Repository: aspnet/AspNetWebStack
Branch: main
Commit: af67fe18a182
Files: 3343
Total size: 17.7 MB

Directory structure:
gitextract_28ij9x6y/

├── .appveyor.yml
├── .azuredevops/
│   └── dependabot.yml
├── .config/
│   ├── CredScanSuppressions.json
│   └── tsaoptions.json
├── .gitattributes
├── .gitignore
├── .nuget/
│   └── packages.config
├── .travis.yml
├── CODE-OF-CONDUCT.md
├── CONTRIBUTING.md
├── Directory.Build.props
├── Directory.Build.targets
├── LICENSE.txt
├── NuGet.Config
├── README.md
├── Runtime.NetFramework.slnf
├── Runtime.NetStandard.slnf
├── Runtime.msbuild
├── Runtime.sln
├── SECURITY.md
├── Settings.StyleCop
├── Tools.sln
├── azure-pipelines-public.yml
├── azure-pipelines.yml
├── build.cmd
├── eng/
│   ├── GetXCopyMSBuild.ps1
│   └── templates/
│       └── default-build.yml
├── es-metadata.yml
├── global.json
├── src/
│   ├── CodeAnalysisDictionary.xml
│   ├── Common/
│   │   ├── AttributeList.cs
│   │   ├── CollectionExtensions.cs
│   │   ├── CommonWebApiResources.Designer.cs
│   │   ├── CommonWebApiResources.resx
│   │   ├── DictionaryExtensions.cs
│   │   ├── EfficientTypePropertyKey.cs
│   │   ├── Empty.cs
│   │   ├── Error.cs
│   │   ├── HashCodeCombiner.cs
│   │   ├── HttpMethodHelper.cs
│   │   ├── ListWrapperCollection.cs
│   │   ├── NonOwnedStream.cs
│   │   ├── PathHelpers.cs
│   │   ├── PrefixContainer.cs
│   │   ├── PropertyHelper.cs
│   │   ├── Routing/
│   │   │   ├── Constraints/
│   │   │   │   ├── AlphaRouteConstraint.cs
│   │   │   │   ├── BoolRouteConstraint.cs
│   │   │   │   ├── CompoundRouteConstraint.cs
│   │   │   │   ├── DateTimeRouteConstraint.cs
│   │   │   │   ├── DecimalRouteConstraint.cs
│   │   │   │   ├── DoubleRouteConstraint.cs
│   │   │   │   ├── FloatRouteConstraint.cs
│   │   │   │   ├── GuidRouteConstraint.cs
│   │   │   │   ├── IntRouteConstraint.cs
│   │   │   │   ├── LengthRouteConstraint.cs
│   │   │   │   ├── LongRouteConstraint.cs
│   │   │   │   ├── MaxLengthRouteConstraint.cs
│   │   │   │   ├── MaxRouteConstraint.cs
│   │   │   │   ├── MinLengthRouteConstraint.cs
│   │   │   │   ├── MinRouteConstraint.cs
│   │   │   │   ├── OptionalRouteConstraint.cs
│   │   │   │   ├── RangeRouteConstraintBase.cs
│   │   │   │   └── RegexRouteConstraint.cs
│   │   │   ├── DefaultInlineConstraintResolver.cs
│   │   │   ├── DirectRouteBuilder.cs
│   │   │   ├── DirectRouteFactoryContext.cs
│   │   │   ├── IDirectRouteBuilder.cs
│   │   │   ├── IDirectRouteFactory.cs
│   │   │   ├── IDirectRouteProvider.cs
│   │   │   ├── IInlineConstraintResolver.cs
│   │   │   ├── IRoutePrefix.cs
│   │   │   ├── InlineRouteTemplateParser.cs
│   │   │   ├── PathContentSegment.cs
│   │   │   ├── PathLiteralSubsegment.cs
│   │   │   ├── PathParameterSubsegment.cs
│   │   │   ├── PathSegment.cs
│   │   │   ├── PathSeparatorSegment.cs
│   │   │   ├── PathSubsegment.cs
│   │   │   ├── RouteEntry.cs
│   │   │   ├── RouteFactoryAttribute.cs
│   │   │   ├── RouteInfoDirectRouteFactory.cs
│   │   │   ├── RouteParser.cs
│   │   │   ├── RoutePrecedence.cs
│   │   │   └── SubRouteCollection.cs
│   │   ├── TaskHelpers.cs
│   │   ├── TaskHelpersExtensions.cs
│   │   ├── TraceWriterExceptionMapper.cs
│   │   └── TypeExtensions.cs
│   ├── CommonAssemblyInfo.cs
│   ├── CommonAssemblyInfo.vb
│   ├── CommonResources.Designer.cs
│   ├── CommonResources.resx
│   ├── Directory.Build.props
│   ├── GlobalSuppressions.cs
│   ├── Microsoft.AspNet.Facebook/
│   │   ├── Authorization/
│   │   │   └── FacebookAuthorizeFilter.cs
│   │   ├── Client/
│   │   │   ├── FacebookClientExtensions.cs
│   │   │   ├── FacebookQueryHelper.cs
│   │   │   └── FacebookRequestHelper.cs
│   │   ├── FacebookAppSettingKeys.cs
│   │   ├── FacebookAuthenticationModule.cs
│   │   ├── FacebookAuthorizeAttribute.cs
│   │   ├── FacebookConfiguration.cs
│   │   ├── FacebookConnection.cs
│   │   ├── FacebookContext.cs
│   │   ├── FacebookFieldModifierAttribute.cs
│   │   ├── FacebookGroupConnection.cs
│   │   ├── FacebookHtmlHelperExtensions.cs
│   │   ├── FacebookRedirectContext.cs
│   │   ├── GlobalFacebookConfiguration.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── JavaScriptRedirectResult.cs
│   │   ├── Microsoft.AspNet.Facebook.csproj
│   │   ├── ModelBinders/
│   │   │   ├── FacebookContextBinderAttribute.cs
│   │   │   ├── FacebookContextModelBinder.cs
│   │   │   ├── FacebookRedirectContextBinderAttribute.cs
│   │   │   └── FacebookRedirectContextModelBinder.cs
│   │   ├── Models/
│   │   │   ├── ChangeEntry.cs
│   │   │   ├── ChangeNotification.cs
│   │   │   └── SubscriptionVerification.cs
│   │   ├── PermissionContext.cs
│   │   ├── PermissionHelper.cs
│   │   ├── PermissionStatus.cs
│   │   ├── PermissionsStatus.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── Providers/
│   │   │   ├── DefaultFacebookClientProvider.cs
│   │   │   ├── DefaultFacebookPermissionService.cs
│   │   │   ├── IFacebookClientProvider.cs
│   │   │   └── IFacebookPermissionService.cs
│   │   ├── Realtime/
│   │   │   └── FacebookRealtimeUpdateController.cs
│   │   ├── Resources.Designer.cs
│   │   ├── Resources.resx
│   │   ├── ShowPromptResult.cs
│   │   └── packages.config
│   ├── Microsoft.Web.Helpers/
│   │   ├── Analytics.cshtml
│   │   ├── Facebook.cshtml
│   │   ├── FileUpload.cshtml
│   │   ├── GamerCard.cshtml
│   │   ├── GlobalSuppressions.cs
│   │   ├── Gravatar.cs
│   │   ├── GravatarRating.cs
│   │   ├── LinkShare.cshtml
│   │   ├── LinkShareSite.cs
│   │   ├── Maps.cshtml
│   │   ├── Microsoft.Web.Helpers.csproj
│   │   ├── PreApplicationStartCode.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── ReCaptcha.cshtml
│   │   ├── Resources/
│   │   │   ├── HelpersToolkitResources.Designer.cs
│   │   │   └── HelpersToolkitResources.resx
│   │   ├── Themes.cs
│   │   ├── ThemesImplementation.cs
│   │   ├── UrlBuilder.cs
│   │   ├── Video.cs
│   │   ├── VirtualPathUtilityBase.cs
│   │   ├── VirtualPathUtilityWrapper.cs
│   │   └── packages.config
│   ├── Microsoft.Web.Mvc/
│   │   ├── AcceptAttribute.cs
│   │   ├── ActionLinkAreaAttribute.cs
│   │   ├── AjaxOnlyAttribute.cs
│   │   ├── AreaHelpers.cs
│   │   ├── AsyncManagerExtensions.cs
│   │   ├── ButtonBuilder.cs
│   │   ├── ButtonsAndLinkExtensions.cs
│   │   ├── CachedExpressionCompiler.cs
│   │   ├── ContentTypeAttribute.cs
│   │   ├── ControllerExtensions.cs
│   │   ├── Controls/
│   │   │   ├── ActionLink.cs
│   │   │   ├── DropDownList.cs
│   │   │   ├── EncodeType.cs
│   │   │   ├── Hidden.cs
│   │   │   ├── Label.cs
│   │   │   ├── MvcControl.cs
│   │   │   ├── MvcInputControl.cs
│   │   │   ├── Password.cs
│   │   │   ├── Repeater.cs
│   │   │   ├── RepeaterItem.cs
│   │   │   ├── RouteValues.cs
│   │   │   └── TextBox.cs
│   │   ├── CookieValueProviderFactory.cs
│   │   ├── CopyAsyncParametersAttribute.cs
│   │   ├── CreditCardAttribute.cs
│   │   ├── CssExtensions.cs
│   │   ├── DeserializeAttribute.cs
│   │   ├── DynamicReflectionObject.cs
│   │   ├── DynamicViewDataDictionary.cs
│   │   ├── DynamicViewPage.cs
│   │   ├── DynamicViewPageOfTModel.cs
│   │   ├── ElementalValueProvider.cs
│   │   ├── EmailAddressAttribute.cs
│   │   ├── Error.cs
│   │   ├── ExpressionUtil/
│   │   │   ├── BinaryExpressionFingerprint.cs
│   │   │   ├── CachedExpressionCompiler.cs
│   │   │   ├── ConditionalExpressionFingerprint.cs
│   │   │   ├── ConstantExpressionFingerprint.cs
│   │   │   ├── DefaultExpressionFingerprint.cs
│   │   │   ├── ExpressionFingerprint.cs
│   │   │   ├── ExpressionFingerprintChain.cs
│   │   │   ├── FingerprintingExpressionVisitor.cs
│   │   │   ├── HashCodeCombiner.cs
│   │   │   ├── Hoisted.cs
│   │   │   ├── HoistingExpressionVisitor.cs
│   │   │   ├── IndexExpressionFingerprint.cs
│   │   │   ├── LambdaExpressionFingerprint.cs
│   │   │   ├── MemberExpressionFingerprint.cs
│   │   │   ├── MethodCallExpressionFingerprint.cs
│   │   │   ├── ParameterExpressionFingerprint.cs
│   │   │   ├── TypeBinaryExpressionFingerprint.cs
│   │   │   └── UnaryExpressionFingerprint.cs
│   │   ├── FileExtensionsAttribute.cs
│   │   ├── FormExtensions.cs
│   │   ├── FuturesFiles/
│   │   │   ├── DefaultTemplates/
│   │   │   │   ├── DisplayTemplates/
│   │   │   │   │   ├── Boolean.ascx
│   │   │   │   │   ├── Collection.ascx
│   │   │   │   │   ├── Decimal.ascx
│   │   │   │   │   ├── EmailAddress.ascx
│   │   │   │   │   ├── HiddenInput.ascx
│   │   │   │   │   ├── Html.ascx
│   │   │   │   │   ├── Object.ascx
│   │   │   │   │   ├── String.ascx
│   │   │   │   │   └── Url.ascx
│   │   │   │   └── EditorTemplates/
│   │   │   │       ├── Boolean.ascx
│   │   │   │       ├── Collection.ascx
│   │   │   │       ├── Decimal.ascx
│   │   │   │       ├── HiddenInput.ascx
│   │   │   │       ├── MultilineText.ascx
│   │   │   │       ├── Object.ascx
│   │   │   │       ├── Password.ascx
│   │   │   │       └── String.ascx
│   │   │   ├── iismap.vbs
│   │   │   ├── registermvc.wsf
│   │   │   └── unregistermvc.wsf
│   │   ├── GlobalSuppressions.cs
│   │   ├── Html/
│   │   │   └── HtmlHelperExtensions.cs
│   │   ├── HtmlButtonType.cs
│   │   ├── IMachineKey.cs
│   │   ├── ImageExtensions.cs
│   │   ├── Internal/
│   │   │   └── ExpressionHelper.cs
│   │   ├── LinkBuilder.cs
│   │   ├── LinkExtensions.cs
│   │   ├── MachineKeyWrapper.cs
│   │   ├── MailToExtensions.cs
│   │   ├── Microsoft.Web.Mvc.csproj
│   │   ├── ModelBinding/
│   │   │   ├── ArrayModelBinder.cs
│   │   │   ├── ArrayModelBinderProvider.cs
│   │   │   ├── BinaryDataModelBinderProvider.cs
│   │   │   ├── BindNeverAttribute.cs
│   │   │   ├── BindRequiredAttribute.cs
│   │   │   ├── BindingBehavior.cs
│   │   │   ├── BindingBehaviorAttribute.cs
│   │   │   ├── CollectionModelBinder.cs
│   │   │   ├── CollectionModelBinderProvider.cs
│   │   │   ├── CollectionModelBinderUtil.cs
│   │   │   ├── ComplexModelDto.cs
│   │   │   ├── ComplexModelDtoModelBinder.cs
│   │   │   ├── ComplexModelDtoModelBinderProvider.cs
│   │   │   ├── ComplexModelDtoResult.cs
│   │   │   ├── DictionaryModelBinder.cs
│   │   │   ├── DictionaryModelBinderProvider.cs
│   │   │   ├── ExtensibleModelBinderAdapter.cs
│   │   │   ├── ExtensibleModelBinderAttribute.cs
│   │   │   ├── ExtensibleModelBindingContext.cs
│   │   │   ├── GenericModelBinderProvider.cs
│   │   │   ├── IExtensibleModelBinder.cs
│   │   │   ├── KeyValuePairModelBinder.cs
│   │   │   ├── KeyValuePairModelBinderProvider.cs
│   │   │   ├── KeyValuePairModelBinderUtil.cs
│   │   │   ├── ModelBinderConfig.cs
│   │   │   ├── ModelBinderErrorMessageProvider.cs
│   │   │   ├── ModelBinderProvider.cs
│   │   │   ├── ModelBinderProviderCollection.cs
│   │   │   ├── ModelBinderProviderOptionsAttribute.cs
│   │   │   ├── ModelBinderProviders.cs
│   │   │   ├── ModelBinderUtil.cs
│   │   │   ├── ModelValidatedEventArgs.cs
│   │   │   ├── ModelValidatingEventArgs.cs
│   │   │   ├── ModelValidationNode.cs
│   │   │   ├── MutableObjectModelBinder.cs
│   │   │   ├── MutableObjectModelBinderProvider.cs
│   │   │   ├── SimpleModelBinderProvider.cs
│   │   │   ├── TypeConverterModelBinder.cs
│   │   │   ├── TypeConverterModelBinderProvider.cs
│   │   │   ├── TypeMatchModelBinder.cs
│   │   │   └── TypeMatchModelBinderProvider.cs
│   │   ├── ModelCopier.cs
│   │   ├── MvcSerializer.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── MvcResources.Designer.cs
│   │   │   └── MvcResources.resx
│   │   ├── RadioExtensions.cs
│   │   ├── ReaderWriterCache.cs
│   │   ├── Resources/
│   │   │   ├── ActionType.cs
│   │   │   ├── AjaxHelperExtensions.cs
│   │   │   ├── AtomEntryActionResult.cs
│   │   │   ├── AtomFeedActionResult.cs
│   │   │   ├── AtomServiceDocumentActionResult.cs
│   │   │   ├── DataContractJsonActionResult.cs
│   │   │   ├── DataContractXmlActionResult.cs
│   │   │   ├── DefaultFormatHelper.cs
│   │   │   ├── DefaultFormatManager.cs
│   │   │   ├── FormatHelper.cs
│   │   │   ├── FormatManager.cs
│   │   │   ├── HtmlHelperExtensions.cs
│   │   │   ├── HttpRequestBaseExtensions.cs
│   │   │   ├── IEnumerableExtensions.cs
│   │   │   ├── IRequestFormatHandler.cs
│   │   │   ├── IResponseFormatHandler.cs
│   │   │   ├── JsonFormatHandler.cs
│   │   │   ├── MultiFormatActionResult.cs
│   │   │   ├── RequestContextExtensions.cs
│   │   │   ├── ResourceControllerFactory.cs
│   │   │   ├── ResourceErrorActionResult.cs
│   │   │   ├── ResourceModelBinder.cs
│   │   │   ├── ResourceRedirectToRouteResult.cs
│   │   │   ├── RouteCollectionExtensions.cs
│   │   │   ├── UriHelperExtensions.cs
│   │   │   ├── WebApiEnabledAttribute.cs
│   │   │   └── XmlFormatHandler.cs
│   │   ├── ScriptExtensions.cs
│   │   ├── SerializationExtensions.cs
│   │   ├── ServerVariablesValueProviderFactory.cs
│   │   ├── SessionValueProviderFactory.cs
│   │   ├── SkipBindingAttribute.cs
│   │   ├── TempDataValueProviderFactory.cs
│   │   ├── TypeDescriptorHelper.cs
│   │   ├── TypeHelpers.cs
│   │   ├── UrlAttribute.cs
│   │   ├── ValueProviderUtil.cs
│   │   └── ViewExtensions.cs
│   ├── Microsoft.Web.WebPages.OAuth/
│   │   ├── AuthenticationClientData.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── Microsoft.Web.WebPages.OAuth.csproj
│   │   ├── OAuthAccount.cs
│   │   ├── OAuthWebSecurity.cs
│   │   ├── PreApplicationStartCode.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── WebResources.Designer.cs
│   │   │   └── WebResources.resx
│   │   ├── ProviderUserIdSerializationHelper.cs
│   │   ├── Resources/
│   │   │   ├── OAuthResources.Designer.cs
│   │   │   └── OAuthResources.resx
│   │   ├── WebPagesOAuthDataProvider.cs
│   │   ├── WebPagesOAuthTokenManager.cs
│   │   └── packages.config
│   ├── Settings.StyleCop
│   ├── Strict.ruleset
│   ├── System.Net.Http.Formatting/
│   │   ├── ByteRangeStreamContent.cs
│   │   ├── CloneableExtensions.cs
│   │   ├── Formatting/
│   │   │   ├── BaseJsonMediaTypeFormatter.cs
│   │   │   ├── BsonMediaTypeFormatter.cs
│   │   │   ├── BufferedMediaTypeFormatter.cs
│   │   │   ├── ContentNegotiationResult.cs
│   │   │   ├── DefaultContentNegotiator.cs
│   │   │   ├── DelegatingEnumerable.cs
│   │   │   ├── FormDataCollection.cs
│   │   │   ├── FormUrlEncodedJson.cs
│   │   │   ├── FormUrlEncodedMediaTypeFormatter.cs
│   │   │   ├── IContentNegotiator.cs
│   │   │   ├── IFormatterLogger.cs
│   │   │   ├── IRequiredMemberSelector.cs
│   │   │   ├── JsonContractResolver.cs
│   │   │   ├── JsonMediaTypeFormatter.cs
│   │   │   ├── MediaTypeConstants.cs
│   │   │   ├── MediaTypeFormatter.cs
│   │   │   ├── MediaTypeFormatterCollection.cs
│   │   │   ├── MediaTypeFormatterExtensions.cs
│   │   │   ├── MediaTypeFormatterMatch.cs
│   │   │   ├── MediaTypeFormatterMatchRanking.cs
│   │   │   ├── MediaTypeHeaderValueExtensions.cs
│   │   │   ├── MediaTypeHeaderValueRange.cs
│   │   │   ├── MediaTypeMapping.cs
│   │   │   ├── MediaTypeWithQualityHeaderValueComparer.cs
│   │   │   ├── ParsedMediaTypeHeaderValue.cs
│   │   │   ├── Parsers/
│   │   │   │   ├── FormUrlEncodedParser.cs
│   │   │   │   ├── HttpRequestHeaderParser.cs
│   │   │   │   ├── HttpRequestLineParser.cs
│   │   │   │   ├── HttpResponseHeaderParser.cs
│   │   │   │   ├── HttpStatusLineParser.cs
│   │   │   │   ├── InternetMessageFormatHeaderParser.cs
│   │   │   │   ├── MimeMultipartBodyPartParser.cs
│   │   │   │   ├── MimeMultipartParser.cs
│   │   │   │   └── ParserState.cs
│   │   │   ├── QueryStringMapping.cs
│   │   │   ├── RequestHeaderMapping.cs
│   │   │   ├── StringComparisonHelper.cs
│   │   │   ├── StringWithQualityHeaderValueComparer.cs
│   │   │   ├── XmlHttpRequestHeaderMapping.cs
│   │   │   └── XmlMediaTypeFormatter.cs
│   │   ├── FormattingUtilities.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── Handlers/
│   │   │   ├── HttpProgressEventArgs.cs
│   │   │   ├── ProgressContent.cs
│   │   │   ├── ProgressMessageHandler.cs
│   │   │   ├── ProgressStream.cs
│   │   │   └── ProgressWriteAsyncResult.cs
│   │   ├── Headers/
│   │   │   ├── CookieHeaderValue.cs
│   │   │   └── CookieState.cs
│   │   ├── HttpClientExtensions.cs
│   │   ├── HttpClientFactory.cs
│   │   ├── HttpContentExtensions.cs
│   │   ├── HttpContentFormDataExtensions.cs
│   │   ├── HttpContentMessageExtensions.cs
│   │   ├── HttpContentMultipartExtensions.cs
│   │   ├── HttpHeaderExtensions.cs
│   │   ├── HttpMessageContent.cs
│   │   ├── HttpRequestHeadersExtensions.cs
│   │   ├── HttpRequestMessageExtensions.cs
│   │   ├── HttpResponseHeadersExtensions.cs
│   │   ├── HttpUnsortedHeaders.cs
│   │   ├── HttpUnsortedRequest.cs
│   │   ├── HttpUnsortedResponse.cs
│   │   ├── Internal/
│   │   │   ├── AsyncResult.cs
│   │   │   ├── ByteRangeStream.cs
│   │   │   ├── DelegatingStream.cs
│   │   │   ├── HttpValueCollection.cs
│   │   │   ├── NonClosingDelegatingStream.cs
│   │   │   ├── NullableAttributes.cs
│   │   │   ├── TranscodingStream.cs
│   │   │   └── TypeExtensions.cs
│   │   ├── InvalidByteRangeException.cs
│   │   ├── MimeBodyPart.cs
│   │   ├── MultipartFileData.cs
│   │   ├── MultipartFileStreamProvider.cs
│   │   ├── MultipartFormDataRemoteStreamProvider.cs
│   │   ├── MultipartFormDataStreamProvider.cs
│   │   ├── MultipartFormDataStreamProviderHelper.cs
│   │   ├── MultipartMemoryStreamProvider.cs
│   │   ├── MultipartRelatedStreamProvider.cs
│   │   ├── MultipartRemoteFileData.cs
│   │   ├── MultipartStreamProvider.cs
│   │   ├── ObjectContent.cs
│   │   ├── ObjectContentOfT.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── Resources.Designer.cs
│   │   │   └── Resources.resx
│   │   ├── PushStreamContent.cs
│   │   ├── RemoteStreamInfo.cs
│   │   ├── System.Net.Http.Formatting.csproj
│   │   ├── UnsupportedMediaTypeException.cs
│   │   ├── UriExtensions.cs
│   │   └── packages.config
│   ├── System.Net.Http.Formatting.ns1_3/
│   │   ├── ICloneable.cs
│   │   ├── MediaTypeHeaderValueExtensions.cs
│   │   └── System.Net.Http.Formatting.ns1_3.csproj
│   ├── System.Net.Http.Formatting.ns2_0/
│   │   └── System.Net.Http.Formatting.ns2_0.csproj
│   ├── System.Web.Cors/
│   │   ├── CorsConstants.cs
│   │   ├── CorsEngine.cs
│   │   ├── CorsPolicy.cs
│   │   ├── CorsRequestContext.cs
│   │   ├── CorsResult.cs
│   │   ├── ICorsEngine.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── SRResources.Designer.cs
│   │   │   └── SRResources.resx
│   │   └── System.Web.Cors.csproj
│   ├── System.Web.Helpers/
│   │   ├── Chart/
│   │   │   ├── Chart.cs
│   │   │   └── ChartTheme.cs
│   │   ├── Common/
│   │   │   └── VirtualPathUtil.cs
│   │   ├── ConversionUtil.cs
│   │   ├── Crypto.cs
│   │   ├── DynamicHelper.cs
│   │   ├── DynamicJavaScriptConverter.cs
│   │   ├── DynamicJsonArray.cs
│   │   ├── DynamicJsonObject.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── HtmlElement.cs
│   │   ├── HtmlObjectPrinter.cs
│   │   ├── Json.cs
│   │   ├── ObjectInfo.cs
│   │   ├── ObjectVisitor.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── Resources/
│   │   │   ├── ChartTemplates.Designer.cs
│   │   │   ├── ChartTemplates.resx
│   │   │   ├── HelpersResources.Designer.cs
│   │   │   └── HelpersResources.resx
│   │   ├── ServerInfo.cs
│   │   ├── SortDirection.cs
│   │   ├── System.Web.Helpers.csproj
│   │   ├── WebCache.cs
│   │   ├── WebGrid/
│   │   │   ├── IWebGridDataSource.cs
│   │   │   ├── PreComputedGridDataSource.cs
│   │   │   ├── SortInfo.cs
│   │   │   ├── WebGrid.cs
│   │   │   ├── WebGridColumn.cs
│   │   │   ├── WebGridDataSource.cs
│   │   │   ├── WebGridPagerModes.cs
│   │   │   ├── WebGridRow.cs
│   │   │   ├── _WebGridRenderer.cshtml
│   │   │   └── _WebGridRenderer.generated.cs
│   │   ├── WebImage.cs
│   │   └── WebMail.cs
│   ├── System.Web.Http/
│   │   ├── AcceptVerbsAttribute.cs
│   │   ├── ActionNameAttribute.cs
│   │   ├── AllowAnonymousAttribute.cs
│   │   ├── ApiController.cs
│   │   ├── AuthorizeAttribute.cs
│   │   ├── Batch/
│   │   │   ├── BatchExecutionOrder.cs
│   │   │   ├── BatchHttpRequestContext.cs
│   │   │   ├── BatchHttpRequestMessageExtensions.cs
│   │   │   ├── DefaultHttpBatchHandler.cs
│   │   │   └── HttpBatchHandler.cs
│   │   ├── Controllers/
│   │   │   ├── ActionFilterResult.cs
│   │   │   ├── ApiControllerActionInvoker.cs
│   │   │   ├── ApiControllerActionSelector.cs
│   │   │   ├── AuthenticationFilterResult.cs
│   │   │   ├── AuthorizationFilterResult.cs
│   │   │   ├── CandidateAction.cs
│   │   │   ├── ExceptionFilterResult.cs
│   │   │   ├── FilterGrouping.cs
│   │   │   ├── HttpActionBinding.cs
│   │   │   ├── HttpActionContext.cs
│   │   │   ├── HttpActionContextExtensions.cs
│   │   │   ├── HttpActionDescriptor.cs
│   │   │   ├── HttpActionDescriptorExtensions.cs
│   │   │   ├── HttpControllerContext.cs
│   │   │   ├── HttpControllerDescriptor.cs
│   │   │   ├── HttpControllerDescriptorExtensions.cs
│   │   │   ├── HttpControllerSettings.cs
│   │   │   ├── HttpParameterBinding.cs
│   │   │   ├── HttpParameterDescriptor.cs
│   │   │   ├── HttpParameterDescriptorExtensions.cs
│   │   │   ├── HttpRequestContext.cs
│   │   │   ├── IActionHttpMethodProvider.cs
│   │   │   ├── IActionResultConverter.cs
│   │   │   ├── IActionValueBinder.cs
│   │   │   ├── IControllerConfiguration.cs
│   │   │   ├── IHttpActionInvoker.cs
│   │   │   ├── IHttpActionSelector.cs
│   │   │   ├── IHttpController.cs
│   │   │   ├── ReflectedHttpActionDescriptor.cs
│   │   │   ├── ReflectedHttpParameterDescriptor.cs
│   │   │   ├── RequestBackedHttpRequestContext.cs
│   │   │   ├── ResponseMessageResultConverter.cs
│   │   │   ├── ValueResultConverter.cs
│   │   │   └── VoidResultConverter.cs
│   │   ├── Dependencies/
│   │   │   ├── EmptyResolver.cs
│   │   │   ├── IDependencyResolver.cs
│   │   │   └── IDependencyScope.cs
│   │   ├── Description/
│   │   │   ├── ApiDescription.cs
│   │   │   ├── ApiExplorer.cs
│   │   │   ├── ApiExplorerSettingsAttribute.cs
│   │   │   ├── ApiParameterDescription.cs
│   │   │   ├── ApiParameterSource.cs
│   │   │   ├── IApiExplorer.cs
│   │   │   ├── IDocumentationProvider.cs
│   │   │   ├── ResponseDescription.cs
│   │   │   └── ResponseTypeAttribute.cs
│   │   ├── Dispatcher/
│   │   │   ├── DefaultAssembliesResolver.cs
│   │   │   ├── DefaultHttpControllerActivator.cs
│   │   │   ├── DefaultHttpControllerSelector.cs
│   │   │   ├── DefaultHttpControllerTypeResolver.cs
│   │   │   ├── HttpControllerDispatcher.cs
│   │   │   ├── HttpControllerTypeCache.cs
│   │   │   ├── HttpRoutingDispatcher.cs
│   │   │   ├── IAssembliesResolver.cs
│   │   │   ├── IHttpControllerActivator.cs
│   │   │   ├── IHttpControllerSelector.cs
│   │   │   └── IHttpControllerTypeResolver.cs
│   │   ├── EmptyReadOnlyDictionary.cs
│   │   ├── ExceptionHandling/
│   │   │   ├── CompositeExceptionLogger.cs
│   │   │   ├── DefaultExceptionHandler.cs
│   │   │   ├── EmptyExceptionHandler.cs
│   │   │   ├── ExceptionCatchBlocks.cs
│   │   │   ├── ExceptionContext.cs
│   │   │   ├── ExceptionContextCatchBlock.cs
│   │   │   ├── ExceptionHandler.cs
│   │   │   ├── ExceptionHandlerContext.cs
│   │   │   ├── ExceptionHandlerExtensions.cs
│   │   │   ├── ExceptionLogger.cs
│   │   │   ├── ExceptionLoggerContext.cs
│   │   │   ├── ExceptionLoggerExtensions.cs
│   │   │   ├── ExceptionServices.cs
│   │   │   ├── IExceptionHandler.cs
│   │   │   ├── IExceptionLogger.cs
│   │   │   └── LastChanceExceptionHandler.cs
│   │   ├── Filters/
│   │   │   ├── ActionDescriptorFilterProvider.cs
│   │   │   ├── ActionFilterAttribute.cs
│   │   │   ├── AuthorizationFilterAttribute.cs
│   │   │   ├── ConfigurationFilterProvider.cs
│   │   │   ├── ExceptionFilterAttribute.cs
│   │   │   ├── FilterAttribute.cs
│   │   │   ├── FilterInfo.cs
│   │   │   ├── FilterInfoComparer.cs
│   │   │   ├── FilterScope.cs
│   │   │   ├── HttpActionExecutedContext.cs
│   │   │   ├── HttpAuthenticationChallengeContext.cs
│   │   │   ├── HttpAuthenticationContext.cs
│   │   │   ├── HttpFilterCollection.cs
│   │   │   ├── IActionFilter.cs
│   │   │   ├── IAuthenticationFilter.cs
│   │   │   ├── IAuthorizationFilter.cs
│   │   │   ├── IExceptionFilter.cs
│   │   │   ├── IFilter.cs
│   │   │   ├── IFilterProvider.cs
│   │   │   └── IOverrideFilter.cs
│   │   ├── FromBodyAttribute.cs
│   │   ├── FromUriAttribute.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── Hosting/
│   │   │   ├── HttpPropertyKeys.cs
│   │   │   ├── IHostBufferPolicySelector.cs
│   │   │   └── SuppressHostPrincipalMessageHandler.cs
│   │   ├── HttpBindNeverAttribute.cs
│   │   ├── HttpBindRequiredAttribute.cs
│   │   ├── HttpConfiguration.cs
│   │   ├── HttpConfigurationExtensions.cs
│   │   ├── HttpDeleteAttribute.cs
│   │   ├── HttpError.cs
│   │   ├── HttpErrorKeys.cs
│   │   ├── HttpGetAttribute.cs
│   │   ├── HttpHeadAttribute.cs
│   │   ├── HttpOptionsAttribute.cs
│   │   ├── HttpPatchAttribute.cs
│   │   ├── HttpPostAttribute.cs
│   │   ├── HttpPutAttribute.cs
│   │   ├── HttpRequestMessageExtensions.cs
│   │   ├── HttpResponseException.cs
│   │   ├── HttpResponseMessageExtensions.cs
│   │   ├── HttpRouteCollection.cs
│   │   ├── HttpRouteCollectionExtensions.cs
│   │   ├── HttpServer.cs
│   │   ├── IHttpActionResult.cs
│   │   ├── IncludeErrorDetailPolicy.cs
│   │   ├── Internal/
│   │   │   ├── CollectionModelBinderUtil.cs
│   │   │   ├── HttpParameterBindingExtensions.cs
│   │   │   ├── MemberInfoExtensions.cs
│   │   │   ├── ParameterInfoExtensions.cs
│   │   │   ├── TypeActivator.cs
│   │   │   ├── TypeDescriptorHelper.cs
│   │   │   └── TypeHelper.cs
│   │   ├── Metadata/
│   │   │   ├── ModelMetadata.cs
│   │   │   ├── ModelMetadataProvider.cs
│   │   │   └── Providers/
│   │   │       ├── AssociatedMetadataProvider.cs
│   │   │       ├── CachedDataAnnotationsMetadataAttributes.cs
│   │   │       ├── CachedDataAnnotationsModelMetadata.cs
│   │   │       ├── CachedModelMetadata.cs
│   │   │       ├── DataAnnotationsModelMetadataProvider.cs
│   │   │       └── EmptyMetadataProvider.cs
│   │   ├── ModelBinding/
│   │   │   ├── Binders/
│   │   │   │   ├── ArrayModelBinder.cs
│   │   │   │   ├── ArrayModelBinderProvider.cs
│   │   │   │   ├── CollectionModelBinder.cs
│   │   │   │   ├── CollectionModelBinderProvider.cs
│   │   │   │   ├── ComplexModelDto.cs
│   │   │   │   ├── ComplexModelDtoModelBinder.cs
│   │   │   │   ├── ComplexModelDtoModelBinderProvider.cs
│   │   │   │   ├── ComplexModelDtoResult.cs
│   │   │   │   ├── CompositeModelBinder.cs
│   │   │   │   ├── CompositeModelBinderProvider.cs
│   │   │   │   ├── DictionaryModelBinder.cs
│   │   │   │   ├── DictionaryModelBinderProvider.cs
│   │   │   │   ├── KeyValuePairModelBinder.cs
│   │   │   │   ├── KeyValuePairModelBinderProvider.cs
│   │   │   │   ├── MutableObjectModelBinder.cs
│   │   │   │   ├── MutableObjectModelBinderProvider.cs
│   │   │   │   ├── SimpleModelBinderProvider.cs
│   │   │   │   ├── TypeConverterModelBinder.cs
│   │   │   │   ├── TypeConverterModelBinderProvider.cs
│   │   │   │   ├── TypeMatchModelBinder.cs
│   │   │   │   └── TypeMatchModelBinderProvider.cs
│   │   │   ├── CancellationTokenParameterBinding.cs
│   │   │   ├── CustomModelBinderAttribute.cs
│   │   │   ├── DefaultActionValueBinder.cs
│   │   │   ├── ErrorParameterBinding.cs
│   │   │   ├── FormDataCollectionExtensions.cs
│   │   │   ├── FormatterParameterBinding.cs
│   │   │   ├── HttpBindingBehavior.cs
│   │   │   ├── HttpBindingBehaviorAttribute.cs
│   │   │   ├── HttpRequestParameterBinding.cs
│   │   │   ├── IModelBinder.cs
│   │   │   ├── IValueProviderParameterBinding.cs
│   │   │   ├── JQueryMVCFormUrlEncodedFormatter.cs
│   │   │   ├── ModelBinderAttribute.cs
│   │   │   ├── ModelBinderConfig.cs
│   │   │   ├── ModelBinderErrorMessageProvider.cs
│   │   │   ├── ModelBinderParameterBinding.cs
│   │   │   ├── ModelBinderProvider.cs
│   │   │   ├── ModelBindingContext.cs
│   │   │   ├── ModelBindingHelper.cs
│   │   │   ├── ModelError.cs
│   │   │   ├── ModelErrorCollection.cs
│   │   │   ├── ModelState.cs
│   │   │   ├── ModelStateDictionary.cs
│   │   │   └── ParameterBindingRulesCollection.cs
│   │   ├── NonActionAttribute.cs
│   │   ├── OverrideActionFiltersAttribute.cs
│   │   ├── OverrideAuthenticationAttribute.cs
│   │   ├── OverrideAuthorizationAttribute.cs
│   │   ├── OverrideExceptionFiltersAttribute.cs
│   │   ├── ParameterBindingAttribute.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── SRResources.Designer.cs
│   │   │   └── SRResources.resx
│   │   ├── Results/
│   │   │   ├── BadRequestErrorMessageResult.cs
│   │   │   ├── BadRequestResult.cs
│   │   │   ├── ConflictResult.cs
│   │   │   ├── CreatedAtRouteNegotiatedContentResult.cs
│   │   │   ├── CreatedNegotiatedContentResult.cs
│   │   │   ├── ExceptionResult.cs
│   │   │   ├── FormattedContentResult.cs
│   │   │   ├── InternalServerErrorResult.cs
│   │   │   ├── InvalidModelStateResult.cs
│   │   │   ├── JsonResult.cs
│   │   │   ├── NegotiatedContentResult.cs
│   │   │   ├── NotFoundResult.cs
│   │   │   ├── OkNegotiatedContentResult.cs
│   │   │   ├── OkResult.cs
│   │   │   ├── RedirectResult.cs
│   │   │   ├── RedirectToRouteResult.cs
│   │   │   ├── ResponseMessageResult.cs
│   │   │   ├── StatusCodeResult.cs
│   │   │   └── UnauthorizedResult.cs
│   │   ├── RouteAttribute.cs
│   │   ├── RouteParameter.cs
│   │   ├── RoutePrefixAttribute.cs
│   │   ├── Routing/
│   │   │   ├── AttributeRoutingMapper.cs
│   │   │   ├── BoundRouteTemplate.cs
│   │   │   ├── DefaultDirectRouteProvider.cs
│   │   │   ├── HttpMethodConstraint.cs
│   │   │   ├── HttpParsedRoute.cs
│   │   │   ├── HttpRoute.cs
│   │   │   ├── HttpRouteData.cs
│   │   │   ├── HttpRouteDataExtensions.cs
│   │   │   ├── HttpRouteDirection.cs
│   │   │   ├── HttpRouteExtensions.cs
│   │   │   ├── HttpRouteValueDictionary.cs
│   │   │   ├── HttpVirtualPathData.cs
│   │   │   ├── IHttpRoute.cs
│   │   │   ├── IHttpRouteConstraint.cs
│   │   │   ├── IHttpRouteData.cs
│   │   │   ├── IHttpRouteInfoProvider.cs
│   │   │   ├── IHttpVirtualPathData.cs
│   │   │   ├── LinkGenerationRoute.cs
│   │   │   ├── MediaTypeFormatterExtensions.cs
│   │   │   ├── RouteCollectionRoute.cs
│   │   │   ├── RouteDataTokenKeys.cs
│   │   │   ├── RouteValueKeys.cs
│   │   │   ├── RoutingContext.cs
│   │   │   ├── StopRoutingHandler.cs
│   │   │   ├── UriPathExtensionMapping.cs
│   │   │   └── UrlHelper.cs
│   │   ├── Services/
│   │   │   ├── ControllerServices.cs
│   │   │   ├── Decorator.cs
│   │   │   ├── DefaultServices.cs
│   │   │   ├── IDecorator.cs
│   │   │   └── ServicesContainer.cs
│   │   ├── ServicesExtensions.cs
│   │   ├── SingleResult.cs
│   │   ├── SingleResultOfT.cs
│   │   ├── System.Web.Http.csproj
│   │   ├── Tracing/
│   │   │   ├── FormattingUtilities.cs
│   │   │   ├── IFormatterTracer.cs
│   │   │   ├── ITraceManager.cs
│   │   │   ├── ITraceWriter.cs
│   │   │   ├── ITraceWriterExtensions.cs
│   │   │   ├── TraceCategories.cs
│   │   │   ├── TraceKind.cs
│   │   │   ├── TraceKindHelper.cs
│   │   │   ├── TraceLevel.cs
│   │   │   ├── TraceLevelHelper.cs
│   │   │   ├── TraceManager.cs
│   │   │   ├── TraceRecord.cs
│   │   │   └── Tracers/
│   │   │       ├── ActionFilterAttributeTracer.cs
│   │   │       ├── ActionFilterTracer.cs
│   │   │       ├── ActionValueBinderTracer.cs
│   │   │       ├── AuthenticationFilterTracer.cs
│   │   │       ├── AuthorizationFilterAttributeTracer.cs
│   │   │       ├── AuthorizationFilterTracer.cs
│   │   │       ├── BufferedMediaTypeFormatterTracer.cs
│   │   │       ├── ContentNegotiatorTracer.cs
│   │   │       ├── DefaultHttpControllerTypeResolverTracer.cs
│   │   │       ├── ExceptionFilterAttributeTracer.cs
│   │   │       ├── ExceptionFilterTracer.cs
│   │   │       ├── FilterTracer.cs
│   │   │       ├── FormUrlEncodedMediaTypeFormatterTracer.cs
│   │   │       ├── FormatterLoggerTraceWrapper.cs
│   │   │       ├── FormatterParameterBindingTracer.cs
│   │   │       ├── HttpActionBindingTracer.cs
│   │   │       ├── HttpActionDescriptorTracer.cs
│   │   │       ├── HttpActionInvokerTracer.cs
│   │   │       ├── HttpActionSelectorTracer.cs
│   │   │       ├── HttpControllerActivatorTracer.cs
│   │   │       ├── HttpControllerDescriptorTracer.cs
│   │   │       ├── HttpControllerSelectorTracer.cs
│   │   │       ├── HttpControllerTracer.cs
│   │   │       ├── HttpParameterBindingTracer.cs
│   │   │       ├── JsonMediaTypeFormatterTracer.cs
│   │   │       ├── MediaTypeFormatterTracer.cs
│   │   │       ├── MessageHandlerTracer.cs
│   │   │       ├── OverrideFilterTracer.cs
│   │   │       ├── RequestMessageHandlerTracer.cs
│   │   │       └── XmlMediaTypeFormatterTracer.cs
│   │   ├── Validation/
│   │   │   ├── BodyModelValidatorContext.cs
│   │   │   ├── DefaultBodyModelValidator.cs
│   │   │   ├── IBodyModelValidator.cs
│   │   │   ├── IBodyModelValidatorKeyBuilder.cs
│   │   │   ├── IModelValidatorCache.cs
│   │   │   ├── ModelStateFormatterLogger.cs
│   │   │   ├── ModelValidatedEventArgs.cs
│   │   │   ├── ModelValidatingEventArgs.cs
│   │   │   ├── ModelValidationNode.cs
│   │   │   ├── ModelValidationRequiredMemberSelector.cs
│   │   │   ├── ModelValidationResult.cs
│   │   │   ├── ModelValidator.cs
│   │   │   ├── ModelValidatorCache.cs
│   │   │   ├── ModelValidatorProvider.cs
│   │   │   ├── Providers/
│   │   │   │   ├── AssociatedValidatorProvider.cs
│   │   │   │   ├── DataAnnotationsModelValidatorProvider.cs
│   │   │   │   ├── DataMemberModelValidatorProvider.cs
│   │   │   │   ├── InvalidModelValidatorProvider.cs
│   │   │   │   └── RequiredMemberModelValidatorProvider.cs
│   │   │   ├── ReferenceEqualityComparer.cs
│   │   │   └── Validators/
│   │   │       ├── DataAnnotationsModelValidator.cs
│   │   │       ├── ErrorModelValidator.cs
│   │   │       ├── RequiredMemberModelValidator.cs
│   │   │       └── ValidatableObjectAdapter.cs
│   │   ├── ValueProviders/
│   │   │   ├── IEnumerableValueProvider.cs
│   │   │   ├── IUriValueProviderFactory.cs
│   │   │   ├── IValueProvider.cs
│   │   │   ├── Providers/
│   │   │   │   ├── CompositeValueProvider.cs
│   │   │   │   ├── CompositeValueProviderFactory.cs
│   │   │   │   ├── ElementalValueProvider.cs
│   │   │   │   ├── NameValuePairsValueProvider.cs
│   │   │   │   ├── QueryStringValueProvider.cs
│   │   │   │   ├── QueryStringValueProviderFactory.cs
│   │   │   │   ├── RouteDataValueProvider.cs
│   │   │   │   └── RouteDataValueProviderFactory.cs
│   │   │   ├── ValueProviderAttribute.cs
│   │   │   ├── ValueProviderFactory.cs
│   │   │   └── ValueProviderResult.cs
│   │   └── packages.config
│   ├── System.Web.Http.Cors/
│   │   ├── AttributeBasedPolicyProviderFactory.cs
│   │   ├── CorsHttpConfigurationExtensions.cs
│   │   ├── CorsHttpRequestMessageExtensions.cs
│   │   ├── CorsHttpResponseMessageExtensions.cs
│   │   ├── CorsMessageHandler.cs
│   │   ├── DisableCorsAttribute.cs
│   │   ├── EnableCorsAttribute.cs
│   │   ├── ICorsPolicyProvider.cs
│   │   ├── ICorsPolicyProviderFactory.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── SRResources.Designer.cs
│   │   │   └── SRResources.resx
│   │   ├── System.Web.Http.Cors.csproj
│   │   └── Tracing/
│   │       ├── CorsEngineTracer.cs
│   │       ├── CorsPolicyProviderFactoryTracer.cs
│   │       ├── CorsPolicyProviderTracer.cs
│   │       └── TraceCategories.cs
│   ├── System.Web.Http.Owin/
│   │   ├── ExceptionHandling/
│   │   │   ├── DefaultExceptionHandler.cs
│   │   │   └── EmptyExceptionLogger.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── HostAuthenticationAttribute.cs
│   │   ├── HostAuthenticationFilter.cs
│   │   ├── HttpMessageHandlerAdapter.cs
│   │   ├── HttpMessageHandlerOptions.cs
│   │   ├── OwinBufferPolicySelector.cs
│   │   ├── OwinConstants.cs
│   │   ├── OwinExceptionCatchBlocks.cs
│   │   ├── OwinHttpConfigurationExtensions.cs
│   │   ├── OwinHttpRequestContext.cs
│   │   ├── OwinHttpRequestMessageExtensions.cs
│   │   ├── OwinRequestExtensions.cs
│   │   ├── OwinResponseExtensions.cs
│   │   ├── PassiveAuthenticationMessageHandler.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── OwinResources.Designer.cs
│   │   │   └── OwinResources.resx
│   │   ├── System.Web.Http.Owin.csproj
│   │   ├── WebApiAppBuilderExtensions.cs
│   │   └── packages.config
│   ├── System.Web.Http.SelfHost/
│   │   ├── Channels/
│   │   │   ├── HttpBinding.cs
│   │   │   ├── HttpBindingSecurity.cs
│   │   │   ├── HttpBindingSecurityMode.cs
│   │   │   ├── HttpBindingSecurityModeHelper.cs
│   │   │   ├── HttpMessage.cs
│   │   │   ├── HttpMessageEncoderFactory.cs
│   │   │   ├── HttpMessageEncodingBindingElement.cs
│   │   │   ├── HttpMessageEncodingChannelListener.cs
│   │   │   ├── HttpMessageEncodingReplyChannel.cs
│   │   │   ├── HttpMessageEncodingRequestContext.cs
│   │   │   └── HttpMessageExtensions.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── HttpRequestMessageExtensions.cs
│   │   ├── HttpSelfHostConfiguration.cs
│   │   ├── HttpSelfHostServer.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── SRResources.Designer.cs
│   │   │   └── SRResources.resx
│   │   ├── SelfHostHttpRequestContext.cs
│   │   ├── ServiceModel/
│   │   │   ├── Channels/
│   │   │   │   ├── AsyncResult.cs
│   │   │   │   ├── BufferManagerOutputStream.cs
│   │   │   │   ├── BufferedOutputStream.cs
│   │   │   │   ├── ChannelAcceptor.cs
│   │   │   │   ├── ChannelBindingUtility.cs
│   │   │   │   ├── CompletedAsyncResult.cs
│   │   │   │   ├── CompletedAsyncResultOfT.cs
│   │   │   │   ├── HttpTransportDefaults.cs
│   │   │   │   ├── IChannelAcceptor.cs
│   │   │   │   ├── LayeredChannel.cs
│   │   │   │   ├── LayeredChannelAcceptor.cs
│   │   │   │   ├── LayeredChannelListener.cs
│   │   │   │   └── TransportDefaults.cs
│   │   │   ├── HostNameComparisonModeHelper.cs
│   │   │   ├── HttpClientCredentialTypeHelper.cs
│   │   │   ├── HttpProxyCredentialTypeHelper.cs
│   │   │   ├── HttpTransportSecurityExtensionMethods.cs
│   │   │   └── TransferModeHelper.cs
│   │   └── System.Web.Http.SelfHost.csproj
│   ├── System.Web.Http.SignalR/
│   │   ├── GlobalSuppressions.cs
│   │   ├── HubController.cs
│   │   ├── HubControllerBase.cs
│   │   ├── HubControllerOfTHub.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── SRResources.Designer.cs
│   │   │   └── SRResources.resx
│   │   ├── System.Web.Http.SignalR.csproj
│   │   └── packages.config
│   ├── System.Web.Http.Tracing/
│   │   ├── GlobalSuppressions.cs
│   │   ├── HttpConfigurationExtensions.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── SRResources.Designer.cs
│   │   │   └── SRResources.resx
│   │   ├── System.Web.Http.Tracing.csproj
│   │   ├── SystemDiagnosticsTraceWriter.cs
│   │   └── packages.config
│   ├── System.Web.Http.WebHost/
│   │   ├── GlobalConfiguration.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── HttpBatchContextWrapper.cs
│   │   ├── HttpControllerHandler.cs
│   │   ├── HttpControllerRouteHandler.cs
│   │   ├── HttpControllerTypeCacheSerializer.cs
│   │   ├── HttpRequestMessageExtensions.cs
│   │   ├── HttpResponseBaseExtensions.cs
│   │   ├── PreApplicationStartCode.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── SRResources.Designer.cs
│   │   │   └── SRResources.resx
│   │   ├── RouteCollectionExtensions.cs
│   │   ├── Routing/
│   │   │   ├── HostedHttpRoute.cs
│   │   │   ├── HostedHttpRouteCollection.cs
│   │   │   ├── HostedHttpRouteData.cs
│   │   │   ├── HostedHttpVirtualPathData.cs
│   │   │   ├── HttpContextBaseExtensions.cs
│   │   │   ├── HttpRequestMessageContextWrapper.cs
│   │   │   ├── HttpRequestMessageWrapper.cs
│   │   │   ├── HttpRouteDataExtensions.cs
│   │   │   ├── HttpRouteExceptionHandler.cs
│   │   │   ├── HttpRouteExceptionRouteHandler.cs
│   │   │   ├── HttpRouteExtensions.cs
│   │   │   └── HttpWebRoute.cs
│   │   ├── SeekableBufferedRequestStream.cs
│   │   ├── SuppressFormsAuthRedirectHelper.cs
│   │   ├── System.Web.Http.WebHost.csproj
│   │   ├── TaskWrapperAsyncResult.cs
│   │   ├── WebHostAssembliesResolver.cs
│   │   ├── WebHostBufferPolicySelector.cs
│   │   ├── WebHostExceptionCatchBlocks.cs
│   │   ├── WebHostExceptionHandler.cs
│   │   ├── WebHostHttpControllerTypeResolver.cs
│   │   ├── WebHostHttpRequestContext.cs
│   │   └── packages.config
│   ├── System.Web.Mvc/
│   │   ├── AcceptVerbsAttribute.cs
│   │   ├── ActionDescriptor.cs
│   │   ├── ActionDescriptorHelper.cs
│   │   ├── ActionExecutedContext.cs
│   │   ├── ActionExecutingContext.cs
│   │   ├── ActionFilterAttribute.cs
│   │   ├── ActionMethodDispatcher.cs
│   │   ├── ActionMethodDispatcherCache.cs
│   │   ├── ActionMethodSelector.cs
│   │   ├── ActionMethodSelectorAttribute.cs
│   │   ├── ActionMethodSelectorBase.cs
│   │   ├── ActionNameAttribute.cs
│   │   ├── ActionNameSelector.cs
│   │   ├── ActionNameSelectorAttribute.cs
│   │   ├── ActionResult.cs
│   │   ├── ActionSelector.cs
│   │   ├── AdditionalMetaDataAttribute.cs
│   │   ├── Ajax/
│   │   │   ├── AjaxExtensions.cs
│   │   │   ├── AjaxOptions.cs
│   │   │   └── InsertionMode.cs
│   │   ├── AjaxHelper.cs
│   │   ├── AjaxHelperOfTModel.cs
│   │   ├── AjaxRequestExtensions.cs
│   │   ├── AllowAnonymousAttribute.cs
│   │   ├── AllowHtmlAttribute.cs
│   │   ├── AreaHelpers.cs
│   │   ├── AreaReference.cs
│   │   ├── AreaRegistration.cs
│   │   ├── AreaRegistrationContext.cs
│   │   ├── AssociatedMetadataProvider.cs
│   │   ├── AssociatedValidatorProvider.cs
│   │   ├── Async/
│   │   │   ├── ActionDescriptorCreator.cs
│   │   │   ├── AsyncActionDescriptor.cs
│   │   │   ├── AsyncActionMethodSelector.cs
│   │   │   ├── AsyncControllerActionInvoker.cs
│   │   │   ├── AsyncManager.cs
│   │   │   ├── AsyncResultWrapper.cs
│   │   │   ├── AsyncVoid.cs
│   │   │   ├── BeginInvokeDelegate.cs
│   │   │   ├── BeginInvokeDelegateOfTState.cs
│   │   │   ├── EndInvokeDelegateOfTResult.cs
│   │   │   ├── EndInvokeDelegateOfTResultTState.cs
│   │   │   ├── EndInvokeVoidDelegate.cs
│   │   │   ├── IAsyncActionInvoker.cs
│   │   │   ├── IAsyncActionInvokerFactory.cs
│   │   │   ├── IAsyncController.cs
│   │   │   ├── IAsyncManagerContainer.cs
│   │   │   ├── OperationCounter.cs
│   │   │   ├── ReflectedAsyncActionDescriptor.cs
│   │   │   ├── ReflectedAsyncControllerDescriptor.cs
│   │   │   ├── SimpleAsyncResult.cs
│   │   │   ├── SingleEntryGate.cs
│   │   │   ├── SynchronizationContextUtil.cs
│   │   │   ├── SynchronousOperationException.cs
│   │   │   ├── TaskAsyncActionDescriptor.cs
│   │   │   ├── TaskWrapperAsyncResult.cs
│   │   │   ├── Trigger.cs
│   │   │   └── TriggerListener.cs
│   │   ├── AsyncController.cs
│   │   ├── AsyncTimeoutAttribute.cs
│   │   ├── AuthorizationContext.cs
│   │   ├── AuthorizeAttribute.cs
│   │   ├── BindAttribute.cs
│   │   ├── BuildManagerCompiledView.cs
│   │   ├── BuildManagerViewEngine.cs
│   │   ├── BuildManagerWrapper.cs
│   │   ├── ByteArrayModelBinder.cs
│   │   ├── CachedAssociatedMetadataProvider.cs
│   │   ├── CachedDataAnnotationsMetadataAttributes.cs
│   │   ├── CachedDataAnnotationsModelMetadata.cs
│   │   ├── CachedDataAnnotationsModelMetadataProvider.cs
│   │   ├── CachedModelMetadata.cs
│   │   ├── CancellationTokenModelBinder.cs
│   │   ├── ChildActionOnlyAttribute.cs
│   │   ├── ChildActionValueProvider.cs
│   │   ├── ChildActionValueProviderFactory.cs
│   │   ├── ClientDataTypeModelValidatorProvider.cs
│   │   ├── CompareAttribute.cs
│   │   ├── CompareAttributeAdapter.cs
│   │   ├── ContentResult.cs
│   │   ├── Controller.cs
│   │   ├── ControllerActionInvoker.cs
│   │   ├── ControllerBase.cs
│   │   ├── ControllerBuilder.cs
│   │   ├── ControllerContext.cs
│   │   ├── ControllerDescriptor.cs
│   │   ├── ControllerDescriptorCache.cs
│   │   ├── ControllerDescriptorExtensions.cs
│   │   ├── ControllerInstanceFilterProvider.cs
│   │   ├── ControllerTypeCache.cs
│   │   ├── CopyOnWriteDictionary.cs
│   │   ├── CustomModelBinderAttribute.cs
│   │   ├── DataAnnotationsModelMetadata.cs
│   │   ├── DataAnnotationsModelMetadataProvider.cs
│   │   ├── DataAnnotationsModelValidator.cs
│   │   ├── DataAnnotationsModelValidatorOfTAttribute.cs
│   │   ├── DataAnnotationsModelValidatorProvider.cs
│   │   ├── DataErrorInfoModelValidatorProvider.cs
│   │   ├── DataTypeAttributeAdapter.cs
│   │   ├── DataTypeUtil.cs
│   │   ├── DefaultControllerFactory.cs
│   │   ├── DefaultModelBinder.cs
│   │   ├── DefaultViewLocationCache.cs
│   │   ├── DependencyResolver.cs
│   │   ├── DependencyResolverExtensions.cs
│   │   ├── DescriptorUtil.cs
│   │   ├── DictionaryHelpers.cs
│   │   ├── DictionaryValueProvider.cs
│   │   ├── DynamicViewDataDictionary.cs
│   │   ├── EmptyModelMetadataProvider.cs
│   │   ├── EmptyModelValidatorProvider.cs
│   │   ├── EmptyResult.cs
│   │   ├── Error.cs
│   │   ├── ExceptionContext.cs
│   │   ├── ExpressionHelper.cs
│   │   ├── ExpressionUtil/
│   │   │   ├── BinaryExpressionFingerprint.cs
│   │   │   ├── CachedExpressionCompiler.cs
│   │   │   ├── ConditionalExpressionFingerprint.cs
│   │   │   ├── ConstantExpressionFingerprint.cs
│   │   │   ├── DefaultExpressionFingerprint.cs
│   │   │   ├── ExpressionFingerprint.cs
│   │   │   ├── ExpressionFingerprintChain.cs
│   │   │   ├── FingerprintingExpressionVisitor.cs
│   │   │   ├── HashCodeCombiner.cs
│   │   │   ├── Hoisted.cs
│   │   │   ├── HoistingExpressionVisitor.cs
│   │   │   ├── IndexExpressionFingerprint.cs
│   │   │   ├── LambdaExpressionFingerprint.cs
│   │   │   ├── MemberExpressionFingerprint.cs
│   │   │   ├── MethodCallExpressionFingerprint.cs
│   │   │   ├── ParameterExpressionFingerprint.cs
│   │   │   ├── TypeBinaryExpressionFingerprint.cs
│   │   │   └── UnaryExpressionFingerprint.cs
│   │   ├── FieldValidationMetadata.cs
│   │   ├── FileContentResult.cs
│   │   ├── FileExtensionsAttributeAdapter.cs
│   │   ├── FilePathResult.cs
│   │   ├── FileResult.cs
│   │   ├── FileStreamResult.cs
│   │   ├── Filter.cs
│   │   ├── FilterAttribute.cs
│   │   ├── FilterAttributeFilterProvider.cs
│   │   ├── FilterInfo.cs
│   │   ├── FilterProviderCollection.cs
│   │   ├── FilterProviders.cs
│   │   ├── FilterScope.cs
│   │   ├── Filters/
│   │   │   ├── AuthenticationChallengeContext.cs
│   │   │   ├── AuthenticationContext.cs
│   │   │   ├── IAuthenticationFilter.cs
│   │   │   └── IOverrideFilter.cs
│   │   ├── FormCollection.cs
│   │   ├── FormContext.cs
│   │   ├── FormMethod.cs
│   │   ├── FormValueProvider.cs
│   │   ├── FormValueProviderFactory.cs
│   │   ├── GlobalFilterCollection.cs
│   │   ├── GlobalFilters.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── HandleErrorAttribute.cs
│   │   ├── HandleErrorInfo.cs
│   │   ├── HiddenInputAttribute.cs
│   │   ├── Html/
│   │   │   ├── ChildActionExtensions.cs
│   │   │   ├── DefaultDisplayTemplates.cs
│   │   │   ├── DefaultEditorTemplates.cs
│   │   │   ├── DisplayExtensions.cs
│   │   │   ├── DisplayNameExtensions.cs
│   │   │   ├── DisplayTextExtensions.cs
│   │   │   ├── EditorExtensions.cs
│   │   │   ├── EnumHelper.cs
│   │   │   ├── FormExtensions.cs
│   │   │   ├── InputExtensions.cs
│   │   │   ├── LabelExtensions.cs
│   │   │   ├── LinkExtensions.cs
│   │   │   ├── MvcForm.cs
│   │   │   ├── NameExtensions.cs
│   │   │   ├── PartialExtensions.cs
│   │   │   ├── RenderPartialExtensions.cs
│   │   │   ├── SelectExtensions.cs
│   │   │   ├── TemplateHelpers.cs
│   │   │   ├── TextAreaExtensions.cs
│   │   │   ├── ValidationExtensions.cs
│   │   │   └── ValueExtensions.cs
│   │   ├── Html5DateRenderingMode.cs
│   │   ├── HtmlHelper.cs
│   │   ├── HtmlHelperOfTModel.cs
│   │   ├── HttpDeleteAttribute.cs
│   │   ├── HttpFileCollectionValueProvider.cs
│   │   ├── HttpFileCollectionValueProviderFactory.cs
│   │   ├── HttpGetAttribute.cs
│   │   ├── HttpHandlerUtil.cs
│   │   ├── HttpHeadAttribute.cs
│   │   ├── HttpNotFoundResult.cs
│   │   ├── HttpOptionsAttribute.cs
│   │   ├── HttpPatchAttribute.cs
│   │   ├── HttpPostAttribute.cs
│   │   ├── HttpPostedFileBaseModelBinder.cs
│   │   ├── HttpPutAttribute.cs
│   │   ├── HttpRequestExtensions.cs
│   │   ├── HttpStatusCodeResult.cs
│   │   ├── HttpUnauthorizedResult.cs
│   │   ├── HttpVerbs.cs
│   │   ├── IActionFilter.cs
│   │   ├── IActionInvoker.cs
│   │   ├── IActionInvokerFactory.cs
│   │   ├── IAuthorizationFilter.cs
│   │   ├── IBuildManager.cs
│   │   ├── IClientValidatable.cs
│   │   ├── IController.cs
│   │   ├── IControllerActivator.cs
│   │   ├── IControllerFactory.cs
│   │   ├── IDependencyResolver.cs
│   │   ├── IEnumerableValueProvider.cs
│   │   ├── IExceptionFilter.cs
│   │   ├── IFilterProvider.cs
│   │   ├── IMetadataAware.cs
│   │   ├── IMethodInfoActionDescriptor.cs
│   │   ├── IModelBinder.cs
│   │   ├── IModelBinderProvider.cs
│   │   ├── IMvcControlBuilder.cs
│   │   ├── IMvcFilter.cs
│   │   ├── IResolver.cs
│   │   ├── IResultFilter.cs
│   │   ├── IRouteWithArea.cs
│   │   ├── ITempDataProvider.cs
│   │   ├── ITempDataProviderFactory.cs
│   │   ├── IUniquelyIdentifiable.cs
│   │   ├── IUnvalidatedRequestValues.cs
│   │   ├── IUnvalidatedValueProvider.cs
│   │   ├── IValueProvider.cs
│   │   ├── IView.cs
│   │   ├── IViewDataContainer.cs
│   │   ├── IViewEngine.cs
│   │   ├── IViewLocationCache.cs
│   │   ├── IViewPageActivator.cs
│   │   ├── IViewStartPageChild.cs
│   │   ├── InputType.cs
│   │   ├── JQueryFormValueProvider.cs
│   │   ├── JQueryFormValueProviderFactory.cs
│   │   ├── JavaScript/
│   │   │   ├── jquery.unobtrusive-ajax.js
│   │   │   └── jquery.validate.unobtrusive.js
│   │   ├── JavaScriptResult.cs
│   │   ├── JsonRequestBehavior.cs
│   │   ├── JsonResult.cs
│   │   ├── JsonValueProviderFactory.cs
│   │   ├── LinqBinaryModelBinder.cs
│   │   ├── MaxLengthAttributeAdapter.cs
│   │   ├── MembershipPasswordAttributeAdapter.cs
│   │   ├── MinLengthAttributeAdapter.cs
│   │   ├── ModelBinderAttribute.cs
│   │   ├── ModelBinderDictionary.cs
│   │   ├── ModelBinderProviderCollection.cs
│   │   ├── ModelBinderProviders.cs
│   │   ├── ModelBinders.cs
│   │   ├── ModelBindingContext.cs
│   │   ├── ModelError.cs
│   │   ├── ModelErrorCollection.cs
│   │   ├── ModelMetadata.cs
│   │   ├── ModelMetadataProvider.cs
│   │   ├── ModelMetadataProviders.cs
│   │   ├── ModelState.cs
│   │   ├── ModelStateDictionary.cs
│   │   ├── ModelValidationResult.cs
│   │   ├── ModelValidator.cs
│   │   ├── ModelValidatorProvider.cs
│   │   ├── ModelValidatorProviderCollection.cs
│   │   ├── ModelValidatorProviders.cs
│   │   ├── MultiSelectList.cs
│   │   ├── MultiServiceResolver.cs
│   │   ├── MvcFilter.cs
│   │   ├── MvcHandler.cs
│   │   ├── MvcHtmlString.cs
│   │   ├── MvcHttpHandler.cs
│   │   ├── MvcRouteHandler.cs
│   │   ├── MvcWebRazorHostFactory.cs
│   │   ├── NameValueCollectionExtensions.cs
│   │   ├── NameValueCollectionValueProvider.cs
│   │   ├── NoAsyncTimeoutAttribute.cs
│   │   ├── NonActionAttribute.cs
│   │   ├── NullViewLocationCache.cs
│   │   ├── OutputCacheAttribute.cs
│   │   ├── OverrideActionFiltersAttribute.cs
│   │   ├── OverrideAuthenticationAttribute.cs
│   │   ├── OverrideAuthorizationAttribute.cs
│   │   ├── OverrideExceptionFiltersAttribute.cs
│   │   ├── OverrideResultFiltersAttribute.cs
│   │   ├── ParameterBindingInfo.cs
│   │   ├── ParameterDescriptor.cs
│   │   ├── ParameterInfoUtil.cs
│   │   ├── PartialViewResult.cs
│   │   ├── PreApplicationStartCode.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── MvcResources.Designer.cs
│   │   │   └── MvcResources.resx
│   │   ├── QueryStringValueProvider.cs
│   │   ├── QueryStringValueProviderFactory.cs
│   │   ├── RangeAttributeAdapter.cs
│   │   ├── Razor/
│   │   │   ├── MvcCSharpRazorCodeGenerator.cs
│   │   │   ├── MvcCSharpRazorCodeParser.cs
│   │   │   ├── MvcVBRazorCodeParser.cs
│   │   │   ├── MvcWebPageRazorHost.cs
│   │   │   ├── SetModelTypeCodeGenerator.cs
│   │   │   └── StartPageLookupDelegate.cs
│   │   ├── RazorView.cs
│   │   ├── RazorViewEngine.cs
│   │   ├── ReaderWriterCache.cs
│   │   ├── RedirectResult.cs
│   │   ├── RedirectToRouteResult.cs
│   │   ├── ReflectedActionDescriptor.cs
│   │   ├── ReflectedAttributeCache.cs
│   │   ├── ReflectedControllerDescriptor.cs
│   │   ├── ReflectedParameterBindingInfo.cs
│   │   ├── ReflectedParameterDescriptor.cs
│   │   ├── RegularExpressionAttributeAdapter.cs
│   │   ├── RemoteAttribute.cs
│   │   ├── RequireHttpsAttribute.cs
│   │   ├── RequiredAttributeAdapter.cs
│   │   ├── ResultExecutedContext.cs
│   │   ├── ResultExecutingContext.cs
│   │   ├── RouteAreaAttribute.cs
│   │   ├── RouteAttribute.cs
│   │   ├── RouteCollectionExtensions.cs
│   │   ├── RouteDataValueProvider.cs
│   │   ├── RouteDataValueProviderFactory.cs
│   │   ├── RoutePrefixAttribute.cs
│   │   ├── RouteValuesHelpers.cs
│   │   ├── Routing/
│   │   │   ├── AttributeRoutingMapper.cs
│   │   │   ├── ConstraintValidation.cs
│   │   │   ├── DefaultDirectRouteProvider.cs
│   │   │   ├── DirectRouteCandidate.cs
│   │   │   ├── DirectRouteExtensions.cs
│   │   │   ├── IDirectRouteProvider.cs
│   │   │   ├── IRouteInfoProvider.cs
│   │   │   ├── LinkGenerationRoute.cs
│   │   │   ├── ParsedRoute.cs
│   │   │   ├── RouteBuilder.cs
│   │   │   ├── RouteCollectionAttributeRoutingExtensions.cs
│   │   │   ├── RouteCollectionRoute.cs
│   │   │   └── RouteDataTokenKeys.cs
│   │   ├── SelectList.cs
│   │   ├── SelectListGroup.cs
│   │   ├── SelectListItem.cs
│   │   ├── SessionStateAttribute.cs
│   │   ├── SessionStateTempDataProvider.cs
│   │   ├── SingleServiceResolver.cs
│   │   ├── StringLengthAttributeAdapter.cs
│   │   ├── System.Web.Mvc.csproj
│   │   ├── TagBuilderExtensions.cs
│   │   ├── TempDataDictionary.cs
│   │   ├── TemplateInfo.cs
│   │   ├── TryGetValueDelegate.cs
│   │   ├── TypeCacheSerializer.cs
│   │   ├── TypeCacheUtil.cs
│   │   ├── TypeDescriptorHelper.cs
│   │   ├── TypeHelpers.cs
│   │   ├── UnvalidatedRequestValuesAccessor.cs
│   │   ├── UnvalidatedRequestValuesWrapper.cs
│   │   ├── UrlHelper.cs
│   │   ├── UrlParameter.cs
│   │   ├── ValidatableObjectAdapter.cs
│   │   ├── ValidateAntiForgeryTokenAttribute.cs
│   │   ├── ValidateInputAttribute.cs
│   │   ├── ValueProviderCollection.cs
│   │   ├── ValueProviderDictionary.cs
│   │   ├── ValueProviderFactories.cs
│   │   ├── ValueProviderFactory.cs
│   │   ├── ValueProviderFactoryCollection.cs
│   │   ├── ValueProviderResult.cs
│   │   ├── ValueProviderUtil.cs
│   │   ├── ViewContext.cs
│   │   ├── ViewDataDictionary.cs
│   │   ├── ViewDataDictionaryOfTModel.cs
│   │   ├── ViewDataInfo.cs
│   │   ├── ViewEngineCollection.cs
│   │   ├── ViewEngineResult.cs
│   │   ├── ViewEngines.cs
│   │   ├── ViewMasterPage.cs
│   │   ├── ViewMasterPageControlBuilder.cs
│   │   ├── ViewMasterPageOfTModel.cs
│   │   ├── ViewPage.cs
│   │   ├── ViewPageControlBuilder.cs
│   │   ├── ViewPageOfTModel.cs
│   │   ├── ViewResult.cs
│   │   ├── ViewResultBase.cs
│   │   ├── ViewStartPage.cs
│   │   ├── ViewTemplateUserControl.cs
│   │   ├── ViewTemplateUserControlOfTModel.cs
│   │   ├── ViewType.cs
│   │   ├── ViewTypeControlBuilder.cs
│   │   ├── ViewTypeParserFilter.cs
│   │   ├── ViewUserControl.cs
│   │   ├── ViewUserControlControlBuilder.cs
│   │   ├── ViewUserControlOfTModel.cs
│   │   ├── VirtualPathProviderViewEngine.cs
│   │   ├── WebFormView.cs
│   │   ├── WebFormViewEngine.cs
│   │   ├── WebViewPage.cs
│   │   ├── WebViewPageOfTModel.cs
│   │   └── packages.config
│   ├── System.Web.Razor/
│   │   ├── CSharpRazorCodeLanguage.cs
│   │   ├── DocumentParseCompleteEventArgs.cs
│   │   ├── Editor/
│   │   │   ├── AutoCompleteEditHandler.cs
│   │   │   ├── BackgroundParser.cs
│   │   │   ├── EditResult.cs
│   │   │   ├── EditorHints.cs
│   │   │   ├── ImplicitExpressionEditHandler.cs
│   │   │   ├── RazorEditorTrace.cs
│   │   │   ├── SingleLineMarkupEditHandler.cs
│   │   │   └── SpanEditHandler.cs
│   │   ├── Generator/
│   │   │   ├── AddImportCodeGenerator.cs
│   │   │   ├── AttributeBlockCodeGenerator.cs
│   │   │   ├── BaseCodeWriter.cs
│   │   │   ├── BlockCodeGenerator.cs
│   │   │   ├── CSharpCodeWriter.cs
│   │   │   ├── CSharpRazorCodeGenerator.cs
│   │   │   ├── CodeGenerationCompleteEventArgs.cs
│   │   │   ├── CodeGeneratorContext.cs
│   │   │   ├── CodeGeneratorPaddingHelper.cs
│   │   │   ├── CodeWriter.cs
│   │   │   ├── CodeWriterExtensions.cs
│   │   │   ├── DynamicAttributeBlockCodeGenerator.cs
│   │   │   ├── ExpressionCodeGenerator.cs
│   │   │   ├── ExpressionRenderingMode.cs
│   │   │   ├── GeneratedClassContext.cs
│   │   │   ├── GeneratedCodeMapping.cs
│   │   │   ├── HelperCodeGenerator.cs
│   │   │   ├── HybridCodeGenerator.cs
│   │   │   ├── IBlockCodeGenerator.cs
│   │   │   ├── ISpanCodeGenerator.cs
│   │   │   ├── LiteralAttributeCodeGenerator.cs
│   │   │   ├── MarkupCodeGenerator.cs
│   │   │   ├── RazorCodeGenerator.cs
│   │   │   ├── RazorCommentCodeGenerator.cs
│   │   │   ├── RazorDirectiveAttributeCodeGenerator.cs
│   │   │   ├── ResolveUrlCodeGenerator.cs
│   │   │   ├── SectionCodeGenerator.cs
│   │   │   ├── SetBaseTypeCodeGenerator.cs
│   │   │   ├── SetLayoutCodeGenerator.cs
│   │   │   ├── SetVBOptionCodeGenerator.cs
│   │   │   ├── SpanCodeGenerator.cs
│   │   │   ├── StatementCodeGenerator.cs
│   │   │   ├── TemplateBlockCodeGenerator.cs
│   │   │   ├── TypeMemberCodeGenerator.cs
│   │   │   ├── VBCodeWriter.cs
│   │   │   └── VBRazorCodeGenerator.cs
│   │   ├── GeneratorResults.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── Parser/
│   │   │   ├── BalancingModes.cs
│   │   │   ├── CSharpCodeParser.Directives.cs
│   │   │   ├── CSharpCodeParser.Statements.cs
│   │   │   ├── CSharpCodeParser.cs
│   │   │   ├── CSharpLanguageCharacteristics.cs
│   │   │   ├── CallbackVisitor.cs
│   │   │   ├── ConditionalAttributeCollapser.cs
│   │   │   ├── HtmlLanguageCharacteristics.cs
│   │   │   ├── HtmlMarkupParser.Block.cs
│   │   │   ├── HtmlMarkupParser.Document.cs
│   │   │   ├── HtmlMarkupParser.Section.cs
│   │   │   ├── HtmlMarkupParser.cs
│   │   │   ├── ISyntaxTreeRewriter.cs
│   │   │   ├── LanguageCharacteristics.cs
│   │   │   ├── MarkupCollapser.cs
│   │   │   ├── MarkupRewriter.cs
│   │   │   ├── ParserBase.cs
│   │   │   ├── ParserContext.cs
│   │   │   ├── ParserHelpers.cs
│   │   │   ├── ParserVisitor.cs
│   │   │   ├── ParserVisitorExtensions.cs
│   │   │   ├── RazorParser.cs
│   │   │   ├── SyntaxConstants.cs
│   │   │   ├── SyntaxTree/
│   │   │   │   ├── AcceptedCharacters.cs
│   │   │   │   ├── Block.cs
│   │   │   │   ├── BlockBuilder.cs
│   │   │   │   ├── BlockType.cs
│   │   │   │   ├── EquivalenceComparer.cs
│   │   │   │   ├── RazorError.cs
│   │   │   │   ├── Span.cs
│   │   │   │   ├── SpanBuilder.cs
│   │   │   │   ├── SpanKind.cs
│   │   │   │   └── SyntaxTreeNode.cs
│   │   │   ├── TextReaderExtensions.cs
│   │   │   ├── TokenizerBackedParser.Helpers.cs
│   │   │   ├── TokenizerBackedParser.cs
│   │   │   ├── VBCodeParser.Directives.cs
│   │   │   ├── VBCodeParser.Statements.cs
│   │   │   ├── VBCodeParser.cs
│   │   │   ├── VBLanguageCharacteristics.cs
│   │   │   └── WhitespaceRewriter.cs
│   │   ├── ParserResults.cs
│   │   ├── PartialParseResult.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── RazorCodeLanguage.cs
│   │   ├── RazorDebugHelpers.cs
│   │   ├── RazorDirectiveAttribute.cs
│   │   ├── RazorEditorParser.cs
│   │   ├── RazorEngineHost.cs
│   │   ├── RazorTemplateEngine.cs
│   │   ├── Resources/
│   │   │   ├── RazorResources.Designer.cs
│   │   │   └── RazorResources.resx
│   │   ├── StateMachine.cs
│   │   ├── System.Web.Razor.csproj
│   │   ├── Text/
│   │   │   ├── BufferingTextReader.cs
│   │   │   ├── ITextBuffer.cs
│   │   │   ├── LineTrackingStringBuffer.cs
│   │   │   ├── LocationTagged.cs
│   │   │   ├── LookaheadTextReader.cs
│   │   │   ├── LookaheadToken.cs
│   │   │   ├── SeekableTextReader.cs
│   │   │   ├── SourceLocation.cs
│   │   │   ├── SourceLocationTracker.cs
│   │   │   ├── TextBufferReader.cs
│   │   │   ├── TextChange.cs
│   │   │   ├── TextChangeType.cs
│   │   │   ├── TextDocumentReader.cs
│   │   │   └── TextExtensions.cs
│   │   ├── Tokenizer/
│   │   │   ├── CSharpHelpers.cs
│   │   │   ├── CSharpKeywordDetector.cs
│   │   │   ├── CSharpTokenizer.cs
│   │   │   ├── HtmlTokenizer.cs
│   │   │   ├── ITokenizer.cs
│   │   │   ├── Symbols/
│   │   │   │   ├── CSharpKeyword.cs
│   │   │   │   ├── CSharpSymbol.cs
│   │   │   │   ├── CSharpSymbolType.cs
│   │   │   │   ├── HtmlSymbol.cs
│   │   │   │   ├── HtmlSymbolType.cs
│   │   │   │   ├── ISymbol.cs
│   │   │   │   ├── KnownSymbolType.cs
│   │   │   │   ├── SymbolBase.cs
│   │   │   │   ├── SymbolExtensions.cs
│   │   │   │   ├── SymbolTypeSuppressions.cs
│   │   │   │   ├── VBKeyword.cs
│   │   │   │   ├── VBSymbol.cs
│   │   │   │   └── VBSymbolType.cs
│   │   │   ├── Tokenizer.cs
│   │   │   ├── TokenizerView.cs
│   │   │   ├── VBHelpers.cs
│   │   │   ├── VBKeywordDetector.cs
│   │   │   ├── VBTokenizer.cs
│   │   │   └── XmlHelpers.cs
│   │   ├── Utils/
│   │   │   ├── CharUtils.cs
│   │   │   ├── DisposableAction.cs
│   │   │   ├── EnumUtil.cs
│   │   │   └── EnumeratorExtensions.cs
│   │   └── VBRazorCodeLanguage.cs
│   ├── System.Web.WebPages/
│   │   ├── ApplicationPart.cs
│   │   ├── ApplicationParts/
│   │   │   ├── ApplicationPartRegistry.cs
│   │   │   ├── DictionaryBasedVirtualPathFactory.cs
│   │   │   ├── IResourceAssembly.cs
│   │   │   ├── LazyAction.cs
│   │   │   ├── ResourceAssembly.cs
│   │   │   ├── ResourceHandler.cs
│   │   │   └── ResourceRouteHandler.cs
│   │   ├── ApplicationStartPage.cs
│   │   ├── AttributeValue.cs
│   │   ├── BrowserHelpers.cs
│   │   ├── BrowserOverride.cs
│   │   ├── BrowserOverrideStore.cs
│   │   ├── BrowserOverrideStores.cs
│   │   ├── BuildManagerWrapper.cs
│   │   ├── Common/
│   │   │   └── DisposableAction.cs
│   │   ├── CookieBrowserOverrideStore.cs
│   │   ├── DefaultDisplayMode.cs
│   │   ├── DisplayInfo.cs
│   │   ├── DisplayModeProvider.cs
│   │   ├── DynamicHttpApplicationState.cs
│   │   ├── DynamicPageDataDictionary.cs
│   │   ├── FileExistenceCache.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── HelperPage.cs
│   │   ├── HelperResult.cs
│   │   ├── Helpers/
│   │   │   ├── AntiForgery.cs
│   │   │   ├── AntiForgeryConfig.cs
│   │   │   ├── AntiXsrf/
│   │   │   │   ├── AntiForgeryConfigWrapper.cs
│   │   │   │   ├── AntiForgeryToken.cs
│   │   │   │   ├── AntiForgeryTokenSerializer.cs
│   │   │   │   ├── AntiForgeryTokenStore.cs
│   │   │   │   ├── AntiForgeryWorker.cs
│   │   │   │   ├── BinaryBlob.cs
│   │   │   │   ├── ClaimUidExtractor.cs
│   │   │   │   ├── IAntiForgeryConfig.cs
│   │   │   │   ├── IAntiForgeryTokenSerializer.cs
│   │   │   │   ├── IClaimUidExtractor.cs
│   │   │   │   ├── ICryptoSystem.cs
│   │   │   │   ├── ITokenStore.cs
│   │   │   │   ├── ITokenValidator.cs
│   │   │   │   ├── MachineKey45CryptoSystem.cs
│   │   │   │   └── TokenValidator.cs
│   │   │   ├── Claims/
│   │   │   │   ├── Claim.cs
│   │   │   │   ├── ClaimsIdentity.cs
│   │   │   │   └── ClaimsIdentityConverter.cs
│   │   │   ├── CryptoUtil.cs
│   │   │   ├── IAntiForgeryAdditionalDataProvider.cs
│   │   │   ├── UnvalidatedRequestValues.cs
│   │   │   └── Validation.cs
│   │   ├── Html/
│   │   │   ├── HtmlHelper.Checkbox.cs
│   │   │   ├── HtmlHelper.Input.cs
│   │   │   ├── HtmlHelper.Internal.cs
│   │   │   ├── HtmlHelper.Label.cs
│   │   │   ├── HtmlHelper.Radio.cs
│   │   │   ├── HtmlHelper.Select.cs
│   │   │   ├── HtmlHelper.TextArea.cs
│   │   │   ├── HtmlHelper.Validation.cs
│   │   │   ├── HtmlHelper.cs
│   │   │   ├── ModelState.cs
│   │   │   ├── ModelStateDictionary.cs
│   │   │   └── SelectListItem.cs
│   │   ├── HttpContextExtensions.cs
│   │   ├── IDisplayMode.cs
│   │   ├── ITemplateFile.cs
│   │   ├── IVirtualPathFactory.cs
│   │   ├── IVirtualPathUtility.cs
│   │   ├── IWebPageRequestExecutor.cs
│   │   ├── Instrumentation/
│   │   │   ├── HttpContextAdapter.Availability.cs
│   │   │   ├── HttpContextAdapter.generated.cs
│   │   │   ├── HttpContextAdapter.tt
│   │   │   ├── InstrumentationService.cs
│   │   │   ├── PageExecutionContextAdapter.generated.cs
│   │   │   ├── PageExecutionContextAdapter.tt
│   │   │   ├── PageExecutionListenerAdapter.generated.cs
│   │   │   ├── PageExecutionListenerAdapter.tt
│   │   │   ├── PageInstrumentationServiceAdapter.cs
│   │   │   └── PositionTagged.cs
│   │   ├── MimeMapping.cs
│   │   ├── Mvc/
│   │   │   ├── HttpAntiForgeryException.cs
│   │   │   ├── ModelClientValidationEqualToRule.cs
│   │   │   ├── ModelClientValidationMaxLengthRule.cs
│   │   │   ├── ModelClientValidationMembershipPasswordRule.cs
│   │   │   ├── ModelClientValidationMinLengthRule.cs
│   │   │   ├── ModelClientValidationRangeRule.cs
│   │   │   ├── ModelClientValidationRegexRule.cs
│   │   │   ├── ModelClientValidationRemoteRule.cs
│   │   │   ├── ModelClientValidationRequiredRule.cs
│   │   │   ├── ModelClientValidationRule.cs
│   │   │   ├── ModelClientValidationStringLengthRule.cs
│   │   │   ├── TagBuilder.cs
│   │   │   ├── TagRenderMode.cs
│   │   │   └── UnobtrusiveValidationAttributesGenerator.cs
│   │   ├── PageDataDictionary.cs
│   │   ├── PageVirtualPathAttribute.cs
│   │   ├── PreApplicationStartCode.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── ReflectionDynamicObject.cs
│   │   ├── RequestBrowserOverrideStore.cs
│   │   ├── RequestExtensions.cs
│   │   ├── RequestResourceTracker.cs
│   │   ├── Resources/
│   │   │   ├── WebPageResources.Designer.cs
│   │   │   └── WebPageResources.resx
│   │   ├── ResponseExtensions.cs
│   │   ├── Scope/
│   │   │   ├── ApplicationScopeStorageDictionary.cs
│   │   │   ├── AspNetRequestScopeStorageProvider.cs
│   │   │   ├── IScopeStorageProvider.cs
│   │   │   ├── ScopeStorage.cs
│   │   │   ├── ScopeStorageComparer.cs
│   │   │   ├── ScopeStorageDictionary.cs
│   │   │   ├── StaticScopeStorageProvider.cs
│   │   │   └── WebConfigScopeStorageDictionary.cs
│   │   ├── SectionWriter.cs
│   │   ├── StartPage.cs
│   │   ├── StringExtensions.cs
│   │   ├── StringWriterExtensions.cs
│   │   ├── System.Web.WebPages.csproj
│   │   ├── TemplateFileInfo.cs
│   │   ├── TemplateStack.cs
│   │   ├── UrlDataList.cs
│   │   ├── Utils/
│   │   │   ├── BuildManagerExceptionUtil.cs
│   │   │   ├── CultureUtil.cs
│   │   │   ├── HtmlAttributePropertyHelper.cs
│   │   │   ├── PathUtil.cs
│   │   │   ├── SessionStateUtil.cs
│   │   │   ├── TypeHelper.cs
│   │   │   ├── UrlRewriterHelper.cs
│   │   │   └── UrlUtil.cs
│   │   ├── Validation/
│   │   │   ├── CompareValidator.cs
│   │   │   ├── DataTypeValidator.cs
│   │   │   ├── IValidator.cs
│   │   │   ├── RequestFieldValidatorBase.cs
│   │   │   ├── ValidationAttributeAdapter.cs
│   │   │   ├── ValidationHelper.cs
│   │   │   └── Validator.cs
│   │   ├── VirtualPathFactoryExtensions.cs
│   │   ├── VirtualPathFactoryManager.cs
│   │   ├── VirtualPathUtilityWrapper.cs
│   │   ├── WebPage.cs
│   │   ├── WebPageBase.cs
│   │   ├── WebPageContext.cs
│   │   ├── WebPageExecutingBase.cs
│   │   ├── WebPageHttpHandler.cs
│   │   ├── WebPageHttpModule.cs
│   │   ├── WebPageMatch.cs
│   │   ├── WebPageRenderingBase.cs
│   │   ├── WebPageRoute.cs
│   │   └── packages.config
│   ├── System.Web.WebPages.Administration/
│   │   ├── Default.cshtml
│   │   ├── EnableInstructions.cshtml
│   │   ├── Framework/
│   │   │   ├── AdminSecurity.cs
│   │   │   ├── PreApplicationStartCode.cs
│   │   │   └── SiteAdmin.cs
│   │   ├── Login.cshtml
│   │   ├── Logout.cshtml
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── Register.cshtml
│   │   ├── Resources/
│   │   │   ├── AdminResources.Designer.cs
│   │   │   ├── AdminResources.resx
│   │   │   ├── PackageManagerResources.Designer.cs
│   │   │   └── PackageManagerResources.resx
│   │   ├── Site.css
│   │   ├── System.Web.WebPages.Administration.csproj
│   │   ├── _Layout.cshtml
│   │   ├── _pagestart.cshtml
│   │   └── packages.config
│   ├── System.Web.WebPages.Deployment/
│   │   ├── AppDomainHelper.cs
│   │   ├── AssemblyUtils.cs
│   │   ├── BuildManagerWrapper.cs
│   │   ├── Common/
│   │   │   ├── IFileSystem.cs
│   │   │   └── PhysicalFileSystem.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── IBuildManager.cs
│   │   ├── PreApplicationStartCode.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── Resources/
│   │   │   ├── ConfigurationResources.Designer.cs
│   │   │   └── ConfigurationResources.resx
│   │   ├── System.Web.WebPages.Deployment.csproj
│   │   ├── WebPagesDeployment.cs
│   │   └── packages.config
│   ├── System.Web.WebPages.Razor/
│   │   ├── AssemblyBuilderWrapper.cs
│   │   ├── CompilingPathEventArgs.cs
│   │   ├── Configuration/
│   │   │   ├── HostSection.cs
│   │   │   ├── RazorPagesSection.cs
│   │   │   └── RazorWebSectionGroup.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── HostingEnvironmentWrapper.cs
│   │   ├── IAssemblyBuilder.cs
│   │   ├── IHostingEnvironment.cs
│   │   ├── PreApplicationStartCode.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── RazorBuildProvider.cs
│   │   ├── Resources/
│   │   │   ├── RazorWebResources.Designer.cs
│   │   │   └── RazorWebResources.resx
│   │   ├── System.Web.WebPages.Razor.csproj
│   │   ├── WebCodeRazorHost.cs
│   │   ├── WebPageRazorHost.cs
│   │   └── WebRazorHostFactory.cs
│   ├── WebApiHelpPage/
│   │   ├── Areas/
│   │   │   └── HelpPage/
│   │   │       ├── ApiDescriptionExtensions.cs
│   │   │       ├── App_Start/
│   │   │       │   └── HelpPageConfig.cs
│   │   │       ├── Controllers/
│   │   │       │   └── HelpController.cs
│   │   │       ├── HelpPage.css
│   │   │       ├── HelpPageAreaRegistration.cs
│   │   │       ├── HelpPageConfigurationExtensions.cs
│   │   │       ├── ModelDescriptions/
│   │   │       │   ├── CollectionModelDescription.cs
│   │   │       │   ├── ComplexTypeModelDescription.cs
│   │   │       │   ├── DictionaryModelDescription.cs
│   │   │       │   ├── EnumTypeModelDescription.cs
│   │   │       │   ├── EnumValueDescription.cs
│   │   │       │   ├── IModelDocumentationProvider.cs
│   │   │       │   ├── KeyValuePairModelDescription.cs
│   │   │       │   ├── ModelDescription.cs
│   │   │       │   ├── ModelDescriptionGenerator.cs
│   │   │       │   ├── ModelNameAttribute.cs
│   │   │       │   ├── ModelNameHelper.cs
│   │   │       │   ├── ParameterAnnotation.cs
│   │   │       │   ├── ParameterDescription.cs
│   │   │       │   └── SimpleTypeModelDescription.cs
│   │   │       ├── Models/
│   │   │       │   └── HelpPageApiModel.cs
│   │   │       ├── SampleGeneration/
│   │   │       │   ├── HelpPageSampleGenerator.cs
│   │   │       │   ├── HelpPageSampleKey.cs
│   │   │       │   ├── ImageSample.cs
│   │   │       │   ├── InvalidSample.cs
│   │   │       │   ├── ObjectGenerator.cs
│   │   │       │   ├── SampleDirection.cs
│   │   │       │   └── TextSample.cs
│   │   │       ├── Views/
│   │   │       │   ├── Help/
│   │   │       │   │   ├── Api.cshtml
│   │   │       │   │   ├── DisplayTemplates/
│   │   │       │   │   │   ├── ApiGroup.cshtml
│   │   │       │   │   │   ├── CollectionModelDescription.cshtml
│   │   │       │   │   │   ├── ComplexTypeModelDescription.cshtml
│   │   │       │   │   │   ├── DictionaryModelDescription.cshtml
│   │   │       │   │   │   ├── EnumTypeModelDescription.cshtml
│   │   │       │   │   │   ├── HelpPageApiModel.cshtml
│   │   │       │   │   │   ├── ImageSample.cshtml
│   │   │       │   │   │   ├── InvalidSample.cshtml
│   │   │       │   │   │   ├── KeyValuePairModelDescription.cshtml
│   │   │       │   │   │   ├── ModelDescriptionLink.cshtml
│   │   │       │   │   │   ├── Parameters.cshtml
│   │   │       │   │   │   ├── Samples.cshtml
│   │   │       │   │   │   ├── SimpleTypeModelDescription.cshtml
│   │   │       │   │   │   └── TextSample.cshtml
│   │   │       │   │   ├── Index.cshtml
│   │   │       │   │   └── ResourceModel.cshtml
│   │   │       │   ├── Shared/
│   │   │       │   │   └── _Layout.cshtml
│   │   │       │   ├── Web.config
│   │   │       │   └── _ViewStart.cshtml
│   │   │       └── XmlDocumentationProvider.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── Settings.StyleCop
│   │   ├── VB/
│   │   │   ├── Areas/
│   │   │   │   └── HelpPage/
│   │   │   │       ├── ApiDescriptionExtensions.vb
│   │   │   │       ├── App_Start/
│   │   │   │       │   └── HelpPageConfig.vb
│   │   │   │       ├── Controllers/
│   │   │   │       │   └── HelpController.vb
│   │   │   │       ├── HelpPage.css
│   │   │   │       ├── HelpPageAreaRegistration.vb
│   │   │   │       ├── HelpPageConfigurationExtensions.vb
│   │   │   │       ├── ModelDescriptions/
│   │   │   │       │   ├── CollectionModelDescription.vb
│   │   │   │       │   ├── ComplexTypeModelDescription.vb
│   │   │   │       │   ├── DictionaryModelDescription.vb
│   │   │   │       │   ├── EnumTypeModelDescription.vb
│   │   │   │       │   ├── EnumValueDescription.vb
│   │   │   │       │   ├── IModelDocumentationProvider.vb
│   │   │   │       │   ├── KeyValuePairModelDescription.vb
│   │   │   │       │   ├── ModelDescription.vb
│   │   │   │       │   ├── ModelDescriptionGenerator.vb
│   │   │   │       │   ├── ModelNameAttribute.vb
│   │   │   │       │   ├── ModelNameHelper.vb
│   │   │   │       │   ├── ParameterAnnotation.vb
│   │   │   │       │   ├── ParameterDescription.vb
│   │   │   │       │   └── SimpleTypeModelDescription.vb
│   │   │   │       ├── Models/
│   │   │   │       │   └── HelpPageApiModel.vb
│   │   │   │       ├── SampleGeneration/
│   │   │   │       │   ├── HelpPageSampleGenerator.vb
│   │   │   │       │   ├── HelpPageSampleKey.vb
│   │   │   │       │   ├── ImageSample.vb
│   │   │   │       │   ├── InvalidSample.vb
│   │   │   │       │   ├── ObjectGenerator.vb
│   │   │   │       │   ├── SampleDirection.vb
│   │   │   │       │   └── TextSample.vb
│   │   │   │       ├── Views/
│   │   │   │       │   ├── Help/
│   │   │   │       │   │   ├── Api.vbhtml
│   │   │   │       │   │   ├── DisplayTemplates/
│   │   │   │       │   │   │   ├── ApiGroup.vbhtml
│   │   │   │       │   │   │   ├── CollectionModelDescription.vbhtml
│   │   │   │       │   │   │   ├── ComplexTypeModelDescription.vbhtml
│   │   │   │       │   │   │   ├── DictionaryModelDescription.vbhtml
│   │   │   │       │   │   │   ├── EnumTypeModelDescription.vbhtml
│   │   │   │       │   │   │   ├── HelpPageApiModel.vbhtml
│   │   │   │       │   │   │   ├── ImageSample.vbhtml
│   │   │   │       │   │   │   ├── InvalidSample.vbhtml
│   │   │   │       │   │   │   ├── KeyValuePairModelDescription.vbhtml
│   │   │   │       │   │   │   ├── ModelDescriptionLink.vbhtml
│   │   │   │       │   │   │   ├── Parameters.vbhtml
│   │   │   │       │   │   │   ├── Samples.vbhtml
│   │   │   │       │   │   │   ├── SimpleTypeModelDescription.vbhtml
│   │   │   │       │   │   │   └── TextSample.vbhtml
│   │   │   │       │   │   ├── Index.vbhtml
│   │   │   │       │   │   └── ResourceModel.vbhtml
│   │   │   │       │   ├── Shared/
│   │   │   │       │   │   └── _Layout.vbhtml
│   │   │   │       │   ├── Web.config
│   │   │   │       │   └── _ViewStart.vbhtml
│   │   │   │       └── XmlDocumentationProvider.vb
│   │   │   ├── GlobalSuppressions.vb
│   │   │   ├── Properties/
│   │   │   │   └── AssemblyInfo.vb
│   │   │   ├── Settings.StyleCop
│   │   │   ├── WebApiHelpPage.VB.nuspec
│   │   │   ├── WebApiHelpPageVB.vbproj
│   │   │   └── packages.config
│   │   ├── WebApiHelpPage.csproj
│   │   ├── WebApiHelpPage.nuspec
│   │   ├── WebApiHelpPageMsBuildTasks.targets
│   │   └── packages.config
│   ├── WebHelpers.ruleset
│   ├── WebMatrix.Data/
│   │   ├── ConfigurationManagerWrapper.cs
│   │   ├── ConnectionConfiguration.cs
│   │   ├── ConnectionEventArgs.cs
│   │   ├── Database.cs
│   │   ├── DbProviderFactoryWrapper.cs
│   │   ├── DynamicRecord.cs
│   │   ├── GlobalSuppressions.cs
│   │   ├── IConfigurationManager.cs
│   │   ├── IConnectionConfiguration.cs
│   │   ├── IDbFileHandler.cs
│   │   ├── IDbProviderFactory.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── Resources/
│   │   │   ├── DataResources.Designer.cs
│   │   │   └── DataResources.resx
│   │   ├── SqlCeDbFileHandler.cs
│   │   ├── SqlServerDbFileHandler.cs
│   │   └── WebMatrix.Data.csproj
│   └── WebMatrix.WebData/
│       ├── ConfigUtil.cs
│       ├── DatabaseConnectionInfo.cs
│       ├── DatabaseWrapper.cs
│       ├── ExtendedMembershipProvider.cs
│       ├── FormsAuthenticationSettings.cs
│       ├── GlobalSuppressions.cs
│       ├── IDatabase.cs
│       ├── OAuthAccountData.cs
│       ├── PreApplicationStartCode.cs
│       ├── Properties/
│       │   └── AssemblyInfo.cs
│       ├── Resources/
│       │   ├── WebDataResources.Designer.cs
│       │   └── WebDataResources.resx
│       ├── SimpleMembershipProvider.cs
│       ├── SimpleMembershipProviderCasingBehavior.cs
│       ├── SimpleRoleProvider.cs
│       ├── WebMatrix.WebData.csproj
│       └── WebSecurity.cs
├── test/
│   ├── Common/
│   │   ├── AttributeListTest.cs
│   │   ├── CollectionExtensionsTest.cs
│   │   ├── DictionaryExtensionsTest.cs
│   │   ├── ErrorTest.cs
│   │   ├── HttpMethodHelperTest.cs
│   │   ├── ListWrapperCollectionTests.cs
│   │   ├── PathHelpersTest.cs
│   │   ├── PrefixContainerTest.cs
│   │   ├── Routing/
│   │   │   ├── DefaultInlineConstraintResolverTest.cs
│   │   │   ├── DirectRouteBuilderTests.cs
│   │   │   ├── InlineRouteTemplateParserTests.cs
│   │   │   ├── RouteConstraintsTests.cs
│   │   │   ├── RouteFactoryAttributeTests.cs
│   │   │   ├── RoutePrecedenceTests.cs
│   │   │   └── SubRouteCollectionTest.cs
│   │   ├── TaskHelpersExtensionsTest.cs
│   │   ├── TaskHelpersTest.cs
│   │   ├── TypeExtensionsTest.cs
│   │   └── UriQueryUtilityTest.cs
│   ├── Directory.Build.props
│   ├── Directory.Build.targets
│   ├── Microsoft.AspNet.Facebook.Test/
│   │   ├── App.config
│   │   ├── DefaultFacebookClientProviderTest.cs
│   │   ├── DefaultFacebookPermissionServiceTest.cs
│   │   ├── FacebookAuthorizeAttributeTest.cs
│   │   ├── FacebookAuthorizeFilterHookTest.cs
│   │   ├── FacebookAuthorizeFilterTest.cs
│   │   ├── FacebookClientExtensionsTest.cs
│   │   ├── FacebookConfigurationTest.cs
│   │   ├── FacebookContextModelBinderTest.cs
│   │   ├── FacebookQueryHelperTest.cs
│   │   ├── FacebookRealtimeControllerTest.cs
│   │   ├── FacebookRedirectContextModelBinderTest.cs
│   │   ├── GlobalFacebookConfigurationTest.cs
│   │   ├── Helpers/
│   │   │   ├── LocalFacebookClient.cs
│   │   │   └── MockHelpers.cs
│   │   ├── Microsoft.AspNet.Facebook.Test.csproj
│   │   ├── Types/
│   │   │   ├── FacebookPicture.cs
│   │   │   ├── SimpleUser.cs
│   │   │   ├── UserPhoto.cs
│   │   │   ├── UserStatus.cs
│   │   │   ├── UserTypeWithFieldModifiers.cs
│   │   │   ├── UserTypeWithIgnoredProperties.cs
│   │   │   ├── UserTypeWithRenamedProperties.cs
│   │   │   ├── UserTypesWithCycles.cs
│   │   │   └── UserWithFriends.cs
│   │   └── packages.config
│   ├── Microsoft.TestCommon/
│   │   ├── AppDomainUtils.cs
│   │   ├── Assert.cs
│   │   ├── CultureReplacer.cs
│   │   ├── DataAttribute.cs
│   │   ├── DictionaryEqualityComparer.cs
│   │   ├── Directory.Build.props
│   │   ├── EnumHelperTestBase.cs
│   │   ├── ExceptionAssertions.cs
│   │   ├── ExceptionUtility.cs
│   │   ├── FactAttribute.cs
│   │   ├── FactDiscoverer.cs
│   │   ├── ForceGCAttribute.cs
│   │   ├── InlineDataAttribute.cs
│   │   ├── MatrixTheoryDataSet.cs
│   │   ├── MemberHelper.cs
│   │   ├── Microsoft/
│   │   │   └── TestCommon/
│   │   │       ├── DataSets/
│   │   │       │   ├── CommonUnitTestDataSets.cs
│   │   │       │   ├── RefTypeTestData.cs
│   │   │       │   ├── TestData.cs
│   │   │       │   ├── TestDataHolder.cs
│   │   │       │   ├── TestDataVariations.cs
│   │   │       │   └── ValueTypeTestData.cs
│   │   │       ├── GenericTypeAssert.cs
│   │   │       ├── HttpAssert.cs
│   │   │       ├── MediaTypeAssert.cs
│   │   │       ├── MediaTypeHeaderValueComparer.cs
│   │   │       ├── ParsedMediaTypeHeaderValue.cs
│   │   │       ├── RegexReplacement.cs
│   │   │       ├── RuntimeEnvironment.cs
│   │   │       ├── SerializerAssert.cs
│   │   │       ├── StreamAssert.cs
│   │   │       ├── TaskAssert.cs
│   │   │       ├── TestDataSetAttribute.cs
│   │   │       ├── TimeoutConstant.cs
│   │   │       ├── TypeAssert.cs
│   │   │       ├── Types/
│   │   │       │   ├── ByteEnum.cs
│   │   │       │   ├── FlagsEnum.cs
│   │   │       │   ├── INameAndIdContainer.cs
│   │   │       │   ├── ISerializableType.cs
│   │   │       │   ├── LongEnum.cs
│   │   │       │   ├── SByteEnum.cs
│   │   │       │   ├── ShortEnum.cs
│   │   │       │   ├── SimpleEnum.cs
│   │   │       │   ├── UIntEnum.cs
│   │   │       │   └── UShortEnum.cs
│   │   │       └── XmlAssert.cs
│   │   ├── Microsoft.TestCommon.csproj
│   │   ├── Platform.cs
│   │   ├── PlatformInfo.cs
│   │   ├── PortReserver.cs
│   │   ├── PreAppStartTestHelper.cs
│   │   ├── PreserveSyncContextAttribute.cs
│   │   ├── PropertyDataAttribute.cs
│   │   ├── ReflectionAssert.cs
│   │   ├── ReplaceCultureAttribute.cs
│   │   ├── RestoreThreadPrincipalAttribute.cs
│   │   ├── SkippedXunitTestCase.cs
│   │   ├── TestFile.cs
│   │   ├── TestHelper.cs
│   │   ├── TheoryAttribute.cs
│   │   ├── TheoryDataSet.cs
│   │   ├── TheoryDiscoverer.cs
│   │   ├── ThreadPoolSyncContext.cs
│   │   ├── TraitAttribute.cs
│   │   ├── VersionTestHelper.cs
│   │   ├── WebUtils.cs
│   │   └── xunit.runner.json
│   ├── Microsoft.Web.Helpers.Test/
│   │   ├── AnalyticsTest.cs
│   │   ├── FacebookTest.cs
│   │   ├── FileUploadTest.cs
│   │   ├── GamerCardTest.cs
│   │   ├── GravatarTest.cs
│   │   ├── LinkShareTest.cs
│   │   ├── MapsTest.cs
│   │   ├── Microsoft.Web.Helpers.Test.csproj
│   │   ├── PreAppStartCodeTest.cs
│   │   ├── ReCaptchaTest.cs
│   │   ├── ThemesTest.cs
│   │   ├── UrlBuilderTest.cs
│   │   ├── VideoTest.cs
│   │   └── packages.config
│   ├── Microsoft.Web.Mvc.Test/
│   │   ├── Controls/
│   │   │   └── Test/
│   │   │       ├── DesignModeSite.cs
│   │   │       ├── DropDownListTest.cs
│   │   │       ├── MvcControlTest.cs
│   │   │       ├── MvcTestHelper.cs
│   │   │       └── ViewDataContainer.cs
│   │   ├── Microsoft.Web.Mvc.Test.csproj
│   │   ├── ModelBinding/
│   │   │   └── Test/
│   │   │       ├── ArrayModelBinderProviderTest.cs
│   │   │       ├── ArrayModelBinderTest.cs
│   │   │       ├── BinaryDataModelBinderProviderTest.cs
│   │   │       ├── BindingBehaviorAttributeTest.cs
│   │   │       ├── CollectionModelBinderProviderTest.cs
│   │   │       ├── CollectionModelBinderTest.cs
│   │   │       ├── CollectionModelBinderUtilTest.cs
│   │   │       ├── ComplexModelDtoModelBinderProviderTest.cs
│   │   │       ├── ComplexModelDtoModelBinderTest.cs
│   │   │       ├── ComplexModelDtoResultTest.cs
│   │   │       ├── ComplexModelDtoTest.cs
│   │   │       ├── DictionaryModelBinderProviderTest.cs
│   │   │       ├── DictionaryModelBinderTest.cs
│   │   │       ├── ExtensibleModelBinderAdapterTest.cs
│   │   │       ├── ExtensibleModelBindingContextTest.cs
│   │   │       ├── GenericModelBinderProviderTest.cs
│   │   │       ├── KeyValuePairModelBinderProviderTest.cs
│   │   │       ├── KeyValuePairModelBinderTest.cs
│   │   │       ├── KeyValuePairModelBinderUtilTest.cs
│   │   │       ├── ModelBinderConfigTest.cs
│   │   │       ├── ModelBinderProviderCollectionTest.cs
│   │   │       ├── ModelBinderProvidersTest.cs
│   │   │       ├── ModelBinderUtilTest.cs
│   │   │       ├── ModelValidationNodeTest.cs
│   │   │       ├── MutableObjectModelBinderProviderTest.cs
│   │   │       ├── MutableObjectModelBinderTest.cs
│   │   │       ├── SimpleModelBinderProviderTest.cs
│   │   │       ├── TypeConverterModelBinderProviderTest.cs
│   │   │       ├── TypeConverterModelBinderTest.cs
│   │   │       ├── TypeMatchModelBinderProviderTest.cs
│   │   │       └── TypeMatchModelBinderTest.cs
│   │   ├── Test/
│   │   │   ├── AcceptAttributeTest.cs
│   │   │   ├── AjaxOnlyAttributeTest.cs
│   │   │   ├── AreaHelpersTest.cs
│   │   │   ├── AsyncManagerExtensionsTest.cs
│   │   │   ├── ButtonTest.cs
│   │   │   ├── ContentTypeAttributeTest.cs
│   │   │   ├── ControllerExtensionsTest.cs
│   │   │   ├── CookieValueProviderFactoryTest.cs
│   │   │   ├── CopyAsyncParametersAttributeTest.cs
│   │   │   ├── CreditCardAttributeTest.cs
│   │   │   ├── CssExtensionsTests.cs
│   │   │   ├── DeserializeAttributeTest.cs
│   │   │   ├── DynamicReflectionObjectTest.cs
│   │   │   ├── DynamicViewDataDictionaryTest.cs
│   │   │   ├── DynamicViewPageTest.cs
│   │   │   ├── ElementalValueProviderTest.cs
│   │   │   ├── EmailAddressAttribueTest.cs
│   │   │   ├── ExpressionHelperTest.cs
│   │   │   ├── FileExtensionsAttributeTest.cs
│   │   │   ├── FormExtensionsTest.cs
│   │   │   ├── ImageExtensionsTest.cs
│   │   │   ├── MailToExtensionsTest.cs
│   │   │   ├── ModelCopierTest.cs
│   │   │   ├── MvcSerializerTest.cs
│   │   │   ├── RadioExtensionsTest.cs
│   │   │   ├── ReaderWriterCacheTest.cs
│   │   │   ├── RenderActionTest.cs
│   │   │   ├── ScriptExtensionsTest.cs
│   │   │   ├── SerializationExtensionsTest.cs
│   │   │   ├── ServerVariablesValueProviderFactoryTest.cs
│   │   │   ├── SessionValueProviderFactoryTest.cs
│   │   │   ├── SkipBindingAttributeTest.cs
│   │   │   ├── SubmitButtonExtensionsTest.cs
│   │   │   ├── SubmitImageExtensionsTest.cs
│   │   │   ├── TempDataValueProviderFactoryTest.cs
│   │   │   ├── TypeHelpersTest.cs
│   │   │   ├── UrlAttributeTest.cs
│   │   │   ├── ValueProviderUtilTest.cs
│   │   │   └── VersionTest.cs
│   │   └── packages.config
│   ├── Microsoft.Web.WebPages.OAuth.Test/
│   │   ├── Microsoft.Web.WebPages.OAuth.Test.csproj
│   │   ├── OAuthWebSecurityTest.cs
│   │   ├── PreAppStartCodeTest.cs
│   │   └── packages.config
│   ├── Settings.StyleCop
│   ├── System.Net.Http.Formatting.Test/
│   │   ├── ByteRangeStreamContentTest.cs
│   │   ├── CustomMultipartFormDataRemoteStreamProvider.cs
│   │   ├── DataSets/
│   │   │   ├── HttpTestData.cs
│   │   │   └── Types/
│   │   │       ├── DataContractEnum.cs
│   │   │       ├── DataContractType.cs
│   │   │       ├── DerivedDataContractType.cs
│   │   │       ├── DerivedFormUrlEncodedMediaTypeFormatter.cs
│   │   │       ├── DerivedJsonMediaTypeFormatter.cs
│   │   │       ├── DerivedWcfPocoType.cs
│   │   │       ├── DerivedXmlMediaTypeFormatter.cs
│   │   │       ├── DerivedXmlSerializableType.cs
│   │   │       ├── INotJsonSerializable.cs
│   │   │       ├── WcfPocoType.cs
│   │   │       └── XmlSerializableType.cs
│   │   ├── Formatting/
│   │   │   ├── BsonMediaTypeFormatterTests.cs
│   │   │   ├── BufferedMediaTypeFormatterTests.cs
│   │   │   ├── ContentNegotiationResultTest.cs
│   │   │   ├── DataContractJsonMediaTypeFormatterTests.cs
│   │   │   ├── DefaultContentNegotiatorTests.cs
│   │   │   ├── FormDataCollectionTests.cs
│   │   │   ├── FormUrlEncodedFromContentTests.cs
│   │   │   ├── FormUrlEncodedFromUriQueryTests.cs
│   │   │   ├── FormUrlEncodedJsonTests.cs
│   │   │   ├── FormUrlEncodedMediaTypeFormatterTests.cs
│   │   │   ├── JsonMediaTypeFormatterTests.cs
│   │   │   ├── JsonNetSerializationTest.cs
│   │   │   ├── JsonNetValidationTest.cs
│   │   │   ├── MediaTypeConstantsTests.cs
│   │   │   ├── MediaTypeFormatterCollectionTests.cs
│   │   │   ├── MediaTypeFormatterExtensionsTests.cs
│   │   │   ├── MediaTypeFormatterMatchTest.cs
│   │   │   ├── MediaTypeFormatterTestBase.cs
│   │   │   ├── MediaTypeFormatterTests.cs
│   │   │   ├── MediaTypeHeaderValueExtensionsTests.cs
│   │   │   ├── MediaTypeMappingTests.cs
│   │   │   ├── MediaTypeWithQualityHeaderValueComparerTests.cs
│   │   │   ├── ParsedMediaTypeHeaderValueTests.cs
│   │   │   ├── Parsers/
│   │   │   │   ├── FormUrlEncodedParserTests.cs
│   │   │   │   ├── HttpRequestHeaderParserTests.cs
│   │   │   │   ├── HttpRequestLineParserTests.cs
│   │   │   │   ├── HttpResponseHeaderParserTests.cs
│   │   │   │   ├── HttpStatusLineParserTests.cs
│   │   │   │   ├── InternetMessageFormatHeaderParserTests.cs
│   │   │   │   └── MimeMultipartParserTests.cs
│   │   │   ├── QueryStringMappingTests.cs
│   │   │   ├── RequestHeaderMappingTests.cs
│   │   │   ├── SerializerConsistencyTests.cs
│   │   │   ├── StringComparisonHelperTest.cs
│   │   │   ├── StringWithQualityHeaderValueComparerTests.cs
│   │   │   ├── XmlHttpRequestHeaderMappingTest.cs
│   │   │   ├── XmlMediaTypeFormatterTests.cs
│   │   │   └── XmlSerializerMediaTypeFormatterTests.cs
│   │   ├── FormattingUtilitiesTests.cs
│   │   ├── Handlers/
│   │   │   ├── HttpProgressEventArgsTest.cs
│   │   │   ├── ProgressContentTest.cs
│   │   │   ├── ProgressMessageHandlerTest.cs
│   │   │   ├── ProgressStreamTest.cs
│   │   │   └── ProgressWriteAsyncResultTest.cs
│   │   ├── Headers/
│   │   │   ├── CookieHeaderValueTest.cs
│   │   │   └── CookieStateTest.cs
│   │   ├── HttpClientExtensionsTest.cs
│   │   ├── HttpClientFactoryTest.cs
│   │   ├── HttpContentExtensionsTest.cs
│   │   ├── HttpContentFormDataExtensionsTest.cs
│   │   ├── HttpContentMessageExtensionsTests.cs
│   │   ├── HttpContentMultipartExtensionsTests.cs
│   │   ├── HttpHeaderExtensionsTest.cs
│   │   ├── HttpMessageContentTests.cs
│   │   ├── HttpRequestHeadersExtensionsTest.cs
│   │   ├── HttpRequestMessageCommonExtensionsTest.cs
│   │   ├── HttpResponseHeadersExtensionsTest.cs
│   │   ├── HttpUnsortedRequestTest.cs
│   │   ├── HttpUnsortedResponseTest.cs
│   │   ├── Internal/
│   │   │   ├── AsyncResultTest.cs
│   │   │   ├── ByteRangeStreamTest.cs
│   │   │   ├── ConcurrentDictionaryTests.cs
│   │   │   ├── DelegatingStreamTest.cs
│   │   │   ├── HttpValueCollectionTest.cs
│   │   │   ├── NonClosingDelegatingStreamTest.cs
│   │   │   └── TranscodingStreamTests.cs
│   │   ├── InvalidByteRangeExceptionTest.cs
│   │   ├── MimeBodyPartTest.cs
│   │   ├── Mocks/
│   │   │   ├── MockAsyncCallback.cs
│   │   │   ├── MockCompletedAsyncResult.cs
│   │   │   ├── MockContentNegotiator.cs
│   │   │   ├── MockDelegatingHandler.cs
│   │   │   ├── MockDelegatingStream.cs
│   │   │   ├── MockHttpContent.cs
│   │   │   ├── MockMediaTypeFormatter.cs
│   │   │   ├── MockMediaTypeMapping.cs
│   │   │   ├── MockNonClosingDelegatingStream.cs
│   │   │   ├── MockProgressEventHandler.cs
│   │   │   └── TestableHttpMessageHandler.cs
│   │   ├── MultipartFileDataTest.cs
│   │   ├── MultipartFileStreamProviderTests.cs
│   │   ├── MultipartFormDataRemoteStreamProviderTests.cs
│   │   ├── MultipartFormDataStreamProviderTests.cs
│   │   ├── MultipartMemoryStreamProviderTests.cs
│   │   ├── MultipartRelatedStreamProviderTests.cs
│   │   ├── MultipartRemoteFileDataTests.cs
│   │   ├── MultipartStreamProviderTestBase.cs
│   │   ├── ObjectContentOfTTests.cs
│   │   ├── ObjectContentTests.cs
│   │   ├── ParserData.cs
│   │   ├── PushStreamContentTest.cs
│   │   ├── RemoteStreamInfoTests.cs
│   │   ├── System.Net.Http.Formatting.Test.csproj
│   │   ├── UriExtensionsTests.cs
│   │   ├── UriQueryDataSet.cs
│   │   └── packages.config
│   ├── System.Net.Http.Formatting.ns1_3.Test/
│   │   └── System.Net.Http.Formatting.ns1_3.Test.csproj
│   ├── System.Net.Http.Formatting.ns2_0.Test/
│   │   └── System.Net.Http.Formatting.ns2_0.Test.csproj
│   ├── System.Web.Cors.Test/
│   │   ├── CorsEngineTest.cs
│   │   ├── CorsPolicyTest.cs
│   │   ├── CorsRequestContextTest.cs
│   │   ├── CorsResultTest.cs
│   │   ├── System.Web.Cors.Test.csproj
│   │   └── packages.config
│   ├── System.Web.Helpers.Test/
│   │   ├── ChartTest.cs
│   │   ├── ConversionUtilTest.cs
│   │   ├── CryptoTest.cs
│   │   ├── DynamicDictionary.cs
│   │   ├── DynamicHelperTest.cs
│   │   ├── DynamicWrapper.cs
│   │   ├── HelperResultTest.cs
│   │   ├── JsonTest.cs
│   │   ├── ObjectInfoTest.cs
│   │   ├── PreComputedGridDataSourceTest.cs
│   │   ├── ServerInfoTest.cs
│   │   ├── System.Web.Helpers.Test.csproj
│   │   ├── TestFiles/
│   │   │   └── xhtml11-flat.dtd
│   │   ├── WebCacheTest.cs
│   │   ├── WebGridDataSourceTest.cs
│   │   ├── WebGridTest.cs
│   │   ├── WebImageTest.cs
│   │   ├── WebMailTest.cs
│   │   ├── XhtmlAssert.cs
│   │   └── packages.config
│   ├── System.Web.Http.Cors.Test/
│   │   ├── AttributeBasedPolicyProviderFactoryTest.cs
│   │   ├── Controllers/
│   │   │   ├── DefaultController.cs
│   │   │   ├── ExternalActionSelectorAttribute.cs
│   │   │   ├── PerControllerConfigController.cs
│   │   │   ├── SampleController.cs
│   │   │   └── ThrowingController.cs
│   │   ├── CorsHttpConfigurationExtensionsTest.cs
│   │   ├── CorsHttpRequestMessageExtensionsTest.cs
│   │   ├── CorsHttpResponseMessageExtensionsTest.cs
│   │   ├── CorsMessageHandlerTest.cs
│   │   ├── DisableCorsAttributeTest.cs
│   │   ├── EnableCorsAttributeTest.cs
│   │   ├── HttpRequestMessageExtensions.cs
│   │   ├── System.Web.Http.Cors.Test.csproj
│   │   ├── Tracing/
│   │   │   ├── CorsEngineTracerTest.cs
│   │   │   ├── CorsPolicyProviderFactoryTracerTest.cs
│   │   │   └── CorsPolicyProviderTracerTest.cs
│   │   └── packages.config
│   ├── System.Web.Http.Integration.Test/
│   │   ├── ApiExplorer/
│   │   │   ├── ApiExplorerSettingsTest.cs
│   │   │   ├── AttributeRoutesTest.cs
│   │   │   ├── Controllers/
│   │   │   │   ├── AmbiguousActionController.cs
│   │   │   │   ├── AttributeRouteControllers.cs
│   │   │   │   ├── DocumentationController.cs
│   │   │   │   ├── HiddenActionController.cs
│   │   │   │   ├── HiddenController.cs
│   │   │   │   ├── ItemController.cs
│   │   │   │   ├── OverloadsController.cs
│   │   │   │   ├── ParameterSourceController.cs
│   │   │   │   └── ResponseTypeController.cs
│   │   │   ├── DocumentationProviders/
│   │   │   │   └── AttributeDocumentationProvider.cs
│   │   │   ├── DocumentationTest.cs
│   │   │   ├── Formatters/
│   │   │   │   └── ItemFormatter.cs
│   │   │   ├── FormattersTest.cs
│   │   │   ├── ParameterSourceTest.cs
│   │   │   ├── ResponseTypeAttributeTest.cs
│   │   │   ├── RouteConstraintsTest.cs
│   │   │   └── RoutesTest.cs
│   │   ├── ContentNegotiation/
│   │   │   ├── AcceptHeaderTests.cs
│   │   │   ├── ConnegController.cs
│   │   │   ├── ConnegItem.cs
│   │   │   ├── ContentNegotiationTestBase.cs
│   │   │   ├── CustomFormatterTests.cs
│   │   │   ├── DefaultContentNegotiatorTests.cs
│   │   │   └── HttpResponseReturnTests.cs
│   │   ├── Controllers/
│   │   │   ├── ActionAttributesTest.cs
│   │   │   ├── ActionReachabilityTest.cs
│   │   │   ├── ApiControllerActionSelectorTest.cs
│   │   │   ├── Apis/
│   │   │   │   ├── ActionAttributeTestController.cs
│   │   │   │   ├── EnumParameterOverloadsController.cs
│   │   │   │   ├── HeaderValueProviderFactory.cs
│   │   │   │   ├── ParameterAttributeController.cs
│   │   │   │   ├── ParameterTestController.cs
│   │   │   │   ├── RegularConfigController.cs
│   │   │   │   ├── SpecialConfigController.cs
│   │   │   │   ├── TestController.cs
│   │   │   │   ├── User.cs
│   │   │   │   ├── UserAddress.cs
│   │   │   │   ├── UsersController.cs
│   │   │   │   └── ValuesController.cs
│   │   │   ├── ControllerConfigurationTest.cs
│   │   │   └── Helpers/
│   │   │       └── ApiControllerHelper.cs
│   │   ├── Dispatcher/
│   │   │   └── CustomHttpControllerTypeResolverTest.cs
│   │   ├── ExceptionHandling/
│   │   │   ├── DuplicateControllers.cs
│   │   │   ├── ExceptionController.cs
│   │   │   ├── ExceptionHandlingTest.cs
│   │   │   ├── HttpResponseExceptionTest.cs
│   │   │   └── IncludeErrorDetailTest.cs
│   │   ├── ModelBinding/
│   │   │   ├── BodyBindingTests.cs
│   │   │   ├── CustomBindingTests.cs
│   │   │   ├── DefaultActionValueBinderTest.cs
│   │   │   ├── HttpContentBindingTests.cs
│   │   │   ├── ModelBindingController.cs
│   │   │   ├── ModelBindingTests.cs
│   │   │   ├── QueryStringBindingTests.cs
│   │   │   └── RouteBindingTests.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── System.Web.Http.Integration.Test.csproj
│   │   ├── Tracing/
│   │   │   ├── ITestTraceWriter.cs
│   │   │   ├── MemoryTraceWriter.cs
│   │   │   ├── NeverTracesTraceWriter.cs
│   │   │   └── TracingTest.cs
│   │   ├── Util/
│   │   │   ├── ApiExplorerHelper.cs
│   │   │   ├── ContextUtil.cs
│   │   │   ├── ConvertToStreamMessageHandler.cs
│   │   │   ├── HttpServerTestBase.cs
│   │   │   └── ScenarioHelper.cs
│   │   └── packages.config
│   ├── System.Web.Http.Owin.Test/
│   │   ├── ExceptionHandling/
│   │   │   ├── DefaultExceptionHandlerTests.cs
│   │   │   └── EmptyExceptionLoggerTests.cs
│   │   ├── HostAuthenticationAttributeTest.cs
│   │   ├── HostAuthenticationFilterTest.cs
│   │   ├── HttpMessageHandlerAdapterTest.cs
│   │   ├── HttpMessageHandlerExtensions.cs
│   │   ├── HttpMessageHandlerOptionsTests.cs
│   │   ├── IgnoreRouteTest.cs
│   │   ├── NonOwnedStreamTests.cs
│   │   ├── OwinBufferPolicySelectorTest.cs
│   │   ├── OwinExceptionCatchBlocksTests.cs
│   │   ├── OwinHostIntegrationTest.cs
│   │   ├── OwinHttpConfigurationExtensionsTest.cs
│   │   ├── OwinHttpRequestContextTests.cs
│   │   ├── OwinHttpRequestMessageExtensionsTest.cs
│   │   ├── OwinRequestExtensionsTests.cs
│   │   ├── OwinResponseExtensionsTests.cs
│   │   ├── PassiveAuthenticationMessageHandlerTest.cs
│   │   ├── System.Web.Http.Owin.Test.csproj
│   │   ├── WebApiAppBuilderExtensionsTest.cs
│   │   └── packages.config
│   ├── System.Web.Http.SelfHost.Test/
│   │   ├── Authentication/
│   │   │   ├── BasicOverHttpTest.cs
│   │   │   ├── CustomMessageHandler.cs
│   │   │   ├── CustomUsernamePasswordValidator.cs
│   │   │   ├── RequireAdminAttribute.cs
│   │   │   └── SampleController.cs
│   │   ├── Channels/
│   │   │   └── HttpBindingSecurityModeHelperTest.cs
│   │   ├── DeeplyNestedTypeTests.cs
│   │   ├── HttpSelfHostConfigurationTest.cs
│   │   ├── HttpSelfHostResponseTest.cs
│   │   ├── HttpSelfHostServerTest.cs
│   │   ├── MaxHttpCollectionKeyTests.cs
│   │   ├── SelfHostHttpRequestContextTests.cs
│   │   ├── ServiceModel/
│   │   │   ├── HostNameComparisonModeHelperTest.cs
│   │   │   └── TransferModeHelperTest.cs
│   │   ├── System.Web.Http.SelfHost.Test.csproj
│   │   └── packages.config
│   ├── System.Web.Http.SignalR.Test/
│   │   ├── HubControllerBaseTest.cs
│   │   ├── HubControllerOfTHubTest.cs
│   │   ├── HubControllerTest.cs
│   │   ├── System.Web.Http.SignalR.Test.csproj
│   │   └── packages.config
│   ├── System.Web.Http.Test/
│   │   ├── AuthorizeAttributeTest.cs
│   │   ├── Batch/
│   │   │   ├── BatchHttpRequestContextTests.cs
│   │   │   ├── BatchHttpRequestMessageExtensionsTest.cs
│   │   │   ├── BatchLearningTests.cs
│   │   │   ├── DefaultHttpBatchHandlerTest.cs
│   │   │   └── HttpBatchHandlerTest.cs
│   │   ├── Common/
│   │   │   └── TraceWriterExceptionMapperTest.cs
│   │   ├── Controllers/
│   │   │   ├── ActionFilterResultTests.cs
│   │   │   ├── ApiControllerActionInvokerTest.cs
│   │   │   ├── ApiControllerActionSelectorTest.cs
│   │   │   ├── ApiControllerTest.cs
│   │   │   ├── ApiControllerTestabilityTest.cs
│   │   │   ├── Apis/
│   │   │   │   ├── User.cs
│   │   │   │   ├── UsersController.cs
│   │   │   │   └── UsersRpcController.cs
│   │   │   ├── AuthenticationFilterResultTests.cs
│   │   │   ├── AuthorizationFilterResultTests.cs
│   │   │   ├── ExceptionFilterResultTests.cs
│   │   │   ├── FilterGroupingTests.cs
│   │   │   ├── HttpActionContextTest.cs
│   │   │   ├── HttpActionDescriptorTest.cs
│   │   │   ├── HttpConfigurationTest.cs
│   │   │   ├── HttpControllerContextTest.cs
│   │   │   ├── HttpControllerDescriptorTest.cs
│   │   │   ├── HttpParameterBindingTest.cs
│   │   │   ├── HttpParameterDescriptorTest.cs
│   │   │   ├── ParameterBindingExtensionsTest.cs
│   │   │   ├── ReflectedHttpActionDescriptorTest.cs
│   │   │   ├── ReflectedHttpParameterDescriptorTest.cs
│   │   │   ├── RequestBackedHttpRequestContextTests.cs
│   │   │   ├── ResponseMessageResultConverterTest.cs
│   │   │   ├── ValueResultConverterTest.cs
│   │   │   └── VoidResultConverterTest.cs
│   │   ├── Description/
│   │   │   ├── ApiExplorerTest.cs
│   │   │   └── ApiParameterDescriptionTest.cs
│   │   ├── Dispatcher/
│   │   │   ├── DefaultAssembliesResolverTest.cs
│   │   │   ├── DefaultHttpControllerActivatorTest.cs
│   │   │   ├── DefaultHttpControllerSelectorTest.cs
│   │   │   ├── DefaultHttpControllerTypeResolverTest.cs
│   │   │   ├── HttpControllerDispatcherTest.cs
│   │   │   ├── HttpErrorTest.cs
│   │   │   └── HttpRoutingDispatcherTest.cs
│   │   ├── ExceptionHandling/
│   │   │   ├── CompositeExceptionLoggerTests.cs
│   │   │   ├── DefaultExceptionHandlerTests.cs
│   │   │   ├── EmptyExceptionHandlerTests.cs
│   │   │   ├── ExceptionCatchBlocksTests.cs
│   │   │   ├── ExceptionContextCatchBlockTests.cs
│   │   │   ├── ExceptionContextTests.cs
│   │   │   ├── ExceptionHandlerContextTests.cs
│   │   │   ├── ExceptionHandlerExtensionsTests.cs
│   │   │   ├── ExceptionHandlerTests.cs
│   │   │   ├── ExceptionLoggerContextTests.cs
│   │   │   ├── ExceptionLoggerExtensionsTests.cs
│   │   │   ├── ExceptionLoggerTests.cs
│   │   │   ├── ExceptionServicesTests.cs
│   │   │   └── LastChanceExceptionHandlerTests.cs
│   │   ├── Filters/
│   │   │   ├── ActionDescriptorFilterProviderTest.cs
│   │   │   ├── ActionFilterAttributeTest.cs
│   │   │   ├── AuthorizationFilterAttributeTest.cs
│   │   │   ├── ConfigurationFilterProviderTest.cs
│   │   │   ├── ExceptionFilterAttributeTest.cs
│   │   │   ├── FilterAttributeTest.cs
│   │   │   ├── FilterInfoComparerTest.cs
│   │   │   ├── FilterInfoTest.cs
│   │   │   ├── HttpActionExecutedContextTest.cs
│   │   │   ├── HttpAuthenticationChallengeContextTests.cs
│   │   │   ├── HttpAuthenticationContextTests.cs
│   │   │   └── HttpFilterCollectionTest.cs
│   │   ├── Hosting/
│   │   │   ├── HttpMessageHandlerExtensions.cs
│   │   │   ├── HttpRouteTest.cs
│   │   │   └── SuppressHostPrincipalMessageHandlerTest.cs
│   │   ├── HttpConfigurationExtensionsTest.cs
│   │   ├── HttpErrorKeysTest.cs
│   │   ├── HttpMessageHandlerExtensions.cs
│   │   ├── HttpRequestMessageExtensionsTest.cs
│   │   ├── HttpResponseExceptionTest.cs
│   │   ├── HttpResponseMessageExtensionsTest.cs
│   │   ├── HttpRouteCollectionExtensionsTest.cs
│   │   ├── HttpRouteCollectionTest.cs
│   │   ├── HttpServerTest.cs
│   │   ├── Internal/
│   │   │   ├── CollectionModelBinderUtilTest.cs
│   │   │   └── TypeActivatorTest.cs
│   │   ├── Metadata/
│   │   │   ├── ModelMetadataTest.cs
│   │   │   └── Providers/
│   │   │       ├── AssociatedMetadataProviderTest.cs
│   │   │       └── DataAnnotationsModelMetadataProviderTest.cs
│   │   ├── ModelBinding/
│   │   │   ├── Binders/
│   │   │   │   ├── ArrayModelBinderProviderTest.cs
│   │   │   │   ├── ArrayModelBinderTest.cs
│   │   │   │   ├── CollectionModelBinderProviderTest.cs
│   │   │   │   ├── CollectionModelBinderTest.cs
│   │   │   │   ├── ComplexModelDtoModelBinderProviderTest.cs
│   │   │   │   ├── ComplexModelDtoModelBinderTest.cs
│   │   │   │   ├── ComplexModelDtoResultTest.cs
│   │   │   │   ├── ComplexModelDtoTest.cs
│   │   │   │   ├── DictionaryModelBinderProviderTest.cs
│   │   │   │   ├── DictionaryModelBinderTest.cs
│   │   │   │   ├── KeyValuePairModelBinderProviderTest.cs
│   │   │   │   ├── KeyValuePairModelBinderTest.cs
│   │   │   │   ├── KeyValuePairModelBinderUtilTest.cs
│   │   │   │   ├── MutableObjectModelBinderProviderTest.cs
│   │   │   │   ├── MutableObjectModelBinderTest.cs
│   │   │   │   ├── SimpleModelBinderProviderTest.cs
│   │   │   │   ├── TypeConverterModelBinderProviderTest.cs
│   │   │   │   ├── TypeConverterModelBinderTest.cs
│   │   │   │   ├── TypeMatchModelBinderProviderTest.cs
│   │   │   │   └── TypeMatchModelBinderTest.cs
│   │   │   ├── CompositeModelBinderTest.cs
│   │   │   ├── DefaultActionValueBinderTest.cs
│   │   │   ├── FormDataCollectionExtensionsTest.cs
│   │   │   ├── FormatterParameterBindingTest.cs
│   │   │   ├── HttpBindingBehaviorAttributeTest.cs
│   │   │   ├── HttpParameterBindingExtensionsTest.cs
│   │   │   ├── ModelBinderAttributeTest.cs
│   │   │   ├── ModelBinderConfigTest.cs
│   │   │   ├── ModelBindingContextTest.cs
│   │   │   ├── ModelBindingEndToEndTests.cs
│   │   │   ├── ModelBindingUtilTest.cs
│   │   │   ├── ParameterBindingProvidersTest.cs
│   │   │   └── SharedModels/
│   │   │       ├── Address.cs
│   │   │       ├── PeopleModel.cs
│   │   │       ├── Person.cs
│   │   │       ├── StreetAddress.cs
│   │   │       └── User.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── Resources.Designer.cs
│   │   ├── Resources.resx
│   │   ├── Results/
│   │   │   ├── BadRequestErrorMessageResultTests.cs
│   │   │   ├── BadRequestResultTests.cs
│   │   │   ├── ConflictResultTests.cs
│   │   │   ├── CreatedAtRouteNegotiatedContentResultTests.cs
│   │   │   ├── CreatedNegotiatedContentResultTests.cs
│   │   │   ├── ExceptionResultTests.cs
│   │   │   ├── FormattedContentResultTests.cs
│   │   │   ├── InternalServerErrorResultTests.cs
│   │   │   ├── InvalidModelStateResultTests.cs
│   │   │   ├── JsonResultTests.cs
│   │   │   ├── NegotiatedContentResultTests.cs
│   │   │   ├── NotFoundResultTests.cs
│   │   │   ├── OkNegotiatedContentResultTests.cs
│   │   │   ├── OkResultTests.cs
│   │   │   ├── RedirectResultTests.cs
│   │   │   ├── RedirectToRouteResultTests.cs
│   │   │   ├── ResponseMessageResultTests.cs
│   │   │   ├── StatusCodeResultTests.cs
│   │   │   └── UnauthorizedResultTests.cs
│   │   ├── Routing/
│   │   │   ├── AttributeRoutingTest.cs
│   │   │   ├── DefaultDirectRouteProviderTests.cs
│   │   │   ├── DirectRouteProviderContextTests.cs
│   │   │   ├── HttpRouteTest.cs
│   │   │   ├── HttpRouteValueDictionaryTest.cs
│   │   │   ├── LinkGenerationRouteTests.cs
│   │   │   ├── MediaTypeFormatterExtensionsTests.cs
│   │   │   ├── RouteAttributeTests.cs
│   │   │   ├── UriPathExtensionMappingTests.cs
│   │   │   └── UrlHelperTest.cs
│   │   ├── Services/
│   │   │   ├── ControllerServicesTests.cs
│   │   │   ├── DecoratorTests.cs
│   │   │   ├── DefaultServicesTests.cs
│   │   │   └── ServicesExtensionsTests.cs
│   │   ├── System.Web.Http.Test.csproj
│   │   ├── Tracing/
│   │   │   ├── FormattingUtilitiesTest.cs
│   │   │   ├── HttpRequestMessageExtensionsTest.cs
│   │   │   ├── ITraceWriterExtensionsTest.cs
│   │   │   ├── TestTraceWriter.cs
│   │   │   ├── TraceKindHelperTest.cs
│   │   │   ├── TraceLevelHelperTest.cs
│   │   │   ├── TraceManagerTest.cs
│   │   │   ├── TraceRecordComparer.cs
│   │   │   ├── TraceRecordTest.cs
│   │   │   ├── TracerCorrectnessTest.cs
│   │   │   └── Tracers/
│   │   │       ├── ActionFilterAttributeTracerTest.cs
│   │   │       ├── ActionFilterTracerTest.cs
│   │   │       ├── ActionValueBinderTracerTest.cs
│   │   │       ├── AuthenticationFilterTracerTests.cs
│   │   │       ├── AuthorizationFilterAttributeTracerTest.cs
│   │   │       ├── AuthorizationFilterTracerTest.cs
│   │   │       ├── BufferedMediaTypeFormatterTracerTest.cs
│   │   │       ├── ContentNegotiatorTracerTest.cs
│   │   │       ├── DefaultHttpControllerTypeResolverTracerTest.cs
│   │   │       ├── ExceptionFilterAttributeTracerTest.cs
│   │   │       ├── ExceptionFilterTracerTest.cs
│   │   │       ├── FilterTracerTest.cs
│   │   │       ├── FormUrlEncodedMediaTypeFormatterTracerTest.cs
│   │   │       ├── FormatterParameterBindingTracerTest.cs
│   │   │       ├── HttpActionBindingTracerTest.cs
│   │   │       ├── HttpActionDescriptorTracerTest.cs
│   │   │       ├── HttpActionInvokerTracerTest.cs
│   │   │       ├── HttpActionSelectorTracerTest.cs
│   │   │       ├── HttpControllerActivatorTracerTest.cs
│   │   │       ├── HttpControllerDescriptorTracerTest.cs
│   │   │       ├── HttpControllerSelectorTracerTest.cs
│   │   │       ├── HttpControllerTracerTest.cs
│   │   │       ├── HttpParameterBindingTracerTest.cs
│   │   │       ├── JsonMediaTypeFormatterTracerTest.cs
│   │   │       ├── MediaTypeFormatterTracerTest.cs
│   │   │       ├── MediaTypeFormatterTracerTestBase.cs
│   │   │       ├── MessageHandlerTracerTest.cs
│   │   │       ├── OverrideFilterTracerTests.cs
│   │   │       ├── ReadWriteMediaTypeFormatterTracerTestBase.cs
│   │   │       ├── RequestMessageHandlerTracerTest.cs
│   │   │       └── XmlMediaTypeFormatterTracerTest.cs
│   │   ├── Util/
│   │   │   ├── ContextUtil.cs
│   │   │   └── SimpleHttpValueProvider.cs
│   │   ├── Validation/
│   │   │   ├── DefaultBodyModelValidatorTest.cs
│   │   │   ├── ModelStateFormatterLoggerTest.cs
│   │   │   ├── ModelValidationNodeTest.cs
│   │   │   ├── ModelValidationRequiredMemberSelectorTest.cs
│   │   │   ├── ModelValidationResultTest.cs
│   │   │   ├── ModelValidatorTest.cs
│   │   │   ├── Providers/
│   │   │   │   ├── AssociatedValidatorProviderTest.cs
│   │   │   │   ├── DataAnnotationsModelValidatorProviderTest.cs
│   │   │   │   ├── DataMemberModelValidatorProviderTest.cs
│   │   │   │   └── InvalidModelValidatorProviderTest.cs
│   │   │   ├── ReferenceEqualityComparerTest.cs
│   │   │   └── Validators/
│   │   │       ├── DataAnnotationsModelValidatorTest.cs
│   │   │       └── ErrorModelValidatorTest.cs
│   │   ├── ValueProviders/
│   │   │   ├── Providers/
│   │   │   │   ├── ElementalValueProviderTest.cs
│   │   │   │   ├── NameValuePairsValueProviderTest.cs
│   │   │   │   ├── QueryStringValueProviderFactoryTest.cs
│   │   │   │   ├── QueryStringValueProviderTest.cs
│   │   │   │   ├── RouteDataValueProviderFactoryTest.cs
│   │   │   │   └── RouteDataValueProviderTest.cs
│   │   │   └── ValueProviderResultTest.cs
│   │   └── packages.config
│   ├── System.Web.Http.Tracing.Test/
│   │   ├── HttpConfigurationTracingExtensionsTest.cs
│   │   ├── System.Web.Http.Tracing.Test.csproj
│   │   ├── SystemDiagnosticsTraceWriterTest.cs
│   │   └── packages.config
│   ├── System.Web.Http.WebHost.Test/
│   │   ├── BatchingTest.cs
│   │   ├── GlobalConfigurationTest.cs
│   │   ├── HttpControllerHandlerTest.cs
│   │   ├── HttpRequestMessageExtensions.cs
│   │   ├── Properties/
│   │   │   └── AssemblyInfo.cs
│   │   ├── RouteCollectionExtensionsTest.cs
│   │   ├── Routing/
│   │   │   ├── HostedHttpRouteCollectionTest.cs
│   │   │   ├── HostedUrlHelperTest.cs
│   │   │   ├── HttpContextBaseExtensionsTest.cs
│   │   │   ├── HttpRequestMessageWrapperTest.cs
│   │   │   ├── HttpRouteExceptionHandlerTests.cs
│   │   │   ├── HttpRouteExceptionRouteHandlerTests.cs
│   │   │   └── HttpWebRouteTests.cs
│   │   ├── SeekableBufferedRequestStreamTest.cs
│   │   ├── SuppressFormsAuthRedirectHelperTest.cs
│   │   ├── System.Web.Http.WebHost.Test.csproj
│   │   ├── WebHostBufferPolicySelectorTest.cs
│   │   ├── WebHostExceptionCatchBlocksTests.cs
│   │   ├── WebHostExceptionHandlerTests.cs
│   │   ├── WebHostHttpRequestContextTests.cs
│   │   └── packages.config
│   ├── System.Web.Mvc.Test/
│   │   ├── Ajax/
│   │   │   └── Test/
│   │   │       ├── AjaxExtensionsTest.cs
│   │   │       └── AjaxOptionsTest.cs
│   │   ├── Async/
│   │   │   └── Test/
│   │   │       ├── AsyncActionDescriptorTest.cs
│   │   │       ├── AsyncActionMethodSelectorTest.cs
│   │   │       ├── AsyncControllerActionInvokerTest.cs
│   │   │       ├── AsyncManagerTest.cs
│   │   │       ├── AsyncResultWrapperTest.cs
│   │   │       ├── MockAsyncResult.cs
│   │   │       ├── OperationCounterTest.cs
│   │   │       ├── ReflectedAsyncActionDescriptorTest.cs
│   │   │       ├── ReflectedAsyncControllerDescriptorTest.cs
│   │   │       ├── SignalContainer.cs
│   │   │       ├── SimpleAsyncResultTest.cs
│   │   │       ├── SingleEntryGateTest.cs
│   │   │       ├── SynchronizationContextUtilTest.cs
│   │   │       ├── SynchronousOperationExceptionTest.cs
│   │   │       ├── TaskAsyncActionDescriptorTest.cs
│   │   │       ├── TaskWrapperAsyncResultTest.cs
│   │   │       └── TriggerListenerTest.cs
│   │   ├── ExpressionUtil/
│   │   │   └── Test/
│   │   │       ├── BinaryExpressionFingerprintTest.cs
│   │   │       ├── CachedExpressionCompilerTest.cs
│   │   │       ├── ConditionalExpressionFingerprintTest.cs
│   │   │       ├── ConstantExpressionFingerprintTest.cs
│   │   │       ├── DefaultExpressionFingerprintTest.cs
│   │   │       ├── DummyExpressionFingerprint.cs
│   │   │       ├── ExpressionFingerprintTest.cs
│   │   │       ├── FingerprintingExpressionVisitorTest.cs
│   │   │       ├── HoistingExpressionVisitorTest.cs
│   │   │       ├── IndexExpressionFingerprintTest.cs
│   │   │       ├── LambdaExpressionFingerprintTest.cs
│   │   │       ├── MemberExpressionFingerprintTest.cs
│   │   │       ├── MethodCallExpressionFingerprintTest.cs
│   │   │       ├── ParameterExpressionFingerprintTest.cs
│   │   │       ├── TypeBinaryExpressionFingerprintTest.cs
│   │   │       └── UnaryExpressionFingerprintTest.cs
│   │   ├── Html/
│   │   │   └── Test/
│   │   │       ├── ChildActionExtensionsTest.cs
│   │   │       ├── DefaultDisplayTemplatesTest.cs
│   │   │       ├── DefaultEditorTemplatesTest.cs
│   │   │       ├── DisplayExtensionsTest.cs
│   │   │       ├── DisplayNameExtensionsTest.cs
│   │   │       ├── DisplayTextExtensionsTest.cs
│   │   │       ├── EditorExtensionsTest.cs
│   │   │       ├── EncodedDataSets.cs
│   │   │       ├── EnumHelperTest.cs
│   │   │       ├── FormExtensionsTest.cs
│   │   │       ├── InputExtensionsTest.cs
│   │   │       ├── LabelExtensionsTest.cs
│   │   │       ├── LinkExtensionsTest.cs
│   │   │       ├── MetadataOverrideScope.cs
│   │   │       ├── MvcFormTest.cs
│   │   │       ├── NameExtensionsTest.cs
│   │   │       ├── PartialExtensionsTest.cs
│   │   │       ├── RenderPartialExtensionsTest.cs
│   │   │       ├── SelectExtensionsTest.cs
│   │   │       ├── TemplateHelpersSafeScope.cs
│   │   │       ├── TemplateHelpersTest.cs
│   │   │       ├── TextAreaExtensionsTest.cs
│   │   │       ├── ValidationExtensionsTest.cs
│   │   │       └── ValueExtensionsTest.cs
│   │   ├── Properties/
│   │   │   ├── AssemblyInfo.cs
│   │   │   ├── Resources.Designer.cs
│   │   │   └── Resources.resx
│   │   ├── Razor/
│   │   │   └── Test/
│   │   │       ├── MvcCSharpRazorCodeGeneratorTest.cs
│   │   │       ├── MvcCSharpRazorCodeParserTest.cs
│   │   │       ├── MvcVBRazorCodeParserTest.cs
│   │   │       └── MvcWebPageRazorHostTest.cs
│   │   ├── Routing/
│   │   │   ├── AttributeRoutingLinkGenerationTest.cs
│   │   │   ├── AttributeRoutingMapperTest.cs
│   │   │   ├── AttributeRoutingTest.cs
│   │   │   ├── DefaultDirectRouteProviderTest.cs
│   │   │   ├── DirectRouteCandidateTest.cs
│   │   │   ├── DirectRouteTestHelpers.cs
│   │   │   ├── RouteAttributeTests.cs
│   │   │   └── RouteCollectionAttributeRoutingExtensionsTests.cs
│   │   ├── System.Web.Mvc.Test.csproj
│   │   ├── Test/
│   │   │   ├── AcceptVerbsAttributeTest.cs
│   │   │   ├── ActionDescriptorTest.cs
│   │   │   ├── ActionExecutedContextTest.cs
│   │   │   ├── ActionExecutingContextTest.cs
│   │   │   ├── ActionFilterAttributeTest.cs
│   │   │   ├── ActionMethodDispatcherCacheTest.cs
│   │   │   ├── ActionMethodDispatcherTest.cs
│   │   │   ├── ActionMethodSelectorTest.cs
│   │   │   ├── ActionNameAttributeTest.cs
│   │   │   ├── AdditionalMetadataAttributeTest.cs
│   │   │   ├── AjaxHelperOfTModelTest.cs
│   │   │   ├── AjaxHelperTest.cs
│   │   │   ├── AjaxRequestExtensionsTest.cs
│   │   │   ├── AllowHtmlAttributeTest.cs
│   │   │   ├── AreaHelpersTest.cs
│   │   │   ├── AreaRegistrationContextTest.cs
│   │   │   ├── AreaRegistrationTest.cs
│   │   │   ├── AssociatedMetadataProviderTest.cs
│   │   │   ├── AssociatedValidatorProviderTest.cs
│   │   │   ├── AsyncControllerTest.cs
│   │   │   ├── AsyncTimeoutAttributeTest.cs
│   │   │   ├── AuthorizationContextTest.cs
│   │   │   ├── AuthorizeAttributeTest.cs
│   │   │   ├── BindAttributeTest.cs
│   │   │   ├── BuildManagerCompiledViewTest.cs
│   │   │   ├── BuildManagerViewEngineTest.cs
│   │   │   ├── ByteArrayModelBinderTest.cs
│   │   │   ├── CachedAssociatedMetadataProviderTest.cs
│   │   │   ├── CachedDataAnnotationsModelMetadataProviderTest.cs
│   │   │   ├── CancellationTokenModelBinderTest.cs
│   │   │   ├── ChildActionOnlyAttributeTest.cs
│   │   │   ├── ChildActionValueProviderFactoryTest.cs
│   │   │   ├── ClientDataTypeModelValidatorProviderTest.cs
│   │   │   ├── CompareAttributeAdapterTest.cs
│   │   │   ├── CompareAttributeTest.cs
│   │   │   ├── ContentResultTest.cs
│   │   │   ├── ControllerActionInvokerTest.cs
│   │   │   ├── ControllerBaseTest.cs
│   │   │   ├── ControllerBuilderTest.cs
│   │   │   ├── ControllerContextTest.cs
│   │   │   ├── ControllerDescriptorCacheTest.cs
│   │   │   ├── ControllerDescriptorTest.cs
│   │   │   ├── ControllerInstanceFilterProviderTest.cs
│   │   │   ├── ControllerTest.cs
│   │   │   ├── CopyOnWriteDictionaryTest.cs
│   │   │   ├── DataAnnotationsModelMetadataProviderTest.cs
│   │   │   ├── DataAnnotationsModelMetadataProviderTestBase.cs
│   │   │   ├── DataAnnotationsModelValidatorProviderTest.cs
│   │   │   ├── DataAnnotationsModelValidatorTest.cs
│   │   │   ├── DataErrorInfoModelValidatorProviderTest.cs
│   │   │   ├── DataTypeUtilTest.cs
│   │   │   ├── DefaultControllerFactoryTest.cs
│   │   │   ├── DefaultModelBinderTest.cs
│   │   │   ├── DefaultViewLocationCacheTest.cs
│   │   │   ├── DependencyResolverTest.cs
│   │   │   ├── DescriptorUtilTest.cs
│   │   │   ├── DictionaryHelpersTest.cs
│   │   │   ├── DictionaryValueProviderTest.cs
│   │   │   ├── DynamicViewDataDictionaryTest.cs
│   │   │   ├── EmptyModelValidatorProviderTest.cs
│   │   │   ├── ExceptionContextTest.cs
│   │   │   ├── ExpressionHelperTest.cs
│   │   │   ├── FieldValidationMetadataTest.cs
│   │   │   ├── FileContentResultTest.cs
│   │   │   ├── FilePathResultTest.cs
│   │   │   ├── FileResultTest.cs
│   │   │   ├── FileStreamResultTest.cs
│   │   │   ├── FilterAttributeFilterProviderTest.cs
│   │   │   ├── FilterInfoTest.cs
│   │   │   ├── FilterProviderCollectionTest.cs
│   │   │   ├── FilterProvidersTest.cs
│   │   │   ├── FilterTest.cs
│   │   │   ├── FormCollectionTest.cs
│   │   │   ├── FormContextTest.cs
│   │   │   ├── FormValueProviderFactoryTest.cs
│   │   │   ├── GlobalFilterCollectionTest.cs
│   │   │   ├── HandleErrorAttributeTest.cs
│   │   │   ├── HandleErrorInfoTest.cs
│   │   │   ├── HtmlHelperOfTModelTest.cs
│   │   │   ├── HtmlHelperTest.cs
│   │   │   ├── HttpDeleteAttributeTest.cs
│   │   │   ├── HttpFileCollectionValueProviderFactoryTest.cs
│   │   │   ├── HttpFileCollectionValueProviderTest.cs
│   │   │   ├── HttpGetAttributeTest.cs
│   │   │   ├── HttpHandlerUtilTest.cs
│   │   │   ├── HttpHeadAttributeTest.cs
│   │   │   ├── HttpNotFoundResultTest.cs
│   │   │   ├── HttpOptionsAttributeTest.cs
│   │   │   ├── HttpPatchAttributeTest.cs
│   │   │   ├── HttpPostAttributeTest.cs
│   │   │   ├── HttpPostedFileBaseModelBinderTest.cs
│   │   │   ├── HttpPutAttributeTest.cs
│   │   │   ├── HttpRequestExtensionsTest.cs
│   │   │   ├── HttpStatusCodeResultTest.cs
│   │   │   ├── HttpUnauthorizedResultTest.cs
│   │   │   ├── HttpVerbAttributeHelper.cs
│   │   │   ├── JQueryFormValueProviderFactoryTest.cs
│   │   │   ├── JavaScriptResultTest.cs
│   │   │   ├── JsonResultTest.cs
│   │   │   ├── JsonValueProviderFactoryTest.cs
│   │   │   ├── LinqBinaryModelBinderTest.cs
│   │   │   ├── MaxLengthAttributeAdapterTest.cs
│   │   │   ├── MinLengthAttributeAdapterTest.cs
│   │   │   ├── MockBuildManager.cs
│   │   │   ├── MockHelpers.cs
│   │   │   ├── MockableUnvalidatedRequestValues.cs
│   │   │   ├── ModelBinderAttributeTest.cs
│   │   │   ├── ModelBinderDictionaryTest.cs
│   │   │   ├── ModelBinderProviderCollectionTest.cs
│   │   │   ├── ModelBinderProvidersTest.cs
│   │   │   ├── ModelBindersTest.cs
│   │   │   ├── ModelBindingContextTest.cs
│   │   │   ├── ModelClientValidationRuleTest.cs
│   │   │   ├── ModelErrorCollectionTest.cs
│   │   │   ├── ModelErrorTest.cs
│   │   │   ├── ModelMetadataProvidersTest.cs
│   │   │   ├── ModelMetadataTest.cs
│   │   │   ├── ModelStateDictionaryTest.cs
│   │   │   ├── ModelStateTest.cs
│   │   │   ├── ModelValidationResultTest.cs
│   │   │   ├── ModelValidatorProviderCollectionTest.cs
│   │   │   ├── ModelValidatorProvidersTest.cs
│   │   │   ├── ModelValidatorTest.cs
│   │   │   ├── MultiSelectListTest.cs
│   │   │   ├── MultiServiceResolverTest.cs
│   │   │   ├── MvcHandlerTest.cs
│   │   │   ├── MvcHtmlStringTest.cs
│   │   │   ├── MvcHttpHandlerTest.cs
│   │   │   ├── MvcRouteHandlerTest.cs
│   │   │   ├── MvcTestHelper.cs
│   │   │   ├── MvcWebRazorHostFactoryTest.cs
│   │   │   ├── NameValueCollectionExtensionsTest.cs
│   │   │   ├── NameValueCollectionValueProviderTest.cs
│   │   │   ├── NoAsyncTimeoutAttributeTest.cs
│   │   │   ├── NonActionAttributeTest.cs
│   │   │   ├── OutputCacheAttributeTest.cs
│   │   │   ├── OverrideActionFiltersAttributeTests.cs
│   │   │   ├── OverrideAuthenticationAttributeTests.cs
│   │   │   ├── OverrideAuthorizationAttributeTests.cs
│   │   │   ├── OverrideExceptionFiltersAttributeTests.cs
│   │   │   ├── OverrideFiltersAttributeTests.cs
│   │   │   ├── OverrideResultFiltersAttributeTests.cs
│   │   │   ├── ParameterBindingInfoTest.cs
│   │   │   ├── ParameterDescriptorTest.cs
│   │   │   ├── ParameterInfoUtilTest.cs
│   │   │   ├── PartialViewResultTest.cs
│   │   │   ├── PreApplicationStartCodeTest.cs
│   │   │   ├── QueryStringValueProviderFactoryTest.cs
│   │   │   ├── RangeAttributeAdapterTest.cs
│   │   │   ├── RazorViewEngineTest.cs
│   │   │   ├── RazorViewTest.cs
│   │   │   ├── ReaderWriterCacheTest.cs
│   │   │   ├── RedirectResultTest.cs
│   │   │   ├── RedirectToRouteResultTest.cs
│   │   │   ├── ReflectedActionDescriptorTest.cs
│   │   │   ├── ReflectedControllerDescriptorTest.cs
│   │   │   ├── ReflectedParameterBindingInfoTest.cs
│   │   │   ├── ReflectedParameterDescriptorTest.cs
│   │   │   ├── RegularExpressionAttributeAdapterTest.cs
│   │   │   ├── RemoteAttributeTest.cs
│   │   │   ├── RequireHttpsAttributeTest.cs
│   │   │   ├── RequiredAttributeAdapterTest.cs
│   │   │   ├── ResultExecutedContextTest.cs
│   │   │   ├── ResultExecutingContextTest.cs
│   │   │   ├── RouteCollectionExtensionsTest.cs
│   │   │   ├── RouteDataValueProviderFactoryTest.cs
│   │   │   ├── SelectListTest.cs
│   │   │   ├── SessionStateTempDataProviderTest.cs
│   │   │   ├── SingleServiceResolverTest.cs
│   │   │   ├── StringLengthAttributeAdapterTest.cs
│   │   │   ├── TempDataDictionaryTest.cs
│   │   │   ├── TypeCacheSerializerTest.cs
│   │   │   ├── TypeCacheUtilTest.cs
│   │   │   ├── TypeHelpersTest.cs
│   │   │   ├── UrlHelperTest.cs
│   │   │   ├── UrlParameterTest.cs
│   │   │   ├── ValidatableObjectAdapterTest.cs
│   │   │   ├── ValidateAntiForgeryTokenAttributeTest.cs
│   │   │   ├── ValidateInputAttributeTest.cs
│   │   │   ├── ValueProviderCollectionTest.cs
│   │   │   ├── ValueProviderDictionaryTest.cs
│   │   │   ├── ValueProviderFactoriesTest.cs
│   │   │   ├── ValueProviderFactoryCollectionTest.cs
│   │   │   ├── ValueProviderResultTest.cs
│   │   │   ├── ValueProviderUtilTest.cs
│   │   │   ├── ViewContextTest.cs
│   │   │   ├── ViewDataDictionaryTest.cs
│   │   │   ├── ViewDataInfoTest.cs
│   │   │   ├── ViewEngineCollectionTest.cs
│   │   │   ├── ViewEngineResultTest.cs
│   │   │   ├── ViewEnginesTest.cs
│   │   │   ├── ViewMasterPageControlBuilderTest.cs
│   │   │   ├── ViewMasterPageTest.cs
│   │   │   ├── ViewPageControlBuilderTest.cs
│   │   │   ├── ViewPageTest.cs
│   │   │   ├── ViewResultBaseTest.cs
│   │   │   ├── ViewResultTest.cs
│   │   │   ├── ViewStartPageTest.cs
│   │   │   ├── ViewTypeParserFilterTest.cs
│   │   │   ├── ViewUserControlControlBuilderTest.cs
│   │   │   ├── ViewUserControlTest.cs
│   │   │   ├── VirtualPathProviderViewEngineTest.cs
│   │   │   ├── WebFormViewEngineTest.cs
│   │   │   └── WebFormViewTest.cs
│   │   ├── Util/
│   │   │   ├── AnonymousObject.cs
│   │   │   ├── DictionaryHelper.cs
│   │   │   ├── HttpContextHelpers.cs
│   │   │   ├── MvcHelper.cs
│   │   │   ├── Resolver.cs
│   │   │   ├── SimpleValueProvider.cs
│   │   │   └── SimpleViewDataContainer.cs
│   │   └── packages.config
│   ├── System.Web.Razor.Test/
│   │   ├── CSharpRazorCodeLanguageTest.cs
│   │   ├── CodeCompileUnitExtensions.cs
│   │   ├── Editor/
│   │   │   └── RazorEditorParserTest.cs
│   │   ├── Framework/
│   │   │   ├── BlockExtensions.cs
│   │   │   ├── BlockTypes.cs
│   │   │   ├── CodeParserTestBase.cs
│   │   │   ├── CsHtmlCodeParserTestBase.cs
│   │   │   ├── CsHtmlMarkupParserTestBase.cs
│   │   │   ├── ErrorCollector.cs
│   │   │   ├── MarkupParserTestBase.cs
│   │   │   ├── ParserTestBase.cs
│   │   │   ├── RawTextSymbol.cs
│   │   │   ├── TestSpanBuilder.cs
│   │   │   ├── VBHtmlCodeParserTestBase.cs
│   │   │   └── VBHtmlMarkupParserTestBase.cs
│   │   ├── Generator/
│   │   │   ├── CSharpRazorCodeGeneratorTest.cs
│   │   │   ├── GeneratedCodeMappingTest.cs
│   │   │   ├── PaddingTest.cs
│   │   │   ├── RazorCodeGeneratorTest.cs
│   │   │   ├── TabTest.cs
│   │   │   ├── TestSpan.cs
│   │   │   └── VBRazorCodeGeneratorTest.cs
│   │   ├── Parser/
│   │   │   ├── BlockTest.cs
│   │   │   ├── CSharp/
│   │   │   │   ├── CSharpAutoCompleteTest.cs
│   │   │   │   ├── CSharpBlockTest.cs
│   │   │   │   ├── CSharpDirectivesTest.cs
│   │   │   │   ├── CSharpErrorTest.cs
│   │   │   │   ├── CSharpExplicitExpressionTest.cs
│   │   │   │   ├── CSharpHelperTest.cs
│   │   │   │   ├── CSharpImplicitExpressionTest.cs
│   │   │   │   ├── CSharpLayoutDirectiveTest.cs
│   │   │   │   ├── CSharpNestedStatementsTest.cs
│   │   │   │   ├── CSharpRazorCommentsTest.cs
│   │   │   │   ├── CSharpReservedWordsTest.cs
│   │   │   │   ├── CSharpSectionTest.cs
│   │   │   │   ├── CSharpSpecialBlockTest.cs
│   │   │   │   ├── CSharpStatementTest.cs
│   │   │   │   ├── CSharpTemplateTest.cs
│   │   │   │   ├── CSharpToMarkupSwitchTest.cs
│   │   │   │   ├── CSharpVerbatimBlockTest.cs
│   │   │   │   ├── CSharpWhitespaceHandlingTest.cs
│   │   │   │   └── CsHtmlDocumentTest.cs
│   │   │   ├── CallbackParserListenerTest.cs
│   │   │   ├── Html/
│   │   │   │   ├── HtmlAttributeTest.cs
│   │   │   │   ├── HtmlBlockTest.cs
│   │   │   │   ├── HtmlDocumentTest.cs
│   │   │   │   ├── HtmlErrorTest.cs
│   │   │   │   ├── HtmlParserTestUtils.cs
│   │   │   │   ├── HtmlTagsTest.cs
│   │   │   │   ├── HtmlToCodeSwitchTest.cs
│   │   │   │   └── HtmlUrlAttributeTest.cs
│   │   │   ├── ParserContextTest.cs
│   │   │   ├── ParserVisitorExtensionsTest.cs
│   │   │   ├── PartialParsing/
│   │   │   │   ├── CSharpPartialParsingTest.cs
│   │   │   │   ├── PartialParsingTestBase.cs
│   │   │   │   └── VBPartialParsingTest.cs
│   │   │   ├── RazorParserTest.cs
│   │   │   ├── VB/
│   │   │   │   ├── VBAutoCompleteTest.cs
│   │   │   │   ├── VBBlockTest.cs
│   │   │   │   ├── VBContinueStatementTest.cs
│   │   │   │   ├── VBDirectiveTest.cs
│   │   │   │   ├── VBErrorTest.cs
│   │   │   │   ├── VBExitStatementTest.cs
│   │   │   │   ├── VBExplicitExpressionTest.cs
│   │   │   │   ├── VBExpressionTest.cs
│   │   │   │   ├── VBExpressionsInCodeTest.cs
│   │   │   │   ├── VBHelperTest.cs
│   │   │   │   ├── VBHtmlDocumentTest.cs
│   │   │   │   ├── VBImplicitExpressionTest.cs
│   │   │   │   ├── VBLayoutDirectiveTest.cs
│   │   │   │   ├── VBNestedStatementsTest.cs
│   │   │   │   ├── VBRazorCommentsTest.cs
│   │   │   │   ├── VBReservedWordsTest.cs
│   │   │   │   ├── VBSectionTest.cs
│   │   │   │   ├── VBSpecialKeywordsTest.cs
│   │   │   │   ├── VBStatementTest.cs
│   │   │   │   ├── VBTemplateTest.cs
│   │   │   │   └── VBToMarkupSwitchTest.cs
│   │   │   └── WhitespaceRewriterTest.cs
│   │   ├── RazorCodeLanguageTest.cs
│   │   ├── RazorDirectiveAttributeTest.cs
│   │   ├── RazorEngineHostTest.cs
│   │   ├── RazorTemplateEngineTest.cs
│   │   ├── StringTextBuffer.cs
│   │   ├── System.Web.Razor.Test.csproj
│   │   ├── TestFiles/
│   │   │   ├── CodeGenerator/
│   │   │   │   ├── CS/
│   │   │   │   │   ├── Output/
│   │   │   │   │   │   ├── Blocks.cs
│   │   │   │   │   │   ├── CodeBlock.cs
│   │   │   │   │   │   ├── CodeBlockAtEOF.cs
│   │   │   │   │   │   ├── Comments.cs
│   │   │   │   │   │   ├── ConditionalAttributes.cs
│   │   │   │   │   │   ├── DesignTime.Tabs.cs
│   │   │   │   │   │   ├── DesignTime.cs
│   │   │   │   │   │   ├── EmptyCodeBlock.cs
│   │   │   │   │   │   ├── EmptyExplicitExpression.cs
│   │   │   │   │   │   ├── EmptyImplicitExpression.cs
│   │   │   │   │   │   ├── EmptyImplicitExpressionInCode.Tabs.cs
│   │   │   │   │   │   ├── EmptyImplicitExpressionInCode.cs
│   │   │   │   │   │   ├── ExplicitExpression.cs
│   │   │   │   │   │   ├── ExplicitExpressionAtEOF.cs
│   │   │   │   │   │   ├── ExpressionsInCode.cs
│   │   │   │   │   │   ├── FunctionsBlock.DesignTime.Tabs.cs
│   │   │   │   │   │   ├── FunctionsBlock.DesignTime.cs
│   │   │   │   │   │   ├── FunctionsBlock.cs
│   │   │   │   │   │   ├── FunctionsBlockMinimal.DesignTime.Tabs.cs
│   │   │   │   │   │   ├── FunctionsBlock_Tabs.cs
│   │   │   │   │   │   ├── Helpers.Instance.cs
│   │   │   │   │   │   ├── Helpers.cs
│   │   │   │   │   │   ├── HelpersMissingCloseParen.cs
│   │   │   │   │   │   ├── HelpersMissingName.cs
│   │   │   │   │   │   ├── HelpersMissingOpenBrace.cs
│   │   │   │   │   │   ├── HelpersMissingOpenParen.cs
│   │   │   │   │   │   ├── HiddenSpansInCode.cs
│   │   │   │   │   │   ├── HtmlCommentWithQuote_Double.cs
│   │   │   │   │   │   ├── HtmlCommentWithQuote_Single.cs
│   │   │   │   │   │   ├── ImplicitExpression.cs
│   │   │   │   │   │   ├── ImplicitExpressionAtEOF.cs
│   │   │   │   │   │   ├── Imports.DesignTime.cs
│   │   │   │   │   │   ├── Imports.cs
│   │   │   │   │   │   ├── Inherits.Designtime.cs
│   │   │   │   │   │   ├── Inherits.Runtime.cs
│   │   │   │   │   │   ├── InlineBlocks.cs
│   │   │   │   │   │   ├── Instrumented.cs
│   │   │   │   │   │   ├── LayoutDirective.cs
│   │   │   │   │   │   ├── MarkupInCodeBlock.cs
│   │   │   │   │   │   ├── NestedCodeBlocks.cs
│   │   │   │   │   │   ├── NestedHelpers.cs
│   │   │   │   │   │   ├── NoLinePragmas.cs
│   │   │   │   │   │   ├── OpenedIf.DesignTime.Tabs.cs
│   │   │   │   │   │   ├── OpenedIf.DesignTime.cs
│   │   │   │   │   │   ├── ParserError.cs
│   │   │   │   │   │   ├── RazorComments.DesignTime.cs
│   │   │   │   │   │   ├── RazorComments.cs
│   │   │   │   │   │   ├── ResolveUrl.cs
│   │   │   │   │   │   ├── Sections.cs
│   │   │   │   │   │   ├── SimpleUnspacedIf.DesignTime.Tabs.cs
│   │   │   │   │   │   ├── Templates.cs
│   │   │   │   │   │   ├── UnfinishedExpressionInCode.Tabs.cs
│   │   │   │   │   │   └── UnfinishedExpressionInCode.cs
│   │   │   │   │   └── Source/
│   │   │   │   │       ├── Blocks.cshtml
│   │   │   │   │       ├── CodeBlock.cshtml
│   │   │   │   │       ├── CodeBlockAtEOF.cshtml
│   │   │   │   │       ├── ConditionalAttributes.cshtml
│   │   │   │   │       ├── DesignTime.cshtml
│   │   │   │   │       ├── EmptyCodeBlock.cshtml
│   │   │   │   │       ├── EmptyExplicitExpression.cshtml
│   │   │   │   │       ├── EmptyImplicitExpression.cshtml
│   │   │   │   │       ├── EmptyImplicitExpressionInCode.cshtml
│   │   │   │   │       ├── ExplicitExpression.cshtml
│   │   │   │   │       ├── ExplicitExpressionAtEOF.cshtml
│   │   │   │   │       ├── ExpressionsInCode.cshtml
│   │   │   │   │       ├── FunctionsBlock.cshtml
│   │   │   │   │       ├── FunctionsBlockMinimal.cshtml
│   │   │   │   │       ├── FunctionsBlock_Tabs.cshtml
│   │   │   │   │       ├── Helpers.cshtml
│   │   │   │   │       ├── HelpersMissingCloseParen.cshtml
│   │   │   │   │       ├── HelpersMissingName.cshtml
│   │   │   │   │       ├── HelpersMissingOpenBrace.cshtml
│   │   │   │   │       ├── HelpersMissingOpenParen.cshtml
│   │   │   │   │       ├── HiddenSpansInCode.cshtml
│   │   │   │   │       ├── HtmlCommentWithQuote_Double.cshtml
│   │   │   │   │       ├── HtmlCommentWithQuote_Single.cshtml
│   │   │   │   │       ├── ImplicitExpression.cshtml
│   │   │   │   │       ├── ImplicitExpressionAtEOF.cshtml
│   │   │   │   │       ├── Imports.cshtml
│   │   │   │   │       ├── Inherits.cshtml
│   │   │   │   │       ├── InlineBlocks.cshtml
│   │   │   │   │       ├── Instrumented.cshtml
│   │   │   │   │       ├── LayoutDirective.cshtml
│   │   │   │   │       ├── MarkupInCodeBlock.cshtml
│   │   │   │   │       ├── NestedCodeBlocks.cshtml
│   │   │   │   │       ├── NestedHelpers.cshtml
│   │   │   │   │       ├── NoLinePragmas.cshtml
│   │   │   │   │       ├── OpenedIf.cshtml
│   │   │   │   │       ├── ParserError.cshtml
│   │   │   │   │       ├── RazorComments.cshtml
│   │   │   │   │       ├── ResolveUrl.cshtml
│   │   │   │   │       ├── Sections.cshtml
│   │   │   │   │       ├── SimpleUnspacedIf.cshtml
│   │   │   │   │       ├── Templates.cshtml
│   │   │   │   │       └── UnfinishedExpressionInCode.cshtml
│   │   │   │   └── VB/
│   │   │   │       ├── Output/
│   │   │   │       │   ├── Blocks.vb
│   │   │   │       │   ├── CodeBlock.vb
│   │   │   │       │   ├── CodeBlockAtEOF.vb
│   │   │   │       │   ├── Comments.vb
│   │   │   │       │   ├── ConditionalAttributes.vb
│   │   │   │       │   ├── DesignTime.vb
│   │   │   │       │   ├── EmptyExplicitExpression.vb
│   │   │   │       │   ├── EmptyImplicitExpression.vb
│   │   │   │       │   ├── EmptyImplicitExpressionInCode.vb
│   │   │   │       │   ├── EmptySection.vb
│   │   │   │       │   ├── ExplicitExpression.vb
│   │   │   │       │   ├── ExplicitExpressionAtEOF.vb
│   │   │   │       │   ├── ExpressionsInCode.vb
│   │   │   │       │   ├── FunctionsBlock.DesignTime.Tabs.vb
│   │   │   │       │   ├── FunctionsBlock.DesignTime.vb
│   │   │   │       │   ├── FunctionsBlock.vb
│   │   │   │       │   ├── Helpers.Instance.vb
│   │   │   │       │   ├── Helpers.vb
│   │   │   │       │   ├── HelpersMissingCloseParen.vb
│   │   │   │       │   ├── HelpersMissingName.vb
│   │   │   │       │   ├── HelpersMissingOpenParen.vb
│   │   │   │       │   ├── ImplicitExpression.vb
│   │   │   │       │   ├── ImplicitExpressionAtEOF.vb
│   │   │   │       │   ├── Imports.DesignTime.vb
│   │   │   │       │   ├── Imports.vb
│   │   │   │       │   ├── Inherits.Designtime.vb
│   │   │   │       │   ├── Inherits.Runtime.vb
│   │   │   │       │   ├── Instrumented.vb
│   │   │   │       │   ├── LayoutDirective.vb
│   │   │   │       │   ├── MarkupInCodeBlock.vb
│   │   │   │       │   ├── NestedCodeBlocks.vb
│   │   │   │       │   ├── NestedHelpers.vb
│   │   │   │       │   ├── NoLinePragmas.vb
│   │   │   │       │   ├── Options.vb
│   │   │   │       │   ├── ParserError.vb
│   │   │   │       │   ├── RazorComments.DesignTime.vb
│   │   │   │       │   ├── RazorComments.vb
│   │   │   │       │   ├── ResolveUrl.vb
│   │   │   │       │   ├── Sections.vb
│   │   │   │       │   ├── Templates.vb
│   │   │   │       │   └── UnfinishedExpressionInCode.vb
│   │   │   │       └── Source/
│   │   │   │           ├── Blocks.vbhtml
│   │   │   │           ├── CodeBlock.vbhtml
│   │   │   │           ├── CodeBlockAtEOF.vbhtml
│   │   │   │           ├── ConditionalAttributes.vbhtml
│   │   │   │           ├── DesignTime.vbhtml
│   │   │   │           ├── EmptyExplicitExpression.vbhtml
│   │   │   │           ├── EmptyImplicitExpression.vbhtml
│   │   │   │           ├── EmptyImplicitExpressionInCode.vbhtml
│   │   │   │           ├── EmptySection.vbhtml
│   │   │   │           ├── ExplicitExpression.vbhtml
│   │   │   │           ├── ExplicitExpressionAtEOF.vbhtml
│   │   │   │           ├── ExpressionsInCode.vbhtml
│   │   │   │           ├── FunctionsBlock.vbhtml
│   │   │   │           ├── Helpers.vbhtml
│   │   │   │           ├── HelpersMissingCloseParen.vbhtml
│   │   │   │           ├── HelpersMissingName.vbhtml
│   │   │   │           ├── HelpersMissingOpenParen.vbhtml
│   │   │   │           ├── ImplicitExpression.vbhtml
│   │   │   │           ├── ImplicitExpressionAtEOF.vbhtml
│   │   │   │           ├── Imports.vbhtml
│   │   │   │           ├── Inherits.vbhtml
│   │   │   │           ├── Instrumented.vbhtml
│   │   │   │           ├── LayoutDirective.vbhtml
│   │   │   │           ├── MarkupInCodeBlock.vbhtml
│   │   │   │           ├── NestedCodeBlocks.vbhtml
│   │   │   │           ├── NestedHelpers.vbhtml
│   │   │   │           ├── NoLinePragmas.vbhtml
│   │   │   │           ├── Options.vbhtml
│   │   │   │           ├── ParserError.vbhtml
│   │   │   │           ├── RazorComments.vbhtml
│   │   │   │           ├── ResolveUrl.vbhtml
│   │   │   │           ├── Sections.vbhtml
│   │   │   │           ├── Templates.vbhtml
│   │   │   │           └── UnfinishedExpressionInCode.vbhtml
│   │   │   ├── DesignTime/
│   │   │   │   ├── Simple.cshtml
│   │   │   │   └── Simple.txt
│   │   │   └── nested-1000.html
│   │   ├── Text/
│   │   │   ├── BufferingTextReaderTest.cs
│   │   │   ├── LineTrackingStringBufferTest.cs
│   │   │   ├── LookaheadTextReaderTestBase.cs
│   │   │   ├── SourceLocationTest.cs
│   │   │   ├── SourceLocationTrackerTest.cs
│   │   │   ├── TextBufferReaderTest.cs
│   │   │   ├── TextChangeTest.cs
│   │   │   └── TextReaderExtensionsTest.cs
│   │   ├── Tokenizer/
│   │   │   ├── CSharpTokenizerCommentTest.cs
│   │   │   ├── CSharpTokenizerIdentifierTest.cs
│   │   │   ├── CSharpTokenizerLiteralTest.cs
│   │   │   ├── CSharpTokenizerOperatorsTest.cs
│   │   │   ├── CSharpTokenizerTest.cs
│   │   │   ├── CSharpTokenizerTestBase.cs
│   │   │   ├── HtmlTokenizerTest.cs
│   │   │   ├── HtmlTokenizerTestBase.cs
│   │   │   ├── TokenizerLookaheadTest.cs
│   │   │   ├── TokenizerTestBase.cs
│   │   │   ├── VBTokenizerCommentTest.cs
│   │   │   ├── VBTokenizerIdentifierTest.cs
│   │   │   ├── VBTokenizerLiteralTest.cs
│   │   │   ├── VBTokenizerOperatorsTest.cs
│   │   │   ├── VBTokenizerTest.cs
│   │   │   └── VBTokenizerTestBase.cs
│   │   ├── Utils/
│   │   │   ├── DisposableActionTest.cs
│   │   │   ├── EnumerableUtils.cs
│   │   │   ├── MiscAssert.cs
│   │   │   ├── MiscUtils.cs
│   │   │   └── SpanAssert.cs
│   │   ├── VBRazorCodeLanguageTest.cs
│   │   └── packages.config
│   ├── System.Web.WebPages.Administration.Test/
│   │   ├── AdminPackageTest.cs
│   │   ├── PackageManagerModuleTest.cs
│   │   ├── PackagesSourceFileTest.cs
│   │   ├── PageUtilsTest.cs
│   │   ├── PreApplicationStartCodeTest.cs
│   │   ├── RemoteAssemblyTest.cs
│   │   ├── System.Web.WebPages.Administration.Test.csproj
│   │   ├── WebProjectManagerTest.cs
│   │   ├── WebProjectSystemTest.cs
│   │   └── packages.config
│   ├── System.Web.WebPages.Deployment.Test/
│   │   ├── App.Config
│   │   ├── AssemblyUtilsTest.cs
│   │   ├── DeploymentUtil.cs
│   │   ├── LatestRazorVersion.cs
│   │   ├── PreApplicationStartCodeTest.cs
│   │   ├── System.Web.WebPages.Deployment.Test.csproj
│   │   ├── TestFileSystem.cs
│   │   ├── TestFiles/
│   │   │   └── ConfigTestSites/
│   │   │       ├── CshtmlFileConfigV1/
│   │   │       │   ├── Default.cshtml
│   │   │       │   └── web.config
│   │   │       ├── CshtmlFileNoVersion/
│   │   │       │   └── Default.cshtml
│   │   │       ├── NoCshtml/
│   │   │       │   └── Default.htm
│   │   │       ├── NoCshtmlConfigv1/
│   │   │       │   ├── Default.htm
│   │   │       │   └── web.config
│   │   │       ├── NoCshtmlNoConfigSetting/
│   │   │       │   ├── Default.htm
│   │   │       │   └── web.config
│   │   │       ├── NoCshtmlWithEnabledSetting/
│   │   │       │   ├── Default.htm
│   │   │       │   └── web.config
│   │   │       └── NoCshtmlWithEnabledSettingFalse/
│   │   │           ├── Default.htm
│   │   │           └── web.config
│   │   ├── WebPagesDeploymentTest.cs
│   │   └── packages.config
│   ├── System.Web.WebPages.Razor.Test/
│   │   ├── PreApplicationStartCodeTest.cs
│   │   ├── RazorBuildProviderTest.cs
│   │   ├── System.Web.WebPages.Razor.Test.csproj
│   │   ├── WebCodeRazorEngineHostTest.cs
│   │   ├── WebPageRazorEngineHostTest.cs
│   │   ├── WebRazorHostFactoryTest.cs
│   │   ├── app.config
│   │   └── packages.config
│   ├── System.Web.WebPages.Test/
│   │   ├── App.config
│   │   ├── ApplicationParts/
│   │   │   ├── ApplicationPartRegistryTest.cs
│   │   │   ├── ApplicationPartTest.cs
│   │   │   ├── MimeMappingTest.cs
│   │   │   ├── ResourceHandlerTest.cs
│   │   │   └── TestResourceAssembly.cs
│   │   ├── Extensions/
│   │   │   ├── HttpContextExtensionsTest.cs
│   │   │   ├── HttpRequestExtensionsTest.cs
│   │   │   ├── HttpResponseExtensionsTest.cs
│   │   │   ├── StringExtensionsTest.cs
│   │   │   └── StringWriterExtensionsTest.cs
│   │   ├── Helpers/
│   │   │   ├── AntiForgeryConfigTest.cs
│   │   │   ├── AntiForgeryTest.cs
│   │   │   ├── AntiXsrf/
│   │   │   │   ├── AntiForgeryTokenSerializerTest.cs
│   │   │   │   ├── AntiForgeryTokenStoreTest.cs
│   │   │   │   ├── AntiForgeryTokenTest.cs
│   │   │   │   ├── AntiForgeryWorkerTest.cs
│   │   │   │   ├── BinaryBlobTest.cs
│   │   │   │   ├── ClaimUidExtractorTest.cs
│   │   │   │   ├── HexUtil.cs
│   │   │   │   ├── MachineKey45CryptoSystemTest.cs
│   │   │   │   ├── MockAntiForgeryConfig.cs
│   │   │   │   ├── MockableAntiForgeryTokenSerializer.cs
│   │   │   │   ├── MockableClaimUidExtractor.cs
│   │   │   │   ├── MockableCryptoSystem.cs
│   │   │   │   ├── MockableTokenStore.cs
│   │   │   │   ├── MockableTokenValidator.cs
│   │   │   │   └── TokenValidatorTest.cs
│   │   │   ├── Claims/
│   │   │   │   ├── ClaimTest.cs
│   │   │   │   ├── ClaimsIdentityConverterTest.cs
│   │   │   │   ├── ClaimsIdentityTest.cs
│   │   │   │   └── MockClaimsIdentity.cs
│   │   │   ├── CryptoUtilTest.cs
│   │   │   └── UnvalidatedRequestValuesTest.cs
│   │   ├── Html/
│   │   │   ├── CheckBoxTest.cs
│   │   │   ├── HtmlHelperFactory.cs
│   │   │   ├── HtmlHelperTest.cs
│   │   │   ├── InputHelperTest.cs
│   │   │   ├── LabelHelperTest.cs
│   │   │   ├── RadioButtonTest.cs
│   │   │   ├── SelectHelperTest.cs
│   │   │   ├── TextAreaHelperTest.cs
│   │   │   └── ValidationHelperTest.cs
│   │   ├── Instrumentation/
│   │   │   └── InstrumentationServiceTest.cs
│   │   ├── LatestRazorVersion.cs
│   │   ├── Mvc/
│   │   │   ├── HttpAntiForgeryExceptionTest.cs
│   │   │   ├── ModelClientValidationMaxLengthRuleTest.cs
│   │   │   ├── ModelClientValidationMembershipPasswordRuleTest.cs
│   │   │   ├── ModelClientValidationMinLengthRuleTest.cs
│   │   │   ├── ModelClientValidationStringLengthRuleTest.cs
│   │   │   ├── TagBuilderTest.cs
│   │   │   └── UnobtrusiveValidationAttributesGeneratorTest.cs
│   │   ├── PreApplicationStartCodeTest.cs
│   │   ├── ScopeStorage/
│   │   │   ├── AspNetRequestScopeStorageProviderTest.cs
│   │   │   ├── ScopeStorageDictionaryTest.cs
│   │   │   ├── ScopeStorageKeyComparerTest.cs
│   │   │   └── WebConfigScopeStorageTest.cs
│   │   ├── System.Web.WebPages.Test.csproj
│   │   ├── TestFiles/
│   │   │   └── Deployed/
│   │   │       ├── Bar
│   │   │       ├── Bar.cshtml
│   │   │       └── Bar.foohtml
│   │   ├── Utils/
│   │   │   ├── CultureUtilTest.cs
│   │   │   ├── HtmlAttributePropertyHelperTest.cs
│   │   │   ├── PathUtilTest.cs
│   │   │   ├── PropertyHelperTest.cs
│   │   │   ├── SessionStateUtilTest.cs
│   │   │   ├── TestObjectFactory.cs
│   │   │   ├── TypeHelperTest.cs
│   │   │   ├── UrlRewriterHelperTest.cs
│   │   │   └── UrlUtilTest.cs
│   │   ├── Validation/
│   │   │   ├── ValidationHelperTest.cs
│   │   │   └── ValidatorTest.cs
│   │   ├── WebPage/
│   │   │   ├── ApplicationStartPageTest.cs
│   │   │   ├── BrowserHelpersTest.cs
│   │   │   ├── BrowserOverrideStoresTest.cs
│   │   │   ├── BuildManagerExceptionUtilTest.cs
│   │   │   ├── BuildManagerWrapperTest.cs
│   │   │   ├── CookieBrowserOverrideStoreTest.cs
│   │   │   ├── DefaultDisplayModeTest.cs
│   │   │   ├── DisplayInfoTest.cs
│   │   │   ├── DisplayModeProviderTest.cs
│   │   │   ├── DynamicHttpApplicationStateTest.cs
│   │   │   ├── DynamicPageDataDictionaryTest.cs
│   │   │   ├── FileExistenceCacheTest.cs
│   │   │   ├── LayoutTest.cs
│   │   │   ├── PageDataDictionaryTest.cs
│   │   │   ├── RenderPageTest.cs
│   │   │   ├── RequestBrowserOverrideStoreTest.cs
│   │   │   ├── RequestResourceTrackerTest.cs
│   │   │   ├── StartPageTest.cs
│   │   │   ├── TemplateStackTest.cs
│   │   │   ├── UrlDataTest.cs
│   │   │   ├── Utils.cs
│   │   │   ├── VirtualPathFactoryExtensionsTest.cs
│   │   │   ├── VirtualPathFactoryManagerTest.cs
│   │   │   ├── WebPageContextTest.cs
│   │   │   ├── WebPageExecutingBaseTest.cs
│   │   │   ├── WebPageHttpHandlerTest.cs
│   │   │   ├── WebPageHttpModuleTest.cs
│   │   │   ├── WebPageRenderingBaseTest.cs
│   │   │   ├── WebPageRouteTest.cs
│   │   │   └── WebPageTest.cs
│   │   └── packages.config
│   ├── WebApiHelpPage.Test/
│   │   ├── Controllers/
│   │   │   ├── UsersController.cs
│   │   │   └── ValuesController.cs
│   │   ├── HelpControllerTest.cs
│   │   ├── HelpPageApiModelTest.cs
│   │   ├── HelpPageAreaRegistrationTest.cs
│   │   ├── HelpPageConfigurationExtensionsTest.cs
│   │   ├── HelpPageSampleKeyTest.cs
│   │   ├── Helpers/
│   │   │   ├── ApiDescriptionHelpers.cs
│   │   │   └── CustomTypes.cs
│   │   ├── HelppageSampleGeneratorTest.cs
│   │   ├── ImageSampleTest.cs
│   │   ├── InvalidSampleTest.cs
│   │   ├── ModelDescriptionGeneratorTest.cs
│   │   ├── ObjectGeneratorTest.cs
│   │   ├── TextSampleTest.cs
│   │   ├── WebApiHelpPage.Test.csproj
│   │   ├── WebConfigTest.cs
│   │   ├── XmlDocumentationProviderTest.cs
│   │   └── packages.config
│   ├── WebApiHelpPage.VB.Test/
│   │   └── WebApiHelpPage.VB.Test.csproj
│   ├── WebMatrix.Data.Test/
│   │   ├── App.config
│   │   ├── ConfigurationManagerWrapperTest.cs
│   │   ├── DatabaseTest.cs
│   │   ├── DynamicRecordTest.cs
│   │   ├── FileHandlerTest.cs
│   │   ├── Mocks/
│   │   │   ├── MockConfigurationManager.cs
│   │   │   ├── MockConnectionConfiguration.cs
│   │   │   ├── MockDbFileHandler.cs
│   │   │   └── MockDbProviderFactory.cs
│   │   ├── WebMatrix.Data.Test.csproj
│   │   └── packages.config
│   └── WebMatrix.WebData.Test/
│       ├── MockDatabase.cs
│       ├── PreApplicationStartCodeTest.cs
│       ├── SimpleMembershipProviderTest.cs
│       ├── SimpleRoleProviderTest.cs
│       ├── WebMatrix.WebData.Test.csproj
│       ├── WebSecurityTest.cs
│       └── packages.config
└── tools/
    ├── 35MSSharedLib1024.snk
    ├── SkipStrongNames.xml
    ├── WebStack.StyleCop.targets
    ├── WebStack.settings.targets
    ├── WebStack.targets
    ├── WebStack.tasks.targets
    ├── WebStack.testing.targets
    ├── src/
    │   └── Microsoft.Web.FxCop/
    │       ├── DoNotCallProblematicMethodsOnTaskRule.cs
    │       ├── DoNotConstructTaskInstancesRule.cs
    │       ├── DoNotUseFinalizersRule.cs
    │       ├── DoNotUseProblematicTaskTypesRule.cs
    │       ├── IntrospectionRule.cs
    │       ├── Microsoft.Web.FxCop.csproj
    │       ├── Properties/
    │       │   └── AssemblyInfo.cs
    │       ├── Rules.xml
    │       ├── TypeNodeExtensions.cs
    │       └── UnusedResourceUsageRule.cs
    └── vslicense/
        ├── dotnet-library-license.htm
        └── dotnet-library-license.md

================================================
FILE CONTENTS
================================================

================================================
FILE: .appveyor.yml
================================================
init:
  - git config --global core.autocrlf true
branches:
  only:
    - main
    - /^(.*\/)?ci-.*$/
    - /^rel\/.*/
configuration:
  - CodeAnalysis
  - Release
matrix:
  fast_finish: true
before_build:
  - cmd: .\build.cmd EnableSkipStrongNames
build_script:
  - cmd: .\build.cmd UnitTest /P:Configuration=%Configuration%
clone_depth: 1
test: off
deploy: off
os: Visual Studio 2017


================================================
FILE: .azuredevops/dependabot.yml
================================================
version: 2
enable-campaigned-updates: false
enable-security-updates: false


================================================
FILE: .config/CredScanSuppressions.json
================================================
{
  "tool": "Credential Scanner",
  "suppressions": [
    {
      "placeholder": "abcdefg",
      "_justification": "This is a fake password used in test code."
    },
    {
      "placeholder": "Pa$$AAECAw==",
      "_justification": "This is a fake password used in test code."
    },
    {
      "placeholder": "ALyuoraY/cIWD1hjo+K81/pf83qo6Q6T+UBYcXN9P3A9WHLvEY10f+lwW5qPG6h9xw==",
      "_justification": "This is a fake hashed password used in test code."
    },
    {
      "placeholder": "abcdefg123",
      "_justification": "This is a fake password used in test code."
    },
    {
      "placeholder": "3e29b24f825e737d97aed5eb62df5076",
      "_justification": "This is a fake password used in test code."
    },
    {
      "placeholder": "My Password",
      "_justification": "This is a fake password used in test code."
    }
  ]
}

================================================
FILE: .config/tsaoptions.json
================================================
{
  "areaPath": "DevDiv\\ASP.NET Core\\Policy Violations",
  "codebaseName": "AspNetWebStack",
  "instanceUrl": "https://devdiv.visualstudio.com/",
  "iterationPath": "DevDiv",
  "notificationAliases": [
    "aspnetcore-build@microsoft.com"
  ],
  "projectName": "DEVDIV",
  "repositoryName": "AspNetWebStack",
  "template": "TFSDEVDIV"
}


================================================
FILE: .gitattributes
================================================
* text

*.bmp binary
*.dll binary
*.gif binary
*.jpg binary
*.png binary
*.snk binary

*.ascx text
*.cd text
*.cmd text
*.coffee text
*.config text
*.cs text diff=csharp 
*.csproj text merge=union 
*.cshtml text
*.css text
*.dtd text
*.edmx text
*.htm text
*.html text
*.js text
*.json text
*.msbuild text
*.nuspec text
*.resx text
*.ruleset text
*.StyleCop text
*.targets text
*.tt text
*.txt text
*.vb text
*.vbhtml text
*.vbproj text merge=union 
*.vbs text
*.wsf text
*.xml text
*.xunit text

*.sln text eol=crlf merge=union 


================================================
FILE: .gitignore
================================================
.msbuild/
.vs/
bin/
obj/
packages/

*.[Cc]ache
*.binlog
*.dll
*.dot[Cc]over
*.exe
*.nupkg
*.orig
*.psess
*.sln.ide
*.suo
*.user
*.vsp
*[Rr]esharper*
*launchSettings.json


================================================
FILE: .nuget/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Web.SkipStrongNames" version="1.0.0" />
  <package id="Microsoft.Web.StyleCop" version="1.0.0" />
  <package id="StyleCop" version="5.0.0" />
  <package id="xunit.runner.msbuild" version="2.4.2" targetFramework="net452" />
</packages>

================================================
FILE: .travis.yml
================================================
language: csharp
sudo: false
dist: trusty
mono: none
os:
  - linux
branches:
  only:
   - not.a.branch
script:
  - echo Skipping builds for now.


================================================
FILE: CODE-OF-CONDUCT.md
================================================
# Code of Conduct

This project has adopted the code of conduct defined by the Contributor Covenant
to clarify expected behavior in our community.

For more information, see the [.NET Foundation Code of Conduct](https://dotnetfoundation.org/code-of-conduct).


================================================
FILE: CONTRIBUTING.md
================================================
# How to contribute

One of the easiest ways to contribute is to participate in discussions and discuss issues. You can also contribute by submitting pull requests with code changes.

## Bugs and feature requests?
For non-security related bugs please log a new issue in this repo.

## Reporting security issues and bugs
Security issues and bugs should be reported privately, via email, to the Microsoft Security Response Center (MSRC)  secure@microsoft.com. You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Further information, including the MSRC PGP key, can be found in the [Security TechCenter](https://technet.microsoft.com/en-us/security/ff852094.aspx).

## Other discussions
Our team members also monitor several other discussion forums:

* [ASP.NET MVC forum](https://forums.asp.net/1146.aspx/1?MVC)
* [ASP.NET Web API forum](https://forums.asp.net/1246.aspx/1?Web+API)
* [ASP.NET Web Pages forum](https://forums.asp.net/1224.aspx/1?ASP+NET+Web+Pages)
* [StackOverflow](https://stackoverflow.com/) with the [`asp.net`](https://stackoverflow.com/questions/tagged/asp.net), [`asp.net-mvc`](https://stackoverflow.com/questions/tagged/asp.net-mvc), [`asp.net-web-api`](https://stackoverflow.com/questions/tagged/asp.net-web-api), [`asp.net-webpages`](https://stackoverflow.com/questions/tagged/asp.net-webpages) or [`razor`](https://stackoverflow.com/questions/tagged/razor) tags.

## Filing issues
When filing issues, please use our [bug filing templates](https://github.com/aspnet/Home/wiki/Functional-bug-template).
The best way to get your bug fixed is to be as detailed as you can be about the problem.
Providing a minimal project with steps to reproduce the problem is ideal.
Here are questions you can answer before you file a bug to make sure you're not missing any important information.

1. Did you read the [documentation](http://www.asp.net/aspnet)?
2. Did you include the snippet of broken code in the issue?
3. What are the *EXACT* steps to reproduce this problem?
4. What package versions are you using (you can see these in the `packages.config` file)?
5. What operating system are you using?
6. What version of IIS are you using?

GitHub supports [markdown](https://help.github.com/articles/github-flavored-markdown/), so when filing bugs make sure you check the formatting before clicking submit.

## Contributing code and content
You will need to sign a [Contributor License Agreement](https://cla2.dotnetfoundation.org/) before submitting your pull request. To complete the Contributor License Agreement (CLA), you will need to submit a request via the form and then electronically sign the Contributor License Agreement when you receive the email containing the link to the document. This needs to only be done once for any .NET Foundation OSS project.

Make sure you can build the code. Familiarize yourself with the project workflow and our coding conventions. If you don't know what a pull request is read this article: https://help.github.com/articles/using-pull-requests.

Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. You might also read these two blogs posts on contributing code: [Open Source Contribution Etiquette](http://tirania.org/blog/archive/2010/Dec-31.html) by Miguel de Icaza and [Don't "Push" Your Pull Requests](https://www.igvita.com/2011/12/19/dont-push-your-pull-requests/) by Ilya Grigorik. Note that all code submissions will be rigorously reviewed and tested by the ASP.NET and Entity Framework teams, and only those that meet an extremely high bar for both quality and design/roadmap appropriateness will be merged into the source.

Here's a few things you should always do when making changes to the code base:

**Commit/Pull Request Format**

```
Summary of the changes (Less than 80 chars)
 - Detail 1
 - Detail 2

Addresses #bugnumber (in this specific format)
```

**Tests**

-  Tests need to be provided for every bug/feature that is completed.
-  Tests only need to be present for issues that need to be verified by QA (e.g. not tasks)
-  If there is a scenario that is far too hard to test there does not need to be a test for it.
  - "Too hard" is determined by the team as a whole.


================================================
FILE: Directory.Build.props
================================================
<Project>
  <!-- Also stop MsBuild searching parent directories for this file. -->

  <PropertyGroup>
    <!-- Require VS2017 so VS builds also use MSBuild v15.0. -->
    <MinimumVisualStudioVersion>16.0</MinimumVisualStudioVersion>
    <!--
      Suppress "MSBUILD : warning : Post-build Code Analysis (FxCopCmd.exe) has been deprecated in favor of FxCop
      analyzers, which run during build. Refer to https://aka.ms/fxcopanalyzers to migrate to FxCop analyzers."
    -->
    <SuppressLegacyCodeAnalysisDeprecatedWarning>true</SuppressLegacyCodeAnalysisDeprecatedWarning>
    <!-- Workaround continued use of netcoreapp2.1; suppress the NETSDK1138 warning. -->
    <CheckEolTargetFramework>false</CheckEolTargetFramework>
  </PropertyGroup>

</Project>


================================================
FILE: Directory.Build.targets
================================================
<Project>
  <!-- Stop MsBuild searching parent directories for this file. -->
</Project>


================================================
FILE: LICENSE.txt
================================================
Copyright (c) .NET Foundation. All rights reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use
these files except in compliance with the License. You may obtain a copy of the
License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.


================================================
FILE: NuGet.Config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <solution>
    <add key="disableSourceControlIntegration" value="true" />
  </solution>
  <packageSources>
    <clear />
    <add key="dotnet-public" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-public/nuget/v3/index.json" />
    <add key="myget-legacy" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/myget-legacy/nuget/v3/index.json" />
  </packageSources>
</configuration>

================================================
FILE: README.md
================================================
# ASP.NET MVC, Web API, Web Pages, and Razor

## Note: This repo is for ASP.NET MVC 5.x, Web API 2.x, and Web Pages 3.x. For ASP.NET Core MVC, check the [AspNetCore repo](https://github.com/aspnet/AspNetCore).

ASP.NET MVC is a web framework that gives you a powerful, patterns-based way to build dynamic websites and Web APIs. ASP.NET MVC enables a clean separation of concerns and gives you full control over markup.

This repo includes:

* ASP.NET MVC 5.x
* ASP.NET Web API 2.x
* ASP.NET Web Pages 3.x
* ASP.NET Razor 3.x

### Contributing

Check out the [contributing](CONTRIBUTING.md) page to see the best places to log issues and start discussions.

### Tags and releases

Git tag or branch|Other products|MVC package versions|Web API package (product) versions|Web Pages package versions
--------|--------------|------------|------------|------------
[v2.0.4](https://github.com/aspnet/AspNetWebStack/tree/v2.0.4)||4.0.40804|4.0.30506|2.0.30506
[v2.1](https://github.com/aspnet/AspNetWebStack/tree/v2.1)|ASP.NET and Web Tools 2012.2, VS 2012 Update 2 (not on http://nuget.org)|v4 2012.2 Update RTM|v1 2012.2 Update RTM|v2 2012.2 Update RTM
[v3.0.2](https://github.com/aspnet/AspNetWebStack/tree/v3.0.2)||5.0.2|5.0.1 (2.0.1)|3.0.1
[v3.1.3](https://github.com/aspnet/AspNetWebStack/tree/v3.1.3)||5.1.3|5.1.2 (2.1.2)|3.1.2
[v3.2.6](https://github.com/aspnet/AspNetWebStack/tree/v3.2.6)||5.2.6|5.2.6|3.2.6
[v3.2.7](https://github.com/aspnet/AspNetWebStack/tree/v3.2.7)||5.2.7|5.2.7|3.2.7
[v3.2.8](https://github.com/aspnet/AspNetWebStack/tree/v3.2.8)||5.2.8|5.2.8|3.2.8
[main](https://github.com/aspnet/AspNetWebStack/tree/main)|New work e.g. MVC 5.2.9-preview1||||


================================================
FILE: Runtime.NetFramework.slnf
================================================
{
  "solution": {
    "path": "Runtime.sln",
    "projects": [
      "src\\Microsoft.AspNet.Facebook\\Microsoft.AspNet.Facebook.csproj",
      "src\\Microsoft.Web.Helpers\\Microsoft.Web.Helpers.csproj",
      "src\\Microsoft.Web.Mvc\\Microsoft.Web.Mvc.csproj",
      "src\\Microsoft.Web.WebPages.OAuth\\Microsoft.Web.WebPages.OAuth.csproj",
      "src\\System.Net.Http.Formatting\\System.Net.Http.Formatting.csproj",
      "src\\System.Web.Cors\\System.Web.Cors.csproj",
      "src\\System.Web.Helpers\\System.Web.Helpers.csproj",
      "src\\System.Web.Http.Cors\\System.Web.Http.Cors.csproj",
      "src\\System.Web.Http.Owin\\System.Web.Http.Owin.csproj",
      "src\\System.Web.Http.SelfHost\\System.Web.Http.SelfHost.csproj",
      "src\\System.Web.Http.SignalR\\System.Web.Http.SignalR.csproj",
      "src\\System.Web.Http.Tracing\\System.Web.Http.Tracing.csproj",
      "src\\System.Web.Http.WebHost\\System.Web.Http.WebHost.csproj",
      "src\\System.Web.Http\\System.Web.Http.csproj",
      "src\\System.Web.Mvc\\System.Web.Mvc.csproj",
      "src\\System.Web.Razor\\System.Web.Razor.csproj",
      "src\\System.Web.WebPages.Administration\\System.Web.WebPages.Administration.csproj",
      "src\\System.Web.WebPages.Deployment\\System.Web.WebPages.Deployment.csproj",
      "src\\System.Web.WebPages.Razor\\System.Web.WebPages.Razor.csproj",
      "src\\System.Web.WebPages\\System.Web.WebPages.csproj",
      "src\\WebApiHelpPage\\VB\\WebApiHelpPageVB.vbproj",
      "src\\WebApiHelpPage\\WebApiHelpPage.csproj",
      "src\\WebMatrix.Data\\WebMatrix.Data.csproj",
      "src\\WebMatrix.WebData\\WebMatrix.WebData.csproj",
      "test\\Microsoft.AspNet.Facebook.Test\\Microsoft.AspNet.Facebook.Test.csproj",
      "test\\Microsoft.TestCommon\\Microsoft.TestCommon.csproj",
      "test\\Microsoft.Web.Helpers.Test\\Microsoft.Web.Helpers.Test.csproj",
      "test\\Microsoft.Web.Mvc.Test\\Microsoft.Web.Mvc.Test.csproj",
      "test\\Microsoft.Web.WebPages.OAuth.Test\\Microsoft.Web.WebPages.OAuth.Test.csproj",
      "test\\System.Net.Http.Formatting.Test\\System.Net.Http.Formatting.Test.csproj",
      "test\\System.Web.Cors.Test\\System.Web.Cors.Test.csproj",
      "test\\System.Web.Helpers.Test\\System.Web.Helpers.Test.csproj",
      "test\\System.Web.Http.Cors.Test\\System.Web.Http.Cors.Test.csproj",
      "test\\System.Web.Http.Integration.Test\\System.Web.Http.Integration.Test.csproj",
      "test\\System.Web.Http.Owin.Test\\System.Web.Http.Owin.Test.csproj",
      "test\\System.Web.Http.SelfHost.Test\\System.Web.Http.SelfHost.Test.csproj",
      "test\\System.Web.Http.SignalR.Test\\System.Web.Http.SignalR.Test.csproj",
      "test\\System.Web.Http.Test\\System.Web.Http.Test.csproj",
      "test\\System.Web.Http.Tracing.Test\\System.Web.Http.Tracing.Test.csproj",
      "test\\System.Web.Http.WebHost.Test\\System.Web.Http.WebHost.Test.csproj",
      "test\\System.Web.Mvc.Test\\System.Web.Mvc.Test.csproj",
      "test\\System.Web.Razor.Test\\System.Web.Razor.Test.csproj",
      "test\\System.Web.WebPages.Administration.Test\\System.Web.WebPages.Administration.Test.csproj",
      "test\\System.Web.WebPages.Deployment.Test\\System.Web.WebPages.Deployment.Test.csproj",
      "test\\System.Web.WebPages.Razor.Test\\System.Web.WebPages.Razor.Test.csproj",
      "test\\System.Web.WebPages.Test\\System.Web.WebPages.Test.csproj",
      "test\\WebApiHelpPage.Test\\WebApiHelpPage.Test.csproj",
      "test\\WebApiHelpPage.VB.Test\\WebApiHelpPage.VB.Test.csproj",
      "test\\WebMatrix.Data.Test\\WebMatrix.Data.Test.csproj",
      "test\\WebMatrix.WebData.Test\\WebMatrix.WebData.Test.csproj"
    ]
  }
}

================================================
FILE: Runtime.NetStandard.slnf
================================================
{
  "solution": {
    "path": "Runtime.sln",
    "projects": [
      "src\\System.Net.Http.Formatting.ns1_3\\System.Net.Http.Formatting.ns1_3.csproj",
      "src\\System.Net.Http.Formatting.ns2_0\\System.Net.Http.Formatting.ns2_0.csproj",
      "test\\Microsoft.TestCommon\\Microsoft.TestCommon.csproj",
      "test\\System.Net.Http.Formatting.ns1_3.Test\\System.Net.Http.Formatting.ns1_3.Test.csproj",
      "test\\System.Net.Http.Formatting.ns2_0.Test\\System.Net.Http.Formatting.ns2_0.Test.csproj"
    ]
  }
}

================================================
FILE: Runtime.msbuild
================================================
<Project DefaultTargets="UnitTest" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="tools/WebStack.tasks.targets"/>
  <UsingTask TaskName="SkipStrongNames.CheckSkipStrongNamesStatus" AssemblyFile="$(SkipStrongNamesExe)" />

  <PropertyGroup>
    <!-- build.cmd sets /p:Desktop=true. The CI server does not; instead, it does an additional step with /p:Configuration=CodeAnalysis. -->
    <Configuration Condition=" '$(Configuration)' == '' and '$(Desktop)' == 'true' ">CodeAnalysis</Configuration>
    <Configuration Condition=" '$(Configuration)' == '' ">Release</Configuration>
    <CodeAnalysis Condition=" '$(CodeAnalysis)' == '' and '$(Configuration)' != 'Release' ">true</CodeAnalysis>
    <StyleCopEnabled Condition=" '$(StyleCopEnabled)' == '' ">true</StyleCopEnabled>
    <BuildInParallel Condition=" '$(BuildInParallel)' == '' And $(MSBuildNodeCount) &gt; 1 ">true</BuildInParallel>
    <BuildInParallel Condition=" '$(BuildInParallel)' == '' ">false</BuildInParallel>
    <RestoreInParallel Condition=" '$(RestoreInParallel)' == '' ">false</RestoreInParallel>
    <TestInParallel Condition=" '$(TestInParallel)' == '' ">false</TestInParallel>
    <TestResultsDirectory>$(MSBuildThisFileDirectory)bin\$(Configuration)\test\TestResults\</TestResultsDirectory>
    <SkipStrongNamesExe>$(MSBuildThisFileDirectory)packages\Microsoft.Web.SkipStrongNames.1.0.0\tools\SkipStrongNames.exe</SkipStrongNamesExe>
    <SkipStrongNamesXml>$(MSBuildThisFileDirectory)tools\SkipStrongNames.xml</SkipStrongNamesXml>
    <NuGetExe>.nuget\NuGet.exe</NuGetExe>
  </PropertyGroup>

  <Target Name="EnableSkipStrongNames" DependsOnTargets="RestoreSkipStrongNames">
    <Exec Command='"$(SkipStrongNamesExe)" -e "$(SkipStrongNamesXml)"' />
    <CheckSkipStrongNamesStatus AssembliesFile="$(SkipStrongNamesXml)">
      <Output TaskParameter="Status" PropertyName="Status" />
    </CheckSkipStrongNamesStatus>
    <Message Text="SkipStrongNames: $(Status)" Importance="High" />
  </Target>

  <Target Name="DisableSkipStrongNames" DependsOnTargets="RestoreSkipStrongNames">
    <Exec Command='"$(SkipStrongNamesExe)" -d "$(SkipStrongNamesXml)"' />
    <CheckSkipStrongNamesStatus AssembliesFile="$(SkipStrongNamesXml)">
      <Output TaskParameter="Status" PropertyName="Status" />
    </CheckSkipStrongNamesStatus>
    <Message Text="SkipStrongNames: $(Status)" Importance="High" />
  </Target>

  <Target Name="Integration" DependsOnTargets="Clean;Build;UnitTest" />

  <Target Name="Clean">
    <MSBuild
        Projects="Runtime.sln"
        Targets="Clean"
        Properties="Configuration=$(Configuration);VisualStudioVersion=$(VisualStudioVersion)" />
    <RemoveDir Directories="bin\$(Configuration)" />
  </Target>

  <Target Name="DownloadNuGet">
    <DownloadNuGet OutputFileName="$(NuGetExe)" MinimumVersion="2.12.0" />
  </Target>

  <Target Name="RestoreSkipStrongNames" DependsOnTargets="DownloadNuGet">
    <Exec Command='"$(NuGetExe)" restore .nuget\packages.config -PackagesDirectory packages -NonInteractive -Verbosity quiet' />
  </Target>

  <ItemGroup>
    <_Testing_NetStandard1_3 Include="true;false" />
  </ItemGroup>

  <Target Name="RestorePackages" DependsOnTargets="DownloadNuGet">
    <Message Text="%0ARestoring NuGet packages..." Importance="High" />

    <!--
      Pre-restore Microsoft.TestCommon due to the many dependencies on this project. Batch it to cover the full
      set of references. Remove $(Platform) to avoid 'Any CPU' appearing in output paths. Can always restore in
      parallel because $(Testing_NetStandard1_3) changes both obj/ and bin/ folders entirely.
    -->
    <MSBuild Projects="test\Microsoft.TestCommon\Microsoft.TestCommon.csproj" Targets="Restore"
      BuildInParallel="true"
      Properties="Configuration=$(Configuration);CodeAnalysis=$(CodeAnalysis);StyleCopEnabled=$(StyleCopEnabled);
                  RestorePackagesConfig=true;VisualStudioVersion=$(VisualStudioVersion);
                  Testing_NetStandard1_3=%(_Testing_NetStandard1_3.Identity)"
      RemoveProperties="Platform" />

    <MSBuild Projects="Runtime.sln" Targets="Restore"
      BuildInParallel="$(RestoreInParallel)"
      Properties="Configuration=$(Configuration);CodeAnalysis=$(CodeAnalysis);StyleCopEnabled=$(StyleCopEnabled);
                  RestorePackagesConfig=true;VisualStudioVersion=$(VisualStudioVersion)" />
    <Message Importance="High" Text="" />
  </Target>

  <!-- Pick the right Microsoft.Web.FxCop package to use and copy it to a standard location. -->
  <Target Name="BuildTools">
    <PropertyGroup>
        <FxCopProjectLocation>$(MSBuildThisFileDirectory)tools\src\Microsoft.Web.FxCop\</FxCopProjectLocation>
        <CustomFxCopRulesPath>$(MSBuildThisFileDirectory)packages\CustomFxCopRules</CustomFxCopRulesPath>
    </PropertyGroup>
    <MSBuild
        Condition=" '$(CodeAnalysis)' == 'true' "
        Projects="$(FxCopProjectLocation)\Microsoft.Web.FxCop.csproj"
        Properties="Configuration=Release;OutputPath=$(CustomFxCopRulesPath)" />
  </Target>

  <Target Name="Build" DependsOnTargets="RestoreSkipStrongNames;RestorePackages;BuildTools">
    <Error Condition=" '$(CodeAnalysis)' == 'true' and '$(Configuration)' == 'Release' "
      Text="Unable to run code analysis in Release configuration. Release assemblies do not include SuppressMessage attributes (so code analysis would always fail with the errors that are normally suppressed)." />
    <MakeDir Directories="bin\$(Configuration)" />

    <!--
      Prebuild Microsoft.TestCommon due to the many dependencies on this project. Batch it to cover the full
      set of references. Remove $(Platform) to avoid 'Any CPU' appearing in output paths. Can always build in
      parallel because $(Testing_NetStandard1_3) changes both obj/ and bin/ folders entirely.
    -->
    <MSBuild Projects="test\Microsoft.TestCommon\Microsoft.TestCommon.csproj" Targets="Build"
      BuildInParallel="true"
      Properties="Configuration=$(Configuration);CodeAnalysis=$(CodeAnalysis);StyleCopEnabled=$(StyleCopEnabled);
                  VisualStudioVersion=$(VisualStudioVersion);
                  Testing_NetStandard1_3=%(_Testing_NetStandard1_3.Identity)"
      RemoveProperties="Platform" />

    <MSBuild
        Projects="Runtime.sln"
        BuildInParallel="$(BuildInParallel)"
        Targets="Build"
        Properties="Configuration=$(Configuration);CodeAnalysis=$(CodeAnalysis);StyleCopEnabled=$(StyleCopEnabled);
                    VisualStudioVersion=$(VisualStudioVersion)" />
  </Target>

  <Target Name="UnitTest" DependsOnTargets="Build;PrintTestRunSummary" />

  <Target Name="RunTests" DependsOnTargets="CheckSkipStrongNames">
    <ItemGroup>
      <_TestDLLsXunit Include="bin\$(Configuration)\test\*.Test.dll;
                               bin\$(Configuration)\test\*\net4*\*.Test.dll" />
      <_XunitProject Include="tools\WebStack.testing.targets">
        <Properties>TestAssembly=%(_TestDLLsXunit.FullPath);
          XmlPath=$(TestResultsDirectory)%(_TestDLLsXunit.FileName)-XunitResults.xml</Properties>
      </_XunitProject>

      <_VSTestDLLs Include="bin\$(Configuration)\test\ns1_3\**\*.Test.dll;
                            bin\$(Configuration)\test\ns2_0\**\*.Test.dll"
          Exclude="bin\$(Configuration)\test\*\net4*\*.Test.dll" />
      <_XunitProject Include="tools\WebStack.testing.targets">
        <Properties>TestAssembly=%(_VSTestDLLs.FullPath);
          XmlPath=$(TestResultsDirectory)%(_VSTestDLLs.FileName)-$([System.String]::Copy('%(_VSTestDLLs.RecursiveDir)').Trim('\\'))-XunitResults.xml;
          UseVSTest=true</Properties>
      </_XunitProject>
    </ItemGroup>

    <!-- Recreate the test results directory so that print summary doesn't run on old test results. -->
    <RemoveDir Directories="$(TestResultsDirectory)" />
    <MakeDir Directories="$(TestResultsDirectory)" />

    <MSBuild Projects="@(_XunitProject)" BuildInParallel="$(TestInParallel)" Targets="TestAssembly">
      <Output TaskParameter="TargetOutputs" ItemName="_ExitCodes" />
    </MSBuild>
  </Target>

  <Target Name="CheckSkipStrongNames" DependsOnTargets="RestoreSkipStrongNames">
    <CheckSkipStrongNamesStatus AssembliesFile="$(SkipStrongNamesXml)">
      <Output TaskParameter="Status" PropertyName="Status" />
    </CheckSkipStrongNamesStatus>
    <Error Text="Unit tests will not run correctly unless SkipStrongNames is Enabled. Current status: $(Status). Run build.cmd EnableSkipStrongNames to fix this problem." Condition="'$(Status)' != 'Enabled'" />
  </Target>

  <Target Name="PrintTestRunSummary" DependsOnTargets="RunTests">
    <PrintTestRunSummary TestResultsDirectory="$(TestResultsDirectory)" />

    <!-- PrintTestRunSummary stops MSBuild if tests failed. But the Xunit target may fail for other reasons... -->
    <Error Text="Testing failed with exit code '%(Code)':%0A@(_ExitCodes -> '  %(Identity)', '%0A')"
        Condition=" '%(Code)' != '0' " />
  </Target>
</Project>


================================================
FILE: Runtime.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.27016.1
MinimumVisualStudioVersion = 15.0
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{C40883CD-366D-4534-8B58-3EA0D13136DF}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Razor", "src\System.Web.Razor\System.Web.Razor.csproj", "{8F18041B-9410-4C36-A9C5-067813DF5F31}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages.Deployment", "src\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj", "{22BABB60-8F02-4027-AFFC-ACF069954536}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages", "src\System.Web.WebPages\System.Web.WebPages.csproj", "{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Helpers", "src\System.Web.Helpers\System.Web.Helpers.csproj", "{9B7E3740-6161-4548-833C-4BBCA43B970E}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages.Razor", "src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj", "{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebMatrix.Data", "src\WebMatrix.Data\WebMatrix.Data.csproj", "{4D39BAAF-8A96-473E-AB79-C8A341885137}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebMatrix.WebData", "src\WebMatrix.WebData\WebMatrix.WebData.csproj", "{55A15F40-1435-4248-A7F2-2A146BB83586}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Web.Helpers", "src\Microsoft.Web.Helpers\Microsoft.Web.Helpers.csproj", "{0C7CE809-0F72-4C19-8C64-D6573E4D9521}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages.Administration", "src\System.Web.WebPages.Administration\System.Web.WebPages.Administration.csproj", "{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Mvc", "src\System.Web.Mvc\System.Web.Mvc.csproj", "{3D3FFD8A-624D-4E9B-954B-E1C105507975}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Web.Mvc", "src\Microsoft.Web.Mvc\Microsoft.Web.Mvc.csproj", "{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Razor.Test", "test\System.Web.Razor.Test\System.Web.Razor.Test.csproj", "{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages.Deployment.Test", "test\System.Web.WebPages.Deployment.Test\System.Web.WebPages.Deployment.Test.csproj", "{268DEE9D-F323-4A00-8ED8-3784388C3E3A}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages.Test", "test\System.Web.WebPages.Test\System.Web.WebPages.Test.csproj", "{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Helpers.Test", "test\System.Web.Helpers.Test\System.Web.Helpers.Test.csproj", "{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages.Razor.Test", "test\System.Web.WebPages.Razor.Test\System.Web.WebPages.Razor.Test.csproj", "{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebMatrix.Data.Test", "test\WebMatrix.Data.Test\WebMatrix.Data.Test.csproj", "{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebMatrix.WebData.Test", "test\WebMatrix.WebData.Test\WebMatrix.WebData.Test.csproj", "{CD48EB41-92A5-4628-A0F7-6A43DF58827E}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Web.Helpers.Test", "test\Microsoft.Web.Helpers.Test\Microsoft.Web.Helpers.Test.csproj", "{2C653A66-8159-4A41-954F-A67915DFDA87}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.WebPages.Administration.Test", "test\System.Web.WebPages.Administration.Test\System.Web.WebPages.Administration.Test.csproj", "{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Mvc.Test", "test\System.Web.Mvc.Test\System.Web.Mvc.Test.csproj", "{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Web.Mvc.Test", "test\Microsoft.Web.Mvc.Test\Microsoft.Web.Mvc.Test.csproj", "{6C28DA70-60F1-4442-967F-591BF3962EC5}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http", "src\System.Web.Http\System.Web.Http.csproj", "{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Test", "test\System.Web.Http.Test\System.Web.Http.Test.csproj", "{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Net.Http.Formatting", "src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj", "{668E9021-CE84-49D9-98FB-DF125A9FCDB0}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.TestCommon", "test\Microsoft.TestCommon\Microsoft.TestCommon.csproj", "{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Net.Http.Formatting.Test", "test\System.Net.Http.Formatting.Test\System.Net.Http.Formatting.Test.csproj", "{7AF77741-9158-4D5F-8782-8F21FADF025F}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.SelfHost", "src\System.Web.Http.SelfHost\System.Web.Http.SelfHost.csproj", "{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.WebHost", "src\System.Web.Http.WebHost\System.Web.Http.WebHost.csproj", "{A0187BC2-8325-4BB2-8697-7F955CF4173E}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Integration.Test", "test\System.Web.Http.Integration.Test\System.Web.Http.Integration.Test.csproj", "{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.WebHost.Test", "test\System.Web.Http.WebHost.Test\System.Web.Http.WebHost.Test.csproj", "{EA62944F-BD25-4730-9405-9BE8FF5BEACD}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Web.WebPages.OAuth", "src\Microsoft.Web.WebPages.OAuth\Microsoft.Web.WebPages.OAuth.csproj", "{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Web.WebPages.OAuth.Test", "test\Microsoft.Web.WebPages.OAuth.Test\Microsoft.Web.WebPages.OAuth.Test.csproj", "{694C6EDF-EA52-438F-B745-82B025ECC0E7}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.SelfHost.Test", "test\System.Web.Http.SelfHost.Test\System.Web.Http.SelfHost.Test.csproj", "{7F29EE87-6A63-43C6-B7FF-74DD06815830}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebApiHelpPage", "src\WebApiHelpPage\WebApiHelpPage.csproj", "{FEDFE6CA-8282-4C5B-A756-E97189690982}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebApiHelpPage.Test", "test\WebApiHelpPage.Test\WebApiHelpPage.Test.csproj", "{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Tracing", "src\System.Web.Http.Tracing\System.Web.Http.Tracing.csproj", "{6E81EF98-8F5C-4EED-8B37-456991CA56FD}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Tracing.Test", "test\System.Web.Http.Tracing.Test\System.Web.Http.Tracing.Test.csproj", "{F87FD911-4A97-4057-8EAE-1CB96B9A1937}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.SignalR", "src\System.Web.Http.SignalR\System.Web.Http.SignalR.csproj", "{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.SignalR.Test", "test\System.Web.Http.SignalR.Test\System.Web.Http.SignalR.Test.csproj", "{E22245AF-D5E1-46F6-B443-C886983EC50C}"
EndProject
Project("{F184B08F-C81C-45F6-A57F-5ABD9991F28F}") = "WebApiHelpPageVB", "src\WebApiHelpPage\VB\WebApiHelpPageVB.vbproj", "{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WebApiHelpPage.VB.Test", "test\WebApiHelpPage.VB.Test\WebApiHelpPage.VB.Test.csproj", "{41D5691F-2720-44A0-9185-EEFE928D2679}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Owin", "src\System.Web.Http.Owin\System.Web.Http.Owin.csproj", "{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Owin.Test", "test\System.Web.Http.Owin.Test\System.Web.Http.Owin.Test.csproj", "{C19267DD-3984-430C-AE18-4034F85DE4E5}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution items", "Solution items", "{CB34D534-9A09-4EE4-B350-C1C23AFBF5EE}"
	ProjectSection(SolutionItems) = preProject
		global.json = global.json
		NuGet.Config = NuGet.Config
		.nuget\packages.config = .nuget\packages.config
	EndProjectSection
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Cors", "src\System.Web.Cors\System.Web.Cors.csproj", "{43C1B979-D593-4A32-BB3A-4316F1C66D66}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Cors", "src\System.Web.Http.Cors\System.Web.Http.Cors.csproj", "{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Cors.Test", "test\System.Web.Cors.Test\System.Web.Cors.Test.csproj", "{BF07E947-120D-4E93-93DA-A4BF121753EA}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "System.Web.Http.Cors.Test", "test\System.Web.Http.Cors.Test\System.Web.Http.Cors.Test.csproj", "{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AspNet.Facebook", "src\Microsoft.AspNet.Facebook\Microsoft.AspNet.Facebook.csproj", "{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.AspNet.Facebook.Test", "test\Microsoft.AspNet.Facebook.Test\Microsoft.AspNet.Facebook.Test.csproj", "{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Http.Formatting.ns1_3", "src\System.Net.Http.Formatting.ns1_3\System.Net.Http.Formatting.ns1_3.csproj", "{5ABD9968-F3A3-4967-B768-A6142F69759E}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Http.Formatting.ns2_0", "src\System.Net.Http.Formatting.ns2_0\System.Net.Http.Formatting.ns2_0.csproj", "{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Http.Formatting.ns1_3.Test", "test\System.Net.Http.Formatting.ns1_3.Test\System.Net.Http.Formatting.ns1_3.Test.csproj", "{A1A20049-04C2-4676-93CF-92449C4BBAA9}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "System.Net.Http.Formatting.ns2_0.Test", "test\System.Net.Http.Formatting.ns2_0.Test\System.Net.Http.Formatting.ns2_0.Test.csproj", "{6C320AD9-F380-4F8B-85F9-0689F88766EC}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		CodeAnalysis|Any CPU = CodeAnalysis|Any CPU
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{8F18041B-9410-4C36-A9C5-067813DF5F31}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{8F18041B-9410-4C36-A9C5-067813DF5F31}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{8F18041B-9410-4C36-A9C5-067813DF5F31}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8F18041B-9410-4C36-A9C5-067813DF5F31}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8F18041B-9410-4C36-A9C5-067813DF5F31}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8F18041B-9410-4C36-A9C5-067813DF5F31}.Release|Any CPU.Build.0 = Release|Any CPU
		{22BABB60-8F02-4027-AFFC-ACF069954536}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{22BABB60-8F02-4027-AFFC-ACF069954536}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{22BABB60-8F02-4027-AFFC-ACF069954536}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{22BABB60-8F02-4027-AFFC-ACF069954536}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{22BABB60-8F02-4027-AFFC-ACF069954536}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{22BABB60-8F02-4027-AFFC-ACF069954536}.Release|Any CPU.Build.0 = Release|Any CPU
		{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}.Release|Any CPU.Build.0 = Release|Any CPU
		{9B7E3740-6161-4548-833C-4BBCA43B970E}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{9B7E3740-6161-4548-833C-4BBCA43B970E}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{9B7E3740-6161-4548-833C-4BBCA43B970E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{9B7E3740-6161-4548-833C-4BBCA43B970E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{9B7E3740-6161-4548-833C-4BBCA43B970E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{9B7E3740-6161-4548-833C-4BBCA43B970E}.Release|Any CPU.Build.0 = Release|Any CPU
		{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}.Release|Any CPU.Build.0 = Release|Any CPU
		{4D39BAAF-8A96-473E-AB79-C8A341885137}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{4D39BAAF-8A96-473E-AB79-C8A341885137}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{4D39BAAF-8A96-473E-AB79-C8A341885137}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{4D39BAAF-8A96-473E-AB79-C8A341885137}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{4D39BAAF-8A96-473E-AB79-C8A341885137}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{4D39BAAF-8A96-473E-AB79-C8A341885137}.Release|Any CPU.Build.0 = Release|Any CPU
		{55A15F40-1435-4248-A7F2-2A146BB83586}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{55A15F40-1435-4248-A7F2-2A146BB83586}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{55A15F40-1435-4248-A7F2-2A146BB83586}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{55A15F40-1435-4248-A7F2-2A146BB83586}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{55A15F40-1435-4248-A7F2-2A146BB83586}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{55A15F40-1435-4248-A7F2-2A146BB83586}.Release|Any CPU.Build.0 = Release|Any CPU
		{0C7CE809-0F72-4C19-8C64-D6573E4D9521}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{0C7CE809-0F72-4C19-8C64-D6573E4D9521}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{0C7CE809-0F72-4C19-8C64-D6573E4D9521}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{0C7CE809-0F72-4C19-8C64-D6573E4D9521}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{0C7CE809-0F72-4C19-8C64-D6573E4D9521}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{0C7CE809-0F72-4C19-8C64-D6573E4D9521}.Release|Any CPU.Build.0 = Release|Any CPU
		{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}.Release|Any CPU.Build.0 = Release|Any CPU
		{3D3FFD8A-624D-4E9B-954B-E1C105507975}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{3D3FFD8A-624D-4E9B-954B-E1C105507975}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{3D3FFD8A-624D-4E9B-954B-E1C105507975}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{3D3FFD8A-624D-4E9B-954B-E1C105507975}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{3D3FFD8A-624D-4E9B-954B-E1C105507975}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{3D3FFD8A-624D-4E9B-954B-E1C105507975}.Release|Any CPU.Build.0 = Release|Any CPU
		{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}.Release|Any CPU.Build.0 = Release|Any CPU
		{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}.Release|Any CPU.Build.0 = Release|Any CPU
		{268DEE9D-F323-4A00-8ED8-3784388C3E3A}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{268DEE9D-F323-4A00-8ED8-3784388C3E3A}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{268DEE9D-F323-4A00-8ED8-3784388C3E3A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{268DEE9D-F323-4A00-8ED8-3784388C3E3A}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{268DEE9D-F323-4A00-8ED8-3784388C3E3A}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{268DEE9D-F323-4A00-8ED8-3784388C3E3A}.Release|Any CPU.Build.0 = Release|Any CPU
		{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}.Release|Any CPU.Build.0 = Release|Any CPU
		{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}.Release|Any CPU.Build.0 = Release|Any CPU
		{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}.Release|Any CPU.Build.0 = Release|Any CPU
		{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}.Release|Any CPU.Build.0 = Release|Any CPU
		{CD48EB41-92A5-4628-A0F7-6A43DF58827E}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{CD48EB41-92A5-4628-A0F7-6A43DF58827E}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{CD48EB41-92A5-4628-A0F7-6A43DF58827E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{CD48EB41-92A5-4628-A0F7-6A43DF58827E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{CD48EB41-92A5-4628-A0F7-6A43DF58827E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{CD48EB41-92A5-4628-A0F7-6A43DF58827E}.Release|Any CPU.Build.0 = Release|Any CPU
		{2C653A66-8159-4A41-954F-A67915DFDA87}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{2C653A66-8159-4A41-954F-A67915DFDA87}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{2C653A66-8159-4A41-954F-A67915DFDA87}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{2C653A66-8159-4A41-954F-A67915DFDA87}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{2C653A66-8159-4A41-954F-A67915DFDA87}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{2C653A66-8159-4A41-954F-A67915DFDA87}.Release|Any CPU.Build.0 = Release|Any CPU
		{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}.Release|Any CPU.Build.0 = Release|Any CPU
		{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}.Release|Any CPU.Build.0 = Release|Any CPU
		{6C28DA70-60F1-4442-967F-591BF3962EC5}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{6C28DA70-60F1-4442-967F-591BF3962EC5}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{6C28DA70-60F1-4442-967F-591BF3962EC5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{6C28DA70-60F1-4442-967F-591BF3962EC5}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{6C28DA70-60F1-4442-967F-591BF3962EC5}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{6C28DA70-60F1-4442-967F-591BF3962EC5}.Release|Any CPU.Build.0 = Release|Any CPU
		{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}.Release|Any CPU.Build.0 = Release|Any CPU
		{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}.Release|Any CPU.Build.0 = Release|Any CPU
		{668E9021-CE84-49D9-98FB-DF125A9FCDB0}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{668E9021-CE84-49D9-98FB-DF125A9FCDB0}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{668E9021-CE84-49D9-98FB-DF125A9FCDB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{668E9021-CE84-49D9-98FB-DF125A9FCDB0}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{668E9021-CE84-49D9-98FB-DF125A9FCDB0}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{668E9021-CE84-49D9-98FB-DF125A9FCDB0}.Release|Any CPU.Build.0 = Release|Any CPU
		{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}.Release|Any CPU.Build.0 = Release|Any CPU
		{7AF77741-9158-4D5F-8782-8F21FADF025F}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{7AF77741-9158-4D5F-8782-8F21FADF025F}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{7AF77741-9158-4D5F-8782-8F21FADF025F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{7AF77741-9158-4D5F-8782-8F21FADF025F}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{7AF77741-9158-4D5F-8782-8F21FADF025F}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{7AF77741-9158-4D5F-8782-8F21FADF025F}.Release|Any CPU.Build.0 = Release|Any CPU
		{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}.Release|Any CPU.Build.0 = Release|Any CPU
		{A0187BC2-8325-4BB2-8697-7F955CF4173E}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{A0187BC2-8325-4BB2-8697-7F955CF4173E}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{A0187BC2-8325-4BB2-8697-7F955CF4173E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A0187BC2-8325-4BB2-8697-7F955CF4173E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A0187BC2-8325-4BB2-8697-7F955CF4173E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A0187BC2-8325-4BB2-8697-7F955CF4173E}.Release|Any CPU.Build.0 = Release|Any CPU
		{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}.Release|Any CPU.Build.0 = Release|Any CPU
		{EA62944F-BD25-4730-9405-9BE8FF5BEACD}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{EA62944F-BD25-4730-9405-9BE8FF5BEACD}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{EA62944F-BD25-4730-9405-9BE8FF5BEACD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{EA62944F-BD25-4730-9405-9BE8FF5BEACD}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{EA62944F-BD25-4730-9405-9BE8FF5BEACD}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{EA62944F-BD25-4730-9405-9BE8FF5BEACD}.Release|Any CPU.Build.0 = Release|Any CPU
		{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}.Release|Any CPU.Build.0 = Release|Any CPU
		{694C6EDF-EA52-438F-B745-82B025ECC0E7}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{694C6EDF-EA52-438F-B745-82B025ECC0E7}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{694C6EDF-EA52-438F-B745-82B025ECC0E7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{694C6EDF-EA52-438F-B745-82B025ECC0E7}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{694C6EDF-EA52-438F-B745-82B025ECC0E7}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{694C6EDF-EA52-438F-B745-82B025ECC0E7}.Release|Any CPU.Build.0 = Release|Any CPU
		{7F29EE87-6A63-43C6-B7FF-74DD06815830}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{7F29EE87-6A63-43C6-B7FF-74DD06815830}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{7F29EE87-6A63-43C6-B7FF-74DD06815830}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{7F29EE87-6A63-43C6-B7FF-74DD06815830}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{7F29EE87-6A63-43C6-B7FF-74DD06815830}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{7F29EE87-6A63-43C6-B7FF-74DD06815830}.Release|Any CPU.Build.0 = Release|Any CPU
		{FEDFE6CA-8282-4C5B-A756-E97189690982}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{FEDFE6CA-8282-4C5B-A756-E97189690982}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{FEDFE6CA-8282-4C5B-A756-E97189690982}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{FEDFE6CA-8282-4C5B-A756-E97189690982}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{FEDFE6CA-8282-4C5B-A756-E97189690982}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{FEDFE6CA-8282-4C5B-A756-E97189690982}.Release|Any CPU.Build.0 = Release|Any CPU
		{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}.Release|Any CPU.Build.0 = Release|Any CPU
		{6E81EF98-8F5C-4EED-8B37-456991CA56FD}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{6E81EF98-8F5C-4EED-8B37-456991CA56FD}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{6E81EF98-8F5C-4EED-8B37-456991CA56FD}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{6E81EF98-8F5C-4EED-8B37-456991CA56FD}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{6E81EF98-8F5C-4EED-8B37-456991CA56FD}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{6E81EF98-8F5C-4EED-8B37-456991CA56FD}.Release|Any CPU.Build.0 = Release|Any CPU
		{F87FD911-4A97-4057-8EAE-1CB96B9A1937}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{F87FD911-4A97-4057-8EAE-1CB96B9A1937}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{F87FD911-4A97-4057-8EAE-1CB96B9A1937}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{F87FD911-4A97-4057-8EAE-1CB96B9A1937}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{F87FD911-4A97-4057-8EAE-1CB96B9A1937}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{F87FD911-4A97-4057-8EAE-1CB96B9A1937}.Release|Any CPU.Build.0 = Release|Any CPU
		{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}.Release|Any CPU.Build.0 = Release|Any CPU
		{E22245AF-D5E1-46F6-B443-C886983EC50C}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{E22245AF-D5E1-46F6-B443-C886983EC50C}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{E22245AF-D5E1-46F6-B443-C886983EC50C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{E22245AF-D5E1-46F6-B443-C886983EC50C}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{E22245AF-D5E1-46F6-B443-C886983EC50C}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{E22245AF-D5E1-46F6-B443-C886983EC50C}.Release|Any CPU.Build.0 = Release|Any CPU
		{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}.Release|Any CPU.Build.0 = Release|Any CPU
		{41D5691F-2720-44A0-9185-EEFE928D2679}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{41D5691F-2720-44A0-9185-EEFE928D2679}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{41D5691F-2720-44A0-9185-EEFE928D2679}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{41D5691F-2720-44A0-9185-EEFE928D2679}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{41D5691F-2720-44A0-9185-EEFE928D2679}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{41D5691F-2720-44A0-9185-EEFE928D2679}.Release|Any CPU.Build.0 = Release|Any CPU
		{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}.Release|Any CPU.Build.0 = Release|Any CPU
		{C19267DD-3984-430C-AE18-4034F85DE4E5}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{C19267DD-3984-430C-AE18-4034F85DE4E5}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{C19267DD-3984-430C-AE18-4034F85DE4E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C19267DD-3984-430C-AE18-4034F85DE4E5}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{C19267DD-3984-430C-AE18-4034F85DE4E5}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C19267DD-3984-430C-AE18-4034F85DE4E5}.Release|Any CPU.Build.0 = Release|Any CPU
		{43C1B979-D593-4A32-BB3A-4316F1C66D66}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{43C1B979-D593-4A32-BB3A-4316F1C66D66}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{43C1B979-D593-4A32-BB3A-4316F1C66D66}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{43C1B979-D593-4A32-BB3A-4316F1C66D66}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{43C1B979-D593-4A32-BB3A-4316F1C66D66}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{43C1B979-D593-4A32-BB3A-4316F1C66D66}.Release|Any CPU.Build.0 = Release|Any CPU
		{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}.Release|Any CPU.Build.0 = Release|Any CPU
		{BF07E947-120D-4E93-93DA-A4BF121753EA}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{BF07E947-120D-4E93-93DA-A4BF121753EA}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{BF07E947-120D-4E93-93DA-A4BF121753EA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{BF07E947-120D-4E93-93DA-A4BF121753EA}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{BF07E947-120D-4E93-93DA-A4BF121753EA}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{BF07E947-120D-4E93-93DA-A4BF121753EA}.Release|Any CPU.Build.0 = Release|Any CPU
		{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}.Release|Any CPU.Build.0 = Release|Any CPU
		{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}.Release|Any CPU.Build.0 = Release|Any CPU
		{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}.Release|Any CPU.Build.0 = Release|Any CPU
		{5ABD9968-F3A3-4967-B768-A6142F69759E}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{5ABD9968-F3A3-4967-B768-A6142F69759E}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{5ABD9968-F3A3-4967-B768-A6142F69759E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{5ABD9968-F3A3-4967-B768-A6142F69759E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{5ABD9968-F3A3-4967-B768-A6142F69759E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{5ABD9968-F3A3-4967-B768-A6142F69759E}.Release|Any CPU.Build.0 = Release|Any CPU
		{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B}.Release|Any CPU.Build.0 = Release|Any CPU
		{A1A20049-04C2-4676-93CF-92449C4BBAA9}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{A1A20049-04C2-4676-93CF-92449C4BBAA9}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{A1A20049-04C2-4676-93CF-92449C4BBAA9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A1A20049-04C2-4676-93CF-92449C4BBAA9}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A1A20049-04C2-4676-93CF-92449C4BBAA9}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A1A20049-04C2-4676-93CF-92449C4BBAA9}.Release|Any CPU.Build.0 = Release|Any CPU
		{6C320AD9-F380-4F8B-85F9-0689F88766EC}.CodeAnalysis|Any CPU.ActiveCfg = CodeAnalysis|Any CPU
		{6C320AD9-F380-4F8B-85F9-0689F88766EC}.CodeAnalysis|Any CPU.Build.0 = CodeAnalysis|Any CPU
		{6C320AD9-F380-4F8B-85F9-0689F88766EC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{6C320AD9-F380-4F8B-85F9-0689F88766EC}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{6C320AD9-F380-4F8B-85F9-0689F88766EC}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{6C320AD9-F380-4F8B-85F9-0689F88766EC}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{8F18041B-9410-4C36-A9C5-067813DF5F31} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{22BABB60-8F02-4027-AFFC-ACF069954536} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{9B7E3740-6161-4548-833C-4BBCA43B970E} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{0939B11A-FE4E-4BA1-8AD6-D97741EE314F} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{4D39BAAF-8A96-473E-AB79-C8A341885137} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{55A15F40-1435-4248-A7F2-2A146BB83586} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{0C7CE809-0F72-4C19-8C64-D6573E4D9521} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{C23F02FC-4538-43F5-ABBA-38BA069AEA8F} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{3D3FFD8A-624D-4E9B-954B-E1C105507975} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{D3CF7430-6DA4-42B0-BD90-CA39D16687B2} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{268DEE9D-F323-4A00-8ED8-3784388C3E3A} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{66A74F3C-A106-4C1E-BAA0-001908FEA2CA} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{CD48EB41-92A5-4628-A0F7-6A43DF58827E} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{2C653A66-8159-4A41-954F-A67915DFDA87} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{21C729D6-ECF8-47EF-A236-7C6A4272EAF0} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{8AC2A2E4-2F11-4D40-A887-62E2583A65E6} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{6C28DA70-60F1-4442-967F-591BF3962EC5} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{668E9021-CE84-49D9-98FB-DF125A9FCDB0} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{7AF77741-9158-4D5F-8782-8F21FADF025F} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{A0187BC2-8325-4BB2-8697-7F955CF4173E} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{3267DFC6-B34D-4011-BC0F-D3B56AF6F608} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{EA62944F-BD25-4730-9405-9BE8FF5BEACD} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{694C6EDF-EA52-438F-B745-82B025ECC0E7} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{7F29EE87-6A63-43C6-B7FF-74DD06815830} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{FEDFE6CA-8282-4C5B-A756-E97189690982} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{291EF478-BF24-4935-BC78-E0DCCD0C9A1B} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{6E81EF98-8F5C-4EED-8B37-456991CA56FD} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{F87FD911-4A97-4057-8EAE-1CB96B9A1937} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{E22245AF-D5E1-46F6-B443-C886983EC50C} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{41D5691F-2720-44A0-9185-EEFE928D2679} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{C19267DD-3984-430C-AE18-4034F85DE4E5} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{43C1B979-D593-4A32-BB3A-4316F1C66D66} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{BF07E947-120D-4E93-93DA-A4BF121753EA} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{1E89A3E9-0A7F-418F-B4BE-6E38A6315373} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{821A136C-7C6F-44C6-A9E6-C39B5BFB1483} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{C3BEF382-C7C4-454D-B017-1EAC03E9A82C} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{5ABD9968-F3A3-4967-B768-A6142F69759E} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{9AAFB58C-B8C1-4D7F-80E6-7B95C94A829B} = {A9836F9E-6DB3-4D9F-ADCA-CF42D8C8BA93}
		{A1A20049-04C2-4676-93CF-92449C4BBAA9} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
		{6C320AD9-F380-4F8B-85F9-0689F88766EC} = {C40883CD-366D-4534-8B58-3EA0D13136DF}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {A855CFDC-9BEE-43A9-A3EA-4C4624A747DB}
	EndGlobalSection
EndGlobal


================================================
FILE: SECURITY.md
================================================
# Security Policy

## Reporting a Vulnerability

Security issues and bugs should be reported privately to the Microsoft Security Response Center (MSRC), either by emailing secure@microsoft.com or via the portal at https://msrc.microsoft.com.
You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your
original message. Further information, including the MSRC PGP key, can be found in the [MSRC Report an Issue FAQ](https://www.microsoft.com/en-us/msrc/faqs-report-an-issue).

Please do not open issues for anything you think might have a security implication.

================================================
FILE: Settings.StyleCop
================================================
<StyleCopSettings Version="105">
  <GlobalSettings>
    <StringProperty Name="MergeSettingsFiles">NoMerge</StringProperty>
  </GlobalSettings>
  <Parsers>
    <Parser ParserId="StyleCop.CSharp.CsParser">
      <ParserSettings>
        <BooleanProperty Name="AnalyzeDesignerFiles">False</BooleanProperty>
      </ParserSettings>
    </Parser>
  </Parsers>
  <Analyzers>
    <Analyzer AnalyzerId="StyleCop.CSharp.NamingRules">
      <Rules>
        <Rule Name="FieldNamesMustNotBeginWithUnderscore">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings>
        <CollectionProperty Name="Hungarian">
          <Value>as</Value>
          <Value>db</Value>
          <Value>dc</Value>
          <Value>do</Value>
          <Value>ef</Value>
          <Value>id</Value>
          <Value>if</Value>
          <Value>in</Value>
          <Value>is</Value>
          <Value>my</Value>
          <Value>no</Value>
          <Value>on</Value>
          <Value>sl</Value>
          <Value>to</Value>
          <Value>ui</Value>
          <Value>vs</Value>
        </CollectionProperty>
      </AnalyzerSettings>
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.DocumentationRules">
      <Rules>
        <Rule Name="FileMustHaveHeader">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileHeaderMustContainFileName">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileHeaderFileNameDocumentationMustMatchFileName">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileHeaderMustHaveValidCompanyText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ConstructorSummaryDocumentationMustBeginWithStandardText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="DestructorSummaryDocumentationMustBeginWithStandardText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="DocumentationHeadersMustNotContainBlankLines">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementsMustBeDocumented">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="PartialElementsMustBeDocumented">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="EnumerationItemsMustBeDocumented">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="DocumentationMustContainValidXml">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementDocumentationMustHaveSummary">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="PartialElementDocumentationMustHaveSummary">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementDocumentationMustHaveSummaryText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="PartialElementDocumentationMustHaveSummaryText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementDocumentationMustNotHaveDefaultSummary">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementParametersMustBeDocumented">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementParameterDocumentationMustMatchElementParameters">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementParameterDocumentationMustDeclareParameterName">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementParameterDocumentationMustHaveText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementReturnValueMustBeDocumented">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementReturnValueDocumentationMustHaveText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="VoidReturnValueMustNotBeDocumented">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="GenericTypeParametersMustBeDocumented">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="GenericTypeParametersMustBeDocumentedPartialClass">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="GenericTypeParameterDocumentationMustMatchTypeParameters">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="GenericTypeParameterDocumentationMustDeclareParameterName">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="GenericTypeParameterDocumentationMustHaveText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="PropertySummaryDocumentationMustMatchAccessors">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="PropertySummaryDocumentationMustOmitSetAccessorWithRestrictedAccess">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementDocumentationMustNotBeCopiedAndPasted">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="SingleLineCommentsMustNotUseDocumentationStyleSlashes">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="DocumentationTextMustNotBeEmpty">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="DocumentationTextMustContainWhitespace">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="DocumentationMustMeetCharacterPercentage">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="IncludedDocumentationXPathDoesNotExist">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="IncludeNodeDoesNotContainValidFileAndPath">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="InheritDocMustBeUsedWithInheritingClass">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileHeaderMustShowCopyright">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileHeaderMustHaveCopyrightText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileHeaderFileNameDocumentationMustMatchTypeName">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings>
        <BooleanProperty Name="IgnorePrivates">True</BooleanProperty>
        <BooleanProperty Name="IgnoreInternals">True</BooleanProperty>
      </AnalyzerSettings>
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.ReadabilityRules">
      <Rules>
        <Rule Name="ParameterMustNotSpanMultipleLines">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="PrefixLocalCallsWithThis">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ParameterMustFollowComma">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="SplitParametersMustStartOnLineAfterDeclaration">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ParametersMustBeOnSameLineOrSeparateLines">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="UseBuiltInTypeAlias">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.LayoutRules">
      <Rules>
        <Rule Name="AllAccessorsMustBeMultiLineOrSingleLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="SingleLineCommentsMustNotBeFollowedByBlankLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ClosingCurlyBracketMustBeFollowedByBlankLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="SingleLineCommentMustBePrecededByBlankLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementsMustBeSeparatedByBlankLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.MaintainabilityRules">
      <Rules>
        <Rule Name="FieldsMustBePrivate">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="DebugAssertMustProvideMessageText">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="StatementMustNotUseUnnecessaryParenthesis">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.OrderingRules">
      <Rules>
        <Rule Name="UsingDirectivesMustBePlacedWithinNamespace">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementsMustAppearInTheCorrectOrder">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementsMustBeOrderedByAccess">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ConstantsMustAppearBeforeFields">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="StaticElementsMustAppearBeforeInstanceElements">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.SpacingRules">
      <Rules>
        <Rule Name="SingleLineCommentsMustBeginWithSingleSpace">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="Microsoft.Web.StyleCop.Rules">
      <Rules />
      <AnalyzerSettings>
        <StringProperty Name="FileHeaderText"> Copyright (c) .NET Foundation. All rights reserved. Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.</StringProperty>
      </AnalyzerSettings>
    </Analyzer>
  </Analyzers>
</StyleCopSettings>

================================================
FILE: Tools.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.27016.1
MinimumVisualStudioVersion = 15.0
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Microsoft.Web.FxCop", "tools\src\Microsoft.Web.FxCop\Microsoft.Web.FxCop.csproj", "{F439D4E6-3FAC-4C30-9585-6D258133A2BF}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{F439D4E6-3FAC-4C30-9585-6D258133A2BF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{F439D4E6-3FAC-4C30-9585-6D258133A2BF}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{F439D4E6-3FAC-4C30-9585-6D258133A2BF}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{F439D4E6-3FAC-4C30-9585-6D258133A2BF}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {F8728741-0321-4EF6-9359-7DF2DCE6E99E}
	EndGlobalSection
EndGlobal


================================================
FILE: azure-pipelines-public.yml
================================================
parameters:
  # Test only the Release build by default.
- name: ReleaseBuildTarget
  displayName: 'Build which target for Release?'
  type: string
  values: [ Build, Integration, UnitTest ]
  default: UnitTest
- name: OtherBuildTarget
  displayName: 'Build which target for Debug/CodeAnalysis?'
  type: string
  values: [ Build, Integration, UnitTest ]
  default: Build

variables:
- name: DOTNET_CLI_TELEMETRY_OPTOUT
  value: 1
- name: DOTNET_NOLOGO
  value: 1
  # Run CodeQL3000 tasks in a separate internal pipeline; not needed here.
- name: Codeql.SkipTaskAutoInjection
  value: true

trigger: [main]
pr: ['*']

stages:
- stage: build
  displayName: Build
  jobs:
  - template: /eng/templates/default-build.yml
    parameters:
      ReleaseBuildTarget: ${{ parameters.ReleaseBuildTarget }}
      OtherBuildTarget: ${{ parameters.OtherBuildTarget }}


================================================
FILE: azure-pipelines.yml
================================================
parameters:
  # Test only the Release build by default.
- name: ReleaseBuildTarget
  displayName: 'Build which target for Release?'
  type: string
  values: [ Build, Integration, UnitTest ]
  default: Build
- name: OtherBuildTarget
  displayName: 'Build which target for Debug/CodeAnalysis?'
  type: string
  values: [ Build, Integration, UnitTest ]
  default: Build

variables:
- name: DOTNET_CLI_TELEMETRY_OPTOUT
  value: 1
- name: DOTNET_NOLOGO
  value: 1
  # Run CodeQL3000 tasks in a separate internal pipeline; not needed here.
- name: Codeql.SkipTaskAutoInjection
  value: true

trigger: [main]
pr: ['*']

resources:
  repositories:
  # Repo: 1ESPipelineTemplates/1ESPipelineTemplates
  - repository: 1esPipelines
    type: git
    name: 1ESPipelineTemplates/1ESPipelineTemplates
    ref: refs/tags/release

extends:
  template: v1/1ES.Official.PipelineTemplate.yml@1esPipelines
  parameters:
    settings:
      networkIsolationPolicy: Permissive, CFSClean, CFSClean2
    sdl:
      policheck:
        enabled: true
      tsa:
        enabled: true
    pool:
      name: NetCore1ESPool-Svc-Internal
      demands:
      - ImageOverride -equals windows.vs2019.amd64
      - ImageVersionOverride -equals 2026.0304.014948
      os: windows
    stages:
    - stage: build
      displayName: Build
      jobs:
      - template: /eng/templates/default-build.yml@self
        parameters:
          ReleaseBuildTarget: ${{ parameters.ReleaseBuildTarget }}
          OtherBuildTarget: ${{ parameters.OtherBuildTarget }}


================================================
FILE: build.cmd
================================================
@echo off
setlocal

if exist bin goto Build
mkdir bin

:Build

REM Require VS2019 (v16.0) on the system. Use `vswhere` for the search because it can find all VS installations.
set vswhere="%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe"
if not exist %vswhere% (
  set vswhere="%ProgramFiles%\Microsoft Visual Studio\Installer\vswhere.exe"
)
if not exist %vswhere% (
  REM vswhere.exe not in normal locations; check the Path.
  for %%X in (vswhere.exe) do (
    set vswhere="%%~$PATH:X"
  )
)
if not exist %vswhere% (
  echo Could not find vswhere.exe. Please run this from a Visual Studio developer prompt.
  goto BuildFail
)

set InstallDir=
for /f "usebackq tokens=*" %%i in (`%vswhere% -version 16 -latest -prerelease -products * ^
    -requires Microsoft.Net.Component.4.5.TargetingPack ^
    -requires Microsoft.Net.Component.4.5.2.TargetingPack ^
    -requires Microsoft.Net.Component.4.6.2.TargetingPack ^
    -property installationPath`) do (
  set "InstallDir=%%i"
)

if not DEFINED InstallDir (
  echo "Could not find a VS2019 installation with the necessary components (targeting packs for v4.5, v4.5.2, and v4.6.2)."
  echo Please install VS2019 or the missing components.
  goto BuildFail
)

REM Find a 64bit MSBuild and add it to path. Require v17.8.3 or later due to our .NET SDK choice.
REM Check for VS2022 first.
set InstallDir=
for /f "usebackq tokens=*" %%i in (`%vswhere% -version 17.8.3 -latest -prerelease -products * ^
    -requires Microsoft.Component.MSBuild ^
    -property installationPath`) do (
  set "InstallDir=%%i"
)

if DEFINED InstallDir (
  REM Add MSBuild to the path.
  set "PATH=%InstallDir%\MSBuild\Current\Bin;%PATH%"
  goto FoundMSBuild
)

REM Otherwise find or install an xcopy-able MSBuild.
echo "Could not find a VS2022 installation with the necessary components (MSBuild). Falling back..."

set "MSBuildVersion=17.8.5"
set "Command=[System.Threading.Thread]::CurrentThread.CurrentCulture = ''"
set "Command=%Command%; [System.Threading.Thread]::CurrentThread.CurrentUICulture = ''"
set "Command=%Command%; try { & '%~dp0eng\GetXCopyMSBuild.ps1' %MSBuildVersion%; exit $LASTEXITCODE }"
set "Command=%Command%  catch { write-host $_; exit 1 }"
PowerShell -NoProfile -NoLogo -ExecutionPolicy Bypass -Command "%Command%"
if %ERRORLEVEL% neq 0 goto BuildFail

REM Add MSBuild to the path.
set "PATH=%~dp0.msbuild\%MSBuildVersion%\tools\MSBuild\Current\Bin;%PATH%"

:FoundMSBuild
REM Configure NuGet operations to work w/in this repo i.e. do not pollute system packages folder.
REM Note this causes two copies of packages restored using packages.config to land in this folder e.g.
REM StyleCpy.5.0.0/ and stylecop/5.0.0/.
set "NUGET_PACKAGES=%~dp0packages"

REM Are we running in a local dev environment (not on CI)?
if DEFINED CI (set Desktop=false) else if DEFINED TEAMCITY_VERSION (set Desktop=false) else (set Desktop=true)

pushd %~dp0
if "%1" == "" goto BuildDefaults

MSBuild "%~dp0Runtime.msbuild" /m /nr:false /p:Platform="Any CPU" /p:Desktop=%Desktop% /v:M ^
    /fl /fileLoggerParameters:LogFile=bin\msbuild.log;Verbosity=Normal /consoleLoggerParameters:Summary /t:%*
if %ERRORLEVEL% neq 0 goto BuildFail
goto BuildSuccess

:BuildDefaults
MSBuild "%~dp0Runtime.msbuild" /m /nr:false /p:Platform="Any CPU" /p:Desktop=%Desktop% /v:M ^
    /fl /fileLoggerParameters:LogFile=bin\msbuild.log;Verbosity=Normal /consoleLoggerParameters:Summary
if %ERRORLEVEL% neq 0 goto BuildFail
goto BuildSuccess

:BuildFail
echo.
echo *** BUILD FAILED ***
popd
endlocal
exit /B 999

:BuildSuccess
echo.
echo **** BUILD SUCCESSFUL ***
popd
endlocal
exit /B 0


================================================
FILE: eng/GetXCopyMSBuild.ps1
================================================
# Lifted from https://github.com/dotnet/arcade/blob/main/eng/common/tools.ps1

[CmdletBinding(DefaultParameterSetName='Groups')]
param(
    [string]$Version = '17.4.1'
)

Set-StrictMode -Version 2
$ErrorActionPreference = 'Stop'

function Create-Directory ([string[]] $path) {
  New-Item -Path $path -Force -ItemType 'Directory' | Out-Null
}

function Unzip([string]$zipfile, [string]$outpath) {
  Add-Type -AssemblyName System.IO.Compression.FileSystem
  [System.IO.Compression.ZipFile]::ExtractToDirectory($zipfile, $outpath)
}

function InitializeXCopyMSBuild([string]$packageVersion, [bool]$install, [string]$ToolsDir) {
  $packageName = 'RoslynTools.MSBuild'
  $packageDir = Join-Path $ToolsDir $packageVersion
  $packagePath = Join-Path $packageDir "$packageName.$packageVersion.nupkg"

  if (!(Test-Path $packageDir)) {
    if (!$install) {
      return $null
    }

    Create-Directory $packageDir

    Write-Host "Downloading $packageName $packageVersion"
    $ProgressPreference = 'SilentlyContinue' # Don't display the console progress UI - it's a huge perf hit
    Invoke-WebRequest "https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-eng/nuget/v3/flat2/$packageName/$packageVersion/$packageName.$packageVersion.nupkg" -OutFile $packagePath

    Unzip $packagePath $packageDir
  }

  return Join-Path $packageDir 'tools'
}

$RepoRoot = Resolve-Path (Join-Path $PSScriptRoot '..\')
InitializeXCopyMSBuild -packageVersion $Version -install $true -ToolsDir (join-path $RepoRoot .msbuild)


================================================
FILE: eng/templates/default-build.yml
================================================
parameters:
  ReleaseBuildTarget: ''
  OtherBuildTarget: ''

jobs:
- job: build
  displayName: Build
  ${{ if eq(variables['System.TeamProject'], 'public') }}:
    pool:
      name: NetCore-Svc-Public
      demands:
      - ImageOverride -equals windows.vs2019.amd64.open
  timeoutInMinutes: 30

  strategy:
    matrix:
      Release:
        _BuildTarget: ${{ parameters.ReleaseBuildTarget }}
        _Configuration: Release
        _StyleCopEnabled: true
        # Do CG work only in internal pipelines.
        skipComponentGovernanceDetection: ${{ eq(variables['System.TeamProject'], 'public') }}
      Debug:
        _BuildTarget: ${{ parameters.OtherBuildTarget }}
        _Configuration: Debug
        _StyleCopEnabled: false
        # Do not redo CG work. Configuration changes in this part of the matrix are not relevant to CG.
        skipComponentGovernanceDetection: true
      CodeAnalysis:
        _BuildTarget: ${{ parameters.OtherBuildTarget }}
        _Configuration: CodeAnalysis
        _StyleCopEnabled: false
        # Do not redo CG work. Configuration changes in this part of the matrix are not relevant to CG.
        skipComponentGovernanceDetection: true

  steps:
  - checkout: self
    clean: true
    displayName: Checkout

  - task: UseDotNet@2
    displayName: Get .NET SDK
    inputs:
      useGlobalJson: true
  - task: UseDotNet@2
    displayName: Get .NET 2.1 runtime
    inputs:
      packageType: runtime
      version: '2.1.x'

  - script: .\build.cmd EnableSkipStrongNames
    displayName: Enable SkipStrongNames
  - script: .\build.cmd $(_BuildTarget) ^
      /binaryLogger:artifacts/msbuild.binlog /p:Configuration=$(_Configuration) /p:StyleCopEnabled=$(_StyleCopEnabled) ^
      /fileLoggerParameters:LogFile=artifacts/msbuild.log;Summary;Verbosity=minimal
    displayName: Build

  - ${{ if eq(variables['System.TeamProject'], 'public') }}:
    - task: PublishBuildArtifacts@1
      displayName: Upload test results
      condition: and(always(), ne(variables._BuildTarget, 'Build'))
      continueOnError: true
      inputs:
        pathtoPublish: ./bin/$(_Configuration)/Test/TestResults/
        artifactName: $(_Configuration) Test Results $(System.JobId)
        artifactType: Container
        parallel: true
    - task: PublishTestResults@2
      condition: and(always(), ne(variables._BuildTarget, 'Build'))
      continueOnError: true
      displayName: Publish test results
      inputs:
        mergeTestResults: true
        searchFolder: ./bin/$(_Configuration)/Test/TestResults/
        testResultsFiles: '*.xml'
        testRunner: xUnit
        testRunTitle: $(_Configuration)
    - task: PublishBuildArtifacts@1
      displayName: Upload logs
      condition: always()
      continueOnError: true
      inputs:
        pathtoPublish: ./artifacts/
        artifactName: $(_Configuration) Logs $(System.JobId)
        artifactType: Container
        parallel: true
  - ${{ if eq(variables['System.TeamProject'], 'internal') }}: 
    - task: 1ES.PublishPipelineArtifact@1
      inputs:
        condition: and(always(), ne(variables._BuildTarget, 'Build'))
        path: ./bin/$(_Configuration)/Test/TestResults/
        artifact: $(_Configuration) Test Results $(System.JobId)
    - task: 1ES.PublishPipelineArtifact@1
      inputs:
        path: ./artifacts/
        artifact: $(_Configuration) Logs $(System.JobId)


================================================
FILE: es-metadata.yml
================================================
schemaVersion: 0.0.1
isProduction: true
accountableOwners:
  service: 4db45fa9-fb0f-43ce-b523-ad1da773dfbc
routing:
  defaultAreaPath:
    org: devdiv
    path: DevDiv\ASP.NET Core


================================================
FILE: global.json
================================================
{
  "sdk": {
    "version": "8.0.419",
    "rollForward": "major"
  }
}


================================================
FILE: src/CodeAnalysisDictionary.xml
================================================
<?xml version="1.0" encoding="utf-8" ?>
<Dictionary>
    <Words>
        <Recognized>
            <Word>Multi</Word>
            <Word>Bitly</Word>
            <Word>Digg</Word>
            <Word>Facebook</Word>
            <Word>Reddit</Word>
            <Word>Captcha</Word>
            <Word>Facebook</Word>
            <Word>Gravatar</Word>
            <Word>JSON</Word>
            <Word>Lookahead</Word>
            <Word>MVC</Word>
            <Word>Param</Word>
            <Word>Params</Word>
            <Word>Pluralizer</Word>
            <Word>Pragma</Word>
            <Word>Pragmas</Word>
            <Word>Templating</Word>
            <Word>Unvalidated</Word>
            <Word>Validator</Word>
            <Word>Validators</Word>
            <Word>Validatable</Word>
            <Word>WebPage</Word>
            <Word>cshtml</Word>
            <Word>vbhtml</Word>
            <Word>asax</Word>
            <Word>Eval</Word>
            <Word>Src</Word>
            <Word>Charset</Word>
            <Word>Coords</Word>
            <Word>Rel</Word>
            <Word>Dto</Word>
            <Word>Tokenizer</Word>
            <Word>ReDim</Word>
            <Word>OAuth</Word>
            <Word>OpenID</Word>
            <Word>Yadis</Word>
            <Word>fwlink</Word>
            <Word>Edm</Word>
            <Word>Deserializer</Word>
            <Word>Api</Word>
            <Word>ws</Word>
            <Word>enc</Word>
            <Word>dir</Word>
            <Word>Auth</Word>
            <Word>bg</Word>
            <Word>Cors</Word>
            <Word>Owin</Word>
            <Word>Unbuffered</Word>
            <Word>Rfc</Word>
            <Word>Realtime</Word>
            <Word>ModelName</Word>
            <Word>BSON</Word>
            <Word>Untyped</Word>
            <Word>Behavior</Word>
            <Word>Callback</Word>
            <Word>Canceled</Word>
            <Word>Color</Word>
            <Word>Fallback</Word>
            <Word>Markup</Word>
            <Word>Preflight</Word>
        </Recognized>
        <Compound>
            <Term CompoundAlternate="WebPage">WebPage</Term>
            <Term CompoundAlternate="WebPages">WebPages</Term>
            <Term CompoundAlternate="TimeLine">TimeLine</Term>
            <Term CompoundAlternate="OAuth">oAuth</Term>
            <Term CompoundAlternate="UserName">userName</Term>
            <Term CompoundAlternate="ModelName">modelName</Term>
            <Term CompoundAlternate="HasId">HasId</Term>
        </Compound>
    </Words>
    <Acronyms>
        <CasingExceptions>
            <Acronym>ID</Acronym>
            <Acronym>Db</Acronym>
            <Acronym>Dto</Acronym>
        </CasingExceptions>
    </Acronyms>
</Dictionary>

================================================
FILE: src/Common/AttributeList.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;

namespace System.ComponentModel
{
    /// <summary>
    /// Wrapper for AttributeCollection to provide generic collection implementation.
    /// </summary>
    internal sealed class AttributeList : IList<Attribute>
    {
        private readonly AttributeCollection _attributes;

        public AttributeList(AttributeCollection attributes)
        {
            Contract.Assert(attributes != null);
            _attributes = attributes;
        }

        public int Count
        {
            get
            {
                return _attributes.Count;
            }
        }

        public bool IsReadOnly
        {
            get
            {
                return true;
            }
        }

        public Attribute this[int index]
        {
            get
            {
                return _attributes[index];
            }
            set
            {
                throw new NotSupportedException();
            }
        }

        public void Add(Attribute attribute)
        {
            throw new NotSupportedException();
        }

        public void Clear()
        {
            throw new NotSupportedException();
        }

        public bool Contains(Attribute attribute)
        {
            return _attributes.Contains(attribute);
        }

        public void CopyTo(Attribute[] target, int startIndex)
        {
            _attributes.CopyTo(target, startIndex);
        }

        public IEnumerator<Attribute> GetEnumerator()
        {
            for (int i = 0; i < _attributes.Count; i++)
            {
                yield return _attributes[i];
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_attributes).GetEnumerator();
        }

        public int IndexOf(Attribute attribute)
        {
            for (int i = 0; i < _attributes.Count; i++)
            {
                if (attribute == _attributes[i]) 
                {
                    return i;
                }                
            }
            return -1;
        }

        public void Insert(int index, Attribute attribute)
        {
            throw new NotSupportedException();
        }

        bool ICollection<Attribute>.Remove(Attribute attribute)
        {
            throw new NotSupportedException();
        }

        public void RemoveAt(int index)
        {
            throw new NotSupportedException();
        }
    }
}


================================================
FILE: src/Common/CollectionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.Linq;

namespace System.Collections.Generic
{
    /// <summary>
    /// Helper extension methods for fast use of collections.
    /// </summary>
    internal static class CollectionExtensions
    {
        /// <summary>
        /// Return a new array with the value added to the end. Slow and best suited to long lived arrays with few writes relative to reads.
        /// </summary>
        public static T[] AppendAndReallocate<T>(this T[] array, T value)
        {
            Contract.Assert(array != null);

            int originalLength = array.Length;
            T[] newArray = new T[originalLength + 1];
            array.CopyTo(newArray, 0);
            newArray[originalLength] = value;
            return newArray;
        }

        /// <summary>
        /// Return the enumerable as an Array, copying if required. Optimized for common case where it is an Array.
        /// Avoid mutating the return value.
        /// </summary>
        public static T[] AsArray<T>(this IEnumerable<T> values)
        {
            Contract.Assert(values != null);

            T[] array = values as T[];
            if (array == null)
            {
                array = values.ToArray();
            }
            return array;
        }

        /// <summary>
        /// Return the enumerable as a Collection of T, copying if required. Optimized for the common case where it is
        /// a Collection of T and avoiding a copy if it implements IList of T. Avoid mutating the return value.
        /// </summary>
        public static Collection<T> AsCollection<T>(this IEnumerable<T> enumerable)
        {
            Contract.Assert(enumerable != null);

            Collection<T> collection = enumerable as Collection<T>;
            if (collection != null)
            {
                return collection;
            }
            // Check for IList so that collection can wrap it instead of copying
            IList<T> list = enumerable as IList<T>;
            if (list == null)
            {
                list = new List<T>(enumerable);
            }
            return new Collection<T>(list);
        }

        /// <summary>
        /// Return the enumerable as a IList of T, copying if required. Avoid mutating the return value.
        /// </summary>
        public static IList<T> AsIList<T>(this IEnumerable<T> enumerable)
        {
            Contract.Assert(enumerable != null);

            IList<T> list = enumerable as IList<T>;
            if (list != null)
            {
                return list;
            }
            return new List<T>(enumerable);
        }

        /// <summary>
        /// Return the enumerable as a List of T, copying if required. Optimized for common case where it is an List of T
        /// or a ListWrapperCollection of T. Avoid mutating the return value.
        /// </summary>
        public static List<T> AsList<T>(this IEnumerable<T> enumerable)
        {
            Contract.Assert(enumerable != null);

            List<T> list = enumerable as List<T>;
            if (list != null)
            {
                return list;
            }
            ListWrapperCollection<T> listWrapper = enumerable as ListWrapperCollection<T>;
            if (listWrapper != null)
            {
                return listWrapper.ItemsList;
            }
            return new List<T>(enumerable);
        }

        /// <summary>
        /// Remove values from the list starting at the index start.
        /// </summary>
        public static void RemoveFrom<T>(this List<T> list, int start)
        {
            Contract.Assert(list != null);
            Contract.Assert(start >= 0 && start <= list.Count);

            list.RemoveRange(start, list.Count - start);
        }

        /// <summary>
        /// Return the only value from list, the type's default value if empty, or call the errorAction for 2 or more.
        /// </summary>
        public static T SingleDefaultOrError<T, TArg1>(this IList<T> list, Action<TArg1> errorAction, TArg1 errorArg1)
        {
            Contract.Assert(list != null);
            Contract.Assert(errorAction != null);

            switch (list.Count)
            {
                case 0:
                    return default(T);

                case 1:
                    T value = list[0];
                    return value;

                default:
                    errorAction(errorArg1);
                    return default(T);
            }
        }

        /// <summary>
        /// Returns a single value in list matching type TMatch if there is only one, null if there are none of type TMatch or calls the
        /// errorAction with errorArg1 if there is more than one.
        /// </summary>
        public static TMatch SingleOfTypeDefaultOrError<TInput, TMatch, TArg1>(this IList<TInput> list, Action<TArg1> errorAction, TArg1 errorArg1) where TMatch : class
        {
            Contract.Assert(list != null);
            Contract.Assert(errorAction != null);

            TMatch result = null;
            for (int i = 0; i < list.Count; i++)
            {
                TMatch typedValue = list[i] as TMatch;
                if (typedValue != null)
                {
                    if (result == null)
                    {
                        result = typedValue;
                    }
                    else
                    {
                        errorAction(errorArg1);
                        return null;
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// Convert an ICollection to an array, removing null values. Fast path for case where there are no null values.
        /// </summary>
        public static T[] ToArrayWithoutNulls<T>(this ICollection<T> collection) where T : class
        {
            Contract.Assert(collection != null);

            T[] result = new T[collection.Count];
            int count = 0;
            foreach (T value in collection)
            {
                if (value != null)
                {
                    result[count] = value;
                    count++;
                }
            }
            if (count == collection.Count)
            {
                return result;
            }
            else
            {
                T[] trimmedResult = new T[count];
                Array.Copy(result, trimmedResult, count);
                return trimmedResult;
            }
        }

        /// <summary>
        /// Convert the array to a Dictionary using the keySelector to extract keys from values and the specified comparer. Optimized for array input.
        /// </summary>
        public static Dictionary<TKey, TValue> ToDictionaryFast<TKey, TValue>(this TValue[] array, Func<TValue, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            Contract.Assert(array != null);
            Contract.Assert(keySelector != null);

            Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>(array.Length, comparer);
            for (int i = 0; i < array.Length; i++)
            {
                TValue value = array[i];
                dictionary.Add(keySelector(value), value);
            }
            return dictionary;
        }

        /// <summary>
        /// Convert the list to a Dictionary using the keySelector to extract keys from values and the specified comparer. Optimized for IList of T input with fast path for array.
        /// </summary>
        public static Dictionary<TKey, TValue> ToDictionaryFast<TKey, TValue>(this IList<TValue> list, Func<TValue, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            Contract.Assert(list != null);
            Contract.Assert(keySelector != null);

            TValue[] array = list as TValue[];
            if (array != null)
            {
                return ToDictionaryFast(array, keySelector, comparer);
            }
            return ToDictionaryFastNoCheck(list, keySelector, comparer);
        }

        /// <summary>
        /// Convert the enumerable to a Dictionary using the keySelector to extract keys from values and the specified comparer. Fast paths for array and IList of T.
        /// </summary>
        public static Dictionary<TKey, TValue> ToDictionaryFast<TKey, TValue>(this IEnumerable<TValue> enumerable, Func<TValue, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            Contract.Assert(enumerable != null);
            Contract.Assert(keySelector != null);

            TValue[] array = enumerable as TValue[];
            if (array != null)
            {
                return ToDictionaryFast(array, keySelector, comparer);
            }
            IList<TValue> list = enumerable as IList<TValue>;
            if (list != null)
            {
                return ToDictionaryFastNoCheck(list, keySelector, comparer);
            }
            Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>(comparer);
            foreach (TValue value in enumerable)
            {
                dictionary.Add(keySelector(value), value);
            }
            return dictionary;
        }

        /// <summary>
        /// Convert the list to a Dictionary using the keySelector to extract keys from values and the specified comparer. Optimized for IList of T input. No checking for other types.
        /// </summary>
        private static Dictionary<TKey, TValue> ToDictionaryFastNoCheck<TKey, TValue>(IList<TValue> list, Func<TValue, TKey> keySelector, IEqualityComparer<TKey> comparer)
        {
            Contract.Assert(list != null);
            Contract.Assert(keySelector != null);

            int listCount = list.Count;
            Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>(listCount, comparer);
            for (int i = 0; i < listCount; i++)
            {
                TValue value = list[i];
                dictionary.Add(keySelector(value), value);
            }
            return dictionary;
        }
    }
}


================================================
FILE: src/Common/CommonWebApiResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.Properties {
    using System;
    using System.Linq;
    using System.Reflection;

    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class CommonWebApiResources {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal CommonWebApiResources() {
        }

        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
#if NETSTANDARD1_3
                    var assembly = typeof(CommonWebApiResources).GetTypeInfo().Assembly;
#else
                    var assembly = typeof(CommonWebApiResources).Assembly;
#endif

                    // Find the CommonResources.resources file's full resource name in this assembly
                    string commonResourcesName = assembly.GetManifestResourceNames().Where(s => s.EndsWith("CommonWebApiResources.resources", StringComparison.OrdinalIgnoreCase)).Single();

                    // Trim off the ".resources"
                    commonResourcesName = commonResourcesName.Substring(0, commonResourcesName.Length - 10);

                    // Load the resource manager
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager(commonResourcesName, assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }

        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Relative URI values are not supported: &apos;{0}&apos;. The URI must be absolute..
        /// </summary>
        internal static string ArgumentInvalidAbsoluteUri {
            get {
                return ResourceManager.GetString("ArgumentInvalidAbsoluteUri", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Unsupported URI scheme: &apos;{0}&apos;. The URI scheme must be either &apos;{1}&apos; or &apos;{2}&apos;..
        /// </summary>
        internal static string ArgumentInvalidHttpUriScheme {
            get {
                return ResourceManager.GetString("ArgumentInvalidHttpUriScheme", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Value must be greater than or equal to {0}..
        /// </summary>
        internal static string ArgumentMustBeGreaterThanOrEqualTo {
            get {
                return ResourceManager.GetString("ArgumentMustBeGreaterThanOrEqualTo", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Value must be less than or equal to {0}..
        /// </summary>
        internal static string ArgumentMustBeLessThanOrEqualTo {
            get {
                return ResourceManager.GetString("ArgumentMustBeLessThanOrEqualTo", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The argument &apos;{0}&apos; is null or empty..
        /// </summary>
        internal static string ArgumentNullOrEmpty {
            get {
                return ResourceManager.GetString("ArgumentNullOrEmpty", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to URI must not contain a query component or a fragment identifier..
        /// </summary>
        internal static string ArgumentUriHasQueryOrFragment {
            get {
                return ResourceManager.GetString("ArgumentUriHasQueryOrFragment", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The value of argument &apos;{0}&apos; ({1}) is invalid for Enum type &apos;{2}&apos;..
        /// </summary>
        internal static string InvalidEnumArgument {
            get {
                return ResourceManager.GetString("InvalidEnumArgument", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/Common/CommonWebApiResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="ArgumentInvalidAbsoluteUri" xml:space="preserve">
    <value>Relative URI values are not supported: '{0}'. The URI must be absolute.</value>
  </data>
  <data name="ArgumentInvalidHttpUriScheme" xml:space="preserve">
    <value>Unsupported URI scheme: '{0}'. The URI scheme must be either '{1}' or '{2}'.</value>
  </data>
  <data name="ArgumentMustBeGreaterThanOrEqualTo" xml:space="preserve">
    <value>Value must be greater than or equal to {0}.</value>
  </data>
  <data name="ArgumentMustBeLessThanOrEqualTo" xml:space="preserve">
    <value>Value must be less than or equal to {0}.</value>
  </data>
  <data name="ArgumentNullOrEmpty" xml:space="preserve">
    <value>The argument '{0}' is null or empty.</value>
  </data>
  <data name="ArgumentUriHasQueryOrFragment" xml:space="preserve">
    <value>URI must not contain a query component or a fragment identifier.</value>
  </data>
  <data name="InvalidEnumArgument" xml:space="preserve">
    <value>The value of argument '{0}' ({1}) is invalid for Enum type '{2}'.</value>
  </data>
</root>

================================================
FILE: src/Common/DictionaryExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.Contracts;

namespace System.Collections.Generic
{
    /// <summary>
    /// Extension methods for <see cref="IDictionary{TKey,TValue}"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    internal static class DictionaryExtensions
    {
        /// <summary>
        /// Remove entries from dictionary that match the removeCondition.
        /// </summary>
        public static void RemoveFromDictionary<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, Func<KeyValuePair<TKey, TValue>, bool> removeCondition)
        {
            // Pass the delegate as the state to avoid a delegate and closure
            dictionary.RemoveFromDictionary((entry, innerCondition) =>
                {
                    return innerCondition(entry);
                },
                removeCondition);
        }

        /// <summary>
        /// Remove entries from dictionary that match the removeCondition.
        /// </summary>
        public static void RemoveFromDictionary<TKey, TValue, TState>(this IDictionary<TKey, TValue> dictionary, Func<KeyValuePair<TKey, TValue>, TState, bool> removeCondition, TState state)
        {
            Contract.Assert(dictionary != null);
            Contract.Assert(removeCondition != null);

            // Because it is not possible to delete while enumerating, a copy of the keys must be taken. Use the size of the dictionary as an upper bound
            // to avoid creating more than one copy of the keys.
            int removeCount = 0;
            TKey[] keys = new TKey[dictionary.Count];
            foreach (var entry in dictionary)
            {
                if (removeCondition(entry, state))
                {
                    keys[removeCount] = entry.Key;
                    removeCount++;
                }
            }
            for (int i = 0; i < removeCount; i++)
            {
                dictionary.Remove(keys[i]);
            }
        }

        /// <summary>
        /// Gets the value of <typeparamref name="T"/> associated with the specified key or <c>default</c> value if
        /// either the key is not present or the value is not of type <typeparamref name="T"/>. 
        /// </summary>
        /// <typeparam name="T">The type of the value associated with the specified key.</typeparam>
        /// <param name="collection">The <see cref="IDictionary{TKey,TValue}"/> instance where <c>TValue</c> is <c>object</c>.</param>
        /// <param name="key">The key whose value to get.</param>
        /// <param name="value">When this method returns, the value associated with the specified key, if the key is found; otherwise, the default value for the type of the value parameter.</param>
        /// <returns><c>true</c> if key was found, value is non-null, and value is of type <typeparamref name="T"/>; otherwise false.</returns>
        public static bool TryGetValue<T>(this IDictionary<string, object> collection, string key, out T value)
        {
            Contract.Assert(collection != null);

            object valueObj;
            if (collection.TryGetValue(key, out valueObj))
            {
                if (valueObj is T)
                {
                    value = (T)valueObj;
                    return true;
                }
            }

            value = default(T);
            return false;
        }

        internal static IEnumerable<KeyValuePair<string, TValue>> FindKeysWithPrefix<TValue>(this IDictionary<string, TValue> dictionary, string prefix)
        {
            Contract.Assert(dictionary != null);
            Contract.Assert(prefix != null);

            TValue exactMatchValue;
            if (dictionary.TryGetValue(prefix, out exactMatchValue))
            {
                yield return new KeyValuePair<string, TValue>(prefix, exactMatchValue);
            }

            foreach (var entry in dictionary)
            {
                string key = entry.Key;

                if (key.Length <= prefix.Length)
                {
                    continue;
                }

                if (!key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                // Everything is prefixed by the empty string
                if (prefix.Length == 0)
                {
                    yield return entry;
                }
                else
                {
                    char charAfterPrefix = key[prefix.Length];
                    switch (charAfterPrefix)
                    {
                        case '[':
                        case '.':
                            yield return entry;
                            break;
                    }
                }
            }
        }
    }
}


================================================
FILE: src/Common/EfficientTypePropertyKey.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    // When the key is cached, it will be more efficient that a normal tuple, because the hash code call
    // is rather expensive particularly for T as Type or T as long string.
    internal class EfficientTypePropertyKey<T1, T2> : Tuple<T1, T2>
    {
        private int _hashCode;

        public EfficientTypePropertyKey(T1 item1, T2 item2)
            : base(item1, item2)
        {
            _hashCode = base.GetHashCode();
        }

        public override int GetHashCode()
        {
            return _hashCode;
        }
    }
}


================================================
FILE: src/Common/Empty.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Collections.Generic
{
    /// <summary>
    /// Helper to provide empty instances with minimal allocation.
    /// </summary>
    internal static class Empty<T>
    {
        private static readonly T[] _emptyArray = new T[0];

        /// <summary>
        /// Returns a zero length array of type. Only allocates once per distinct type.
        /// </summary>
        public static T[] Array 
        { 
            get { return _emptyArray; } 
        }
    }
}


================================================
FILE: src/Common/Error.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Http.Properties;

namespace System.Web.Http
{
    /// <summary>
    /// Utility class for creating and unwrapping <see cref="Exception"/> instances.
    /// </summary>
    internal static class Error
    {
        private const string HttpScheme = "http";
        private const string HttpsScheme = "https";

        /// <summary>
        /// Formats the specified resource string using <see cref="M:CultureInfo.CurrentCulture"/>.
        /// </summary>
        /// <param name="format">A composite format string.</param>
        /// <param name="args">An object array that contains zero or more objects to format.</param>
        /// <returns>The formatted string.</returns>
        internal static string Format(string format, params object[] args)
        {
            return String.Format(CultureInfo.CurrentCulture, format, args);
        }

        /// <summary>
        /// Creates an <see cref="ArgumentException"/> with the provided properties.
        /// </summary>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentException Argument(string messageFormat, params object[] messageArgs)
        {
            return new ArgumentException(Error.Format(messageFormat, messageArgs));
        }

        /// <summary>
        /// Creates an <see cref="ArgumentException"/> with the provided properties.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentException Argument(string parameterName, string messageFormat, params object[] messageArgs)
        {
            return new ArgumentException(Error.Format(messageFormat, messageArgs), parameterName);
        }

        /// <summary>
        /// Creates an <see cref="ArgumentException"/> with a message saying that the argument must be an "http" or "https" URI.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="actualValue">The value of the argument that causes this exception.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentException ArgumentUriNotHttpOrHttpsScheme(string parameterName, Uri actualValue)
        {
            return new ArgumentException(Error.Format(CommonWebApiResources.ArgumentInvalidHttpUriScheme, actualValue, HttpScheme, HttpsScheme), parameterName);
        }

        /// <summary>
        /// Creates an <see cref="ArgumentException"/> with a message saying that the argument must be an absolute URI.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="actualValue">The value of the argument that causes this exception.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentException ArgumentUriNotAbsolute(string parameterName, Uri actualValue)
        {
            return new ArgumentException(Error.Format(CommonWebApiResources.ArgumentInvalidAbsoluteUri, actualValue), parameterName);
        }

        /// <summary>
        /// Creates an <see cref="ArgumentException"/> with a message saying that the argument must be an absolute URI
        /// without a query or fragment identifier and then logs it with <see cref="F:TraceLevel.Error"/>.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="actualValue">The value of the argument that causes this exception.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentException ArgumentUriHasQueryOrFragment(string parameterName, Uri actualValue)
        {
            return new ArgumentException(Error.Format(CommonWebApiResources.ArgumentUriHasQueryOrFragment, actualValue), parameterName);
        }

        /// <summary>
        /// Creates an <see cref="ArgumentNullException"/> with the provided properties.
        /// </summary>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "The purpose of this API is to return an error for properties")]
        internal static ArgumentNullException PropertyNull()
        {
            return new ArgumentNullException("value");
        }

        /// <summary>
        /// Creates an <see cref="ArgumentNullException"/> with the provided properties.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentNullException ArgumentNull(string parameterName)
        {
            return new ArgumentNullException(parameterName);
        }

        /// <summary>
        /// Creates an <see cref="ArgumentNullException"/> with the provided properties.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentNullException ArgumentNull(string parameterName, string messageFormat, params object[] messageArgs)
        {
            return new ArgumentNullException(parameterName, Error.Format(messageFormat, messageArgs));
        }

        /// <summary>
        /// Creates an <see cref="ArgumentException"/> with a default message.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentException ArgumentNullOrEmpty(string parameterName)
        {
            return Error.Argument(parameterName, CommonWebApiResources.ArgumentNullOrEmpty, parameterName);
        }

        /// <summary>
        /// Creates an <see cref="ArgumentOutOfRangeException"/> with the provided properties.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="actualValue">The value of the argument that causes this exception.</param>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentOutOfRangeException ArgumentOutOfRange(string parameterName, object actualValue, string messageFormat, params object[] messageArgs)
        {
            return new ArgumentOutOfRangeException(parameterName, actualValue, Error.Format(messageFormat, messageArgs));
        }

        /// <summary>
        /// Creates an <see cref="ArgumentOutOfRangeException"/> with a message saying that the argument must be greater than or equal to <paramref name="minValue"/>.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="actualValue">The value of the argument that causes this exception.</param>
        /// <param name="minValue">The minimum size of the argument.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentOutOfRangeException ArgumentMustBeGreaterThanOrEqualTo(string parameterName, object actualValue, object minValue)
        {
            return new ArgumentOutOfRangeException(parameterName, actualValue, Error.Format(CommonWebApiResources.ArgumentMustBeGreaterThanOrEqualTo, minValue));
        }

        /// <summary>
        /// Creates an <see cref="ArgumentOutOfRangeException"/> with a message saying that the argument must be less than or equal to <paramref name="maxValue"/>.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="actualValue">The value of the argument that causes this exception.</param>
        /// <param name="maxValue">The maximum size of the argument.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentOutOfRangeException ArgumentMustBeLessThanOrEqualTo(string parameterName, object actualValue, object maxValue)
        {
            return new ArgumentOutOfRangeException(parameterName, actualValue, Error.Format(CommonWebApiResources.ArgumentMustBeLessThanOrEqualTo, maxValue));
        }

        /// <summary>
        /// Creates an <see cref="KeyNotFoundException"/> with a message saying that the key was not found.
        /// </summary>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static KeyNotFoundException KeyNotFound()
        {
            return new KeyNotFoundException();
        }

        /// <summary>
        /// Creates an <see cref="KeyNotFoundException"/> with a message saying that the key was not found.
        /// </summary>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static KeyNotFoundException KeyNotFound(string messageFormat, params object[] messageArgs)
        {
            return new KeyNotFoundException(Error.Format(messageFormat, messageArgs));
        }

        /// <summary>
        /// Creates an <see cref="ObjectDisposedException"/> initialized according to guidelines.
        /// </summary>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ObjectDisposedException ObjectDisposed(string messageFormat, params object[] messageArgs)
        {
            // Pass in null, not disposedObject.GetType().FullName as per the above guideline
            return new ObjectDisposedException(null, Error.Format(messageFormat, messageArgs));
        }

        /// <summary>
        /// Creates an <see cref="OperationCanceledException"/> initialized with the provided parameters.
        /// </summary>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static OperationCanceledException OperationCanceled()
        {
            return new OperationCanceledException();
        }

        /// <summary>
        /// Creates an <see cref="OperationCanceledException"/> initialized with the provided parameters.
        /// </summary>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static OperationCanceledException OperationCanceled(string messageFormat, params object[] messageArgs)
        {
            return new OperationCanceledException(Error.Format(messageFormat, messageArgs));
        }

        /// <summary>
        /// Creates an <see cref="ArgumentException"/> for an invalid enum argument.
        /// </summary>
        /// <param name="parameterName">The name of the parameter that caused the current exception.</param>
        /// <param name="invalidValue">The value of the argument that failed.</param>
        /// <param name="enumClass">A <see cref="Type"/> that represents the enumeration class with the valid values.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static ArgumentException InvalidEnumArgument(string parameterName, int invalidValue, Type enumClass)
        {
            return new InvalidEnumArgumentException(parameterName, invalidValue, enumClass);
        }

        /// <summary>
        /// Creates an <see cref="InvalidOperationException"/>.
        /// </summary>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static InvalidOperationException InvalidOperation(string messageFormat, params object[] messageArgs)
        {
            return new InvalidOperationException(Error.Format(messageFormat, messageArgs));
        }

        /// <summary>
        /// Creates an <see cref="InvalidOperationException"/>.
        /// </summary>
        /// <param name="innerException">Inner exception</param>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static InvalidOperationException InvalidOperation(Exception innerException, string messageFormat, params object[] messageArgs)
        {
            return new InvalidOperationException(Error.Format(messageFormat, messageArgs), innerException);
        }

        /// <summary>
        /// Creates an <see cref="NotSupportedException"/>.
        /// </summary>
        /// <param name="messageFormat">A composite format string explaining the reason for the exception.</param>
        /// <param name="messageArgs">An object array that contains zero or more objects to format.</param>
        /// <returns>The logged <see cref="Exception"/>.</returns>
        internal static NotSupportedException NotSupported(string messageFormat, params object[] messageArgs)
        {
            return new NotSupportedException(Error.Format(messageFormat, messageArgs));
        }

#if NETSTANDARD1_3 // InvalidEnumArgumentException not available in netstandard1.3.
        internal class InvalidEnumArgumentException : ArgumentException
        {
            public InvalidEnumArgumentException() : this(null)
            { }

            public InvalidEnumArgumentException(string message) : base(message)
            { }

            public InvalidEnumArgumentException(string message, Exception innerException) : base(message, innerException)
            { }

            public InvalidEnumArgumentException(string argumentName, int invalidValue, Type enumClass) : base(
                Error.Format(CommonWebApiResources.InvalidEnumArgument, argumentName, invalidValue, enumClass.Name),
                argumentName)
            { }
        }
#endif
    }
}


================================================
FILE: src/Common/HashCodeCombiner.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;

namespace Microsoft.Internal.Web.Utils
{
    internal class HashCodeCombiner
    {
        private long _combinedHash64 = 0x1505L;

        public int CombinedHash
        {
            get { return _combinedHash64.GetHashCode(); }
        }

        public HashCodeCombiner Add(IEnumerable e)
        {
            if (e == null)
            {
                Add(0);
            }
            else
            {
                int count = 0;
                foreach (object o in e)
                {
                    Add(o);
                    count++;
                }
                Add(count);
            }
            return this;
        }

        public HashCodeCombiner Add(int i)
        {
            _combinedHash64 = ((_combinedHash64 << 5) + _combinedHash64) ^ i;
            return this;
        }

        public HashCodeCombiner Add(object o)
        {
            int hashCode = (o != null) ? o.GetHashCode() : 0;
            Add(hashCode);
            return this;
        }

        public static HashCodeCombiner Start()
        {
            return new HashCodeCombiner();
        }
    }
}


================================================
FILE: src/Common/HttpMethodHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;

namespace System.Web.Http
{
    /// <summary>
    /// Various helper methods for the static members of <see cref="HttpMethod"/>. 
    /// </summary>
    internal static class HttpMethodHelper
    {
        /// <summary>
        /// Gets the static <see cref="HttpMethod"/> instance for any given HTTP method name.
        /// </summary>
        /// <param name="method">The HTTP request method.</param>
        /// <returns>An existing static <see cref="HttpMethod"/> or a new instance if the method was not found.</returns>
        internal static HttpMethod GetHttpMethod(string method)
        {
            if (String.IsNullOrEmpty(method))
            {
                return null;
            }

            if (String.Equals("GET", method, StringComparison.OrdinalIgnoreCase))
            {
                return HttpMethod.Get;
            }

            if (String.Equals("POST", method, StringComparison.OrdinalIgnoreCase))
            {
                return HttpMethod.Post;
            }

            if (String.Equals("PUT", method, StringComparison.OrdinalIgnoreCase))
            {
                return HttpMethod.Put;
            }

            if (String.Equals("DELETE", method, StringComparison.OrdinalIgnoreCase))
            {
                return HttpMethod.Delete;
            }

            if (String.Equals("HEAD", method, StringComparison.OrdinalIgnoreCase))
            {
                return HttpMethod.Head;
            }

            if (String.Equals("OPTIONS", method, StringComparison.OrdinalIgnoreCase))
            {
                return HttpMethod.Options;
            }

            if (String.Equals("TRACE", method, StringComparison.OrdinalIgnoreCase))
            {
                return HttpMethod.Trace;
            }

            return new HttpMethod(method);
        }
    }
}


================================================
FILE: src/Common/ListWrapperCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Collections.ObjectModel
{
    /// <summary>
    /// A class that inherits from Collection of T but also exposes its underlying data as List of T for performance.
    /// </summary>
    internal sealed class ListWrapperCollection<T> : Collection<T>
    {
        private readonly List<T> _items;

        internal ListWrapperCollection()
            : this(new List<T>())
        {
        }

        internal ListWrapperCollection(List<T> list)
            : base(list)
        {
            _items = list;
        }

        internal List<T> ItemsList
        {
            get { return _items; }
        }
    }
}


================================================
FILE: src/Common/NonOwnedStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http
{
    /// <summary>Represents a stream that replaces another stream to prevent actually closing that stream.</summary>
    /// <remarks>
    /// This class uses the Decorator [GoF] pattern; it forwards all calls except those related to Dispose and Close.
    /// </remarks>
    internal class NonOwnedStream : Stream
    {
        protected NonOwnedStream()
        {
        }

        public NonOwnedStream(Stream innerStream)
        {
            if (innerStream == null)
            {
                throw new ArgumentNullException("innerStream");
            }

            InnerStream = innerStream;
        }

        protected Stream InnerStream
        {
            get;
            set;
        }

        protected bool IsDisposed
        {
            get;
            private set;
        }

        public override bool CanRead
        {
            get
            {
                // Per documentation, CanRead should return false rather than throw when the stream is closed.
                if (IsDisposed)
                {
                    return false;
                }

                return InnerStream.CanRead;
            }
        }

        public override bool CanSeek
        {
            get
            {
                // Per documentation, CanSeek should return false rather than throw when the stream is closed.
                if (IsDisposed)
                {
                    return false;
                }

                return InnerStream.CanSeek;
            }
        }

        public override bool CanTimeout
        {
            get
            {
                // Per documentation, this value apparently is a constant for a particular implementation class.
                // Throwing when disposed appears inappropriate here.
                return InnerStream.CanTimeout;
            }
        }

        public override bool CanWrite
        {
            get
            {
                // Per documentation, CanWrite should return false rather than throw when the stream is closed.
                if (IsDisposed)
                {
                    return false;
                }

                return InnerStream.CanWrite;
            }
        }

        public override long Length
        {
            get
            {
                // Per documentation, this property throws ObjectDisposedException if the stream is closed.
                ThrowIfDisposed();
                return InnerStream.Length;
            }
        }

        public override long Position
        {
            get
            {
                // Per documentation, this property throws ObjectDisposedException if the stream is closed.
                ThrowIfDisposed();
                return InnerStream.Position;
            }
            set
            {
                // Per documentation, this property throws ObjectDisposedException if the stream is closed.
                ThrowIfDisposed();
                InnerStream.Position = value;
            }
        }

        public override int ReadTimeout
        {
            get
            {
                // Documentation does not state the behavior when the stream is closed. The NetworkStream
                // implementation suggests the contract should be to throw ObjectDisposedException when the stream is
                // closed.
                ThrowIfDisposed();
                return InnerStream.ReadTimeout;
            }
            set
            {
                // Documentation does not state the behavior when the stream is closed. The NetworkStream
                // implementation suggests the contract should be to throw ObjectDisposedException when the stream is
                // closed.
                ThrowIfDisposed();
                InnerStream.ReadTimeout = value;
            }
        }

        public override int WriteTimeout
        {
            get
            {
                // Documentation does not state the behavior when the stream is closed. The NetworkStream
                // implementation suggests the contract should be to throw ObjectDisposedException when the stream is
                // closed.
                ThrowIfDisposed();
                return InnerStream.WriteTimeout;
            }
            set
            {
                // Documentation does not state the behavior when the stream is closed. The NetworkStream
                // implementation suggests the contract should be to throw ObjectDisposedException when the stream is
                // closed.
                ThrowIfDisposed();
                InnerStream.WriteTimeout = value;
            }
        }

        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            ThrowIfDisposed();
            return InnerStream.BeginRead(buffer, offset, count, callback, state);
        }

        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            ThrowIfDisposed();
            return InnerStream.BeginWrite(buffer, offset, count, callback, state);
        }

        public override void Close()
        {
            // base.Close() calls Dispose(true) and GC.SuppressFinalize(this), which is exactly what we want.
            // Note that we do NOT call _innerStream.Close here, as that would actually close the original source
            // stream, which is the one thing this class is designed to prevent.
            base.Close();
        }

        public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
        {
            ThrowIfDisposed();
            return InnerStream.CopyToAsync(destination, bufferSize, cancellationToken);
        }

        // Not overriding MarshalByRefObj.CreateObjRef.

        // Not overriding Stream.CreateWaitHandle.

        [SuppressMessage(
            "Microsoft.Usage", 
            "CA2215:Dispose methods should call base class dispose",
            Justification = "We're intentionally preventing a double dispose here.")]
        protected override void Dispose(bool disposing)
        {
            // Note that we do NOT call _innerStream.Dispose or Close here, as that would actually close the original
            // source stream, which is the one thing this class is designed to prevent.

            if (!IsDisposed)
            {
                base.Dispose(disposing);
                IsDisposed = true;
            }
        }

        public override int EndRead(IAsyncResult asyncResult)
        {
            ThrowIfDisposed();
            return InnerStream.EndRead(asyncResult);
        }

        public override void EndWrite(IAsyncResult asyncResult)
        {
            ThrowIfDisposed();
            InnerStream.EndWrite(asyncResult);
        }

        // Not overriding Object.Equals.

        public override void Flush()
        {
            ThrowIfDisposed();
            InnerStream.Flush();
        }

        public override Task FlushAsync(CancellationToken cancellationToken)
        {
            ThrowIfDisposed();
            return InnerStream.FlushAsync(cancellationToken);
        }

        // Not overriding Object.GetHashCode.

        // Not overriding MarshalByRefObj.InitializeLifetimeService.

        // Per documentation, don't override Stream.ObjectInvariant.

        public override int Read(byte[] buffer, int offset, int count)
        {
            ThrowIfDisposed();
            return InnerStream.Read(buffer, offset, count);
        }

        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            ThrowIfDisposed();
            return InnerStream.ReadAsync(buffer, offset, count, cancellationToken);
        }

        public override int ReadByte()
        {
            ThrowIfDisposed();
            return InnerStream.ReadByte();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            ThrowIfDisposed();
            return InnerStream.Seek(offset, origin);
        }

        public override void SetLength(long value)
        {
            ThrowIfDisposed();
            InnerStream.SetLength(value);
        }

        // Not overriding Object.ToString().

        public override void Write(byte[] buffer, int offset, int count)
        {
            ThrowIfDisposed();
            InnerStream.Write(buffer, offset, count);
        }

        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            ThrowIfDisposed();
            return InnerStream.WriteAsync(buffer, offset, count, cancellationToken);
        }

        public override void WriteByte(byte value)
        {
            ThrowIfDisposed();
            InnerStream.WriteByte(value);
        }

        protected void ThrowIfDisposed()
        {
            if (IsDisposed)
            {
                throw new ObjectDisposedException(null);
            }
        }
    }
}


================================================
FILE: src/Common/PathHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;

namespace System.Web
{
    /// <summary>
    /// Helpers for working with IO paths.
    /// </summary>
    internal static class PathHelpers
    {
        /// <summary>
        /// Returns whether the path has the specified file extension.
        /// </summary>
        public static bool EndsWithExtension(string path, string extension)
        {
            Contract.Assert(path != null);
            Contract.Assert(extension != null && extension.Length > 0);

            if (path.EndsWith(extension, StringComparison.OrdinalIgnoreCase))
            {
                int extensionLength = extension.Length;
                int pathLength = path.Length;
                return (pathLength > extensionLength && path[pathLength - extensionLength - 1] == '.');
            }
            return false;
        }
    }
}


================================================
FILE: src/Common/PrefixContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web
{
    /// <summary>
    /// This is a container for prefix values. It normalizes all the values into dotted-form and then stores
    /// them in a sorted array. All queries for prefixes are also normalized to dotted-form, and searches
    /// for ContainsPrefix are done with a binary search.
    /// </summary>
    internal class PrefixContainer
    {
        private readonly ICollection<string> _originalValues;
        private readonly string[] _sortedValues;

        internal PrefixContainer(ICollection<string> values)
        {
            if (values == null)
            {
                throw new ArgumentNullException("values");
            }

            _originalValues = values;
            _sortedValues = _originalValues.ToArrayWithoutNulls();
            Array.Sort(_sortedValues, StringComparer.OrdinalIgnoreCase);
        }

        internal bool ContainsPrefix(string prefix)
        {
            if (prefix == null)
            {
                throw new ArgumentNullException("prefix");
            }

            if (prefix.Length == 0)
            {
                return _sortedValues.Length > 0; // only match empty string when we have some value
            }

            PrefixComparer prefixComparer = new PrefixComparer(prefix);
            bool containsPrefix = Array.BinarySearch(_sortedValues, prefix, prefixComparer) > -1;
            if (!containsPrefix)
            {
                // If there's something in the search boundary that starts with the same name
                // as the collection prefix that we're trying to find, the binary search would actually fail.
                // For example, let's say we have foo.a, foo.bE and foo.b[0]. Calling Array.BinarySearch
                // will fail to find foo.b because it will land on foo.bE, then look at foo.a and finally
                // failing to find the prefix which is actually present in the container (foo.b[0]).
                // Here we're doing another pass looking specifically for collection prefix.
                containsPrefix = Array.BinarySearch(_sortedValues, prefix + "[", prefixComparer) > -1;
            }
            return containsPrefix;
        }

        // Given "foo.bar", "foo.hello", "something.other", foo[abc].baz and asking for prefix "foo" will return:
        // - "bar"/"foo.bar"
        // - "hello"/"foo.hello"
        // - "abc"/"foo[abc]"
        internal IDictionary<string, string> GetKeysFromPrefix(string prefix)
        {
            IDictionary<string, string> result = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

            foreach (var entry in _originalValues)
            {
                if (entry != null)
                {
                    if (entry.Length == prefix.Length)
                    {
                        // No key in this entry
                        continue;
                    }

                    if (prefix.Length == 0)
                    {
                        GetKeyFromEmptyPrefix(entry, result);
                    }
                    else if (entry.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                    {
                        GetKeyFromNonEmptyPrefix(prefix, entry, result);
                    }
                }
            }

            return result;
        }

        private static void GetKeyFromEmptyPrefix(string entry, IDictionary<string, string> results)
        {
            string key;
            int dotPosition = entry.IndexOf('.');
            int bracketPosition = entry.IndexOf('[');
            int delimiterPosition = -1;

            if (dotPosition == -1)
            {
                if (bracketPosition != -1)
                {
                    delimiterPosition = bracketPosition;
                }
            }
            else
            {
                if (bracketPosition == -1)
                {
                    delimiterPosition = dotPosition;
                }
                else
                {
                    delimiterPosition = Math.Min(dotPosition, bracketPosition);
                }
            }

            key = delimiterPosition == -1 ? entry : entry.Substring(0, delimiterPosition);
            results[key] = key;
        }

        private static void GetKeyFromNonEmptyPrefix(string prefix, string entry, IDictionary<string, string> results)
        {
            string key = null;
            string fullName = null;
            int keyPosition = prefix.Length + 1;

            switch (entry[prefix.Length])
            {
                case '.':
                    int dotPosition = entry.IndexOf('.', keyPosition);
                    if (dotPosition == -1)
                    {
                        dotPosition = entry.Length;
                    }

                    key = entry.Substring(keyPosition, dotPosition - keyPosition);
                    fullName = entry.Substring(0, dotPosition);
                    break;

                case '[':
                    int bracketPosition = entry.IndexOf(']', keyPosition);
                    if (bracketPosition == -1)
                    {
                        // Malformed for dictionary
                        return;
                    }

                    key = entry.Substring(keyPosition, bracketPosition - keyPosition);
                    fullName = entry.Substring(0, bracketPosition + 1);
                    break;

                default:
                    return;
            }

            if (!results.ContainsKey(key))
            {
                results.Add(key, fullName);
            }
        }

        internal static bool IsPrefixMatch(string prefix, string testString)
        {
            if (testString == null)
            {
                return false;
            }

            if (prefix.Length == 0)
            {
                return true; // shortcut - non-null testString matches empty prefix
            }

            if (prefix.Length > testString.Length)
            {
                return false; // not long enough
            }

            if (!testString.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
            {
                return false; // prefix doesn't match
            }

            if (testString.Length == prefix.Length)
            {
                return true; // exact match
            }

            // invariant: testString.Length > prefix.Length
            switch (testString[prefix.Length])
            {
                case '.':
                case '[':
                    return true; // known delimiters

                default:
                    return false; // not known delimiter
            }
        }

        private class PrefixComparer : IComparer<String>
        {
            private string _prefix;

            public PrefixComparer(string prefix)
            {
                _prefix = prefix;
            }

            public int Compare(string x, string y)
            {
                string testString = Object.ReferenceEquals(x, _prefix) ? y : x;
                if (IsPrefixMatch(_prefix, testString))
                {
                    return 0;
                }

                return StringComparer.OrdinalIgnoreCase.Compare(x, y);
            }
        }
    }
}

================================================
FILE: src/Common/PropertyHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Reflection;

#if ASPNETWEBAPI
namespace System.Web.Http.Internal
#else
namespace System.Web.WebPages
#endif
{
    internal class PropertyHelper
    {
        private static ConcurrentDictionary<Type, PropertyHelper[]> _reflectionCache = new ConcurrentDictionary<Type, PropertyHelper[]>();

        private Func<object, object> _valueGetter;

        /// <summary>
        /// Initializes a fast property helper. This constructor does not cache the helper.
        /// </summary>
        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "This is intended the Name is auto set differently per type and the type is internal")]
        public PropertyHelper(PropertyInfo property)
        {
            Contract.Assert(property != null);

            Name = property.Name;
            _valueGetter = MakeFastPropertyGetter(property);
        }

        /// <summary>
        /// Creates a single fast property setter. The result is not cached.
        /// </summary>
        /// <param name="propertyInfo">propertyInfo to extract the getter for.</param>
        /// <returns>a fast setter.</returns>
        /// <remarks>This method is more memory efficient than a dynamically compiled lambda, and about the same speed.</remarks>
        public static Action<TDeclaringType, object> MakeFastPropertySetter<TDeclaringType>(PropertyInfo propertyInfo)
            where TDeclaringType : class
        {
            Contract.Assert(propertyInfo != null);

            MethodInfo setMethod = propertyInfo.GetSetMethod();

            Contract.Assert(setMethod != null);
            Contract.Assert(!setMethod.IsStatic);
            Contract.Assert(setMethod.GetParameters().Length == 1);
            Contract.Assert(!propertyInfo.ReflectedType.IsValueType);

            // Instance methods in the CLR can be turned into static methods where the first parameter
            // is open over "this". This parameter is always passed by reference, so we have a code
            // path for value types and a code path for reference types.
            Type typeInput = propertyInfo.ReflectedType;
            Type typeValue = setMethod.GetParameters()[0].ParameterType;

            Delegate callPropertySetterDelegate;

            // Create a delegate TValue -> "TDeclaringType.Property"
            var propertySetterAsAction = setMethod.CreateDelegate(typeof(Action<,>).MakeGenericType(typeInput, typeValue));
            var callPropertySetterClosedGenericMethod = _callPropertySetterOpenGenericMethod.MakeGenericMethod(typeInput, typeValue);
            callPropertySetterDelegate = Delegate.CreateDelegate(typeof(Action<TDeclaringType, object>), propertySetterAsAction, callPropertySetterClosedGenericMethod);

            return (Action<TDeclaringType, object>)callPropertySetterDelegate;
        }

        public virtual string Name { get; protected set; }

        public object GetValue(object instance)
        {
            Contract.Assert(_valueGetter != null, "Must call Initialize before using this object");

            return _valueGetter(instance);
        }

        /// <summary>
        /// Creates and caches fast property helpers that expose getters for every public get property on the underlying type.
        /// </summary>
        /// <param name="instance">the instance to extract property accessors for.</param>
        /// <returns>a cached array of all public property getters from the underlying type of this instance.</returns>
        public static PropertyHelper[] GetProperties(object instance)
        {
            return GetProperties(instance, CreateInstance, _reflectionCache);
        }

        /// <summary>
        /// Creates a single fast property getter. The result is not cached.
        /// </summary>
        /// <param name="propertyInfo">propertyInfo to extract the getter for.</param>
        /// <returns>a fast getter.</returns>
        /// <remarks>This method is more memory efficient than a dynamically compiled lambda, and about the same speed.</remarks>
        public static Func<object, object> MakeFastPropertyGetter(PropertyInfo propertyInfo)
        {
            Contract.Assert(propertyInfo != null);

            MethodInfo getMethod = propertyInfo.GetGetMethod();
            Contract.Assert(getMethod != null);
            Contract.Assert(!getMethod.IsStatic);
            Contract.Assert(getMethod.GetParameters().Length == 0);

            // Instance methods in the CLR can be turned into static methods where the first parameter
            // is open over "this". This parameter is always passed by reference, so we have a code
            // path for value types and a code path for reference types.
            Type typeInput = getMethod.ReflectedType;
            Type typeOutput = getMethod.ReturnType;

            Delegate callPropertyGetterDelegate;
            if (typeInput.IsValueType)
            {
                // Create a delegate (ref TDeclaringType) -> TValue
                Delegate propertyGetterAsFunc = getMethod.CreateDelegate(typeof(ByRefFunc<,>).MakeGenericType(typeInput, typeOutput));
                MethodInfo callPropertyGetterClosedGenericMethod = _callPropertyGetterByReferenceOpenGenericMethod.MakeGenericMethod(typeInput, typeOutput);
                callPropertyGetterDelegate = Delegate.CreateDelegate(typeof(Func<object, object>), propertyGetterAsFunc, callPropertyGetterClosedGenericMethod);
            }
            else
            {
                // Create a delegate TDeclaringType -> TValue
                Delegate propertyGetterAsFunc = getMethod.CreateDelegate(typeof(Func<,>).MakeGenericType(typeInput, typeOutput));
                MethodInfo callPropertyGetterClosedGenericMethod = _callPropertyGetterOpenGenericMethod.MakeGenericMethod(typeInput, typeOutput);
                callPropertyGetterDelegate = Delegate.CreateDelegate(typeof(Func<object, object>), propertyGetterAsFunc, callPropertyGetterClosedGenericMethod);
            }

            return (Func<object, object>)callPropertyGetterDelegate;
        }

        private static PropertyHelper CreateInstance(PropertyInfo property)
        {
            return new PropertyHelper(property);
        }

        // Implementation of the fast getter.
        private delegate TValue ByRefFunc<TDeclaringType, TValue>(ref TDeclaringType arg);

        private static readonly MethodInfo _callPropertyGetterOpenGenericMethod = typeof(PropertyHelper).GetMethod("CallPropertyGetter", BindingFlags.NonPublic | BindingFlags.Static);
        private static readonly MethodInfo _callPropertyGetterByReferenceOpenGenericMethod = typeof(PropertyHelper).GetMethod("CallPropertyGetterByReference", BindingFlags.NonPublic | BindingFlags.Static);

        private static object CallPropertyGetter<TDeclaringType, TValue>(Func<TDeclaringType, TValue> getter, object @this)
        {
            return getter((TDeclaringType)@this);
        }

        private static object CallPropertyGetterByReference<TDeclaringType, TValue>(ByRefFunc<TDeclaringType, TValue> getter, object @this)
        {
            TDeclaringType unboxed = (TDeclaringType)@this;
            return getter(ref unboxed);
        }

        // Implementation of the fast setter.
        private static readonly MethodInfo _callPropertySetterOpenGenericMethod = typeof(PropertyHelper).GetMethod("CallPropertySetter", BindingFlags.NonPublic | BindingFlags.Static);

        private static void CallPropertySetter<TDeclaringType, TValue>(Action<TDeclaringType, TValue> setter, object @this, object value)
        {
            setter((TDeclaringType)@this, (TValue)value);
        }

        protected static PropertyHelper[] GetProperties(object instance,
                                                        Func<PropertyInfo, PropertyHelper> createPropertyHelper,
                                                        ConcurrentDictionary<Type, PropertyHelper[]> cache)
        {
            // Using an array rather than IEnumerable, as this will be called on the hot path numerous times.
            PropertyHelper[] helpers;

            Type type = instance.GetType();

            if (!cache.TryGetValue(type, out helpers))
            {
                // We avoid loading indexed properties using the where statement.
                // Indexed properties are not useful (or valid) for grabbing properties off an anonymous object.
                IEnumerable<PropertyInfo> properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance)
                                                           .Where(prop => prop.GetIndexParameters().Length == 0 &&
                                                                          prop.GetMethod != null);

                var newHelpers = new List<PropertyHelper>();

                foreach (PropertyInfo property in properties)
                {
                    PropertyHelper propertyHelper = createPropertyHelper(property);

                    newHelpers.Add(propertyHelper);
                }

                helpers = newHelpers.ToArray();
                cache.TryAdd(type, helpers);
            }

            return helpers;
        }
    }
}


================================================
FILE: src/Common/Routing/Constraints/AlphaRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to contain only lowercase or uppercase letters A through Z in the English alphabet.
    /// </summary>
    public class AlphaRouteConstraint : RegexRouteConstraint
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AlphaRouteConstraint" /> class.
        /// </summary>
        public AlphaRouteConstraint() : base(@"^[a-z]*$")
        {
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/BoolRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only Boolean values.
    /// </summary>
#if ASPNETWEBAPI
    public class BoolRouteConstraint : IHttpRouteConstraint
#else
    public class BoolRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is bool)
                {
                    return true;
                }

                bool result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return Boolean.TryParse(valueString, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/CompoundRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route by several child constraints.
    /// </summary>
#if ASPNETWEBAPI
    public class CompoundRouteConstraint : IHttpRouteConstraint
#else
    public class CompoundRouteConstraint : IRouteConstraint
#endif
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CompoundRouteConstraint" /> class.
        /// </summary>
        /// <param name="constraints">The child constraints that must match for this constraint to match.</param>
#if ASPNETWEBAPI
        public CompoundRouteConstraint(IList<IHttpRouteConstraint> constraints)
#else
        public CompoundRouteConstraint(IList<IRouteConstraint> constraints)
#endif
        {
            if (constraints == null)
            {
                throw Error.ArgumentNull("constraints");
            }

            Constraints = constraints;
        }

        /// <summary>
        /// Gets the child constraints that must match for this constraint to match.
        /// </summary>
#if ASPNETWEBAPI
        public IEnumerable<IHttpRouteConstraint> Constraints { get; private set; }
#else
        public IEnumerable<IRouteConstraint> Constraints { get; private set; }
#endif

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            foreach (var constraint in Constraints)
            {
#if ASPNETWEBAPI
                if (!constraint.Match(request, route, parameterName, values, routeDirection))
#else
                if (!constraint.Match(httpContext, route, parameterName, values, routeDirection))
#endif
                {
                    return false;
                }
            }
            return true;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/DateTimeRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only <see cref="DateTime"/> values.
    /// </summary>
#if ASPNETWEBAPI
    public class DateTimeRouteConstraint : IHttpRouteConstraint
#else
    public class DateTimeRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is DateTime)
                {
                    return true;
                }

                DateTime result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return DateTime.TryParse(valueString, CultureInfo.InvariantCulture, DateTimeStyles.None, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/DecimalRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only decimal values.
    /// </summary>
#if ASPNETWEBAPI
    public class DecimalRouteConstraint : IHttpRouteConstraint
#else
    public class DecimalRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is decimal)
                {
                    return true;
                }

                decimal result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return Decimal.TryParse(valueString, NumberStyles.Number, CultureInfo.InvariantCulture, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/DoubleRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only 64-bit floating-point values.
    /// </summary>
#if ASPNETWEBAPI
    public class DoubleRouteConstraint : IHttpRouteConstraint
#else
    public class DoubleRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is double)
                {
                    return true;
                }

                double result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return Double.TryParse(valueString, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/FloatRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Mvc;
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only 32-bit floating-point values.
    /// </summary>
#if ASPNETWEBAPI
    public class FloatRouteConstraint : IHttpRouteConstraint
#else
    public class FloatRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is float)
                {
                    return true;
                }

                float result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return Single.TryParse(valueString, NumberStyles.Float | NumberStyles.AllowThousands, CultureInfo.InvariantCulture, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/GuidRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Mvc;
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only <see cref="Guid"/> values.
    /// </summary>
#if ASPNETWEBAPI
    public class GuidRouteConstraint : IHttpRouteConstraint
#else
    public class GuidRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is Guid)
                {
                    return true;
                }

                Guid result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return Guid.TryParse(valueString, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/IntRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only 32-bit integer values.
    /// </summary>
#if ASPNETWEBAPI
    public class IntRouteConstraint : IHttpRouteConstraint
#else
    public class IntRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is int)
                {
                    return true;
                }

                int result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return Int32.TryParse(valueString, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/LengthRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to be a string of a given length or within a given range of lengths.
    /// </summary>
#if ASPNETWEBAPI
    public class LengthRouteConstraint : IHttpRouteConstraint
#else
    public class LengthRouteConstraint : IRouteConstraint
#endif
    {
        public LengthRouteConstraint(int length)
        {
            if (length < 0)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("length", length, 0);
            }

            Length = length;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="LengthRouteConstraint" /> class that constrains
        /// a route parameter to be a string of a given length.
        /// </summary>
        /// <param name="minLength">The minimum length of the route parameter.</param>
        /// <param name="maxLength">The maximum length of the route parameter.</param>
        public LengthRouteConstraint(int minLength, int maxLength)
        {
            if (minLength < 0)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("minLength", minLength, 0);
            }

            if (maxLength < 0)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxLength", maxLength, 0);
            }

            MinLength = minLength;
            MaxLength = maxLength;
        }

        /// <summary>
        /// Gets the length of the route parameter, if one is set.
        /// </summary>
        public int? Length { get; private set; }

        /// <summary>
        /// Gets the minimum length of the route parameter, if one is set.
        /// </summary>
        public int? MinLength { get; private set; }

        /// <summary>
        /// Gets the maximum length of the route parameter, if one is set.
        /// </summary>
        public int? MaxLength { get; private set; }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                int length = valueString.Length;
                if (Length.HasValue)
                {
                    return length == Length.Value;
                }
                else
                {
                    return length >= MinLength.Value && length <= MaxLength.Value;
                }
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/LongRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to represent only 64-bit integer values.
    /// </summary>
#if ASPNETWEBAPI
    public class LongRouteConstraint : IHttpRouteConstraint
#else
    public class LongRouteConstraint : IRouteConstraint
#endif
    {
        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                if (value is long)
                {
                    return true;
                }

                long result;
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return Int64.TryParse(valueString, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/MaxLengthRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to be a string with a maximum length.
    /// </summary>
#if ASPNETWEBAPI
    public class MaxLengthRouteConstraint : IHttpRouteConstraint
#else
    public class MaxLengthRouteConstraint : IRouteConstraint
#endif
    {
        public MaxLengthRouteConstraint(int maxLength)
        {
            if (maxLength < 0)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxLength", maxLength, 0);
            }

            MaxLength = maxLength;
        }

        /// <summary>
        /// Gets the maximum length of the route parameter.
        /// </summary>
        public int MaxLength { get; private set; }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return valueString.Length <= MaxLength;
            }
            return false;
        }
    }
}


================================================
FILE: src/Common/Routing/Constraints/MaxRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to be an integer with a maximum value.
    /// </summary>
#if ASPNETWEBAPI
    public class MaxRouteConstraint : IHttpRouteConstraint
#else
    public class MaxRouteConstraint : IRouteConstraint
#endif
    {
        public MaxRouteConstraint(long max)
        {
            Max = max;
        }

        /// <summary>
        /// Gets the maximum value of the route parameter.
        /// </summary>
        public long Max { get; private set; }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                long longValue;
                if (value is long)
                {
                    longValue = (long)value;
                    return longValue <= Max;
                }

                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                if (Int64.TryParse(valueString, NumberStyles.Integer, CultureInfo.InvariantCulture, out longValue))
                {
                    return longValue <= Max;
                }
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/MinLengthRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to be a string with a maximum length.
    /// </summary>
#if ASPNETWEBAPI
    public class MinLengthRouteConstraint : IHttpRouteConstraint
#else
    public class MinLengthRouteConstraint : IRouteConstraint
#endif
    {
        public MinLengthRouteConstraint(int minLength)
        {
            if (minLength < 0)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("minLength", minLength, 0);
            }

            MinLength = minLength;
        }

        /// <summary>
        /// Gets the minimum length of the route parameter.
        /// </summary>
        public int MinLength { get; private set; }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return valueString.Length >= MinLength;
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/MinRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to be a long with a minimum value.
    /// </summary>
#if ASPNETWEBAPI
    public class MinRouteConstraint : IHttpRouteConstraint
#else
    public class MinRouteConstraint : IRouteConstraint
#endif
    {
        public MinRouteConstraint(long min)
        {
            Min = min;
        }

        /// <summary>
        /// Gets the minimum value of the route parameter.
        /// </summary>
        public long Min { get; private set; }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                long longValue;
                if (value is long)
                {
                    longValue = (long)value;
                    return longValue >= Min;
                }

                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                if (Int64.TryParse(valueString, NumberStyles.Integer, CultureInfo.InvariantCulture, out longValue))
                {
                    return longValue >= Min;
                }
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/OptionalRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route by an inner constraint that doesn't fail when an optional parameter is set to its default value.
    /// </summary>
#if ASPNETWEBAPI
    public class OptionalRouteConstraint : IHttpRouteConstraint
#else
    public class OptionalRouteConstraint : IRouteConstraint
#endif
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="OptionalRouteConstraint" /> class.
        /// </summary>
        /// <param name="innerConstraint">The inner constraint to match if the parameter is not an optional parameter without a value</param>
#if ASPNETWEBAPI
        public OptionalRouteConstraint(IHttpRouteConstraint innerConstraint)
#else
        public OptionalRouteConstraint(IRouteConstraint innerConstraint)
#endif
        {
            if (innerConstraint == null)
            {
                throw Error.ArgumentNull("innerConstraint");
            }

            InnerConstraint = innerConstraint;
        }

        /// <summary>
        /// Gets the inner constraint to match if the parameter is not an optional parameter without a value.
        /// </summary>
#if ASPNETWEBAPI
        public IHttpRouteConstraint InnerConstraint { get; private set; }
#else
        public IRouteConstraint InnerConstraint { get; private set; }
#endif

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            // If the parameter is optional and has no value, then pass the constraint
            object defaultValue;
#if ASPNETWEBAPI
            var optionalParameter = RouteParameter.Optional;
#else
            var optionalParameter = UrlParameter.Optional;
#endif
            if (route.Defaults.TryGetValue(parameterName, out defaultValue) && defaultValue == optionalParameter)
            {
                object value;
                if (values.TryGetValue(parameterName, out value) && value == optionalParameter)
                {
                    return true;
                }
            }

#if ASPNETWEBAPI
            return InnerConstraint.Match(request, route, parameterName, values, routeDirection);
#else
            return InnerConstraint.Match(httpContext, route, parameterName, values, routeDirection);
#endif
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/RangeRouteConstraintBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constraints a route parameter to be an integer within a given range of values.
    /// </summary>
#if ASPNETWEBAPI
    public class RangeRouteConstraint : IHttpRouteConstraint
#else
    public class RangeRouteConstraint : IRouteConstraint
#endif
    {
        public RangeRouteConstraint(long min, long max)
        {
            Min = min;
            Max = max;
        }

        /// <summary>
        /// Gets the minimum value of the route parameter.
        /// </summary>
        public long Min { get; private set; }

        /// <summary>
        /// Gets the maximum value of the route parameter.
        /// </summary>
        public long Max { get; private set; }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                long longValue;
                if (value is long)
                {
                    longValue = (long)value;
                    return longValue >= Min && longValue <= Max;
                }

                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                if (Int64.TryParse(valueString, NumberStyles.Integer, CultureInfo.InvariantCulture, out longValue))
                {
                    return longValue >= Min && longValue <= Max;
                }
            }
            return false;
        }
    }
}

================================================
FILE: src/Common/Routing/Constraints/RegexRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
#if ASPNETWEBAPI
using System.Net.Http;
using System.Text.RegularExpressions;
#else
using System.Text.RegularExpressions;
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing.Constraints
#else
namespace System.Web.Mvc.Routing.Constraints
#endif
{
    /// <summary>
    /// Constrains a route parameter to match a regular expression.
    /// </summary>
#if ASPNETWEBAPI
    public class RegexRouteConstraint : IHttpRouteConstraint
#else
    public class RegexRouteConstraint : IRouteConstraint
#endif
    {
        private readonly Regex _regex;

        public RegexRouteConstraint(string pattern)
        {
            Pattern = pattern;
            _regex = new Regex(pattern, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.Compiled);
        }

        /// <summary>
        /// Gets the regular expression pattern to match.
        /// </summary>
        public string Pattern { get; private set; }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
#else
        public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
#endif
        {
            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            object value;
            if (values.TryGetValue(parameterName, out value) && value != null)
            {
                string valueString = Convert.ToString(value, CultureInfo.InvariantCulture);
                return _regex.IsMatch(valueString);
            }
            return false;
        }
    }
}


================================================
FILE: src/Common/Routing/DefaultInlineConstraintResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
#if ASPNETWEBAPI
using System.Web.Http.Routing.Constraints;
using ErrorResources = System.Web.Http.Properties.SRResources;
#else
using System.Web.Mvc.Routing.Constraints;
using System.Web.Routing;
using ErrorResources = System.Web.Mvc.Properties.MvcResources;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>
    /// The default implementation of <see cref="IInlineConstraintResolver"/>. Resolves constraints by parsing
    /// a constraint key and constraint arguments, using a map to resolve the constraint type, and calling an
    /// appropriate constructor for the constraint type.
    /// </summary>
    public class DefaultInlineConstraintResolver : IInlineConstraintResolver
    {
        private readonly IDictionary<string, Type> _inlineConstraintMap = GetDefaultConstraintMap();

        /// <summary>
        /// Gets the mutable dictionary that maps constraint keys to a particular constraint type.
        /// </summary>
        public IDictionary<string, Type> ConstraintMap
        {
            get
            {
                return _inlineConstraintMap;
            }
        }

        private static IDictionary<string, Type> GetDefaultConstraintMap()
        {
            return new Dictionary<string, Type>(StringComparer.OrdinalIgnoreCase)
            {
                // Type-specific constraints
                { "bool", typeof(BoolRouteConstraint) },
                { "datetime", typeof(DateTimeRouteConstraint) },
                { "decimal", typeof(DecimalRouteConstraint) },
                { "double", typeof(DoubleRouteConstraint) },
                { "float", typeof(FloatRouteConstraint) },
                { "guid", typeof(GuidRouteConstraint) },
                { "int", typeof(IntRouteConstraint) },
                { "long", typeof(LongRouteConstraint) },

                // Length constraints
                { "minlength", typeof(MinLengthRouteConstraint) },
                { "maxlength", typeof(MaxLengthRouteConstraint) },
                { "length", typeof(LengthRouteConstraint) },
                
                // Min/Max value constraints
                { "min", typeof(MinRouteConstraint) },
                { "max", typeof(MaxRouteConstraint) },
                { "range", typeof(RangeRouteConstraint) },

                // Regex-based constraints
                { "alpha", typeof(AlphaRouteConstraint) },
                { "regex", typeof(RegexRouteConstraint) }
            };
        }

        /// <inheritdoc />
#if ASPNETWEBAPI
        public virtual IHttpRouteConstraint ResolveConstraint(string inlineConstraint)
#else
        public virtual IRouteConstraint ResolveConstraint(string inlineConstraint)
#endif
        {
            if (inlineConstraint == null)
            {
                throw Error.ArgumentNull("inlineConstraint");
            }

            string constraintKey;
            string argumentString;
            int indexOfFirstOpenParens = inlineConstraint.IndexOf('(');
            if (indexOfFirstOpenParens >= 0 && inlineConstraint.EndsWith(")", StringComparison.Ordinal))
            {
                constraintKey = inlineConstraint.Substring(0, indexOfFirstOpenParens);
                argumentString = inlineConstraint.Substring(indexOfFirstOpenParens + 1, inlineConstraint.Length - indexOfFirstOpenParens - 2);
            }
            else
            {
                constraintKey = inlineConstraint;
                argumentString = null;
            }

            Type constraintType;
            if (!_inlineConstraintMap.TryGetValue(constraintKey, out constraintType))
            {
                // Cannot resolve the constraint key
                return null;
            }

#if ASPNETWEBAPI
            if (!typeof(IHttpRouteConstraint).IsAssignableFrom(constraintType))
#else
            if (!typeof(IRouteConstraint).IsAssignableFrom(constraintType))
#endif
            {
                throw Error.InvalidOperation(ErrorResources.DefaultInlineConstraintResolver_TypeNotConstraint, constraintType.Name, constraintKey);
            }

#if ASPNETWEBAPI
            return (IHttpRouteConstraint)CreateConstraint(constraintType, argumentString);
#else
            return (IRouteConstraint)CreateConstraint(constraintType, argumentString);
#endif
        }

        private static object CreateConstraint(Type constraintType, string argumentString)
        {
            // No arguments - call the default constructor
            if (argumentString == null)
            {
                return Activator.CreateInstance(constraintType);
            }

            ConstructorInfo activationConstructor = null;
            object[] parameters = null;
            ConstructorInfo[] constructors = constraintType.GetConstructors();

            // If there is only one constructor and it has a single parameter, pass the argument string directly
            // This is necessary for the Regex RouteConstraint to ensure that patterns are not split on commas.
            if (constructors.Length == 1 && constructors[0].GetParameters().Length == 1)
            {
                activationConstructor = constructors[0];
                parameters = ConvertArguments(activationConstructor.GetParameters(), new string[] { argumentString });
            }
            else
            {
                string[] arguments = argumentString.Split(',').Select(argument => argument.Trim()).ToArray();

                ConstructorInfo[] matchingConstructors = constructors.Where(ci => ci.GetParameters().Length == arguments.Length).ToArray();
                int constructorMatches = matchingConstructors.Length;

                if (constructorMatches == 0)
                {
                    throw Error.InvalidOperation(ErrorResources.DefaultInlineConstraintResolver_CouldNotFindCtor, constraintType.Name, argumentString.Length);
                }
                else if (constructorMatches == 1)
                {
                    activationConstructor = matchingConstructors[0];
                    parameters = ConvertArguments(activationConstructor.GetParameters(), arguments);
                }
                else
                {
                    throw Error.InvalidOperation(ErrorResources.DefaultInlineConstraintResolver_AmbiguousCtors, constraintType.Name, argumentString.Length);
                }
            }

            return activationConstructor.Invoke(parameters);
        }

        private static object[] ConvertArguments(ParameterInfo[] parameterInfos, string[] arguments)
        {
            object[] parameters = new object[parameterInfos.Length];
            for (int i = 0; i < parameterInfos.Length; i++)
            {
                ParameterInfo parameter = parameterInfos[i];
                Type parameterType = parameter.ParameterType;
                parameters[i] = Convert.ChangeType(arguments[i], parameterType, CultureInfo.InvariantCulture);
            }
            return parameters;
        }
    }
}


================================================
FILE: src/Common/Routing/DirectRouteBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
#if ASPNETWEBAPI
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
#else
using System.Web.Routing;
#endif

#if ASPNETWEBAPI
using TActionDescriptor = System.Web.Http.Controllers.HttpActionDescriptor;
using TParsedRoute = System.Web.Http.Routing.HttpParsedRoute;
using TResources = System.Web.Http.Properties.SRResources;
using TRoute = System.Web.Http.Routing.IHttpRoute;
using TRouteDictionary = System.Collections.Generic.IDictionary<string, object>;
using TRouteDictionaryConcrete = System.Web.Http.Routing.HttpRouteValueDictionary;

#else

using TActionDescriptor = System.Web.Mvc.ActionDescriptor;
using TParsedRoute = System.Web.Mvc.Routing.ParsedRoute;
using TResources = System.Web.Mvc.Properties.MvcResources;
using TRoute = System.Web.Routing.Route;
using TRouteDictionary = System.Web.Routing.RouteValueDictionary;
using TRouteDictionaryConcrete = System.Web.Routing.RouteValueDictionary;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>Represents a builder that creates direct routes to actions (attribute routes).</summary>
    internal class DirectRouteBuilder : IDirectRouteBuilder
    {
        private readonly TActionDescriptor[] _actions;
        private readonly bool _targetIsAction;

        private string _template;

        /// <summary>Initializes a new instance of the <see cref="DirectRouteBuilder"/> class.</summary>
        /// <param name="actions">The action descriptors to which to create a route.</param>
        /// <param name="targetIsAction">
        /// A value indicating whether the route is configured at the action or controller level.
        /// </param>
        public DirectRouteBuilder(IReadOnlyCollection<TActionDescriptor> actions, bool targetIsAction)
        {
            if (actions == null)
            {
                throw new ArgumentNullException("actions");
            }

            _actions = actions.ToArray();

            _targetIsAction = targetIsAction;
        }

        /// <inheritdoc/>
        public string Name { get; set; }

        /// <inheritdoc/>
        public string Template
        {
            get
            {
                return _template;
            }
            set
            {
                ParsedRoute = null;
                _template = value;
            }
        }

        /// <inheritdoc/>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly",
            Justification = "Null and empty values are legitimate, separate options when constructing a route.")]
        public TRouteDictionary Defaults { get; set; }

        /// <inheritdoc/>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly",
            Justification = "Null and empty values are legitimate, separate options when constructing a route.")]
        public TRouteDictionary Constraints { get; set; }

        /// <inheritdoc/>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly",
            Justification = "Null and empty values are legitimate, separate options when constructing a route.")]
        public TRouteDictionary DataTokens { get; set; }

        internal TParsedRoute ParsedRoute { get; set; }

        /// <inheritdoc/>
        public int Order { get; set; }

        /// <inheritdoc/>
        public decimal Precedence { get; set; }

        /// <inheritdoc/>
        public IReadOnlyCollection<TActionDescriptor> Actions
        {
            get { return _actions; }
        }

        /// <inheritdoc/>
        public bool TargetIsAction
        {
            get { return _targetIsAction; }
        }

        /// <inheritdoc/>
        public virtual RouteEntry Build()
        {
            if (ParsedRoute == null)
            {
                ParsedRoute = RouteParser.Parse(Template);
            }

            ValidateParameters(ParsedRoute);

            TRouteDictionaryConcrete defaults;
#if ASPNETWEBAPI
            defaults = Copy(Defaults);
#else
            defaults = Copy(Defaults) ?? new RouteValueDictionary();
#endif
            TRouteDictionaryConcrete constraints = Copy(Constraints);
            TRouteDictionaryConcrete dataTokens = Copy(DataTokens) ?? new TRouteDictionaryConcrete();

            dataTokens[RouteDataTokenKeys.Actions] = _actions;

#if ASPNETWEBAPI
            if (!TargetIsAction)
            {
                dataTokens[RouteDataTokenKeys.Controller] = _actions[0].ControllerDescriptor;
            }
#endif

            int order = Order;

            if (order != default(int))
            {
                dataTokens[RouteDataTokenKeys.Order] = order;
            }

            decimal precedence = Precedence;

            if (precedence != default(decimal))
            {
                dataTokens[RouteDataTokenKeys.Precedence] = precedence;
            }

#if ASPNETWEBAPI
            if (constraints != null)
            {
                foreach (var constraint in constraints)
                {
                    HttpRoute.ValidateConstraint(Template, constraint.Key, constraint.Value);
                }
            }

            HttpMessageHandler handler = null;
            IHttpRoute route = new HttpRoute(Template, defaults, constraints, dataTokens, handler, ParsedRoute);
#else
            ControllerDescriptor controllerDescriptor = GetControllerDescriptor();

            if (controllerDescriptor != null)
            {
                defaults["controller"] = controllerDescriptor.ControllerName;
            }

            if (TargetIsAction && _actions.Length == 1)
            {
                ActionDescriptor actionDescriptor = _actions[0];
                defaults["action"] = actionDescriptor.ActionName;

                dataTokens[RouteDataTokenKeys.TargetIsAction] = true;
            }

            RouteAreaAttribute area = controllerDescriptor.GetAreaFrom();
            string areaName = controllerDescriptor.GetAreaName(area);

            if (areaName != null)
            {
                dataTokens[RouteDataTokenKeys.Area] = areaName;
                dataTokens[RouteDataTokenKeys.UseNamespaceFallback] = false;

                Type controllerType = controllerDescriptor.ControllerType;

                if (controllerType != null)
                {
                    dataTokens[RouteDataTokenKeys.Namespaces] = new[] { controllerType.Namespace };
                }
            }

            Route route = new Route(Template, defaults, constraints, dataTokens, routeHandler: null);

            ConstraintValidation.Validate(route);
#endif

            return new RouteEntry(Name, route);
        }

        // Accessible for tests
        internal virtual void ValidateParameters(TParsedRoute parsedRoute)
        {
            Contract.Assert(parsedRoute != null);

            if (parsedRoute.PathSegments != null)
            {
                foreach (var contentSegment in parsedRoute.PathSegments.OfType<PathContentSegment>())
                {
                    if (contentSegment != null && contentSegment.Subsegments != null)
                    {
                        foreach (var parameterSegment in contentSegment.Subsegments.OfType<PathParameterSubsegment>())
                        {
                            if (parameterSegment != null)
                            {
                                if (String.Equals(parameterSegment.ParameterName, "controller", StringComparison.OrdinalIgnoreCase))
                                {
                                    throw Error.InvalidOperation(TResources.DirectRoute_InvalidParameter_Controller);
                                }
                                else if (TargetIsAction && String.Equals(parameterSegment.ParameterName, "action", StringComparison.OrdinalIgnoreCase))
                                {
                                    throw Error.InvalidOperation(TResources.DirectRoute_InvalidParameter_Action);
                                }
                            }
                        }
                    }
                }
            }
        }

        internal static void ValidateRouteEntry(RouteEntry entry)
        {
            Contract.Assert(entry != null);

            TRoute route = entry.Route;
            Contract.Assert(route != null);

            TActionDescriptor[] targetActions = route.GetTargetActionDescriptors();

            if (targetActions == null || targetActions.Length == 0)
            {
                throw new InvalidOperationException(TResources.DirectRoute_MissingActionDescriptors);
            }
#if ASPNETWEBAPI
            if (route.Handler != null)
            {
                throw new InvalidOperationException(TResources.DirectRoute_HandlerNotSupported);
            }
#else
            if (route.RouteHandler != null)
            {
                throw new InvalidOperationException(TResources.DirectRoute_RouteHandlerNotSupported);
            }
#endif
        }

        private static TRouteDictionaryConcrete Copy(TRouteDictionary routeDictionary)
        {
            if (routeDictionary == null)
            {
                return null;
            }

            return new TRouteDictionaryConcrete(routeDictionary);
        }

#if !ASPNETWEBAPI
        private ControllerDescriptor GetControllerDescriptor()
        {
            ControllerDescriptor controller = null;

            foreach (ActionDescriptor action in _actions)
            {
                if (controller == null)
                {
                    controller = action.ControllerDescriptor;
                }
                else if (action.ControllerDescriptor != controller)
                {
                    controller = null;
                    break;
                }
            }

            return controller;
        }
#endif
    }
}


================================================
FILE: src/Common/Routing/DirectRouteFactoryContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;

#if ASPNETWEBAPI
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using TActionDescriptor = System.Web.Http.Controllers.HttpActionDescriptor;
using TParsedRoute = System.Web.Http.Routing.HttpParsedRoute;
using TRouteDictionary = System.Web.Http.Routing.HttpRouteValueDictionary;
#else
using System.Text;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using TActionDescriptor = System.Web.Mvc.ActionDescriptor;
using TParsedRoute = System.Web.Mvc.Routing.ParsedRoute;
using TRouteDictionary = System.Web.Routing.RouteValueDictionary;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>Represents a context that supports creating a direct route.</summary>
    public class DirectRouteFactoryContext
    {
        private readonly string _actionName;

#if !ASPNETWEBAPI
        private readonly string _controllerName;
#endif

#if ASPNETWEBAPI
        private readonly string _prefix;
#else
        private readonly string _areaPrefix;
        private readonly string _controllerPrefix;
#endif

        private readonly IReadOnlyCollection<TActionDescriptor> _actions;
        private readonly IInlineConstraintResolver _inlineConstraintResolver;
        private readonly bool _targetIsAction;

#if ASPNETWEBAPI
        /// <summary>Initializes a new instance of the <see cref="DirectRouteFactoryContext"/></summary>
        /// <param name="prefix">The route prefix, if any, defined by the controller.</param>
        /// <param name="actions">The action descriptors to which to create a route.</param>
        /// <param name="inlineConstraintResolver">The inline constraint resolver.</param>
        /// <param name="targetIsAction">
        /// A value indicating whether the route is configured at the action or controller level.
        /// </param>
        public DirectRouteFactoryContext(string prefix, IReadOnlyCollection<HttpActionDescriptor> actions,
            IInlineConstraintResolver inlineConstraintResolver, bool targetIsAction)
#else
        /// <summary>Initializes a new instance of the <see cref="DirectRouteFactoryContext"/></summary>
        /// <param name="areaPrefix">The route prefix, if any, defined by the area.</param>
        /// <param name="controllerPrefix">The route prefix, if any, defined by the controller.</param>
        /// <param name="actions">The action descriptors to which to create a route.</param>
        /// <param name="inlineConstraintResolver">The inline constraint resolver.</param>
        /// <param name="targetIsAction">
        /// A value indicating whether the route is configured at the action or controller level.
        /// </param>
        public DirectRouteFactoryContext(string areaPrefix, string controllerPrefix,
            IReadOnlyCollection<ActionDescriptor> actions, IInlineConstraintResolver inlineConstraintResolver,
            bool targetIsAction)
#endif
        {
            if (actions == null)
            {
                throw new ArgumentNullException("actions");
            }

            if (inlineConstraintResolver == null)
            {
                throw new ArgumentNullException("inlineConstraintResolver");
            }

#if ASPNETWEBAPI
            _prefix = prefix;
#else
            _areaPrefix = areaPrefix;
            _controllerPrefix = controllerPrefix;
#endif
            _actions = actions;
            _inlineConstraintResolver = inlineConstraintResolver;

            TActionDescriptor firstDescriptor = actions.FirstOrDefault();

            if (firstDescriptor != null)
            {
                _actionName = firstDescriptor.ActionName;
#if !ASPNETWEBAPI
                ControllerDescriptor controllerDescriptor = firstDescriptor.ControllerDescriptor;

                if (controllerDescriptor != null)
                {
                    _controllerName = controllerDescriptor.ControllerName;
                }
#endif
            }

            _targetIsAction = targetIsAction;
        }

#if ASPNETWEBAPI
        /// <summary>Gets the route prefix, if any, defined by the controller.</summary>
        public string Prefix
        {
            get { return _prefix; }
        }
#else
        /// <summary>Gets the route prefix, if any, defined by the area.</summary>
        public string AreaPrefix
        {
            get { return _areaPrefix; }
        }

        /// <summary>Gets the route prefix, if any, defined by the controller.</summary>
        public string ControllerPrefix
        {
            get { return _controllerPrefix; }
        }
#endif

        /// <summary>Gets the action descriptors to which to create a route.</summary>
        public IReadOnlyCollection<TActionDescriptor> Actions
        {
            get { return _actions; }
        }

        /// <summary>Gets the inline constraint resolver.</summary>
        public IInlineConstraintResolver InlineConstraintResolver
        {
            get { return _inlineConstraintResolver; }
        }

        /// <summary>
        /// Gets a value indicating whether the route is configured at the action or controller level.
        /// </summary>
        /// <remarks>
        /// <see langword="true"/> when the route is configured at the action level; otherwise <see langword="false"/>
        /// (if the route is configured at the controller level).
        /// </remarks>
        public bool TargetIsAction
        {
            get { return _targetIsAction; }
        }

        /// <summary>Creates a route builder that can build a route matching this context.</summary>
        /// <param name="template">The route template.</param>
        /// <returns>A route builder that can build a route matching this context.</returns>
        public IDirectRouteBuilder CreateBuilder(string template)
        {
            return CreateBuilderInternal(template);
        }

        internal virtual IDirectRouteBuilder CreateBuilderInternal(string template)
        {
            return CreateBuilder(template, _inlineConstraintResolver);
        }

        /// <summary>Creates a route builder that can build a route matching this context.</summary>
        /// <param name="template">The route template.</param>
        /// <param name="constraintResolver">
        /// The inline constraint resolver to use, if any; otherwise, <see langword="null"/>.
        /// </param>
        /// <returns>A route builder that can build a route matching this context.</returns>
        public IDirectRouteBuilder CreateBuilder(string template, IInlineConstraintResolver constraintResolver)
        {
            DirectRouteBuilder builder = new DirectRouteBuilder(_actions, _targetIsAction);

#if ASPNETWEBAPI
            string prefixedTemplate = BuildRouteTemplate(_prefix, template);
#else
            string prefixedTemplate = BuildRouteTemplate(_areaPrefix, _controllerPrefix, template ?? String.Empty);
#endif
            ValidateTemplate(prefixedTemplate);

            if (constraintResolver != null)
            {
                TRouteDictionary defaults = new TRouteDictionary();
                TRouteDictionary constraints = new TRouteDictionary();

                string detokenizedTemplate = InlineRouteTemplateParser.ParseRouteTemplate(prefixedTemplate, defaults,
                    constraints, constraintResolver);
                TParsedRoute parsedRoute = RouteParser.Parse(detokenizedTemplate);
                decimal precedence = RoutePrecedence.Compute(parsedRoute, constraints);

                builder.Defaults = defaults;
                builder.Constraints = constraints;
                builder.Template = detokenizedTemplate;
                builder.Precedence = precedence;
                builder.ParsedRoute = parsedRoute;
            }
            else
            {
                builder.Template = prefixedTemplate;
            }

            return builder;
        }

#if ASPNETWEBAPI
        private static string BuildRouteTemplate(string routePrefix, string routeTemplate)
        {
            if (String.IsNullOrEmpty(routeTemplate))
            {
                return routePrefix ?? String.Empty;
            }

            // If the provider's template starts with '~/', ignore the route prefix
            if (routeTemplate.StartsWith("~/", StringComparison.Ordinal))
            {
                return routeTemplate.Substring(2);
            }
            else if (String.IsNullOrEmpty(routePrefix))
            {
                return routeTemplate;
            }
            else
            {
                // template and prefix both not null - combine them
                return routePrefix + '/' + routeTemplate;
            }
        }
#else
        internal static string BuildRouteTemplate(string areaPrefix, string prefix, string template)
        {
            // If the attribute's template starts with '~/', ignore the area and controller prefixes
            if (template != null && template.StartsWith("~/", StringComparison.Ordinal))
            {
                return template.Substring(2);
            }

            if (prefix == null && areaPrefix == null)
            {
                return template;
            }

            StringBuilder templateBuilder = new StringBuilder();

            if (areaPrefix != null)
            {
                templateBuilder.Append(areaPrefix);
            }

            if (!String.IsNullOrEmpty(prefix))
            {
                if (templateBuilder.Length > 0)
                {
                    templateBuilder.Append('/');
                }
                templateBuilder.Append(prefix);
            }

            if (!String.IsNullOrEmpty(template))
            {
                if (templateBuilder.Length > 0)
                {
                    templateBuilder.Append('/');
                }
                templateBuilder.Append(template);
            }

            return templateBuilder.ToString();
        }
#endif

        private void ValidateTemplate(string template)
        {
            if (template != null && template.StartsWith("/", StringComparison.Ordinal))
            {
#if ASPNETWEBAPI
                string errorMessage = Error.Format(SRResources.AttributeRoutes_InvalidTemplate, template, _actionName);
#else
                string errorMessage = Error.Format(MvcResources.RouteTemplate_CannotStart_WithForwardSlash, template,
                    _actionName, _controllerName);
#endif
                throw new InvalidOperationException(errorMessage);
            }
        }
    }
}


================================================
FILE: src/Common/Routing/IDirectRouteBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

#if ASPNETWEBAPI
using TActionDescriptor = System.Web.Http.Controllers.HttpActionDescriptor;
using TRouteDictionary = System.Collections.Generic.IDictionary<string, object>;
#else
using TActionDescriptor = System.Web.Mvc.ActionDescriptor;
using TRouteDictionary = System.Web.Routing.RouteValueDictionary;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>Defines a builder that creates direct routes to actions (attribute routes).</summary>
    public interface IDirectRouteBuilder
    {
        /// <summary>Gets or sets the route name, if any; otherwise <see langword="null"/>.</summary>
        string Name { get; set; }

        /// <summary>Gets or sets the route template.</summary>
        /// <remarks>
        /// This value is the core route template that remains after resolving and removing any inline constraints.
        /// </remarks>
        string Template { get; set; }

        /// <summary>Gets or sets the route defaults.</summary>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly",
            Justification = "Null and empty values are legitimate, separate options when constructing a route.")]
        TRouteDictionary Defaults { get; set; }

        /// <summary>Gets or sets the route constraints.</summary>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly",
            Justification = "Null and empty values are legitimate, separate options when constructing a route.")]
        TRouteDictionary Constraints { get; set; }

        /// <summary>Gets or sets the route data tokens.</summary>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly",
            Justification = "Null and empty values are legitimate, separate options when constructing a route.")]
        TRouteDictionary DataTokens { get; set; }

        /// <summary>Gets or sets the route order.</summary>
        /// <remarks>
        /// The route order disambiguates multiple matching routes and overrides precedence.
        /// The intended use of order is for an explicitly provided precedence override value.
        /// </remarks>
        int Order { get; set; }

        /// <summary>Gets or sets the route precedence.</summary>
        /// <remarks>
        /// The route order disambiguates multiple matching routes with the same order.
        /// The intended use of precedence is for default, automatically computed disambiguation based on inline
        /// constraint types.
        /// </remarks>
        decimal Precedence { get; set; }

        /// <summary>Gets the action descriptors to which to create a route.</summary>
        IReadOnlyCollection<TActionDescriptor> Actions { get; }

        /// <summary>
        /// Gets a value indicating whether the route is configured at the action or controller level.
        /// </summary>
        /// <remarks>
        /// <see langword="true"/> when the route is configured at the action level; otherwise <see langword="false"/>
        /// (if the route is configured at the controller level).
        /// </remarks>
        bool TargetIsAction { get; }

        /// <summary>Creates a route entry based on the current property values.</summary>
        /// <returns>The route entry created.</returns>
        RouteEntry Build();
    }
}


================================================
FILE: src/Common/Routing/IDirectRouteFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>
    /// Defines a factory that creates a route directly to a set of action descriptors (an attribute route).
    /// </summary>
    public interface IDirectRouteFactory
    {
        /// <summary>Creates a direct route entry.</summary>
        /// <param name="context">The context to use to create the route.</param>
        /// <returns>The direct route entry.</returns>
        RouteEntry CreateRoute(DirectRouteFactoryContext context);
    }
}


================================================
FILE: src/Common/Routing/IDirectRouteProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Defines a provider for routes that directly target action descriptors (attribute routes).
    /// </summary>
    public interface IDirectRouteProvider
    {
        /// <summary>Gets the direct routes for a controller.</summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="actionDescriptors">The action descriptors.</param>
        /// <param name="constraintResolver">The inline constraint resolver.</param>
        /// <returns>A set of route entries for the controller.</returns>
        IReadOnlyList<RouteEntry> GetDirectRoutes(
            HttpControllerDescriptor controllerDescriptor, 
            IReadOnlyList<HttpActionDescriptor> actionDescriptors,
            IInlineConstraintResolver constraintResolver);
    }
}


================================================
FILE: src/Common/Routing/IInlineConstraintResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
using TConstraint = System.Web.Http.Routing.IHttpRouteConstraint;
#else
using TConstraint = System.Web.Routing.IRouteConstraint;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>
    /// Defines an abstraction for resolving inline constraints as instances of <see cref="TConstraint"/>.
    /// </summary>
    public interface IInlineConstraintResolver
    {
        /// <summary>
        /// Resolves the inline constraint.
        /// </summary>
        /// <param name="inlineConstraint">The inline constraint to resolve.</param>
        /// <returns>The <see cref="TConstraint"/> the inline constraint was resolved to.</returns>
        TConstraint ResolveConstraint(string inlineConstraint);
    }
}

================================================
FILE: src/Common/Routing/IRoutePrefix.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>Defines a route prefix.</summary>
    public interface IRoutePrefix
    {
        /// <summary>Gets the route prefix.</summary>
        string Prefix { get; }
    }
}

================================================
FILE: src/Common/Routing/InlineRouteTemplateParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Text.RegularExpressions;
#if ASPNETWEBAPI
using System.Web.Http.Routing.Constraints;
using ErrorResources = System.Web.Http.Properties.SRResources;
#else
using System.Web.Mvc.Routing.Constraints;
using System.Web.Routing;
using ErrorResources = System.Web.Mvc.Properties.MvcResources;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>
    /// This class is used by the AttributeRouting mapper, during configuration,
    /// to parse and strip defaults and constraints from the template.
    /// </summary>
    internal class InlineRouteTemplateParser
    {
        // One or more characters, matches "id"
        private const string ParameterNameRegex = @"(?<parameterName>.+?)";

        // Zero or more inline constraints that start with a colon followed by zero or more characters
        // Optionally the constraint can have arguments within parentheses - necessary to capture characters like ":" and "}"
        // Matches ":int", ":length(2)", ":regex(\})", ":regex(:)" zero or more times
        private const string ConstraintRegex = @"(:(?<constraint>.*?(\(.*?\))?))*";

        // Optional "?" for optional parameters or a default value with an equal sign followed by zero or more characters
        // Matches "?", "=", "=abc"
        private const string DefaultValueRegex = @"(?<defaultValue>\?|(=.*?))?";

        private static readonly Regex _parameterRegex = new Regex(
            "{" + ParameterNameRegex + ConstraintRegex + DefaultValueRegex + "}",
            RegexOptions.Compiled);

        public static string ParseRouteTemplate(string routeTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IInlineConstraintResolver constraintResolver)
        {
            Contract.Assert(defaults != null);
            Contract.Assert(constraints != null);

            MatchCollection parameterMatches = _parameterRegex.Matches(routeTemplate);

            foreach (Match parameterMatch in parameterMatches)
            {
                string parameterName = parameterMatch.Groups["parameterName"].Value;
                // We may need to strip out the initial wildcard used for wildcard parameters
                if (parameterName.StartsWith("*", StringComparison.OrdinalIgnoreCase))
                {
                    parameterName = parameterName.Substring(1);
                }

                // Add the default value if present
                Group defaultValueGroup = parameterMatch.Groups["defaultValue"];
                object defaultValue = GetDefaultValue(defaultValueGroup);
                if (defaultValue != null)
                {
                    defaults.Add(parameterName, defaultValue);
                }

                // Register inline constraints if present
                Group constraintGroup = parameterMatch.Groups["constraint"];
#if ASPNETWEBAPI
                bool isOptional = defaultValue == RouteParameter.Optional;
#else
                bool isOptional = defaultValue == UrlParameter.Optional;
#endif
                var constraint = GetInlineConstraint(constraintGroup, isOptional, constraintResolver);
                if (constraint != null)
                {
                    constraints.Add(parameterName, constraint);
                }
            }

            // Replaces parameter matches with just the parameter name in braces
            // Strips out the optional '?', default value, inline constraints
            return _parameterRegex.Replace(routeTemplate, @"{${parameterName}}");
        }

        private static object GetDefaultValue(Group defaultValueGroup)
        {
            if (defaultValueGroup.Success)
            {
                string defaultValueMatch = defaultValueGroup.Value;
                if (defaultValueMatch == "?")
                {
#if ASPNETWEBAPI
                    return RouteParameter.Optional;
#else
                    return UrlParameter.Optional;
#endif
                }
                else
                {
                    // Strip out the equal sign at the beginning
                    Contract.Assert(defaultValueMatch.StartsWith("=", StringComparison.Ordinal));
                    return defaultValueMatch.Substring(1);
                }
            }
            return null;
        }

#if ASPNETWEBAPI
        private static IHttpRouteConstraint GetInlineConstraint(Group constraintGroup, bool isOptional, IInlineConstraintResolver constraintResolver)
#else
        private static IRouteConstraint GetInlineConstraint(Group constraintGroup, bool isOptional, IInlineConstraintResolver constraintResolver)
#endif
        {
#if ASPNETWEBAPI
            List<IHttpRouteConstraint> parameterConstraints = new List<IHttpRouteConstraint>();
#else
            List<IRouteConstraint> parameterConstraints = new List<IRouteConstraint>();
#endif
            foreach (Capture constraintCapture in constraintGroup.Captures)
            {
                string inlineConstraint = constraintCapture.Value;
                var constraint = constraintResolver.ResolveConstraint(inlineConstraint);
                if (constraint == null)
                {
                    throw Error.InvalidOperation(ErrorResources.HttpRouteBuilder_CouldNotResolveConstraint, constraintResolver.GetType().Name, inlineConstraint);
                }
                parameterConstraints.Add(constraint);
            }

            if (parameterConstraints.Count > 0)
            {
                var constraint = parameterConstraints.Count == 1 ?
                    parameterConstraints[0] :
                    new CompoundRouteConstraint(parameterConstraints);

                if (isOptional)
                {
                    // Constraints should match RouteParameter.Optional if the parameter is optional
                    // This prevents contraining when there's no value specified
                    constraint = new OptionalRouteConstraint(constraint);
                }

                return constraint;
            }
            return null;
        }
    }
}

================================================
FILE: src/Common/Routing/PathContentSegment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    // Represents a segment of a URI that is not a separator. It contains subsegments such as literals and parameters.
    internal sealed class PathContentSegment : PathSegment
    {
        public PathContentSegment(List<PathSubsegment> subsegments)
        {
            Subsegments = subsegments;
        }

        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "Not changing original algorithm.")]
        public bool IsCatchAll
        {
            get
            {
                // TODO: Verify this is correct. Maybe add an assert.
                // Performance sensitive
                // Caching count is faster for IList<T>
                int subsegmentCount = Subsegments.Count;
                for (int i = 0; i < subsegmentCount; i++)
                {
                    PathSubsegment seg = Subsegments[i];
                    PathParameterSubsegment paramterSubSegment = seg as PathParameterSubsegment;
                    if (paramterSubSegment != null && paramterSubSegment.IsCatchAll)
                    {
                        return true;
                    }
                }
                return false;
            }
        }

        public List<PathSubsegment> Subsegments { get; private set; }

#if ROUTE_DEBUGGING
        public override string LiteralText
        {
            get
            {
                List<string> s = new List<string>();
                foreach (PathSubsegment subsegment in Subsegments)
                {
                    s.Add(subsegment.LiteralText);
                }
                return String.Join(String.Empty, s.ToArray());
            }
        }

        public override string ToString()
        {
            List<string> s = new List<string>();
            foreach (PathSubsegment subsegment in Subsegments)
            {
                s.Add(subsegment.ToString());
            }
            return "[ " + String.Join(", ", s.ToArray()) + " ]";
        }
#endif
    }
}


================================================
FILE: src/Common/Routing/PathLiteralSubsegment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    // Represents a literal subsegment of a ContentPathSegment
    internal sealed class PathLiteralSubsegment : PathSubsegment
    {
        public PathLiteralSubsegment(string literal)
        {
            Literal = literal;
        }

        public string Literal { get; private set; }

#if ROUTE_DEBUGGING
        public override string LiteralText
        {
            get
            {
                return Literal;
            }
        }

        public override string ToString()
        {
            return "\"" + Literal + "\"";
        }
#endif
    }
}


================================================
FILE: src/Common/Routing/PathParameterSubsegment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    // Represents a parameter subsegment of a ContentPathSegment
    internal sealed class PathParameterSubsegment : PathSubsegment
    {
        public PathParameterSubsegment(string parameterName)
        {
            if (parameterName.StartsWith("*", StringComparison.Ordinal))
            {
                ParameterName = parameterName.Substring(1);
                IsCatchAll = true;
            }
            else
            {
                ParameterName = parameterName;
            }
        }

        public bool IsCatchAll { get; private set; }

        public string ParameterName { get; private set; }

#if ROUTE_DEBUGGING
        public override string LiteralText
        {
            get
            {
                return "{" + (IsCatchAll ? "*" : String.Empty) + ParameterName + "}";
            }
        }

        public override string ToString()
        {
            return "{" + (IsCatchAll ? "*" : String.Empty) + ParameterName + "}";
        }
#endif
    }
}


================================================
FILE: src/Common/Routing/PathSegment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    // Represents a segment of a URI such as a separator or content
    internal abstract class PathSegment
    {
#if ROUTE_DEBUGGING
        public abstract string LiteralText
        {
            get;
        }
#endif
    }
}


================================================
FILE: src/Common/Routing/PathSeparatorSegment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    // Represents a "/" separator in a URI
    internal sealed class PathSeparatorSegment : PathSegment
    {
#if ROUTE_DEBUGGING
        public override string LiteralText
        {
            get
            {
                return "/";
            }
        }

        public override string ToString()
        {
            return "\"/\"";
        }
#endif
    }
}


================================================
FILE: src/Common/Routing/PathSubsegment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    // Represents a subsegment of a ContentPathSegment such as a parameter or a literal.
    internal abstract class PathSubsegment
    {
#if ROUTE_DEBUGGING
        public abstract string LiteralText
        {
            get;
        }
#endif
    }
}


================================================
FILE: src/Common/Routing/RouteEntry.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
using TRoute = System.Web.Http.Routing.IHttpRoute;
#else
using TRoute = System.Web.Routing.Route;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>Represents a named route.</summary>
    public class RouteEntry
    {
        private readonly string _name;
        private readonly TRoute _route;

        /// <summary>Initializes a new instance of the <see cref="RouteEntry"/> class.</summary>
        /// <param name="name">The route name, if any; otherwise, <see langword="null"/>.</param>
        /// <param name="route">The route.</param>
        public RouteEntry(string name, TRoute route)
        {
            if (route == null)
            {
                throw new ArgumentNullException("route");
            }

            _name = name;
            _route = route;
        }

        /// <summary>Gets the route name, if any; otherwise, <see langword="null"/>.</summary>
        public string Name
        {
            get { return _name; }
        }

        /// <summary>Gets the route.</summary>
        public TRoute Route
        {
            get { return _route; }
        }
    }
}


================================================
FILE: src/Common/Routing/RouteFactoryAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;

#if ASPNETWEBAPI
using TRouteDictionary = System.Collections.Generic.IDictionary<string, object>;
#else
using TRouteDictionary = System.Web.Routing.RouteValueDictionary;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>Represents an attribute route that may contain custom constraints.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = false, AllowMultiple = true)]
    public abstract class RouteFactoryAttribute : Attribute, IDirectRouteFactory
    {
        private readonly string _template;

        /// <summary>Initializes a new instance of the <see cref="RouteFactoryAttribute"/> class.</summary>
        /// <param name="template">The route template.</param>
        protected RouteFactoryAttribute(string template)
        {
            _template = template;
        }

        /// <summary>Gets the route template.</summary>
        public string Template
        {
            get { return _template; }
        }

        /// <summary>Gets or sets the route name, if any; otherwise <see langword="null"/>.</summary>
        public string Name { get; set; }

        /// <summary>Gets or sets the route order.</summary>
        public int Order { get; set; }

        /// <summary>Gets the route defaults, if any; otherwise <see langword="null"/>.</summary>
        public virtual TRouteDictionary Defaults
        {
            get { return null; }
        }

        /// <summary>Gets the route constraints, if any; otherwise <see langword="null"/>.</summary>
        public virtual TRouteDictionary Constraints
        {
            get { return null; }
        }

        /// <summary>Gets the route data tokens, if any; otherwise <see langword="null"/>.</summary>
        public virtual TRouteDictionary DataTokens
        {
            get { return null; }
        }

        /// <inheritdoc />
        public RouteEntry CreateRoute(DirectRouteFactoryContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            IDirectRouteBuilder builder = context.CreateBuilder(Template);
            Contract.Assert(builder != null);
            builder.Name = Name;
            builder.Order = Order;

            TRouteDictionary builderDefaults = builder.Defaults;

            if (builderDefaults == null)
            {
                builder.Defaults = Defaults;
            }
            else
            {
                TRouteDictionary defaults = Defaults;

                if (defaults != null)
                {
                    foreach (KeyValuePair<string, object> defaultItem in defaults)
                    {
                        builderDefaults[defaultItem.Key] = defaultItem.Value;
                    }
                }
            }

            TRouteDictionary builderConstraints = builder.Constraints;

            if (builderConstraints == null)
            {
                builder.Constraints = Constraints;
            }
            else
            {
                TRouteDictionary constraints = Constraints;

                if (constraints != null)
                {
                    foreach (KeyValuePair<string, object> constraint in constraints)
                    {
                        builderConstraints[constraint.Key] = constraint.Value;
                    }
                }
            }

            TRouteDictionary builderDataTokens = builder.DataTokens;

            if (builderDataTokens == null)
            {
                builder.DataTokens = DataTokens;
            }
            else
            {
                TRouteDictionary dataTokens = DataTokens;

                if (dataTokens != null)
                {
                    foreach (KeyValuePair<string, object> dataToken in dataTokens)
                    {
                        builderDataTokens[dataToken.Key] = dataToken.Value;
                    }
                }
            }

            return builder.Build();
        }
    }
}


================================================
FILE: src/Common/Routing/RouteInfoDirectRouteFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;

#if ASPNETWEBAPI
using TRouteInfoProvider = System.Web.Http.Routing.IHttpRouteInfoProvider;
#else
using System.Web.Mvc.Properties;
using TRouteInfoProvider = System.Web.Mvc.Routing.IRouteInfoProvider;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <remarks>
    /// This class is an adapter that turns an IHttpRouteInfoProvider into an IDirectRouteFactory. We need it because
    /// we already shipped IHttpRouteInfoProvider but want to standardize the internal implementation around the more
    /// general IDirectRouteFactory interface.
    /// We can remove this class if we ever stop supporting custom attributes that implement IHttpRouteInfoProvider.
    /// </remarks>
    internal class RouteInfoDirectRouteFactory : IDirectRouteFactory
    {
        private readonly TRouteInfoProvider _infoProvider;

        public RouteInfoDirectRouteFactory(TRouteInfoProvider infoProvider)
        {
            if (infoProvider == null)
            {
                throw new ArgumentNullException("infoProvider");
            }

            _infoProvider = infoProvider;
        }

        public RouteEntry CreateRoute(DirectRouteFactoryContext context)
        {
            Contract.Assert(context != null);

            IDirectRouteBuilder builder = context.CreateBuilder(_infoProvider.Template);
            Contract.Assert(builder != null);

            builder.Name = _infoProvider.Name;

#if ASPNETWEBAPI
            builder.Order = _infoProvider.Order;
#endif

            return builder.Build();
        }
    }
}


================================================
FILE: src/Common/Routing/RouteParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
#if ASPNETWEBAPI
using ErrorResources = System.Web.Http.Properties.SRResources;
using TParsedRoute = System.Web.Http.Routing.HttpParsedRoute;
#else
using ErrorResources = System.Web.Mvc.Properties.MvcResources;
using TParsedRoute = System.Web.Mvc.Routing.ParsedRoute;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    // in the MVC case, route parsing is done for AttributeRouting's sake, so that
    // it could order the discovered routes before pushing them into the routeCollection,
    // where, unfortunately, they would be parsed again.
    internal static class RouteParser
    {
        private static string GetLiteral(string segmentLiteral)
        {
            // Scan for errant single { and } and convert double {{ to { and double }} to }

            // First we eliminate all escaped braces and then check if any other braces are remaining
            string newLiteral = segmentLiteral.Replace("{{", String.Empty).Replace("}}", String.Empty);
            if (newLiteral.Contains("{") || newLiteral.Contains("}"))
            {
                return null;
            }

            // If it's a valid format, we unescape the braces
            return segmentLiteral.Replace("{{", "{").Replace("}}", "}");
        }

        private static int IndexOfFirstOpenParameter(string segment, int startIndex)
        {
            // Find the first unescaped open brace
            while (true)
            {
                startIndex = segment.IndexOf('{', startIndex);
                if (startIndex == -1)
                {
                    // If there are no more open braces, stop
                    return -1;
                }
                if ((startIndex + 1 == segment.Length) ||
                    ((startIndex + 1 < segment.Length) && (segment[startIndex + 1] != '{')))
                {
                    // If we found an open brace that is followed by a non-open brace, it's
                    // a parameter delimiter.
                    // It's also a delimiter if the open brace is the last character - though
                    // it ends up being being called out as invalid later on.
                    return startIndex;
                }
                // Increment by two since we want to skip both the open brace that
                // we're on as well as the subsequent character since we know for
                // sure that it is part of an escape sequence.
                startIndex += 2;
            }
        }

        internal static bool IsSeparator(string s)
        {
            return String.Equals(s, "/", StringComparison.Ordinal);
        }

        private static bool IsValidParameterName(string parameterName)
        {
            if (parameterName.Length == 0)
            {
                return false;
            }

            for (int i = 0; i < parameterName.Length; i++)
            {
                char c = parameterName[i];
                if (c == '/' || c == '{' || c == '}')
                {
                    return false;
                }
            }

            return true;
        }

        internal static bool IsInvalidRouteTemplate(string routeTemplate)
        {
            return routeTemplate.StartsWith("~", StringComparison.Ordinal) ||
                   routeTemplate.StartsWith("/", StringComparison.Ordinal) ||
                   (routeTemplate.IndexOf('?') != -1);
        }

        public static TParsedRoute Parse(string routeTemplate)
        {
            if (routeTemplate == null)
            {
                routeTemplate = String.Empty;
            }

            if (IsInvalidRouteTemplate(routeTemplate))
            {
                throw Error.Argument("routeTemplate", ErrorResources.Route_InvalidRouteTemplate);
            }

            List<string> uriParts = SplitUriToPathSegmentStrings(routeTemplate);
            Exception ex = ValidateUriParts(uriParts);
            if (ex != null)
            {
                throw ex;
            }

            List<PathSegment> pathSegments = SplitUriToPathSegments(uriParts);

            Contract.Assert(uriParts.Count == pathSegments.Count, "The number of string segments should be the same as the number of path segments");

            return new TParsedRoute(pathSegments);
        }

        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly",
            Justification = "The exceptions are just constructed here, but they are thrown from a method that does have those parameter names.")]
        private static List<PathSubsegment> ParseUriSegment(string segment, out Exception exception)
        {
            int startIndex = 0;

            List<PathSubsegment> pathSubsegments = new List<PathSubsegment>();

            while (startIndex < segment.Length)
            {
                int nextParameterStart = IndexOfFirstOpenParameter(segment, startIndex);
                if (nextParameterStart == -1)
                {
                    // If there are no more parameters in the segment, capture the remainder as a literal and stop
                    string lastLiteralPart = GetLiteral(segment.Substring(startIndex));
                    if (lastLiteralPart == null)
                    {
                        exception = Error.Argument("routeTemplate", ErrorResources.Route_MismatchedParameter, segment);
                        return null;
                    }

                    if (lastLiteralPart.Length > 0)
                    {
                        pathSubsegments.Add(new PathLiteralSubsegment(lastLiteralPart));
                    }
                    break;
                }

                int nextParameterEnd = segment.IndexOf('}', nextParameterStart + 1);
                if (nextParameterEnd == -1)
                {
                    exception = Error.Argument("routeTemplate", ErrorResources.Route_MismatchedParameter, segment);
                    return null;
                }

                string literalPart = GetLiteral(segment.Substring(startIndex, nextParameterStart - startIndex));
                if (literalPart == null)
                {
                    exception = Error.Argument("routeTemplate", ErrorResources.Route_MismatchedParameter, segment);
                    return null;
                }

                if (literalPart.Length > 0)
                {
                    pathSubsegments.Add(new PathLiteralSubsegment(literalPart));
                }

                string parameterName = segment.Substring(nextParameterStart + 1, nextParameterEnd - nextParameterStart - 1);
                pathSubsegments.Add(new PathParameterSubsegment(parameterName));

                startIndex = nextParameterEnd + 1;
            }

            exception = null;
            return pathSubsegments;
        }

        private static List<PathSegment> SplitUriToPathSegments(List<string> uriParts)
        {
            List<PathSegment> pathSegments = new List<PathSegment>();

            foreach (string pathSegment in uriParts)
            {
                bool isCurrentPartSeparator = IsSeparator(pathSegment);
                if (isCurrentPartSeparator)
                {
                    pathSegments.Add(new PathSeparatorSegment());
                }
                else
                {
                    Exception exception;
                    List<PathSubsegment> subsegments = ParseUriSegment(pathSegment, out exception);
                    Contract.Assert(exception == null, "This only gets called after the path has been validated, so there should never be an exception here");
                    pathSegments.Add(new PathContentSegment(subsegments));
                }
            }
            return pathSegments;
        }

        internal static List<string> SplitUriToPathSegmentStrings(string uri)
        {
            List<string> parts = new List<string>();

            if (String.IsNullOrEmpty(uri))
            {
                return parts;
            }

            int currentIndex = 0;

            // Split the incoming URI into individual parts
            while (currentIndex < uri.Length)
            {
                int indexOfNextSeparator = uri.IndexOf('/', currentIndex);
                if (indexOfNextSeparator == -1)
                {
                    // If there are no more separators, the rest of the string is the last part
                    string finalPart = uri.Substring(currentIndex);
                    if (finalPart.Length > 0)
                    {
                        parts.Add(finalPart);
                    }
                    break;
                }

                string nextPart = uri.Substring(currentIndex, indexOfNextSeparator - currentIndex);
                if (nextPart.Length > 0)
                {
                    parts.Add(nextPart);
                }

                Contract.Assert(uri[indexOfNextSeparator] == '/', "The separator char itself should always be a '/'.");
                parts.Add("/");
                currentIndex = indexOfNextSeparator + 1;
            }

            return parts;
        }

        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "Not changing original algorithm")]
        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly",
            Justification = "The exceptions are just constructed here, but they are thrown from a method that does have those parameter names.")]
        private static Exception ValidateUriParts(List<string> pathSegments)
        {
            Contract.Assert(pathSegments != null, "The value should always come from SplitUri(), and that function should never return null.");

            HashSet<string> usedParameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            bool? isPreviousPartSeparator = null;

            bool foundCatchAllParameter = false;

            foreach (string pathSegment in pathSegments)
            {
                if (foundCatchAllParameter)
                {
                    // If we ever start an iteration of the loop and we've already found a
                    // catchall parameter then we have an invalid URI format.
                    return Error.Argument("routeTemplate", ErrorResources.Route_CatchAllMustBeLast, "routeTemplate");
                }

                bool isCurrentPartSeparator;
                if (isPreviousPartSeparator == null)
                {
                    // Prime the loop with the first value
                    isPreviousPartSeparator = IsSeparator(pathSegment);
                    isCurrentPartSeparator = isPreviousPartSeparator.Value;
                }
                else
                {
                    isCurrentPartSeparator = IsSeparator(pathSegment);

                    // If both the previous part and the current part are separators, it's invalid
                    if (isCurrentPartSeparator && isPreviousPartSeparator.Value)
                    {
                        return Error.Argument("routeTemplate", ErrorResources.Route_CannotHaveConsecutiveSeparators);
                    }

                    Contract.Assert(isCurrentPartSeparator != isPreviousPartSeparator.Value, "This assert should only happen if both the current and previous parts are non-separators. This should never happen because consecutive non-separators are always parsed as a single part.");
                    isPreviousPartSeparator = isCurrentPartSeparator;
                }

                // If it's not a separator, parse the segment for parameters and validate it
                if (!isCurrentPartSeparator)
                {
                    Exception exception;
                    List<PathSubsegment> subsegments = ParseUriSegment(pathSegment, out exception);
                    if (exception != null)
                    {
                        return exception;
                    }

                    exception = ValidateUriSegment(subsegments, usedParameterNames);
                    if (exception != null)
                    {
                        return exception;
                    }

                    foundCatchAllParameter = subsegments.Any<PathSubsegment>(seg => (seg is PathParameterSubsegment) && ((PathParameterSubsegment)seg).IsCatchAll);
                }
            }
            return null;
        }

        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly",
            Justification = "The exceptions are just constructed here, but they are thrown from a method that does have those parameter names.")]
        private static Exception ValidateUriSegment(List<PathSubsegment> pathSubsegments, HashSet<string> usedParameterNames)
        {
            bool segmentContainsCatchAll = false;

            Type previousSegmentType = null;

            foreach (PathSubsegment subsegment in pathSubsegments)
            {
                if (previousSegmentType != null)
                {
                    if (previousSegmentType == subsegment.GetType())
                    {
                        return Error.Argument("routeTemplate", ErrorResources.Route_CannotHaveConsecutiveParameters);
                    }
                }
                previousSegmentType = subsegment.GetType();

                PathLiteralSubsegment literalSubsegment = subsegment as PathLiteralSubsegment;
                if (literalSubsegment != null)
                {
                    // Nothing to validate for literals - everything is valid
                }
                else
                {
                    PathParameterSubsegment parameterSubsegment = subsegment as PathParameterSubsegment;
                    if (parameterSubsegment != null)
                    {
                        string parameterName = parameterSubsegment.ParameterName;

                        if (parameterSubsegment.IsCatchAll)
                        {
                            segmentContainsCatchAll = true;
                        }

                        // Check for valid characters in the parameter name
                        if (!IsValidParameterName(parameterName))
                        {
                            return Error.Argument("routeTemplate", ErrorResources.Route_InvalidParameterName, parameterName);
                        }

                        if (usedParameterNames.Contains(parameterName))
                        {
                            return Error.Argument("routeTemplate", ErrorResources.Route_RepeatedParameter, parameterName);
                        }
                        else
                        {
                            usedParameterNames.Add(parameterName);
                        }
                    }
                    else
                    {
                        Contract.Assert(false, "Invalid path subsegment type");
                    }
                }
            }

            if (segmentContainsCatchAll && (pathSubsegments.Count != 1))
            {
                return Error.Argument("routeTemplate", ErrorResources.Route_CannotHaveCatchAllInMultiSegment);
            }

            return null;
        }
    }
}


================================================
FILE: src/Common/Routing/RoutePrecedence.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;

#if ASPNETWEBAPI
using TParsedRoute = System.Web.Http.Routing.HttpParsedRoute;
#else
using TParsedRoute = System.Web.Mvc.Routing.ParsedRoute;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    internal static class RoutePrecedence
    {
        // Segments have the following order:
        // 1 - Literal segments
        // 2 - Constrained parameter segments / Multi-part segments
        // 3 - Unconstrained parameter segments
        // 4 - Constrained wildcard parameter segments
        // 5 - Unconstrained wildcard parameter segments
        internal static int ComputeDigit(PathContentSegment segment, IDictionary<string, object> constraints)
        {
            if (segment.Subsegments.Count > 1)
            {
                // Multi-part segments should appear after literal segments but before parameter segments
                return 2;
            }

            PathSubsegment subsegment = segment.Subsegments[0];
            // Literal segments always go first
            if (subsegment is PathLiteralSubsegment)
            {
                return 1;
            }
            else
            {
                PathParameterSubsegment parameterSegment = subsegment as PathParameterSubsegment;
                Contract.Assert(parameterSegment != null);
                int order = parameterSegment.IsCatchAll ? 5 : 3;

                // If there is a route constraint for the parameter, reduce order by 1
                // Constrained parameters end up with order 2, Constrained catch alls end up with order 4
                if (constraints != null && constraints.ContainsKey(parameterSegment.ParameterName))
                {
                    order--;
                }

                return order;
            }
        }

        public static decimal Compute(TParsedRoute parsedRoute, IDictionary<string, object> constraints)
        {
            // Each precedence digit corresponds to one decimal place. For example, 3 segments with precedences 2, 1,
            // and 4 results in a combined precedence of 2.14 (decimal).
            IList<PathContentSegment> segments = parsedRoute.PathSegments.OfType<PathContentSegment>().ToArray();

            decimal precedence = 0;
            uint divisor = 1; // The first digit occupies the one's place.

            for (int i = 0; i < segments.Count; i++)
            {
                PathContentSegment segment = segments[i];

                int digit = ComputeDigit(segment, constraints);
                Contract.Assert(digit >= 0 && digit < 10);

                precedence = precedence + Decimal.Divide(digit, divisor);

                // The next digit occupies the subsequent place (always after the decimal point and growing to the
                // right).
                divisor *= 10;
            }

            return precedence;
        }
    }
}


================================================
FILE: src/Common/Routing/SubRouteCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;

#if ASPNETWEBAPI
using System.Web.Http.Properties;
using TRoute = System.Web.Http.Routing.IHttpRoute;
using TRouteEntry = System.Web.Http.Routing.RouteEntry;
#else
using System.Web.Mvc.Properties;
using TRoute = System.Web.Routing.Route;
using TRouteEntry = System.Web.Mvc.Routing.RouteEntry;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>Represents a collection of route entries and the routes they contain.</summary>
    /// <remarks>
    /// This is used in attribute routing, where we want to match multiple routes, and then later
    /// disambiguate which one is best.
    /// </remarks>
    internal class SubRouteCollection : IReadOnlyCollection<TRoute>
    {
        private readonly List<TRoute> _routes = new List<TRoute>();
        private readonly List<TRouteEntry> _entries = new List<TRouteEntry>();

        public void Add(TRouteEntry entry)
        {
            Contract.Assert(entry != null);
            TRoute route = entry.Route;
            Contract.Assert(route != null);

            string name = entry.Name;

            if (name != null)
            {
                TRouteEntry duplicateEntry = _entries.SingleOrDefault((e) => e.Name == name);

                if (duplicateEntry != null)
                {
                    ThrowExceptionForDuplicateRouteNames(name, route, duplicateEntry.Route);
                }
            }

            _routes.Add(route);
            _entries.Add(entry);
        }

        public void AddRange(IEnumerable<TRouteEntry> entries)
        {
            foreach (RouteEntry entry in entries)
            {
                Add(entry);
            }
        }

        public int Count
        {
            get { return _entries.Count; }
        }

        public IEnumerator<TRoute> GetEnumerator()
        {
            return _routes.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_routes).GetEnumerator();
        }

        public IReadOnlyCollection<TRouteEntry> Entries
        {
            get { return _entries; }
        }

        private static void ThrowExceptionForDuplicateRouteNames(string name, TRoute route1, TRoute route2)
        {
#if ASPNETWEBAPI
            throw new InvalidOperationException(String.Format(
                CultureInfo.CurrentCulture,
                SRResources.SubRouteCollection_DuplicateRouteName,
                name,
                route1.RouteTemplate,
                route2.RouteTemplate));
#else
            throw new InvalidOperationException(String.Format(
                CultureInfo.CurrentCulture,
                MvcResources.SubRouteCollection_DuplicateRouteName,
                name,
                route1.Url,
                route2.Url));
#endif
        }
    }
}


================================================
FILE: src/Common/TaskHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Threading.Tasks
{
    /// <summary>
    /// Helpers for safely using Task libraries. 
    /// </summary>
    internal static class TaskHelpers
    {
        private static readonly Task _defaultCompleted = Task.FromResult<AsyncVoid>(default(AsyncVoid));

        private static readonly Task<object> _completedTaskReturningNull = Task.FromResult<object>(null);

        /// <summary>
        /// Returns a canceled Task. The task is completed, IsCanceled = True, IsFaulted = False.
        /// </summary>
        internal static Task Canceled()
        {
            return CancelCache<AsyncVoid>.Canceled;
        }

        /// <summary>
        /// Returns a canceled Task of the given type. The task is completed, IsCanceled = True, IsFaulted = False.
        /// </summary>
        internal static Task<TResult> Canceled<TResult>()
        {
            return CancelCache<TResult>.Canceled;
        }

        /// <summary>
        /// Returns a completed task that has no result. 
        /// </summary>        
        internal static Task Completed()
        {
            return _defaultCompleted;
        }

        /// <summary>
        /// Returns an error task. The task is Completed, IsCanceled = False, IsFaulted = True
        /// </summary>
        internal static Task FromError(Exception exception)
        {
            return FromError<AsyncVoid>(exception);
        }

        /// <summary>
        /// Returns an error task of the given type. The task is Completed, IsCanceled = False, IsFaulted = True
        /// </summary>
        /// <typeparam name="TResult"></typeparam>
        internal static Task<TResult> FromError<TResult>(Exception exception)
        {
            TaskCompletionSource<TResult> tcs = new TaskCompletionSource<TResult>();
            tcs.SetException(exception);
            return tcs.Task;
        }

        internal static Task<object> NullResult()
        {
            return _completedTaskReturningNull;
        }

        /// <summary>
        /// Used as the T in a "conversion" of a Task into a Task{T}
        /// </summary>
        private struct AsyncVoid
        {
        }

        /// <summary>
        /// This class is a convenient cache for per-type cancelled tasks
        /// </summary>
        private static class CancelCache<TResult>
        {
            public static readonly Task<TResult> Canceled = GetCancelledTask();

            private static Task<TResult> GetCancelledTask()
            {
                TaskCompletionSource<TResult> tcs = new TaskCompletionSource<TResult>();
                tcs.SetCanceled();
                return tcs.Task;
            }
        }
    }
}


================================================
FILE: src/Common/TaskHelpersExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Threading.Tasks
{
    internal static class TaskHelpersExtensions
    {
        /// <summary>
        /// Cast Task to Task of object
        /// </summary>
        internal static async Task<object> CastToObject(this Task task)
        {
            await task;
            return null;
        }

        /// <summary>
        /// Cast Task of T to Task of object
        /// </summary>
        internal static async Task<object> CastToObject<T>(this Task<T> task)
        {
            return (object)await task;
        }

        /// <summary>
        /// Throws the first faulting exception for a task which is faulted. It preserves the original stack trace when
        /// throwing the exception. Note: It is the caller's responsibility not to pass incomplete tasks to this
        /// method, because it does degenerate into a call to the equivalent of .Wait() on the task when it hasn't yet
        /// completed.
        /// </summary>
        internal static void ThrowIfFaulted(this Task task)
        {
            task.GetAwaiter().GetResult();
        }

        /// <summary>
        /// Attempts to get the result value for the given task. If the task ran to completion, then
        /// it will return true and set the result value; otherwise, it will return false.
        /// </summary>
        [SuppressMessage("Microsoft.Web.FxCop", "MW1201", Justification = "The usages here are deemed safe, and provide the implementations that this rule relies upon.")]
        internal static bool TryGetResult<TResult>(this Task<TResult> task, out TResult result)
        {
            if (task.Status == TaskStatus.RanToCompletion)
            {
                result = task.Result;
                return true;
            }

            result = default(TResult);
            return false;
        }
    }
}


================================================
FILE: src/Common/TraceWriterExceptionMapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net;
using System.Net.Http;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Extension methods for <see cref="TraceRecord"/>.
    /// </summary>
    internal static class TraceWriterExceptionMapper
    {
        private const string HttpErrorExceptionMessageFormat = "ExceptionMessage{0}='{1}'";
        private const string HttpErrorExceptionTypeFormat = "ExceptionType{0}='{1}'";
        private const string HttpErrorMessageDetailFormat = "MessageDetail='{0}'";
        private const string HttpErrorModelStateErrorFormat = "ModelStateError=[{0}]";
        private const string HttpErrorModelStatePairFormat = "{0}=[{1}]";
        private const string HttpErrorStackTraceFormat = "StackTrace{0}={1}";
        private const string HttpErrorUserMessageFormat = "UserMessage='{0}'";

        /// <summary>
        /// Examines the given <see cref="TraceRecord"/> to determine whether it
        /// contains an <see cref="HttpResponseException"/> and if so, modifies
        /// the <see cref="TraceRecord"/> to capture more detailed information.
        /// </summary>
        /// <param name="traceRecord">The <see cref="TraceRecord"/> to examine and modify.</param>
        public static void TranslateHttpResponseException(TraceRecord traceRecord)
        {
            Contract.Assert(traceRecord != null);

            HttpResponseException httpResponseException = ExtractHttpResponseException(traceRecord.Exception);
            if (httpResponseException == null)
            {
                return;
            }

            HttpResponseMessage response = httpResponseException.Response;
            Contract.Assert(response != null);

            // If the status has been set already, do not overwrite it,
            // otherwise propagate the status into the record.
            if (traceRecord.Status == 0)
            {
                traceRecord.Status = response.StatusCode;
            }

            traceRecord.Level = GetMappedTraceLevel(httpResponseException) ?? traceRecord.Level;

            // HttpResponseExceptions often contain HttpError instances that carry
            // detailed information that may be filtered out by IncludeErrorDetailPolicy
            // before reaching the client. Capture it here for the trace.
            ObjectContent objectContent = response.Content as ObjectContent;
            if (objectContent == null)
            {
                return;
            }

            HttpError httpError = objectContent.Value as HttpError;
            if (httpError == null)
            {
                return;
            }

            object messageObject = null;
            object messageDetailsObject = null;

            List<string> messages = new List<string>();

            if (httpError.TryGetValue(HttpErrorKeys.MessageKey, out messageObject))
            {
                messages.Add(Error.Format(HttpErrorUserMessageFormat, messageObject));
            }

            if (httpError.TryGetValue(HttpErrorKeys.MessageDetailKey, out messageDetailsObject))
            {
                messages.Add(Error.Format(HttpErrorMessageDetailFormat, messageDetailsObject));
            }

            // Extract the exception from this HttpError and then incrementally
            // walk down all inner exceptions.
            AddExceptions(httpError, messages);

            // ModelState errors are handled with a nested HttpError
            object modelStateErrorObject = null;
            if (httpError.TryGetValue(HttpErrorKeys.ModelStateKey, out modelStateErrorObject))
            {
                HttpError modelStateError = modelStateErrorObject as HttpError;
                if (modelStateError != null)
                {
                    messages.Add(FormatModelStateErrors(modelStateError));
                }
            }

            traceRecord.Message = String.Join(", ", messages);
        }

        /// <summary>
        /// Gets the <see cref="TraceLevel"/> per the <see cref="HttpStatusCode"/> if the given exception is
        /// a <see cref="HttpResponseException"/>; otherwise <see langword="null"/>.
        /// </summary>
        /// <param name="exception">The exception.</param>
        /// <returns>The corresponding trace level if the exception represents an <see cref="HttpResponseException"/>.</returns>
        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "shared source. called from a different assembly")]
        public static TraceLevel? GetMappedTraceLevel(Exception exception)
        {
            HttpResponseException httpResponseException = ExtractHttpResponseException(exception);
            if (httpResponseException == null)
            {
                return null;
            }

            return GetMappedTraceLevel(httpResponseException);
        }

        /// <summary>
        /// Gets the <see cref="TraceLevel"/> per the <see cref="HttpStatusCode"/>.
        /// </summary>
        /// <param name="httpResponseException">The exception for which the trace level has to be found.</param>
        /// <returns>The mapped trace level.</returns>
        public static TraceLevel? GetMappedTraceLevel(HttpResponseException httpResponseException)
        {
            Contract.Assert(httpResponseException != null);

            HttpResponseMessage response = httpResponseException.Response;
            Contract.Assert(response != null);

            TraceLevel? level = null;

            // Client level errors are downgraded to TraceLevel.Warn
            if ((int)response.StatusCode < (int)HttpStatusCode.InternalServerError)
            {
                level = TraceLevel.Warn;
            }

            // Non errors are downgraded to TraceLevel.Info
            if ((int)response.StatusCode < (int)HttpStatusCode.BadRequest)
            {
                level = TraceLevel.Info;
            }

            return level;
        }

        private static HttpResponseException ExtractHttpResponseException(Exception exception)
        {
            if (exception == null)
            {
                return null;
            }

            var httpResponseException = exception as HttpResponseException;
            if (httpResponseException != null)
            {
                return httpResponseException;
            }

            var aggregateException = exception as AggregateException;
            if (aggregateException != null)
            {
                httpResponseException = aggregateException
                    .Flatten()
                    .InnerExceptions
                    .Select(ExtractHttpResponseException)
                    .Where(ex => ex != null && ex.Response != null)
                    .OrderByDescending(ex => ex.Response.StatusCode)
                    .FirstOrDefault();
                return httpResponseException;
            }

            return ExtractHttpResponseException(exception.InnerException);
        }

        /// <summary>
        /// Unpacks any exceptions in the given <see cref="HttpError"/> and adds
        /// them into a collection of name-value pairs that can be composed into a single string.
        /// </summary>
        /// <remarks>
        /// This helper also iterates over all inner exceptions and unpacks them too.
        /// </remarks>
        /// <param name="httpError">The <see cref="HttpError"/> to unpack.</param>
        /// <param name="messages">A collection of messages to which the new information should be added.</param>
        private static void AddExceptions(HttpError httpError, List<string> messages)
        {
            Contract.Assert(httpError != null);
            Contract.Assert(messages != null);

            object exceptionMessageObject = null;
            object exceptionTypeObject = null;
            object stackTraceObject = null;
            object innerExceptionObject = null;

            for (int i = 0; httpError != null; i++)
            {
                // For uniqueness, key names append the depth of inner exception
                string indexText = i == 0 ? String.Empty : Error.Format("[{0}]", i);

                if (httpError.TryGetValue(HttpErrorKeys.ExceptionTypeKey, out exceptionTypeObject))
                {
                    messages.Add(Error.Format(HttpErrorExceptionTypeFormat, indexText, exceptionTypeObject));
                }

                if (httpError.TryGetValue(HttpErrorKeys.ExceptionMessageKey, out exceptionMessageObject))
                {
                    messages.Add(Error.Format(HttpErrorExceptionMessageFormat, indexText, exceptionMessageObject));
                }

                if (httpError.TryGetValue(HttpErrorKeys.StackTraceKey, out stackTraceObject))
                {
                    messages.Add(Error.Format(HttpErrorStackTraceFormat, indexText, stackTraceObject));
                }

                if (!httpError.TryGetValue(HttpErrorKeys.InnerExceptionKey, out innerExceptionObject))
                {
                    break;
                }

                Contract.Assert(!Object.ReferenceEquals(httpError, innerExceptionObject));

                httpError = innerExceptionObject as HttpError;
            }
        }

        private static string FormatModelStateErrors(HttpError modelStateError)
        {
            Contract.Assert(modelStateError != null);

            List<string> messages = new List<string>();
            foreach (var pair in modelStateError)
            {
                IEnumerable<string> errorList = pair.Value as IEnumerable<string>;
                if (errorList != null)
                {
                    messages.Add(Error.Format(HttpErrorModelStatePairFormat, pair.Key, String.Join(", ", errorList)));
                }
            }

            return Error.Format(HttpErrorModelStateErrorFormat, String.Join(", ", messages));
        }
    }
}


================================================
FILE: src/Common/TypeExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;

namespace System
{
    /// <summary>
    /// Extension methods for <see cref="Type"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    internal static class TypeExtensions
    {
        public static bool IsNullable(this Type type)
        {
            if (type.IsValueType)
            {
                // value types are only nullable if they are Nullable<T>
                return type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>);
            }
            else
            {
                // reference types are always nullable
                return true;
            }
        }
    }
}


================================================
FILE: src/CommonAssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;
using System.Resources;
using System.Runtime.InteropServices;

#if !BUILD_GENERATED_VERSION
[assembly: AssemblyCompany(".NET Foundation")]
[assembly: AssemblyCopyright("Copyright © .NET Foundation. All rights reserved.")]
#endif
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
#if !NOT_CLS_COMPLIANT
[assembly: CLSCompliant(true)]
#endif
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyMetadata("Serviceable", "True")]

// ===================================================================================
//  TAKE CARE WHEN EDITING OR REMOVING ANYTHING BELOW THIS COMMENT.
//  BUILD_GENERATED_VERSION will be set in any CI build. Versions below are not used.
// ===================================================================================

#if (ASPNETMVC && (ASPNETWEBPAGES || ASPNETFACEBOOK || ASPNETHTTPFORMATTING)) || (ASPNETWEBPAGES && (ASPNETFACEBOOK || ASPNETHTTPFORMATTING)) || (ASPNETFACEBOOK && ASPNETHTTPFORMATTING)
#error Runtime projects cannot define more than one of ASPNETMVC, ASPNETWEBPAGES, ASPNETFACEBOOK, or ASPNETHTTPFORMATTING
#elif ASPNETHTTPFORMATTING
#if !BUILD_GENERATED_VERSION
[assembly: AssemblyVersion("6.0.0.0")] // ASPNETHTTPFORMATTING
[assembly: AssemblyFileVersion("6.0.0.0")] // ASPNETHTTPFORMATTING
#endif
#elif ASPNETMVC
#if !BUILD_GENERATED_VERSION
[assembly: AssemblyVersion("5.3.0.0")] // ASPNETMVC
[assembly: AssemblyFileVersion("5.3.0.0")] // ASPNETMVC
#endif
[assembly: AssemblyProduct("Microsoft ASP.NET MVC")]
#elif ASPNETWEBPAGES
#if !BUILD_GENERATED_VERSION
[assembly: AssemblyVersion("3.0.0.0")] // ASPNETWEBPAGES
[assembly: AssemblyFileVersion("3.0.0.0")] // ASPNETWEBPAGES
#endif
[assembly: AssemblyProduct("Microsoft ASP.NET Web Pages")]
#elif ASPNETFACEBOOK
#if !BUILD_GENERATED_VERSION
[assembly: AssemblyVersion("1.1.0.0")] // ASPNETFACEBOOK
[assembly: AssemblyFileVersion("1.1.0.0")] // ASPNETFACEBOOK
#endif
[assembly: AssemblyProduct("Microsoft ASP.NET Facebook")]
#else
#error Runtime projects must define ASPNETMVC, ASPNETWEBPAGES or ASPNETFACEBOOK
#endif


================================================
FILE: src/CommonAssemblyInfo.vb
================================================
' Copyright (c) .NET Foundation. All rights reserved.
' Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

Imports System
Imports System.Reflection
Imports System.Resources
Imports System.Runtime.InteropServices

<Assembly: AssemblyCompany(".NET Foundation")>
<Assembly: AssemblyCopyright("Copyright © .NET Foundation. All rights reserved.")>
<Assembly: AssemblyConfiguration("")>
<Assembly: AssemblyTrademark("")>
<Assembly: ComVisible(False)>
<Assembly: CLSCompliant(True)>

<Assembly: NeutralResourcesLanguage("en-US")>

' ===========================================================================
' DO NOT EDIT OR REMOVE ANYTHING BELOW THIS COMMENT.
' Version numbers are automatically generated based on regular expressions.
' ===========================================================================

<Assembly: AssemblyVersion("5.3.0.0")>   'ASPNETMVC
<Assembly: AssemblyFileVersion("5.3.0.0")>   'ASPNETMVC
<Assembly: AssemblyProduct("Microsoft ASP.NET MVC")>

================================================
FILE: src/CommonResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.239
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.Internal.Web.Utils {
    using System;
    using System.Linq;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class CommonResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal CommonResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    // Find the CommonResources.resources file's full resource name in this assembly
                    string commonResourcesName = global::System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceNames().Where(s => s.EndsWith("CommonResources.resources", StringComparison.OrdinalIgnoreCase)).Single();

                    // Trim off the ".resources"
                    commonResourcesName = commonResourcesName.Substring(0, commonResourcesName.Length - 10);

                    // Load the resource manager
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager(commonResourcesName, typeof(CommonResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value cannot be null or an empty string..
        /// </summary>
        internal static string Argument_Cannot_Be_Null_Or_Empty {
            get {
                return ResourceManager.GetString("Argument_Cannot_Be_Null_Or_Empty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be between {0} and {1}..
        /// </summary>
        internal static string Argument_Must_Be_Between {
            get {
                return ResourceManager.GetString("Argument_Must_Be_Between", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be a value from the &quot;{0}&quot; enumeration..
        /// </summary>
        internal static string Argument_Must_Be_Enum_Member {
            get {
                return ResourceManager.GetString("Argument_Must_Be_Enum_Member", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be greater than {0}..
        /// </summary>
        internal static string Argument_Must_Be_GreaterThan {
            get {
                return ResourceManager.GetString("Argument_Must_Be_GreaterThan", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be greater than or equal to {0}..
        /// </summary>
        internal static string Argument_Must_Be_GreaterThanOrEqualTo {
            get {
                return ResourceManager.GetString("Argument_Must_Be_GreaterThanOrEqualTo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be less than {0}..
        /// </summary>
        internal static string Argument_Must_Be_LessThan {
            get {
                return ResourceManager.GetString("Argument_Must_Be_LessThan", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be less than or equal to {0}..
        /// </summary>
        internal static string Argument_Must_Be_LessThanOrEqualTo {
            get {
                return ResourceManager.GetString("Argument_Must_Be_LessThanOrEqualTo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value cannot be an empty string. It must either be null or a non-empty string..
        /// </summary>
        internal static string Argument_Must_Be_Null_Or_Non_Empty {
            get {
                return ResourceManager.GetString("Argument_Must_Be_Null_Or_Non_Empty", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/CommonResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Argument_Cannot_Be_Null_Or_Empty" xml:space="preserve">
    <value>Value cannot be null or an empty string.</value>
  </data>
  <data name="Argument_Must_Be_Between" xml:space="preserve">
    <value>Value must be between {0} and {1}.</value>
  </data>
  <data name="Argument_Must_Be_Enum_Member" xml:space="preserve">
    <value>Value must be a value from the "{0}" enumeration.</value>
  </data>
  <data name="Argument_Must_Be_GreaterThan" xml:space="preserve">
    <value>Value must be greater than {0}.</value>
  </data>
  <data name="Argument_Must_Be_GreaterThanOrEqualTo" xml:space="preserve">
    <value>Value must be greater than or equal to {0}.</value>
  </data>
  <data name="Argument_Must_Be_LessThan" xml:space="preserve">
    <value>Value must be less than {0}.</value>
  </data>
  <data name="Argument_Must_Be_LessThanOrEqualTo" xml:space="preserve">
    <value>Value must be less than or equal to {0}.</value>
  </data>
  <data name="Argument_Must_Be_Null_Or_Non_Empty" xml:space="preserve">
    <value>Value cannot be an empty string. It must either be null or a non-empty string.</value>
  </data>
</root>

================================================
FILE: src/Directory.Build.props
================================================
<Project>
  <Import Project="..\Directory.Build.props" />

  <PropertyGroup>
    <IsPackable>true</IsPackable>
    <IsTestProject>false</IsTestProject>
    <TargetFrameworkVersion Condition=" !$(MSBuildProjectName.StartsWith('System.Net.Http.Formatting.ns')) ">v4.5</TargetFrameworkVersion>
  </PropertyGroup>
</Project>


================================================
FILE: src/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "Assembly is delay-signed")]


================================================
FILE: src/Microsoft.AspNet.Facebook/Authorization/FacebookAuthorizeFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Facebook;
using Microsoft.AspNet.Facebook.Client;

namespace Microsoft.AspNet.Facebook.Authorization
{
    /// <summary>
    /// Authorization filter that verifies the signed requests and permissions from Facebook.
    /// </summary>
    public class FacebookAuthorizeFilter : IAuthorizationFilter
    {
        private static readonly Uri FacebookUri = new Uri("https://www.facebook.com/");
        private static readonly Uri DefaultAuthorizationRedirectUrl = FacebookUri;
        private static readonly Uri DefaultCannotCreateCookiesRedirectPath = FacebookUri;
        // Facebook Missing Permissions, shortened version to not add excessively long query string parameters to the url.
        private const string MissingPermissionsQueryName = "__fb_mps";

        private FacebookConfiguration _config;

        /// <summary>
        /// Initializes a new instance of the <see cref="FacebookAuthorizeFilter" /> class.
        /// </summary>
        /// <param name="config">The <see cref="FacebookConfiguration"/>.</param>
        public FacebookAuthorizeFilter(FacebookConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            _config = config;
        }

        /// <summary>
        /// Called when authorization is required.
        /// </summary>
        /// <param name="filterContext">The filter context.</param>
        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Type references are needed for authorization")]
        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            IEnumerable<FacebookAuthorizeAttribute> authorizeAttributes = filterContext.ActionDescriptor
                .GetCustomAttributes(typeof(FacebookAuthorizeAttribute), inherit: true)
                .Union(filterContext.ActionDescriptor.ControllerDescriptor
                    .GetCustomAttributes(typeof(FacebookAuthorizeAttribute), inherit: true))
                .OfType<FacebookAuthorizeAttribute>();
            if (!authorizeAttributes.Any())
            {
                return;
            }

            FacebookClient client = _config.ClientProvider.CreateClient();
            HttpRequestBase request = filterContext.HttpContext.Request;
            dynamic signedRequest = FacebookRequestHelpers.GetSignedRequest(
                filterContext.HttpContext,
                rawSignedRequest =>
                {
                    return client.ParseSignedRequest(rawSignedRequest);
                });
            string userId = null;
            string accessToken = null;
            if (signedRequest != null)
            {
                userId = signedRequest.user_id;
                accessToken = signedRequest.oauth_token;
            }

            NameValueCollection parsedQueries = HttpUtility.ParseQueryString(request.Url.Query);
            HashSet<string> requiredPermissions = PermissionHelper.GetRequiredPermissions(authorizeAttributes);

            bool handleError = !String.IsNullOrEmpty(parsedQueries["error"]);

            // This must occur AFTER the handleError calculation because it modifies the parsed queries.
            string redirectUrl = GetRedirectUrl(request, parsedQueries);

            // Check if there was an error and we should handle it.
            if (handleError)
            {
                Uri errorUrl;

                if (String.IsNullOrEmpty(_config.AuthorizationRedirectPath))
                {
                    errorUrl = DefaultAuthorizationRedirectUrl;
                }
                else
                {
                    errorUrl = GetErroredAuthorizeUri(redirectUrl, requiredPermissions);
                }

                filterContext.Result = CreateRedirectResult(errorUrl);

                // There was an error so short circuit
                return;
            }

            FacebookContext facebookContext = new FacebookContext
            {
                Client = client,
                SignedRequest = signedRequest,
                AccessToken = accessToken,
                UserId = userId,
                Configuration = _config
            };

            PermissionContext permissionContext = new PermissionContext
            {
                FacebookContext = facebookContext,
                FilterContext = filterContext,
                RequiredPermissions = requiredPermissions,
            };

            // Check if we need to prompt for default permissions.
            if (signedRequest == null || String.IsNullOrEmpty(userId) || String.IsNullOrEmpty(accessToken))
            {
                PromptDefaultPermissions(permissionContext, redirectUrl);
            }
            else if (requiredPermissions.Any())
            {
                PermissionsStatus currentPermissionsStatus = _config.PermissionService.GetUserPermissionsStatus(userId, accessToken);
                // Instead of performing another request to gather "granted" permissions just parse the status
                IEnumerable<string> currentPermissions = PermissionHelper.GetGrantedPermissions(currentPermissionsStatus);
                IEnumerable<string> missingPermissions = requiredPermissions.Except(currentPermissions);

                // If we have missing permissions than we need to present a prompt or redirect to an error 
                // page if there's an error.
                if (missingPermissions.Any())
                {
                    permissionContext.MissingPermissions = missingPermissions;
                    permissionContext.DeclinedPermissions = PermissionHelper.GetDeclinedPermissions(currentPermissionsStatus);
                    permissionContext.SkippedPermissions = PermissionHelper.GetSkippedPermissions(
                        filterContext.HttpContext.Request,
                        missingPermissions,
                        permissionContext.DeclinedPermissions);

                    // Add a query string parameter that enables us to identify if we've already prompted for missing permissions
                    // and therefore can detect cookies.
                    AddCookieVerificationQuery(parsedQueries);
                    // Rebuild the redirect Url so it contains the new query string parameter.
                    redirectUrl = GetRedirectUrl(request, parsedQueries);

                    PromptMissingPermissions(permissionContext, redirectUrl);
                }
            }
        }

        /// <summary>
        /// Adds a query string parameter to a <see cref="NameValueCollection"/> that enables a 
        /// <see cref="FacebookAuthorizeFilter"/> to detect when cookies are unavailable and then trigger the 
        /// <see cref="OnCannotCreateCookies"/> hook.
        /// </summary>
        /// <param name="queries">List of query parameters that are used to create a url.</param>
        protected static void AddCookieVerificationQuery(NameValueCollection queries)
        {
            // Add a query string parameter that enables us to identify if we've already prompted for missing permissions
            queries.Add(MissingPermissionsQueryName, "true");
        }

        /// <summary>
        /// Called when authorization fails and need to create a redirect result.
        /// </summary>
        /// <param name="redirectUrl">The redirect URL.</param>
        /// <returns>The <see cref="ActionResult"/>.</returns>
        public virtual JavaScriptRedirectResult CreateRedirectResult(Uri redirectUrl)
        {
            if (redirectUrl == null)
            {
                throw new ArgumentNullException("redirectUrl");
            }

            return new JavaScriptRedirectResult(redirectUrl);
        }

        /// <summary>
        /// Returns an <see cref="ActionResult"/> that indicates we want to show a permission prompt.  Should only be used as a
        /// return value within the <see cref="OnPermissionPrompt"/> and <see cref="OnDeniedPermissionPrompt"/> methods.
        /// </summary>
        /// <returns>An <see cref="ActionResult"/> that indicates that we want to show a permission prompt.</returns>
        protected ShowPromptResult ShowPrompt(PermissionContext context)
        {
            FacebookClient client = context.FacebookContext.Client;
            Uri navigationUrl = client.GetLoginUrl(context.RedirectUrl,
                                                   _config.AppId,
                                                   permissions: String.Join(",", context.RequiredPermissions));

            return new ShowPromptResult(navigationUrl);
        }

        /// <summary>
        /// Invoked during <see cref="OnAuthorization"/> after determining that cookies cannot be created. Default behavior
        /// redirects to a no cookies error page.
        /// </summary>
        /// <param name="context">Provides access to permission information associated with the user.</param>
        protected virtual void OnCannotCreateCookies(PermissionContext context)
        {
            Uri redirectPath;

            if (String.IsNullOrEmpty(_config.CannotCreateCookieRedirectPath))
            {
                redirectPath = DefaultCannotCreateCookiesRedirectPath;
            }
            else
            {
                redirectPath = GetCannotCreateCookiesUri();
            }

            context.Result = CreateRedirectResult(redirectPath);
        }

        /// <summary>
        /// Invoked during <see cref="OnAuthorization"/> when a prompt requests permissions that were skipped or revoked.
        /// Set the <paramref name="context"/>'s Result property to modify login flow.
        /// </summary>
        /// <param name="context">Provides access to permission information associated with the user.</param>
        protected virtual void OnDeniedPermissionPrompt(PermissionContext context)
        {
        }

        /// <summary>
        /// Invoked during <see cref="OnAuthorization"/> prior to a permission prompt that is requesting permissions that have
        /// not been requested before. Set the <paramref name="context"/>'s Result property to modify login flow.
        /// </summary>
        /// <param name="context">Provides access to permission information associated with the user.</param>
        protected virtual void OnPermissionPrompt(PermissionContext context)
        {
            context.Result = ShowPrompt(context);
        }

        private Uri GetErroredAuthorizeUri(string originUrl, HashSet<string> requiredPermissions)
        {
            if (requiredPermissions == null)
            {
                throw new ArgumentNullException("requiredPermissions");
            }

            string requiredPermissionString = String.Join(",", requiredPermissions);
            UriBuilder authorizationUrlBuilder = new UriBuilder(new Uri(_config.AppUrl));
            authorizationUrlBuilder.Path += _config.AuthorizationRedirectPath.Substring(1);
            authorizationUrlBuilder.Query = String.Format(CultureInfo.InvariantCulture,
                "originUrl={0}&permissions={1}",
                HttpUtility.UrlEncode(originUrl),
                HttpUtility.UrlEncode(requiredPermissionString));

            return authorizationUrlBuilder.Uri;
        }

        private Uri GetCannotCreateCookiesUri()
        {
            UriBuilder noCookiesUrlBuilder = new UriBuilder(new Uri(_config.AppUrl));
            noCookiesUrlBuilder.Path += _config.CannotCreateCookieRedirectPath.Substring(1);

            return noCookiesUrlBuilder.Uri;
        }

        private string GetRedirectUrl(HttpRequestBase request)
        {
            NameValueCollection queryNameValuePair = HttpUtility.ParseQueryString(request.Url.Query);
            return GetRedirectUrl(request, queryNameValuePair);
        }

        private string GetRedirectUrl(HttpRequestBase request, NameValueCollection queryNameValuePair)
        {
            // Don't propagate query strings added by Facebook OAuth Dialog
            queryNameValuePair.Remove("code");
            queryNameValuePair.Remove("error");
            queryNameValuePair.Remove("error_reason");
            queryNameValuePair.Remove("error_description");

            string redirectUrl = String.Format(
                CultureInfo.InvariantCulture,
                "{0}/{1}",
                _config.AppUrl.TrimEnd('/'),
                request.AppRelativeCurrentExecutionFilePath.TrimStart('~', '/'));

            string query = queryNameValuePair.ToString();
            if (!String.IsNullOrEmpty(query))
            {
                redirectUrl += "?" + query;
            }

            return redirectUrl;
        }

        private void PromptDefaultPermissions(PermissionContext permissionContext, string redirectUrl)
        {
            FacebookClient client = permissionContext.FacebookContext.Client;
            // Cannot obtain user information from signed_request, redirect to Facebook OAuth dialog.
            Uri navigationUrl = client.GetLoginUrl(redirectUrl,
                                                   _config.AppId,
                                                   permissions: null);

            permissionContext.FilterContext.Result = CreateRedirectResult(navigationUrl);
        }

        private void PromptMissingPermissions(PermissionContext permissionContext, string redirectUrl)
        {
            AuthorizationContext filterContext = permissionContext.FilterContext;
            HashSet<string> requiredPermissions = permissionContext.RequiredPermissions;

            // If there were no errors it means that we will be prompted with a permission prompt.
            // Therefore, invoke the permission prompt hooks and navigate to the prompt.

            IEnumerable<string> declinedPermissions = permissionContext.DeclinedPermissions;
            IEnumerable<string> skippedPermissions = permissionContext.SkippedPermissions;
            IEnumerable<string> missingPermissions = permissionContext.MissingPermissions;

            // Declined permissions and skipped permissions can persist through multiple pages.  So we need to cross check
            // them against the current pages permissions, this will determine if we should invoke the denied permission hook.
            bool deniedPermissions = missingPermissions.Where(
                permission => declinedPermissions.Contains(permission) ||
                              skippedPermissions.Contains(permission)).Any();

            permissionContext.RedirectUrl = redirectUrl;

            // See if our persisted permissions cookie doesn't exist and if we've had missing permissions before.
            // Essentially this checks to see if we've tried to persist permissions before and were unsuccessful due to an
            // inability to create cookies.
            if (!PermissionHelper.RequestedPermissionsCookieExists(filterContext.HttpContext.Request) &&
                filterContext.HttpContext.Request.QueryString.Get(MissingPermissionsQueryName) != null)
            {
                OnCannotCreateCookies(permissionContext);
            }
            else
            {
                // The DeniedPermissionPromptHook will only be invoked if we detect there are denied permissions.
                // It is attempted instead of the permission hook to allow app creators to handle situations when a user
                // skip's or revokes previously prompted permissions. Ex: redirect to a different page.
                if (deniedPermissions)
                {
                    OnDeniedPermissionPrompt(permissionContext);
                }
                else
                {
                    OnPermissionPrompt(permissionContext);
                }

                // We persist the requested permissions in a cookie to know if a permission was denied in any way.
                // The persisted data allows us to detect skipping of permissions.
                PermissionHelper.PersistRequestedPermissions(filterContext, requiredPermissions);
            }

            filterContext.Result = permissionContext.Result;
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Client/FacebookClientExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Threading.Tasks;
using Facebook;

namespace Microsoft.AspNet.Facebook.Client
{
    /// <summary>
    /// Extension methods for <see cref="FacebookClient"/>.
    /// </summary>
    public static class FacebookClientExtensions
    {
        private const string PermissionsEndPoint = "me/permissions";

        /// <summary>
        /// Gets the Facebook object located at a given path.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <param name="objectPath">The object path.</param>
        /// <returns>A Facebook object.</returns>
        public static Task<object> GetFacebookObjectAsync(this FacebookClient client, string objectPath)
        {
            return GetFacebookObjectAsync<object>(client, objectPath);
        }

        /// <summary>
        /// Gets the Facebook object located at a given path.
        /// </summary>
        /// <typeparam name="TFacebookObject">The type of the Facebook object.</typeparam>
        /// <param name="client">The client.</param>
        /// <param name="objectPath">The object path.</param>
        /// <returns>A Facebook object.</returns>
        public static Task<TFacebookObject> GetFacebookObjectAsync<TFacebookObject>(this FacebookClient client, string objectPath) where TFacebookObject : class
        {
            if (client == null)
            {
                throw new ArgumentNullException("client");
            }
            if (objectPath == null)
            {
                throw new ArgumentNullException("objectPath");
            }

            string path = objectPath + FacebookQueryHelper.GetFields(typeof(TFacebookObject));
            return client.GetTaskAsync<TFacebookObject>(path);
        }

        /// <summary>
        /// Gets the current user information.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <returns>The current user.</returns>
        public static Task<object> GetCurrentUserAsync(this FacebookClient client)
        {
            return GetCurrentUserAsync<object>(client);
        }

        /// <summary>
        /// Gets the current user information.
        /// </summary>
        /// <typeparam name="TUser">The type of the user.</typeparam>
        /// <param name="client">The client.</param>
        /// <returns>The current user.</returns>
        public static Task<TUser> GetCurrentUserAsync<TUser>(this FacebookClient client) where TUser : class
        {
            return GetFacebookObjectAsync<TUser>(client, "me");
        }

        /// <summary>
        /// Gets the current user friends information.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <returns>A collection of friends.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Using tasks")]
        public static Task<IList<object>> GetCurrentUserFriendsAsync(this FacebookClient client)
        {
            return GetCurrentUserFriendsAsync<object>(client);
        }

        /// <summary>
        /// Gets the current user friends information.
        /// </summary>
        /// <typeparam name="TUserFriend">The type of the user friend.</typeparam>
        /// <param name="client">The client.</param>
        /// <returns>A collection of friends.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Using tasks")]
        public static async Task<IList<TUserFriend>> GetCurrentUserFriendsAsync<TUserFriend>(this FacebookClient client) where TUserFriend : class
        {
            FacebookGroupConnection<TUserFriend> friends = await GetFacebookObjectAsync<FacebookGroupConnection<TUserFriend>>(client, "me/friends");
            return friends != null ?
                friends.Data :
                new TUserFriend[0];
        }

        /// <summary>
        /// Gets the permissions granted by the current user.
        /// </summary>
        /// <param name="client">The client.</param>
        /// <returns>A collection of permissions.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Using tasks")]
        public static async Task<IList<string>> GetCurrentUserPermissionsAsync(this FacebookClient client)
        {
            FacebookGroupConnection<IDictionary<string, string>> permissionResults = 
                await client.GetTaskAsync<FacebookGroupConnection<IDictionary<string, string>>>(PermissionsEndPoint);
            PermissionsStatus permissionsStatus = new PermissionsStatus(permissionResults.Data);

            return PermissionHelper.GetGrantedPermissions(permissionsStatus).ToList();
        }

        /// <summary>
        /// Gets the current user statuses.
        /// </summary>
        /// <typeparam name="TStatus">The type of the status.</typeparam>
        /// <param name="client">The client.</param>
        /// <returns>A collection of statuses.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Using tasks")]
        public static async Task<IList<TStatus>> GetCurrentUserStatusesAsync<TStatus>(this FacebookClient client) where TStatus : class
        {
            FacebookGroupConnection<TStatus> statuses = await GetFacebookObjectAsync<FacebookGroupConnection<TStatus>>(client, "me/statuses");
            return statuses != null ?
                statuses.Data :
                new TStatus[0];
        }

        /// <summary>
        /// Gets the current user photos.
        /// </summary>
        /// <typeparam name="TPhotos">The type of the photo.</typeparam>
        /// <param name="client">The client.</param>
        /// <returns>A collection of user photos.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Using tasks")]
        public static async Task<IList<TPhotos>> GetCurrentUserPhotosAsync<TPhotos>(this FacebookClient client) where TPhotos : class
        {
            FacebookGroupConnection<TPhotos> photos = await GetFacebookObjectAsync<FacebookGroupConnection<TPhotos>>(client, "me/photos");
            return photos != null ?
                photos.Data :
                new TPhotos[0];
        }

        internal static Uri GetLoginUrl(this FacebookClient client, string redirectUrl, string appId, string permissions)
        {
            if (String.IsNullOrEmpty(redirectUrl))
            {
                throw new ArgumentException(Resources.ArgumentCannotBeNullOrEmpty, "redirectUrl");
            }
            if (String.IsNullOrEmpty(appId))
            {
                throw new ArgumentException(Resources.ArgumentCannotBeNullOrEmpty, "appId");
            }

            Dictionary<string, object> loginUrlParameters = new Dictionary<string, object>();
            loginUrlParameters["redirect_uri"] = redirectUrl;
            loginUrlParameters["client_id"] = appId;
            if (!String.IsNullOrEmpty(permissions))
            {
                loginUrlParameters["scope"] = permissions;
            }

            return client.GetLoginUrl(loginUrlParameters);
        }

        internal static IList<IDictionary<string, string>> GetCurrentUserPermissionsStatus(this FacebookClient client)
        {
            FacebookGroupConnection<IDictionary<string, string>> permissionResults = 
                client.Get<FacebookGroupConnection<IDictionary<string, string>>>(PermissionsEndPoint);

            return permissionResults.Data;
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Client/FacebookQueryHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
using System.Text;
using Newtonsoft.Json;

namespace Microsoft.AspNet.Facebook.Client
{
    /// <summary>
    /// Helper for constructing Facebook Graph API queries.
    /// </summary>
    public static class FacebookQueryHelper
    {
        /// <summary>
        /// Gets the appropriate "fields" query parameter for the Facebook Graph API based on the public properties of the model type.
        /// </summary>
        /// <param name="modelType">Type of the model.</param>
        /// <returns>The "fields" query parameter.</returns>
        public static string GetFields(Type modelType)
        {
            IList<string> fieldNames = GetFieldNames(modelType, typesVisited: new HashSet<Type>());
            if (fieldNames.Count > 0 && modelType != typeof(object))
            {
                return "?fields=" + String.Join(",", fieldNames);
            }

            return String.Empty;
        }

        private static string GetConnectionFields(Type modelType, HashSet<Type> typesVisited)
        {
            if (typesVisited.Contains(modelType))
            {
                throw new InvalidOperationException(Resources.CircularReferenceNotSupported);
            }

            IList<string> fieldNames = GetFieldNames(modelType, typesVisited);
            if (fieldNames.Count > 0 && modelType != typeof(object))
            {
                return ".fields(" + String.Join(",", fieldNames) + ")";
            }

            return String.Empty;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Lowercase is intended for field names.")]
        private static IList<string> GetFieldNames(Type modelType, HashSet<Type> typesVisited)
        {
            Type connectionType;
            if (TryUnwrapConnectionType(modelType, out connectionType))
            {
                modelType = connectionType;
            }

            PropertyInfo[] properties = modelType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            List<string> facebookFields = new List<string>();
            foreach (PropertyInfo property in properties)
            {
                string propertyName = property.Name;
                AttributeCollection attributes =
                   TypeDescriptor.GetProperties(modelType)[propertyName].Attributes;

                JsonIgnoreAttribute jsonIgnoreAttribute =
                   (JsonIgnoreAttribute)attributes[typeof(JsonIgnoreAttribute)];

                if (jsonIgnoreAttribute == null)
                {
                    JsonPropertyAttribute jsonPropertyAttribute =
                        (JsonPropertyAttribute)attributes[typeof(JsonPropertyAttribute)];
                    FacebookFieldModifierAttribute modifierAttribute =
                        (FacebookFieldModifierAttribute)attributes[typeof(FacebookFieldModifierAttribute)];

                    StringBuilder fieldName = new StringBuilder(
                        jsonPropertyAttribute != null ?
                            jsonPropertyAttribute.PropertyName :
                            propertyName);

                    if (modifierAttribute != null)
                    {
                        fieldName.AppendFormat(CultureInfo.InvariantCulture, ".{0}", modifierAttribute.FieldModifier);
                    }

                    Type propertyType = property.PropertyType;
                    if (TryUnwrapConnectionType(propertyType, out connectionType))
                    {
                        typesVisited.Add(property.DeclaringType);
                        fieldName.Append(GetConnectionFields(connectionType, typesVisited));
                    }

                    facebookFields.Add(fieldName.ToString().ToLowerInvariant());
                }
            }

            return facebookFields;
        }

        private static bool TryUnwrapConnectionType(Type modelType, out Type connectionType)
        {
            if (modelType.IsGenericType)
            {
                Type genericTypeDefinition = modelType.GetGenericTypeDefinition();
                if (genericTypeDefinition == typeof(FacebookConnection<>) ||
                    genericTypeDefinition == typeof(FacebookGroupConnection<>))
                {
                    Type genericArgumentType = modelType.GetGenericArguments()[0];
                    connectionType = genericArgumentType;
                    return true;
                }
            }
            connectionType = null;
            return false;
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Client/FacebookRequestHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web;

namespace Microsoft.AspNet.Facebook.Client
{
    internal static class FacebookRequestHelpers
    {
        private const string SignedRequestKey = "signed_request";
        private const string ParsedSignedRequestKey = "parsed_signed_request";

        public static dynamic GetSignedRequest(HttpContextBase context, Func<string, object> parseSignedRequest)
        {
            if (context.Items.Contains(ParsedSignedRequestKey))
            {
                return context.Items[ParsedSignedRequestKey];
            }

            string rawSignedRequest = context.Request.Form[SignedRequestKey] ?? context.Request.QueryString[SignedRequestKey];
            object signedRequest = null;
            if (!String.IsNullOrEmpty(rawSignedRequest))
            {
                signedRequest = parseSignedRequest(rawSignedRequest);
                context.Items.Add(ParsedSignedRequestKey, signedRequest);
            }
            return signedRequest;
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookAppSettingKeys.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook
{
    internal static class FacebookAppSettingKeys
    {
        public static readonly string DisableAuthenticationModule = "Facebook:DisableAuthenticationModule";
        public static readonly string AppId = "Facebook:AppId";
        public static readonly string AppSecret = "Facebook:AppSecret";
        public static readonly string AppNamespace = "Facebook:AppNamespace";
        public static readonly string AppUrl = "Facebook:AppUrl";
        public static readonly string AuthorizationRedirectPath = "Facebook:AuthorizationRedirectPath";
        public static readonly string CannotCreateCookiesRedirectPath = "Facebook:CannotCreateCookiesRedirectPath";
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookAuthenticationModule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Security.Claims;
using System.Threading;
using System.Web;
using Facebook;
using Microsoft.AspNet.Facebook.Client;

namespace Microsoft.AspNet.Facebook
{
    internal sealed class FacebookAuthenticationModule : IHttpModule
    {
        public void Init(HttpApplication context)
        {
            context.AuthenticateRequest += (sender, e) =>
            {
                HttpContext httpContext = ((HttpApplication)sender).Context;

                dynamic signedRequest = FacebookRequestHelpers.GetSignedRequest(
                    new HttpContextWrapper(httpContext),
                    rawSignedRequest =>
                    {
                        FacebookConfiguration config = GlobalFacebookConfiguration.Configuration;
                        FacebookClient client = config.ClientProvider.CreateClient();
                        return client.ParseSignedRequest(rawSignedRequest);
                    });

                if (signedRequest != null)
                {
                    string userId = signedRequest.user_id;
                    if (!String.IsNullOrEmpty(userId))
                    {
                        ClaimsPrincipal principal = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.NameIdentifier, userId) }));
                        Thread.CurrentPrincipal = principal;
                        httpContext.User = principal;
                    }
                }
            };
        }

        public void Dispose()
        {
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookAuthorizeAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Restricts the access to requests with valid Facebook signed request parameter and to users that have the required permissions.
    /// This attribute can be declared on a controller, an action or both.
    /// </summary>
    [SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification = "The attribute argument is already defined as a ReadOnlyCollection.")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class FacebookAuthorizeAttribute : Attribute
    {
        private ReadOnlyCollection<string> _permissions;

        /// <summary>
        /// Initializes a new instance of the <see cref="FacebookAuthorizeAttribute" /> class without requiring permissions.
        /// </summary>
        public FacebookAuthorizeAttribute()
            : this(new string[0])
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FacebookAuthorizeAttribute" /> class requiring permissions.
        /// </summary>
        /// <param name="permissions">The permissions.</param>
        public FacebookAuthorizeAttribute(params string[] permissions)
        {
            if (permissions == null)
            {
                throw new ArgumentNullException("permissions");
            }

            foreach (string permission in permissions)
            {
                if (permission.Contains(','))
                {
                    throw new ArgumentException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            Resources.PermissionStringShouldNotContainComma,
                            permission),
                            "permissions");
                }
            }

            _permissions = new ReadOnlyCollection<string>(permissions);
        }

        /// <summary>
        /// Gets the required permissions.
        /// </summary>
        public ReadOnlyCollection<string> Permissions
        {
            get
            {
                return _permissions;
            }
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Concurrent;
using System.Configuration;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using Microsoft.AspNet.Facebook.Providers;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Configuration for the Facebook application.
    /// </summary>
    public class FacebookConfiguration
    {
        private const string FacebookAppBaseUrl = "https://apps.facebook.com";
        private readonly ConcurrentDictionary<object, object> _properties = new ConcurrentDictionary<object, object>();
        private string _appUrl;
        private string _authorizationRedirectPath;
        private string _cannotCreateCookieRedirectPath;

        /// <summary>
        /// Gets or sets the App ID.
        /// </summary>
        public string AppId { get; set; }

        /// <summary>
        /// Gets or sets the App Secret.
        /// </summary>
        public string AppSecret { get; set; }

        /// <summary>
        /// Gets or sets the App Namespace.
        /// </summary>
        public string AppNamespace { get; set; }

        /// <summary>
        /// Gets or sets the URL path that the <see cref="Microsoft.AspNet.Facebook.Authorization.FacebookAuthorizeFilter"/> will 
        /// redirect to when the user did not grant the required permissions. If value is not set it will result in a redirection
        /// to Facebook's home page.
        /// </summary>
        public string AuthorizationRedirectPath
        {
            get
            {
                return _authorizationRedirectPath;
            }
            set
            {
                EnsureRedirectPath(value, "AuthorizationRedirectPath");
                _authorizationRedirectPath = value;
            }
        }

        /// <summary>
        /// Gets or sets the URL path that the <see cref="Microsoft.AspNet.Facebook.Authorization.FacebookAuthorizeFilter"/> will 
        /// redirect to when the we determine that we are unable to create cookies. If value is not set it will result in a 
        /// redirection to Facebook's home page.
        /// </summary>
        public string CannotCreateCookieRedirectPath
        {
            get
            {
                return _cannotCreateCookieRedirectPath;
            }
            set
            {
                EnsureRedirectPath(value, "CannotCreateCookieRedirectPath");

                _cannotCreateCookieRedirectPath = value;
            }
        }

        /// <summary>
        /// Gets or sets the absolute URL for the Facebook App.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "We prefer strings because this is read from appSettings")]
        public string AppUrl
        {
            get
            {
                if (String.IsNullOrEmpty(_appUrl))
                {
                    _appUrl = GetAppUrl();
                }
                return _appUrl;
            }
            set
            {
                _appUrl = value;
            }
        }

        /// <summary>
        /// Gets or sets the <see cref="IFacebookClientProvider"/>.
        /// </summary>
        public IFacebookClientProvider ClientProvider { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="IFacebookPermissionService"/>.
        /// </summary>
        public IFacebookPermissionService PermissionService { get; set; }

        /// <summary>
        /// Gets the additional properties associated with this instance.
        /// </summary>
        public ConcurrentDictionary<object, object> Properties
        {
            get { return _properties; }
        }

        /// <summary>
        /// Loads the configuration properties from app settings.
        /// </summary>
        /// <remarks>
        /// It will map the following keys from appSettings to the corresponding properties:
        /// Facebook:AppId = AppId,
        /// Facebook:AppSecret = AppSecret,
        /// Facebook:AppNamespace = AppNamespace,
        /// Facebook:AppUrl = AppUrl,
        /// Facebook:AuthorizationRedirectPath = AuthorizationRedirectPath.
        /// </remarks>
        public virtual void LoadFromAppSettings()
        {
            AppId = ConfigurationManager.AppSettings[FacebookAppSettingKeys.AppId];
            if (String.IsNullOrEmpty(AppId))
            {
                throw new InvalidOperationException(String.Format(
                    CultureInfo.CurrentCulture,
                    Resources.AppSettingIsRequired,
                    FacebookAppSettingKeys.AppId));
            }

            AppSecret = ConfigurationManager.AppSettings[FacebookAppSettingKeys.AppSecret];
            if (String.IsNullOrEmpty(AppSecret))
            {
                throw new InvalidOperationException(String.Format(
                    CultureInfo.CurrentCulture,
                    Resources.AppSettingIsRequired,
                    FacebookAppSettingKeys.AppSecret));
            }

            AppNamespace = ConfigurationManager.AppSettings[FacebookAppSettingKeys.AppNamespace];
            AppUrl = ConfigurationManager.AppSettings[FacebookAppSettingKeys.AppUrl];
            AuthorizationRedirectPath = ConfigurationManager.AppSettings[FacebookAppSettingKeys.AuthorizationRedirectPath];
            CannotCreateCookieRedirectPath = 
                ConfigurationManager.AppSettings[FacebookAppSettingKeys.CannotCreateCookiesRedirectPath];
        }

        private static void EnsureRedirectPath(string value, string redirectParameterName)
        {
            // Check for '~/' prefix while allowing null or empty value to be set.
            if (!String.IsNullOrEmpty(value) && !value.StartsWith("~/", StringComparison.Ordinal))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        Resources.InvalidRedirectPath,
                        redirectParameterName),
                    "value");
            }
        }

        private string GetAppUrl()
        {
            return String.Format(
                CultureInfo.InvariantCulture,
                "{0}/{1}",
                FacebookAppBaseUrl,
                String.IsNullOrEmpty(AppNamespace) ? AppId : AppNamespace);
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookConnection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Model for the Facebook object connection.
    /// </summary>
    /// <typeparam name="T">Type of the connection.</typeparam>
    public class FacebookConnection<T>
    {
        /// <summary>
        /// Gets or sets the connection data.
        /// </summary>
        public T Data { get; set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Facebook;
using Microsoft.AspNet.Facebook.ModelBinders;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Provides access to Facebook-specific information.
    /// </summary>
    [FacebookContextBinderAttribute]
    public class FacebookContext
    {
        /// <summary>
        /// Gets or sets the parsed signed request.
        /// </summary>
        public dynamic SignedRequest { get; set; }

        /// <summary>
        /// Gets or sets the access token.
        /// </summary>
        public string AccessToken { get; set; }

        /// <summary>
        /// Gets or sets the user ID.
        /// </summary>
        public string UserId { get; set; }

        /// <summary>
        /// Gets or sets the Facebook client.
        /// </summary>
        public FacebookClient Client { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="FacebookConfiguration"/>.
        /// </summary>
        public FacebookConfiguration Configuration { get; set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookFieldModifierAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Allows adding field modifiers when querying Facebook Graph API.
    /// </summary>
    [AttributeUsage(AttributeTargets.Property, Inherited = true, AllowMultiple = false)]
    public sealed class FacebookFieldModifierAttribute : Attribute
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="FacebookFieldModifierAttribute" /> class.
        /// </summary>
        /// <param name="fieldModifier">The field modifier.</param>
        public FacebookFieldModifierAttribute(string fieldModifier)
        {
            FieldModifier = fieldModifier;
        }

        /// <summary>
        /// Gets the field modifier.
        /// </summary>
        public string FieldModifier { get; private set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookGroupConnection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Model for the Facebook object connection when it contains a collection.
    /// </summary>
    /// <typeparam name="T">Type of the collection element.</typeparam>
    public class FacebookGroupConnection<T>
    {
        /// <summary>
        /// Gets or sets the connection data.
        /// </summary>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "Needed for JSON deserialization")]
        public IList<T> Data { get; set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookHtmlHelperExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web;
using System.Web.Mvc;
using System.Web.Mvc.Html;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Facebook-related extension methods for <see cref="HtmlHelper"/>.
    /// </summary>
    public static class FacebookHtmlHelperExtensions
    {
        /// <summary>
        /// Returns the signed_request in a hidden input element.
        /// </summary>
        /// <param name="htmlHelper">The <see cref="HtmlHelper"/>.</param>
        /// <returns>The signed_request in a hidden input element.</returns>
        public static IHtmlString FacebookSignedRequest(this HtmlHelper htmlHelper)
        {
            string signedRequest = htmlHelper.ViewContext.HttpContext.Request.Params["signed_request"];
            if (!String.IsNullOrEmpty(signedRequest))
            {
                return htmlHelper.Hidden("signed_request", signedRequest);
            }
            return new HtmlString(String.Empty);
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/FacebookRedirectContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using Microsoft.AspNet.Facebook.ModelBinders;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Provides access to the data redirected from <see cref="Microsoft.AspNet.Facebook.Authorization.FacebookAuthorizeFilter"/>.
    /// </summary>
    [FacebookRedirectContextBinder]
    public class FacebookRedirectContext
    {
        /// <summary>
        /// Gets or sets the origin URL.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "We prefer strings because this is read from query strings")]
        public string OriginUrl { get; set; }

        /// <summary>
        /// Gets or sets the redirect URL.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "We prefer strings because this is read from query strings")]
        public string RedirectUrl { get; set; }

        /// <summary>
        /// Gets or sets the required permissions specified on <see cref="FacebookAuthorizeAttribute"/>.
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] RequiredPermissions { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="FacebookConfiguration"/>.
        /// </summary>
        public FacebookConfiguration Configuration { get; set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/GlobalFacebookConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Microsoft.AspNet.Facebook.Providers;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Provides a global <see cref="FacebookConfiguration"/> for ASP.NET applications.
    /// </summary>
    public static class GlobalFacebookConfiguration
    {
        private static readonly Lazy<FacebookConfiguration> _configuration = new Lazy<FacebookConfiguration>(
        () =>
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            config.PermissionService = new DefaultFacebookPermissionService(config);
            return config;
        });

        /// <summary>
        /// Gets the global <see cref="FacebookConfiguration"/>.
        /// </summary>
        public static FacebookConfiguration Configuration
        {
            get
            {
                return _configuration.Value;
            }
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "Microsoft.AspNet.Facebook.Models", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "Microsoft.AspNet.Facebook.ModelBinders", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "Microsoft.AspNet.Facebook.Realtime", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "Microsoft.AspNet.Facebook.Providers", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "Microsoft.AspNet.Facebook.Client", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "Microsoft.AspNet.Facebook.Authorization", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames",
    Justification = "Assembly is delay-signed")]

================================================
FILE: src/Microsoft.AspNet.Facebook/JavaScriptRedirectResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Web;
using System.Web.Mvc;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Represents an <see cref="ActionResult"/> that redirects to a permission prompt login via JavaScript.
    /// </summary>
    public class JavaScriptRedirectResult : ContentResult
    {
        internal Uri RedirectUrl { get; private set; }

        /// <summary>
        /// Creates a JavaScript based redirect <see cref="ActionResult"/>.
        /// </summary>
        /// <param name="redirectUrl">The url to redirect to.</param>
        public JavaScriptRedirectResult(Uri redirectUrl)
        {
            RedirectUrl = redirectUrl;

            ContentType = "text/html";
            Content = String.Format(
                CultureInfo.InvariantCulture,
                "<script>window.top.location = '{0}';</script>",
                HttpUtility.JavaScriptStringEncode(RedirectUrl.AbsoluteUri));
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/Microsoft.AspNet.Facebook.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{821A136C-7C6F-44C6-A9E6-C39B5BFB1483}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.AspNet.Facebook</RootNamespace>
    <AssemblyName>Microsoft.AspNet.Facebook</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETFACEBOOK</DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
    <DefineConstants>TRACE;DEBUG;CODE_ANALYSIS;ASPNETFACEBOOK</DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|AnyCPU'">
    <DefineConstants>TRACE;ASPNETFACEBOOK</DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'CodeAnalysis|AnyCPU'">
    <DefineConstants>TRACE;CODE_ANALYSIS;ASPNETFACEBOOK</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Facebook, Version=6.0.10.0, Culture=neutral, PublicKeyToken=58cb4f2111d1e6de, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\Facebook.6.4.2\lib\net45\Facebook.dll</HintPath>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Entity" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Web" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.XML" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Client\FacebookRequestHelper.cs" />
    <Compile Include="JavaScriptRedirectResult.cs" />
    <Compile Include="PermissionContext.cs" />
    <Compile Include="PermissionHelper.cs" />
    <Compile Include="FacebookAppSettingKeys.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="PermissionsStatus.cs" />
    <Compile Include="PermissionStatus.cs" />
    <Compile Include="FacebookAuthenticationModule.cs" />
    <Compile Include="FacebookHtmlHelperExtensions.cs" />
    <Compile Include="GlobalFacebookConfiguration.cs" />
    <Compile Include="ModelBinders\FacebookRedirectContextBinderAttribute.cs" />
    <Compile Include="FacebookAuthorizeAttribute.cs" />
    <Compile Include="FacebookFieldModifierAttribute.cs" />
    <Compile Include="ModelBinders\FacebookContextBinderAttribute.cs" />
    <Compile Include="Authorization\FacebookAuthorizeFilter.cs" />
    <Compile Include="Client\FacebookClientExtensions.cs" />
    <Compile Include="Client\FacebookQueryHelper.cs" />
    <Compile Include="Providers\IFacebookPermissionService.cs" />
    <Compile Include="Providers\DefaultFacebookPermissionService.cs" />
    <Compile Include="Realtime\FacebookRealtimeUpdateController.cs" />
    <Compile Include="Models\ChangeNotification.cs" />
    <Compile Include="Models\ChangeEntry.cs" />
    <Compile Include="FacebookConnection.cs" />
    <Compile Include="FacebookGroupConnection.cs" />
    <Compile Include="ModelBinders\FacebookRedirectContextModelBinder.cs" />
    <Compile Include="FacebookRedirectContext.cs" />
    <Compile Include="FacebookContext.cs" />
    <Compile Include="ModelBinders\FacebookContextModelBinder.cs" />
    <Compile Include="Models\SubscriptionVerification.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Providers\DefaultFacebookClientProvider.cs" />
    <Compile Include="FacebookConfiguration.cs" />
    <Compile Include="Providers\IFacebookClientProvider.cs" />
    <Compile Include="Resources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="ShowPromptResult.cs" />
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Resources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http.WebHost\System.Web.Http.WebHost.csproj">
      <Project>{a0187bc2-8325-4bb2-8697-7f955cf4173e}</Project>
      <Name>System.Web.Http.WebHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3d3ffd8a-624d-4e9b-954b-e1c105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8f18041b-9410-4c36-a9c5-067813df5f31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22babb60-8f02-4027-affc-acf069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939b11a-fe4e-4ba1-8ad6-d97741ee314f}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76efa9c5-8d7e-4fdf-b710-e20f8b6b00d2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: src/Microsoft.AspNet.Facebook/ModelBinders/FacebookContextBinderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.AspNet.Facebook.ModelBinders
{
    [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
    internal sealed class FacebookContextBinderAttribute : CustomModelBinderAttribute
    {
        public override IModelBinder GetBinder()
        {
            return new FacebookContextModelBinder(GlobalFacebookConfiguration.Configuration);
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/ModelBinders/FacebookContextModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Facebook;
using Microsoft.AspNet.Facebook.Client;

namespace Microsoft.AspNet.Facebook.ModelBinders
{
    /// <summary>
    /// Model binds an action method parameter to a <see cref="FacebookContext"/>.
    /// </summary>
    public class FacebookContextModelBinder : IModelBinder
    {
        private FacebookConfiguration _config;

        /// <summary>
        /// Initializes a new instance of the <see cref="FacebookContextModelBinder" /> class.
        /// </summary>
        /// <param name="config">The <see cref="FacebookConfiguration"/>.</param>
        public FacebookContextModelBinder(FacebookConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            _config = config;
        }

        /// <summary>
        /// Binds the model to a value by using the specified controller context and binding context.
        /// </summary>
        /// <param name="controllerContext">The controller context.</param>
        /// <param name="bindingContext">The binding context.</param>
        /// <returns>
        /// The bound value.
        /// </returns>
        public virtual object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            FacebookClient client = _config.ClientProvider.CreateClient();
            dynamic signedRequest = FacebookRequestHelpers.GetSignedRequest(
                controllerContext.HttpContext,
                rawSignedRequest =>
                {
                    return client.ParseSignedRequest(rawSignedRequest);
                });
            if (signedRequest != null)
            {
                string accessToken = signedRequest.oauth_token;
                string userId = signedRequest.user_id;
                client.AccessToken = accessToken;
                return new FacebookContext
                {
                    Client = client,
                    SignedRequest = signedRequest,
                    AccessToken = accessToken,
                    UserId = userId,
                    Configuration = _config
                };
            }
            else
            {
                bindingContext.ModelState.AddModelError(bindingContext.ModelName, Resources.MissingSignedRequest);
            }

            return null;
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/ModelBinders/FacebookRedirectContextBinderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.AspNet.Facebook.ModelBinders
{
    [AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
    internal sealed class FacebookRedirectContextBinderAttribute : CustomModelBinderAttribute
    {
        public override IModelBinder GetBinder()
        {
            return new FacebookRedirectContextModelBinder(GlobalFacebookConfiguration.Configuration);
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/ModelBinders/FacebookRedirectContextModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Web;
using System.Web.Mvc;
using Facebook;
using Microsoft.AspNet.Facebook.Client;

namespace Microsoft.AspNet.Facebook.ModelBinders
{
    /// <summary>
    /// Model binds an action method parameter to a <see cref="FacebookRedirectContext"/>.
    /// </summary>
    public class FacebookRedirectContextModelBinder : IModelBinder
    {
        private FacebookConfiguration _config;

        /// <summary>
        /// Initializes a new instance of the <see cref="FacebookRedirectContextModelBinder" /> class.
        /// </summary>
        /// <param name="config">The <see cref="FacebookConfiguration"/>.</param>
        public FacebookRedirectContextModelBinder(FacebookConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            _config = config;
        }

        /// <summary>
        /// Binds the model to a value by using the specified controller context and binding context.
        /// </summary>
        /// <param name="controllerContext">The controller context.</param>
        /// <param name="bindingContext">The binding context.</param>
        /// <returns>
        /// The bound value.
        /// </returns>
        public virtual object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            HttpRequestBase request = controllerContext.HttpContext.Request;
            string originUrl = request.QueryString["originUrl"];
            string permissions = request.QueryString["permissions"];

            if (!String.IsNullOrEmpty(originUrl))
            {
                if (!originUrl.StartsWith(_config.AppUrl, StringComparison.OrdinalIgnoreCase))
                {
                    bindingContext.ModelState.AddModelError(bindingContext.ModelName,
                        String.Format(CultureInfo.CurrentCulture, Resources.UrlCannotBeExternal, "originUrl", _config.AppUrl));
                }
            }
            else
            {
                bindingContext.ModelState.AddModelError(bindingContext.ModelName,
                    String.Format(CultureInfo.CurrentCulture, Resources.ParameterIsRequired, "originUrl"));
            }

            string redirectUrl = null;
            string[] requiredPermissions = permissions != null ? permissions.Split(',') : new string[0];
            if (bindingContext.ModelState.IsValid)
            {
                FacebookClient client = _config.ClientProvider.CreateClient();
                // Don't want to redirect to a permissioned URL, the action authorize filters take care of that.
                redirectUrl = client.GetLoginUrl(originUrl, _config.AppId, String.Empty).AbsoluteUri;
            }

            return new FacebookRedirectContext
            {
                OriginUrl = originUrl,
                RequiredPermissions = requiredPermissions,
                RedirectUrl = redirectUrl,
                Configuration = _config
            };
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Models/ChangeEntry.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Newtonsoft.Json;

namespace Microsoft.AspNet.Facebook.Models
{
    /// <summary>
    /// Change entry from Facebook as part of Realtime Updates.
    /// </summary>
    public class ChangeEntry
    {
        /// <summary>
        /// Gets or sets the user id.
        /// </summary>
        [JsonProperty("UId")]
        public long UserId { get; set; }

        /// <summary>
        /// Gets or sets the changed fields.
        /// </summary>
        [JsonProperty("Changed_Fields")]
        public IEnumerable<string> ChangedFields { get; set; }

        /// <summary>
        /// Gets or sets the time.
        /// </summary>
        public long Time { get; set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Models/ChangeNotification.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace Microsoft.AspNet.Facebook.Models
{
    /// <summary>
    /// Notification from Facebook as part of Realtime Updates.
    /// </summary>
    public class ChangeNotification
    {
        /// <summary>
        /// Gets or sets the object that has been updated.
        /// </summary>
        /// <value>
        /// The Facebook object.
        /// </value>
        public string Object { get; set; }

        /// <summary>
        /// Gets or sets the change entry.
        /// </summary>
        /// <value>
        /// The change entry.
        /// </value>
        public IEnumerable<ChangeEntry> Entry { get; set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Models/SubscriptionVerification.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Http;

namespace Microsoft.AspNet.Facebook.Models
{
    /// <summary>
    /// Subscription verification data from Facebook as part of Realtime Updates.
    /// </summary>
    [FromUri(Name = "hub")]
    public class SubscriptionVerification
    {
        /// <summary>
        /// Gets or sets the mode.
        /// </summary>
        /// <value>
        /// The mode.
        /// </value>
        public string Mode { get; set; }

        /// <summary>
        /// Gets or sets the verify_token.
        /// </summary>
        /// <value>
        /// The verify_token.
        /// </value>
        [SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Justification = "This is a shipped API")]
        public string Verify_Token { get; set; }

        /// <summary>
        /// Gets or sets the challenge string.
        /// </summary>
        /// <value>
        /// The challenge string.
        /// </value>
        public string Challenge { get; set; }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/PermissionContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Provides access to permission information associated with a user.
    /// </summary>
    public class PermissionContext
    {
        /// <summary>
        /// Permissions that were previously requested for but not granted for the lifetime of this application. This can happen
        /// by a user revoking, skipping or choosing not to allow permissions in the Facebook login dialog.
        /// </summary>
        /// <remarks>
        /// This should only ever be "set" or modified within tests.
        /// </remarks>
        public IEnumerable<string> DeclinedPermissions { get; set; }

        /// <summary>
        /// Provides access to Facebook-specific information.
        /// </summary>
        /// <remarks>
        /// This should only ever be "set" or modified within tests.
        /// </remarks>
        public FacebookContext FacebookContext { get; set; }

        /// <summary>
        /// Provides access to filter information.
        /// </summary>
        /// <remarks>
        /// This should only ever be "set" or modified within tests.
        /// </remarks>
        public AuthorizationContext FilterContext { get; set; }

        /// <summary>
        /// The entire list of missing permissions for the current page, including <see cref="DeclinedPermissions"/> and 
        /// <see cref="SkippedPermissions"/>.
        /// </summary>
        /// <remarks>
        /// This should only ever be "set" or modified within tests.
        /// </remarks>
        public IEnumerable<string> MissingPermissions { get; set; }

        /// <summary>
        /// The entire list of requested permissions for the current page. Includes permissions that were already prompted for.
        /// </summary>
        /// <remarks>
        /// This should only ever be "set" or modified within tests.
        /// </remarks>
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", 
            Justification = "This is public and can be set in tests.")]
        public HashSet<string> RequiredPermissions { get; set; }

        /// <summary>
        /// The <see cref="ActionResult" /> that should be used to control the login flow.  If value is null then we will continue
        /// onto the action that is intended to be invoked.  Non-null values short-circuit the action.
        /// </summary>
        public ActionResult Result { get; set; }

        /// <summary>
        /// Permissions that were previously requested for but skipped for the current page. This can happen from a user hitting
        /// the "skip" button when requesting permissions.
        /// </summary>
        /// <remarks>Skips are tracked via cookies. If cookies are cleared skips will not be detected.</remarks>
        /// <remarks>
        /// This should only ever be "set" or modified within tests.
        /// </remarks>
        public IEnumerable<string> SkippedPermissions { get; set; }

        internal string RedirectUrl { get; set; }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/PermissionHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;

namespace Microsoft.AspNet.Facebook
{
    internal static class PermissionHelper
    {
        // This cookie name is used to track permissions we've requested of the user to determine skipped permissions.
        public const string RequestedPermissionCookieName = "_fb_requested_permissions";

        public static IEnumerable<string> GetDeclinedPermissions(PermissionsStatus permissionsStatus)
        {
            return GetPermissionsWithStatus(permissionsStatus, PermissionStatus.Declined);
        }

        public static IEnumerable<string> GetGrantedPermissions(PermissionsStatus permissionsStatus)
        {
            return GetPermissionsWithStatus(permissionsStatus, PermissionStatus.Granted);
        }

        public static IEnumerable<string> GetPreviouslyRequestedPermissions(HttpRequestBase request)
        {
            HttpCookie existingCookie = request.Cookies.Get(RequestedPermissionCookieName);

            // If there's no cookie or an empty cookie then don't return a 1 element enumerable, return an empty one.
            if (existingCookie == null || String.IsNullOrEmpty(existingCookie.Value))
            {
                return Enumerable.Empty<string>();
            }

            return existingCookie.Value.Split(',');
        }

        public static HashSet<string> GetRequiredPermissions(IEnumerable<FacebookAuthorizeAttribute> facebookAuthorizeAttributes)
        {
            var requiredPermissions = new HashSet<string>(
                facebookAuthorizeAttributes.SelectMany(attribute => attribute.Permissions),
                StringComparer.Ordinal);

            return requiredPermissions;
        }

        public static IEnumerable<string> GetSkippedPermissions(HttpRequestBase request,
                                                                IEnumerable<string> missingPermissions,
                                                                IEnumerable<string> declinedPermissions)
        {
            IEnumerable<string> previouslyRequestedPermissions = PermissionHelper.GetPreviouslyRequestedPermissions(request);
            IEnumerable<string> previouslyRequestedMissingPermissions = missingPermissions.Where((permission) =>
                previouslyRequestedPermissions.Contains(permission));
            IEnumerable<string> skippedPermissions = previouslyRequestedMissingPermissions.Except(declinedPermissions);

            return skippedPermissions;
        }

        public static void PersistRequestedPermissions(AuthorizationContext context, IEnumerable<string> requestedPermissions)
        {
            HttpRequestBase request = context.HttpContext.Request;
            IEnumerable<string> existingRequestedPermissions = GetPreviouslyRequestedPermissions(request);
            IEnumerable<string> combinedRequestedPermissions = existingRequestedPermissions.Concat(requestedPermissions);

            // No need for duplicates
            combinedRequestedPermissions = combinedRequestedPermissions.Distinct(StringComparer.Ordinal);

            string newCookieValue = String.Join(",", combinedRequestedPermissions);

            HttpCookieCollection responseCookies = context.HttpContext.Response.Cookies;
            HttpCookie cookie = new HttpCookie(RequestedPermissionCookieName, newCookieValue);
            responseCookies.Add(cookie);
        }

        public static bool RequestedPermissionsCookieExists(HttpRequestBase request)
        {
            return request.Cookies.Get(RequestedPermissionCookieName) != null;
        }

        private static IEnumerable<string> GetPermissionsWithStatus(PermissionsStatus permissionsStatus, 
                                                                    PermissionStatus status)
        {
            return permissionsStatus.Status.Where(kvp => kvp.Value == status)
                                           .Select(kvp => kvp.Key);
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/PermissionStatus.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Describes the kind of permission for an entry in the <see cref="PermissionsStatus.Status"/> dictionary.
    /// </summary>
    public enum PermissionStatus
    {
        /// <summary>
        /// User granted permission.
        /// </summary>
        Granted,

        /// <summary>
        /// User declined permission.
        /// </summary>
        Declined,

        /// <summary>
        /// Unknown status of a permission.
        /// </summary>
        Unknown
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/PermissionsStatus.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Provides access to a users permissions status and the raw data returned from an API.
    /// </summary>
    public class PermissionsStatus
    {
        // Values representing permission statuses returned by the facebook graph API.
        private const string FacebookPermissionGranted = "granted";
        private const string FacebookPermissionDeclined = "declined";

        /// <summary>
        /// Constructs a more useable object than the provided api result.
        /// </summary>
        /// <param name="apiResult">The raw data returned by the queried API.</param>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This type is the raw type of data that Facebook returns to us.")]
        public PermissionsStatus(IList<IDictionary<string, string>> apiResult)
        {
            ApiResult = apiResult;
            Status = ConvertApiResult(apiResult);
        }

        /// <summary>
        /// A parsed, easier to use version of the <see cref="ApiResult"/>.
        /// </summary>
        public IDictionary<string, PermissionStatus> Status { get; private set; }

        /// <summary>
        /// The raw data returned by the queried API.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", 
            Justification = "This type is the raw type of data that Facebook returns to us.")]
        public IList<IDictionary<string, string>> ApiResult { get; private set; }

        /// <summary>
        /// Queries the <see cref="Status"/> member for the provided permission name.
        /// </summary>
        /// <param name="permission">The name of the permission to query the <see cref="Status"/> for.</param>
        /// <returns>The permission's status.</returns>
        public PermissionStatus this[string permission]
        {
            get
            {
                return Status[permission];
            }
        }

        private static PermissionStatus ConvertPermissionStatus(string permissionStatus)
        {
            if (String.Equals(permissionStatus, FacebookPermissionGranted, StringComparison.OrdinalIgnoreCase))
            {
                return PermissionStatus.Granted;
            }
            else if (String.Equals(permissionStatus, FacebookPermissionDeclined, StringComparison.OrdinalIgnoreCase))
            {
                return PermissionStatus.Declined;
            }

            return PermissionStatus.Unknown;
        }

        private static IDictionary<string, PermissionStatus> ConvertApiResult(IList<IDictionary<string, string>> apiResults)
        {
            IDictionary<string, PermissionStatus> transformedPermissions =
                new Dictionary<string, PermissionStatus>(StringComparer.OrdinalIgnoreCase);

            if (apiResults != null && apiResults.Any())
            {
                foreach (IDictionary<string, string> permissionData in apiResults)
                {
                    PermissionStatus status = ConvertPermissionStatus(permissionData["status"]);
                    transformedPermissions.Add(permissionData["permission"], status);
                }
            }

            return transformedPermissions;
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using Microsoft.AspNet.Facebook;

[assembly: AssemblyTitle("Microsoft.AspNet.Facebook")]
[assembly: AssemblyDescription("")]

[assembly: InternalsVisibleTo("Microsoft.AspNet.Facebook.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/Microsoft.AspNet.Facebook/Providers/DefaultFacebookClientProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Facebook;
using Newtonsoft.Json;

namespace Microsoft.AspNet.Facebook.Providers
{
    /// <summary>
    /// Default implementation of <see cref="IFacebookClientProvider"/>.
    /// </summary>
    public class DefaultFacebookClientProvider : IFacebookClientProvider
    {
        private FacebookConfiguration _config;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultFacebookClientProvider" /> class.
        /// </summary>
        /// <param name="configuration">The <see cref="FacebookConfiguration"/>.</param>
        public DefaultFacebookClientProvider(FacebookConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            _config = configuration;
        }

        /// <summary>
        /// Creates a <see cref="FacebookClient"/> with AppId and AppSecret that uses Json.NET for serialization and deserialization.
        /// Does not have an access token associated with it by default.
        /// </summary>
        /// <returns>The <see cref="FacebookClient"/> instance.</returns>
        public virtual FacebookClient CreateClient()
        {
            FacebookClient client = new FacebookClient();
            client.AppId = _config.AppId;
            client.AppSecret = _config.AppSecret;
            client.SetJsonSerializers(JsonConvert.SerializeObject, JsonConvert.DeserializeObject);
            return client;
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Providers/DefaultFacebookPermissionService.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Facebook;
using Microsoft.AspNet.Facebook.Client;

namespace Microsoft.AspNet.Facebook.Providers
{
    /// <summary>
    /// Default implementation of <see cref="IFacebookPermissionService"/>.
    /// </summary>
    public class DefaultFacebookPermissionService : IFacebookPermissionService
    {
        private FacebookConfiguration _config;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultFacebookPermissionService" /> class.
        /// </summary>
        /// <param name="configuration">The <see cref="FacebookConfiguration"/>.</param>
        public DefaultFacebookPermissionService(FacebookConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            _config = configuration;
        }

        /// <summary>
        /// Gets the user permissions by calling the Facebook Graph API.
        /// </summary>
        /// <param name="userId">The user id.</param>
        /// <param name="accessToken">The access token.</param>
        /// <returns>The user permissions.</returns>
        public virtual IEnumerable<string> GetUserPermissions(string userId, string accessToken)
        {
            if (userId == null)
            {
                throw new ArgumentNullException("userId");
            }

            if (accessToken == null)
            {
                throw new ArgumentNullException("accessToken");
            }

            PermissionsStatus permissionsStatus = GetUserPermissionsStatus(userId, accessToken);

            return PermissionHelper.GetGrantedPermissions(permissionsStatus);
        }

        /// <summary>
        /// Gets the users permission status by calling the Facebook graph API.
        /// </summary>
        /// <param name="userId">The user id.</param>
        /// <param name="accessToken">The access token.</param>
        /// <returns>The users permission status is in the following format { { "permissionName", "granted|declined" } }.</returns>
        public virtual PermissionsStatus GetUserPermissionsStatus(string userId, string accessToken)
        {
            if (userId == null)
            {
                throw new ArgumentNullException("userId");
            }

            if (accessToken == null)
            {
                throw new ArgumentNullException("accessToken");
            }

            FacebookClient client = _config.ClientProvider.CreateClient();
            client.AccessToken = accessToken;

            IList<IDictionary<string, string>> rawPermissionsStatus = client.GetCurrentUserPermissionsStatus();
            PermissionsStatus permissionsStatus = new PermissionsStatus(rawPermissionsStatus);

            return permissionsStatus;
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Providers/IFacebookClientProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Facebook;

namespace Microsoft.AspNet.Facebook.Providers
{
    /// <summary>
    /// Provides an abstraction for creating <see cref="FacebookClient"/>.
    /// </summary>
    public interface IFacebookClientProvider
    {
        /// <summary>
        /// Creates an instance of <see cref="FacebookClient"/>.
        /// </summary>
        /// <returns>The <see cref="FacebookClient"/> instance.</returns>
        FacebookClient CreateClient();
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Providers/IFacebookPermissionService.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace Microsoft.AspNet.Facebook.Providers
{
    /// <summary>
    /// Provides an abstraction for retrieving the user permissions.
    /// </summary>
    public interface IFacebookPermissionService
    {
        /// <summary>
        /// Gets the user permissions.
        /// </summary>
        /// <param name="userId">The user id.</param>
        /// <param name="accessToken">The access token.</param>
        /// <returns>The user permissions.</returns>
        IEnumerable<string> GetUserPermissions(string userId, string accessToken);

        /// <summary>
        /// Gets the users permission status.
        /// </summary>
        /// <param name="userId">The user id.</param>
        /// <param name="accessToken">The access token.</param>
        /// <returns>The user permissions status.</returns>
        PermissionsStatus GetUserPermissionsStatus(string userId, string accessToken);
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Realtime/FacebookRealtimeUpdateController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using Facebook;
using Microsoft.AspNet.Facebook.Models;

namespace Microsoft.AspNet.Facebook.Realtime
{
    /// <summary>
    /// <see cref="ApiController"/> for handling Facebook Realtime Update subscriptions.
    /// </summary>
    public abstract class FacebookRealtimeUpdateController : ApiController
    {
        private const string XHubSignatureHeaderName = "X-Hub-Signature";
        private FacebookConfiguration _facebookConfiguration;

        /// <summary>
        /// Gets the verify token.
        /// </summary>
        /// <value>
        /// The verify token.
        /// </value>
        public abstract string VerifyToken { get; }

        /// <summary>
        /// Gets or sets the <see cref="FacebookConfiguration"/>.
        /// </summary>
        /// <value>
        /// The <see cref="FacebookConfiguration"/>.
        /// </value>
        public FacebookConfiguration FacebookConfiguration
        {
            get
            {
                if (_facebookConfiguration == null)
                {
                    _facebookConfiguration = GlobalFacebookConfiguration.Configuration;
                }
                return _facebookConfiguration;
            }
            set
            {
                _facebookConfiguration = value;
            }
        }

        /// <summary>
        /// Handles the update.
        /// </summary>
        /// <param name="notification">The notification.</param>
        [NonAction]
        public abstract Task HandleUpdateAsync(ChangeNotification notification);

        /// <summary>
        /// Handles the HTTP GET requests from Facebook for subscription verification.
        /// </summary>
        /// <param name="subscriptionVerification">The subscription verification.</param>
        [SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Get", Justification = "Needs to be this name to follow routing conventions")]
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "HttpResponseMessage will be disposed by Web API")]
        public virtual HttpResponseMessage Get(SubscriptionVerification subscriptionVerification)
        {
            try
            {
                FacebookClient client = FacebookConfiguration.ClientProvider.CreateClient();
                client.VerifyGetSubscription(subscriptionVerification.Mode, subscriptionVerification.Verify_Token, subscriptionVerification.Challenge, VerifyToken);
            }
            catch (ArgumentException argumentException)
            {
                return Request.CreateErrorResponse(HttpStatusCode.BadRequest, argumentException);
            }

            return new HttpResponseMessage
            {
                Content = new StringContent(subscriptionVerification.Challenge)
            };
        }

        /// <summary>
        /// Handles the HTTP POST requests from Facebook for updates.
        /// </summary>
        public virtual async Task<HttpResponseMessage> Post()
        {
            IEnumerable<string> headerValues;
            if (Request.Headers.TryGetValues(XHubSignatureHeaderName, out headerValues))
            {
                string signatureHeaderValue = headerValues.FirstOrDefault();
                try
                {
                    string contentString = await Request.Content.ReadAsStringAsync();
                    FacebookClient client = FacebookConfiguration.ClientProvider.CreateClient();
                    ChangeNotification notification = client.VerifyPostSubscription(signatureHeaderValue, contentString, typeof(ChangeNotification)) as ChangeNotification;
                    await HandleUpdateAsync(notification);
                }
                catch (ArgumentException argumentException)
                {
                    return Request.CreateErrorResponse(HttpStatusCode.BadRequest, argumentException);
                }
                catch (HttpResponseException responseException)
                {
                    return responseException.Response;
                }
            }
            else
            {
                return Request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    String.Format(CultureInfo.CurrentCulture, Resources.MissingRequiredHeader, XHubSignatureHeaderName));
            }

            return Request.CreateResponse(HttpStatusCode.OK);
        }
    }
}

================================================
FILE: src/Microsoft.AspNet.Facebook/Resources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.35317
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.AspNet.Facebook {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.AspNet.Facebook.Resources", typeof(Resources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The app setting &apos;{0}&apos; is required and cannot be missing or empty. Make sure you set it in the configuration file..
        /// </summary>
        internal static string AppSettingIsRequired {
            get {
                return ResourceManager.GetString("AppSettingIsRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This argument cannot be null or empty..
        /// </summary>
        internal static string ArgumentCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("ArgumentCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Circular type references are not supported..
        /// </summary>
        internal static string CircularReferenceNotSupported {
            get {
                return ResourceManager.GetString("CircularReferenceNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid &apos;{0}&apos;. The &apos;{0}&apos; can only be set relative to the AppUrl. Prefix the path with &apos;~/&apos;..
        /// </summary>
        internal static string InvalidRedirectPath {
            get {
                return ResourceManager.GetString("InvalidRedirectPath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The required header &apos;{0}&apos; is missing..
        /// </summary>
        internal static string MissingRequiredHeader {
            get {
                return ResourceManager.GetString("MissingRequiredHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The signed request is missing..
        /// </summary>
        internal static string MissingSignedRequest {
            get {
                return ResourceManager.GetString("MissingSignedRequest", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; parameter is required..
        /// </summary>
        internal static string ParameterIsRequired {
            get {
                return ResourceManager.GetString("ParameterIsRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided permission string &apos;{0}&apos; should not contain comma (,)..
        /// </summary>
        internal static string PermissionStringShouldNotContainComma {
            get {
                return ResourceManager.GetString("PermissionStringShouldNotContainComma", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; cannot be an external URL. It must have &apos;{1}&apos; as the prefix..
        /// </summary>
        internal static string UrlCannotBeExternal {
            get {
                return ResourceManager.GetString("UrlCannotBeExternal", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/Resources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="AppSettingIsRequired" xml:space="preserve">
    <value>The app setting '{0}' is required and cannot be missing or empty. Make sure you set it in the configuration file.</value>
  </data>
  <data name="ArgumentCannotBeNullOrEmpty" xml:space="preserve">
    <value>This argument cannot be null or empty.</value>
  </data>
  <data name="CircularReferenceNotSupported" xml:space="preserve">
    <value>Circular type references are not supported.</value>
  </data>
  <data name="InvalidRedirectPath" xml:space="preserve">
    <value>Invalid '{0}'. The '{0}' can only be set relative to the AppUrl. Prefix the path with '~/'.</value>
  </data>
  <data name="MissingRequiredHeader" xml:space="preserve">
    <value>The required header '{0}' is missing.</value>
  </data>
  <data name="MissingSignedRequest" xml:space="preserve">
    <value>The signed request is missing.</value>
  </data>
  <data name="ParameterIsRequired" xml:space="preserve">
    <value>The '{0}' parameter is required.</value>
  </data>
  <data name="PermissionStringShouldNotContainComma" xml:space="preserve">
    <value>The provided permission string '{0}' should not contain comma (,).</value>
  </data>
  <data name="UrlCannotBeExternal" xml:space="preserve">
    <value>The '{0}' cannot be an external URL. It must have '{1}' as the prefix.</value>
  </data>
</root>

================================================
FILE: src/Microsoft.AspNet.Facebook/ShowPromptResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.AspNet.Facebook
{
    /// <summary>
    /// Represents an <see cref="ActionResult"/> that redirects to a permission prompt login via JavaScript.
    /// </summary>
    public class ShowPromptResult : JavaScriptRedirectResult
    {
        /// <summary>
        /// Creates a JavaScript based redirect <see cref="ActionResult"/>.
        /// </summary>
        /// <param name="promptUrl">The url that the prompt exists at.</param>
        public ShowPromptResult(Uri promptUrl)
            : base(promptUrl)
        {
        }
    }
}


================================================
FILE: src/Microsoft.AspNet.Facebook/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Facebook" version="6.4.2" targetFramework="net45" />
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
</packages>

================================================
FILE: src/Microsoft.Web.Helpers/Analytics.cshtml
================================================
@* Generator: WebPagesHelper *@

@helper GetGoogleHtml(string webPropertyId) {
    var webPropertyIdJson = new HtmlString(HttpUtility.JavaScriptStringEncode(webPropertyId, addDoubleQuotes: false));

    <script type="text/javascript">
        var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
        document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
    </script>
    <script type="text/javascript">
        try{
            var pageTracker = _gat._getTracker("@webPropertyIdJson");
            pageTracker._trackPageview();
        } catch(err) {}
    </script>
}

@helper GetGoogleAsyncHtml(string webPropertyId) {
    var webPropertyIdJson = new HtmlString(HttpUtility.JavaScriptStringEncode(webPropertyId, addDoubleQuotes: false));
    <script type="text/javascript">
        var _gaq = _gaq || [];
        _gaq.push(['_setAccount', '@webPropertyIdJson']);
        _gaq.push(['_trackPageview']);
        (function() {
            var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
            ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
            var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
        })();
    </script>
}

@helper GetYahooHtml(string account) {
    var accountJson = new HtmlString(HttpUtility.JavaScriptStringEncode(account, addDoubleQuotes: false));
    <script type="text/javascript">
        window.ysm_customData = new Object();
        window.ysm_customData.conversion = "transId=,currency=,amount=";
        var ysm_accountid = "@accountJson";
        document.write("<SCR" + "IPT language='JavaScript' type='text/javascript' "
        + "SRC=//" + "srv3.wa.marketingsolutions.yahoo.com" + "/script/ScriptServlet" + "?aid=" + ysm_accountid
        + "></SCR" + "IPT>");
    </script>
}

@helper GetStatCounterHtml(int project, string security) {
    var securityJson = new HtmlString(HttpUtility.JavaScriptStringEncode(security, addDoubleQuotes: false));

    <script type="text/javascript">
    var sc_project=@project;
    var sc_invisible=1;
    var sc_security="@securityJson";
    var sc_text=2;
    var sc_https=1;
    var scJsHost = (("https:" == document.location.protocol) ? "https://secure." : "http://www.");
    document.write("<sc" + "ript type='text/javascript' src='" + scJsHost + "statcounter.com/counter/counter_xhtml.js'></" + "script>");
    </script>
    <noscript>
    <div class="statcounter">
    <a title="tumblrstatistics" class="statcounter" href="http://www.statcounter.com/tumblr/"><img class="statcounter" src="https://c.statcounter.com/@project/0/@security/1/" alt="tumblr statistics"/></a></div>
    </noscript>
}     
       

================================================
FILE: src/Microsoft.Web.Helpers/Facebook.cshtml
================================================
@* Generator: WebPagesHelper *@

@using System.Collections.Specialized
@using System.Globalization
@using System.Security
@using System.Text
@using System.Web.Helpers
@using System.Web.WebPages.Scope
@using WebMatrix.Data
@using WebMatrix.WebData

@functions {
    
    private const string FacebookCredentialsTableName = "webpages_FacebookCredentials";
    private const string FacebookCredentialsIdColumn = "FacebookId";
    private const string FacebookCredentialsUserIdColumn = "UserId";

    private const string DefaultUserIdColumn = "UserId";
    private const string DefaultUserNameColumn = "email";
    private const string DefaultUserTableName = "UserProfile";

    private const string DefaultFacebookPerms = "email";
    private const string DefaultCallbackUrl = "~/Facebook/Login";
    private const string FacebookApiProfileUrl = "https://graph.facebook.com/me";
    private const string FacebookCookieAccessToken = "access_token";

    private static readonly object _isInitializedKey = new object();
    private static readonly object _membershipDBNameKey = new object();
    private static readonly object _appIdKey = new object();
    private static readonly object _appSecretKey = new object();
    private static readonly object _language = new object();

    public static bool HasMembershipIntegration {
        get {
            return !MembershipDBName.IsEmpty();
        }
    }

    public static bool IsFacebookUserAuthenticated {
        get {
            return !GetFacebookCookieInfo(HttpContext, "uid").IsEmpty();
        }
    }

    public static bool IsFacebookUserAssociated {
        get {
            return !GetAssociatedMembershipUserName().IsEmpty();
        }
    }

    public static bool IsInitialized {
        get {
            return (bool)(ScopeStorage.CurrentScope[_isInitializedKey] ?? false);
        }

        private set {
            ScopeStorage.CurrentScope[_isInitializedKey] = value;
        }
    }

    public static string MembershipDBName {
        get {
            return (string)(ScopeStorage.CurrentScope[_membershipDBNameKey] ?? "");
        }

        set {
            ScopeStorage.CurrentScope[_membershipDBNameKey] = value;
        }
    }

    public static string AppId {
        get {
            return (string)(ScopeStorage.CurrentScope[_appIdKey] ?? "");
        }

        set {
            ScopeStorage.CurrentScope[_appIdKey] = value;
        }
    }

    public static string AppSecret {
        get {
            return (string)(ScopeStorage.CurrentScope[_appSecretKey] ?? "");
        }

        set {
            ScopeStorage.CurrentScope[_appSecretKey] = value;
        }
    }

    public static string Language {
        get {
            return (string)(ScopeStorage.CurrentScope[_language] ?? "en_US");
        }

        set {
            ScopeStorage.CurrentScope[_language] = value;
        }
    }
    
    private static HttpContextBase HttpContext {
        get {
            return new HttpContextWrapper(System.Web.HttpContext.Current);
        }
    }

    ///<summary>
    /// Initialize the helper with your Facebook application settings. 
    /// 
    /// If the 'membershipDBName' parameter is specified, Facebook membership integration will be enabled, 
    /// allowing users to register and associate their Facebook user account (identified with the e-mail) 
    /// with your site membership and the WebSecurity helper. 
    /// In this case, the helper will initialize the WebSecurity WebMatrix helper automatically (if not done previously) 
    /// and the store the Facebook membership information in the 'membershipDbName' database.    
    ///</summary>
    ///<param name="appId">Facebook application id.</param>        
    ///<param name="appSecret">Facebook application secret.</param>   
    ///<param name="membershipDbName">Name of the database used for storing the membership data.</param>   
    public static void Initialize(string appId, string appSecret, string membershipDbName = "") {
        AppId = appId;
        AppSecret = appSecret;
        IsInitialized = true;

        if (!membershipDbName.IsEmpty()) {
            MembershipDBName = membershipDbName;

            InitializeMembershipProviderIfNeeded();
            InitializeFacebookTableIfNeeded();
        }
    }

    ///<summary>
    /// Retrieves the Facebook profile of current logged in user.
    ///</summary>
    public static UserProfile GetFacebookUserProfile() {
        var accessToken = GetFacebookCookieInfo(HttpContext, FacebookCookieAccessToken);

        if (accessToken.IsEmpty()) {
            return null;
        }

        var userProfileUrl = new Uri(new UrlBuilder(FacebookApiProfileUrl).AddParam(FacebookCookieAccessToken, accessToken));

        using (var client = new WebClient()) {
            using (var receiveStream = client.OpenRead(userProfileUrl)) {
                var result = new StreamReader(receiveStream).ReadToEnd();
                var profile = Json.Decode<UserProfile>(result);

                return profile;
            }
        }
    }

    ///<summary>
    /// Associates the specified User Name (e.g. email, depending on your membership model) with the current Facebook User Id from the logged user.
    ///</summary>
    ///<param name="userName">The user name to associate the current logged-in facebook account to.</param>
    public static void AssociateMembershipAccount(string userName) {
        if (!IsFacebookUserAuthenticated) {
            throw new InvalidOperationException("No Facebook user is authenticated.");
        }

        if (IsFacebookUserAssociated) {
            throw new InvalidOperationException("The authenticated Facebook user is already associated to a membership account.");
        }

        using (var db = Database.Open(MembershipDBName)) {
            var facebookUserId = GetFacebookCookieInfo(HttpContext, "uid").As<long>();

            var userId = WebSecurity.GetUserId(userName);
            db.Execute(String.Format(CultureInfo.InvariantCulture, "INSERT INTO {0} ({1}, {2}) VALUES (@0, @1)", FacebookCredentialsTableName, FacebookCredentialsUserIdColumn, FacebookCredentialsIdColumn), 
                userId, facebookUserId);

            // User is registered in the application
            FormsAuthentication.SetAuthCookie(userName, false);
        }
    }

    public static bool MembershipLogin() {
        var user = GetAssociatedMembershipUserName();

        if (!user.IsEmpty()) {
            // User is registered in the application
            FormsAuthentication.SetAuthCookie(user, false);
            return true;
        }
        else {
            return false;
        }
    }

    private static void InitializeMembershipProviderIfNeeded() {
        var provider = GetMembershipProvider();

        if (IsMembershipProviderInitialized(provider)) {
            WebSecurity.InitializeDatabaseConnection(MembershipDBName, DefaultUserTableName, DefaultUserIdColumn, DefaultUserNameColumn, true);
        }
    }

    private static void InitializeFacebookTableIfNeeded() {
        using (var db = Database.Open(MembershipDBName)) {
            var table = db.QuerySingle("SELECT * FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = @0", FacebookCredentialsTableName);

            if (table == null) {
                db.Execute(String.Format(CultureInfo.InvariantCulture, "CREATE TABLE {0} ({1} INT NOT NULL, {2} BIGINT NOT NULL)", FacebookCredentialsTableName, FacebookCredentialsUserIdColumn, FacebookCredentialsIdColumn));
            }
        }
    }

    private static string GetAssociatedMembershipUserName() {
        var userName = "";

        if (IsFacebookUserAuthenticated) {
            using (var db = Database.Open(MembershipDBName)) {
                var userId = db.QueryValue(String.Format(CultureInfo.InvariantCulture, "SELECT {0} FROM {1} WHERE {2} = LOWER(@0)", FacebookCredentialsUserIdColumn, FacebookCredentialsTableName, FacebookCredentialsIdColumn),
                    GetFacebookCookieInfo(HttpContext, "uid"));
                if (userId != null) {
                    userName = GetUserName(userId);
                }
            }
        }

        return userName;
    }

    private static string GetUserName(int userId) {
        var userName = "";

        using (var db = Database.Open(MembershipDBName)) {
            var provider = GetMembershipProvider();
            userName = db.QueryValue(String.Format(CultureInfo.InvariantCulture, "SELECT {0} FROM {1} WHERE {2} = @0", provider.UserNameColumn, provider.UserTableName, provider.UserIdColumn), userId);
        }

        return userName;
    }

    private static SimpleMembershipProvider GetMembershipProvider() {
        var provider = Membership.Provider as SimpleMembershipProvider;

        if (provider == null) {
            throw new InvalidOperationException("Simple Membership Provider not found.");
        }

        return provider;
    }

    private static bool IsMembershipProviderInitialized(SimpleMembershipProvider provider) {
        return provider.UserTableName.IsEmpty() || provider.UserIdColumn.IsEmpty() || provider.UserNameColumn.IsEmpty();
    }

    internal static string GetFacebookCookieInfo(HttpContextBase httpContext, string key) {
        var request = httpContext.Request;
        var name = "fbs_" + AppId;

        if (request.Cookies[name] != null) {
            var value = request.Cookies[name].Value;
            var args = HttpUtility.ParseQueryString(value.Replace("\"", ""));

            if (!IsFacebookCookieValid(args)) {
                throw new InvalidOperationException("Invalid Facebook cookie.");
            }

            return args[key];
        }
        else {
            return "";
        }
    }

    private static bool IsFacebookCookieValid(NameValueCollection args) {
        var payload = new StringBuilder();
        var keys = args.AllKeys;
        Array.Sort(keys);
        foreach (var key in keys) {
            if (!key.Equals("sig", StringComparison.OrdinalIgnoreCase)) {
                payload.AppendFormat("{0}={1}", key, args[key]);
            }
        }
        
        payload.Append(AppSecret);

        // Review: The HMAC uses MD5 which is not cryptographically secure. We need to investigate other Facebook authentication methods.
        var signature = new StringBuilder();
        using (var md5 = System.Security.Cryptography.MD5CryptoServiceProvider.Create()) {
            var hash = md5.ComputeHash(Encoding.ASCII.GetBytes(payload.ToString()));
            for (int i = 0; i < hash.Length; i++) {
                signature.Append(hash[i].ToString("X2", CultureInfo.InvariantCulture));
            }
        }
        return String.Equals(args["sig"], signature.ToString(), StringComparison.OrdinalIgnoreCase);
    }

    public class UserProfile {
        public string Id { get; set; }
        public string Name { get; set; }
        public string First_Name { get; set; }
        public string Last_Name { get; set; }
        public string Link { get; set; }
        public string Bio { get; set; }
        public string Gender { get; set; }
        public string Email { get; set; }
        public string Timezone { get; set; }
        public string Locale { get; set; }
        public string Updated_Time { get; set; }
    }

    private static IHtmlString RawJS(string text) {
        return new HtmlString(HttpUtility.JavaScriptStringEncode(text));
    }
}

@*
Summary: 
  Initialize the Facebook JavaScript SDK to be able to support the XFBML tags of the social plugins.
*@
@helper GetInitializationScripts() {
    <div id="fb-root"></div>
    <script type="text/javascript">
        window.fbAsyncInit = function () {
            FB.init({ appId: '@RawJS(AppId)', status: true, cookie: true, xfbml: true });
        };
        (function () {
            var e = document.createElement('script'); e.async = true;
            e.src = document.location.protocol +
            '//connect.facebook.net/@RawJS(Language)/all.js';
            document.getElementById('fb-root').appendChild(e);
        } ());

        function loginRedirect(url) { window.location = url; }
    </script>
}

@*
Summary:
  Shows a Facebook Login Button, with site membership integration, allowing users to login on your site with their Facebook account (e-mail).
  To use this method, you need to provide the 'membershipDbName' in the helper's Initialize() method.

Parameter: registerUrl
    Specifies the URL to register the logged user, and associate it with a Membership account.
Parameter: returnUrl
    Specifies URL to redirect after the user has successfully logged in (i.e. the Facebook User has a Membership Account).
Parameter: callbackUrl
    Specifies the URL of the WebMatrix page that will handle the Membership login (default URL is ~/Facebook/Login.cshtml).
Parameter: buttonText
    Specifies the Login Button Text.
Parameter: autoLogoutLink
    When set to true, if the user is logged into Facebook the button will display a logout button instead.
Parameter: size
    Specifies the button size: "small", "medium", "large", "xlarge".
Paramter: length
    Specifies the text lenght: "long" --> 'Connect with Facebook" or "short" --> 'Connect'.
Parameter: showFaces
    Specifies whether to display profile photos below the button.
Parameter: extendedPermissions
    The extendedPermissions parameter can be used to request extended permissions from the user. For example, if you want to incorporate a user's photos into your application, set this value to “user_photos”.
*@
@helper LoginButton(
        string registerUrl,
        string returnUrl = "~/",
        string callbackUrl = DefaultCallbackUrl,
        string buttonText = "",
        bool autoLogoutLink = false,
        string size = "medium",
        string length = "long",
        bool showFaces = false,
        string extendedPermissions = "") {

    var redirectUrl = new UrlBuilder(callbackUrl)
                            .AddParam("registerUrl", new UrlBuilder(registerUrl))
                            .AddParam("returnUrl", new UrlBuilder(returnUrl));
    var onLogin = String.Format(CultureInfo.InvariantCulture, "loginRedirect('{0}')", RawJS(redirectUrl));
    extendedPermissions = extendedPermissions.IsEmpty() ? "email" : String.Concat("email,", extendedPermissions);

    <fb:login-button autologoutlink="@autoLogoutLink" size="@size" length="@length" onlogin="@onLogin" show-faces="@showFaces" perms="@extendedPermissions">@buttonText</fb:login-button>        
}  

@*
Summary:
  Shows a Facebook Login Button, without integrating Facebook login with your site membership.

Parameter: buttonText
    Specifies the Login Button Text.
Parameter: autoLogoutLink
    When set to true, if the user is logged into Facebook the button will display a logout button instead.
Parameter: size
    The button size: "small", "medium", "large", "xlarge".
Parameter: length
    The text lenght: "long" --> 'Connect with Facebook" or "short" --> 'Connect'
Parameter: onLogin
    Specifies the JavaScript action to execute after the user login. 
Parameter: showFaces
    Whether to display profile photos below the button.
Parameter: extendedPermissions
    The extendedPermissions parameter can be used to request extended permissions from the user. For example, if you want to incorporate a user's photos into your application, set this value to “user_photos”.
*@
@helper LoginButtonTagOnly(
    string buttonText = "",
    bool autoLogoutLink = false,
    string size = "long",
    string length = "short",
    string onLogin = "",
    bool showFaces = false,
    string extendedPermissions = "") {
    <fb:login-button autologoutlink="@autoLogoutLink" size="@size" length="@length" onlogin="@onLogin" show-faces="@showFaces" perms="@extendedPermissions">@buttonText</fb:login-button>
}
    
@*
Summary:
  Shows a Facebook Like Button. When the user clicks the Like button on your site, a story appears in the user's friends' News Feed with a link back to your website.

Parameter: href
    The URL to like.
Parameter: buttonLayout
    The button layout:
        - standard: Displays social text to the right of the button and friends' profile photos below. 
            Minimum width: 225 pixels. Default width: 450 pixels. Height: 35 pixels (without photos) or 80 pixels (with photos). 
        - button_count: Displays the total number of likes to the right of the button. 
            Minimum width: 90 pixels. Default width: 90 pixels. Height: 20 pixels.
Parameter: showFaces
    Specifies whether to display profile photos below the button (standard layout only).
Parameter: width
    The width of the Like button.
Parameter: height
    The height of the plugin in pixels.
Parameter: action
    The verb to display on the button: 'like', 'recommend'. 
Parameter: font
    The font to display in the button: 'arial', 'lucida grande', 'segoe ui', 'tahoma', 'trebuchet ms', 'verdana'.
Parameter: colorScheme
    The color scheme for the like button: 'light' or 'dark'.
Parameter: refLabel
    A label for tracking referrals; must be less than 50 characters and can contain alphanumeric characters and some punctuation (currently +/=-.:_).
    
*@
@helper LikeButton(
            string href = "",
            string buttonLayout = "standard",
            bool showFaces = true,
            int width = 450,
            int height = 80,
            string action = "like",
            string font = "",
            string colorScheme = "light",
            string refLabel = ""
            ) {    
                
    if (href.IsEmpty()) {
        href = Request.Url.OriginalString;
    }

    var src = new UrlBuilder("http://www.facebook.com/plugins/like.php")
                    .AddParam("href", href)
                    .AddParam("layout", buttonLayout)
                    .AddParam("show_faces", showFaces)
                    .AddParam("width", width)
                    .AddParam("action", action)
                    .AddParam("colorscheme", colorScheme)
                    .AddParam("height", height)
                    .AddParam("font", font)
                    .AddParam("locale", Language)
                    .AddParam("ref", refLabel);
        
    <iframe src="@src" scrolling="no" frameborder="0" style="border:none; overflow:hidden; width:@(width)px; height:@(height)px;" allowTransparency="true"></iframe>
}

@*
Summary:
    Shows a Facebook Comments plugin.
    The Comments Box easily enables your users to comment on your site's content — whether it's for a web page, article, photo, or other piece of content. 
    Then the user can share the comment on Facebook on their Wall and in their friends' streams.
    An 'Administer Comments' link will appear below the 'Post' button for developers of the application.

Parameter: xid
    An id associated with the comments object (defaults to URL-encoded page URL).
Parameter: width
    The width of the plugin, in pixels.
Parameter: numPosts
    The number of comments to display, or 0 to hide all comments. 
Parameter: reverse
    Changes the order of comments and comment area to allow greater customization.
Parameter: removeRoundedBox
    Removes the rounded box around the text area where comments are written to allow greater customization.
*@
@helper Comments(
            string xid = "",
            int width = 550,
            int numPosts = 10,
            bool reverseOrder = false,
            bool removeRoundedBox = false) {
    <fb:comments @if (!xid.IsEmpty()) { <text>xid="@xid" </text> }numposts="@numPosts" width="@width" reverse="@reverseOrder" simple="@removeRoundedBox" ></fb:comments>
}

@*
Summary:
    Shows a Facebook Recommendations plugin. The Recommendations plugin shows personalized recommendations to your users.
    Since the content is hosted by Facebook, the plugin can display personalized recommendations whether or not the user has logged into your site.
    To generate the recommendations, the plugin considers all the social interactions with URLs from your site.
    For a logged in Facebook user, the plugin will give preference to and highlight objects her friends have interacted with.
    
    *NOTE*: This helper method requires that your site is published into a public address where others can use it. Check this tutorial on publishing with WebMatrix: http://www.asp.net/webmatrix/tutorials/publish-a-website 

Parameter: site
    The address of your published site. For example "www.fourthcoffee.com"
Parameter: width
    The width of the plugin in pixels.
Parameter: height
    The height of the plugin in pixels.
Parameter: showHeader
    Whether to show a 'Recommendations' title bar.
Parameter: colorScheme
    The color scheme of the plugin: 'light' or 'dark'.
Parameter: font
    The font name for the plugin.
Parameter: borderColor
    The border color of the plugin. Use common color names as Red, White, Black, and so on.
Parameter: filter
    Allows you to filter which URLs are shown in the plugin. The plugin will only include URLs which contain the filter term in the first two path parameters of the URL.
Parameter: refLabel
    A label for tracking referrals; must be less than 50 characters and can contain alphanumeric characters and some punctuation (currently +/=-.:_).
*@
@helper Recommendations(
            string site = "",
            int width = 300,
            int height = 300,
            bool showHeader = true,
            string colorScheme = "light",
            string font = "",
            string borderColor = "",
            string filter = "",
            string refLabel = ""
    ) {	
        if (site.IsEmpty()) {
            site = Request.Url.Host;
        }

    var src = new UrlBuilder("http://www.facebook.com/plugins/recommendations.php")
                    .AddParam("site", site)
                    .AddParam("width", width)
                    .AddParam("height", height)
                    .AddParam("header", showHeader)
                    .AddParam("colorscheme", colorScheme)
                    .AddParam("font", font)
                    .AddParam("border_color", borderColor)
                    .AddParam("filter", filter)
                    .AddParam("ref", refLabel)
                    .AddParam("locale", Language);
    
    <iframe src="@src" scrolling="no" frameborder="0" style="border:none; overflow:hidden; width:@(width)px; height:@(height)px;" allowTransparency="true"></iframe>
}

@*
Summary:
    Shows a Facebook Like Box. The Like Box is a social plugin that enables Facebook Page owners to attract and gain Likes from their own website.
    The Like Box enables users to:
        - See how many users already like this page, and which of their friends like it too
        - Read recent posts from the page
        - Like the page with one click, without needing to visit the page   

Parameter: href
    The URL of the Facebook Page for this Like box.
Parameter: width
    The width of the plugin in pixels.
Parameter: height
    The height of the plugin in pixels.
Parameter: colorScheme
    The color scheme of the plugin: 'light' or 'dark'.
Parameter: connections
    Number of shown users who have liked this Page. Use 0 to avoid showing the users box.
Parameter: showStream
    Shows the profile stream for the public profile of the page. 
Parameter: showHeader
    Shows the 'Find us on Facebook' bar at top. Only shown when either stream or connections are present.
*@
@helper LikeBox(
            string href,
            int width = 292,
            int height = 587,
            string colorScheme = "light",
            int connections = 10,
            bool showStream = true,
            bool showHeader = true) {   
    
    var src = new UrlBuilder("http://www.facebook.com/plugins/likebox.php")
                    .AddParam("href", href)
                    .AddParam("width", width)
                    .AddParam("height", height)
                    .AddParam("header", showHeader)
                    .AddParam("colorscheme", colorScheme)
                    .AddParam("connections", connections)
                    .AddParam("stream", showStream)
                    .AddParam("header", showHeader)
                    .AddParam("locale", Language);
                                 
    <iframe src="@src" scrolling="no" frameborder="0" style="border:none; overflow:hidden; width:@(width)px; height:@(height)px;" allowTransparency="true"></iframe>                
}

@*
Summary:
    Shows a Facebook Facepile plugin.
    The Facepile plugin shows the Facebook profile pictures of the user's friends who have already signed up for your site. 
    The plugin doesn't show up if the user is logged out of Facebook or doesn't have friends who have signed up for your site using Facebook.

Parameter: maxRows
    The maximum number of rows of profile pictures to show. The plugin dynamically sizes its height; for example, if you specify a maximum of four rows, and there are only enough friends to fill two rows, the height of the plugin will be only what is needed for two rows of profile pictures. 
Parameter: width
    The width of the plugin in pixels. 
*@
@helper Facepile(
            int maxRows = 1,
            int width = 200) {
    <fb:facepile max-rows="@maxRows" width="@width"></fb:facepile>
}

@*
Summary:
    Shows a Facebook Live Stream plugin.
    The Live Stream plugin lets users visiting your site or application share activity and comments in real time. 
    The Live Stream Box works best when you are running a real-time event, like live streaming video for concerts, speeches, or webcasts, live Web chats, 
    webinars, massively multiplayer games.

Parameter: width
    The width of the plugin in pixels.
Parameter: height
    The height of the plugin in pixels.
Parameter: xid
    If you have multiple live stream boxes on the same page, specify a unique 'xid' for each.
Parameter: viaUrl
    The URL that users are redirected to when they click on your app name on a status (if not specified, your Connect URL is used).
Parameter: alwaysPostToFriends
    If set, all user posts will always go to their profile. This option should only be used when users' posts are likely to make sense outside of the context of the event.
*@
@helper LiveStream(
            int width = 400,
            int height = 500,
            string xid = "",
            string viaUrl = "",
            bool alwaysPostToFriends = false) {
       
                
    var builder = new UrlBuilder("http://www.facebook.com/plugins/live_stream_box.php")
        .AddParam("app_id", AppId)
        .AddParam("width", width)
        .AddParam("height", height)
        .AddParam("always_post_to_friends", alwaysPostToFriends)
        .AddParam("locale", Language);

    if (!xid.IsEmpty()) {
        builder.AddParam("xid", xid);
        builder.AddParam("via_url", viaUrl);
    }
    
    <iframe src="@builder" scrolling="no" frameborder="0" style="border:none; overflow:hidden; width:@(width)px; height:@(height)px;" allowTransparency="true"></iframe>
}

@*
Summary:
    Shows a Facebook Activity Feed plugin.    
    The Activity Feed plugin displays the most interesting recent activity taking place on your site. Since the content is hosted by Facebook, 
    the plugin can display personalized content whether or not the user has logged into your site. The activity feed displays stories both when 
    users like content on your site and when users share content from your site back to Facebook.
    
    *NOTE*: This helper method requires that your site is published into a public address where others can use it. Check this tutorial on publishing with WebMatrix: http://www.asp.net/webmatrix/tutorials/publish-a-website 

Parameter: site
    The address of your published site. For example "www.fourthcoffee.com"
Parameter: width
    The width of the plugin in pixels.
Parameter: height
    The height of the plugin in pixels.
Parameter: showHeader
    Show the 'Recent Activity' title bar.
Parameter: colorScheme
    The color scheme of the plugin: 'light' or 'dark'.
Parameter: font
    The font name for the plugin.
Parameter: borderColor
    The border color of the plugin. Use common color names as Red, White, Black, and so on.
Parameter: showRecommendations
    Whether to show recommendations on the activity feed.
*@
@helper ActivityFeed(
        string site = "",
        int width = 300,
        int height = 300,
        bool showHeader = true,
        string colorScheme = "light",
        string font = "",
        string borderColor = "",
        bool showRecommendations = false) {
    if (site.IsEmpty()) {
        site = Request.Url.Host;
    }

    var src = new UrlBuilder("http://www.facebook.com/plugins/activity.php")
                    .AddParam("site", site)
                    .AddParam("width", width)
                    .AddParam("height", height)
                    .AddParam("header", showHeader)
                    .AddParam("colorscheme", colorScheme)
                    .AddParam("font", font)
                    .AddParam("border_color", borderColor)
                    .AddParam("recommendations", showRecommendations)
                    .AddParam("locale", Language);                
                    
    <iframe src="@src" scrolling="no" frameborder="0" style="border:none; overflow:hidden; width:300px; height:300px;" allowTransparency="true"></iframe>
}

@*
Summary:
    OpenGraph properties allows you to specify structured information about your web pages to show up your pages richly across Facebook and enable Facebook users to establish connections to your pages.
    
    Use this method to show OpenGraph page data, as the page title, URL, and so on.
    
    *NOTE*: It is important to notice that the OpenGraph properties are read directly from your site by Facebook, therefore your site needs to be published into a public address to see the OpenGraph properties working. 
    Check this tutorial on publishing with WebMatrix: http://www.asp.net/webmatrix/tutorials/publish-a-website 

Parameter: siteName
    A human-readable name for your site, e.g., "Fourth Coffee".
Parameter: title
    The title of your page as it should appear within Facebook, e.g., "Pecan Pie".
Parameter: type
    The type of your page, e.g., "food". See the complete list of supported types here: http://developers.facebook.com/docs/opengraph#types
Parameter: url
    The canonical URL of your object that will be used as its permanent ID in the graph, e.g., http://www.fourthcoffe.com/Product/1/.
Parameter: imageUrl
    An image URL which should represent your page within the graph. The image must be at least 50px by 50px and have a maximum aspect ratio of 3:1.
Parameter: description
    A one to two sentence description of your page.
*@
@helper OpenGraphRequiredProperties(
    string siteName,
    string title,
    string type,
    string url,
    string imageUrl,
    string description = "") {  
    <meta property="og:site_name" content="@siteName"/>
    <meta property="fb:app_id" content="@AppId"/>     
    <meta property="og:title" content="@title"/>
    <meta property="og:type" content="@type"/>
    <meta property="og:url" content="@url"/>
    <meta property="og:image" content="@imageUrl"/>        
        if (!description.IsEmpty()) {
    <meta property="og:description" content="@description"/>
        }
}

@*
Summary:
    OpenGraph properties allows you to specify structured information about your web pages to show up your pages richly across Facebook and enable Facebook users to establish connections to your pages.
    
    Use this method to show page location data. This is useful if your pages is a business profile or about anything else with a real-world location. You can specify location via latitude and longitude, a full address, or both.
    
    *NOTE*: It is important to notice that the OpenGraph properties are read directly from your site by Facebook, therefore your site needs to be published into a public address to see the OpenGraph properties working. 
    Check this tutorial on publishing with WebMatrix: http://www.asp.net/webmatrix/tutorials/publish-a-website 
*@     
@helper OpenGraphLocationProperties(
    string latitude = "",
    string longitude = "",
    string streetAddress = "",
    string locality = "",
    string region = "",
    string postalCode = "",
    string countryName = "") {        
        if (!latitude.IsEmpty()) {
    <meta property="og:latitude" content="@latitude"/>
        }
        if (!longitude.IsEmpty()) {
    <meta property="og:longitude" content="@longitude"/>
        }
        if (!streetAddress.IsEmpty()) {
    <meta property="og:street-address" content="@streetAddress"/>
        }
        if (!locality.IsEmpty()) {
    <meta property="og:locality" content="@locality"/>
        }
        if (!region.IsEmpty()) {
    <meta property="og:region" content="@region"/>
        }
        if (!postalCode.IsEmpty()) {
    <meta property="og:postal-code" content="@postalCode"/>
        }
        if (!countryName.IsEmpty()) {
    <meta property="og:country-name" content="@countryName"/>
        }
}

@*
Summary:
    OpenGraph properties allows you to specify structured information about your web pages to show up your pages richly across Facebook and enable Facebook users to establish connections to your pages.
    
    Use this method to show contact information about your page. Consider including contact information if your page is about an entity that can be contacted.
    
    *NOTE*: It is important to notice that the OpenGraph properties are read directly from your site by Facebook, therefore your site needs to be published into a public address to see the OpenGraph properties working. 
    Check this tutorial on publishing with WebMatrix: http://www.asp.net/webmatrix/tutorials/publish-a-website 
*@
@helper OpenGraphContactProperties(
    string email = "",
    string phoneNumber = "",
    string faxNumber = "") {        
    
        if (!email.IsEmpty()) {
    <meta property="og:email" content="@email"/>
        }
        if (!phoneNumber.IsEmpty()) {
    <meta property="og:phone_number" content="@phoneNumber"/>
        }
        if (!faxNumber.IsEmpty()) {
    <meta property="og:fax_number" content="@faxNumber"/>
        }
    
}

@*
Summary:
    Use this method inside your opening HTML tag for W3C compatibility.
        For example: <html xmlns="http://www.w3.org/1999/xhtml" @Facebook.FbmlNamespaces()>         
*@
@helper FbmlNamespaces() {<text>xmlns:fb="http://www.facebook.com/2008/fbml" xmlns:og="http://opengraphprotocol.org/schema/"</text>}


================================================
FILE: src/Microsoft.Web.Helpers/FileUpload.cshtml
================================================
@* Generator: WebPagesHelper *@

@using System.Globalization
@using System.Web
@using Microsoft.Internal.Web.Utils
@using Resources

@functions {
    private class FileUploadTracker {
        private static readonly object _countKey = new object();
        private static readonly object _scriptAlreadyRendered = new object();
        private readonly HttpContextBase _httpContext;

        public FileUploadTracker(HttpContextBase httpContext) {
            _httpContext = httpContext;
        }

        public bool ScriptAlreadyRendered {
            get {
                bool? rendered = _httpContext.Items[_scriptAlreadyRendered] as bool?;
                return rendered.HasValue && rendered.Value;
            }
            set {
                _httpContext.Items[_scriptAlreadyRendered] = value;
            }
        }

        public int RenderCount {
            get {
                int? count = _httpContext.Items[_countKey] as int?;
                if (!count.HasValue) {
                    count = 0;
                }
                return count.Value;
            }
            set {
                _httpContext.Items[_countKey] = value;
            }
        }
    }
}

@helper GetHtml(string name = null,
            int initialNumberOfFiles = 1,
            bool allowMoreFilesToBeAdded = true,
            bool includeFormTag = true,
            string addText = null,
            string uploadText = null) {
    @_GetHtml(new HttpContextWrapper(HttpContext.Current), name, initialNumberOfFiles, allowMoreFilesToBeAdded,
                includeFormTag, addText, uploadText)
}

@helper _GetHtml(HttpContextBase context, string name, int initialNumberOfFiles, 
        bool allowMoreFilesToBeAdded, bool includeFormTag, string addText, string uploadText) {
    
    if (initialNumberOfFiles < 0) {
        throw new ArgumentOutOfRangeException(
            "initialNumberOfFiles",
            String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "0"));
    }
    var tracker = new FileUploadTracker(context);
    int count = tracker.RenderCount++;

    name = name ?? "fileUpload";
    uploadText = uploadText ?? HelpersToolkitResources.FileUpload_Upload;
    addText = addText ?? HelpersToolkitResources.FileUpload_AddMore;


    if (allowMoreFilesToBeAdded && !tracker.ScriptAlreadyRendered) {
        tracker.ScriptAlreadyRendered = true;

        <script type="text/javascript"> 
            if (!window["FileUploadHelper"]) window["FileUploadHelper"] = {};  
            FileUploadHelper.addInputElement = function(index, name) {  
                var inputElem = document.createElement("input");  
                inputElem.type = "file";  
                inputElem.name = name;  
                var divElem = document.createElement("div");  
                divElem.appendChild(inputElem.cloneNode(false));   
                var inputs = document.getElementById("file-upload-" + index);  
                inputs.appendChild(divElem);  
            } 
        </script>
    }

    if (includeFormTag) {
        @:<form action="" enctype="multipart/form-data" method="post">
    }
    <div class="file-upload" id="file-upload-@(count)">
        @for(int i = 0; i < initialNumberOfFiles; i++) {
            <div>
                <input name="@name" type="file" />
            </div>
        }
    </div>

    if (allowMoreFilesToBeAdded || includeFormTag) {
        <div class="file-upload-buttons">
        @if (allowMoreFilesToBeAdded) {
            <a href="#" onclick="FileUploadHelper.addInputElement(@count, @HttpUtility.JavaScriptStringEncode(name, addDoubleQuotes: true)); return false;">@addText</a>
        }
        @if (includeFormTag) {
            <input type="submit" value="@uploadText" />
        }
        </div>
    }
    
    if (includeFormTag) {
        @:</form>
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/GamerCard.cshtml
================================================
@* Generator: WebPagesHelper *@

@using Microsoft.Internal.Web.Utils

@helper GetHtml(string gamerTag) {
    if (gamerTag.IsEmpty()) {
        throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "gamerTag");
    }
    <iframe frameborder="0" height="140" scrolling="no" src="http://gamercard.xbox.com/@(HttpUtility.UrlPathEncode(gamerTag)).card" width="204">@gamerTag</iframe>
}

================================================
FILE: src/Microsoft.Web.Helpers/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#GetInitializationScripts()", Justification = "It is analogous to the get pattern users are familiar with")]
[assembly: SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#GetFacebookUserProfile()", Justification = "It is analogous to the get pattern users are familiar with")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.Analytics", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.Bing", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.Facebook", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.FileUpload", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.GamerCard", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.LinkShare", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.Maps", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Scope = "type", Target = "Microsoft.Web.Helpers.ReCaptcha", Justification = "This is the default format in which helpers are generated.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LoginButton(System.String,System.String,System.String,System.String,System.Boolean,System.String,System.String,System.Boolean,System.String)", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "4#", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#OpenGraphRequiredProperties(System.String,System.String,System.String,System.String,System.String,System.String)", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LoginButton(System.String,System.String,System.String,System.String,System.Boolean,System.String,System.String,System.Boolean,System.String)", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LoginButton(System.String,System.String,System.String,System.String,System.Boolean,System.String,System.String,System.Boolean,System.String)", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Scope = "member", Target = "Microsoft.Web.Helpers.Bing.#SearchBox(System.String,System.String,System.String)", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "3#", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#OpenGraphRequiredProperties(System.String,System.String,System.String,System.String,System.String,System.String)", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "3#", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LiveStream(System.Int32,System.Int32,System.String,System.String,System.Boolean)", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Scope = "member", Target = "Microsoft.Web.Helpers.Bing.#SiteUrl", Justification = "We prefer strings to URIs for helpers")]
[assembly: SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", Scope = "type", Target = "Microsoft.Web.Helpers.Facebook+UserProfile", Justification = "The type is consumed but never instantiated by a user")]
[assembly: SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Scope = "member", Target = "Microsoft.Web.Helpers.Maps.#GetBingHtml(System.String,System.String,System.String,System.String,System.String,System.String,System.Int32,System.String,System.Boolean,System.String,System.Collections.Generic.IEnumerable`1<Microsoft.Web.Helpers.Maps+MapLocation>)", Justification = "We're printing a JSON value that needs to be lower case")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Facepile", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#Facepile(System.Int32,System.Int32)", Justification = "Facebook related term")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Fbml", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#FbmlNamespaces()", Justification = "Facebook related term")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "num", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#Comments(System.String,System.Int32,System.Int32,System.Boolean,System.Boolean)", Justification = "num is not Hungarian notation")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "xid", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#Comments(System.String,System.Int32,System.Int32,System.Boolean,System.Boolean)", Justification = "Facebook related term")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "xid", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LiveStream(System.Int32,System.Int32,System.String,System.String,System.Boolean)", Justification = "Facebook related term")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Re", Scope = "type", Target = "Microsoft.Web.Helpers.ReCaptcha")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Logout", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LoginButton(System.String,System.String,System.String,System.String,System.Boolean,System.String,System.String,System.Boolean,System.String)", Justification = "We use login and logout in WebMatrix.Security")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LoginButtonTagOnly(System.String,System.Boolean,System.String,System.String,System.String,System.Boolean,System.String)", Justification = "We use login and logout in WebMatrix.Security")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Logout", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LoginButtonTagOnly(System.String,System.Boolean,System.String,System.String,System.String,System.Boolean,System.String)", Justification = "We use login and logout in WebMatrix.Security")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#LoginButton(System.String,System.String,System.String,System.String,System.Boolean,System.String,System.String,System.Boolean,System.String)", Justification = "We use login and logout in WebMatrix.Security")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook.#MembershipLogin()", Justification = "We use login and logout in WebMatrix.Security")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Scope = "member", Target = "Microsoft.Web.Helpers.LinkShare.#BitlyLogin", Justification = "We use login and logout in WebMatrix.Security")]
[assembly: SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Scope = "member", Target = "Microsoft.Web.Helpers.Bing.#SiteUrl", Justification = "Property name is used instead of the generic term value to make it simpler to debug.")]
[assembly: SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Scope = "member", Target = "Microsoft.Web.Helpers.GamerCard.#GetHtml(System.String)")]
[assembly: SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Scope = "member", Target = "Microsoft.Web.Helpers.Bing.#SiteTitle", Justification = "Property name is used instead of the generic term value to make it simpler to debug.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook+UserProfile.#Updated_Time", Justification = "This is serailzed from a JSON schema, so member names have to be exactly this way.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook+UserProfile.#Last_Name", Justification = "This is serailzed from a JSON schema, so member names have to be exactly this way.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook+UserProfile.#First_Name", Justification = "This is serailzed from a JSON schema, so member names have to be exactly this way.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Timezone", Scope = "member", Target = "Microsoft.Web.Helpers.Facebook+UserProfile.#Timezone", Justification = "This is serailzed from a JSON schema, so member names have to be exactly this way.")]


================================================
FILE: src/Microsoft.Web.Helpers/Gravatar.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web;
using System.Web.Helpers;
using Microsoft.Internal.Web.Utils;
using Resources;

namespace Microsoft.Web.Helpers
{
    public static class Gravatar
    {
        private const string GravatarUrl = "http://www.gravatar.com/avatar/";

        // review - extract conversion of anonymous object to html attributes string into separate helper
        public static HtmlString GetHtml(string email, int imageSize = 80, string defaultImage = null,
                                         GravatarRating rating = GravatarRating.Default, string imageExtension = null, object attributes = null)
        {
            bool altSpecified = false;
            string url = GetUrl(email, imageSize, defaultImage, rating, imageExtension);
            StringBuilder html = new StringBuilder(String.Format(CultureInfo.InvariantCulture, "<img src=\"{0}\" ", url));
            if (attributes != null)
            {
                foreach (var p in attributes.GetType().GetProperties().OrderBy(p => p.Name))
                {
                    if (!p.Name.Equals("src", StringComparison.OrdinalIgnoreCase))
                    {
                        object value = p.GetValue(attributes, null);
                        if (value != null)
                        {
                            string encodedValue = HttpUtility.HtmlAttributeEncode(value.ToString());
                            html.Append(String.Format(CultureInfo.InvariantCulture, "{0}=\"{1}\" ", p.Name, encodedValue));
                        }
                        if (p.Name.Equals("alt", StringComparison.OrdinalIgnoreCase))
                        {
                            altSpecified = true;
                        }
                    }
                }
            }
            if (!altSpecified)
            {
                html.Append("alt=\"gravatar\" ");
            }
            html.Append("/>");
            return new HtmlString(html.ToString());
        }

        // See: http://en.gravatar.com/site/implement/url
        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "Strings are easier to work with for Plan9 scenario")]
        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Gravatar.com requires lowercase")]
        public static string GetUrl(string email, int imageSize = 80, string defaultImage = null,
                                    GravatarRating rating = GravatarRating.Default, string imageExtension = null)
        {
            if (String.IsNullOrEmpty(email))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "email");
            }
            if ((imageSize <= 0) || (imageSize > 512))
            {
                throw new ArgumentException(HelpersToolkitResources.Gravatar_InvalidImageSize, "imageSize");
            }

            StringBuilder url = new StringBuilder(GravatarUrl);
            email = email.Trim().ToLowerInvariant();
            url.Append(Crypto.Hash(email, algorithm: "md5").ToLowerInvariant());

            if (!String.IsNullOrEmpty(imageExtension))
            {
                if (!imageExtension.StartsWith(".", StringComparison.Ordinal))
                {
                    url.Append('.');
                }
                url.Append(imageExtension);
            }

            url.Append("?s=");
            url.Append(imageSize);

            if (rating != GravatarRating.Default)
            {
                url.Append("&r=");
                url.Append(rating.ToString().ToLowerInvariant());
            }

            if (!String.IsNullOrEmpty(defaultImage))
            {
                url.Append("&d=");
                url.Append(HttpUtility.UrlEncode(defaultImage));
            }

            return HttpUtility.HtmlAttributeEncode(url.ToString());
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/GravatarRating.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace Microsoft.Web.Helpers
{
    public enum GravatarRating
    {
        Default,
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "G", Justification = "Matches the gravatar.com rating. Suppressed in source because this is a one-time occurrence")]
        G,
        PG,
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "R", Justification = "Matches the gravatar.com rating. Suppressed in source because this is a one-time occurrence")]
        R,
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "X", Justification = "Matches the gravatar.com rating. Suppressed in source because this is a one-time occurrence")]
        X
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/LinkShare.cshtml
================================================
@* Generator: WebPagesHelper *@

@using System.Globalization
@using System.Text
@using System.Web.WebPages.Scope
@using Microsoft.Internal.Web.Utils
@using Resources;
@functions {
    internal static readonly object _bitlyApiKey = new object();
    internal static readonly object _bitlyLogin = new object();
    private static readonly Lazy<IEnumerable<LinkShareSite>> _allSites = new Lazy<IEnumerable<LinkShareSite>>(() =>
        from site in (LinkShareSite[])Enum.GetValues(typeof(LinkShareSite))
#pragma warning disable 0618
        where site != LinkShareSite.All
#pragma warning restore 0618
        select site
    );

    public static string BitlyApiKey {
        get {
            return ScopeStorage.CurrentScope[_bitlyApiKey] as string;
        }

        set {
            if (value == null) {
                throw new ArgumentNullException("value");
            }
            ScopeStorage.CurrentScope[_bitlyApiKey] = value;
        }
    }

    public static string BitlyLogin {
        get {
            return ScopeStorage.CurrentScope[_bitlyLogin] as string;
        }

        set {
            if (value == null) {
                throw new ArgumentNullException("value");
            }
            ScopeStorage.CurrentScope[_bitlyLogin] = value;
        }
    }

    private static string GetShortenedUrl(string pageLinkBack) {
        if (BitlyLogin.IsEmpty() || BitlyApiKey.IsEmpty()) {
            return pageLinkBack;
        }
        string encodedPageLinkBack = HttpUtility.UrlEncode(pageLinkBack);
        string key = "Bitly_pageLinkBack_" + BitlyApiKey + "_" + encodedPageLinkBack;
        string shortUrl = WebCache.Get(key) as string;
        if (shortUrl != null) {
            return shortUrl;
        }

        string bitlyReq = "http://api.bit.ly/v3/shorten?format=txt&longUrl=" + encodedPageLinkBack + "&login=" + BitlyLogin + "&apiKey=" + BitlyApiKey;
        try {
            shortUrl = GetWebResponse(bitlyReq);
        }
        catch (WebException) {
            return pageLinkBack;
        }
        if (shortUrl != null) {
            WebCache.Set(key, shortUrl);
            return shortUrl;
        }
        return pageLinkBack;
    }

    private static string GetWebResponse(string address) {
        WebRequest request = WebRequest.Create(address);
        request.Method = "GET";
        request.Timeout = 5 * 1000; //5 seconds
        using (var response = (HttpWebResponse)request.GetResponse()) {
            if (response.StatusCode != HttpStatusCode.OK) {
                return null;
            }
            using (Stream stream = response.GetResponseStream()) {
                using (MemoryStream memStream = new MemoryStream()) {
                    stream.CopyTo(memStream);
                    // Review: Should we use the ContentEncoding from response?
                    return Encoding.UTF8.GetString(memStream.ToArray());
                }
            }
        }
    }

    /// <summary>
    /// Returns an ordered list of LinkShareSite based on position of "All" parameter occurs in the list.
    /// </summary>
    /// <remarks>
    /// The LinkShareSite is accepted as a params array.
    /// In the event that no value is provided or the LinkShareSite.All is the first param, we display all the sites in the order they appear in the enum.
    /// If not, the items we look for the first occurence of LinkShareSite.All in the array. 
    /// The items that appear before this appear in the order they are specified. The All is replaced by all items in the enum that were not already specified by the user 
    /// in the order they appear in the enum.
    /// e.g.  sites = [] { Twitter, Facebook, Digg, All }
    /// Would result in returning {Twitter, Facebook, Digg, Delicious, Reddit, StumbleUpon} 
    /// </remarks>
    internal static IEnumerable<LinkShareSite> GetSitesInOrder(LinkShareSite[] linkSites) {
        var allSites = _allSites.Value;
        if (linkSites == null || !linkSites.Any() || linkSites.First() == LinkShareSite.All) {
            // Show all sites
            return allSites;
        }
        var result = linkSites.TakeWhile(c => c != LinkShareSite.All).ToList();
        if (result.Count != linkSites.Length) {
            return Enumerable.Concat(result, allSites.Except(result));
        }
        else {
            return result;
        }
    }

    private static void ConstructPageLinkBack(ref string pageLinkBack, out string shortenedUrl) {
        HttpContext context = HttpContext.Current;
        if ((pageLinkBack == null) && (context != null)) {
            pageLinkBack = context.Request.Url.GetComponents(UriComponents.SchemeAndServer | UriComponents.Path, UriFormat.Unescaped);
        }
        shortenedUrl = GetShortenedUrl(pageLinkBack);
    }
}

@helper GetHtml(string pageTitle,
    string pageLinkBack = null,
    string twitterUserName = null,
    string additionalTweetText = null,
    params LinkShareSite[] linkSites) {

    if (pageTitle.IsEmpty()) {
        throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "pageTitle"), "pageTitle");
    }

    string shortenedUrl;
    ConstructPageLinkBack(ref pageLinkBack, out shortenedUrl);

    pageLinkBack = HttpUtility.UrlEncode(pageLinkBack);
    shortenedUrl = HttpUtility.UrlEncode(shortenedUrl);
    pageTitle = HttpUtility.UrlEncode(pageTitle);

    foreach (var site in GetSitesInOrder(linkSites)) {
        switch (site) {
            case LinkShareSite.Delicious:
                <a href="http://delicious.com/save?v=5&amp;noui&amp;jump=close&amp;url=@(shortenedUrl)&amp;title=@(pageTitle)" target="_blank" title="Add to del.icio.us">
                    <img alt="Add to del.icio.us" src="https://delicious.com/favicon.ico" style="border:0; height:16px; width:16px; margin:0 1px;" title="Add to del.icio.us" /></a>
                break;

            case LinkShareSite.Digg:
                <a href="http://digg.com/submit?url=@(pageLinkBack)&amp;title=@(pageTitle)" target="_blank" title="Digg!">
                    <img alt="Digg!" src="http://digg.com/favicon.ico" style="border:0; height:16px; width:16px; margin:0 1px;" title="Digg!" /></a>
                break;
            case LinkShareSite.Facebook:
                <a href="http://www.facebook.com/sharer.php?u=@(shortenedUrl)&amp;t=@(pageTitle)" target="_blank" title="Share on Facebook">
                    <img alt="Share on Facebook" src="http://facebook.com/favicon.ico" style="border:0; height:16px; width:16px; margin:0 1px;" title="Share on Facebook" /></a>
                break;
            case LinkShareSite.Reddit:
                <a href="http://reddit.com/submit?url=@(pageLinkBack)&amp;title=@(pageTitle)" target="_blank" title="Reddit!">
                    <img alt="Reddit!" src="http://www.reddit.com/favicon.ico" style="border:0; height:16px; width:16px; margin:0 1px;" title="Reddit!" /></a>
                break;
            case LinkShareSite.StumbleUpon:
                <a href="http://www.stumbleupon.com/submit?url=@(pageLinkBack)&amp;title=@(pageTitle)" target="_blank" title="Stumble it!">
                    <img alt="Stumble it!" src="http://stumbleupon.com/favicon.ico" style="border:0; height:16px; width:16px; margin:0 1px;" title="Stumble it!" /></a>
                break;            
            case LinkShareSite.Twitter:
                string status = String.Empty;
                if (!twitterUserName.IsEmpty()) {
                    status += ", (via @@" + twitterUserName + ")";
                }
                if (!additionalTweetText.IsEmpty()) {
                    status += ' ' + additionalTweetText;
                }
                status = HttpUtility.UrlEncode(status);
                <a href="http://twitter.com/home/?status=@(pageTitle)%3a+@(shortenedUrl)@(status)" target="_blank" title="Share on Twitter">
                    <img alt="Share on Twitter" src="http://twitter.com/favicon.ico" style="border:0; height:16px; width:16px; margin:0 1px;" title="Share on Twitter" />
                </a>
                break;
            default:
                throw new NotSupportedException(String.Format(CultureInfo.CurrentUICulture, HelpersToolkitResources.LinkShareValue_NotSupported, site));                
        }
    }
}

================================================
FILE: src/Microsoft.Web.Helpers/LinkShareSite.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
namespace Microsoft.Web.Helpers
{
    public enum LinkShareSite
    {
        Delicious = 0,
        Digg = 1,
        // GoogleBuzz = 2, has been deprecated
        Facebook = 3,
        Reddit = 4,
        StumbleUpon = 5,
        Twitter = 6,
        All = 7,
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/Maps.cshtml
================================================
@* Generator : WebPagesHelper *@

@using System.Diagnostics
@using System.Web.WebPages.Scope
@using System.Web.UI.WebControls
@using System.Globalization
@using Microsoft.Internal.Web.Utils

@functions {
    private const string DefaultWidth = "300px";
    private const string DefaultHeight = "300px";
    private static readonly object _mapIdKey = new object();
    private static readonly object _mapQuestApiKey = new object();
    private static readonly object _bingApiKey = new object();
    private static readonly object _yahooApiKey = new object();

    public static string MapQuestApiKey {
        get {
            return (string)ScopeStorage.CurrentScope[_mapQuestApiKey];
        }
        set {
            ScopeStorage.CurrentScope[_mapQuestApiKey] = value;
        }
    }

    public static string YahooApiKey {
        get {
            return (string)ScopeStorage.CurrentScope[_yahooApiKey];
        }
        set {
            ScopeStorage.CurrentScope[_yahooApiKey] = value;
        }
    }

    public static string BingApiKey {
        get {
            return (string)ScopeStorage.CurrentScope[_bingApiKey];
        }
        set {
            ScopeStorage.CurrentScope[_bingApiKey] = value;
        }
    }

    // allow for stubbing this static resource in tests
    private static Func<HttpContextBase> _getCurrentHttpContext = (Func<HttpContextBase>)(() => new HttpContextWrapper(HttpContext.Current));
    internal static Func<HttpContextBase> GetCurrentHttpContext {
        private get {
            return _getCurrentHttpContext;
        }
        set {
            _getCurrentHttpContext = value;
        }
    }

    private static int MapId {
        get {
            var value = (int?)(GetCurrentHttpContext().Items[_mapIdKey]);
            return value.GetValueOrDefault();
        }
        set {
            GetCurrentHttpContext().Items[_mapIdKey] = value;
        }
    }
    
    private static string GetMapElementId() {
        return "map_" + MapId;   
    }
    
    private static string TryParseUnit(string value, string defaultValue) {
        if (String.IsNullOrEmpty(value)) {
            return defaultValue;
        }
        try {
            return Unit.Parse(value, CultureInfo.InvariantCulture).ToString(CultureInfo.InvariantCulture);
        } catch (ArgumentException) {
            return defaultValue;    
        }    
    }

    private static IHtmlString RawJS(string text) {
        return Raw(HttpUtility.JavaScriptStringEncode(text));
    }
    
    private static IHtmlString Raw(string text) {
        return new HtmlString(text);    
    }
    
    private static string GetApiKey(string apiKey, object scopeStorageKey) {
        if (apiKey.IsEmpty()) {
            return (string)ScopeStorage.CurrentScope[scopeStorageKey];   
        }
        return apiKey;   
    }

    public class MapLocation {
        private readonly string _latitude;
        private readonly string _longitude;
        public MapLocation(string latitude, string longitude) {
            _latitude = latitude;
            _longitude = longitude;
        }

        public string Latitude {
            get { return _latitude; }
        }

        public string Longitude {
            get { return _longitude; }
        }
    }

    internal static string GetDirectionsQuery(string location, string latitude, string longitude, Func<string, string> encoder = null) {
        encoder = encoder ?? HttpUtility.UrlEncode;
        Debug.Assert(!(location.IsEmpty() && latitude.IsEmpty() && longitude.IsEmpty()));
        if (location.IsEmpty()) {
            return encoder(latitude + "," + longitude);
        }
        return encoder(location);
    }
}

@**
Summary:
    Generates Html to display a Map Quest map.
Parameter:
    key: Map Quest API key
Parameter location:
    Address of the location to center the map at
Parameter latitude:
    Latitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter longitude:
    Longitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter width: 
    Width of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter height: 
    Height of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter zoom:
    Initial zoom level of the map. Defaults to 7.
Parameter type:
    Map type to display. Valid values are "map", "sat" or "hyb".
Parameter showDirectionsLink:
    Determines if a link to get directions should be displayed when a location is specified. Defaults to true.
Parameter directionsLinkText
    The text for the get directions link. Defaults to "Get Directions".
**@
@helper GetMapQuestHtml(string key = null, string location = null, string latitude = null, string longitude = null, string width = "300px", string height = "300px", int zoom = 7, string type = "map",
            bool showDirectionsLink = true, string directionsLinkText = "Get Directions", bool showZoomControl = true, IEnumerable<MapLocation> pushpins = null) {
    key = GetApiKey(key, _mapQuestApiKey);
    if (key.IsEmpty()) {
        throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "key");  
    }
    
    string mapElement = GetMapElementId();
    string loc = "null"; // We want to print the value 'null' in the client
    if (latitude != null && longitude != null) {
        loc = String.Format(CultureInfo.InvariantCulture, "{{lat: {0}, lng: {1}}}",
            HttpUtility.JavaScriptStringEncode(latitude, addDoubleQuotes: false), HttpUtility.JavaScriptStringEncode(longitude, addDoubleQuotes: false));
    }

    // The MapQuest key listed on their website is Url encoded to begin with. 
    <script src="http://mapquestapi.com/sdk/js/v6.0.0/mqa.toolkit.js?key=@key" type="text/javascript"></script>
    <script type="text/javascript">
        MQA.EventUtil.observe(window, 'load', function() {
            var map = new MQA.TileMap(document.getElementById('@mapElement'), @zoom, @Raw(loc), '@RawJS(type)'); 
            @if (showZoomControl) {
            <text>
                MQA.withModule('zoomcontrol3', function() {
	                map.addControl(new MQA.LargeZoomControl3(), new MQA.MapCornerPlacement(MQA.MapCorner.TOP_LEFT));
                });
            </text>
            }
            @if (!String.IsNullOrEmpty(location)) {
            <text>
                MQA.withModule('geocoder', function() {
                    map.geocodeAndAddLocations('@RawJS(location)');
                });
            </text>
            }
            @if (pushpins != null) {
                foreach (var p in pushpins) {
                    @: map.addShape(new MQA.Poi({lat:@RawJS(p.Latitude),lng:@RawJS(p.Longitude)}));
	            }
            }
        });
    </script>
    
    <div id="@mapElement" style="width:@TryParseUnit(width, DefaultWidth); height:@TryParseUnit(height, DefaultHeight);">
    </div>
    if (showDirectionsLink) {
        <a class="map-link" href="http://www.mapquest.com/?q=@GetDirectionsQuery(location, latitude, longitude)">@directionsLinkText</a>
    }
    MapId++;
}

@**
Summary:
    Generates Html to display Bing map.
Parameter:
    key: Bing Maps application key
Parameter location:
    Address of the location to center the map at
Parameter latitude:
    Latitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter longitude:
    Longitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter width: 
    Width of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter height: 
    Height of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter zoom:
    Initial zoom level of the map. Defaults to 14.
Parameter type:
    Map type to display. Valid values are "auto", "aerial", "birdeye", "road" and "mercator".
Parameter useAdaptiveOverlay:
    Determines if the map overlay that adapts to the colors of the current map view is used. Defaults to true.
Parameter showDirectionsLink:
    Determines if a link to get directions should be displayed when a location is specified. Defaults to true.
Parameter directionsLinkText
    The text for the get directions link. Defaults to "Get Directions".
**@
@helper GetBingHtml(string key = null, string location = null, string latitude = null, string longitude = null, string width = null, string height = null, int zoom = 14, string type = "auto",
            bool useAdaptiveOverlay = true, bool showDirectionsLink = true, string directionsLinkText = "Get Directions", IEnumerable<MapLocation> pushpins = null) {
    key = GetApiKey(key, _bingApiKey);
    if (key.IsEmpty()) {
        throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "key");
    } 
    string mapElement = GetMapElementId();
    
    type = (type ?? "auto").ToLowerInvariant();

    <script src="http://ecn.dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=7.0" type="text/javascript"></script>
    <script type="text/javascript">
        jQuery(window).load(function() { 
            var map = null;
            @if (useAdaptiveOverlay) {
                <text>
                Microsoft.Maps.loadModule('Microsoft.Maps.Overlays.Style', {
                    callback: function () {
                        map = new Microsoft.Maps.Map(document.getElementById("@mapElement"), { credentials: '@RawJS(key)', mapTypeId: Microsoft.Maps.MapTypeId['@RawJS(type)'], customizeOverlays: true });

                </text>
            } else {
                <text>
                map = new Microsoft.Maps.Map(document.getElementById("@mapElement"), { credentials: '@RawJS(key)', mapTypeId: Microsoft.Maps.MapTypeId['@RawJS(type)'] });
                </text>
            }
            @if (latitude != null && longitude != null) {
                @: map.setView({zoom: @zoom, center: new Microsoft.Maps.Location(@RawJS(latitude), @RawJS(longitude))});
            }
            else if (location != null) {
                <text>
                map.getCredentials(function(credentials) {
                    $.ajax({
                        url: 'http://dev.virtualearth.net/REST/v1/Locations/' + encodeURI('@RawJS(location)'),
                        type: 'GET',
                        crossDomain: true,
                        data: { output: 'json', key: credentials }, dataType: 'jsonp', jsonp: 'jsonp',
                        success: function(data) {
                            if (data && data.resourceSets && data.resourceSets.length > 0 && data.resourceSets[0].resources && data.resourceSets[0].resources.length > 0) {
                                var r = data.resourceSets[0].resources[0].point.coordinates;
                                var loc = new Microsoft.Maps.Location(r[0], r[1]);
                                map.setView({zoom: @zoom, center: loc});              
                                map.entities.push(new Microsoft.Maps.Pushpin(loc, null));
                            }
                        }
                    });
                });
                </text>
            }
            @if (pushpins != null) {
                foreach(var loc in pushpins) {
                    @: map.entities.push(new Microsoft.Maps.Pushpin(new Microsoft.Maps.Location(@RawJS(loc.Latitude), @RawJS(loc.Longitude)), null));
                }
            }
            @if (useAdaptiveOverlay) {
                <text>
                    }
                });
                </text>
            }
        });
    </script>
    
    <div class="map" id="@mapElement" style="position:relative; width:@TryParseUnit(width, DefaultWidth); height:@TryParseUnit(height, DefaultHeight);">
    </div>
    if (showDirectionsLink) {
        // Review: Need to figure out if the link needs to be localized. 
        <a class="map-link" href="http://www.bing.com/maps/?v=2&where1=@GetDirectionsQuery(location, latitude, longitude)">@directionsLinkText</a>
    }
    MapId++;
}

@**
Summary:
    Generates Html to display a Google map.
Parameter location:
    Address of the location to center the map at
Parameter latitude:
    Latitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter longitude:
    Longitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter width: 
    Width of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter height: 
    Height of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter zoom:
    Initial zoom level of the map. Defaults to 14.
Parameter type:
    Map type to display. Valid values are "ROADMAP", "HYBRID", "SATELLITE" and "TERRAIN".
Parameter showDirectionsLink:
    Determines if a link to get directions should be displayed when a location is specified. Defaults to true.
Parameter directionsLinkText
    The text for the get directions link. Defaults to "Get Directions".
**@
@helper GetGoogleHtml(string location = null, string latitude = null, string longitude = null, string width = null, string height = null, int zoom = 14, string type = "ROADMAP",
                bool showDirectionsLink = true, string directionsLinkText = "Get Directions", IEnumerable<MapLocation> pushpins = null) {
    string mapElement = GetMapElementId();
    type = (type ?? "ROADMAP").ToUpperInvariant(); // Map types are in upper case

    // Google maps does not support null centers. We'll set it to arbitrary values if they are null and only the location is provided.
    // These locations are somewhere around Microsoft's Redmond Campus.
    latitude = latitude ?? "47.652437";
    longitude = longitude ?? "-122.132424";

    <script src="http://maps.google.com/maps/api/js?sensor=false" type="text/javascript"></script>
    <script type="text/javascript">
        $(function() {
            var map = new google.maps.Map(document.getElementById("@mapElement"), { zoom: @zoom, center: new google.maps.LatLng(@RawJS(latitude), @RawJS(longitude)), mapTypeId: google.maps.MapTypeId['@RawJS(type)'] });
            @if (!String.IsNullOrEmpty(location)) {
                <text>
                new google.maps.Geocoder().geocode({address: '@RawJS(location)'}, function(response, status) {
                    if (status === google.maps.GeocoderStatus.OK) {
                        var best = response[0].geometry.location;
                        map.panTo(best);
                        new google.maps.Marker({map : map, position: best });
                    }
                });
                </text>
            }
            @if (pushpins != null) {
                foreach(var loc in pushpins) {
                    @: new google.maps.Marker({map : map, position: new google.maps.LatLng(@RawJS(loc.Latitude), @RawJS(loc.Longitude))});
                }
            }
        });
    </script>
    
    <div class="map" id="@mapElement" style="width:@TryParseUnit(width, DefaultWidth); height:@TryParseUnit(height, DefaultHeight);">
    </div>
    if (showDirectionsLink) {
        <a class="map-link" href="http://maps.google.com/maps?q=@GetDirectionsQuery(location, latitude, longitude)">@directionsLinkText</a>
    }
    MapId++;
}

@**
Summary:
    Generates Html to display a Yahoo map.
Parameter:
    key: Yahoo application ID
Parameter location:
    Address of the location to center the map at
Parameter latitude:
    Latitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter longitude:
    Longitude to center on. If both latitude and longitude are specified, location is ignored.
Parameter width: 
    Width of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter height: 
    Height of the map with units such as 480px, 100% etc. Defaults to 300px.
Parameter zoom:
    Initial zoom level of the map. Defaults to 4.
Parameter type:
    Map type to display. Valid values are "YAHOO_MAP_SAT", "YAHOO_MAP_HYB" and "YAHOO_MAP_REG". 
Parameter showDirectionsLink:
    Determines if a link to get directions should be displayed when a location is specified. Defaults to true.
Parameter directionsLinkText
    The text for the get directions link. Defaults to "Get Directions".
**@
@helper GetYahooHtml(string key = null, string location = null, string latitude = null, string longitude = null, string width = null, string height = null, int zoom = 4, string type = "YAHOO_MAP_REG",
                bool showDirectionsLink = true, string directionsLinkText = "Get Directions", IEnumerable<MapLocation> pushpins = null) {
    key = GetApiKey(key, _yahooApiKey);
    if (key.IsEmpty()) {
        throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "key");
    }                     
    string mapElement = GetMapElementId();

    <script src="http://api.maps.yahoo.com/ajaxymap?v=3.8&appid=@HttpUtility.UrlEncode(key)" type="text/javascript"></script>
    <script type="text/javascript">
        $(function() {
            var map = new YMap(document.getElementById('@RawJS(mapElement)'));  
            map.addTypeControl();  
            map.setMapType(@RawJS(type));  
            @if (latitude != null && longitude != null) {
                @: map.drawZoomAndCenter(new YGeoPoint(@RawJS(latitude), @RawJS(longitude)), @zoom);
            }
            else if (!String.IsNullOrEmpty(location)) {
                @: map.drawZoomAndCenter('@RawJS(location)', @zoom);
            }
            else {
                @: map.setZoomLevel(@zoom);
            }
            @if(pushpins != null) {
                foreach (var loc in pushpins) {
                     @: map.addMarker(new YGeoPoint(@RawJS(loc.Latitude), @RawJS(loc.Longitude)));
                 }
            }

        });
    </script>
    
    <div id="@mapElement" style="width:@TryParseUnit(width, DefaultWidth); height:@TryParseUnit(height, DefaultHeight);">
    </div>
    if (showDirectionsLink) {
        <a class="map-link" href="http://maps.yahoo.com/#q1=@GetDirectionsQuery(location, latitude, longitude, HttpUtility.UrlPathEncode)">@directionsLinkText</a>
    }
    MapId++;
}



================================================
FILE: src/Microsoft.Web.Helpers/Microsoft.Web.Helpers.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{0C7CE809-0F72-4C19-8C64-D6573E4D9521}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.Web.Helpers</RootNamespace>
    <AssemblyName>Microsoft.Web.Helpers</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\WebHelpers.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.ApplicationServices" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="Gravatar.cs" />
    <Compile Include="GravatarRating.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="Resources\HelpersToolkitResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>HelpersToolkitResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Themes.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ThemesImplementation.cs" />
    <Compile Include="Video.cs" />
    <Compile Include="VirtualPathUtilityBase.cs" />
    <Compile Include="VirtualPathUtilityWrapper.cs" />
    <Compile Include="UrlBuilder.cs" />
    <Compile Include="LinkShareSite.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\HelpersToolkitResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>HelpersToolkitResources.Designer.cs</LastGenOutput>
      <CustomToolNamespace>Resources</CustomToolNamespace>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9B7E3740-6161-4548-833C-4BBCA43B970E}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\WebMatrix.Data\WebMatrix.Data.csproj">
      <Project>{4D39BAAF-8A96-473E-AB79-C8A341885137}</Project>
      <Name>WebMatrix.Data</Name>
    </ProjectReference>
    <ProjectReference Include="..\WebMatrix.WebData\WebMatrix.WebData.csproj">
      <Project>{55A15F40-1435-4248-A7F2-2A146BB83586}</Project>
      <Name>WebMatrix.WebData</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
    <RazorSrcFiles Include="Analytics.cshtml" />
    <RazorSrcFiles Include="FileUpload.cshtml" />
    <RazorSrcFiles Include="GamerCard.cshtml" />
    <RazorSrcFiles Include="LinkShare.cshtml" />
    <RazorSrcFiles Include="ReCaptcha.cshtml" />
    <RazorSrcFiles Include="Facebook.cshtml" />
    <RazorSrcFiles Include="Maps.cshtml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  
  <!-- Note: RazorGenerator.MsBuild uses Razor 3.0 \ Mvc 5.0 for generating views. In the event we update the Mvc parser, we'll need to ensure this package references the updated Mvc build -->
  <Import Project="..\..\packages\RazorGenerator.MsBuild.2.2.0\build\RazorGenerator.MsBuild.targets" Condition="Exists('..\..\packages\RazorGenerator.MsBuild.2.2.0\build\RazorGenerator.MsBuild.targets')" />
</Project>

================================================
FILE: src/Microsoft.Web.Helpers/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.WebPages.Razor;

namespace Microsoft.Web.Helpers
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        private static bool _startWasCalled;

        public static void Start()
        {
            // Even though ASP.NET will only call each PreAppStart once, we sometimes internally call one PreAppStart from 
            // another PreAppStart to ensure that things get initialized in the right order. ASP.NET does not guarantee the 
            // order so we have to guard against multiple calls.
            // All Start calls are made on same thread, so no lock needed here.

            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            // Auto import the Microsoft.Web.Helpers namespace to all apps that are executing.
            WebPageRazorHost.AddGlobalImport(typeof(PreApplicationStartCode).Namespace);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using Microsoft.Web.Helpers;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("Microsoft.Web.Helpers")]
[assembly: AssemblyDescription("")]
[assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]
[assembly: InternalsVisibleTo("Microsoft.Web.Helpers.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/Microsoft.Web.Helpers/ReCaptcha.cshtml
================================================
@* Generator: WebPagesHelper *@

@using System
@using System.Globalization
@using System.IO
@using System.Text
@using System.Web.WebPages.Scope
@using Microsoft.Internal.Web.Utils
@using Resources

@functions{
    private const string _reCaptchaUrl = "http://www.google.com/recaptcha/api";
    private const string _reCaptchaSecureUrl = "https://www.google.com/recaptcha/api";
    private static readonly object _errorCodeCacheKey = new object();
    internal static readonly object _privateKey = new object();
    internal static readonly object _publicKey = new object();
    
    public static string PrivateKey {
        get {
            return ScopeStorage.CurrentScope[_privateKey] as string;
        }

        set {
            if (value == null) {
                throw new ArgumentNullException("value");
            }
            ScopeStorage.CurrentScope[_privateKey] = value;
        }
    }

    public static string PublicKey {
        get {
            return ScopeStorage.CurrentScope[_publicKey] as string;
        }

        set {
            if (value == null) {
                throw new ArgumentNullException("value");
            }
            ScopeStorage.CurrentScope[_publicKey] = value;
        }
    }
    
    public static bool Validate(string privateKey = null) {
        return Validate(HttpContext.Current == null ? null : new HttpContextWrapper(HttpContext.Current), privateKey, UrlBuilder.DefaultVirtualPathUtility);
    }   

    internal static string GetLastError(HttpContextBase context) {
        if (context.Items.Contains(_errorCodeCacheKey)) {
            return context.Items[_errorCodeCacheKey] as string;
        }
        return String.Empty;
    }
    
    internal static bool Validate(HttpContextBase context, string privateKey, VirtualPathUtilityBase virtualPathUtility) {
        privateKey = privateKey ?? PrivateKey;

        if (String.IsNullOrEmpty(privateKey)) {
            throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "privateKey");
        }

        SetLastError(context, String.Empty);
        string postedBody = GetValidatePostData(context, privateKey, virtualPathUtility);
        if (String.IsNullOrEmpty(postedBody)) {
            return false;
        }
        string result = ExecuteValidateRequest(postedBody);
        return HandleValidateResponse(context, result);
    }

    internal static string GetValidatePostData(HttpContextBase context, string privateKey, VirtualPathUtilityBase virtualPathUtility) {
        string remoteIP = context.Request.ServerVariables["REMOTE_ADDR"];
        if (String.IsNullOrEmpty(remoteIP)) {
            throw new InvalidOperationException(HelpersToolkitResources.ReCaptcha_RemoteIPNotFound);
        }

        // Noscript rendering requires the user to copy and paste the challenge string to a textarea.
        // When the challenge is invalid the recaptcha service doesn't return an error that affects
        // UI rendering, so Validate should just return false without issuing the web request.
        string challenge = context.Request.Form["recaptcha_challenge_field"];
        if (String.IsNullOrEmpty(challenge)) {
            return String.Empty;
        }
        string response = (context.Request.Form["recaptcha_response_field"] ?? String.Empty).Trim();

        var builder = new UrlBuilder(context, virtualPathUtility, path: null, parameters: null)
                .AddParam("privatekey", privateKey)
                .AddParam("remoteip", context.Request.ServerVariables["REMOTE_ADDR"])
                .AddParam("challenge", challenge)
                .AddParam("response", response);
        
        // Trim the leading ? and return the QueryString
        return builder.QueryString.Substring(1);
    }

    internal static bool HandleValidateResponse(HttpContextBase context, string response) {
        if (!String.IsNullOrEmpty(response)) {
            string[] results = response.Split('\n');
            if (results.Length > 0) {
                bool rval = Convert.ToBoolean(results[0], CultureInfo.InvariantCulture);
                if (!rval && (results.Length > 1)) {
                    SetLastError(context, results[1]);
                }
                return rval;
            }
        }
        return false;
    }

    internal static string GetChallengeUrl(HttpContextBase httpContext, string publicKey = null, string errorCode = null) {
        return GetUrlHelper(httpContext, "challenge", publicKey, errorCode: errorCode);
    }

    private static string ExecuteValidateRequest(string formData) {
        WebRequest request = WebRequest.Create(_reCaptchaUrl + "/verify");
        request.Method = "POST";
        request.Timeout = 5000; //milliseconds
        request.ContentType = "application/x-www-form-urlencoded";

        byte[] content = Encoding.UTF8.GetBytes(formData);
        using (Stream stream = request.GetRequestStream()) {
            stream.Write(content, 0, content.Length);
        }
        using (WebResponse response = request.GetResponse()) {
            using (StreamReader reader = new StreamReader(response.GetResponseStream())) {
                return reader.ReadToEnd();
            }
        }
    }

    private static string GetUrlHelper(HttpContextBase context, string path, string publicKey, string errorCode) {

        publicKey = publicKey ?? PublicKey;
        if (String.IsNullOrEmpty(publicKey)) {
            throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "publicKey");
        }

        var builder = new UrlBuilder(context.Request.IsSecureConnection ? _reCaptchaSecureUrl : _reCaptchaUrl);
        builder.AddPath(path);
        builder.AddParam("k", publicKey);
        if (!String.IsNullOrEmpty(errorCode)) {
            builder.AddParam("error", errorCode);
        }
        return builder;
    }

    private static void SetLastError(HttpContextBase context, string value) {
        context.Items[_errorCodeCacheKey] = value;
    }
}

@helper GetHtml(string publicKey = null, string theme = "red", 
    string language = "en", int tabIndex = 0) {

    @GetHtmlWithOptions(publicKey, options: new Dictionary<string, object>() {
        { "theme", theme }, { "lang", language }, { "tabindex", tabIndex }
    })
}

@helper GetHtmlWithOptions(string publicKey = null, object options = null) {
    @GetHtml(HttpContext.Current == null ? null : new HttpContextWrapper(HttpContext.Current), publicKey, options)
}

@helper GetHtml(HttpContextBase httpContext, string publicKey = null, object options = null) {
    if (options != null) {
        var optionJson = new HtmlString(Json.Encode(options));
        <script type="text/javascript">
            var RecaptchaOptions=@optionJson;
        </script>
    }
    <script src="@GetChallengeUrl(httpContext, publicKey, GetLastError(httpContext))" type="text/javascript"></script>

    <noscript>
        <iframe frameborder="0" height="300px" src="@GetUrlHelper(httpContext, "noscript", publicKey, errorCode: null)" width="500px"></iframe>
        <br /><br />
        <textarea cols="40" name="recaptcha_challenge_field" rows="3"></textarea>
        <input name="recaptcha_response_field" type="hidden" value="manual_challenge" />
    </noscript>
}


================================================
FILE: src/Microsoft.Web.Helpers/Resources/HelpersToolkitResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18051
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class HelpersToolkitResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal HelpersToolkitResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Web.Helpers.Resources.HelpersToolkitResources", typeof(HelpersToolkitResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add more files.
        /// </summary>
        internal static string FileUpload_AddMore {
            get {
                return ResourceManager.GetString("FileUpload_AddMore", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Upload.
        /// </summary>
        internal static string FileUpload_Upload {
            get {
                return ResourceManager.GetString("FileUpload_Upload", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Gravatar image size must be between 1 and 512 pixels..
        /// </summary>
        internal static string Gravatar_InvalidImageSize {
            get {
                return ResourceManager.GetString("Gravatar_InvalidImageSize", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LinkShare value {0} is not supported by the Link Share helper. .
        /// </summary>
        internal static string LinkShareValue_NotSupported {
            get {
                return ResourceManager.GetString("LinkShareValue_NotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The captcha cannot be validated because the remote address was not found in the request..
        /// </summary>
        internal static string ReCaptcha_RemoteIPNotFound {
            get {
                return ResourceManager.GetString("ReCaptcha_RemoteIPNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You cannot have a null folder. Try using Themes.GetResourcePath(string fileName) instead if you do not want to specify a folder..
        /// </summary>
        internal static string Themes_FolderCannotBeNull {
            get {
                return ResourceManager.GetString("Themes_FolderCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unknown theme &apos;{0}&apos;. Ensure that a directory labeled &apos;{0}&apos; exists under the theme directory..
        /// </summary>
        internal static string Themes_InvalidTheme {
            get {
                return ResourceManager.GetString("Themes_InvalidTheme", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You must call the &quot;Themes.Initialize&quot; method before you call any other method of the &quot;Themes&quot; class..
        /// </summary>
        internal static string Themes_NotInitialized {
            get {
                return ResourceManager.GetString("Themes_NotInitialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The media file &quot;{0}&quot; does not exist..
        /// </summary>
        internal static string Video_FileDoesNotExist {
            get {
                return ResourceManager.GetString("Video_FileDoesNotExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property &quot;{0}&quot; cannot be set through this argument..
        /// </summary>
        internal static string Video_PropertyCannotBeSet {
            get {
                return ResourceManager.GetString("Video_PropertyCannotBeSet", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/Resources/HelpersToolkitResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="FileUpload_AddMore" xml:space="preserve">
    <value>Add more files</value>
  </data>
  <data name="FileUpload_Upload" xml:space="preserve">
    <value>Upload</value>
  </data>
  <data name="Gravatar_InvalidImageSize" xml:space="preserve">
    <value>The Gravatar image size must be between 1 and 512 pixels.</value>
  </data>
  <data name="LinkShareValue_NotSupported" xml:space="preserve">
    <value>LinkShare value {0} is not supported by the Link Share helper. </value>
  </data>
  <data name="ReCaptcha_RemoteIPNotFound" xml:space="preserve">
    <value>The captcha cannot be validated because the remote address was not found in the request.</value>
  </data>
  <data name="Themes_FolderCannotBeNull" xml:space="preserve">
    <value>You cannot have a null folder. Try using Themes.GetResourcePath(string fileName) instead if you do not want to specify a folder.</value>
  </data>
  <data name="Themes_InvalidTheme" xml:space="preserve">
    <value>Unknown theme '{0}'. Ensure that a directory labeled '{0}' exists under the theme directory.</value>
  </data>
  <data name="Themes_NotInitialized" xml:space="preserve">
    <value>You must call the "Themes.Initialize" method before you call any other method of the "Themes" class.</value>
  </data>
  <data name="Video_FileDoesNotExist" xml:space="preserve">
    <value>The media file "{0}" does not exist.</value>
  </data>
  <data name="Video_PropertyCannotBeSet" xml:space="preserve">
    <value>Property "{0}" cannot be set through this argument.</value>
  </data>
</root>

================================================
FILE: src/Microsoft.Web.Helpers/Themes.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Web.Hosting;
using System.Web.WebPages.Scope;

namespace Microsoft.Web.Helpers
{
    public static class Themes
    {
        public static string ThemeDirectory
        {
            get { return Implementation.ThemeDirectory; }
        }

        public static string CurrentTheme
        {
            get { return Implementation.CurrentTheme; }
            set { Implementation.CurrentTheme = value; }
        }

        public static string DefaultTheme
        {
            get { return Implementation.DefaultTheme; }
        }

        public static ReadOnlyCollection<string> AvailableThemes
        {
            get { return Implementation.AvailableThemes; }
        }

        private static ThemesImplementation Implementation
        {
            get { return new ThemesImplementation(HostingEnvironment.VirtualPathProvider, ScopeStorage.CurrentScope); }
        }

        public static void Initialize(string themeDirectory, string defaultTheme)
        {
            Implementation.Initialize(themeDirectory, defaultTheme);
        }

        /// <summary>
        /// Get a file that lives directly inside the theme directory
        /// </summary>
        /// <param name="fileName">The filename to look for</param>
        /// <returns>The full path to the file that matches the requested file</returns>
        public static string GetResourcePath(string fileName)
        {
            return Implementation.GetResourcePath(fileName);
        }

        public static string GetResourcePath(string folder, string fileName)
        {
            return Implementation.GetResourcePath(folder, fileName);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/ThemesImplementation.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Hosting;
using Microsoft.Internal.Web.Utils;
using Resources;

namespace Microsoft.Web.Helpers
{
    internal class ThemesImplementation
    {
        internal static readonly object CurrentThemeKey = new object();
        internal static readonly object ThemeDirectoryKey = new object();
        internal static readonly object DefaultThemeKey = new object();
        internal static readonly object ThemesInitializedKey = new object();
        private readonly VirtualPathProvider _vpp;
        private readonly IDictionary<object, object> _currentScope;

        public ThemesImplementation(VirtualPathProvider vpp, IDictionary<object, object> scopeStorage)
        {
            _vpp = vpp;
            _currentScope = scopeStorage;
        }

        public string ThemeDirectory
        {
            get
            {
                EnsureInitialized();
                return (string)_currentScope[ThemeDirectoryKey];
            }
            private set
            {
                Debug.Assert(value != null);
                _currentScope[ThemeDirectoryKey] = value;
            }
        }

        /// <summary>
        /// This should live throughout the application life cycle
        /// and be set in _appstart.cshtml
        /// </summary>
        public string DefaultTheme
        {
            get
            {
                EnsureInitialized();
                return (string)_currentScope[DefaultThemeKey];
            }
            private set
            {
                Debug.Assert(value != null);
                _currentScope[DefaultThemeKey] = value;
            }
        }

        /// <summary>
        /// The current theme to use. When this is set,
        /// all GetResource checks will check if the CurrentTheme
        /// contains the file, and if it doesn't it will fall back to
        /// the DefaultTheme
        /// </summary>
        public string CurrentTheme
        {
            get
            {
                EnsureInitialized();
                return (string)_currentScope[CurrentThemeKey] ?? DefaultTheme;
            }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "value");
                }

                // EnsureValidTheme would verify if themes have been correctly initialized and that the value specified is a valid theme.
                if (!IsValidTheme(AvailableThemes, value))
                {
                    throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, HelpersToolkitResources.Themes_InvalidTheme, value), "value");
                }
                _currentScope[CurrentThemeKey] = value;
            }
        }

        public ReadOnlyCollection<string> AvailableThemes
        {
            get
            {
                EnsureInitialized();
                return GetAvailableThemes(ThemeDirectory);
            }
        }

        private string CurrentThemePath
        {
            get { return Path.Combine(ThemeDirectory, CurrentTheme); }
        }

        private string DefaultThemePath
        {
            get { return Path.Combine(ThemeDirectory, DefaultTheme); }
        }

        private bool ThemesInitialized
        {
            get
            {
                bool? value = (bool?)_currentScope[ThemesInitializedKey];
                return value != null && value.Value;
            }
            set { _currentScope[ThemesInitializedKey] = value; }
        }

        public void Initialize(string themeDirectory, string defaultTheme)
        {
            if (String.IsNullOrEmpty(themeDirectory))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "themeDirectory");
            }

            if (String.IsNullOrEmpty(defaultTheme))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "defaultTheme");
            }

            var availableThemes = GetAvailableThemes(themeDirectory);
            if (!IsValidTheme(availableThemes, defaultTheme))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, HelpersToolkitResources.Themes_InvalidTheme, defaultTheme), "defaultTheme");
            }

            ThemeDirectory = themeDirectory;
            DefaultTheme = defaultTheme;
            ThemesInitialized = true;
        }

        /// <summary>
        /// Get a file that lives directly inside the theme directory
        /// </summary>
        /// <param name="fileName">The filename to look for</param>
        /// <returns>The full path to the file that matches the requested file</returns>
        public string GetResourcePath(string fileName)
        {
            return GetResourcePath(String.Empty, fileName);
        }

        public string GetResourcePath(string folder, string fileName)
        {
            EnsureInitialized();

            if (folder == null)
            {
                throw new ArgumentNullException("folder", HelpersToolkitResources.Themes_FolderCannotBeNull);
            }

            if (String.IsNullOrEmpty(fileName))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "fileName");
            }

            return FindMatchingFile(Path.Combine(CurrentThemePath, folder), fileName) ??
                   FindMatchingFile(Path.Combine(DefaultThemePath, folder), fileName);
        }

        /// <summary>
        /// Try and find a file in the specified folder that matches name.
        /// </summary>
        /// <returns>The full path to the file that matches the requested file
        /// or null if no matching file is found</returns>
        internal string FindMatchingFile(string folder, string name)
        {
            Debug.Assert(!String.IsNullOrEmpty(folder));
            Debug.Assert(!String.IsNullOrEmpty(name));

            // Get the virtual path information
            VirtualDirectory directory = _vpp.GetDirectory(folder);

            // If the folder specified doesn't exist
            // or it doesn't contain any files
            if (directory == null || directory.Files == null)
            {
                return null;
            }

            // Go through every file in the directory
            foreach (VirtualFile file in directory.Files)
            {
                string path = file.VirtualPath;

                // Compare the filename to the filename that we passed
                if (Path.GetFileName(path).Equals(name, StringComparison.OrdinalIgnoreCase))
                {
                    return path;
                }
            }

            // If no matching files, return null
            return null;
        }

        private ReadOnlyCollection<string> GetAvailableThemes(string themesRoot)
        {
            VirtualDirectory directory = _vpp.GetDirectory(themesRoot);

            var themes = new List<string>();

            // Go through every file in the directory
            foreach (VirtualDirectory dir in directory.Directories)
            {
                themes.Add(dir.Name);
            }
            return themes.AsReadOnly();
        }

        private void EnsureInitialized()
        {
            if (!ThemesInitialized)
            {
                throw new InvalidOperationException(HelpersToolkitResources.Themes_NotInitialized);
            }
        }

        private static bool IsValidTheme(IEnumerable<string> availableThemes, string theme)
        {
            return availableThemes.Contains(theme, StringComparer.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/UrlBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Text;
using System.Web;
using System.Web.Routing;
using System.Web.WebPages;

namespace Microsoft.Web.Helpers
{
    public class UrlBuilder
    {
        private static readonly VirtualPathUtilityWrapper _defaultVirtualPathUtility = new VirtualPathUtilityWrapper();
        private readonly VirtualPathUtilityBase _virtualPathUtility;
        private readonly StringBuilder _params = new StringBuilder();
        private string _path;

        /// <summary>
        /// Constructs an Url with the current page's virtual path and no query string parameters
        /// </summary>
        public UrlBuilder()
            : this(null, null)
        {
        }

        /// <summary>
        /// Constructs an Url with the specified path and no query string parameters.
        /// </summary>
        public UrlBuilder(string path)
            : this(path, null)
        {
        }

        /// <summary>
        /// Constructs an Url with the current page's virtual path and the parameters 
        /// </summary>
        /// <param name="parameters"></param>
        public UrlBuilder(object parameters)
            : this(null, parameters)
        {
        }

        public UrlBuilder(string path, object parameters)
            : this(GetHttpContext(), null, path, parameters)
        {
        }

        internal UrlBuilder(HttpContextBase httpContext, VirtualPathUtilityBase virtualPathUtility, string path, object parameters)
        {
            _virtualPathUtility = virtualPathUtility;
            Uri uri;
            if (Uri.TryCreate(path, UriKind.Absolute, out uri))
            {
                _path = uri.GetLeftPart(UriPartial.Path);
                _params.Append(uri.Query);
            }
            else
            {
                // If the url is being built as part of a WebPages request, use the template stack to identify the current template's virtual path.
                _path = GetPageRelativePath(httpContext, path);
                int queryStringIndex = (_path ?? String.Empty).IndexOf('?');
                if (queryStringIndex != -1)
                {
                    _params.Append(_path.Substring(queryStringIndex));
                    _path = _path.Substring(0, queryStringIndex);
                }
            }

            if (parameters != null)
            {
                AddParam(parameters);
            }
        }

        internal static VirtualPathUtilityBase DefaultVirtualPathUtility
        {
            get { return _defaultVirtualPathUtility; }
        }

        public string Path
        {
            get { return _path; }
        }

        public string QueryString
        {
            get { return _params.ToString(); }
        }

        private VirtualPathUtilityBase VirtualPathUtility
        {
            get { return _virtualPathUtility ?? _defaultVirtualPathUtility; }
        }

        /// <summary>
        /// Factory method to create an UrlBuilder instance
        /// </summary>
        public static UrlBuilder Create(string path, object parameters = null)
        {
            return new UrlBuilder(path, parameters);
        }

        public UrlBuilder AddPath(string path)
        {
            _path = EnsureTrailingSlash(_path);
            if (!path.IsEmpty())
            {
                _path += HttpUtility.UrlPathEncode(path.TrimStart('/'));
            }
            return this;
        }

        public UrlBuilder AddPath(params string[] pathTokens)
        {
            foreach (var token in pathTokens)
            {
                AddPath(token);
            }
            return this;
        }

        public UrlBuilder AddParam(string name, object value)
        {
            if (!String.IsNullOrEmpty(name))
            {
                _params.Append(_params.Length == 0 ? '?' : '&');
                _params.Append(HttpUtility.UrlEncode(name))
                    .Append('=')
                    .Append(HttpUtility.UrlEncode(Convert.ToString(value, CultureInfo.InvariantCulture)));
            }
            return this;
        }

        public UrlBuilder AddParam(object values)
        {
            var dictionary = new RouteValueDictionary(values);
            foreach (var item in dictionary)
            {
                AddParam(item.Key, item.Value);
            }

            return this;
        }

        public override string ToString()
        {
            return _path + _params;
        }

        private static HttpContextBase GetHttpContext()
        {
            return HttpContext.Current != null ? new HttpContextWrapper(HttpContext.Current) : null;
        }

        private static string EnsureTrailingSlash(string path)
        {
            if (!path.IsEmpty() && path[path.Length - 1] != '/')
            {
                path += '/';
            }
            return path;
        }

        private string GetPageRelativePath(HttpContextBase httpContext, string path)
        {
            if (httpContext == null)
            {
                return path;
            }
            var templateFile = TemplateStack.GetCurrentTemplate(httpContext);
            if (templateFile != null)
            {
                var templateVirtualPath = templateFile.TemplateInfo.VirtualPath;
                if (path.IsEmpty())
                {
                    path = templateVirtualPath;
                }
                else
                {
                    path = VirtualPathUtility.Combine(templateVirtualPath, path);
                }
            }
            return VirtualPathUtility.ToAbsolute(path ?? "~/");
        }

        public static implicit operator string(UrlBuilder builder)
        {
            return builder.ToString();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/Video.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Routing;
using System.Web.WebPages;
using Microsoft.Internal.Web.Utils;
using Resources;

namespace Microsoft.Web.Helpers
{
    public static class Video
    {
        private const string FlashCab =
            "http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab";

        private const string FlashClassId = "clsid:d27cdb6e-ae6d-11cf-96b8-444553540000";
        private const string FlashMimeType = "application/x-shockwave-flash";
        private const string MediaPlayerClassId = "clsid:6BF52A52-394A-11D3-B153-00C04F79FAA6";
        private const string MediaPlayerMimeType = "application/x-mplayer2";
        private const string OleMimeType = "application/x-oleobject";
        private const string SilverlightMimeType = "application/x-silverlight-2";

        // These attributes can't be specified using anonymous objects (either because they are available as separate arguments or because
        // they don't make sense in the context of the helper).
        private static readonly string[] _globalBlacklist = new[] { "width", "height", "type", "data", "classid", "codebase" };
        private static readonly string[] _mediaPlayerBlacklist = new[] { "autoStart", "playCount", "uiMode", "stretchToFit", "enableContextMenu", "mute", "volume", "baseURL" };
        private static readonly string[] _silverlightBlacklist = new[] { "background", "initparams", "minruntimeversion", "autoUpgrade" };
        private static readonly string[] _flashBlacklist = new[] { "play", "loop", "menu", "bgColor", "quality", "scale", "wmode", "base" };

        private static VirtualPathUtilityWrapper _pathUtility = new VirtualPathUtilityWrapper();

#if CODE_COVERAGE 
        [ExcludeFromCodeCoverage]
#endif

        private static HttpContextBase HttpContext
        {
            get
            {
                var httpContext = System.Web.HttpContext.Current;
                return httpContext == null ? null : new HttpContextWrapper(httpContext);
            }
        }

        // see: http://kb2.adobe.com/cps/127/tn_12701.html
#if CODE_COVERAGE 
        [ExcludeFromCodeCoverage]
#endif

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "10#",
            Justification = "string parameter passed to flash in object tag")]
        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "bgColor",
            Justification = "This method is public and the parameter name cannot be changed")]
        public static HelperResult Flash(string path, string width = null, string height = null,
                                         bool play = true, bool loop = true, bool menu = true, string bgColor = null,
                                         string quality = null, string scale = null, string windowMode = null, string baseUrl = null,
                                         string version = null, object options = null, object htmlAttributes = null, string embedName = null)
        {
            return Flash(HttpContext, _pathUtility, path, width, height, play, loop, menu, bgColor,
                         quality, scale, windowMode, baseUrl, version, options, htmlAttributes, embedName);
        }

        // see: http://msdn.microsoft.com/en-us/library/aa392321
#if CODE_COVERAGE 
        [ExcludeFromCodeCoverage]
#endif

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "10#",
            Justification = "string parameter passed to media player in object tag")]
        public static HelperResult MediaPlayer(string path, string width = null, string height = null,
                                               bool autoStart = true, int playCount = 1, string uiMode = null, bool stretchToFit = false,
                                               bool enableContextMenu = true, bool mute = false, int volume = -1, string baseUrl = null,
                                               object options = null, object htmlAttributes = null, string embedName = null)
        {
            return MediaPlayer(HttpContext, _pathUtility, path, width, height, autoStart, playCount, uiMode, stretchToFit,
                               enableContextMenu, mute, volume, baseUrl, options, htmlAttributes, embedName);
        }

        // should users really use Silverlight.js?
        // see: http://msdn.microsoft.com/en-us/library/cc838259(v=VS.95).aspx
#if CODE_COVERAGE 
        [ExcludeFromCodeCoverage]
#endif

        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "bgColor",
           Justification = "This method is public and the parameter name cannot be changed")]
        public static HelperResult Silverlight(string path, string width, string height,
                                               string bgColor = null, string initParameters = null, string minimumVersion = null, bool autoUpgrade = true,
                                               object options = null, object htmlAttributes = null)
        {
            return Silverlight(HttpContext, _pathUtility, path, width, height, bgColor, initParameters, minimumVersion, autoUpgrade,
                               options, htmlAttributes);
        }

        internal static HelperResult Flash(HttpContextBase context, VirtualPathUtilityBase pathUtility, string path,
                                           string width = null, string height = null, bool play = true, bool loop = true, bool menu = true,
                                           string backgroundColor = null, string quality = null, string scale = null, string windowMode = null,
                                           string baseUrl = null, string version = null, object options = null, object htmlAttributes = null, string embedName = null)
        {
            var parameters = ObjectToDictionary(options, "options", _flashBlacklist);
            if (!play)
            {
                parameters["play"] = false;
            }
            if (!loop)
            {
                parameters["loop"] = false;
            }
            if (!menu)
            {
                parameters["menu"] = false;
            }
            if (!String.IsNullOrEmpty(backgroundColor))
            {
                parameters["bgColor"] = backgroundColor;
            }
            if (!String.IsNullOrEmpty(quality))
            {
                parameters["quality"] = quality;
            }
            if (!String.IsNullOrEmpty(scale))
            {
                parameters["scale"] = scale;
            }
            if (!String.IsNullOrEmpty(windowMode))
            {
                parameters["wmode"] = windowMode;
            }
            if (!String.IsNullOrEmpty(baseUrl))
            {
                parameters["base"] = baseUrl;
            }

            string cab = FlashCab;
            if (!String.IsNullOrEmpty(version))
            {
                cab += "#version=" + version.Replace('.', ',');
            }
            return GetHtml(context, pathUtility, path, width, height,
                           OleMimeType, null, FlashClassId, cab, "movie", FlashMimeType, parameters, htmlAttributes, embedName);
        }

        internal static HelperResult MediaPlayer(HttpContextBase context, VirtualPathUtilityBase pathUtility, string path, string width = null, string height = null,
                                                 bool autoStart = true, int playCount = 1, string uiMode = null, bool stretchToFit = false,
                                                 bool enableContextMenu = true, bool mute = false, int volume = -1, string baseUrl = null,
                                                 object options = null, object htmlAttributes = null, string embedName = null)
        {
            var parameters = ObjectToDictionary(options, "options", _mediaPlayerBlacklist);
            if (!autoStart)
            {
                parameters["autoStart"] = false;
            }
            if (playCount != 1)
            {
                parameters["playCount"] = playCount;
            }
            if (!String.IsNullOrEmpty(uiMode))
            {
                parameters["uiMode"] = uiMode;
            }
            if (stretchToFit)
            {
                parameters["stretchToFit"] = true;
            }
            if (!enableContextMenu)
            {
                parameters["enableContextMenu"] = false;
            }
            if (mute)
            {
                parameters["mute"] = true;
            }
            if (volume >= 0)
            {
                parameters["volume"] = Math.Min(volume, 100);
            }
            if (!String.IsNullOrEmpty(baseUrl))
            {
                parameters["baseURL"] = baseUrl;
            }

            return GetHtml(context, pathUtility, path, width, height,
                           null, null, MediaPlayerClassId, null, "URL", MediaPlayerMimeType, parameters, htmlAttributes, embedName);
        }

        internal static HelperResult Silverlight(HttpContextBase context, VirtualPathUtilityBase pathUtility, string path, string width, string height,
                                                 string backgroundColor = null, string initParameters = null, string minimumVersion = null, bool autoUpgrade = true,
                                                 object options = null, object htmlAttributes = null)
        {
            if (String.IsNullOrEmpty(width))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "width");
            }
            if (String.IsNullOrEmpty(height))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "height");
            }

            var parameters = ObjectToDictionary(options, "options", _silverlightBlacklist);
            if (!String.IsNullOrEmpty(backgroundColor))
            {
                parameters["background"] = backgroundColor;
            }
            if (!String.IsNullOrEmpty(initParameters))
            {
                parameters["initparams"] = initParameters;
            }
            if (!String.IsNullOrEmpty(minimumVersion))
            {
                parameters["minruntimeversion"] = minimumVersion;
            }
            if (!autoUpgrade)
            {
                parameters["autoUpgrade"] = autoUpgrade;
            }

            return GetHtml(context, pathUtility, path, width, height,
                           SilverlightMimeType, "data:" + SilverlightMimeType + ",", // ',' required for Opera support
                           null, null, "source", null, parameters, htmlAttributes, null,
                           tw =>
                           {
                               tw.WriteLine("<a href=\"http://go.microsoft.com/fwlink/?LinkID=149156\" style=\"text-decoration:none\">");
                               tw.WriteLine("<img src=\"http://go.microsoft.com/fwlink?LinkId=108181\" alt=\"Get Microsoft Silverlight\" style=\"border-style:none\"/>");
                               tw.WriteLine("</a>");
                           });
        }

        private static IDictionary<string, object> ObjectToDictionary(object o, string argName, string[] blackList)
        {
            var dictionary = new RouteValueDictionary(o);

            foreach (var key in dictionary.Keys)
            {
                if (blackList.Contains(key, StringComparer.OrdinalIgnoreCase))
                {
                    throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture,
                                                              HelpersToolkitResources.Video_PropertyCannotBeSet, key), argName);
                }
            }
            return dictionary;
        }

        private static HelperResult GetHtml(HttpContextBase context, VirtualPathUtilityBase pathUtility,
                                            string path, string width, string height, string objectType, string objectDataType,
                                            string objectClassId, string objectCodeBase, string pathParamName, string embedContentType,
                                            IDictionary<string, object> parameters = null, object htmlAttributes = null, string embedName = null,
                                            Action<TextWriter> plugin = null)
        {
            path = ValidatePath(context, pathUtility, path);

            var objectAttr = ObjectToDictionary(htmlAttributes, "htmlAttributes", _globalBlacklist);
            objectAttr["width"] = width;
            objectAttr["height"] = height;
            objectAttr["type"] = objectType;
            objectAttr["data"] = objectDataType;
            objectAttr["classid"] = objectClassId;
            objectAttr["codebase"] = objectCodeBase;

            return new HelperResult(tw =>
            {
                tw.Write("<object ");
                foreach (var a in objectAttr.OrderBy(a => a.Key, StringComparer.OrdinalIgnoreCase))
                {
                    var value = (a.Value == null) ? null : a.Value.ToString();
                    WriteIfNotNullOrEmpty(tw, a.Key, value);
                }
                tw.WriteLine(">");

                // object parameters
                if (!String.IsNullOrEmpty(pathParamName))
                {
                    tw.WriteLine("<param name=\"{0}\" value=\"{1}\" />",
                                 HttpUtility.HtmlAttributeEncode(pathParamName),
                                 HttpUtility.HtmlAttributeEncode(HttpUtility.UrlPathEncode(path)));
                }
                if (parameters != null)
                {
                    foreach (var p in parameters)
                    {
                        tw.WriteLine("<param name=\"{0}\" value=\"{1}\" />",
                                     HttpUtility.HtmlAttributeEncode(p.Key),
                                     HttpUtility.HtmlAttributeEncode(p.Value.ToString()));
                    }
                }

                if (!String.IsNullOrEmpty(embedContentType))
                {
                    tw.Write("<embed src=\"{0}\" ", HttpUtility.HtmlAttributeEncode(HttpUtility.UrlPathEncode(path)));
                    WriteIfNotNullOrEmpty(tw, "width", width);
                    WriteIfNotNullOrEmpty(tw, "height", height);
                    WriteIfNotNullOrEmpty(tw, "name", embedName);
                    WriteIfNotNullOrEmpty(tw, "type", embedContentType);
                    if (parameters != null)
                    {
                        foreach (var p in parameters)
                        {
                            tw.Write("{0}=\"{1}\" ", HttpUtility.HtmlEncode(p.Key), HttpUtility.HtmlAttributeEncode(p.Value.ToString()));
                        }
                    }
                    tw.WriteLine("/>");
                }
                if (plugin != null)
                {
                    plugin(tw);
                }
                tw.WriteLine("</object>");
            });
        }

        private static string ValidatePath(HttpContextBase context, VirtualPathUtilityBase pathUtility, string path)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }
            string originalPath = path;
            if (!path.StartsWith("http", StringComparison.OrdinalIgnoreCase))
            {
                // resolve relative paths
                path = pathUtility.Combine(context.Request.AppRelativeCurrentExecutionFilePath, path);
                // resolve to app absolute - SL doesn't support app relative
                path = pathUtility.ToAbsolute(path);
                if (!File.Exists(context.Server.MapPath(path)))
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture,
                                                                      HelpersToolkitResources.Video_FileDoesNotExist, originalPath));
                }
            }
            return path;
        }

        private static void WriteIfNotNullOrEmpty(TextWriter tw, string key, string value)
        {
            Debug.Assert(!String.IsNullOrEmpty(key));

            if (!String.IsNullOrEmpty(value))
            {
                tw.Write("{0}=\"{1}\" ", HttpUtility.HtmlEncode(key), HttpUtility.HtmlAttributeEncode(value));
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/VirtualPathUtilityBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Helpers
{
    public abstract class VirtualPathUtilityBase
    {
        public abstract string Combine(string basePath, string relativePath);

        public abstract string ToAbsolute(string virtualPath);
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/VirtualPathUtilityWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web;

namespace Microsoft.Web.Helpers
{
    internal sealed class VirtualPathUtilityWrapper : VirtualPathUtilityBase
    {
        public override string Combine(string basePath, string relativePath)
        {
            return VirtualPathUtility.Combine(basePath, relativePath);
        }

        public override string ToAbsolute(string virtualPath)
        {
            return VirtualPathUtility.ToAbsolute(virtualPath);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Helpers/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="RazorGenerator.MsBuild" version="2.2.0" targetFramework="net45" />
</packages>

================================================
FILE: src/Microsoft.Web.Mvc/AcceptAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public sealed class AcceptAttribute : DataTypeAttribute, IClientValidatable
    {
        public AcceptAttribute()
            : base("upload")
        {
            ErrorMessage = MvcResources.FileExtensionsAttribute_Invalid;
            ErrorMessage = MvcResources.AcceptAttribute_Invalid;
        }

        public string MimeTypes { get; set; }

        private string MimeTypesFormatted
        {
            get { return MimeTypesParsed.Aggregate((left, right) => left + ", " + right); }
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "These strings are normalized to lowercase because they are presented to the user in lowercase format")]
        private string MimeTypesNormalized
        {
            get { return MimeTypes.Replace(" ", String.Empty).ToLowerInvariant(); }
        }

        private IEnumerable<string> MimeTypesParsed
        {
            get { return MimeTypesNormalized.Split(','); }
        }

        public override string FormatErrorMessage(string name)
        {
            return String.Format(CultureInfo.CurrentCulture, ErrorMessageString, name, MimeTypesFormatted);
        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule
            {
                ValidationType = "accept",
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName())
            };
            rule.ValidationParameters["mimetype"] = MimeTypesNormalized;
            yield return rule;
        }

        public override bool IsValid(object value)
        {
            if (value == null)
            {
                return true;
            }

            HttpPostedFileBase valueAsFileBase = value as HttpPostedFileBase;
            if (valueAsFileBase != null)
            {
                return ValidateMimeTypes(valueAsFileBase.ContentType);
            }

            string valueAsString = value as string;
            if (valueAsString != null)
            {
                return ValidateMimeTypes(valueAsString);
            }

            return false;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "These strings are normalized to lowercase because they are presented to the user in lowercase format")]
        private bool ValidateMimeTypes(string mimeType)
        {
            return MimeTypesParsed.Contains(mimeType.ToLowerInvariant());
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ActionLinkAreaAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public sealed class ActionLinkAreaAttribute : Attribute
    {
        public ActionLinkAreaAttribute(string area)
        {
            if (area == null)
            {
                throw new ArgumentNullException("area");
            }

            Area = area;
        }

        public string Area { get; private set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/AjaxOnlyAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class AjaxOnlyAttribute : ActionMethodSelectorAttribute
    {
        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            // Dev10 #939671 - If this attribute is going to say AJAX *only*, then we need to check the header
            // specifically, as otherwise clients can modify the form or query string to contain the name/value
            // pair we're looking for.
            return (controllerContext.HttpContext.Request.Headers["X-Requested-With"] == "XMLHttpRequest");
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/AreaHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using System.Web.Routing;

namespace Microsoft.Web.Mvc
{
    public static class AreaHelpers
    {
        public static string GetAreaName(RouteBase route)
        {
            IRouteWithArea routeWithArea = route as IRouteWithArea;
            if (routeWithArea != null)
            {
                return routeWithArea.Area;
            }

            Route castRoute = route as Route;
            if (castRoute != null && castRoute.DataTokens != null)
            {
                return castRoute.DataTokens["area"] as string;
            }

            return null;
        }

        public static string GetAreaName(RouteData routeData)
        {
            object area;
            if (routeData.DataTokens.TryGetValue("area", out area))
            {
                return area as string;
            }

            return GetAreaName(routeData.Route);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/AsyncManagerExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc.Async;

namespace Microsoft.Web.Mvc
{
    public static class AsyncManagerExtensions
    {
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "An unhandled exception here will bring down the worker process.")]
        [SuppressMessage("StyleCop.CSharp.MaintainabilityRules", "SA1409:RemoveUnnecessaryCode",
            Justification = "The empty lock statement is required for synchronization.")]
        public static void RegisterTask(this AsyncManager asyncManager, Func<AsyncCallback, IAsyncResult> beginDelegate, Action<IAsyncResult> endDelegate)
        {
            if (asyncManager == null)
            {
                throw new ArgumentNullException("asyncManager");
            }
            if (beginDelegate == null)
            {
                throw new ArgumentNullException("beginDelegate");
            }
            if (endDelegate == null)
            {
                throw new ArgumentNullException("endDelegate");
            }

            // need to wait to execute the callback until after BeginXxx() has completed
            object delegateExecutingLockObj = new object();

            AsyncCallback callback = ar =>
            {
                lock (delegateExecutingLockObj)
                {
                    // this empty lock is required to synchronized with the beginDelegate call
                }
                if (!ar.CompletedSynchronously)
                {
                    try
                    {
                        asyncManager.Sync(() => endDelegate(ar)); // called on different thread, so have to take application lock
                    }
                    catch
                    {
                        // Need to swallow exceptions, as otherwise unhandled exceptions on a ThreadPool thread
                        // can bring down the entire worker process.
                    }
                    finally
                    {
                        asyncManager.OutstandingOperations.Decrement();
                    }
                }
            };

            IAsyncResult asyncResult;
            asyncManager.OutstandingOperations.Increment();
            try
            {
                lock (delegateExecutingLockObj)
                {
                    asyncResult = beginDelegate(callback);
                }
            }
            catch
            {
                asyncManager.OutstandingOperations.Decrement();
                throw;
            }

            if (asyncResult.CompletedSynchronously)
            {
                try
                {
                    endDelegate(asyncResult); // call on same thread
                }
                finally
                {
                    asyncManager.OutstandingOperations.Decrement();
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ButtonBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public static class ButtonBuilder
    {
        public static TagBuilder SubmitButton(string name, string buttonText, IDictionary<string, object> htmlAttributes)
        {
            TagBuilder buttonTag = new TagBuilder("input");

            buttonTag.MergeAttribute("type", "submit");
            if (!buttonTag.Attributes.ContainsKey("id") && name != null)
            {
                buttonTag.GenerateId(name);
            }

            if (!String.IsNullOrEmpty(name))
            {
                buttonTag.MergeAttribute("name", name);
            }

            if (!String.IsNullOrEmpty(buttonText))
            {
                buttonTag.MergeAttribute("value", buttonText);
            }

            buttonTag.MergeAttributes(htmlAttributes, true);
            return buttonTag;
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public static TagBuilder SubmitImage(string name, string sourceUrl, IDictionary<string, object> htmlAttributes)
        {
            TagBuilder buttonTag = new TagBuilder("input");

            buttonTag.MergeAttribute("type", "image");

            if (!buttonTag.Attributes.ContainsKey("id"))
            {
                buttonTag.GenerateId(name);
            }

            if (!String.IsNullOrEmpty(name))
            {
                buttonTag.MergeAttribute("name", name);
            }

            if (!String.IsNullOrEmpty(sourceUrl))
            {
                buttonTag.MergeAttribute("src", sourceUrl);
            }
            buttonTag.MergeAttributes(htmlAttributes, true);
            return buttonTag;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "This conversion is appropriate because it's for HTML, not for comparsion normalization")]
        public static TagBuilder Button(string name, string buttonText, HtmlButtonType type, string onClickMethod, IDictionary<string, object> htmlAttributes)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            TagBuilder buttonTag = new TagBuilder("button");

            if (!String.IsNullOrEmpty(name))
            {
                buttonTag.MergeAttribute("name", name);
            }

            buttonTag.MergeAttribute("type", type.ToString().ToLowerInvariant());

            buttonTag.InnerHtml = buttonText;

            if (!String.IsNullOrEmpty(onClickMethod))
            {
                buttonTag.MergeAttribute("onclick", onClickMethod);
            }

            buttonTag.MergeAttributes(htmlAttributes, true);
            return buttonTag;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ButtonsAndLinkExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public static class ButtonsAndLinkExtensions
    {
        /// <summary>
        /// Creates a submit button for your form
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">The name.</param>
        /// <returns></returns>
        public static MvcHtmlString SubmitButton(this HtmlHelper helper, string name)
        {
            return SubmitButton(helper, name, null, null);
        }

        /// <summary>
        /// Creates a submit button for your form
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">The name.</param>
        /// <param name="buttonText">The text for the button face</param>
        /// <returns></returns>
        public static MvcHtmlString SubmitButton(this HtmlHelper helper, string name, string buttonText)
        {
            return SubmitButton(helper, name, buttonText, null);
        }

        /// <summary>
        /// Creates a submit button for your form
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        public static MvcHtmlString SubmitButton(this HtmlHelper helper)
        {
            return SubmitButton(helper, null, null, null);
        }

        /// <summary>
        /// Creates a submit button for your form
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="buttonText">The text for the button face</param>
        /// <param name="htmlAttributes">Any attributes you want set on the tag. Use anonymous-type declaration for this: new{class=cssclass}</param>
        /// <returns></returns>
        public static MvcHtmlString SubmitButton(this HtmlHelper helper, string name, string buttonText, object htmlAttributes)
        {
            return helper.SubmitButton(name, buttonText, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        /// <summary>
        /// Creates a submit button for your form
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="buttonText">The text for the button face</param>
        /// <param name="htmlAttributes">Dictionary of HTML settings</param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "helper", Justification = "Required for Extension Method")]
        public static MvcHtmlString SubmitButton(this HtmlHelper helper, string name, string buttonText, IDictionary<string, object> htmlAttributes)
        {
            return MvcHtmlString.Create(ButtonBuilder.SubmitButton(name, buttonText, htmlAttributes).ToString(TagRenderMode.SelfClosing));
        }

        /// <summary>
        /// Creates a submit button for your form using an image
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="imageSrc">The URL for the image</param>
        /// <returns></returns>
        public static MvcHtmlString SubmitImage(this HtmlHelper helper, string name, string imageSrc)
        {
            return helper.SubmitImage(name, imageSrc, null);
        }

        /// <summary>
        /// Creates a submit button for your form using an image
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="imageSrc">The URL for the image</param>
        /// <param name="htmlAttributes">Any attributes you want set on the tag. Use anonymous-type declaration for this: new{class=cssclass}</param>
        /// <returns></returns>
        public static MvcHtmlString SubmitImage(this HtmlHelper helper, string name, string imageSrc, object htmlAttributes)
        {
            return helper.SubmitImage(name, imageSrc, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        /// <summary>
        /// Creates a submit button for your form using an image
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="imageSrc">The URL for the image</param>
        /// <param name="htmlAttributes">Dictionary of HTML settings</param>
        /// <returns></returns>
        public static MvcHtmlString SubmitImage(this HtmlHelper helper, string name, string imageSrc, IDictionary<string, object> htmlAttributes)
        {
            if (imageSrc == null)
            {
                throw new ArgumentNullException("imageSrc");
            }

            string resolvedUrl = UrlHelper.GenerateContentUrl(imageSrc, helper.ViewContext.HttpContext);
            return MvcHtmlString.Create(ButtonBuilder.SubmitImage(name, resolvedUrl, htmlAttributes).ToString(TagRenderMode.SelfClosing));
        }

        /// <summary>
        /// A Simple button you can use with javascript
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="buttonText">The text for the button face</param>
        /// <param name="buttonType">The button type (Button, Submit, or Reset)</param>
        /// <returns></returns>
        public static MvcHtmlString Button(this HtmlHelper helper, string name, string buttonText, HtmlButtonType buttonType)
        {
            return helper.Button(name, buttonText, buttonType, null, (IDictionary<string, object>)null);
        }

        /// <summary>
        /// A Simple button you can use with javascript
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="buttonText">The text for the button face</param>
        /// <param name="buttonType">The button type (Button, Submit, or Reset)</param>
        /// <param name="onClickMethod">The method or script routine to call when the button is clicked.</param>
        /// <returns></returns>
        public static MvcHtmlString Button(this HtmlHelper helper, string name, string buttonText, HtmlButtonType buttonType, string onClickMethod)
        {
            return helper.Button(name, buttonText, buttonType, onClickMethod, (IDictionary<string, object>)null);
        }

        /// <summary>
        /// A Simple button you can use with javascript
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="buttonText">The text for the button face</param>
        /// <param name="buttonType">The button type (Button, Submit, or Reset)</param>
        /// <param name="onClickMethod">The method or script routine to call when the button is clicked.</param>
        /// <param name="htmlAttributes">Any attributes you want set on the tag. Use anonymous-type declaration for this: new{class=cssclass}</param>
        /// <returns></returns>
        public static MvcHtmlString Button(this HtmlHelper helper, string name, string buttonText, HtmlButtonType buttonType, string onClickMethod, object htmlAttributes)
        {
            return helper.Button(name, buttonText, buttonType, onClickMethod, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        /// <summary>
        /// A Simple button you can use with javascript
        /// </summary>
        /// <param name="helper">The helper which we extend.</param>
        /// <param name="name">Name of the button</param>
        /// <param name="buttonText">The text for the button face</param>
        /// <param name="buttonType">The button type (Button, Submit, or Reset)</param>
        /// <param name="onClickMethod">The method or script routine to call when the button is clicked.</param>
        /// <param name="htmlAttributes">Any attributes you want set on the tag. Use anonymous-type declaration for this: new{class=cssclass}</param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "helper", Justification = "This is an Extension Method and requires this argument")]
        public static MvcHtmlString Button(this HtmlHelper helper, string name, string buttonText, HtmlButtonType buttonType, string onClickMethod, IDictionary<string, object> htmlAttributes)
        {
            return MvcHtmlString.Create(ButtonBuilder.Button(name, buttonText, buttonType, onClickMethod, htmlAttributes).ToString(TagRenderMode.Normal));
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/CachedExpressionCompiler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

namespace Microsoft.Web.Mvc
{
    // The caching expression tree compiler was copied from MVC core to MVC Futures so that Futures code could benefit
    // from it and so that it could be exposed as a public API. This is the only public entry point into the system.
    // See the comments in the ExpressionUtil namespace for more information.
    //
    // The unit tests for the ExpressionUtil.* types are in the System.Web.Mvc.Test project.
    public static class CachedExpressionCompiler
    {
        private static readonly ParameterExpression _unusedParameterExpr = Expression.Parameter(typeof(object), "_unused");

        // Implements caching around LambdaExpression.Compile() so that equivalent expression trees only have to be
        // compiled once.
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static Func<TModel, TValue> Compile<TModel, TValue>(this Expression<Func<TModel, TValue>> lambdaExpression)
        {
            if (lambdaExpression == null)
            {
                throw new ArgumentNullException("lambdaExpression");
            }

            return ExpressionUtil.CachedExpressionCompiler.Process(lambdaExpression);
        }

        // Evaluates an expression (not a LambdaExpression), e.g. 2 + 2.
        public static object Evaluate(Expression arg)
        {
            if (arg == null)
            {
                throw new ArgumentNullException("arg");
            }

            Func<object, object> func = Wrap(arg);
            return func(null);
        }

        private static Func<object, object> Wrap(Expression arg)
        {
            Expression<Func<object, object>> lambdaExpr = Expression.Lambda<Func<object, object>>(Expression.Convert(arg, typeof(object)), _unusedParameterExpr);
            return ExpressionUtil.CachedExpressionCompiler.Process(lambdaExpr);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ContentTypeAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class ContentTypeAttribute : ActionFilterAttribute
    {
        public ContentTypeAttribute(string contentType)
        {
            if (String.IsNullOrEmpty(contentType))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "contentType");
            }

            ContentType = contentType;
        }

        public string ContentType { get; private set; }

        public override void OnResultExecuting(ResultExecutingContext filterContext)
        {
            filterContext.HttpContext.Response.ContentType = ContentType;
        }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            filterContext.HttpContext.Response.ContentType = ContentType;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ControllerExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.Routing;
using ExpressionHelper = Microsoft.Web.Mvc.Internal.ExpressionHelper;

namespace Microsoft.Web.Mvc
{
    public static class ControllerExtensions
    {
        // Shortcut to allow users to write this.RedirectToAction(x => x.OtherMethod()) to redirect
        // to a different method on the same controller.
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static RedirectToRouteResult RedirectToAction<TController>(this TController controller, Expression<Action<TController>> action) where TController : Controller
        {
            return RedirectToAction((Controller)controller, action);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static RedirectToRouteResult RedirectToAction<TController>(this Controller controller, Expression<Action<TController>> action) where TController : Controller
        {
            if (controller == null)
            {
                throw new ArgumentNullException("controller");
            }

            RouteValueDictionary routeValues = ExpressionHelper.GetRouteValuesFromExpression(action);
            return new RedirectToRouteResult(routeValues);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/ActionLink.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using System.Web.Mvc;
using System.Web.Routing;
using System.Web.UI;

namespace Microsoft.Web.Mvc.Controls
{
    [ParseChildren(true)]
    [PersistChildren(false)]
    public class ActionLink : MvcControl
    {
        private string _actionName;
        private string _controllerName;
        private string _text;
        private string _routeName;
        private RouteValues _values;

        [DefaultValue("")]
        public string ActionName
        {
            get { return _actionName ?? String.Empty; }
            set { _actionName = value; }
        }

        [DefaultValue("")]
        public string ControllerName
        {
            get { return _controllerName ?? String.Empty; }
            set { _controllerName = value; }
        }

        [DefaultValue("")]
        public string RouteName
        {
            get { return _routeName ?? String.Empty; }
            set { _routeName = value; }
        }

        [DesignerSerializationVisibility(DesignerSerializationVisibility.Content)]
        [PersistenceMode(PersistenceMode.InnerProperty)]
        public RouteValues Values
        {
            get
            {
                if (_values == null)
                {
                    _values = new RouteValues();
                }
                return _values;
            }
        }

        public string Text
        {
            get { return _text ?? String.Empty; }
            set { _text = value; }
        }

        protected override void Render(HtmlTextWriter writer)
        {
            RouteValueDictionary routeValues = new RouteValueDictionary();
            foreach (var attribute in Values.Attributes)
            {
                routeValues.Add(attribute.Key, attribute.Value);
            }

            if (!String.IsNullOrEmpty(ActionName) && !routeValues.ContainsKey("action"))
            {
                routeValues.Add("action", ActionName);
            }
            if (!String.IsNullOrEmpty(ControllerName) && !routeValues.ContainsKey("controller"))
            {
                routeValues.Add("controller", ControllerName);
            }

            string href = null;
            if (DesignMode)
            {
                href = "/";
            }
            else
            {
                VirtualPathData vpd = RouteTable.Routes.GetVirtualPathForArea(ViewContext.RequestContext, RouteName, routeValues);
                if (vpd == null)
                {
                    throw new InvalidOperationException("A route that matches the requested values could not be located in the route table.");
                }
                href = vpd.VirtualPath;
            }

            foreach (var attribute in Attributes)
            {
                writer.AddAttribute(attribute.Key, attribute.Value);
            }

            if (!Attributes.ContainsKey("href"))
            {
                writer.AddAttribute(HtmlTextWriterAttribute.Href, href);
            }

            writer.RenderBeginTag(HtmlTextWriterTag.A);

            writer.WriteEncodedText(Text);

            writer.RenderEndTag();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/DropDownList.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Web.Mvc;
using System.Web.UI;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Controls
{
    // TODO: Have ListBoxBase class to use with DropDownList and ListBox?
    // TODO: Do we need a way to explicitly specify the items? And only get the selected value(s) from ViewData?

    public class DropDownList : MvcControl
    {
        private string _name;
        private string _optionLabel;

        [DefaultValue("")]
        public string Name
        {
            get { return _name ?? String.Empty; }
            set { _name = value; }
        }

        [DefaultValue("")]
        public string OptionLabel
        {
            get { return _optionLabel ?? String.Empty; }
            set { _optionLabel = value; }
        }

        private object GetModelStateValue(string key, Type destinationType)
        {
            ModelState modelState;
            if (ViewData.ModelState.TryGetValue(key, out modelState))
            {
                return modelState.Value.ConvertTo(destinationType, null /* culture */);
            }
            return null;
        }

        private IEnumerable<SelectListItem> GetSelectData(string name)
        {
            object o = null;
            if (ViewData != null)
            {
                o = ViewData.Eval(name);
            }
            if (o == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.HtmlHelper_MissingSelectData,
                        name,
                        "IEnumerable<SelectListItem>"));
            }
            IEnumerable<SelectListItem> selectList = o as IEnumerable<SelectListItem>;
            if (selectList == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.HtmlHelper_WrongSelectDataType,
                        name,
                        o.GetType().FullName,
                        "IEnumerable<SelectListItem>"));
            }
            return selectList;
        }

        protected override void Render(HtmlTextWriter writer)
        {
            if (!DesignMode && String.IsNullOrEmpty(Name))
            {
                throw new InvalidOperationException(MvcResources.CommonControls_NameRequired);
            }

            if (DesignMode)
            {
                RenderDesignMode(writer);
            }
            else
            {
                RenderRuntime(writer);
            }
        }

        private void RenderDesignMode(HtmlTextWriter writer)
        {
            writer.RenderBeginTag(HtmlTextWriterTag.Select);
            writer.RenderBeginTag(HtmlTextWriterTag.Option);
            if (String.IsNullOrEmpty(OptionLabel))
            {
                writer.WriteEncodedText(MvcResources.DropDownList_SampleItem);
            }
            else
            {
                writer.WriteEncodedText(OptionLabel);
            }
            writer.RenderEndTag();
            writer.RenderEndTag();
        }

        private void RenderRuntime(HtmlTextWriter writer)
        {
            // TODO: Move this to the base class once it exists
            bool allowMultiple = false;

            SortedDictionary<string, string> attrs = new SortedDictionary<string, string>();

            foreach (KeyValuePair<string, string> attribute in Attributes)
            {
                attrs.Add(attribute.Key, attribute.Value);
            }

            attrs.Add("name", Name);
            if (!String.IsNullOrEmpty(ID))
            {
                attrs.Add("id", ID);
            }
            if (allowMultiple)
            {
                attrs.Add("multiple", "multiple");
            }

            // If there are any errors for a named field, we add the css attribute.
            ModelState modelState;
            if (ViewData.ModelState.TryGetValue(Name, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    string currentValue;

                    if (attrs.TryGetValue("class", out currentValue))
                    {
                        attrs["class"] = HtmlHelper.ValidationInputCssClassName + " " + currentValue;
                    }
                    else
                    {
                        attrs["class"] = HtmlHelper.ValidationInputCssClassName;
                    }
                }
            }

            foreach (KeyValuePair<string, string> attribute in attrs)
            {
                writer.AddAttribute(attribute.Key, Convert.ToString(attribute.Value, CultureInfo.CurrentCulture));
            }

            writer.RenderBeginTag(HtmlTextWriterTag.Select);

            // Use ViewData to get the list of items
            IEnumerable<SelectListItem> selectList = GetSelectData(Name);

            object defaultValue = (allowMultiple) ? GetModelStateValue(Name, typeof(string[])) : GetModelStateValue(Name, typeof(string));

            if (defaultValue != null)
            {
                IEnumerable defaultValues = (allowMultiple) ? defaultValue as IEnumerable : new[] { defaultValue };
                IEnumerable<string> values = from object value in defaultValues
                                             select Convert.ToString(value, CultureInfo.CurrentCulture);
                HashSet<string> selectedValues = new HashSet<string>(values, StringComparer.OrdinalIgnoreCase);
                List<SelectListItem> newSelectList = new List<SelectListItem>();

                foreach (SelectListItem item in selectList)
                {
                    item.Selected = (item.Value != null) ? selectedValues.Contains(item.Value) : selectedValues.Contains(item.Text);
                    newSelectList.Add(item);
                }
                selectList = newSelectList;
            }

            // Render the option label if it exists
            if (!String.IsNullOrEmpty(OptionLabel))
            {
                writer.AddAttribute(HtmlTextWriterAttribute.Value, String.Empty);
                writer.RenderBeginTag(HtmlTextWriterTag.Option);
                writer.WriteEncodedText(OptionLabel);
                writer.RenderEndTag();
            }

            // Render out the list items
            foreach (SelectListItem listItem in selectList)
            {
                if (listItem.Value != null)
                {
                    writer.AddAttribute(HtmlTextWriterAttribute.Value, listItem.Value);
                }
                if (listItem.Selected)
                {
                    writer.AddAttribute(HtmlTextWriterAttribute.Selected, "selected");
                }
                writer.RenderBeginTag(HtmlTextWriterTag.Option);
                writer.WriteEncodedText(listItem.Text);
                writer.RenderEndTag();
            }

            writer.RenderEndTag();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/EncodeType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.Controls
{
    public enum EncodeType
    {
        Html,
        HtmlAttribute,
        None,
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/Hidden.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.Controls
{
    public class Hidden : MvcInputControl
    {
        public Hidden()
            : base("hidden")
        {
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/Label.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using System.Globalization;
using System.Web;
using System.Web.UI;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Controls
{
    public class Label : MvcControl
    {
        private string _format;
        private string _name;
        private int _truncateLength = -1;
        private string _truncateText = "...";

        [DefaultValue(EncodeType.Html)]
        public EncodeType EncodeType { get; set; }

        [DefaultValue("")]
        public string Format
        {
            get { return _format ?? String.Empty; }
            set { _format = value; }
        }

        [DefaultValue("")]
        public string Name
        {
            get { return _name ?? String.Empty; }
            set { _name = value; }
        }

        [DefaultValue(-1)]
        [Description("The length of the text at which to truncate the value. Set to -1 to never truncate.")]
        public int TruncateLength
        {
            get { return _truncateLength; }
            set
            {
                if (value < -1)
                {
                    throw new ArgumentOutOfRangeException("value", "The TruncateLength property must be greater than or equal to -1.");
                }
                _truncateLength = value;
            }
        }

        [DefaultValue("...")]
        [Description("The text to display at the end of the string if it is truncated. This text is never encoded.")]
        public string TruncateText
        {
            get { return _truncateText ?? String.Empty; }
            set { _truncateText = value; }
        }

        protected override void Render(HtmlTextWriter writer)
        {
            if (!DesignMode && String.IsNullOrEmpty(Name))
            {
                throw new InvalidOperationException(MvcResources.CommonControls_NameRequired);
            }

            string stringValue = String.Empty;
            if (ViewData != null)
            {
                object rawValue = ViewData.Eval(Name);

                if (String.IsNullOrEmpty(Format))
                {
                    stringValue = Convert.ToString(rawValue, CultureInfo.CurrentCulture);
                }
                else
                {
                    stringValue = String.Format(CultureInfo.CurrentCulture, Format, rawValue);
                }
            }

            writer.AddAttribute(HtmlTextWriterAttribute.Name, Name);
            if (!String.IsNullOrEmpty(ID))
            {
                writer.AddAttribute(HtmlTextWriterAttribute.Id, ID);
            }

            bool wasTruncated = false;
            if ((TruncateLength >= 0) && (stringValue.Length > TruncateLength))
            {
                stringValue = stringValue.Substring(0, TruncateLength);
                wasTruncated = true;
            }

            switch (EncodeType)
            {
                case EncodeType.Html:
                    writer.Write(HttpUtility.HtmlEncode(stringValue));
                    break;
                case EncodeType.HtmlAttribute:
                    writer.Write(HttpUtility.HtmlAttributeEncode(stringValue));
                    break;
                case EncodeType.None:
                    writer.Write(stringValue);
                    break;
            }

            if (wasTruncated)
            {
                writer.Write(TruncateText);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/MvcControl.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Web.Mvc;
using System.Web.UI;

namespace Microsoft.Web.Mvc.Controls
{
    // TODO: Consider using custom HTML writer instead of the default one to get prettier rendering

    public abstract class MvcControl : Control, IAttributeAccessor
    {
        private IDictionary<string, string> _attributes;
        private IViewDataContainer _viewDataContainer;
        private ViewContext _viewContext;

        [Browsable(false)]
        public IDictionary<string, string> Attributes
        {
            get
            {
                EnsureAttributes();
                return _attributes;
            }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public override bool EnableViewState
        {
            get { return base.EnableViewState; }
            set { base.EnableViewState = value; }
        }

        public ViewContext ViewContext
        {
            get
            {
                if (_viewContext == null)
                {
                    // TODO: Is this logic correct? Why not just case Page to ViewPage?
                    Control parent = Parent;
                    while (parent != null)
                    {
                        ViewPage viewPage = parent as ViewPage;
                        if (viewPage != null)
                        {
                            _viewContext = viewPage.ViewContext;
                            break;
                        }
                        parent = parent.Parent;
                    }
                }
                return _viewContext;
            }
        }

        public IViewDataContainer ViewDataContainer
        {
            get
            {
                if (_viewDataContainer == null)
                {
                    Control parent = Parent;
                    while (parent != null)
                    {
                        _viewDataContainer = parent as IViewDataContainer;
                        if (_viewDataContainer != null)
                        {
                            break;
                        }
                        parent = parent.Parent;
                    }
                }
                return _viewDataContainer;
            }
        }

        public ViewDataDictionary ViewData
        {
            get
            {
                IViewDataContainer vdc = ViewDataContainer;
                return (vdc == null) ? null : vdc.ViewData;
            }
        }

        private void EnsureAttributes()
        {
            if (_attributes == null)
            {
                _attributes = new SortedDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            }
        }

        protected virtual string GetAttribute(string key)
        {
            EnsureAttributes();
            string value;
            _attributes.TryGetValue(key, out value);
            return value;
        }

        protected virtual void SetAttribute(string key, string value)
        {
            EnsureAttributes();
            _attributes[key] = value;
        }

        #region IAttributeAccessor Members

        string IAttributeAccessor.GetAttribute(string key)
        {
            return GetAttribute(key);
        }

        void IAttributeAccessor.SetAttribute(string key, string value)
        {
            SetAttribute(key, value);
        }

        #endregion
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/MvcInputControl.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Web.Mvc;
using System.Web.UI;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Controls
{
    public abstract class MvcInputControl : MvcControl
    {
        private string _format;
        private string _name;

        protected MvcInputControl(string inputType)
        {
            if (String.IsNullOrEmpty(inputType))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "inputType");
            }
            InputType = inputType;
        }

        [DefaultValue("")]
        public string Format
        {
            get { return _format ?? String.Empty; }
            set { _format = value; }
        }

        [Browsable(false)]
        public string InputType { get; private set; }

        [DefaultValue("")]
        public string Name
        {
            get { return _name ?? String.Empty; }
            set { _name = value; }
        }

        private ModelState GetModelState()
        {
            return ViewData.ModelState[Name];
        }

        private object GetModelStateValue(Type destinationType)
        {
            ModelState modelState = GetModelState();
            if (modelState != null)
            {
                return modelState.Value.ConvertTo(destinationType, null /* culture */);
            }
            return null;
        }

        protected override void Render(HtmlTextWriter writer)
        {
            if (!DesignMode && String.IsNullOrEmpty(Name))
            {
                throw new InvalidOperationException(MvcResources.CommonControls_NameRequired);
            }

            SortedDictionary<string, string> attrs = new SortedDictionary<string, string>();

            foreach (KeyValuePair<string, string> attribute in Attributes)
            {
                attrs.Add(attribute.Key, attribute.Value);
            }

            if (!Attributes.ContainsKey("type"))
            {
                attrs.Add("type", InputType);
            }
            attrs.Add("name", Name);
            if (!String.IsNullOrEmpty(ID))
            {
                attrs.Add("id", ID);
            }

            if (DesignMode)
            {
                // Use a dummy value in design mode
                attrs.Add("value", "TextBox");
            }
            else
            {
                string attemptedValue = (string)GetModelStateValue(typeof(string));

                if (attemptedValue != null)
                {
                    // Never format the attempted value since it was already formatted in the previous request
                    attrs.Add("value", attemptedValue);
                }
                else
                {
                    // Use an explicit value attribute if it is available. Otherwise get it from ViewData.
                    string attributeValue;
                    Attributes.TryGetValue("value", out attributeValue);
                    object rawValue = attributeValue ?? ViewData.Eval(Name);
                    string stringValue;

                    if (String.IsNullOrEmpty(Format))
                    {
                        stringValue = Convert.ToString(rawValue, CultureInfo.CurrentCulture);
                    }
                    else
                    {
                        stringValue = String.Format(CultureInfo.CurrentCulture, Format, rawValue);
                    }

                    // The HtmlTextWriter will automatically encode this value
                    attrs.Add("value", stringValue);
                }

                // If there are any errors for a named field, we add the CSS attribute.
                ModelState modelState = GetModelState();
                if ((modelState != null) && (modelState.Errors.Count > 0))
                {
                    string currentValue;

                    if (attrs.TryGetValue("class", out currentValue))
                    {
                        attrs["class"] = HtmlHelper.ValidationInputCssClassName + " " + currentValue;
                    }
                    else
                    {
                        attrs["class"] = HtmlHelper.ValidationInputCssClassName;
                    }
                }
            }

            foreach (KeyValuePair<string, string> attribute in attrs)
            {
                writer.AddAttribute(attribute.Key, Convert.ToString(attribute.Value, CultureInfo.CurrentCulture));
            }

            writer.RenderBeginTag(HtmlTextWriterTag.Input);

            writer.RenderEndTag();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/Password.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.Controls
{
    public class Password : MvcInputControl
    {
        public Password()
            : base("password")
        {
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/Repeater.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;
using System.Web.UI;

namespace Microsoft.Web.Mvc.Controls
{
    [ParseChildren(true)]
    [PersistChildren(false)]
    public class Repeater : MvcControl
    {
        private string _name;

        [DefaultValue(null)]
        [Browsable(false)]
        [PersistenceMode(PersistenceMode.InnerProperty)]
        [TemplateContainer(typeof(RepeaterItem))]
        [TemplateInstance(TemplateInstance.Multiple)]
        public ITemplate ItemTemplate { get; set; }

        [DefaultValue(null)]
        [Browsable(false)]
        [PersistenceMode(PersistenceMode.InnerProperty)]
        [TemplateContainer(typeof(RepeaterItem))]
        [TemplateInstance(TemplateInstance.Single)]
        public ITemplate EmptyDataTemplate { get; set; }

        [DefaultValue("")]
        public string Name
        {
            get { return _name ?? String.Empty; }
            set { _name = value; }
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The child objects are disposed when their container is disposed")]
        protected override void OnPreRender(EventArgs e)
        {
            base.OnPreRender(e);

            // Dummy control to which we parent all the data item controls
            Control containerControl = new Control();

            IEnumerable dataItems = ViewData.Eval(Name) as IEnumerable;
            bool hasData = false;
            if (dataItems != null)
            {
                int index = 0;
                foreach (object dataItem in dataItems)
                {
                    hasData = true;
                    RepeaterItem repeaterItem = new RepeaterItem(index, dataItem)
                    {
                        ViewData = new ViewDataDictionary(dataItem),
                    };
                    ItemTemplate.InstantiateIn(repeaterItem);
                    containerControl.Controls.Add(repeaterItem);

                    index++;
                }
            }

            if (!hasData)
            {
                // If there was no data, instantiate the EmptyDataTemplate
                Control emptyDataContainer = new Control();
                EmptyDataTemplate.InstantiateIn(emptyDataContainer);
                containerControl.Controls.Add(emptyDataContainer);
            }

            Controls.Add(containerControl);

            containerControl.DataBind();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/RepeaterItem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;
using System.Web.UI;

namespace Microsoft.Web.Mvc.Controls
{
    public class RepeaterItem : Control, IDataItemContainer, IViewDataContainer
    {
        private object _dataItem;
        private int _itemIndex;

        public RepeaterItem(int itemIndex, object dataItem)
        {
            _itemIndex = itemIndex;
            _dataItem = dataItem;
        }

        public object DataItem
        {
            get { return _dataItem; }
        }

        public int DataItemIndex
        {
            get { return _itemIndex; }
        }

        public int DisplayIndex
        {
            get { return _itemIndex; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is intended to be settable for unit testing purposes.")]
        public ViewDataDictionary ViewData { get; set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/RouteValues.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.UI;

namespace Microsoft.Web.Mvc.Controls
{
    public class RouteValues : IAttributeAccessor
    {
        private IDictionary<string, string> _attributes;

        public IDictionary<string, string> Attributes
        {
            get
            {
                EnsureAttributes();
                return _attributes;
            }
        }

        private void EnsureAttributes()
        {
            if (_attributes == null)
            {
                _attributes = new SortedDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            }
        }

        protected virtual string GetAttribute(string key)
        {
            EnsureAttributes();
            string value;
            _attributes.TryGetValue(key, out value);
            return value;
        }

        protected virtual void SetAttribute(string key, string value)
        {
            EnsureAttributes();
            _attributes[key] = value;
        }

        #region IAttributeAccessor Members

        string IAttributeAccessor.GetAttribute(string key)
        {
            return GetAttribute(key);
        }

        void IAttributeAccessor.SetAttribute(string key, string value)
        {
            SetAttribute(key, value);
        }

        #endregion
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Controls/TextBox.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.Controls
{
    public class TextBox : MvcInputControl
    {
        public TextBox()
            : base("text")
        {
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/CookieValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Web;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public class CookieValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            HttpCookieCollection cookies = controllerContext.HttpContext.Request.Cookies;

            Dictionary<string, string> backingStore = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            for (int i = 0; i < cookies.Count; i++)
            {
                HttpCookie cookie = cookies[i];
                if (!String.IsNullOrEmpty(cookie.Name))
                {
                    backingStore[cookie.Name] = cookie.Value;
                }
            }

            return new DictionaryValueProvider<string>(backingStore, CultureInfo.InvariantCulture);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/CopyAsyncParametersAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using System.Web.Mvc.Async;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class CopyAsyncParametersAttribute : ActionFilterAttribute
    {
        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            IAsyncManagerContainer container = filterContext.Controller as IAsyncManagerContainer;
            if (container != null)
            {
                AsyncManager asyncManager = container.AsyncManager;
                foreach (var entry in filterContext.ActionParameters)
                {
                    asyncManager.Parameters[entry.Key] = entry.Value;
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/CreditCardAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public sealed class CreditCardAttribute : DataTypeAttribute, IClientValidatable
    {
        public CreditCardAttribute()
            : base("creditcard")
        {
            ErrorMessage = MvcResources.CreditCardAttribute_Invalid;
        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            yield return new ModelClientValidationRule
            {
                ValidationType = "creditcard",
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName())
            };
        }

        public override bool IsValid(object value)
        {
            if (value == null)
            {
                return true;
            }

            string creditCardNumber = value as string;
            if (creditCardNumber == null)
            {
                return false;
            }
            creditCardNumber = creditCardNumber.Replace("-", String.Empty);

            int checksum = 0;
            bool evenDigit = false;

            // http://www.beachnet.com/~hstiles/cardtype.html
            foreach (char digit in creditCardNumber.Reverse())
            {
                if (!Char.IsDigit(digit))
                {
                    return false;
                }

                int digitValue = (digit - '0') * (evenDigit ? 2 : 1);
                evenDigit = !evenDigit;

                while (digitValue > 0)
                {
                    checksum += digitValue % 10;
                    digitValue /= 10;
                }
            }

            return (checksum % 10) == 0;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/CssExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    public static class CssExtensions
    {
        public static MvcHtmlString Css(this HtmlHelper helper, string file)
        {
            return Css(helper, file, null);
        }

        public static MvcHtmlString Css(this HtmlHelper helper, string file, string mediaType)
        {
            if (String.IsNullOrEmpty(file))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "file");
            }

            string src;
            if (ScriptExtensions.IsRelativeToDefaultPath(file))
            {
                src = "~/Content/" + file;
            }
            else
            {
                src = file;
            }

            TagBuilder linkTag = new TagBuilder("link");
            linkTag.MergeAttribute("type", "text/css");
            linkTag.MergeAttribute("rel", "stylesheet");
            if (mediaType != null)
            {
                linkTag.MergeAttribute("media", mediaType);
            }
            linkTag.MergeAttribute("href", UrlHelper.GenerateContentUrl(src, helper.ViewContext.HttpContext));
            return MvcHtmlString.Create(linkTag.ToString(TagRenderMode.SelfClosing));
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/DeserializeAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
    public sealed class DeserializeAttribute : CustomModelBinderAttribute
    {
        public DeserializeAttribute()
        {
        }

        internal MvcSerializer Serializer { get; set; }

        public override IModelBinder GetBinder()
        {
            return new DeserializingModelBinder(Serializer);
        }

        private sealed class DeserializingModelBinder : IModelBinder
        {
            private readonly MvcSerializer _serializer;

            public DeserializingModelBinder(MvcSerializer serializer)
            {
                _serializer = serializer ?? new MvcSerializer();
            }

            [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Mvc.ValueProviderResult.ConvertTo(System.Type)", Justification = "The target object should make the correct culture determination, not this method.")]
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                if (bindingContext == null)
                {
                    throw new ArgumentNullException("bindingContext");
                }

                ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
                if (valueProviderResult == null)
                {
                    // nothing found
                    return null;
                }

                string serializedValue = (string)valueProviderResult.ConvertTo(typeof(string));
                return _serializer.Deserialize(serializedValue);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/DynamicReflectionObject.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    internal class DynamicReflectionObject : DynamicObject
    {
        private readonly object _realObject;

        private DynamicReflectionObject(object realObject)
        {
            _realObject = realObject;
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            PropertyInfo propInfo = _realObject.GetType().GetProperty(binder.Name);

            if (propInfo == null)
            {
                PropertyInfo[] properties = _realObject.GetType().GetProperties();
                if (properties.Length == 0)
                {
                    throw new InvalidOperationException(
                        String.Format(CultureInfo.CurrentCulture,
                                      MvcResources.DynamicViewPage_NoProperties,
                                      binder.Name));
                }

                string propNames = properties.Select(p => p.Name)
                    .OrderBy(name => name)
                    .Aggregate((left, right) => left + ", " + right);

                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  MvcResources.DynamicViewPage_PropertyDoesNotExist,
                                  binder.Name,
                                  propNames));
            }

            result = Wrap(propInfo.GetValue(_realObject, null));
            return true;
        }

        public static dynamic Wrap(object obj)
        {
            // We really only want to wrap anonymous objects, but there's no surefire way to determine
            // that an object is anonymous. We'll use the best metrics we can (internal non-nested type
            // that derives directly from Object).
            if (obj != null)
            {
                Type type = obj.GetType();
                if (!type.IsPublic && type.BaseType == typeof(Object) && type.DeclaringType == null)
                {
                    return new DynamicReflectionObject(obj);
                }
            }

            return obj;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/DynamicViewDataDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Dynamic;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    internal class DynamicViewDataDictionary : DynamicObject
    {
        private readonly ViewDataDictionary _dictionary;

        private DynamicViewDataDictionary(ViewDataDictionary dictionary)
        {
            _dictionary = dictionary;
        }

        public object Model
        {
            get { return _dictionary.Model; }
            set { _dictionary.Model = value; }
        }

        public ModelMetadata ModelMetadata
        {
            get { return _dictionary.ModelMetadata; }
            set { _dictionary.ModelMetadata = value; }
        }

        public ModelStateDictionary ModelState
        {
            get { return _dictionary.ModelState; }
        }

        public TemplateInfo TemplateInfo
        {
            get { return _dictionary.TemplateInfo; }
            set { _dictionary.TemplateInfo = value; }
        }

        private bool GetValue(string name, out object result)
        {
            result = DynamicReflectionObject.Wrap(_dictionary.Eval(name)) ?? String.Empty;
            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            if (indexes.Length != 1)
            {
                throw new ArgumentException(MvcResources.DynamicViewDataDictionary_SingleIndexerOnly);
            }

            string name = indexes[0] as string;
            if (name == null)
            {
                throw new ArgumentException(MvcResources.DynamicViewDataDictionary_StringIndexerOnly);
            }

            return GetValue(name, out result);
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            return GetValue(binder.Name, out result);
        }

        public static dynamic Wrap(ViewDataDictionary dictionary)
        {
            return new DynamicViewDataDictionary(dictionary);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/DynamicViewPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public class DynamicViewPage : ViewPage
    {
        public new dynamic Model
        {
            get { return DynamicReflectionObject.Wrap(base.Model); }
        }

        public new dynamic ViewData
        {
            get { return DynamicViewDataDictionary.Wrap(base.ViewData); }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/DynamicViewPageOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public class DynamicViewPage<TModel> : ViewPage<TModel>
    {
        public new dynamic ViewData
        {
            get { return DynamicViewDataDictionary.Wrap(base.ViewData); }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ElementalValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    // Represents a value provider that contains a single value.
    internal sealed class ElementalValueProvider : IValueProvider
    {
        public ElementalValueProvider(string name, object rawValue, CultureInfo culture)
        {
            Name = name;
            RawValue = rawValue;
            Culture = culture;
        }

        public CultureInfo Culture { get; private set; }

        public string Name { get; private set; }

        public object RawValue { get; private set; }

        public bool ContainsPrefix(string prefix)
        {
            return ValueProviderUtil.IsPrefixMatch(prefix, Name);
        }

        public ValueProviderResult GetValue(string key)
        {
            return (String.Equals(key, Name, StringComparison.OrdinalIgnoreCase))
                       ? new ValueProviderResult(RawValue, Convert.ToString(RawValue, Culture), Culture)
                       : null;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/EmailAddressAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Text.RegularExpressions;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public sealed class EmailAddressAttribute : DataTypeAttribute, IClientValidatable
    {
        private static Regex _regex = new Regex(@"^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);

        public EmailAddressAttribute()
            : base(DataType.EmailAddress)
        {
            ErrorMessage = MvcResources.EmailAddressAttribute_Invalid;
        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            yield return new ModelClientValidationRule
            {
                ValidationType = "email",
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName())
            };
        }

        public override bool IsValid(object value)
        {
            if (value == null)
            {
                return true;
            }

            string valueAsString = value as string;
            return valueAsString != null && _regex.Match(valueAsString).Length > 0;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Error.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    internal static class Error
    {
        public static InvalidOperationException BindingBehavior_ValueNotFound(string fieldName)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.BindingBehavior_ValueNotFound,
                                               fieldName);
            return new InvalidOperationException(errorString);
        }

        public static ArgumentException Common_TypeMustImplementInterface(Type providedType, Type requiredInterfaceType, string parameterName)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.Common_TypeMustImplementInterface,
                                               providedType, requiredInterfaceType);
            return new ArgumentException(errorString, parameterName);
        }

        public static ArgumentException GenericModelBinderProvider_ParameterMustSpecifyOpenGenericType(Type specifiedType, string parameterName)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.GenericModelBinderProvider_ParameterMustSpecifyOpenGenericType,
                                               specifiedType);
            return new ArgumentException(errorString, parameterName);
        }

        public static ArgumentException GenericModelBinderProvider_TypeArgumentCountMismatch(Type modelType, Type modelBinderType)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.GenericModelBinderProvider_TypeArgumentCountMismatch,
                                               modelType, modelType.GetGenericArguments().Length, modelBinderType, modelBinderType.GetGenericArguments().Length);
            return new ArgumentException(errorString, "modelBinderType");
        }

        public static InvalidOperationException ModelBinderProviderCollection_BinderForTypeNotFound(Type modelType)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.ModelBinderProviderCollection_BinderForTypeNotFound,
                                               modelType);
            return new InvalidOperationException(errorString);
        }

        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "The purpose of this class is to throw errors on behalf of other methods")]
        public static ArgumentException ModelBinderUtil_ModelCannotBeNull(Type expectedType)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.ModelBinderUtil_ModelCannotBeNull,
                                               expectedType);
            return new ArgumentException(errorString, "bindingContext");
        }

        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "The purpose of this class is to throw errors on behalf of other methods")]
        public static ArgumentException ModelBinderUtil_ModelInstanceIsWrong(Type actualType, Type expectedType)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.ModelBinderUtil_ModelInstanceIsWrong,
                                               actualType, expectedType);
            return new ArgumentException(errorString, "bindingContext");
        }

        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "The purpose of this class is to throw errors on behalf of other methods")]
        public static ArgumentException ModelBinderUtil_ModelMetadataCannotBeNull()
        {
            return new ArgumentException(MvcResources.ModelBinderUtil_ModelMetadataCannotBeNull, "bindingContext");
        }

        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "The purpose of this class is to throw errors on behalf of other methods")]
        public static ArgumentException ModelBinderUtil_ModelTypeIsWrong(Type actualType, Type expectedType)
        {
            string errorString = String.Format(CultureInfo.CurrentCulture, MvcResources.ModelBinderUtil_ModelTypeIsWrong,
                                               actualType, expectedType);
            return new ArgumentException(errorString, "bindingContext");
        }

        public static InvalidOperationException ModelBindingContext_ModelMetadataMustBeSet()
        {
            return new InvalidOperationException(MvcResources.ModelBindingContext_ModelMetadataMustBeSet);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/BinaryExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // BinaryExpression fingerprint class
    // Useful for things like array[index]

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class BinaryExpressionFingerprint : ExpressionFingerprint
    {
        public BinaryExpressionFingerprint(ExpressionType nodeType, Type type, MethodInfo method)
            : base(nodeType, type)
        {
            // Other properties on BinaryExpression (like IsLifted / IsLiftedToNull) are simply derived
            // from Type and NodeType, so they're not necessary for inclusion in the fingerprint.

            Method = method;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.binaryexpression.method.aspx
        public MethodInfo Method { get; private set; }

        public override bool Equals(object obj)
        {
            BinaryExpressionFingerprint other = obj as BinaryExpressionFingerprint;
            return (other != null)
                   && Equals(this.Method, other.Method)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Method);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/CachedExpressionCompiler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    internal static class CachedExpressionCompiler
    {
        // This is the entry point to the cached expression compilation system. The system
        // will try to turn the expression into an actual delegate as quickly as possible,
        // relying on cache lookups and other techniques to save time if appropriate.
        // If the provided expression is particularly obscure and the system doesn't know
        // how to handle it, we'll just compile the expression as normal.
        public static Func<TModel, TValue> Process<TModel, TValue>(Expression<Func<TModel, TValue>> lambdaExpression)
        {
            return Compiler<TModel, TValue>.Compile(lambdaExpression);
        }

        private static class Compiler<TIn, TOut>
        {
            private static Func<TIn, TOut> _identityFunc;

            private static readonly ConcurrentDictionary<MemberInfo, Func<TIn, TOut>> _simpleMemberAccessDict =
                new ConcurrentDictionary<MemberInfo, Func<TIn, TOut>>();

            private static readonly ConcurrentDictionary<MemberInfo, Func<object, TOut>> _constMemberAccessDict =
                new ConcurrentDictionary<MemberInfo, Func<object, TOut>>();

            private static readonly ConcurrentDictionary<ExpressionFingerprintChain, Hoisted<TIn, TOut>> _fingerprintedCache =
                new ConcurrentDictionary<ExpressionFingerprintChain, Hoisted<TIn, TOut>>();

            public static Func<TIn, TOut> Compile(Expression<Func<TIn, TOut>> expr)
            {
                return CompileFromIdentityFunc(expr)
                       ?? CompileFromConstLookup(expr)
                       ?? CompileFromMemberAccess(expr)
                       ?? CompileFromFingerprint(expr)
                       ?? CompileSlow(expr);
            }

            private static Func<TIn, TOut> CompileFromConstLookup(Expression<Func<TIn, TOut>> expr)
            {
                ConstantExpression constExpr = expr.Body as ConstantExpression;
                if (constExpr != null)
                {
                    // model => {const}

                    TOut constantValue = (TOut)constExpr.Value;
                    return _ => constantValue;
                }

                return null;
            }

            private static Func<TIn, TOut> CompileFromIdentityFunc(Expression<Func<TIn, TOut>> expr)
            {
                if (expr.Body == expr.Parameters[0])
                {
                    // model => model

                    // don't need to lock, as all identity funcs are identical
                    if (_identityFunc == null)
                    {
                        _identityFunc = expr.Compile();
                    }

                    return _identityFunc;
                }

                return null;
            }

            private static Func<TIn, TOut> CompileFromFingerprint(Expression<Func<TIn, TOut>> expr)
            {
                List<object> capturedConstants;
                ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

                if (fingerprint != null)
                {
                    var del = _fingerprintedCache.GetOrAdd(fingerprint, _ =>
                    {
                        // Fingerprinting succeeded, but there was a cache miss. Rewrite the expression
                        // and add the rewritten expression to the cache.

                        var hoistedExpr = HoistingExpressionVisitor<TIn, TOut>.Hoist(expr);
                        return hoistedExpr.Compile();
                    });
                    return model => del(model, capturedConstants);
                }

                // couldn't be fingerprinted
                return null;
            }

            private static Func<TIn, TOut> CompileFromMemberAccess(Expression<Func<TIn, TOut>> expr)
            {
                // Performance tests show that on the x64 platform, special-casing static member and
                // captured local variable accesses is faster than letting the fingerprinting system
                // handle them. On the x86 platform, the fingerprinting system is faster, but only
                // by around one microsecond, so it's not worth it to complicate the logic here with
                // an architecture check.

                MemberExpression memberExpr = expr.Body as MemberExpression;
                if (memberExpr != null)
                {
                    if (memberExpr.Expression == expr.Parameters[0] || memberExpr.Expression == null)
                    {
                        // model => model.Member or model => StaticMember
                        return _simpleMemberAccessDict.GetOrAdd(memberExpr.Member, _ => expr.Compile());
                    }

                    ConstantExpression constExpr = memberExpr.Expression as ConstantExpression;
                    if (constExpr != null)
                    {
                        // model => {const}.Member (captured local variable)
                        var del = _constMemberAccessDict.GetOrAdd(memberExpr.Member, _ =>
                        {
                            // rewrite as capturedLocal => ((TDeclaringType)capturedLocal).Member
                            var constParamExpr = Expression.Parameter(typeof(object), "capturedLocal");
                            var constCastExpr = Expression.Convert(constParamExpr, memberExpr.Member.DeclaringType);
                            var newMemberAccessExpr = memberExpr.Update(constCastExpr);
                            var newLambdaExpr = Expression.Lambda<Func<object, TOut>>(newMemberAccessExpr, constParamExpr);
                            return newLambdaExpr.Compile();
                        });

                        object capturedLocal = constExpr.Value;
                        return _ => del(capturedLocal);
                    }
                }

                return null;
            }

            private static Func<TIn, TOut> CompileSlow(Expression<Func<TIn, TOut>> expr)
            {
                // fallback compilation system - just compile the expression directly
                return expr.Compile();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/ConditionalExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // ConditionalExpression fingerprint class
    // Expression of form (test) ? ifTrue : ifFalse

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class ConditionalExpressionFingerprint : ExpressionFingerprint
    {
        public ConditionalExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on ConditionalExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            ConditionalExpressionFingerprint other = obj as ConditionalExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/ConstantExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // ConstantExpression fingerprint class
    //
    // A ConstantExpression might represent a captured local variable, so we can't compile
    // the value directly into the cached function. Instead, a placeholder is generated
    // and the value is hoisted into a local variables array. This placeholder can then
    // be compiled and cached, and the array lookup happens at runtime.

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class ConstantExpressionFingerprint : ExpressionFingerprint
    {
        public ConstantExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on ConstantExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            ConstantExpressionFingerprint other = obj as ConstantExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/DefaultExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // DefaultExpression fingerprint class
    // Expression of form default(T)

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class DefaultExpressionFingerprint : ExpressionFingerprint
    {
        public DefaultExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on DefaultExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            DefaultExpressionFingerprint other = obj as DefaultExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/ExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq.Expressions;

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // Serves as the base class for all expression fingerprints. Provides a default implementation
    // of GetHashCode().

    internal abstract class ExpressionFingerprint
    {
        protected ExpressionFingerprint(ExpressionType nodeType, Type type)
        {
            NodeType = nodeType;
            Type = type;
        }

        // the type of expression node, e.g. OP_ADD, MEMBER_ACCESS, etc.
        public ExpressionType NodeType { get; private set; }

        // the CLR type resulting from this expression, e.g. int, string, etc.
        public Type Type { get; private set; }

        internal virtual void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddInt32((int)NodeType);
            combiner.AddObject(Type);
        }

        protected bool Equals(ExpressionFingerprint other)
        {
            return (other != null)
                   && (this.NodeType == other.NodeType)
                   && Equals(this.Type, other.Type);
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as ExpressionFingerprint);
        }

        public override int GetHashCode()
        {
            HashCodeCombiner combiner = new HashCodeCombiner();
            AddToHashCodeCombiner(combiner);
            return combiner.CombinedHash;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/ExpressionFingerprintChain.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // Expression fingerprint chain class
    // Contains information used for generalizing, comparing, and recreating Expression instances
    //
    // Since Expression objects are immutable and are recreated for every invocation of an expression
    // helper method, they can't be compared directly. Fingerprinting Expression objects allows
    // information about them to be abstracted away, and the fingerprints can be directly compared.
    // Consider the process of fingerprinting that all values (parameters, constants, etc.) are hoisted
    // and replaced with dummies. What remains can be decomposed into a sequence of operations on specific
    // types and specific inputs.
    //
    // Some sample fingerprints chains:
    //
    // 2 + 4 -> OP_ADD, CONST:int, NULL, CONST:int
    // 2 + 8 -> OP_ADD, CONST:int, NULL, CONST:int
    // 2.0 + 4.0 -> OP_ADD, CONST:double, NULL, CONST:double
    //
    // 2 + 4 and 2 + 8 have the same fingerprint, but 2.0 + 4.0 has a different fingerprint since its
    // underlying types differ. Note that this looks a bit like prefix notation and is a side effect
    // of how the ExpressionVisitor class recurses into expressions. (Occasionally there will be a NULL
    // in the fingerprint chain, which depending on context can denote a static member, a null Conversion
    // in a BinaryExpression, and so forth.)
    //
    // "Hello " + "world" -> OP_ADD, CONST:string, NULL, CONST:string
    // "Hello " + {model} -> OP_ADD, CONST:string, NULL, PARAM_0:string
    //
    // These string concatenations have different fingerprints since the inputs are provided differently:
    // one is a constant, the other is a parameter.
    //
    // ({model} ?? "sample").Length -> MEMBER_ACCESS(String.Length), OP_COALESCE, PARAM_0:string, NULL, CONST:string
    // ({model} ?? "other sample").Length -> MEMBER_ACCESS(String.Length), OP_COALESCE, PARAM_0:string, NULL, CONST:string
    //
    // These expressions have the same fingerprint since all constants of the same underlying type are
    // treated equally.
    //
    // It's also important that the fingerprints don't reference the actual Expression objects that were
    // used to generate them, as the fingerprints will be cached, and caching a fingerprint that references
    // an Expression will root the Expression (and any objects it references).

    internal sealed class ExpressionFingerprintChain : IEquatable<ExpressionFingerprintChain>
    {
        public readonly List<ExpressionFingerprint> Elements = new List<ExpressionFingerprint>();

        public bool Equals(ExpressionFingerprintChain other)
        {
            // Two chains are considered equal if two elements appearing in the same index in
            // each chain are equal (value equality, not referential equality).

            if (other == null)
            {
                return false;
            }

            if (this.Elements.Count != other.Elements.Count)
            {
                return false;
            }

            for (int i = 0; i < this.Elements.Count; i++)
            {
                if (!Equals(this.Elements[i], other.Elements[i]))
                {
                    return false;
                }
            }

            return true;
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as ExpressionFingerprintChain);
        }

        public override int GetHashCode()
        {
            HashCodeCombiner combiner = new HashCodeCombiner();
            Elements.ForEach(combiner.AddFingerprint);
            return combiner.CombinedHash;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/FingerprintingExpressionVisitor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // This is a visitor which produces a fingerprint of an expression. It doesn't
    // rewrite the expression in a form which can be compiled and cached.

    internal sealed class FingerprintingExpressionVisitor : ExpressionVisitor
    {
        private readonly List<object> _seenConstants = new List<object>();
        private readonly List<ParameterExpression> _seenParameters = new List<ParameterExpression>();
        private readonly ExpressionFingerprintChain _currentChain = new ExpressionFingerprintChain();
        private bool _gaveUp;

        private FingerprintingExpressionVisitor()
        {
        }

        private T GiveUp<T>(T node)
        {
            // We don't understand this node, so just quit.

            _gaveUp = true;
            return node;
        }

        // Returns the fingerprint chain + captured constants list for this expression, or null
        // if the expression couldn't be fingerprinted.
        public static ExpressionFingerprintChain GetFingerprintChain(Expression expr, out List<object> capturedConstants)
        {
            FingerprintingExpressionVisitor visitor = new FingerprintingExpressionVisitor();
            visitor.Visit(expr);

            if (visitor._gaveUp)
            {
                capturedConstants = null;
                return null;
            }
            else
            {
                capturedConstants = visitor._seenConstants;
                return visitor._currentChain;
            }
        }

        public override Expression Visit(Expression node)
        {
            if (node == null)
            {
                _currentChain.Elements.Add(null);
                return null;
            }
            else
            {
                return base.Visit(node);
            }
        }

        protected override Expression VisitBinary(BinaryExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new BinaryExpressionFingerprint(node.NodeType, node.Type, node.Method));
            return base.VisitBinary(node);
        }

        protected override Expression VisitBlock(BlockExpression node)
        {
            return GiveUp(node);
        }

        protected override CatchBlock VisitCatchBlock(CatchBlock node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitConditional(ConditionalExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new ConditionalExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitConditional(node);
        }

        protected override Expression VisitConstant(ConstantExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }

            _seenConstants.Add(node.Value);
            _currentChain.Elements.Add(new ConstantExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitConstant(node);
        }

        protected override Expression VisitDebugInfo(DebugInfoExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitDefault(DefaultExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new DefaultExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitDefault(node);
        }

        protected override Expression VisitDynamic(DynamicExpression node)
        {
            return GiveUp(node);
        }

        protected override ElementInit VisitElementInit(ElementInit node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitExtension(Expression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitGoto(GotoExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitIndex(IndexExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new IndexExpressionFingerprint(node.NodeType, node.Type, node.Indexer));
            return base.VisitIndex(node);
        }

        protected override Expression VisitInvocation(InvocationExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitLabel(LabelExpression node)
        {
            return GiveUp(node);
        }

        protected override LabelTarget VisitLabelTarget(LabelTarget node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitLambda<T>(Expression<T> node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new LambdaExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitLambda(node);
        }

        protected override Expression VisitListInit(ListInitExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitLoop(LoopExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitMember(MemberExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new MemberExpressionFingerprint(node.NodeType, node.Type, node.Member));
            return base.VisitMember(node);
        }

        protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
        {
            return GiveUp(node);
        }

        protected override MemberBinding VisitMemberBinding(MemberBinding node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitMemberInit(MemberInitExpression node)
        {
            return GiveUp(node);
        }

        protected override MemberListBinding VisitMemberListBinding(MemberListBinding node)
        {
            return GiveUp(node);
        }

        protected override MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new MethodCallExpressionFingerprint(node.NodeType, node.Type, node.Method));
            return base.VisitMethodCall(node);
        }

        protected override Expression VisitNew(NewExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitNewArray(NewArrayExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }

            int parameterIndex = _seenParameters.IndexOf(node);
            if (parameterIndex < 0)
            {
                // first time seeing this parameter
                parameterIndex = _seenParameters.Count;
                _seenParameters.Add(node);
            }

            _currentChain.Elements.Add(new ParameterExpressionFingerprint(node.NodeType, node.Type, parameterIndex));
            return base.VisitParameter(node);
        }

        protected override Expression VisitRuntimeVariables(RuntimeVariablesExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitSwitch(SwitchExpression node)
        {
            return GiveUp(node);
        }

        protected override SwitchCase VisitSwitchCase(SwitchCase node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitTry(TryExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitTypeBinary(TypeBinaryExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new TypeBinaryExpressionFingerprint(node.NodeType, node.Type, node.TypeOperand));
            return base.VisitTypeBinary(node);
        }

        protected override Expression VisitUnary(UnaryExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new UnaryExpressionFingerprint(node.NodeType, node.Type, node.Method));
            return base.VisitUnary(node);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/HashCodeCombiner.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // based on System.Web.Util.HashCodeCombiner
    internal class HashCodeCombiner
    {
        private long _combinedHash64 = 0x1505L;

        public int CombinedHash
        {
            get { return _combinedHash64.GetHashCode(); }
        }

        public void AddFingerprint(ExpressionFingerprint fingerprint)
        {
            if (fingerprint != null)
            {
                fingerprint.AddToHashCodeCombiner(this);
            }
            else
            {
                AddInt32(0);
            }
        }

        public void AddEnumerable(IEnumerable e)
        {
            if (e == null)
            {
                AddInt32(0);
            }
            else
            {
                int count = 0;
                foreach (object o in e)
                {
                    AddObject(o);
                    count++;
                }
                AddInt32(count);
            }
        }

        public void AddInt32(int i)
        {
            _combinedHash64 = ((_combinedHash64 << 5) + _combinedHash64) ^ i;
        }

        public void AddObject(object o)
        {
            int hashCode = (o != null) ? o.GetHashCode() : 0;
            AddInt32(hashCode);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/Hoisted.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    internal delegate TValue Hoisted<TModel, TValue>(TModel model, List<object> capturedConstants);
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/HoistingExpressionVisitor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq.Expressions;

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // This is a visitor which rewrites constant expressions as parameter lookups. It's meant
    // to produce an expression which can be cached safely.

    internal sealed class HoistingExpressionVisitor<TIn, TOut> : ExpressionVisitor
    {
        private static readonly ParameterExpression _hoistedConstantsParamExpr = Expression.Parameter(typeof(List<object>), "hoistedConstants");
        private int _numConstantsProcessed;

        // factory will create instance
        private HoistingExpressionVisitor()
        {
        }

        public static Expression<Hoisted<TIn, TOut>> Hoist(Expression<Func<TIn, TOut>> expr)
        {
            // rewrite Expression<Func<TIn, TOut>> as Expression<Hoisted<TIn, TOut>>

            var visitor = new HoistingExpressionVisitor<TIn, TOut>();
            var rewrittenBodyExpr = visitor.Visit(expr.Body);
            var rewrittenLambdaExpr = Expression.Lambda<Hoisted<TIn, TOut>>(rewrittenBodyExpr, expr.Parameters[0], _hoistedConstantsParamExpr);
            return rewrittenLambdaExpr;
        }

        protected override Expression VisitConstant(ConstantExpression node)
        {
            // rewrite the constant expression as (TConst)hoistedConstants[i];
            return Expression.Convert(Expression.Property(_hoistedConstantsParamExpr, "Item", Expression.Constant(_numConstantsProcessed++)), node.Type);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/IndexExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // IndexExpression fingerprint class
    // Represents certain forms of array access or indexer property access

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class IndexExpressionFingerprint : ExpressionFingerprint
    {
        public IndexExpressionFingerprint(ExpressionType nodeType, Type type, PropertyInfo indexer)
            : base(nodeType, type)
        {
            // Other properties on IndexExpression (like the argument count) are simply derived
            // from Type and Indexer, so they're not necessary for inclusion in the fingerprint.

            Indexer = indexer;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.indexexpression.indexer.aspx
        public PropertyInfo Indexer { get; private set; }

        public override bool Equals(object obj)
        {
            IndexExpressionFingerprint other = obj as IndexExpressionFingerprint;
            return (other != null)
                   && Equals(this.Indexer, other.Indexer)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Indexer);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/LambdaExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // LambdaExpression fingerprint class
    // Represents a lambda expression (root element in Expression<T>)

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class LambdaExpressionFingerprint : ExpressionFingerprint
    {
        public LambdaExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on LambdaExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            LambdaExpressionFingerprint other = obj as LambdaExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/MemberExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // MemberExpression fingerprint class
    // Expression of form xxx.FieldOrProperty

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class MemberExpressionFingerprint : ExpressionFingerprint
    {
        public MemberExpressionFingerprint(ExpressionType nodeType, Type type, MemberInfo member)
            : base(nodeType, type)
        {
            Member = member;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.memberexpression.member.aspx
        public MemberInfo Member { get; private set; }

        public override bool Equals(object obj)
        {
            MemberExpressionFingerprint other = obj as MemberExpressionFingerprint;
            return (other != null)
                   && Equals(this.Member, other.Member)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Member);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/MethodCallExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // MethodCallExpression fingerprint class
    // Expression of form xxx.Foo(...), xxx[...] (get_Item()), etc.

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class MethodCallExpressionFingerprint : ExpressionFingerprint
    {
        public MethodCallExpressionFingerprint(ExpressionType nodeType, Type type, MethodInfo method)
            : base(nodeType, type)
        {
            // Other properties on MethodCallExpression (like the argument count) are simply derived
            // from Type and Indexer, so they're not necessary for inclusion in the fingerprint.

            Method = method;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.methodcallexpression.method.aspx
        public MethodInfo Method { get; private set; }

        public override bool Equals(object obj)
        {
            MethodCallExpressionFingerprint other = obj as MethodCallExpressionFingerprint;
            return (other != null)
                   && Equals(this.Method, other.Method)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Method);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/ParameterExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // ParameterExpression fingerprint class
    // Can represent the model parameter or an inner parameter in an open lambda expression

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class ParameterExpressionFingerprint : ExpressionFingerprint
    {
        public ParameterExpressionFingerprint(ExpressionType nodeType, Type type, int parameterIndex)
            : base(nodeType, type)
        {
            ParameterIndex = parameterIndex;
        }

        // Parameter position within the overall expression, used to maintain alpha equivalence.
        public int ParameterIndex { get; private set; }

        public override bool Equals(object obj)
        {
            ParameterExpressionFingerprint other = obj as ParameterExpressionFingerprint;
            return (other != null)
                   && (this.ParameterIndex == other.ParameterIndex)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddInt32(ParameterIndex);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/TypeBinaryExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // TypeBinary fingerprint class
    // Expression of form "obj is T"

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class TypeBinaryExpressionFingerprint : ExpressionFingerprint
    {
        public TypeBinaryExpressionFingerprint(ExpressionType nodeType, Type type, Type typeOperand)
            : base(nodeType, type)
        {
            TypeOperand = typeOperand;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.typebinaryexpression.typeoperand.aspx
        public Type TypeOperand { get; private set; }

        public override bool Equals(object obj)
        {
            TypeBinaryExpressionFingerprint other = obj as TypeBinaryExpressionFingerprint;
            return (other != null)
                   && Equals(this.TypeOperand, other.TypeOperand)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(TypeOperand);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ExpressionUtil/UnaryExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace Microsoft.Web.Mvc.ExpressionUtil
{
    // UnaryExpression fingerprint class
    // The most common appearance of a UnaryExpression is a cast or other conversion operator

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class UnaryExpressionFingerprint : ExpressionFingerprint
    {
        public UnaryExpressionFingerprint(ExpressionType nodeType, Type type, MethodInfo method)
            : base(nodeType, type)
        {
            // Other properties on UnaryExpression (like IsLifted / IsLiftedToNull) are simply derived
            // from Type and NodeType, so they're not necessary for inclusion in the fingerprint.

            Method = method;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.unaryexpression.method.aspx
        public MethodInfo Method { get; private set; }

        public override bool Equals(object obj)
        {
            UnaryExpressionFingerprint other = obj as UnaryExpressionFingerprint;
            return (other != null)
                   && Equals(this.Method, other.Method)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Method);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/FileExtensionsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public sealed class FileExtensionsAttribute : DataTypeAttribute, IClientValidatable
    {
        private string _extensions;

        public FileExtensionsAttribute()
            : base("upload")
        {
            ErrorMessage = MvcResources.FileExtensionsAttribute_Invalid;
        }

        public string Extensions
        {
            get { return String.IsNullOrWhiteSpace(_extensions) ? "png,jpg,jpeg,gif" : _extensions; }
            set { _extensions = value; }
        }

        private string ExtensionsFormatted
        {
            get { return ExtensionsParsed.Aggregate((left, right) => left + ", " + right); }
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "These strings are normalized to lowercase because they are presented to the user in lowercase format")]
        private string ExtensionsNormalized
        {
            get { return Extensions.Replace(" ", String.Empty).Replace(".", String.Empty).ToLowerInvariant(); }
        }

        private IEnumerable<string> ExtensionsParsed
        {
            get { return ExtensionsNormalized.Split(',').Select(e => "." + e); }
        }

        public override string FormatErrorMessage(string name)
        {
            return String.Format(CultureInfo.CurrentCulture, ErrorMessageString, name, ExtensionsFormatted);
        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule
            {
                ValidationType = "extension",
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName())
            };
            rule.ValidationParameters["extension"] = ExtensionsNormalized;
            yield return rule;
        }

        public override bool IsValid(object value)
        {
            if (value == null)
            {
                return true;
            }

            HttpPostedFileBase valueAsFileBase = value as HttpPostedFileBase;
            if (valueAsFileBase != null)
            {
                return ValidateExtension(valueAsFileBase.FileName);
            }

            string valueAsString = value as string;
            if (valueAsString != null)
            {
                return ValidateExtension(valueAsString);
            }

            return false;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "These strings are normalized to lowercase because they are presented to the user in lowercase format")]
        private bool ValidateExtension(string fileName)
        {
            try
            {
                return ExtensionsParsed.Contains(Path.GetExtension(fileName).ToLowerInvariant());
            }
            catch (ArgumentException)
            {
                return false;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/FormExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.Mvc.Html;

namespace Microsoft.Web.Mvc
{
    public static class FormExtensions
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcForm BeginForm<TController>(this HtmlHelper helper, Expression<Action<TController>> action) where TController : Controller
        {
            return BeginForm(helper, action, FormMethod.Post, null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcForm BeginForm<TController>(this HtmlHelper helper, Expression<Action<TController>> action, FormMethod method) where TController : Controller
        {
            return BeginForm(helper, action, method, null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcForm BeginForm<TController>(this HtmlHelper helper, Expression<Action<TController>> action, FormMethod method, object htmlAttributes) where TController : Controller
        {
            return BeginForm(helper, action, method, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcForm BeginForm<TController>(this HtmlHelper helper, Expression<Action<TController>> action, FormMethod method, IDictionary<string, object> htmlAttributes) where TController : Controller
        {
            TagBuilder tagBuilder = new TagBuilder("form");
            tagBuilder.MergeAttributes(htmlAttributes);
            string formAction = helper.BuildUrlFromExpression(action);
            tagBuilder.MergeAttribute("action", formAction);
            tagBuilder.MergeAttribute("method", HtmlHelper.GetFormMethodString(method));

            helper.ViewContext.Writer.Write(tagBuilder.ToString(TagRenderMode.StartTag));
            return new MvcForm(helper.ViewContext);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/Boolean.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
    private bool? Value {
        get {
            if (ViewData.Model == null) {
                return null;
            }
            return Convert.ToBoolean(ViewData.Model, System.Globalization.CultureInfo.InvariantCulture);
        }
    }
</script>
<% if (ViewData.ModelMetadata.IsNullableValueType) { %>
    <select class="list-box tri-state" disabled="disabled">
        <option value="" <%= Value.HasValue ? "" : "selected='selected'" %>>Not Set</option>
        <option value="true" <%= Value.HasValue && Value.Value ? "selected='selected'" : "" %>>True</option>
        <option value="false" <%= Value.HasValue && !Value.Value ? "selected='selected'" : "" %>>False</option>
    </select>
<% } else { %>
    <input type="checkbox" class="check-box" disabled="disabled" <%= Value.HasValue && Value.Value ? "checked='checked'" : "" %> />
<% } %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/Collection.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<%
    if (Model != null) {
        string oldPrefix = ViewData.TemplateInfo.HtmlFieldPrefix;
        int index = 0;

        ViewData.TemplateInfo.HtmlFieldPrefix = String.Empty;
        
        foreach (object item in (IEnumerable)Model) {
            string fieldName = String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}[{1}]", oldPrefix, index++);
            ViewContext.Writer.Write(Html.DisplayFor(m => item, null, fieldName));
        }
        
        ViewData.TemplateInfo.HtmlFieldPrefix = oldPrefix;
    }
%>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/Decimal.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
    private object FormattedValue {
        get {
            if (ViewData.TemplateInfo.FormattedModelValue == ViewData.ModelMetadata.Model) {
                return String.Format(System.Globalization.CultureInfo.CurrentCulture, "{0:0.00}", ViewData.ModelMetadata.Model);
            }
            return ViewData.TemplateInfo.FormattedModelValue;
        }
    }
</script>
<%= Html.Encode(FormattedValue) %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/EmailAddress.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<a href="mailto:<%= Html.AttributeEncode(Model) %>"><%= Html.Encode(ViewData.TemplateInfo.FormattedModelValue) %></a>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/HiddenInput.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<% if (!ViewData.ModelMetadata.HideSurroundingHtml) { %>
    <%= Html.Encode(ViewData.TemplateInfo.FormattedModelValue) %>
<% } %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/Html.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<%= ViewData.TemplateInfo.FormattedModelValue %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/Object.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
    bool ShouldShow(ModelMetadata metadata) {
        return metadata.ShowForDisplay
            && metadata.ModelType != typeof(System.Data.EntityState)
            && !metadata.IsComplexType
            && !ViewData.TemplateInfo.Visited(metadata);
    }
</script>
<% if (Model == null) { %>
    <%= ViewData.ModelMetadata.NullDisplayText %>
<% } else if (ViewData.TemplateInfo.TemplateDepth > 1) { %>
    <%= ViewData.ModelMetadata.SimpleDisplayText %>
<% } else { %>
    <% foreach (var prop in ViewData.ModelMetadata.Properties.Where(pm => ShouldShow(pm))) { %>
        <% if (prop.HideSurroundingHtml) { %>
            <%= Html.Display(prop.PropertyName) %>
        <% } else { %>
            <% if (!String.IsNullOrEmpty(prop.GetDisplayName())) { %>
                <div class="display-label"><%= prop.GetDisplayName() %></div>
            <% } %>
            <div class="display-field"><%= Html.Display(prop.PropertyName) %></div>
        <% } %>
    <% } %>
<% } %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/String.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<%= Html.Encode(ViewData.TemplateInfo.FormattedModelValue) %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/DisplayTemplates/Url.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<a href="<%= Html.AttributeEncode(Model) %>"><%= Html.Encode(ViewData.TemplateInfo.FormattedModelValue) %></a>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/Boolean.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
    private List<SelectListItem> TriStateValues {
        get {
            return new List<SelectListItem> {
                new SelectListItem { Text = "Not Set", Value = String.Empty, Selected = !Value.HasValue },
                new SelectListItem { Text = "True", Value = "true", Selected = Value.HasValue && Value.Value },
                new SelectListItem { Text = "False", Value = "false", Selected = Value.HasValue && !Value.Value },
            };
        }
    }
    private bool? Value {
        get {
            if (ViewData.Model == null) {
                return null;
            }
            return Convert.ToBoolean(ViewData.Model, System.Globalization.CultureInfo.InvariantCulture);
        }
    }
</script>
<% if (ViewData.ModelMetadata.IsNullableValueType) { %>
    <%= Html.DropDownList("", TriStateValues, new { @class = "list-box tri-state" }) %>
<% } else { %>
    <%= Html.CheckBox("", Value ?? false, new { @class = "check-box" }) %>
<% } %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/Collection.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<%
    if (Model != null) {
        string oldPrefix = ViewData.TemplateInfo.HtmlFieldPrefix;
        int index = 0;

        ViewData.TemplateInfo.HtmlFieldPrefix = String.Empty;
        
        foreach (object item in (IEnumerable)Model) {
            string fieldName = String.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}[{1}]", oldPrefix, index++);
            ViewContext.Writer.Write(Html.EditorFor(m => item, null, fieldName));
        }
        
        ViewData.TemplateInfo.HtmlFieldPrefix = oldPrefix;
    }
%>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/Decimal.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
    private object FormattedValue {
        get {
            if (ViewData.TemplateInfo.FormattedModelValue == ViewData.ModelMetadata.Model) {
                return String.Format(System.Globalization.CultureInfo.CurrentCulture, "{0:0.00}", ViewData.ModelMetadata.Model);
            }
            return ViewData.TemplateInfo.FormattedModelValue;
        }
    }
</script>
<%= Html.TextBox("", FormattedValue, new { @class = "text-box single-line" }) %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/HiddenInput.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
    private object ModelValue {
        get {
            if (Model is System.Data.Linq.Binary) {
                return Convert.ToBase64String(((System.Data.Linq.Binary)Model).ToArray());
            }
            if (Model is byte[]) {
                return Convert.ToBase64String((byte[])Model);
            }
            return Model;
        }
    }
</script>
<% if (!ViewData.ModelMetadata.HideSurroundingHtml) { %>
    <%= Html.Encode(ViewData.TemplateInfo.FormattedModelValue) %>
<% } %>
<%= Html.Hidden("", ModelValue) %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/MultilineText.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<%= Html.TextArea("", ViewData.TemplateInfo.FormattedModelValue.ToString(), 0, 0, new { @class = "text-box multi-line" }) %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/Object.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<script runat="server">
    bool ShouldShow(ModelMetadata metadata) {
        return metadata.ShowForEdit
            && metadata.ModelType != typeof(System.Data.EntityState)
            && !metadata.IsComplexType
            && !ViewData.TemplateInfo.Visited(metadata);
    }
</script>
<% if (ViewData.TemplateInfo.TemplateDepth > 1) { %>
    <% if (Model == null) { %>
        <%= ViewData.ModelMetadata.NullDisplayText %>
    <% } else { %>
        <%= ViewData.ModelMetadata.SimpleDisplayText %>
    <% } %>
<% } else { %>    
    <% foreach (var prop in ViewData.ModelMetadata.Properties.Where(pm => ShouldShow(pm))) { %>
        <% if (prop.HideSurroundingHtml) { %>
            <%= Html.Editor(prop.PropertyName) %>
        <% } else { %>
            <% if (!String.IsNullOrEmpty(Html.Label(prop.PropertyName).ToHtmlString())) { %>
                <div class="editor-label"><%= Html.Label(prop.PropertyName) %></div>
            <% } %>
            <div class="editor-field"><%= Html.Editor(prop.PropertyName) %> <%= Html.ValidationMessage(prop.PropertyName, "*") %></div>
        <% } %>
    <% } %>
<% } %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/Password.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<%= Html.Password("", ViewData.TemplateInfo.FormattedModelValue, new { @class = "text-box single-line password" })%>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/DefaultTemplates/EditorTemplates/String.ascx
================================================
<%@ Control Language="C#" Inherits="System.Web.Mvc.ViewUserControl" %>
<%= Html.TextBox("", ViewData.TemplateInfo.FormattedModelValue, new { @class = "text-box single-line" }) %>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/iismap.vbs
================================================
Const HKEY_LOCAL_MACHINE = &H80000002
Const MACHINE_NAME = "localhost"
Const DEFAULT_PATH = "W3SVC"
Const SCRIPT_MAPS = "ScriptMaps"

Function ExtensionExists(extension, fxVersion)
    Dim scriptExtension
    iisScriptMaps = GetScriptMaps()
    
    For scriptIndex = 0 To UBound(iisScriptMaps)
        scriptMap = iisScriptMaps(scriptIndex)
        decomposedScriptMap = Split(scriptMap, ",")
        scriptExtension = Right(decomposedScriptMap(0), Len(decomposedScriptMap(0))-1)
        If StrComp(LCase(scriptExtension), LCase(extension)) = 0 Then
          If InStr(scriptMap, fxVersion) > 0 Then
              ExtensionExists = true
            End If
        End If
    Next
    
    ExtensionExists = false
End Function

Function GetFrameworkPath(fxVersion)
    strComputer = "."
    Set registryObj = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\default:StdRegProv")
 
    strKeyPath = "SOFTWARE\Microsoft\.NETFramework"
    strValueName = "InstallRoot"
    registryObj.GetStringValue HKEY_LOCAL_MACHINE, strKeyPath, strValueName, strValue

    GetFrameworkPath = strValue & fxVersion
End Function

Function GetFrameworkVersions()
    strComputer = "."
    Set registryObj = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\default:StdRegProv")
    strKeyPath = "SOFTWARE\Microsoft\.NETFramework"
    registryObj.EnumKey HKEY_LOCAL_MACHINE, strKeyPath, arrSubKeys
    Set regex = New RegExp
    regex.Pattern = "^(v(2|4)\.\d+\.\d+(\.\d+)?)$"
    regex.Global = True
    ReDim fxVersions(0)

    For Each key in arrSubKeys
        If regex.Test(key) Then
            ReDim Preserve fxVersions(UBound(fxVersions)+1)
            fxVersions(UBound(fxVersions)-1) = key
        End If
    Next
   
    If UBound(fxVersions) > 0 Then
        Redim Preserve fxVersions(UBound(fxVersions)-1)
    End If
  
    GetFrameworkVersions = fxVersions
End Function

Function IsValidFrameworkVersion(fxVersion)
    strComputer = "."
    Set registryObj = GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & strComputer & "\root\default:StdRegProv")
    strKeyPath = "SOFTWARE\Microsoft\.NETFramework\" & fxVersion
    registryObj.EnumKey HKEY_LOCAL_MACHINE, strKeyPath, arrSubKeys
    
    IsValidFrameworkVersion = Not IsNull(arrSubKeys)
End Function

Function GetScriptMaps()
    Dim iisObject
    Set iisObject = GetObject("IIS://" & MACHINE_NAME & "/" & DEFAULT_PATH)   
    GetScriptMaps = iisObject.Get(SCRIPT_MAPS)
End Function

Sub RegisterExtension(extension, fxVersion)
    Dim iisScriptMaps

    Set iisObject = GetObject("IIS://" & MACHINE_NAME & "/" & DEFAULT_PATH)
    iisScriptMaps = GetScriptMaps()
    
    If ExtensionExists(extension, fxVersion) Then
        WScript.Echo extension & " is already registered for .NET Framework " & fxVersion & "."
        WScript.Quit
    End If
    
    ReDim Preserve iisScriptMaps(UBound(iisScriptMaps)+1)
    
    iisScriptMaps(UBound(iisScriptMaps)) = "." & extension & "," & GetFrameworkPath(fxVersion) & "\aspnet_isapi.dll,1,GET,HEAD,POST"
    iisObject.Put "ScriptMaps", iisScriptMaps
    iisObject.Setinfo
End Sub

Sub SetScriptMaps(ScriptMaps)
    Dim iisObject
    
    Set iisObject = GetObject("ISS://" & MACHINE_NAME & "/" & DEFAULT_PATH)
    
    iisObject.Put SCRIPT_MAPS, ScriptMaps
    iisObject.Setinfo
End Sub

Sub UnregisterExtension(extension, fxVersion)
    Dim newScriptMaps
    
    Set iisObject = GetObject("IIS://" & MACHINE_NAME & "/" & DEFAULT_PATH)
    iisScriptMaps = GetScriptMaps()
    
    If Not ExtensionExists(extension, fxVersion) Then
        WScript.Echo extension & " is not registered for .NET Framework " & fxVersion & "."
        WScript.Quit
    End If

    ReDim newScriptMaps(UBound(iisScriptMaps)-1)
    Dim newScriptIndex
    newScriptIndex = 0

    For scriptIndex = 0 To UBound(iisScriptMaps)
        scriptMap = iisScriptMaps(scriptIndex)
        decomposedScriptMap = Split(scriptMap, ",")
        scriptExtension = Right(decomposedScriptMap(0), Len(decomposedScriptMap(0))-1)
        If (StrComp(LCase(scriptExtension), LCase(extension)) <> 0) Or ((StrComp(LCase(scriptExtension), LCase(extension)) = 0) And (InStr(scriptMap, fxVersion) = 0)) Then
            newScriptMaps(newScriptIndex) = scriptMap
            newScriptIndex = newScriptIndex + 1
        End If
    Next
    
    iisObject.Put "ScriptMaps", newScriptMaps
    iisObject.Setinfo
End Sub

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/registermvc.wsf
================================================
<job>
    <script language="VBScript" src="iismap.vbs">
        If WScript.Arguments.Count = 0 Then
            msg = "You need to specify a .NET Framework version. Please use one of the following:" & VbCrLf
            For Each fxVersion in GetFrameworkVersions()
                msg = msg & fxVersion & VbCrLf
            Next
            WScript.Echo msg
            WScript.Quit
        ElseIf Not IsValidFrameworkVersion(WScript.Arguments(0)) Then
            msg = WScript.Arguments(0) & " is not a valid .NET Framework version. Please use one of the following:" & VbCrLf
            For Each fxVersion in GetFrameworkVersions()
                msg = msg & fxVersion & VbCrLf
            Next
            WScript.Echo msg
            WScript.Quit
        End If
        RegisterExtension "mvc", WScript.Arguments(0)
    </script>
</job>

================================================
FILE: src/Microsoft.Web.Mvc/FuturesFiles/unregistermvc.wsf
================================================
<job>
    <script language="VBScript" src="iismap.vbs">
        If WScript.Arguments.Count = 0 Then
            msg = "You need to specify a .NET Framework version. Please use one of the following: " & VbCrLf
            For Each fxVersion in GetFrameworkVersions()
                msg = msg & fxVersion & VbCrLf
            Next
            WScript.Echo msg
            WScript.Quit
        ElseIf Not IsValidFrameworkVersion(WScript.Arguments(0)) Then
            msg = WScript.Arguments(0) & " is not a valid .NET Framework version. Please use one of the following: " & VbCrLf
            For Each fxVersion in GetFrameworkVersions()
                msg = msg & fxVersion & VbCrLf
            Next
            WScript.Echo msg
            WScript.Quit
        End If
        UnregisterExtension "mvc", WScript.Arguments(0)
    </script>
</job>

================================================
FILE: src/Microsoft.Web.Mvc/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project. 
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc. 
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File". 
// You do not need to add suppressions to this file manually. 

[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "Microsoft.Web.Mvc.Html", Justification = "Helpers reside within a separate namespace to support alternate helper classes.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "whitelist", Scope = "resource", Target = "Microsoft.Web.Mvc.Properties.MvcResources.resources", Justification = "The spelling is correct.")]
[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "Assembly is delay-signed.")]


================================================
FILE: src/Microsoft.Web.Mvc/Html/HtmlHelperExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Web.Routing;

namespace Microsoft.Web.Mvc.Html
{
    // This class contains definitions of single "super" HTML helper methods, which rely on
    // CLR 4's default values for method parameters to make them more consumable. Methods
    // which previously took an HTML attributes object/dictionary now have their legal
    // attribute values all available as optional parameters. Some attributes are only
    // applicable for some DTDs; deprecated attributes (like "align" on input) were
    // specifically excluded.
    //
    // Since htmlAttributes was very often the last parameter to HTML helper methods,
    // converting to these new syntaxes should be as simple as converting your anonymous
    // object htmlAttributes collections into optional parameters.
    //
    // Where there were two overloads for route values (anonymous object and dictionary),
    // there is only a single overload now, which takes type object. If what you pass is
    // a dictionary of the correct type, then we'll use that; otherwise, we'll assume it's
    // an anonymous object and create the dictionary for you. This should make it simple
    // to port methods using route values, as they should just continue to work as before.
    //
    // Some HTML helpers did not take HTML attributes parameters. They are recreated here
    // so that the user does not have to import both System.Web.Mvc.Html as well as this
    // namespace, since the purpose of these methods is to get rid of all the overloads
    // for the built-in HTML helpers.
    //
    // The legal attribute values were derived from: http://www.w3schools.com/tags/

    public static class HtmlHelperExtensions
    {
        // ChildActionExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString Action(this HtmlHelper htmlHelper, string actionName, string controllerName = null, object routeValues = null)
        {
            return ChildActionExtensions.Action(
                htmlHelper,
                actionName,
                controllerName,
                routeValues as IDictionary<string, object> ?? new RouteValueDictionary(routeValues));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static void RenderAction(this HtmlHelper htmlHelper, string actionName, string controllerName = null, object routeValues = null)
        {
            ChildActionExtensions.RenderAction(
                htmlHelper,
                actionName,
                controllerName,
                routeValues as IDictionary<string, object> ?? new RouteValueDictionary(routeValues));
        }

        // DisplayExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString Display(this HtmlHelper htmlHelper, string expression, string templateName = null, string htmlFieldName = null)
        {
            return DisplayExtensions.Display(htmlHelper, expression, templateName, htmlFieldName);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString DisplayFor<TModel, TValue>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TValue>> expression, string templateName = null, string htmlFieldName = null)
        {
            return DisplayExtensions.DisplayFor(htmlHelper, expression, templateName, htmlFieldName);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString DisplayForModel(this HtmlHelper htmlHelper, string templateName = null, string htmlFieldName = null)
        {
            return DisplayExtensions.DisplayForModel(htmlHelper, templateName, htmlFieldName);
        }

        // DisplayTextExtensions

        public static MvcHtmlString DisplayText(this HtmlHelper htmlHelper, string name)
        {
            return DisplayTextExtensions.DisplayText(htmlHelper, name);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayTextFor<TModel, TResult>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TResult>> expression)
        {
            return DisplayTextExtensions.DisplayTextFor(htmlHelper, expression);
        }

        // EditorExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString Editor(this HtmlHelper htmlHelper, string expression, string templateName = null, string htmlFieldName = null)
        {
            return EditorExtensions.Editor(htmlHelper, expression, templateName, htmlFieldName);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString EditorFor<TModel, TValue>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TValue>> expression, string templateName = null, string htmlFieldName = null)
        {
            return EditorExtensions.EditorFor(htmlHelper, expression, templateName, htmlFieldName);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString EditorForModel(this HtmlHelper htmlHelper, string templateName = null, string htmlFieldName = null)
        {
            return EditorExtensions.EditorForModel(htmlHelper, templateName, htmlFieldName);
        }

        // FormExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName = null, string controllerName = null, object routeValues = null, FormMethod method = FormMethod.Post, string accept = null, string acceptCharset = null, string cssClass = null, string dir = null, string encType = null, string id = null, string lang = null, string name = null, string style = null, string title = null)
        {
            return htmlHelper.BeginForm(
                actionName,
                controllerName,
                routeValues as RouteValueDictionary ?? new RouteValueDictionary(routeValues),
                method,
                FormAttributes(accept, acceptCharset, cssClass, dir, encType, id, lang, name, style, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, RouteValueDictionary routeValues = null, FormMethod method = FormMethod.Post, string accept = null, string acceptCharset = null, string cssClass = null, string dir = null, string encType = null, string id = null, string lang = null, string name = null, string style = null, string title = null)
        {
            return htmlHelper.BeginRouteForm(
                routeName,
                routeValues ?? new RouteValueDictionary(routeValues),
                method,
                FormAttributes(accept, acceptCharset, cssClass, dir, encType, id, lang, name, style, title));
        }

        public static void EndForm(this HtmlHelper htmlHelper)
        {
            System.Web.Mvc.Html.FormExtensions.EndForm(htmlHelper);
        }

        // InputExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString CheckBox(this HtmlHelper htmlHelper, string name, bool? isChecked = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            var htmlAttributes = InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title);

            return isChecked.HasValue
                       ? htmlHelper.CheckBox(name, isChecked.Value, htmlAttributes)
                       : htmlHelper.CheckBox(name, htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString CheckBoxFor<TModel>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, bool>> expression, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.CheckBoxFor(
                expression,
                InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString Hidden(this HtmlHelper htmlHelper, string name, object value = null, string cssClass = null, string id = null, string style = null)
        {
            return htmlHelper.Hidden(name, value, Attributes(cssClass, id, style));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString HiddenFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string cssClass = null, string id = null, string style = null)
        {
            return htmlHelper.HiddenFor(expression, Attributes(cssClass, id, style));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString Password(this HtmlHelper htmlHelper, string name, object value = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.Password(
                name,
                value,
                InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString PasswordFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string cssClass = null, bool disabled = false, string dir = null, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.PasswordFor(
                expression,
                InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString RadioButton(this HtmlHelper htmlHelper, string name, object value, bool? isChecked = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            var htmlAttributes = InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title);

            return isChecked.HasValue
                       ? htmlHelper.RadioButton(name, value, isChecked.Value, htmlAttributes)
                       : htmlHelper.RadioButton(name, value, htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString RadioButtonFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object value, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.RadioButtonFor(
                expression,
                value,
                InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name, object value = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.TextBox(
                name,
                value,
                InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString TextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? maxLength = null, bool readOnly = false, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.TextBoxFor(
                expression,
                InputAttributes(cssClass, dir, disabled, id, lang, maxLength, readOnly, size, style, tabIndex, title));
        }

        // LabelExtensions

        public static MvcHtmlString Label(this HtmlHelper htmlHelper, string expression)
        {
            return LabelExtensions.Label(htmlHelper, expression);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TValue>> expression)
        {
            return LabelExtensions.LabelFor(htmlHelper, expression);
        }

        public static MvcHtmlString LabelForModel(this HtmlHelper htmlHelper)
        {
            return LabelExtensions.LabelForModel(htmlHelper);
        }

        // LinkExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName = null, string protocol = null, string hostName = null, string fragment = null, object routeValues = null, string accessKey = null, string charset = null, string coords = null, string cssClass = null, string dir = null, string hrefLang = null, string id = null, string lang = null, string name = null, string rel = null, string rev = null, string shape = null, string style = null, string target = null, string title = null)
        {
            return htmlHelper.ActionLink(
                linkText,
                actionName,
                controllerName,
                protocol,
                hostName,
                fragment,
                routeValues as RouteValueDictionary ?? new RouteValueDictionary(routeValues),
                AnchorAttributes(accessKey, charset, coords, cssClass, dir, hrefLang, id, lang, name, rel, rev, shape, style, target, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName, string protocol = null, string hostName = null, string fragment = null, object routeValues = null, string accessKey = null, string charset = null, string coords = null, string cssClass = null, string dir = null, string hrefLang = null, string id = null, string lang = null, string name = null, string rel = null, string rev = null, string shape = null, string style = null, string target = null, string title = null)
        {
            return htmlHelper.RouteLink(
                linkText,
                routeName,
                protocol,
                hostName,
                fragment,
                routeValues as RouteValueDictionary ?? new RouteValueDictionary(routeValues),
                AnchorAttributes(accessKey, charset, coords, cssClass, dir, hrefLang, id, lang, name, rel, rev, shape, style, target, title));
        }

        // PartialExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString Partial(this HtmlHelper htmlHelper, string partialViewName, object model = null, ViewDataDictionary viewData = null)
        {
            return PartialExtensions.Partial(
                htmlHelper,
                partialViewName,
                model,
                viewData ?? htmlHelper.ViewData);
        }

        // RenderPartialExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static void RenderPartial(this HtmlHelper htmlHelper, string partialViewName, object model = null, ViewDataDictionary viewData = null)
        {
            RenderPartialExtensions.RenderPartial(
                htmlHelper,
                partialViewName,
                model,
                viewData ?? htmlHelper.ViewData);
        }

        // SelectExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList = null, string optionLabel = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.DropDownList(
                name,
                selectList,
                optionLabel,
                SelectAttributes(cssClass, dir, disabled, id, lang, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList = null, string optionLabel = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.DropDownListFor(
                expression,
                selectList,
                optionLabel,
                SelectAttributes(cssClass, dir, disabled, id, lang, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString ListBox(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.ListBox(
                name,
                selectList,
                SelectAttributes(cssClass, dir, disabled, id, lang, size, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString ListBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int? size = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.ListBoxFor(
                expression,
                selectList,
                SelectAttributes(cssClass, dir, disabled, id, lang, size, style, tabIndex, title));
        }

        // TextAreaExtensions

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, string value = null, string accessKey = null, string cssClass = null, int? cols = null, string dir = null, bool disabled = false, string id = null, string lang = null, bool readOnly = false, int? rows = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.TextArea(
                name,
                value,
                TextAreaAttributes(accessKey, cssClass, cols, dir, disabled, id, lang, readOnly, rows, style, tabIndex, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString TextAreaFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string accessKey = null, string cssClass = null, int? cols = null, string dir = null, bool disabled = false, string id = null, string lang = null, bool readOnly = false, int? rows = null, string style = null, int? tabIndex = null, string title = null)
        {
            return htmlHelper.TextAreaFor(
                expression,
                TextAreaAttributes(accessKey, cssClass, cols, dir, disabled, id, lang, readOnly, rows, style, tabIndex, title));
        }

        // ValidationExtensions

        public static void Validate(this HtmlHelper htmlHelper, string modelName)
        {
            ValidationExtensions.Validate(htmlHelper, modelName);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static void ValidateFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            ValidationExtensions.ValidateFor(htmlHelper, expression);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", MessageId = "2#", Justification = "This API has already shipped.")]
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName, string validationMessage = null, string cssClass = null, string dir = null, string id = null, string lang = null, string style = null, string title = null)
        {
            return htmlHelper.ValidationMessage(
                modelName,
                validationMessage,
                SpanAttributes(cssClass, dir, id, lang, style, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string validationMessage = null, string cssClass = null, string dir = null, string id = null, string lang = null, string style = null, string title = null)
        {
            return htmlHelper.ValidationMessageFor(
                expression,
                validationMessage,
                SpanAttributes(cssClass, dir, id, lang, style, title));
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "The purpose of these helpers is to use default parameters to simplify common usage.")]
        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, string message = null, bool excludePropertyErrors = false, string cssClass = null, string dir = null, string id = null, string lang = null, string style = null, string title = null)
        {
            return htmlHelper.ValidationSummary(
                excludePropertyErrors,
                message,
                SpanAttributes(cssClass, dir, id, lang, style, title));
        }

        // Helper methods

        private static void AddOptional(this IDictionary<string, object> dictionary, string key, bool value)
        {
            if (value)
            {
                dictionary[key] = key;
            }
        }

        private static void AddOptional(this IDictionary<string, object> dictionary, string key, object value)
        {
            if (value != null)
            {
                dictionary[key] = value;
            }
        }

        private static IDictionary<string, object> Attributes(string cssClass, string id, string style)
        {
            var htmlAttributes = new RouteValueDictionary();

            htmlAttributes.AddOptional("class", cssClass);
            htmlAttributes.AddOptional("id", id);
            htmlAttributes.AddOptional("style", style);

            return htmlAttributes;
        }

        private static IDictionary<string, object> AnchorAttributes(string accessKey, string charset, string coords, string cssClass, string dir, string hrefLang, string id, string lang, string name, string rel, string rev, string shape, string style, string target, string title)
        {
            var htmlAttributes = Attributes(cssClass, id, style);

            htmlAttributes.AddOptional("accesskey", accessKey);
            htmlAttributes.AddOptional("charset", charset);
            htmlAttributes.AddOptional("coords", coords);
            htmlAttributes.AddOptional("dir", dir);
            htmlAttributes.AddOptional("hreflang", hrefLang);
            htmlAttributes.AddOptional("lang", lang);
            htmlAttributes.AddOptional("name", name);
            htmlAttributes.AddOptional("rel", rel);
            htmlAttributes.AddOptional("rev", rev);
            htmlAttributes.AddOptional("shape", shape);
            htmlAttributes.AddOptional("target", target);
            htmlAttributes.AddOptional("title", title);

            return htmlAttributes;
        }

        private static IDictionary<string, object> FormAttributes(string accept, string acceptCharset, string cssClass, string dir, string encType, string id, string lang, string name, string style, string title)
        {
            var htmlAttributes = Attributes(cssClass, id, style);

            htmlAttributes.AddOptional("accept", accept);
            htmlAttributes.AddOptional("accept-charset", acceptCharset);
            htmlAttributes.AddOptional("dir", dir);
            htmlAttributes.AddOptional("enctype", encType);
            htmlAttributes.AddOptional("lang", lang);
            htmlAttributes.AddOptional("name", name);
            htmlAttributes.AddOptional("title", title);

            return htmlAttributes;
        }

        private static IDictionary<string, object> InputAttributes(string cssClass, string dir, bool disabled, string id, string lang, int? maxLength, bool readOnly, int? size, string style, int? tabIndex, string title)
        {
            var htmlAttributes = Attributes(cssClass, id, style);

            htmlAttributes.AddOptional("dir", dir);
            htmlAttributes.AddOptional("disabled", disabled);
            htmlAttributes.AddOptional("lang", lang);
            htmlAttributes.AddOptional("maxlength", maxLength);
            htmlAttributes.AddOptional("readonly", readOnly);
            htmlAttributes.AddOptional("size", size);
            htmlAttributes.AddOptional("tabindex", tabIndex);
            htmlAttributes.AddOptional("title", title);

            return htmlAttributes;
        }

        private static IDictionary<string, object> SelectAttributes(string cssClass, string dir, bool disabled, string id, string lang, int? size, string style, int? tabIndex, string title)
        {
            var htmlAttributes = Attributes(cssClass, id, style);

            htmlAttributes.AddOptional("dir", dir);
            htmlAttributes.AddOptional("disabled", disabled);
            htmlAttributes.AddOptional("lang", lang);
            htmlAttributes.AddOptional("size", size);
            htmlAttributes.AddOptional("tabindex", tabIndex);
            htmlAttributes.AddOptional("title", title);

            return htmlAttributes;
        }

        private static IDictionary<string, object> SpanAttributes(string cssClass, string dir, string id, string lang, string style, string title)
        {
            var htmlAttributes = Attributes(cssClass, id, style);

            htmlAttributes.AddOptional("dir", dir);
            htmlAttributes.AddOptional("lang", lang);
            htmlAttributes.AddOptional("title", title);

            return htmlAttributes;
        }

        private static IDictionary<string, object> TextAreaAttributes(string accessKey, string cssClass, int? cols, string dir, bool disabled, string id, string lang, bool readOnly, int? rows, string style, int? tabIndex, string title)
        {
            var htmlAttributes = Attributes(cssClass, id, style);

            htmlAttributes.AddOptional("accesskey", accessKey);
            htmlAttributes.AddOptional("cols", cols);
            htmlAttributes.AddOptional("dir", dir);
            htmlAttributes.AddOptional("disabled", disabled);
            htmlAttributes.AddOptional("lang", lang);
            htmlAttributes.AddOptional("readonly", readOnly);
            htmlAttributes.AddOptional("rows", rows);
            htmlAttributes.AddOptional("style", style);
            htmlAttributes.AddOptional("tabindex", tabIndex);
            htmlAttributes.AddOptional("title", title);

            return htmlAttributes;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/HtmlButtonType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc
{
    public enum HtmlButtonType
    {
        Button,
        Submit,
        Reset,
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/IMachineKey.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Security;

namespace Microsoft.Web.Mvc
{
    // Used for mocking out the static MachineKey type

    internal interface IMachineKey
    {
        byte[] Unprotect(string protectedData, params string[] purposes);
        string Protect(byte[] userData, params string[] purposes);
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ImageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    public static class ImageExtensions
    {
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public static MvcHtmlString Image(this HtmlHelper helper, string imageRelativeUrl)
        {
            return Image(helper, imageRelativeUrl, null, null);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "Required for Extension Method")]
        public static MvcHtmlString Image(this HtmlHelper helper, string imageRelativeUrl, string alt)
        {
            return Image(helper, imageRelativeUrl, alt, null);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public static MvcHtmlString Image(this HtmlHelper helper, string imageRelativeUrl, string alt, object htmlAttributes)
        {
            return Image(helper, imageRelativeUrl, alt, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public static MvcHtmlString Image(this HtmlHelper helper, string imageRelativeUrl, object htmlAttributes)
        {
            return Image(helper, imageRelativeUrl, null, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public static MvcHtmlString Image(this HtmlHelper helper, string imageRelativeUrl, IDictionary<string, object> htmlAttributes)
        {
            return Image(helper, imageRelativeUrl, null, htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public static MvcHtmlString Image(this HtmlHelper helper, string imageRelativeUrl, string alt, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(imageRelativeUrl))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "imageRelativeUrl");
            }

            string imageUrl = UrlHelper.GenerateContentUrl(imageRelativeUrl, helper.ViewContext.HttpContext);
            return MvcHtmlString.Create(Image(imageUrl, alt, htmlAttributes).ToString(TagRenderMode.SelfClosing));
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "The value is a not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public static TagBuilder Image(string imageUrl, string alt, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(imageUrl))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "imageUrl");
            }

            TagBuilder imageTag = new TagBuilder("img");

            if (!String.IsNullOrEmpty(imageUrl))
            {
                imageTag.MergeAttribute("src", imageUrl);
            }

            if (!String.IsNullOrEmpty(alt))
            {
                imageTag.MergeAttribute("alt", alt);
            }

            imageTag.MergeAttributes(htmlAttributes, true);

            if (imageTag.Attributes.ContainsKey("alt") && !imageTag.Attributes.ContainsKey("title"))
            {
                imageTag.MergeAttribute("title", (imageTag.Attributes["alt"] ?? String.Empty));
            }
            return imageTag;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Internal/ExpressionHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Internal
{
    public static class ExpressionHelper
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]
        public static RouteValueDictionary GetRouteValuesFromExpression<TController>(Expression<Action<TController>> action) where TController : Controller
        {
            if (action == null)
            {
                throw new ArgumentNullException("action");
            }

            MethodCallExpression call = action.Body as MethodCallExpression;
            if (call == null)
            {
                throw new ArgumentException(MvcResources.ExpressionHelper_MustBeMethodCall, "action");
            }

            string controllerName = typeof(TController).Name;
            if (!controllerName.EndsWith("Controller", StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentException(MvcResources.ExpressionHelper_TargetMustEndInController, "action");
            }
            controllerName = controllerName.Substring(0, controllerName.Length - "Controller".Length);
            if (controllerName.Length == 0)
            {
                throw new ArgumentException(MvcResources.ExpressionHelper_CannotRouteToController, "action");
            }

            // TODO: How do we know that this method is even web callable?
            //      For now, we just let the call itself throw an exception.

            string actionName = GetTargetActionName(call.Method);

            var rvd = new RouteValueDictionary();
            rvd.Add("Controller", controllerName);
            rvd.Add("Action", actionName);

            ActionLinkAreaAttribute areaAttr = typeof(TController).GetCustomAttributes(typeof(ActionLinkAreaAttribute), true /* inherit */).FirstOrDefault() as ActionLinkAreaAttribute;
            if (areaAttr != null)
            {
                string areaName = areaAttr.Area;
                rvd.Add("Area", areaName);
            }

            AddParameterValuesFromExpressionToDictionary(rvd, call);
            return rvd;
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]
        public static string GetInputName<TModel, TProperty>(Expression<Func<TModel, TProperty>> expression)
        {
            if (expression.Body.NodeType == ExpressionType.Call)
            {
                MethodCallExpression methodCallExpression = (MethodCallExpression)expression.Body;
                string name = GetInputName(methodCallExpression);
                return name.Substring(expression.Parameters[0].Name.Length + 1);
            }
            return expression.Body.ToString().Substring(expression.Parameters[0].Name.Length + 1);
        }

        private static string GetInputName(MethodCallExpression expression)
        {
            // p => p.Foo.Bar().Baz.ToString() => p.Foo OR throw...

            MethodCallExpression methodCallExpression = expression.Object as MethodCallExpression;
            if (methodCallExpression != null)
            {
                return GetInputName(methodCallExpression);
            }
            return expression.Object.ToString();
        }

        // This method contains some heuristics that will help determine the correct action name from a given MethodInfo
        // assuming the default sync / async invokers are in use. The logic's not foolproof, but it should be good enough
        // for most uses.
        private static string GetTargetActionName(MethodInfo methodInfo)
        {
            string methodName = methodInfo.Name;

            // do we know this not to be an action?
            if (methodInfo.IsDefined(typeof(NonActionAttribute), true /* inherit */))
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                  MvcResources.ExpressionHelper_CannotCallNonAction, methodName));
            }

            // has this been renamed?
            ActionNameAttribute nameAttr = methodInfo.GetCustomAttributes(typeof(ActionNameAttribute), true /* inherit */).OfType<ActionNameAttribute>().FirstOrDefault();
            if (nameAttr != null)
            {
                return nameAttr.Name;
            }

            // targeting an async action?
            if (methodInfo.DeclaringType.IsSubclassOf(typeof(AsyncController)))
            {
                if (methodName.EndsWith("Async", StringComparison.OrdinalIgnoreCase))
                {
                    return methodName.Substring(0, methodName.Length - "Async".Length);
                }
                if (methodName.EndsWith("Completed", StringComparison.OrdinalIgnoreCase))
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                      MvcResources.ExpressionHelper_CannotCallCompletedMethod, methodName));
                }
            }

            // fallback
            return methodName;
        }

        private static void AddParameterValuesFromExpressionToDictionary(RouteValueDictionary rvd, MethodCallExpression call)
        {
            ParameterInfo[] parameters = call.Method.GetParameters();

            if (parameters.Length > 0)
            {
                for (int i = 0; i < parameters.Length; i++)
                {
                    Expression arg = call.Arguments[i];
                    object value = null;
                    ConstantExpression ce = arg as ConstantExpression;
                    if (ce != null)
                    {
                        // If argument is a constant expression, just get the value
                        value = ce.Value;
                    }
                    else
                    {
                        value = CachedExpressionCompiler.Evaluate(arg);
                    }
                    rvd.Add(parameters[i].Name, value);
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/LinkBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Mvc;
using System.Web.Routing;
using ExpressionHelper = Microsoft.Web.Mvc.Internal.ExpressionHelper;

namespace Microsoft.Web.Mvc
{
    public static class LinkBuilder
    {
        /// <summary>
        /// Builds a URL based on the Expression passed in
        /// </summary>
        /// <typeparam name="TController">Controller Type Only</typeparam>
        /// <param name="context">The current ViewContext</param>
        /// <param name="routeCollection">The <see cref="RouteCollection"/> to use for building the URL.</param>
        /// <param name="action">The action to invoke</param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters"), SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an Extension Method which allows the user to provide a strongly-typed argument via Expression"), SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Need to be sure the passed-in argument is of type Controller::Action")]
        public static string BuildUrlFromExpression<TController>(RequestContext context, RouteCollection routeCollection, Expression<Action<TController>> action) where TController : Controller
        {
            RouteValueDictionary routeValues = ExpressionHelper.GetRouteValuesFromExpression(action);
            VirtualPathData vpd = routeCollection.GetVirtualPathForArea(context, routeValues);
            return (vpd == null) ? null : vpd.VirtualPath;
        }

        /// <summary>
        /// Creates a querystring as a Dictionary based on the passed-in Lambda
        /// </summary>
        /// <param name="call">The Lambda of the Controller method</param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Allowing Lambda compilation to fail if it doesn't compile at run time - design-time compilation will not allow for runtime Exception")]
        public static RouteValueDictionary BuildParameterValuesFromExpression(MethodCallExpression call)
        {
            RouteValueDictionary result = new RouteValueDictionary();

            ParameterInfo[] parameters = call.Method.GetParameters();

            if (parameters.Length > 0)
            {
                for (int i = 0; i < parameters.Length; i++)
                {
                    Expression arg = call.Arguments[i];
                    object value;
                    ConstantExpression ce = arg as ConstantExpression;
                    if (ce != null)
                    {
                        // If argument is a constant expression, just get the value
                        value = ce.Value;
                    }
                    else
                    {
                        try
                        {
                            value = CachedExpressionCompiler.Evaluate(arg);
                        }
                        catch
                        {
                            // ?????
                            value = String.Empty;
                        }
                    }
                    // Code should be added here to appropriately escape the value string
                    result.Add(parameters[i].Name, value);
                }
            }
            return result;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/LinkExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Web.Routing;
using ExpressionHelper = Microsoft.Web.Mvc.Internal.ExpressionHelper;

namespace Microsoft.Web.Mvc
{
    public static class LinkExtensions
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "This is a UI method and is required to use strings as Uri"), SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an Extension Method which allows the user to provide a strongly-typed argument via Expression")]
        public static string BuildUrlFromExpression<TController>(this HtmlHelper helper, Expression<Action<TController>> action) where TController : Controller
        {
            return LinkBuilder.BuildUrlFromExpression(helper.ViewContext.RequestContext, helper.RouteCollection, action);
        }

        /// <summary>
        /// Creates an anchor tag based on the passed in controller type and method
        /// </summary>
        /// <typeparam name="TController">The Controller Type</typeparam>
        /// <param name="helper">The <see cref="HtmlHelper"/> where to create the link.</param>
        /// <param name="action">The Method to route to</param>
        /// <param name="linkText">The linked text to appear on the page</param>
        /// <returns>The anchor tag.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ActionLink<TController>(this HtmlHelper helper, Expression<Action<TController>> action, string linkText) where TController : Controller
        {
            return ActionLink(helper, action, linkText, null);
        }

        /// <summary>
        /// Creates an anchor tag based on the passed in controller type and method
        /// </summary>
        /// <typeparam name="TController">The Controller Type</typeparam>
        /// <param name="helper">The <see cref="HtmlHelper"/> where to create the link.</param>
        /// <param name="action">The Method to route to</param>
        /// <param name="linkText">The linked text to appear on the page</param>
        /// <param name="htmlAttributes">Any additional HTML attributes.</param>
        /// <returns>The anchor tag.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ActionLink<TController>(this HtmlHelper helper, Expression<Action<TController>> action, string linkText, object htmlAttributes) where TController : Controller
        {
            RouteValueDictionary routingValues = ExpressionHelper.GetRouteValuesFromExpression(action);

            return helper.RouteLink(linkText, routingValues, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/MachineKeyWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web;
using System.Web.Security;

namespace Microsoft.Web.Mvc
{
    // Concrete implementation of IMachineKey that talks to the static MachineKey type

    internal sealed class MachineKeyWrapper : IMachineKey
    {
        private static readonly MachineKeyWrapper _singletonInstance = new MachineKeyWrapper();

        public static MachineKeyWrapper Instance
        {
            get
            {
                return _singletonInstance;
            }
        }

        public byte[] Unprotect(string protectedData, params string[] purposes)
        {
            byte[] protectedBytes = Convert.FromBase64String(protectedData);
            return MachineKey.Unprotect(protectedBytes, purposes);
        }

        public string Protect(byte[] userData, params string[] purposes)
        {
            byte[] protectedBytes = MachineKey.Protect(userData, purposes);
            return Convert.ToBase64String(protectedBytes);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/MailToExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "MailTo", Justification = "This is correctly cased.")]
    public static class MailToExtensions
    {
        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress)
        {
            return Mailto(helper, linkText, emailAddress, null, null, null, null, null);
        }

        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress, object htmlAttributes)
        {
            return Mailto(helper, linkText, emailAddress, null, null, null, null, htmlAttributes);
        }

        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress, IDictionary<string, object> htmlAttributes)
        {
            return Mailto(helper, linkText, emailAddress, null, null, null, null, htmlAttributes);
        }

        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress, string subject)
        {
            return Mailto(helper, linkText, emailAddress, subject, null, null, null, null);
        }

        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress, string subject, object htmlAttributes)
        {
            return Mailto(helper, linkText, emailAddress, subject, null, null, null, htmlAttributes);
        }

        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress, string subject, IDictionary<string, object> htmlAttributes)
        {
            return Mailto(helper, linkText, emailAddress, subject, null, null, null, htmlAttributes);
        }

        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress, string subject, string body, string cc, string bcc, object htmlAttributes)
        {
            return Mailto(helper, linkText, emailAddress, subject, body, cc, bcc, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString Mailto(this HtmlHelper helper, string linkText, string emailAddress, string subject,
                                           string body, string cc, string bcc, IDictionary<string, object> htmlAttributes)
        {
            if (emailAddress == null)
            {
                throw new ArgumentNullException("emailAddress"); // TODO: Resource message
            }
            if (linkText == null)
            {
                throw new ArgumentNullException("linkText"); // TODO: Resource message
            }

            string mailToUrl = "mailto:" + emailAddress;

            List<string> mailQuery = new List<string>();
            if (!String.IsNullOrEmpty(subject))
            {
                mailQuery.Add("subject=" + helper.Encode(subject));
            }

            if (!String.IsNullOrEmpty(cc))
            {
                mailQuery.Add("cc=" + helper.Encode(cc));
            }

            if (!String.IsNullOrEmpty(bcc))
            {
                mailQuery.Add("bcc=" + helper.Encode(bcc));
            }

            if (!String.IsNullOrEmpty(body))
            {
                string encodedBody = helper.Encode(body);
                encodedBody = encodedBody.Replace(Environment.NewLine, "%0A");
                mailQuery.Add("body=" + encodedBody);
            }

            string query = String.Empty;
            for (int i = 0; i < mailQuery.Count; i++)
            {
                query += mailQuery[i];
                if (i < mailQuery.Count - 1)
                {
                    query += "&";
                }
            }
            if (query.Length > 0)
            {
                mailToUrl += "?" + query;
            }

            TagBuilder mailtoAnchor = new TagBuilder("a");
            mailtoAnchor.MergeAttribute("href", mailToUrl);
            mailtoAnchor.MergeAttributes(htmlAttributes, true);
            mailtoAnchor.InnerHtml = linkText;
            return MvcHtmlString.Create(mailtoAnchor.ToString());
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Microsoft.Web.Mvc.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.Web.Mvc</RootNamespace>
    <AssemblyName>Microsoft.Web.Mvc</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
    <NoWarn>1591</NoWarn>
    <!-- Force signing off -->
    <SignAssembly>false</SignAssembly>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.ServiceModel" />
    <Reference Include="System.ServiceModel.Web" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.Abstractions" />
    <Reference Include="System.Web.Routing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="AcceptAttribute.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="MachineKeyWrapper.cs" />
    <Compile Include="IMachineKey.cs" />
    <Compile Include="CreditCardAttribute.cs" />
    <Compile Include="EmailAddressAttribute.cs" />
    <Compile Include="FileExtensionsAttribute.cs" />
    <Compile Include="AreaHelpers.cs" />
    <Compile Include="AsyncManagerExtensions.cs" />
    <Compile Include="CookieValueProviderFactory.cs" />
    <Compile Include="ActionLinkAreaAttribute.cs" />
    <Compile Include="ControllerExtensions.cs" />
    <Compile Include="DynamicReflectionObject.cs" />
    <Compile Include="DynamicViewDataDictionary.cs" />
    <Compile Include="DynamicViewPage.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="DynamicViewPageOfTModel.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ExpressionUtil\BinaryExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\CachedExpressionCompiler.cs" />
    <Compile Include="ExpressionUtil\ConditionalExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ConstantExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\DefaultExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ExpressionFingerprintChain.cs" />
    <Compile Include="ExpressionUtil\FingerprintingExpressionVisitor.cs" />
    <Compile Include="ExpressionUtil\HashCodeCombiner.cs" />
    <Compile Include="ExpressionUtil\Hoisted.cs" />
    <Compile Include="ExpressionUtil\HoistingExpressionVisitor.cs" />
    <Compile Include="ExpressionUtil\IndexExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\LambdaExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\MemberExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\MethodCallExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ParameterExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\TypeBinaryExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\UnaryExpressionFingerprint.cs" />
    <Compile Include="Html\HtmlHelperExtensions.cs" />
    <Compile Include="ModelBinding\BinaryDataModelBinderProvider.cs" />
    <Compile Include="ModelBinding\ExtensibleModelBinderAttribute.cs" />
    <Compile Include="ModelBinding\ModelBinderProviderOptionsAttribute.cs" />
    <Compile Include="ModelBinding\ExtensibleModelBinderAdapter.cs" />
    <Compile Include="ModelBinding\ExtensibleModelBindingContext.cs" />
    <Compile Include="ModelBinding\IExtensibleModelBinder.cs" />
    <Compile Include="ModelBinding\ModelBinderErrorMessageProvider.cs" />
    <Compile Include="ModelCopier.cs" />
    <Compile Include="ModelBinding\CollectionModelBinderProvider.cs" />
    <Compile Include="ModelBinding\CollectionModelBinderUtil.cs" />
    <Compile Include="ModelBinding\CollectionModelBinder.cs" />
    <Compile Include="ModelBinding\ComplexModelDtoModelBinderProvider.cs" />
    <Compile Include="ModelBinding\ArrayModelBinderProvider.cs" />
    <Compile Include="ModelBinding\ArrayModelBinder.cs" />
    <Compile Include="ModelBinding\BindingBehaviorAttribute.cs" />
    <Compile Include="ModelBinding\BindingBehavior.cs" />
    <Compile Include="ModelBinding\BindNeverAttribute.cs" />
    <Compile Include="ModelBinding\BindRequiredAttribute.cs" />
    <Compile Include="ModelBinding\GenericModelBinderProvider.cs" />
    <Compile Include="ModelBinding\DictionaryModelBinderProvider.cs" />
    <Compile Include="ModelBinding\DictionaryModelBinder.cs" />
    <Compile Include="UrlAttribute.cs" />
    <Compile Include="ValueProviderUtil.cs" />
    <Compile Include="ElementalValueProvider.cs" />
    <Compile Include="ModelBinding\KeyValuePairModelBinderProvider.cs" />
    <Compile Include="ModelBinding\KeyValuePairModelBinderUtil.cs" />
    <Compile Include="ModelBinding\KeyValuePairModelBinder.cs" />
    <Compile Include="TypeDescriptorHelper.cs" />
    <Compile Include="Error.cs" />
    <Compile Include="ModelBinding\ComplexModelDto.cs" />
    <Compile Include="ModelBinding\ComplexModelDtoModelBinder.cs" />
    <Compile Include="ModelBinding\ComplexModelDtoResult.cs" />
    <Compile Include="ModelBinding\ModelBinderConfig.cs" />
    <Compile Include="ModelBinding\MutableObjectModelBinder.cs" />
    <Compile Include="ModelBinding\MutableObjectModelBinderProvider.cs" />
    <Compile Include="ModelBinding\SimpleModelBinderProvider.cs" />
    <Compile Include="ModelBinding\TypeConverterModelBinder.cs" />
    <Compile Include="ModelBinding\TypeConverterModelBinderProvider.cs" />
    <Compile Include="ModelBinding\TypeMatchModelBinderProvider.cs" />
    <Compile Include="ModelBinding\TypeMatchModelBinder.cs" />
    <Compile Include="ModelBinding\ModelBinderProviderCollection.cs" />
    <Compile Include="ModelBinding\ModelBinderProvider.cs" />
    <Compile Include="ModelBinding\ModelBinderUtil.cs" />
    <Compile Include="ModelBinding\ModelValidatedEventArgs.cs" />
    <Compile Include="ModelBinding\ModelValidatingEventArgs.cs" />
    <Compile Include="ModelBinding\ModelValidationNode.cs" />
    <Compile Include="ModelBinding\ModelBinderProviders.cs" />
    <Compile Include="ServerVariablesValueProviderFactory.cs" />
    <Compile Include="TempDataValueProviderFactory.cs" />
    <Compile Include="SessionValueProviderFactory.cs" />
    <Compile Include="CopyAsyncParametersAttribute.cs" />
    <Compile Include="CssExtensions.cs" />
    <Compile Include="Resources\ActionType.cs" />
    <Compile Include="Resources\AjaxHelperExtensions.cs" />
    <Compile Include="Resources\AtomEntryActionResult.cs" />
    <Compile Include="Resources\AtomFeedActionResult.cs" />
    <Compile Include="Resources\AtomServiceDocumentActionResult.cs" />
    <Compile Include="Resources\DataContractJsonActionResult.cs" />
    <Compile Include="Resources\JsonFormatHandler.cs" />
    <Compile Include="Resources\RouteCollectionExtensions.cs" />
    <Compile Include="Resources\UriHelperExtensions.cs" />
    <Compile Include="Resources\WebApiEnabledAttribute.cs" />
    <Compile Include="Resources\XmlFormatHandler.cs" />
    <Compile Include="Resources\IResponseFormatHandler.cs" />
    <Compile Include="Resources\IRequestFormatHandler.cs" />
    <Compile Include="Resources\FormatManager.cs" />
    <Compile Include="Resources\HtmlHelperExtensions.cs" />
    <Compile Include="Resources\MultiFormatActionResult.cs" />
    <Compile Include="Resources\RequestContextExtensions.cs" />
    <Compile Include="Resources\ResourceControllerFactory.cs" />
    <Compile Include="Resources\ResourceErrorActionResult.cs" />
    <Compile Include="Resources\ResourceModelBinder.cs" />
    <Compile Include="Resources\ResourceRedirectToRouteResult.cs" />
    <Compile Include="Resources\DataContractXmlActionResult.cs" />
    <Compile Include="Resources\HttpRequestBaseExtensions.cs" />
    <Compile Include="Resources\IEnumerableExtensions.cs" />
    <Compile Include="Resources\DefaultFormatHelper.cs" />
    <Compile Include="Resources\DefaultFormatManager.cs" />
    <Compile Include="Resources\FormatHelper.cs" />
    <Compile Include="Internal\ExpressionHelper.cs" />
    <Compile Include="DeserializeAttribute.cs" />
    <Compile Include="ScriptExtensions.cs" />
    <Compile Include="SerializationExtensions.cs" />
    <Compile Include="MvcSerializer.cs" />
    <Compile Include="AjaxOnlyAttribute.cs" />
    <Compile Include="CachedExpressionCompiler.cs" />
    <Compile Include="ReaderWriterCache.cs" />
    <Compile Include="ButtonBuilder.cs" />
    <Compile Include="ButtonsAndLinkExtensions.cs" />
    <Compile Include="ContentTypeAttribute.cs" />
    <Compile Include="Controls\ActionLink.cs" />
    <Compile Include="Controls\EncodeType.cs" />
    <Compile Include="Controls\DropDownList.cs" />
    <Compile Include="Controls\Hidden.cs" />
    <Compile Include="Controls\Label.cs" />
    <Compile Include="Controls\MvcControl.cs" />
    <Compile Include="Controls\MvcInputControl.cs" />
    <Compile Include="Controls\Password.cs" />
    <Compile Include="Controls\Repeater.cs" />
    <Compile Include="Controls\RepeaterItem.cs" />
    <Compile Include="Controls\RouteValues.cs" />
    <Compile Include="Controls\TextBox.cs" />
    <Compile Include="SkipBindingAttribute.cs" />
    <Compile Include="FormExtensions.cs" />
    <Compile Include="HtmlButtonType.cs" />
    <Compile Include="LinkBuilder.cs" />
    <Compile Include="LinkExtensions.cs" />
    <Compile Include="RadioExtensions.cs" />
    <Compile Include="ImageExtensions.cs" />
    <Compile Include="MailToExtensions.cs" />
    <Compile Include="TypeHelpers.cs" />
    <Compile Include="ViewExtensions.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\MvcResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>MvcResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3D3FFD8A-624D-4E9B-954B-E1C105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\MvcResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>MvcResources.Designer.cs</LastGenOutput>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\Boolean.ascx">
      <SubType>ASPXCodeBehind</SubType>
    </None>
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\Collection.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\Decimal.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\EmailAddress.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\HiddenInput.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\Html.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\Object.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\String.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\DisplayTemplates\Url.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\Boolean.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\Collection.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\Decimal.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\HiddenInput.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\MultilineText.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\Object.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\Password.ascx" />
    <None Include="FuturesFiles\DefaultTemplates\EditorTemplates\String.ascx" />
    <None Include="FuturesFiles\iismap.vbs" />
    <None Include="FuturesFiles\MvcDiagnostics.aspx">
      <SubType>ASPXCodeBehind</SubType>
    </None>
    <None Include="FuturesFiles\registermvc.wsf" />
    <None Include="FuturesFiles\unregistermvc.wsf" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ArrayModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public class ArrayModelBinder<TElement> : CollectionModelBinder<TElement>
    {
        protected override bool CreateOrReplaceCollection(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, IList<TElement> newCollection)
        {
            bindingContext.Model = newCollection.ToArray();
            return true;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ArrayModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class ArrayModelBinderProvider : ModelBinderProvider
    {
        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            if (!bindingContext.ModelMetadata.IsReadOnly && bindingContext.ModelType.IsArray &&
                bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
            {
                Type elementType = bindingContext.ModelType.GetElementType();
                return (IExtensibleModelBinder)Activator.CreateInstance(typeof(ArrayModelBinder<>).MakeGenericType(elementType));
            }

            return null;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/BinaryDataModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Data.Linq;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // This is a single provider that can work with both byte[] and Binary models.
    public sealed class BinaryDataModelBinderProvider : ModelBinderProvider
    {
        private static readonly ModelBinderProvider[] _providers = new ModelBinderProvider[]
        {
            new SimpleModelBinderProvider(typeof(byte[]), new ByteArrayExtensibleModelBinder()),
            new SimpleModelBinderProvider(typeof(Binary), new LinqBinaryExtensibleModelBinder())
        };

        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            return (from provider in _providers
                    let binder = provider.GetBinder(controllerContext, bindingContext)
                    where binder != null
                    select binder).FirstOrDefault();
        }

        // This is essentially a clone of the ByteArrayModelBinder from core
        private class ByteArrayExtensibleModelBinder : IExtensibleModelBinder
        {
            [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We want to ignore when the data is corrupted")]
            [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Mvc.ValueProviderResult.ConvertTo(System.Type)", Justification = "The target object should make the correct culture determination, not this method.")]
            public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                ModelBinderUtil.ValidateBindingContext(bindingContext);
                ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);

                // case 1: there was no <input ... /> element containing this data
                if (valueProviderResult == null)
                {
                    return false;
                }

                string base64String = (string)valueProviderResult.ConvertTo(typeof(string));

                // case 2: there was an <input ... /> element but it was left blank
                if (String.IsNullOrEmpty(base64String))
                {
                    return false;
                }

                // Future proofing. If the byte array is actually an instance of System.Data.Linq.Binary
                // then we need to remove these quotes put in place by the ToString() method.
                string realValue = base64String.Replace("\"", String.Empty);
                try
                {
                    bindingContext.Model = ConvertByteArray(Convert.FromBase64String(realValue));
                    return true;
                }
                catch
                {
                    // corrupt data - just ignore
                    return false;
                }
            }

            protected virtual object ConvertByteArray(byte[] originalModel)
            {
                return originalModel;
            }
        }

        // This is essentially a clone of the LinqBinaryModelBinder from core
        private class LinqBinaryExtensibleModelBinder : ByteArrayExtensibleModelBinder
        {
            protected override object ConvertByteArray(byte[] originalModel)
            {
                return new Binary(originalModel);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/BindNeverAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.Web.Mvc.ModelBinding
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class BindNeverAttribute : BindingBehaviorAttribute
    {
        public BindNeverAttribute()
            : base(BindingBehavior.Never)
        {
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/BindRequiredAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.Web.Mvc.ModelBinding
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class BindRequiredAttribute : BindingBehaviorAttribute
    {
        public BindRequiredAttribute()
            : base(BindingBehavior.Required)
        {
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/BindingBehavior.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.ModelBinding
{
    public enum BindingBehavior
    {
        Optional = 0,
        Never,
        Required
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/BindingBehaviorAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;

namespace Microsoft.Web.Mvc.ModelBinding
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This class is designed to be overridden")]
    public class BindingBehaviorAttribute : Attribute
    {
        private static readonly object _typeId = new object();

        public BindingBehaviorAttribute(BindingBehavior behavior)
        {
            Behavior = behavior;
        }

        public BindingBehavior Behavior { get; private set; }

        public override object TypeId
        {
            get { return _typeId; }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/CollectionModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public class CollectionModelBinder<TElement> : IExtensibleModelBinder
    {
        // Used when the ValueProvider contains the collection to be bound as multiple elements, e.g. foo[0], foo[1].
        private static List<TElement> BindComplexCollection(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            string indexPropertyName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, "index");
            ValueProviderResult valueProviderResultIndex = bindingContext.ValueProvider.GetValue(indexPropertyName);
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(valueProviderResultIndex);
            return BindComplexCollectionFromIndexes(controllerContext, bindingContext, indexNames);
        }

        internal static List<TElement> BindComplexCollectionFromIndexes(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, IEnumerable<string> indexNames)
        {
            bool indexNamesIsFinite;
            if (indexNames != null)
            {
                indexNamesIsFinite = true;
            }
            else
            {
                indexNamesIsFinite = false;
                indexNames = CollectionModelBinderUtil.GetZeroBasedIndexes();
            }

            List<TElement> boundCollection = new List<TElement>();
            foreach (string indexName in indexNames)
            {
                string fullChildName = ModelBinderUtil.CreateIndexModelName(bindingContext.ModelName, indexName);
                ExtensibleModelBindingContext childBindingContext = new ExtensibleModelBindingContext(bindingContext)
                {
                    ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(TElement)),
                    ModelName = fullChildName
                };

                object boundValue = null;
                IExtensibleModelBinder childBinder = bindingContext.ModelBinderProviders.GetBinder(controllerContext, childBindingContext);
                if (childBinder != null)
                {
                    if (childBinder.BindModel(controllerContext, childBindingContext))
                    {
                        boundValue = childBindingContext.Model;

                        // merge validation up
                        bindingContext.ValidationNode.ChildNodes.Add(childBindingContext.ValidationNode);
                    }
                }
                else
                {
                    // should we even bother continuing?
                    if (!indexNamesIsFinite)
                    {
                        break;
                    }
                }

                boundCollection.Add(ModelBinderUtil.CastOrDefault<TElement>(boundValue));
            }

            return boundCollection;
        }

        public virtual bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            List<TElement> boundCollection = (valueProviderResult != null)
                                                 ? BindSimpleCollection(controllerContext, bindingContext, valueProviderResult.RawValue, valueProviderResult.Culture)
                                                 : BindComplexCollection(controllerContext, bindingContext);

            bool retVal = CreateOrReplaceCollection(controllerContext, bindingContext, boundCollection);
            return retVal;
        }

        // Used when the ValueProvider contains the collection to be bound as a single element, e.g. the raw value
        // is [ "1", "2" ] and needs to be converted to an int[].
        internal static List<TElement> BindSimpleCollection(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, object rawValue, CultureInfo culture)
        {
            if (rawValue == null)
            {
                return null; // nothing to do
            }

            List<TElement> boundCollection = new List<TElement>();

            object[] rawValueArray = ModelBinderUtil.RawValueToObjectArray(rawValue);
            foreach (object rawValueElement in rawValueArray)
            {
                ExtensibleModelBindingContext innerBindingContext = new ExtensibleModelBindingContext(bindingContext)
                {
                    ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(TElement)),
                    ModelName = bindingContext.ModelName,
                    ValueProvider = new ValueProviderCollection
                    {
                        // aggregate value provider
                        new ElementalValueProvider(bindingContext.ModelName, rawValueElement, culture), // our temporary provider goes at the front of the list
                        bindingContext.ValueProvider
                    }
                };

                object boundValue = null;
                IExtensibleModelBinder childBinder = bindingContext.ModelBinderProviders.GetBinder(controllerContext, innerBindingContext);
                if (childBinder != null)
                {
                    if (childBinder.BindModel(controllerContext, innerBindingContext))
                    {
                        boundValue = innerBindingContext.Model;
                        bindingContext.ValidationNode.ChildNodes.Add(innerBindingContext.ValidationNode);
                    }
                }
                boundCollection.Add(ModelBinderUtil.CastOrDefault<TElement>(boundValue));
            }

            return boundCollection;
        }

        // Extensibility point that allows the bound collection to be manipulated or transformed before
        // being returned from the binder.
        protected virtual bool CreateOrReplaceCollection(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, IList<TElement> newCollection)
        {
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, newCollection, () => new List<TElement>());
            return true;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/CollectionModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class CollectionModelBinderProvider : ModelBinderProvider
    {
        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            if (bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
            {
                return CollectionModelBinderUtil.GetGenericBinder(typeof(ICollection<>), typeof(List<>), typeof(CollectionModelBinder<>), bindingContext.ModelMetadata);
            }
            else
            {
                return null;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/CollectionModelBinderUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    internal static class CollectionModelBinderUtil
    {
        public static void CreateOrReplaceCollection<TElement>(ExtensibleModelBindingContext bindingContext, IEnumerable<TElement> incomingElements, Func<ICollection<TElement>> creator)
        {
            ICollection<TElement> collection = bindingContext.Model as ICollection<TElement>;
            if (collection == null || collection.IsReadOnly)
            {
                collection = creator();
                bindingContext.Model = collection;
            }

            collection.Clear();
            foreach (TElement element in incomingElements)
            {
                collection.Add(element);
            }
        }

        public static void CreateOrReplaceDictionary<TKey, TValue>(ExtensibleModelBindingContext bindingContext, IEnumerable<KeyValuePair<TKey, TValue>> incomingElements, Func<IDictionary<TKey, TValue>> creator)
        {
            IDictionary<TKey, TValue> dictionary = bindingContext.Model as IDictionary<TKey, TValue>;
            if (dictionary == null || dictionary.IsReadOnly)
            {
                dictionary = creator();
                bindingContext.Model = dictionary;
            }

            dictionary.Clear();
            foreach (var element in incomingElements)
            {
                if (element.Key != null)
                {
                    dictionary[element.Key] = element.Value;
                }
            }
        }

        // supportedInterfaceType: type that is updatable by this binder
        // newInstanceType: type that will be created by the binder if necessary
        // openBinderType: model binder type
        // modelMetadata: metadata for the model to bind
        //
        // example: GetGenericBinder(typeof(IList<>), typeof(List<>), typeof(ListBinder<>), ...) means that the ListBinder<T>
        // type can update models that implement IList<T>, and if for some reason the existing model instance is not
        // updatable the binder will create a List<T> object and bind to that instead. This method will return a ListBinder<T>
        // or null, depending on whether the type and updatability checks succeed.
        public static IExtensibleModelBinder GetGenericBinder(Type supportedInterfaceType, Type newInstanceType, Type openBinderType, ModelMetadata modelMetadata)
        {
            Type[] typeArguments = GetTypeArgumentsForUpdatableGenericCollection(supportedInterfaceType, newInstanceType, modelMetadata);
            return (typeArguments != null) ? (IExtensibleModelBinder)Activator.CreateInstance(openBinderType.MakeGenericType(typeArguments)) : null;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Mvc.ValueProviderResult.ConvertTo(System.Type)", Justification = "This model binder binds collections, so it does not need culture.")]
        public static IEnumerable<string> GetIndexNamesFromValueProviderResult(ValueProviderResult valueProviderResultIndex)
        {
            IEnumerable<string> indexNames = null;
            if (valueProviderResultIndex != null)
            {
                string[] indexes = (string[])(valueProviderResultIndex.ConvertTo(typeof(string[])));
                if (indexes != null && indexes.Length > 0)
                {
                    indexNames = indexes;
                }
            }
            return indexNames;
        }

        public static IEnumerable<string> GetZeroBasedIndexes()
        {
            int i = 0;
            while (true)
            {
                yield return i.ToString(CultureInfo.InvariantCulture);
                i++;
            }
        }

        // Returns the generic type arguments for the model type if updatable, else null.
        // supportedInterfaceType: open type (like IList<>) of supported interface, must implement ICollection<>
        // newInstanceType: open type (like List<>) of object that will be created, must implement supportedInterfaceType
        public static Type[] GetTypeArgumentsForUpdatableGenericCollection(Type supportedInterfaceType, Type newInstanceType, ModelMetadata modelMetadata)
        {
            /*
             * Check that we can extract proper type arguments from the model.
             */

            if (!modelMetadata.ModelType.IsGenericType || modelMetadata.ModelType.IsGenericTypeDefinition)
            {
                // not a closed generic type
                return null;
            }

            Type[] modelTypeArguments = modelMetadata.ModelType.GetGenericArguments();
            if (modelTypeArguments.Length != supportedInterfaceType.GetGenericArguments().Length)
            {
                // wrong number of generic type arguments
                return null;
            }

            /*
             * Is it possible just to change the reference rather than update the collection in-place?
             */

            if (!modelMetadata.IsReadOnly)
            {
                Type closedNewInstanceType = newInstanceType.MakeGenericType(modelTypeArguments);
                if (modelMetadata.ModelType.IsAssignableFrom(closedNewInstanceType))
                {
                    return modelTypeArguments;
                }
            }

            /*
             * At this point, we know we can't change the reference, so we need to verify that
             * the model instance can be updated in-place.
             */

            Type closedSupportedInterfaceType = supportedInterfaceType.MakeGenericType(modelTypeArguments);
            if (!closedSupportedInterfaceType.IsInstanceOfType(modelMetadata.Model))
            {
                return null; // not instance of correct interface
            }

            Type closedCollectionType = TypeHelpers.ExtractGenericInterface(closedSupportedInterfaceType, typeof(ICollection<>));
            bool collectionInstanceIsReadOnly = (bool)closedCollectionType.GetProperty("IsReadOnly").GetValue(modelMetadata.Model, null);
            if (collectionInstanceIsReadOnly)
            {
                return null;
            }
            else
            {
                return modelTypeArguments;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ComplexModelDto.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // Describes a complex model, but uses a collection rather than individual properties as the data store.
    public class ComplexModelDto
    {
        public ComplexModelDto(ModelMetadata modelMetadata, IEnumerable<ModelMetadata> propertyMetadata)
        {
            if (modelMetadata == null)
            {
                throw new ArgumentNullException("modelMetadata");
            }
            if (propertyMetadata == null)
            {
                throw new ArgumentNullException("propertyMetadata");
            }

            ModelMetadata = modelMetadata;
            PropertyMetadata = new ReadOnlyCollection<ModelMetadata>(propertyMetadata.ToList());
            Results = new Dictionary<ModelMetadata, ComplexModelDtoResult>();
        }

        public ModelMetadata ModelMetadata { get; private set; }

        public ReadOnlyCollection<ModelMetadata> PropertyMetadata { get; private set; }

        // Contains entries corresponding to each property against which binding was
        // attempted. If binding failed, the entry's value will be null. If binding
        // was never attempted, this dictionary will not contain a corresponding
        // entry.
        public IDictionary<ModelMetadata, ComplexModelDtoResult> Results { get; private set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ComplexModelDtoModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class ComplexModelDtoModelBinder : IExtensibleModelBinder
    {
        public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(ComplexModelDto), false /* allowNullModel */);

            ComplexModelDto dto = (ComplexModelDto)bindingContext.Model;
            foreach (ModelMetadata propertyMetadata in dto.PropertyMetadata)
            {
                ExtensibleModelBindingContext propertyBindingContext = new ExtensibleModelBindingContext(bindingContext)
                {
                    ModelMetadata = propertyMetadata,
                    ModelName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, propertyMetadata.PropertyName)
                };

                // bind and propagate the values
                IExtensibleModelBinder propertyBinder = bindingContext.ModelBinderProviders.GetBinder(controllerContext, propertyBindingContext);
                if (propertyBinder != null)
                {
                    if (propertyBinder.BindModel(controllerContext, propertyBindingContext))
                    {
                        dto.Results[propertyMetadata] = new ComplexModelDtoResult(propertyBindingContext.Model, propertyBindingContext.ValidationNode);
                    }
                    else
                    {
                        dto.Results[propertyMetadata] = null;
                    }
                }
            }

            return true;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ComplexModelDtoModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // Returns a binder that can bind ComplexModelDto objects.
    public sealed class ComplexModelDtoModelBinderProvider : ModelBinderProvider
    {
        // This is really just a simple binder.
        private static readonly SimpleModelBinderProvider _underlyingProvider = GetUnderlyingProvider();

        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            return _underlyingProvider.GetBinder(controllerContext, bindingContext);
        }

        private static SimpleModelBinderProvider GetUnderlyingProvider()
        {
            return new SimpleModelBinderProvider(typeof(ComplexModelDto), new ComplexModelDtoModelBinder())
            {
                SuppressPrefixCheck = true
            };
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ComplexModelDtoResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class ComplexModelDtoResult
    {
        public ComplexModelDtoResult(object model, ModelValidationNode validationNode)
        {
            if (validationNode == null)
            {
                throw new ArgumentNullException("validationNode");
            }

            Model = model;
            ValidationNode = validationNode;
        }

        public object Model { get; private set; }

        public ModelValidationNode ValidationNode { get; private set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/DictionaryModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public class DictionaryModelBinder<TKey, TValue> : CollectionModelBinder<KeyValuePair<TKey, TValue>>
    {
        protected override bool CreateOrReplaceCollection(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, IList<KeyValuePair<TKey, TValue>> newCollection)
        {
            CollectionModelBinderUtil.CreateOrReplaceDictionary(bindingContext, newCollection, () => new Dictionary<TKey, TValue>());
            return true;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/DictionaryModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class DictionaryModelBinderProvider : ModelBinderProvider
    {
        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            if (bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
            {
                return CollectionModelBinderUtil.GetGenericBinder(typeof(IDictionary<,>), typeof(Dictionary<,>), typeof(DictionaryModelBinder<,>), bindingContext.ModelMetadata);
            }
            else
            {
                return null;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ExtensibleModelBinderAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // A model binder that is used to interface between the old system and the new system.
    public sealed class ExtensibleModelBinderAdapter : IModelBinder
    {
        public ExtensibleModelBinderAdapter(ModelBinderProviderCollection providers)
        {
            Providers = providers ?? ModelBinderProviders.Providers;
        }

        public ModelBinderProviderCollection Providers { get; private set; }

        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            CheckPropertyFilter(bindingContext);
            ExtensibleModelBindingContext newBindingContext = CreateNewBindingContext(bindingContext, bindingContext.ModelName);

            IExtensibleModelBinder binder = Providers.GetBinder(controllerContext, newBindingContext);
            if (binder == null && !String.IsNullOrEmpty(bindingContext.ModelName)
                && bindingContext.FallbackToEmptyPrefix && bindingContext.ModelMetadata.IsComplexType)
            {
                // fallback to empty prefix?
                newBindingContext = CreateNewBindingContext(bindingContext, String.Empty /* modelName */);
                binder = Providers.GetBinder(controllerContext, newBindingContext);
            }

            if (binder != null)
            {
                bool boundSuccessfully = binder.BindModel(controllerContext, newBindingContext);
                if (boundSuccessfully)
                {
                    // run validation and return the model
                    newBindingContext.ValidationNode.Validate(controllerContext, null /* parentNode */);
                    return newBindingContext.Model;
                }
            }

            return null; // something went wrong
        }

        private static void CheckPropertyFilter(ModelBindingContext bindingContext)
        {
            if (bindingContext.ModelType.GetProperties().Select(p => p.Name).Any(name => !bindingContext.PropertyFilter(name)))
            {
                throw new InvalidOperationException(MvcResources.ExtensibleModelBinderAdapter_PropertyFilterMustNotBeSet);
            }
        }

        private ExtensibleModelBindingContext CreateNewBindingContext(ModelBindingContext oldBindingContext, string modelName)
        {
            ExtensibleModelBindingContext newBindingContext = new ExtensibleModelBindingContext
            {
                ModelBinderProviders = Providers,
                ModelMetadata = oldBindingContext.ModelMetadata,
                ModelName = modelName,
                ModelState = oldBindingContext.ModelState,
                ValueProvider = oldBindingContext.ValueProvider
            };

            return newBindingContext;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ExtensibleModelBinderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.Web.Mvc.ModelBinding
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false, Inherited = true)]
    public sealed class ExtensibleModelBinderAttribute : Attribute
    {
        public ExtensibleModelBinderAttribute(Type binderType)
        {
            BinderType = binderType;
        }

        public Type BinderType { get; private set; }

        public bool SuppressPrefixCheck { get; set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ExtensibleModelBindingContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public class ExtensibleModelBindingContext
    {
        private ModelBinderProviderCollection _modelBinderProviders;
        private string _modelName;
        private ModelStateDictionary _modelState;
        private Dictionary<string, ModelMetadata> _propertyMetadata;
        private ModelValidationNode _validationNode;

        public ExtensibleModelBindingContext()
            : this(null)
        {
        }

        // copies certain values that won't change between parent and child objects,
        // e.g. ValueProvider, ModelState
        public ExtensibleModelBindingContext(ExtensibleModelBindingContext bindingContext)
        {
            if (bindingContext != null)
            {
                ModelBinderProviders = bindingContext.ModelBinderProviders;
                ModelState = bindingContext.ModelState;
                ValueProvider = bindingContext.ValueProvider;
            }
        }

        public object Model
        {
            get
            {
                EnsureModelMetadata();
                return ModelMetadata.Model;
            }
            set
            {
                EnsureModelMetadata();
                ModelMetadata.Model = value;
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is writeable to support unit testing")]
        public ModelBinderProviderCollection ModelBinderProviders
        {
            get
            {
                if (_modelBinderProviders == null)
                {
                    _modelBinderProviders = ModelBinding.ModelBinderProviders.Providers;
                }
                return _modelBinderProviders;
            }
            set { _modelBinderProviders = value; }
        }

        public ModelMetadata ModelMetadata { get; set; }

        public string ModelName
        {
            get
            {
                if (_modelName == null)
                {
                    _modelName = String.Empty;
                }
                return _modelName;
            }
            set { _modelName = value; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is writeable to support unit testing")]
        public ModelStateDictionary ModelState
        {
            get
            {
                if (_modelState == null)
                {
                    _modelState = new ModelStateDictionary();
                }
                return _modelState;
            }
            set { _modelState = value; }
        }

        public Type ModelType
        {
            get
            {
                EnsureModelMetadata();
                return ModelMetadata.ModelType;
            }
        }

        public IDictionary<string, ModelMetadata> PropertyMetadata
        {
            get
            {
                if (_propertyMetadata == null)
                {
                    _propertyMetadata = ModelMetadata.Properties.ToDictionary(m => m.PropertyName, StringComparer.OrdinalIgnoreCase);
                }

                return _propertyMetadata;
            }
        }

        public ModelValidationNode ValidationNode
        {
            get
            {
                if (_validationNode == null)
                {
                    _validationNode = new ModelValidationNode(ModelMetadata, ModelName);
                }
                return _validationNode;
            }
            set { _validationNode = value; }
        }

        public IValueProvider ValueProvider { get; set; }

        private void EnsureModelMetadata()
        {
            if (ModelMetadata == null)
            {
                throw Error.ModelBindingContext_ModelMetadataMustBeSet();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/GenericModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // Returns a user-specified binder for a given open generic type.
    public sealed class GenericModelBinderProvider : ModelBinderProvider
    {
        private readonly Func<Type[], IExtensibleModelBinder> _modelBinderFactory;
        private readonly Type _modelType;

        public GenericModelBinderProvider(Type modelType, IExtensibleModelBinder modelBinder)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }
            if (modelBinder == null)
            {
                throw new ArgumentNullException("modelBinder");
            }

            ValidateParameters(modelType, null /* modelBinderType */);

            _modelType = modelType;
            _modelBinderFactory = _ => modelBinder;
        }

        public GenericModelBinderProvider(Type modelType, Type modelBinderType)
        {
            // The binder can be a closed type, in which case it will be instantiated directly. If the binder
            // is an open type, the type arguments will be determined at runtime and the corresponding closed
            // type instantiated.

            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }
            if (modelBinderType == null)
            {
                throw new ArgumentNullException("modelBinderType");
            }

            ValidateParameters(modelType, modelBinderType);
            bool modelBinderTypeIsOpenGeneric = modelBinderType.IsGenericTypeDefinition;

            _modelType = modelType;
            _modelBinderFactory = typeArguments =>
            {
                Type closedModelBinderType = (modelBinderTypeIsOpenGeneric) ? modelBinderType.MakeGenericType(typeArguments) : modelBinderType;
                try
                {
                    return (IExtensibleModelBinder)Activator.CreateInstance(closedModelBinderType);
                }
                catch (MissingMethodException exception)
                {
                    // Ensure thrown exception contains the type name.  Might be down a few levels.
                    MissingMethodException replacementException =
                        ModelBinderUtil.EnsureDebuggableException(exception, closedModelBinderType.FullName);
                    if (replacementException != null)
                    {
                        throw replacementException;
                    }

                    throw;
                }
            };
        }

        public GenericModelBinderProvider(Type modelType, Func<Type[], IExtensibleModelBinder> modelBinderFactory)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }
            if (modelBinderFactory == null)
            {
                throw new ArgumentNullException("modelBinderFactory");
            }

            ValidateParameters(modelType, null /* modelBinderType */);

            _modelType = modelType;
            _modelBinderFactory = modelBinderFactory;
        }

        public Type ModelType
        {
            get { return _modelType; }
        }

        public bool SuppressPrefixCheck { get; set; }

        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            Type[] typeArguments = null;
            if (ModelType.IsInterface)
            {
                Type matchingClosedInterface = TypeHelpers.ExtractGenericInterface(bindingContext.ModelType, ModelType);
                if (matchingClosedInterface != null)
                {
                    typeArguments = matchingClosedInterface.GetGenericArguments();
                }
            }
            else
            {
                typeArguments = TypeHelpers.GetTypeArgumentsIfMatch(bindingContext.ModelType, ModelType);
            }

            if (typeArguments != null)
            {
                if (SuppressPrefixCheck || bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
                {
                    return _modelBinderFactory(typeArguments);
                }
            }

            return null;
        }

        private static void ValidateParameters(Type modelType, Type modelBinderType)
        {
            if (!modelType.IsGenericTypeDefinition)
            {
                throw Error.GenericModelBinderProvider_ParameterMustSpecifyOpenGenericType(modelType, "modelType");
            }
            if (modelBinderType != null)
            {
                if (!typeof(IExtensibleModelBinder).IsAssignableFrom(modelBinderType))
                {
                    throw Error.Common_TypeMustImplementInterface(modelBinderType, typeof(IExtensibleModelBinder), "modelBinderType");
                }
                if (modelBinderType.IsGenericTypeDefinition)
                {
                    if (modelType.GetGenericArguments().Length != modelBinderType.GetGenericArguments().Length)
                    {
                        throw Error.GenericModelBinderProvider_TypeArgumentCountMismatch(modelType, modelBinderType);
                    }
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/IExtensibleModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public interface IExtensibleModelBinder
    {
        bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext);
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/KeyValuePairModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class KeyValuePairModelBinder<TKey, TValue> : IExtensibleModelBinder
    {
        private ModelMetadataProvider _metadataProvider;

        internal ModelMetadataProvider MetadataProvider
        {
            get
            {
                if (_metadataProvider == null)
                {
                    _metadataProvider = ModelMetadataProviders.Current;
                }
                return _metadataProvider;
            }
            set { _metadataProvider = value; }
        }

        public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(KeyValuePair<TKey, TValue>), true /* allowNullModel */);

            TKey key;
            bool keyBindingSucceeded = KeyValuePairModelBinderUtil.TryBindStrongModel(controllerContext, bindingContext, "key", MetadataProvider, out key);

            TValue value;
            bool valueBindingSucceeded = KeyValuePairModelBinderUtil.TryBindStrongModel(controllerContext, bindingContext, "value", MetadataProvider, out value);

            if (keyBindingSucceeded && valueBindingSucceeded)
            {
                bindingContext.Model = new KeyValuePair<TKey, TValue>(key, value);
            }
            return keyBindingSucceeded || valueBindingSucceeded;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/KeyValuePairModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class KeyValuePairModelBinderProvider : ModelBinderProvider
    {
        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            string keyFieldName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, "key");
            string valueFieldName = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, "value");

            if (bindingContext.ValueProvider.ContainsPrefix(keyFieldName) && bindingContext.ValueProvider.ContainsPrefix(valueFieldName))
            {
                return ModelBinderUtil.GetPossibleBinderInstance(bindingContext.ModelType, typeof(KeyValuePair<,>) /* supported model type */, typeof(KeyValuePairModelBinder<,>) /* binder type */);
            }
            else
            {
                // 'key' or 'value' missing
                return null;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/KeyValuePairModelBinderUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    internal static class KeyValuePairModelBinderUtil
    {
        public static bool TryBindStrongModel<TModel>(ControllerContext controllerContext, ExtensibleModelBindingContext parentBindingContext, string propertyName, ModelMetadataProvider metadataProvider, out TModel model)
        {
            ExtensibleModelBindingContext propertyBindingContext = new ExtensibleModelBindingContext(parentBindingContext)
            {
                ModelMetadata = metadataProvider.GetMetadataForType(null, typeof(TModel)),
                ModelName = ModelBinderUtil.CreatePropertyModelName(parentBindingContext.ModelName, propertyName)
            };

            IExtensibleModelBinder binder = parentBindingContext.ModelBinderProviders.GetBinder(controllerContext, propertyBindingContext);
            if (binder != null)
            {
                if (binder.BindModel(controllerContext, propertyBindingContext))
                {
                    object untypedModel = propertyBindingContext.Model;
                    model = ModelBinderUtil.CastOrDefault<TModel>(untypedModel);
                    parentBindingContext.ValidationNode.ChildNodes.Add(propertyBindingContext.ValidationNode);
                    return true;
                }
            }

            model = default(TModel);
            return false;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelBinderConfig.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // Provides configuration settings common to the new model binding system.
    public static class ModelBinderConfig
    {
        private static ModelBinderErrorMessageProvider _typeConversionErrorMessageProvider;
        private static ModelBinderErrorMessageProvider _valueRequiredErrorMessageProvider;

        public static ModelBinderErrorMessageProvider TypeConversionErrorMessageProvider
        {
            get
            {
                if (_typeConversionErrorMessageProvider == null)
                {
                    _typeConversionErrorMessageProvider = DefaultTypeConversionErrorMessageProvider;
                }
                return _typeConversionErrorMessageProvider;
            }
            set { _typeConversionErrorMessageProvider = value; }
        }

        public static ModelBinderErrorMessageProvider ValueRequiredErrorMessageProvider
        {
            get
            {
                if (_valueRequiredErrorMessageProvider == null)
                {
                    _valueRequiredErrorMessageProvider = DefaultValueRequiredErrorMessageProvider;
                }
                return _valueRequiredErrorMessageProvider;
            }
            set { _valueRequiredErrorMessageProvider = value; }
        }

        private static string DefaultTypeConversionErrorMessageProvider(ControllerContext controllerContext, ModelMetadata modelMetadata, object incomingValue)
        {
            return GetResourceCommon(controllerContext, modelMetadata, incomingValue, GetValueInvalidResource);
        }

        private static string DefaultValueRequiredErrorMessageProvider(ControllerContext controllerContext, ModelMetadata modelMetadata, object incomingValue)
        {
            return GetResourceCommon(controllerContext, modelMetadata, incomingValue, GetValueRequiredResource);
        }

        private static string GetResourceCommon(ControllerContext controllerContext, ModelMetadata modelMetadata, object incomingValue, Func<ControllerContext, string> resourceAccessor)
        {
            string displayName = modelMetadata.GetDisplayName();
            string errorMessageTemplate = resourceAccessor(controllerContext);
            string errorMessage = String.Format(CultureInfo.CurrentCulture, errorMessageTemplate, incomingValue, displayName);
            return errorMessage;
        }

        private static string GetUserResourceString(ControllerContext controllerContext, string resourceName)
        {
            return GetUserResourceString(controllerContext, resourceName, DefaultModelBinder.ResourceClassKey);
        }

        // If the user specified a ResourceClassKey try to load the resource they specified.
        // If the class key is invalid, an exception will be thrown.
        // If the class key is valid but the resource is not found, it returns null, in which
        // case it will fall back to the MVC default error message.
        internal static string GetUserResourceString(ControllerContext controllerContext, string resourceName, string resourceClassKey)
        {
            return (!String.IsNullOrEmpty(resourceClassKey) && (controllerContext != null) && (controllerContext.HttpContext != null))
                       ? controllerContext.HttpContext.GetGlobalResourceObject(resourceClassKey, resourceName, CultureInfo.CurrentUICulture) as string
                       : null;
        }

        private static string GetValueInvalidResource(ControllerContext controllerContext)
        {
            return GetUserResourceString(controllerContext, "PropertyValueInvalid") ?? MvcResources.ModelBinderConfig_ValueInvalid;
        }

        private static string GetValueRequiredResource(ControllerContext controllerContext)
        {
            return GetUserResourceString(controllerContext, "PropertyValueRequired") ?? MvcResources.ModelBinderConfig_ValueRequired;
        }

        /*
         * Initialization routines which replace the default binder implementation with the new binder implementation.
         */

        public static void Initialize()
        {
            Initialize(ModelBinders.Binders, ModelBinderProviders.Providers);
        }

        internal static void Initialize(ModelBinderDictionary binders, ModelBinderProviderCollection providers)
        {
            binders.Clear();
            binders.DefaultBinder = new ExtensibleModelBinderAdapter(providers);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelBinderErrorMessageProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public delegate string ModelBinderErrorMessageProvider(ControllerContext controllerContext, ModelMetadata modelMetadata, object incomingValue);
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public abstract class ModelBinderProvider
    {
        public abstract IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext);
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelBinderProviderCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class ModelBinderProviderCollection : Collection<ModelBinderProvider>
    {
        public ModelBinderProviderCollection()
        {
        }

        public ModelBinderProviderCollection(IList<ModelBinderProvider> list)
            : base(list)
        {
        }

        private static void EnsureNoBindAttribute(Type modelType)
        {
            if (TypeDescriptorHelper.Get(modelType).GetAttributes().OfType<BindAttribute>().Any())
            {
                string errorMessage = String.Format(CultureInfo.CurrentCulture, MvcResources.ModelBinderProviderCollection_TypeCannotHaveBindAttribute,
                                                    modelType);
                throw new InvalidOperationException(errorMessage);
            }
        }

        public IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (bindingContext == null)
            {
                throw new ArgumentNullException("bindingContext");
            }

            EnsureNoBindAttribute(bindingContext.ModelType);

            ModelBinderProvider providerFromAttr;
            if (TryGetProviderFromAttributes(bindingContext.ModelType, out providerFromAttr))
            {
                return providerFromAttr.GetBinder(controllerContext, bindingContext);
            }

            return (from provider in this
                    let binder = provider.GetBinder(controllerContext, bindingContext)
                    where binder != null
                    select binder).FirstOrDefault();
        }

        internal IExtensibleModelBinder GetRequiredBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            IExtensibleModelBinder binder = GetBinder(controllerContext, bindingContext);
            if (binder == null)
            {
                throw Error.ModelBinderProviderCollection_BinderForTypeNotFound(bindingContext.ModelType);
            }
            return binder;
        }

        protected override void InsertItem(int index, ModelBinderProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            base.InsertItem(index, item);
        }

        private void InsertSimpleProviderAtFront(ModelBinderProvider provider)
        {
            // Don't want to insert simple providers before any that are marked as "should go first,"
            // as that might throw off other providers like the exact type match provider.

            int i = 0;
            for (; i < Count; i++)
            {
                if (!ShouldProviderGoFirst(this[i]))
                {
                    break;
                }
            }

            base.InsertItem(i, provider);
        }

        public void RegisterBinderForGenericType(Type modelType, IExtensibleModelBinder modelBinder)
        {
            InsertSimpleProviderAtFront(new GenericModelBinderProvider(modelType, modelBinder));
        }

        public void RegisterBinderForGenericType(Type modelType, Func<Type[], IExtensibleModelBinder> modelBinderFactory)
        {
            InsertSimpleProviderAtFront(new GenericModelBinderProvider(modelType, modelBinderFactory));
        }

        public void RegisterBinderForGenericType(Type modelType, Type modelBinderType)
        {
            InsertSimpleProviderAtFront(new GenericModelBinderProvider(modelType, modelBinderType));
        }

        public void RegisterBinderForType(Type modelType, IExtensibleModelBinder modelBinder)
        {
            RegisterBinderForType(modelType, modelBinder, false /* suppressPrefixCheck */);
        }

        internal void RegisterBinderForType(Type modelType, IExtensibleModelBinder modelBinder, bool suppressPrefixCheck)
        {
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(modelType, modelBinder)
            {
                SuppressPrefixCheck = suppressPrefixCheck
            };
            InsertSimpleProviderAtFront(provider);
        }

        public void RegisterBinderForType(Type modelType, Func<IExtensibleModelBinder> modelBinderFactory)
        {
            InsertSimpleProviderAtFront(new SimpleModelBinderProvider(modelType, modelBinderFactory));
        }

        protected override void SetItem(int index, ModelBinderProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }

            base.SetItem(index, item);
        }

        private static bool ShouldProviderGoFirst(ModelBinderProvider provider)
        {
            ModelBinderProviderOptionsAttribute options = provider.GetType()
                .GetCustomAttributes(typeof(ModelBinderProviderOptionsAttribute), true /* inherit */)
                .OfType<ModelBinderProviderOptionsAttribute>()
                .FirstOrDefault();

            return (options != null) ? options.FrontOfList : false;
        }

        private static bool TryGetProviderFromAttributes(Type modelType, out ModelBinderProvider provider)
        {
            ExtensibleModelBinderAttribute attr = TypeDescriptorHelper.Get(modelType).GetAttributes().OfType<ExtensibleModelBinderAttribute>().FirstOrDefault();
            if (attr == null)
            {
                provider = null;
                return false;
            }

            if (typeof(ModelBinderProvider).IsAssignableFrom(attr.BinderType))
            {
                provider = (ModelBinderProvider)CreateInstance(attr.BinderType);
            }
            else if (typeof(IExtensibleModelBinder).IsAssignableFrom(attr.BinderType))
            {
                Type closedBinderType = (attr.BinderType.IsGenericTypeDefinition) ? attr.BinderType.MakeGenericType(modelType.GetGenericArguments()) : attr.BinderType;
                IExtensibleModelBinder binderInstance = (IExtensibleModelBinder)CreateInstance(closedBinderType);
                provider = new SimpleModelBinderProvider(modelType, binderInstance) { SuppressPrefixCheck = attr.SuppressPrefixCheck };
            }
            else
            {
                string errorMessage = String.Format(CultureInfo.CurrentCulture, MvcResources.ModelBinderProviderCollection_InvalidBinderType,
                                                    attr.BinderType, typeof(ModelBinderProvider), typeof(IExtensibleModelBinder));
                throw new InvalidOperationException(errorMessage);
            }

            return true;
        }

        private static object CreateInstance(Type type)
        {
            try
            {
                return Activator.CreateInstance(type);
            }
            catch (MissingMethodException exception)
            {
                // Ensure thrown exception contains the type name.  Might be down a few levels.
                MissingMethodException replacementException =
                    ModelBinderUtil.EnsureDebuggableException(exception, type.FullName);
                if (replacementException != null)
                {
                    throw replacementException;
                }

                throw;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelBinderProviderOptionsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.Web.Mvc.ModelBinding
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public sealed class ModelBinderProviderOptionsAttribute : Attribute
    {
        // Specifies that a provider should appear at the front of the list, e.g. other providers should
        // not be auto-registered at the front unless explicitly requested.
        public bool FrontOfList { get; set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelBinderProviders.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.ModelBinding
{
    public static class ModelBinderProviders
    {
        private static readonly ModelBinderProviderCollection _providers = CreateDefaultCollection();

        public static ModelBinderProviderCollection Providers
        {
            get { return _providers; }
        }

        private static ModelBinderProviderCollection CreateDefaultCollection()
        {
            return new ModelBinderProviderCollection
            {
                new TypeMatchModelBinderProvider(),
                new BinaryDataModelBinderProvider(),
                new KeyValuePairModelBinderProvider(),
                new ComplexModelDtoModelBinderProvider(),
                new ArrayModelBinderProvider(),
                new DictionaryModelBinderProvider(),
                new CollectionModelBinderProvider(),
                new TypeConverterModelBinderProvider(),
                new MutableObjectModelBinderProvider()
            };
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelBinderUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Globalization;
using System.Linq;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.ModelBinding
{
    internal static class ModelBinderUtil
    {
        public static TModel CastOrDefault<TModel>(object model)
        {
            return (model is TModel) ? (TModel)model : default(TModel);
        }

        public static string CreateIndexModelName(string parentName, int index)
        {
            return CreateIndexModelName(parentName, index.ToString(CultureInfo.InvariantCulture));
        }

        public static string CreateIndexModelName(string parentName, string index)
        {
            return (parentName.Length == 0) ? "[" + index + "]" : parentName + "[" + index + "]";
        }

        public static string CreatePropertyModelName(string prefix, string propertyName)
        {
            if (String.IsNullOrEmpty(prefix))
            {
                return propertyName ?? String.Empty;
            }
            else if (String.IsNullOrEmpty(propertyName))
            {
                return prefix ?? String.Empty;
            }
            else
            {
                return prefix + "." + propertyName;
            }
        }

        public static IExtensibleModelBinder GetPossibleBinderInstance(Type closedModelType, Type openModelType, Type openBinderType)
        {
            Type[] typeArguments = TypeHelpers.GetTypeArgumentsIfMatch(closedModelType, openModelType);
            return (typeArguments != null) ? (IExtensibleModelBinder)Activator.CreateInstance(openBinderType.MakeGenericType(typeArguments)) : null;
        }

        public static object[] RawValueToObjectArray(object rawValue)
        {
            // precondition: rawValue is not null

            // Need to special-case String so it's not caught by the IEnumerable check which follows
            if (rawValue is string)
            {
                return new[] { rawValue };
            }

            object[] rawValueAsObjectArray = rawValue as object[];
            if (rawValueAsObjectArray != null)
            {
                return rawValueAsObjectArray;
            }

            IEnumerable rawValueAsEnumerable = rawValue as IEnumerable;
            if (rawValueAsEnumerable != null)
            {
                return rawValueAsEnumerable.Cast<object>().ToArray();
            }

            // fallback
            return new[] { rawValue };
        }

        public static void ReplaceEmptyStringWithNull(ModelMetadata modelMetadata, ref object model)
        {
            if (modelMetadata.ConvertEmptyStringToNull && StringIsEmptyOrWhitespace(model as string))
            {
                model = null;
            }
        }

        /// <summary>
        /// Provide a new <see cref="MissingMethodException"/> if original Message does not contain given full Type name.
        /// </summary>
        /// <param name="originalException"><see cref="MissingMethodException"/> to check.</param>
        /// <param name="fullTypeName">Full Type name which Message should contain.</param>
        /// <returns>New <see cref="MissingMethodException"/> if an update is required; null otherwise.</returns>
        public static MissingMethodException EnsureDebuggableException(
            MissingMethodException originalException,
            string fullTypeName)
        {
            MissingMethodException replacementException = null;
            if (!originalException.Message.Contains(fullTypeName))
            {
                string message = String.Format(
                    CultureInfo.CurrentCulture,
                    MvcResources.ModelBinderUtil_CannotCreateInstance,
                    originalException.Message,
                    fullTypeName);
                replacementException = new MissingMethodException(message, originalException);
            }

            return replacementException;
        }

        // Based on String.IsNullOrWhitespace
        private static bool StringIsEmptyOrWhitespace(string s)
        {
            if (s == null)
            {
                return false;
            }

            if (s.Length != 0)
            {
                for (int i = 0; i < s.Length; i++)
                {
                    if (!Char.IsWhiteSpace(s[i]))
                    {
                        return false;
                    }
                }
            }
            return true;
        }

        public static void ValidateBindingContext(ExtensibleModelBindingContext bindingContext)
        {
            if (bindingContext == null)
            {
                throw new ArgumentNullException("bindingContext");
            }

            if (bindingContext.ModelMetadata == null)
            {
                throw Error.ModelBinderUtil_ModelMetadataCannotBeNull();
            }
        }

        public static void ValidateBindingContext(ExtensibleModelBindingContext bindingContext, Type requiredType, bool allowNullModel)
        {
            ValidateBindingContext(bindingContext);

            if (bindingContext.ModelType != requiredType)
            {
                throw Error.ModelBinderUtil_ModelTypeIsWrong(bindingContext.ModelType, requiredType);
            }

            if (!allowNullModel && bindingContext.Model == null)
            {
                throw Error.ModelBinderUtil_ModelCannotBeNull(requiredType);
            }

            if (bindingContext.Model != null && !requiredType.IsInstanceOfType(bindingContext.Model))
            {
                throw Error.ModelBinderUtil_ModelInstanceIsWrong(bindingContext.Model.GetType(), requiredType);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelValidatedEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class ModelValidatedEventArgs : EventArgs
    {
        public ModelValidatedEventArgs(ControllerContext controllerContext, ModelValidationNode parentNode)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            ControllerContext = controllerContext;
            ParentNode = parentNode;
        }

        public ControllerContext ControllerContext { get; private set; }

        public ModelValidationNode ParentNode { get; private set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelValidatingEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class ModelValidatingEventArgs : CancelEventArgs
    {
        public ModelValidatingEventArgs(ControllerContext controllerContext, ModelValidationNode parentNode)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            ControllerContext = controllerContext;
            ParentNode = parentNode;
        }

        public ControllerContext ControllerContext { get; private set; }

        public ModelValidationNode ParentNode { get; private set; }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/ModelValidationNode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class ModelValidationNode
    {
        public ModelValidationNode(ModelMetadata modelMetadata, string modelStateKey)
            : this(modelMetadata, modelStateKey, null)
        {
        }

        public ModelValidationNode(ModelMetadata modelMetadata, string modelStateKey, IEnumerable<ModelValidationNode> childNodes)
        {
            if (modelMetadata == null)
            {
                throw new ArgumentNullException("modelMetadata");
            }
            if (modelStateKey == null)
            {
                throw new ArgumentNullException("modelStateKey");
            }

            ModelMetadata = modelMetadata;
            ModelStateKey = modelStateKey;
            ChildNodes = (childNodes != null) ? childNodes.ToList() : new List<ModelValidationNode>();
        }

        public event EventHandler<ModelValidatedEventArgs> Validated;

        public event EventHandler<ModelValidatingEventArgs> Validating;

        public ICollection<ModelValidationNode> ChildNodes { get; private set; }

        public ModelMetadata ModelMetadata { get; private set; }

        public string ModelStateKey { get; private set; }

        public bool ValidateAllProperties { get; set; }

        public bool SuppressValidation { get; set; }

        public void CombineWith(ModelValidationNode otherNode)
        {
            if (otherNode != null && !otherNode.SuppressValidation)
            {
                Validated += otherNode.Validated;
                Validating += otherNode.Validating;
                foreach (ModelValidationNode childNode in otherNode.ChildNodes)
                {
                    ChildNodes.Add(childNode);
                }
            }
        }

        private void OnValidated(ModelValidatedEventArgs e)
        {
            EventHandler<ModelValidatedEventArgs> handler = Validated;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private void OnValidating(ModelValidatingEventArgs e)
        {
            EventHandler<ModelValidatingEventArgs> handler = Validating;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private object TryConvertContainerToMetadataType(ModelValidationNode parentNode)
        {
            if (parentNode != null)
            {
                object containerInstance = parentNode.ModelMetadata.Model;
                if (containerInstance != null)
                {
                    Type expectedContainerType = ModelMetadata.ContainerType;
                    if (expectedContainerType != null)
                    {
                        if (expectedContainerType.IsInstanceOfType(containerInstance))
                        {
                            return containerInstance;
                        }
                    }
                }
            }

            return null;
        }

        public void Validate(ControllerContext controllerContext)
        {
            Validate(controllerContext, null /* parentNode */);
        }

        public void Validate(ControllerContext controllerContext, ModelValidationNode parentNode)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            if (SuppressValidation)
            {
                // no-op
                return;
            }

            // pre-validation steps
            ModelValidatingEventArgs validatingEventArgs = new ModelValidatingEventArgs(controllerContext, parentNode);
            OnValidating(validatingEventArgs);
            if (validatingEventArgs.Cancel)
            {
                return;
            }

            ValidateChildren(controllerContext);
            ValidateThis(controllerContext, parentNode);

            // post-validation steps
            ModelValidatedEventArgs validatedEventArgs = new ModelValidatedEventArgs(controllerContext, parentNode);
            OnValidated(validatedEventArgs);
        }

        private void ValidateChildren(ControllerContext controllerContext)
        {
            foreach (ModelValidationNode child in ChildNodes)
            {
                child.Validate(controllerContext, this);
            }

            if (ValidateAllProperties)
            {
                ValidateProperties(controllerContext);
            }
        }

        private void ValidateProperties(ControllerContext controllerContext)
        {
            // Based off CompositeModelValidator.
            ModelStateDictionary modelState = controllerContext.Controller.ViewData.ModelState;

            // DevDiv Bugs #227802 - Caching problem in ModelMetadata requires us to manually regenerate
            // the ModelMetadata.
            object model = ModelMetadata.Model;
            ModelMetadata updatedMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, ModelMetadata.ModelType);

            foreach (ModelMetadata propertyMetadata in updatedMetadata.Properties)
            {
                // Only want to add errors to ModelState if something doesn't already exist for the property node,
                // else we could end up with duplicate or irrelevant error messages.
                string propertyKeyRoot = ModelBinderUtil.CreatePropertyModelName(ModelStateKey, propertyMetadata.PropertyName);

                if (modelState.IsValidField(propertyKeyRoot))
                {
                    foreach (ModelValidator propertyValidator in propertyMetadata.GetValidators(controllerContext))
                    {
                        foreach (ModelValidationResult propertyResult in propertyValidator.Validate(model))
                        {
                            string thisErrorKey = ModelBinderUtil.CreatePropertyModelName(propertyKeyRoot, propertyResult.MemberName);
                            modelState.AddModelError(thisErrorKey, propertyResult.Message);
                        }
                    }
                }
            }
        }

        private void ValidateThis(ControllerContext controllerContext, ModelValidationNode parentNode)
        {
            ModelStateDictionary modelState = controllerContext.Controller.ViewData.ModelState;
            if (!modelState.IsValidField(ModelStateKey))
            {
                return; // short-circuit
            }

            object container = TryConvertContainerToMetadataType(parentNode);
            foreach (ModelValidator validator in ModelMetadata.GetValidators(controllerContext))
            {
                foreach (ModelValidationResult validationResult in validator.Validate(container))
                {
                    string trueModelStateKey = ModelBinderUtil.CreatePropertyModelName(ModelStateKey, validationResult.MemberName);
                    modelState.AddModelError(trueModelStateKey, validationResult.Message);
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/MutableObjectModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public class MutableObjectModelBinder : IExtensibleModelBinder
    {
        private ModelMetadataProvider _metadataProvider;

        internal ModelMetadataProvider MetadataProvider
        {
            get
            {
                if (_metadataProvider == null)
                {
                    _metadataProvider = ModelMetadataProviders.Current;
                }
                return _metadataProvider;
            }
            set { _metadataProvider = value; }
        }

        public virtual bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            EnsureModel(controllerContext, bindingContext);
            IEnumerable<ModelMetadata> propertyMetadatas = GetMetadataForProperties(controllerContext, bindingContext);
            ComplexModelDto dto = CreateAndPopulateDto(controllerContext, bindingContext, propertyMetadatas);

            // post-processing, e.g. property setters and hooking up validation
            ProcessDto(controllerContext, bindingContext, dto);
            bindingContext.ValidationNode.ValidateAllProperties = true; // complex models require full validation
            return true;
        }

        protected virtual bool CanUpdateProperty(ModelMetadata propertyMetadata)
        {
            return CanUpdatePropertyInternal(propertyMetadata);
        }

        internal static bool CanUpdatePropertyInternal(ModelMetadata propertyMetadata)
        {
            return (!propertyMetadata.IsReadOnly || CanUpdateReadOnlyProperty(propertyMetadata.ModelType));
        }

        private static bool CanUpdateReadOnlyProperty(Type propertyType)
        {
            // Value types have copy-by-value semantics, which prevents us from updating
            // properties that are marked readonly.
            if (propertyType.IsValueType)
            {
                return false;
            }

            // Arrays are strange beasts since their contents are mutable but their sizes aren't.
            // Therefore we shouldn't even try to update these. Further reading:
            // http://blogs.msdn.com/ericlippert/archive/2008/09/22/arrays-considered-somewhat-harmful.aspx
            if (propertyType.IsArray)
            {
                return false;
            }

            // Special-case known immutable reference types
            if (propertyType == typeof(string))
            {
                return false;
            }

            return true;
        }

        private ComplexModelDto CreateAndPopulateDto(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, IEnumerable<ModelMetadata> propertyMetadatas)
        {
            // create a DTO and call into the DTO binder
            ComplexModelDto originalDto = new ComplexModelDto(bindingContext.ModelMetadata, propertyMetadatas);
            ExtensibleModelBindingContext dtoBindingContext = new ExtensibleModelBindingContext(bindingContext)
            {
                ModelMetadata = MetadataProvider.GetMetadataForType(() => originalDto, typeof(ComplexModelDto)),
                ModelName = bindingContext.ModelName
            };

            IExtensibleModelBinder dtoBinder = bindingContext.ModelBinderProviders.GetRequiredBinder(controllerContext, dtoBindingContext);
            dtoBinder.BindModel(controllerContext, dtoBindingContext);
            return (ComplexModelDto)dtoBindingContext.Model;
        }

        protected virtual object CreateModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            // If the Activator throws an exception, we want to propagate it back up the call stack, since the application
            // developer should know that this was an invalid type to try to bind to.
            try
            {
                return Activator.CreateInstance(bindingContext.ModelType);
            }
            catch (MissingMethodException exception)
            {
                // Ensure thrown exception contains the type name.  Might be down a few levels.
                MissingMethodException replacementException =
                    ModelBinderUtil.EnsureDebuggableException(exception, bindingContext.ModelType.FullName);
                if (replacementException != null)
                {
                    throw replacementException;
                }

                throw;
            }
        }

        // Called when the property setter null check failed, allows us to add our own error message to ModelState.
        internal static EventHandler<ModelValidatedEventArgs> CreateNullCheckFailedHandler(ControllerContext controllerContext, ModelMetadata modelMetadata, object incomingValue)
        {
            return (sender, e) =>
            {
                ModelValidationNode validationNode = (ModelValidationNode)sender;
                ModelStateDictionary modelState = e.ControllerContext.Controller.ViewData.ModelState;

                if (modelState.IsValidField(validationNode.ModelStateKey))
                {
                    string errorMessage = ModelBinderConfig.ValueRequiredErrorMessageProvider(controllerContext, modelMetadata, incomingValue);
                    if (errorMessage != null)
                    {
                        modelState.AddModelError(validationNode.ModelStateKey, errorMessage);
                    }
                }
            };
        }

        protected virtual void EnsureModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            if (bindingContext.Model == null)
            {
                bindingContext.ModelMetadata.Model = CreateModel(controllerContext, bindingContext);
            }
        }

        protected virtual IEnumerable<ModelMetadata> GetMetadataForProperties(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            // keep a set of the required properties so that we can cross-reference bound properties later
            HashSet<string> requiredProperties;
            HashSet<string> skipProperties;
            GetRequiredPropertiesCollection(bindingContext.ModelType, out requiredProperties, out skipProperties);

            return from propertyMetadata in bindingContext.ModelMetadata.Properties
                   let propertyName = propertyMetadata.PropertyName
                   let shouldUpdateProperty = requiredProperties.Contains(propertyName) || !skipProperties.Contains(propertyName)
                   where shouldUpdateProperty && CanUpdateProperty(propertyMetadata)
                   select propertyMetadata;
        }

        private static object GetPropertyDefaultValue(PropertyDescriptor propertyDescriptor)
        {
            DefaultValueAttribute attr = propertyDescriptor.Attributes.OfType<DefaultValueAttribute>().FirstOrDefault();
            return (attr != null) ? attr.Value : null;
        }

        internal static void GetRequiredPropertiesCollection(Type modelType, out HashSet<string> requiredProperties, out HashSet<string> skipProperties)
        {
            requiredProperties = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            skipProperties = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            // Use attributes on the property before attributes on the type.
            ICustomTypeDescriptor modelDescriptor = TypeDescriptorHelper.Get(modelType);
            PropertyDescriptorCollection propertyDescriptors = modelDescriptor.GetProperties();
            BindingBehaviorAttribute typeAttr = modelDescriptor.GetAttributes().OfType<BindingBehaviorAttribute>().SingleOrDefault();

            foreach (PropertyDescriptor propertyDescriptor in propertyDescriptors)
            {
                BindingBehaviorAttribute propAttr = propertyDescriptor.Attributes.OfType<BindingBehaviorAttribute>().SingleOrDefault();
                BindingBehaviorAttribute workingAttr = propAttr ?? typeAttr;
                if (workingAttr != null)
                {
                    switch (workingAttr.Behavior)
                    {
                        case BindingBehavior.Required:
                            requiredProperties.Add(propertyDescriptor.Name);
                            break;

                        case BindingBehavior.Never:
                            skipProperties.Add(propertyDescriptor.Name);
                            break;
                    }
                }
            }
        }

        internal void ProcessDto(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, ComplexModelDto dto)
        {
            HashSet<string> requiredProperties;
            HashSet<string> skipProperties;
            GetRequiredPropertiesCollection(bindingContext.ModelType, out requiredProperties, out skipProperties);

            // Are all of the required fields accounted for?
            HashSet<string> missingRequiredProperties = new HashSet<string>(requiredProperties);
            missingRequiredProperties.ExceptWith(dto.Results.Select(r => r.Key.PropertyName));
            string missingPropertyName = missingRequiredProperties.FirstOrDefault();
            if (missingPropertyName != null)
            {
                string fullPropertyKey = ModelBinderUtil.CreatePropertyModelName(bindingContext.ModelName, missingPropertyName);
                throw Error.BindingBehavior_ValueNotFound(fullPropertyKey);
            }

            // for each property that was bound, call the setter, recording exceptions as necessary
            foreach (var entry in dto.Results)
            {
                ModelMetadata propertyMetadata = entry.Key;

                ComplexModelDtoResult dtoResult = entry.Value;
                if (dtoResult != null)
                {
                    SetProperty(controllerContext, bindingContext, propertyMetadata, dtoResult);
                    bindingContext.ValidationNode.ChildNodes.Add(dtoResult.ValidationNode);
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We're recording this exception so that we can act on it later.")]
        protected virtual void SetProperty(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult)
        {
            PropertyDescriptor propertyDescriptor = TypeDescriptorHelper.Get(bindingContext.ModelType).GetProperties().Find(propertyMetadata.PropertyName, true /* ignoreCase */);
            if (propertyDescriptor == null || propertyDescriptor.IsReadOnly)
            {
                return; // nothing to do
            }

            object value = dtoResult.Model ?? GetPropertyDefaultValue(propertyDescriptor);
            propertyMetadata.Model = value;

            // 'Required' validators need to run first so that we can provide useful error messages if
            // the property setters throw, e.g. if we're setting entity keys to null. See comments in
            // DefaultModelBinder.SetProperty() for more information.
            if (value == null)
            {
                string modelStateKey = dtoResult.ValidationNode.ModelStateKey;
                if (bindingContext.ModelState.IsValidField(modelStateKey))
                {
                    ModelValidator requiredValidator = ModelValidatorProviders.Providers.GetValidators(propertyMetadata, controllerContext).Where(v => v.IsRequired).FirstOrDefault();
                    if (requiredValidator != null)
                    {
                        foreach (ModelValidationResult validationResult in requiredValidator.Validate(bindingContext.Model))
                        {
                            bindingContext.ModelState.AddModelError(modelStateKey, validationResult.Message);
                        }
                    }
                }
            }

            if (value != null || TypeHelpers.TypeAllowsNullValue(propertyDescriptor.PropertyType))
            {
                try
                {
                    propertyDescriptor.SetValue(bindingContext.Model, value);
                }
                catch (Exception ex)
                {
                    // don't display a duplicate error message if a binding error has already occurred for this field
                    string modelStateKey = dtoResult.ValidationNode.ModelStateKey;
                    if (bindingContext.ModelState.IsValidField(modelStateKey))
                    {
                        bindingContext.ModelState.AddModelError(modelStateKey, ex);
                    }
                }
            }
            else
            {
                // trying to set a non-nullable value type to null, need to make sure there's a message
                string modelStateKey = dtoResult.ValidationNode.ModelStateKey;
                if (bindingContext.ModelState.IsValidField(modelStateKey))
                {
                    dtoResult.ValidationNode.Validated += CreateNullCheckFailedHandler(controllerContext, propertyMetadata, value);
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/MutableObjectModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class MutableObjectModelBinderProvider : ModelBinderProvider
    {
        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            if (!bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
            {
                // no values to bind
                return null;
            }

            if (bindingContext.ModelType == typeof(ComplexModelDto))
            {
                // forbidden type - will cause a stack overflow if we try binding this type
                return null;
            }

            return new MutableObjectModelBinder();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/SimpleModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // Returns a user-specified binder for a given type.
    public sealed class SimpleModelBinderProvider : ModelBinderProvider
    {
        private readonly Func<IExtensibleModelBinder> _modelBinderFactory;
        private readonly Type _modelType;

        public SimpleModelBinderProvider(Type modelType, IExtensibleModelBinder modelBinder)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }
            if (modelBinder == null)
            {
                throw new ArgumentNullException("modelBinder");
            }

            _modelType = modelType;
            _modelBinderFactory = () => modelBinder;
        }

        public SimpleModelBinderProvider(Type modelType, Func<IExtensibleModelBinder> modelBinderFactory)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }
            if (modelBinderFactory == null)
            {
                throw new ArgumentNullException("modelBinderFactory");
            }

            _modelType = modelType;
            _modelBinderFactory = modelBinderFactory;
        }

        public Type ModelType
        {
            get { return _modelType; }
        }

        public bool SuppressPrefixCheck { get; set; }

        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            if (bindingContext.ModelType == ModelType)
            {
                if (SuppressPrefixCheck || bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
                {
                    return _modelBinderFactory();
                }
            }

            return null;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/TypeConverterModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class TypeConverterModelBinder : IExtensibleModelBinder
    {
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is recorded to be acted upon later.")]
        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Mvc.ValueProviderResult.ConvertTo(System.Type)", Justification = "The ValueProviderResult already has the necessary context to perform a culture-aware conversion.")]
        public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            if (valueProviderResult == null)
            {
                return false; // no entry
            }

            object newModel;
            bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
            try
            {
                newModel = valueProviderResult.ConvertTo(bindingContext.ModelType);
            }
            catch (Exception ex)
            {
                if (IsFormatException(ex))
                {
                    // there was a type conversion failure
                    string errorString = ModelBinderConfig.TypeConversionErrorMessageProvider(controllerContext, bindingContext.ModelMetadata, valueProviderResult.AttemptedValue);
                    if (errorString != null)
                    {
                        bindingContext.ModelState.AddModelError(bindingContext.ModelName, errorString);
                    }
                }
                else
                {
                    bindingContext.ModelState.AddModelError(bindingContext.ModelName, ex);
                }
                return false;
            }

            ModelBinderUtil.ReplaceEmptyStringWithNull(bindingContext.ModelMetadata, ref newModel);
            bindingContext.Model = newModel;
            return true;
        }

        private static bool IsFormatException(Exception ex)
        {
            for (; ex != null; ex = ex.InnerException)
            {
                if (ex is FormatException)
                {
                    return true;
                }
            }
            return false;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/TypeConverterModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // Returns a binder that can perform conversions using a .NET TypeConverter.
    public sealed class TypeConverterModelBinderProvider : ModelBinderProvider
    {
        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            if (valueProviderResult == null)
            {
                return null; // no value to convert
            }

            if (!TypeDescriptor.GetConverter(bindingContext.ModelType).CanConvertFrom(typeof(string)))
            {
                return null; // this type cannot be converted
            }

            return new TypeConverterModelBinder();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/TypeMatchModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    public sealed class TypeMatchModelBinder : IExtensibleModelBinder
    {
        public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            ValueProviderResult valueProviderResult = GetCompatibleValueProviderResult(bindingContext);
            if (valueProviderResult == null)
            {
                return false; // conversion would have failed
            }

            bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
            object model = valueProviderResult.RawValue;
            ModelBinderUtil.ReplaceEmptyStringWithNull(bindingContext.ModelMetadata, ref model);
            bindingContext.Model = model;

            return true;
        }

        internal static ValueProviderResult GetCompatibleValueProviderResult(ExtensibleModelBindingContext bindingContext)
        {
            ModelBinderUtil.ValidateBindingContext(bindingContext);

            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            if (valueProviderResult == null)
            {
                return null; // the value doesn't exist
            }

            if (!TypeHelpers.IsCompatibleObject(bindingContext.ModelType, valueProviderResult.RawValue))
            {
                return null; // value is of incompatible type
            }

            return valueProviderResult;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelBinding/TypeMatchModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.Mvc.ModelBinding
{
    // Returns a binder that can extract a ValueProviderResult.RawValue and return it directly.
    [ModelBinderProviderOptions(FrontOfList = true)]
    public sealed class TypeMatchModelBinderProvider : ModelBinderProvider
    {
        public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
        {
            return (TypeMatchModelBinder.GetCompatibleValueProviderResult(bindingContext) != null)
                       ? new TypeMatchModelBinder()
                       : null /* no match */;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ModelCopier.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;

namespace Microsoft.Web.Mvc
{
    public static class ModelCopier
    {
        public static void CopyCollection<T>(IEnumerable<T> from, ICollection<T> to)
        {
            if (from == null || to == null || to.IsReadOnly)
            {
                return;
            }

            to.Clear();
            foreach (T element in from)
            {
                to.Add(element);
            }
        }

        public static void CopyModel(object from, object to)
        {
            if (from == null || to == null)
            {
                return;
            }

            PropertyDescriptorCollection fromProperties = TypeDescriptor.GetProperties(from);
            PropertyDescriptorCollection toProperties = TypeDescriptor.GetProperties(to);

            foreach (PropertyDescriptor fromProperty in fromProperties)
            {
                PropertyDescriptor toProperty = toProperties.Find(fromProperty.Name, true /* ignoreCase */);
                if (toProperty != null && !toProperty.IsReadOnly)
                {
                    // Can from.Property reference just be assigned directly to to.Property reference?
                    bool isDirectlyAssignable = toProperty.PropertyType.IsAssignableFrom(fromProperty.PropertyType);
                    // Is from.Property just the nullable form of to.Property?
                    bool liftedValueType = (isDirectlyAssignable) ? false : (Nullable.GetUnderlyingType(fromProperty.PropertyType) == toProperty.PropertyType);

                    if (isDirectlyAssignable || liftedValueType)
                    {
                        object fromValue = fromProperty.GetValue(from);
                        if (isDirectlyAssignable || (fromValue != null && liftedValueType))
                        {
                            toProperty.SetValue(to, fromValue);
                        }
                    }
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/MvcSerializer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Web.Security;
using System.Xml;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    public class MvcSerializer
    {
        private static readonly string[] _machineKeyPurposes = new string[] { "Microsoft.Web.Mvc.MvcSerializer.v1" };

        private static SerializationException CreateSerializationException(Exception innerException)
        {
            return new SerializationException(MvcResources.MvcSerializer_DeserializationFailed, innerException);
        }

        public virtual object Deserialize(string serializedValue)
        {
            return Deserialize(serializedValue, MachineKeyWrapper.Instance);
        }

        internal static object Deserialize(string serializedValue, IMachineKey machineKey)
        {
            if (String.IsNullOrEmpty(serializedValue))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "serializedValue");
            }

            try
            {
                // First, need to decrypt / verify data
                byte[] rawBytes = machineKey.Unprotect(serializedValue, _machineKeyPurposes);

                // Finally, deserialize the object graph
                using (MemoryStream ms = new MemoryStream(rawBytes, 0, rawBytes.Length))
                {
                    return DeserializeGraph(ms);
                }
            }
            catch (Exception ex)
            {
                throw CreateSerializationException(ex);
            }
        }

        // Deserializes a stream to a graph using the NetDataContractSerializer (binary mode)
        private static object DeserializeGraph(Stream rawBytes)
        {
            using (XmlDictionaryReader dr = XmlDictionaryReader.CreateBinaryReader(rawBytes, XmlDictionaryReaderQuotas.Max))
            {
                object deserialized = new NetDataContractSerializer().ReadObject(dr);
                return deserialized;
            }
        }

        public virtual string Serialize(object state)
        {
            return Serialize(state, MachineKeyWrapper.Instance);
        }

        internal static string Serialize(object state, IMachineKey machineKey)
        {
            try
            {
                // First, need to serialize the object graph
                byte[] rawBytes;
                using (MemoryStream ms = new MemoryStream())
                {
                    SerializeGraph(ms, state);
                    rawBytes = ms.ToArray();
                }

                // Then, encrypt / sign data
                return machineKey.Protect(rawBytes, _machineKeyPurposes);
            }
            catch (Exception ex)
            {
                throw CreateSerializationException(ex);
            }
        }

        // Serializes a graph to a byte array using the NetDataContractSerializer (binary mode)
        private static void SerializeGraph(Stream outputStream, object graph)
        {
            using (XmlDictionaryWriter dw = XmlDictionaryWriter.CreateBinaryWriter(outputStream, null, null, ownsStream: false))
            {
                new NetDataContractSerializer().WriteObject(dw, graph);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

[assembly: AssemblyTitle("Microsoft.Web.Mvc.dll")]
[assembly: AssemblyDescription("Microsoft.Web.Mvc.dll")]
[assembly: Guid("f3507a98-9429-404b-9e0e-1b426a5b3ad5")]
[assembly: InternalsVisibleTo("Microsoft.Web.Mvc.Test")]


================================================
FILE: src/Microsoft.Web.Mvc/Properties/MvcResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18051
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.Web.Mvc.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class MvcResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal MvcResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Web.Mvc.Properties.MvcResources", typeof(MvcResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} field only accepts files with one of the following content types: {1}..
        /// </summary>
        internal static string AcceptAttribute_Invalid {
            get {
                return ResourceManager.GetString("AcceptAttribute_Invalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value for &apos;{0}&apos; is required but was not present in the request..
        /// </summary>
        internal static string BindingBehavior_ValueNotFound {
            get {
                return ResourceManager.GetString("BindingBehavior_ValueNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value cannot be null or empty..
        /// </summary>
        internal static string Common_NullOrEmpty {
            get {
                return ResourceManager.GetString("Common_NullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; does not implement the interface &apos;{1}&apos;..
        /// </summary>
        internal static string Common_TypeMustImplementInterface {
            get {
                return ResourceManager.GetString("Common_TypeMustImplementInterface", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;Name&apos; property must be set..
        /// </summary>
        internal static string CommonControls_NameRequired {
            get {
                return ResourceManager.GetString("CommonControls_NameRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} field is not a valid credit card number..
        /// </summary>
        internal static string CreditCardAttribute_Invalid {
            get {
                return ResourceManager.GetString("CreditCardAttribute_Invalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sample Item.
        /// </summary>
        internal static string DropDownList_SampleItem {
            get {
                return ResourceManager.GetString("DropDownList_SampleItem", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DynamicViewDataDictionary only supports single indexers..
        /// </summary>
        internal static string DynamicViewDataDictionary_SingleIndexerOnly {
            get {
                return ResourceManager.GetString("DynamicViewDataDictionary_SingleIndexerOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DynamicViewDataDictionary only supports string-based indexers..
        /// </summary>
        internal static string DynamicViewDataDictionary_StringIndexerOnly {
            get {
                return ResourceManager.GetString("DynamicViewDataDictionary_StringIndexerOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property {0} doesn&apos;t exist. There are no public properties on this object..
        /// </summary>
        internal static string DynamicViewPage_NoProperties {
            get {
                return ResourceManager.GetString("DynamicViewPage_NoProperties", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property {0} doesn&apos;t exist. Supported properties are: {1}..
        /// </summary>
        internal static string DynamicViewPage_PropertyDoesNotExist {
            get {
                return ResourceManager.GetString("DynamicViewPage_PropertyDoesNotExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} field is not a valid e-mail address..
        /// </summary>
        internal static string EmailAddressAttribute_Invalid {
            get {
                return ResourceManager.GetString("EmailAddressAttribute_Invalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The method &apos;{0}&apos; is an asynchronous completion method and cannot be called directly..
        /// </summary>
        internal static string ExpressionHelper_CannotCallCompletedMethod {
            get {
                return ResourceManager.GetString("ExpressionHelper_CannotCallCompletedMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The method &apos;{0}&apos; is marked [NonAction] and cannot be called directly..
        /// </summary>
        internal static string ExpressionHelper_CannotCallNonAction {
            get {
                return ResourceManager.GetString("ExpressionHelper_CannotCallNonAction", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot route to class named &apos;Controller&apos;..
        /// </summary>
        internal static string ExpressionHelper_CannotRouteToController {
            get {
                return ResourceManager.GetString("ExpressionHelper_CannotRouteToController", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expression must be a method call..
        /// </summary>
        internal static string ExpressionHelper_MustBeMethodCall {
            get {
                return ResourceManager.GetString("ExpressionHelper_MustBeMethodCall", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Controller name must end in &apos;Controller&apos;..
        /// </summary>
        internal static string ExpressionHelper_TargetMustEndInController {
            get {
                return ResourceManager.GetString("ExpressionHelper_TargetMustEndInController", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The new model binding system cannot be used when a property whitelist or blacklist has been specified in [Bind] or via the call to UpdateModel() / TryUpdateModel(). Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead..
        /// </summary>
        internal static string ExtensibleModelBinderAdapter_PropertyFilterMustNotBeSet {
            get {
                return ResourceManager.GetString("ExtensibleModelBinderAdapter_PropertyFilterMustNotBeSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} field only accepts files with the following extensions: {1}.
        /// </summary>
        internal static string FileExtensionsAttribute_Invalid {
            get {
                return ResourceManager.GetString("FileExtensionsAttribute_Invalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; is not an open generic type..
        /// </summary>
        internal static string GenericModelBinderProvider_ParameterMustSpecifyOpenGenericType {
            get {
                return ResourceManager.GetString("GenericModelBinderProvider_ParameterMustSpecifyOpenGenericType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The open model type &apos;{0}&apos; has {1} generic type argument(s), but the open binder type &apos;{2}&apos; has {3} generic type argument(s). The binder type must not be an open generic type or must have the same number of generic arguments as the open model type..
        /// </summary>
        internal static string GenericModelBinderProvider_TypeArgumentCountMismatch {
            get {
                return ResourceManager.GetString("GenericModelBinderProvider_TypeArgumentCountMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There is no ViewData item with the key &apos;{0}&apos; of type &apos;{1}&apos;..
        /// </summary>
        internal static string HtmlHelper_MissingSelectData {
            get {
                return ResourceManager.GetString("HtmlHelper_MissingSelectData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ViewData item with the key &apos;{0}&apos; is of type &apos;{1}&apos; but needs to be of type &apos;{2}&apos;..
        /// </summary>
        internal static string HtmlHelper_WrongSelectDataType {
            get {
                return ResourceManager.GetString("HtmlHelper_WrongSelectDataType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value &apos;{0}&apos; is not valid for {1}..
        /// </summary>
        internal static string ModelBinderConfig_ValueInvalid {
            get {
                return ResourceManager.GetString("ModelBinderConfig_ValueInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value is required..
        /// </summary>
        internal static string ModelBinderConfig_ValueRequired {
            get {
                return ResourceManager.GetString("ModelBinderConfig_ValueRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A binder for type {0} could not be located..
        /// </summary>
        internal static string ModelBinderProviderCollection_BinderForTypeNotFound {
            get {
                return ResourceManager.GetString("ModelBinderProviderCollection_BinderForTypeNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; does not subclass {1} or implement the interface {2}..
        /// </summary>
        internal static string ModelBinderProviderCollection_InvalidBinderType {
            get {
                return ResourceManager.GetString("ModelBinderProviderCollection_InvalidBinderType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model of type &apos;{0}&apos; has a [Bind] attribute. The new model binding system cannot be used with models that have type-level [Bind] attributes. Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead..
        /// </summary>
        internal static string ModelBinderProviderCollection_TypeCannotHaveBindAttribute {
            get {
                return ResourceManager.GetString("ModelBinderProviderCollection_TypeCannotHaveBindAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} Object type &apos;{1}&apos;..
        /// </summary>
        internal static string ModelBinderUtil_CannotCreateInstance {
            get {
                return ResourceManager.GetString("ModelBinderUtil_CannotCreateInstance", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context has a null Model, but this binder requires a non-null model of type &apos;{0}&apos;..
        /// </summary>
        internal static string ModelBinderUtil_ModelCannotBeNull {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context has a Model of type &apos;{0}&apos;, but this binder can only operate on models of type &apos;{1}&apos;..
        /// </summary>
        internal static string ModelBinderUtil_ModelInstanceIsWrong {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelInstanceIsWrong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context cannot have a null ModelMetadata..
        /// </summary>
        internal static string ModelBinderUtil_ModelMetadataCannotBeNull {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelMetadataCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context has a ModelType of &apos;{0}&apos;, but this binder can only operate on models of type &apos;{1}&apos;..
        /// </summary>
        internal static string ModelBinderUtil_ModelTypeIsWrong {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelTypeIsWrong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ModelMetadata property must be set before accessing this property..
        /// </summary>
        internal static string ModelBindingContext_ModelMetadataMustBeSet {
            get {
                return ResourceManager.GetString("ModelBindingContext_ModelMetadataMustBeSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deserialization failed. Verify that the data is being deserialized using the same SerializationMode with which it was serialized. Otherwise see the inner exception..
        /// </summary>
        internal static string MvcSerializer_DeserializationFailed {
            get {
                return ResourceManager.GetString("MvcSerializer_DeserializationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error dispatching on controller {0}, conflicting actions matched: {1}..
        /// </summary>
        internal static string ResourceControllerFactory_ConflictingActions {
            get {
                return ResourceManager.GetString("ResourceControllerFactory_ConflictingActions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error dispatching on controller {0}, no actions matched..
        /// </summary>
        internal static string ResourceControllerFactory_NoActions {
            get {
                return ResourceManager.GetString("ResourceControllerFactory_NoActions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Format &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string Resources_UnsupportedFormat {
            get {
                return ResourceManager.GetString("Resources_UnsupportedFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unsupported Media Type: &apos;{0}&apos;..
        /// </summary>
        internal static string Resources_UnsupportedMediaType {
            get {
                return ResourceManager.GetString("Resources_UnsupportedMediaType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} field is not a valid fully-qualified http, https, or ftp URL..
        /// </summary>
        internal static string UrlAttribute_Invalid {
            get {
                return ResourceManager.GetString("UrlAttribute_Invalid", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Properties/MvcResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Common_NullOrEmpty" xml:space="preserve">
    <value>Value cannot be null or empty.</value>
  </data>
  <data name="ExpressionHelper_CannotRouteToController" xml:space="preserve">
    <value>Cannot route to class named 'Controller'.</value>
  </data>
  <data name="ExpressionHelper_MustBeMethodCall" xml:space="preserve">
    <value>Expression must be a method call.</value>
  </data>
  <data name="ExpressionHelper_TargetMustEndInController" xml:space="preserve">
    <value>Controller name must end in 'Controller'.</value>
  </data>
  <data name="HtmlHelper_MissingSelectData" xml:space="preserve">
    <value>There is no ViewData item with the key '{0}' of type '{1}'.</value>
  </data>
  <data name="HtmlHelper_WrongSelectDataType" xml:space="preserve">
    <value>The ViewData item with the key '{0}' is of type '{1}' but needs to be of type '{2}'.</value>
  </data>
  <data name="CommonControls_NameRequired" xml:space="preserve">
    <value>The 'Name' property must be set.</value>
  </data>
  <data name="MvcSerializer_DeserializationFailed" xml:space="preserve">
    <value>Deserialization failed. Verify that the data is being deserialized using the same SerializationMode with which it was serialized. Otherwise see the inner exception.</value>
  </data>
  <data name="Resources_UnsupportedMediaType" xml:space="preserve">
    <value>Unsupported Media Type: '{0}'.</value>
  </data>
  <data name="Resources_UnsupportedFormat" xml:space="preserve">
    <value>Format '{0}' is not supported.</value>
  </data>
  <data name="ExpressionHelper_CannotCallCompletedMethod" xml:space="preserve">
    <value>The method '{0}' is an asynchronous completion method and cannot be called directly.</value>
  </data>
  <data name="ExpressionHelper_CannotCallNonAction" xml:space="preserve">
    <value>The method '{0}' is marked [NonAction] and cannot be called directly.</value>
  </data>
  <data name="ModelBinderUtil_ModelCannotBeNull" xml:space="preserve">
    <value>The binding context has a null Model, but this binder requires a non-null model of type '{0}'.</value>
  </data>
  <data name="ModelBinderUtil_ModelInstanceIsWrong" xml:space="preserve">
    <value>The binding context has a Model of type '{0}', but this binder can only operate on models of type '{1}'.</value>
  </data>
  <data name="ModelBinderUtil_ModelMetadataCannotBeNull" xml:space="preserve">
    <value>The binding context cannot have a null ModelMetadata.</value>
  </data>
  <data name="ModelBinderUtil_ModelTypeIsWrong" xml:space="preserve">
    <value>The binding context has a ModelType of '{0}', but this binder can only operate on models of type '{1}'.</value>
  </data>
  <data name="ModelBinderConfig_ValueInvalid" xml:space="preserve">
    <value>The value '{0}' is not valid for {1}.</value>
  </data>
  <data name="ModelBinderConfig_ValueRequired" xml:space="preserve">
    <value>A value is required.</value>
  </data>
  <data name="ModelBinderProviderCollection_BinderForTypeNotFound" xml:space="preserve">
    <value>A binder for type {0} could not be located.</value>
  </data>
  <data name="ModelBindingContext_ModelMetadataMustBeSet" xml:space="preserve">
    <value>The ModelMetadata property must be set before accessing this property.</value>
  </data>
  <data name="Common_TypeMustImplementInterface" xml:space="preserve">
    <value>The type '{0}' does not implement the interface '{1}'.</value>
  </data>
  <data name="GenericModelBinderProvider_ParameterMustSpecifyOpenGenericType" xml:space="preserve">
    <value>The type '{0}' is not an open generic type.</value>
  </data>
  <data name="GenericModelBinderProvider_TypeArgumentCountMismatch" xml:space="preserve">
    <value>The open model type '{0}' has {1} generic type argument(s), but the open binder type '{2}' has {3} generic type argument(s). The binder type must not be an open generic type or must have the same number of generic arguments as the open model type.</value>
  </data>
  <data name="BindingBehavior_ValueNotFound" xml:space="preserve">
    <value>A value for '{0}' is required but was not present in the request.</value>
  </data>
  <data name="ExtensibleModelBinderAdapter_PropertyFilterMustNotBeSet" xml:space="preserve">
    <value>The new model binding system cannot be used when a property whitelist or blacklist has been specified in [Bind] or via the call to UpdateModel() / TryUpdateModel(). Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead.</value>
  </data>
  <data name="ModelBinderProviderCollection_TypeCannotHaveBindAttribute" xml:space="preserve">
    <value>The model of type '{0}' has a [Bind] attribute. The new model binding system cannot be used with models that have type-level [Bind] attributes. Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead.</value>
  </data>
  <data name="ModelBinderProviderCollection_InvalidBinderType" xml:space="preserve">
    <value>The type '{0}' does not subclass {1} or implement the interface {2}.</value>
  </data>
  <data name="DynamicViewDataDictionary_SingleIndexerOnly" xml:space="preserve">
    <value>DynamicViewDataDictionary only supports single indexers.</value>
  </data>
  <data name="DynamicViewDataDictionary_StringIndexerOnly" xml:space="preserve">
    <value>DynamicViewDataDictionary only supports string-based indexers.</value>
  </data>
  <data name="DynamicViewPage_NoProperties" xml:space="preserve">
    <value>The property {0} doesn't exist. There are no public properties on this object.</value>
  </data>
  <data name="DynamicViewPage_PropertyDoesNotExist" xml:space="preserve">
    <value>The property {0} doesn't exist. Supported properties are: {1}.</value>
  </data>
  <data name="DropDownList_SampleItem" xml:space="preserve">
    <value>Sample Item</value>
  </data>
  <data name="ResourceControllerFactory_ConflictingActions" xml:space="preserve">
    <value>Error dispatching on controller {0}, conflicting actions matched: {1}.</value>
  </data>
  <data name="ResourceControllerFactory_NoActions" xml:space="preserve">
    <value>Error dispatching on controller {0}, no actions matched.</value>
  </data>
  <data name="FileExtensionsAttribute_Invalid" xml:space="preserve">
    <value>The {0} field only accepts files with the following extensions: {1}</value>
  </data>
  <data name="CreditCardAttribute_Invalid" xml:space="preserve">
    <value>The {0} field is not a valid credit card number.</value>
  </data>
  <data name="EmailAddressAttribute_Invalid" xml:space="preserve">
    <value>The {0} field is not a valid e-mail address.</value>
  </data>
  <data name="UrlAttribute_Invalid" xml:space="preserve">
    <value>The {0} field is not a valid fully-qualified http, https, or ftp URL.</value>
  </data>
  <data name="AcceptAttribute_Invalid" xml:space="preserve">
    <value>The {0} field only accepts files with one of the following content types: {1}.</value>
  </data>
  <data name="ModelBinderUtil_CannotCreateInstance" xml:space="preserve">
    <value>{0} Object type '{1}'.</value>
  </data>
</root>

================================================
FILE: src/Microsoft.Web.Mvc/RadioExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    public static class RadioListExtensions
    {
        public static MvcHtmlString[] RadioButtonList(this HtmlHelper htmlHelper, string name)
        {
            return RadioButtonList(htmlHelper, name, (IDictionary<string, object>)null);
        }

        public static MvcHtmlString[] RadioButtonList(this HtmlHelper htmlHelper, string name, object htmlAttributes)
        {
            return RadioButtonList(htmlHelper, name, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString[] RadioButtonList(this HtmlHelper htmlHelper, string name, IDictionary<string, object> htmlAttributes)
        {
            IEnumerable<SelectListItem> selectList = htmlHelper.GetSelectData(name);
            return htmlHelper.RadioButtonListInternal(name, selectList, true /* usedViewData */, htmlAttributes);
        }

        public static MvcHtmlString[] RadioButtonList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList)
        {
            return RadioButtonList(htmlHelper, name, selectList, null);
        }

        public static MvcHtmlString[] RadioButtonList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return RadioButtonList(htmlHelper, name, selectList, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString[] RadioButtonList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            return htmlHelper.RadioButtonListInternal(name, selectList, false /* usedViewData */, htmlAttributes);
        }

        private static IEnumerable<SelectListItem> GetSelectData(this HtmlHelper htmlHelper, string name)
        {
            object o = null;
            if (htmlHelper.ViewData != null)
            {
                o = htmlHelper.ViewData.Eval(name);
            }
            if (o == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.HtmlHelper_MissingSelectData,
                        name,
                        typeof(IEnumerable<SelectListItem>)));
            }
            IEnumerable<SelectListItem> selectList = o as IEnumerable<SelectListItem>;
            if (selectList == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.HtmlHelper_WrongSelectDataType,
                        name,
                        o.GetType().FullName,
                        typeof(IEnumerable<SelectListItem>)));
            }
            return selectList;
        }

        private static MvcHtmlString[] RadioButtonListInternal(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, bool usedViewData, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
            }
            if (selectList == null)
            {
                throw new ArgumentNullException("selectList");
            }

            // If we haven't already used ViewData to get the entire list of items then we need to
            // use the ViewData-supplied value before using the parameter-supplied value.
            if (!usedViewData)
            {
                object defaultValue = htmlHelper.ViewData.Eval(name);

                if (defaultValue != null)
                {
                    IEnumerable defaultValues = new[] { defaultValue };
                    IEnumerable<string> values = from object value in defaultValues
                                                 select Convert.ToString(value, CultureInfo.CurrentCulture);
                    HashSet<string> selectedValues = new HashSet<string>(values, StringComparer.OrdinalIgnoreCase);
                    List<SelectListItem> newSelectList = new List<SelectListItem>();

                    foreach (SelectListItem item in selectList)
                    {
                        item.Selected = (item.Value != null) ? selectedValues.Contains(item.Value) : selectedValues.Contains(item.Text);
                        newSelectList.Add(item);
                    }

                    selectList = newSelectList;
                }
            }

            IEnumerable<MvcHtmlString> radioButtons = selectList.Select(item => htmlHelper.RadioButton(name, item.Value, item.Selected, htmlAttributes));

            return radioButtons.ToArray();
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ReaderWriterCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Threading;

namespace Microsoft.Web.Mvc
{
    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Instances of this type are meant to be singletons.")]
    internal abstract class ReaderWriterCache<TKey, TValue>
    {
        private readonly Dictionary<TKey, TValue> _cache;
        private readonly ReaderWriterLockSlim _readerWriterLock = new ReaderWriterLockSlim();

        protected ReaderWriterCache()
            : this(null)
        {
        }

        protected ReaderWriterCache(IEqualityComparer<TKey> comparer)
        {
            _cache = new Dictionary<TKey, TValue>(comparer);
        }

        protected Dictionary<TKey, TValue> Cache
        {
            get { return _cache; }
        }

        protected TValue FetchOrCreateItem(TKey key, Func<TValue> creator)
        {
            // first, see if the item already exists in the cache
            _readerWriterLock.EnterReadLock();
            try
            {
                TValue existingEntry;
                if (_cache.TryGetValue(key, out existingEntry))
                {
                    return existingEntry;
                }
            }
            finally
            {
                _readerWriterLock.ExitReadLock();
            }

            // insert the new item into the cache
            TValue newEntry = creator();
            _readerWriterLock.EnterWriteLock();
            try
            {
                TValue existingEntry;
                if (_cache.TryGetValue(key, out existingEntry))
                {
                    // another thread already inserted an item, so use that one
                    return existingEntry;
                }

                _cache[key] = newEntry;
                return newEntry;
            }
            finally
            {
                _readerWriterLock.ExitWriteLock();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/ActionType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// This enum is used by the UrlHelper extension methods to create links within resource controllers
    /// </summary>
    public enum ActionType
    {
        Create,
        GetCreateForm,
        Index,
        Retrieve,
        Update,
        GetUpdateForm,
        Delete,
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/AjaxHelperExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using System.Web.Mvc.Ajax;
using System.Web.Mvc.Html;

namespace Microsoft.Web.Mvc.Resources
{
    public static class AjaxHelperExtensions
    {
        /// <summary>
        /// Generates the Form preamble, defaulting the link for the Retrieve action
        /// </summary>
        /// <param name="ajax"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <param name="ajaxOptions"></param>
        /// <returns></returns>
        public static MvcForm BeginResourceForm(this AjaxHelper ajax, string controllerName, object routeValues, AjaxOptions ajaxOptions)
        {
            return ajax.BeginResourceForm(controllerName, routeValues, ajaxOptions, ActionType.Retrieve);
        }

        /// <summary>
        /// Generates the Form preamble
        /// </summary>
        /// <param name="ajax"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <param name="ajaxOptions"></param>
        /// <param name="actionType"></param>
        /// <returns></returns>
        public static MvcForm BeginResourceForm(this AjaxHelper ajax, string controllerName, object routeValues, AjaxOptions ajaxOptions, ActionType actionType)
        {
            switch (actionType)
            {
                case ActionType.GetUpdateForm:
                    return ajax.BeginRouteForm(controllerName + "-editForm", routeValues, ajaxOptions);
                case ActionType.GetCreateForm:
                    return ajax.BeginRouteForm(controllerName + "-createForm", ajaxOptions);
                case ActionType.Retrieve:
                case ActionType.Delete:
                case ActionType.Update:
                    // can we use ajaxOptions to either add the header?
                    MvcForm form = ajax.BeginRouteForm(controllerName, routeValues, ajaxOptions);
                    return form;
                case ActionType.Create:
                    return ajax.BeginRouteForm(controllerName + "-create", ajaxOptions);
                case ActionType.Index:
                    return ajax.BeginRouteForm(controllerName + "-index", ajaxOptions);
                default:
                    throw new ArgumentOutOfRangeException("actionType");
            }
        }

        /// <summary>
        /// Generates a link to the resource controller, defaulting to the Retrieve action
        /// </summary>
        /// <param name="ajax"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <param name="ajaxOptions"></param>
        /// <returns></returns>
        public static MvcHtmlString ResourceLink(this AjaxHelper ajax, string controllerName, object routeValues, AjaxOptions ajaxOptions)
        {
            return ajax.ResourceLink(controllerName, controllerName, routeValues, ajaxOptions, ActionType.Retrieve);
        }

        /// <summary>
        /// Generates a link to the resource controller, defaulting to the Retrieve action
        /// </summary>
        /// <param name="ajax"></param>
        /// <param name="controllerName"></param>
        /// <param name="linkText"></param>
        /// <param name="routeValues"></param>
        /// <param name="ajaxOptions"></param>
        /// <returns></returns>
        public static MvcHtmlString ResourceLink(this AjaxHelper ajax, string controllerName, string linkText, object routeValues, AjaxOptions ajaxOptions)
        {
            return ajax.ResourceLink(linkText, controllerName, routeValues, ajaxOptions, ActionType.Retrieve);
        }

        /// <summary>
        /// Generates a link to the resource controller
        /// </summary>
        /// <param name="ajax"></param>
        /// <param name="controllerName"></param>
        /// <param name="linkText"></param>
        /// <param name="routeValues"></param>
        /// <param name="ajaxOptions"></param>
        /// <param name="actionType"></param>
        /// <returns></returns>
        public static MvcHtmlString ResourceLink(this AjaxHelper ajax, string controllerName, string linkText, object routeValues, AjaxOptions ajaxOptions, ActionType actionType)
        {
            switch (actionType)
            {
                case ActionType.GetUpdateForm:
                    return ajax.RouteLink(linkText, controllerName + "-editForm", routeValues, ajaxOptions);
                case ActionType.GetCreateForm:
                    return ajax.RouteLink(linkText, controllerName + "-createForm", ajaxOptions);
                case ActionType.Retrieve:
                case ActionType.Delete:
                case ActionType.Update:
                    return ajax.RouteLink(linkText, controllerName, routeValues, ajaxOptions);
                case ActionType.Create:
                    return ajax.RouteLink(linkText, controllerName + "-create", ajaxOptions);
                case ActionType.Index:
                    return ajax.RouteLink(linkText, controllerName + "-index", ajaxOptions);
                default:
                    throw new ArgumentOutOfRangeException("actionType");
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/AtomEntryActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.ServiceModel.Syndication;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Xml;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// An ActionResult that can render a SyndicationItem to the Atom 1.0 entry format
    /// </summary>
    public class AtomEntryActionResult : ActionResult
    {
        private ContentType contentType;
        private SyndicationItem item;

        /// <summary>
        /// The content type defaults to application/atom+xml; type=entry
        /// </summary>
        /// <param name="item"></param>
        public AtomEntryActionResult(SyndicationItem item)
            : this(item, new ContentType("application/atom+xml;type=entry"))
        {
        }

        public AtomEntryActionResult(SyndicationItem item, ContentType contentType)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            if (contentType == null)
            {
                throw new ArgumentNullException("contentType");
            }
            this.item = item;
            this.contentType = contentType;
        }

        public ContentType ContentType
        {
            get { return this.contentType; }
        }

        public SyndicationItem Item
        {
            get { return this.item; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            Encoding encoding = Encoding.UTF8;
            if (!String.IsNullOrEmpty(this.ContentType.CharSet))
            {
                try
                {
                    encoding = Encoding.GetEncoding(this.ContentType.CharSet);
                }
                catch (ArgumentException)
                {
                    throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, this.ContentType));
                }
            }
            XmlWriterSettings settings = new XmlWriterSettings { Encoding = encoding };
            this.ContentType.CharSet = settings.Encoding.HeaderName;
            context.HttpContext.Response.ContentType = this.ContentType.ToString();
            using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.OutputStream, settings))
            {
                this.Item.GetAtom10Formatter().WriteTo(writer);
                writer.Flush();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/AtomFeedActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.ServiceModel.Syndication;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Xml;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// An ActionResult that can render a SyndicationFeed to the Atom 1.0 feed format
    /// </summary>
    public class AtomFeedActionResult : ActionResult
    {
        private ContentType contentType;
        private SyndicationFeed feed;

        /// <summary>
        /// The content type defaults to application/atom+xml
        /// </summary>
        /// <param name="feed"></param>
        public AtomFeedActionResult(SyndicationFeed feed)
            : this(feed, new ContentType("application/atom+xml"))
        {
        }

        public AtomFeedActionResult(SyndicationFeed feed, ContentType contentType)
        {
            if (feed == null)
            {
                throw new ArgumentNullException("feed");
            }
            if (contentType == null)
            {
                throw new ArgumentNullException("contentType");
            }
            this.feed = feed;
            this.contentType = contentType;
        }

        public ContentType ContentType
        {
            get { return this.contentType; }
        }

        public SyndicationFeed Feed
        {
            get { return this.feed; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            Encoding encoding = Encoding.UTF8;
            if (!String.IsNullOrEmpty(this.ContentType.CharSet))
            {
                try
                {
                    encoding = Encoding.GetEncoding(this.ContentType.CharSet);
                }
                catch (ArgumentException)
                {
                    throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, this.ContentType));
                }
            }
            XmlWriterSettings settings = new XmlWriterSettings { Encoding = encoding };
            this.ContentType.CharSet = settings.Encoding.HeaderName;
            context.HttpContext.Response.ContentType = this.ContentType.ToString();
            using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.OutputStream, settings))
            {
                this.Feed.GetAtom10Formatter().WriteTo(writer);
                writer.Flush();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/AtomServiceDocumentActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.ServiceModel.Syndication;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Xml;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// An ActionResult that can render a ServiceDocument to the Atom 1.0 ServiceDocument format
    /// </summary>
    public class AtomServiceDocumentActionResult : ActionResult
    {
        private ContentType contentType;
        private ServiceDocument document;

        /// <summary>
        /// The content type defaults to application/atomsvc+xml
        /// </summary>
        /// <param name="document"></param>
        public AtomServiceDocumentActionResult(ServiceDocument document)
            : this(document, new ContentType("application/atomsvc+xml"))
        {
        }

        public AtomServiceDocumentActionResult(ServiceDocument document, ContentType contentType)
        {
            if (document == null)
            {
                throw new ArgumentNullException("document");
            }
            if (contentType == null)
            {
                throw new ArgumentNullException("contentType");
            }
            this.document = document;
            this.contentType = contentType;
        }

        public ContentType ContentType
        {
            get { return this.contentType; }
        }

        public ServiceDocument Document
        {
            get { return this.document; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            Encoding encoding = Encoding.UTF8;
            if (!String.IsNullOrEmpty(this.ContentType.CharSet))
            {
                try
                {
                    encoding = Encoding.GetEncoding(this.ContentType.CharSet);
                }
                catch (ArgumentException)
                {
                    throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, this.ContentType));
                }
            }
            XmlWriterSettings settings = new XmlWriterSettings { Encoding = encoding };
            this.ContentType.CharSet = settings.Encoding.HeaderName;
            context.HttpContext.Response.ContentType = this.ContentType.ToString();
            using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.OutputStream, settings))
            {
                this.Document.GetFormatter().WriteTo(writer);
                writer.Flush();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/DataContractJsonActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Xml;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// An ActionResult that can render an object to the json format using the DataContractJsonSerializer
    /// </summary>
    public class DataContractJsonActionResult : ActionResult
    {
        private ContentType contentType;
        private object data;

        /// <summary>
        /// The default content type is application/json
        /// </summary>
        /// <param name="data"></param>
        public DataContractJsonActionResult(object data)
            : this(data, new ContentType("application/json"))
        {
        }

        public DataContractJsonActionResult(object data, ContentType contentType)
        {
            this.data = data;
            this.contentType = contentType;
        }

        public ContentType ContentType
        {
            get { return this.contentType; }
        }

        public object Data
        {
            get { return this.data; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            Encoding encoding = Encoding.UTF8;
            if (!String.IsNullOrEmpty(this.ContentType.CharSet))
            {
                try
                {
                    encoding = Encoding.GetEncoding(this.ContentType.CharSet);
                }
                catch (ArgumentException)
                {
                    throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, this.ContentType));
                }
            }
            DataContractJsonSerializer dcs = new DataContractJsonSerializer(this.Data.GetType());
            this.ContentType.CharSet = encoding.HeaderName;
            context.HttpContext.Response.ContentType = this.ContentType.ToString();
            using (XmlWriter writer = JsonReaderWriterFactory.CreateJsonWriter(context.HttpContext.Response.OutputStream, encoding))
            {
                dcs.WriteObject(writer, this.Data);
                writer.Flush();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/DataContractXmlActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.Runtime.Serialization;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Xml;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// An ActionResult that can render an object to the xml format using the DataContractSerializer
    /// </summary>
    public class DataContractXmlActionResult : ActionResult
    {
        private ContentType contentType;
        private object data;

        /// <summary>
        /// The content type of the response defaults to application/xml
        /// </summary>
        public DataContractXmlActionResult(object data)
            : this(data, new ContentType("application/xml"))
        {
        }

        public DataContractXmlActionResult(object data, ContentType contentType)
        {
            this.data = data;
            this.contentType = contentType;
        }

        public ContentType ContentType
        {
            get { return this.contentType; }
        }

        public object Data
        {
            get { return this.data; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            Encoding encoding = Encoding.UTF8;
            if (!String.IsNullOrEmpty(this.ContentType.CharSet))
            {
                try
                {
                    encoding = Encoding.GetEncoding(this.ContentType.CharSet);
                }
                catch (ArgumentException)
                {
                    throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, this.ContentType));
                }
            }
            XmlWriterSettings settings = new XmlWriterSettings { Encoding = encoding };
            DataContractSerializer dcs = new DataContractSerializer(this.Data.GetType());
            this.ContentType.CharSet = settings.Encoding.HeaderName;
            context.HttpContext.Response.ContentType = this.ContentType.ToString();
            using (XmlWriter writer = XmlWriter.Create(context.HttpContext.Response.OutputStream, settings))
            {
                dcs.WriteObject(writer, this.Data);
                writer.Flush();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/DefaultFormatHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Default implementation of FormatHelper
    /// The results for GetRequestFormat() and GetResponseFormats() are cached on the HttpContext.Items dictionary:
    /// HttpContext.Items["requestFormat"]
    /// HttpContext.Items["responseFormat"]
    /// </summary>
    public class DefaultFormatHelper : FormatHelper
    {
        private const string FormatVariableName = "format";
        private const string QualityFactor = "q";

        public const string RequestFormatKey = "requestFormat";
        public const string ResponseFormatKey = "responseFormat";

        /// <summary>
        /// Returns the format of a given request, according to the following
        /// rules:
        /// 1. If a Content-Type header exists it returns a ContentType for it or fails if one can't be created
        /// 2. Otherwie, if a Content-Type header does not exists it provides the default ContentType of "application/octet-stream" (per RFC 2616 7.2.1)
        /// </summary>
        /// <param name="requestContext">The request.</param>
        /// <returns>The format of the request.</returns>
        /// <exception cref="HttpException">If the format is unrecognized or not supported.</exception>
        public override ContentType GetRequestFormat(RequestContext requestContext)
        {
            ContentType result;
            if (!requestContext.HttpContext.Items.Contains(RequestFormatKey))
            {
                result = GetRequestFormat(requestContext.HttpContext.Request, true);
                requestContext.HttpContext.Items.Add(RequestFormatKey, result);
            }
            else
            {
                result = (ContentType)requestContext.HttpContext.Items[RequestFormatKey];
            }
            return result;
        }

        internal static ContentType GetRequestFormat(HttpRequestBase request, bool throwOnError)
        {
            if (!String.IsNullOrEmpty(request.ContentType))
            {
                ContentType contentType = ParseContentType(request.ContentType);
                if (contentType != null)
                {
                    return contentType;
                }
                if (throwOnError)
                {
                    throw new HttpException((int)HttpStatusCode.UnsupportedMediaType, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedMediaType, request.ContentType));
                }
                return null;
            }
            return new ContentType();
        }

        /// <summary>
        /// Returns the preferred content type to use for the response, based on the request, according to the following
        /// rules:
        /// 1. If the RouteData contains a value for a key called "format", its value is returned as the content type
        /// 2. Otherwise, if the query string contains a key called "format", its value is returned as the content type
        /// 3. Otherwise, if the request has an Accepts header, the list of content types in order of preference is returned
        /// 4. Otherwise, if the request has a content type, its value is returned
        /// </summary>
        /// <param name="requestContext">The request.</param>
        /// <returns>The formats to use for rendering a response.</returns>
        public override IEnumerable<ContentType> GetResponseFormats(RequestContext requestContext)
        {
            IEnumerable<ContentType> result;
            if (!requestContext.HttpContext.Items.Contains(ResponseFormatKey))
            {
                result = GetResponseFormatsRouteAware(requestContext);
                requestContext.HttpContext.Items.Add(ResponseFormatKey, result);
            }
            else
            {
                result = (IEnumerable<ContentType>)requestContext.HttpContext.Items[ResponseFormatKey];
            }
            return result;
        }

        private static List<ContentType> GetResponseFormatsRouteAware(RequestContext requestContext)
        {
            List<ContentType> result = GetResponseFormatsCore(requestContext.HttpContext.Request);
            ContentType contentType;
            if (result == null)
            {
                contentType = FormatManager.Current.FormatHelper.GetRequestFormat(requestContext);
                result = new List<ContentType>(new[] { contentType });
            }
            if (TryGetFromRouteData(requestContext.RouteData, out contentType))
            {
                result.Insert(0, contentType);
            }
            return result;
        }

        /// <summary>
        /// Returns the preferred content type to use for the response, based on the request, according to the following
        /// rules:
        /// 1. If the query string contains a key called "format", its value is returned as the content type
        /// 2. Otherwise, if the request has an Accepts header, the list of content types in order of preference is returned
        /// 3. Otherwise, if the request has a content type, its value is returned
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        internal static List<ContentType> GetResponseFormats(HttpRequestBase request)
        {
            List<ContentType> result = GetResponseFormatsCore(request);
            if (result == null)
            {
                ContentType contentType = GetRequestFormat(request, true);
                result = new List<ContentType>(new[] { contentType });
            }
            return result;
        }

        private static List<ContentType> GetResponseFormatsCore(HttpRequestBase request)
        {
            ContentType contentType;
            if (TryGetFromUri(request, out contentType))
            {
                return new List<ContentType>(new[] { contentType });
            }
            string[] accepts = request.AcceptTypes;
            if (accepts != null && accepts.Length > 0)
            {
                return GetAcceptHeaderElements(accepts);
            }
            return null;
        }

        // CONSIDER: we currently don't process the Accept-Charset header, need to take it into account, EG:
        // Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
        private static List<ContentType> GetAcceptHeaderElements(string[] acceptHeaderElements)
        {
            List<ContentType> contentTypeList = new List<ContentType>(acceptHeaderElements.Length);
            foreach (string acceptHeaderElement in acceptHeaderElements)
            {
                if (acceptHeaderElement != null)
                {
                    ContentType contentType = ParseContentType(acceptHeaderElement);
                    // ignore unknown formats to allow fallback
                    if (contentType != null)
                    {
                        contentTypeList.Add(contentType);
                    }
                }
            }
            contentTypeList.Sort(new AcceptHeaderElementComparer());
            // CONSIDER: we used the "q" parameter for sorting, so now we strip it
            // it might be ebtter to strip it later in case someone needs to access it
            foreach (ContentType ct in contentTypeList)
            {
                if (ct.Parameters.ContainsKey(QualityFactor))
                {
                    ct.Parameters.Remove(QualityFactor);
                }
            }
            return contentTypeList;
        }

        public override bool IsBrowserRequest(RequestContext requestContext)
        {
            return IsBrowserRequest(requestContext.HttpContext.Request);
        }

        // Parses a string into a ContentType instance, supports
        // friendly names and enforces a charset (which defaults to utf-8)
        internal static ContentType ParseContentType(string contentTypeString)
        {
            ContentType contentType = null;
            try
            {
                contentType = new ContentType(contentTypeString);
            }
            catch (FormatException)
            {
                // This may be a friendly name (for example, "xml" instead of "text/xml").
                // if so, try mapping to a content type
                if (!FormatManager.Current.TryMapFormatFriendlyName(contentTypeString, out contentType))
                {
                    return null;
                }
            }
            Encoding encoding = Encoding.UTF8;
            if (!String.IsNullOrEmpty(contentType.CharSet))
            {
                try
                {
                    encoding = Encoding.GetEncoding(contentType.CharSet);
                }
                catch (ArgumentException)
                {
                    return null;
                }
            }
            contentType.CharSet = encoding.HeaderName;
            return contentType;
        }

        // Route-based format override so clients can use a route variable
        private static bool TryGetFromRouteData(RouteData routeData, out ContentType contentType)
        {
            contentType = null;
            if (routeData != null)
            {
                string fromRouteData = routeData.Values[FormatVariableName] as string;
                if (!String.IsNullOrEmpty(fromRouteData))
                {
                    contentType = ParseContentType(fromRouteData);
                }
            }
            return contentType != null;
        }

        // Uri-based format override so clients can use a query string
        // also useful when using the browser where you can't set headerss
        private static bool TryGetFromUri(HttpRequestBase request, out ContentType contentType)
        {
            string fromParams = request.QueryString[FormatVariableName];
            if (fromParams != null)
            {
                contentType = ParseContentType(fromParams);
                if (contentType != null)
                {
                    return true;
                }
            }
            contentType = null;
            return false;
        }

        /// <summary>
        /// Determines whether the specified HTTP request was sent by a Browser.
        /// A request is considered to be from the browser if:
        /// it's a GET or POST
        /// and does not have a non-HTML entity format (XML/JSON)
        /// and has a known User-Agent header (as determined by the request's BrowserCapabilities property),
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>true if the specified HTTP request is a Browser request; otherwise, false.</returns>
        internal static bool IsBrowserRequest(HttpRequestBase request)
        {
            if (!request.IsHttpMethod(HttpVerbs.Get) && !request.IsHttpMethod(HttpVerbs.Post))
            {
                return false;
            }
            ContentType requestFormat = GetRequestFormat(request, false);
            if (requestFormat == null || String.Compare(requestFormat.MediaType, FormatManager.UrlEncoded, StringComparison.OrdinalIgnoreCase) != 0)
            {
                if (FormatManager.Current.CanDeserialize(requestFormat))
                {
                    return false;
                }
            }
            HttpBrowserCapabilitiesBase browserCapabilities = request.Browser;
            if (browserCapabilities != null && !String.IsNullOrEmpty(request.Browser.Browser) && request.Browser.Browser != "Unknown")
            {
                return true;
            }
            return false;
        }

        private class AcceptHeaderElementComparer : IComparer<ContentType>
        {
            [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "x, y",
                Justification = "No need to fix this since this is a private class.")]
            public int Compare(ContentType x, ContentType y)
            {
                string[] xTypeSubType = x.MediaType.Split('/');
                string[] yTypeSubType = y.MediaType.Split('/');

                if (String.Equals(xTypeSubType[0], yTypeSubType[0], StringComparison.OrdinalIgnoreCase))
                {
                    if (String.Equals(xTypeSubType[1], yTypeSubType[1], StringComparison.OrdinalIgnoreCase))
                    {
                        // need to check the number of parameters to determine which is more specific
                        bool xHasParam = HasParameters(x);
                        bool yHasParam = HasParameters(y);
                        if (xHasParam && !yHasParam)
                        {
                            return 1;
                        }
                        else if (!xHasParam && yHasParam)
                        {
                            return -1;
                        }
                    }
                    else
                    {
                        if (xTypeSubType[1][0] == '*' && xTypeSubType[1].Length == 1)
                        {
                            return 1;
                        }
                        if (yTypeSubType[1][0] == '*' && yTypeSubType[1].Length == 1)
                        {
                            return -1;
                        }
                    }
                }
                else if (xTypeSubType[0][0] == '*' && xTypeSubType[0].Length == 1)
                {
                    return 1;
                }
                else if (yTypeSubType[0][0] == '*' && yTypeSubType[0].Length == 1)
                {
                    return -1;
                }

                decimal qualityDifference = GetQualityFactor(x) - GetQualityFactor(y);
                if (qualityDifference < 0)
                {
                    return 1;
                }
                else if (qualityDifference > 0)
                {
                    return -1;
                }
                return 0;
            }

            private static decimal GetQualityFactor(ContentType contentType)
            {
                decimal result;
                foreach (string key in contentType.Parameters.Keys)
                {
                    if (String.Equals(QualityFactor, key, StringComparison.OrdinalIgnoreCase))
                    {
                        if (Decimal.TryParse(contentType.Parameters[key], NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out result) &&
                            (result <= (decimal)1.0))
                        {
                            return result;
                        }
                    }
                }

                return (decimal)1.0;
            }

            private static bool HasParameters(ContentType contentType)
            {
                int number = 0;
                foreach (string param in contentType.Parameters.Keys)
                {
                    if (!String.Equals(QualityFactor, param, StringComparison.OrdinalIgnoreCase))
                    {
                        number++;
                    }
                }

                return (number > 0);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/DefaultFormatManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Web.Mvc.Resources
{
    public class DefaultFormatManager : FormatManager
    {
        public DefaultFormatManager()
        {
            XmlFormatHandler xmlHandler = new XmlFormatHandler();
            JsonFormatHandler jsonHandler = new JsonFormatHandler();
            this.RequestFormatHandlers.Add(xmlHandler);
            this.RequestFormatHandlers.Add(jsonHandler);
            this.ResponseFormatHandlers.Add(xmlHandler);
            this.ResponseFormatHandlers.Add(jsonHandler);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/FormatHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Mime;
using System.Web;
using System.Web.Routing;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Base class for content negotiation support
    /// </summary>
    public abstract class FormatHelper
    {
        /// <summary>
        /// Returns the ContentType of a given request.
        /// </summary>
        /// <param name="requestContext">The request.</param>
        /// <returns>The format of the request.</returns>
        /// <exception cref="HttpException">If the format is unrecognized or not supported.</exception>
        public abstract ContentType GetRequestFormat(RequestContext requestContext);

        /// <summary>
        /// Returns a collection of ContentType instances that can be used to render a response to a given request, sorted in priority order.
        /// </summary>
        /// <param name="requestContext">The request.</param>
        /// <returns>The formats to use for rendering a response.</returns>
        public abstract IEnumerable<ContentType> GetResponseFormats(RequestContext requestContext);

        /// <summary>
        /// Determines whether the specified HTTP request was sent by a Browser.
        /// </summary>
        /// <param name="requestContext">The request.</param>
        /// <returns></returns>
        public abstract bool IsBrowserRequest(RequestContext requestContext);
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/FormatManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Net.Mime;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Class that maintains a registration of handlers for
    /// request and response formats
    /// </summary>
    public class FormatManager
    {
        public const string UrlEncoded = "application/x-www-form-urlencoded";

        private static FormatManager _current = new DefaultFormatManager();

        private Collection<IRequestFormatHandler> _requestHandlers;
        private Collection<IResponseFormatHandler> _responseHandlers;
        private FormatHelper _formatHelper;

        public FormatManager()
        {
            this._requestHandlers = new Collection<IRequestFormatHandler>();
            this._responseHandlers = new Collection<IResponseFormatHandler>();
            this._formatHelper = new DefaultFormatHelper();
        }

        /// <summary>
        /// The list of handlers that can parse the request body
        /// </summary>
        public Collection<IRequestFormatHandler> RequestFormatHandlers
        {
            get { return this._requestHandlers; }
        }

        /// <summary>
        /// The list of handlers that can serialize the response body
        /// </summary>
        public Collection<IResponseFormatHandler> ResponseFormatHandlers
        {
            get { return this._responseHandlers; }
        }

        public static FormatManager Current
        {
            get { return _current; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                _current = value;
            }
        }

        // CONSIDER: the FormatHelper is an abstraction that lets users extend the content negotiation process
        // we must reconsider the FormatManager/FormatHelper factoring and provide a cleaner way of allowing this same extensibility
        public FormatHelper FormatHelper
        {
            get { return _formatHelper; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                _formatHelper = value;
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1007:UseGenericsWhereAppropriate", Justification = "This is an existing API; this would be a breaking change")]
        public bool TryDeserialize(ControllerContext controllerContext, ModelBindingContext bindingContext, ContentType requestFormat, out object model)
        {
            for (int i = 0; i < this.RequestFormatHandlers.Count; ++i)
            {
                if (this.RequestFormatHandlers[i].CanDeserialize(requestFormat))
                {
                    model = this.RequestFormatHandlers[i].Deserialize(controllerContext, bindingContext, requestFormat);
                    return true;
                }
            }
            model = null;
            return false;
        }

        public bool CanDeserialize(ContentType contentType)
        {
            for (int i = 0; i < this.RequestFormatHandlers.Count; ++i)
            {
                if (this.RequestFormatHandlers[i].CanDeserialize(contentType))
                {
                    return true;
                }
            }
            return false;
        }

        public bool CanSerialize(ContentType responseFormat)
        {
            for (int i = 0; i < this.ResponseFormatHandlers.Count; ++i)
            {
                if (this.ResponseFormatHandlers[i].CanSerialize(responseFormat))
                {
                    return true;
                }
            }
            return false;
        }

        public void Serialize(ControllerContext context, object model, ContentType responseFormat)
        {
            for (int i = 0; i < this.ResponseFormatHandlers.Count; ++i)
            {
                if (this.ResponseFormatHandlers[i].CanSerialize(responseFormat))
                {
                    this.ResponseFormatHandlers[i].Serialize(context, model, responseFormat);
                    return;
                }
            }
            throw new NotSupportedException();
        }

        public bool TryMapFormatFriendlyName(string formatName, out ContentType contentType)
        {
            for (int i = 0; i < this.ResponseFormatHandlers.Count; ++i)
            {
                if (this.ResponseFormatHandlers[i].TryMapFormatFriendlyName(formatName, out contentType))
                {
                    return true;
                }
            }
            contentType = null;
            return false;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/HtmlHelperExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using System.Web.Mvc.Html;

namespace Microsoft.Web.Mvc.Resources
{
    public static class HtmlHelperExtensions
    {
        /// <summary>
        /// Generates the Form preamble, defaulting the link for the Retrieve action
        /// </summary>
        /// <param name="html"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <returns></returns>
        public static MvcForm BeginResourceForm(this HtmlHelper html, string controllerName, object routeValues)
        {
            return html.BeginResourceForm(controllerName, routeValues, ActionType.Retrieve);
        }

        /// <summary>
        /// Generates the Form preamble
        /// </summary>
        /// <param name="html"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <param name="actionType"></param>
        /// <returns></returns>
        public static MvcForm BeginResourceForm(this HtmlHelper html, string controllerName, object routeValues, ActionType actionType)
        {
            return html.BeginResourceForm(controllerName, routeValues, null, actionType);
        }

        /// <summary>
        /// Generates the Form preamble
        /// </summary>
        /// <param name="html"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <param name="htmlAttributes"></param>
        /// <param name="actionType"></param>
        /// <returns></returns>
        public static MvcForm BeginResourceForm(this HtmlHelper html, string controllerName, object routeValues, object htmlAttributes, ActionType actionType)
        {
            switch (actionType)
            {
                case ActionType.GetUpdateForm:
                    return html.BeginRouteForm(controllerName + "-editForm", routeValues, FormMethod.Post, htmlAttributes);
                case ActionType.GetCreateForm:
                    return html.BeginRouteForm(controllerName + "-createForm", FormMethod.Post, htmlAttributes);
                case ActionType.Retrieve:
                case ActionType.Delete:
                case ActionType.Update:
                    return html.BeginRouteForm(controllerName, routeValues, FormMethod.Post, htmlAttributes);
                case ActionType.Create:
                    return html.BeginRouteForm(controllerName + "-create", FormMethod.Post, htmlAttributes);
                case ActionType.Index:
                    return html.BeginRouteForm(controllerName + "-index", FormMethod.Post, htmlAttributes);
                default:
                    throw new ArgumentOutOfRangeException("actionType");
            }
        }

        /// <summary>
        /// Generates a link to the resource controller, defaulting to the Retrieve action
        /// </summary>
        /// <param name="html"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <returns></returns>
        public static MvcHtmlString ResourceLink(this HtmlHelper html, string controllerName, object routeValues)
        {
            return html.ResourceLink(controllerName, controllerName, routeValues, ActionType.Retrieve);
        }

        /// <summary>
        /// Generates a link to the resource controller, defaulting to the Retrieve action
        /// </summary>
        /// <param name="html"></param>
        /// <param name="controllerName"></param>
        /// <param name="linkText"></param>
        /// <param name="routeValues"></param>
        /// <returns></returns>
        public static MvcHtmlString ResourceLink(this HtmlHelper html, string controllerName, string linkText, object routeValues)
        {
            return html.ResourceLink(controllerName, linkText, routeValues, ActionType.Retrieve);
        }

        /// <summary>
        /// Generates a link to the resource controller
        /// </summary>
        /// <param name="html"></param>
        /// <param name="controllerName"></param>
        /// <param name="linkText"></param>
        /// <param name="routeValues"></param>
        /// <param name="actionType"></param>
        /// <returns></returns>
        public static MvcHtmlString ResourceLink(this HtmlHelper html, string controllerName, string linkText, object routeValues, ActionType actionType)
        {
            switch (actionType)
            {
                case ActionType.GetUpdateForm:
                    return html.RouteLink(linkText, controllerName + "-editForm", routeValues);
                case ActionType.GetCreateForm:
                    return html.RouteLink(linkText, controllerName + "-createForm", routeValues);
                case ActionType.Retrieve:
                case ActionType.Delete:
                case ActionType.Update:
                    return html.RouteLink(linkText, controllerName, routeValues);
                case ActionType.Create:
                    return html.RouteLink(linkText, controllerName + "-create", routeValues);
                case ActionType.Index:
                    return html.RouteLink(linkText, controllerName + "-index", routeValues);
                default:
                    throw new ArgumentOutOfRangeException("actionType");
            }
        }

        /// <summary>
        /// Emits a hidden form variable for X-Http-Method-Override. The only valid values for actionType
        /// are ActionType.Delete and ActionType.Update
        /// </summary>
        /// <param name="html"></param>
        /// <param name="actionType"></param>
        /// <returns></returns>
        public static MvcHtmlString HttpMethodOverride(this HtmlHelper html, ActionType actionType)
        {
            if (actionType != ActionType.Delete && actionType != ActionType.Update)
            {
                throw new ArgumentOutOfRangeException("actionType");
            }
            return html.HttpMethodOverride(actionType == ActionType.Delete ? "DELETE" : "PUT");
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/HttpRequestBaseExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Net.Mime;
using System.Web;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// HttpRequestBase extension methods that call directly into the DefaultFormatHelper
    /// </summary>
    public static class HttpRequestBaseExtensions
    {
        public static ContentType GetRequestFormat(this HttpRequestBase request)
        {
            return DefaultFormatHelper.GetRequestFormat(request, true);
        }

        public static IEnumerable<ContentType> GetResponseFormats(this HttpRequestBase request)
        {
            return DefaultFormatHelper.GetResponseFormats(request);
        }

        internal static bool HasBody(this HttpRequestBase request)
        {
            return request.ContentLength > 0 || String.Compare("chunked", request.Headers["Transfer-Encoding"], StringComparison.OrdinalIgnoreCase) == 0;
        }

        public static bool IsBrowserRequest(this HttpRequestBase request)
        {
            return DefaultFormatHelper.IsBrowserRequest(request);
        }

        public static bool IsHttpMethod(this HttpRequestBase request, HttpVerbs httpMethod)
        {
            return request.IsHttpMethod(httpMethod, false);
        }

        public static bool IsHttpMethod(this HttpRequestBase request, string httpMethod)
        {
            return request.IsHttpMethod(httpMethod, false);
        }

        // CODEREVIEW: this implementation kind of misses the point of HttpVerbs
        // by falling back to string comparison, consider something better
        // also, how do we keep this switch in sync?
        public static bool IsHttpMethod(this HttpRequestBase request, HttpVerbs httpMethod, bool allowOverride)
        {
            switch (httpMethod)
            {
                case HttpVerbs.Get:
                    return request.IsHttpMethod("GET", allowOverride);
                case HttpVerbs.Post:
                    return request.IsHttpMethod("POST", allowOverride);
                case HttpVerbs.Put:
                    return request.IsHttpMethod("PUT", allowOverride);
                case HttpVerbs.Delete:
                    return request.IsHttpMethod("DELETE", allowOverride);
                case HttpVerbs.Head:
                    return request.IsHttpMethod("HEAD", allowOverride);
                case HttpVerbs.Patch:
                    return request.IsHttpMethod("PATCH", allowOverride);
                case HttpVerbs.Options:
                    return request.IsHttpMethod("OPTIONS", allowOverride);
                default:
                    // CODEREVIEW: does this look reasonable?
                    return request.IsHttpMethod(httpMethod.ToString().ToUpperInvariant(), allowOverride);
            }
        }

        public static bool IsHttpMethod(this HttpRequestBase request, string httpMethod, bool allowOverride)
        {
            string requestHttpMethod = allowOverride ? request.GetHttpMethodOverride() : request.HttpMethod;
            return String.Equals(requestHttpMethod, httpMethod, StringComparison.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/IEnumerableExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace Microsoft.Web.Mvc.Resources
{
    public static class IEnumerableExtensions
    {
        /// <summary>
        /// Convenience API to allow an IEnumerable{T} (such as returned by Linq2Sql) to be serialized by DataContractSerilizer
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="collection"></param>
        /// <returns></returns>
        public static IEnumerable<T> AsSerializable<T>(this IEnumerable<T> collection) where T : class
        {
            return new IEnumerableWrapper<T>(collection);
        }

        // This wrapper allows IEnumerable<T> to be serialized by DataContractSerilizer
        // it implements the minimal amount of surface needed for serialization.
        private class IEnumerableWrapper<T> : IEnumerable<T>
            where T : class
        {
            private IEnumerable<T> _collection;

            // The DataContractSerilizer needs a default constructor to ensure the object can be
            // deserialized. We have a dummy one since we don't actually need deserialization.
            public IEnumerableWrapper()
            {
                throw new NotImplementedException();
            }

            internal IEnumerableWrapper(IEnumerable<T> collection)
            {
                this._collection = collection;
            }

            // The DataContractSerilizer needs an Add method to ensure the object can be
            // deserialized. We have a dummy one since we don't actually need deserialization.
            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Needed to satisfy the deserialization contract")]
            [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "item", Justification = "Needed to satisfy the deserialization contract")]
            public void Add(T item)
            {
                throw new NotImplementedException();
            }

            public IEnumerator<T> GetEnumerator()
            {
                return this._collection.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return ((IEnumerable)this._collection).GetEnumerator();
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/IRequestFormatHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Mime;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Extensibility mechanism for deserializing data in additional formats.
    /// FormatManager.Current.RequestFormatHandlers contains the list of request formats
    /// supported by the web application
    /// </summary>
    public interface IRequestFormatHandler
    {
        /// <summary>
        /// Returns true if the handler can deserialize request's content type
        /// </summary>
        /// <param name="requestFormat"></param>
        /// <returns></returns>
        bool CanDeserialize(ContentType requestFormat);

        /// <summary>
        /// Deserialize the request body based on model binding context and return the object.
        /// Note that the URI parameters are handled by the base infrastructure.
        /// </summary>
        /// <param name="controllerContext"></param>
        /// <param name="bindingContext"></param>
        /// <param name="requestFormat"></param>
        /// <returns></returns>
        object Deserialize(ControllerContext controllerContext, ModelBindingContext bindingContext, ContentType requestFormat);
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/IResponseFormatHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Mime;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Extensibility mechanism for serializing response in
    /// additional formats. FormatManager.Current.RequestFormatHandlers contains the list of request formats
    /// supported by the web application
    /// </summary>
    public interface IResponseFormatHandler
    {
        /// <summary>
        /// The preferred friendly name for the handled format
        /// </summary>
        string FriendlyName { get; }

        /// <summary>
        /// Return true if the specified friendly name ('xml' for instance) can
        /// be mapped to a content type ('application/xml' for instance). If the mapping
        /// can be performed return the content type that the friendlyName maps to
        /// </summary>
        /// <param name="friendlyName"></param>
        /// <param name="contentType"></param>
        /// <returns></returns>
        bool TryMapFormatFriendlyName(string friendlyName, out ContentType contentType);

        /// <summary>
        /// Return true if the specified response format can be serialized
        /// </summary>
        /// <param name="responseFormat"></param>
        /// <returns></returns>
        bool CanSerialize(ContentType responseFormat);

        /// <summary>
        /// Serialize the model into the response body in the specified response format
        /// </summary>
        /// <param name="context"></param>
        /// <param name="model"></param>
        /// <param name="responseFormat"></param>
        void Serialize(ControllerContext context, object model, ContentType responseFormat);
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/JsonFormatHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Net.Mime;
using System.Runtime.Serialization.Json;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    public class JsonFormatHandler : IRequestFormatHandler, IResponseFormatHandler
    {
        public string FriendlyName
        {
            get { return "Json"; }
        }

        public bool CanDeserialize(ContentType requestFormat)
        {
            return requestFormat != null && IsCompatibleMediaType(requestFormat.MediaType);
        }

        public object Deserialize(ControllerContext controllerContext, ModelBindingContext bindingContext, ContentType requestFormat)
        {
            DataContractJsonSerializer json = new DataContractJsonSerializer(bindingContext.ModelType);
            return json.ReadObject(controllerContext.HttpContext.Request.InputStream);
        }

        public bool CanSerialize(ContentType responseFormat)
        {
            return responseFormat != null && IsCompatibleMediaType(responseFormat.MediaType);
        }

        public void Serialize(ControllerContext context, object model, ContentType responseFormat)
        {
            DataContractJsonActionResult json = new DataContractJsonActionResult(model, responseFormat);
            json.ExecuteResult(context);
        }

        protected virtual bool IsCompatibleMediaType(string mediaType)
        {
            return (mediaType == "text/json" || mediaType == "application/json");
        }

        public bool TryMapFormatFriendlyName(string friendlyName, out ContentType contentType)
        {
            if (String.Equals(friendlyName, this.FriendlyName, StringComparison.OrdinalIgnoreCase))
            {
                contentType = new ContentType("application/json");
                return true;
            }
            contentType = null;
            return false;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/MultiFormatActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.Web;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Returns the response in the format specified by the request. By default, supports returning the model
    /// as a HTML view, XML and JSON.
    /// If the response format requested is not supported, then the NotAcceptable status code is returned
    /// </summary>
    [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Multi", Justification = "FxCop won't accept this in the custom dictionary, so we're suppressing it in source")]
    public class MultiFormatActionResult : ActionResult
    {
        private object _model;
        private ContentType _responseFormat;
        private HttpStatusCode _statusCode;

        public MultiFormatActionResult(object model, ContentType responseFormat)
            : this(model, responseFormat, HttpStatusCode.OK)
        {
        }

        public MultiFormatActionResult(object model, ContentType responseFormat, HttpStatusCode statusCode)
        {
            _model = model;
            _responseFormat = responseFormat;
            _statusCode = statusCode;
        }

        public override void ExecuteResult(ControllerContext context)
        {
            if (!TryExecuteResult(context, this._model, this._responseFormat))
            {
                throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, this._responseFormat));
            }
        }

        public virtual bool TryExecuteResult(ControllerContext context, object model, ContentType responseFormat)
        {
            if (!FormatManager.Current.CanSerialize(responseFormat))
            {
                return false;
            }
            context.HttpContext.Response.ClearContent();
            context.HttpContext.Response.StatusCode = (int)_statusCode;
            FormatManager.Current.Serialize(context, model, responseFormat);
            return true;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/RequestContextExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Mime;
using System.Web.Routing;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// RequestContext extension methods that call directly into the registered FormatHelper
    /// </summary>
    public static class RequestContextExtensions
    {
        public static ContentType GetRequestFormat(this RequestContext requestContext)
        {
            return FormatManager.Current.FormatHelper.GetRequestFormat(requestContext);
        }

        public static IEnumerable<ContentType> GetResponseFormats(this RequestContext requestContext)
        {
            return FormatManager.Current.FormatHelper.GetResponseFormats(requestContext);
        }

        public static bool IsBrowserRequest(this RequestContext requestContext)
        {
            return FormatManager.Current.FormatHelper.IsBrowserRequest(requestContext);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/ResourceControllerFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using System.Web.SessionState;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Specialized ControllerFactory that augments the base controller factory to make it RESTful - specifically, adding
    /// support for multiple formats, HTTP method based dispatch to controller methods and HTTP error handling
    /// </summary>
    public class ResourceControllerFactory : IControllerFactory
    {
        private const string RestActionToken = "$REST$";

        private IControllerFactory _inner;

        public ResourceControllerFactory()
        {
            _inner = ControllerBuilder.Current.GetControllerFactory();
        }

        public ResourceControllerFactory(IControllerFactory inner)
        {
            _inner = inner;
        }

        public IController CreateController(RequestContext requestContext, string controllerName)
        {
            IController ic = _inner.CreateController(requestContext, controllerName);
            Controller c = ic as Controller;
            if (c != null && WebApiEnabledAttribute.IsDefined(c))
            {
                IActionInvoker iai = c.ActionInvoker;
                ControllerActionInvoker cai = iai as ControllerActionInvoker;
                if (cai != null)
                {
                    c.ActionInvoker = new ResourceControllerActionInvoker();

                    string actionName = requestContext.RouteData.Values["action"] as string;
                    if (String.IsNullOrEmpty(actionName))
                    {
                        // set it to a well known dummy value to avoid not having an action as that would prevent the fixup
                        // code in ResourceControllerActionInvoker, which is based on ActionDescriptor, from running
                        requestContext.RouteData.Values["action"] = RestActionToken;
                    }
                }
            }
            return ic;
        }

        public SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
        {
            return _inner.GetControllerSessionBehavior(requestContext, controllerName);
        }

        public void ReleaseController(IController controller)
        {
            _inner.ReleaseController(controller);
        }

        // This ActionInvoker allows us to dispatch to a controller when no action was provided by the routing
        // infrastructure, but the information is available in the request's HTTP verb (GET/PUT/POST/DELETE)
        private class ResourceControllerActionInvoker : ControllerActionInvoker
        {
            protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
            {
                if (actionName == RestActionToken)
                {
                    // cleanup the restActionToken we set earlier
                    controllerContext.RequestContext.RouteData.Values["action"] = null;

                    List<ActionDescriptor> matches = new List<ActionDescriptor>();
                    foreach (ActionDescriptor ad in controllerDescriptor.GetCanonicalActions())
                    {
                        object[] acceptVerbs = ad.GetCustomAttributes(typeof(AcceptVerbsAttribute), false);
                        if (acceptVerbs.Length > 0)
                        {
                            foreach (object o in acceptVerbs)
                            {
                                AcceptVerbsAttribute ava = o as AcceptVerbsAttribute;
                                if (ava != null)
                                {
                                    if (ava.Verbs.Contains(controllerContext.HttpContext.Request.GetHttpMethodOverride().ToUpperInvariant()))
                                    {
                                        matches.Add(ad);
                                    }
                                }
                            }
                        }
                    }
                    switch (matches.Count)
                    {
                        case 0:
                            break;
                        case 1:
                            ActionDescriptor ad = matches[0];
                            actionName = ad.ActionName;
                            controllerContext.RequestContext.RouteData.Values["action"] = actionName;
                            return ad;
                        default:
                            StringBuilder matchesString = new StringBuilder(matches[0].ActionName);
                            for (int index = 1; index < matches.Count; index++)
                            {
                                matchesString.Append(", ");
                                matchesString.Append(matches[index].ActionName);
                            }
                            return new ResourceErrorActionDescriptor(
                                controllerDescriptor,
                                HttpStatusCode.Conflict,
                                String.Format(
                                    CultureInfo.CurrentCulture,
                                    MvcResources.ResourceControllerFactory_ConflictingActions,
                                    controllerDescriptor.ControllerName,
                                    matchesString));
                    }
                }
                return base.FindAction(controllerContext, controllerDescriptor, actionName) ??
                       new ResourceErrorActionDescriptor(
                           controllerDescriptor,
                           HttpStatusCode.NotFound,
                           String.Format(
                               CultureInfo.CurrentCulture,
                               MvcResources.ResourceControllerFactory_NoActions,
                               controllerDescriptor.ControllerName));
            }

            // This class is used when we don't find an ActionDescriptor or find multiple matches
            // in this case we want to return an error response but throwing an HttpException from
            // FindAction bypasses the InvokeExceptionFilters, so instead we throw in this custom ActionDescriptor
            private class ResourceErrorActionDescriptor : ActionDescriptor
            {
                private ControllerDescriptor controllerDescriptor;
                private string message;
                private HttpStatusCode statusCode;

                public ResourceErrorActionDescriptor(ControllerDescriptor controllerDescriptor, HttpStatusCode statusCode, string message)
                {
                    this.message = message;
                    this.statusCode = statusCode;
                    this.controllerDescriptor = controllerDescriptor;
                }

                public override string ActionName
                {
                    get { return RestActionToken; }
                }

                public override ControllerDescriptor ControllerDescriptor
                {
                    get { return this.controllerDescriptor; }
                }

                public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters)
                {
                    HttpException he = new HttpException((int)this.statusCode, this.message);
                    ResourceErrorActionResult rear;
                    if (!WebApiEnabledAttribute.TryGetErrorResult2(controllerContext.RequestContext, he, out rear))
                    {
                        rear = new ResourceErrorActionResult(new HttpException((int)this.statusCode, this.message), new ContentType("text/plain"));
                    }
                    return rear;
                }

                public override ParameterDescriptor[] GetParameters()
                {
                    return new ParameterDescriptor[0];
                }
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/ResourceErrorActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Mime;
using System.Web;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Action result for returning HTTP errors that result from performing operations on resources, including
    /// an optional details in the HTTP body
    /// </summary>
    public class ResourceErrorActionResult : ActionResult
    {
        private object details;
        private ContentType responseFormat;
        private HttpStatusCode statusCode;

        /// <summary>
        /// Sends back a response using the status code in the HttpException.
        /// The response body contains a details serialized in the responseFormat.
        /// If the HttpException.Data has a key named "details", its value is used as the response body.
        /// If there is no such key, HttpException.ToString() is used as the response body.
        /// </summary>
        /// <param name="httpException"></param>
        /// <param name="responseFormat"></param>
        public ResourceErrorActionResult(HttpException httpException, ContentType responseFormat)
        {
            this.statusCode = (HttpStatusCode)httpException.GetHttpCode();
            this.details = httpException.Data.Contains("details") ? httpException.Data["details"] : httpException.ToString();
            this.responseFormat = responseFormat;
        }

        public override void ExecuteResult(ControllerContext context)
        {
            if (this.details != null)
            {
                MultiFormatActionResult rar = new MultiFormatActionResult(this.details, this.responseFormat, this.statusCode);
                if (rar.TryExecuteResult(context, this.details, this.responseFormat))
                {
                    return;
                }
            }
            context.HttpContext.Response.ClearContent();
            context.HttpContext.Response.StatusCode = (int)this.statusCode;
            context.HttpContext.Response.TrySkipIisCustomErrors = true;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/ResourceModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.Web;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// ModelBinder implementation that augments the inner model binder with support for binding to other formats -
    /// XML and JSON by default.
    /// </summary>
    public class ResourceModelBinder : IModelBinder
    {
        private IModelBinder _inner;

        /// <summary>
        /// Wraps the ModelBinders.Binders.DefaultBinder
        /// </summary>
        public ResourceModelBinder()
            : this(ModelBinders.Binders.DefaultBinder)
        {
        }

        public ResourceModelBinder(IModelBinder inner)
        {
            this._inner = inner;
        }

        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            if (WebApiEnabledAttribute.IsDefined(controllerContext.Controller))
            {
                if (!controllerContext.RouteData.Values.ContainsKey(bindingContext.ModelName) && controllerContext.HttpContext.Request.HasBody())
                {
                    ContentType requestFormat = controllerContext.RequestContext.GetRequestFormat();
                    object model;
                    if (TryBindModel(controllerContext, bindingContext, requestFormat, out model))
                    {
                        bindingContext.ModelMetadata.Model = model;
                        MyDefaultModelBinder dmb = new MyDefaultModelBinder();
                        dmb.CallOnModelUpdated(controllerContext, bindingContext);
                        if (!MyDefaultModelBinder.IsModelValid(bindingContext))
                        {
                            List<ModelError> details = new List<ModelError>();
                            foreach (ModelState ms in bindingContext.ModelState.Values)
                            {
                                foreach (ModelError me in ms.Errors)
                                {
                                    details.Add(me);
                                }
                            }
                            HttpException failure = new HttpException((int)HttpStatusCode.ExpectationFailed, "Invalid Model");
                            failure.Data["details"] = details;
                            throw failure;
                        }
                        return model;
                    }
                    throw new HttpException((int)HttpStatusCode.UnsupportedMediaType, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedMediaType, (requestFormat == null ? String.Empty : requestFormat.MediaType)));
                }
            }
            return this._inner.BindModel(controllerContext, bindingContext);
        }

        [SuppressMessage("Microsoft.Design", "CA1007:UseGenericsWhereAppropriate", Justification = "This is an existing API; this would be a breaking change")]
        public bool TryBindModel(ControllerContext controllerContext, ModelBindingContext bindingContext, ContentType requestFormat, out object model)
        {
            if (requestFormat != null && String.Compare(requestFormat.MediaType, FormatManager.UrlEncoded, StringComparison.OrdinalIgnoreCase) == 0)
            {
                model = this._inner.BindModel(controllerContext, bindingContext);
                return true;
            }
            if (!FormatManager.Current.TryDeserialize(controllerContext, bindingContext, requestFormat, out model))
            {
                model = null;
                return false;
            }
            return true;
        }

        private class MyDefaultModelBinder : DefaultModelBinder
        {
            public void CallOnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                OnModelUpdated(controllerContext, bindingContext);
            }

            internal static new bool IsModelValid(ModelBindingContext bindingContext)
            {
                return DefaultModelBinder.IsModelValid(bindingContext);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/ResourceRedirectToRouteResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Augments the RedirectToRouteResult behavior by sending Created HTTP status code in responses to POST, OK HTTP status code otherwise
    /// </summary>
    internal class ResourceRedirectToRouteResult : ActionResult
    {
        private RedirectToRouteResult inner;

        public ResourceRedirectToRouteResult(RedirectToRouteResult inner)
        {
            this.inner = inner;
        }

        public override void ExecuteResult(ControllerContext context)
        {
            // call the base which we expect to be setting the Location header
            this.inner.ExecuteResult(context);

            if (!context.RequestContext.IsBrowserRequest())
            {
                // on POST we return Created, otherwise (EG: DELETE) we return OK
                context.HttpContext.Response.ClearContent();
                context.HttpContext.Response.StatusCode = context.HttpContext.Request.IsHttpMethod(HttpVerbs.Post, true) ? (int)HttpStatusCode.Created : (int)HttpStatusCode.OK;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/RouteCollectionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;
using System.Web.Routing;

namespace Microsoft.Web.Mvc.Resources
{
    public static class RouteCollectionExtensions
    {
        /// <summary>
        /// Adds the routes to enable RESTful routing of requests to specified controller. The controllerName is the URL prefix to the controller.
        /// The routeSuffix is used for more specific routing in the resource. For example, a controllerName of "books" and a routeSuffix of "{id}" will
        /// result in the following routes being registered for the controller:
        /// ~/books/, ~/books/{id} to the resource,
        /// ~/books/CreateForm to the CreateForm controller action,
        /// ~/books/{id}/EditForm to the EditForm controller action
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeSuffix"></param>
        public static void MapResourceRoute(this RouteCollection routes, string controllerName, string routeSuffix)
        {
            routes.MapResourceRoute(controllerName, null, routeSuffix, null);
        }

        /// <summary>
        /// Adds the routes to enable RESTful routing of requests to specified controller. The controllerName is the URL prefix to the controller.
        /// The routeSuffix is used for more specific routing in the resource. For example, a controllerName of "books" and a routeSuffix of "{id}" will
        /// result in the following routes being registered for the controller:
        /// ~/books/, ~/books/{id} to the resource,
        /// ~/books/CreateForm to the CreateForm controller action,
        /// ~/books/{id}/EditForm to the EditForm controller action
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeSuffix"></param>
        /// <param name="constraints"></param>
        public static void MapResourceRoute(this RouteCollection routes, string controllerName, string routeSuffix, object constraints)
        {
            routes.MapResourceRoute(controllerName, null, routeSuffix, constraints);
        }

        /// <summary>
        /// Adds the routes to enable RESTful routing of requests to specified controller. The routePrefix is the URL prefix to the controller.
        /// The routeSuffix is used for more specific routing in the resource. For example, a routePrefix of "books" and a routeSuffix of "{id}" will
        /// result in the following routes being registered for the controller:
        /// ~/books/, ~/books/{id} to the resource,
        /// ~/books/CreateForm to the CreateForm controller action,
        /// ~/books/{id}/EditForm to the EditForm controller action
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="controllerName"></param>
        /// <param name="routePrefix"></param>
        /// <param name="routeSuffix"></param>
        public static void MapResourceRoute(this RouteCollection routes, string controllerName, string routePrefix, string routeSuffix)
        {
            routes.MapResourceRoute(controllerName, routePrefix, routeSuffix, null);
        }

        /// <summary>
        /// Adds the routes to enable RESTful routing of requests to specified controller. The routePrefix is the URL prefix to the controller.
        /// The routeSuffix is used for more specific routing in the resource. For example, a routePrefix of "books" and a routeSuffix of "{id}" will
        /// result in the following routes being registered for the controller:
        /// ~/books/, ~/books/{id} to the resource,
        /// ~/books/CreateForm to the CreateForm controller action,
        /// ~/books/{id}/EditForm to the EditForm controller action
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="controllerName"></param>
        /// <param name="routePrefix"></param>
        /// <param name="routeSuffix"></param>
        /// <param name="constraints"></param>
        public static void MapResourceRoute(this RouteCollection routes, string controllerName, string routePrefix, string routeSuffix, object constraints)
        {
            if (String.IsNullOrEmpty(routePrefix))
            {
                routePrefix = controllerName;
            }
            else
            {
                routePrefix = routePrefix + "/" + controllerName;
            }
            if (!String.IsNullOrEmpty(routeSuffix))
            {
                routeSuffix = "/" + routeSuffix;
            }

            routes.MapRoute(
                controllerName + "-editForm",
                routePrefix + routeSuffix + "/EditForm",
                new { controller = controllerName, action = "EditForm" },
                constraints);
            routes.MapRoute(
                controllerName + "-createForm",
                routePrefix + "/CreateForm",
                new { controller = controllerName, action = "CreateForm" });
            routes.MapRoute(
                controllerName,
                routePrefix + routeSuffix,
                new { controller = controllerName },
                constraints);
            routes.MapRoute(
                controllerName + "-create",
                routePrefix,
                new { controller = controllerName, action = "Create" },
                new { postOnly = new HttpMethodConstraint("POST") });
            routes.MapRoute(
                controllerName + "-index",
                routePrefix,
                new { controller = controllerName, action = "Index" });
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "controller", Justification = "This is an extension method, the parameter is necessary to provide a place to hook the method")]
        public static string GetResourceRouteName(this Controller controller, string controllerName, ActionType actionType)
        {
            switch (actionType)
            {
                case ActionType.GetUpdateForm:
                    return controllerName + "-editForm";
                case ActionType.GetCreateForm:
                    return controllerName + "-createForm";
                case ActionType.Retrieve:
                case ActionType.Delete:
                case ActionType.Update:
                    return controllerName;
                case ActionType.Create:
                    return controllerName + "-create";
                case ActionType.Index:
                    return controllerName + "-index";
                default:
                    throw new ArgumentOutOfRangeException("actionType");
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/UriHelperExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    public static class UriHelperExtensions
    {
        /// <summary>
        /// Generates the route URL for the resource controller's Retrieve action
        /// </summary>
        /// <param name="url"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters"), SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an Extension Method which allows the user to provide a strongly-typed argument via Expression"), SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Need to be sure the passed-in argument is of type Controller::Action")]
        public static string ResourceUrl(this UrlHelper url, string controllerName, object routeValues)
        {
            return url.ResourceUrl(controllerName, routeValues, ActionType.Retrieve);
        }

        /// <summary>
        /// Generates the route URL for the resource
        /// </summary>
        /// <param name="url"></param>
        /// <param name="controllerName"></param>
        /// <param name="routeValues"></param>
        /// <param name="actionType"></param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "The return value is not a regular URL since it may contain ~/ ASP.NET-specific characters"), SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an Extension Method which allows the user to provide a strongly-typed argument via Expression"), SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Need to be sure the passed-in argument is of type Controller::Action")]
        public static string ResourceUrl(this UrlHelper url, string controllerName, object routeValues, ActionType actionType)
        {
            switch (actionType)
            {
                case ActionType.GetUpdateForm:
                    return url.RouteUrl(controllerName + "-editForm", routeValues);
                case ActionType.GetCreateForm:
                    return url.RouteUrl(controllerName + "-createForm");
                case ActionType.Retrieve:
                case ActionType.Delete:
                case ActionType.Update:
                    return url.RouteUrl(controllerName, routeValues);
                case ActionType.Create:
                    return url.RouteUrl(controllerName + "-create");
                case ActionType.Index:
                    return url.RouteUrl(controllerName + "-index");
                default:
                    throw new ArgumentOutOfRangeException("actionType");
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/WebApiEnabledAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net;
using System.Net.Mime;
using System.Text;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc.Resources
{
    /// <summary>
    /// Attribute indicating that the controller supports multiple formats (HTML, XML, JSON etc), HTTP method based dispatch
    /// and HTTP error handling.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This class is designed to be overridden")]
    public class WebApiEnabledAttribute : ActionFilterAttribute, IExceptionFilter
    {
        public WebApiEnabledAttribute()
        {
            this.StatusOnNullModel = HttpStatusCode.NotFound;
        }

        /// <summary>
        /// The HTTP status code to use in case a null value is returned from the controller action method.
        /// The default is NotFound
        /// </summary>
        public HttpStatusCode StatusOnNullModel { get; set; }

        public static bool IsDefined(ControllerBase controller)
        {
            Type controllerType = controller.GetType();
            WebApiEnabledAttribute[] rea = controllerType.GetCustomAttributes(typeof(WebApiEnabledAttribute), true) as WebApiEnabledAttribute[];
            return rea != null && rea.Length > 0;
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            MultiFormatActionResult multiFormatResult = filterContext.Result as MultiFormatActionResult;
            if (multiFormatResult == null)
            {
                ViewResultBase viewResult = filterContext.Result as ViewResultBase;
                if (viewResult != null && viewResult.ViewData != null)
                {
                    bool handled = false;
                    foreach (ContentType responseFormat in filterContext.RequestContext.GetResponseFormats())
                    {
                        // CONSIDER: making this lookup optional if perf is an issue
                        for (int i = 0; i < FormatManager.Current.ResponseFormatHandlers.Count; ++i)
                        {
                            IResponseFormatHandler handler = FormatManager.Current.ResponseFormatHandlers[i];
                            if (handler.CanSerialize(responseFormat))
                            {
                                // we can't use the full ContentType's name (EG: "text/xml")
                                // instead we use the FriendlyName on the matching IResponseFormatHandler
                                string friendlyName = handler.FriendlyName;
                                string viewName = viewResult.ViewName;
                                if (String.IsNullOrEmpty(viewName))
                                {
                                    viewName = filterContext.RouteData.GetRequiredString("action");
                                }
                                // CONSIDER: is this naming convention sufficient? look at extensibility (how can I customize the FindView process?)
                                viewName = viewName + "." + friendlyName;
                                // CONSIDER: ViewEngineCollection queries view engines in registration order and returns 1st match,
                                // would it make sense to let the client provide a hint in case
                                ViewEngineResult result = viewResult.ViewEngineCollection.FindView(filterContext, viewName, null);
                                // ignore errors and fallback to default behavior
                                if (result != null && result.View != null)
                                {
                                    Encoding encoding = Encoding.UTF8;
                                    if (!String.IsNullOrEmpty(responseFormat.CharSet))
                                    {
                                        try
                                        {
                                            encoding = Encoding.GetEncoding(responseFormat.CharSet);
                                        }
                                        catch (ArgumentException)
                                        {
                                            throw new HttpException((int)HttpStatusCode.NotAcceptable, String.Format(CultureInfo.CurrentCulture, MvcResources.Resources_UnsupportedFormat, responseFormat));
                                        }
                                    }
                                    responseFormat.CharSet = encoding.HeaderName;
                                    filterContext.HttpContext.Response.ContentType = responseFormat.ToString();
                                    filterContext.HttpContext.Response.ContentEncoding = encoding;
                                    // we have set the Response.ContentType but know that the webforms view engine will override it
                                    // a different ViewPage base class that sets this can be used to workaround this
                                    // so we make the computed responseFormat available in ViewData
                                    viewResult.ViewData[DefaultFormatHelper.ResponseFormatKey] = responseFormat;
                                    viewResult.View = result.View;
                                    viewResult.ViewName = viewName;
                                    handled = true;
                                    break;
                                }
                            }
                        }
                        if (handled)
                        {
                            break;
                        }
                        if (TryGetResult(viewResult, responseFormat, out multiFormatResult))
                        {
                            if (multiFormatResult != null)
                            {
                                filterContext.Result = multiFormatResult;
                            }
                            handled = true;
                            break;
                        }
                    }
                    if (!handled)
                    {
                        // if enumeration doesn't yield a handler the request is not acceptable
                        // CONSIDER: returning all formats considered in the exception messages
                        throw new HttpException((int)HttpStatusCode.NotAcceptable, "None of the formats specified by the accept header is supported.");
                    }
                }
            }
            base.OnActionExecuted(filterContext);
            RedirectToRouteResult redirectResult = filterContext.Result as RedirectToRouteResult;
            if (redirectResult != null && !filterContext.RequestContext.IsBrowserRequest())
            {
                filterContext.Result = new ResourceRedirectToRouteResult(redirectResult);
            }
        }

        public void OnException(ExceptionContext filterContext)
        {
            if (filterContext.ExceptionHandled)
            {
                return;
            }
            HttpException he = filterContext.Exception as HttpException;
            if (he != null)
            {
                ResourceErrorActionResult rear;
                if (TryGetErrorResult2(filterContext.RequestContext, he, out rear))
                {
                    if (rear != null)
                    {
                        filterContext.Result = rear;
                        filterContext.ExceptionHandled = true;
                    }
                    return;
                }
                // if enumeration doesn't yield a handler the request is not acceptable
                // CONSIDER: returning all formats considered in the exception messages
                throw new HttpException((int)HttpStatusCode.NotAcceptable, "None of the formats specified by the accept header is supported.");
            }
        }

        public virtual bool TryGetErrorResult(HttpException exception, ContentType responseFormat, out ResourceErrorActionResult actionResult)
        {
            if (FormatManager.Current.CanSerialize(responseFormat))
            {
                actionResult = new ResourceErrorActionResult(exception, responseFormat);
                return true;
            }
            switch (responseFormat.MediaType)
            {
                case "application/octet-stream":
                case "application/x-www-form-urlencoded":
                case "text/html":
                case "*/*":
                    actionResult = null;
                    return true;
                default:
                    actionResult = null;
                    return false;
            }
        }

        public virtual bool TryGetResult(ViewResultBase viewResult, ContentType responseFormat, out MultiFormatActionResult actionResult)
        {
            if (FormatManager.Current.CanSerialize(responseFormat))
            {
                if (viewResult.ViewData.Model == null)
                {
                    throw new HttpException((int)this.StatusOnNullModel, this.StatusOnNullModel.ToString());
                }
                actionResult = new MultiFormatActionResult(viewResult.ViewData.Model, responseFormat);
                return true;
            }

            switch (responseFormat.MediaType)
            {
                case "application/octet-stream":
                case "application/x-www-form-urlencoded":
                case "text/html":
                case "*/*":
                    actionResult = null;
                    return true;
                default:
                    actionResult = null;
                    return false;
            }
        }

        internal static bool TryGetErrorResult2(RequestContext requestContext, HttpException he, out ResourceErrorActionResult actionResult)
        {
            foreach (ContentType responseFormat in requestContext.GetResponseFormats())
            {
                WebApiEnabledAttribute dummy = new WebApiEnabledAttribute();
                if (dummy.TryGetErrorResult(he, responseFormat, out actionResult))
                {
                    return true;
                }
            }
            actionResult = null;
            return false;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/Resources/XmlFormatHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Net.Mime;
using System.Runtime.Serialization;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc.Resources
{
    public class XmlFormatHandler : IRequestFormatHandler, IResponseFormatHandler
    {
        public string FriendlyName
        {
            get { return "Xml"; }
        }

        public bool CanDeserialize(ContentType requestFormat)
        {
            return requestFormat != null && IsCompatibleMediaType(requestFormat.MediaType);
        }

        public object Deserialize(ControllerContext controllerContext, ModelBindingContext bindingContext, ContentType requestFormat)
        {
            DataContractSerializer xml = new DataContractSerializer(bindingContext.ModelType, null, Int32.MaxValue, true, true, null);
            return xml.ReadObject(controllerContext.HttpContext.Request.InputStream);
        }

        public bool CanSerialize(ContentType responseFormat)
        {
            return responseFormat != null && IsCompatibleMediaType(responseFormat.MediaType);
        }

        public void Serialize(ControllerContext context, object model, ContentType responseFormat)
        {
            DataContractXmlActionResult xml = new DataContractXmlActionResult(model, responseFormat);
            xml.ExecuteResult(context);
        }

        protected virtual bool IsCompatibleMediaType(string mediaType)
        {
            return (mediaType == "text/xml" || mediaType == "application/xml");
        }

        public bool TryMapFormatFriendlyName(string friendlyName, out ContentType contentType)
        {
            if (String.Equals(friendlyName, this.FriendlyName, StringComparison.OrdinalIgnoreCase))
            {
                contentType = new ContentType("application/xml");
                return true;
            }
            contentType = null;
            return false;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ScriptExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    public static class ScriptExtensions
    {
        public static MvcHtmlString Script(this HtmlHelper helper, string releaseFile)
        {
            return Script(helper, releaseFile, releaseFile);
        }

        public static MvcHtmlString Script(this HtmlHelper helper, string releaseFile, string debugFile)
        {
            if (String.IsNullOrEmpty(releaseFile))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "releaseFile");
            }
            if (String.IsNullOrEmpty(debugFile))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "debugFile");
            }

            string src;
            string file = helper.ViewContext.HttpContext.IsDebuggingEnabled ? debugFile : releaseFile;
            if (IsRelativeToDefaultPath(file))
            {
                src = "~/Scripts/" + file;
            }
            else
            {
                src = file;
            }

            TagBuilder scriptTag = new TagBuilder("script");
            scriptTag.MergeAttribute("type", "text/javascript");
            scriptTag.MergeAttribute("src", UrlHelper.GenerateContentUrl(src, helper.ViewContext.HttpContext));
            return MvcHtmlString.Create(scriptTag.ToString(TagRenderMode.Normal));
        }

        internal static bool IsRelativeToDefaultPath(string file)
        {
            return !(file.StartsWith("~", StringComparison.Ordinal) ||
                     file.StartsWith("../", StringComparison.Ordinal) ||
                     file.StartsWith("/", StringComparison.Ordinal) ||
                     file.StartsWith("http://", StringComparison.OrdinalIgnoreCase) ||
                     file.StartsWith("https://", StringComparison.OrdinalIgnoreCase));
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/SerializationExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    public static class SerializationExtensions
    {
        public static MvcHtmlString Serialize(this HtmlHelper htmlHelper, string name)
        {
            return SerializeInternal(htmlHelper, name, null, useViewData: true);
        }

        internal static MvcHtmlString Serialize(this HtmlHelper htmlHelper, string name, MvcSerializer serializer)
        {
            return SerializeInternal(htmlHelper, name, null, useViewData: true, serializer: serializer);
        }

        public static MvcHtmlString Serialize(this HtmlHelper htmlHelper, string name, object data)
        {
            return SerializeInternal(htmlHelper, name, data, useViewData: false);
        }

        internal static MvcHtmlString Serialize(this HtmlHelper htmlHelper, string name, object data, MvcSerializer serializer)
        {
            return SerializeInternal(htmlHelper, name, data, useViewData: false, serializer: serializer);
        }

        private static MvcHtmlString SerializeInternal(HtmlHelper htmlHelper, string name, object data, bool useViewData)
        {
            return SerializeInternal(htmlHelper, name, data, useViewData, null);
        }

        private static MvcHtmlString SerializeInternal(HtmlHelper htmlHelper, string name, object data, bool useViewData, MvcSerializer serializer)
        {
            if (htmlHelper == null)
            {
                throw new ArgumentNullException("htmlHelper");
            }

            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
            }

            name = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            if (useViewData)
            {
                data = htmlHelper.ViewData.Eval(name);
            }

            string serializedData = (serializer ?? new MvcSerializer()).Serialize(data);

            TagBuilder builder = new TagBuilder("input");
            builder.Attributes["type"] = "hidden";
            builder.Attributes["name"] = name;
            builder.Attributes["value"] = serializedData;
            return MvcHtmlString.Create(builder.ToString(TagRenderMode.SelfClosing));
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ServerVariablesValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public class ServerVariablesValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            NameValueCollection nvc = controllerContext.HttpContext.Request.ServerVariables;
            return new NameValueCollectionValueProvider(nvc, CultureInfo.InvariantCulture);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/SessionValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Web;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public class SessionValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            HttpSessionStateBase session = controllerContext.HttpContext.Session;
            if (session == null)
            {
                // session is disabled
                return null;
            }

            Dictionary<string, object> backingStore = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            foreach (string key in session)
            {
                if (key != null)
                {
                    backingStore[key] = session[key]; // copy to backing store
                }
            }

            // use the invariant culture since Session contains serialized objects
            return new DictionaryValueProvider<object>(backingStore, CultureInfo.InvariantCulture);
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/SkipBindingAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
    public sealed class SkipBindingAttribute : CustomModelBinderAttribute
    {
        private static readonly NullBinder _nullBinder = new NullBinder();

        public override IModelBinder GetBinder()
        {
            return _nullBinder;
        }

        private class NullBinder : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                return null;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/TempDataValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    public class TempDataValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            TempDataDictionary tempData = controllerContext.Controller.TempData;
            if (tempData.Count == 0)
            {
                // fast-track empty TempData
                return null;
            }

            return new TempDataValueProvider(tempData);
        }

        /// <summary>
        /// dummy struct that resembles Void but can be used in a generic context
        /// </summary>
        private struct TempDataVoid
        {
        }

        private sealed class TempDataValueProvider : DictionaryValueProvider<TempDataVoid>
        {
            private readonly TempDataDictionary _tempData;

            // use invariant culture since TempData should contain objects
            public TempDataValueProvider(TempDataDictionary tempData)
                : base(GetVoidDictionary(tempData), CultureInfo.InvariantCulture)
            {
                _tempData = tempData;
            }

            public override ValueProviderResult GetValue(string key)
            {
                object rawValue;

                // TryGetValue will mark the entry for removal.
                if (_tempData.TryGetValue(key, out rawValue))
                {
                    string attemptedValue = Convert.ToString(rawValue, CultureInfo.InvariantCulture);
                    return new ValueProviderResult(rawValue, attemptedValue, CultureInfo.InvariantCulture);
                }
                else
                {
                    // no value found
                    return null;
                }
            }

            private static Dictionary<string, TempDataVoid> GetVoidDictionary(TempDataDictionary tempData)
            {
                // Create a special backing store that doesn't directly hold the values, since the DictionaryValueProvider
                // enumerates over the backing store but enumerating over TempData marks everything for removal.
                Dictionary<string, TempDataVoid> d = new Dictionary<string, TempDataVoid>(StringComparer.OrdinalIgnoreCase);

                // Enumerating over TempDataDictionary.Keys doesn't mark them for removal.
                foreach (string key in tempData.Keys)
                {
                    d[key] = default(TempDataVoid);
                }

                return d;
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/TypeDescriptorHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Web.Mvc;

namespace Microsoft.Web.Mvc
{
    internal static class TypeDescriptorHelper
    {
        private static readonly MockMetadataProvider _mockMetadataProvider = new MockMetadataProvider();

        public static ICustomTypeDescriptor Get(Type type)
        {
            return _mockMetadataProvider.GetTypeDescriptor(type);
        }

        // System.Web.Mvc.TypeDescriptorHelpers is internal, so this mock subclassed type provides
        // access to it via the GetTypeDescriptor() virtual method.
        private sealed class MockMetadataProvider : AssociatedMetadataProvider
        {
            protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
            {
                throw new NotImplementedException();
            }

            public new ICustomTypeDescriptor GetTypeDescriptor(Type type)
            {
                return base.GetTypeDescriptor(type);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/TypeHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;

namespace Microsoft.Web.Mvc
{
    internal static class TypeHelpers
    {
        public static Type ExtractGenericInterface(Type queryType, Type interfaceType)
        {
            Func<Type, bool> matchesInterface = t => t.IsGenericType && t.GetGenericTypeDefinition() == interfaceType;
            return (matchesInterface(queryType)) ? queryType : queryType.GetInterfaces().FirstOrDefault(matchesInterface);
        }

        public static Type[] GetTypeArgumentsIfMatch(Type closedType, Type matchingOpenType)
        {
            if (!closedType.IsGenericType)
            {
                return null;
            }

            Type openType = closedType.GetGenericTypeDefinition();
            return (matchingOpenType == openType) ? closedType.GetGenericArguments() : null;
        }

        public static bool IsCompatibleObject(Type type, object value)
        {
            return ((value == null && TypeAllowsNullValue(type)) || type.IsInstanceOfType(value));
        }

        public static bool IsNullableValueType(Type type)
        {
            return Nullable.GetUnderlyingType(type) != null;
        }

        public static bool TypeAllowsNullValue(Type type)
        {
            return (!type.IsValueType || IsNullableValueType(type));
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/UrlAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Text.RegularExpressions;
using System.Web.Mvc;
using Microsoft.Web.Mvc.Properties;

namespace Microsoft.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false)]
    public sealed class UrlAttribute : DataTypeAttribute, IClientValidatable
    {
        private static Regex _regex = new Regex(@"^(https?|ftp):\/\/(((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:)*@)?(((\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])\.(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]))|((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?)(:\d*)?)(\/((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)+(\/(([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)*)*)?)?(\?((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|[\uE000-\uF8FF]|\/|\?)*)?(\#((([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(%[\da-f]{2})|[!\$&'\(\)\*\+,;=]|:|@)|\/|\?)*)?$", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture);

        public UrlAttribute()
            : base(DataType.Url)
        {
            ErrorMessage = MvcResources.UrlAttribute_Invalid;
        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            yield return new ModelClientValidationRule
            {
                ValidationType = "url",
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName())
            };
        }

        public override bool IsValid(object value)
        {
            if (value == null)
            {
                return true;
            }

            string valueAsString = value as string;
            return valueAsString != null && _regex.Match(valueAsString).Length > 0;
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ValueProviderUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.Web.Mvc
{
    internal static class ValueProviderUtil
    {
        public static bool IsPrefixMatch(string prefix, string testString)
        {
            if (testString == null)
            {
                return false;
            }

            if (prefix.Length == 0)
            {
                return true; // shortcut - non-null testString matches empty prefix
            }

            if (!testString.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
            {
                return false; // prefix doesn't match
            }

            if (testString.Length == prefix.Length)
            {
                return true; // exact match
            }

            // invariant: testString.Length > prefix.Length
            switch (testString[prefix.Length])
            {
                case '.':
                case '[':
                    return true; // known delimiters

                default:
                    return false; // not known delimiter
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.Mvc/ViewExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.Mvc.Html;
using System.Web.Routing;
using ExpressionHelper = Microsoft.Web.Mvc.Internal.ExpressionHelper;

namespace Microsoft.Web.Mvc
{
    public static class ViewExtensions
    {
        public static void RenderRoute(this HtmlHelper helper, RouteValueDictionary routeValues)
        {
            if (routeValues == null)
            {
                throw new ArgumentNullException("routeValues");
            }

            string actionName = (string)routeValues["action"];
            helper.RenderAction(actionName, routeValues);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static void RenderAction<TController>(this HtmlHelper helper, Expression<Action<TController>> action) where TController : Controller
        {
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(action);

            foreach (var entry in helper.ViewContext.RouteData.Values)
            {
                if (!rvd.ContainsKey(entry.Key))
                {
                    rvd.Add(entry.Key, entry.Value);
                }
            }

            RenderRoute(helper, rvd);
        }
    }
}


================================================
FILE: src/Microsoft.Web.WebPages.OAuth/AuthenticationClientData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using DotNetOpenAuth.AspNet;

namespace Microsoft.Web.WebPages.OAuth
{
    /// <summary>
    /// Store display name and extra data of an IAuthenticationClient instance.
    /// </summary>
    public class AuthenticationClientData
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="AuthenticationClientData"/> class.
        /// </summary>
        /// <param name="authenticationClient">The authentication client.</param>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag used to store extra data about this client</param>
        public AuthenticationClientData(IAuthenticationClient authenticationClient, string displayName, IDictionary<string, object> extraData)
        {
            if (authenticationClient == null)
            {
                throw new ArgumentNullException("authenticationClient");
            }

            AuthenticationClient = authenticationClient;
            DisplayName = displayName;
            ExtraData = extraData;
        }

        /// <summary>
        /// Gets the authentication client.
        /// </summary>
        public IAuthenticationClient AuthenticationClient { get; private set; }

        /// <summary>
        /// Gets the display name.
        /// </summary>
        public string DisplayName { get; private set; }

        /// <summary>
        /// The data bag used to store extra data about this client.
        /// </summary>
        public IDictionary<string, object> ExtraData { get; private set; }
    }
}

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "Microsoft.Web.WebPages.OAuth")]


================================================
FILE: src/Microsoft.Web.WebPages.OAuth/Microsoft.Web.WebPages.OAuth.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.Web.WebPages.OAuth</RootNamespace>
    <AssemblyName>Microsoft.Web.WebPages.OAuth</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <Reference Include="DotNetOpenAuth.AspNet, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.AspNet.4.0.3.12153\lib\net40-full\DotNetOpenAuth.AspNet.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.Core.4.0.3.12153\lib\net40-full\DotNetOpenAuth.Core.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OAuth, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OAuth.Core.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OAuth.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OAuth.Consumer, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OAuth.Consumer.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OAuth.Consumer.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OpenId, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OpenId.Core.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OpenId.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OpenId.RelyingParty, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OpenId.RelyingParty.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OpenId.RelyingParty.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.ApplicationServices" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="AuthenticationClientData.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="OAuthAccount.cs" />
    <Compile Include="OAuthWebSecurity.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\WebResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>WebResources.resx</DependentUpon>
    </Compile>
    <Compile Include="ProviderUserIdSerializationHelper.cs" />
    <Compile Include="Resources\OAuthResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>OAuthResources.resx</DependentUpon>
    </Compile>
    <Compile Include="WebPagesOAuthDataProvider.cs" />
    <Compile Include="WebPagesOAuthTokenManager.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\WebMatrix.WebData\WebMatrix.WebData.csproj">
      <Project>{55A15F40-1435-4248-A7F2-2A146BB83586}</Project>
      <Name>WebMatrix.WebData</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Properties\WebResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>WebResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\OAuthResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>OAuthResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/OAuthAccount.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using Microsoft.Web.WebPages.OAuth.Properties;

namespace Microsoft.Web.WebPages.OAuth
{
    /// <summary>
    /// Represents an OAuth &amp; OpenID account.
    /// </summary>
    public class OAuthAccount
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="OAuthAccount"/> class.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        public OAuthAccount(string provider, string providerUserId)
        {
            if (String.IsNullOrEmpty(provider))
            {
                throw new ArgumentException(
                    String.Format(CultureInfo.CurrentCulture, WebResources.Argument_Cannot_Be_Null_Or_Empty, "provider"),
                    "provider");
            }

            if (String.IsNullOrEmpty(providerUserId))
            {
                throw new ArgumentException(
                    String.Format(CultureInfo.CurrentCulture, WebResources.Argument_Cannot_Be_Null_Or_Empty, "providerUserId"),
                    "providerUserId");
            }

            Provider = provider;
            ProviderUserId = providerUserId;
        }

        /// <summary>
        /// Gets the provider name.
        /// </summary>
        public string Provider { get; private set; }

        /// <summary>
        /// Gets the provider user id.
        /// </summary>
        public string ProviderUserId { get; private set; }
    }
}


================================================
FILE: src/Microsoft.Web.WebPages.OAuth/OAuthWebSecurity.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web;
using System.Web.Security;
using DotNetOpenAuth.AspNet;
using DotNetOpenAuth.AspNet.Clients;
using Microsoft.Web.WebPages.OAuth.Properties;
using WebMatrix.WebData;

namespace Microsoft.Web.WebPages.OAuth
{
    /// <summary>
    /// Contains APIs to manage authentication against OAuth &amp; OpenID service providers
    /// </summary>
    public static class OAuthWebSecurity
    {
        internal static IOpenAuthDataProvider OAuthDataProvider = new WebPagesOAuthDataProvider();

        // contains all registered authentication clients
        private static readonly Dictionary<string, AuthenticationClientData> _authenticationClients =
            new Dictionary<string, AuthenticationClientData>(StringComparer.OrdinalIgnoreCase);

        /// <summary>
        /// Gets a value indicating whether the current user is authenticated by an OAuth provider.
        /// </summary>
        public static bool IsAuthenticatedWithOAuth
        {
            get
            {
                if (HttpContext.Current == null)
                {
                    throw new InvalidOperationException(WebResources.HttpContextNotAvailable);
                }

                return GetIsAuthenticatedWithOAuthCore(new HttpContextWrapper(HttpContext.Current));
            }
        }

        /// <summary>
        /// Gets the collection of all registered authentication client;
        /// </summary>
        /// <returns></returns>
        public static ICollection<AuthenticationClientData> RegisteredClientData
        {
            get
            {
                // the Values property returns a read-only collection.
                // so we don't need to worry about clients of this method modifying our internal collection.
                return _authenticationClients.Values;
            }
        }

        /// <summary>
        /// Registers the Facebook client.
        /// </summary>
        /// <param name="appId">The app id.</param>
        /// <param name="appSecret">The app secret.</param>
        public static void RegisterFacebookClient(string appId, string appSecret)
        {
            RegisterFacebookClient(appId, appSecret, displayName: "Facebook");
        }

        /// <summary>
        /// Registers the Facebook client.
        /// </summary>
        /// <param name="appId">The app id.</param>
        /// <param name="appSecret">The app secret.</param>
        /// <param name="displayName">The display name of the client.</param>
        public static void RegisterFacebookClient(string appId, string appSecret, string displayName)
        {
            RegisterFacebookClient(appId, appSecret, displayName, extraData: new Dictionary<string, object>());
        }

        /// <summary>
        /// Registers the Facebook client.
        /// </summary>
        /// <param name="appId">The app id.</param>
        /// <param name="appSecret">The app secret.</param>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag used to store extra data about this client</param>
        public static void RegisterFacebookClient(string appId, string appSecret, string displayName, IDictionary<string, object> extraData)
        {
            RegisterClient(new FacebookClient(appId, appSecret), displayName, extraData);
        }

        /// <summary>
        /// Registers the Microsoft account client.
        /// </summary>
        /// <param name="clientId">The client id.</param>
        /// <param name="clientSecret">The client secret.</param>
        public static void RegisterMicrosoftClient(string clientId, string clientSecret)
        {
            RegisterMicrosoftClient(clientId, clientSecret, displayName: "Microsoft");
        }

        /// <summary>
        /// Registers the Microsoft account client.
        /// </summary>
        /// <param name="clientId">The client id.</param>
        /// <param name="clientSecret">The client secret.</param>
        /// <param name="displayName">The display name.</param>
        public static void RegisterMicrosoftClient(string clientId, string clientSecret, string displayName)
        {
            RegisterMicrosoftClient(clientId, clientSecret, displayName, new Dictionary<string, object>());
        }

        /// <summary>
        /// Registers the Microsoft account client.
        /// </summary>
        /// <param name="clientId">The client id.</param>
        /// <param name="clientSecret">The client secret.</param>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag used to store extra data about this client</param>
        public static void RegisterMicrosoftClient(string clientId, string clientSecret, string displayName, IDictionary<string, object> extraData)
        {
            RegisterClient(new MicrosoftClient(clientId, clientSecret), displayName, extraData);
        }

        /// <summary>
        /// Registers the Twitter client.
        /// </summary>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        public static void RegisterTwitterClient(string consumerKey, string consumerSecret)
        {
            RegisterTwitterClient(consumerKey, consumerSecret, displayName: "Twitter");
        }

        /// <summary>
        /// Registers the Twitter client.
        /// </summary>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        /// <param name="displayName">The display name.</param>
        public static void RegisterTwitterClient(string consumerKey, string consumerSecret, string displayName)
        {
            RegisterTwitterClient(consumerKey, consumerSecret, displayName, new Dictionary<string, object>());
        }

        /// <summary>
        /// Registers the Twitter client.
        /// </summary>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag used to store extra data about this client</param>
        public static void RegisterTwitterClient(string consumerKey, string consumerSecret, string displayName, IDictionary<string, object> extraData)
        {
            var twitterClient = new TwitterClient(consumerKey, consumerSecret);
            RegisterClient(twitterClient, displayName, extraData);
        }

        /// <summary>
        /// Registers the LinkedIn client.
        /// </summary>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        public static void RegisterLinkedInClient(string consumerKey, string consumerSecret)
        {
            RegisterLinkedInClient(consumerKey, consumerSecret, displayName: "LinkedIn");
        }

        /// <summary>
        /// Registers the LinkedIn client.
        /// </summary>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        /// <param name="displayName">The display name.</param>
        public static void RegisterLinkedInClient(string consumerKey, string consumerSecret, string displayName)
        {
            RegisterLinkedInClient(consumerKey, consumerSecret, displayName, new Dictionary<string, object>());
        }

        /// <summary>
        /// Registers the LinkedIn client.
        /// </summary>
        /// <param name="consumerKey">The consumer key.</param>
        /// <param name="consumerSecret">The consumer secret.</param>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag used to store extra data about this client</param>
        public static void RegisterLinkedInClient(string consumerKey, string consumerSecret, string displayName, IDictionary<string, object> extraData)
        {
            var linkedInClient = new LinkedInClient(consumerKey, consumerSecret);
            RegisterClient(linkedInClient, displayName, extraData);
        }

        /// <summary>
        /// Registers the Google client.
        /// </summary>
        public static void RegisterGoogleClient()
        {
            RegisterGoogleClient(displayName: "Google");
        }

        /// <summary>
        /// Registers the Google client.
        /// </summary>
        /// <param name="displayName">The display name.</param>
        public static void RegisterGoogleClient(string displayName)
        {
            RegisterClient(new GoogleOpenIdClient(), displayName, new Dictionary<string, object>());
        }

        /// <summary>
        /// Registers the Google client.
        /// </summary>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag.</param>
        public static void RegisterGoogleClient(string displayName, IDictionary<string, object> extraData)
        {
            RegisterClient(new GoogleOpenIdClient(), displayName, extraData);
        }

        /// <summary>
        /// Registers the Yahoo client.
        /// </summary>
        public static void RegisterYahooClient()
        {
            RegisterYahooClient(displayName: "Yahoo");
        }

        /// <summary>
        /// Registers the Yahoo client.
        /// </summary>
        /// <param name="displayName">The display name.</param>
        public static void RegisterYahooClient(string displayName)
        {
            RegisterYahooClient(displayName, new Dictionary<string, object>());
        }

        /// <summary>
        /// Registers the Yahoo client.
        /// </summary>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag.</param>
        public static void RegisterYahooClient(string displayName, IDictionary<string, object> extraData)
        {
            RegisterClient(new YahooOpenIdClient(), displayName, extraData);
        }

        /// <summary>
        /// Registers an authentication client.
        /// </summary>
        /// <param name="client">The client to be registered.</param>
        [CLSCompliant(false)]
        public static void RegisterClient(IAuthenticationClient client)
        {
            RegisterClient(client, displayName: null, extraData: new Dictionary<string, object>());
        }

        /// <summary>
        /// Registers an authentication client.
        /// </summary>
        /// <param name="client">The client to be registered</param>
        /// <param name="displayName">The display name.</param>
        /// <param name="extraData">The data bag used to store extra data about the specified client</param>
        [CLSCompliant(false)]
        public static void RegisterClient(IAuthenticationClient client, string displayName, IDictionary<string, object> extraData)
        {
            if (client == null)
            {
                throw new ArgumentNullException("client");
            }

            if (String.IsNullOrEmpty(client.ProviderName))
            {
                throw new ArgumentException(WebResources.InvalidServiceProviderName, "client");
            }

            if (_authenticationClients.ContainsKey(client.ProviderName))
            {
                throw new ArgumentException(WebResources.ServiceProviderNameExists, "client");
            }

            var clientData = new AuthenticationClientData(client, displayName, extraData);
            _authenticationClients.Add(client.ProviderName, clientData);
        }

        /// <summary>
        /// Requests the specified provider to start the authentication by directing users to an external website
        /// </summary>
        /// <param name="provider">The provider.</param>
        public static void RequestAuthentication(string provider)
        {
            RequestAuthentication(provider, returnUrl: null);
        }

        /// <summary>
        /// Requests the specified provider to start the authentication by directing users to an external website
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="returnUrl">The return url after user is authenticated.</param>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to allow relative app path, and support ~/")]
        public static void RequestAuthentication(string provider, string returnUrl)
        {
            if (HttpContext.Current == null)
            {
                throw new InvalidOperationException(WebResources.HttpContextNotAvailable);
            }

            RequestAuthenticationCore(new HttpContextWrapper(HttpContext.Current), provider, returnUrl);
        }

        /// <summary>
        /// Requests the authentication core.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="provider">The provider.</param>
        /// <param name="returnUrl">The return URL.</param>
        internal static void RequestAuthenticationCore(HttpContextBase context, string provider, string returnUrl)
        {
            IAuthenticationClient client = GetOAuthClient(provider);
            var securityManager = new OpenAuthSecurityManager(context, client, OAuthDataProvider);
            securityManager.RequestAuthentication(returnUrl);
        }

        /// <summary>
        /// Checks if user is successfully authenticated when user is redirected back to this user.
        /// </summary>
        [CLSCompliant(false)]
        public static AuthenticationResult VerifyAuthentication()
        {
            return VerifyAuthentication(returnUrl: null);
        }

        /// <summary>
        /// Checks if user is successfully authenticated when user is redirected back to this user.
        /// </summary>
        /// <param name="returnUrl">The return URL which must match the one passed to RequestAuthentication earlier.</param>
        [CLSCompliant(false)]
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "We want to allow relative app path, and support ~/")]
        public static AuthenticationResult VerifyAuthentication(string returnUrl)
        {
            if (HttpContext.Current == null)
            {
                throw new InvalidOperationException(WebResources.HttpContextNotAvailable);
            }

            return VerifyAuthenticationCore(new HttpContextWrapper(HttpContext.Current), returnUrl);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to allow relative app path, and support ~/")]
        internal static AuthenticationResult VerifyAuthenticationCore(HttpContextBase context, string returnUrl)
        {
            string providerName = OpenAuthSecurityManager.GetProviderName(context);
            if (String.IsNullOrEmpty(providerName))
            {
                return AuthenticationResult.Failed;
            }

            IAuthenticationClient client;
            if (TryGetOAuthClient(providerName, out client))
            {
                var securityManager = new OpenAuthSecurityManager(context, client, OAuthDataProvider);
                return securityManager.VerifyAuthentication(returnUrl);
            }
            else
            {
                throw new InvalidOperationException(WebResources.InvalidServiceProviderName);
            }
        }

        /// <summary>
        /// Checks if the specified provider user id represents a valid account.
        /// If it does, log user in.
        /// </summary>
        /// <param name="providerName">Name of the provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        /// <param name="createPersistentCookie">if set to <c>true</c> create persistent cookie as part of the login.</param>
        /// <returns>
        ///   <c>true</c> if the login is successful.
        /// </returns>
        [SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Justification = "Login is used more consistently in ASP.Net")]
        public static bool Login(string providerName, string providerUserId, bool createPersistentCookie)
        {
            if (HttpContext.Current == null)
            {
                throw new InvalidOperationException(WebResources.HttpContextNotAvailable);
            }

            return LoginCore(new HttpContextWrapper(HttpContext.Current), providerName, providerUserId, createPersistentCookie);
        }

        internal static bool LoginCore(HttpContextBase context, string providerName, string providerUserId, bool createPersistentCookie)
        {
            var provider = GetOAuthClient(providerName);
            var securityManager = new OpenAuthSecurityManager(context, provider, OAuthDataProvider);
            return securityManager.Login(providerUserId, createPersistentCookie);
        }

        internal static bool GetIsAuthenticatedWithOAuthCore(HttpContextBase context)
        {
            return new OpenAuthSecurityManager(context).IsAuthenticatedWithOpenAuth;
        }

        /// <summary>
        /// Creates or update the account with the specified provider, provider user id and associate it with the specified user name.
        /// </summary>
        /// <param name="providerName">Name of the provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        /// <param name="userName">The user name.</param>
        public static void CreateOrUpdateAccount(string providerName, string providerUserId, string userName)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            provider.CreateOrUpdateOAuthAccount(providerName, providerUserId, userName);
        }

        /// <summary>
        /// Gets the registered user name corresponding to the specified provider and provider user id.
        /// </summary>
        /// <param name="providerName">Name of the provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        /// <returns></returns>
        public static string GetUserName(string providerName, string providerUserId)
        {
            return OAuthDataProvider.GetUserNameFromOpenAuth(providerName, providerUserId);
        }

        /// <summary>
        /// Gets all OAuth &amp; OpenID accounts which are associted with the specified user name.
        /// </summary>
        /// <param name="userName">The user name.</param>
        public static ICollection<OAuthAccount> GetAccountsFromUserName(string userName)
        {
            if (String.IsNullOrEmpty(userName))
            {
                throw new ArgumentException(
                    String.Format(CultureInfo.CurrentCulture, WebResources.Argument_Cannot_Be_Null_Or_Empty, "userName"),
                    "userName");
            }

            ExtendedMembershipProvider provider = VerifyProvider();
            return provider.GetAccountsForUser(userName).Select(p => new OAuthAccount(p.Provider, p.ProviderUserId)).ToList();
        }

        /// <summary>
        /// Determines whether there exists a local account (as opposed to OAuth account) with the specified userId.
        /// </summary>
        /// <param name="userId">The user id to check for local account.</param>
        /// <returns>
        ///   <c>true</c> if there is a local account with the specified user id]; otherwise, <c>false</c>.
        /// </returns>
        public static bool HasLocalAccount(int userId)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this
            return provider.HasLocalAccount(userId);
        }

        /// <summary>
        /// Delete the specified OAuth &amp; OpenID account
        /// </summary>
        /// <param name="providerName">Name of the provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        public static bool DeleteAccount(string providerName, string providerUserId)
        {
            ExtendedMembershipProvider provider = VerifyProvider();

            string username = GetUserName(providerName, providerUserId);
            if (String.IsNullOrEmpty(username))
            {
                // account doesn't exist
                return false;
            }

            provider.DeleteOAuthAccount(providerName, providerUserId);
            return true;
        }

        /// <summary>
        /// Gets the OAuth client data of the specified provider name.
        /// </summary>
        /// <param name="providerName">Name of the provider.</param>
        /// <returns>The AuthenticationClientData of the specified provider name.</returns>
        public static AuthenticationClientData GetOAuthClientData(string providerName)
        {
            if (providerName == null)
            {
                throw new ArgumentNullException("providerName");
            }

            return _authenticationClients[providerName];
        }

        /// <summary>
        /// Tries getting the OAuth client data of the specified provider name.
        /// </summary>
        /// <param name="providerName">Name of the provider.</param>
        /// <param name="clientData">The client data of the specified provider name.</param>
        /// <returns><c>true</c> if the client data is found for the specified provider name. Otherwise, <c>false</c></returns>
        public static bool TryGetOAuthClientData(string providerName, out AuthenticationClientData clientData)
        {
            if (providerName == null)
            {
                throw new ArgumentNullException("providerName");
            }

            return _authenticationClients.TryGetValue(providerName, out clientData);
        }

        internal static IAuthenticationClient GetOAuthClient(string providerName)
        {
            if (!_authenticationClients.ContainsKey(providerName))
            {
                throw new ArgumentException(WebResources.ServiceProviderNotFound, "providerName");
            }

            return _authenticationClients[providerName].AuthenticationClient;
        }

        internal static bool TryGetOAuthClient(string provider, out IAuthenticationClient client)
        {
            if (_authenticationClients.ContainsKey(provider))
            {
                client = _authenticationClients[provider].AuthenticationClient;
                return true;
            }
            else
            {
                client = null;
                return false;
            }
        }

        /// <summary>
        /// for unit tests
        /// </summary>
        internal static void ClearProviders()
        {
            _authenticationClients.Clear();
        }

        private static ExtendedMembershipProvider VerifyProvider()
        {
            var provider = Membership.Provider as ExtendedMembershipProvider;
            if (provider == null)
            {
                throw new InvalidOperationException();
            }
            return provider;
        }

        /// <summary>
        /// Securely serializes a providerName/providerUserId pair.
        /// </summary>
        /// <param name="providerName">The provider name.</param>
        /// <param name="providerUserId">The provider-specific user id.</param>
        /// <returns>A cryptographically protected serialization of the inputs which is suitable for round-tripping.</returns>
        /// <remarks>Do not persist the return value to permanent storage. This implementation is subject to change.</remarks>
        public static string SerializeProviderUserId(string providerName, string providerUserId)
        {
            if (providerName == null)
            {
                throw new ArgumentNullException("providerName");
            }
            if (providerUserId == null)
            {
                throw new ArgumentNullException("providerUserId");
            }

            return ProviderUserIdSerializationHelper.ProtectData(providerName, providerUserId);
        }

        /// <summary>
        /// Deserializes a string obtained from <see cref="SerializeProviderUserId(string, string)"/> back into a 
        /// providerName/providerUserId pair.
        /// </summary>
        /// <param name="data">The input data.</param>
        /// <param name="providerName">Will contain the deserialized provider name.</param>
        /// <param name="providerUserId">Will contain the deserialized provider user id.</param>
        /// <returns><c>True</c> if successful.</returns>
        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "1#", Justification = "This design is acceptable")]
        public static bool TryDeserializeProviderUserId(string data, out string providerName, out string providerUserId)
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }

            return ProviderUserIdSerializationHelper.UnprotectData(data, out providerName, out providerUserId);
        }
    }
}

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.WebPages.Razor;

namespace Microsoft.Web.WebPages.OAuth
{
    /// <summary>
    /// Defines Start() method that gets executed when this assembly is loaded by ASP.NET
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        /// <summary>
        /// Register global namepace imports for this assembly 
        /// </summary>
        public static void Start()
        {
            WebPageRazorHost.AddGlobalImport("DotNetOpenAuth.AspNet");
            WebPageRazorHost.AddGlobalImport("Microsoft.Web.WebPages.OAuth");

            // Disable the "calls home" feature of DNOA
            DotNetOpenAuth.Reporting.Enabled = false;
        }
    }
}

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;

[assembly: AssemblyTitle("Microsoft.Web.WebPages.OAuth")]
[assembly: AssemblyDescription("")]

[assembly: InternalsVisibleTo("Microsoft.Web.WebPages.OAuth.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: PreApplicationStartMethod(typeof(Microsoft.Web.WebPages.OAuth.PreApplicationStartCode), "Start")]


================================================
FILE: src/Microsoft.Web.WebPages.OAuth/Properties/WebResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.488
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.Web.WebPages.OAuth.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class WebResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal WebResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Web.WebPages.OAuth.Properties.WebResources", typeof(WebResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} cannot be null or an empty string..
        /// </summary>
        internal static string Argument_Cannot_Be_Null_Or_Empty {
            get {
                return ResourceManager.GetString("Argument_Cannot_Be_Null_Or_Empty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HttpContext is not available in the current thread..
        /// </summary>
        internal static string HttpContextNotAvailable {
            get {
                return ResourceManager.GetString("HttpContextNotAvailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid provider name..
        /// </summary>
        internal static string InvalidServiceProviderName {
            get {
                return ResourceManager.GetString("InvalidServiceProviderName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Another service provider with the same name has already been registered..
        /// </summary>
        internal static string ServiceProviderNameExists {
            get {
                return ResourceManager.GetString("ServiceProviderNameExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A service provider could not be found by the specified name..
        /// </summary>
        internal static string ServiceProviderNotFound {
            get {
                return ResourceManager.GetString("ServiceProviderNotFound", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.WebPages.OAuth/Properties/WebResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Argument_Cannot_Be_Null_Or_Empty" xml:space="preserve">
    <value>{0} cannot be null or an empty string.</value>
  </data>
  <data name="HttpContextNotAvailable" xml:space="preserve">
    <value>HttpContext is not available in the current thread.</value>
  </data>
  <data name="InvalidServiceProviderName" xml:space="preserve">
    <value>Invalid provider name.</value>
  </data>
  <data name="ServiceProviderNameExists" xml:space="preserve">
    <value>Another service provider with the same name has already been registered.</value>
  </data>
  <data name="ServiceProviderNotFound" xml:space="preserve">
    <value>A service provider could not be found by the specified name.</value>
  </data>
</root>

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/ProviderUserIdSerializationHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Web.Security;

namespace Microsoft.Web.WebPages.OAuth
{
    internal static class ProviderUserIdSerializationHelper
    {
        // Custom message purpose to prevent this data from being readable by a different subsystem.
        private static byte[] _padding = new byte[] { 0x85, 0xC5, 0x65, 0x72 };

        [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "The instances are disposed correctly.")]
        public static string ProtectData(string providerName, string providerUserId)
        {
            using (MemoryStream ms = new MemoryStream())
            using (BinaryWriter bw = new BinaryWriter(ms))
            {
                bw.Write(providerName);
                bw.Write(providerUserId);
                bw.Flush();
                byte[] serializedWithPadding = new byte[ms.Length + _padding.Length];
                Buffer.BlockCopy(_padding, 0, serializedWithPadding, 0, _padding.Length);
                Buffer.BlockCopy(ms.GetBuffer(), 0, serializedWithPadding, _padding.Length, (int)ms.Length);
#pragma warning disable 0618 // Encode is [Obsolete] in 4.5
                return MachineKey.Encode(serializedWithPadding, MachineKeyProtection.All);
#pragma warning restore 0618
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "The instances are disposed correctly.")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "All exception are being caught on purpose.")]
        public static bool UnprotectData(string protectedData, out string providerName, out string providerUserId)
        {
            providerName = null;
            providerUserId = null;
            if (String.IsNullOrEmpty(protectedData))
            {
                return false;
            }
#pragma warning disable 0618 // Decode is [Obsolete] in 4.5
            byte[] decodedWithPadding = MachineKey.Decode(protectedData, MachineKeyProtection.All);
#pragma warning restore 0618
            if (decodedWithPadding.Length < _padding.Length)
            {
                return false;
            }

            // timing attacks aren't really applicable to this, so we just do the simple check.
            for (int i = 0; i < _padding.Length; i++)
            {
                if (_padding[i] != decodedWithPadding[i])
                {
                    return false;
                }
            }

            using (MemoryStream ms = new MemoryStream(decodedWithPadding, _padding.Length, decodedWithPadding.Length - _padding.Length))
            using (BinaryReader br = new BinaryReader(ms))
            {
                try
                {
                    // use temp variable to keep both out parameters consistent and only set them when the input stream is read completely
                    string name = br.ReadString();
                    string userId = br.ReadString();

                    // make sure that we consume the entire input stream
                    if (ms.ReadByte() == -1)
                    {
                        providerName = name;
                        providerUserId = userId;
                        return true;
                    }
                }
                catch
                {
                    // Any exceptions will result in this method returning false.
                }
            }
            return false;
        }
    }
}

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/Resources/OAuthResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.488
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.Web.WebPages.OAuth.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class OAuthResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal OAuthResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Web.WebPages.OAuth.Resources.OAuthResources", typeof(OAuthResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To call this method, the &quot;Membership.Provider&quot; property must be an instance of &quot;ExtendedMembershipProvider&quot;..
        /// </summary>
        internal static string Security_NoExtendedMembershipProvider {
            get {
                return ResourceManager.GetString("Security_NoExtendedMembershipProvider", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/Microsoft.Web.WebPages.OAuth/Resources/OAuthResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Security_NoExtendedMembershipProvider" xml:space="preserve">
    <value>To call this method, the "Membership.Provider" property must be an instance of "ExtendedMembershipProvider".</value>
  </data>
</root>

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/WebPagesOAuthDataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Security;
using DotNetOpenAuth.AspNet;
using Microsoft.Web.WebPages.OAuth.Resources;
using WebMatrix.WebData;

namespace Microsoft.Web.WebPages.OAuth
{
    internal class WebPagesOAuthDataProvider : IOpenAuthDataProvider
    {
        private static ExtendedMembershipProvider VerifyProvider()
        {
            var provider = Membership.Provider as ExtendedMembershipProvider;
            if (provider == null)
            {
                throw new InvalidOperationException(OAuthResources.Security_NoExtendedMembershipProvider);
            }
            return provider;
        }

        public string GetUserNameFromOpenAuth(string openAuthProvider, string openAuthId)
        {
            ExtendedMembershipProvider provider = VerifyProvider();

            int userId = provider.GetUserIdFromOAuth(openAuthProvider, openAuthId);
            if (userId == -1) 
            {
                return null;
            }

            return provider.GetUserNameFromId(userId);
        }
    }
}

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/WebPagesOAuthTokenManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Security;
using DotNetOpenAuth.AspNet.Clients;
using Microsoft.Internal.Web.Utils;
using Microsoft.Web.WebPages.OAuth.Resources;
using WebMatrix.WebData;

namespace Microsoft.Web.WebPages.OAuth
{
    /// <summary>
    /// WebPages implementation for the <see cref="IOAuthTokenManager"/> interface which store tokens into SimpleMembership database
    /// </summary>
    internal class WebPagesOAuthTokenManager : IOAuthTokenManager
    {
        private static ExtendedMembershipProvider VerifyProvider()
        {
            var provider = Membership.Provider as ExtendedMembershipProvider;
            if (provider == null)
            {
                throw new InvalidOperationException(OAuthResources.Security_NoExtendedMembershipProvider);
            }
            return provider;
        }

        /// <summary>
        /// Gets the token secret from the specified token.
        /// </summary>
        /// <param name="token">The token.</param>
        /// <returns>
        /// The token's secret
        /// </returns>
        public string GetTokenSecret(string token)
        {
            if (String.IsNullOrEmpty(token))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "token");
            }

            return VerifyProvider().GetOAuthTokenSecret(token);
        }

        /// <summary>
        /// Replaces the request token with access token.
        /// </summary>
        /// <param name="requestToken">The request token.</param>
        /// <param name="accessToken">The access token.</param>
        /// <param name="accessTokenSecret">The access token secret.</param>
        public void ReplaceRequestTokenWithAccessToken(string requestToken, string accessToken, string accessTokenSecret)
        {
            if (String.IsNullOrEmpty(requestToken))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "requestToken");
            }

            if (String.IsNullOrEmpty(accessToken))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "accessToken");
            }

            if (String.IsNullOrEmpty(accessTokenSecret))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "accessTokenSecret");
            }

            VerifyProvider().ReplaceOAuthRequestTokenWithAccessToken(requestToken, accessToken, accessTokenSecret);
        }

        /// <summary>
        /// Stores the request token together with its secret.
        /// </summary>
        /// <param name="requestToken">The request token.</param>
        /// <param name="requestTokenSecret">The request token secret.</param>
        public void StoreRequestToken(string requestToken, string requestTokenSecret)
        {
            if (String.IsNullOrEmpty(requestToken))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "requestToken");
            }

            VerifyProvider().StoreOAuthRequestToken(requestToken, requestTokenSecret);
        }
    }
}

================================================
FILE: src/Microsoft.Web.WebPages.OAuth/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="DotNetOpenAuth.AspNet" version="4.0.3.12153" targetFramework="net45" />
  <package id="DotNetOpenAuth.Core" version="4.0.3.12153" targetFramework="net45" />
  <package id="DotNetOpenAuth.OAuth.Consumer" version="4.0.3.12153" targetFramework="net45" />
  <package id="DotNetOpenAuth.OAuth.Core" version="4.0.3.12153" targetFramework="net45" />
  <package id="DotNetOpenAuth.OpenId.Core" version="4.0.3.12153" targetFramework="net45" />
  <package id="DotNetOpenAuth.OpenId.RelyingParty" version="4.0.3.12153" targetFramework="net45" />
</packages>

================================================
FILE: src/Settings.StyleCop
================================================
<StyleCopSettings Version="105">
  <GlobalSettings>
    <StringProperty Name="MergeSettingsFiles">Parent</StringProperty>
  </GlobalSettings>
</StyleCopSettings>

================================================
FILE: src/Strict.ruleset
================================================
<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="FxCop rules for ASP.NET Web Stack" Description="This rule set contains the rules for ASP.NET Web Stack." ToolsVersion="10.0">
  <RuleHintPaths>
    <Path>..\packages\CustomFxCopRules</Path>
  </RuleHintPaths>
  <IncludeAll Action="Error" />
  <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
    <Rule Id="CA1062" Action="None" />
    <!-- Ignore int.ToString(...) calls w/o an IFormatProvider in old code. -->
    <Rule Id="CA1305" Action="None" />
  </Rules>
</RuleSet>

================================================
FILE: src/System.Net.Http.Formatting/ByteRangeStreamContent.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.IO;
using System.Linq;
using System.Net.Http.Headers;
using System.Net.Http.Internal;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// <see cref="HttpContent"/> implementation which provides a byte range view over a stream used to generate HTTP
    /// 206 (Partial Content) byte range responses. The <see cref="ByteRangeStreamContent"/> supports one or more
    /// byte ranges regardless of whether the ranges are consecutive or not. If there is only one range then a
    /// single partial response body containing a Content-Range header is generated. If there are more than one
    /// ranges then a multipart/byteranges response is generated where each body part contains a range indicated
    /// by the associated Content-Range header field.
    /// </summary>
    public class ByteRangeStreamContent : HttpContent
    {
        private const string SupportedRangeUnit = "bytes";
        private const string ByteRangesContentSubtype = "byteranges";
        private const int DefaultBufferSize = 4096;
        private const int MinBufferSize = 1;

        private readonly Stream _content;
        private readonly long _start;
        private readonly HttpContent _byteRangeContent;
        private bool _disposed;

        /// <summary>
        /// <see cref="HttpContent"/> implementation which provides a byte range view over a stream used to generate HTTP
        /// 206 (Partial Content) byte range responses. If none of the requested ranges overlap with the current extend
        /// of the selected resource represented by the <paramref name="content"/> parameter then an
        /// <see cref="InvalidByteRangeException"/> is thrown indicating the valid Content-Range of the content.
        /// </summary>
        /// <param name="content">The stream over which to generate a byte range view.</param>
        /// <param name="range">The range or ranges, typically obtained from the Range HTTP request header field.</param>
        /// <param name="mediaType">The media type of the content stream.</param>
        public ByteRangeStreamContent(Stream content, RangeHeaderValue range, string mediaType)
            : this(content, range, new MediaTypeHeaderValue(mediaType), DefaultBufferSize)
        {
        }

        /// <summary>
        /// <see cref="HttpContent"/> implementation which provides a byte range view over a stream used to generate HTTP
        /// 206 (Partial Content) byte range responses. If none of the requested ranges overlap with the current extend
        /// of the selected resource represented by the <paramref name="content"/> parameter then an
        /// <see cref="InvalidByteRangeException"/> is thrown indicating the valid Content-Range of the content.
        /// </summary>
        /// <param name="content">The stream over which to generate a byte range view.</param>
        /// <param name="range">The range or ranges, typically obtained from the Range HTTP request header field.</param>
        /// <param name="mediaType">The media type of the content stream.</param>
        /// <param name="bufferSize">The buffer size used when copying the content stream.</param>
        public ByteRangeStreamContent(Stream content, RangeHeaderValue range, string mediaType, int bufferSize)
            : this(content, range, new MediaTypeHeaderValue(mediaType), bufferSize)
        {
        }

        /// <summary>
        /// <see cref="HttpContent"/> implementation which provides a byte range view over a stream used to generate HTTP
        /// 206 (Partial Content) byte range responses. If none of the requested ranges overlap with the current extend
        /// of the selected resource represented by the <paramref name="content"/> parameter then an
        /// <see cref="InvalidByteRangeException"/> is thrown indicating the valid Content-Range of the content.
        /// </summary>
        /// <param name="content">The stream over which to generate a byte range view.</param>
        /// <param name="range">The range or ranges, typically obtained from the Range HTTP request header field.</param>
        /// <param name="mediaType">The media type of the content stream.</param>
        public ByteRangeStreamContent(Stream content, RangeHeaderValue range, MediaTypeHeaderValue mediaType)
            : this(content, range, mediaType, DefaultBufferSize)
        {
        }

        /// <summary>
        /// <see cref="HttpContent"/> implementation which provides a byte range view over a stream used to generate HTTP
        /// 206 (Partial Content) byte range responses. If none of the requested ranges overlap with the current extend
        /// of the selected resource represented by the <paramref name="content"/> parameter then an
        /// <see cref="InvalidByteRangeException"/> is thrown indicating the valid Content-Range of the content.
        /// </summary>
        /// <param name="content">The stream over which to generate a byte range view.</param>
        /// <param name="range">The range or ranges, typically obtained from the Range HTTP request header field.</param>
        /// <param name="mediaType">The media type of the content stream.</param>
        /// <param name="bufferSize">The buffer size used when copying the content stream.</param>
        public ByteRangeStreamContent(Stream content, RangeHeaderValue range, MediaTypeHeaderValue mediaType, int bufferSize)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }
            if (!content.CanSeek)
            {
                throw Error.Argument("content", Properties.Resources.ByteRangeStreamNotSeekable, typeof(ByteRangeStreamContent).Name);
            }
            if (range == null)
            {
                throw Error.ArgumentNull("range");
            }
            if (mediaType == null)
            {
                throw Error.ArgumentNull("mediaType");
            }
            if (bufferSize < MinBufferSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize);
            }
            if (!range.Unit.Equals(SupportedRangeUnit, StringComparison.OrdinalIgnoreCase))
            {
                throw Error.Argument("range", Properties.Resources.ByteRangeStreamContentNotBytesRange, range.Unit, SupportedRangeUnit);
            }

            try
            {
                // If we have more than one range then we use a multipart/byteranges content type as wrapper.
                // Otherwise we use a non-multipart response.
                if (range.Ranges.Count > 1)
                {
                    // Create Multipart content and copy headers to this content
                    MultipartContent rangeContent = new MultipartContent(ByteRangesContentSubtype);
                    _byteRangeContent = rangeContent;

                    foreach (RangeItemHeaderValue rangeValue in range.Ranges)
                    {
                        try
                        {
                            ByteRangeStream rangeStream = new ByteRangeStream(content, rangeValue);
                            HttpContent rangeBodyPart = new StreamContent(rangeStream, bufferSize);
                            rangeBodyPart.Headers.ContentType = mediaType;
                            rangeBodyPart.Headers.ContentRange = rangeStream.ContentRange;
                            rangeContent.Add(rangeBodyPart);
                        }
                        catch (ArgumentOutOfRangeException)
                        {
                            // We ignore range errors until we check that we have at least one valid range
                        }
                    }

                    // If no overlapping ranges were found then stop
                    if (!rangeContent.Any())
                    {
                        ContentRangeHeaderValue actualContentRange = new ContentRangeHeaderValue(content.Length);
                        string msg = Error.Format(Properties.Resources.ByteRangeStreamNoneOverlap, range.ToString());
                        throw new InvalidByteRangeException(actualContentRange, msg);
                    }
                }
                else if (range.Ranges.Count == 1)
                {
                    try
                    {
                        ByteRangeStream rangeStream = new ByteRangeStream(content, range.Ranges.First());
                        _byteRangeContent = new StreamContent(rangeStream, bufferSize);
                        _byteRangeContent.Headers.ContentType = mediaType;
                        _byteRangeContent.Headers.ContentRange = rangeStream.ContentRange;
                    }
                    catch (ArgumentOutOfRangeException)
                    {
                        ContentRangeHeaderValue actualContentRange = new ContentRangeHeaderValue(content.Length);
                        string msg = Error.Format(Properties.Resources.ByteRangeStreamNoOverlap, range.ToString());
                        throw new InvalidByteRangeException(actualContentRange, msg);
                    }
                }
                else
                {
                    throw Error.Argument("range", Properties.Resources.ByteRangeStreamContentNoRanges);
                }

                // Copy headers from byte range content so that we get the right content type etc.
                _byteRangeContent.Headers.CopyTo(Headers);

                _content = content;
                _start = content.Position;
            }
            catch
            {
                if (_byteRangeContent != null)
                {
                    _byteRangeContent.Dispose();
                }
                throw;
            }
        }

        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
        {
            // Reset stream to start position
            _content.Position = _start;

            // Copy result to output
            return _byteRangeContent.CopyToAsync(stream);
        }

        protected override bool TryComputeLength(out long length)
        {
            long? contentLength = _byteRangeContent.Headers.ContentLength;
            if (contentLength.HasValue)
            {
                length = contentLength.Value;
                return true;
            }

            length = -1;
            return false;
        }

        protected override void Dispose(bool disposing)
        {
            Contract.Assert(_byteRangeContent != null);
            if (disposing)
            {
                if (!_disposed)
                {
                    _byteRangeContent.Dispose();
                    _content.Dispose();
                    _disposed = true;
                }
            }
            base.Dispose(disposing);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/CloneableExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http
{
    internal static class CloneableExtensions
    {
        /// <summary>
        /// Convenience method for cloning objects that implement <see cref="ICloneable"/> explicitly.
        /// </summary>
        /// <typeparam name="T">The type of the cloneable object.</typeparam>
        /// <param name="value">The cloneable object.</param>
        /// <returns>The result of cloning the <paramref name="value"/>.</returns>
        internal static T Clone<T>(this T value) where T : ICloneable
        {
            return (T)value.Clone();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/BaseJsonMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Abstract <see cref="MediaTypeFormatter"/> class to support Bson and Json.
    /// </summary>
    public abstract class BaseJsonMediaTypeFormatter : MediaTypeFormatter
    {
        // Though MaxDepth is not supported in netstandard1.3, we still override JsonReader's MaxDepth
        private int _maxDepth = FormattingUtilities.DefaultMaxDepth;

        private readonly IContractResolver _defaultContractResolver;

        private JsonSerializerSettings _jsonSerializerSettings;

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseJsonMediaTypeFormatter"/> class.
        /// </summary>
        protected BaseJsonMediaTypeFormatter()
        {
            // Initialize serializer settings
            _defaultContractResolver = new JsonContractResolver(this);
            _jsonSerializerSettings = CreateDefaultSerializerSettings();

            // Set default supported character encodings
            SupportedEncodings.Add(new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));
            SupportedEncodings.Add(new UnicodeEncoding(bigEndian: false, byteOrderMark: true, throwOnInvalidBytes: true));
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="BaseJsonMediaTypeFormatter"/> class.
        /// </summary>
        /// <param name="formatter">The <see cref="BaseJsonMediaTypeFormatter"/> instance to copy settings from.</param>
        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors",
            Justification = "MaxDepth is sealed in existing subclasses and its documentation carries warnings.")]
        protected BaseJsonMediaTypeFormatter(BaseJsonMediaTypeFormatter formatter)
            : base(formatter)
        {
            Contract.Assert(formatter != null);
            SerializerSettings = formatter.SerializerSettings;

            MaxDepth = formatter._maxDepth;
        }

        /// <summary>
        /// Gets or sets the <see cref="JsonSerializerSettings"/> used to configure the <see cref="JsonSerializer"/>.
        /// </summary>
        public JsonSerializerSettings SerializerSettings
        {
            get { return _jsonSerializerSettings; }
            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }

                _jsonSerializerSettings = value;
            }
        }

        /// <summary>
        /// Gets or sets the maximum depth allowed by this formatter.
        /// </summary>
        /// <remarks>
        /// Any override must call the base getter and setter. The setter may be called before a derived class
        /// constructor runs, so any override should be very careful about using derived class state.
        /// </remarks>
        public virtual int MaxDepth
        {
            get
            {
                return _maxDepth;
            }
            set
            {
                if (value < FormattingUtilities.DefaultMinDepth)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, FormattingUtilities.DefaultMinDepth);
                }

                _maxDepth = value;
            }
        }

        /// <summary>
        /// Creates a <see cref="JsonSerializerSettings"/> instance with the default settings used by the <see cref="BaseJsonMediaTypeFormatter"/>.
        /// </summary>
        public JsonSerializerSettings CreateDefaultSerializerSettings()
        {
            return new JsonSerializerSettings()
            {
                ContractResolver = _defaultContractResolver,
                MissingMemberHandling = MissingMemberHandling.Ignore,

                // Do not change this setting
                // Setting this to None prevents Json.NET from loading malicious, unsafe, or security-sensitive types
                TypeNameHandling = TypeNameHandling.None
            };
        }

        /// <summary>
        /// Determines whether this <see cref="BaseJsonMediaTypeFormatter"/> can read objects
        /// of the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> of object that will be read.</param>
        /// <returns><c>true</c> if objects of this <paramref name="type"/> can be read, otherwise <c>false</c>.</returns>
        public override bool CanReadType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            return true;
        }

        /// <summary>
        /// Determines whether this <see cref="BaseJsonMediaTypeFormatter"/> can write objects
        /// of the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> of object that will be written.</param>
        /// <returns><c>true</c> if objects of this <paramref name="type"/> can be written, otherwise <c>false</c>.</returns>
        public override bool CanWriteType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            return true;
        }

        /// <summary>
        /// Called during deserialization to read an object of the specified <paramref name="type"/>
        /// from the specified <paramref name="readStream"/>.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> of object to read.</param>
        /// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
        /// <param name="content">The <see cref="HttpContent"/> for the content being written.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            try
            {
                return Task.FromResult(ReadFromStream(type, readStream, content, formatterLogger));
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError<object>(e);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "Caller's formatterLogger is notified of problem in all cases where Exception is not rethrown.")]
        private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            Contract.Assert(type != null);
            Contract.Assert(readStream != null);

            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;

            // If content length is 0 then return default value for this type
            if (contentHeaders != null && contentHeaders.ContentLength == 0)
            {
                return GetDefaultValueForType(type);
            }

            // Get the character encoding for the content
            // Never non-null since SelectCharacterEncoding() throws in error / not found scenarios
            Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);

            try
            {
                return ReadFromStream(type, readStream, effectiveEncoding, formatterLogger);
            }
            catch (Exception e)
            {
                if (formatterLogger == null)
                {
                    throw;
                }

                formatterLogger.LogError(String.Empty, e);
                return GetDefaultValueForType(type);
            }
        }

        /// <summary>
        /// Called during deserialization to read an object of the specified <paramref name="type"/>
        /// from the specified <paramref name="readStream"/>.
        /// </summary>
        /// <remarks>
        /// Public for delegating wrappers of this class.  Expected to be called only from
        /// <see cref="ReadFromStreamAsync"/>.
        /// </remarks>
        /// <param name="type">The <see cref="Type"/> of object to read.</param>
        /// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
        /// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when reading.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>The <see cref="object"/> instance that has been read.</returns>
        public virtual object ReadFromStream(Type type, Stream readStream, Encoding effectiveEncoding, IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            using (JsonReader jsonReader = CreateJsonReaderInternal(type, readStream, effectiveEncoding))
            {
                jsonReader.CloseInput = false;
                jsonReader.MaxDepth = _maxDepth;

                JsonSerializer jsonSerializer = CreateJsonSerializerInternal();

                EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs> errorHandler = null;
                if (formatterLogger != null)
                {
                    // Error must always be marked as handled
                    // Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes
                    errorHandler = (sender, e) =>
                    {
                        Exception exception = e.ErrorContext.Error;
                        formatterLogger.LogError(e.ErrorContext.Path, exception);
                        e.ErrorContext.Handled = true;
                    };
                    jsonSerializer.Error += errorHandler;
                }

                try
                {
                    return jsonSerializer.Deserialize(jsonReader, type);
                }
                finally
                {
                    if (errorHandler != null)
                    {
                        // Clean up the error handler in case CreateJsonSerializer() reuses a serializer
                        jsonSerializer.Error -= errorHandler;
                    }
                }
            }
        }

        private JsonReader CreateJsonReaderInternal(Type type, Stream readStream, Encoding effectiveEncoding)
        {
            Contract.Assert(type != null);
            Contract.Assert(readStream != null);
            Contract.Assert(effectiveEncoding != null);

            JsonReader reader = CreateJsonReader(type, readStream, effectiveEncoding);
            if (reader == null)
            {
                throw Error.InvalidOperation(Properties.Resources.MediaTypeFormatter_JsonReaderFactoryReturnedNull, "CreateJsonReader");
            }

            return reader;
        }

        /// <summary>
        /// Called during deserialization to get the <see cref="JsonReader"/>.
        /// </summary>
        /// <remarks>
        /// Public for delegating wrappers of this class.  Expected to be called only from
        /// <see cref="ReadFromStreamAsync"/>.
        /// </remarks>
        /// <param name="type">The <see cref="Type"/> of object to read.</param>
        /// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
        /// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when reading.</param>
        /// <returns>The <see cref="JsonWriter"/> used during deserialization.</returns>
        public abstract JsonReader CreateJsonReader(Type type, Stream readStream, Encoding effectiveEncoding);

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This is a public extensibility point, we can't predict what exceptions will come through")]
        private JsonSerializer CreateJsonSerializerInternal()
        {
            JsonSerializer serializer = null;
            try
            {
                serializer = CreateJsonSerializer();
            }
            catch (Exception exception)
            {
                throw Error.InvalidOperation(exception, Properties.Resources.JsonSerializerFactoryThrew, "CreateJsonSerializer");
            }

            if (serializer == null)
            {
                throw Error.InvalidOperation(Properties.Resources.JsonSerializerFactoryReturnedNull, "CreateJsonSerializer");
            }

            return serializer;
        }

        /// <summary>
        /// Called during serialization and deserialization to get the <see cref="JsonSerializer"/>.
        /// </summary>
        /// <remarks>
        /// Public for delegating wrappers of this class.  Expected to be called only from
        /// <see cref="ReadFromStreamAsync"/> and <see cref="WriteToStreamAsync"/>.
        /// </remarks>
        /// <returns>The <see cref="JsonSerializer"/> used during serialization and deserialization.</returns>
        public virtual JsonSerializer CreateJsonSerializer()
        {
            JsonSerializer jsonSerializer = JsonSerializer.Create(SerializerSettings);
            return jsonSerializer;
        }

        /// <inheritdoc />
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }
            if (cancellationToken.IsCancellationRequested)
            {
                return TaskHelpers.Canceled();
            }

            try
            {
                WriteToStream(type, value, writeStream, content);
                return TaskHelpers.Completed();
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError(e);
            }
        }

        private void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
        {
            Contract.Assert(type != null);
            Contract.Assert(writeStream != null);

            Encoding effectiveEncoding = SelectCharacterEncoding(content == null ? null : content.Headers);
            WriteToStream(type, value, writeStream, effectiveEncoding);
        }

        /// <summary>
        /// Called during serialization to write an object of the specified <paramref name="type"/>
        /// to the specified <paramref name="writeStream"/>.
        /// </summary>
        /// <remarks>
        /// Public for delegating wrappers of this class.  Expected to be called only from
        /// <see cref="WriteToStreamAsync"/>.
        /// </remarks>
        /// <param name="type">The <see cref="Type"/> of object to write.</param>
        /// <param name="value">The object to write.</param>
        /// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when writing.</param>
        public virtual void WriteToStream(Type type, object value, Stream writeStream, Encoding effectiveEncoding)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            using (JsonWriter jsonWriter = CreateJsonWriterInternal(type, writeStream, effectiveEncoding))
            {
                jsonWriter.CloseOutput = false;

                JsonSerializer jsonSerializer = CreateJsonSerializerInternal();
                jsonSerializer.Serialize(jsonWriter, value);
                jsonWriter.Flush();
            }
        }

        private JsonWriter CreateJsonWriterInternal(Type type, Stream writeStream, Encoding effectiveEncoding)
        {
            Contract.Assert(type != null);
            Contract.Assert(writeStream != null);
            Contract.Assert(effectiveEncoding != null);

            JsonWriter writer = CreateJsonWriter(type, writeStream, effectiveEncoding);
            if (writer == null)
            {
                throw Error.InvalidOperation(Properties.Resources.MediaTypeFormatter_JsonWriterFactoryReturnedNull, "CreateJsonWriter");
            }

            return writer;
        }

        /// <summary>
        /// Called during serialization to get the <see cref="JsonWriter"/>.
        /// </summary>
        /// <remarks>
        /// Public for delegating wrappers of this class.  Expected to be called only from
        /// <see cref="WriteToStreamAsync"/>.
        /// </remarks>
        /// <param name="type">The <see cref="Type"/> of object to write.</param>
        /// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="effectiveEncoding">The <see cref="Encoding"/> to use when writing.</param>
        /// <returns>The <see cref="JsonWriter"/> used during serialization.</returns>
        public abstract JsonWriter CreateJsonWriter(Type type, Stream writeStream, Encoding effectiveEncoding);
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/BsonMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Bson;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// <see cref="MediaTypeFormatter"/> class to handle Bson.
    /// </summary>
    public class BsonMediaTypeFormatter : BaseJsonMediaTypeFormatter
    {
        private static readonly Type OpenDictionaryType = typeof(Dictionary<,>);

        /// <summary>
        /// Initializes a new instance of the <see cref="BsonMediaTypeFormatter"/> class.
        /// </summary>
        public BsonMediaTypeFormatter()
        {
            // Set default supported media type
            SupportedMediaTypes.Add(MediaTypeConstants.ApplicationBsonMediaType);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="BsonMediaTypeFormatter"/> class.
        /// </summary>
        /// <param name="formatter">The <see cref="BsonMediaTypeFormatter"/> instance to copy settings from.</param>
        protected BsonMediaTypeFormatter(BsonMediaTypeFormatter formatter)
            : base(formatter)
        {
        }

        /// <summary>
        /// Gets the default media type for Json, namely "application/bson".
        /// </summary>
        /// <remarks>
        /// The default media type does not have any <c>charset</c> parameter as
        /// the <see cref="Encoding"/> can be configured on a per <see cref="BsonMediaTypeFormatter"/>
        /// instance basis.
        /// </remarks>
        /// <value>
        /// Because <see cref="MediaTypeHeaderValue"/> is mutable, the value
        /// returned will be a new instance every time.
        /// </value>
        public static MediaTypeHeaderValue DefaultMediaType
        {
            get
            {
                return MediaTypeConstants.ApplicationBsonMediaType;
            }
        }

        /// <inheritdoc />
        public sealed override int MaxDepth
        {
            get
            {
                return base.MaxDepth;
            }
            set
            {
                base.MaxDepth = value;
            }
        }

        /// <inheritdoc />
        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            if (type == typeof(DBNull) && content != null && content.Headers != null && content.Headers.ContentLength == 0)
            {
                // Lower-level Json.Net deserialization can convert null to DBNull.Value. However this formatter treats
                // DBNull.Value like null and serializes no content. Json.Net code won't be invoked at all (for read or
                // write). Override BaseJsonMediaTypeFormatter.ReadFromStream()'s call to GetDefaultValueForType()
                // (which would return null in this case) and instead return expected DBNull.Value. Special case exists
                // primarily for parity with JsonMediaTypeFormatter.
                return Task.FromResult((object)DBNull.Value);
            }
            else
            {
                return base.ReadFromStreamAsync(type, readStream, content, formatterLogger);
            }
        }

        /// <inheritdoc />
        public override object ReadFromStream(Type type, Stream readStream, Encoding effectiveEncoding,
            IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            // Special-case for simple types: Deserialize a Dictionary with a single element named Value.
            // Serialization created this Dictionary<string, object> to work around BSON restrictions: BSON cannot
            // handle a top-level simple type.  NewtonSoft.Json throws a JsonWriterException with message "Error
            // writing Binary value. BSON must start with an Object or Array. Path ''." when WriteToStream() is given
            // such a value.
            //
            // Added clause for typeof(byte[]) needed because NewtonSoft.Json sometimes throws above Exception when
            // WriteToStream() is given a byte[] value.  (Not clear where the bug lies and, worse, it doesn't reproduce
            // reliably.)
            //
            // Request for typeof(object) may cause a simple value to round trip as a JObject.
            if (IsSimpleType(type) || type == typeof(byte[]))
            {
                // Read as exact expected Dictionary<string, T> to ensure NewtonSoft.Json does correct top-level conversion.
                Type dictionaryType = OpenDictionaryType.MakeGenericType(new Type[] { typeof(string), type });
                IDictionary dictionary =
                    base.ReadFromStream(dictionaryType, readStream, effectiveEncoding, formatterLogger) as IDictionary;
                if (dictionary == null)
                {
                    // Not valid since BaseJsonMediaTypeFormatter.ReadFromStream(Type, Stream, HttpContent, IFormatterLogger)
                    // handles empty content and does not call ReadFromStream(Type, Stream, Encoding, IFormatterLogger)
                    // in that case.
                    throw Error.InvalidOperation(Properties.Resources.MediaTypeFormatter_BsonParseError_MissingData,
                        dictionaryType.Name);
                }

                // Unfortunately IDictionary doesn't have TryGetValue()...
                string firstKey = String.Empty;
                foreach (DictionaryEntry item in dictionary)
                {
                    if (dictionary.Count == 1 && (item.Key as string) == "Value")
                    {
                        // Success
                        return item.Value;
                    }
                    else
                    {
                        if (item.Key != null)
                        {
                            firstKey = item.Key.ToString();
                        }

                        break;
                    }
                }

                throw Error.InvalidOperation(Properties.Resources.MediaTypeFormatter_BsonParseError_UnexpectedData,
                    dictionary.Count, firstKey);
            }
            else
            {
                return base.ReadFromStream(type, readStream, effectiveEncoding, formatterLogger);
            }
        }

        /// <inheritdoc />
        public override JsonReader CreateJsonReader(Type type, Stream readStream, Encoding effectiveEncoding)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            BsonDataReader reader = new BsonDataReader(new BinaryReader(readStream, effectiveEncoding));

            try
            {
                // Special case discussed at http://stackoverflow.com/questions/16910369/bson-array-deserialization-with-json-net
                // Dispensed with string (aka IEnumerable<char>) case above in ReadFromStream()
                reader.ReadRootValueAsArray =
                    typeof(IEnumerable).IsAssignableFrom(type) && !typeof(IDictionary).IsAssignableFrom(type);
            }
            catch
            {
                // Ensure instance is cleaned up in case of an issue
                ((IDisposable)reader).Dispose();
                throw;
            }

            return reader;
        }

        /// <inheritdoc />
        public override void WriteToStream(Type type, object value, Stream writeStream, Encoding effectiveEncoding)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            if (value == null)
            {
                // Cannot serialize null at the top level. Json.Net throws Newtonsoft.Json.JsonWriterException : Error
                // writing Null value. BSON must start with an Object or Array. Path ''. Fortunately
                // BaseJsonMediaTypeFormatter.ReadFromStream(Type, Stream, HttpContent, IFormatterLogger) treats zero-
                // length content as null or the default value of a struct.
                return;
            }

            if (value == DBNull.Value)
            {
                // ReadFromStreamAsync() override above converts null to DBNull.Value if given Type is DBNull; normally
                // however DBNull.Value round-trips as null. There's a known edge case where a full .NET application
                // uses the portable version of this formatter. The full .NET application may pass DBNull.Value,
                // leading to a JsonWriterException. If a DBNull is at a lower level in the value, the portable
                // Json.Net assembly will also fail to special-case that DBNull, serialize it as an empty JSON object
                // rather than null, and not meet the receiver's expectations.
                return;
            }

            // See comments in ReadFromStream() above about this special case and the need to include byte[] in it.
            // Using runtime type here because Json.Net will throw during serialization whenever it cannot handle the
            // runtime type at the top level. For e.g. passed type may be typeof(object) and value may be a string.
            Type runtimeType = value.GetType();
            if (IsSimpleType(runtimeType) || runtimeType == typeof(byte[]))
            {
                // Wrap value in a Dictionary with a single property named "Value" to provide BSON with an Object.  Is
                // written out as binary equivalent of { "Value": value } JSON.
                Dictionary<string, object> temporaryDictionary = new Dictionary<string, object>
                {
                    { "Value", value },
                };
                base.WriteToStream(typeof(Dictionary<string, object>), temporaryDictionary, writeStream, effectiveEncoding);
            }
            else
            {
                base.WriteToStream(type, value, writeStream, effectiveEncoding);
            }
        }

        /// <inheritdoc />
        public override JsonWriter CreateJsonWriter(Type type, Stream writeStream, Encoding effectiveEncoding)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            return new BsonDataWriter(new BinaryWriter(writeStream, effectiveEncoding));
        }

        // Return true if Json.Net will likely convert value of given type to a Json primitive, not JsonArray nor
        // JsonObject.
        // To do: https://aspnetwebstack.codeplex.com/workitem/1467
        private static bool IsSimpleType(Type type)
        {
            Contract.Assert(type != null);

            // CanConvertFrom() check is similar to MVC / Web API ModelMetadata.IsComplexType getters. This is
            // sufficient for many cases but Json.Net uses JsonConverterAttribute and built-in converters, not type
            // descriptors.
            bool isSimpleType = TypeDescriptor.GetConverter(type).CanConvertFrom(typeof(string));

            return isSimpleType;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/BufferedMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Headers;
using System.Net.Http.Internal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Base class for writing a synchronous formatter on top of the asynchronous formatter infrastructure.
    /// This does not guarantee non-blocking threads. The only way to guarantee that we don't block a thread on IO is
    /// to use the asynchronous <see cref="MediaTypeFormatter"/>.
    /// </summary>
    public abstract class BufferedMediaTypeFormatter : MediaTypeFormatter
    {
        private const int MinBufferSize = 0;
        private const int DefaultBufferSize = 16 * 1024;

        private int _bufferSizeInBytes = DefaultBufferSize;

        /// <summary>
        /// Initializes a new instance of the <see cref="BufferedMediaTypeFormatter"/> class.
        /// </summary>
        protected BufferedMediaTypeFormatter()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="BufferedMediaTypeFormatter"/> class.
        /// </summary>
        /// <param name="formatter">The <see cref="BufferedMediaTypeFormatter"/> instance to copy settings from.</param>
        protected BufferedMediaTypeFormatter(BufferedMediaTypeFormatter formatter)
            : base(formatter)
        {
            BufferSize = formatter.BufferSize;
        }

        /// <summary>
        /// Suggested size of buffer to use with streams, in bytes. The default size is 16K.
        /// </summary>
        public int BufferSize
        {
            get { return _bufferSizeInBytes; }
            set
            {
                if (value < MinBufferSize)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinBufferSize);
                }
                _bufferSizeInBytes = value;
            }
        }

        /// <summary>
        /// Writes synchronously to the buffered stream.
        /// </summary>
        /// <remarks>
        /// An implementation of this method should close <paramref name="writeStream"/> upon completion.
        /// </remarks>
        /// <param name="type">The type of the object to write.</param>
        /// <param name="value">The object value to write.  It may be <c>null</c>.</param>
        /// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available. Note that
        /// modifying the headers of the content will have no effect on the generated HTTP message; they should only be used to guide the writing.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        public virtual void WriteToStream(Type type, object value, Stream writeStream, HttpContent content,
            CancellationToken cancellationToken)
        {
            WriteToStream(type, value, writeStream, content);
        }

        /// <summary>
        /// Writes synchronously to the buffered stream.
        /// </summary>
        /// <remarks>
        /// An implementation of this method should close <paramref name="writeStream"/> upon completion.
        /// </remarks>
        /// <param name="type">The type of the object to write.</param>
        /// <param name="value">The object value to write.  It may be <c>null</c>.</param>
        /// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available. Note that
        /// modifying the headers of the content will have no effect on the generated HTTP message; they should only be used to guide the writing.</param>
        public virtual void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
        {
            throw Error.NotSupported(Properties.Resources.MediaTypeFormatterCannotWriteSync, GetType().Name);
        }

        /// <summary>
        /// Reads synchronously from the buffered stream.
        /// </summary>
        /// <remarks>
        /// An implementation of this method should close <paramref name="readStream"/> upon completion.
        /// </remarks>
        /// <param name="type">The type of the object to deserialize.</param>
        /// <param name="readStream">The <see cref="Stream"/> to read.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>An object of the given type.</returns>
        public virtual object ReadFromStream(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return ReadFromStream(type, readStream, content, formatterLogger);
        }

        /// <summary>
        /// Reads synchronously from the buffered stream.
        /// </summary>
        /// <remarks>
        /// An implementation of this method should close <paramref name="readStream"/> upon completion.
        /// </remarks>
        /// <param name="type">The type of the object to deserialize.</param>
        /// <param name="readStream">The <see cref="Stream"/> to read.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>An object of the given type.</returns>
        public virtual object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            throw Error.NotSupported(Properties.Resources.MediaTypeFormatterCannotReadSync, GetType().Name);
        }

        // Sealed because derived classes shouldn't override the async version. Override sync version instead.
        public sealed override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext)
        {
            return WriteToStreamAsync(type, value, writeStream, content, transportContext, CancellationToken.None);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public sealed override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }

            try
            {
                WriteToStreamSync(type, value, writeStream, content, cancellationToken);
                return TaskHelpers.Completed();
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError(e);
            }
        }

        private void WriteToStreamSync(Type type, object value, Stream writeStream, HttpContent content,
            CancellationToken cancellationToken)
        {
            using (Stream bufferedStream = GetBufferStream(writeStream, _bufferSizeInBytes))
            {
                WriteToStream(type, value, bufferedStream, content, cancellationToken);
            }
        }

        public sealed override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger)
        {
            return ReadFromStreamAsync(type, readStream, content, formatterLogger, CancellationToken.None);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public sealed override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            try
            {
                return Task.FromResult(ReadFromStreamSync(type, readStream, content, formatterLogger, cancellationToken));
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError<object>(e);
            }
        }

        private object ReadFromStreamSync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger,
            CancellationToken cancellationToken)
        {
            object result;
            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
            if (contentHeaders != null && contentHeaders.ContentLength == 0)
            {
                result = GetDefaultValueForType(type);
            }
            else
            {
                using (Stream bufferedStream = GetBufferStream(readStream, _bufferSizeInBytes))
                {
                    result = ReadFromStream(type, bufferedStream, content, formatterLogger, cancellationToken);
                }
            }
            return result;
        }

        private static Stream GetBufferStream(Stream innerStream, int bufferSize)
        {
            Contract.Assert(innerStream != null);

            // We wrap the inner stream in a non-closing delegating stream so that we allow the user
            // to use the using (...) pattern yet not break the contract of formatters not closing
            // the inner stream.
            Stream nonClosingStream = new NonClosingDelegatingStream(innerStream);

            // This uses a naive buffering. BufferedStream() will block the thread while it drains the buffer.
            // We can explore a smarter implementation that async drains the buffer.
            return new BufferedStream(nonClosingStream, bufferSize);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/ContentNegotiationResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Represents the result of content negotiation performed using
    /// <see cref="IContentNegotiator.Negotiate(Type, HttpRequestMessage, IEnumerable{MediaTypeFormatter})"/>
    /// </summary>
    public class ContentNegotiationResult
    {
        private MediaTypeFormatter _formatter;

        /// <summary>
        /// Create the content negotiation result object.
        /// </summary>
        /// <param name="formatter">The formatter.</param>
        /// <param name="mediaType">The preferred media type. Can be <c>null</c>.</param>
        public ContentNegotiationResult(MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            _formatter = formatter;
            MediaType = mediaType;
        }

        /// <summary>
        /// The formatter chosen for serialization.
        /// </summary>
        public MediaTypeFormatter Formatter
        {
            get { return _formatter; }
            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }
                _formatter = value;
            }
        }

        /// <summary>
        /// The media type that is associated with the formatter chosen for serialization. Can be <c>null</c>.
        /// </summary>
        public MediaTypeHeaderValue MediaType { get; set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/DefaultContentNegotiator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http.Headers;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Class that selects a <see cref="MediaTypeFormatter"/> for an <see cref="HttpRequestMessage"/>
    /// or <see cref="HttpResponseMessage"/>.
    /// </summary>
    public class DefaultContentNegotiator : IContentNegotiator
    {
        public DefaultContentNegotiator()
            : this(false)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultContentNegotiator"/> with
        /// the given setting for <paramref name="excludeMatchOnTypeOnly"/>.
        /// </summary>
        /// <param name="excludeMatchOnTypeOnly">
        /// If ExcludeMatchOnTypeOnly is true then we don't match on type only which means
        /// that we return null if we can't match on anything in the request. This is useful
        /// for generating 406 (Not Acceptable) status codes.
        /// </param>
        public DefaultContentNegotiator(bool excludeMatchOnTypeOnly)
        {
            ExcludeMatchOnTypeOnly = excludeMatchOnTypeOnly;
        }

        /// <summary>
        /// If ExcludeMatchOnTypeOnly is true then we don't match on type only which means
        /// that we return null if we can't match on anything in the request. This is useful
        /// for generating 406 (Not Acceptable) status codes.
        /// </summary>
        public bool ExcludeMatchOnTypeOnly { get; private set; }

        /// <summary>
        /// Performs content negotiating by selecting the most appropriate <see cref="MediaTypeFormatter"/> out of the passed in
        /// <paramref name="formatters"/> for the given <paramref name="request"/> that can serialize an object of the given
        /// <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The type to be serialized.</param>
        /// <param name="request">The request.</param>
        /// <param name="formatters">The set of <see cref="MediaTypeFormatter"/> objects from which to choose.</param>
        /// <returns>The result of the negotiation containing the most appropriate <see cref="MediaTypeFormatter"/> instance,
        /// or <c>null</c> if there is no appropriate formatter.</returns>
        public virtual ContentNegotiationResult Negotiate(Type type, HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
        {
            // Performance-sensitive
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (formatters == null)
            {
                throw Error.ArgumentNull("formatters");
            }

            // Go through each formatter to compute how well it matches.
            Collection<MediaTypeFormatterMatch> matches = ComputeFormatterMatches(type, request, formatters);

            // Select best formatter match among the matches
            MediaTypeFormatterMatch bestFormatterMatch = SelectResponseMediaTypeFormatter(matches);

            // We found a best formatter
            if (bestFormatterMatch != null)
            {
                // Find the best character encoding for the selected formatter
                Encoding bestEncodingMatch = SelectResponseCharacterEncoding(request, bestFormatterMatch.Formatter);
                if (bestEncodingMatch != null)
                {
                    bestFormatterMatch.MediaType.CharSet = bestEncodingMatch.WebName;
                }

                MediaTypeHeaderValue bestMediaType = bestFormatterMatch.MediaType;
                MediaTypeFormatter bestFormatter = bestFormatterMatch.Formatter.GetPerRequestFormatterInstance(type, request, bestMediaType);
                return new ContentNegotiationResult(bestFormatter, bestMediaType);
            }

            return null;
        }

        /// <summary>
        /// Determine how well each formatter matches by associating a <see cref="MediaTypeFormatterMatchRanking"/> value
        /// with the formatter. Then associate the quality of the match based on q-factors and other parameters. The result of this
        /// method is a collection of the matches found categorized and assigned a quality value.
        /// </summary>
        /// <param name="type">The type to be serialized.</param>
        /// <param name="request">The request.</param>
        /// <param name="formatters">The set of <see cref="MediaTypeFormatter"/> objects from which to choose.</param>
        /// <returns>A collection containing all the matches.</returns>
        protected virtual Collection<MediaTypeFormatterMatch> ComputeFormatterMatches(Type type, HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
        {
            // Performance-sensitive
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (formatters == null)
            {
                throw Error.ArgumentNull("formatters");
            }

            IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues = null;

            // Go through each formatter to find how well it matches.
            ListWrapperCollection<MediaTypeFormatterMatch> matches = new ListWrapperCollection<MediaTypeFormatterMatch>();
            MediaTypeFormatter[] writingFormatters = GetWritingFormatters(formatters);
            for (int i = 0; i < writingFormatters.Length; i++)
            {
                MediaTypeFormatter formatter = writingFormatters[i];
                MediaTypeFormatterMatch match = null;

                // Check first that formatter can write the actual type
                if (!formatter.CanWriteType(type))
                {
                    // Formatter can't even write the type so no match at all
                    continue;
                }

                // Match against media type mapping.
                if ((match = MatchMediaTypeMapping(request, formatter)) != null)
                {
                    matches.Add(match);
                    continue;
                }

                // Match against the accept header values.
                if (sortedAcceptValues == null)
                {
                    // Sort the Accept header values in descending order based on q-factor
                    sortedAcceptValues = SortMediaTypeWithQualityHeaderValuesByQFactor(request.Headers.Accept);
                }
                if ((match = MatchAcceptHeader(sortedAcceptValues, formatter)) != null)
                {
                    matches.Add(match);
                    continue;
                }

                // Match against request's media type if any
                if ((match = MatchRequestMediaType(request, formatter)) != null)
                {
                    matches.Add(match);
                    continue;
                }

                // Check whether we should match on type or stop the matching process.
                // The latter is used to generate 406 (Not Acceptable) status codes.
                bool shouldMatchOnType = ShouldMatchOnType(sortedAcceptValues);

                // Match against the type of object we are writing out
                if (shouldMatchOnType && (match = MatchType(type, formatter)) != null)
                {
                    matches.Add(match);
                    continue;
                }
            }

            return matches;
        }

        /// <summary>
        /// Select the best match among the candidate matches found.
        /// </summary>
        /// <param name="matches">The collection of matches.</param>
        /// <returns>The <see cref="MediaTypeFormatterMatch"/> determined to be the best match.</returns>
        protected virtual MediaTypeFormatterMatch SelectResponseMediaTypeFormatter(ICollection<MediaTypeFormatterMatch> matches)
        {
            // Performance-sensitive
            if (matches == null)
            {
                throw Error.ArgumentNull("matches");
            }

            List<MediaTypeFormatterMatch> matchList = matches.AsList();

            MediaTypeFormatterMatch bestMatchOnType = null;
            MediaTypeFormatterMatch bestMatchOnAcceptHeaderLiteral = null;
            MediaTypeFormatterMatch bestMatchOnAcceptHeaderSubtypeMediaRange = null;
            MediaTypeFormatterMatch bestMatchOnAcceptHeaderAllMediaRange = null;
            MediaTypeFormatterMatch bestMatchOnMediaTypeMapping = null;
            MediaTypeFormatterMatch bestMatchOnRequestMediaType = null;

            // Go through each formatter to find the best match in each category.
            for (int i = 0; i < matchList.Count; i++)
            {
                MediaTypeFormatterMatch match = matchList[i];
                switch (match.Ranking)
                {
                    case MediaTypeFormatterMatchRanking.MatchOnCanWriteType:
                        // First match by type trumps all other type matches
                        if (bestMatchOnType == null)
                        {
                            bestMatchOnType = match;
                        }
                        break;

                    case MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping:
                        // Matches on accept headers using mappings must choose the highest quality match
                        bestMatchOnMediaTypeMapping = UpdateBestMatch(bestMatchOnMediaTypeMapping, match);
                        break;

                    case MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral:
                        // Matches on accept headers must choose the highest quality match.
                        // A match of 0.0 means we won't use it at all.
                        bestMatchOnAcceptHeaderLiteral = UpdateBestMatch(bestMatchOnAcceptHeaderLiteral, match);
                        break;

                    case MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange:
                        // Matches on accept headers must choose the highest quality match.
                        // A match of 0.0 means we won't use it at all.
                        bestMatchOnAcceptHeaderSubtypeMediaRange = UpdateBestMatch(bestMatchOnAcceptHeaderSubtypeMediaRange, match);
                        break;

                    case MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange:
                        // Matches on accept headers must choose the highest quality match.
                        // A match of 0.0 means we won't use it at all.
                        bestMatchOnAcceptHeaderAllMediaRange = UpdateBestMatch(bestMatchOnAcceptHeaderAllMediaRange, match);
                        break;

                    case MediaTypeFormatterMatchRanking.MatchOnRequestMediaType:
                        // First match on request content type trumps other request content matches
                        if (bestMatchOnRequestMediaType == null)
                        {
                            bestMatchOnRequestMediaType = match;
                        }
                        break;
                }
            }

            // If we received matches based on both supported media types and from media type mappings,
            // we want to give precedence to the media type mappings, but only if their quality is >= that of the supported media type.
            // We do this because media type mappings are the user's extensibility point and must take precedence over normal
            // supported media types in the case of a tie. The 99% case is where both have quality 1.0.
            if (bestMatchOnMediaTypeMapping != null)
            {
                MediaTypeFormatterMatch mappingOverride = bestMatchOnMediaTypeMapping;
                mappingOverride = UpdateBestMatch(mappingOverride, bestMatchOnAcceptHeaderLiteral);
                mappingOverride = UpdateBestMatch(mappingOverride, bestMatchOnAcceptHeaderSubtypeMediaRange);
                mappingOverride = UpdateBestMatch(mappingOverride, bestMatchOnAcceptHeaderAllMediaRange);
                if (mappingOverride != bestMatchOnMediaTypeMapping)
                {
                    bestMatchOnMediaTypeMapping = null;
                }
            }

            // now select the formatter and media type
            // A MediaTypeMapping is highest precedence -- it is an extensibility point
            // allowing the user to override normal accept header matching
            MediaTypeFormatterMatch bestMatch = null;
            if (bestMatchOnMediaTypeMapping != null)
            {
                bestMatch = bestMatchOnMediaTypeMapping;
            }
            else if (bestMatchOnAcceptHeaderLiteral != null ||
                bestMatchOnAcceptHeaderSubtypeMediaRange != null ||
                bestMatchOnAcceptHeaderAllMediaRange != null)
            {
                bestMatch = UpdateBestMatch(bestMatch, bestMatchOnAcceptHeaderLiteral);
                bestMatch = UpdateBestMatch(bestMatch, bestMatchOnAcceptHeaderSubtypeMediaRange);
                bestMatch = UpdateBestMatch(bestMatch, bestMatchOnAcceptHeaderAllMediaRange);
            }
            else if (bestMatchOnRequestMediaType != null)
            {
                bestMatch = bestMatchOnRequestMediaType;
            }
            else if (bestMatchOnType != null)
            {
                bestMatch = bestMatchOnType;
            }

            return bestMatch;
        }

        /// <summary>
        /// Determine the best character encoding for writing the response. First we look
        /// for accept-charset headers and if not found then we try to match
        /// any charset encoding in the request (in case of PUT, POST, etc.)
        /// If no encoding is found then we use the default for the formatter.
        /// </summary>
        /// <returns>The <see cref="Encoding"/> determined to be the best match.</returns>
        protected virtual Encoding SelectResponseCharacterEncoding(HttpRequestMessage request, MediaTypeFormatter formatter)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            // If there are any SupportedEncodings then we pick an encoding
            List<Encoding> supportedEncodings = formatter.SupportedEncodingsInternal;
            if (supportedEncodings.Count > 0)
            {
                // Sort Accept-Charset header values
                IEnumerable<StringWithQualityHeaderValue> sortedAcceptCharsetValues = SortStringWithQualityHeaderValuesByQFactor(request.Headers.AcceptCharset);

                // Check for match based on accept-charset headers
                foreach (StringWithQualityHeaderValue acceptCharset in sortedAcceptCharsetValues)
                {
                    for (int i = 0; i < supportedEncodings.Count; i++)
                    {
                        Encoding encoding = supportedEncodings[i];
                        if (encoding != null && acceptCharset.Quality != FormattingUtilities.NoMatch &&
                            (acceptCharset.Value.Equals(encoding.WebName, StringComparison.OrdinalIgnoreCase) ||
                            acceptCharset.Value.Equals("*", StringComparison.OrdinalIgnoreCase)))
                        {
                            return encoding;
                        }
                    }
                }

                // Check for match based on any request entity body
                return formatter.SelectCharacterEncoding(request.Content != null ? request.Content.Headers : null);
            }

            return null;
        }

        /// <summary>
        /// Match a request against the <see cref="MediaTypeMapping"/>s registered with the formatter.
        /// </summary>
        /// <param name="request">The request to match.</param>
        /// <param name="formatter">The formatter to match against.</param>
        /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
        protected virtual MediaTypeFormatterMatch MatchMediaTypeMapping(HttpRequestMessage request, MediaTypeFormatter formatter)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            List<MediaTypeMapping> mediaTypeMappings = formatter.MediaTypeMappingsInternal;
            for (int i = 0; i < mediaTypeMappings.Count; i++)
            {
                MediaTypeMapping mapping = mediaTypeMappings[i];
                double quality;
                if (mapping != null && ((quality = mapping.TryMatchMediaType(request)) > FormattingUtilities.NoMatch))
                {
                    return new MediaTypeFormatterMatch(formatter, mapping.MediaType, quality, MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping);
                }
            }

            return null;
        }

        /// <summary>
        /// Match the request accept header field values against the formatter's registered supported media types.
        /// </summary>
        /// <param name="sortedAcceptValues">The sorted accept header values to match.</param>
        /// <param name="formatter">The formatter to match against.</param>
        /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
        protected virtual MediaTypeFormatterMatch MatchAcceptHeader(IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues, MediaTypeFormatter formatter)
        {
            if (sortedAcceptValues == null)
            {
                throw Error.ArgumentNull("sortedAcceptValues");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            foreach (MediaTypeWithQualityHeaderValue acceptMediaTypeValue in sortedAcceptValues)
            {
                List<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypesInternal;
                for (int i = 0; i < supportedMediaTypes.Count; i++)
                {
                    MediaTypeHeaderValue supportedMediaType = supportedMediaTypes[i];
                    MediaTypeHeaderValueRange range;
                    if (supportedMediaType != null && acceptMediaTypeValue.Quality != FormattingUtilities.NoMatch &&
                        supportedMediaType.IsSubsetOf(acceptMediaTypeValue, out range))
                    {
                        MediaTypeFormatterMatchRanking ranking;
                        switch (range)
                        {
                            case MediaTypeHeaderValueRange.AllMediaRange:
                                ranking = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange;
                                break;

                            case MediaTypeHeaderValueRange.SubtypeMediaRange:
                                ranking = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange;
                                break;

                            default:
                                ranking = MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral;
                                break;
                        }

                        return new MediaTypeFormatterMatch(formatter, supportedMediaType, acceptMediaTypeValue.Quality, ranking);
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Match any request media type (in case there is a request entity body) against the formatter's registered
        /// media types.
        /// </summary>
        /// <param name="request">The request to match.</param>
        /// <param name="formatter">The formatter to match against.</param>
        /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
        protected virtual MediaTypeFormatterMatch MatchRequestMediaType(HttpRequestMessage request, MediaTypeFormatter formatter)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            if (request.Content != null)
            {
                MediaTypeHeaderValue requestMediaType = request.Content.Headers.ContentType;
                if (requestMediaType != null)
                {
                    List<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypesInternal;
                    for (int i = 0; i < supportedMediaTypes.Count; i++)
                    {
                        MediaTypeHeaderValue supportedMediaType = supportedMediaTypes[i];
                        if (supportedMediaType != null && supportedMediaType.IsSubsetOf(requestMediaType))
                        {
                            return new MediaTypeFormatterMatch(formatter, supportedMediaType, FormattingUtilities.Match, MediaTypeFormatterMatchRanking.MatchOnRequestMediaType);
                        }
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Determine whether to match on type or not. This is used to determine whether to
        /// generate a 406 response or use the default media type formatter in case there
        /// is no match against anything in the request. If ExcludeMatchOnTypeOnly is true
        /// then we don't match on type unless there are no accept headers.
        /// </summary>
        /// <param name="sortedAcceptValues">The sorted accept header values to match.</param>
        /// <returns>True if not ExcludeMatchOnTypeOnly and accept headers with a q-factor bigger than 0.0 are present.</returns>
        protected virtual bool ShouldMatchOnType(IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues)
        {
            if (sortedAcceptValues == null)
            {
                throw Error.ArgumentNull("sortedAcceptValues");
            }

            return !(ExcludeMatchOnTypeOnly && sortedAcceptValues.Any());
        }

        /// <summary>
        /// Pick the first supported media type and indicate we've matched only on type
        /// </summary>
        /// <param name="type">The type to be serialized.</param>
        /// <param name="formatter">The formatter we are matching against.</param>
        /// <returns>A <see cref="MediaTypeFormatterMatch"/> indicating the quality of the match or null is no match.</returns>
        protected virtual MediaTypeFormatterMatch MatchType(Type type, MediaTypeFormatter formatter)
        {
            // Performance-sensitive
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            // We already know that we do match on type -- otherwise we wouldn't even be called --
            // so this is just a matter of determining how we match.
            MediaTypeHeaderValue mediaType = null;
            List<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypesInternal;
            if (supportedMediaTypes.Count > 0)
            {
                mediaType = supportedMediaTypes[0];
            }
            return new MediaTypeFormatterMatch(formatter, mediaType, FormattingUtilities.Match, MediaTypeFormatterMatchRanking.MatchOnCanWriteType);
        }

        /// <summary>
        /// Sort Accept header values and related header field values with similar syntax rules
        /// (if more than 1) in descending order based on q-factor.
        /// </summary>
        /// <param name="headerValues">The header values to sort.</param>
        /// <returns>The sorted header values.</returns>
        protected virtual IEnumerable<MediaTypeWithQualityHeaderValue> SortMediaTypeWithQualityHeaderValuesByQFactor(ICollection<MediaTypeWithQualityHeaderValue> headerValues)
        {
            if (headerValues == null)
            {
                throw Error.ArgumentNull("headerValues");
            }

            if (headerValues.Count > 1)
            {
                // Use OrderBy() instead of Array.Sort() as it performs fewer comparisons. In this case the comparisons
                // are quite expensive so OrderBy() performs better.
                return headerValues.OrderByDescending(m => m, MediaTypeWithQualityHeaderValueComparer.QualityComparer).ToArray();
            }
            else
            {
                return headerValues;
            }
        }

        /// <summary>
        /// Sort Accept-Charset, Accept-Encoding, Accept-Language and related header field values with similar syntax rules
        /// (if more than 1) in descending order based on q-factor.
        /// </summary>
        /// <param name="headerValues">The header values to sort.</param>
        /// <returns>The sorted header values.</returns>
        protected virtual IEnumerable<StringWithQualityHeaderValue> SortStringWithQualityHeaderValuesByQFactor(ICollection<StringWithQualityHeaderValue> headerValues)
        {
            if (headerValues == null)
            {
                throw Error.ArgumentNull("headerValues");
            }

            if (headerValues.Count > 1)
            {
                // Use OrderBy() instead of Array.Sort() as it performs fewer comparisons. In this case the comparisons
                // are quite expensive so OrderBy() performs better.
                return headerValues.OrderByDescending(m => m, StringWithQualityHeaderValueComparer.QualityComparer).ToArray();
            }
            else
            {
                return headerValues;
            }
        }

        /// <summary>
        /// Evaluates whether a match is better than the current match and if so returns the replacement; otherwise returns the
        /// current match.
        /// </summary>
        protected virtual MediaTypeFormatterMatch UpdateBestMatch(MediaTypeFormatterMatch current, MediaTypeFormatterMatch potentialReplacement)
        {
            if (potentialReplacement == null)
            {
                return current;
            }

            if (current != null)
            {
                return (potentialReplacement.Quality > current.Quality) ? potentialReplacement : current;
            }

            return potentialReplacement;
        }

        private static MediaTypeFormatter[] GetWritingFormatters(IEnumerable<MediaTypeFormatter> formatters)
        {
            Contract.Assert(formatters != null);
            MediaTypeFormatterCollection formatterCollection = formatters as MediaTypeFormatterCollection;
            if (formatterCollection != null)
            {
                return formatterCollection.WritingFormatters;
            }
            return formatters.AsArray();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/DelegatingEnumerable.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Helper class to serialize <see cref="IEnumerable{T}"/> types by delegating them through a concrete implementation."/>.
    /// </summary>
    /// <typeparam name="T">The interface implementing <see cref="IEnumerable{T}"/> to proxy.</typeparam>
    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "Enumerable conveys the meaning of collection")]
    public sealed class DelegatingEnumerable<T> : IEnumerable<T>
    {
        private IEnumerable<T> _source;

        /// <summary>
        /// Initialize a DelegatingEnumerable. This constructor is necessary for <see cref="System.Runtime.Serialization.DataContractSerializer"/> to work.
        /// </summary>
        public DelegatingEnumerable()
        {
            _source = Enumerable.Empty<T>();
        }

        /// <summary>
        /// Initialize a DelegatingEnumerable with an <see cref="IEnumerable{T}"/>. This is a helper class to proxy <see cref="IEnumerable{T}"/> interfaces for <see cref="System.Xml.Serialization.XmlSerializer"/>.
        /// </summary>
        /// <param name="source">The <see cref="IEnumerable{T}"/> instance to get the enumerator from.</param>
        public DelegatingEnumerable(IEnumerable<T> source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }
            _source = source;
        }

        /// <summary>
        /// Get the enumerator of the associated <see cref="IEnumerable{T}"/>.
        /// </summary>
        /// <returns>The enumerator of the <see cref="IEnumerable{T}"/> source.</returns>
        public IEnumerator<T> GetEnumerator()
        {
            return _source.GetEnumerator();
        }

        /// <summary>
        /// This method is not implemented but is required method for serialization to work. Do not use.
        /// </summary>
        /// <param name="item">The item to add. Unused.</param>
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", Justification = "Required by XmlSerializer, never used.")]
        public void Add(object item)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Get the enumerator of the associated <see cref="IEnumerable{T}"/>.
        /// </summary>
        /// <returns>The enumerator of the <see cref="IEnumerable{T}"/> source.</returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return _source.GetEnumerator();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/FormDataCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Formatting.Internal;
using System.Net.Http.Formatting.Parsers;
using System.Text;
using System.Threading;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Represent the form data.
    /// - This has 100% fidelity (including ordering, which is important for deserializing ordered array).
    /// - using interfaces allows us to optimize the implementation. E.g., we can avoid eagerly string-splitting a 10gb file.
    /// - This also provides a convenient place to put extension methods.
    /// </summary>
    public class FormDataCollection : IEnumerable<KeyValuePair<string, string>>
    {
        private readonly IEnumerable<KeyValuePair<string, string>> _pairs;

        private NameValueCollection _nameValueCollection;

        /// <summary>
        /// Initialize a form collection around incoming data.
        /// The key value enumeration should be immutable.
        /// </summary>
        /// <param name="pairs">incoming set of key value pairs. Ordering is preserved.</param>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is the convention for representing FormData")]
        public FormDataCollection(IEnumerable<KeyValuePair<string, string>> pairs)
        {
            if (pairs == null)
            {
                throw Error.ArgumentNull("pairs");
            }
            _pairs = pairs;
        }

        /// <summary>
        /// Initialize a form collection from a query string.
        /// Uri and FormURl body have the same schema.
        /// </summary>
        public FormDataCollection(Uri uri)
        {
            if (uri == null)
            {
                throw Error.ArgumentNull("uri");
            }

            string query = uri.Query;
            if (query != null && query.Length > 0 && query[0] == '?')
            {
                query = query.Substring(1);
            }

            _pairs = ParseQueryString(query);
        }

        /// <summary>
        /// Initialize a form collection from a URL encoded query string. Any leading question
        /// mark (?) will be considered part of the query string and treated as any other value.
        /// </summary>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1057:StringUriOverloadsCallSystemUriOverloads", Justification = "string is a query string, not a URI")]
        public FormDataCollection(string query)
        {
            _pairs = ParseQueryString(query);
        }

        /// <summary>
        /// Gets values associated with a given key. If there are multiple values, they're concatenated.
        /// </summary>
        /// <param name="name">The name of the entry that contains the values to get. The name can be null.</param>
        /// <returns>Values associated with a given key. If there are multiple values, they're concatenated.</returns>
        public string this[string name]
        {
            get
            {
                return Get(name);
            }
        }

        // Helper to invoke parser around a query string
        private static IEnumerable<KeyValuePair<string, string>> ParseQueryString(string query)
        {
            List<KeyValuePair<string, string>> result = new List<KeyValuePair<string, string>>();
            if (String.IsNullOrWhiteSpace(query))
            {
                return result;
            }

            byte[] bytes = Encoding.UTF8.GetBytes(query);

            FormUrlEncodedParser parser = new FormUrlEncodedParser(result, Int64.MaxValue);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(bytes, bytes.Length, ref bytesConsumed, isFinal: true);

            if (state != ParserState.Done)
            {
                throw Error.InvalidOperation(Properties.Resources.FormUrlEncodedParseError, bytesConsumed);
            }

            return result;
        }

        /// <summary>
        /// Get the collection as a NameValueCollection.
        /// Beware this loses some ordering. Values are ordered within a key,
        /// but keys are no longer ordered against each other.
        /// </summary>
        public NameValueCollection ReadAsNameValueCollection()
        {
            if (_nameValueCollection == null)
            {
                // Initialize in a private collection to be thread-safe, and swap the finished object.
                // Ok to double initialize this.
                HttpValueCollection newCollection = HttpValueCollection.Create(this);
                Interlocked.Exchange(ref _nameValueCollection, newCollection);
            }
            return _nameValueCollection;
        }

        /// <summary>
        /// Get values associated with a given key. If there are multiple values, they're concatenated.
        /// </summary>
        public string Get(string key)
        {
            return ReadAsNameValueCollection().Get(key);
        }

        /// <summary>
        /// Get a value associated with a given key.
        /// </summary>
        public string[] GetValues(string key)
        {
            return ReadAsNameValueCollection().GetValues(key);
        }

        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
        {
            return _pairs.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            IEnumerable ie = _pairs;
            return ie.GetEnumerator();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/FormUrlEncodedJson.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Http;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// This class provides a low-level API for parsing HTML form URL-encoded data, also known as <c>application/x-www-form-urlencoded</c>
    /// data. The output of the parser is a <see cref="JObject"/> instance.
    /// <remarks>This is a low-level API intended for use by other APIs. It has been optimized for performance and
    /// is not intended to be called directly from user code.</remarks>
    /// </summary>
    internal static class FormUrlEncodedJson
    {
        private const string ApplicationFormUrlEncoded = @"application/x-www-form-urlencoded";
        private const int MinDepth = 0;

        private static readonly string[] _emptyPath = new string[]
        {
            String.Empty
        };

        /// <summary>
        /// Parses a collection of query string values as a <see cref="JObject"/>.
        /// </summary>
        /// <remarks>This is a low-level API intended for use by other APIs. It has been optimized for performance and
        /// is not intended to be called directly from user code.</remarks>
        /// <param name="nameValuePairs">The collection of query string name-value pairs parsed in lexical order. Both names
        /// and values must be un-escaped so that they don't contain any <see cref="Uri"/> encoding.</param>
        /// <returns>The <see cref="JObject"/> corresponding to the given query string values.</returns>
        public static JObject Parse(IEnumerable<KeyValuePair<string, string>> nameValuePairs)
        {
            return ParseInternal(nameValuePairs, Int32.MaxValue, true);
        }

        /// <summary>
        /// Parses a collection of query string values as a <see cref="JObject"/>.
        /// </summary>
        /// <remarks>This is a low-level API intended for use by other APIs. It has been optimized for performance and
        /// is not intended to be called directly from user code.</remarks>
        /// <param name="nameValuePairs">The collection of query string name-value pairs parsed in lexical order. Both names
        /// and values must be un-escaped so that they don't contain any <see cref="Uri"/> encoding.</param>
        /// <param name="maxDepth">The maximum depth of object graph encoded as <c>x-www-form-urlencoded</c>.</param>
        /// <returns>The <see cref="JObject"/> corresponding to the given query string values.</returns>
        public static JObject Parse(IEnumerable<KeyValuePair<string, string>> nameValuePairs, int maxDepth)
        {
            return ParseInternal(nameValuePairs, maxDepth, true);
        }

        /// <summary>
        /// Parses a collection of query string values as a <see cref="JObject"/>.
        /// </summary>
        /// <remarks>This is a low-level API intended for use by other APIs. It has been optimized for performance and
        /// is not intended to be called directly from user code.</remarks>
        /// <param name="nameValuePairs">The collection of query string name-value pairs parsed in lexical order. Both names
        /// and values must be un-escaped so that they don't contain any <see cref="Uri"/> encoding.</param>
        /// <param name="value">The parsed result or null if parsing failed.</param>
        /// <returns><c>true</c> if <paramref name="nameValuePairs"/> was parsed successfully; otherwise false.</returns>
        public static bool TryParse(IEnumerable<KeyValuePair<string, string>> nameValuePairs, out JObject value)
        {
            return (value = ParseInternal(nameValuePairs, Int32.MaxValue, false)) != null;
        }

        /// <summary>
        /// Parses a collection of query string values as a <see cref="JObject"/>.
        /// </summary>
        /// <remarks>This is a low-level API intended for use by other APIs. It has been optimized for performance and
        /// is not intended to be called directly from user code.</remarks>
        /// <param name="nameValuePairs">The collection of query string name-value pairs parsed in lexical order. Both names
        /// and values must be un-escaped so that they don't contain any <see cref="Uri"/> encoding.</param>
        /// <param name="maxDepth">The maximum depth of object graph encoded as <c>x-www-form-urlencoded</c>.</param>
        /// <param name="value">The parsed result or null if parsing failed.</param>
        /// <returns><c>true</c> if <paramref name="nameValuePairs"/> was parsed successfully; otherwise false.</returns>
        public static bool TryParse(IEnumerable<KeyValuePair<string, string>> nameValuePairs, int maxDepth, out JObject value)
        {
            return (value = ParseInternal(nameValuePairs, maxDepth, false)) != null;
        }

        /// <summary>
        /// Parses a collection of query string values as a <see cref="JObject"/>.
        /// </summary>
        /// <remarks>This is a low-level API intended for use by other APIs. It has been optimized for performance and
        /// is not intended to be called directly from user code.</remarks>
        /// <param name="nameValuePairs">The collection of query string name-value pairs parsed in lexical order. Both names
        /// and values must be un-escaped so that they don't contain any <see cref="Uri"/> encoding.</param>
        /// <param name="maxDepth">The maximum depth of object graph encoded as <c>x-www-form-urlencoded</c>.</param>
        /// <param name="throwOnError">Indicates whether to throw an exception on error or return false</param>
        /// <returns>The <see cref="JObject"/> corresponding to the given query string values.</returns>
        private static JObject ParseInternal(IEnumerable<KeyValuePair<string, string>> nameValuePairs, int maxDepth, bool throwOnError)
        {
            if (nameValuePairs == null)
            {
                throw Error.ArgumentNull("nameValuePairs");
            }

            if (maxDepth <= MinDepth)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxDepth", maxDepth, MinDepth + 1);
            }

            JObject result = new JObject();
            foreach (var nameValuePair in nameValuePairs)
            {
                string key = nameValuePair.Key;
                string value = nameValuePair.Value;

                // value is preserved, even if it's null, "undefined", "null", String.Empty, etc when converting to JToken.

                if (key == null)
                {
                    if (String.IsNullOrEmpty(value))
                    {
                        if (throwOnError)
                        {
                            throw Error.Argument("nameValuePairs", Properties.Resources.QueryStringNameShouldNotNull);
                        }

                        return null;
                    }

                    string[] path = new string[] { value };
                    if (!Insert(result, path, null, throwOnError))
                    {
                        return null;
                    }
                }
                else
                {
                    string[] path = GetPath(key, maxDepth, throwOnError);
                    if (path == null || !Insert(result, path, value, throwOnError))
                    {
                        return null;
                    }
                }
            }

            FixContiguousArrays(result);
            return result;
        }

        private static string[] GetPath(string key, int maxDepth, bool throwOnError)
        {
            Contract.Assert(key != null, "Key cannot be null (this function is only called by Parse if key != null)");

            if (String.IsNullOrWhiteSpace(key))
            {
                return _emptyPath;
            }

            if (!ValidateQueryString(key, throwOnError))
            {
                return null;
            }

            string[] path = key.Split('[');
            for (int i = 0; i < path.Length; i++)
            {
                if (path[i].EndsWith("]", StringComparison.Ordinal))
                {
                    path[i] = path[i].Substring(0, path[i].Length - 1);
                }
            }

            // For consistency with JSON, the depth of a[b]=1 is 3 (which is the depth of {a:{b:1}}, given
            // that in the JSON-XML mapping there's a <root> element wrapping the JSON object:
            // <root><a><b>1</b></a></root>. So if the length of the path is greater than *or equal* to
            // maxDepth, then we throw.
            if (path.Length >= maxDepth)
            {
                if (throwOnError)
                {
                    throw Error.Argument(Properties.Resources.MaxDepthExceeded, maxDepth);
                }

                return null;
            }

            return path;
        }

        private static bool ValidateQueryString(string key, bool throwOnError)
        {
            bool hasUnMatchedLeftBraket = false;
            for (int i = 0; i < key.Length; i++)
            {
                switch (key[i])
                {
                    case '[':
                        if (!hasUnMatchedLeftBraket)
                        {
                            hasUnMatchedLeftBraket = true;
                        }
                        else
                        {
                            if (throwOnError)
                            {
                                throw Error.Argument(Properties.Resources.NestedBracketNotValid, ApplicationFormUrlEncoded, i);
                            }

                            return false;
                        }

                        break;
                    case ']':
                        if (hasUnMatchedLeftBraket)
                        {
                            hasUnMatchedLeftBraket = false;
                        }
                        else
                        {
                            if (throwOnError)
                            {
                                throw Error.Argument(Properties.Resources.UnMatchedBracketNotValid, ApplicationFormUrlEncoded, i);
                            }

                            return false;
                        }

                        break;
                }
            }

            if (hasUnMatchedLeftBraket)
            {
                if (throwOnError)
                {
                    throw Error.Argument(Properties.Resources.NestedBracketNotValid, ApplicationFormUrlEncoded, key.LastIndexOf('['));
                }

                return false;
            }

            return true;
        }

        private static bool Insert(JObject root, string[] path, string value, bool throwOnError)
        {
            // to-do: verify consistent with new parsing, whether single value is in path or value
            Contract.Assert(root != null, "Root object can't be null");

            JObject current = root;
            JObject parent = null;

            for (int i = 0; i < path.Length - 1; i++)
            {
                if (String.IsNullOrEmpty(path[i]))
                {
                    if (throwOnError)
                    {
                        throw Error.Argument(Properties.Resources.InvalidArrayInsert, BuildPathString(path, i));
                    }

                    return false;
                }

                if (!((IDictionary<string, JToken>)current).ContainsKey(path[i]))
                {
                    current[path[i]] = new JObject();
                }
                else
                {
                    // Since the loop goes up to the next-to-last item in the path, if we hit a null
                    // or a primitive, then we have a mismatching node.
                    if (current[path[i]] == null || current[path[i]] is JValue)
                    {
                        if (throwOnError)
                        {
                            throw Error.Argument(Properties.Resources.FormUrlEncodedMismatchingTypes, BuildPathString(path, i));
                        }

                        return false;
                    }
                }

                parent = current;
                current = current[path[i]] as JObject;
            }

            string lastKey = path[path.Length - 1];
            if (String.IsNullOrEmpty(lastKey) && path.Length > 1)
            {
                if (!AddToArray(parent, path, value, throwOnError))
                {
                    return false;
                }
            }
            else
            {
                if (current == null)
                {
                    if (throwOnError)
                    {
                        throw Error.Argument(Properties.Resources.FormUrlEncodedMismatchingTypes, BuildPathString(path, path.Length - 1));
                    }

                    return false;
                }

                if (!AddToObject(current, path, value, throwOnError))
                {
                    return false;
                }
            }

            return true;
        }

        private static bool AddToObject(JObject obj, string[] path, string value, bool throwOnError)
        {
            Contract.Assert(obj != null, "JsonObject cannot be null");

            int pathIndex = path.Length - 1;
            string key = path[pathIndex];

            if (((IDictionary<string, JToken>)obj).ContainsKey(key))
            {
                if (obj[key] == null || obj[key].Type == JTokenType.Null)
                {
                    if (throwOnError)
                    {
                        throw Error.Argument(Properties.Resources.FormUrlEncodedMismatchingTypes, BuildPathString(path, pathIndex));
                    }

                    return false;
                }

                bool isRoot = path.Length == 1;
                if (isRoot)
                {
                    // jQuery 1.3 behavior, make it into an array(object) if primitive
                    if (obj[key].Type == JTokenType.String)
                    {
                        string oldValue = obj[key].ToObject<string>();
                        JObject jo = new JObject();
                        jo.Add("0", oldValue);
                        jo.Add("1", value);
                        obj[key] = jo;
                    }
                    else if (obj[key] is JObject)
                    {
                        // if it was already an object, simply add the value
                        JObject jo = obj[key] as JObject;
                        string index = GetIndex(jo, throwOnError);
                        if (index == null)
                        {
                            return false;
                        }

                        jo.Add(index, value);
                    }
                }
                else
                {
                    if (throwOnError)
                    {
                        throw Error.Argument(Properties.Resources.JQuery13CompatModeNotSupportNestedJson, BuildPathString(path, pathIndex));
                    }

                    return false;
                }
            }
            else
            {
                // if the object didn't contain the key, simply add it now
                // the null check here is necessary because otherwise the created JValue type will be implictly cast as a string JValue
                if (value == null)
                {
                    obj[key] = null;
                }
                else
                {
                    obj[key] = value;
                }
            }

            return true;
        }

        // JsonObject passed in is semantically an array
        private static bool AddToArray(JObject parent, string[] path, string value, bool throwOnError)
        {
            Contract.Assert(parent != null, "Parent cannot be null");
            Contract.Assert(path.Length >= 2, "The path must be at least 2, one for the ending [], and one for before the '[' (which can be empty)");

            string parentPath = path[path.Length - 2];

            Contract.Assert(((IDictionary<string, JToken>)parent).ContainsKey(parentPath), "It was added on insert to get to this point");
            JObject jo = parent[parentPath] as JObject;

            if (jo == null)
            {
                // a[b][c]=1&a[b][]=2 => invalid
                if (throwOnError)
                {
                    throw Error.Argument(Properties.Resources.FormUrlEncodedMismatchingTypes, BuildPathString(path, path.Length - 1));
                }

                return false;
            }
            else
            {
                string index = GetIndex(jo, throwOnError);
                if (index == null)
                {
                    return false;
                }

                jo.Add(index, value);
            }

            return true;
        }

        // TODO: consider optimize it by only look at the last one
        private static string GetIndex(JObject jsonObject, bool throwOnError)
        {
            int max = -1;
            if (jsonObject.Count > 0)
            {
                IEnumerable<string> keys = ((IDictionary<string, JToken>)jsonObject).Keys;
                foreach (var key in keys)
                {
                    int tempInt;
                    if (Int32.TryParse(key, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out tempInt) && tempInt > max)
                    {
                        max = tempInt;
                    }
                    else
                    {
                        if (throwOnError)
                        {
                            throw Error.Argument(Properties.Resources.FormUrlEncodedMismatchingTypes, key);
                        }

                        return null;
                    }
                }
            }

            max++;
            return max.ToString(CultureInfo.InvariantCulture);
        }

        private static void FixContiguousArrays(JToken jv)
        {
            JArray ja = jv as JArray;

            if (ja != null)
            {
                for (int i = 0; i < ja.Count; i++)
                {
                    if (ja[i] != null)
                    {
                        ja[i] = FixSingleContiguousArray(ja[i]);
                        FixContiguousArrays(ja[i]);
                    }
                }
            }
            else
            {
                JObject jo = jv as JObject;

                if (jo != null && jo.Count > 0)
                {
                    List<string> keys = new List<string>(((IDictionary<string, JToken>)jo).Keys);
                    foreach (string key in keys)
                    {
                        if (jo[key] != null)
                        {
                            jo[key] = FixSingleContiguousArray(jo[key]);
                            FixContiguousArrays(jo[key]);
                        }
                    }
                }
            }

            //// do nothing for primitives
        }

        private static JToken FixSingleContiguousArray(JToken original)
        {
            JObject jo = original as JObject;
            if (jo != null && jo.Count > 0)
            {
                List<string> childKeys = new List<string>(((IDictionary<string, JToken>)jo).Keys);
                List<string> sortedKeys;
                if (CanBecomeArray(childKeys, out sortedKeys))
                {
                    JArray newResult = new JArray();
                    foreach (string sortedKey in sortedKeys)
                    {
                        newResult.Add(jo[sortedKey]);
                    }

                    return newResult;
                }
            }

            return original;
        }

        private static bool CanBecomeArray(List<string> keys, out List<string> sortedKeys)
        {
            List<ArrayCandidate> intKeys = new List<ArrayCandidate>();
            sortedKeys = null;
            bool areContiguousIndices = true;
            foreach (string key in keys)
            {
                int intKey;
                if (!Int32.TryParse(key, NumberStyles.None, CultureInfo.InvariantCulture, out intKey))
                {
                    // if not a non-negative number, it cannot become an array
                    areContiguousIndices = false;
                    break;
                }

                string strKey = intKey.ToString(CultureInfo.InvariantCulture);
                if (!strKey.Equals(key, StringComparison.Ordinal))
                {
                    // int.Parse returned true, but it's not really the same number.
                    // It's the case for strings such as "1\0".
                    areContiguousIndices = false;
                    break;
                }

                intKeys.Add(new ArrayCandidate(intKey, strKey));
            }

            if (areContiguousIndices)
            {
                intKeys.Sort((x, y) => x.Key - y.Key);

                for (int i = 0; i < intKeys.Count; i++)
                {
                    if (intKeys[i].Key != i)
                    {
                        areContiguousIndices = false;
                        break;
                    }
                }
            }

            if (areContiguousIndices)
            {
                sortedKeys = new List<string>(intKeys.Select(x => x.Value));
            }

            return areContiguousIndices;
        }

        private static string BuildPathString(string[] path, int i)
        {
            StringBuilder errorPath = new StringBuilder(path[0]);
            for (int p = 1; p <= i; p++)
            {
                errorPath.AppendFormat(CultureInfo.InvariantCulture, "[{0}]", path[p]);
            }

            return errorPath.ToString();
        }

        /// <summary>
        /// Class that wraps key-value pairs.
        /// </summary>
        /// <remarks>
        /// This use of this class avoids a FxCop warning CA908 which happens if using various generic types.
        /// </remarks>
        private class ArrayCandidate
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="ArrayCandidate"/> class.
            /// </summary>
            /// <param name="key">The key of this <see cref="ArrayCandidate"/> instance.</param>
            /// <param name="value">The value of this <see cref="ArrayCandidate"/> instance.</param>
            public ArrayCandidate(int key, string value)
            {
                Key = key;
                Value = value;
            }

            /// <summary>
            /// Gets or sets the key of this <see cref="ArrayCandidate"/> instance.
            /// </summary>
            /// <value>
            /// The key of this <see cref="ArrayCandidate"/> instance.
            /// </value>
            public int Key { get; set; }

            /// <summary>
            /// Gets or sets the value of this <see cref="ArrayCandidate"/> instance.
            /// </summary>
            /// <value>
            /// The value of this <see cref="ArrayCandidate"/> instance.
            /// </value>
            public string Value { get; set; }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/FormUrlEncodedMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Formatting.Parsers;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// <see cref="MediaTypeFormatter"/> class for handling HTML form URL-ended data, also known as <c>application/x-www-form-urlencoded</c>.
    /// </summary>
    public class FormUrlEncodedMediaTypeFormatter : MediaTypeFormatter
    {
        private const int MinBufferSize = 256;
        private const int DefaultBufferSize = 32 * 1024;

        private int _readBufferSize = DefaultBufferSize;
        private int _maxDepth = FormattingUtilities.DefaultMaxDepth;
        private readonly bool _isDerived;

        /// <summary>
        /// Initializes a new instance of the <see cref="FormUrlEncodedMediaTypeFormatter"/> class.
        /// </summary>
        public FormUrlEncodedMediaTypeFormatter()
        {
            SupportedMediaTypes.Add(MediaTypeConstants.ApplicationFormUrlEncodedMediaType);
            _isDerived = GetType() != typeof(FormUrlEncodedMediaTypeFormatter);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FormUrlEncodedMediaTypeFormatter"/> class.
        /// </summary>
        /// <param name="formatter">The <see cref="FormUrlEncodedMediaTypeFormatter"/> instance to copy settings from.</param>
        protected FormUrlEncodedMediaTypeFormatter(FormUrlEncodedMediaTypeFormatter formatter)
            : base(formatter)
        {
            MaxDepth = formatter.MaxDepth;
            ReadBufferSize = formatter.ReadBufferSize;
            _isDerived = GetType() != typeof(FormUrlEncodedMediaTypeFormatter);
        }

        /// <summary>
        /// Gets the default media type for HTML Form URL encoded data, namely <c>application/x-www-form-urlencoded</c>.
        /// </summary>
        /// <value>
        /// Because <see cref="MediaTypeHeaderValue"/> is mutable, the value
        /// returned will be a new instance every time.
        /// </value>
        public static MediaTypeHeaderValue DefaultMediaType
        {
            get { return MediaTypeConstants.ApplicationFormUrlEncodedMediaType; }
        }

        /// <summary>
        /// Gets or sets the maximum depth allowed by this formatter.
        /// </summary>
        public int MaxDepth
        {
            get
            {
                return _maxDepth;
            }
            set
            {
                if (value < FormattingUtilities.DefaultMinDepth)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, FormattingUtilities.DefaultMinDepth);
                }

                _maxDepth = value;
            }
        }

        /// <summary>
        /// Gets or sets the size of the buffer when reading the incoming stream.
        /// </summary>
        /// <value>
        /// The size of the read buffer.
        /// </value>
        public int ReadBufferSize
        {
            get { return _readBufferSize; }

            set
            {
                if (value < MinBufferSize)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinBufferSize);
                }

                _readBufferSize = value;
            }
        }

        internal override bool CanWriteAnyTypes
        {
            get
            {
                return _isDerived;
            }
        }

        /// <summary>
        /// Determines whether this <see cref="FormUrlEncodedMediaTypeFormatter"/> can read objects
        /// of the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The type of object that will be read.</param>
        /// <returns><c>true</c> if objects of this <paramref name="type"/> can be read, otherwise <c>false</c>.</returns>
        public override bool CanReadType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            // Can't read arbitrary types.
            return type == typeof(FormDataCollection) || FormattingUtilities.IsJTokenType(type);
        }

        /// <summary>
        /// Determines whether this <see cref="FormUrlEncodedMediaTypeFormatter"/> can write objects
        /// of the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The type of object that will be written.</param>
        /// <returns><c>true</c> if objects of this <paramref name="type"/> can be written, otherwise <c>false</c>.</returns>
        public override bool CanWriteType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            return false;
        }

        /// <summary>
        /// Called during deserialization to read an object of the specified <paramref name="type"/>
        /// from the specified <paramref name="readStream"/>.
        /// </summary>
        /// <param name="type">The type of object to read.</param>
        /// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
        /// <param name="content">The <see cref="HttpContent"/> for the content being read.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            try
            {
                return Task.FromResult(ReadFromStream(type, readStream));
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError<object>(e);
            }
        }

        private object ReadFromStream(Type type, Stream readStream)
        {
            object result;
            IEnumerable<KeyValuePair<string, string>> nameValuePairs = ReadFormUrlEncoded(readStream, ReadBufferSize);

            if (type == typeof(FormDataCollection))
            {
                result = new FormDataCollection(nameValuePairs);
            }
            else if (FormattingUtilities.IsJTokenType(type))
            {
                result = FormUrlEncodedJson.Parse(nameValuePairs, _maxDepth);
            }
            else
            {
                // Passed us an unsupported type. Should have called CanReadType() first.
                throw Error.InvalidOperation(Properties.Resources.SerializerCannotSerializeType, GetType().Name, type.Name);
            }
            return result;
        }

        /// <summary>
        /// Reads all name-value pairs encoded as HTML Form URL encoded data and add them to
        /// a collection as UNescaped URI strings.
        /// </summary>
        /// <param name="input">Stream to read from.</param>
        /// <param name="bufferSize">Size of the buffer used to read the contents.</param>
        /// <returns>Collection of name-value pairs.</returns>
        private static IEnumerable<KeyValuePair<string, string>> ReadFormUrlEncoded(Stream input, int bufferSize)
        {
            Contract.Assert(input != null, "input stream cannot be null");
            Contract.Assert(bufferSize >= MinBufferSize, "buffer size cannot be less than MinBufferSize");

            byte[] data = new byte[bufferSize];

            int bytesRead;
            bool isFinal = false;
            List<KeyValuePair<string, string>> result = new List<KeyValuePair<string, string>>();
            FormUrlEncodedParser parser = new FormUrlEncodedParser(result, Int64.MaxValue);
            ParserState state;

            while (true)
            {
                try
                {
                    bytesRead = input.Read(data, 0, data.Length);
                    if (bytesRead == 0)
                    {
                        isFinal = true;
                    }
                }
                catch (Exception e)
                {
                    throw Error.InvalidOperation(e, Properties.Resources.ErrorReadingFormUrlEncodedStream);
                }

                int bytesConsumed = 0;
                state = parser.ParseBuffer(data, bytesRead, ref bytesConsumed, isFinal);
                if (state != ParserState.NeedMoreData && state != ParserState.Done)
                {
                    throw Error.InvalidOperation(Properties.Resources.FormUrlEncodedParseError, bytesConsumed);
                }

                if (isFinal)
                {
                    return result;
                }
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/IContentNegotiator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http.Headers;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Performs content negotiation. 
    /// This is the process of selecting a response writer (formatter) in compliance with header values in the request.
    /// </summary>
    public interface IContentNegotiator
    {
        /// <summary>
        /// Performs content negotiating by selecting the most appropriate <see cref="MediaTypeFormatter"/> out of the passed in
        /// <paramref name="formatters"/> for the given <paramref name="request"/> that can serialize an object of the given
        /// <paramref name="type"/>.
        /// </summary>
        /// <remarks>
        /// Implementations of this method should call <see cref="MediaTypeFormatter.GetPerRequestFormatterInstance(Type, HttpRequestMessage, MediaTypeHeaderValue)"/>
        /// on the selected <see cref="MediaTypeFormatter">formatter</see> and return the result of that method.
        /// </remarks>
        /// <param name="type">The type to be serialized.</param>
        /// <param name="request">Request message, which contains the header values used to perform negotiation.</param>
        /// <param name="formatters">The set of <see cref="MediaTypeFormatter"/> objects from which to choose.</param>
        /// <returns>The result of the negotiation containing the most appropriate <see cref="MediaTypeFormatter"/> instance,
        /// or <c>null</c> if there is no appropriate formatter.</returns>
        ContentNegotiationResult Negotiate(Type type, HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters);
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/IFormatterLogger.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Interface to log events that occur during formatter reads.
    /// </summary>
    public interface IFormatterLogger
    {
        /// <summary>
        /// Logs an error.
        /// </summary>
        /// <param name="errorPath">The path to the member for which the error is being logged.</param>
        /// <param name="errorMessage">The error message to be logged.</param>
        void LogError(string errorPath, string errorMessage);

        /// <summary>
        /// Logs an error.
        /// </summary>
        /// <param name="errorPath">The path to the member for which the error is being logged.</param>
        /// <param name="exception">The exception to be logged.</param>
        void LogError(string errorPath, Exception exception);
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/IRequiredMemberSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Interface to determine which data members on a particular type are required.
    /// </summary>
    public interface IRequiredMemberSelector
    {
        /// <summary>
        /// Determines whether a given member is required on deserialization.
        /// </summary>
        /// <param name="member">The <see cref="MemberInfo"/> that will be deserialized.</param>
        /// <returns><c>true</c> if <paramref name="member"/> should be treated as a required member, otherwise <c>false</c>.</returns>
        bool IsRequiredMember(MemberInfo member);
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/JsonContractResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Represents the default <see cref="IContractResolver"/> used by <see cref="BaseJsonMediaTypeFormatter"/>.
    /// It uses the formatter's <see cref="IRequiredMemberSelector"/> to select required members and recognizes
    /// the <see cref="SerializableAttribute"/> type annotation.
    /// </summary>
    public class JsonContractResolver : DefaultContractResolver
    {
        private readonly MediaTypeFormatter _formatter;

        /// <summary>
        /// Initializes a new instance of the <see cref="JsonContractResolver" /> class.
        /// </summary>
        /// <param name="formatter">The formatter to use for resolving required members.</param>
        public JsonContractResolver(MediaTypeFormatter formatter)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            _formatter = formatter;

#if !NETSTANDARD1_3
            // Need this setting to have [Serializable] types serialized correctly
            IgnoreSerializableAttribute = false;
#endif
        }

        // Determines whether a member is required or not and sets the appropriate JsonProperty settings
        private void ConfigureProperty(MemberInfo member, JsonProperty property)
        {
            if (_formatter.RequiredMemberSelector != null && _formatter.RequiredMemberSelector.IsRequiredMember(member))
            {
                property.Required = Required.AllowNull;
                property.DefaultValueHandling = DefaultValueHandling.Include;
                property.NullValueHandling = NullValueHandling.Include;
            }
            else
            {
                property.Required = Required.Default;
            }
        }

        /// <inheritdoc />
        protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
        {
            JsonProperty property = base.CreateProperty(member, memberSerialization);
            ConfigureProperty(member, property);
            return property;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/JsonMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Headers;
#if !NETSTANDARD1_3 // Unnecessary when targeting netstandard1.3.
using System.Net.Http.Internal;
#endif
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using System.Xml;
using Newtonsoft.Json;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// <see cref="MediaTypeFormatter"/> class to handle Json.
    /// </summary>
    public class JsonMediaTypeFormatter : BaseJsonMediaTypeFormatter
    {
        private readonly ConcurrentDictionary<Type, DataContractJsonSerializer> _dataContractSerializerCache = new ConcurrentDictionary<Type, DataContractJsonSerializer>();
        private readonly XmlDictionaryReaderQuotas _readerQuotas = FormattingUtilities.CreateDefaultReaderQuotas();
        private readonly RequestHeaderMapping _requestHeaderMapping;

        /// <summary>
        /// Initializes a new instance of the <see cref="JsonMediaTypeFormatter"/> class.
        /// </summary>
        public JsonMediaTypeFormatter()
        {
            // Set default supported media types
            SupportedMediaTypes.Add(MediaTypeConstants.ApplicationJsonMediaType);
            SupportedMediaTypes.Add(MediaTypeConstants.TextJsonMediaType);

            _requestHeaderMapping = new XmlHttpRequestHeaderMapping();
            MediaTypeMappings.Add(_requestHeaderMapping);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="JsonMediaTypeFormatter"/> class.
        /// </summary>
        /// <param name="formatter">The <see cref="JsonMediaTypeFormatter"/> instance to copy settings from.</param>
        protected JsonMediaTypeFormatter(JsonMediaTypeFormatter formatter)
            : base(formatter)
        {
            Contract.Assert(formatter != null);

            UseDataContractJsonSerializer = formatter.UseDataContractJsonSerializer;
            Indent = formatter.Indent;
        }

        /// <summary>
        /// Gets the default media type for Json, namely "application/json".
        /// </summary>
        /// <remarks>
        /// The default media type does not have any <c>charset</c> parameter as
        /// the <see cref="Encoding"/> can be configured on a per <see cref="JsonMediaTypeFormatter"/>
        /// instance basis.
        /// </remarks>
        /// <value>
        /// Because <see cref="MediaTypeHeaderValue"/> is mutable, the value
        /// returned will be a new instance every time.
        /// </value>
        public static MediaTypeHeaderValue DefaultMediaType
        {
            get { return MediaTypeConstants.ApplicationJsonMediaType; }
        }

        /// <summary>
        /// Gets or sets a value indicating whether to use <see cref="DataContractJsonSerializer"/> by default.
        /// </summary>
        /// <value>
        ///     <c>true</c> if use <see cref="DataContractJsonSerializer"/> by default; otherwise, <c>false</c>. The default is <c>false</c>.
        /// </value>
        public bool UseDataContractJsonSerializer { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to indent elements when writing data.
        /// </summary>
        public bool Indent { get; set; }

        /// <inheritdoc/>
        public sealed override int MaxDepth
        {
            get
            {
                return base.MaxDepth;
            }
            set
            {
                base.MaxDepth = value;
                _readerQuotas.MaxDepth = value;
            }
        }

        /// <inheritdoc />
        public override JsonReader CreateJsonReader(Type type, Stream readStream, Encoding effectiveEncoding)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            return new JsonTextReader(new StreamReader(readStream, effectiveEncoding));
        }

        /// <inheritdoc />
        public override JsonWriter CreateJsonWriter(Type type, Stream writeStream, Encoding effectiveEncoding)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            JsonWriter jsonWriter = new JsonTextWriter(new StreamWriter(writeStream, effectiveEncoding));
            if (Indent)
            {
                jsonWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
            }

            return jsonWriter;
        }

        /// <inheritdoc />
        public override bool CanReadType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (UseDataContractJsonSerializer)
            {
                // If there is a registered non-null serializer, we can support this type.
                DataContractJsonSerializer serializer =
                    _dataContractSerializerCache.GetOrAdd(type, (t) => CreateDataContractSerializer(t, throwOnError: false));

                // Null means we tested it before and know it is not supported
                return serializer != null;
            }
            else
            {
                return base.CanReadType(type);
            }
        }

        /// <inheritdoc />
        public override bool CanWriteType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (UseDataContractJsonSerializer)
            {
                MediaTypeFormatter.TryGetDelegatingTypeForIQueryableGenericOrSame(ref type);

                // If there is a registered non-null serializer, we can support this type.
                object serializer =
                    _dataContractSerializerCache.GetOrAdd(type, (t) => CreateDataContractSerializer(t, throwOnError: false));

                // Null means we tested it before and know it is not supported
                return serializer != null;
            }
            else
            {
                return base.CanWriteType(type);
            }
        }

        /// <inheritdoc />
        public override object ReadFromStream(Type type, Stream readStream, Encoding effectiveEncoding, IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            if (UseDataContractJsonSerializer)
            {
                DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type);

#if NETSTANDARD1_3 // Unreachable when targeting netstandard1.3. Return just to satisfy the compiler.
                return null;
#else
                // DCS encodings are limited to UTF8, UTF16BE, and UTF16LE. Convert to UTF8 as we read.
                Stream innerStream =
                    string.Equals(effectiveEncoding.WebName, Utf8Encoding.WebName, StringComparison.OrdinalIgnoreCase) ?
                    new NonClosingDelegatingStream(readStream) :
                    new TranscodingStream(readStream, effectiveEncoding, Utf8Encoding, leaveOpen: true);

                // XmlDictionaryReader will always dispose of innerStream when we dispose of the reader.
                using XmlDictionaryReader reader =
                    JsonReaderWriterFactory.CreateJsonReader(innerStream, Utf8Encoding, _readerQuotas, onClose: null);
                return dataContractSerializer.ReadObject(reader);
#endif
            }
            else
            {
                return base.ReadFromStream(type, readStream, effectiveEncoding, formatterLogger);
            }
        }

        /// <inheritdoc />
        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }

            if (UseDataContractJsonSerializer && Indent)
            {
                throw Error.NotSupported(Properties.Resources.UnsupportedIndent, typeof(DataContractJsonSerializer));
            }

            return base.WriteToStreamAsync(type, value, writeStream, content, transportContext, cancellationToken);
        }

        /// <inheritdoc />
        public override void WriteToStream(Type type, object value, Stream writeStream, Encoding effectiveEncoding)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }

            if (effectiveEncoding == null)
            {
                throw Error.ArgumentNull("effectiveEncoding");
            }

            if (UseDataContractJsonSerializer)
            {
                if (MediaTypeFormatter.TryGetDelegatingTypeForIQueryableGenericOrSame(ref type))
                {
                    if (value != null)
                    {
                        value = MediaTypeFormatter.GetTypeRemappingConstructor(type).Invoke(new object[] { value });
                    }
                }

                WritePreamble(writeStream, effectiveEncoding);
                if (string.Equals(effectiveEncoding.WebName, Utf8Encoding.WebName, StringComparison.OrdinalIgnoreCase))
                {
                    WriteObject(writeStream, type, value);
                }
                else
                {
                    // JsonReaderWriterFactory is internal and DataContractJsonSerializer only writes UTF8 for the
                    // netstandard1.3 project. In addition, DCS encodings are limited to UTF8, UTF16BE, and UTF16LE.
                    // Convert to UTF8 as we write.
                    using var innerStream = new TranscodingStream(writeStream, effectiveEncoding, Utf8Encoding, leaveOpen: true);
                    WriteObject(innerStream, type, value);
                }
            }
            else
            {
                base.WriteToStream(type, value, writeStream, effectiveEncoding);
            }
        }

        private void WriteObject(Stream stream, Type type, object value)
        {
            DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type);

#if !NETSTANDARD1_3 // Unreachable when targeting netstandard1.3.
            // Do not dispose of the stream. WriteToStream handles that where it's needed.
            using XmlWriter writer = JsonReaderWriterFactory.CreateJsonWriter(stream, Utf8Encoding, ownsStream: false);
            dataContractSerializer.WriteObject(writer, value);
#endif
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Catch all is around an extensibile method")]
        private DataContractJsonSerializer CreateDataContractSerializer(Type type, bool throwOnError)
        {
            Contract.Assert(type != null);

#if NETSTANDARD1_3 // XsdDataContractExporter is not supported in netstandard1.3
            if (throwOnError)
            {
                throw new PlatformNotSupportedException(Error.Format(
                    Properties.Resources.JsonMediaTypeFormatter_DCS_NotSupported,
                    nameof(UseDataContractJsonSerializer)));
            }
            else
            {
                return null;
            }
#else

            DataContractJsonSerializer serializer = null;
            Exception exception = null;

            try
            {
                // Verify that type is a valid data contract by forcing the serializer to try to create a data contract
                FormattingUtilities.XsdDataContractExporter.GetRootElementName(type);

                serializer = CreateDataContractSerializer(type);
            }
            catch (Exception caught)
            {
                exception = caught;
            }

            if (serializer == null && throwOnError)
            {
                if (exception != null)
                {
                    throw Error.InvalidOperation(exception, Properties.Resources.SerializerCannotSerializeType,
                                  typeof(DataContractJsonSerializer).Name,
                                  type.Name);
                }
                else
                {
                    throw Error.InvalidOperation(Properties.Resources.SerializerCannotSerializeType,
                                  typeof(DataContractJsonSerializer).Name,
                                  type.Name);
                }
            }

            return serializer;
#endif
        }

        /// <summary>
        /// Called during deserialization to get the <see cref="DataContractJsonSerializer"/>.
        /// </summary>
        /// <remarks>
        /// Public for delegating wrappers of this class.  Expected to be called only from
        /// <see cref="BaseJsonMediaTypeFormatter.ReadFromStreamAsync"/> and <see cref="WriteToStreamAsync"/>.
        /// </remarks>
        /// <param name="type">The type of object that will be serialized or deserialized.</param>
        /// <returns>The <see cref="DataContractJsonSerializer"/> used to serialize the object.</returns>
        public virtual DataContractJsonSerializer CreateDataContractSerializer(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            return new DataContractJsonSerializer(type);
        }

        private DataContractJsonSerializer GetDataContractSerializer(Type type)
        {
            Contract.Assert(type != null, "Type cannot be null");

            DataContractJsonSerializer serializer =
                _dataContractSerializerCache.GetOrAdd(type, (t) => CreateDataContractSerializer(type, throwOnError: true));

            if (serializer == null)
            {
                // A null serializer means the type cannot be serialized
                throw Error.InvalidOperation(Properties.Resources.SerializerCannotSerializeType, typeof(DataContractJsonSerializer).Name, type.Name);
            }

            return serializer;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeConstants.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Constants related to media types.
    /// </summary>
    internal static class MediaTypeConstants
    {
        private static readonly MediaTypeHeaderValue _defaultApplicationXmlMediaType = new MediaTypeHeaderValue("application/xml");
        private static readonly MediaTypeHeaderValue _defaultTextXmlMediaType = new MediaTypeHeaderValue("text/xml");
        private static readonly MediaTypeHeaderValue _defaultApplicationJsonMediaType = new MediaTypeHeaderValue("application/json");
        private static readonly MediaTypeHeaderValue _defaultTextJsonMediaType = new MediaTypeHeaderValue("text/json");
        private static readonly MediaTypeHeaderValue _defaultApplicationOctetStreamMediaType = new MediaTypeHeaderValue("application/octet-stream");
        private static readonly MediaTypeHeaderValue _defaultApplicationFormUrlEncodedMediaType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
        private static readonly MediaTypeHeaderValue _defaultApplicationBsonMediaType = new MediaTypeHeaderValue("application/bson");

        /// <summary>
        /// Gets a <see cref="MediaTypeHeaderValue"/> instance representing <c>application/octet-stream</c>.
        /// </summary>
        /// <value>
        /// A new <see cref="MediaTypeHeaderValue"/> instance representing <c>application/octet-stream</c>.
        /// </value>
        public static MediaTypeHeaderValue ApplicationOctetStreamMediaType
        {
            get { return _defaultApplicationOctetStreamMediaType.Clone(); }
        }

        /// <summary>
        /// Gets a <see cref="MediaTypeHeaderValue"/> instance representing <c>application/xml</c>.
        /// </summary>
        /// <value>
        /// A new <see cref="MediaTypeHeaderValue"/> instance representing <c>application/xml</c>.
        /// </value>
        public static MediaTypeHeaderValue ApplicationXmlMediaType
        {
            get { return _defaultApplicationXmlMediaType.Clone(); }
        }

        /// <summary>
        /// Gets a <see cref="MediaTypeHeaderValue"/> instance representing <c>application/json</c>.
        /// </summary>
        /// <value>
        /// A new <see cref="MediaTypeHeaderValue"/> instance representing <c>application/json</c>.
        /// </value>
        public static MediaTypeHeaderValue ApplicationJsonMediaType
        {
            get { return _defaultApplicationJsonMediaType.Clone(); }
        }

        /// <summary>
        /// Gets a <see cref="MediaTypeHeaderValue"/> instance representing <c>text/xml</c>.
        /// </summary>
        /// <value>
        /// A new <see cref="MediaTypeHeaderValue"/> instance representing <c>text/xml</c>.
        /// </value>
        public static MediaTypeHeaderValue TextXmlMediaType
        {
            get { return _defaultTextXmlMediaType.Clone(); }
        }

        /// <summary>
        /// Gets a <see cref="MediaTypeHeaderValue"/> instance representing <c>text/json</c>.
        /// </summary>
        /// <value>
        /// A new <see cref="MediaTypeHeaderValue"/> instance representing <c>text/json</c>.
        /// </value>
        public static MediaTypeHeaderValue TextJsonMediaType
        {
            get { return _defaultTextJsonMediaType.Clone(); }
        }

        /// <summary>
        /// Gets a <see cref="MediaTypeHeaderValue"/> instance representing <c>application/x-www-form-urlencoded</c>.
        /// </summary>
        /// <value>
        /// A new <see cref="MediaTypeHeaderValue"/> instance representing <c>application/x-www-form-urlencoded</c>.
        /// </value>
        public static MediaTypeHeaderValue ApplicationFormUrlEncodedMediaType
        {
            get { return _defaultApplicationFormUrlEncodedMediaType.Clone(); }
        }

        /// <summary>
        /// Gets a <see cref="MediaTypeHeaderValue"/> instance representing <c>application/bson</c>.
        /// </summary>
        /// <value>
        /// A new <see cref="MediaTypeHeaderValue"/> instance representing <c>application/bson</c>.
        /// </value>
        /// <remarks>
        /// Not yet a standard. In particular this media type is not currently listed at
        /// http://www.iana.org/assignments/media-types/application.
        /// </remarks>
        public static MediaTypeHeaderValue ApplicationBsonMediaType
        {
            get { return _defaultApplicationBsonMediaType.Clone(); }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Net.Http.Headers;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Base class to handle serializing and deserializing strongly-typed objects using <see cref="ObjectContent"/>.
    /// </summary>
    public abstract class MediaTypeFormatter
    {
        private protected static readonly Encoding Utf8Encoding =
            new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true);
        private const int DefaultMinHttpCollectionKeys = 1;
        private const int DefaultMaxHttpCollectionKeys = 1000; // same default as ASPNET
        private const string IWellKnownComparerTypeName = "System.IWellKnownStringEqualityComparer, mscorlib, Version=4.0.0.0, PublicKeyToken=b77a5c561934e089";

        private static readonly ConcurrentDictionary<Type, Type> _delegatingEnumerableCache = new ConcurrentDictionary<Type, Type>();
        private static ConcurrentDictionary<Type, ConstructorInfo> _delegatingEnumerableConstructorCache = new ConcurrentDictionary<Type, ConstructorInfo>();
        private static Lazy<int> _defaultMaxHttpCollectionKeys = new Lazy<int>(InitializeDefaultCollectionKeySize, true); // Max number of keys is 1000
        private static int _maxHttpCollectionKeys = -1;

        private readonly List<MediaTypeHeaderValue> _supportedMediaTypes;
        private readonly List<Encoding> _supportedEncodings;
        private readonly List<MediaTypeMapping> _mediaTypeMappings;
        private IRequiredMemberSelector _requiredMemberSelector;

        /// <summary>
        /// Initializes a new instance of the <see cref="MediaTypeFormatter"/> class.
        /// </summary>
        protected MediaTypeFormatter()
        {
            _supportedMediaTypes = new List<MediaTypeHeaderValue>();
            SupportedMediaTypes = new MediaTypeHeaderValueCollection(_supportedMediaTypes);
            _supportedEncodings = new List<Encoding>();
            SupportedEncodings = new Collection<Encoding>(_supportedEncodings);
            _mediaTypeMappings = new List<MediaTypeMapping>();
            MediaTypeMappings = new Collection<MediaTypeMapping>(_mediaTypeMappings);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MediaTypeFormatter"/> class.
        /// </summary>
        /// <param name="formatter">The <see cref="MediaTypeFormatter"/> instance to copy settings from.</param>
        protected MediaTypeFormatter(MediaTypeFormatter formatter)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            _supportedMediaTypes = formatter._supportedMediaTypes;
            SupportedMediaTypes = formatter.SupportedMediaTypes;
            _supportedEncodings = formatter._supportedEncodings;
            SupportedEncodings = formatter.SupportedEncodings;
            _mediaTypeMappings = formatter._mediaTypeMappings;
            MediaTypeMappings = formatter.MediaTypeMappings;
            _requiredMemberSelector = formatter._requiredMemberSelector;
        }

        /// <summary>
        /// Gets or sets the maximum number of keys stored in a NameValueCollection.
        /// </summary>
        public static int MaxHttpCollectionKeys
        {
            get
            {
                if (_maxHttpCollectionKeys < 0)
                {
                    _maxHttpCollectionKeys = _defaultMaxHttpCollectionKeys.Value;
                }

                return _maxHttpCollectionKeys;
            }
            set
            {
                if (value < DefaultMinHttpCollectionKeys)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, DefaultMinHttpCollectionKeys);
                }

                _maxHttpCollectionKeys = value;
            }
        }

        /// <summary>
        /// Gets the mutable collection of <see cref="MediaTypeHeaderValue"/> elements supported by
        /// this <see cref="MediaTypeFormatter"/> instance.
        /// </summary>
        public Collection<MediaTypeHeaderValue> SupportedMediaTypes { get; private set; }

        internal List<MediaTypeHeaderValue> SupportedMediaTypesInternal
        {
            get { return _supportedMediaTypes; }
        }

        /// <summary>
        /// Gets the mutable collection of character encodings supported by
        /// this <see cref="MediaTypeFormatter"/> instance. The encodings are
        /// used when reading or writing data.
        /// </summary>
        public Collection<Encoding> SupportedEncodings { get; private set; }

        internal List<Encoding> SupportedEncodingsInternal
        {
            get { return _supportedEncodings; }
        }

        /// <summary>
        /// Gets the mutable collection of <see cref="MediaTypeMapping"/> elements used
        /// by this <see cref="MediaTypeFormatter"/> instance to determine the
        /// <see cref="MediaTypeHeaderValue"/> of requests or responses.
        /// </summary>
        public Collection<MediaTypeMapping> MediaTypeMappings { get; private set; }

        internal List<MediaTypeMapping> MediaTypeMappingsInternal
        {
            get { return _mediaTypeMappings; }
        }

        /// <summary>
        /// Gets or sets the <see cref="IRequiredMemberSelector"/> used to determine required members.
        /// </summary>
        public virtual IRequiredMemberSelector RequiredMemberSelector
        {
            get
            {
                return _requiredMemberSelector;
            }
            set
            {
                _requiredMemberSelector = value;
            }
        }

        internal virtual bool CanWriteAnyTypes
        {
            get { return true; }
        }

        /// <summary>
        /// Returns a <see cref="Task"/> to deserialize an object of the given <paramref name="type"/> from the given <paramref name="readStream"/>
        /// </summary>
        /// <remarks>
        /// <para>This implementation throws a <see cref="NotSupportedException"/>. Derived types should override this method if the formatter
        /// supports reading.</para>
        /// <para>An implementation of this method should NOT close <paramref name="readStream"/> upon completion. The stream will be closed independently when
        /// the <see cref="HttpContent"/> instance is disposed.
        /// </para>
        /// </remarks>
        /// <param name="type">The type of the object to deserialize.</param>
        /// <param name="readStream">The <see cref="Stream"/> to read.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available. It may be <c>null</c>.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>A <see cref="Task"/> whose result will be an object of the given type.</returns>
        /// <exception cref="NotSupportedException">Derived types need to support reading.</exception>
        /// <seealso cref="CanReadType(Type)"/>
        public virtual Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            throw Error.NotSupported(Properties.Resources.MediaTypeFormatterCannotRead, GetType().Name);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> to deserialize an object of the given <paramref name="type"/> from the given <paramref name="readStream"/>
        /// </summary>
        /// <remarks>
        /// <para>This implementation throws a <see cref="NotSupportedException"/>. Derived types should override this method if the formatter
        /// supports reading.</para>
        /// <para>An implementation of this method should NOT close <paramref name="readStream"/> upon completion. The stream will be closed independently when
        /// the <see cref="HttpContent"/> instance is disposed.
        /// </para>
        /// </remarks>
        /// <param name="type">The type of the object to deserialize.</param>
        /// <param name="readStream">The <see cref="Stream"/> to read.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available. It may be <c>null</c>.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task"/> whose result will be an object of the given type.</returns>
        /// <exception cref="NotSupportedException">Derived types need to support reading.</exception>
        /// <seealso cref="CanReadType(Type)"/>
        public virtual Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            if (cancellationToken.IsCancellationRequested)
            {
                return TaskHelpers.Canceled<object>();
            }

            return ReadFromStreamAsync(type, readStream, content, formatterLogger);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that serializes the given <paramref name="value"/> of the given <paramref name="type"/>
        /// to the given <paramref name="writeStream"/>.
        /// </summary>
        /// <remarks>
        /// <para>This implementation throws a <see cref="NotSupportedException"/>. Derived types should override this method if the formatter
        /// supports reading.</para>
        /// <para>An implementation of this method should NOT close <paramref name="writeStream"/> upon completion. The stream will be closed independently when
        /// the <see cref="HttpContent"/> instance is disposed.
        /// </para>
        /// </remarks>
        /// <param name="type">The type of the object to write.</param>
        /// <param name="value">The object value to write.  It may be <c>null</c>.</param>
        /// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available. It may be <c>null</c>.</param>
        /// <param name="transportContext">The <see cref="TransportContext"/> if available. It may be <c>null</c>.</param>
        /// <returns>A <see cref="Task"/> that will perform the write.</returns>
        /// <exception cref="NotSupportedException">Derived types need to support writing.</exception>
        /// <seealso cref="CanWriteType(Type)"/>
        public virtual Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
        {
            // HttpContent.SerializeToStreamAsync doesn't take in a CancellationToken. So, there is no easy way to get the CancellationToken
            // to the formatter while writing response. We are cheating here by passing fake cancellation tokens. We should fix this
            // when we fix HttpContent.
            return WriteToStreamAsync(type, value, writeStream, content, transportContext, CancellationToken.None);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that serializes the given <paramref name="value"/> of the given <paramref name="type"/>
        /// to the given <paramref name="writeStream"/>.
        /// </summary>
        /// <remarks>
        /// <para>This implementation throws a <see cref="NotSupportedException"/>. Derived types should override this method if the formatter
        /// supports reading.</para>
        /// <para>An implementation of this method should NOT close <paramref name="writeStream"/> upon completion. The stream will be closed independently when
        /// the <see cref="HttpContent"/> instance is disposed.
        /// </para>
        /// </remarks>
        /// <param name="type">The type of the object to write.</param>
        /// <param name="value">The object value to write.  It may be <c>null</c>.</param>
        /// <param name="writeStream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="content">The <see cref="HttpContent"/> if available. It may be <c>null</c>.</param>
        /// <param name="transportContext">The <see cref="TransportContext"/> if available. It may be <c>null</c>.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task"/> that will perform the write.</returns>
        /// <exception cref="NotSupportedException">Derived types need to support writing.</exception>
        /// <seealso cref="CanWriteType(Type)"/>
        public virtual Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            throw Error.NotSupported(Properties.Resources.MediaTypeFormatterCannotWrite, GetType().Name);
        }

        private static bool TryGetDelegatingType(Type interfaceType, ref Type type)
        {
            if (type != null && type.IsInterface() && type.IsGenericType())
            {
                Type genericType = type.ExtractGenericInterface(interfaceType);

                if (genericType != null)
                {
                    type = GetOrAddDelegatingType(type, genericType);
                    return true;
                }
            }

            return false;
        }

        private static int InitializeDefaultCollectionKeySize()
        {
            return Int32.MaxValue;
        }

        /// <summary>
        /// This method converts <see cref="IEnumerable{T}"/> (and interfaces that mandate it) to a <see cref="DelegatingEnumerable{T}"/> for serialization purposes.
        /// </summary>
        /// <param name="type">The type to potentially be wrapped. If the type is wrapped, it's changed in place.</param>
        /// <returns>Returns <c>true</c> if the type was wrapped; <c>false</c>, otherwise</returns>
        internal static bool TryGetDelegatingTypeForIEnumerableGenericOrSame(ref Type type)
        {
            return TryGetDelegatingType(FormattingUtilities.EnumerableInterfaceGenericType, ref type);
        }

        /// <summary>
        /// This method converts <see cref="IQueryable{T}"/> (and interfaces that mandate it) to a <see cref="DelegatingEnumerable{T}"/> for serialization purposes.
        /// </summary>
        /// <param name="type">The type to potentially be wrapped. If the type is wrapped, it's changed in place.</param>
        /// <returns>Returns <c>true</c> if the type was wrapped; <c>false</c>, otherwise</returns>
        internal static bool TryGetDelegatingTypeForIQueryableGenericOrSame(ref Type type)
        {
            return TryGetDelegatingType(FormattingUtilities.QueryableInterfaceGenericType, ref type);
        }

        internal static ConstructorInfo GetTypeRemappingConstructor(Type type)
        {
            ConstructorInfo constructorInfo;
            _delegatingEnumerableConstructorCache.TryGetValue(type, out constructorInfo);
            return constructorInfo;
        }

        /// <summary>
        /// Determines the best <see cref="Encoding"/> amongst the supported encodings
        /// for reading or writing an HTTP entity body based on the provided <paramref name="contentHeaders"/>.
        /// </summary>
        /// <param name="contentHeaders">The content headers provided as part of the request or response.</param>
        /// <returns>The <see cref="Encoding"/> to use when reading the request or writing the response.</returns>
        public Encoding SelectCharacterEncoding(HttpContentHeaders contentHeaders)
        {
            // Performance-sensitive
            Encoding encoding = null;
            if (contentHeaders != null && contentHeaders.ContentType != null)
            {
                // Find encoding based on content type charset parameter
                string charset = contentHeaders.ContentType.CharSet;
                if (!String.IsNullOrWhiteSpace(charset))
                {
                    for (int i = 0; i < _supportedEncodings.Count; i++)
                    {
                        Encoding supportedEncoding = _supportedEncodings[i];
                        if (charset.Equals(supportedEncoding.WebName, StringComparison.OrdinalIgnoreCase))
                        {
                            encoding = supportedEncoding;
                            break;
                        }
                    }
                }
            }

            if (encoding == null)
            {
                // We didn't find a character encoding match based on the content headers.
                // Instead we try getting the default character encoding.
                if (_supportedEncodings.Count > 0)
                {
                    encoding = _supportedEncodings[0];
                }
            }

            if (encoding == null)
            {
                // No supported encoding was found so there is no way for us to start reading or writing.
                throw Error.InvalidOperation(Properties.Resources.MediaTypeFormatterNoEncoding, GetType().Name);
            }

            return encoding;
        }

        /// <summary>
        /// Sets the default headers for content that will be formatted using this formatter. This method
        /// is called from the <see cref="ObjectContent"/> constructor.
        /// This implementation sets the Content-Type header to the value of <paramref name="mediaType"/> if it is
        /// not <c>null</c>. If it is <c>null</c> it sets the Content-Type to the default media type of this formatter.
        /// If the Content-Type does not specify a charset it will set it using this formatters configured
        /// <see cref="Encoding"/>.
        /// </summary>
        /// <remarks>
        /// Subclasses can override this method to set content headers such as Content-Type etc. Subclasses should
        /// call the base implementation. Subclasses should treat the passed in <paramref name="mediaType"/> (if not <c>null</c>)
        /// as the authoritative media type and use that as the Content-Type.
        /// </remarks>
        /// <param name="type">The type of the object being serialized. See <see cref="ObjectContent"/>.</param>
        /// <param name="headers">The content headers that should be configured.</param>
        /// <param name="mediaType">The authoritative media type. Can be <c>null</c>.</param>
        public virtual void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            if (mediaType != null)
            {
                headers.ContentType = mediaType.Clone();
            }

            // If content type is not set then set it based on supported media types.
            if (headers.ContentType == null)
            {
                MediaTypeHeaderValue defaultMediaType = null;
                if (_supportedMediaTypes.Count > 0)
                {
                    defaultMediaType = _supportedMediaTypes[0];
                }
                if (defaultMediaType != null)
                {
                    headers.ContentType = defaultMediaType.Clone();
                }
            }

            // If content type charset parameter is not set then set it based on the supported encodings.
            if (headers.ContentType != null && headers.ContentType.CharSet == null)
            {
                Encoding defaultEncoding = null;
                if (_supportedEncodings.Count > 0)
                {
                    defaultEncoding = _supportedEncodings[0];
                }
                if (defaultEncoding != null)
                {
                    headers.ContentType.CharSet = defaultEncoding.WebName;
                }
            }
        }

        /// <summary>
        /// Returns a specialized instance of the <see cref="MediaTypeFormatter"/> that can handle formatting a response for the given
        /// parameters. This method is called after a formatter has been selected through content negotiation.
        /// </summary>
        /// <remarks>
        /// The default implementation returns <c>this</c> instance. Derived classes can choose to return a new instance if
        /// they need to close over any of the parameters.
        /// </remarks>
        /// <param name="type">The type being serialized.</param>
        /// <param name="request">The request.</param>
        /// <param name="mediaType">The media type chosen for the serialization. Can be <c>null</c>.</param>
        /// <returns>An instance that can format a response to the given <paramref name="request"/>.</returns>
        public virtual MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return this;
        }

        /// <summary>
        /// Determines whether this <see cref="MediaTypeFormatter"/> can deserialize
        /// an object of the specified type.
        /// </summary>
        /// <remarks>
        /// Derived classes must implement this method and indicate if a type can or cannot be deserialized.
        /// </remarks>
        /// <param name="type">The type of object that will be deserialized.</param>
        /// <returns><c>true</c> if this <see cref="MediaTypeFormatter"/> can deserialize an object of that type; otherwise <c>false</c>.</returns>
        public abstract bool CanReadType(Type type);

        /// <summary>
        /// Determines whether this <see cref="MediaTypeFormatter"/> can serialize
        /// an object of the specified type.
        /// </summary>
        /// <remarks>
        /// Derived classes must implement this method and indicate if a type can or cannot be serialized.
        /// </remarks>
        /// <param name="type">The type of object that will be serialized.</param>
        /// <returns><c>true</c> if this <see cref="MediaTypeFormatter"/> can serialize an object of that type; otherwise <c>false</c>.</returns>
        public abstract bool CanWriteType(Type type);

        private static Type GetOrAddDelegatingType(Type type, Type genericType)
        {
            return _delegatingEnumerableCache.GetOrAdd(
                type,
                (typeToRemap) =>
                {
                    // The current method is called by methods that already checked the type for is not null, is generic and is or implements IEnumerable<T>
                    // This retrieves the T type of the IEnumerable<T> interface.
                    Type elementType = genericType.GetGenericArguments()[0];
                    Type delegatingType = FormattingUtilities.DelegatingEnumerableGenericType.MakeGenericType(elementType);
                    ConstructorInfo delegatingConstructor = delegatingType.GetConstructor(new Type[] { FormattingUtilities.EnumerableInterfaceGenericType.MakeGenericType(elementType) });
                    _delegatingEnumerableConstructorCache.TryAdd(delegatingType, delegatingConstructor);

                    return delegatingType;
                });
        }

        /// <summary>
        /// Gets the default value for the specified type.
        /// </summary>
        public static object GetDefaultValueForType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (type.IsValueType())
            {
                return Activator.CreateInstance(type);
            }
            return null;
        }

        private protected static void WritePreamble(Stream stream, Encoding encoding)
        {
            byte[] bytes = encoding.GetPreamble();
            if (bytes.Length > 0)
            {
                stream.Write(bytes, 0, bytes.Length);
            }
        }

        /// <summary>
        /// Collection class that validates it contains only <see cref="MediaTypeHeaderValue"/> instances
        /// that are not null and not media ranges.
        /// </summary>
        internal class MediaTypeHeaderValueCollection : Collection<MediaTypeHeaderValue>
        {
            private static readonly Type _mediaTypeHeaderValueType = typeof(MediaTypeHeaderValue);

            internal MediaTypeHeaderValueCollection(IList<MediaTypeHeaderValue> list)
                : base(list)
            {
            }

            /// <summary>
            /// Inserts the <paramref name="item"/> into the collection at the specified <paramref name="index"/>.
            /// </summary>
            /// <param name="index">The zero-based index at which item should be inserted.</param>
            /// <param name="item">The object to insert. It cannot be <c>null</c>.</param>
            protected override void InsertItem(int index, MediaTypeHeaderValue item)
            {
                ValidateMediaType(item);
                base.InsertItem(index, item);
            }

            /// <summary>
            /// Replaces the element at the specified <paramref name="index"/>.
            /// </summary>
            /// <param name="index">The zero-based index of the item that should be replaced.</param>
            /// <param name="item">The new value for the element at the specified index.  It cannot be <c>null</c>.</param>
            protected override void SetItem(int index, MediaTypeHeaderValue item)
            {
                ValidateMediaType(item);
                base.SetItem(index, item);
            }

            private static void ValidateMediaType(MediaTypeHeaderValue item)
            {
                if (item == null)
                {
                    throw Error.ArgumentNull("item");
                }

                ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(item);
                if (parsedMediaType.IsAllMediaRange || parsedMediaType.IsSubtypeMediaRange)
                {
                    throw Error.Argument("item", Properties.Resources.CannotUseMediaRangeForSupportedMediaType, _mediaTypeHeaderValueType.Name, item.MediaType);
                }
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeFormatterCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http.Headers;
using System.Web.Http;
using System.Xml;
using System.Xml.Linq;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Collection class that contains <see cref="MediaTypeFormatter"/> instances.
    /// </summary>
    public class MediaTypeFormatterCollection : Collection<MediaTypeFormatter>
    {
        private static readonly Type _mediaTypeFormatterType = typeof(MediaTypeFormatter);

        private MediaTypeFormatter[] _writingFormatters;

        /// <summary>
        /// Initializes a new instance of the <see cref="MediaTypeFormatterCollection"/> class.
        /// </summary>
        /// <remarks>
        /// This collection will be initialized to contain default <see cref="MediaTypeFormatter"/>
        /// instances for Xml, JsonValue and Json.
        /// </remarks>
        public MediaTypeFormatterCollection()
            : this(CreateDefaultFormatters())
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MediaTypeFormatterCollection"/> class.
        /// </summary>
        /// <param name="formatters">A collection of <see cref="MediaTypeFormatter"/> instances to place in the collection.</param>
        public MediaTypeFormatterCollection(IEnumerable<MediaTypeFormatter> formatters)
        {
            VerifyAndSetFormatters(formatters);
        }

        internal event EventHandler Changing;

        /// <summary>
        /// Gets the <see cref="MediaTypeFormatter"/> to use for Xml.
        /// </summary>
        public XmlMediaTypeFormatter XmlFormatter
        {
            get { return Items.OfType<XmlMediaTypeFormatter>().FirstOrDefault(); }
        }

        /// <summary>
        /// Gets the <see cref="MediaTypeFormatter"/> to use for Json.
        /// </summary>
        public JsonMediaTypeFormatter JsonFormatter
        {
            get { return Items.OfType<JsonMediaTypeFormatter>().FirstOrDefault(); }
        }

        /// <summary>
        /// Gets the <see cref="MediaTypeFormatter"/> to use for <c>application/x-www-form-urlencoded</c> data.
        /// </summary>
        public FormUrlEncodedMediaTypeFormatter FormUrlEncodedFormatter
        {
            get { return Items.OfType<FormUrlEncodedMediaTypeFormatter>().FirstOrDefault(); }
        }

        internal MediaTypeFormatter[] WritingFormatters
        {
            get
            {
                if (_writingFormatters == null)
                {
                    _writingFormatters = GetWritingFormatters();
                }
                return _writingFormatters;
            }
        }

        /// <summary>
        /// Adds the elements of the specified collection to the end of the <see cref="MediaTypeFormatterCollection"/>.
        /// </summary>
        /// <param name="items">
        /// The items that should be added to the end of the <see cref="MediaTypeFormatterCollection"/>.
        /// The items collection itself cannot be <see langword="null"/>, but it can contain elements that are
        /// <see langword="null"/>.
        /// </param>
        public void AddRange(IEnumerable<MediaTypeFormatter> items)
        {
            if (items == null)
            {
                throw Error.ArgumentNull("items");
            }

            foreach (MediaTypeFormatter item in items)
            {
                Add(item);
            }
        }

        /// <summary>
        /// Inserts the elements of a collection into the <see cref="MediaTypeFormatterCollection"/> at the specified
        /// index.
        /// </summary>
        /// <param name="index">The zero-based index at which the new elements should be inserted.</param>
        /// <param name="items">
        /// The items that should be inserted into the <see cref="MediaTypeFormatterCollection"/>. The items collection
        /// itself cannot be <see langword="null"/>, but it can contain elements that are <see langword="null"/>.
        /// </param>
        public void InsertRange(int index, IEnumerable<MediaTypeFormatter> items)
        {
            if (items == null)
            {
                throw Error.ArgumentNull("items");
            }

            foreach (MediaTypeFormatter item in items)
            {
                Insert(index++, item);
            }
        }

        /// <summary>
        /// Helper to search a collection for a formatter that can read the .NET type in the given mediaType.
        /// </summary>
        /// <param name="type">.NET type to read</param>
        /// <param name="mediaType">media type to match on.</param>
        /// <returns>Formatter that can read the type. Null if no formatter found.</returns>
        public MediaTypeFormatter FindReader(Type type, MediaTypeHeaderValue mediaType)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (mediaType == null)
            {
                throw Error.ArgumentNull("mediaType");
            }

            foreach (MediaTypeFormatter formatter in Items)
            {
                if (formatter != null && formatter.CanReadType(type))
                {
                    foreach (MediaTypeHeaderValue supportedMediaType in formatter.SupportedMediaTypes)
                    {
                        if (supportedMediaType != null && supportedMediaType.IsSubsetOf(mediaType))
                        {
                            return formatter;
                        }
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Helper to search a collection for a formatter that can write the .NET type in the given mediaType.
        /// </summary>
        /// <param name="type">.NET type to read</param>
        /// <param name="mediaType">media type to match on.</param>
        /// <returns>Formatter that can write the type. Null if no formatter found.</returns>
        public MediaTypeFormatter FindWriter(Type type, MediaTypeHeaderValue mediaType)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (mediaType == null)
            {
                throw Error.ArgumentNull("mediaType");
            }

            foreach (MediaTypeFormatter formatter in Items)
            {
                if (formatter != null && formatter.CanWriteType(type))
                {
                    foreach (MediaTypeHeaderValue supportedMediaType in formatter.SupportedMediaTypes)
                    {
                        if (supportedMediaType != null && supportedMediaType.IsSubsetOf(mediaType))
                        {
                            return formatter;
                        }
                    }
                }
            }

            return null;
        }

        /// <summary>
        /// Returns true if the type is one of those loosely defined types that should be excluded from validation
        /// </summary>
        /// <param name="type">.NET <see cref="Type"/> to validate</param>
        /// <returns><c>true</c> if the type should be excluded.</returns>
        public static bool IsTypeExcludedFromValidation(Type type)
        {
            return
                typeof(XmlNode).IsAssignableFrom(type) ||
                typeof(FormDataCollection).IsAssignableFrom(type) ||
                FormattingUtilities.IsJTokenType(type) ||
                typeof(XObject).IsAssignableFrom(type) ||
                typeof(Type).IsAssignableFrom(type) ||
                type == typeof(byte[]);
        }

        protected override void ClearItems()
        {
            OnChanging();
            base.ClearItems();
        }

        protected override void InsertItem(int index, MediaTypeFormatter item)
        {
            OnChanging();
            base.InsertItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            OnChanging();
            base.RemoveItem(index);
        }

        protected override void SetItem(int index, MediaTypeFormatter item)
        {
            OnChanging();
            base.SetItem(index, item);
        }

        private void OnChanging()
        {
            if (Changing != null)
            {
                Changing(this, EventArgs.Empty);
            }

            // Clear cached state
            _writingFormatters = null;
        }

        private MediaTypeFormatter[] GetWritingFormatters()
        {
            return Items.Where((formatter) => formatter != null && formatter.CanWriteAnyTypes).ToArray();
        }

        /// <summary>
        /// Creates a collection of new instances of the default <see cref="MediaTypeFormatter"/>s.
        /// </summary>
        /// <returns>The collection of default <see cref="MediaTypeFormatter"/> instances.</returns>
        private static IEnumerable<MediaTypeFormatter> CreateDefaultFormatters()
        {
            return new MediaTypeFormatter[]
            {
                new JsonMediaTypeFormatter(),
                new XmlMediaTypeFormatter()
#if NETSTANDARD1_3 // XsdDataContractExporter is not supported in netstandard1.3. Cannot use DCS.
                { UseXmlSerializer = true }
#endif
                ,
                new FormUrlEncodedMediaTypeFormatter()
            };
        }

        private void VerifyAndSetFormatters(IEnumerable<MediaTypeFormatter> formatters)
        {
            if (formatters == null)
            {
                throw Error.ArgumentNull("formatters");
            }

            foreach (MediaTypeFormatter formatter in formatters)
            {
                if (formatter == null)
                {
                    throw Error.Argument("formatters", Properties.Resources.CannotHaveNullInList, _mediaTypeFormatterType.Name);
                }

                Add(formatter);
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeFormatterExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Extensions for adding <see cref="MediaTypeMapping"/> items to a <see cref="MediaTypeFormatter"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class MediaTypeFormatterExtensions
    {
        /// <summary>
        /// Updates the given <paramref name="formatter"/>'s set of <see cref="MediaTypeMapping"/> elements
        /// so that it associates the <paramref name="mediaType"/> with <see cref="Uri"/>s containing
        /// a specific query parameter and value.
        /// </summary>
        /// <param name="formatter">The <see cref="MediaTypeFormatter"/> to receive the new <see cref="QueryStringMapping"/> item.</param>
        /// <param name="queryStringParameterName">The name of the query parameter.</param>
        /// <param name="queryStringParameterValue">The value assigned to that query parameter.</param>
        /// <param name="mediaType">The <see cref="MediaTypeHeaderValue"/> to associate 
        /// with a <see cref="Uri"/> containing a query string matching <paramref name="queryStringParameterName"/> 
        /// and <paramref name="queryStringParameterValue"/>.</param>
        public static void AddQueryStringMapping(
            this MediaTypeFormatter formatter,
            string queryStringParameterName,
            string queryStringParameterValue,
            MediaTypeHeaderValue mediaType)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            formatter.MediaTypeMappings.Add(mapping);
        }

        /// <summary>
        /// Updates the given <paramref name="formatter"/>'s set of <see cref="MediaTypeMapping"/> elements
        /// so that it associates the <paramref name="mediaType"/> with <see cref="Uri"/>s containing
        /// a specific query parameter and value.
        /// </summary>
        /// <param name="formatter">The <see cref="MediaTypeFormatter"/> to receive the new <see cref="QueryStringMapping"/> item.</param>
        /// <param name="queryStringParameterName">The name of the query parameter.</param>
        /// <param name="queryStringParameterValue">The value assigned to that query parameter.</param>
        /// <param name="mediaType">The media type to associate 
        /// with a <see cref="Uri"/> containing a query string matching <paramref name="queryStringParameterName"/>
        /// and <paramref name="queryStringParameterValue"/>.</param>
        public static void AddQueryStringMapping(
            this MediaTypeFormatter formatter,
            string queryStringParameterName,
            string queryStringParameterValue,
            string mediaType)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            formatter.MediaTypeMappings.Add(mapping);
        }

        /// <summary>
        /// Updates the given <paramref name="formatter"/>'s set of <see cref="MediaTypeMapping"/> elements
        /// so that it associates the <paramref name="mediaType"/> with a specific HTTP request header field
        /// with a specific value.
        /// </summary>
        /// <remarks><see cref="RequestHeaderMapping"/> checks header fields associated with <see cref="M:HttpRequestMessage.Headers"/> for a match. It does
        /// not check header fields associated with <see cref="M:HttpResponseMessage.Headers"/> or <see cref="M:HttpContent.Headers"/> instances.</remarks>
        /// <param name="formatter">The <see cref="MediaTypeFormatter"/> to receive the new <see cref="MediaTypeMapping"/> item.</param>
        /// <param name="headerName">Name of the header to match.</param>
        /// <param name="headerValue">The header value to match.</param>
        /// <param name="valueComparison">The <see cref="StringComparison"/> to use when matching <paramref name="headerValue"/>.</param>
        /// <param name="isValueSubstring">if set to <c>true</c> then <paramref name="headerValue"/> is 
        /// considered a match if it matches a substring of the actual header value.</param>
        /// <param name="mediaType">The <see cref="MediaTypeHeaderValue"/> to associate 
        /// with a <see cref="M:HttpRequestMessage.Header"/> entry with a name matching <paramref name="headerName"/>
        /// and a value matching <paramref name="headerValue"/>.</param>
        public static void AddRequestHeaderMapping(
            this MediaTypeFormatter formatter,
            string headerName,
            string headerValue,
            StringComparison valueComparison,
            bool isValueSubstring,
            MediaTypeHeaderValue mediaType)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, valueComparison, isValueSubstring, mediaType);
            formatter.MediaTypeMappings.Add(mapping);
        }

        /// <summary>
        /// Updates the given <paramref name="formatter"/>'s set of <see cref="MediaTypeMapping"/> elements
        /// so that it associates the <paramref name="mediaType"/> with a specific HTTP request header field
        /// with a specific value.
        /// </summary>
        /// <remarks><see cref="RequestHeaderMapping"/> checks header fields associated with <see cref="M:HttpRequestMessage.Headers"/> for a match. It does
        /// not check header fields associated with <see cref="M:HttpResponseMessage.Headers"/> or <see cref="M:HttpContent.Headers"/> instances.</remarks>
        /// <param name="formatter">The <see cref="MediaTypeFormatter"/> to receive the new <see cref="MediaTypeMapping"/> item.</param>
        /// <param name="headerName">Name of the header to match.</param>
        /// <param name="headerValue">The header value to match.</param>
        /// <param name="valueComparison">The <see cref="StringComparison"/> to use when matching <paramref name="headerValue"/>.</param>
        /// <param name="isValueSubstring">if set to <c>true</c> then <paramref name="headerValue"/> is 
        /// considered a match if it matches a substring of the actual header value.</param>
        /// <param name="mediaType">The media type to associate 
        /// with a <see cref="M:HttpRequestMessage.Header"/> entry with a name matching <paramref name="headerName"/>
        /// and a value matching <paramref name="headerValue"/>.</param>
        public static void AddRequestHeaderMapping(
            this MediaTypeFormatter formatter,
            string headerName,
            string headerValue,
            StringComparison valueComparison,
            bool isValueSubstring,
            string mediaType)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, valueComparison, isValueSubstring, mediaType);
            formatter.MediaTypeMappings.Add(mapping);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeFormatterMatch.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// This class describes how well a particular <see cref="MediaTypeFormatter"/> matches a request.
    /// </summary>
    public class MediaTypeFormatterMatch
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="MediaTypeFormatterMatch"/> class.
        /// </summary>
        /// <param name="formatter">The matching formatter.</param>
        /// <param name="mediaType">The media type. Can be <c>null</c> in which case the media type <c>application/octet-stream</c> is used.</param>
        /// <param name="quality">The quality of the match. Can be <c>null</c> in which case it is considered a full match with a value of 1.0</param>
        /// <param name="ranking">The kind of match.</param>
        public MediaTypeFormatterMatch(MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, double? quality, MediaTypeFormatterMatchRanking ranking)
        {
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            Formatter = formatter;
            MediaType = mediaType != null ? mediaType.Clone() : MediaTypeConstants.ApplicationOctetStreamMediaType;
            Quality = quality ?? FormattingUtilities.Match;
            Ranking = ranking;
        }

        /// <summary>
        /// Gets the media type formatter.
        /// </summary>
        public MediaTypeFormatter Formatter { get; private set; }

        /// <summary>
        /// Gets the matched media type.
        /// </summary>
        public MediaTypeHeaderValue MediaType { get; private set; }

        /// <summary>
        /// Gets the quality of the match
        /// </summary>
        public double Quality { get; private set; }

        /// <summary>
        /// Gets the kind of match that occurred.
        /// </summary>
        public MediaTypeFormatterMatchRanking Ranking { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeFormatterMatchRanking.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Contains information about the degree to which a <see cref="MediaTypeFormatter"/> matches the  
    /// explicit or implicit preferences found in an incoming request.
    /// </summary>
    public enum MediaTypeFormatterMatchRanking
    {
        /// <summary>
        /// No match was found
        /// </summary>
        None = 0,

        /// <summary>
        /// Matched on type meaning that the formatter is able to serialize the type
        /// </summary>
        MatchOnCanWriteType,

        /// <summary>
        /// Matched on explicit literal accept header in <see cref="HttpRequestMessage"/>, 
        /// e.g. "application/json".
        /// </summary>
        MatchOnRequestAcceptHeaderLiteral,

        /// <summary>
        /// Matched on explicit subtype range accept header in <see cref="HttpRequestMessage"/>,
        /// e.g. "application/*".
        /// </summary>
        MatchOnRequestAcceptHeaderSubtypeMediaRange,

        /// <summary>
        /// Matched on explicit all media type range accept header in <see cref="HttpRequestMessage"/>,
        /// e.g. "*/*"
        /// </summary>
        MatchOnRequestAcceptHeaderAllMediaRange,

        /// <summary>
        /// Matched on <see cref="HttpRequestMessage"/> after having applied
        /// the various <see cref="MediaTypeMapping"/>s.
        /// </summary>
        MatchOnRequestWithMediaTypeMapping,

        /// <summary>
        /// Matched on the media type of the <see cref="HttpContent"/> of the <see cref="HttpRequestMessage"/>.
        /// </summary>
        MatchOnRequestMediaType,
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeHeaderValueExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http.Headers;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Extension methods for <see cref="MediaTypeHeaderValue"/>.
    /// </summary>
    internal static class MediaTypeHeaderValueExtensions
    {
        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
        /// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
        /// parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2)
        {
            MediaTypeHeaderValueRange mediaType2Range;
            return IsSubsetOf(mediaType1, mediaType2, out mediaType2Range);
        }

        /// <summary>
        /// Determines whether two <see cref="MediaTypeHeaderValue"/> instances match. The instance
        /// <paramref name="mediaType1"/> is said to match <paramref name="mediaType2"/> if and only if
        /// <paramref name="mediaType1"/> is a strict subset of the values and parameters of <paramref name="mediaType2"/>.
        /// That is, if the media type and media type parameters of <paramref name="mediaType1"/> are all present
        /// and match those of <paramref name="mediaType2"/> then it is a match even though <paramref name="mediaType2"/> may have additional
        /// parameters.
        /// </summary>
        /// <param name="mediaType1">The first media type.</param>
        /// <param name="mediaType2">The second media type.</param>
        /// <param name="mediaType2Range">Indicates whether <paramref name="mediaType2"/> is a regular media type, a subtype media range, or a full media range</param>
        /// <returns><c>true</c> if this is a subset of <paramref name="mediaType2"/>; false otherwise.</returns>
        public static bool IsSubsetOf(this MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2, out MediaTypeHeaderValueRange mediaType2Range)
        {
            // Performance-sensitive
            Contract.Assert(mediaType1 != null);

            if (mediaType2 == null)
            {
                mediaType2Range = MediaTypeHeaderValueRange.None;
                return false;
            }

            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);
            mediaType2Range = parsedMediaType2.IsAllMediaRange ? MediaTypeHeaderValueRange.AllMediaRange :
                parsedMediaType2.IsSubtypeMediaRange ? MediaTypeHeaderValueRange.SubtypeMediaRange :
                MediaTypeHeaderValueRange.None;

            if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.AllMediaRange)
                {
                    return false;
                }
            }
            else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
            {
                if (mediaType2Range != MediaTypeHeaderValueRange.SubtypeMediaRange)
                {
                    return false;
                }
            }

            // So far we either have a full match or a subset match. Now check that all of
            // mediaType1's parameters are present and equal in mediatype2
            // Optimize for the common case where the parameters inherit from Collection<T> and cache the count which is faster for Collection<T>.
            Collection<NameValueHeaderValue> parameters1 = mediaType1.Parameters.AsCollection();
            int parameterCount1 = parameters1.Count;
            Collection<NameValueHeaderValue> parameters2 = mediaType2.Parameters.AsCollection();
            int parameterCount2 = parameters2.Count;
            for (int i = 0; i < parameterCount1; i++)
            {
                NameValueHeaderValue parameter1 = parameters1[i];
                bool found = false;
                for (int j = 0; j < parameterCount2; j++)
                {
                    NameValueHeaderValue parameter2 = parameters2[j];
                    if (parameter1.Equals(parameter2))
                    {
                        found = true;
                        break;
                    }
                }
                if (!found)
                {
                    return false;
                }
            }
            return true;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeHeaderValueRange.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http.Formatting
{
    internal enum MediaTypeHeaderValueRange
    {
        /// <summary>
        /// Not a media type range
        /// </summary>
        None = 0,

        /// <summary>
        /// A subtype media range, e.g. "application/*".
        /// </summary>
        SubtypeMediaRange,

        /// <summary>
        /// An all media range, e.g. "*/*".
        /// </summary>
        AllMediaRange,
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// An abstract base class used to create an association between <see cref="HttpRequestMessage"/> or 
    /// <see cref="HttpResponseMessage"/> instances that have certain characteristics 
    /// and a specific <see cref="MediaTypeHeaderValue"/>. 
    /// </summary>
    public abstract class MediaTypeMapping
    {
        /// <summary>
        /// Initializes a new instance of a <see cref="MediaTypeMapping"/> with the
        /// given <paramref name="mediaType"/> value.
        /// </summary>
        /// <param name="mediaType">
        /// The <see cref="MediaTypeHeaderValue"/> that is associated with <see cref="HttpRequestMessage"/> or 
        /// <see cref="HttpResponseMessage"/> instances that have the given characteristics of the 
        /// <see cref="MediaTypeMapping"/>.
        /// </param>
        protected MediaTypeMapping(MediaTypeHeaderValue mediaType)
        {
            if (mediaType == null)
            {
                throw Error.ArgumentNull("mediaType");
            }

            MediaType = mediaType;
        }

        /// <summary>
        /// Initializes a new instance of a <see cref="MediaTypeMapping"/> with the
        /// given <paramref name="mediaType"/> value.
        /// </summary>
        /// <param name="mediaType">
        /// The <see cref="string"/> that is associated with <see cref="HttpRequestMessage"/> or 
        /// <see cref="HttpResponseMessage"/> instances that have the given characteristics of the 
        /// <see cref="MediaTypeMapping"/>.
        /// </param>
        protected MediaTypeMapping(string mediaType)
        {
            if (String.IsNullOrWhiteSpace(mediaType))
            {
                throw Error.ArgumentNull("mediaType");
            }

            MediaType = new MediaTypeHeaderValue(mediaType);
        }

        /// <summary>
        /// Gets the <see cref="MediaTypeHeaderValue"/> that is associated with <see cref="HttpRequestMessage"/> or 
        /// <see cref="HttpResponseMessage"/> instances that have the given characteristics of the 
        /// <see cref="MediaTypeMapping"/>.
        /// </summary>
        public MediaTypeHeaderValue MediaType { get; private set; }

        /// <summary>
        /// Returns the quality of the match of the <see cref="MediaTypeHeaderValue"/>
        /// associated with <paramref name="request"/>.
        /// </summary>
        /// <param name="request">
        /// The <see cref="HttpRequestMessage"/> to evaluate for the characteristics 
        /// associated with the <see cref="MediaTypeHeaderValue"/>
        /// of the <see cref="MediaTypeMapping"/>.
        /// </param> 
        /// <returns>
        /// The quality of the match. It must be between <c>0.0</c> and <c>1.0</c>.
        /// A value of <c>0.0</c> signifies no match.
        /// A value of <c>1.0</c> signifies a complete match.
        /// </returns>
        public abstract double TryMatchMediaType(HttpRequestMessage request);
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/MediaTypeWithQualityHeaderValueComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http.Headers;

namespace System.Net.Http.Formatting
{
    /// Implementation of <see cref="IComparer{T}"/> that can compare accept media type header fields
    /// based on their quality values (a.k.a q-values). See
    /// <see cref="StringWithQualityHeaderValueComparer"/> for a comparer for other content negotiation
    /// header field q-values.
    internal class MediaTypeWithQualityHeaderValueComparer : IComparer<MediaTypeWithQualityHeaderValue>
    {
        private static readonly MediaTypeWithQualityHeaderValueComparer _mediaTypeComparer = new MediaTypeWithQualityHeaderValueComparer();

        private MediaTypeWithQualityHeaderValueComparer()
        {
        }

        public static MediaTypeWithQualityHeaderValueComparer QualityComparer
        {
            get { return _mediaTypeComparer; }
        }

        /// <summary>
        /// Compares two <see cref="MediaTypeWithQualityHeaderValue"/> based on their quality value (a.k.a their "q-value").
        /// Values with identical q-values are considered equal (i.e the result is 0) with the exception that sub-type wild-cards are
        /// considered less than specific media types and full wild-cards are considered less than sub-type wild-cards. This allows to
        /// sort a sequence of <see cref="StringWithQualityHeaderValue"/> following their q-values in the order of specific media types,
        /// sub-type wildcards, and last any full wild-cards.
        /// </summary>
        /// <param name="mediaType1">The first <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
        /// <param name="mediaType2">The second <see cref="MediaTypeWithQualityHeaderValue"/> to compare.</param>
        /// <returns></returns>
        public int Compare(MediaTypeWithQualityHeaderValue mediaType1, MediaTypeWithQualityHeaderValue mediaType2)
        {
            Contract.Assert(mediaType1 != null, "The 'mediaType1' parameter should not be null.");
            Contract.Assert(mediaType2 != null, "The 'mediaType2' parameter should not be null.");

            if (Object.ReferenceEquals(mediaType1, mediaType2))
            {
                return 0;
            }

            int returnValue = CompareBasedOnQualityFactor(mediaType1, mediaType2);

            if (returnValue == 0)
            {
                ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
                ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

                if (!parsedMediaType1.TypesEqual(ref parsedMediaType2))
                {
                    if (parsedMediaType1.IsAllMediaRange)
                    {
                        return -1;
                    }
                    else if (parsedMediaType2.IsAllMediaRange)
                    {
                        return 1;
                    }
                    else if (parsedMediaType1.IsSubtypeMediaRange && !parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return -1;
                    }
                    else if (!parsedMediaType1.IsSubtypeMediaRange && parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return 1;
                    }
                }
                else if (!parsedMediaType1.SubTypesEqual(ref parsedMediaType2))
                {
                    if (parsedMediaType1.IsSubtypeMediaRange)
                    {
                        return -1;
                    }
                    else if (parsedMediaType2.IsSubtypeMediaRange)
                    {
                        return 1;
                    }
                }
            }

            return returnValue;
        }

        private static int CompareBasedOnQualityFactor(MediaTypeWithQualityHeaderValue mediaType1, MediaTypeWithQualityHeaderValue mediaType2)
        {
            Contract.Assert(mediaType1 != null);
            Contract.Assert(mediaType2 != null);

            double mediaType1Quality = mediaType1.Quality ?? FormattingUtilities.Match;
            double mediaType2Quality = mediaType2.Quality ?? FormattingUtilities.Match;
            double qualityDifference = mediaType1Quality - mediaType2Quality;
            if (qualityDifference < 0)
            {
                return -1;
            }
            else if (qualityDifference > 0)
            {
                return 1;
            }

            return 0;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/ParsedMediaTypeHeaderValue.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http.Headers;

namespace System.Net.Http.Formatting
{
    // This type is instanciated by frequently called comparison methods so is very performance sensitive
    internal struct ParsedMediaTypeHeaderValue
    {
        private const char MediaRangeAsterisk = '*';
        private const char MediaTypeSubtypeDelimiter = '/';

        private readonly string _mediaType;
        private readonly int _delimiterIndex;
        private readonly bool _isAllMediaRange;
        private readonly bool _isSubtypeMediaRange;

        public ParsedMediaTypeHeaderValue(MediaTypeHeaderValue mediaTypeHeaderValue)
        {
            Contract.Assert(mediaTypeHeaderValue != null);
            string mediaType = _mediaType = mediaTypeHeaderValue.MediaType;
            _delimiterIndex = mediaType.IndexOf(MediaTypeSubtypeDelimiter);
            Contract.Assert(_delimiterIndex > 0, "The constructor of the MediaTypeHeaderValue would have failed if there wasn't a type and subtype.");

            _isAllMediaRange = false;
            _isSubtypeMediaRange = false;
            int mediaTypeLength = mediaType.Length;
            if (_delimiterIndex == mediaTypeLength - 2)
            {
                if (mediaType[mediaTypeLength - 1] == MediaRangeAsterisk)
                {
                    _isSubtypeMediaRange = true;
                    if (_delimiterIndex == 1 && mediaType[0] == MediaRangeAsterisk)
                    {
                        _isAllMediaRange = true;
                    }
                }
            }
        }

        public bool IsAllMediaRange
        {
            get { return _isAllMediaRange; }
        }

        public bool IsSubtypeMediaRange
        {
            get { return _isSubtypeMediaRange; }
        }

        public bool TypesEqual(ref ParsedMediaTypeHeaderValue other)
        {
            if (_delimiterIndex != other._delimiterIndex)
            {
                return false;
            }
            return String.Compare(_mediaType, 0, other._mediaType, 0, _delimiterIndex, StringComparison.OrdinalIgnoreCase) == 0;
        }

        public bool SubTypesEqual(ref ParsedMediaTypeHeaderValue other)
        {
            int _subTypeLength = _mediaType.Length - _delimiterIndex - 1;
            if (_subTypeLength != other._mediaType.Length - other._delimiterIndex - 1)
            {
                return false;
            }
            return String.Compare(_mediaType, _delimiterIndex + 1, other._mediaType, other._delimiterIndex + 1, _subTypeLength, StringComparison.OrdinalIgnoreCase) == 0;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/FormUrlEncodedParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// Buffer-oriented parsing of HTML form URL-ended, also known as <c>application/x-www-form-urlencoded</c>, data.
    /// </summary>
    internal class FormUrlEncodedParser
    {
        private const int MinMessageSize = 1;
        private long _totalBytesConsumed;
        private long _maxMessageSize;

        private NameValueState _nameValueState;
        private ICollection<KeyValuePair<string, string>> _nameValuePairs;
        private readonly CurrentNameValuePair _currentNameValuePair;

        /// <summary>
        /// Initializes a new instance of the <see cref="FormUrlEncodedParser"/> class.
        /// </summary>
        /// <param name="nameValuePairs">The collection to which name value pairs are added as they are parsed.</param>
        /// <param name="maxMessageSize">Maximum length of all the individual name value pairs.</param>
        public FormUrlEncodedParser(ICollection<KeyValuePair<string, string>> nameValuePairs, long maxMessageSize)
        {
            // The minimum length which would be an empty buffer
            if (maxMessageSize < MinMessageSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxMessageSize", maxMessageSize, MinMessageSize);
            }

            if (nameValuePairs == null)
            {
                throw Error.ArgumentNull("nameValuePairs");
            }

            _nameValuePairs = nameValuePairs;
            _maxMessageSize = maxMessageSize;
            _currentNameValuePair = new CurrentNameValuePair();
        }

        private enum NameValueState
        {
            Name = 0,
            Value
        }

        /// <summary>
        /// Parse a buffer of URL form-encoded name-value pairs and add them to the collection.
        /// Bytes are parsed in a consuming manner from the beginning of the buffer meaning that the same bytes can not be
        /// present in the buffer.
        /// </summary>
        /// <param name="buffer">Buffer from where data is read</param>
        /// <param name="bytesReady">Size of buffer</param>
        /// <param name="bytesConsumed">Offset into buffer</param>
        /// <param name="isFinal">Indicates whether the end of the URL form-encoded data has been reached.</param>
        /// <returns>State of the parser. Call this method with new data until it reaches a final state.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is translated to parse state.")]
        public ParserState ParseBuffer(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed,
            bool isFinal)
        {
            if (buffer == null)
            {
                throw Error.ArgumentNull("buffer");
            }

            ParserState parseStatus = ParserState.NeedMoreData;

            if (bytesConsumed >= bytesReady)
            {
                if (isFinal)
                {
                    parseStatus = CopyCurrent(parseStatus);
                }

                // We either can already tell we need more data or we are done
                return parseStatus;
            }

            try
            {
                parseStatus = ParseNameValuePairs(
                    buffer,
                    bytesReady,
                    ref bytesConsumed,
                    ref _nameValueState,
                    _maxMessageSize,
                    ref _totalBytesConsumed,
                    _currentNameValuePair,
                    _nameValuePairs);

                if (isFinal)
                {
                    parseStatus = CopyCurrent(parseStatus);
                }
            }
            catch (Exception)
            {
                parseStatus = ParserState.Invalid;
            }

            return parseStatus;
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "This is a parser which cannot be split up for performance reasons.")]
        private static ParserState ParseNameValuePairs(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed,
            ref NameValueState nameValueState,
            long maximumLength,
            ref long totalBytesConsumed,
            CurrentNameValuePair currentNameValuePair,
            ICollection<KeyValuePair<string, string>> nameValuePairs)
        {
            Contract.Assert((bytesReady - bytesConsumed) >= 0, "ParseNameValuePairs()|(inputBufferLength - bytesParsed) < 0");
            Contract.Assert(maximumLength <= 0 || totalBytesConsumed <= maximumLength, "ParseNameValuePairs()|Headers already read exceeds limit.");

            // Remember where we started.
            int initialBytesParsed = bytesConsumed;
            int segmentStart;

            // Set up parsing status with what will happen if we exceed the buffer.
            ParserState parseStatus = ParserState.DataTooBig;
            long effectiveMax = maximumLength <= 0 ? Int64.MaxValue : maximumLength - totalBytesConsumed + initialBytesParsed;
            if (bytesReady < effectiveMax)
            {
                parseStatus = ParserState.NeedMoreData;
                effectiveMax = bytesReady;
            }

            Contract.Assert(bytesConsumed < effectiveMax, "We have already consumed more than the max buffer length.");

            switch (nameValueState)
            {
                case NameValueState.Name:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '=' && buffer[bytesConsumed] != '&')
                    {
                        if (++bytesConsumed == effectiveMax)
                        {
                            string name = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentNameValuePair.Name.Append(name);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string name = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentNameValuePair.Name.Append(name);
                    }

                    // Check if we got name=value or just name
                    if (buffer[bytesConsumed] == '=')
                    {
                        // Move part the '='
                        nameValueState = NameValueState.Value;
                        if (++bytesConsumed == effectiveMax)
                        {
                            goto quit;
                        }

                        goto case NameValueState.Value;
                    }
                    else
                    {
                        // Copy parsed name-only to collection
                        currentNameValuePair.CopyNameOnlyTo(nameValuePairs);

                        // Move past the '&' but stay in same state
                        if (++bytesConsumed == effectiveMax)
                        {
                            goto quit;
                        }

                        goto case NameValueState.Name;
                    }

                case NameValueState.Value:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '&')
                    {
                        if (++bytesConsumed == effectiveMax)
                        {
                            string value = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentNameValuePair.Value.Append(value);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string value = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentNameValuePair.Value.Append(value);
                    }

                    // Copy parsed name value pair to collection
                    currentNameValuePair.CopyTo(nameValuePairs);

                    // Move past the '&'
                    nameValueState = NameValueState.Name;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case NameValueState.Name;
            }

        quit:
            totalBytesConsumed += bytesConsumed - initialBytesParsed;
            return parseStatus;
        }

        private ParserState CopyCurrent(ParserState parseState)
        {
            // Copy parsed name value pair to collection
            if (_nameValueState == NameValueState.Name)
            {
                if (_totalBytesConsumed > 0)
                {
                    _currentNameValuePair.CopyNameOnlyTo(_nameValuePairs);
                }
            }
            else
            {
                _currentNameValuePair.CopyTo(_nameValuePairs);
            }

            // We are done (or in an error state)
            return parseState == ParserState.NeedMoreData ? ParserState.Done : parseState;
        }

        /// <summary>
        /// Maintains information about the current header field being parsed.
        /// </summary>
        private class CurrentNameValuePair
        {
            private const int DefaultNameAllocation = 128;
            private const int DefaultValueAllocation = 2 * 1024;

            private readonly StringBuilder _name = new StringBuilder(DefaultNameAllocation);
            private readonly StringBuilder _value = new StringBuilder(DefaultValueAllocation);

            /// <summary>
            /// Gets the name of the name value pair.
            /// </summary>
            public StringBuilder Name
            {
                get { return _name; }
            }

            /// <summary>
            /// Gets the value of the name value pair
            /// </summary>
            public StringBuilder Value
            {
                get { return _value; }
            }

            /// <summary>
            /// Copies current name value pair field to the provided collection instance.
            /// </summary>
            /// <param name="nameValuePairs">The collection to copy into.</param>
            public void CopyTo(ICollection<KeyValuePair<string, string>> nameValuePairs)
            {
                string unescapedName = WebUtility.UrlDecode(_name.ToString());
                string escapedValue = _value.ToString();
                string value = WebUtility.UrlDecode(escapedValue);

                nameValuePairs.Add(new KeyValuePair<string, string>(unescapedName, value));

                Clear();
            }

            /// <summary>
            /// Copies current name-only to the provided collection instance.
            /// </summary>
            /// <param name="nameValuePairs">The collection to copy into.</param>
            public void CopyNameOnlyTo(ICollection<KeyValuePair<string, string>> nameValuePairs)
            {
                string unescapedName = WebUtility.UrlDecode(_name.ToString());
                string value = String.Empty;
                nameValuePairs.Add(new KeyValuePair<string, string>(unescapedName, value));
                Clear();
            }

            /// <summary>
            /// Clears this instance.
            /// </summary>
            private void Clear()
            {
                _name.Clear();
                _value.Clear();
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/HttpRequestHeaderParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// The <see cref="HttpRequestHeaderParser"/> combines <see cref="HttpRequestLineParser"/> for parsing the HTTP Request Line  
    /// and <see cref="InternetMessageFormatHeaderParser"/> for parsing each header field. 
    /// </summary>
    internal class HttpRequestHeaderParser
    {
        internal const int DefaultMaxRequestLineSize = 2 * 1024;
        internal const int DefaultMaxHeaderSize = 16 * 1024; // Same default size as IIS has for regular requests

        private HttpUnsortedRequest _httpRequest;
        private HttpRequestState _requestStatus = HttpRequestState.RequestLine;

        private HttpRequestLineParser _requestLineParser;
        private InternetMessageFormatHeaderParser _headerParser;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpRequestHeaderParser"/> class.
        /// </summary>
        /// <param name="httpRequest">The parsed HTTP request without any header sorting.</param>
        public HttpRequestHeaderParser(HttpUnsortedRequest httpRequest)
            : this(httpRequest, DefaultMaxRequestLineSize, DefaultMaxHeaderSize)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpRequestHeaderParser"/> class.
        /// </summary>
        /// <param name="httpRequest">The parsed HTTP request without any header sorting.</param>
        /// <param name="maxRequestLineSize">The max length of the HTTP request line.</param>
        /// <param name="maxHeaderSize">The max length of the HTTP header.</param>
        public HttpRequestHeaderParser(HttpUnsortedRequest httpRequest, int maxRequestLineSize, int maxHeaderSize)
        {
            if (httpRequest == null)
            {
                throw Error.ArgumentNull("httpRequest");
            }

            _httpRequest = httpRequest;

            // Create request line parser
            _requestLineParser = new HttpRequestLineParser(_httpRequest, maxRequestLineSize);

            // Create header parser
            _headerParser = new InternetMessageFormatHeaderParser(_httpRequest.HttpHeaders, maxHeaderSize);
        }

        private enum HttpRequestState
        {
            RequestLine = 0, // parsing request line
            RequestHeaders // reading headers
        }

        /// <summary>
        /// Parse an HTTP request header and fill in the <see cref="HttpRequestMessage"/> instance.
        /// </summary>
        /// <param name="buffer">Request buffer from where request is read</param>
        /// <param name="bytesReady">Size of request buffer</param>
        /// <param name="bytesConsumed">Offset into request buffer</param>
        /// <returns>State of the parser.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is propagated.")]
        public ParserState ParseBuffer(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed)
        {
            if (buffer == null)
            {
                throw Error.ArgumentNull("buffer");
            }

            ParserState parseStatus = ParserState.NeedMoreData;
            ParserState subParseStatus = ParserState.NeedMoreData;

            switch (_requestStatus)
            {
                case HttpRequestState.RequestLine:
                    try
                    {
                        subParseStatus = _requestLineParser.ParseBuffer(buffer, bytesReady, ref bytesConsumed);
                    }
                    catch (Exception)
                    {
                        subParseStatus = ParserState.Invalid;
                    }

                    if (subParseStatus == ParserState.Done)
                    {
                        _requestStatus = HttpRequestState.RequestHeaders;
                        subParseStatus = ParserState.NeedMoreData;
                        goto case HttpRequestState.RequestHeaders;
                    }
                    else if (subParseStatus != ParserState.NeedMoreData)
                    {
                        // Report error - either Invalid or DataTooBig
                        parseStatus = subParseStatus;
                        break;
                    }

                    break; // read more data

                case HttpRequestState.RequestHeaders:
                    if (bytesConsumed >= bytesReady)
                    {
                        // we already can tell we need more data
                        break;
                    }

                    try
                    {
                        subParseStatus = _headerParser.ParseBuffer(buffer, bytesReady, ref bytesConsumed);
                    }
                    catch (Exception)
                    {
                        subParseStatus = ParserState.Invalid;
                    }

                    if (subParseStatus == ParserState.Done)
                    {
                        parseStatus = subParseStatus;
                    }
                    else if (subParseStatus != ParserState.NeedMoreData)
                    {
                        parseStatus = subParseStatus;
                        break;
                    }

                    break; // need more data
            }

            return parseStatus;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/HttpRequestLineParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// HTTP Request Line parser for parsing the first line (the request line) in an HTTP request.
    /// </summary>
    internal class HttpRequestLineParser
    {
        internal const int MinRequestLineSize = 14;
        private const int DefaultTokenAllocation = 2 * 1024;

        private int _totalBytesConsumed;
        private int _maximumHeaderLength;

        private HttpRequestLineState _requestLineState;
        private HttpUnsortedRequest _httpRequest;
        private StringBuilder _currentToken = new StringBuilder(DefaultTokenAllocation);

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpRequestLineParser"/> class.
        /// </summary>
        /// <param name="httpRequest"><see cref="HttpUnsortedRequest"/> instance where the request line properties will be set as they are parsed.</param>
        /// <param name="maxRequestLineSize">Maximum length of HTTP header.</param>
        public HttpRequestLineParser(HttpUnsortedRequest httpRequest, int maxRequestLineSize)
        {
            // The minimum length which would be an empty header terminated by CRLF
            if (maxRequestLineSize < MinRequestLineSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxRequestLineSize", maxRequestLineSize, MinRequestLineSize);
            }

            if (httpRequest == null)
            {
                throw Error.ArgumentNull("httpRequest");
            }

            _httpRequest = httpRequest;
            _maximumHeaderLength = maxRequestLineSize;
        }

        private enum HttpRequestLineState
        {
            RequestMethod = 0,
            RequestUri,
            BeforeVersionNumbers,
            MajorVersionNumber,
            MinorVersionNumber,
            AfterCarriageReturn
        }

        /// <summary>
        /// Parse an HTTP request line.
        /// Bytes are parsed in a consuming manner from the beginning of the request buffer meaning that the same bytes can not be
        /// present in the request buffer.
        /// </summary>
        /// <param name="buffer">Request buffer from where request is read</param>
        /// <param name="bytesReady">Size of request buffer</param>
        /// <param name="bytesConsumed">Offset into request buffer</param>
        /// <returns>State of the parser.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is translated to parse state.")]
        public ParserState ParseBuffer(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed)
        {
            if (buffer == null)
            {
                throw Error.ArgumentNull("buffer");
            }

            ParserState parseStatus = ParserState.NeedMoreData;

            if (bytesConsumed >= bytesReady)
            {
                // We already can tell we need more data
                return parseStatus;
            }

            try
            {
                parseStatus = ParseRequestLine(
                    buffer,
                    bytesReady,
                    ref bytesConsumed,
                    ref _requestLineState,
                    _maximumHeaderLength,
                    ref _totalBytesConsumed,
                    _currentToken,
                    _httpRequest);
            }
            catch (Exception)
            {
                parseStatus = ParserState.Invalid;
            }

            return parseStatus;
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "This is a parser which cannot be split up for performance reasons.")]
        private static ParserState ParseRequestLine(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed,
            ref HttpRequestLineState requestLineState,
            int maximumHeaderLength,
            ref int totalBytesConsumed,
            StringBuilder currentToken,
            HttpUnsortedRequest httpRequest)
        {
            Contract.Assert((bytesReady - bytesConsumed) >= 0, "ParseRequestLine()|(bytesReady - bytesConsumed) < 0");
            Contract.Assert(maximumHeaderLength <= 0 || totalBytesConsumed <= maximumHeaderLength, "ParseRequestLine()|Headers already read exceeds limit.");

            // Remember where we started.
            int initialBytesParsed = bytesConsumed;
            int segmentStart;

            // Set up parsing status with what will happen if we exceed the buffer.
            ParserState parseStatus = ParserState.DataTooBig;
            int effectiveMax = maximumHeaderLength <= 0 ? Int32.MaxValue : (maximumHeaderLength - totalBytesConsumed + bytesConsumed);
            if (bytesReady < effectiveMax)
            {
                parseStatus = ParserState.NeedMoreData;
                effectiveMax = bytesReady;
            }

            Contract.Assert(bytesConsumed < effectiveMax, "We have already consumed more than the max header length.");

            switch (requestLineState)
            {
                case HttpRequestLineState.RequestMethod:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != ' ')
                    {
                        if (buffer[bytesConsumed] < 0x21 || buffer[bytesConsumed] > 0x7a)
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string method = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(method);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string method = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(method);
                    }

                    // Copy value out
                    httpRequest.Method = new HttpMethod(currentToken.ToString());
                    currentToken.Clear();

                    // Move past the SP
                    requestLineState = HttpRequestLineState.RequestUri;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpRequestLineState.RequestUri;

                case HttpRequestLineState.RequestUri:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != ' ')
                    {
                        if (buffer[bytesConsumed] == '\r')
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string addr = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(addr);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string addr = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(addr);
                    }

                    // URI validation happens when we create the URI later.
                    if (currentToken.Length == 0)
                    {
                        throw new FormatException(Properties.Resources.HttpMessageParserEmptyUri);
                    }

                    // Copy value out
                    httpRequest.RequestUri = currentToken.ToString();
                    currentToken.Clear();

                    // Move past the SP
                    requestLineState = HttpRequestLineState.BeforeVersionNumbers;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpRequestLineState.BeforeVersionNumbers;

                case HttpRequestLineState.BeforeVersionNumbers:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '/')
                    {
                        if (buffer[bytesConsumed] < 0x21 || buffer[bytesConsumed] > 0x7a)
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string token = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(token);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string token = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(token);
                    }

                    // Validate value
                    string version = currentToken.ToString();
                    if (String.CompareOrdinal(FormattingUtilities.HttpVersionToken, version) != 0)
                    {
                        throw new FormatException(Error.Format(Properties.Resources.HttpInvalidVersion, version, FormattingUtilities.HttpVersionToken));
                    }

                    currentToken.Clear();

                    // Move past the '/'
                    requestLineState = HttpRequestLineState.MajorVersionNumber;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpRequestLineState.MajorVersionNumber;

                case HttpRequestLineState.MajorVersionNumber:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '.')
                    {
                        if (buffer[bytesConsumed] < '0' || buffer[bytesConsumed] > '9')
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string major = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(major);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string major = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(major);
                    }

                    // Move past the "."
                    currentToken.Append('.');
                    requestLineState = HttpRequestLineState.MinorVersionNumber;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpRequestLineState.MinorVersionNumber;

                case HttpRequestLineState.MinorVersionNumber:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '\r')
                    {
                        if (buffer[bytesConsumed] < '0' || buffer[bytesConsumed] > '9')
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string minor = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(minor);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string minor = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(minor);
                    }

                    // Copy out value
                    httpRequest.Version = Version.Parse(currentToken.ToString());
                    currentToken.Clear();

                    // Move past the CR
                    requestLineState = HttpRequestLineState.AfterCarriageReturn;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpRequestLineState.AfterCarriageReturn;

                case HttpRequestLineState.AfterCarriageReturn:
                    if (buffer[bytesConsumed] != '\n')
                    {
                        parseStatus = ParserState.Invalid;
                        goto quit;
                    }

                    parseStatus = ParserState.Done;
                    bytesConsumed++;
                    break;
            }

        quit:
            totalBytesConsumed += bytesConsumed - initialBytesParsed;
            return parseStatus;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/HttpResponseHeaderParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// The <see cref="HttpResponseHeaderParser"/> combines <see cref="HttpStatusLineParser"/> for parsing the HTTP Status Line  
    /// and <see cref="InternetMessageFormatHeaderParser"/> for parsing each header field. 
    /// </summary>
    internal class HttpResponseHeaderParser
    {
        internal const int DefaultMaxStatusLineSize = 2 * 1024;
        internal const int DefaultMaxHeaderSize = 16 * 1024; // Same default size as IIS has for HTTP requests

        private HttpUnsortedResponse _httpResponse;
        private HttpResponseState _responseStatus = HttpResponseState.StatusLine;

        private HttpStatusLineParser _statusLineParser;
        private InternetMessageFormatHeaderParser _headerParser;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpResponseHeaderParser"/> class.
        /// </summary>
        /// <param name="httpResponse">The parsed HTTP response without any header sorting.</param>
        public HttpResponseHeaderParser(HttpUnsortedResponse httpResponse)
            : this(httpResponse, DefaultMaxStatusLineSize, DefaultMaxHeaderSize)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpResponseHeaderParser"/> class.
        /// </summary>
        /// <param name="httpResponse">The parsed HTTP response without any header sorting.</param>
        /// <param name="maxResponseLineSize">The max length of the HTTP status line.</param>
        /// <param name="maxHeaderSize">The max length of the HTTP header.</param>
        public HttpResponseHeaderParser(HttpUnsortedResponse httpResponse, int maxResponseLineSize, int maxHeaderSize)
        {
            if (httpResponse == null)
            {
                throw Error.ArgumentNull("httpResponse");
            }

            _httpResponse = httpResponse;

            // Create status line parser
            _statusLineParser = new HttpStatusLineParser(_httpResponse, maxResponseLineSize);

            // Create header parser
            _headerParser = new InternetMessageFormatHeaderParser(_httpResponse.HttpHeaders, maxHeaderSize);
        }

        private enum HttpResponseState
        {
            StatusLine = 0, // parsing status line
            ResponseHeaders // reading headers
        }

        /// <summary>
        /// Parse an HTTP response header and fill in the <see cref="HttpResponseMessage"/> instance.
        /// </summary>
        /// <param name="buffer">Response buffer from where response is read</param>
        /// <param name="bytesReady">Size of response buffer</param>
        /// <param name="bytesConsumed">Offset into response buffer</param>
        /// <returns>State of the parser.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is propagated.")]
        public ParserState ParseBuffer(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed)
        {
            if (buffer == null)
            {
                throw Error.ArgumentNull("buffer");
            }

            ParserState parseStatus = ParserState.NeedMoreData;
            ParserState subParseStatus = ParserState.NeedMoreData;

            switch (_responseStatus)
            {
                case HttpResponseState.StatusLine:
                    try
                    {
                        subParseStatus = _statusLineParser.ParseBuffer(buffer, bytesReady, ref bytesConsumed);
                    }
                    catch (Exception)
                    {
                        subParseStatus = ParserState.Invalid;
                    }

                    if (subParseStatus == ParserState.Done)
                    {
                        _responseStatus = HttpResponseState.ResponseHeaders;
                        subParseStatus = ParserState.NeedMoreData;
                        goto case HttpResponseState.ResponseHeaders;
                    }
                    else if (subParseStatus != ParserState.NeedMoreData)
                    {
                        // Report error - either Invalid or DataTooBig
                        parseStatus = subParseStatus;
                        break;
                    }

                    break; // read more data

                case HttpResponseState.ResponseHeaders:
                    if (bytesConsumed >= bytesReady)
                    {
                        // we already can tell we need more data
                        break;
                    }

                    try
                    {
                        subParseStatus = _headerParser.ParseBuffer(buffer, bytesReady, ref bytesConsumed);
                    }
                    catch (Exception)
                    {
                        subParseStatus = ParserState.Invalid;
                    }

                    if (subParseStatus == ParserState.Done)
                    {
                        parseStatus = subParseStatus;
                    }
                    else if (subParseStatus != ParserState.NeedMoreData)
                    {
                        parseStatus = subParseStatus;
                        break;
                    }

                    break; // need more data
            }

            return parseStatus;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/HttpStatusLineParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// HTTP Status line parser for parsing the first line (the status line) in an HTTP response.
    /// </summary>
    internal class HttpStatusLineParser
    {
        internal const int MinStatusLineSize = 15;
        private const int DefaultTokenAllocation = 2 * 1024;
        private const int MaxStatusCode = 1000;

        private int _totalBytesConsumed;
        private int _maximumHeaderLength;

        private HttpStatusLineState _statusLineState;
        private HttpUnsortedResponse _httpResponse;
        private StringBuilder _currentToken = new StringBuilder(DefaultTokenAllocation);

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpStatusLineParser"/> class.
        /// </summary>
        /// <param name="httpResponse"><see cref="HttpUnsortedResponse"/> instance where the response line properties will be set as they are parsed.</param>
        /// <param name="maxStatusLineSize">Maximum length of HTTP header.</param>
        public HttpStatusLineParser(HttpUnsortedResponse httpResponse, int maxStatusLineSize)
        {
            // The minimum length which would be an empty header terminated by CRLF
            if (maxStatusLineSize < MinStatusLineSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxStatusLineSize", maxStatusLineSize, MinStatusLineSize);
            }

            if (httpResponse == null)
            {
                throw Error.ArgumentNull("httpResponse");
            }

            _httpResponse = httpResponse;
            _maximumHeaderLength = maxStatusLineSize;
        }

        private enum HttpStatusLineState
        {
            BeforeVersionNumbers = 0,
            MajorVersionNumber,
            MinorVersionNumber,
            StatusCode,
            ReasonPhrase,
            AfterCarriageReturn
        }

        /// <summary>
        /// Parse an HTTP status line.
        /// Bytes are parsed in a consuming manner from the beginning of the response buffer meaning that the same bytes can not be
        /// present in the response buffer.
        /// </summary>
        /// <param name="buffer">Response buffer from where response is read</param>
        /// <param name="bytesReady">Size of response buffer</param>
        /// <param name="bytesConsumed">Offset into response buffer</param>
        /// <returns>State of the parser.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is translated to parse state.")]
        public ParserState ParseBuffer(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed)
        {
            if (buffer == null)
            {
                throw Error.ArgumentNull("buffer");
            }

            ParserState parseStatus = ParserState.NeedMoreData;

            if (bytesConsumed >= bytesReady)
            {
                // We already can tell we need more data
                return parseStatus;
            }

            try
            {
                parseStatus = ParseStatusLine(
                    buffer,
                    bytesReady,
                    ref bytesConsumed,
                    ref _statusLineState,
                    _maximumHeaderLength,
                    ref _totalBytesConsumed,
                    _currentToken,
                    _httpResponse);
            }
            catch (Exception)
            {
                parseStatus = ParserState.Invalid;
            }

            return parseStatus;
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "This is a parser which cannot be split up for performance reasons.")]
        private static ParserState ParseStatusLine(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed,
            ref HttpStatusLineState statusLineState,
            int maximumHeaderLength,
            ref int totalBytesConsumed,
            StringBuilder currentToken,
            HttpUnsortedResponse httpResponse)
        {
            Contract.Assert((bytesReady - bytesConsumed) >= 0, "ParseRequestLine()|(bytesReady - bytesConsumed) < 0");
            Contract.Assert(maximumHeaderLength <= 0 || totalBytesConsumed <= maximumHeaderLength, "ParseRequestLine()|Headers already read exceeds limit.");

            // Remember where we started.
            int initialBytesParsed = bytesConsumed;
            int segmentStart;

            // Set up parsing status with what will happen if we exceed the buffer.
            ParserState parseStatus = ParserState.DataTooBig;
            int effectiveMax = maximumHeaderLength <= 0 ? Int32.MaxValue : (maximumHeaderLength - totalBytesConsumed + bytesConsumed);
            if (bytesReady < effectiveMax)
            {
                parseStatus = ParserState.NeedMoreData;
                effectiveMax = bytesReady;
            }

            Contract.Assert(bytesConsumed < effectiveMax, "We have already consumed more than the max header length.");

            switch (statusLineState)
            {
                case HttpStatusLineState.BeforeVersionNumbers:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '/')
                    {
                        if (buffer[bytesConsumed] < 0x21 || buffer[bytesConsumed] > 0x7a)
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string token = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(token);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string token = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(token);
                    }

                    // Validate value
                    string version = currentToken.ToString();
                    if (String.CompareOrdinal(FormattingUtilities.HttpVersionToken, version) != 0)
                    {
                        throw new FormatException(Error.Format(Properties.Resources.HttpInvalidVersion, version, FormattingUtilities.HttpVersionToken));
                    }

                    currentToken.Clear();

                    // Move past the '/'
                    statusLineState = HttpStatusLineState.MajorVersionNumber;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpStatusLineState.MajorVersionNumber;

                case HttpStatusLineState.MajorVersionNumber:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '.')
                    {
                        if (buffer[bytesConsumed] < '0' || buffer[bytesConsumed] > '9')
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string major = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(major);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string major = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(major);
                    }

                    // Move past the "."
                    currentToken.Append('.');
                    statusLineState = HttpStatusLineState.MinorVersionNumber;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpStatusLineState.MinorVersionNumber;

                case HttpStatusLineState.MinorVersionNumber:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != ' ')
                    {
                        if (buffer[bytesConsumed] < '0' || buffer[bytesConsumed] > '9')
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string minor = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(minor);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string minor = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(minor);
                    }

                    // Copy out value
                    httpResponse.Version = Version.Parse(currentToken.ToString());
                    currentToken.Clear();

                    // Move past the SP
                    statusLineState = HttpStatusLineState.StatusCode;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpStatusLineState.StatusCode;

                case HttpStatusLineState.StatusCode:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != ' ')
                    {
                        if (buffer[bytesConsumed] < '0' || buffer[bytesConsumed] > '9')
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string method = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(method);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string method = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(method);
                    }

                    // Copy value out
                    int statusCode = Int32.Parse(currentToken.ToString(), CultureInfo.InvariantCulture);
                    if (statusCode < 100 || statusCode > 1000)
                    {
                        throw new FormatException(Error.Format(Properties.Resources.HttpInvalidStatusCode, statusCode, 100, 1000));
                    }

                    httpResponse.StatusCode = (HttpStatusCode)statusCode;
                    currentToken.Clear();

                    // Move past the SP
                    statusLineState = HttpStatusLineState.ReasonPhrase;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpStatusLineState.ReasonPhrase;

                case HttpStatusLineState.ReasonPhrase:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '\r')
                    {
                        if (buffer[bytesConsumed] < 0x20 || buffer[bytesConsumed] > 0x7a)
                        {
                            parseStatus = ParserState.Invalid;
                            goto quit;
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string addr = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentToken.Append(addr);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string addr = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentToken.Append(addr);
                    }

                    // Copy value out
                    httpResponse.ReasonPhrase = currentToken.ToString();
                    currentToken.Clear();

                    // Move past the CR
                    statusLineState = HttpStatusLineState.AfterCarriageReturn;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HttpStatusLineState.AfterCarriageReturn;

                case HttpStatusLineState.AfterCarriageReturn:
                    if (buffer[bytesConsumed] != '\n')
                    {
                        parseStatus = ParserState.Invalid;
                        goto quit;
                    }

                    parseStatus = ParserState.Done;
                    bytesConsumed++;
                    break;
            }

        quit:
            totalBytesConsumed += bytesConsumed - initialBytesParsed;
            return parseStatus;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/InternetMessageFormatHeaderParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http.Headers;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// Buffer-oriented RFC 5322 style Internet Message Format parser which can be used to pass header
    /// fields used in HTTP and MIME message entities.
    /// </summary>
    internal class InternetMessageFormatHeaderParser
    {
        internal const int MinHeaderSize = 2;

        private int _totalBytesConsumed;
        private int _maxHeaderSize;

        private HeaderFieldState _headerState;
        private HttpHeaders _headers;
        private CurrentHeaderFieldStore _currentHeader;
        private readonly bool _ignoreHeaderValidation;

        /// <summary>
        /// Initializes a new instance of the <see cref="InternetMessageFormatHeaderParser"/> class.
        /// </summary>
        /// <param name="headers">Concrete <see cref="HttpHeaders"/> instance where header fields are added as they are parsed.</param>
        /// <param name="maxHeaderSize">Maximum length of complete header containing all the individual header fields.</param>
        public InternetMessageFormatHeaderParser(HttpHeaders headers, int maxHeaderSize)
            : this(headers, maxHeaderSize, ignoreHeaderValidation: false)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="InternetMessageFormatHeaderParser"/> class.
        /// </summary>
        /// <param name="headers">
        /// Concrete <see cref="HttpHeaders"/> instance where header fields are added as they are parsed.
        /// </param>
        /// <param name="maxHeaderSize">
        /// Maximum length of complete header containing all the individual header fields.
        /// </param>
        /// <param name="ignoreHeaderValidation">
        /// Will validate content and names of headers if set to <c>false</c>.
        /// </param>
        public InternetMessageFormatHeaderParser(HttpHeaders headers, int maxHeaderSize, bool ignoreHeaderValidation)
        {
            // The minimum length which would be an empty header terminated by CRLF
            if (maxHeaderSize < InternetMessageFormatHeaderParser.MinHeaderSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxHeaderSize", maxHeaderSize, MinHeaderSize);
            }

            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            _headers = headers;
            _maxHeaderSize = maxHeaderSize;
            _ignoreHeaderValidation = ignoreHeaderValidation;
            _currentHeader = new CurrentHeaderFieldStore();
        }

        private enum HeaderFieldState
        {
            Name = 0,
            Value,
            AfterCarriageReturn,
            FoldingLine
        }

        /// <summary>
        /// Parse a buffer of RFC 5322 style header fields and add them to the <see cref="HttpHeaders"/> collection.
        /// Bytes are parsed in a consuming manner from the beginning of the buffer meaning that the same bytes can not be
        /// present in the buffer.
        /// </summary>
        /// <param name="buffer">Request buffer from where request is read</param>
        /// <param name="bytesReady">Size of request buffer</param>
        /// <param name="bytesConsumed">Offset into request buffer</param>
        /// <returns>State of the parser. Call this method with new data until it reaches a final state.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is translated to parse state.")]
        public ParserState ParseBuffer(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed)
        {
            if (buffer == null)
            {
                throw Error.ArgumentNull("buffer");
            }

            ParserState parseStatus = ParserState.NeedMoreData;

            if (bytesConsumed >= bytesReady)
            {
                // We already can tell we need more data
                return parseStatus;
            }

            try
            {
                parseStatus = InternetMessageFormatHeaderParser.ParseHeaderFields(
                    buffer,
                    bytesReady,
                    ref bytesConsumed,
                    ref _headerState,
                    _maxHeaderSize,
                    ref _totalBytesConsumed,
                    _currentHeader,
                    _headers,
                    _ignoreHeaderValidation);
            }
            catch (Exception)
            {
                parseStatus = ParserState.Invalid;
            }

            return parseStatus;
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "This is a parser which cannot be split up for performance reasons.")]
        private static ParserState ParseHeaderFields(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed,
            ref HeaderFieldState requestHeaderState,
            int maximumHeaderLength,
            ref int totalBytesConsumed,
            CurrentHeaderFieldStore currentField,
            HttpHeaders headers,
            bool ignoreHeaderValidation)
        {
            Contract.Assert((bytesReady - bytesConsumed) >= 0, "ParseHeaderFields()|(inputBufferLength - bytesParsed) < 0");
            Contract.Assert(maximumHeaderLength <= 0 || totalBytesConsumed <= maximumHeaderLength, "ParseHeaderFields()|Headers already read exceeds limit.");

            // Remember where we started.
            int initialBytesParsed = bytesConsumed;
            int segmentStart;

            // Set up parsing status with what will happen if we exceed the buffer.
            ParserState parseStatus = ParserState.DataTooBig;
            int effectiveMax = maximumHeaderLength <= 0 ? Int32.MaxValue : maximumHeaderLength - totalBytesConsumed + initialBytesParsed;
            if (bytesReady < effectiveMax)
            {
                parseStatus = ParserState.NeedMoreData;
                effectiveMax = bytesReady;
            }

            Contract.Assert(bytesConsumed < effectiveMax, "We have already consumed more than the max header length.");

            switch (requestHeaderState)
            {
                case HeaderFieldState.Name:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != ':')
                    {
                        if (buffer[bytesConsumed] == '\r')
                        {
                            if (!currentField.IsEmpty())
                            {
                                parseStatus = ParserState.Invalid;
                                goto quit;
                            }
                            else
                            {
                                // Move past the '\r'
                                requestHeaderState = HeaderFieldState.AfterCarriageReturn;
                                if (++bytesConsumed == effectiveMax)
                                {
                                    goto quit;
                                }

                                goto case HeaderFieldState.AfterCarriageReturn;
                            }
                        }

                        if (++bytesConsumed == effectiveMax)
                        {
                            string headerFieldName = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentField.Name.Append(headerFieldName);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string headerFieldName = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentField.Name.Append(headerFieldName);
                    }

                    // Move past the ':'
                    requestHeaderState = HeaderFieldState.Value;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HeaderFieldState.Value;

                case HeaderFieldState.Value:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != '\r')
                    {
                        if (++bytesConsumed == effectiveMax)
                        {
                            string headerFieldValue = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                            currentField.Value.Append(headerFieldValue);
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        string headerFieldValue = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart);
                        currentField.Value.Append(headerFieldValue);
                    }

                    // Move past the CR
                    requestHeaderState = HeaderFieldState.AfterCarriageReturn;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HeaderFieldState.AfterCarriageReturn;

                case HeaderFieldState.AfterCarriageReturn:
                    if (buffer[bytesConsumed] != '\n')
                    {
                        parseStatus = ParserState.Invalid;
                        goto quit;
                    }

                    if (currentField.IsEmpty())
                    {
                        parseStatus = ParserState.Done;
                        bytesConsumed++;
                        goto quit;
                    }

                    requestHeaderState = HeaderFieldState.FoldingLine;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HeaderFieldState.FoldingLine;

                case HeaderFieldState.FoldingLine:
                    if (buffer[bytesConsumed] != ' ' && buffer[bytesConsumed] != '\t')
                    {
                        currentField.CopyTo(headers, ignoreHeaderValidation);
                        requestHeaderState = HeaderFieldState.Name;
                        if (bytesConsumed == effectiveMax)
                        {
                            goto quit;
                        }

                        goto case HeaderFieldState.Name;
                    }

                    // Unfold line by inserting SP instead
                    currentField.Value.Append(' ');

                    // Continue parsing header field value
                    requestHeaderState = HeaderFieldState.Value;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case HeaderFieldState.Value;
            }

        quit:
            totalBytesConsumed += bytesConsumed - initialBytesParsed;
            return parseStatus;
        }

        /// <summary>
        /// Maintains information about the current header field being parsed.
        /// </summary>
        private class CurrentHeaderFieldStore
        {
            private const int DefaultFieldNameAllocation = 128;
            private const int DefaultFieldValueAllocation = 2 * 1024;

            private static readonly char[] _linearWhiteSpace = new char[] { ' ', '\t' };

            private readonly StringBuilder _name = new StringBuilder(CurrentHeaderFieldStore.DefaultFieldNameAllocation);
            private readonly StringBuilder _value = new StringBuilder(CurrentHeaderFieldStore.DefaultFieldValueAllocation);

            /// <summary>
            /// Gets the header field name.
            /// </summary>
            public StringBuilder Name
            {
                get { return _name; }
            }

            /// <summary>
            /// Gets the header field value.
            /// </summary>
            public StringBuilder Value
            {
                get { return _value; }
            }

            /// <summary>
            /// Copies current header field to the provided <see cref="HttpHeaders"/> instance.
            /// </summary>
            /// <param name="headers">The headers.</param>
            /// <param name="ignoreHeaderValidation">Set to false to validate headers</param>
            public void CopyTo(HttpHeaders headers, bool ignoreHeaderValidation)
            {
                var name = _name.ToString();
                var value = _value.ToString().Trim(CurrentHeaderFieldStore._linearWhiteSpace);
                if (string.Equals("expires", name, StringComparison.OrdinalIgnoreCase))
                {
                    ignoreHeaderValidation = true;
                }

                if (ignoreHeaderValidation)
                {
                    headers.TryAddWithoutValidation(name, value);
                }
                else
                {
                    headers.Add(name, value);
                }

                Clear();
            }

            /// <summary>
            /// Determines whether this instance is empty.
            /// </summary>
            /// <returns>
            ///   <c>true</c> if this instance is empty; otherwise, <c>false</c>.
            /// </returns>
            public bool IsEmpty()
            {
                return _name.Length == 0 && _value.Length == 0;
            }

            /// <summary>
            /// Clears this instance.
            /// </summary>
            private void Clear()
            {
                _name.Clear();
                _value.Clear();
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/MimeMultipartBodyPartParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// Complete MIME multipart parser that combines <see cref="MimeMultipartParser"/> for parsing the MIME message into individual body parts
    /// and <see cref="InternetMessageFormatHeaderParser"/> for parsing each body part into a MIME header and a MIME body. The caller of the parser is returned
    /// the resulting MIME bodies which can then be written to some output.
    /// </summary>
    internal class MimeMultipartBodyPartParser : IDisposable
    {
        internal const long DefaultMaxMessageSize = Int64.MaxValue;
        private const int DefaultMaxBodyPartHeaderSize = 4 * 1024;

        // MIME parser
        private MimeMultipartParser _mimeParser;
        private MimeMultipartParser.State _mimeStatus = MimeMultipartParser.State.NeedMoreData;
        private ArraySegment<byte>[] _parsedBodyPart = new ArraySegment<byte>[2];
        private MimeBodyPart _currentBodyPart;
        private bool _isFirst = true;

        // Header field parser
        private ParserState _bodyPartHeaderStatus = ParserState.NeedMoreData;
        private int _maxBodyPartHeaderSize;

        // Stream provider
        private MultipartStreamProvider _streamProvider;

        private HttpContent _content;

        /// <summary>
        /// Initializes a new instance of the <see cref="MimeMultipartBodyPartParser"/> class.
        /// </summary>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param>
        public MimeMultipartBodyPartParser(HttpContent content, MultipartStreamProvider streamProvider)
            : this(content, streamProvider, DefaultMaxMessageSize, DefaultMaxBodyPartHeaderSize)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MimeMultipartBodyPartParser"/> class.
        /// </summary>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param>
        /// <param name="maxMessageSize">The max length of the entire MIME multipart message.</param>
        /// <param name="maxBodyPartHeaderSize">The max length of the MIME header within each MIME body part.</param>
        public MimeMultipartBodyPartParser(
            HttpContent content,
            MultipartStreamProvider streamProvider,
            long maxMessageSize,
            int maxBodyPartHeaderSize)
        {
            Contract.Assert(content != null, "content cannot be null.");
            Contract.Assert(streamProvider != null, "streamProvider cannot be null.");

            string boundary = ValidateArguments(content, maxMessageSize, true);

            _mimeParser = new MimeMultipartParser(boundary, maxMessageSize);
            _currentBodyPart = new MimeBodyPart(streamProvider, maxBodyPartHeaderSize, content);
            _content = content;
            _maxBodyPartHeaderSize = maxBodyPartHeaderSize;

            _streamProvider = streamProvider;
        }

        /// <summary>
        /// Determines whether the specified content is MIME multipart content.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <returns>
        ///   <c>true</c> if the specified content is MIME multipart content; otherwise, <c>false</c>.
        /// </returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is translated to false return.")]
        public static bool IsMimeMultipartContent(HttpContent content)
        {
            Contract.Assert(content != null, "content cannot be null.");
            try
            {
                string boundary = ValidateArguments(content, DefaultMaxMessageSize, false);
                return boundary != null;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Parses the data provided and generates parsed MIME body part bodies in the form of <see cref="ArraySegment{T}"/> which are ready to
        /// write to the output stream.
        /// </summary>
        /// <param name="data">The data to parse</param>
        /// <param name="bytesRead">The number of bytes available in the input data</param>
        /// <returns>Parsed <see cref="MimeBodyPart"/> instances.</returns>
        public IEnumerable<MimeBodyPart> ParseBuffer(byte[] data, int bytesRead)
        {
            int bytesConsumed = 0;
            bool isFinal = false;

            // There's a special case here - if we've reached the end of the message and there's no optional
            // CRLF, then we're out of bytes to read, but we have finished the message.
            //
            // If IsWaitingForEndOfMessage is true and we're at the end of the stream, then we're going to
            // call into the parser again with an empty array as the buffer to signal the end of the parse.
            // Then the final boundary segment will be marked as complete.
            if (bytesRead == 0 && !_mimeParser.IsWaitingForEndOfMessage)
            {
                CleanupCurrentBodyPart();
                throw new IOException(Properties.Resources.ReadAsMimeMultipartUnexpectedTermination);
            }

            // Make sure we remove an old array segments.
            _currentBodyPart.Segments.Clear();

            while (_mimeParser.CanParseMore(bytesRead, bytesConsumed))
            {
                _mimeStatus = _mimeParser.ParseBuffer(data, bytesRead, ref bytesConsumed, out _parsedBodyPart[0], out _parsedBodyPart[1], out isFinal);
                if (_mimeStatus != MimeMultipartParser.State.BodyPartCompleted && _mimeStatus != MimeMultipartParser.State.NeedMoreData)
                {
                    CleanupCurrentBodyPart();
                    throw Error.InvalidOperation(Properties.Resources.ReadAsMimeMultipartParseError, bytesConsumed, data);
                }

                // First body is empty preamble which we just ignore
                if (_isFirst)
                {
                    if (_mimeStatus == MimeMultipartParser.State.BodyPartCompleted)
                    {
                        _isFirst = false;
                    }

                    continue;
                }

                // Parse the two array segments containing parsed body parts that the MIME parser gave us
                foreach (ArraySegment<byte> part in _parsedBodyPart)
                {
                    if (part.Count == 0)
                    {
                        continue;
                    }

                    if (_bodyPartHeaderStatus != ParserState.Done)
                    {
                        int headerConsumed = part.Offset;
                        _bodyPartHeaderStatus = _currentBodyPart.HeaderParser.ParseBuffer(part.Array, part.Count + part.Offset, ref headerConsumed);
                        if (_bodyPartHeaderStatus == ParserState.Done)
                        {
                            // Add the remainder as body part content
                            _currentBodyPart.Segments.Add(new ArraySegment<byte>(part.Array, headerConsumed, part.Count + part.Offset - headerConsumed));
                        }
                        else if (_bodyPartHeaderStatus != ParserState.NeedMoreData)
                        {
                            CleanupCurrentBodyPart();
                            throw Error.InvalidOperation(Properties.Resources.ReadAsMimeMultipartHeaderParseError, headerConsumed, part.Array);
                        }
                    }
                    else
                    {
                        // Add the data as body part content
                        _currentBodyPart.Segments.Add(part);
                    }
                }

                if (_mimeStatus == MimeMultipartParser.State.BodyPartCompleted)
                {
                    // If body is completed then swap current body part
                    MimeBodyPart completed = _currentBodyPart;
                    completed.IsComplete = true;
                    completed.IsFinal = isFinal;

                    _currentBodyPart = new MimeBodyPart(_streamProvider, _maxBodyPartHeaderSize, _content);

                    _mimeStatus = MimeMultipartParser.State.NeedMoreData;
                    _bodyPartHeaderStatus = ParserState.NeedMoreData;
                    yield return completed;
                }
                else
                {
                    // Otherwise return what we have
                    yield return _currentBodyPart;
                }
            }
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        protected void Dispose(bool disposing)
        {
            if (disposing)
            {
                _mimeParser = null;
                CleanupCurrentBodyPart();
            }
        }

        private static string ValidateArguments(HttpContent content, long maxMessageSize, bool throwOnError)
        {
            Contract.Assert(content != null, "content cannot be null.");
            if (maxMessageSize < MimeMultipartParser.MinMessageSize)
            {
                if (throwOnError)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxMessageSize", maxMessageSize, MimeMultipartParser.MinMessageSize);
                }
                else
                {
                    return null;
                }
            }

            MediaTypeHeaderValue contentType = content.Headers.ContentType;
            if (contentType == null)
            {
                if (throwOnError)
                {
                    throw Error.Argument("content", Properties.Resources.ReadAsMimeMultipartArgumentNoContentType, typeof(HttpContent).Name, "multipart/");
                }
                else
                {
                    return null;
                }
            }

            if (!contentType.MediaType.StartsWith("multipart", StringComparison.OrdinalIgnoreCase))
            {
                if (throwOnError)
                {
                    throw Error.Argument("content", Properties.Resources.ReadAsMimeMultipartArgumentNoMultipart, typeof(HttpContent).Name, "multipart/");
                }
                else
                {
                    return null;
                }
            }

            string boundary = null;
            foreach (NameValueHeaderValue p in contentType.Parameters)
            {
                if (p.Name.Equals("boundary", StringComparison.OrdinalIgnoreCase))
                {
                    boundary = FormattingUtilities.UnquoteToken(p.Value);
                    break;
                }
            }

            if (boundary == null)
            {
                if (throwOnError)
                {
                    throw Error.Argument("content", Properties.Resources.ReadAsMimeMultipartArgumentNoBoundary, typeof(HttpContent).Name, "multipart", "boundary");
                }
                else
                {
                    return null;
                }
            }

            return boundary;
        }

        private void CleanupCurrentBodyPart()
        {
            if (_currentBodyPart != null)
            {
                _currentBodyPart.Dispose();
                _currentBodyPart = null;
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/MimeMultipartParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// Buffer-oriented MIME multipart parser.
    /// </summary>
    internal class MimeMultipartParser
    {
        internal const int MinMessageSize = 10;

        private const int MaxBoundarySize = 256;

        private const byte HTAB = 0x09;
        private const byte SP = 0x20;
        private const byte CR = 0x0D;
        private const byte LF = 0x0A;
        private const byte Dash = 0x2D;
        private static readonly ArraySegment<byte> _emptyBodyPart = new ArraySegment<byte>(new byte[0]);

        private long _totalBytesConsumed;
        private long _maxMessageSize;

        private BodyPartState _bodyPartState;
        private string _boundary;
        private CurrentBodyPartStore _currentBoundary;

        /// <summary>
        /// Initializes a new instance of the <see cref="MimeMultipartParser"/> class.
        /// </summary>
        /// <param name="boundary">Message boundary</param>
        /// <param name="maxMessageSize">Maximum length of entire MIME multipart message.</param>
        public MimeMultipartParser(string boundary, long maxMessageSize)
        {
            // The minimum length which would be an empty message terminated by CRLF
            if (maxMessageSize < MimeMultipartParser.MinMessageSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxMessageSize", maxMessageSize, MinMessageSize);
            }

            if (String.IsNullOrWhiteSpace(boundary))
            {
                throw Error.ArgumentNull("boundary");
            }

            if (boundary.Length > MaxBoundarySize - 10)
            {
                throw Error.ArgumentMustBeLessThanOrEqualTo("boundary", boundary.Length, MaxBoundarySize - 10);
            }

            if (boundary.EndsWith(" ", StringComparison.Ordinal))
            {
                throw Error.Argument("boundary", Properties.Resources.MimeMultipartParserBadBoundary);
            }

            _maxMessageSize = maxMessageSize;
            _boundary = boundary;
            _currentBoundary = new CurrentBodyPartStore(_boundary);
            _bodyPartState = BodyPartState.AfterFirstLineFeed;
        }

        public bool IsWaitingForEndOfMessage
        {
            get
            {
                return
                    _bodyPartState == BodyPartState.AfterBoundary &&
                    _currentBoundary != null &&
                    _currentBoundary.IsFinal;
            }
        }

        private enum BodyPartState
        {
            BodyPart = 0,
            AfterFirstCarriageReturn,
            AfterFirstLineFeed,
            AfterFirstDash,
            Boundary,
            AfterBoundary,
            AfterSecondDash,
            AfterSecondCarriageReturn
        }

        private enum MessageState
        {
            Boundary = 0, // about to parse boundary
            BodyPart, // about to parse body-part
            CloseDelimiter // about to read close-delimiter
        }

        /// <summary>
        /// Represents the overall state of the <see cref="MimeMultipartParser"/>.
        /// </summary>
        public enum State
        {
            /// <summary>
            /// Need more data
            /// </summary>
            NeedMoreData = 0,

            /// <summary>
            /// Parsing of a complete body part succeeded.
            /// </summary>
            BodyPartCompleted,

            /// <summary>
            /// Bad data format
            /// </summary>
            Invalid,

            /// <summary>
            /// Data exceeds the allowed size
            /// </summary>
            DataTooBig,
        }

        public bool CanParseMore(int bytesRead, int bytesConsumed)
        {
            if (bytesConsumed < bytesRead)
            {
                // If there's more bytes we haven't parsed, then we can parse more
                return true;
            }

            if (bytesRead == 0 && IsWaitingForEndOfMessage)
            {
                // If we're waiting for the end of the message and we've arrived there, we want parse to be called
                // again so we can mark the parse as complete.
                //
                // This can happen when the last boundary segment doesn't have a trailing CRLF. We need to wait until
                // the end of the message to complete the parse because we need to consume any trailing whitespace that's
                //present.
                return true;
            }

            return false;
        }

        /// <summary>
        /// Parse a MIME multipart message. Bytes are parsed in a consuming
        /// manner from the beginning of the request buffer meaning that the same bytes can not be
        /// present in the request buffer.
        /// </summary>
        /// <param name="buffer">Request buffer from where request is read</param>
        /// <param name="bytesReady">Size of request buffer</param>
        /// <param name="bytesConsumed">Offset into request buffer</param>
        /// <param name="remainingBodyPart">Any body part that was considered as a potential MIME multipart boundary but which was in fact part of the body.</param>
        /// <param name="bodyPart">The bulk of the body part.</param>
        /// <param name="isFinalBodyPart">Indicates whether the final body part has been found.</param>
        /// <remarks>In order to get the complete body part, the caller is responsible for concatenating the contents of the
        /// <paramref name="remainingBodyPart"/> and <paramref name="bodyPart"/> out parameters.</remarks>
        /// <returns>State of the parser.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is translated to parse state.")]
        public State ParseBuffer(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed,
            out ArraySegment<byte> remainingBodyPart,
            out ArraySegment<byte> bodyPart,
            out bool isFinalBodyPart)
        {
            if (buffer == null)
            {
                throw Error.ArgumentNull("buffer");
            }

            State parseStatus = State.NeedMoreData;
            remainingBodyPart = MimeMultipartParser._emptyBodyPart;
            bodyPart = MimeMultipartParser._emptyBodyPart;
            isFinalBodyPart = false;

            try
            {
                parseStatus = MimeMultipartParser.ParseBodyPart(
                    buffer,
                    bytesReady,
                    ref bytesConsumed,
                    ref _bodyPartState,
                    _maxMessageSize,
                    ref _totalBytesConsumed,
                    _currentBoundary);
            }
            catch (Exception)
            {
                parseStatus = State.Invalid;
            }

            remainingBodyPart = _currentBoundary.GetDiscardedBoundary();
            bodyPart = _currentBoundary.BodyPart;
            if (parseStatus == State.BodyPartCompleted)
            {
                isFinalBodyPart = _currentBoundary.IsFinal;
                _currentBoundary.ClearAll();
            }
            else
            {
                _currentBoundary.ClearBodyPart();
            }

            return parseStatus;
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "This is a parser which cannot be split up for performance reasons.")]
        private static State ParseBodyPart(
            byte[] buffer,
            int bytesReady,
            ref int bytesConsumed,
            ref BodyPartState bodyPartState,
            long maximumMessageLength,
            ref long totalBytesConsumed,
            CurrentBodyPartStore currentBodyPart)
        {
            Contract.Assert((bytesReady - bytesConsumed) >= 0, "ParseBodyPart()|(bytesReady - bytesConsumed) < 0");
            Contract.Assert(maximumMessageLength <= 0 || totalBytesConsumed <= maximumMessageLength, "ParseBodyPart()|Message already read exceeds limit.");

            // Remember where we started.
            int segmentStart;
            int initialBytesParsed = bytesConsumed;

            if (bytesReady == 0 && bodyPartState == BodyPartState.AfterBoundary && currentBodyPart.IsFinal)
            {
                // We've seen the end of the stream - the final body part has no trailing CRLF
                return State.BodyPartCompleted;
            }

            // Set up parsing status with what will happen if we exceed the buffer.
            State parseStatus = State.DataTooBig;
            long effectiveMax = maximumMessageLength <= 0 ? Int64.MaxValue : (maximumMessageLength - totalBytesConsumed + bytesConsumed);
            if (effectiveMax == 0)
            {
                // effectiveMax is based on our max message size - if we've arrrived at the max size, then we need
                // to stop parsing.
                return State.DataTooBig;
            }

            if (bytesReady <= effectiveMax)
            {
                parseStatus = State.NeedMoreData;
                effectiveMax = bytesReady;
            }

            currentBodyPart.ResetBoundaryOffset();

            Contract.Assert(bytesConsumed < effectiveMax, "We have already consumed more than the max header length.");

            switch (bodyPartState)
            {
                case BodyPartState.BodyPart:
                    while (buffer[bytesConsumed] != MimeMultipartParser.CR)
                    {
                        if (++bytesConsumed == effectiveMax)
                        {
                            goto quit;
                        }
                    }

                    // Remember potential boundary
                    currentBodyPart.AppendBoundary(MimeMultipartParser.CR);

                    // Move past the CR
                    bodyPartState = BodyPartState.AfterFirstCarriageReturn;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case BodyPartState.AfterFirstCarriageReturn;

                case BodyPartState.AfterFirstCarriageReturn:
                    if (buffer[bytesConsumed] != MimeMultipartParser.LF)
                    {
                        currentBodyPart.ResetBoundary();
                        bodyPartState = BodyPartState.BodyPart;
                        goto case BodyPartState.BodyPart;
                    }

                    // Remember potential boundary
                    currentBodyPart.AppendBoundary(MimeMultipartParser.LF);

                    // Move past the CR
                    bodyPartState = BodyPartState.AfterFirstLineFeed;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case BodyPartState.AfterFirstLineFeed;

                case BodyPartState.AfterFirstLineFeed:
                    if (buffer[bytesConsumed] == MimeMultipartParser.CR)
                    {
                        // Remember potential boundary
                        currentBodyPart.ResetBoundary();
                        currentBodyPart.AppendBoundary(MimeMultipartParser.CR);

                        // Move past the CR
                        bodyPartState = BodyPartState.AfterFirstCarriageReturn;
                        if (++bytesConsumed == effectiveMax)
                        {
                            goto quit;
                        }

                        goto case BodyPartState.AfterFirstCarriageReturn;
                    }

                    if (buffer[bytesConsumed] != MimeMultipartParser.Dash)
                    {
                        currentBodyPart.ResetBoundary();
                        bodyPartState = BodyPartState.BodyPart;
                        goto case BodyPartState.BodyPart;
                    }

                    // Remember potential boundary
                    currentBodyPart.AppendBoundary(MimeMultipartParser.Dash);

                    // Move past the Dash
                    bodyPartState = BodyPartState.AfterFirstDash;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case BodyPartState.AfterFirstDash;

                case BodyPartState.AfterFirstDash:
                    if (buffer[bytesConsumed] != MimeMultipartParser.Dash)
                    {
                        currentBodyPart.ResetBoundary();
                        bodyPartState = BodyPartState.BodyPart;
                        goto case BodyPartState.BodyPart;
                    }

                    // Remember potential boundary
                    currentBodyPart.AppendBoundary(MimeMultipartParser.Dash);

                    // Move past the Dash
                    bodyPartState = BodyPartState.Boundary;
                    if (++bytesConsumed == effectiveMax)
                    {
                        goto quit;
                    }

                    goto case BodyPartState.Boundary;

                case BodyPartState.Boundary:
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != MimeMultipartParser.CR)
                    {
                        if (++bytesConsumed == effectiveMax)
                        {
                            if (currentBodyPart.AppendBoundary(buffer, segmentStart, bytesConsumed - segmentStart))
                            {
                                if (currentBodyPart.IsBoundaryComplete())
                                {
                                    // At this point we've seen the end of a boundary segment that is aligned at the end
                                    // of the buffer - this might be because we have another segment coming or it might
                                    // truly be the end of the message.
                                    bodyPartState = BodyPartState.AfterBoundary;
                                }
                            }
                            else
                            {
                                currentBodyPart.ResetBoundary();
                                bodyPartState = BodyPartState.BodyPart;
                            }
                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        if (!currentBodyPart.AppendBoundary(buffer, segmentStart, bytesConsumed - segmentStart))
                        {
                            currentBodyPart.ResetBoundary();
                            bodyPartState = BodyPartState.BodyPart;
                            goto case BodyPartState.BodyPart;
                        }
                    }

                    goto case BodyPartState.AfterBoundary;

                case BodyPartState.AfterBoundary:

                    // This state means that we just saw the end of a boundary. It might by a 'normal' boundary, in which
                    // case it's followed by optional whitespace and a CRLF. Or it might be the 'final' boundary and will
                    // be followed by '--', optional whitespace and an optional CRLF.
                    if (buffer[bytesConsumed] == MimeMultipartParser.Dash && !currentBodyPart.IsFinal)
                    {
                        currentBodyPart.AppendBoundary(MimeMultipartParser.Dash);
                        if (++bytesConsumed == effectiveMax)
                        {
                            bodyPartState = BodyPartState.AfterSecondDash;
                            goto quit;
                        }

                        goto case BodyPartState.AfterSecondDash;
                    }

                    // Capture optional whitespace
                    segmentStart = bytesConsumed;
                    while (buffer[bytesConsumed] != MimeMultipartParser.CR)
                    {
                        if (++bytesConsumed == effectiveMax)
                        {
                            if (!currentBodyPart.AppendBoundary(buffer, segmentStart, bytesConsumed - segmentStart))
                            {
                                // It's an unexpected character
                                currentBodyPart.ResetBoundary();
                                bodyPartState = BodyPartState.BodyPart;
                            }

                            goto quit;
                        }
                    }

                    if (bytesConsumed > segmentStart)
                    {
                        if (!currentBodyPart.AppendBoundary(buffer, segmentStart, bytesConsumed - segmentStart))
                        {
                            currentBodyPart.ResetBoundary();
                            bodyPartState = BodyPartState.BodyPart;
                            goto case BodyPartState.BodyPart;
                        }
                    }

                    if (buffer[bytesConsumed] == MimeMultipartParser.CR)
                    {
                        currentBodyPart.AppendBoundary(MimeMultipartParser.CR);
                        if (++bytesConsumed == effectiveMax)
                        {
                            bodyPartState = BodyPartState.AfterSecondCarriageReturn;
                            goto quit;
                        }

                        goto case BodyPartState.AfterSecondCarriageReturn;
                    }
                    else
                    {
                        // It's an unexpected character
                        currentBodyPart.ResetBoundary();
                        bodyPartState = BodyPartState.BodyPart;
                        goto case BodyPartState.BodyPart;
                    }

                case BodyPartState.AfterSecondDash:
                    if (buffer[bytesConsumed] == MimeMultipartParser.Dash)
                    {
                        currentBodyPart.AppendBoundary(MimeMultipartParser.Dash);
                        bytesConsumed++;

                        if (currentBodyPart.IsBoundaryComplete())
                        {
                            Debug.Assert(currentBodyPart.IsFinal);

                            // If we get in here, it means we've see the trailing '--' of the last boundary - in order to consume all of the
                            // remaining bytes, we don't mark the parse as complete again - wait until this method is called again with the
                            // empty buffer to do that.
                            bodyPartState = BodyPartState.AfterBoundary;
                            parseStatus = State.NeedMoreData;
                            goto quit;
                        }
                        else
                        {
                            currentBodyPart.ResetBoundary();
                            if (bytesConsumed == effectiveMax)
                            {
                                goto quit;
                            }

                            goto case BodyPartState.BodyPart;
                        }
                    }
                    else
                    {
                        currentBodyPart.ResetBoundary();
                        bodyPartState = BodyPartState.BodyPart;
                        goto case BodyPartState.BodyPart;
                    }

                case BodyPartState.AfterSecondCarriageReturn:
                    if (buffer[bytesConsumed] != MimeMultipartParser.LF)
                    {
                        currentBodyPart.ResetBoundary();
                        bodyPartState = BodyPartState.BodyPart;
                        goto case BodyPartState.BodyPart;
                    }

                    currentBodyPart.AppendBoundary(MimeMultipartParser.LF);
                    bytesConsumed++;

                    bodyPartState = BodyPartState.BodyPart;
                    if (currentBodyPart.IsBoundaryComplete())
                    {
                        parseStatus = State.BodyPartCompleted;
                        goto quit;
                    }
                    else
                    {
                        currentBodyPart.ResetBoundary();
                        if (bytesConsumed == effectiveMax)
                        {
                            goto quit;
                        }

                        goto case BodyPartState.BodyPart;
                    }
            }

        quit:
            if (initialBytesParsed < bytesConsumed)
            {
                int boundaryLength = currentBodyPart.BoundaryDelta;
                if (boundaryLength > 0 && parseStatus != State.BodyPartCompleted)
                {
                    currentBodyPart.HasPotentialBoundaryLeftOver = true;
                }

                int bodyPartEnd = bytesConsumed - initialBytesParsed - boundaryLength;

                currentBodyPart.BodyPart = new ArraySegment<byte>(buffer, initialBytesParsed, bodyPartEnd);
            }

            totalBytesConsumed += bytesConsumed - initialBytesParsed;
            return parseStatus;
        }

        /// <summary>
        /// Maintains information about the current body part being parsed.
        /// </summary>
        [DebuggerDisplay("{DebuggerToString()}")]
        private class CurrentBodyPartStore
        {
            private const int InitialOffset = 2;

            private byte[] _boundaryStore = new byte[MaxBoundarySize];
            private int _boundaryStoreLength;

            private byte[] _referenceBoundary = new byte[MaxBoundarySize];
            private int _referenceBoundaryLength;

            private byte[] _boundary = new byte[MaxBoundarySize];
            private int _boundaryLength = 0;

            private ArraySegment<byte> _bodyPart = MimeMultipartParser._emptyBodyPart;
            private bool _isFinal;
            private bool _isFirst = true;
            private bool _releaseDiscardedBoundary;
            private int _boundaryOffset;

            /// <summary>
            /// Initializes a new instance of the <see cref="CurrentBodyPartStore"/> class.
            /// </summary>
            /// <param name="referenceBoundary">The reference boundary.</param>
            public CurrentBodyPartStore(string referenceBoundary)
            {
                Contract.Assert(referenceBoundary != null);

                _referenceBoundary[0] = MimeMultipartParser.CR;
                _referenceBoundary[1] = MimeMultipartParser.LF;
                _referenceBoundary[2] = MimeMultipartParser.Dash;
                _referenceBoundary[3] = MimeMultipartParser.Dash;
                _referenceBoundaryLength = 4 + Encoding.UTF8.GetBytes(referenceBoundary, 0, referenceBoundary.Length, _referenceBoundary, 4);

                _boundary[0] = MimeMultipartParser.CR;
                _boundary[1] = MimeMultipartParser.LF;
                _boundaryLength = CurrentBodyPartStore.InitialOffset;
            }

            /// <summary>
            /// Gets or sets a value indicating whether this instance has potential boundary left over.
            /// </summary>
            /// <value>
            /// <c>true</c> if this instance has potential boundary left over; otherwise, <c>false</c>.
            /// </value>
            public bool HasPotentialBoundaryLeftOver { get; set; }

            /// <summary>
            /// Gets the boundary delta.
            /// </summary>
            public int BoundaryDelta
            {
                get { return (_boundaryLength - _boundaryOffset > 0) ? _boundaryLength - _boundaryOffset : _boundaryLength; }
            }

            /// <summary>
            /// Gets or sets the body part.
            /// </summary>
            /// <value>
            /// The body part.
            /// </value>
            public ArraySegment<byte> BodyPart
            {
                get { return _bodyPart; }

                set { _bodyPart = value; }
            }

            /// <summary>
            /// Gets a value indicating whether this body part instance is final.
            /// </summary>
            /// <value>
            ///   <c>true</c> if this body part instance is final; otherwise, <c>false</c>.
            /// </value>
            public bool IsFinal
            {
                get { return _isFinal; }
            }

            /// <summary>
            /// Resets the boundary offset.
            /// </summary>
            public void ResetBoundaryOffset()
            {
                _boundaryOffset = _boundaryLength;
            }

            /// <summary>
            /// Resets the boundary.
            /// </summary>
            public void ResetBoundary()
            {
                // If we had a potential boundary left over then store it so that we don't loose it
                if (HasPotentialBoundaryLeftOver)
                {
                    Buffer.BlockCopy(_boundary, 0, _boundaryStore, 0, _boundaryOffset);
                    _boundaryStoreLength = _boundaryOffset;
                    HasPotentialBoundaryLeftOver = false;
                    _releaseDiscardedBoundary = true;
                }

                _boundaryLength = 0;
                _boundaryOffset = 0;
            }

            /// <summary>
            /// Appends byte to the current boundary.
            /// </summary>
            /// <param name="data">The data to append to the boundary.</param>
            public void AppendBoundary(byte data)
            {
                _boundary[_boundaryLength++] = data;
            }

            /// <summary>
            /// Appends array of bytes to the current boundary.
            /// </summary>
            /// <param name="data">The data to append to the boundary.</param>
            /// <param name="offset">The offset into the data.</param>
            /// <param name="count">The number of bytes to append.</param>
            public bool AppendBoundary(byte[] data, int offset, int count)
            {
                // Check that potential boundary is not bigger than our reference boundary.
                // Allow for 2 extra characters to include the final boundary which ends with
                // an additional "--" sequence + plus up to 4 LWS characters (which are allowed).
                if (_boundaryLength + count > _referenceBoundaryLength + 6)
                {
                    return false;
                }

                int cnt = _boundaryLength;
                Buffer.BlockCopy(data, offset, _boundary, _boundaryLength, count);
                _boundaryLength += count;

                // Verify that boundary matches so far
                int maxCount = Math.Min(_boundaryLength, _referenceBoundaryLength);
                for (; cnt < maxCount; cnt++)
                {
                    if (_boundary[cnt] != _referenceBoundary[cnt])
                    {
                        return false;
                    }
                }

                return true;
            }

            /// <summary>
            /// Gets the discarded boundary.
            /// </summary>
            /// <returns>An <see cref="ArraySegment{T}"/> containing the discarded boundary.</returns>
            public ArraySegment<byte> GetDiscardedBoundary()
            {
                if (_boundaryStoreLength > 0 && _releaseDiscardedBoundary)
                {
                    ArraySegment<byte> discarded = new ArraySegment<byte>(_boundaryStore, 0, _boundaryStoreLength);
                    _boundaryStoreLength = 0;
                    return discarded;
                }

                return MimeMultipartParser._emptyBodyPart;
            }

            /// <summary>
            /// Determines whether current boundary is valid.
            /// </summary>
            /// <returns>
            ///   <c>true</c> if curent boundary is valid; otherwise, <c>false</c>.
            /// </returns>
            public bool IsBoundaryValid()
            {
                int offset = 0;
                if (_isFirst)
                {
                    offset = CurrentBodyPartStore.InitialOffset;
                }

                int count = offset;
                for (; count < _referenceBoundaryLength; count++)
                {
                    if (_boundary[count] != _referenceBoundary[count])
                    {
                        return false;
                    }
                }

                // Check for final
                bool boundaryIsFinal = false;
                if (_boundary[count] == MimeMultipartParser.Dash &&
                    _boundary[count + 1] == MimeMultipartParser.Dash)
                {
                    boundaryIsFinal = true;
                    count += 2;
                }

                // Rest of boundary must be ignorable whitespace in order for it to match
                for (; count < _boundaryLength - 2; count++)
                {
                    if (_boundary[count] != MimeMultipartParser.SP && _boundary[count] != MimeMultipartParser.HTAB)
                    {
                        return false;
                    }
                }

                // We have a valid boundary so whatever we stored in the boundary story is no longer needed
                _isFinal = boundaryIsFinal;
                _isFirst = false;

                return true;
            }

            public bool IsBoundaryComplete()
            {
                if (!IsBoundaryValid())
                {
                    return false;
                }

                if (_boundaryLength < _referenceBoundaryLength)
                {
                    return false;
                }

                if (_boundaryLength == _referenceBoundaryLength + 1 &&
                    _boundary[_referenceBoundaryLength] == MimeMultipartParser.Dash)
                {
                    return false;
                }

                return true;
            }

            /// <summary>
            /// Clears the body part.
            /// </summary>
            public void ClearBodyPart()
            {
                BodyPart = MimeMultipartParser._emptyBodyPart;
            }

            /// <summary>
            /// Clears all.
            /// </summary>
            public void ClearAll()
            {
                _releaseDiscardedBoundary = false;
                HasPotentialBoundaryLeftOver = false;
                _boundaryLength = 0;
                _boundaryOffset = 0;
                _boundaryStoreLength = 0;
                _isFinal = false;
                ClearBodyPart();
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Used for Debugger Display.")]
            private string DebuggerToString()
            {
                var referenceBoundary = Encoding.UTF8.GetString(_referenceBoundary, 0, _referenceBoundaryLength);
                var boundary = Encoding.UTF8.GetString(_boundary, 0, _boundaryLength);

                return String.Format(
                    CultureInfo.InvariantCulture,
                    "Expected: {0} *** Current: {1}",
                    referenceBoundary,
                    boundary);
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/Parsers/ParserState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http.Formatting.Parsers
{
    /// <summary>
    /// Represents the overall state of various parsers.
    /// </summary>
    internal enum ParserState
    {
        /// <summary>
        /// Need more data
        /// </summary>
        NeedMoreData = 0,

        /// <summary>
        /// Parsing completed (final)
        /// </summary>
        Done,

        /// <summary>
        /// Bad data format (final)
        /// </summary>
        Invalid,

        /// <summary>
        /// Data exceeds the allowed size (final)
        /// </summary>
        DataTooBig,
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/QueryStringMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Class that provides <see cref="MediaTypeHeaderValue"/>s from query strings.
    /// </summary>
    public class QueryStringMapping : MediaTypeMapping
    {
        private static readonly Type _queryStringMappingType = typeof(QueryStringMapping);

        /// <summary>
        /// Initializes a new instance of the <see cref="QueryStringMapping"/> class.
        /// </summary>
        /// <param name="queryStringParameterName">The name of the query string parameter to match, if present.</param>
        /// <param name="queryStringParameterValue">The value of the query string parameter specified by <paramref name="queryStringParameterName"/>.</param>
        /// <param name="mediaType">The media type to use if the query parameter specified by <paramref name="queryStringParameterName"/> is present
        /// and assigned the value specified by <paramref name="queryStringParameterValue"/>.</param>
        public QueryStringMapping(string queryStringParameterName, string queryStringParameterValue, string mediaType)
            : base(mediaType)
        {
            Initialize(queryStringParameterName, queryStringParameterValue);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="QueryStringMapping"/> class.
        /// </summary>
        /// <param name="queryStringParameterName">The name of the query string parameter to match, if present.</param>
        /// <param name="queryStringParameterValue">The value of the query string parameter specified by <paramref name="queryStringParameterName"/>.</param>
        /// <param name="mediaType">The <see cref="MediaTypeHeaderValue"/> to use if the query parameter specified by <paramref name="queryStringParameterName"/> is present
        /// and assigned the value specified by <paramref name="queryStringParameterValue"/>.</param>
        public QueryStringMapping(string queryStringParameterName, string queryStringParameterValue, MediaTypeHeaderValue mediaType)
            : base(mediaType)
        {
            Initialize(queryStringParameterName, queryStringParameterValue);
        }

        /// <summary>
        /// Gets the query string parameter name.
        /// </summary>
        public string QueryStringParameterName { get; private set; }

        /// <summary>
        /// Gets the query string parameter value.
        /// </summary>
        public string QueryStringParameterValue { get; private set; }

        /// <summary>
        /// Returns a value indicating whether the current <see cref="QueryStringMapping"/>
        /// instance can return a <see cref="MediaTypeHeaderValue"/> from <paramref name="request"/>.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/> to check.</param>
        /// <returns>If this instance can produce a <see cref="MediaTypeHeaderValue"/> from <paramref name="request"/>
        /// it returns <c>1.0</c> otherwise <c>0.0</c>.</returns>
        public override double TryMatchMediaType(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            NameValueCollection queryString = GetQueryString(request.RequestUri);
            return DoesQueryStringMatch(queryString) ? FormattingUtilities.Match : FormattingUtilities.NoMatch;
        }

        private static NameValueCollection GetQueryString(Uri uri)
        {
            if (uri == null)
            {
                throw Error.InvalidOperation(Properties.Resources.NonNullUriRequiredForMediaTypeMapping, _queryStringMappingType.Name);
            }

            return new FormDataCollection(uri).ReadAsNameValueCollection();
        }

        private void Initialize(string queryStringParameterName, string queryStringParameterValue)
        {
            if (String.IsNullOrWhiteSpace(queryStringParameterName))
            {
                throw Error.ArgumentNull("queryStringParameterName");
            }

            if (String.IsNullOrWhiteSpace(queryStringParameterValue))
            {
                throw Error.ArgumentNull("queryStringParameterValue");
            }

            QueryStringParameterName = queryStringParameterName.Trim();
            QueryStringParameterValue = queryStringParameterValue.Trim();
        }

        private bool DoesQueryStringMatch(NameValueCollection queryString)
        {
            if (queryString != null)
            {
                foreach (string queryParameter in queryString.AllKeys)
                {
                    if (String.Equals(queryParameter, QueryStringParameterName, StringComparison.OrdinalIgnoreCase))
                    {
                        string queryValue = queryString[queryParameter];
                        if (String.Equals(queryValue, QueryStringParameterValue, StringComparison.OrdinalIgnoreCase))
                        {
                            return true;
                        }
                    }
                }
            }

            return false;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/RequestHeaderMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// This class provides a mapping from an arbitrary HTTP request header field to a <see cref="MediaTypeHeaderValue"/>
    /// used to select <see cref="MediaTypeFormatter"/> instances for handling the entity body of an <see cref="HttpRequestMessage"/>
    /// or <see cref="HttpResponseMessage"/>.
    /// <remarks>This class only checks header fields associated with <see cref="HttpRequestMessage.Headers"/> for a match. It does
    /// not check header fields associated with <see cref="HttpResponseMessage.Headers"/> or <see cref="HttpContent.Headers"/> instances.</remarks>
    /// </summary>
    public class RequestHeaderMapping : MediaTypeMapping
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RequestHeaderMapping"/> class.
        /// </summary>
        /// <param name="headerName">Name of the header to match.</param>
        /// <param name="headerValue">The header value to match.</param>
        /// <param name="valueComparison">The value comparison to use when matching <paramref name="headerValue"/>.</param>
        /// <param name="isValueSubstring">if set to <c>true</c> then <paramref name="headerValue"/> is
        /// considered a match if it matches a substring of the actual header value.</param>
        /// <param name="mediaType">The media type to use if <paramref name="headerName"/> and <paramref name="headerValue"/>
        /// is considered a match.</param>
        public RequestHeaderMapping(string headerName, string headerValue, StringComparison valueComparison, bool isValueSubstring, string mediaType)
            : base(mediaType)
        {
            Initialize(headerName, headerValue, valueComparison, isValueSubstring);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RequestHeaderMapping"/> class.
        /// </summary>
        /// <param name="headerName">Name of the header to match.</param>
        /// <param name="headerValue">The header value to match.</param>
        /// <param name="valueComparison">The <see cref="StringComparison"/> to use when matching <paramref name="headerValue"/>.</param>
        /// <param name="isValueSubstring">if set to <c>true</c> then <paramref name="headerValue"/> is
        /// considered a match if it matches a substring of the actual header value.</param>
        /// <param name="mediaType">The <see cref="MediaTypeHeaderValue"/> to use if <paramref name="headerName"/> and <paramref name="headerValue"/>
        /// is considered a match.</param>
        public RequestHeaderMapping(string headerName, string headerValue, StringComparison valueComparison, bool isValueSubstring, MediaTypeHeaderValue mediaType)
            : base(mediaType)
        {
            Initialize(headerName, headerValue, valueComparison, isValueSubstring);
        }

        /// <summary>
        /// Gets the name of the header to match.
        /// </summary>
        public string HeaderName { get; private set; }

        /// <summary>
        /// Gets the header value to match.
        /// </summary>
        public string HeaderValue { get; private set; }

        /// <summary>
        /// Gets the <see cref="StringComparison"/> to use when matching <see cref="HeaderValue"/>.
        /// </summary>
        public StringComparison HeaderValueComparison { get; private set; }

        /// <summary>
        /// Gets a value indicating whether <see cref="HeaderValue"/> is
        /// a matched as a substring of the actual header value.
        /// this instance is value substring.
        /// </summary>
        /// <value>
        /// <c>true</c> if <see cref="HeaderValue"/> is to be matched as a substring; otherwise <c>false</c>.
        /// </value>
        public bool IsValueSubstring { get; private set; }

        /// <summary>
        /// Returns a value indicating whether the current <see cref="RequestHeaderMapping"/>
        /// instance can return a <see cref="MediaTypeHeaderValue"/> from <paramref name="request"/>.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/> to check.</param>
        /// <returns>
        /// The quality of the match. It must be between <c>0.0</c> and <c>1.0</c>.
        /// A value of <c>0.0</c> signifies no match.
        /// A value of <c>1.0</c> signifies a complete match.
        /// </returns>
        public override double TryMatchMediaType(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return MatchHeaderValue(request, HeaderName, HeaderValue, HeaderValueComparison, IsValueSubstring);
        }

        private static double MatchHeaderValue(HttpRequestMessage request, string headerName, string headerValue, StringComparison valueComparison, bool isValueSubstring)
        {
            Contract.Assert(request != null, "request should not be null");
            Contract.Assert(headerName != null, "header name should not be null");
            Contract.Assert(headerValue != null, "header value should not be null");

            IEnumerable<string> values;
            if (request.Headers.TryGetValues(headerName, out values))
            {
                foreach (string value in values)
                {
                    if (isValueSubstring)
                    {
                        if (value.IndexOf(headerValue, valueComparison) != -1)
                        {
                            return FormattingUtilities.Match;
                        }
                    }
                    else
                    {
                        if (value.Equals(headerValue, valueComparison))
                        {
                            return FormattingUtilities.Match;
                        }
                    }
                }
            }

            return FormattingUtilities.NoMatch;
        }

        private void Initialize(string headerName, string headerValue, StringComparison valueComparison, bool isValueSubstring)
        {
            if (String.IsNullOrWhiteSpace(headerName))
            {
                throw Error.ArgumentNull("headerName");
            }

            if (String.IsNullOrWhiteSpace(headerValue))
            {
                throw Error.ArgumentNull("headerValue");
            }

            StringComparisonHelper.Validate(valueComparison, "valueComparison");

            HeaderName = headerName;
            HeaderValue = headerValue;
            HeaderValueComparison = valueComparison;
            IsValueSubstring = isValueSubstring;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/StringComparisonHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Helper class for validating <see cref="StringComparison"/> values.
    /// </summary>
    internal static class StringComparisonHelper
    {
        /// <summary>
        /// Determines whether the specified <paramref name="value"/> is defined by the <see cref="StringComparison"/>
        /// enumeration.
        /// </summary>
        /// <param name="value">The value to verify.</param>
        /// <returns>
        /// <c>true</c> if the specified options is defined; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsDefined(StringComparison value)
        {
            return value == StringComparison.CurrentCulture ||
                   value == StringComparison.CurrentCultureIgnoreCase ||
#if !NETSTANDARD1_3
                   value == StringComparison.InvariantCulture ||
                   value == StringComparison.InvariantCultureIgnoreCase ||
#endif
                   value == StringComparison.Ordinal ||
                   value == StringComparison.OrdinalIgnoreCase;
        }

        /// <summary>
        /// Validates the specified <paramref name="value"/> and throws an <see cref="ArgumentException"/>
        /// exception if not valid.
        /// </summary>
        /// <param name="value">The value to validate.</param>
        /// <param name="parameterName">Name of the parameter to use if throwing exception.</param>
        public static void Validate(StringComparison value, string parameterName)
        {
            if (!IsDefined(value))
            {
                throw Error.InvalidEnumArgument(parameterName, (int)value, typeof(StringComparison));
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/StringWithQualityHeaderValueComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http.Headers;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Implementation of <see cref="IComparer{T}"/> that can compare content negotiation header fields
    /// based on their quality values (a.k.a q-values). This applies to values used in accept-charset,
    /// accept-encoding, accept-language and related header fields with similar syntax rules. See
    /// <see cref="MediaTypeWithQualityHeaderValueComparer"/> for a comparer for media type
    /// q-values.
    /// </summary>
    internal class StringWithQualityHeaderValueComparer : IComparer<StringWithQualityHeaderValue>
    {
        private static readonly StringWithQualityHeaderValueComparer _qualityComparer =
            new StringWithQualityHeaderValueComparer();

        private StringWithQualityHeaderValueComparer()
        {
        }

        public static StringWithQualityHeaderValueComparer QualityComparer
        {
            get { return _qualityComparer; }
        }

        /// <summary>
        /// Compares two <see cref="StringWithQualityHeaderValue"/> based on their quality value (a.k.a their "q-value").
        /// Values with identical q-values are considered equal (i.e the result is 0) with the exception of wild-card
        /// values (i.e. a value of "*") which are considered less than non-wild-card values. This allows to sort
        /// a sequence of <see cref="StringWithQualityHeaderValue"/> following their q-values ending up with any
        /// wild-cards at the end.
        /// </summary>
        /// <param name="stringWithQuality1">The first value to compare.</param>
        /// <param name="stringWithQuality2">The second value to compare</param>
        /// <returns>The result of the comparison.</returns>
        public int Compare(StringWithQualityHeaderValue stringWithQuality1,
                           StringWithQualityHeaderValue stringWithQuality2)
        {
            Contract.Assert(stringWithQuality1 != null);
            Contract.Assert(stringWithQuality2 != null);

            double quality1 = stringWithQuality1.Quality ?? FormattingUtilities.Match;
            double quality2 = stringWithQuality2.Quality ?? FormattingUtilities.Match;
            double qualityDifference = quality1 - quality2;
            if (qualityDifference < 0)
            {
                return -1;
            }
            else if (qualityDifference > 0)
            {
                return 1;
            }

            if (!String.Equals(stringWithQuality1.Value, stringWithQuality2.Value, StringComparison.OrdinalIgnoreCase))
            {
                if (String.Equals(stringWithQuality1.Value, "*", StringComparison.OrdinalIgnoreCase))
                {
                    return -1;
                }
                else if (String.Equals(stringWithQuality2.Value, "*", StringComparison.OrdinalIgnoreCase))
                {
                    return 1;
                }
            }

            return 0;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/XmlHttpRequestHeaderMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// A <see cref="RequestHeaderMapping"/> that maps the X-Requested-With http header field set by AJAX XmlHttpRequest (XHR)
    /// to the media type <c>application/json</c> if no explicit Accept header fields are present in the request.
    /// </summary>
    public class XmlHttpRequestHeaderMapping : RequestHeaderMapping
    {
        /// <summary>
        /// Initializes a new instance of <see cref="XmlHttpRequestHeaderMapping" /> class
        /// </summary>
        public XmlHttpRequestHeaderMapping() :
            base(FormattingUtilities.HttpRequestedWithHeader, FormattingUtilities.HttpRequestedWithHeaderValue, StringComparison.OrdinalIgnoreCase, isValueSubstring: true, mediaType: MediaTypeConstants.ApplicationJsonMediaType)
        {
        }

        /// <summary>
        /// Returns a value indicating whether the current <see cref="RequestHeaderMapping"/>
        /// instance can return a <see cref="MediaTypeHeaderValue"/> from <paramref name="request"/>.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/> to check.</param>
        /// <returns>
        /// The quality of the match.
        /// A value of <c>0.0</c> signifies no match.
        /// A value of <c>1.0</c> signifies a complete match and that the request was made using XmlHttpRequest without an Accept header.
        /// </returns>
        public override double TryMatchMediaType(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            // Accept header trumps XHR mapping.
            // Accept: */* is equivalent to passing no Accept header.
            if (request.Headers.Accept.Count == 0
                || (request.Headers.Accept.Count == 1 && request.Headers.Accept.First().MediaType.Equals("*/*", StringComparison.Ordinal)))
            {
                return base.TryMatchMediaType(request);
            }
            else
            {
                return FormattingUtilities.NoMatch;
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Formatting/XmlMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Headers;
using System.Net.Http.Internal;
using System.Runtime.Serialization;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using System.Xml;
using System.Xml.Serialization;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// <see cref="MediaTypeFormatter"/> class to handle Xml.
    /// </summary>
    public class XmlMediaTypeFormatter : MediaTypeFormatter
    {
        private ConcurrentDictionary<Type, object> _serializerCache = new ConcurrentDictionary<Type, object>();
        private XmlDictionaryReaderQuotas _readerQuotas = FormattingUtilities.CreateDefaultReaderQuotas();

        /// <summary>
        /// Initializes a new instance of the <see cref="XmlMediaTypeFormatter"/> class.
        /// </summary>
        public XmlMediaTypeFormatter()
        {
            // Set default supported media types
            SupportedMediaTypes.Add(MediaTypeConstants.ApplicationXmlMediaType);
            SupportedMediaTypes.Add(MediaTypeConstants.TextXmlMediaType);

            // Set default supported character encodings
            SupportedEncodings.Add(new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));
            SupportedEncodings.Add(new UnicodeEncoding(bigEndian: false, byteOrderMark: true, throwOnInvalidBytes: true));
            WriterSettings = new XmlWriterSettings
            {
                OmitXmlDeclaration = true,
                CloseOutput = false,
                CheckCharacters = false
            };
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="XmlMediaTypeFormatter"/> class.
        /// </summary>
        /// <param name="formatter">The <see cref="XmlMediaTypeFormatter"/> instance to copy settings from.</param>
        protected XmlMediaTypeFormatter(XmlMediaTypeFormatter formatter)
            : base(formatter)
        {
            UseXmlSerializer = formatter.UseXmlSerializer;
            WriterSettings = formatter.WriterSettings;
            MaxDepth = formatter.MaxDepth;
        }

        /// <summary>
        /// Gets the default media type for xml, namely "application/xml".
        /// </summary>
        /// <value>
        /// <remarks>
        /// The default media type does not have any <c>charset</c> parameter as
        /// the <see cref="Encoding"/> can be configured on a per <see cref="XmlMediaTypeFormatter"/>
        /// instance basis.
        /// </remarks>
        /// Because <see cref="MediaTypeHeaderValue"/> is mutable, the value
        /// returned will be a new instance every time.
        /// </value>
        public static MediaTypeHeaderValue DefaultMediaType
        {
            get { return MediaTypeConstants.ApplicationXmlMediaType; }
        }

        /// <summary>
        /// Gets or sets a value indicating whether to use <see cref="XmlSerializer"/> instead of <see cref="DataContractSerializer"/> by default.
        /// </summary>
        /// <value>
        ///     <c>true</c> if use <see cref="XmlSerializer"/> by default; otherwise, <c>false</c>. The default is <c>false</c>.
        /// </value>
        [DefaultValue(false)]
        public bool UseXmlSerializer { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to indent elements when writing data.
        /// </summary>
        public bool Indent
        {
            get
            {
                return WriterSettings.Indent;
            }
            set
            {
                WriterSettings.Indent = value;
            }
        }

        /// <summary>
        /// Gets the <see cref="XmlWriterSettings"/> to be used while writing.
        /// </summary>
        public XmlWriterSettings WriterSettings { get; private set; }

        /// <summary>
        /// Gets or sets the maximum depth allowed by this formatter.
        /// </summary>
        public int MaxDepth
        {
            get
            {
                return _readerQuotas.MaxDepth;
            }
            set
            {
                if (value < FormattingUtilities.DefaultMinDepth)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, FormattingUtilities.DefaultMinDepth);
                }

                _readerQuotas.MaxDepth = value;
            }
        }

        /// <summary>
        /// Registers the <see cref="XmlObjectSerializer"/> to use to read or write
        /// the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The type of object that will be serialized or deserialized with <paramref name="serializer"/>.</param>
        /// <param name="serializer">The <see cref="XmlObjectSerializer"/> instance to use.</param>
        public void SetSerializer(Type type, XmlObjectSerializer serializer)
        {
            VerifyAndSetSerializer(type, serializer);
        }

        /// <summary>
        /// Registers the <see cref="XmlObjectSerializer"/> to use to read or write
        /// the specified <typeparamref name="T"/> type.
        /// </summary>
        /// <typeparam name="T">The type of object that will be serialized or deserialized with <paramref name="serializer"/>.</typeparam>
        /// <param name="serializer">The <see cref="XmlObjectSerializer"/> instance to use.</param>
        [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "The T represents a Type parameter.")]
        public void SetSerializer<T>(XmlObjectSerializer serializer)
        {
            SetSerializer(typeof(T), serializer);
        }

        /// <summary>
        /// Registers the <see cref="XmlSerializer"/> to use to read or write
        /// the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The type of objects for which <paramref name="serializer"/> will be used.</param>
        /// <param name="serializer">The <see cref="XmlSerializer"/> instance to use.</param>
        public void SetSerializer(Type type, XmlSerializer serializer)
        {
            VerifyAndSetSerializer(type, serializer);
        }

        /// <summary>
        /// Registers the <see cref="XmlSerializer"/> to use to read or write
        /// the specified <typeparamref name="T"/> type.
        /// </summary>
        /// <typeparam name="T">The type of object that will be serialized or deserialized with <paramref name="serializer"/>.</typeparam>
        /// <param name="serializer">The <see cref="XmlSerializer"/> instance to use.</param>
        [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "The T represents a Type parameter.")]
        public void SetSerializer<T>(XmlSerializer serializer)
        {
            SetSerializer(typeof(T), serializer);
        }

        /// <summary>
        /// Unregisters the serializer currently associated with the given <paramref name="type"/>.
        /// </summary>
        /// <remarks>
        /// Unless another serializer is registered for the <paramref name="type"/>, a default one will be created.
        /// </remarks>
        /// <param name="type">The type of object whose serializer should be removed.</param>
        /// <returns><c>true</c> if a serializer was registered for the <paramref name="type"/>; otherwise <c>false</c>.</returns>
        public bool RemoveSerializer(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            object value;
            return _serializerCache.TryRemove(type, out value);
        }

        /// <summary>
        /// Determines whether this <see cref="XmlMediaTypeFormatter"/> can read objects
        /// of the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The type of object that will be read.</param>
        /// <returns><c>true</c> if objects of this <paramref name="type"/> can be read, otherwise <c>false</c>.</returns>
        public override bool CanReadType(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            // If there is a registered non-null serializer, we can support this type.
            // Otherwise attempt to create the default serializer.
            object serializer = GetCachedSerializer(type, throwOnError: false);

            // Null means we tested it before and know it is not supported
            return serializer != null;
        }

        /// <summary>
        /// Determines whether this <see cref="XmlMediaTypeFormatter"/> can write objects
        /// of the specified <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The type of object that will be written.</param>
        /// <returns><c>true</c> if objects of this <paramref name="type"/> can be written, otherwise <c>false</c>.</returns>
        public override bool CanWriteType(Type type)
        {
            // Performance-sensitive
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (UseXmlSerializer)
            {
                MediaTypeFormatter.TryGetDelegatingTypeForIEnumerableGenericOrSame(ref type);
            }
            else
            {
                MediaTypeFormatter.TryGetDelegatingTypeForIQueryableGenericOrSame(ref type);
            }

            // If there is a registered non-null serializer, we can support this type.
            object serializer = GetCachedSerializer(type, throwOnError: false);

            // Null means we tested it before and know it is not supported
            return serializer != null;
        }

        /// <summary>
        /// Called during deserialization to read an object of the specified <paramref name="type"/>
        /// from the specified <paramref name="readStream"/>.
        /// </summary>
        /// <param name="type">The type of object to read.</param>
        /// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
        /// <param name="content">The <see cref="HttpContent"/> for the content being read.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (readStream == null)
            {
                throw Error.ArgumentNull("readStream");
            }

            try
            {
                return Task.FromResult(ReadFromStream(type, readStream, content, formatterLogger));
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError<object>(e);
            }
        }

        private object ReadFromStream(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;

            // If content length is 0 then return default value for this type
            if (contentHeaders != null && contentHeaders.ContentLength == 0)
            {
                return GetDefaultValueForType(type);
            }

            object serializer = GetDeserializer(type, content);

            try
            {
                using (XmlReader reader = CreateXmlReader(readStream, content))
                {
                    XmlSerializer xmlSerializer = serializer as XmlSerializer;
                    if (xmlSerializer != null)
                    {
                        return xmlSerializer.Deserialize(reader);
                    }
                    else
                    {
                        XmlObjectSerializer xmlObjectSerializer = serializer as XmlObjectSerializer;
                        if (xmlObjectSerializer == null)
                        {
                            ThrowInvalidSerializerException(serializer, "GetDeserializer");
                        }
                        return xmlObjectSerializer.ReadObject(reader);
                    }
                }
            }
            catch (Exception e)
            {
                if (formatterLogger == null)
                {
                    throw;
                }
                formatterLogger.LogError(String.Empty, e);
                return GetDefaultValueForType(type);
            }
        }

        /// <summary>
        /// Called during deserialization to get the XML serializer to use for deserializing objects.
        /// </summary>
        /// <param name="type">The type of object to deserialize.</param>
        /// <param name="content">The <see cref="HttpContent"/> for the content being read.</param>
        /// <returns>An instance of <see cref="XmlObjectSerializer"/> or <see cref="XmlSerializer"/> to use for deserializing the object.</returns>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", Justification = "The term deserializer is spelled correctly.")]
        protected internal virtual object GetDeserializer(Type type, HttpContent content)
        {
            return GetSerializerForType(type);
        }

        /// <summary>
        /// Called during deserialization to get the XML reader to use for reading objects from the stream.
        /// </summary>
        /// <param name="readStream">The <see cref="Stream"/> to read from.</param>
        /// <param name="content">The <see cref="HttpContent"/> for the content being read.</param>
        /// <returns>The <see cref="XmlReader"/> to use for reading objects.</returns>
        protected internal virtual XmlReader CreateXmlReader(Stream readStream, HttpContent content)
        {
            // Get the character encoding for the content
            Encoding effectiveEncoding = SelectCharacterEncoding(content == null ? null : content.Headers);

            // DCS encodings are limited to UTF8, UTF16BE, and UTF16LE. Convert to UTF8 as we read.
            Stream innerStream = string.Equals(effectiveEncoding.WebName, Utf8Encoding.WebName, StringComparison.OrdinalIgnoreCase) ?
                new NonClosingDelegatingStream(readStream) :
                new TranscodingStream(readStream, effectiveEncoding, Utf8Encoding, leaveOpen: true);

            // XmlDictionaryReader will always dispose of innerStream when caller disposes of the reader.
            return XmlDictionaryReader.CreateTextReader(innerStream, Utf8Encoding, _readerQuotas, onClose: null);
        }

        /// <inheritdoc/>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (writeStream == null)
            {
                throw Error.ArgumentNull("writeStream");
            }
            if (cancellationToken.IsCancellationRequested)
            {
                return TaskHelpers.Canceled();
            }

            try
            {
                WriteToStream(type, value, writeStream, content);
                return TaskHelpers.Completed();
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError(e);
            }
        }

        private void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
        {
            bool isRemapped = false;
            if (UseXmlSerializer)
            {
                isRemapped = MediaTypeFormatter.TryGetDelegatingTypeForIEnumerableGenericOrSame(ref type);
            }
            else
            {
                isRemapped = MediaTypeFormatter.TryGetDelegatingTypeForIQueryableGenericOrSame(ref type);
            }

            if (isRemapped && value != null)
            {
                value = MediaTypeFormatter.GetTypeRemappingConstructor(type).Invoke(new object[] { value });
            }

            object serializer = GetSerializer(type, value, content);

            using (XmlWriter writer = CreateXmlWriter(writeStream, content))
            {
                XmlSerializer xmlSerializer = serializer as XmlSerializer;
                if (xmlSerializer != null)
                {
                    xmlSerializer.Serialize(writer, value);
                }
                else
                {
                    XmlObjectSerializer xmlObjectSerializer = serializer as XmlObjectSerializer;
                    if (xmlObjectSerializer == null)
                    {
                        ThrowInvalidSerializerException(serializer, "GetSerializer");
                    }
                    xmlObjectSerializer.WriteObject(writer, value);
                }
            }
        }

        /// <summary>
        /// Called during serialization to get the XML serializer to use for serializing objects.
        /// </summary>
        /// <param name="type">The type of object to serialize.</param>
        /// <param name="value">The object to serialize.</param>
        /// <param name="content">The <see cref="HttpContent"/> for the content being written.</param>
        /// <returns>An instance of <see cref="XmlObjectSerializer"/> or <see cref="XmlSerializer"/> to use for serializing the object.</returns>
        protected internal virtual object GetSerializer(Type type, object value, HttpContent content)
        {
            return GetSerializerForType(type);
        }

        /// <summary>
        /// Called during serialization to get the XML writer to use for writing objects to the stream.
        /// </summary>
        /// <param name="writeStream">The <see cref="Stream"/> to write to.</param>
        /// <param name="content">The <see cref="HttpContent"/> for the content being written.</param>
        /// <returns>The <see cref="XmlWriter"/> to use for writing objects.</returns>
        protected internal virtual XmlWriter CreateXmlWriter(Stream writeStream, HttpContent content)
        {
            Encoding effectiveEncoding = SelectCharacterEncoding(content != null ? content.Headers : null);
            WritePreamble(writeStream, effectiveEncoding);

            // DCS encodings are limited to UTF8, UTF16BE, and UTF16LE. Convert to UTF8 as we read.
            Stream innerStream = string.Equals(effectiveEncoding.WebName, Utf8Encoding.WebName, StringComparison.OrdinalIgnoreCase) ?
                writeStream :
                new TranscodingStream(writeStream, effectiveEncoding, Utf8Encoding, leaveOpen: true);

            XmlWriterSettings writerSettings = WriterSettings.Clone();
            writerSettings.Encoding = Utf8Encoding;

            // Have XmlWriter dispose of innerStream when caller disposes of the writer if using a TranscodingStream.
            writerSettings.CloseOutput = writeStream != innerStream;

            return XmlWriter.Create(innerStream, writerSettings);
        }

        /// <summary>
        /// Called during deserialization to get the XML serializer.
        /// </summary>
        /// <param name="type">The type of object that will be serialized or deserialized.</param>
        /// <returns>The <see cref="XmlSerializer"/> used to serialize the object.</returns>
        public virtual XmlSerializer CreateXmlSerializer(Type type)
        {
            return new XmlSerializer(type);
        }

        /// <summary>
        /// Called during deserialization to get the DataContractSerializer serializer.
        /// </summary>
        /// <param name="type">The type of object that will be serialized or deserialized.</param>
        /// <returns>The <see cref="DataContractSerializer"/> used to serialize the object.</returns>
        public virtual DataContractSerializer CreateDataContractSerializer(Type type)
        {
            return new DataContractSerializer(type);
        }

        /// <summary>
        /// This method is to support infrastructure and is not intended to be used directly from your code.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public XmlReader InvokeCreateXmlReader(Stream readStream, HttpContent content)
        {
            return CreateXmlReader(readStream, content);
        }

        /// <summary>
        /// This method is to support infrastructure and is not intended to be used directly from your code.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public XmlWriter InvokeCreateXmlWriter(Stream writeStream, HttpContent content)
        {
            return CreateXmlWriter(writeStream, content);
        }

        /// <summary>
        /// This method is to support infrastructure and is not intended to be used directly from your code.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public object InvokeGetDeserializer(Type type, HttpContent content)
        {
            return GetDeserializer(type, content);
        }

        /// <summary>
        /// This method is to support infrastructure and is not intended to be used directly from your code.
        /// </summary>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public object InvokeGetSerializer(Type type, object value, HttpContent content)
        {
            return GetSerializer(type, value, content);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Since we use an extensible factory method we cannot control the exceptions being thrown")]
        private object CreateDefaultSerializer(Type type, bool throwOnError)
        {
            Contract.Assert(type != null, "type cannot be null.");

#if NETSTANDARD1_3 // XsdDataContractExporter is not supported in netstandard1.3
            if (!UseXmlSerializer)
            {
                if (throwOnError)
                {
                    throw new PlatformNotSupportedException(Error.Format(
                        Properties.Resources.XmlMediaTypeFormatter_DCS_NotSupported,
                        nameof(UseXmlSerializer)));
                }
                else
                {
                    return null;
                }
            }
#endif

            Exception exception = null;
            object serializer = null;

            try
            {
                if (UseXmlSerializer)
                {
                    serializer = CreateXmlSerializer(type);
                }
                else
                {
#if !NETSTANDARD1_3 // Unreachable when targeting netstandard1.3.
                    // Verify that type is a valid data contract by forcing the serializer to try to create a data contract
                    FormattingUtilities.XsdDataContractExporter.GetRootElementName(type);

                    serializer = CreateDataContractSerializer(type);
#endif
                }
            }
            catch (Exception caught)
            {
                exception = caught;
            }

            if (serializer == null && throwOnError)
            {
                if (exception != null)
                {
                    throw Error.InvalidOperation(exception, Properties.Resources.SerializerCannotSerializeType,
                                  UseXmlSerializer ? typeof(XmlSerializer).Name : typeof(DataContractSerializer).Name,
                                  type.Name);
                }
                else
                {
                    throw Error.InvalidOperation(Properties.Resources.SerializerCannotSerializeType,
                              UseXmlSerializer ? typeof(XmlSerializer).Name : typeof(DataContractSerializer).Name,
                              type.Name);
                }
            }

            return serializer;
        }

        private object GetCachedSerializer(Type type, bool throwOnError)
        {
            // Performance-sensitive
            object serializer;
            if (!_serializerCache.TryGetValue(type, out serializer))
            {
                // Race condition on creation has no side effects
                serializer = CreateDefaultSerializer(type, throwOnError);
                _serializerCache.TryAdd(type, serializer);
            }
            return serializer;
        }

        private void VerifyAndSetSerializer(Type type, object serializer)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (serializer == null)
            {
                throw Error.ArgumentNull("serializer");
            }

            SetSerializerInternal(type, serializer);
        }

        private void SetSerializerInternal(Type type, object serializer)
        {
            Contract.Assert(type != null, "type cannot be null.");
            Contract.Assert(serializer != null, "serializer cannot be null.");

            _serializerCache.AddOrUpdate(type, serializer, (key, value) => serializer);
        }

        private object GetSerializerForType(Type type)
        {
            // Performance-sensitive
            Contract.Assert(type != null, "Type cannot be null");

            object serializer = GetCachedSerializer(type, throwOnError: true);

            if (serializer == null)
            {
                // A null serializer indicates the type has already been tested
                // and found unsupportable.
                throw Error.InvalidOperation(Properties.Resources.SerializerCannotSerializeType,
                              UseXmlSerializer ? typeof(XmlSerializer).Name : typeof(DataContractSerializer).Name,
                              type.Name);
            }

            Contract.Assert(serializer is XmlSerializer || serializer is XmlObjectSerializer, "Only XmlSerializer or XmlObjectSerializer are supported.");
            return serializer;
        }

        private static void ThrowInvalidSerializerException(object serializer, string getSerializerMethodName)
        {
            if (serializer == null)
            {
                throw Error.InvalidOperation(Properties.Resources.XmlMediaTypeFormatter_NullReturnedSerializer, getSerializerMethodName);
            }
            else
            {
                throw Error.InvalidOperation(Properties.Resources.XmlMediaTypeFormatter_InvalidSerializerType, serializer.GetType().Name, getSerializerMethodName);
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/FormattingUtilities.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Runtime.Serialization;
using System.Xml;
using Newtonsoft.Json.Linq;

namespace System.Net.Http
{
    /// <summary>
    /// Provides various internal utility functions
    /// </summary>
    internal static class FormattingUtilities
    {
        // Supported date formats for input.
        private static readonly string[] dateFormats = new string[]
        {
            // "r", // RFC 1123, required output format but too strict for input
            "ddd, d MMM yyyy H:m:s 'GMT'", // RFC 1123 (r, except it allows both 1 and 01 for date and time)
            "ddd, d MMM yyyy H:m:s", // RFC 1123, no zone - assume GMT
            "d MMM yyyy H:m:s 'GMT'", // RFC 1123, no day-of-week
            "d MMM yyyy H:m:s", // RFC 1123, no day-of-week, no zone
            "ddd, d MMM yy H:m:s 'GMT'", // RFC 1123, short year
            "ddd, d MMM yy H:m:s", // RFC 1123, short year, no zone
            "d MMM yy H:m:s 'GMT'", // RFC 1123, no day-of-week, short year
            "d MMM yy H:m:s", // RFC 1123, no day-of-week, short year, no zone

            "dddd, d'-'MMM'-'yy H:m:s 'GMT'", // RFC 850, short year
            "dddd, d'-'MMM'-'yy H:m:s", // RFC 850 no zone
            "ddd, d'-'MMM'-'yyyy H:m:s 'GMT'", // RFC 850, long year
            "ddd MMM d H:m:s yyyy", // ANSI C's asctime() format

            "ddd, d MMM yyyy H:m:s zzz", // RFC 5322
            "ddd, d MMM yyyy H:m:s", // RFC 5322 no zone
            "d MMM yyyy H:m:s zzz", // RFC 5322 no day-of-week
            "d MMM yyyy H:m:s", // RFC 5322 no day-of-week, no zone
        };

        // Valid header token characters are within the range 0x20 < c < 0x7F excluding the following characters
        private const string NonTokenChars = "()<>@,;:\\\"/[]?={}";

        /// <summary>
        /// Quality factor to indicate a perfect match.
        /// </summary>
        public const double Match = 1.0;

        /// <summary>
        /// Quality factor to indicate no match.
        /// </summary>
        public const double NoMatch = 0.0;

        /// <summary>
        /// The default max depth for our formatter is 256
        /// </summary>
        public const int DefaultMaxDepth = 256;

        /// <summary>
        /// The default min depth for our formatter is 1
        /// </summary>
        public const int DefaultMinDepth = 1;

        /// <summary>
        /// HTTP X-Requested-With header field name
        /// </summary>
        public const string HttpRequestedWithHeader = @"x-requested-with";

        /// <summary>
        /// HTTP X-Requested-With header field value
        /// </summary>
        public const string HttpRequestedWithHeaderValue = @"XMLHttpRequest";

        /// <summary>
        /// HTTP Host header field name
        /// </summary>
        public const string HttpHostHeader = "Host";

        /// <summary>
        /// HTTP Version token
        /// </summary>
        public const string HttpVersionToken = "HTTP";

        /// <summary>
        /// A <see cref="Type"/> representing <see cref="HttpRequestMessage"/>.
        /// </summary>
        public static readonly Type HttpRequestMessageType = typeof(HttpRequestMessage);

        /// <summary>
        /// A <see cref="Type"/> representing <see cref="HttpResponseMessage"/>.
        /// </summary>
        public static readonly Type HttpResponseMessageType = typeof(HttpResponseMessage);

        /// <summary>
        /// A <see cref="Type"/> representing <see cref="HttpContent"/>.
        /// </summary>
        public static readonly Type HttpContentType = typeof(HttpContent);

        /// <summary>
        /// A <see cref="Type"/> representing <see cref="DelegatingEnumerable{T}"/>.
        /// </summary>
        public static readonly Type DelegatingEnumerableGenericType = typeof(DelegatingEnumerable<>);

        /// <summary>
        /// A <see cref="Type"/> representing <see cref="IEnumerable{T}"/>.
        /// </summary>
        public static readonly Type EnumerableInterfaceGenericType = typeof(IEnumerable<>);

        /// <summary>
        /// A <see cref="Type"/> representing <see cref="IQueryable{T}"/>.
        /// </summary>
        public static readonly Type QueryableInterfaceGenericType = typeof(IQueryable<>);

#if !NETSTANDARD1_3 // XsdDataContractExporter is not supported in netstandard1.3
        /// <summary>
        /// An instance of <see cref="XsdDataContractExporter"/>.
        /// </summary>
        public static readonly XsdDataContractExporter XsdDataContractExporter = new XsdDataContractExporter();
#endif

        /// <summary>
        /// Determines whether <paramref name="type"/> is a <see cref="JToken"/> type.
        /// </summary>
        /// <param name="type">The type to test.</param>
        /// <returns>
        ///   <c>true</c> if <paramref name="type"/> is a <see cref="JToken"/> type; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsJTokenType(Type type)
        {
            return typeof(JToken).IsAssignableFrom(type);
        }

        /// <summary>
        /// Creates an empty <see cref="HttpContentHeaders"/> instance. The only way is to get it from a dummy
        /// <see cref="HttpContent"/> instance.
        /// </summary>
        /// <returns>The created instance.</returns>
        public static HttpContentHeaders CreateEmptyContentHeaders()
        {
            HttpContent tempContent = null;
            HttpContentHeaders contentHeaders = null;
            try
            {
                tempContent = new StringContent(String.Empty);
                contentHeaders = tempContent.Headers;
                contentHeaders.Clear();
            }
            finally
            {
                // We can dispose the content without touching the headers
                if (tempContent != null)
                {
                    tempContent.Dispose();
                }
            }

            return contentHeaders;
        }

        /// <summary>
        /// Create a default reader quotas with a default depth quota of 1K
        /// </summary>
        /// <returns></returns>
        public static XmlDictionaryReaderQuotas CreateDefaultReaderQuotas()
        {
            return new XmlDictionaryReaderQuotas()
            {
                MaxArrayLength = Int32.MaxValue,
                MaxBytesPerRead = Int32.MaxValue,
                MaxDepth = DefaultMaxDepth,
                MaxNameTableCharCount = Int32.MaxValue,
                MaxStringContentLength = Int32.MaxValue
            };
        }

        /// <summary>
        /// Remove bounding quotes on a token if present
        /// </summary>
        /// <param name="token">Token to unquote.</param>
        /// <returns>Unquoted token.</returns>
        public static string UnquoteToken(string token)
        {
            if (String.IsNullOrWhiteSpace(token))
            {
                return token;
            }

            if (token.StartsWith("\"", StringComparison.Ordinal) && token.EndsWith("\"", StringComparison.Ordinal) && token.Length > 1)
            {
                return token.Substring(1, token.Length - 2);
            }

            return token;
        }

        public static bool ValidateHeaderToken(string token)
        {
            if (token == null)
            {
                return false;
            }

            foreach (char c in token)
            {
                if (c < 0x21 || c > 0x7E || NonTokenChars.IndexOf(c) != -1)
                {
                    return false;
                }
            }

            return true;
        }

        public static string DateToString(DateTimeOffset dateTime)
        {
            // Format according to RFC1123; 'r' uses invariant info (DateTimeFormatInfo.InvariantInfo)
            return dateTime.ToUniversalTime().ToString("r", CultureInfo.InvariantCulture);
        }

        public static bool TryParseDate(string input, out DateTimeOffset result)
        {
            return DateTimeOffset.TryParseExact(input, dateFormats, DateTimeFormatInfo.InvariantInfo,
                                                DateTimeStyles.AllowWhiteSpaces | DateTimeStyles.AssumeUniversal,
                                                out result);
        }

        /// <summary>
        /// Parses valid integer strings with no leading signs, whitespace or other <see cref="NumberStyles"/>
        /// </summary>
        /// <param name="value">The value to parse</param>
        /// <param name="result">The result</param>
        /// <returns>True if value was valid; false otherwise.</returns>
        public static bool TryParseInt32(string value, out int result)
        {
            return Int32.TryParse(value, NumberStyles.None, NumberFormatInfo.InvariantInfo, out result);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Net.Http.Headers", Justification = "We follow the layout of System.Net.Http.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Net.Http.Handlers", Justification = "Handlers provide an extensibility hook which we want to keep in a separate namespace.")]
// Some resources are specific to the netstandard1.3 assembly
[assembly: SuppressMessage("Microsoft.Web.FxCop", "MW1000:UnusedResourceUsageRule", Justification = "There are a few unused resources due to missing netstandard1.3 features.")]


================================================
FILE: src/System.Net.Http.Formatting/Handlers/HttpProgressEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;

namespace System.Net.Http.Handlers
{
    /// <summary>
    /// Provides data for the events generated by <see cref="ProgressMessageHandler"/>.
    /// </summary>
    public class HttpProgressEventArgs : ProgressChangedEventArgs
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpProgressEventArgs"/> with the parameters given.
        /// </summary>
        /// <param name="progressPercentage">The percent completed of the overall exchange.</param>
        /// <param name="userToken">Any user state provided as part of reading or writing the data.</param>
        /// <param name="bytesTransferred">The current number of bytes either received or sent.</param>
        /// <param name="totalBytes">The total number of bytes expected to be received or sent.</param>
        public HttpProgressEventArgs(int progressPercentage, object userToken, long bytesTransferred, long? totalBytes)
            : base(progressPercentage, userToken)
        {
            BytesTransferred = bytesTransferred;
            TotalBytes = totalBytes;
        }

        /// <summary>
        /// Gets the current number of bytes transferred.
        /// </summary>
        public long BytesTransferred { get; private set; }

        /// <summary>
        /// Gets the total number of expected bytes to be sent or received. If the number is not known then this is null.
        /// </summary>
        public long? TotalBytes { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Handlers/ProgressContent.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.IO;
using System.Threading.Tasks;

namespace System.Net.Http.Handlers
{
    /// <summary>
    /// Wraps an inner <see cref="HttpContent"/> in order to insert a <see cref="ProgressStream"/> on writing data.
    /// </summary>
    internal class ProgressContent : HttpContent
    {
        private readonly HttpContent _innerContent;
        private readonly ProgressMessageHandler _handler;
        private readonly HttpRequestMessage _request;

        public ProgressContent(HttpContent innerContent, ProgressMessageHandler handler, HttpRequestMessage request)
        {
            Contract.Assert(innerContent != null);
            Contract.Assert(handler != null);
            Contract.Assert(request != null);

            _innerContent = innerContent;
            _handler = handler;
            _request = request;

            innerContent.Headers.CopyTo(Headers);
        }

        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
        {
            ProgressStream progressStream = new ProgressStream(stream, _handler, _request, response: null);
            return _innerContent.CopyToAsync(progressStream);
        }

        protected override bool TryComputeLength(out long length)
        {
            long? contentLength = _innerContent.Headers.ContentLength;
            if (contentLength.HasValue)
            {
                length = contentLength.Value;
                return true;
            }

            length = -1;
            return false;
        }

        protected override void Dispose(bool disposing)
        {
            base.Dispose(disposing);
            if (disposing)
            {
                _innerContent.Dispose();
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Handlers/ProgressMessageHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Threading;
using System.Threading.Tasks;

namespace System.Net.Http.Handlers
{
    /// <summary>
    /// The <see cref="ProgressMessageHandler"/> provides a mechanism for getting progress event notifications
    /// when sending and receiving data in connection with exchanging HTTP requests and responses.
    /// Register event handlers for the events <see cref="HttpSendProgress"/> and <see cref="HttpReceiveProgress"/>
    /// to see events for data being sent and received.
    /// </summary>
    public class ProgressMessageHandler : DelegatingHandler
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ProgressMessageHandler"/> class.
        /// </summary>
        public ProgressMessageHandler()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ProgressMessageHandler"/> class.
        /// </summary>
        /// <param name="innerHandler">The inner handler to which this handler submits requests.</param>
        public ProgressMessageHandler(HttpMessageHandler innerHandler)
            : base(innerHandler)
        {
        }

        /// <summary>
        /// Occurs every time the client sending data is making progress.
        /// </summary>
        public event EventHandler<HttpProgressEventArgs> HttpSendProgress;

        /// <summary>
        /// Occurs every time the client receiving data is making progress.
        /// </summary>
        public event EventHandler<HttpProgressEventArgs> HttpReceiveProgress;

        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            AddRequestProgress(request);
            HttpResponseMessage response = await base.SendAsync(request, cancellationToken);

            if (HttpReceiveProgress != null && response != null && response.Content != null)
            {
                cancellationToken.ThrowIfCancellationRequested();
                await AddResponseProgressAsync(request, response);
            }

            return response;
        }

        /// <summary>
        /// Raises the <see cref="HttpSendProgress"/> event.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="e">The <see cref="HttpProgressEventArgs"/> instance containing the event data.</param>
        protected internal virtual void OnHttpRequestProgress(HttpRequestMessage request, HttpProgressEventArgs e)
        {
            if (HttpSendProgress != null)
            {
                HttpSendProgress(request, e);
            }
        }

        /// <summary>
        /// Raises the <see cref="HttpReceiveProgress"/> event.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="e">The <see cref="HttpProgressEventArgs"/> instance containing the event data.</param>
        protected internal virtual void OnHttpResponseProgress(HttpRequestMessage request, HttpProgressEventArgs e)
        {
            if (HttpReceiveProgress != null)
            {
                HttpReceiveProgress(request, e);
            }
        }

        private void AddRequestProgress(HttpRequestMessage request)
        {
            if (HttpSendProgress != null && request != null && request.Content != null)
            {
                HttpContent progressContent = new ProgressContent(request.Content, this, request);
                request.Content = progressContent;
            }
        }

        private async Task<HttpResponseMessage> AddResponseProgressAsync(HttpRequestMessage request, HttpResponseMessage response)
        {
            Stream stream = await response.Content.ReadAsStreamAsync();
            ProgressStream progressStream = new ProgressStream(stream, this, request, response);
            HttpContent progressContent = new StreamContent(progressStream);
            response.Content.Headers.CopyTo(progressContent.Headers);
            response.Content = progressContent;
            return response;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Handlers/ProgressStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Internal;
using System.Threading;
using System.Threading.Tasks;

namespace System.Net.Http.Handlers
{
    /// <summary>
    /// This implementation of <see cref="DelegatingStream"/> registers how much data has been
    /// read (received) versus written (sent) for a particular HTTP operation. The implementation
    /// is client side in that the total bytes to send is taken from the request and the total
    /// bytes to read is taken from the response. In a server side scenario, it would be the
    /// other way around (reading the request and writing the response).
    /// </summary>
    internal class ProgressStream : DelegatingStream
    {
        private readonly ProgressMessageHandler _handler;
        private readonly HttpRequestMessage _request;

        private long _bytesReceived;
        private long? _totalBytesToReceive;

        private long _bytesSent;
        private long? _totalBytesToSend;

        public ProgressStream(Stream innerStream, ProgressMessageHandler handler, HttpRequestMessage request, HttpResponseMessage response)
            : base(innerStream)
        {
            Contract.Assert(handler != null);
            Contract.Assert(request != null);

            if (request.Content != null)
            {
                _totalBytesToSend = request.Content.Headers.ContentLength;
            }

            if (response != null && response.Content != null)
            {
                _totalBytesToReceive = response.Content.Headers.ContentLength;
            }

            _handler = handler;
            _request = request;
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            int bytesRead = InnerStream.Read(buffer, offset, count);
            ReportBytesReceived(bytesRead, userState: null);
            return bytesRead;
        }

        public override int ReadByte()
        {
            int byteRead = InnerStream.ReadByte();
            ReportBytesReceived(byteRead == -1 ? 0 : 1, userState: null);
            return byteRead;
        }

        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            int readCount = await InnerStream.ReadAsync(buffer, offset, count, cancellationToken);
            ReportBytesReceived(readCount, userState: null);
            return readCount;
        }

#if !NETSTANDARD1_3 // BeginX and EndX are not supported on Streams in netstandard1.3
        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            return InnerStream.BeginRead(buffer, offset, count, callback, state);
        }

        public override int EndRead(IAsyncResult asyncResult)
        {
            int bytesRead = InnerStream.EndRead(asyncResult);
            ReportBytesReceived(bytesRead, asyncResult.AsyncState);
            return bytesRead;
        }
#endif

        public override void Write(byte[] buffer, int offset, int count)
        {
            InnerStream.Write(buffer, offset, count);
            ReportBytesSent(count, userState: null);
        }

        public override void WriteByte(byte value)
        {
            InnerStream.WriteByte(value);
            ReportBytesSent(1, userState: null);
        }

       public override async Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            await InnerStream.WriteAsync(buffer, offset, count, cancellationToken);
            ReportBytesSent(count, userState: null);
        }

#if !NETSTANDARD1_3 // BeginX and EndX are not supported on Streams in netstandard1.3
        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            return new ProgressWriteAsyncResult(InnerStream, this, buffer, offset, count, callback, state);
        }

        public override void EndWrite(IAsyncResult asyncResult)
        {
            ProgressWriteAsyncResult.End(asyncResult);
        }
#endif

        internal void ReportBytesSent(int bytesSent, object userState)
        {
            if (bytesSent > 0)
            {
                _bytesSent += bytesSent;
                int percentage = 0;
                if (_totalBytesToSend.HasValue && _totalBytesToSend != 0)
                {
                    percentage = (int)((100L * _bytesSent) / _totalBytesToSend);
                }

                // We only pass the request as it is guaranteed to be non-null (the response may be null)
                _handler.OnHttpRequestProgress(_request, new HttpProgressEventArgs(percentage, userState, _bytesSent, _totalBytesToSend));
            }
        }

        private void ReportBytesReceived(int bytesReceived, object userState)
        {
            if (bytesReceived > 0)
            {
                _bytesReceived += bytesReceived;
                int percentage = 0;
                if (_totalBytesToReceive.HasValue && _totalBytesToReceive != 0)
                {
                    percentage = (int)((100L * _bytesReceived) / _totalBytesToReceive);
                }

                // We only pass the request as it is guaranteed to be non-null (the response may be null)
                _handler.OnHttpResponseProgress(_request, new HttpProgressEventArgs(percentage, userState, _bytesReceived, _totalBytesToReceive));
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Handlers/ProgressWriteAsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Internal;

namespace System.Net.Http.Handlers
{
    internal class ProgressWriteAsyncResult : AsyncResult
    {
        private static readonly AsyncCallback _writeCompletedCallback = WriteCompletedCallback;

        private readonly Stream _innerStream;
        private readonly ProgressStream _progressStream;
        private readonly int _count;

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is handled as part of IAsyncResult completion.")]
        public ProgressWriteAsyncResult(Stream innerStream, ProgressStream progressStream, byte[] buffer, int offset, int count, AsyncCallback callback, object state)
            : base(callback, state)
        {
            Contract.Assert(innerStream != null);
            Contract.Assert(progressStream != null);
            Contract.Assert(buffer != null);

            _innerStream = innerStream;
            _progressStream = progressStream;
            _count = count;

            try
            {
                IAsyncResult result = innerStream.BeginWrite(buffer, offset, count, _writeCompletedCallback, this);
                if (result.CompletedSynchronously)
                {
                    WriteCompleted(result);
                }
            }
            catch (Exception e)
            {
                Complete(true, e);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is handled as part of IAsyncResult completion.")]
        private static void WriteCompletedCallback(IAsyncResult result)
        {
            if (result.CompletedSynchronously)
            {
                return;
            }

            ProgressWriteAsyncResult thisPtr = (ProgressWriteAsyncResult)result.AsyncState;
            try
            {
                thisPtr.WriteCompleted(result);
            }
            catch (Exception e)
            {
                thisPtr.Complete(false, e);
            }
        }

        private void WriteCompleted(IAsyncResult result)
        {
            _innerStream.EndWrite(result);
            _progressStream.ReportBytesSent(_count, AsyncState);
            Complete(result.CompletedSynchronously);
        }

        public static void End(IAsyncResult result)
        {
            AsyncResult.End<ProgressWriteAsyncResult>(result);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Headers/CookieHeaderValue.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Net.Http.Formatting;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Headers
{
    public class CookieHeaderValue : ICloneable
    {
        private const string ExpiresToken = "expires";
        private const string MaxAgeToken = "max-age";
        private const string DomainToken = "domain";
        private const string PathToken = "path";
        private const string SecureToken = "secure";
        private const string HttpOnlyToken = "httponly";
        private const string DefaultPath = "/";

        private static readonly char[] segmentSeparator = new char[] { ';' };
        private static readonly char[] nameValueSeparator = new char[] { '=' };

        // Use list instead of dictionary since we may have multiple parameters with the same name.
        private Collection<CookieState> _cookies;

        public CookieHeaderValue(string name, string value)
        {
            CookieState cookie = new CookieState(name, value);
            Cookies.Add(cookie);
        }

        public CookieHeaderValue(string name, NameValueCollection values)
        {
            CookieState cookie = new CookieState(name, values);
            Cookies.Add(cookie);
        }

        /// <summary>
        /// Constructor to be used by parser to create a new instance of this type.
        /// </summary>
        protected CookieHeaderValue()
        {
        }

        private CookieHeaderValue(CookieHeaderValue source)
        {
            if (source == null)
            {
                throw Error.ArgumentNull("source");
            }

            Expires = source.Expires;
            MaxAge = source.MaxAge;
            Domain = source.Domain;
            Path = source.Path;
            Secure = source.Secure;
            HttpOnly = source.HttpOnly;

            foreach (CookieState cookie in source.Cookies)
            {
                Cookies.Add(cookie.Clone<CookieState>());
            }
        }

        public Collection<CookieState> Cookies
        {
            get
            {
                if (_cookies == null)
                {
                    _cookies = new Collection<CookieState>();
                }
                return _cookies;
            }
        }

        public DateTimeOffset? Expires { get; set; }

        public TimeSpan? MaxAge { get; set; }

        public string Domain { get; set; }

        public string Path { get; set; }

        public bool Secure { get; set; }

        public bool HttpOnly { get; set; }

        public CookieState this[string name]
        {
            get
            {
                if (String.IsNullOrEmpty(name))
                {
                    return null;
                }

                CookieState cookie = Cookies.FirstOrDefault(c => String.Equals(c.Name, name, StringComparison.OrdinalIgnoreCase));
                if (cookie == null)
                {
                    cookie = new CookieState(name, String.Empty);
                    Cookies.Add(cookie);
                }
                return cookie;
            }
        }

        public override string ToString()
        {
            StringBuilder header = new StringBuilder();
            bool first = true;

            foreach (CookieState cookie in Cookies)
            {
                first = AppendSegment(header, first, cookie.ToString(), null);
            }

            if (Expires.HasValue)
            {
                first = AppendSegment(header, first, ExpiresToken, FormattingUtilities.DateToString(Expires.Value));
            }

            if (MaxAge.HasValue)
            {
                first = AppendSegment(header, first, MaxAgeToken, ((int)MaxAge.Value.TotalSeconds).ToString(NumberFormatInfo.InvariantInfo));
            }

            if (Domain != null)
            {
                first = AppendSegment(header, first, DomainToken, Domain);
            }

            if (Path != null)
            {
                first = AppendSegment(header, first, PathToken, Path);
            }

            if (Secure)
            {
                first = AppendSegment(header, first, SecureToken, null);
            }

            if (HttpOnly)
            {
                first = AppendSegment(header, first, HttpOnlyToken, null);
            }

            return header.ToString();
        }

        public object Clone()
        {
            return new CookieHeaderValue(this);
        }

        public static bool TryParse(string input, out CookieHeaderValue parsedValue)
        {
            parsedValue = null;
            if (!String.IsNullOrEmpty(input))
            {
                string[] segments = input.Split(segmentSeparator);
                CookieHeaderValue instance = new CookieHeaderValue();
                foreach (string segment in segments)
                {
                    if (!ParseCookieSegment(instance, segment))
                    {
                        return false;
                    }
                }

                // If we didn't find any cookie state name/value pairs then cookie is not valid
                if (instance.Cookies.Count == 0)
                {
                    return false;
                }

                parsedValue = instance;
                return true;
            }

            return false;
        }

        private static bool AppendSegment(StringBuilder builder, bool first, string name, string value)
        {
            if (first)
            {
                first = false;
            }
            else
            {
                builder.Append("; ");
            }

            builder.Append(name);
            if (value != null)
            {
                builder.Append("=");
                builder.Append(value);
            }
            return first;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This is a try method where we do want to ignore errors.")]
        private static bool ParseCookieSegment(CookieHeaderValue instance, string segment)
        {
            if (String.IsNullOrWhiteSpace(segment))
            {
                return true;
            }

            string[] nameValue = segment.Split(nameValueSeparator, 2);
            if (nameValue.Length < 1 || String.IsNullOrWhiteSpace(nameValue[0]))
            {
                return false;
            }

            string name = nameValue[0].Trim();
            if (String.Equals(name, ExpiresToken, StringComparison.OrdinalIgnoreCase))
            {
                string value = GetSegmentValue(nameValue, null);
                DateTimeOffset expires;
                if (FormattingUtilities.TryParseDate(value, out expires))
                {
                    instance.Expires = expires;
                    return true;
                }
                return false;
            }
            else if (String.Equals(name, MaxAgeToken, StringComparison.OrdinalIgnoreCase))
            {
                string value = GetSegmentValue(nameValue, null);
                int maxAge;
                if (FormattingUtilities.TryParseInt32(value, out maxAge))
                {
                    instance.MaxAge = new TimeSpan(0, 0, maxAge);
                    return true;
                }
                return false;
            }
            else if (String.Equals(name, DomainToken, StringComparison.OrdinalIgnoreCase))
            {
                instance.Domain = GetSegmentValue(nameValue, null);
                return true;
            }
            else if (String.Equals(name, PathToken, StringComparison.OrdinalIgnoreCase))
            {
                instance.Path = GetSegmentValue(nameValue, DefaultPath);
                return true;
            }
            else if (String.Equals(name, SecureToken, StringComparison.OrdinalIgnoreCase))
            {
                string value = GetSegmentValue(nameValue, null);
                if (!String.IsNullOrWhiteSpace(value))
                {
                    return false;
                }
                instance.Secure = true;
                return true;
            }
            else if (String.Equals(name, HttpOnlyToken, StringComparison.OrdinalIgnoreCase))
            {
                string value = GetSegmentValue(nameValue, null);
                if (!String.IsNullOrWhiteSpace(value))
                {
                    return false;
                }
                instance.HttpOnly = true;
                return true;
            }
            else
            {
                string value = GetSegmentValue(nameValue, null);

                // We read the cookie segment as form data
                try
                {
                    FormDataCollection formData = new FormDataCollection(value);
                    NameValueCollection values = formData.ReadAsNameValueCollection();
                    CookieState cookie = new CookieState(name, values);
                    instance.Cookies.Add(cookie);
                    return true;
                }
                catch
                {
                    return false;
                }
            }
        }

        private static string GetSegmentValue(string[] nameValuePair, string defaultValue)
        {
            Contract.Assert(nameValuePair != null);
            return nameValuePair.Length > 1 ? FormattingUtilities.UnquoteToken(nameValuePair[1]) : defaultValue;
        }
    }
}

================================================
FILE: src/System.Net.Http.Formatting/Headers/CookieState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Diagnostics.Contracts;
using System.Net.Http.Formatting.Internal;
using System.Web.Http;

namespace System.Net.Http.Headers
{
    public class CookieState : ICloneable
    {
        private string _name;
        private NameValueCollection _values = HttpValueCollection.Create();

        public CookieState(string name)
            : this(name, String.Empty)
        {
        }

        public CookieState(string name, string value)
        {
            CheckNameFormat(name, "name");
            _name = name;

            CheckValueFormat(value, "value");
            Value = value;
        }

        public CookieState(string name, NameValueCollection values)
        {
            CheckNameFormat(name, "name");
            _name = name;

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }
            Values.Add(values);
        }

        private CookieState(CookieState source)
        {
            Contract.Requires(source != null);

            _name = source._name;
            if (source._values != null)
            {
                Values.Add(source._values);
            }
        }

        public string Name
        {
            get { return _name; }
            set
            {
                CheckNameFormat(value, "value");
                _name = value;
            }
        }

        /// <summary>
        /// If the cookie data is a simple string value then set or retrieve it using the <see cref="Value"/> property.
        /// If the cookie data is structured then use the <see cref="Values"/> property.
        /// </summary>
        public string Value
        {
            get
            {
                return Values.Count > 0 ? Values.AllKeys[0] : String.Empty;
            }

            set
            {
                CheckValueFormat(value, "value");
                if (Values.Count > 0)
                {
                    Values.AllKeys[0] = value;
                }
                else
                {
                    Values.Add(value, String.Empty);
                }
            }
        }

        /// <summary>
        /// If the cookie data is structured then use the <see cref="Values"/> property for setting and getting individual sub-name/value pairs.
        /// If the cookie data is a simple string value then set or retrieve it using the <see cref="Value"/> property.
        /// </summary>
        public NameValueCollection Values
        {
            get { return _values; }
        }

        public string this[string subName]
        {
            get { return Values[subName]; }
            set { Values[subName] = value; }
        }

        public override string ToString()
        {
            return _name + "=" + (_values != null ? _values.ToString() : String.Empty);
        }

        public object Clone()
        {
            return new CookieState(this);
        }

        private static void CheckNameFormat(string name, string parameterName)
        {
            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            if (!FormattingUtilities.ValidateHeaderToken(name))
            {
                throw Error.Argument(parameterName, Properties.Resources.CookieInvalidName);
            }
        }

        private static void CheckValueFormat(string value, string parameterName)
        {
            // Empty string is a valid cookie value
            if (value == null)
            {
                throw Error.ArgumentNull(parameterName);
            }
        }
    }
}

================================================
FILE: src/System.Net.Http.Formatting/HttpClientExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Extension methods that aid in making formatted requests using <see cref="HttpClient"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpClientExtensions
    {
        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsJsonAsync<T>(this HttpClient client, string requestUri, T value)
        {
            return client.PostAsJsonAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsJsonAsync<T>(this HttpClient client, string requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, new JsonMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsJsonAsync<T>(this HttpClient client, Uri requestUri, T value)
        {
            return client.PostAsJsonAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsJsonAsync<T>(this HttpClient client, Uri requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, new JsonMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsXmlAsync<T>(this HttpClient client, string requestUri, T value)
        {
            return client.PostAsXmlAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsXmlAsync<T>(this HttpClient client, string requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, new XmlMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsXmlAsync<T>(this HttpClient client, Uri requestUri, T value)
        {
            return client.PostAsXmlAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsXmlAsync<T>(this HttpClient client, Uri requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, new XmlMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PostAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter)
        {
            return client.PostAsync(requestUri, value, formatter, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PostAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, formatter, mediaType: (MediaTypeHeaderValue)null, cancellationToken: cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PostAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, string mediaType)
        {
            return client.PostAsync(requestUri, value, formatter, mediaType, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, string mediaType, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, formatter, ObjectContent.BuildHeaderValue(mediaType), cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The caller is responsible for disposing the object")]
        [SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "The called method will convert to Uri instance.")]
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, CancellationToken cancellationToken)
        {
            if (client == null)
            {
                throw Error.ArgumentNull("client");
            }

            var content = new ObjectContent<T>(value, formatter, mediaType);

            return client.PostAsync(requestUri, content, cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PostAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter)
        {
            return client.PostAsync(requestUri, value, formatter, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PostAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, formatter, mediaType: (MediaTypeHeaderValue)null, cancellationToken: cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PostAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, string mediaType)
        {
            return client.PostAsync(requestUri, value, formatter, mediaType, CancellationToken.None);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, string mediaType, CancellationToken cancellationToken)
        {
            return client.PostAsync(requestUri, value, formatter, ObjectContent.BuildHeaderValue(mediaType), cancellationToken);
        }

        /// <summary>
        /// Sends a POST request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The caller is responsible for disposing the object")]
        public static Task<HttpResponseMessage> PostAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, CancellationToken cancellationToken)
        {
            if (client == null)
            {
                throw Error.ArgumentNull("client");
            }

            var content = new ObjectContent<T>(value, formatter, mediaType);

            return client.PostAsync(requestUri, content, cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsJsonAsync<T>(this HttpClient client, string requestUri, T value)
        {
            return client.PutAsJsonAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsJsonAsync<T>(this HttpClient client, string requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, new JsonMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsJsonAsync<T>(this HttpClient client, Uri requestUri, T value)
        {
            return client.PutAsJsonAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as JSON.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="JsonMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsJsonAsync<T>(this HttpClient client, Uri requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, new JsonMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses a default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsXmlAsync<T>(this HttpClient client, string requestUri, T value)
        {
            return client.PutAsXmlAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsXmlAsync<T>(this HttpClient client, string requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, new XmlMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsXmlAsync<T>(this HttpClient client, Uri requestUri, T value)
        {
            return client.PutAsXmlAsync(requestUri, value, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with the given <paramref name="value"/> serialized
        /// as XML.
        /// </summary>
        /// <remarks>
        /// This method uses the default instance of <see cref="XmlMediaTypeFormatter"/>.
        /// </remarks>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsXmlAsync<T>(this HttpClient client, Uri requestUri, T value, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, new XmlMediaTypeFormatter(), cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PutAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter)
        {
            return client.PutAsync(requestUri, value, formatter, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PutAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, formatter, mediaType: (MediaTypeHeaderValue)null, cancellationToken: cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PutAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, string mediaType)
        {
            return client.PutAsync(requestUri, value, formatter, mediaType, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, string mediaType, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, formatter, ObjectContent.BuildHeaderValue(mediaType), cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "We want to support URIs as strings")]
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The caller is responsible for disposing the object")]
        [SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "The called method will convert to Uri instance.")]
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, string requestUri, T value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, CancellationToken cancellationToken)
        {
            if (client == null)
            {
                throw Error.ArgumentNull("client");
            }

            var content = new ObjectContent<T>(value, formatter, mediaType);

            return client.PutAsync(requestUri, content, cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PutAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter)
        {
            return client.PutAsync(requestUri, value, formatter, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PutAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, formatter, mediaType: (MediaTypeHeaderValue)null, cancellationToken: cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <seealso cref="PutAsync{T}(HttpClient, string, T, MediaTypeFormatter, string, CancellationToken)"/>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, string mediaType)
        {
            return client.PutAsync(requestUri, value, formatter, mediaType, CancellationToken.None);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, string mediaType, CancellationToken cancellationToken)
        {
            return client.PutAsync(requestUri, value, formatter, ObjectContent.BuildHeaderValue(mediaType), cancellationToken);
        }

        /// <summary>
        /// Sends a PUT request as an asynchronous operation to the specified Uri with <paramref name="value"/>
        /// serialized using the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of <paramref name="value"/>.</typeparam>
        /// <param name="client">The client used to make the request.</param>
        /// <param name="requestUri">The Uri the request is sent to.</param>
        /// <param name="value">The value that will be placed in the request's entity body.</param>
        /// <param name="formatter">The formatter used to serialize the <paramref name="value"/>.</param>
        /// <param name="mediaType">The authoritative value of the request's content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing the asynchronous operation.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The caller is responsible for disposing the object")]
        public static Task<HttpResponseMessage> PutAsync<T>(this HttpClient client, Uri requestUri, T value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, CancellationToken cancellationToken)
        {
            if (client == null)
            {
                throw Error.ArgumentNull("client");
            }

            var content = new ObjectContent<T>(value, formatter, mediaType);

            return client.PutAsync(requestUri, content, cancellationToken);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpClientFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http;

namespace System.Net.Http
{
    public static class HttpClientFactory
    {
        /// <summary>
        /// Creates a new <see cref="HttpClient"/> instance configured with the handlers provided and with an
        /// <see cref="HttpClientHandler"/> as the innermost handler.
        /// </summary>
        /// <param name="handlers">An ordered list of <see cref="DelegatingHandler"/> instances to be invoked as an 
        /// <see cref="HttpRequestMessage"/> travels from the <see cref="HttpClient"/> to the network and an 
        /// <see cref="HttpResponseMessage"/> travels from the network back to <see cref="HttpClient"/>.
        /// The handlers are invoked in a top-down fashion. That is, the first entry is invoked first for 
        /// an outbound request message but last for an inbound response message.</param>
        /// <returns>An <see cref="HttpClient"/> instance with the configured handlers.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Handler is disposed with HttpClient")]
        public static HttpClient Create(params DelegatingHandler[] handlers)
        {
            return Create(new HttpClientHandler(), handlers);
        }

        /// <summary>
        /// Creates a new <see cref="HttpClient"/> instance configured with the handlers provided and with the
        /// provided <paramref name="innerHandler"/> as the innermost handler.
        /// </summary>
        /// <param name="innerHandler">The inner handler represents the destination of the HTTP message channel.</param>
        /// <param name="handlers">An ordered list of <see cref="DelegatingHandler"/> instances to be invoked as an 
        /// <see cref="HttpRequestMessage"/> travels from the <see cref="HttpClient"/> to the network and an 
        /// <see cref="HttpResponseMessage"/> travels from the network back to <see cref="HttpClient"/>.
        /// The handlers are invoked in a top-down fashion. That is, the first entry is invoked first for 
        /// an outbound request message but last for an inbound response message.</param>
        /// <returns>An <see cref="HttpClient"/> instance with the configured handlers.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Handler is disposed with HttpClient")]
        public static HttpClient Create(HttpMessageHandler innerHandler, params DelegatingHandler[] handlers)
        {
            HttpMessageHandler pipeline = CreatePipeline(innerHandler, handlers);
            return new HttpClient(pipeline);
        }

        /// <summary>
        /// Creates an instance of an <see cref="HttpMessageHandler"/> using the <see cref="DelegatingHandler"/> instances
        /// provided by <paramref name="handlers"/>. The resulting pipeline can be used to manually create <see cref="HttpClient"/>
        /// or <see cref="HttpMessageInvoker"/> instances with customized message handlers.
        /// </summary>
        /// <param name="innerHandler">The inner handler represents the destination of the HTTP message channel.</param>
        /// <param name="handlers">An ordered list of <see cref="DelegatingHandler"/> instances to be invoked as part 
        /// of sending an <see cref="HttpRequestMessage"/> and receiving an <see cref="HttpResponseMessage"/>.
        /// The handlers are invoked in a top-down fashion. That is, the first entry is invoked first for 
        /// an outbound request message but last for an inbound response message.</param>
        /// <returns>The HTTP message channel.</returns>
        public static HttpMessageHandler CreatePipeline(HttpMessageHandler innerHandler, IEnumerable<DelegatingHandler> handlers)
        {
            if (innerHandler == null)
            {
                throw Error.ArgumentNull("innerHandler");
            }

            if (handlers == null)
            {
                return innerHandler;
            }

            // Wire handlers up in reverse order starting with the inner handler
            HttpMessageHandler pipeline = innerHandler;
            IEnumerable<DelegatingHandler> reversedHandlers = handlers.Reverse();
            foreach (DelegatingHandler handler in reversedHandlers)
            {
                if (handler == null)
                {
                    throw Error.Argument("handlers", Properties.Resources.DelegatingHandlerArrayContainsNullItem, typeof(DelegatingHandler).Name);
                }

                if (handler.InnerHandler != null)
                {
                    throw Error.Argument("handlers", Properties.Resources.DelegatingHandlerArrayHasNonNullInnerHandler, typeof(DelegatingHandler).Name, "InnerHandler", handler.GetType().Name);
                }

                handler.InnerHandler = pipeline;
                pipeline = handler;
            }

            return pipeline;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpContentExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Extension methods to allow strongly typed objects to be read from <see cref="HttpContent"/> instances.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpContentExtensions
    {
        private static MediaTypeFormatterCollection _defaultMediaTypeFormatterCollection = null;

        // Using the JsonMediaTypeFormatter for the first time is rather expensive (due to reflection cost
        // when creating the default contract resolver). Hence we new up a static collection, such
        // that the second call is much faster.
        private static MediaTypeFormatterCollection DefaultMediaTypeFormatterCollection
        {
            get
            {
                if (_defaultMediaTypeFormatterCollection == null)
                {
                    _defaultMediaTypeFormatterCollection = new MediaTypeFormatterCollection();
                }

                return _defaultMediaTypeFormatterCollection;
            }
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified <paramref name="type"/>
        /// from the <paramref name="content"/> instance.
        /// </summary>
        /// <remarks>This override use the built-in collection of formatters.</remarks>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="type">The type of the object to read.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<object> ReadAsAsync(this HttpContent content, Type type)
        {
            return content.ReadAsAsync(type, DefaultMediaTypeFormatterCollection);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified <paramref name="type"/>
        /// from the <paramref name="content"/> instance.
        /// </summary>
        /// <remarks>This override use the built-in collection of formatters.</remarks>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="type">The type of the object to read.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<object> ReadAsAsync(this HttpContent content, Type type, CancellationToken cancellationToken)
        {
            return content.ReadAsAsync(type, DefaultMediaTypeFormatterCollection, cancellationToken);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified <paramref name="type"/>
        /// from the <paramref name="content"/> instance using one of the provided <paramref name="formatters"/>
        /// to deserialize the content.
        /// </summary>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="type">The type of the object to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<object> ReadAsAsync(this HttpContent content, Type type, IEnumerable<MediaTypeFormatter> formatters)
        {
            return ReadAsAsync<object>(content, type, formatters, null);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified <paramref name="type"/>
        /// from the <paramref name="content"/> instance using one of the provided <paramref name="formatters"/>
        /// to deserialize the content.
        /// </summary>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="type">The type of the object to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<object> ReadAsAsync(this HttpContent content, Type type, IEnumerable<MediaTypeFormatter> formatters,
            CancellationToken cancellationToken)
        {
            return ReadAsAsync<object>(content, type, formatters, null, cancellationToken);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified <paramref name="type"/>
        /// from the <paramref name="content"/> instance using one of the provided <paramref name="formatters"/>
        /// to deserialize the content.
        /// </summary>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="type">The type of the object to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<object> ReadAsAsync(this HttpContent content, Type type, IEnumerable<MediaTypeFormatter> formatters,
            IFormatterLogger formatterLogger)
        {
            return ReadAsAsync<object>(content, type, formatters, formatterLogger);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified <paramref name="type"/>
        /// from the <paramref name="content"/> instance using one of the provided <paramref name="formatters"/>
        /// to deserialize the content.
        /// </summary>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="type">The type of the object to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<object> ReadAsAsync(this HttpContent content, Type type, IEnumerable<MediaTypeFormatter> formatters,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return ReadAsAsync<object>(content, type, formatters, formatterLogger, cancellationToken);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified
        /// type <typeparamref name="T"/> from the <paramref name="content"/> instance.
        /// </summary>
        /// <remarks>This override use the built-in collection of formatters.</remarks>
        /// <typeparam name="T">The type of the object to read.</typeparam>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<T> ReadAsAsync<T>(this HttpContent content)
        {
            return content.ReadAsAsync<T>(DefaultMediaTypeFormatterCollection);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified
        /// type <typeparamref name="T"/> from the <paramref name="content"/> instance.
        /// </summary>
        /// <remarks>This override use the built-in collection of formatters.</remarks>
        /// <typeparam name="T">The type of the object to read.</typeparam>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<T> ReadAsAsync<T>(this HttpContent content, CancellationToken cancellationToken)
        {
            return content.ReadAsAsync<T>(DefaultMediaTypeFormatterCollection, cancellationToken);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified
        /// type <typeparamref name="T"/> from the <paramref name="content"/> instance.
        /// </summary>
        /// <typeparam name="T">The type of the object to read.</typeparam>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<T> ReadAsAsync<T>(this HttpContent content, IEnumerable<MediaTypeFormatter> formatters)
        {
            return ReadAsAsync<T>(content, typeof(T), formatters, null);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified
        /// type <typeparamref name="T"/> from the <paramref name="content"/> instance.
        /// </summary>
        /// <typeparam name="T">The type of the object to read.</typeparam>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<T> ReadAsAsync<T>(this HttpContent content, IEnumerable<MediaTypeFormatter> formatters,
            CancellationToken cancellationToken)
        {
            return ReadAsAsync<T>(content, typeof(T), formatters, null, cancellationToken);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified
        /// type <typeparamref name="T"/> from the <paramref name="content"/> instance.
        /// </summary>
        /// <typeparam name="T">The type of the object to read.</typeparam>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<T> ReadAsAsync<T>(this HttpContent content, IEnumerable<MediaTypeFormatter> formatters,
            IFormatterLogger formatterLogger)
        {
            return ReadAsAsync<T>(content, typeof(T), formatters, formatterLogger);
        }

        /// <summary>
        /// Returns a <see cref="Task"/> that will yield an object of the specified
        /// type <typeparamref name="T"/> from the <paramref name="content"/> instance.
        /// </summary>
        /// <typeparam name="T">The type of the object to read.</typeparam>
        /// <param name="content">The <see cref="HttpContent"/> instance from which to read.</param>
        /// <param name="formatters">The collection of <see cref="MediaTypeFormatter"/> instances to use.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an object of the specified type.</returns>
        public static Task<T> ReadAsAsync<T>(this HttpContent content, IEnumerable<MediaTypeFormatter> formatters,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return ReadAsAsync<T>(content, typeof(T), formatters, formatterLogger, cancellationToken);
        }

        private static Task<T> ReadAsAsync<T>(HttpContent content, Type type, IEnumerable<MediaTypeFormatter> formatters,
            IFormatterLogger formatterLogger)
        {
            return ReadAsAsync<T>(content, type, formatters, formatterLogger, CancellationToken.None);
        }

        // There are many helper overloads for ReadAs*(). Provide one worker function to ensure the logic is shared.
        //
        // For loosely typed, T = Object, type = specific class.
        // For strongly typed, T == type.GetType()
        private static Task<T> ReadAsAsync<T>(HttpContent content, Type type, IEnumerable<MediaTypeFormatter> formatters,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (formatters == null)
            {
                throw Error.ArgumentNull("formatters");
            }

            ObjectContent objectContent = content as ObjectContent;
            if (objectContent != null && objectContent.Value != null && type.IsAssignableFrom(objectContent.Value.GetType()))
            {
                return Task.FromResult((T)objectContent.Value);
            }

            MediaTypeFormatter formatter = null;
            // Default to "application/octet-stream" if there is no content-type in accordance with section 7.2.1 of the HTTP spec
            MediaTypeHeaderValue mediaType = content.Headers.ContentType ?? MediaTypeConstants.ApplicationOctetStreamMediaType;

            formatter = new MediaTypeFormatterCollection(formatters).FindReader(type, mediaType);

            if (formatter == null)
            {
                if (content.Headers.ContentLength == 0)
                {
                    T defaultValue = (T)MediaTypeFormatter.GetDefaultValueForType(type);
                    return Task.FromResult<T>(defaultValue);
                }

                throw new UnsupportedMediaTypeException(
                    Error.Format(Properties.Resources.NoReadSerializerAvailable, type.Name, mediaType.MediaType),
                    mediaType);
            }

            return ReadAsAsyncCore<T>(content, type, formatterLogger, formatter, cancellationToken);
        }

        private static async Task<T> ReadAsAsyncCore<T>(HttpContent content, Type type, IFormatterLogger formatterLogger,
            MediaTypeFormatter formatter, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            Stream stream = await content.ReadAsStreamAsync();

            object result = await formatter.ReadFromStreamAsync(type, stream, content, formatterLogger, cancellationToken);
            return (T)result;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpContentFormDataExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.ComponentModel;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Extension methods to allow HTML form URL-encoded data, also known as <c>application/x-www-form-urlencoded</c>,
    /// to be read from <see cref="HttpContent"/> instances.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpContentFormDataExtensions
    {
        private const string ApplicationFormUrlEncoded = "application/x-www-form-urlencoded";

        /// <summary>
        /// Determines whether the specified content is HTML form URL-encoded data, also known as <c>application/x-www-form-urlencoded</c> data.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <returns>
        /// <c>true</c> if the specified content is HTML form URL-encoded data; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsFormData(this HttpContent content)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            MediaTypeHeaderValue contentType = content.Headers.ContentType;
            return contentType != null && String.Equals(ApplicationFormUrlEncoded, contentType.MediaType, StringComparison.OrdinalIgnoreCase);
        }

        /// <summary>
        /// Returns a <see cref="Task{T}"/> that will yield a <see cref="NameValueCollection"/> instance containing the form data
        /// parsed as HTML form URL-encoded from the <paramref name="content"/> instance.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <returns>A <see cref="Task{T}"/> which will provide the result. If the data can not be read
        /// as HTML form URL-encoded data then the result is null.</returns>
        public static Task<NameValueCollection> ReadAsFormDataAsync(this HttpContent content)
        {
            return ReadAsFormDataAsync(content, CancellationToken.None);
        }

        /// <summary>
        /// Returns a <see cref="Task{T}"/> that will yield a <see cref="NameValueCollection"/> instance containing the form data
        /// parsed as HTML form URL-encoded from the <paramref name="content"/> instance.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task{T}"/> which will provide the result. If the data can not be read
        /// as HTML form URL-encoded data then the result is null.</returns>
        public static Task<NameValueCollection> ReadAsFormDataAsync(this HttpContent content, CancellationToken cancellationToken)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            MediaTypeFormatter[] formatters = new MediaTypeFormatter[1] { new FormUrlEncodedMediaTypeFormatter() };
            return ReadAsAsyncCore(content, formatters, cancellationToken);
        }

        private static async Task<NameValueCollection> ReadAsAsyncCore(HttpContent content, MediaTypeFormatter[] formatters,
            CancellationToken cancellationToken)
        {
            FormDataCollection formData = await content.ReadAsAsync<FormDataCollection>(formatters, cancellationToken);
            return formData == null ? null : formData.ReadAsNameValueCollection();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpContentMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.Parsers;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Extension methods to read <see cref="HttpRequestMessage"/> and <see cref="HttpResponseMessage"/> entities from <see cref="HttpContent"/> instances.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpContentMessageExtensions
    {
        private const int MinBufferSize = 256;
        private const int DefaultBufferSize = 32 * 1024;

        /// <summary>
        /// Determines whether the specified content is HTTP request message content.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <returns>
        ///   <c>true</c> if the specified content is HTTP message content; otherwise, <c>false</c>.
        /// </returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception translates to false.")]
        public static bool IsHttpRequestMessageContent(this HttpContent content)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            try
            {
                return HttpMessageContent.ValidateHttpMessageContent(content, true, false);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// Determines whether the specified content is HTTP response message content.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <returns>
        ///   <c>true</c> if the specified content is HTTP message content; otherwise, <c>false</c>.
        /// </returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception translates to false.")]
        public static bool IsHttpResponseMessageContent(this HttpContent content)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            try
            {
                return HttpMessageContent.ValidateHttpMessageContent(content, false, false);
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content)
        {
            return ReadAsHttpRequestMessageAsync(content, "http", DefaultBufferSize);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, CancellationToken cancellationToken)
        {
            return ReadAsHttpRequestMessageAsync(content, "http", DefaultBufferSize, cancellationToken);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="uriScheme">The URI scheme to use for the request URI.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a full URI but only the URI scheme")]
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, string uriScheme)
        {
            return ReadAsHttpRequestMessageAsync(content, uriScheme, DefaultBufferSize);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="uriScheme">The URI scheme to use for the request URI.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a full URI but only the URI scheme")]
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, string uriScheme,
            CancellationToken cancellationToken)
        {
            return ReadAsHttpRequestMessageAsync(content, uriScheme, DefaultBufferSize, cancellationToken);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="uriScheme">The URI scheme to use for the request URI (the
        /// URI scheme is not actually part of the HTTP Request URI and so must be provided externally).</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a full URI but only the URI scheme")]
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, string uriScheme, int bufferSize)
        {
            return ReadAsHttpRequestMessageAsync(content, uriScheme, bufferSize, HttpRequestHeaderParser.DefaultMaxHeaderSize);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="uriScheme">The URI scheme to use for the request URI (the
        /// URI scheme is not actually part of the HTTP Request URI and so must be provided externally).</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a full URI but only the URI scheme")]
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, string uriScheme,
            int bufferSize, CancellationToken cancellationToken)
        {
            return ReadAsHttpRequestMessageAsync(content, uriScheme, bufferSize,
                HttpRequestHeaderParser.DefaultMaxHeaderSize, cancellationToken);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="uriScheme">The URI scheme to use for the request URI (the
        /// URI scheme is not actually part of the HTTP Request URI and so must be provided externally).</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <param name="maxHeaderSize">The max length of the HTTP header.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a full URI but only the URI scheme")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception translates to parser state.")]
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, string uriScheme,
            int bufferSize, int maxHeaderSize)
        {
            return ReadAsHttpRequestMessageAsync(content, uriScheme, bufferSize, maxHeaderSize, CancellationToken.None);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="uriScheme">The URI scheme to use for the request URI (the
        /// URI scheme is not actually part of the HTTP Request URI and so must be provided externally).</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <param name="maxHeaderSize">The max length of the HTTP header.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpRequestMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a full URI but only the URI scheme")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception translates to parser state.")]
        public static Task<HttpRequestMessage> ReadAsHttpRequestMessageAsync(this HttpContent content, string uriScheme,
            int bufferSize, int maxHeaderSize, CancellationToken cancellationToken)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            if (uriScheme == null)
            {
                throw Error.ArgumentNull("uriScheme");
            }

            if (!Uri.CheckSchemeName(uriScheme))
            {
                throw Error.Argument("uriScheme", Properties.Resources.HttpMessageParserInvalidUriScheme, uriScheme, typeof(Uri).Name);
            }

            if (bufferSize < MinBufferSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize);
            }

            if (maxHeaderSize < InternetMessageFormatHeaderParser.MinHeaderSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxHeaderSize", maxHeaderSize, InternetMessageFormatHeaderParser.MinHeaderSize);
            }

            HttpMessageContent.ValidateHttpMessageContent(content, true, true);

            return content.ReadAsHttpRequestMessageAsyncCore(uriScheme, bufferSize, maxHeaderSize, cancellationToken);
        }

        private static async Task<HttpRequestMessage> ReadAsHttpRequestMessageAsyncCore(this HttpContent content,
            string uriScheme, int bufferSize, int maxHeaderSize, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            Stream stream = await content.ReadAsStreamAsync();

            HttpUnsortedRequest httpRequest = new HttpUnsortedRequest();
            HttpRequestHeaderParser parser = new HttpRequestHeaderParser(httpRequest,
                Math.Max(HttpRequestHeaderParser.DefaultMaxRequestLineSize, maxHeaderSize), maxHeaderSize);
            ParserState parseStatus;

            byte[] buffer = new byte[bufferSize];
            int bytesRead = 0;
            int headerConsumed = 0;

            while (true)
            {
                try
                {
                    bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken);
                }
                catch (Exception e)
                {
                    throw new IOException(Properties.Resources.HttpMessageErrorReading, e);
                }

                try
                {
                    parseStatus = parser.ParseBuffer(buffer, bytesRead, ref headerConsumed);
                }
                catch (Exception)
                {
                    parseStatus = ParserState.Invalid;
                }

                if (parseStatus == ParserState.Done)
                {
                    return CreateHttpRequestMessage(uriScheme, httpRequest, stream, bytesRead - headerConsumed);
                }
                else if (parseStatus != ParserState.NeedMoreData)
                {
                    throw Error.InvalidOperation(Properties.Resources.HttpMessageParserError, headerConsumed, buffer);
                }
                else if (bytesRead == 0)
                {
                    throw new IOException(Properties.Resources.ReadAsHttpMessageUnexpectedTermination);
                }
            }
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpResponseMessage"/>.</returns>
        public static Task<HttpResponseMessage> ReadAsHttpResponseMessageAsync(this HttpContent content)
        {
            return ReadAsHttpResponseMessageAsync(content, DefaultBufferSize);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpResponseMessage"/>.</returns>
        public static Task<HttpResponseMessage> ReadAsHttpResponseMessageAsync(this HttpContent content, CancellationToken cancellationToken)
        {
            return ReadAsHttpResponseMessageAsync(content, DefaultBufferSize, cancellationToken);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpResponseMessage"/>.</returns>
        public static Task<HttpResponseMessage> ReadAsHttpResponseMessageAsync(this HttpContent content, int bufferSize)
        {
            return ReadAsHttpResponseMessageAsync(content, bufferSize, HttpResponseHeaderParser.DefaultMaxHeaderSize);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpResponseMessage"/>.</returns>
        public static Task<HttpResponseMessage> ReadAsHttpResponseMessageAsync(this HttpContent content, int bufferSize,
            CancellationToken cancellationToken)
        {
            return ReadAsHttpResponseMessageAsync(content, bufferSize, HttpResponseHeaderParser.DefaultMaxHeaderSize, cancellationToken);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <param name="maxHeaderSize">The max length of the HTTP header.</param>
        /// <returns>A task object representing reading the content as an <see cref="HttpResponseMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception translates to parser state.")]
        public static Task<HttpResponseMessage> ReadAsHttpResponseMessageAsync(this HttpContent content, int bufferSize,
            int maxHeaderSize)
        {
            return ReadAsHttpResponseMessageAsync(content, bufferSize, maxHeaderSize, CancellationToken.None);
        }

        /// <summary>
        /// Read the <see cref="HttpContent"/> as an <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="content">The content to read.</param>
        /// <param name="bufferSize">Size of the buffer.</param>
        /// <param name="maxHeaderSize">The max length of the HTTP header.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>The parsed <see cref="HttpResponseMessage"/> instance.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception translates to parser state.")]
        public static Task<HttpResponseMessage> ReadAsHttpResponseMessageAsync(this HttpContent content, int bufferSize,
            int maxHeaderSize, CancellationToken cancellationToken)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            if (bufferSize < MinBufferSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize);
            }

            if (maxHeaderSize < InternetMessageFormatHeaderParser.MinHeaderSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("maxHeaderSize", maxHeaderSize, InternetMessageFormatHeaderParser.MinHeaderSize);
            }

            HttpMessageContent.ValidateHttpMessageContent(content, false, true);

            return content.ReadAsHttpResponseMessageAsyncCore(bufferSize, maxHeaderSize, cancellationToken);
        }

        private static async Task<HttpResponseMessage> ReadAsHttpResponseMessageAsyncCore(this HttpContent content,
            int bufferSize, int maxHeaderSize, CancellationToken cancellationToken)
        {
            cancellationToken.ThrowIfCancellationRequested();
            Stream stream = await content.ReadAsStreamAsync();

            HttpUnsortedResponse httpResponse = new HttpUnsortedResponse();
            HttpResponseHeaderParser parser = new HttpResponseHeaderParser(httpResponse, HttpResponseHeaderParser.DefaultMaxStatusLineSize, maxHeaderSize);
            ParserState parseStatus;

            byte[] buffer = new byte[bufferSize];
            int bytesRead = 0;
            int headerConsumed = 0;

            while (true)
            {
                try
                {
                    bytesRead = await stream.ReadAsync(buffer, 0, buffer.Length, cancellationToken);
                }
                catch (Exception e)
                {
                    throw new IOException(Properties.Resources.HttpMessageErrorReading, e);
                }

                try
                {
                    parseStatus = parser.ParseBuffer(buffer, bytesRead, ref headerConsumed);
                }
                catch (Exception)
                {
                    parseStatus = ParserState.Invalid;
                }

                if (parseStatus == ParserState.Done)
                {
                    // Create and return parsed HttpResponseMessage
                    return CreateHttpResponseMessage(httpResponse, stream, bytesRead - headerConsumed);
                }
                else if (parseStatus != ParserState.NeedMoreData)
                {
                    throw Error.InvalidOperation(Properties.Resources.HttpMessageParserError, headerConsumed, buffer);
                }
                else if (bytesRead == 0)
                {
                    throw new IOException(Properties.Resources.ReadAsHttpMessageUnexpectedTermination);
                }
            }
        }

        /// <summary>
        /// Creates the request URI by combining scheme (provided) with parsed values of
        /// host and path.
        /// </summary>
        /// <param name="uriScheme">The URI scheme to use for the request URI.</param>
        /// <param name="httpRequest">The unsorted HTTP request.</param>
        /// <returns>A fully qualified request URI.</returns>
        private static Uri CreateRequestUri(string uriScheme, HttpUnsortedRequest httpRequest)
        {
            Contract.Assert(httpRequest != null, "httpRequest cannot be null.");
            Contract.Assert(uriScheme != null, "uriScheme cannot be null");

            IEnumerable<string> hostValues;
            if (httpRequest.HttpHeaders.TryGetValues(FormattingUtilities.HttpHostHeader, out hostValues))
            {
                int hostCount = hostValues.Count();
                if (hostCount != 1)
                {
                    throw Error.InvalidOperation(Properties.Resources.HttpMessageParserInvalidHostCount, FormattingUtilities.HttpHostHeader, hostCount);
                }
            }
            else
            {
                throw Error.InvalidOperation(Properties.Resources.HttpMessageParserInvalidHostCount, FormattingUtilities.HttpHostHeader, 0);
            }

            // We don't use UriBuilder as hostValues.ElementAt(0) contains 'host:port' and UriBuilder needs these split out into separate host and port.
            string requestUri = String.Format(CultureInfo.InvariantCulture, "{0}://{1}{2}", uriScheme, hostValues.ElementAt(0), httpRequest.RequestUri);
            return new Uri(requestUri);
        }

        /// <summary>
        /// Copies the unsorted header fields to a sorted collection.
        /// </summary>
        /// <param name="source">The unsorted source headers</param>
        /// <param name="destination">The destination <see cref="HttpRequestHeaders"/> or <see cref="HttpResponseHeaders"/>.</param>
        /// <param name="contentStream">The input <see cref="Stream"/> used to form any <see cref="HttpContent"/> being part of this HTTP request.</param>
        /// <param name="rewind">Start location of any request entity within the <paramref name="contentStream"/>.</param>
        /// <returns>An <see cref="HttpContent"/> instance if header fields contained and <see cref="HttpContentHeaders"/>.</returns>
        private static HttpContent CreateHeaderFields(HttpHeaders source, HttpHeaders destination, Stream contentStream, int rewind)
        {
            Contract.Assert(source != null, "source headers cannot be null");
            Contract.Assert(destination != null, "destination headers cannot be null");
            Contract.Assert(contentStream != null, "contentStream must be non null");
            HttpContentHeaders contentHeaders = null;
            HttpContent content;

            // Set the header fields
            foreach (KeyValuePair<string, IEnumerable<string>> header in source)
            {
                if (!destination.TryAddWithoutValidation(header.Key, header.Value))
                {
                    if (contentHeaders == null)
                    {
                        contentHeaders = FormattingUtilities.CreateEmptyContentHeaders();
                    }

                    contentHeaders.TryAddWithoutValidation(header.Key, header.Value);
                }
            }

            // If we have content headers then create an HttpContent for this request or response. Otherwise,
            // provide a HttpContent instance to overwrite the null or EmptyContent value.
            if (contentHeaders != null)
            {
                // Need to rewind the input stream to be at the position right after the HTTP header
                // which we may already have parsed as we read the content stream.
                if (!contentStream.CanSeek)
                {
                    throw Error.InvalidOperation(Properties.Resources.HttpMessageContentStreamMustBeSeekable, "ContentReadStream", FormattingUtilities.HttpResponseMessageType.Name);
                }

                contentStream.Seek(0 - rewind, SeekOrigin.Current);
                content = new StreamContent(contentStream);
                contentHeaders.CopyTo(content.Headers);
            }
            else
            {
                content = new StreamContent(Stream.Null);
            }

            return content;
        }

        /// <summary>
        /// Creates an <see cref="HttpRequestMessage"/> based on information provided in <see cref="HttpUnsortedRequest"/>.
        /// </summary>
        /// <param name="uriScheme">The URI scheme to use for the request URI.</param>
        /// <param name="httpRequest">The unsorted HTTP request.</param>
        /// <param name="contentStream">The input <see cref="Stream"/> used to form any <see cref="HttpContent"/> being part of this HTTP request.</param>
        /// <param name="rewind">Start location of any request entity within the <paramref name="contentStream"/>.</param>
        /// <returns>A newly created <see cref="HttpRequestMessage"/> instance.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "caller becomes owner.")]
        private static HttpRequestMessage CreateHttpRequestMessage(string uriScheme, HttpUnsortedRequest httpRequest, Stream contentStream, int rewind)
        {
            Contract.Assert(uriScheme != null, "URI scheme must be non null");
            Contract.Assert(httpRequest != null, "httpRequest must be non null");
            Contract.Assert(contentStream != null, "contentStream must be non null");

            HttpRequestMessage httpRequestMessage = new HttpRequestMessage();

            // Set method, requestURI, and version
            httpRequestMessage.Method = httpRequest.Method;
            httpRequestMessage.RequestUri = CreateRequestUri(uriScheme, httpRequest);
            httpRequestMessage.Version = httpRequest.Version;

            // Set the header fields and content if any
            httpRequestMessage.Content = CreateHeaderFields(httpRequest.HttpHeaders, httpRequestMessage.Headers, contentStream, rewind);

            return httpRequestMessage;
        }

        /// <summary>
        /// Creates an <see cref="HttpResponseMessage"/> based on information provided in <see cref="HttpUnsortedResponse"/>.
        /// </summary>
        /// <param name="httpResponse">The unsorted HTTP Response.</param>
        /// <param name="contentStream">The input <see cref="Stream"/> used to form any <see cref="HttpContent"/> being part of this HTTP Response.</param>
        /// <param name="rewind">Start location of any Response entity within the <paramref name="contentStream"/>.</param>
        /// <returns>A newly created <see cref="HttpResponseMessage"/> instance.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "caller becomes owner.")]
        private static HttpResponseMessage CreateHttpResponseMessage(HttpUnsortedResponse httpResponse, Stream contentStream, int rewind)
        {
            Contract.Assert(httpResponse != null, "httpResponse must be non null");
            Contract.Assert(contentStream != null, "contentStream must be non null");

            HttpResponseMessage httpResponseMessage = new HttpResponseMessage();

            // Set version, status code and reason phrase
            httpResponseMessage.Version = httpResponse.Version;
            httpResponseMessage.StatusCode = httpResponse.StatusCode;
            httpResponseMessage.ReasonPhrase = httpResponse.ReasonPhrase;

            // Set the header fields and content if any
            httpResponseMessage.Content = CreateHeaderFields(httpResponse.HttpHeaders, httpResponseMessage.Headers, contentStream, rewind);

            return httpResponseMessage;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpContentMultipartExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Formatting.Parsers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Extension methods to read MIME multipart entities from <see cref="HttpContent"/> instances.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpContentMultipartExtensions
    {
        private const int MinBufferSize = 256;
        private const int DefaultBufferSize = 32 * 1024;

        /// <summary>
        /// Determines whether the specified content is MIME multipart content.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <returns>
        ///   <c>true</c> if the specified content is MIME multipart content; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsMimeMultipartContent(this HttpContent content)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            return MimeMultipartBodyPartParser.IsMimeMultipartContent(content);
        }

        /// <summary>
        /// Determines whether the specified content is MIME multipart content with the
        /// specified subtype. For example, the subtype <c>mixed</c> would match content
        /// with a content type of <c>multipart/mixed</c>.
        /// </summary>
        /// <param name="content">The content.</param>
        /// <param name="subtype">The MIME multipart subtype to match.</param>
        /// <returns>
        ///   <c>true</c> if the specified content is MIME multipart content with the specified subtype; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsMimeMultipartContent(this HttpContent content, string subtype)
        {
            if (String.IsNullOrWhiteSpace(subtype))
            {
                throw Error.ArgumentNull("subtype");
            }

            if (IsMimeMultipartContent(content))
            {
                if (content.Headers.ContentType.MediaType.Equals("multipart/" + subtype, StringComparison.OrdinalIgnoreCase))
                {
                    return true;
                }
            }

            return false;
        }

        /// <summary>
        /// Reads all body parts within a MIME multipart message into memory using a <see cref="MultipartMemoryStreamProvider"/>.
        /// </summary>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns>
        public static Task<MultipartMemoryStreamProvider> ReadAsMultipartAsync(this HttpContent content)
        {
            return ReadAsMultipartAsync<MultipartMemoryStreamProvider>(content, new MultipartMemoryStreamProvider(), DefaultBufferSize);
        }

        /// <summary>
        /// Reads all body parts within a MIME multipart message into memory using a <see cref="MultipartMemoryStreamProvider"/>.
        /// </summary>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns>
        public static Task<MultipartMemoryStreamProvider> ReadAsMultipartAsync(this HttpContent content, CancellationToken cancellationToken)
        {
            return ReadAsMultipartAsync<MultipartMemoryStreamProvider>(content, new MultipartMemoryStreamProvider(), DefaultBufferSize, cancellationToken);
        }

        /// <summary>
        /// Reads all body parts within a MIME multipart message using the provided <see cref="MultipartStreamProvider"/> instance
        /// to determine where the contents of each body part is written.
        /// </summary>
        /// <typeparam name="T">The <see cref="MultipartStreamProvider"/> with which to process the data.</typeparam>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param>
        /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns>
        public static Task<T> ReadAsMultipartAsync<T>(this HttpContent content, T streamProvider) where T : MultipartStreamProvider
        {
            return ReadAsMultipartAsync(content, streamProvider, DefaultBufferSize);
        }

        /// <summary>
        /// Reads all body parts within a MIME multipart message using the provided <see cref="MultipartStreamProvider"/> instance
        /// to determine where the contents of each body part is written.
        /// </summary>
        /// <typeparam name="T">The <see cref="MultipartStreamProvider"/> with which to process the data.</typeparam>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns>
        public static Task<T> ReadAsMultipartAsync<T>(this HttpContent content, T streamProvider, CancellationToken cancellationToken)
            where T : MultipartStreamProvider
        {
            return ReadAsMultipartAsync(content, streamProvider, DefaultBufferSize, cancellationToken);
        }

        /// <summary>
        /// Reads all body parts within a MIME multipart message using the provided <see cref="MultipartStreamProvider"/> instance
        /// to determine where the contents of each body part is written and <paramref name="bufferSize"/> as read buffer size.
        /// </summary>
        /// <typeparam name="T">The <see cref="MultipartStreamProvider"/> with which to process the data.</typeparam>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param>
        /// <param name="bufferSize">Size of the buffer used to read the contents.</param>
        /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns>
        public static Task<T> ReadAsMultipartAsync<T>(this HttpContent content, T streamProvider, int bufferSize)
            where T : MultipartStreamProvider
        {
            return ReadAsMultipartAsync(content, streamProvider, bufferSize, CancellationToken.None);
        }

        /// <summary>
        /// Reads all body parts within a MIME multipart message using the provided <see cref="MultipartStreamProvider"/> instance
        /// to determine where the contents of each body part is written and <paramref name="bufferSize"/> as read buffer size.
        /// </summary>
        /// <typeparam name="T">The <see cref="MultipartStreamProvider"/> with which to process the data.</typeparam>
        /// <param name="content">An existing <see cref="HttpContent"/> instance to use for the object's content.</param>
        /// <param name="streamProvider">A stream provider providing output streams for where to write body parts as they are parsed.</param>
        /// <param name="bufferSize">Size of the buffer used to read the contents.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task{T}"/> representing the tasks of getting the result of reading the MIME content.</returns>
        public static async Task<T> ReadAsMultipartAsync<T>(this HttpContent content, T streamProvider, int bufferSize,
            CancellationToken cancellationToken) where T : MultipartStreamProvider
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            if (streamProvider == null)
            {
                throw Error.ArgumentNull("streamProvider");
            }

            if (bufferSize < MinBufferSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize);
            }

            Stream stream;
            try
            {
                stream = await content.ReadAsStreamAsync();
            }
            catch (Exception e)
            {
                throw new IOException(Properties.Resources.ReadAsMimeMultipartErrorReading, e);
            }

            using (var parser = new MimeMultipartBodyPartParser(content, streamProvider))
            {
                byte[] data = new byte[bufferSize];
                MultipartAsyncContext context = new MultipartAsyncContext(stream, parser, data, streamProvider.Contents);

                // Start async read/write loop
                await MultipartReadAsync(context, cancellationToken);

                // Let the stream provider post-process when everything is complete
                await streamProvider.ExecutePostProcessingAsync(cancellationToken);
                return streamProvider;
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is propagated.")]
        private static async Task MultipartReadAsync(MultipartAsyncContext context, CancellationToken cancellationToken)
        {
            Contract.Assert(context != null, "context cannot be null");
            while (true)
            {
                int bytesRead;
                try
                {
                    bytesRead = await context.ContentStream.ReadAsync(context.Data, 0, context.Data.Length, cancellationToken);
                }
                catch (Exception e)
                {
                    throw new IOException(Properties.Resources.ReadAsMimeMultipartErrorReading, e);
                }

                IEnumerable<MimeBodyPart> parts = context.MimeParser.ParseBuffer(context.Data, bytesRead);

                foreach (MimeBodyPart part in parts)
                {
                    foreach (ArraySegment<byte> segment in part.Segments)
                    {
                        try
                        {
                            await part.WriteSegment(segment, cancellationToken);
                        }
                        catch (Exception e)
                        {
                            part.Dispose();
                            throw new IOException(Properties.Resources.ReadAsMimeMultipartErrorWriting, e);
                        }
                    }

                    if (CheckIsFinalPart(part, context.Result))
                    {
                        return;
                    }
                }
            }
        }

        private static bool CheckIsFinalPart(MimeBodyPart part, ICollection<HttpContent> result)
        {
            Contract.Assert(part != null, "part cannot be null.");
            Contract.Assert(result != null, "result cannot be null.");
            if (part.IsComplete)
            {
                HttpContent partContent = part.GetCompletedHttpContent();
                if (partContent != null)
                {
                    result.Add(partContent);
                }

                bool isFinal = part.IsFinal;
                part.Dispose();
                return isFinal;
            }

            return false;
        }

        /// <summary>
        /// Managing state for asynchronous read and write operations
        /// </summary>
        private class MultipartAsyncContext
        {
            public MultipartAsyncContext(Stream contentStream, MimeMultipartBodyPartParser mimeParser, byte[] data, ICollection<HttpContent> result)
            {
                Contract.Assert(contentStream != null);
                Contract.Assert(mimeParser != null);
                Contract.Assert(data != null);

                ContentStream = contentStream;
                Result = result;
                MimeParser = mimeParser;
                Data = data;
            }

            /// <summary>
            /// Gets the <see cref="Stream"/> that we read from.
            /// </summary>
            public Stream ContentStream { get; private set; }

            /// <summary>
            /// Gets the collection of parsed <see cref="HttpContent"/> instances.
            /// </summary>
            public ICollection<HttpContent> Result { get; private set; }

            /// <summary>
            /// The data buffer that we use for reading data from the input stream into before processing.
            /// </summary>
            public byte[] Data { get; private set; }

            /// <summary>
            /// Gets the MIME parser instance used to parse the data
            /// </summary>
            public MimeMultipartBodyPartParser MimeParser { get; private set; }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpHeaderExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http.Headers;

namespace System.Net.Http
{
    internal static class HttpHeaderExtensions
    {
        public static void CopyTo(this HttpContentHeaders fromHeaders, HttpContentHeaders toHeaders)
        {
            Contract.Assert(fromHeaders != null, "fromHeaders cannot be null.");
            Contract.Assert(toHeaders != null, "toHeaders cannot be null.");

            foreach (KeyValuePair<string, IEnumerable<string>> header in fromHeaders)
            {
                toHeaders.TryAddWithoutValidation(header.Key, header.Value);
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpMessageContent.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Derived <see cref="HttpContent"/> class which can encapsulate an <see cref="HttpResponseMessage"/>
    /// or an <see cref="HttpRequestMessage"/> as an entity with media type "application/http".
    /// </summary>
    public class HttpMessageContent : HttpContent
    {
        private const string SP = " ";
        private const string ColonSP = ": ";
        private const string CRLF = "\r\n";
        private const string CommaSeparator = ", ";

        private const int DefaultHeaderAllocation = 2 * 1024;

        private const string DefaultMediaType = "application/http";

        private const string MsgTypeParameter = "msgtype";
        private const string DefaultRequestMsgType = "request";
        private const string DefaultResponseMsgType = "response";

        private const string DefaultRequestMediaType = DefaultMediaType + "; " + MsgTypeParameter + "=" + DefaultRequestMsgType;
        private const string DefaultResponseMediaType = DefaultMediaType + "; " + MsgTypeParameter + "=" + DefaultResponseMsgType;

        // Set of header fields that only support single values such as Set-Cookie.
        private static readonly HashSet<string> _singleValueHeaderFields = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            "Cookie",
            "Set-Cookie",
            "X-Powered-By",
        };

        // Set of header fields that should get serialized as space-separated values such as User-Agent.
        private static readonly HashSet<string> _spaceSeparatedValueHeaderFields = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            "User-Agent",
        };

        private bool _contentConsumed;
        private Lazy<Task<Stream>> _streamTask;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpMessageContent"/> class encapsulating an
        /// <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="httpRequest">The <see cref="HttpResponseMessage"/> instance to encapsulate.</param>
        public HttpMessageContent(HttpRequestMessage httpRequest)
        {
            if (httpRequest == null)
            {
                throw Error.ArgumentNull("httpRequest");
            }

            HttpRequestMessage = httpRequest;
            Headers.ContentType = new MediaTypeHeaderValue(DefaultMediaType);
            Headers.ContentType.Parameters.Add(new NameValueHeaderValue(MsgTypeParameter, DefaultRequestMsgType));

            InitializeStreamTask();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpMessageContent"/> class encapsulating an
        /// <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="httpResponse">The <see cref="HttpResponseMessage"/> instance to encapsulate.</param>
        public HttpMessageContent(HttpResponseMessage httpResponse)
        {
            if (httpResponse == null)
            {
                throw Error.ArgumentNull("httpResponse");
            }

            HttpResponseMessage = httpResponse;
            Headers.ContentType = new MediaTypeHeaderValue(DefaultMediaType);
            Headers.ContentType.Parameters.Add(new NameValueHeaderValue(MsgTypeParameter, DefaultResponseMsgType));

            InitializeStreamTask();
        }

        private HttpContent Content
        {
            get { return HttpRequestMessage != null ? HttpRequestMessage.Content : HttpResponseMessage.Content; }
        }

        /// <summary>
        /// Gets the HTTP request message.
        /// </summary>
        public HttpRequestMessage HttpRequestMessage { get; private set; }

        /// <summary>
        /// Gets the HTTP response message.
        /// </summary>
        public HttpResponseMessage HttpResponseMessage { get; private set; }

        private void InitializeStreamTask()
        {
            _streamTask = new Lazy<Task<Stream>>(() => Content == null ? null : Content.ReadAsStreamAsync());
        }

        /// <summary>
        /// Validates whether the content contains an HTTP Request or an HTTP Response.
        /// </summary>
        /// <param name="content">The content to validate.</param>
        /// <param name="isRequest">if set to <c>true</c> if the content is either an HTTP Request or an HTTP Response.</param>
        /// <param name="throwOnError">Indicates whether validation failure should result in an <see cref="Exception"/> or not.</param>
        /// <returns><c>true</c> if content is either an HTTP Request or an HTTP Response</returns>
        internal static bool ValidateHttpMessageContent(HttpContent content, bool isRequest, bool throwOnError)
        {
            if (content == null)
            {
                throw Error.ArgumentNull("content");
            }

            MediaTypeHeaderValue contentType = content.Headers.ContentType;
            if (contentType != null)
            {
                if (!contentType.MediaType.Equals(DefaultMediaType, StringComparison.OrdinalIgnoreCase))
                {
                    if (throwOnError)
                    {
                        throw Error.Argument("content", Properties.Resources.HttpMessageInvalidMediaType, FormattingUtilities.HttpContentType.Name,
                                      isRequest ? DefaultRequestMediaType : DefaultResponseMediaType);
                    }
                    else
                    {
                        return false;
                    }
                }

                foreach (NameValueHeaderValue parameter in contentType.Parameters)
                {
                    if (parameter.Name.Equals(MsgTypeParameter, StringComparison.OrdinalIgnoreCase))
                    {
                        string msgType = FormattingUtilities.UnquoteToken(parameter.Value);
                        if (!msgType.Equals(isRequest ? DefaultRequestMsgType : DefaultResponseMsgType, StringComparison.OrdinalIgnoreCase))
                        {
                            if (throwOnError)
                            {
                                throw Error.Argument("content", Properties.Resources.HttpMessageInvalidMediaType, FormattingUtilities.HttpContentType.Name, isRequest ? DefaultRequestMediaType : DefaultResponseMediaType);
                            }
                            else
                            {
                                return false;
                            }
                        }

                        return true;
                    }
                }
            }

            if (throwOnError)
            {
                throw Error.Argument("content", Properties.Resources.HttpMessageInvalidMediaType, FormattingUtilities.HttpContentType.Name, isRequest ? DefaultRequestMediaType : DefaultResponseMediaType);
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Asynchronously serializes the object's content to the given <paramref name="stream"/>.
        /// </summary>
        /// <param name="stream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="context">The associated <see cref="TransportContext"/>.</param>
        /// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
        protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
        {
            if (stream == null)
            {
                throw Error.ArgumentNull("stream");
            }

            byte[] header = SerializeHeader();
            await stream.WriteAsync(header, 0, header.Length);

            if (Content != null)
            {
                Stream readStream = await _streamTask.Value;
                ValidateStreamForReading(readStream);
                await Content.CopyToAsync(stream);
            }
        }

        /// <summary>
        /// Computes the length of the stream if possible.
        /// </summary>
        /// <param name="length">The computed length of the stream.</param>
        /// <returns><c>true</c> if the length has been computed; otherwise <c>false</c>.</returns>
        [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1108:BlockStatementsMustNotContainEmbeddedComments",
            Justification = "The code is more readable with such comments")]
        protected override bool TryComputeLength(out long length)
        {
            // We have four states we could be in:
            //   0. We have content and it knows its ContentLength.
            //   1. We have content, but the task is still running or finished without success
            //   2. We have content, the task has finished successfully, and the stream came back as a null or non-seekable
            //   3. We have content, the task has finished successfully, and the stream is seekable, so we know its length
            //   4. We don't have content (streamTask.Value == null)
            //
            // For #1 and #2, we return false.
            // For #3, we return true & the size of our headers + the content length
            // For #4, we return true & the size of our headers

            length = 0;

            if (Content?.Headers.ContentLength is not null)
            {
                length = (long)Content.Headers.ContentLength; // Case #0
            }
            else if (_streamTask.Value is not null)
            {
                Stream readStream;
                if (!_streamTask.Value.TryGetResult(out readStream) // Case #1
                    || readStream == null || !readStream.CanSeek) // Case #2
                {
                    length = -1;
                    return false;
                }

                length = readStream.Length; // Case #3
            }

            // We serialize header to a StringBuilder so that we can determine the length
            // following the pattern for HttpContent to try and determine the message length.
            // The perf overhead is no larger than for the other HttpContent implementations.
            byte[] header = SerializeHeader();
            length += header.Length;
            return true;
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (HttpRequestMessage != null)
                {
                    HttpRequestMessage.Dispose();
                    HttpRequestMessage = null;
                }

                if (HttpResponseMessage != null)
                {
                    HttpResponseMessage.Dispose();
                    HttpResponseMessage = null;
                }
            }

            base.Dispose(disposing);
        }

        /// <summary>
        /// Serializes the HTTP request line.
        /// </summary>
        /// <param name="message">Where to write the request line.</param>
        /// <param name="httpRequest">The HTTP request.</param>
        private static void SerializeRequestLine(StringBuilder message, HttpRequestMessage httpRequest)
        {
            Contract.Assert(message != null, "message cannot be null");
            message.Append(httpRequest.Method + SP);
            message.Append(httpRequest.RequestUri.PathAndQuery + SP);
            message.Append(FormattingUtilities.HttpVersionToken + "/" + (httpRequest.Version != null ? httpRequest.Version.ToString(2) : "1.1") + CRLF);

            // Only insert host header if not already present.
            if (httpRequest.Headers.Host == null)
            {
                message.Append(FormattingUtilities.HttpHostHeader + ColonSP + httpRequest.RequestUri.Authority + CRLF);
            }
        }

        /// <summary>
        /// Serializes the HTTP status line.
        /// </summary>
        /// <param name="message">Where to write the status line.</param>
        /// <param name="httpResponse">The HTTP response.</param>
        private static void SerializeStatusLine(StringBuilder message, HttpResponseMessage httpResponse)
        {
            Contract.Assert(message != null, "message cannot be null");
            message.Append(FormattingUtilities.HttpVersionToken + "/" + (httpResponse.Version != null ? httpResponse.Version.ToString(2) : "1.1") + SP);
            message.Append((int)httpResponse.StatusCode + SP);
            message.Append(httpResponse.ReasonPhrase + CRLF);
        }

        /// <summary>
        /// Serializes the header fields.
        /// </summary>
        /// <param name="message">Where to write the status line.</param>
        /// <param name="headers">The headers to write.</param>
        private static void SerializeHeaderFields(StringBuilder message, HttpHeaders headers)
        {
            Contract.Assert(message != null, "message cannot be null");
            if (headers != null)
            {
                foreach (KeyValuePair<string, IEnumerable<string>> header in headers)
                {
                    if (_singleValueHeaderFields.Contains(header.Key))
                    {
                        foreach (string value in header.Value)
                        {
                            message.Append(header.Key + ColonSP + value + CRLF);
                        }
                    }
                    else if (_spaceSeparatedValueHeaderFields.Contains(header.Key))
                    {
                        message.Append(header.Key + ColonSP + String.Join(SP, header.Value) + CRLF);
                    }
                    else
                    {
                        message.Append(header.Key + ColonSP + String.Join(CommaSeparator, header.Value) + CRLF);
                    }
                }
            }
        }

        private byte[] SerializeHeader()
        {
            StringBuilder message = new StringBuilder(DefaultHeaderAllocation);
            HttpHeaders headers = null;
            HttpContent content = null;
            if (HttpRequestMessage != null)
            {
                SerializeRequestLine(message, HttpRequestMessage);
                headers = HttpRequestMessage.Headers;
                content = HttpRequestMessage.Content;
            }
            else
            {
                SerializeStatusLine(message, HttpResponseMessage);
                headers = HttpResponseMessage.Headers;
                content = HttpResponseMessage.Content;
            }

            SerializeHeaderFields(message, headers);
            if (content != null)
            {
                SerializeHeaderFields(message, content.Headers);
            }

            message.Append(CRLF);
            return Encoding.UTF8.GetBytes(message.ToString());
        }

        private void ValidateStreamForReading(Stream stream)
        {
            // Stream is null case should be an extreme, incredibly unlikely corner case. Every HttpContent from
            // the framework (see dotnet/runtime or .NET Framework reference source) provides a non-null Stream
            // in the ReadAsStreamAsync task's return value. Likely need a poorly-designed derived HttpContent
            // to hit this. Mostly ignoring the fact this message doesn't make much sense for the case.
            if (stream is null || !stream.CanRead)
            {
                throw Error.NotSupported(Properties.Resources.NotSupported_UnreadableStream);
            }

            // If the content needs to be written to a target stream a 2nd time, then the stream must support
            // seeking (e.g. a FileStream), otherwise the stream can't be copied a second time to a target
            // stream (e.g. a NetworkStream).
            if (_contentConsumed)
            {
                if (stream.CanSeek)
                {
                    stream.Position = 0;
                }
                else
                {
                    throw Error.InvalidOperation(Properties.Resources.HttpMessageContentAlreadyRead,
                                  FormattingUtilities.HttpContentType.Name,
                                  HttpRequestMessage != null
                                      ? FormattingUtilities.HttpRequestMessageType.Name
                                      : FormattingUtilities.HttpResponseMessageType.Name);
                }
            }

            _contentConsumed = true;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpRequestHeadersExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Provides extension methods for the <see cref="HttpRequestHeaders"/> class.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpRequestHeadersExtensions
    {
        private const string Cookie = "Cookie";

        /// <summary>
        /// Gets any cookie headers present in the request. Each <c>Cookie</c> header is 
        /// represented as one <see cref="CookieHeaderValue"/> instance. A <see cref="CookieHeaderValue"/>
        /// contains information about the domain, path, and other cookie information as well as one or
        /// more <see cref="CookieState"/> instances. Each <see cref="CookieState"/> instance contains
        /// a cookie name and whatever cookie state is associate with that name. The state is in the form of a 
        /// <see cref="System.Collections.Specialized.NameValueCollection"/> which on the wire is encoded as HTML Form URL-encoded data. 
        /// This representation allows for multiple related "cookies" to be carried within the same
        /// <c>Cookie</c> header while still providing separation between each cookie state. A sample
        /// <c>Cookie</c> header is shown below. In this example, there are two <see cref="CookieState"/>
        /// with names <c>stateA</c> and <c>stateB</c> respectively. Further, each cookie state contains two name/value
        /// pairs (name1/value1 and name2/value2) and (name3/value3 and name4/value4).
        /// <code>
        /// Cookie: stateA=name1=value1&amp;name2=value2; stateB=name3=value3&amp;name4=value4; domain=domain1; path=path1;
        /// </code>
        /// </summary>
        /// <param name="headers">The request headers</param>
        /// <returns>A collection of <see cref="CookieHeaderValue"/> instances.</returns>
        public static Collection<CookieHeaderValue> GetCookies(this HttpRequestHeaders headers)
        {
            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            Collection<CookieHeaderValue> result = new Collection<CookieHeaderValue>();
            IEnumerable<string> cookieHeaders;
            if (headers.TryGetValues(Cookie, out cookieHeaders))
            {
                foreach (string cookieHeader in cookieHeaders)
                {
                    CookieHeaderValue cookieHeaderValue;
                    if (CookieHeaderValue.TryParse(cookieHeader, out cookieHeaderValue))
                    {
                        result.Add(cookieHeaderValue);
                    }
                }
            }
            return result;
        }

        /// <summary>
        /// Gets any cookie headers present in the request which contains a <see cref="CookieState"/> with
        /// a name that matches the provided <paramref name="name"/>. For example, if there are two Cookie
        /// header fields looking like this:
        /// <code>
        /// Cookie: stateA=name1=value1&amp;name2=value2; stateB=name3=value3&amp;name4=value4; domain=domain1; path=path1;
        /// Cookie: stateC=name5=value5&amp;name6=value6; stateD=name7=value7&amp;name8=value8; domain=domain2; path=path2;
        /// </code>
        /// and <c>name</c> is <c>stateD</c> then only the second Cookie header will be returned.
        /// </summary>
        /// <param name="headers">The request headers</param>
        /// <param name="name">The name of the <see cref="CookieState"/> to match.</param>
        /// <returns>A collection of <see cref="CookieHeaderValue"/> instances with a matching <see cref="CookieState"/>.</returns>
        public static Collection<CookieHeaderValue> GetCookies(this HttpRequestHeaders headers, string name)
        {
            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            IEnumerable<CookieHeaderValue> cookieHeaderValues = GetCookies(headers);
            CookieHeaderValue[] matches = cookieHeaderValues.Where(header => header.Cookies.Any(state => String.Equals(state.Name, name, StringComparison.OrdinalIgnoreCase))).ToArray();
            return new Collection<CookieHeaderValue>(matches);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Provides extension methods for the <see cref="HttpRequestMessage"/> class.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpRequestMessageExtensions
    {
        /// <summary>
        /// Creates an <see cref="HttpResponseMessage"/> wired up to the associated <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <param name="statusCode">The HTTP status code.</param>
        /// <returns>An initialized <see cref="HttpResponseMessage"/>.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller will dispose")]
        public static HttpResponseMessage CreateResponse(this HttpRequestMessage request, HttpStatusCode statusCode)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return new HttpResponseMessage
            {
                Content = new StreamContent(Stream.Null),
                StatusCode = statusCode,
                RequestMessage = request
            };
        }

        /// <summary>
        /// Creates an <see cref="HttpResponseMessage"/> wired up to the associated <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>An initialized <see cref="HttpResponseMessage"/>.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller will dispose")]
        public static HttpResponseMessage CreateResponse(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return new HttpResponseMessage
            {
                Content = new StreamContent(Stream.Null),
                RequestMessage = request
            };
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpResponseHeadersExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Provides extension methods for the <see cref="HttpResponseHeaders"/> class.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpResponseHeadersExtensions
    {
        private const string SetCookie = "Set-Cookie";

        /// <summary>
        /// Adds cookies to a response. Each <c>Set-Cookie</c> header is 
        /// represented as one <see cref="CookieHeaderValue"/> instance. A <see cref="CookieHeaderValue"/>
        /// contains information about the domain, path, and other cookie information as well as one or
        /// more <see cref="CookieState"/> instances. Each <see cref="CookieState"/> instance contains
        /// a cookie name and whatever cookie state is associate with that name. The state is in the form of a 
        /// <see cref="System.Collections.Specialized.NameValueCollection"/> which on the wire is encoded as HTML Form URL-encoded data. 
        /// This representation allows for multiple related "cookies" to be carried within the same
        /// <c>Cookie</c> header while still providing separation between each cookie state. A sample
        /// <c>Cookie</c> header is shown below. In this example, there are two <see cref="CookieState"/>
        /// with names <c>state1</c> and <c>state2</c> respectively. Further, each cookie state contains two name/value
        /// pairs (name1/value1 and name2/value2) and (name3/value3 and name4/value4).
        /// <code>
        /// Set-Cookie: state1:name1=value1&amp;name2=value2; state2:name3=value3&amp;name4=value4; domain=domain1; path=path1;
        /// </code>
        /// </summary>
        /// <param name="headers">The response headers</param>
        /// <param name="cookies">The cookie values to add to the response.</param>
        public static void AddCookies(this HttpResponseHeaders headers, IEnumerable<CookieHeaderValue> cookies)
        {
            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            if (cookies == null)
            {
                throw Error.ArgumentNull("cookies");
            }

            foreach (CookieHeaderValue cookie in cookies)
            {
                if (cookie == null)
                {
                    throw Error.Argument("cookies", Properties.Resources.CookieNull);
                }

                headers.TryAddWithoutValidation(SetCookie, cookie.ToString());
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpUnsortedHeaders.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;

namespace System.Net.Http
{
    /// <summary>
    /// All of the existing non-abstract <see cref="HttpHeaders"/> implementations, namely
    /// <see cref="HttpRequestHeaders"/>, <see cref="HttpResponseHeaders"/>, and <see cref="HttpContentHeaders"/>
    /// enforce strict rules on what kinds of HTTP header fields can be added to each collection.
    /// When parsing the "application/http" media type we need to just get the unsorted list. It
    /// will get sorted later.
    /// </summary>
    internal class HttpUnsortedHeaders : HttpHeaders
    {
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpUnsortedRequest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting.Parsers;
using System.Net.Http.Headers;

namespace System.Net.Http
{
    /// <summary>
    /// Represents the HTTP Request Line and header parameters parsed by <see cref="HttpRequestLineParser"/>
    /// and <see cref="HttpRequestHeaderParser"/>.
    /// </summary>
    internal class HttpUnsortedRequest
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpUnsortedRequest"/> class.
        /// </summary>
        public HttpUnsortedRequest()
        {
            // Collection of unsorted headers. Later we will sort it into the appropriate
            // HttpContentHeaders, HttpRequestHeaders, and HttpResponseHeaders.
            HttpHeaders = new HttpUnsortedHeaders();
        }

        /// <summary>
        /// Gets or sets the HTTP method.
        /// </summary>
        /// <value>
        /// The HTTP method.
        /// </value>
        public HttpMethod Method { get; set; }

        /// <summary>
        /// Gets or sets the HTTP request URI portion that is carried in the RequestLine (i.e the URI path + query).
        /// </summary>
        /// <value>
        /// The request URI.
        /// </value>
        public string RequestUri { get; set; }

        /// <summary>
        /// Gets or sets the HTTP version.
        /// </summary>
        /// <value>
        /// The HTTP version.
        /// </value>
        public Version Version { get; set; }

        /// <summary>
        /// Gets the unsorted HTTP request headers.
        /// </summary>
        public HttpHeaders HttpHeaders { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/HttpUnsortedResponse.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting.Parsers;
using System.Net.Http.Headers;

namespace System.Net.Http
{
    /// <summary>
    /// Represents the HTTP Status Line and header parameters parsed by <see cref="HttpStatusLineParser"/>
    /// and <see cref="HttpResponseHeaderParser"/>.
    /// </summary>
    internal class HttpUnsortedResponse
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpUnsortedRequest"/> class.
        /// </summary>
        public HttpUnsortedResponse()
        {
            // Collection of unsorted headers. Later we will sort it into the appropriate
            // HttpContentHeaders, HttpRequestHeaders, and HttpResponseHeaders.
            HttpHeaders = new HttpUnsortedHeaders();
        }

        /// <summary>
        /// Gets or sets the HTTP version.
        /// </summary>
        /// <value>
        /// The HTTP version.
        /// </value>
        public Version Version { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="HttpStatusCode"/>
        /// </summary>
        /// <value>
        /// The HTTP status code
        /// </value>
        public HttpStatusCode StatusCode { get; set; }

        /// <summary>
        /// Gets or sets the HTTP reason phrase
        /// </summary>
        /// <value>
        /// The response reason phrase
        /// </value>
        public string ReasonPhrase { get; set; }

        /// <summary>
        /// Gets the unsorted HTTP request headers.
        /// </summary>
        public HttpHeaders HttpHeaders { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/AsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Threading;
using System.Web.Http;

namespace System.Net.Http.Internal
{
    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "_manualResetEvent is disposed in End<TAsyncResult>")]
    internal abstract class AsyncResult : IAsyncResult
    {
        private AsyncCallback _callback;
        private object _state;

        private bool _isCompleted;
        private bool _completedSynchronously;
        private bool _endCalled;

        private Exception _exception;

        protected AsyncResult(AsyncCallback callback, object state)
        {
            _callback = callback;
            _state = state;
        }

        public object AsyncState
        {
            get { return _state; }
        }

        public WaitHandle AsyncWaitHandle
        {
            get
            {
                Contract.Assert(false, "AsyncWaitHandle is not supported -- use callbacks instead.");
                return null;
            }
        }

        public bool CompletedSynchronously
        {
            get { return _completedSynchronously; }
        }

        public bool HasCallback
        {
            get { return _callback != null; }
        }

        public bool IsCompleted
        {
            get { return _isCompleted; }
        }

        protected void Complete(bool completedSynchronously)
        {
            if (_isCompleted)
            {
                throw Error.InvalidOperation(Properties.Resources.AsyncResult_MultipleCompletes, GetType().Name);
            }

            _completedSynchronously = completedSynchronously;
            _isCompleted = true;

            if (_callback != null)
            {
                try
                {
                    _callback(this);
                }
                catch (Exception e)
                {
                    throw Error.InvalidOperation(e, Properties.Resources.AsyncResult_CallbackThrewException);
                }
            }
        }

        protected void Complete(bool completedSynchronously, Exception exception)
        {
            _exception = exception;
            Complete(completedSynchronously);
        }

        protected static TAsyncResult End<TAsyncResult>(IAsyncResult result) where TAsyncResult : AsyncResult
        {
            if (result == null)
            {
                throw Error.ArgumentNull("result");
            }

            TAsyncResult thisPtr = result as TAsyncResult;

            if (thisPtr == null)
            {
                throw Error.Argument("result", Properties.Resources.AsyncResult_ResultMismatch);
            }

            if (!thisPtr._isCompleted)
            {
                thisPtr.AsyncWaitHandle.WaitOne();
            }

            if (thisPtr._endCalled)
            {
                throw Error.InvalidOperation(Properties.Resources.AsyncResult_MultipleEnds);
            }

            thisPtr._endCalled = true;

            if (thisPtr._exception != null)
            {
                throw thisPtr._exception;
            }

            return thisPtr;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/ByteRangeStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http.Internal
{
    /// <summary>
    /// Stream which only exposes a read-only only range view of an
    /// inner stream.
    /// </summary>
    internal class ByteRangeStream : DelegatingStream
    {
        // The offset stream position at which the range starts.
        private readonly long _lowerbounds;

        // The total number of bytes within the range.
        private readonly long _totalCount;

        // The current number of bytes read into the range
        private long _currentCount;

        public ByteRangeStream(Stream innerStream, RangeItemHeaderValue range)
            : base(innerStream)
        {
            if (range == null)
            {
                throw Error.ArgumentNull("range");
            }
            if (!innerStream.CanSeek)
            {
                throw Error.Argument("innerStream", Properties.Resources.ByteRangeStreamNotSeekable, typeof(ByteRangeStream).Name);
            }
            if (innerStream.Length < 1)
            {
                throw Error.ArgumentOutOfRange("innerStream", innerStream.Length, Properties.Resources.ByteRangeStreamEmpty, typeof(ByteRangeStream).Name);
            }
            if (range.From.HasValue && range.From.Value > innerStream.Length)
            {
                throw Error.ArgumentOutOfRange("range", range.From, Properties.Resources.ByteRangeStreamInvalidFrom, innerStream.Length);
            }

            // Ranges are inclusive so 0-9 means the first 10 bytes
            long maxLength = innerStream.Length - 1;
            long upperbounds;
            if (range.To.HasValue)
            {
                if (range.From.HasValue)
                {
                    // e.g bytes=0-499 (the first 500 bytes offsets 0-499)
                    upperbounds = Math.Min(range.To.Value, maxLength);
                    _lowerbounds = range.From.Value;
                }
                else
                {
                    // e.g bytes=-500 (the final 500 bytes)
                    upperbounds = maxLength;
                    _lowerbounds = Math.Max(innerStream.Length - range.To.Value, 0);
                }
            }
            else
            {
                if (range.From.HasValue)
                {
                    // e.g bytes=500- (from byte offset 500 and up)
                    upperbounds = maxLength;
                    _lowerbounds = range.From.Value;
                }
                else
                {
                    // e.g. bytes=- (invalid so will never get here)
                    upperbounds = maxLength;
                    _lowerbounds = 0;
                }
            }

            _totalCount = upperbounds - _lowerbounds + 1;
            ContentRange = new ContentRangeHeaderValue(_lowerbounds, upperbounds, innerStream.Length);
        }

        public ContentRangeHeaderValue ContentRange { get; private set; }

        public override long Length
        {
            get { return _totalCount; }
        }

        public override bool CanWrite
        {
            get { return false; }
        }

        public override long Position
        {
            get
            {
                return _currentCount;
            }
            set
            {
                if (value < 0)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, 0L);
                }

                _currentCount = value;
            }
        }

#if !NETSTANDARD1_3 // BeginX and EndX are not supported on Streams in netstandard1.3
        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            return base.BeginRead(buffer, offset, PrepareStreamForRangeRead(count), callback, state);
        }
#endif

        public override int Read(byte[] buffer, int offset, int count)
        {
            return base.Read(buffer, offset, PrepareStreamForRangeRead(count));
        }

        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            return base.ReadAsync(buffer, offset, PrepareStreamForRangeRead(count), cancellationToken);
        }

        public override int ReadByte()
        {
            int effectiveCount = PrepareStreamForRangeRead(1);
            if (effectiveCount <= 0)
            {
                return -1;
            }

            return base.ReadByte();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            switch (origin)
            {
                case SeekOrigin.Begin:
                    _currentCount = offset;
                    break;
                case SeekOrigin.Current:
                    _currentCount = _currentCount + offset;
                    break;
                case SeekOrigin.End:
                    _currentCount = _totalCount + offset;
                    break;
                default:
                    throw Error.InvalidEnumArgument("origin", (int)origin, typeof(SeekOrigin));
            }

            if (_currentCount < 0L)
            {
                throw new IOException(Properties.Resources.ByteRangeStreamInvalidOffset);
            }

            return _currentCount;
        }

        public override void SetLength(long value)
        {
            throw Error.NotSupported(Properties.Resources.ByteRangeStreamReadOnly);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            throw Error.NotSupported(Properties.Resources.ByteRangeStreamReadOnly);
        }

#if !NETSTANDARD1_3 // BeginX and EndX are not supported on Streams in netstandard1.3
        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            throw Error.NotSupported(Properties.Resources.ByteRangeStreamReadOnly);
        }

        public override void EndWrite(IAsyncResult asyncResult)
        {
            throw Error.NotSupported(Properties.Resources.ByteRangeStreamReadOnly);
        }
#endif

        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            throw Error.NotSupported(Properties.Resources.ByteRangeStreamReadOnly);
        }

        public override void WriteByte(byte value)
        {
            throw Error.NotSupported(Properties.Resources.ByteRangeStreamReadOnly);
        }

        /// <summary>
        /// Gets the correct count for the next read operation.
        /// </summary>
        /// <param name="count">The count requested to be read by the caller.</param>
        /// <returns>The remaining bytes to read within the range defined for this stream.</returns>
        private int PrepareStreamForRangeRead(int count)
        {
            // A negative count causes base.Raad* methods to throw an ArgumentOutOfRangeException.
            if (count <= 0)
            {
                return count;
            }

            // Reading past the end simply does nothing.
            if (_currentCount >= _totalCount)
            {
                return 0;
            }

            long effectiveCount = Math.Min(count, _totalCount - _currentCount);

            // Check if we should update the inner stream's position.
            var newPosition = _lowerbounds + _currentCount;
            var position = InnerStream.Position;
            if (newPosition != position)
            {
                InnerStream.Position = newPosition;
            }

            // Update current number of bytes read.
            _currentCount += effectiveCount;

            // Effective count can never be bigger than int.
            return (int)effectiveCount;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/DelegatingStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http.Internal
{
    /// <summary>
    /// Stream that delegates to inner stream.
    /// This is taken from System.Net.Http
    /// </summary>
    internal abstract class DelegatingStream : Stream
    {
        private readonly Stream _innerStream;

        protected DelegatingStream(Stream innerStream)
        {
            if (innerStream == null)
            {
                throw Error.ArgumentNull("innerStream");
            }
            _innerStream = innerStream;
        }

        protected Stream InnerStream
        {
            get { return _innerStream; }
        }

        public override bool CanRead
        {
            get { return _innerStream.CanRead; }
        }

        public override bool CanSeek
        {
            get { return _innerStream.CanSeek; }
        }

        public override bool CanWrite
        {
            get { return _innerStream.CanWrite; }
        }

        public override long Length
        {
            get { return _innerStream.Length; }
        }

        public override long Position
        {
            get { return _innerStream.Position; }
            set { _innerStream.Position = value; }
        }

        public override int ReadTimeout
        {
            get { return _innerStream.ReadTimeout; }
            set { _innerStream.ReadTimeout = value; }
        }

        public override bool CanTimeout
        {
            get { return _innerStream.CanTimeout; }
        }

        public override int WriteTimeout
        {
            get { return _innerStream.WriteTimeout; }
            set { _innerStream.WriteTimeout = value; }
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                _innerStream.Dispose();
            }
            base.Dispose(disposing);
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            return _innerStream.Seek(offset, origin);
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            return _innerStream.Read(buffer, offset, count);
        }

        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            return _innerStream.ReadAsync(buffer, offset, count, cancellationToken);
        }

#if !NETSTANDARD1_3 // BeginX and EndX not supported on Streams in netstandard1.3
        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            return _innerStream.BeginRead(buffer, offset, count, callback, state);
        }

        public override int EndRead(IAsyncResult asyncResult)
        {
            return _innerStream.EndRead(asyncResult);
        }
#endif

        public override int ReadByte()
        {
            return _innerStream.ReadByte();
        }

        public override void Flush()
        {
            _innerStream.Flush();
        }

        public override Task FlushAsync(CancellationToken cancellationToken)
        {
            return _innerStream.FlushAsync(cancellationToken);
        }

        public override void SetLength(long value)
        {
            _innerStream.SetLength(value);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            _innerStream.Write(buffer, offset, count);
        }

        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            return _innerStream.WriteAsync(buffer, offset, count, cancellationToken);
        }

#if !NETSTANDARD1_3 // BeginX and EndX not supported on Streams in netstandard1.3
        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            return _innerStream.BeginWrite(buffer, offset, count, callback, state);
        }

        public override void EndWrite(IAsyncResult asyncResult)
        {
            _innerStream.EndWrite(asyncResult);
        }
#endif

        public override void WriteByte(byte value)
        {
            _innerStream.WriteByte(value);
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/HttpValueCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http.Internal;
using System.Runtime.Serialization;
using System.Text;
using System.Web.Http;

namespace System.Net.Http.Formatting.Internal
{
    /// <summary>
    ///  NameValueCollection to represent form data and to generate form data output.
    /// </summary>
#if !NETSTANDARD1_3 // NameValueCollection is not serializable in netstandard1.3.
    [Serializable]
#endif
    internal class HttpValueCollection : NameValueCollection
    {
#if !NETSTANDARD1_3 // NameValueCollection is not serializable in netstandard1.3.
        protected HttpValueCollection(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }
#endif

        private HttpValueCollection()
            : base(StringComparer.OrdinalIgnoreCase) // case-insensitive keys
        {
        }

        // Use a builder function instead of a ctor to avoid virtual calls from the ctor.
        // The above condition is only important in the Full .NET fx implementation.
        internal static HttpValueCollection Create()
        {
            return new HttpValueCollection();
        }

        internal static HttpValueCollection Create(IEnumerable<KeyValuePair<string, string>> pairs)
        {
            Contract.Assert(pairs != null);

            var hvc = new HttpValueCollection();

            // Ordering example:
            //   k=A&j=B&k=C --> k:[A,C];j=[B].
            foreach (KeyValuePair<string, string> kvp in pairs)
            {
                hvc.Add(kvp.Key, kvp.Value);
            }

            hvc.IsReadOnly = false;
            return hvc;
        }

        /// <summary>
        /// Adds a name-value pair to the collection.
        /// </summary>
        /// <param name="name">The name to be added as a case insensitive string.</param>
        /// <param name="value">The value to be added.</param>
        public override void Add(string name, string value)
        {
            ThrowIfMaxHttpCollectionKeysExceeded(Count);

            name = name ?? String.Empty;
            value = value ?? String.Empty;

            base.Add(name, value);
        }

        /// <summary>
        /// Converts the content of this instance to its equivalent string representation.
        /// </summary>
        /// <returns>The string representation of the value of this instance, multiple values with a single key are comma separated.</returns>
        public override string ToString()
        {
            return ToString(true);
        }

        private static void ThrowIfMaxHttpCollectionKeysExceeded(int count)
        {
            if (count >= MediaTypeFormatter.MaxHttpCollectionKeys)
            {
                throw Error.InvalidOperation(System.Net.Http.Properties.Resources.MaxHttpCollectionKeyLimitReached, MediaTypeFormatter.MaxHttpCollectionKeys, typeof(MediaTypeFormatter));
            }
        }

        private string ToString(bool urlEncode)
        {
            if (Count == 0)
            {
                return String.Empty;
            }

            StringBuilder builder = new StringBuilder();
            bool first = true;
            foreach (string name in this)
            {
                string[] values = GetValues(name);
                if (values == null || values.Length == 0)
                {
                    first = AppendNameValuePair(builder, first, urlEncode, name, String.Empty);
                }
                else
                {
                    foreach (string value in values)
                    {
                        first = AppendNameValuePair(builder, first, urlEncode, name, value);
                    }
                }
            }

            return builder.ToString();
        }

        private static bool AppendNameValuePair(StringBuilder builder, bool first, bool urlEncode, string name, string value)
        {
            string effectiveName = name ?? String.Empty;
            string encodedName = urlEncode ? WebUtility.UrlEncode(effectiveName) : effectiveName;

            string effectiveValue = value ?? String.Empty;
            string encodedValue = urlEncode ? WebUtility.UrlEncode(effectiveValue) : effectiveValue;

            if (first)
            {
                first = false;
            }
            else
            {
                builder.Append("&");
            }

            builder.Append(encodedName);
            if (!String.IsNullOrEmpty(encodedValue))
            {
                builder.Append("=");
                builder.Append(encodedValue);
            }
            return first;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/NonClosingDelegatingStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Net.Http.Internal
{
    /// <summary>
    /// Stream that doesn't close the inner stream when closed. This is to work around a limitation
    /// in the <see cref="System.Xml.XmlDictionaryReader"/> insisting of closing the inner stream.
    /// The regular <see cref="System.Xml.XmlReader"/> does allow for not closing the inner stream but that
    /// doesn't have the quota that we need for security reasons. Implementations of
    /// <see cref="System.Net.Http.Formatting.MediaTypeFormatter"/>
    /// should not close the input stream when reading or writing so hence this workaround.
    /// </summary>
    internal class NonClosingDelegatingStream : DelegatingStream
    {
        public NonClosingDelegatingStream(Stream innerStream)
            : base(innerStream)
        {
        }

#if NETSTANDARD1_3
        protected override void Dispose(bool disposing)
        {
        }
#else
        public override void Close()
        {
        }
#endif
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/NullableAttributes.cs
================================================
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

// From https://github.com/dotnet/runtime/blob/88868b7a781f4e5b9037b8721f30440207a7aa42/src/tools/illink/src/ILLink.RoslynAnalyzer/NullableAttributes.cs

namespace System.Diagnostics.CodeAnalysis
{
#if !NETSTANDARD2_1
    /// <summary>Specifies that null is allowed as an input even if the corresponding type disallows it.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class AllowNullAttribute : Attribute { }

    /// <summary>Specifies that null is disallowed as an input even if the corresponding type allows it.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class DisallowNullAttribute : Attribute { }

    /// <summary>Specifies that an output may be null even if the corresponding type disallows it.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class MaybeNullAttribute : Attribute { }

    /// <summary>Specifies that an output will not be null even if the corresponding type allows it. Specifies that an input argument was not null when the call returns.</summary>
    [AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class NotNullAttribute : Attribute { }

    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter may be null even if the corresponding type disallows it.</summary>
    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class MaybeNullWhenAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified return value condition.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter may be null.
        /// </param>
        public MaybeNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;

        /// <summary>Gets the return value condition.</summary>
        public bool ReturnValue { get; }
    }

    /// <summary>Specifies that when a method returns <see cref="ReturnValue"/>, the parameter will not be null even if the corresponding type allows it.</summary>
    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class NotNullWhenAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified return value condition.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter will not be null.
        /// </param>
        public NotNullWhenAttribute(bool returnValue) => ReturnValue = returnValue;

        /// <summary>Gets the return value condition.</summary>
        public bool ReturnValue { get; }
    }

    /// <summary>Specifies that the output will be non-null if the named parameter is non-null.</summary>
    [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class NotNullIfNotNullAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the associated parameter name.</summary>
        /// <param name="parameterName">
        /// The associated parameter name.  The output will be non-null if the argument to the parameter specified is non-null.
        /// </param>
        public NotNullIfNotNullAttribute(string parameterName) => ParameterName = parameterName;

        /// <summary>Gets the associated parameter name.</summary>
        public string ParameterName { get; }
    }

    /// <summary>Applied to a method that will never return under any circumstance.</summary>
    [AttributeUsage(AttributeTargets.Method, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class DoesNotReturnAttribute : Attribute { }

    /// <summary>Specifies that the method will not return if the associated Boolean parameter is passed the specified value.</summary>
    [AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class DoesNotReturnIfAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified parameter value.</summary>
        /// <param name="parameterValue">
        /// The condition parameter value. Code after the method will be considered unreachable by diagnostics if the argument to
        /// the associated parameter matches this value.
        /// </param>
        public DoesNotReturnIfAttribute(bool parameterValue) => ParameterValue = parameterValue;

        /// <summary>Gets the condition parameter value.</summary>
        public bool ParameterValue { get; }
    }
#endif

    /// <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values.</summary>
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class MemberNotNullAttribute : Attribute
    {
        /// <summary>Initializes the attribute with a field or property member.</summary>
        /// <param name="member">
        /// The field or property member that is promised to be not-null.
        /// </param>
        public MemberNotNullAttribute(string member) => Members = new[] { member };

        /// <summary>Initializes the attribute with the list of field and property members.</summary>
        /// <param name="members">
        /// The list of field and property members that are promised to be not-null.
        /// </param>
        public MemberNotNullAttribute(params string[] members) => Members = members;

        /// <summary>Gets field or property member names.</summary>
        public string[] Members { get; }
    }

    /// <summary>Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition.</summary>
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
#if SYSTEM_PRIVATE_CORELIB
    public
#else
    internal
#endif
        sealed class MemberNotNullWhenAttribute : Attribute
    {
        /// <summary>Initializes the attribute with the specified return value condition and a field or property member.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter will not be null.
        /// </param>
        /// <param name="member">
        /// The field or property member that is promised to be not-null.
        /// </param>
        public MemberNotNullWhenAttribute(bool returnValue, string member)
        {
            ReturnValue = returnValue;
            Members = new[] { member };
        }

        /// <summary>Initializes the attribute with the specified return value condition and list of field and property members.</summary>
        /// <param name="returnValue">
        /// The return value condition. If the method returns this value, the associated parameter will not be null.
        /// </param>
        /// <param name="members">
        /// The list of field and property members that are promised to be not-null.
        /// </param>
        public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
        {
            ReturnValue = returnValue;
            Members = members;
        }

        /// <summary>Gets the return value condition.</summary>
        public bool ReturnValue { get; }

        /// <summary>Gets field or property member names.</summary>
        public string[] Members { get; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/TranscodingStream.cs
================================================
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

// From https://github.com/dotnet/runtime/blob/88868b7a781f4e5b9037b8721f30440207a7aa42/src/libraries/System.Private.CoreLib/src/System/Text/TranscodingStream.cs

using System.Buffers;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using Properties = System.Net.Http.Properties;

#nullable enable

namespace System.Text
{
    internal sealed class TranscodingStream : Stream
    {
        private const int DefaultReadByteBufferSize = 4 * 1024; // lifted from StreamReader.cs (FileStream)

        // We optimistically assume 1 byte ~ 1 char during transcoding. This is a good rule of thumb
        // but isn't always appropriate: transcoding between single-byte and multi-byte encodings
        // will violate this, as will any invalid data fixups performed by the transcoder itself.
        // To account for these unknowns we have a minimum scratch buffer size we use during the
        // transcoding process. This should be generous enough to account for even the largest
        // fallback mechanism we're likely to see in the real world.

        private const int MinWriteRentedArraySize = 4 * 1024;
        private const int MaxWriteRentedArraySize = 1024 * 1024;

        private static readonly byte[] EmptyByteBuffer = new byte[0];
        private static readonly char[] EmptyCharBuffer = new char[0];

        private readonly Encoding _innerEncoding;
        private readonly Encoding _thisEncoding;
        private Stream _innerStream; // null if the wrapper has been disposed
        private readonly bool _leaveOpen;
        private readonly byte[] _singleByteBuffer = new byte[1];

        /*
         * Fields used for writing bytes [this] -> chars -> bytes [inner]
         * Lazily initialized the first time we need to write
         */

        private Encoder? _innerEncoder;
        private Decoder? _thisDecoder;

        /*
         * Fields used for reading bytes [inner] -> chars -> bytes [this]
         * Lazily initialized the first time we need to read
         */

        private Encoder? _thisEncoder;
        private Decoder? _innerDecoder;
        private int _readCharBufferMaxSize; // the maximum number of characters _innerDecoder.ReadChars can return
        private byte[]? _readBuffer; // contains the data that Read() should return
        private int _readBufferOffset;
        private int _readBufferCount;

        internal TranscodingStream(Stream innerStream, Encoding innerEncoding, Encoding thisEncoding, bool leaveOpen = false)
        {
            _innerStream = innerStream ?? throw Error.ArgumentNull(nameof(innerStream));
            _leaveOpen = leaveOpen;

            _innerEncoding = innerEncoding ?? throw Error.ArgumentNull(nameof(innerEncoding));
            _thisEncoding = thisEncoding ?? throw Error.ArgumentNull(nameof(thisEncoding));
        }

        /*
         * Most CanXyz methods delegate to the inner stream, returning false
         * if this instance has been disposed. CanSeek is always false.
         */

        public override bool CanRead => _innerStream?.CanRead ?? false;

        public override bool CanSeek => false;

        public override bool CanWrite => _innerStream?.CanWrite ?? false;

        public override long Length => throw Error.NotSupported(Properties.Resources.NotSupported_UnseekableStream);

        public override long Position
        {
            get => throw Error.NotSupported(Properties.Resources.NotSupported_UnseekableStream);
            set => throw Error.NotSupported(Properties.Resources.NotSupported_UnseekableStream);
        }

        protected override void Dispose(bool disposing)
        {
            Debug.Assert(disposing, "This type isn't finalizable.");
            base.Dispose(disposing);

            if (_innerStream is null)
            {
                return; // dispose called multiple times, ignore
            }

            // First, flush any pending data to the inner stream.

            ArraySegment<byte> pendingData = FinalFlushWriteBuffers();
            if (pendingData.Count != 0)
            {
                _innerStream.Write(pendingData.Array, pendingData.Offset, pendingData.Count);
            }

            // Mark our object as disposed

            Stream innerStream = _innerStream;
            _innerStream = null!;

            // And dispose the inner stream if needed

            if (!_leaveOpen)
            {
                innerStream.Dispose();
            }
        }

#if NETCOREAPP3_1_OR_GREATER || NETSTANDARD2_1
        public override ValueTask DisposeAsync()
        {
            if (_innerStream is null)
            {
                return default; // dispose called multiple times, ignore
            }

            // First, get any pending data destined for the inner stream.

            ArraySegment<byte> pendingData = FinalFlushWriteBuffers();

            if (pendingData.Count == 0)
            {
                // Fast path: just dispose of the object graph.
                // No need to write anything to the stream first.

                Stream innerStream = _innerStream;
                _innerStream = null!;

                return (_leaveOpen)
                    ? default /* no work to do */
                    : innerStream.DisposeAsync();
            }

            // Slower path; need to perform an async write followed by an async dispose.

            return DisposeAsyncCore(pendingData);
            async ValueTask DisposeAsyncCore(ArraySegment<byte> pendingData)
            {
                Debug.Assert(pendingData.Count != 0);

                Stream innerStream = _innerStream;
                _innerStream = null!;

                await innerStream.WriteAsync(pendingData.AsMemory()).ConfigureAwait(false);

                if (!_leaveOpen)
                {
                    await innerStream.DisposeAsync().ConfigureAwait(false);
                }
            }
        }
#endif

#pragma warning disable CS3016 // Arrays as attribute arguments is not CLS-compliant
#pragma warning disable CS8774 // Member must have a non-null value when exiting.

        // Sets up the data structures that are necessary before any read operation takes place,
        // throwing if the object is in a state where reads are not possible.
        [MemberNotNull(nameof(_innerDecoder), nameof(_thisEncoder), nameof(_readBuffer))]
        private void EnsurePreReadConditions()
        {
            ThrowIfDisposed();
            if (_innerDecoder is null)
            {
                InitializeReadDataStructures();
            }

            void InitializeReadDataStructures()
            {
                if (!CanRead)
                {
                    throw Error.NotSupported(Properties.Resources.NotSupported_UnreadableStream);
                }

                _innerDecoder = _innerEncoding.GetDecoder();
                _thisEncoder = _thisEncoding.GetEncoder();
                _readCharBufferMaxSize = _innerEncoding.GetMaxCharCount(DefaultReadByteBufferSize);

                // Can't use ArrayPool for the below array since it's an instance field of this object.
                // But since we never expose the raw array contents to our callers we can get away
                // with skipping the array zero-init during allocation. The segment points to the
                // data which we haven't yet read; however, we own the entire backing array and can
                // re-create the segment as needed once the array is repopulated.

#if NET5_0_OR_GREATER
                _readBuffer = GC.AllocateUninitializedArray<byte>(_thisEncoding.GetMaxByteCount(_readCharBufferMaxSize));
#else
                _readBuffer = new byte[_thisEncoding.GetMaxByteCount(_readCharBufferMaxSize)];
#endif
            }
        }

        // Sets up the data structures that are necessary before any write operation takes place,
        // throwing if the object is in a state where writes are not possible.
        [MemberNotNull(nameof(_thisDecoder), nameof(_innerEncoder))]
        private void EnsurePreWriteConditions()
        {
            ThrowIfDisposed();
            if (_innerEncoder is null)
            {
                InitializeReadDataStructures();
            }

            void InitializeReadDataStructures()
            {
                if (!CanWrite)
                {
                    throw Error.NotSupported(Properties.Resources.NotSupported_UnwritableStream);
                }

                _innerEncoder = _innerEncoding.GetEncoder();
                _thisDecoder = _thisEncoding.GetDecoder();
            }
        }

#pragma warning restore CS8774 // Member must have a non-null value when exiting.
#pragma warning restore CS3016 // Arrays as attribute arguments is not CLS-compliant

        // returns any pending data that needs to be flushed to the inner stream before disposal
        private ArraySegment<byte> FinalFlushWriteBuffers()
        {
            // If this stream was never used for writing, no-op.

            if (_thisDecoder is null || _innerEncoder is null)
            {
                return default;
            }

            // convert bytes [this] -> chars
            // Having leftover data in our buffers should be very rare since it should only
            // occur if the end of the stream contains an incomplete multi-byte sequence.
            // Let's not bother complicating this logic with array pool rentals or allocation-
            // avoiding loops.

            char[] chars = EmptyCharBuffer;
            int charCount = _thisDecoder.GetCharCount(EmptyByteBuffer, 0, 0, flush: true);
            if (charCount > 0)
            {
                chars = new char[charCount];
                charCount = _thisDecoder.GetChars(EmptyByteBuffer, 0, 0, chars, 0, flush: true);
            }

            // convert chars -> bytes [inner]
            // It's possible that _innerEncoder might need to perform some end-of-text fixup
            // (due to flush: true), even if _thisDecoder didn't need to do so.

            byte[] bytes = EmptyByteBuffer;
            int byteCount = _innerEncoder.GetByteCount(chars, 0, charCount, flush: true);
            if (byteCount > 0)
            {
                bytes = new byte[byteCount];
                byteCount = _innerEncoder.GetBytes(chars, 0, charCount, bytes, 0, flush: true);
            }

            return new ArraySegment<byte>(bytes, 0, byteCount);
        }

        public override void Flush()
        {
            // Don't pass flush: true to our inner decoder + encoder here, since it could cause data
            // corruption if a flush occurs mid-stream. Wait until the stream is being closed.

            ThrowIfDisposed();
            _innerStream.Flush();
        }

        public override Task FlushAsync(CancellationToken cancellationToken)
        {
            // Don't pass flush: true to our inner decoder + encoder here, since it could cause data
            // corruption if a flush occurs mid-stream. Wait until the stream is being closed.

            ThrowIfDisposed();
            return _innerStream.FlushAsync(cancellationToken);
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            ValidateBufferArguments(buffer, offset, count);

            return Read(new Span<byte>(buffer, offset, count));
        }

#if NETCOREAPP || NETSTANDARD2_1
        public override
#else
        private
#endif
        int Read(Span<byte> buffer)
        {
            EnsurePreReadConditions();

            // If there's no data in our pending read buffer, we'll need to populate it from
            // the inner stream. We read the inner stream's bytes, decode that to chars using
            // the 'inner' encoding, then re-encode those chars under the 'this' encoding.
            // We've already calculated the worst-case expansions for the intermediate buffers,
            // so we use GetChars / GetBytes instead of Convert to simplify the below code
            // and to ensure an exception is thrown if the Encoding reported an incorrect
            // worst-case expansion.

            if (_readBufferCount == 0)
            {
                byte[] rentedBytes = ArrayPool<byte>.Shared.Rent(DefaultReadByteBufferSize);
                char[] rentedChars = ArrayPool<char>.Shared.Rent(_readCharBufferMaxSize);

                try
                {
                    int pendingReadDataPopulatedJustNow;
                    bool isEofReached;

                    do
                    {
                        // Beware: Use our constant value instead of 'rentedBytes.Length' for the count
                        // parameter below. The reason for this is that the array pool could've returned
                        // a larger-than-expected array, but our worst-case expansion calculations
                        // performed earlier didn't take that into account.

                        int innerBytesReadJustNow = _innerStream.Read(rentedBytes, 0, DefaultReadByteBufferSize);
                        isEofReached = (innerBytesReadJustNow == 0);

                        // Convert bytes [inner] -> chars, then convert chars -> bytes [this].
                        // We can't return 0 to our caller until inner stream EOF has been reached. But if the
                        // inner stream returns a non-empty but incomplete buffer, GetBytes may return 0 anyway
                        // since it can't yet make forward progress on the input data. If this happens, we'll
                        // loop so that we don't return 0 to our caller until we truly see inner stream EOF.

                        int charsDecodedJustNow = _innerDecoder.GetChars(rentedBytes, 0, innerBytesReadJustNow, rentedChars, 0, flush: isEofReached);
                        pendingReadDataPopulatedJustNow = _thisEncoder.GetBytes(rentedChars, 0, charsDecodedJustNow, _readBuffer, 0, flush: isEofReached);
                    } while (!isEofReached && pendingReadDataPopulatedJustNow == 0);

                    _readBufferOffset = 0;
                    _readBufferCount = pendingReadDataPopulatedJustNow;
                }
                finally
                {
                    ArrayPool<byte>.Shared.Return(rentedBytes);
                    ArrayPool<char>.Shared.Return(rentedChars);
                }
            }

            // At this point: (a) we've populated our pending read buffer and there's
            // useful data to return to our caller; or (b) the pending read buffer is
            // empty because the inner stream has reached EOF and all pending read data
            // has already been flushed, and we should return 0.

            int bytesToReturn = Math.Min(_readBufferCount, buffer.Length);
            _readBuffer.AsSpan(_readBufferOffset, bytesToReturn).CopyTo(buffer);
            _readBufferOffset += bytesToReturn;
            _readBufferCount -= bytesToReturn;
            return bytesToReturn;
        }

        public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            ValidateBufferArguments(buffer, offset, count);

            return ReadAsync(new Memory<byte>(buffer, offset, count), cancellationToken).AsTask();
        }

#if NETCOREAPP || NETSTANDARD2_1
        public override
#else
        private
#endif
        ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default)
        {
            EnsurePreReadConditions();

            if (cancellationToken.IsCancellationRequested)
            {
#if NETCOREAPP || NETSTANDARD
                return new ValueTask<int>(Task.FromCanceled<int>(cancellationToken));
#else
                // Lose track of the CancellationToken in this case.
                return new ValueTask<int>(TaskHelpers.Canceled<int>());
#endif
            }

            return ReadAsyncCore(buffer, cancellationToken);
            async ValueTask<int> ReadAsyncCore(Memory<byte> buffer, CancellationToken cancellationToken)
            {
                // If there's no data in our pending read buffer, we'll need to populate it from
                // the inner stream. We read the inner stream's bytes, decode that to chars using
                // the 'inner' encoding, then re-encode those chars under the 'this' encoding.
                // We've already calculated the worst-case expansions for the intermediate buffers,
                // so we use GetChars / GetBytes instead of Convert to simplify the below code
                // and to ensure an exception is thrown if the Encoding reported an incorrect
                // worst-case expansion.

                if (_readBufferCount == 0)
                {
                    byte[] rentedBytes = ArrayPool<byte>.Shared.Rent(DefaultReadByteBufferSize);
                    char[] rentedChars = ArrayPool<char>.Shared.Rent(_readCharBufferMaxSize);

                    try
                    {
                        int pendingReadDataPopulatedJustNow;
                        bool isEofReached;

                        do
                        {
                            // Beware: Use our constant value instead of 'rentedBytes.Length' when creating
                            // the Mem<byte> struct. The reason for this is that the array pool could've returned
                            // a larger-than-expected array, but our worst-case expansion calculations
                            // performed earlier didn't take that into account.

                            int innerBytesReadJustNow = await _innerStream.ReadAsync(rentedBytes, 0, DefaultReadByteBufferSize, cancellationToken).ConfigureAwait(false);
                            isEofReached = (innerBytesReadJustNow == 0);

                            // Convert bytes [inner] -> chars, then convert chars -> bytes [this].
                            // We can't return 0 to our caller until inner stream EOF has been reached. But if the
                            // inner stream returns a non-empty but incomplete buffer, GetBytes may return 0 anyway
                            // since it can't yet make forward progress on the input data. If this happens, we'll
                            // loop so that we don't return 0 to our caller until we truly see inner stream EOF.

                            int charsDecodedJustNow = _innerDecoder.GetChars(rentedBytes, 0, innerBytesReadJustNow, rentedChars, 0, flush: isEofReached);
                            pendingReadDataPopulatedJustNow = _thisEncoder.GetBytes(rentedChars, 0, charsDecodedJustNow, _readBuffer, 0, flush: isEofReached);
                        } while (!isEofReached && pendingReadDataPopulatedJustNow == 0);

                        _readBufferOffset = 0;
                        _readBufferCount = pendingReadDataPopulatedJustNow;
                    }
                    finally
                    {
                        ArrayPool<byte>.Shared.Return(rentedBytes);
                        ArrayPool<char>.Shared.Return(rentedChars);
                    }
                }

                // At this point: (a) we've populated our pending read buffer and there's
                // useful data to return to our caller; or (b) the pending read buffer is
                // empty because the inner stream has reached EOF and all pending read data
                // has already been flushed, and we should return 0.

                int bytesToReturn = Math.Min(_readBufferCount, buffer.Length);
                _readBuffer.AsSpan(_readBufferOffset, bytesToReturn).CopyTo(buffer.Span);
                _readBufferOffset += bytesToReturn;
                _readBufferCount -= bytesToReturn;
                return bytesToReturn;
            }
        }

        public override int ReadByte()
        {
            return Read(_singleByteBuffer, offset: 0, count: 1) != 0 ? _singleByteBuffer[0] : -1;
        }

        public override long Seek(long offset, SeekOrigin origin)
            => throw Error.NotSupported(Properties.Resources.NotSupported_UnseekableStream);

        public override void SetLength(long value)
            => throw Error.NotSupported(Properties.Resources.NotSupported_UnseekableStream);

#if NET6_0_OR_GREATER
        [StackTraceHidden]
#endif
        private void ThrowIfDisposed()
        {
            if (_innerStream is null)
            {
                ThrowObjectDisposedException();
            }
        }

        [DoesNotReturn]
#if NET6_0_OR_GREATER
        [StackTraceHidden]
#endif
        private void ThrowObjectDisposedException()
        {
            throw new ObjectDisposedException(GetType().Name, Properties.Resources.ObjectDisposed_StreamClosed);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            ValidateBufferArguments(buffer, offset, count);

#if NETCOREAPP || NETSTANDARD2_1
            Write(new ReadOnlySpan<byte>(buffer, offset, count));
#else
            WriteCore(buffer, offset, count);
#endif
        }

#if NETCOREAPP || NETSTANDARD2_1
        public override void Write(ReadOnlySpan<byte> buffer)
        {
            EnsurePreWriteConditions();

            if (buffer.IsEmpty)
            {
                return;
            }

            int rentalLength = buffer.Length < MinWriteRentedArraySize ? MinWriteRentedArraySize :
                buffer.Length > MaxWriteRentedArraySize ? MaxWriteRentedArraySize :
                buffer.Length;

            char[] scratchChars = ArrayPool<char>.Shared.Rent(rentalLength);
            byte[] scratchBytes = ArrayPool<byte>.Shared.Rent(rentalLength);

            try
            {
                bool decoderFinished, encoderFinished;
                do
                {
                    // convert bytes [this] -> chars

                    _thisDecoder.Convert(
                        bytes: buffer,
                        chars: scratchChars,
                        flush: false,
                        out int bytesConsumed,
                        out int charsWritten,
                        out decoderFinished);

                    buffer = buffer.Slice(bytesConsumed);

                    // convert chars -> bytes [inner]

                    Span<char> decodedChars = scratchChars.AsSpan(0, charsWritten);

                    do
                    {
                        _innerEncoder.Convert(
                            chars: decodedChars,
                            bytes: scratchBytes,
                            flush: false,
                            out int charsConsumed,
                            out int bytesWritten,
                            out encoderFinished);

                        decodedChars = decodedChars.Slice(charsConsumed);

                        // It's more likely that the inner stream provides an optimized implementation of
                        // Write(byte[], ...) over Write(ROS<byte>), so we'll prefer the byte[]-based overloads.

                        _innerStream.Write(scratchBytes, 0, bytesWritten);
                    } while (!encoderFinished);
                } while (!decoderFinished);
            }
            finally
            {
                ArrayPool<char>.Shared.Return(scratchChars);
                ArrayPool<byte>.Shared.Return(scratchBytes);
            }
        }
#else
        private void WriteCore(byte[] buffer, int offset, int count)
        {
            EnsurePreWriteConditions();

            if (count == 0)
            {
                return;
            }

            int rentalLength = buffer.Length < MinWriteRentedArraySize ? MinWriteRentedArraySize :
                buffer.Length > MaxWriteRentedArraySize ? MaxWriteRentedArraySize :
                buffer.Length;

            char[] scratchChars = ArrayPool<char>.Shared.Rent(rentalLength);
            byte[] scratchBytes = ArrayPool<byte>.Shared.Rent(rentalLength);

            try
            {
                bool decoderFinished, encoderFinished;
                do
                {
                    // convert bytes [this] -> chars

                    _thisDecoder.Convert(
                        bytes: buffer,
                        byteIndex: offset,
                        byteCount: count,
                        chars: scratchChars,
                        charIndex: 0,
                        charCount: rentalLength,
                        flush: false,
                        out int bytesConsumed,
                        out int charsWritten,
                        out decoderFinished);

                    offset += bytesConsumed;
                    count -= bytesConsumed;

                    // convert chars -> bytes [inner]

                    int scratchOffset = 0;
                    do
                    {
                        _innerEncoder.Convert(
                            chars: scratchChars,
                            charIndex: scratchOffset,
                            charCount: charsWritten,
                            bytes: scratchBytes,
                            byteIndex: 0,
                            byteCount: rentalLength,
                            flush: false,
                            out int charsConsumed,
                            out int bytesWritten,
                            out encoderFinished);

                        scratchOffset += charsConsumed;
                        charsWritten -= charsConsumed;

                        // It's more likely that the inner stream provides an optimized implementation of
                        // Write(byte[], ...) over Write(ROS<byte>), so we'll prefer the byte[]-based overloads.

                        _innerStream.Write(scratchBytes, 0, bytesWritten);
                    } while (!encoderFinished);
                } while (!decoderFinished);
            }
            finally
            {
                ArrayPool<char>.Shared.Return(scratchChars);
                ArrayPool<byte>.Shared.Return(scratchBytes);
            }
        }
#endif

        public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            ValidateBufferArguments(buffer, offset, count);

#if NETCOREAPP || NETSTANDARD2_1
            return WriteAsync(new ReadOnlyMemory<byte>(buffer, offset, count), cancellationToken).AsTask();
#else
            return WriteAsyncCore(buffer, offset, count, cancellationToken).AsTask();
#endif
        }

#if NETCOREAPP || NETSTANDARD2_1
        public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default)
        {
            EnsurePreWriteConditions();

            if (cancellationToken.IsCancellationRequested)
            {
                return new ValueTask(Task.FromCanceled<int>(cancellationToken));
            }

            if (buffer.IsEmpty)
            {
                // ValueTask.CompletedTask
                return default;
            }

            return WriteAsyncCore(buffer, cancellationToken);
            async ValueTask WriteAsyncCore(ReadOnlyMemory<byte> remainingOuterEncodedBytes, CancellationToken cancellationToken)
            {
                int rentalLength = remainingOuterEncodedBytes.Length < MinWriteRentedArraySize ? MinWriteRentedArraySize :
                    remainingOuterEncodedBytes.Length > MaxWriteRentedArraySize ? MaxWriteRentedArraySize:
                    remainingOuterEncodedBytes.Length;

                char[] scratchChars = ArrayPool<char>.Shared.Rent(rentalLength);
                byte[] scratchBytes = ArrayPool<byte>.Shared.Rent(rentalLength);

                try
                {
                    bool decoderFinished, encoderFinished;
                    do
                    {
                        // convert bytes [this] -> chars

                        _thisDecoder.Convert(
                            bytes: buffer,
                            chars: scratchChars,
                            flush: false,
                            out int bytesConsumed,
                            out int charsWritten,
                            out decoderFinished);

                        buffer = buffer.Slice(bytesConsumed);

                        // convert chars -> bytes [inner]

                        Span<char> decodedChars = scratchChars.AsSpan(0, charsWritten);

                        do
                        {
                            _innerEncoder.Convert(
                                chars: decodedChars,
                                bytes: scratchBytes,
                                flush: false,
                                out int charsConsumed,
                                out int bytesWritten,
                                out encoderFinished);

                            decodedChars = decodedChars.Slice(charsConsumed);

                            await _innerStream.WriteAsync(scratchBytes, 0, bytesWritten, cancellationToken).ConfigureAwait(false);
                        } while (!encoderFinished);
                    } while (!decoderFinished);
                }
                finally
                {
                    ArrayPool<char>.Shared.Return(scratchChars);
                    ArrayPool<byte>.Shared.Return(scratchBytes);
                }
            }
        }
#else
        private ValueTask WriteAsyncCore(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            EnsurePreWriteConditions();

            if (cancellationToken.IsCancellationRequested)
            {
#if NETSTANDARD
                return new ValueTask(Task.FromCanceled<int>(cancellationToken));
#else
                // Lose track of the CancellationToken in this case.
                return new ValueTask(TaskHelpers.Canceled());
#endif
            }

            if (count == 0)
            {
                // ValueTask.CompletedTask
                return default;
            }

            return WriteAsyncCore(buffer, cancellationToken);
            async ValueTask WriteAsyncCore(ReadOnlyMemory<byte> remainingOuterEncodedBytes, CancellationToken cancellationToken)
            {
                int rentalLength = remainingOuterEncodedBytes.Length < MinWriteRentedArraySize ? MinWriteRentedArraySize :
                    remainingOuterEncodedBytes.Length > MaxWriteRentedArraySize ? MaxWriteRentedArraySize :
                    remainingOuterEncodedBytes.Length;

                char[] scratchChars = ArrayPool<char>.Shared.Rent(rentalLength);
                byte[] scratchBytes = ArrayPool<byte>.Shared.Rent(rentalLength);

                try
                {
                    bool decoderFinished, encoderFinished;
                    do
                    {
                        // convert bytes [this] -> chars

                        _thisDecoder.Convert(
                            bytes: buffer,
                            byteIndex: offset,
                            byteCount: count,
                            chars: scratchChars,
                            charIndex: 0,
                            charCount: rentalLength,
                            flush: false,
                            out int bytesConsumed,
                            out int charsWritten,
                            out decoderFinished);

                        offset += bytesConsumed;
                        count -= bytesConsumed;

                        // convert chars -> bytes [inner]

                        int scratchOffset = 0;
                        do
                        {
                            _innerEncoder.Convert(
                                chars: scratchChars,
                                charIndex: scratchOffset,
                                charCount: charsWritten,
                                bytes: scratchBytes,
                                byteIndex: 0,
                                byteCount: rentalLength,
                                flush: false,
                                out int charsConsumed,
                                out int bytesWritten,
                                out encoderFinished);

                            scratchOffset += charsConsumed;
                            charsWritten -= charsConsumed;

                            await _innerStream.WriteAsync(scratchBytes, 0, bytesWritten, cancellationToken).ConfigureAwait(false);
                        } while (!encoderFinished);
                    } while (!decoderFinished);
                }
                finally
                {
                    ArrayPool<char>.Shared.Return(scratchChars);
                    ArrayPool<byte>.Shared.Return(scratchBytes);
                }
            }
        }
#endif

        public override void WriteByte(byte value)
        {
            _singleByteBuffer[0] = value;
            Write(_singleByteBuffer, offset: 0, count: 1);
        }

        // From https://github.com/dotnet/runtime/blob/88868b7a781f4e5b9037b8721f30440207a7aa42/src/libraries/System.Private.CoreLib/src/System/IO/Stream.cs

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        private static void ValidateBufferArguments(byte[] buffer, int offset, int count)
        {
            if (buffer is null)
            {
                throw Error.ArgumentNull(nameof(buffer));
            }

            if (offset < 0)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo(nameof(offset), offset, minValue: 0);
            }

            if ((uint)count > buffer.Length - offset)
            {
                throw Error.ArgumentOutOfRange(nameof(count), count, Properties.Resources.Argument_InvalidOffLen);
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Internal/TypeExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Reflection;

namespace System.Net.Http
{
    internal static class TypeExtensions
    {
#if NETSTANDARD1_3
        private static bool EqualTo(this Type[] t1, Type[] t2)
        {
            if (t1.Length != t2.Length)
            {
                return false;
            }

            for (int idx = 0; idx < t1.Length; ++idx)
            {
                if (t1[idx] != t2[idx])
                {
                    return false;
                }
            }

            return true;
        }

        public static ConstructorInfo GetConstructor(this Type type, Type[] types)
        {
            return type.GetTypeInfo().DeclaredConstructors
                                     .Where(c => c.IsPublic)
                                     .SingleOrDefault(c => c.GetParameters()
                                                            .Select(p => p.ParameterType).ToArray().EqualTo(types));
        }
#endif

        public static Type ExtractGenericInterface(this Type queryType, Type interfaceType)
        {
            Func<Type, bool> matchesInterface = t => t.IsGenericType() && t.GetGenericTypeDefinition() == interfaceType;
            return (matchesInterface(queryType)) ? queryType : queryType.GetInterfaces().FirstOrDefault(matchesInterface);
        }

#if NETSTANDARD1_3
        public static Type[] GetGenericArguments(this Type type)
        {
            return type.GetTypeInfo().GenericTypeArguments;
        }

        public static Type[] GetInterfaces(this Type type)
        {
            return type.GetTypeInfo().ImplementedInterfaces.ToArray();
        }
#endif

#if NETSTANDARD1_3
        public static bool IsAssignableFrom(this Type type, Type c)
        {
            return type.GetTypeInfo().IsAssignableFrom(c.GetTypeInfo());
        }
#endif

        public static bool IsGenericType(this Type type)
        {
#if NETSTANDARD1_3
            return type.GetTypeInfo().IsGenericType;
#else
            return type.IsGenericType;
#endif
        }

        public static bool IsInterface(this Type type)
        {
#if NETSTANDARD1_3
            return type.GetTypeInfo().IsInterface;
#else
            return type.IsInterface;
#endif
        }

        public static bool IsValueType(this Type type)
        {
#if NETSTANDARD1_3
            return type.GetTypeInfo().IsValueType;
#else
            return type.IsValueType;
#endif
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/InvalidByteRangeException.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Headers;
using System.Runtime.Serialization;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// An exception thrown by <see cref="ByteRangeStreamContent"/> in case none of the requested ranges
    /// overlap with the current extend of the selected resource. The current extend of the resource
    /// is indicated in the ContentRange property.
    /// </summary>
    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable", Justification = "Exception is not intended to be serialized.")]
    [SuppressMessage("Microsoft.Usage", "CA2240:ImplementISerializableCorrectly", Justification = "Exception is not intended to be serialized.")]
    [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors", Justification = "The ContentRange is a required parameter.")]
    public class InvalidByteRangeException : Exception
    {
        public InvalidByteRangeException(ContentRangeHeaderValue contentRange)
        {
            Initialize(contentRange);
        }

        public InvalidByteRangeException(ContentRangeHeaderValue contentRange, string message)
            : base(message)
        {
            Initialize(contentRange);
        }

        public InvalidByteRangeException(ContentRangeHeaderValue contentRange, string message, Exception innerException)
            : base(message, innerException)
        {
            Initialize(contentRange);
        }

#if !NETSTANDARD1_3 // Exception is not serializable in netstandard1.3.
        public InvalidByteRangeException(ContentRangeHeaderValue contentRange, SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
            Initialize(contentRange);
        }
#endif

        /// <summary>
        /// The current extend of the resource indicated in terms of a ContentRange header field.
        /// </summary>
        public ContentRangeHeaderValue ContentRange { get; private set; }

        private void Initialize(ContentRangeHeaderValue contentRange)
        {
            if (contentRange == null)
            {
                throw Error.ArgumentNull("contentRange");
            }
            ContentRange = contentRange;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MimeBodyPart.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Formatting.Parsers;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Maintains information about MIME body parts parsed by <see cref="MimeMultipartBodyPartParser"/>.
    /// </summary>
    internal class MimeBodyPart : IDisposable
    {
        private static readonly Type _streamType = typeof(Stream);
        private Stream _outputStream;
        private MultipartStreamProvider _streamProvider;
        private HttpContent _parentContent;
        private HttpContent _content;
        private HttpContentHeaders _headers;

        /// <summary>
        /// Initializes a new instance of the <see cref="MimeBodyPart"/> class.
        /// </summary>
        /// <param name="streamProvider">The stream provider.</param>
        /// <param name="maxBodyPartHeaderSize">The max length of the MIME header within each MIME body part.</param>
        /// <param name="parentContent">The part's parent content</param>
        public MimeBodyPart(MultipartStreamProvider streamProvider, int maxBodyPartHeaderSize, HttpContent parentContent)
        {
            Contract.Assert(streamProvider != null);
            Contract.Assert(parentContent != null);
            _streamProvider = streamProvider;
            _parentContent = parentContent;
            Segments = new List<ArraySegment<byte>>(2);
            _headers = FormattingUtilities.CreateEmptyContentHeaders();
            HeaderParser = new InternetMessageFormatHeaderParser(
                _headers,
                maxBodyPartHeaderSize,
                ignoreHeaderValidation: true);
        }

        /// <summary>
        /// Gets the header parser.
        /// </summary>
        /// <value>
        /// The header parser.
        /// </value>
        public InternetMessageFormatHeaderParser HeaderParser { get; private set; }

        /// <summary>
        /// Gets the part's content as an HttpContent.
        /// </summary>
        /// <value>
        /// The part's content, or null if the part had no content.
        /// </value>
        public HttpContent GetCompletedHttpContent()
        {
            Contract.Assert(IsComplete);

            if (_content == null)
            {
                return null;
            }

            _headers.CopyTo(_content.Headers);
            return _content;
        }

        /// <summary>
        /// Gets the set of <see cref="ArraySegment{T}"/> pointing to the read buffer with
        /// contents of this body part.
        /// </summary>
        public List<ArraySegment<byte>> Segments { get; private set; }

        /// <summary>
        /// Gets or sets a value indicating whether the body part has been completed.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is complete; otherwise, <c>false</c>.
        /// </value>
        public bool IsComplete { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether this is the final body part.
        /// </summary>
        /// <value>
        /// <c>true</c> if this instance is complete; otherwise, <c>false</c>.
        /// </value>
        public bool IsFinal { get; set; }

        /// <summary>
        /// Writes the <paramref name="segment"/> into the part's output stream.
        /// </summary>
        /// <param name="segment">The current segment to be written to the part's output stream.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        public async Task WriteSegment(ArraySegment<byte> segment, CancellationToken cancellationToken)
        {
            var stream = GetOutputStream();
            await stream.WriteAsync(segment.Array, segment.Offset, segment.Count, cancellationToken);
        }

        /// <summary>
        /// Gets the output stream.
        /// </summary>
        /// <returns>The output stream to write the body part to.</returns>
        private Stream GetOutputStream()
        {
            if (_outputStream == null)
            {
                try
                {
                    _outputStream = _streamProvider.GetStream(_parentContent, _headers);
                }
                catch (Exception e)
                {
                    throw Error.InvalidOperation(e, Properties.Resources.ReadAsMimeMultipartStreamProviderException, _streamProvider.GetType().Name);
                }

                if (_outputStream == null)
                {
                    throw Error.InvalidOperation(Properties.Resources.ReadAsMimeMultipartStreamProviderNull, _streamProvider.GetType().Name, _streamType.Name);
                }

                if (!_outputStream.CanWrite)
                {
                    throw Error.InvalidOperation(Properties.Resources.ReadAsMimeMultipartStreamProviderReadOnly, _streamProvider.GetType().Name, _streamType.Name);
                }
                _content = new StreamContent(_outputStream);
            }

            return _outputStream;
        }

        /// <summary>
        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        protected void Dispose(bool disposing)
        {
            if (disposing)
            {
                CleanupOutputStream();
                CleanupHttpContent();
                _parentContent = null;
                HeaderParser = null;
                Segments.Clear();
            }
        }

        /// <summary>
        /// In the success case, the HttpContent is to be used after this Part has been parsed and disposed of.
        /// Only if Dispose has been called on a non-completed part, the parsed HttpContent needs to be disposed of as well.
        /// </summary>
        private void CleanupHttpContent()
        {
            if (!IsComplete && _content != null)
            {
                _content.Dispose();
            }

            _content = null;
        }

        /// <summary>
        /// Resets the output stream by either closing it or, in the case of a <see cref="MemoryStream"/> resetting
        /// position to 0 so that it can be read by the caller.
        /// </summary>
        private void CleanupOutputStream()
        {
            if (_outputStream != null)
            {
                MemoryStream output = _outputStream as MemoryStream;
                if (output != null)
                {
                    output.Position = 0;
                }
                else
                {
#if NETSTANDARD1_3
                    _outputStream.Dispose();
#else
                    _outputStream.Close();
#endif
                }

                _outputStream = null;
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartFileData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http
{
    public class MultipartFileData
    {
        public MultipartFileData(HttpContentHeaders headers, string localFileName)
        {
            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            if (localFileName == null)
            {
                throw Error.ArgumentNull("localFileName");
            }

            Headers = headers;
            LocalFileName = localFileName;
        }

        public HttpContentHeaders Headers { get; private set; }

        public string LocalFileName { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartFileStreamProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Net.Http.Headers;
using System.Net.Http.Internal;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// A <see cref="MultipartStreamProvider"/> suited for writing each MIME body parts of the MIME multipart
    /// message to a file using a <see cref="FileStream"/>.
    /// </summary>
    public class MultipartFileStreamProvider : MultipartStreamProvider
    {
        private const int MinBufferSize = 1;
        private const int DefaultBufferSize = 0x1000;

        private string _rootPath;
        private int _bufferSize = DefaultBufferSize;

        private Collection<MultipartFileData> _fileData = new Collection<MultipartFileData>();

        /// <summary>
        /// Initializes a new instance of the <see cref="MultipartFileStreamProvider"/> class.
        /// </summary>
        /// <param name="rootPath">The root path where the content of MIME multipart body parts are written to.</param>
        public MultipartFileStreamProvider(string rootPath)
            : this(rootPath, DefaultBufferSize)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MultipartFileStreamProvider"/> class.
        /// </summary>
        /// <param name="rootPath">The root path where the content of MIME multipart body parts are written to.</param>
        /// <param name="bufferSize">The number of bytes buffered for writes to a file.</param>
        public MultipartFileStreamProvider(string rootPath, int bufferSize)
        {
            if (rootPath == null)
            {
                throw Error.ArgumentNull("rootPath");
            }

            if (bufferSize < MinBufferSize)
            {
                throw Error.ArgumentMustBeGreaterThanOrEqualTo("bufferSize", bufferSize, MinBufferSize);
            }

            _rootPath = Path.GetFullPath(rootPath);
            _bufferSize = bufferSize;
        }

        /// <summary>
        /// Gets a collection containing the local files names and associated HTTP content headers of MIME 
        /// body parts written to file.
        /// </summary>
        public Collection<MultipartFileData> FileData
        {
            get { return _fileData; }
        }

        /// <summary>
        /// Gets the root path where the content of MIME multipart body parts are written to.
        /// </summary>
        protected string RootPath
        {
            get { return _rootPath; }
        }

        /// <summary>
        /// Gets the number of bytes buffered for writes to a file.
        /// </summary>
        protected int BufferSize
        {
            get { return _bufferSize; }
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Stream is closed by caller (MultipartWriteDelegatingStream is just a wrapper that calls into the inner stream.)")]
        public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
        {
            if (parent == null)
            {
                throw Error.ArgumentNull("parent");
            }

            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            string localFilePath;
            try
            {
                string filename = GetLocalFileName(headers);
                localFilePath = Path.Combine(_rootPath, Path.GetFileName(filename));
            }
            catch (Exception e)
            {
                throw Error.InvalidOperation(e, Properties.Resources.MultipartStreamProviderInvalidLocalFileName);
            }

            // Add local file name 
            MultipartFileData fileData = new MultipartFileData(headers, localFilePath);
            _fileData.Add(fileData);

            return File.Create(localFilePath, _bufferSize, FileOptions.Asynchronous);
        }

        /// <summary>
        /// Gets the name of the local file which will be combined with the root path to
        /// create an absolute file name where the contents of the current MIME body part
        /// will be stored.
        /// </summary>
        /// <param name="headers">The headers for the current MIME body part.</param>
        /// <returns>A relative filename with no path component.</returns>
        public virtual string GetLocalFileName(HttpContentHeaders headers)
        {
            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            return String.Format(CultureInfo.InvariantCulture, "BodyPart_{0}", Guid.NewGuid());
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartFormDataRemoteStreamProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.IO;
using System.Net.Http.Formatting.Internal;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// A <see cref="MultipartStreamProvider"/> implementation suited for use with HTML file uploads for writing file
    /// content to a remote storage <see cref="Stream"/>. The stream provider looks at the <b>Content-Disposition</b>
    /// header field and determines an output remote <see cref="Stream"/> based on the presence of a <b>filename</b>
    /// parameter. If a <b>filename</b> parameter is present in the <b>Content-Disposition</b> header field, then the
    /// body part is written to a remote <see cref="Stream"/> provided by <see cref="GetRemoteStream"/>.
    /// Otherwise it is written to a <see cref="MemoryStream"/>.
    /// </summary>
    public abstract class MultipartFormDataRemoteStreamProvider : MultipartStreamProvider
    {
        private CancellationToken _cancellationToken = CancellationToken.None;

        /// <summary>
        /// Initializes a new instance of the <see cref="MultipartFormDataRemoteStreamProvider"/> class.
        /// </summary>
        protected MultipartFormDataRemoteStreamProvider()
        {
            FormData = HttpValueCollection.Create();
            FileData = new Collection<MultipartRemoteFileData>();
        }

        /// <summary>
        /// Gets a collection of file data passed as part of the multipart form data.
        /// </summary>
        public Collection<MultipartRemoteFileData> FileData { get; private set; }

        /// <summary>
        /// Gets a <see cref="NameValueCollection"/> of form data passed as part of the multipart form data.
        /// </summary>
        public NameValueCollection FormData { get; private set; }

        /// <summary>
        /// Provides a <see cref="RemoteStreamInfo"/> for <see cref="GetStream"/>. Override this method to provide a
        /// remote stream to which the data should be written.
        /// </summary>
        /// <param name="parent">The parent <see cref="HttpContent"/> MIME multipart instance.</param>
        /// <param name="headers">The header fields describing the body part's content. </param>
        /// <returns>
        /// A result specifying a remote stream where the file will be written to and a location where the file can be
        /// accessed. It cannot be null and the stream must be writable.
        /// </returns>
        public abstract RemoteStreamInfo GetRemoteStream(HttpContent parent, HttpContentHeaders headers);

        /// <inheritdoc />
        public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
        {
            if (MultipartFormDataStreamProviderHelper.IsFileContent(parent, headers))
            {
                RemoteStreamInfo remoteStreamInfo = GetRemoteStream(parent, headers);
                if (remoteStreamInfo == null)
                {
                    throw Error.InvalidOperation(Properties.Resources.RemoteStreamInfoCannotBeNull,
                        "GetRemoteStream", GetType().Name);
                }
                FileData.Add(new MultipartRemoteFileData(headers, remoteStreamInfo.Location, remoteStreamInfo.FileName));

                return remoteStreamInfo.RemoteStream;
            }

            return new MemoryStream();
        }

        /// <summary>
        /// Read the non-file contents as form data.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the post processing.</returns>
        public override Task ExecutePostProcessingAsync()
        {
            // In consistency with existing MultipartFormDataStreamProvider,
            // this method predates support for cancellation, and we need to make sure it is always invoked when
            // ExecutePostProcessingAsync is called for compatability.
            return MultipartFormDataStreamProviderHelper.ReadFormDataAsync(Contents, FormData,
                _cancellationToken);
        }

        /// <summary>
        /// Read the non-file contents as form data.
        /// </summary>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task"/> representing the post processing.</returns>
        public override Task ExecutePostProcessingAsync(CancellationToken cancellationToken)
        {
            _cancellationToken = cancellationToken;
            return ExecutePostProcessingAsync();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartFormDataStreamProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.IO;
using System.Net.Http.Formatting.Internal;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;

namespace System.Net.Http
{
    /// <summary>
    /// A <see cref="MultipartStreamProvider"/> implementation suited for use with HTML file uploads for writing file
    /// content to a <see cref="FileStream"/>. The stream provider looks at the <b>Content-Disposition</b> header
    /// field and determines an output <see cref="Stream"/> based on the presence of a <b>filename</b> parameter.
    /// If a <b>filename</b> parameter is present in the <b>Content-Disposition</b> header field then the body
    /// part is written to a <see cref="FileStream"/>, otherwise it is written to a <see cref="MemoryStream"/>.
    /// This makes it convenient to process MIME Multipart HTML Form data which is a combination of form
    /// data and file content.
    /// </summary>
    public class MultipartFormDataStreamProvider : MultipartFileStreamProvider
    {
        // pass around cancellation token through field to maintain backward compat.
        private CancellationToken _cancellationToken;

        /// <summary>
        /// Initializes a new instance of the <see cref="MultipartFormDataStreamProvider"/> class.
        /// </summary>
        /// <param name="rootPath">The root path where the content of MIME multipart body parts are written to.</param>
        public MultipartFormDataStreamProvider(string rootPath)
            : base(rootPath)
        {
            FormData = HttpValueCollection.Create();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="MultipartFormDataStreamProvider"/> class.
        /// </summary>
        /// <param name="rootPath">The root path where the content of MIME multipart body parts are written to.</param>
        /// <param name="bufferSize">The number of bytes buffered for writes to the file.</param>
        public MultipartFormDataStreamProvider(string rootPath, int bufferSize)
            : base(rootPath, bufferSize)
        {
            FormData = HttpValueCollection.Create();
        }

        /// <summary>
        /// Gets a <see cref="NameValueCollection"/> of form data passed as part of the multipart form data.
        /// </summary>
        public NameValueCollection FormData { get; private set; }

        /// <summary>
        /// This body part stream provider examines the headers provided by the MIME multipart parser
        /// and decides whether it should return a file stream or a memory stream for the body part to be
        /// written to.
        /// </summary>
        /// <param name="parent">The parent MIME multipart HttpContent instance.</param>
        /// <param name="headers">Header fields describing the body part</param>
        /// <returns>The <see cref="Stream"/> instance where the message body part is written to.</returns>
        public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
        {
            if (MultipartFormDataStreamProviderHelper.IsFileContent(parent, headers))
            {
                return base.GetStream(parent, headers);
            }

            return new MemoryStream();
        }

        /// <summary>
        /// Read the non-file contents as form data.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the post processing.</returns>
        public override Task ExecutePostProcessingAsync()
        {
            // This method predates support for cancellation, and we need to make sure it is always invoked when
            // ExecutePostProcessingAsync is called for compatability.
            return MultipartFormDataStreamProviderHelper.ReadFormDataAsync(Contents, FormData,
                _cancellationToken);
        }

        /// <summary>
        /// Read the non-file contents as form data.
        /// </summary>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task"/> representing the post processing.</returns>
        public override Task ExecutePostProcessingAsync(CancellationToken cancellationToken)
        {
            _cancellationToken = cancellationToken;
            return ExecutePostProcessingAsync();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartFormDataStreamProviderHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    internal static class MultipartFormDataStreamProviderHelper
    {
        public static bool IsFileContent(HttpContent parent, HttpContentHeaders headers)
        {
            if (parent == null)
            {
                throw Error.ArgumentNull("parent");
            }

            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            // For form data, Content-Disposition header is a requirement.
            ContentDispositionHeaderValue contentDisposition = headers.ContentDisposition;
            if (contentDisposition == null)
            {
                // If no Content-Disposition header was present.
                throw Error.InvalidOperation(Properties.Resources.MultipartFormDataStreamProviderNoContentDisposition,
                    "Content-Disposition");
            }

            // The file name's existence indicates it is a file data.
            if (!String.IsNullOrEmpty(contentDisposition.FileName))
            {
                return true;
            }

            return false;
        }

        /// <summary>
        /// Read the non-file contents as form data.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the post processing.</returns>
        public static async Task ReadFormDataAsync(Collection<HttpContent> contents,
            NameValueCollection formData, CancellationToken cancellationToken)
        {
            // Find instances of HttpContent for which we created a memory stream and read them asynchronously
            // to get the string content and then add that as form data
            foreach (HttpContent content in contents)
            {
                ContentDispositionHeaderValue contentDisposition = content.Headers.ContentDisposition;
                // If FileName is null or empty, the content is form data and will be processed.
                if (String.IsNullOrEmpty(contentDisposition.FileName))
                {
                    // Extract name from Content-Disposition header. We know from earlier that the header is present.
                    string formFieldName = FormattingUtilities.UnquoteToken(contentDisposition.Name) ?? String.Empty;

                    // Read the contents as string data and add to form data
                    cancellationToken.ThrowIfCancellationRequested();
                    string formFieldValue = await content.ReadAsStringAsync();
                    formData.Add(formFieldName, formFieldValue);
                }
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartMemoryStreamProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Provides a <see cref="MultipartStreamProvider"/> implementation that returns a <see cref="MemoryStream"/> instance.
    /// This facilitates deserialization or other manipulation of the contents in memory.
    /// </summary>
    public class MultipartMemoryStreamProvider : MultipartStreamProvider
    {
        /// <summary>
        /// This <see cref="MultipartStreamProvider"/> implementation returns a <see cref="MemoryStream"/> instance.
        /// This facilitates deserialization or other manipulation of the contents in memory. 
        /// </summary>
        public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
        {
            if (parent == null)
            {
                throw Error.ArgumentNull("parent");
            }

            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            return new MemoryStream();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartRelatedStreamProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.IO;
using System.Linq;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// An <see cref="MultipartStreamProvider"/> suited for reading MIME body parts following the
    /// <c>multipart/related</c> media type as defined in RFC 2387 (see http://www.ietf.org/rfc/rfc2387.txt).
    /// </summary>
    public class MultipartRelatedStreamProvider : MultipartStreamProvider
    {
        private const string RelatedSubType = "related";
        private const string ContentID = "Content-ID";
        private const string StartParameter = "Start";

        private HttpContent _rootContent;
        private HttpContent _parent;

        /// <summary>
        /// Gets the <see cref="HttpContent"/> instance that has been marked as the <c>root</c> content in the
        /// MIME multipart related message using the <c>start</c> parameter. If no <c>start</c> parameter is
        /// present then pick the first of the children.
        /// </summary>
        public HttpContent RootContent
        {
            get
            {
                if (_rootContent == null)
                {
                    _rootContent = FindRootContent(_parent, Contents);
                }

                return _rootContent;
            }
        }

        public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
        {
            if (parent == null)
            {
                throw Error.ArgumentNull("parent");
            }

            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            // See if we need to remember the parent to be able to determine the root content
            if (_parent == null)
            {
                _parent = parent;
            }

            return new MemoryStream();
        }

        /// <summary>
        /// Looks for the "start" parameter of the parent's content type and then finds the corresponding
        /// child HttpContent with a matching Content-ID header field.
        /// </summary>
        /// <returns>The matching child or null if none found.</returns>
        private static HttpContent FindRootContent(HttpContent parent, IEnumerable<HttpContent> children)
        {
            Contract.Assert(children != null);

            // Find 'start' parameter from parent content type. The value is used
            // to identify the MIME body with the corresponding Content-ID header value.
            NameValueHeaderValue startNameValue = FindMultipartRelatedParameter(parent, StartParameter);
            if (startNameValue == null)
            {
                // If we didn't find a "start" parameter then take the first child.
                return children.FirstOrDefault();
            }

            // Look for the child with a Content-ID header that corresponds to the "start" value.
            // If no matching child is found then we return null.
            string startValue = FormattingUtilities.UnquoteToken(startNameValue.Value);
            return children.FirstOrDefault(
                content =>
                {
                    IEnumerable<string> values;
                    if (content.Headers.TryGetValues(ContentID, out values))
                    {
                        return String.Equals(
                            FormattingUtilities.UnquoteToken(values.ElementAt(0)),
                            startValue,
                            StringComparison.OrdinalIgnoreCase);
                    }

                    return false;
                });
        }

        /// <summary>
        /// Looks for a parameter in the <see cref="MediaTypeHeaderValue"/>.
        /// </summary>
        /// <returns>The matching parameter or null if none found.</returns>
        private static NameValueHeaderValue FindMultipartRelatedParameter(HttpContent content, string parameterName)
        {
            // If no parent then we are done
            if (content == null)
            {
                return null;
            }

            // Check that we have a parent content type and that it is indeed multipart/related
            MediaTypeHeaderValue parentContentType = content.Headers.ContentType;
            if (parentContentType == null || !content.IsMimeMultipartContent(RelatedSubType))
            {
                return null;
            }

            // Look for parameter
            return parentContentType.Parameters.FirstOrDefault(nvp => String.Equals(nvp.Name, parameterName, StringComparison.OrdinalIgnoreCase));
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartRemoteFileData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Represents a multipart file data for remote storage.
    /// </summary>
    public class MultipartRemoteFileData
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="MultipartRemoteFileData"/> class.
        /// </summary>
        /// <param name="headers">The headers of the multipart file data.</param>
        /// <param name="location">The remote file's location.</param>
        /// <param name="fileName">The remote file's name.</param>
        public MultipartRemoteFileData(HttpContentHeaders headers, string location, string fileName)
        {
            if (headers == null)
            {
                throw Error.ArgumentNull("headers");
            }

            if (location == null)
            {
                throw Error.ArgumentNull("location");
            }

            if (fileName == null)
            {
                throw Error.ArgumentNull("fileName");
            }

            FileName = fileName;
            Headers = headers;
            Location = location;
        }

        /// <summary>
        /// Gets the remote file's name.
        /// </summary>
        public string FileName { get; private set; }

        /// <summary>
        /// Gets the headers of the multipart file data.
        /// </summary>
        public HttpContentHeaders Headers { get; private set; }

        /// <summary>
        /// Gets the remote file's location.
        /// </summary>
        public string Location { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/MultipartStreamProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.IO;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;

namespace System.Net.Http
{
    /// <summary>
    /// An <see cref="MultipartStreamProvider"/> implementation examines the headers provided by the MIME multipart parser
    /// as part of the MIME multipart extension methods (see <see cref="HttpContentMultipartExtensions"/>) and decides 
    /// what kind of stream to return for the body part to be written to.
    /// </summary>
    public abstract class MultipartStreamProvider
    {
        private Collection<HttpContent> _contents = new Collection<HttpContent>();

        /// <summary>
        /// Initializes a new instance of the <see cref="MultipartStreamProvider"/> class.
        /// </summary>
        protected MultipartStreamProvider()
        {
        }

        /// <summary>
        /// Gets the collection of <see cref="HttpContent"/> instances where each instance represents a MIME body part.
        /// </summary>
        public Collection<HttpContent> Contents
        {
            get { return _contents; }
        }

        /// <summary>
        /// When a MIME multipart body part has been parsed this method is called to get a stream for where to write the body part to.
        /// </summary>
        /// <param name="parent">The parent <see cref="HttpContent"/> MIME multipart instance.</param>
        /// <param name="headers">The header fields describing the body parts content. Looking for header fields such as 
        /// Content-Type and Content-Disposition can help provide the appropriate stream. In addition to using the information
        /// in the provided header fields, it is also possible to add new header fields or modify existing header fields. This can
        /// be useful to get around situations where the Content-type may say <b>application/octet-stream</b> but based on
        /// analyzing the <b>Content-Disposition</b> header field it is found that the content in fact is <b>application/json</b>, for example.</param>
        /// <returns>A stream instance where the contents of a body part will be written to.</returns>
        public abstract Stream GetStream(HttpContent parent, HttpContentHeaders headers);

        /// <summary>
        /// Immediately upon reading the last MIME body part but before completing the read task, this method is 
        /// called to enable the <see cref="MultipartStreamProvider"/> to do any post processing on the <see cref="HttpContent"/>
        /// instances that have been read. For example, it can be used to copy the data to another location, or perform
        /// some other kind of post processing on the data before completing the read operation.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the post processing.</returns>
        public virtual Task ExecutePostProcessingAsync()
        {
            return TaskHelpers.Completed();
        }

        /// <summary>
        /// Immediately upon reading the last MIME body part but before completing the read task, this method is 
        /// called to enable the <see cref="MultipartStreamProvider"/> to do any post processing on the <see cref="HttpContent"/>
        /// instances that have been read. For example, it can be used to copy the data to another location, or perform
        /// some other kind of post processing on the data before completing the read operation.
        /// </summary>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task"/> representing the post processing.</returns>
        public virtual Task ExecutePostProcessingAsync(CancellationToken cancellationToken)
        {
            // Call the other overload to maintain backward compatibility.
            return ExecutePostProcessingAsync();
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/ObjectContent.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Contains a value as well as an associated <see cref="MediaTypeFormatter"/> that will be
    /// used to serialize the value when writing this content.
    /// </summary>
    public class ObjectContent : HttpContent
    {
        private object _value;
        private readonly MediaTypeFormatter _formatter;

        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectContent"/> class.
        /// </summary>
        /// <param name="type">The type of object this instance will contain.</param>
        /// <param name="value">The value of the object this instance will contain.</param>
        /// <param name="formatter">The formatter to use when serializing the value.</param>
        public ObjectContent(Type type, object value, MediaTypeFormatter formatter)
            : this(type, value, formatter, (MediaTypeHeaderValue)null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectContent"/> class.
        /// </summary>
        /// <param name="type">The type of object this instance will contain.</param>
        /// <param name="value">The value of the object this instance will contain.</param>
        /// <param name="formatter">The formatter to use when serializing the value.</param>
        /// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        public ObjectContent(Type type, object value, MediaTypeFormatter formatter, string mediaType)
            : this(type, value, formatter, BuildHeaderValue(mediaType))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectContent"/> class.
        /// </summary>
        /// <param name="type">The type of object this instance will contain.</param>
        /// <param name="value">The value of the object this instance will contain.</param>
        /// <param name="formatter">The formatter to use when serializing the value.</param>
        /// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        public ObjectContent(Type type, object value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            if (!formatter.CanWriteType(type))
            {
                throw Error.InvalidOperation(Properties.Resources.ObjectContent_FormatterCannotWriteType, formatter.GetType().FullName, type.Name);
            }

            _formatter = formatter;
            ObjectType = type;

            VerifyAndSetObject(value);
            _formatter.SetDefaultContentHeaders(type, Headers, mediaType);
        }

        /// <summary>
        /// Gets the type of object managed by this <see cref="ObjectContent"/> instance.
        /// </summary>
        public Type ObjectType { get; private set; }

        /// <summary>
        /// The <see cref="MediaTypeFormatter">formatter</see> associated with this content instance.
        /// </summary>
        public MediaTypeFormatter Formatter
        {
            get { return _formatter; }
        }

        /// <summary>
        /// Gets or sets the value of the current <see cref="ObjectContent"/>.
        /// </summary>
        public object Value
        {
            get { return _value; }
            set { _value = value; }
        }

        internal static MediaTypeHeaderValue BuildHeaderValue(string mediaType)
        {
            return mediaType != null ? new MediaTypeHeaderValue(mediaType) : null;
        }

        /// <summary>
        /// Asynchronously serializes the object's content to the given <paramref name="stream"/>.
        /// </summary>
        /// <param name="stream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="context">The associated <see cref="TransportContext"/>.</param>
        /// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
        {
            return _formatter.WriteToStreamAsync(ObjectType, Value, stream, this, context);
        }

        /// <summary>
        /// Computes the length of the stream if possible.
        /// </summary>
        /// <param name="length">The computed length of the stream.</param>
        /// <returns><c>true</c> if the length has been computed; otherwise <c>false</c>.</returns>
        protected override bool TryComputeLength(out long length)
        {
            length = -1;
            return false;
        }

        private static bool IsTypeNullable(Type type)
        {
            return !type.IsValueType() ||
                   (type.IsGenericType() &&
                    type.GetGenericTypeDefinition() == typeof(Nullable<>));
        }

        private void VerifyAndSetObject(object value)
        {
            Contract.Assert(ObjectType != null, "Type cannot be null");

            if (value == null)
            {
                // Null may not be assigned to value types (unless Nullable<T>)
                if (!IsTypeNullable(ObjectType))
                {
                    throw Error.InvalidOperation(Properties.Resources.CannotUseNullValueType, typeof(ObjectContent).Name, ObjectType.Name);
                }
            }
            else
            {
                // Non-null objects must be a type assignable to Type
                Type objectType = value.GetType();
                if (!ObjectType.IsAssignableFrom(objectType))
                {
                    throw Error.Argument("value", Properties.Resources.ObjectAndTypeDisagree, objectType.Name, ObjectType.Name);
                }
            }

            _value = value;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/ObjectContentOfT.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;
using System.Net.Http.Headers;

namespace System.Net.Http
{
    /// <summary>
    /// Generic form of <see cref="ObjectContent"/>.
    /// </summary>
    /// <typeparam name="T">The type of object this <see cref="ObjectContent"/> class will contain.</typeparam>
    public class ObjectContent<T> : ObjectContent
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectContent{T}"/> class.
        /// </summary>
        /// <param name="value">The value of the object this instance will contain.</param>
        /// <param name="formatter">The formatter to use when serializing the value.</param>
        public ObjectContent(T value, MediaTypeFormatter formatter)
            : this(value, formatter, (MediaTypeHeaderValue)null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectContent{T}"/> class.
        /// </summary>
        /// <param name="value">The value of the object this instance will contain.</param>
        /// <param name="formatter">The formatter to use when serializing the value.</param>
        /// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        public ObjectContent(T value, MediaTypeFormatter formatter, string mediaType)
            : this(value, formatter, BuildHeaderValue(mediaType))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ObjectContent{T}"/> class.
        /// </summary>
        /// <param name="value">The value of the object this instance will contain.</param>
        /// <param name="formatter">The formatter to use when serializing the value.</param>
        /// <param name="mediaType">The authoritative value of the content's Content-Type header. Can be <c>null</c> in which case the
        /// <paramref name="formatter">formatter's</paramref> default content type will be used.</param>
        public ObjectContent(T value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
            : base(typeof(T), value, formatter, mediaType)
        {
        }
    }
}

================================================
FILE: src/System.Net.Http.Formatting/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("System.Net.Http.Formatting")]
[assembly: AssemblyDescription("")]
[assembly: Guid("7fa1ae84-36e2-46b6-812c-c985a8e65e9a")]

#if NETSTANDARD2_0
[assembly: InternalsVisibleTo("System.Net.Http.Formatting.ns2_0.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
#elif NETSTANDARD1_3
[assembly: InternalsVisibleTo("Microsoft.TestCommon, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Net.Http.Formatting.ns1_3.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
#else
[assembly: InternalsVisibleTo("System.Net.Http.Formatting.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Net.Http.Formatting.Test.Integration, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
#endif


================================================
FILE: src/System.Net.Http.Formatting/Properties/Resources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Net.Http.Properties {
    using System;
    using System.Reflection;


    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {

        private static global::System.Resources.ResourceManager resourceMan;

        private static global::System.Globalization.CultureInfo resourceCulture;

        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }

        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
#if NETSTANDARD1_3
                    var assembly = typeof(Resources).GetTypeInfo().Assembly;
#else
                    var assembly = typeof(Resources).Assembly;
#endif
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Net.Http.Properties.Resources", assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }

        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection..
        /// </summary>
        internal static string Argument_InvalidOffLen {
            get {
                return ResourceManager.GetString("Argument_InvalidOffLen", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Async Callback threw an exception..
        /// </summary>
        internal static string AsyncResult_CallbackThrewException {
            get {
                return ResourceManager.GetString("AsyncResult_CallbackThrewException", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The IAsyncResult implementation &apos;{0}&apos; tried to complete a single operation multiple times. This could be caused by an incorrect application IAsyncResult implementation or other extensibility code, such as an IAsyncResult that returns incorrect CompletedSynchronously values or invokes the AsyncCallback multiple times..
        /// </summary>
        internal static string AsyncResult_MultipleCompletes {
            get {
                return ResourceManager.GetString("AsyncResult_MultipleCompletes", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to End cannot be called twice on an AsyncResult..
        /// </summary>
        internal static string AsyncResult_MultipleEnds {
            get {
                return ResourceManager.GetString("AsyncResult_MultipleEnds", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to An incorrect IAsyncResult was provided to an &apos;End&apos; method. The IAsyncResult object passed to &apos;End&apos; must be the one returned from the matching &apos;Begin&apos; or passed to the callback provided to &apos;Begin&apos;..
        /// </summary>
        internal static string AsyncResult_ResultMismatch {
            get {
                return ResourceManager.GetString("AsyncResult_ResultMismatch", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Found zero byte ranges. There must be at least one byte range provided..
        /// </summary>
        internal static string ByteRangeStreamContentNoRanges {
            get {
                return ResourceManager.GetString("ByteRangeStreamContentNoRanges", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The range unit &apos;{0}&apos; is not valid. The range must have a unit of &apos;{1}&apos;..
        /// </summary>
        internal static string ByteRangeStreamContentNotBytesRange {
            get {
                return ResourceManager.GetString("ByteRangeStreamContentNotBytesRange", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The stream over which &apos;{0}&apos; provides a range view must have a length greater than or equal to 1..
        /// </summary>
        internal static string ByteRangeStreamEmpty {
            get {
                return ResourceManager.GetString("ByteRangeStreamEmpty", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;From&apos; value of the range must be less than or equal to {0}..
        /// </summary>
        internal static string ByteRangeStreamInvalidFrom {
            get {
                return ResourceManager.GetString("ByteRangeStreamInvalidFrom", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to An attempt was made to move the position before the beginning of the stream..
        /// </summary>
        internal static string ByteRangeStreamInvalidOffset {
            get {
                return ResourceManager.GetString("ByteRangeStreamInvalidOffset", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to None of the requested ranges ({0}) overlap with the current extent of the selected resource..
        /// </summary>
        internal static string ByteRangeStreamNoneOverlap {
            get {
                return ResourceManager.GetString("ByteRangeStreamNoneOverlap", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The requested range ({0}) does not overlap with the current extent of the selected resource..
        /// </summary>
        internal static string ByteRangeStreamNoOverlap {
            get {
                return ResourceManager.GetString("ByteRangeStreamNoOverlap", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The stream over which &apos;{0}&apos; provides a range view must be seekable..
        /// </summary>
        internal static string ByteRangeStreamNotSeekable {
            get {
                return ResourceManager.GetString("ByteRangeStreamNotSeekable", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to This is a read-only stream..
        /// </summary>
        internal static string ByteRangeStreamReadOnly {
            get {
                return ResourceManager.GetString("ByteRangeStreamReadOnly", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A null &apos;{0}&apos; is not valid..
        /// </summary>
        internal static string CannotHaveNullInList {
            get {
                return ResourceManager.GetString("CannotHaveNullInList", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; of &apos;{1}&apos; cannot be used as a supported media type because it is a media range..
        /// </summary>
        internal static string CannotUseMediaRangeForSupportedMediaType {
            get {
                return ResourceManager.GetString("CannotUseMediaRangeForSupportedMediaType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; type cannot accept a null value for the value type &apos;{1}&apos;..
        /// </summary>
        internal static string CannotUseNullValueType {
            get {
                return ResourceManager.GetString("CannotUseNullValueType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The specified value is not a valid cookie name..
        /// </summary>
        internal static string CookieInvalidName {
            get {
                return ResourceManager.GetString("CookieInvalidName", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Cookie cannot be null..
        /// </summary>
        internal static string CookieNull {
            get {
                return ResourceManager.GetString("CookieNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; list is invalid because it contains one or more null items..
        /// </summary>
        internal static string DelegatingHandlerArrayContainsNullItem {
            get {
                return ResourceManager.GetString("DelegatingHandlerArrayContainsNullItem", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; list is invalid because the property &apos;{1}&apos; of &apos;{2}&apos; is not null..
        /// </summary>
        internal static string DelegatingHandlerArrayHasNonNullInnerHandler {
            get {
                return ResourceManager.GetString("DelegatingHandlerArrayHasNonNullInnerHandler", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error reading HTML form URL-encoded data stream..
        /// </summary>
        internal static string ErrorReadingFormUrlEncodedStream {
            get {
                return ResourceManager.GetString("ErrorReadingFormUrlEncodedStream", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Mismatched types at node &apos;{0}&apos;..
        /// </summary>
        internal static string FormUrlEncodedMismatchingTypes {
            get {
                return ResourceManager.GetString("FormUrlEncodedMismatchingTypes", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error parsing HTML form URL-encoded data, byte {0}..
        /// </summary>
        internal static string FormUrlEncodedParseError {
            get {
                return ResourceManager.GetString("FormUrlEncodedParseError", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid HTTP status code: &apos;{0}&apos;. The status code must be between {1} and {2}..
        /// </summary>
        internal static string HttpInvalidStatusCode {
            get {
                return ResourceManager.GetString("HttpInvalidStatusCode", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid HTTP version: &apos;{0}&apos;. The version must start with the characters &apos;{1}&apos;..
        /// </summary>
        internal static string HttpInvalidVersion {
            get {
                return ResourceManager.GetString("HttpInvalidVersion", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; of the &apos;{1}&apos; has already been read..
        /// </summary>
        internal static string HttpMessageContentAlreadyRead {
            get {
                return ResourceManager.GetString("HttpMessageContentAlreadyRead", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; must be seekable in order to create an &apos;{1}&apos; instance containing an entity body.  .
        /// </summary>
        internal static string HttpMessageContentStreamMustBeSeekable {
            get {
                return ResourceManager.GetString("HttpMessageContentStreamMustBeSeekable", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error reading HTTP message..
        /// </summary>
        internal static string HttpMessageErrorReading {
            get {
                return ResourceManager.GetString("HttpMessageErrorReading", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid &apos;{0}&apos; instance provided. It does not have a content type header with a value of &apos;{1}&apos;..
        /// </summary>
        internal static string HttpMessageInvalidMediaType {
            get {
                return ResourceManager.GetString("HttpMessageInvalidMediaType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to HTTP Request URI cannot be an empty string..
        /// </summary>
        internal static string HttpMessageParserEmptyUri {
            get {
                return ResourceManager.GetString("HttpMessageParserEmptyUri", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error parsing HTTP message header byte {0} of message {1}..
        /// </summary>
        internal static string HttpMessageParserError {
            get {
                return ResourceManager.GetString("HttpMessageParserError", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to An invalid number of &apos;{0}&apos; header fields were present in the HTTP Request. It must contain exactly one &apos;{0}&apos; header field but found {1}..
        /// </summary>
        internal static string HttpMessageParserInvalidHostCount {
            get {
                return ResourceManager.GetString("HttpMessageParserInvalidHostCount", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid URI scheme: &apos;{0}&apos;. The URI scheme must be a valid &apos;{1}&apos; scheme..
        /// </summary>
        internal static string HttpMessageParserInvalidUriScheme {
            get {
                return ResourceManager.GetString("HttpMessageParserInvalidUriScheme", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid array at node &apos;{0}&apos;..
        /// </summary>
        internal static string InvalidArrayInsert {
            get {
                return ResourceManager.GetString("InvalidArrayInsert", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Traditional style array without &apos;[]&apos; is not supported with nested object at location {0}..
        /// </summary>
        internal static string JQuery13CompatModeNotSupportNestedJson {
            get {
                return ResourceManager.GetString("JQuery13CompatModeNotSupportNestedJson", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Unable to validate types on this platform when {0} is &apos;true&apos;. Please reset {0} or move to a supported platform, one where the &apos;netstandard2.0&apos; assembly is usable..
        /// </summary>
        internal static string JsonMediaTypeFormatter_DCS_NotSupported {
            get {
                return ResourceManager.GetString("JsonMediaTypeFormatter_DCS_NotSupported", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; method returned null. It must return a JSON serializer instance..
        /// </summary>
        internal static string JsonSerializerFactoryReturnedNull {
            get {
                return ResourceManager.GetString("JsonSerializerFactoryReturnedNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; method threw an exception when attempting to create a JSON serializer..
        /// </summary>
        internal static string JsonSerializerFactoryThrew {
            get {
                return ResourceManager.GetString("JsonSerializerFactoryThrew", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The maximum read depth ({0}) has been exceeded because the form url-encoded data being read has more levels of nesting than is allowed..
        /// </summary>
        internal static string MaxDepthExceeded {
            get {
                return ResourceManager.GetString("MaxDepthExceeded", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The number of keys in a NameValueCollection has exceeded the limit of &apos;{0}&apos;. You can adjust it by modifying the MaxHttpCollectionKeys property on the &apos;{1}&apos; class..
        /// </summary>
        internal static string MaxHttpCollectionKeyLimitReached {
            get {
                return ResourceManager.GetString("MaxHttpCollectionKeyLimitReached", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error parsing BSON data; unable to read content as a {0}..
        /// </summary>
        internal static string MediaTypeFormatter_BsonParseError_MissingData {
            get {
                return ResourceManager.GetString("MediaTypeFormatter_BsonParseError_MissingData", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error parsing BSON data; unexpected dictionary content: {0} entries, first key &apos;{1}&apos;..
        /// </summary>
        internal static string MediaTypeFormatter_BsonParseError_UnexpectedData {
            get {
                return ResourceManager.GetString("MediaTypeFormatter_BsonParseError_UnexpectedData", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; method returned null. It must return a JSON reader instance..
        /// </summary>
        internal static string MediaTypeFormatter_JsonReaderFactoryReturnedNull {
            get {
                return ResourceManager.GetString("MediaTypeFormatter_JsonReaderFactoryReturnedNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; method returned null. It must return a JSON writer instance..
        /// </summary>
        internal static string MediaTypeFormatter_JsonWriterFactoryReturnedNull {
            get {
                return ResourceManager.GetString("MediaTypeFormatter_JsonWriterFactoryReturnedNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The media type formatter of type &apos;{0}&apos; does not support reading because it does not implement the ReadFromStreamAsync method..
        /// </summary>
        internal static string MediaTypeFormatterCannotRead {
            get {
                return ResourceManager.GetString("MediaTypeFormatterCannotRead", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The media type formatter of type &apos;{0}&apos; does not support reading because it does not implement the ReadFromStream method..
        /// </summary>
        internal static string MediaTypeFormatterCannotReadSync {
            get {
                return ResourceManager.GetString("MediaTypeFormatterCannotReadSync", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The media type formatter of type &apos;{0}&apos; does not support writing because it does not implement the WriteToStreamAsync method..
        /// </summary>
        internal static string MediaTypeFormatterCannotWrite {
            get {
                return ResourceManager.GetString("MediaTypeFormatterCannotWrite", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The media type formatter of type &apos;{0}&apos; does not support writing because it does not implement the WriteToStream method..
        /// </summary>
        internal static string MediaTypeFormatterCannotWriteSync {
            get {
                return ResourceManager.GetString("MediaTypeFormatterCannotWriteSync", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to No encoding found for media type formatter &apos;{0}&apos;. There must be at least one supported encoding registered in order for the media type formatter to read or write content..
        /// </summary>
        internal static string MediaTypeFormatterNoEncoding {
            get {
                return ResourceManager.GetString("MediaTypeFormatterNoEncoding", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to MIME multipart boundary cannot end with an empty space..
        /// </summary>
        internal static string MimeMultipartParserBadBoundary {
            get {
                return ResourceManager.GetString("MimeMultipartParserBadBoundary", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Did not find required &apos;{0}&apos; header field in MIME multipart body part..
        /// </summary>
        internal static string MultipartFormDataStreamProviderNoContentDisposition {
            get {
                return ResourceManager.GetString("MultipartFormDataStreamProviderNoContentDisposition", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Could not determine a valid local file name for the multipart body part..
        /// </summary>
        internal static string MultipartStreamProviderInvalidLocalFileName {
            get {
                return ResourceManager.GetString("MultipartStreamProviderInvalidLocalFileName", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Nested bracket is not valid for &apos;{0}&apos; data at position {1}..
        /// </summary>
        internal static string NestedBracketNotValid {
            get {
                return ResourceManager.GetString("NestedBracketNotValid", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to A non-null request URI must be provided to determine if a &apos;{0}&apos; matches a given request or response message..
        /// </summary>
        internal static string NonNullUriRequiredForMediaTypeMapping {
            get {
                return ResourceManager.GetString("NonNullUriRequiredForMediaTypeMapping", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to No MediaTypeFormatter is available to read an object of type &apos;{0}&apos; from content with media type &apos;{1}&apos;..
        /// </summary>
        internal static string NoReadSerializerAvailable {
            get {
                return ResourceManager.GetString("NoReadSerializerAvailable", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Stream does not support reading..
        /// </summary>
        internal static string NotSupported_UnreadableStream {
            get {
                return ResourceManager.GetString("NotSupported_UnreadableStream", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Stream does not support seeking..
        /// </summary>
        internal static string NotSupported_UnseekableStream {
            get {
                return ResourceManager.GetString("NotSupported_UnseekableStream", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Stream does not support writing..
        /// </summary>
        internal static string NotSupported_UnwritableStream {
            get {
                return ResourceManager.GetString("NotSupported_UnwritableStream", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to An object of type &apos;{0}&apos; cannot be used with a type parameter of &apos;{1}&apos;..
        /// </summary>
        internal static string ObjectAndTypeDisagree {
            get {
                return ResourceManager.GetString("ObjectAndTypeDisagree", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The configured formatter &apos;{0}&apos; cannot write an object of type &apos;{1}&apos;..
        /// </summary>
        internal static string ObjectContent_FormatterCannotWriteType {
            get {
                return ResourceManager.GetString("ObjectContent_FormatterCannotWriteType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Cannot access a closed stream..
        /// </summary>
        internal static string ObjectDisposed_StreamClosed {
            get {
                return ResourceManager.GetString("ObjectDisposed_StreamClosed", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Query string name cannot be null..
        /// </summary>
        internal static string QueryStringNameShouldNotNull {
            get {
                return ResourceManager.GetString("QueryStringNameShouldNotNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Unexpected end of HTTP message stream. HTTP message is not complete..
        /// </summary>
        internal static string ReadAsHttpMessageUnexpectedTermination {
            get {
                return ResourceManager.GetString("ReadAsHttpMessageUnexpectedTermination", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid &apos;{0}&apos; instance provided. It does not have a &apos;{1}&apos; content-type header with a &apos;{2}&apos; parameter..
        /// </summary>
        internal static string ReadAsMimeMultipartArgumentNoBoundary {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartArgumentNoBoundary", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid &apos;{0}&apos; instance provided. It does not have a content-type header value. &apos;{0}&apos; instances must have a content-type header starting with &apos;{1}&apos;..
        /// </summary>
        internal static string ReadAsMimeMultipartArgumentNoContentType {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartArgumentNoContentType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Invalid &apos;{0}&apos; instance provided. It does not have a content type header starting with &apos;{1}&apos;..
        /// </summary>
        internal static string ReadAsMimeMultipartArgumentNoMultipart {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartArgumentNoMultipart", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error reading MIME multipart body part..
        /// </summary>
        internal static string ReadAsMimeMultipartErrorReading {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartErrorReading", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error writing MIME multipart body part to output stream..
        /// </summary>
        internal static string ReadAsMimeMultipartErrorWriting {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartErrorWriting", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error parsing MIME multipart body part header byte {0} of data segment {1}..
        /// </summary>
        internal static string ReadAsMimeMultipartHeaderParseError {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartHeaderParseError", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Error parsing MIME multipart message byte {0} of data segment {1}..
        /// </summary>
        internal static string ReadAsMimeMultipartParseError {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartParseError", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The stream provider of type &apos;{0}&apos; threw an exception..
        /// </summary>
        internal static string ReadAsMimeMultipartStreamProviderException {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartStreamProviderException", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The stream provider of type &apos;{0}&apos; returned null. It must return a writable &apos;{1}&apos; instance..
        /// </summary>
        internal static string ReadAsMimeMultipartStreamProviderNull {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartStreamProviderNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The stream provider of type &apos;{0}&apos; returned a read-only stream. It must return a writable &apos;{1}&apos; instance..
        /// </summary>
        internal static string ReadAsMimeMultipartStreamProviderReadOnly {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartStreamProviderReadOnly", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Unexpected end of MIME multipart stream. MIME multipart message is not complete..
        /// </summary>
        internal static string ReadAsMimeMultipartUnexpectedTermination {
            get {
                return ResourceManager.GetString("ReadAsMimeMultipartUnexpectedTermination", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; method in &apos;{1}&apos; returned null. It must return a RemoteStreamResult instance containing a writable stream and a valid URL..
        /// </summary>
        internal static string RemoteStreamInfoCannotBeNull {
            get {
                return ResourceManager.GetString("RemoteStreamInfoCannotBeNull", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; serializer cannot serialize the type &apos;{1}&apos;..
        /// </summary>
        internal static string SerializerCannotSerializeType {
            get {
                return ResourceManager.GetString("SerializerCannotSerializeType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to There is an unmatched opened bracket for the &apos;{0}&apos; at position {1}..
        /// </summary>
        internal static string UnMatchedBracketNotValid {
            get {
                return ResourceManager.GetString("UnMatchedBracketNotValid", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Indentation is not supported by &apos;{0}&apos;..
        /// </summary>
        internal static string UnsupportedIndent {
            get {
                return ResourceManager.GetString("UnsupportedIndent", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to Unable to validate types on this platform when {0} is &apos;false&apos;. Please set {0} or move to a supported platform, one where the &apos;netstandard2.0&apos; assembly is usable..
        /// </summary>
        internal static string XmlMediaTypeFormatter_DCS_NotSupported {
            get {
                return ResourceManager.GetString("XmlMediaTypeFormatter_DCS_NotSupported", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The object of type &apos;{0}&apos; returned by {1} must be an instance of either XmlObjectSerializer or XmlSerializer..
        /// </summary>
        internal static string XmlMediaTypeFormatter_InvalidSerializerType {
            get {
                return ResourceManager.GetString("XmlMediaTypeFormatter_InvalidSerializerType", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to The object returned by {0} must not be a null value..
        /// </summary>
        internal static string XmlMediaTypeFormatter_NullReturnedSerializer {
            get {
                return ResourceManager.GetString("XmlMediaTypeFormatter_NullReturnedSerializer", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/Properties/Resources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!--
    Microsoft ResX Schema

    Version 2.0

    The primary goals of this format is to allow a simple XML format
    that is mostly human readable. The generation and parsing of the
    various data types are done through the TypeConverter classes
    associated with the data types.

    Example:

    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>

    There are any number of "resheader" rows that contain simple
    name/value pairs.

    Each data row contains a name, and value. The row also contains a
    type or mimetype. Type corresponds to a .NET class that support
    text/value conversion through the TypeConverter architecture.
    Classes that don't support this are serialized and stored with the
    mimetype set.

    The mimetype is used for serialized objects, and tells the
    ResXResourceReader how to depersist the object. This is currently not
    extensible. For a given mimetype the value must be set accordingly:

    Note - application/x-microsoft.net.object.binary.base64 is the format
    that the ResXResourceWriter will generate, however the reader can
    read any of the formats listed below.

    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="CannotHaveNullInList" xml:space="preserve">
    <value>A null '{0}' is not valid.</value>
  </data>
  <data name="CannotUseMediaRangeForSupportedMediaType" xml:space="preserve">
    <value>The '{0}' of '{1}' cannot be used as a supported media type because it is a media range.</value>
  </data>
  <data name="CannotUseNullValueType" xml:space="preserve">
    <value>The '{0}' type cannot accept a null value for the value type '{1}'.</value>
  </data>
  <data name="ErrorReadingFormUrlEncodedStream" xml:space="preserve">
    <value>Error reading HTML form URL-encoded data stream.</value>
  </data>
  <data name="FormUrlEncodedParseError" xml:space="preserve">
    <value>Error parsing HTML form URL-encoded data, byte {0}.</value>
  </data>
  <data name="HttpInvalidStatusCode" xml:space="preserve">
    <value>Invalid HTTP status code: '{0}'. The status code must be between {1} and {2}.</value>
  </data>
  <data name="HttpInvalidVersion" xml:space="preserve">
    <value>Invalid HTTP version: '{0}'. The version must start with the characters '{1}'.</value>
  </data>
  <data name="HttpMessageContentAlreadyRead" xml:space="preserve">
    <value>The '{0}' of the '{1}' has already been read.</value>
  </data>
  <data name="HttpMessageContentStreamMustBeSeekable" xml:space="preserve">
    <value>The '{0}' must be seekable in order to create an '{1}' instance containing an entity body.  </value>
  </data>
  <data name="HttpMessageErrorReading" xml:space="preserve">
    <value>Error reading HTTP message.</value>
  </data>
  <data name="HttpMessageInvalidMediaType" xml:space="preserve">
    <value>Invalid '{0}' instance provided. It does not have a content type header with a value of '{1}'.</value>
  </data>
  <data name="HttpMessageParserEmptyUri" xml:space="preserve">
    <value>HTTP Request URI cannot be an empty string.</value>
  </data>
  <data name="HttpMessageParserError" xml:space="preserve">
    <value>Error parsing HTTP message header byte {0} of message {1}.</value>
  </data>
  <data name="HttpMessageParserInvalidHostCount" xml:space="preserve">
    <value>An invalid number of '{0}' header fields were present in the HTTP Request. It must contain exactly one '{0}' header field but found {1}.</value>
  </data>
  <data name="HttpMessageParserInvalidUriScheme" xml:space="preserve">
    <value>Invalid URI scheme: '{0}'. The URI scheme must be a valid '{1}' scheme.</value>
  </data>
  <data name="MimeMultipartParserBadBoundary" xml:space="preserve">
    <value>MIME multipart boundary cannot end with an empty space.</value>
  </data>
  <data name="MultipartFormDataStreamProviderNoContentDisposition" xml:space="preserve">
    <value>Did not find required '{0}' header field in MIME multipart body part.</value>
  </data>
  <data name="MultipartStreamProviderInvalidLocalFileName" xml:space="preserve">
    <value>Could not determine a valid local file name for the multipart body part.</value>
  </data>
  <data name="NonNullUriRequiredForMediaTypeMapping" xml:space="preserve">
    <value>A non-null request URI must be provided to determine if a '{0}' matches a given request or response message.</value>
  </data>
  <data name="NoReadSerializerAvailable" xml:space="preserve">
    <value>No MediaTypeFormatter is available to read an object of type '{0}' from content with media type '{1}'.</value>
  </data>
  <data name="ObjectAndTypeDisagree" xml:space="preserve">
    <value>An object of type '{0}' cannot be used with a type parameter of '{1}'.</value>
  </data>
  <data name="ReadAsMimeMultipartArgumentNoBoundary" xml:space="preserve">
    <value>Invalid '{0}' instance provided. It does not have a '{1}' content-type header with a '{2}' parameter.</value>
  </data>
  <data name="ReadAsMimeMultipartArgumentNoContentType" xml:space="preserve">
    <value>Invalid '{0}' instance provided. It does not have a content-type header value. '{0}' instances must have a content-type header starting with '{1}'.</value>
  </data>
  <data name="ReadAsMimeMultipartArgumentNoMultipart" xml:space="preserve">
    <value>Invalid '{0}' instance provided. It does not have a content type header starting with '{1}'.</value>
  </data>
  <data name="ReadAsMimeMultipartErrorReading" xml:space="preserve">
    <value>Error reading MIME multipart body part.</value>
  </data>
  <data name="ReadAsMimeMultipartErrorWriting" xml:space="preserve">
    <value>Error writing MIME multipart body part to output stream.</value>
  </data>
  <data name="ReadAsMimeMultipartHeaderParseError" xml:space="preserve">
    <value>Error parsing MIME multipart body part header byte {0} of data segment {1}.</value>
  </data>
  <data name="ReadAsMimeMultipartParseError" xml:space="preserve">
    <value>Error parsing MIME multipart message byte {0} of data segment {1}.</value>
  </data>
  <data name="ReadAsMimeMultipartStreamProviderException" xml:space="preserve">
    <value>The stream provider of type '{0}' threw an exception.</value>
  </data>
  <data name="ReadAsMimeMultipartStreamProviderNull" xml:space="preserve">
    <value>The stream provider of type '{0}' returned null. It must return a writable '{1}' instance.</value>
  </data>
  <data name="ReadAsMimeMultipartStreamProviderReadOnly" xml:space="preserve">
    <value>The stream provider of type '{0}' returned a read-only stream. It must return a writable '{1}' instance.</value>
  </data>
  <data name="ReadAsMimeMultipartUnexpectedTermination" xml:space="preserve">
    <value>Unexpected end of MIME multipart stream. MIME multipart message is not complete.</value>
  </data>
  <data name="SerializerCannotSerializeType" xml:space="preserve">
    <value>The '{0}' serializer cannot serialize the type '{1}'.</value>
  </data>
  <data name="UnsupportedIndent" xml:space="preserve">
    <value>Indentation is not supported by '{0}'.</value>
  </data>
  <data name="MediaTypeFormatterCannotRead" xml:space="preserve">
    <value>The media type formatter of type '{0}' does not support reading because it does not implement the ReadFromStreamAsync method.</value>
  </data>
  <data name="MediaTypeFormatterCannotWrite" xml:space="preserve">
    <value>The media type formatter of type '{0}' does not support writing because it does not implement the WriteToStreamAsync method.</value>
  </data>
  <data name="MediaTypeFormatterCannotReadSync" xml:space="preserve">
    <value>The media type formatter of type '{0}' does not support reading because it does not implement the ReadFromStream method.</value>
  </data>
  <data name="MediaTypeFormatterCannotWriteSync" xml:space="preserve">
    <value>The media type formatter of type '{0}' does not support writing because it does not implement the WriteToStream method.</value>
  </data>
  <data name="ObjectContent_FormatterCannotWriteType" xml:space="preserve">
    <value>The configured formatter '{0}' cannot write an object of type '{1}'.</value>
  </data>
  <data name="FormUrlEncodedMismatchingTypes" xml:space="preserve">
    <value>Mismatched types at node '{0}'.</value>
  </data>
  <data name="InvalidArrayInsert" xml:space="preserve">
    <value>Invalid array at node '{0}'.</value>
  </data>
  <data name="JQuery13CompatModeNotSupportNestedJson" xml:space="preserve">
    <value>Traditional style array without '[]' is not supported with nested object at location {0}.</value>
  </data>
  <data name="MaxDepthExceeded" xml:space="preserve">
    <value>The maximum read depth ({0}) has been exceeded because the form url-encoded data being read has more levels of nesting than is allowed.</value>
  </data>
  <data name="NestedBracketNotValid" xml:space="preserve">
    <value>Nested bracket is not valid for '{0}' data at position {1}.</value>
  </data>
  <data name="QueryStringNameShouldNotNull" xml:space="preserve">
    <value>Query string name cannot be null.</value>
  </data>
  <data name="UnMatchedBracketNotValid" xml:space="preserve">
    <value>There is an unmatched opened bracket for the '{0}' at position {1}.</value>
  </data>
  <data name="MediaTypeFormatterNoEncoding" xml:space="preserve">
    <value>No encoding found for media type formatter '{0}'. There must be at least one supported encoding registered in order for the media type formatter to read or write content.</value>
  </data>
  <data name="CookieInvalidName" xml:space="preserve">
    <value>The specified value is not a valid cookie name.</value>
  </data>
  <data name="CookieNull" xml:space="preserve">
    <value>Cookie cannot be null.</value>
  </data>
  <data name="MaxHttpCollectionKeyLimitReached" xml:space="preserve">
    <value>The number of keys in a NameValueCollection has exceeded the limit of '{0}'. You can adjust it by modifying the MaxHttpCollectionKeys property on the '{1}' class.</value>
  </data>
  <data name="AsyncResult_CallbackThrewException" xml:space="preserve">
    <value>Async Callback threw an exception.</value>
  </data>
  <data name="AsyncResult_MultipleCompletes" xml:space="preserve">
    <value>The IAsyncResult implementation '{0}' tried to complete a single operation multiple times. This could be caused by an incorrect application IAsyncResult implementation or other extensibility code, such as an IAsyncResult that returns incorrect CompletedSynchronously values or invokes the AsyncCallback multiple times.</value>
  </data>
  <data name="AsyncResult_MultipleEnds" xml:space="preserve">
    <value>End cannot be called twice on an AsyncResult.</value>
  </data>
  <data name="AsyncResult_ResultMismatch" xml:space="preserve">
    <value>An incorrect IAsyncResult was provided to an 'End' method. The IAsyncResult object passed to 'End' must be the one returned from the matching 'Begin' or passed to the callback provided to 'Begin'.</value>
  </data>
  <data name="DelegatingHandlerArrayContainsNullItem" xml:space="preserve">
    <value>The '{0}' list is invalid because it contains one or more null items.</value>
  </data>
  <data name="DelegatingHandlerArrayHasNonNullInnerHandler" xml:space="preserve">
    <value>The '{0}' list is invalid because the property '{1}' of '{2}' is not null.</value>
  </data>
  <data name="ReadAsHttpMessageUnexpectedTermination" xml:space="preserve">
    <value>Unexpected end of HTTP message stream. HTTP message is not complete.</value>
  </data>
  <data name="ByteRangeStreamContentNotBytesRange" xml:space="preserve">
    <value>The range unit '{0}' is not valid. The range must have a unit of '{1}'.</value>
  </data>
  <data name="ByteRangeStreamInvalidFrom" xml:space="preserve">
    <value>The 'From' value of the range must be less than or equal to {0}.</value>
  </data>
  <data name="ByteRangeStreamNoneOverlap" xml:space="preserve">
    <value>None of the requested ranges ({0}) overlap with the current extent of the selected resource.</value>
  </data>
  <data name="ByteRangeStreamNoOverlap" xml:space="preserve">
    <value>The requested range ({0}) does not overlap with the current extent of the selected resource.</value>
  </data>
  <data name="ByteRangeStreamNotSeekable" xml:space="preserve">
    <value>The stream over which '{0}' provides a range view must be seekable.</value>
  </data>
  <data name="ByteRangeStreamReadOnly" xml:space="preserve">
    <value>This is a read-only stream.</value>
  </data>
  <data name="ByteRangeStreamContentNoRanges" xml:space="preserve">
    <value>Found zero byte ranges. There must be at least one byte range provided.</value>
  </data>
  <data name="ByteRangeStreamEmpty" xml:space="preserve">
    <value>The stream over which '{0}' provides a range view must have a length greater than or equal to 1.</value>
  </data>
  <data name="XmlMediaTypeFormatter_InvalidSerializerType" xml:space="preserve">
    <value>The object of type '{0}' returned by {1} must be an instance of either XmlObjectSerializer or XmlSerializer.</value>
  </data>
  <data name="XmlMediaTypeFormatter_NullReturnedSerializer" xml:space="preserve">
    <value>The object returned by {0} must not be a null value.</value>
  </data>
  <data name="JsonSerializerFactoryReturnedNull" xml:space="preserve">
    <value>The '{0}' method returned null. It must return a JSON serializer instance.</value>
  </data>
  <data name="JsonSerializerFactoryThrew" xml:space="preserve">
    <value>The '{0}' method threw an exception when attempting to create a JSON serializer.</value>
  </data>
  <data name="MediaTypeFormatter_JsonReaderFactoryReturnedNull" xml:space="preserve">
    <value>The '{0}' method returned null. It must return a JSON reader instance.</value>
  </data>
  <data name="MediaTypeFormatter_JsonWriterFactoryReturnedNull" xml:space="preserve">
    <value>The '{0}' method returned null. It must return a JSON writer instance.</value>
  </data>
  <data name="MediaTypeFormatter_BsonParseError_MissingData" xml:space="preserve">
    <value>Error parsing BSON data; unable to read content as a {0}.</value>
  </data>
  <data name="MediaTypeFormatter_BsonParseError_UnexpectedData" xml:space="preserve">
    <value>Error parsing BSON data; unexpected dictionary content: {0} entries, first key '{1}'.</value>
  </data>
  <data name="RemoteStreamInfoCannotBeNull" xml:space="preserve">
    <value>The '{0}' method in '{1}' returned null. It must return a RemoteStreamResult instance containing a writable stream and a valid URL.</value>
  </data>
  <data name="ByteRangeStreamInvalidOffset" xml:space="preserve">
    <value>An attempt was made to move the position before the beginning of the stream.</value>
  </data>
  <data name="Argument_InvalidOffLen" xml:space="preserve">
    <value>Offset and length were out of bounds for the array or count is greater than the number of elements from index to the end of the source collection.</value>
  </data>
  <data name="NotSupported_UnreadableStream" xml:space="preserve">
    <value>Stream does not support reading.</value>
  </data>
  <data name="NotSupported_UnseekableStream" xml:space="preserve">
    <value>Stream does not support seeking.</value>
  </data>
  <data name="NotSupported_UnwritableStream" xml:space="preserve">
    <value>Stream does not support writing.</value>
  </data>
  <data name="ObjectDisposed_StreamClosed" xml:space="preserve">
    <value>Cannot access a closed stream.</value>
  </data>
  <data name="JsonMediaTypeFormatter_DCS_NotSupported" xml:space="preserve">
    <value>Unable to validate types on this platform when {0} is 'true'. Please reset {0} or move to a supported platform, one where the .NET Standard 2.0 assembly is usable.</value>
  </data>
  <data name="XmlMediaTypeFormatter_DCS_NotSupported" xml:space="preserve">
    <value>Unable to validate types on this platform when {0} is 'false'. Please set {0} or move to a supported platform, one where the .NET Standard 2.0 assembly is usable.</value>
  </data>
</root>

================================================
FILE: src/System.Net.Http.Formatting/PushStreamContent.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Net.Http.Internal;
using System.Threading.Tasks;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Provides an <see cref="HttpContent"/> implementation that exposes an output <see cref="Stream"/>
    /// which can be written to directly. The ability to push data to the output stream differs from the
    /// <see cref="StreamContent"/> where data is pulled and not pushed.
    /// </summary>
    public class PushStreamContent : HttpContent
    {
        private readonly Func<Stream, HttpContent, TransportContext, Task> _onStreamAvailable;

        /// <summary>
        /// Initializes a new instance of the <see cref="PushStreamContent"/> class. The
        /// <paramref name="onStreamAvailable"/> action is called when an output stream
        /// has become available allowing the action to write to it directly. When the
        /// stream is closed, it will signal to the content that it has completed and the
        /// HTTP request or response will be completed.
        /// </summary>
        /// <param name="onStreamAvailable">The action to call when an output stream is available.</param>
        public PushStreamContent(Action<Stream, HttpContent, TransportContext> onStreamAvailable)
            : this(Taskify(onStreamAvailable), (MediaTypeHeaderValue)null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PushStreamContent"/> class.
        /// </summary>
        /// <param name="onStreamAvailable">The action to call when an output stream is available. When the
        /// output stream is closed or disposed, it will signal to the content that it has completed and the
        /// HTTP request or response will be completed.</param>
        public PushStreamContent(Func<Stream, HttpContent, TransportContext, Task> onStreamAvailable)
            : this(onStreamAvailable, (MediaTypeHeaderValue)null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PushStreamContent"/> class with the given media type.
        /// </summary>
        /// <param name="onStreamAvailable">The action to call when an output stream is available.</param>
        /// <param name="mediaType">The value of the Content-Type content header on an HTTP response.</param>
        public PushStreamContent(Action<Stream, HttpContent, TransportContext> onStreamAvailable, string mediaType)
            : this(Taskify(onStreamAvailable), new MediaTypeHeaderValue(mediaType))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PushStreamContent"/> class with the given media type.
        /// </summary>
        /// <param name="onStreamAvailable">The action to call when an output stream is available. When the
        /// output stream is closed or disposed, it will signal to the content that it has completed and the
        /// HTTP request or response will be completed.</param>
        /// <param name="mediaType">The value of the Content-Type content header on an HTTP response.</param>
        public PushStreamContent(Func<Stream, HttpContent, TransportContext, Task> onStreamAvailable, string mediaType)
            : this(onStreamAvailable, new MediaTypeHeaderValue(mediaType))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PushStreamContent"/> class with the given <see cref="MediaTypeHeaderValue"/>.
        /// </summary>
        /// <param name="onStreamAvailable">The action to call when an output stream is available.</param>
        /// <param name="mediaType">The value of the Content-Type content header on an HTTP response.</param>
        public PushStreamContent(Action<Stream, HttpContent, TransportContext> onStreamAvailable, MediaTypeHeaderValue mediaType)
            : this(Taskify(onStreamAvailable), mediaType)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="PushStreamContent"/> class with the given <see cref="MediaTypeHeaderValue"/>.
        /// </summary>
        /// <param name="onStreamAvailable">The action to call when an output stream is available. When the
        /// output stream is closed or disposed, it will signal to the content that it has completed and the
        /// HTTP request or response will be completed.</param>
        /// <param name="mediaType">The value of the Content-Type content header on an HTTP response.</param>
        public PushStreamContent(Func<Stream, HttpContent, TransportContext, Task> onStreamAvailable, MediaTypeHeaderValue mediaType)
        {
            if (onStreamAvailable == null)
            {
                throw Error.ArgumentNull("onStreamAvailable");
            }

            _onStreamAvailable = onStreamAvailable;
            Headers.ContentType = mediaType ?? MediaTypeConstants.ApplicationOctetStreamMediaType;
        }

        private static Func<Stream, HttpContent, TransportContext, Task> Taskify(
            Action<Stream, HttpContent, TransportContext> onStreamAvailable)
        {
            if (onStreamAvailable == null)
            {
                throw Error.ArgumentNull("onStreamAvailable");
            }

            return (Stream stream, HttpContent content, TransportContext transportContext) =>
            {
                onStreamAvailable(stream, content, transportContext);
                return TaskHelpers.Completed();
            };
        }

        /// <summary>
        /// When this method is called, it calls the action provided in the constructor with the output
        /// stream to write to. Once the action has completed its work it closes the stream which will
        /// close this content instance and complete the HTTP request or response.
        /// </summary>
        /// <param name="stream">The <see cref="Stream"/> to which to write.</param>
        /// <param name="context">The associated <see cref="TransportContext"/>.</param>
        /// <returns>A <see cref="Task"/> instance that is asynchronously serializing the object's content.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is passed as task result.")]
        protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
        {
            TaskCompletionSource<bool> serializeToStreamTask = new TaskCompletionSource<bool>();

            Stream wrappedStream = new CompleteTaskOnCloseStream(stream, serializeToStreamTask);
            await _onStreamAvailable(wrappedStream, this, context);

            // wait for wrappedStream.Close/Dispose to get called.
            await serializeToStreamTask.Task;
        }

        /// <summary>
        /// Computes the length of the stream if possible.
        /// </summary>
        /// <param name="length">The computed length of the stream.</param>
        /// <returns><c>true</c> if the length has been computed; otherwise <c>false</c>.</returns>
        protected override bool TryComputeLength(out long length)
        {
            // We can't know the length of the content being pushed to the output stream.
            length = -1;
            return false;
        }

        internal class CompleteTaskOnCloseStream : DelegatingStream
        {
            private TaskCompletionSource<bool> _serializeToStreamTask;

            public CompleteTaskOnCloseStream(Stream innerStream, TaskCompletionSource<bool> serializeToStreamTask)
                : base(innerStream)
            {
                Contract.Assert(serializeToStreamTask != null);
                _serializeToStreamTask = serializeToStreamTask;
            }

#if NETSTANDARD1_3
            [SuppressMessage(
                "Microsoft.Usage",
                "CA2215:Dispose methods should call base class dispose",
                Justification = "See comments, this is intentional.")]
            protected override void Dispose(bool disposing)
            {
                // We don't dispose the underlying stream because we don't own it. Dispose in this case just signifies
                // that the user's action is finished.
                _serializeToStreamTask.TrySetResult(true);
            }
#else
            public override void Close()
            {
                // We don't Close the underlying stream because we don't own it. Dispose in this case just signifies
                // that the user's action is finished.
                _serializeToStreamTask.TrySetResult(true);
            }
#endif
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/RemoteStreamInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Represents the result for <see cref="MultipartFormDataRemoteStreamProvider.GetRemoteStream"/>.
    /// </summary>
    public class RemoteStreamInfo
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RemoteStreamInfo"/> class.
        /// </summary>
        /// <param name="remoteStream">
        /// The remote stream instance where the file will be written to.
        /// </param>
        /// <param name="location">The remote file's location.</param>
        /// <param name="fileName">The remote file's name.</param>
        public RemoteStreamInfo(Stream remoteStream, string location, string fileName)
        {
            if (remoteStream == null)
            {
                throw Error.ArgumentNull("remoteStream");
            }

            if (location == null)
            {
                throw Error.ArgumentNull("location");
            }

            if (fileName == null)
            {
                throw Error.ArgumentNull("fileName");
            }

            FileName = fileName;
            RemoteStream = remoteStream;
            Location = location;
        }

        /// <summary>
        /// Gets the remote file's location.
        /// </summary>
        public string FileName { get; private set; }

        /// <summary>
        /// Gets the remote file's location.
        /// </summary>
        public string Location { get; private set; }

        /// <summary>
        /// Gets the remote stream instance where the file will be written to.
        /// </summary>
        public Stream RemoteStream { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/System.Net.Http.Formatting.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Net.Http</RootNamespace>
    <AssemblyName>System.Net.Http.Formatting</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETHTTPFORMATTING</DefineConstants>
    <TargetFrameworkProfile Condition="'$(TargetFrameworkVersion)' != 'v4.5'">Client</TargetFrameworkProfile>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>

  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Buffers, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.Buffers.4.5.1\lib\netstandard2.0\System.Buffers.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Memory, Version=4.0.1.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.Memory.4.5.5\lib\netstandard2.0\System.Memory.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.Threading.Tasks.Extensions.4.5.4\lib\netstandard2.0\System.Threading.Tasks.Extensions.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System.Xml" />
    <Reference Include="System.Xml.Linq" />

    <Reference Include="netstandard, Version=2.0.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\NETStandard.Library.2.0.3\lib\netstandard2.0\netstandard.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json.Bson, Version=1.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.Bson.1.0.2\lib\net45\Newtonsoft.Json.Bson.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>

    <Compile Include="..\CommonAssemblyInfo.cs" Link="Properties\CommonAssemblyInfo.cs" />
    <Compile Include="..\Common\CollectionExtensions.cs" Link="Common\CollectionExtensions.cs" />
    <Compile Include="..\Common\Error.cs" Link="Common\Error.cs" />
    <Compile Include="..\Common\ListWrapperCollection.cs" Link="Common\ListWrapperCollection.cs" />
    <Compile Include="..\Common\TaskHelpers.cs" Link="Common\TaskHelpers.cs" />
    <Compile Include="..\Common\TaskHelpersExtensions.cs" Link="Common\TaskHelpersExtensions.cs" />

    <Compile Include="**\*.cs" Exclude="obj\**\*.cs;Properties\Resources.Designer.cs" />

    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
      <DesignTime>True</DesignTime>
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
    </Compile>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonWebApiResources.Designer.cs</LastGenOutput>
      <Link>Properties\CommonWebApiResources.resx</Link>
    </EmbeddedResource>

    <Compile Include="Properties\Resources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DependentUpon>Resources.resx</DependentUpon>
      <DesignTime>True</DesignTime>
    </Compile>
    <EmbeddedResource Include="Properties\Resources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
      <SubType>Designer</SubType>
    </EmbeddedResource>

    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" Link="CodeAnalysisDictionary.xml" />

    <None Include="packages.config" />
  </ItemGroup>

  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>


================================================
FILE: src/System.Net.Http.Formatting/UnsupportedMediaTypeException.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Headers;
using System.Web.Http;

namespace System.Net.Http
{
    /// <summary>
    /// Defines an exception type for signalling that a request's media type was not supported.
    /// </summary>
    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable", Justification = "This type is not meant to be serialized")]
    [SuppressMessage("Microsoft.Usage", "CA2240:ImplementISerializableCorrectly", Justification = "This type is not meant to be serialized")]
    [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors", Justification = "UnsupportedMediaTypeException is only used to propagate the media type back to the server layer")]
    public class UnsupportedMediaTypeException : Exception
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="UnsupportedMediaTypeException" /> class.
        /// </summary>
        /// <param name="message">The message that describes the error.</param>
        /// <param name="mediaType">The unsupported media type.</param>
        public UnsupportedMediaTypeException(string message, MediaTypeHeaderValue mediaType)
            : base(message)
        {
            if (mediaType == null)
            {
                throw Error.ArgumentNull("mediaType");
            }

            MediaType = mediaType;
        }

        public MediaTypeHeaderValue MediaType { get; private set; }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/UriExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Formatting;
using System.Web.Http;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace System.Net.Http
{
    /// <summary>
    /// Extension methods to allow strongly typed objects to be read from the query component of <see cref="Uri"/> instances.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class UriExtensions
    {
        /// <summary>
        /// Parses the query portion of the specified <see cref="Uri"/>.
        /// </summary>
        /// <param name="address">The <see cref="Uri"/> instance from which to read.</param>
        /// <returns>A <see cref="NameValueCollection"/> containing the parsed result.</returns>
        public static NameValueCollection ParseQueryString(this Uri address)
        {
            if (address == null)
            {
                throw Error.ArgumentNull("address");
            }

            return new FormDataCollection(address).ReadAsNameValueCollection();
        }

        /// <summary>
        /// Reads HTML form URL encoded data provided in the <see cref="Uri"/> query component as a <see cref="JObject"/> object.
        /// </summary>
        /// <param name="address">The <see cref="Uri"/> instance from which to read.</param>
        /// <param name="value">An object to be initialized with this instance or null if the conversion cannot be performed.</param>
        /// <returns><c>true</c> if the query component can be read as <see cref="JObject"/>; otherwise <c>false</c>.</returns>
        public static bool TryReadQueryAsJson(this Uri address, out JObject value)
        {
            if (address == null)
            {
                throw Error.ArgumentNull("address");
            }

            IEnumerable<KeyValuePair<string, string>> query = new FormDataCollection(address);
            return FormUrlEncodedJson.TryParse(query, out value);
        }

        /// <summary>
        /// Reads HTML form URL encoded data provided in the <see cref="Uri"/> query component as an <see cref="Object"/> of the given <paramref name="type"/>.
        /// </summary>
        /// <param name="address">The <see cref="Uri"/> instance from which to read.</param>
        /// <param name="type">The type of the object to read.</param>
        /// <param name="value">An object to be initialized with this instance or null if the conversion cannot be performed.</param>
        /// <returns><c>true</c> if the query component can be read as the specified type; otherwise <c>false</c>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1007:UseGenericsWhereAppropriate", Justification = "This is the non-generic version.")]
        public static bool TryReadQueryAs(this Uri address, Type type, out object value)
        {
            if (address == null)
            {
                throw Error.ArgumentNull("address");
            }

            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            IEnumerable<KeyValuePair<string, string>> query = new FormDataCollection(address);
            JObject jsonObject;
            if (FormUrlEncodedJson.TryParse(query, out jsonObject))
            {
                using (JTokenReader jsonReader = new JTokenReader(jsonObject))
                {
                    value = new JsonSerializer().Deserialize(jsonReader, type);
                }
                return true;
            }

            value = null;
            return false;
        }

        /// <summary>
        /// Reads HTML form URL encoded data provided in the <see cref="Uri"/> query component as an <see cref="Object"/> of type <typeparamref name="T"/>.
        /// </summary>
        /// <typeparam name="T">The type of the object to read.</typeparam>
        /// <param name="address">The <see cref="Uri"/> instance from which to read.</param>
        /// <param name="value">An object to be initialized with this instance or null if the conversion cannot be performed.</param>
        /// <returns><c>true</c> if the query component can be read as the specified type; otherwise <c>false</c>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "The T represents the output parameter, not an input parameter.")]
        public static bool TryReadQueryAs<T>(this Uri address, out T value)
        {
            if (address == null)
            {
                throw Error.ArgumentNull("address");
            }

            IEnumerable<KeyValuePair<string, string>> query = new FormDataCollection(address);
            JObject jsonObject;
            if (FormUrlEncodedJson.TryParse(query, out jsonObject))
            {
                value = jsonObject.ToObject<T>();
                return true;
            }

            value = default(T);
            return false;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
  <package id="Newtonsoft.Json.Bson" version="1.0.2" targetFramework="net45" />
  <package id="NETStandard.Library" version="2.0.3" targetFramework="netstandard2.0" />
  <package id="System.Buffers" version="4.5.1" targetFramework="netstandard2.0" />
  <package id="System.Memory" version="4.5.5" targetFramework="netstandard2.0" />
  <package id="System.Threading.Tasks.Extensions" version="4.5.4" targetFramework="netstandard2.0" />
</packages>

================================================
FILE: src/System.Net.Http.Formatting.ns1_3/ICloneable.cs
================================================
// No ICloneable interface in .NET Standard 1.3.

namespace System
{
    internal interface ICloneable
    {
        object Clone();
    }
}


================================================
FILE: src/System.Net.Http.Formatting.ns1_3/MediaTypeHeaderValueExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http.Headers;

namespace System.Net.Http
{
    internal static class MediaTypeHeaderValueExtensions
    {
        public static MediaTypeHeaderValue Clone(this MediaTypeHeaderValue mediaType)
        {
            Contract.Assert(mediaType != null && mediaType.GetType() == typeof(MediaTypeHeaderValue));

            var result = new MediaTypeHeaderValue(mediaType.MediaType);
            foreach (var parameter in mediaType.Parameters)
            {
                result.Parameters.Add(new NameValueHeaderValue(parameter.Name, parameter.Value));
            }

            return result;
        }
    }
}


================================================
FILE: src/System.Net.Http.Formatting.ns1_3/System.Net.Http.Formatting.ns1_3.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <TargetFramework>netstandard1.3</TargetFramework>
    <RootNamespace>System.Net.Http</RootNamespace>
    <AssemblyName>System.Net.Http.Formatting</AssemblyName>
    <OutputPath>$(OutputPath)ns1_3\</OutputPath>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>false</RunCodeAnalysis>
    <DefineConstants>$(DefineConstants);ASPNETHTTPFORMATTING</DefineConstants>
    <NoWarn>1591</NoWarn>
    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
    <Configurations>$(Configurations);CodeAnalysis</Configurations>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="System.Collections.Specialized" Version="4.3.0" />
    <PackageReference Include="System.ComponentModel.EventBasedAsync" Version="4.3.0" />
    <PackageReference Include="System.Data.Common" Version="4.3.0" />
    <PackageReference Include="System.Diagnostics.Contracts" Version="4.3.0" />
    <PackageReference Include="System.Memory" Version="4.5.5" />
    <PackageReference Include="System.Runtime.Serialization.Json" Version="4.3.0" />
    <PackageReference Include="System.Runtime.Serialization.Xml" Version="4.3.0" />
    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />
    <PackageReference Include="System.Xml.XmlSerializer" Version="4.3.0" />

    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
    <PackageReference Include="Newtonsoft.Json.Bson" Version="1.0.2" />

    <Compile Include="..\CommonAssemblyInfo.cs" Link="Properties\CommonAssemblyInfo.cs" />
    <Compile Include="..\Common\CollectionExtensions.cs" Link="Common\CollectionExtensions.cs" />
    <Compile Include="..\Common\Error.cs" Link="Common\Error.cs" />
    <Compile Include="..\Common\ListWrapperCollection.cs" Link="Common\ListWrapperCollection.cs" />
    <Compile Include="..\Common\TaskHelpers.cs" Link="Common\TaskHelpers.cs" />
    <Compile Include="..\Common\TaskHelpersExtensions.cs" Link="Common\TaskHelpersExtensions.cs" />

    <Compile Include="..\System.Net.Http.Formatting\**\*.cs"
        Exclude="..\System.Net.Http.Formatting\obj\**\*.cs;
                 ..\System.Net.Http.Formatting\Formatting\BufferedMediaTypeFormatter.cs;
                 ..\System.Net.Http.Formatting\Handlers\ProgressWriteAsyncResult.cs;
                 ..\System.Net.Http.Formatting\Properties\Resources.Designer.cs">
      <Link>%(RecursiveDir)\%(Filename).cs</Link>
    </Compile>

    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
      <DesignTime>True</DesignTime>
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
    </Compile>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonWebApiResources.Designer.cs</LastGenOutput>
      <Link>Properties\CommonWebApiResources.resx</Link>
    </EmbeddedResource>

    <Compile Include="..\System.Net.Http.Formatting\Properties\Resources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DependentUpon>Resources.resx</DependentUpon>
      <DesignTime>True</DesignTime>
      <Link>Properties\Resources.Designer.cs</Link>
    </Compile>
    <EmbeddedResource Include="..\System.Net.Http.Formatting\Properties\Resources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
      <Link>Properties\Resources.resx</Link>
      <SubType>Designer</SubType>
    </EmbeddedResource>

    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" Link="CodeAnalysisDictionary.xml" />
  </ItemGroup>
</Project>


================================================
FILE: src/System.Net.Http.Formatting.ns2_0/System.Net.Http.Formatting.ns2_0.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <TargetFramework>netstandard2.0</TargetFramework>
    <RootNamespace>System.Net.Http</RootNamespace>
    <AssemblyName>System.Net.Http.Formatting</AssemblyName>
    <OutputPath>$(OutputPath)ns2_0\</OutputPath>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>false</RunCodeAnalysis>
    <DefineConstants>$(DefineConstants);ASPNETHTTPFORMATTING</DefineConstants>
    <NoWarn>1591</NoWarn>
    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
    <Configurations>$(Configurations);CodeAnalysis</Configurations>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="System.Memory" Version="4.5.5" />
    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.4" />

    <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
    <PackageReference Include="Newtonsoft.Json.Bson" Version="1.0.2" />

    <Compile Include="..\CommonAssemblyInfo.cs" Link="Properties\CommonAssemblyInfo.cs" />
    <Compile Include="..\Common\CollectionExtensions.cs" Link="Common\CollectionExtensions.cs" />
    <Compile Include="..\Common\Error.cs" Link="Common\Error.cs" />
    <Compile Include="..\Common\ListWrapperCollection.cs" Link="Common\ListWrapperCollection.cs" />
    <Compile Include="..\Common\TaskHelpers.cs" Link="Common\TaskHelpers.cs" />
    <Compile Include="..\Common\TaskHelpersExtensions.cs" Link="Common\TaskHelpersExtensions.cs" />

    <Compile Include="..\System.Net.Http.Formatting\**\*.cs"
        Exclude="..\System.Net.Http.Formatting\obj\**\*.cs;
                 ..\System.Net.Http.Formatting\Properties\Resources.Designer.cs">
      <Link>%(RecursiveDir)\%(Filename).cs</Link>
    </Compile>

    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
      <DesignTime>True</DesignTime>
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
    </Compile>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonWebApiResources.Designer.cs</LastGenOutput>
      <Link>Properties\CommonWebApiResources.resx</Link>
    </EmbeddedResource>

    <Compile Include="..\System.Net.Http.Formatting\Properties\Resources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DependentUpon>Resources.resx</DependentUpon>
      <DesignTime>True</DesignTime>
      <Link>Properties\Resources.Designer.cs</Link>
    </Compile>
    <EmbeddedResource Include="..\System.Net.Http.Formatting\Properties\Resources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
      <Link>Properties\Resources.resx</Link>
      <SubType>Designer</SubType>
    </EmbeddedResource>

    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" Link="CodeAnalysisDictionary.xml" />
  </ItemGroup>
</Project>


================================================
FILE: src/System.Web.Cors/CorsConstants.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Cors
{
    /// <summary>
    /// CORS-related constants.
    /// </summary>
    public static class CorsConstants
    {
        /// <summary>
        /// The HTTP method for the CORS preflight request.
        /// </summary>
        public static readonly string PreflightHttpMethod = "OPTIONS";

        /// <summary>
        /// The Origin request header.
        /// </summary>
        public static readonly string Origin = "Origin";

        /// <summary>
        /// The value for the Access-Control-Allow-Origin response header to allow all origins.
        /// </summary>
        public static readonly string AnyOrigin = "*";

        /// <summary>
        /// The Access-Control-Request-Method request header.
        /// </summary>
        public static readonly string AccessControlRequestMethod = "Access-Control-Request-Method";

        /// <summary>
        /// The Access-Control-Request-Headers request header.
        /// </summary>
        public static readonly string AccessControlRequestHeaders = "Access-Control-Request-Headers";

        /// <summary>
        /// The Access-Control-Allow-Origin response header.
        /// </summary>
        public static readonly string AccessControlAllowOrigin = "Access-Control-Allow-Origin";

        /// <summary>
        /// The Access-Control-Allow-Headers response header.
        /// </summary>
        public static readonly string AccessControlAllowHeaders = "Access-Control-Allow-Headers";

        /// <summary>
        /// The Access-Control-Expose-Headers response header.
        /// </summary>
        public static readonly string AccessControlExposeHeaders = "Access-Control-Expose-Headers";

        /// <summary>
        /// The Access-Control-Allow-Methods response header.
        /// </summary>
        public static readonly string AccessControlAllowMethods = "Access-Control-Allow-Methods";

        /// <summary>
        /// The Access-Control-Allow-Credentials response header.
        /// </summary>
        public static readonly string AccessControlAllowCredentials = "Access-Control-Allow-Credentials";

        /// <summary>
        /// The Access-Control-Max-Age response header.
        /// </summary>
        public static readonly string AccessControlMaxAge = "Access-Control-Max-Age";

        internal static readonly string[] SimpleRequestHeaders =
        {
            "Origin",
            "Accept",
            "Accept-Language",
            "Content-Language",
        };

        internal static readonly string[] SimpleResponseHeaders =
        {
            "Cache-Control",
            "Content-Language",
            "Content-Type",
            "Expires",
            "Last-Modified",
            "Pragma"
        };

        internal static readonly string[] SimpleMethods =
        {
            "GET",
            "HEAD",
            "POST"
        };
    }
}

================================================
FILE: src/System.Web.Cors/CorsEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Cors.Properties;

namespace System.Web.Cors
{
    /// <summary>
    /// An implementation of <see cref="ICorsEngine"/> based on the CORS specifications.
    /// </summary>
    public class CorsEngine : ICorsEngine
    {
        /// <summary>
        /// Evaluates the policy.
        /// </summary>
        /// <param name="requestContext">The <see cref="CorsRequestContext" />.</param>
        /// <param name="policy">The <see cref="CorsPolicy" />.</param>
        /// <returns>
        /// The <see cref="CorsResult" />
        /// </returns>
        /// <exception cref="System.ArgumentNullException">
        /// requestContext
        /// or
        /// policy
        /// </exception>
        public virtual CorsResult EvaluatePolicy(CorsRequestContext requestContext, CorsPolicy policy)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (policy == null)
            {
                throw new ArgumentNullException("policy");
            }

            CorsResult result = new CorsResult();

            if (!TryValidateOrigin(requestContext, policy, result))
            {
                return result;
            }

            result.SupportsCredentials = policy.SupportsCredentials;

            if (requestContext.IsPreflight)
            {
                if (!TryValidateMethod(requestContext, policy, result))
                {
                    return result;
                }

                if (!TryValidateHeaders(requestContext, policy, result))
                {
                    return result;
                }

                result.PreflightMaxAge = policy.PreflightMaxAge;
            }
            else
            {
                AddHeaderValues(result.AllowedExposedHeaders, policy.ExposedHeaders);
            }

            return result;
        }

        /// <summary>
        /// Try to validate the requested method based on <see cref="CorsPolicy"/>.
        /// </summary>
        /// <param name="requestContext">The <see cref="CorsRequestContext"/>.</param>
        /// <param name="policy">The <see cref="CorsPolicy"/>.</param>
        /// <param name="result">The <see cref="CorsResult"/>.</param>
        /// <returns><c>true</c> if the requested method is valid; otherwise, <c>false</c>. </returns>
        /// <exception cref="System.ArgumentNullException">
        /// requestContext
        /// or
        /// policy
        /// or
        /// result
        /// </exception>
        public virtual bool TryValidateMethod(CorsRequestContext requestContext, CorsPolicy policy, CorsResult result)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (policy == null)
            {
                throw new ArgumentNullException("policy");
            }
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            if (policy.AllowAnyMethod ||
                policy.Methods.Contains(requestContext.AccessControlRequestMethod))
            {
                result.AllowedMethods.Add(requestContext.AccessControlRequestMethod);
            }
            else
            {
                result.ErrorMessages.Add(String.Format(
                    CultureInfo.CurrentCulture,
                    SRResources.MethodNotAllowed,
                    requestContext.AccessControlRequestMethod));
            }

            return result.IsValid;
        }

        /// <summary>
        /// Try to validate the requested headers based on <see cref="CorsPolicy"/>.
        /// </summary>
        /// <param name="requestContext">The <see cref="CorsRequestContext"/>.</param>
        /// <param name="policy">The <see cref="CorsPolicy"/>.</param>
        /// <param name="result">The <see cref="CorsResult"/>.</param>
        /// <returns><c>true</c> if the requested headers are valid; otherwise, <c>false</c>. </returns>
        /// <exception cref="System.ArgumentNullException">
        /// requestContext
        /// or
        /// policy
        /// or
        /// result
        /// </exception>
        public virtual bool TryValidateHeaders(CorsRequestContext requestContext, CorsPolicy policy, CorsResult result)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (policy == null)
            {
                throw new ArgumentNullException("policy");
            }
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            if (policy.AllowAnyHeader ||
                requestContext.AccessControlRequestHeaders.IsSubsetOf(policy.Headers))
            {
                AddHeaderValues(result.AllowedHeaders, requestContext.AccessControlRequestHeaders);
            }
            else
            {
                result.ErrorMessages.Add(String.Format(
                    CultureInfo.CurrentCulture,
                    SRResources.HeadersNotAllowed,
                    String.Join(",", requestContext.AccessControlRequestHeaders)));
            }

            return result.IsValid;
        }

        /// <summary>
        /// Try to validate the request origin based on <see cref="CorsPolicy"/>.
        /// </summary>
        /// <param name="requestContext">The <see cref="CorsRequestContext"/>.</param>
        /// <param name="policy">The <see cref="CorsPolicy"/>.</param>
        /// <param name="result">The <see cref="CorsResult"/>.</param>
        /// <returns><c>true</c> if the request origin is valid; otherwise, <c>false</c>. </returns>
        /// <exception cref="System.ArgumentNullException">
        /// requestContext
        /// or
        /// policy
        /// or
        /// result
        /// </exception>
        public virtual bool TryValidateOrigin(CorsRequestContext requestContext, CorsPolicy policy, CorsResult result)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (policy == null)
            {
                throw new ArgumentNullException("policy");
            }
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            if (requestContext.Origin != null)
            {
                if (policy.AllowAnyOrigin)
                {
                    if (policy.SupportsCredentials)
                    {
                        result.AllowedOrigin = requestContext.Origin;
                    }
                    else
                    {
                        result.AllowedOrigin = CorsConstants.AnyOrigin;
                    }
                }
                else if (policy.Origins.Contains(requestContext.Origin))
                {
                    result.AllowedOrigin = requestContext.Origin;
                }
                else
                {
                    result.ErrorMessages.Add(String.Format(
                        CultureInfo.CurrentCulture,
                        SRResources.OriginNotAllowed,
                        requestContext.Origin));
                }
            }
            else
            {
                result.ErrorMessages.Add(SRResources.NoOriginHeader);
            }

            return result.IsValid;
        }

        private static void AddHeaderValues(IList<string> target, IEnumerable<string> headerValues)
        {
            foreach (string headerValue in headerValues)
            {
                target.Add(headerValue);
            }
        }
    }
}

================================================
FILE: src/System.Web.Cors/CorsPolicy.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Web.Cors.Properties;

namespace System.Web.Cors
{
    /// <summary>
    /// Defines the policy for Cross-Origin requests based on the CORS specifications.
    /// </summary>
    public class CorsPolicy
    {
        private long? _preflightMaxAge;

        /// <summary>
        /// Initializes a new instance of the <see cref="CorsPolicy"/> class.
        /// </summary>
        public CorsPolicy()
        {
            ExposedHeaders = new List<string>();
            Headers = new List<string>();
            Methods = new List<string>();
            Origins = new List<string>();
        }

        /// <summary>
        /// Gets or sets a value indicating whether to allow all headers.
        /// </summary>
        public bool AllowAnyHeader { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to allow all methods.
        /// </summary>
        public bool AllowAnyMethod { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether to allow all origins.
        /// </summary>
        public bool AllowAnyOrigin { get; set; }

        /// <summary>
        /// Gets the headers that the resource might use and can be exposed.
        /// </summary>
        public IList<string> ExposedHeaders { get; private set; }

        /// <summary>
        /// Gets the headers that are supported by the resource.
        /// </summary>
        public IList<string> Headers { get; private set; }

        /// <summary>
        /// Gets the methods that are supported by the resource.
        /// </summary>
        public IList<string> Methods { get; private set; }

        /// <summary>
        /// Gets the origins that are allowed to access the resource.
        /// </summary>
        public IList<string> Origins { get; private set; }

        /// <summary>
        /// Gets or sets the number of seconds the results of a preflight request can be cached.
        /// </summary>
        public long? PreflightMaxAge
        {
            get
            {
                return _preflightMaxAge;
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentOutOfRangeException("value", SRResources.PreflightMaxAgeOutOfRange);
                }
                _preflightMaxAge = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the resource supports user credentials in the request.
        /// </summary>
        public bool SupportsCredentials { get; set; }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String" /> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append("AllowAnyHeader: ");
            builder.Append(AllowAnyHeader);
            builder.Append(", AllowAnyMethod: ");
            builder.Append(AllowAnyMethod);
            builder.Append(", AllowAnyOrigin: ");
            builder.Append(AllowAnyOrigin);
            builder.Append(", PreflightMaxAge: ");
            builder.Append(PreflightMaxAge.HasValue ? PreflightMaxAge.Value.ToString(CultureInfo.InvariantCulture) : "null");
            builder.Append(", SupportsCredentials: ");
            builder.Append(SupportsCredentials);
            builder.Append(", Origins: {");
            builder.Append(String.Join(",", Origins));
            builder.Append("}");
            builder.Append(", Methods: {");
            builder.Append(String.Join(",", Methods));
            builder.Append("}");
            builder.Append(", Headers: {");
            builder.Append(String.Join(",", Headers));
            builder.Append("}");
            builder.Append(", ExposedHeaders: {");
            builder.Append(String.Join(",", ExposedHeaders));
            builder.Append("}");
            return builder.ToString();
        }
    }
}

================================================
FILE: src/System.Web.Cors/CorsRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Text;

namespace System.Web.Cors
{
    /// <summary>
    /// Provides access to CORS-specific information on the request.
    /// </summary>
    public class CorsRequestContext
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CorsRequestContext"/> class.
        /// </summary>
        public CorsRequestContext()
        {
            AccessControlRequestHeaders = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            Properties = new Dictionary<string, object>();
        }

        /// <summary>
        /// Gets or sets the request URI.
        /// </summary>
        public Uri RequestUri { get; set; }

        /// <summary>
        /// Gets or sets the request method.
        /// </summary>
        public string HttpMethod { get; set; }

        /// <summary>
        /// Gets or sets the Origin header value.
        /// </summary>
        public string Origin { get; set; }

        /// <summary>
        /// Gets or sets the Host header value.
        /// </summary>
        public string Host { get; set; }

        /// <summary>
        /// Gets or sets the Access-Control-Request-Method header value.
        /// </summary>
        public string AccessControlRequestMethod { get; set; }

        /// <summary>
        /// Gets the Access-Control-Request-Headers header value.
        /// </summary>
        public ISet<string> AccessControlRequestHeaders { get; private set; }

        /// <summary>
        /// Gets a set of properties for the <see cref="CorsRequestContext"/>.
        /// </summary>
        public IDictionary<string, object> Properties { get; private set; }

        /// <summary>
        /// Gets a value indicating whether this is a preflight request.
        /// </summary>
        public bool IsPreflight
        {
            get
            {
                return Origin != null &&
                    AccessControlRequestMethod != null &&
                    String.Equals(HttpMethod, CorsConstants.PreflightHttpMethod, StringComparison.OrdinalIgnoreCase);
            }
        }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String" /> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append("Origin: ");
            builder.Append(Origin ?? "null");
            builder.Append(", HttpMethod: ");
            builder.Append(HttpMethod ?? "null");
            builder.Append(", IsPreflight: ");
            builder.Append(IsPreflight);
            builder.Append(", Host: ");
            builder.Append(Host);
            builder.Append(", AccessControlRequestMethod: ");
            builder.Append(AccessControlRequestMethod ?? "null");
            builder.Append(", RequestUri: ");
            builder.Append(RequestUri);
            builder.Append(", AccessControlRequestHeaders: {");
            builder.Append(String.Join(",", AccessControlRequestHeaders));
            builder.Append("}");
            return builder.ToString();
        }
    }
}

================================================
FILE: src/System.Web.Cors/CorsResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Cors.Properties;

namespace System.Web.Cors
{
    /// <summary>
    /// Results returned by <see cref="CorsEngine"/>.
    /// </summary>
    public class CorsResult
    {
        private long? _preflightMaxAge;

        /// <summary>
        /// Initializes a new instance of the <see cref="CorsResult"/> class.
        /// </summary>
        public CorsResult()
        {
            AllowedMethods = new List<string>();
            AllowedHeaders = new List<string>();
            AllowedExposedHeaders = new List<string>();
            ErrorMessages = new List<string>();
        }

        /// <summary>
        /// Gets a value indicating whether the result is valid.
        /// </summary>
        public bool IsValid
        {
            get
            {
                return ErrorMessages.Count == 0;
            }
        }

        /// <summary>
        /// Gets the error messages.
        /// </summary>
        public IList<string> ErrorMessages { get; private set; }

        /// <summary>
        /// Gets or sets the allowed origin.
        /// </summary>
        public string AllowedOrigin { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether the resource supports user credentials.
        /// </summary>
        public bool SupportsCredentials { get; set; }

        /// <summary>
        /// Gets the allowed methods.
        /// </summary>
        public IList<string> AllowedMethods { get; private set; }

        /// <summary>
        /// Gets the allowed headers.
        /// </summary>
        public IList<string> AllowedHeaders { get; private set; }

        /// <summary>
        /// Gets the allowed headers that can be exposed on the response.
        /// </summary>
        public IList<string> AllowedExposedHeaders { get; private set; }

        /// <summary>
        /// Gets or sets the number of seconds the results of a preflight request can be cached.
        /// </summary>
        public long? PreflightMaxAge
        {
            get
            {
                return _preflightMaxAge;
            }
            set
            {
                if (value < 0)
                {
                    throw new ArgumentOutOfRangeException("value", SRResources.PreflightMaxAgeOutOfRange);
                }
                _preflightMaxAge = value;
            }
        }

        /// <summary>
        /// Returns CORS-specific headers that should be added to the response.
        /// </summary>
        /// <returns>The response headers.</returns>
        public virtual IDictionary<string, string> ToResponseHeaders()
        {
            IDictionary<string, string> headers = new Dictionary<string, string>();

            if (AllowedOrigin != null)
            {
                headers.Add(CorsConstants.AccessControlAllowOrigin, AllowedOrigin);
            }

            if (SupportsCredentials)
            {
                headers.Add(CorsConstants.AccessControlAllowCredentials, "true");
            }

            if (AllowedMethods.Count > 0)
            {
                // Filter out simple methods
                IEnumerable<string> nonSimpleAllowMethods = AllowedMethods.Where(m =>
                    !CorsConstants.SimpleMethods.Contains(m, StringComparer.OrdinalIgnoreCase));
                AddHeader(headers, CorsConstants.AccessControlAllowMethods, nonSimpleAllowMethods);
            }

            if (AllowedHeaders.Count > 0)
            {
                // Filter out simple request headers
                IEnumerable<string> nonSimpleAllowRequestHeaders = AllowedHeaders.Where(header =>
                    !CorsConstants.SimpleRequestHeaders.Contains(header, StringComparer.OrdinalIgnoreCase));
                AddHeader(headers, CorsConstants.AccessControlAllowHeaders, nonSimpleAllowRequestHeaders);
            }

            if (AllowedExposedHeaders.Count > 0)
            {
                // Filter out simple response headers
                IEnumerable<string> nonSimpleAllowResponseHeaders = AllowedExposedHeaders.Where(header =>
                    !CorsConstants.SimpleResponseHeaders.Contains(header, StringComparer.OrdinalIgnoreCase));
                AddHeader(headers, CorsConstants.AccessControlExposeHeaders, nonSimpleAllowResponseHeaders);
            }

            if (PreflightMaxAge.HasValue)
            {
                headers.Add(CorsConstants.AccessControlMaxAge, PreflightMaxAge.ToString());
            }

            return headers;
        }

        /// <summary>
        /// Returns a <see cref="System.String" /> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String" /> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append("IsValid: ");
            builder.Append(IsValid);
            builder.Append(", AllowCredentials: ");
            builder.Append(SupportsCredentials);
            builder.Append(", PreflightMaxAge: ");
            builder.Append(PreflightMaxAge.HasValue ? PreflightMaxAge.Value.ToString(CultureInfo.InvariantCulture) : "null");
            builder.Append(", AllowOrigin: ");
            builder.Append(AllowedOrigin);
            builder.Append(", AllowExposedHeaders: {");
            builder.Append(String.Join(",", AllowedExposedHeaders));
            builder.Append("}");
            builder.Append(", AllowHeaders: {");
            builder.Append(String.Join(",", AllowedHeaders));
            builder.Append("}");
            builder.Append(", AllowMethods: {");
            builder.Append(String.Join(",", AllowedMethods));
            builder.Append("}");
            builder.Append(", ErrorMessages: {");
            builder.Append(String.Join(",", ErrorMessages));
            builder.Append("}");
            return builder.ToString();
        }

        private static void AddHeader(IDictionary<string, string> headers, string headerName, IEnumerable<string> headerValues)
        {
            string methods = String.Join(",", headerValues);
            if (!String.IsNullOrEmpty(methods))
            {
                headers.Add(headerName, methods);
            }
        }
    }
}

================================================
FILE: src/System.Web.Cors/ICorsEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Cors
{
    /// <summary>
    /// Provides an abstraction for evaluating CORS requests based on <see cref="CorsPolicy"/>.
    /// </summary>
    public interface ICorsEngine
    {
        /// <summary>
        /// Evaluates the policy.
        /// </summary>
        /// <param name="requestContext">The <see cref="CorsRequestContext"/>.</param>
        /// <param name="policy">The <see cref="CorsPolicy"/>.</param>
        /// <returns>The <see cref="CorsResult"/></returns>
        CorsResult EvaluatePolicy(CorsRequestContext requestContext, CorsPolicy policy);
    }
}

================================================
FILE: src/System.Web.Cors/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Reflection;

[assembly: AssemblyTitle("System.Web.Cors")]
[assembly: AssemblyDescription("")]
[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "This assembly is delay-signed.")]

================================================
FILE: src/System.Web.Cors/Properties/SRResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18033
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Cors.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class SRResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SRResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Cors.Properties.SRResources", typeof(SRResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collection of headers &apos;{0}&apos; is not allowed..
        /// </summary>
        internal static string HeadersNotAllowed {
            get {
                return ResourceManager.GetString("HeadersNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The method &apos;{0}&apos; is not allowed..
        /// </summary>
        internal static string MethodNotAllowed {
            get {
                return ResourceManager.GetString("MethodNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request does not contain the Origin header..
        /// </summary>
        internal static string NoOriginHeader {
            get {
                return ResourceManager.GetString("NoOriginHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The origin &apos;{0}&apos; is not allowed..
        /// </summary>
        internal static string OriginNotAllowed {
            get {
                return ResourceManager.GetString("OriginNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PreflightMaxAge must be greater than or equal to 0..
        /// </summary>
        internal static string PreflightMaxAgeOutOfRange {
            get {
                return ResourceManager.GetString("PreflightMaxAgeOutOfRange", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Cors/Properties/SRResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="HeadersNotAllowed" xml:space="preserve">
    <value>The collection of headers '{0}' is not allowed.</value>
  </data>
  <data name="MethodNotAllowed" xml:space="preserve">
    <value>The method '{0}' is not allowed.</value>
  </data>
  <data name="NoOriginHeader" xml:space="preserve">
    <value>The request does not contain the Origin header.</value>
  </data>
  <data name="OriginNotAllowed" xml:space="preserve">
    <value>The origin '{0}' is not allowed.</value>
  </data>
  <data name="PreflightMaxAgeOutOfRange" xml:space="preserve">
    <value>PreflightMaxAge must be greater than or equal to 0.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Cors/System.Web.Cors.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{43C1B979-D593-4A32-BB3A-4316F1C66D66}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Cors</RootNamespace>
    <AssemblyName>System.Web.Cors</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
  </PropertyGroup>
  <PropertyGroup>
    <SignAssembly>true</SignAssembly>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="CorsPolicy.cs" />
    <Compile Include="ICorsEngine.cs" />
    <Compile Include="CorsConstants.cs" />
    <Compile Include="CorsEngine.cs" />
    <Compile Include="CorsRequestContext.cs" />
    <Compile Include="CorsResult.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\SRResources.Designer.cs">
      <DependentUpon>SRResources.resx</DependentUpon>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\SRResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>SRResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Helpers/Chart/Chart.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.IO;
using System.Text;
using System.Web.Helpers.Resources;
using System.Web.Hosting;
using System.Web.UI.DataVisualization.Charting;
using System.Web.UI.WebControls;
using System.Web.WebPages;
using System.Xml;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    // Post-Beta Work:
    // -DataBind and Points.DataBind - need to find scenarios
    // -Elements: Annotations, MapAreas
    // -Interactivity / AJAX support?
    public class Chart
    {
        private readonly int _height;
        private readonly int _width;
        private readonly string _themePath;
        private readonly string _theme;

        private readonly List<LegendData> _legends = new List<LegendData>();
        private readonly List<SeriesData> _series = new List<SeriesData>();
        private readonly List<TitleData> _titles = new List<TitleData>();

        private HttpContextBase _httpContext;
        private Func<VirtualPathProvider> _virtualPathProviderFunc;

        private string _path;

        private DataSourceData _dataSource;
        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "_xAxis, _yAxis",
           Justification = "These names make most sense.")]
        private ChartAxisData _xAxis, _yAxis;

#if CODE_COVERAGE
        [ExcludeFromCodeCoverage]
#endif

        /// <param name="width">Chart width in pixels.</param>
        /// <param name="height">Chart height in pixels.</param>
        /// <param name="theme">String containing chart theme definition. Chart's theme defines properties like colors, positions, etc.
        /// This parameter is primarily meant for one of the predefined Chart themes, however any valid chart theme is acceptable.</param>
        /// <param name="themePath">Path to a file containing definition of chart theme, default is none.</param>
        /// <remarks>Both the theme and themePath parameters can be specified. In this case, the Chart class applies the theme xml first 
        /// followed by the content of file at themePath.
        /// </remarks>
        /// <example>
        /// Chart(100, 100, theme: ChartTheme.Blue)
        /// Chart(100, 100, theme: ChartTheme.Vanilla, themePath: "my-theme.xml")
        /// Chart(100, 100, theme: ".... definition inline ...." ) 
        /// Chart(100, 100, themePath: "my-theme.xml")
        /// Any valid theme definition can be used as content of the file specified in themePath
        /// </example>
        public Chart(
            int width,
            int height,
            string theme = null,
            string themePath = null)
            : this(GetDefaultContext(), () => HostingEnvironment.VirtualPathProvider, width, height, theme, themePath)
        {
        }

        // Overload used only for testing
        internal Chart(HttpContextBase httpContext, VirtualPathProvider virtualPathProvider, int width, int height,
                       string theme = null, string themePath = null)
            : this(httpContext, () => virtualPathProvider, width, height, theme, themePath)
        {
        }

        internal Chart(HttpContextBase httpContext, Func<VirtualPathProvider> virtualPathProviderFunc,
            int width, int height, string theme = null, string themePath = null)
        {
            Contract.Assert(httpContext != null);
            Contract.Assert(virtualPathProviderFunc != null);

            // HostingEnvironment.VirtualPathProvider never null in running host but may change at any time.
            Contract.Assert(virtualPathProviderFunc() != null);

            if (width < 0)
            {
                throw new ArgumentOutOfRangeException("width", String.Format(
                    CultureInfo.CurrentCulture,
                    CommonResources.Argument_Must_Be_GreaterThanOrEqualTo,
                    0));
            }
            if (height < 0)
            {
                throw new ArgumentOutOfRangeException("height", String.Format(
                    CultureInfo.CurrentCulture,
                    CommonResources.Argument_Must_Be_GreaterThanOrEqualTo,
                    0));
            }

            _httpContext = httpContext;
            _virtualPathProviderFunc = virtualPathProviderFunc;
            _width = width;
            _height = height;
            _theme = theme;

            // path must be app-relative in case chart is rendered from handler in different directory
            if (!String.IsNullOrEmpty(themePath))
            {
                _themePath = VirtualPathUtil.ResolvePath(TemplateStack.GetCurrentTemplate(httpContext), httpContext, themePath);
                if (!virtualPathProviderFunc().FileExists(_themePath))
                {
                    throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, HelpersResources.Chart_ThemeFileNotFound, _themePath), "themePath");
                }
            }
        }

        public string FileName
        {
            get { return _path; }
        }

        public int Height
        {
            get { return _height; }
        }

        public int Width
        {
            get { return _width; }
        }

        /// <param name="title">Legend title.</param>
        /// <param name="name">Legend name.</param>
        public Chart AddLegend(
            string title = null,
            string name = null)
        {
            _legends.Add(new LegendData
            {
                Name = name,
                Title = title
            });
            return this;
        }

        /// <param name="name">Series name.</param>
        /// <param name="chartType">Chart type (see: SeriesChartType).</param>
        /// <param name="chartArea">Chart area where the series is displayed.</param>
        /// <param name="axisLabel">Axis label for the series.</param>
        /// <param name="legend">Legend for the series.</param>
        /// <param name="markerStep">Axis marker step.</param>
        /// <param name="xValue">X data source, if data-binding the series.</param>
        /// <param name="xField">Column for the X data points, if data-binding the series.</param>
        /// <param name="yValues">Y data source(s), if data-binding the series.</param>
        /// <param name="yFields">Column(s) for the Y data points, if data-binding the series.</param>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "x",
            Justification = "Name based on X-axis. Suppressed in source because this is a one-time occurrence")]
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "y",
            Justification = "Name based on Y-axis. Suppressed in source because this is a one-time occurrence")]
        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "xValue, xField, yValues, yFields",
            Justification = "These names cannot be changed because this is a public method.")]
        public Chart AddSeries(
            string name = null,
            string chartType = "Column",
            string chartArea = null,
            string axisLabel = null,
            string legend = null,
            int markerStep = 1,
            IEnumerable xValue = null,
            string xField = null,
            IEnumerable yValues = null,
            string yFields = null)
        {
            if (String.IsNullOrEmpty(chartType))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "chartType");
            }

            DataSourceData dataSource = null;
            if (yValues != null)
            {
                dataSource = new DataSourceData
                {
                    XDataSource = xValue,
                    XField = xField,
                    DataSource = yValues,
                    YFields = yFields
                };
            }

            _series.Add(new SeriesData
            {
                Name = name,
                ChartType = ConvertStringArgument<SeriesChartType>("chartType", chartType),
                ChartArea = chartArea,
                AxisLabel = axisLabel,
                Legend = legend,
                MarkerStep = markerStep,
                DataSource = dataSource
            });
            return this;
        }

        /// <param name="text">Title text.</param>
        /// <param name="name">Title name.</param>
        public Chart AddTitle(
            string text = null,
            string name = null)
        {
            _titles.Add(new TitleData
            {
                Name = name,
                Text = text
            });
            return this;
        }

        /// <param name="title">Title for X-axis</param>
        /// <param name="min">The minimum value on X-axis. Default 0</param>
        /// <param name="max">The maximum value on X-axis. Default NaN</param>
        public Chart SetXAxis(
            string title = "",
            double min = 0,
            double max = Double.NaN)
        {
            _xAxis = new ChartAxisData { Title = title, Minimum = min, Maximum = max };
            return this;
        }

        /// <param name="title">Title for Y-axis</param>
        /// <param name="min">The minimum value on Y-axis. Default 0</param>
        /// <param name="max">The maximum value on Y-axis. Default NaN</param>
        public Chart SetYAxis(
            string title = "",
            double min = 0,
            double max = Double.NaN)
        {
            _yAxis = new ChartAxisData { Title = title, Minimum = min, Maximum = max };
            return this;
        }

        /// <summary>
        /// Data-binds the chart by grouping values in a series.  The series will be created by the chart.
        /// </summary>
        /// <param name="dataSource">Chart data source.</param>
        /// <param name="groupByField">Column which series should be grouped by.</param>
        /// <param name="xField">Column for the X data points.</param>
        /// <param name="yFields">Column(s) for the Y data points, separated by comma.</param>
        /// <param name="otherFields"></param>
        /// <param name="pointSortOrder">Sort order (see: PointSortOrder).</param>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "x",
            Justification = "Name based on X-axis. Suppressed in source because this is a one-time occurrence")]
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "y",
            Justification = "Name based on Y-axis. Suppressed in source because this is a one-time occurrence")]
        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "xField, yFields",
            Justification = "These names cannot be changed because this is a public method.")]
        public Chart DataBindCrossTable(IEnumerable dataSource, string groupByField, string xField, string yFields,
                                        string otherFields = null, string pointSortOrder = "Ascending")
        {
            if (dataSource == null)
            {
                throw new ArgumentNullException("dataSource");
            }
            if (dataSource is string)
            {
                throw new ArgumentException(HelpersResources.Chart_ExceptionDataBindSeriesToString, "dataSource");
            }
            if (String.IsNullOrEmpty(groupByField))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "groupByField");
            }
            if (String.IsNullOrEmpty(yFields))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "yFields");
            }

            _dataSource = new DataSourceData
            {
                DataSource = dataSource,
                GroupByField = groupByField,
                XField = xField,
                YFields = yFields,
                OtherFields = otherFields,
                PointSortOrder = ConvertStringArgument<PointSortOrder>("pointSortOrder", pointSortOrder)
            };
            return this;
        }

        /// <summary>
        /// Data-binds the chart using a data source, with multiple y values supported.  The series will be created by the chart.
        /// </summary>
        /// <param name="dataSource">Chart data source.</param>
        /// <param name="xField">Column for the X data points.</param>
        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "x",
            Justification = "Name based on X-axis. Suppressed in source because this is a one-time occurrence")]
        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "xField",
            Justification = "These names cannot be changed because this is a public method.")]
        public Chart DataBindTable(IEnumerable dataSource, string xField = null)
        {
            if (dataSource == null)
            {
                throw new ArgumentNullException("dataSource");
            }
            if (dataSource is string)
            {
                throw new ArgumentException(HelpersResources.Chart_ExceptionDataBindSeriesToString, "dataSource");
            }

            _dataSource = new DataSourceData
            {
                DataBindTable = true,
                DataSource = dataSource,
                XField = xField
            };
            return this;
        }

        /// <summary>
        /// Get the bytes for the chart image.
        /// </summary>
        /// <param name="format">Image format (see: ChartImageFormat).</param>
        public byte[] GetBytes(string format = "jpeg")
        {
            var imageFormat = ConvertStringToChartImageFormat(format);
            using (MemoryStream stream = new MemoryStream())
            {
                ExecuteChartAction(c =>
                {
                    c.SaveImage(stream, imageFormat);
                });
                return stream.ToArray();
            }
        }

#if CODE_COVERAGE
        [ExcludeFromCodeCoverage]
#endif

        /// <summary>
        /// Loads a chart from the cache. This can be used to render from an image handler.
        /// </summary>
        /// <param name="key">Cache key.</param>
        public static Chart GetFromCache(string key)
        {
            return GetFromCache(GetDefaultContext(), key);
        }

        /// <summary>
        /// Saves the chart image to a file.
        /// </summary>
        /// <param name="path">File path.</param>
        /// <param name="format">Chart image format (see: ChartImageFormat).</param>
        public Chart Save(string path, string format = "jpeg")
        {
            return Save(GetDefaultContext(), path, format);
        }

        internal Chart Save(HttpContextBase httpContext, string path, string format)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }
            var imageFormat = ConvertStringToChartImageFormat(format);

            _path = VirtualPathUtil.MapPath(httpContext, path);
            ExecuteChartAction(c =>
            {
                c.RenderType = RenderType.ImageTag;
                c.SaveImage(FileName, imageFormat);
            });
            return this;
        }

        /// <summary>
        /// Saves the chart in cache.  This can be used to render from an image handler.
        /// </summary>
        /// <param name="key">Cache key.  Uses new GUID by default.</param>
        /// <param name="minutesToCache">Number of minutes to save in cache.</param>
        /// <param name="slidingExpiration">Whether a sliding expiration policy is used.</param>
        /// <returns>Cache key.</returns>
        public string SaveToCache(string key = null, int minutesToCache = 20, bool slidingExpiration = true)
        {
            if (String.IsNullOrEmpty(key))
            {
                key = GetUniqueKey();
            }

            WebCache.Set(key, this, minutesToCache, slidingExpiration);
            return key;
        }

        /// <summary>
        /// Saves the chart to the specified template file.
        /// </summary>
        /// <param name="path">XML template file path.</param>
        public Chart SaveXml(string path)
        {
            return SaveXml(GetDefaultContext(), path);
        }

        /// <summary>
        /// Saves the chart to the specified template file.
        /// </summary>
        /// <param name="httpContext">The <see cref="HttpContextBase"/>.</param>
        /// <param name="path">XML template file path.</param>
        internal Chart SaveXml(HttpContextBase httpContext, string path)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }

            ExecuteChartAction(c =>
            {
                c.SaveXml(VirtualPathUtil.MapPath(httpContext, path));
            });
            return this;
        }

        public WebImage ToWebImage(string format = "jpeg")
        {
            return new WebImage(GetBytes(format));
        }

        /// <summary>
        /// Writes the chart image to the response stream.  This can be used to render from an image handler.
        /// </summary>
        /// <param name="format">Image format (see: ChartImageFormat).</param>
        public Chart Write(string format = "jpeg")
        {
            var response = _httpContext.Response;
            response.Charset = String.Empty;
            response.ContentType = "image/" + NormalizeFormat(format);
            response.BinaryWrite(GetBytes(format));
            return this;
        }

#if CODE_COVERAGE
        [ExcludeFromCodeCoverage]
#endif

        /// <summary>
        /// Writes a chart stored in cache to the response stream.  This can be used to render from an image handler.
        /// </summary>
        /// <param name="key">Cache key.</param>
        /// <param name="format">Image format (see: ChartImageFormat).</param>
        public static Chart WriteFromCache(string key, string format = "jpeg")
        {
            return WriteFromCache(GetDefaultContext(), key, format);
        }

        // create and execute an action against the WebForm control in a limited scope since the control is disposable.
        internal void ExecuteChartAction(Action<UI.DataVisualization.Charting.Chart> action)
        {
            using (UI.DataVisualization.Charting.Chart chart = new UI.DataVisualization.Charting.Chart())
            {
                chart.Width = new Unit(_width);
                chart.Height = new Unit(_height);

                ApplyChartArea(chart);
                ApplyLegends(chart);
                ApplySeries(chart);
                ApplyTitles(chart);

                DataBindChart(chart);

                // load the template last so that it can be applied to all the chart elements
                LoadThemes(chart);

                action(chart);
            }
        }

        private void LoadThemes(UI.DataVisualization.Charting.Chart chart)
        {
            if (!String.IsNullOrEmpty(_theme))
            {
                using (MemoryStream memoryStream = new MemoryStream())
                {
                    byte[] themeContent = Encoding.UTF8.GetBytes(_theme);
                    memoryStream.Write(themeContent, 0, themeContent.Length);
                    memoryStream.Seek(0, SeekOrigin.Begin);

                    LoadChartThemeFromFile(chart, memoryStream);
                }
            }

            if (!String.IsNullOrEmpty(_themePath))
            {
                using (Stream stream = _virtualPathProviderFunc().GetFile(_themePath).Open())
                {
                    LoadChartThemeFromFile(chart, stream);
                }
            }
        }

        private static void LoadChartThemeFromFile(UI.DataVisualization.Charting.Chart chart, Stream templateStream)
        {
            // workarounds for Chart templating bugs mentioned in:
            // http://social.msdn.microsoft.com/Forums/en-US/MSWinWebChart/thread/b50d5b7e-30e2-4948-af7a-370d9be1268a
            chart.Serializer.Content = SerializationContents.All;
            chart.Serializer.SerializableContent = String.Empty; // deserialize all content
            chart.Serializer.IsTemplateMode = true;
            chart.Serializer.IsResetWhenLoading = false;
            // loading serializer with stream to avoid bug with template file getting locked in VS

            // The default xml reader used by the serializer does not ignore comments
            // Using the IsUnknownAttributeIgnored fixes this, but then it would give no feedback to the user 
            // if member names do not match the spelling and casing of Chart properties. 
            XmlReader reader = XmlReader.Create(templateStream, new XmlReaderSettings { IgnoreComments = true });
            chart.Serializer.Load(reader);
        }

        internal static Chart GetFromCache(HttpContextBase context, string key)
        {
            Contract.Assert(context != null);

            if (String.IsNullOrEmpty(key))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "key");
            }

            var chart = WebCache.Get(key) as Chart;
            if (chart != null)
            {
                chart._httpContext = context;
            }
            return chart;
        }

        internal static Chart WriteFromCache(HttpContextBase context, string key, string format = "jpeg")
        {
            var chart = GetFromCache(context, key);
            if (chart != null)
            {
                chart.Write(format);
            }
            return chart;
        }

        // Notes on ApplyXXX methods:
        // Chart elements should be configured before they are added to the chart, otherwise there
        // will be some rendering problems.
        // We must catch all exceptions when configuring chart elements and dispose of them manually
        // if they have not been added to the chart yet, otherwise FxCop will complain.

        private void ApplyChartArea(UI.DataVisualization.Charting.Chart chart)
        {
            ChartArea chartArea = new ChartArea("Default");
            try
            {
                ApplyAxis(chartArea.AxisX, _xAxis);
                ApplyAxis(chartArea.AxisY, _yAxis);
                chart.ChartAreas.Add(chartArea);
            }
            catch
            {
                // This is to appease FxCop
                chartArea.Dispose();
                throw;
            }
        }

        private static void ApplyAxis(Axis axis, ChartAxisData axisData)
        {
            if (axisData == null)
            {
                return;
            }

            if (!String.IsNullOrEmpty(axisData.Title))
            {
                axis.Title = axisData.Title;
            }
            axis.Minimum = axisData.Minimum;
            axis.Maximum = axisData.Maximum;
        }

        private void ApplyLegends(UI.DataVisualization.Charting.Chart chart)
        {
            foreach (var legendData in _legends)
            {
                var legend = new Legend();
                try
                {
                    legend.Name = legendData.Name ?? String.Empty;
                    legend.Title = legendData.Title ?? String.Empty;
                }
                catch (Exception)
                {
                    // see notes above
                    legend.Dispose();
                    throw;
                }
                chart.Legends.Add(legend);
            }
        }

        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "yValues, yValuesArray",
            Justification = "These names make the most sense.")]
        private void ApplySeries(UI.DataVisualization.Charting.Chart chart)
        {
            foreach (var seriesData in _series)
            {
                var series = new Series();
                try
                {
                    series.AxisLabel = seriesData.AxisLabel ?? String.Empty;
                    series.ChartArea = seriesData.ChartArea ?? String.Empty;
                    series.ChartType = seriesData.ChartType;
                    series.Legend = seriesData.Legend ?? String.Empty;
                    series.MarkerStep = seriesData.MarkerStep;
                    series.Name = seriesData.Name ?? String.Empty;

                    // data-bind the series (todo - support o.Points.DataBind())
                    if (seriesData.DataSource != null)
                    {
                        if (String.IsNullOrEmpty(seriesData.DataSource.YFields))
                        {
                            var yValues = seriesData.DataSource.DataSource;
                            var yValuesArray = yValues as IEnumerable[];
                            if ((yValuesArray != null) && !(yValues is string[]))
                            {
                                series.Points.DataBindXY(seriesData.DataSource.XDataSource, yValuesArray);
                            }
                            else
                            {
                                series.Points.DataBindXY(seriesData.DataSource.XDataSource, yValues);
                            }
                        }
                        else
                        {
                            series.Points.DataBindXY(seriesData.DataSource.XDataSource, seriesData.DataSource.XField,
                                                     seriesData.DataSource.DataSource, seriesData.DataSource.YFields);
                        }
                    }
                }
                catch (Exception)
                {
                    // see notes above
                    series.Dispose();
                    throw;
                }
                chart.Series.Add(series);
            }
        }

        private void ApplyTitles(UI.DataVisualization.Charting.Chart chart)
        {
            foreach (var titleData in _titles)
            {
                var title = new Title();
                try
                {
                    title.Name = titleData.Name;
                    title.Text = titleData.Text;
                }
                catch (Exception)
                {
                    // see notes above
                    title.Dispose();
                    throw;
                }
                chart.Titles.Add(title);
            }
        }

        private static T ConvertStringArgument<T>(string paramName, string value)
        {
            object result;
            if (!ConversionUtil.TryFromString(typeof(T), value, out result))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          HelpersResources.Chart_ArgumentConversionFailed, typeof(T).FullName), paramName);
            }
            return (T)result;
        }

        /// <summary>
        /// Method to convert a string to a ChartImageFormat.
        /// The chart image needs to be normalized to allow for alternate names such as 'jpg', 'xpng' etc 
        /// to be mapped to their appropriate ChartImageFormat.
        /// </summary>
        private static ChartImageFormat ConvertStringToChartImageFormat(string format)
        {
            object result;
            format = NormalizeFormat(format);
            if (!ConversionUtil.TryFromString(typeof(ChartImageFormat), format, out result))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          HelpersResources.Image_IncorrectImageFormat, format), "format");
            }
            return (ChartImageFormat)result;
        }

        private void DataBindChart(UI.DataVisualization.Charting.Chart chart)
        {
            // NOTE: WebForms chart will throw null refs if optional values are set to null
            if (_dataSource != null)
            {
                if (!String.IsNullOrEmpty(_dataSource.GroupByField))
                {
                    chart.DataBindCrossTable(
                        _dataSource.DataSource,
                        _dataSource.GroupByField,
                        _dataSource.XField ?? String.Empty,
                        _dataSource.YFields,
                        _dataSource.OtherFields ?? String.Empty,
                        _dataSource.PointSortOrder);
                }
                else if (_dataSource.DataBindTable)
                {
                    chart.DataBindTable(
                        _dataSource.DataSource,
                        _dataSource.XField ?? String.Empty);
                }
                else
                {
                    Debug.Assert(false, "Chart.DataBind was removed - should not reach here");
                    //chart.DataSource = _dataSource.DataSource;
                    //chart.DataBind();
                }
            }
        }

#if CODE_COVERAGE
        [ExcludeFromCodeCoverage]
#endif

        private static HttpContextBase GetDefaultContext()
        {
            return new HttpContextWrapper(HttpContext.Current);
        }

        // review: should GUIDs be used in a handler's querystring?
        private static string GetUniqueKey()
        {
            return Guid.NewGuid().ToString();
        }

        private static string NormalizeFormat(string format)
        {
            if (String.IsNullOrEmpty(format))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "format");
            }
            if (format.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
            {
                format = format.Substring(6);
            }
            return ConversionUtil.NormalizeImageFormat(format);
        }

        // data-binding can be done through Chart or individual Series
        private class DataSourceData
        {
            public bool DataBindTable { get; set; }
            public IEnumerable DataSource { get; set; }
            public string GroupByField { get; set; }
            public string OtherFields { get; set; }
            public string XField { get; set; }
            public string YFields { get; set; }
            public PointSortOrder PointSortOrder { get; set; }

            // optional XValue for Series.Points.DataBindXY only:
            public IEnumerable XDataSource { get; set; }
        }

        private class LegendData
        {
            public string Name { get; set; }
            public string Title { get; set; }
        }

        private class SeriesData
        {
            public string AxisLabel { get; set; }
            public string ChartArea { get; set; }
            public SeriesChartType ChartType { get; set; }
            public string Legend { get; set; }
            public int MarkerStep { get; set; }
            public string Name { get; set; }
            public DataSourceData DataSource { get; set; }
        }

        private class TitleData
        {
            public string Name { get; set; }
            public string Text { get; set; }
        }

        private class ChartAxisData
        {
            public double Minimum { get; set; }
            public double Maximum { get; set; }
            public string Title { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.Helpers/Chart/ChartTheme.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers
{
    public static class ChartTheme
    {
        // Review: Need better names.

        public const string Blue =
            @"<Chart BackColor=""#D3DFF0"" BackGradientStyle=""TopBottom"" BackSecondaryColor=""White"" BorderColor=""26, 59, 105"" BorderlineDashStyle=""Solid"" BorderWidth=""2"" Palette=""BrightPastel"">
    <ChartAreas>
        <ChartArea Name=""Default"" _Template_=""All"" BackColor=""64, 165, 191, 228"" BackGradientStyle=""TopBottom"" BackSecondaryColor=""White"" BorderColor=""64, 64, 64, 64"" BorderDashStyle=""Solid"" ShadowColor=""Transparent"" /> 
    </ChartAreas>
    <Legends>
        <Legend _Template_=""All"" BackColor=""Transparent"" Font=""Trebuchet MS, 8.25pt, style=Bold"" IsTextAutoFit=""False"" /> 
    </Legends>
    <BorderSkin SkinStyle=""Emboss"" /> 
  </Chart>";

        public const string Green =
            @"<Chart BackColor=""#C9DC87"" BackGradientStyle=""TopBottom"" BorderColor=""181, 64, 1"" BorderWidth=""2"" BorderlineDashStyle=""Solid"" Palette=""BrightPastel"">
  <ChartAreas>
    <ChartArea Name=""Default"" _Template_=""All"" BackColor=""Transparent"" BackSecondaryColor=""White"" BorderColor=""64, 64, 64, 64"" BorderDashStyle=""Solid"" ShadowColor=""Transparent"">
      <AxisY LineColor=""64, 64, 64, 64"">
        <MajorGrid Interval=""Auto"" LineColor=""64, 64, 64, 64"" />
        <LabelStyle Font=""Trebuchet MS, 8.25pt, style=Bold"" />
      </AxisY>
      <AxisX LineColor=""64, 64, 64, 64"">
        <MajorGrid LineColor=""64, 64, 64, 64"" />
        <LabelStyle Font=""Trebuchet MS, 8.25pt, style=Bold"" />
      </AxisX>
      <Area3DStyle Inclination=""15"" IsClustered=""False"" IsRightAngleAxes=""False"" Perspective=""10"" Rotation=""10"" WallWidth=""0"" />
    </ChartArea>
  </ChartAreas>
  <Legends>
    <Legend _Template_=""All"" Alignment=""Center"" BackColor=""Transparent"" Docking=""Bottom"" Font=""Trebuchet MS, 8.25pt, style=Bold"" IsTextAutoFit =""False"" LegendStyle=""Row"">
    </Legend>
  </Legends>
  <BorderSkin SkinStyle=""Emboss"" />
</Chart>";

        public const string Vanilla =
            @"<Chart Palette=""SemiTransparent"" BorderColor=""#000"" BorderWidth=""2"" BorderlineDashStyle=""Solid"">
<ChartAreas>
    <ChartArea _Template_=""All"" Name=""Default"">
            <AxisX>
                <MinorGrid Enabled=""False"" />
                <MajorGrid Enabled=""False"" />
            </AxisX>
            <AxisY>
                <MajorGrid Enabled=""False"" />
                <MinorGrid Enabled=""False"" />
            </AxisY>
    </ChartArea>
</ChartAreas>
</Chart>";

        public const string Vanilla3D =
            @"<Chart BackColor=""#555"" BackGradientStyle=""TopBottom"" BorderColor=""181, 64, 1"" BorderWidth=""2"" BorderlineDashStyle=""Solid"" Palette=""SemiTransparent"" AntiAliasing=""All"">
    <ChartAreas>
        <ChartArea Name=""Default"" _Template_=""All"" BackColor=""Transparent"" BackSecondaryColor=""White"" BorderColor=""64, 64, 64, 64"" BorderDashStyle=""Solid"" ShadowColor=""Transparent"">
            <Area3DStyle LightStyle=""Simplistic"" Enable3D=""True"" Inclination=""30"" IsClustered=""False"" IsRightAngleAxes=""False"" Perspective=""10"" Rotation=""-30"" WallWidth=""0"" />
        </ChartArea>
    </ChartAreas>
</Chart>";

        public const string Yellow =
            @"<Chart BackColor=""#FADA5E"" BackGradientStyle=""TopBottom"" BorderColor=""#B8860B"" BorderWidth=""2"" BorderlineDashStyle=""Solid"" Palette=""EarthTones"">
  <ChartAreas>
    <ChartArea Name=""Default"" _Template_=""All"" BackColor=""Transparent"" BackSecondaryColor=""White"" BorderColor=""64, 64, 64, 64"" BorderDashStyle=""Solid"" ShadowColor=""Transparent"">
      <AxisY>
        <LabelStyle Font=""Trebuchet MS, 8.25pt, style=Bold"" />
      </AxisY>
      <AxisX LineColor=""64, 64, 64, 64"">
        <LabelStyle Font=""Trebuchet MS, 8.25pt, style=Bold"" />
      </AxisX>
    </ChartArea>
  </ChartAreas>
  <Legends>
    <Legend _Template_=""All"" BackColor=""Transparent"" Docking=""Bottom"" Font=""Trebuchet MS, 8.25pt, style=Bold"" LegendStyle=""Row"">
    </Legend>
  </Legends>
  <BorderSkin SkinStyle=""Emboss"" />
</Chart>";
    }
}


================================================
FILE: src/System.Web.Helpers/Common/VirtualPathUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Web.Helpers.Resources;
using System.Web.WebPages;

namespace System.Web.Helpers
{
    internal static class VirtualPathUtil
    {
        /// <summary>
        /// Resolves and maps a path (physical or virtual) to a physical path on the server. 
        /// </summary>
        /// <param name="httpContext">The <see cref="HttpContextBase"/>.</param>
        /// <param name="path">Either a physical rooted path or a virtual path to be mapped.
        /// Physical paths are returned without modifications. Virtual paths are resolved relative to the current executing page.
        /// </param>
        /// <remarks>Result of this call should not be shown to the user (e.g. in an exception message) since
        /// it could be security sensitive. But we need to pass this result to the file APIs like File.WriteAllBytes
        /// which will show it if exceptions are raised from them. Unfortunately VirtualPathProvider doesn't have
        /// APIs for writing so we can't use that.</remarks>
        public static string MapPath(HttpContextBase httpContext, string path)
        {
            Debug.Assert(!String.IsNullOrEmpty(path));

            if (Path.IsPathRooted(path))
            {
                return path;
            }

            // There is no TryMapPath API so we have to catch HttpException if we want to
            // throw ArgumentException instead.  
            try
            {
                return httpContext.Request.MapPath(ResolvePath(TemplateStack.GetCurrentTemplate(httpContext), httpContext, path));
            }
            catch (HttpException)
            {
                throw new ArgumentException(
                    String.Format(CultureInfo.InvariantCulture, HelpersResources.PathUtils_IncorrectPath, path), "path");
            }
        }

        /// <summary>
        /// Resolves path relative to the current executing page
        /// </summary>
        public static string ResolvePath(string virtualPath)
        {
            if (String.IsNullOrEmpty(virtualPath))
            {
                return virtualPath;
            }

            if (HttpContext.Current == null)
            {
                return virtualPath;
            }
            var httpContext = new HttpContextWrapper(HttpContext.Current);
            return ResolvePath(TemplateStack.GetCurrentTemplate(httpContext), httpContext, virtualPath);
        }

        internal static string ResolvePath(ITemplateFile templateFile, HttpContextBase httpContext, string virtualPath)
        {
            Debug.Assert(!String.IsNullOrEmpty(virtualPath));
            string basePath;
            if (templateFile != null)
            {
                // If a page is available resolve paths relative to it.
                basePath = templateFile.TemplateInfo.VirtualPath;
            }
            else
            {
                basePath = httpContext.Request.AppRelativeCurrentExecutionFilePath;
            }
            return VirtualPathUtility.Combine(basePath, virtualPath);
        }
    }
}


================================================
FILE: src/System.Web.Helpers/ConversionUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Drawing.Imaging;
using System.Reflection;

namespace System.Web.Helpers
{
    internal static class ConversionUtil
    {
        private static MethodInfo _stringToEnumMethod;

        internal static string ToString<T>(T obj)
        {
            Type type = typeof(T);
            if (type.IsEnum)
            {
                return obj.ToString();
            }
            TypeConverter converter = TypeDescriptor.GetConverter(type);
            if ((converter != null) && (converter.CanConvertTo(typeof(string))))
            {
                return converter.ConvertToInvariantString(obj);
            }
            return null;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "TypeConverter throws System.Exception instead of a more specific one.")]
        internal static bool TryFromString(Type type, string value, out object result)
        {
            result = null;
            if (type == typeof(string))
            {
                result = value;
                return true;
            }
            if (type.IsEnum)
            {
                return TryFromStringToEnumHelper(type, value, out result);
            }
            if (type == typeof(Color))
            {
                Color color;
                bool rval = TryFromStringToColor(value, out color);
                result = color;
                return rval;
            }
            // TypeConverter doesn't really have TryConvert APIs.  We should avoid TypeConverter.IsValid
            // which performs a duplicate conversion, and just handle the general exception ourselves.
            TypeConverter converter = TypeDescriptor.GetConverter(type);
            if ((converter != null) && converter.CanConvertFrom(typeof(string)))
            {
                try
                {
                    result = converter.ConvertFromInvariantString(value);
                    return true;
                }
                catch
                {
                    // Do nothing
                }
            }
            return false;
        }

        internal static bool TryFromStringToEnum<T>(string value, out T result) where T : struct
        {
            return Enum.TryParse(value, ignoreCase: true, result: out result);
        }

        private static bool TryFromStringToEnumHelper(Type enumType, string value, out object result)
        {
            result = null;
            if (_stringToEnumMethod == null)
            {
                _stringToEnumMethod = typeof(ConversionUtil).GetMethod("TryFromStringToEnum",
                                                                       BindingFlags.Static | BindingFlags.NonPublic);
                Debug.Assert(_stringToEnumMethod != null);
            }
            var args = new object[] { value, null };
            var rval = (bool)_stringToEnumMethod.MakeGenericMethod(enumType).Invoke(null, args);
            result = args[1];
            return rval;
        }

        internal static bool TryFromStringToFontFamily(string fontFamily, out FontFamily result)
        {
            result = null;
            bool converted = false;
            foreach (FontFamily fontFamilyTemp in FontFamily.Families)
            {
                if (fontFamily.Equals(fontFamilyTemp.Name, StringComparison.OrdinalIgnoreCase))
                {
                    result = fontFamilyTemp;
                    converted = true;
                    break;
                }
            }
            return converted;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "TypeConverter throws System.Exception instad of a more specific one.")]
        internal static bool TryFromStringToColor(string value, out Color result)
        {
            result = default(Color);

            // Parse color specified as hex number
            if (value.StartsWith("#", StringComparison.OrdinalIgnoreCase))
            {
                // Only allow colors in form of #RRGGBB or #RGB
                if ((value.Length != 7) && (value.Length != 4))
                {
                    return false;
                }

                // Expand short version
                if (value.Length == 4)
                {
                    char[] newValue = new char[7];
                    newValue[0] = '#';
                    newValue[1] = newValue[2] = value[1];
                    newValue[3] = newValue[4] = value[2];
                    newValue[5] = newValue[6] = value[3];
                    value = new string(newValue);
                }
            }

            TypeConverter converter = TypeDescriptor.GetConverter(typeof(Color));
            Debug.Assert((converter != null) && (converter.CanConvertFrom(typeof(string))));

            // There are no TryConvert APIs on TypeConverter so we have to catch exception. 
            // In addition to that, invalid conversion just throws System.Exception with misleading message,
            // instead of a more specific exception type. 
            try
            {
                result = (Color)converter.ConvertFromInvariantString(value);
            }
            catch (Exception)
            {
                return false;
            }

            return true;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase",
            Justification = "Format names are used in Http headers and are usually specified in lower case")]
        internal static string NormalizeImageFormat(string value)
        {
            value = value.ToLowerInvariant();
            switch (value)
            {
                case "jpeg":
                case "jpg":
                case "pjpeg":
                    return "jpeg";

                case "png":
                case "x-png":
                    return "png";

                case "icon":
                case "ico":
                case "x-icon":
                    return "icon";
            }
            return value;
        }

        internal static bool TryFromStringToImageFormat(string value, out ImageFormat result)
        {
            result = default(ImageFormat);

            if (String.IsNullOrEmpty(value))
            {
                return false;
            }
            if (value.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
            {
                value = value.Substring("image/".Length);
            }
            value = NormalizeImageFormat(value);

            TypeConverter converter = TypeDescriptor.GetConverter(typeof(ImageFormat));
            Debug.Assert((converter != null) && (converter.CanConvertFrom(typeof(string))));

            try
            {
                result = (ImageFormat)converter.ConvertFromInvariantString(value);
            }
            catch (NotSupportedException)
            {
                return false;
            }

            return true;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/Crypto.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Security.Cryptography;
using System.Text;
using System.Web.Helpers.Resources;

namespace System.Web.Helpers
{
    public static class Crypto
    {
        private const int PBKDF2IterCount = 1000; // default for Rfc2898DeriveBytes
        private const int PBKDF2SubkeyLength = 256 / 8; // 256 bits
        private const int SaltSize = 128 / 8; // 128 bits

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "byte", Justification = "It really is a byte length")]
        internal static byte[] GenerateSaltInternal(int byteLength = SaltSize)
        {
            byte[] buf = new byte[byteLength];
            using (var rng = new RNGCryptoServiceProvider())
            {
                rng.GetBytes(buf);
            }
            return buf;
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "byte", Justification = "It really is a byte length")]
        public static string GenerateSalt(int byteLength = SaltSize)
        {
            return Convert.ToBase64String(GenerateSaltInternal(byteLength));
        }

        public static string Hash(string input, string algorithm = "sha256")
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }

            return Hash(Encoding.UTF8.GetBytes(input), algorithm);
        }

        public static string Hash(byte[] input, string algorithm = "sha256")
        {
            if (input == null)
            {
                throw new ArgumentNullException("input");
            }

            using (HashAlgorithm alg = HashAlgorithm.Create(algorithm))
            {
                if (alg != null)
                {
                    byte[] hashData = alg.ComputeHash(input);
                    return BinaryToHex(hashData);
                }
                else
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, HelpersResources.Crypto_NotSupportedHashAlg, algorithm));
                }
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "SHA", Justification = "Consistent with the Framework, which uses SHA")]
        public static string SHA1(string input)
        {
            return Hash(input, "sha1");
        }

        [SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "SHA", Justification = "Consistent with the Framework, which uses SHA")]
        public static string SHA256(string input)
        {
            return Hash(input, "sha256");
        }

        /* =======================
         * HASHED PASSWORD FORMATS
         * =======================
         * 
         * Version 0:
         * PBKDF2 with HMAC-SHA1, 128-bit salt, 256-bit subkey, 1000 iterations.
         * (See also: SDL crypto guidelines v5.1, Part III)
         * Format: { 0x00, salt, subkey }
         */

        public static string HashPassword(string password)
        {
            if (password == null)
            {
                throw new ArgumentNullException("password");
            }

            // Produce a version 0 (see comment above) password hash.
            byte[] salt;
            byte[] subkey;
            using (var deriveBytes = new Rfc2898DeriveBytes(password, SaltSize, PBKDF2IterCount))
            {
                salt = deriveBytes.Salt;
                subkey = deriveBytes.GetBytes(PBKDF2SubkeyLength);
            }

            byte[] outputBytes = new byte[1 + SaltSize + PBKDF2SubkeyLength];
            Buffer.BlockCopy(salt, 0, outputBytes, 1, SaltSize);
            Buffer.BlockCopy(subkey, 0, outputBytes, 1 + SaltSize, PBKDF2SubkeyLength);
            return Convert.ToBase64String(outputBytes);
        }

        // hashedPassword must be of the format of HashWithPassword (salt + Hash(salt+input)
        public static bool VerifyHashedPassword(string hashedPassword, string password)
        {
            if (hashedPassword == null)
            {
                throw new ArgumentNullException("hashedPassword");
            }
            if (password == null)
            {
                throw new ArgumentNullException("password");
            }

            byte[] hashedPasswordBytes = Convert.FromBase64String(hashedPassword);

            // Verify a version 0 (see comment above) password hash.

            if (hashedPasswordBytes.Length != (1 + SaltSize + PBKDF2SubkeyLength) || hashedPasswordBytes[0] != 0x00)
            {
                // Wrong length or version header.
                return false;
            }

            byte[] salt = new byte[SaltSize];
            Buffer.BlockCopy(hashedPasswordBytes, 1, salt, 0, SaltSize);
            byte[] storedSubkey = new byte[PBKDF2SubkeyLength];
            Buffer.BlockCopy(hashedPasswordBytes, 1 + SaltSize, storedSubkey, 0, PBKDF2SubkeyLength);

            byte[] generatedSubkey;
            using (var deriveBytes = new Rfc2898DeriveBytes(password, salt, PBKDF2IterCount))
            {
                generatedSubkey = deriveBytes.GetBytes(PBKDF2SubkeyLength);
            }
            return ByteArraysEqual(storedSubkey, generatedSubkey);
        }

        internal static string BinaryToHex(byte[] data)
        {
            char[] hex = new char[data.Length * 2];

            for (int iter = 0; iter < data.Length; iter++)
            {
                byte hexChar = ((byte)(data[iter] >> 4));
                hex[iter * 2] = (char)(hexChar > 9 ? hexChar + 0x37 : hexChar + 0x30);
                hexChar = ((byte)(data[iter] & 0xF));
                hex[(iter * 2) + 1] = (char)(hexChar > 9 ? hexChar + 0x37 : hexChar + 0x30);
            }
            return new string(hex);
        }

        // Compares two byte arrays for equality. The method is specifically written so that the loop is not optimized.
        [MethodImpl(MethodImplOptions.NoOptimization)]
        private static bool ByteArraysEqual(byte[] a, byte[] b)
        {
            if (ReferenceEquals(a, b))
            {
                return true;
            }

            if (a == null || b == null || a.Length != b.Length)
            {
                return false;
            }

            bool areSame = true;
            for (int i = 0; i < a.Length; i++)
            {
                areSame &= (a[i] == b[i]);
            }
            return areSame;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/DynamicHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Linq.Expressions;
using System.Runtime.CompilerServices;
using Microsoft.CSharp.RuntimeBinder;

namespace Microsoft.Internal.Web.Utils
{
    /// <summary>
    /// Helper to evaluate different method on dynamic objects
    /// </summary>
    internal static class DynamicHelper
    {
        // We must pass in "object" instead of "dynamic" for the target dynamic object because if we use dynamic, the compiler will
        // convert the call to this helper into a dynamic expression, even though we don't need it to be.  Since this class is internal,
        // it cannot be accessed from a dynamic expression and thus we get errors.

        // Dev10 Bug 914027 - Changed the first parameter from dynamic to object, see comment at top for details
        public static bool TryGetMemberValue(object obj, string memberName, out object result)
        {
            try
            {
                result = GetMemberValue(obj, memberName);
                return true;
            }
            catch (RuntimeBinderException)
            {
            }
            catch (RuntimeBinderInternalCompilerException)
            {
            }

            // We catch the C# specific runtime binder exceptions since we're using the C# binder in this case
            result = null;
            return false;
        }

        // Dev10 Bug 914027 - Changed the first parameter from dynamic to object, see comment at top for details
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We want to swallow exceptions that happen during runtime binding")]
        public static bool TryGetMemberValue(object obj, GetMemberBinder binder, out object result)
        {
            try
            {
                // VB us an instance of GetBinderAdapter that does not implement FallbackGetMemeber. This causes lookup of property expressions on dynamic objects to fail.
                // Since all types are private to the assembly, we assume that as long as they belong to CSharp runtime, it is the right one. 
                if (typeof(Binder).Assembly.Equals(binder.GetType().Assembly))
                {
                    // Only use the binder if its a C# binder.
                    result = GetMemberValue(obj, binder);
                }
                else
                {
                    result = GetMemberValue(obj, binder.Name);
                }
                return true;
            }
            catch
            {
                result = null;
                return false;
            }
        }

        // Dev10 Bug 914027 - Changed the first parameter from dynamic to object, see comment at top for details
        public static object GetMemberValue(object obj, string memberName)
        {
            var callSite = GetMemberAccessCallSite(memberName);
            return callSite.Target(callSite, obj);
        }

        // Dev10 Bug 914027 - Changed the first parameter from dynamic to object, see comment at top for details
        public static object GetMemberValue(object obj, GetMemberBinder binder)
        {
            var callSite = GetMemberAccessCallSite(binder);
            return callSite.Target(callSite, obj);
        }

        // dynamic d = new object();
        // object s = d.Name;
        // The following code gets generated for this expression:
        // callSite = CallSite<Func<CallSite, object, object>>.Create(Binder.GetMember(CSharpBinderFlags.None, "Name", typeof(Program), new CSharpArgumentInfo[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) }));
        // callSite.Target(callSite, d);
        // typeof(Program) is the containing type of the dynamic operation.
        // Dev10 Bug 914027 - Changed the callsite's target parameter from dynamic to object, see comment at top for details
        public static CallSite<Func<CallSite, object, object>> GetMemberAccessCallSite(string memberName)
        {
            var binder = Binder.GetMember(CSharpBinderFlags.None, memberName, typeof(DynamicHelper), new[] { CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null) });
            return GetMemberAccessCallSite(binder);
        }

        // Dev10 Bug 914027 - Changed the callsite's target parameter from dynamic to object, see comment at top for details
        public static CallSite<Func<CallSite, object, object>> GetMemberAccessCallSite(CallSiteBinder binder)
        {
            return CallSite<Func<CallSite, object, object>>.Create(binder);
        }

        // Dev10 Bug 914027 - Changed the first parameter from dynamic to object, see comment at top for details
        public static IEnumerable<string> GetMemberNames(object obj)
        {
            var provider = obj as IDynamicMetaObjectProvider;
            Debug.Assert(provider != null, "obj doesn't implement IDynamicMetaObjectProvider");

            Expression parameter = Expression.Parameter(typeof(object));
            return provider.GetMetaObject(parameter).GetDynamicMemberNames();
        }
    }
}


================================================
FILE: src/System.Web.Helpers/DynamicJavaScriptConverter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.Web.Script.Serialization;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    /// <summary>
    /// Converter that knows how to get the member values from a dynamic object.
    /// </summary>
    internal class DynamicJavaScriptConverter : JavaScriptConverter
    {
        public override IEnumerable<Type> SupportedTypes
        {
            get
            {
                // REVIEW: For some reason the converters don't pick up interfaces
                yield return typeof(IDynamicMetaObjectProvider);
                yield return typeof(DynamicObject);
            }
        }

        public override object Deserialize(IDictionary<string, object> dictionary, Type type, JavaScriptSerializer serializer)
        {
            throw new NotSupportedException();
        }

        public override IDictionary<string, object> Serialize(object obj, JavaScriptSerializer serializer)
        {
            var values = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            var memberNames = DynamicHelper.GetMemberNames(obj);

            // This should never happen
            Debug.Assert(memberNames != null);

            // Get the value for each member in the dynamic object
            foreach (string memberName in memberNames)
            {
                object value = DynamicHelper.GetMemberValue(obj, memberName);
                var jsonValue = value as DynamicJsonArray;
                if (jsonValue != null)
                {
                    value = (object[])jsonValue;
                }
                values[memberName] = value;
            }

            return values;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/DynamicJsonArray.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Linq;

namespace System.Web.Helpers
{
    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "This class isn't meant to be used directly")]
    public class DynamicJsonArray : DynamicObject, IEnumerable<object>
    {
        private readonly object[] _arrayValues;

        public DynamicJsonArray(object[] arrayValues)
        {
            Debug.Assert(arrayValues != null);
            _arrayValues = arrayValues.Select(Json.WrapObject).ToArray();
        }

        public int Length
        {
            get { return _arrayValues.Length; }
        }

        public dynamic this[int index]
        {
            get { return _arrayValues[index]; }
            set { _arrayValues[index] = Json.WrapObject(value); }
        }

        public override bool TryConvert(ConvertBinder binder, out object result)
        {
            if (_arrayValues.GetType().IsAssignableFrom(binder.Type))
            {
                result = _arrayValues;
                return true;
            }
            return base.TryConvert(binder, out result);
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            // Testing for members should never throw. This is important when dealing with
            // services that return different json results. Testing for a member shouldn't throw,
            // it should just return null (or undefined)
            result = null;
            return true;
        }

        public IEnumerator GetEnumerator()
        {
            return _arrayValues.GetEnumerator();
        }

        private IEnumerable<object> GetEnumerable()
        {
            return _arrayValues.AsEnumerable();
        }

        IEnumerator<object> IEnumerable<object>.GetEnumerator()
        {
            return GetEnumerable().GetEnumerator();
        }

        [SuppressMessage("Microsoft.Usage", "CA2225:OperatorOverloadsHaveNamedAlternates", Justification = "This class isn't meant to be used directly")]
        public static implicit operator object[](DynamicJsonArray obj)
        {
            return obj._arrayValues;
        }

        [SuppressMessage("Microsoft.Usage", "CA2225:OperatorOverloadsHaveNamedAlternates", Justification = "This class isn't meant to be used directly")]
        public static implicit operator Array(DynamicJsonArray obj)
        {
            return obj._arrayValues;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/DynamicJsonObject.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using System.Web.Helpers.Resources;

namespace System.Web.Helpers
{
    // REVIEW: Consider implementing ICustomTypeDescriptor and IDictionary<string, object>
    public class DynamicJsonObject : DynamicObject
    {
        private readonly IDictionary<string, object> _values;

        public DynamicJsonObject(IDictionary<string, object> values)
        {
            Debug.Assert(values != null);
            _values = values.ToDictionary(p => p.Key, p => Json.WrapObject(p.Value),
                                          StringComparer.OrdinalIgnoreCase);
        }

        public override bool TryConvert(ConvertBinder binder, out object result)
        {
            result = null;
            if (binder.Type.IsAssignableFrom(_values.GetType()))
            {
                result = _values;
            }
            else
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, HelpersResources.Json_UnableToConvertType, binder.Type));
            }
            return true;
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            result = GetValue(binder.Name);
            return true;
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            _values[binder.Name] = Json.WrapObject(value);
            return true;
        }

        public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
        {
            string key = GetKey(indexes);
            if (!String.IsNullOrEmpty(key))
            {
                _values[key] = Json.WrapObject(value);
            }
            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            string key = GetKey(indexes);
            result = null;
            if (!String.IsNullOrEmpty(key))
            {
                result = GetValue(key);
            }
            return true;
        }

        private static string GetKey(object[] indexes)
        {
            if (indexes.Length == 1)
            {
                return (string)indexes[0];
            }
            // REVIEW: Should this throw?
            return null;
        }

        public override IEnumerable<string> GetDynamicMemberNames()
        {
            return _values.Keys;
        }

        private object GetValue(string name)
        {
            object result;
            if (_values.TryGetValue(name, out result))
            {
                return result;
            }
            return null;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc.
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File".
// You do not need to add suppressions to this file manually.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "sha", Scope = "resource", Target = "System.Web.Helpers.Resources.HelpersResources.resources", Justification = "sha is the algorithm")]


================================================
FILE: src/System.Web.Helpers/HtmlElement.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Web.UI;

namespace System.Web.Helpers
{
    internal class HtmlElement
    {
        public HtmlElement(string tagName)
        {
            TagName = tagName;
            Attributes = new Dictionary<string, string>();
            Children = new List<HtmlElement>();
        }

        internal string TagName { get; set; }

        internal string InnerText { get; set; }

        public IList<HtmlElement> Children { get; set; }

        private IDictionary<string, string> Attributes { get; set; }

        public string this[string name]
        {
            get { return Attributes[name]; }
            set { MergeAttribute(name, value); }
        }

        public HtmlElement SetInnerText(string innerText)
        {
            InnerText = innerText;
            Children.Clear();
            return this;
        }

        public HtmlElement AppendChild(HtmlElement e)
        {
            Children.Add(e);
            return this;
        }

        public HtmlElement AppendChild(string innerText)
        {
            AppendChild(CreateSpan(innerText));
            return this;
        }

        private void MergeAttribute(string name, string value)
        {
            Attributes[name] = value;
        }

        public HtmlElement AddCssClass(string className)
        {
            string currentValue;
            if (!Attributes.TryGetValue("class", out currentValue))
            {
                Attributes["class"] = className;
            }
            else
            {
                Attributes["class"] = currentValue + " " + className;
            }
            return this;
        }

        public IHtmlString ToHtmlString()
        {
            using (StringWriter sw = new StringWriter(CultureInfo.InvariantCulture))
            {
                WriteTo(sw);
                return new HtmlString(sw.ToString());
            }
        }

        public void WriteTo(TextWriter writer)
        {
            WriteToInternal(new HtmlTextWriter(writer));
        }

        private void WriteToInternal(HtmlTextWriter writer)
        {
            foreach (var a in Attributes)
            {
                writer.AddAttribute(a.Key, a.Value, true);
            }
            writer.RenderBeginTag(TagName);
            if (!String.IsNullOrEmpty(InnerText))
            {
                writer.WriteEncodedText(InnerText);
            }
            else
            {
                foreach (var e in Children)
                {
                    e.WriteToInternal(writer);
                }
            }
            writer.RenderEndTag();
        }

        public override string ToString()
        {
            return ToHtmlString().ToString();
        }

        internal static HtmlElement CreateSpan(string innerText, string cssClass = null)
        {
            var span = new HtmlElement("span");
            span.SetInnerText(innerText);
            if (!String.IsNullOrEmpty(cssClass))
            {
                span.AddCssClass(cssClass);
            }
            return span;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/HtmlObjectPrinter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.Helpers.Resources;

namespace System.Web.Helpers
{
    internal class HtmlObjectPrinter : ObjectVisitor
    {
        private const string Styles =
            @"<style type=""text/css"">       
    .objectinfo { font-size: 13px; }
    .objectinfo .type { color: #0000ff; }
    .objectinfo .complexType { color: #2b91af; }
    .objectinfo .name { color: Black; }
    .objectinfo .value { color: Black; }
    .objectinfo .quote { color: Brown; }
    .objectinfo .null { color: Red; }
    .objectinfo .exception { color:Red; }
    .objectinfo .typeContainer { border-left: solid 2px #7C888A; padding-left: 3px; margin-left:3px; }
    .objectinfo h3, h2 { margin:0; padding:0; }
    .objectinfo ul { margin-top:0; margin-bottom:0; list-style-type:none; padding-left:10px; margin-left:10px; }
</style>
";

        private static readonly HtmlElement _nullSpan = HtmlElement.CreateSpan("(null)", "null");
        // List of chars to escape within strings
        private static readonly Dictionary<char, string> _printableEscapeChars = new Dictionary<char, string>
        {
            { '\0', "\\0" },
            { '\\', "\\\\" },
            { '\'', "'" },
            { '\"', "\\\"" },
            { '\a', "\\a" },
            { '\b', "\\b" },
            { '\f', "\\f" },
            { '\n', "\\n" },
            { '\r', "\\r" },
            { '\t', "\\t" },
            { '\v', "\\v" },
        };

        // We want to exclude the type name next to the value for members
        private bool _excludeTypeName;
        private Stack<HtmlElement> _elementStack = new Stack<HtmlElement>();

        public HtmlObjectPrinter(int recursionLimit, int enumerationLimit)
            : base(recursionLimit, enumerationLimit)
        {
        }

        private HtmlElement Current
        {
            get
            {
                Debug.Assert(_elementStack.Count > 0);
                return _elementStack.Peek();
            }
        }

        public void WriteTo(object value, TextWriter writer)
        {
            HtmlElement rootElement = new HtmlElement("div");
            rootElement.AddCssClass("objectinfo");

            PushElement(rootElement);
            Visit(value, 0);
            PopElement();

            Debug.Assert(_elementStack.Count == 0, "Stack should be empty");

            // REVIEW: We should only do this once per page/request
            writer.Write(Styles);
            rootElement.WriteTo(writer);
        }

        public override void VisitKeyValues(object value, IEnumerable<object> keys, Func<object, object> valueSelector, int depth)
        {
            string id = GetObjectId(value);
            HtmlElement ul = new HtmlElement("ul");
            ul.AddCssClass("typeEnumeration");
            ul["id"] = id;

            PushElement(ul);
            base.VisitKeyValues(value, keys, valueSelector, depth);
            PopElement();

            Current.AppendChild(ul);
        }

        public override void VisitKeyValue(object key, object value, int depth)
        {
            HtmlElement keyElement = new HtmlElement("span");
            PushElement(keyElement);
            Visit(key, depth);
            PopElement();

            HtmlElement valueElement = new HtmlElement("span");
            PushElement(valueElement);
            Visit(value, depth);
            PopElement();

            // Append the elements to the li
            HtmlElement li = new HtmlElement("li");
            li.AppendChild(keyElement);
            li.AppendChild(" = ");
            li.AppendChild(valueElement);
            Current.AppendChild(li);
        }

        public override void VisitEnumerable(IEnumerable enumerable, int depth)
        {
            string id = GetObjectId(enumerable);

            HtmlElement ul = new HtmlElement("ul");
            ul.AddCssClass("typeEnumeration");
            ul["id"] = id;

            PushElement(ul);
            base.VisitEnumerable(enumerable, depth);
            PopElement();

            Current.AppendChild(ul);
        }

        public override void VisitIndexedEnumeratedValue(int index, object item, int depth)
        {
            HtmlElement li = new HtmlElement("li");
            li.AppendChild(String.Format(CultureInfo.InvariantCulture, "[{0}] = ", index));
            PushElement(li);
            base.VisitIndexedEnumeratedValue(index, item, depth);
            PopElement();
            Current.AppendChild(li);
        }

        public override void VisitEnumeratedValue(object item, int depth)
        {
            HtmlElement li = new HtmlElement("li");
            PushElement(li);
            base.VisitEnumeratedValue(item, depth);
            PopElement();
            Current.AppendChild(li);
        }

        public override void VisitEnumeratonLimitExceeded()
        {
            HtmlElement li = new HtmlElement("li");
            li.AppendChild("...");
            Current.AppendChild(li);
        }

        public override void VisitMembers(IEnumerable<string> names, Func<string, Type> typeSelector, Func<string, object> valueSelector, int depth)
        {
            HtmlElement ul = new HtmlElement("ul");
            ul.AddCssClass("typeProperties");

            PushElement(ul);
            base.VisitMembers(names, typeSelector, valueSelector, depth);
            PopElement();

            Current.AppendChild(ul);
        }

        public override void VisitMember(string name, Type type, object value, int depth)
        {
            HtmlElement li = new HtmlElement("li");

            if (type != null)
            {
                li.AppendChild(CreateTypeNameSpan(type));
                li.AppendChild(" ");
            }

            li.AppendChild(CreateNameSpan(name));
            li.AppendChild(" = ");

            PushElement(li);

            _excludeTypeName = true;
            base.VisitMember(name, type, value, depth);
            _excludeTypeName = false;

            PopElement();

            Current.AppendChild(li);
        }

        public override void VisitComplexObject(object value, int depth)
        {
            string id = GetObjectId(value);

            HtmlElement objectElement = new HtmlElement("div");
            objectElement.AddCssClass("typeContainer");
            objectElement["id"] = id;

            PushElement(objectElement);
            base.VisitComplexObject(value, depth);
            PopElement();

            if (objectElement.Children.Any())
            {
                Current.AppendChild(objectElement);
            }
        }

        public override void VisitNull()
        {
            Current.AppendChild(_nullSpan);
        }

        public override void VisitStringValue(string stringValue)
        {
            // Convert the string escape sequences
            stringValue = "\"" + ConvertEscapseSequences(stringValue) + "\"";
            Current.AppendChild(CreateQuotedSpan(stringValue));
        }

        public override void VisitVisitedObject(string id, object value)
        {
            Current.AppendChild(CreateVisitedLink(id));
        }

        public override void Visit(object value, int depth)
        {
            if (value != null)
            {
                if (!_excludeTypeName)
                {
                    Current.AppendChild(CreateTypeNameSpan(value.GetType()));
                    Current.AppendChild(" ");
                }
                _excludeTypeName = false;
            }

            base.Visit(value, depth);
        }

        public override void VisitObjectVisitorException(ObjectVisitorException exception)
        {
            Current.AppendChild(CreateExceptionSpan(exception));
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Making the value lowercase has nothing to do with normalization. It's used to show true or false instead of the Title case version")]
        public override void VisitConvertedValue(object value, string convertedValue)
        {
            Type type = value.GetType();
            if (type.Equals(typeof(bool)))
            {
                // Convert True or False to lowercase
                convertedValue = convertedValue.ToLowerInvariant();
                Current.AppendChild(CreateTypeSpan(convertedValue));
                return;
            }

            if (type.Equals(typeof(char)))
            {
                string charValue = GetCharValue((char)value);
                Current.AppendChild(CreateQuotedSpan("'" + charValue + "'"));
                return;
            }

            // See if the value is a Type itself
            Type valueAsType = value as Type;
            if (valueAsType != null)
            {
                // For types we're going to generate elements that print typeof(TypeName)
                Current.AppendChild(CreateParentSpan(CreateTypeSpan("typeof"),
                                                     CreateOperatorSpan("("),
                                                     CreateTypeNameSpan(valueAsType),
                                                     CreateOperatorSpan(")")));
            }
            else
            {
                Current.AppendChild(CreateValueSpan(convertedValue));
            }
        }

        private static HtmlElement CreateParentSpan(params HtmlElement[] elements)
        {
            HtmlElement span = new HtmlElement("span");
            foreach (var e in elements)
            {
                span.AppendChild(e);
            }
            return span;
        }

        private static HtmlElement CreateNameSpan(string name)
        {
            return HtmlElement.CreateSpan(name, "name");
        }

        private static HtmlElement CreateOperatorSpan(string @operator)
        {
            return HtmlElement.CreateSpan(@operator, "operator");
        }

        private static HtmlElement CreateValueSpan(string value)
        {
            return HtmlElement.CreateSpan(value, "value");
        }

        private static HtmlElement CreateExceptionSpan(ObjectVisitorException exception)
        {
            HtmlElement span = new HtmlElement("span");
            span.AppendChild(HelpersResources.ObjectInfo_PropertyThrewException);
            span.AppendChild(HtmlElement.CreateSpan(exception.InnerException.Message, "exception"));
            return span;
        }

        private static HtmlElement CreateQuotedSpan(string value)
        {
            return HtmlElement.CreateSpan(value, "quote");
        }

        private static HtmlElement CreateLink(string href, string linkText, string cssClass = null)
        {
            HtmlElement a = new HtmlElement("a");
            a.SetInnerText(linkText);
            a["href"] = href;
            if (!String.IsNullOrEmpty(cssClass))
            {
                a.AddCssClass(cssClass);
            }
            return a;
        }

        private static HtmlElement CreateVisitedLink(string id)
        {
            string text = String.Format(CultureInfo.InvariantCulture, "[{0}]", HelpersResources.ObjectInfo_PreviousDisplayed);
            return CreateLink("#" + id, text);
        }

        private static HtmlElement CreateTypeSpan(string value)
        {
            return HtmlElement.CreateSpan(value, "type");
        }

        private static HtmlElement CreateTypeNameSpan(Type type)
        {
            string typeName = GetTypeName(type);
            HtmlElement span = new HtmlElement("span");
            StringBuilder sb = new StringBuilder();
            // Convert the type name into html elements with different css classes
            foreach (var ch in typeName)
            {
                if (IsOperator(ch))
                {
                    if (sb.Length > 0)
                    {
                        span.AppendChild(CreateTypeSpan(sb.ToString()));
                        sb.Clear();
                    }
                    span.AppendChild(CreateOperatorSpan(ch.ToString()));
                }
                else
                {
                    sb.Append(ch);
                }
            }
            if (sb.Length > 0)
            {
                span.AppendChild(CreateTypeSpan(sb.ToString()));
            }
            return span;
        }

        private static bool IsOperator(char ch)
        {
            // These are the operators we expect to see within type names
            return ch == '[' || ch == ']' || ch == '<' || ch == '>' || ch == '&' || ch == '*';
        }

        internal void PushElement(HtmlElement element)
        {
            _elementStack.Push(element);
        }

        internal HtmlElement PopElement()
        {
            Debug.Assert(_elementStack.Count > 0);
            return _elementStack.Pop();
        }

        internal static string ConvertEscapseSequences(string value)
        {
            StringBuilder sb = new StringBuilder();
            foreach (var ch in value)
            {
                sb.Append(GetCharValue(ch));
            }
            return sb.ToString();
        }

        private static string GetCharValue(char ch)
        {
            string value;
            if (_printableEscapeChars.TryGetValue(ch, out value))
            {
                return value;
            }
            // REVIEW: Perf?
            return ch.ToString();
        }
    }
}


================================================
FILE: src/System.Web.Helpers/Json.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Web.Script.Serialization;

namespace System.Web.Helpers
{
    public static class Json
    {
        private static readonly JavaScriptSerializer _serializer = CreateSerializer();

        public static string Encode(object value)
        {
            // Serialize our dynamic array type as an array
            DynamicJsonArray jsonArray = value as DynamicJsonArray;
            if (jsonArray != null)
            {
                return _serializer.Serialize((object[])jsonArray);
            }

            return _serializer.Serialize(value);
        }

        public static void Write(object value, TextWriter writer)
        {
            writer.Write(_serializer.Serialize(value));
        }

        public static dynamic Decode(string value)
        {
            return WrapObject(_serializer.DeserializeObject(value));
        }

        public static dynamic Decode(string value, Type targetType)
        {
            return WrapObject(_serializer.Deserialize(value, targetType));
        }

        public static T Decode<T>(string value)
        {
            return _serializer.Deserialize<T>(value);
        }

        private static JavaScriptSerializer CreateSerializer()
        {
            JavaScriptSerializer serializer = new JavaScriptSerializer();
            serializer.RegisterConverters(new[] { new DynamicJavaScriptConverter() });
            return serializer;
        }

        internal static dynamic WrapObject(object value)
        {
            // The JavaScriptSerializer returns IDictionary<string, object> for objects
            // and object[] for arrays, so we wrap those in different dynamic objects
            // so we can access the object graph using dynamic
            var dictionaryValues = value as IDictionary<string, object>;
            if (dictionaryValues != null)
            {
                return new DynamicJsonObject(dictionaryValues);
            }

            var arrayValues = value as object[];
            if (arrayValues != null)
            {
                return new DynamicJsonArray(arrayValues);
            }

            return value;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/ObjectInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.WebPages;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    public static class ObjectInfo
    {
        private const int DefaultRecursionLimit = 10;
        private const int DefaultEnumerationLimit = 1000;

        public static HelperResult Print(object value, int depth = DefaultRecursionLimit, int enumerationLength = DefaultEnumerationLimit)
        {
            if (depth < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "depth",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }
            if (enumerationLength <= 0)
            {
                throw new ArgumentOutOfRangeException(
                    "enumerationLength",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThan, 0));
            }

            HtmlObjectPrinter printer = new HtmlObjectPrinter(depth, enumerationLength);
            return new HelperResult(writer => printer.WriteTo(value, writer));
        }
    }
}


================================================
FILE: src/System.Web.Helpers/ObjectVisitor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    internal class ObjectVisitor
    {
        private static readonly Dictionary<Type, string> _typeNames = new Dictionary<Type, string>
        {
            { typeof(string), "string" },
            { typeof(object), "object" },
            { typeof(int), "int" },
            { typeof(byte), "byte" },
            { typeof(short), "short" },
            { typeof(long), "long" },
            { typeof(decimal), "decimal" },
            { typeof(float), "float" },
            { typeof(double), "double" },
            { typeof(bool), "bool" },
            { typeof(char), "char" },
            { typeof(void), "void" }
        };

        private static readonly char[] _separators = { '&', '[', '*' };

        private readonly int _recursionLimit;
        private readonly int _enumerationLimit;
        private Dictionary<object, string> _visited = new Dictionary<object, string>();

        public ObjectVisitor(int recursionLimit, int enumerationLimit)
        {
            Debug.Assert(enumerationLimit > 0);
            Debug.Assert(recursionLimit >= 0);
            _enumerationLimit = enumerationLimit;
            _recursionLimit = recursionLimit;
        }

        protected string GetObjectId(object value)
        {
            string id;
            if (_visited.TryGetValue(value, out id))
            {
                return id;
            }
            return null;
        }

        public virtual void Visit(object value, int depth)
        {
            if (value == null || DBNull.Value.Equals(value))
            {
                VisitNull();
                return;
            }

            // Check to see if the we've already visited this object
            string id;
            if (_visited.TryGetValue(value, out id))
            {
                VisitVisitedObject(id, value);
                return;
            }

            string stringValue = value as string;
            if (stringValue != null)
            {
                VisitStringValue(stringValue);
                return;
            }

            if (TryConvertToString(value, out stringValue))
            {
                VisitConvertedValue(value, stringValue);
                return;
            }

            // This exceptin occurs when we try to access the property and it fails
            // for some reason. The actual exception is wrapped in the ObjectVisitorException
            ObjectVisitorException exception = value as ObjectVisitorException;
            if (exception != null)
            {
                VisitObjectVisitorException(exception);
                return;
            }

            // Mark the object as visited
            id = CreateObjectId(value);
            _visited.Add(value, id);

            NameValueCollection nameValueCollection = value as NameValueCollection;
            if (nameValueCollection != null)
            {
                VisitNameValueCollection(nameValueCollection, depth);
                return;
            }

            IDictionary dictionary = value as IDictionary;
            if (dictionary != null)
            {
                VisitDictionary(dictionary, depth);
                return;
            }

            IEnumerable enumerable = value as IEnumerable;
            if (enumerable != null)
            {
                VisitEnumerable(enumerable, depth);
                return;
            }

            VisitComplexObject(value, depth + 1);
        }

        public virtual void VisitObjectVisitorException(ObjectVisitorException exception)
        {
        }

        public virtual void VisitConvertedValue(object value, string convertedValue)
        {
            VisitStringValue(convertedValue);
        }

        public virtual void VisitVisitedObject(string id, object value)
        {
        }

        public virtual void VisitNull()
        {
        }

        public virtual void VisitStringValue(string stringValue)
        {
        }

        public virtual void VisitComplexObject(object value, int depth)
        {
            if (depth > _recursionLimit)
            {
                return;
            }

            Debug.Assert(value != null, "Value should not be null");

            var dynamicObject = value as IDynamicMetaObjectProvider;
            // Only look at dynamic objects that do not implement ICustomTypeDescriptor
            if (dynamicObject != null && !(dynamicObject is ICustomTypeDescriptor))
            {
                var memberNames = DynamicHelper.GetMemberNames(dynamicObject);

                if (memberNames != null)
                {
                    // Always use the runtime type for dynamic objects since there is no metadata
                    VisitMembers(memberNames,
                                 name => null,
                                 name => DynamicHelper.GetMemberValue(dynamicObject, name),
                                 depth);
                }
            }
            else
            {
                // REVIEW: We should try to filter out properties of certain types

                // Dump properties using type descriptor
                var props = TypeDescriptor.GetProperties(value);
                var propNames = from PropertyDescriptor p in props
                                select p.Name;

                VisitMembers(propNames,
                             name => props.Find(name, ignoreCase: true).PropertyType,
                             name => GetPropertyDescriptorValue(value, name, props),
                             depth);

                // Dump fields
                var fields = value.GetType().GetFields(BindingFlags.Public | BindingFlags.Instance)
                    .ToDictionary(field => field.Name);

                VisitMembers(fields.Keys,
                             name => fields[name].FieldType,
                             name => GetFieldValue(value, name, fields),
                             depth);
            }
        }

        public virtual void VisitNameValueCollection(NameValueCollection collection, int depth)
        {
            VisitKeyValues(collection, collection.AllKeys.Cast<object>(), key => collection[(string)key], depth);
        }

        public virtual void VisitDictionary(IDictionary dictionary, int depth)
        {
            VisitKeyValues(dictionary, dictionary.Keys.Cast<object>(), key => dictionary[key], depth);
        }

        public virtual void VisitEnumerable(IEnumerable enumerable, int depth)
        {
            if (depth > _recursionLimit)
            {
                return;
            }

            Type enumerableType = enumerable.GetType();
            bool isIndexedEnumeration = ImplementsInterface(enumerableType, typeof(IList<>))
                                        || ImplementsInterface(enumerableType, typeof(IList));

            int index = 0;
            foreach (var item in enumerable)
            {
                if (index >= _enumerationLimit)
                {
                    VisitEnumeratonLimitExceeded();
                    break;
                }
                if (isIndexedEnumeration)
                {
                    VisitIndexedEnumeratedValue(index, item, depth);
                }
                else
                {
                    VisitEnumeratedValue(item, depth);
                }
                index++;
            }
        }

        public virtual void VisitEnumeratedValue(object item, int depth)
        {
            Visit(item, depth);
        }

        public virtual void VisitIndexedEnumeratedValue(int index, object item, int depth)
        {
            Visit(item, depth);
        }

        public virtual void VisitEnumeratonLimitExceeded()
        {
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We don't want to fail surface any exceptions throw from getting property accessors")]
        public virtual void VisitMembers(IEnumerable<string> names, Func<string, Type> typeSelector, Func<string, object> valueSelector, int depth)
        {
            foreach (string name in names)
            {
                Type type = null;
                object value = null;
                try
                {
                    // Get the type and value
                    type = typeSelector(name);
                    value = valueSelector(name);

                    // If the type is null try using the runtime type
                    if (value != null && type == null)
                    {
                        type = value.GetType();
                    }
                }
                catch (Exception ex)
                {
                    // Set the value as an exception we know about
                    value = new ObjectVisitorException(null, ex);
                }
                finally
                {
                    VisitMember(name, type, value, depth);
                }
            }
        }

        public virtual void VisitMember(string name, Type type, object value, int depth)
        {
            Visit(value, depth);
        }

        public virtual void VisitKeyValues(object value, IEnumerable<object> keys, Func<object, object> valueSelector, int depth)
        {
            if (depth > _recursionLimit)
            {
                return;
            }

            foreach (var key in keys)
            {
                VisitKeyValue(key, valueSelector(key), depth);
            }
        }

        public virtual void VisitKeyValue(object key, object value, int depth)
        {
            // Dump the key and value
            Visit(key, depth);
            Visit(value, depth);
        }

        protected virtual string CreateObjectId(object value)
        {
            // REVIEW: Maybe use a guid?
            return value.GetHashCode().ToString(CultureInfo.InvariantCulture);
        }

        internal static string GetTypeName(Type type)
        {
            // See if we have the type name stored
            string typeName;
            if (_typeNames.TryGetValue(type, out typeName))
            {
                return typeName;
            }

            if (type.IsGenericType)
            {
                // Get the generic type name without arguments
                string genericTypeName = GetGenericTypeName(type);
                // Create a user friendly type name
                var arguments = from argType in type.GetGenericArguments()
                                select GetTypeName(argType);

                return String.Format(CultureInfo.InvariantCulture, "{0}<{1}>", genericTypeName, String.Join(", ", arguments));
            }

            if (type.IsByRef || type.IsArray || type.IsPointer)
            {
                // Get the element type name
                string elementTypeName = GetTypeName(type.GetElementType());
                // Append the separator
                int sepIndex = type.Name.IndexOfAny(_separators);
                return elementTypeName + type.Name.Substring(sepIndex);
            }

            // Fallback to using the type name as is
            return type.Name;
        }

        private static string GetGenericTypeName(Type type)
        {
            Debug.Assert(type.IsGenericType, "Type is not a generic type");

            // Check for anonymous types
            if (IsAnonymousType(type))
            {
                return "AnonymousType";
            }

            string genericTypeDefinitionName = type.GetGenericTypeDefinition().Name;
            int index = genericTypeDefinitionName.IndexOf('`');
            Debug.Assert(index >= 0);
            // Get the generic type name without the `
            return genericTypeDefinitionName.Substring(0, index);
        }

        // Copied from System.Web.WebPages/Util/TypeHelpers.cs
        private static bool IsAnonymousType(Type type)
        {
            Debug.Assert(type != null, "Type should not be null");

            // TODO: The only way to detect anonymous types right now.
            return Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute), false)
                   && type.IsGenericType && type.Name.Contains("AnonymousType")
                   && (type.Name.StartsWith("<>", StringComparison.OrdinalIgnoreCase) || type.Name.StartsWith("VB$", StringComparison.OrdinalIgnoreCase))
                   && (type.Attributes & TypeAttributes.NotPublic) == TypeAttributes.NotPublic;
        }

        private static bool ImplementsInterface(Type type, Type targetInterfaceType)
        {
            Func<Type, bool> implementsInterface = t => targetInterfaceType.IsAssignableFrom(t);
            if (targetInterfaceType.IsGenericType)
            {
                implementsInterface = t => t.IsGenericType && targetInterfaceType.IsAssignableFrom(t.GetGenericTypeDefinition());
            }
            return implementsInterface(type) || type.GetInterfaces().Any(implementsInterface);
        }

        private static object GetFieldValue(object value, string name, IDictionary<string, FieldInfo> fields)
        {
            FieldInfo fieldInfo;
            // Get the value from the dictionary
            bool result = fields.TryGetValue(name, out fieldInfo);
            Debug.Assert(result, "Entry should exist");
            return fieldInfo.GetValue(value);
        }

        private static object GetPropertyDescriptorValue(object value, string name, PropertyDescriptorCollection props)
        {
            PropertyDescriptor propertyDescriptor = props.Find(name, ignoreCase: true);
            Debug.Assert(propertyDescriptor != null, "Property descriptor shouldn't be null");
            return propertyDescriptor.GetValue(value);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We don't want to surface any exceptions while trying to convert from string")]
        private static bool TryConvertToString(object value, out string stringValue)
        {
            stringValue = null;
            try
            {
                IConvertible convertibe = value as IConvertible;
                if (convertibe != null)
                {
                    stringValue = convertibe.ToString(CultureInfo.CurrentCulture);
                    return true;
                }

                TypeConverter converter = TypeDescriptor.GetConverter(value);
                if (converter.CanConvertFrom(typeof(string)))
                {
                    stringValue = converter.ConvertToString(value);
                    return true;
                }

                Type type = value.GetType();
                if (type == typeof(object))
                {
                    stringValue = value.ToString();
                    return true;
                }
                Type valueAsType = value as Type;
                if (valueAsType != null)
                {
                    stringValue = "typeof(" + GetTypeName(valueAsType) + ")";
                    return true;
                }
            }
            catch (Exception)
            {
                // If we failed to convert the type for any reason return false
            }
            return false;
        }

        [Serializable]
        public class ObjectVisitorException : Exception
        {
            public ObjectVisitorException()
            {
            }

            public ObjectVisitorException(string message)
                : base(message)
            {
            }

            public ObjectVisitorException(string message, Exception inner)
                : base(message, inner)
            {
            }

            protected ObjectVisitorException(
                SerializationInfo info,
                StreamingContext context)
                : base(info, context)
            {
            }
        }
    }
}


================================================
FILE: src/System.Web.Helpers/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("System.Web.Helpers")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.Helpers.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/System.Web.Helpers/Resources/ChartTemplates.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.1
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Microsoft.WebPages.Helpers.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class ChartTemplates {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal ChartTemplates() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.WebPages.Helpers.Resources.ChartTemplates", typeof(ChartTemplates).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to - &lt;Chart BackColor=&quot;#D3DFF0&quot; BackGradientStyle=&quot;TopBottom&quot; BackSecondaryColor=&quot;White&quot; BorderColor=&quot;26, 59, 105&quot; BorderlineDashStyle=&quot;Solid&quot; BorderWidth=&quot;2&quot; Palette=&quot;BrightPastel&quot;&gt;
        ///- 	&lt;ChartAreas&gt;
        ///		&lt;ChartArea Name=&quot;Default&quot; _Template_=&quot;All&quot; BackColor=&quot;64, 165, 191, 228&quot; BackGradientStyle=&quot;TopBottom&quot; BackSecondaryColor=&quot;White&quot; BorderColor=&quot;64, 64, 64, 64&quot; BorderDashStyle=&quot;Solid&quot; ShadowColor=&quot;Transparent&quot; /&gt; 
        ///	&lt;/ChartAreas&gt;
        ///	&lt;Legends&gt;
        ///		&lt;Legend _Template_=&quot;All&quot; BackColor=&quot;Transparent&quot; Font=&quot;Trebuchet MS, [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Blue {
            get {
                return ResourceManager.GetString("Blue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;Chart BackColor=&quot;#C9DC87&quot; BackGradientStyle=&quot;TopBottom&quot; BorderColor=&quot;181, 64, 1&quot; BorderWidth=&quot;2&quot; BorderlineDashStyle=&quot;Solid&quot; Palette=&quot;BrightPastel&quot;&gt;
        ///  &lt;ChartAreas&gt;
        ///    &lt;ChartArea Name=&quot;Default&quot; _Template_=&quot;All&quot; BackColor=&quot;Transparent&quot; BackSecondaryColor=&quot;White&quot; BorderColor=&quot;64, 64, 64, 64&quot; BorderDashStyle=&quot;Solid&quot; ShadowColor=&quot;Transparent&quot;&gt;
        ///      &lt;AxisY LineColor=&quot;64, 64, 64, 64&quot;&gt;
        ///        &lt;MajorGrid Interval=&quot;Auto&quot; LineColor=&quot;64, 64, 64, 64&quot; /&gt;
        ///        &lt;LabelStyle Font=&quot;Trebuchet MS, 8.25pt, style=Bold [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Green {
            get {
                return ResourceManager.GetString("Green", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;Chart Palette=&quot;SemiTransparent&quot; BorderColor=&quot;#000&quot; BorderWidth=&quot;2&quot; BorderlineDashStyle=&quot;Solid&quot;&gt;
        ///&lt;ChartAreas&gt;
        ///    &lt;ChartArea _Template_=&quot;All&quot; Name=&quot;Default&quot;&gt;
        ///            &lt;AxisX&gt;
        ///                &lt;MinorGrid Enabled=&quot;False&quot; /&gt;
        ///                &lt;MajorGrid Enabled=&quot;False&quot; /&gt;
        ///            &lt;/AxisX&gt;
        ///            &lt;AxisY&gt;
        ///                &lt;MajorGrid Enabled=&quot;False&quot; /&gt;
        ///                &lt;MinorGrid Enabled=&quot;False&quot; /&gt;
        ///            &lt;/AxisY&gt;
        ///    &lt;/ChartArea&gt;
        ///&lt;/ChartAreas&gt;
        ///&lt;/Chart&gt;.
        /// </summary>
        internal static string Vanilla {
            get {
                return ResourceManager.GetString("Vanilla", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;Chart BackColor=&quot;#555&quot; BackGradientStyle=&quot;TopBottom&quot; BorderColor=&quot;181, 64, 1&quot; BorderWidth=&quot;2&quot; BorderlineDashStyle=&quot;Solid&quot; Palette=&quot;Excel&quot; AntiAliasing=&quot;All&quot;&gt;
        ///    &lt;ChartAreas&gt;
        ///        &lt;ChartArea Name=&quot;Default&quot; _Template_=&quot;All&quot; BackColor=&quot;Transparent&quot; BackSecondaryColor=&quot;White&quot; BorderColor=&quot;64, 64, 64, 64&quot; BorderDashStyle=&quot;Solid&quot; ShadowColor=&quot;Transparent&quot;&gt;
        ///            &lt;Area3DStyle LightStyle=&quot;Simplistic&quot; Enable3D=&quot;True&quot; Inclination=&quot;5&quot; IsClustered=&quot;False&quot; IsRightAngleAxes=&quot;False&quot; Perspective=&quot;10&quot; Rotation [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Vanilla3D {
            get {
                return ResourceManager.GetString("Vanilla3D", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;Chart  BackColor=&quot;#FADA5E&quot; BackGradientStyle=&quot;TopBottom&quot; BorderColor=&quot;#B8860B&quot; BorderWidth=&quot;2&quot; BorderlineDashStyle=&quot;Solid&quot; Palette=&quot;EarthTones&quot;&gt;
        ///  &lt;ChartAreas&gt;
        ///    &lt;ChartArea Name=&quot;Default&quot; _Template_=&quot;All&quot; BackColor=&quot;Transparent&quot; BackSecondaryColor=&quot;White&quot; BorderColor=&quot;64, 64, 64, 64&quot; BorderDashStyle=&quot;Solid&quot; ShadowColor=&quot;Transparent&quot;&gt;
        ///      &lt;AxisY&gt;
        ///        &lt;LabelStyle Font=&quot;Trebuchet MS, 8.25pt, style=Bold&quot; /&gt;
        ///      &lt;/AxisY&gt;
        ///      &lt;AxisX LineColor=&quot;64, 64, 64, 64&quot;&gt;
        ///        &lt;LabelStyle Font=&quot;Trebuch [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Yellow {
            get {
                return ResourceManager.GetString("Yellow", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Helpers/Resources/ChartTemplates.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Blue" xml:space="preserve">
    <value>&lt;Chart BackColor="#D3DFF0" BackGradientStyle="TopBottom" BackSecondaryColor="White" BorderColor="26, 59, 105" BorderlineDashStyle="Solid" BorderWidth="2" Palette="BrightPastel"&gt;
 	&lt;ChartAreas&gt;
		&lt;ChartArea Name="Default" _Template_="All" BackColor="64, 165, 191, 228" BackGradientStyle="TopBottom" BackSecondaryColor="White" BorderColor="64, 64, 64, 64" BorderDashStyle="Solid" ShadowColor="Transparent" /&gt; 
	&lt;/ChartAreas&gt;
	&lt;Legends&gt;
		&lt;Legend _Template_="All" BackColor="Transparent" Font="Trebuchet MS, 8.25pt, style=Bold" IsTextAutoFit="False" /&gt; 
	&lt;/Legends&gt;
	&lt;BorderSkin SkinStyle="Emboss" /&gt; 
  &lt;/Chart&gt;</value>
  </data>
  <data name="Green" xml:space="preserve">
    <value>&lt;Chart BackColor="#C9DC87" BackGradientStyle="TopBottom" BorderColor="181, 64, 1" BorderWidth="2" BorderlineDashStyle="Solid" Palette="BrightPastel"&gt;
  &lt;ChartAreas&gt;
    &lt;ChartArea Name="Default" _Template_="All" BackColor="Transparent" BackSecondaryColor="White" BorderColor="64, 64, 64, 64" BorderDashStyle="Solid" ShadowColor="Transparent"&gt;
      &lt;AxisY LineColor="64, 64, 64, 64"&gt;
        &lt;MajorGrid Interval="Auto" LineColor="64, 64, 64, 64" /&gt;
        &lt;LabelStyle Font="Trebuchet MS, 8.25pt, style=Bold" /&gt;
      &lt;/AxisY&gt;
      &lt;AxisX LineColor="64, 64, 64, 64"&gt;
        &lt;MajorGrid LineColor="64, 64, 64, 64" /&gt;
        &lt;LabelStyle Font="Trebuchet MS, 8.25pt, style=Bold" /&gt;
      &lt;/AxisX&gt;
      &lt;Area3DStyle Inclination="15" IsClustered="False" IsRightAngleAxes="False" Perspective="10" Rotation="10" WallWidth="0" /&gt;
    &lt;/ChartArea&gt;
  &lt;/ChartAreas&gt;
  &lt;Legends&gt;
    &lt;Legend _Template_="All" Alignment="Center" BackColor="Transparent" Docking="Bottom" Font="Trebuchet MS, 8.25pt, style=Bold" IsTextAutoFit ="False" LegendStyle="Row"&gt;
    &lt;/Legend&gt;
  &lt;/Legends&gt;
  &lt;BorderSkin SkinStyle="Emboss" /&gt;
&lt;/Chart&gt;</value>
  </data>
  <data name="Vanilla" xml:space="preserve">
    <value>&lt;Chart Palette="SemiTransparent" BorderColor="#000" BorderWidth="2" BorderlineDashStyle="Solid"&gt;
&lt;ChartAreas&gt;
    &lt;ChartArea _Template_="All" Name="Default"&gt;
            &lt;AxisX&gt;
                &lt;MinorGrid Enabled="False" /&gt;
                &lt;MajorGrid Enabled="False" /&gt;
            &lt;/AxisX&gt;
            &lt;AxisY&gt;
                &lt;MajorGrid Enabled="False" /&gt;
                &lt;MinorGrid Enabled="False" /&gt;
            &lt;/AxisY&gt;
    &lt;/ChartArea&gt;
&lt;/ChartAreas&gt;
&lt;/Chart&gt;</value>
  </data>
  <data name="Vanilla3D" xml:space="preserve">
    <value>&lt;Chart BackColor="#555" BackGradientStyle="TopBottom" BorderColor="181, 64, 1" BorderWidth="2" BorderlineDashStyle="Solid" Palette="SemiTransparent" AntiAliasing="All"&gt;
    &lt;ChartAreas&gt;
        &lt;ChartArea Name="Default" _Template_="All" BackColor="Transparent" BackSecondaryColor="White" BorderColor="64, 64, 64, 64" BorderDashStyle="Solid" ShadowColor="Transparent"&gt;
            &lt;Area3DStyle LightStyle="Simplistic" Enable3D="True" Inclination="30" IsClustered="False" IsRightAngleAxes="False" Perspective="10" Rotation="-30" WallWidth="0" /&gt;
        &lt;/ChartArea&gt;
    &lt;/ChartAreas&gt;
&lt;/Chart&gt;</value>
  </data>
  <data name="Yellow" xml:space="preserve">
    <value>&lt;Chart  BackColor="#FADA5E" BackGradientStyle="TopBottom" BorderColor="#B8860B" BorderWidth="2" BorderlineDashStyle="Solid" Palette="EarthTones"&gt;
  &lt;ChartAreas&gt;
    &lt;ChartArea Name="Default" _Template_="All" BackColor="Transparent" BackSecondaryColor="White" BorderColor="64, 64, 64, 64" BorderDashStyle="Solid" ShadowColor="Transparent"&gt;
      &lt;AxisY&gt;
        &lt;LabelStyle Font="Trebuchet MS, 8.25pt, style=Bold" /&gt;
      &lt;/AxisY&gt;
      &lt;AxisX LineColor="64, 64, 64, 64"&gt;
        &lt;LabelStyle Font="Trebuchet MS, 8.25pt, style=Bold" /&gt;
      &lt;/AxisX&gt;
    &lt;/ChartArea&gt;
  &lt;/ChartAreas&gt;
  &lt;Legends&gt;
    &lt;Legend _Template_="All" Alignment="Left" BackColor="Transparent" Docking="Bottom" Font="Trebuchet MS, 8.25pt, style=Bold" LegendStyle="Row"&gt;
    &lt;/Legend&gt;
  &lt;/Legends&gt;
  &lt;BorderSkin SkinStyle="Emboss" /&gt;
&lt;/Chart&gt;</value>
  </data>
</root>

================================================
FILE: src/System.Web.Helpers/Resources/HelpersResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.225
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Helpers.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class HelpersResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal HelpersResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Helpers.Resources.HelpersResources", typeof(HelpersResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Argument conversion to type &quot;{0}&quot; failed..
        /// </summary>
        internal static string Chart_ArgumentConversionFailed {
            get {
                return ResourceManager.GetString("Chart_ArgumentConversionFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A series cannot be data-bound to a string object..
        /// </summary>
        internal static string Chart_ExceptionDataBindSeriesToString {
            get {
                return ResourceManager.GetString("Chart_ExceptionDataBindSeriesToString", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The theme file &quot;{0}&quot; could not be found..
        /// </summary>
        internal static string Chart_ThemeFileNotFound {
            get {
                return ResourceManager.GetString("Chart_ThemeFileNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The hash algorithm &apos;{0}&apos; is not supported, valid values are: sha256, sha1, md5.
        /// </summary>
        internal static string Crypto_NotSupportedHashAlg {
            get {
                return ResourceManager.GetString("Crypto_NotSupportedHashAlg", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; is invalid image format. Valid values are image format names like: &quot;JPEG&quot;, &quot;BMP&quot;, &quot;GIF&quot;, &quot;PNG&quot;, etc..
        /// </summary>
        internal static string Image_IncorrectImageFormat {
            get {
                return ResourceManager.GetString("Image_IncorrectImageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to convert to &quot;{0}&quot;. Use Json.Decode&lt;T&gt; instead..
        /// </summary>
        internal static string Json_UnableToConvertType {
            get {
                return ResourceManager.GetString("Json_UnableToConvertType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Previously Displayed.
        /// </summary>
        internal static string ObjectInfo_PreviousDisplayed {
            get {
                return ResourceManager.GetString("ObjectInfo_PreviousDisplayed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Accessing a property threw an exception: .
        /// </summary>
        internal static string ObjectInfo_PropertyThrewException {
            get {
                return ResourceManager.GetString("ObjectInfo_PropertyThrewException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to File path &quot;{0}&quot; is invalid..
        /// </summary>
        internal static string PathUtils_IncorrectPath {
            get {
                return ResourceManager.GetString("PathUtils_IncorrectPath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Additional server information is available when the page is running with high trust..
        /// </summary>
        internal static string ServerInfo_AdditionalInfo {
            get {
                return ResourceManager.GetString("ServerInfo_AdditionalInfo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Environment Variables.
        /// </summary>
        internal static string ServerInfo_EnvVars {
            get {
                return ResourceManager.GetString("ServerInfo_EnvVars", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ASP.NET Server Information.
        /// </summary>
        internal static string ServerInfo_Header {
            get {
                return ResourceManager.GetString("ServerInfo_Header", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTTP Runtime Information.
        /// </summary>
        internal static string ServerInfo_HttpRuntime {
            get {
                return ResourceManager.GetString("ServerInfo_HttpRuntime", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legacy Code Access Security.
        /// </summary>
        internal static string ServerInfo_LegacyCAS {
            get {
                return ResourceManager.GetString("ServerInfo_LegacyCAS", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legacy Code Access Security has been detected on your system. Microsoft WebPage features require the ASP.NET 4 Code Access Security model. For information about how to resolve this, contact your server administrator..
        /// </summary>
        internal static string ServerInfo_LegacyCasHelpInfo {
            get {
                return ResourceManager.GetString("ServerInfo_LegacyCasHelpInfo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to no value.
        /// </summary>
        internal static string ServerInfo_NoValue {
            get {
                return ResourceManager.GetString("ServerInfo_NoValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Server Configuration.
        /// </summary>
        internal static string ServerInfo_ServerConfigTable {
            get {
                return ResourceManager.GetString("ServerInfo_ServerConfigTable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ASP.NET Server Variables.
        /// </summary>
        internal static string ServerInfo_ServerVars {
            get {
                return ResourceManager.GetString("ServerInfo_ServerVars", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The column name cannot be null or an empty string unless a custom format is specified..
        /// </summary>
        internal static string WebGrid_ColumnNameOrFormatRequired {
            get {
                return ResourceManager.GetString("WebGrid_ColumnNameOrFormatRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Column &quot;{0}&quot; does not exist..
        /// </summary>
        internal static string WebGrid_ColumnNotFound {
            get {
                return ResourceManager.GetString("WebGrid_ColumnNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The WebGrid instance is already bound to a data source..
        /// </summary>
        internal static string WebGrid_DataSourceBound {
            get {
                return ResourceManager.GetString("WebGrid_DataSourceBound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A data source must be bound before this operation can be performed..
        /// </summary>
        internal static string WebGrid_NoDataSourceBound {
            get {
                return ResourceManager.GetString("WebGrid_NoDataSourceBound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This operation is not supported when paging is disabled for the &quot;WebGrid&quot; object..
        /// </summary>
        internal static string WebGrid_NotSupportedIfPagingIsDisabled {
            get {
                return ResourceManager.GetString("WebGrid_NotSupportedIfPagingIsDisabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This operation is not supported when sorting is disabled for the &quot;WebGrid&quot; object..
        /// </summary>
        internal static string WebGrid_NotSupportedIfSortingIsDisabled {
            get {
                return ResourceManager.GetString("WebGrid_NotSupportedIfSortingIsDisabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use this argument, pager mode &quot;{0}&quot; must be enabled..
        /// </summary>
        internal static string WebGrid_PagerModeMustBeEnabled {
            get {
                return ResourceManager.GetString("WebGrid_PagerModeMustBeEnabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This property cannot be set after the &quot;WebGrid&quot; object has been sorted or paged. Make sure that this property is set prior to invoking the &quot;Rows&quot; property directly or indirectly through other methods such as &quot;GetHtml&quot;, &quot;Pager&quot;, &quot;Table&quot;, etc..
        /// </summary>
        internal static string WebGrid_PropertySetterNotSupportedAfterDataBound {
            get {
                return ResourceManager.GetString("WebGrid_PropertySetterNotSupportedAfterDataBound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value for &quot;rowCount&quot; must be specified when &quot;autoSortAndPage&quot; is set to true and paging is enabled..
        /// </summary>
        internal static string WebGrid_RowCountNotSpecified {
            get {
                return ResourceManager.GetString("WebGrid_RowCountNotSpecified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select.
        /// </summary>
        internal static string WebGrid_SelectLinkText {
            get {
                return ResourceManager.GetString("WebGrid_SelectLinkText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;fontColor&quot; value is invalid. Valid values are names like &quot;White&quot;, &quot;Black&quot;, or &quot;DarkBlue&quot;, or hexadecimal values in the form &quot;#RRGGBB&quot; or &quot;#RGB&quot;..
        /// </summary>
        internal static string WebImage_IncorrectColorName {
            get {
                return ResourceManager.GetString("WebImage_IncorrectColorName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;fontFamily&quot; value is invalid. Valid values are font family names like: &quot;Arial&quot;, &quot;Times New Roman&quot;, etc. Make sure that the font family you are trying to use is installed on the server..
        /// </summary>
        internal static string WebImage_IncorrectFontFamily {
            get {
                return ResourceManager.GetString("WebImage_IncorrectFontFamily", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;fontStyle&quot; value is invalid. Valid values are: &quot;Regular&quot;, &quot;Bold&quot;, &quot;Italic&quot;, &quot;Underline&quot;, and &quot;Strikeout&quot;..
        /// </summary>
        internal static string WebImage_IncorrectFontStyle {
            get {
                return ResourceManager.GetString("WebImage_IncorrectFontStyle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;horizontalAlign&quot; value is invalid. Valid values are: &quot;Right&quot;, &quot;Left&quot;, and &quot;Center&quot;..
        /// </summary>
        internal static string WebImage_IncorrectHorizontalAlignment {
            get {
                return ResourceManager.GetString("WebImage_IncorrectHorizontalAlignment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;verticalAlign&quot; value is invalid. Valid values are: &quot;Top&quot;, &quot;Bottom&quot;, and &quot;Middle&quot;..
        /// </summary>
        internal static string WebImage_IncorrectVerticalAlignment {
            get {
                return ResourceManager.GetString("WebImage_IncorrectVerticalAlignment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Watermark width and height must both be positive or both be zero..
        /// </summary>
        internal static string WebImage_IncorrectWidthAndHeight {
            get {
                return ResourceManager.GetString("WebImage_IncorrectWidthAndHeight", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An image could not be constructed from the content provided..
        /// </summary>
        internal static string WebImage_InvalidImageContents {
            get {
                return ResourceManager.GetString("WebImage_InvalidImageContents", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;priority&quot; value is invalid. Valid values are &quot;Low&quot;, &quot;Normal&quot; and &quot;High&quot;..
        /// </summary>
        internal static string WebMail_InvalidPriority {
            get {
                return ResourceManager.GetString("WebMail_InvalidPriority", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A string in the collection is null or empty..
        /// </summary>
        internal static string WebMail_ItemInCollectionIsNull {
            get {
                return ResourceManager.GetString("WebMail_ItemInCollectionIsNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;SmtpServer&quot; was not specified..
        /// </summary>
        internal static string WebMail_SmtpServerNotSpecified {
            get {
                return ResourceManager.GetString("WebMail_SmtpServerNotSpecified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No &quot;From&quot; email address was specified and a default value could not be assigned..
        /// </summary>
        internal static string WebMail_UnableToDetermineFrom {
            get {
                return ResourceManager.GetString("WebMail_UnableToDetermineFrom", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Helpers/Resources/HelpersResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Chart_ArgumentConversionFailed" xml:space="preserve">
    <value>Argument conversion to type "{0}" failed.</value>
  </data>
  <data name="Chart_ExceptionDataBindSeriesToString" xml:space="preserve">
    <value>A series cannot be data-bound to a string object.</value>
  </data>
  <data name="Chart_ThemeFileNotFound" xml:space="preserve">
    <value>The theme file "{0}" could not be found.</value>
  </data>
  <data name="Crypto_NotSupportedHashAlg" xml:space="preserve">
    <value>The hash algorithm '{0}' is not supported, valid values are: sha256, sha1, md5</value>
  </data>
  <data name="Image_IncorrectImageFormat" xml:space="preserve">
    <value>"{0}" is invalid image format. Valid values are image format names like: "JPEG", "BMP", "GIF", "PNG", etc.</value>
  </data>
  <data name="Json_UnableToConvertType" xml:space="preserve">
    <value>Unable to convert to "{0}". Use Json.Decode&lt;T&gt; instead.</value>
  </data>
  <data name="ObjectInfo_PreviousDisplayed" xml:space="preserve">
    <value>Previously Displayed</value>
  </data>
  <data name="ObjectInfo_PropertyThrewException" xml:space="preserve">
    <value>Accessing a property threw an exception: </value>
  </data>
  <data name="PathUtils_IncorrectPath" xml:space="preserve">
    <value>File path "{0}" is invalid.</value>
  </data>
  <data name="ServerInfo_AdditionalInfo" xml:space="preserve">
    <value>Additional server information is available when the page is running with high trust.</value>
  </data>
  <data name="ServerInfo_EnvVars" xml:space="preserve">
    <value>Environment Variables</value>
  </data>
  <data name="ServerInfo_Header" xml:space="preserve">
    <value>ASP.NET Server Information</value>
  </data>
  <data name="ServerInfo_HttpRuntime" xml:space="preserve">
    <value>HTTP Runtime Information</value>
  </data>
  <data name="ServerInfo_LegacyCAS" xml:space="preserve">
    <value>Legacy Code Access Security</value>
  </data>
  <data name="ServerInfo_LegacyCasHelpInfo" xml:space="preserve">
    <value>Legacy Code Access Security has been detected on your system. Microsoft WebPage features require the ASP.NET 4 Code Access Security model. For information about how to resolve this, contact your server administrator.</value>
  </data>
  <data name="ServerInfo_NoValue" xml:space="preserve">
    <value>no value</value>
  </data>
  <data name="ServerInfo_ServerConfigTable" xml:space="preserve">
    <value>Server Configuration</value>
  </data>
  <data name="ServerInfo_ServerVars" xml:space="preserve">
    <value>ASP.NET Server Variables</value>
  </data>
  <data name="WebGrid_ColumnNameOrFormatRequired" xml:space="preserve">
    <value>The column name cannot be null or an empty string unless a custom format is specified.</value>
  </data>
  <data name="WebGrid_ColumnNotFound" xml:space="preserve">
    <value>Column "{0}" does not exist.</value>
  </data>
  <data name="WebGrid_DataSourceBound" xml:space="preserve">
    <value>The WebGrid instance is already bound to a data source.</value>
  </data>
  <data name="WebGrid_NoDataSourceBound" xml:space="preserve">
    <value>A data source must be bound before this operation can be performed.</value>
  </data>
  <data name="WebGrid_NotSupportedIfPagingIsDisabled" xml:space="preserve">
    <value>This operation is not supported when paging is disabled for the "WebGrid" object.</value>
  </data>
  <data name="WebGrid_NotSupportedIfSortingIsDisabled" xml:space="preserve">
    <value>This operation is not supported when sorting is disabled for the "WebGrid" object.</value>
  </data>
  <data name="WebGrid_PagerModeMustBeEnabled" xml:space="preserve">
    <value>To use this argument, pager mode "{0}" must be enabled.</value>
  </data>
  <data name="WebGrid_PropertySetterNotSupportedAfterDataBound" xml:space="preserve">
    <value>This property cannot be set after the "WebGrid" object has been sorted or paged. Make sure that this property is set prior to invoking the "Rows" property directly or indirectly through other methods such as "GetHtml", "Pager", "Table", etc.</value>
  </data>
  <data name="WebGrid_RowCountNotSpecified" xml:space="preserve">
    <value>A value for "rowCount" must be specified when "autoSortAndPage" is set to true and paging is enabled.</value>
  </data>
  <data name="WebGrid_SelectLinkText" xml:space="preserve">
    <value>Select</value>
  </data>
  <data name="WebImage_IncorrectColorName" xml:space="preserve">
    <value>The "fontColor" value is invalid. Valid values are names like "White", "Black", or "DarkBlue", or hexadecimal values in the form "#RRGGBB" or "#RGB".</value>
  </data>
  <data name="WebImage_IncorrectFontFamily" xml:space="preserve">
    <value>The "fontFamily" value is invalid. Valid values are font family names like: "Arial", "Times New Roman", etc. Make sure that the font family you are trying to use is installed on the server.</value>
  </data>
  <data name="WebImage_IncorrectFontStyle" xml:space="preserve">
    <value>The "fontStyle" value is invalid. Valid values are: "Regular", "Bold", "Italic", "Underline", and "Strikeout".</value>
  </data>
  <data name="WebImage_IncorrectHorizontalAlignment" xml:space="preserve">
    <value>The "horizontalAlign" value is invalid. Valid values are: "Right", "Left", and "Center".</value>
  </data>
  <data name="WebImage_IncorrectVerticalAlignment" xml:space="preserve">
    <value>The "verticalAlign" value is invalid. Valid values are: "Top", "Bottom", and "Middle".</value>
  </data>
  <data name="WebImage_IncorrectWidthAndHeight" xml:space="preserve">
    <value>Watermark width and height must both be positive or both be zero.</value>
  </data>
  <data name="WebImage_InvalidImageContents" xml:space="preserve">
    <value>An image could not be constructed from the content provided.</value>
  </data>
  <data name="WebMail_InvalidPriority" xml:space="preserve">
    <value>The "priority" value is invalid. Valid values are "Low", "Normal" and "High".</value>
  </data>
  <data name="WebMail_ItemInCollectionIsNull" xml:space="preserve">
    <value>A string in the collection is null or empty.</value>
  </data>
  <data name="WebMail_SmtpServerNotSpecified" xml:space="preserve">
    <value>"SmtpServer" was not specified.</value>
  </data>
  <data name="WebMail_UnableToDetermineFrom" xml:space="preserve">
    <value>No "From" email address was specified and a default value could not be assigned.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Helpers/ServerInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Security;
using System.Text;
using System.Web.Helpers.Resources;
using System.Web.WebPages;

namespace System.Web.Helpers
{
    /// <summary>
    /// Provides various info about ASP.NET server.
    /// </summary>
    public static class ServerInfo
    {
        /// <remarks>
        /// todo: figure out right place for this
        /// </remarks>
        private const string Style =
            "<style type=\"text/css\">" +
            "  div.server-info { text-align: center; }" +
            "  table.server-info { border-collapse:collapse; text-align:center; margin: auto; width:600px; direction: ltr; }" +
            "  table.server-info tbody tr:nth-child(even){ background-color: #EEE; }" +
            "  table.server-info, table.server-info th, table.server-info td { border:1px solid black; }" +
            "  table.server-info th, table.server-info td " +
            " { text-align:left; padding:2px; font-family:Tahoma, Arial, sans-serif; font-size:0.75em; }" +
            "  h1.server-info { font-family:Tahoma, Arial, sans-serif; font-size:150%; text-align:center; }" +
            "  table.server-info h2 { font-family:Tahoma, Arial, sans-serif; font-size:125%; text-align:center; }" +
            "  p.server-info { text-align:center; font-family:Tahoma, Arial, sans-serif; font-size:0.75em; }" +
            "  .ital { font-style: italic; } " +
            "  .warn { color: #F00; } " +
            "</style>";

        internal static IDictionary<string, string> EnvironmentVariables()
        {
            // todo: extract well defined subset for special use?

            // use a case-insensitive dictionary since environment variables are case-insensitive.
            IDictionary<string, string> environmentVariablesResult = new SortedDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            IDictionary environmentVariables;

            // todo: better way to deal with security; query config for trust level?
            try
            {
                environmentVariables = Environment.GetEnvironmentVariables();
            }
            catch (SecurityException)
            {
                return environmentVariablesResult;
            }

            foreach (DictionaryEntry entry in environmentVariables)
            {
                environmentVariablesResult.Add(entry.Key.ToString(), InsertWhiteSpace(entry.Value.ToString()));
            }

            return environmentVariablesResult;
        }

        internal static IDictionary<string, string> ServerVariables()
        {
            var httpContext = HttpContext.Current;
            return ServerVariables(httpContext != null ? new HttpContextWrapper(httpContext) : null);
        }

        internal static IDictionary<string, string> ServerVariables(HttpContextBase context)
        {
            // todo: extract well defined subset for special use?

            IDictionary<string, string> serverVariablesResult = new SortedDictionary<string, string>();
            NameValueCollection serverVariables;

            // todo: better way to deal with security; query config for trust level?
            try
            {
                if ((context != null) && (context.Request != null))
                {
                    serverVariables = context.Request.ServerVariables;
                }
                else
                {
                    // Just return empty collection when there is no context available.
                    return serverVariablesResult;
                }
            }
            catch (SecurityException)
            {
                return serverVariablesResult;
            }

            foreach (string key in serverVariables.AllKeys)
            {
                // todo: these values contains very long strings with no spaces that distorts table layout - figure out how to deal with it
                if (key.Equals("ALL_HTTP", StringComparison.OrdinalIgnoreCase) ||
                    key.Equals("ALL_RAW", StringComparison.OrdinalIgnoreCase) ||
                    key.Equals("HTTP_AUTHORIZATION", StringComparison.OrdinalIgnoreCase) ||
                    key.Equals("HTTP_COOKIE", StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                serverVariablesResult.Add(key, InsertWhiteSpace(serverVariables[key]));
            }

            return serverVariablesResult;
        }

        internal static IDictionary<string, string> Configuration()
        {
            IDictionary<string, string> info = new Dictionary<string, string>();

            // todo: do we need to localize these strings or would that be confusing
            // (Since we just display API names that are all in English)

            info.Add("Current Local Time", DateTime.Now.ToString(CultureInfo.CurrentCulture));
            info.Add("Current UTC Time", DateTime.UtcNow.ToString(CultureInfo.CurrentCulture));
            info.Add("Current Culture", CultureInfo.CurrentCulture.DisplayName);

            info.Add("Machine Name", Environment.MachineName);
            info.Add("OS Version", Environment.OSVersion.ToString());
            info.Add("ASP.NET Version", Environment.Version.ToString());
            info.Add("ASP.NET Web Pages Version", new AssemblyName(typeof(WebPage).Assembly.FullName).Version.ToString());
            info.Add("User Name", Environment.UserName);
            info.Add("User Interactive", Environment.UserInteractive.ToString());
            info.Add("Processor Count", Environment.ProcessorCount.ToString(CultureInfo.InvariantCulture));
            info.Add("Tick Count", Environment.TickCount.ToString(CultureInfo.InvariantCulture));

            // Calls bellow require full trust.

            try
            {
                info.Add("Current Directory", Environment.CurrentDirectory);
            }
            catch (SecurityException)
            {
                return info;
            }

            info.Add("System Directory", Environment.SystemDirectory);
            info.Add("User Domain Name", Environment.UserDomainName);
            info.Add("Working Set", Environment.WorkingSet.ToString(CultureInfo.InvariantCulture) + " bytes");

            return info;
        }

        internal static IDictionary<string, string> HttpRuntimeInfo()
        {
            IDictionary<string, string> info = new Dictionary<string, string>();

            // todo: better way to deal with security; query config for trust level?
            try
            {
                info.Add("CLR Install Directory", HttpRuntime.ClrInstallDirectory);
            }
            catch (SecurityException)
            {
                return info;
            }

            try
            {
                info.Add("Codegen Directory", HttpRuntime.CodegenDir);
                info.Add("Bin Directory", HttpRuntime.BinDirectory);
                info.Add("AppDomain Application Path", HttpRuntime.AppDomainAppPath);
            }
            catch (ArgumentException)
            {
                // do nothing
                // These APIs don't check if path is set before setting security demands, which causes exception.
                // So far this happens only when running from unit tests.
            }

            info.Add("Asp Install Directory", HttpRuntime.AspInstallDirectory);
            info.Add("Machine Configuration Directory", HttpRuntime.MachineConfigurationDirectory);

            info.Add("AppDomain Id", HttpRuntime.AppDomainId);
            info.Add("AppDomain Application Id", HttpRuntime.AppDomainAppId);
            info.Add("AppDomain Application Virtual Path", HttpRuntime.AppDomainAppVirtualPath);

            info.Add("Asp Client Script Physical Path", HttpRuntime.AspClientScriptPhysicalPath);

            info.Add("Asp Client Script Virtual Path", HttpRuntime.AspClientScriptVirtualPath);

            info.Add("Cache Size", HttpRuntime.Cache.Count.ToString(CultureInfo.InvariantCulture));
            info.Add("Cache Effective Percentage Physical Memory Limit", HttpRuntime.Cache.EffectivePercentagePhysicalMemoryLimit.ToString(CultureInfo.InvariantCulture));
            info.Add("Cache Effective Private Bytes Limit", HttpRuntime.Cache.EffectivePrivateBytesLimit.ToString(CultureInfo.InvariantCulture));

            info.Add("On UNC Share", HttpRuntime.IsOnUNCShare.ToString());

            return info;
        }

        internal static IDictionary<string, string> LegacyCAS()
        {
            return LegacyCAS(AppDomain.CurrentDomain);
        }

        internal static IDictionary<string, string> LegacyCAS(AppDomain appDomain)
        {
            IDictionary<string, string> info = new Dictionary<string, string>();

            try
            {
                bool legacyCasModeEnabled = !appDomain.IsHomogenous;
                if (legacyCasModeEnabled)
                {
                    info[HelpersResources.ServerInfo_LegacyCAS] = HelpersResources.ServerInfo_LegacyCasHelpInfo;
                }
            }
            catch (SecurityException)
            {
                return info;
            }
            return info;
        }

        /// <summary>
        /// Generates HTML required to display server information.
        /// </summary>
        /// <remarks>
        /// HTML generated is XHTML 1.0 compliant but not XHTML 1.1 or HTML5 compliant. The reason is that we
        /// generate &lt;style&gt; tag inside &lt;body&gt; tag, which is not allowed. This is by design for now since ServerInfo
        /// is debugging aid and should not be used as a permanent part of any web page.
        /// </remarks>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate",
            Justification = "This could be time consuming operation that does not just retrieve a field.")]
        public static HtmlString GetHtml()
        {
            StringBuilder sb = new StringBuilder(Style);

            sb.AppendLine(String.Format(CultureInfo.InvariantCulture, "<h1 class=\"server-info\">{0}</h1>",
                                        HttpUtility.HtmlEncode(HelpersResources.ServerInfo_Header)));

            var configuration = Configuration();
            Debug.Assert((configuration != null) && (configuration.Count > 0));
            PrintInfoSection(sb, HelpersResources.ServerInfo_ServerConfigTable, configuration);

            var serverVariables = ServerVariables();
            Debug.Assert((serverVariables != null));
            PrintInfoSection(sb, HelpersResources.ServerInfo_ServerVars, serverVariables);

            var legacyCAS = LegacyCAS();
            if (legacyCAS.Any())
            {
                PrintInfoSection(sb, HelpersResources.ServerInfo_LegacyCAS, legacyCAS);
            }

            // Info below is not available in medium trust.

            var httpRuntimeInfo = HttpRuntimeInfo();
            Debug.Assert(httpRuntimeInfo != null);

            if (!httpRuntimeInfo.Any())
            {
                sb.AppendLine(String.Format(CultureInfo.InvariantCulture, "<p class=\"server-info\">{0}</p>",
                                            HttpUtility.HtmlEncode(HelpersResources.ServerInfo_AdditionalInfo)));
                return new HtmlString(sb.ToString());
            }
            else
            {
                PrintInfoSection(sb, HelpersResources.ServerInfo_HttpRuntime, httpRuntimeInfo);

                var envVariables = EnvironmentVariables();
                Debug.Assert(envVariables != null);
                PrintInfoSection(sb, HelpersResources.ServerInfo_EnvVars, envVariables);
            }

            return new HtmlString(sb.ToString());
        }

        /// <summary>
        /// Renders a table section printing out rows and columns.
        /// </summary>
        private static void PrintInfoSection(StringBuilder builder, string sectionTitle, IDictionary<string, string> entries)
        {
            builder.AppendLine("<div class=\"server-info\">");
            builder.AppendLine("<table class=\"server-info\" dir=\"ltr\">");
            if (!String.IsNullOrEmpty(sectionTitle))
            {
                builder.AppendLine("<caption>");
                builder.AppendFormat(CultureInfo.InvariantCulture, "<h2>{0}</h2>", HttpUtility.HtmlEncode(sectionTitle)).AppendLine();
                builder.AppendLine("</caption>");
            }
            builder.AppendLine("<colgroup><col style=\"width:30%;\" /> <col style=\"width:70%;\"  /></colgroup>");
            builder.AppendLine("<tbody>");
            foreach (var entry in entries)
            {
                var css = String.Empty;
                string value = entry.Value;
                if (entry.Key == HelpersResources.ServerInfo_LegacyCAS)
                {
                    // TODO: suboptimal solution, but its easier to do this than come up with something that works better
                    css = "warn";
                }
                else if (String.IsNullOrEmpty(entry.Value))
                {
                    css = "ital";
                    value = HelpersResources.ServerInfo_NoValue;
                }
                if (css.Any())
                {
                    css = " class=\"" + css + "\"";
                }
                builder.Append("<tr>");
                builder.AppendFormat(CultureInfo.InvariantCulture, "<th scope=\"row\">{0}</th>", HttpUtility.HtmlEncode(entry.Key));
                builder.AppendFormat(CultureInfo.InvariantCulture, "<td{0}>{1}</td>", css, HttpUtility.HtmlEncode(value));
                builder.AppendLine("</tr>");
            }
            builder.AppendLine("</tbody>");
            builder.AppendLine("</table>");
            builder.AppendLine("</div>");
        }

        /// <summary>
        /// Inserts spaces after ',' and ';' so table can be rendered properly.
        /// </summary>
        private static string InsertWhiteSpace(string s)
        {
            return s.Replace(",", ", ").Replace(";", "; ");
        }
    }
}


================================================
FILE: src/System.Web.Helpers/SortDirection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers
{
    public enum SortDirection
    {
        Ascending,
        Descending
    }
}


================================================
FILE: src/System.Web.Helpers/System.Web.Helpers.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{9B7E3740-6161-4548-833C-4BBCA43B970E}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>System.Web.Helpers</RootNamespace>
    <AssemblyName>System.Web.Helpers</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\WebHelpers.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Runtime.Caching" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.DataVisualization" />
    <Reference Include="System.Web.Extensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.XML" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="Chart\Chart.cs" />
    <Compile Include="Chart\ChartTheme.cs" />
    <Compile Include="Common\VirtualPathUtil.cs" />
    <Compile Include="ConversionUtil.cs" />
    <Compile Include="Crypto.cs" />
    <Compile Include="DynamicHelper.cs" />
    <Compile Include="DynamicJavaScriptConverter.cs" />
    <Compile Include="DynamicJsonArray.cs" />
    <Compile Include="DynamicJsonObject.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="HtmlElement.cs" />
    <Compile Include="HtmlObjectPrinter.cs" />
    <Compile Include="Json.cs" />
    <Compile Include="ObjectInfo.cs" />
    <Compile Include="ObjectVisitor.cs" />
    <Compile Include="WebCache.cs" />
    <Compile Include="ServerInfo.cs" />
    <Compile Include="Resources\HelpersResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>HelpersResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="SortDirection.cs" />
    <Compile Include="WebGrid\IWebGridDataSource.cs" />
    <Compile Include="WebGrid\PreComputedGridDataSource.cs" />
    <Compile Include="WebGrid\SortInfo.cs" />
    <Compile Include="WebGrid\WebGridDataSource.cs" />
    <Compile Include="WebGrid\WebGrid.cs" />
    <Compile Include="WebGrid\WebGridColumn.cs" />
    <Compile Include="WebGrid\WebGridPagerModes.cs" />
    <Compile Include="WebGrid\_WebGridRenderer.generated.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>_WebGridRenderer.cshtml</DependentUpon>
    </Compile>
    <Compile Include="WebGrid\WebGridRow.cs" />
    <Compile Include="WebImage.cs" />
    <Compile Include="WebMail.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Resources\HelpersResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>HelpersResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Content Include="WebGrid\_WebGridRenderer.cshtml">
      <Generator>RazorHelperGenerator</Generator>
      <LastGenOutput>_WebGridRenderer.generated.cs</LastGenOutput>
      <CustomToolNamespace>System.Web.Helpers</CustomToolNamespace>
    </Content>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Helpers/WebCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Runtime.Caching;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    public static class WebCache
    {
        public static void Set(string key, object value, int minutesToCache = 20, bool slidingExpiration = true)
        {
            if (minutesToCache <= 0)
            {
                throw new ArgumentOutOfRangeException("minutesToCache",
                                                      String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThan, 0));
            }
            else if (slidingExpiration && (minutesToCache > 365 * 24 * 60))
            {
                // For sliding expiration policies, MemoryCache has a time limit of 365 days. 
                throw new ArgumentOutOfRangeException("minutesToCache",
                                                      String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_LessThanOrEqualTo, 365 * 24 * 60));
            }

            CacheItemPolicy policy = new CacheItemPolicy();
            TimeSpan expireTime = new TimeSpan(0, minutesToCache, 0);

            if (slidingExpiration)
            {
                policy.SlidingExpiration = expireTime;
            }
            else
            {
                policy.AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(minutesToCache);
            }

            MemoryCache.Default.Set(key, value, policy);
        }

        public static dynamic Get(string key)
        {
            return MemoryCache.Default.Get(key);
        }

        public static dynamic Remove(string key)
        {
            return MemoryCache.Default.Remove(key);
        }
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/IWebGridDataSource.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Helpers
{
    internal interface IWebGridDataSource
    {
        int TotalRowCount { get; }

        IList<WebGridRow> GetRows(SortInfo sortInfo, int pageIndex);
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/PreComputedGridDataSource.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace System.Web.Helpers
{
    /// <summary>
    /// Source wrapper for data provided by the user that is already sorted and paged. The user provides the WebGrid the rows to bind and additionally the total number of rows that 
    /// are available.
    /// </summary>
    internal sealed class PreComputedGridDataSource : IWebGridDataSource
    {
        private readonly int _totalRows;
        private readonly IList<WebGridRow> _rows;

        public PreComputedGridDataSource(WebGrid grid, IEnumerable<dynamic> values, int totalRows)
        {
            Debug.Assert(grid != null);
            Debug.Assert(values != null);

            _totalRows = totalRows;
            _rows = values.Select((value, index) => new WebGridRow(grid, value: value, rowIndex: index)).ToList();
        }

        public int TotalRowCount
        {
            get { return _totalRows; }
        }

        public IList<WebGridRow> GetRows(SortInfo sortInfo, int pageIndex)
        {
            // Data is already sorted and paged. Ignore parameters.
            return _rows;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/SortInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers
{
    internal sealed class SortInfo : IEquatable<SortInfo>
    {
        public string SortColumn { get; set; }

        public SortDirection SortDirection { get; set; }

        public bool Equals(SortInfo other)
        {
            return other != null
                   && String.Equals(SortColumn, other.SortColumn, StringComparison.OrdinalIgnoreCase)
                   && SortDirection == other.SortDirection;
        }

        public override bool Equals(object obj)
        {
            SortInfo sortInfo = obj as SortInfo;
            if (sortInfo != null)
            {
                return Equals(sortInfo);
            }
            return base.Equals(obj);
        }

        public override int GetHashCode()
        {
            return SortColumn.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/WebGrid.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Web.Helpers.Resources;
using System.Web.WebPages;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    public class WebGrid
    {
        private const string AjaxUpdateScript = "$({1}).swhgLoad({0},{1}{2});";
        private readonly HttpContextBase _context;
        private readonly bool _canPage;
        private readonly bool _canSort;
        private readonly string _ajaxUpdateContainerId;
        private readonly string _ajaxUpdateCallback;
        private readonly string _defaultSort;
        private readonly string _pageFieldName = "page";
        private readonly string _sortDirectionFieldName = "sortdir";
        private readonly string _selectionFieldName = "row";
        private readonly string _sortFieldName = "sort";
        private readonly string _fieldNamePrefix;
        private int _pageIndex = -1;
        private bool _pageIndexSet;
        private int _rowsPerPage;
        private int _selectedIndex = -1;
        private bool _selectedIndexSet;
        private string _sortColumn;
        private bool _sortColumnSet;
        private bool _sortColumnExplicitlySet;
        private SortDirection _sortDirection;
        private bool _sortDirectionSet;
        private IWebGridDataSource _dataSource;
        private bool _dataSourceBound;
        private bool _dataSourceMaterialized;
        private IEnumerable<string> _columnNames;
        private Type _elementType;
        private IList<WebGridRow> _rows;

        /// <param name="source">Data source</param>
        /// <param name="columnNames">Data source column names. Auto-populated by default.</param>
        /// <param name="defaultSort">Default sort column.</param>
        /// <param name="rowsPerPage">Number of rows per page.</param>
        /// <param name="canPage"></param>
        /// <param name="canSort"></param>
        /// <param name="ajaxUpdateContainerId">ID for the grid's container element. This enables AJAX support.</param>
        /// <param name="ajaxUpdateCallback">Callback function for the AJAX functionality once the update is complete</param>
        /// <param name="fieldNamePrefix">Prefix for query string fields to support multiple grids.</param>
        /// <param name="pageFieldName">Query string field name for page number.</param>
        /// <param name="selectionFieldName">Query string field name for selected row number.</param>
        /// <param name="sortFieldName">Query string field name for sort column.</param>
        /// <param name="sortDirectionFieldName">Query string field name for sort direction.</param>
#if CODE_COVERAGE 
        [ExcludeFromCodeCoverage]
#endif
        public WebGrid(
            IEnumerable<dynamic> source = null,
            IEnumerable<string> columnNames = null,
            string defaultSort = null,
            int rowsPerPage = 10,
            bool canPage = true,
            bool canSort = true,
            string ajaxUpdateContainerId = null,
            string ajaxUpdateCallback = null,
            string fieldNamePrefix = null,
            string pageFieldName = null,
            string selectionFieldName = null,
            string sortFieldName = null,
            string sortDirectionFieldName = null)
            : this(new HttpContextWrapper(Web.HttpContext.Current), defaultSort: defaultSort, rowsPerPage: rowsPerPage, canPage: canPage,
                   canSort: canSort, ajaxUpdateContainerId: ajaxUpdateContainerId, ajaxUpdateCallback: ajaxUpdateCallback, fieldNamePrefix: fieldNamePrefix, pageFieldName: pageFieldName,
                   selectionFieldName: selectionFieldName, sortFieldName: sortFieldName, sortDirectionFieldName: sortDirectionFieldName)
        {
            if (source != null)
            {
                Bind(source, columnNames);
            }
        }

        // NOTE: WebGrid uses an IEnumerable<dynamic> data source instead of IEnumerable<T> to avoid generics in the syntax.
        internal WebGrid(
            HttpContextBase context,
            string defaultSort = null,
            int rowsPerPage = 10,
            bool canPage = true,
            bool canSort = true,
            string ajaxUpdateContainerId = null,
            string ajaxUpdateCallback = null,
            string fieldNamePrefix = null,
            string pageFieldName = null,
            string selectionFieldName = null,
            string sortFieldName = null,
            string sortDirectionFieldName = null)
        {
            Debug.Assert(context != null);

            if (rowsPerPage < 1)
            {
                throw new ArgumentOutOfRangeException("rowsPerPage", String.Format(CultureInfo.CurrentCulture,
                                                                                   CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 1));
            }

            _context = context;
            _defaultSort = defaultSort;
            _rowsPerPage = rowsPerPage;
            _canPage = canPage;
            _canSort = canSort;
            _ajaxUpdateContainerId = ajaxUpdateContainerId;
            _ajaxUpdateCallback = ajaxUpdateCallback;

            _fieldNamePrefix = fieldNamePrefix;

            if (!String.IsNullOrEmpty(pageFieldName))
            {
                _pageFieldName = pageFieldName;
            }
            if (!String.IsNullOrEmpty(selectionFieldName))
            {
                _selectionFieldName = selectionFieldName;
            }
            if (!String.IsNullOrEmpty(sortFieldName))
            {
                _sortFieldName = sortFieldName;
            }
            if (!String.IsNullOrEmpty(sortDirectionFieldName))
            {
                _sortDirectionFieldName = sortDirectionFieldName;
            }

            CustomSorters = new Dictionary<string, Expression>(StringComparer.OrdinalIgnoreCase);
        }

        public IEnumerable<string> ColumnNames
        {
            get
            {
                // Review: Assuming that the users always binds the source and provides column names / we infer the default columns names on binding
                // Would not work if we want to allow column names to be independently set.
                EnsureDataBound();
                return _columnNames;
            }
        }

        public bool CanSort
        {
            get { return _canSort; }
        }

        public string AjaxUpdateContainerId
        {
            get { return _ajaxUpdateContainerId; }
        }

        public bool IsAjaxEnabled
        {
            get { return !String.IsNullOrEmpty(_ajaxUpdateContainerId); }
        }

        public string AjaxUpdateCallback
        {
            get { return _ajaxUpdateCallback; }
        }

        public string FieldNamePrefix
        {
            get { return _fieldNamePrefix ?? String.Empty; }
        }

        public bool HasSelection
        {
            get { return SelectedIndex >= 0; }
        }

        public int PageCount
        {
            get
            {
                if (!_canPage)
                {
                    return 1;
                }
                return (int)Math.Ceiling((double)TotalRowCount / RowsPerPage);
            }
        }

        public string PageFieldName
        {
            get { return FieldNamePrefix + _pageFieldName; }
        }

        public int PageIndex
        {
            get
            {
                if (!_canPage)
                {
                    //Default page index is 0
                    return 0;
                }
                if (!_pageIndexSet)
                {
                    int page;
                    if (!_canPage || !Int32.TryParse(QueryString[PageFieldName], out page) || (page < 1))
                    {
                        page = 1;
                    }

                    if (_dataSourceBound && page > PageCount)
                    {
                        page = PageCount;
                    }

                    _pageIndex = page - 1;
                    _pageIndexSet = true;
                }
                return _pageIndex;
            }
            set
            {
                if (!_canPage)
                {
                    throw new NotSupportedException(HelpersResources.WebGrid_NotSupportedIfPagingIsDisabled);
                }

                if (!_dataSourceBound)
                {
                    // Allow the user to specify arbitrary non-negative values before data binding
                    if (value < 0)
                    {
                        throw new ArgumentOutOfRangeException("value", String.Format(CultureInfo.CurrentCulture,
                                                                                     CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
                    }
                    else
                    {
                        _pageIndex = value;
                        _pageIndexSet = true;
                    }
                }
                else
                {
                    // Once data bound, perform bounds check on the PageIndex. Also ensure the data source has not been materialized.
                    if ((value < 0) || (value >= PageCount))
                    {
                        throw new ArgumentOutOfRangeException("value", String.Format(CultureInfo.CurrentCulture,
                                                                                     CommonResources.Argument_Must_Be_Between, 0, (PageCount - 1)));
                    }
                    else if (value != _pageIndex)
                    {
                        EnsureDataSourceNotMaterialized();
                        _pageIndex = value;
                        _pageIndexSet = true;
                    }
                }
            }
        }

        public IList<WebGridRow> Rows
        {
            get
            {
                EnsureDataBound();
                if (!_dataSourceMaterialized)
                {
                    _rows = _dataSource.GetRows(SortInfo, PageIndex);
                    _dataSourceMaterialized = true;
                }
                return _rows;
            }
        }

        public int RowsPerPage
        {
            get { return _rowsPerPage; }
        }

        public WebGridRow SelectedRow
        {
            get
            {
                if ((SelectedIndex >= 0) && (SelectedIndex < Rows.Count))
                {
                    return Rows[SelectedIndex];
                }
                return null;
            }
        }

        public int SelectedIndex
        {
            get
            {
                if (!_selectedIndexSet)
                {
                    int row;
                    // Range checking should not use Rows.Count since this will cause paging and sorting.
                    // Review: side effect is that HasSelection will return true if Rows.Count (current page's
                    // row count) is less than both SelectedIndex and RowsPerPage. This scenario should only
                    // happen if someone manually modifies the query string.
                    // If paging isn't enabled, this getter isn't doing a upper bounds check on the value.
                    if ((!Int32.TryParse(QueryString[SelectionFieldName], out row)) || (row < 1) || (_canPage && (row > RowsPerPage)))
                    {
                        row = 0;
                    }
                    _selectedIndex = row - 1;
                    _selectedIndexSet = true;
                }
                return _selectedIndex;
            }
            set
            {
                if (_selectedIndex != value)
                {
                    EnsureDataSourceNotMaterialized();
                    _selectedIndex = value;
                }
                _selectedIndexSet = true;
            }
        }

        public string SelectionFieldName
        {
            get { return FieldNamePrefix + _selectionFieldName; }
        }

        public string SortColumn
        {
            get
            {
                if (!_sortColumnSet)
                {
                    string sortColumn = QueryString[SortFieldName];
                    if (!_dataSourceBound || ValidateSortColumn(sortColumn))
                    {
                        _sortColumn = sortColumn;
                        _sortColumnSet = true;
                    }
                }
                if (String.IsNullOrEmpty(_sortColumn))
                {
                    return _defaultSort ?? String.Empty;
                }
                return _sortColumn;
            }
            set
            {
                EnsureDataBound();
                if (!SortColumn.Equals(value, StringComparison.OrdinalIgnoreCase))
                {
                    EnsureDataSourceNotMaterialized();
                    _sortColumn = value;
                }
                _sortColumnSet = true;
                _sortColumnExplicitlySet = true;
            }
        }

        public SortDirection SortDirection
        {
            get
            {
                if (!_sortDirectionSet)
                {
                    string sortDirection = QueryString[SortDirectionFieldName];
                    if (sortDirection != null)
                    {
                        if (sortDirection.Equals("DESC", StringComparison.OrdinalIgnoreCase) ||
                            sortDirection.Equals("DESCENDING", StringComparison.OrdinalIgnoreCase))
                        {
                            _sortDirection = SortDirection.Descending;
                        }
                    }
                    _sortDirectionSet = true;
                }
                return _sortDirection;
            }
            set
            {
                if (!_dataSourceBound)
                {
                    _sortDirection = value;
                }
                else if (_sortDirection != value)
                {
                    EnsureDataSourceNotMaterialized();
                    _sortDirection = value;
                }
                _sortDirectionSet = true;
            }
        }

        private SortInfo SortInfo
        {
            get { return new SortInfo { SortColumn = SortColumn, SortDirection = SortDirection }; }
        }

        public string SortDirectionFieldName
        {
            get { return FieldNamePrefix + _sortDirectionFieldName; }
        }

        public string SortFieldName
        {
            get { return FieldNamePrefix + _sortFieldName; }
        }

        internal IDictionary<string, Expression> CustomSorters { get; private set; }

        public int TotalRowCount
        {
            get
            {
                EnsureDataBound();
                return _dataSource.TotalRowCount;
            }
        }

        private HttpContextBase HttpContext
        {
            get { return _context; }
        }

        private NameValueCollection QueryString
        {
            get { return HttpContext.Request.QueryString; }
        }

        internal static Type GetElementType(IEnumerable<dynamic> source)
        {
            Debug.Assert(source != null, "source cannot be null");
            Type sourceType = source.GetType();

            if (source.FirstOrDefault() is IDynamicMetaObjectProvider)
            {
                return typeof(IDynamicMetaObjectProvider);
            }
            else if (sourceType.IsArray)
            {
                return sourceType.GetElementType();
            }
            Type elementType = sourceType.GetInterfaces().Select(GetGenericEnumerableType).FirstOrDefault(t => t != null);

            Debug.Assert(elementType != null);
            return elementType;
        }

        private static Type GetGenericEnumerableType(Type type)
        {
            Type enumerableType = typeof(IEnumerable<>);
            if (type.IsGenericType && enumerableType.IsAssignableFrom(type.GetGenericTypeDefinition()))
            {
                return type.GetGenericArguments()[0];
            }
            return null;
        }

        public WebGrid Bind(IEnumerable<dynamic> source, IEnumerable<string> columnNames = null, bool autoSortAndPage = true, int rowCount = -1)
        {
            if (_dataSourceBound)
            {
                throw new InvalidOperationException(HelpersResources.WebGrid_DataSourceBound);
            }
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }
            if (!autoSortAndPage && _canPage && rowCount == -1)
            {
                throw new ArgumentException(HelpersResources.WebGrid_RowCountNotSpecified, "rowCount");
            }

            _elementType = GetElementType(source);
            if (_columnNames == null)
            {
                _columnNames = columnNames ?? GetDefaultColumnNames(source, elementType: _elementType);
            }

            if (!autoSortAndPage)
            {
                _dataSource = new PreComputedGridDataSource(grid: this, values: source, totalRows: rowCount);
            }
            else
            {
                WebGridDataSource dataSource = new WebGridDataSource(grid: this, values: source, elementType: _elementType, canPage: _canPage, canSort: _canSort);
                dataSource.DefaultSort = new SortInfo { SortColumn = _defaultSort, SortDirection = SortDirection.Ascending };
                dataSource.RowsPerPage = _rowsPerPage;
                _dataSource = dataSource;
            }
            _dataSourceBound = true;
            ValidatePreDataBoundValues();
            return this;
        }

        // todo: add templating from file support
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Non-static for syntax, and in case we want to check column existence.")]
        public WebGridColumn Column(string columnName = null, string header = null, Func<dynamic, object> format = null, string style = null,
                                    bool canSort = true)
        {
            if (String.IsNullOrEmpty(columnName))
            {
                if (format == null)
                {
                    throw new ArgumentException(HelpersResources.WebGrid_ColumnNameOrFormatRequired, "columnName");
                }
            }

            return new WebGridColumn { ColumnName = columnName, Header = header, Format = format, Style = style, CanSort = canSort };
        }

        // Should we keep this no-op API for improved WebGrid syntax? Alternatives are:
        // 1. columns: grid.Columns(
        //        grid.Column(...), grid.Column(...)
        //    )
        // 2. columns: new[] {
        //        grid.Column(...), grid.Column(...)
        //    }
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Review: No-op API for syntax simplification?")]
        public WebGridColumn[] Columns(params WebGridColumn[] columnSet)
        {
            return columnSet;
        }

        public IHtmlString GetContainerUpdateScript(string path)
        {
            var script = String.Format(CultureInfo.InvariantCulture, AjaxUpdateScript,
                                       HttpUtility.JavaScriptStringEncode(path, addDoubleQuotes: true),
                                       HttpUtility.JavaScriptStringEncode('#' + AjaxUpdateContainerId, addDoubleQuotes: true),
                                       !String.IsNullOrEmpty(AjaxUpdateCallback) ? ',' + HttpUtility.JavaScriptStringEncode(AjaxUpdateCallback) : String.Empty);

            return new HtmlString(HttpUtility.HtmlAttributeEncode(script));
        }

        /// <summary>
        /// Gets the HTML for a table with a pager.
        /// </summary>
        /// <param name="tableStyle">Table class for styling.</param>
        /// <param name="headerStyle">Header row class for styling.</param>
        /// <param name="footerStyle">Footer row class for styling.</param>
        /// <param name="rowStyle">Row class for styling (odd rows only).</param>
        /// <param name="alternatingRowStyle">Row class for styling (even rows only).</param>
        /// <param name="selectedRowStyle">Selected row class for styling.</param>
        /// <param name="displayHeader">Whether the header row should be displayed.</param>
        /// <param name="caption">The string displayed as the table caption</param>
        /// <param name="fillEmptyRows">Whether the table can add empty rows to ensure the rowsPerPage row count.</param>
        /// <param name="emptyRowCellValue">Value used to populate empty rows. This property is only used when <paramref name="fillEmptyRows"/> is set</param>
        /// <param name="columns">Column model for customizing column rendering.</param>
        /// <param name="exclusions">Columns to exclude when auto-populating columns.</param>
        /// <param name="mode">Modes for pager rendering.</param>
        /// <param name="firstText">Text for link to first page.</param>
        /// <param name="previousText">Text for link to previous page.</param>
        /// <param name="nextText">Text for link to next page.</param>
        /// <param name="lastText">Text for link to last page.</param>
        /// <param name="numericLinksCount">Number of numeric links that should display.</param>
        /// <param name="htmlAttributes">An object that contains the HTML attributes to set for the element.</param>
        public IHtmlString GetHtml(
            string tableStyle = null,
            string headerStyle = null,
            string footerStyle = null,
            string rowStyle = null,
            string alternatingRowStyle = null,
            string selectedRowStyle = null,
            string caption = null,
            bool displayHeader = true,
            bool fillEmptyRows = false,
            string emptyRowCellValue = null,
            IEnumerable<WebGridColumn> columns = null,
            IEnumerable<string> exclusions = null,
            WebGridPagerModes mode = WebGridPagerModes.NextPrevious | WebGridPagerModes.Numeric,
            string firstText = null,
            string previousText = null,
            string nextText = null,
            string lastText = null,
            int numericLinksCount = 5,
            object htmlAttributes = null)
        {
            Func<dynamic, object> footer = null;
            if (_canPage && (PageCount > 1))
            {
                footer = item => Pager(mode, firstText, previousText, nextText, lastText, numericLinksCount, explicitlyCalled: false);
            }

            return Table(tableStyle, headerStyle, footerStyle, rowStyle, alternatingRowStyle, selectedRowStyle, caption, displayHeader,
                         fillEmptyRows, emptyRowCellValue, columns, exclusions, footer: footer,
                         htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "Strings are easier for Plan9 developer to work with")]
        public string GetPageUrl(int pageIndex)
        {
            if (!_canPage)
            {
                throw new NotSupportedException(HelpersResources.WebGrid_NotSupportedIfPagingIsDisabled);
            }
            if ((pageIndex < 0) || (pageIndex >= PageCount))
            {
                throw new ArgumentOutOfRangeException("pageIndex", String.Format(CultureInfo.CurrentCulture,
                                                                                 CommonResources.Argument_Must_Be_Between, 0, (PageCount - 1)));
            }

            NameValueCollection queryString = new NameValueCollection(1);
            queryString[PageFieldName] = (pageIndex + 1L).ToString(CultureInfo.CurrentCulture);
            return GetPath(queryString, SelectionFieldName);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "Strings are easier for Plan9 developer to work with")]
        public string GetSortUrl(string column)
        {
            if (!_canSort)
            {
                throw new NotSupportedException(HelpersResources.WebGrid_NotSupportedIfSortingIsDisabled);
            }
            if (String.IsNullOrEmpty(column))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "column");
            }

            var sort = SortColumn;
            var sortDir = SortDirection.Ascending;
            if (column.Equals(sort, StringComparison.OrdinalIgnoreCase))
            {
                if (SortDirection == SortDirection.Ascending)
                {
                    sortDir = SortDirection.Descending;
                }
            }

            NameValueCollection queryString = new NameValueCollection(2);
            queryString[SortFieldName] = column;
            queryString[SortDirectionFieldName] = GetSortDirectionString(sortDir);
            return GetPath(queryString, PageFieldName, SelectionFieldName);
        }

        /// <summary>
        /// Gets the HTML for a pager.
        /// </summary>
        /// <param name="mode">Modes for pager rendering.</param>
        /// <param name="firstText">Text for link to first page.</param>
        /// <param name="previousText">Text for link to previous page.</param>
        /// <param name="nextText">Text for link to next page.</param>
        /// <param name="lastText">Text for link to last page.</param>
        /// <param name="numericLinksCount">Number of numeric links that should display.</param>
        public HelperResult Pager(
            WebGridPagerModes mode = WebGridPagerModes.NextPrevious | WebGridPagerModes.Numeric,
            string firstText = null,
            string previousText = null,
            string nextText = null,
            string lastText = null,
            int numericLinksCount = 5)
        {
            return Pager(mode, firstText, previousText, nextText, lastText, numericLinksCount, explicitlyCalled: true);
        }

        /// <param name="mode">Modes for pager rendering.</param>
        /// <param name="firstText">Text for link to first page.</param>
        /// <param name="previousText">Text for link to previous page.</param>
        /// <param name="nextText">Text for link to next page.</param>
        /// <param name="lastText">Text for link to last page.</param>
        /// <param name="numericLinksCount">Number of numeric links that should display.</param>
        /// <param name="explicitlyCalled">The Pager can be explicitly called by the public API or is called by the WebGrid when no footer is provided.
        /// In the explicit scenario, we would need to render a container for the pager to allow identifying the pager links.
        /// In the implicit scenario, the grid table would be the container.
        /// </param>
        private HelperResult Pager(
            WebGridPagerModes mode,
            string firstText,
            string previousText,
            string nextText,
            string lastText,
            int numericLinksCount,
            bool explicitlyCalled)
        {
            if (!_canPage)
            {
                throw new NotSupportedException(HelpersResources.WebGrid_NotSupportedIfPagingIsDisabled);
            }
            if (!ModeEnabled(mode, WebGridPagerModes.FirstLast) && (firstText != null))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          HelpersResources.WebGrid_PagerModeMustBeEnabled, "FirstLast"), "firstText");
            }
            if (!ModeEnabled(mode, WebGridPagerModes.NextPrevious) && (previousText != null))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          HelpersResources.WebGrid_PagerModeMustBeEnabled, "NextPrevious"), "previousText");
            }
            if (!ModeEnabled(mode, WebGridPagerModes.NextPrevious) && (nextText != null))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          HelpersResources.WebGrid_PagerModeMustBeEnabled, "NextPrevious"), "nextText");
            }
            if (!ModeEnabled(mode, WebGridPagerModes.FirstLast) && (lastText != null))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          HelpersResources.WebGrid_PagerModeMustBeEnabled, "FirstLast"), "lastText");
            }
            if (numericLinksCount < 0)
            {
                throw new ArgumentOutOfRangeException("numericLinksCount",
                                                      String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }

            return WebGridRenderer.Pager(this, HttpContext, mode: mode, firstText: firstText, previousText: previousText, nextText: nextText, lastText: lastText,
                                         numericLinksCount: numericLinksCount, renderAjaxContainer: explicitlyCalled);
        }

        /// <summary>
        /// Gets the HTML for a table with a pager.
        /// </summary>
        /// <param name="tableStyle">Table class for styling.</param>
        /// <param name="headerStyle">Header row class for styling.</param>
        /// <param name="footerStyle">Footer row class for styling.</param>
        /// <param name="rowStyle">Row class for styling (odd rows only).</param>
        /// <param name="alternatingRowStyle">Row class for styling (even rows only).</param>
        /// <param name="selectedRowStyle">Selected row class for styling.</param>
        /// <param name="caption">The table caption</param>
        /// <param name="displayHeader">Whether the header row should be displayed.</param>
        /// <param name="fillEmptyRows">Whether the table can add empty rows to ensure the rowsPerPage row count.</param>
        /// <param name="emptyRowCellValue">Value used to populate empty rows. This property is only used when <paramref name="fillEmptyRows"/> is set</param>
        /// <param name="columns">Column model for customizing column rendering.</param>
        /// <param name="exclusions">Columns to exclude when auto-populating columns.</param>
        /// <param name="footer">Table footer template.</param>
        /// <param name="htmlAttributes">An object that contains the HTML attributes to set for the element.</param>
        public IHtmlString Table(
            string tableStyle = null,
            string headerStyle = null,
            string footerStyle = null,
            string rowStyle = null,
            string alternatingRowStyle = null,
            string selectedRowStyle = null,
            string caption = null,
            bool displayHeader = true,
            bool fillEmptyRows = false,
            string emptyRowCellValue = null,
            IEnumerable<WebGridColumn> columns = null,
            IEnumerable<string> exclusions = null,
            Func<dynamic, object> footer = null,
            object htmlAttributes = null)
        {
            if (columns == null)
            {
                columns = GetDefaultColumns(exclusions);
            }
            // In order of precedence, the parameters that affect the visibility of columns in WebGrid - 
            // (1) "columns" argument of this method 
            // (2) "exclusion" argument of this method 
            // (3) "columnNames" argument of the constructor. 
            // At the time of binding we can verify if a simple property specified in the query string is a column that would be visible to the user. 
            // However, for complex properties or if either of (1) or (2) arguments are specified, we can only verify at this point. 
            EnsureColumnIsSortable(columns);

            if (emptyRowCellValue == null)
            {
                emptyRowCellValue = "&nbsp;";
            }

            return WebGridRenderer.Table(this, HttpContext, tableStyle: tableStyle, headerStyle: headerStyle, footerStyle: footerStyle, rowStyle: rowStyle,
                                         alternatingRowStyle: alternatingRowStyle, selectedRowStyle: selectedRowStyle, caption: caption, displayHeader: displayHeader, fillEmptyRows: fillEmptyRows,
                                         emptyRowCellValue: emptyRowCellValue, columns: columns, exclusions: exclusions, footer: footer, htmlAttributes: htmlAttributes);
        }

        /// <summary>
        /// Adds a specific sort function for a given column.
        /// </summary>
        /// <typeparam name="TElement">The type of elements in the grid's source.</typeparam>
        /// <typeparam name="TProperty">The column type, usually inferred from the keySelector function's return type.</typeparam>
        /// <param name="columnName">The column name (as used for sorting)</param>
        /// <param name="keySelector">The function used to select a key to sort by, for each element in the grid's source.</param>
        /// <returns>The current grid, with the new custom sorter applied.</returns>
        /// <example>
        /// <code>
        /// var grid = new WebGrid(items)
        ///     .AddSorter("Manager.Name", (Employee x) => (x == null || x.Manager == null) ? null : x.Manager.Name);
        /// </code>
        /// </example>
        [SuppressMessage("Microsoft.Design", "CA1006", Justification = "This design make sense, and is a reasonable user experience for users of the helpers")]
        public WebGrid AddSorter<TElement, TProperty>(string columnName, Expression<Func<TElement, TProperty>> keySelector)
        {
            CustomSorters[columnName] = keySelector;
            return this;
        }

        /// <param name="columns">The set of columns that are rendered to the client.</param>
        private void EnsureColumnIsSortable(IEnumerable<WebGridColumn> columns)
        {
            // Fix for bug 941102
            // The ValidateSortColumn can validate a few regular cases for sorting and reset those values to default. However, for sort columns that are complex expressions,
            // or if the user specifies a subset of columns in the GetHtml method (via columns / exclusions), the method is ineffective. 
            // Review: Should this method not throw if the data was not explicitly sorted and paged by the user
            if (_canSort && !_sortColumnExplicitlySet && !String.IsNullOrEmpty(SortColumn) && !StringComparer.OrdinalIgnoreCase.Equals(_defaultSort, SortColumn)
                && !columns.Select(c => c.ColumnName).Contains(SortColumn, StringComparer.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, HelpersResources.WebGrid_ColumnNotFound, SortColumn));
            }
        }

        internal static dynamic GetMember(WebGridRow row, string name)
        {
            object result;
            if (row.TryGetMember(name, out result))
            {
                return result;
            }
            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                              HelpersResources.WebGrid_ColumnNotFound, name));
        }

        // review: make sure this is ordered
        internal string GetPath(NameValueCollection queryString, params string[] exclusions)
        {
            NameValueCollection temp = new NameValueCollection(QueryString);
            // update current query string in case values were set programmatically
            if (temp.AllKeys.Contains(PageFieldName))
            {
                temp.Set(PageFieldName, (PageIndex + 1L).ToString(CultureInfo.CurrentCulture));
            }
            if (temp.AllKeys.Contains(SelectionFieldName))
            {
                if (SelectedIndex < 0)
                {
                    temp.Remove(SelectionFieldName);
                }
                else
                {
                    temp.Set(SelectionFieldName, (SelectedIndex + 1L).ToString(CultureInfo.CurrentCulture));
                }
            }
            if (temp.AllKeys.Contains(SortFieldName))
            {
                if (String.IsNullOrEmpty(SortColumn))
                {
                    temp.Remove(SortFieldName);
                }
                else
                {
                    temp.Set(SortFieldName, SortColumn);
                }
            }
            if (temp.AllKeys.Contains(SortDirectionFieldName))
            {
                temp.Set(SortDirectionFieldName, GetSortDirectionString(SortDirection));
            }

            // remove fields from exclusions list
            foreach (var key in exclusions)
            {
                temp.Remove(key);
            }
            // replace with new field values
            foreach (string key in queryString.Keys)
            {
                temp.Set(key, queryString[key]);
            }
            queryString = temp;

            StringBuilder sb = new StringBuilder(HttpContext.Request.Path);

            sb.Append("?");
            for (int i = 0; i < queryString.Count; i++)
            {
                if (i > 0)
                {
                    sb.Append("&");
                }
                sb.Append(HttpUtility.UrlEncode(queryString.Keys[i]));
                sb.Append("=");
                sb.Append(HttpUtility.UrlEncode(queryString[i]));
            }
            return sb.ToString();
        }

        internal static string GetSortDirectionString(SortDirection sortDir)
        {
            return (sortDir == SortDirection.Ascending) ? "ASC" : "DESC";
        }

        private void EnsureDataBound()
        {
            if (!_dataSourceBound)
            {
                throw new InvalidOperationException(HelpersResources.WebGrid_NoDataSourceBound);
            }
        }

        private void EnsureDataSourceNotMaterialized()
        {
            if (_dataSourceMaterialized)
            {
                throw new InvalidOperationException(HelpersResources.WebGrid_PropertySetterNotSupportedAfterDataBound);
            }
        }

        private void ValidatePreDataBoundValues()
        {
            if (_canPage && _pageIndexSet && PageIndex > PageCount)
            {
                PageIndex = PageCount;
            }
            else if (_canSort && _sortColumnSet && !ValidateSortColumn(SortColumn))
            {
                SortColumn = _defaultSort;
            }
        }

        private bool ValidateSortColumn(string value)
        {
            Debug.Assert(ColumnNames != null);

            // Navigation columns that contain '.' will be validated during the Sort operation
            // Validate other properties up-front and ignore any bad columns passed via the query string
            return _sortColumnExplicitlySet
                   || String.IsNullOrEmpty(value)
                   || StringComparer.OrdinalIgnoreCase.Equals(_defaultSort, value)
                   || ColumnNames.Contains(value, StringComparer.OrdinalIgnoreCase)
                   || value.Contains('.');
        }

        private static IEnumerable<string> GetDefaultColumnNames(IEnumerable<dynamic> source, Type elementType)
        {
            var dynObj = source.FirstOrDefault() as IDynamicMetaObjectProvider;
            if (dynObj != null)
            {
                return DynamicHelper.GetMemberNames(dynObj);
            }
            else
            {
                return (from p in elementType.GetProperties()
                        where IsBindableType(p.PropertyType) && (p.GetIndexParameters().Length == 0)
                        select p.Name).OrderBy(n => n, StringComparer.OrdinalIgnoreCase).ToArray();
            }
        }

        private IEnumerable<WebGridColumn> GetDefaultColumns(IEnumerable<string> exclusions)
        {
            IEnumerable<string> names = ColumnNames;
            if (exclusions != null)
            {
                names = names.Except(exclusions);
            }
            return (from n in names
                    select new WebGridColumn { ColumnName = n, CanSort = true }).ToArray();
        }

        // see: DataBoundControlHelper.IsBindableType
        private static bool IsBindableType(Type type)
        {
            Debug.Assert(type != null);

            Type underlyingType = Nullable.GetUnderlyingType(type);
            if (underlyingType != null)
            {
                type = underlyingType;
            }
            return (type.IsPrimitive ||
                    type.Equals(typeof(string)) ||
                    type.Equals(typeof(DateTime)) ||
                    type.Equals(typeof(Decimal)) ||
                    type.Equals(typeof(Guid)) ||
                    type.Equals(typeof(DateTimeOffset)) ||
                    type.Equals(typeof(TimeSpan)));
        }

        private static bool ModeEnabled(WebGridPagerModes mode, WebGridPagerModes modeCheck)
        {
            return (mode & modeCheck) == modeCheck;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/WebGridColumn.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers
{
    public class WebGridColumn
    {
        public bool CanSort { get; set; }

        public string ColumnName { get; set; }

        public Func<dynamic, object> Format { get; set; }

        public string Header { get; set; }

        public string Style { get; set; }
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/WebGridDataSource.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using Microsoft.CSharp.RuntimeBinder;
using Binder = Microsoft.CSharp.RuntimeBinder.Binder;

namespace System.Web.Helpers
{
    /// <summary>
    /// Default data source that sorts results if a sort column is specified.
    /// </summary>
    internal sealed class WebGridDataSource : IWebGridDataSource
    {
        private static readonly MethodInfo SortGenericExpressionMethod = typeof(WebGridDataSource).GetMethod("SortGenericExpression", BindingFlags.Static | BindingFlags.NonPublic);

        private readonly WebGrid _grid;
        private readonly Type _elementType;
        private readonly IEnumerable<dynamic> _values;
        private readonly bool _canPage;
        private readonly bool _canSort;

        public WebGridDataSource(WebGrid grid, IEnumerable<dynamic> values, Type elementType, bool canPage, bool canSort)
        {
            Debug.Assert(grid != null);
            Debug.Assert(values != null);

            _grid = grid;
            _values = values;
            _elementType = elementType;
            _canPage = canPage;
            _canSort = canSort;
        }

        public SortInfo DefaultSort { get; set; }

        public int RowsPerPage { get; set; }

        public int TotalRowCount
        {
            get { return _values.Count(); }
        }

        public IList<WebGridRow> GetRows(SortInfo sortInfo, int pageIndex)
        {
            IEnumerable<dynamic> rowData = _values;

            if (_canSort)
            {
                rowData = Sort(_values.AsQueryable(), sortInfo);
            }

            rowData = Page(rowData, pageIndex);

            try
            {
                // Force compile the underlying IQueryable
                rowData = rowData.ToList();
            }
            catch (ArgumentException)
            {
                // The OrderBy method uses a generic comparer which fails when the collection contains 2 or more 
                // items that cannot be compared (e.g. DBNulls, mixed types such as strings and ints et al) with the exception
                // System.ArgumentException: At least one object must implement IComparable.
                // Silently fail if this exception occurs and declare that the two items are equivalent
                rowData = Page(_values.AsQueryable(), pageIndex);
            }
            return rowData.Select((value, index) => new WebGridRow(_grid, value: value, rowIndex: index)).ToList();
        }

        private IQueryable<dynamic> Sort(IQueryable<dynamic> data, SortInfo sortInfo)
        {
            if (!String.IsNullOrEmpty(sortInfo.SortColumn) || ((DefaultSort != null) && !String.IsNullOrEmpty(DefaultSort.SortColumn)))
            {
                return Sort(data, _elementType, sortInfo);
            }
            return data;
        }

        private IEnumerable<dynamic> Page(IEnumerable<dynamic> data, int pageIndex)
        {
            if (_canPage)
            {
                Debug.Assert(RowsPerPage > 0);
                return data.Skip(pageIndex * RowsPerPage).Take(RowsPerPage);
            }
            return data;
        }

        private IQueryable<dynamic> Sort(IQueryable<dynamic> data, Type elementType, SortInfo sort)
        {
            Debug.Assert(data != null);

            if (typeof(IDynamicMetaObjectProvider).IsAssignableFrom(elementType))
            {
                // IDynamicMetaObjectProvider properties are only available through a runtime binder, so we
                // must build a custom LINQ expression for getting the dynamic property value.
                // Lambda: o => o.Property (where Property is obtained by runtime binder)
                // NOTE: lambda must not use internals otherwise this will fail in partial trust when Helpers assembly is in GAC
                var binder = Binder.GetMember(CSharpBinderFlags.None, sort.SortColumn, typeof(WebGrid), new[]
                {
                    CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null)
                });
                var param = Expression.Parameter(typeof(IDynamicMetaObjectProvider), "o");
                var getter = Expression.Dynamic(binder, typeof(object), param);
                return SortGenericExpression<IDynamicMetaObjectProvider, object>(data, getter, param, sort.SortDirection);
            }

            Expression sorterFunctionBody;
            ParameterExpression sorterFunctionParameter;

            Expression sorter;
            if (_grid.CustomSorters.TryGetValue(sort.SortColumn, out sorter))
            {
                var lambda = sorter as LambdaExpression;
                Debug.Assert(lambda != null);

                sorterFunctionBody = lambda.Body;
                sorterFunctionParameter = lambda.Parameters[0];
            }
            else
            {
                // The IQueryable<dynamic> data source is cast as IQueryable<object> at runtime. We must call
                // SortGenericExpression using reflection so that the LINQ expressions use the actual element type.
                // Lambda: o => o.Property[.NavigationProperty,etc]
                sorterFunctionParameter = Expression.Parameter(elementType, "o");
                Expression member = sorterFunctionParameter;
                var type = elementType;
                var sorts = sort.SortColumn.Split('.');
                foreach (var name in sorts)
                {
                    PropertyInfo prop = type.GetProperty(name);
                    if (prop == null)
                    {
                        // no-op in case navigation property came from querystring (falls back to default sort)
                        if ((DefaultSort != null) && !sort.Equals(DefaultSort) && !String.IsNullOrEmpty(DefaultSort.SortColumn))
                        {
                            return Sort(data, elementType, DefaultSort);
                        }
                        return data;
                    }
                    member = Expression.Property(member, prop);
                    type = prop.PropertyType;
                }
                sorterFunctionBody = member;
            }

            var actualSortMethod = SortGenericExpressionMethod.MakeGenericMethod(elementType, sorterFunctionBody.Type);
            return (IQueryable<dynamic>)actualSortMethod.Invoke(null, new object[] { data, sorterFunctionBody, sorterFunctionParameter, sort.SortDirection });
        }

        private static IQueryable<TElement> SortGenericExpression<TElement, TProperty>(IQueryable<dynamic> data, Expression body,
                                                                                       ParameterExpression param, SortDirection sortDirection)
        {
            Debug.Assert(data != null);
            Debug.Assert(body != null);
            Debug.Assert(param != null);

            // The IQueryable<dynamic> data source is cast as an IQueryable<object> at runtime.  We must cast
            // this to an IQueryable<TElement> so that the reflection done by the LINQ expressions will work.
            IQueryable<TElement> data2 = data.Cast<TElement>();
            Expression<Func<TElement, TProperty>> lambda = Expression.Lambda<Func<TElement, TProperty>>(body, param);
            if (sortDirection == SortDirection.Descending)
            {
                return data2.OrderByDescending(lambda);
            }
            else
            {
                return data2.OrderBy(lambda);
            }
        }
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/WebGridPagerModes.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers
{
    [Flags]
    public enum WebGridPagerModes
    {
        Numeric = 0x1,
        NextPrevious = 0x2,
        FirstLast = 0x4,
        All = 0x7
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/WebGridRow.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Helpers.Resources;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "Collection is not an appropriate suffix for this class")]
    public class WebGridRow : DynamicObject, IEnumerable<object>
    {
        private const string RowIndexMemberName = "ROW";
        private const BindingFlags BindFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static | BindingFlags.IgnoreCase;

        private WebGrid _grid;
        private IDynamicMetaObjectProvider _dynamic;
        private int _rowIndex;
        private object _value;
        private IEnumerable<dynamic> _values;

        public WebGridRow(WebGrid webGrid, object value, int rowIndex)
        {
            _grid = webGrid;
            _value = value;
            _rowIndex = rowIndex;
            _dynamic = value as IDynamicMetaObjectProvider;
        }

        public dynamic Value
        {
            get { return _value; }
        }

        public WebGrid WebGrid
        {
            get { return _grid; }
        }

        public object this[string name]
        {
            get
            {
                if (String.IsNullOrEmpty(name))
                {
                    throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
                }
                object value = null;
                if (!TryGetMember(name, out value))
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                      HelpersResources.WebGrid_ColumnNotFound, name));
                }
                return value;
            }
        }

        public object this[int index]
        {
            get
            {
                if ((index < 0) || (index >= _grid.ColumnNames.Count()))
                {
                    throw new ArgumentOutOfRangeException("index");
                }
                return this.Skip(index).First();
            }
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public IEnumerator<object> GetEnumerator()
        {
            if (_values == null)
            {
                _values = _grid.ColumnNames.Select(c => WebGrid.GetMember(this, c));
            }
            return _values.GetEnumerator();
        }

        public IHtmlString GetSelectLink(string text = null)
        {
            if (String.IsNullOrEmpty(text))
            {
                text = HelpersResources.WebGrid_SelectLinkText;
            }
            return WebGridRenderer.GridLink(_grid, GetSelectUrl(), text);
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "review: I think a method is more appropriate here")]
        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "Strings are easier for Plan9 developer to work with")]
        public string GetSelectUrl()
        {
            NameValueCollection queryString = new NameValueCollection(1);
            queryString[WebGrid.SelectionFieldName] = (_rowIndex + 1L).ToString(CultureInfo.CurrentCulture);
            return WebGrid.GetPath(queryString);
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            result = null;
            // Try to get the row index
            if (TryGetRowIndex(binder.Name, out result))
            {
                return true;
            }

            // Try to evaluate the dynamic member based on the binder
            if (_dynamic != null && DynamicHelper.TryGetMemberValue(_dynamic, binder, out result))
            {
                return true;
            }

            return TryGetComplexMember(_value, binder.Name, out result);
        }

        internal bool TryGetMember(string memberName, out object result)
        {
            result = null;

            // Try to get the row index
            if (TryGetRowIndex(memberName, out result))
            {
                return true;
            }

            // Try to evaluate the dynamic member based on the name
            if (_dynamic != null && DynamicHelper.TryGetMemberValue(_dynamic, memberName, out result))
            {
                return true;
            }

            // Support '.' for navigation properties
            return TryGetComplexMember(_value, memberName, out result);
        }

        public override string ToString()
        {
            return _value.ToString();
        }

        private bool TryGetRowIndex(string memberName, out object result)
        {
            result = null;
            if (String.IsNullOrEmpty(memberName))
            {
                return false;
            }

            if (memberName == RowIndexMemberName)
            {
                result = _rowIndex;
                return true;
            }

            return false;
        }

        private static bool TryGetComplexMember(object obj, string name, out object result)
        {
            result = null;

            string[] names = name.Split('.');
            for (int i = 0; i < names.Length; i++)
            {
                if ((obj == null) || !TryGetMember(obj, names[i], out result))
                {
                    result = null;
                    return false;
                }
                obj = result;
            }
            return true;
        }

        private static bool TryGetMember(object obj, string name, out object result)
        {
            PropertyInfo property = obj.GetType().GetProperty(name, BindFlags);
            if ((property != null) && (property.GetIndexParameters().Length == 0))
            {
                result = property.GetValue(obj, null);
                return true;
            }
            result = null;
            return false;
        }
    }
}


================================================
FILE: src/System.Web.Helpers/WebGrid/_WebGridRenderer.cshtml
================================================
@using System.Globalization 
@using System.Text 
@using System.Web.Helpers.Resources
@using System.Web.Mvc 
@using System.Web.WebPages.Html 
@using System.Web.WebPages.Scope 
@using Microsoft.Internal.Web.Utils

@helper GridInitScript(WebGrid webGrid, HttpContextBase httpContext) { 
    if (!webGrid.IsAjaxEnabled) {
        return;
    } 
    if (!IsGridScriptRendered(httpContext)) { 
        SetGridScriptRendered(httpContext, true);
        <script type="text/javascript">
        (function($) {
            $.fn.swhgLoad = function(url, containerId, callback) {
                url = url + (url.indexOf('?') == -1 ? '?' : '&') + '__swhg=' + new Date().getTime();

                $('<div/>').load(url + ' ' + containerId, function(data, status, xhr) {
                    $(containerId).replaceWith($(this).html());
                    if (typeof(callback) === 'function') {
                        callback.apply(this, arguments);
                    }
                });
                return this;
            }

            $(function() {
                $('table[data-swhgajax="true"],span[data-swhgajax="true"]').each(function() {
                    var self = $(this);
                    var containerId = '#' + self.data('swhgcontainer');
                    var callback = getFunction(self.data('swhgcallback'));

                    $(containerId).parent().delegate(containerId + ' a[data-swhglnk="true"]', 'click', function() {
                        $(containerId).swhgLoad($(this).attr('href'), containerId, callback);
                        return false;
                    });
                })
            });

            function getFunction(code, argNames) {
                argNames = argNames || [];
                var fn = window, parts = (code || "").split(".");
                while (fn && parts.length) {
                    fn = fn[parts.shift()];
                }
                if (typeof (fn) === "function") {
                    return fn;
                }
                argNames.push(code);
                return Function.constructor.apply(null, argNames);
            }
        })(jQuery);
        </script>
    } 
} 

@helper Table(WebGrid webGrid, 
        HttpContextBase httpContext, 
        string tableStyle, 
        string headerStyle, 
        string footerStyle, 
        string rowStyle, 
        string alternatingRowStyle, 
        string selectedRowStyle,
        string caption, 
        bool displayHeader, 
        bool fillEmptyRows, 
        string emptyRowCellValue,
        IEnumerable<WebGridColumn> columns,
        IEnumerable<string> exclusions,
        Func<dynamic, object> footer,
        object htmlAttributes) {
    
    if (emptyRowCellValue == null) {
        emptyRowCellValue = "&nbsp;";
    }

    @GridInitScript(webGrid, httpContext) 

    var htmlAttributeDictionary = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
    if (webGrid.IsAjaxEnabled) {
        htmlAttributeDictionary["data-swhgajax"] = "true";
        htmlAttributeDictionary["data-swhgcontainer"] = webGrid.AjaxUpdateContainerId;
        htmlAttributeDictionary["data-swhgcallback"] = webGrid.AjaxUpdateCallback;
    }

    <table@(tableStyle.IsEmpty() ? null : Raw(" class=\"" + HttpUtility.HtmlAttributeEncode(tableStyle) + "\""))@PrintAttributes(htmlAttributeDictionary)>
    @if (!caption.IsEmpty()) {
        <caption>@caption</caption>
    }
    @if (displayHeader) {
    <thead>
        <tr@CssClass(headerStyle)>
        @foreach (var column in columns) {
            <th scope="col">
            @if (ShowSortableColumnHeader(webGrid, column)) {
                var text = column.Header.IsEmpty() ? column.ColumnName : column.Header;
                @GridLink(webGrid, webGrid.GetSortUrl(column.ColumnName), text)
            }
            else {
                @(column.Header ?? column.ColumnName)
            }
            </th>
        }
        </tr>
    </thead>
    }
    @if (footer != null) {
    <tfoot>
        <tr @CssClass(footerStyle)>
            <td colspan="@columns.Count()">@Format(footer, null)</td>
        </tr>
    </tfoot>
    }
    <tbody>
    @{
        int rowIndex = 0;
    }
    @foreach (var row in webGrid.Rows) {
        string style = GetRowStyle(webGrid, rowIndex++, rowStyle, alternatingRowStyle, selectedRowStyle);
        <tr@CssClass(style)>
        @foreach (var column in columns) {
            var value = (column.Format == null) ? HttpUtility.HtmlEncode(row[column.ColumnName]) : Format(column.Format, row).ToString();
            <td@CssClass(column.Style)>@Raw(value)</td>
        }
        </tr>
    }
    @if (fillEmptyRows) {
        rowIndex = webGrid.Rows.Count;
        while (rowIndex < webGrid.RowsPerPage) {
            string style = GetRowStyle(webGrid, rowIndex++, rowStyle, alternatingRowStyle, null);
            <tr@CssClass(style)>
                @foreach (var column in columns) {
                    <td@CssClass(column.Style)>@Raw(emptyRowCellValue)</td>
                }
            </tr>
        }
    }
    </tbody>
    </table>
}


@helper Pager(
        WebGrid webGrid,
        HttpContextBase httpContext,
        WebGridPagerModes mode,
        string firstText,
        string previousText,
        string nextText,
        string lastText,
        int numericLinksCount,
        bool renderAjaxContainer) {

    int currentPage = webGrid.PageIndex;
    int totalPages = webGrid.PageCount;
    int lastPage = totalPages - 1;

    @GridInitScript(webGrid, httpContext) 
    
    if (renderAjaxContainer && webGrid.IsAjaxEnabled) {
        @:<span data-swhgajax="true" data-swhgcontainer="@webGrid.AjaxUpdateContainerId" data-swhgcallback="@webGrid.AjaxUpdateCallback">
    }

    if (ModeEnabled(mode, WebGridPagerModes.FirstLast) && currentPage > 1) {
        if (String.IsNullOrEmpty(firstText)) {
            firstText = "<<";
        }
        @GridLink(webGrid, webGrid.GetPageUrl(0), firstText)
        @Raw(" ")
    }
  
    if (ModeEnabled(mode, WebGridPagerModes.NextPrevious) && currentPage > 0) {
        if (String.IsNullOrEmpty(previousText)) {
            previousText = "<";
        }
        @GridLink(webGrid, webGrid.GetPageUrl(currentPage - 1), previousText)
        @Raw(" ")
    }

    if (ModeEnabled(mode, WebGridPagerModes.Numeric) && (totalPages > 1)) {
        int last = currentPage + (numericLinksCount / 2);
        int first = last - numericLinksCount + 1;
        if (last > lastPage) {
            first -= last - lastPage;
            last = lastPage;
        }
        if (first < 0) {
            last = Math.Min(last + (0 - first), lastPage);
            first = 0;
        }
        for (int i = first; i <= last; i++) {
            var pageText = (i + 1).ToString(CultureInfo.InvariantCulture);
            if (i == currentPage) {
              <span>@pageText</span>
            }
            else {
              @GridLink(webGrid, webGrid.GetPageUrl(i), pageText)
            }
            @Raw(" ")
        }
    }

    if (ModeEnabled(mode, WebGridPagerModes.NextPrevious) && (currentPage < lastPage)) {
        if (String.IsNullOrEmpty(nextText)) {
          nextText = ">";
        }
        @GridLink(webGrid, webGrid.GetPageUrl(currentPage + 1), nextText)
        @Raw(" ")
    }
    
    if (ModeEnabled(mode, WebGridPagerModes.FirstLast) && (currentPage < lastPage - 1)) {
        if (String.IsNullOrEmpty(lastText)) {
          lastText = ">>";
        }
        @GridLink(webGrid, webGrid.GetPageUrl(lastPage), lastText)
    }
    
    if (renderAjaxContainer && webGrid.IsAjaxEnabled) {
        @:</span>
    }
}

@functions{
    private static readonly object _gridScriptRenderedKey = new object();

    private static bool IsGridScriptRendered(HttpContextBase context) {
        bool? value = (bool?)context.Items[_gridScriptRenderedKey];
        return value.HasValue && value.Value;
    }

    private static void SetGridScriptRendered(HttpContextBase context, bool value) {
        context.Items[_gridScriptRenderedKey] = value;
    }

    private static bool ShowSortableColumnHeader(WebGrid grid, WebGridColumn column) {
        return grid.CanSort && column.CanSort && !column.ColumnName.IsEmpty();
    }

    public static IHtmlString GridLink(WebGrid webGrid, string url, string text) {
        TagBuilder builder = new TagBuilder("a");
        builder.SetInnerText(text);
        builder.MergeAttribute("href", url);
        if (webGrid.IsAjaxEnabled) {
            builder.MergeAttribute("data-swhglnk", "true");
        }
        return builder.ToHtmlString(TagRenderMode.Normal);
    }

    private static IHtmlString Raw(string text) {
        return new HtmlString(text);
    }

    private static IHtmlString RawJS(string text) {
        return new HtmlString(HttpUtility.JavaScriptStringEncode(text));
    }

    private static IHtmlString CssClass(string className) {
        return new HtmlString((!className.IsEmpty()) ? " class=\"" + HttpUtility.HtmlAttributeEncode(className) + "\"" : String.Empty);
    }

    private static string GetRowStyle(WebGrid webGrid, int rowIndex, string rowStyle, string alternatingRowStyle, string selectedRowStyle) {
        StringBuilder style = new StringBuilder();

        if (rowIndex % 2 == 0) {
            if (!String.IsNullOrEmpty(rowStyle)) {
                style.Append(rowStyle);
            }
        }
        else {
            if (!String.IsNullOrEmpty(alternatingRowStyle)) {
                style.Append(alternatingRowStyle);
            }
        }

        if (!String.IsNullOrEmpty(selectedRowStyle) && (rowIndex == webGrid.SelectedIndex)) {
            if (style.Length > 0) {
                style.Append(" ");
            }
            style.Append(selectedRowStyle);
        }
        return style.ToString();
    }

    private static HelperResult Format(Func<dynamic, object> format, dynamic arg) {
        var result = format(arg);
        return new HelperResult(tw => {
            var helper = result as HelperResult;
            if (helper != null) {
                helper.WriteTo(tw);
                return;
            }
            IHtmlString htmlString = result as IHtmlString;
            if (htmlString != null) {
                tw.Write(htmlString);
                return;
            }
            if (result != null) {
                tw.Write(HttpUtility.HtmlEncode(result));
            }
        });
    }

    private static IHtmlString PrintAttributes(IDictionary<string, object> attributes) {
        var builder = new StringBuilder();
        foreach (var item in attributes) {
            var value = Convert.ToString(item.Value, CultureInfo.InvariantCulture);
            builder.Append(' ')
                    .Append(HttpUtility.HtmlEncode(item.Key))
                    .Append("=\"")
                    .Append(HttpUtility.HtmlAttributeEncode(value))
                    .Append('"');
        }
        return new HtmlString(builder.ToString());
    }

    private static bool ModeEnabled(WebGridPagerModes mode, WebGridPagerModes modeCheck) {
        return (mode & modeCheck) == modeCheck;
    }
}

================================================
FILE: src/System.Web.Helpers/WebGrid/_WebGridRenderer.generated.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.214
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using System.Web.WebPages;
using System.Web.WebPages.Html;

namespace System.Web.Helpers
{
    [GeneratedCode("RazorSingleFileGenerator", "1.0.0.0")]
    internal class WebGridRenderer : HelperPage
    {
#line hidden
#line hidden
        public static HelperResult GridInitScript(WebGrid webGrid, HttpContextBase httpContext)
        {
            return new HelperResult(__razor_helper_writer =>
            {
                if (!webGrid.IsAjaxEnabled)
                {
                    return;
                }
                if (!IsGridScriptRendered(httpContext))
                {
                    SetGridScriptRendered(httpContext, true);

                    WriteLiteralTo(@__razor_helper_writer, "        <script type=\"text/javascript\">\r\n        (function($) {\r\n            $.fn" +
                                                           ".swhgLoad = function(url, containerId, callback) {\r\n                url = url + " +
                                                           "(url.indexOf(\'?\') == -1 ? \'?\' : \'&\') + \'__swhg=\' + new Date().getTime();\r\n\r\n    " +
                                                           "            $(\'<div/>\').load(url + \' \' + containerId, function(data, status, xhr" +
                                                           ") {\r\n                    $(containerId).replaceWith($(this).html());\r\n          " +
                                                           "          if (typeof(callback) === \'function\') {\r\n                        callba" +
                                                           "ck.apply(this, arguments);\r\n                    }\r\n                });\r\n        " +
                                                           "        return this;\r\n            }\r\n\r\n            $(function() {\r\n             " +
                                                           "   $(\'table[data-swhgajax=\"true\"],span[data-swhgajax=\"true\"]\').each(function() {" +
                                                           "\r\n                    var self = $(this);\r\n                    var containerId =" +
                                                           " \'#\' + self.data(\'swhgcontainer\');\r\n                    var callback = getFuncti" +
                                                           "on(self.data(\'swhgcallback\'));\r\n\r\n                    $(containerId).parent().de" +
                                                           "legate(containerId + \' a[data-swhglnk=\"true\"]\', \'click\', function() {\r\n         " +
                                                           "               $(containerId).swhgLoad($(this).attr(\'href\'), containerId, callba" +
                                                           "ck);\r\n                        return false;\r\n                    });\r\n          " +
                                                           "      })\r\n            });\r\n\r\n            function getFunction(code, argNames) {\r" +
                                                           "\n                argNames = argNames || [];\r\n                var fn = window, pa" +
                                                           "rts = (code || \"\").split(\".\");\r\n                while (fn && parts.length) {\r\n  " +
                                                           "                  fn = fn[parts.shift()];\r\n                }\r\n                if" +
                                                           " (typeof (fn) === \"function\") {\r\n                    return fn;\r\n               " +
                                                           " }\r\n                argNames.push(code);\r\n                return Function.constr" +
                                                           "uctor.apply(null, argNames);\r\n            }\r\n        })(jQuery);\r\n        </scri" +
                                                           "pt>\r\n");
                }
            });
        }

#line hidden
        public static HelperResult Table(WebGrid webGrid,
                                         HttpContextBase httpContext,
                                         string tableStyle,
                                         string headerStyle,
                                         string footerStyle,
                                         string rowStyle,
                                         string alternatingRowStyle,
                                         string selectedRowStyle,
                                         string caption,
                                         bool displayHeader,
                                         bool fillEmptyRows,
                                         string emptyRowCellValue,
                                         IEnumerable<WebGridColumn> columns,
                                         IEnumerable<string> exclusions,
                                         Func<dynamic, object> footer,
                                         object htmlAttributes)
        {
            return new HelperResult(__razor_helper_writer =>
            {
                if (emptyRowCellValue == null)
                {
                    emptyRowCellValue = "&nbsp;";
                }

                WriteTo(@__razor_helper_writer, GridInitScript(webGrid, httpContext));

                var htmlAttributeDictionary = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
                if (webGrid.IsAjaxEnabled)
                {
                    htmlAttributeDictionary["data-swhgajax"] = "true";
                    htmlAttributeDictionary["data-swhgcontainer"] = webGrid.AjaxUpdateContainerId;
                    htmlAttributeDictionary["data-swhgcallback"] = webGrid.AjaxUpdateCallback;
                }

                WriteLiteralTo(@__razor_helper_writer, "    <table");

                WriteTo(@__razor_helper_writer, tableStyle.IsEmpty() ? null : Raw(" class=\"" + HttpUtility.HtmlAttributeEncode(tableStyle) + "\""));

                WriteTo(@__razor_helper_writer, PrintAttributes(htmlAttributeDictionary));

                WriteLiteralTo(@__razor_helper_writer, ">\r\n");

                if (!caption.IsEmpty())
                {
                    WriteLiteralTo(@__razor_helper_writer, "        <caption>");

                    WriteTo(@__razor_helper_writer, caption);

                    WriteLiteralTo(@__razor_helper_writer, "</caption>\r\n");
                }

                if (displayHeader)
                {
                    WriteLiteralTo(@__razor_helper_writer, "    <thead>\r\n        <tr");

                    WriteTo(@__razor_helper_writer, CssClass(headerStyle));

                    WriteLiteralTo(@__razor_helper_writer, ">\r\n");

                    foreach (var column in columns)
                    {
                        WriteLiteralTo(@__razor_helper_writer, "            <th scope=\"col\">\r\n");

                        if (ShowSortableColumnHeader(webGrid, column))
                        {
                            var text = column.Header.IsEmpty() ? column.ColumnName : column.Header;

                            WriteTo(@__razor_helper_writer, GridLink(webGrid, webGrid.GetSortUrl(column.ColumnName), text));
                        }
                        else
                        {
                            WriteTo(@__razor_helper_writer, column.Header ?? column.ColumnName);
                        }

                        WriteLiteralTo(@__razor_helper_writer, "            </th>\r\n");
                    }

                    WriteLiteralTo(@__razor_helper_writer, "        </tr>\r\n    </thead>\r\n");
                }

                if (footer != null)
                {
                    WriteLiteralTo(@__razor_helper_writer, "    <tfoot>\r\n        <tr ");

                    WriteTo(@__razor_helper_writer, CssClass(footerStyle));

                    WriteLiteralTo(@__razor_helper_writer, ">\r\n            <td colspan=\"");

                    WriteTo(@__razor_helper_writer, columns.Count());

                    WriteLiteralTo(@__razor_helper_writer, "\">");

                    WriteTo(@__razor_helper_writer, Format(footer, null));

                    WriteLiteralTo(@__razor_helper_writer, "</td>\r\n        </tr>\r\n    </tfoot>\r\n");
                }

                WriteLiteralTo(@__razor_helper_writer, "    <tbody>\r\n");

                int rowIndex = 0;

                foreach (var row in webGrid.Rows)
                {
                    string style = GetRowStyle(webGrid, rowIndex++, rowStyle, alternatingRowStyle, selectedRowStyle);

                    WriteLiteralTo(@__razor_helper_writer, "        <tr");

                    WriteTo(@__razor_helper_writer, CssClass(style));

                    WriteLiteralTo(@__razor_helper_writer, ">\r\n");

                    foreach (var column in columns)
                    {
                        var value = (column.Format == null) ? HttpUtility.HtmlEncode(row[column.ColumnName]) : Format(column.Format, row).ToString();

                        WriteLiteralTo(@__razor_helper_writer, "            <td");

                        WriteTo(@__razor_helper_writer, CssClass(column.Style));

                        WriteLiteralTo(@__razor_helper_writer, ">");

                        WriteTo(@__razor_helper_writer, Raw(value));

                        WriteLiteralTo(@__razor_helper_writer, "</td>\r\n");
                    }

                    WriteLiteralTo(@__razor_helper_writer, "        </tr>\r\n");
                }

                if (fillEmptyRows)
                {
                    rowIndex = webGrid.Rows.Count;
                    while (rowIndex < webGrid.RowsPerPage)
                    {
                        string style = GetRowStyle(webGrid, rowIndex++, rowStyle, alternatingRowStyle, null);

                        WriteLiteralTo(@__razor_helper_writer, "            <tr");

                        WriteTo(@__razor_helper_writer, CssClass(style));

                        WriteLiteralTo(@__razor_helper_writer, ">\r\n");

                        foreach (var column in columns)
                        {
                            WriteLiteralTo(@__razor_helper_writer, "                    <td");

                            WriteTo(@__razor_helper_writer, CssClass(column.Style));

                            WriteLiteralTo(@__razor_helper_writer, ">");

                            WriteTo(@__razor_helper_writer, Raw(emptyRowCellValue));

                            WriteLiteralTo(@__razor_helper_writer, "</td>\r\n");
                        }

                        WriteLiteralTo(@__razor_helper_writer, "            </tr>\r\n");
                    }
                }

                WriteLiteralTo(@__razor_helper_writer, "    </tbody>\r\n    </table>\r\n");
            });
        }

#line hidden
        public static HelperResult Pager(
            WebGrid webGrid,
            HttpContextBase httpContext,
            WebGridPagerModes mode,
            string firstText,
            string previousText,
            string nextText,
            string lastText,
            int numericLinksCount,
            bool renderAjaxContainer)
        {
            return new HelperResult(__razor_helper_writer =>
            {
                int currentPage = webGrid.PageIndex;
                int totalPages = webGrid.PageCount;
                int lastPage = totalPages - 1;

                WriteTo(@__razor_helper_writer, GridInitScript(webGrid, httpContext));

                if (renderAjaxContainer && webGrid.IsAjaxEnabled)
                {
                    WriteLiteralTo(@__razor_helper_writer, "        ");

                    WriteLiteralTo(@__razor_helper_writer, "<span data-swhgajax=\"true\" data-swhgcontainer=\"");

                    WriteTo(@__razor_helper_writer, webGrid.AjaxUpdateContainerId);

                    WriteLiteralTo(@__razor_helper_writer, "\" data-swhgcallback=\"");

                    WriteTo(@__razor_helper_writer, webGrid.AjaxUpdateCallback);

                    WriteLiteralTo(@__razor_helper_writer, "\">\r\n");
                }

                if (ModeEnabled(mode, WebGridPagerModes.FirstLast) && currentPage > 1)
                {
                    if (String.IsNullOrEmpty(firstText))
                    {
                        firstText = "<<";
                    }

                    WriteTo(@__razor_helper_writer, GridLink(webGrid, webGrid.GetPageUrl(0), firstText));

                    WriteTo(@__razor_helper_writer, Raw(" "));
                }

                if (ModeEnabled(mode, WebGridPagerModes.NextPrevious) && currentPage > 0)
                {
                    if (String.IsNullOrEmpty(previousText))
                    {
                        previousText = "<";
                    }

                    WriteTo(@__razor_helper_writer, GridLink(webGrid, webGrid.GetPageUrl(currentPage - 1), previousText));

                    WriteTo(@__razor_helper_writer, Raw(" "));
                }

                if (ModeEnabled(mode, WebGridPagerModes.Numeric) && (totalPages > 1))
                {
                    int last = currentPage + (numericLinksCount / 2);
                    int first = last - numericLinksCount + 1;
                    if (last > lastPage)
                    {
                        first -= last - lastPage;
                        last = lastPage;
                    }
                    if (first < 0)
                    {
                        last = Math.Min(last + (0 - first), lastPage);
                        first = 0;
                    }
                    for (int i = first; i <= last; i++)
                    {
                        var pageText = (i + 1).ToString(CultureInfo.InvariantCulture);
                        if (i == currentPage)
                        {
                            WriteTo(@__razor_helper_writer, pageText);
                        }
                        else
                        {
                            WriteTo(@__razor_helper_writer, GridLink(webGrid, webGrid.GetPageUrl(i), pageText));
                        }

                        WriteTo(@__razor_helper_writer, Raw(" "));
                    }
                }

                if (ModeEnabled(mode, WebGridPagerModes.NextPrevious) && (currentPage < lastPage))
                {
                    if (String.IsNullOrEmpty(nextText))
                    {
                        nextText = ">";
                    }

                    WriteTo(@__razor_helper_writer, GridLink(webGrid, webGrid.GetPageUrl(currentPage + 1), nextText));

                    WriteTo(@__razor_helper_writer, Raw(" "));
                }

                if (ModeEnabled(mode, WebGridPagerModes.FirstLast) && (currentPage < lastPage - 1))
                {
                    if (String.IsNullOrEmpty(lastText))
                    {
                        lastText = ">>";
                    }

                    WriteTo(@__razor_helper_writer, GridLink(webGrid, webGrid.GetPageUrl(lastPage), lastText));
                }

                if (renderAjaxContainer && webGrid.IsAjaxEnabled)
                {
                    WriteLiteralTo(@__razor_helper_writer, "        ");

                    WriteLiteralTo(@__razor_helper_writer, "</span>\r\n");
                }
            });
        }

        private static readonly object _gridScriptRenderedKey = new object();

        private static bool IsGridScriptRendered(HttpContextBase context)
        {
            bool? value = (bool?)context.Items[_gridScriptRenderedKey];
            return value.HasValue && value.Value;
        }

        private static void SetGridScriptRendered(HttpContextBase context, bool value)
        {
            context.Items[_gridScriptRenderedKey] = value;
        }

        private static bool ShowSortableColumnHeader(WebGrid grid, WebGridColumn column)
        {
            return grid.CanSort && column.CanSort && !column.ColumnName.IsEmpty();
        }

        public static IHtmlString GridLink(WebGrid webGrid, string url, string text)
        {
            TagBuilder builder = new TagBuilder("a");
            builder.SetInnerText(text);
            builder.MergeAttribute("href", url);
            if (webGrid.IsAjaxEnabled)
            {
                builder.MergeAttribute("data-swhglnk", "true");
            }
            return builder.ToHtmlString(TagRenderMode.Normal);
        }

        private static IHtmlString Raw(string text)
        {
            return new HtmlString(text);
        }

        private static IHtmlString RawJS(string text)
        {
            return new HtmlString(HttpUtility.JavaScriptStringEncode(text));
        }

        private static IHtmlString CssClass(string className)
        {
            return new HtmlString((!className.IsEmpty()) ? " class=\"" + HttpUtility.HtmlAttributeEncode(className) + "\"" : String.Empty);
        }

        private static string GetRowStyle(WebGrid webGrid, int rowIndex, string rowStyle, string alternatingRowStyle, string selectedRowStyle)
        {
            StringBuilder style = new StringBuilder();

            if (rowIndex % 2 == 0)
            {
                if (!String.IsNullOrEmpty(rowStyle))
                {
                    style.Append(rowStyle);
                }
            }
            else
            {
                if (!String.IsNullOrEmpty(alternatingRowStyle))
                {
                    style.Append(alternatingRowStyle);
                }
            }

            if (!String.IsNullOrEmpty(selectedRowStyle) && (rowIndex == webGrid.SelectedIndex))
            {
                if (style.Length > 0)
                {
                    style.Append(" ");
                }
                style.Append(selectedRowStyle);
            }
            return style.ToString();
        }

        private static HelperResult Format(Func<dynamic, object> format, dynamic arg)
        {
            var result = format(arg);
            return new HelperResult(tw =>
            {
                var helper = result as HelperResult;
                if (helper != null)
                {
                    helper.WriteTo(tw);
                    return;
                }
                IHtmlString htmlString = result as IHtmlString;
                if (htmlString != null)
                {
                    tw.Write(htmlString);
                    return;
                }
                if (result != null)
                {
                    tw.Write(HttpUtility.HtmlEncode(result));
                }
            });
        }

        private static IHtmlString PrintAttributes(IDictionary<string, object> attributes)
        {
            var builder = new StringBuilder();
            foreach (var item in attributes)
            {
                var value = Convert.ToString(item.Value, CultureInfo.InvariantCulture);
                builder.Append(' ')
                    .Append(HttpUtility.HtmlEncode(item.Key))
                    .Append("=\"")
                    .Append(HttpUtility.HtmlAttributeEncode(value))
                    .Append('"');
            }
            return new HtmlString(builder.ToString());
        }

        private static bool ModeEnabled(WebGridPagerModes mode, WebGridPagerModes modeCheck)
        {
            return (mode & modeCheck) == modeCheck;
        }

        protected static HttpApplication ApplicationInstance
        {
            get { return ((Context.ApplicationInstance)); }
        }
    }
}

================================================
FILE: src/System.Web.Helpers/WebImage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Drawing.Text;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Helpers.Resources;
using System.Web.UI.WebControls;
using Microsoft.Internal.Web.Utils;
using Image = System.Drawing.Image;

namespace System.Web.Helpers
{
    public class WebImage
    {
        // Default resolution to use when getting bitmap from image
        private const float FixedResolution = 96f;

        private static readonly IDictionary<Guid, ImageFormat> _imageFormatLookup = new[]
        {
            Drawing.Imaging.ImageFormat.Bmp, Drawing.Imaging.ImageFormat.Emf, Drawing.Imaging.ImageFormat.Exif,
            Drawing.Imaging.ImageFormat.Gif, Drawing.Imaging.ImageFormat.Icon, Drawing.Imaging.ImageFormat.Jpeg,
            Drawing.Imaging.ImageFormat.MemoryBmp, Drawing.Imaging.ImageFormat.Png, Drawing.Imaging.ImageFormat.Tiff,
            Drawing.Imaging.ImageFormat.Wmf
        }.ToDictionary(format => format.Guid, format => format);

        private static readonly Func<string, byte[]> _defaultReadAction = File.ReadAllBytes;

        // Initial format is the format of the image when it was constructed. 
        // Current format is the format currently stored in the content buffer. This can
        // be different than initial format since image transformations can change format.
        private readonly ImageFormat _initialFormat;
        private readonly List<ImageTransformation> _transformations = new List<ImageTransformation>();
        private ImageFormat _currentFormat;
        private byte[] _content;
        private string _fileName;
        private int _height = -1;
        private int _width = -1;

        private PropertyItem[] _properties; // image metadata

        public WebImage(byte[] content)
        {
            _initialFormat = ValidateImageContent(content, "content");
            _currentFormat = _initialFormat;
            _content = (byte[])content.Clone();
        }

        public WebImage(string filePath)
            : this(new HttpContextWrapper(HttpContext.Current), _defaultReadAction, filePath)
        {
        }

        public WebImage(Stream imageStream)
        {
            if (imageStream.CanSeek)
            {
                imageStream.Seek(0, SeekOrigin.Begin);

                _content = new byte[imageStream.Length];
                using (BinaryReader reader = new BinaryReader(imageStream))
                {
                    reader.Read(_content, 0, (int)imageStream.Length);
                }
            }
            else
            {
                List<byte[]> chunks = new List<byte[]>();
                int totalSize = 0;
                using (BinaryReader reader = new BinaryReader(imageStream))
                {
                    // Pick some size for chunks that is still under limit
                    // that causes them to be placed on the large object heap.
                    int chunkSizeInBytes = 1024 * 50;
                    byte[] nextChunk = null;
                    do
                    {
                        nextChunk = reader.ReadBytes(chunkSizeInBytes);
                        totalSize += nextChunk.Length;
                        chunks.Add(nextChunk);
                    }
                    while (nextChunk.Length == chunkSizeInBytes);
                }

                _content = new byte[totalSize];
                int startIndex = 0;
                foreach (var chunk in chunks)
                {
                    chunk.CopyTo(_content, startIndex);
                    startIndex += chunk.Length;
                }
            }
            _initialFormat = ValidateImageContent(_content, "imageStream");
            _currentFormat = _initialFormat;
        }

        internal WebImage(HttpContextBase httpContext, Func<string, byte[]> readAction, string filePath)
        {
            if (String.IsNullOrEmpty(filePath))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "filePath");
            }

            _fileName = filePath;
            _content = readAction(VirtualPathUtil.MapPath(httpContext, filePath));
            _initialFormat = ValidateImageContent(_content, "filePath");
            _currentFormat = _initialFormat;
        }

        private WebImage(WebImage other)
        {
            Debug.Assert(other != null);
            Debug.Assert(other._content != null, "Incorrectly constructed instance.");

            // We are not validating the contents from this constructor since its a copy constructor. 
            _content = (byte[])other._content.Clone();
            _initialFormat = other._initialFormat;
            _currentFormat = other._currentFormat;
            _fileName = other._fileName;

            _height = other._height;
            _width = other._width;

            _properties = (other._properties != null) ? (PropertyItem[])other._properties.Clone() : null;

            _transformations = new List<ImageTransformation>(other._transformations);
        }

        public int Height
        {
            get
            {
                if ((_transformations.Count > 0) || (_height < 0))
                {
                    ApplyTransformationsAndSetProperties();
                }
                return _height;
            }
        }

        public int Width
        {
            get
            {
                if ((_transformations.Count > 0) || (_width < 0))
                {
                    ApplyTransformationsAndSetProperties();
                }
                return _width;
            }
        }

        public string FileName
        {
            get { return _fileName; }
            set { _fileName = value; }
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase",
            Justification = "No security decision is made based on this string. It's customary to display MIME format in lowercase.")]
        public string ImageFormat
        {
            get
            {
                if (_transformations.Any())
                {
                    ApplyTransformationsAndSetProperties();
                }

                Debug.Assert(_currentFormat != null);
                return ConversionUtil.ToString(_currentFormat).ToLowerInvariant();
            }
        }

        public static WebImage GetImageFromRequest(string postedFileName = null)
        {
            var request = new HttpRequestWrapper(HttpContext.Current.Request);
            return GetImageFromRequest(request, postedFileName);
        }

        internal static WebImage GetImageFromRequest(HttpRequestBase request, string postedFileName = null)
        {
            Debug.Assert(request != null);
            if ((request.Files == null) || (request.Files.Count == 0))
            {
                return null;
            }
            HttpPostedFileBase file = String.IsNullOrEmpty(postedFileName) ? request.Files[0] : request.Files[postedFileName];
            if (file == null || file.ContentLength < 1)
            {
                return null;
            }

            // The content type is specified by the browser and is unreliable. 
            // Disregard content type, acquire mime type.
            ImageFormat format;
            string mimeType = MimeMapping.GetMimeMapping(file.FileName);
            if (!ConversionUtil.TryFromStringToImageFormat(mimeType, out format))
            {
                // Unsupported image format.
                return null;
            }

            WebImage webImage = new WebImage(file.InputStream);
            webImage.FileName = file.FileName;
            return webImage;
        }

        public WebImage Clone()
        {
            return new WebImage(this);
        }

        public byte[] GetBytes(string requestedFormat = null)
        {
            if (_transformations.Count > 0)
            {
                ApplyTransformationsAndSetProperties();
            }

            ImageFormat requestedImageFormat = null;
            if (!String.IsNullOrEmpty(requestedFormat))
            {
                // This will throw if image format is incorrect.
                requestedImageFormat = GetImageFormat(requestedFormat);
            }

            requestedImageFormat = requestedImageFormat ?? _initialFormat;
            Debug.Assert(requestedImageFormat != null, "Initial format can never be null");
            if (requestedImageFormat.Equals(_currentFormat))
            {
                return (byte[])_content.Clone();
            }

            // Conversion from one format to another
            using (MemoryStream sourceBuffer = new MemoryStream(_content))
            {
                using (Image image = Image.FromStream(sourceBuffer))
                {
                    // if _properties are not initialized that means image did not go through any
                    // transformations yet and original byte array contains all metadata available
                    if (_properties != null)
                    {
                        CopyMetadata(_properties, image);
                    }

                    using (MemoryStream destinationBuffer = new MemoryStream())
                    {
                        image.Save(destinationBuffer, requestedImageFormat);
                        return destinationBuffer.ToArray();
                    }
                }
            }
        }

        public WebImage Resize(int width, int height, bool preserveAspectRatio = true, bool preventEnlarge = false)
        {
            if (width <= 0)
            {
                throw new ArgumentOutOfRangeException(
                    "width",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThan, 0));
            }
            if (height <= 0)
            {
                throw new ArgumentOutOfRangeException(
                    "height",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThan, 0));
            }

            ResizeTransformation trans = new ResizeTransformation(height, width, preserveAspectRatio, preventEnlarge);
            _transformations.Add(trans);
            return this;
        }

        public WebImage Crop(int top = 0, int left = 0, int bottom = 0, int right = 0)
        {
            if (top < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "top",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }
            if (left < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "left",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }
            if (bottom < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "bottom",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }
            if (right < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "right",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }

            CropTransformation crop = new CropTransformation(top, right, bottom, left);
            _transformations.Add(crop);
            return this;
        }

        public WebImage RotateLeft()
        {
            ImageTransformation transform = new RotateTransformation(RotateFlipType.Rotate270FlipNone);
            _transformations.Add(transform);
            return this;
        }

        public WebImage RotateRight()
        {
            ImageTransformation transform = new RotateTransformation(RotateFlipType.Rotate90FlipNone);
            _transformations.Add(transform);
            return this;
        }

        public WebImage FlipVertical()
        {
            ImageTransformation transform = new RotateTransformation(RotateFlipType.RotateNoneFlipY);
            _transformations.Add(transform);
            return this;
        }

        public WebImage FlipHorizontal()
        {
            ImageTransformation transform = new RotateTransformation(RotateFlipType.RotateNoneFlipX);
            _transformations.Add(transform);
            return this;
        }

        /// <summary>
        /// Adds text watermark to a WebImage.
        /// </summary>
        /// <param name="text">Text to use as a watermark.</param>
        /// <param name="fontColor">Watermark color. Can be specified as a string (e.g. "White") or as a hex value (e.g. "#00FF00").</param>
        /// <param name="fontSize">Font size in points.</param>
        /// <param name="fontStyle">Font style: bold, italics, etc.</param>
        /// <param name="fontFamily">Font family name: e.g. Microsoft Sans Serif</param>
        /// <param name="horizontalAlign">Horizontal alignment for watermark text. Can be "right", "left", or "center".</param>
        /// <param name="verticalAlign">Vertical alignment for watermark text. Can be "top", "bottom", or "middle".</param>
        /// <param name="opacity">Watermark text opacity. Should be between 0 and 100.</param>
        /// <param name="padding">Size of padding around watermark text in pixels.</param>
        /// <returns>Modified WebImage instance with added watermark.</returns>
        public WebImage AddTextWatermark(
            string text,
            string fontColor = "Black",
            int fontSize = 12,
            string fontStyle = "Regular",
            string fontFamily = "Microsoft Sans Serif",
            string horizontalAlign = "Right",
            string verticalAlign = "Bottom",
            int opacity = 100,
            int padding = 5)
        {
            if (String.IsNullOrEmpty(text))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "text");
            }

            Color color;
            if (!ConversionUtil.TryFromStringToColor(fontColor, out color))
            {
                throw new ArgumentException(HelpersResources.WebImage_IncorrectColorName);
            }

            if ((opacity < 0) || (opacity > 100))
            {
                throw new ArgumentOutOfRangeException("opacity", String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_Between, 0, 100));
            }

            int alpha = 255 * opacity / 100;
            color = Color.FromArgb(alpha, color);

            if (fontSize <= 0)
            {
                throw new ArgumentOutOfRangeException(
                    "fontSize",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThan, 0));
            }

            FontStyle fontStyleEnum;
            if (!ConversionUtil.TryFromStringToEnum(fontStyle, out fontStyleEnum))
            {
                throw new ArgumentException(HelpersResources.WebImage_IncorrectFontStyle);
            }

            FontFamily fontFamilyClass;
            if (!ConversionUtil.TryFromStringToFontFamily(fontFamily, out fontFamilyClass))
            {
                throw new ArgumentException(HelpersResources.WebImage_IncorrectFontFamily);
            }

            HorizontalAlign horizontalAlignEnum = ParseHorizontalAlign(horizontalAlign);
            VerticalAlign verticalAlignEnum = ParseVerticalAlign(verticalAlign);

            if (padding < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "padding",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }

            WatermarkTextTransformation transformation =
                new WatermarkTextTransformation(text, color, fontSize, fontStyleEnum, fontFamilyClass, horizontalAlignEnum, verticalAlignEnum, padding);
            _transformations.Add(transformation);
            return this;
        }

        /// <summary>
        /// Adds image watermark to an image.
        /// </summary>
        /// <param name="watermarkImage">Image to use as a watermark.</param>
        /// <param name="width">Width of watermark.</param>
        /// <param name="height">Height of watermark.</param>
        /// <param name="horizontalAlign">Horizontal alignment for watermark image. Can be "right", "left", or "center".</param>
        /// <param name="verticalAlign">Vertical alignment for watermark image. Can be "top", "bottom", or "middle".</param>
        /// <param name="opacity">Watermark text opacity. Should be between 0 and 100.</param>
        /// <param name="padding">Size of padding around watermark image in pixels.</param>
        /// <returns>Modified WebImage instance with added watermark.</returns>
        public WebImage AddImageWatermark(
            WebImage watermarkImage,
            int width = 0,
            int height = 0,
            string horizontalAlign = "Right",
            string verticalAlign = "Bottom",
            int opacity = 100,
            int padding = 5)
        {
            if (watermarkImage == null)
            {
                throw new ArgumentNullException("watermarkImage");
            }

            if (width < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "width",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }
            if (height < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "height",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }
            if (((width == 0) && (height > 0)) || ((width > 0) && (height == 0)))
            {
                throw new ArgumentException(HelpersResources.WebImage_IncorrectWidthAndHeight);
            }
            if ((opacity < 0) || (opacity > 100))
            {
                throw new ArgumentOutOfRangeException("opacity", String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_Between, 0, 100));
            }

            HorizontalAlign horizontalAlignEnum = ParseHorizontalAlign(horizontalAlign);
            VerticalAlign verticalAlignEnum = ParseVerticalAlign(verticalAlign);

            if (padding < 0)
            {
                throw new ArgumentOutOfRangeException(
                    "padding",
                    String.Format(CultureInfo.InvariantCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, 0));
            }

            WatermarkImageTransformation transformation =
                new WatermarkImageTransformation(watermarkImage.Clone(), width, height, horizontalAlignEnum, verticalAlignEnum, opacity, padding);
            _transformations.Add(transformation);
            return this;
        }

        /// <summary>
        /// Adds image watermark to an image.
        /// </summary>
        /// <param name="watermarkImageFilePath">File to read watermark image from.</param>
        /// <param name="width">Width of watermark.</param>
        /// <param name="height">Height of watermark.</param>
        /// <param name="horizontalAlign">Horizontal alignment for watermark image. Can be "right", "left", or "center".</param>
        /// <param name="verticalAlign">Vertical alignment for watermark image. Can be "top", "bottom", or "middle".</param>
        /// <param name="opacity">Watermark text opacity. Should be between 0 and 100.</param>
        /// <param name="padding">Size of padding around watermark image in pixels.</param>
        /// <returns>WebImage instance with added watermark.</returns>
        public WebImage AddImageWatermark(
            string watermarkImageFilePath,
            int width = 0,
            int height = 0,
            string horizontalAlign = "Right",
            string verticalAlign = "Bottom",
            int opacity = 100,
            int padding = 5)
        {
            return AddImageWatermark(new HttpContextWrapper(HttpContext.Current), _defaultReadAction, watermarkImageFilePath, width, height,
                                     horizontalAlign, verticalAlign, opacity, padding);
        }

        internal WebImage AddImageWatermark(
            HttpContextBase httpContext,
            Func<string, byte[]> readAction,
            string watermarkImageFilePath,
            int width,
            int height,
            string horizontalAlign,
            string verticalAlign,
            int opacity,
            int padding)
        {
            return AddImageWatermark(new WebImage(httpContext, readAction, watermarkImageFilePath), width, height, horizontalAlign, verticalAlign, opacity, padding);
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase",
            Justification = "No security decision is made based on this string. It's customary to display MIME format in lowercase.")]
        public WebImage Write(string requestedFormat = null)
        {
            // GetBytes takes care of executing pending transformations and 
            // determining current image format if we didn't have it set before.
            // todo: this could be made more efficient by avoiding cloning array 
            // when format is same
            requestedFormat = requestedFormat ?? _initialFormat.ToString();
            Debug.Assert(requestedFormat != null);
            byte[] content = GetBytes(requestedFormat);

            string requestedFormatWithPrefix;
            if (requestedFormat.StartsWith("image/", StringComparison.OrdinalIgnoreCase))
            {
                requestedFormatWithPrefix = requestedFormat;
            }
            else
            {
                requestedFormatWithPrefix = "image/" + requestedFormat;
            }

            HttpResponse response = HttpContext.Current.Response;
            response.ContentType = requestedFormatWithPrefix;
            response.BinaryWrite(content);

            return this;
        }

        /// <param name="filePath">If no filePath is specified, the method falls back to the file name if the image was constructed from a file or 
        /// the file name on the client (the browser machine) if the image was built off GetImageFromRequest
        /// </param>
        /// <param name="imageFormat">The format the image is saved in</param>
        /// <param name="forceCorrectExtension">Appends a well known extension to the filePath based on the imageFormat specified. 
        /// If the filePath uses a valid extension, no change is made.
        /// e.g. format: "jpg", filePath: "foo.txt". Image saved at = "foo.txt.jpeg"
        ///      format: "png", filePath: "foo.png". Image saved at = "foo.txt.png"
        /// </param>
        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase",
            Justification = "File extensions are typically specified in lower case.")]
        public WebImage Save(string filePath = null, string imageFormat = null, bool forceCorrectExtension = true)
        {
            return Save(new HttpContextWrapper(HttpContext.Current), File.WriteAllBytes, filePath, imageFormat, forceCorrectExtension);
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "The string is a file extension which is typically lower case")]
        internal WebImage Save(HttpContextBase context, Action<string, byte[]> saveAction, string filePath, string imageFormat, bool forceWellKnownExtension)
        {
            filePath = filePath ?? FileName;
            if (String.IsNullOrEmpty(filePath))
            {
                throw new ArgumentNullException("filePath", CommonResources.Argument_Cannot_Be_Null_Or_Empty);
            }

            // GetBytes takes care of executing pending transformations.
            // todo: this could be made more efficient by avoiding cloning array 
            // when format is same
            byte[] content = GetBytes(imageFormat);
            if (forceWellKnownExtension)
            {
                ImageFormat saveImageFormat;
                ImageFormat requestedImageFormat = String.IsNullOrEmpty(imageFormat) ? _initialFormat : GetImageFormat(imageFormat);
                var extension = Path.GetExtension(filePath).TrimStart('.');
                // TryFromStringToImageFormat accepts mime types and image names. For images supported by System.Drawing.Imaging, the image name maps to the extension.
                // Replace the extension with the current format in the following two events:
                //  * The extension format cannot be converted to a known format
                //  * The format does not match. 
                if (!ConversionUtil.TryFromStringToImageFormat(extension, out saveImageFormat) || !saveImageFormat.Equals(requestedImageFormat))
                {
                    extension = requestedImageFormat.ToString().ToLowerInvariant();
                    filePath = filePath + "." + extension;
                }
            }
            saveAction(VirtualPathUtil.MapPath(context, filePath), content);
            // Update the FileName since it may have changed whilst saving.
            FileName = filePath;
            return this;
        }

        /// <summary>
        /// Constructs a System.Drawing.Image instance from the content which validates the contents of the image.
        /// </summary>
        /// <exception cref="System.ArgumentException">When an Image construction fails.</exception>
        private static ImageFormat ValidateImageContent(byte[] content, string paramName)
        {
            try
            {
                using (MemoryStream stream = new MemoryStream(content))
                {
                    using (Image image = Image.FromStream(stream, useEmbeddedColorManagement: false))
                    {
                        var rawFormat = image.RawFormat;
                        ImageFormat actualFormat;
                        // RawFormat returns a ImageFormat instance with the same Guid as the predefined types 
                        // This instance is not very useful when it comes to printing human readable strings and file extensions.
                        // Therefore, lookup the predefined instance 
                        if (!_imageFormatLookup.TryGetValue(rawFormat.Guid, out actualFormat))
                        {
                            actualFormat = rawFormat;
                        }
                        return actualFormat;
                    }
                }
            }
            catch (ArgumentException exception)
            {
                throw new ArgumentException(HelpersResources.WebImage_InvalidImageContents, paramName, exception);
            }
        }

        private static ImageFormat GetImageFormat(string format)
        {
            Debug.Assert(!String.IsNullOrEmpty(format), "format cannot be null");

            ImageFormat result;
            if (!ConversionUtil.TryFromStringToImageFormat(format, out result))
            {
                throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, HelpersResources.Image_IncorrectImageFormat, format), "format");
            }

            return result;
        }

        private static HorizontalAlign ParseHorizontalAlign(string alignment)
        {
            bool conversionOk;
            HorizontalAlign horizontalAlign;
            conversionOk = ConversionUtil.TryFromStringToEnum(alignment, out horizontalAlign);
            if (!conversionOk || (horizontalAlign == HorizontalAlign.Justify) || (horizontalAlign == HorizontalAlign.NotSet))
            {
                throw new ArgumentException(HelpersResources.WebImage_IncorrectHorizontalAlignment);
            }
            return horizontalAlign;
        }

        private static VerticalAlign ParseVerticalAlign(string alignment)
        {
            bool conversionOk;
            VerticalAlign verticalAlign;
            conversionOk = ConversionUtil.TryFromStringToEnum(alignment, out verticalAlign);
            if (!conversionOk || (verticalAlign == VerticalAlign.NotSet))
            {
                throw new ArgumentException(HelpersResources.WebImage_IncorrectVerticalAlignment);
            }
            return verticalAlign;
        }

        private void GetContentFromImageAndUpdateFormat(Image image)
        {
            using (MemoryStream buffer = new MemoryStream())
            {
                if (image.RawFormat.Equals(Drawing.Imaging.ImageFormat.MemoryBmp))
                {
                    // Memory Bmps are an in-memory format and do not have encoders to save to disk / stream. 
                    // Save it in the current format whenever we encounter which ensures we preserve image information such as transparency.
                    image.Save(buffer, _currentFormat);
                }
                else
                {
                    // If the RawFormat has an encoder, save it as-is to prevent the cost of encoding it to another format such as the initial or current format. 
                    image.Save(buffer, image.RawFormat);
                    _currentFormat = image.RawFormat;
                }

                _content = buffer.ToArray();
            }
        }

        private void ApplyTransformationsAndSetProperties()
        {
            Debug.Assert(_content != null, "Incorrectly constructed instance.");

            MemoryStream stream = null;
            Image image = null;
            try
            {
                stream = new MemoryStream(_content);
                image = Image.FromStream(stream);

                if (_properties == null)
                {
                    // makes sure properties is never null after initialization
                    _properties = image.PropertyItems ?? new PropertyItem[0];
                }

                foreach (ImageTransformation trans in _transformations)
                {
                    Image tempImage = trans.ApplyTransformation(image);

                    // ApplyTransformation could return the same image if no transformations are made or if
                    // transformations are made on the image itself.
                    if (tempImage != image)
                    {
                        if (stream != null)
                        {
                            stream.Dispose();
                            stream = null;
                        }

                        Debug.Assert((image != null) && (tempImage != null), "Image instances should not be null.");
                        image.Dispose();
                        image = tempImage;
                    }

                    // This is just to keep FxCop happy. Otherwise it thinks that tempImage could be diposed twice.
                    tempImage = null;
                }

                // If there were any transformations we need to get new content. This will also update the current format to the RawFormat.
                if (_transformations.Any())
                {
                    GetContentFromImageAndUpdateFormat(image);
                    _transformations.Clear();
                }

                _height = image.Size.Height;
                _width = image.Size.Width;
            }
            finally
            {
                if (image != null)
                {
                    image.Dispose();
                }
                if (stream != null)
                {
                    stream.Dispose();
                }
            }
        }

        /// <remarks>Caller has to dispose of returned Bitmap object.</remarks>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "Callers of this method are responsible for disposing returned Bitmap")]
        private static Bitmap GetBitmapFromImage(Image image, int width, int height, bool preserveResolution = true)
        {
            bool indexed = (image.PixelFormat == PixelFormat.Format1bppIndexed ||
                            image.PixelFormat == PixelFormat.Format4bppIndexed ||
                            image.PixelFormat == PixelFormat.Format8bppIndexed ||
                            image.PixelFormat == PixelFormat.Indexed);

            Bitmap bitmap = indexed ? new Bitmap(width, height) : new Bitmap(width, height, image.PixelFormat);
            if (preserveResolution)
            {
                bitmap.SetResolution(image.HorizontalResolution, image.VerticalResolution);
            }
            else
            {
                bitmap.SetResolution(FixedResolution, FixedResolution);
            }

            using (Graphics graphic = Graphics.FromImage(bitmap))
            {
                if (indexed)
                {
                    graphic.FillRectangle(Brushes.White, 0, 0, width, height);
                }
                graphic.InterpolationMode = InterpolationMode.HighQualityBicubic;
                graphic.DrawImage(image, 0, 0, width, height);
            }

            return bitmap;
        }

        private static void CopyMetadata(PropertyItem[] properties, Image target)
        {
            foreach (PropertyItem property in properties)
            {
                try
                {
                    target.SetPropertyItem(property);
                }
                catch (ArgumentException)
                {
                    // just ignore it; on some configurations this fails
                }
            }
        }

        private class CropTransformation : ImageTransformation
        {
            public CropTransformation(int top, int right, int bottom, int left)
            {
                Top = top;
                Right = right;
                Bottom = bottom;
                Left = left;
            }

            public int Top { get; set; }
            public int Right { get; set; }
            public int Bottom { get; set; }
            public int Left { get; set; }

            public override Image ApplyTransformation(Image image)
            {
                if ((Top + Bottom > image.Height) || (Left + Right > image.Width))
                {
                    // If Crop arguments are too big (i.e. whole image is cropped) we don't make any changes. 
                    return image;
                }

                int width = image.Width - (Left + Right);
                int height = image.Height - (Top + Bottom);

                RectangleF rect = new RectangleF(Left, Top, width, height);

                // todo: check if we can guarantee that rect is inside the image at this point
                using (Bitmap bitmap = GetBitmapFromImage(image, image.Width, image.Height))
                {
                    try
                    {
                        return bitmap.Clone(rect, image.PixelFormat);
                    }
                    catch (OutOfMemoryException)
                    {
                        // Bitmap.Clone unfortunately throws OOM exception when rect is 
                        // outside of the source bitmap bounds
                        return image;
                    }
                }
            }
        }

        private abstract class ImageTransformation
        {
            public abstract Image ApplyTransformation(Image image);
        }

        private class ResizeTransformation : ImageTransformation
        {
            public ResizeTransformation(int height, int width, bool preserveAspectRatio, bool preventEnlarge)
            {
                Height = height;
                Width = width;
                PreserveAspectRatio = preserveAspectRatio;
                PreventEnlarge = preventEnlarge;
            }

            public int Height { get; set; }
            public int Width { get; set; }
            public bool PreserveAspectRatio { get; set; }
            public bool PreventEnlarge { get; set; }

            public override Image ApplyTransformation(Image image)
            {
                int height = Height;
                int width = Width;

                if (PreserveAspectRatio)
                {
                    double heightRatio = (height * 100.0) / image.Height;
                    double widthRatio = (width * 100.0) / image.Width;
                    if (heightRatio > widthRatio)
                    {
                        height = (int)Math.Round((widthRatio * image.Height) / 100);
                    }
                    else if (heightRatio < widthRatio)
                    {
                        width = (int)Math.Round((heightRatio * image.Width) / 100);
                    }
                }

                if (PreventEnlarge)
                {
                    if (height > image.Height)
                    {
                        height = image.Height;
                    }
                    if (width > image.Width)
                    {
                        width = image.Width;
                    }
                }

                if ((image.Height == height) && (image.Width == width))
                {
                    return image;
                }

                return GetBitmapFromImage(image, width, height);
            }
        }

        private class RotateTransformation : ImageTransformation
        {
            public RotateTransformation(RotateFlipType direction)
            {
                Direction = direction;
            }

            public RotateFlipType Direction { get; set; }

            public override Image ApplyTransformation(Image image)
            {
                image.RotateFlip(Direction);
                return image;
            }
        }

        private class WatermarkImageTransformation : WatermarkTransformation
        {
            public WatermarkImageTransformation(
                WebImage image,
                int width,
                int height,
                HorizontalAlign horizontalAlign,
                VerticalAlign verticalAlign,
                int opacity,
                int padding)
                : base(horizontalAlign, verticalAlign, padding)
            {
                WatermarkImage = image;
                Width = width;
                Height = height;
                Opacity = opacity;
            }

            public WebImage WatermarkImage { get; set; }
            public int Width { get; set; }
            public int Height { get; set; }
            public int Opacity { get; set; }

            public override Image ApplyTransformation(Image image)
            {
                // Use original image dimensions if user didn't specify any.
                if (Width == 0)
                {
                    Debug.Assert(Height == 0, "If one dimension is zero the other one must be too.");
                    Width = WatermarkImage.Width;
                    Height = WatermarkImage.Height;
                }

                if (((Padding * 2) + Width >= image.Width) || ((Padding * 2) + Height >= image.Height))
                {
                    // If watermark image + padding is too big we don't make any changes. 
                    return image;
                }

                WatermarkImage.Resize(Width, Height, preserveAspectRatio: false, preventEnlarge: false);
                float alphaScaling = ((float)Opacity) / 100;

                byte[] watermarkBuffer = WatermarkImage.GetBytes();
                Rectangle rect = GetRectangleInsideImage(image, Width, Height);

                using (Graphics targetGraphics = Graphics.FromImage(image))
                {
                    using (MemoryStream memStream = new MemoryStream(watermarkBuffer))
                    {
                        using (Image watermarkImage = Image.FromStream(memStream))
                        {
                            AddWatermark(targetGraphics, watermarkImage, rect, alphaScaling);
                        }
                    }
                }

                return image;
            }
        }

        private class WatermarkTextTransformation : WatermarkTransformation
        {
            public WatermarkTextTransformation(
                string text,
                Color fontColor,
                int fontSize,
                FontStyle fontStyle,
                FontFamily fontFamily,
                HorizontalAlign alignX,
                VerticalAlign alignY,
                int padding)
                : base(alignX, alignY, padding)
            {
                Text = text;
                FontColor = fontColor;
                FontSize = fontSize;
                FontStyle = fontStyle;
                FontFamily = fontFamily;
            }

            public string Text { get; set; }
            public Color FontColor { get; set; }
            public int FontSize { get; set; }
            public FontStyle FontStyle { get; set; }
            public FontFamily FontFamily { get; set; }

            public override Image ApplyTransformation(Image image)
            {
                if ((Padding * 2 >= image.Width) || (Padding * 2 >= image.Height))
                {
                    // If padding is too big we don't make any changes. 
                    return image;
                }

                // Get font size and text area that text fits into using fixed size resolution version of the image.
                // This is needed so we create the same size/position text watermark even when images have different
                // resolutions. Otherwise, watermark is slightly different even when text & size arguments are the same.
                int fontSize;
                SizeF textArea;
                using (Bitmap fixedResolutionImage = GetBitmapFromImage(image, image.Width, image.Height, preserveResolution: false))
                {
                    using (Graphics graphics = Graphics.FromImage(fixedResolutionImage))
                    {
                        fontSize = GetBestFontSize(image, graphics, out textArea);
                    }
                }

                int textWidth = (int)Math.Ceiling(textArea.Width);
                int textHeight = (int)Math.Ceiling(textArea.Height);
                Rectangle area = GetRectangleInsideImage(image, textWidth, textHeight);

                // Create new bitmap that only contains text in the right size.
                using (Bitmap textBitmap = new Bitmap(textWidth, textHeight))
                {
                    using (Graphics graphics = Graphics.FromImage(textBitmap))
                    {
                        using (Font font = new Font(FontFamily, fontSize, FontStyle))
                        {
                            using (Brush brushToUse = new SolidBrush(FontColor))
                            {
                                graphics.TextRenderingHint = TextRenderingHint.AntiAlias;
                                graphics.DrawString(Text, font, brushToUse, new PointF(0F, 0F));
                            }
                        }
                    }

                    // Use generated bitmap with text to apply as image watermark.
                    using (Graphics targetGraphics = Graphics.FromImage(image))
                    {
                        AddWatermark(targetGraphics, textBitmap, area, 1f);
                    }
                }

                return image;
            }

            private int GetBestFontSize(Image image, Graphics graphics, out SizeF textArea)
            {
                SizeF layoutArea = new SizeF(image.Width - (Padding * 2), image.Height - (Padding * 2));
                int bestFontSize = FontSize;
                textArea = layoutArea;

                using (StringFormat format = new StringFormat(StringFormatFlags.NoClip | StringFormatFlags.MeasureTrailingSpaces))
                {
                    for (int fontSize = FontSize; fontSize >= 2; fontSize--)
                    {
                        int numChars = 0, numLines = 0;
                        using (Font font = new Font(FontFamily, fontSize, FontStyle))
                        {
                            textArea = graphics.MeasureString(Text, font, layoutArea, format, out numChars, out numLines);
                        }

                        if ((numChars >= Text.Length) && (textArea.Width <= layoutArea.Width) && (textArea.Height <= layoutArea.Height))
                        {
                            // it fits! Exit now
                            return fontSize;
                        }
                        else
                        {
                            bestFontSize = fontSize;
                        }
                    }
                }
                return bestFontSize;
            }
        }

        private abstract class WatermarkTransformation : ImageTransformation
        {
            private static readonly float[][] _identityScalingMatrix =
                {
                    new float[] { 1, 0, 0, 0, 0 },
                    new float[] { 0, 1, 0, 0, 0 },
                    new float[] { 0, 0, 1, 0, 0 },
                    new float[] { 0, 0, 0, 1, 0 },
                    new float[] { 0, 0, 0, 0, 1 }
                };

            public WatermarkTransformation(HorizontalAlign alignX, VerticalAlign alignY, int padding)
            {
                HorizontalAlign = alignX;
                VerticalAlign = alignY;
                Padding = padding;
            }

            public HorizontalAlign HorizontalAlign { get; set; }
            public VerticalAlign VerticalAlign { get; set; }
            public int Padding { get; set; }

            public Rectangle GetRectangleInsideImage(Image image, int width, int height)
            {
                int posX, posY;

                switch (HorizontalAlign)
                {
                    case HorizontalAlign.Left:
                        posX = Padding;
                        break;
                    case HorizontalAlign.Right:
                        posX = image.Width - width - Padding;
                        break;
                    case HorizontalAlign.Center:
                    default:
                        posX = (image.Width - width) / 2;
                        break;
                }
                switch (VerticalAlign)
                {
                    case VerticalAlign.Top:
                        posY = Padding;
                        break;
                    case VerticalAlign.Bottom:
                        posY = image.Height - height - Padding;
                        break;
                    case VerticalAlign.Middle:
                    default:
                        posY = (image.Height - height) / 2;
                        break;
                }

                return new Rectangle(posX, posY, width, height);
            }

            private static float[][] GetScalingMatrix(float alphaScaling)
            {
                if (alphaScaling == 1)
                {
                    return _identityScalingMatrix;
                }

                float[][] scalingMatrix =
                    {
                        new float[] { 1, 0, 0, 0, 0 },
                        new float[] { 0, 1, 0, 0, 0 },
                        new float[] { 0, 0, 1, 0, 0 },
                        new[] { 0, 0, 0, alphaScaling, 0 },
                        new float[] { 0, 0, 0, 0, 1 }
                    };
                return scalingMatrix;
            }

            public static void AddWatermark(Graphics targetGraphics, Image watermark, Rectangle rect, float alphaScaling)
            {
                float[][] scalingMatrix = GetScalingMatrix(alphaScaling);
                ColorMatrix colorMatrix = new ColorMatrix(scalingMatrix);

                using (ImageAttributes imageAtt = new ImageAttributes())
                {
                    imageAtt.SetColorMatrix(colorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Default);
                    targetGraphics.DrawImage(watermark, rect, 0, 0, watermark.Width, watermark.Height, GraphicsUnit.Pixel, imageAtt);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Helpers/WebMail.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Net;
using System.Net.Mail;
using System.Text;
using System.Web.Helpers.Resources;
using System.Web.WebPages.Scope;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Helpers
{
    [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "WebMail", Justification = "The name of this class is consistent with the naming convention followed in other helpers")]
    public static class WebMail
    {
        internal static readonly object SmtpServerKey = new object();
        internal static readonly object SmtpPortKey = new object();
        internal static readonly object SmtpUseDefaultCredentialsKey = new object();
        internal static readonly object EnableSslKey = new object();
        internal static readonly object PasswordKey = new object();
        internal static readonly object UserNameKey = new object();
        internal static readonly object FromKey = new object();
        internal static readonly Lazy<IDictionary<object, object>> SmtpDefaults = new Lazy<IDictionary<object, object>>(ReadSmtpDefaults);

        /// <summary>
        /// MailMessage dictates that headers values that have equivalent properties would be discarded or overwritten. The list of values is available at 
        /// http://msdn.microsoft.com/en-us/library/system.net.mail.mailmessage.aspx
        /// </summary>
        private static readonly Dictionary<string, Action<MailMessage, string>> _actionableHeaders = new Dictionary<string, Action<MailMessage, string>>(StringComparer.OrdinalIgnoreCase)
        {
            { "Bcc", (message, value) => message.Bcc.Add(value) },
            { "Cc", (message, value) => message.CC.Add(value) },
            { "From", (mailMessage, value) =>
            {
                mailMessage.From = new MailAddress(value);
            }
                },
            { "Priority", SetPriority },
            { "Reply-To", (mailMessage, value) =>
            {
                mailMessage.ReplyToList.Add(value);
            }
                },
            { "Sender", (mailMessage, value) =>
            {
                mailMessage.Sender = new MailAddress(value);
            }
                },
            { "To", (mailMessage, value) =>
            {
                mailMessage.To.Add(value);
            }
                },
        };

        ///////////////////////////////////////////////////////////////////////////
        // Public Properties
        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "SmtpServer is more descriptive as compared to the actual argument \"value\"")]
        public static string SmtpServer
        {
            get { return ReadValue<string>(SmtpServerKey); }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "SmtpServer");
                }
                ScopeStorage.CurrentScope[SmtpServerKey] = value;
            }
        }

        public static int SmtpPort
        {
            get { return ReadValue<int>(SmtpPortKey); }
            set { ScopeStorage.CurrentScope[SmtpPortKey] = value; }
        }

        public static string From
        {
            get { return ReadValue<string>(FromKey); }
            set { ScopeStorage.CurrentScope[FromKey] = value; }
        }

        public static bool SmtpUseDefaultCredentials
        {
            get { return ReadValue<bool>(SmtpUseDefaultCredentialsKey); }
            set { ScopeStorage.CurrentScope[SmtpUseDefaultCredentialsKey] = value; }
        }

        public static bool EnableSsl
        {
            get { return ReadValue<bool>(EnableSslKey); }
            set { ScopeStorage.CurrentScope[EnableSslKey] = value; }
        }

        public static string UserName
        {
            get { return ReadValue<string>(UserNameKey); }
            set { ScopeStorage.CurrentScope[UserNameKey] = value; }
        }

        public static string Password
        {
            get { return ReadValue<string>(PasswordKey); }
            set { ScopeStorage.CurrentScope[PasswordKey] = value; }
        }

        public static void Send(string to,
                                string subject,
                                string body,
                                string from = null,
                                string cc = null,
                                IEnumerable<string> filesToAttach = null,
                                bool isBodyHtml = true,
                                IEnumerable<string> additionalHeaders = null,
                                string bcc = null,
                                string contentEncoding = null,
                                string headerEncoding = null,
                                string priority = null,
                                string replyTo = null)
        {
            if (filesToAttach != null)
            {
                foreach (string fileName in filesToAttach)
                {
                    if (String.IsNullOrEmpty(fileName))
                    {
                        throw new ArgumentException(HelpersResources.WebMail_ItemInCollectionIsNull, "filesToAttach");
                    }
                }
            }

            if (additionalHeaders != null)
            {
                foreach (string header in additionalHeaders)
                {
                    if (String.IsNullOrEmpty(header))
                    {
                        throw new ArgumentException(HelpersResources.WebMail_ItemInCollectionIsNull, "additionalHeaders");
                    }
                }
            }

            MailPriority priorityValue = MailPriority.Normal;
            if (!String.IsNullOrEmpty(priority) && !ConversionUtil.TryFromStringToEnum(priority, out priorityValue))
            {
                throw new ArgumentException(HelpersResources.WebMail_InvalidPriority, "priority");
            }

            if (String.IsNullOrEmpty(SmtpServer))
            {
                throw new InvalidOperationException(HelpersResources.WebMail_SmtpServerNotSpecified);
            }

            using (MailMessage message = new MailMessage())
            {
                SetPropertiesOnMessage(message, to, subject, body, from, cc, bcc, replyTo, contentEncoding, headerEncoding, priorityValue,
                                       filesToAttach, isBodyHtml, additionalHeaders);
                using (SmtpClient client = new SmtpClient())
                {
                    SetPropertiesOnClient(client);
                    client.Send(message);
                }
            }
        }

        private static TValue ReadValue<TValue>(object key)
        {
            return (TValue)(ScopeStorage.CurrentScope[key] ?? SmtpDefaults.Value[key]);
        }

        private static IDictionary<object, object> ReadSmtpDefaults()
        {
            Dictionary<object, object> smtpDefaults = new Dictionary<object, object>();
            try
            {
                // Create a new SmtpClient object: this will read config & tell us what the default value is
                using (SmtpClient client = new SmtpClient())
                {
                    smtpDefaults[SmtpServerKey] = client.Host;
                    smtpDefaults[SmtpPortKey] = client.Port;
                    smtpDefaults[EnableSslKey] = client.EnableSsl;
                    smtpDefaults[SmtpUseDefaultCredentialsKey] = client.UseDefaultCredentials;

                    var credentials = client.Credentials as NetworkCredential;
                    if (credentials != null)
                    {
                        smtpDefaults[UserNameKey] = credentials.UserName;
                        smtpDefaults[PasswordKey] = credentials.Password;
                    }
                    else
                    {
                        smtpDefaults[UserNameKey] = null;
                        smtpDefaults[PasswordKey] = null;
                    }
                    using (MailMessage message = new MailMessage())
                    {
                        smtpDefaults[FromKey] = (message.From != null) ? message.From.Address : null;
                    }
                }
            }
            catch (InvalidOperationException)
            {
                // Due to Bug Dev10 PS 337470 ("SmtpClient reports InvalidOperationException when disposed"), we need to ignore the spurious InvalidOperationException
            }
            return smtpDefaults;
        }

        internal static void SetPropertiesOnClient(SmtpClient client)
        {
            // If no value has been assigned to these properties, at the very worst we will simply 
            // write back the values we just read from the SmtpClient
            if (SmtpServer != null)
            {
                client.Host = SmtpServer;
            }
            client.Port = SmtpPort;
            client.UseDefaultCredentials = SmtpUseDefaultCredentials;
            client.EnableSsl = EnableSsl;
            if (!String.IsNullOrEmpty(UserName))
            {
                client.Credentials = new NetworkCredential(UserName, Password);
            }
        }

        internal static void SetPropertiesOnMessage(MailMessage message, string to, string subject,
                                                    string body, string from, string cc, string bcc, string replyTo,
                                                    string contentEncoding, string headerEncoding, MailPriority priority,
                                                    IEnumerable<string> filesToAttach, bool isBodyHtml,
                                                    IEnumerable<string> additionalHeaders)
        {
            message.Subject = subject;
            message.Body = body;
            message.IsBodyHtml = isBodyHtml;

            if (additionalHeaders != null)
            {
                AssignHeaderValues(message, additionalHeaders);
            }

            if (to != null)
            {
                message.To.Add(to);
            }

            if (!String.IsNullOrEmpty(cc))
            {
                message.CC.Add(cc);
            }

            if (!String.IsNullOrEmpty(bcc))
            {
                message.Bcc.Add(bcc);
            }

            if (!String.IsNullOrEmpty(replyTo))
            {
                message.ReplyToList.Add(replyTo);
            }

            if (!String.IsNullOrEmpty(contentEncoding))
            {
                message.BodyEncoding = Encoding.GetEncoding(contentEncoding);
            }

            if (!String.IsNullOrEmpty(headerEncoding))
            {
                message.HeadersEncoding = Encoding.GetEncoding(headerEncoding);
            }

            message.Priority = priority;

            if (from != null)
            {
                message.From = new MailAddress(from);
            }
            else if (!String.IsNullOrEmpty(From))
            {
                message.From = new MailAddress(From);
            }
            else if (message.From == null || String.IsNullOrEmpty(message.From.Address))
            {
                var httpContext = HttpContext.Current;
                if (httpContext != null)
                {
                    message.From = new MailAddress("DoNotReply@" + httpContext.Request.Url.Host);
                }
                else
                {
                    throw new InvalidOperationException(HelpersResources.WebMail_UnableToDetermineFrom);
                }
            }

            if (filesToAttach != null)
            {
                foreach (string file in filesToAttach)
                {
                    if (!Path.IsPathRooted(file) && HttpRuntime.AppDomainAppPath != null)
                    {
                        message.Attachments.Add(new Attachment(Path.Combine(HttpRuntime.AppDomainAppPath, file)));
                    }
                    else
                    {
                        message.Attachments.Add(new Attachment(file));
                    }
                }
            }
        }

        internal static void AssignHeaderValues(MailMessage message, IEnumerable<string> headerValues)
        {
            // Parse the header value. If this 
            foreach (var header in headerValues)
            {
                string key, value;
                if (TryParseHeader(header, out key, out value))
                {
                    // Verify if the header key maps to a property on MailMessage. 
                    Action<MailMessage, string> action;
                    if (_actionableHeaders.TryGetValue(key, out action))
                    {
                        try
                        {
                            action(message, value);
                        }
                        catch (FormatException)
                        {
                            // If the mail address is invalid, swallow the exception.
                        }
                    }
                    message.Headers.Add(key, value);
                }
            }
        }

        /// <summary>
        /// Parses a SMTP Mail header of the format "name: value"
        /// </summary>
        /// <returns>True if the header was parsed.</returns>
        internal static bool TryParseHeader(string header, out string key, out string value)
        {
            int pos = header.IndexOf(':');
            if (pos > 0)
            {
                key = header.Substring(0, pos).TrimEnd();
                value = header.Substring(pos + 1).TrimStart();
                return key.Length > 0 && value.Length > 0;
            }
            key = null;
            value = null;
            return false;
        }

        private static void SetPriority(MailMessage message, string priority)
        {
            MailPriority priorityValue;
            if (!String.IsNullOrEmpty(priority) && ConversionUtil.TryFromStringToEnum(priority, out priorityValue))
            {
                // If we can parse it, set it. Do nothing otherwise
                message.Priority = priorityValue;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/AcceptVerbsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies what HTTP methods an action supports.
    /// </summary>
    [SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification = "The accessor is exposed as an Collection<HttpMethod>.")]
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class AcceptVerbsAttribute : Attribute, IActionHttpMethodProvider
    {
        private readonly Collection<HttpMethod> _httpMethods;

        /// <summary>
        /// Initializes a new instance of the <see cref="AcceptVerbsAttribute" /> class.        
        /// </summary>
        /// <param name="method">The HTTP method the action supports.</param>
        /// <remarks>
        /// This is a CLS compliant constructor.
        /// </remarks>
        public AcceptVerbsAttribute(string method)
            : this(new string[] { method })
        {
        }
        
        /// <summary>
        /// Initializes a new instance of the <see cref="AcceptVerbsAttribute" /> class.
        /// </summary>
        /// <param name="methods">The HTTP methods the action supports.</param>
        /// <remarks>
        /// This constructor is not CLS-compliant.
        /// </remarks>
        public AcceptVerbsAttribute(params string[] methods)
        {
            _httpMethods = methods != null
                                   ? new Collection<HttpMethod>(methods.Select(method => HttpMethodHelper.GetHttpMethod(method)).ToArray())
                                   : new Collection<HttpMethod>(new HttpMethod[0]);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="AcceptVerbsAttribute" /> class.
        /// </summary>
        /// <param name="methods">The HTTP methods the action supports.</param>
        internal AcceptVerbsAttribute(params HttpMethod[] methods)
        {
            _httpMethods = new Collection<HttpMethod>(methods);
        }

        /// <summary>
        /// Gets the HTTP methods the action supports.
        /// </summary>
        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _httpMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ActionNameAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class ActionNameAttribute : Attribute
    {
        public ActionNameAttribute(string name)
        {
            Name = name;
        }

        public string Name { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/AllowAnonymousAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    /// <summary>
    /// Actions and controllers marked with this attribute are skipped by <see cref="AuthorizeAttribute"/> during authorization.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = false)]
    public sealed class AllowAnonymousAttribute : Attribute
    {
    }
}


================================================
FILE: src/System.Web.Http/ApiController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Security.Principal;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Filters;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;
using System.Web.Http.Results;
using System.Web.Http.Routing;
using System.Web.Http.Validation;
using Newtonsoft.Json;

namespace System.Web.Http
{
    public abstract class ApiController : IHttpController, IDisposable
    {
        private HttpActionContext _actionContext = new HttpActionContext();
        private bool _initialized;

        /// <summary>Gets the configuration.</summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public HttpConfiguration Configuration
        {
            get { return ControllerContext.Configuration; }
            set { ControllerContext.Configuration = value; }
        }

        /// <summary>Gets the controller context.</summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public HttpControllerContext ControllerContext
        {
            get
            {
                // unit test only
                if (ActionContext.ControllerContext == null)
                {
                    ActionContext.ControllerContext = new HttpControllerContext
                    {
                        RequestContext = new RequestBackedHttpRequestContext()
                    };
                }
                return ActionContext.ControllerContext;
            }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                ActionContext.ControllerContext = value;
            }
        }

        /// <summary>Gets the action context.</summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public HttpActionContext ActionContext
        {
            get { return _actionContext; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _actionContext = value;
            }
        }

        /// <summary>
        /// Gets model state after the model binding process. This ModelState will be empty before model binding happens.
        /// </summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public ModelStateDictionary ModelState
        {
            get
            {
                return ActionContext.ModelState;
            }
        }

        /// <summary>Gets or sets the HTTP request message.</summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public HttpRequestMessage Request
        {
            get
            {
                return ControllerContext.Request;
            }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                HttpRequestContext contextOnRequest = value.GetRequestContext();
                HttpRequestContext contextOnController = RequestContext;

                if (contextOnRequest != null && contextOnRequest != contextOnController)
                {
                    // Prevent unit testers from setting conflicting requests contexts.
                    throw new InvalidOperationException(SRResources.RequestContextConflict);
                }

                ControllerContext.Request = value;
                value.SetRequestContext(contextOnController);

                RequestBackedHttpRequestContext requestBackedContext =
                    contextOnController as RequestBackedHttpRequestContext;

                if (requestBackedContext != null)
                {
                    requestBackedContext.Request = value;
                }
            }
        }

        /// <summary>Gets the request context.</summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public HttpRequestContext RequestContext
        {
            get
            {
                return ControllerContext.RequestContext;
            }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                HttpRequestContext oldContext = ControllerContext.RequestContext;
                HttpRequestMessage request = Request;

                if (request != null)
                {
                    HttpRequestContext contextOnRequest = request.GetRequestContext();

                    if (contextOnRequest != null && contextOnRequest != oldContext && contextOnRequest != value)
                    {
                        // Prevent unit testers from setting conflicting requests contexts.
                        throw new InvalidOperationException(SRResources.RequestContextConflict);
                    }

                    request.SetRequestContext(value);
                }

                ControllerContext.RequestContext = value;
            }
        }

        /// <summary>Gets a factory used to generate URLs to other APIs.</summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public UrlHelper Url
        {
            get { return RequestContext.Url; }
            set { RequestContext.Url = value; }
        }

        /// <summary>Gets or sets the current principal associated with this request.</summary>
        /// <remarks>The setter is intended for unit testing purposes only.</remarks>
        public IPrincipal User
        {
            get { return RequestContext.Principal; }
            set { RequestContext.Principal = value; }
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "This method is a coordinator, so this coupling is expected.")]
        public virtual Task<HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
        {
            if (_initialized)
            {
                // if user has registered a controller factory which produces the same controller instance, we should throw here
                throw Error.InvalidOperation(SRResources.CannotSupportSingletonInstance, typeof(ApiController).Name, typeof(IHttpControllerActivator).Name);
            }

            Initialize(controllerContext);

            // We can't be reused, and we know we're disposable, so make sure we go away when
            // the request has been completed.
            if (Request != null)
            {
                Request.RegisterForDispose(this);
            }

            HttpControllerDescriptor controllerDescriptor = controllerContext.ControllerDescriptor;
            ServicesContainer controllerServices = controllerDescriptor.Configuration.Services;

            HttpActionDescriptor actionDescriptor = controllerServices.GetActionSelector().SelectAction(controllerContext);
            ActionContext.ActionDescriptor = actionDescriptor;
            if (Request != null)
            {
                Request.SetActionDescriptor(actionDescriptor);
            }

            FilterGrouping filterGrouping = actionDescriptor.GetFilterGrouping();

            IActionFilter[] actionFilters = filterGrouping.ActionFilters;
            IAuthenticationFilter[] authenticationFilters = filterGrouping.AuthenticationFilters;
            IAuthorizationFilter[] authorizationFilters = filterGrouping.AuthorizationFilters;
            IExceptionFilter[] exceptionFilters = filterGrouping.ExceptionFilters;

            IHttpActionResult result = new ActionFilterResult(actionDescriptor.ActionBinding, ActionContext,
                controllerServices, actionFilters);
            if (authorizationFilters.Length > 0)
            {
                result = new AuthorizationFilterResult(ActionContext, authorizationFilters, result);
            }
            if (authenticationFilters.Length > 0)
            {
                result = new AuthenticationFilterResult(ActionContext, this, authenticationFilters, result);
            }
            if (exceptionFilters.Length > 0)
            {
                IExceptionLogger exceptionLogger = ExceptionServices.GetLogger(controllerServices);
                IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(controllerServices);
                result = new ExceptionFilterResult(ActionContext, exceptionFilters, exceptionLogger, exceptionHandler,
                    result);
            }

            return result.ExecuteAsync(cancellationToken);
        }

        /// <summary>
        /// Validates the given entity and adds the validation errors to the <see cref="ApiController.ModelState"/>
        /// under the empty prefix, if any.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity to be validated.</typeparam>
        /// <param name="entity">The entity being validated.</param>
        public void Validate<TEntity>(TEntity entity)
        {
            Validate(entity, keyPrefix: String.Empty);
        }

        /// <summary>
        /// Validates the given entity and adds the validation errors to the <see cref="ApiController.ModelState"/>, if any.
        /// </summary>
        /// <typeparam name="TEntity">The type of the entity to be validated.</typeparam>
        /// <param name="entity">The entity being validated.</param>
        /// <param name="keyPrefix">
        /// The key prefix under which the model state errors would be added in the <see cref="ApiController.ModelState"/>.
        /// </param>
        public void Validate<TEntity>(TEntity entity, string keyPrefix)
        {
            if (Configuration == null)
            {
                throw Error.InvalidOperation(SRResources.TypePropertyMustNotBeNull, typeof(ApiController).Name, "Configuration");
            }

            IBodyModelValidator validator = Configuration.Services.GetBodyModelValidator();
            if (validator != null)
            {
                ModelMetadataProvider metadataProvider = Configuration.Services.GetModelMetadataProvider();
                Contract.Assert(metadataProvider != null, "GetModelMetadataProvider throws on null.");

                validator.Validate(entity, typeof(TEntity), metadataProvider, ActionContext, keyPrefix);
            }
        }

        /// <summary>Creates a <see cref="BadRequestResult"/> (400 Bad Request).</summary>
        /// <returns>A <see cref="BadRequestResult"/>.</returns>
        protected internal virtual BadRequestResult BadRequest()
        {
            return new BadRequestResult(this);
        }

        /// <summary>
        /// Creates a <see cref="BadRequestErrorMessageResult"/> (400 Bad Request) with the specified error message.
        /// </summary>
        /// <param name="message">The user-visible error message.</param>
        /// <returns>A <see cref="BadRequestErrorMessageResult"/> with the specified error message.</returns>
        protected internal virtual BadRequestErrorMessageResult BadRequest(string message)
        {
            return new BadRequestErrorMessageResult(message, this);
        }

        /// <summary>
        /// Creates an <see cref="InvalidModelStateResult"/> (400 Bad Request) with the specified model state.
        /// </summary>
        /// <param name="modelState">The model state to include in the error.</param>
        /// <returns>An <see cref="InvalidModelStateResult"/> with the specified model state.</returns>
        protected internal virtual InvalidModelStateResult BadRequest(ModelStateDictionary modelState)
        {
            return new InvalidModelStateResult(modelState, this);
        }

        /// <summary>Creates a <see cref="ConflictResult"/> (409 Conflict).</summary>
        /// <returns>A <see cref="ConflictResult"/>.</returns>
        protected internal virtual ConflictResult Conflict()
        {
            return new ConflictResult(this);
        }

        /// <summary>Creates a <see cref="NegotiatedContentResult{T}"/> with the specified values.</summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="value">The content value to negotiate and format in the entity body.</param>
        /// <returns>A <see cref="NegotiatedContentResult{T}"/> with the specified values.</returns>
        protected internal virtual NegotiatedContentResult<T> Content<T>(HttpStatusCode statusCode, T value)
        {
            return new NegotiatedContentResult<T>(statusCode, value, this);
        }

        /// <summary>Creates a <see cref="FormattedContentResult{T}"/> with the specified values.</summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="value">The content value to format in the entity body.</param>
        /// <param name="formatter">The formatter to use to format the content.</param>
        /// <returns>A <see cref="FormattedContentResult{T}"/> with the specified values.</returns>
        protected internal FormattedContentResult<T> Content<T>(HttpStatusCode statusCode, T value,
            MediaTypeFormatter formatter)
        {
            return Content(statusCode, value, formatter, (MediaTypeHeaderValue)null);
        }

        /// <summary>Creates a <see cref="FormattedContentResult{T}"/> with the specified values.</summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="value">The content value to format in the entity body.</param>
        /// <param name="formatter">The formatter to use to format the content.</param>
        /// <param name="mediaType">The value for the Content-Type header.</param>
        /// <returns>A <see cref="FormattedContentResult{T}"/> with the specified values.</returns>
        protected internal FormattedContentResult<T> Content<T>(HttpStatusCode statusCode, T value,
            MediaTypeFormatter formatter, string mediaType)
        {
            return Content(statusCode, value, formatter, new MediaTypeHeaderValue(mediaType));
        }

        /// <summary>Creates a <see cref="FormattedContentResult{T}"/> with the specified values.</summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="value">The content value to format in the entity body.</param>
        /// <param name="formatter">The formatter to use to format the content.</param>
        /// <param name="mediaType">
        /// The value for the Content-Type header, or <see langword="null"/> to have the formatter pick a default
        /// value.
        /// </param>
        /// <returns>A <see cref="FormattedContentResult{T}"/> with the specified values.</returns>
        protected internal virtual FormattedContentResult<T> Content<T>(HttpStatusCode statusCode, T value,
            MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
        {
            return new FormattedContentResult<T>(statusCode, value, formatter, mediaType, this);
        }

        /// <summary>
        /// Creates a <see cref="CreatedNegotiatedContentResult{T}"/> (201 Created) with the specified values.
        /// </summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="location">
        /// The location at which the content has been created. Must be a relative or absolute URL.
        /// </param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <returns>A <see cref="CreatedNegotiatedContentResult{T}"/> with the specified values.</returns>
        protected internal CreatedNegotiatedContentResult<T> Created<T>(string location, T content)
        {
            if (location == null)
            {
                throw new ArgumentNullException("location");
            }

            return Created<T>(new Uri(location, UriKind.RelativeOrAbsolute), content);
        }

        /// <summary>
        /// Creates a <see cref="CreatedNegotiatedContentResult{T}"/> (201 Created) with the specified values.
        /// </summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="location">The location at which the content has been created.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <returns>A <see cref="CreatedNegotiatedContentResult{T}"/> with the specified values.</returns>
        protected internal virtual CreatedNegotiatedContentResult<T> Created<T>(Uri location, T content)
        {
            return new CreatedNegotiatedContentResult<T>(location, content, this);
        }

        /// <summary>
        /// Creates a <see cref="CreatedAtRouteNegotiatedContentResult{T}"/> (201 Created) with the specified values.
        /// </summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <returns>A <see cref="CreatedAtRouteNegotiatedContentResult{T}"/> with the specified values.</returns>
        protected internal CreatedAtRouteNegotiatedContentResult<T> CreatedAtRoute<T>(string routeName,
            object routeValues, T content)
        {
            return CreatedAtRoute<T>(routeName, new HttpRouteValueDictionary(routeValues), content);
        }

        /// <summary>
        /// Creates a <see cref="CreatedAtRouteNegotiatedContentResult{T}"/> (201 Created) with the specified values.
        /// </summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <returns>A <see cref="CreatedAtRouteNegotiatedContentResult{T}"/> with the specified values.</returns>
        protected internal virtual CreatedAtRouteNegotiatedContentResult<T> CreatedAtRoute<T>(string routeName,
            IDictionary<string, object> routeValues, T content)
        {
            return new CreatedAtRouteNegotiatedContentResult<T>(routeName, routeValues, content, this);
        }

        /// <summary>Creates an <see cref="InternalServerErrorResult"/> (500 Internal Server Error).</summary>
        /// <returns>A <see cref="InternalServerErrorResult"/>.</returns>
        protected internal virtual InternalServerErrorResult InternalServerError()
        {
            return new InternalServerErrorResult(this);
        }

        /// <summary>
        /// Creates an <see cref="ExceptionResult"/> (500 Internal Server Error) with the specified exception.
        /// </summary>
        /// <param name="exception">The exception to include in the error.</param>
        /// <returns>An <see cref="ExceptionResult"/> with the specified exception.</returns>
        protected internal virtual ExceptionResult InternalServerError(Exception exception)
        {
            return new ExceptionResult(exception, this);
        }

        /// <summary>Creates a <see cref="JsonResult{T}"/> (200 OK) with the specified value.</summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="content">The content value to serialize in the entity body.</param>
        /// <returns>A <see cref="JsonResult{T}"/> with the specified value.</returns>
        protected internal JsonResult<T> Json<T>(T content)
        {
            return Json<T>(content, new JsonSerializerSettings());
        }

        /// <summary>Creates a <see cref="JsonResult{T}"/> (200 OK) with the specified values.</summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="content">The content value to serialize in the entity body.</param>
        /// <param name="serializerSettings">The serializer settings.</param>
        /// <returns>A <see cref="JsonResult{T}"/> with the specified values.</returns>
        protected internal JsonResult<T> Json<T>(T content, JsonSerializerSettings serializerSettings)
        {
            return Json<T>(content, serializerSettings, new UTF8Encoding(encoderShouldEmitUTF8Identifier: false,
                throwOnInvalidBytes: true));
        }

        /// <summary>Creates a <see cref="JsonResult{T}"/> (200 OK) with the specified values.</summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="content">The content value to serialize in the entity body.</param>
        /// <param name="serializerSettings">The serializer settings.</param>
        /// <param name="encoding">The content encoding.</param>
        /// <returns>A <see cref="JsonResult{T}"/> with the specified values.</returns>
        protected internal virtual JsonResult<T> Json<T>(T content, JsonSerializerSettings serializerSettings,
            Encoding encoding)
        {
            return new JsonResult<T>(content, serializerSettings, encoding, this);
        }

        /// <summary>Creates a <see cref="NotFoundResult"/> (404 Not Found).</summary>
        /// <returns>A <see cref="NotFoundResult"/>.</returns>
        protected internal virtual NotFoundResult NotFound()
        {
            return new NotFoundResult(this);
        }

        /// <summary>Creates an <see cref="OkResult"/> (200 OK).</summary>
        /// <returns>An <see cref="OkResult"/>.</returns>
        protected internal virtual OkResult Ok()
        {
            return new OkResult(this);
        }

        /// <summary>
        /// Creates an <see cref="OkNegotiatedContentResult{T}"/> (200 OK) with the specified values.
        /// </summary>
        /// <typeparam name="T">The type of content in the entity body.</typeparam>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <returns>An <see cref="OkNegotiatedContentResult{T}"/> with the specified values.</returns>
        protected internal virtual OkNegotiatedContentResult<T> Ok<T>(T content)
        {
            return new OkNegotiatedContentResult<T>(content, this);
        }

        /// <summary>Creates a <see cref="RedirectResult"/> (302 Found) with the specified value.</summary>
        /// <param name="location">The location to which to redirect.</param>
        /// <returns>A <see cref="RedirectResult"/> with the specified value.</returns>
        protected internal virtual RedirectResult Redirect(string location)
        {
            if (location == null)
            {
                throw new ArgumentNullException("location");
            }

            return Redirect(new Uri(location));
        }

        /// <summary>Creates a <see cref="RedirectResult"/> (302 Found) with the specified value.</summary>
        /// <param name="location">The location to which to redirect.</param>
        /// <returns>A <see cref="RedirectResult"/> with the specified value.</returns>
        protected internal virtual RedirectResult Redirect(Uri location)
        {
            return new RedirectResult(location, this);
        }

        /// <summary>Creates a <see cref="RedirectToRouteResult"/> (302 Found) with the specified values.</summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <returns>A <see cref="RedirectToRouteResult"/> with the specified values.</returns>
        protected internal RedirectToRouteResult RedirectToRoute(string routeName, object routeValues)
        {
            return RedirectToRoute(routeName, new HttpRouteValueDictionary(routeValues));
        }

        /// <summary>Creates a <see cref="RedirectToRouteResult"/> (302 Found) with the specified values.</summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <returns>A <see cref="RedirectToRouteResult"/> with the specified values.</returns>
        protected internal virtual RedirectToRouteResult RedirectToRoute(string routeName,
            IDictionary<string, object> routeValues)
        {
            return new RedirectToRouteResult(routeName, routeValues, this);
        }

        /// <summary>Creates a <see cref="ResponseMessageResult"/> with the specified response.</summary>
        /// <param name="response">The HTTP response message.</param>
        /// <returns>A <see cref="ResponseMessageResult"/> for the specified response.</returns>
        protected internal virtual ResponseMessageResult ResponseMessage(HttpResponseMessage response)
        {
            return new ResponseMessageResult(response);
        }

        /// <summary>Creates a <see cref="StatusCodeResult"/> with the specified status code.</summary>
        /// <param name="status">The HTTP status code for the response message</param>
        /// <returns>A <see cref="StatusCodeResult"/> with the specified status code.</returns>
        protected internal virtual StatusCodeResult StatusCode(HttpStatusCode status)
        {
            return new StatusCodeResult(status, this);
        }

        /// <summary>
        /// Creates an <see cref="UnauthorizedResult"/> (401 Unauthorized) with the specified values.
        /// </summary>
        /// <param name="challenges">The WWW-Authenticate challenges.</param>
        /// <returns>An <see cref="UnauthorizedResult"/> with the specified values.</returns>
        protected internal UnauthorizedResult Unauthorized(params AuthenticationHeaderValue[] challenges)
        {
            return Unauthorized((IEnumerable<AuthenticationHeaderValue>)challenges);
        }

        /// <summary>
        /// Creates an <see cref="UnauthorizedResult"/> (401 Unauthorized) with the specified values.
        /// </summary>
        /// <param name="challenges">The WWW-Authenticate challenges.</param>
        /// <returns>An <see cref="UnauthorizedResult"/> with the specified values.</returns>
        protected internal virtual UnauthorizedResult Unauthorized(IEnumerable<AuthenticationHeaderValue> challenges)
        {
            return new UnauthorizedResult(challenges, this);
        }

        protected virtual void Initialize(HttpControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            _initialized = true;
            ControllerContext = controllerContext;
        }

        #region IDisposable

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
        }

        #endregion IDisposable
    }
}

================================================
FILE: src/System.Web.Http/AuthorizeAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Principal;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Properties;

namespace System.Web.Http
{
    /// <summary>
    /// An authorization filter that verifies the request's <see cref="IPrincipal"/>.
    /// </summary>
    /// <remarks>You can declare multiple of these attributes per action. You can also use <see cref="AllowAnonymousAttribute"/>
    /// to disable authorization for a specific action.</remarks>
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "We want to support extensibility")]
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = true, AllowMultiple = true)]
    public class AuthorizeAttribute : AuthorizationFilterAttribute
    {
        private static readonly string[] _emptyArray = new string[0];

        private readonly object _typeId = new object();

        private string _roles;
        private string[] _rolesSplit = _emptyArray;
        private string _users;
        private string[] _usersSplit = _emptyArray;

        /// <summary>
        /// Gets or sets the authorized roles.
        /// </summary>
        /// <value>
        /// The roles string.
        /// </value>
        /// <remarks>Multiple role names can be specified using the comma character as a separator.</remarks>
        public string Roles
        {
            get { return _roles ?? String.Empty; }
            set
            {
                _roles = value;
                _rolesSplit = SplitString(value);
            }
        }

        /// <summary>
        /// Gets a unique identifier for this <see cref="T:System.Attribute"/>.
        /// </summary>
        /// <returns>The unique identifier for the attribute.</returns>
        public override object TypeId
        {
            get { return _typeId; }
        }

        /// <summary>
        /// Gets or sets the authorized users.
        /// </summary>
        /// <value>
        /// The users string.
        /// </value>
        /// <remarks>Multiple role names can be specified using the comma character as a separator.</remarks>
        public string Users
        {
            get { return _users ?? String.Empty; }
            set
            {
                _users = value;
                _usersSplit = SplitString(value);
            }
        }

        /// <summary>
        /// Determines whether access for this particular request is authorized. This method uses the user <see cref="IPrincipal"/>
        /// returned via <see cref="HttpRequestContext.Principal"/>. Authorization is denied if the user is not authenticated,
        /// the user is not in the authorized group of <see cref="Users"/> (if defined), or if the user is not in any of the authorized 
        /// <see cref="Roles"/> (if defined).
        /// </summary>
        /// <param name="actionContext">The context.</param>
        /// <returns><c>true</c> if access is authorized; otherwise <c>false</c>.</returns>
        protected virtual bool IsAuthorized(HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            IPrincipal user = actionContext.ControllerContext.RequestContext.Principal;
            if (user == null || user.Identity == null || !user.Identity.IsAuthenticated)
            {
                return false;
            }

            if (_usersSplit.Length > 0 && !_usersSplit.Contains(user.Identity.Name, StringComparer.OrdinalIgnoreCase))
            {
                return false;
            }

            if (_rolesSplit.Length > 0 && !_rolesSplit.Any(user.IsInRole))
            {
                return false;
            }

            return true;
        }

        /// <summary>
        /// Called when an action is being authorized. This method uses the user <see cref="IPrincipal"/>
        /// returned via <see cref="HttpRequestContext.Principal"/>. Authorization is denied if
        /// - the request is not associated with any user.
        /// - the user is not authenticated,
        /// - the user is authenticated but is not in the authorized group of <see cref="Users"/> (if defined), or if the user
        /// is not in any of the authorized <see cref="Roles"/> (if defined).
        /// 
        /// If authorization is denied then this method will invoke <see cref="HandleUnauthorizedRequest(HttpActionContext)"/> to process the unauthorized request.
        /// </summary>
        /// <remarks>You can use <see cref="AllowAnonymousAttribute"/> to cause authorization checks to be skipped for a particular
        /// action or controller.</remarks>
        /// <seealso cref="IsAuthorized(HttpActionContext)" />
        /// <param name="actionContext">The context.</param>
        /// <exception cref="ArgumentNullException">The context parameter is null.</exception>
        public override void OnAuthorization(HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            if (SkipAuthorization(actionContext))
            {
                return;
            }

            if (!IsAuthorized(actionContext))
            {
                HandleUnauthorizedRequest(actionContext);
            }
        }

        /// <summary>
        /// Processes requests that fail authorization. This default implementation creates a new response with the
        /// Unauthorized status code. Override this method to provide your own handling for unauthorized requests.
        /// </summary>
        /// <param name="actionContext">The context.</param>
        protected virtual void HandleUnauthorizedRequest(HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            actionContext.Response = actionContext.ControllerContext.Request.CreateErrorResponse(HttpStatusCode.Unauthorized, SRResources.RequestNotAuthorized);
        }

        private static bool SkipAuthorization(HttpActionContext actionContext)
        {
            Contract.Assert(actionContext != null);

            return actionContext.ActionDescriptor.GetCustomAttributes<AllowAnonymousAttribute>().Any()
                   || actionContext.ControllerContext.ControllerDescriptor.GetCustomAttributes<AllowAnonymousAttribute>().Any();
        }

        /// <summary>
        /// Splits the string on commas and removes any leading/trailing whitespace from each result item.
        /// </summary>
        /// <param name="original">The input string.</param>
        /// <returns>An array of strings parsed from the input <paramref name="original"/> string.</returns>
        internal static string[] SplitString(string original)
        {
            if (String.IsNullOrEmpty(original))
            {
                return _emptyArray;
            }

            var split = from piece in original.Split(',')
                        let trimmed = piece.Trim()
                        where !String.IsNullOrEmpty(trimmed)
                        select trimmed;
            return split.ToArray();
        }
    }
}


================================================
FILE: src/System.Web.Http/Batch/BatchExecutionOrder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Batch
{
    /// <summary>
    /// Defines the order of execution for batch requests.
    /// </summary>
    public enum BatchExecutionOrder
    {
        /// <summary>
        /// Executes the batch requests sequentially.
        /// </summary>
        Sequential = 0,

        /// <summary>
        /// Executes the batch requests non-sequentially.
        /// </summary>
        NonSequential
    }
}

================================================
FILE: src/System.Web.Http/Batch/BatchHttpRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;

namespace System.Web.Http.Batch
{
    internal class BatchHttpRequestContext : HttpRequestContext
    {
        private readonly HttpRequestContext _batchContext;

        public BatchHttpRequestContext(HttpRequestContext batchContext)
        {
            if (batchContext == null)
            {
                throw new ArgumentNullException("batchContext");
            }

            _batchContext = batchContext;
        }

        public HttpRequestContext BatchContext
        {
            get { return _batchContext; }
        }

        public override X509Certificate2 ClientCertificate
        {
            get
            {
                return _batchContext.ClientCertificate;
            }
            set
            {
                _batchContext.ClientCertificate = value;
            }
        }

        public override HttpConfiguration Configuration
        {
            get
            {
                // Use separate route data for configuration (base, not _batchContext).
                return base.Configuration;
            }
            set
            {
                // Use separate route data for configuration (base, not _batchContext).
                base.Configuration = value;
            }
        }

        public override bool IncludeErrorDetail
        {
            get
            {
                return _batchContext.IncludeErrorDetail;
            }
            set
            {
                _batchContext.IncludeErrorDetail = value;
            }
        }

        public override bool IsLocal
        {
            get
            {
                return _batchContext.IsLocal;
            }
            set
            {
                _batchContext.IsLocal = value;
            }
        }

        public override IPrincipal Principal
        {
            get
            {
                return _batchContext.Principal;
            }
            set
            {
                _batchContext.Principal = value;
            }
        }

        public override IHttpRouteData RouteData
        {
            get
            {
                // Use separate route data for batching (base, not _batchContext).
                return base.RouteData;
            }
            set
            {
                // Use separate route data for batching (base, not _batchContext).
                base.RouteData = value;
            }
        }

        public override UrlHelper Url
        {
            get
            {
                // Use a separate URL factory for batching (base, not _batchContext).
                return base.Url;
            }
            set
            {
                // Use a separate URL factory for batching (base, not _batchContext).
                base.Url = value;
            }
        }

        public override string VirtualPathRoot
        {
            get
            {
                return _batchContext.VirtualPathRoot;
            }
            set
            {
                _batchContext.VirtualPathRoot = value;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Batch/BatchHttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;

namespace System.Web.Http.Batch
{
    /// <summary>
    /// Provides extension methods for the <see cref="HttpRequestMessage"/> class.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class BatchHttpRequestMessageExtensions
    {
        private const string HttpBatchContextKey = "MS_HttpBatchContext";

        private static readonly string[] BatchRequestPropertyExclusions =
        {
            HttpPropertyKeys.HttpRouteDataKey,
            HttpPropertyKeys.DisposableRequestResourcesKey,
            HttpPropertyKeys.SynchronizationContextKey,
            HttpPropertyKeys.HttpConfigurationKey,
            HttpRoute.RoutingContextKey,
            HttpBatchContextKey
        };

        /// <summary>
        /// Copies the properties from another <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="subRequest">The sub-request.</param>
        /// <param name="batchRequest">The batch request that contains the properties to copy.</param>
        public static void CopyBatchRequestProperties(this HttpRequestMessage subRequest, HttpRequestMessage batchRequest)
        {
            if (subRequest == null)
            {
                throw new ArgumentNullException("subRequest");
            }
            if (batchRequest == null)
            {
                throw new ArgumentNullException("batchRequest");
            }

            foreach (KeyValuePair<string, object> property in batchRequest.Properties)
            {
                if (!BatchRequestPropertyExclusions.Contains(property.Key))
                {
                    subRequest.Properties.Add(property);
                }
            }

            HttpRequestContext originalContext = subRequest.GetRequestContext();

            if (originalContext != null)
            {
                BatchHttpRequestContext subRequestContext = new BatchHttpRequestContext(originalContext)
                {
                    Url = new UrlHelper(subRequest)
                };

                subRequest.SetRequestContext(subRequestContext);
            }
        }
    }
}

================================================
FILE: src/System.Web.Http/Batch/DefaultHttpBatchHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.Batch
{
    /// <summary>
    /// Default implementation of <see cref="HttpBatchHandler"/> that encodes the HTTP request/response messages as MIME multipart.
    /// </summary>
    /// <remarks>
    /// By default, it buffers the HTTP request messages in memory during parsing.
    /// </remarks>
    public class DefaultHttpBatchHandler : HttpBatchHandler
    {
        private const string MultiPartContentSubtype = "mixed";
        private const string MultiPartMixed = "multipart/mixed";
        private BatchExecutionOrder _executionOrder;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultHttpBatchHandler"/> class.
        /// </summary>
        /// <param name="httpServer">The <see cref="HttpServer"/> for handling the individual batch requests.</param>
        public DefaultHttpBatchHandler(HttpServer httpServer)
            : base(httpServer)
        {
            ExecutionOrder = BatchExecutionOrder.Sequential;
            SupportedContentTypes = new List<string>() { MultiPartMixed };
        }

        /// <summary>
        /// Gets or sets the execution order for the batch requests. The default execution order is sequential.
        /// </summary>
        /// <exception cref="System.ComponentModel.InvalidEnumArgumentException">value</exception>
        public BatchExecutionOrder ExecutionOrder
        {
            get
            {
                return _executionOrder;
            }
            set
            {
                if (!Enum.IsDefined(typeof(BatchExecutionOrder), value))
                {
                    throw new InvalidEnumArgumentException("value", (int)value, typeof(BatchExecutionOrder));
                }
                _executionOrder = value;
            }
        }

        /// <summary>
        /// Gets the supported content types for the batch request.
        /// </summary>
        public IList<string> SupportedContentTypes { get; private set; }

        /// <summary>
        /// Creates the batch response message.
        /// </summary>
        /// <param name="responses">The responses for the batch requests.</param>
        /// <param name="request">The original request containing all the batch requests.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>The batch response message.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller is responsible for disposing the object.")]
        public virtual Task<HttpResponseMessage> CreateResponseMessageAsync(IList<HttpResponseMessage> responses, HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (responses == null)
            {
                throw Error.ArgumentNull("responses");
            }
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            MultipartContent batchContent = new MultipartContent(MultiPartContentSubtype);

            foreach (HttpResponseMessage batchResponse in responses)
            {
                batchContent.Add(new HttpMessageContent(batchResponse));
            }

            HttpResponseMessage response = request.CreateResponse();
            response.Content = batchContent;
            return Task.FromResult(response);
        }

        /// <inheritdoc/>
        public override async Task<HttpResponseMessage> ProcessBatchAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            ValidateRequest(request);

            IList<HttpRequestMessage> subRequests = await ParseBatchRequestsAsync(request, cancellationToken);

            try
            {
                IList<HttpResponseMessage> responses = await ExecuteRequestMessagesAsync(subRequests, cancellationToken);
                return await CreateResponseMessageAsync(responses, request, cancellationToken);
            }
            finally
            {
                foreach (HttpRequestMessage subRequest in subRequests)
                {
                    request.RegisterForDispose(subRequest.GetResourcesForDisposal());
                    request.RegisterForDispose(subRequest);
                }
            }
        }

        /// <summary>
        /// Executes the batch request messages.
        /// </summary>
        /// <param name="requests">The collection of batch request messages.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A collection of <see cref="HttpResponseMessage"/> for the batch requests.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "We need to return a collection of response messages asynchronously.")]
        public virtual async Task<IList<HttpResponseMessage>> ExecuteRequestMessagesAsync(IEnumerable<HttpRequestMessage> requests, CancellationToken cancellationToken)
        {
            if (requests == null)
            {
                throw Error.ArgumentNull("requests");
            }

            List<HttpResponseMessage> responses = new List<HttpResponseMessage>();

            try
            {
                switch (ExecutionOrder)
                {
                    case BatchExecutionOrder.Sequential:
                        foreach (HttpRequestMessage request in requests)
                        {
                            responses.Add(await Invoker.SendAsync(request, cancellationToken));
                        }
                        break;

                    case BatchExecutionOrder.NonSequential:
                        responses.AddRange(await Task.WhenAll(requests.Select(request => Invoker.SendAsync(request, cancellationToken))));
                        break;
                }
            }
            catch
            {
                foreach (HttpResponseMessage response in responses)
                {
                    if (response != null)
                    {
                        response.Dispose();
                    }
                }
                throw;
            }

            return responses;
        }

        /// <summary>
        /// Converts the incoming batch request into a collection of request messages.
        /// </summary>
        /// <param name="request">The request containing the batch request messages.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A collection of <see cref="HttpRequestMessage"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "We need to return a collection of request messages asynchronously.")]
        public virtual async Task<IList<HttpRequestMessage>> ParseBatchRequestsAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            List<HttpRequestMessage> requests = new List<HttpRequestMessage>();
            cancellationToken.ThrowIfCancellationRequested();
            MultipartStreamProvider streamProvider = await request.Content.ReadAsMultipartAsync();
            foreach (HttpContent httpContent in streamProvider.Contents)
            {
                cancellationToken.ThrowIfCancellationRequested();
                HttpRequestMessage innerRequest = request.RequestUri == null ? await httpContent.ReadAsHttpRequestMessageAsync() : await httpContent.ReadAsHttpRequestMessageAsync(request.RequestUri.Scheme);
                innerRequest.CopyBatchRequestProperties(request);
                requests.Add(innerRequest);
            }
            return requests;
        }

        /// <summary>
        /// Validates the incoming request that contains the batch request messages.
        /// </summary>
        /// <param name="request">The request containing the batch request messages.</param>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller is responsible for disposing the object.")]
        public virtual void ValidateRequest(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (request.Content == null)
            {
                throw new HttpResponseException(request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    SRResources.BatchRequestMissingContent));
            }

            MediaTypeHeaderValue contentType = request.Content.Headers.ContentType;
            if (contentType == null)
            {
                throw new HttpResponseException(request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    SRResources.BatchContentTypeMissing));
            }

            if (!SupportedContentTypes.Contains(contentType.MediaType, StringComparer.OrdinalIgnoreCase))
            {
                throw new HttpResponseException(request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    Error.Format(SRResources.BatchMediaTypeNotSupported, contentType.MediaType)));
            }
        }
    }
}

================================================
FILE: src/System.Web.Http/Batch/HttpBatchHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;

namespace System.Web.Http.Batch
{
    /// <summary>
    /// Defines the abstraction for handling HTTP batch requests.
    /// </summary>
    // Class Hierarchy
    // - HttpBatchHandler
    //   - DefaultHttpBatchHandler
    //   - ODataBatchHandler
    //     - DefaultODataBatchHandler
    //     - UnbufferedODataBatchHandler
    public abstract class HttpBatchHandler : HttpMessageHandler
    {
        private readonly HttpServer _server;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpBatchHandler"/> class.
        /// </summary>
        /// <param name="httpServer">The <see cref="HttpServer"/> for handling the individual batch requests.</param>
        protected HttpBatchHandler(HttpServer httpServer)
        {
            if (httpServer == null)
            {
                throw Error.ArgumentNull("httpServer");
            }

            _server = httpServer;
            Invoker = new HttpMessageInvoker(httpServer);
        }

        /// <summary>
        /// Gets the invoker to send the batch requests to the <see cref="HttpServer"/>.
        /// </summary>
        public HttpMessageInvoker Invoker { get; private set; }

        /// <remarks>This property is internal and settable only for unit testing purposes.</remarks>
        internal IExceptionLogger ExceptionLogger
        {
            get
            {
                return _server.ExceptionLogger;
            }
            set
            {
                _server.ExceptionLogger = value;
            }
        }

        /// <remarks>This property is internal and settable only for unit testing purposes.</remarks>
        internal IExceptionHandler ExceptionHandler
        {
            get
            {
                return _server.ExceptionHandler;
            }
            set
            {
                _server.ExceptionHandler = value;
            }
        }

        /// <inheritdoc/>
        protected sealed override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            request.Properties[HttpPropertyKeys.IsBatchRequest] = true;

            ExceptionDispatchInfo exceptionInfo;

            try
            {
                return await ProcessBatchAsync(request, cancellationToken);
            }
            catch (OperationCanceledException)
            {
                // Propogate the canceled task without calling exception loggers or handlers.
                throw;
            }
            catch (HttpResponseException httpResponseException)
            {
                return httpResponseException.Response;
            }
            catch (Exception exception)
            {
                exceptionInfo = ExceptionDispatchInfo.Capture(exception);
            }

            Debug.Assert(exceptionInfo.SourceException != null);

            ExceptionContext exceptionContext = new ExceptionContext(exceptionInfo.SourceException,
                ExceptionCatchBlocks.HttpBatchHandler, request);
            await ExceptionLogger.LogAsync(exceptionContext, cancellationToken);
            HttpResponseMessage response = await ExceptionHandler.HandleAsync(exceptionContext, cancellationToken);

            if (response == null)
            {
                exceptionInfo.Throw();
            }

            return response;
        }

        /// <summary>
        /// Processes the incoming batch request as a single <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="request">The batch request.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>The batch response.</returns>
        public abstract Task<HttpResponseMessage> ProcessBatchAsync(HttpRequestMessage request, CancellationToken cancellationToken);
    }
}

================================================
FILE: src/System.Web.Http/Controllers/ActionFilterResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;

namespace System.Web.Http.Controllers
{
    internal class ActionFilterResult : IHttpActionResult
    {
        private readonly HttpActionBinding _binding;
        private readonly HttpActionContext _context;
        private readonly ServicesContainer _services;
        private readonly IActionFilter[] _filters;

        public ActionFilterResult(HttpActionBinding binding, HttpActionContext context, ServicesContainer services,
            IActionFilter[] filters)
        {
            Contract.Assert(binding != null);
            Contract.Assert(context != null);
            Contract.Assert(services != null);
            Contract.Assert(filters != null);

            _binding = binding;
            _context = context;
            _services = services;
            _filters = filters;
        }

        public async Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            await _binding.ExecuteBindingAsync(_context, cancellationToken);

            ActionInvoker actionInvoker = new ActionInvoker(_context, cancellationToken, _services);
            // Empty filters is the default case so avoid delegates
            // Ensure empty case remains the same as the filtered case
            if (_filters.Length == 0)
            {
                return await actionInvoker.InvokeActionAsync();
            }
            // Ensure delegate continues to use the C# Compiler static delegate caching optimization
            Func<ActionInvoker, Task<HttpResponseMessage>> invokeCallback = (innerInvoker) =>
                innerInvoker.InvokeActionAsync();
            return await InvokeActionWithActionFilters(_context, cancellationToken, _filters, invokeCallback,
                actionInvoker)();
        }

        public static Func<Task<HttpResponseMessage>> InvokeActionWithActionFilters(HttpActionContext actionContext,
            CancellationToken cancellationToken, IActionFilter[] filters, Func<Task<HttpResponseMessage>> innerAction)
        {
            Contract.Assert(actionContext != null);
            Contract.Assert(filters != null);
            Contract.Assert(innerAction != null);

            // Because the continuation gets built from the inside out we need to reverse the filter list so that least
            // specific filters (Global) get run first and the most specific filters (Action) get run last.
            Func<Task<HttpResponseMessage>> result = innerAction;
            for (int i = filters.Length - 1; i >= 0; i--)
            {
                IActionFilter filter = filters[i];
                Func<Func<Task<HttpResponseMessage>>, IActionFilter, Func<Task<HttpResponseMessage>>>
                    chainContinuation = (continuation, innerFilter) =>
                    {
                        return () => innerFilter.ExecuteActionFilterAsync(actionContext, cancellationToken,
                            continuation);
                    };
                result = chainContinuation(result, filter);
            }

            return result;
        }

        private static Func<Task<HttpResponseMessage>> InvokeActionWithActionFilters<T>(
            HttpActionContext actionContext, CancellationToken cancellationToken, IActionFilter[] filters,
            Func<T, Task<HttpResponseMessage>> innerAction, T state)
        {
            return InvokeActionWithActionFilters(actionContext, cancellationToken, filters, () => innerAction(state));
        }

        // Keep as struct to avoid allocation
        private struct ActionInvoker
        {
            private readonly HttpActionContext _context;
            private readonly CancellationToken _cancellationToken;
            private readonly ServicesContainer _controllerServices;

            public ActionInvoker(HttpActionContext context, CancellationToken cancellationToken,
                ServicesContainer controllerServices)
            {
                Contract.Assert(controllerServices != null);

                _context = context;
                _cancellationToken = cancellationToken;
                _controllerServices = controllerServices;
            }

            public Task<HttpResponseMessage> InvokeActionAsync()
            {
                return _controllerServices.GetActionInvoker().InvokeActionAsync(_context, _cancellationToken);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/ApiControllerActionInvoker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.Controllers
{
    public class ApiControllerActionInvoker : IHttpActionInvoker
    {
        public virtual Task<HttpResponseMessage> InvokeActionAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            return InvokeActionAsyncCore(actionContext, cancellationToken);
        }

        private static async Task<HttpResponseMessage> InvokeActionAsyncCore(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            HttpActionDescriptor actionDescriptor = actionContext.ActionDescriptor;
            Contract.Assert(actionDescriptor != null);

            HttpControllerContext controllerContext = actionContext.ControllerContext;
            Contract.Assert(controllerContext != null);

            try
            {
                object result = await actionDescriptor.ExecuteAsync(controllerContext, actionContext.ActionArguments, cancellationToken);

                // This is cached in a local for performance reasons. ReturnType is a virtual property on HttpActionDescriptor,
                // or else we'd want to cache this as part of that class.
                bool isDeclaredTypeActionResult = typeof(IHttpActionResult).IsAssignableFrom(actionDescriptor.ReturnType);
                if (result == null && isDeclaredTypeActionResult)
                {
                    // If the return type of the action descriptor is IHttpActionResult, it's not valid to return null
                    throw Error.InvalidOperation(SRResources.ApiControllerActionInvoker_NullHttpActionResult);
                }
                
                if (isDeclaredTypeActionResult || actionDescriptor.ReturnType == typeof(object))
                {
                    IHttpActionResult actionResult = result as IHttpActionResult;

                    if (actionResult == null && isDeclaredTypeActionResult)
                    {
                        // If the return type of the action descriptor is IHttpActionResult, it's not valid to return an
                        // object that doesn't implement IHttpActionResult
                        throw Error.InvalidOperation(SRResources.ApiControllerActionInvoker_InvalidHttpActionResult, result.GetType());
                    }
                    else if (actionResult != null)
                    {
                        HttpResponseMessage response = await actionResult.ExecuteAsync(cancellationToken);
                        if (response == null)
                        {
                            throw Error.InvalidOperation(SRResources.ResponseMessageResultConverter_NullHttpResponseMessage);
                        }

                        response.EnsureResponseHasRequest(actionContext.Request);
                        return response;
                    }
                }
 
                // This is a non-IHttpActionResult, so run the converter
                return actionDescriptor.ResultConverter.Convert(controllerContext, result);
            }
            catch (HttpResponseException httpResponseException)
            {
                HttpResponseMessage response = httpResponseException.Response;
                response.EnsureResponseHasRequest(actionContext.Request);

                return response;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/ApiControllerActionSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Web.Http.Internal;
using System.Web.Http.Properties;
using System.Web.Http.Routing;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Reflection based action selector.
    /// We optimize for the case where we have an <see cref="ApiControllerActionSelector"/> instance per <see cref="HttpControllerDescriptor"/>
    /// instance but can support cases where there are many <see cref="HttpControllerDescriptor"/> instances for one
    /// <see cref="ApiControllerActionSelector"/> as well. In the latter case the lookup is slightly slower because it goes through
    /// the <see cref="P:HttpControllerDescriptor.Properties"/> dictionary.
    /// </summary>
    public class ApiControllerActionSelector : IHttpActionSelector
    {
        private ActionSelectorCacheItem _fastCache;
        private readonly object _cacheKey = new object();

        public virtual HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            ActionSelectorCacheItem internalSelector = GetInternalSelector(controllerContext.ControllerDescriptor);
            return internalSelector.SelectAction(controllerContext);
        }

        public virtual ILookup<string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor)
        {
            if (controllerDescriptor == null)
            {
                throw Error.ArgumentNull("controllerDescriptor");
            }

            ActionSelectorCacheItem internalSelector = GetInternalSelector(controllerDescriptor);
            return internalSelector.GetActionMapping();
        }

        private ActionSelectorCacheItem GetInternalSelector(HttpControllerDescriptor controllerDescriptor)
        {
            // Performance-sensitive

            // First check in the local fast cache and if not a match then look in the broader 
            // HttpControllerDescriptor.Properties cache
            if (_fastCache == null)
            {
                ActionSelectorCacheItem selector = new ActionSelectorCacheItem(controllerDescriptor);
                Interlocked.CompareExchange(ref _fastCache, selector, null);
                return selector;
            }
            else if (_fastCache.HttpControllerDescriptor == controllerDescriptor)
            {
                // If the key matches and we already have the delegate for creating an instance then just execute it
                return _fastCache;
            }
            else
            {
                // If the key doesn't match then lookup/create delegate in the HttpControllerDescriptor.Properties for
                // that HttpControllerDescriptor instance
                object cacheValue;
                if (controllerDescriptor.Properties.TryGetValue(_cacheKey, out cacheValue))
                {
                    return (ActionSelectorCacheItem)cacheValue;
                }
                // Race condition on initialization has no side effects
                ActionSelectorCacheItem selector = new ActionSelectorCacheItem(controllerDescriptor);
                controllerDescriptor.Properties.TryAdd(_cacheKey, selector);
                return selector;
            }
        }

        // All caching is in a dedicated cache class, which may be optionally shared across selector instances.
        // Make this a private nested class so that nobody else can conflict with our state.
        // Cache is initialized during ctor on a single thread.
        private class ActionSelectorCacheItem
        {
            private readonly HttpControllerDescriptor _controllerDescriptor;

            // Includes action descriptors for actionsByVerb with and without route attributes.
            private readonly CandidateAction[] _combinedCandidateActions;

            private readonly IDictionary<HttpActionDescriptor, string[]> _actionParameterNames = new Dictionary<HttpActionDescriptor, string[]>();

            // Includes action descriptors for actionsByVerb with and without route attributes.
            private readonly ILookup<string, HttpActionDescriptor> _combinedActionNameMapping;

            // Selection commonly looks up an action by verb.
            // Cache this mapping. These caches are completely optional and we still behave correctly if we cache miss.
            // We can adjust the specific set we cache based on profiler information.
            // Conceptually, this set of caches could be a HttpMethod --> ReflectedHttpActionDescriptor[].
            // - Beware that HttpMethod has a very slow hash function (it does case-insensitive string hashing). So don't use Dict.
            // - there are unbounded number of http methods, so make sure the cache doesn't grow indefinitely.
            // - we can build the cache at startup and don't need to continually add to it.
            private static readonly HttpMethod[] _cacheListVerbKinds = new HttpMethod[] { HttpMethod.Get, HttpMethod.Put, HttpMethod.Post };

            private StandardActionSelectionCache _standardActions;

            public ActionSelectorCacheItem(HttpControllerDescriptor controllerDescriptor)
            {
                Contract.Assert(controllerDescriptor != null);

                // Initialize the cache entirely in the ctor on a single thread.
                _controllerDescriptor = controllerDescriptor;

                MethodInfo[] allMethods = _controllerDescriptor.ControllerType.GetMethods(BindingFlags.Instance | BindingFlags.Public);
                MethodInfo[] validMethods = Array.FindAll(allMethods, IsValidActionMethod);

                _combinedCandidateActions = new CandidateAction[validMethods.Length];
                for (int i = 0; i < validMethods.Length; i++)
                {
                    MethodInfo method = validMethods[i];
                    ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(_controllerDescriptor, method);
                    _combinedCandidateActions[i] = new CandidateAction
                    {
                        ActionDescriptor = actionDescriptor
                    };
                    HttpActionBinding actionBinding = actionDescriptor.ActionBinding;

                    // Building an action parameter name mapping to compare against the URI parameters coming from the request. Here we only take into account required parameters that are simple types and come from URI.
                    _actionParameterNames.Add(
                        actionDescriptor,
                        actionBinding.ParameterBindings
                            .Where(binding => !binding.Descriptor.IsOptional && TypeHelper.CanConvertFromString(binding.Descriptor.ParameterType) && binding.WillReadUri())
                            .Select(binding => binding.Descriptor.Prefix ?? binding.Descriptor.ParameterName).ToArray());
                }

                _combinedActionNameMapping = 
                    _combinedCandidateActions
                    .Select(c => c.ActionDescriptor)
                    .ToLookup(actionDesc => actionDesc.ActionName, StringComparer.OrdinalIgnoreCase);
            }

            public HttpControllerDescriptor HttpControllerDescriptor
            {
                get { return _controllerDescriptor; }
            }

            // This method lazy-initializes the data needed for action selection. This is a safe race-condition. This is
            // done because we don't know whether or not an action/controller is attribute routed until after attribute
            // routes are added.
            private void InitializeStandardActions()
            {
                if (_standardActions != null)
                {
                    return;
                }

                StandardActionSelectionCache standardActions = new StandardActionSelectionCache();

                if (_controllerDescriptor.IsAttributeRouted())
                {
                    // The controller has an attribute route; no actionsByVerb are accessible via standard routing.
                    standardActions.StandardCandidateActions = new CandidateAction[0];
                }
                else
                {
                    // The controller does not have an attribute route; some actionsByVerb may be accessible via standard
                    // routing.
                    List<CandidateAction> standardCandidateActions = new List<CandidateAction>();

                    for (int i = 0; i < _combinedCandidateActions.Length; i++)
                    {
                        CandidateAction candidate = _combinedCandidateActions[i];

                        // We know that this cast is safe before we created all of the action descriptors for standard actions
                        ReflectedHttpActionDescriptor action = (ReflectedHttpActionDescriptor)candidate.ActionDescriptor;

                        // Allow standard routes access inherited actionsByVerb or actionsByVerb without Route attributes.
                        if (action.MethodInfo.DeclaringType != _controllerDescriptor.ControllerType
                            || !candidate.ActionDescriptor.IsAttributeRouted())
                        {
                            standardCandidateActions.Add(candidate);
                        }
                    }

                    standardActions.StandardCandidateActions = standardCandidateActions.ToArray();
                }

                standardActions.StandardActionNameMapping = 
                    standardActions.StandardCandidateActions
                    .Select(c => c.ActionDescriptor)
                    .ToLookup(actionDesc => actionDesc.ActionName, StringComparer.OrdinalIgnoreCase);

                // Bucket the action descriptors by common verbs.
                int len = _cacheListVerbKinds.Length;
                standardActions.CacheListVerbs = new CandidateAction[len][];
                for (int i = 0; i < len; i++)
                {
                    standardActions.CacheListVerbs[i] = FindActionsForVerbWorker(_cacheListVerbKinds[i], standardActions.StandardCandidateActions);
                }

                _standardActions = standardActions;
            }

            public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
            {
                InitializeStandardActions();
                
                List<CandidateActionWithParams> selectedCandidates = FindMatchingActions(controllerContext); 

                switch (selectedCandidates.Count)
                {
                    case 0:
                        throw new HttpResponseException(CreateSelectionError(controllerContext));
                    case 1:
                        ElevateRouteData(controllerContext, selectedCandidates[0]);
                        return selectedCandidates[0].ActionDescriptor;
                    default:

                        // Throws exception because multiple actionsByVerb match the request
                        string ambiguityList = CreateAmbiguousMatchList(selectedCandidates);
                        throw Error.InvalidOperation(SRResources.ApiControllerActionSelector_AmbiguousMatch, ambiguityList);
                }
            }

            private static void ElevateRouteData(HttpControllerContext controllerContext, CandidateActionWithParams selectedCandidate)
            {
                controllerContext.RouteData = selectedCandidate.RouteDataSource;
            }
                        
            // Find all actionsByVerb on this controller that match the request. 
            // if ignoreVerbs = true, then don't filter actionsByVerb based on mismatching Http verb. This is useful for detecting 404/405. 
            private List<CandidateActionWithParams> FindMatchingActions(HttpControllerContext controllerContext, bool ignoreVerbs = false)
            {
                // If matched with direct route?
                IHttpRouteData routeData = controllerContext.RouteData;
                IEnumerable<IHttpRouteData> subRoutes = routeData.GetSubRoutes();
                                
                IEnumerable<CandidateActionWithParams> actionsWithParameters = (subRoutes == null) ? 
                    GetInitialCandidateWithParameterListForRegularRoutes(controllerContext, ignoreVerbs) :
                    GetInitialCandidateWithParameterListForDirectRoutes(controllerContext, subRoutes, ignoreVerbs);

                // Make sure the action parameter matches the route and query parameters.
                List<CandidateActionWithParams> actionsFoundByParams = FindActionMatchRequiredRouteAndQueryParameters(actionsWithParameters);

                List<CandidateActionWithParams> orderCandidates = RunOrderFilter(actionsFoundByParams);
                List<CandidateActionWithParams> precedenceCandidates = RunPrecedenceFilter(orderCandidates);

                // Overload resolution logic is applied when needed.
                List<CandidateActionWithParams> selectedCandidates = FindActionMatchMostRouteAndQueryParameters(precedenceCandidates);

                return selectedCandidates;
            }

            // Selection error. Caller has already determined the request is an error, and now we need to provide the best error message.
            // If there's another verb that could satisfy this URL, then return 405.
            // Else return 404.
            [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller is responsible for disposing of response instance.")]
            private HttpResponseMessage CreateSelectionError(HttpControllerContext controllerContext)
            {
                // Check for 405.  
                List<CandidateActionWithParams> actionsFoundByParams = FindMatchingActions(controllerContext, ignoreVerbs: true);

                if (actionsFoundByParams.Count > 0)
                {
                    return Create405Response(controllerContext, actionsFoundByParams);
                }

                // Throws HttpResponseException with NotFound status because no action matches the request
                return CreateActionNotFoundResponse(controllerContext);
            }

            // Create a 405 error response with proper headers and message string. 
            [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller is responsible for disposing of response instance.")]
            private static HttpResponseMessage Create405Response(HttpControllerContext controllerContext, IEnumerable<CandidateActionWithParams> allowedCandidates)
            {
                HttpMethod incomingMethod = controllerContext.Request.Method;
                HttpResponseMessage response = controllerContext.Request.CreateErrorResponse(
                    HttpStatusCode.MethodNotAllowed,
                    Error.Format(SRResources.ApiControllerActionSelector_HttpMethodNotSupported, incomingMethod));

                // 405 must include an Allow content-header with the allowable methods.
                // See: https://tools.ietf.org/html/rfc2616#section-14.7
                HashSet<HttpMethod> methods = new HashSet<HttpMethod>();
                foreach (var candidate in allowedCandidates)
                {
                    methods.UnionWith(candidate.ActionDescriptor.SupportedHttpMethods);
                }
                foreach (var method in methods)
                {
                    response.Content.Headers.Allow.Add(method.ToString());
                }

                return response;
            }

            // Create a 404
            private HttpResponseMessage CreateActionNotFoundResponse(HttpControllerContext controllerContext)
            {
                return controllerContext.Request.CreateErrorResponse(
                    HttpStatusCode.NotFound,
                    Error.Format(SRResources.ResourceNotFound, controllerContext.Request.RequestUri),
                    Error.Format(SRResources.ApiControllerActionSelector_ActionNotFound, _controllerDescriptor.ControllerName));
            }

            // Create a 404, including the name of the action we were looking for. 
            // This overload includes the action name. 
            private HttpResponseMessage CreateActionNotFoundResponse(HttpControllerContext controllerContext, string actionName)
            {
                return controllerContext.Request.CreateErrorResponse(
                    HttpStatusCode.NotFound,
                    Error.Format(SRResources.ResourceNotFound, controllerContext.Request.RequestUri),
                    Error.Format(SRResources.ApiControllerActionSelector_ActionNameNotFound, _controllerDescriptor.ControllerName, actionName));
            }

            // Call for direct routes. 
            private static List<CandidateActionWithParams> GetInitialCandidateWithParameterListForDirectRoutes(HttpControllerContext controllerContext, IEnumerable<IHttpRouteData> subRoutes, bool ignoreVerbs)
            {
                HttpRequestMessage request = controllerContext.Request;
                HttpMethod incomingMethod = controllerContext.Request.Method;

                var queryNameValuePairs = request.GetQueryNameValuePairs();

                List<CandidateActionWithParams> candidateActionWithParams = new List<CandidateActionWithParams>();

                foreach (IHttpRouteData subRouteData in subRoutes)
                {
                    // Each route may have different route parameters.
                    ISet<string> combinedParameterNames = GetCombinedParameterNames(queryNameValuePairs, subRouteData.Values);

                    CandidateAction[] candidates = subRouteData.Route.GetDirectRouteCandidates();

                    string actionName;
                    subRouteData.Values.TryGetValue(RouteValueKeys.Action, out actionName);

                    foreach (var candidate in candidates)
                    {
                        if ((actionName == null) || candidate.MatchName(actionName))
                        {
                            if (ignoreVerbs || candidate.MatchVerb(incomingMethod))
                            {
                                candidateActionWithParams.Add(new CandidateActionWithParams(candidate, combinedParameterNames, subRouteData));
                            }
                        }
                    }
                }
                return candidateActionWithParams;
            }

            // Call for non-direct routes
            private IEnumerable<CandidateActionWithParams> GetInitialCandidateWithParameterListForRegularRoutes(HttpControllerContext controllerContext, bool ignoreVerbs = false)
            {
                CandidateAction[] candidates = GetInitialCandidateList(controllerContext, ignoreVerbs);
                return GetCandidateActionsWithBindings(controllerContext, candidates);
            }

            private CandidateAction[] GetInitialCandidateList(HttpControllerContext controllerContext, bool ignoreVerbs = false)
            {
                // Initial candidate list is determined by:
                // - Direct route?
                // - {action} value?
                // - ignore verbs?
                string actionName;

                HttpMethod incomingMethod = controllerContext.Request.Method;
                IHttpRouteData routeData = controllerContext.RouteData;

                Contract.Assert(routeData.GetSubRoutes() == null, "Should not be called on a direct route");
                CandidateAction[] candidates;

                if (routeData.Values.TryGetValue(RouteValueKeys.Action, out actionName))
                {
                    // We have an explicit {action} value, do traditional binding. Just lookup by actionName
                    HttpActionDescriptor[] actionsFoundByName = _standardActions.StandardActionNameMapping[actionName].ToArray();

                    // Throws HttpResponseException with NotFound status because no action matches the Name
                    if (actionsFoundByName.Length == 0)
                    {
                        throw new HttpResponseException(CreateActionNotFoundResponse(controllerContext, actionName));
                    }

                    CandidateAction[] candidatesFoundByName = new CandidateAction[actionsFoundByName.Length];

                    for (int i = 0; i < actionsFoundByName.Length; i++)
                    {
                        candidatesFoundByName[i] = new CandidateAction
                        {
                            ActionDescriptor = actionsFoundByName[i]
                        };
                    }

                    if (ignoreVerbs)
                    {
                        candidates = candidatesFoundByName;
                    }
                    else
                    {
                        candidates = FilterIncompatibleVerbs(incomingMethod, candidatesFoundByName);
                    }
                }
                else
                {
                    if (ignoreVerbs)
                    {
                        candidates = _standardActions.StandardCandidateActions;
                    }
                    else
                    {
                        // No direct routing or {action} parameter, infer it from the verb.
                        candidates = FindActionsForVerb(incomingMethod, _standardActions.CacheListVerbs, _standardActions.StandardCandidateActions);
                    }
                }

                return candidates;
            }

            private static CandidateAction[] FilterIncompatibleVerbs(HttpMethod incomingMethod, CandidateAction[] candidatesFoundByName)
            {
                return candidatesFoundByName.Where(candidate => candidate.ActionDescriptor.SupportedHttpMethods.Contains(incomingMethod)).ToArray();
            }

            public ILookup<string, HttpActionDescriptor> GetActionMapping()
            {
                return _combinedActionNameMapping;
            }

            // Get a non-null set that combines both the route and query parameters. 
            private static ISet<string> GetCombinedParameterNames(IEnumerable<KeyValuePair<string, string>> queryNameValuePairs, IDictionary<string, object> routeValues)
            {
                HashSet<string> routeParameterNames = new HashSet<string>(routeValues.Keys, StringComparer.OrdinalIgnoreCase);
                routeParameterNames.Remove(RouteValueKeys.Controller);
                routeParameterNames.Remove(RouteValueKeys.Action);

                var combinedParameterNames = new HashSet<string>(routeParameterNames, StringComparer.OrdinalIgnoreCase);
                if (queryNameValuePairs != null)
                {
                    foreach (var queryNameValuePair in queryNameValuePairs)
                    {
                        combinedParameterNames.Add(queryNameValuePair.Key);
                    }
                }
                return combinedParameterNames;
            }

            private List<CandidateActionWithParams> FindActionMatchRequiredRouteAndQueryParameters(IEnumerable<CandidateActionWithParams> candidatesFound)
            {
                List<CandidateActionWithParams> matches = new List<CandidateActionWithParams>();

                foreach (var candidate in candidatesFound)
                {
                    HttpActionDescriptor descriptor = candidate.ActionDescriptor;
                    if (IsSubset(_actionParameterNames[descriptor], candidate.CombinedParameterNames))
                    {
                        matches.Add(candidate);
                    }
                }

                return matches;
            }

            private List<CandidateActionWithParams> FindActionMatchMostRouteAndQueryParameters(List<CandidateActionWithParams> candidatesFound)
            {
                if (candidatesFound.Count > 1)
                {
                    // select the results that match the most number of required parameters
                    return candidatesFound
                        .GroupBy(candidate => _actionParameterNames[candidate.ActionDescriptor].Length)
                        .OrderByDescending(g => g.Key)
                        .First()
                        .ToList();
                }

                return candidatesFound;
            }

            // Given a list of candidate actionsByVerb, return a parallel list that includes the parameter information. 
            // This is used for regular routing where all candidates come from a single route, so they all share the same route parameter names. 
            private static CandidateActionWithParams[] GetCandidateActionsWithBindings(HttpControllerContext controllerContext, CandidateAction[] candidatesFound)
            {
                HttpRequestMessage request = controllerContext.Request;
                var queryNameValuePairs = request.GetQueryNameValuePairs();
                IHttpRouteData routeData = controllerContext.RouteData;
                IDictionary<string, object> routeValues = routeData.Values;
                ISet<string> combinedParameterNames = GetCombinedParameterNames(queryNameValuePairs, routeValues);

                CandidateActionWithParams[] candidatesWithParams = Array.ConvertAll(candidatesFound, candidate => new CandidateActionWithParams(candidate, combinedParameterNames, routeData));
                return candidatesWithParams;
            }

            private static bool IsSubset(string[] actionParameters, ISet<string> routeAndQueryParameters)
            {
                foreach (string actionParameter in actionParameters)
                {
                    if (!routeAndQueryParameters.Contains(actionParameter))
                    {
                        return false;
                    }
                }

                return true;
            }

            private static List<CandidateActionWithParams> RunOrderFilter(List<CandidateActionWithParams> candidatesFound)
            {
                if (candidatesFound.Count == 0)
                {
                    return candidatesFound;
                }
                int minOrder = candidatesFound.Min(c => c.CandidateAction.Order);
                return candidatesFound.Where(c => c.CandidateAction.Order == minOrder).AsList();
            }

            private static List<CandidateActionWithParams> RunPrecedenceFilter(List<CandidateActionWithParams> candidatesFound)
            {
                if (candidatesFound.Count == 0)
                {
                    return candidatesFound;
                }
                decimal highestPrecedence = candidatesFound.Min(c => c.CandidateAction.Precedence);
                return candidatesFound.Where(c => c.CandidateAction.Precedence == highestPrecedence).AsList();
            }

            // This is called when we don't specify an Action name
            // Get list of actionsByVerb that match a given verb. This can match by name or IActionHttpMethodSelector
            private static CandidateAction[] FindActionsForVerb(HttpMethod verb, CandidateAction[][] actionsByVerb, CandidateAction[] otherActions)
            {
                // Check cache for common verbs.
                for (int i = 0; i < _cacheListVerbKinds.Length; i++)
                {
                    // verb selection on common verbs is normalized to have object reference identity.
                    // This is significantly more efficient than comparing the verbs based on strings.
                    if (Object.ReferenceEquals(verb, _cacheListVerbKinds[i]))
                    {
                        return actionsByVerb[i];
                    }
                }

                // General case for any verbs.
                return FindActionsForVerbWorker(verb, otherActions);
            }

            // Given a list of actionsByVerb, filter it to ones that match a given verb. This can match by name or IActionHttpMethodSelector.
            // Since this list is fixed for a given verb type, it can be pre-computed and cached.
            // This function should not do caching. It's the helper that builds the caches.
            private static CandidateAction[] FindActionsForVerbWorker(HttpMethod verb, CandidateAction[] candidates)
            {
                List<CandidateAction> listCandidates = new List<CandidateAction>();

                FindActionsForVerbWorker(verb, candidates, listCandidates);

                return listCandidates.ToArray();
            }

            // Adds to existing list rather than send back as a return value.
            private static void FindActionsForVerbWorker(HttpMethod verb, CandidateAction[] candidates, List<CandidateAction> listCandidates)
            {
                foreach (CandidateAction candidate in candidates)
                {
                    if (candidate.ActionDescriptor != null && candidate.ActionDescriptor.SupportedHttpMethods.Contains(verb))
                    {
                        listCandidates.Add(candidate);
                    }
                }
            }

            private static string CreateAmbiguousMatchList(IEnumerable<CandidateActionWithParams> ambiguousCandidates)
            {
                StringBuilder exceptionMessageBuilder = new StringBuilder();
                foreach (CandidateActionWithParams candidate in ambiguousCandidates)
                {
                    HttpActionDescriptor descriptor = candidate.ActionDescriptor;
                    Contract.Assert(descriptor != null);

                    string controllerTypeName;

                    if (descriptor.ControllerDescriptor != null
                        && descriptor.ControllerDescriptor.ControllerType != null)
                    {
                        controllerTypeName = descriptor.ControllerDescriptor.ControllerType.FullName;
                    }
                    else
                    {
                        controllerTypeName = String.Empty;
                    }

                    exceptionMessageBuilder.AppendLine();
                    exceptionMessageBuilder.Append(Error.Format(
                        SRResources.ActionSelector_AmbiguousMatchType,
                        descriptor.ActionName, controllerTypeName));
                }

                return exceptionMessageBuilder.ToString();
            }

            private static bool IsValidActionMethod(MethodInfo methodInfo)
            {
                if (methodInfo.IsSpecialName)
                {
                    // not a normal method, e.g. a constructor or an event
                    return false;
                }

                if (methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(TypeHelper.ApiControllerType))
                {
                    // is a method on Object, IHttpController, ApiController
                    return false;
                }

                if (methodInfo.GetCustomAttribute<NonActionAttribute>() != null)
                {
                    return false;
                }

                return true;
            }
        }

        // Associate parameter (route and query) with each action. 
        // For regular routing, there was just a single route, and so single set of route parameters and so all of these
        // may share the same set of combined parameter names.
        // For attribute routing, there may be multiple routes, each with different route parameter names, and 
        // so each instance of a CandidateActionWithParams may have a different parameter set.
        [DebuggerDisplay("{DebuggerToString()}")]
        private class CandidateActionWithParams
        {
            public CandidateActionWithParams(CandidateAction candidateAction, ISet<string> parameters, IHttpRouteData routeDataSource)
            {
                CandidateAction = candidateAction;
                CombinedParameterNames = parameters;
                RouteDataSource = routeDataSource;
            }

            public CandidateAction CandidateAction { get; private set; }
            public ISet<string> CombinedParameterNames { get; private set; }

            // Remember this so that we can apply it for model binding. 
            public IHttpRouteData RouteDataSource { get; private set; }

            public HttpActionDescriptor ActionDescriptor
            {
                get
                {
                    return CandidateAction.ActionDescriptor;
                }
            }

            [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called from DebuggerDisplay")]
            private string DebuggerToString()
            {
                StringBuilder sb = new StringBuilder();
                sb.Append(CandidateAction.DebuggerToString());
                if (CombinedParameterNames.Count > 0)
                {
                    sb.Append(", Params =");
                    foreach (string param in CombinedParameterNames)
                    {
                        sb.AppendFormat(" {0}", param);
                    }
                }
                return sb.ToString();
            }
        }

        // A cache of the 'standard actions' for a controller - the actions that are reachable via traditional routes.
        private class StandardActionSelectionCache
        {
            // Includes action descriptors only for actions accessible via standard routing (without route attributes).
            public ILookup<string, HttpActionDescriptor> StandardActionNameMapping { get; set; }

            // Includes action descriptors only for actions accessible via standard routing (without route attributes).
            public CandidateAction[] StandardCandidateActions { get; set; }

            public CandidateAction[][] CacheListVerbs { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/AuthenticationFilterResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Hosting;

namespace System.Web.Http.Controllers
{
    internal class AuthenticationFilterResult : IHttpActionResult
    {
        private readonly HttpActionContext _context;
        private readonly ApiController _controller;
        private readonly IAuthenticationFilter[] _filters;
        private readonly IHttpActionResult _innerResult;

        public AuthenticationFilterResult(HttpActionContext context, ApiController controller,
            IAuthenticationFilter[] filters, IHttpActionResult innerResult)
        {
            Contract.Assert(context != null);
            Contract.Assert(controller != null);
            Contract.Assert(filters != null);
            Contract.Assert(innerResult != null);

            _context = context;
            _controller = controller;
            _filters = filters;
            _innerResult = innerResult;
        }

        public async Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            IHttpActionResult result = _innerResult;
            IPrincipal originalPrincipal = _controller.User;
            HttpAuthenticationContext authenticationContext = new HttpAuthenticationContext(_context,
                originalPrincipal);

            for (int i = 0; i < _filters.Length; i++)
            {
                IAuthenticationFilter filter = _filters[i];
                await filter.AuthenticateAsync(authenticationContext, cancellationToken);

                IHttpActionResult error = authenticationContext.ErrorResult;

                // Short-circuit on the first authentication filter to provide an error result.
                if (error != null)
                {
                    result = error;
                    break;
                }
            }

            IPrincipal newPrincipal = authenticationContext.Principal;

            if (newPrincipal != originalPrincipal)
            {
                _controller.User = newPrincipal;
            }

            // Run challenge on all filters (passing the result of each into the next). If a filter failed, the
            // challenges run on the failure result. If no filter failed, the challenges run on the original inner
            // result.
            HttpAuthenticationChallengeContext challengeContext = new HttpAuthenticationChallengeContext(_context,
                result);

            for (int i = 0; i < _filters.Length; i++)
            {
                IAuthenticationFilter filter = _filters[i];
                await filter.ChallengeAsync(challengeContext, cancellationToken);
            }

            Contract.Assert(challengeContext.Result != null);
            result = challengeContext.Result;

            return await result.ExecuteAsync(cancellationToken);
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/AuthorizationFilterResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;

namespace System.Web.Http.Controllers
{
    internal class AuthorizationFilterResult : IHttpActionResult
    {
        private readonly HttpActionContext _context;
        private readonly IAuthorizationFilter[] _filters;
        private readonly IHttpActionResult _innerResult;

        public AuthorizationFilterResult(HttpActionContext context, IAuthorizationFilter[] filters,
            IHttpActionResult innerResult)
        {
            Contract.Assert(context != null);
            Contract.Assert(filters != null);
            Contract.Assert(innerResult != null);

            _context = context;
            _filters = filters;
            _innerResult = innerResult;
        }

        public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            // We need to reverse the filter list so that least specific filters (Global) get run first and the most
            // specific filters (Action) get run last.
            Func<Task<HttpResponseMessage>> result = () => _innerResult.ExecuteAsync(cancellationToken);
            for (int i = _filters.Length - 1; i >= 0; i--)
            {
                IAuthorizationFilter filter = _filters[i];
                Func<Func<Task<HttpResponseMessage>>, IAuthorizationFilter, Func<Task<HttpResponseMessage>>>
                    chainContinuation = (continuation, innerFilter) =>
                    {
                        return () => innerFilter.ExecuteAuthorizationFilterAsync(_context, cancellationToken,
                            continuation);
                    };
                result = chainContinuation(result, filter);
            }

            return result();
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/CandidateAction.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Globalization;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Routing
{
    // This is static description of an action and can be shared across requests. 
    // Direct routes may cache a list of these. 
    [DebuggerDisplay("{DebuggerToString()}")]
    internal class CandidateAction
    {
        public HttpActionDescriptor ActionDescriptor { get; set; }
        public int Order { get; set; }
        public decimal Precedence { get; set; }

        public bool MatchName(string actionName)
        {
            return String.Equals(ActionDescriptor.ActionName, actionName, StringComparison.OrdinalIgnoreCase);
        }

        public bool MatchVerb(HttpMethod method)
        {
            return ActionDescriptor.SupportedHttpMethods.Contains(method);
        }

        internal string DebuggerToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "{0}, Order={1}, Prec={2}", ActionDescriptor.ActionName, Order, Precedence);
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/ExceptionFilterResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Filters;

namespace System.Web.Http.Controllers
{
    internal class ExceptionFilterResult : IHttpActionResult
    {
        private readonly HttpActionContext _context;
        private readonly IExceptionFilter[] _filters;
        private readonly IExceptionLogger _exceptionLogger;
        private readonly IExceptionHandler _exceptionHandler;

        private readonly IHttpActionResult _innerResult;

        public ExceptionFilterResult(HttpActionContext context, IExceptionFilter[] filters,
            IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler, IHttpActionResult innerResult)
        {
            Contract.Assert(context != null);
            Contract.Assert(filters != null);
            Contract.Assert(exceptionLogger != null);
            Contract.Assert(exceptionHandler != null);
            Contract.Assert(innerResult != null);

            _context = context;
            _filters = filters;
            _exceptionLogger = exceptionLogger;
            _exceptionHandler = exceptionHandler;
            _innerResult = innerResult;
        }

        public async Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            ExceptionDispatchInfo exceptionInfo;

            try
            {
                return await _innerResult.ExecuteAsync(cancellationToken);
            }
            catch (Exception e)
            {
                exceptionInfo = ExceptionDispatchInfo.Capture(e);
            }

            // This code path only runs if the task is faulted with an exception
            Exception exception = exceptionInfo.SourceException;
            Debug.Assert(exception != null);

            bool isCancellationException = exception is OperationCanceledException;

            ExceptionContext exceptionContext = new ExceptionContext(
                exception,
                ExceptionCatchBlocks.IExceptionFilter,
                _context);

            if (!isCancellationException)
            {
                // We don't log cancellation exceptions because it doesn't represent an error.
                await _exceptionLogger.LogAsync(exceptionContext, cancellationToken);
            }

            HttpActionExecutedContext executedContext = new HttpActionExecutedContext(_context, exception);

            // Note: exception filters need to be scheduled in the reverse order so that
            // the more specific filter (e.g. Action) executes before the less specific ones (e.g. Global)
            for (int i = _filters.Length - 1; i >= 0; i--)
            {
                IExceptionFilter exceptionFilter = _filters[i];
                await exceptionFilter.ExecuteExceptionFilterAsync(executedContext, cancellationToken);
            }

            if (executedContext.Response == null && !isCancellationException)
            {
                // We don't log cancellation exceptions because it doesn't represent an error.
                executedContext.Response = await _exceptionHandler.HandleAsync(exceptionContext, cancellationToken);
            }

            if (executedContext.Response != null)
            {
                return executedContext.Response;
            }
            else
            {
                // Preserve the original stack trace when the exception is not changed by any filter.
                if (exception == executedContext.Exception)
                {
                    exceptionInfo.Throw();
                }

                // If the exception is changed by a filter, throw the new exception instead.
                throw executedContext.Exception;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/FilterGrouping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Filters;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Quickly split filters into different types
    /// </summary>
    internal class FilterGrouping
    {
        private IActionFilter[] _actionFilters;
        private IAuthorizationFilter[] _authorizationFilters;
        private IAuthenticationFilter[] _authenticationFilters;
        private IExceptionFilter[] _exceptionFilters;

        public FilterGrouping(IEnumerable<FilterInfo> filters)
        {
            // evaluate the 'filters' enumerable only once since the operation can be quite expensive
            List<FilterInfo> orderedCache = filters.ToList();

            List<FilterInfo> overrides = orderedCache.Where(f => f.Instance is IOverrideFilter).ToList();

            FilterScope actionOverride = SelectLastOverrideScope<IActionFilter>(overrides);
            FilterScope authorizationOverride = SelectLastOverrideScope<IAuthorizationFilter>(overrides);
            FilterScope authenticationOverride = SelectLastOverrideScope<IAuthenticationFilter>(overrides);
            FilterScope exceptionOverride = SelectLastOverrideScope<IExceptionFilter>(overrides);

            _actionFilters = SelectAvailable<IActionFilter>(orderedCache, actionOverride);
            _authorizationFilters = SelectAvailable<IAuthorizationFilter>(orderedCache, authorizationOverride);
            _authenticationFilters = SelectAvailable<IAuthenticationFilter>(orderedCache, authenticationOverride);
            _exceptionFilters = SelectAvailable<IExceptionFilter>(orderedCache, exceptionOverride);
        }

        public IActionFilter[] ActionFilters
        {
            get { return _actionFilters; }
        }

        public IAuthorizationFilter[] AuthorizationFilters
        {
            get { return _authorizationFilters; }
        }

        public IAuthenticationFilter[] AuthenticationFilters
        {
            get { return _authenticationFilters; }
        }

        public IExceptionFilter[] ExceptionFilters
        {
            get { return _exceptionFilters; }
        }

        private static T[] SelectAvailable<T>(List<FilterInfo> filters, FilterScope overrideFiltersBeforeScope)
        {
            // Determine which filters are available for this filter type, given the current overrides in place.
            // A filter should be processed if:
            //  1. It implements the appropriate interface for this filter type.
            //  2. It has not been overridden (its scope is not before the scope of the last override for this
            //     type).
            return filters.Where(f => f.Scope >= overrideFiltersBeforeScope
                && (f.Instance is T)).Select(f => (T)f.Instance).ToArray();
        }

        private static FilterScope SelectLastOverrideScope<T>(List<FilterInfo> overrideFilters)
        {
            // A filter type (such as action filter) can be overridden, which means every filter of that type at an
            // earlier scope must be ignored. Determine the scope of the last override filter (if any). Only
            // filters at this scope or later will be processed.

            FilterInfo lastOverride = overrideFilters.Where(
                f => ((IOverrideFilter)f.Instance).FiltersToOverride == typeof(T)).LastOrDefault();

            // If no override is present, the filter is not overridden (and filters at any scope, starting with
            // First are processed). Not overriding a filter is equivalent to placing an override at the First
            // filter scope (since there's nothing before First to override).
            if (lastOverride == null)
            {
                return FilterScope.Global;
            }

            return lastOverride.Scope;
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpActionBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Metadata;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// This describes *how* the binding will happen. Does not actually bind. 
    /// This is static for a given action descriptor and can be reused across requests. 
    /// This may be a nice thing to log. Or set a breakpoint after we create and preview what's about to happen. 
    /// In theory, this could be precompiled for each Action descriptor.  
    /// </summary>
    public class HttpActionBinding
    {
        private HttpActionDescriptor _actionDescriptor;
        private HttpParameterBinding[] _parameterBindings;

        private ModelMetadataProvider _metadataProvider;

        public HttpActionBinding()
        {
        }

        public HttpActionBinding(HttpActionDescriptor actionDescriptor, HttpParameterBinding[] bindings)
        {
            ActionDescriptor = actionDescriptor;
            ParameterBindings = bindings;
        }

        /// <summary>
        /// Back pointer to the action this binding is for. 
        /// This can also provide the Type[], string[] names for the parameters.
        /// </summary>
        public HttpActionDescriptor ActionDescriptor
        {
            get
            {
                return _actionDescriptor;
            }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                _actionDescriptor = value;
            }
        }

        /// <summary>
        /// Specifies synchronous bindings for each parameter.This is a parallel array to the ActionDescriptor's parameter array. 
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "Want an array")]
        public HttpParameterBinding[] ParameterBindings
        {
            get
            {
                return _parameterBindings;
            }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                _parameterBindings = value;
            }
        }

        public virtual Task ExecuteBindingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            if (_parameterBindings.Length == 0)
            {
                return TaskHelpers.Completed();
            }

            // First, make sure the actionBinding is valid before trying to execute it. This keeps us in a known state in case of errors.
            for (int i = 0; i < ParameterBindings.Length; i++)
            {
                HttpParameterBinding parameterBinder = ParameterBindings[i];
                if (!parameterBinder.IsValid)
                {
                    // Throwing an exception because the webService developer's action signature is bad.
                    // This exception will be caught and converted into a 500 by the dispatcher
                    throw new InvalidOperationException(parameterBinder.ErrorMessage);
                }
            }

            if (_metadataProvider == null)
            {
                HttpConfiguration config = actionContext.ControllerContext.Configuration;
                _metadataProvider = config.Services.GetModelMetadataProvider();
            }

            return ExecuteBindingAsyncCore(actionContext, cancellationToken);
        }

        private async Task ExecuteBindingAsyncCore(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            // Execute all the binders.
            for (int index = 0; index < ParameterBindings.Length; index++)
            {
                HttpParameterBinding parameterBinder = ParameterBindings[index];

                await parameterBinder.ExecuteBindingAsync(_metadataProvider, actionContext, cancellationToken);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpActionContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Contains information for the executing action.
    /// </summary>
    public class HttpActionContext
    {
        private readonly ModelStateDictionary _modelState = new ModelStateDictionary();
        private readonly Dictionary<string, object> _operationArguments = new Dictionary<string, object>();
        private HttpActionDescriptor _actionDescriptor;
        private HttpControllerContext _controllerContext;
       
        public HttpActionContext(HttpControllerContext controllerContext, HttpActionDescriptor actionDescriptor)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            _controllerContext = controllerContext;
            _actionDescriptor = actionDescriptor;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpActionContext"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public HttpActionContext()
        {
        }

        public HttpControllerContext ControllerContext
        {
            get { return _controllerContext; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _controllerContext = value;
            }
        }

        public HttpActionDescriptor ActionDescriptor
        {
            get { return _actionDescriptor; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _actionDescriptor = value;
            }
        }

        public ModelStateDictionary ModelState
        {
            get { return _modelState; }
        }

        public Dictionary<string, object> ActionArguments
        {
            get { return _operationArguments; }
        }

        public HttpResponseMessage Response { get; set; }

        /// <summary>
        /// Gets the current <see cref="HttpRequestMessage"/>.
        /// </summary>
        public HttpRequestMessage Request
        {
            get { return _controllerContext != null ? _controllerContext.Request : null; }
        }

        /// <summary>
        /// Gets the current <see cref="HttpRequestContext"/>.
        /// </summary>
        public HttpRequestContext RequestContext
        {
            get { return _controllerContext != null ? _controllerContext.RequestContext : null; }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpActionContextExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Validation;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Extension methods for <see cref="HttpActionContext"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpActionContextExtensions
    {
        /// <summary>
        /// Gets the <see cref="ModelMetadataProvider"/> instance for a given <see cref="HttpActionContext"/>.
        /// </summary>
        /// <param name="actionContext">The context.</param>
        /// <returns>An <see cref="ModelMetadataProvider"/> instance.</returns>
        public static ModelMetadataProvider GetMetadataProvider(this HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            return actionContext.ControllerContext.Configuration.Services.GetModelMetadataProvider();
        }

        /// <summary>
        /// Gets the collection of registered <see cref="ModelValidatorProvider"/> instances.
        /// </summary>
        /// <param name="actionContext">The context.</param>
        /// <returns>A collection of <see cref="ModelValidatorProvider"/> instances.</returns>
        public static IEnumerable<ModelValidatorProvider> GetValidatorProviders(this HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            return actionContext.ControllerContext.Configuration.Services.GetModelValidatorProviders();
        }

        /// <summary>
        /// Gets the collection of registered <see cref="ModelValidator"/> instances.
        /// </summary>
        /// <param name="actionContext">The context.</param>
        /// <param name="metadata">The metadata.</param>
        /// <returns>A collection of registered <see cref="ModelValidator"/> instances.</returns>
        public static IEnumerable<ModelValidator> GetValidators(this HttpActionContext actionContext, ModelMetadata metadata)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            IModelValidatorCache validatorCache = actionContext.GetValidatorCache();
            return actionContext.GetValidators(metadata, validatorCache);
        }

        internal static IEnumerable<ModelValidator> GetValidators(this HttpActionContext actionContext, ModelMetadata metadata, IModelValidatorCache validatorCache)
        {
            if (validatorCache == null)
            {
                // slow path: there is no validator cache on the configuration
                return metadata.GetValidators(actionContext.GetValidatorProviders());
            }
            else
            {
                return validatorCache.GetValidators(metadata);
            }
        }

        internal static IModelValidatorCache GetValidatorCache(this HttpActionContext actionContext)
        {
            Contract.Assert(actionContext != null);

            HttpConfiguration configuration = actionContext.ControllerContext.Configuration;
            return configuration.Services.GetModelValidatorCache();
        }

        public static bool TryBindStrongModel<TModel>(this HttpActionContext actionContext, ModelBindingContext parentBindingContext, string propertyName, ModelMetadataProvider metadataProvider, out TModel model)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            ModelBindingContext propertyBindingContext = new ModelBindingContext(parentBindingContext)
            {
                ModelMetadata = metadataProvider.GetMetadataForType(null, typeof(TModel)),
                ModelName = ModelBindingHelper.CreatePropertyModelName(parentBindingContext.ModelName, propertyName)
            };

            if (actionContext.Bind(propertyBindingContext))
            {
                object untypedModel = propertyBindingContext.Model;
                model = ModelBindingHelper.CastOrDefault<TModel>(untypedModel);
                parentBindingContext.ValidationNode.ChildNodes.Add(propertyBindingContext.ValidationNode);
                return true;
            }

            model = default(TModel);
            return false;
        }

        // Pulls binders from the config
        public static bool Bind(this HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            Type modelType = bindingContext.ModelType;
            HttpConfiguration config = actionContext.ControllerContext.Configuration;

            IEnumerable<IModelBinder> binders = from provider in config.Services.GetModelBinderProviders()
                                                select provider.GetBinder(config, modelType);

            return Bind(actionContext, bindingContext, binders);
        }

        /// <summary>
        /// Attempt to bind against the given ActionContext.
        /// </summary>
        /// <param name="actionContext">The action context.</param>
        /// <param name="bindingContext">The binding context.</param>
        /// <param name="binders">set of binders to use for binding</param>
        /// <returns>True if the bind was successful, else false.</returns>
        public static bool Bind(this HttpActionContext actionContext, ModelBindingContext bindingContext, IEnumerable<IModelBinder> binders)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            if (bindingContext == null)
            {
                throw Error.ArgumentNull("bindingContext");
            }

            // Protects against stack overflow for deeply nested model binding
            RuntimeHelpers.EnsureSufficientExecutionStack();

            Type modelType = bindingContext.ModelType;
            HttpConfiguration config = actionContext.ControllerContext.Configuration;

            ModelBinderProvider providerFromAttr;
            if (ModelBindingHelper.TryGetProviderFromAttributes(modelType, out providerFromAttr))
            {
                IModelBinder binder = providerFromAttr.GetBinder(config, modelType);
                if (binder != null)
                {
                    return binder.BindModel(actionContext, bindingContext);
                }
            }

            foreach (IModelBinder binder in binders)
            {
                if (binder != null)
                {
                    if (binder.BindModel(actionContext, bindingContext))
                    {
                        return true;
                    }
                }
            }

            // Either we couldn't find a binder, or the binder couldn't bind. Distinction is not important.
            return false;
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Internal;
using System.Web.Http.Properties;

namespace System.Web.Http.Controllers
{
    public abstract class HttpActionDescriptor
    {
        private readonly ConcurrentDictionary<object, object> _properties = new ConcurrentDictionary<object, object>();

        private IActionResultConverter _converter;
        private readonly Lazy<Collection<FilterInfo>> _filterPipeline;
        private FilterGrouping _filterGrouping;
        private Collection<FilterInfo> _filterPipelineForGrouping;

        private HttpConfiguration _configuration;
        private HttpControllerDescriptor _controllerDescriptor;
        private readonly Collection<HttpMethod> _supportedHttpMethods = new Collection<HttpMethod>();

        private HttpActionBinding _actionBinding;

        private static readonly ResponseMessageResultConverter _responseMessageResultConverter = new ResponseMessageResultConverter();
        private static readonly VoidResultConverter _voidResultConverter = new VoidResultConverter();

        protected HttpActionDescriptor()
        {
            _filterPipeline = new Lazy<Collection<FilterInfo>>(InitializeFilterPipeline);
        }

        protected HttpActionDescriptor(HttpControllerDescriptor controllerDescriptor)
            : this()
        {
            if (controllerDescriptor == null)
            {
                throw Error.ArgumentNull("controllerDescriptor");
            }

            _controllerDescriptor = controllerDescriptor;
            _configuration = _controllerDescriptor.Configuration;
        }

        public abstract string ActionName { get; }

        public HttpConfiguration Configuration
        {
            get { return _configuration; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _configuration = value;
            }
        }

        public virtual HttpActionBinding ActionBinding
        {
            get
            {
                if (_actionBinding == null)
                {
                    ServicesContainer controllerServices = _controllerDescriptor.Configuration.Services;
                    IActionValueBinder actionValueBinder = controllerServices.GetActionValueBinder();
                    HttpActionBinding actionBinding = actionValueBinder.GetBinding(this);
                    _actionBinding = actionBinding;
                }
                return _actionBinding;
            }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _actionBinding = value;
            }
        }

        public HttpControllerDescriptor ControllerDescriptor
        {
            get { return _controllerDescriptor; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _controllerDescriptor = value;
            }
        }

        /// <summary>
        /// The return type of the method or <c>null</c> if the method does not return a value (e.g. a method returning
        /// <c>void</c>).
        /// </summary>
        /// <remarks>
        /// This property should describe the type of the value contained by the result of executing the action
        /// via the <see cref="ExecuteAsync(HttpControllerContext, IDictionary{string, object}, CancellationToken)"/>.
        /// </remarks>
        public abstract Type ReturnType { get; }

        /// <summary>
        /// Gets the converter for correctly transforming the result of calling
        /// <see cref="ExecuteAsync(HttpControllerContext, IDictionary{string, object}, CancellationToken)"/> into an instance of
        /// <see cref="HttpResponseMessage"/>. 
        /// </summary>
        /// <remarks>
        /// <para>This converter is not used when the runtime return value of an action is an <see cref="IHttpActionResult"/>.</para>
        /// <para>
        /// This value is <see langword="null" /> when the declared <see cref="ReturnType"/> is an <see cref="IHttpActionResult"/>.
        /// </para>
        /// <para>
        /// The behavior of the returned converter should align with the action's declared <see cref="ReturnType"/>.
        /// </para>
        /// </remarks>
        public virtual IActionResultConverter ResultConverter
        {
            get
            {
                // This initialization is not thread safe but that's fine since the converters do not have
                // any interesting state. If 2 threads get 2 different instances of the same converter type
                // we don't really care.
                if (_converter == null)
                {
                    _converter = GetResultConverter(ReturnType);
                }
                return _converter;
            }
        }

        public virtual Collection<HttpMethod> SupportedHttpMethods
        {
            get { return _supportedHttpMethods; }
        }

        /// <summary>
        /// Gets the properties associated with this instance.
        /// </summary>
        public virtual ConcurrentDictionary<object, object> Properties
        {
            get { return _properties; }
        }

        /// <summary>
        /// Gets the custom attributes.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public virtual Collection<T> GetCustomAttributes<T>() where T : class
        {
            return GetCustomAttributes<T>(inherit: true);
        }

        /// <summary>
        /// Gets the custom attributes for the action.
        /// </summary>
        /// <typeparam name="T">The type of attribute to search for.</typeparam>
        /// <param name="inherit"><c>true</c> to search this action's inheritance chain to find the attributes; otherwise, <c>false</c>.</param>
        /// <returns>The collection of custom attributes applied to this action.</returns>
        public virtual Collection<T> GetCustomAttributes<T>(bool inherit) where T : class
        {
            return new Collection<T>();
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Filters can be built dynamically")]
        public virtual Collection<IFilter> GetFilters()
        {
            return new Collection<IFilter>();
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Parameters can be built dynamically")]
        public abstract Collection<HttpParameterDescriptor> GetParameters();

        internal static IActionResultConverter GetResultConverter(Type type)
        {
            if (type != null && type.IsGenericParameter)
            {
                // This can happen if somebody declares an action method as:
                // public T Get<T>() { }
                throw Error.InvalidOperation(SRResources.HttpActionDescriptor_NoConverterForGenericParamterTypeExists, type);
            }

            if (type == null)
            {
                return _voidResultConverter;
            }
            else if (typeof(HttpResponseMessage).IsAssignableFrom(type))
            {
                return _responseMessageResultConverter;
            }
            else if (typeof(IHttpActionResult).IsAssignableFrom(type))
            {
                return null;
            }
            else
            {
                Type valueConverterType = typeof(ValueResultConverter<>).MakeGenericType(type);
                return TypeActivator.Create<IActionResultConverter>(valueConverterType).Invoke();
            }
        }

        /// <summary>
        /// Executes the described action and returns a <see cref="Task{T}"/> that once completed will
        /// contain the return value of the action.
        /// </summary>
        /// <param name="controllerContext">The context.</param>
        /// <param name="arguments">The arguments.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task{T}"/> that once completed will contain the return value of the action.</returns>
        public abstract Task<object> ExecuteAsync(HttpControllerContext controllerContext, IDictionary<string, object> arguments, CancellationToken cancellationToken);

        /// <summary>
        /// Returns the filters for the given configuration and action. The filter collection is ordered
        /// according to the FilterScope (in order from least specific to most specific: First, Global, Controller, Action).
        /// 
        /// If a given filter disallows duplicates (AllowMultiple=False) then the most specific filter is maintained
        /// and less specific filters get removed (e.g. if there is a Authorize filter with a Controller scope and another
        /// one with an Action scope then the one with the Action scope will be maintained and the one with the Controller
        /// scope will be discarded).
        /// </summary>
        /// <returns>A <see cref="Collection{T}"/> of all filters associated with this <see cref="HttpActionDescriptor"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Filter pipeline can be built dynamically")]
        public virtual Collection<FilterInfo> GetFilterPipeline()
        {
            return _filterPipeline.Value;
        }

        internal FilterGrouping GetFilterGrouping()
        {
            // Performance-sensitive
            // Filter grouping is expensive so cache whenever possible
            // For compatibility, the virtual method must be called
            Collection<FilterInfo> currentFilterPipeline = GetFilterPipeline();
            if (_filterGrouping == null || _filterPipelineForGrouping != currentFilterPipeline)
            {
                _filterGrouping = new FilterGrouping(currentFilterPipeline);
                _filterPipelineForGrouping = currentFilterPipeline;
            }
            return _filterGrouping;
        }

        private Collection<FilterInfo> InitializeFilterPipeline()
        {
            IEnumerable<IFilterProvider> filterProviders = _configuration.Services.GetFilterProviders();

            IEnumerable<FilterInfo> filters = filterProviders.SelectMany(fp => fp.GetFilters(_configuration, this)).OrderBy(f => f, FilterInfoComparer.Instance);

            // Need to discard duplicate filters from the end, so that most specific ones get kept (Action scope) and
            // less specific ones get removed (Global)
            filters = RemoveDuplicates(filters.Reverse()).Reverse();

            return new Collection<FilterInfo>(filters.ToList());
        }

        private static IEnumerable<FilterInfo> RemoveDuplicates(IEnumerable<FilterInfo> filters)
        {
            Contract.Assert(filters != null);

            HashSet<Type> visitedTypes = new HashSet<Type>();

            foreach (FilterInfo filter in filters)
            {
                object filterInstance = filter.Instance;
                Type filterInstanceType = filterInstance.GetType();

                if (!visitedTypes.Contains(filterInstanceType) || AllowMultiple(filterInstance))
                {
                    yield return filter;
                    visitedTypes.Add(filterInstanceType);
                }
            }
        }

        private static bool AllowMultiple(object filterInstance)
        {
            IFilter filter = filterInstance as IFilter;
            return filter == null || filter.AllowMultiple;
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpActionDescriptorExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Controllers
{
    internal static class HttpActionDescriptorExtensions
    {
        private const string AttributeRoutedPropertyKey = "MS_IsAttributeRouted";

        public static bool IsAttributeRouted(this HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            object value;
            actionDescriptor.Properties.TryGetValue(AttributeRoutedPropertyKey, out value);
            return value as bool? ?? false;
        }

        public static void SetIsAttributeRouted(this HttpActionDescriptor actionDescriptor, bool value)
        {
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            actionDescriptor.Properties[AttributeRoutedPropertyKey] = value;
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpControllerContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Routing;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Contains information for a single HTTP operation.
    /// </summary>
    public class HttpControllerContext
    {
        private HttpRequestContext _requestContext;
        private HttpRequestMessage _request;
        private HttpControllerDescriptor _controllerDescriptor;
        private IHttpController _controller;

        /// <summary>Initializes a new instance of the <see cref="HttpControllerContext"/> class.</summary>
        /// <param name="requestContext">The request context.</param>
        /// <param name="request">The HTTP request.</param>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="controller">The controller.</param>
        public HttpControllerContext(HttpRequestContext requestContext, HttpRequestMessage request,
            HttpControllerDescriptor controllerDescriptor, IHttpController controller)
        {
            if (requestContext == null)
            {
                throw Error.ArgumentNull("requestContext");
            }

            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (controllerDescriptor == null)
            {
                throw Error.ArgumentNull("controllerDescriptor");
            }

            if (controller == null)
            {
                throw Error.ArgumentNull("controller");
            }

            _requestContext = requestContext;
            _request = request;
            _controllerDescriptor = controllerDescriptor;
            _controller = controller;
        }

        public HttpControllerContext(HttpConfiguration configuration, IHttpRouteData routeData,
            HttpRequestMessage request)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            if (routeData == null)
            {
                throw Error.ArgumentNull("routeData");
            }

            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            _requestContext = new HttpRequestContext
            {
                Configuration = configuration,
                RouteData = routeData
            };
            _request = request;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpControllerContext"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public HttpControllerContext()
        {
            // Note: This constructor is also used by a FormDataCollectionExtensions where we attempt to create a 
            // controller context with incomplete request context.
            _requestContext = new HttpRequestContext();
        }

        public HttpConfiguration Configuration
        {
            get
            {
                return _requestContext.Configuration;
            }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _requestContext.Configuration = value;
            }
        }

        /// <summary>
        /// Gets or sets the controller descriptor.
        /// </summary>
        /// <value>
        /// The controller descriptor.
        /// </value>
        public HttpControllerDescriptor ControllerDescriptor
        {
            get { return _controllerDescriptor; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _controllerDescriptor = value;
            }
        }

        /// <summary>
        /// Gets or sets the HTTP controller.
        /// </summary>
        /// <value>
        /// The HTTP controller.
        /// </value>
        public IHttpController Controller
        {
            get { return _controller; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _controller = value;
            }
        }

        public HttpRequestMessage Request
        {
            get { return _request; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _request = value;
            }
        }

        /// <summary>Gets or sets the request context.</summary>
        public HttpRequestContext RequestContext
        {
            get { return _requestContext; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _requestContext = value;
            }
        }

        public IHttpRouteData RouteData
        {
            get { return _requestContext.RouteData; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _requestContext.RouteData = value;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpControllerDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Dispatcher;
using System.Web.Http.Filters;
using System.Web.Http.Internal;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Description and configuration for a controller.
    /// </summary>
    public class HttpControllerDescriptor
    {
        private readonly ConcurrentDictionary<object, object> _properties = new ConcurrentDictionary<object, object>();

        private HttpConfiguration _configuration;

        private string _controllerName;
        private Type _controllerType;

        private object[] _attributeCache;
        private object[] _declaredOnlyAttributeCache;

        public HttpControllerDescriptor(HttpConfiguration configuration, string controllerName, Type controllerType)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            if (controllerName == null)
            {
                throw Error.ArgumentNull("controllerName");
            }

            if (controllerType == null)
            {
                throw Error.ArgumentNull("controllerType");
            }

            _configuration = configuration;
            _controllerName = controllerName;
            _controllerType = controllerType;

            Initialize();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpControllerDescriptor"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public HttpControllerDescriptor()
        {
        }

        // For unit testing purposes. 
        internal HttpControllerDescriptor(HttpConfiguration configuration)
        {
            Initialize(configuration);
        }

        /// <summary>
        /// Gets the properties associated with this instance.
        /// </summary>
        public virtual ConcurrentDictionary<object, object> Properties
        {
            get { return _properties; }
        }

        /// <summary>
        /// Gets the configuration associated with the <see cref="HttpControllerDescriptor"/>. 
        /// </summary>
        public HttpConfiguration Configuration
        {
            get { return _configuration; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _configuration = value;
            }
        }

        public string ControllerName
        {
            get { return _controllerName; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _controllerName = value;
            }
        }

        public Type ControllerType
        {
            get { return _controllerType; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _controllerType = value;
            }
        }

        /// <summary>
        /// Creates a controller instance for the given <see cref="HttpRequestMessage"/>
        /// </summary>
        /// <param name="request">The request message</param>
        /// <returns></returns>
        public virtual IHttpController CreateController(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            // Invoke the controller activator
            IHttpControllerActivator activator = Configuration.Services.GetHttpControllerActivator();
            IHttpController instance = activator.Create(request, this, ControllerType);
            return instance;
        }

        /// <summary>
        /// Returns the collection of <see cref="IFilter">filters</see> associated with this descriptor's controller.
        /// </summary>
        /// <remarks>The default implementation calls <see cref="GetCustomAttributes{IFilter}()"/>.</remarks>
        /// <returns>A collection of filters associated with this controller.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Filters can be built dynamically")]
        public virtual Collection<IFilter> GetFilters()
        {
            return GetCustomAttributes<IFilter>();
        }

        /// <summary>
        /// Returns a collection of attributes that can be assigned to <typeparamref name="T"/> for this descriptor's controller.
        /// </summary>
        /// <remarks>The default implementation retrieves the matching set of attributes declared on <see cref="ControllerType"/>.</remarks>
        /// <typeparam name="T">Used to filter the collection of attributes. Use a value of <see cref="Object"/> to retrieve all attributes.</typeparam>
        /// <returns>A collection of attributes associated with this controller.</returns>
        public virtual Collection<T> GetCustomAttributes<T>() where T : class
        {
            return GetCustomAttributes<T>(inherit: true);
        }

        /// <summary>
        /// Returns a collection of attributes that can be assigned to <typeparamref name="T"/> for this descriptor's controller.
        /// </summary>
        /// <remarks>The default implementation retrieves the matching set of attributes declared on <see cref="ControllerType"/>.</remarks>
        /// <typeparam name="T">Used to filter the collection of attributes. Use a value of <see cref="Object"/> to retrieve all attributes.</typeparam>
        /// <param name="inherit"><c>true</c> to search this controller's inheritance chain to find the attributes; otherwise, <c>false</c>.</param>
        /// <returns>A collection of attributes associated with this controller.</returns>
        public virtual Collection<T> GetCustomAttributes<T>(bool inherit) where T : class
        {
            object[] attributes;
            // Getting custom attributes via reflection is slow. 
            // But iterating over a object[] to pick out specific types is fast. 
            // Furthermore, many different services may call to ask for different attributes, so we have multiple callers. 
            // That means there's not a single cache for the callers, which means there's some value caching here.
            if (inherit)
            {
                if (_attributeCache == null)
                {
                    // Even in a race, we'll just ask for the custom attributes twice.
                    _attributeCache = ControllerType.GetCustomAttributes(inherit: true);
                }
                attributes = _attributeCache;
            }
            else
            {
                if (_declaredOnlyAttributeCache == null)
                {
                    // Even in a race, we'll just ask for the custom attributes twice.
                    _declaredOnlyAttributeCache = ControllerType.GetCustomAttributes(inherit: false);
                }
                attributes = _declaredOnlyAttributeCache;
            }

            return new Collection<T>(TypeHelper.OfType<T>(attributes));
        }

        // For unit tests for initializing mock objects. Controller may not have a type, so we can't do the normal Initialize() path. 
        internal void Initialize(HttpConfiguration configuration)
        {
            _configuration = configuration;
        }

        // Initialize the Controller Descriptor. This invokes all IControllerConfiguration attributes
        // on the controller type (and its base types)
        private void Initialize()
        {
            InvokeAttributesOnControllerType(this, ControllerType);
        }

        // Helper to invoke any Controller config attributes on this controller type or its base classes.
        private static void InvokeAttributesOnControllerType(HttpControllerDescriptor controllerDescriptor, Type type)
        {
            Contract.Assert(controllerDescriptor != null);

            if (type == null)
            {
                return;
            }
            // Initialize base class before derived classes (same order as ctors).
            InvokeAttributesOnControllerType(controllerDescriptor, type.BaseType);

            // Check for attribute
            object[] attrs = type.GetCustomAttributes(inherit: false);
            foreach (object attr in attrs)
            {
                var controllerConfig = attr as IControllerConfiguration;
                if (controllerConfig != null)
                {
                    var originalConfig = controllerDescriptor.Configuration;
                    var controllerSettings = new HttpControllerSettings(originalConfig);
                    controllerConfig.Initialize(controllerSettings, controllerDescriptor);
                    controllerDescriptor.Configuration = HttpConfiguration.ApplyControllerSettings(controllerSettings, originalConfig);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpControllerDescriptorExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Controllers
{
    internal static class HttpControllerDescriptorExtensions
    {
        private const string AttributeRoutedPropertyKey = "MS_IsAttributeRouted";

        public static bool IsAttributeRouted(this HttpControllerDescriptor controllerDescriptor)
        {
            if (controllerDescriptor == null)
            {
                throw new ArgumentNullException("controllerDescriptor");
            }

            object value;
            controllerDescriptor.Properties.TryGetValue(AttributeRoutedPropertyKey, out value);
            return value as bool? ?? false;
        }

        public static void SetIsAttributeRouted(this HttpControllerDescriptor controllerDescriptor, bool value)
        {
            if (controllerDescriptor == null)
            {
                throw new ArgumentNullException("controllerDescriptor");
            }

            controllerDescriptor.Properties[AttributeRoutedPropertyKey] = value;
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpControllerSettings.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Formatting;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Controllers
{
    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "ServicesContainer is disposed with the configuration")]
    public sealed class HttpControllerSettings
    {
        private MediaTypeFormatterCollection _formatters;
        private ParameterBindingRulesCollection _parameterBindingRules;
        private ServicesContainer _services;
        private HttpConfiguration _configuration;

        public HttpControllerSettings(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            _configuration = configuration;
        }

        public MediaTypeFormatterCollection Formatters
        {
            get
            {
                if (_formatters == null)
                {
                    _formatters = new MediaTypeFormatterCollection(_configuration.Formatters);
                }

                return _formatters;
            }
        }

        public ParameterBindingRulesCollection ParameterBindingRules
        {
            get
            {
                if (_parameterBindingRules == null)
                {
                    _parameterBindingRules = new ParameterBindingRulesCollection();
                    foreach (var parameterBindingRule in _configuration.ParameterBindingRules)
                    {
                        _parameterBindingRules.Add(parameterBindingRule);
                    }
                }

                return _parameterBindingRules;
            }
        }

        public ServicesContainer Services
        {
            get
            {
                if (_services == null)
                {
                    _services = new ControllerServices(_configuration.Services);
                }

                return _services;
            }
        }

        internal bool IsFormatterCollectionInitialized
        {
            get { return _formatters != null; }
        }

        internal bool IsParameterBindingRuleCollectionInitialized
        {
            get { return _parameterBindingRules != null; }
        }

        internal bool IsServiceCollectionInitialized
        {
            get { return _services != null; }
        }
    }
}

================================================
FILE: src/System.Web.Http/Controllers/HttpParameterBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Metadata;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Describes how a parameter is bound. The binding should be static (based purely on the descriptor) and 
    /// can be shared across requests. 
    /// </summary>
    public abstract class HttpParameterBinding
    {
        private readonly HttpParameterDescriptor _descriptor;

        protected HttpParameterBinding(HttpParameterDescriptor descriptor)
        {
            if (descriptor == null)
            {
                throw Error.ArgumentNull("descriptor");
            }
            _descriptor = descriptor;
        }

        /// <summary>
        /// True iff this binding owns the body. This is important since the body can be a stream that is only read once.
        /// This lets us know who is trying to read the body, and enforce that there is only one reader. 
        /// </summary>
        public virtual bool WillReadBody
        {
            get { return false; }
        }

        /// <summary>
        /// True if the binding was successful and ExecuteBinding can be called. 
        /// False if there was an error determining this binding. This means a developer error somewhere, such as 
        /// configuration, parameter types, proper attributes, etc. 
        /// </summary>
        public bool IsValid
        {
            get { return ErrorMessage == null; }
        }

        /// <summary>
        /// Get an error message describing why this binding is invalid. 
        /// </summary>
        public virtual string ErrorMessage
        {
            get { return null; }
        }

        public HttpParameterDescriptor Descriptor
        {
            get { return _descriptor; }
        }

        /// <summary>
        /// Execute the binding for the given request.
        /// On success, this will add the parameter to the actionContext.ActionArguments dictionary.
        /// Caller ensures <see cref="IsValid"/> is true.
        /// </summary>
        /// <param name="metadataProvider">metadata provider to use for validation.</param>
        /// <param name="actionContext">action context for the binding. This contains the parameter dictionary that will get populated.</param>
        /// <param name="cancellationToken">Cancellation token for cancelling the binding operation. Or a binder can also bind a parameter to this.</param>
        /// <returns>Task that is signaled when the binding is complete. For simple bindings from a URI, this should be signalled immediately.
        /// For bindings that read the content body, this may do network IO.</returns>
        public abstract Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken);

        /// <summary>
        /// Helper to get the parameter value from the action context's argument dictionary
        /// </summary>
        /// <param name="actionContext">action context </param>
        /// <returns>the value for this parameter in the given action context, or null if the parameter has not yet been set.</returns>
        protected object GetValue(HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            object value;
            actionContext.ActionArguments.TryGetValue(Descriptor.ParameterName, out value);
            return value;
        }

        /// <summary>
        /// Helper to set the result of this parameter binding in the action context's argument dictionary. 
        /// </summary>
        /// <param name="actionContext">action context.</param>
        /// <param name="value">parameter value.</param>
        protected void SetValue(HttpActionContext actionContext, object value)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }
            actionContext.ActionArguments[Descriptor.ParameterName] = value;
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpParameterDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Web.Http.Internal;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;

namespace System.Web.Http.Controllers
{
    public abstract class HttpParameterDescriptor
    {
        private readonly ConcurrentDictionary<object, object> _properties = new ConcurrentDictionary<object, object>();

        private ParameterBindingAttribute _parameterBindingAttribute;
        private bool _searchedModelBinderAttribute;
        private HttpConfiguration _configuration;
        private HttpActionDescriptor _actionDescriptor;

        protected HttpParameterDescriptor()
        {
        }

        protected HttpParameterDescriptor(HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            _actionDescriptor = actionDescriptor;
            _configuration = _actionDescriptor.Configuration;
        }

        public HttpConfiguration Configuration
        {
            get { return _configuration; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _configuration = value;
            }
        }

        public HttpActionDescriptor ActionDescriptor
        {
            get { return _actionDescriptor; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _actionDescriptor = value;
            }
        }

        /// <summary>
        /// Gets the properties associated with this instance.
        /// </summary>
        public ConcurrentDictionary<object, object> Properties
        {
            get { return _properties; }
        }

        public virtual object DefaultValue
        {
            get { return null; }
        }

        public abstract string ParameterName { get; }

        public abstract Type ParameterType { get; }

        public virtual string Prefix
        {
            get
            {
                ParameterBindingAttribute attribute = ParameterBinderAttribute;
                ModelBinderAttribute modelAttribute = attribute as ModelBinderAttribute;
                return modelAttribute != null
                           ? modelAttribute.Name
                           : null;
            }
        }

        /// <summary>
        /// Gets a value indicating whether the parameter is optional.
        /// </summary>
        /// <value>
        /// <c>true</c> if the parameter is optional; otherwise, <c>false</c>.
        /// </value>
        public virtual bool IsOptional
        {
            get { return false; }
        }

        /// <summary>
        /// Return a <see cref="ParameterBindingAttribute"/> if present on this parameter's signature or declared type.
        /// Returns null if no attribute is specified.
        /// </summary>
        public virtual ParameterBindingAttribute ParameterBinderAttribute
        {
            get
            {
                if (_parameterBindingAttribute == null)
                {
                    if (!_searchedModelBinderAttribute)
                    {
                        _searchedModelBinderAttribute = true;
                        _parameterBindingAttribute = FindParameterBindingAttribute();
                    }
                }

                return _parameterBindingAttribute;
            }

            set { _parameterBindingAttribute = value; }
        }

        public virtual Collection<T> GetCustomAttributes<T>() where T : class
        {
            return new Collection<T>();
        }

        private ParameterBindingAttribute FindParameterBindingAttribute()
        {
            // Can be on parameter itself or on the parameter's type.  Nearest wins.
            return ChooseAttribute(GetCustomAttributes<ParameterBindingAttribute>())
                ?? ChooseAttribute(ParameterType.GetCustomAttributes<ParameterBindingAttribute>(false));
        }

        private static ParameterBindingAttribute ChooseAttribute(IList<ParameterBindingAttribute> list)
        {
            if (list.Count == 0)
            {
                return null;
            }
            if (list.Count > 1)
            {
                // Multiple attributes specified at the same level
                return new AmbiguousParameterBindingAttribute();
            }
            return list[0];
        }

        // Helper class to return an error binding if an parameter has an invalid attribute combination. 
        private sealed class AmbiguousParameterBindingAttribute : ParameterBindingAttribute
        {
            public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter)
            {
                string message = Error.Format(SRResources.ParameterBindingConflictingAttributes, parameter.ParameterName);
                return parameter.BindAsError(message);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/HttpParameterDescriptorExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http.Formatting;
using System.Web.Http.ModelBinding;
using System.Web.Http.Validation;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Convenience helpers to easily create specific types of parameter bindings
    /// These provide a direct programmatic counterpart to the <see cref="ParameterBindingAttribute"/> attributes. 
    /// </summary>
    public static class ParameterBindingExtensions
    {
        /// <summary>
        /// If we know statically that this binding can never succeed, then use an error binding.
        /// This will prevent the action from executing.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="message">error message for user.</param>
        /// <returns>an error binding. Specifically, IsValid on the binding will be false.</returns>
        public static HttpParameterBinding BindAsError(this HttpParameterDescriptor parameter, string message)
        {
            return new ErrorParameterBinding(parameter, message);
        }

        /// <summary>
        /// Bind the parameter as if it had the given attribute on the declaration.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="attribute">attribute to describe the binding.</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithAttribute(this HttpParameterDescriptor parameter, ParameterBindingAttribute attribute)
        {
            return attribute.GetBinding(parameter);
        }

        /// <summary>
        /// Bind the parameter using model binding. Get all other information from the configuration.
        /// This is the same as having a plain ModelBinderAttribute on the parameter.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithModelBinding(this HttpParameterDescriptor parameter)
        {
            return BindWithAttribute(parameter, new ModelBinderAttribute());
        }

        /// <summary>
        /// Bind the parameter using the given model binder. 
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="binder">model binder to use on parameter</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithModelBinding(this HttpParameterDescriptor parameter, IModelBinder binder)
        {
            HttpConfiguration config = parameter.Configuration;
            IEnumerable<ValueProviderFactory> valueProviderFactories = new ModelBinderAttribute().GetValueProviderFactories(config);

            return BindWithModelBinding(parameter, binder, valueProviderFactories);
        }

        /// <summary>
        /// Bind the parameter using default model binding but with the supplied value providers.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="valueProviderFactories">value provider factories to feed to model binders</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithModelBinding(this HttpParameterDescriptor parameter, params ValueProviderFactory[] valueProviderFactories)
        {
            return BindWithModelBinding(parameter, (IEnumerable<ValueProviderFactory>)valueProviderFactories);
        }

        /// <summary>
        /// Bind the parameter using default model binding but with the supplied value providers.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="valueProviderFactories">value provider factories to feed to model binders</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithModelBinding(this HttpParameterDescriptor parameter, IEnumerable<ValueProviderFactory> valueProviderFactories)
        {
            HttpConfiguration config = parameter.Configuration;
            IModelBinder binder = new ModelBinderAttribute().GetModelBinder(config, parameter.ParameterType);

            return new ModelBinderParameterBinding(parameter, binder, valueProviderFactories);
        }

        /// <summary>
        /// Bind the parameter using the supplied binder and value providers.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="binder">model binder to use for binding.</param>
        /// <param name="valueProviderFactories">value provider factories to feed to model binder.</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithModelBinding(this HttpParameterDescriptor parameter, IModelBinder binder, IEnumerable<ValueProviderFactory> valueProviderFactories)
        {
            return new ModelBinderParameterBinding(parameter, binder, valueProviderFactories);
        }

        /// <summary>
        /// Bind the parameter from the body using the formatters from the configuration. 
        /// This is like having a [FromBody] attribute on the parameter
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithFormatter(this HttpParameterDescriptor parameter)
        {
            HttpConfiguration config = parameter.Configuration;
            IEnumerable<MediaTypeFormatter> formatters = config.Formatters;
            IBodyModelValidator validators = config.Services.GetBodyModelValidator();

            return new FormatterParameterBinding(parameter, formatters, validators);
        }

        /// <summary>
        /// Bind this parameter from the body using the supplied set of formatters.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="formatters">formatters to choose from when binding the body</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithFormatter(this HttpParameterDescriptor parameter, params MediaTypeFormatter[] formatters)
        {
            return BindWithFormatter(parameter, (IEnumerable<MediaTypeFormatter>)formatters);
        }

        /// <summary>
        /// Bind this parameter from the body using the supplied set of formatters.
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="formatters">formatters to choose from when binding the body</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithFormatter(this HttpParameterDescriptor parameter, IEnumerable<MediaTypeFormatter> formatters)
        {
            HttpConfiguration config = parameter.Configuration;
            IBodyModelValidator validators = config.Services.GetBodyModelValidator();
            return new FormatterParameterBinding(parameter, formatters, validators);
        }

        /// <summary>
        /// Bind this parameter from the body using the supplied set of formatters and validator. 
        /// </summary>
        /// <param name="parameter">parameter to provide binding for.</param>
        /// <param name="formatters">formatters to choose from when binding the body</param>
        /// <param name="bodyModelValidator">a validator. Null to disable validation for this parameter.</param>
        /// <returns>a binding</returns>
        public static HttpParameterBinding BindWithFormatter(this HttpParameterDescriptor parameter, IEnumerable<MediaTypeFormatter> formatters, IBodyModelValidator bodyModelValidator)
        {
            return new FormatterParameterBinding(parameter, formatters, bodyModelValidator);
        }
    }
}

================================================
FILE: src/System.Web.Http/Controllers/HttpRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Web.Http.Routing;

namespace System.Web.Http.Controllers
{
    /// <summary>Represents the context associated with a request.</summary>
    public class HttpRequestContext
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpRequestContext"/> class.
        /// </summary>
        public HttpRequestContext()
        {
            // This is constructor is available to allow placing breakpoints on construction.
        }

        /// <summary>Gets or sets the client certificate.</summary>
        public virtual X509Certificate2 ClientCertificate { get; set; }

        /// <summary>Gets or sets the configuration.</summary>
        public virtual HttpConfiguration Configuration { get; set; }

        /// <summary>
        /// Gets or sets a value indicating whether error details, such as exception messages and stack traces,
        /// should be included in the response for this request.
        /// </summary>
        public virtual bool IncludeErrorDetail { get; set; }

        /// <summary>Gets or sets a value indicating whether the request originates from a local address.</summary>
        public virtual bool IsLocal { get; set; }

        /// <summary>Gets or sets the principal.</summary>
        public virtual IPrincipal Principal { get; set; }

        /// <summary>Gets or sets the route data.</summary>
        public virtual IHttpRouteData RouteData { get; set; }

        /// <summary>Gets or sets the factory used to generate URLs to other APIs.</summary>
        public virtual UrlHelper Url { get; set; }

        /// <summary>Gets or sets the virtual path root.</summary>
        public virtual string VirtualPathRoot { get; set; }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/IActionHttpMethodProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;

namespace System.Web.Http.Controllers
{
    public interface IActionHttpMethodProvider
    {
        Collection<HttpMethod> HttpMethods { get; }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/IActionResultConverter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Threading;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// A contract for a conversion routine that can take the result of an action returned from
    /// <see cref="HttpActionDescriptor.ExecuteAsync(HttpControllerContext, IDictionary{string, object}, CancellationToken)"/>
    /// and synchronously convert it to an instance of <see cref="HttpResponseMessage"/>.
    /// </summary>
    /// <remarks>
    /// This interface is not used when the runtime return value of an action is an <see cref="IHttpActionResult"/>.
    /// </remarks>
    public interface IActionResultConverter
    {
        HttpResponseMessage Convert(HttpControllerContext controllerContext, object actionResult);
    }
}

================================================
FILE: src/System.Web.Http/Controllers/IActionValueBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Controllers
{
    public interface IActionValueBinder
    {
        HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor);
    }
}


================================================
FILE: src/System.Web.Http/Controllers/IControllerConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// If a controller is decorated with an attribute with this interface, then it gets invoked
    /// to initialize the controller settings. 
    /// </summary>
    public interface IControllerConfiguration
    {
        /// <summary>
        /// Callback invoked to set per-controller overrides for this controllerDescriptor.
        /// </summary>
        /// <param name="controllerSettings">The controller settings to initialize.</param>
        /// <param name="controllerDescriptor">The controller descriptor. Note that the <see cref="HttpControllerDescriptor"/> can be associated with the derived controller type given that <see cref="IControllerConfiguration"/> is inherited.</param>
        void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor);
    }
}


================================================
FILE: src/System.Web.Http/Controllers/IHttpActionInvoker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Controllers
{
    public interface IHttpActionInvoker
    {
        Task<HttpResponseMessage> InvokeActionAsync(HttpActionContext actionContext, CancellationToken cancellationToken);
    }
}


================================================
FILE: src/System.Web.Http/Controllers/IHttpActionSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
namespace System.Web.Http.Controllers
{
    public interface IHttpActionSelector
    {
        /// <summary>
        /// Selects the action.
        /// </summary>
        /// <param name="controllerContext">The controller context.</param>
        /// <returns>The selected action.</returns>
        HttpActionDescriptor SelectAction(HttpControllerContext controllerContext);

        /// <summary>
        /// Returns a map, keyed by action string, of all <see cref="HttpActionDescriptor"/> that the selector can select. 
        /// This is primarily called by <see cref="System.Web.Http.Description.IApiExplorer"/> to discover all the possible actions in the controller.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <returns>A map of <see cref="HttpActionDescriptor"/> that the selector can select, or null if the selector does not have a well-defined mapping of <see cref="HttpActionDescriptor"/>.</returns>
        ILookup<string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor);
    }
}


================================================
FILE: src/System.Web.Http/Controllers/IHttpController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Controllers
{
    public interface IHttpController
    {
        Task<HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken);
    }
}


================================================
FILE: src/System.Web.Http/Controllers/ReflectedHttpActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Internal;
using System.Web.Http.Properties;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// An action descriptor representing a reflected synchronous or asynchronous action method.
    /// </summary>
    public class ReflectedHttpActionDescriptor : HttpActionDescriptor
    {
        private static readonly object[] _empty = new object[0];

        private readonly Lazy<Collection<HttpParameterDescriptor>> _parameters;
        private ParameterInfo[] _parameterInfos;

        private Lazy<ActionExecutor> _actionExecutor;
        private MethodInfo _methodInfo;
        private Type _returnType;
        private string _actionName;
        private Collection<HttpMethod> _supportedHttpMethods;

        // Getting custom attributes via reflection is slow. 
        // But iterating over a object[] to pick out specific types is fast. 
        // Furthermore, many different services may call to ask for different attributes, so we have multiple callers. 
        // That means there's not a single cache for the callers, which means there's some value caching here.
        // This cache can be a 2x speedup in some benchmarks.
        private object[] _attributeCache;
        private object[] _declaredOnlyAttributeCache;

        private static readonly HttpMethod[] _supportedHttpMethodsByConvention = 
        { 
            HttpMethod.Get, 
            HttpMethod.Post, 
            HttpMethod.Put, 
            HttpMethod.Delete, 
            HttpMethod.Head, 
            HttpMethod.Options, 
            new HttpMethod("PATCH") 
        };

        /// <summary>
        /// Initializes a new instance of the <see cref="ReflectedHttpActionDescriptor"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public ReflectedHttpActionDescriptor()
        {
            _parameters = new Lazy<Collection<HttpParameterDescriptor>>(() => InitializeParameterDescriptors());
            _supportedHttpMethods = new Collection<HttpMethod>();
        }

        public ReflectedHttpActionDescriptor(HttpControllerDescriptor controllerDescriptor, MethodInfo methodInfo)
            : base(controllerDescriptor)
        {
            if (methodInfo == null)
            {
                throw Error.ArgumentNull("methodInfo");
            }

            InitializeProperties(methodInfo);
            _parameters = new Lazy<Collection<HttpParameterDescriptor>>(() => InitializeParameterDescriptors());
        }

        public override string ActionName
        {
            get { return _actionName; }
        }

        public override Collection<HttpMethod> SupportedHttpMethods
        {
            get { return _supportedHttpMethods; }
        }

        public MethodInfo MethodInfo
        {
            get { return _methodInfo; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                InitializeProperties(value);
            }
        }

        private ParameterInfo[] ParameterInfos
        {
            get
            {
                if (_parameterInfos == null)
                {
                    _parameterInfos = _methodInfo.GetParameters();
                }
                return _parameterInfos;
            }
        }

        /// <inheritdoc/>
        public override Type ReturnType
        {
            get { return _returnType; }
        }

        /// <inheritdoc/>
        public override Collection<T> GetCustomAttributes<T>(bool inherit)
        {
            object[] attributes = inherit ? _attributeCache : _declaredOnlyAttributeCache;
            return new Collection<T>(TypeHelper.OfType<T>(attributes));
        }

        /// <inheritdoc/>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The caught exception type is reflected into a faulted task.")]
        public override Task<object> ExecuteAsync(HttpControllerContext controllerContext, IDictionary<string, object> arguments, CancellationToken cancellationToken)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            if (arguments == null)
            {
                throw Error.ArgumentNull("arguments");
            }

            if (cancellationToken.IsCancellationRequested)
            {
                return TaskHelpers.Canceled<object>();
            }

            try
            {
                object[] argumentValues = PrepareParameters(arguments, controllerContext);
                return _actionExecutor.Value.Execute(controllerContext.Controller, argumentValues);
            }
            catch (Exception e)
            {
                return TaskHelpers.FromError<object>(e);
            }
        }

        public override Collection<IFilter> GetFilters()
        {
            return new Collection<IFilter>(GetCustomAttributes<IFilter>().Concat(base.GetFilters()).ToList());
        }

        public override Collection<HttpParameterDescriptor> GetParameters()
        {
            return _parameters.Value;
        }

        private void InitializeProperties(MethodInfo methodInfo)
        {
            _methodInfo = methodInfo;
            _parameterInfos = null;
            _returnType = GetReturnType(methodInfo);
            _actionExecutor = new Lazy<ActionExecutor>(() => InitializeActionExecutor(_methodInfo));
            _declaredOnlyAttributeCache = _methodInfo.GetCustomAttributes(inherit: false);
            _attributeCache = _methodInfo.GetCustomAttributes(inherit: true);
            _actionName = GetActionName(_methodInfo, _attributeCache);
            _supportedHttpMethods = GetSupportedHttpMethods(_methodInfo, _attributeCache);
        }

        internal static Type GetReturnType(MethodInfo methodInfo)
        {
            Type result = methodInfo.ReturnType;
            if (typeof(Task).IsAssignableFrom(result))
            {
                result = TypeHelper.GetTaskInnerTypeOrNull(methodInfo.ReturnType);
            }
            if (result == typeof(void))
            {
                result = null;
            }
            return result;
        }

        private Collection<HttpParameterDescriptor> InitializeParameterDescriptors()
        {
            Contract.Assert(_methodInfo != null);

            List<HttpParameterDescriptor> parameterInfos = ParameterInfos.Select(
                (item) => new ReflectedHttpParameterDescriptor(this, item)).ToList<HttpParameterDescriptor>();
            return new Collection<HttpParameterDescriptor>(parameterInfos);
        }

        private object[] PrepareParameters(IDictionary<string, object> parameters, HttpControllerContext controllerContext)
        {
            // This is on a hotpath, so a quick check to avoid the allocation if we have no parameters. 
            if (_parameters.Value.Count == 0)
            {
                return _empty;
            }

            ParameterInfo[] parameterInfos = ParameterInfos;
            int parameterCount = parameterInfos.Length;
            object[] parameterValues = new object[parameterCount];
            for (int parameterIndex = 0; parameterIndex < parameterCount; parameterIndex++)
            {
                parameterValues[parameterIndex] = ExtractParameterFromDictionary(parameterInfos[parameterIndex], parameters, controllerContext);
            }
            return parameterValues;
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller is responsible for disposing of response instance.")]
        private object ExtractParameterFromDictionary(ParameterInfo parameterInfo, IDictionary<string, object> parameters, HttpControllerContext controllerContext)
        {
            object value;

            if (!parameters.TryGetValue(parameterInfo.Name, out value))
            {
                // the key should always be present, even if the parameter value is null
                throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    SRResources.BadRequest,
                    Error.Format(SRResources.ReflectedActionDescriptor_ParameterNotInDictionary,
                                 parameterInfo.Name, parameterInfo.ParameterType, MethodInfo, MethodInfo.DeclaringType)));
            }

            if (value == null && !TypeHelper.TypeAllowsNullValue(parameterInfo.ParameterType))
            {
                // tried to pass a null value for a non-nullable parameter type
                throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    SRResources.BadRequest,
                    Error.Format(SRResources.ReflectedActionDescriptor_ParameterCannotBeNull,
                                    parameterInfo.Name, parameterInfo.ParameterType, MethodInfo, MethodInfo.DeclaringType)));
            }

            if (value != null && !parameterInfo.ParameterType.IsInstanceOfType(value))
            {
                // value was supplied but is not of the proper type
                throw new HttpResponseException(controllerContext.Request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    SRResources.BadRequest,
                    Error.Format(SRResources.ReflectedActionDescriptor_ParameterValueHasWrongType,
                                    parameterInfo.Name, MethodInfo, MethodInfo.DeclaringType, value.GetType(), parameterInfo.ParameterType)));
            }

            return value;
        }

        private static string GetActionName(MethodInfo methodInfo, object[] actionAttributes)
        {
            ActionNameAttribute nameAttribute = TypeHelper.OfType<ActionNameAttribute>(actionAttributes).FirstOrDefault();
            return nameAttribute != null
                       ? nameAttribute.Name
                       : methodInfo.Name;
        }

        private static Collection<HttpMethod> GetSupportedHttpMethods(MethodInfo methodInfo, object[] actionAttributes)
        {
            Collection<HttpMethod> supportedHttpMethods = new Collection<HttpMethod>();
            ICollection<IActionHttpMethodProvider> httpMethodProviders = TypeHelper.OfType<IActionHttpMethodProvider>(actionAttributes);
            if (httpMethodProviders.Count > 0)
            {
                // Get HttpMethod from attributes
                foreach (IActionHttpMethodProvider httpMethodSelector in httpMethodProviders)
                {
                    foreach (HttpMethod httpMethod in httpMethodSelector.HttpMethods)
                    {
                        supportedHttpMethods.Add(httpMethod);
                    }
                }
            }
            else
            {
                // Get HttpMethod from method name convention 
                for (int i = 0; i < _supportedHttpMethodsByConvention.Length; i++)
                {
                    if (methodInfo.Name.StartsWith(_supportedHttpMethodsByConvention[i].Method, StringComparison.OrdinalIgnoreCase))
                    {
                        supportedHttpMethods.Add(_supportedHttpMethodsByConvention[i]);
                        break;
                    }
                }
            }

            if (supportedHttpMethods.Count == 0)
            {
                // Use POST as the default HttpMethod
                supportedHttpMethods.Add(HttpMethod.Post);
            }

            return supportedHttpMethods;
        }

        // Implementing Equals and GetHashCode is needed here because when tracing is enabled, a different set of action descriptors
        // are available at configuration time for attribute routing and at runtime. This is because the default action selector
        // clears its action descriptor cache when the controller descriptor is different. And since tracing wraps the controller
        // descriptor for tracing, the cache gets cleared and new action descriptors get created for tracing. We need to compare
        // the action descriptors by method info to be able to correlate attribute routing actions to the tracing action descriptors.

        /// <inheritdoc />
        public override int GetHashCode()
        {
            if (_methodInfo != null)
            {
                return _methodInfo.GetHashCode();
            }

            return base.GetHashCode();
        }

        /// <inheritdoc />
        public override bool Equals(object obj)
        {
            if (_methodInfo != null)
            {
                ReflectedHttpActionDescriptor otherDescriptor = obj as ReflectedHttpActionDescriptor;
                if (otherDescriptor == null)
                {
                    return false;
                }

                return _methodInfo.Equals(otherDescriptor._methodInfo);
            }

            return base.Equals(obj);
        }

        private static ActionExecutor InitializeActionExecutor(MethodInfo methodInfo)
        {
            if (methodInfo.ContainsGenericParameters)
            {
                throw Error.InvalidOperation(SRResources.ReflectedHttpActionDescriptor_CannotCallOpenGenericMethods,
                                     methodInfo, methodInfo.ReflectedType.FullName);
            }

            return new ActionExecutor(methodInfo);
        }

        private sealed class ActionExecutor
        {
            private readonly Func<object, object[], Task<object>> _executor;
            private static MethodInfo _convertOfTMethod = typeof(ActionExecutor).GetMethod("Convert", BindingFlags.Static | BindingFlags.NonPublic);

            public ActionExecutor(MethodInfo methodInfo)
            {
                Contract.Assert(methodInfo != null);
                _executor = GetExecutor(methodInfo);
            }

            public Task<object> Execute(object instance, object[] arguments)
            {
                return _executor(instance, arguments);
            }

            // Method called via reflection.
            private static Task<object> Convert<T>(object taskAsObject)
            {
                Task<T> task = (Task<T>)taskAsObject;
                return task.CastToObject<T>();
            }

            // Do not inline or optimize this method to avoid stack-related reflection demand issues when
            // running from the GAC in medium trust
            [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
            private static Func<object, Task<object>> CompileGenericTaskConversionDelegate(Type taskValueType)
            {
                Contract.Assert(taskValueType != null);

                return (Func<object, Task<object>>)Delegate.CreateDelegate(typeof(Func<object, Task<object>>), _convertOfTMethod.MakeGenericMethod(taskValueType));
            }

            private static Func<object, object[], Task<object>> GetExecutor(MethodInfo methodInfo)
            {
                // Parameters to executor
                ParameterExpression instanceParameter = Expression.Parameter(typeof(object), "instance");
                ParameterExpression parametersParameter = Expression.Parameter(typeof(object[]), "parameters");

                // Build parameter list
                List<Expression> parameters = new List<Expression>();
                ParameterInfo[] paramInfos = methodInfo.GetParameters();
                for (int i = 0; i < paramInfos.Length; i++)
                {
                    ParameterInfo paramInfo = paramInfos[i];
                    BinaryExpression valueObj = Expression.ArrayIndex(parametersParameter, Expression.Constant(i));
                    UnaryExpression valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);

                    // valueCast is "(Ti) parameters[i]"
                    parameters.Add(valueCast);
                }

                // Call method
                UnaryExpression instanceCast = (!methodInfo.IsStatic) ? Expression.Convert(instanceParameter, methodInfo.ReflectedType) : null;
                MethodCallExpression methodCall = Expression.Call(instanceCast, methodInfo, parameters);

                // methodCall is "((MethodInstanceType) instance).method((T0) parameters[0], (T1) parameters[1], ...)"
                // Create function
                if (methodCall.Type == typeof(void))
                {
                    // for: public void Action()
                    Expression<Action<object, object[]>> lambda = Expression.Lambda<Action<object, object[]>>(methodCall, instanceParameter, parametersParameter);
                    Action<object, object[]> voidExecutor = lambda.Compile();
                    return (instance, methodParameters) =>
                    {
                        voidExecutor(instance, methodParameters);
                        return TaskHelpers.NullResult();
                    };
                }
                else
                {
                    // must coerce methodCall to match Func<object, object[], object> signature
                    UnaryExpression castMethodCall = Expression.Convert(methodCall, typeof(object));
                    Expression<Func<object, object[], object>> lambda = Expression.Lambda<Func<object, object[], object>>(castMethodCall, instanceParameter, parametersParameter);
                    Func<object, object[], object> compiled = lambda.Compile();
                    if (methodCall.Type == typeof(Task))
                    {
                        // for: public Task Action()
                        return (instance, methodParameters) =>
                        {
                            Task r = (Task)compiled(instance, methodParameters);
                            ThrowIfWrappedTaskInstance(methodInfo, r.GetType());
                            return r.CastToObject();
                        };
                    }
                    else if (typeof(Task).IsAssignableFrom(methodCall.Type))
                    {
                        // for: public Task<T> Action()
                        // constructs: return (Task<object>)Convert<T>(((Task<T>)instance).method((T0) param[0], ...))
                        Type taskValueType = TypeHelper.GetTaskInnerTypeOrNull(methodCall.Type);
                        var compiledConversion = CompileGenericTaskConversionDelegate(taskValueType);

                        return (instance, methodParameters) =>
                        {
                            object callResult = compiled(instance, methodParameters);
                            Task<object> convertedResult = compiledConversion(callResult);
                            return convertedResult;
                        };
                    }
                    else
                    {
                        // for: public T Action()
                        return (instance, methodParameters) =>
                        {
                            var result = compiled(instance, methodParameters);
                            // Throw when the result of a method is Task. Asynchronous methods need to declare that they
                            // return a Task.
                            Task resultAsTask = result as Task;
                            if (resultAsTask != null)
                            {
                                throw Error.InvalidOperation(SRResources.ActionExecutor_UnexpectedTaskInstance,
                                    methodInfo.Name, methodInfo.DeclaringType.Name);
                            }
                            return Task.FromResult(result);
                        };
                    }
                }
            }

            private static void ThrowIfWrappedTaskInstance(MethodInfo method, Type type)
            {
                // Throw if a method declares a return type of Task and returns an instance of Task<Task> or Task<Task<T>>
                // This most likely indicates that the developer forgot to call Unwrap() somewhere.
                Contract.Assert(method.ReturnType == typeof(Task));
                // Fast path: check if type is exactly Task first.
                if (type != typeof(Task))
                {
                    Type innerTaskType = TypeHelper.GetTaskInnerTypeOrNull(type);
                    if (innerTaskType != null && typeof(Task).IsAssignableFrom(innerTaskType))
                    {
                        throw Error.InvalidOperation(SRResources.ActionExecutor_WrappedTaskInstance,
                            method.Name, method.DeclaringType.Name, type.FullName);
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/ReflectedHttpParameterDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Reflection;
using System.Web.Http.Internal;

namespace System.Web.Http.Controllers
{
    public class ReflectedHttpParameterDescriptor : HttpParameterDescriptor
    {
        private ParameterInfo _parameterInfo;

        public ReflectedHttpParameterDescriptor(HttpActionDescriptor actionDescriptor, ParameterInfo parameterInfo)
            : base(actionDescriptor)
        {
            if (parameterInfo == null)
            {
                throw Error.ArgumentNull("parameterInfo");
            }

            ParameterInfo = parameterInfo;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ReflectedHttpParameterDescriptor"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public ReflectedHttpParameterDescriptor()
        {
        }

        public override object DefaultValue
        {
            get
            {
                object value;
                if (ParameterInfo.TryGetDefaultValue(out value))
                {
                    return value;
                }
                else
                {
                    return base.DefaultValue;
                }
            }
        }

        public ParameterInfo ParameterInfo
        {
            get { return _parameterInfo; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _parameterInfo = value;
            }
        }

        /// <summary>
        /// Gets a value indicating whether the parameter is optional.
        /// </summary>
        /// <value>
        /// <c>true</c> if the parameter is optional; otherwise, <c>false</c>.
        /// </value>
        public override bool IsOptional
        {
            get { return ParameterInfo.IsOptional; }
        }

        public override string ParameterName
        {
            get { return ParameterInfo.Name; }
        }

        public override Type ParameterType
        {
            get { return ParameterInfo.ParameterType; }
        }

        public override Collection<TAttribute> GetCustomAttributes<TAttribute>()
        {
            return new Collection<TAttribute>((TAttribute[])ParameterInfo.GetCustomAttributes(typeof(TAttribute), inherit: false)); 
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/RequestBackedHttpRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Web.Http.Routing;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Represents a request context that does not change the behavior of legacy properties. Once a request context is
    /// set, things like route data and client certificate start coming from it instead of from the legacy request
    /// properties. This class is a request context that will do the same thing as the legacy request properties would
    /// have done while still allowing GetRequestContext to return non-null.
    /// </summary>
    internal sealed class RequestBackedHttpRequestContext : HttpRequestContext
    {
        private HttpRequestMessage _request;

        private X509Certificate2 _certificate;
        private bool _certificateSet;

        private HttpConfiguration _configuration;
        private bool _configurationSet;

        private bool _includeErrorDetail;
        private bool _includeErrorDetailSet;

        private bool _isLocal;
        private bool _isLocalSet;

        private IHttpRouteData _routeData;
        private bool _routeDataSet;

        private UrlHelper _url;
        private bool _urlSet;

        private string _virtualPathRoot;
        private bool _virtualPathRootSet;

        public RequestBackedHttpRequestContext()
        {
            // We don't have to override Principal since the base class provides the simple property.
            Principal = Thread.CurrentPrincipal;
        }

        public RequestBackedHttpRequestContext(HttpRequestMessage request)
            : this()
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            _request = request;
        }

        public HttpRequestMessage Request
        {
            get
            {
                return _request;
            }
            set
            {
                _request = value;
            }
        }

        public override X509Certificate2 ClientCertificate
        {
            get
            {
                if (_certificateSet)
                {
                    return _certificate;
                }
                else if (_request != null)
                {
                    return _request.LegacyGetClientCertificate();
                }
                else
                {
                    return null;
                }
            }
            set
            {
                _certificate = value;
                _certificateSet = true;
            }
        }

        public override HttpConfiguration Configuration
        {
            get
            {
                if (_configurationSet)
                {
                    return _configuration;
                }
                else if (_request != null)
                {
                    return _request.LegacyGetConfiguration();
                }
                else
                {
                    return null;
                }
            }
            set
            {
                _configuration = value;
                _configurationSet = true;
            }
        }

        public override bool IncludeErrorDetail
        {
            get
            {
                if (_includeErrorDetailSet)
                {
                    return _includeErrorDetail;
                }
                else if (_request != null)
                {
                    return _request.LegacyShouldIncludeErrorDetail();
                }
                else
                {
                    return false;
                }
            }
            set
            {
                _includeErrorDetail = value;
                _includeErrorDetailSet = true;
            }
        }

        public override bool IsLocal
        {
            get
            {
                if (_isLocalSet)
                {
                    return _isLocal;
                }
                else if (_request != null)
                {
                    return _request.LegacyIsLocal();
                }
                else
                {
                    return false;
                }
            }
            set
            {
                _isLocal = value;
                _isLocalSet = true;
            }
        }

        public override IHttpRouteData RouteData
        {
            get
            {
                if (_routeDataSet)
                {
                    return _routeData;
                }
                else if (_request != null)
                {
                    return _request.LegacyGetRouteData();
                }
                else
                {
                    return null;
                }
            }
            set
            {
                _routeData = value;
                _routeDataSet = true;
            }
        }

        public override UrlHelper Url
        {
            get
            {
                if (_urlSet)
                {
                    return _url;
                }
                else if (_request != null)
                {
                    return new UrlHelper(_request);
                }
                else
                {
                    return null;
                }
            }
            set
            {
                _url = value;
                _urlSet = true;
            }
        }

        public override string VirtualPathRoot
        {
            get
            {
                if (_virtualPathRootSet)
                {
                    return _virtualPathRoot;
                }

                HttpConfiguration configuration = Configuration;

                if (configuration != null)
                {
                    return configuration.VirtualPathRoot;
                }
                else
                {
                    return null;
                }
            }
            set
            {
                _virtualPathRoot = value;
                _virtualPathRootSet = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/ResponseMessageResultConverter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Properties;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// A converter for actions with a return type of <see cref="HttpResponseMessage"/>.
    /// </summary>
    public class ResponseMessageResultConverter : IActionResultConverter
    {
        public HttpResponseMessage Convert(HttpControllerContext controllerContext, object actionResult)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            HttpResponseMessage response = (HttpResponseMessage)actionResult;
            if (response == null)
            {
                throw Error.InvalidOperation(SRResources.ResponseMessageResultConverter_NullHttpResponseMessage);
            }

            response.EnsureResponseHasRequest(controllerContext.Request);
            return response;
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/ValueResultConverter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// A converter for creating responses from actions that return an arbitrary T value.
    /// </summary>
    /// <typeparam name="T">The declared return type of an action.</typeparam>
    public class ValueResultConverter<T> : IActionResultConverter
    {
        public HttpResponseMessage Convert(HttpControllerContext controllerContext, object actionResult)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            HttpResponseMessage resultAsResponse = actionResult as HttpResponseMessage;
            if (resultAsResponse != null)
            {
                resultAsResponse.EnsureResponseHasRequest(controllerContext.Request);
                return resultAsResponse;
            }

            T value = (T)actionResult;
            return controllerContext.Request.CreateResponse<T>(HttpStatusCode.OK, value, controllerContext.Configuration);
        }
    }
}


================================================
FILE: src/System.Web.Http/Controllers/VoidResultConverter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// A converter for creating a response from actions that do not return a value.
    /// </summary>
    public class VoidResultConverter : IActionResultConverter
    {
        public HttpResponseMessage Convert(HttpControllerContext controllerContext, object actionResult)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            Contract.Assert(actionResult == null);
            return controllerContext.Request.CreateResponse(HttpStatusCode.NoContent);
        }
    }
}


================================================
FILE: src/System.Web.Http/Dependencies/EmptyResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Http.Dependencies
{
    internal class EmptyResolver : IDependencyResolver
    {
        private static readonly IDependencyResolver _instance = new EmptyResolver();

        private EmptyResolver()
        {
        }

        public static IDependencyResolver Instance
        {
            get { return _instance; }
        }

        public IDependencyScope BeginScope()
        {
            return this;
        }

        public void Dispose()
        {
        }

        public object GetService(Type serviceType)
        {
            return null;
        }

        public IEnumerable<object> GetServices(Type serviceType)
        {
            return Enumerable.Empty<object>();
        }
    }
}


================================================
FILE: src/System.Web.Http/Dependencies/IDependencyResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Dependencies
{
    /// <summary>
    /// Represents a dependency injection container.
    /// </summary>
    public interface IDependencyResolver : IDependencyScope
    {
        /// <summary>
        /// Starts a resolution scope. Objects which are resolved in the given scope will belong to
        /// that scope, and when the scope is disposed, those objects are returned to the container.
        /// Implementers should return a new instance of <see cref="IDependencyScope"/> every time this
        /// method is called, unless the container does not have any concept of scope or resource
        /// release (in which case, it would be okay to return 'this', so long as the calls to
        /// <see cref="IDisposable.Dispose"/> are effectively NOOPs).
        /// </summary>
        /// <returns>The dependency scope.</returns>
        IDependencyScope BeginScope();
    }
}


================================================
FILE: src/System.Web.Http/Dependencies/IDependencyScope.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Dependencies
{
    /// <summary>
    /// Represents a scope that is tracked by the dependency injection container. The scope is
    /// used to keep track of resources that have been provided, so that they can then be
    /// subsequently released when <see cref="IDisposable.Dispose"/> is called.
    /// </summary>
    public interface IDependencyScope : IDisposable
    {
        /// <summary>
        /// Gets an instance of the given <paramref name="serviceType"/>. Must return <c>null</c>
        /// if the service is not available (must not throw).
        /// </summary>
        /// <param name="serviceType">The object type.</param>
        /// <returns>The requested object, if found; <c>null</c> otherwise.</returns>
        object GetService(Type serviceType);

        /// <summary>
        /// Gets all instances of the given <paramref name="serviceType"/>. Must return an empty
        /// collection if the service is not available (must not return <c>null</c> or throw).
        /// </summary>
        /// <param name="serviceType">The object type.</param>
        /// <returns>A sequence of instances of the requested <paramref name="serviceType"/>. The sequence
        /// should be empty (not <c>null</c>) if no objects of the given type are available.</returns>
        IEnumerable<object> GetServices(Type serviceType);
    }
}


================================================
FILE: src/System.Web.Http/Description/ApiDescription.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;

namespace System.Web.Http.Description
{
    /// <summary>
    /// Describes an API defined by relative URI path and HTTP method.
    /// </summary>
    public class ApiDescription
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ApiDescription"/> class.
        /// </summary>
        public ApiDescription()
        {
            SupportedRequestBodyFormatters = new Collection<MediaTypeFormatter>();
            SupportedResponseFormatters = new Collection<MediaTypeFormatter>();
            ParameterDescriptions = new Collection<ApiParameterDescription>();
            ResponseDescription = new ResponseDescription();
        }

        /// <summary>
        /// Gets or sets the HTTP method.
        /// </summary>
        /// <value>
        /// The HTTP method.
        /// </value>
        public HttpMethod HttpMethod { get; set; }

        /// <summary>
        /// Gets or sets the relative path.
        /// </summary>
        /// <value>
        /// The relative path.
        /// </value>
        public string RelativePath { get; set; }

        /// <summary>
        /// Gets or sets the action descriptor that will handle the API.
        /// </summary>
        /// <value>
        /// The action descriptor.
        /// </value>
        public HttpActionDescriptor ActionDescriptor { get; set; }

        /// <summary>
        /// Gets or sets the registered route for the API.
        /// </summary>
        /// <value>
        /// The route.
        /// </value>
        public IHttpRoute Route { get; set; }

        /// <summary>
        /// Gets or sets the documentation of the API.
        /// </summary>
        /// <value>
        /// The documentation.
        /// </value>
        public string Documentation { get; set; }

        /// <summary>
        /// Gets the supported response formatters.
        /// </summary>
        public Collection<MediaTypeFormatter> SupportedResponseFormatters { get; internal set; }

        /// <summary>
        /// Gets the supported request body formatters.
        /// </summary>
        public Collection<MediaTypeFormatter> SupportedRequestBodyFormatters { get; internal set; }

        /// <summary>
        /// Gets the parameter descriptions.
        /// </summary>
        public Collection<ApiParameterDescription> ParameterDescriptions { get; internal set; }

        /// <summary>
        /// Gets the response description.
        /// </summary>
        public ResponseDescription ResponseDescription { get; internal set; }

        /// <summary>
        /// Gets the ID. The ID is unique within <see cref="HttpServer"/>.
        /// </summary>
        public string ID
        {
            get
            {
                return (HttpMethod != null ? HttpMethod.Method : String.Empty) +
                    (RelativePath ?? String.Empty);
            }
        }
    }
}

================================================
FILE: src/System.Web.Http/Description/ApiExplorer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Internal;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Routing;
using System.Web.Http.Services;

namespace System.Web.Http.Description
{
    /// <summary>
    /// Explores the URI space of the service based on routes, controllers and actions available in the system.
    /// </summary>
    public class ApiExplorer : IApiExplorer
    {
        private Lazy<Collection<ApiDescription>> _apiDescriptions;
        private readonly HttpConfiguration _config;
        private static readonly Regex _actionVariableRegex = new Regex(String.Format(CultureInfo.CurrentCulture, "{{{0}}}", RouteValueKeys.Action), RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
        private static readonly Regex _controllerVariableRegex = new Regex(String.Format(CultureInfo.CurrentCulture, "{{{0}}}", RouteValueKeys.Controller), RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);

        /// <summary>
        /// Initializes a new instance of the <see cref="ApiExplorer"/> class.
        /// </summary>
        /// <param name="configuration">The configuration.</param>
        public ApiExplorer(HttpConfiguration configuration)
        {
            _config = configuration;
            _apiDescriptions = new Lazy<Collection<ApiDescription>>(InitializeApiDescriptions);
        }

        /// <summary>
        /// Gets the API descriptions. The descriptions are initialized on the first access.
        /// </summary>
        public Collection<ApiDescription> ApiDescriptions
        {
            get
            {
                return _apiDescriptions.Value;
            }
        }

        /// <summary>
        /// Gets or sets the documentation provider. The provider will be responsible for documenting the API.
        /// </summary>
        /// <value>
        /// The documentation provider.
        /// </value>
        public IDocumentationProvider DocumentationProvider { get; set; }

        /// <summary>
        /// Determines whether the controller should be considered for <see cref="ApiExplorer.ApiDescriptions"/> generation. Called when initializing the <see cref="ApiExplorer.ApiDescriptions"/>.
        /// </summary>
        /// <param name="controllerVariableValue">The controller variable value from the route.</param>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="route">The route.</param>
        /// <returns><c>true</c> if the controller should be considered for <see cref="ApiExplorer.ApiDescriptions"/> generation, <c>false</c> otherwise.</returns>
        public virtual bool ShouldExploreController(string controllerVariableValue, HttpControllerDescriptor controllerDescriptor, IHttpRoute route)
        {
            if (controllerDescriptor == null)
            {
                throw Error.ArgumentNull("controllerDescriptor");
            }

            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            ApiExplorerSettingsAttribute setting = controllerDescriptor.GetCustomAttributes<ApiExplorerSettingsAttribute>().FirstOrDefault();
            return (setting == null || !setting.IgnoreApi) &&
                MatchRegexConstraint(route, RouteValueKeys.Controller, controllerVariableValue);
        }

        /// <summary>
        /// Determines whether the action should be considered for <see cref="ApiExplorer.ApiDescriptions"/> generation. Called when initializing the <see cref="ApiExplorer.ApiDescriptions"/>.
        /// </summary>
        /// <param name="actionVariableValue">The action variable value from the route.</param>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <param name="route">The route.</param>
        /// <returns><c>true</c> if the action should be considered for <see cref="ApiExplorer.ApiDescriptions"/> generation, <c>false</c> otherwise.</returns>
        public virtual bool ShouldExploreAction(string actionVariableValue, HttpActionDescriptor actionDescriptor, IHttpRoute route)
        {
            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            ApiExplorerSettingsAttribute setting = actionDescriptor.GetCustomAttributes<ApiExplorerSettingsAttribute>().FirstOrDefault();
            return (setting == null || !setting.IgnoreApi) &&
                MatchRegexConstraint(route, RouteValueKeys.Action, actionVariableValue);
        }

        /// <summary>
        /// Gets a collection of HttpMethods supported by the action. Called when initializing the <see cref="ApiExplorer.ApiDescriptions"/>.
        /// </summary>
        /// <param name="route">The route.</param>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <returns>A collection of HttpMethods supported by the action.</returns>
        public virtual Collection<HttpMethod> GetHttpMethodsSupportedByAction(IHttpRoute route, HttpActionDescriptor actionDescriptor)
        {
            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            IList<HttpMethod> supportedMethods = new List<HttpMethod>();
            IList<HttpMethod> actionHttpMethods = actionDescriptor.SupportedHttpMethods;
            HttpMethodConstraint httpMethodConstraint = route.Constraints.Values.FirstOrDefault(c => typeof(HttpMethodConstraint).IsAssignableFrom(c.GetType())) as HttpMethodConstraint;

            if (httpMethodConstraint == null)
            {
                supportedMethods = actionHttpMethods;
            }
            else
            {
                supportedMethods = httpMethodConstraint.AllowedMethods.Intersect(actionHttpMethods).ToList();
            }

            return new Collection<HttpMethod>(supportedMethods);
        }

        private IEnumerable<IHttpRoute> FlattenRoutes(IEnumerable<IHttpRoute> routes)
        {
            foreach (IHttpRoute route in routes)
            {
                IEnumerable<IHttpRoute> nested = route as IEnumerable<IHttpRoute>;
                if (nested != null)
                {
                    foreach (var subRoute in FlattenRoutes(nested))
                    {
                        yield return subRoute;
                    }
                }
                else
                {
                    yield return route;
                }
            }
        }

        private static HttpControllerDescriptor GetDirectRouteController(CandidateAction[] directRouteCandidates)
        {
            if (directRouteCandidates != null)
            {
                // Set the controller descriptor for the first action descriptor
                HttpControllerDescriptor controllerDescriptor = directRouteCandidates[0].ActionDescriptor.ControllerDescriptor;

                // Check that all other action descriptors share the same controller descriptor
                for (int i = 1; i < directRouteCandidates.Length; i++)
                {
                    if (directRouteCandidates[i].ActionDescriptor.ControllerDescriptor != controllerDescriptor)
                    {
                        // This can happen if a developer puts the same route template on different actions
                        // in different controllers.
                        return null;
                    }
                }

                return controllerDescriptor;
            }

            return null;
        }

        private Collection<ApiDescription> InitializeApiDescriptions()
        {
            Collection<ApiDescription> apiDescriptions = new Collection<ApiDescription>();
            IHttpControllerSelector controllerSelector = _config.Services.GetHttpControllerSelector();
            IDictionary<string, HttpControllerDescriptor> controllerMappings = controllerSelector.GetControllerMapping();
            if (controllerMappings != null)
            {
                ApiDescriptionComparer descriptionComparer = new ApiDescriptionComparer();
                foreach (IHttpRoute route in FlattenRoutes(_config.Routes))
                {
                    CandidateAction[] directRouteCandidates = route.GetDirectRouteCandidates();

                    HttpControllerDescriptor directRouteController = GetDirectRouteController(directRouteCandidates);
                    Collection<ApiDescription> descriptionsFromRoute =
                        (directRouteController != null && directRouteCandidates != null) ?
                            ExploreDirectRoute(directRouteController, directRouteCandidates, route) :
                            ExploreRouteControllers(controllerMappings, route);

                    // Remove ApiDescription that will lead to ambiguous action matching.
                    // E.g. a controller with Post() and PostComment(). When the route template is {controller}, it produces POST /controller and POST /controller.
                    descriptionsFromRoute = RemoveInvalidApiDescriptions(descriptionsFromRoute);

                    foreach (ApiDescription description in descriptionsFromRoute)
                    {
                        // Do not add the description if the previous route has a matching description with the same HTTP method and relative path.
                        // E.g. having two routes with the templates "api/Values/{id}" and "api/{controller}/{id}" can potentially produce the same
                        // relative path "api/Values/{id}" but only the first one matters.
                        if (!apiDescriptions.Contains(description, descriptionComparer))
                        {
                            apiDescriptions.Add(description);
                        }
                    }
                }
            }

            return apiDescriptions;
        }

        private Collection<ApiDescription> ExploreDirectRoute(HttpControllerDescriptor controllerDescriptor, CandidateAction[] candidates, IHttpRoute route)
        {
            Collection<ApiDescription> descriptions = new Collection<ApiDescription>();

            if (ShouldExploreController(controllerDescriptor.ControllerName, controllerDescriptor, route))
            {
                foreach (CandidateAction action in candidates)
                {
                    HttpActionDescriptor actionDescriptor = action.ActionDescriptor;
                    string actionName = actionDescriptor.ActionName;

                    if (ShouldExploreAction(actionName, actionDescriptor, route))
                    {
                        string routeTemplate = route.RouteTemplate;
                        if (_actionVariableRegex.IsMatch(routeTemplate))
                        {
                            // expand {action} variable
                            routeTemplate = _actionVariableRegex.Replace(routeTemplate, actionName);
                        }

                        PopulateActionDescriptions(actionDescriptor, route, routeTemplate, descriptions);
                    }
                }
            }

            return descriptions;
        }

        private Collection<ApiDescription> ExploreRouteControllers(IDictionary<string, HttpControllerDescriptor> controllerMappings, IHttpRoute route)
        {
            Collection<ApiDescription> apiDescriptions = new Collection<ApiDescription>();
            string routeTemplate = route.RouteTemplate;
            string controllerVariableValue;
            if (_controllerVariableRegex.IsMatch(routeTemplate))
            {
                // unbound controller variable, {controller}
                foreach (KeyValuePair<string, HttpControllerDescriptor> controllerMapping in controllerMappings)
                {
                    controllerVariableValue = controllerMapping.Key;
                    HttpControllerDescriptor controllerDescriptor = controllerMapping.Value;
                    if (ShouldExploreController(controllerVariableValue, controllerDescriptor, route))
                    {
                        // expand {controller} variable
                        string expandedRouteTemplate = _controllerVariableRegex.Replace(routeTemplate, controllerVariableValue);
                        ExploreRouteActions(route, expandedRouteTemplate, controllerDescriptor, apiDescriptions);
                    }
                }
            }
            else if (route.Defaults.TryGetValue(RouteValueKeys.Controller, out controllerVariableValue))
            {
                // bound controller variable, {controller = "controllerName"}
                HttpControllerDescriptor controllerDescriptor;
                if (controllerMappings.TryGetValue(controllerVariableValue, out controllerDescriptor) && ShouldExploreController(controllerVariableValue, controllerDescriptor, route))
                {
                    ExploreRouteActions(route, routeTemplate, controllerDescriptor, apiDescriptions);
                }
            }

            return apiDescriptions;
        }

        private void ExploreRouteActions(IHttpRoute route, string localPath, HttpControllerDescriptor controllerDescriptor, Collection<ApiDescription> apiDescriptions)
        {
            // exclude controllers that are marked with route attributes.
            if (!controllerDescriptor.IsAttributeRouted())
            {
                ServicesContainer controllerServices = controllerDescriptor.Configuration.Services;
                ILookup<string, HttpActionDescriptor> actionMappings = controllerServices.GetActionSelector().GetActionMapping(controllerDescriptor);
                string actionVariableValue;
                if (actionMappings != null)
                {
                    if (_actionVariableRegex.IsMatch(localPath))
                    {
                        // unbound action variable, {action}
                        foreach (IGrouping<string, HttpActionDescriptor> actionMapping in actionMappings)
                        {
                            // expand {action} variable
                            actionVariableValue = actionMapping.Key;
                            string expandedLocalPath = _actionVariableRegex.Replace(localPath, actionVariableValue);
                            PopulateActionDescriptions(actionMapping, actionVariableValue, route, expandedLocalPath, apiDescriptions);
                        }
                    }
                    else if (route.Defaults.TryGetValue(RouteValueKeys.Action, out actionVariableValue))
                    {
                        // bound action variable, { action = "actionName" }
                        PopulateActionDescriptions(actionMappings[actionVariableValue], actionVariableValue, route, localPath, apiDescriptions);
                    }
                    else
                    {
                        // no {action} specified, e.g. {controller}/{id}
                        foreach (IGrouping<string, HttpActionDescriptor> actionMapping in actionMappings)
                        {
                            PopulateActionDescriptions(actionMapping, null, route, localPath, apiDescriptions);
                        }
                    }
                }
            }
        }

        private void PopulateActionDescriptions(IEnumerable<HttpActionDescriptor> actionDescriptors, string actionVariableValue, IHttpRoute route, string localPath, Collection<ApiDescription> apiDescriptions)
        {
            foreach (HttpActionDescriptor actionDescriptor in actionDescriptors)
            {
                if (ShouldExploreAction(actionVariableValue, actionDescriptor, route))
                {
                    // exclude actions that are marked with route attributes except for the inherited actions.
                    if (!actionDescriptor.IsAttributeRouted())
                    {
                        PopulateActionDescriptions(actionDescriptor, route, localPath, apiDescriptions);
                    }
                }
            }
        }

        private void PopulateActionDescriptions(HttpActionDescriptor actionDescriptor, IHttpRoute route, string localPath, Collection<ApiDescription> apiDescriptions)
        {
            string apiDocumentation = GetApiDocumentation(actionDescriptor);

            HttpParsedRoute parsedRoute = RouteParser.Parse(localPath);

            // parameters
            IList<ApiParameterDescription> parameterDescriptions = CreateParameterDescriptions(actionDescriptor, parsedRoute, route.Defaults);

            // expand all parameter variables
            string finalPath;

            if (!TryExpandUriParameters(route, parsedRoute, parameterDescriptions, out finalPath))
            {
                // the action cannot be reached due to parameter mismatch, e.g. routeTemplate = "/users/{name}" and GetUsers(id)
                return;
            }

            // request formatters
            ApiParameterDescription bodyParameter = parameterDescriptions.FirstOrDefault(description => description.Source == ApiParameterSource.FromBody);
            IEnumerable<MediaTypeFormatter> supportedRequestBodyFormatters = bodyParameter != null ?
                actionDescriptor.Configuration.Formatters.Where(f => f.CanReadType(bodyParameter.ParameterDescriptor.ParameterType)) :
                Enumerable.Empty<MediaTypeFormatter>();

            // response formatters
            ResponseDescription responseDescription = CreateResponseDescription(actionDescriptor);
            Type returnType = responseDescription.ResponseType ?? responseDescription.DeclaredType;
            IEnumerable<MediaTypeFormatter> supportedResponseFormatters = (returnType != null && returnType != typeof(void)) ?
                actionDescriptor.Configuration.Formatters.Where(f => f.CanWriteType(returnType)) :
                Enumerable.Empty<MediaTypeFormatter>();

            // Replacing the formatter tracers with formatters if tracers are present.
            supportedRequestBodyFormatters = GetInnerFormatters(supportedRequestBodyFormatters);
            supportedResponseFormatters = GetInnerFormatters(supportedResponseFormatters);

            // get HttpMethods supported by an action. Usually there is one HttpMethod per action but we allow multiple of them per action as well.
            IList<HttpMethod> supportedMethods = GetHttpMethodsSupportedByAction(route, actionDescriptor);

            foreach (HttpMethod method in supportedMethods)
            {
                apiDescriptions.Add(new ApiDescription
                {
                    Documentation = apiDocumentation,
                    HttpMethod = method,
                    RelativePath = finalPath,
                    ActionDescriptor = actionDescriptor,
                    Route = route,
                    SupportedResponseFormatters = new Collection<MediaTypeFormatter>(supportedResponseFormatters.ToList()),
                    SupportedRequestBodyFormatters = new Collection<MediaTypeFormatter>(supportedRequestBodyFormatters.ToList()),
                    ParameterDescriptions = new Collection<ApiParameterDescription>(parameterDescriptions),
                    ResponseDescription = responseDescription
                });
            }
        }

        private ResponseDescription CreateResponseDescription(HttpActionDescriptor actionDescriptor)
        {
            Collection<ResponseTypeAttribute> responseTypeAttribute = actionDescriptor.GetCustomAttributes<ResponseTypeAttribute>();
            Type responseType = responseTypeAttribute.Select(attribute => attribute.ResponseType).FirstOrDefault();

            return new ResponseDescription
            {
                DeclaredType = actionDescriptor.ReturnType,
                ResponseType = responseType,
                Documentation = GetApiResponseDocumentation(actionDescriptor)
            };
        }

        private static IEnumerable<MediaTypeFormatter> GetInnerFormatters(IEnumerable<MediaTypeFormatter> mediaTypeFormatters)
        {
            foreach (MediaTypeFormatter formatter in mediaTypeFormatters)
            {
                yield return Decorator.GetInner(formatter);
            }
        }

        private static bool ShouldEmitPrefixes(ICollection<ApiParameterDescription> parameterDescriptions)
        {
            // Determine if there are two or more complex objects from the Uri so TryExpandUriParameters needs to emit prefixes.
            return parameterDescriptions.Count(parameter =>
                        parameter.Source == ApiParameterSource.FromUri &&
                        parameter.ParameterDescriptor != null &&
                        !TypeHelper.CanConvertFromString(parameter.ParameterDescriptor.ParameterType) &&
                        parameter.CanConvertPropertiesFromString()) > 1;
        }

        // Set as internal for the unit test.
        internal static bool TryExpandUriParameters(IHttpRoute route, HttpParsedRoute parsedRoute, ICollection<ApiParameterDescription> parameterDescriptions, out string expandedRouteTemplate)
        {
            Dictionary<string, object> parameterValuesForRoute = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            bool emitPrefixes = ShouldEmitPrefixes(parameterDescriptions);
            string prefix = String.Empty;
            foreach (ApiParameterDescription parameterDescription in parameterDescriptions)
            {
                if (parameterDescription.Source == ApiParameterSource.FromUri)
                {
                    if (parameterDescription.ParameterDescriptor == null)
                    {
                        // Undeclared route parameter handling generates query string like
                        // "?name={name}"
                        AddPlaceholder(parameterValuesForRoute, parameterDescription.Name);
                    }
                    else if (TypeHelper.CanConvertFromString(parameterDescription.ParameterDescriptor.ParameterType))
                    {
                        // Simple type generates query string like
                        // "?name={name}"
                        AddPlaceholder(parameterValuesForRoute, parameterDescription.Name);
                    }
                    else if (IsBindableCollection(parameterDescription.ParameterDescriptor.ParameterType))
                    {
                        string parameterName = parameterDescription.ParameterDescriptor.ParameterName;
                        Type innerType =
                            GetCollectionElementType(parameterDescription.ParameterDescriptor.ParameterType);
                        PropertyInfo[] innerTypeProperties =
                            ApiParameterDescription.GetBindableProperties(innerType).ToArray();
                        if (innerTypeProperties.Any())
                        {
                            // Complex array and collection generate query string like
                            // "?name[0].foo={name[0].foo}&name[0].bar={name[0].bar}
                            //  &name[1].foo={name[1].foo}&name[1].bar={name[1].bar}"
                            AddPlaceholderForProperties(parameterValuesForRoute,
                                                        innerTypeProperties,
                                                        parameterName + "[0].");
                            AddPlaceholderForProperties(parameterValuesForRoute,
                                                        innerTypeProperties,
                                                        parameterName + "[1].");
                        }
                        else
                        {
                            // Simple array and collection generate query string like
                            // "?name[0]={name[0]}&name[1]={name[1]}".
                            AddPlaceholder(parameterValuesForRoute, parameterName + "[0]");
                            AddPlaceholder(parameterValuesForRoute, parameterName + "[1]");
                        }
                    }
                    else if (IsBindableKeyValuePair(parameterDescription.ParameterDescriptor.ParameterType))
                    {
                        // KeyValuePair generates query string like
                        // "?key={key}&value={value}"
                        AddPlaceholder(parameterValuesForRoute, "key");
                        AddPlaceholder(parameterValuesForRoute, "value");
                    }
                    else if (IsBindableDictionry(parameterDescription.ParameterDescriptor.ParameterType))
                    {
                        // Dictionary generates query string like
                        // "?dict[0].key={dict[0].key}&dict[0].value={dict[0].value}
                        //  &dict[1].key={dict[1].key}&dict[1].value={dict[1].value}"
                        string parameterName = parameterDescription.ParameterDescriptor.ParameterName;
                        AddPlaceholder(parameterValuesForRoute, parameterName + "[0].key");
                        AddPlaceholder(parameterValuesForRoute, parameterName + "[0].value");
                        AddPlaceholder(parameterValuesForRoute, parameterName + "[1].key");
                        AddPlaceholder(parameterValuesForRoute, parameterName + "[1].value");
                    }
                    else if (parameterDescription.CanConvertPropertiesFromString())
                    {
                        if (emitPrefixes)
                        {
                            prefix = parameterDescription.Name + ".";
                        }

                        // Inserting the individual properties of the object in the query string
                        // as all the complex object can not be converted from string, but all its
                        // individual properties can.
                        AddPlaceholderForProperties(parameterValuesForRoute,
                                                    parameterDescription.GetBindableProperties(),
                                                    prefix);
                    }
                }
            }

            BoundRouteTemplate boundRouteTemplate = parsedRoute.Bind(null, parameterValuesForRoute, new HttpRouteValueDictionary(route.Defaults), new HttpRouteValueDictionary(route.Constraints));
            if (boundRouteTemplate == null)
            {
                expandedRouteTemplate = null;
                return false;
            }

            expandedRouteTemplate = Uri.UnescapeDataString(boundRouteTemplate.BoundTemplate);
            return true;
        }

        private static Type GetCollectionElementType(Type collectionType)
        {
            Contract.Assert(!typeof(IDictionary).IsAssignableFrom(collectionType));

            Type elementType = collectionType.GetElementType();
            if (elementType == null)
            {
                elementType = CollectionModelBinderUtil
                    .GetGenericBinderTypeArgs(typeof(ICollection<>), collectionType)
                    .First();
            }
            return elementType;
        }

        private static void AddPlaceholderForProperties(Dictionary<string, object> parameterValuesForRoute,
                                                        IEnumerable<PropertyInfo> properties,
                                                        string prefix)
        {
            foreach (PropertyInfo property in properties)
            {
                string queryParameterName = prefix + property.Name;
                AddPlaceholder(parameterValuesForRoute, queryParameterName);
            }
        }

        private static bool IsBindableCollection(Type type)
        {
            Contract.Assert(type != null);

            return type.IsArray || new CollectionModelBinderProvider().GetBinder(null, type) != null;
        }

        private static bool IsBindableDictionry(Type type)
        {
            Contract.Assert(type != null);

            return new DictionaryModelBinderProvider().GetBinder(null, type) != null;
        }

        private static bool IsBindableKeyValuePair(Type type)
        {
            Contract.Assert(type != null);

            return TypeHelper.GetTypeArgumentsIfMatch(type, typeof(KeyValuePair<,>)) != null;
        }

        private static void AddPlaceholder(Dictionary<string, object> parameterValuesForRoute,
                                          string queryParameterName)
        {
            if (!parameterValuesForRoute.ContainsKey(queryParameterName))
            {
                parameterValuesForRoute.Add(queryParameterName, "{" + queryParameterName + "}");
            }
        }

        private IList<ApiParameterDescription> CreateParameterDescriptions(HttpActionDescriptor actionDescriptor, HttpParsedRoute parsedRoute, IDictionary<string, object> routeDefaults)
        {
            IList<ApiParameterDescription> parameterDescriptions = new List<ApiParameterDescription>();
            HttpActionBinding actionBinding = GetActionBinding(actionDescriptor);

            // try get parameter binding information if available
            if (actionBinding != null)
            {
                HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
                if (parameterBindings != null)
                {
                    foreach (HttpParameterBinding parameter in parameterBindings)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromBinding(parameter));
                    }
                }
            }
            else
            {
                Collection<HttpParameterDescriptor> parameters = actionDescriptor.GetParameters();
                if (parameters != null)
                {
                    foreach (HttpParameterDescriptor parameter in parameters)
                    {
                        parameterDescriptions.Add(CreateParameterDescriptionFromDescriptor(parameter));
                    }
                }
            }

            // Adding route parameters not declared on the action. We're doing this because route parameters may or
            // may not be part of the action parameters and we want to have them in the description.
            AddUndeclaredRouteParameters(parsedRoute, routeDefaults, parameterDescriptions);

            return parameterDescriptions;
        }

        private static void AddUndeclaredRouteParameters(HttpParsedRoute parsedRoute, IDictionary<string, object> routeDefaults, IList<ApiParameterDescription> parameterDescriptions)
        {
            foreach (PathSegment path in parsedRoute.PathSegments)
            {
                PathContentSegment content = path as PathContentSegment;
                if (content != null)
                {
                    foreach (PathSubsegment subSegment in content.Subsegments)
                    {
                        PathParameterSubsegment parameter = subSegment as PathParameterSubsegment;
                        if (parameter != null)
                        {
                            object parameterValue;
                            string parameterName = parameter.ParameterName;
                            if (!parameterDescriptions.Any(p => String.Equals(p.Name, parameterName, StringComparison.OrdinalIgnoreCase)) &&
                                (!routeDefaults.TryGetValue(parameterName, out parameterValue) ||
                                parameterValue != RouteParameter.Optional))
                            {
                                parameterDescriptions.Add(
                                    new ApiParameterDescription
                                    {
                                        Name = parameterName,
                                        Source = ApiParameterSource.FromUri
                                    });
                            }
                        }
                    }
                }
            }
        }

        private ApiParameterDescription CreateParameterDescriptionFromDescriptor(HttpParameterDescriptor parameter)
        {
            Contract.Assert(parameter != null);
            return new ApiParameterDescription
            {
                ParameterDescriptor = parameter,
                Name = parameter.Prefix ?? parameter.ParameterName,
                Documentation = GetApiParameterDocumentation(parameter),
                Source = ApiParameterSource.Unknown,
            };
        }

        private ApiParameterDescription CreateParameterDescriptionFromBinding(HttpParameterBinding parameterBinding)
        {
            ApiParameterDescription parameterDescription = CreateParameterDescriptionFromDescriptor(parameterBinding.Descriptor);
            if (parameterBinding.WillReadBody)
            {
                parameterDescription.Source = ApiParameterSource.FromBody;
            }
            else if (parameterBinding.WillReadUri())
            {
                parameterDescription.Source = ApiParameterSource.FromUri;
            }

            return parameterDescription;
        }

        private string GetApiDocumentation(HttpActionDescriptor actionDescriptor)
        {
            IDocumentationProvider documentationProvider = DocumentationProvider ?? actionDescriptor.Configuration.Services.GetDocumentationProvider();
            if (documentationProvider != null)
            {
                return documentationProvider.GetDocumentation(actionDescriptor);
            }

            return null;
        }

        private string GetApiParameterDocumentation(HttpParameterDescriptor parameterDescriptor)
        {
            IDocumentationProvider documentationProvider = DocumentationProvider ?? parameterDescriptor.Configuration.Services.GetDocumentationProvider();
            if (documentationProvider != null)
            {
                return documentationProvider.GetDocumentation(parameterDescriptor);
            }

            return null;
        }

        private string GetApiResponseDocumentation(HttpActionDescriptor actionDescriptor)
        {
            IDocumentationProvider documentationProvider = DocumentationProvider ?? actionDescriptor.Configuration.Services.GetDocumentationProvider();
            if (documentationProvider != null)
            {
                return documentationProvider.GetResponseDocumentation(actionDescriptor);
            }

            return null;
        }

        // remove ApiDescription that will lead to ambiguous action matching.
        private static Collection<ApiDescription> RemoveInvalidApiDescriptions(Collection<ApiDescription> apiDescriptions)
        {
            HashSet<string> duplicateApiDescriptionIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            HashSet<string> visitedApiDescriptionIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            foreach (ApiDescription description in apiDescriptions)
            {
                string apiDescriptionId = description.ID;
                if (visitedApiDescriptionIds.Contains(apiDescriptionId))
                {
                    duplicateApiDescriptionIds.Add(apiDescriptionId);
                }
                else
                {
                    visitedApiDescriptionIds.Add(apiDescriptionId);
                }
            }

            Collection<ApiDescription> filteredApiDescriptions = new Collection<ApiDescription>();
            foreach (ApiDescription apiDescription in apiDescriptions)
            {
                string apiDescriptionId = apiDescription.ID;
                if (!duplicateApiDescriptionIds.Contains(apiDescriptionId))
                {
                    filteredApiDescriptions.Add(apiDescription);
                }
            }

            return filteredApiDescriptions;
        }

        private static bool MatchRegexConstraint(IHttpRoute route, string parameterName, string parameterValue)
        {
            IDictionary<string, object> constraints = route.Constraints;
            if (constraints != null)
            {
                object constraint;
                if (constraints.TryGetValue(parameterName, out constraint))
                {
                    // treat the constraint as a string which represents a Regex.
                    // note that we don't support custom constraint (IHttpRouteConstraint) because it might rely on the request and some runtime states
                    string constraintsRule = constraint as string;
                    if (constraintsRule != null)
                    {
                        string constraintsRegEx = "^(" + constraintsRule + ")$";
                        return parameterValue != null && Regex.IsMatch(parameterValue, constraintsRegEx, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
                    }
                }
            }

            return true;
        }

        private static HttpActionBinding GetActionBinding(HttpActionDescriptor actionDescriptor)
        {
            HttpControllerDescriptor controllerDescriptor = actionDescriptor.ControllerDescriptor;
            if (controllerDescriptor == null)
            {
                return null;
            }

            ServicesContainer controllerServices = controllerDescriptor.Configuration.Services;
            IActionValueBinder actionValueBinder = controllerServices.GetActionValueBinder();
            HttpActionBinding actionBinding = actionValueBinder != null ? actionValueBinder.GetBinding(actionDescriptor) : null;
            return actionBinding;
        }

        private sealed class ApiDescriptionComparer : IEqualityComparer<ApiDescription>
        {
            public bool Equals(ApiDescription x, ApiDescription y)
            {
                return String.Equals(x.ID, y.ID, StringComparison.OrdinalIgnoreCase);
            }

            public int GetHashCode(ApiDescription obj)
            {
                return obj.ID.ToUpperInvariant().GetHashCode();
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Description/ApiExplorerSettingsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Description
{
    /// <summary>
    /// This attribute can be used on the controllers and actions to influence the behavior of <see cref="ApiExplorer"/>.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
    public sealed class ApiExplorerSettingsAttribute : Attribute
    {
        /// <summary>
        /// Gets or sets a value indicating whether to exclude the controller or action from the ApiDescriptions generated by <see cref="ApiExplorer"/>.
        /// </summary>
        /// <value>
        ///   <c>true</c> if the controller or action should be ignored; otherwise, <c>false</c>.
        /// </value>
        public bool IgnoreApi { get; set; }
    }
}


================================================
FILE: src/System.Web.Http/Description/ApiParameterDescription.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;

namespace System.Web.Http.Description
{
    /// <summary>
    /// Describes a parameter on the API defined by relative URI path and HTTP method.
    /// </summary>
    public class ApiParameterDescription
    {
        /// <summary>
        /// Gets or sets the name.
        /// </summary>
        /// <value>
        /// The name.
        /// </value>
        public string Name { get; set; }

        /// <summary>
        /// Gets or sets the documentation.
        /// </summary>
        /// <value>
        /// The documentation.
        /// </value>
        public string Documentation { get; set; }

        /// <summary>
        /// Gets or sets the source of the parameter. It may come from the request URI, request body or other places.
        /// </summary>
        /// <value>
        /// The source.
        /// </value>
        public ApiParameterSource Source { get; set; }

        /// <summary>
        /// Gets or sets the parameter descriptor.
        /// </summary>
        /// <value>
        /// The parameter descriptor. <see langref="null"/> if (and only if) a <see cref="ApiParameterSource.FromUri"/>
        /// parameter is declared in route template but unused in the API. Never-<see langref="null"/> for other
        /// sources.
        /// </value>
        /// <remarks>
        /// For more information on the <see langref="null"/> case, search <see cref="ApiExplorer"/> for "undeclared"
        /// route parameter handling.
        /// </remarks>
        public HttpParameterDescriptor ParameterDescriptor { get; set; }

        internal IEnumerable<PropertyInfo> GetBindableProperties()
        {
            return GetBindableProperties(ParameterDescriptor.ParameterType);
        }

        internal bool CanConvertPropertiesFromString()
        {
            return GetBindableProperties().All(p => TypeHelper.CanConvertFromString(p.PropertyType));
        }

        internal static IEnumerable<PropertyInfo> GetBindableProperties(Type type)
        {
            return type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
                       .Where(p => p.GetGetMethod() != null && p.GetSetMethod() != null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Description/ApiParameterSource.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Description
{
    /// <summary>
    /// Describes where the parameter come from.
    /// </summary>
    public enum ApiParameterSource
    {
        FromUri = 0,
        FromBody,
        Unknown
    }
}


================================================
FILE: src/System.Web.Http/Description/IApiExplorer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;

namespace System.Web.Http.Description
{
    /// <summary>
    /// Defines the interface for getting a collection of <see cref="ApiDescription"/>.
    /// </summary>
    public interface IApiExplorer
    {
        /// <summary>
        /// Gets the API descriptions.
        /// </summary>
        Collection<ApiDescription> ApiDescriptions { get; }
    }
}


================================================
FILE: src/System.Web.Http/Description/IDocumentationProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.Description
{
    /// <summary>
    /// Defines the provider responsible for documenting the service.
    /// </summary>
    public interface IDocumentationProvider
    {
        /// <summary>
        /// Gets the documentation based on <see cref="HttpControllerDescriptor"/>.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <returns>Documentation for the controller.</returns>
        string GetDocumentation(HttpControllerDescriptor controllerDescriptor);

        /// <summary>
        /// Gets the documentation based on <see cref="HttpActionDescriptor"/>.
        /// </summary>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <returns>Documentation for the action.</returns>
        string GetDocumentation(HttpActionDescriptor actionDescriptor);

        /// <summary>
        /// Gets the documentation based on <see cref="HttpParameterDescriptor"/>.
        /// </summary>
        /// <param name="parameterDescriptor">The parameter descriptor.</param>
        /// <returns>Documentation for the parameter.</returns>
        string GetDocumentation(HttpParameterDescriptor parameterDescriptor);

        /// <summary>
        /// Gets the response documentation based on <see cref="HttpActionDescriptor"/>.
        /// </summary>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <returns>Documentation for the action response.</returns>
        string GetResponseDocumentation(HttpActionDescriptor actionDescriptor);
    }
}


================================================
FILE: src/System.Web.Http/Description/ResponseDescription.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Description
{
    /// <summary>
    /// Describes the API response.
    /// </summary>
    public class ResponseDescription
    {
        /// <summary>
        /// Gets or sets the declared response type.
        /// </summary>
        public Type DeclaredType { get; set; }

        /// <summary>
        /// Gets or sets the actual response type.
        /// </summary>
        public Type ResponseType { get; set; }

        /// <summary>
        /// Gets or sets the response documentation.
        /// </summary>
        public string Documentation { get; set; }
    }
}

================================================
FILE: src/System.Web.Http/Description/ResponseTypeAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Description
{
    /// <summary>
    /// Use this to specify the entity type returned by an action when the declared return type
    /// is <see cref="System.Net.Http.HttpResponseMessage"/> or <see cref="IHttpActionResult"/>.
    /// The <see cref="ResponseType"/> will be read by <see cref="ApiExplorer"/> when generating <see cref="ApiDescription"/>.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
    public sealed class ResponseTypeAttribute : Attribute
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ResponseTypeAttribute"/> class.
        /// </summary>
        /// <param name="responseType">The response type.</param>
        public ResponseTypeAttribute(Type responseType)
        {
            ResponseType = responseType;
        }

        /// <summary>
        /// Gets the response type.
        /// </summary>
        public Type ResponseType { get; private set; }
    }
}

================================================
FILE: src/System.Web.Http/Dispatcher/DefaultAssembliesResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Provides an implementation of <see cref="IAssembliesResolver"/> with no external dependencies.
    /// </summary>
    public class DefaultAssembliesResolver : IAssembliesResolver
    {
        /// <summary>
        /// Returns a list of assemblies available for the application.
        /// </summary>
        /// <returns>A <see cref="Collection{Assembly}"/> of assemblies.</returns>
        public virtual ICollection<Assembly> GetAssemblies()
        {
            return AppDomain.CurrentDomain.GetAssemblies().ToList();
        }
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/DefaultHttpControllerActivator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.Properties;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Default implementation of an <see cref="IHttpControllerActivator"/>.
    /// A different implementation can be registered via the <see cref="T:System.Web.Http.Services.DependencyResolver"/>.
    /// We optimize for the case where we have an <see cref="Controllers.ApiControllerActionInvoker"/> 
    /// instance per <see cref="HttpControllerDescriptor"/> instance but can support cases where there are
    /// many <see cref="HttpControllerDescriptor"/> instances for one <see cref="System.Web.Http.Controllers.ApiControllerActionInvoker"/> 
    /// as well. In the latter case the lookup is slightly slower because it goes through the 
    /// <see cref="P:HttpControllerDescriptor.Properties"/> dictionary.
    /// </summary>
    public class DefaultHttpControllerActivator : IHttpControllerActivator
    {
        private Tuple<HttpControllerDescriptor, Func<IHttpController>> _fastCache;
        private object _cacheKey = new object();

        /// <summary>
        /// Creates the <see cref="IHttpController"/> specified by <paramref name="controllerType"/> using the given <paramref name="request"/>
        /// </summary>
        /// <param name="request">The request message.</param>
        /// <param name="controllerType">Type of the controller.</param>
        /// <param name="controllerDescriptor">The controller descriptor</param>
        /// <returns>An instance of type <paramref name="controllerType"/>.</returns>
        public IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (controllerDescriptor == null)
            {
                throw Error.ArgumentNull("controllerDescriptor");
            }

            if (controllerType == null)
            {
                throw Error.ArgumentNull("controllerType");
            }

            try
            {
                Func<IHttpController> activator;

                // First check in the local fast cache and if not a match then look in the broader 
                // HttpControllerDescriptor.Properties cache
                if (_fastCache == null)
                {
                    IHttpController controller = GetInstanceOrActivator(request, controllerType, out activator);
                    if (controller != null)
                    {
                        // we have a controller registered with the dependency resolver for this controller type
                        return controller;
                    }
                    else
                    {
                        Tuple<HttpControllerDescriptor, Func<IHttpController>> cacheItem = Tuple.Create(controllerDescriptor, activator);
                        Interlocked.CompareExchange(ref _fastCache, cacheItem, null);
                    }
                }
                else if (_fastCache.Item1 == controllerDescriptor)
                {
                    // If the key matches and we already have the delegate for creating an instance.
                    activator = _fastCache.Item2;
                }
                else
                {
                    // If the key doesn't match then lookup/create delegate in the HttpControllerDescriptor.Properties for
                    // that HttpControllerDescriptor instance
                    object value;
                    if (controllerDescriptor.Properties.TryGetValue(_cacheKey, out value))
                    {
                        activator = (Func<IHttpController>)value;
                    }
                    else
                    {
                        IHttpController controller = GetInstanceOrActivator(request, controllerType, out activator);
                        if (controller != null)
                        {
                            // we have a controller registered with the dependency resolver for this controller type
                            return controller;
                        }
                        else
                        {
                            controllerDescriptor.Properties.TryAdd(_cacheKey, activator);
                        }
                    }
                }

                return activator();
            }
            catch (Exception ex)
            {
                throw Error.InvalidOperation(ex, SRResources.DefaultControllerFactory_ErrorCreatingController, controllerType.Name);
            }
        }

        // Returns the controller instance from the dependency resolver if there is one registered
        // else returns the activator that calls the default ctor for the give controllerType.
        private static IHttpController GetInstanceOrActivator(HttpRequestMessage request, Type controllerType, out Func<IHttpController> activator)
        {
            Contract.Assert(request != null);
            Contract.Assert(controllerType != null);

            // If dependency resolver returns controller object then use it.
            IHttpController instance = (IHttpController)request.GetDependencyScope().GetService(controllerType);
            if (instance != null)
            {
                activator = null;
                return instance;
            }

            // Otherwise create a delegate for creating a new instance of the type
            activator = TypeActivator.Create<IHttpController>(controllerType);
            return null;
        }
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/DefaultHttpControllerSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using System.Web.Http.Routing;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Default <see cref="IHttpControllerSelector"/> instance for choosing a <see cref="HttpControllerDescriptor"/> given a <see cref="HttpRequestMessage"/>
    /// A different implementation can be registered via the <see cref="HttpConfiguration.Services"/>.
    /// </summary>
    public class DefaultHttpControllerSelector : IHttpControllerSelector
    {
        public static readonly string ControllerSuffix = "Controller";

        private const string ControllerKey = "controller";

        private readonly HttpConfiguration _configuration;
        private readonly HttpControllerTypeCache _controllerTypeCache;
        private readonly Lazy<ConcurrentDictionary<string, HttpControllerDescriptor>> _controllerInfoCache;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultHttpControllerSelector"/> class.
        /// </summary>
        /// <param name="configuration">The configuration.</param>
        public DefaultHttpControllerSelector(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            _controllerInfoCache = new Lazy<ConcurrentDictionary<string, HttpControllerDescriptor>>(InitializeControllerInfoCache);
            _configuration = configuration;
            _controllerTypeCache = new HttpControllerTypeCache(_configuration);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller is responsible for disposing of response instance.")]
        public virtual HttpControllerDescriptor SelectController(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            IHttpRouteData routeData = request.GetRouteData();
            HttpControllerDescriptor controllerDescriptor;
            if (routeData != null)
            {   
                controllerDescriptor = GetDirectRouteController(routeData);
                if (controllerDescriptor != null)
                {
                    return controllerDescriptor;
                }                
            }

            string controllerName = GetControllerName(request);
            if (String.IsNullOrEmpty(controllerName))
            {
                throw new HttpResponseException(request.CreateErrorResponse(
                    HttpStatusCode.NotFound,
                    Error.Format(SRResources.ResourceNotFound, request.RequestUri),
                    Error.Format(SRResources.ControllerNameNotFound, request.RequestUri)));
            }

            if (_controllerInfoCache.Value.TryGetValue(controllerName, out controllerDescriptor))
            {
                return controllerDescriptor;
            }

            ICollection<Type> matchingTypes = _controllerTypeCache.GetControllerTypes(controllerName);

            // ControllerInfoCache is already initialized.
            Contract.Assert(matchingTypes.Count != 1);

            if (matchingTypes.Count == 0)
            {
                // no matching types
                throw new HttpResponseException(request.CreateErrorResponse(
                    HttpStatusCode.NotFound,
                    Error.Format(SRResources.ResourceNotFound, request.RequestUri),
                    Error.Format(SRResources.DefaultControllerFactory_ControllerNameNotFound, controllerName)));
            }
            else
            {
                // multiple matching types
                throw CreateAmbiguousControllerException(request.GetRouteData().Route, controllerName, matchingTypes);
            }
        }

        public virtual IDictionary<string, HttpControllerDescriptor> GetControllerMapping()
        {
            return _controllerInfoCache.Value.ToDictionary(c => c.Key, c => c.Value, StringComparer.OrdinalIgnoreCase);
        }

        public virtual string GetControllerName(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            IHttpRouteData routeData = request.GetRouteData();
            if (routeData == null)
            {
                return null;
            }

            // Look up controller in route data
            string controllerName = null;
            routeData.Values.TryGetValue(ControllerKey, out controllerName);
            return controllerName;
        }

        // If routeData is from an attribute route, get the controller that can handle it. 
        // Else return null. Throws an exception if multiple controllers match
        private static HttpControllerDescriptor GetDirectRouteController(IHttpRouteData routeData)
        {
            CandidateAction[] candidates = routeData.GetDirectRouteCandidates();
            if (candidates != null)
            {
                // Set the controller descriptor for the first action descriptor
                Contract.Assert(candidates.Length > 0);
                Contract.Assert(candidates[0].ActionDescriptor != null);

                HttpControllerDescriptor controllerDescriptor = candidates[0].ActionDescriptor.ControllerDescriptor;

                // Check that all other candidate action descriptors share the same controller descriptor
                for (int i = 1; i < candidates.Length; i++)
                {
                    CandidateAction candidate = candidates[i];
                    if (candidate.ActionDescriptor.ControllerDescriptor != controllerDescriptor)
                    {
                        // We've found an ambiguity (multiple controllers matched)
                        throw CreateDirectRouteAmbiguousControllerException(candidates);
                    }
                }

                return controllerDescriptor;
            }

            return null;
        }

        private static Exception CreateDirectRouteAmbiguousControllerException(CandidateAction[] candidates)
        {
            Contract.Assert(candidates != null);
            Contract.Assert(candidates.Length > 1);

            HashSet<Type> matchingTypes = new HashSet<Type>();
            for (int i = 0; i < candidates.Length; i++)
            {
                matchingTypes.Add(candidates[i].ActionDescriptor.ControllerDescriptor.ControllerType);
            }

            // we need to generate an exception containing all the controller types
            StringBuilder typeList = new StringBuilder();
            foreach (Type matchedType in matchingTypes)
            {
                typeList.AppendLine();
                typeList.Append(matchedType.FullName);
            }

            return Error.InvalidOperation(SRResources.DirectRoute_AmbiguousController, typeList, Environment.NewLine);
        }

        private static Exception CreateAmbiguousControllerException(IHttpRoute route, string controllerName, ICollection<Type> matchingTypes)
        {
            Contract.Assert(route != null);
            Contract.Assert(controllerName != null);
            Contract.Assert(matchingTypes != null);

            // Generate an exception containing all the controller types
            StringBuilder typeList = new StringBuilder();
            foreach (Type matchedType in matchingTypes)
            {
                typeList.AppendLine();
                typeList.Append(matchedType.FullName);
            }

            string errorMessage = Error.Format(SRResources.DefaultControllerFactory_ControllerNameAmbiguous_WithRouteTemplate, controllerName, route.RouteTemplate, typeList, Environment.NewLine);
            return new InvalidOperationException(errorMessage);
        }

        private ConcurrentDictionary<string, HttpControllerDescriptor> InitializeControllerInfoCache()
        {
            var result = new ConcurrentDictionary<string, HttpControllerDescriptor>(StringComparer.OrdinalIgnoreCase);
            var duplicateControllers = new HashSet<string>();
            Dictionary<string, ILookup<string, Type>> controllerTypeGroups = _controllerTypeCache.Cache;

            foreach (KeyValuePair<string, ILookup<string, Type>> controllerTypeGroup in controllerTypeGroups)
            {
                string controllerName = controllerTypeGroup.Key;

                foreach (IGrouping<string, Type> controllerTypesGroupedByNs in controllerTypeGroup.Value)
                {
                    foreach (Type controllerType in controllerTypesGroupedByNs)
                    {
                        if (result.Keys.Contains(controllerName))
                        {
                            duplicateControllers.Add(controllerName);
                            break;
                        }
                        else
                        {
                            result.TryAdd(controllerName, new HttpControllerDescriptor(_configuration, controllerName, controllerType));
                        }
                    }
                }
            }

            foreach (string duplicateController in duplicateControllers)
            {
                HttpControllerDescriptor descriptor;
                result.TryRemove(duplicateController, out descriptor);
            }

            return result;
        }
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/DefaultHttpControllerTypeResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Reflection;
using System.Web.Http.Controllers;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Provides an implementation of <see cref="IHttpControllerTypeResolver"/> with no external dependencies.
    /// </summary>
    public class DefaultHttpControllerTypeResolver : IHttpControllerTypeResolver
    {
        private readonly Predicate<Type> _isControllerTypePredicate;
        private Func<Assembly, Type[]> _getTypesFunc = GetTypes;

        /// <summary>
        /// Initializes a new instance of the <see cref="DefaultHttpControllerTypeResolver"/> with a default
        /// filter for detecting controller types.
        /// </summary>
        public DefaultHttpControllerTypeResolver()
            : this(IsControllerType)
        {
        }

        /// <summary>
        /// Creates a new <see cref="DefaultHttpControllerTypeResolver"/> instance using a predicate to filter controller types.
        /// </summary>
        /// <param name="predicate">The predicate.</param>
        public DefaultHttpControllerTypeResolver(Predicate<Type> predicate)
        {
            if (predicate == null)
            {
                throw Error.ArgumentNull("predicate");
            }

            _isControllerTypePredicate = predicate;
        }

        protected internal virtual Predicate<Type> IsControllerTypePredicate
        {
            get { return _isControllerTypePredicate; }
        }

        internal static bool IsControllerType(Type t)
        {
            Contract.Assert(t != null);
            return
                t != null &&
                t.IsClass &&
                t.IsVisible &&
                !t.IsAbstract &&
                typeof(IHttpController).IsAssignableFrom(t) &&
                HasValidControllerName(t);
        }

        /// <summary>
        /// Returns a list of controllers available for the application.
        /// </summary>
        /// <returns>An <see cref="ICollection{Type}"/> of controllers.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Catching all exceptions in this case is the right to do.")]
        public virtual ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
        {
            if (assembliesResolver == null)
            {
                throw Error.ArgumentNull("assembliesResolver");
            }

            List<Type> result = new List<Type>();

            // Go through all assemblies referenced by the application and search for types matching a predicate
            ICollection<Assembly> assemblies = assembliesResolver.GetAssemblies();
            foreach (Assembly assembly in assemblies)
            {
                Type[] exportedTypes = null;
                if (assembly == null || assembly.IsDynamic)
                {
                    // can't call GetTypes on a null (or dynamic?) assembly
                    continue;
                }

                try
                {
                    exportedTypes = _getTypesFunc(assembly);
                }
                catch (ReflectionTypeLoadException ex)
                {
                    exportedTypes = ex.Types;
                }
                catch
                {
                    // We deliberately ignore all exceptions when building the cache. If 
                    // a controller type is not found then we will respond later with a 404.
                    // However, until then we don't know whether an exception at all will
                    // have an impact on finding a controller.
                    continue;
                }

                if (exportedTypes != null)
                {
                    result.AddRange(exportedTypes.Where(x => TypeIsVisible(x) && IsControllerTypePredicate(x)));
                }
            }

            return result;
        }

        /// <summary>
        /// Returns an array of <see cref="Type"/>s in the given <paramref name="assembly"/>.
        /// </summary>
        /// <remarks>Available separately only to allow a tracing override.</remarks>
        /// <param name="assembly">The <see cref="Assembly"/> to check.</param>
        /// <returns>Array of <see cref="Type"/>s types in the assembly.</returns>
        internal static Type[] GetTypes(Assembly assembly)
        {
            return assembly.GetTypes();
        }

        /// <summary>
        /// We match if type name ends with "Controller" and that is not the only part of the 
        /// name (i.e it can't be just "Controller"). The reason is that the route name has to 
        /// be a non-empty prefix of the controller type name.
        /// </summary>
        internal static bool HasValidControllerName(Type controllerType)
        {
            Contract.Assert(controllerType != null);
            string controllerSuffix = DefaultHttpControllerSelector.ControllerSuffix;
            return controllerType.Name.Length > controllerSuffix.Length && controllerType.Name.EndsWith(controllerSuffix, StringComparison.OrdinalIgnoreCase);
        }

        internal void SetGetTypesFunc(Func<Assembly, Type[]> getTypesFunc)
        {
            _getTypesFunc = getTypesFunc;
        }

        private static bool TypeIsVisible(Type type)
        {
            return (type != null && type.IsVisible);
        }
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/HttpControllerDispatcher.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Properties;
using System.Web.Http.Routing;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Dispatches an incoming <see cref="HttpRequestMessage"/> to an <see cref="IHttpController"/> implementation for processing.
    /// </summary>
    public class HttpControllerDispatcher : HttpMessageHandler
    {
        private readonly HttpConfiguration _configuration;

        private IExceptionLogger _exceptionLogger;
        private IExceptionHandler _exceptionHandler;
        private IHttpControllerSelector _controllerSelector;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpControllerDispatcher"/> class.
        /// </summary>
        public HttpControllerDispatcher(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            _configuration = configuration;
        }

        /// <summary>
        /// Gets the <see cref="HttpConfiguration"/>.
        /// </summary>
        public HttpConfiguration Configuration
        {
            get { return _configuration; }
        }

        /// <remarks>This property is internal and settable only for unit testing purposes.</remarks>
        internal IExceptionLogger ExceptionLogger
        {
            get
            {
                if (_exceptionLogger == null)
                {
                    _exceptionLogger = ExceptionServices.GetLogger(_configuration);
                }

                return _exceptionLogger;
            }
            set
            {
                _exceptionLogger = value;
            }
        }

        /// <remarks>This property is internal and settable only for unit testing purposes.</remarks>
        internal IExceptionHandler ExceptionHandler
        {
            get
            {
                if (_exceptionHandler == null)
                {
                    _exceptionHandler = ExceptionServices.GetHandler(_configuration);
                }

                return _exceptionHandler;
            }
            set
            {
                _exceptionHandler = value;
            }
        }

        private IHttpControllerSelector ControllerSelector
        {
            get
            {
                if (_controllerSelector == null)
                {
                    _controllerSelector = _configuration.Services.GetHttpControllerSelector();
                }

                return _controllerSelector;
            }
        }

        /// <summary>
        /// Dispatches an incoming <see cref="HttpRequestMessage"/> to an <see cref="IHttpController"/>.
        /// </summary>
        /// <param name="request">The request to dispatch</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task{HttpResponseMessage}"/> representing the ongoing operation.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We report the error in the HTTP response.")]
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            ExceptionDispatchInfo exceptionInfo;
            HttpControllerContext controllerContext = null;

            try
            {
                HttpControllerDescriptor controllerDescriptor = ControllerSelector.SelectController(request);
                if (controllerDescriptor == null)
                {
                    return request.CreateErrorResponse(
                        HttpStatusCode.NotFound,
                        Error.Format(SRResources.ResourceNotFound, request.RequestUri),
                        SRResources.NoControllerSelected);
                }

                IHttpController controller = controllerDescriptor.CreateController(request);
                if (controller == null)
                {
                    return request.CreateErrorResponse(
                        HttpStatusCode.NotFound,
                        Error.Format(SRResources.ResourceNotFound, request.RequestUri),
                        SRResources.NoControllerCreated);
                }

                controllerContext = CreateControllerContext(request, controllerDescriptor, controller);
                return await controller.ExecuteAsync(controllerContext, cancellationToken);
            }
            catch (OperationCanceledException)
            {
                // Propogate the canceled task without calling exception loggers or handlers.
                throw;
            }
            catch (HttpResponseException httpResponseException)
            {
                return httpResponseException.Response;
            }
            catch (Exception exception)
            {
                exceptionInfo = ExceptionDispatchInfo.Capture(exception);
            }

            Debug.Assert(exceptionInfo.SourceException != null);

            ExceptionContext exceptionContext = new ExceptionContext(
                exceptionInfo.SourceException,
                ExceptionCatchBlocks.HttpControllerDispatcher,
                request)
                {
                    ControllerContext = controllerContext,
                };

            await ExceptionLogger.LogAsync(exceptionContext, cancellationToken);
            HttpResponseMessage response = await ExceptionHandler.HandleAsync(exceptionContext, cancellationToken);

            if (response == null)
            {
                exceptionInfo.Throw();
            }

            return response;
        }

        private static HttpControllerContext CreateControllerContext(
            HttpRequestMessage request, 
            HttpControllerDescriptor controllerDescriptor,
            IHttpController controller)
        {
            Contract.Assert(request != null);
            Contract.Assert(controllerDescriptor != null);
            Contract.Assert(controller != null);

            HttpConfiguration controllerConfiguration = controllerDescriptor.Configuration;

            // Set the controller configuration on the request properties
            HttpConfiguration requestConfig = request.GetConfiguration();
            if (requestConfig == null)
            {
                request.SetConfiguration(controllerConfiguration);
            }
            else
            {
                if (requestConfig != controllerConfiguration)
                {
                    request.SetConfiguration(controllerConfiguration);
                }
            }

            HttpRequestContext requestContext = request.GetRequestContext();

            // if the host doesn't create the context we will fallback to creating it.
            if (requestContext == null)
            {
                requestContext = new RequestBackedHttpRequestContext(request)
                {
                    // we are caching controller configuration to support per controller configuration.
                    Configuration = controllerConfiguration,
                };

                // if the host did not set a request context we will also set it back to the request.
                request.SetRequestContext(requestContext);
            }

            return new HttpControllerContext(requestContext, request, controllerDescriptor, controller);
        }

        private static HttpConfiguration EnsureNonNull(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            return configuration;
        }
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/HttpControllerTypeCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Manages a cache of <see cref="System.Web.Http.Controllers.IHttpController"/> types detected in the system.
    /// </summary>
    internal sealed class HttpControllerTypeCache
    {
        private readonly HttpConfiguration _configuration;
        private readonly Lazy<Dictionary<string, ILookup<string, Type>>> _cache;

        public HttpControllerTypeCache(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            _configuration = configuration;
            _cache = new Lazy<Dictionary<string, ILookup<string, Type>>>(InitializeCache);
        }

        internal Dictionary<string, ILookup<string, Type>> Cache
        {
            get { return _cache.Value; }
        }

        public ICollection<Type> GetControllerTypes(string controllerName)
        {
            if (String.IsNullOrEmpty(controllerName))
            {
                throw Error.ArgumentNullOrEmpty("controllerName");
            }

            HashSet<Type> matchingTypes = new HashSet<Type>();

            ILookup<string, Type> namespaceLookup;
            if (_cache.Value.TryGetValue(controllerName, out namespaceLookup))
            {
                foreach (var namespaceGroup in namespaceLookup)
                {
                    matchingTypes.UnionWith(namespaceGroup);
                }
            }

            return matchingTypes;
        }

        private Dictionary<string, ILookup<string, Type>> InitializeCache()
        {
            IAssembliesResolver assembliesResolver = _configuration.Services.GetAssembliesResolver();
            IHttpControllerTypeResolver controllersResolver = _configuration.Services.GetHttpControllerTypeResolver();

            ICollection<Type> controllerTypes = controllersResolver.GetControllerTypes(assembliesResolver);
            var groupedByName = controllerTypes.GroupBy(
                t => t.Name.Substring(0, t.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length),
                StringComparer.OrdinalIgnoreCase);

            return groupedByName.ToDictionary(
                g => g.Key,
                g => g.ToLookup(t => t.Namespace ?? String.Empty, StringComparer.OrdinalIgnoreCase),
                StringComparer.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/HttpRoutingDispatcher.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Hosting;
using System.Web.Http.Properties;
using System.Web.Http.Routing;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// This class is the default endpoint message handler which examines the <see cref="IHttpRoute"/>
    /// of the matched route, and chooses which message handler to call. If <see cref="IHttpRoute.Handler"/>
    /// is <c>null</c>, then it delegates to <see cref="HttpControllerDispatcher"/>.
    /// </summary>
    public class HttpRoutingDispatcher : HttpMessageHandler
    {
        private readonly HttpConfiguration _configuration;
        private readonly HttpMessageInvoker _defaultInvoker;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpRoutingDispatcher"/> class,
        /// using the provided <see cref="HttpConfiguration"/> and <see cref="HttpControllerDispatcher"/>
        /// as the default handler.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "HttpControllerDispatcher does not require disposal")]
        public HttpRoutingDispatcher(HttpConfiguration configuration)
            : this(configuration, new HttpControllerDispatcher(configuration))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpRoutingDispatcher"/> class,
        /// using the provided <see cref="HttpConfiguration"/> and <see cref="HttpMessageHandler"/>.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="defaultHandler">The default handler to use when the <see cref="IHttpRoute"/> has no <see cref="IHttpRoute.Handler"/>.</param>
        public HttpRoutingDispatcher(HttpConfiguration configuration, HttpMessageHandler defaultHandler)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }
            if (defaultHandler == null)
            {
                throw Error.ArgumentNull("defaultHandler");
            }

            _configuration = configuration;
            _defaultInvoker = new HttpMessageInvoker(defaultHandler);
        }

        /// <inheritdoc/>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The Web API framework will dispose of the response after sending it")]
        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            // Lookup route data, or if not found as a request property then we look it up in the route table
            IHttpRouteData routeData = request.GetRouteData();
            if (routeData == null)
            {
                routeData = _configuration.Routes.GetRouteData(request);
                if (routeData != null)
                {
                    request.SetRouteData(routeData);
                }
            }

            if (routeData == null || (routeData.Route != null && routeData.Route.Handler is StopRoutingHandler))
            {
                request.Properties.Add(HttpPropertyKeys.NoRouteMatched, true);
                return Task.FromResult(request.CreateErrorResponse(
                    HttpStatusCode.NotFound,
                    Error.Format(SRResources.ResourceNotFound, request.RequestUri),
                    SRResources.NoRouteData));
            }

            routeData.RemoveOptionalRoutingParameters();

            // routeData.Route could be null if user adds a custom route that derives from System.Web.Routing.Route explicitly 
            // and add that to the RouteCollection in the web hosted case
            var invoker = (routeData.Route == null || routeData.Route.Handler == null) ?
                _defaultInvoker : new HttpMessageInvoker(routeData.Route.Handler, disposeHandler: false);
            return invoker.SendAsync(request, cancellationToken);
        }       
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/IAssembliesResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Provides an abstraction for managing the assemblies of an application. A different
    /// implementation can be registered via the <see cref="T:System.Web.Http.Services.DependencyResolver"/>.
    /// </summary>
    public interface IAssembliesResolver
    {
        /// <summary>
        /// Returns a list of assemblies available for the application.
        /// </summary>
        /// <returns>An <see cref="ICollection{Assembly}"/> of assemblies.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This is better handled as a method.")]
        ICollection<Assembly> GetAssemblies();
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/IHttpControllerActivator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Defines the methods that are required for an <see cref="IHttpControllerActivator"/>.
    /// </summary>
    public interface IHttpControllerActivator
    {
        IHttpController Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType);
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/IHttpControllerSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Defines the methods that are required for an <see cref="IHttpController"/> factory.
    /// </summary>
    public interface IHttpControllerSelector
    {
        /// <summary>
        /// Selects a <see cref="HttpControllerDescriptor"/> for the given <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="request">The request message.</param>
        /// <returns>An <see cref="HttpControllerDescriptor"/> instance.</returns>
        HttpControllerDescriptor SelectController(HttpRequestMessage request);

        /// <summary>
        /// Returns a map, keyed by controller string, of all <see cref="HttpControllerDescriptor"/> that the selector can select. 
        /// This is primarily called by <see cref="System.Web.Http.Description.IApiExplorer"/> to discover all the possible controllers in the system.
        /// </summary>
        /// <returns>A map of all <see cref="HttpControllerDescriptor"/> that the selector can select, or null if the selector does not have a well-defined mapping of <see cref="HttpControllerDescriptor"/>.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This is better handled as a method.")]
        IDictionary<string, HttpControllerDescriptor> GetControllerMapping();
    }
}


================================================
FILE: src/System.Web.Http/Dispatcher/IHttpControllerTypeResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.Http.Dispatcher
{
    /// <summary>
    /// Provides an abstraction for managing the controller types of an application. A different
    /// implementation can be registered via the <see cref="T:System.Web.Http.Services.DependencyResolver"/>.
    /// </summary>
    public interface IHttpControllerTypeResolver
    {
        /// <summary>
        /// Returns a list of controllers available for the application.
        /// </summary>
        /// <returns>An <see cref="ICollection{Type}"/> of controllers.</returns>
        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This is better handled as a method.")]
        ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver);
    }
}


================================================
FILE: src/System.Web.Http/EmptyReadOnlyDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace System.Web.Http
{
    internal class EmptyReadOnlyDictionary<TKey, TValue>
    {
        private static readonly ReadOnlyDictionary<TKey, TValue> _value = new ReadOnlyDictionary<TKey, TValue>(new Dictionary<TKey, TValue>());

        public static IDictionary<TKey, TValue> Value
        {
            get { return _value; }
        }        
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/CompositeExceptionLogger.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.ExceptionHandling
{
    internal class CompositeExceptionLogger : IExceptionLogger
    {
        private readonly IExceptionLogger[] _loggers;

        public CompositeExceptionLogger(params IExceptionLogger[] loggers)
            : this((IEnumerable<IExceptionLogger>)loggers)
        {
        }

        public CompositeExceptionLogger(IEnumerable<IExceptionLogger> loggers)
        {
            if (loggers == null)
            {
                throw new ArgumentNullException("loggers");
            }

            _loggers = loggers.ToArray();
        }

        public IEnumerable<IExceptionLogger> Loggers
        {
            get { return _loggers; }
        }

        public Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            List<Task> tasks = new List<Task>();

            Contract.Assert(_loggers != null);

            foreach (IExceptionLogger logger in _loggers)
            {
                if (logger == null)
                {
                    throw new InvalidOperationException(Error.Format(SRResources.TypeInstanceMustNotBeNull,
                        typeof(IExceptionLogger).Name));
                }

                Task task = logger.LogAsync(context, cancellationToken);
                tasks.Add(task);
            }

            return Task.WhenAll(tasks);
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/DefaultExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;
using System.Web.Http.Results;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Provides the default implementation for handling exceptions within Web API.</summary>
    /// <remarks>
    /// This class preserves the legacy behavior of catch blocks and is the the default registered IExceptionHandler.
    /// This default service allows adding the IExceptionHandler service extensibility point without making any
    /// breaking changes in the default implementation.
    /// </remarks>
    internal class DefaultExceptionHandler : IExceptionHandler
    {
        public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            Handle(context);
            return TaskHelpers.Completed();
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "We already shipped this code; avoiding even minor breaking changes in error handling.")]
        private static void Handle(ExceptionHandlerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);
            Exception exception = exceptionContext.Exception;

            HttpRequestMessage request = exceptionContext.Request;

            if (request == null)
            {
                throw new ArgumentException(Error.Format(SRResources.TypePropertyMustNotBeNull,
                    typeof(ExceptionContext).Name, "Request"), "context");
            }

            if (exceptionContext.CatchBlock == ExceptionCatchBlocks.IExceptionFilter)
            {
                // The exception filter stage propagates unhandled exceptions by default (when no filter handles the
                // exception).
                return;
            }

            context.Result = new ResponseMessageResult(request.CreateErrorResponse(HttpStatusCode.InternalServerError,
                exception));
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/EmptyExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>
    /// Represents an exception handler that leaves exceptions unhandled (allowing them to propagate).
    /// </summary>
    /// <remarks>
    /// This class represents the behavior of having no IExceptionHandler service, such as when the registered service
    /// is removed (Null Object pattern).
    /// </remarks>
    internal class EmptyExceptionHandler : IExceptionHandler
    {
        public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            // For exceptions at the top of the call stack, Result will start out non-null (due to
            // LastChanceExceptionHandler). This class does not force exceptions back to unhandled in such cases, so it
            // will not not trigger the host-level exception processing, such as the ASP.NET yellow screen.
            return TaskHelpers.Completed();
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionCatchBlocks.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Batch;
using System.Web.Http.Dispatcher;
using System.Web.Http.Filters;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Provides the catch blocks used within this assembly.</summary>
    public static class ExceptionCatchBlocks
    {
        private static readonly ExceptionContextCatchBlock _httpBatchHandler =
            new ExceptionContextCatchBlock(typeof(HttpBatchHandler).Name, isTopLevel: false, callsHandler: true);
        private static readonly ExceptionContextCatchBlock _httpControllerDispatcher =
            new ExceptionContextCatchBlock(typeof(HttpControllerDispatcher).Name, isTopLevel: false, callsHandler: true);
        private static readonly ExceptionContextCatchBlock _httpServer =
            new ExceptionContextCatchBlock(typeof(HttpServer).Name, isTopLevel: true, callsHandler: true);
        private static readonly ExceptionContextCatchBlock _exceptionFilter =
            new ExceptionContextCatchBlock(typeof(IExceptionFilter).Name, isTopLevel: false, callsHandler: true);

        /// <summary>Gets the catch block in <see cref="HttpBatchHandler"/>.SendAsync.</summary>
        public static ExceptionContextCatchBlock HttpBatchHandler
        {
            get { return _httpBatchHandler; }
        }

        /// <summary>Gets the catch block in <see cref="HttpControllerDispatcher"/>.SendAsync.</summary>
        public static ExceptionContextCatchBlock HttpControllerDispatcher
        {
            get { return _httpControllerDispatcher; }
        }

        /// <summary>Gets the catch block in <see cref="HttpServer"/>.SendAsync</summary>
        public static ExceptionContextCatchBlock HttpServer
        {
            get { return _httpServer; }
        }

        /// <summary>
        /// Gets the catch block in <see cref="ApiController"/>.ExecuteAsync when using <see cref="IExceptionFilter"/>.
        /// </summary>
        public static ExceptionContextCatchBlock IExceptionFilter
        {
            get { return _exceptionFilter; }
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Represents an exception and the contextual data associated with it when it was caught.</summary>
    public class ExceptionContext
    {
        /// <summary>Initializes a new instance of the <see cref="ExceptionContext"/> class.</summary>
        /// <param name="exception">The exception caught.</param>
        /// <param name="catchBlock">The catch block where the exception was caught.</param>
        /// <remarks>This constructor is for unit testing purposes only.</remarks>
        public ExceptionContext(Exception exception, ExceptionContextCatchBlock catchBlock)
        {
            if (exception == null)
            {
                throw new ArgumentNullException("exception");
            }

            Exception = exception;

            if (catchBlock == null)
            {
                throw new ArgumentNullException("catchBlock");
            }

            CatchBlock = catchBlock;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExceptionContext"/> class using the values provided.
        /// </summary>
        /// <param name="exception">The exception caught.</param>
        /// <param name="catchBlock">The catch block where the exception was caught.</param>
        /// <param name="actionContext">The action context in which the exception occurred.</param>
        public ExceptionContext(Exception exception, ExceptionContextCatchBlock catchBlock,
            HttpActionContext actionContext)
            : this(exception, catchBlock)
        {
            if (actionContext == null)
            {
                throw new ArgumentNullException("actionContext");
            }

            ActionContext = actionContext;

            HttpControllerContext controllerContext = actionContext.ControllerContext;

            if (controllerContext == null)
            {
                throw new ArgumentException(Error.Format(SRResources.TypePropertyMustNotBeNull,
                    typeof(HttpActionContext).Name, "ControllerContext"), "actionContext");
            }

            ControllerContext = controllerContext;

            HttpRequestContext requestContext = controllerContext.RequestContext;
            Contract.Assert(requestContext != null);
            RequestContext = requestContext;

            HttpRequestMessage request = controllerContext.Request;

            if (request == null)
            {
                throw new ArgumentException(Error.Format(SRResources.TypePropertyMustNotBeNull,
                    typeof(HttpControllerContext).Name, "Request"), "actionContext");
            }

            Request = request;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExceptionContext"/> class using the values provided.
        /// </summary>
        /// <param name="exception">The exception caught.</param>
        /// <param name="catchBlock">The catch block where the exception was caught.</param>
        /// <param name="request">The request being processed when the exception was caught.</param>
        public ExceptionContext(Exception exception, ExceptionContextCatchBlock catchBlock, HttpRequestMessage request)
            : this(exception, catchBlock)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            Request = request;
            RequestContext = request.GetRequestContext();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ExceptionContext"/> class using the values provided.
        /// </summary>
        /// <param name="exception">The exception caught.</param>
        /// <param name="catchBlock">The catch block where the exception was caught.</param>
        /// <param name="request">The request being processed when the exception was caught.</param>
        /// <param name="response">The repsonse being returned when the exception was caught.</param>
        public ExceptionContext(Exception exception, ExceptionContextCatchBlock catchBlock, HttpRequestMessage request,
            HttpResponseMessage response) : this(exception, catchBlock)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            Request = request;
            RequestContext = request.GetRequestContext();

            if (response == null)
            {
                throw new ArgumentNullException("response");
            }

            Response = response;
        }

        /// <summary>Gets the exception caught.</summary>
        public Exception Exception { get; private set; }

        /// <summary>Gets the catch block in which the exception was caught.</summary>
        public ExceptionContextCatchBlock CatchBlock { get; private set; }

        /// <summary>Gets the request being processed when the exception was caught.</summary>
        /// <remarks>The setter is for unit testing purposes only.</remarks>
        public HttpRequestMessage Request { get; set; }

        /// <summary>Gets the request context in which the exception occurred.</summary>
        /// <remarks>The setter is for unit testing purposes only.</remarks>
        public HttpRequestContext RequestContext { get; set; }

        /// <summary>Gets the controller context in which the exception occurred, if available.</summary>
        /// <remarks>
        /// <para>This property will be <see langword="null"/> in most cases.</para>
        /// <para>The setter is for unit testing purposes only.</para>
        /// </remarks>
        public HttpControllerContext ControllerContext { get; set; }

        /// <summary>Gets the action context in which the exception occurred, if available.</summary>
        /// <remarks>
        /// <para>This property will be <see langword="null"/> in most cases.</para>
        /// <para>The setter is for unit testing purposes only.</para>
        /// </remarks>
        public HttpActionContext ActionContext { get; set; }

        /// <summary>Gets the response being sent when the exception was caught.</summary>
        /// <remarks>
        /// <para>This property will be <see langword="null"/> in most cases.</para>
        /// <para>The setter is for unit testing purposes only.</para>
        /// </remarks>
        public HttpResponseMessage Response { get; set; }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionContextCatchBlock.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Represents the catch block location for an <see cref="ExceptionContext"/>.</summary>
    [DebuggerDisplay("Name: {Name}, IsTopLevel: {IsTopLevel}")]
    public class ExceptionContextCatchBlock
    {
        private readonly string _name;
        private readonly bool _isTopLevel;
        private readonly bool _callsHandler;

        /// <summary>
        /// Initializes a new instance of <see cref="ExceptionContextCatchBlock"/> with the values provided.
        /// </summary>
        /// <param name="name">The label for the catch block where the exception was caught.</param>
        /// <param name="isTopLevel">
        /// A value indicating whether the catch block where the exception was caught is the last one before the host.
        /// </param>
        /// <param name="callsHandler">
        /// A value indicating whether exceptions in the catch block can be handled after they are logged.
        /// </param>
        /// <remarks>
        /// To compare an exception catch block with a well-known value, see classes like
        /// <see cref="ExceptionCatchBlocks"/> for the specific objects to use.
        /// This constructor is only intended for use within static classes that define such well-known catch blocks.
        /// </remarks>
        public ExceptionContextCatchBlock(string name, bool isTopLevel, bool callsHandler)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            _name = name;
            _isTopLevel = isTopLevel;
            _callsHandler = callsHandler;
        }

        /// <summary>Gets a label for the catch block in which the exception was caught.</summary>
        public string Name
        {
            get { return _name; }
        }

        /// <summary>
        /// Gets a value indicating whether the catch block where the exception was caught is the last one before the
        /// host.
        /// </summary>
        public bool IsTopLevel
        {
            get { return _isTopLevel; }
        }

        /// <summary>
        /// Gets a value indicating whether exceptions in the catch block can be handled after they are logged.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Some exceptions are caught after a response is already partially sent, which prevents sending a new
        /// response to handle the exception. In such cases, <see cref="IExceptionLogger"/> will be called to log the
        /// exception, but the <see cref="IExceptionHandler"/> will not be called.
        /// </para>
        /// <para>
        /// If this value is <see langword="true"/>, exceptions from this catch block will be provided to both
        /// <see cref="IExceptionLogger"/> and <see cref="IExceptionHandler"/>. If this value is
        /// see langword="false"/>, exceptions from this catch block cannot be handled and will only be provided to
        /// <see cref="IExceptionLogger"/>.
        /// </para>
        /// </remarks>
        public bool CallsHandler
        {
            get { return _callsHandler; }
        }

        /// <inheritdoc/>
        public override string ToString()
        {
            return _name;
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Represents an unhandled exception handler.</summary>
    public abstract class ExceptionHandler : IExceptionHandler
    {
        /// <inheritdoc />
        Task IExceptionHandler.HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);

            if (!ShouldHandle(context))
            {
                return TaskHelpers.Completed();
            }

            return HandleAsync(context, cancellationToken);
        }

        /// <summary>When overridden in a derived class, handles the exception asynchronously.</summary>
        /// <param name="context">The exception handler context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task representing the asynchronous exception handling operation.</returns>
        public virtual Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            Handle(context);
            return TaskHelpers.Completed();
        }

        /// <summary>When overridden in a derived class, handles the exception synchronously.</summary>
        /// <param name="context">The exception handler context.</param>
        public virtual void Handle(ExceptionHandlerContext context)
        {
        }

        /// <summary>Determines whether the exception should be handled.</summary>
        /// <param name="context">The exception handler context.</param>
        /// <returns>
        /// <see langword="true"/> if the exception should be handled; otherwise, <see langword="false"/>.
        /// </returns>
        /// <remarks>The default decision is only to handle exceptions caught at top-level catch blocks.</remarks>
        public virtual bool ShouldHandle(ExceptionHandlerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);

            ExceptionContextCatchBlock catchBlock = exceptionContext.CatchBlock;

            return catchBlock.IsTopLevel;
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionHandlerContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Represents the context within which unhandled exception handling occurs.</summary>
    public class ExceptionHandlerContext
    {
        private readonly ExceptionContext _exceptionContext;

        /// <summary>Initializes a new instance of the <see cref="ExceptionHandlerContext"/> class.</summary>
        /// <param name="exceptionContext">The exception context.</param>
        public ExceptionHandlerContext(ExceptionContext exceptionContext)
        {
            if (exceptionContext == null)
            {
                throw new ArgumentNullException("exceptionContext");
            }

            _exceptionContext = exceptionContext;
        }

        /// <summary>Gets the exception context providing the exception and related data.</summary>
        public ExceptionContext ExceptionContext
        {
            get { return _exceptionContext; }
        }

        /// <summary>Gets or sets the result providing the response message when the exception is handled.</summary>
        /// <remarks>
        /// If this value is <see langword="null"/>, the exception is left unhandled and will be re-thrown.
        /// </remarks>
        public IHttpActionResult Result { get; set; }

        /// <summary>Gets the exception caught.</summary>
        public Exception Exception
        {
            get { return _exceptionContext.Exception; }
        }

        /// <summary>Gets the catch block in which the exception was caught.</summary>
        public ExceptionContextCatchBlock CatchBlock
        {
            get { return _exceptionContext.CatchBlock; }
        }

        /// <summary>Gets the request being processed when the exception was caught.</summary>
        public HttpRequestMessage Request
        {
            get { return _exceptionContext.Request; }
        }

        /// <summary>Gets the request context in which the exception occurred.</summary>
        public HttpRequestContext RequestContext
        {
            get { return _exceptionContext.RequestContext; }
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionHandlerExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Provides extension methods for <see cref="IExceptionHandler"/>.</summary>
    public static class ExceptionHandlerExtensions
    {
        /// <summary>Calls an exception handler and determines the response handling it, if any.</summary>
        /// <param name="handler">The unhandled exception handler.</param>
        /// <param name="context">The exception context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>
        /// A task that, when completed, contains the response message to return when the exception is handled, or
        /// <see langword="null"/> when the exception remains unhandled.
        /// </returns>
        public static Task<HttpResponseMessage> HandleAsync(this IExceptionHandler handler,
            ExceptionContext context, CancellationToken cancellationToken)
        {
            if (handler == null)
            {
                throw new ArgumentNullException("handler");
            }

            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionHandlerContext handlerContext = new ExceptionHandlerContext(context);
            return HandleAsyncCore(handler, handlerContext, cancellationToken);
        }

        private static async Task<HttpResponseMessage> HandleAsyncCore(IExceptionHandler handler,
            ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            Contract.Assert(handler != null);
            Contract.Assert(context != null);

            await handler.HandleAsync(context, cancellationToken);

            IHttpActionResult result = context.Result;

            if (result == null)
            {
                return null;
            }

            HttpResponseMessage response = await result.ExecuteAsync(cancellationToken);

            if (response == null)
            {
                throw new InvalidOperationException(Error.Format(SRResources.TypeMethodMustNotReturnNull,
                    typeof(IHttpActionResult).Name, "ExecuteAsync"));
            }

            return response;
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionLogger.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Represents an unhandled exception logger.</summary>
    public abstract class ExceptionLogger : IExceptionLogger
    {
        internal const string LoggedByKey = "MS_LoggedBy";

        /// <inheritdoc />
        Task IExceptionLogger.LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);

            if (!ShouldLog(context))
            {
                return TaskHelpers.Completed();
            }

            return LogAsync(context, cancellationToken);
        }

        /// <summary>When overridden in a derived class, logs the exception asynchronously.</summary>
        /// <param name="context">The exception logger context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task representing the asynchronous exception logging operation.</returns>
        public virtual Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            Log(context);
            return TaskHelpers.Completed();
        }

        /// <summary>When overridden in a derived class, logs the exception synchronously.</summary>
        /// <param name="context">The exception logger context.</param>
        public virtual void Log(ExceptionLoggerContext context)
        {
        }

        /// <summary>Determines whether the exception should be logged.</summary>
        /// <param name="context">The exception logger context.</param>
        /// <returns>
        /// <see langword="true"/> if the exception should be logged; otherwise, <see langword="false"/>.
        /// </returns>
        /// <remarks>
        /// The default decision is only to log an exception instance the first time it is seen by this logger.
        /// </remarks>
        public virtual bool ShouldLog(ExceptionLoggerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);

            IDictionary data = exceptionContext.Exception.Data;

            if (data == null || data.IsReadOnly)
            {
                // If the exception doesn't have a mutable Data collection, we can't prevent duplicate logging. In this
                // case, just log every time.
                return true;
            }

            ICollection<object> loggedBy;

            if (data.Contains(LoggedByKey))
            {
                object untypedLoggedBy = data[LoggedByKey];

                loggedBy = untypedLoggedBy as ICollection<object>;

                if (loggedBy == null)
                {
                    // If exception.Data["MS_LoggedBy"] exists but is not of the right type, we can't prevent duplicate
                    // logging. In this case, just log every time.
                    return true;
                }

                if (loggedBy.Contains(this))
                {
                    // If this logger has already logged this exception, don't log again.
                    return false;
                }
            }
            else
            {
                loggedBy = new List<object>();
                data.Add(LoggedByKey, loggedBy);
            }

            // Either loggedBy did not exist before (we just added it) or it already existed of the right type and did
            // not already contain this logger. Log now, but mark not to log this exception again for this logger.
            Contract.Assert(loggedBy != null);
            loggedBy.Add(this);
            return true;
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionLoggerContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Represents the context within which unhandled exception logging occurs.</summary>
    public class ExceptionLoggerContext
    {
        private readonly ExceptionContext _exceptionContext;

        /// <summary>
        /// Initializes a new instance of the <see cref="ExceptionLoggerContext"/> class using the values provided.
        /// </summary>
        /// <param name="exceptionContext">The exception context.</param>
        public ExceptionLoggerContext(ExceptionContext exceptionContext)
        {
            if (exceptionContext == null)
            {
                throw new ArgumentNullException("exceptionContext");
            }

            _exceptionContext = exceptionContext;
        }

        /// <summary>Gets the exception context providing the exception and related data.</summary>
        public ExceptionContext ExceptionContext
        {
            get { return _exceptionContext; }
        }

        /// <summary>Gets the exception caught.</summary>
        public Exception Exception
        {
            get { return _exceptionContext.Exception; }
        }

        /// <summary>Gets the catch block in which the exception was caught.</summary>
        public ExceptionContextCatchBlock CatchBlock
        {
            get { return _exceptionContext.CatchBlock; }
        }

        /// <summary>Gets the request being processed when the exception was caught.</summary>
        public HttpRequestMessage Request
        {
            get { return _exceptionContext.Request; }
        }

        /// <summary>Gets the request context in which the exception occurred.</summary>
        public HttpRequestContext RequestContext
        {
            get { return _exceptionContext.RequestContext; }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the exception can subsequently be handled by an
        /// <see cref="IExceptionHandler"/> to produce a new response message.
        /// </summary>
        /// <remarks>
        /// <para>
        /// Some exceptions are caught after a response is already partially sent, which prevents sending a new
        /// response to handle the exception. In such cases, <see cref="IExceptionLogger"/> will be called to log the
        /// exception, but the <see cref="IExceptionHandler"/> will not be called.
        /// </para>
        /// <para>
        /// If this value is <see langword="true"/>, exceptions from this catch block will be provided to both
        /// <see cref="IExceptionLogger"/> and <see cref="IExceptionHandler"/>. If this value is
        /// see langword="false"/>, exceptions from this catch block cannot be handled and will only be provided to
        /// <see cref="IExceptionLogger"/>.
        /// </para>
        /// </remarks>
        public bool CallsHandler
        {
            get
            {
                Contract.Assert(_exceptionContext != null);
                ExceptionContextCatchBlock catchBlock = _exceptionContext.CatchBlock;

                return catchBlock.CallsHandler;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionLoggerExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Provides extension methods for <see cref="IExceptionLogger"/>.</summary>
    public static class ExceptionLoggerExtensions
    {
        /// <summary>Calls an exception logger.</summary>
        /// <param name="logger">The unhandled exception logger.</param>
        /// <param name="context">The exception context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task representing the asynchronous exception logging operation.</returns>
        public static Task LogAsync(this IExceptionLogger logger, ExceptionContext context,
            CancellationToken cancellationToken)
        {
            if (logger == null)
            {
                throw new ArgumentNullException("logger");
            }

            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionLoggerContext loggerContext = new ExceptionLoggerContext(context);
            return logger.LogAsync(loggerContext, cancellationToken);
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/ExceptionServices.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Web.Http.Controllers;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Creates exception services to call logging and handling from catch blocks.</summary>
    public static class ExceptionServices
    {
        /// <summary>Gets an exception logger that calls all registered logger services.</summary>
        /// <param name="configuration">The configuration.</param>
        /// <returns>A composite logger.</returns>
        public static IExceptionLogger GetLogger(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            ServicesContainer services = configuration.Services;
            Contract.Assert(services != null);
            return GetLogger(services);
        }

        /// <summary>Gets an exception logger that calls all registered logger services.</summary>
        /// <param name="services">The services container.</param>
        /// <returns>A composite logger.</returns>
        public static IExceptionLogger GetLogger(ServicesContainer services)
        {
            if (services == null)
            {
                throw new ArgumentNullException("services");
            }

            Lazy<IExceptionLogger> exceptionServicesLogger = services.ExceptionServicesLogger;
            Contract.Assert(exceptionServicesLogger != null);
            return exceptionServicesLogger.Value;
        }

        internal static IExceptionLogger CreateLogger(ServicesContainer services)
        {
            Contract.Assert(services != null);

            IEnumerable<IExceptionLogger> loggers = services.GetExceptionLoggers();
            Contract.Assert(loggers != null);
            return new CompositeExceptionLogger(loggers);
        }

        /// <summary>
        /// Gets an exception handler that calls the registered handler service, if any, and ensures exceptions do not
        /// accidentally propagate to the host.
        /// </summary>
        /// <param name="configuration">The configuration.</param>
        /// <returns>
        /// An exception handler that calls any registered handler and ensures exceptions do not accidentally propagate
        /// to the host.
        /// </returns>
        public static IExceptionHandler GetHandler(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            ServicesContainer services = configuration.Services;
            Contract.Assert(services != null);
            return GetHandler(services);
        }

        /// <summary>
        /// Gets an exception handler that calls the registered handler service, if any, and ensures exceptions do not
        /// accidentally propagate to the host.
        /// </summary>
        /// <param name="services">The services container.</param>
        /// <returns>
        /// An exception handler that calls any registered handler and ensures exceptions do not accidentally propagate
        /// to the host.
        /// </returns>
        public static IExceptionHandler GetHandler(ServicesContainer services)
        {
            if (services == null)
            {
                throw new ArgumentNullException("services");
            }

            Lazy<IExceptionHandler> exceptionServicesHandler = services.ExceptionServicesHandler;
            Contract.Assert(exceptionServicesHandler != null);
            return exceptionServicesHandler.Value;
        }

        internal static IExceptionHandler CreateHandler(ServicesContainer services)
        {
            Contract.Assert(services != null);

            IExceptionHandler innerHandler = services.GetExceptionHandler() ?? new EmptyExceptionHandler();
            return new LastChanceExceptionHandler(innerHandler);
        }
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/IExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Defines an unhandled exception handler.</summary>
    /// <remarks>
    /// An unhandled exception handler can either handle the exception (by providing a response) or allow it to
    /// propagate (by providing no response).
    /// </remarks>
    public interface IExceptionHandler
    {
        /// <summary>
        /// Process an unhandled exception, either allowing it to propagate or handling it by providing a response
        /// message to return instead.
        /// </summary>
        /// <param name="context">The exception handler context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task representing the asynchronous exception handling operation.</returns>
        /// <remarks>
        /// <para>
        /// The exception handler either handles the exception or allows it to propagate. An exception is handled by
        /// setting <see cref="ExceptionHandlerContext.Result"/>, which provides the response message to return in
        /// place of the exception thrown. If <see cref="ExceptionHandlerContext.Result"/> is
        /// <see langword="null"/>, the exception remains unhandled, and the exception will continue to propagate up
        /// the call stack.
        /// </para>
        /// <para>
        /// If the exception propagates when <see cref="ExceptionContextCatchBlock.IsTopLevel"/> is
        /// <see langword="true"/>, the host will see the exception thrown. If the exception propagates when
        /// <see cref="ExceptionContextCatchBlock.IsTopLevel"/> is <see langword="false"/>, another catch block within
        /// Web API will be the next to see the exception, and the exception handler will be called again to make a
        /// decision at that point.
        /// </para>
        /// </remarks>
        Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken);
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/IExceptionLogger.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.ExceptionHandling
{
    /// <summary>Defines an unhandled exception logger.</summary>
    public interface IExceptionLogger
    {
        /// <summary>Logs an unhandled exception.</summary>
        /// <param name="context">The exception logger context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task representing the asynchronous exception logging operation.</returns>
        Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken);
    }
}


================================================
FILE: src/System.Web.Http/ExceptionHandling/LastChanceExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Results;

namespace System.Web.Http.ExceptionHandling
{
    internal class LastChanceExceptionHandler : IExceptionHandler
    {
        private readonly IExceptionHandler _innerHandler;

        public LastChanceExceptionHandler(IExceptionHandler innerHandler)
        {
            if (innerHandler == null)
            {
                throw new ArgumentNullException("innerHandler");
            }

            _innerHandler = innerHandler;
        }

        public IExceptionHandler InnerHandler
        {
            get { return _innerHandler; }
        }

        public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            if (context != null)
            {
                ExceptionContext exceptionContext = context.ExceptionContext;
                Contract.Assert(exceptionContext != null);

                ExceptionContextCatchBlock catchBlock = exceptionContext.CatchBlock;

                if (catchBlock != null && catchBlock.IsTopLevel)
                {
                    context.Result = CreateDefaultLastChanceResult(exceptionContext);
                }
            }

            return _innerHandler.HandleAsync(context, cancellationToken);
        }

        private static IHttpActionResult CreateDefaultLastChanceResult(ExceptionContext context)
        {
            Contract.Assert(context != null);

            Exception exception = context.Exception;

            if (exception == null)
            {
                return null;
            }

            HttpRequestMessage request = context.Request;

            if (request == null)
            {
                return null;
            }

            HttpRequestContext requestContext = context.RequestContext;

            if (requestContext == null)
            {
                return null;
            }

            HttpConfiguration configuration = requestContext.Configuration;

            if (configuration == null)
            {
                return null;
            }

            ServicesContainer services = configuration.Services;
            Contract.Assert(services != null);
            IContentNegotiator contentNegotiator = services.GetContentNegotiator();

            if (contentNegotiator == null)
            {
                return null;
            }

            IEnumerable<MediaTypeFormatter> formatters = configuration.Formatters;
            Contract.Assert(formatters != null);

            return new ExceptionResult(exception, requestContext.IncludeErrorDetail, contentNegotiator, request,
                formatters);
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/ActionDescriptorFilterProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    /// <summary>
    /// This <see cref="IFilterProvider"/> implementation retrieves <see cref="FilterInfo">filters</see> associated with an <see cref="HttpActionDescriptor"/>
    /// instance.
    /// </summary>
    public class ActionDescriptorFilterProvider : IFilterProvider
    {
        /// <summary>
        /// Returns the collection of filters associated with <paramref name="actionDescriptor"/>.
        /// </summary>
        /// <remarks>
        /// The implementation invokes <see cref="HttpActionDescriptor.GetFilters()"/> and <see cref="HttpControllerDescriptor.GetFilters()"/>.
        /// </remarks>
        /// <param name="configuration">The configuration. This value is not used.</param>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <returns>A collection of filters.</returns>
        public IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            IEnumerable<FilterInfo> controllerFilters = actionDescriptor.ControllerDescriptor.GetFilters().Select(instance => new FilterInfo(instance, FilterScope.Controller));
            IEnumerable<FilterInfo> actionFilters = actionDescriptor.GetFilters().Select(instance => new FilterInfo(instance, FilterScope.Action));

            return controllerFilters.Concat(actionFilters);
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/ActionFilterAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;

namespace System.Web.Http.Filters
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public abstract class ActionFilterAttribute : FilterAttribute, IActionFilter
    {
        public virtual void OnActionExecuting(HttpActionContext actionContext)
        {
        }

        public virtual void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "exception is flowed through the task")]
        public virtual Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            try
            {
                OnActionExecuting(actionContext);
            }
            catch (Exception ex)
            {
                return TaskHelpers.FromError(ex);
            }

            return TaskHelpers.Completed();
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "exception is flowed through the task")]
        public virtual Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
        {
            try
            {
                OnActionExecuted(actionExecutedContext);
            }
            catch (Exception ex)
            {
                return TaskHelpers.FromError(ex);
            }

            return TaskHelpers.Completed();
        }

        Task<HttpResponseMessage> IActionFilter.ExecuteActionFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }
            if (continuation == null)
            {
                throw Error.ArgumentNull("continuation");
            }

            return ExecuteActionFilterAsyncCore(actionContext, cancellationToken, continuation);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We want to intercept all exceptions")]
        private async Task<HttpResponseMessage> ExecuteActionFilterAsyncCore(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
        {
            await OnActionExecutingAsync(actionContext, cancellationToken);

            if (actionContext.Response != null)
            {
                return actionContext.Response;
            }

            return await CallOnActionExecutedAsync(actionContext, cancellationToken, continuation);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We want to intercept all exceptions")]
        private async Task<HttpResponseMessage> CallOnActionExecutedAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
        {
            cancellationToken.ThrowIfCancellationRequested();

            HttpResponseMessage response = null;
            ExceptionDispatchInfo exceptionInfo = null;
            try
            {
                response = await continuation();
            }
            catch (Exception e)
            {
                exceptionInfo = ExceptionDispatchInfo.Capture(e);
            }

            Exception exception;

            if (exceptionInfo == null)
            {
                exception = null;
            }
            else
            {
                exception = exceptionInfo.SourceException;
            }

            HttpActionExecutedContext executedContext = new HttpActionExecutedContext(actionContext, exception)
            {
                Response = response
            };

            try
            {
                await OnActionExecutedAsync(executedContext, cancellationToken);
            }
            catch
            {
                // Catch is running because OnActionExecuted threw an exception, so we just want to re-throw.
                // We also need to reset the response to forget about it since a filter threw an exception.
                actionContext.Response = null;
                throw;
            }

            if (executedContext.Response != null)
            {
                return executedContext.Response;
            }

            Exception newException = executedContext.Exception;

            if (newException != null)
            {
                if (newException == exception)
                {
                    exceptionInfo.Throw();
                }
                else
                {
                    throw newException;
                }
            }

            throw Error.InvalidOperation(SRResources.ActionFilterAttribute_MustSupplyResponseOrException, GetType().Name);
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/AuthorizationFilterAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public abstract class AuthorizationFilterAttribute : FilterAttribute, IAuthorizationFilter
    {
        public virtual void OnAuthorization(HttpActionContext actionContext)
        {
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "exception is flowed through the task")]
        public virtual Task OnAuthorizationAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            try
            {
                OnAuthorization(actionContext);
            }
            catch (Exception ex)
            {
                return TaskHelpers.FromError(ex);
            }

            return TaskHelpers.Completed();
        }

        Task<HttpResponseMessage> IAuthorizationFilter.ExecuteAuthorizationFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }
            if (continuation == null)
            {
                throw Error.ArgumentNull("continuation");
            }

            return ExecuteAuthorizationFilterAsyncCore(actionContext, cancellationToken, continuation);
        }

        private async Task<HttpResponseMessage> ExecuteAuthorizationFilterAsyncCore(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
        {
            await OnAuthorizationAsync(actionContext, cancellationToken);

            if (actionContext.Response != null)
            {
                return actionContext.Response;
            }
            else
            {
                return await continuation();
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/ConfigurationFilterProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    public class ConfigurationFilterProvider : IFilterProvider
    {
        public IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            return configuration.Filters;
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/ExceptionFilterAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Filters
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public abstract class ExceptionFilterAttribute : FilterAttribute, IExceptionFilter
    {
        public virtual void OnException(HttpActionExecutedContext actionExecutedContext)
        {
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is flowed in the task")]
        public virtual Task OnExceptionAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
        {
            try
            {
                OnException(actionExecutedContext);
            }
            catch (Exception ex)
            {
                return TaskHelpers.FromError(ex);
            }

            return TaskHelpers.Completed();
        }

        Task IExceptionFilter.ExecuteExceptionFilterAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
        {
            if (actionExecutedContext == null)
            {
                throw Error.ArgumentNull("actionExecutedContext");
            }

            return ExecuteExceptionFilterAsyncCore(actionExecutedContext, cancellationToken);
        }

        private async Task ExecuteExceptionFilterAsyncCore(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
        {
            await OnExceptionAsync(actionExecutedContext, cancellationToken);
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/FilterAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http.Internal;

namespace System.Web.Http.Filters
{
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "We want to allow inheritance")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public abstract class FilterAttribute : Attribute, IFilter
    {
        private static readonly ConcurrentDictionary<Type, bool> _attributeUsageCache = new ConcurrentDictionary<Type, bool>();

        public virtual bool AllowMultiple
        {
            get { return AllowsMultiple(GetType()); }
        }

        private static bool AllowsMultiple(Type attributeType)
        {
            return _attributeUsageCache.GetOrAdd(
                attributeType,
                type => type.GetCustomAttributes<AttributeUsageAttribute>(inherit: true).First().AllowMultiple);
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/FilterInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Filters
{
    public sealed class FilterInfo
    {
        public FilterInfo(IFilter instance, FilterScope scope)
        {
            if (instance == null)
            {
                throw Error.ArgumentNull("instance");
            }

            Instance = instance;
            Scope = scope;
        }

        public IFilter Instance { get; private set; }

        public FilterScope Scope { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/Filters/FilterInfoComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Filters
{
    internal sealed class FilterInfoComparer : IComparer<FilterInfo>
    {
        private static readonly FilterInfoComparer _instance = new FilterInfoComparer();

        public static FilterInfoComparer Instance
        {
            get { return _instance; }
        }

        public int Compare(FilterInfo x, FilterInfo y)
        {
            if (x == null && y == null)
            {
                return 0;
            }
            else if (x == null)
            {
                return -1;
            }
            else if (y == null)
            {
                return 1;
            }
            else
            {
                var r = x.Scope - y.Scope;
                return r;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/FilterScope.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Filters
{
    public enum FilterScope
    {
        Global = 0,
        Controller = 10,
        Action = 20,
    }
}


================================================
FILE: src/System.Web.Http/Filters/HttpActionExecutedContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    public class HttpActionExecutedContext
    {
        private HttpActionContext _actionContext;

        public HttpActionExecutedContext(HttpActionContext actionContext, Exception exception)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            Exception = exception;
            _actionContext = actionContext;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpActionExecutedContext"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public HttpActionExecutedContext()
        {
        }

        public HttpActionContext ActionContext
        {
            get { return _actionContext; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _actionContext = value;
            }
        }

        public Exception Exception { get; set; }

        public HttpResponseMessage Response
        {
            get
            {
                return ActionContext != null ? ActionContext.Response : null;
            }

            set
            {
                ActionContext.Response = value;
            }
        }

        /// <summary>
        /// Gets the current <see cref="HttpRequestMessage"/>.
        /// </summary>
        public HttpRequestMessage Request
        {
            get
            {
                return (ActionContext != null && ActionContext.ControllerContext != null)
                           ? ActionContext.ControllerContext.Request
                           : null;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/HttpAuthenticationChallengeContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    /// <summary>
    /// Represents an authentication challenge context containing information for executing an authentication
    /// challenge.
    /// </summary>
    public class HttpAuthenticationChallengeContext
    {
        private IHttpActionResult _result;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpAuthenticationChallengeContext"/> class.
        /// </summary>
        /// <param name="actionContext">The action context.</param>
        /// <param name="result">The current action result.</param>
        public HttpAuthenticationChallengeContext(HttpActionContext actionContext, IHttpActionResult result)
        {
            if (actionContext == null)
            {
                throw new ArgumentNullException("actionContext");
            }

            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            ActionContext = actionContext;
            Result = result;
        }

        /// <summary>Gets the action context.</summary>
        public HttpActionContext ActionContext { get; private set; }

        /// <summary>Gets or sets the action result to execute.</summary>
        /// <remarks>
        /// Authentication filters wishing to add an authentication challenge will often chain the result (set the
        /// value to an action result that executes the previous value and then does something additional, such as add
        /// a WWW-Authenticate header).
        /// </remarks>
        public IHttpActionResult Result
        {
            get
            {
                return _result;
            }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }

                _result = value;
            }
        }

        /// <summary>Gets the request message.</summary>
        public HttpRequestMessage Request
        {
            get
            {
                Contract.Assert(ActionContext != null);
                return ActionContext.Request;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/HttpAuthenticationContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Security.Principal;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    /// <summary>Represents an authentication context containing information for performing authentication.</summary>
    public class HttpAuthenticationContext
    {
        /// <summary>Initializes a new instance of the <see cref="HttpAuthenticationContext"/> class.</summary>
        /// <param name="actionContext">The action context.</param>
        /// <param name="principal">The current principal.</param>
        public HttpAuthenticationContext(HttpActionContext actionContext, IPrincipal principal)
        {
            if (actionContext == null)
            {
                throw new ArgumentNullException("actionContext");
            }

            ActionContext = actionContext;
            Principal = principal;
        }

        /// <summary>Gets the action context.</summary>
        public HttpActionContext ActionContext { get; private set; }

        /// <summary>Gets or sets the authenticated principal.</summary>
        public IPrincipal Principal { get; set; }

        /// <summary>
        /// Gets or sets an action result that will produce an error response (if authentication failed; otherwise,
        /// <see langword="null"/>).
        /// </summary>
        public IHttpActionResult ErrorResult { get; set; }

        /// <summary>Gets the request message.</summary>
        public HttpRequestMessage Request
        {
            get
            {
                Contract.Assert(ActionContext != null);
                return ActionContext.Request;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/HttpFilterCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Web.Http.Properties;

namespace System.Web.Http.Filters
{
    public class HttpFilterCollection : IEnumerable<FilterInfo>
    {
        private readonly List<FilterInfo> _filters = new List<FilterInfo>();

        public int Count
        {
            get { return _filters.Count; }
        }

        public void Add(IFilter filter)
        {
            if (filter == null)
            {
                throw Error.ArgumentNull("filter");
            }

            _filters.Add(CreateFilterInfo(filter));
        }

        /// <summary>
        /// Adds the elements of the specified collection to the end of the filter collection.
        /// </summary>
        /// <param name="filters">The collection of filters to add.</param>
        public void AddRange(IEnumerable<IFilter> filters)
        {
            if (filters == null)
            {
                throw Error.ArgumentNull("filters");
            }

            // ToArray used here to avoid iterating the filter collection twice.
            IFilter[] cachedFilters = filters.ToArray();
            for (int i = 0; i < cachedFilters.Length; i++)
            {
                if (cachedFilters[i] == null)
                {
                    throw new ArgumentException(
                        String.Format(CultureInfo.CurrentCulture, SRResources.CollectionParameterContainsNullElement, "filters"),
                        "filters");
                }
            }

            for (int i = 0; i < cachedFilters.Length; i++)
            {
                _filters.Add(CreateFilterInfo(cachedFilters[i]));
            }
        }

        private static FilterInfo CreateFilterInfo(IFilter filter)
        {
            Contract.Assert(filter != null);
            return new FilterInfo(filter, FilterScope.Global);
        }

        public void Clear()
        {
            _filters.Clear();
        }

        public bool Contains(IFilter filter)
        {
            return _filters.Any(f => f.Instance == filter);
        }

        public IEnumerator<FilterInfo> GetEnumerator()
        {
            return _filters.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public void Remove(IFilter filter)
        {
            _filters.RemoveAll(f => f.Instance == filter);
        }
    }
}


================================================
FILE: src/System.Web.Http/Filters/IActionFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    public interface IActionFilter : IFilter
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Represents a continuation call")]
        Task<HttpResponseMessage> ExecuteActionFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation);
    }
}


================================================
FILE: src/System.Web.Http/Filters/IAuthenticationFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Filters
{
    /// <summary>Defines a filter that performs authentication.</summary>
    public interface IAuthenticationFilter : IFilter
    {
        /// <summary>Authenticates the request.</summary>
        /// <param name="context">The authentication context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task"/> that will perform authentication.</returns>
        Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken);

        /// <summary>Adds an authentication challenge to the inner <see cref="IHttpActionResult"/>.</summary>
        /// <param name="context">The authentication challenge context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task"/> that will perform the authentication challenge.</returns>
        Task ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken);
    }
}


================================================
FILE: src/System.Web.Http/Filters/IAuthorizationFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    public interface IAuthorizationFilter : IFilter
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Represents a continuation call")]
        Task<HttpResponseMessage> ExecuteAuthorizationFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation);
    }
}


================================================
FILE: src/System.Web.Http/Filters/IExceptionFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Filters
{
    public interface IExceptionFilter : IFilter
    {
        Task ExecuteExceptionFilterAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken);
    }
}


================================================
FILE: src/System.Web.Http/Filters/IFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Filters
{
    public interface IFilter
    {
        bool AllowMultiple { get; }
    }
}


================================================
FILE: src/System.Web.Http/Filters/IFilterProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;

namespace System.Web.Http.Filters
{
    public interface IFilterProvider
    {
        IEnumerable<FilterInfo> GetFilters(HttpConfiguration configuration, HttpActionDescriptor actionDescriptor);
    }
}


================================================
FILE: src/System.Web.Http/Filters/IOverrideFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Filters
{
    /// <summary>Defines a filter that overrides other filters.</summary>
    public interface IOverrideFilter : IFilter
    {
        /// <summary>Gets the type of filters to override.</summary>
        /// <remarks>
        /// The following types of filters may be overridden:
        /// <list type="bullet">
        /// <item><description><see cref="IActionFilter"/></description></item>
        /// <item><description><see cref="IAuthenticationFilter"/></description></item>
        /// <item><description><see cref="IAuthorizationFilter"/></description></item>
        /// <item><description><see cref="IExceptionFilter"/></description></item>
        /// </list>
        /// </remarks>
        Type FiltersToOverride { get; }
    }
}


================================================
FILE: src/System.Web.Http/FromBodyAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Validation;

namespace System.Web.Http
{
    /// <summary>
    /// This attribute is used on action parameters to indicate
    /// they come only from the content body of the incoming <see cref="HttpRequestMessage"/>.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
    public sealed class FromBodyAttribute : ParameterBindingAttribute
    {
        public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter)
        {
            if (parameter == null)
            {
                throw Error.ArgumentNull("parameter");
            }

            IEnumerable<MediaTypeFormatter> formatters = parameter.Configuration.Formatters;
            IBodyModelValidator validator = parameter.Configuration.Services.GetBodyModelValidator();

            return parameter.BindWithFormatter(formatters, validator);
        }
    }
}


================================================
FILE: src/System.Web.Http/FromUriAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.ModelBinding;
using System.Web.Http.ValueProviders;

namespace System.Web.Http
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
    public sealed class FromUriAttribute : ModelBinderAttribute
    {
        public override IEnumerable<ValueProviderFactory> GetValueProviderFactories(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            foreach (ValueProviderFactory f in base.GetValueProviderFactories(configuration))
            {
                if (f is IUriValueProviderFactory)
                {
                    yield return f;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames",
    Justification = "The assembly is delay signed")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Net.Http",
    Justification = "Functionality logically belongs in a namespace defined in a different binary")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Net.Http.Formatting", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Web.Http.Batch", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Web.Http.Dependencies", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Web.Http.Hosting", Justification = "Removing this namespace now would be a breaking change.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Web.Http.Metadata")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Web.Http.Services")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace",
    Target = "System.Web.Http.Validation.Validators", Justification = "Namespace follows folder structure")]
[assembly: SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope = "member",
    Target = "System.Web.Http.Filters.ActionFilterAttribute.#System.Web.Http.Filters.IActionFilter.ExecuteActionFilterAsync(System.Web.Http.Controllers.HttpActionContext,System.Threading.CancellationToken,System.Func`1<System.Threading.Tasks.Task`1<System.Net.Http.HttpResponseMessage>>)")]
[assembly: SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope = "member",
    Target = "System.Web.Http.Filters.AuthorizationFilterAttribute.#System.Web.Http.Filters.IAuthorizationFilter.ExecuteAuthorizationFilterAsync(System.Web.Http.Controllers.HttpActionContext,System.Threading.CancellationToken,System.Func`1<System.Threading.Tasks.Task`1<System.Net.Http.HttpResponseMessage>>)")]
[assembly: SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope = "member",
    Target = "System.Web.Http.Filters.ExceptionFilterAttribute.#System.Web.Http.Filters.IExceptionFilter.ExecuteExceptionFilterAsync(System.Web.Http.Filters.HttpActionExecutedContext,System.Threading.CancellationToken)")]


================================================
FILE: src/System.Web.Http/Hosting/HttpPropertyKeys.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;

namespace System.Web.Http.Hosting
{
    /// <summary>
    /// Provides common keys for properties stored in the <see cref="HttpRequestMessage.Properties"/>
    /// </summary>
    public static class HttpPropertyKeys
    {
        /// <summary>
        /// Provides a key for the <see cref="HttpConfiguration"/> associated with this request.
        /// </summary>
        public static readonly string HttpConfigurationKey = "MS_HttpConfiguration";

        /// <summary>
        /// Provides a key for the <see cref="IHttpRouteData"/> associated with this request.
        /// </summary>
        public static readonly string HttpRouteDataKey = "MS_HttpRouteData";

        /// <summary>
        /// Provides a key for the <see cref="System.Web.Http.Controllers.HttpActionDescriptor"/> associated with this request.
        /// </summary>
        public static readonly string HttpActionDescriptorKey = "MS_HttpActionDescriptor";

        /// <summary>
        /// Provides a key for the current <see cref="SynchronizationContext"/> stored in <see cref="HttpRequestMessage.Properties"/>.
        /// If <see cref="SynchronizationContext.Current"/> is <c>null</c> then no context is stored.
        /// </summary>
        public static readonly string SynchronizationContextKey = "MS_SynchronizationContext";

        /// <summary>
        /// Provides a key for the collection of resources that should be disposed when a request is disposed.
        /// </summary>
        public static readonly string DisposableRequestResourcesKey = "MS_DisposableRequestResources";

        /// <summary>
        /// Provides a key for the dependency scope for this request.
        /// </summary>
        public static readonly string DependencyScope = "MS_DependencyScope";

        /// <summary>
        /// Provides a key for the client certificate for this request.
        /// </summary>
        public static readonly string ClientCertificateKey = "MS_ClientCertificate";

        /// <summary>
        /// Provides a key for a delegate which can retrieve the client certificate for this request.
        /// </summary>
        public static readonly string RetrieveClientCertificateDelegateKey = "MS_RetrieveClientCertificateDelegate";

        /// <summary>
        /// Provides a key for the <see cref="HttpRequestContext"/> for this request.
        /// </summary>
        public static readonly string RequestContextKey = "MS_RequestContext";

        /// <summary>
        /// Provides a key for the <see cref="Guid"/> stored in <see cref="HttpRequestMessage.Properties"/>.
        /// This is the correlation id for that request.
        /// </summary>
        public static readonly string RequestCorrelationKey = "MS_RequestId";

        /// <summary>
        /// Provides a key that indicates whether the request originates from a local address.
        /// </summary>
        public static readonly string IsLocalKey = "MS_IsLocal";

        /// <summary>
        /// Provides a key that indicates whether the request failed to match a route.
        /// </summary>
        public static readonly string NoRouteMatched = "MS_NoRouteMatched";

        /// <summary>
        /// Provides a key that indicates whether error details are to be included in the response for this HTTP request.
        /// </summary>
        public static readonly string IncludeErrorDetailKey = "MS_IncludeErrorDetail";

        /// <summary>
        /// Provides a key for the parsed query string stored in <see cref="HttpRequestMessage.Properties"/>.
        /// </summary>
        public static readonly string RequestQueryNameValuePairsKey = "MS_QueryNameValuePairs";

        /// <summary>
        /// Provides the original query string for the parsed query string stored in <see cref="HttpRequestMessage.Properties"/>
        /// under the key <see cref="HttpPropertyKeys.RequestQueryNameValuePairsKey" />.
        /// </summary>
        public static readonly string CachedRequestQueryKey = "MS_CachedRequestQuery";

        /// <summary>
        /// Provides a key that indicates whether the request is a batch request.
        /// </summary>
        public static readonly string IsBatchRequest = "MS_BatchRequest";
    }
}

================================================
FILE: src/System.Web.Http/Hosting/IHostBufferPolicySelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;

namespace System.Web.Http.Hosting
{
    /// <summary>
    /// Interface for controlling the use of buffering requests and responses in the host. If a host
    /// provides support for buffering requests and/or responses then it can use this interface to 
    /// determine the policy for when buffering is to be used.
    /// </summary>
    public interface IHostBufferPolicySelector
    {
        /// <summary>
        /// Determines whether the host should buffer the entity body when processing a request with content.
        /// </summary>
        /// <param name="hostContext">The host-specific context.</param>
        /// <returns><c>true</c> if buffering should be used; otherwise a streamed request should be used.</returns>
        bool UseBufferedInputStream(object hostContext);

        /// <summary>
        /// Determines whether the host should buffer the <see cref="HttpResponseMessage"/> entity body.
        /// </summary>
        /// <param name="response">The <see cref="HttpResponseMessage"/>response for which to determine
        /// whether host output buffering should be used for the response entity body.</param>
        /// <returns><c>true</c> if buffering should be used; otherwise a streamed response should be used.</returns>
        bool UseBufferedOutputStream(HttpResponseMessage response);
    }
}


================================================
FILE: src/System.Web.Http/Hosting/SuppressHostPrincipalMessageHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Security.Claims;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Properties;

namespace System.Web.Http.Hosting
{
    /// <summary>Represents a message handler that suppresses host authentication results.</summary>
    /// <remarks>
    /// This message handler sets the current principal to anonymous upon entry. As a result, any authentication
    /// performed by the host is ignored. The subsequent pipeline, including <see cref="IAuthenticationFilter"/>s, is
    /// then the exclusive authority for authentication.
    /// </remarks>
    public class SuppressHostPrincipalMessageHandler : DelegatingHandler
    {
        private static readonly Lazy<IPrincipal> _anonymousPrincipal = new Lazy<IPrincipal>(
            () => new ClaimsPrincipal(new ClaimsIdentity()), isThreadSafe: true);

        /// <inheritdoc />
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            var previousPrincipal = SetCurrentPrincipal(request, _anonymousPrincipal.Value);
            try
            {
                return await base.SendAsync(request, cancellationToken);
            }
            finally
            {
                SetCurrentPrincipal(request, previousPrincipal);
            }
        }

        private static IPrincipal SetCurrentPrincipal(HttpRequestMessage request, IPrincipal principal)
        {
            Contract.Assert(request != null);

            HttpRequestContext requestContext = request.GetRequestContext();
            if (requestContext == null)
            {
                throw new ArgumentException(SRResources.Request_RequestContextMustNotBeNull, "request");
            }

            var previousPrincipal = requestContext.Principal;
            requestContext.Principal = principal;

            return previousPrincipal;
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpBindNeverAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.ModelBinding;

namespace System.Web.Http
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class HttpBindNeverAttribute : HttpBindingBehaviorAttribute
    {
        public HttpBindNeverAttribute()
            : base(HttpBindingBehavior.Never)
        {
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpBindRequiredAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.ModelBinding;

namespace System.Web.Http
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class HttpBindRequiredAttribute : HttpBindingBehaviorAttribute
    {
        public HttpBindRequiredAttribute()
            : base(HttpBindingBehavior.Required)
        {
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.Filters;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Services;
using System.Web.Http.Tracing;
using System.Web.Http.Validation;

namespace System.Web.Http
{
    /// <summary>
    /// Configuration of <see cref="HttpServer"/> instances.
    /// </summary>
    public class HttpConfiguration : IDisposable
    {
        private readonly HttpRouteCollection _routes;
        private readonly ConcurrentDictionary<object, object> _properties = new ConcurrentDictionary<object, object>();
        private readonly MediaTypeFormatterCollection _formatters;
        private readonly Collection<DelegatingHandler> _messageHandlers = new Collection<DelegatingHandler>();
        private readonly HttpFilterCollection _filters = new HttpFilterCollection();

        private IDependencyResolver _dependencyResolver = EmptyResolver.Instance;
        private Action<HttpConfiguration> _initializer = DefaultInitializer;
        private bool _initialized;

        private bool _disposed;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpConfiguration"/> class.
        /// </summary>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "The route collection is disposed as part of this class.")]
        public HttpConfiguration()
            : this(new HttpRouteCollection(String.Empty))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpConfiguration"/> class.
        /// </summary>
        /// <param name="routes">The <see cref="HttpRouteCollection"/> to associate with this instance.</param>
        public HttpConfiguration(HttpRouteCollection routes)
        {
            if (routes == null)
            {
                throw Error.ArgumentNull("routes");
            }

            _routes = routes;
            _formatters = DefaultFormatters(this);

            Services = new DefaultServices(this);
            ParameterBindingRules = DefaultActionValueBinder.GetDefaultParameterBinders();
        }

        private HttpConfiguration(HttpConfiguration configuration, HttpControllerSettings settings)
        {
            _routes = configuration.Routes;
            _filters = configuration.Filters;
            _messageHandlers = configuration.MessageHandlers;
            _properties = configuration.Properties;
            _dependencyResolver = configuration.DependencyResolver;
            IncludeErrorDetailPolicy = configuration.IncludeErrorDetailPolicy;

            // per-controller settings
            Services = settings.IsServiceCollectionInitialized ? settings.Services : configuration.Services;
            _formatters = settings.IsFormatterCollectionInitialized ? settings.Formatters : configuration.Formatters;
            ParameterBindingRules = settings.IsParameterBindingRuleCollectionInitialized ? settings.ParameterBindingRules : configuration.ParameterBindingRules;

            // Use the original configuration's initializer so that its Initialize()
            // will perform the same logic on this clone as on the original.
            Initializer = configuration.Initializer;

            // create a new validator cache if the validator providers have changed
            if (settings.IsServiceCollectionInitialized &&
                !settings.Services.GetModelValidatorProviders().SequenceEqual(configuration.Services.GetModelValidatorProviders()))
            {
                ModelValidatorCache validatorCache = new ModelValidatorCache(new Lazy<IEnumerable<ModelValidatorProvider>>(() => Services.GetModelValidatorProviders()));
                settings.Services.Replace(typeof(IModelValidatorCache), validatorCache);
            }
        }

        /// <summary>
        /// Gets or sets the action that will perform final initialization
        /// of the <see cref="HttpConfiguration"/> instance before it is used
        /// to process requests.
        /// </summary>
        /// <remarks>The Action returned by this property will be called to perform
        /// final initialization of an <see cref="HttpConfiguration"/> before it is
        /// used to process a request.
        /// <para>
        /// The <see cref="HttpConfiguration"/> passed to this action should be
        /// considered immutable after the action returns.
        /// </para>
        /// </remarks>
        public Action<HttpConfiguration> Initializer
        {
            get
            {
                return _initializer;
            }
            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }

                _initializer = value;
            }
        }

        /// <summary>
        /// Gets the list of filters that apply to all requests served using this HttpConfiguration instance.
        /// </summary>
        public HttpFilterCollection Filters
        {
            get { return _filters; }
        }

        /// <summary>
        /// Gets an ordered list of <see cref="DelegatingHandler"/> instances to be invoked as an
        /// <see cref="HttpRequestMessage"/> travels up the stack and an <see cref="HttpResponseMessage"/> travels down in
        /// stack in return. The handlers are invoked in a top-down fashion in the incoming path and bottom-up in the outgoing 
        /// path. That is, the first entry is invoked first for an incoming request message but last for an outgoing 
        /// response message.
        /// </summary>
        /// <value>
        /// The message handler collection.
        /// </value>
        public Collection<DelegatingHandler> MessageHandlers
        {
            get { return _messageHandlers; }
        }

        /// <summary>
        /// Gets the <see cref="HttpRouteCollection"/> associated with this <see cref="HttpServer"/> instance.
        /// </summary>
        /// <value>
        /// The <see cref="HttpRouteCollection"/>.
        /// </value>
        public HttpRouteCollection Routes
        {
            get { return _routes; }
        }

        /// <summary>
        /// Gets the properties associated with this instance.
        /// </summary>
        public ConcurrentDictionary<object, object> Properties
        {
            get { return _properties; }
        }

        /// <summary>
        /// Gets the root virtual path. The <see cref="VirtualPathRoot"/> property always returns 
        /// "/" as the first character of the returned value.
        /// </summary>
        public string VirtualPathRoot
        {
            get { return _routes.VirtualPathRoot; }
        }

        /// <summary>
        /// Gets or sets the dependency resolver associated with this <see cref="HttpConfiguration"/>.
        /// </summary>
        public IDependencyResolver DependencyResolver
        {
            get { return _dependencyResolver; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _dependencyResolver = value;
            }
        }

        /// <summary>
        /// Gets the container of default services associated with this <see cref="HttpConfiguration"/>.
        /// Only supports the list of service types documented on <see cref="DefaultServices"/>. For general
        /// purpose types, please use <see cref="DependencyResolver"/>.
        /// </summary>
        public ServicesContainer Services { get; internal set; }

        /// <summary>
        /// Top level hook for how parameters should be bound. 
        /// This should be respected by the IActionValueBinder. If a parameter is not claimed by the list, the IActionValueBinder still binds it. 
        /// </summary>
        public ParameterBindingRulesCollection ParameterBindingRules { get; internal set; }

        /// <summary>
        /// Gets or sets a value indicating whether error details should be included in error messages.
        /// </summary>
        public IncludeErrorDetailPolicy IncludeErrorDetailPolicy { get; set; }

        /// <summary>
        /// Gets the media type formatters.
        /// </summary>
        public MediaTypeFormatterCollection Formatters
        {
            get { return _formatters; }
        }

        private static MediaTypeFormatterCollection DefaultFormatters(HttpConfiguration config)
        {
            var formatters = new MediaTypeFormatterCollection();

            // Basic FormUrlFormatter does not support binding to a T. 
            // Use our JQuery formatter instead.
            formatters.Add(new JQueryMvcFormUrlEncodedFormatter(config));

            return formatters;
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller owns the disposable object")]
        internal static HttpConfiguration ApplyControllerSettings(HttpControllerSettings settings, HttpConfiguration configuration)
        {
            if (!settings.IsFormatterCollectionInitialized && !settings.IsParameterBindingRuleCollectionInitialized && !settings.IsServiceCollectionInitialized)
            {
                return configuration;
            }

            // Create a clone of the original configuration, including its initialization rules.
            // Invoking Initialize therefore initializes the cloned config the same way as the original.
            HttpConfiguration newConfiguration = new HttpConfiguration(configuration, settings);
            newConfiguration.Initializer(newConfiguration);
            return newConfiguration;
        }

        private static void DefaultInitializer(HttpConfiguration configuration)
        {
            // Register the default IRequiredMemberSelector for formatters that haven't been assigned one
            ModelMetadataProvider metadataProvider = configuration.Services.GetModelMetadataProvider();
            IEnumerable<ModelValidatorProvider> validatorProviders = configuration.Services.GetModelValidatorProviders();
            IRequiredMemberSelector defaultRequiredMemberSelector = new ModelValidationRequiredMemberSelector(metadataProvider, validatorProviders);

            foreach (MediaTypeFormatter formatter in configuration.Formatters)
            {
                if (formatter.RequiredMemberSelector == null)
                {
                    formatter.RequiredMemberSelector = defaultRequiredMemberSelector;
                }
            }

            // Initialize the tracing layer.
            // This must be the last initialization code to execute
            // because it alters the configuration and expects no
            // further changes.  As a default service, we know it
            // must be present.
            ITraceManager traceManager = configuration.Services.GetTraceManager();
            Contract.Assert(traceManager != null);
            traceManager.Initialize(configuration);
        }

        /// <summary>
        /// Invoke the Intializer hook. It is considered immutable from this point forward.
        /// It's safe to call this multiple times. 
        /// </summary>
        public void EnsureInitialized()
        { 
            if (_initialized)
            {
                return;
            }
            _initialized = true;
            Initializer(this);            
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                _disposed = true;

                if (disposing)
                {
                    _routes.Dispose();
                    DependencyResolver.Dispose();
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpConfigurationExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Hosting;
using System.Web.Http.ModelBinding;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Routing;

namespace System.Web.Http
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpConfigurationExtensions
    {
        /// <summary>
        /// Register that the given parameter type on an Action is to be bound using the model binder.
        /// </summary>
        /// <param name="configuration">configuration to be updated.</param>
        /// <param name="type">parameter type that binder is applied to</param>
        /// <param name="binder">a model binder</param>
        public static void BindParameter(this HttpConfiguration configuration, Type type, IModelBinder binder)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (binder == null)
            {
                throw Error.ArgumentNull("binder");
            }

            // Add a provider so that we can use this type recursively
            // Be sure to insert at position 0 to preempt any eager binders (eg, MutableObjectBinder) that 
            // may eagerly claim all types.
            configuration.Services.Insert(typeof(ModelBinderProvider), 0, new SimpleModelBinderProvider(type, binder));

            // Add the binder to the list of rules. 
            // This ensures that the parameter binding will actually use model binding instead of Formatters.            
            // Without this, the parameter binding system may see the parameter type is complex and choose
            // to use formatters instead, in which case it would ignore the registered model binders. 
            configuration.ParameterBindingRules.Insert(0, type, param => param.BindWithModelBinding(binder));
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        // Corresponds to the MVC implementation of attribute routing in
        // System.Web.Mvc.RouteCollectionAttributeRoutingExtensions.
        public static void MapHttpAttributeRoutes(this HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            AttributeRoutingMapper.MapAttributeRoutes(configuration, new DefaultInlineConstraintResolver(), new DefaultDirectRouteProvider());
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints.
        /// </param>
        // Corresponds to the MVC implementation of attribute routing in
        // System.Web.Mvc.RouteCollectionAttributeRoutingExtensions.
        public static void MapHttpAttributeRoutes(this HttpConfiguration configuration,
            IInlineConstraintResolver constraintResolver)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            AttributeRoutingMapper.MapAttributeRoutes(configuration, constraintResolver, new DefaultDirectRouteProvider());
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="directRouteProvider">
        /// The <see cref="IDirectRouteProvider"/> to use for discovering and building routes.
        /// </param>
        // Corresponds to the MVC implementation of attribute routing in
        // System.Web.Mvc.RouteCollectionAttributeRoutingExtensions.
        public static void MapHttpAttributeRoutes(
            this HttpConfiguration configuration,
            IDirectRouteProvider directRouteProvider)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            if (directRouteProvider == null)
            {
                throw new ArgumentNullException("directRouteProvider");
            }

            AttributeRoutingMapper.MapAttributeRoutes(configuration, new DefaultInlineConstraintResolver(), directRouteProvider);
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="configuration">The server configuration.</param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints.
        /// </param>
        /// <param name="directRouteProvider">
        /// The <see cref="IDirectRouteProvider"/> to use for discovering and building routes.
        /// </param>
        // Corresponds to the MVC implementation of attribute routing in
        // System.Web.Mvc.RouteCollectionAttributeRoutingExtensions.
        public static void MapHttpAttributeRoutes(
            this HttpConfiguration configuration,
            IInlineConstraintResolver constraintResolver,
            IDirectRouteProvider directRouteProvider)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            if (directRouteProvider == null)
            {
                throw new ArgumentNullException("directRouteProvider");
            }

            AttributeRoutingMapper.MapAttributeRoutes(configuration, constraintResolver, directRouteProvider);
        }

        // Test Hook for inspecting the route table generated by MapHttpAttributeRoutes. 
        // MapHttpAttributeRoutes doesn't return the route collection because it's an implementation detail
        // that attr routes even generate a meaningful route collection. 
        // Public APIs can get similar functionality by querying the IHttpRoute for IReadOnlyCollection<IHttpRoute>.
        internal static IReadOnlyCollection<IHttpRoute> GetAttributeRoutes(this HttpConfiguration configuration)
        {
            configuration.EnsureInitialized();

            HttpRouteCollection routes = configuration.Routes;
            foreach (IHttpRoute route in routes)
            {
                var attrRoute = route as IReadOnlyCollection<IHttpRoute>;
                if (attrRoute != null)
                {
                    return attrRoute;
                }
            }
            return null;
        }

        /// <summary>Enables suppression of the host's principal.</summary>
        /// <param name="configuration">The server configuration.</param>
        /// <remarks>
        /// When the host's principal is suppressed, the current principal is set to anonymous upon entering the
        /// <see cref="HttpServer"/>'s first message handler. As a result, any authentication performed by the host is
        /// ignored. The remaining pipeline within the <see cref="HttpServer"/>, including
        /// <see cref="IAuthenticationFilter"/>s, is then the exclusive authority for authentication.
        /// </remarks>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "Message handler should be disposed with parent configuration.")]
        public static void SuppressHostPrincipal(this HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            Contract.Assert(configuration.MessageHandlers != null);
            configuration.MessageHandlers.Insert(0, new SuppressHostPrincipalMessageHandler());
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpDeleteAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies that an action supports the DELETE HTTP method.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpDeleteAttribute : Attribute, IActionHttpMethodProvider
    {
        private static readonly Collection<HttpMethod> _supportedMethods = new Collection<HttpMethod>(new HttpMethod[] { HttpMethod.Delete });

        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _supportedMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpError.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

namespace System.Web.Http
{
    /// <summary>
    /// Defines a serializable container for storing error information. This information is stored 
    /// as key/value pairs. The dictionary keys to look up standard error information are available 
    /// on the <see cref="HttpErrorKeys"/> type.
    /// </summary>
    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "This type is only a dictionary to get the right serialization format")]
    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable", Justification = "DCS does not support IXmlSerializable types that are also marked as [Serializable]")]
    [XmlRoot("Error")]
    public sealed class HttpError : Dictionary<string, object>, IXmlSerializable
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpError"/> class.
        /// </summary>
        public HttpError()
            : base(StringComparer.OrdinalIgnoreCase)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpError"/> class containing error message <paramref name="message"/>.
        /// </summary>
        /// <param name="message">The error message to associate with this instance.</param>
        public HttpError(string message)
            : this()
        {
            if (message == null)
            {
                throw Error.ArgumentNull("message");
            }

            Message = message;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpError"/> class for <paramref name="exception"/>.
        /// </summary>
        /// <param name="exception">The exception to use for error information.</param>
        /// <param name="includeErrorDetail"><c>true</c> to include the exception information in the error; <c>false</c> otherwise</param>
        public HttpError(Exception exception, bool includeErrorDetail)
            : this()
        {
            if (exception == null)
            {
                throw Error.ArgumentNull("exception");
            }

            Message = SRResources.ErrorOccurred;

            if (includeErrorDetail)
            {
                Add(HttpErrorKeys.ExceptionMessageKey, exception.Message);
                Add(HttpErrorKeys.ExceptionTypeKey, exception.GetType().FullName);
                Add(HttpErrorKeys.StackTraceKey, exception.StackTrace);
                if (exception.InnerException != null)
                {
                    Add(HttpErrorKeys.InnerExceptionKey, new HttpError(exception.InnerException, includeErrorDetail));
                }
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpError"/> class for <paramref name="modelState"/>.
        /// </summary>
        /// <param name="modelState">The invalid model state to use for error information.</param>
        /// <param name="includeErrorDetail"><c>true</c> to include exception messages in the error; <c>false</c> otherwise</param>
        public HttpError(ModelStateDictionary modelState, bool includeErrorDetail)
            : this()
        {
            if (modelState == null)
            {
                throw Error.ArgumentNull("modelState");
            }

            if (modelState.IsValid)
            {
                throw Error.Argument("modelState", SRResources.ValidModelState);
            }

            Message = SRResources.BadRequest;

            HttpError modelStateError = new HttpError();
            foreach (KeyValuePair<string, ModelState> keyModelStatePair in modelState)
            {
                string key = keyModelStatePair.Key;
                ModelErrorCollection errors = keyModelStatePair.Value.Errors;
                if (errors != null && errors.Count > 0)
                {
                    IEnumerable<string> errorMessages = errors.Select(error =>
                    {
                        if (includeErrorDetail && error.Exception != null)
                        {
                            return error.Exception.Message;
                        }
                        else
                        {
                            return String.IsNullOrEmpty(error.ErrorMessage) ? SRResources.ErrorOccurred : error.ErrorMessage;
                        }
                    }).ToArray();
                    modelStateError.Add(key, errorMessages);
                }
            }

            Add(HttpErrorKeys.ModelStateKey, modelStateError);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpError"/> class containing error message <paramref name="message"/> 
        /// and error message detail <paramref name="messageDetail"/>.
        /// </summary>
        /// <param name="message">The error message to associate with this instance.</param>
        /// <param name="messageDetail">The error message detail to associate with this instance.</param>
        internal HttpError(string message, string messageDetail)
            : this(message)
        {
            if (messageDetail == null)
            {
                throw Error.ArgumentNull("message");
            }

            Add(HttpErrorKeys.MessageDetailKey, messageDetail);
        }

        /// <summary>
        /// The high-level, user-visible message explaining the cause of the error. Information carried in this field 
        /// should be considered public in that it will go over the wire regardless of the <see cref="IncludeErrorDetailPolicy"/>. 
        /// As a result care should be taken not to disclose sensitive information about the server or the application.
        /// </summary>
        public string Message
        {
            get { return GetPropertyValue<String>(HttpErrorKeys.MessageKey); }
            set { this[HttpErrorKeys.MessageKey] = value; }
        }

        /// <summary>
        /// The <see cref="ModelState"/> containing information about the errors that occurred during model binding.
        /// </summary>
        /// <remarks>
        /// The inclusion of <see cref="System.Exception"/> information carried in the <see cref="ModelState"/> is
        /// controlled by the <see cref="IncludeErrorDetailPolicy"/>. All other information in the <see cref="ModelState"/>
        /// should be considered public in that it will go over the wire. As a result care should be taken not to 
        /// disclose sensitive information about the server or the application.
        /// </remarks>
        public HttpError ModelState
        {
            get { return GetPropertyValue<HttpError>(HttpErrorKeys.ModelStateKey); }
        }

        /// <summary>
        /// A detailed description of the error intended for the developer to understand exactly what failed.
        /// </summary>
        /// <remarks>
        /// The inclusion of this field is controlled by the <see cref="IncludeErrorDetailPolicy"/>. The 
        /// field is expected to contain information about the server or the application that should not 
        /// be disclosed broadly.
        /// </remarks>
        public string MessageDetail
        {
            get { return GetPropertyValue<String>(HttpErrorKeys.MessageDetailKey); }
            set { this[HttpErrorKeys.MessageDetailKey] = value; }
        }

        /// <summary>
        /// The message of the <see cref="System.Exception"/> if available.
        /// </summary>
        /// <remarks>
        /// The inclusion of this field is controlled by the <see cref="IncludeErrorDetailPolicy"/>. The 
        /// field is expected to contain information about the server or the application that should not 
        /// be disclosed broadly.
        /// </remarks>
        public string ExceptionMessage
        {
            get { return GetPropertyValue<String>(HttpErrorKeys.ExceptionMessageKey); }
            set { this[HttpErrorKeys.ExceptionMessageKey] = value; }
        }

        /// <summary>
        /// The type of the <see cref="System.Exception"/> if available.
        /// </summary>
        /// <remarks>
        /// The inclusion of this field is controlled by the <see cref="IncludeErrorDetailPolicy"/>. The 
        /// field is expected to contain information about the server or the application that should not 
        /// be disclosed broadly.
        /// </remarks>
        public string ExceptionType
        {
            get { return GetPropertyValue<String>(HttpErrorKeys.ExceptionTypeKey); }
            set { this[HttpErrorKeys.ExceptionTypeKey] = value; }
        }

        /// <summary>
        /// The stack trace information associated with this instance if available.
        /// </summary>
        /// <remarks>
        /// The inclusion of this field is controlled by the <see cref="IncludeErrorDetailPolicy"/>. The 
        /// field is expected to contain information about the server or the application that should not 
        /// be disclosed broadly.
        /// </remarks>
        public string StackTrace
        {
            get { return GetPropertyValue<String>(HttpErrorKeys.StackTraceKey); }
            set { this[HttpErrorKeys.StackTraceKey] = value; }
        }

        /// <summary>
        /// The inner <see cref="System.Exception"/> associated with this instance if available.
        /// </summary>
        /// <remarks>
        /// The inclusion of this field is controlled by the <see cref="IncludeErrorDetailPolicy"/>. The 
        /// field is expected to contain information about the server or the application that should not 
        /// be disclosed broadly.
        /// </remarks>
        public HttpError InnerException
        {
            get { return GetPropertyValue<HttpError>(HttpErrorKeys.InnerExceptionKey); }
        }

        /// <summary>
        /// Gets a particular property value from this error instance.
        /// </summary>
        /// <typeparam name="TValue">The type of the property.</typeparam>
        /// <param name="key">The name of the error property.</param>
        /// <returns>The value of the error property.</returns>
        public TValue GetPropertyValue<TValue>(string key)
        {
            TValue value;
            if (this.TryGetValue(key, out value))
            {
                return value;
            }
            return default(TValue);
        }

        XmlSchema IXmlSerializable.GetSchema()
        {
            return null;
        }

        void IXmlSerializable.ReadXml(XmlReader reader)
        {
            if (reader.IsEmptyElement)
            {
                reader.Read();
                return;
            }

            reader.ReadStartElement();
            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
            {
                string key = XmlConvert.DecodeName(reader.LocalName);
                string value = reader.ReadInnerXml();

                this.Add(key, value);
                reader.MoveToContent();
            }
            reader.ReadEndElement();
        }

        void IXmlSerializable.WriteXml(XmlWriter writer)
        {
            foreach (KeyValuePair<string, object> keyValuePair in this)
            {
                string key = keyValuePair.Key;
                object value = keyValuePair.Value;
                writer.WriteStartElement(XmlConvert.EncodeLocalName(key));
                if (value != null)
                {
                    HttpError innerError = value as HttpError;
                    if (innerError == null)
                    {
                        writer.WriteValue(value);
                    }
                    else
                    {
                        ((IXmlSerializable)innerError).WriteXml(writer);
                    }
                }
                writer.WriteEndElement();
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpErrorKeys.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    /// <summary>
    /// Provides keys to look up error information stored in the <see cref="HttpError"/> dictionary.
    /// </summary>
    public static class HttpErrorKeys
    {
        /// <summary>
        /// Provides a key for the Message.
        /// </summary>
        public static readonly string MessageKey = "Message";

        /// <summary>
        /// Provides a key for the MessageDetail.
        /// </summary>
        public static readonly string MessageDetailKey = "MessageDetail";

        /// <summary>
        /// Provides a key for the ModelState.
        /// </summary>
        public static readonly string ModelStateKey = "ModelState";

        /// <summary>
        /// Provides a key for the ExceptionMessage.
        /// </summary>
        public static readonly string ExceptionMessageKey = "ExceptionMessage";

        /// <summary>
        /// Provides a key for the ExceptionType.
        /// </summary>
        public static readonly string ExceptionTypeKey = "ExceptionType";

        /// <summary>
        /// Provides a key for the StackTrace.
        /// </summary>
        public static readonly string StackTraceKey = "StackTrace";

        /// <summary>
        /// Provides a key for the InnerException.
        /// </summary>
        public static readonly string InnerExceptionKey = "InnerException";

        /// <summary>
        /// Provides a key for the MessageLanguage.
        /// </summary>
        public static readonly string MessageLanguageKey = "MessageLanguage";

        /// <summary>
        /// Provides a key for the ErrorCode.
        /// </summary>
        public static readonly string ErrorCodeKey = "ErrorCode";
    }
}

================================================
FILE: src/System.Web.Http/HttpGetAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies that an action supports the GET HTTP method.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpGetAttribute : Attribute, IActionHttpMethodProvider
    {
        private static readonly Collection<HttpMethod> _supportedMethods = new Collection<HttpMethod>(new HttpMethod[] { HttpMethod.Get });

        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _supportedMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpHeadAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies that an action supports the HEAD HTTP method.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpHeadAttribute : Attribute, IActionHttpMethodProvider
    {
        private static readonly Collection<HttpMethod> _supportedMethods = new Collection<HttpMethod>(new HttpMethod[] { HttpMethod.Head });

        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _supportedMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpOptionsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies that an action supports the OPTIONS HTTP method.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpOptionsAttribute : Attribute, IActionHttpMethodProvider
    {
        private static readonly Collection<HttpMethod> _supportedMethods = new Collection<HttpMethod>(new HttpMethod[] { HttpMethod.Options });

        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _supportedMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpPatchAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies that an action supports the PATCH HTTP method.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpPatchAttribute : Attribute, IActionHttpMethodProvider
    {
        private static readonly Collection<HttpMethod> _supportedMethods = new Collection<HttpMethod>(new HttpMethod[] { new HttpMethod("PATCH") });

        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _supportedMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpPostAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies that an action supports the POST HTTP method.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpPostAttribute : Attribute, IActionHttpMethodProvider
    {
        private static readonly Collection<HttpMethod> _supportedMethods = new Collection<HttpMethod>(new HttpMethod[] { HttpMethod.Post });

        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _supportedMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpPutAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Specifies that an action supports the PUT HTTP method.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpPutAttribute : Attribute, IActionHttpMethodProvider
    {
        private static readonly Collection<HttpMethod> _supportedMethods = new Collection<HttpMethod>(new HttpMethod[] { HttpMethod.Put });

        public Collection<HttpMethod> HttpMethods
        {
            get
            {
                return _supportedMethods;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.Hosting;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;
using System.Web.Http.Results;
using System.Web.Http.Routing;

namespace System.Net.Http
{
    /// <summary>
    /// Provides extension methods for the <see cref="HttpRequestMessage"/> class.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpRequestMessageExtensions
    {
        /// <summary>
        /// Gets the <see cref="HttpConfiguration"/> for the given request.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="HttpConfiguration"/>.</returns>
        public static HttpConfiguration GetConfiguration(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                return requestContext.Configuration;
            }

            return request.LegacyGetConfiguration();
        }

        internal static HttpConfiguration LegacyGetConfiguration(this HttpRequestMessage request)
        {
            return request.GetProperty<HttpConfiguration>(HttpPropertyKeys.HttpConfigurationKey);
        }

        /// <summary>
        /// Sets the <see cref="HttpConfiguration"/> for the given request.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <param name="configuration">The <see cref="HttpConfiguration"/> to set.</param>
        public static void SetConfiguration(this HttpRequestMessage request, HttpConfiguration configuration)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                requestContext.Configuration = configuration;
            }

            request.Properties[HttpPropertyKeys.HttpConfigurationKey] = configuration;
        }

        /// <summary>
        /// Gets the dependency resolver scope associated with this <see cref="HttpRequestMessage"/>.
        /// Services which are retrieved from this scope will be released when the request is
        /// cleaned up by the framework.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="IDependencyScope"/> for the given request.</returns>
        public static IDependencyScope GetDependencyScope(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            IDependencyScope result;
            if (!request.Properties.TryGetValue<IDependencyScope>(HttpPropertyKeys.DependencyScope, out result))
            {
                IDependencyResolver dependencyResolver = request.GetConfiguration().DependencyResolver;
                result = dependencyResolver.BeginScope();
                if (result == null)
                {
                    throw Error.InvalidOperation(SRResources.DependencyResolver_BeginScopeReturnsNull, dependencyResolver.GetType().Name);
                }
                request.Properties[HttpPropertyKeys.DependencyScope] = result;
                request.RegisterForDispose(result);
            }

            return result;
        }

        /// <summary>Gets the <see cref="HttpRequestContext"/> associated with this request.</summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="HttpRequestContext"/> associated with this request.</returns>
        public static HttpRequestContext GetRequestContext(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.GetProperty<HttpRequestContext>(HttpPropertyKeys.RequestContextKey);
        }

        /// <summary>Gets an <see cref="HttpRequestContext"/> associated with this request.</summary>
        /// <param name="request">The HTTP request.</param>
        /// <param name="context">The <see cref="HttpRequestContext"/> to associate with this request.</param>
        public static void SetRequestContext(this HttpRequestMessage request, HttpRequestContext context)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (context == null)
            {
                throw Error.ArgumentNull("context");
            }

            request.Properties[HttpPropertyKeys.RequestContextKey] = context;
        }

        /// <summary>
        /// Gets the <see cref="System.Threading.SynchronizationContext"/> for the given request or null if not available.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="System.Threading.SynchronizationContext"/> or null.</returns>
        public static SynchronizationContext GetSynchronizationContext(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.GetProperty<SynchronizationContext>(HttpPropertyKeys.SynchronizationContextKey);
        }

        internal static void SetSynchronizationContext(this HttpRequestMessage request, SynchronizationContext synchronizationContext)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            request.Properties[HttpPropertyKeys.SynchronizationContextKey] = synchronizationContext;
        }

        /// <summary>
        /// Gets the current <see cref="T:System.Security.Cryptography.X509Certificates.X509Certificate2"/> or null if not available.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="T:System.Security.Cryptography.X509Certificates.X509Certificate2"/> or null.</returns>
        public static X509Certificate2 GetClientCertificate(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                return requestContext.ClientCertificate;
            }

            return request.LegacyGetClientCertificate();
        }

        internal static X509Certificate2 LegacyGetClientCertificate(this HttpRequestMessage request)
        {
            X509Certificate2 result = null;

            if (!request.Properties.TryGetValue(HttpPropertyKeys.ClientCertificateKey, out result))
            {
                // now let us get out the delegate and try to invoke it
                Func<HttpRequestMessage, X509Certificate2> retrieveCertificate;

                if (request.Properties.TryGetValue(HttpPropertyKeys.RetrieveClientCertificateDelegateKey, out retrieveCertificate))
                {
                    result = retrieveCertificate(request);

                    if (result != null)
                    {
                        request.Properties.Add(HttpPropertyKeys.ClientCertificateKey, result);
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// Gets the <see cref="System.Web.Http.Routing.IHttpRouteData"/> for the given request or null if not available.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="System.Web.Http.Routing.IHttpRouteData"/> or null.</returns>
        public static IHttpRouteData GetRouteData(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                return requestContext.RouteData;
            }

            return request.LegacyGetRouteData();
        }

        internal static IHttpRouteData LegacyGetRouteData(this HttpRequestMessage request)
        {
            return request.GetProperty<IHttpRouteData>(HttpPropertyKeys.HttpRouteDataKey);
        }

        /// <summary>
        /// Sets the <see cref="System.Web.Http.Routing.IHttpRouteData"/> for the given request.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <param name="routeData">The HTTP route data.</param>
        public static void SetRouteData(this HttpRequestMessage request, IHttpRouteData routeData)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (routeData == null)
            {
                throw Error.ArgumentNull("routeData");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                requestContext.RouteData = routeData;
            }

            request.Properties[HttpPropertyKeys.HttpRouteDataKey] = routeData;
        }

        /// <summary>
        /// Gets the <see cref="System.Web.Http.Controllers.HttpActionDescriptor"/> selected for the given request or null if not available.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="System.Web.Http.Controllers.HttpActionDescriptor"/> or null.</returns>
        public static HttpActionDescriptor GetActionDescriptor(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.GetProperty<HttpActionDescriptor>(HttpPropertyKeys.HttpActionDescriptorKey);
        }

        internal static void SetActionDescriptor(this HttpRequestMessage request, HttpActionDescriptor actionDescriptor)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            request.Properties[HttpPropertyKeys.HttpActionDescriptorKey] = actionDescriptor;
        }

        private static T GetProperty<T>(this HttpRequestMessage request, string key)
        {
            T value;
            request.Properties.TryGetValue(key, out value);
            return value;
        }

        /// <summary>
        /// Helper method for creating an <see cref="HttpResponseMessage"/> message with a "416 (Requested Range Not Satisfiable)" status code.
        /// This response can be used in combination with the <see cref="ByteRangeStreamContent"/> to indicate that the requested range or
        /// ranges do not overlap with the current resource. The response contains a "Content-Range" header indicating the valid upper and lower
        /// bounds for requested ranges.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="invalidByteRangeException">An <see cref="InvalidByteRangeException"/> instance, typically thrown by a
        /// <see cref="ByteRangeStreamContent"/> instance.</param>
        /// <returns>An 416 (Requested Range Not Satisfiable) error response with a Content-Range header indicating the valid range.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller will dispose")]
        public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, InvalidByteRangeException invalidByteRangeException)
        {
            if (invalidByteRangeException == null)
            {
                throw Error.ArgumentNull("invalidByteRangeException");
            }

            HttpResponseMessage rangeNotSatisfiableResponse = request.CreateErrorResponse(HttpStatusCode.RequestedRangeNotSatisfiable, invalidByteRangeException);
            rangeNotSatisfiableResponse.Content.Headers.ContentRange = invalidByteRangeException.ContentRange;
            return rangeNotSatisfiableResponse;
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
        /// with an instance of <see cref="ObjectContent{T}"/> wrapping an <see cref="HttpError"/> with message <paramref name="message"/>.
        /// If no formatter is found, this method returns a response with status 406 NotAcceptable.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="message">The error message.</param>
        /// <returns>An error response with error message <paramref name="message"/> and status code <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message)
        {
            return request.CreateErrorResponse(statusCode, new HttpError(message));
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
        /// with an instance of <see cref="ObjectContent{T}"/> wrapping an <see cref="HttpError"/> with message <paramref name="message"/>
        /// and message detail <paramref name="messageDetail"/>.If no formatter is found, this method returns a response with
        /// status 406 NotAcceptable.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="message">The error message. This message will always be seen by clients.</param>
        /// <param name="messageDetail">The error message detail. This message will only be seen by clients if we should include error detail.</param>
        /// <returns>An error response with error message <paramref name="message"/> and message detail <paramref name="messageDetail"/>
        /// and status code <paramref name="statusCode"/>.</returns>
        internal static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message, string messageDetail)
        {
            return request.CreateErrorResponse(statusCode, includeErrorDetail => includeErrorDetail ? new HttpError(message, messageDetail) : new HttpError(message));
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
        /// with an instance of <see cref="ObjectContent{T}"/> wrapping an <see cref="HttpError"/> with error message <paramref name="message"/>
        /// for exception <paramref name="exception"/>. If no formatter is found, this method returns a response with status 406 NotAcceptable.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="message">The error message.</param>
        /// <param name="exception">The exception.</param>
        /// <returns>An error response for <paramref name="exception"/> with error message <paramref name="message"/>
        /// and status code <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message, Exception exception)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.CreateErrorResponse(statusCode, includeErrorDetail => new HttpError(exception, includeErrorDetail) { Message = message });
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
        /// with an instance of <see cref="ObjectContent{T}"/> wrapping an <see cref="HttpError"/> for exception <paramref name="exception"/>.
        /// If no formatter is found, this method returns a response with status 406 NotAcceptable.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="exception">The exception.</param>
        /// <returns>An error response for <paramref name="exception"/> with status code <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, Exception exception)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.CreateErrorResponse(statusCode, includeErrorDetail => new HttpError(exception, includeErrorDetail));
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
        /// with an instance of <see cref="ObjectContent{T}"/> wrapping an <see cref="HttpError"/> for model state <paramref name="modelState"/>.
        /// If no formatter is found, this method returns a response with status 406 NotAcceptable.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="modelState">The model state.</param>
        /// <returns>An error response for <paramref name="modelState"/> with status code <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, ModelStateDictionary modelState)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.CreateErrorResponse(statusCode, includeErrorDetail => new HttpError(modelState, includeErrorDetail));
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> representing an error
        /// with an instance of <see cref="ObjectContent{T}"/> wrapping <paramref name="error"/> as the content. If no formatter
        /// is found, this method returns a response with status 406 NotAcceptable.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="error">The error to wrap.</param>
        /// <returns>An error response wrapping <paramref name="error"/> with status code <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, HttpError error)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.CreateErrorResponse(statusCode, includeErrorDetail => error);
        }

        private static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, Func<bool, HttpError> errorCreator)
        {
            HttpConfiguration configuration = request.GetConfiguration();

            HttpError error = errorCreator(request.ShouldIncludeErrorDetail());

            // CreateErrorResponse should never fail, even if there is no configuration associated with the request
            // In that case, use the default HttpConfiguration to con-neg the response media type
            if (configuration == null)
            {
                using (HttpConfiguration defaultConfig = new HttpConfiguration())
                {
                    return request.CreateResponse<HttpError>(statusCode, error, defaultConfig);
                }
            }
            else
            {
                return request.CreateResponse<HttpError>(statusCode, error, configuration);
            }
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> with an instance
        /// of <see cref="ObjectContent{T}"/> as the content and <see cref="System.Net.HttpStatusCode.OK"/> as the status code
        /// if a formatter can be found. If no formatter is found, this method returns a response with status 406 NotAcceptable.
        /// This forwards the call to <see cref="CreateResponse{T}(HttpRequestMessage, HttpStatusCode, T, HttpConfiguration)"/> with
        /// <see cref="System.Net.HttpStatusCode.OK"/> status code and a <c>null</c> configuration.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <returns>A response wrapping <paramref name="value"/> with <see cref="System.Net.HttpStatusCode.OK"/> status code.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, T value)
        {
            return request.CreateResponse<T>(HttpStatusCode.OK, value, configuration: null);
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> with an instance
        /// of <see cref="ObjectContent{T}"/> as the content if a formatter can be found. If no formatter is found, this
        /// method returns a response with status 406 NotAcceptable. This forwards the call to
        /// <see cref="CreateResponse{T}(HttpRequestMessage, HttpStatusCode, T, HttpConfiguration)"/> with a <c>null</c>
        /// configuration.
        /// </summary>
        /// <remarks>
        /// This method requires that <paramref name="request"/> has been associated with an instance of
        /// <see cref="HttpConfiguration"/>.
        /// </remarks>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value)
        {
            return request.CreateResponse<T>(statusCode, value, configuration: null);
        }

        /// <summary>
        /// Helper method that performs content negotiation and creates a <see cref="HttpResponseMessage"/> with an instance
        /// of <see cref="ObjectContent{T}"/> as the content if a formatter can be found. If no formatter is found, this
        /// method returns a response with status 406 NotAcceptable.
        /// </summary>
        /// <remarks>
        /// This method will use the provided <paramref name="configuration"/> or it will get the
        /// <see cref="HttpConfiguration"/> instance associated with <paramref name="request"/>.
        /// </remarks>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <param name="configuration">The configuration to use. Can be <c>null</c>.</param>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, HttpConfiguration configuration)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            configuration = configuration ?? request.GetConfiguration();
            if (configuration == null)
            {
                throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoConfiguration);
            }

            IContentNegotiator contentNegotiator = configuration.Services.GetContentNegotiator();
            if (contentNegotiator == null)
            {
                throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoContentNegotiator, typeof(IContentNegotiator).FullName);
            }

            IEnumerable<MediaTypeFormatter> formatters = configuration.Formatters;

            return NegotiatedContentResult<T>.Execute(statusCode, value, contentNegotiator, request, formatters);
        }

        /// <summary>
        /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
        /// <paramref name="value"/>. The given <paramref name="mediaType"/> is used to find an instance of <see cref="MediaTypeFormatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <param name="mediaType">The media type used to look up an instance of <see cref="MediaTypeFormatter"/>.</param>
        /// <exception cref="InvalidOperationException">Thrown if the <paramref name="request"/> does not have an associated
        /// <see cref="HttpConfiguration"/> instance or if the configuration does not have a formatter matching <paramref name="mediaType"/>.</exception>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, string mediaType)
        {
            return request.CreateResponse(statusCode, value, new MediaTypeHeaderValue(mediaType));
        }

        /// <summary>
        /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
        /// <paramref name="value"/>. The given <paramref name="mediaType"/> is used to find an instance of <see cref="MediaTypeFormatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <param name="mediaType">The media type used to look up an instance of <see cref="MediaTypeFormatter"/>.</param>
        /// <exception cref="InvalidOperationException">Thrown if the <paramref name="request"/> does not have an associated
        /// <see cref="HttpConfiguration"/> instance or if the configuration does not have a formatter matching <paramref name="mediaType"/>.</exception>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, MediaTypeHeaderValue mediaType)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (mediaType == null)
            {
                throw Error.ArgumentNull("mediaType");
            }

            HttpConfiguration configuration = request.GetConfiguration();
            if (configuration == null)
            {
                throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoConfiguration);
            }

            MediaTypeFormatter formatter = configuration.Formatters.FindWriter(typeof(T), mediaType);
            if (formatter == null)
            {
                throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoMatchingFormatter, mediaType, typeof(T).Name);
            }

            return request.CreateResponse(statusCode, value, formatter, mediaType);
        }

        /// <summary>
        /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
        /// <paramref name="value"/> and the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <param name="formatter">The formatter to use.</param>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, MediaTypeFormatter formatter)
        {
            return request.CreateResponse(statusCode, value, formatter, (MediaTypeHeaderValue)null);
        }

        /// <summary>
        /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
        /// <paramref name="value"/> and the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <param name="formatter">The formatter to use.</param>
        /// <param name="mediaType">The media type override to set on the response's content. Can be <c>null</c>.</param>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, MediaTypeFormatter formatter, string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeader = mediaType != null ? new MediaTypeHeaderValue(mediaType) : null;
            return request.CreateResponse(statusCode, value, formatter, mediaTypeHeader);
        }

        /// <summary>
        /// Helper method that creates a <see cref="HttpResponseMessage"/> with an <see cref="ObjectContent{T}"/> instance containing the provided
        /// <paramref name="value"/> and the given <paramref name="formatter"/>.
        /// </summary>
        /// <typeparam name="T">The type of the value.</typeparam>
        /// <param name="request">The request.</param>
        /// <param name="statusCode">The status code of the created response.</param>
        /// <param name="value">The value to wrap. Can be <c>null</c>.</param>
        /// <param name="formatter">The formatter to use.</param>
        /// <param name="mediaType">The media type override to set on the response's content. Can be <c>null</c>.</param>
        /// <returns>A response wrapping <paramref name="value"/> with <paramref name="statusCode"/>.</returns>
        public static HttpResponseMessage CreateResponse<T>(this HttpRequestMessage request, HttpStatusCode statusCode, T value, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }
            if (formatter == null)
            {
                throw Error.ArgumentNull("formatter");
            }

            return FormattedContentResult<T>.Execute(statusCode, value, formatter, mediaType, request);
        }

        /// <summary>
        /// Adds the given <paramref name="resource"/> to a list of resources that will be disposed by a host once
        /// the <paramref name="request"/> is disposed.
        /// </summary>
        /// <param name="request">The request controlling the lifecycle of <paramref name="resource"/>.</param>
        /// <param name="resource">The resource to dispose when <paramref name="request"/> is being disposed. Can be <c>null</c>.</param>
        public static void RegisterForDispose(this HttpRequestMessage request, IDisposable resource)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (resource == null)
            {
                return;
            }

            List<IDisposable> trackedResources = GetRegisteredResourcesForDispose(request);

            trackedResources.Add(resource);
        }

        /// <summary>
        /// Adds the given <paramref name="resources"/> to a list of resources that will be disposed by a host once
        /// the <paramref name="request"/> is disposed.
        /// </summary>
        /// <param name="request">The request controlling the lifecycle of <paramref name="resources"/>.</param>
        /// <param name="resources">The resources to dispose when <paramref name="request"/> is being disposed. Can be <c>null</c>.</param>
        public static void RegisterForDispose(this HttpRequestMessage request, IEnumerable<IDisposable> resources)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (resources == null)
            {
                throw Error.ArgumentNull("resources");
            }

            List<IDisposable> trackedResources = GetRegisteredResourcesForDispose(request);

            foreach (IDisposable resource in resources)
            {
                if (resource != null)
                {
                    trackedResources.Add(resource);
                }
            }
        }

        /// <summary>
        /// Disposes of all tracked resources associated with the <paramref name="request"/> which were added via the
        /// <see cref="RegisterForDispose(HttpRequestMessage, IDisposable)"/> method.
        /// </summary>
        /// <param name="request">The request.</param>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We want to ignore all exceptions.")]
        public static void DisposeRequestResources(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            List<IDisposable> resourcesToDispose;
            if (request.Properties.TryGetValue(HttpPropertyKeys.DisposableRequestResourcesKey, out resourcesToDispose))
            {
                foreach (IDisposable resource in resourcesToDispose)
                {
                    try
                    {
                        resource.Dispose();
                    }
                    catch
                    {
                        // ignore exceptions
                    }
                }
                resourcesToDispose.Clear();
            }
        }

        /// <summary>
        /// Retrieves the <see cref="Guid"/> which has been assigned as the
        /// correlation id associated with the given <paramref name="request"/>.
        /// The value will be created and set the first time this method is called.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/></param>
        /// <returns>The <see cref="Guid"/> associated with that request.</returns>
        public static Guid GetCorrelationId(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            Guid correlationId;
            if (!request.Properties.TryGetValue<Guid>(HttpPropertyKeys.RequestCorrelationKey, out correlationId))
            {
                // Check if the Correlation Manager ID is set; otherwise fallback to creating a new GUID
                correlationId = Trace.CorrelationManager.ActivityId;
                if (correlationId == Guid.Empty)
                {
                    correlationId = Guid.NewGuid();
                }

                request.Properties.Add(HttpPropertyKeys.RequestCorrelationKey, correlationId);
            }

            return correlationId;
        }

        /// <summary>
        /// Retrieves the parsed query string as a collection of key-value pairs.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/></param>
        /// <returns>The query string as a collection of key-value pairs.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "NameValuePairsValueProvider takes an IEnumerable<KeyValuePair<string, string>>")]
        public static IEnumerable<KeyValuePair<string, string>> GetQueryNameValuePairs(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            Uri uri = request.RequestUri;

            // Unit tests may not always provide a Uri in the request
            if (uri == null || String.IsNullOrEmpty(uri.Query))
            {
                return Enumerable.Empty<KeyValuePair<string, string>>();
            }

            IEnumerable<KeyValuePair<string, string>> queryStringData;
            string cachedQueryString;

            request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out queryStringData);
            request.Properties.TryGetValue<string>(HttpPropertyKeys.CachedRequestQueryKey, out cachedQueryString);

            if (queryStringData == null ||
               (cachedQueryString != null && !Object.ReferenceEquals(cachedQueryString, uri.Query ?? String.Empty)))
            {
                FormDataCollection formData = new FormDataCollection(uri);

                // The ToArray call here avoids reparsing the query string, and avoids storing an Enumerator state
                // machine in the request state.
                queryStringData = formData.GetJQueryNameValuePairs().ToArray();
                request.Properties[HttpPropertyKeys.RequestQueryNameValuePairsKey] = queryStringData;
                request.Properties[HttpPropertyKeys.CachedRequestQueryKey] = uri.Query ?? String.Empty;
            }

            return queryStringData;
        }

        /// <summary>
        /// Retrieves the <see cref="UrlHelper"/> instance associated with this request.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/>.</param>
        /// <returns>The <see cref="UrlHelper"/> instance associated with this request.</returns>
        public static UrlHelper GetUrlHelper(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                return requestContext.Url;
            }

            return new UrlHelper(request);
        }

        /// <summary>
        /// Gets a value indicating whether the request originates from a local address or not.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns><see langword="true"/> if the request originates from a local address; otherwise, <see langword="false"/>.</returns>
        public static bool IsLocal(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                return requestContext.IsLocal;
            }

            return request.LegacyIsLocal();
        }

        internal static bool LegacyIsLocal(this HttpRequestMessage request)
        {
            Lazy<bool> isLocal = request.GetProperty<Lazy<bool>>(HttpPropertyKeys.IsLocalKey);

            return isLocal == null ? false : isLocal.Value;
        }

        /// <summary>
        /// Gets a value indicating whether the request originates from a batch.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns><see langword="true"/> if the request originates from a batch; otherwise, <see langword="false"/>.</returns>
        public static bool IsBatchRequest(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.GetProperty<bool>(HttpPropertyKeys.IsBatchRequest);
        }

        /// <summary>
        /// Gets a value indicating whether error details, such as exception messages and stack traces, should be included for this HTTP request.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns><see langword="true"/> if the error details are to be included; otherwise, <see langword="false"/>.</returns>
        public static bool ShouldIncludeErrorDetail(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpRequestContext requestContext = GetRequestContext(request);

            if (requestContext != null)
            {
                return requestContext.IncludeErrorDetail;
            }

            return request.LegacyShouldIncludeErrorDetail();
        }

        internal static bool LegacyShouldIncludeErrorDetail(this HttpRequestMessage request)
        {
            HttpConfiguration configuration = request.GetConfiguration();
            IncludeErrorDetailPolicy includeErrorDetailPolicy = IncludeErrorDetailPolicy.Default;
            if (configuration != null)
            {
                includeErrorDetailPolicy = configuration.IncludeErrorDetailPolicy;
            }
            switch (includeErrorDetailPolicy)
            {
                case IncludeErrorDetailPolicy.Default:
                    Lazy<bool> includeErrorDetail = request.GetProperty<Lazy<bool>>(HttpPropertyKeys.IncludeErrorDetailKey);
                    if (includeErrorDetail != null)
                    {
                        // If we are on webhost and the user hasn't changed the IncludeErrorDetailPolicy
                        // look up into the Request's property bag else default to LocalOnly.
                        return includeErrorDetail.Value;
                    }

                    goto case IncludeErrorDetailPolicy.LocalOnly;

                case IncludeErrorDetailPolicy.LocalOnly:
                    return request.IsLocal();

                case IncludeErrorDetailPolicy.Always:
                    return true;

                case IncludeErrorDetailPolicy.Never:
                default:
                    return false;
            }
        }

        /// <summary>
        /// Gets the collection of resources registered for dispose once the <paramref name="request"/> is disposed.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>A collection of resources registered for dispose.</returns>
        public static IEnumerable<IDisposable> GetResourcesForDisposal(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return GetRegisteredResourcesForDispose(request);
        }

        private static List<IDisposable> GetRegisteredResourcesForDispose(HttpRequestMessage request)
        {
            List<IDisposable> registeredResourcesForDispose;
            if (!request.Properties.TryGetValue(HttpPropertyKeys.DisposableRequestResourcesKey, out registeredResourcesForDispose))
            {
                registeredResourcesForDispose = new List<IDisposable>();
                request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey] = registeredResourcesForDispose;
            }
            return registeredResourcesForDispose;
        }
    }
}

================================================
FILE: src/System.Web.Http/HttpResponseException.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Net.Http;
using System.Web.Http.Properties;

namespace System.Web.Http
{
    /// <summary>
    /// An exception that allows for a given <see cref="HttpResponseMessage"/>
    /// to be returned to the client.
    /// </summary>
    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable", Justification = "This type is not meant to be serialized")]
    [SuppressMessage("Microsoft.Usage", "CA2240:Implement ISerializable correctly", Justification = "This type has no serializable state")]
    [SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors", Justification = "HttpResponseException is not a real exception and is just an easy way to return HttpResponseMessage")]
    public class HttpResponseException : Exception
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HttpResponseException"/> class.
        /// </summary>
        /// <param name="statusCode">The status code of the response.</param>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Instance is disposed elsewhere")]
        public HttpResponseException(HttpStatusCode statusCode)
            : this(new HttpResponseMessage(statusCode))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpResponseException"/> class.
        /// </summary>
        /// <param name="response">The response message.</param>
        public HttpResponseException(HttpResponseMessage response)
            : base(SRResources.HttpResponseExceptionMessage)
        {
            if (response == null)
            {
                throw Error.ArgumentNull("response");
            }

            Response = response;
        }

        /// <summary>
        /// Gets the <see cref="HttpResponseMessage"/> to return to the client.
        /// </summary>
        public HttpResponseMessage Response { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/HttpResponseMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.Http;

namespace System.Net.Http
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpResponseMessageExtensions
    {
        /// <summary>
        /// Attempts to retrieve a strongly-typed value from a <paramref name="response"/>.
        /// </summary>
        /// <remarks>
        /// If <see cref="HttpResponseMessage.Content"/> is an instance of <see cref="ObjectContent"/>
        /// attempts to retrieve the <see cref="ObjectContent.Value"/> if it is compatible with <typeparamref name="T"/>.
        /// If it is it returns <c>true</c> and sets <paramref name="value"/>. If not it returns <c>false</c> and
        /// sets <paramref name="value"/> to the default instance of <typeparamref name="T"/>.
        /// </remarks>
        /// <typeparam name="T">The type of the value to retrieve.</typeparam>
        /// <param name="response">The response.</param>
        /// <param name="value">Will contain the retrieved value if this method succeeds.</param>
        /// <returns>Returns <c>true</c> if the response has a content with a value that can be cast to <typeparamref name="T"/>,
        /// <c>false</c> otherwise.</returns>
        public static bool TryGetContentValue<T>(this HttpResponseMessage response, out T value)
        {
            if (response == null)
            {
                throw Error.ArgumentNull("response");
            }

            ObjectContent content = response.Content as ObjectContent;
            if (content != null)
            {
                if (content.Value is T)
                {
                    value = (T)content.Value;
                    return true;
                }
            }

            value = default(T);
            return false;
        }

        /// <summary>
        /// Attaches the given <paramref name="request"/> to the <paramref name="response"/> if the response does not already
        /// have a pointer to a request.
        /// </summary>
        /// <param name="response">The response.</param>
        /// <param name="request">The request.</param>
        internal static void EnsureResponseHasRequest(this HttpResponseMessage response, HttpRequestMessage request)
        {
            if (response != null && response.RequestMessage == null)
            {
                response.RequestMessage = request;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpRouteCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using System.Web.Http.Routing;

namespace System.Web.Http
{
    public class HttpRouteCollection : ICollection<IHttpRoute>, IDisposable
    {
        // Arbitrary base address for evaluating the root virtual path
        private static readonly Uri _referenceBaseAddress = new Uri("http://localhost");

        private readonly string _virtualPathRoot;
        private readonly List<IHttpRoute> _collection = new List<IHttpRoute>();
        private readonly IDictionary<string, IHttpRoute> _dictionary = new Dictionary<string, IHttpRoute>(StringComparer.OrdinalIgnoreCase);
        private bool _disposed;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpRouteCollection"/> class with a <see cref="M:VirtualPathRoot"/>
        /// value of "/".
        /// </summary>
        public HttpRouteCollection()
            : this("/")
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "Relative URIs are not URIs")]
        public HttpRouteCollection(string virtualPathRoot)
        {
            if (virtualPathRoot == null)
            {
                throw Error.ArgumentNull("virtualPathRoot");
            }

            // Validate virtual path
            Uri address = new Uri(_referenceBaseAddress, virtualPathRoot);
            _virtualPathRoot = "/" + address.GetComponents(UriComponents.Path, UriFormat.Unescaped);
        }

        public virtual string VirtualPathRoot
        {
            get { return _virtualPathRoot; }
        }

        public virtual int Count
        {
            get { return _collection.Count; }
        }

        public virtual bool IsReadOnly
        {
            get { return false; }
        }

        public virtual IHttpRoute this[int index]
        {
            get { return _collection[index]; }
        }

        public virtual IHttpRoute this[string name]
        {
            get { return _dictionary[name]; }
        }

        public virtual IHttpRouteData GetRouteData(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            for (int i = 0; i < _collection.Count; i++)
            {
                string virtualPathRoot = GetVirtualPathRoot(request.GetRequestContext());
                IHttpRouteData routeData = _collection[i].GetRouteData(virtualPathRoot, request);
                if (routeData != null)
                {
                    return routeData;
                }
            }

            return null;
        }

        public virtual IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, string name, IDictionary<string, object> values)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            IHttpRoute route;
            if (!_dictionary.TryGetValue(name, out route))
            {
                throw Error.Argument("name", SRResources.RouteCollection_NameNotFound, name);
            }
            IHttpVirtualPathData virtualPath = route.GetVirtualPath(request, values);
            if (virtualPath == null)
            {
                return null;
            }

            // Construct a new VirtualPathData with the resolved app path
            string virtualPathRoot = GetVirtualPathRoot(request.GetRequestContext());
            if (!virtualPathRoot.EndsWith("/", StringComparison.Ordinal))
            {
                virtualPathRoot += "/";
            }

            // Note: The virtual path root here always ends with a "/" and the
            // virtual path never starts with a "/" (that's how routes work).
            return new HttpVirtualPathData(virtualPath.Route, virtualPathRoot + virtualPath.VirtualPath);
        }

        // Returns the virtual path root on the request context if present
        // Otherwise, fall back on the virtual path root for the route collection
        private string GetVirtualPathRoot(HttpRequestContext requestContext)
        {
            if (requestContext != null)
            {
                return requestContext.VirtualPathRoot ?? String.Empty;
            }

            return _virtualPathRoot;
        }

        public IHttpRoute CreateRoute(string routeTemplate, object defaults, object constraints)
        {
            IDictionary<string, object> dataTokens = new Dictionary<string, object>();

            return CreateRoute(routeTemplate, new HttpRouteValueDictionary(defaults), new HttpRouteValueDictionary(constraints), dataTokens, handler: null);
        }

        public IHttpRoute CreateRoute(string routeTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> dataTokens)
        {
            return CreateRoute(routeTemplate, defaults, constraints, dataTokens, handler: null);
        }

        public virtual IHttpRoute CreateRoute(string routeTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> dataTokens, HttpMessageHandler handler)
        {
            HttpRouteValueDictionary routeDefaults = new HttpRouteValueDictionary(defaults);
            HttpRouteValueDictionary routeConstraints = new HttpRouteValueDictionary(constraints);
            HttpRouteValueDictionary routeDataTokens = new HttpRouteValueDictionary(dataTokens);

            foreach (var constraint in routeConstraints)
            {
                ValidateConstraint(routeTemplate, constraint.Key, constraint.Value);
            }

            return new HttpRoute(routeTemplate, routeDefaults, routeConstraints, routeDataTokens, handler);
        }

        /// <summary>
        /// Validates that a constraint is valid for an <see cref="IHttpRoute"/> created by a call
        /// to the <see cref="HttpRouteCollection.CreateRoute(string, IDictionary&lt;string, object&gt;, IDictionary&lt;string, object&gt;, IDictionary&lt;string, object&gt;, HttpMessageHandler)"/> method.
        /// </summary>
        /// <param name="routeTemplate">The route template.</param>
        /// <param name="name">The constraint name.</param>
        /// <param name="constraint">The constraint object.</param>
        /// <remarks>
        /// Implement this method when deriving from <see cref="HttpRouteCollection"/> to allow contraints of
        /// types other than <see cref="string"/> and <see cref="IHttpRouteConstraint"/>.
        /// </remarks>
        protected virtual void ValidateConstraint(string routeTemplate, string name, object constraint)
        {
            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            if (constraint == null)
            {
                throw Error.ArgumentNull("constraint");
            }

            HttpRoute.ValidateConstraint(routeTemplate, name, constraint);
        }

        void ICollection<IHttpRoute>.Add(IHttpRoute route)
        {
            throw Error.NotSupported(SRResources.Route_AddRemoveWithNoKeyNotSupported, typeof(HttpRouteCollection).Name);
        }

        public virtual void Add(string name, IHttpRoute route)
        {
            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            _dictionary.Add(name, route);
            _collection.Add(route);
        }

        public virtual void Clear()
        {
            _dictionary.Clear();
            _collection.Clear();
        }

        public virtual bool Contains(IHttpRoute item)
        {
            if (item == null)
            {
                throw Error.ArgumentNull("item");
            }

            return _collection.Contains(item);
        }

        public virtual bool ContainsKey(string name)
        {
            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            return _dictionary.ContainsKey(name);
        }

        public virtual void CopyTo(IHttpRoute[] array, int arrayIndex)
        {
            _collection.CopyTo(array, arrayIndex);
        }

        public virtual void CopyTo(KeyValuePair<string, IHttpRoute>[] array, int arrayIndex)
        {
            _dictionary.CopyTo(array, arrayIndex);
        }

        public virtual void Insert(int index, string name, IHttpRoute value)
        {
            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            if (value == null)
            {
                throw Error.ArgumentNull("value");
            }

            // Check that index is valid
            if (_collection[index] != null)
            {
                _dictionary.Add(name, value);
                _collection.Insert(index, value);
            }
        }

        bool ICollection<IHttpRoute>.Remove(IHttpRoute route)
        {
            throw Error.NotSupported(SRResources.Route_AddRemoveWithNoKeyNotSupported, typeof(HttpRouteCollection).Name);
        }

        public virtual bool Remove(string name)
        {
            if (name == null)
            {
                throw Error.ArgumentNull("name");
            }

            IHttpRoute value;
            if (_dictionary.TryGetValue(name, out value))
            {
                bool dictionaryRemove = _dictionary.Remove(name);
                bool collectionRemove = _collection.Remove(value);
                Contract.Assert(dictionaryRemove == collectionRemove);
                return dictionaryRemove;
            }

            return false;
        }

        public virtual IEnumerator<IHttpRoute> GetEnumerator()
        {
            return _collection.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return OnGetEnumerator();
        }

        protected virtual IEnumerator OnGetEnumerator()
        {
            return _collection.GetEnumerator();
        }

        public virtual bool TryGetValue(string name, out IHttpRoute route)
        {
            return _dictionary.TryGetValue(name, out route);
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                if (disposing)
                {
                    // Creating a collection to avoid double-disposing any handlers that are shared between routes
                    HashSet<IDisposable> handlers = new HashSet<IDisposable>();
                    foreach (var route in this)
                    {
                        if (route.Handler != null)
                        {
                            handlers.Add(route.Handler);
                        }
                    }

                    foreach (var handler in handlers)
                    {
                        handler.Dispose();
                    }
                }

                _disposed = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpRouteCollectionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http;
using System.Web.Http.Batch;
using System.Web.Http.Routing;

namespace System.Web.Http
{
    /// <summary>
    /// Extension methods for <see cref="HttpRouteCollection"/>
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpRouteCollectionExtensions
    {
        /// <summary>
        /// Maps the specified route template.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate)
        {
            return MapHttpRoute(routes, name, routeTemplate, defaults: null, constraints: null, handler: null);
        }

        /// <summary>
        /// Maps the specified route template and sets default constraints.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults)
        {
            return MapHttpRoute(routes, name, routeTemplate, defaults, constraints: null, handler: null);
        }

        /// <summary>
        /// Maps the specified route template and sets default route values and constraints.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <param name="constraints">A set of expressions that specify values for <paramref name="routeTemplate"/>.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults, object constraints)
        {
            return MapHttpRoute(routes, name, routeTemplate, defaults, constraints, handler: null);
        }

        /// <summary>
        /// Maps the specified route template and sets default route values, constraints, and end-point message handler.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <param name="constraints">A set of expressions that specify values for <paramref name="routeTemplate"/>.</param>
        /// <param name="handler">The handler to which the request will be dispatched.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static IHttpRoute MapHttpRoute(this HttpRouteCollection routes, string name, string routeTemplate, object defaults, object constraints, HttpMessageHandler handler)
        {
            if (routes == null)
            {
                throw Error.ArgumentNull("routes");
            }

            HttpRouteValueDictionary defaultsDictionary = new HttpRouteValueDictionary(defaults);
            HttpRouteValueDictionary constraintsDictionary = new HttpRouteValueDictionary(constraints);
            IHttpRoute route = routes.CreateRoute(routeTemplate, defaultsDictionary, constraintsDictionary, dataTokens: null, handler: handler);
            routes.Add(name, route);
            return route;
        }

        /// <summary>
        /// Maps the specified route for handling HTTP batch requests.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="routeName">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="batchHandler">The <see cref="HttpBatchHandler"/> for handling batch requests.</param>
        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "We want the handler to be a batch handler.")]
        public static IHttpRoute MapHttpBatchRoute(this HttpRouteCollection routes, string routeName, string routeTemplate, HttpBatchHandler batchHandler)
        {
            return routes.MapHttpRoute(routeName, routeTemplate, defaults: null, constraints: null, handler: batchHandler);
        }

        /// <summary>
        /// Ignores the specified route.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="routeName">The name of the route to ignore.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        public static IHttpRoute IgnoreRoute(this HttpRouteCollection routes, string routeName, string routeTemplate)
        {
            return IgnoreRoute(routes, routeName, routeTemplate, constraints: null);
        }

        /// <summary>
        /// Ignores the specified route.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="routeName">The name of the route to ignore.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="constraints">A set of expressions that specify values for <paramref name="routeTemplate"/>.</param>
        [SuppressMessage("Microsoft.Reliability", "CA2000:DisposeObjectsBeforeLosingScope", Justification = "The handler instance is owned by the Route. StopRoutingHandler.Dispose() doesn't do anything, so we don't care if we throw and fail to dispose it. Currently it will never be disposed, see https://aspnetwebstack.codeplex.com/workitem/1393.")]
        public static IHttpRoute IgnoreRoute(this HttpRouteCollection routes, string routeName, string routeTemplate, object constraints)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }
            if (routeName == null)
            {
                throw new ArgumentNullException("routeName");
            }
            if (routeTemplate == null)
            {
                throw new ArgumentNullException("routeTemplate");
            }

            IgnoreHttpRouteInternal route = new IgnoreHttpRouteInternal(routeTemplate, new HttpRouteValueDictionary(constraints), new StopRoutingHandler());
            routes.Add(routeName, route);
            return route;
        }

        private sealed class IgnoreHttpRouteInternal : HttpRoute
        {
            public IgnoreHttpRouteInternal(string routeTemplate, HttpRouteValueDictionary constraints, HttpMessageHandler handler)
                : base(routeTemplate, constraints: constraints, handler: handler, dataTokens: null, defaults: null)
            {
            }

            public override IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, IDictionary<string, object> values)
            {
                // Never match during route generation. This avoids the scenario where an IgnoreRoute with
                // fairly relaxed constraints ends up eagerly matching all generated URLs.
                return null;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/HttpServer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Properties;

namespace System.Web.Http
{
    /// <summary>
    /// Defines an implementation of an <see cref="HttpMessageHandler"/> which dispatches an 
    /// incoming <see cref="HttpRequestMessage"/> and creates an <see cref="HttpResponseMessage"/> as a result.
    /// </summary>
    public class HttpServer : DelegatingHandler
    {
        // _anonymousPrincipal needs thread-safe intialization so use a static field initializer
        private static readonly IPrincipal _anonymousPrincipal = new GenericPrincipal(new GenericIdentity(String.Empty), new string[0]);

        private readonly HttpConfiguration _configuration;
        private readonly HttpMessageHandler _dispatcher;

        private IExceptionLogger _exceptionLogger;
        private IExceptionHandler _exceptionHandler;
        private bool _disposed;
        private bool _initialized = false;
        private object _initializationLock = new object();
        private object _initializationTarget;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpServer"/> class with default configuration and dispatcher.
        /// </summary>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "The configuration object is disposed as part of this class.")]
        public HttpServer()
            : this(new HttpConfiguration())
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpServer"/> class with default dispatcher.
        /// </summary>
        /// <param name="configuration">The <see cref="HttpConfiguration"/> used to configure this <see cref="HttpServer"/> instance.</param>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "The configuration object is disposed as part of this class.")]
        public HttpServer(HttpConfiguration configuration)
            : this(configuration, new HttpRoutingDispatcher(configuration))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpServer"/> class with a custom dispatcher.
        /// </summary>
        /// <param name="dispatcher">Http dispatcher responsible for handling incoming requests.</param>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "The configuration object is disposed as part of this class.")]
        public HttpServer(HttpMessageHandler dispatcher)
            : this(new HttpConfiguration(), dispatcher)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpServer"/> class.
        /// </summary>
        /// <param name="configuration">The <see cref="HttpConfiguration"/> used to configure this <see cref="HttpServer"/> instance.</param>
        /// <param name="dispatcher">Http dispatcher responsible for handling incoming requests.</param>
        [SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "principal",
            Justification = "Must access Thread.CurrentPrincipal to work around problem in .NET 4.5")]
        public HttpServer(HttpConfiguration configuration, HttpMessageHandler dispatcher)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            if (dispatcher == null)
            {
                throw Error.ArgumentNull("dispatcher");
            }

            // Read the thread principal to work around a problem up to .NET 4.5.1 that CurrentPrincipal creates a new instance each time it is read in async 
            // code if it has not been queried from the spawning thread.
            IPrincipal principal = Thread.CurrentPrincipal;

            _dispatcher = dispatcher;
            _configuration = configuration;
        }

        /// <summary>
        /// Gets the dispatcher.
        /// </summary>
        public HttpMessageHandler Dispatcher
        {
            get { return _dispatcher; }
        }

        /// <summary>
        /// Gets the <see cref="HttpConfiguration"/>.
        /// </summary>
        public HttpConfiguration Configuration
        {
            get { return _configuration; }
        }

        /// <remarks>This property is settable only for unit testing purposes.</remarks>
        internal IExceptionLogger ExceptionLogger
        {
            get
            {
                if (_exceptionLogger == null)
                {
                    _exceptionLogger = ExceptionServices.GetLogger(_configuration);
                }

                return _exceptionLogger;
            }
            set
            {
                _exceptionLogger = value;
            }
        }

        /// <remarks>This property is settable only for unit testing purposes.</remarks>
        internal IExceptionHandler ExceptionHandler
        {
            get
            {
                if (_exceptionHandler == null)
                {
                    _exceptionHandler = ExceptionServices.GetHandler(_configuration);
                }

                return _exceptionHandler;
            }
            set
            {
                _exceptionHandler = value;
            }
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged SRResources.</param>
        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                _disposed = true;
                if (disposing)
                {
                    _configuration.Dispose();
                }
            }

            base.Dispose(disposing);
        }

        /// <summary>
        /// Dispatches an incoming <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="request">The request to dispatch</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A <see cref="Task{HttpResponseMessage}"/> representing the ongoing operation.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller becomes owner.")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "we are converting exceptions to error responses.")]
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (_disposed)
            {
                return request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, SRResources.HttpServerDisposed);
            }

            // The first request initializes the server
            EnsureInitialized();

            // Capture current synchronization context and add it as a parameter to the request
            SynchronizationContext context = SynchronizationContext.Current;
            if (context != null)
            {
                request.SetSynchronizationContext(context);
            }

            // Add HttpConfiguration object as a parameter to the request 
            request.SetConfiguration(_configuration);

            // Ensure we have a principal, even if the host didn't give us one
            IPrincipal originalPrincipal = Thread.CurrentPrincipal;
            if (originalPrincipal == null)
            {
                Thread.CurrentPrincipal = _anonymousPrincipal;
            }

            // Ensure we have a principal on the request context (if there is a request context).
            HttpRequestContext requestContext = request.GetRequestContext();

            if (requestContext == null)
            {
                requestContext = new RequestBackedHttpRequestContext(request);

                // if the host did not set a request context we will also set it back to the request.
                request.SetRequestContext(requestContext);
            }

            try
            {
                ExceptionDispatchInfo exceptionInfo;

                try
                {
                    return await base.SendAsync(request, cancellationToken);
                }
                catch (OperationCanceledException)
                {
                    // Propogate the canceled task without calling exception loggers or handlers.
                    throw;
                }
                catch (HttpResponseException exception)
                {
                    return exception.Response;
                }
                catch (Exception exception)
                {
                    exceptionInfo = ExceptionDispatchInfo.Capture(exception);
                }

                Debug.Assert(exceptionInfo.SourceException != null);

                ExceptionContext exceptionContext = new ExceptionContext(exceptionInfo.SourceException,
                    ExceptionCatchBlocks.HttpServer, request);
                await ExceptionLogger.LogAsync(exceptionContext, cancellationToken);
                HttpResponseMessage response = await ExceptionHandler.HandleAsync(exceptionContext,
                    cancellationToken);

                if (response == null)
                {
                    exceptionInfo.Throw();
                }

                return response;
            }
            finally
            {
                Thread.CurrentPrincipal = originalPrincipal;
            }
        }

        private void EnsureInitialized()
        {
            LazyInitializer.EnsureInitialized(ref _initializationTarget, ref _initialized, ref _initializationLock, () =>
            {
                Initialize();
                return null;
            });
        }

        /// <summary>
        /// Prepares the server for operation.
        /// </summary>
        /// <remarks>
        /// This method must be called after all configuration is complete
        /// but before the first request is processed.
        /// </remarks>
        protected virtual void Initialize()
        {
            // Do final initialization of the configuration.
            // It is considered immutable from this point forward.
            _configuration.EnsureInitialized();

            // Create pipeline
            InnerHandler = HttpClientFactory.CreatePipeline(_dispatcher, _configuration.MessageHandlers);
        }

        private static HttpConfiguration EnsureNonNull(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            return configuration;
        }
    }
}


================================================
FILE: src/System.Web.Http/IHttpActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http
{
    /// <summary>Defines a command that asynchronously creates an <see cref="HttpResponseMessage"/>.</summary>
    public interface IHttpActionResult
    {
        /// <summary>Creates an <see cref="HttpResponseMessage"/> asynchronously.</summary>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>A task that, when completed, contains the <see cref="HttpResponseMessage"/>.</returns>
        Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken);
    }
}


================================================
FILE: src/System.Web.Http/IncludeErrorDetailPolicy.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    /// <summary>
    /// Enum to indicate whether error details, such as exception messages and stack traces, should be included in error messages.
    /// </summary>
    public enum IncludeErrorDetailPolicy
    {
        /// <summary>
        /// Default to the host specific behavior. This looks at the CustomErrors setting on webhost and
        /// defaults to LocalOnly in selfhost.
        /// </summary>
        Default = 0,

        /// <summary>
        /// Only include error details when responding to a local request.
        /// </summary>
        LocalOnly,

        /// <summary>
        /// Always include error details.
        /// </summary>
        Always,

        /// <summary>
        /// Never include error details.
        /// </summary>
        Never
    }
}


================================================
FILE: src/System.Web.Http/Internal/CollectionModelBinderUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.Internal
{
    internal static class CollectionModelBinderUtil
    {
        internal static void CreateOrReplaceCollection<TElement>(ModelBindingContext bindingContext, IEnumerable<TElement> incomingElements, Func<ICollection<TElement>> creator)
        {
            ICollection<TElement> collection = bindingContext.Model as ICollection<TElement>;
            if (collection == null || collection.IsReadOnly)
            {
                collection = creator();
                bindingContext.Model = collection;
            }

            collection.Clear();
            foreach (TElement element in incomingElements)
            {
                collection.Add(element);
            }
        }

        internal static void CreateOrReplaceDictionary<TKey, TValue>(ModelBindingContext bindingContext, IEnumerable<KeyValuePair<TKey, TValue>> incomingElements, Func<IDictionary<TKey, TValue>> creator)
        {
            IDictionary<TKey, TValue> dictionary = bindingContext.Model as IDictionary<TKey, TValue>;
            if (dictionary == null || dictionary.IsReadOnly)
            {
                dictionary = creator();
                bindingContext.Model = dictionary;
            }

            dictionary.Clear();
            foreach (var element in incomingElements)
            {
                if (element.Key != null)
                {
                    dictionary[element.Key] = element.Value;
                }
            }
        }

        /// <summary>
        /// Instantiate a generic binder.
        /// </summary>
        /// <param name="supportedInterfaceType">Type that is updatable by this binder.</param>
        /// <param name="newInstanceType">Type that will be created by the binder if necessary.</param>
        /// <param name="openBinderType">Model binder type.</param>
        /// <param name="modelType">Model type.</param>
        /// <returns></returns>
        // Example: GetGenericBinder(typeof(IList<>), typeof(List<>), typeof(ListBinder<>), ...) means that the ListBinder<T>
        // type can update models that implement IList<T>, and if for some reason the existing model instance is not
        // updatable the binder will create a List<T> object and bind to that instead. This method will return a ListBinder<T>
        // or null, depending on whether the type and updatability checks succeed.
        internal static IModelBinder GetGenericBinder(Type supportedInterfaceType, Type newInstanceType, Type openBinderType, Type modelType)
        {
            Contract.Assert(supportedInterfaceType != null);
            Contract.Assert(openBinderType != null);
            Contract.Assert(modelType != null);

            Type[] modelTypeArguments = GetGenericBinderTypeArgs(supportedInterfaceType, modelType);

            if (modelTypeArguments == null)
            {
                return null;
            }

            Type closedNewInstanceType = newInstanceType.MakeGenericType(modelTypeArguments);
            if (!modelType.IsAssignableFrom(closedNewInstanceType))
            {
                return null;
            }

            Type closedBinderType = openBinderType.MakeGenericType(modelTypeArguments);
            var binder = (IModelBinder)Activator.CreateInstance(closedBinderType);
            return binder;
        }

        // Get the generic arguments for the binder, based on the model type. Or null if not compatible.
        internal static Type[] GetGenericBinderTypeArgs(Type supportedInterfaceType, Type modelType)
        {
            if (!modelType.IsGenericType || modelType.IsGenericTypeDefinition)
            {
                // not a closed generic type
                return null;
            }

            Type[] modelTypeArguments = modelType.GetGenericArguments();
            if (modelTypeArguments.Length != supportedInterfaceType.GetGenericArguments().Length)
            {
                // wrong number of generic type arguments
                return null;
            }

            return modelTypeArguments;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Http.ValueProviders.ValueProviderResult.ConvertTo(System.Type)", Justification = "The ValueProviderResult already has the necessary context to perform a culture-aware conversion.")]
        internal static IEnumerable<string> GetIndexNamesFromValueProviderResult(ValueProviderResult valueProviderResultIndex)
        {
            IEnumerable<string> indexNames = null;
            if (valueProviderResultIndex != null)
            {
                string[] indexes = (string[])valueProviderResultIndex.ConvertTo(typeof(string[]));
                if (indexes != null && indexes.Length > 0)
                {
                    indexNames = indexes;
                }
            }
            return indexNames;
        }

        internal static IEnumerable<string> GetZeroBasedIndexes()
        {
            int i = 0;
            while (true)
            {
                yield return i.ToString(CultureInfo.InvariantCulture);
                i++;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Internal/HttpParameterBindingExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.Internal
{
    internal static class HttpParameterBindingExtensions
    {
        public static bool WillReadUri(this HttpParameterBinding parameterBinding)
        {
            if (parameterBinding == null)
            {
                throw Error.ArgumentNull("parameterBinding");
            }

            IValueProviderParameterBinding valueProviderParameterBinding = parameterBinding as IValueProviderParameterBinding;
            if (valueProviderParameterBinding != null)
            {
                IEnumerable<ValueProviderFactory> valueProviderFactories = valueProviderParameterBinding.ValueProviderFactories;
                if (valueProviderFactories.Any() && valueProviderFactories.All(factory => factory is IUriValueProviderFactory))
                {
                    return true;
                }
            }

            return false;
        }
    }
}


================================================
FILE: src/System.Web.Http/Internal/MemberInfoExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Http.Internal
{
    internal static class MemberInfoExtensions
    {
        public static TAttribute[] GetCustomAttributes<TAttribute>(this MemberInfo member, bool inherit) where TAttribute : class
        {
            if (member == null)
            {
                throw Error.ArgumentNull("member");
            }

            return (TAttribute[])member.GetCustomAttributes(typeof(TAttribute), inherit);
        }
    }
}


================================================
FILE: src/System.Web.Http/Internal/ParameterInfoExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Reflection;

namespace System.Web.Http.Internal
{
    internal static class ParameterInfoExtensions
    {
        public static bool TryGetDefaultValue(this ParameterInfo parameterInfo, out object value)
        {
            if (parameterInfo == null)
            {
                throw Error.ArgumentNull("parameterInfo");
            }

            // this will get the default value as seen by the VB / C# compilers
            // if no value was baked in, RawDefaultValue returns DBNull.Value
            object defaultValue = parameterInfo.DefaultValue;
            if (defaultValue != DBNull.Value)
            {
                value = defaultValue;
                return true;
            }

            // if the compiler did not bake in a default value, check the [DefaultValue] attribute
            DefaultValueAttribute[] attrs = (DefaultValueAttribute[])parameterInfo.GetCustomAttributes(typeof(DefaultValueAttribute), false);
            if (attrs == null || attrs.Length == 0)
            {
                value = default(object);
                return false;
            }
            else
            {
                value = attrs[0].Value;
                return true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Internal/TypeActivator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Linq.Expressions;

namespace System.Web.Http.Internal
{
    internal static class TypeActivator
    {
        public static Func<TBase> Create<TBase>(Type instanceType) where TBase : class
        {
            Contract.Assert(instanceType != null);
            NewExpression newInstanceExpression = Expression.New(instanceType);
            return Expression.Lambda<Func<TBase>>(newInstanceExpression).Compile();
        }

        public static Func<TInstance> Create<TInstance>() where TInstance : class
        {
            return Create<TInstance>(typeof(TInstance));
        }

        public static Func<object> Create(Type instanceType)
        {
            Contract.Assert(instanceType != null);
            return Create<object>(instanceType);
        }
    }
}


================================================
FILE: src/System.Web.Http/Internal/TypeDescriptorHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Security;

namespace System.Web.Http.Internal
{
    internal static class TypeDescriptorHelper
    {
        internal static ICustomTypeDescriptor Get(Type type)
        {
            return new AssociatedMetadataTypeTypeDescriptionProvider(type).GetTypeDescriptor(type);
        }
    }
}


================================================
FILE: src/System.Web.Http/Internal/TypeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics.Contracts;
using System.Threading.Tasks;

namespace System.Web.Http.Internal
{
    /// <summary>
    /// A static class that provides various <see cref="Type"/> related helpers.
    /// </summary>
    internal static class TypeHelper
    {
        private static readonly Type TaskGenericType = typeof(Task<>);

        internal static readonly Type ApiControllerType = typeof(ApiController);

        internal static Type GetTaskInnerTypeOrNull(Type type)
        {
            Contract.Assert(type != null);
            if (type.IsGenericType && !type.IsGenericTypeDefinition)
            {
                Type genericTypeDefinition = type.GetGenericTypeDefinition();

                if (TaskGenericType == genericTypeDefinition)
                {
                    return type.GetGenericArguments()[0];
                }
            }

            return null;
        }

        internal static Type[] GetTypeArgumentsIfMatch(Type closedType, Type matchingOpenType)
        {
            if (!closedType.IsGenericType)
            {
                return null;
            }

            Type openType = closedType.GetGenericTypeDefinition();
            return (matchingOpenType == openType) ? closedType.GetGenericArguments() : null;
        }

        internal static bool IsCompatibleObject(Type type, object value)
        {
            return (value == null && TypeAllowsNullValue(type)) || type.IsInstanceOfType(value);
        }

        internal static bool IsNullableValueType(Type type)
        {
            return Nullable.GetUnderlyingType(type) != null;
        }

        internal static bool TypeAllowsNullValue(Type type)
        {
            return !type.IsValueType || IsNullableValueType(type);
        }

        internal static bool IsSimpleType(Type type)
        {
            return type.IsPrimitive ||
                   type.Equals(typeof(string)) ||
                   type.Equals(typeof(DateTime)) ||
                   type.Equals(typeof(Decimal)) ||
                   type.Equals(typeof(Guid)) ||
                   type.Equals(typeof(DateTimeOffset)) ||
                   type.Equals(typeof(TimeSpan));
        }

        internal static bool IsSimpleUnderlyingType(Type type)
        {
            Type underlyingType = Nullable.GetUnderlyingType(type);
            if (underlyingType != null)
            {
                type = underlyingType;
            }

            return TypeHelper.IsSimpleType(type);
        }

        internal static bool CanConvertFromString(Type type)
        {
            return TypeHelper.IsSimpleUnderlyingType(type) ||
                TypeHelper.HasStringConverter(type);
        }

        internal static bool HasStringConverter(Type type)
        {
            return TypeDescriptor.GetConverter(type).CanConvertFrom(typeof(string));
        }

        /// <summary>
        /// Fast implementation to get the subset of a given type.
        /// </summary>
        /// <typeparam name="T">type to search for</typeparam>
        /// <returns>subset of objects that can be assigned to T</returns>
        internal static ReadOnlyCollection<T> OfType<T>(object[] objects) where T : class
        {
            int max = objects.Length;
            List<T> list = new List<T>(max);
            int idx = 0;
            for (int i = 0; i < max; i++)
            {
                T attr = objects[i] as T;
                if (attr != null)
                {
                    list.Add(attr);
                    idx++;
                }
            }
            list.Capacity = idx;

            return new ReadOnlyCollection<T>(list);
        }
    }
}

================================================
FILE: src/System.Web.Http/Metadata/ModelMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http.Internal;
using System.Web.Http.Validation;

namespace System.Web.Http.Metadata
{
    public class ModelMetadata
    {
        private readonly Type _containerType;
        private readonly Type _modelType;
        private readonly string _propertyName;
        private EfficientTypePropertyKey<Type, string> _cacheKey;

        /// <summary>
        /// Explicit backing store for the things we want initialized by default, so don't have to call
        /// the protected virtual setters of an auto-generated property.
        /// </summary>
        private Dictionary<string, object> _additionalValues;
        private bool _convertEmptyStringToNull = true;
        private object _model;
        private Func<object> _modelAccessor;
        private IEnumerable<ModelMetadata> _properties;
        private Type _realModelType;

        public ModelMetadata(ModelMetadataProvider provider, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
        {
            if (provider == null)
            {
                throw Error.ArgumentNull("provider");
            }
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }

            Provider = provider;

            _containerType = containerType;
            _modelAccessor = modelAccessor;
            _modelType = modelType;
            _propertyName = propertyName;
        }

        internal ModelMetadata(ModelMetadataProvider provider, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName, EfficientTypePropertyKey<Type, string> cacheKey)
            : this(provider, containerType, modelAccessor, modelType, propertyName)
        {
            if (cacheKey == null)
            {
                throw Error.ArgumentNull("cacheKey");
            }

            _cacheKey = cacheKey;
        }

        public virtual Dictionary<string, object> AdditionalValues
        {
            get
            {
                if (_additionalValues == null)
                {
                    _additionalValues = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
                }

                return _additionalValues;
            }
        }

        public Type ContainerType
        {
            get { return _containerType; }
        }

        public virtual bool ConvertEmptyStringToNull
        {
            get { return _convertEmptyStringToNull; }
            set { _convertEmptyStringToNull = value; }
        }

        public virtual string Description { get; set; }

        public virtual bool IsComplexType
        {
            get { return !TypeHelper.HasStringConverter(ModelType); }
        }

        public bool IsNullableValueType
        {
            get { return TypeHelper.IsNullableValueType(ModelType); }
        }

        public virtual bool IsReadOnly { get; set; }

        public object Model
        {
            get
            {
                if (_modelAccessor != null)
                {
                    _model = _modelAccessor();
                    _modelAccessor = null;
                }
                return _model;
            }
            set
            {
                _model = value;
                _modelAccessor = null;
                _properties = null;
                _realModelType = null;
            }
        }

        public Type ModelType
        {
            get { return _modelType; }
        }

        public virtual IEnumerable<ModelMetadata> Properties
        {
            get
            {
                if (_properties == null)
                {
                    _properties = Provider.GetMetadataForProperties(Model, RealModelType);
                }
                return _properties;
            }
        }

        public string PropertyName
        {
            get { return _propertyName; }
        }

        protected ModelMetadataProvider Provider { get; set; }

        internal Type RealModelType
        {
            get
            {
                if (_realModelType == null)
                {
                    _realModelType = ModelType;

                    // Don't call GetType() if the model is Nullable<T>, because it will
                    // turn Nullable<T> into T for non-null values
                    if (Model != null && !TypeHelper.IsNullableValueType(ModelType))
                    {
                        _realModelType = Model.GetType();
                    }
                }

                return _realModelType;
            }
        }

        internal EfficientTypePropertyKey<Type, string> CacheKey
        {
            get
            {
                if (_cacheKey == null)
                {
                    _cacheKey = CreateCacheKey(ContainerType, ModelType, PropertyName);
                }

                return _cacheKey;
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "The method is a delegating helper to choose among multiple property values")]
        public virtual string GetDisplayName()
        {
            return PropertyName ?? ModelType.Name;
        }

        public virtual IEnumerable<ModelValidator> GetValidators(IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            if (validatorProviders == null)
            {
                throw Error.ArgumentNull("validatorProviders");
            }

            return validatorProviders.SelectMany(provider => provider.GetValidators(this, validatorProviders));
        }

        private static EfficientTypePropertyKey<Type, string> CreateCacheKey(Type containerType, Type modelType, string propertyName)
        {
            // If metadata is for a property then containerType != null && propertyName != null
            // If metadata is for a type then containerType == null && propertyName == null, so we have to use modelType for the cache key.
            return new EfficientTypePropertyKey<Type, string>(containerType ?? modelType, propertyName);
        }
    }
}


================================================
FILE: src/System.Web.Http/Metadata/ModelMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Metadata
{
    public abstract class ModelMetadataProvider
    {
        public abstract IEnumerable<ModelMetadata> GetMetadataForProperties(object container, Type containerType);

        public abstract ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, string propertyName);

        public abstract ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType);
    }
}


================================================
FILE: src/System.Web.Http/Metadata/Providers/AssociatedMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.Contracts;
using System.Reflection;
using System.Reflection.Emit;
using System.Web.Http.Internal;
using System.Web.Http.Properties;

namespace System.Web.Http.Metadata.Providers
{
    public abstract class AssociatedMetadataProvider<TModelMetadata> : ModelMetadataProvider
        where TModelMetadata : ModelMetadata
    {
        private ConcurrentDictionary<Type, TypeInformation> _typeInfoCache = new ConcurrentDictionary<Type, TypeInformation>();

        public sealed override IEnumerable<ModelMetadata> GetMetadataForProperties(object container, Type containerType)
        {
            if (containerType == null)
            {
                throw Error.ArgumentNull("containerType");
            }

            return GetMetadataForPropertiesImpl(container, containerType);
        }

        private IEnumerable<ModelMetadata> GetMetadataForPropertiesImpl(object container, Type containerType)
        {
            TypeInformation typeInfo = GetTypeInformation(containerType);
            foreach (KeyValuePair<string, PropertyInformation> kvp in typeInfo.Properties)
            {
                PropertyInformation propertyInfo = kvp.Value;
                Func<object> modelAccessor = null;
                if (container != null)
                {
                    Func<object, object> propertyGetter = propertyInfo.ValueAccessor;
                    modelAccessor = () => propertyGetter(container);
                }
                yield return CreateMetadataFromPrototype(propertyInfo.Prototype, modelAccessor);
            }
        }

        public sealed override ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, string propertyName)
        {
            if (containerType == null)
            {
                throw Error.ArgumentNull("containerType");
            }
            if (String.IsNullOrEmpty(propertyName))
            {
                throw Error.ArgumentNullOrEmpty("propertyName");
            }

            TypeInformation typeInfo = GetTypeInformation(containerType);
            PropertyInformation propertyInfo;
            if (!typeInfo.Properties.TryGetValue(propertyName, out propertyInfo))
            {
                throw Error.Argument("propertyName", SRResources.Common_PropertyNotFound, containerType, propertyName);
            }

            return CreateMetadataFromPrototype(propertyInfo.Prototype, modelAccessor);
        }

        public sealed override ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType)
        {
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }

            TModelMetadata prototype = GetTypeInformation(modelType).Prototype;
            return CreateMetadataFromPrototype(prototype, modelAccessor);
        }

        // Override for creating the prototype metadata (without the accessor)
        protected abstract TModelMetadata CreateMetadataPrototype(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName);

        // Override for applying the prototype + modelAccess to yield the final metadata
        protected abstract TModelMetadata CreateMetadataFromPrototype(TModelMetadata prototype, Func<object> modelAccessor);

        private TypeInformation GetTypeInformation(Type type)
        {
            // This retrieval is implemented as a TryGetValue/TryAdd instead of a GetOrAdd to avoid the performance cost of creating instance delegates
            TypeInformation typeInfo;
            if (!_typeInfoCache.TryGetValue(type, out typeInfo))
            {
                typeInfo = CreateTypeInformation(type);
                _typeInfoCache.TryAdd(type, typeInfo);
            }
            return typeInfo;
        }

        private TypeInformation CreateTypeInformation(Type type)
        {
            TypeInformation info = new TypeInformation();
            ICustomTypeDescriptor typeDescriptor = TypeDescriptorHelper.Get(type);
            info.TypeDescriptor = typeDescriptor;
            info.Prototype = CreateMetadataPrototype(AsAttributes(typeDescriptor.GetAttributes()), containerType: null, modelType: type, propertyName: null);
            
            Dictionary<string, PropertyInformation> properties = new Dictionary<string, PropertyInformation>();
            foreach (PropertyDescriptor property in typeDescriptor.GetProperties())
            {
                // Avoid re-generating a property descriptor if one has already been generated for the property name
                if (!properties.ContainsKey(property.Name))
                {
                    properties.Add(property.Name, CreatePropertyInformation(type, property));
                }
            }
            info.Properties = properties;

            return info;
        }

        private PropertyInformation CreatePropertyInformation(Type containerType, PropertyDescriptor property)
        {
            PropertyInformation info = new PropertyInformation();
            info.ValueAccessor = CreatePropertyValueAccessor(property);
            info.Prototype = CreateMetadataPrototype(AsAttributes(property.Attributes), containerType, property.PropertyType, property.Name);
            return info;
        }

        // Optimization: yield provides much better performance than the LINQ .Cast<Attribute>() in this case
        private static IEnumerable<Attribute> AsAttributes(IEnumerable attributes)
        {
            foreach (object attribute in attributes)
            {
                yield return attribute as Attribute;
            }
        }

        private static Func<object, object> CreatePropertyValueAccessor(PropertyDescriptor property)
        {
            Type declaringType = property.ComponentType;
            if (declaringType.IsVisible)
            {
                string propertyName = property.Name;
                PropertyInfo propertyInfo = declaringType.GetProperty(propertyName, property.PropertyType);

                if (propertyInfo != null && propertyInfo.CanRead)
                {
                    MethodInfo getMethodInfo = propertyInfo.GetGetMethod();
                    if (getMethodInfo != null)
                    {
                        return CreateDynamicValueAccessor(getMethodInfo, declaringType, propertyName);
                    }
                }
            }

            // If either the type isn't public or we can't find a public getter, use the slow Reflection path
            return container => property.GetValue(container);
        }

        // Uses Lightweight Code Gen to generate a tiny delegate that gets the property value
        // This is an optimization to avoid having to go through the much slower System.Reflection APIs
        // e.g. generates (object o) => (Person)o.Id
        private static Func<object, object> CreateDynamicValueAccessor(MethodInfo getMethodInfo, Type declaringType, string propertyName)
        {
            Contract.Assert(getMethodInfo != null && getMethodInfo.IsPublic && !getMethodInfo.IsStatic);

            Type propertyType = getMethodInfo.ReturnType;
            DynamicMethod dynamicMethod = new DynamicMethod("Get" + propertyName + "From" + declaringType.Name, typeof(object), new Type[] { typeof(object) });
            ILGenerator ilg = dynamicMethod.GetILGenerator();

            // Load the container onto the stack, convert from object => declaring type for the property
            ilg.Emit(OpCodes.Ldarg_0);
            if (declaringType.IsValueType)
            {
                ilg.Emit(OpCodes.Unbox, declaringType);
            }
            else
            {
                ilg.Emit(OpCodes.Castclass, declaringType);
            }

            // if declaring type is value type, we use Call : structs don't have inheritance
            // if get method is sealed or isn't virtual, we use Call : it can't be overridden
            if (declaringType.IsValueType || !getMethodInfo.IsVirtual || getMethodInfo.IsFinal)
            {
                ilg.Emit(OpCodes.Call, getMethodInfo);
            }
            else
            {
                ilg.Emit(OpCodes.Callvirt, getMethodInfo);
            }

            // Box if the property type is a value type, so it can be returned as an object
            if (propertyType.IsValueType)
            {
                ilg.Emit(OpCodes.Box, propertyType);
            }

            // Return property value
            ilg.Emit(OpCodes.Ret);

            return (Func<object, object>)dynamicMethod.CreateDelegate(typeof(Func<object, object>));
        }

        private class TypeInformation
        {
            public ICustomTypeDescriptor TypeDescriptor { get; set; }
            public TModelMetadata Prototype { get; set; }
            public Dictionary<string, PropertyInformation> Properties { get; set; }
        }

        private class PropertyInformation
        {
            public Func<object, object> ValueAccessor { get; set; }
            public TModelMetadata Prototype { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.Http/Metadata/Providers/CachedDataAnnotationsMetadataAttributes.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Security;

namespace System.Web.Http.Metadata.Providers
{
    public class CachedDataAnnotationsMetadataAttributes
    {
        public CachedDataAnnotationsMetadataAttributes(IEnumerable<Attribute> attributes)
        {
            Display = attributes.OfType<DisplayAttribute>().FirstOrDefault();
            DisplayFormat = attributes.OfType<DisplayFormatAttribute>().FirstOrDefault();
            DisplayName = attributes.OfType<DisplayNameAttribute>().FirstOrDefault();
            Editable = attributes.OfType<EditableAttribute>().FirstOrDefault();
            ReadOnly = attributes.OfType<ReadOnlyAttribute>().FirstOrDefault();
        }

        public DisplayAttribute Display { get; protected set; }

        public DisplayNameAttribute DisplayName { get; protected set; }

        public DisplayFormatAttribute DisplayFormat { get; protected set; }

        public EditableAttribute Editable { get; protected set; }

        public ReadOnlyAttribute ReadOnly { get; protected set; }
    }
}


================================================
FILE: src/System.Web.Http/Metadata/Providers/CachedDataAnnotationsModelMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Metadata.Providers
{
    // REVIEW: No access to HiddenInputAttribute
    public class CachedDataAnnotationsModelMetadata : CachedModelMetadata<CachedDataAnnotationsMetadataAttributes>
    {
        public CachedDataAnnotationsModelMetadata(CachedDataAnnotationsModelMetadata prototype, Func<object> modelAccessor)
            : base(prototype, modelAccessor)
        {
        }

        public CachedDataAnnotationsModelMetadata(DataAnnotationsModelMetadataProvider provider, Type containerType, Type modelType, string propertyName, IEnumerable<Attribute> attributes)
            : base(provider, containerType, modelType, propertyName, new CachedDataAnnotationsMetadataAttributes(attributes))
        {
        }

        protected override bool ComputeConvertEmptyStringToNull()
        {
            return PrototypeCache.DisplayFormat != null
                       ? PrototypeCache.DisplayFormat.ConvertEmptyStringToNull
                       : base.ComputeConvertEmptyStringToNull();
        }

        protected override string ComputeDescription()
        {
            return PrototypeCache.Display != null
                       ? PrototypeCache.Display.GetDescription()
                       : base.ComputeDescription();
        }

        protected override bool ComputeIsReadOnly()
        {
            if (PrototypeCache.Editable != null)
            {
                return !PrototypeCache.Editable.AllowEdit;
            }

            if (PrototypeCache.ReadOnly != null)
            {
                return PrototypeCache.ReadOnly.IsReadOnly;
            }

            return base.ComputeIsReadOnly();
        }

        public override string GetDisplayName()
        {
            // DisplayName could be provided by either the DisplayAttribute, or DisplayNameAttribute. If neither of
            // those supply a name, then we fall back to the property name (in base.GetDisplayName()).
            // 
            // DisplayName has lower precedence than Display.Name, for consistency with MVC.

            // DisplayAttribute doesn't require you to set a name, so this could be null. 
            if (PrototypeCache.Display != null)
            {
                string name = PrototypeCache.Display.GetName();
                if (name != null)
                {
                    return name;
                }
            }

            // It's also possible for DisplayNameAttribute to be used without setting a name. If a user does that, then DisplayName will
            // return the empty string - but for consistency with MVC we allow it. We do fallback to the property name in the (unlikely)
            // scenario that the user sets null as the DisplayName, again, for consistency with MVC.
            if (PrototypeCache.DisplayName != null)
            {
                string name = PrototypeCache.DisplayName.DisplayName;
                if (name != null)
                {
                    return name;
                }
            }

            // If neither attribute specifies a name, we'll fall back to the property name.
            return base.GetDisplayName();
        }
    }
}


================================================
FILE: src/System.Web.Http/Metadata/Providers/CachedModelMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Metadata.Providers
{
    // This class assumes that model metadata is expensive to create, and allows the user to
    // stash a cache object that can be copied around as a prototype to make creation and
    // computation quicker. It delegates the retrieval of values to getter methods, the results
    // of which are cached on a per-metadata-instance basis.
    //
    // This allows flexible caching strategies: either caching the source of information across
    // instances or caching of the actual information itself, depending on what the developer
    // decides to put into the prototype cache.
    public abstract class CachedModelMetadata<TPrototypeCache> : ModelMetadata
    {
        private bool _convertEmptyStringToNull;
        private string _description;
        private bool _isReadOnly;
        private bool _isComplexType;

        private bool _convertEmptyStringToNullComputed;
        private bool _descriptionComputed;
        private bool _isReadOnlyComputed;
        private bool _isComplexTypeComputed;

        // Constructor for creating real instances of the metadata class based on a prototype
        protected CachedModelMetadata(CachedModelMetadata<TPrototypeCache> prototype, Func<object> modelAccessor)
            : base(prototype.Provider, prototype.ContainerType, modelAccessor, prototype.ModelType, prototype.PropertyName, prototype.CacheKey)
        {
            PrototypeCache = prototype.PrototypeCache;

            _isComplexType = prototype.IsComplexType;
            _isComplexTypeComputed = true;
        }

        // Constructor for creating the prototype instances of the metadata class
        protected CachedModelMetadata(DataAnnotationsModelMetadataProvider provider, Type containerType, Type modelType, string propertyName, TPrototypeCache prototypeCache)
            : base(provider, containerType, null /* modelAccessor */, modelType, propertyName)
        {
            PrototypeCache = prototypeCache;
        }

        public sealed override bool ConvertEmptyStringToNull
        {
            get
            {
                if (!_convertEmptyStringToNullComputed)
                {
                    _convertEmptyStringToNull = ComputeConvertEmptyStringToNull();
                    _convertEmptyStringToNullComputed = true;
                }
                return _convertEmptyStringToNull;
            }
            set
            {
                _convertEmptyStringToNull = value;
                _convertEmptyStringToNullComputed = true;
            }
        }

        public sealed override string Description
        {
            get
            {
                if (!_descriptionComputed)
                {
                    _description = ComputeDescription();
                    _descriptionComputed = true;
                }
                return _description;
            }
            set
            {
                _description = value;
                _descriptionComputed = true;
            }
        }

        public sealed override bool IsReadOnly
        {
            get
            {
                if (!_isReadOnlyComputed)
                {
                    _isReadOnly = ComputeIsReadOnly();
                    _isReadOnlyComputed = true;
                }
                return _isReadOnly;
            }
            set
            {
                _isReadOnly = value;
                _isReadOnlyComputed = true;
            }
        }

        public sealed override bool IsComplexType
        {
            get
            {
                if (!_isComplexTypeComputed)
                {
                    _isComplexType = ComputeIsComplexType();
                    _isComplexTypeComputed = true;
                }
                return _isComplexType;
            }
        }

        protected TPrototypeCache PrototypeCache { get; set; }

        protected virtual bool ComputeConvertEmptyStringToNull()
        {
            return base.ConvertEmptyStringToNull;
        }

        protected virtual string ComputeDescription()
        {
            return base.Description;
        }

        protected virtual bool ComputeIsReadOnly()
        {
            return base.IsReadOnly;
        }

        protected virtual bool ComputeIsComplexType()
        {
            return base.IsComplexType;
        }
    }
}


================================================
FILE: src/System.Web.Http/Metadata/Providers/DataAnnotationsModelMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Metadata.Providers
{
    public class DataAnnotationsModelMetadataProvider : AssociatedMetadataProvider<CachedDataAnnotationsModelMetadata>
    {
        protected override CachedDataAnnotationsModelMetadata CreateMetadataPrototype(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName)
        {
            return new CachedDataAnnotationsModelMetadata(this, containerType, modelType, propertyName, attributes);
        }

        protected override CachedDataAnnotationsModelMetadata CreateMetadataFromPrototype(CachedDataAnnotationsModelMetadata prototype, Func<object> modelAccessor)
        {
            return new CachedDataAnnotationsModelMetadata(prototype, modelAccessor);
        }
    }
}


================================================
FILE: src/System.Web.Http/Metadata/Providers/EmptyMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Metadata.Providers
{
    public class EmptyModelMetadataProvider : AssociatedMetadataProvider<ModelMetadata>
    {
        protected override ModelMetadata CreateMetadataPrototype(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName)
        {
            return new ModelMetadata(this, containerType, null, modelType, propertyName);
        }

        protected override ModelMetadata CreateMetadataFromPrototype(ModelMetadata prototype, Func<object> modelAccessor)
        {
            return new ModelMetadata(this, prototype.ContainerType, modelAccessor, prototype.ModelType, prototype.PropertyName);
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/ArrayModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    public class ArrayModelBinder<TElement> : CollectionModelBinder<TElement>
    {
        public override bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            if (bindingContext.ModelMetadata.IsReadOnly)
            {
                return false;
            }

            return base.BindModel(actionContext, bindingContext);
        }

        protected override bool CreateOrReplaceCollection(HttpActionContext actionContext, ModelBindingContext bindingContext, IList<TElement> newCollection)
        {
            bindingContext.Model = newCollection.ToArray();
            return true;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/ArrayModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class ArrayModelBinderProvider : ModelBinderProvider
    {
        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }

            if (!modelType.IsArray)
            {
                return null;
            }

            Type elementType = modelType.GetElementType();
            return (IModelBinder)Activator.CreateInstance(typeof(ArrayModelBinder<>).MakeGenericType(elementType));
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/CollectionModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;

namespace System.Web.Http.ModelBinding.Binders
{
    public class CollectionModelBinder<TElement> : IModelBinder
    {
        // Used when the ValueProvider contains the collection to be bound as multiple elements, e.g. foo[0], foo[1].
        private static List<TElement> BindComplexCollection(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            string indexPropertyName = ModelBindingHelper.CreatePropertyModelName(bindingContext.ModelName, "index");
            ValueProviderResult valueProviderResultIndex = bindingContext.ValueProvider.GetValue(indexPropertyName);
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(valueProviderResultIndex);
            return BindComplexCollectionFromIndexes(actionContext, bindingContext, indexNames);
        }

        internal static List<TElement> BindComplexCollectionFromIndexes(HttpActionContext actionContext, ModelBindingContext bindingContext, IEnumerable<string> indexNames)
        {
            bool indexNamesIsFinite;
            if (indexNames != null)
            {
                indexNamesIsFinite = true;
            }
            else
            {
                indexNamesIsFinite = false;
                indexNames = CollectionModelBinderUtil.GetZeroBasedIndexes();
            }

            List<TElement> boundCollection = new List<TElement>();
            foreach (string indexName in indexNames)
            {
                string fullChildName = ModelBindingHelper.CreateIndexModelName(bindingContext.ModelName, indexName);
                ModelBindingContext childBindingContext = new ModelBindingContext(bindingContext)
                {
                    ModelMetadata = actionContext.GetMetadataProvider().GetMetadataForType(null, typeof(TElement)),
                    ModelName = fullChildName
                };

                bool didBind = false;
                object boundValue = null;                
                if (actionContext.Bind(childBindingContext))                
                {
                    didBind = true;
                    boundValue = childBindingContext.Model;

                    // merge validation up
                    bindingContext.ValidationNode.ChildNodes.Add(childBindingContext.ValidationNode);
                }                

                // infinite size collection stops on first bind failure
                if (!didBind && !indexNamesIsFinite)
                {
                    break;
                }

                boundCollection.Add(ModelBindingHelper.CastOrDefault<TElement>(boundValue));
            }

            return boundCollection;
        }

        public virtual bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            ModelBindingHelper.ValidateBindingContext(bindingContext);

            if (!bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
            {
                return false;
            }

            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            List<TElement> boundCollection = (valueProviderResult != null)
                                                 ? BindSimpleCollection(actionContext, bindingContext, valueProviderResult.RawValue, valueProviderResult.Culture)
                                                 : BindComplexCollection(actionContext, bindingContext);

            bool retVal = CreateOrReplaceCollection(actionContext, bindingContext, boundCollection);
            return retVal;
        }

        // Used when the ValueProvider contains the collection to be bound as a single element, e.g. the raw value
        // is [ "1", "2" ] and needs to be converted to an int[].
        internal static List<TElement> BindSimpleCollection(HttpActionContext actionContext, ModelBindingContext bindingContext, object rawValue, CultureInfo culture)
        {
            if (rawValue == null)
            {
                return null; // nothing to do
            }

            List<TElement> boundCollection = new List<TElement>();

            object[] rawValueArray = ModelBindingHelper.RawValueToObjectArray(rawValue);
            foreach (object rawValueElement in rawValueArray)
            {
                ModelBindingContext innerBindingContext = new ModelBindingContext(bindingContext)
                {
                    ModelMetadata = actionContext.GetMetadataProvider().GetMetadataForType(null, typeof(TElement)),
                    ModelName = bindingContext.ModelName,
                    ValueProvider = new CompositeValueProvider
                    {
                        new ElementalValueProvider(bindingContext.ModelName, rawValueElement, culture), // our temporary provider goes at the front of the list
                        bindingContext.ValueProvider
                    }
                };

                object boundValue = null;
                if (actionContext.Bind(innerBindingContext))                
                {
                    boundValue = innerBindingContext.Model;
                    bindingContext.ValidationNode.ChildNodes.Add(innerBindingContext.ValidationNode);
                }                
                boundCollection.Add(ModelBindingHelper.CastOrDefault<TElement>(boundValue));
            }

            return boundCollection;
        }

        // Extensibility point that allows the bound collection to be manipulated or transformed before
        // being returned from the binder.
        protected virtual bool CreateOrReplaceCollection(HttpActionContext actionContext, ModelBindingContext bindingContext, IList<TElement> newCollection)
        {
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, newCollection, () => new List<TElement>());
            return true;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/CollectionModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class CollectionModelBinderProvider : ModelBinderProvider
    {
        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {            
            return CollectionModelBinderUtil.GetGenericBinder(typeof(ICollection<>), typeof(List<>), typeof(CollectionModelBinder<>), modelType); 
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/ComplexModelDto.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Http.Metadata;

namespace System.Web.Http.ModelBinding.Binders
{
    // Describes a complex model, but uses a collection rather than individual properties as the data store.
    public class ComplexModelDto
    {
        public ComplexModelDto(ModelMetadata modelMetadata, IEnumerable<ModelMetadata> propertyMetadata)
        {
            if (modelMetadata == null)
            {
                throw Error.ArgumentNull("modelMetadata");
            }

            if (propertyMetadata == null)
            {
                throw Error.ArgumentNull("propertyMetadata");
            }

            ModelMetadata = modelMetadata;
            PropertyMetadata = new Collection<ModelMetadata>(propertyMetadata.ToList());
            Results = new Dictionary<ModelMetadata, ComplexModelDtoResult>();
        }

        public ModelMetadata ModelMetadata { get; private set; }

        public Collection<ModelMetadata> PropertyMetadata { get; private set; }

        // Contains entries corresponding to each property against which binding was
        // attempted. If binding failed, the entry's value will be null. If binding
        // was never attempted, this dictionary will not contain a corresponding
        // entry.
        public IDictionary<ModelMetadata, ComplexModelDtoResult> Results { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/ComplexModelDtoModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class ComplexModelDtoModelBinder : IModelBinder
    {
        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(ComplexModelDto), false /* allowNullModel */);

            ComplexModelDto dto = (ComplexModelDto)bindingContext.Model;
            foreach (ModelMetadata propertyMetadata in dto.PropertyMetadata)
            {
                ModelBindingContext propertyBindingContext = new ModelBindingContext(bindingContext)
                {
                    ModelMetadata = propertyMetadata,
                    ModelName = ModelBindingHelper.CreatePropertyModelName(bindingContext.ModelName, propertyMetadata.PropertyName)
                };

                // bind and propagate the values
                // If we can't bind, then leave the result missing (don't add a null).
                if (actionContext.Bind(propertyBindingContext))
                {
                    dto.Results[propertyMetadata] = new ComplexModelDtoResult(propertyBindingContext.Model, propertyBindingContext.ValidationNode);
                }
            }

            return true;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/ComplexModelDtoModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    // Returns a binder that can bind ComplexModelDto objects.
    public sealed class ComplexModelDtoModelBinderProvider : ModelBinderProvider
    {
        // This is really just a simple binder.
        private static readonly SimpleModelBinderProvider _underlyingProvider = GetUnderlyingProvider();

        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            return _underlyingProvider.GetBinder(configuration, modelType);
        }

        private static SimpleModelBinderProvider GetUnderlyingProvider()
        {
            return new SimpleModelBinderProvider(typeof(ComplexModelDto), new ComplexModelDtoModelBinder())
            {
                SuppressPrefixCheck = true
            };
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/ComplexModelDtoResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Validation;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class ComplexModelDtoResult
    {
        public ComplexModelDtoResult(object model, ModelValidationNode validationNode)
        {
            if (validationNode == null)
            {
                throw Error.ArgumentNull("validationNode");
            }

            Model = model;
            ValidationNode = validationNode;
        }

        public object Model { get; private set; }

        public ModelValidationNode ValidationNode { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/CompositeModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    /// <summary>
    /// This class is an <see cref="IModelBinder"/> that delegates to one of a collection of
    /// <see cref="ModelBinderProvider"/> instances.
    /// </summary>
    /// <remarks>
    /// If no binder is available and the <see cref="ModelBindingContext"/> allows it,
    /// this class tries to find a binder using an empty prefix.
    /// </remarks>
    public class CompositeModelBinder : IModelBinder
    {
        public CompositeModelBinder(IEnumerable<IModelBinder> binders)
            : this(binders.ToArray())
        {
        }

        public CompositeModelBinder(params IModelBinder[] binders)
        {
            Binders = binders;
        }

        private IModelBinder[] Binders { get; set; }

        public virtual bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            ModelBindingContext newBindingContext = CreateNewBindingContext(bindingContext, bindingContext.ModelName);

            bool boundSuccessfully = TryBind(actionContext, newBindingContext);
            if (!boundSuccessfully && !String.IsNullOrEmpty(bindingContext.ModelName)
                && bindingContext.FallbackToEmptyPrefix)
            {
                // fallback to empty prefix?
                newBindingContext = CreateNewBindingContext(bindingContext, modelName: String.Empty);
                boundSuccessfully = TryBind(actionContext, newBindingContext);
            }

            if (!boundSuccessfully)
            {
                return false; // something went wrong
            }

            // run validation and return the model
            // If we fell back to an empty prefix above and are dealing with simple types,
            // propagate the non-blank model name through for user clarity in validation errors.
            // Complex types will reveal their individual properties as model names and do not require this.
            if (!newBindingContext.ModelMetadata.IsComplexType && String.IsNullOrEmpty(newBindingContext.ModelName))
            {
                newBindingContext.ValidationNode = new Validation.ModelValidationNode(newBindingContext.ModelMetadata, bindingContext.ModelName);
            }

            newBindingContext.ValidationNode.Validate(actionContext, null /* parentNode */);
            bindingContext.Model = newBindingContext.Model;
            return true;
        }

        private bool TryBind(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            return actionContext.Bind(bindingContext, Binders);
        }

        private static ModelBindingContext CreateNewBindingContext(ModelBindingContext oldBindingContext, string modelName)
        {
            ModelBindingContext newBindingContext = new ModelBindingContext
            {
                ModelMetadata = oldBindingContext.ModelMetadata,
                ModelName = modelName,
                ModelState = oldBindingContext.ModelState,
                ValueProvider = oldBindingContext.ValueProvider
            };

            // validation is expensive to create, so copy it over if we can
            if (Object.ReferenceEquals(modelName, oldBindingContext.ModelName))
            {
                newBindingContext.ValidationNode = oldBindingContext.ValidationNode;
            }

            return newBindingContext;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/CompositeModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class CompositeModelBinderProvider : ModelBinderProvider
    {
        private ModelBinderProvider[] _providers;

        public CompositeModelBinderProvider()
        {
        }

        public CompositeModelBinderProvider(IEnumerable<ModelBinderProvider> providers)
        {
            if (providers == null)
            {
                throw Error.ArgumentNull("providers");
            }

            _providers = providers.ToArray();
        }

        public IEnumerable<ModelBinderProvider> Providers
        {
            get { return _providers; }
        }

        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            IEnumerable<ModelBinderProvider> providers = _providers ?? configuration.Services.GetModelBinderProviders();

            // Pre-filter out any binders that we know can't match. 
            IEnumerable<IModelBinder> binders = from provider in providers 
                                                let binder = provider.GetBinder(configuration, modelType) 
                                                where binder != null 
                                                select binder;
            return new CompositeModelBinder(binders);
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/DictionaryModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;

namespace System.Web.Http.ModelBinding.Binders
{
    public class DictionaryModelBinder<TKey, TValue> : CollectionModelBinder<KeyValuePair<TKey, TValue>>
    {
        protected override bool CreateOrReplaceCollection(HttpActionContext actionContext, ModelBindingContext bindingContext, IList<KeyValuePair<TKey, TValue>> newCollection)
        {
            CollectionModelBinderUtil.CreateOrReplaceDictionary(bindingContext, newCollection, () => new Dictionary<TKey, TValue>());
            return true;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/DictionaryModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Internal;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class DictionaryModelBinderProvider : ModelBinderProvider
    {
        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            return CollectionModelBinderUtil.GetGenericBinder(typeof(IDictionary<,>), typeof(Dictionary<,>), typeof(DictionaryModelBinder<,>), modelType);
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/KeyValuePairModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.Metadata;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class KeyValuePairModelBinder<TKey, TValue> : IModelBinder
    {
        internal ModelMetadataProvider MetadataProvider { private get; set; }

        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            ModelMetadataProvider metadataProvider = MetadataProvider ?? actionContext.GetMetadataProvider();
            ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(KeyValuePair<TKey, TValue>), true /* allowNullModel */);

            TKey key;
            bool keyBindingSucceeded = actionContext.TryBindStrongModel(bindingContext, "key", metadataProvider, out key);

            TValue value;
            bool valueBindingSucceeded = actionContext.TryBindStrongModel(bindingContext, "value", metadataProvider, out value);

            if (keyBindingSucceeded && valueBindingSucceeded)
            {
                bindingContext.Model = new KeyValuePair<TKey, TValue>(key, value);
            }
            return keyBindingSucceeded || valueBindingSucceeded;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/KeyValuePairModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class KeyValuePairModelBinderProvider : ModelBinderProvider
    {
        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            return ModelBindingHelper.GetPossibleBinderInstance(
                closedModelType: modelType, 
                openModelType: typeof(KeyValuePair<,>), 
                openBinderType: typeof(KeyValuePairModelBinder<,>));
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/MutableObjectModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;
using System.Web.Http.Validation;

namespace System.Web.Http.ModelBinding.Binders
{
    public class MutableObjectModelBinder : IModelBinder
    {
        internal ModelMetadataProvider MetadataProvider { private get; set; }

        internal static bool CanBindType(Type modelType)
        {
            // Simple types cannot use this binder
            bool isComplexType = !TypeHelper.HasStringConverter(modelType);
            if (!isComplexType)
            {
                return false;
            }

            if (modelType == typeof(ComplexModelDto))
            {
                // forbidden type - will cause a stack overflow if we try binding this type
                return false;
            }
            return true;
        }

        public virtual bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            ModelBindingHelper.ValidateBindingContext(bindingContext);

            if (!bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
            {
                // no values to bind
                return false;
            }

            if (!CanBindType(bindingContext.ModelType))
            {
                return false;
            }

            EnsureModel(actionContext, bindingContext);
            IEnumerable<ModelMetadata> propertyMetadatas = GetMetadataForProperties(actionContext, bindingContext);
            ComplexModelDto dto = CreateAndPopulateDto(actionContext, bindingContext, propertyMetadatas);

            // post-processing, e.g. property setters and hooking up validation
            ProcessDto(actionContext, bindingContext, dto);
            bindingContext.ValidationNode.ValidateAllProperties = true; // complex models require full validation
            return true;
        }

        protected virtual bool CanUpdateProperty(ModelMetadata propertyMetadata)
        {
            return CanUpdatePropertyInternal(propertyMetadata);
        }

        internal static bool CanUpdatePropertyInternal(ModelMetadata propertyMetadata)
        {
            return !propertyMetadata.IsReadOnly || CanUpdateReadOnlyProperty(propertyMetadata.ModelType);
        }

        private static bool CanUpdateReadOnlyProperty(Type propertyType)
        {
            // Value types have copy-by-value semantics, which prevents us from updating
            // properties that are marked readonly.
            if (propertyType.IsValueType)
            {
                return false;
            }

            // Arrays are strange beasts since their contents are mutable but their sizes aren't.
            // Therefore we shouldn't even try to update these. Further reading:
            // http://blogs.msdn.com/ericlippert/archive/2008/09/22/arrays-considered-somewhat-harmful.aspx
            if (propertyType.IsArray)
            {
                return false;
            }

            // Special-case known immutable reference types
            if (propertyType == typeof(string))
            {
                return false;
            }

            return true;
        }

        private ComplexModelDto CreateAndPopulateDto(HttpActionContext actionContext, ModelBindingContext bindingContext, IEnumerable<ModelMetadata> propertyMetadatas)
        {
            ModelMetadataProvider metadataProvider = MetadataProvider ?? actionContext.GetMetadataProvider();

            // create a DTO and call into the DTO binder
            ComplexModelDto originalDto = new ComplexModelDto(bindingContext.ModelMetadata, propertyMetadatas);
            ModelBindingContext dtoBindingContext = new ModelBindingContext(bindingContext)
            {
                ModelMetadata = metadataProvider.GetMetadataForType(() => originalDto, typeof(ComplexModelDto)),
                ModelName = bindingContext.ModelName
            };

            actionContext.Bind(dtoBindingContext);
            return (ComplexModelDto)dtoBindingContext.Model;
        }

        protected virtual object CreateModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            // If the Activator throws an exception, we want to propagate it back up the call stack, since the application
            // developer should know that this was an invalid type to try to bind to.
            return Activator.CreateInstance(bindingContext.ModelType);
        }

        // Called when the property setter null check failed, allows us to add our own error message to ModelState.
        internal static EventHandler<ModelValidatedEventArgs> CreateNullCheckFailedHandler(ModelMetadata modelMetadata, object incomingValue)
        {
            return (sender, e) =>
            {
                ModelValidationNode validationNode = (ModelValidationNode)sender;
                ModelStateDictionary modelState = e.ActionContext.ModelState;

                if (modelState.IsValidField(validationNode.ModelStateKey))
                {
                    string errorMessage = ModelBinderConfig.ValueRequiredErrorMessageProvider(e.ActionContext, modelMetadata, incomingValue);
                    if (errorMessage != null)
                    {
                        modelState.AddModelError(validationNode.ModelStateKey, errorMessage);
                    }
                }
            };
        }

        protected virtual void EnsureModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {            
            if (bindingContext.Model == null)
            {
                bindingContext.ModelMetadata.Model = CreateModel(actionContext, bindingContext);
            }
        }

        protected virtual IEnumerable<ModelMetadata> GetMetadataForProperties(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            // keep a set of the required properties so that we can cross-reference bound properties later
            HashSet<string> requiredProperties;
            Dictionary<string, ModelValidator> requiredValidators;
            HashSet<string> skipProperties;
            GetRequiredPropertiesCollection(actionContext, bindingContext, out requiredProperties, out requiredValidators, out skipProperties);

            return from propertyMetadata in bindingContext.ModelMetadata.Properties
                   let propertyName = propertyMetadata.PropertyName
                   let shouldUpdateProperty = requiredProperties.Contains(propertyName) || !skipProperties.Contains(propertyName)
                   where shouldUpdateProperty && CanUpdateProperty(propertyMetadata)
                   select propertyMetadata;
        }

        private static object GetPropertyDefaultValue(PropertyDescriptor propertyDescriptor)
        {
            DefaultValueAttribute attr = propertyDescriptor.Attributes.OfType<DefaultValueAttribute>().FirstOrDefault();
            return (attr != null) ? attr.Value : null;
        }

        internal static void GetRequiredPropertiesCollection(HttpActionContext actionContext, ModelBindingContext bindingContext, out HashSet<string> requiredProperties, out Dictionary<string, ModelValidator> requiredValidators, out HashSet<string> skipProperties)
        {
            requiredProperties = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            requiredValidators = new Dictionary<string, ModelValidator>(StringComparer.OrdinalIgnoreCase);
            skipProperties = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

            // Use attributes on the property before attributes on the type.
            ICustomTypeDescriptor modelDescriptor = TypeDescriptorHelper.Get(bindingContext.ModelType);
            PropertyDescriptorCollection propertyDescriptors = modelDescriptor.GetProperties();
            HttpBindingBehaviorAttribute typeAttr = modelDescriptor.GetAttributes().OfType<HttpBindingBehaviorAttribute>().SingleOrDefault();

            foreach (PropertyDescriptor propertyDescriptor in propertyDescriptors)
            {
                string propertyName = propertyDescriptor.Name;
                ModelMetadata propertyMetadata = bindingContext.PropertyMetadata[propertyName];
                ModelValidator requiredValidator = actionContext.GetValidators(propertyMetadata).Where(v => v.IsRequired).FirstOrDefault();
                requiredValidators[propertyName] = requiredValidator;

                HttpBindingBehaviorAttribute propAttr = propertyDescriptor.Attributes.OfType<HttpBindingBehaviorAttribute>().SingleOrDefault();
                HttpBindingBehaviorAttribute workingAttr = propAttr ?? typeAttr;
                if (workingAttr != null)
                {
                    switch (workingAttr.Behavior)
                    {
                        case HttpBindingBehavior.Required:
                            requiredProperties.Add(propertyName);
                            break;

                        case HttpBindingBehavior.Never:
                            skipProperties.Add(propertyName);
                            break;
                    }
                }
                else if (requiredValidator != null)
                {
                    requiredProperties.Add(propertyName);
                }
            }
        }

        internal void ProcessDto(HttpActionContext actionContext, ModelBindingContext bindingContext, ComplexModelDto dto)
        {
            HashSet<string> requiredProperties;
            Dictionary<string, ModelValidator> requiredValidators;
            HashSet<string> skipProperties;
            GetRequiredPropertiesCollection(actionContext, bindingContext, out requiredProperties, out requiredValidators, out skipProperties);

            // Eliminate provided properties from requiredProperties; leaving just *missing* required properties.
            requiredProperties.ExceptWith(dto.Results.Select(r => r.Key.PropertyName));

            foreach (string missingRequiredProperty in requiredProperties)
            {
                string modelStateKey = ModelBindingHelper.CreatePropertyModelName(
                    bindingContext.ValidationNode.ModelStateKey, missingRequiredProperty);

                // Update Model as SetProperty() would: Place null value where validator will check for non-null. This
                // ensures a failure result from a required validator (if any) even for a non-nullable property.
                // (Otherwise, propertyMetadata.Model is likely already null.)
                ModelMetadata propertyMetadata = bindingContext.PropertyMetadata[missingRequiredProperty];
                propertyMetadata.Model = null;

                // Execute validator (if any) to get custom error message.
                ModelValidator validator = requiredValidators[missingRequiredProperty];
                bool addedError = RunValidator(validator, bindingContext, propertyMetadata, modelStateKey);

                // Fall back to default message if HttpBindingBehaviorAttribute required this property or validator
                // (oddly) succeeded.
                if (!addedError)
                {
                    bindingContext.ModelState.AddModelError(modelStateKey,
                        Error.Format(SRResources.MissingRequiredMember, missingRequiredProperty));
                }
            }

            // for each property that was bound, call the setter, recording exceptions as necessary
            foreach (var entry in dto.Results)
            {
                ModelMetadata propertyMetadata = entry.Key;

                ComplexModelDtoResult dtoResult = entry.Value;
                if (dtoResult != null)
                {
                    SetProperty(actionContext, bindingContext, propertyMetadata, dtoResult, requiredValidators[propertyMetadata.PropertyName]);
                    bindingContext.ValidationNode.ChildNodes.Add(dtoResult.ValidationNode);
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We're recording this exception so that we can act on it later.")]
        protected virtual void SetProperty(HttpActionContext actionContext, ModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult, ModelValidator requiredValidator)
        {
            PropertyDescriptor propertyDescriptor = TypeDescriptorHelper.Get(bindingContext.ModelType).GetProperties().Find(propertyMetadata.PropertyName, true /* ignoreCase */);
            if (propertyDescriptor == null || propertyDescriptor.IsReadOnly)
            {
                return; // nothing to do
            }

            object value = dtoResult.Model ?? GetPropertyDefaultValue(propertyDescriptor);
            propertyMetadata.Model = value;

            // 'Required' validators need to run first so that we can provide useful error messages if
            // the property setters throw, e.g. if we're setting entity keys to null. See comments in
            // DefaultModelBinder.SetProperty() for more information.
            if (value == null)
            {
                string modelStateKey = dtoResult.ValidationNode.ModelStateKey;
                if (bindingContext.ModelState.IsValidField(modelStateKey))
                {
                    RunValidator(requiredValidator, bindingContext, propertyMetadata, modelStateKey);
                }
            }

            if (value != null || TypeHelper.TypeAllowsNullValue(propertyDescriptor.PropertyType))
            {
                try
                {
                    propertyDescriptor.SetValue(bindingContext.Model, value);
                }
                catch (Exception ex)
                {
                    // don't display a duplicate error message if a binding error has already occurred for this field
                    string modelStateKey = dtoResult.ValidationNode.ModelStateKey;
                    if (bindingContext.ModelState.IsValidField(modelStateKey))
                    {
                        bindingContext.ModelState.AddModelError(modelStateKey, ex);
                    }
                }
            }
            else
            {
                // trying to set a non-nullable value type to null, need to make sure there's a message
                string modelStateKey = dtoResult.ValidationNode.ModelStateKey;
                if (bindingContext.ModelState.IsValidField(modelStateKey))
                {
                    dtoResult.ValidationNode.Validated += CreateNullCheckFailedHandler(propertyMetadata, value);
                }
            }
        }

        // Returns true if validator execution adds a model error.
        private static bool RunValidator(ModelValidator validator, ModelBindingContext bindingContext,
            ModelMetadata propertyMetadata, string modelStateKey)
        {
            bool addedError = false;
            if (validator != null)
            {
                foreach (ModelValidationResult validationResult in validator.Validate(propertyMetadata, bindingContext.Model))
                {
                    bindingContext.ModelState.AddModelError(modelStateKey, validationResult.Message);
                    addedError = true;
                }
            }

            return addedError;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/MutableObjectModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class MutableObjectModelBinderProvider : ModelBinderProvider
    {
        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            if (!MutableObjectModelBinder.CanBindType(modelType))
            {
                return null;
            }

            return new MutableObjectModelBinder();
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/SimpleModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    // Returns a user-specified binder for a given type.
    public sealed class SimpleModelBinderProvider : ModelBinderProvider
    {
        private readonly Func<IModelBinder> _modelBinderFactory;
        private readonly Type _modelType;

        public SimpleModelBinderProvider(Type modelType, IModelBinder modelBinder)
        {
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }
            if (modelBinder == null)
            {
                throw Error.ArgumentNull("modelBinder");
            }

            _modelType = modelType;
            _modelBinderFactory = () => modelBinder;
        }

        public SimpleModelBinderProvider(Type modelType, Func<IModelBinder> modelBinderFactory)
        {
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }
            if (modelBinderFactory == null)
            {
                throw Error.ArgumentNull("modelBinderFactory");
            }

            _modelType = modelType;
            _modelBinderFactory = modelBinderFactory;
        }

        public Type ModelType
        {
            get { return _modelType; }
        }

        public bool SuppressPrefixCheck { get; set; }

        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }

            if (modelType == ModelType)
            {
                if (SuppressPrefixCheck)
                {
                    // If we're suppressing a prefix check, then we don't need any further info from the ActionContext
                    // to know that we're using this binder. 
                    return _modelBinderFactory();
                }
                else
                {
                    return new SimpleModelBinder(this);
                }
            }
            return null;
        }

        // Helper binder to do the prefix check before invoking into the user's binder. 
        private class SimpleModelBinder : IModelBinder
        {
            private readonly SimpleModelBinderProvider _parent;

            public SimpleModelBinder(SimpleModelBinderProvider parent)
            {
                _parent = parent;
            }

            public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
            {
                Contract.Assert(!_parent.SuppressPrefixCheck); // wouldn't have even created this binder 
                if (bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
                {
                    IModelBinder binder = _parent._modelBinderFactory();
                    return binder.BindModel(actionContext, bindingContext);
                }
                return false;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/TypeConverterModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class TypeConverterModelBinder : IModelBinder
    {
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is recorded to be acted upon later.")]
        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Http.ValueProviders.ValueProviderResult.ConvertTo(System.Type)", Justification = "The ValueProviderResult already has the necessary context to perform a culture-aware conversion.")]
        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            ModelBindingHelper.ValidateBindingContext(bindingContext);

            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            if (valueProviderResult == null)
            {
                return false; // no entry
            }

            // Provider should have verified this before creating
            Contract.Assert(TypeHelper.HasStringConverter(bindingContext.ModelType));            

            object newModel;
            bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
            try
            {
                newModel = valueProviderResult.ConvertTo(bindingContext.ModelType);
            }
            catch (Exception ex)
            {
                if (IsFormatException(ex))
                {
                    // there was a type conversion failure
                    string errorString = ModelBinderConfig.TypeConversionErrorMessageProvider(actionContext, bindingContext.ModelMetadata, valueProviderResult.AttemptedValue);
                    if (errorString != null)
                    {
                        bindingContext.ModelState.AddModelError(bindingContext.ModelName, errorString);
                    }
                }
                else
                {
                    bindingContext.ModelState.AddModelError(bindingContext.ModelName, ex);
                }
                return false;
            }

            ModelBindingHelper.ReplaceEmptyStringWithNull(bindingContext.ModelMetadata, ref newModel);
            bindingContext.Model = newModel;
            return true;
        }

        private static bool IsFormatException(Exception ex)
        {
            for (; ex != null; ex = ex.InnerException)
            {
                if (ex is FormatException)
                {
                    return true;
                }
            }
            return false;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/TypeConverterModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding.Binders
{
    // Returns a binder that can perform conversions using a .NET TypeConverter.
    public sealed class TypeConverterModelBinderProvider : ModelBinderProvider
    {
        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }

            if (!TypeHelper.HasStringConverter(modelType))
            {
                return null; // this type cannot be converted
            }
            return new TypeConverterModelBinder();
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/TypeMatchModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;
using System.Web.Http.Validation;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding.Binders
{
    public sealed class TypeMatchModelBinder : IModelBinder
    {
        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            ValueProviderResult valueProviderResult = GetCompatibleValueProviderResult(bindingContext);
            if (valueProviderResult == null)
            {
                return false; // conversion would have failed
            }

            bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);
            object model = valueProviderResult.RawValue;
            ModelBindingHelper.ReplaceEmptyStringWithNull(bindingContext.ModelMetadata, ref model);
            bindingContext.Model = model;
            if (bindingContext.ModelMetadata.IsComplexType)
            {
                HttpControllerContext controllerContext = actionContext.ControllerContext;
                if (controllerContext == null)
                {
                    throw Error.Argument("actionContext", SRResources.TypePropertyMustNotBeNull,
                        typeof(HttpActionContext).Name, "ControllerContext");
                }

                HttpConfiguration configuration = controllerContext.Configuration;
                if (configuration == null)
                {
                    throw Error.Argument("actionContext", SRResources.TypePropertyMustNotBeNull,
                        typeof(HttpControllerContext).Name, "Configuration");
                }

                ServicesContainer services = configuration.Services;
                Contract.Assert(services != null);

                IBodyModelValidator validator = services.GetBodyModelValidator();
                ModelMetadataProvider metadataProvider = services.GetModelMetadataProvider();
                if (validator != null && metadataProvider != null)
                {
                    validator.Validate(model, bindingContext.ModelType, metadataProvider, actionContext, bindingContext.ModelName);
                }
            }

            return true;
        }

        internal static ValueProviderResult GetCompatibleValueProviderResult(ModelBindingContext bindingContext)
        {
            ModelBindingHelper.ValidateBindingContext(bindingContext);

            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
            if (valueProviderResult == null)
            {
                return null; // the value doesn't exist
            }

            if (!TypeHelper.IsCompatibleObject(bindingContext.ModelType, valueProviderResult.RawValue))
            {
                return null; // value is of incompatible type
            }

            return valueProviderResult;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/Binders/TypeMatchModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding.Binders
{
    // Returns a binder that can extract a ValueProviderResult.RawValue and return it directly.
    public sealed class TypeMatchModelBinderProvider : ModelBinderProvider
    {
        private static readonly TypeMatchModelBinder _binder = new TypeMatchModelBinder();

        public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
        {
            return _binder;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/CancellationTokenParameterBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Bind directly to the cancellation token
    /// </summary>
    public class CancellationTokenParameterBinding : HttpParameterBinding
    {
        public CancellationTokenParameterBinding(HttpParameterDescriptor descriptor)
            : base(descriptor)
        {
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            string name = Descriptor.ParameterName;
            actionContext.ActionArguments.Add(name, cancellationToken);
            return TaskHelpers.Completed();
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/CustomModelBinderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Http.ModelBinding
{
    [AttributeUsage(ValidTargets, AllowMultiple = false, Inherited = false)]
    public abstract class CustomModelBinderAttribute : Attribute
    {
        internal const AttributeTargets ValidTargets = AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.Struct;

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method can potentially perform a non-trivial amount of work.")]
        public abstract IModelBinder GetBinder();
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/DefaultActionValueBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.Properties;

namespace System.Web.Http.ModelBinding
{
    public class DefaultActionValueBinder : IActionValueBinder
    {
        /// <summary>
        /// Implementation of <see cref="IActionValueBinder"/>, Primary entry point for binding parameters for an action.
        /// </summary>
        public virtual HttpActionBinding GetBinding(HttpActionDescriptor actionDescriptor)
        {
            if (actionDescriptor == null)
            {
                throw Error.ArgumentNull("actionDescriptor");
            }

            HttpParameterDescriptor[] parameters = actionDescriptor.GetParameters().ToArray();
            HttpParameterBinding[] binders = Array.ConvertAll(parameters, GetParameterBinding);

            HttpActionBinding actionBinding = new HttpActionBinding(actionDescriptor, binders);

            EnsureOneBodyParameter(actionBinding);

            return actionBinding;
        }

        /// <summary>
        /// Update actionBinding to enforce there is at most 1 body parameter.
        /// If there are multiple, convert them all to <see cref="ErrorParameterBinding"/>
        /// </summary>
        private static void EnsureOneBodyParameter(HttpActionBinding actionBinding)
        {
            IList<HttpParameterDescriptor> parameters = actionBinding.ActionDescriptor.GetParameters();

            int idxFromBody = -1;
            for (int i = 0; i < actionBinding.ParameterBindings.Length; i++)
            {
                if (actionBinding.ParameterBindings[i].WillReadBody)
                {
                    if (idxFromBody >= 0)
                    {
                        // This is the 2nd parameter to read from the body. Flag an error.
                        string name1 = parameters[idxFromBody].ParameterName;
                        string name2 = parameters[i].ParameterName;

                        string message = Error.Format(SRResources.ParameterBindingCantHaveMultipleBodyParameters, name1, name2);
                        actionBinding.ParameterBindings[i] = new ErrorParameterBinding(parameters[i], message);
                        actionBinding.ParameterBindings[idxFromBody] = new ErrorParameterBinding(parameters[idxFromBody], message);
                    }
                    else
                    {
                        idxFromBody = i;
                    }
                }
            }
        }

        // Determine how a single parameter will get bound.
        // This is all sync. We don't need to actually read the body just to determine that we'll bind to the body.
        protected virtual HttpParameterBinding GetParameterBinding(HttpParameterDescriptor parameter)
        {
            // Attribute has the highest precedence
            // Presence of a model binder attribute overrides.
            ParameterBindingAttribute attr = parameter.ParameterBinderAttribute;
            if (attr != null)
            {
                return attr.GetBinding(parameter);
            }

            // No attribute, so lookup in global map.
            ParameterBindingRulesCollection pb = parameter.Configuration.ParameterBindingRules;
            if (pb != null)
            {
                HttpParameterBinding binding = pb.LookupBinding(parameter);
                if (binding != null)
                {
                    return binding;
                }
            }

            // Not explicitly specified in global map or attribute.
            // Use a default policy to determine it. These are catch-all policies.
            Type type = parameter.ParameterType;
            if (TypeHelper.CanConvertFromString(type))
            {
                // For simple types, the default is to look in URI. Exactly as if the parameter had a [FromUri] attribute.
                return parameter.BindWithAttribute(new FromUriAttribute());
            }

            // Fallback. Must be a complex type. Default is to look in body. Exactly as if this type had a [FromBody] attribute.
            attr = new FromBodyAttribute();
            return attr.GetBinding(parameter);
        }

        // Create an instance and add some default binders
        internal static ParameterBindingRulesCollection GetDefaultParameterBinders()
        {
            ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();

            pb.Add(typeof(CancellationToken), parameter => new CancellationTokenParameterBinding(parameter));
            pb.Add(typeof(HttpRequestMessage), parameter => new HttpRequestParameterBinding(parameter));

            // Warning binder for HttpContent.
            pb.Add(parameter => typeof(HttpContent).IsAssignableFrom(parameter.ParameterType) ?
                                    parameter.BindAsError(Error.Format(SRResources.ParameterBindingIllegalType, parameter.ParameterType.Name, parameter.ParameterName))
                                    : null);

            return pb;
        }
    }
}

================================================
FILE: src/System.Web.Http/ModelBinding/ErrorParameterBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Describe a binding error.  This includes a message that can give meaningful information to a client.
    /// </summary>
    public class ErrorParameterBinding : HttpParameterBinding
    {
        private readonly string _message;

        public ErrorParameterBinding(HttpParameterDescriptor descriptor, string message)
            : base(descriptor)
        {
            if (message == null)
            {
                throw Error.ArgumentNull("message");
            }
            _message = message;
        }

        public override string ErrorMessage
        {
            get
            {
                return _message;
            }
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            // Caller should have already checked IsError before executing, so we shoulnd't be here. 
            return TaskHelpers.FromError(new InvalidOperationException());
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/FormDataCollectionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http.Formatting;
using System.Text;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Properties;
using System.Web.Http.Validation;
using System.Web.Http.Validation.Providers;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;

namespace System.Web.Http.ModelBinding
{
    public static class FormDataCollectionExtensions
    {
        // This is a helper method to use Model Binding over a JQuery syntax. 
        // Normalize from JQuery to MVC keys. The model binding infrastructure uses MVC keys
        // x[] --> x
        // [] --> ""
        // x[field]  --> x.field, where field is not a number
        internal static string NormalizeJQueryToMvc(string key)
        {
            if (key == null)
            {
                return String.Empty;
            }

            StringBuilder sb = null;
            int i = 0;
            while (true)
            {
                int indexOpen = key.IndexOf('[', i);
                if (indexOpen < 0)
                {
                    // Fast path, no normalization needed.
                    // This skips the string conversion and allocating the string builder.
                    if (i == 0)
                    {
                        return key;
                    }
                    sb = sb ?? new StringBuilder();
                    sb.Append(key, i, key.Length - i);
                    break; // no more brackets
                }

                sb = sb ?? new StringBuilder();
                sb.Append(key, i, indexOpen - i); // everything up to "["

                // Find closing bracket.
                int indexClose = key.IndexOf(']', indexOpen);
                if (indexClose == -1)
                {
                    throw Error.Argument("key", SRResources.JQuerySyntaxMissingClosingBracket);
                }

                if (indexClose == indexOpen + 1)
                {
                    // Empty bracket. Signifies array. Just remove. 
                }
                else
                {
                    if (Char.IsDigit(key[indexOpen + 1]))
                    {
                        // array index. Leave unchanged. 
                        sb.Append(key, indexOpen, indexClose - indexOpen + 1);
                    }
                    else
                    {
                        // Field name.  Convert to dot notation. 
                        sb.Append('.');
                        sb.Append(key, indexOpen + 1, indexClose - indexOpen - 1);
                    }
                }

                i = indexClose + 1;
                if (i >= key.Length)
                {
                    break; // end of string
                }
            }
            return sb.ToString();
        }

        internal static IEnumerable<KeyValuePair<string, string>> GetJQueryNameValuePairs(this FormDataCollection formData)
        {
            if (formData == null)
            {
                throw Error.ArgumentNull("formData");
            }

            int count = 0;

            foreach (KeyValuePair<string, string> kv in formData)
            {
                ThrowIfMaxHttpCollectionKeysExceeded(count);

                string key = NormalizeJQueryToMvc(kv.Key);
                string value = kv.Value ?? String.Empty;
                yield return new KeyValuePair<string, string>(key, value);

                count++;
            }
        }

        private static void ThrowIfMaxHttpCollectionKeysExceeded(int count)
        {
            if (count >= MediaTypeFormatter.MaxHttpCollectionKeys)
            {
                throw Error.InvalidOperation(SRResources.MaxHttpCollectionKeyLimitReached, MediaTypeFormatter.MaxHttpCollectionKeys, typeof(MediaTypeFormatter));
            }
        }

        // Create a IValueProvider for the given form, assuming a JQuery syntax.
        internal static IValueProvider GetJQueryValueProvider(this FormDataCollection formData)
        {
            if (formData == null)
            {
                throw Error.ArgumentNull("formData");
            }

            IEnumerable<KeyValuePair<string, string>> nvc = formData.GetJQueryNameValuePairs();
            return new NameValuePairsValueProvider(nvc, CultureInfo.InvariantCulture);
        }

        public static T ReadAs<T>(this FormDataCollection formData)
        {
            return (T)ReadAs(formData, typeof(T));
        }

        public static T ReadAs<T>(this FormDataCollection formData, HttpActionContext actionContext)
        {
            return (T)ReadAs(formData, typeof(T), String.Empty, actionContext: actionContext);
        }

        public static object ReadAs(this FormDataCollection formData, Type type)
        {
            return ReadAs(formData, type, String.Empty, requiredMemberSelector: null, formatterLogger: null);
        }

        public static object ReadAs(this FormDataCollection formData, Type type, HttpActionContext actionContext)
        {
            return ReadAs(formData, type, String.Empty, actionContext);
        }

        public static T ReadAs<T>(this FormDataCollection formData, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger)
        {
            return (T)ReadAs(formData, typeof(T), modelName, requiredMemberSelector, formatterLogger);
        }

        public static T ReadAs<T>(this FormDataCollection formData, string modelName, HttpActionContext actionContext)
        {
            return (T)ReadAs(formData, typeof(T), modelName, actionContext);
        }

        public static object ReadAs(this FormDataCollection formData, Type type, string modelName, HttpActionContext actionContext)
        {
            if (formData == null)
            {
                throw Error.ArgumentNull("formData");
            }
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            return ReadAsInternal(formData, type, modelName, actionContext);
        }

        public static object ReadAs(this FormDataCollection formData, Type type, string modelName,
            IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger)
        {
            return ReadAs(formData, type, modelName, requiredMemberSelector, formatterLogger, config: null);
        }

        /// <summary>
        /// Deserialize the form data to the given type, using model binding.  
        /// </summary>
        /// <param name="formData">collection with parsed form url data</param>
        /// <param name="type">target type to read as</param>
        /// <param name="modelName">null or empty to read the entire form as a single object. 
        /// This is common for body data. Or the name of a model to do a partial binding against the form data. 
        /// This is common for extracting individual fields.</param>
        /// <param name="requiredMemberSelector">The <see cref="IRequiredMemberSelector"/> 
        /// used to determine required members.</param>
        /// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
        /// <param name="config">The <see cref="HttpConfiguration"/> configuration to pick binder from.
        /// Can be null if the config was not created already. In that case a new config is created.</param>
        /// <returns>best attempt to bind the object. The best attempt may be null.</returns>
        public static object ReadAs(this FormDataCollection formData, Type type, string modelName, 
                                        IRequiredMemberSelector requiredMemberSelector,
                                        IFormatterLogger formatterLogger, HttpConfiguration config)
        {
            if (formData == null)
            {
                throw Error.ArgumentNull("formData");
            }
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            object result = null;
            HttpActionContext actionContext = null;

            bool validateRequiredMembers = requiredMemberSelector != null && formatterLogger != null;

            if (validateRequiredMembers)
            {
                // We wrap the config so we can override the services and cache 
                // without affecting outside callers or users of the config.
                using (HttpConfiguration wrapperConfig = new HttpConfiguration())
                {
                    config = config == null ? wrapperConfig : config;
                    wrapperConfig.Services = new ServicesContainerWrapper(config,
                                                new RequiredMemberModelValidatorProvider(requiredMemberSelector));

                    // The HttpActionContext provides access to configuration for ModelBinders, and is also provided
                    // to the IModelBinder when binding occurs. Since HttpActionContext was not provided, create a default.
                    actionContext = CreateActionContextForModelBinding(wrapperConfig);
                    result = ReadAs(formData, type, modelName, actionContext);
                }
            }
            else
            {
                if (config == null)
                {
                    using (config = new HttpConfiguration())
                    {
                        actionContext = CreateActionContextForModelBinding(config);
                        result = ReadAs(formData, type, modelName, actionContext);
                    }
                }
                else
                {
                    actionContext = CreateActionContextForModelBinding(config);
                    result = ReadAs(formData, type, modelName, actionContext);
                }
            }

            // The model binding will log any errors to the HttpActionContext's ModelState. Since this is a context
            // that we created and doesn't map to a real action invocation, we want to forward the errors to 
            // the user-specified IFormatterLogger.
            if (formatterLogger != null)
            {
                foreach (KeyValuePair<string, ModelState> modelStatePair in actionContext.ModelState)
                {
                    foreach (ModelError modelError in modelStatePair.Value.Errors)
                    {
                        if (modelError.Exception != null)
                        {
                            formatterLogger.LogError(modelStatePair.Key, modelError.Exception);
                        }
                        else
                        {
                            formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage);
                        }
                    }
                }
            }

            return result;
        }

        private static object ReadAsInternal(this FormDataCollection formData, Type type, string modelName, HttpActionContext actionContext)
        {
            Contract.Assert(formData != null);
            Contract.Assert(type != null);
            Contract.Assert(actionContext != null);

            IValueProvider valueProvider = formData.GetJQueryValueProvider();
            ModelBindingContext bindingContext = CreateModelBindingContext(actionContext, modelName ?? String.Empty, type, valueProvider);

            ModelBinderProvider modelBinderProvider = CreateModelBindingProvider(actionContext);

            IModelBinder modelBinder = modelBinderProvider.GetBinder(actionContext.ControllerContext.Configuration, type);
            bool haveResult = modelBinder.BindModel(actionContext, bindingContext);
            if (haveResult)
            {
                return bindingContext.Model;
            }

            return MediaTypeFormatter.GetDefaultValueForType(type);
        }

        // Helper for ReadAs() to get a ModelBinderProvider to read FormUrl data. 
        private static ModelBinderProvider CreateModelBindingProvider(HttpActionContext actionContext)
        {
            Contract.Assert(actionContext != null);

            ServicesContainer cs = actionContext.ControllerContext.Configuration.Services;
            IEnumerable<ModelBinderProvider> providers = cs.GetModelBinderProviders();
            ModelBinderProvider modelBinderProvider = new CompositeModelBinderProvider(providers);
            return modelBinderProvider;
        }

        // Helper for ReadAs() to get a ModelBindingContext to invoke model binding over FormUrl data. 
        private static ModelBindingContext CreateModelBindingContext(HttpActionContext actionContext, string modelName, Type type, IValueProvider vp)
        {
            Contract.Assert(actionContext != null);
            Contract.Assert(type != null);
            Contract.Assert(vp != null);

            ServicesContainer cs = actionContext.ControllerContext.Configuration.Services;
            ModelMetadataProvider metadataProvider = cs.GetModelMetadataProvider();

            ModelBindingContext ctx = new ModelBindingContext()
            {
                ModelName = modelName,
                FallbackToEmptyPrefix = false,
                ModelMetadata = metadataProvider.GetMetadataForType(null, type),
                ModelState = actionContext.ModelState,
                ValueProvider = vp
            };
            return ctx;
        }

        // Creates a default action context to invoke model binding
        private static HttpActionContext CreateActionContextForModelBinding(HttpConfiguration config)
        {
            Contract.Assert(config != null);

            HttpControllerContext controllerContext = new HttpControllerContext() { Configuration = config };
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(config);

            HttpActionContext actionContext = new HttpActionContext { ControllerContext = controllerContext };

            return actionContext;
        }

        // This class is internal for Unit Testing purposes
        internal class ServicesContainerWrapper : ServicesContainer
        {
            private HttpConfiguration _originalConfig;
            private ModelValidatorProvider _requiredMemberModelValidatorProvider;

            public ServicesContainerWrapper(
                                HttpConfiguration originalConfig,
                                ModelValidatorProvider requiredMemberModelValidatorProvider)
            {
                _originalConfig = originalConfig;
                _requiredMemberModelValidatorProvider = requiredMemberModelValidatorProvider;
            }

            // Without modifying the original config, the wrapper returns only the expected
            // Validator Provider. Since the cache is expected to have the original config's
            // cache entries, it is wrapped as well.
            public override object GetService(Type serviceType)
            {
                if (serviceType == typeof(IModelValidatorCache))
                {
                    return new ModelValidatorCache(
                                    new Lazy<IEnumerable<ModelValidatorProvider>>(
                                        () => this.GetServices<ModelValidatorProvider>()));
                }
                else if (serviceType == typeof(ModelValidatorProvider))
                {
                    return _requiredMemberModelValidatorProvider;
                }
                else
                {
                    return _originalConfig.Services.GetService(serviceType);
                }
            }

            public override IEnumerable<object> GetServices(Type serviceType)
            {
                if (serviceType == typeof(ModelValidatorProvider))
                {
                    return new ModelValidatorProvider[] { _requiredMemberModelValidatorProvider };
                }
                else
                {
                    return _originalConfig.Services.GetServices(serviceType);
                }
            }

            protected override List<object> GetServiceInstances(Type serviceType)
            {
                throw new NotImplementedException();
            }

            // The following methods are expected to work the same way irrespective of the wrapper.
            // Hence they are not special cased for the Validator Providers / Cache.
            public override bool IsSingleService(Type serviceType)
            {
                return _originalConfig.Services.IsSingleService(serviceType);
            }

            protected override void ClearSingle(Type serviceType)
            {
                _originalConfig.Services.Clear(serviceType);
            }

            protected override void ReplaceSingle(Type serviceType, object service)
            {
                _originalConfig.Services.Replace(serviceType, service);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/FormatterParameterBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;
using System.Web.Http.Validation;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Parameter binding that will read from the body and invoke the formatters. 
    /// </summary>
    public class FormatterParameterBinding : HttpParameterBinding
    {
        // Magic key to pass cancellation token through the request property bag to maintain backward compat.
        private const string CancellationTokenKey = "MS_FormatterParameterBinding_CancellationToken";

        private IEnumerable<MediaTypeFormatter> _formatters;
        private string _errorMessage;

        public FormatterParameterBinding(HttpParameterDescriptor descriptor, IEnumerable<MediaTypeFormatter> formatters, IBodyModelValidator bodyModelValidator)
            : base(descriptor)
        {
            if (descriptor.IsOptional)
            {
                _errorMessage = Error.Format(SRResources.OptionalBodyParameterNotSupported, descriptor.Prefix ?? descriptor.ParameterName, GetType().Name);
            }
            Formatters = formatters;
            BodyModelValidator = bodyModelValidator;
        }

        public override bool WillReadBody
        {
            get { return true; }
        }

        public override string ErrorMessage
        {
            get
            {
                return _errorMessage;
            }
        }

        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _formatters; }
            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("formatters");
                }
                _formatters = value;
            }
        }

        public IBodyModelValidator BodyModelValidator
        {
            get;
            set;
        }

        public virtual Task<object> ReadContentAsync(HttpRequestMessage request, Type type,
            IEnumerable<MediaTypeFormatter> formatters, IFormatterLogger formatterLogger)
        {
            // Try to get the cancellation token if it is set earlier during the magic handshake
            // to maintain backward compatibility.
            object cancellationToken;
            if (!request.Properties.TryGetValue(CancellationTokenKey, out cancellationToken))
            {
                cancellationToken = CancellationToken.None;
            }

            return ReadContentAsync(request, type, formatters, formatterLogger, (CancellationToken)cancellationToken);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Disposed later")]
        public virtual Task<object> ReadContentAsync(HttpRequestMessage request, Type type,
            IEnumerable<MediaTypeFormatter> formatters, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            HttpContent content = request.Content;
            if (content == null)
            {
                object defaultValue = MediaTypeFormatter.GetDefaultValueForType(type);
                if (defaultValue == null)
                {
                    return TaskHelpers.NullResult();
                }
                else
                {
                    return Task.FromResult(defaultValue);
                }
            }

            try
            {
                return content.ReadAsAsync(type, formatters, formatterLogger, cancellationToken);
            }
            catch (UnsupportedMediaTypeException exception)
            {
                // If there is no Content-Type header, provide a better error message
                string errorFormat = content.Headers.ContentType == null ?
                    SRResources.UnsupportedMediaTypeNoContentType :
                    SRResources.UnsupportedMediaType;

                throw new HttpResponseException(
                    request.CreateErrorResponse(
                        HttpStatusCode.UnsupportedMediaType,
                        Error.Format(errorFormat, exception.MediaType.MediaType),
                        exception));
            }
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext,
            CancellationToken cancellationToken)
        {
            HttpParameterDescriptor paramFromBody = this.Descriptor;
            Type type = paramFromBody.ParameterType;
            HttpRequestMessage request = actionContext.ControllerContext.Request;
            IFormatterLogger formatterLogger = new ModelStateFormatterLogger(actionContext.ModelState, paramFromBody.ParameterName);

            return ExecuteBindingAsyncCore(metadataProvider, actionContext, paramFromBody, type, request, formatterLogger, cancellationToken);
        }

        // Perf-sensitive - keeping the async method as small as possible
        private async Task ExecuteBindingAsyncCore(ModelMetadataProvider metadataProvider, HttpActionContext actionContext,
            HttpParameterDescriptor paramFromBody, Type type, HttpRequestMessage request, IFormatterLogger formatterLogger,
            CancellationToken cancellationToken)
        {
            // pass the cancellation token through the request as we cannot call the ReadContentAsync overload that takes
            // CancellationToken for backword compatibility reasons.
            request.Properties[CancellationTokenKey] = cancellationToken;
            object model = await ReadContentAsync(request, type, _formatters, formatterLogger);

            // Put the parameter result into the action context.
            SetValue(actionContext, model);

            // validate the object graph.
            // null indicates we want no body parameter validation
            if (BodyModelValidator != null)
            {
                BodyModelValidator.Validate(model, type, metadataProvider, actionContext, paramFromBody.ParameterName);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/HttpBindingBehavior.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ModelBinding
{
    public enum HttpBindingBehavior
    {
        Optional = 0,
        Never,
        Required
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/HttpBindingBehaviorAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Http.ModelBinding
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This class is designed to be overridden")]
    public class HttpBindingBehaviorAttribute : Attribute
    {
        private static readonly object _typeId = new object();

        public HttpBindingBehaviorAttribute(HttpBindingBehavior behavior)
        {
            Behavior = behavior;
        }

        public HttpBindingBehavior Behavior { get; private set; }

        public override object TypeId
        {
            get { return _typeId; }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/HttpRequestParameterBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Parameter binds to the request
    /// </summary>
    public class HttpRequestParameterBinding : HttpParameterBinding
    {
        public HttpRequestParameterBinding(HttpParameterDescriptor descriptor)
            : base(descriptor)
        {            
        }        

        // Execute the binding for the given request.
        // On success, this will add the parameter to the actionContext.ActionArguments dictionary.
        // Caller ensures IsError==false. 
        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            string name = Descriptor.ParameterName;
            HttpRequestMessage request = actionContext.ControllerContext.Request;
            actionContext.ActionArguments.Add(name, request);

            return TaskHelpers.Completed();
        }        
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/IModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Interface for model binding.
    /// </summary>
    public interface IModelBinder
    {
        bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext);
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/IValueProviderParameterBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Describes a parameter binding that uses one or more instances of <see cref="ValueProviderFactory"/>
    /// </summary>
    public interface IValueProviderParameterBinding
    {
        /// <summary>
        /// Gets the <see cref="ValueProviderFactory"/> instances used by this
        /// parameter binding.
        /// </summary>
        IEnumerable<ValueProviderFactory> ValueProviderFactories { get; }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/JQueryMVCFormUrlEncodedFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading.Tasks;

namespace System.Web.Http.ModelBinding
{
    // Supports JQuery schema on FormURL. 
    public class JQueryMvcFormUrlEncodedFormatter : FormUrlEncodedMediaTypeFormatter
    {
        private readonly HttpConfiguration _configuration = null;

        public JQueryMvcFormUrlEncodedFormatter()
        {
        }

        public JQueryMvcFormUrlEncodedFormatter(HttpConfiguration config)
        {
            _configuration = config;
        }

        public override bool CanReadType(Type type)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            return true;
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            if (readStream == null)
            {
                throw new ArgumentNullException("readStream");
            }

            // For simple types, defer to base class
            if (base.CanReadType(type))
            {
                return base.ReadFromStreamAsync(type, readStream, content, formatterLogger);
            }

            return ReadFromStreamAsyncCore(type, readStream, content, formatterLogger);
        }

        private async Task<object> ReadFromStreamAsyncCore(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            object obj = await base.ReadFromStreamAsync(typeof(FormDataCollection), readStream, content, formatterLogger);
            FormDataCollection fd = (FormDataCollection)obj;

            try
            {
                return fd.ReadAs(type, String.Empty, RequiredMemberSelector, formatterLogger, _configuration);
            }
            catch (Exception e)
            {
                if (formatterLogger == null)
                {
                    throw;
                }
                formatterLogger.LogError(String.Empty, e);
                return GetDefaultValueForType(type);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelBinderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Properties;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Specify this parameter uses a model binder. This can optionally specify the specific model binder and 
    /// value providers that drive that model binder. 
    /// Derived attributes may provide convenience settings for the model binder or value provider. 
    /// </summary>
    [SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification = "want constructor argument shortcut")]
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "part of a class hierarchy")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
    public class ModelBinderAttribute : ParameterBindingAttribute
    {
        public ModelBinderAttribute()
            : this(null)
        {
        }

        public ModelBinderAttribute(Type binderType)
        {
            BinderType = binderType;
        }

        /// <summary>
        /// Sets the type of the model binder. 
        /// This type must be a subclass of <see cref="ModelBinderProvider"/>  or <see cref="IModelBinder"/>      
        /// If null, uses the default from the configuration. 
        /// </summary>   
        public Type BinderType { get; set; }

        /// <summary>
        /// Gets or sets the name to consider as the parameter name during model binding
        /// </summary>
        public string Name { get; set; }

        public bool SuppressPrefixCheck { get; set; }

        public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter)
        {
            HttpConfiguration config = parameter.Configuration;
            IModelBinder binder = GetModelBinder(config, parameter.ParameterType);
            IEnumerable<ValueProviderFactory> valueProviderFactories = GetValueProviderFactories(config);

            return new ModelBinderParameterBinding(parameter, binder, valueProviderFactories);
        }

        // This will get called by a parameter binding, which will cache the results. 
        public ModelBinderProvider GetModelBinderProvider(HttpConfiguration configuration)
        {
            if (BinderType != null)
            {
                object value = GetOrInstantiate(configuration, BinderType);

                if (value != null)
                {
                    VerifyBinderType(value.GetType());
                    ModelBinderProvider result = (ModelBinderProvider)value;
                    return result;
                }
            }

            // Create default over config
            IEnumerable<ModelBinderProvider> providers = configuration.Services.GetModelBinderProviders();

            if (providers.Count() == 1)
            {
                return providers.First();
            }

            return new CompositeModelBinderProvider(providers);
        }

        /// <summary>
        /// Get the IModelBinder for this type.
        /// </summary>
        /// <param name="configuration">The configuration.</param>
        /// <param name="modelType">model type that the binder is expected to bind.</param>
        /// <returns>
        /// a non-null model binder.
        /// </returns>
        public IModelBinder GetModelBinder(HttpConfiguration configuration, Type modelType)
        {
            if (BinderType == null)
            {
                ModelBinderProvider provider = GetModelBinderProvider(configuration);
                return provider.GetBinder(configuration, modelType);
            }

            // This may create a IModelBinder or a ModelBinderProvider
            object value = GetOrInstantiate(configuration, BinderType);

            Contract.Assert(value != null); // Activator would have thrown

            IModelBinder binder = value as IModelBinder;
            if (binder != null)
            {
                return binder;
            }
            else
            {
                ModelBinderProvider provider = value as ModelBinderProvider;
                if (provider != null)
                {
                    return provider.GetBinder(configuration, modelType);
                }
            }

            Type required = typeof(IModelBinder);
            throw Error.InvalidOperation(SRResources.ValueProviderFactory_Cannot_Create, required.Name, value.GetType().Name, required.Name);
        }

        /// <summary>
        /// Value providers that will be fed to the model binder.
        /// </summary>
        public virtual IEnumerable<ValueProviderFactory> GetValueProviderFactories(HttpConfiguration configuration)
        {
            // By default, just get all registered value provider factories
            return configuration.Services.GetValueProviderFactories();
        }

        private static void VerifyBinderType(Type attemptedType)
        {
            Type required = typeof(ModelBinderProvider);
            if (!required.IsAssignableFrom(attemptedType))
            {
                throw Error.InvalidOperation(SRResources.ValueProviderFactory_Cannot_Create, required.Name, attemptedType.Name, required.Name);
            }
        }

        private static object GetOrInstantiate(HttpConfiguration configuration, Type type)
        {
            IDependencyResolver dr = configuration.DependencyResolver;
            object value = dr.GetService(type);
            if (value != null)
            {
                return value;
            }

            return Activator.CreateInstance(type);
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelBinderConfig.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;

namespace System.Web.Http.ModelBinding
{
    // REVIEW: Need a way to get the user's resource string choice
    // Provides configuration settings common to the new model binding system.
    public static class ModelBinderConfig
    {
        private static string _resourceClassKey;
        private static ModelBinderErrorMessageProvider _typeConversionErrorMessageProvider;
        private static ModelBinderErrorMessageProvider _valueRequiredErrorMessageProvider;

        public static string ResourceClassKey
        {
            get { return _resourceClassKey ?? String.Empty; }
            set { _resourceClassKey = value; }
        }

        public static ModelBinderErrorMessageProvider TypeConversionErrorMessageProvider
        {
            get
            {
                if (_typeConversionErrorMessageProvider == null)
                {
                    _typeConversionErrorMessageProvider = DefaultTypeConversionErrorMessageProvider;
                }
                return _typeConversionErrorMessageProvider;
            }
            set { _typeConversionErrorMessageProvider = value; }
        }

        public static ModelBinderErrorMessageProvider ValueRequiredErrorMessageProvider
        {
            get
            {
                if (_valueRequiredErrorMessageProvider == null)
                {
                    _valueRequiredErrorMessageProvider = DefaultValueRequiredErrorMessageProvider;
                }
                return _valueRequiredErrorMessageProvider;
            }
            set { _valueRequiredErrorMessageProvider = value; }
        }

        private static string DefaultTypeConversionErrorMessageProvider(HttpActionContext actionContext, ModelMetadata modelMetadata, object incomingValue)
        {
            return GetResourceCommon(actionContext, modelMetadata, incomingValue, GetValueInvalidResource);
        }

        private static string DefaultValueRequiredErrorMessageProvider(HttpActionContext actionContext, ModelMetadata modelMetadata, object incomingValue)
        {
            return GetResourceCommon(actionContext, modelMetadata, incomingValue, GetValueRequiredResource);
        }

        private static string GetResourceCommon(HttpActionContext actionContext, ModelMetadata modelMetadata, object incomingValue, Func<HttpActionContext, string> resourceAccessor)
        {
            string displayName = modelMetadata.GetDisplayName();
            string errorMessageTemplate = resourceAccessor(actionContext);
            return Error.Format(errorMessageTemplate, incomingValue, displayName);
        }

        private static string GetUserResourceString(HttpActionContext actionContext, string resourceName)
        {
            return GetUserResourceString(actionContext, resourceName, ResourceClassKey);
        }

        // If the user specified a ResourceClassKey try to load the resource they specified.
        // If the class key is invalid, an exception will be thrown.
        // If the class key is valid but the resource is not found, it returns null, in which
        // case it will fall back to the MVC default error message.
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "resourceName", Justification = "Temporary")]
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "resourceClassKey", Justification = "Temporary")]
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "actionContext", Justification = "Temporary")]
        internal static string GetUserResourceString(HttpActionContext actionContext, string resourceName, string resourceClassKey)
        {
#if false
            return (!String.IsNullOrEmpty(resourceClassKey) && (actionContext != null) && (actionContext.HttpContext != null))
                       ? actionContext.HttpContext.GetGlobalResourceObject(resourceClassKey, resourceName, CultureInfo.CurrentUICulture) as string
                       : null;
#else
            return null;
#endif
        }

        private static string GetValueInvalidResource(HttpActionContext actionContext)
        {
            return GetUserResourceString(actionContext, "PropertyValueInvalid") ?? SRResources.ModelBinderConfig_ValueInvalid;
        }

        private static string GetValueRequiredResource(HttpActionContext actionContext)
        {
            return GetUserResourceString(actionContext, "PropertyValueRequired") ?? SRResources.ModelBinderConfig_ValueRequired;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelBinderErrorMessageProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using System.Web.Http.Metadata;

namespace System.Web.Http.ModelBinding
{
    public delegate string ModelBinderErrorMessageProvider(HttpActionContext actionContext, ModelMetadata modelMetadata, object incomingValue);
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelBinderParameterBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Validation;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Describes a parameter that gets bound via ModelBinding.  
    /// </summary>
    public class ModelBinderParameterBinding : HttpParameterBinding, IValueProviderParameterBinding
    {
        private readonly ValueProviderFactory[] _valueProviderFactories;
        private readonly IModelBinder _binder;

        public ModelBinderParameterBinding(HttpParameterDescriptor descriptor,
            IModelBinder modelBinder,
            IEnumerable<ValueProviderFactory> valueProviderFactories)
            : base(descriptor)
        {
            if (modelBinder == null)
            {
                throw Error.ArgumentNull("modelBinder");
            }
            if (valueProviderFactories == null)
            {
                throw Error.ArgumentNull("valueProviderFactories");
            }

            _binder = modelBinder;
            _valueProviderFactories = valueProviderFactories.ToArray();
        }

        public IEnumerable<ValueProviderFactory> ValueProviderFactories
        {
            get { return _valueProviderFactories; }
        }

        public IModelBinder Binder
        {
            get { return _binder; }
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            ModelBindingContext ctx = GetModelBindingContext(metadataProvider, actionContext);

            bool haveResult = _binder.BindModel(actionContext, ctx);
            object model = haveResult ? ctx.Model : Descriptor.DefaultValue;
            SetValue(actionContext, model);

            return TaskHelpers.Completed();
        }

        private ModelBindingContext GetModelBindingContext(ModelMetadataProvider metadataProvider, HttpActionContext actionContext)
        {
            string name = Descriptor.ParameterName;
            Type type = Descriptor.ParameterType;

            string prefix = Descriptor.Prefix;

            IValueProvider vp = CompositeValueProviderFactory.GetValueProvider(actionContext, _valueProviderFactories);

            ModelBindingContext ctx = new ModelBindingContext()
            {
                ModelName = prefix ?? name,
                FallbackToEmptyPrefix = prefix == null, // only fall back if prefix not specified
                ModelMetadata = metadataProvider.GetMetadataForType(null, type),
                ModelState = actionContext.ModelState,
                ValueProvider = vp
            };

            return ctx;
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding
{
    public abstract class ModelBinderProvider
    {
        /// <summary>
        /// Find a binder for the given type
        /// </summary>
        /// <param name="configuration">a configuration object</param>
        /// <param name="modelType">the type of the model to bind against.</param>
        /// <returns>a binder, which can attempt to bind this type. Or null if the binder knows statically that it will never be able to bind the type.</returns>
        public abstract IModelBinder GetBinder(HttpConfiguration configuration, Type modelType);
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelBindingContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;
using System.Web.Http.Validation;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding
{
    public class ModelBindingContext
    {
        private string _modelName;
        private ModelStateDictionary _modelState;
        private Dictionary<string, ModelMetadata> _propertyMetadata;
        private ModelValidationNode _validationNode;

        public ModelBindingContext()
            : this(null)
        {
        }

        // copies certain values that won't change between parent and child objects,
        // e.g. ValueProvider, ModelState
        public ModelBindingContext(ModelBindingContext bindingContext)
        {
            if (bindingContext != null)
            {
                ModelState = bindingContext.ModelState;
                ValueProvider = bindingContext.ValueProvider;
            }
        }

        public object Model
        {
            get
            {
                EnsureModelMetadata();
                return ModelMetadata.Model;
            }
            set
            {
                EnsureModelMetadata();
                ModelMetadata.Model = value;
            }
        }

        public ModelMetadata ModelMetadata { get; set; }

        public string ModelName
        {
            get
            {
                if (_modelName == null)
                {
                    _modelName = String.Empty;
                }
                return _modelName;
            }
            set { _modelName = value; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is writeable to support unit testing")]
        public ModelStateDictionary ModelState
        {
            get
            {
                if (_modelState == null)
                {
                    _modelState = new ModelStateDictionary();
                }
                return _modelState;
            }
            set { _modelState = value; }
        }

        public Type ModelType
        {
            get
            {
                EnsureModelMetadata();
                return ModelMetadata.ModelType;
            }
        }

        public IDictionary<string, ModelMetadata> PropertyMetadata
        {
            get
            {
                if (_propertyMetadata == null)
                {
                    _propertyMetadata = ModelMetadata.Properties.ToDictionary(m => m.PropertyName, StringComparer.OrdinalIgnoreCase);
                }

                return _propertyMetadata;
            }
        }

        public ModelValidationNode ValidationNode
        {
            get
            {
                if (_validationNode == null)
                {
                    _validationNode = new ModelValidationNode(ModelMetadata, ModelName);
                }
                return _validationNode;
            }
            set { _validationNode = value; }
        }

        public IValueProvider ValueProvider { get; set; }

        public bool FallbackToEmptyPrefix { get; set; }

        private void EnsureModelMetadata()
        {
            if (ModelMetadata == null)
            {
                throw Error.InvalidOperation(SRResources.ModelBindingContext_ModelMetadataMustBeSet);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelBindingHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Concurrent;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Properties;

namespace System.Web.Http.ModelBinding
{
    internal static class ModelBindingHelper
    {
        private static readonly ConcurrentDictionary<Type, ModelBinderAttribute> _modelBinderAttributeCache = new ConcurrentDictionary<Type, ModelBinderAttribute>();

        internal static TModel CastOrDefault<TModel>(object model)
        {
            return (model is TModel) ? (TModel)model : default(TModel);
        }

        internal static string CreateIndexModelName(string parentName, int index)
        {
            return CreateIndexModelName(parentName, index.ToString(CultureInfo.InvariantCulture));
        }

        internal static string CreateIndexModelName(string parentName, string index)
        {
            return (parentName.Length == 0) ? "[" + index + "]" : parentName + "[" + index + "]";
        }

        internal static string CreatePropertyModelName(string prefix, string propertyName)
        {
            if (String.IsNullOrEmpty(prefix))
            {
                return propertyName ?? String.Empty;
            }
            else if (String.IsNullOrEmpty(propertyName))
            {
                return prefix ?? String.Empty;
            }
            else
            {
                return prefix + "." + propertyName;
            }
        }

        // Concatenate model keys, if suffix is an indexer, concat strings; otherwise insert a period between the two
        internal static string ConcatenateKeys(string prefix, string suffix)
        {
            Contract.Assert(!String.IsNullOrEmpty(prefix));
            if (String.IsNullOrEmpty(suffix))
            {
                return prefix;
            }
            return suffix.StartsWith("[", StringComparison.Ordinal) ? prefix + suffix : prefix + "." + suffix;
        }

        internal static IModelBinder GetPossibleBinderInstance(Type closedModelType, Type openModelType, Type openBinderType)
        {
            Type[] typeArguments = TypeHelper.GetTypeArgumentsIfMatch(closedModelType, openModelType);
            return (typeArguments != null) ? (IModelBinder)Activator.CreateInstance(openBinderType.MakeGenericType(typeArguments)) : null;
        }

        internal static object[] RawValueToObjectArray(object rawValue)
        {
            // precondition: rawValue is not null

            // Need to special-case String so it's not caught by the IEnumerable check which follows
            if (rawValue is string)
            {
                return new[] { rawValue };
            }

            object[] rawValueAsObjectArray = rawValue as object[];
            if (rawValueAsObjectArray != null)
            {
                return rawValueAsObjectArray;
            }

            IEnumerable rawValueAsEnumerable = rawValue as IEnumerable;
            if (rawValueAsEnumerable != null)
            {
                return rawValueAsEnumerable.Cast<object>().ToArray();
            }

            // fallback
            return new[] { rawValue };
        }

        internal static void ReplaceEmptyStringWithNull(ModelMetadata modelMetadata, ref object model)
        {
            if (model is string &&
                modelMetadata.ConvertEmptyStringToNull &&
                String.IsNullOrWhiteSpace(model as string))
            {
                model = null;
            }
        }

        internal static bool TryGetProviderFromAttribute(Type modelType, ModelBinderAttribute modelBinderAttribute, out ModelBinderProvider provider)
        {
            Contract.Assert(modelType != null, "modelType cannot be null.");
            Contract.Assert(modelBinderAttribute != null, "modelBinderAttribute cannot be null");

            // TODO, 386718, remove the following if statement when the bug is resolved
            if (modelBinderAttribute.BinderType == null)
            {
                provider = null;
                return false;
            }

            if (typeof(ModelBinderProvider).IsAssignableFrom(modelBinderAttribute.BinderType))
            {
                // REVIEW: DI?
                provider = (ModelBinderProvider)Activator.CreateInstance(modelBinderAttribute.BinderType);
            }
            else if (typeof(IModelBinder).IsAssignableFrom(modelBinderAttribute.BinderType))
            {
                Type closedBinderType =
                    modelBinderAttribute.BinderType.IsGenericTypeDefinition
                        ? modelBinderAttribute.BinderType.MakeGenericType(modelType.GetGenericArguments())
                        : modelBinderAttribute.BinderType;

                IModelBinder binderInstance = (IModelBinder)Activator.CreateInstance(closedBinderType);
                provider = new SimpleModelBinderProvider(modelType, binderInstance) { SuppressPrefixCheck = modelBinderAttribute.SuppressPrefixCheck };
            }
            else
            {
                throw Error.InvalidOperation(SRResources.ModelBinderProviderCollection_InvalidBinderType, modelBinderAttribute.BinderType, typeof(ModelBinderProvider), typeof(IModelBinder));
            }

            return true;
        }

        internal static bool TryGetProviderFromAttributes(Type modelType, out ModelBinderProvider provider)
        {
            ModelBinderAttribute attr = GetModelBinderAttribute(modelType);
            if (attr == null)
            {
                provider = null;
                return false;
            }

            return TryGetProviderFromAttribute(modelType, attr, out provider);
        }

        private static ModelBinderAttribute GetModelBinderAttribute(Type modelType)
        {
            ModelBinderAttribute modelBinderAttribute;
            if (!_modelBinderAttributeCache.TryGetValue(modelType, out modelBinderAttribute))
            {
                modelBinderAttribute = TypeDescriptorHelper.Get(modelType).GetAttributes().OfType<ModelBinderAttribute>().FirstOrDefault();
                _modelBinderAttributeCache.TryAdd(modelType, modelBinderAttribute);
            }
            return modelBinderAttribute;
        }

        internal static void ValidateBindingContext(ModelBindingContext bindingContext)
        {
            if (bindingContext == null)
            {
                throw Error.ArgumentNull("bindingContext");
            }

            if (bindingContext.ModelMetadata == null)
            {
                throw Error.Argument("bindingContext", SRResources.ModelBinderUtil_ModelMetadataCannotBeNull);
            }
        }

        internal static void ValidateBindingContext(ModelBindingContext bindingContext, Type requiredType, bool allowNullModel)
        {
            ValidateBindingContext(bindingContext);

            if (bindingContext.ModelType != requiredType)
            {
                throw Error.Argument("bindingContext", SRResources.ModelBinderUtil_ModelTypeIsWrong, bindingContext.ModelType, requiredType);
            }

            if (!allowNullModel && bindingContext.Model == null)
            {
                throw Error.Argument("bindingContext", SRResources.ModelBinderUtil_ModelCannotBeNull, requiredType);
            }

            if (bindingContext.Model != null && !requiredType.IsInstanceOfType(bindingContext.Model))
            {
                throw Error.Argument("bindingContext", SRResources.ModelBinderUtil_ModelInstanceIsWrong, bindingContext.Model.GetType(), requiredType);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelError.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ModelBinding
{
    [Serializable]
    public class ModelError
    {
        public ModelError(Exception exception)
            : this(exception, errorMessage: null)
        {
        }

        public ModelError(Exception exception, string errorMessage)
            : this(errorMessage)
        {
            if (exception == null)
            {
                throw Error.ArgumentNull("exception");
            }

            Exception = exception;
        }

        public ModelError(string errorMessage)
        {
            ErrorMessage = errorMessage ?? String.Empty;
        }

        public Exception Exception { get; private set; }

        public string ErrorMessage { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelErrorCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;

namespace System.Web.Http.ModelBinding
{
    [Serializable]
    public class ModelErrorCollection : Collection<ModelError>
    {
        public void Add(Exception exception)
        {
            Add(new ModelError(exception));
        }

        public void Add(string errorMessage)
        {
            Add(new ModelError(errorMessage));
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding
{
    [Serializable]
    public class ModelState
    {
        private ModelErrorCollection _errors = new ModelErrorCollection();

        public ValueProviderResult Value { get; set; }

        public ModelErrorCollection Errors
        {
            get { return _errors; }
        }
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ModelStateDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ModelBinding
{
    [Serializable]
    public class ModelStateDictionary : IDictionary<string, ModelState>
    {
        private readonly Dictionary<string, ModelState> _innerDictionary;

        public ModelStateDictionary()
        {
            _innerDictionary = new Dictionary<string, ModelState>(StringComparer.OrdinalIgnoreCase);
        }

        public ModelStateDictionary(ModelStateDictionary dictionary)
        {
            if (dictionary == null)
            {
                throw Error.ArgumentNull("dictionary");
            }

            _innerDictionary = new Dictionary<string, ModelState>(dictionary, StringComparer.OrdinalIgnoreCase);
        }

        public int Count
        {
            get { return _innerDictionary.Count; }
        }

        public bool IsReadOnly
        {
            get { return ((IDictionary<string, ModelState>)_innerDictionary).IsReadOnly; }
        }

        public bool IsValid
        {
            get { return Values.All(modelState => modelState.Errors.Count == 0); }
        }

        public ICollection<string> Keys
        {
            get { return _innerDictionary.Keys; }
        }

        public ICollection<ModelState> Values
        {
            get { return _innerDictionary.Values; }
        }

        public ModelState this[string key]
        {
            get
            {
                ModelState value;
                _innerDictionary.TryGetValue(key, out value);
                return value;
            }
            set { _innerDictionary[key] = value; }
        }

        public void Add(KeyValuePair<string, ModelState> item)
        {
            ((IDictionary<string, ModelState>)_innerDictionary).Add(item);
        }

        public void Add(string key, ModelState value)
        {
            _innerDictionary.Add(key, value);
        }

        public void AddModelError(string key, Exception exception)
        {
            GetModelStateForKey(key).Errors.Add(exception);
        }

        public void AddModelError(string key, string errorMessage)
        {
            GetModelStateForKey(key).Errors.Add(errorMessage);
        }

        public void Clear()
        {
            _innerDictionary.Clear();
        }

        public bool Contains(KeyValuePair<string, ModelState> item)
        {
            return ((IDictionary<string, ModelState>)_innerDictionary).Contains(item);
        }

        public bool ContainsKey(string key)
        {
            return _innerDictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<string, ModelState>[] array, int arrayIndex)
        {
            ((IDictionary<string, ModelState>)_innerDictionary).CopyTo(array, arrayIndex);
        }

        public IEnumerator<KeyValuePair<string, ModelState>> GetEnumerator()
        {
            return _innerDictionary.GetEnumerator();
        }

        private ModelState GetModelStateForKey(string key)
        {
            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            ModelState modelState;
            if (!TryGetValue(key, out modelState))
            {
                modelState = new ModelState();
                this[key] = modelState;
            }

            return modelState;
        }

        public bool IsValidField(string key)
        {
            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            // if the key is not found in the dictionary, we just say that it's valid (since there are no errors)
            foreach (KeyValuePair<string, ModelState> entry in this.FindKeysWithPrefix(key))
            {
                if (entry.Value.Errors.Count != 0)
                {
                    return false;
                }
            }
            return true;
        }

        public void Merge(ModelStateDictionary dictionary)
        {
            if (dictionary == null)
            {
                return;
            }

            foreach (var entry in dictionary)
            {
                this[entry.Key] = entry.Value;
            }
        }

        public bool Remove(KeyValuePair<string, ModelState> item)
        {
            return ((IDictionary<string, ModelState>)_innerDictionary).Remove(item);
        }

        public bool Remove(string key)
        {
            return _innerDictionary.Remove(key);
        }

        public void SetModelValue(string key, ValueProviderResult value)
        {
            GetModelStateForKey(key).Value = value;
        }

        public bool TryGetValue(string key, out ModelState value)
        {
            return _innerDictionary.TryGetValue(key, out value);
        }

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_innerDictionary).GetEnumerator();
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Http/ModelBinding/ParameterBindingRulesCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Web.Http.Controllers;

namespace System.Web.Http.ModelBinding
{    
    /// <summary>
    /// Collection of functions that can produce a parameter binding for a given parameter.   
    /// </summary>
    public class ParameterBindingRulesCollection : Collection<Func<HttpParameterDescriptor, HttpParameterBinding>>
    {
        // Helper to wrap the lambda in a type-check
        // This is for convenience overloads that want to register by type, which should be a common case.
        private static Func<HttpParameterDescriptor, HttpParameterBinding> TypeCheck(Type type, Func<HttpParameterDescriptor, HttpParameterBinding> func)
        {
            return (param => (param.ParameterType == type) ? func(param) : null);
        }
                
        /// <summary>
        /// Adds function to the end of the collection. 
        /// The function added is a wrapper around funcInner that checks that parameterType matches typeMatch.
        /// </summary>
        /// <param name="typeMatch">type to match against HttpParameterDescriptor.ParameterType</param>
        /// <param name="funcInner">inner function that is invoked if type match succeeds</param>
        public void Add(Type typeMatch, Func<HttpParameterDescriptor, HttpParameterBinding> funcInner)
        {
            Add(TypeCheck(typeMatch, funcInner));
        }

        /// <summary>
        /// Insert a function at the specified index in the collection.
        /// /// The function added is a wrapper around funcInner that checks that parameterType matches typeMatch.
        /// </summary>
        /// <param name="index">index to insert at.</param>
        /// <param name="typeMatch">type to match against HttpParameterDescriptor.ParameterType</param>
        /// <param name="funcInner">inner function that is invoked if type match succeeds</param>
        public void Insert(int index, Type typeMatch, Func<HttpParameterDescriptor, HttpParameterBinding> funcInner)
        {
            Insert(index, TypeCheck(typeMatch, funcInner));
        }
                
        /// <summary>
        /// Execute each binding function in order until one of them returns a non-null binding. 
        /// </summary>
        /// <param name="parameter">parameter to bind.</param>
        /// <returns>the first non-null binding produced for the parameter. Of null if no binding is produced.</returns>
        public HttpParameterBinding LookupBinding(HttpParameterDescriptor parameter)
        {
            foreach (Func<HttpParameterDescriptor, HttpParameterBinding> func in this)
            {
                HttpParameterBinding binding = func(parameter);
                if (binding != null)
                {
                    return binding;
                }
            }
            return null;
        }
    }
}


================================================
FILE: src/System.Web.Http/NonActionAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Apply this attribute on a method so that it is not publicly reachable via routing. 
    /// The method will not be considered an action.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class NonActionAttribute : Attribute
    {
    }
}


================================================
FILE: src/System.Web.Http/OverrideActionFiltersAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Filters;

namespace System.Web.Http
{
    /// <summary>Represents a filter attribute that overrides action filters defined at a higher level.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideActionFiltersAttribute : Attribute, IOverrideFilter
    {
        /// <inheritdoc />
        public bool AllowMultiple
        {
            get { return false; }
        }

        /// <inheritdoc />
        public Type FiltersToOverride
        {
            get { return typeof(IActionFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Http/OverrideAuthenticationAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Filters;

namespace System.Web.Http
{
    /// <summary>
    /// Represents a filter attribute that overrides authentication filters defined at a higher level.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideAuthenticationAttribute : Attribute, IOverrideFilter
    {
        public bool AllowMultiple
        {
            get { return false; }
        }

        public Type FiltersToOverride
        {
            get { return typeof(IAuthenticationFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Http/OverrideAuthorizationAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Filters;

namespace System.Web.Http
{
    /// <summary>
    /// Represents a filter attribute that overrides authorization filters defined at a higher level.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideAuthorizationAttribute : Attribute, IOverrideFilter
    {
        public bool AllowMultiple
        {
            get { return false; }
        }

        public Type FiltersToOverride
        {
            get { return typeof(IAuthorizationFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Http/OverrideExceptionFiltersAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Filters;

namespace System.Web.Http
{
    /// <summary>Represents a filter attribute that overrides exception filters defined at a higher level.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideExceptionFiltersAttribute : Attribute, IOverrideFilter
    {
        public bool AllowMultiple
        {
            get { return false; }
        }

        public Type FiltersToOverride
        {
            get { return typeof(IExceptionFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Http/ParameterBindingAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http
{
    /// <summary>
    /// Attribute on a parameter or type that produces a <see cref="HttpParameterBinding"/>. 
    /// If the attribute is on a type-declaration, then it's as if that attribute is present on all action parameters 
    /// of that type.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
    public abstract class ParameterBindingAttribute : Attribute
    {
        public abstract HttpParameterBinding GetBinding(HttpParameterDescriptor parameter);
    }
}

================================================
FILE: src/System.Web.Http/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

[assembly: AssemblyTitle("System.Web.Http")]
[assembly: AssemblyDescription("")]
[assembly: Guid("70cecdcd-46f5-492b-9e1f-1d9a947f1fd1")]
[assembly: InternalsVisibleTo("System.Web.Http.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Web.Http.Integration.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/System.Web.Http/Properties/SRResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.34011
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class SRResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SRResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.Properties.SRResources", typeof(SRResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The method &apos;{0}&apos; on type &apos;{1}&apos; returned a Task instance even though it is not an asynchronous method..
        /// </summary>
        internal static string ActionExecutor_UnexpectedTaskInstance {
            get {
                return ResourceManager.GetString("ActionExecutor_UnexpectedTaskInstance", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The method &apos;{0}&apos; on type &apos;{1}&apos; returned an instance of &apos;{2}&apos;. Make sure to call Unwrap on the returned value to avoid unobserved faulted Task..
        /// </summary>
        internal static string ActionExecutor_WrappedTaskInstance {
            get {
                return ResourceManager.GetString("ActionExecutor_WrappedTaskInstance", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to After calling {0}.OnActionExecuted, the HttpActionExecutedContext properties Result and Exception were both null. At least one of these values must be non-null. To provide a new response, please set the Result object; to indicate an error, please throw an exception..
        /// </summary>
        internal static string ActionFilterAttribute_MustSupplyResponseOrException {
            get {
                return ResourceManager.GetString("ActionFilterAttribute_MustSupplyResponseOrException", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} on type {1}.
        /// </summary>
        internal static string ActionSelector_AmbiguousMatchType {
            get {
                return ResourceManager.GetString("ActionSelector_AmbiguousMatchType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ApiController.Request must not be null..
        /// </summary>
        internal static string ApiController_RequestMustNotBeNull {
            get {
                return ResourceManager.GetString("ApiController_RequestMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An object of type &apos;{0}&apos; was returned where an instance of IHttpActionResult was expected..
        /// </summary>
        internal static string ApiControllerActionInvoker_InvalidHttpActionResult {
            get {
                return ResourceManager.GetString("ApiControllerActionInvoker_InvalidHttpActionResult", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A null value was returned where an instance of IHttpActionResult was expected..
        /// </summary>
        internal static string ApiControllerActionInvoker_NullHttpActionResult {
            get {
                return ResourceManager.GetString("ApiControllerActionInvoker_NullHttpActionResult", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No action was found on the controller &apos;{0}&apos; that matches the name &apos;{1}&apos;..
        /// </summary>
        internal static string ApiControllerActionSelector_ActionNameNotFound {
            get {
                return ResourceManager.GetString("ApiControllerActionSelector_ActionNameNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No action was found on the controller &apos;{0}&apos; that matches the request..
        /// </summary>
        internal static string ApiControllerActionSelector_ActionNotFound {
            get {
                return ResourceManager.GetString("ApiControllerActionSelector_ActionNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple actions were found that match the request: {0}.
        /// </summary>
        internal static string ApiControllerActionSelector_AmbiguousMatch {
            get {
                return ResourceManager.GetString("ApiControllerActionSelector_AmbiguousMatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The requested resource does not support http method &apos;{0}&apos;..
        /// </summary>
        internal static string ApiControllerActionSelector_HttpMethodNotSupported {
            get {
                return ResourceManager.GetString("ApiControllerActionSelector_HttpMethodNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route prefix &apos;{0}&apos; on the controller named &apos;{1}&apos; cannot end with a &apos;/&apos; character..
        /// </summary>
        internal static string AttributeRoutes_InvalidPrefix {
            get {
                return ResourceManager.GetString("AttributeRoutes_InvalidPrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route template &apos;{0}&apos; on the action named &apos;{1}&apos; cannot start with a &apos;/&apos; character..
        /// </summary>
        internal static string AttributeRoutes_InvalidTemplate {
            get {
                return ResourceManager.GetString("AttributeRoutes_InvalidTemplate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The authentication filter did not encounter an error or set a principal..
        /// </summary>
        internal static string AuthenticationFilterDidNothing {
            get {
                return ResourceManager.GetString("AuthenticationFilterDidNothing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The authentication filter encountered an error. ErrorResult=&apos;{0}&apos;..
        /// </summary>
        internal static string AuthenticationFilterErrorResult {
            get {
                return ResourceManager.GetString("AuthenticationFilterErrorResult", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The authentication filter successfully set a principal to a known identity. Identity.Name=&apos;{0}&apos;. Identity.AuthenticationType=&apos;{1}&apos;..
        /// </summary>
        internal static string AuthenticationFilterSetPrincipalToKnownIdentity {
            get {
                return ResourceManager.GetString("AuthenticationFilterSetPrincipalToKnownIdentity", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The authentication filter set a principal to an unknown identity..
        /// </summary>
        internal static string AuthenticationFilterSetPrincipalToUnknownIdentity {
            get {
                return ResourceManager.GetString("AuthenticationFilterSetPrincipalToUnknownIdentity", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request is invalid..
        /// </summary>
        internal static string BadRequest {
            get {
                return ResourceManager.GetString("BadRequest", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The batch request must have a &quot;Content-Type&quot; header..
        /// </summary>
        internal static string BatchContentTypeMissing {
            get {
                return ResourceManager.GetString("BatchContentTypeMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The batch request of media type &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string BatchMediaTypeNotSupported {
            get {
                return ResourceManager.GetString("BatchMediaTypeNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;Content&apos; property on the batch request cannot be null..
        /// </summary>
        internal static string BatchRequestMissingContent {
            get {
                return ResourceManager.GetString("BatchRequestMissingContent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot reuse an &apos;{0}&apos; instance. &apos;{0}&apos; has to be constructed per incoming message. Check your custom &apos;{1}&apos; and make sure that it will not manufacture the same instance..
        /// </summary>
        internal static string CannotSupportSingletonInstance {
            get {
                return ResourceManager.GetString("CannotSupportSingletonInstance", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter &apos;{0}&apos; cannot contain a null element..
        /// </summary>
        internal static string CollectionParameterContainsNullElement {
            get {
                return ResourceManager.GetString("CollectionParameterContainsNullElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property {0}.{1} could not be found..
        /// </summary>
        internal static string Common_PropertyNotFound {
            get {
                return ResourceManager.GetString("Common_PropertyNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type {0} must derive from {1}..
        /// </summary>
        internal static string Common_TypeMustDriveFromType {
            get {
                return ResourceManager.GetString("Common_TypeMustDriveFromType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No route providing a controller name was found to match request URI &apos;{0}&apos;.
        /// </summary>
        internal static string ControllerNameNotFound {
            get {
                return ResourceManager.GetString("ControllerNameNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type {0} must have a public constructor which accepts three parameters of types {1}, {2}, and {3}..
        /// </summary>
        internal static string DataAnnotationsModelValidatorProvider_ConstructorRequirements {
            get {
                return ResourceManager.GetString("DataAnnotationsModelValidatorProvider_ConstructorRequirements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type {0} must have a public constructor which accepts two parameters of types {1} and {2}..
        /// </summary>
        internal static string DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements {
            get {
                return ResourceManager.GetString("DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple types were found that match the controller named &apos;{0}&apos;. This can happen if the route that services this request (&apos;{1}&apos;) found multiple controllers defined with the same name but differing namespaces, which is not supported.{3}{3}The request for &apos;{0}&apos; has found the following matching controllers:{2}.
        /// </summary>
        internal static string DefaultControllerFactory_ControllerNameAmbiguous_WithRouteTemplate {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_ControllerNameAmbiguous_WithRouteTemplate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No type was found that matches the controller named &apos;{0}&apos;..
        /// </summary>
        internal static string DefaultControllerFactory_ControllerNameNotFound {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_ControllerNameNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error occurred when trying to create a controller of type &apos;{0}&apos;. Make sure that the controller has a parameterless public constructor..
        /// </summary>
        internal static string DefaultControllerFactory_ErrorCreatingController {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_ErrorCreatingController", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constructor to use for activating the constraint type &apos;{0}&apos; is ambiguous. Multiple constructors were found with the following number of parameters: {1}..
        /// </summary>
        internal static string DefaultInlineConstraintResolver_AmbiguousCtors {
            get {
                return ResourceManager.GetString("DefaultInlineConstraintResolver_AmbiguousCtors", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not find a constructor for constraint type &apos;{0}&apos; with the following number of parameters: {1}..
        /// </summary>
        internal static string DefaultInlineConstraintResolver_CouldNotFindCtor {
            get {
                return ResourceManager.GetString("DefaultInlineConstraintResolver_CouldNotFindCtor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constraint type &apos;{0}&apos; which is mapped to constraint key &apos;{1}&apos; must implement the IHttpRouteConstraint interface..
        /// </summary>
        internal static string DefaultInlineConstraintResolver_TypeNotConstraint {
            get {
                return ResourceManager.GetString("DefaultInlineConstraintResolver_TypeNotConstraint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The service type {0} is not supported..
        /// </summary>
        internal static string DefaultServices_InvalidServiceType {
            get {
                return ResourceManager.GetString("DefaultServices_InvalidServiceType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A dependency resolver of type &apos;{0}&apos; returned an invalid value of null from its BeginScope method. If the container does not have a concept of scope, consider returning a scope that resolves in the root of the container instead..
        /// </summary>
        internal static string DependencyResolver_BeginScopeReturnsNull {
            get {
                return ResourceManager.GetString("DependencyResolver_BeginScopeReturnsNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No service registered for type &apos;{0}&apos;..
        /// </summary>
        internal static string DependencyResolverNoService {
            get {
                return ResourceManager.GetString("DependencyResolverNoService", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple controller types were found that match the URL. This can happen if attribute routes on multiple controllers match the requested URL.{1}{1}The request has found the following matching controller types: {0}.
        /// </summary>
        internal static string DirectRoute_AmbiguousController {
            get {
                return ResourceManager.GetString("DirectRoute_AmbiguousController", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Direct routing does not support per-route message handlers..
        /// </summary>
        internal static string DirectRoute_HandlerNotSupported {
            get {
                return ResourceManager.GetString("DirectRoute_HandlerNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A direct route for an action method cannot use the parameter &apos;action&apos;. Specify a literal path in place of this parameter to create a route to the action..
        /// </summary>
        internal static string DirectRoute_InvalidParameter_Action {
            get {
                return ResourceManager.GetString("DirectRoute_InvalidParameter_Action", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A direct route cannot use the parameter &apos;controller&apos;. Specify a literal path in place of this parameter to create a route to a controller..
        /// </summary>
        internal static string DirectRoute_InvalidParameter_Controller {
            get {
                return ResourceManager.GetString("DirectRoute_InvalidParameter_Controller", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route does not have any associated action descriptors. Routing requires that each direct route map to a non-empty set of actions..
        /// </summary>
        internal static string DirectRoute_MissingActionDescriptors {
            get {
                return ResourceManager.GetString("DirectRoute_MissingActionDescriptors", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error has occurred..
        /// </summary>
        internal static string ErrorOccurred {
            get {
                return ResourceManager.GetString("ErrorOccurred", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No action result converter could be constructed for a generic parameter type &apos;{0}&apos;..
        /// </summary>
        internal static string HttpActionDescriptor_NoConverterForGenericParamterTypeExists {
            get {
                return ResourceManager.GetString("HttpActionDescriptor_NoConverterForGenericParamterTypeExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HttpControllerContext.Configuration must not be null..
        /// </summary>
        internal static string HttpControllerContext_ConfigurationMustNotBeNull {
            get {
                return ResourceManager.GetString("HttpControllerContext_ConfigurationMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request does not have an associated configuration object or the provided configuration was null..
        /// </summary>
        internal static string HttpRequestMessageExtensions_NoConfiguration {
            get {
                return ResourceManager.GetString("HttpRequestMessageExtensions_NoConfiguration", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided configuration does not have an instance of the &apos;{0}&apos; service registered..
        /// </summary>
        internal static string HttpRequestMessageExtensions_NoContentNegotiator {
            get {
                return ResourceManager.GetString("HttpRequestMessageExtensions_NoContentNegotiator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not find a formatter matching the media type &apos;{0}&apos; that can write an instance of &apos;{1}&apos;..
        /// </summary>
        internal static string HttpRequestMessageExtensions_NoMatchingFormatter {
            get {
                return ResourceManager.GetString("HttpRequestMessageExtensions_NoMatchingFormatter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Processing of the HTTP request resulted in an exception. Please see the HTTP response returned by the &apos;Response&apos; property of this exception for details..
        /// </summary>
        internal static string HttpResponseExceptionMessage {
            get {
                return ResourceManager.GetString("HttpResponseExceptionMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The inline constraint resolver of type &apos;{0}&apos; was unable to resolve the following inline constraint: &apos;{1}&apos;..
        /// </summary>
        internal static string HttpRouteBuilder_CouldNotResolveConstraint {
            get {
                return ResourceManager.GetString("HttpRouteBuilder_CouldNotResolveConstraint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The server is no longer available..
        /// </summary>
        internal static string HttpServerDisposed {
            get {
                return ResourceManager.GetString("HttpServerDisposed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key is invalid JQuery syntax because it is missing a closing bracket.
        /// </summary>
        internal static string JQuerySyntaxMissingClosingBracket {
            get {
                return ResourceManager.GetString("JQuerySyntaxMissingClosingBracket", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The number of keys in a NameValueCollection has exceeded the limit of &apos;{0}&apos;. You can adjust it by modifying the MaxHttpCollectionKeys property on the &apos;{1}&apos; class..
        /// </summary>
        internal static string MaxHttpCollectionKeyLimitReached {
            get {
                return ResourceManager.GetString("MaxHttpCollectionKeyLimitReached", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Property &apos;{0}&apos; on type &apos;{1}&apos; is invalid. Value-typed properties marked as [Required] must also be marked with [DataMember(IsRequired=true)] to be recognized as required. Consider attributing the declaring type with [DataContract] and the property with [DataMember(IsRequired=true)]..
        /// </summary>
        internal static string MissingDataMemberIsRequired {
            get {
                return ResourceManager.GetString("MissingDataMemberIsRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} property is required..
        /// </summary>
        internal static string MissingRequiredMember {
            get {
                return ResourceManager.GetString("MissingRequiredMember", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value &apos;{0}&apos; is not valid for {1}..
        /// </summary>
        internal static string ModelBinderConfig_ValueInvalid {
            get {
                return ResourceManager.GetString("ModelBinderConfig_ValueInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value is required..
        /// </summary>
        internal static string ModelBinderConfig_ValueRequired {
            get {
                return ResourceManager.GetString("ModelBinderConfig_ValueRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; does not subclass {1} or implement the interface {2}..
        /// </summary>
        internal static string ModelBinderProviderCollection_InvalidBinderType {
            get {
                return ResourceManager.GetString("ModelBinderProviderCollection_InvalidBinderType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context has a null Model, but this binder requires a non-null model of type &apos;{0}&apos;..
        /// </summary>
        internal static string ModelBinderUtil_ModelCannotBeNull {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context has a Model of type &apos;{0}&apos;, but this binder can only operate on models of type &apos;{1}&apos;..
        /// </summary>
        internal static string ModelBinderUtil_ModelInstanceIsWrong {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelInstanceIsWrong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context cannot have a null ModelMetadata..
        /// </summary>
        internal static string ModelBinderUtil_ModelMetadataCannotBeNull {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelMetadataCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The binding context has a ModelType of &apos;{0}&apos;, but this binder can only operate on models of type &apos;{1}&apos;..
        /// </summary>
        internal static string ModelBinderUtil_ModelTypeIsWrong {
            get {
                return ResourceManager.GetString("ModelBinderUtil_ModelTypeIsWrong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ModelMetadata property must be set before accessing this property..
        /// </summary>
        internal static string ModelBindingContext_ModelMetadataMustBeSet {
            get {
                return ResourceManager.GetString("ModelBindingContext_ModelMetadataMustBeSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No controller was created to handle this request..
        /// </summary>
        internal static string NoControllerCreated {
            get {
                return ResourceManager.GetString("NoControllerCreated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No controller was selected to handle this request..
        /// </summary>
        internal static string NoControllerSelected {
            get {
                return ResourceManager.GetString("NoControllerSelected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No route data was found for this request..
        /// </summary>
        internal static string NoRouteData {
            get {
                return ResourceManager.GetString("NoRouteData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The object has not yet been initialized. Ensure that HttpConfiguration.EnsureInitialized() is called in the application&apos;s startup code after all other initialization code..
        /// </summary>
        internal static string Object_NotYetInitialized {
            get {
                return ResourceManager.GetString("Object_NotYetInitialized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Optional parameter &apos;{0}&apos; is not supported by &apos;{1}&apos;..
        /// </summary>
        internal static string OptionalBodyParameterNotSupported {
            get {
                return ResourceManager.GetString("OptionalBodyParameterNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Can&apos;t bind multiple parameters (&apos;{0}&apos; and &apos;{1}&apos;) to the request&apos;s content..
        /// </summary>
        internal static string ParameterBindingCantHaveMultipleBodyParameters {
            get {
                return ResourceManager.GetString("ParameterBindingCantHaveMultipleBodyParameters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Can&apos;t bind parameter &apos;{0}&apos; because it has conflicting attributes on it..
        /// </summary>
        internal static string ParameterBindingConflictingAttributes {
            get {
                return ResourceManager.GetString("ParameterBindingConflictingAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Can&apos;t bind parameter &apos;{1}&apos;. Must specify a custom model binder to bind parameters of type &apos;{0}&apos;..
        /// </summary>
        internal static string ParameterBindingIllegalType {
            get {
                return ResourceManager.GetString("ParameterBindingIllegalType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameters dictionary contains a null entry for parameter &apos;{0}&apos; of non-nullable type &apos;{1}&apos; for method &apos;{2}&apos; in &apos;{3}&apos;. An optional parameter must be a reference type, a nullable type, or be declared as an optional parameter..
        /// </summary>
        internal static string ReflectedActionDescriptor_ParameterCannotBeNull {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_ParameterCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameters dictionary does not contain an entry for parameter &apos;{0}&apos; of type &apos;{1}&apos; for method &apos;{2}&apos; in &apos;{3}&apos;. The dictionary must contain an entry for each parameter, including parameters that have null values..
        /// </summary>
        internal static string ReflectedActionDescriptor_ParameterNotInDictionary {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_ParameterNotInDictionary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameters dictionary contains an invalid entry for parameter &apos;{0}&apos; for method &apos;{1}&apos; in &apos;{2}&apos;. The dictionary contains a value of type &apos;{3}&apos;, but the parameter requires a value of type &apos;{4}&apos;..
        /// </summary>
        internal static string ReflectedActionDescriptor_ParameterValueHasWrongType {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_ParameterValueHasWrongType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot call action method &apos;{0}&apos; on controller &apos;{1}&apos; because the action method is a generic method..
        /// </summary>
        internal static string ReflectedHttpActionDescriptor_CannotCallOpenGenericMethods {
            get {
                return ResourceManager.GetString("ReflectedHttpActionDescriptor_CannotCallOpenGenericMethods", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request must have a request context..
        /// </summary>
        internal static string Request_RequestContextMustNotBeNull {
            get {
                return ResourceManager.GetString("Request_RequestContextMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request context property on the request must be null or match ApiController.RequestContext..
        /// </summary>
        internal static string RequestContextConflict {
            get {
                return ResourceManager.GetString("RequestContextConflict", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property &apos;Request&apos; on &apos;{0}&apos; is null. The property must be initialized with a non-null value..
        /// </summary>
        internal static string RequestIsNull {
            get {
                return ResourceManager.GetString("RequestIsNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Authorization has been denied for this request..
        /// </summary>
        internal static string RequestNotAuthorized {
            get {
                return ResourceManager.GetString("RequestNotAuthorized", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No HTTP resource was found that matches the request URI &apos;{0}&apos;..
        /// </summary>
        internal static string ResourceNotFound {
            get {
                return ResourceManager.GetString("ResourceNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A null value was returned where an instance of HttpResponseMessage was expected..
        /// </summary>
        internal static string ResponseMessageResultConverter_NullHttpResponseMessage {
            get {
                return ResourceManager.GetString("ResponseMessageResultConverter_NullHttpResponseMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding or removing items from a &apos;{0}&apos; is not supported. Please use a key when adding and removing items..
        /// </summary>
        internal static string Route_AddRemoveWithNoKeyNotSupported {
            get {
                return ResourceManager.GetString("Route_AddRemoveWithNoKeyNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path segment that contains more than one section, such as a literal section or a parameter, cannot contain a catch-all parameter..
        /// </summary>
        internal static string Route_CannotHaveCatchAllInMultiSegment {
            get {
                return ResourceManager.GetString("Route_CannotHaveCatchAllInMultiSegment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path segment cannot contain two consecutive parameters. They must be separated by a &apos;/&apos; or by a literal string..
        /// </summary>
        internal static string Route_CannotHaveConsecutiveParameters {
            get {
                return ResourceManager.GetString("Route_CannotHaveConsecutiveParameters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route template separator character &apos;/&apos; cannot appear consecutively. It must be separated by either a parameter or a literal value..
        /// </summary>
        internal static string Route_CannotHaveConsecutiveSeparators {
            get {
                return ResourceManager.GetString("Route_CannotHaveConsecutiveSeparators", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A catch-all parameter can only appear as the last segment of the route template..
        /// </summary>
        internal static string Route_CatchAllMustBeLast {
            get {
                return ResourceManager.GetString("Route_CatchAllMustBeLast", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route parameter name &apos;{0}&apos; is invalid. Route parameter names must be non-empty and cannot contain these characters: &quot;{{&quot;, &quot;}}&quot;, &quot;/&quot;, &quot;?&quot;.
        /// </summary>
        internal static string Route_InvalidParameterName {
            get {
                return ResourceManager.GetString("Route_InvalidParameterName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route template cannot start with a &apos;/&apos; or &apos;~&apos; character and it cannot contain a &apos;?&apos; character..
        /// </summary>
        internal static string Route_InvalidRouteTemplate {
            get {
                return ResourceManager.GetString("Route_InvalidRouteTemplate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There is an incomplete parameter in this path segment: &apos;{0}&apos;. Check that each &apos;{{&apos; character has a matching &apos;}}&apos; character..
        /// </summary>
        internal static string Route_MismatchedParameter {
            get {
                return ResourceManager.GetString("Route_MismatchedParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route parameter name &apos;{0}&apos; appears more than one time in the route template..
        /// </summary>
        internal static string Route_RepeatedParameter {
            get {
                return ResourceManager.GetString("Route_RepeatedParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constraint entry &apos;{0}&apos; on the route with route template &apos;{1}&apos; must have a string value or be of a type which implements &apos;{2}&apos;..
        /// </summary>
        internal static string Route_ValidationMustBeStringOrCustomConstraint {
            get {
                return ResourceManager.GetString("Route_ValidationMustBeStringOrCustomConstraint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A route named &apos;{0}&apos; could not be found in the route collection..
        /// </summary>
        internal static string RouteCollection_NameNotFound {
            get {
                return ResourceManager.GetString("RouteCollection_NameNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only one route prefix attribute is supported. Remove extra attributes from the controller of type &apos;{0}&apos;..
        /// </summary>
        internal static string RoutePrefix_CannotSupportMultiRoutePrefix {
            get {
                return ResourceManager.GetString("RoutePrefix_CannotSupportMultiRoutePrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property &apos;prefix&apos; from route prefix attribute on controller of type &apos;{0}&apos; cannot be null..
        /// </summary>
        internal static string RoutePrefix_PrefixCannotBeNull {
            get {
                return ResourceManager.GetString("RoutePrefix_PrefixCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A route named &apos;{0}&apos; is already in the route collection. Route names must be unique.
        ///
        ///Duplicates:
        ///{1}
        ///{2}.
        /// </summary>
        internal static string SubRouteCollection_DuplicateRouteName {
            get {
                return ResourceManager.GetString("SubRouteCollection_DuplicateRouteName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Action filter for &apos;{0}&apos;.
        /// </summary>
        internal static string TraceActionFilterMessage {
            get {
                return ResourceManager.GetString("TraceActionFilterMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Action=&apos;{0}&apos;.
        /// </summary>
        internal static string TraceActionInvokeMessage {
            get {
                return ResourceManager.GetString("TraceActionInvokeMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Action returned &apos;{0}&apos;.
        /// </summary>
        internal static string TraceActionReturnValue {
            get {
                return ResourceManager.GetString("TraceActionReturnValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selected action &apos;{0}&apos;.
        /// </summary>
        internal static string TraceActionSelectedMessage {
            get {
                return ResourceManager.GetString("TraceActionSelectedMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Binding parameter &apos;{0}&apos;.
        /// </summary>
        internal static string TraceBeginParameterBind {
            get {
                return ResourceManager.GetString("TraceBeginParameterBind", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cancelled.
        /// </summary>
        internal static string TraceCancelledMessage {
            get {
                return ResourceManager.GetString("TraceCancelledMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; bound to the value &apos;{1}&apos;.
        /// </summary>
        internal static string TraceEndParameterBind {
            get {
                return ResourceManager.GetString("TraceEndParameterBind", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parameter &apos;{0}&apos; failed to bind..
        /// </summary>
        internal static string TraceEndParameterBindNoBind {
            get {
                return ResourceManager.GetString("TraceEndParameterBindNoBind", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Will use same &apos;{0}&apos; formatter.
        /// </summary>
        internal static string TraceGetPerRequestFormatterEndMessage {
            get {
                return ResourceManager.GetString("TraceGetPerRequestFormatterEndMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Will use new &apos;{0}&apos; formatter.
        /// </summary>
        internal static string TraceGetPerRequestFormatterEndMessageNew {
            get {
                return ResourceManager.GetString("TraceGetPerRequestFormatterEndMessageNew", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Obtaining formatter of type &apos;{0}&apos; for type=&apos;{1}&apos;, mediaType=&apos;{2}&apos;.
        /// </summary>
        internal static string TraceGetPerRequestFormatterMessage {
            get {
                return ResourceManager.GetString("TraceGetPerRequestFormatterMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Null formatter.
        /// </summary>
        internal static string TraceGetPerRequestNullFormatterEndMessage {
            get {
                return ResourceManager.GetString("TraceGetPerRequestNullFormatterEndMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exception thrown while getting types from &apos;{0}&apos;..
        /// </summary>
        internal static string TraceHttpControllerTypeResolverError {
            get {
                return ResourceManager.GetString("TraceHttpControllerTypeResolverError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invoking action &apos;{0}&apos;.
        /// </summary>
        internal static string TraceInvokingAction {
            get {
                return ResourceManager.GetString("TraceInvokingAction", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}: {1}.
        /// </summary>
        internal static string TraceModelStateErrorMessage {
            get {
                return ResourceManager.GetString("TraceModelStateErrorMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Model state is invalid. {0}.
        /// </summary>
        internal static string TraceModelStateInvalidMessage {
            get {
                return ResourceManager.GetString("TraceModelStateInvalidMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type=&apos;{0}&apos;, formatters=[{1}].
        /// </summary>
        internal static string TraceNegotiateFormatter {
            get {
                return ResourceManager.GetString("TraceNegotiateFormatter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to none.
        /// </summary>
        internal static string TraceNoneObjectMessage {
            get {
                return ResourceManager.GetString("TraceNoneObjectMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type=&apos;{0}&apos;, content-type=&apos;{1}&apos;.
        /// </summary>
        internal static string TraceReadFromStreamMessage {
            get {
                return ResourceManager.GetString("TraceReadFromStreamMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value read=&apos;{0}&apos;.
        /// </summary>
        internal static string TraceReadFromStreamValueMessage {
            get {
                return ResourceManager.GetString("TraceReadFromStreamValueMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Content-type=&apos;{0}&apos;, content-length={1}.
        /// </summary>
        internal static string TraceRequestCompleteMessage {
            get {
                return ResourceManager.GetString("TraceRequestCompleteMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Route=&apos;{0}&apos;.
        /// </summary>
        internal static string TraceRouteMessage {
            get {
                return ResourceManager.GetString("TraceRouteMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selected formatter=&apos;{0}&apos;, content-type=&apos;{1}&apos;.
        /// </summary>
        internal static string TraceSelectedFormatter {
            get {
                return ResourceManager.GetString("TraceSelectedFormatter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to unknown.
        /// </summary>
        internal static string TraceUnknownMessage {
            get {
                return ResourceManager.GetString("TraceUnknownMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Model state is valid. Values: {0}.
        /// </summary>
        internal static string TraceValidModelState {
            get {
                return ResourceManager.GetString("TraceValidModelState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value=&apos;{0}&apos;, type=&apos;{1}&apos;, content-type=&apos;{2}&apos;.
        /// </summary>
        internal static string TraceWriteToStreamMessage {
            get {
                return ResourceManager.GetString("TraceWriteToStreamMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} instance must not be null..
        /// </summary>
        internal static string TypeInstanceMustNotBeNull {
            get {
                return ResourceManager.GetString("TypeInstanceMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}.{1} must not return null..
        /// </summary>
        internal static string TypeMethodMustNotReturnNull {
            get {
                return ResourceManager.GetString("TypeMethodMustNotReturnNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}.{1} must not be null..
        /// </summary>
        internal static string TypePropertyMustNotBeNull {
            get {
                return ResourceManager.GetString("TypePropertyMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request entity&apos;s media type &apos;{0}&apos; is not supported for this resource..
        /// </summary>
        internal static string UnsupportedMediaType {
            get {
                return ResourceManager.GetString("UnsupportedMediaType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request contains an entity body but no Content-Type header. The inferred media type &apos;{0}&apos; is not supported for this resource..
        /// </summary>
        internal static string UnsupportedMediaTypeNoContentType {
            get {
                return ResourceManager.GetString("UnsupportedMediaTypeNoContentType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to UrlHelper.Link must not return null..
        /// </summary>
        internal static string UrlHelper_LinkMustNotReturnNull {
            get {
                return ResourceManager.GetString("UrlHelper_LinkMustNotReturnNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model object inside the metadata claimed to be compatible with {0}, but was actually {1}..
        /// </summary>
        internal static string ValidatableObjectAdapter_IncompatibleType {
            get {
                return ResourceManager.GetString("ValidatableObjectAdapter_IncompatibleType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value is required but was not present in the request..
        /// </summary>
        internal static string Validation_ValueNotFound {
            get {
                return ResourceManager.GetString("Validation_ValueNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Field &apos;{0}&apos; on type &apos;{1}&apos; is attributed with one or more validation attributes. Validation attributes on fields are not supported. Consider using a public property for validation instead..
        /// </summary>
        internal static string ValidationAttributeOnField {
            get {
                return ResourceManager.GetString("ValidationAttributeOnField", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Non-public property &apos;{0}&apos; on type &apos;{1}&apos; is attributed with one or more validation attributes. Validation attributes on non-public properties are not supported. Consider using a public property for validation instead..
        /// </summary>
        internal static string ValidationAttributeOnNonPublicProperty {
            get {
                return ResourceManager.GetString("ValidationAttributeOnNonPublicProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model state is valid..
        /// </summary>
        internal static string ValidModelState {
            get {
                return ResourceManager.GetString("ValidModelState", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not create a &apos;{0}&apos; from &apos;{1}&apos;. Please ensure it derives from &apos;{0}&apos; and has a public parameterless constructor..
        /// </summary>
        internal static string ValueProviderFactory_Cannot_Create {
            get {
                return ResourceManager.GetString("ValueProviderFactory_Cannot_Create", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter conversion from type &apos;{0}&apos; to type &apos;{1}&apos; failed. See the inner exception for more information..
        /// </summary>
        internal static string ValueProviderResult_ConversionThrew {
            get {
                return ResourceManager.GetString("ValueProviderResult_ConversionThrew", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter conversion from type &apos;{0}&apos; to type &apos;{1}&apos; failed because no type converter can convert between these types..
        /// </summary>
        internal static string ValueProviderResult_NoConverterExists {
            get {
                return ResourceManager.GetString("ValueProviderResult_NoConverterExists", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Properties/SRResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="ModelBinderUtil_ModelCannotBeNull" xml:space="preserve">
    <value>The binding context has a null Model, but this binder requires a non-null model of type '{0}'.</value>
  </data>
  <data name="ModelBinderUtil_ModelInstanceIsWrong" xml:space="preserve">
    <value>The binding context has a Model of type '{0}', but this binder can only operate on models of type '{1}'.</value>
  </data>
  <data name="ModelBinderUtil_ModelMetadataCannotBeNull" xml:space="preserve">
    <value>The binding context cannot have a null ModelMetadata.</value>
  </data>
  <data name="ModelBinderUtil_ModelTypeIsWrong" xml:space="preserve">
    <value>The binding context has a ModelType of '{0}', but this binder can only operate on models of type '{1}'.</value>
  </data>
  <data name="ModelBinderConfig_ValueInvalid" xml:space="preserve">
    <value>The value '{0}' is not valid for {1}.</value>
  </data>
  <data name="ModelBinderConfig_ValueRequired" xml:space="preserve">
    <value>A value is required.</value>
  </data>
  <data name="ModelBindingContext_ModelMetadataMustBeSet" xml:space="preserve">
    <value>The ModelMetadata property must be set before accessing this property.</value>
  </data>
  <data name="Common_PropertyNotFound" xml:space="preserve">
    <value>The property {0}.{1} could not be found.</value>
  </data>
  <data name="ModelBinderProviderCollection_InvalidBinderType" xml:space="preserve">
    <value>The type '{0}' does not subclass {1} or implement the interface {2}.</value>
  </data>
  <data name="ValueProviderResult_ConversionThrew" xml:space="preserve">
    <value>The parameter conversion from type '{0}' to type '{1}' failed. See the inner exception for more information.</value>
  </data>
  <data name="ValueProviderResult_NoConverterExists" xml:space="preserve">
    <value>The parameter conversion from type '{0}' to type '{1}' failed because no type converter can convert between these types.</value>
  </data>
  <data name="Common_TypeMustDriveFromType" xml:space="preserve">
    <value>The type {0} must derive from {1}.</value>
  </data>
  <data name="DataAnnotationsModelValidatorProvider_ConstructorRequirements" xml:space="preserve">
    <value>The type {0} must have a public constructor which accepts three parameters of types {1}, {2}, and {3}.</value>
  </data>
  <data name="DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements" xml:space="preserve">
    <value>The type {0} must have a public constructor which accepts two parameters of types {1} and {2}.</value>
  </data>
  <data name="ValidatableObjectAdapter_IncompatibleType" xml:space="preserve">
    <value>The model object inside the metadata claimed to be compatible with {0}, but was actually {1}.</value>
  </data>
  <data name="HttpResponseExceptionMessage" xml:space="preserve">
    <value>Processing of the HTTP request resulted in an exception. Please see the HTTP response returned by the 'Response' property of this exception for details.</value>
  </data>
  <data name="ApiControllerActionSelector_AmbiguousMatch" xml:space="preserve">
    <value>Multiple actions were found that match the request: {0}</value>
  </data>
  <data name="DefaultControllerFactory_ControllerNameAmbiguous_WithRouteTemplate" xml:space="preserve">
    <value>Multiple types were found that match the controller named '{0}'. This can happen if the route that services this request ('{1}') found multiple controllers defined with the same name but differing namespaces, which is not supported.{3}{3}The request for '{0}' has found the following matching controllers:{2}</value>
  </data>
  <data name="DefaultControllerFactory_ControllerNameNotFound" xml:space="preserve">
    <value>No type was found that matches the controller named '{0}'.</value>
  </data>
  <data name="DefaultControllerFactory_ErrorCreatingController" xml:space="preserve">
    <value>An error occurred when trying to create a controller of type '{0}'. Make sure that the controller has a parameterless public constructor.</value>
  </data>
  <data name="DependencyResolverNoService" xml:space="preserve">
    <value>No service registered for type '{0}'.</value>
  </data>
  <data name="ApiControllerActionSelector_ActionNotFound" xml:space="preserve">
    <value>No action was found on the controller '{0}' that matches the request.</value>
  </data>
  <data name="ApiControllerActionSelector_ActionNameNotFound" xml:space="preserve">
    <value>No action was found on the controller '{0}' that matches the name '{1}'.</value>
  </data>
  <data name="ApiControllerActionSelector_HttpMethodNotSupported" xml:space="preserve">
    <value>The requested resource does not support http method '{0}'.</value>
  </data>
  <data name="ActionSelector_AmbiguousMatchType" xml:space="preserve">
    <value>{0} on type {1}</value>
  </data>
  <data name="ReflectedActionDescriptor_ParameterCannotBeNull" xml:space="preserve">
    <value>The parameters dictionary contains a null entry for parameter '{0}' of non-nullable type '{1}' for method '{2}' in '{3}'. An optional parameter must be a reference type, a nullable type, or be declared as an optional parameter.</value>
  </data>
  <data name="ReflectedActionDescriptor_ParameterNotInDictionary" xml:space="preserve">
    <value>The parameters dictionary does not contain an entry for parameter '{0}' of type '{1}' for method '{2}' in '{3}'. The dictionary must contain an entry for each parameter, including parameters that have null values.</value>
  </data>
  <data name="ReflectedActionDescriptor_ParameterValueHasWrongType" xml:space="preserve">
    <value>The parameters dictionary contains an invalid entry for parameter '{0}' for method '{1}' in '{2}'. The dictionary contains a value of type '{3}', but the parameter requires a value of type '{4}'.</value>
  </data>
  <data name="Route_CannotHaveCatchAllInMultiSegment" xml:space="preserve">
    <value>A path segment that contains more than one section, such as a literal section or a parameter, cannot contain a catch-all parameter.</value>
  </data>
  <data name="Route_CannotHaveConsecutiveParameters" xml:space="preserve">
    <value>A path segment cannot contain two consecutive parameters. They must be separated by a '/' or by a literal string.</value>
  </data>
  <data name="Route_CannotHaveConsecutiveSeparators" xml:space="preserve">
    <value>The route template separator character '/' cannot appear consecutively. It must be separated by either a parameter or a literal value.</value>
  </data>
  <data name="Route_CatchAllMustBeLast" xml:space="preserve">
    <value>A catch-all parameter can only appear as the last segment of the route template.</value>
  </data>
  <data name="Route_InvalidParameterName" xml:space="preserve">
    <value>The route parameter name '{0}' is invalid. Route parameter names must be non-empty and cannot contain these characters: "{{", "}}", "/", "?"</value>
  </data>
  <data name="Route_InvalidRouteTemplate" xml:space="preserve">
    <value>The route template cannot start with a '/' or '~' character and it cannot contain a '?' character.</value>
  </data>
  <data name="Route_MismatchedParameter" xml:space="preserve">
    <value>There is an incomplete parameter in this path segment: '{0}'. Check that each '{{' character has a matching '}}' character.</value>
  </data>
  <data name="Route_RepeatedParameter" xml:space="preserve">
    <value>The route parameter name '{0}' appears more than one time in the route template.</value>
  </data>
  <data name="Route_ValidationMustBeStringOrCustomConstraint" xml:space="preserve">
    <value>The constraint entry '{0}' on the route with route template '{1}' must have a string value or be of a type which implements '{2}'.</value>
  </data>
  <data name="Route_AddRemoveWithNoKeyNotSupported" xml:space="preserve">
    <value>Adding or removing items from a '{0}' is not supported. Please use a key when adding and removing items.</value>
  </data>
  <data name="ValueProviderFactory_Cannot_Create" xml:space="preserve">
    <value>Could not create a '{0}' from '{1}'. Please ensure it derives from '{0}' and has a public parameterless constructor.</value>
  </data>
  <data name="Validation_ValueNotFound" xml:space="preserve">
    <value>A value is required but was not present in the request.</value>
  </data>
  <data name="CannotSupportSingletonInstance" xml:space="preserve">
    <value>Cannot reuse an '{0}' instance. '{0}' has to be constructed per incoming message. Check your custom '{1}' and make sure that it will not manufacture the same instance.</value>
  </data>
  <data name="ActionFilterAttribute_MustSupplyResponseOrException" xml:space="preserve">
    <value>After calling {0}.OnActionExecuted, the HttpActionExecutedContext properties Result and Exception were both null. At least one of these values must be non-null. To provide a new response, please set the Result object; to indicate an error, please throw an exception.</value>
  </data>
  <data name="TraceActionInvokeMessage" xml:space="preserve">
    <value>Action='{0}'</value>
  </data>
  <data name="TraceActionFilterMessage" xml:space="preserve">
    <value>Action filter for '{0}'</value>
  </data>
  <data name="TraceActionSelectedMessage" xml:space="preserve">
    <value>Selected action '{0}'</value>
  </data>
  <data name="TraceCancelledMessage" xml:space="preserve">
    <value>Cancelled</value>
  </data>
  <data name="TraceRouteMessage" xml:space="preserve">
    <value>Route='{0}'</value>
  </data>
  <data name="TraceModelStateInvalidMessage" xml:space="preserve">
    <value>Model state is invalid. {0}</value>
  </data>
  <data name="TraceNoneObjectMessage" xml:space="preserve">
    <value>none</value>
  </data>
  <data name="TraceReadFromStreamMessage" xml:space="preserve">
    <value>Type='{0}', content-type='{1}'</value>
  </data>
  <data name="TraceReadFromStreamValueMessage" xml:space="preserve">
    <value>Value read='{0}'</value>
  </data>
  <data name="TraceRequestCompleteMessage" xml:space="preserve">
    <value>Content-type='{0}', content-length={1}</value>
  </data>
  <data name="TraceSelectedFormatter" xml:space="preserve">
    <value>Selected formatter='{0}', content-type='{1}'</value>
  </data>
  <data name="TraceNegotiateFormatter" xml:space="preserve">
    <value>Type='{0}', formatters=[{1}]</value>
  </data>
  <data name="TraceUnknownMessage" xml:space="preserve">
    <value>unknown</value>
  </data>
  <data name="TraceWriteToStreamMessage" xml:space="preserve">
    <value>Value='{0}', type='{1}', content-type='{2}'</value>
  </data>
  <data name="HttpRequestMessageExtensions_NoConfiguration" xml:space="preserve">
    <value>The request does not have an associated configuration object or the provided configuration was null.</value>
  </data>
  <data name="TraceGetPerRequestFormatterEndMessage" xml:space="preserve">
    <value>Will use same '{0}' formatter</value>
  </data>
  <data name="TraceGetPerRequestFormatterMessage" xml:space="preserve">
    <value>Obtaining formatter of type '{0}' for type='{1}', mediaType='{2}'</value>
  </data>
  <data name="RouteCollection_NameNotFound" xml:space="preserve">
    <value>A route named '{0}' could not be found in the route collection.</value>
  </data>
  <data name="ParameterBindingCantHaveMultipleBodyParameters" xml:space="preserve">
    <value>Can't bind multiple parameters ('{0}' and '{1}') to the request's content.</value>
  </data>
  <data name="ParameterBindingConflictingAttributes" xml:space="preserve">
    <value>Can't bind parameter '{0}' because it has conflicting attributes on it.</value>
  </data>
  <data name="ParameterBindingIllegalType" xml:space="preserve">
    <value>Can't bind parameter '{1}'. Must specify a custom model binder to bind parameters of type '{0}'.</value>
  </data>
  <data name="TraceBeginParameterBind" xml:space="preserve">
    <value>Binding parameter '{0}'</value>
  </data>
  <data name="TraceEndParameterBind" xml:space="preserve">
    <value>Parameter '{0}' bound to the value '{1}'</value>
  </data>
  <data name="TraceEndParameterBindNoBind" xml:space="preserve">
    <value>Parameter '{0}' failed to bind.</value>
  </data>
  <data name="TraceInvokingAction" xml:space="preserve">
    <value>Invoking action '{0}'</value>
  </data>
  <data name="TraceActionReturnValue" xml:space="preserve">
    <value>Action returned '{0}'</value>
  </data>
  <data name="TraceModelStateErrorMessage" xml:space="preserve">
    <value>{0}: {1}</value>
  </data>
  <data name="TraceGetPerRequestNullFormatterEndMessage" xml:space="preserve">
    <value>Null formatter</value>
  </data>
  <data name="TraceValidModelState" xml:space="preserve">
    <value>Model state is valid. Values: {0}</value>
  </data>
  <data name="TraceGetPerRequestFormatterEndMessageNew" xml:space="preserve">
    <value>Will use new '{0}' formatter</value>
  </data>
  <data name="JQuerySyntaxMissingClosingBracket" xml:space="preserve">
    <value>The key is invalid JQuery syntax because it is missing a closing bracket</value>
  </data>
  <data name="HttpRequestMessageExtensions_NoContentNegotiator" xml:space="preserve">
    <value>The provided configuration does not have an instance of the '{0}' service registered.</value>
  </data>
  <data name="ReflectedHttpActionDescriptor_CannotCallOpenGenericMethods" xml:space="preserve">
    <value>Cannot call action method '{0}' on controller '{1}' because the action method is a generic method.</value>
  </data>
  <data name="ResponseMessageResultConverter_NullHttpResponseMessage" xml:space="preserve">
    <value>A null value was returned where an instance of HttpResponseMessage was expected.</value>
  </data>
  <data name="ActionExecutor_UnexpectedTaskInstance" xml:space="preserve">
    <value>The method '{0}' on type '{1}' returned a Task instance even though it is not an asynchronous method.</value>
  </data>
  <data name="ActionExecutor_WrappedTaskInstance" xml:space="preserve">
    <value>The method '{0}' on type '{1}' returned an instance of '{2}'. Make sure to call Unwrap on the returned value to avoid unobserved faulted Task.</value>
  </data>
  <data name="HttpActionDescriptor_NoConverterForGenericParamterTypeExists" xml:space="preserve">
    <value>No action result converter could be constructed for a generic parameter type '{0}'.</value>
  </data>
  <data name="MissingRequiredMember" xml:space="preserve">
    <value>The {0} property is required.</value>
  </data>
  <data name="HttpRequestMessageExtensions_NoMatchingFormatter" xml:space="preserve">
    <value>Could not find a formatter matching the media type '{0}' that can write an instance of '{1}'.</value>
  </data>
  <data name="DefaultServices_InvalidServiceType" xml:space="preserve">
    <value>The service type {0} is not supported.</value>
  </data>
  <data name="MaxHttpCollectionKeyLimitReached" xml:space="preserve">
    <value>The number of keys in a NameValueCollection has exceeded the limit of '{0}'. You can adjust it by modifying the MaxHttpCollectionKeys property on the '{1}' class.</value>
  </data>
  <data name="ControllerNameNotFound" xml:space="preserve">
    <value>No route providing a controller name was found to match request URI '{0}'</value>
  </data>
  <data name="HttpServerDisposed" xml:space="preserve">
    <value>The server is no longer available.</value>
  </data>
  <data name="NoControllerCreated" xml:space="preserve">
    <value>No controller was created to handle this request.</value>
  </data>
  <data name="NoControllerSelected" xml:space="preserve">
    <value>No controller was selected to handle this request.</value>
  </data>
  <data name="NoRouteData" xml:space="preserve">
    <value>No route data was found for this request.</value>
  </data>
  <data name="RequestNotAuthorized" xml:space="preserve">
    <value>Authorization has been denied for this request.</value>
  </data>
  <data name="ValidModelState" xml:space="preserve">
    <value>The model state is valid.</value>
  </data>
  <data name="ErrorOccurred" xml:space="preserve">
    <value>An error has occurred.</value>
  </data>
  <data name="BadRequest" xml:space="preserve">
    <value>The request is invalid.</value>
  </data>
  <data name="ResourceNotFound" xml:space="preserve">
    <value>No HTTP resource was found that matches the request URI '{0}'.</value>
  </data>
  <data name="OptionalBodyParameterNotSupported" xml:space="preserve">
    <value>Optional parameter '{0}' is not supported by '{1}'.</value>
  </data>
  <data name="MissingDataMemberIsRequired" xml:space="preserve">
    <value>Property '{0}' on type '{1}' is invalid. Value-typed properties marked as [Required] must also be marked with [DataMember(IsRequired=true)] to be recognized as required. Consider attributing the declaring type with [DataContract] and the property with [DataMember(IsRequired=true)].</value>
  </data>
  <data name="ValidationAttributeOnField" xml:space="preserve">
    <value>Field '{0}' on type '{1}' is attributed with one or more validation attributes. Validation attributes on fields are not supported. Consider using a public property for validation instead.</value>
  </data>
  <data name="ValidationAttributeOnNonPublicProperty" xml:space="preserve">
    <value>Non-public property '{0}' on type '{1}' is attributed with one or more validation attributes. Validation attributes on non-public properties are not supported. Consider using a public property for validation instead.</value>
  </data>
  <data name="DependencyResolver_BeginScopeReturnsNull" xml:space="preserve">
    <value>A dependency resolver of type '{0}' returned an invalid value of null from its BeginScope method. If the container does not have a concept of scope, consider returning a scope that resolves in the root of the container instead.</value>
  </data>
  <data name="UnsupportedMediaType" xml:space="preserve">
    <value>The request entity's media type '{0}' is not supported for this resource.</value>
  </data>
  <data name="UnsupportedMediaTypeNoContentType" xml:space="preserve">
    <value>The request contains an entity body but no Content-Type header. The inferred media type '{0}' is not supported for this resource.</value>
  </data>
  <data name="DefaultInlineConstraintResolver_CouldNotFindCtor" xml:space="preserve">
    <value>Could not find a constructor for constraint type '{0}' with the following number of parameters: {1}.</value>
  </data>
  <data name="DefaultInlineConstraintResolver_TypeNotConstraint" xml:space="preserve">
    <value>The constraint type '{0}' which is mapped to constraint key '{1}' must implement the IHttpRouteConstraint interface.</value>
  </data>
  <data name="HttpRouteBuilder_CouldNotResolveConstraint" xml:space="preserve">
    <value>The inline constraint resolver of type '{0}' was unable to resolve the following inline constraint: '{1}'.</value>
  </data>
  <data name="DefaultInlineConstraintResolver_AmbiguousCtors" xml:space="preserve">
    <value>The constructor to use for activating the constraint type '{0}' is ambiguous. Multiple constructors were found with the following number of parameters: {1}.</value>
  </data>
  <data name="AttributeRoutes_InvalidPrefix" xml:space="preserve">
    <value>The route prefix '{0}' on the controller named '{1}' cannot end with a '/' character.</value>
  </data>
  <data name="AttributeRoutes_InvalidTemplate" xml:space="preserve">
    <value>The route template '{0}' on the action named '{1}' cannot start with a '/' character.</value>
  </data>
  <data name="BatchMediaTypeNotSupported" xml:space="preserve">
    <value>The batch request of media type '{0}' is not supported.</value>
  </data>
  <data name="BatchContentTypeMissing" xml:space="preserve">
    <value>The batch request must have a "Content-Type" header.</value>
  </data>
  <data name="BatchRequestMissingContent" xml:space="preserve">
    <value>The 'Content' property on the batch request cannot be null.</value>
  </data>
  <data name="ApiControllerActionInvoker_InvalidHttpActionResult" xml:space="preserve">
    <value>An object of type '{0}' was returned where an instance of IHttpActionResult was expected.</value>
  </data>
  <data name="ApiControllerActionInvoker_NullHttpActionResult" xml:space="preserve">
    <value>A null value was returned where an instance of IHttpActionResult was expected.</value>
  </data>
  <data name="ApiController_RequestMustNotBeNull" xml:space="preserve">
    <value>ApiController.Request must not be null.</value>
  </data>
  <data name="HttpControllerContext_ConfigurationMustNotBeNull" xml:space="preserve">
    <value>HttpControllerContext.Configuration must not be null.</value>
  </data>
  <data name="UrlHelper_LinkMustNotReturnNull" xml:space="preserve">
    <value>UrlHelper.Link must not return null.</value>
  </data>
  <data name="RequestIsNull" xml:space="preserve">
    <value>The property 'Request' on '{0}' is null. The property must be initialized with a non-null value.</value>
  </data>
  <data name="Object_NotYetInitialized" xml:space="preserve">
    <value>The object has not yet been initialized. Ensure that HttpConfiguration.EnsureInitialized() is called in the application's startup code after all other initialization code.</value>
  </data>
  <data name="RequestContextConflict" xml:space="preserve">
    <value>The request context property on the request must be null or match ApiController.RequestContext.</value>
  </data>
  <data name="Request_RequestContextMustNotBeNull" xml:space="preserve">
    <value>The request must have a request context.</value>
  </data>
  <data name="TypeInstanceMustNotBeNull" xml:space="preserve">
    <value>The {0} instance must not be null.</value>
  </data>
  <data name="TypePropertyMustNotBeNull" xml:space="preserve">
    <value>{0}.{1} must not be null.</value>
  </data>
  <data name="TypeMethodMustNotReturnNull" xml:space="preserve">
    <value>{0}.{1} must not return null.</value>
  </data>
  <data name="SubRouteCollection_DuplicateRouteName" xml:space="preserve">
    <value>A route named '{0}' is already in the route collection. Route names must be unique.

Duplicates:
{1}
{2}</value>
  </data>
  <data name="DirectRoute_MissingActionDescriptors" xml:space="preserve">
    <value>The route does not have any associated action descriptors. Routing requires that each direct route map to a non-empty set of actions.</value>
  </data>
  <data name="RoutePrefix_CannotSupportMultiRoutePrefix" xml:space="preserve">
    <value>Only one route prefix attribute is supported. Remove extra attributes from the controller of type '{0}'.</value>
  </data>
  <data name="RoutePrefix_PrefixCannotBeNull" xml:space="preserve">
    <value>The property 'prefix' from route prefix attribute on controller of type '{0}' cannot be null.</value>
  </data>
  <data name="DirectRoute_AmbiguousController" xml:space="preserve">
    <value>Multiple controller types were found that match the URL. This can happen if attribute routes on multiple controllers match the requested URL.{1}{1}The request has found the following matching controller types: {0}</value>
  </data>
  <data name="DirectRoute_HandlerNotSupported" xml:space="preserve">
    <value>Direct routing does not support per-route message handlers.</value>
  </data>
  <data name="TraceHttpControllerTypeResolverError" xml:space="preserve">
    <value>Exception thrown while getting types from '{0}'.</value>
  </data>
  <data name="DirectRoute_InvalidParameter_Action" xml:space="preserve">
    <value>A direct route for an action method cannot use the parameter 'action'. Specify a literal path in place of this parameter to create a route to the action.</value>
  </data>
  <data name="DirectRoute_InvalidParameter_Controller" xml:space="preserve">
    <value>A direct route cannot use the parameter 'controller'. Specify a literal path in place of this parameter to create a route to a controller.</value>
  </data>
  <data name="CollectionParameterContainsNullElement" xml:space="preserve">
    <value>The parameter '{0}' cannot contain a null element.</value>
  </data>
  <data name="AuthenticationFilterErrorResult" xml:space="preserve">
    <value>The authentication filter encountered an error. ErrorResult='{0}'.</value>
  </data>
  <data name="AuthenticationFilterSetPrincipalToKnownIdentity" xml:space="preserve">
    <value>The authentication filter successfully set a principal to a known identity. Identity.Name='{0}'. Identity.AuthenticationType='{1}'.</value>
  </data>
  <data name="AuthenticationFilterDidNothing" xml:space="preserve">
    <value>The authentication filter did not encounter an error or set a principal.</value>
  </data>
  <data name="AuthenticationFilterSetPrincipalToUnknownIdentity" xml:space="preserve">
    <value>The authentication filter set a principal to an unknown identity.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Http/Results/BadRequestErrorMessageResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns a <see cref="HttpStatusCode.BadRequest"/> response and performs
    /// content negotiation on an <see cref="HttpError"/> with a <see cref="HttpError.Message"/>.
    /// </summary>
    public class BadRequestErrorMessageResult : IHttpActionResult
    {
        private readonly string _message;
        private readonly NegotiatedContentResult<HttpError>.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="BadRequestErrorMessageResult"/> class.</summary>
        /// <param name="message">The user-visible error message.</param>
        /// <param name="contentNegotiator">The content negotiator to handle content negotiation.</param>
        /// <param name="request">The request message which led to this result.</param>
        /// <param name="formatters">The formatters to use to negotiate and format the content.</param>
        public BadRequestErrorMessageResult(string message, IContentNegotiator contentNegotiator,
            HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
            : this(message, new NegotiatedContentResult<HttpError>.DirectDependencyProvider(contentNegotiator, request,
                formatters))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="BadRequestErrorMessageResult"/> class.</summary>
        /// <param name="message">The user-visible error message.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public BadRequestErrorMessageResult(string message, ApiController controller)
            : this(message, new NegotiatedContentResult<HttpError>.ApiControllerDependencyProvider(controller))
        {
        }

        private BadRequestErrorMessageResult(string message,
            NegotiatedContentResult<HttpError>.IDependencyProvider dependencies)
        {
            if (message == null)
            {
                throw new ArgumentNullException("message");
            }

            Contract.Assert(dependencies != null);

            _message = message;
            _dependencies = dependencies;
        }

        /// <summary>Gets the user-visible error message.</summary>
        public string Message
        {
            get { return _message; }
        }

        /// <summary>Gets the content negotiator to handle content negotiation.</summary>
        public IContentNegotiator ContentNegotiator
        {
            get { return _dependencies.ContentNegotiator; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <summary>Gets the formatters to use to negotiate and format the content.</summary>
        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _dependencies.Formatters; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            HttpError error = new HttpError(_message);
            return NegotiatedContentResult<HttpError>.Execute(HttpStatusCode.BadRequest, error,
                _dependencies.ContentNegotiator, _dependencies.Request, _dependencies.Formatters);
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/BadRequestResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns an empty <see cref="HttpStatusCode.BadRequest"/> response.
    /// </summary>
    public class BadRequestResult : IHttpActionResult
    {
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="BadRequestResult"/> class.</summary>
        /// <param name="request">The request message which led to this result.</param>
        public BadRequestResult(HttpRequestMessage request)
            : this(new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="BadRequestResult"/> class.</summary>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public BadRequestResult(ApiController controller)
            : this(new StatusCodeResult.ApiControllerDependencyProvider(controller))
        {
        }

        private BadRequestResult(StatusCodeResult.IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _dependencies = dependencies;
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(StatusCodeResult.Execute(HttpStatusCode.BadRequest, _dependencies.Request));
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/ConflictResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns an empty <see cref="HttpStatusCode.Conflict"/> response.
    /// </summary>
    public class ConflictResult : IHttpActionResult
    {
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="ConflictResult"/> class.</summary>
        /// <param name="request">The request message which led to this result.</param>
        public ConflictResult(HttpRequestMessage request)
            : this(new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="ConflictResult"/> class.</summary>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public ConflictResult(ApiController controller)
            : this(new StatusCodeResult.ApiControllerDependencyProvider(controller))
        {
        }

        private ConflictResult(StatusCodeResult.IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _dependencies = dependencies;
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(StatusCodeResult.Execute(HttpStatusCode.Conflict, _dependencies.Request));
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/CreatedAtRouteNegotiatedContentResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using System.Web.Http.Routing;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that performs route generation and content negotiation and returns a
    /// <see cref="HttpStatusCode.Created"/> response when content negotiation succeeds.
    /// </summary>
    /// <typeparam name="T">The type of content in the entity body.</typeparam>
    public class CreatedAtRouteNegotiatedContentResult<T> : IHttpActionResult
    {
        private readonly string _routeName;
        private readonly IDictionary<string, object> _routeValues;
        private readonly T _content;
        private readonly IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="CreatedAtRouteNegotiatedContentResult{T}"/> class with the
        /// values provided.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="urlFactory">The factory to use to generate the route URL.</param>
        /// <param name="contentNegotiator">The content negotiator to handle content negotiation.</param>
        /// <param name="request">The request message which led to this result.</param>
        /// <param name="formatters">The formatters to use to negotiate and format the content.</param>
        public CreatedAtRouteNegotiatedContentResult(string routeName, IDictionary<string, object> routeValues,
            T content, UrlHelper urlFactory, IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
            : this(routeName, routeValues, content, new DirectDependencyProvider(urlFactory, contentNegotiator,
                request, formatters))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreatedAtRouteNegotiatedContentResult{T}"/> class with the
        /// values provided.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public CreatedAtRouteNegotiatedContentResult(string routeName, IDictionary<string, object> routeValues,
            T content, ApiController controller)
            : this(routeName, routeValues, content, new ApiControllerDependencyProvider(controller))
        {
        }

        private CreatedAtRouteNegotiatedContentResult(string routeName, IDictionary<string, object> routeValues,
            T content, IDependencyProvider dependencies)
        {
            if (routeName == null)
            {
                throw new ArgumentNullException("routeName");
            }

            Contract.Assert(dependencies != null);

            _routeName = routeName;
            _routeValues = routeValues;
            _content = content;
            _dependencies = dependencies;
        }

        /// <summary>Gets the name of the route to use for generating the URL.</summary>
        public string RouteName
        {
            get { return _routeName; }
        }

        /// <summary>Gets the route data to use for generating the URL.</summary>
        public IDictionary<string, object> RouteValues
        {
            get { return _routeValues; }
        }

        /// <summary>Gets the content value to negotiate and format in the entity body.</summary>
        public T Content
        {
            get { return _content; }
        }

        /// <summary>Gets the factory to use to generate the route URL.</summary>
        public UrlHelper UrlFactory
        {
            get { return _dependencies.UrlFactory; }
        }

        /// <summary>Gets the content negotiator to handle content negotiation.</summary>
        public IContentNegotiator ContentNegotiator
        {
            get { return _dependencies.ContentNegotiator; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <summary>Gets the formatters to use to negotiate and format the content.</summary>
        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _dependencies.Formatters; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            // Run content negotiation.
            ContentNegotiationResult result = _dependencies.ContentNegotiator.Negotiate(typeof(T),
                _dependencies.Request, _dependencies.Formatters);

            HttpResponseMessage response = new HttpResponseMessage();

            try
            {
                if (result == null)
                {
                    // A null result from content negotiation indicates that the response should be a 406.
                    response.StatusCode = HttpStatusCode.NotAcceptable;
                }
                else
                {
                    response.StatusCode = HttpStatusCode.Created;

                    string link = _dependencies.UrlFactory.Link(_routeName, _routeValues);

                    if (link == null)
                    {
                        throw new InvalidOperationException(SRResources.UrlHelper_LinkMustNotReturnNull);
                    }

                    response.Headers.Location = new Uri(link);
                    Contract.Assert(result.Formatter != null);
                    // At this point mediaType should be a cloned value. (The content negotiator is responsible for
                    // returning a new copy.)
                    response.Content = new ObjectContent<T>(_content, result.Formatter, result.MediaType);
                }

                response.RequestMessage = _dependencies.Request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }

        /// <summary>Defines a provider for dependencies that are not always directly available.</summary>
        /// <remarks>
        /// This abstraction supports the unit testing scenario of creating the result without creating a content
        /// negotiator, request message, or formatters. (The ApiController provider implementation does lazy evaluation
        /// to make that scenario work.)
        /// </remarks>
        private interface IDependencyProvider
        {
            UrlHelper UrlFactory { get; }

            IContentNegotiator ContentNegotiator { get; }

            HttpRequestMessage Request { get; }

            IEnumerable<MediaTypeFormatter> Formatters { get; }
        }

        private sealed class DirectDependencyProvider : IDependencyProvider
        {
            private readonly UrlHelper _urlFactory;
            private readonly IContentNegotiator _contentNegotiator;
            private readonly HttpRequestMessage _request;
            private readonly IEnumerable<MediaTypeFormatter> _formatters;

            public DirectDependencyProvider(UrlHelper urlFactory, IContentNegotiator contentNegotiator,
                HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
            {
                if (urlFactory == null)
                {
                    throw new ArgumentNullException("urlFactory");
                }

                if (contentNegotiator == null)
                {
                    throw new ArgumentNullException("contentNegotiator");
                }

                if (request == null)
                {
                    throw new ArgumentNullException("request");
                }

                if (formatters == null)
                {
                    throw new ArgumentNullException("formatters");
                }

                _urlFactory = urlFactory;
                _contentNegotiator = contentNegotiator;
                _request = request;
                _formatters = formatters;
            }

            public UrlHelper UrlFactory
            {
                get { return _urlFactory; }
            }

            public IContentNegotiator ContentNegotiator
            {
                get { return _contentNegotiator; }
            }

            public HttpRequestMessage Request
            {
                get { return _request; }
            }

            public IEnumerable<MediaTypeFormatter> Formatters
            {
                get { return _formatters; }
            }
        }

        private sealed class ApiControllerDependencyProvider : IDependencyProvider
        {
            private readonly ApiController _controller;

            private IDependencyProvider _resolvedDependencies;

            public ApiControllerDependencyProvider(ApiController controller)
            {
                if (controller == null)
                {
                    throw new ArgumentNullException("controller");
                }

                _controller = controller;
            }

            public UrlHelper UrlFactory
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.UrlFactory;
                }
            }

            public IContentNegotiator ContentNegotiator
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.ContentNegotiator;
                }
            }

            public HttpRequestMessage Request
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.Request;
                }
            }

            public IEnumerable<MediaTypeFormatter> Formatters
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.Formatters;
                }
            }

            private void EnsureResolved()
            {
                if (_resolvedDependencies == null)
                {
                    HttpRequestMessage request = _controller.Request;

                    if (request == null)
                    {
                        throw new InvalidOperationException(SRResources.ApiController_RequestMustNotBeNull);
                    }

                    UrlHelper urlFactory = _controller.Url ?? new UrlHelper(request);

                    HttpConfiguration configuration = _controller.Configuration;

                    if (configuration == null)
                    {
                        throw new InvalidOperationException(
                            SRResources.HttpControllerContext_ConfigurationMustNotBeNull);
                    }

                    ServicesContainer services = configuration.Services;
                    Contract.Assert(services != null);
                    IContentNegotiator contentNegotiator = services.GetContentNegotiator();

                    if (contentNegotiator == null)
                    {
                        throw new InvalidOperationException(Error.Format(
                            SRResources.HttpRequestMessageExtensions_NoContentNegotiator, typeof(IContentNegotiator)));
                    }

                    IEnumerable<MediaTypeFormatter> formatters = configuration.Formatters;
                    Contract.Assert(formatters != null);

                    _resolvedDependencies = new DirectDependencyProvider(urlFactory, contentNegotiator, request,
                        formatters);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/CreatedNegotiatedContentResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that performs content negotiation and returns a
    /// <see cref="HttpStatusCode.Created"/> response when it succeeds.
    /// </summary>
    /// <typeparam name="T">The type of content in the entity body.</typeparam>
    public class CreatedNegotiatedContentResult<T> : IHttpActionResult
    {
        private readonly Uri _location;
        private readonly T _content;
        private readonly NegotiatedContentResult<T>.IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="CreatedNegotiatedContentResult{T}"/> class with the values
        /// provided.
        /// </summary>
        /// <param name="location">The location at which the content has been created.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="contentNegotiator">The content negotiator to handle content negotiation.</param>
        /// <param name="request">The request message which led to this result.</param>
        /// <param name="formatters">The formatters to use to negotiate and format the content.</param>
        public CreatedNegotiatedContentResult(Uri location, T content, IContentNegotiator contentNegotiator,
            HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
            : this(location, content, new NegotiatedContentResult<T>.DirectDependencyProvider(contentNegotiator,
                request, formatters))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CreatedNegotiatedContentResult{T}"/> class with the values
        /// provided.
        /// </summary>
        /// <param name="location">The location at which the content has been created.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public CreatedNegotiatedContentResult(Uri location, T content, ApiController controller)
            : this(location, content, new NegotiatedContentResult<T>.ApiControllerDependencyProvider(controller))
        {
        }

        private CreatedNegotiatedContentResult(Uri location, T content,
            NegotiatedContentResult<T>.IDependencyProvider dependencies)
        {
            if (location == null)
            {
                throw new ArgumentNullException("location");
            }

            Contract.Assert(dependencies != null);

            _location = location;
            _content = content;
            _dependencies = dependencies;
        }

        /// <summary>Gets the location at which the content has been created.</summary>
        public Uri Location
        {
            get { return _location; }
        }

        /// <summary>Gets the content value to negotiate and format in the entity body.</summary>
        public T Content
        {
            get { return _content; }
        }

        /// <summary>Gets the content negotiator to handle content negotiation.</summary>
        public IContentNegotiator ContentNegotiator
        {
            get { return _dependencies.ContentNegotiator; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <summary>Gets the formatters to use to negotiate and format the content.</summary>
        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _dependencies.Formatters; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            // Run content negotiation.
            ContentNegotiationResult result = _dependencies.ContentNegotiator.Negotiate(typeof(T),
                _dependencies.Request, _dependencies.Formatters);

            HttpResponseMessage response = new HttpResponseMessage();

            try
            {
                if (result == null)
                {
                    // A null result from content negotiation indicates that the response should be a 406.
                    response.StatusCode = HttpStatusCode.NotAcceptable;
                }
                else
                {
                    response.StatusCode = HttpStatusCode.Created;
                    response.Headers.Location = _location;
                    Contract.Assert(result.Formatter != null);
                    // At this point mediaType should be a cloned value. (The content negotiator is responsible for
                    // returning a new copy.)
                    response.Content = new ObjectContent<T>(_content, result.Formatter, result.MediaType);
                }

                response.RequestMessage = _dependencies.Request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/ExceptionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns a <see cref="HttpStatusCode.InternalServerError"/> response and
    /// performs content negotiation on an <see cref="HttpError"/> based on an <see cref="Exception"/>.
    /// </summary>
    public class ExceptionResult : IHttpActionResult
    {
        private readonly Exception _exception;
        private readonly IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="ExceptionResult"/> class.</summary>
        /// <param name="exception">The exception to include in the error.</param>
        /// <param name="includeErrorDetail">
        /// <see langword="true"/> if the error should include exception messages; otherwise, <see langword="false"/>.
        /// </param>
        /// <param name="contentNegotiator">The content negotiator to handle content negotiation.</param>
        /// <param name="request">The request message which led to this result.</param>
        /// <param name="formatters">The formatters to use to negotiate and format the content.</param>
        public ExceptionResult(Exception exception, bool includeErrorDetail, IContentNegotiator contentNegotiator,
            HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
            : this(exception, new DirectDependencyProvider(includeErrorDetail, contentNegotiator, request,
                formatters))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="ExceptionResult"/> class.</summary>
        /// <param name="exception">The exception to include in the error.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public ExceptionResult(Exception exception, ApiController controller)
            : this(exception, new ApiControllerDependencyProvider(controller))
        {
        }

        private ExceptionResult(Exception exception, IDependencyProvider dependencies)
        {
            if (exception == null)
            {
                throw new ArgumentNullException("exception");
            }

            Contract.Assert(dependencies != null);

            _exception = exception;
            _dependencies = dependencies;
        }

        /// <summary>Gets the exception to include in the error.</summary>
        public Exception Exception
        {
            get { return _exception; }
        }

        /// <summary>Gets a value indicating whether the error should include exception messages.</summary>
        public bool IncludeErrorDetail
        {
            get { return _dependencies.IncludeErrorDetail; }
        }

        /// <summary>Gets the content negotiator to handle content negotiation.</summary>
        public IContentNegotiator ContentNegotiator
        {
            get { return _dependencies.ContentNegotiator; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <summary>Gets the formatters to use to negotiate and format the content.</summary>
        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _dependencies.Formatters; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            HttpError error = new HttpError(_exception, _dependencies.IncludeErrorDetail);
            return NegotiatedContentResult<HttpError>.Execute(HttpStatusCode.InternalServerError, error,
                _dependencies.ContentNegotiator, _dependencies.Request, _dependencies.Formatters);
        }

        /// <summary>Defines a provider for dependencies that are not always directly available.</summary>
        /// <remarks>
        /// This abstraction supports the unit testing scenario of creating the result without creating a content
        /// negotiator, request message, or formatters. (The ApiController provider implementation does lazy evaluation
        /// to make that scenario work.)
        /// </remarks>
        internal interface IDependencyProvider
        {
            bool IncludeErrorDetail { get; }

            IContentNegotiator ContentNegotiator { get; }

            HttpRequestMessage Request { get; }

            IEnumerable<MediaTypeFormatter> Formatters { get; }
        }

        internal sealed class DirectDependencyProvider : IDependencyProvider
        {
            private readonly bool _includeErrorDetail;
            private readonly IContentNegotiator _contentNegotiator;
            private readonly HttpRequestMessage _request;
            private readonly IEnumerable<MediaTypeFormatter> _formatters;

            public DirectDependencyProvider(bool includeErrorDetail, IContentNegotiator contentNegotiator,
                HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
            {
                if (contentNegotiator == null)
                {
                    throw new ArgumentNullException("contentNegotiator");
                }

                if (request == null)
                {
                    throw new ArgumentNullException("request");
                }

                if (formatters == null)
                {
                    throw new ArgumentNullException("formatters");
                }

                _includeErrorDetail = includeErrorDetail;
                _contentNegotiator = contentNegotiator;
                _request = request;
                _formatters = formatters;
            }

            public bool IncludeErrorDetail
            {
                get { return _includeErrorDetail; }
            }

            public IContentNegotiator ContentNegotiator
            {
                get { return _contentNegotiator; }
            }

            public HttpRequestMessage Request
            {
                get { return _request; }
            }

            public IEnumerable<MediaTypeFormatter> Formatters
            {
                get { return _formatters; }
            }
        }

        internal sealed class ApiControllerDependencyProvider : IDependencyProvider
        {
            private readonly ApiController _controller;

            private IDependencyProvider _resolvedDependencies;

            public ApiControllerDependencyProvider(ApiController controller)
            {
                if (controller == null)
                {
                    throw new ArgumentNullException("controller");
                }

                _controller = controller;
            }

            public bool IncludeErrorDetail
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.IncludeErrorDetail;
                }
            }

            public IContentNegotiator ContentNegotiator
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.ContentNegotiator;
                }
            }

            public HttpRequestMessage Request
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.Request;
                }
            }

            public IEnumerable<MediaTypeFormatter> Formatters
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.Formatters;
                }
            }

            private void EnsureResolved()
            {
                if (_resolvedDependencies == null)
                {
                    HttpRequestContext requestContext = _controller.RequestContext;
                    Contract.Assert(requestContext != null);
                    bool includeErrorDetail = requestContext.IncludeErrorDetail;

                    HttpConfiguration configuration = _controller.Configuration;

                    if (configuration == null)
                    {
                        throw new InvalidOperationException(
                            SRResources.HttpControllerContext_ConfigurationMustNotBeNull);
                    }

                    ServicesContainer services = configuration.Services;
                    Contract.Assert(services != null);
                    IContentNegotiator contentNegotiator = services.GetContentNegotiator();

                    if (contentNegotiator == null)
                    {
                        throw new InvalidOperationException(Error.Format(
                            SRResources.HttpRequestMessageExtensions_NoContentNegotiator, typeof(IContentNegotiator)));
                    }

                    HttpRequestMessage request = _controller.Request;

                    if (request == null)
                    {
                        throw new InvalidOperationException(SRResources.ApiController_RequestMustNotBeNull);
                    }

                    IEnumerable<MediaTypeFormatter> formatters = configuration.Formatters;
                    Contract.Assert(formatters != null);

                    _resolvedDependencies = new DirectDependencyProvider(includeErrorDetail, contentNegotiator, request,
                        formatters);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/FormattedContentResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>Represents an action result that returns formatted content.</summary>
    /// <typeparam name="T">The type of content in the entity body.</typeparam>
    public class FormattedContentResult<T> : IHttpActionResult
    {
        private readonly HttpStatusCode _statusCode;
        private readonly T _content;
        private readonly MediaTypeFormatter _formatter;
        private readonly MediaTypeHeaderValue _mediaType;
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="FormattedContentResult{T}"/> class with the values provided.
        /// </summary>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="content">The content value to format in the entity body.</param>
        /// <param name="formatter">The formatter to use to format the content.</param>
        /// <param name="mediaType">
        /// The value for the Content-Type header, or <see langword="null"/> to have the formatter pick a default
        /// value.
        /// </param>
        /// <param name="request">The request message which led to this result.</param>
        public FormattedContentResult(HttpStatusCode statusCode, T content, MediaTypeFormatter formatter,
            MediaTypeHeaderValue mediaType, HttpRequestMessage request)
            : this(statusCode, content, formatter, mediaType, new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="FormattedContentResult{T}"/> class with the values provided.
        /// </summary>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="content">The content value to format in the entity body.</param>
        /// <param name="formatter">The formatter to use to format the content.</param>
        /// <param name="mediaType">
        /// The value for the Content-Type header, or <see langword="null"/> to have the formatter pick a default
        /// value.
        /// </param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public FormattedContentResult(HttpStatusCode statusCode, T content, MediaTypeFormatter formatter,
            MediaTypeHeaderValue mediaType, ApiController controller)
            : this(statusCode, content, formatter, mediaType, new StatusCodeResult.ApiControllerDependencyProvider(
                controller))
        {
        }

        private FormattedContentResult(HttpStatusCode statusCode, T content, MediaTypeFormatter formatter,
            MediaTypeHeaderValue mediaType, StatusCodeResult.IDependencyProvider dependencies)
        {
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }

            Contract.Assert(dependencies != null);

            _statusCode = statusCode;
            _content = content;
            _formatter = formatter;
            _mediaType = mediaType;
            _dependencies = dependencies;
        }

        /// <summary>Gets the HTTP status code for the response message.</summary>
        public HttpStatusCode StatusCode
        {
            get { return _statusCode; }
        }

        /// <summary>Gets the content value to format in the entity body.</summary>
        public T Content
        {
            get { return _content; }
        }

        /// <summary>Gets the formatter to use to format the content.</summary>
        public MediaTypeFormatter Formatter
        {
            get { return _formatter; }
        }

        /// <summary>
        /// Gets the value for the Content-Type header, or <see langword="null"/> to have the formatter pick a default
        /// value.
        /// </summary>
        public MediaTypeHeaderValue MediaType
        {
            get { return _mediaType; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            return Execute(_statusCode, _content, _formatter, _mediaType, _dependencies.Request);
        }

        internal static HttpResponseMessage Execute(HttpStatusCode statusCode, T content, MediaTypeFormatter formatter,
            MediaTypeHeaderValue mediaType, HttpRequestMessage request)
        {
            HttpResponseMessage response = new HttpResponseMessage(statusCode);

            try
            {
                response.Content = new ObjectContent<T>(content, formatter, mediaType);
                response.RequestMessage = request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/InternalServerErrorResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns an empty <see cref="HttpStatusCode.InternalServerError"/> response.
    /// </summary>
    public class InternalServerErrorResult : IHttpActionResult
    {
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="InternalServerErrorResult"/> class.</summary>
        /// <param name="request">The request message which led to this result.</param>
        public InternalServerErrorResult(HttpRequestMessage request)
            : this(new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="InternalServerErrorResult"/> class.</summary>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public InternalServerErrorResult(ApiController controller)
            : this(new StatusCodeResult.ApiControllerDependencyProvider(controller))
        {
        }

        private InternalServerErrorResult(StatusCodeResult.IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _dependencies = dependencies;
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(StatusCodeResult.Execute(HttpStatusCode.InternalServerError,
                _dependencies.Request));
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/InvalidModelStateResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns a <see cref="HttpStatusCode.BadRequest"/> response and performs
    /// content negotiation on an <see cref="HttpError"/> based on a <see cref="ModelStateDictionary"/>.
    /// </summary>
    public class InvalidModelStateResult : IHttpActionResult
    {
        private readonly ModelStateDictionary _modelState;
        private readonly ExceptionResult.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="InvalidModelStateResult"/> class.</summary>
        /// <param name="modelState">The model state to include in the error.</param>
        /// <param name="includeErrorDetail">
        /// <see langword="true"/> if the error should include exception messages; otherwise, <see langword="false"/>.
        /// </param>
        /// <param name="contentNegotiator">The content negotiator to handle content negotiation.</param>
        /// <param name="request">The request message which led to this result.</param>
        /// <param name="formatters">The formatters to use to negotiate and format the content.</param>
        public InvalidModelStateResult(ModelStateDictionary modelState, bool includeErrorDetail,
            IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
            : this(modelState, new ExceptionResult.DirectDependencyProvider(includeErrorDetail, contentNegotiator,
                request, formatters))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="InvalidModelStateResult"/> class.</summary>
        /// <param name="modelState">The model state to include in the error.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public InvalidModelStateResult(ModelStateDictionary modelState, ApiController controller)
            : this(modelState, new ExceptionResult.ApiControllerDependencyProvider(controller))
        {
        }

        private InvalidModelStateResult(ModelStateDictionary modelState,
            ExceptionResult.IDependencyProvider dependencies)
        {
            if (modelState == null)
            {
                throw new ArgumentNullException("modelState");
            }

            Contract.Assert(dependencies != null);

            _modelState = modelState;
            _dependencies = dependencies;
        }

        /// <summary>Gets the model state to include in the error.</summary>
        public ModelStateDictionary ModelState
        {
            get { return _modelState; }
        }

        /// <summary>Gets a value indicating whether the error should include exception messages.</summary>
        public bool IncludeErrorDetail
        {
            get { return _dependencies.IncludeErrorDetail; }
        }

        /// <summary>Gets the content negotiator to handle content negotiation.</summary>
        public IContentNegotiator ContentNegotiator
        {
            get { return _dependencies.ContentNegotiator; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <summary>Gets the formatters to use to negotiate and format the content.</summary>
        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _dependencies.Formatters; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            HttpError error = new HttpError(_modelState, _dependencies.IncludeErrorDetail);
            return NegotiatedContentResult<HttpError>.Execute(HttpStatusCode.BadRequest, error,
                _dependencies.ContentNegotiator, _dependencies.Request, _dependencies.Formatters);
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/JsonResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Newtonsoft.Json;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns an <see cref="HttpStatusCode.OK"/> response with JSON data.
    /// </summary>
    /// <typeparam name="T">The type of content in the entity body.</typeparam>
    public class JsonResult<T> : IHttpActionResult
    {
        private readonly T _content;
        private readonly JsonSerializerSettings _serializerSettings;
        private readonly Encoding _encoding;
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="JsonResult{T}"/> class with the values provided.
        /// </summary>
        /// <param name="content">The content value to serialize in the entity body.</param>
        /// <param name="serializerSettings">The serializer settings.</param>
        /// <param name="encoding">The content encoding.</param>
        /// <param name="request">The request message which led to this result.</param>
        public JsonResult(T content, JsonSerializerSettings serializerSettings, Encoding encoding,
            HttpRequestMessage request)
            : this(content, serializerSettings, encoding, new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="JsonResult{T}"/> class with the values provided.
        /// </summary>
        /// <param name="content">The content value to serialize in the entity body.</param>
        /// <param name="serializerSettings">The serializer settings.</param>
        /// <param name="encoding">The content encoding.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public JsonResult(T content, JsonSerializerSettings serializerSettings, Encoding encoding,
            ApiController controller)
            : this(content, serializerSettings, encoding, new StatusCodeResult.ApiControllerDependencyProvider(
                controller))
        {
        }

        private JsonResult(T content, JsonSerializerSettings serializerSettings, Encoding encoding,
            StatusCodeResult.IDependencyProvider dependencies)
        {
            if (serializerSettings == null)
            {
                throw new ArgumentNullException("serializerSettings");
            }

            if (encoding == null)
            {
                throw new ArgumentNullException("encoding");
            }

            Contract.Assert(dependencies != null);

            _content = content;
            _serializerSettings = serializerSettings;
            _encoding = encoding;
            _dependencies = dependencies;
        }

        /// <summary>Gets the content value to serialize in the entity body.</summary>
        public T Content
        {
            get { return _content; }
        }

        /// <summary>Gets the serializer settings.</summary>
        public JsonSerializerSettings SerializerSettings
        {
            get { return _serializerSettings; }
        }

        /// <summary>Gets the content encoding.</summary>
        public Encoding Encoding
        {
            get { return _encoding; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);

            try
            {
                ArraySegment<byte> segment = Serialize();
                response.Content = new ByteArrayContent(segment.Array, segment.Offset, segment.Count);
                MediaTypeHeaderValue contentType = new MediaTypeHeaderValue("application/json");
                contentType.CharSet = _encoding.WebName;
                response.Content.Headers.ContentType = contentType;
                response.RequestMessage = _dependencies.Request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }

        [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification =
            "False positive; specifying leaveOpen: true and CloseOutput=false prevents this condition.")]
        private ArraySegment<byte> Serialize()
        {
            JsonSerializer serializer = JsonSerializer.Create(_serializerSettings);

            using (MemoryStream stream = new MemoryStream())
            {
                const int DefaultStreamWriterBufferSize = 0x400;
                using (TextWriter textWriter = new StreamWriter(stream, _encoding,
                    bufferSize: DefaultStreamWriterBufferSize, leaveOpen: true))
                {
                    using (JsonWriter jsonWriter = new JsonTextWriter(textWriter) { CloseOutput = false })
                    {
                        serializer.Serialize(jsonWriter, _content);
                        jsonWriter.Flush();
                    }
                }

                Contract.Assert(stream.Length <= Int32.MaxValue);
                return new ArraySegment<byte>(stream.GetBuffer(), 0, (int)stream.Length);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/NegotiatedContentResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;

namespace System.Web.Http.Results
{
    /// <summary>Represents an action result that performs content negotiation.</summary>
    /// <typeparam name="T">The type of content in the entity body.</typeparam>
    public class NegotiatedContentResult<T> : IHttpActionResult
    {
        private readonly HttpStatusCode _statusCode;
        private readonly T _content;
        private readonly IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="NegotiatedContentResult{T}"/> class with the values provided.
        /// </summary>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="contentNegotiator">The content negotiator to handle content negotiation.</param>
        /// <param name="request">The request message which led to this result.</param>
        /// <param name="formatters">The formatters to use to negotiate and format the content.</param>
        public NegotiatedContentResult(HttpStatusCode statusCode, T content, IContentNegotiator contentNegotiator,
            HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
            : this(statusCode, content, new DirectDependencyProvider(contentNegotiator, request, formatters))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="NegotiatedContentResult{T}"/> class with the values provided.
        /// </summary>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public NegotiatedContentResult(HttpStatusCode statusCode, T content, ApiController controller)
            : this(statusCode, content, new ApiControllerDependencyProvider(controller))
        {
        }

        private NegotiatedContentResult(HttpStatusCode statusCode, T content, IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _statusCode = statusCode;
            _content = content;
            _dependencies = dependencies;
        }

        /// <summary>Gets the HTTP status code for the response message.</summary>
        public HttpStatusCode StatusCode
        {
            get { return _statusCode; }
        }

        /// <summary>Gets the content value to negotiate and format in the entity body.</summary>
        public T Content
        {
            get { return _content; }
        }

        /// <summary>Gets the content negotiator to handle content negotiation.</summary>
        public IContentNegotiator ContentNegotiator
        {
            get { return _dependencies.ContentNegotiator; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <summary>Gets the formatters to use to negotiate and format the content.</summary>
        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _dependencies.Formatters; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            return Execute(_statusCode, _content, _dependencies.ContentNegotiator, _dependencies.Request,
                _dependencies.Formatters);
        }

        internal static HttpResponseMessage Execute(HttpStatusCode statusCode, T content,
            IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
        {
            Contract.Assert(contentNegotiator != null);
            Contract.Assert(request != null);
            Contract.Assert(formatters != null);

            // Run content negotiation.
            ContentNegotiationResult result = contentNegotiator.Negotiate(typeof(T), request, formatters);

            HttpResponseMessage response = new HttpResponseMessage();

            try
            {
                if (result == null)
                {
                    // A null result from content negotiation indicates that the response should be a 406.
                    response.StatusCode = HttpStatusCode.NotAcceptable;
                }
                else
                {
                    response.StatusCode = statusCode;
                    Contract.Assert(result.Formatter != null);
                    // At this point mediaType should be a cloned value. (The content negotiator is responsible for
                    // returning a new copy.)
                    response.Content = new ObjectContent<T>(content, result.Formatter, result.MediaType);
                }

                response.RequestMessage = request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }

        /// <summary>Defines a provider for dependencies that are not always directly available.</summary>
        /// <remarks>
        /// This abstraction supports the unit testing scenario of creating the result without creating a content
        /// negotiator, request message, or formatters. (The ApiController provider implementation does lazy evaluation
        /// to make that scenario work.)
        /// </remarks>
        internal interface IDependencyProvider
        {
            IContentNegotiator ContentNegotiator { get; }

            HttpRequestMessage Request { get; }

            IEnumerable<MediaTypeFormatter> Formatters { get; }
        }

        internal sealed class DirectDependencyProvider : IDependencyProvider
        {
            private readonly IContentNegotiator _contentNegotiator;
            private readonly HttpRequestMessage _request;
            private readonly IEnumerable<MediaTypeFormatter> _formatters;

            public DirectDependencyProvider(IContentNegotiator contentNegotiator, HttpRequestMessage request,
                IEnumerable<MediaTypeFormatter> formatters)
            {
                if (contentNegotiator == null)
                {
                    throw new ArgumentNullException("contentNegotiator");
                }

                if (request == null)
                {
                    throw new ArgumentNullException("request");
                }

                if (formatters == null)
                {
                    throw new ArgumentNullException("formatters");
                }

                _contentNegotiator = contentNegotiator;
                _request = request;
                _formatters = formatters;
            }

            public IContentNegotiator ContentNegotiator
            {
                get { return _contentNegotiator; }
            }

            public HttpRequestMessage Request
            {
                get { return _request; }
            }

            public IEnumerable<MediaTypeFormatter> Formatters
            {
                get { return _formatters; }
            }
        }

        internal sealed class ApiControllerDependencyProvider : IDependencyProvider
        {
            private readonly ApiController _controller;

            private IDependencyProvider _resolvedDependencies;

            public ApiControllerDependencyProvider(ApiController controller)
            {
                if (controller == null)
                {
                    throw new ArgumentNullException("controller");
                }

                _controller = controller;
            }

            public IContentNegotiator ContentNegotiator
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.ContentNegotiator;
                }
            }

            public HttpRequestMessage Request
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.Request;
                }
            }

            public IEnumerable<MediaTypeFormatter> Formatters
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.Formatters;
                }
            }

            private void EnsureResolved()
            {
                if (_resolvedDependencies == null)
                {
                    HttpConfiguration configuration = _controller.Configuration;

                    if (configuration == null)
                    {
                        throw new InvalidOperationException(
                            SRResources.HttpControllerContext_ConfigurationMustNotBeNull);
                    }

                    ServicesContainer services = configuration.Services;
                    Contract.Assert(services != null);
                    IContentNegotiator contentNegotiator = services.GetContentNegotiator();

                    if (contentNegotiator == null)
                    {
                        throw new InvalidOperationException(Error.Format(
                            SRResources.HttpRequestMessageExtensions_NoContentNegotiator, typeof(IContentNegotiator)));
                    }

                    HttpRequestMessage request = _controller.Request;

                    if (request == null)
                    {
                        throw new InvalidOperationException(SRResources.ApiController_RequestMustNotBeNull);
                    }

                    IEnumerable<MediaTypeFormatter> formatters = configuration.Formatters;
                    Contract.Assert(formatters != null);

                    _resolvedDependencies = new DirectDependencyProvider(contentNegotiator, request, formatters);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/NotFoundResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns an empty <see cref="HttpStatusCode.NotFound"/> response.
    /// </summary>
    public class NotFoundResult : IHttpActionResult
    {
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="NotFoundResult"/> class.</summary>
        /// <param name="request">The request message which led to this result.</param>
        public NotFoundResult(HttpRequestMessage request)
            : this(new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="NotFoundResult"/> class.</summary>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public NotFoundResult(ApiController controller)
            : this(new StatusCodeResult.ApiControllerDependencyProvider(controller))
        {
        }

        private NotFoundResult(StatusCodeResult.IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _dependencies = dependencies;
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(StatusCodeResult.Execute(HttpStatusCode.NotFound, _dependencies.Request));
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/OkNegotiatedContentResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that performs content negotiation and returns an <see cref="HttpStatusCode.OK"/>
    /// response when it succeeds.
    /// </summary>
    /// <typeparam name="T">The type of content in the entity body.</typeparam>
    public class OkNegotiatedContentResult<T> : IHttpActionResult
    {
        private readonly T _content;
        private readonly NegotiatedContentResult<T>.IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="OkNegotiatedContentResult{T}"/> class with the values
        /// provided.
        /// </summary>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="contentNegotiator">The content negotiator to handle content negotiation.</param>
        /// <param name="request">The request message which led to this result.</param>
        /// <param name="formatters">The formatters to use to negotiate and format the content.</param>
        public OkNegotiatedContentResult(T content, IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
            : this(content, new NegotiatedContentResult<T>.DirectDependencyProvider(contentNegotiator, request,
            formatters))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="OkNegotiatedContentResult{T}"/> class with the values
        /// provided.
        /// </summary>
        /// <param name="content">The content value to negotiate and format in the entity body.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public OkNegotiatedContentResult(T content, ApiController controller)
            : this(content, new NegotiatedContentResult<T>.ApiControllerDependencyProvider(controller))
        {
        }

        private OkNegotiatedContentResult(T content, NegotiatedContentResult<T>.IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _content = content;
            _dependencies = dependencies;
        }

        /// <summary>Gets the content value to negotiate and format in the entity body.</summary>
        public T Content
        {
            get { return _content; }
        }

        /// <summary>Gets the content negotiator to handle content negotiation.</summary>
        public IContentNegotiator ContentNegotiator
        {
            get { return _dependencies.ContentNegotiator; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <summary>Gets the formatters to use to negotiate and format the content.</summary>
        public IEnumerable<MediaTypeFormatter> Formatters
        {
            get { return _dependencies.Formatters; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(NegotiatedContentResult<T>.Execute(HttpStatusCode.OK, _content,
                _dependencies.ContentNegotiator, _dependencies.Request, _dependencies.Formatters));
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/OkResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>Represents an action result that returns an empty <see cref="HttpStatusCode.OK"/> response.</summary>
    public class OkResult : IHttpActionResult
    {
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="OkResult"/> class.</summary>
        /// <param name="request">The request message which led to this result.</param>
        public OkResult(HttpRequestMessage request)
            : this(new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="OkResult"/> class.</summary>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public OkResult(ApiController controller)
            : this(new StatusCodeResult.ApiControllerDependencyProvider(controller))
        {
        }

        private OkResult(StatusCodeResult.IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _dependencies = dependencies;
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(StatusCodeResult.Execute(HttpStatusCode.OK, _dependencies.Request));
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/RedirectResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result for a <see cref="HttpStatusCode.Redirect"/>.
    /// </summary>
    public class RedirectResult : IHttpActionResult
    {
        private readonly Uri _location;
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="RedirectResult"/> class with the values provided.
        /// </summary>
        /// <param name="location">The location to which to redirect.</param>
        /// <param name="request">The request message which led to this result.</param>
        public RedirectResult(Uri location, HttpRequestMessage request)
            : this(location, new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RedirectResult"/> class with the values provided.
        /// </summary>
        /// <param name="location">The location to which to redirect.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public RedirectResult(Uri location, ApiController controller)
            : this(location, new StatusCodeResult.ApiControllerDependencyProvider(controller))
        {
        }

        private RedirectResult(Uri location, StatusCodeResult.IDependencyProvider dependencies)
        {
            if (location == null)
            {
                throw new ArgumentNullException("location");
            }

            Contract.Assert(dependencies != null);

            _location = location;
            _dependencies = dependencies;
        }

        /// <summary>Gets the location at which the content has been created.</summary>
        public Uri Location
        {
            get { return _location; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.Redirect);

            try
            {
                response.Headers.Location = _location;
                response.RequestMessage = _dependencies.Request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/RedirectToRouteResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;
using System.Web.Http.Routing;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that performs route generation and returns a <see cref="HttpStatusCode.Redirect"/>
    /// response.
    /// </summary>
    public class RedirectToRouteResult : IHttpActionResult
    {
        private readonly string _routeName;
        private readonly IDictionary<string, object> _routeValues;
        private readonly IDependencyProvider _dependencies;

        /// <summary>
        /// Initializes a new instance of the <see cref="RedirectToRouteResult"/> class with the values provided.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <param name="urlFactory">The factory to use to generate the route URL.</param>
        /// <param name="request">The request message which led to this result.</param>
        public RedirectToRouteResult(string routeName, IDictionary<string, object> routeValues, UrlHelper urlFactory,
            HttpRequestMessage request)
            : this(routeName, routeValues, new DirectDependencyProvider(urlFactory, request))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RedirectToRouteResult"/> class with the values provided.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public RedirectToRouteResult(string routeName, IDictionary<string, object> routeValues,
            ApiController controller)
            : this(routeName, routeValues, new ApiControllerDependencyProvider(controller))
        {
        }

        private RedirectToRouteResult(string routeName, IDictionary<string, object> routeValues,
            IDependencyProvider dependencies)
        {
            if (routeName == null)
            {
                throw new ArgumentNullException("routeName");
            }

            Contract.Assert(dependencies != null);

            _routeName = routeName;
            _routeValues = routeValues;
            _dependencies = dependencies;
        }

        /// <summary>Gets the name of the route to use for generating the URL.</summary>
        public string RouteName
        {
            get { return _routeName; }
        }

        /// <summary>Gets the route data to use for generating the URL.</summary>
        public IDictionary<string, object> RouteValues
        {
            get { return _routeValues; }
        }

        /// <summary>Gets the factory to use to generate the route URL.</summary>
        public UrlHelper UrlFactory
        {
            get { return _dependencies.UrlFactory; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.Redirect);

            try
            {
                string link = _dependencies.UrlFactory.Link(_routeName, _routeValues);

                if (link == null)
                {
                    throw new InvalidOperationException(SRResources.UrlHelper_LinkMustNotReturnNull);
                }

                response.Headers.Location = new Uri(link);
                response.RequestMessage = _dependencies.Request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }

        /// <summary>Defines a provider for dependencies that are not always directly available.</summary>
        /// <remarks>
        /// This abstraction supports the unit testing scenario of creating the result without creating a content
        /// negotiator, request message, or formatters. (The ApiController provider implementation does lazy evaluation
        /// to make that scenario work.)
        /// </remarks>
        private interface IDependencyProvider
        {
            UrlHelper UrlFactory { get; }

            HttpRequestMessage Request { get; }
        }

        private sealed class DirectDependencyProvider : IDependencyProvider
        {
            private readonly UrlHelper _urlFactory;
            private readonly HttpRequestMessage _request;

            public DirectDependencyProvider(UrlHelper urlFactory, HttpRequestMessage request)
            {
                if (urlFactory == null)
                {
                    throw new ArgumentNullException("urlFactory");
                }

                if (request == null)
                {
                    throw new ArgumentNullException("request");
                }

                _urlFactory = urlFactory;
                _request = request;
            }

            public UrlHelper UrlFactory
            {
                get { return _urlFactory; }
            }

            public HttpRequestMessage Request
            {
                get { return _request; }
            }
        }

        private sealed class ApiControllerDependencyProvider : IDependencyProvider
        {
            private readonly ApiController _controller;

            private IDependencyProvider _resolvedDependencies;

            public ApiControllerDependencyProvider(ApiController controller)
            {
                if (controller == null)
                {
                    throw new ArgumentNullException("controller");
                }

                _controller = controller;
            }

            public UrlHelper UrlFactory
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.UrlFactory;
                }
            }

            public HttpRequestMessage Request
            {
                get
                {
                    EnsureResolved();
                    return _resolvedDependencies.Request;
                }
            }

            private void EnsureResolved()
            {
                if (_resolvedDependencies == null)
                {
                    HttpRequestMessage request = _controller.Request;

                    if (request == null)
                    {
                        throw new InvalidOperationException(SRResources.ApiController_RequestMustNotBeNull);
                    }

                    UrlHelper urlFactory = _controller.Url ?? new UrlHelper(request);

                    _resolvedDependencies = new DirectDependencyProvider(urlFactory, request);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/ResponseMessageResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>Represents an action result that returns a specified response message.</summary>
    public class ResponseMessageResult : IHttpActionResult
    {
        private readonly HttpResponseMessage _response;

        /// <summary>Initializes a new instance of the <see cref="ResponseMessageResult"/> class.</summary>
        /// <param name="response">The response message.</param>
        public ResponseMessageResult(HttpResponseMessage response)
        {
            if (response == null)
            {
                throw new ArgumentNullException("response");
            }

            _response = response;
        }

        /// <summary>Gets the response message.</summary>
        public HttpResponseMessage Response
        {
            get { return _response; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(_response);
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/StatusCodeResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.Results
{
    /// <summary>Represents an action result that returns a specified HTTP status code.</summary>
    public class StatusCodeResult : IHttpActionResult
    {
        private readonly HttpStatusCode _statusCode;
        private readonly IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="StatusCodeResult"/> class.</summary>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="request">The request message which led to this result.</param>
        public StatusCodeResult(HttpStatusCode statusCode, HttpRequestMessage request)
            : this(statusCode, new DirectDependencyProvider(request))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="StatusCodeResult"/> class.</summary>
        /// <param name="statusCode">The HTTP status code for the response message.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public StatusCodeResult(HttpStatusCode statusCode, ApiController controller)
            : this(statusCode, new ApiControllerDependencyProvider(controller))
        {
        }

        private StatusCodeResult(HttpStatusCode statusCode, IDependencyProvider dependencies)
        {
            Contract.Assert(dependencies != null);

            _statusCode = statusCode;
            _dependencies = dependencies;
        }

        /// <summary>Gets the HTTP status code for the response message.</summary>
        public HttpStatusCode StatusCode
        {
            get { return _statusCode; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            return Execute(_statusCode, _dependencies.Request);
        }

        internal static HttpResponseMessage Execute(HttpStatusCode statusCode, HttpRequestMessage request)
        {
            HttpResponseMessage response = new HttpResponseMessage(statusCode);

            try
            {
                response.RequestMessage = request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }

        /// <summary>Defines a provider for dependencies that are not always directly available.</summary>
        /// <remarks>
        /// This abstraction supports the unit testing scenario of creating the result without creating a request
        /// message. (The ApiController provider implementation does lazy evaluation to make that scenario work.)
        /// </remarks>
        internal interface IDependencyProvider
        {
            HttpRequestMessage Request { get; }
        }

        internal sealed class DirectDependencyProvider : IDependencyProvider
        {
            private readonly HttpRequestMessage _request;

            public DirectDependencyProvider(HttpRequestMessage request)
            {
                if (request == null)
                {
                    throw new ArgumentNullException("request");
                }

                _request = request;
            }

            public HttpRequestMessage Request
            {
                get { return _request; }
            }
        }

        internal sealed class ApiControllerDependencyProvider : IDependencyProvider
        {
            private readonly ApiController _controller;

            private HttpRequestMessage _request;

            public ApiControllerDependencyProvider(ApiController controller)
            {
                if (controller == null)
                {
                    throw new ArgumentNullException("controller");
                }

                _controller = controller;
            }

            public HttpRequestMessage Request
            {
                get
                {
                    EnsureResolved();
                    return _request;
                }
            }

            private void EnsureResolved()
            {
                if (_request == null)
                {
                    HttpRequestMessage request = _controller.Request;

                    if (request == null)
                    {
                        throw new InvalidOperationException(SRResources.ApiController_RequestMustNotBeNull);
                    }

                    _request = request;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Results/UnauthorizedResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Results
{
    /// <summary>
    /// Represents an action result that returns an <see cref="HttpStatusCode.Unauthorized"/> response.
    /// </summary>
    public class UnauthorizedResult : IHttpActionResult
    {
        private readonly IEnumerable<AuthenticationHeaderValue> _challenges;
        private readonly StatusCodeResult.IDependencyProvider _dependencies;

        /// <summary>Initializes a new instance of the <see cref="StatusCodeResult"/> class.</summary>
        /// <param name="challenges">The WWW-Authenticate challenges.</param>
        /// <param name="request">The request message which led to this result.</param>
        public UnauthorizedResult(IEnumerable<AuthenticationHeaderValue> challenges, HttpRequestMessage request)
            : this(challenges, new StatusCodeResult.DirectDependencyProvider(request))
        {
        }

        /// <summary>Initializes a new instance of the <see cref="StatusCodeResult"/> class.</summary>
        /// <param name="challenges">The WWW-Authenticate challenges.</param>
        /// <param name="controller">The controller from which to obtain the dependencies needed for execution.</param>
        public UnauthorizedResult(IEnumerable<AuthenticationHeaderValue> challenges, ApiController controller)
            : this(challenges, new StatusCodeResult.ApiControllerDependencyProvider(controller))
        {
        }

        private UnauthorizedResult(IEnumerable<AuthenticationHeaderValue> challenges,
            StatusCodeResult.IDependencyProvider dependencies)
        {
            if (challenges == null)
            {
                throw new ArgumentNullException("challenges");
            }

            Contract.Assert(dependencies != null);

            _challenges = challenges;
            _dependencies = dependencies;
        }

        /// <summary>Gets the WWW-Authenticate challenges.</summary>
        public IEnumerable<AuthenticationHeaderValue> Challenges
        {
            get { return _challenges; }
        }

        /// <summary>Gets the request message which led to this result.</summary>
        public HttpRequestMessage Request
        {
            get { return _dependencies.Request; }
        }

        /// <inheritdoc />
        public virtual Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
        {
            return Task.FromResult(Execute());
        }

        private HttpResponseMessage Execute()
        {
            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.Unauthorized);

            try
            {
                foreach (AuthenticationHeaderValue challenge in _challenges)
                {
                    response.Headers.WwwAuthenticate.Add(challenge);
                }

                response.RequestMessage = _dependencies.Request;
            }
            catch
            {
                response.Dispose();
                throw;
            }

            return response;
        }
    }
}


================================================
FILE: src/System.Web.Http/RouteAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Web.Http.Routing;

namespace System.Web.Http
{
    /// <summary>
    /// Place on a controller or action to expose it directly via a route. 
    /// When placed on a controller, it applies to actions that do not have any <see cref="RouteAttribute"/>s on them.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public sealed class RouteAttribute : Attribute, IDirectRouteFactory, IHttpRouteInfoProvider
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RouteAttribute" /> class.
        /// </summary>
        public RouteAttribute()
        {
            Template = String.Empty;
        }
        
        /// <summary>
        /// Initializes a new instance of the <see cref="RouteAttribute" /> class.
        /// </summary>
        /// <param name="template">The route template describing the URI pattern to match against.</param>
        public RouteAttribute(string template)
        {
            if (template == null)
            {
                throw Error.ArgumentNull("template");
            }
            Template = template;
        }

        /// <inheritdoc />
        public string Name { get; set; }

        /// <inheritdoc />
        public int Order { get; set; }

        /// <inheritdoc />
        public string Template { get; private set; }

        RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context)
        {
            Contract.Assert(context != null);

            IDirectRouteBuilder builder = context.CreateBuilder(Template);
            Contract.Assert(builder != null);

            builder.Name = Name;
            builder.Order = Order;
            return builder.Build();
        }
    }
}


================================================
FILE: src/System.Web.Http/RouteParameter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Http
{
    /// <summary>
    /// The <see cref="RouteParameter"/> class can be used to indicate properties about a route parameter (the literals and placeholders 
    /// located within segments of a <see cref="M:IHttpRoute.RouteTemplate"/>). 
    /// It can for example be used to indicate that a route parameter is optional.
    /// </summary>
    public sealed class RouteParameter
    {
        /// <summary>
        /// Optional Parameter
        /// </summary>
        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes", Justification = "This type is immutable.")]
        public static readonly RouteParameter Optional = new RouteParameter();

        // singleton constructor
        private RouteParameter()
        {
        }

        /// <summary>
        /// Returns a <see cref="System.String"/> that represents this instance.
        /// </summary>
        /// <returns>
        /// A <see cref="System.String"/> that represents this instance.
        /// </returns>
        public override string ToString()
        {
            return String.Empty;
        }
    }
}


================================================
FILE: src/System.Web.Http/RoutePrefixAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Http.Routing;

namespace System.Web.Http
{
    /// <summary>
    /// Annotates a controller with a route prefix that applies to actions that have any <see cref="RouteAttribute"/>s on them.
    /// </summary>
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This attribute is intended to be extended by the user.")]
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public class RoutePrefixAttribute : Attribute, IRoutePrefix
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RoutePrefixAttribute" /> class without specifying any parameters.
        /// </summary>
        protected RoutePrefixAttribute()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RoutePrefixAttribute" /> class.
        /// </summary>
        /// <param name="prefix">The route prefix for the controller.</param>
        public RoutePrefixAttribute(string prefix)
        {
            if (prefix == null)
            {
                throw Error.ArgumentNull("prefix");
            }

            Prefix = prefix;
        }

        /// <summary>
        /// Gets the route prefix.
        /// </summary>
        public virtual string Prefix { get; private set; }
    }
}

================================================
FILE: src/System.Web.Http/Routing/AttributeRoutingMapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Properties;

namespace System.Web.Http.Routing
{
    /// <remarks>
    /// Corresponds to the MVC implementation of attribute routing in System.Web.Mvc.Routing.AttributeRoutingMapper.
    /// </remarks>
    internal static class AttributeRoutingMapper
    {
        // Attribute routing will inject a single top-level route into the route table.
        private const string AttributeRouteName = "MS_attributerouteWebApi";

        public static void MapAttributeRoutes(
            HttpConfiguration configuration,
            IInlineConstraintResolver constraintResolver,
            IDirectRouteProvider directRouteProvider)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            if (directRouteProvider == null)
            {
                throw new ArgumentNullException("directRouteProvider");
            }

            RouteCollectionRoute aggregateRoute = new RouteCollectionRoute();
            configuration.Routes.Add(AttributeRouteName, aggregateRoute);

            Action<HttpConfiguration> previousInitializer = configuration.Initializer;
            configuration.Initializer = config =>
                {
                    // Chain to the previous initializer hook. Do this before we access the config since
                    // initialization may make last minute changes to the configuration.
                    previousInitializer(config);

                    SubRouteCollection subRoutes = null;

                    // Add a single placeholder route that handles all of attribute routing.
                    // Add an initialize hook that initializes these routes after the config has been initialized.
                    Func<SubRouteCollection> initializer = () =>
                    {
                        subRoutes = new SubRouteCollection();
                        AddRouteEntries(subRoutes, configuration, constraintResolver, directRouteProvider);
                        return subRoutes;
                    };

                    // This won't change config. It wants to pick up the finalized config.
                    aggregateRoute.EnsureInitialized(initializer);

                    if (subRoutes != null)
                    {
                        AddGenerationHooksForSubRoutes(config.Routes, subRoutes.Entries);
                    }
                };
        }

        // Add generation hooks for the Attribute-routing subroutes.
        // This lets us generate urls for routes supplied by attr-based routing.
        private static void AddGenerationHooksForSubRoutes(HttpRouteCollection routeTable,
            IEnumerable<RouteEntry> entries)
        {
            Contract.Assert(entries != null);
            foreach (RouteEntry entry in entries)
            {
                Contract.Assert(entry != null);
                string name = entry.Name;

                if (name != null)
                {
                    IHttpRoute route = entry.Route;
                    Contract.Assert(route != null);
                    IHttpRoute linkGenerationRoute = new LinkGenerationRoute(route);
                    routeTable.Add(name, linkGenerationRoute);
                }
            }
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling",
            Justification = "This method is a coordinator, so this coupling is expected. Also fine unless building Debug configuration.")]
        private static void AddRouteEntries(
            SubRouteCollection collector,
            HttpConfiguration configuration,
            IInlineConstraintResolver constraintResolver,
            IDirectRouteProvider directRouteProvider)
        {
            Contract.Assert(configuration != null);
            Contract.Assert(directRouteProvider != null);

            IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector();
            IDictionary<string, HttpControllerDescriptor> controllerMap = controllerSelector.GetControllerMapping();
            if (controllerMap != null)
            {
                foreach (HttpControllerDescriptor controllerDescriptor in controllerMap.Values)
                {
                    IHttpActionSelector actionSelector = controllerDescriptor.Configuration.Services.GetActionSelector();

                    ILookup<string, HttpActionDescriptor> actionsByName =
                        actionSelector.GetActionMapping(controllerDescriptor);
                    if (actionsByName == null)
                    {
                        continue;
                    }

                    List<HttpActionDescriptor> actions = actionsByName.SelectMany(g => g).ToList();
                    IReadOnlyCollection<RouteEntry> newEntries =
                        directRouteProvider.GetDirectRoutes(controllerDescriptor, actions, constraintResolver);
                    if (newEntries == null)
                    {
                        throw Error.InvalidOperation(
                            SRResources.TypeMethodMustNotReturnNull,
                            typeof(IDirectRouteProvider).Name, "GetDirectRoutes");
                    }

                    foreach (RouteEntry entry in newEntries)
                    {
                        if (entry == null)
                        {
                            throw Error.InvalidOperation(
                                SRResources.TypeMethodMustNotReturnNull,
                                typeof(IDirectRouteProvider).Name, "GetDirectRoutes");
                        }

                        DirectRouteBuilder.ValidateRouteEntry(entry);

                        // We need to mark each action as only reachable by direct routes so that traditional routes
                        // don't accidentally hit them.
                        HttpControllerDescriptor routeControllerDescriptor = entry.Route.GetTargetControllerDescriptor();
                        if (routeControllerDescriptor == null)
                        {
                            HttpActionDescriptor[] actionDescriptors = entry.Route.GetTargetActionDescriptors();
                            foreach (var actionDescriptor in actionDescriptors)
                            {
                                actionDescriptor.SetIsAttributeRouted(true);
                            }
                        }
                        else
                        {
                            routeControllerDescriptor.SetIsAttributeRouted(true);
                        }
                    }

                    collector.AddRange(newEntries);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/BoundRouteTemplate.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Represents a URI generated from a <see cref="HttpParsedRoute"/>. 
    /// </summary>
    internal class BoundRouteTemplate
    {
        public string BoundTemplate { get; set; }

        public HttpRouteValueDictionary Values { get; set; }
    }
}


================================================
FILE: src/System.Web.Http/Routing/DefaultDirectRouteProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// A default implementation of <see cref="IDirectRouteProvider"/>.
    /// </summary>
    public class DefaultDirectRouteProvider : IDirectRouteProvider
    {
        /// <summary>
        /// Gets direct routes for the given controller descriptor and action descriptors based on 
        /// <see cref="IDirectRouteFactory"/> attributes.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="actionDescriptors">The action descriptors for all actions.</param>
        /// <param name="constraintResolver">The constraint resolver.</param>
        /// <returns>A set of route entries.</returns>
        /// <remarks>
        /// The implementation returns route entries for the given controller and actions. 
        /// 
        /// Any actions that have associated <see cref="IDirectRouteFactory"/> instances will produce route
        /// entries that route direct to those actions.
        /// 
        /// Any actions that do not have an associated <see cref="IDirectRouteFactory"/> instances will be
        /// associated with the controller. If the controller has any associated <see cref="IDirectRouteProvider"/>
        /// instances, then route entries will be created for the controller and associated actions.
        /// </remarks>
        public virtual IReadOnlyList<RouteEntry> GetDirectRoutes(
            HttpControllerDescriptor controllerDescriptor, 
            IReadOnlyList<HttpActionDescriptor> actionDescriptors,
            IInlineConstraintResolver constraintResolver)
        {
            List<RouteEntry> entries = new List<RouteEntry>();

            List<HttpActionDescriptor> actionsWithoutRoutes = new List<HttpActionDescriptor>();

            foreach (HttpActionDescriptor action in actionDescriptors)
            {
                IReadOnlyList<IDirectRouteFactory> factories = GetActionRouteFactories(action);

                if (factories != null && factories.Count > 0)
                {
                    IReadOnlyCollection<RouteEntry> actionEntries = GetActionDirectRoutes(action, factories, constraintResolver);
                    if (actionEntries != null)
                    {
                        entries.AddRange(actionEntries);
                    }
                }
                else
                {
                    // IF there are no routes on the specific action, attach it to the controller routes (if any).
                    actionsWithoutRoutes.Add(action);
                }
            }

            if (actionsWithoutRoutes.Count > 0)
            {
                IReadOnlyList<IDirectRouteFactory> controllerFactories = GetControllerRouteFactories(controllerDescriptor);
                if (controllerFactories != null && controllerFactories.Count > 0)
                {
                    IReadOnlyCollection<RouteEntry> controllerEntries = GetControllerDirectRoutes(
                        controllerDescriptor,
                        actionsWithoutRoutes, 
                        controllerFactories, 
                        constraintResolver);

                    if (controllerEntries != null)
                    {
                        entries.AddRange(controllerEntries);
                    }
                }
            }

            return entries;
        }

        /// <summary>
        /// Gets route factories for the given controller descriptor.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <returns>A set of route factories.</returns>
        /// <remarks>
        /// The implementation returns <see cref="IDirectRouteFactory"/> instances based on attributes on the controller.
        /// </remarks>
        protected virtual IReadOnlyList<IDirectRouteFactory> GetControllerRouteFactories(HttpControllerDescriptor controllerDescriptor)
        {
            Collection<IDirectRouteFactory> newFactories = controllerDescriptor.GetCustomAttributes<IDirectRouteFactory>(inherit: false);

            Collection<IHttpRouteInfoProvider> oldProviders = controllerDescriptor.GetCustomAttributes<IHttpRouteInfoProvider>(inherit: false);

            List<IDirectRouteFactory> combined = new List<IDirectRouteFactory>();
            combined.AddRange(newFactories);

            foreach (IHttpRouteInfoProvider oldProvider in oldProviders)
            {
                if (oldProvider is IDirectRouteFactory)
                {
                    continue;
                }

                combined.Add(new RouteInfoDirectRouteFactory(oldProvider));
            }

            return combined;
        }

        /// <summary>
        /// Gets a set of route factories for the given action descriptor.
        /// </summary>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <returns>A set of route factories.</returns>
        /// <remarks>
        /// The implementation returns <see cref="IDirectRouteFactory"/> instances based on attributes on the action. Returns
        /// null if the action was defined on a base class of this controller.
        /// </remarks>
        protected virtual IReadOnlyList<IDirectRouteFactory> GetActionRouteFactories(HttpActionDescriptor actionDescriptor)
        {
            // Ignore the Route attributes from inherited actions.
            ReflectedHttpActionDescriptor reflectedActionDescriptor = actionDescriptor as ReflectedHttpActionDescriptor;
            if (reflectedActionDescriptor != null &&
                reflectedActionDescriptor.MethodInfo != null &&
                reflectedActionDescriptor.MethodInfo.DeclaringType != actionDescriptor.ControllerDescriptor.ControllerType)
            {
                return null;
            }

            Collection<IDirectRouteFactory> newFactories = actionDescriptor.GetCustomAttributes<IDirectRouteFactory>(inherit: false);

            Collection<IHttpRouteInfoProvider> oldProviders = actionDescriptor.GetCustomAttributes<IHttpRouteInfoProvider>(inherit: false);

            List<IDirectRouteFactory> combined = new List<IDirectRouteFactory>();
            combined.AddRange(newFactories);

            foreach (IHttpRouteInfoProvider oldProvider in oldProviders)
            {
                if (oldProvider is IDirectRouteFactory)
                {
                    continue;
                }

                combined.Add(new RouteInfoDirectRouteFactory(oldProvider));
            }

            return combined;
        }

        /// <summary>
        /// Creates <see cref="RouteEntry"/> instances based on the provided factories, controller and actions. The route
        /// entries provided direct routing to the provided controller and can reach the set of provided actions.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="actionDescriptors">The action descriptors.</param>
        /// <param name="factories">The direct route factories.</param>
        /// <param name="constraintResolver">The constraint resolver.</param>
        /// <returns>A set of route entries.</returns>
        protected virtual IReadOnlyList<RouteEntry> GetControllerDirectRoutes(
            HttpControllerDescriptor controllerDescriptor,
            IReadOnlyList<HttpActionDescriptor> actionDescriptors,
            IReadOnlyList<IDirectRouteFactory> factories,
            IInlineConstraintResolver constraintResolver)
        {
            return CreateRouteEntries(
                GetRoutePrefix(controllerDescriptor), 
                factories, 
                actionDescriptors, 
                constraintResolver, 
                targetIsAction: false);
        }

        /// <summary>
        /// Creates <see cref="RouteEntry"/> instances based on the provided factories and action. The route entries
        /// provide direct routing to the provided action.
        /// </summary>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <param name="factories">The direct route factories.</param>
        /// <param name="constraintResolver">The constraint resolver.</param>
        /// <returns>A set of route entries.</returns>
        protected virtual IReadOnlyList<RouteEntry> GetActionDirectRoutes(
            HttpActionDescriptor actionDescriptor, 
            IReadOnlyList<IDirectRouteFactory> factories,
            IInlineConstraintResolver constraintResolver)
        {
            return CreateRouteEntries(
                GetRoutePrefix(actionDescriptor.ControllerDescriptor), 
                factories, 
                new HttpActionDescriptor[] { actionDescriptor }, 
                constraintResolver, 
                targetIsAction: true);
        }

        /// <summary>
        /// Gets the route prefix from the provided controller.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <returns>The route prefix or null.</returns>
        protected virtual string GetRoutePrefix(HttpControllerDescriptor controllerDescriptor)
        {
            Collection<IRoutePrefix> attributes = controllerDescriptor.GetCustomAttributes<IRoutePrefix>(inherit: false);

            if (attributes == null)
            {
                return null;
            }

            if (attributes.Count > 1)
            {
                string errorMessage = Error.Format(SRResources.RoutePrefix_CannotSupportMultiRoutePrefix, controllerDescriptor.ControllerType.FullName);
                throw new InvalidOperationException(errorMessage);
            }

            if (attributes.Count == 1)
            {
                IRoutePrefix attribute = attributes[0];

                if (attribute != null)
                {
                    string prefix = attribute.Prefix;
                    if (prefix == null)
                    {
                        string errorMessage = Error.Format(
                            SRResources.RoutePrefix_PrefixCannotBeNull,
                            controllerDescriptor.ControllerType.FullName);
                        throw new InvalidOperationException(errorMessage);
                    }

                    if (prefix.EndsWith("/", StringComparison.Ordinal))
                    {
                        throw Error.InvalidOperation(SRResources.AttributeRoutes_InvalidPrefix, prefix,
                            controllerDescriptor.ControllerName);
                    }

                    return prefix;
                }
            }

            return null;
        }

        private static IReadOnlyList<RouteEntry> CreateRouteEntries(
            string prefix,
            IReadOnlyCollection<IDirectRouteFactory> factories,
            IReadOnlyCollection<HttpActionDescriptor> actions, 
            IInlineConstraintResolver constraintResolver, 
            bool targetIsAction)
        {
            List<RouteEntry> entries = new List<RouteEntry>();
            foreach (IDirectRouteFactory factory in factories)
            {
                RouteEntry entry = CreateRouteEntry(prefix, factory, actions, constraintResolver, targetIsAction);
                entries.Add(entry);
            }

            return entries;
        }

        private static RouteEntry CreateRouteEntry(
            string prefix,
            IDirectRouteFactory factory,
            IReadOnlyCollection<HttpActionDescriptor> actions,
            IInlineConstraintResolver constraintResolver,
            bool targetIsAction)
        {
            Contract.Assert(factory != null);

            DirectRouteFactoryContext context = new DirectRouteFactoryContext(prefix, actions, constraintResolver, targetIsAction);
            RouteEntry entry = factory.CreateRoute(context);

            if (entry == null)
            {
                throw Error.InvalidOperation(SRResources.TypeMethodMustNotReturnNull,
                    typeof(IDirectRouteFactory).Name, "CreateRoute");
            }

            DirectRouteBuilder.ValidateRouteEntry(entry);

            return entry;
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpMethodConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http;

namespace System.Web.Http.Routing
{
    public class HttpMethodConstraint : IHttpRouteConstraint
    {
        public HttpMethodConstraint(params HttpMethod[] allowedMethods)
        {
            if (allowedMethods == null)
            {
                throw Error.ArgumentNull("allowedMethods");
            }

            AllowedMethods = new Collection<HttpMethod>(allowedMethods);
        }

        public Collection<HttpMethod> AllowedMethods { get; private set; }

        protected virtual bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (parameterName == null)
            {
                throw Error.ArgumentNull("parameterName");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            switch (routeDirection)
            {
                case HttpRouteDirection.UriResolution:
                    return AllowedMethods.Contains(request.Method);

                case HttpRouteDirection.UriGeneration:
                    // We need to see if the user specified the HTTP method explicitly.  Consider these two routes:
                    //
                    // a) Route: template = "/{foo}", Constraints = { httpMethod = new HttpMethodConstraint("GET") }
                    // b) Route: template = "/{foo}", Constraints = { httpMethod = new HttpMethodConstraint("POST") }
                    //
                    // A user might know ahead of time that a URI he/she is generating might be used with a particular HTTP
                    // method.  If a URI will be used for an HTTP POST but we match on (a) while generating the URI, then
                    // the HTTP GET-specific route will be used for URI generation, which might have undesired behavior.
                    // To prevent this, a user might call RouteCollection.GetVirtualPath(..., { httpMethod = "POST" }) to
                    // signal that he is generating a URI that will be used for an HTTP POST, so he wants the URI
                    // generation to be performed by the (b) route instead of the (a) route, consistent with what would
                    // happen on incoming requests.
                    HttpMethod constraint;
                    if (!values.TryGetValue(parameterName, out constraint))
                    {
                        return true;
                    }

                    return AllowedMethods.Contains(constraint);

                default:
                    throw Error.InvalidEnumArgument(String.Empty, (int)routeDirection, typeof(HttpRouteDirection));
            }
        }

        bool IHttpRouteConstraint.Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
        {
            return Match(request, route, parameterName, values, routeDirection);
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpParsedRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace System.Web.Http.Routing
{
    internal sealed class HttpParsedRoute
    {
        public HttpParsedRoute(List<PathSegment> pathSegments)
        {
            Contract.Assert(pathSegments != null);
            PathSegments = pathSegments;
        }

        public List<PathSegment> PathSegments { get; private set; }

        [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "Not changing original algorithm")]
        [SuppressMessage("Microsoft.Maintainability", "CA1505:AvoidUnmaintainableCode", Justification = "Not changing original algorithm")]
        [SuppressMessage("Microsoft.Performance", "CA1809:AvoidExcessiveLocals",
            Justification = "Not changing original algorithm. Also fine unless building Debug configuration.")]
        public BoundRouteTemplate Bind(IDictionary<string, object> currentValues, IDictionary<string, object> values, HttpRouteValueDictionary defaultValues, HttpRouteValueDictionary constraints)
        {
            if (currentValues == null)
            {
                currentValues = new HttpRouteValueDictionary();
            }

            if (values == null)
            {
                values = new HttpRouteValueDictionary();
            }

            if (defaultValues == null)
            {
                defaultValues = new HttpRouteValueDictionary();
            }

            // The set of values we should be using when generating the URI in this route
            HttpRouteValueDictionary acceptedValues = new HttpRouteValueDictionary();

            // Keep track of which new values have been used
            HashSet<string> unusedNewValues = new HashSet<string>(values.Keys, StringComparer.OrdinalIgnoreCase);

            // Step 1: Get the list of values we're going to try to use to match and generate this URI

            // Find out which entries in the URI are valid for the URI we want to generate.
            // If the URI had ordered parameters a="1", b="2", c="3" and the new values
            // specified that b="9", then we need to invalidate everything after it. The new
            // values should then be a="1", b="9", c=<no value>.
            ForEachParameter(PathSegments, delegate(PathParameterSubsegment parameterSubsegment)
            {
                // If it's a parameter subsegment, examine the current value to see if it matches the new value
                string parameterName = parameterSubsegment.ParameterName;

                object newParameterValue;
                bool hasNewParameterValue = values.TryGetValue(parameterName, out newParameterValue);
                if (hasNewParameterValue)
                {
                    unusedNewValues.Remove(parameterName);
                }

                object currentParameterValue;
                bool hasCurrentParameterValue = currentValues.TryGetValue(parameterName, out currentParameterValue);

                if (hasNewParameterValue && hasCurrentParameterValue)
                {
                    if (!RoutePartsEqual(currentParameterValue, newParameterValue))
                    {
                        // Stop copying current values when we find one that doesn't match
                        return false;
                    }
                }

                // If the parameter is a match, add it to the list of values we will use for URI generation
                if (hasNewParameterValue)
                {
                    if (IsRoutePartNonEmpty(newParameterValue))
                    {
                        acceptedValues.Add(parameterName, newParameterValue);
                    }
                }
                else
                {
                    if (hasCurrentParameterValue)
                    {
                        acceptedValues.Add(parameterName, currentParameterValue);
                    }
                }
                return true;
            });

            // Add all remaining new values to the list of values we will use for URI generation
            foreach (var newValue in values)
            {
                if (IsRoutePartNonEmpty(newValue.Value))
                {
                    if (!acceptedValues.ContainsKey(newValue.Key))
                    {
                        acceptedValues.Add(newValue.Key, newValue.Value);
                    }
                }
            }

            // Add all current values that aren't in the URI at all
            foreach (var currentValue in currentValues)
            {
                string parameterName = currentValue.Key;
                if (!acceptedValues.ContainsKey(parameterName))
                {
                    PathParameterSubsegment parameterSubsegment = GetParameterSubsegment(PathSegments, parameterName);
                    if (parameterSubsegment == null)
                    {
                        acceptedValues.Add(parameterName, currentValue.Value);
                    }
                }
            }

            // Add all remaining default values from the route to the list of values we will use for URI generation
            ForEachParameter(PathSegments, delegate(PathParameterSubsegment parameterSubsegment)
            {
                if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName))
                {
                    object defaultValue;
                    if (!IsParameterRequired(parameterSubsegment, defaultValues, out defaultValue))
                    {
                        // Add the default value only if there isn't already a new value for it and
                        // only if it actually has a default value, which we determine based on whether
                        // the parameter value is required.
                        acceptedValues.Add(parameterSubsegment.ParameterName, defaultValue);
                    }
                }
                return true;
            });

            // All required parameters in this URI must have values from somewhere (i.e. the accepted values)
            bool hasAllRequiredValues = ForEachParameter(PathSegments, delegate(PathParameterSubsegment parameterSubsegment)
            {
                object defaultValue;
                if (IsParameterRequired(parameterSubsegment, defaultValues, out defaultValue))
                {
                    if (!acceptedValues.ContainsKey(parameterSubsegment.ParameterName))
                    {
                        // If the route parameter value is required that means there's
                        // no default value, so if there wasn't a new value for it
                        // either, this route won't match.
                        return false;
                    }
                }
                return true;
            });
            if (!hasAllRequiredValues)
            {
                return null;
            }

            // All other default values must match if they are explicitly defined in the new values
            HttpRouteValueDictionary otherDefaultValues = new HttpRouteValueDictionary(defaultValues);
            ForEachParameter(PathSegments, delegate(PathParameterSubsegment parameterSubsegment)
            {
                otherDefaultValues.Remove(parameterSubsegment.ParameterName);
                return true;
            });

            foreach (var defaultValue in otherDefaultValues)
            {
                object value;
                if (values.TryGetValue(defaultValue.Key, out value))
                {
                    unusedNewValues.Remove(defaultValue.Key);
                    if (!RoutePartsEqual(value, defaultValue.Value))
                    {
                        // If there is a non-parameterized value in the route and there is a
                        // new value for it and it doesn't match, this route won't match.
                        return null;
                    }
                }
            }

            // Step 2: If the route is a match generate the appropriate URI

            StringBuilder uri = new StringBuilder();
            StringBuilder pendingParts = new StringBuilder();

            bool pendingPartsAreAllSafe = false;
            bool blockAllUriAppends = false;

            for (int i = 0; i < PathSegments.Count; i++)
            {
                PathSegment pathSegment = PathSegments[i]; // parsedRouteUriPart

                if (pathSegment is PathSeparatorSegment)
                {
                    if (pendingPartsAreAllSafe)
                    {
                        // Accept
                        if (pendingParts.Length > 0)
                        {
                            if (blockAllUriAppends)
                            {
                                return null;
                            }

                            // Append any pending literals to the URI
                            uri.Append(pendingParts.ToString());
                            pendingParts.Length = 0;
                        }
                    }
                    pendingPartsAreAllSafe = false;

                    // Guard against appending multiple separators for empty segments
                    if (pendingParts.Length > 0 && pendingParts[pendingParts.Length - 1] == '/')
                    {
                        // Dev10 676725: Route should not be matched if that causes mismatched tokens
                        // Dev11 86819: We will allow empty matches if all subsequent segments are null
                        if (blockAllUriAppends)
                        {
                            return null;
                        }

                        // Append any pending literals to the URI (without the trailing slash) and prevent any future appends
                        uri.Append(pendingParts.ToString(0, pendingParts.Length - 1));
                        pendingParts.Length = 0;
                        blockAllUriAppends = true;
                    }
                    else
                    {
                        pendingParts.Append("/");
                    }
                }
                else
                {
                    PathContentSegment contentPathSegment = pathSegment as PathContentSegment;
                    if (contentPathSegment != null)
                    {
                        // Segments are treated as all-or-none. We should never output a partial segment.
                        // If we add any subsegment of this segment to the generated URI, we have to add
                        // the complete match. For example, if the subsegment is "{p1}-{p2}.xml" and we
                        // used a value for {p1}, we have to output the entire segment up to the next "/".
                        // Otherwise we could end up with the partial segment "v1" instead of the entire
                        // segment "v1-v2.xml".
                        bool addedAnySubsegments = false;

                        for (int j = 0; j < contentPathSegment.Subsegments.Count; j++)
                        {
                            PathSubsegment subsegment = contentPathSegment.Subsegments[j];
                            PathLiteralSubsegment literalSubsegment = subsegment as PathLiteralSubsegment;
                            if (literalSubsegment != null)
                            {
                                // If it's a literal we hold on to it until we are sure we need to add it
                                pendingPartsAreAllSafe = true;
                                pendingParts.Append(literalSubsegment.Literal);
                            }
                            else
                            {
                                PathParameterSubsegment parameterSubsegment = subsegment as PathParameterSubsegment;
                                if (parameterSubsegment != null)
                                {
                                    if (pendingPartsAreAllSafe)
                                    {
                                        // Accept
                                        if (pendingParts.Length > 0)
                                        {
                                            if (blockAllUriAppends)
                                            {
                                                return null;
                                            }

                                            // Append any pending literals to the URI
                                            uri.Append(pendingParts.ToString());
                                            pendingParts.Length = 0;

                                            addedAnySubsegments = true;
                                        }
                                    }
                                    pendingPartsAreAllSafe = false;

                                    // If it's a parameter, get its value
                                    object acceptedParameterValue;
                                    bool hasAcceptedParameterValue = acceptedValues.TryGetValue(parameterSubsegment.ParameterName, out acceptedParameterValue);
                                    if (hasAcceptedParameterValue)
                                    {
                                        unusedNewValues.Remove(parameterSubsegment.ParameterName);
                                    }

                                    object defaultParameterValue;
                                    defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultParameterValue);

                                    if (RoutePartsEqual(acceptedParameterValue, defaultParameterValue))
                                    {
                                        // If the accepted value is the same as the default value, mark it as pending since
                                        // we won't necessarily add it to the URI we generate.
                                        pendingParts.Append(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture));
                                    }
                                    else
                                    {
                                        if (blockAllUriAppends)
                                        {
                                            return null;
                                        }

                                        // Add the new part to the URI as well as any pending parts
                                        if (pendingParts.Length > 0)
                                        {
                                            // Append any pending literals to the URI
                                            uri.Append(pendingParts.ToString());
                                            pendingParts.Length = 0;
                                        }
                                        uri.Append(Convert.ToString(acceptedParameterValue, CultureInfo.InvariantCulture));

                                        addedAnySubsegments = true;
                                    }
                                }
                                else
                                {
                                    Contract.Assert(false, "Invalid path subsegment type");
                                }
                            }
                        }

                        if (addedAnySubsegments)
                        {
                            // See comment above about why we add the pending parts
                            if (pendingParts.Length > 0)
                            {
                                if (blockAllUriAppends)
                                {
                                    return null;
                                }

                                // Append any pending literals to the URI
                                uri.Append(pendingParts.ToString());
                                pendingParts.Length = 0;
                            }
                        }
                    }
                    else
                    {
                        Contract.Assert(false, "Invalid path segment type");
                    }
                }
            }

            if (pendingPartsAreAllSafe)
            {
                // Accept
                if (pendingParts.Length > 0)
                {
                    if (blockAllUriAppends)
                    {
                        return null;
                    }

                    // Append any pending literals to the URI
                    uri.Append(pendingParts.ToString());
                }
            }

            // Process constraints keys
            if (constraints != null)
            {
                // If there are any constraints, mark all the keys as being used so that we don't
                // generate query string items for custom constraints that don't appear as parameters
                // in the URI format.
                foreach (var constraintsItem in constraints)
                {
                    unusedNewValues.Remove(constraintsItem.Key);
                }
            }

            // Encode the URI before we append the query string, otherwise we would double encode the query string
            StringBuilder encodedUri = new StringBuilder();
            encodedUri.Append(UriEncode(uri.ToString()));
            uri = encodedUri;

            // Add remaining new values as query string parameters to the URI
            if (unusedNewValues.Count > 0)
            {
                // Generate the query string
                bool firstParam = true;
                foreach (string unusedNewValue in unusedNewValues)
                {
                    object value;
                    if (acceptedValues.TryGetValue(unusedNewValue, out value))
                    {
                        uri.Append(firstParam ? '?' : '&');
                        firstParam = false;
                        uri.Append(Uri.EscapeDataString(unusedNewValue));
                        uri.Append('=');
                        uri.Append(Uri.EscapeDataString(Convert.ToString(value, CultureInfo.InvariantCulture)));
                    }
                }
            }

            return new BoundRouteTemplate
            {
                BoundTemplate = uri.ToString(),
                Values = acceptedValues
            };
        }

        private static string EscapeReservedCharacters(Match m)
        {
            return Uri.HexEscape(m.Value[0]);
        }

        private static bool ForEachParameter(List<PathSegment> pathSegments, Func<PathParameterSubsegment, bool> action)
        {
            for (int i = 0; i < pathSegments.Count; i++)
            {
                PathSegment pathSegment = pathSegments[i];

                if (pathSegment is PathSeparatorSegment)
                {
                    // We only care about parameter subsegments, so skip this
                    continue;
                }
                else
                {
                    PathContentSegment contentPathSegment = pathSegment as PathContentSegment;
                    if (contentPathSegment != null)
                    {
                        for (int j = 0; j < contentPathSegment.Subsegments.Count; j++)
                        {
                            PathSubsegment subsegment = contentPathSegment.Subsegments[j];
                            PathLiteralSubsegment literalSubsegment = subsegment as PathLiteralSubsegment;
                            if (literalSubsegment != null)
                            {
                                // We only care about parameter subsegments, so skip this
                                continue;
                            }
                            else
                            {
                                PathParameterSubsegment parameterSubsegment = subsegment as PathParameterSubsegment;
                                if (parameterSubsegment != null)
                                {
                                    if (!action(parameterSubsegment))
                                    {
                                        return false;
                                    }
                                }
                                else
                                {
                                    Contract.Assert(false, "Invalid path subsegment type");
                                }
                            }
                        }
                    }
                    else
                    {
                        Contract.Assert(false, "Invalid path segment type");
                    }
                }
            }

            return true;
        }

        private static PathParameterSubsegment GetParameterSubsegment(List<PathSegment> pathSegments, string parameterName)
        {
            PathParameterSubsegment foundParameterSubsegment = null;

            ForEachParameter(pathSegments, delegate(PathParameterSubsegment parameterSubsegment)
            {
                if (String.Equals(parameterName, parameterSubsegment.ParameterName, StringComparison.OrdinalIgnoreCase))
                {
                    foundParameterSubsegment = parameterSubsegment;
                    return false;
                }
                else
                {
                    return true;
                }
            });

            return foundParameterSubsegment;
        }

        private static bool IsParameterRequired(PathParameterSubsegment parameterSubsegment, HttpRouteValueDictionary defaultValues, out object defaultValue)
        {
            if (parameterSubsegment.IsCatchAll)
            {
                defaultValue = null;
                return false;
            }

            return !defaultValues.TryGetValue(parameterSubsegment.ParameterName, out defaultValue);
        }

        private static bool IsRoutePartNonEmpty(object routePart)
        {
            string routePartString = routePart as string;
            if (routePartString != null)
            {
                return routePartString.Length > 0;
            }
            return routePart != null;
        }

        public HttpRouteValueDictionary Match(RoutingContext context, HttpRouteValueDictionary defaultValues)
        {
            List<string> requestPathSegments = context.PathSegments;

            if (defaultValues == null)
            {
                defaultValues = new HttpRouteValueDictionary();
            }

            HttpRouteValueDictionary matchedValues = new HttpRouteValueDictionary();

            // This flag gets set once all the data in the URI has been parsed through, but
            // the route we're trying to match against still has more parts. At this point
            // we'll only continue matching separator characters and parameters that have
            // default values.
            bool ranOutOfStuffToParse = false;

            // This value gets set once we start processing a catchall parameter (if there is one
            // at all). Once we set this value we consume all remaining parts of the URI into its
            // parameter value.
            bool usedCatchAllParameter = false;

            for (int i = 0; i < PathSegments.Count; i++)
            {
                PathSegment pathSegment = PathSegments[i];

                if (requestPathSegments.Count <= i)
                {
                    ranOutOfStuffToParse = true;
                }

                string requestPathSegment = ranOutOfStuffToParse ? null : requestPathSegments[i];

                if (pathSegment is PathSeparatorSegment)
                {
                    if (ranOutOfStuffToParse)
                    {
                        // If we're trying to match a separator in the route but there's no more content, that's OK
                    }
                    else
                    {
                        if (!String.Equals(requestPathSegment, "/", StringComparison.Ordinal))
                        {
                            return null;
                        }
                    }
                }
                else
                {
                    PathContentSegment contentPathSegment = pathSegment as PathContentSegment;
                    if (contentPathSegment != null)
                    {
                        if (contentPathSegment.IsCatchAll)
                        {
                            Contract.Assert(i == (PathSegments.Count - 1), "If we're processing a catch-all, we should be on the last route segment.");
                            MatchCatchAll(contentPathSegment, requestPathSegments.Skip(i), defaultValues, matchedValues);
                            usedCatchAllParameter = true;
                        }
                        else
                        {
                            if (!MatchContentPathSegment(contentPathSegment, requestPathSegment, defaultValues, matchedValues))
                            {
                                return null;
                            }
                        }
                    }
                    else
                    {
                        Contract.Assert(false, "Invalid path segment type");
                    }
                }
            }

            if (!usedCatchAllParameter)
            {
                if (PathSegments.Count < requestPathSegments.Count)
                {
                    // If we've already gone through all the parts defined in the route but the URI
                    // still contains more content, check that the remaining content is all separators.
                    for (int i = PathSegments.Count; i < requestPathSegments.Count; i++)
                    {
                        if (!RouteParser.IsSeparator(requestPathSegments[i]))
                        {
                            return null;
                        }
                    }
                }
            }

            // Copy all remaining default values to the route data
            if (defaultValues != null)
            {
                foreach (var defaultValue in defaultValues)
                {
                    if (!matchedValues.ContainsKey(defaultValue.Key))
                    {
                        matchedValues.Add(defaultValue.Key, defaultValue.Value);
                    }
                }
            }

            return matchedValues;
        }

        private static void MatchCatchAll(PathContentSegment contentPathSegment, IEnumerable<string> remainingRequestSegments, HttpRouteValueDictionary defaultValues, HttpRouteValueDictionary matchedValues)
        {
            string remainingRequest = String.Join(String.Empty, remainingRequestSegments.ToArray());

            PathParameterSubsegment catchAllSegment = contentPathSegment.Subsegments[0] as PathParameterSubsegment;

            object catchAllValue;

            if (remainingRequest.Length > 0)
            {
                catchAllValue = remainingRequest;
            }
            else
            {
                defaultValues.TryGetValue(catchAllSegment.ParameterName, out catchAllValue);
            }

            matchedValues.Add(catchAllSegment.ParameterName, catchAllValue);
        }

        private static bool MatchContentPathSegment(PathContentSegment routeSegment, string requestPathSegment, HttpRouteValueDictionary defaultValues, HttpRouteValueDictionary matchedValues)
        {
            if (String.IsNullOrEmpty(requestPathSegment))
            {
                // If there's no data to parse, we must have exactly one parameter segment and no other segments - otherwise no match

                if (routeSegment.Subsegments.Count > 1)
                {
                    return false;
                }

                PathParameterSubsegment parameterSubsegment = routeSegment.Subsegments[0] as PathParameterSubsegment;
                if (parameterSubsegment == null)
                {
                    return false;
                }

                // We must have a default value since there's no value in the request URI
                object parameterValue;
                if (defaultValues.TryGetValue(parameterSubsegment.ParameterName, out parameterValue))
                {
                    // If there's a default value for this parameter, use that default value
                    matchedValues.Add(parameterSubsegment.ParameterName, parameterValue);
                    return true;
                }
                else
                {
                    // If there's no default value, this segment doesn't match
                    return false;
                }
            }

            // Optimize for the common case where there is only one subsegment in the segment - either a parameter or a literal
            if (routeSegment.Subsegments.Count == 1)
            {
                return MatchSingleContentPathSegment(routeSegment.Subsegments[0], requestPathSegment, matchedValues);
            }

            // Find last literal segment and get its last index in the string

            int lastIndex = requestPathSegment.Length;
            int indexOfLastSegmentUsed = routeSegment.Subsegments.Count - 1;

            PathParameterSubsegment parameterNeedsValue = null; // Keeps track of a parameter segment that is pending a value
            PathLiteralSubsegment lastLiteral = null; // Keeps track of the left-most literal we've encountered

            while (indexOfLastSegmentUsed >= 0)
            {
                int newLastIndex = lastIndex;

                PathParameterSubsegment parameterSubsegment = routeSegment.Subsegments[indexOfLastSegmentUsed] as PathParameterSubsegment;
                if (parameterSubsegment != null)
                {
                    // Hold on to the parameter so that we can fill it in when we locate the next literal
                    parameterNeedsValue = parameterSubsegment;
                }
                else
                {
                    PathLiteralSubsegment literalSubsegment = routeSegment.Subsegments[indexOfLastSegmentUsed] as PathLiteralSubsegment;
                    if (literalSubsegment != null)
                    {
                        lastLiteral = literalSubsegment;

                        int startIndex = lastIndex - 1;
                        // If we have a pending parameter subsegment, we must leave at least one character for that
                        if (parameterNeedsValue != null)
                        {
                            startIndex--;
                        }

                        if (startIndex < 0)
                        {
                            return false;
                        }

                        int indexOfLiteral = requestPathSegment.LastIndexOf(literalSubsegment.Literal, startIndex, StringComparison.OrdinalIgnoreCase);
                        if (indexOfLiteral == -1)
                        {
                            // If we couldn't find this literal index, this segment cannot match
                            return false;
                        }

                        // If the first subsegment is a literal, it must match at the right-most extent of the request URI.
                        // Without this check if your route had "/Foo/" we'd match the request URI "/somethingFoo/".
                        // This check is related to the check we do at the very end of this function.
                        if (indexOfLastSegmentUsed == (routeSegment.Subsegments.Count - 1))
                        {
                            if ((indexOfLiteral + literalSubsegment.Literal.Length) != requestPathSegment.Length)
                            {
                                return false;
                            }
                        }

                        newLastIndex = indexOfLiteral;
                    }
                    else
                    {
                        Contract.Assert(false, "Invalid path segment type");
                    }
                }

                if ((parameterNeedsValue != null) && (((lastLiteral != null) && (parameterSubsegment == null)) || (indexOfLastSegmentUsed == 0)))
                {
                    // If we have a pending parameter that needs a value, grab that value

                    int parameterStartIndex;
                    int parameterTextLength;

                    if (lastLiteral == null)
                    {
                        if (indexOfLastSegmentUsed == 0)
                        {
                            parameterStartIndex = 0;
                        }
                        else
                        {
                            parameterStartIndex = newLastIndex;
                            Contract.Assert(false, "indexOfLastSegementUsed should always be 0 from the check above");
                        }
                        parameterTextLength = lastIndex;
                    }
                    else
                    {
                        // If we're getting a value for a parameter that is somewhere in the middle of the segment
                        if ((indexOfLastSegmentUsed == 0) && (parameterSubsegment != null))
                        {
                            parameterStartIndex = 0;
                            parameterTextLength = lastIndex;
                        }
                        else
                        {
                            parameterStartIndex = newLastIndex + lastLiteral.Literal.Length;
                            parameterTextLength = lastIndex - parameterStartIndex;
                        }
                    }

                    string parameterValueString = requestPathSegment.Substring(parameterStartIndex, parameterTextLength);

                    if (String.IsNullOrEmpty(parameterValueString))
                    {
                        // If we're here that means we have a segment that contains multiple sub-segments.
                        // For these segments all parameters must have non-empty values. If the parameter
                        // has an empty value it's not a match.
                        return false;
                    }
                    else
                    {
                        // If there's a value in the segment for this parameter, use the subsegment value
                        matchedValues.Add(parameterNeedsValue.ParameterName, parameterValueString);
                    }

                    parameterNeedsValue = null;
                    lastLiteral = null;
                }

                lastIndex = newLastIndex;
                indexOfLastSegmentUsed--;
            }

            // If the last subsegment is a parameter, it's OK that we didn't parse all the way to the left extent of
            // the string since the parameter will have consumed all the remaining text anyway. If the last subsegment
            // is a literal then we *must* have consumed the entire text in that literal. Otherwise we end up matching
            // the route "Foo" to the request URI "somethingFoo". Thus we have to check that we parsed the *entire*
            // request URI in order for it to be a match.
            // This check is related to the check we do earlier in this function for LiteralSubsegments.
            return (lastIndex == 0) || (routeSegment.Subsegments[0] is PathParameterSubsegment);
        }

        private static bool MatchSingleContentPathSegment(PathSubsegment pathSubsegment, string requestPathSegment, HttpRouteValueDictionary matchedValues)
        {
            PathParameterSubsegment parameterSubsegment = pathSubsegment as PathParameterSubsegment;
            if (parameterSubsegment == null)
            {
                // Handle a single literal segment
                PathLiteralSubsegment literalSubsegment = pathSubsegment as PathLiteralSubsegment;
                Contract.Assert(literalSubsegment != null, "Invalid path segment type");
                return literalSubsegment.Literal.Equals(requestPathSegment, StringComparison.OrdinalIgnoreCase);
            }
            else
            {
                // Handle a single parameter segment
                matchedValues.Add(parameterSubsegment.ParameterName, requestPathSegment);
                return true;
            }
        }

        private static bool RoutePartsEqual(object a, object b)
        {
            string sa = a as string;
            string sb = b as string;
            if (sa != null && sb != null)
            {
                // For strings do a case-insensitive comparison
                return String.Equals(sa, sb, StringComparison.OrdinalIgnoreCase);
            }
            else
            {
                if (a != null && b != null)
                {
                    // Explicitly call .Equals() in case it is overridden in the type
                    return a.Equals(b);
                }
                else
                {
                    // At least one of them is null. Return true if they both are
                    return a == b;
                }
            }
        }

        private static string UriEncode(string str)
        {
            string escape = Uri.EscapeUriString(str);
            return Regex.Replace(escape, "([#?])", new MatchEvaluator(EscapeReservedCharacters));
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Text.RegularExpressions;
using System.Web.Http.Properties;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Route class for self-host (i.e. hosted outside of ASP.NET). This class is mostly the
    /// same as the System.Web.Routing.Route implementation.
    /// This class has the same URL matching functionality as System.Web.Routing.Route. However,
    /// in order for this route to match when generating URLs, a special "httproute" key must be
    /// specified when generating the URL.
    /// </summary>
    public class HttpRoute : IHttpRoute
    {
        /// <summary>
        /// Key used to signify that a route URL generation request should include HTTP routes (e.g. Web API).
        /// If this key is not specified then no HTTP routes will match.
        /// </summary>
        public static readonly string HttpRouteKey = "httproute";

        internal const string RoutingContextKey = "MS_RoutingContext";

        private string _routeTemplate;
        private HttpRouteValueDictionary _defaults;
        private HttpRouteValueDictionary _constraints;
        private HttpRouteValueDictionary _dataTokens;

        public HttpRoute()
            : this(routeTemplate: null, defaults: null, constraints: null, dataTokens: null, handler: null, parsedRoute: null)
        {
        }

        public HttpRoute(string routeTemplate)
            : this(routeTemplate, defaults: null, constraints: null, dataTokens: null, handler: null, parsedRoute: null)
        {
        }

        public HttpRoute(string routeTemplate, HttpRouteValueDictionary defaults)
            : this(routeTemplate, defaults, constraints: null, dataTokens: null, handler: null, parsedRoute: null)
        {
        }

        public HttpRoute(string routeTemplate, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints)
            : this(routeTemplate, defaults, constraints, dataTokens: null, handler: null, parsedRoute: null)
        {
        }

        public HttpRoute(string routeTemplate, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints, HttpRouteValueDictionary dataTokens)
            : this(routeTemplate, defaults, constraints, dataTokens, handler: null, parsedRoute: null)
        {
        }

        public HttpRoute(string routeTemplate, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints, HttpRouteValueDictionary dataTokens, HttpMessageHandler handler)
            : this(routeTemplate, defaults, constraints, dataTokens, handler, parsedRoute: null)
        {
        }

        internal HttpRoute(string routeTemplate, HttpRouteValueDictionary defaults, HttpRouteValueDictionary constraints, HttpRouteValueDictionary dataTokens, HttpMessageHandler handler, HttpParsedRoute parsedRoute)
        {
            _routeTemplate = routeTemplate == null ? String.Empty : routeTemplate;
            _defaults = defaults ?? new HttpRouteValueDictionary();
            _constraints = constraints ?? new HttpRouteValueDictionary();
            _dataTokens = dataTokens ?? new HttpRouteValueDictionary();
            Handler = handler;

            if (parsedRoute == null)
            {
                // The parser will throw for invalid routes.
                ParsedRoute = RouteParser.Parse(routeTemplate);
            }
            else
            {
                ParsedRoute = parsedRoute;
            }
        }

        public IDictionary<string, object> Defaults
        {
            get { return _defaults; }
        }

        public IDictionary<string, object> Constraints
        {
            get { return _constraints; }
        }

        public IDictionary<string, object> DataTokens
        {
            get { return _dataTokens; }
        }

        public HttpMessageHandler Handler { get; private set; }

        public string RouteTemplate
        {
            get { return _routeTemplate; }
        }

        internal HttpParsedRoute ParsedRoute { get; private set; }

        public virtual IHttpRouteData GetRouteData(string virtualPathRoot, HttpRequestMessage request)
        {
            if (virtualPathRoot == null)
            {
                throw Error.ArgumentNull("virtualPathRoot");
            }

            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            RoutingContext context = GetOrCreateRoutingContext(virtualPathRoot, request);
            if (!context.IsValid)
            {
                return null;
            }

            HttpRouteValueDictionary values = ParsedRoute.Match(context, _defaults);
            if (values == null)
            {
                // If we got back a null value set, that means the URI did not match
                return null;
            }

            // Validate the values
            if (!ProcessConstraints(request, values, HttpRouteDirection.UriResolution))
            {
                return null;
            }

            return new HttpRouteData(this, values);
        }

        private static RoutingContext GetOrCreateRoutingContext(string virtualPathRoot, HttpRequestMessage request)
        {
            RoutingContext context;
            if (!request.Properties.TryGetValue<RoutingContext>(RoutingContextKey, out context))
            {
                context = CreateRoutingContext(virtualPathRoot, request);
                request.Properties[RoutingContextKey] = context;
            }

            return context;
        }

        private static RoutingContext CreateRoutingContext(string virtualPathRoot, HttpRequestMessage request)
        {
            // Note: we don't validate host/port as this is expected to be done at the host level
            string requestPath = "/" + request.RequestUri.GetComponents(UriComponents.Path, UriFormat.Unescaped);

            // This code is optimized for the common path being an exact case match on the virtual path string.
            // An Ordinal (case-sensitive) comparison is significantly faster than OrdinalIgnoreCase.
            if (!requestPath.StartsWith(virtualPathRoot, StringComparison.Ordinal))
            {
                if (!requestPath.StartsWith(virtualPathRoot, StringComparison.OrdinalIgnoreCase))
                {
                    return RoutingContext.Invalid();
                }
            }

            string relativeRequestPath = null;
            int virtualPathLength = virtualPathRoot.Length;
            if (requestPath.Length > virtualPathLength && requestPath[virtualPathLength] == '/')
            {
                relativeRequestPath = requestPath.Substring(virtualPathLength + 1);
            }
            else
            {
                relativeRequestPath = requestPath.Substring(virtualPathLength);
            }

            return RoutingContext.Valid(RouteParser.SplitUriToPathSegmentStrings(relativeRequestPath));
        }

        /// <summary>
        /// Attempt to generate a URI that represents the values passed in based on current
        /// values from the <see cref="HttpRouteData"/> and new values using the specified <see cref="HttpRoute"/>.
        /// </summary>
        /// <param name="request">The HTTP request message.</param>
        /// <param name="values">The route values.</param>
        /// <returns>A <see cref="HttpVirtualPathData"/> instance or null if URI cannot be generated.</returns>
        public virtual IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, IDictionary<string, object> values)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            // Only perform URL generation if the "httproute" key was specified. This allows these
            // routes to be ignored when a regular MVC app tries to generate URLs. Without this special
            // key an HTTP route used for Web API would normally take over almost all the routes in a
            // typical app.
            if (values != null && !values.Keys.Contains(HttpRouteKey, StringComparer.OrdinalIgnoreCase))
            {
                return null;
            }
            // Remove the value from the collection so that it doesn't affect the generated URL
            var newValues = GetRouteDictionaryWithoutHttpRouteKey(values);

            IHttpRouteData routeData = request.GetRouteData();
            IDictionary<string, object> requestValues = routeData == null ? null : routeData.Values;

            BoundRouteTemplate result = ParsedRoute.Bind(requestValues, newValues, _defaults, _constraints);
            if (result == null)
            {
                return null;
            }

            // Verify that the route matches the validation rules
            if (!ProcessConstraints(request, result.Values, HttpRouteDirection.UriGeneration))
            {
                return null;
            }

            return new HttpVirtualPathData(this, result.BoundTemplate);
        }

        private static IDictionary<string, object> GetRouteDictionaryWithoutHttpRouteKey(IDictionary<string, object> routeValues)
        {
            var newRouteValues = new HttpRouteValueDictionary();
            if (routeValues != null)
            {
                foreach (var routeValue in routeValues)
                {
                    if (!String.Equals(routeValue.Key, HttpRouteKey, StringComparison.OrdinalIgnoreCase))
                    {
                        newRouteValues.Add(routeValue.Key, routeValue.Value);
                    }
                }
            }
            return newRouteValues;
        }

        protected virtual bool ProcessConstraint(HttpRequestMessage request, object constraint, string parameterName, HttpRouteValueDictionary values, HttpRouteDirection routeDirection)
        {
            IHttpRouteConstraint customConstraint = constraint as IHttpRouteConstraint;
            if (customConstraint != null)
            {
                return customConstraint.Match(request, this, parameterName, values, routeDirection);
            }

            // If there was no custom constraint, then treat the constraint as a string which represents a Regex.
            string constraintsRule = constraint as string;
            if (constraintsRule == null)
            {
                throw Error.InvalidOperation(SRResources.Route_ValidationMustBeStringOrCustomConstraint, parameterName, RouteTemplate, typeof(IHttpRouteConstraint).Name);
            }

            object parameterValue;
            values.TryGetValue(parameterName, out parameterValue);
            string parameterValueString = Convert.ToString(parameterValue, CultureInfo.InvariantCulture);
            string constraintsRegEx = "^(" + constraintsRule + ")$";
            return Regex.IsMatch(parameterValueString, constraintsRegEx, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
        }

        private bool ProcessConstraints(HttpRequestMessage request, HttpRouteValueDictionary values, HttpRouteDirection routeDirection)
        {
            if (Constraints != null)
            {
                foreach (KeyValuePair<string, object> constraintsItem in Constraints)
                {
                    if (!ProcessConstraint(request, constraintsItem.Value, constraintsItem.Key, values, routeDirection))
                    {
                        return false;
                    }
                }
            }

            return true;
        }

        // Validates that a constraint is of a type that HttpRoute can process. This is not valid to
        // call when a route implements IHttpRoute or inherits from HttpRoute - as the derived class can handle
        // any types of constraints it wants to support.
        internal static void ValidateConstraint(string routeTemplate, string name, object constraint)
        {
            if (constraint is IHttpRouteConstraint)
            {
                return;
            }

            if (constraint is string)
            {
                return;
            }

            throw CreateInvalidConstraintTypeException(routeTemplate, name);
        }

        private static Exception CreateInvalidConstraintTypeException(string routeTemplate, string name)
        {
            return Error.InvalidOperation(
                SRResources.Route_ValidationMustBeStringOrCustomConstraint,
                name,
                routeTemplate,
                typeof(IHttpRouteConstraint).FullName);
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpRouteData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Routing
{
    public class HttpRouteData : IHttpRouteData
    {
        private IHttpRoute _route;
        private IDictionary<string, object> _values;

        public HttpRouteData(IHttpRoute route)
            : this(route, new HttpRouteValueDictionary())
        {
        }

        public HttpRouteData(IHttpRoute route, HttpRouteValueDictionary values)
        {
            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            _route = route;
            _values = values;
        }

        public IHttpRoute Route
        {
            get { return _route; }
        }

        public IDictionary<string, object> Values
        {
            get { return _values; }
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpRouteDataExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;

namespace System.Web.Http.Routing
{
    public static class HttpRouteDataExtensions
    {
        /// <summary>
        /// Remove all optional parameters that do not have a value from the route data. 
        /// </summary>
        /// <param name="routeData">route data, to be mutated in-place.</param>
        public static void RemoveOptionalRoutingParameters(this IHttpRouteData routeData)
        {
            RemoveOptionalRoutingParameters(routeData.Values);

            var subRouteData = routeData.GetSubRoutes();
            if (subRouteData != null)
            {
                foreach (IHttpRouteData sub in subRouteData)
                {
                    RemoveOptionalRoutingParameters(sub);
                }
            }
        }

        private static void RemoveOptionalRoutingParameters(IDictionary<string, object> routeValueDictionary)
        {
            Contract.Assert(routeValueDictionary != null);

            // Get all keys for which the corresponding value is 'Optional'.
            // Having a separate array is necessary so that we don't manipulate the dictionary while enumerating.
            // This is on a hot-path and linq expressions are showing up on the profile, so do array manipulation.
            int max = routeValueDictionary.Count;
            int i = 0;
            string[] matching = new string[max];
            foreach (KeyValuePair<string, object> kv in routeValueDictionary)
            {
                if (kv.Value == RouteParameter.Optional)
                {
                    matching[i] = kv.Key;
                    i++;
                }
            }
            for (int j = 0; j < i; j++)
            {
                string key = matching[j];
                routeValueDictionary.Remove(key);
            }
        }

        /// <summary>
        /// If a route is really a union of other routes, return the set of sub routes. 
        /// </summary>
        /// <param name="routeData">a union route data</param>
        /// <returns>set of sub soutes contained within this route</returns>
        public static IEnumerable<IHttpRouteData> GetSubRoutes(this IHttpRouteData routeData)
        {
            IHttpRouteData[] subRoutes = null;
            if (routeData.Values.TryGetValue(RouteCollectionRoute.SubRouteDataKey, out subRoutes))
            {
                return subRoutes;
            }
            return null;
        }

        // If routeData is from an attribute route, get the action descriptors, order and precedence that it may match
        // to. Caller still needs to run action selection to pick the specific action.
        // Else return null.
        internal static CandidateAction[] GetDirectRouteCandidates(this IHttpRouteData routeData)
        {
            Contract.Assert(routeData != null);
            IEnumerable<IHttpRouteData> subRoutes = routeData.GetSubRoutes();

            // Possible this is being called on a subroute. This can happen after ElevateRouteData. Just chain. 
            if (subRoutes == null)
            {
                if (routeData.Route == null)
                {
                    // If the matched route is a System.Web.Routing.Route (in web host) then routeData.Route
                    // will be null. Normally a System.Web.Routing.Route match would go through an MVC handler
                    // but we can get here through HttpRoutingDispatcher in WebAPI batching. If that happens, 
                    // then obviously it's not a WebAPI attribute routing match.
                    return null;
                }
                else
                {
                    return routeData.Route.GetDirectRouteCandidates();
                }
            }

            var list = new List<CandidateAction>();

            foreach (IHttpRouteData subData in subRoutes)
            {
                CandidateAction[] candidates = subData.Route.GetDirectRouteCandidates();
                if (candidates != null)
                {
                    list.AddRange(candidates);
                }
            }
            return list.ToArray();
        }
    }
}

================================================
FILE: src/System.Web.Http/Routing/HttpRouteDirection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Routing
{
    public enum HttpRouteDirection
    {
        UriResolution = 0,
        UriGeneration
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpRouteExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Routing
{
    internal static class HttpRouteExtensions
    {
        // If route is a direct route, get the action descriptors, order and precedence it may map to.
        public static CandidateAction[] GetDirectRouteCandidates(this IHttpRoute route)
        {
            Contract.Assert(route != null);

            IDictionary<string, object> dataTokens = route.DataTokens;
            if (dataTokens == null)
            {
                return null;
            }

            List<CandidateAction> candidates = new List<CandidateAction>();

            HttpActionDescriptor[] directRouteActions = null;
            HttpActionDescriptor[] possibleDirectRouteActions;
            if (dataTokens.TryGetValue<HttpActionDescriptor[]>(RouteDataTokenKeys.Actions, out possibleDirectRouteActions))
            {
                if (possibleDirectRouteActions != null && possibleDirectRouteActions.Length > 0)
                {
                    directRouteActions = possibleDirectRouteActions;
                }
            }

            if (directRouteActions == null)
            {
                return null;
            }

            int order = 0;
            int possibleOrder;
            if (dataTokens.TryGetValue<int>(RouteDataTokenKeys.Order, out possibleOrder))
            {
                order = possibleOrder;
            }

            decimal precedence = 0M;
            decimal possiblePrecedence;

            if (dataTokens.TryGetValue<decimal>(RouteDataTokenKeys.Precedence, out possiblePrecedence))
            {
                precedence = possiblePrecedence;
            }

            foreach (HttpActionDescriptor actionDescriptor in directRouteActions)
            {
                candidates.Add(new CandidateAction
                {
                    ActionDescriptor = actionDescriptor,
                    Order = order,
                    Precedence = precedence
                });
            }

            return candidates.ToArray();
        }

        public static HttpActionDescriptor[] GetTargetActionDescriptors(this IHttpRoute route)
        {
            Contract.Assert(route != null);
            IDictionary<string, object> dataTokens = route.DataTokens;

            if (dataTokens == null)
            {
                return null;
            }

            HttpActionDescriptor[] actions;

            if (!dataTokens.TryGetValue<HttpActionDescriptor[]>(RouteDataTokenKeys.Actions, out actions))
            {
                return null;
            }

            return actions;
        }

        public static HttpControllerDescriptor GetTargetControllerDescriptor(this IHttpRoute route)
        {
            Contract.Assert(route != null);
            IDictionary<string, object> dataTokens = route.DataTokens;

            if (dataTokens == null)
            {
                return null;
            }

            HttpControllerDescriptor controller;

            if (!dataTokens.TryGetValue<HttpControllerDescriptor>(RouteDataTokenKeys.Controller, out controller))
            {
                return null;
            }

            return controller;
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpRouteValueDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Web.Http.Internal;

namespace System.Web.Http.Routing
{
    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable", Justification = "This class will never be serialized.")]
    public class HttpRouteValueDictionary : Dictionary<string, object>
    {
        public HttpRouteValueDictionary()
            : base(StringComparer.OrdinalIgnoreCase)
        {
        }

        public HttpRouteValueDictionary(IDictionary<string, object> dictionary)
            : base(StringComparer.OrdinalIgnoreCase)
        {
            if (dictionary != null)
            {
                foreach (KeyValuePair<string, object> current in dictionary)
                {
                    Add(current.Key, current.Value);
                }
            }
        }

        public HttpRouteValueDictionary(object values)
            : base(StringComparer.OrdinalIgnoreCase)
        {
            IDictionary<string, object> valuesAsDictionary = values as IDictionary<string, object>;
            if (valuesAsDictionary != null)
            {
                foreach (KeyValuePair<string, object> current in valuesAsDictionary)
                {
                    Add(current.Key, current.Value);
                }
            }
            else if (values != null)
            {
                foreach (PropertyHelper property in PropertyHelper.GetProperties(values))
                {
                    // Extract the property values from the property helper
                    // The advantage here is that the property helper caches fast accessors.
                    Add(property.Name, property.GetValue(values));
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/HttpVirtualPathData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Routing
{
    public class HttpVirtualPathData : IHttpVirtualPathData
    {
        private string _virtualPath;

        public HttpVirtualPathData(IHttpRoute route, string virtualPath)
        {
            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (virtualPath == null)
            {
                throw Error.ArgumentNull("virtualPath");
            }

            Route = route;
            VirtualPath = virtualPath;
        }

        public IHttpRoute Route { get; private set; }

        public string VirtualPath
        {
            get { return _virtualPath; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _virtualPath = value;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/IHttpRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// <see cref="IHttpRoute"/> defines the interface for a route expressing how to map an incoming <see cref="HttpRequestMessage"/> to a particular controller
    /// and action.
    /// </summary>
    public interface IHttpRoute
    {
        /// <summary>
        /// Gets the route template describing the URI pattern to match against. 
        /// </summary>
        string RouteTemplate { get; }

        /// <summary>
        /// Gets the default values for route parameters if not provided by the incoming <see cref="HttpRequestMessage"/>.
        /// </summary>
        IDictionary<string, object> Defaults { get; }

        /// <summary>
        /// Gets the constraints for the route parameters.
        /// </summary>
        IDictionary<string, object> Constraints { get; }

        /// <summary>
        /// Gets any additional data tokens not used directly to determine whether a route matches an incoming <see cref="HttpRequestMessage"/>.
        /// </summary>
        IDictionary<string, object> DataTokens { get; }

        /// <summary>
        /// Gets the message handler that will be the recipient of the request. If <c>null</c>, the default handler will
        /// be used (which dispatches messages to implementations of <see cref="IHttpController"/>).
        /// </summary>
        HttpMessageHandler Handler { get; }

        /// <summary>
        /// Determine whether this route is a match for the incoming request by looking up the <see cref="IHttpRouteData"/> for the route.
        /// </summary>
        /// <param name="virtualPathRoot">The virtual path root.</param>
        /// <param name="request">The request.</param>
        /// <returns>The <see cref="IHttpRouteData"/> for a route if matches; otherwise <c>null</c>.</returns>
        IHttpRouteData GetRouteData(string virtualPathRoot, HttpRequestMessage request);

        /// <summary>
        /// Compute a URI based on the route and the values provided.
        /// </summary>
        /// <param name="request">The request message.</param>
        /// <param name="values">The values.</param>
        /// <returns></returns>
        IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, IDictionary<string, object> values);
    }
}


================================================
FILE: src/System.Web.Http/Routing/IHttpRouteConstraint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Defines an abstraction for constraining a route.
    /// </summary>
    public interface IHttpRouteConstraint
    {
        /// <summary>
        /// Attempts to match the specified request.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="route">The route that is being constrained.</param>
        /// <param name="parameterName">The name of the parameter.</param>
        /// <param name="values">The route value dictionary.</param>
        /// <param name="routeDirection">The direction of the routing, i.e. URI resolution or URI generation.</param>
        /// <returns><c>false</c> if the route should not match the specified request, or <c>true</c> otherwise</returns>
        bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection);
    }
}


================================================
FILE: src/System.Web.Http/Routing/IHttpRouteData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Routing
{
    public interface IHttpRouteData
    {
        IHttpRoute Route { get; }

        IDictionary<string, object> Values { get; }
    }
}


================================================
FILE: src/System.Web.Http/Routing/IHttpRouteInfoProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Provides information for defining a route.
    /// </summary>
    public interface IHttpRouteInfoProvider
    {
        /// <summary>
        /// Gets the name of the route to generate.
        /// </summary>
        string Name { get; }

        /// <summary>
        /// Gets the route template describing the URI pattern to match against.
        /// </summary>
        string Template { get; }

        /// <summary>
        /// Gets the order of the route relative to other routes. Default value is 0.
        /// </summary>
        int Order { get; }
    }
}


================================================
FILE: src/System.Web.Http/Routing/IHttpVirtualPathData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Routing
{
    public interface IHttpVirtualPathData
    {
        IHttpRoute Route { get; }

        string VirtualPath { get; set; }
    }
}


================================================
FILE: src/System.Web.Http/Routing/LinkGenerationRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Route that generates a virtual path, but does not claim any routes. 
    /// This can be used with RouteCollectionRoute to provide generation by names. 
    /// Delegates to an inner route to do actual generation.
    /// </summary>
    /// <remarks>
    /// Parallel to the MVC implementation of attribute routing in System.Web.Mvc.Routing.LinkGenerationRoute.
    /// </remarks>
    internal class LinkGenerationRoute : IHttpRoute
    {
        private readonly IHttpRoute _innerRoute;

        public LinkGenerationRoute(IHttpRoute innerRoute)
        {
            if (innerRoute == null)
            {
                throw new ArgumentNullException("innerRoute");
            }

            _innerRoute = innerRoute;
        }

        public string RouteTemplate
        {
            get { return _innerRoute.RouteTemplate; }
        }

        public IDictionary<string, object> Defaults
        {
            get { return _innerRoute.Defaults; }
        }

        public IDictionary<string, object> Constraints
        {
            get { return _innerRoute.Constraints; }
        }

        public IDictionary<string, object> DataTokens
        {
            get { return _innerRoute.DataTokens; }
        }

        public HttpMessageHandler Handler
        {
            get { return null; }
        }

        public IHttpRouteData GetRouteData(string virtualPathRoot, HttpRequestMessage request)
        {
            // Claims no routes
            return null;
        }

        public IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, IDictionary<string, object> values)
        {
            return _innerRoute.GetVirtualPath(request, values);
        }
    }
}

================================================
FILE: src/System.Web.Http/Routing/MediaTypeFormatterExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Headers;
using System.Web.Http.Routing;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Extensions for adding <see cref="MediaTypeMapping"/> items to a <see cref="MediaTypeFormatter"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class MediaTypeFormatterExtensions
    {
        /// <summary>
        /// Updates the given <paramref name="formatter"/>'s set of <see cref="MediaTypeMapping"/> elements
        /// so that it associates the <paramref name="mediaType"/> with <see cref="HttpRequestMessage"/> whose <see cref="IHttpRouteData"/> contains a URL Parameter {ext}
        /// with the given <paramref name="uriPathExtension"/>.
        /// </summary>
        /// <param name="formatter">The <see cref="MediaTypeFormatter"/> to receive the new <see cref="UriPathExtensionMapping"/> item.</param>
        /// <param name="uriPathExtension">The string of the <see cref="Uri"/> path extension.</param>
        /// <param name="mediaType">The <see cref="MediaTypeHeaderValue"/> to associate with.</param>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", Justification = "There is no meaningful System.Uri representation for a path suffix such as '.xml'")]
        public static void AddUriPathExtensionMapping(
            this MediaTypeFormatter formatter,
            string uriPathExtension,
            MediaTypeHeaderValue mediaType)
        {
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }

            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
            formatter.MediaTypeMappings.Add(mapping);
        }

        /// <summary>
        /// Updates the given <paramref name="formatter"/>'s set of <see cref="MediaTypeMapping"/> elements
        /// so that it associates the <paramref name="mediaType"/> with <see cref="HttpRequestMessage"/> whose <see cref="IHttpRouteData"/> contains a URL Parameter {ext}
        /// with the given <paramref name="uriPathExtension"/>.
        /// </summary>
        /// <param name="formatter">The <see cref="MediaTypeFormatter"/> to receive the new <see cref="UriPathExtensionMapping"/> item.</param>
        /// <param name="uriPathExtension">The string of the <see cref="Uri"/> path extension.</param>
        /// <param name="mediaType">The string media type to associate with.</param>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", Justification = "There is no meaningful System.Uri representation for a path suffix such as '.xml'")]
        public static void AddUriPathExtensionMapping(this MediaTypeFormatter formatter, string uriPathExtension, string mediaType)
        {
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }

            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
            formatter.MediaTypeMappings.Add(mapping);
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/RouteCollectionRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Properties;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// A single route that is the composite of multiple "sub routes".  
    /// </summary>
    /// <remarks>
    /// Corresponds to the MVC implementation of attribute routing in System.Web.Mvc.Routing.RouteCollectionRoute.
    /// </remarks>
    internal class RouteCollectionRoute : IHttpRoute, IReadOnlyCollection<IHttpRoute>
    {
        // Key for accessing SubRoutes on a RouteData.
        // We expose this through the RouteData.Values instead of a derived class because 
        // RouteData can get wrapped in another type, but Values still gets persisted through the wrappers. 
        // Prefix with a \0 to protect against conflicts with user keys. 
        public const string SubRouteDataKey = "MS_SubRoutes";

        private IReadOnlyCollection<IHttpRoute> _subRoutes;

        private static readonly IDictionary<string, object> _empty = EmptyReadOnlyDictionary<string, object>.Value;
        
        public RouteCollectionRoute()
        {
        }

        // This will enumerate all controllers and action descriptors, which will run those 
        // Initialization hooks, which may try to initialize controller-specific config, which
        // may call back to the initialize hook. So guard against that reentrancy.
        private bool _beingInitialized;

        // deferred hook for initializing the sub routes. The composite route can be added during the middle of 
        // intializing, but then the actual sub routes can get populated after initialization has finished. 
        public void EnsureInitialized(Func<IReadOnlyCollection<IHttpRoute>> initializer)
        {
            if (_beingInitialized && _subRoutes == null)
            {
                // Avoid reentrant initialization
                return;
            }

            try
            {
                _beingInitialized = true;

                _subRoutes = initializer();
                Contract.Assert(_subRoutes != null);                
            }
            finally
            {
                _beingInitialized = false;
            }
        }

        private IReadOnlyCollection<IHttpRoute> SubRoutes
        {
            get
            {
                // Caller should have already explicitly called EnsureInitialize. 
                // Avoid lazy initilization from within the route table because the route table
                // is shared resource and init can happen 
                if (_subRoutes == null)
                {
                    string msg = Error.Format(SRResources.Object_NotYetInitialized);
                    throw new InvalidOperationException(msg);
                }

                return _subRoutes;
            }
        }

        public string RouteTemplate
        {
            get { return String.Empty; }
        }

        public IDictionary<string, object> Defaults
        {
            get { return _empty; }
        }

        public IDictionary<string, object> Constraints
        {
            get { return _empty; }
        }

        public IDictionary<string, object> DataTokens
        {
            get { return null; }
        }

        public HttpMessageHandler Handler
        {
            get
            {
                return null;
            }
        }
                
        // Returns null if no match. 
        // Else, returns a composite route data that encapsulates the possible routes this may match against. 
        public IHttpRouteData GetRouteData(string virtualPathRoot, HttpRequestMessage request)
        {
            List<IHttpRouteData> matches = new List<IHttpRouteData>();
            foreach (IHttpRoute route in SubRoutes)
            {
                IHttpRouteData match = route.GetRouteData(virtualPathRoot, request);
                if (match != null)
                {
                    matches.Add(match);
                }
            }
            if (matches.Count == 0)
            {
                return null;  // no matches
            }

            return new RouteCollectionRouteData(this, matches.ToArray());
        }

        public IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, IDictionary<string, object> values)
        {
            // Use LinkGenerationRoute stubs to get placeholders for all the sub routes. 
            return null;
        }

        public int Count
        {
            get { return SubRoutes.Count; }
        }

        public IEnumerator<IHttpRoute> GetEnumerator()
        {
            return SubRoutes.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return SubRoutes.GetEnumerator();
        }

        // Represents a union of multiple IHttpRouteDatas. 
        private class RouteCollectionRouteData : IHttpRouteData
        {
            public RouteCollectionRouteData(IHttpRoute parent, IHttpRouteData[] subRouteDatas)
            {
                Route = parent;

                // Each sub route may have different values. Callers need to enumerate the subroutes 
                // and individually query each. 
                // Find sub-routes via the SubRouteDataKey; don't expose as a property since the RouteData 
                // can be wrapped in an outer type that doesn't propagate properties. 
                Values = new HttpRouteValueDictionary() { { SubRouteDataKey, subRouteDatas } };
            }

            public IHttpRoute Route { get; private set; }

            public IDictionary<string, object> Values { get; private set; }
        }        
    }
}

================================================
FILE: src/System.Web.Http/Routing/RouteDataTokenKeys.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Provides keys for looking up route values and data tokens.
    /// </summary>
    internal static class RouteDataTokenKeys
    {
        // Used to provide the action descriptors to consider for attribute routing
        public const string Actions = "actions";

        // Used to indicate that a route is a controller-level attribute route.
        public const string Controller = "controller";

        // Used to allow customer-provided disambiguation between multiple matching attribute routes
        public const string Order = "order";

        // Used to allow URI constraint-based disambiguation between multiple matching attribute routes
        public const string Precedence = "precedence";
    }
}

================================================
FILE: src/System.Web.Http/Routing/RouteValueKeys.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Routing
{
    /// <summary>Provides keys for looking up route values.</summary>
    internal static class RouteValueKeys
    {
        // Used to provide the action and controller name
        public const string Action = "action";
        public const string Controller = "controller";
    }
}

================================================
FILE: src/System.Web.Http/Routing/RoutingContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Parameter class for URL matching in routing.
    /// </summary>
    internal class RoutingContext
    {
        private static readonly RoutingContext CachedInvalid = new RoutingContext() { IsValid = false };

        public static RoutingContext Invalid()
        {
            return CachedInvalid;
        }

        public static RoutingContext Valid(List<string> pathSegments)
        {
            return new RoutingContext()
            {
                PathSegments = pathSegments,
                IsValid = true,
            };
        }

        private RoutingContext()
        {
        }

        public bool IsValid
        {
            get;
            private set;
        }

        public List<string> PathSegments
        {
            get;
            private set;
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/StopRoutingHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Represents a handler that specifies routing should not handle requests for a route template. When a route provides this class as a handler, requests matching against the route will be ignored.
    /// </summary>
    public sealed class StopRoutingHandler : HttpMessageHandler
    {
        /// <summary>
        /// Like <see cref="T:System.Web.Routing.StopRoutingHandler"/>, the handler does nothing but throws a NotSupportedException. This method should never be called,
        /// and the NotSupportedException should never be thrown directly, because this handler will be replaced by responding a message saying that no route is matched.
        /// </summary>
        /// <param name="request">The HTTP request message to send.</param>
        /// <param name="cancellationToken">The notification that operations should be canceled.</param>
        /// <returns>Throws NotSupportedException.</returns>
        protected override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request, CancellationToken cancellationToken)
        {
            throw new NotSupportedException();
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/UriPathExtensionMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http.Headers;
using System.Web.Http.Routing;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// Class that provides <see cref="MediaTypeHeaderValue"/>'s from path extension appearing in <see cref="IHttpRouteData"/>.
    /// It uses the value of the {ext} URL parameter from <see cref="IHttpRouteData"/> for a match.
    /// </summary>
    /// <example>
    /// This sample shows how to use the UriPathExtensionMapping to map urls ending with ".json" to "application/json"
    /// <code>
    /// config.Routes.MapHttpRoute("Default", "{controller}");
    /// config.Routes.MapHttpRoute("DefaultWithExt", "{controller}.{ext}");
    /// config.Formatters.JsonFormatter.AddUriPathExtensionMapping("json", "application/json");
    /// </code>
    /// </example>
    public class UriPathExtensionMapping : MediaTypeMapping
    {
        public static readonly string UriPathExtensionKey = "ext";

        /// <summary>
        /// Initializes a new instance of the <see cref="UriPathExtensionMapping"/> class.
        /// </summary>
        /// <param name="uriPathExtension">The extension corresponding to <paramref name="mediaType"/>.
        /// This value should not include a dot or wildcards.</param>
        /// <param name="mediaType">The media type that will be returned if <paramref name="uriPathExtension"/> is matched.</param>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", Justification = "There is no meaningful System.Uri representation for a path suffix such as '.xml'")]
        public UriPathExtensionMapping(string uriPathExtension, string mediaType)
            : base(mediaType)
        {
            Initialize(uriPathExtension);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="UriPathExtensionMapping"/> class.
        /// </summary>
        /// <param name="uriPathExtension">The extension corresponding to <paramref name="mediaType"/>.
        /// This value should not include a dot or wildcards.</param>
        /// <param name="mediaType">The <see cref="MediaTypeHeaderValue"/> that will be returned if <paramref name="uriPathExtension"/> is matched.</param>
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", Justification = "There is no meaningful System.Uri representation for a path suffix such as '.xml'")]
        public UriPathExtensionMapping(string uriPathExtension, MediaTypeHeaderValue mediaType)
            : base(mediaType)
        {
            Initialize(uriPathExtension);
        }

        /// <summary>
        /// Gets the <see cref="Uri"/> path extension.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "There is no meaningful System.Uri representation for a path suffix such as '.xml'")]
        public string UriPathExtension { get; private set; }

        /// <summary>
        /// Returns a value indicating whether this <see cref="UriPathExtensionMapping"/>
        /// instance can provide a <see cref="MediaTypeHeaderValue"/> for the given <paramref name="request"/>.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/> to check.</param>
        /// <returns>If this <paramref name="request"/>'s route data contains a match for <see cref="UriPathExtension"/>
        /// it returns <c>1.0</c> otherwise <c>0.0</c>.</returns>
        public override double TryMatchMediaType(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            string extension = GetUriPathExtensionOrNull(request);
            return String.Equals(extension, UriPathExtension, StringComparison.OrdinalIgnoreCase) ? 1.0 : 0.0;
        }

        private static string GetUriPathExtensionOrNull(HttpRequestMessage request)
        {
            IHttpRouteData routeData = request.GetRouteData();

            if (routeData != null)
            {
                string extension;
                if (routeData.Values.TryGetValue(UriPathExtensionKey, out extension))
                {
                    return extension;
                }
            }

            return null;
        }

        private void Initialize(string uriPathExtension)
        {
            if (String.IsNullOrWhiteSpace(uriPathExtension))
            {
                throw new ArgumentNullException("uriPathExtension");
            }

            UriPathExtension = uriPathExtension.Trim().TrimStart('.');
        }
    }
}


================================================
FILE: src/System.Web.Http/Routing/UrlHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;

namespace System.Web.Http.Routing
{
    /// <summary>
    /// Represents a factory for creating URLs.
    /// </summary>
    public class UrlHelper
    {
        private HttpRequestMessage _request;

        /// <summary>
        /// Initializes a new instance of the <see cref="UrlHelper"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public UrlHelper()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="UrlHelper"/> class.
        /// </summary>
        /// <param name="request">The HTTP request message containing the context under which the URLs are generated.</param>
        public UrlHelper(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            Request = request;
        }

        /// <summary>
        /// Gets the <see cref="HttpRequestMessage"/> of the current <see cref="UrlHelper"/>.
        /// The setter is not intended to be used other than for unit testing purpose. 
        /// </summary>
        public HttpRequestMessage Request
        {
            get { return _request; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _request = value;
            }
        }

        /// <summary>
        /// Creates an absolute URL using the specified path.
        /// </summary>
        /// <param name="path">The URL path, which may be a relative URL, a rooted URL, or a virtual path.</param>
        /// <returns>The generated URL.</returns>
        [SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "It is safe to pass string here")]
        public virtual string Content(string path)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw Error.ArgumentNullOrEmpty("path");
            }

            if (Request == null)
            {
                throw Error.InvalidOperation(SRResources.RequestIsNull, "UrlHelper");
            }

            if (path.StartsWith("~/", StringComparison.Ordinal))
            {
                // This is a virtual path, we need to combine it with the virtual path root
                string virtualPathRoot;
                HttpRequestContext requestContext = Request.GetRequestContext();

                if (requestContext != null)
                {
                    virtualPathRoot = requestContext.VirtualPathRoot;
                }
                else
                {
                    HttpConfiguration configuration = Request.GetConfiguration();
                    if (configuration == null)
                    {
                        throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoConfiguration);
                    }

                    virtualPathRoot = configuration.VirtualPathRoot;
                }

                if (virtualPathRoot == null)
                {
                    virtualPathRoot = "/";
                }

                if (!virtualPathRoot.StartsWith("/", StringComparison.Ordinal))
                {
                    virtualPathRoot = "/" + virtualPathRoot;
                }
                if (!virtualPathRoot.EndsWith("/", StringComparison.Ordinal))
                {
                    virtualPathRoot += "/";
                }

                return new Uri(Request.RequestUri, virtualPathRoot + path.Substring("~/".Length)).AbsoluteUri;
            }
            else
            {
                return new Uri(Request.RequestUri, path).AbsoluteUri;
            }
        }

        /// <summary>
        /// Creates a relative URL using the specified route and route data.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <returns>The generated URL.</returns>
        public virtual string Route(string routeName, object routeValues)
        {
            return Route(routeName, new HttpRouteValueDictionary(routeValues));
        }

        /// <summary>
        /// Creates a relative URL using the specified route and route data.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <returns>The generated URL.</returns>
        public virtual string Route(string routeName, IDictionary<string, object> routeValues)
        {
            return GetVirtualPath(Request, routeName, routeValues);
        }

        /// <summary>
        /// Creates an absolute URL using the given route and route data.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <returns>The generated URL.</returns>
        [SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "It is safe to pass string here")]
        public virtual string Link(string routeName, object routeValues)
        {
            return Link(routeName, new HttpRouteValueDictionary(routeValues));
        }

        /// <summary>
        /// Creates an absolute URL using the specified route and route data.
        /// </summary>
        /// <param name="routeName">The name of the route to use for generating the URL.</param>
        /// <param name="routeValues">The route data to use for generating the URL.</param>
        /// <returns>The generated URL.</returns>
        [SuppressMessage("Microsoft.Usage", "CA2234:PassSystemUriObjectsInsteadOfStrings", Justification = "It is safe to pass string here")]
        public virtual string Link(string routeName, IDictionary<string, object> routeValues)
        {
            string link = Route(routeName, routeValues);
            if (!String.IsNullOrEmpty(link))
            {
                link = new Uri(Request.RequestUri, link).AbsoluteUri;
            }

            return link;
        }

        private static string GetVirtualPath(HttpRequestMessage request, string routeName, IDictionary<string, object> routeValues)
        {
            if (routeValues == null)
            {
                // If no route values were passed in at all we have to create a new dictionary
                // so that we can add the extra "httproute" key.
                routeValues = new HttpRouteValueDictionary();
                routeValues.Add(HttpRoute.HttpRouteKey, true);
            }
            else
            {
                // Copy the dictionary so that we can guarantee that routeValues uses an OrdinalIgnoreCase comparer
                // and to add the extra "httproute" key used by all Web API routes to disambiguate them from other MVC routes.
                routeValues = new HttpRouteValueDictionary(routeValues);
                if (!routeValues.ContainsKey(HttpRoute.HttpRouteKey))
                {
                    routeValues.Add(HttpRoute.HttpRouteKey, true);
                }
            }

            HttpConfiguration configuration = request.GetConfiguration();
            if (configuration == null)
            {
                throw Error.InvalidOperation(SRResources.HttpRequestMessageExtensions_NoConfiguration);
            }

            IHttpVirtualPathData vpd = configuration.Routes.GetVirtualPath(
                request: request,
                name: routeName,
                values: routeValues);
            if (vpd == null)
            {
                return null;
            }
            return vpd.VirtualPath;
        }
    }
}


================================================
FILE: src/System.Web.Http/Services/ControllerServices.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.Http.Controllers
{
    /// <summary>
    /// Represents a container for services that can be specific to a controller. 
    /// This shadows the services from its parent <see cref="ServicesContainer"/>. A controller can either set a service here, or fall through 
    /// to the more global set of services. 
    /// </summary>
    public class ControllerServices : ServicesContainer
    {
        // This lists specific services that have been over ridden for the controller.
        // Anything missing means just fall through and ask the _parent. 
        // This dictionary is only written at initialization time, and then read-only during steady state.
        // So it can be safely read from multiple threads after initialization.
        private Dictionary<Type, object> _overrideSingle;
        private Dictionary<Type, List<object>> _overrideMulti;
        private readonly ServicesContainer _parent;

        public ControllerServices(ServicesContainer parent)
        {
            if (parent == null)
            {
                throw Error.ArgumentNull("parent");
            }
            _parent = parent;
        }

        public override bool IsSingleService(Type serviceType)
        {
            return _parent.IsSingleService(serviceType);
        }

        public override object GetService(Type serviceType)
        {
            if (_overrideSingle != null)
            {
                object item;
                if (_overrideSingle.TryGetValue(serviceType, out item))
                {
                    return item;
                }
            }
            return _parent.GetService(serviceType);
        }

        public override IEnumerable<object> GetServices(Type serviceType)
        {
            if (_overrideMulti != null)
            {
                List<object> list;
                if (_overrideMulti.TryGetValue(serviceType, out list))
                {
                    return list;
                }
            }
            return _parent.GetServices(serviceType);
        }

        /// <inheritdoc/>
        protected override void ReplaceSingle(Type serviceType, object service)
        {
            if (_overrideSingle == null)
            {
                _overrideSingle = new Dictionary<Type, object>();
            }
            _overrideSingle[serviceType] = service;
        }

        /// <inheritdoc/>
        protected override void ClearSingle(Type serviceType)
        {
            if (_overrideSingle == null)
            {
                return;
            }
            _overrideSingle.Remove(serviceType);
        }

        // This is called to request a mutation to services.
        [SuppressMessage("Microsoft.Design", "CA1002:DoNotExposeGenericLists", Justification = "want a mutable list")]
        protected override List<object> GetServiceInstances(Type serviceType)
        {
            if (_overrideMulti == null)
            {
                _overrideMulti = new Dictionary<Type, List<object>>();
            }
            List<object> list;
            if (!_overrideMulti.TryGetValue(serviceType, out list))
            {
                // Copy parents list. 
                list = new List<object>(_parent.GetServices(serviceType));

                // Copy into per-controller. If they're asking for the list, the expectation is that it's going to get mutated.
                _overrideMulti[serviceType] = list;
            }
            return list;
        }
    }
}

================================================
FILE: src/System.Web.Http/Services/Decorator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Services
{
    /// <summary>
    /// Provides a method for retrieving the innermost object of an object that might be wrapped by an <see cref="IDecorator{T}"/>.
    /// </summary>
    public static class Decorator
    {
        /// <summary>
        /// Gets the innermost object which does not implement <see cref="IDecorator{T}"/>.
        /// </summary>
        /// <param name="outer">Object which needs to be unwrapped.</param>
        /// <returns>The innermost object of Type T which does not implement <see cref="IDecorator{T}"/>.</returns>
        public static T GetInner<T>(T outer)
        {
            T inner = outer;
            IDecorator<T> decorator = inner as IDecorator<T>;
            while (decorator != null)
            {
                inner = decorator.Inner;
                IDecorator<T> innerDecorator = inner as IDecorator<T>;
                if (decorator == innerDecorator)
                {
                    break;
                }
                decorator = innerDecorator;
            }

            return inner;
        }
    }
}


================================================
FILE: src/System.Web.Http/Services/DefaultServices.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Filters;
using System.Web.Http.Hosting;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Properties;
using System.Web.Http.Tracing;
using System.Web.Http.Validation;
using System.Web.Http.Validation.Providers;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;

namespace System.Web.Http.Services
{
    /// <summary>
    ///     <para>
    ///         Represents a container for service instances used by the <see cref="HttpConfiguration"/>. Note that
    ///         this container only supports known types, and methods to get or set arbitrary service types will
    ///         throw <see cref="ArgumentException"/> when called. For creation of arbitrary types, please use
    ///         <see cref="IDependencyResolver"/> instead. The supported types for this container are:
    ///     </para>
    ///     <list type="bullet">
    ///         <item><see cref="IActionValueBinder"/></item>
    ///         <item><see cref="IApiExplorer"/></item>
    ///         <item><see cref="IAssembliesResolver"/></item>
    ///         <item><see cref="IBodyModelValidator"/></item>
    ///         <item><see cref="IContentNegotiator"/></item>
    ///         <item><see cref="IDocumentationProvider"/></item>
    ///         <item><see cref="IExceptionHandler"/></item>
    ///         <item><see cref="IExceptionLogger"/></item>
    ///         <item><see cref="IFilterProvider"/></item>
    ///         <item><see cref="IHostBufferPolicySelector"/></item>
    ///         <item><see cref="IHttpActionInvoker"/></item>
    ///         <item><see cref="IHttpActionSelector"/></item>
    ///         <item><see cref="IHttpControllerActivator"/></item>
    ///         <item><see cref="IHttpControllerSelector"/></item>
    ///         <item><see cref="IHttpControllerTypeResolver"/></item>
    ///         <item><see cref="ITraceManager"/></item>
    ///         <item><see cref="ITraceWriter"/></item>
    ///         <item><see cref="ModelBinderProvider"/></item>
    ///         <item><see cref="ModelMetadataProvider"/></item>
    ///         <item><see cref="ModelValidatorProvider"/></item>
    ///         <item><see cref="ValueProviderFactory"/></item>
    ///     </list>
    ///     <para>
    ///         Passing any type which is not on this to any method on this interface will cause
    ///         an <see cref="ArgumentException"/> to be thrown.
    ///     </para>
    /// </summary>
    [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Although this class is not sealed, end users cannot set instances of it so in practice it is sealed.")]
    public class DefaultServices : ServicesContainer
    {
        private ConcurrentDictionary<Type, object[]> _cacheMulti = new ConcurrentDictionary<Type, object[]>();
        private ConcurrentDictionary<Type, object> _cacheSingle = new ConcurrentDictionary<Type, object>();
        private readonly HttpConfiguration _configuration;

        // Mutation operations delegate (throw if applied to wrong set)
        private readonly Dictionary<Type, object> _defaultServicesSingle = new Dictionary<Type, object>();

        private readonly Dictionary<Type, List<object>> _defaultServicesMulti = new Dictionary<Type, List<object>>();
        private IDependencyResolver _lastKnownDependencyResolver;
        private readonly HashSet<Type> _serviceTypesSingle;
        private readonly HashSet<Type> _serviceTypesMulti;

        /// <summary>
        /// This constructor is for unit testing purposes only.
        /// </summary>
        protected DefaultServices()
        {
        }

        private void SetSingle<T>(T instance) where T : class
        {
            _defaultServicesSingle[typeof(T)] = instance;
        }
        private void SetMultiple<T>(params T[] instances) where T : class
        {
            var x = (IEnumerable<object>)instances;
            _defaultServicesMulti[typeof(T)] = new List<object>(x);
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Class needs references to large number of types.")]
        public DefaultServices(HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            _configuration = configuration;

            // Initialize the dictionary with all known service types, even if the list for that service type is
            // empty, because we will throw if the developer tries to read or write unsupported types.

            SetSingle<IActionValueBinder>(new DefaultActionValueBinder());
            SetSingle<IApiExplorer>(new ApiExplorer(configuration));
            SetSingle<IAssembliesResolver>(new DefaultAssembliesResolver());
            SetSingle<IBodyModelValidator>(new DefaultBodyModelValidator());
            SetSingle<IContentNegotiator>(new DefaultContentNegotiator());
            SetSingle<IDocumentationProvider>(null); // Missing

            SetMultiple<IFilterProvider>(new ConfigurationFilterProvider(),
                                      new ActionDescriptorFilterProvider());

            SetSingle<IHostBufferPolicySelector>(null);
            SetSingle<IHttpActionInvoker>(new ApiControllerActionInvoker());
            SetSingle<IHttpActionSelector>(new ApiControllerActionSelector());
            SetSingle<IHttpControllerActivator>(new DefaultHttpControllerActivator());
            SetSingle<IHttpControllerSelector>(new DefaultHttpControllerSelector(configuration));
            SetSingle<IHttpControllerTypeResolver>(new DefaultHttpControllerTypeResolver());
            SetSingle<ITraceManager>(new TraceManager());
            SetSingle<ITraceWriter>(null);

            // This is a priority list. So put the most common binders at the top. 
            SetMultiple<ModelBinderProvider>(new TypeConverterModelBinderProvider(),
                                        new TypeMatchModelBinderProvider(),
                                        new KeyValuePairModelBinderProvider(),
                                        new ComplexModelDtoModelBinderProvider(),
                                        new ArrayModelBinderProvider(),
                                        new DictionaryModelBinderProvider(),
                                        new CollectionModelBinderProvider(),
                                        new MutableObjectModelBinderProvider());
            SetSingle<ModelMetadataProvider>(new DataAnnotationsModelMetadataProvider());
            SetMultiple<ModelValidatorProvider>(new DataAnnotationsModelValidatorProvider(),
                                        new DataMemberModelValidatorProvider());

            // This is an ordered list,so put the most common providers at the top. 
            SetMultiple<ValueProviderFactory>(new QueryStringValueProviderFactory(),
                                           new RouteDataValueProviderFactory());

            ModelValidatorCache validatorCache = new ModelValidatorCache(new Lazy<IEnumerable<ModelValidatorProvider>>(() => this.GetModelValidatorProviders()));
            SetSingle<IModelValidatorCache>(validatorCache);

            SetSingle<IExceptionHandler>(new DefaultExceptionHandler());
            SetMultiple<IExceptionLogger>();

            _serviceTypesSingle = new HashSet<Type>(_defaultServicesSingle.Keys);
            _serviceTypesMulti = new HashSet<Type>(_defaultServicesMulti.Keys);

            // Reset the caches and the known dependency scope
            ResetCache();
        }

        public override bool IsSingleService(Type serviceType)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }
            return _serviceTypesSingle.Contains(serviceType);
        }

        /// <summary>
        /// Try to get a service of the given type.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <returns>The first instance of the service, or null if the service is not found.</returns>
        public override object GetService(Type serviceType)
        {
            // Cached read case is very performance-sensitive
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }

            // Invalidate the cache if the dependency scope has switched
            if (_lastKnownDependencyResolver != _configuration.DependencyResolver)
            {
                ResetCache();
            }

            object result;

            if (_cacheSingle.TryGetValue(serviceType, out result))
            {
                return result;
            }

            // Check input after initial read attempt for performance.
            if (!_serviceTypesSingle.Contains(serviceType))
            {
                throw Error.Argument("serviceType", SRResources.DefaultServices_InvalidServiceType, serviceType.Name);
            }

            // Get the service from DI. If we're coming up hot, this might
            // mean we end up creating the service more than once.
            object dependencyService = _lastKnownDependencyResolver.GetService(serviceType);

            if (!_cacheSingle.TryGetValue(serviceType, out result))
            {
                result = dependencyService ?? _defaultServicesSingle[serviceType];
                _cacheSingle.TryAdd(serviceType, result);
            }

            return result;
        }

        /// <summary>
        /// Try to get a list of services of the given type.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <returns>The list of service instances of the given type. Returns an empty enumeration if the
        /// service is not found. </returns>
        public override IEnumerable<object> GetServices(Type serviceType)
        {
            // Cached read case is very performance-sensitive
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }

            // Invalidate the cache if the dependency scope has switched
            if (_lastKnownDependencyResolver != _configuration.DependencyResolver)
            {
                ResetCache();
            }

            object[] result;

            if (_cacheMulti.TryGetValue(serviceType, out result))
            {
                return result;
            }

            // Check input after initial read attempt for performance.
            if (!_serviceTypesMulti.Contains(serviceType))
            {
                throw Error.Argument("serviceType", SRResources.DefaultServices_InvalidServiceType, serviceType.Name);
            }

            // Get the service from DI. If we're coming up hot, this might
            // mean we end up creating the service more than once.
            IEnumerable<object> dependencyServices = _lastKnownDependencyResolver.GetServices(serviceType);

            if (!_cacheMulti.TryGetValue(serviceType, out result))
            {
                result = dependencyServices.Where(s => s != null)
                                            .Concat(_defaultServicesMulti[serviceType])
                                            .ToArray();
                _cacheMulti.TryAdd(serviceType, result);
            }

            return result;
        }

        // Returns the List<object> for the given service type. Also validates serviceType is in the known service type list.
        [SuppressMessage("Microsoft.Design", "CA1002:DoNotExposeGenericLists", Justification = "inherits from base")]
        protected override List<object> GetServiceInstances(Type serviceType)
        {
            Contract.Assert(serviceType != null);

            List<object> result;
            if (!_defaultServicesMulti.TryGetValue(serviceType, out result))
            {
                throw Error.Argument("serviceType", SRResources.DefaultServices_InvalidServiceType, serviceType.Name);
            }

            return result;
        }

        protected override void ClearSingle(Type serviceType)
        {
            _defaultServicesSingle[serviceType] = null;
        }

        protected override void ReplaceSingle(Type serviceType, object service)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }
            _defaultServicesSingle[serviceType] = service;
        }

        // Removes the cached values for all service types. Called when the dependency scope
        // has changed since the last time we made a request.
        private void ResetCache()
        {
            _cacheSingle = new ConcurrentDictionary<Type, object>();
            _cacheMulti = new ConcurrentDictionary<Type, object[]>();
            _lastKnownDependencyResolver = _configuration.DependencyResolver;
        }

        // Removes the cached values for a single service type. Called whenever the user manipulates
        // the local service list for a given service type.
        protected override void ResetCache(Type serviceType)
        {
            object single;
            _cacheSingle.TryRemove(serviceType, out single);
            object[] multiple;
            _cacheMulti.TryRemove(serviceType, out multiple);
        }
    }
}


================================================
FILE: src/System.Web.Http/Services/IDecorator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Services
{
    /// <summary>
    /// Defines a decorator that exposes the inner decorated object.
    /// </summary>
    public interface IDecorator<out T>
    {
        /// <summary>
        /// Gets the inner object.
        /// </summary>
        T Inner { get; }
    }
}


================================================
FILE: src/System.Web.Http/Services/ServicesContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Properties;

namespace System.Web.Http.Controllers
{
    // This is common to both per-controller and global config. 
    // It facilitates sharing all the mutation operations between them.
    public abstract class ServicesContainer : IDisposable
    {
        // Wrapped/composite versions of the exception service interfaces designed for consumption in catch blocks.
        // See ExceptionServices.GetLogger/Handler for how these internal services are used.
        // These instances must be stored separately and not provided via GetService because existing stores for 
        // GetService do not provide concurrency control and these two wrappers are potentially initialized late.
        internal readonly Lazy<IExceptionLogger> ExceptionServicesLogger;
        internal readonly Lazy<IExceptionHandler> ExceptionServicesHandler;

        /// <summary>Initializes a new instance of the <see cref="ServicesContainer"/> class.</summary>
        protected ServicesContainer()
        {
            ExceptionServicesLogger = new Lazy<IExceptionLogger>(CreateExceptionServicesLogger);
            ExceptionServicesHandler = new Lazy<IExceptionHandler>(CreateExceptionServicesHandler);
        }

        public abstract object GetService(Type serviceType);
        public abstract IEnumerable<object> GetServices(Type serviceType);

        // critical method for mutation operations (Add,Insert,Clear,Replace, etc)
        // This is used for multi-services. 
        // There are other abstract methods to mutate the single services.
        [SuppressMessage("Microsoft.Design", "CA1002:DoNotExposeGenericLists", Justification = "expose for mutation")]
        protected abstract List<object> GetServiceInstances(Type serviceType);

        protected virtual void ResetCache(Type serviceType)
        {
        }

        /// <summary>
        /// Determine whether the service type should be fetched with GetService or GetServices. 
        /// </summary>
        /// <param name="serviceType">type of service to query</param>
        /// <returns>true iff the service is singular. </returns>
        public abstract bool IsSingleService(Type serviceType);

        /// <summary>
        /// Adds a service to the end of services list for the given service type. 
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="service">The service instance.</param>
        public void Add(Type serviceType, object service)
        {
            Insert(serviceType, Int32.MaxValue, service);
        }

        /// <summary>
        /// Adds the services of the specified collection to the end of the services list for
        /// the given service type.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="services">The services to add.</param>
        public void AddRange(Type serviceType, IEnumerable<object> services)
        {
            InsertRange(serviceType, Int32.MaxValue, services);
        }

        /// <summary>
        /// Removes all the service instances of the given service type. 
        /// </summary>
        /// <param name="serviceType">The service type to clear from the services list.</param>
        public virtual void Clear(Type serviceType)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }

            if (IsSingleService(serviceType))
            {
                ClearSingle(serviceType);
            }
            else
            {
                ClearMultiple(serviceType);
            }
            ResetCache(serviceType);
        }

        protected abstract void ClearSingle(Type serviceType);

        protected virtual void ClearMultiple(Type serviceType)
        {
            List<object> instances = GetServiceInstances(serviceType);
            instances.Clear();
        }

        /// <summary>
        /// Searches for a service that matches the conditions defined by the specified
        /// predicate, and returns the zero-based index of the first occurrence.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="match">The delegate that defines the conditions of the element
        /// to search for. </param>
        /// <returns>The zero-based index of the first occurrence, if found; otherwise, -1.</returns>
        public int FindIndex(Type serviceType, Predicate<object> match)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }
            if (match == null)
            {
                throw Error.ArgumentNull("match");
            }

            List<object> instances = GetServiceInstances(serviceType);
            return instances.FindIndex(match);
        }

        /// <summary>
        /// Inserts a service into the collection at the specified index.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="index">The zero-based index at which the service should be inserted.
        /// If <see cref="Int32.MaxValue"/> is passed, ensures the element is added to the end.</param>
        /// <param name="service">The service to insert.</param>
        public void Insert(Type serviceType, int index, object service)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }
            if (service == null)
            {
                throw Error.ArgumentNull("service");
            }
            if (!serviceType.IsAssignableFrom(service.GetType()))
            {
                throw Error.Argument("service", SRResources.Common_TypeMustDriveFromType, service.GetType().Name, serviceType.Name);
            }

            List<object> instances = GetServiceInstances(serviceType);
            if (index == Int32.MaxValue)
            {
                index = instances.Count;
            }

            instances.Insert(index, service);

            ResetCache(serviceType);
        }

        /// <summary>
        /// Inserts the elements of the collection into the service list at the specified index.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="index">The zero-based index at which the new elements should be inserted.
        /// If <see cref="Int32.MaxValue"/> is passed, ensures the elements are added to the end.</param>
        /// <param name="services">The collection of services to insert.</param>
        public void InsertRange(Type serviceType, int index, IEnumerable<object> services)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }
            if (services == null)
            {
                throw Error.ArgumentNull("services");
            }

            object[] filteredServices = services.Where(svc => svc != null).ToArray();
            object incorrectlyTypedService = filteredServices.FirstOrDefault(svc => !serviceType.IsAssignableFrom(svc.GetType()));
            if (incorrectlyTypedService != null)
            {
                throw Error.Argument("services", SRResources.Common_TypeMustDriveFromType, incorrectlyTypedService.GetType().Name, serviceType.Name);
            }

            List<object> instances = GetServiceInstances(serviceType);
            if (index == Int32.MaxValue)
            {
                index = instances.Count;
            }

            instances.InsertRange(index, filteredServices);

            ResetCache(serviceType);
        }

        /// <summary>
        /// Removes the first occurrence of the given service from the service list for the given service type.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="service">The service instance to remove.</param>
        /// <returns> <c>true</c> if the item is successfully removed; otherwise, <c>false</c>.</returns>
        public bool Remove(Type serviceType, object service)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }
            if (service == null)
            {
                throw Error.ArgumentNull("service");
            }

            List<object> instances = GetServiceInstances(serviceType);
            bool result = instances.Remove(service);

            ResetCache(serviceType);

            return result;
        }

        /// <summary>
        /// Removes all the elements that match the conditions defined by the specified predicate.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="match">The delegate that defines the conditions of the elements to remove.</param>
        /// <returns>The number of elements removed from the list.</returns>
        public int RemoveAll(Type serviceType, Predicate<object> match)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }
            if (match == null)
            {
                throw Error.ArgumentNull("match");
            }

            List<object> instances = GetServiceInstances(serviceType);
            int result = instances.RemoveAll(match);

            ResetCache(serviceType);

            return result;
        }

        /// <summary>
        /// Removes the service at the specified index.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="index">The zero-based index of the service to remove.</param>
        public void RemoveAt(Type serviceType, int index)
        {
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }

            List<object> instances = GetServiceInstances(serviceType);
            instances.RemoveAt(index);

            ResetCache(serviceType);
        }

        /// <summary>
        /// Replaces all existing services for the given service type with the given
        /// service instance. This works for both singular and plural services. 
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="service">The service instance.</param>
        /// <inheritdoc/>        
        public void Replace(Type serviceType, object service)
        {
            // Check this early, so we don't call RemoveAll before Insert would catch the null service.
            if (serviceType == null)
            {
                throw Error.ArgumentNull("serviceType");
            }

            if ((service != null) && (!serviceType.IsAssignableFrom(service.GetType())))
            {
                throw Error.Argument("service", SRResources.Common_TypeMustDriveFromType, service.GetType().Name, serviceType.Name);
            }

            if (IsSingleService(serviceType))
            {
                ReplaceSingle(serviceType, service);
            }
            else
            {
                ReplaceMultiple(serviceType, service);
            }
            ResetCache(serviceType);
        }

        protected abstract void ReplaceSingle(Type serviceType, object service);

        protected virtual void ReplaceMultiple(Type serviceType, object service)
        {
            RemoveAll(serviceType, _ => true);
            Insert(serviceType, 0, service);
        }

        /// <summary>
        /// Replaces all existing services for the given service type with the given
        /// service instances.
        /// </summary>
        /// <param name="serviceType">The service type.</param>
        /// <param name="services">The service instances.</param>
        public void ReplaceRange(Type serviceType, IEnumerable<object> services)
        {
            // Check this early, so we don't call RemoveAll before InsertRange would catch the null services.
            if (services == null)
            {
                throw Error.ArgumentNull("services");
            }

            RemoveAll(serviceType, _ => true);
            InsertRange(serviceType, 0, services);
        }

        /// <inheritdoc/>
        [SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Although this class is not sealed, end users cannot set instances of it so in practice it is sealed.")]
        [SuppressMessage("Microsoft.Usage", "CA1816:CallGCSuppressFinalizeCorrectly", Justification = "Although this class is not sealed, end users cannot set instances of it so in practice it is sealed.")]
        public virtual void Dispose()
        {
        }

        private IExceptionLogger CreateExceptionServicesLogger()
        {
            return ExceptionServices.CreateLogger(this);
        }

        private IExceptionHandler CreateExceptionServicesHandler()
        {
            return ExceptionServices.CreateHandler(this);
        }
    }
}

================================================
FILE: src/System.Web.Http/ServicesExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Filters;
using System.Web.Http.Hosting;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;
using System.Web.Http.Tracing;
using System.Web.Http.Validation;
using System.Web.Http.ValueProviders;

namespace System.Web.Http
{
    /// <summary>
    /// This provides a centralized list of type-safe accessors describing where and how we get services.
    /// This also provides a single entry point for each service request. That makes it easy
    /// to see which parts of the code use it, and provides a single place to comment usage.
    /// Accessors encapsulate usage like:
    /// <list type="bullet">
    /// <item>Type-safe using {T} instead of unsafe <see cref="System.Type"/>.</item>
    /// <item>which type do we key off? This is interesting with type hierarchies.</item>
    /// <item>do we ask for singular or plural?</item>
    /// <item>is it optional or mandatory?</item>
    /// <item>what are the ordering semantics</item>
    /// </list>
    /// Expected that any <see cref="IEnumerable{T}"/> we return is non-null, although possibly empty.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class ServicesExtensions
    {
        public static IEnumerable<ModelBinderProvider> GetModelBinderProviders(this ServicesContainer services)
        {
            return services.GetServices<ModelBinderProvider>();
        }

        public static ModelMetadataProvider GetModelMetadataProvider(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<ModelMetadataProvider>();
        }

        public static IEnumerable<ModelValidatorProvider> GetModelValidatorProviders(this ServicesContainer services)
        {
            return services.GetServices<ModelValidatorProvider>();
        }

        internal static IModelValidatorCache GetModelValidatorCache(this ServicesContainer services)
        {
            return services.GetService<IModelValidatorCache>();
        }

        public static IContentNegotiator GetContentNegotiator(this ServicesContainer services)
        {
            return services.GetService<IContentNegotiator>();
        }

        /// <summary>
        /// Controller activator is used to instantiate an <see cref="IHttpController"/>.
        /// </summary>
        /// <returns>
        /// An <see cref="IHttpControllerActivator"/> instance or null if none are registered.
        /// </returns>
        public static IHttpControllerActivator GetHttpControllerActivator(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<IHttpControllerActivator>();
        }

        public static IHttpActionSelector GetActionSelector(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<IHttpActionSelector>();
        }

        public static IHttpActionInvoker GetActionInvoker(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<IHttpActionInvoker>();
        }

        public static IActionValueBinder GetActionValueBinder(this ServicesContainer services)
        {
            return services.GetService<IActionValueBinder>();
        }

        /// <summary>
        /// Get ValueProviderFactories. The order of returned providers is the priority order that we search the factories.
        /// </summary>
        public static IEnumerable<ValueProviderFactory> GetValueProviderFactories(this ServicesContainer services)
        {
            return services.GetServices<ValueProviderFactory>();
        }

        public static IBodyModelValidator GetBodyModelValidator(this ServicesContainer services)
        {
            return services.GetService<IBodyModelValidator>();
        }

        public static IHostBufferPolicySelector GetHostBufferPolicySelector(this ServicesContainer services)
        {
            return services.GetService<IHostBufferPolicySelector>();
        }

        /// <summary>
        /// Get a controller selector, which selects an <see cref="HttpControllerDescriptor"/> given an <see cref="HttpRequestMessage"/>.
        /// </summary>
        public static IHttpControllerSelector GetHttpControllerSelector(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<IHttpControllerSelector>();
        }

        public static IAssembliesResolver GetAssembliesResolver(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<IAssembliesResolver>();
        }

        public static IHttpControllerTypeResolver GetHttpControllerTypeResolver(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<IHttpControllerTypeResolver>();
        }

        public static IApiExplorer GetApiExplorer(this ServicesContainer services)
        {
            return services.GetServiceOrThrow<IApiExplorer>();
        }

        public static IDocumentationProvider GetDocumentationProvider(this ServicesContainer services)
        {
            return services.GetService<IDocumentationProvider>();
        }

        /// <summary>Returns the registered unhandled exception handler, if any.</summary>
        /// <param name="services">The services container.</param>
        /// <returns>
        /// The registered unhandled exception hander, if present; otherwise, <see langword="null"/>.
        /// </returns>
        public static IExceptionHandler GetExceptionHandler(this ServicesContainer services)
        {
            return services.GetService<IExceptionHandler>();
        }

        /// <summary>Returns the collection of registered unhandled exception loggers.</summary>
        /// <param name="services">The services container.</param>
        /// <returns>The collection of registered unhandled exception loggers.</returns>
        public static IEnumerable<IExceptionLogger> GetExceptionLoggers(this ServicesContainer services)
        {
            return services.GetServices<IExceptionLogger>();
        }

        public static IEnumerable<IFilterProvider> GetFilterProviders(this ServicesContainer services)
        {
            return services.GetServices<IFilterProvider>();
        }

        public static ITraceManager GetTraceManager(this ServicesContainer services)
        {
            return services.GetService<ITraceManager>();
        }

        public static ITraceWriter GetTraceWriter(this ServicesContainer services)
        {
            return services.GetService<ITraceWriter>();
        }

        internal static IEnumerable<TService> GetServices<TService>(this ServicesContainer services)
        {
            if (services == null)
            {
                throw Error.ArgumentNull("services");
            }

            return services.GetServices(typeof(TService)).Cast<TService>();
        }

        // Runtime code shouldn't call GetService() directly. Instead, have a wrapper (like the ones above)
        // and call through the wrapper.
        private static TService GetService<TService>(this ServicesContainer services)
        {
            if (services == null)
            {
                throw Error.ArgumentNull("services");
            }

            return (TService)services.GetService(typeof(TService));
        }

        private static T GetServiceOrThrow<T>(this ServicesContainer services)
        {
            T result = services.GetService<T>();
            if (result == null)
            {
                throw Error.InvalidOperation(SRResources.DependencyResolverNoService, typeof(T).FullName);
            }

            return result;
        }
    }
}


================================================
FILE: src/System.Web.Http/SingleResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Runtime.CompilerServices;

namespace System.Web.Http
{
    /// <summary>
    /// Represents an <see cref="IQueryable"/> containing zero or one entities. Use together with an
    /// <c>[EnableQuery]</c> from the System.Web.Http.OData or System.Web.OData namespace.
    /// </summary>
    [TypeForwardedFrom("System.Web.Http.OData, Version=5.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public abstract class SingleResult
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SingleResult"/> class.
        /// </summary>
        /// <param name="queryable">The <see cref="IQueryable"/> containing zero or one entities.</param>
        protected SingleResult(IQueryable queryable)
        {
            if (queryable == null)
            {
                throw Error.ArgumentNull("queryable");
            }

            Queryable = queryable;
        }

        /// <summary>
        /// The <see cref="IQueryable"/> containing zero or one entities.
        /// </summary>
        public IQueryable Queryable { get; private set; }

        /// <summary>
        /// Creates a <see cref="SingleResult{T}"/> from an <see cref="IQueryable{T}"/>. A helper method to instantiate
        /// a <see cref="SingleResult{T}"/> object without having to explicitly specify the type
        /// <typeparamref name="T"/>.
        /// </summary>
        /// <typeparam name="T">The type of the data in the data source.</typeparam>
        /// <param name="queryable">The <see cref="IQueryable{T}"/> containing zero or one entities.</param>
        /// <returns>The created <see cref="SingleResult{T}"/>.</returns>
        public static SingleResult<T> Create<T>(IQueryable<T> queryable)
        {
            return new SingleResult<T>(queryable);
        }
    }
}


================================================
FILE: src/System.Web.Http/SingleResultOfT.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Runtime.CompilerServices;

namespace System.Web.Http
{
    /// <summary>
    /// Represents an <see cref="IQueryable{T}"/> containing zero or one entities. Use together with an
    /// <c>[EnableQuery]</c> from the System.Web.Http.OData or System.Web.OData namespace.
    /// </summary>
    /// <typeparam name="T">The type of the data in the data source.</typeparam>
    [TypeForwardedFrom("System.Web.Http.OData, Version=5.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public sealed class SingleResult<T> : SingleResult
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="SingleResult{T}"/> class.
        /// </summary>
        /// <param name="queryable">The <see cref="IQueryable{T}"/> containing zero or one entities.</param>
        public SingleResult(IQueryable<T> queryable)
            : base(queryable)
        {
        }

        /// <summary>
        /// The <see cref="IQueryable{T}"/> containing zero or one entities.
        /// </summary>
        public new IQueryable<T> Queryable
        {
            get
            {
                return base.Queryable as IQueryable<T>;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/System.Web.Http.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http</RootNamespace>
    <AssemblyName>System.Web.Http</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC;ASPNETWEBAPI</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\Common\CollectionExtensions.cs">
      <Link>Common\CollectionExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\DictionaryExtensions.cs">
      <Link>Common\DictionaryExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\EfficientTypePropertyKey.cs">
      <Link>Metadata\EfficientTypePropertyKey.cs</Link>
    </Compile>
    <Compile Include="..\Common\Error.cs">
      <Link>Common\Error.cs</Link>
    </Compile>
    <Compile Include="..\Common\HttpMethodHelper.cs">
      <Link>Common\HttpMethodHelper.cs</Link>
    </Compile>
    <Compile Include="..\Common\ListWrapperCollection.cs">
      <Link>Common\ListWrapperCollection.cs</Link>
    </Compile>
    <Compile Include="..\Common\PrefixContainer.cs">
      <Link>Common\PrefixContainer.cs</Link>
    </Compile>
    <Compile Include="..\Common\PropertyHelper.cs">
      <Link>Routing\PropertyHelper.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DirectRouteBuilder.cs">
      <Link>Routing\DirectRouteBuilder.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DirectRouteFactoryContext.cs">
      <Link>Routing\DirectRouteFactoryContext.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IDirectRouteBuilder.cs">
      <Link>Routing\IDirectRouteBuilder.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IDirectRouteFactory.cs">
      <Link>Routing\IDirectRouteFactory.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IDirectRouteProvider.cs">
      <Link>Routing\IDirectRouteProvider.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IInlineConstraintResolver.cs">
      <Link>Routing\IInlineConstraintResolver.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteEntry.cs">
      <Link>Routing\RouteEntry.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteFactoryAttribute.cs">
      <Link>Routing\RouteFactoryAttribute.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteInfoDirectRouteFactory.cs">
      <Link>Routing\RouteInfoDirectRouteFactory.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteParser.cs">
      <Link>Routing\RouteParser.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RoutePrecedence.cs">
      <Link>Routing\RoutePrecedence.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpers.cs">
      <Link>Common\TaskHelpers.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpersExtensions.cs">
      <Link>Common\TaskHelpersExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\TraceWriterExceptionMapper.cs">
      <Link>Tracing\TraceWriterExceptionMapper.cs</Link>
    </Compile>
    <Compile Include="..\Common\TypeExtensions.cs">
      <Link>Common\TypeExtensions.cs</Link>
    </Compile>
    <Compile Include="AcceptVerbsAttribute.cs" />
    <Compile Include="Batch\BatchExecutionOrder.cs" />
    <Compile Include="Batch\BatchHttpRequestContext.cs" />
    <Compile Include="Batch\HttpBatchHandler.cs" />
    <Compile Include="Batch\DefaultHttpBatchHandler.cs" />
    <Compile Include="Batch\BatchHttpRequestMessageExtensions.cs" />
    <Compile Include="Controllers\ActionFilterResult.cs" />
    <Compile Include="Controllers\AuthenticationFilterResult.cs" />
    <Compile Include="Controllers\AuthorizationFilterResult.cs" />
    <Compile Include="Controllers\ExceptionFilterResult.cs" />
    <Compile Include="Controllers\HttpActionDescriptorExtensions.cs" />
    <Compile Include="Controllers\HttpControllerDescriptorExtensions.cs" />
    <Compile Include="Controllers\RequestBackedHttpRequestContext.cs" />
    <Compile Include="Controllers\HttpControllerSettings.cs" />
    <Compile Include="Controllers\HttpParameterDescriptorExtensions.cs" />
    <Compile Include="Controllers\HttpRequestContext.cs" />
    <Compile Include="Controllers\IActionResultConverter.cs" />
    <Compile Include="Controllers\HttpActionContext.cs" />
    <Compile Include="Controllers\IControllerConfiguration.cs" />
    <Compile Include="Description\ResponseTypeAttribute.cs" />
    <Compile Include="Description\ResponseDescription.cs" />
    <Compile Include="EmptyReadOnlyDictionary.cs" />
    <Compile Include="ExceptionHandling\CompositeExceptionLogger.cs" />
    <Compile Include="ExceptionHandling\ExceptionContextCatchBlock.cs" />
    <Compile Include="ExceptionHandling\ExceptionHandlerExtensions.cs" />
    <Compile Include="ExceptionHandling\ExceptionLogger.cs" />
    <Compile Include="ExceptionHandling\DefaultExceptionHandler.cs" />
    <Compile Include="ExceptionHandling\ExceptionContext.cs" />
    <Compile Include="ExceptionHandling\ExceptionHandler.cs" />
    <Compile Include="ExceptionHandling\ExceptionHandlerContext.cs" />
    <Compile Include="ExceptionHandling\ExceptionLoggerExtensions.cs" />
    <Compile Include="ExceptionHandling\ExceptionServices.cs" />
    <Compile Include="ExceptionHandling\ExceptionCatchBlocks.cs" />
    <Compile Include="ExceptionHandling\IExceptionHandler.cs" />
    <Compile Include="ExceptionHandling\IExceptionLogger.cs" />
    <Compile Include="ExceptionHandling\ExceptionLoggerContext.cs" />
    <Compile Include="ExceptionHandling\EmptyExceptionHandler.cs" />
    <Compile Include="ExceptionHandling\LastChanceExceptionHandler.cs" />
    <Compile Include="Filters\HttpAuthenticationChallengeContext.cs" />
    <Compile Include="Properties\SRResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>SRResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Results\BadRequestResult.cs" />
    <Compile Include="Results\RedirectToRouteResult.cs" />
    <Compile Include="Results\RedirectResult.cs" />
    <Compile Include="Results\CreatedAtRouteNegotiatedContentResult.cs" />
    <Compile Include="Results\BadRequestErrorMessageResult.cs" />
    <Compile Include="Results\JsonResult.cs" />
    <Compile Include="Results\ConflictResult.cs" />
    <Compile Include="Results\UnauthorizedResult.cs" />
    <Compile Include="Results\ExceptionResult.cs" />
    <Compile Include="Results\OkResult.cs" />
    <Compile Include="Results\InternalServerErrorResult.cs" />
    <Compile Include="Results\NotFoundResult.cs" />
    <Compile Include="Results\CreatedNegotiatedContentResult.cs" />
    <Compile Include="Results\OkNegotiatedContentResult.cs" />
    <Compile Include="Results\InvalidModelStateResult.cs" />
    <Compile Include="Results\FormattedContentResult.cs" />
    <Compile Include="Hosting\SuppressHostPrincipalMessageHandler.cs" />
    <Compile Include="Results\NegotiatedContentResult.cs" />
    <Compile Include="Results\StatusCodeResult.cs" />
    <Compile Include="IHttpActionResult.cs" />
    <Compile Include="HttpErrorKeys.cs" />
    <Compile Include="Controllers\FilterGrouping.cs" />
    <Compile Include="RoutePrefixAttribute.cs" />
    <Compile Include="Filters\HttpAuthenticationContext.cs" />
    <Compile Include="Results\ResponseMessageResult.cs" />
    <Compile Include="Filters\IAuthenticationFilter.cs" />
    <Compile Include="Filters\IOverrideFilter.cs" />
    <Compile Include="OverrideActionFiltersAttribute.cs" />
    <Compile Include="OverrideAuthenticationAttribute.cs" />
    <Compile Include="OverrideAuthorizationAttribute.cs" />
    <Compile Include="OverrideExceptionFiltersAttribute.cs" />
    <Compile Include="RouteAttribute.cs" />
    <Compile Include="Controllers\CandidateAction.cs" />
    <Compile Include="Routing\AttributeRoutingMapper.cs" />
    <Compile Include="Routing\DefaultDirectRouteProvider.cs" />
    <Compile Include="Routing\RouteValueKeys.cs" />
    <Compile Include="Routing\RouteCollectionRoute.cs" />
    <Compile Include="Routing\LinkGenerationRoute.cs" />
    <Compile Include="Routing\HttpRouteDataExtensions.cs" />
    <Compile Include="Routing\HttpRouteExtensions.cs" />
    <Compile Include="Routing\RouteDataTokenKeys.cs" />
    <Compile Include="..\Common\Routing\Constraints\AlphaRouteConstraint.cs">
      <Link>Routing\Constraints\AlphaRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\BoolRouteConstraint.cs">
      <Link>Routing\Constraints\BoolRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\CompoundRouteConstraint.cs">
      <Link>Routing\Constraints\CompoundRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\DateTimeRouteConstraint.cs">
      <Link>Routing\Constraints\DateTimeRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\DecimalRouteConstraint.cs">
      <Link>Routing\Constraints\DecimalRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\DoubleRouteConstraint.cs">
      <Link>Routing\Constraints\DoubleRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\FloatRouteConstraint.cs">
      <Link>Routing\Constraints\FloatRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\GuidRouteConstraint.cs">
      <Link>Routing\Constraints\GuidRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\IntRouteConstraint.cs">
      <Link>Routing\Constraints\IntRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\LengthRouteConstraint.cs">
      <Link>Routing\Constraints\LengthRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\LongRouteConstraint.cs">
      <Link>Routing\Constraints\LongRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MaxLengthRouteConstraint.cs">
      <Link>Routing\Constraints\MaxLengthRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MaxRouteConstraint.cs">
      <Link>Routing\Constraints\MaxRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MinLengthRouteConstraint.cs">
      <Link>Routing\Constraints\MinLengthRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MinRouteConstraint.cs">
      <Link>Routing\Constraints\MinRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\RangeRouteConstraintBase.cs">
      <Link>Routing\Constraints\RangeRouteConstraintBase.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\RegexRouteConstraint.cs">
      <Link>Routing\Constraints\RegexRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\OptionalRouteConstraint.cs">
      <Link>Routing\Constraints\OptionalRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DefaultInlineConstraintResolver.cs">
      <Link>Routing\DefaultInlineConstraintResolver.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\InlineRouteTemplateParser.cs">
      <Link>Routing\InlineRouteTemplateParser.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\SubRouteCollection.cs">
      <Link>Routing\SubRouteCollection.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IRoutePrefix.cs">
      <Link>Routing\IRoutePrefix.cs</Link>
    </Compile>
    <Compile Include="Routing\IHttpRouteInfoProvider.cs" />
    <Compile Include="Routing\RoutingContext.cs" />
    <Compile Include="Routing\StopRoutingHandler.cs" />
    <Compile Include="Services\Decorator.cs" />
    <Compile Include="Services\IDecorator.cs" />
    <Compile Include="SingleResult.cs" />
    <Compile Include="SingleResultOfT.cs" />
    <Compile Include="Tracing\TraceLevelHelper.cs" />
    <Compile Include="Tracing\TraceKindHelper.cs" />
    <Compile Include="Tracing\Tracers\AuthenticationFilterTracer.cs" />
    <Compile Include="Tracing\Tracers\FormatterLoggerTraceWrapper.cs" />
    <Compile Include="Tracing\Tracers\DefaultHttpControllerTypeResolverTracer.cs" />
    <Compile Include="Tracing\Tracers\OverrideFilterTracer.cs" />
    <Compile Include="Validation\BodyModelValidatorContext.cs" />
    <Compile Include="Validation\IModelValidatorCache.cs" />
    <Compile Include="Validation\IBodyModelValidatorKeyBuilder.cs" />
    <Compile Include="Validation\ModelValidatorCache.cs" />
    <Compile Include="Controllers\ResponseMessageResultConverter.cs" />
    <Compile Include="Controllers\ValueResultConverter.cs" />
    <Compile Include="Controllers\VoidResultConverter.cs" />
    <Compile Include="Dependencies\IDependencyScope.cs" />
    <Compile Include="Dispatcher\DefaultAssembliesResolver.cs" />
    <Compile Include="Dispatcher\HttpRoutingDispatcher.cs" />
    <Compile Include="Dispatcher\IAssembliesResolver.cs" />
    <Compile Include="Hosting\IHostBufferPolicySelector.cs" />
    <Compile Include="HttpConfigurationExtensions.cs" />
    <Compile Include="HttpOptionsAttribute.cs" />
    <Compile Include="HttpHeadAttribute.cs" />
    <Compile Include="HttpPatchAttribute.cs" />
    <Compile Include="Description\ApiDescription.cs" />
    <Compile Include="Description\ApiExplorer.cs" />
    <Compile Include="Description\ApiExplorerSettingsAttribute.cs" />
    <Compile Include="Description\ApiParameterDescription.cs" />
    <Compile Include="Description\ApiParameterSource.cs" />
    <Compile Include="Description\IDocumentationProvider.cs" />
    <Compile Include="Description\IApiExplorer.cs" />
    <Compile Include="IncludeErrorDetailPolicy.cs" />
    <Compile Include="Filters\HttpActionExecutedContext.cs" />
    <Compile Include="Internal\HttpParameterBindingExtensions.cs" />
    <Compile Include="ModelBinding\FormatterParameterBinding.cs" />
    <Compile Include="ModelBinding\CancellationTokenParameterBinding.cs" />
    <Compile Include="ModelBinding\ErrorParameterBinding.cs" />
    <Compile Include="ModelBinding\FormDataCollectionExtensions.cs" />
    <Compile Include="Controllers\HttpActionBinding.cs" />
    <Compile Include="Controllers\HttpActionDescriptor.cs" />
    <Compile Include="ActionNameAttribute.cs" />
    <Compile Include="Controllers\ReflectedHttpActionDescriptor.cs" />
    <Compile Include="AllowAnonymousAttribute.cs" />
    <Compile Include="HttpError.cs" />
    <Compile Include="HttpResponseException.cs" />
    <Compile Include="ModelBinding\HttpRequestParameterBinding.cs" />
    <Compile Include="ModelBinding\IValueProviderParameterBinding.cs" />
    <Compile Include="ModelBinding\JQueryMVCFormUrlEncodedFormatter.cs" />
    <Compile Include="ModelBinding\ModelBinderParameterBinding.cs" />
    <Compile Include="ModelBinding\ParameterBindingRulesCollection.cs" />
    <Compile Include="ParameterBindingAttribute.cs" />
    <Compile Include="HttpResponseMessageExtensions.cs" />
    <Compile Include="Dispatcher\DefaultHttpControllerActivator.cs" />
    <Compile Include="Controllers\HttpControllerDescriptor.cs" />
    <Compile Include="Dispatcher\IHttpControllerActivator.cs" />
    <Compile Include="HttpRouteCollection.cs" />
    <Compile Include="HttpPutAttribute.cs" />
    <Compile Include="HttpDeleteAttribute.cs" />
    <Compile Include="Controllers\IActionHttpMethodProvider.cs" />
    <Compile Include="Controllers\ApiControllerActionInvoker.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="AuthorizeAttribute.cs" />
    <Compile Include="HttpGetAttribute.cs" />
    <Compile Include="HttpPostAttribute.cs" />
    <Compile Include="HttpRequestMessageExtensions.cs" />
    <Compile Include="Filters\HttpFilterCollection.cs" />
    <Compile Include="Filters\IFilter.cs" />
    <Compile Include="HttpServer.cs" />
    <Compile Include="Internal\TypeActivator.cs" />
    <Compile Include="ModelBinding\DefaultActionValueBinder.cs" />
    <Compile Include="Controllers\IHttpActionInvoker.cs" />
    <Compile Include="Controllers\IActionValueBinder.cs" />
    <Compile Include="Controllers\IHttpActionSelector.cs" />
    <Compile Include="Filters\ActionFilterAttribute.cs" />
    <Compile Include="Filters\AuthorizationFilterAttribute.cs" />
    <Compile Include="Filters\ExceptionFilterAttribute.cs" />
    <Compile Include="Filters\ActionDescriptorFilterProvider.cs" />
    <Compile Include="Filters\FilterInfo.cs" />
    <Compile Include="Filters\FilterInfoComparer.cs" />
    <Compile Include="Filters\FilterScope.cs" />
    <Compile Include="Filters\ConfigurationFilterProvider.cs" />
    <Compile Include="Filters\IActionFilter.cs" />
    <Compile Include="Filters\IAuthorizationFilter.cs" />
    <Compile Include="Filters\IExceptionFilter.cs" />
    <Compile Include="Filters\IFilterProvider.cs" />
    <Compile Include="Internal\MemberInfoExtensions.cs" />
    <Compile Include="ModelBinding\Binders\CompositeModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\CompositeModelBinder.cs" />
    <Compile Include="HttpRouteCollectionExtensions.cs" />
    <Compile Include="RouteParameter.cs" />
    <Compile Include="Routing\BoundRouteTemplate.cs" />
    <Compile Include="Routing\IHttpVirtualPathData.cs" />
    <Compile Include="Routing\IHttpRouteData.cs" />
    <Compile Include="Routing\IHttpRoute.cs" />
    <Compile Include="Routing\HttpMethodConstraint.cs" />
    <Compile Include="Routing\HttpParsedRoute.cs" />
    <Compile Include="Routing\HttpRoute.cs" />
    <Compile Include="Routing\HttpRouteData.cs" />
    <Compile Include="Routing\HttpRouteDirection.cs" />
    <Compile Include="Routing\HttpRouteValueDictionary.cs" />
    <Compile Include="Routing\HttpVirtualPathData.cs" />
    <Compile Include="Routing\IHttpRouteConstraint.cs" />
    <Compile Include="Routing\MediaTypeFormatterExtensions.cs" />
    <Compile Include="..\Common\Routing\PathContentSegment.cs">
      <Link>Routing\PathContentSegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathLiteralSubsegment.cs">
      <Link>Routing\PathLiteralSubsegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathParameterSubsegment.cs">
      <Link>Routing\PathParameterSubsegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathSegment.cs">
      <Link>Routing\PathSegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathSeparatorSegment.cs">
      <Link>Routing\PathSeparatorSegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathSubsegment.cs">
      <Link>Routing\PathSubsegment.cs</Link>
    </Compile>
    <Compile Include="NonActionAttribute.cs" />
    <Compile Include="Routing\UriPathExtensionMapping.cs" />
    <Compile Include="Routing\UrlHelper.cs" />
    <Compile Include="Dispatcher\HttpControllerTypeCache.cs" />
    <Compile Include="Dispatcher\DefaultHttpControllerSelector.cs" />
    <Compile Include="Dispatcher\DefaultHttpControllerTypeResolver.cs" />
    <Compile Include="ServicesExtensions.cs" />
    <Compile Include="Dependencies\EmptyResolver.cs" />
    <Compile Include="Dependencies\IDependencyResolver.cs" />
    <Compile Include="Dispatcher\IHttpControllerSelector.cs" />
    <Compile Include="Filters\FilterAttribute.cs" />
    <Compile Include="Hosting\HttpPropertyKeys.cs" />
    <Compile Include="Dispatcher\HttpControllerDispatcher.cs" />
    <Compile Include="Dispatcher\IHttpControllerTypeResolver.cs" />
    <Compile Include="Internal\TypeHelper.cs" />
    <Compile Include="Internal\ParameterInfoExtensions.cs" />
    <Compile Include="Controllers\ReflectedHttpParameterDescriptor.cs" />
    <Compile Include="HttpBindNeverAttribute.cs" />
    <Compile Include="HttpBindRequiredAttribute.cs" />
    <Compile Include="Controllers\HttpActionContextExtensions.cs" />
    <Compile Include="ModelBinding\ModelBindingHelper.cs" />
    <Compile Include="Controllers\ApiControllerActionSelector.cs" />
    <Compile Include="Controllers\HttpParameterBinding.cs" />
    <Compile Include="Controllers\HttpParameterDescriptor.cs" />
    <Compile Include="Services\ControllerServices.cs" />
    <Compile Include="Services\DefaultServices.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="Controllers\IHttpController.cs" />
    <Compile Include="Internal\TypeDescriptorHelper.cs" />
    <Compile Include="Internal\CollectionModelBinderUtil.cs" />
    <Compile Include="Metadata\Providers\AssociatedMetadataProvider.cs" />
    <Compile Include="Metadata\Providers\CachedDataAnnotationsMetadataAttributes.cs" />
    <Compile Include="Metadata\Providers\CachedModelMetadata.cs" />
    <Compile Include="Metadata\ModelMetadata.cs" />
    <Compile Include="Metadata\ModelMetadataProvider.cs" />
    <Compile Include="Metadata\Providers\CachedDataAnnotationsModelMetadata.cs" />
    <Compile Include="Metadata\Providers\DataAnnotationsModelMetadataProvider.cs" />
    <Compile Include="Metadata\Providers\EmptyMetadataProvider.cs" />
    <Compile Include="ModelBinding\Binders\ArrayModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\ArrayModelBinder.cs" />
    <Compile Include="ModelBinding\HttpBindingBehavior.cs" />
    <Compile Include="ModelBinding\HttpBindingBehaviorAttribute.cs" />
    <Compile Include="ModelBinding\Binders\CollectionModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\CollectionModelBinder.cs" />
    <Compile Include="ModelBinding\Binders\ComplexModelDto.cs" />
    <Compile Include="ModelBinding\Binders\ComplexModelDtoModelBinder.cs" />
    <Compile Include="ModelBinding\Binders\ComplexModelDtoModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\ComplexModelDtoResult.cs" />
    <Compile Include="ModelBinding\Binders\DictionaryModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\DictionaryModelBinder.cs" />
    <Compile Include="ModelBinding\ModelBinderAttribute.cs" />
    <Compile Include="ModelBinding\CustomModelBinderAttribute.cs" />
    <Compile Include="ModelBinding\ModelBindingContext.cs" />
    <Compile Include="ModelBinding\IModelBinder.cs" />
    <Compile Include="ModelBinding\Binders\KeyValuePairModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\KeyValuePairModelBinder.cs" />
    <Compile Include="ModelBinding\ModelBinderConfig.cs" />
    <Compile Include="ModelBinding\ModelBinderErrorMessageProvider.cs" />
    <Compile Include="ModelBinding\ModelBinderProvider.cs" />
    <Compile Include="Controllers\HttpControllerContext.cs" />
    <Compile Include="ModelBinding\ModelError.cs" />
    <Compile Include="ModelBinding\ModelErrorCollection.cs" />
    <Compile Include="ModelBinding\ModelState.cs" />
    <Compile Include="ModelBinding\ModelStateDictionary.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Services\ServicesContainer.cs" />
    <Compile Include="Tracing\IFormatterTracer.cs" />
    <Compile Include="Tracing\ITraceManager.cs" />
    <Compile Include="Tracing\ITraceWriter.cs" />
    <Compile Include="Tracing\ITraceWriterExtensions.cs" />
    <Compile Include="Tracing\TraceManager.cs" />
    <Compile Include="Tracing\TraceCategories.cs" />
    <Compile Include="Tracing\TraceKind.cs" />
    <Compile Include="Tracing\TraceLevel.cs" />
    <Compile Include="Tracing\TraceRecord.cs" />
    <Compile Include="Tracing\Tracers\HttpActionBindingTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpActionDescriptorTracer.cs" />
    <Compile Include="Tracing\Tracers\ActionFilterAttributeTracer.cs" />
    <Compile Include="Tracing\Tracers\ActionFilterTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpActionInvokerTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpActionSelectorTracer.cs" />
    <Compile Include="Tracing\Tracers\ActionValueBinderTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerDescriptorTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerTracer.cs" />
    <Compile Include="Tracing\Tracers\AuthorizationFilterAttributeTracer.cs" />
    <Compile Include="Tracing\Tracers\AuthorizationFilterTracer.cs" />
    <Compile Include="Tracing\Tracers\BufferedMediaTypeFormatterTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerActivatorTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerSelectorTracer.cs" />
    <Compile Include="Tracing\Tracers\ExceptionFilterAttributeTracer.cs" />
    <Compile Include="Tracing\Tracers\ExceptionFilterTracer.cs" />
    <Compile Include="Tracing\Tracers\FilterTracer.cs" />
    <Compile Include="Tracing\Tracers\ContentNegotiatorTracer.cs" />
    <Compile Include="Tracing\Tracers\FormatterParameterBindingTracer.cs" />
    <Compile Include="Tracing\Tracers\FormUrlEncodedMediaTypeFormatterTracer.cs" />
    <Compile Include="Tracing\Tracers\HttpParameterBindingTracer.cs" />
    <Compile Include="Tracing\Tracers\JsonMediaTypeFormatterTracer.cs" />
    <Compile Include="Tracing\Tracers\MediaTypeFormatterTracer.cs" />
    <Compile Include="Tracing\Tracers\MessageHandlerTracer.cs" />
    <Compile Include="Tracing\Tracers\RequestMessageHandlerTracer.cs" />
    <Compile Include="Tracing\Tracers\XmlMediaTypeFormatterTracer.cs" />
    <Compile Include="Tracing\FormattingUtilities.cs" />
    <Compile Include="Validation\DefaultBodyModelValidator.cs" />
    <Compile Include="Validation\IBodyModelValidator.cs" />
    <Compile Include="Validation\ModelStateFormatterLogger.cs" />
    <Compile Include="Validation\ModelValidatedEventArgs.cs" />
    <Compile Include="Validation\ModelValidatingEventArgs.cs" />
    <Compile Include="Validation\ModelValidationNode.cs" />
    <Compile Include="ModelBinding\Binders\MutableObjectModelBinder.cs" />
    <Compile Include="ModelBinding\Binders\MutableObjectModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\SimpleModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\TypeConverterModelBinder.cs" />
    <Compile Include="ModelBinding\Binders\TypeConverterModelBinderProvider.cs" />
    <Compile Include="ModelBinding\Binders\TypeMatchModelBinder.cs" />
    <Compile Include="ModelBinding\Binders\TypeMatchModelBinderProvider.cs" />
    <Compile Include="Validation\ModelValidationRequiredMemberSelector.cs" />
    <Compile Include="Validation\ModelValidationResult.cs" />
    <Compile Include="Validation\ModelValidator.cs" />
    <Compile Include="Validation\ModelValidatorProvider.cs" />
    <Compile Include="Validation\Providers\AssociatedValidatorProvider.cs" />
    <Compile Include="Validation\Providers\DataAnnotationsModelValidatorProvider.cs" />
    <Compile Include="Validation\Providers\DataMemberModelValidatorProvider.cs" />
    <Compile Include="Validation\Providers\InvalidModelValidatorProvider.cs" />
    <Compile Include="Validation\Providers\RequiredMemberModelValidatorProvider.cs" />
    <Compile Include="Validation\ReferenceEqualityComparer.cs" />
    <Compile Include="Validation\Validators\ErrorModelValidator.cs" />
    <Compile Include="Validation\Validators\RequiredMemberModelValidator.cs" />
    <Compile Include="Validation\Validators\ValidatableObjectAdapter.cs" />
    <Compile Include="Validation\Validators\DataAnnotationsModelValidator.cs" />
    <Compile Include="FromBodyAttribute.cs" />
    <Compile Include="FromUriAttribute.cs" />
    <Compile Include="ValueProviders\IUriValueProviderFactory.cs" />
    <Compile Include="ValueProviders\Providers\CompositeValueProvider.cs" />
    <Compile Include="ValueProviders\Providers\CompositeValueProviderFactory.cs" />
    <Compile Include="ValueProviders\Providers\NameValuePairsValueProvider.cs" />
    <Compile Include="ValueProviders\Providers\ElementalValueProvider.cs" />
    <Compile Include="ValueProviders\IEnumerableValueProvider.cs" />
    <Compile Include="ValueProviders\Providers\RouteDataValueProvider.cs" />
    <Compile Include="ValueProviders\Providers\RouteDataValueProviderFactory.cs" />
    <Compile Include="ValueProviders\ValueProviderFactory.cs" />
    <Compile Include="ValueProviders\Providers\QueryStringValueProvider.cs" />
    <Compile Include="ValueProviders\Providers\QueryStringValueProviderFactory.cs" />
    <Compile Include="ValueProviders\ValueProviderAttribute.cs" />
    <Compile Include="ValueProviders\ValueProviderResult.cs" />
    <Compile Include="ValueProviders\IValueProvider.cs" />
    <Compile Include="HttpConfiguration.cs" />
    <Compile Include="ApiController.cs" />
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Link>Properties\CommonWebApiResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonWebApiResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\SRResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <SubType>Designer</SubType>
      <LastGenOutput>SRResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Http/Tracing/FormattingUtilities.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Net.Http.Formatting;
using System.Text;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Properties;
using System.Web.Http.Routing;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// General purpose utilities to format strings used in tracing.
    /// </summary>
    internal static class FormattingUtilities
    {
        public static readonly string NullMessage = "null";

        public static string ActionArgumentsToString(IDictionary<string, object> actionArguments)
        {
            Contract.Assert(actionArguments != null);
            return String.Join(", ",
                               actionArguments.Keys.Select<string, string>(
                                   (k) => k + "=" + ValueToString(actionArguments[k], CultureInfo.CurrentCulture)));
        }

        public static string ActionDescriptorToString(HttpActionDescriptor actionDescriptor)
        {
            Contract.Assert(actionDescriptor != null);

            string parameterList = String.Join(", ",
                                               actionDescriptor.GetParameters().Select<HttpParameterDescriptor, string>(
                                                   (p) => p.ParameterType.Name + " " + p.ParameterName));

            return actionDescriptor.ActionName + "(" + parameterList + ")";
        }

        public static string ActionInvokeToString(HttpActionContext actionContext)
        {
            Contract.Assert(actionContext != null);
            return ActionInvokeToString(actionContext.ActionDescriptor.ActionName, actionContext.ActionArguments);
        }

        public static string ActionInvokeToString(string actionName, IDictionary<string, object> arguments)
        {
            Contract.Assert(actionName != null);
            Contract.Assert(arguments != null);

            return actionName + "(" + ActionArgumentsToString(arguments) + ")";
        }

        public static string FormattersToString(IEnumerable<MediaTypeFormatter> formatters)
        {
            Contract.Assert(formatters != null);

            return String.Join(", ", formatters.Select<MediaTypeFormatter, string>((f) => f.GetType().Name));
        }

        public static string ModelBinderToString(ModelBinderProvider provider)
        {
            Contract.Assert(provider != null);

            CompositeModelBinderProvider composite = provider as CompositeModelBinderProvider;
            if (composite == null)
            {
                return provider.GetType().Name;
            }

            string modelBinderList = String.Join(", ", composite.Providers.Select<ModelBinderProvider, string>(ModelBinderToString));

            return provider.GetType().Name + "(" + modelBinderList + ")";
        }

        public static string ModelStateToString(ModelStateDictionary modelState)
        {
            Contract.Assert(modelState != null);

            if (modelState.IsValid)
            {
                return String.Empty;
            }

            StringBuilder modelStateBuilder = new StringBuilder();
            foreach (string key in modelState.Keys)
            {
                ModelState state = modelState[key];
                if (state.Errors.Count > 0)
                {
                    foreach (ModelError error in state.Errors)
                    {
                        string errorString = Error.Format(SRResources.TraceModelStateErrorMessage, 
                                                           key,
                                                           error.ErrorMessage);
                        if (modelStateBuilder.Length > 0)
                        {
                            modelStateBuilder.Append(',');
                        }

                        modelStateBuilder.Append(errorString);
                    }
                }
            }

            return modelStateBuilder.ToString();
        }

        public static string RouteToString(IHttpRouteData routeData)
        {
            Contract.Assert(routeData != null);

            return String.Join(",", routeData.Values.Select((pair) => Error.Format("{0}:{1}", pair.Key, pair.Value)));
        }

        public static string ValueProviderToString(IValueProvider provider)
        {
            Contract.Assert(provider != null);

            CompositeValueProvider composite = provider as CompositeValueProvider;
            if (composite == null)
            {
                return provider.GetType().Name;
            }

            string providerList = String.Join(", ", composite.Select<IValueProvider, string>(ValueProviderToString));
            return provider.GetType().Name + "(" + providerList + ")";
        }

        public static string ValueToString(object value, CultureInfo cultureInfo)
        {
            Contract.Assert(cultureInfo != null);

            if (value == null)
            {
                return NullMessage;
            }

            return Convert.ToString(value, cultureInfo);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/IFormatterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Tracing.Tracers;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Interface used to mark <see cref="MediaTypeFormatterTracer"/> classes.
    /// </summary>
    internal interface IFormatterTracer
    {
        /// <summary>
        /// Gets the associated <see cref="HttpRequestMessage"/>.
        /// </summary>
        HttpRequestMessage Request { get; }

        /// <summary>
        /// Gets the inner <see cref="MediaTypeFormatter"/> this tracer is monitoring.
        /// </summary>
        MediaTypeFormatter InnerFormatter { get; }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/ITraceManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Interface to initialize the tracing layer.
    /// </summary>
    /// <remarks>
    /// This is an extensibility interface that may be inserted into
    /// <see cref="HttpConfiguration.Services"/> to provide a replacement for the
    /// entire tracing layer.
    /// </remarks>
    public interface ITraceManager
    {
        void Initialize(HttpConfiguration configuration);
    }
}


================================================
FILE: src/System.Web.Http/Tracing/ITraceWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Interface to write <see cref="TraceRecord"/> instances.
    /// </summary>
    public interface ITraceWriter
    {
        /// <summary>
        /// Creates and writes a new <see cref="TraceRecord"/> to the current <see cref="ITraceWriter"/>
        /// if tracing is enabled for the given <paramref name="category"/> and <paramref name="level"/>.
        /// </summary>
        /// <remarks>
        /// The decision whether tracing is enabled for a specific category and level
        /// is an implementation detail of each individual <see cref="ITraceWriter"/>.
        /// <para>
        /// If the current <see cref="ITraceWriter"/> decides tracing is enabled for the given 
        /// category and level, it will construct a new <see cref="TraceRecord"/> and invoke 
        /// the caller's <paramref name="traceAction"/> to allow the caller to fill in additional
        /// information.
        /// </para>
        /// <para>
        /// If the current <see cref="ITraceWriter"/> decides tracing is not enabled for the given
        /// category and level, no <see cref="TraceRecord"/> will be created,
        /// and the <paramref name="traceAction"/> will not be called.
        /// </para> 
        /// </remarks>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to associate
        /// the <see cref="TraceRecord"/>.  It may be <c>null</c> but doing so will result in
        /// a <see cref="TraceRecord"/> that is not correlated with its originating request.</param>
        /// <param name="category">The logical category for the trace.  Users may define their own.</param>
        /// <param name="level">The <see cref="TraceLevel"/> at which to write this trace.</param>
        /// <param name="traceAction">The action to invoke if tracing is enabled.  The caller is expected
        /// to fill in any or all of the values of the given <see cref="TraceRecord"/> in this action.</param>
        void Trace(HttpRequestMessage request, string category, TraceLevel level, Action<TraceRecord> traceAction);
    }
}


================================================
FILE: src/System.Web.Http/Tracing/ITraceWriterExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Extension methods for <see cref="ITraceWriter"/>.
    /// </summary>
    public static class ITraceWriterExtensions
    {
        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Debug"/> with the given message.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Debug(this ITraceWriter traceWriter, HttpRequestMessage request, string category, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Debug, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Debug"/> with the given <paramref name="exception"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        public static void Debug(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception)
        {
            Trace(traceWriter, request, category, TraceLevel.Debug, exception);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Debug"/> with the given message and exception.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Debug(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Debug, exception, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Error"/> with the given message.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Error(this ITraceWriter traceWriter, HttpRequestMessage request, string category, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Error, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Error"/> with the given <paramref name="exception"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        public static void Error(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception)
        {
            Trace(traceWriter, request, category, TraceLevel.Error, exception);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Error"/> with the given message and exception.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Error(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Error, exception, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Fatal"/> with the given message.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Fatal(this ITraceWriter traceWriter, HttpRequestMessage request, string category, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Fatal, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Fatal"/> with the given <paramref name="exception"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        public static void Fatal(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception)
        {
            Trace(traceWriter, request, category, TraceLevel.Fatal, exception);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Fatal"/> with the given message and exception.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Fatal(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Fatal, exception, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Info"/> with the given message.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Info(this ITraceWriter traceWriter, HttpRequestMessage request, string category, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Info, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Info"/> with the given <paramref name="exception"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        public static void Info(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception)
        {
            Trace(traceWriter, request, category, TraceLevel.Info, exception);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Info"/> with the given message and exception.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Info(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Info, exception, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a single <see cref="TraceRecord"/> to the given <see cref="ITraceWriter"/> if the trace writer
        /// is enabled for the given <paramref name="category"/> and <paramref name="level"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so cannot be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="level">The <see cref="TraceLevel"/> for the trace.</param>
        /// <param name="exception">The <see cref="Exception"/> to trace.   It may not be null.</param>
        public static void Trace(this ITraceWriter traceWriter, HttpRequestMessage request, string category, TraceLevel level, Exception exception)
        {
            if (traceWriter == null)
            {
                throw System.Web.Http.Error.ArgumentNull("traceWriter");
            }

            if (exception == null)
            {
                throw System.Web.Http.Error.ArgumentNull("exception");
            }

            traceWriter.Trace(
                request,
                category,
                level,
                (TraceRecord traceRecord) =>
                {
                    traceRecord.Exception = exception;
                });
        }

        /// <summary>
        /// Writes a single <see cref="TraceRecord"/> to the given <see cref="ITraceWriter"/> if the trace writer
        /// is enabled for the given <paramref name="category"/> and <paramref name="level"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="level">The <see cref="TraceLevel"/> for the trace.</param>
        /// <param name="exception">The <see cref="Exception"/> to trace.   It may not be null.</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Trace(this ITraceWriter traceWriter, HttpRequestMessage request, string category, TraceLevel level, Exception exception, string messageFormat, params object[] messageArguments)
        {
            if (traceWriter == null)
            {
                throw System.Web.Http.Error.ArgumentNull("traceWriter");
            }

            if (exception == null)
            {
                throw System.Web.Http.Error.ArgumentNull("exception");
            }

            if (messageFormat == null)
            {
                throw System.Web.Http.Error.ArgumentNull("messageFormat");
            }

            traceWriter.Trace(
                request,
                category,
                level,
                (TraceRecord traceRecord) =>
                {
                    traceRecord.Exception = exception;
                    traceRecord.Message = System.Web.Http.Error.Format(messageFormat, messageArguments);
                });
        }

        /// <summary>
        /// Writes a single <see cref="TraceRecord"/> to the given <see cref="ITraceWriter"/> if the trace writer
        /// is enabled for the given <paramref name="category"/> and <paramref name="level"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="level">The <see cref="TraceLevel"/> for the trace.</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Trace(this ITraceWriter traceWriter, HttpRequestMessage request, string category, TraceLevel level, string messageFormat, params object[] messageArguments)
        {
            if (traceWriter == null)
            {
                throw System.Web.Http.Error.ArgumentNull("traceWriter");
            }

            if (messageFormat == null)
            {
                throw System.Web.Http.Error.ArgumentNull("messageFormat");
            }

            traceWriter.Trace(
                request,
                category,
                level,
                (TraceRecord traceRecord) =>
                {
                    traceRecord.Message = System.Web.Http.Error.Format(messageFormat, messageArguments);
                });
        }

        /// <summary>
        /// Traces both a begin and an end trace around a specified operation.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/>.</param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to associate the trace.  It may be null.</param>
        /// <param name="category">The logical category of the trace.</param>
        /// <param name="level">The <see cref="TraceLevel"/> of the trace.</param>
        /// <param name="operatorName">The name of the object performing the operation.  It may be null.</param>
        /// <param name="operationName">The name of the operation being performed.  It may be null.</param>
        /// <param name="beginTrace">The <see cref="Action"/> to invoke prior to performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        /// <param name="execute">An <see cref="Action"/> that performs the operation.</param>
        /// <param name="endTrace">The <see cref="Action"/> to invoke after successfully performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        /// <param name="errorTrace">The <see cref="Action"/> to invoke if an error was encountered performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        public static void TraceBeginEnd(this ITraceWriter traceWriter,
                                        HttpRequestMessage request,
                                        string category,
                                        TraceLevel level,
                                        string operatorName,
                                        string operationName,
                                        Action<TraceRecord> beginTrace,
                                        Action execute,
                                        Action<TraceRecord> endTrace,
                                        Action<TraceRecord> errorTrace)
        {
            if (traceWriter == null)
            {
                throw System.Web.Http.Error.ArgumentNull("traceWriter");
            }

            if (execute == null)
            {
                throw System.Web.Http.Error.ArgumentNull("execute");
            }

            traceWriter.Trace(
                request,
                category,
                level,
                (TraceRecord traceRecord) =>
                {
                    traceRecord.Kind = TraceKind.Begin;
                    traceRecord.Operator = operatorName;
                    traceRecord.Operation = operationName;
                    if (beginTrace != null)
                    {
                        beginTrace(traceRecord);
                    }
                });
            try
            {
                execute();

                traceWriter.Trace(
                    request,
                    category,
                    level,
                    (TraceRecord traceRecord) =>
                    {
                        traceRecord.Kind = TraceKind.End;
                        traceRecord.Operator = operatorName;
                        traceRecord.Operation = operationName;
                        if (endTrace != null)
                        {
                            endTrace(traceRecord);
                        }
                    });
            }
            catch (Exception exception)
            {
                traceWriter.TraceError(exception, request, category, operatorName, operationName, errorTrace);
                throw;
            }
        }

        /// <summary>
        /// Traces both a begin and an end trace around a specified asynchronous operation.
        /// </summary>
        /// <remarks>The end trace will occur when the asynchronous operation completes, either success or failure.</remarks>
        /// <typeparam name="TResult">The type of result produced by the <see cref="Task"/>.</typeparam>
        /// /// <param name="traceWriter">The <see cref="ITraceWriter"/>.</param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to associate the trace.  It may be null.</param>
        /// <param name="category">The logical category of the trace.</param>
        /// <param name="level">The <see cref="TraceLevel"/> of the trace.</param>
        /// <param name="operatorName">The name of the object performing the operation.  It may be null.</param>
        /// <param name="operationName">The name of the operation being performed.  It may be null.</param>
        /// <param name="beginTrace">The <see cref="Action"/> to invoke prior to performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        /// <param name="execute">An <see cref="Func{Task}"/> that returns the <see cref="Task"/> that will perform the operation.</param>
        /// <param name="endTrace">The <see cref="Action"/> to invoke after successfully performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  The result of the completed task will also
        /// be passed to this action.  This action may be null.</param>
        /// <param name="errorTrace">The <see cref="Action"/> to invoke if an error was encountered performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        /// <returns>The <see cref="Task"/> returned by the operation.</returns>
        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Nested generic required for this method.")]
        public static Task<TResult> TraceBeginEndAsync<TResult>(this ITraceWriter traceWriter,
                                HttpRequestMessage request,
                                string category,
                                TraceLevel level,
                                string operatorName,
                                string operationName,
                                Action<TraceRecord> beginTrace,
                                Func<Task<TResult>> execute,
                                Action<TraceRecord, TResult> endTrace,
                                Action<TraceRecord> errorTrace)
        {
            if (traceWriter == null)
            {
                throw System.Web.Http.Error.ArgumentNull("traceWriter");
            }

            if (execute == null)
            {
                throw System.Web.Http.Error.ArgumentNull("execute");
            }

            traceWriter.Trace(
                request,
                category,
                level,
                (TraceRecord traceRecord) =>
                {
                    traceRecord.Kind = TraceKind.Begin;
                    traceRecord.Operator = operatorName;
                    traceRecord.Operation = operationName;
                    if (beginTrace != null)
                    {
                        beginTrace(traceRecord);
                    }
                });
            try
            {
                Task<TResult> task = execute();

                // If the operation returned a null Task, we cannot do any
                // further tracing.  Return that null to the caller as
                // would happen if tracing were not enabled.
                if (task == null)
                {
                    return task;
                }

                return traceWriter.TraceBeginEndAsyncCore<TResult>(request, category, level, operatorName, operationName, endTrace, errorTrace, task);
            }
            catch (Exception exception)
            {
                traceWriter.TraceError(exception, request, category, operatorName, operationName, errorTrace);
                throw;
            }
        }

        private static async Task<TResult> TraceBeginEndAsyncCore<TResult>(this ITraceWriter traceWriter,
            HttpRequestMessage request,
            string category, TraceLevel level,
            string operatorName,
            string operationName,
            Action<TraceRecord, TResult> endTrace,
            Action<TraceRecord> errorTrace,
            Task<TResult> task)
        {
            try
            {
                TResult result = await task;
                traceWriter.Trace(
                    request,
                    category,
                    level,
                    (TraceRecord traceRecord) =>
                    {
                        traceRecord.Kind = TraceKind.End;
                        traceRecord.Operator = operatorName;
                        traceRecord.Operation = operationName;
                        if (endTrace != null)
                        {
                            endTrace(traceRecord, result);
                        }
                    });

                return result;
            }
            catch (OperationCanceledException)
            {
                traceWriter.Trace(
                        request,
                        category,
                        TraceLevel.Warn,
                        (TraceRecord traceRecord) =>
                        {
                            traceRecord.Kind = TraceKind.End;
                            traceRecord.Operator = operatorName;
                            traceRecord.Operation = operationName;
                            traceRecord.Message = SRResources.TraceCancelledMessage;
                            if (errorTrace != null)
                            {
                                errorTrace(traceRecord);
                            }
                        });

                throw;
            }
            catch (Exception exception)
            {
                traceWriter.TraceError(exception, request, category, operatorName, operationName, errorTrace);
                throw;
            }
        }

        /// <summary>
        /// Traces both a begin and an end trace around a specified asynchronous operation.
        /// </summary>
        /// <remarks>The end trace will occur when the asynchronous operation completes, either success or failure.</remarks>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/>.</param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to associate the trace.  It may be null.</param>
        /// <param name="category">The logical category of the trace.</param>
        /// <param name="level">The <see cref="TraceLevel"/> of the trace.</param>
        /// <param name="operatorName">The name of the object performing the operation.  It may be null.</param>
        /// <param name="operationName">The name of the operation being performed.  It may be null.</param>
        /// <param name="beginTrace">The <see cref="Action"/> to invoke prior to performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        /// <param name="execute">An <see cref="Func{Task}"/> that returns the <see cref="Task"/> that will perform the operation.</param>
        /// <param name="endTrace">The <see cref="Action"/> to invoke after successfully performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        /// <param name="errorTrace">The <see cref="Action"/> to invoke if an error was encountered performing the operation, 
        /// allowing the given <see cref="TraceRecord"/> to be filled in.  It may be null.</param>
        /// <returns>The <see cref="Task"/> returned by the operation.</returns>
        public static Task TraceBeginEndAsync(this ITraceWriter traceWriter,
                                HttpRequestMessage request,
                                string category,
                                TraceLevel level,
                                string operatorName,
                                string operationName,
                                Action<TraceRecord> beginTrace,
                                Func<Task> execute,
                                Action<TraceRecord> endTrace,
                                Action<TraceRecord> errorTrace)
        {
            if (traceWriter == null)
            {
                throw System.Web.Http.Error.ArgumentNull("traceWriter");
            }

            if (execute == null)
            {
                throw System.Web.Http.Error.ArgumentNull("execute");
            }

            traceWriter.Trace(
                request,
                category,
                level,
                (TraceRecord traceRecord) =>
                {
                    traceRecord.Kind = TraceKind.Begin;
                    traceRecord.Operator = operatorName;
                    traceRecord.Operation = operationName;
                    if (beginTrace != null)
                    {
                        beginTrace(traceRecord);
                    }
                });
            try
            {
                Task task = execute();

                // If the operation returned a null Task, we cannot do any
                // further tracing.  Return that null to the caller as
                // would happen if tracing were not enabled.
                if (task == null)
                {
                    return task;
                }

                return traceWriter.TraceBeginEndAsyncCore(request, category, level, operatorName, operationName, endTrace, errorTrace, task);
            }
            catch (Exception exception)
            {
                traceWriter.TraceError(exception, request, category, operatorName, operationName, errorTrace);
                throw;
            }
        }

        private static async Task TraceBeginEndAsyncCore(this ITraceWriter traceWriter,
            HttpRequestMessage request,
            string category,
            TraceLevel level,
            string operatorName,
            string operationName,
            Action<TraceRecord> endTrace,
            Action<TraceRecord> errorTrace,
            Task task)
        {
            try
            {
                await task;
                traceWriter.Trace(
                        request,
                        category,
                        level,
                        (TraceRecord traceRecord) =>
                        {
                            traceRecord.Kind = TraceKind.End;
                            traceRecord.Operator = operatorName;
                            traceRecord.Operation = operationName;
                            if (endTrace != null)
                            {
                                endTrace(traceRecord);
                            }
                        });
            }
            catch (OperationCanceledException)
            {
                traceWriter.Trace(
                        request,
                        category,
                        TraceLevel.Warn,
                        (TraceRecord traceRecord) =>
                        {
                            traceRecord.Kind = TraceKind.End;
                            traceRecord.Operator = operatorName;
                            traceRecord.Operation = operationName;
                            traceRecord.Message = SRResources.TraceCancelledMessage;
                            if (errorTrace != null)
                            {
                                errorTrace(traceRecord);
                            }
                        });

                throw;
            }
            catch (Exception exception)
            {
                traceWriter.TraceError(exception, request, category, operatorName, operationName, errorTrace);
                throw;
            }
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Warn"/> with the given message.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Warn(this ITraceWriter traceWriter, HttpRequestMessage request, string category, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Warn, messageFormat, messageArguments);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Warn"/> with the given <paramref name="exception"/>.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        public static void Warn(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception)
        {
            Trace(traceWriter, request, category, TraceLevel.Warn, exception);
        }

        /// <summary>
        /// Writes a <see cref="TraceRecord"/> at <see cref="TraceLevel.Warn"/> with the given message and exception.
        /// </summary>
        /// <param name="traceWriter">The <see cref="ITraceWriter"/></param>
        /// <param name="request">The <see cref="HttpRequestMessage"/> with which to correlate the request.  
        /// It may be null, but if so will not be correlated with any request.</param>
        /// <param name="category">The category for the trace.</param>
        /// <param name="exception">The exception to trace</param>
        /// <param name="messageFormat">The string to use to format a message.  It may not be null.</param>
        /// <param name="messageArguments">Optional list of arguments for the <paramref name="messageFormat"/>.</param>
        public static void Warn(this ITraceWriter traceWriter, HttpRequestMessage request, string category, Exception exception, string messageFormat, params object[] messageArguments)
        {
            Trace(traceWriter, request, category, TraceLevel.Warn, exception, messageFormat, messageArguments);
        }

        private static void TraceError(this ITraceWriter traceWriter, Exception exception, HttpRequestMessage request,
            string category, string operatorName, string operationName, Action<TraceRecord> errorTrace)
        {
            TraceLevel traceLevel = TraceWriterExceptionMapper.GetMappedTraceLevel(exception) ?? TraceLevel.Error;
            traceWriter.Trace(request, category, traceLevel, (traceRecord) =>
                {
                    traceRecord.Kind = TraceKind.End;
                    traceRecord.Operator = operatorName;
                    traceRecord.Operation = operationName;
                    traceRecord.Exception = exception;
                    TraceWriterExceptionMapper.TranslateHttpResponseException(traceRecord);
                    if (errorTrace != null)
                    {
                        errorTrace(traceRecord);
                    }
                });
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/TraceCategories.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Category names traced by the default tracing implementation.
    /// </summary>
    /// <remarks>
    /// The list of permitted category names is open-ended, and users may define their own.
    /// It is recommended that category names reflect the namespace of their
    /// respective area.  This prevents name conflicts and allows external
    /// logging tools to enable or disable tracing by namespace.
    /// </remarks>
    public static class TraceCategories
    {
        public static readonly string ActionCategory = "System.Web.Http.Action";
        public static readonly string ControllersCategory = "System.Web.Http.Controllers";
        public static readonly string FiltersCategory = "System.Web.Http.Filters";
        public static readonly string FormattingCategory = "System.Net.Http.Formatting";
        public static readonly string MessageHandlersCategory = "System.Web.Http.MessageHandlers";
        public static readonly string ModelBindingCategory = "System.Web.Http.ModelBinding";
        public static readonly string RequestCategory = "System.Web.Http.Request";
        public static readonly string RoutingCategory = "System.Web.Http.Routing";
    }
}


================================================
FILE: src/System.Web.Http/Tracing/TraceKind.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Describes the kind of <see cref="TraceRecord"/> for an individual trace operation.
    /// </summary>
    public enum TraceKind
    {
        /// <summary>
        /// Single trace, not part of a Begin/End trace pair
        /// </summary>
        Trace = 0,

        /// <summary>
        /// Trace marking the beginning of some operation.
        /// </summary>
        Begin,

        /// <summary>
        /// Trace marking the end of some operation.
        /// </summary>
        End,
    }
}


================================================
FILE: src/System.Web.Http/Tracing/TraceKindHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Tracing
{
    internal static class TraceKindHelper
    {
        public static bool IsDefined(TraceKind traceKind)
        {
            return traceKind == TraceKind.Trace ||
                   traceKind == TraceKind.Begin ||
                   traceKind == TraceKind.End;
        }

        public static void Validate(TraceKind value, string parameterValue)
        {
            if (!IsDefined(value))
            {
                throw Error.InvalidEnumArgument(parameterValue, (int)value, typeof(TraceKind));
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/TraceLevel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Available trace levels.
    /// </summary>
    /// <remarks>
    /// The interpretation of these levels is the responsibility of the
    /// <see cref="ITraceWriter"/> implementation.   The general convention is that
    /// enabling a particular trace level also enables all levels greater than or
    /// equal to it.  For example, tracing at <see cref="Warn"/> level would
    /// generally trace if the trace writer was enabled to trace at level <see cref="Info"/>.
    /// </remarks>
    public enum TraceLevel
    {
        /// <summary>
        /// Tracing is disabled
        /// </summary>
        Off = 0,

        /// <summary>
        /// Trace level for debugging traces
        /// </summary>
        Debug = 1,

        /// <summary>
        /// Trace level for informational traces
        /// </summary>
        Info = 2,

        /// <summary>
        /// Trace level for warning traces
        /// </summary>
        Warn = 3,

        /// <summary>
        /// Trace level for error traces
        /// </summary>
        Error = 4,

        /// <summary>
        /// Trace level for fatal traces
        /// </summary>
        Fatal = 5
    }
}


================================================
FILE: src/System.Web.Http/Tracing/TraceLevelHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Tracing
{
    internal static class TraceLevelHelper
    {
        public static bool IsDefined(TraceLevel traceLevel)
        {
            return traceLevel == TraceLevel.Off ||
                   traceLevel == TraceLevel.Debug ||
                   traceLevel == TraceLevel.Info ||
                   traceLevel == TraceLevel.Warn ||
                   traceLevel == TraceLevel.Error ||
                   traceLevel == TraceLevel.Fatal;
        }

        public static void Validate(TraceLevel value, string parameterValue)
        {
            if (!IsDefined(value))
            {
                throw Error.InvalidEnumArgument(parameterValue, (int)value, typeof(TraceLevel));
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/TraceManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Services;
using System.Web.Http.Tracing.Tracers;

namespace System.Web.Http.Tracing
{
    internal class TraceManager : ITraceManager
    {
        public void Initialize(HttpConfiguration configuration)
        {
            ITraceWriter traceWriter = configuration.Services.GetTraceWriter();
            if (traceWriter != null)
            {
                // Install tracers only when a custom trace writer has been registered
                CreateAllTracers(configuration, traceWriter);
            }
        }

        private static void CreateAllTracers(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            CreateActionInvokerTracer(configuration, traceWriter);
            CreateActionSelectorTracer(configuration, traceWriter);
            CreateActionValueBinderTracer(configuration, traceWriter);
            CreateContentNegotiatorTracer(configuration, traceWriter);
            CreateControllerActivatorTracer(configuration, traceWriter);
            CreateControllerSelectorTracer(configuration, traceWriter);
            CreateHttpControllerTypeResolverTracer(configuration, traceWriter);
            CreateMessageHandlerTracers(configuration, traceWriter);
            CreateMediaTypeFormatterTracers(configuration, traceWriter);
        }

        // Get services from the global config. These are normally per-controller services, but we're getting the global fallbacks.
        private static TService GetService<TService>(ServicesContainer services)
        {
            return (TService)services.GetService(typeof(TService));
        }

        private static void CreateActionInvokerTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            IHttpActionInvoker invoker = GetService<IHttpActionInvoker>(configuration.Services);
            if (invoker != null && !(invoker is HttpActionInvokerTracer))
            {
                HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(invoker, traceWriter);
                configuration.Services.Replace(typeof(IHttpActionInvoker), tracer);
            }
        }

        private static void CreateActionSelectorTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            IHttpActionSelector selector = GetService<IHttpActionSelector>(configuration.Services);
            if (selector != null && !(selector is HttpActionSelectorTracer))
            {
                HttpActionSelectorTracer tracer = new HttpActionSelectorTracer(selector, traceWriter);
                configuration.Services.Replace(typeof(IHttpActionSelector), tracer);
            }
        }

        private static void CreateActionValueBinderTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            IActionValueBinder binder = GetService<IActionValueBinder>(configuration.Services);
            if (binder != null && !(binder is ActionValueBinderTracer))
            {
                ActionValueBinderTracer tracer = new ActionValueBinderTracer(binder, traceWriter);
                configuration.Services.Replace(typeof(IActionValueBinder), tracer);
            }
        }

        private static void CreateContentNegotiatorTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            IContentNegotiator negotiator = configuration.Services.GetContentNegotiator();
            if (negotiator != null && !(negotiator is ContentNegotiatorTracer))
            {
                ContentNegotiatorTracer tracer = new ContentNegotiatorTracer(negotiator, traceWriter);
                configuration.Services.Replace(typeof(IContentNegotiator), tracer);
            }
        }

        private static void CreateControllerActivatorTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            IHttpControllerActivator activator = GetService<IHttpControllerActivator>(configuration.Services);
            if (activator != null && !(activator is HttpControllerActivatorTracer))
            {
                HttpControllerActivatorTracer tracer = new HttpControllerActivatorTracer(activator, traceWriter);
                configuration.Services.Replace(typeof(IHttpControllerActivator), tracer);
            }
        }

        private static void CreateControllerSelectorTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            IHttpControllerSelector controllerSelector = configuration.Services.GetHttpControllerSelector();
            if (controllerSelector != null && !(controllerSelector is HttpControllerSelectorTracer))
            {
                HttpControllerSelectorTracer tracer = new HttpControllerSelectorTracer(controllerSelector, traceWriter);
                configuration.Services.Replace(typeof(IHttpControllerSelector), tracer);
            }
        }

        private static void CreateHttpControllerTypeResolverTracer(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            DefaultHttpControllerTypeResolver resolver =
                configuration.Services.GetHttpControllerTypeResolver() as DefaultHttpControllerTypeResolver;
            if (resolver != null)
            {
                IHttpControllerTypeResolver tracer = new DefaultHttpControllerTypeResolverTracer(resolver, traceWriter);
                configuration.Services.Replace(typeof(IHttpControllerTypeResolver), tracer);
            }
        }

        private static void CreateMediaTypeFormatterTracers(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            for (int i = 0; i < configuration.Formatters.Count; i++)
            {
                MediaTypeFormatter formatter = configuration.Formatters[i];
                if (!(formatter is IFormatterTracer))
                {
                    configuration.Formatters[i] = MediaTypeFormatterTracer.CreateTracer(
                                                    configuration.Formatters[i],
                                                    traceWriter,
                                                    request: null);
                }
            }
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Will be disposed when pipeline is disposed.")]
        private static void CreateMessageHandlerTracers(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            int handlerCount = configuration.MessageHandlers.Count;

            // If message handlers have already been wired into the pipeline,
            // we do not install tracing message handlers. This scenario occurs
            // when initialization is attempted twice, such as per-controller configuration. 
            if (handlerCount > 0 && configuration.MessageHandlers[0].InnerHandler != null)
            {
                return;
            }

            // RequestMessageHandlerTracer will be the first tracer to get executed and each messageHandlerTracer
            // will execute before its respective handler. For the MessageHandlerTracers to be registered, 
            // the message handler list must be of the form:
            // requestMessageHandlerTracer
            // messageHandler1Tracer
            // messageHandler1
            // ...
            // ...
            // messageHandlerNTracer
            // messageHandlerN
            // Where "N" is a non-negative integer. That is, there could be zero or more pairs of handlers/tracers, plus a 
            // request tracer at the beginning. If the state does not match this pattern, the tracer list is recreated.
            if (!AreMessageHandlerTracersRegistered(configuration.MessageHandlers))
            {
                // Removing the MessageHandlerTracer and RequestMessageHandlerTracer in the reverse order.
                for (int i = handlerCount - 1; i >= 0; i--)
                {
                    if (configuration.MessageHandlers[i] is RequestMessageHandlerTracer || configuration.MessageHandlers[i] is MessageHandlerTracer)
                    {
                        configuration.MessageHandlers.RemoveAt(i);
                    }
                }
                handlerCount = configuration.MessageHandlers.Count;

                // Insert a tracing handler before each existing message handler (in execution order)
                for (int i = 0; i < handlerCount * 2; i += 2)
                {
                    DelegatingHandler innerHandler = configuration.MessageHandlers[i];
                    DelegatingHandler handlerTracer = new MessageHandlerTracer(innerHandler, traceWriter);
                    configuration.MessageHandlers.Insert(i, handlerTracer);
                }

                configuration.MessageHandlers.Insert(0, new RequestMessageHandlerTracer(traceWriter));
            }
        }

        private static bool AreMessageHandlerTracersRegistered(Collection<DelegatingHandler> messageHandlers)
        {
            int handlerCount = messageHandlers.Count;
            
            // if the handler count is zero, exit early.
            if (handlerCount == 0)
            {
                return false;
            }

            // if RequestMessageHandlerTracer is absent, exit early.
            if (!(messageHandlers[0] is RequestMessageHandlerTracer))
            {
                return false;
            }

            // Message handler list must be an odd number (2*N+1) for N message handlers.
            if (handlerCount % 2 != 1)
            {
                return false;
            }

            // Check if all odd positions have tracers and even positions have their corresponding handlers.
            for (int i = 2; i < handlerCount; i += 2)
            {
                DelegatingHandler tracer = messageHandlers[i - 1];
                DelegatingHandler messageHandler = messageHandlers[i];
                if (!(tracer is MessageHandlerTracer))
                {
                    return false;
                }

                DelegatingHandler innerHandler = Decorator.GetInner(tracer);
                if (innerHandler != messageHandler)
                {
                    return false;
                }
            }

            return true;
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/TraceRecord.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Http;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Data object used by <see cref="ITraceWriter"/> to record traces.
    /// </summary>
    [DebuggerDisplay("Category: {Category}, Operation: {Operation}, Level: {Level}, Kind: {Kind}")]
    public class TraceRecord
    {
        private TraceKind _traceKind;
        private TraceLevel _traceLevel;

        private Lazy<Dictionary<object, object>> _properties = new Lazy<Dictionary<object, object>>(
            () => new Dictionary<object, object>());

        public TraceRecord(HttpRequestMessage request, string category, TraceLevel level)
        {
            Timestamp = DateTime.UtcNow;
            Request = request;
            RequestId = request != null ? request.GetCorrelationId() : Guid.Empty;
            Category = category;
            Level = level;
        }

        /// <summary>
        /// Gets or sets the tracing category.
        /// </summary>
        public string Category { get; set; }

        /// <summary>
        /// Gets or sets the exception.
        /// </summary>
        public Exception Exception { get; set; }

        /// <summary>
        /// Gets or sets the kind of trace.
        /// </summary>
        public TraceKind Kind
        {
            get
            {
                return _traceKind;
            }
            set
            {
                TraceKindHelper.Validate(value, "value");
                _traceKind = value;
            }
        }

        /// <summary>
        /// Gets or sets the tracing level.
        /// </summary>
        public TraceLevel Level
        {
            get
            {
                return _traceLevel;
            }
            set
            {
                TraceLevelHelper.Validate(value, "value");
                _traceLevel = value;
            }
        }

        /// <summary>
        /// Gets or sets the message.
        /// </summary>
        public string Message { get; set; }

        /// <summary>
        /// Gets or sets the logical operation name being performed.
        /// </summary>
        public string Operation { get; set; }

        /// <summary>
        /// Gets or sets the logical name of the object performing the operation
        /// </summary>
        public string Operator { get; set; }

        /// <summary>
        /// Optional user-defined property bag.
        /// </summary>
        public Dictionary<object, object> Properties
        {
            get { return _properties.Value; }
        }

        /// <summary>
        /// Gets the <see cref="HttpRequestMessage"/>
        /// </summary>
        public HttpRequestMessage Request { get; private set; }

        /// <summary>
        /// Gets the correlation ID  from the <see cref="Request"/>.
        /// </summary>
        public Guid RequestId { get; private set; }

        /// <summary>
        /// Gets or sets the <see cref="HttpStatusCode"/> associated with the <see cref="HttpResponseMessage"/>.
        /// </summary>
        public HttpStatusCode Status { get; set; }

        /// <summary>
        /// Gets the <see cref="DateTime"/> of this trace (via <see cref="DateTime.UtcNow"/>)
        /// </summary>
        public DateTime Timestamp { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/ActionFilterAttributeTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="ActionFilterAttribute"/>.
    /// </summary>
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "internal type needs to override, tracer are not sealed")]
    internal class ActionFilterAttributeTracer : ActionFilterAttribute, IDecorator<ActionFilterAttribute>
    {
        private readonly ActionFilterAttribute _innerFilter;
        private readonly ITraceWriter _traceWriter;

        public ActionFilterAttributeTracer(ActionFilterAttribute innerFilter, ITraceWriter traceWriter)
        {
            Contract.Assert(innerFilter != null);
            Contract.Assert(traceWriter != null);

            _innerFilter = innerFilter;
            _traceWriter = traceWriter;
        }

        public ActionFilterAttribute Inner
        {
            get { return _innerFilter; }
        }

        public override bool AllowMultiple
        {
            get
            {
                return _innerFilter.AllowMultiple;
            }
        }

        public override object TypeId
        {
            get
            {
                return _innerFilter.TypeId;
            }
        }

        public override bool Equals(object obj)
        {
            return _innerFilter.Equals(obj);
        }

        public override int GetHashCode()
        {
            return _innerFilter.GetHashCode();
        }

        public override bool IsDefaultAttribute()
        {
            return _innerFilter.IsDefaultAttribute();
        }

        public override bool Match(object obj)
        {
            return _innerFilter.Match(obj);
        }

        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            // This will never get called, all the traces are going through OnActionExecutingAsync, which calls directly the inner method.
        }

        public override Task OnActionExecutedAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
        {
            return OnActionExecutedAsyncCore(actionExecutedContext, cancellationToken);
        }

        private Task OnActionExecutedAsyncCore(HttpActionExecutedContext actionExecutedContext,
                                               CancellationToken cancellationToken,
                                               [CallerMemberName] string methodName = null)
        {
            return _traceWriter.TraceBeginEndAsync(
                actionExecutedContext.Request,
                TraceCategories.FiltersCategory,
                TraceLevel.Info,
                _innerFilter.GetType().Name,
                methodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                                        SRResources.TraceActionFilterMessage,
                                        FormattingUtilities.ActionDescriptorToString(
                                            actionExecutedContext.ActionContext.ActionDescriptor));
                    tr.Exception = actionExecutedContext.Exception;
                    HttpResponseMessage response = actionExecutedContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                execute: async () =>
                {
                    await _innerFilter.OnActionExecutedAsync(actionExecutedContext, cancellationToken);
                },
                endTrace: (tr) =>
                {
                    tr.Exception = actionExecutedContext.Exception;
                    HttpResponseMessage response = actionExecutedContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: (tr) =>
                {
                    HttpResponseMessage response = actionExecutedContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                });
        }

        public override void OnActionExecuting(HttpActionContext actionContext)
        {
            // This will never get called, all the traces are going through OnActionExecutingAsync, which calls directly the inner method.
        }

        public override Task OnActionExecutingAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            return OnActionExecutingAsyncCore(actionContext, cancellationToken);
        }

        private Task OnActionExecutingAsyncCore(HttpActionContext actionContext,
                                                CancellationToken cancellationToken,
                                                [CallerMemberName] string methodName = null)
        {
            return _traceWriter.TraceBeginEndAsync(
                actionContext.Request,
                TraceCategories.FiltersCategory,
                TraceLevel.Info,
                _innerFilter.GetType().Name,
                methodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                                    SRResources.TraceActionFilterMessage,
                                    FormattingUtilities.ActionDescriptorToString(
                                        actionContext.ActionDescriptor));

                    HttpResponseMessage response = actionContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                execute: async () =>
                {
                    await _innerFilter.OnActionExecutingAsync(actionContext, cancellationToken);
                },
                endTrace: (tr) =>
                {
                    HttpResponseMessage response = actionContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: (tr) =>
                {
                    HttpResponseMessage response = actionContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                });
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/ActionFilterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IActionFilter"/>.
    /// </summary>
    internal class ActionFilterTracer : FilterTracer, IActionFilter, IDecorator<IActionFilter>
    {
        private const string ExecuteActionFilterAsyncMethodName = "ExecuteActionFilterAsync";

        public ActionFilterTracer(IActionFilter innerFilter, ITraceWriter traceWriter)
            : base(innerFilter, traceWriter)
        {
        }

        public new IActionFilter Inner
        {
            get { return InnerActionFilter; }
        }

        private IActionFilter InnerActionFilter
        {
            get { return InnerFilter as IActionFilter; }
        }

        Task<HttpResponseMessage> IActionFilter.ExecuteActionFilterAsync(HttpActionContext actionContext,
                                                                         CancellationToken cancellationToken,
                                                                         Func<Task<HttpResponseMessage>> continuation)
        {
            return TraceWriter.TraceBeginEndAsync<HttpResponseMessage>(
                actionContext.Request,
                TraceCategories.FiltersCategory,
                TraceLevel.Info,
                InnerActionFilter.GetType().Name,
                ExecuteActionFilterAsyncMethodName,
                beginTrace: null,
                execute: () => InnerActionFilter.ExecuteActionFilterAsync(actionContext, cancellationToken, continuation),
                endTrace: (tr, response) =>
                {
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/ActionValueBinderTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IActionValueBinder"/>
    /// </summary>
    internal class ActionValueBinderTracer : IActionValueBinder, IDecorator<IActionValueBinder>
    {
        private readonly IActionValueBinder _innerBinder;
        private readonly ITraceWriter _traceWriter;

        public ActionValueBinderTracer(IActionValueBinder innerBinder, ITraceWriter traceWriter)
        {
            Contract.Assert(innerBinder != null);
            Contract.Assert(traceWriter != null);

            _innerBinder = innerBinder;
            _traceWriter = traceWriter;
        }

        public IActionValueBinder Inner
        {
            get { return _innerBinder; }
        }

        // Creates wrapping tracers for all HttpParameterBindings
        HttpActionBinding IActionValueBinder.GetBinding(HttpActionDescriptor actionDescriptor)
        {
            HttpActionBinding actionBinding = _innerBinder.GetBinding(actionDescriptor);

            if (actionBinding == null)
            {
                return null;
            }

            HttpParameterBinding[] parameterBindings = actionBinding.ParameterBindings;
            HttpParameterBinding[] newParameterBindings = new HttpParameterBinding[parameterBindings.Length];
            for (int i = 0; i < newParameterBindings.Length; i++)
            {
                HttpParameterBinding parameterBinding = parameterBindings[i];

                // Intercept FormatterParameterBinding to replace its formatters
                FormatterParameterBinding formatterParameterBinding = parameterBinding as FormatterParameterBinding;
                newParameterBindings[i] = formatterParameterBinding != null
                                            ? (HttpParameterBinding)new FormatterParameterBindingTracer(formatterParameterBinding, _traceWriter)
                                            : (HttpParameterBinding)new HttpParameterBindingTracer(parameterBinding, _traceWriter);
            }

            // Replace the inner HttpActionBinding's parameter bindings with our tracing versions.
            // This allows each individual parameter binding to trace.
            actionBinding.ParameterBindings = newParameterBindings;

            // Then create an HttpActionBindingTracer to wrap the actual HttpActionBinding
            if (!(actionBinding is HttpActionBindingTracer))
            {
                return new HttpActionBindingTracer(actionBinding, _traceWriter);
            }

            return actionBinding;
        }
    }
}

================================================
FILE: src/System.Web.Http/Tracing/Tracers/AuthenticationFilterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Globalization;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>Represents a tracer for an <see cref="IAuthenticationFilter"/>.</summary>
    internal class AuthenticationFilterTracer : FilterTracer, IAuthenticationFilter, IDecorator<IAuthenticationFilter>
    {
        private const string AuthenticateAsyncMethodName = "AuthenticateAsync";
        private const string ChallengeAsyncMethodName = "ChallengeAsync";

        private readonly IAuthenticationFilter _innerFilter;

        public AuthenticationFilterTracer(IAuthenticationFilter innerFilter, ITraceWriter traceWriter)
            : base(innerFilter, traceWriter)
        {
            _innerFilter = innerFilter;
        }

        public new IAuthenticationFilter Inner
        {
            get { return _innerFilter; }
        }

        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            IPrincipal originalPrincipal = null;
            return TraceWriter.TraceBeginEndAsync(
                request: context != null ? context.Request : null,
                category: TraceCategories.FiltersCategory,
                level: TraceLevel.Info,
                operatorName: _innerFilter.GetType().Name,
                operationName: AuthenticateAsyncMethodName,
                beginTrace: (tr) =>
                {
                    if (context != null)
                    {
                        originalPrincipal = context.Principal;
                    }
                },
                execute: () => _innerFilter.AuthenticateAsync(context, cancellationToken),
                endTrace: (tr) =>
                {
                    if (context != null)
                    {
                        if (context.ErrorResult != null)
                        {
                            tr.Message = String.Format(CultureInfo.CurrentCulture,
                                SRResources.AuthenticationFilterErrorResult,
                                context.ErrorResult);
                        }
                        else if (context.Principal != originalPrincipal)
                        {
                            if (context.Principal == null || context.Principal.Identity == null)
                            {
                                tr.Message = SRResources.AuthenticationFilterSetPrincipalToUnknownIdentity;
                            }
                            else
                            {
                                tr.Message = String.Format(CultureInfo.CurrentCulture,
                                    SRResources.AuthenticationFilterSetPrincipalToKnownIdentity,
                                    context.Principal.Identity.Name,
                                    context.Principal.Identity.AuthenticationType);
                            }
                        }
                        else
                        {
                            tr.Message = SRResources.AuthenticationFilterDidNothing;
                        }
                    }
                },
                errorTrace: null);
        }

        public Task ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken)
        {
            return TraceWriter.TraceBeginEndAsync(
                request: context != null ? context.Request : null,
                category: TraceCategories.FiltersCategory,
                level: TraceLevel.Info,
                operatorName: _innerFilter.GetType().Name,
                operationName: ChallengeAsyncMethodName,
                beginTrace: null,
                execute: () => _innerFilter.ChallengeAsync(context, cancellationToken),
                endTrace: null,
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/AuthorizationFilterAttributeTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="AuthorizationFilterAttribute"/>
    /// </summary>
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "internal type needs to override, tracer are not sealed")]
    internal class AuthorizationFilterAttributeTracer : AuthorizationFilterAttribute, IDecorator<AuthorizationFilterAttribute>
    {
        private readonly AuthorizationFilterAttribute _innerFilter;
        private readonly ITraceWriter _traceStore;

        public AuthorizationFilterAttributeTracer(AuthorizationFilterAttribute innerFilter, ITraceWriter traceWriter)
        {
            Contract.Assert(innerFilter != null);
            Contract.Assert(traceWriter != null);

            _innerFilter = innerFilter;
            _traceStore = traceWriter;
        }

        public AuthorizationFilterAttribute Inner
        {
            get { return _innerFilter; }
        }

        public override bool AllowMultiple
        {
            get
            {
                return _innerFilter.AllowMultiple;
            }
        }

        public override object TypeId
        {
            get
            {
                return _innerFilter.TypeId;
            }
        }

        public override bool Equals(object obj)
        {
            return _innerFilter.Equals(obj);
        }

        public override int GetHashCode()
        {
            return _innerFilter.GetHashCode();
        }

        public override bool IsDefaultAttribute()
        {
            return _innerFilter.IsDefaultAttribute();
        }

        public override bool Match(object obj)
        {
            return _innerFilter.Match(obj);
        }

        public override void OnAuthorization(HttpActionContext actionContext)
        {
           // this will not trace, all traces go through the async call.
        }

        public override Task OnAuthorizationAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            return OnAuthorizationSyncCore(actionContext, cancellationToken);
        }

        private Task OnAuthorizationSyncCore(HttpActionContext actionContext,
                                             CancellationToken cancellationToken,
                                             [CallerMemberName] string methodName = null)
        {
            return _traceStore.TraceBeginEndAsync(
                actionContext.ControllerContext.Request,
                TraceCategories.FiltersCategory,
                TraceLevel.Info,
                _innerFilter.GetType().Name,
                methodName,
                beginTrace: (tr) =>
                {
                    HttpResponseMessage response = actionContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                execute: async () => { await _innerFilter.OnAuthorizationAsync(actionContext, cancellationToken); },
                endTrace: (tr) =>
                {
                    HttpResponseMessage response = actionContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: (tr) =>
                {
                    HttpResponseMessage response = actionContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                });
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/AuthorizationFilterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IAuthorizationFilter"/>.
    /// </summary>
    internal class AuthorizationFilterTracer : FilterTracer, IAuthorizationFilter, IDecorator<IAuthorizationFilter>
    {
        private const string ExecuteAuthorizationFilterAsyncMethodName = "ExecuteAuthorizationFilterAsync";

        public AuthorizationFilterTracer(IAuthorizationFilter innerFilter, ITraceWriter traceWriter)
            : base(innerFilter, traceWriter)
        {
        }

        public new IAuthorizationFilter Inner
        {
            get { return InnerAuthorizationFilter; }
        }

        private IAuthorizationFilter InnerAuthorizationFilter
        {
            get { return InnerFilter as IAuthorizationFilter; }
        }

        public Task<HttpResponseMessage> ExecuteAuthorizationFilterAsync(HttpActionContext actionContext,
                                                                         CancellationToken cancellationToken,
                                                                         Func<Task<HttpResponseMessage>> continuation)
        {
            return TraceWriter.TraceBeginEndAsync<HttpResponseMessage>(
                actionContext.Request,
                TraceCategories.FiltersCategory,
                TraceLevel.Info,
                InnerAuthorizationFilter.GetType().Name,
                ExecuteAuthorizationFilterAsyncMethodName,
                beginTrace: null,
                execute: () => InnerAuthorizationFilter.ExecuteAuthorizationFilterAsync(actionContext, cancellationToken, continuation),
                endTrace: (tr, response) =>
                {
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/BufferedMediaTypeFormatterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    internal class BufferedMediaTypeFormatterTracer : BufferedMediaTypeFormatter, IFormatterTracer, IDecorator<BufferedMediaTypeFormatter>
    {
        private const string OnReadFromStreamMethodName = "ReadFromStream";
        private const string OnWriteToStreamMethodName = "WriteToStream";

        private readonly BufferedMediaTypeFormatter _inner;
        private MediaTypeFormatterTracer _innerTracer;

        public BufferedMediaTypeFormatterTracer(BufferedMediaTypeFormatter innerFormatter, ITraceWriter traceWriter, HttpRequestMessage request)
            : base(innerFormatter)
        {
            _inner = innerFormatter;
            _innerTracer = new MediaTypeFormatterTracer(innerFormatter, traceWriter, request);
        }

        HttpRequestMessage IFormatterTracer.Request
        {
            get { return _innerTracer.Request; }
        }

        public BufferedMediaTypeFormatter Inner
        {
            get { return _inner; }
        }

        public MediaTypeFormatter InnerFormatter
        {
            get { return _innerTracer.InnerFormatter; }
        }

        public override IRequiredMemberSelector RequiredMemberSelector
        {
            get
            {
                return _innerTracer.RequiredMemberSelector;
            }
            set
            {
                _innerTracer.RequiredMemberSelector = value;
            }
        }

        public override bool CanReadType(Type type)
        {
            return _innerTracer.CanReadType(type);
        }

        public override bool CanWriteType(Type type)
        {
            return _innerTracer.CanWriteType(type);
        }

        public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
        {
            return _innerTracer.GetPerRequestFormatterInstance(type, request, mediaType);
        }

        public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType)
        {
            _innerTracer.SetDefaultContentHeaders(type, headers, mediaType);
        }

        public override object ReadFromStream(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger)
        {
            return ReadFromStreamCore(type, readStream, content, formatterLogger);
        }

        public override object ReadFromStream(Type type, Stream stream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return ReadFromStreamCore(type, stream, content, formatterLogger, cancellationToken);
        }

        private object ReadFromStreamCore(Type type, Stream stream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken? cancellationToken = null)
        {
            BufferedMediaTypeFormatter innerFormatter = InnerFormatter as BufferedMediaTypeFormatter;
            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
            MediaTypeHeaderValue contentType = contentHeaders == null ? null : contentHeaders.ContentType;
            object value = null;

            _innerTracer.TraceWriter.TraceBeginEnd(
                _innerTracer.Request,
                TraceCategories.FormattingCategory,
                TraceLevel.Info,
                _innerTracer.InnerFormatter.GetType().Name,
                OnReadFromStreamMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                            SRResources.TraceReadFromStreamMessage,
                            type.Name,
                            contentType == null ? SRResources.TraceNoneObjectMessage : contentType.ToString());
                },
                execute: () =>
                {
                    if (cancellationToken.HasValue)
                    {
                        value = innerFormatter.ReadFromStream(type, stream, content, formatterLogger, cancellationToken.Value);
                    }
                    else
                    {
                        value = innerFormatter.ReadFromStream(type, stream, content, formatterLogger);
                    }
                },
                endTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                                SRResources.TraceReadFromStreamValueMessage,
                                FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture));
                },
                errorTrace: null);

            return value;
        }

        public override void WriteToStream(Type type, object value, Stream writeStream, HttpContent content)
        {
            WriteToStreamCore(type, value, writeStream, content);
        }

        public override void WriteToStream(Type type, object value, Stream writeStream, HttpContent content,
            CancellationToken cancellationToken)
        {
            WriteToStreamCore(type, value, writeStream, content, cancellationToken);
        }

        private void WriteToStreamCore(Type type, object value, Stream writeStream, HttpContent content,
            CancellationToken? cancellationToken = null)
        {
            BufferedMediaTypeFormatter innerFormatter = InnerFormatter as BufferedMediaTypeFormatter;

            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
            MediaTypeHeaderValue contentType = contentHeaders == null
                           ? null
                           : contentHeaders.ContentType;

            _innerTracer.TraceWriter.TraceBeginEnd(
                _innerTracer.Request,
                TraceCategories.FormattingCategory,
                TraceLevel.Info,
                _innerTracer.InnerFormatter.GetType().Name,
                OnWriteToStreamMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                            SRResources.TraceWriteToStreamMessage,
                            FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture),
                            type.Name,
                            contentType == null ? SRResources.TraceNoneObjectMessage : contentType.ToString());
                },
                execute: () =>
                {
                    if (cancellationToken.HasValue)
                    {
                        innerFormatter.WriteToStream(type, value, writeStream, content, cancellationToken.Value);
                    }
                    else
                    {
                        innerFormatter.WriteToStream(type, value, writeStream, content);
                    }
                },
                endTrace: null,
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/ContentNegotiatorTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IContentNegotiator"/>.
    /// </summary>
    internal class ContentNegotiatorTracer : IContentNegotiator, IDecorator<IContentNegotiator>
    {
        private const string NegotiateMethodName = "Negotiate";

        private readonly IContentNegotiator _innerNegotiator;
        private readonly ITraceWriter _traceWriter;

        public ContentNegotiatorTracer(IContentNegotiator innerNegotiator, ITraceWriter traceWriter)
        {
            Contract.Assert(innerNegotiator != null);
            Contract.Assert(traceWriter != null);

            _innerNegotiator = innerNegotiator;
            _traceWriter = traceWriter;
        }

        public IContentNegotiator Inner
        {
            get { return _innerNegotiator; }
        }

        public ContentNegotiationResult Negotiate(Type type, HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
        {
            ContentNegotiationResult result = null;

            _traceWriter.TraceBeginEnd(
                request,
                TraceCategories.FormattingCategory,
                TraceLevel.Info,
                _innerNegotiator.GetType().Name,
                NegotiateMethodName,

                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                        SRResources.TraceNegotiateFormatter,
                        type.Name,
                        FormattingUtilities.FormattersToString(formatters));
                },

                execute: () =>
                {
                    result = _innerNegotiator.Negotiate(type, request, formatters);
                },

                endTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                        SRResources.TraceSelectedFormatter,
                        result == null
                            ? SRResources.TraceNoneObjectMessage
                            : MediaTypeFormatterTracer.ActualMediaTypeFormatter(result.Formatter).GetType().Name,
                        result == null || result.MediaType == null
                            ? SRResources.TraceNoneObjectMessage
                            : result.MediaType.ToString());
                },

                errorTrace: null);

            if (result != null)
            {
                result.Formatter = MediaTypeFormatterTracer.CreateTracer(result.Formatter, _traceWriter, request);
            }

            return result;
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/DefaultHttpControllerTypeResolverTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Reflection;
using System.Web.Http.Dispatcher;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Internal class to trace use of <see cref="DefaultHttpControllerTypeResolver"/>.
    /// </summary>
    internal class DefaultHttpControllerTypeResolverTracer
        : DefaultHttpControllerTypeResolver, IDecorator<DefaultHttpControllerTypeResolver>
    {
        private readonly DefaultHttpControllerTypeResolver _innerResolver;
        private readonly ITraceWriter _traceWriter;
        private readonly string _innerTypeName;

        public DefaultHttpControllerTypeResolverTracer(DefaultHttpControllerTypeResolver innerResolver,
            ITraceWriter traceWriter)
        {
            Contract.Assert(innerResolver != null);
            Contract.Assert(traceWriter != null);

            _innerResolver = innerResolver;
            _traceWriter = traceWriter;
            _innerTypeName = _innerResolver.GetType().Name;

            // Update inner resolver to call back here. Works around fact GetControllerTypes swallows exceptions and
            // improves tracing.
            _innerResolver.SetGetTypesFunc(GetTypesAndTrace);
        }

        public DefaultHttpControllerTypeResolver Inner
        {
            get { return _innerResolver; }
        }

        protected internal override Predicate<Type> IsControllerTypePredicate
        {
            get { return _innerResolver.IsControllerTypePredicate; }
        }

        // Trace beginning and end of GetControllerTypes() invocations. Error tracing should never occur since base
        // implementation swallows all exceptions.
        public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
        {
            ICollection<Type> result = null;
            _traceWriter.TraceBeginEnd(request: null,
                category: TraceCategories.ControllersCategory,
                level: TraceLevel.Debug,
                operatorName: _innerTypeName,
                operationName: "GetControllerTypes",
                beginTrace: null,
                execute: () => { result = _innerResolver.GetControllerTypes(assembliesResolver); },
                endTrace: null,
                errorTrace: null);

            return result;
        }

        // Warn about any exceptions encountered in GetTypes() invocations. Do not trace beginning or end since that
        // could be quite noisy.
        private Type[] GetTypesAndTrace(Assembly assembly)
        {
            try
            {
                return DefaultHttpControllerTypeResolver.GetTypes(assembly);
            }
            catch (Exception exception)
            {
                _traceWriter.Warn(request: null,
                    category: TraceCategories.ControllersCategory,
                    exception: exception,
                    messageFormat: SRResources.TraceHttpControllerTypeResolverError,
                    messageArguments: assembly.FullName);

                throw;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/ExceptionFilterAttributeTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Runtime.CompilerServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="ExceptionFilterAttribute"/>.
    /// </summary>
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "internal type needs to override, tracer are not sealed")]
    internal class ExceptionFilterAttributeTracer : ExceptionFilterAttribute, IDecorator<ExceptionFilterAttribute>
    {
        private readonly ExceptionFilterAttribute _innerFilter;
        private readonly ITraceWriter _traceStore;

        public ExceptionFilterAttributeTracer(ExceptionFilterAttribute innerFilter, ITraceWriter traceWriter)
        {
            Contract.Assert(innerFilter != null);
            Contract.Assert(traceWriter != null);

            _innerFilter = innerFilter;
            _traceStore = traceWriter;
        }

        public ExceptionFilterAttribute Inner
        {
            get { return _innerFilter; }
        }

        public override bool AllowMultiple
        {
            get
            {
                return _innerFilter.AllowMultiple;
            }
        }

        public override object TypeId
        {
            get
            {
                return _innerFilter.TypeId;
            }
        }

        public override bool Equals(object obj)
        {
            return _innerFilter.Equals(obj);
        }

        public override int GetHashCode()
        {
            return _innerFilter.GetHashCode();
        }

        public override bool IsDefaultAttribute()
        {
            return _innerFilter.IsDefaultAttribute();
        }

        public override bool Match(object obj)
        {
            return _innerFilter.Match(obj);
        }

        public override void OnException(HttpActionExecutedContext actionExecutedContext)
        {
           // this will not trace, all traces go through the async call.
        }

        public override Task OnExceptionAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
        {
            return OnExceptionAsyncCore(actionExecutedContext, cancellationToken);
        }

        private Task OnExceptionAsyncCore(HttpActionExecutedContext actionExecutedContext,
                                          CancellationToken cancellationToken,
                                          [CallerMemberName] string methodName = null)
        {
            return _traceStore.TraceBeginEndAsync(
                actionExecutedContext.Request,
                TraceCategories.FiltersCategory,
                TraceLevel.Info,
                _innerFilter.GetType().Name,
                methodName,
                beginTrace: (tr) =>
                {
                    HttpResponseMessage response = actionExecutedContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                execute: async () =>
                {
                    await _innerFilter.OnExceptionAsync(actionExecutedContext, cancellationToken);
                },
                endTrace: (tr) =>
                {
                    Exception returnedException = actionExecutedContext.Exception;
                    tr.Level = returnedException == null ? TraceLevel.Info : TraceLevel.Error;
                    tr.Exception = returnedException;
                    HttpResponseMessage response = actionExecutedContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: (tr) =>
                {
                    HttpResponseMessage response = actionExecutedContext.Response;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                });
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/ExceptionFilterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IExceptionFilter"/>.
    /// </summary>
    internal class ExceptionFilterTracer : FilterTracer, IExceptionFilter, IDecorator<IExceptionFilter>
    {
        private const string ExecuteExceptionFilterAsyncMethodName = "ExecuteExceptionFilterAsync";

        public ExceptionFilterTracer(IExceptionFilter innerFilter, ITraceWriter traceWriter)
            : base(innerFilter, traceWriter)
        {
        }

        public new IExceptionFilter Inner
        {
            get { return InnerExceptionFilter; }
        }

        public IExceptionFilter InnerExceptionFilter
        {
            get { return InnerFilter as IExceptionFilter; }
        }

        public Task ExecuteExceptionFilterAsync(HttpActionExecutedContext actionExecutedContext,
                                                CancellationToken cancellationToken)
        {
            return TraceWriter.TraceBeginEndAsync(
                actionExecutedContext.Request,
                TraceCategories.FiltersCategory,
                TraceLevel.Info,
                InnerExceptionFilter.GetType().Name,
                ExecuteExceptionFilterAsyncMethodName,
                beginTrace: (tr) =>
                {
                    tr.Exception = actionExecutedContext.Exception;
                },

                execute: () => InnerExceptionFilter.ExecuteExceptionFilterAsync(actionExecutedContext, cancellationToken),

                endTrace: (tr) =>
                {
                    tr.Exception = actionExecutedContext.Exception;
                },

                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/FilterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Web.Http.Filters;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Base class and helper for the creation of filter tracers.
    /// </summary>
    internal class FilterTracer : IFilter, IDecorator<IFilter>
    {
        public FilterTracer(IFilter innerFilter, ITraceWriter traceWriter)
        {
            Contract.Assert(innerFilter != null);
            Contract.Assert(traceWriter != null);

            InnerFilter = innerFilter;
            TraceWriter = traceWriter;
        }

        public IFilter Inner
        {
            get { return InnerFilter; }
        }

        public IFilter InnerFilter { get; set; }

        public ITraceWriter TraceWriter { get; set; }

        public bool AllowMultiple
        {
            get { return InnerFilter.AllowMultiple; }
        }

        public static IEnumerable<IFilter> CreateFilterTracers(IFilter filter, ITraceWriter traceWriter)
        {
            List<IFilter> filters = new List<IFilter>();
            bool addedActionAttributeTracer = false;
            bool addedAuthorizationAttributeTracer = false;
            bool addedExceptionAttributeTracer = false;

            ActionFilterAttribute actionFilterAttribute = filter as ActionFilterAttribute;
            if (actionFilterAttribute != null)
            {
                filters.Add(new ActionFilterAttributeTracer(actionFilterAttribute, traceWriter));
                addedActionAttributeTracer = true;
            }

            AuthorizationFilterAttribute authorizationFilterAttribute = filter as AuthorizationFilterAttribute;
            if (authorizationFilterAttribute != null)
            {
                filters.Add(new AuthorizationFilterAttributeTracer(authorizationFilterAttribute, traceWriter));
                addedAuthorizationAttributeTracer = true;
            }

            ExceptionFilterAttribute exceptionFilterAttribute = filter as ExceptionFilterAttribute;
            if (exceptionFilterAttribute != null)
            {
                filters.Add(new ExceptionFilterAttributeTracer(exceptionFilterAttribute, traceWriter));
                addedExceptionAttributeTracer = true;
            }

            // Do not add an IActionFilter tracer if we already added an ActionFilterAttribute tracer
            IActionFilter actionFilter = filter as IActionFilter;
            if (actionFilter != null && !addedActionAttributeTracer)
            {
                filters.Add(new ActionFilterTracer(actionFilter, traceWriter));
            }

            // Do not add an IAuthorizationFilter tracer if we already added an AuthorizationFilterAttribute tracer
            IAuthorizationFilter authorizationFilter = filter as IAuthorizationFilter;
            if (authorizationFilter != null && !addedAuthorizationAttributeTracer)
            {
                filters.Add(new AuthorizationFilterTracer(authorizationFilter, traceWriter));
            }

            IAuthenticationFilter authenticationFilter = filter as IAuthenticationFilter;
            if (authenticationFilter != null)
            {
                filters.Add(new AuthenticationFilterTracer(authenticationFilter, traceWriter));
            }

            // Do not add an IExceptionFilter tracer if we already added an ExceptoinFilterAttribute tracer
            IExceptionFilter exceptionFilter = filter as IExceptionFilter;
            if (exceptionFilter != null && !addedExceptionAttributeTracer)
            {
                filters.Add(new ExceptionFilterTracer(exceptionFilter, traceWriter));
            }

            IOverrideFilter overrideFilter = filter as IOverrideFilter;
            if (overrideFilter != null)
            {
                filters.Add(new OverrideFilterTracer(overrideFilter, traceWriter));
            }

            if (filters.Count == 0)
            {
                filters.Add(new FilterTracer(filter, traceWriter));
            }
            
            return filters;
        }

        public static IEnumerable<FilterInfo> CreateFilterTracers(FilterInfo filter, ITraceWriter traceWriter)
        {
            IFilter filterInstance = filter.Instance;
            IEnumerable<IFilter> filterTracers = CreateFilterTracers(filterInstance, traceWriter);
            List<FilterInfo> filters = new List<FilterInfo>();
            foreach (IFilter filterTracer in filterTracers)
            {
                filters.Add(new FilterInfo(filterTracer, filter.Scope));
            }

            return filters;
        }

        public static bool IsFilterTracer(IFilter filter)
        {
            return filter is FilterTracer ||
                   filter is ActionFilterAttributeTracer ||
                   filter is AuthorizationFilterAttributeTracer ||
                   filter is ExceptionFilterAttributeTracer;
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/FormUrlEncodedMediaTypeFormatterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="FormUrlEncodedMediaTypeFormatter"/>.  
    /// It is required because users can select formatters by this type.
    /// </summary>
    internal class FormUrlEncodedMediaTypeFormatterTracer : FormUrlEncodedMediaTypeFormatter, IFormatterTracer, IDecorator<FormUrlEncodedMediaTypeFormatter>
    {
        private readonly FormUrlEncodedMediaTypeFormatter _inner;
        private MediaTypeFormatterTracer _innerTracer;

        public FormUrlEncodedMediaTypeFormatterTracer(FormUrlEncodedMediaTypeFormatter innerFormatter, ITraceWriter traceWriter, HttpRequestMessage request)
            : base(innerFormatter)
        {
            _inner = innerFormatter;
            _innerTracer = new MediaTypeFormatterTracer(innerFormatter, traceWriter, request);
        }

        HttpRequestMessage IFormatterTracer.Request
        {
            get { return _innerTracer.Request; }
        }

        public FormUrlEncodedMediaTypeFormatter Inner
        {
            get { return _inner; }
        }

        public MediaTypeFormatter InnerFormatter
        {
            get { return _innerTracer.InnerFormatter; }
        }

        public override IRequiredMemberSelector RequiredMemberSelector
        {
            get
            {
                return _innerTracer.RequiredMemberSelector;
            }
            set
            {
                _innerTracer.RequiredMemberSelector = value;
            }
        }

        public override bool CanReadType(Type type)
        {
            return _innerTracer.CanReadType(type);
        }

        public override bool CanWriteType(Type type)
        {
            return _innerTracer.CanWriteType(type);
        }

        public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
        {
            return _innerTracer.GetPerRequestFormatterInstance(type, request, mediaType);
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return _innerTracer.ReadFromStreamAsync(type, readStream, content, formatterLogger, cancellationToken);
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            return _innerTracer.ReadFromStreamAsync(type, readStream, content, formatterLogger);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            return _innerTracer.WriteToStreamAsync(type, value, writeStream, content, transportContext, cancellationToken);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
        {
            return _innerTracer.WriteToStreamAsync(type, value, writeStream, content, transportContext);
        }

        public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType)
        {
            _innerTracer.SetDefaultContentHeaders(type, headers, mediaType);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/FormatterLoggerTraceWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Net.Http.Formatting;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// FormatterLogger to trace an error while logging.
    /// </summary>
    internal class FormatterLoggerTraceWrapper : IFormatterLogger
    {
        private readonly IFormatterLogger _formatterLogger;
        private readonly ITraceWriter _traceWriter;
        private readonly HttpRequestMessage _request;
        private readonly string _operatorName;
        private readonly string _operationName;

        public FormatterLoggerTraceWrapper(IFormatterLogger formatterLogger,
                                           ITraceWriter traceWriter,
                                           HttpRequestMessage request,
                                           string operatorName,
                                           string operationName)
        {
            Contract.Assert(formatterLogger != null);
            Contract.Assert(traceWriter != null);

            _formatterLogger = formatterLogger;
            _traceWriter = traceWriter;
            _request = request;
            _operatorName = operatorName;
            _operationName = operationName;
        }

        public void LogError(string errorPath, string errorMessage)
        {
            _traceWriter.Trace(_request, TraceCategories.FormattingCategory, TraceLevel.Error, (traceRecord) =>
                {
                    traceRecord.Kind = TraceKind.Trace;
                    traceRecord.Operator = _operatorName;
                    traceRecord.Operation = _operationName;
                    traceRecord.Message = errorMessage;
                });
            _formatterLogger.LogError(errorPath, errorMessage);
        }

        public void LogError(string errorPath, Exception exception)
        {
            _traceWriter.Trace(_request, TraceCategories.FormattingCategory, TraceLevel.Error, (traceRecord) =>
                {
                    traceRecord.Kind = TraceKind.Trace;
                    traceRecord.Operator = _operatorName;
                    traceRecord.Operation = _operationName;
                    traceRecord.Exception = exception;
                });
            _formatterLogger.LogError(errorPath, exception);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/FormatterParameterBindingTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer to wrap a <see cref="FormatterParameterBinding"/>.
    /// Its primary purpose is to intercept binding requests so that it can create tracers for the formatters.
    /// </summary>
    internal class FormatterParameterBindingTracer : FormatterParameterBinding, IDecorator<FormatterParameterBinding>
    {
        private const string ExecuteBindingAsyncMethodName = "ExecuteBindingAsync";

        private readonly FormatterParameterBinding _innerBinding;
        private readonly ITraceWriter _traceWriter;

        public FormatterParameterBindingTracer(FormatterParameterBinding innerBinding, ITraceWriter traceWriter)
            : base(innerBinding.Descriptor, innerBinding.Formatters, innerBinding.BodyModelValidator)
        {
            Contract.Assert(innerBinding != null);
            Contract.Assert(traceWriter != null);

            _innerBinding = innerBinding;
            _traceWriter = traceWriter;
        }

        public FormatterParameterBinding Inner
        {
            get { return _innerBinding; }
        }

        public override string ErrorMessage
        {
            get { return _innerBinding.ErrorMessage; }
        }

        public override bool WillReadBody
        {
            get { return _innerBinding.WillReadBody; }
        }

        public override Task<object> ReadContentAsync(HttpRequestMessage request, Type type,
            IEnumerable<MediaTypeFormatter> formatters, IFormatterLogger formatterLogger)
        {
            // Intercept this method solely to wrap formatters with request-aware formatter tracers
            // There is no other interception point where a request and a formatter are paired.
            return _innerBinding.ReadContentAsync(request, type, CreateFormatterTracers(request, formatters), formatterLogger);
        }

        public override Task<object> ReadContentAsync(HttpRequestMessage request, Type type,
            IEnumerable<MediaTypeFormatter> formatters, IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return _innerBinding.ReadContentAsync(request, type, formatters, formatterLogger, cancellationToken);
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext,
            CancellationToken cancellationToken)
        {
            return _traceWriter.TraceBeginEndAsync(
                actionContext.Request,
                TraceCategories.ModelBindingCategory,
                TraceLevel.Info,
                _innerBinding.GetType().Name,
                ExecuteBindingAsyncMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(SRResources.TraceBeginParameterBind,
                                              _innerBinding.Descriptor.ParameterName);
                },

                execute: () => _innerBinding.ExecuteBindingAsync(metadataProvider, actionContext, cancellationToken),

                endTrace: (tr) =>
                {
                    string parameterName = _innerBinding.Descriptor.ParameterName;
                    tr.Message = actionContext.ActionArguments.ContainsKey(parameterName)
                                    ? Error.Format(SRResources.TraceEndParameterBind, parameterName,
                                                    FormattingUtilities.ValueToString(actionContext.ActionArguments[parameterName], CultureInfo.CurrentCulture))
                                    : Error.Format(SRResources.TraceEndParameterBindNoBind,
                                                    parameterName);
                },
                errorTrace: null);
        }

        private IEnumerable<MediaTypeFormatter> CreateFormatterTracers(HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
        {
            List<MediaTypeFormatter> formatterTracers = new List<MediaTypeFormatter>();
            foreach (MediaTypeFormatter formatter in formatters)
            {
                formatterTracers.Add(MediaTypeFormatterTracer.CreateTracer(formatter, _traceWriter, request));
            }

            return formatterTracers;
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpActionBindingTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    internal class HttpActionBindingTracer : HttpActionBinding, IDecorator<HttpActionBinding>
    {
        private const string ExecuteBindingAsyncMethodName = "ExecuteBindingAsync";

        private readonly HttpActionBinding _innerBinding;
        private readonly ITraceWriter _traceWriter;

        public HttpActionBindingTracer(HttpActionBinding innerBinding, ITraceWriter traceWriter)
        {
            Contract.Assert(innerBinding != null);
            Contract.Assert(traceWriter != null);

            _innerBinding = innerBinding;
            _traceWriter = traceWriter;

            // Properties that cannot be delegated to the inner must be replicated.
            // They must also avoid an ArgumentNullException for null values.
            if (_innerBinding.ParameterBindings != null)
            {
                ParameterBindings = _innerBinding.ParameterBindings;
            }

            if (_innerBinding.ActionDescriptor != null)
            {
                ActionDescriptor = _innerBinding.ActionDescriptor;
            }
        }

        public HttpActionBinding Inner
        {
            get { return _innerBinding; }
        }

        public override Task ExecuteBindingAsync(Controllers.HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            return _traceWriter.TraceBeginEndAsync(
                actionContext.ControllerContext.Request,
                TraceCategories.ModelBindingCategory,
                TraceLevel.Info,
                _innerBinding.GetType().Name,
                ExecuteBindingAsyncMethodName,
                beginTrace: null,
                execute: () => _innerBinding.ExecuteBindingAsync(actionContext, cancellationToken),
                endTrace: (tr) =>
                {
                    if (!actionContext.ModelState.IsValid)
                    {
                        tr.Message = Error.Format(SRResources.TraceModelStateInvalidMessage,
                                                  FormattingUtilities.ModelStateToString(
                                                        actionContext.ModelState));
                    }
                    else
                    {
                        if (actionContext.ActionDescriptor.GetParameters().Count > 0)
                        {
                            tr.Message = Error.Format(SRResources.TraceValidModelState,
                                                      FormattingUtilities.ActionArgumentsToString(
                                                            actionContext.ActionArguments));
                        }
                    }
                },
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpActionDescriptorTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="HttpActionDescriptor"/>.
    /// </summary>
    internal class HttpActionDescriptorTracer : HttpActionDescriptor, IDecorator<HttpActionDescriptor>
    {
        private const string ExecuteMethodName = "ExecuteAsync";

        private readonly HttpActionDescriptor _innerDescriptor;
        private readonly ITraceWriter _traceWriter;

        public HttpActionDescriptorTracer(HttpControllerContext controllerContext, HttpActionDescriptor innerDescriptor, ITraceWriter traceWriter)
            : base(controllerContext.ControllerDescriptor)
        {
            Contract.Assert(innerDescriptor != null);
            Contract.Assert(traceWriter != null);

            _innerDescriptor = innerDescriptor;
            _traceWriter = traceWriter;
        }

        public HttpActionDescriptor Inner
        {
            get { return _innerDescriptor; }
        }

        public override ConcurrentDictionary<object, object> Properties
        {
            get
            {
                return _innerDescriptor.Properties;
            }
        }

        public override HttpActionBinding ActionBinding
        {
            get
            {
                return _innerDescriptor.ActionBinding;
            }
            set
            {
                _innerDescriptor.ActionBinding = value;
            }
        }

        public override Collection<HttpMethod> SupportedHttpMethods
        {
            get
            {
                return _innerDescriptor.SupportedHttpMethods;
            }
        }

        public override string ActionName
        {
            get { return _innerDescriptor.ActionName; }
        }

        public override IActionResultConverter ResultConverter
        {
            get { return _innerDescriptor.ResultConverter; }
        }

        public override Type ReturnType
        {
            get { return _innerDescriptor.ReturnType; }
        }

        public override Task<object> ExecuteAsync(HttpControllerContext controllerContext, IDictionary<string, object> arguments, CancellationToken cancellationToken)
        {
            return _traceWriter.TraceBeginEndAsync<object>(
                controllerContext.Request,
                TraceCategories.ActionCategory,
                TraceLevel.Info,
                _innerDescriptor.GetType().Name,
                ExecuteMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(SRResources.TraceInvokingAction,
                                              FormattingUtilities.ActionInvokeToString(ActionName, arguments));
                },
                execute: () =>
                {
                    return _innerDescriptor.ExecuteAsync(controllerContext, arguments, cancellationToken);
                },
                endTrace: (tr, value) =>
                {
                    tr.Message = Error.Format(SRResources.TraceActionReturnValue,
                                              FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture));
                },
                errorTrace: null);
        }

        public override Collection<T> GetCustomAttributes<T>()
        {
            return _innerDescriptor.GetCustomAttributes<T>();
        }

        public override Collection<T> GetCustomAttributes<T>(bool inherit)
        {
            return _innerDescriptor.GetCustomAttributes<T>(inherit);
        }

        public override Collection<IFilter> GetFilters()
        {
            List<IFilter> filters = new List<IFilter>(_innerDescriptor.GetFilters());
            List<IFilter> returnFilters = new List<IFilter>(filters.Count);
            for (int i = 0; i < filters.Count; i++)
            {
                if (FilterTracer.IsFilterTracer(filters[i]))
                {
                    returnFilters.Add(filters[i]);
                }
                else
                {
                    IEnumerable<IFilter> filterTracers = FilterTracer.CreateFilterTracers(filters[i], _traceWriter);
                    foreach (IFilter filterTracer in filterTracers)
                    {
                        returnFilters.Add(filterTracer);
                    }
                }
            }

            return new Collection<IFilter>(returnFilters);
        }

        public override Collection<FilterInfo> GetFilterPipeline()
        {
            List<FilterInfo> filters = new List<FilterInfo>(_innerDescriptor.GetFilterPipeline());
            List<FilterInfo> returnFilters = new List<FilterInfo>(filters.Count);
            for (int i = 0; i < filters.Count; i++)
            {
                // If this filter has been wrapped already, use as is
                if (FilterTracer.IsFilterTracer(filters[i].Instance))
                {
                    returnFilters.Add(filters[i]);
                }
                else
                {
                    IEnumerable<FilterInfo> filterTracers = FilterTracer.CreateFilterTracers(filters[i], _traceWriter);
                    foreach (FilterInfo filterTracer in filterTracers)
                    {
                        returnFilters.Add(filterTracer);
                    }
                }
            }

            return new Collection<FilterInfo>(returnFilters);
        }

        public override Collection<HttpParameterDescriptor> GetParameters()
        {
            return _innerDescriptor.GetParameters();
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpActionInvokerTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IHttpActionInvoker"/>.
    /// </summary>
    internal class HttpActionInvokerTracer : IHttpActionInvoker, IDecorator<IHttpActionInvoker>
    {
        private const string InvokeActionAsyncMethodName = "InvokeActionAsync";

        private readonly IHttpActionInvoker _innerInvoker;
        private readonly ITraceWriter _traceWriter;

        public HttpActionInvokerTracer(IHttpActionInvoker innerInvoker, ITraceWriter traceWriter)
        {
            Contract.Assert(innerInvoker != null);
            Contract.Assert(traceWriter != null);

            _innerInvoker = innerInvoker;
            _traceWriter = traceWriter;
        }

        public IHttpActionInvoker Inner
        {
            get { return _innerInvoker; }
        }

        Task<HttpResponseMessage> IHttpActionInvoker.InvokeActionAsync(HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            if (actionContext == null)
            {
                throw new ArgumentNullException("actionContext");
            }

            return _traceWriter.TraceBeginEndAsync<HttpResponseMessage>(
                actionContext.ControllerContext.Request,
                TraceCategories.ActionCategory,
                TraceLevel.Info,
                _innerInvoker.GetType().Name,
                InvokeActionAsyncMethodName,

                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                        SRResources.TraceActionInvokeMessage,
                        FormattingUtilities.ActionInvokeToString(actionContext));
                },

                execute: () => (Task<HttpResponseMessage>)_innerInvoker.InvokeActionAsync(actionContext, cancellationToken),

                endTrace: (tr, result) =>
                {
                    HttpResponseMessage response = result;
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },

                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpActionSelectorTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IHttpActionSelector"/>.
    /// </summary>
    internal class HttpActionSelectorTracer : IHttpActionSelector, IDecorator<IHttpActionSelector>
    {
        private const string SelectActionMethodName = "SelectAction";

        private readonly IHttpActionSelector _innerSelector;
        private readonly ITraceWriter _traceWriter;

        public HttpActionSelectorTracer(IHttpActionSelector innerSelector, ITraceWriter traceWriter)
        {
            Contract.Assert(innerSelector != null);
            Contract.Assert(traceWriter != null);

            _innerSelector = innerSelector;
            _traceWriter = traceWriter;
        }

        public IHttpActionSelector Inner
        {
            get { return _innerSelector; }
        }

        public ILookup<string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor)
        {
            return _innerSelector.GetActionMapping(controllerDescriptor);
        }

        HttpActionDescriptor IHttpActionSelector.SelectAction(HttpControllerContext controllerContext)
        {
            HttpActionDescriptor actionDescriptor = null;

            _traceWriter.TraceBeginEnd(
                    controllerContext.Request,
                    TraceCategories.ActionCategory,
                    TraceLevel.Info,
                    _innerSelector.GetType().Name,
                    SelectActionMethodName,
                    beginTrace: null,
                    execute: () => { actionDescriptor = _innerSelector.SelectAction(controllerContext); },
                    endTrace: (tr) =>
                    {
                        tr.Message = Error.Format(
                            SRResources.TraceActionSelectedMessage,
                            FormattingUtilities.ActionDescriptorToString(actionDescriptor));
                    },

                    errorTrace: null);

            // Intercept returned HttpActionDescriptor with a tracing version
            if (actionDescriptor != null && !(actionDescriptor is HttpActionDescriptorTracer))
            {
                return new HttpActionDescriptorTracer(controllerContext, actionDescriptor, _traceWriter);
            }

            return actionDescriptor;
        }
    }
}

================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpControllerActivatorTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IHttpControllerActivator"/>.
    /// </summary>
    internal class HttpControllerActivatorTracer : IHttpControllerActivator, IDecorator<IHttpControllerActivator>
    {
        private const string CreateMethodName = "Create";

        private readonly IHttpControllerActivator _innerActivator;
        private readonly ITraceWriter _traceWriter;

        public HttpControllerActivatorTracer(IHttpControllerActivator innerActivator, ITraceWriter traceWriter)
        {
            Contract.Assert(innerActivator != null);
            Contract.Assert(traceWriter != null);

            _innerActivator = innerActivator;
            _traceWriter = traceWriter;
        }

        public IHttpControllerActivator Inner
        {
            get { return _innerActivator; }
        }

        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "disposable controller is later released in ReleaseController")]
        IHttpController IHttpControllerActivator.Create(HttpRequestMessage request, HttpControllerDescriptor controllerDescriptor, Type controllerType)
        {
            IHttpController controller = null;

            _traceWriter.TraceBeginEnd(
                request,
                TraceCategories.ControllersCategory,
                TraceLevel.Info,
                _innerActivator.GetType().Name,
                CreateMethodName,
                beginTrace: null,
                execute: () =>
                {
                    controller = _innerActivator.Create(request, controllerDescriptor, controllerType);
                },
                endTrace: (tr) =>
                {
                    tr.Message = controller == null ? SRResources.TraceNoneObjectMessage : controller.GetType().FullName;
                },
                errorTrace: null);

            if (controller != null && !(controller is HttpControllerTracer))
            {
                controller = new HttpControllerTracer(request, controller, _traceWriter);
            }

            return controller;
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpControllerDescriptorTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref=" HttpControllerDescriptor"/>
    /// </summary>
    internal class HttpControllerDescriptorTracer : HttpControllerDescriptor, IDecorator<HttpControllerDescriptor>
    {
        private const string CreateControllerMethodName = "CreateController";

        private readonly HttpControllerDescriptor _innerDescriptor;
        private readonly ITraceWriter _traceWriter;

        public HttpControllerDescriptorTracer(HttpControllerDescriptor innerDescriptor, ITraceWriter traceWriter)
        {
            Contract.Assert(innerDescriptor != null);
            Contract.Assert(traceWriter != null);

            Configuration = innerDescriptor.Configuration;
            ControllerName = innerDescriptor.ControllerName;
            ControllerType = innerDescriptor.ControllerType;

            _innerDescriptor = innerDescriptor;
            _traceWriter = traceWriter;
        }

        public HttpControllerDescriptor Inner
        {
            get { return _innerDescriptor; }
        }

        public override ConcurrentDictionary<object, object> Properties
        {
            get
            {
                return _innerDescriptor.Properties;
            }
        }

        public override Collection<T> GetCustomAttributes<T>()
        {
            return _innerDescriptor.GetCustomAttributes<T>();
        }

        public override Collection<T> GetCustomAttributes<T>(bool inherit)
        {
            return _innerDescriptor.GetCustomAttributes<T>(inherit);
        }

        public override Collection<Filters.IFilter> GetFilters()
        {
            return _innerDescriptor.GetFilters();
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "This object is returned back to the caller")]
        public override IHttpController CreateController(HttpRequestMessage request)
        {
            IHttpController controller = null;

            _traceWriter.TraceBeginEnd(
                request,
                TraceCategories.ControllersCategory,
                TraceLevel.Info,
                _innerDescriptor.GetType().Name,
                CreateControllerMethodName,
                beginTrace: null,
                execute: () =>
                {
                    controller = _innerDescriptor.CreateController(request);
                },
                endTrace: (tr) =>
                {
                    tr.Message = controller == null
                                        ? SRResources.TraceNoneObjectMessage
                                        : HttpControllerTracer.ActualControllerType(controller).FullName;
                },
                errorTrace: null);

            if (controller != null && !(controller is HttpControllerTracer))
            {
                return new HttpControllerTracer(request, controller, _traceWriter);
            }

            return controller;
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpControllerSelectorTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IHttpControllerSelector"/>.
    /// </summary>
    internal class HttpControllerSelectorTracer : IHttpControllerSelector, IDecorator<IHttpControllerSelector>
    {
        private const string SelectControllerMethodName = "SelectController";

        private readonly IHttpControllerSelector _innerSelector;
        private readonly ITraceWriter _traceWriter;

        public HttpControllerSelectorTracer(IHttpControllerSelector innerSelector, ITraceWriter traceWriter)
        {
            Contract.Assert(innerSelector != null);
            Contract.Assert(traceWriter != null);

            _innerSelector = innerSelector;
            _traceWriter = traceWriter;
        }

        public IHttpControllerSelector Inner
        {
            get { return _innerSelector; }
        }

        HttpControllerDescriptor IHttpControllerSelector.SelectController(HttpRequestMessage request)
        {
            HttpControllerDescriptor controllerDescriptor = null;

            _traceWriter.TraceBeginEnd(
                request,
                TraceCategories.ControllersCategory,
                TraceLevel.Info,
                _innerSelector.GetType().Name,
                SelectControllerMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                                    SRResources.TraceRouteMessage,
                                    FormattingUtilities.RouteToString(request.GetRouteData()));
                },
                execute: () =>
                {
                    controllerDescriptor = _innerSelector.SelectController(request);
                },
                endTrace: (tr) =>
                {
                    tr.Message = controllerDescriptor == null
                                        ? SRResources.TraceNoneObjectMessage
                                        : controllerDescriptor.ControllerName;
                },
                errorTrace: null);

            if (controllerDescriptor != null && !(controllerDescriptor is HttpControllerDescriptorTracer))
            {
                return new HttpControllerDescriptorTracer(controllerDescriptor, _traceWriter);
            }

            return controllerDescriptor;
        }

        IDictionary<string, HttpControllerDescriptor> IHttpControllerSelector.GetControllerMapping()
        {
            return _innerSelector.GetControllerMapping();
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpControllerTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="IHttpController"/>.
    /// </summary>
    internal class HttpControllerTracer : IHttpController, IDisposable, IDecorator<IHttpController>
    {
        private const string DisposeMethodName = "Dispose";
        private const string ExecuteAsyncMethodName = "ExecuteAsync";

        private readonly IHttpController _innerController;
        private readonly HttpRequestMessage _request;
        private readonly ITraceWriter _traceWriter;

        public HttpControllerTracer(HttpRequestMessage request, IHttpController innerController, ITraceWriter traceWriter)
        {
            Contract.Assert(innerController != null);
            Contract.Assert(traceWriter != null);

            _innerController = innerController;
            _request = request;
            _traceWriter = traceWriter;
        }

        public IHttpController Inner
        {
            get { return _innerController; }
        }

        void IDisposable.Dispose()
        {
            IDisposable disposable = _innerController as IDisposable;
            if (disposable != null)
            {
                _traceWriter.TraceBeginEnd(
                    _request,
                    TraceCategories.ControllersCategory,
                    TraceLevel.Info,
                    _innerController.GetType().Name,
                    DisposeMethodName,
                    beginTrace: null,
                    execute: disposable.Dispose,
                    endTrace: null,
                    errorTrace: null);
            }
        }

        Task<HttpResponseMessage> IHttpController.ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
        {
            return _traceWriter.TraceBeginEndAsync<HttpResponseMessage>(
                controllerContext.Request,
                TraceCategories.ControllersCategory,
                TraceLevel.Info,
                _innerController.GetType().Name,
                ExecuteAsyncMethodName,
                beginTrace: null,
                execute: () =>
                {
                    // Critical to allow wrapped controller to have itself in ControllerContext
                    controllerContext.Controller = ActualController(controllerContext.Controller);
                    return ExecuteAsyncCore(controllerContext, cancellationToken);
                },
                endTrace: (tr, response) =>
                {
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: null);
        }

        private async Task<HttpResponseMessage> ExecuteAsyncCore(HttpControllerContext controllerContext, CancellationToken cancellationToken)
        {
            try
            {
                return await _innerController.ExecuteAsync(controllerContext, cancellationToken);
            }
            finally
            {
                IDisposable disposable = _innerController as IDisposable;

                if (disposable != null)
                {
                    // Need to remove the original controller from the disposables list, if it's
                    // there, and put ourselves in there instead, so we can trace the dispose.
                    // This currently knows a little too much about how RegisterForDispose works,
                    // but that's unavoidable unless we want to offer UnregisterForDispose.
                    IList<IDisposable> disposables;
                    if (_request.Properties.TryGetValue(HttpPropertyKeys.DisposableRequestResourcesKey, out disposables))
                    {
                        disposables.Remove(disposable);
                        disposables.Add(this);
                    }
                }
            }
        }

        public static IHttpController ActualController(IHttpController controller)
        {
            HttpControllerTracer tracer = controller as HttpControllerTracer;
            return tracer == null ? controller : tracer._innerController;
        }

        public static Type ActualControllerType(IHttpController controller)
        {
            return ActualController(controller).GetType();
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/HttpParameterBindingTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;
using System.Web.Http.Services;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer to wrap an <see cref="HttpParameterBinding"/>.
    /// Its primary purpose is to monitor <see cref="ExecuteBindingAsync"/>.
    /// </summary>
    internal class HttpParameterBindingTracer : HttpParameterBinding, IValueProviderParameterBinding, IDecorator<HttpParameterBinding>
    {
        private const string ExecuteBindingAsyncMethodName = "ExecuteBindingAsync";

        public HttpParameterBindingTracer(HttpParameterBinding innerBinding, ITraceWriter traceWriter) : base(innerBinding.Descriptor)
        {
            Contract.Assert(innerBinding != null);
            Contract.Assert(traceWriter != null);

            InnerBinding = innerBinding;
            TraceWriter = traceWriter;
        }

        public HttpParameterBinding Inner
        {
            get { return InnerBinding; }
        }

        protected HttpParameterBinding InnerBinding { get; private set; }

        protected ITraceWriter TraceWriter { get; private set; }

        public override string ErrorMessage
        {
            get
            {
                return InnerBinding.ErrorMessage;
            }
        }

        public override bool WillReadBody
        {
            get
            {
                return InnerBinding.WillReadBody;
            }
        }

        public IEnumerable<ValueProviderFactory> ValueProviderFactories
        {
            get
            {
                IValueProviderParameterBinding valueProviderParameterBinding = InnerBinding as IValueProviderParameterBinding;
                return valueProviderParameterBinding != null ? valueProviderParameterBinding.ValueProviderFactories : Enumerable.Empty<ValueProviderFactory>();
            }
        }

        public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            return TraceWriter.TraceBeginEndAsync(
                actionContext.Request,
                TraceCategories.ModelBindingCategory,
                TraceLevel.Info,
                InnerBinding.GetType().Name,
                ExecuteBindingAsyncMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(SRResources.TraceBeginParameterBind,
                                              InnerBinding.Descriptor.ParameterName);
                },

                execute: () => InnerBinding.ExecuteBindingAsync(metadataProvider, actionContext, cancellationToken),

                endTrace: (tr) =>
                {
                    string parameterName = InnerBinding.Descriptor.ParameterName;

                    // Model binding error for this parameter shows the error
                    if (!actionContext.ModelState.IsValid && actionContext.ModelState.ContainsKey(parameterName))
                    {
                        tr.Message = Error.Format(SRResources.TraceModelStateInvalidMessage,
                                                  FormattingUtilities.ModelStateToString(
                                                       actionContext.ModelState));
                    }
                    else
                    {
                        tr.Message = actionContext.ActionArguments.ContainsKey(parameterName)
                                         ? Error.Format(SRResources.TraceEndParameterBind, parameterName,
                                                        FormattingUtilities.ValueToString(
                                                             actionContext.ActionArguments[parameterName],
                                                             CultureInfo.CurrentCulture))
                                         : Error.Format(SRResources.TraceEndParameterBindNoBind,
                                                        parameterName);
                    }
                },
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/JsonMediaTypeFormatterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Services;
using Newtonsoft.Json;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="JsonMediaTypeFormatter"/>.  
    /// It is required because users can select formatters by this type.
    /// </summary>
    internal class JsonMediaTypeFormatterTracer : JsonMediaTypeFormatter, IFormatterTracer, IDecorator<JsonMediaTypeFormatter>
    {
        private readonly JsonMediaTypeFormatter _inner;
        private MediaTypeFormatterTracer _innerTracer;

        public JsonMediaTypeFormatterTracer(JsonMediaTypeFormatter innerFormatter, ITraceWriter traceWriter, HttpRequestMessage request)
            : base(innerFormatter)
        {
            _inner = innerFormatter;
            _innerTracer = new MediaTypeFormatterTracer(innerFormatter, traceWriter, request);
        }

        HttpRequestMessage IFormatterTracer.Request
        {
            get { return _innerTracer.Request; }
        }

        public JsonMediaTypeFormatter Inner
        {
            get { return _inner; }
        }

        public MediaTypeFormatter InnerFormatter
        {
            get { return _innerTracer.InnerFormatter; }
        }

        public override IRequiredMemberSelector RequiredMemberSelector
        {
            get
            {
                return _innerTracer.RequiredMemberSelector;
            }
            set
            {
                _innerTracer.RequiredMemberSelector = value;
            }
        }

        public override bool CanReadType(Type type)
        {
            return _innerTracer.CanReadType(type);
        }

        public override bool CanWriteType(Type type)
        {
            return _innerTracer.CanWriteType(type);
        }

        public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
        {
            return _innerTracer.GetPerRequestFormatterInstance(type, request, mediaType);
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger)
        {
            return _innerTracer.ReadFromStreamAsync(type, readStream, content, formatterLogger);
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return _innerTracer.ReadFromStreamAsync(type, readStream, content, formatterLogger, cancellationToken);
        }

        // Callback from ReadFromStreamAsync is not expected to be called; _innerTracer.ReadFromStreamAsync uses
        // _inner.ReadFromStreamAsync
        public override object ReadFromStream(Type type, Stream readStream, Encoding effectiveEncoding, IFormatterLogger formatterLogger)
        {
            return _inner.ReadFromStream(type, readStream, effectiveEncoding, formatterLogger);
        }

        // Callback from ReadFromStreamAsync is not expected to be called; _innerTracer.ReadFromStreamAsync uses
        // _inner.ReadFromStreamAsync
        public override JsonReader CreateJsonReader(Type type, Stream readStream, Encoding effectiveEncoding)
        {
            return _inner.CreateJsonReader(type, readStream, effectiveEncoding);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext)
        {
            return _innerTracer.WriteToStreamAsync(type, value, writeStream, content, transportContext);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            return _innerTracer.WriteToStreamAsync(type, value, writeStream, content, transportContext, cancellationToken);
        }

        // Callback from WriteToStreamAsync is not expected to be called; _innerTracer.WriteToStreamAsync uses
        // _inner.WriteToStreamAsync
        public override void WriteToStream(Type type, object value, Stream writeStream, Encoding effectiveEncoding)
        {
            _inner.WriteToStream(type, value, writeStream, effectiveEncoding);
        }

        // Callback from WriteToStreamAsync is not expected to be called; _innerTracer.WriteToStreamAsync uses
        // _inner.WriteToStreamAsync
        public override JsonWriter CreateJsonWriter(Type type, Stream writeStream, Encoding effectiveEncoding)
        {
            return _inner.CreateJsonWriter(type, writeStream, effectiveEncoding);
        }

        public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType)
        {
            _innerTracer.SetDefaultContentHeaders(type, headers, mediaType);
        }

        // Callback is not expected to be called; _innerTracer methods won't use our base methods
        public override JsonSerializer CreateJsonSerializer()
        {
            return _inner.CreateJsonSerializer();
        }

        // Callback is not expected to be called; _innerTracer methods won't use our base methods
        public override DataContractJsonSerializer CreateDataContractSerializer(Type type)
        {
            return _inner.CreateDataContractSerializer(type);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/MediaTypeFormatterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer to monitor <see cref="MediaTypeFormatter"/> instances.
    /// </summary>
    internal class MediaTypeFormatterTracer : MediaTypeFormatter, IFormatterTracer, IDecorator<MediaTypeFormatter>
    {
        private const string ReadFromStreamAsyncMethodName = "ReadFromStreamAsync";
        private const string WriteToStreamAsyncMethodName = "WriteToStreamAsync";
        private const string GetPerRequestFormatterInstanceMethodName = "GetPerRequestFormatterInstance";

        private readonly MediaTypeFormatter _inner;

        public MediaTypeFormatterTracer(MediaTypeFormatter innerFormatter, ITraceWriter traceWriter, HttpRequestMessage request)
            : base(innerFormatter)
        {
            Contract.Assert(innerFormatter != null);
            Contract.Assert(traceWriter != null);

            InnerFormatter = innerFormatter;
            TraceWriter = traceWriter;
            Request = request;
            _inner = innerFormatter;
        }

        public MediaTypeFormatter Inner
        {
            get { return _inner; }
        }

        public MediaTypeFormatter InnerFormatter { get; private set; }

        public ITraceWriter TraceWriter { get; set; }

        public HttpRequestMessage Request { get; set; }

        public override IRequiredMemberSelector RequiredMemberSelector
        {
            get
            {
                return InnerFormatter.RequiredMemberSelector;
            }
            set
            {
                InnerFormatter.RequiredMemberSelector = value;
            }
        }

        public static MediaTypeFormatter ActualMediaTypeFormatter(MediaTypeFormatter formatter)
        {
            IFormatterTracer tracer = formatter as IFormatterTracer;
            return tracer == null ? formatter : tracer.InnerFormatter;
        }

        public static MediaTypeFormatter CreateTracer(MediaTypeFormatter formatter, ITraceWriter traceWriter, HttpRequestMessage request)
        {
            // If we have been asked to wrap a tracer around a formatter, it could be
            // already wrapped, and there is nothing to do.  But if we see it is a tracer
            // that is not associated with a request, we wrap it into a new tracer that
            // does have a request.  The only formatter tracers without requests are the
            // ones in the default MediaTypeFormatterCollection in the HttpConfiguration.
            IFormatterTracer formatterTracer = formatter as IFormatterTracer;
            if (formatterTracer != null)
            {
                if (formatterTracer.Request == request)
                {
                    return formatter;
                }

                formatter = formatterTracer.InnerFormatter;
            }

            MediaTypeFormatter tracer = null;

            XmlMediaTypeFormatter xmlFormatter = formatter as XmlMediaTypeFormatter;
            JsonMediaTypeFormatter jsonFormatter = formatter as JsonMediaTypeFormatter;
            FormUrlEncodedMediaTypeFormatter formUrlFormatter = formatter as FormUrlEncodedMediaTypeFormatter;
            BufferedMediaTypeFormatter bufferedFormatter = formatter as BufferedMediaTypeFormatter;

            // We special-case Xml, Json and FormUrlEncoded formatters because we expect to be able
            // to find them with IsAssignableFrom in the MediaTypeFormatterCollection.
            if (xmlFormatter != null)
            {
                tracer = new XmlMediaTypeFormatterTracer(xmlFormatter, traceWriter, request);
            }
            else if (jsonFormatter != null)
            {
                tracer = new JsonMediaTypeFormatterTracer(jsonFormatter, traceWriter, request);
            }
            else if (formUrlFormatter != null)
            {
                tracer = new FormUrlEncodedMediaTypeFormatterTracer(formUrlFormatter, traceWriter, request);
            }
            else if (bufferedFormatter != null)
            {
                tracer = new BufferedMediaTypeFormatterTracer(bufferedFormatter, traceWriter, request);
            }
            else
            {
                tracer = new MediaTypeFormatterTracer(formatter, traceWriter, request);
            }

            return tracer;
        }

        public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
        {
            MediaTypeFormatter formatter = null;

            TraceWriter.TraceBeginEnd(
                request,
                TraceCategories.FormattingCategory,
                TraceLevel.Info,
                InnerFormatter.GetType().Name,
                GetPerRequestFormatterInstanceMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                        SRResources.TraceGetPerRequestFormatterMessage,
                        InnerFormatter.GetType().Name,
                        type.Name,
                        mediaType);
                },
                execute: () => { formatter = InnerFormatter.GetPerRequestFormatterInstance(type, request, mediaType); },
                endTrace: (tr) =>
                {
                    if (formatter == null)
                    {
                        tr.Message = SRResources.TraceGetPerRequestNullFormatterEndMessage;
                    }
                    else
                    {
                        string formatMessage =
                            Object.ReferenceEquals(MediaTypeFormatterTracer.ActualMediaTypeFormatter(formatter),
                                                   InnerFormatter)
                                ? SRResources.TraceGetPerRequestFormatterEndMessage
                                : SRResources.TraceGetPerRequestFormatterEndMessageNew;

                        tr.Message = Error.Format(formatMessage, formatter.GetType().Name);
                    }
                },
                errorTrace: null);

            if (formatter != null && !(formatter is IFormatterTracer))
            {
                formatter = MediaTypeFormatterTracer.CreateTracer(formatter, TraceWriter, request);
            }

            return formatter;
        }

        public override bool CanReadType(Type type)
        {
            return InnerFormatter.CanReadType(type);
        }

        public override bool CanWriteType(Type type)
        {
            return InnerFormatter.CanWriteType(type);
        }

        public override bool Equals(object obj)
        {
            return InnerFormatter.Equals(obj);
        }

        public override int GetHashCode()
        {
            return InnerFormatter.GetHashCode();
        }

        public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType)
        {
            InnerFormatter.SetDefaultContentHeaders(type, headers, mediaType);
        }

        public override string ToString()
        {
            return InnerFormatter.ToString();
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger)
        {
            return ReadFromStreamAsyncCore(type, readStream, content, formatterLogger, cancellationToken: null);
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return ReadFromStreamAsyncCore(type, readStream, content, formatterLogger, cancellationToken);
        }

        private Task<object> ReadFromStreamAsyncCore(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken? cancellationToken)
        {
            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
            MediaTypeHeaderValue contentType = contentHeaders == null ? null : contentHeaders.ContentType;

            IFormatterLogger formatterLoggerTraceWrapper =
                (formatterLogger == null) ? null : new FormatterLoggerTraceWrapper(formatterLogger,
                                                                                   TraceWriter,
                                                                                   Request,
                                                                                   InnerFormatter.GetType().Name,
                                                                                   ReadFromStreamAsyncMethodName);

            return TraceWriter.TraceBeginEndAsync<object>(
                Request,
                TraceCategories.FormattingCategory,
                TraceLevel.Info,
                InnerFormatter.GetType().Name,
                ReadFromStreamAsyncMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                                        SRResources.TraceReadFromStreamMessage,
                                        type.Name,
                                        contentType == null ? SRResources.TraceNoneObjectMessage : contentType.ToString());
                },

                execute: () =>
                {
                    if (cancellationToken.HasValue)
                    {
                        return InnerFormatter.ReadFromStreamAsync(type, readStream, content, formatterLoggerTraceWrapper, cancellationToken.Value);
                    }
                    else
                    {
                        return InnerFormatter.ReadFromStreamAsync(type, readStream, content, formatterLoggerTraceWrapper);
                    }
                },
                endTrace: (tr, value) =>
                {
                    tr.Message = Error.Format(
                                        SRResources.TraceReadFromStreamValueMessage,
                                        FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture));
                },

                errorTrace: null);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext)
        {
            return WriteToStreamAsyncCore(type, value, writeStream, content, transportContext);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            return WriteToStreamAsyncCore(type, value, writeStream, content, transportContext, cancellationToken);
        }

        private Task WriteToStreamAsyncCore(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken? cancellationToken = null)
        {
            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
            MediaTypeHeaderValue contentType = contentHeaders == null
                                       ? null
                                       : contentHeaders.ContentType;

            return TraceWriter.TraceBeginEndAsync(
                Request,
                TraceCategories.FormattingCategory,
                TraceLevel.Info,
                InnerFormatter.GetType().Name,
                WriteToStreamAsyncMethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = Error.Format(
                                        SRResources.TraceWriteToStreamMessage,
                                        FormattingUtilities.ValueToString(value, CultureInfo.CurrentCulture),
                                        type.Name,
                                        contentType == null ? SRResources.TraceNoneObjectMessage : contentType.ToString());
                },
                execute: () =>
                {
                    if (cancellationToken.HasValue)
                    {
                        return InnerFormatter.WriteToStreamAsync(type, value, writeStream, content, transportContext, cancellationToken.Value);
                    }
                    else
                    {
                        return InnerFormatter.WriteToStreamAsync(type, value, writeStream, content, transportContext);
                    }
                },
                endTrace: null,
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/MessageHandlerTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer to wrap a <see cref="DelegatingHandler"/>.
    /// </summary>
    internal class MessageHandlerTracer : DelegatingHandler, IDecorator<DelegatingHandler>
    {
        private const string SendAsyncMethodName = "SendAsync";

        private readonly DelegatingHandler _innerHandler;
        private readonly ITraceWriter _traceWriter;

        public MessageHandlerTracer(DelegatingHandler innerHandler, ITraceWriter traceWriter)
        {
            Contract.Assert(innerHandler != null);
            Contract.Assert(traceWriter != null);

            _innerHandler = innerHandler;
            _traceWriter = traceWriter;
        }

        public DelegatingHandler Inner
        {
            get { return _innerHandler; }
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return _traceWriter.TraceBeginEndAsync<HttpResponseMessage>(
                request,
                TraceCategories.MessageHandlersCategory,
                TraceLevel.Info,
                _innerHandler.GetType().Name,
                SendAsyncMethodName,
                beginTrace: null,
                execute: () => base.SendAsync(request, cancellationToken),
                endTrace: (tr, response) =>
                {
                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }
                },
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/OverrideFilterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Filters;
using System.Web.Http.Services;

namespace System.Web.Http.Tracing.Tracers
{
    internal class OverrideFilterTracer : FilterTracer, IOverrideFilter, IDecorator<IOverrideFilter>
    {
        private readonly IOverrideFilter _innerFilter;

        public OverrideFilterTracer(IOverrideFilter innerFilter, ITraceWriter traceWriter)
            : base(innerFilter, traceWriter)
        {
            _innerFilter = innerFilter;
        }

        public new IOverrideFilter Inner
        {
            get { return _innerFilter; }
        }

        public Type FiltersToOverride
        {
            get { return _innerFilter.FiltersToOverride; }
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/RequestMessageHandlerTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Properties;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Internal <see cref="DelegatingHandler"/> that executes before and after all of the installed message handlers.
    /// The begin trace of this handler is the first trace for the request.
    /// </summary>
    internal class RequestMessageHandlerTracer : DelegatingHandler
    {
        private readonly ITraceWriter _traceWriter;

        public RequestMessageHandlerTracer(ITraceWriter traceWriter)
        {
            Contract.Assert(traceWriter != null);

            _traceWriter = traceWriter;
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return _traceWriter.TraceBeginEndAsync<HttpResponseMessage>(
                request,
                TraceCategories.RequestCategory,
                TraceLevel.Info,
                String.Empty,
                String.Empty,
                beginTrace: (tr) =>
                {
                    tr.Message = request.RequestUri == null ? SRResources.TraceNoneObjectMessage : request.RequestUri.ToString();
                },

                execute: () => base.SendAsync(request, cancellationToken),

                endTrace: (tr, response) =>
                {
                    MediaTypeHeaderValue contentType = response == null
                                                            ? null
                                                            : response.Content == null
                                                                    ? null
                                                                    : response.Content.Headers.ContentType;

                    long? contentLength = response == null
                                                ? null
                                                : response.Content == null
                                                    ? null
                                                    : response.Content.Headers.ContentLength;

                    if (response != null)
                    {
                        tr.Status = response.StatusCode;
                    }

                    tr.Message =
                        Error.Format(SRResources.TraceRequestCompleteMessage,
                                     contentType == null
                                        ? SRResources.TraceNoneObjectMessage
                                        : contentType.ToString(),
                                     contentLength.HasValue
                                        ? contentLength.Value.ToString(CultureInfo.CurrentCulture)
                                        : SRResources.TraceUnknownMessage);
                },
                errorTrace: null);
        }
    }
}


================================================
FILE: src/System.Web.Http/Tracing/Tracers/XmlMediaTypeFormatterTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Runtime.Serialization;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Services;
using System.Xml;
using System.Xml.Serialization;

namespace System.Web.Http.Tracing.Tracers
{
    /// <summary>
    /// Tracer for <see cref="XmlMediaTypeFormatter"/>.  
    /// It is required because users can select formatters by this type.
    /// </summary>
    internal class XmlMediaTypeFormatterTracer : XmlMediaTypeFormatter, IFormatterTracer, IDecorator<XmlMediaTypeFormatter>
    {
        private readonly XmlMediaTypeFormatter _inner;
        private readonly MediaTypeFormatterTracer _innerTracer;

        public XmlMediaTypeFormatterTracer(XmlMediaTypeFormatter innerFormatter, ITraceWriter traceWriter, HttpRequestMessage request)
            : base(innerFormatter)
        {
            _inner = innerFormatter;
            _innerTracer = new MediaTypeFormatterTracer(innerFormatter, traceWriter, request);
        }

        HttpRequestMessage IFormatterTracer.Request
        {
            get { return _innerTracer.Request; }
        }

        public XmlMediaTypeFormatter Inner
        {
            get { return _inner; }
        }

        public MediaTypeFormatter InnerFormatter
        {
            get { return _innerTracer.InnerFormatter; }
        }

        public override IRequiredMemberSelector RequiredMemberSelector
        {
            get
            {
                return _innerTracer.RequiredMemberSelector;
            }
            set
            {
                _innerTracer.RequiredMemberSelector = value;
            }
        }

        public override bool CanReadType(Type type)
        {
            return _innerTracer.CanReadType(type);
        }

        public override bool CanWriteType(Type type)
        {
            return _innerTracer.CanWriteType(type);
        }

        public override MediaTypeFormatter GetPerRequestFormatterInstance(Type type, HttpRequestMessage request, MediaTypeHeaderValue mediaType)
        {
            return _innerTracer.GetPerRequestFormatterInstance(type, request, mediaType);
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
            IFormatterLogger formatterLogger, CancellationToken cancellationToken)
        {
            return _innerTracer.ReadFromStreamAsync(type, readStream, content, formatterLogger, cancellationToken);
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            return _innerTracer.ReadFromStreamAsync(type, readStream, content, formatterLogger);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
            TransportContext transportContext, CancellationToken cancellationToken)
        {
            return _innerTracer.WriteToStreamAsync(type, value, writeStream, content, transportContext, cancellationToken);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
        {
            return _innerTracer.WriteToStreamAsync(type, value, writeStream, content, transportContext);
        }

        public override void SetDefaultContentHeaders(Type type, HttpContentHeaders headers, MediaTypeHeaderValue mediaType)
        {
            _innerTracer.SetDefaultContentHeaders(type, headers, mediaType);
        }

        public override XmlSerializer CreateXmlSerializer(Type type)
        {
            return _inner.CreateXmlSerializer(type);
        }

        public override DataContractSerializer CreateDataContractSerializer(Type type)
        {
            return _inner.CreateDataContractSerializer(type);
        }

        protected override XmlReader CreateXmlReader(Stream readStream, HttpContent content)
        {
            return _inner.InvokeCreateXmlReader(readStream, content);
        }

        protected override XmlWriter CreateXmlWriter(Stream writeStream, HttpContent content)
        {
            return _inner.InvokeCreateXmlWriter(writeStream, content);
        }

        protected override object GetDeserializer(Type type, HttpContent content)
        {
            return _inner.InvokeGetDeserializer(type, content);
        }

        protected override object GetSerializer(Type type, object value, HttpContent content)
        {
            return _inner.InvokeGetSerializer(type, value, content);
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/BodyModelValidatorContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Validation
{
    /// <summary>
    /// Context passed between <see cref="DefaultBodyModelValidator"/> methods.
    /// </summary>
    public class BodyModelValidatorContext
    {
        public BodyModelValidatorContext(ModelStateDictionary modelState)
        {
            if (modelState == null)
            {
                throw new ArgumentNullException("modelState");
            }

            KeyBuilders = new Stack<IBodyModelValidatorKeyBuilder>();
            ModelState = modelState;
            Visited = new HashSet<object>(ReferenceEqualityComparer.Instance);
        }

        /// <summary>
        /// Gets or sets the <see cref="ModelMetadataProvider"/> used to provide the model metadata.
        /// </summary>
        public ModelMetadataProvider MetadataProvider { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="HttpActionContext"/> within which the model is being validated.
        /// </summary>
        public HttpActionContext ActionContext { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="IModelValidatorCache"/>.
        /// </summary>
        public IModelValidatorCache ValidatorCache { get; set; }

        /// <summary>
        /// Gets the current <see cref="ModelStateDictionary"/>.
        /// </summary>
        public ModelStateDictionary ModelState { get; private set; }

        /// <summary>
        /// Gets the set of model objects visited in this validation. Includes the model being validated in the
        /// current scope.
        /// </summary>
        public HashSet<object> Visited { get; private set; }

        /// <summary>
        /// Gets the stack of <see cref="IBodyModelValidatorKeyBuilder"/>s used in this validation. Includes
        /// the <see cref="IBodyModelValidatorKeyBuilder"/> to generate model state keys for the current scope.
        /// </summary>
        public Stack<IBodyModelValidatorKeyBuilder> KeyBuilders { get; private set; }

        /// <summary>
        /// Gets or sets the model state prefix for the root scope of this validation.
        /// </summary>
        public string RootPrefix { get; set; }
    }
}


================================================
FILE: src/System.Web.Http/Validation/DefaultBodyModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http.Formatting;
using System.Runtime.CompilerServices;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Validation
{
    /// <summary>
    /// Recursively validate an object.
    /// </summary>
    public class DefaultBodyModelValidator : IBodyModelValidator
    {
        /// <summary>
        /// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
        /// </summary>
        /// <param name="model">The model to be validated.</param>
        /// <param name="type">The <see cref="Type"/> to use for validation.</param>
        /// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
        /// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
        /// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
        /// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
        public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (metadataProvider == null)
            {
                throw Error.ArgumentNull("metadataProvider");
            }

            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            if (model != null && !ShouldValidateType(model.GetType()))
            {
                return true;
            }

            ModelValidatorProvider[] validatorProviders = actionContext.GetValidatorProviders().ToArray();
            // Optimization : avoid validating the object graph if there are no validator providers
            if (validatorProviders == null || validatorProviders.Length == 0)
            {
                return true;
            }

            ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type);
            BodyModelValidatorContext validationContext = new BodyModelValidatorContext(actionContext.ModelState)
            {
                MetadataProvider = metadataProvider,
                ActionContext = actionContext,
                ValidatorCache = actionContext.GetValidatorCache(),
                RootPrefix = keyPrefix
            };
            return ValidateNodeAndChildren(metadata, validationContext, container: null, validators: null);
        }

        /// <summary>
        /// Determines whether instances of a particular type should be validated
        /// </summary>
        /// <param name="type">The type to validate.</param>
        /// <returns><c>true</c> if the type should be validated; <c>false</c> otherwise</returns>
        public virtual bool ShouldValidateType(Type type)
        {
            return !MediaTypeFormatterCollection.IsTypeExcludedFromValidation(type);
        }

        /// <summary>
        /// Recursively validate the given <paramref name="metadata"/> and <paramref name="container"/>.
        /// </summary>
        /// <param name="metadata">The <see cref="ModelMetadata"/> for the object to validate.</param>
        /// <param name="validationContext">The <see cref="BodyModelValidatorContext"/>.</param>
        /// <param name="container">The object containing the object to validate.</param>
        /// <param name="validators">The collection of <see cref="ModelValidator"/>s.</param>
        /// <returns>
        /// <see langword="true"/> if validation succeeds for the given <paramref name="metadata"/>,
        /// <paramref name="container"/>, and child nodes; <see langword="false"/> otherwise.
        /// </returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "See comment below")]
        protected virtual bool ValidateNodeAndChildren(
            ModelMetadata metadata,
            BodyModelValidatorContext validationContext,
            object container,
            IEnumerable<ModelValidator> validators)
        {
            // Recursion guard to avoid stack overflows
            RuntimeHelpers.EnsureSufficientExecutionStack();

            if (metadata == null)
            {
                throw Error.ArgumentNull("metadata");
            }
            if (validationContext == null)
            {
                throw Error.ArgumentNull("validationContext");
            }

            object model = null;
            try
            {
                model = metadata.Model;
            }
            catch
            {
                // Retrieving the model failed - typically caused by a property getter throwing
                // Being unable to retrieve a property is not a validation error - many properties can only be retrieved if certain conditions are met
                // For example, Uri.AbsoluteUri throws for relative URIs but it shouldn't be considered a validation error
                return true;
            }

            bool isValid = true;

            if (validators == null)
            {
                validators = validationContext.ActionContext.GetValidators(metadata, validationContext.ValidatorCache);
            }

            // We don't need to recursively traverse the graph for null values
            if (model == null)
            {
                return ShallowValidate(metadata, validationContext, container, validators);
            }

            // We don't need to recursively traverse the graph for types that shouldn't be validated
            Type modelType = model.GetType();
            if (TypeHelper.IsSimpleType(modelType) || !ShouldValidateType(modelType))
            {
                return ShallowValidate(metadata, validationContext, container, validators);
            }

            // Check to avoid infinite recursion. This can happen with cycles in an object graph.
            if (validationContext.Visited.Contains(model))
            {
                return true;
            }
            validationContext.Visited.Add(model);

            // Validate the children first - depth-first traversal
            IEnumerable enumerableModel = model as IEnumerable;
            if (enumerableModel == null)
            {
                isValid = ValidateProperties(metadata, validationContext);
            }
            else
            {
                isValid = ValidateElements(enumerableModel, validationContext);
            }
            if (isValid)
            {
                // Don't bother to validate this node if children failed.
                isValid = ShallowValidate(metadata, validationContext, container, validators);
            }

            // Pop the object so that it can be validated again in a different path
            validationContext.Visited.Remove(model);

            return isValid;
        }

        /// <summary>
        /// Recursively validate the properties of the given <paramref name="metadata"/>.
        /// </summary>
        /// <param name="metadata">The <see cref="ModelMetadata"/> for the object to validate.</param>
        /// <param name="validationContext">The <see cref="BodyModelValidatorContext"/>.</param>
        /// <returns>
        /// <see langword="true"/> if validation succeeds for all properties in <paramref name="metadata"/>;
        /// <see langword="false"/> otherwise.
        /// </returns>
        protected virtual bool ValidateProperties(ModelMetadata metadata, BodyModelValidatorContext validationContext)
        {
            if (metadata == null)
            {
                throw Error.ArgumentNull("metadata");
            }
            if (validationContext == null)
            {
                throw Error.ArgumentNull("validationContext");
            }

            bool isValid = true;
            PropertyScope propertyScope = new PropertyScope();
            validationContext.KeyBuilders.Push(propertyScope);
            foreach (ModelMetadata childMetadata in validationContext.MetadataProvider.GetMetadataForProperties(metadata.Model, metadata.RealModelType))
            {
                propertyScope.PropertyName = childMetadata.PropertyName;
                if (!ValidateNodeAndChildren(childMetadata, validationContext, metadata.Model, validators: null))
                {
                    isValid = false;
                }
            }
            validationContext.KeyBuilders.Pop();
            return isValid;
        }

        /// <summary>
        /// Recursively validate the elements of the <paramref name="model"/> collection.
        /// </summary>
        /// <param name="model">The <see cref="IEnumerable"/> instance containing the elements to validate.</param>
        /// <param name="validationContext">The <see cref="BodyModelValidatorContext"/>.</param>
        /// <returns>
        /// <see langword="true"/> if validation succeeds for all elements of <paramref name="model"/>;
        /// <see langword="false"/> otherwise.
        /// </returns>
        protected virtual bool ValidateElements(IEnumerable model, BodyModelValidatorContext validationContext)
        {
            if (model == null)
            {
                throw Error.ArgumentNull("model");
            }
            if (validationContext == null)
            {
                throw Error.ArgumentNull("validationContext");
            }

            bool isValid = true;
            Type elementType = GetElementType(model.GetType());
            ModelMetadata elementMetadata = validationContext.MetadataProvider.GetMetadataForType(null, elementType);

            ElementScope elementScope = new ElementScope() { Index = 0 };
            validationContext.KeyBuilders.Push(elementScope);
            IEnumerable<ModelValidator> validators = validationContext.ActionContext.GetValidators(elementMetadata, validationContext.ValidatorCache);

            // if there are no validators or the object is null we bail out quickly
            // when there are large arrays of null, this will save a significant amount of processing
            // with minimal impact to other scenarios.
            bool anyValidatorsDefined = validators.Any();

            foreach (object element in model)
            {
                // If the element is non null, the recursive calls might find more validators.
                // If it's null, then a shallow validation will be performed.
                if (element != null || anyValidatorsDefined)
                {
                    elementMetadata.Model = element;

                    if (!ValidateNodeAndChildren(elementMetadata, validationContext, model, validators))
                    {
                        isValid = false;
                    }
                }

                elementScope.Index++;
            }
            validationContext.KeyBuilders.Pop();
            return isValid;
        }

        /// <summary>
        /// Validate a single node, not including its children.
        /// </summary>
        /// <param name="metadata">The <see cref="ModelMetadata"/>.</param>
        /// <param name="validationContext">The <see cref="BodyModelValidatorContext"/>.</param>
        /// <param name="container">The object to validate.</param>
        /// <param name="validators">The collection of <see cref="ModelValidator"/>s.</param>
        /// <returns>
        /// <see langword="true"/> if validation succeeds for the given <paramref name="metadata"/> and
        /// <paramref name="container"/>; <see langword="false"/> otherwise.
        /// </returns>
        protected virtual bool ShallowValidate(
            ModelMetadata metadata,
            BodyModelValidatorContext validationContext,
            object container,
            IEnumerable<ModelValidator> validators)
        {
            if (metadata == null)
            {
                throw Error.ArgumentNull("metadata");
            }
            if (validationContext == null)
            {
                throw Error.ArgumentNull("validationContext");
            }
            if (validators == null)
            {
                throw Error.ArgumentNull("validators");
            }

            bool isValid = true;
            string modelKey = null;

            // When the are no validators we bail quickly. This saves a GetEnumerator allocation.
            // In a large array (tens of thousands or more) scenario it's very significant.
            ICollection validatorsAsCollection = validators as ICollection;
            if (validatorsAsCollection != null && validatorsAsCollection.Count == 0)
            {
                return isValid;
            }

            foreach (ModelValidator validator in validators)
            {
                foreach (ModelValidationResult error in validator.Validate(metadata, container))
                {
                    if (modelKey == null)
                    {
                        modelKey = validationContext.RootPrefix;
                        foreach (IBodyModelValidatorKeyBuilder keyBuilder in validationContext.KeyBuilders.Reverse())
                        {
                            modelKey = keyBuilder.AppendTo(modelKey);
                        }
                    }
                    string errorKey = ModelBindingHelper.CreatePropertyModelName(modelKey, error.MemberName);
                    validationContext.ModelState.AddModelError(errorKey, error.Message);
                    isValid = false;
                }
            }
            return isValid;
        }

        private static Type GetElementType(Type type)
        {
            Contract.Assert(typeof(IEnumerable).IsAssignableFrom(type));
            if (type.IsArray)
            {
                return type.GetElementType();
            }

            foreach (Type implementedInterface in type.GetInterfaces())
            {
                if (implementedInterface.IsGenericType && implementedInterface.GetGenericTypeDefinition() == typeof(IEnumerable<>))
                {
                    return implementedInterface.GetGenericArguments()[0];
                }
            }

            return typeof(object);
        }

        private class PropertyScope : IBodyModelValidatorKeyBuilder
        {
            public string PropertyName { get; set; }

            public string AppendTo(string prefix)
            {
                return ModelBindingHelper.CreatePropertyModelName(prefix, PropertyName);
            }
        }

        private class ElementScope : IBodyModelValidatorKeyBuilder
        {
            public int Index { get; set; }

            public string AppendTo(string prefix)
            {
                return ModelBindingHelper.CreateIndexModelName(prefix, Index);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/IBodyModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Validation
{
    /// <summary>
    /// Validates the body parameter of an action after the parameter has been read by the <see cref="MediaTypeFormatter"/>.
    /// </summary>
    public interface IBodyModelValidator
    {
        /// <summary>
        /// Determines whether the <paramref name="model"/> is valid and adds any validation errors to the <paramref name="actionContext"/>'s <see cref="ModelStateDictionary"/>
        /// </summary>
        /// <param name="model">The model to be validated.</param>
        /// <param name="type">The <see cref="Type"/> to use for validation.</param>
        /// <param name="metadataProvider">The <see cref="ModelMetadataProvider"/> used to provide the model metadata.</param>
        /// <param name="actionContext">The <see cref="HttpActionContext"/> within which the model is being validated.</param>
        /// <param name="keyPrefix">The <see cref="string"/> to append to the key for any validation errors.</param>
        /// <returns><c>true</c>if <paramref name="model"/> is valid, <c>false</c> otherwise.</returns>
        bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix);
    }
}


================================================
FILE: src/System.Web.Http/Validation/IBodyModelValidatorKeyBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Validation
{
    /// <summary>
    /// Abstraction for creating keys used in nested validation scopes. Intended for use in
    /// <see cref="IBodyModelValidator"/> implementations, especially <see cref="DefaultBodyModelValidator"/>.
    /// </summary>
    public interface IBodyModelValidatorKeyBuilder
    {
        /// <summary>
        /// Returns the key for a nested scope within the <paramref name="prefix"/> scope.
        /// </summary>
        /// <param name="prefix">Key for the current scope.</param>
        /// <returns>Key for a nested scope. Usually appends a property name to <paramref name="prefix"/>.</returns>
        string AppendTo(string prefix);
    }
}


================================================
FILE: src/System.Web.Http/Validation/IModelValidatorCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata;

namespace System.Web.Http.Validation
{
    /// <summary>
    /// Defines a cache for <see cref="ModelValidator"/>s. This cache is keyed on the type or property that the
    /// metadata is associated with.
    /// </summary>
    public interface IModelValidatorCache
    {
        /// <summary>
        /// Returns the <see cref="ModelValidator"/>s for the given <paramref name="metadata"/>.
        /// </summary>
        /// <param name="metadata">The <see cref="ModelMetadata"/>.</param>
        /// <returns>An array of <see cref="ModelValidator"/>s for the given <paramref name="metadata"/>.</returns>
        ModelValidator[] GetValidators(ModelMetadata metadata);
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelStateFormatterLogger.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Validation
{
    /// <summary>
    /// This <see cref="IFormatterLogger"/> logs formatter errors to the provided <see cref="ModelStateDictionary"/>.
    /// </summary>
    public class ModelStateFormatterLogger : IFormatterLogger
    {
        private readonly ModelStateDictionary _modelState;
        private readonly string _prefix;

        public ModelStateFormatterLogger(ModelStateDictionary modelState, string prefix)
        {
            if (modelState == null)
            {
                throw Error.ArgumentNull("modelState");
            }

            _modelState = modelState;
            _prefix = prefix;
        }

        public void LogError(string errorPath, string errorMessage)
        {
            if (errorPath == null)
            {
                throw Error.ArgumentNull("errorPath");
            }
            if (errorMessage == null)
            {
                throw Error.ArgumentNull("errorMessage");
            }

            string key = ModelBindingHelper.ConcatenateKeys(_prefix, errorPath);
            _modelState.AddModelError(key, errorMessage);
        }

        public void LogError(string errorPath, Exception exception)
        {
            if (errorPath == null)
            {
                throw Error.ArgumentNull("errorPath");
            }
            if (exception == null)
            {
                throw Error.ArgumentNull("exception");
            }

            string key = ModelBindingHelper.ConcatenateKeys(_prefix, errorPath);
            _modelState.AddModelError(key, exception);
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidatedEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.Validation
{
    public sealed class ModelValidatedEventArgs : EventArgs
    {
        public ModelValidatedEventArgs(HttpActionContext actionContext, ModelValidationNode parentNode)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            ActionContext = actionContext;
            ParentNode = parentNode;
        }

        public HttpActionContext ActionContext { get; private set; }

        public ModelValidationNode ParentNode { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidatingEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.Http.Controllers;

namespace System.Web.Http.Validation
{
    public sealed class ModelValidatingEventArgs : CancelEventArgs
    {
        public ModelValidatingEventArgs(HttpActionContext actionContext, ModelValidationNode parentNode)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            ActionContext = actionContext;
            ParentNode = parentNode;
        }

        public HttpActionContext ActionContext { get; private set; }

        public ModelValidationNode ParentNode { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidationNode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;

namespace System.Web.Http.Validation
{
    public sealed class ModelValidationNode
    {
        private IEnumerable<ModelValidator> _validators;
        private readonly List<ModelValidationNode> _childNodes;

        public ModelValidationNode(ModelMetadata modelMetadata, string modelStateKey)
            : this(modelMetadata, modelStateKey, null)
        {
        }

        public ModelValidationNode(ModelMetadata modelMetadata, string modelStateKey, IEnumerable<ModelValidationNode> childNodes)
        {
            if (modelMetadata == null)
            {
                throw Error.ArgumentNull("modelMetadata");
            }
            if (modelStateKey == null)
            {
                throw Error.ArgumentNull("modelStateKey");
            }

            ModelMetadata = modelMetadata;
            ModelStateKey = modelStateKey;
            _childNodes = (childNodes != null) ? childNodes.ToList() : new List<ModelValidationNode>();
        }

        public event EventHandler<ModelValidatedEventArgs> Validated;

        public event EventHandler<ModelValidatingEventArgs> Validating;

        public ICollection<ModelValidationNode> ChildNodes 
        {
            get { return _childNodes; }
        }

        public ModelMetadata ModelMetadata { get; private set; }

        public string ModelStateKey { get; private set; }

        public bool ValidateAllProperties { get; set; }

        public bool SuppressValidation { get; set; }

        public void CombineWith(ModelValidationNode otherNode)
        {
            if (otherNode != null && !otherNode.SuppressValidation)
            {
                Validated += otherNode.Validated;
                Validating += otherNode.Validating;
                List<ModelValidationNode> otherChildNodes = otherNode._childNodes;
                for (int i = 0; i < otherChildNodes.Count; i++)
                {
                    ModelValidationNode childNode = otherChildNodes[i];
                    _childNodes.Add(childNode);
                }
            }
        }

        private void OnValidated(ModelValidatedEventArgs e)
        {
            EventHandler<ModelValidatedEventArgs> handler = Validated;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private void OnValidating(ModelValidatingEventArgs e)
        {
            EventHandler<ModelValidatingEventArgs> handler = Validating;
            if (handler != null)
            {
                handler(this, e);
            }
        }

        private object TryConvertContainerToMetadataType(ModelValidationNode parentNode)
        {
            if (parentNode != null)
            {
                object containerInstance = parentNode.ModelMetadata.Model;
                if (containerInstance != null)
                {
                    Type expectedContainerType = ModelMetadata.ContainerType;
                    if (expectedContainerType != null)
                    {
                        if (expectedContainerType.IsInstanceOfType(containerInstance))
                        {
                            return containerInstance;
                        }
                    }
                }
            }

            return null;
        }

        public void Validate(HttpActionContext actionContext)
        {
            Validate(actionContext, null /* parentNode */);
        }

        public void Validate(HttpActionContext actionContext, ModelValidationNode parentNode)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            if (SuppressValidation)
            {
                // no-op
                return;
            }

            // pre-validation steps
            ModelValidatingEventArgs validatingEventArgs = new ModelValidatingEventArgs(actionContext, parentNode);
            OnValidating(validatingEventArgs);
            if (validatingEventArgs.Cancel)
            {
                return;
            }

            ValidateChildren(actionContext);
            ValidateThis(actionContext, parentNode);

            // post-validation steps
            ModelValidatedEventArgs validatedEventArgs = new ModelValidatedEventArgs(actionContext, parentNode);
            OnValidated(validatedEventArgs);
        }

        private void ValidateChildren(HttpActionContext actionContext)
        {
            for (int i = 0; i < _childNodes.Count; i++)
            {
                ModelValidationNode child = _childNodes[i];
                child.Validate(actionContext, this);
            }

            if (ValidateAllProperties)
            {
                ValidateProperties(actionContext);
            }
        }

        private void ValidateProperties(HttpActionContext actionContext)
        {
            // Based off CompositeModelValidator.
            ModelStateDictionary modelState = actionContext.ModelState;

            // DevDiv Bugs #227802 - Caching problem in ModelMetadata requires us to manually regenerate
            // the ModelMetadata.
            object model = ModelMetadata.Model;
            ModelMetadata updatedMetadata = actionContext.GetMetadataProvider().GetMetadataForType(() => model, ModelMetadata.ModelType);

            foreach (ModelMetadata propertyMetadata in updatedMetadata.Properties)
            {
                // Only want to add errors to ModelState if something doesn't already exist for the property node,
                // else we could end up with duplicate or irrelevant error messages.
                string propertyKeyRoot = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, propertyMetadata.PropertyName);

                if (modelState.IsValidField(propertyKeyRoot))
                {
                    foreach (ModelValidator propertyValidator in actionContext.GetValidators(propertyMetadata))
                    {
                        foreach (ModelValidationResult propertyResult in propertyValidator.Validate(propertyMetadata, model))
                        {
                            string thisErrorKey = ModelBindingHelper.CreatePropertyModelName(propertyKeyRoot, propertyResult.MemberName);
                            modelState.AddModelError(thisErrorKey, propertyResult.Message);
                        }
                    }
                }
            }
        }

        private void ValidateThis(HttpActionContext actionContext, ModelValidationNode parentNode)
        {
            ModelStateDictionary modelState = actionContext.ModelState;
            if (!modelState.IsValidField(ModelStateKey))
            {
                return; // short-circuit
            }

            // If 'this' is null and there is no parent, we cannot validate, and
            // the DataAnnotationsModelValidator will throw.   So we intercept here
            // to provide a catch-all value-required validation error
            if (parentNode == null && ModelMetadata.Model == null)
            {
                string trueModelStateKey = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, ModelMetadata.GetDisplayName());
                modelState.AddModelError(trueModelStateKey, SRResources.Validation_ValueNotFound);
                return;
            }

            _validators = actionContext.GetValidators(ModelMetadata);

            object container = TryConvertContainerToMetadataType(parentNode);
            // Optimize for the common case where the validators are in an array
            ModelValidator[] validators = _validators.AsArray();
            for (int i = 0; i < validators.Length; i++)
            {
                ModelValidator validator = validators[i];
                foreach (ModelValidationResult validationResult in validator.Validate(ModelMetadata, container))
                {
                    string trueModelStateKey = ModelBindingHelper.CreatePropertyModelName(ModelStateKey, validationResult.MemberName);
                    modelState.AddModelError(trueModelStateKey, validationResult.Message);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidationRequiredMemberSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting;
using System.Reflection;
using System.Web.Http.Metadata;

namespace System.Web.Http.Validation
{
    /// <summary>
    /// This <see cref="IRequiredMemberSelector"/> selects required members by checking for any 
    /// required ModelValidators associated with the member. This is the default implementation used by
    /// <see cref="HttpConfiguration"/>.
    /// </summary>
    public sealed class ModelValidationRequiredMemberSelector : IRequiredMemberSelector
    {
        private readonly ModelMetadataProvider _metadataProvider;
        private readonly List<ModelValidatorProvider> _validatorProviders;

        public ModelValidationRequiredMemberSelector(ModelMetadataProvider metadataProvider, IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            if (metadataProvider == null)
            {
                throw Error.ArgumentNull("metadataProvider");
            }
            if (validatorProviders == null)
            {
                throw Error.ArgumentNull("validatorProviders");
            }

            _metadataProvider = metadataProvider;
            _validatorProviders = validatorProviders.ToList();
        }

        public bool IsRequiredMember(MemberInfo member)
        {
            if (member == null)
            {
                throw Error.ArgumentNull("member");
            }

            // Optimization : avoid computing validators if there are no validator providers
            if (_validatorProviders == null || !_validatorProviders.Any())
            {
                return false;
            }

            PropertyInfo property = member as PropertyInfo;
            // if member is not a property or there is no public getter
            if (property == null || property.GetGetMethod() == null)
            {
                return false;
            }

            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => null, member.DeclaringType, member.Name);
            if (metadata.ModelType.IsNullable())
            {
                // If the model type is nullable, the value validator will raise a model error for the null member
                // Only non-nullable property types need to be checked by the formatter
                return false;
            }

            IEnumerable<ModelValidator> validators = metadata.GetValidators(_validatorProviders);
            return validators.Any(validator => validator.IsRequired);
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidationResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Validation
{
    public class ModelValidationResult
    {
        private string _memberName;
        private string _message;

        public string MemberName
        {
            get { return _memberName ?? String.Empty; }
            set { _memberName = value; }
        }

        public string Message
        {
            get { return _message ?? String.Empty; }
            set { _message = value; }
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;

namespace System.Web.Http.Validation
{
    public abstract class ModelValidator
    {
        protected ModelValidator(IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            if (validatorProviders == null)
            {
                throw Error.ArgumentNull("validatorProviders");
            }

            ValidatorProviders = validatorProviders;
        }

        protected internal IEnumerable<ModelValidatorProvider> ValidatorProviders { get; private set; }

        public virtual bool IsRequired
        {
            get { return false; }
        }

        public static ModelValidator GetModelValidator(IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            return new CompositeModelValidator(validatorProviders);
        }

        public abstract IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container);

        private class CompositeModelValidator : ModelValidator
        {
            public CompositeModelValidator(IEnumerable<ModelValidatorProvider> validatorProviders)
                : base(validatorProviders)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
            {
                bool propertiesValid = true;

                foreach (ModelMetadata propertyMetadata in metadata.Properties)
                {
                    foreach (ModelValidator propertyValidator in propertyMetadata.GetValidators(ValidatorProviders))
                    {
                        foreach (ModelValidationResult propertyResult in propertyValidator.Validate(metadata, container))
                        {
                            propertiesValid = false;
                            yield return new ModelValidationResult
                            {
                                MemberName = ModelBindingHelper.CreatePropertyModelName(propertyMetadata.PropertyName, propertyResult.MemberName),
                                Message = propertyResult.Message
                            };
                        }
                    }
                }

                if (propertiesValid)
                {
                    foreach (ModelValidator typeValidator in metadata.GetValidators(ValidatorProviders))
                    {
                        foreach (ModelValidationResult typeResult in typeValidator.Validate(metadata, container))
                        {
                            yield return typeResult;
                        }
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidatorCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Web.Http.Metadata;

namespace System.Web.Http.Validation
{
    /// <summary>
    /// Defines a cache for <see cref="ModelValidator"/>s. This cache is keyed on the type or property that the metadata is associated with.
    /// </summary>
    internal class ModelValidatorCache : IModelValidatorCache
    {
        private ConcurrentDictionary<EfficientTypePropertyKey<Type, string>, ModelValidator[]> _validatorCache = new ConcurrentDictionary<EfficientTypePropertyKey<Type, string>, ModelValidator[]>();
        private Lazy<IEnumerable<ModelValidatorProvider>> _validatorProviders;

        public ModelValidatorCache(Lazy<IEnumerable<ModelValidatorProvider>> validatorProviders)
        {
            _validatorProviders = validatorProviders;
        }

        public ModelValidator[] GetValidators(ModelMetadata metadata)
        {
            ModelValidator[] validators;
            if (!_validatorCache.TryGetValue(metadata.CacheKey, out validators))
            {
                // Compute validators
                // There are no side-effects if the same validators are created more than once
                validators = metadata.GetValidators(_validatorProviders.Value).ToArray();
                _validatorCache.TryAdd(metadata.CacheKey, validators);
            }
            return validators;
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Metadata;

namespace System.Web.Http.Validation
{
    public abstract class ModelValidatorProvider
    {
        public abstract IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders);
    }
}


================================================
FILE: src/System.Web.Http/Validation/Providers/AssociatedValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Web.Http.Internal;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;

namespace System.Web.Http.Validation.Providers
{
    public abstract class AssociatedValidatorProvider : ModelValidatorProvider
    {
        protected virtual ICustomTypeDescriptor GetTypeDescriptor(Type type)
        {
            return TypeDescriptorHelper.Get(type);
        }

        public sealed override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            if (metadata == null)
            {
                throw Error.ArgumentNull("metadata");
            }
            if (validatorProviders == null)
            {
                throw Error.ArgumentNull("validatorProviders");
            }

            if (metadata.ContainerType != null && !String.IsNullOrEmpty(metadata.PropertyName))
            {
                return GetValidatorsForProperty(metadata, validatorProviders);
            }

            return GetValidatorsForType(metadata, validatorProviders);
        }

        protected abstract IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders, IEnumerable<Attribute> attributes);

        private IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            ICustomTypeDescriptor typeDescriptor = GetTypeDescriptor(metadata.ContainerType);
            PropertyDescriptor property = typeDescriptor.GetProperties().Find(metadata.PropertyName, true);
            if (property == null)
            {
                throw Error.Argument("metadata", SRResources.Common_PropertyNotFound, metadata.ContainerType, metadata.PropertyName);
            }

            return GetValidators(metadata, validatorProviders, property.Attributes.OfType<Attribute>());
        }

        private IEnumerable<ModelValidator> GetValidatorsForType(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            return GetValidators(metadata, validatorProviders, GetTypeDescriptor(metadata.ModelType).GetAttributes().Cast<Attribute>());
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/Providers/DataAnnotationsModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Security;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;
using System.Web.Http.Validation.Validators;

namespace System.Web.Http.Validation.Providers
{
    // A factory for validators based on ValidationAttribute
    public delegate ModelValidator DataAnnotationsModelValidationFactory(IEnumerable<ModelValidatorProvider> validatorProviders, ValidationAttribute attribute);

    // A factory for validators based on IValidatableObject
    public delegate ModelValidator DataAnnotationsValidatableObjectAdapterFactory(IEnumerable<ModelValidatorProvider> validatorProviders);

    /// <summary>
    /// An implementation of <see cref="ModelValidatorProvider"/> which providers validators
    /// for attributes which derive from <see cref="ValidationAttribute"/>. It also provides
    /// a validator for types which implement <see cref="IValidatableObject"/>.
    /// </summary>
    public class DataAnnotationsModelValidatorProvider : AssociatedValidatorProvider
    {
        // Factories for validation attributes

        internal DataAnnotationsModelValidationFactory DefaultAttributeFactory =
            (validationProviders, attribute) => new DataAnnotationsModelValidator(validationProviders, attribute);

        internal Dictionary<Type, DataAnnotationsModelValidationFactory> AttributeFactories =
            new Dictionary<Type, DataAnnotationsModelValidationFactory>();

        // Factories for IValidatableObject models
        internal DataAnnotationsValidatableObjectAdapterFactory DefaultValidatableFactory =
            (validationProviders) => new ValidatableObjectAdapter(validationProviders);

        internal Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory> ValidatableFactories =
            new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();

        protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders, IEnumerable<Attribute> attributes)
        {
                List<ModelValidator> results = new List<ModelValidator>();

                // Produce a validator for each validation attribute we find
                foreach (ValidationAttribute attribute in attributes.OfType<ValidationAttribute>())
                {
                    DataAnnotationsModelValidationFactory factory;
                    if (!AttributeFactories.TryGetValue(attribute.GetType(), out factory))
                    {
                        factory = DefaultAttributeFactory;
                    }
                    results.Add(factory(validatorProviders, attribute));
                }

                // Produce a validator if the type supports IValidatableObject
                if (typeof(IValidatableObject).IsAssignableFrom(metadata.ModelType))
                {
                    DataAnnotationsValidatableObjectAdapterFactory factory;
                    if (!ValidatableFactories.TryGetValue(metadata.ModelType, out factory))
                    {
                        factory = DefaultValidatableFactory;
                    }
                    results.Add(factory(validatorProviders));
                }

                return results;
            }

        #region Validation attribute adapter registration

        public void RegisterAdapter(Type attributeType, Type adapterType)
        {
            ValidateAttributeType(attributeType);
            ValidateAttributeAdapterType(adapterType);
            ConstructorInfo constructor = GetAttributeAdapterConstructor(attributeType, adapterType);

                AttributeFactories[attributeType] = (context, attribute) => (ModelValidator)constructor.Invoke(new object[] { context, attribute });
            }

        public void RegisterAdapterFactory(Type attributeType, DataAnnotationsModelValidationFactory factory)
        {
            ValidateAttributeType(attributeType);
            ValidateAttributeFactory(factory);

                AttributeFactories[attributeType] = factory;
            }

        public void RegisterDefaultAdapter(Type adapterType)
        {
            ValidateAttributeAdapterType(adapterType);
            ConstructorInfo constructor = GetAttributeAdapterConstructor(typeof(ValidationAttribute), adapterType);

            DefaultAttributeFactory = (context, attribute) => (ModelValidator)constructor.Invoke(new object[] { context, attribute });
        }

        public void RegisterDefaultAdapterFactory(DataAnnotationsModelValidationFactory factory)
        {
            ValidateAttributeFactory(factory);

            DefaultAttributeFactory = factory;
        }

        // Helpers 

        private static ConstructorInfo GetAttributeAdapterConstructor(Type attributeType, Type adapterType)
        {
            ConstructorInfo constructor = adapterType.GetConstructor(new[] { typeof(IEnumerable<ModelValidatorProvider>), attributeType });
            if (constructor == null)
            {
                throw Error.Argument("adapterType", SRResources.DataAnnotationsModelValidatorProvider_ConstructorRequirements, adapterType.Name, typeof(ModelMetadata).Name, "IEnumerable<" + typeof(ModelValidatorProvider).Name + ">", attributeType.Name);
            }

            return constructor;
        }

        private static void ValidateAttributeAdapterType(Type adapterType)
        {
            if (adapterType == null)
            {
                throw Error.ArgumentNull("adapterType");
            }

            if (!typeof(ModelValidator).IsAssignableFrom(adapterType))
            {
                throw Error.Argument("adapterType", SRResources.Common_TypeMustDriveFromType, adapterType.Name, typeof(ModelValidator).Name);
            }
        }

        private static void ValidateAttributeType(Type attributeType)
        {
            if (attributeType == null)
            {
                throw Error.ArgumentNull("attributeType");
            }

            if (!typeof(ValidationAttribute).IsAssignableFrom(attributeType))
            {
                throw Error.Argument("attributeType", SRResources.Common_TypeMustDriveFromType, attributeType.Name, typeof(ValidationAttribute).Name);
            }
        }

        private static void ValidateAttributeFactory(DataAnnotationsModelValidationFactory factory)
        {
            if (factory == null)
            {
                throw Error.ArgumentNull("factory");
            }
        }

        #endregion

        #region IValidatableObject adapter registration

        /// <summary>
        /// Registers an adapter type for the given <paramref name="modelType"/>, which must
        /// implement <see cref="IValidatableObject"/>. The adapter type must derive from
        /// <see cref="ModelValidator"/> and it must contain a public constructor
        /// which takes two parameters of types <see cref="ModelMetadata"/> and
        /// <see cref="HttpActionContext"/>.
        /// </summary>
        public void RegisterValidatableObjectAdapter(Type modelType, Type adapterType)
        {
            ValidateValidatableModelType(modelType);
            ValidateValidatableAdapterType(adapterType);
            ConstructorInfo constructor = GetValidatableAdapterConstructor(adapterType);

                ValidatableFactories[modelType] = context => (ModelValidator)constructor.Invoke(new object[] { context });
            }

        /// <summary>
        /// Registers an adapter factory for the given <paramref name="modelType"/>, which must
        /// implement <see cref="IValidatableObject"/>.
        /// </summary>
        public void RegisterValidatableObjectAdapterFactory(Type modelType, DataAnnotationsValidatableObjectAdapterFactory factory)
        {
            ValidateValidatableModelType(modelType);
            ValidateValidatableFactory(factory);

                ValidatableFactories[modelType] = factory;
            }

        /// <summary>
        /// Registers the default adapter type for objects which implement
        /// <see cref="IValidatableObject"/>. The adapter type must derive from
        /// <see cref="ModelValidator"/> and it must contain a public constructor
        /// which takes two parameters of types <see cref="ModelMetadata"/> and
        /// <see cref="HttpActionContext"/>.
        /// </summary>
        public void RegisterDefaultValidatableObjectAdapter(Type adapterType)
        {
            ValidateValidatableAdapterType(adapterType);
            ConstructorInfo constructor = GetValidatableAdapterConstructor(adapterType);

            DefaultValidatableFactory = context => (ModelValidator)constructor.Invoke(new object[] { context });
        }

        /// <summary>
        /// Registers the default adapter factory for objects which implement
        /// <see cref="IValidatableObject"/>.
        /// </summary>
        public void RegisterDefaultValidatableObjectAdapterFactory(DataAnnotationsValidatableObjectAdapterFactory factory)
        {
            ValidateValidatableFactory(factory);

            DefaultValidatableFactory = factory;
        }

        // Helpers 

        private static ConstructorInfo GetValidatableAdapterConstructor(Type adapterType)
        {
            ConstructorInfo constructor = adapterType.GetConstructor(new[] { typeof(IEnumerable<ModelValidatorProvider>) });
            if (constructor == null)
            {
                throw Error.Argument("adapterType", SRResources.DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements, adapterType.Name, typeof(ModelMetadata).Name, "IEnumerable<" + typeof(ModelValidatorProvider).Name + ">");
            }

            return constructor;
        }

        private static void ValidateValidatableAdapterType(Type adapterType)
        {
            if (adapterType == null)
            {
                throw Error.ArgumentNull("adapterType");
            }
            if (!typeof(ModelValidator).IsAssignableFrom(adapterType))
            {
                throw Error.Argument("adapterType", SRResources.Common_TypeMustDriveFromType, adapterType.Name, typeof(ModelValidator).Name);
            }
        }

        private static void ValidateValidatableModelType(Type modelType)
        {
            if (modelType == null)
            {
                throw Error.ArgumentNull("modelType");
            }
            if (!typeof(IValidatableObject).IsAssignableFrom(modelType))
            {
                throw Error.Argument("modelType", SRResources.Common_TypeMustDriveFromType, modelType.Name, typeof(IValidatableObject).Name);
            }
        }

        private static void ValidateValidatableFactory(DataAnnotationsValidatableObjectAdapterFactory factory)
        {
            if (factory == null)
            {
                throw Error.ArgumentNull("factory");
            }
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Http/Validation/Providers/DataMemberModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Web.Http.Internal;
using System.Web.Http.Metadata;
using System.Web.Http.Validation.Validators;

namespace System.Web.Http.Validation.Providers
{
    /// <summary>
    /// This <see cref="ModelValidatorProvider"/> provides a required ModelValidator for members marked as [DataMember(IsRequired=true)].
    /// </summary>
    public class DataMemberModelValidatorProvider : AssociatedValidatorProvider
    {
        protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders, IEnumerable<Attribute> attributes)
        {
            // Types cannot be required; only properties can
            if (metadata.ContainerType == null || String.IsNullOrEmpty(metadata.PropertyName))
            {
                return Enumerable.Empty<ModelValidator>();
            }

            if (IsRequiredDataMember(metadata.ContainerType, attributes))
            {
                return new[] { new RequiredMemberModelValidator(validatorProviders) };
            }

            return Enumerable.Empty<ModelValidator>();
        }

        internal static bool IsRequiredDataMember(Type containerType, IEnumerable<Attribute> attributes)
        {
            DataMemberAttribute dataMemberAttribute = attributes.OfType<DataMemberAttribute>().FirstOrDefault();
            if (dataMemberAttribute != null)
            {
                // isDataContract == true iff the container type has at least one DataContractAttribute
                bool isDataContract = TypeDescriptorHelper.Get(containerType).GetAttributes().OfType<DataContractAttribute>().Any();
                if (isDataContract && dataMemberAttribute.IsRequired)
                {
                    return true;
                }
            }
            return false;
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/Providers/InvalidModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Reflection;
using System.Security;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;
using System.Web.Http.Validation.Validators;

namespace System.Web.Http.Validation.Providers
{
    /// <summary>
    /// An implementation of <see cref="ModelValidatorProvider"/> which provides validators that throw exceptions when the model is invalid.
    /// </summary>
    public class InvalidModelValidatorProvider : AssociatedValidatorProvider
    {
        protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders, IEnumerable<Attribute> attributes)
        {
            if (metadata.ContainerType == null || String.IsNullOrEmpty(metadata.PropertyName))
            {
                // Validate that the type's fields and nonpublic properties don't have any validation attributes on them
                // Validation only runs against public properties
                Type type = metadata.ModelType;
                PropertyInfo[] nonPublicProperties = type.GetProperties(BindingFlags.NonPublic | BindingFlags.Instance);
                foreach (PropertyInfo nonPublicProperty in nonPublicProperties)
                {
                    if (nonPublicProperty.GetCustomAttributes(typeof(ValidationAttribute), inherit: true).Length > 0)
                    {
                        yield return new ErrorModelValidator(validatorProviders, Error.Format(SRResources.ValidationAttributeOnNonPublicProperty, nonPublicProperty.Name, type));
                    }
                }

                FieldInfo[] allFields = metadata.ModelType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
                foreach (FieldInfo field in allFields)
                {
                    if (field.GetCustomAttributes(typeof(ValidationAttribute), inherit: true).Length > 0)
                    {
                        yield return new ErrorModelValidator(validatorProviders, Error.Format(SRResources.ValidationAttributeOnField, field.Name, type));
                    }
                }
            }
            else
            {
                // Validate that value-typed properties marked as [Required] are also marked as [DataMember(IsRequired=true)]
                // Certain formatters may not recognize a member as required if it's marked as [Required] but not [DataMember(IsRequired=true)]
                // This is not a problem for reference types because [Required] will still cause a model error to be raised after a null value is deserialized
                if (metadata.ModelType.IsValueType && attributes.Any(attribute => attribute is RequiredAttribute))
                {
                    if (!DataMemberModelValidatorProvider.IsRequiredDataMember(metadata.ContainerType, attributes))
                    {
                        yield return new ErrorModelValidator(validatorProviders, Error.Format(SRResources.MissingDataMemberIsRequired, metadata.PropertyName, metadata.ContainerType));
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/Providers/RequiredMemberModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting;
using System.Reflection;
using System.Web.Http.Metadata;
using System.Web.Http.Validation.Validators;

namespace System.Web.Http.Validation.Providers
{
    public class RequiredMemberModelValidatorProvider : ModelValidatorProvider
    {
        private IRequiredMemberSelector _requiredMemberSelector;

        public RequiredMemberModelValidatorProvider(IRequiredMemberSelector requiredMemberSelector)
        {
            _requiredMemberSelector = requiredMemberSelector;
        }

        public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders)
        {
            string propertyName = metadata.PropertyName;
            // if we're validating a property and not a type
            if (propertyName != null)
            {
                PropertyInfo metadataProperty = metadata.ContainerType.GetProperty(propertyName);
                if (_requiredMemberSelector.IsRequiredMember(metadataProperty))
                {
                    return new ModelValidator[] { new RequiredMemberModelValidator(validatorProviders) };
                }
            }

            return Enumerable.Empty<ModelValidator>();
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/ReferenceEqualityComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace System.Web.Http.Validation
{
    internal class ReferenceEqualityComparer : IEqualityComparer<object>
    {
        private static readonly ReferenceEqualityComparer _instance = new ReferenceEqualityComparer();

        public static ReferenceEqualityComparer Instance
        {
            get
            {
                return _instance;
            }
        }

        public new bool Equals(object x, object y)
        {
            return Object.ReferenceEquals(x, y);
        }

        public int GetHashCode(object obj)
        {
            return RuntimeHelpers.GetHashCode(obj);
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/Validators/DataAnnotationsModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel.DataAnnotations;
using System.Configuration;
using System.Linq;
using System.Web.Http.Metadata;

namespace System.Web.Http.Validation.Validators
{
    public class DataAnnotationsModelValidator : ModelValidator
    {
        internal static readonly string UseLegacyValidationMemberNameKey = "webapi:UseLegacyValidationMemberName";
        private static bool _useLegacyValidationMemberName =
            GetUseLegacyValidationMemberName(ConfigurationManager.AppSettings);

        public DataAnnotationsModelValidator(
            IEnumerable<ModelValidatorProvider> validatorProviders,
            ValidationAttribute attribute)
            : base(validatorProviders)
        {
            if (attribute == null)
            {
                throw Error.ArgumentNull("attribute");
            }

            Attribute = attribute;
        }

        // Internal for testing
        internal static bool UseLegacyValidationMemberName
        {
            get { return _useLegacyValidationMemberName; }
            set { _useLegacyValidationMemberName = value; }
        }

        protected internal ValidationAttribute Attribute { get; private set; }

        public override bool IsRequired
        {
            get { return Attribute is RequiredAttribute; }
        }

        public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
        {
            string memberName;
            if (_useLegacyValidationMemberName)
            {
                // Using member name from a Display or DisplayFormat attribute is generally incorrect. This
                // (configuration-controlled) override is provided only for corner cases where strict
                // back-compatibility is required.
                memberName = metadata.GetDisplayName();
            }
            else
            {
                // MemberName expression matches GetDisplayName() except it ignores Display and DisplayName
                // attributes. ModelType fallback isn't great and can separate errors and attempted values in the
                // ModelState. But, expression matches MVC, avoids a null MemberName, and is mostly back-compatible.
                memberName = metadata.PropertyName ?? metadata.ModelType.Name;
            }

            // Per the WCF RIA Services team, instance can never be null (if you have
            // no parent, you pass yourself for the "instance" parameter).
            ValidationContext context = new ValidationContext(instance: container ?? metadata.Model)
            {
                DisplayName = metadata.GetDisplayName(),
                MemberName = memberName,
            };

            ValidationResult result = Attribute.GetValidationResult(metadata.Model, context);

            if (result != ValidationResult.Success)
            {
                // ModelValidationResult.MemberName is used by invoking validators (such as ModelValidationNode) to
                // construct the ModelKey for ModelStateDictionary. When validating at type level we want to append the
                // returned MemberNames if specified (e.g. person.Address.FirstName). For property validation, the
                // ModelKey can be constructed using the ModelMetadata and we should ignore MemberName (we don't want
                // (person.Name.Name). However the invoking validator does not have a way to distinguish between these two
                // cases. Consequently we'll only set MemberName if this validation returns a MemberName that is different
                // from the property being validated.

                string errorMemberName = result.MemberNames.FirstOrDefault();
                if (String.Equals(errorMemberName, memberName, StringComparison.Ordinal))
                {
                    errorMemberName = null;
                }

                var validationResult = new ModelValidationResult
                {
                    Message = result.ErrorMessage,
                    MemberName = errorMemberName
                };

                return new ModelValidationResult[] { validationResult };
            }

            return Enumerable.Empty<ModelValidationResult>();
        }

        // Internal for testing
        internal static bool GetUseLegacyValidationMemberName(NameValueCollection appSettings)
        {
            var useLegacyMemberNameArray = appSettings.GetValues(UseLegacyValidationMemberNameKey);
            if (useLegacyMemberNameArray != null &&
                useLegacyMemberNameArray.Length > 0)
            {
                bool useLegacyMemberName;
                if (bool.TryParse(useLegacyMemberNameArray[0], out useLegacyMemberName) &&
                    useLegacyMemberName)
                {
                    return true;
                }
            }

            return false;
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/Validators/ErrorModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Metadata;

namespace System.Web.Http.Validation.Validators
{
    /// <summary>
    /// A <see cref="ModelValidator"/> to represent an error. This validator will always throw an exception regardless of the actual model value.
    /// </summary>
    public class ErrorModelValidator : ModelValidator
    {
        private string _errorMessage;

        public ErrorModelValidator(IEnumerable<ModelValidatorProvider> validatorProviders, string errorMessage) : base(validatorProviders)
        {
            if (errorMessage == null)
            {
                throw Error.ArgumentNull("errorMessage");
            }

            _errorMessage = errorMessage;
        }

        public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
        {
            throw Error.InvalidOperation(_errorMessage);
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/Validators/RequiredMemberModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Metadata;

namespace System.Web.Http.Validation.Validators
{
    /// <summary>
    /// <see cref="ModelValidator"/> for required members.
    /// </summary>
    public class RequiredMemberModelValidator : ModelValidator
    {
        public RequiredMemberModelValidator(IEnumerable<ModelValidatorProvider> validatorProviders)
            : base(validatorProviders)
        {
        }

        public override bool IsRequired
        {
            get { return true; }
        }

        public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
        {
            return Enumerable.Empty<ModelValidationResult>();
        }
    }
}


================================================
FILE: src/System.Web.Http/Validation/Validators/ValidatableObjectAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Http.Metadata;
using System.Web.Http.Properties;

namespace System.Web.Http.Validation.Validators
{
    public class ValidatableObjectAdapter : ModelValidator
    {
        public ValidatableObjectAdapter(IEnumerable<ModelValidatorProvider> validatorProviders)
            : base(validatorProviders)
        {
        }

        public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
        {
            // NOTE: Container is never used here, because IValidatableObject doesn't give you
            // any way to get access to your container.

            object model = metadata.Model;
            if (model == null)
            {
                return Enumerable.Empty<ModelValidationResult>();
            }

            IValidatableObject validatable = model as IValidatableObject;
            if (validatable == null)
            {
                throw Error.InvalidOperation(SRResources.ValidatableObjectAdapter_IncompatibleType, model.GetType());
            }

            ValidationContext validationContext = new ValidationContext(validatable, null, null);
            return ConvertResults(validatable.Validate(validationContext));
        }

        private static IEnumerable<ModelValidationResult> ConvertResults(IEnumerable<ValidationResult> results)
        {
            foreach (ValidationResult result in results)
            {
                if (result != ValidationResult.Success)
                {
                    if (result.MemberNames == null || !result.MemberNames.Any())
                    {
                        yield return new ModelValidationResult { Message = result.ErrorMessage };
                    }
                    else
                    {
                        foreach (string memberName in result.MemberNames)
                        {
                            yield return new ModelValidationResult { Message = result.ErrorMessage, MemberName = memberName };
                        }
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/IEnumerableValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.ValueProviders
{
    public interface IEnumerableValueProvider : IValueProvider
    {
        IDictionary<string, string> GetKeysFromPrefix(string prefix);
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/IUriValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Http.ValueProviders
{
    /// <summary>
    /// This interface is implemented by any <see cref="ValueProviderFactory"/> that supports
    /// the creation of a <see cref="IValueProvider"/> to access the <see cref="T:System.Uri"/> of
    /// an incoming <see cref="T:System.Net.Http.HttpRequestMessage"/>.
    /// </summary>
    [SuppressMessage("Microsoft.Design", "CA1040:AvoidEmptyInterfaces", Justification = "Tagging interface is intentional to allow Linq TypeOf")]
    public interface IUriValueProviderFactory
    {
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/IValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ValueProviders
{
    /// <summary>
    /// Defines the methods that are required for a value provider in ASP.NET Web Api.
    /// </summary>
    public interface IValueProvider
    {
        /// <summary>
        /// Determines whether the collection contains the specified prefix.
        /// </summary>
        /// <param name="prefix">The prefix to search for.</param>
        /// <returns>true if the collection contains the specified prefix; otherwise, false.</returns>
        bool ContainsPrefix(string prefix);

        /// <summary>
        /// Retrieves a value object using the specified key.
        /// </summary>
        /// <param name="key">The key of the value object to retrieve.</param>
        /// <returns>The value object for the specified key. If the exact key is not found, null.</returns>
        ValueProviderResult GetValue(string key);
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/CompositeValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

namespace System.Web.Http.ValueProviders.Providers
{
    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "It is more fundamentally a value provider than a collection")]
    public class CompositeValueProvider : Collection<IValueProvider>, IValueProvider, IEnumerableValueProvider
    {
        public CompositeValueProvider()
        {
        }

        public CompositeValueProvider(IList<IValueProvider> list)
            : base(list)
        {
        }

        public virtual bool ContainsPrefix(string prefix)
        {
            foreach (IValueProvider vp in this)
            {
                if (vp.ContainsPrefix(prefix))
                {
                    return true;
                }
            }
            return false;
        }

        public virtual ValueProviderResult GetValue(string key)
        {
            // Performance-sensitive
            // Caching the count is faster for IList<T>
            int itemCount = Items.Count;
            for (int i = 0; i < itemCount; i++)
            {
                IValueProvider vp = Items[i];
                ValueProviderResult result = vp.GetValue(key);
                if (result != null)
                {
                    return result;
                }
            }
            return null;
        }

        public virtual IDictionary<string, string> GetKeysFromPrefix(string prefix)
        {
            foreach (IValueProvider vp in this)
            {
                IDictionary<string, string> result = GetKeysFromPrefixFromProvider(vp, prefix);
                if (result != null && result.Count > 0)
                {
                    return result;
                }
            }
            return new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
        }

        internal static IDictionary<string, string> GetKeysFromPrefixFromProvider(IValueProvider provider, string prefix)
        {
            IEnumerableValueProvider enumeratedProvider = provider as IEnumerableValueProvider;
            return (enumeratedProvider != null) ? enumeratedProvider.GetKeysFromPrefix(prefix) : null;
        }

        protected override void InsertItem(int index, IValueProvider item)
        {
            if (item == null)
            {
                throw Error.ArgumentNull("item");
            }
            base.InsertItem(index, item);
        }

        protected override void SetItem(int index, IValueProvider item)
        {
            if (item == null)
            {
                throw Error.ArgumentNull("item");
            }
            base.SetItem(index, item);
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/CompositeValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;

namespace System.Web.Http.ValueProviders.Providers
{
    public class CompositeValueProviderFactory : ValueProviderFactory
    {
        private ValueProviderFactory[] _factories;

        public CompositeValueProviderFactory(IEnumerable<ValueProviderFactory> factories)
        {
            _factories = factories.ToArray();
        }

        public override IValueProvider GetValueProvider(HttpActionContext actionContext)
        {
            return GetValueProvider(actionContext, _factories);
        }

        // Get a single ValueProvider from a collection of factories. 
        // This will never return null.
        internal static IValueProvider GetValueProvider(HttpActionContext actionContext, ValueProviderFactory[] factories)
        {
            // Fast-path the case of just one factory
            if (factories.Length == 1)
            {
                IValueProvider provider = factories[0].GetValueProvider(actionContext);
                if (provider != null)
                {
                    return provider;
                }
            }

            List<IValueProvider> providers = new List<IValueProvider>();
            foreach (ValueProviderFactory factory in factories)
            {
                IValueProvider vp = factory.GetValueProvider(actionContext);
                if (vp != null)
                {
                    providers.Add(vp);
                }
            }

            // Fast-path the case of just one provider
            if (providers.Count == 1)
            {
                return providers[0];
            }
            
            return new CompositeValueProvider(providers);
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/ElementalValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;

namespace System.Web.Http.ValueProviders.Providers
{
    // Represents a value provider that contains a single value.
    internal sealed class ElementalValueProvider : IValueProvider
    {
        public ElementalValueProvider(string name, object rawValue, CultureInfo culture)
        {
            Name = name;
            RawValue = rawValue;
            Culture = culture;
        }

        public CultureInfo Culture { get; private set; }

        public string Name { get; private set; }

        public object RawValue { get; private set; }

        public bool ContainsPrefix(string prefix)
        {
            return PrefixContainer.IsPrefixMatch(prefix, Name);
        }

        public ValueProviderResult GetValue(string key)
        {
            return String.Equals(key, Name, StringComparison.OrdinalIgnoreCase)
                       ? new ValueProviderResult(RawValue, Convert.ToString(RawValue, Culture), Culture)
                       : null;
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/NameValuePairsValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;

namespace System.Web.Http.ValueProviders.Providers
{
    public class NameValuePairsValueProvider : IEnumerableValueProvider
    {
        private readonly CultureInfo _culture;
        private PrefixContainer _prefixContainer;
        private Dictionary<string, object> _values;
        private readonly Lazy<Dictionary<string, object>> _lazyValues;

        /// <summary>
        /// Creates a NameValuePairsProvider wrapping an existing set of key value pairs.
        /// </summary>
        /// <param name="values">The key value pairs to wrap.</param>
        /// <param name="culture">The culture to return with ValueProviderResult instances.</param>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Represents a collection of name/value pairs, cannot use NameValueCollection because it performs poorly")]
        public NameValuePairsValueProvider(IEnumerable<KeyValuePair<string, string>> values, CultureInfo culture)
        {
            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            _values = InitializeValues(values);
            _culture = culture;
        }

        /// <summary>
        /// Creates a NameValuePairsProvider wrapping a lazily evaluated set of key value pairs.
        /// </summary>
        /// <param name="valuesFactory">A function returning the key value pairs to wrap.</param>
        /// <param name="culture">The culture to return with ValueProviderResult instances.</param>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Represents a collection of name/value pairs, cannot use NameValueCollection because it performs poorly")]
        public NameValuePairsValueProvider(Func<IEnumerable<KeyValuePair<string, string>>> valuesFactory, CultureInfo culture)
        {
            if (valuesFactory == null)
            {
                throw Error.ArgumentNull("valuesFactory");
            }
            _lazyValues = new Lazy<Dictionary<string, object>>(() => InitializeValues(valuesFactory()), isThreadSafe: true);
            _culture = culture;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="NameValuePairsValueProvider"/> class.
        /// </summary>
        /// <param name="values">The name value pairs.</param>
        /// <param name="culture">The culture to return with ValueProviderResult instances.</param>
        public NameValuePairsValueProvider(IDictionary<string, object> values, CultureInfo culture)
        {
            if (values == null)
            {
                throw Error.ArgumentNull("values");
            }

            _values = InitializeValues(values);
            _culture = culture;
        }

        // For unit testing purposes
        internal CultureInfo Culture
        {
            get
            {
                return _culture;
            }
        }

        private PrefixContainer PrefixContainer
        {
            get
            {
                if (_prefixContainer == null)
                {
                    // Initialization race is OK providing data remains read-only and object identity is not significant
                    _prefixContainer = new PrefixContainer(Values.Keys);
                }
                return _prefixContainer;
            }
        }

        private Dictionary<string, object> Values
        {
            get
            {
                if (_values == null)
                {
                    Contract.Assert(_lazyValues != null);
                    _values = _lazyValues.Value;
                }
                return _values;
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "One of the casts is conditionally compiled")]
        private static Dictionary<string, object> InitializeValues<T>(IEnumerable<KeyValuePair<string, T>> nameValuePairs)
            where T : class
        {
            // Performance-sensitive.
            // Optimize for the cases of 0 pairs, and for names being unique when present.
            Dictionary<string, object> valuesDictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

            // Avoid looping in the 0 case.
            KeyValuePair<string, string>[] nameValuePairsArray = nameValuePairs as KeyValuePair<string, string>[];
            if (nameValuePairsArray != null && nameValuePairsArray.Length == 0)
            {
                return valuesDictionary;
            }
            Dictionary<string, object> nameValuePairsDictionary = nameValuePairs as Dictionary<string, object>;
            if (nameValuePairsDictionary != null && nameValuePairsDictionary.Count == 0)
            {
                return valuesDictionary;
            }

            foreach (KeyValuePair<string, T> nameValuePair in nameValuePairs)
            {
                string name = nameValuePair.Key;
                object value;
                // We optimize for the common case of a name being associated with exactly one value by avoiding a List
                // allocation if we can avoid it. The first time the key appears, the value gets stored as a string. 
                // Only if the key appears a second time do we allocate a List to store the values for that key.
                if (valuesDictionary.TryGetValue(name, out value))
                {
                    List<T> values = value as List<T>;
                    if (values == null)
                    {
                        // allocate a new list to store the first value and the second, new value
                        valuesDictionary[name] = new List<T>() { value as T, nameValuePair.Value };
                    }
                    else
                    {
                        values.Add(nameValuePair.Value);
                    }
                }
                else
                {
                    valuesDictionary[name] = nameValuePair.Value;
                }
            }
            return valuesDictionary;
        }

        public virtual bool ContainsPrefix(string prefix)
        {
            return PrefixContainer.ContainsPrefix(prefix);
        }

        public virtual IDictionary<string, string> GetKeysFromPrefix(string prefix)
        {
            if (prefix == null)
            {
                throw Error.ArgumentNull("prefix");
            }

            return PrefixContainer.GetKeysFromPrefix(prefix);
        }

        public virtual ValueProviderResult GetValue(string key)
        {
            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            object value;
            if (Values.TryGetValue(key, out value))
            {
                return new ValueProviderResult(value, GetAttemptedValue(value), _culture);
            }
            else
            {
                return null;
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily", Justification = "One of the casts is conditionally compiled")]
        private static string GetAttemptedValue(object value)
        {
            List<string> valueStrings = value as List<string>;
            if (valueStrings == null)
            {
                return value as string;
            }
            else
            {
                return String.Join(",", valueStrings);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/QueryStringValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Net.Http;
using System.Web.Http.Controllers;

namespace System.Web.Http.ValueProviders.Providers
{
    public class QueryStringValueProvider : NameValuePairsValueProvider
    {
        public QueryStringValueProvider(HttpActionContext actionContext, CultureInfo culture)
            : base(actionContext.ControllerContext.Request.GetQueryNameValuePairs(), culture)
        {
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/QueryStringValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Http.Controllers;

namespace System.Web.Http.ValueProviders.Providers
{
    public class QueryStringValueProviderFactory : ValueProviderFactory, IUriValueProviderFactory
    {
        private const string RequestLocalStorageKey = "{8572540D-3BD9-46DA-B112-A1E6C9086003}";

        public override IValueProvider GetValueProvider(HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            // Only parse the query string once-per request. 
                        
            QueryStringValueProvider provider;
            IDictionary<string, object> storage  = actionContext.Request.Properties;

            if (!storage.TryGetValue(RequestLocalStorageKey, out provider))
            {
                provider = new QueryStringValueProvider(actionContext, CultureInfo.InvariantCulture);
                storage[RequestLocalStorageKey] = provider;
            }            
            
            return provider;
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/RouteDataValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;

namespace System.Web.Http.ValueProviders.Providers
{
    public class RouteDataValueProvider : NameValuePairsValueProvider
    {
        public RouteDataValueProvider(HttpActionContext actionContext, CultureInfo culture)
            : base(GetRouteValues(actionContext.ControllerContext.RouteData), culture)
        {
        }

        internal static IEnumerable<KeyValuePair<string, string>> GetRouteValues(IHttpRouteData routeData)
        {
            foreach (KeyValuePair<string, object> pair in routeData.Values)
            {
                string value = (pair.Value == null) ? null : pair.Value.ToString();
                yield return new KeyValuePair<string, string>(pair.Key, value);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/Providers/RouteDataValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Http.Controllers;

namespace System.Web.Http.ValueProviders.Providers
{
    public class RouteDataValueProviderFactory : ValueProviderFactory, IUriValueProviderFactory
    {
        private const string RequestLocalStorageKey = "{C0E50671-A1D4-429E-93C9-2AA63779924F}";

        public override IValueProvider GetValueProvider(HttpActionContext actionContext)
        {
            if (actionContext == null)
            {
                throw Error.ArgumentNull("actionContext");
            }

            // cache the route provider across requests so that we don't recompute on every parameter.
            RouteDataValueProvider provider;
            IDictionary<string, object> storage = actionContext.Request.Properties;

            if (!storage.TryGetValue(RequestLocalStorageKey, out provider))
            {
                provider = new RouteDataValueProvider(actionContext, CultureInfo.InvariantCulture);
                storage[RequestLocalStorageKey] = provider;
            }

            return provider;       
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/ValueProviderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using System.Web.Http.Properties;

namespace System.Web.Http.ValueProviders
{
    /// <summary>
    /// This attribute is used to specify a custom <see cref="ValueProviderFactory"/>.
    /// </summary>
    [SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification = "property already exposed in plural form")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
    public sealed class ValueProviderAttribute : ModelBinderAttribute
    {
        private readonly Type[] _valueProviderFactoryTypes;

        // Provide CLS compliant overload
        public ValueProviderAttribute(Type valueProviderFactory)
            : this(new Type[] { valueProviderFactory })
        {
        }

        // Convenience for multiple types. This is not cls-compliant.
        public ValueProviderAttribute(params Type[] valueProviderFactories)
        {
            _valueProviderFactoryTypes = valueProviderFactories;
        }

        public IEnumerable<Type> ValueProviderFactoryTypes
        {
            get { return _valueProviderFactoryTypes; }
        }

        public override IEnumerable<ValueProviderFactory> GetValueProviderFactories(HttpConfiguration configuration)
        {
            // By default, just get all registered value provider factories
            return Array.ConvertAll(_valueProviderFactoryTypes, Instantiate);
        }

        private static ValueProviderFactory Instantiate(Type factoryType)
        {
            if (factoryType == null)
            {
                throw new ArgumentNullException("factoryType");
            }

            if (!typeof(ValueProviderFactory).IsAssignableFrom(factoryType))
            {
                throw Error.InvalidOperation(SRResources.ValueProviderFactory_Cannot_Create, typeof(ValueProviderFactory), factoryType);
            }

            return (ValueProviderFactory)Activator.CreateInstance(factoryType);
        }
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/ValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;

namespace System.Web.Http.ValueProviders
{
    public abstract class ValueProviderFactory
    {
        /// <summary>
        /// Get a value provider with values from the given <paramref name="actionContext"/>.
        /// </summary>
        /// <param name="actionContext">action context that value provider will populate from</param>
        /// <returns>a value provider instance or null</returns>
        public abstract IValueProvider GetValueProvider(HttpActionContext actionContext);
    }
}


================================================
FILE: src/System.Web.Http/ValueProviders/ValueProviderResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.ComponentModel;
using System.Globalization;
using System.Web.Http.Properties;

namespace System.Web.Http.ValueProviders
{
    [Serializable]
    public class ValueProviderResult
    {
        private static readonly CultureInfo _staticCulture = CultureInfo.InvariantCulture;
        private CultureInfo _instanceCulture;

        // default constructor so that subclassed types can set the properties themselves
        protected ValueProviderResult()
        {
        }

        public ValueProviderResult(object rawValue, string attemptedValue, CultureInfo culture)
        {
            RawValue = rawValue;
            AttemptedValue = attemptedValue;
            Culture = culture;
        }

        public string AttemptedValue { get; protected set; }

        public CultureInfo Culture
        {
            get
            {
                if (_instanceCulture == null)
                {
                    _instanceCulture = _staticCulture;
                }
                return _instanceCulture;
            }
            protected set { _instanceCulture = value; }
        }

        public object RawValue { get; protected set; }

        private static object ConvertSimpleType(CultureInfo culture, object value, Type destinationType)
        {
            if (value == null || destinationType.IsInstanceOfType(value))
            {
                return value;
            }

            // if this is a user-input value but the user didn't type anything, return no value
            string valueAsString = value as string;

            if (valueAsString != null && String.IsNullOrWhiteSpace(valueAsString))
            {
                return null;
            }

            TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
            bool canConvertFrom = converter.CanConvertFrom(value.GetType());
            if (!canConvertFrom)
            {
                converter = TypeDescriptor.GetConverter(value.GetType());
            }
            if (!(canConvertFrom || converter.CanConvertTo(destinationType)))
            {
                // EnumConverter cannot convert integer, so we verify manually
                if (destinationType.IsEnum && value is int)
                {
                    return Enum.ToObject(destinationType, (int)value);
                }

                // In case of a Nullable object, we try again with its underlying type.
                Type underlyingType = Nullable.GetUnderlyingType(destinationType);
                if (underlyingType != null)
                {
                    return ConvertSimpleType(culture, value, underlyingType);
                }

                throw Error.InvalidOperation(SRResources.ValueProviderResult_NoConverterExists, value.GetType(), destinationType);
            }

            try
            {
                return canConvertFrom
                           ? converter.ConvertFrom(null, culture, value)
                           : converter.ConvertTo(null, culture, value, destinationType);
            }
            catch (Exception ex)
            {
                throw Error.InvalidOperation(ex, SRResources.ValueProviderResult_ConversionThrew, value.GetType(), destinationType);
            }
        }

        public object ConvertTo(Type type)
        {
            return ConvertTo(type, null /* culture */);
        }

        public virtual object ConvertTo(Type type, CultureInfo culture)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            object value = RawValue;
            if (value == null)
            {
                // treat null route parameters as though they were the default value for the type
                return type.IsValueType ? Activator.CreateInstance(type) : null;
            }

            if (type.IsInstanceOfType(value))
            {
                return value;
            }

            CultureInfo cultureToUse = culture ?? Culture;
            return UnwrapPossibleListType(cultureToUse, value, type);
        }

        private static object UnwrapPossibleListType(CultureInfo culture, object value, Type destinationType)
        {
            // array conversion results in four cases, as below
            IList valueAsList = value as IList;
            if (destinationType.IsArray)
            {
                Type destinationElementType = destinationType.GetElementType();
                if (valueAsList != null)
                {
                    // case 1: both destination + source type are lists, so convert each element
                    IList converted = Array.CreateInstance(destinationElementType, valueAsList.Count);
                    for (int i = 0; i < valueAsList.Count; i++)
                    {
                        converted[i] = ConvertSimpleType(culture, valueAsList[i], destinationElementType);
                    }
                    return converted;
                }
                else
                {
                    // case 2: destination type is array but source is single element, so wrap element in array + convert
                    object element = ConvertSimpleType(culture, value, destinationElementType);
                    IList converted = Array.CreateInstance(destinationElementType, 1);
                    converted[0] = element;
                    return converted;
                }
            }
            else if (valueAsList != null)
            {
                // case 3: destination type is single element but source is array, so extract first element + convert
                if (valueAsList.Count > 0)
                {
                    value = valueAsList[0];
                    return ConvertSimpleType(culture, value, destinationType);
                }
                else
                {
                    // case 3(a): source is empty array, so can't perform conversion
                    return null;
                }
            }

            // case 4: both destination + source type are single elements, so convert
            return ConvertSimpleType(culture, value, destinationType);
        }
    }
}


================================================
FILE: src/System.Web.Http/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.Http.Cors/AttributeBasedPolicyProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net.Http;
using System.Web.Cors;
using System.Web.Http.Controllers;
using System.Web.Http.Cors.Properties;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// An implementation of <see cref="ICorsPolicyProviderFactory"/> that returns the <see cref="ICorsPolicyProvider"/> from the controller or action attribute.
    /// </summary>
    public class AttributeBasedPolicyProviderFactory : ICorsPolicyProviderFactory
    {
        private const string HttpContextBaseKey = "MS_HttpContext";

        /// <summary>
        /// Gets or sets the default <see cref="ICorsPolicyProvider"/>.
        /// </summary>
        public ICorsPolicyProvider DefaultPolicyProvider { get; set; }

        /// <summary>
        /// Gets the <see cref="ICorsPolicyProvider" /> for the request.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>
        /// The <see cref="ICorsPolicyProvider" />.
        /// </returns>
        /// <exception cref="System.ArgumentNullException">request</exception>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The object is registered for disposal when the request message is disposed.")]
        public virtual ICorsPolicyProvider GetCorsPolicyProvider(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            CorsRequestContext corsRequestContext = request.GetCorsRequestContext();
            HttpActionDescriptor actionDescriptor = null;
            if (corsRequestContext.IsPreflight)
            {
                HttpRequestMessage targetRequest = new HttpRequestMessage(new HttpMethod(corsRequestContext.AccessControlRequestMethod), request.RequestUri);

                request.RegisterForDispose(targetRequest);

                try
                {
                    foreach (var property in request.Properties)
                    {
                        // The RouteData and HttpContext from the preflight request properties contain information
                        // relevant to the preflight request and not the actual request, therefore we need to exclude them.
                        if (property.Key != HttpPropertyKeys.HttpRouteDataKey &&
                            property.Key != HttpContextBaseKey)
                        {
                            targetRequest.Properties.Add(property.Key, property.Value);
                        }
                    }

                    HttpConfiguration config = request.GetConfiguration();
                    if (config == null)
                    {
                        throw new InvalidOperationException(SRResources.NoConfiguration);
                    }

                    IHttpRouteData routeData = config.Routes.GetRouteData(request);
                    if (routeData == null)
                    {
                        // No route data found for selecting action with EnableCorsAttribute, thus no ICorsPolicyProvider is returned
                        // and let the CorsMessageHandler flow the request to the normal Web API pipeline.
                        return null;
                    }

                    actionDescriptor = SelectAction(targetRequest, routeData, config);
                }
                catch
                {
                    if (DefaultPolicyProvider != null)
                    {
                        return DefaultPolicyProvider;
                    }
                    throw;
                }
            }
            else
            {
                actionDescriptor = request.GetActionDescriptor();
            }

            return GetCorsPolicyProvider(actionDescriptor);
        }

        private ICorsPolicyProvider GetCorsPolicyProvider(HttpActionDescriptor actionDescriptor)
        {
            ICorsPolicyProvider policyProvider = null;
            if (actionDescriptor != null)
            {
                HttpControllerDescriptor controllerDescriptor = actionDescriptor.ControllerDescriptor;
                policyProvider = actionDescriptor.GetCustomAttributes<ICorsPolicyProvider>().FirstOrDefault();
                if (policyProvider == null && controllerDescriptor != null)
                {
                    policyProvider = controllerDescriptor.GetCustomAttributes<ICorsPolicyProvider>().FirstOrDefault();
                }
            }

            if (policyProvider == null)
            {
                policyProvider = DefaultPolicyProvider;
            }

            return policyProvider;
        }

        private static HttpActionDescriptor SelectAction(HttpRequestMessage request, IHttpRouteData routeData, HttpConfiguration config)
        {
            request.SetRouteData(routeData);

            routeData.RemoveOptionalRoutingParameters();

            HttpControllerDescriptor controllerDescriptor = config.Services.GetHttpControllerSelector().SelectController(request);

            // Get the per-controller configuration
            config = controllerDescriptor.Configuration;
            request.SetConfiguration(config);
            HttpRequestContext requestContext = request.GetRequestContext();

            if (requestContext == null)
            {
                requestContext = new HttpRequestContext
                {
                    Configuration = config,
                    RouteData = routeData,
                    Url = new UrlHelper(request),
                    VirtualPathRoot = config.VirtualPathRoot
                };
            }

            IHttpController controller = controllerDescriptor.CreateController(request);
            using (controller as IDisposable)
            {
                HttpControllerContext controllerContext = new HttpControllerContext(requestContext, request, controllerDescriptor, controller);
                return config.Services.GetActionSelector().SelectAction(controllerContext);
            }
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/CorsHttpConfigurationExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Web.Cors;
using System.Web.Http.Cors;
using System.Web.Http.Cors.Tracing;
using System.Web.Http.Tracing;

namespace System.Web.Http
{
    /// <summary>
    /// CORS-related extension methods for <see cref="HttpConfiguration"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class CorsHttpConfigurationExtensions
    {
        private const string CorsEngineKey = "MS_CorsEngineKey";
        private const string CorsPolicyProviderFactoryKey = "MS_CorsPolicyProviderFactoryKey";
        private const string CorsEnabledKey = "MS_CorsEnabledKey";

        /// <summary>
        /// Enables the support for CORS.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        public static void EnableCors(this HttpConfiguration httpConfiguration)
        {
            EnableCors(httpConfiguration, null, false);
        }
        
        /// <summary>
        /// Enables the support for CORS.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="rethrowExceptions">Indicates whether upstream exceptions should be rethrown</param>
        public static void EnableCors(this HttpConfiguration httpConfiguration, bool rethrowExceptions)
        {
            EnableCors(httpConfiguration, null, rethrowExceptions);
        }

        /// <summary>
        /// Enables the support for CORS.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="defaultPolicyProvider">The default <see cref="ICorsPolicyProvider"/>.</param>
        public static void EnableCors(this HttpConfiguration httpConfiguration, ICorsPolicyProvider defaultPolicyProvider)
        {
            EnableCors(httpConfiguration, defaultPolicyProvider, false);
        }

        /// <summary>
        /// Enables the support for CORS.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="defaultPolicyProvider">The default <see cref="ICorsPolicyProvider"/>.</param>
        /// <param name="rethrowExceptions">Indicates whether upstream exceptions should be rethrown</param>
        /// <exception cref="System.ArgumentNullException">httpConfiguration</exception>
        public static void EnableCors(this HttpConfiguration httpConfiguration, ICorsPolicyProvider defaultPolicyProvider,
            bool rethrowExceptions)
        {
            if (httpConfiguration == null)
            {
                throw new ArgumentNullException("httpConfiguration");
            }

            if (defaultPolicyProvider != null)
            {
                AttributeBasedPolicyProviderFactory policyProviderFactory = new AttributeBasedPolicyProviderFactory();
                policyProviderFactory.DefaultPolicyProvider = defaultPolicyProvider;
                httpConfiguration.SetCorsPolicyProviderFactory(policyProviderFactory);
            }

            AddCorsMessageHandler(httpConfiguration, rethrowExceptions);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller owns the disposable object")]
        private static void AddCorsMessageHandler(this HttpConfiguration httpConfiguration, bool rethrowExceptions)
        {
            object corsEnabled;
            if (!httpConfiguration.Properties.TryGetValue(CorsEnabledKey, out corsEnabled))
            {
                Action<HttpConfiguration> defaultInitializer = httpConfiguration.Initializer;
                httpConfiguration.Initializer = config =>
                {
                    if (!config.Properties.TryGetValue(CorsEnabledKey, out corsEnabled))
                    {
                        // Execute this in the Initializer to ensure that the CorsMessageHandler is added last.
                        config.MessageHandlers.Add(new CorsMessageHandler(config, rethrowExceptions));

                        ITraceWriter traceWriter = config.Services.GetTraceWriter();

                        if (traceWriter != null)
                        {
                            ICorsPolicyProviderFactory factory = config.GetCorsPolicyProviderFactory();
                            config.SetCorsPolicyProviderFactory(new CorsPolicyProviderFactoryTracer(factory, traceWriter));
                            ICorsEngine corsEngine = config.GetCorsEngine();
                            config.SetCorsEngine(new CorsEngineTracer(corsEngine, traceWriter));
                        }

                        config.Properties[CorsEnabledKey] = true;
                    }
                    defaultInitializer(config);
                };
            }
        }

        /// <summary>
        /// Sets the <see cref="ICorsEngine"/> on the <see cref="HttpConfiguration"/>.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="corsEngine">The <see cref="ICorsEngine"/>.</param>
        /// <exception cref="System.ArgumentNullException">
        /// httpConfiguration
        /// or
        /// corsEngine
        /// </exception>
        public static void SetCorsEngine(this HttpConfiguration httpConfiguration, ICorsEngine corsEngine)
        {
            if (httpConfiguration == null)
            {
                throw new ArgumentNullException("httpConfiguration");
            }
            if (corsEngine == null)
            {
                throw new ArgumentNullException("corsEngine");
            }

            httpConfiguration.Properties[CorsEngineKey] = corsEngine;
        }

        /// <summary>
        /// Gets the <see cref="ICorsEngine"/> from the <see cref="HttpConfiguration"/>.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <returns>The <see cref="ICorsEngine"/>.</returns>
        /// <exception cref="System.ArgumentNullException">httpConfiguration</exception>
        public static ICorsEngine GetCorsEngine(this HttpConfiguration httpConfiguration)
        {
            if (httpConfiguration == null)
            {
                throw new ArgumentNullException("httpConfiguration");
            }

            return (ICorsEngine)httpConfiguration.Properties.GetOrAdd(CorsEngineKey, k => new CorsEngine());
        }

        /// <summary>
        /// Sets the <see cref="ICorsPolicyProviderFactory"/> on the <see cref="HttpConfiguration"/>.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="corsPolicyProviderFactory">The <see cref="ICorsPolicyProviderFactory"/>.</param>
        /// <exception cref="System.ArgumentNullException">
        /// httpConfiguration
        /// or
        /// corsPolicyProviderFactory
        /// </exception>
        public static void SetCorsPolicyProviderFactory(this HttpConfiguration httpConfiguration, ICorsPolicyProviderFactory corsPolicyProviderFactory)
        {
            if (httpConfiguration == null)
            {
                throw new ArgumentNullException("httpConfiguration");
            }
            if (corsPolicyProviderFactory == null)
            {
                throw new ArgumentNullException("corsPolicyProviderFactory");
            }

            httpConfiguration.Properties[CorsPolicyProviderFactoryKey] = corsPolicyProviderFactory;
        }

        /// <summary>
        /// Gets the <see cref="ICorsPolicyProviderFactory"/> from the <see cref="HttpConfiguration"/>.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <returns>The <see cref="ICorsPolicyProviderFactory"/>.</returns>
        /// <exception cref="System.ArgumentNullException">httpConfiguration</exception>
        public static ICorsPolicyProviderFactory GetCorsPolicyProviderFactory(this HttpConfiguration httpConfiguration)
        {
            if (httpConfiguration == null)
            {
                throw new ArgumentNullException("httpConfiguration");
            }

            return (ICorsPolicyProviderFactory)httpConfiguration.Properties.GetOrAdd(CorsPolicyProviderFactoryKey, k => new AttributeBasedPolicyProviderFactory());
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/CorsHttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Net.Http;
using System.Web.Cors;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// CORS-related extension methods for <see cref="HttpRequestMessage"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class CorsHttpRequestMessageExtensions
    {
        private const string CorsRequestContextKey = "MS_CorsRequestContextKey";

        /// <summary>
        /// Gets the <see cref="CorsRequestContext"/> for a given request.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/>.</param>
        /// <returns>The <see cref="CorsRequestContext"/>.</returns>
        /// <exception cref="System.ArgumentNullException">request</exception>
        public static CorsRequestContext GetCorsRequestContext(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            object corsRequestContext;
            if (!request.Properties.TryGetValue(CorsRequestContextKey, out corsRequestContext))
            {
                if (!request.Headers.Contains(CorsConstants.Origin))
                {
                    return null;
                }

                CorsRequestContext requestContext = new CorsRequestContext
                {
                    RequestUri = request.RequestUri,
                    HttpMethod = request.Method.Method,
                    Host = request.Headers.Host,
                    Origin = request.GetHeader(CorsConstants.Origin),
                    AccessControlRequestMethod = request.GetHeader(CorsConstants.AccessControlRequestMethod)
                };
                requestContext.Properties.Add(typeof(HttpRequestMessage).FullName, request);

                IEnumerable<string> accessControlRequestHeaders = request.GetHeaders(CorsConstants.AccessControlRequestHeaders);
                foreach (string accessControlRequestHeader in accessControlRequestHeaders)
                {
                    if (accessControlRequestHeader != null)
                    {
                        IEnumerable<string> headerValues = accessControlRequestHeader.Split(',').Select(x => x.Trim());
                        foreach (string header in headerValues)
                        {
                            requestContext.AccessControlRequestHeaders.Add(header);
                        }
                    }
                }

                request.Properties.Add(CorsRequestContextKey, requestContext);
                corsRequestContext = requestContext;
            }

            return (CorsRequestContext)corsRequestContext;
        }

        private static string GetHeader(this HttpRequestMessage request, string name)
        {
            return request.GetHeaders(name).FirstOrDefault();
        }

        private static IEnumerable<string> GetHeaders(this HttpRequestMessage request, string name)
        {
            IEnumerable<string> headerValues;
            if (request.Headers.TryGetValues(name, out headerValues))
            {
                if (headerValues != null)
                {
                    return headerValues;
                }
            }

            return Enumerable.Empty<string>();
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/CorsHttpResponseMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Net.Http;
using System.Web.Cors;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// CORS-related extension methods for <see cref="HttpResponseMessage"/>.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class CorsHttpResponseMessageExtensions
    {
        /// <summary>
        /// Writes the CORS headers on the response.
        /// </summary>
        /// <param name="response">The <see cref="HttpResponseMessage"/>.</param>
        /// <param name="corsResult">The <see cref="CorsResult"/>.</param>
        /// <exception cref="System.ArgumentNullException">
        /// response
        /// or
        /// corsResult
        /// </exception>
        public static void WriteCorsHeaders(this HttpResponseMessage response, CorsResult corsResult)
        {
            if (response == null)
            {
                throw new ArgumentNullException("response");
            }
            if (corsResult == null)
            {
                throw new ArgumentNullException("corsResult");
            }

            IDictionary<string, string> corsHeaders = corsResult.ToResponseHeaders();
            if (corsHeaders != null)
            {
                foreach (KeyValuePair<string, string> header in corsHeaders)
                {
                    response.Headers.TryAddWithoutValidation(header.Key, header.Value);
                }
            }
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/CorsMessageHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;
using System.Web.Http.Cors.Properties;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// Custom <see cref="DelegatingHandler"/> for handling CORS requests.
    /// </summary>
    public class CorsMessageHandler : DelegatingHandler
    {
        private HttpConfiguration _httpConfiguration;
        private bool _rethrowExceptions;

        /// <summary>
        /// Initializes a new instance of the <see cref="CorsMessageHandler"/> class.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <exception cref="System.ArgumentNullException">httpConfiguration</exception>
        public CorsMessageHandler(HttpConfiguration httpConfiguration) : this(httpConfiguration, false)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CorsMessageHandler"/> class.
        /// </summary>
        /// <param name="httpConfiguration">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="rethrowExceptions">Indicates whether upstream exceptions should be rethrown</param>
        /// <exception cref="System.ArgumentNullException">httpConfiguration</exception>
        public CorsMessageHandler(HttpConfiguration httpConfiguration, bool rethrowExceptions)
        {
            if (httpConfiguration == null)
            {
                throw new ArgumentNullException("httpConfiguration");
            }

            _httpConfiguration = httpConfiguration;
            _rethrowExceptions = rethrowExceptions;
        }

        /// <summary>
        /// Sends an HTTP request to the inner handler to send to the server as an asynchronous operation.
        /// </summary>
        /// <param name="request">The HTTP request message to send to the server.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>
        /// Returns <see cref="T:System.Threading.Tasks.Task`1" />. The task object representing the asynchronous operation.
        /// </returns>
        protected async override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            CorsRequestContext corsRequestContext = request.GetCorsRequestContext();
            if (corsRequestContext != null)
            {
                try
                {
                    if (corsRequestContext.IsPreflight)
                    {
                        return await HandleCorsPreflightRequestAsync(request, corsRequestContext, cancellationToken);
                    }
                    else
                    {
                        return await HandleCorsRequestAsync(request, corsRequestContext, cancellationToken);
                    }
                }
                catch (Exception exception)
                {
                    if (_rethrowExceptions)
                    {
                        throw;
                    }

                    return HandleException(request, exception);
                }
            }
            else
            {
                return await base.SendAsync(request, cancellationToken);
            }
        }

        /// <summary>
        /// Handles the actual CORS request.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/>.</param>
        /// <param name="corsRequestContext">The <see cref="CorsRequestContext"/>.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
        /// <returns>The <see cref="Task{HttpResponseMessage}"/>.</returns>
        /// <exception cref="System.ArgumentNullException">
        /// request
        /// or
        /// corsRequestContext
        /// </exception>
        public virtual async Task<HttpResponseMessage> HandleCorsRequestAsync(HttpRequestMessage request, CorsRequestContext corsRequestContext, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }
            if (corsRequestContext == null)
            {
                throw new ArgumentNullException("corsRequestContext");
            }

            HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
            CorsPolicy corsPolicy = await GetCorsPolicyAsync(request, cancellationToken);
            if (corsPolicy != null)
            {
                CorsResult result;
                if (TryEvaluateCorsPolicy(corsRequestContext, corsPolicy, out result))
                {
                    if (response != null)
                    {
                        response.WriteCorsHeaders(result);
                    }
                }
            }
            return response;
        }

        /// <summary>
        /// Handles the preflight request specified by CORS.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="corsRequestContext">The cors request context.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>The <see cref="Task{HttpResponseMessage}"/></returns>
        /// <exception cref="System.ArgumentNullException">
        /// request
        /// or
        /// corsRequestContext
        /// </exception>
        public virtual async Task<HttpResponseMessage> HandleCorsPreflightRequestAsync(HttpRequestMessage request, CorsRequestContext corsRequestContext, CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }
            if (corsRequestContext == null)
            {
                throw new ArgumentNullException("corsRequestContext");
            }

            try
            {
                // Make sure Access-Control-Request-Method is valid.
                new HttpMethod(corsRequestContext.AccessControlRequestMethod);
            }
            catch (ArgumentException)
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest,
                        SRResources.AccessControlRequestMethodCannotBeNullOrEmpty);
            }
            catch (FormatException)
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest,
                    String.Format(CultureInfo.CurrentCulture,
                        SRResources.InvalidAccessControlRequestMethod,
                        corsRequestContext.AccessControlRequestMethod));
            }

            CorsPolicy corsPolicy = await GetCorsPolicyAsync(request, cancellationToken);
            if (corsPolicy != null)
            {
                HttpResponseMessage response = null;
                CorsResult result;
                if (TryEvaluateCorsPolicy(corsRequestContext, corsPolicy, out result))
                {
                    response = request.CreateResponse(HttpStatusCode.OK);
                    response.WriteCorsHeaders(result);
                }
                else
                {
                    response = result != null ?
                        request.CreateErrorResponse(HttpStatusCode.BadRequest, String.Join(" | ", result.ErrorMessages)) :
                        request.CreateResponse(HttpStatusCode.BadRequest);
                }

                return response;
            }
            else
            {
                return await base.SendAsync(request, cancellationToken);
            }
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller owns HttpRequestMessage instance.")]
        private static HttpResponseMessage HandleException(HttpRequestMessage request, Exception exception)
        {
            HttpResponseException httpResponseException = exception as HttpResponseException;

            if (httpResponseException != null)
            {
                return httpResponseException.Response;
            }

            return request.CreateErrorResponse(HttpStatusCode.InternalServerError, exception);
        }

        private async Task<CorsPolicy> GetCorsPolicyAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            CorsPolicy corsPolicy = null;
            ICorsPolicyProviderFactory corsPolicyProviderFactory = _httpConfiguration.GetCorsPolicyProviderFactory();
            ICorsPolicyProvider corsPolicyProvider = corsPolicyProviderFactory.GetCorsPolicyProvider(request);
            if (corsPolicyProvider != null)
            {
                corsPolicy = await corsPolicyProvider.GetCorsPolicyAsync(request, cancellationToken);
            }
            return corsPolicy;
        }

        private bool TryEvaluateCorsPolicy(CorsRequestContext requestContext, CorsPolicy corsPolicy, out CorsResult corsResult)
        {
            ICorsEngine engine = _httpConfiguration.GetCorsEngine();
            corsResult = engine.EvaluatePolicy(requestContext, corsPolicy);
            return corsResult != null && corsResult.IsValid;
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/DisableCorsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// This class defines an attribute that can be applied to an action or a controller to disable CORS.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)]
    public sealed class DisableCorsAttribute : Attribute, ICorsPolicyProvider
    {
        /// <inheritdoc />
        public Task<CorsPolicy> GetCorsPolicyAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return Task.FromResult<CorsPolicy>(null);
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/EnableCorsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;
using System.Web.Http.Cors.Properties;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// This class defines an attribute that can be applied to an action or a controller to enable CORS.
    /// By default, it allows all origins, methods and headers.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false)]
    [SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification = "Attribute arguments are accessible as collections.")]
    public sealed class EnableCorsAttribute : Attribute, ICorsPolicyProvider
    {
        private CorsPolicy _corsPolicy;
        private bool _originsValidated;

        /// <summary>
        /// Initializes a new instance of the <see cref="EnableCorsAttribute" /> class.
        /// </summary>
        /// <param name="origins">Comma-separated list of origins that are allowed to access the resource. Use "*" to allow all.</param>
        /// <param name="headers">Comma-separated list of headers that are supported by the resource. Use "*" to allow all. Use null or empty string to allow none.</param>
        /// <param name="methods">
        /// Comma-separated list of methods that are supported by the resource. Use "*" to allow all. Use null or empty string to allow none.
        /// Note:
        /// Http verbs are case-sensitive, if you don't use "*", you should use upper case when specifying GET, PUT, POST, DELETE etc.
        /// For example:
        /// var cors = new EnableCorsAttribute("http://localhost:1234", "*", "GET,PUT,POST,DELETE");
        /// </param>
        public EnableCorsAttribute(string origins, string headers, string methods)
            : this(origins, headers, methods, null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="EnableCorsAttribute" /> class.
        /// </summary>
        /// <param name="origins">Comma-separated list of origins that are allowed to access the resource. Use "*" to allow all.</param>
        /// <param name="headers">Comma-separated list of headers that are supported by the resource. Use "*" to allow all. Use null or empty string to allow none.</param>
        /// <param name="methods">
        /// Comma-separated list of methods that are supported by the resource. Use "*" to allow all. Use null or empty string to allow none.
        /// Note:
        /// Http verbs are case-sensitive, if you don't use "*", you should use upper case when specifying GET, PUT, POST, DELETE etc.
        /// For example:
        /// var cors = new EnableCorsAttribute("http://localhost:1234", "*", "GET,PUT,POST,DELETE");
        /// </param>
        /// <param name="exposedHeaders">Comma-separated list of headers that the resource might use and can be exposed. Use null or empty string to expose none.</param>
        public EnableCorsAttribute(string origins, string headers, string methods, string exposedHeaders)
        {
            if (String.IsNullOrEmpty(origins))
            {
                throw new ArgumentException(
                    SRResources.ArgumentCannotBeNullOrEmpty,
                    "origins");
            }

            _corsPolicy = new CorsPolicy();
            if (origins == "*")
            {
                _corsPolicy.AllowAnyOrigin = true;
            }
            else
            {
                AddCommaSeparatedValuesToCollection(origins, _corsPolicy.Origins);
            }

            if (!String.IsNullOrEmpty(headers))
            {
                if (headers == "*")
                {
                    _corsPolicy.AllowAnyHeader = true;
                }
                else
                {
                    AddCommaSeparatedValuesToCollection(headers, _corsPolicy.Headers);
                }
            }

            if (!String.IsNullOrEmpty(methods))
            {
                if (methods == "*")
                {
                    _corsPolicy.AllowAnyMethod = true;
                }
                else
                {
                    AddCommaSeparatedValuesToCollection(methods, _corsPolicy.Methods);
                }
            }

            if (!String.IsNullOrEmpty(exposedHeaders))
            {
                AddCommaSeparatedValuesToCollection(exposedHeaders, _corsPolicy.ExposedHeaders);
            }
        }

        /// <summary>
        /// Gets the headers that the resource might use and can be exposed.
        /// </summary>
        public IList<string> ExposedHeaders
        {
            get
            {
                return _corsPolicy.ExposedHeaders;
            }
        }

        /// <summary>
        /// Gets the headers that are supported by the resource.
        /// </summary>
        public IList<string> Headers
        {
            get
            {
                return _corsPolicy.Headers;
            }
        }

        /// <summary>
        /// Gets the methods that are supported by the resource.
        /// </summary>
        public IList<string> Methods
        {
            get
            {
                return _corsPolicy.Methods;
            }
        }

        /// <summary>
        /// Gets the origins that are allowed to access the resource.
        /// </summary>
        public IList<string> Origins
        {
            get
            {
                return _corsPolicy.Origins;
            }
        }

        /// <summary>
        /// Gets or sets the number of seconds the results of a preflight request can be cached.
        /// </summary>
        public long PreflightMaxAge
        {
            get
            {
                return _corsPolicy.PreflightMaxAge ?? -1;
            }
            set
            {
                _corsPolicy.PreflightMaxAge = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the resource supports user credentials in the request.
        /// </summary>
        public bool SupportsCredentials
        {
            get
            {
                return _corsPolicy.SupportsCredentials;
            }
            set
            {
                _corsPolicy.SupportsCredentials = value;
            }
        }

        /// <inheritdoc />
        public Task<CorsPolicy> GetCorsPolicyAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            if (!_originsValidated)
            {
                ValidateOrigins(_corsPolicy.Origins);
                _originsValidated = true;
            }

            return Task.FromResult(_corsPolicy);
        }

        private static void ValidateOrigins(IList<string> origins)
        {
            foreach (string origin in origins)
            {
                if (String.IsNullOrEmpty(origin))
                {
                    throw new InvalidOperationException(SRResources.OriginCannotBeNullOrEmpty);
                }

                if (origin.EndsWith("/", StringComparison.Ordinal))
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            SRResources.OriginCannotEndWithSlash,
                            origin));
                }

                if (!Uri.IsWellFormedUriString(origin, UriKind.Absolute))
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            SRResources.OriginNotWellFormed,
                            origin));
                }

                Uri originUri = new Uri(origin);
                if ((!String.IsNullOrEmpty(originUri.AbsolutePath) && !String.Equals(originUri.AbsolutePath, "/", StringComparison.Ordinal)) ||
                    !String.IsNullOrEmpty(originUri.Query) ||
                    !String.IsNullOrEmpty(originUri.Fragment))
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            SRResources.OriginMustNotContainPathQueryOrFragment,
                            origin));
                }
            }
        }

        private static void AddCommaSeparatedValuesToCollection(string commaSeparatedValues, IList<string> collection)
        {
            string[] values = commaSeparatedValues.Split(',');
            for (int i = 0; i < values.Length; i++)
            {
                string value = values[i].Trim();
                if (!String.IsNullOrEmpty(value))
                {
                    collection.Add(value);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Cors/ICorsPolicyProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// Provides an abstraction for getting the <see cref="CorsPolicy"/>.
    /// </summary>
    public interface ICorsPolicyProvider
    {
        /// <summary>
        /// Gets the <see cref="CorsPolicy"/>.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <param name="cancellationToken">The token to monitor for cancellation requests.</param>
        /// <returns>The <see cref="CorsPolicy"/>.</returns>
        Task<CorsPolicy> GetCorsPolicyAsync(HttpRequestMessage request, CancellationToken cancellationToken);
    }
}

================================================
FILE: src/System.Web.Http.Cors/ICorsPolicyProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;

namespace System.Web.Http.Cors
{
    /// <summary>
    /// Provides an abstraction for getting the <see cref="ICorsPolicyProvider"/>.
    /// </summary>
    public interface ICorsPolicyProviderFactory
    {
        /// <summary>
        /// Gets the <see cref="ICorsPolicyProvider"/> for the request.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>The <see cref="ICorsPolicyProvider"/>.</returns>
        ICorsPolicyProvider GetCorsPolicyProvider(HttpRequestMessage request);
    }
}

================================================
FILE: src/System.Web.Http.Cors/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;

[assembly: AssemblyTitle("System.Web.Http.Cors")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.Http.Cors.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "This assembly is delay-signed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http", Justification = "More types exist in this namespace within other assemblies")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http.Cors.Tracing", Justification = "Namespace follows folder structure")]

================================================
FILE: src/System.Web.Http.Cors/Properties/SRResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18213
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.Cors.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class SRResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SRResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.Cors.Properties.SRResources", typeof(SRResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;Access-Control-Request-Method&quot; header value cannot be null or empty..
        /// </summary>
        internal static string AccessControlRequestMethodCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("AccessControlRequestMethodCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value cannot be null or an empty string..
        /// </summary>
        internal static string ArgumentCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("ArgumentCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;Access-Control-Request-Method&quot; header value &apos;{0}&apos; is invalid..
        /// </summary>
        internal static string InvalidAccessControlRequestMethod {
            get {
                return ResourceManager.GetString("InvalidAccessControlRequestMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request does not have an associated configuration object..
        /// </summary>
        internal static string NoConfiguration {
            get {
                return ResourceManager.GetString("NoConfiguration", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified policy origin cannot be null or empty..
        /// </summary>
        internal static string OriginCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("OriginCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified policy origin &apos;{0}&apos; is invalid. It cannot end with a forward slash..
        /// </summary>
        internal static string OriginCannotEndWithSlash {
            get {
                return ResourceManager.GetString("OriginCannotEndWithSlash", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified policy origin &apos;{0}&apos; is invalid. It must not contain a path, query, or fragment..
        /// </summary>
        internal static string OriginMustNotContainPathQueryOrFragment {
            get {
                return ResourceManager.GetString("OriginMustNotContainPathQueryOrFragment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified policy origin &apos;{0}&apos; is invalid. It must be correctly formed with the scheme, the host, and optionally, the port..
        /// </summary>
        internal static string OriginNotWellFormed {
            get {
                return ResourceManager.GetString("OriginNotWellFormed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CorsRequestContext: &apos;{0}&apos;.
        /// </summary>
        internal static string TraceCorsRequestContext {
            get {
                return ResourceManager.GetString("TraceCorsRequestContext", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CorsResult returned: &apos;{0}&apos;.
        /// </summary>
        internal static string TraceEndCorsResultReturned {
            get {
                return ResourceManager.GetString("TraceEndCorsResultReturned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No CorsResult returned..
        /// </summary>
        internal static string TraceEndNoCorsResultReturned {
            get {
                return ResourceManager.GetString("TraceEndNoCorsResultReturned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No CorsPolicyProvider selected.
        /// </summary>
        internal static string TraceEndNoPolicyProviderReturned {
            get {
                return ResourceManager.GetString("TraceEndNoPolicyProviderReturned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No CorsPolicy selected.
        /// </summary>
        internal static string TraceEndNoPolicyReturned {
            get {
                return ResourceManager.GetString("TraceEndNoPolicyReturned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CorsPolicyProvider selected: &apos;{0}&apos;.
        /// </summary>
        internal static string TraceEndPolicyProviderReturned {
            get {
                return ResourceManager.GetString("TraceEndPolicyProviderReturned", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CorsPolicy selected: &apos;{0}&apos;.
        /// </summary>
        internal static string TraceEndPolicyReturned {
            get {
                return ResourceManager.GetString("TraceEndPolicyReturned", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Cors/Properties/SRResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="AccessControlRequestMethodCannotBeNullOrEmpty" xml:space="preserve">
    <value>The "Access-Control-Request-Method" header value cannot be null or empty.</value>
  </data>
  <data name="ArgumentCannotBeNullOrEmpty" xml:space="preserve">
    <value>Value cannot be null or an empty string.</value>
  </data>
  <data name="InvalidAccessControlRequestMethod" xml:space="preserve">
    <value>The "Access-Control-Request-Method" header value '{0}' is invalid.</value>
  </data>
  <data name="NoConfiguration" xml:space="preserve">
    <value>The request does not have an associated configuration object.</value>
  </data>
  <data name="OriginCannotBeNullOrEmpty" xml:space="preserve">
    <value>The specified policy origin cannot be null or empty.</value>
  </data>
  <data name="OriginCannotEndWithSlash" xml:space="preserve">
    <value>The specified policy origin '{0}' is invalid. It cannot end with a forward slash.</value>
  </data>
  <data name="OriginMustNotContainPathQueryOrFragment" xml:space="preserve">
    <value>The specified policy origin '{0}' is invalid. It must not contain a path, query, or fragment.</value>
  </data>
  <data name="OriginNotWellFormed" xml:space="preserve">
    <value>The specified policy origin '{0}' is invalid. It must be correctly formed with the scheme, the host, and optionally, the port.</value>
  </data>
  <data name="TraceCorsRequestContext" xml:space="preserve">
    <value>CorsRequestContext: '{0}'</value>
  </data>
  <data name="TraceEndCorsResultReturned" xml:space="preserve">
    <value>CorsResult returned: '{0}'</value>
  </data>
  <data name="TraceEndNoCorsResultReturned" xml:space="preserve">
    <value>No CorsResult returned.</value>
  </data>
  <data name="TraceEndNoPolicyProviderReturned" xml:space="preserve">
    <value>No CorsPolicyProvider selected</value>
  </data>
  <data name="TraceEndNoPolicyReturned" xml:space="preserve">
    <value>No CorsPolicy selected</value>
  </data>
  <data name="TraceEndPolicyProviderReturned" xml:space="preserve">
    <value>CorsPolicyProvider selected: '{0}'</value>
  </data>
  <data name="TraceEndPolicyReturned" xml:space="preserve">
    <value>CorsPolicy selected: '{0}'</value>
  </data>
</root>

================================================
FILE: src/System.Web.Http.Cors/System.Web.Http.Cors.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{25DEF6F6-7F99-4EB7-91ED-5181A346AFE1}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.Cors</RootNamespace>
    <AssemblyName>System.Web.Http.Cors</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
  </PropertyGroup>
  <PropertyGroup>
    <SignAssembly>true</SignAssembly>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="AttributeBasedPolicyProviderFactory.cs" />
    <Compile Include="Tracing\CorsEngineTracer.cs" />
    <Compile Include="Tracing\TraceCategories.cs" />
    <Compile Include="Tracing\CorsPolicyProviderFactoryTracer.cs" />
    <Compile Include="Tracing\CorsPolicyProviderTracer.cs" />
    <Compile Include="DisableCorsAttribute.cs" />
    <Compile Include="EnableCorsAttribute.cs" />
    <Compile Include="ICorsPolicyProvider.cs" />
    <Compile Include="ICorsPolicyProviderFactory.cs" />
    <Compile Include="CorsHttpConfigurationExtensions.cs" />
    <Compile Include="CorsHttpRequestMessageExtensions.cs" />
    <Compile Include="CorsHttpResponseMessageExtensions.cs" />
    <Compile Include="CorsMessageHandler.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\SRResources.Designer.cs">
      <DependentUpon>SRResources.resx</DependentUpon>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Cors\System.Web.Cors.csproj">
      <Project>{43c1b979-d593-4a32-bb3a-4316f1c66d66}</Project>
      <Name>System.Web.Cors</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\SRResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>SRResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Http.Cors/Tracing/CorsEngineTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http;
using System.Web.Cors;
using System.Web.Http.Cors.Properties;
using System.Web.Http.Tracing;

namespace System.Web.Http.Cors.Tracing
{
    internal class CorsEngineTracer : ICorsEngine
    {
        private ICorsEngine _innerCorsEngine;
        private ITraceWriter _traceWriter;
        private const string MethodName = "EvaluatePolicy";

        public CorsEngineTracer(ICorsEngine corsEngine, ITraceWriter traceWriter)
        {
            Contract.Assert(corsEngine != null);
            Contract.Assert(traceWriter != null);

            _innerCorsEngine = corsEngine;
            _traceWriter = traceWriter;
        }

        public CorsResult EvaluatePolicy(CorsRequestContext requestContext, CorsPolicy policy)
        {
            CorsResult corsResult = null;
            object request;
            requestContext.Properties.TryGetValue(typeof(HttpRequestMessage).FullName, out request);

            _traceWriter.TraceBeginEnd(
                request as HttpRequestMessage,
                TraceCategories.CorsCategory,
                TraceLevel.Info,
                _innerCorsEngine.GetType().Name,
                MethodName,
                beginTrace: null,
                execute: () => { corsResult = _innerCorsEngine.EvaluatePolicy(requestContext, policy); },
                endTrace: (tr) =>
                {
                    if (corsResult != null)
                    {
                        tr.Message = String.Format(CultureInfo.CurrentCulture, SRResources.TraceEndCorsResultReturned, corsResult);
                    }
                    else
                    {
                        tr.Message = SRResources.TraceEndNoCorsResultReturned;
                    }
                },
                errorTrace: null);

            return corsResult;
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/Tracing/CorsPolicyProviderFactoryTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http;
using System.Web.Http.Cors.Properties;
using System.Web.Http.Tracing;

namespace System.Web.Http.Cors.Tracing
{
    internal class CorsPolicyProviderFactoryTracer : ICorsPolicyProviderFactory
    {
        private ICorsPolicyProviderFactory _innerPolicyProviderFactory;
        private ITraceWriter _traceWriter;
        private const string MethodName = "GetCorsPolicyProvider";

        public CorsPolicyProviderFactoryTracer(ICorsPolicyProviderFactory innerPolicyProviderFactory, ITraceWriter traceWriter)
        {
            Contract.Assert(innerPolicyProviderFactory != null);
            Contract.Assert(traceWriter != null);

            _innerPolicyProviderFactory = innerPolicyProviderFactory;
            _traceWriter = traceWriter;
        }

        public ICorsPolicyProvider GetCorsPolicyProvider(HttpRequestMessage request)
        {
            ICorsPolicyProvider policyProvider = null;

            _traceWriter.TraceBeginEnd(
                request,
                TraceCategories.CorsCategory,
                TraceLevel.Info,
                _innerPolicyProviderFactory.GetType().Name,
                MethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = String.Format(CultureInfo.CurrentCulture, SRResources.TraceCorsRequestContext, request.GetCorsRequestContext());
                },
                execute: () => { policyProvider = _innerPolicyProviderFactory.GetCorsPolicyProvider(request); },
                endTrace: (tr) =>
                {
                    if (policyProvider != null)
                    {
                        tr.Message = String.Format(CultureInfo.CurrentCulture, SRResources.TraceEndPolicyProviderReturned, policyProvider);
                    }
                    else
                    {
                        tr.Message = SRResources.TraceEndNoPolicyProviderReturned;
                    }
                },
                errorTrace: null);

            if (policyProvider != null)
            {
                return new CorsPolicyProviderTracer(policyProvider, _traceWriter);
            }

            return null;
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/Tracing/CorsPolicyProviderTracer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;
using System.Web.Http.Cors.Properties;
using System.Web.Http.Tracing;

namespace System.Web.Http.Cors.Tracing
{
    internal class CorsPolicyProviderTracer : ICorsPolicyProvider
    {
        private ICorsPolicyProvider _innerPolicyProvider;
        private ITraceWriter _traceWriter;
        private const string MethodName = "GetCorsPolicyAsync";

        public CorsPolicyProviderTracer(ICorsPolicyProvider innerPolicyProvider, ITraceWriter traceWriter)
        {
            Contract.Assert(innerPolicyProvider != null);
            Contract.Assert(traceWriter != null);

            _innerPolicyProvider = innerPolicyProvider;
            _traceWriter = traceWriter;
        }

        public Task<CorsPolicy> GetCorsPolicyAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return _traceWriter.TraceBeginEndAsync<CorsPolicy>(
                request,
                TraceCategories.CorsCategory,
                TraceLevel.Info,
                _innerPolicyProvider.GetType().Name,
                MethodName,
                beginTrace: (tr) =>
                {
                    tr.Message = String.Format(CultureInfo.CurrentCulture, SRResources.TraceCorsRequestContext, request.GetCorsRequestContext());
                },
                execute: () => _innerPolicyProvider.GetCorsPolicyAsync(request, cancellationToken),
                endTrace: (tr, policy) =>
                {
                    if (policy != null)
                    {
                        tr.Message = String.Format(CultureInfo.CurrentCulture, SRResources.TraceEndPolicyReturned, policy);
                    }
                    else
                    {
                        tr.Message = SRResources.TraceEndNoPolicyReturned;
                    }
                },
                errorTrace: null);
        }
    }
}

================================================
FILE: src/System.Web.Http.Cors/Tracing/TraceCategories.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Cors.Tracing
{
    /// <summary>
    /// Category names traced by the default CORS tracing implementation.
    /// </summary>
    public static class TraceCategories
    {
        /// <summary>
        /// The trace category for CORS-related events.
        /// </summary>
        public static readonly string CorsCategory = "System.Web.Http.Cors";
    }
}

================================================
FILE: src/System.Web.Http.Owin/ExceptionHandling/DefaultExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Owin.Properties;
using System.Web.Http.Results;

namespace System.Web.Http.Owin.ExceptionHandling
{
    internal class DefaultExceptionHandler : IExceptionHandler
    {
        public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            Handle(context);
            return TaskHelpers.Completed();
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "We already shipped this code; avoiding even minor breaking changes in error handling.")]
        private static void Handle(ExceptionHandlerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);

            HttpRequestMessage request = exceptionContext.Request;

            if (request == null)
            {
                throw new ArgumentException(Error.Format(OwinResources.TypePropertyMustNotBeNull,
                    typeof(ExceptionContext).Name, "Request"), "context");
            }

            context.Result = new ResponseMessageResult(request.CreateErrorResponse(HttpStatusCode.InternalServerError,
                exceptionContext.Exception));
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/ExceptionHandling/EmptyExceptionLogger.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;

namespace System.Web.Http.Owin.ExceptionHandling
{
    internal class EmptyExceptionLogger : IExceptionLogger
    {
        public Task LogAsync(ExceptionLoggerContext context, CancellationToken cancellationToken)
        {
            return TaskHelpers.Completed();
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "The assembly is delay signed")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "Owin", Justification = "More types exist in this namespace within other assemblies")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Net.Http", Justification = "More types exist in this namespace within other assemblies")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http", Justification = "More types exist in this namespace within other assemblies.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http.Owin")]


================================================
FILE: src/System.Web.Http.Owin/HostAuthenticationAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;

namespace System.Web.Http
{
    /// <summary>Represents an authentication attribute that authenticates via OWIN middleware.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
    public sealed class HostAuthenticationAttribute : Attribute, IAuthenticationFilter
    {
        private readonly IAuthenticationFilter _innerFilter;
        private readonly string _authenticationType;

        /// <summary>Initializes a new instance of the <see cref="HostAuthenticationAttribute"/> class.</summary>
        /// <param name="authenticationType">The authentication type of the OWIN middleware to use.</param>
        public HostAuthenticationAttribute(string authenticationType)
            : this(new HostAuthenticationFilter(authenticationType))
        {
            _authenticationType = authenticationType;
        }

        internal HostAuthenticationAttribute(IAuthenticationFilter innerFilter)
        {
            if (innerFilter == null)
            {
                throw new ArgumentNullException("innerFilter");
            }

            _innerFilter = innerFilter;
        }

        /// <inheritdoc />
        public bool AllowMultiple
        {
            get { return true; }
        }

        /// <summary>Gets the authentication type of the OWIN middleware to use.</summary>
        public string AuthenticationType
        {
            get { return _authenticationType; }
        }

        internal IAuthenticationFilter InnerFilter
        {
            get
            {
                return _innerFilter;
            }
        }

        /// <inheritdoc />
        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            return _innerFilter.AuthenticateAsync(context, cancellationToken);
        }

        /// <inheritdoc />
        public Task ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken)
        {
            return _innerFilter.ChallengeAsync(context, cancellationToken);
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/HostAuthenticationFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Security.Claims;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Owin.Properties;
using Microsoft.Owin;
using Microsoft.Owin.Security;

namespace System.Web.Http
{
    /// <summary>Represents an authentication filter that authenticates via OWIN middleware.</summary>
    public class HostAuthenticationFilter : IAuthenticationFilter
    {
        private readonly string _authenticationType;

        /// <summary>Initializes a new instance of the <see cref="HostAuthenticationFilter"/> class.</summary>
        /// <param name="authenticationType">The authentication type of the OWIN middleware to use.</param>
        public HostAuthenticationFilter(string authenticationType)
        {
            if (authenticationType == null)
            {
                throw new ArgumentNullException("authenticationType");
            }

            _authenticationType = authenticationType;
        }

        /// <summary>Gets the authentication type of the OWIN middleware to use.</summary>
        public string AuthenticationType
        {
            get { return _authenticationType; }
        }

        /// <inheritdoc />
        public async Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpRequestMessage request = context.Request;

            if (request == null)
            {
                throw new InvalidOperationException(OwinResources.HttpAuthenticationContext_RequestMustNotBeNull);
            }

            IAuthenticationManager authenticationManager = GetAuthenticationManagerOrThrow(request);

            cancellationToken.ThrowIfCancellationRequested();
            AuthenticateResult result = await authenticationManager.AuthenticateAsync(_authenticationType);

            if (result != null)
            {
                IIdentity identity = result.Identity;

                if (identity != null)
                {
                    context.Principal = new ClaimsPrincipal(identity);
                }
            }
        }

        /// <inheritdoc />
        public Task ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpRequestMessage request = context.Request;

            if (request == null)
            {
                throw new InvalidOperationException(OwinResources.HttpAuthenticationChallengeContext_RequestMustNotBeNull);
            }

            IAuthenticationManager authenticationManager = GetAuthenticationManagerOrThrow(request);

            // Control the challenges that OWIN middleware adds later.
            authenticationManager.AuthenticationResponseChallenge = AddChallengeAuthenticationType(
                authenticationManager.AuthenticationResponseChallenge, _authenticationType);

            return TaskHelpers.Completed();
        }

        /// <inheritdoc />
        public bool AllowMultiple
        {
            get { return true; }
        }

        private static AuthenticationResponseChallenge AddChallengeAuthenticationType(
            AuthenticationResponseChallenge challenge, string authenticationType)
        {
            Contract.Assert(authenticationType != null);

            List<string> authenticationTypes = new List<string>();
            AuthenticationProperties properties;

            if (challenge != null)
            {
                string[] currentAuthenticationTypes = challenge.AuthenticationTypes;

                if (currentAuthenticationTypes != null)
                {
                    authenticationTypes.AddRange(currentAuthenticationTypes);
                }

                properties = challenge.Properties;
            }
            else
            {
                properties = new AuthenticationProperties();
            }

            authenticationTypes.Add(authenticationType);

            return new AuthenticationResponseChallenge(authenticationTypes.ToArray(), properties);
        }

        private static IAuthenticationManager GetAuthenticationManagerOrThrow(HttpRequestMessage request)
        {
            Contract.Assert(request != null);

            IAuthenticationManager authenticationManager = request.GetAuthenticationManager();

            if (authenticationManager == null)
            {
                throw new InvalidOperationException(OwinResources.IAuthenticationManagerNotAvailable);
            }

            return authenticationManager;
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/HttpMessageHandlerAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Runtime.ExceptionServices;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.Owin.ExceptionHandling;
using System.Web.Http.Owin.Properties;
using Microsoft.Owin;

namespace System.Web.Http.Owin
{
    /// <summary>
    /// Represents an OWIN component that submits requests to an <see cref="HttpMessageHandler"/> when invoked.
    /// </summary>
    public class HttpMessageHandlerAdapter : OwinMiddleware, IDisposable
    {
        private readonly HttpMessageHandler _messageHandler;
        private readonly HttpMessageInvoker _messageInvoker;
        private readonly IHostBufferPolicySelector _bufferPolicySelector;
        private readonly IExceptionLogger _exceptionLogger;
        private readonly IExceptionHandler _exceptionHandler;
        private readonly CancellationToken _appDisposing;

        private bool _disposed;

        /// <summary>Initializes a new instance of the <see cref="HttpMessageHandlerAdapter"/> class.</summary>
        /// <param name="next">The next component in the pipeline.</param>
        /// <param name="options">The options to configure this adapter.</param>
        public HttpMessageHandlerAdapter(OwinMiddleware next, HttpMessageHandlerOptions options)
            : base(next)
        {
            if (options == null)
            {
                throw new ArgumentNullException("options");
            }

            _messageHandler = options.MessageHandler;

            if (_messageHandler == null)
            {
                throw new ArgumentException(Error.Format(OwinResources.TypePropertyMustNotBeNull,
                    typeof(HttpMessageHandlerOptions).Name, "MessageHandler"), "options");
            }

            _messageInvoker = new HttpMessageInvoker(_messageHandler);
            _bufferPolicySelector = options.BufferPolicySelector;

            if (_bufferPolicySelector == null)
            {
                throw new ArgumentException(Error.Format(OwinResources.TypePropertyMustNotBeNull,
                    typeof(HttpMessageHandlerOptions).Name, "BufferPolicySelector"), "options");
            }

            _exceptionLogger = options.ExceptionLogger;

            if (_exceptionLogger == null)
            {
                throw new ArgumentException(Error.Format(OwinResources.TypePropertyMustNotBeNull,
                    typeof(HttpMessageHandlerOptions).Name, "ExceptionLogger"), "options");
            }

            _exceptionHandler = options.ExceptionHandler;

            if (_exceptionHandler == null)
            {
                throw new ArgumentException(Error.Format(OwinResources.TypePropertyMustNotBeNull,
                    typeof(HttpMessageHandlerOptions).Name, "ExceptionHandler"), "options");
            }

            _appDisposing = options.AppDisposing;

            if (_appDisposing.CanBeCanceled)
            {
                _appDisposing.Register(OnAppDisposing);
            }
        }

        /// <summary>Initializes a new instance of the <see cref="HttpMessageHandlerAdapter"/> class.</summary>
        /// <param name="next">The next component in the pipeline.</param>
        /// <param name="messageHandler">The <see cref="HttpMessageHandler"/> to submit requests to.</param>
        /// <param name="bufferPolicySelector">
        /// The <see cref="IHostBufferPolicySelector"/> that determines whether or not to buffer requests and
        /// responses.
        /// </param>
        /// <remarks>
        /// This constructor is retained for backwards compatibility. The constructor taking
        /// <see cref="HttpMessageHandlerOptions"/> should be used instead.
        /// </remarks>
        [Obsolete("Use the HttpMessageHandlerAdapter(OwinMiddleware, HttpMessageHandlerOptions) constructor instead.")]
        public HttpMessageHandlerAdapter(OwinMiddleware next, HttpMessageHandler messageHandler,
            IHostBufferPolicySelector bufferPolicySelector)
            : this(next, CreateOptions(messageHandler, bufferPolicySelector))
        {
        }

        /// <summary>Gets the <see cref="HttpMessageHandler"/> to submit requests to.</summary>
        public HttpMessageHandler MessageHandler
        {
            get { return _messageHandler; }
        }

        /// <summary>
        /// Gets the <see cref="IHostBufferPolicySelector"/> that determines whether or not to buffer requests and
        /// responses.
        /// </summary>
        public IHostBufferPolicySelector BufferPolicySelector
        {
            get { return _bufferPolicySelector; }
        }

        /// <summary>Gets the <see cref="IExceptionLogger"/> to use to log unhandled exceptions.</summary>
        public IExceptionLogger ExceptionLogger
        {
            get { return _exceptionLogger; }
        }

        /// <summary>Gets the <see cref="IExceptionHandler"/> to use to process unhandled exceptions.</summary>
        public IExceptionHandler ExceptionHandler
        {
            get { return _exceptionHandler; }
        }

        /// <summary>Gets the <see cref="CancellationToken"/> that triggers cleanup of this component.</summary>
        public CancellationToken AppDisposing
        {
            get { return _appDisposing; }
        }

        /// <inheritdoc />
        public override Task Invoke(IOwinContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            IOwinRequest owinRequest = context.Request;
            IOwinResponse owinResponse = context.Response;

            if (owinRequest == null)
            {
                throw Error.InvalidOperation(OwinResources.OwinContext_NullRequest);
            }
            if (owinResponse == null)
            {
                throw Error.InvalidOperation(OwinResources.OwinContext_NullResponse);
            }

            return InvokeCore(context, owinRequest, owinResponse);
        }

        private async Task InvokeCore(IOwinContext context, IOwinRequest owinRequest, IOwinResponse owinResponse)
        {
            CancellationToken cancellationToken = owinRequest.CallCancelled;
            HttpContent requestContent;

            bool bufferInput = _bufferPolicySelector.UseBufferedInputStream(hostContext: context);

            if (!bufferInput)
            {
                owinRequest.DisableBuffering();
            }

            if (!owinRequest.Body.CanSeek && bufferInput)
            {
                requestContent = await CreateBufferedRequestContentAsync(owinRequest, cancellationToken);
            }
            else
            {
                requestContent = CreateStreamedRequestContent(owinRequest);
            }

            HttpRequestMessage request = CreateRequestMessage(owinRequest, requestContent);
            MapRequestProperties(request, context);

            SetPrincipal(owinRequest.User);

            HttpResponseMessage response = null;
            bool callNext;

            try
            {
                response = await _messageInvoker.SendAsync(request, cancellationToken);

                // Handle null responses
                if (response == null)
                {
                    throw Error.InvalidOperation(OwinResources.SendAsync_ReturnedNull);
                }

                // Handle soft 404s where no route matched - call the next component
                if (IsSoftNotFound(request, response))
                {
                    callNext = true;
                }
                else
                {
                    callNext = false;

                    // Compute Content-Length before calling UseBufferedOutputStream because the default implementation
                    // accesses that header and we want to catch any exceptions calling TryComputeLength here.

                    if (response.Content == null
                        || await ComputeContentLengthAsync(request, response, owinResponse, cancellationToken))
                    {
                        bool bufferOutput = _bufferPolicySelector.UseBufferedOutputStream(response);

                        if (!bufferOutput)
                        {
                            owinResponse.DisableBuffering();
                        }
                        else if (response.Content != null)
                        {
                            response = await BufferResponseContentAsync(request, response, cancellationToken);
                        }

                        if (await PrepareHeadersAsync(request, response, owinResponse, cancellationToken))
                        {
                            await SendResponseMessageAsync(request, response, owinResponse, cancellationToken);
                        }
                    }
                }
            }
            finally
            {
                request.DisposeRequestResources();
                request.Dispose();
                if (response != null)
                {
                    response.Dispose();
                }
            }

            // Call the next component if no route matched
            if (callNext && Next != null)
            {
                await Next.Invoke(context);
            }
        }

        private static HttpContent CreateStreamedRequestContent(IOwinRequest owinRequest)
        {
            // Note that we must NOT dispose owinRequest.Body in this case. Disposing it would close the input
            // stream and prevent cascaded components from accessing it. The server MUST handle any necessary
            // cleanup upon request completion. NonOwnedStream prevents StreamContent (or its callers including
            // HttpRequestMessage) from calling Close or Dispose on owinRequest.Body.
            return new StreamContent(new NonOwnedStream(owinRequest.Body));
        }

        private static async Task<HttpContent> CreateBufferedRequestContentAsync(IOwinRequest owinRequest,
            CancellationToken cancellationToken)
        {
            // We need to replace the request body with a buffered stream so that other components can read the stream.
            // For this stream to be useful, it must NOT be diposed along with the request. Streams created by
            // StreamContent do get disposed along with the request, so use MemoryStream to buffer separately.
            MemoryStream buffer;
            int? contentLength = owinRequest.GetContentLength();

            if (!contentLength.HasValue)
            {
                buffer = new MemoryStream();
            }
            else
            {
                buffer = new MemoryStream(Math.Min(4 * 1024, contentLength.Value));
            }

            cancellationToken.ThrowIfCancellationRequested();

            using (StreamContent copier = new StreamContent(owinRequest.Body))
            {
                await copier.CopyToAsync(buffer);
            }

            // Provide the non-disposing, buffered stream to later OWIN components (set to the stream's beginning).
            buffer.Position = 0;
            owinRequest.Body = buffer;

            // For MemoryStream, Length is guaranteed to be an int.
            return new ByteArrayContent(buffer.GetBuffer(), 0, (int)buffer.Length);
        }

        private static HttpRequestMessage CreateRequestMessage(IOwinRequest owinRequest, HttpContent requestContent)
        {
            // Create the request
            HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(owinRequest.Method), owinRequest.Uri);

            try
            {
                // Set the body
                request.Content = requestContent;

                // Copy the headers
                foreach (KeyValuePair<string, string[]> header in owinRequest.Headers)
                {
                    if (!request.Headers.TryAddWithoutValidation(header.Key, header.Value))
                    {
                        bool success = requestContent.Headers.TryAddWithoutValidation(header.Key, header.Value);
                        Contract.Assert(success,
                            "Every header can be added either to the request headers or to the content headers");
                    }
                }
            }
            catch
            {
                request.Dispose();
                throw;
            }

            return request;
        }

        private static void MapRequestProperties(HttpRequestMessage request, IOwinContext context)
        {
            // Set the OWIN context on the request
            request.SetOwinContext(context);

            // Set a request context on the request that lazily populates each property.
            HttpRequestContext requestContext = new OwinHttpRequestContext(context, request);
            request.SetRequestContext(requestContext);
        }

        private static void SetPrincipal(IPrincipal user)
        {
            if (user != null)
            {
                Thread.CurrentPrincipal = user;
            }
        }

        private static bool IsSoftNotFound(HttpRequestMessage request, HttpResponseMessage response)
        {
            if (response.StatusCode == HttpStatusCode.NotFound)
            {
                bool routingFailure;
                if (request.Properties.TryGetValue<bool>(HttpPropertyKeys.NoRouteMatched, out routingFailure)
                    && routingFailure)
                {
                    return true;
                }
            }
            return false;
        }

        private async Task<HttpResponseMessage> BufferResponseContentAsync(HttpRequestMessage request,
            HttpResponseMessage response, CancellationToken cancellationToken)
        {
            ExceptionDispatchInfo exceptionInfo;

            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                await response.Content.LoadIntoBufferAsync();
                return response;
            }
            catch (OperationCanceledException)
            {
                // Propogate the canceled task without calling exception loggers or handlers.
                throw;
            }
            catch (Exception exception)
            {
                exceptionInfo = ExceptionDispatchInfo.Capture(exception);
            }

            // If the content can't be buffered, create a buffered error response for the exception
            // This code will commonly run when a formatter throws during the process of serialization

            Debug.Assert(exceptionInfo.SourceException != null);

            ExceptionContext exceptionContext = new ExceptionContext(exceptionInfo.SourceException,
                OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferContent, request, response);

            await _exceptionLogger.LogAsync(exceptionContext, cancellationToken);
            HttpResponseMessage errorResponse = await _exceptionHandler.HandleAsync(exceptionContext,
                cancellationToken);

            response.Dispose();

            if (errorResponse == null)
            {
                exceptionInfo.Throw();
                return null;
            }

            // We have an error response to try to buffer and send back.

            response = errorResponse;
            cancellationToken.ThrowIfCancellationRequested();

            Exception errorException;

            try
            {
                // Try to buffer the error response and send it back.
                await response.Content.LoadIntoBufferAsync();
                return response;
            }
            catch (OperationCanceledException)
            {
                // Propogate the canceled task without calling exception loggers.
                throw;
            }
            catch (Exception exception)
            {
                errorException = exception;
            }

            // We tried to send back an error response with content, but we couldn't. It's an edge case; the best we
            // can do is to log that exception and send back an empty 500.

            ExceptionContext errorExceptionContext = new ExceptionContext(errorException,
                OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferError, request, response);
            await _exceptionLogger.LogAsync(errorExceptionContext, cancellationToken);

            response.Dispose();
            return request.CreateResponse(HttpStatusCode.InternalServerError);
        }

        // Prepares Content-Length and Transfer-Encoding headers.
        private Task<bool> PrepareHeadersAsync(HttpRequestMessage request, HttpResponseMessage response,
            IOwinResponse owinResponse, CancellationToken cancellationToken)
        {
            Contract.Assert(response != null);
            HttpResponseHeaders responseHeaders = response.Headers;
            Contract.Assert(responseHeaders != null);
            HttpContent content = response.Content;
            bool isTransferEncodingChunked = responseHeaders.TransferEncodingChunked == true;
            HttpHeaderValueCollection<TransferCodingHeaderValue> transferEncoding = responseHeaders.TransferEncoding;

            if (content != null)
            {
                HttpContentHeaders contentHeaders = content.Headers;
                Contract.Assert(contentHeaders != null);

                if (isTransferEncodingChunked)
                {
                    // According to section 4.4 of the HTTP 1.1 spec, HTTP responses that use chunked transfer
                    // encoding must not have a content length set. Chunked should take precedence over content
                    // length in this case because chunked is always set explicitly by users while the Content-Length
                    // header can be added implicitly by System.Net.Http.
                    contentHeaders.ContentLength = null;
                }
                else
                {
                    // Copy the response content headers only after ensuring they are complete.
                    // We ask for Content-Length first because HttpContent lazily computes this header and only
                    // afterwards writes the value into the content headers.
                    return ComputeContentLengthAsync(request, response, owinResponse, cancellationToken);
                }
            }

            // Ignore the Transfer-Encoding header if it is just "chunked"; the host will likely provide it when no
            // Content-Length is present (and if the host does not, there's not much better this code could do to
            // transmit the current response, since HttpContent is assumed to be unframed; in that case, silently drop
            // the Transfer-Encoding: chunked header).
            // HttpClient sets this header when it receives chunked content, but HttpContent does not include the
            // frames. The OWIN contract is to set this header only when writing chunked frames to the stream.
            // A Web API caller who desires custom framing would need to do a different Transfer-Encoding (such as
            // "identity, chunked").
            if (isTransferEncodingChunked && transferEncoding.Count == 1)
            {
                transferEncoding.Clear();
            }

            return Task.FromResult(true);
        }

        [SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "unused",
            Justification = "unused variable necessary to call getter")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "Exception is turned into an error response.")]
        private Task<bool> ComputeContentLengthAsync(HttpRequestMessage request, HttpResponseMessage response,
            IOwinResponse owinResponse, CancellationToken cancellationToken)
        {
            Contract.Assert(response != null);
            HttpResponseHeaders responseHeaders = response.Headers;
            Contract.Assert(responseHeaders != null);
            HttpContent content = response.Content;
            Contract.Assert(content != null);
            HttpContentHeaders contentHeaders = content.Headers;
            Contract.Assert(contentHeaders != null);

            Exception exception;

            try
            {
                var unused = contentHeaders.ContentLength;

                return Task.FromResult(true);
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            return HandleTryComputeLengthExceptionAsync(exception, request, response, owinResponse, cancellationToken);
        }

        private async Task<bool> HandleTryComputeLengthExceptionAsync(Exception exception, HttpRequestMessage request,
            HttpResponseMessage response, IOwinResponse owinResponse, CancellationToken cancellationToken)
        {
            Contract.Assert(owinResponse != null);

            ExceptionContext exceptionContext = new ExceptionContext(exception,
                OwinExceptionCatchBlocks.HttpMessageHandlerAdapterComputeContentLength, request, response);
            await _exceptionLogger.LogAsync(exceptionContext, cancellationToken);

            // Send back an empty error response if TryComputeLength throws.
            owinResponse.StatusCode = (int)HttpStatusCode.InternalServerError;
            SetHeadersForEmptyResponse(owinResponse.Headers);
            return false;
        }

        private Task SendResponseMessageAsync(HttpRequestMessage request, HttpResponseMessage response,
            IOwinResponse owinResponse, CancellationToken cancellationToken)
        {
            owinResponse.StatusCode = (int)response.StatusCode;
            owinResponse.ReasonPhrase = response.ReasonPhrase;

            // Copy non-content headers
            IDictionary<string, string[]> responseHeaders = owinResponse.Headers;
            foreach (KeyValuePair<string, IEnumerable<string>> header in response.Headers)
            {
                responseHeaders[header.Key] = header.Value.AsArray();
            }

            HttpContent responseContent = response.Content;
            if (responseContent == null)
            {
                SetHeadersForEmptyResponse(responseHeaders);
                return TaskHelpers.Completed();
            }
            else
            {
                // Copy content headers
                foreach (KeyValuePair<string, IEnumerable<string>> contentHeader in responseContent.Headers)
                {
                    responseHeaders[contentHeader.Key] = contentHeader.Value.AsArray();
                }

                // Copy body
                return SendResponseContentAsync(request, response, owinResponse, cancellationToken);
            }
        }

        private static void SetHeadersForEmptyResponse(IDictionary<string, string[]> headers)
        {
            // Set the content-length to 0 to prevent the server from sending back the response chunked
            headers["Content-Length"] = new string[] { "0" };
        }

        private async Task SendResponseContentAsync(HttpRequestMessage request, HttpResponseMessage response,
            IOwinResponse owinResponse, CancellationToken cancellationToken)
        {
            Contract.Assert(response != null);
            Contract.Assert(response.Content != null);

            Exception exception;
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                await response.Content.CopyToAsync(owinResponse.Body);
                return;
            }
            catch (OperationCanceledException)
            {
                // Propogate the canceled task without calling exception loggers;
                throw;
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            // We're streaming content, so we can only call loggers, not handlers, as we've already (possibly) send the
            // status code and headers across the wire. Log the exception, but then just abort.
            ExceptionContext exceptionContext = new ExceptionContext(exception,
                OwinExceptionCatchBlocks.HttpMessageHandlerAdapterStreamContent, request, response);
            await _exceptionLogger.LogAsync(exceptionContext, cancellationToken);
            await AbortResponseAsync();
        }

        private static Task AbortResponseAsync()
        {
            // OWIN doesn't yet support an explicit Abort event. Returning a canceled task is the best contract at the
            // moment.
            return TaskHelpers.Canceled();
        }

        // Provides HttpMessageHandlerOptions for callers using the old constructor.
        private static HttpMessageHandlerOptions CreateOptions(HttpMessageHandler messageHandler,
            IHostBufferPolicySelector bufferPolicySelector)
        {
            if (messageHandler == null)
            {
                throw new ArgumentNullException("messageHandler");
            }

            if (bufferPolicySelector == null)
            {
                throw new ArgumentNullException("bufferPolicySelector");
            }

            // Callers using the old constructor get the default exception handler, no exception logging support, and no
            // app cleanup support.

            return new HttpMessageHandlerOptions
            {
                MessageHandler = messageHandler,
                BufferPolicySelector = bufferPolicySelector,
                ExceptionLogger = new EmptyExceptionLogger(),
                ExceptionHandler = new DefaultExceptionHandler(),
                AppDisposing = CancellationToken.None
            };
        }

        /// <summary>
        /// Releases unmanaged and optionally managed resources.
        /// </summary>
        /// <param name="disposing">
        /// <see langword="true"/> to release both managed and unmanaged resources; <see langword="false"/> to release
        /// only unmanaged resources.
        /// </param>
        /// <remarks>
        /// This class implements <see cref="IDisposable"/> for legacy reasons. New callers should instead provide a
        /// cancellation token via <see cref="AppDisposing"/> using the constructor that takes
        /// <see cref="HttpMessageHandlerOptions"/>.
        /// </remarks>
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                OnAppDisposing();
            }
        }

        /// <inheritdoc />
        /// <remarks>
        /// This class implements <see cref="IDisposable"/> for legacy reasons. New callers should instead provide a
        /// cancellation token via <see cref="AppDisposing"/> using the constructor that takes
        /// <see cref="HttpMessageHandlerOptions"/>.
        /// </remarks>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void OnAppDisposing()
        {
            if (!_disposed)
            {
                _messageInvoker.Dispose();
                _disposed = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/HttpMessageHandlerOptions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;

namespace System.Web.Http.Owin
{
    /// <summary>Represents the options for configuring an <see cref="HttpMessageHandlerAdapter"/>.</summary>
    public class HttpMessageHandlerOptions
    {
        /// <summary>
        /// Gets or sets the <see cref="HttpMessageHandler"/> to submit requests to.
        /// </summary>
        public HttpMessageHandler MessageHandler { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="IHostBufferPolicySelector"/> that determines whether or not to buffer requests
        /// and responses.
        /// </summary>
        public IHostBufferPolicySelector BufferPolicySelector { get; set; }

        /// <summary>Gets or sets the <see cref="IExceptionLogger"/> to use to log unhandled exceptions.</summary>
        public IExceptionLogger ExceptionLogger { get; set; }

        /// <summary>Gets or sets the <see cref="IExceptionHandler"/> to use to process unhandled exceptions.</summary>
        public IExceptionHandler ExceptionHandler { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="CancellationToken"/> that triggers cleanup of the
        /// <see cref="HttpMessageHandlerAdapter"/>.
        /// </summary>
        public CancellationToken AppDisposing { get; set; }
    }
}


================================================
FILE: src/System.Web.Http.Owin/OwinBufferPolicySelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Hosting;

namespace System.Web.Http.Owin
{
    /// <summary>
    /// Provides the default implementation of <see cref="IHostBufferPolicySelector"/> used by the OWIN Web API adapter.
    /// </summary>
    public class OwinBufferPolicySelector : IHostBufferPolicySelector
    {
        /// <inheritdoc />
        public bool UseBufferedInputStream(object hostContext)
        {
            return false;
        }

        /// <inheritdoc />
        public bool UseBufferedOutputStream(HttpResponseMessage response)
        {
            if (response == null)
            {
                throw Error.ArgumentNull("response");
            }

            HttpContent content = response.Content;
            if (content == null)
            {
                return false;
            }

            // Any HttpContent that knows its length is presumably already buffered internally.
            long? contentLength = content.Headers.ContentLength;
            if (contentLength.HasValue && contentLength.Value >= 0)
            {
                return false;
            }

            // If the response is meant to use chunked transfer encoding, don't buffer.
            bool? transferEncodingChunked = response.Headers.TransferEncodingChunked;
            if (transferEncodingChunked.HasValue && transferEncodingChunked.Value)
            {
                return false;
            }

            // Content length is null or -1 (meaning not known).  
            // Buffer any HttpContent except StreamContent and PushStreamContent
            if (content is StreamContent || content is PushStreamContent)
            {
                return false;
            }

            return true;
        }
    }
}

================================================
FILE: src/System.Web.Http.Owin/OwinConstants.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Owin
{
    /// <summary>
    /// Standard keys and values for use within the OWIN interfaces.
    /// </summary>
    internal static class OwinConstants
    {
        // Request keys
        public const string ClientCertifiateKey = "ssl.ClientCertificate";
        public const string IsLocalKey = "server.IsLocal";
    }
}

================================================
FILE: src/System.Web.Http.Owin/OwinExceptionCatchBlocks.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;

namespace System.Web.Http.Owin
{
    /// <summary>Provides the catch blocks used within this assembly.</summary>
    public static class OwinExceptionCatchBlocks
    {
        private static readonly ExceptionContextCatchBlock _httpMessageHandlerAdapterBufferContent =
            new ExceptionContextCatchBlock(typeof(HttpMessageHandlerAdapter).Name + ".BufferContent",
                isTopLevel: true, callsHandler: true);
        private static readonly ExceptionContextCatchBlock _httpMessageHandlerAdapterBufferError =
            new ExceptionContextCatchBlock(typeof(HttpMessageHandlerAdapter).Name + ".BufferError", isTopLevel: true,
                callsHandler: false);
        private static readonly ExceptionContextCatchBlock _httpMessageHandlerAdapterComputeContentLength =
            new ExceptionContextCatchBlock(typeof(HttpMessageHandlerAdapter).Name + ".ComputeContentLength",
                isTopLevel: true, callsHandler: false);
        private static readonly ExceptionContextCatchBlock _httpMessageHandlerAdapterStreamContent =
            new ExceptionContextCatchBlock(typeof(HttpMessageHandlerAdapter).Name + ".StreamContent",
                isTopLevel: true, callsHandler: false);

        /// <summary>Gets the catch block in <see cref="HttpMessageHandlerAdapter"/>.BufferContent.</summary>
        /// <remarks>
        /// This catch block handles exceptions when writing the <see cref="HttpContent"/> under an
        /// <see cref="IHostBufferPolicySelector"/> that buffers.
        /// </remarks>
        public static ExceptionContextCatchBlock HttpMessageHandlerAdapterBufferContent
        {
            get
            {
                return _httpMessageHandlerAdapterBufferContent;
            }
        }

        /// <summary>Gets the catch block in <see cref="HttpMessageHandlerAdapter"/>.BufferError.</summary>
        /// <remarks>
        /// This catch block handles exceptions when writing the <see cref="HttpContent"/> of the error response itself
        /// (after <see cref="HttpMessageHandlerAdapterBufferContent"/>).
        /// </remarks>
        public static ExceptionContextCatchBlock HttpMessageHandlerAdapterBufferError
        {
            get
            {
                return _httpMessageHandlerAdapterBufferError;
            }
        }

        /// <summary>Gets the catch block in <see cref="HttpMessageHandlerAdapter"/>.ComputeContentLength.</summary>
        /// <remarks>
        /// This catch block handles exceptions when calling <see cref="HttpContent.TryComputeLength"/>.
        /// </remarks>
        public static ExceptionContextCatchBlock HttpMessageHandlerAdapterComputeContentLength
        {
            get
            {
                return _httpMessageHandlerAdapterComputeContentLength;
            }
        }

        /// <summary>Gets the catch block in <see cref="HttpMessageHandlerAdapter"/>.StreamContent.</summary>
        /// <remarks>
        /// This catch block handles exceptions when writing the <see cref="HttpContent"/> under an
        /// <see cref="IHostBufferPolicySelector"/> that does not buffer.
        /// </remarks>
        public static ExceptionContextCatchBlock HttpMessageHandlerAdapterStreamContent
        {
            get
            {
                return _httpMessageHandlerAdapterStreamContent;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/OwinHttpConfigurationExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Web.Http.Filters;
using System.Web.Http.Owin;

namespace System.Web.Http
{
    /// <summary>Provides extension methods for the <see cref="HttpConfiguration"/> class.</summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class OwinHttpConfigurationExtensions
    {
        /// <summary>Enables suppression of the host's default authentication.</summary>
        /// <param name="configuration">The server configuration.</param>
        /// <remarks>
        /// When the host's default authentication is suppressed, the current principal is set to anonymous upon
        /// entering the <see cref="HttpServer"/>'s first message handler. As a result, any default authentication
        /// performed by the host is ignored. The remaining pipeline within the <see cref="HttpServer"/>, including
        /// <see cref="IAuthenticationFilter"/>s, is then the exclusive authority for authentication.
        /// </remarks>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "Message handler should be disposed with parent configuration.")]
        public static void SuppressDefaultHostAuthentication(this HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            Contract.Assert(configuration.MessageHandlers != null);
            configuration.MessageHandlers.Insert(0, new PassiveAuthenticationMessageHandler());
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/OwinHttpRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.Owin;

namespace System.Web.Http.Owin
{
    internal class OwinHttpRequestContext : HttpRequestContext
    {
        private readonly IOwinContext _context;
        private readonly HttpRequestMessage _request;

        private X509Certificate2 _clientCertificate;
        private bool _clientCertificateSet;

        private bool _includeErrorDetail;
        private bool _includeErrorDetailSet;

        private bool _isLocal;
        private bool _isLocalSet;

        private UrlHelper _url;
        private bool _urlSet;

        private string _virtualPathRoot;
        private bool _virtualPathRootSet;

        public OwinHttpRequestContext(IOwinContext context, HttpRequestMessage request)
        {
            Contract.Assert(context != null);
            Contract.Assert(context.Request != null);
            Contract.Assert(request != null);
            _context = context;
            _request = request;
        }

        public IOwinContext Context
        {
            get { return _context; }
        }

        public HttpRequestMessage Request
        {
            get { return _request; }
        }

        //// Configuration and RouteData are not overridden; these values are provided by later points in the
        ////  pipeline (HttpServer and HttpRoutingDispatcher)

        public override X509Certificate2 ClientCertificate
        {
            get
            {
                if (!_clientCertificateSet)
                {
                    _clientCertificate = _context.Get<X509Certificate2>(OwinConstants.ClientCertifiateKey);
                    _clientCertificateSet = true;
                }

                return _clientCertificate;
            }
            set
            {
                _clientCertificate = value;
                _clientCertificateSet = true;
            }
        }

        public override bool IncludeErrorDetail
        {
            get
            {
                if (!_includeErrorDetailSet)
                {
                    HttpConfiguration configuration = Configuration;
                    IncludeErrorDetailPolicy includeErrorDetailPolicy;

                    if (configuration != null)
                    {
                        includeErrorDetailPolicy = configuration.IncludeErrorDetailPolicy;
                    }
                    else
                    {
                        includeErrorDetailPolicy = IncludeErrorDetailPolicy.Default;
                    }

                    bool value;

                    switch (includeErrorDetailPolicy)
                    {
                        case IncludeErrorDetailPolicy.Default:
                        case IncludeErrorDetailPolicy.LocalOnly:
                            value = IsLocal;
                            break;

                        case IncludeErrorDetailPolicy.Always:
                            value = true;
                            break;

                        case IncludeErrorDetailPolicy.Never:
                        default:
                            value = false;
                            break;
                    }

                    _includeErrorDetail = value;
                    _includeErrorDetailSet = true;
                }

                return _includeErrorDetail;
            }
            set
            {
                _includeErrorDetail = value;
                _includeErrorDetailSet = true;
            }
        }

        public override bool IsLocal
        {
            get
            {
                if (!_isLocalSet)
                {
                    _isLocal = _context.Get<bool>(OwinConstants.IsLocalKey);
                    _isLocalSet = true;
                }

                return _isLocal;
            }
            set
            {
                _isLocal = value;
                _isLocalSet = true;
            }
        }

        public override IPrincipal Principal
        {
            get
            {
                return _context.Request.User;
            }
            set
            {
                _context.Request.User = value;
                Thread.CurrentPrincipal = value;
            }
        }

        public override UrlHelper Url
        {
            get
            {
                if (!_urlSet)
                {
                    _url = new UrlHelper(_request);
                    _urlSet = true;
                }

                return _url;
            }
            set
            {
                _url = value;
                _urlSet = true;
            }
        }

        public override string VirtualPathRoot
        {
            get
            {
                if (!_virtualPathRootSet)
                {
                    // Set the virtual path root for link resolution and link generation to work
                    // OWIN spec requires request path base to be either the empty string or start with "/"
                    string requestPathBase = _context.Request.PathBase.Value;
                    _virtualPathRoot = String.IsNullOrEmpty(requestPathBase) ? "/" : requestPathBase;
                    _virtualPathRootSet = true;
                }

                return _virtualPathRoot;
            }
            set
            {
                _virtualPathRoot = value;
                _virtualPathRootSet = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/OwinHttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using Microsoft.Owin;
using Microsoft.Owin.Security;

namespace System.Net.Http
{
    /// <summary>
    /// Provides extension methods for the <see cref="HttpRequestMessage"/> class.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class OwinHttpRequestMessageExtensions
    {
        private const string OwinEnvironmentKey = "MS_OwinEnvironment";
        private const string OwinContextKey = "MS_OwinContext";

        /// <summary>Gets the OWIN context for the specified request.</summary>
        /// <param name="request">The HTTP request message.</param>
        /// <returns>
        /// The OWIN environment for the specified context, if available; otherwise <see langword="null"/>.
        /// </returns>
        public static IOwinContext GetOwinContext(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            IOwinContext context;
            if (!request.Properties.TryGetValue<IOwinContext>(OwinContextKey, out context))
            {
                // If the OWIN context is not available, try to create by upgrading an OWIN environment property
                // instead.
                IDictionary<string, object> environment;
                if (request.Properties.TryGetValue<IDictionary<string, object>>(OwinEnvironmentKey, out environment))
                {
                    context = new OwinContext(environment);
                    SetOwinContext(request, context);
                    request.Properties.Remove(OwinEnvironmentKey);
                }
            }
            return context;
        }

        /// <summary>Sets the OWIN context for the specified request.</summary>
        /// <param name="request">The HTTP request message.</param>
        /// <param name="context">The OWIN context to set.</param>
        public static void SetOwinContext(this HttpRequestMessage request, IOwinContext context)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            request.Properties[OwinContextKey] = context;
            // Make sure only one of the two properties exists (single source of truth).
            request.Properties.Remove(OwinEnvironmentKey);
        }

        /// <summary>Gets the OWIN environment for the specified request.</summary>
        /// <param name="request">The HTTP request message.</param>
        /// <returns>
        /// The OWIN environment for the specified request, if available; otherwise <see langword="null"/>.
        /// </returns>
        public static IDictionary<string, object> GetOwinEnvironment(this HttpRequestMessage request)
        {
            IOwinContext context = GetOwinContext(request);

            if (context == null)
            {
                return null;
            }

            return context.Environment;
        }

        /// <summary>Sets the OWIN environment for the specified request.</summary>
        /// <param name="request">The HTTP request message.</param>
        /// <param name="environment">The OWIN environment to set.</param>
        public static void SetOwinEnvironment(this HttpRequestMessage request, IDictionary<string, object> environment)
        {
            SetOwinContext(request, new OwinContext(environment));
        }

        internal static IAuthenticationManager GetAuthenticationManager(this HttpRequestMessage request)
        {
            IOwinContext context = GetOwinContext(request);

            if (context == null)
            {
                return null;
            }

            return context.Authentication;
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/OwinRequestExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using Microsoft.Owin;

namespace System.Web.Http.Owin
{
    internal static class OwinRequestExtensions
    {
        private const string ContentLengthHeaderName = "Content-Length";
        private const string DisableRequestBufferingKey = "server.DisableRequestBuffering";

        public static void DisableBuffering(this IOwinRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            IDictionary<string, object> environment = request.Environment;

            if (environment == null)
            {
                return;
            }

            Action action;

            if (!environment.TryGetValue(DisableRequestBufferingKey, out action))
            {
                return;
            }

            Contract.Assert(action != null);
            action.Invoke();
        }

        public static int? GetContentLength(this IOwinRequest request)
        {
            Contract.Assert(request != null);

            IHeaderDictionary headers = request.Headers;

            if (headers == null)
            {
                return null;
            }

            string[] values;

            if (!headers.TryGetValue(ContentLengthHeaderName, out values))
            {
                return null;
            }

            if (values == null || values.Length != 1)
            {
                return null;
            }

            string value = values[0];

            if (value == null)
            {
                return null;
            }

            int parsed;

            if (!Int32.TryParse(value, out parsed))
            {
                return null;
            }

            if (parsed < 0)
            {
                return null;
            }

            return parsed;
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/OwinResponseExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using Microsoft.Owin;

namespace System.Web.Http.Owin
{
    internal static class OwinResponseExtensions
    {
        private const string DisableResponseBufferingKey = "server.DisableResponseBuffering";

        public static void DisableBuffering(this IOwinResponse response)
        {
            if (response == null)
            {
                throw new ArgumentNullException("response");
            }

            IDictionary<string, object> environment = response.Environment;

            if (environment == null)
            {
                return;
            }

            Action action;

            if (!environment.TryGetValue(DisableResponseBufferingKey, out action))
            {
                return;
            }

            Contract.Assert(action != null);
            action.Invoke();
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/PassiveAuthenticationMessageHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Security.Claims;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Owin.Properties;
using Microsoft.Owin.Security;

namespace System.Web.Http.Owin
{
    /// <summary>Represents a message handler that treats all OWIN authentication middleware as passive.</summary>
    /// <remarks>
    /// This message handler sets the current principal to anonymous upon entry and disables the default OWIN
    /// authentication middleware challenges. As a result, any default authentication performed by the host is ignored.
    /// The subsequent pipeline, including <see cref="IAuthenticationFilter"/>s, is then the exclusive authority for
    /// authentication.
    /// </remarks>
    public class PassiveAuthenticationMessageHandler : DelegatingHandler
    {
        private static readonly Lazy<IPrincipal> _anonymousPrincipal = new Lazy<IPrincipal>(
            () => new ClaimsPrincipal(new ClaimsIdentity()), isThreadSafe: true);

        /// <inheritdoc />
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            HttpResponseMessage response;
            var previousPrincipal = SetCurrentPrincipal(request, _anonymousPrincipal.Value);
            try
            {
                response = await base.SendAsync(request, cancellationToken);
            }
            finally
            {
                SetCurrentPrincipal(request, previousPrincipal);
            }

            SuppressDefaultAuthenticationChallenges(request);

            return response;
        }

        private static IPrincipal SetCurrentPrincipal(HttpRequestMessage request, IPrincipal principal)
        {
            Contract.Assert(request != null);

            HttpRequestContext requestContext = request.GetRequestContext();
            if (requestContext == null)
            {
                throw new ArgumentException(OwinResources.Request_RequestContextMustNotBeNull, "request");
            }

            var previousPrincipal = requestContext.Principal;
            requestContext.Principal = principal;

            return previousPrincipal;
        }

        private static void SuppressDefaultAuthenticationChallenges(HttpRequestMessage request)
        {
            Contract.Assert(request != null);

            IAuthenticationManager authenticationManager = request.GetAuthenticationManager();

            if (authenticationManager == null)
            {
                throw new InvalidOperationException(OwinResources.IAuthenticationManagerNotAvailable);
            }

            AuthenticationResponseChallenge currentChallenge = authenticationManager.AuthenticationResponseChallenge;

            // A null challenge or challenge.AuthenticationTypes == null or empty represents the the default behavior
            // of running all active authentication middleware challenges.
            // Provide an array with a single null item to suppress this default behavior.
            string[] suppressAuthenticationTypes = new string[] { null };

            if (currentChallenge == null)
            {
                authenticationManager.AuthenticationResponseChallenge = new AuthenticationResponseChallenge(
                    suppressAuthenticationTypes, new AuthenticationProperties());
            }
            else if (currentChallenge.AuthenticationTypes == null || currentChallenge.AuthenticationTypes.Length == 0)
            {
                authenticationManager.AuthenticationResponseChallenge = new AuthenticationResponseChallenge(
                    suppressAuthenticationTypes, currentChallenge.Properties);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

[assembly: AssemblyTitle("System.Web.Http.Owin")]
[assembly: AssemblyDescription("")]
[assembly: Guid("41f9da53-4a52-4cd7-af85-77a214c5b13b")]
[assembly: InternalsVisibleTo("System.Web.Http.Owin.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]

================================================
FILE: src/System.Web.Http.Owin/Properties/OwinResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18051
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.Owin.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class OwinResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal OwinResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.Owin.Properties.OwinResources", typeof(OwinResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HttpAuthenticationChallengeContext.Request must not be null..
        /// </summary>
        internal static string HttpAuthenticationChallengeContext_RequestMustNotBeNull {
            get {
                return ResourceManager.GetString("HttpAuthenticationChallengeContext_RequestMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HttpAuthenticationContext.Request must not be null..
        /// </summary>
        internal static string HttpAuthenticationContext_RequestMustNotBeNull {
            get {
                return ResourceManager.GetString("HttpAuthenticationContext_RequestMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No OWIN authentication manager is associated with the request..
        /// </summary>
        internal static string IAuthenticationManagerNotAvailable {
            get {
                return ResourceManager.GetString("IAuthenticationManagerNotAvailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The OWIN context&apos;s Request property must not be null..
        /// </summary>
        internal static string OwinContext_NullRequest {
            get {
                return ResourceManager.GetString("OwinContext_NullRequest", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The OWIN context&apos;s Response property must not be null..
        /// </summary>
        internal static string OwinContext_NullResponse {
            get {
                return ResourceManager.GetString("OwinContext_NullResponse", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The request must have a request context..
        /// </summary>
        internal static string Request_RequestContextMustNotBeNull {
            get {
                return ResourceManager.GetString("Request_RequestContextMustNotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The message handler did not return a response message..
        /// </summary>
        internal static string SendAsync_ReturnedNull {
            get {
                return ResourceManager.GetString("SendAsync_ReturnedNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}.{1} must not be null..
        /// </summary>
        internal static string TypePropertyMustNotBeNull {
            get {
                return ResourceManager.GetString("TypePropertyMustNotBeNull", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/Properties/OwinResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="HttpAuthenticationChallengeContext_RequestMustNotBeNull" xml:space="preserve">
    <value>HttpAuthenticationChallengeContext.Request must not be null.</value>
  </data>
  <data name="HttpAuthenticationContext_RequestMustNotBeNull" xml:space="preserve">
    <value>HttpAuthenticationContext.Request must not be null.</value>
  </data>
  <data name="IAuthenticationManagerNotAvailable" xml:space="preserve">
    <value>No OWIN authentication manager is associated with the request.</value>
  </data>
  <data name="OwinContext_NullRequest" xml:space="preserve">
    <value>The OWIN context's Request property must not be null.</value>
  </data>
  <data name="OwinContext_NullResponse" xml:space="preserve">
    <value>The OWIN context's Response property must not be null.</value>
  </data>
  <data name="Request_RequestContextMustNotBeNull" xml:space="preserve">
    <value>The request must have a request context.</value>
  </data>
  <data name="SendAsync_ReturnedNull" xml:space="preserve">
    <value>The message handler did not return a response message.</value>
  </data>
  <data name="TypePropertyMustNotBeNull" xml:space="preserve">
    <value>{0}.{1} must not be null.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Http.Owin/System.Web.Http.Owin.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{66DD7CD7-C68F-4D0E-9F3D-3B58C49D1467}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.Owin</RootNamespace>
    <AssemblyName>System.Web.Http.Owin</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Microsoft.Owin">
      <HintPath>..\..\packages\Microsoft.Owin.4.2.2\lib\net45\Microsoft.Owin.dll</HintPath>
    </Reference>
    <Reference Include="Owin">
      <HintPath>..\..\packages\Owin.1.0\lib\net40\Owin.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\Common\CollectionExtensions.cs">
      <Link>Common\CollectionExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\DictionaryExtensions.cs">
      <Link>Common\DictionaryExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\Error.cs">
      <Link>Common\Error.cs</Link>
    </Compile>
    <Compile Include="..\Common\ListWrapperCollection.cs">
      <Link>Common\ListWrapperCollection.cs</Link>
    </Compile>
    <Compile Include="..\Common\NonOwnedStream.cs">
      <Link>Common\NonOwnedStream.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpers.cs">
      <Link>Common\TaskHelpers.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpersExtensions.cs">
      <Link>Common\TaskHelpersExtensions.cs</Link>
    </Compile>
    <Compile Include="ExceptionHandling\DefaultExceptionHandler.cs" />
    <Compile Include="ExceptionHandling\EmptyExceptionLogger.cs" />
    <Compile Include="OwinExceptionCatchBlocks.cs" />
    <Compile Include="HostAuthenticationAttribute.cs" />
    <Compile Include="HttpMessageHandlerOptions.cs" />
    <Compile Include="OwinHttpConfigurationExtensions.cs" />
    <Compile Include="HostAuthenticationFilter.cs" />
    <Compile Include="OwinBufferPolicySelector.cs" />
    <Compile Include="OwinConstants.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="HttpMessageHandlerAdapter.cs" />
    <Compile Include="OwinHttpRequestContext.cs" />
    <Compile Include="OwinHttpRequestMessageExtensions.cs" />
    <Compile Include="OwinRequestExtensions.cs" />
    <Compile Include="OwinResponseExtensions.cs" />
    <Compile Include="PassiveAuthenticationMessageHandler.cs" />
    <Compile Include="WebApiAppBuilderExtensions.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\OwinResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>OwinResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Link>Properties\CommonWebApiResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonWebApiResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Properties\OwinResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>OwinResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Http.Owin/WebApiAppBuilderExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Threading;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.Owin;

namespace Owin
{
    /// <summary>
    /// Provides extension methods for the <see cref="IAppBuilder"/> class.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class WebApiAppBuilderExtensions
    {
        private static readonly IHostBufferPolicySelector _defaultBufferPolicySelector =
            new OwinBufferPolicySelector();

        /// <summary>Adds a component to the OWIN pipeline for running a Web API endpoint.</summary>
        /// <param name="builder">The application builder.</param>
        /// <param name="configuration">The <see cref="HttpConfiguration"/> used to configure the endpoint.</param>
        /// <returns>The application builder.</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "In the success path, HttpMessageHandlerAdapter owns the message handler.")]
        public static IAppBuilder UseWebApi(this IAppBuilder builder, HttpConfiguration configuration)
        {
            if (builder == null)
            {
                throw new ArgumentNullException("builder");
            }

            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            HttpServer server = new HttpServer(configuration);

            try
            {
                HttpMessageHandlerOptions options = CreateOptions(builder, server, configuration);
                return UseMessageHandler(builder, options);
            }
            catch
            {
                server.Dispose();
                throw;
            }
        }

        /// <summary>Adds a component to the OWIN pipeline for running a Web API endpoint.</summary>
        /// <param name="builder">The application builder.</param>
        /// <param name="httpServer">The http server.</param>
        /// <returns>The application builder.</returns>
        public static IAppBuilder UseWebApi(this IAppBuilder builder, HttpServer httpServer)
        {
            if (builder == null)
            {
                throw new ArgumentNullException("builder");
            }

            if (httpServer == null)
            {
                throw new ArgumentNullException("httpServer");
            }

            HttpConfiguration configuration = httpServer.Configuration;
            Contract.Assert(configuration != null);

            HttpMessageHandlerOptions options = CreateOptions(builder, httpServer, configuration);
            return UseMessageHandler(builder, options);
        }

        private static IAppBuilder UseMessageHandler(this IAppBuilder builder, HttpMessageHandlerOptions options)
        {
            Contract.Assert(builder != null);
            Contract.Assert(options != null);

            return builder.Use(typeof(HttpMessageHandlerAdapter), options);
        }

        private static HttpMessageHandlerOptions CreateOptions(IAppBuilder builder, HttpServer server,
            HttpConfiguration configuration)
        {
            Contract.Assert(builder != null);
            Contract.Assert(server != null);
            Contract.Assert(configuration != null);

            ServicesContainer services = configuration.Services;
            Contract.Assert(services != null);

            IHostBufferPolicySelector bufferPolicySelector = services.GetHostBufferPolicySelector()
                ?? _defaultBufferPolicySelector;
            IExceptionLogger exceptionLogger = ExceptionServices.GetLogger(services);
            IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(services);

            return new HttpMessageHandlerOptions
            {
                MessageHandler = server,
                BufferPolicySelector = bufferPolicySelector,
                ExceptionLogger = exceptionLogger,
                ExceptionHandler = exceptionHandler,
                AppDisposing = builder.GetOnAppDisposingProperty()
            };
        }

        internal static CancellationToken GetOnAppDisposingProperty(this IAppBuilder builder)
        {
            Contract.Assert(builder != null);

            IDictionary<string, object> properties = builder.Properties;

            if (properties == null)
            {
                return CancellationToken.None;
            }

            object value;

            if (!properties.TryGetValue("host.OnAppDisposing", out value))
            {
                return CancellationToken.None;
            }

            CancellationToken? token = value as CancellationToken?;

            if (!token.HasValue)
            {
                return CancellationToken.None;
            }

            return token.Value;
        }
    }
}


================================================
FILE: src/System.Web.Http.Owin/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Owin" version="4.2.2" targetFramework="net45" />
  <package id="Owin" version="1.0" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpBinding.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.ServiceModel;
using System.Web.Http.SelfHost.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.Channels
{   
    /// <summary>
    /// A binding used with endpoints for web services that use strongly-type HTTP request 
    /// and response messages.
    /// </summary>
    public class HttpBinding : Binding, IBindingRuntimePreferences
    {
        internal const string CollectionElementName = "httpBinding";
        internal const TransferMode DefaultTransferMode = System.ServiceModel.TransferMode.Buffered;
        
        private HttpsTransportBindingElement _httpsTransportBindingElement;
        private HttpTransportBindingElement _httpTransportBindingElement;
        private HttpBindingSecurity _security;
        private HttpMessageEncodingBindingElement _httpMessageEncodingBindingElement;
        private Action<HttpTransportBindingElement> _configureTransportBindingElement;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpBinding"/> class.
        /// </summary>
        public HttpBinding()
        {
            Initialize();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpBinding"/> class with the 
        /// type of security used by the binding explicitly specified.
        /// </summary>
        /// <param name="securityMode">The value of <see cref="HttpBindingSecurityMode"/> that 
        /// specifies the type of security that is used to configure a service endpoint using the
        /// <see cref="HttpBinding"/> binding.
        /// </param>
        public HttpBinding(HttpBindingSecurityMode securityMode)
            : this()
        {
            _security.Mode = securityMode;
        }

        /// <summary>
        /// Gets the envelope version that is used by endpoints that are configured to use an 
        /// <see cref="HttpBinding"/> binding.  Always returns <see cref="System.ServiceModel.EnvelopeVersion.None"/>.
        /// </summary>
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is existing public API")]
        public EnvelopeVersion EnvelopeVersion
        {
            get { return EnvelopeVersion.None; }
        }

        /// <summary>
        /// Gets or sets a value that indicates whether the hostname is used to reach the 
        /// service when matching the URI.
        /// </summary>
        [DefaultValue(HttpTransportDefaults.HostNameComparisonMode)]
        public HostNameComparisonMode HostNameComparisonMode
        {
            get { return _httpTransportBindingElement.HostNameComparisonMode; }

            set
            {
                _httpTransportBindingElement.HostNameComparisonMode = value;
                _httpsTransportBindingElement.HostNameComparisonMode = value;
            }
        }

        /// <summary>
        /// Gets or sets the maximum amount of memory allocated for the buffer manager that manages the buffers 
        /// required by endpoints that use this binding.
        /// </summary>
        [DefaultValue(TransportDefaults.MaxBufferPoolSize)]
        public long MaxBufferPoolSize
        {
            get { return _httpTransportBindingElement.MaxBufferPoolSize; }

            set
            {
                _httpTransportBindingElement.MaxBufferPoolSize = value;
                _httpsTransportBindingElement.MaxBufferPoolSize = value;
            }
        }

        /// <summary>
        /// Gets or sets the maximum amount of memory that is allocated for use by the manager of the message 
        /// buffers that receive messages from the channel.
        /// </summary>
        [DefaultValue(TransportDefaults.MaxBufferSize)]
        public int MaxBufferSize
        {
            get { return _httpTransportBindingElement.MaxBufferSize; }

            set
            {
                _httpTransportBindingElement.MaxBufferSize = value;
                _httpsTransportBindingElement.MaxBufferSize = value;
            }
        }

        /// <summary>
        /// Gets or sets the maximum size for a message that can be processed by the binding.
        /// </summary>
        [DefaultValue(TransportDefaults.MaxReceivedMessageSize)]
        public long MaxReceivedMessageSize
        {
            get { return _httpTransportBindingElement.MaxReceivedMessageSize; }

            set
            {
                _httpTransportBindingElement.MaxReceivedMessageSize = value;
                _httpsTransportBindingElement.MaxReceivedMessageSize = value;
            }
        }

        /// <summary>
        /// Gets or sets the delegate which can configure the <see cref="HttpTransportBindingElement"/> that this binding creates.
        /// </summary>
        public Action<HttpTransportBindingElement> ConfigureTransportBindingElement
        {
            get { return _configureTransportBindingElement; }

            set 
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _configureTransportBindingElement = value;              
            }
        }

        /// <summary>
        /// Gets the URI transport scheme for the channels and listeners that are configured 
        /// with this binding. (Overrides <see cref="System.ServiceModel.Channels.Binding.Scheme">
        /// Binding.Scheme</see>.)
        /// </summary>
        public override string Scheme
        {
            get { return GetTransport().Scheme; }
        }

        /// <summary>
        /// Gets or sets the security settings used with this binding. 
        /// </summary>
        public HttpBindingSecurity Security
        {
            get { return _security; }

            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }

                _security = value;
            }
        }

        /// <summary>
        /// Gets or sets a value that indicates whether the service configured with the 
        /// binding uses streamed or buffered (or both) modes of message transfer.
        /// </summary>
        [DefaultValue(HttpTransportDefaults.TransferMode)]
        public TransferMode TransferMode
        {
            get { return _httpTransportBindingElement.TransferMode; }

            set
            {
                _httpTransportBindingElement.TransferMode = value;
                _httpsTransportBindingElement.TransferMode = value;
            }
        }

        /// <summary>
        /// Gets a value indicating whether incoming requests can be handled more efficiently synchronously or asynchronously.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "This is the pattern used by all standard bindings.")]
        bool IBindingRuntimePreferences.ReceiveSynchronously
        {
            get { return false; }
        }

        /// <summary>
        /// Returns an ordered collection of binding elements contained in the current binding. 
        /// (Overrides <see cref="System.ServiceModel.Channels.Binding.CreateBindingElements">
        /// Binding.CreateBindingElements</see>.)
        /// </summary>
        /// <returns>
        /// An ordered collection of binding elements contained in the current binding.
        /// </returns>
        public override BindingElementCollection CreateBindingElements()
        {
            BindingElementCollection bindingElements = new BindingElementCollection();

            bindingElements.Add(_httpMessageEncodingBindingElement);
            bindingElements.Add(GetTransport());

            return bindingElements.Clone();
        }

        private TransportBindingElement GetTransport()
        {
            HttpTransportBindingElement result = null;

            if (_security.Mode == HttpBindingSecurityMode.Transport)
            {
                _security.Transport.ConfigureTransportProtectionAndAuthentication(_httpsTransportBindingElement);
                result = _httpsTransportBindingElement;
            }
            else if (_security.Mode == HttpBindingSecurityMode.TransportCredentialOnly)
            {
                _security.Transport.ConfigureTransportAuthentication(_httpTransportBindingElement);
                result = _httpTransportBindingElement;
            }
            else
            {
                _security.Transport.DisableTransportAuthentication(_httpTransportBindingElement);
                result = _httpTransportBindingElement;
            }

            // give customer final chance to customize the auth scheme
            if (_configureTransportBindingElement != null)
            {
                _configureTransportBindingElement(result);
            }

            return result;
        }

        private void Initialize()
        {
            _security = new HttpBindingSecurity();

            _httpTransportBindingElement = new HttpTransportBindingElement();
            _httpTransportBindingElement.ManualAddressing = true;

            _httpsTransportBindingElement = new HttpsTransportBindingElement();
            _httpsTransportBindingElement.ManualAddressing = true;

            _httpMessageEncodingBindingElement = new HttpMessageEncodingBindingElement();
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpBindingSecurity.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;

namespace System.Web.Http.SelfHost.Channels
{
    /// <summary>
    /// Specifies the types of security available to a service endpoint configured to use an
    /// <see cref="HttpBinding"/> binding.
    /// </summary>
    public sealed class HttpBindingSecurity
    {
        internal const HttpBindingSecurityMode DefaultMode = HttpBindingSecurityMode.None;

        private HttpBindingSecurityMode _mode;
        private HttpTransportSecurity _transportSecurity;

        /// <summary>
        /// Creates a new instance of the <see cref="HttpBindingSecurity"/> class.
        /// </summary>
        public HttpBindingSecurity()
        {
            _mode = DefaultMode;
            _transportSecurity = new HttpTransportSecurity();
        }

        /// <summary>
        /// Gets or sets the mode of security that is used by an endpoint configured to use an
        /// <see cref="HttpBinding"/> binding.
        /// </summary>
        public HttpBindingSecurityMode Mode
        {
            get { return _mode; }

            set
            {
                HttpBindingSecurityModeHelper.Validate(value, "value");
                _mode = value;
            }
        }

        /// <summary>
        /// Gets or sets an object that contains the transport-level security settings for the 
        /// <see cref="HttpBinding"/> binding.
        /// </summary>
        public HttpTransportSecurity Transport
        {
            get { return _transportSecurity; }

            set { _transportSecurity = value ?? new HttpTransportSecurity(); }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpBindingSecurityMode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.SelfHost.Channels
{
    /// <summary>
    /// Defines the modes of security that can be used to configure a service endpoint that uses the
    /// <see cref="HttpBinding"/>.
    /// </summary>
    public enum HttpBindingSecurityMode
    {
        /// <summary>
        /// Indicates no security is used with HTTP requests.
        /// </summary>
        None,

        /// <summary>
        /// Indicates that transport-level security is used with HTTP requests.
        /// </summary>
        Transport,

        /// <summary>
        /// Indicates that only HTTP-based client authentication is provided.
        /// </summary>
        TransportCredentialOnly,
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpBindingSecurityModeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;

namespace System.Web.Http.SelfHost.Channels
{
    /// <summary>
    /// Internal helper class to validate <see cref="HttpBindingSecurityMode"/> enum values.
    /// </summary>
    internal static class HttpBindingSecurityModeHelper
    {
        /// <summary>
        /// Determines whether the specified <paramref name="value"/> is defined by the <see cref="HttpBindingSecurityMode"/>
        /// enumeration.
        /// </summary>
        /// <param name="value">The value to test.</param>
        /// <returns><c>true</c> if <paramref name="value"/> is a valid <see cref="HttpBindingSecurityMode"/> value; otherwise<c> false</c>.</returns>
        public static bool IsDefined(HttpBindingSecurityMode value)
        {
            return value == HttpBindingSecurityMode.None ||
                   value == HttpBindingSecurityMode.Transport ||
                   value == HttpBindingSecurityMode.TransportCredentialOnly;
        }

        /// <summary>
        /// Validates the specified <paramref name="value"/> and throws an <see cref="InvalidEnumArgumentException"/>
        /// exception if not valid.
        /// </summary>
        /// <param name="value">The value to validate.</param>
        /// <param name="parameterName">Name of the parameter to use if throwing exception.</param>
        public static void Validate(HttpBindingSecurityMode value, string parameterName)
        {
            if (!IsDefined(value))
            {
                throw Error.InvalidEnumArgument(parameterName, (int)value, typeof(HttpBindingSecurityMode));
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpMessage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.Properties;
using System.Xml;

namespace System.Web.Http.SelfHost.Channels
{
    internal sealed class HttpMessage : Message
    {
        private HttpRequestMessage _request;
        private HttpResponseMessage _response;
        private MessageHeaders _headers;
        private MessageProperties _properties;

        public HttpMessage(HttpRequestMessage request)
        {
            Contract.Assert(request != null, "The 'request' parameter should not be null.");
            _request = request;
            Headers.To = request.RequestUri;
            IsRequest = true;
        }

        public HttpMessage(HttpResponseMessage response)
        {
            Contract.Assert(response != null, "The 'response' parameter should not be null.");
            _response = response;
            IsRequest = false;
        }

        public override MessageVersion Version
        {
            get
            {
                EnsureNotDisposed();
                return MessageVersion.None;
            }
        }

        public override MessageHeaders Headers
        {
            get
            {
                EnsureNotDisposed();
                if (_headers == null)
                {
                    _headers = new MessageHeaders(MessageVersion.None);
                }

                return _headers;
            }
        }

        public override MessageProperties Properties
        {
            get
            {
                EnsureNotDisposed();
                if (_properties == null)
                {
                    _properties = new MessageProperties();
                    _properties.AllowOutputBatching = false;
                }

                return _properties;
            }
        }

        public override bool IsEmpty
        {
            get
            {
                long? contentLength = GetHttpContentLength();
                return contentLength.HasValue && contentLength.Value == 0;
            }
        }

        public override bool IsFault
        {
            get { return false; }
        }

        public bool IsRequest { get; private set; }

        public HttpRequestMessage GetHttpRequestMessage(bool extract)
        {
            EnsureNotDisposed();
            Contract.Assert(IsRequest, "This method should only be called when IsRequest is true.");
            if (extract)
            {
                HttpRequestMessage req = _request;
                _request = null;
                return req;
            }

            return _request;
        }

        public HttpResponseMessage GetHttpResponseMessage(bool extract)
        {
            EnsureNotDisposed();
            Contract.Assert(!IsRequest, "This method should only be called when IsRequest is false.");
            if (extract)
            {
                HttpResponseMessage res = _response;
                _response = null;
                return res;
            }

            return _response;
        }

        protected override void OnWriteBodyContents(XmlDictionaryWriter writer)
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override MessageBuffer OnCreateBufferedCopy(int maxBufferSize)
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override XmlDictionaryReader OnGetReaderAtBodyContents()
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override string OnGetBodyAttribute(string localName, string ns)
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override void OnWriteStartBody(XmlDictionaryWriter writer)
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override void OnWriteStartEnvelope(XmlDictionaryWriter writer)
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override void OnBodyToString(XmlDictionaryWriter writer)
        {
            if (writer == null)
            {
                throw Error.ArgumentNull("writer");
            }

            long? contentLength = GetHttpContentLength();
            string contentString = null;

            if (IsRequest)
            {
                contentString = contentLength.HasValue
                                    ? Error.Format(SRResources.MessageBodyIsHttpRequestMessageWithKnownContentLength, contentLength.Value)
                                    : SRResources.MessageBodyIsHttpRequestMessageWithUnknownContentLength;
            }
            else
            {
                contentString = contentLength.HasValue
                                    ? Error.Format(SRResources.MessageBodyIsHttpResponseMessageWithKnownContentLength, contentLength.Value)
                                    : SRResources.MessageBodyIsHttpResponseMessageWithUnknownContentLength;
            }

            writer.WriteString(contentString);
        }

        protected override void OnWriteMessage(XmlDictionaryWriter writer)
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override void OnWriteStartHeaders(XmlDictionaryWriter writer)
        {
            throw Error.NotSupported(GetNotSupportedMessage());
        }

        protected override void OnClose()
        {
            base.OnClose();
            if (_request != null)
            {
                _request.DisposeRequestResources();
                _request.Dispose();
                _request = null;
            }

            if (_response != null)
            {
                _response.Dispose();
                _response = null;
            }
        }

        private static string GetNotSupportedMessage()
        {
            return Error.Format(
                SRResources.MessageReadWriteCopyNotSupported,
                HttpMessageExtensions.ToHttpRequestMessageMethodName,
                HttpMessageExtensions.ToHttpResponseMessageMethodName,
                typeof(HttpMessage).Name);
        }

        private void EnsureNotDisposed()
        {
            if (IsDisposed)
            {
                throw Error.ObjectDisposed(SRResources.MessageClosed, typeof(Message).Name);
            }
        }

        private long? GetHttpContentLength()
        {
            HttpContent content = IsRequest
                                      ? GetHttpRequestMessage(false).Content
                                      : GetHttpResponseMessage(false).Content;

            if (content == null)
            {
                return 0;
            }

            return content.Headers.ContentLength;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpMessageEncoderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net.Http;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.SelfHost.Properties;
using System.Web.Http.SelfHost.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.Channels
{
    internal class HttpMessageEncoderFactory : MessageEncoderFactory
    {
        private HttpMessageEncoder _encoder;

        public HttpMessageEncoderFactory()
        {
            _encoder = new HttpMessageEncoder();
        }

        public override MessageEncoder Encoder
        {
            get { return _encoder; }
        }

        public override MessageVersion MessageVersion
        {
            get { return MessageVersion.None; }
        }

        public override MessageEncoder CreateSessionEncoder()
        {
            throw Error.NotSupported(SRResources.HttpMessageEncoderFactoryDoesNotSupportSessionEncoder, typeof(HttpMessageEncoderFactory).Name);
        }

        private class HttpMessageEncoder : MessageEncoder
        {
            private const string ContentTypeHeaderName = "Content-Type";
            private const string MaxSentMessageSizeExceededResourceStringName = "MaxSentMessageSizeExceeded";
            private static readonly string _httpBindingClassName = typeof(HttpBinding).FullName;
            private static readonly string _httpResponseMessageClassName = typeof(HttpResponseMessage).FullName;

            public override string ContentType
            {
                get { return String.Empty; }
            }

            public override string MediaType
            {
                get { return String.Empty; }
            }

            public override MessageVersion MessageVersion
            {
                get { return MessageVersion.None; }
            }

            public override bool IsContentTypeSupported(string contentType)
            {
                if (contentType == null)
                {
                    throw Error.ArgumentNull("contentType");
                }

                return true;
            }

            [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "disposed later.")]
            public override Message ReadMessage(ArraySegment<byte> buffer, BufferManager bufferManager, string contentType)
            {
                if (bufferManager == null)
                {
                    throw Error.ArgumentNull("bufferManager");
                }

                HttpRequestMessage request = new HttpRequestMessage();
                request.Content = new ByteArrayBufferManagerContent(bufferManager, buffer.Array, buffer.Offset, buffer.Count);
                if (!String.IsNullOrEmpty(contentType))
                {
                    request.Content.Headers.TryAddWithoutValidation(ContentTypeHeaderName, contentType);
                }

                Message message = request.ToMessage();
                message.Properties.Encoder = this;

                return message;
            }

            [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "disposed later.")]
            public override Message ReadMessage(Stream stream, int maxSizeOfHeaders, string contentType)
            {
                if (stream == null)
                {
                    throw Error.ArgumentNull("stream");
                }

                HttpRequestMessage request = new HttpRequestMessage();
                request.Content = new StreamContent(stream);
                if (!String.IsNullOrEmpty(contentType))
                {
                    request.Content.Headers.TryAddWithoutValidation(ContentTypeHeaderName, contentType);
                }

                Message message = request.ToMessage();
                message.Properties.Encoder = this;

                return message;
            }

            public override ArraySegment<byte> WriteMessage(Message message, int maxMessageSize, BufferManager bufferManager, int messageOffset)
            {
                if (message == null)
                {
                    throw Error.ArgumentNull("message");
                }

                if (bufferManager == null)
                {
                    throw Error.ArgumentNull("bufferManager");
                }

                if (maxMessageSize < 0)
                {
                    throw Error.ArgumentOutOfRange("maxMessageSize", maxMessageSize, SRResources.NonnegativeNumberRequired);
                }

                if (messageOffset < 0)
                {
                    throw Error.ArgumentOutOfRange("messageOffset", messageOffset, SRResources.NonnegativeNumberRequired);
                }

                if (messageOffset > maxMessageSize)
                {
                    throw Error.Argument(String.Empty, SRResources.ParameterMustBeLessThanOrEqualSecondParameter, "messageOffset", "maxMessageSize");
                }

                // TODO: DevDiv2 bug #378887 -- find out how to eliminate this middle buffer
                using (BufferManagerOutputStream stream = new BufferManagerOutputStream(MaxSentMessageSizeExceededResourceStringName, 0, maxMessageSize, bufferManager))
                {
                    int num;
                    stream.Skip(messageOffset);
                    WriteMessage(message, stream);

                    byte[] buffer = stream.ToArray(out num);
                    ArraySegment<byte> messageData = new ArraySegment<byte>(buffer, 0, num - messageOffset);

                    // ToArray transfers full ownership of buffer to us, meaning we are responsible for returning it to BufferManager.
                    // But we must delay that release until WCF has finished with the buffer we are returning from this method.
                    HttpMessageEncodingRequestContext requestContext = HttpMessageEncodingRequestContext.GetContextFromMessage(message);
                    Contract.Assert(requestContext != null);
                    requestContext.BufferManager = bufferManager;
                    requestContext.BufferToReturn = buffer;

                    return messageData;
                }
            }

            [SuppressMessage("Microsoft.Web.FxCop", "MW1201:DoNotCallProblematicMethodsOnTask", Justification = "The WriteMessage() API is synchronous, and Wait() won't deadlock in self-host.")]
            public override void WriteMessage(Message message, Stream stream)
            {
                if (message == null)
                {
                    throw Error.ArgumentNull("message");
                }

                if (stream == null)
                {
                    throw Error.ArgumentNull("stream");
                }

                ThrowIfMismatchedMessageVersion(message);

                message.Properties.Encoder = this;

                HttpResponseMessage response = GetHttpResponseMessageOrThrow(message);

                if (response.Content != null)
                {
                    HttpMessageEncodingRequestContext requestContext =
                        HttpMessageEncodingRequestContext.GetContextFromMessage(message);

                    WriteMessageCore(response, stream, requestContext).Wait();
                }
            }

            private static async Task WriteMessageCore(
                HttpResponseMessage response,
                Stream stream,
                HttpMessageEncodingRequestContext requestContext)
            {
                try
                {
                    await response.Content.CopyToAsync(stream);
                }
                catch (Exception ex)
                {
                    if (requestContext != null)
                    {
                        requestContext.Exception = ex;
                    }

                    throw;
                }
            }

            internal void ThrowIfMismatchedMessageVersion(Message message)
            {
                if (message.Version != MessageVersion)
                {
                    throw new ProtocolException(Error.Format(SRResources.EncoderMessageVersionMismatch, message.Version, MessageVersion));
                }
            }

            private static HttpResponseMessage GetHttpResponseMessageOrThrow(Message message)
            {
                HttpResponseMessage response = message.ToHttpResponseMessage();
                if (response == null)
                {
                    throw Error.InvalidOperation(
                        SRResources.MessageInvalidForHttpMessageEncoder,
                        _httpBindingClassName,
                        HttpMessageExtensions.ToMessageMethodName,
                        _httpResponseMessageClassName);
                }

                return response;
            }

            private class ByteArrayBufferManagerContent : ByteArrayContent
            {
                private BufferManager _bufferManager;
                private byte[] _content;

                public ByteArrayBufferManagerContent(BufferManager bufferManager, byte[] content, int offset, int count)
                    : base(content, offset, count)
                {
                    Contract.Assert(bufferManager != null, "The 'bufferManager' parameter should never be null.");

                    _bufferManager = bufferManager;
                    _content = content;
                }

                protected override void Dispose(bool disposing)
                {
                    try
                    {
                        if (disposing)
                        {
                            BufferManager oldBufferManager = Interlocked.Exchange(ref _bufferManager, null);
                            if (oldBufferManager != null)
                            {
                                oldBufferManager.ReturnBuffer(_content);
                                _content = null;
                            }
                        }
                    }
                    finally
                    {
                        base.Dispose(disposing);
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpMessageEncodingBindingElement.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.Properties;

namespace System.Web.Http.SelfHost.Channels
{
    /// <summary>
    /// Provides an <see cref="HttpMessageEncoderFactory"/> that returns a <see cref="MessageEncoder"/> 
    /// that is able to produce and consume <see cref="HttpMessage"/> instances.
    /// </summary>
    internal sealed class HttpMessageEncodingBindingElement : MessageEncodingBindingElement
    {
        private static readonly Type _replyChannelType = typeof(IReplyChannel);

        /// <summary>
        /// Gets or sets the message version that can be handled by the message encoders produced by the message encoder factory.
        /// </summary>
        /// <returns>The <see cref="MessageVersion"/> used by the encoders produced by the message encoder factory.</returns>
        public override MessageVersion MessageVersion
        {
            get { return MessageVersion.None; }

            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }

                if (value != MessageVersion.None)
                {
                    throw Error.NotSupported(SRResources.OnlyMessageVersionNoneSupportedOnHttpMessageEncodingBindingElement, typeof(HttpMessageEncodingBindingElement).Name);
                }
            }
        }

        /// <summary>
        /// Returns a value that indicates whether the binding element can build a listener for a specific type of channel.
        /// </summary>
        /// <typeparam name="TChannel">The type of channel the listener accepts.</typeparam>
        /// <param name="context">The <see cref="BindingContext"/> that provides context for the binding element</param>
        /// <returns>true if the <see cref="IChannelListener{TChannel}"/> of type <see cref="IChannel"/> can be built by the binding element; otherwise, false.</returns>
        public override bool CanBuildChannelFactory<TChannel>(BindingContext context)
        {
            return false;
        }

        /// <summary>
        /// Returns a value that indicates whether the binding element can build a channel factory for a specific type of channel.
        /// </summary>
        /// <typeparam name="TChannel">The type of channel the channel factory produces.</typeparam>
        /// <param name="context">The <see cref="BindingContext"/> that provides context for the binding element</param>
        /// <returns>ALways false.</returns>
        public override IChannelFactory<TChannel> BuildChannelFactory<TChannel>(BindingContext context)
        {
            throw Error.NotSupported(SRResources.ChannelFactoryNotSupported, typeof(HttpMessageEncodingBindingElement).Name, typeof(IChannelFactory).Name);
        }

        /// <summary>
        /// Returns a value that indicates whether the binding element can build a channel factory for a specific type of channel.
        /// </summary>
        /// <typeparam name="TChannel">The type of channel the channel factory produces.</typeparam>
        /// <param name="context">The <see cref="BindingContext"/> that provides context for the binding element</param>
        /// <returns>ALways false.</returns>
        public override bool CanBuildChannelListener<TChannel>(BindingContext context)
        {
            if (context == null)
            {
                throw Error.ArgumentNull("context");
            }

            context.BindingParameters.Add(this);

            return IsChannelShapeSupported<TChannel>() && context.CanBuildInnerChannelListener<TChannel>();
        }

        /// <summary>
        /// Initializes a channel listener to accept channels of a specified type from the binding context.
        /// </summary>
        /// <typeparam name="TChannel">The type of channel the listener is built to accept.</typeparam>
        /// <param name="context">The <see cref="BindingContext"/> that provides context for the binding element</param>
        /// <returns>The <see cref="IChannelListener{TChannel}"/> of type <see cref="IChannel"/> initialized from the context.</returns>
        public override IChannelListener<TChannel> BuildChannelListener<TChannel>(BindingContext context)
        {
            if (context == null)
            {
                throw Error.ArgumentNull("context");
            }

            if (!IsChannelShapeSupported<TChannel>())
            {
                throw Error.NotSupported(SRResources.ChannelShapeNotSupported, typeof(HttpMessageEncodingBindingElement).Name, typeof(IReplyChannel).Name);
            }

            context.BindingParameters.Add(this);

            IChannelListener<IReplyChannel> innerListener = context.BuildInnerChannelListener<IReplyChannel>();

            if (innerListener == null)
            {
                return null;
            }

            return (IChannelListener<TChannel>)new HttpMessageEncodingChannelListener(context.Binding, innerListener);
        }

        /// <summary>
        /// Returns a copy of the binding element object.
        /// </summary>
        /// <returns>A <see cref="BindingElement"/> object that is a deep clone of the original.</returns>
        public override BindingElement Clone()
        {
            return new HttpMessageEncodingBindingElement();
        }

        /// <summary>
        /// Creates a factory for producing message encoders that are able to 
        /// produce and consume <see cref="HttpMessage"/> instances.
        /// </summary>
        /// <returns>
        /// The <see cref="MessageEncoderFactory"/> used to produce message encoders that are able to 
        /// produce and consume <see cref="HttpMessage"/> instances.
        /// </returns>
        public override MessageEncoderFactory CreateMessageEncoderFactory()
        {
            return new HttpMessageEncoderFactory();
        }

        private static bool IsChannelShapeSupported<TChannel>()
        {
            return typeof(TChannel) == _replyChannelType;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpMessageEncodingChannelListener.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.Channels
{
    internal class HttpMessageEncodingChannelListener : LayeredChannelListener<IReplyChannel>
    {
        private IChannelListener<IReplyChannel> _innerChannelListener;

        public HttpMessageEncodingChannelListener(Binding binding, IChannelListener<IReplyChannel> innerListener) :
            base(binding, innerListener)
        {
        }

        protected override void OnOpening()
        {
            _innerChannelListener = (IChannelListener<IReplyChannel>)InnerChannelListener;
            base.OnOpening();
        }

        protected override IReplyChannel OnAcceptChannel(TimeSpan timeout)
        {
            IReplyChannel innerChannel = _innerChannelListener.AcceptChannel(timeout);
            return WrapInnerChannel(innerChannel);
        }

        protected override IAsyncResult OnBeginAcceptChannel(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return _innerChannelListener.BeginAcceptChannel(timeout, callback, state);
        }

        protected override IReplyChannel OnEndAcceptChannel(IAsyncResult result)
        {
            IReplyChannel innerChannel = _innerChannelListener.EndAcceptChannel(result);
            return WrapInnerChannel(innerChannel);
        }

        protected override IAsyncResult OnBeginWaitForChannel(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return _innerChannelListener.BeginWaitForChannel(timeout, callback, state);
        }

        protected override bool OnEndWaitForChannel(IAsyncResult result)
        {
            return _innerChannelListener.EndWaitForChannel(result);
        }

        protected override bool OnWaitForChannel(TimeSpan timeout)
        {
            return _innerChannelListener.WaitForChannel(timeout);
        }

        private IReplyChannel WrapInnerChannel(IReplyChannel innerChannel)
        {
            return (innerChannel != null)
                       ? new HttpMessageEncodingReplyChannel(this, innerChannel)
                       : (IReplyChannel)null;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpMessageEncodingReplyChannel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.Channels
{
    internal class HttpMessageEncodingReplyChannel : LayeredChannel<IReplyChannel>, IReplyChannel, IChannel, ICommunicationObject
    {
        public HttpMessageEncodingReplyChannel(ChannelManagerBase channelManager, IReplyChannel innerChannel)
            : base(channelManager, innerChannel)
        {
        }

        public EndpointAddress LocalAddress
        {
            get { return InnerChannel.LocalAddress; }
        }

        public IAsyncResult BeginReceiveRequest(AsyncCallback callback, object state)
        {
            return InnerChannel.BeginReceiveRequest(callback, state);
        }

        public IAsyncResult BeginReceiveRequest(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return InnerChannel.BeginReceiveRequest(timeout, callback, state);
        }

        public IAsyncResult BeginTryReceiveRequest(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return InnerChannel.BeginTryReceiveRequest(timeout, callback, state);
        }

        public IAsyncResult BeginWaitForRequest(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return InnerChannel.BeginWaitForRequest(timeout, callback, state);
        }

        public RequestContext EndReceiveRequest(IAsyncResult result)
        {
            RequestContext innerContext = InnerChannel.EndReceiveRequest(result);
            return WrapRequestContext(innerContext);
        }

        public bool EndTryReceiveRequest(IAsyncResult result, out RequestContext context)
        {
            RequestContext innerContext;
            context = null;
            if (!InnerChannel.EndTryReceiveRequest(result, out innerContext))
            {
                return false;
            }

            context = WrapRequestContext(innerContext);
            return true;
        }

        public bool EndWaitForRequest(IAsyncResult result)
        {
            return InnerChannel.EndWaitForRequest(result);
        }

        public RequestContext ReceiveRequest()
        {
            RequestContext innerContext = InnerChannel.ReceiveRequest();
            return WrapRequestContext(innerContext);
        }

        public RequestContext ReceiveRequest(TimeSpan timeout)
        {
            RequestContext innerContext = InnerChannel.ReceiveRequest(timeout);
            return WrapRequestContext(innerContext);
        }

        public bool TryReceiveRequest(TimeSpan timeout, out RequestContext context)
        {
            RequestContext innerContext;
            if (InnerChannel.TryReceiveRequest(timeout, out innerContext))
            {
                context = WrapRequestContext(innerContext);
                return true;
            }

            context = null;
            return false;
        }

        public bool WaitForRequest(TimeSpan timeout)
        {
            return InnerChannel.WaitForRequest(timeout);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "disposed later.")]
        private static RequestContext WrapRequestContext(RequestContext innerContext)
        {
            return (innerContext != null)
                       ? new HttpMessageEncodingRequestContext(innerContext)
                       : (RequestContext)null;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpMessageEncodingRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.Properties;

namespace System.Web.Http.SelfHost.Channels
{
    internal class HttpMessageEncodingRequestContext : RequestContext
    {
        private const string HttpMessageEncodingRequestContextPropertyName = "MS_HttpMessageEncodingRequestContextKey";
        private const string DefaultReasonPhrase = "OK";

        private RequestContext _innerContext;
        private Message _configuredRequestMessage;

        public HttpMessageEncodingRequestContext(RequestContext innerContext)
        {
            Contract.Assert(innerContext != null, "The 'innerContext' parameter should not be null.");
            _innerContext = innerContext;
        }

        internal Exception Exception { get; set; }
        internal BufferManager BufferManager { get; set; }
        internal byte[] BufferToReturn { get; set; }

        public override Message RequestMessage
        {
            get
            {
                if (_configuredRequestMessage == null)
                {
                    _configuredRequestMessage = ConfigureRequestMessage(_innerContext.RequestMessage);
                }

                return _configuredRequestMessage;
            }
        }

        public override void Abort()
        {
            Cleanup();
            _innerContext.Abort();
        }

        public override IAsyncResult BeginReply(Message message, TimeSpan timeout, AsyncCallback callback, object state)
        {
            ConfigureResponseMessage(message);
            return _innerContext.BeginReply(message, timeout, callback, state);
        }

        public override IAsyncResult BeginReply(Message message, AsyncCallback callback, object state)
        {
            ConfigureResponseMessage(message);
            return _innerContext.BeginReply(message, callback, state);
        }

        public override void Close(TimeSpan timeout)
        {
            Cleanup();
            _innerContext.Close(timeout);
        }

        public override void Close()
        {
            Cleanup();
            _innerContext.Close();
        }

        public override void EndReply(IAsyncResult result)
        {
            try
            {
                _innerContext.EndReply(result);
            }
            catch (Exception ex)
            {
                Exception = ex;
                throw;
            }
        }

        public override void Reply(Message message, TimeSpan timeout)
        {
            ConfigureResponseMessage(message);
            _innerContext.Reply(message, timeout);
        }

        public override void Reply(Message message)
        {
            ConfigureResponseMessage(message);
            _innerContext.Reply(message);
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                // To avoid double buffering, we use the BufferedOutputStream's own buffer
                // that it created through the BufferManager passed to WriteStream.
                // We are responsible for returning that buffer to the BufferManager
                // because we used BufferedOutputStream.ToArray to take ownership
                // of its buffers.
                if (BufferManager != null && BufferToReturn != null)
                {
                    BufferManager.ReturnBuffer(BufferToReturn);
                    BufferToReturn = null;
                }
            }

            base.Dispose(disposing);
        }

        internal static HttpMessageEncodingRequestContext GetContextFromMessage(Message message)
        {
            HttpMessageEncodingRequestContext context = null;
            message.Properties.TryGetValue<HttpMessageEncodingRequestContext>(HttpMessageEncodingRequestContextPropertyName, out context);
            return context;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Cleanup exceptions are ignored as they are not fatal to the host.")]
        private void Cleanup()
        {
            if (_configuredRequestMessage != null)
            {
                try
                {
                    _configuredRequestMessage.Close();
                }
                catch
                {
                }
            }
        }

        private static void CopyHeadersToNameValueCollection(HttpHeaders headers, NameValueCollection nameValueCollection)
        {
            foreach (KeyValuePair<string, IEnumerable<string>> header in headers)
            {
                foreach (string value in header.Value)
                {
                    nameValueCollection.Add(header.Key, value);
                }
            }
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "disposed later.")]
        private static Message ConfigureRequestMessage(Message message)
        {
            if (message == null)
            {
                return null;
            }

            HttpRequestMessageProperty requestProperty;
            if (!message.Properties.TryGetValue(HttpRequestMessageProperty.Name, out requestProperty))
            {
                throw Error.InvalidOperation(
                    SRResources.RequestMissingHttpRequestMessageProperty,
                    HttpRequestMessageProperty.Name,
                    typeof(HttpRequestMessageProperty).Name);
            }

            Uri uri = message.Headers.To;
            if (uri == null)
            {
                throw Error.InvalidOperation(SRResources.RequestMissingToHeader);
            }

            HttpRequestMessage httpRequestMessage = message.ToHttpRequestMessage();
            if (httpRequestMessage == null)
            {
                if (!message.IsEmpty)
                {
                    throw Error.InvalidOperation(SRResources.NonHttpMessageMustBeEmpty, HttpMessageExtensions.ToHttpRequestMessageMethodName, typeof(HttpMessage).Name);
                }

                httpRequestMessage = new HttpRequestMessage();
                Message oldMessage = message;
                message = httpRequestMessage.ToMessage();
                message.Properties.CopyProperties(oldMessage.Properties);
                oldMessage.Close();
            }
            else
            {
                // Clear headers but not properties.
                message.Headers.Clear();
            }

            // Copy message properties to HttpRequestMessage. While it does have the
            // risk of allowing properties to get out of sync they in virtually all cases are
            // read-only so the risk is low. The downside to not doing it is that it isn't
            // possible to access anything from HttpRequestMessage (or OperationContent.Current)
            // which is worse.
            foreach (KeyValuePair<string, object> kv in message.Properties)
            {
                httpRequestMessage.Properties.Add(kv.Key, kv.Value);
            }

            if (httpRequestMessage.Content == null)
            {
                httpRequestMessage.Content = new ByteArrayContent(new byte[0]);
            }
            else
            {
                httpRequestMessage.Content.Headers.Clear();
            }

            message.Headers.To = uri;

            httpRequestMessage.RequestUri = uri;
            httpRequestMessage.Method = HttpMethodHelper.GetHttpMethod(requestProperty.Method);

            WebHeaderCollection headers = requestProperty.Headers;
            foreach (var headerName in headers.AllKeys)
            {
                string headerValue = headers[headerName];
                if (!httpRequestMessage.Headers.TryAddWithoutValidation(headerName, headerValue))
                {
                    httpRequestMessage.Content.Headers.TryAddWithoutValidation(headerName, headerValue);
                }
            }

            return message;
        }

        private void ConfigureResponseMessage(Message message)
        {
            Contract.Assert(message != null);

            HttpResponseMessageProperty responseProperty = new HttpResponseMessageProperty();
            HttpResponseMessage httpResponseMessage = message.ToHttpResponseMessage();

            if (httpResponseMessage == null)
            {
                responseProperty.StatusCode = HttpStatusCode.InternalServerError;
                responseProperty.SuppressEntityBody = true;
            }
            else
            {
                responseProperty.StatusCode = httpResponseMessage.StatusCode;
                if (httpResponseMessage.ReasonPhrase != null &&
                    httpResponseMessage.ReasonPhrase != DefaultReasonPhrase)
                {
                    responseProperty.StatusDescription = httpResponseMessage.ReasonPhrase;
                }

                CopyHeadersToNameValueCollection(httpResponseMessage.Headers, responseProperty.Headers);
                HttpContent content = httpResponseMessage.Content;
                if (content != null)
                {
                    CopyHeadersToNameValueCollection(httpResponseMessage.Content.Headers, responseProperty.Headers);
                }
                else
                {
                    responseProperty.SuppressEntityBody = true;
                }
            }

            message.Properties.Clear();
            message.Headers.Clear();

            message.Properties.Add(HttpResponseMessageProperty.Name, responseProperty);

            // The current request context flows with the Message for later use
            // by HttpMessageEncoder.WriteMessage
            message.Properties.Add(HttpMessageEncodingRequestContextPropertyName, this);
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Channels/HttpMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.Channels
{
    /// <summary>
    /// Provides extension methods for getting an <see cref="HttpRequestMessage"/> instance or
    /// an <see cref="HttpResponseMessage"/> instance from a <see cref="Message"/> instance and
    /// provides extension methods for creating a <see cref="Message"/> instance from either an 
    /// <see cref="HttpRequestMessage"/> instance or an 
    /// <see cref="HttpResponseMessage"/> instance.
    /// </summary>
    internal static class HttpMessageExtensions
    {
        internal const string ToHttpRequestMessageMethodName = "ToHttpRequestMessage";
        internal const string ToHttpResponseMessageMethodName = "ToHttpResponseMessage";
        internal const string ToMessageMethodName = "ToMessage";

        /// <summary>
        /// Returns a reference to the <see cref="HttpRequestMessage"/> 
        /// instance held by the given <see cref="Message"/> or null if the <see cref="Message"/> does not
        /// hold a reference to an <see cref="HttpRequestMessage"/> 
        /// instance.
        /// </summary>
        /// <param name="message">The given <see cref="Message"/> that holds a reference to an 
        /// <see cref="HttpRequestMessage"/> instance.
        /// </param>
        /// <returns>
        /// A reference to the <see cref="HttpRequestMessage"/> 
        /// instance held by the given <see cref="Message"/> or null if the <see cref="Message"/> does not
        /// hold a reference to an <see cref="HttpRequestMessage"/> 
        /// instance.
        /// </returns>
        public static HttpRequestMessage ToHttpRequestMessage(this Message message)
        {
            if (message == null)
            {
                throw Error.ArgumentNull("message");
            }

            HttpMessage httpMessage = message as HttpMessage;
            if (httpMessage != null && httpMessage.IsRequest)
            {
                return httpMessage.GetHttpRequestMessage(false);
            }

            return null;
        }

        /// <summary>
        /// Returns a reference to the <see cref="HttpResponseMessage"/> 
        /// instance held by the given <see cref="Message"/> or null if the <see cref="Message"/> does not
        /// hold a reference to an <see cref="HttpResponseMessage"/> 
        /// instance.
        /// </summary>
        /// <param name="message">The given <see cref="Message"/> that holds a reference to an 
        /// <see cref="HttpResponseMessage"/> instance.
        /// </param>
        /// <returns>
        /// A reference to the <see cref="HttpResponseMessage"/> 
        /// instance held by the given <see cref="Message"/> or null if the <see cref="Message"/> does not
        /// hold a reference to an <see cref="HttpResponseMessage"/> 
        /// instance.
        /// </returns>
        public static HttpResponseMessage ToHttpResponseMessage(this Message message)
        {
            if (message == null)
            {
                throw Error.ArgumentNull("message");
            }

            HttpMessage httpMessage = message as HttpMessage;
            if (httpMessage != null && !httpMessage.IsRequest)
            {
                return httpMessage.GetHttpResponseMessage(false);
            }

            return null;
        }

        /// <summary>
        /// Returns a reference to the <see cref="HttpResponseMessage"/> 
        /// instance held by the given <see cref="Message"/> or null if the <see cref="Message"/> does not
        /// hold a reference to an <see cref="HttpResponseMessage"/> 
        /// instance.
        /// </summary>
        /// <remarks>The caller takes over the ownership of the associated <see cref="HttpRequestMessage"/> and is responsible for its disposal.</remarks>
        /// <param name="message">The given <see cref="Message"/> that holds a reference to an 
        /// <see cref="HttpResponseMessage"/> instance.
        /// </param>
        /// <returns>
        /// A reference to the <see cref="HttpResponseMessage"/> 
        /// instance held by the given <see cref="Message"/> or null if the <see cref="Message"/> does not
        /// hold a reference to an <see cref="HttpResponseMessage"/> 
        /// instance.
        /// The caller is responsible for disposing any <see cref="HttpResponseMessage"/> instance returned.
        /// </returns>
        public static HttpResponseMessage ExtractHttpResponseMessage(this Message message)
        {
            if (message == null)
            {
                throw Error.ArgumentNull("message");
            }

            HttpMessage httpMessage = message as HttpMessage;
            if (httpMessage != null && !httpMessage.IsRequest)
            {
                return httpMessage.GetHttpResponseMessage(true);
            }

            return null;
        }

        /// <summary>
        /// Creates a new <see cref="Message"/> that holds a reference to the given 
        /// <see cref="HttpRequestMessage"/> instance.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/> 
        /// instance to which the new <see cref="Message"/> should hold a reference.
        /// </param>
        /// <returns>A <see cref="Message"/> that holds a reference to the given
        /// <see cref="HttpRequestMessage"/> instance.
        /// </returns>
        public static Message ToMessage(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return new HttpMessage(request);
        }

        /// <summary>
        /// Creates a new <see cref="Message"/> that holds a reference to the given
        /// <see cref="HttpResponseMessage"/> instance.
        /// </summary>
        /// <param name="response">The <see cref="HttpResponseMessage"/> 
        /// instance to which the new <see cref="Message"/> should hold a reference.
        /// </param>
        /// <returns>A <see cref="Message"/> that holds a reference to the given
        /// <see cref="HttpResponseMessage"/> instance.
        /// </returns>
        public static Message ToMessage(this HttpResponseMessage response)
        {
            if (response == null)
            {
                throw Error.ArgumentNull("response");
            }

            return new HttpMessage(response);
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "These assemblies are delay-signed.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Justification = "Classes are grouped logically for user clarity.", Scope = "Namespace", Target = "System.Net.Http")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Justification = "Classes are grouped logically for user clarity.", Scope = "Namespace", Target = "System.Web.Http.SelfHost")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Justification = "Classes are grouped logically for user clarity.", Scope = "Namespace", Target = "System.Web.Http.SelfHost.Activation")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Justification = "Classes are grouped logically for user clarity.", Scope = "Namespace", Target = "System.Web.Http.SelfHost.Channels")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1701:ResourceStringCompoundWordsShouldBeCasedCorrectly", MessageId = "URIs", Scope = "resource", Target = "System.Web.Http.SelfHost.Properties.SRResources.resources", Justification = "FxCop does not seem to allow adding an exception to this term in its dictionary.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "URIs", Scope = "resource", Target = "System.Web.Http.SelfHost.Properties.SRResources.resources", Justification = "FxCop does not seem to allow adding an exception to this term in its dictionary.")]


================================================
FILE: src/System.Web.Http.SelfHost/HttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ServiceModel.Security;
using System.Web.Http;
using System.Web.Http.SelfHost;

namespace System.Net.Http
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpRequestMessageExtensions
    {
        /// <summary>
        /// Gets the current <see cref="T:System.ServiceModel.Security.SecurityMessageProperty"/> 
        /// stored in <see cref="M:HttpRequestMessage.Properties"/> for the given request.
        /// </summary>
        /// <param name="request">The HTTP request.</param>
        /// <returns>The <see cref="SecurityMessageProperty"/>.</returns>
        public static SecurityMessageProperty GetSecurityMessageProperty(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            return request.GetProperty<SecurityMessageProperty>(HttpSelfHostServer.SecurityKey);
        }

        private static T GetProperty<T>(this HttpRequestMessage request, string key)
        {
            T value;
            request.Properties.TryGetValue(key, out value);
            return value;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/HttpSelfHostConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IdentityModel.Selectors;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.ServiceModel.Security;
using System.Web.Http.SelfHost.Channels;
using System.Web.Http.SelfHost.Properties;
using System.Web.Http.SelfHost.ServiceModel;
using System.Web.Http.SelfHost.ServiceModel.Channels;

namespace System.Web.Http.SelfHost
{
    /// <summary>
    /// The configuration class for Http Services
    /// </summary>
    public class HttpSelfHostConfiguration : HttpConfiguration
    {
        private const int DefaultMaxConcurrentRequests = 100;
        private const int DefaultMaxBufferSize = 64 * 1024;
        private const int DefaultReceivedMessageSize = 64 * 1024;

        private const int MinConcurrentRequests = 1;
        private const int MinBufferSize = 1;
        private const int MinReceivedMessageSize = 1;

        private static readonly TimeSpan DefaultReceiveTimeout = new TimeSpan(0, 10, 0);
        private static readonly TimeSpan DefaultSendTimeout = new TimeSpan(0, 1, 0);

        private Uri _baseAddress;
        private int _maxConcurrentRequests;
        private ServiceCredentials _credentials = new ServiceCredentials();
        private HttpClientCredentialType _clientCredentialType = HttpClientCredentialType.None;
        private TransferMode _transferMode;
        private int _maxBufferSize = DefaultMaxBufferSize;
        private bool _maxBufferSizeIsInitialized;
        private long _maxReceivedMessageSize = DefaultReceivedMessageSize;
        private TimeSpan _receiveTimeout = DefaultReceiveTimeout;
        private TimeSpan _sendTimeout = DefaultSendTimeout;
        private HostNameComparisonMode _hostNameComparisonMode;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpSelfHostConfiguration"/> class.
        /// </summary>
        /// <param name="baseAddress">The base address.</param>
        public HttpSelfHostConfiguration(string baseAddress)
            : this(CreateBaseAddress(baseAddress))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpSelfHostConfiguration"/> class.
        /// </summary>
        /// <param name="baseAddress">The base address.</param>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "caller owns object")]
        public HttpSelfHostConfiguration(Uri baseAddress)
            : base(new HttpRouteCollection(ValidateBaseAddress(baseAddress).AbsolutePath))
        {
            _baseAddress = ValidateBaseAddress(baseAddress);
            _maxConcurrentRequests = MultiplyByProcessorCount(DefaultMaxConcurrentRequests);
            _maxBufferSize = TransportDefaults.MaxBufferSize;
            _maxReceivedMessageSize = TransportDefaults.MaxReceivedMessageSize;
        }

        /// <summary>
        /// Gets the base address.
        /// </summary>
        /// <value>
        /// The base address.
        /// </value>
        public Uri BaseAddress
        {
            get { return _baseAddress; }
        }

        /// <summary>
        /// Gets or sets the upper limit of how many concurrent <see cref="T:System.Net.Http.HttpRequestMessage"/> instances 
        /// can be processed at any given time. The default is 100 times the number of CPU cores.
        /// </summary>
        /// <value>
        /// The maximum concurrent <see cref="T:System.Net.Http.HttpRequestMessage"/> instances processed at any given time.
        /// </value>
        public int MaxConcurrentRequests
        {
            get { return _maxConcurrentRequests; }

            set
            {
                if (value < MinConcurrentRequests)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinConcurrentRequests);
                }
                _maxConcurrentRequests = value;
            }
        }

        /// <summary>
        /// Gets or sets the transfer mode.
        /// </summary>
        /// <value>
        /// The transfer mode.
        /// </value>
        public TransferMode TransferMode
        {
            get { return _transferMode; }

            set
            {
                TransferModeHelper.Validate(value, "value");
                _transferMode = value;
            }
        }

        /// <summary>
        /// Specifies how the host name should be used in URI comparisons when dispatching an incoming message.
        /// </summary>
        public HostNameComparisonMode HostNameComparisonMode
        {
            get { return _hostNameComparisonMode; }

            set
            {
                HostNameComparisonModeHelper.Validate(value, "value");
                _hostNameComparisonMode = value;
            }
        }

        /// <summary>
        /// Gets or sets the size of the max buffer.
        /// </summary>
        /// <value>
        /// The size of the max buffer.
        /// </value>
        public int MaxBufferSize
        {
            get
            {
                if (_maxBufferSizeIsInitialized || TransferMode != TransferMode.Buffered)
                {
                    return _maxBufferSize;
                }

                long maxReceivedMessageSize = MaxReceivedMessageSize;
                if (maxReceivedMessageSize > Int32.MaxValue)
                {
                    return Int32.MaxValue;
                }
                return (int)maxReceivedMessageSize;
            }

            set
            {
                if (value < MinBufferSize)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinBufferSize);
                }
                _maxBufferSizeIsInitialized = true;
                _maxBufferSize = value;
            }
        }

        /// <summary>
        /// Gets or sets the size of the max received message.
        /// </summary>
        /// <value>
        /// The size of the max received message.
        /// </value>
        public long MaxReceivedMessageSize
        {
            get { return _maxReceivedMessageSize; }

            set
            {
                if (value < MinReceivedMessageSize)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, MinReceivedMessageSize);
                }
                _maxReceivedMessageSize = value;
            }
        }

        /// <summary>
        /// Gets or sets the interval of time that a connection can remain inactive, during which no application messages are received, before it is dropped.
        /// </summary>
        /// <value>
        /// The interval of time that a connection can remain inactive, during which no application messages are received, before it is dropped.
        /// </value>
        public TimeSpan ReceiveTimeout
        {
            get { return _receiveTimeout; }

            set
            {
                if (value < TimeSpan.Zero)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, TimeSpan.Zero);
                }

                _receiveTimeout = value;
            }
        }

        /// <summary>
        /// Gets or sets the interval of time provided for a write operation to complete before the transport raises an exception.
        /// </summary>
        /// <value>
        /// The interval of time provided for a write operation to complete before the transport raises an exception.
        /// </value>
        public TimeSpan SendTimeout
        {
            get { return _sendTimeout; }

            set
            {
                if (value < TimeSpan.Zero)
                {
                    throw Error.ArgumentMustBeGreaterThanOrEqualTo("value", value, TimeSpan.Zero);
                }

                _sendTimeout = value;
            }
        }

        /// <summary>
        /// Gets or sets UserNamePasswordValidator so that it can be used to validate the username and password
        /// sent over HTTP or HTTPS
        /// </summary>
        /// <value>
        /// The server certificate.
        /// </value>
        public UserNamePasswordValidator UserNamePasswordValidator
        {
            get { return _credentials.UserNameAuthentication.CustomUserNamePasswordValidator; }

            set 
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _clientCredentialType = HttpClientCredentialType.Basic;
                _credentials.UserNameAuthentication.CustomUserNamePasswordValidator = value;
                _credentials.UserNameAuthentication.UserNamePasswordValidationMode = UserNamePasswordValidationMode.Custom;
            }
        }

        /// <summary>
        /// Gets or sets X509CertificateValidator so that it can be used to validate the client certificate
        /// sent over HTTPS
        /// </summary>
        /// <value>
        /// The server certificate.
        /// </value>
        public X509CertificateValidator X509CertificateValidator
        {
            get { return _credentials.ClientCertificate.Authentication.CustomCertificateValidator; }

            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }

                _clientCredentialType = HttpClientCredentialType.Certificate;
                _credentials.ClientCertificate.Authentication.CustomCertificateValidator = value;
                _credentials.ClientCertificate.Authentication.CertificateValidationMode = X509CertificateValidationMode.Custom;
            }
        }

        /// <summary>
        /// Gets/Sets the ClientCredentialType that server is expecting. 
        /// </summary>
        /// <value>
        /// The default value is HttpClientCredentialType.None.
        /// </value>
        public HttpClientCredentialType ClientCredentialType
        {
            get { return _clientCredentialType; }
            set { _clientCredentialType = value; }
        }

        /// <summary>
        /// Internal method called to configure <see cref="HttpBinding"/> settings.
        /// </summary>
        /// <param name="httpBinding">Http binding.</param>
        /// <returns>The <see cref="BindingParameterCollection"/> to use when building the <see cref="IChannelListener"/> or null if no binding parameters are present.</returns>
        internal BindingParameterCollection ConfigureBinding(HttpBinding httpBinding)
        {
            return OnConfigureBinding(httpBinding);
        }

        /// <summary>
        /// Called to apply the configuration on the endpoint level.
        /// </summary>
        /// <param name="httpBinding">Http endpoint.</param>
        /// <returns>The <see cref="BindingParameterCollection"/> to use when building the <see cref="IChannelListener"/> or null if no binding parameters are present.</returns>
        protected virtual BindingParameterCollection OnConfigureBinding(HttpBinding httpBinding)
        {
            if (httpBinding == null)
            {
                throw Error.ArgumentNull("httpBinding");
            }

            if (_clientCredentialType != HttpClientCredentialType.Basic && _credentials.UserNameAuthentication.CustomUserNamePasswordValidator != null)
            {
                throw Error.InvalidOperation(SRResources.CannotUseOtherClientCredentialTypeWithUserNamePasswordValidator);
            }

            if (_clientCredentialType != HttpClientCredentialType.Certificate && _credentials.ClientCertificate.Authentication.CustomCertificateValidator != null)
            {
                throw Error.InvalidOperation(SRResources.CannotUseOtherClientCredentialTypeWithX509CertificateValidator);
            }

            httpBinding.MaxBufferSize = MaxBufferSize;
            httpBinding.MaxReceivedMessageSize = MaxReceivedMessageSize;
            httpBinding.TransferMode = TransferMode;
            httpBinding.HostNameComparisonMode = HostNameComparisonMode;
            httpBinding.ReceiveTimeout = ReceiveTimeout;
            httpBinding.SendTimeout = SendTimeout;

            // Set up binding parameters
            if (_baseAddress.Scheme == Uri.UriSchemeHttps)
            {
                // we need to use SSL
                httpBinding.Security = new HttpBindingSecurity()
                {
                    Mode = HttpBindingSecurityMode.Transport,
                };
            }
            
            if (_clientCredentialType != HttpClientCredentialType.None)
            {       
                if (httpBinding.Security == null || httpBinding.Security.Mode == HttpBindingSecurityMode.None)
                {
                    // Basic over HTTP case
                    httpBinding.Security = new HttpBindingSecurity()
                    {
                        Mode = HttpBindingSecurityMode.TransportCredentialOnly,
                    };
                }

                httpBinding.Security.Transport.ClientCredentialType = _clientCredentialType;                
            }

            if (UserNamePasswordValidator != null || X509CertificateValidator != null)
            {
                // those are the only two things that affect service credentials
                return AddCredentialsToBindingParameters();
            }
            else
            {
                return null;
            }
        }

        private BindingParameterCollection AddCredentialsToBindingParameters()
        {
            BindingParameterCollection bindingParameters = new BindingParameterCollection();
            bindingParameters.Add(_credentials);
            return bindingParameters;
        }

        private static Uri CreateBaseAddress(string baseAddress)
        {
            if (baseAddress == null)
            {
                throw Error.ArgumentNull("baseAddress");
            }

            return new Uri(baseAddress, UriKind.RelativeOrAbsolute);
        }

        private static Uri ValidateBaseAddress(Uri baseAddress)
        {
            if (baseAddress == null)
            {
                throw Error.ArgumentNull("baseAddress");
            }

            if (!baseAddress.IsAbsoluteUri)
            {
                throw Error.ArgumentUriNotAbsolute("baseAddress", baseAddress);
            }

            if (!String.IsNullOrEmpty(baseAddress.Query) || !String.IsNullOrEmpty(baseAddress.Fragment))
            {
                throw Error.ArgumentUriHasQueryOrFragment("baseAddress", baseAddress);
            }

            if (!ReferenceEquals(baseAddress.Scheme, Uri.UriSchemeHttp) && !ReferenceEquals(baseAddress.Scheme, Uri.UriSchemeHttps))
            {
                throw Error.ArgumentUriNotHttpOrHttpsScheme("baseAddress", baseAddress);
            }

            return baseAddress;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        internal static int MultiplyByProcessorCount(int value)
        {
            Contract.Assert(value > 0);
            try
            {
                return Math.Max(Environment.ProcessorCount * value, value);
            }
            catch
            {
                return value;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/HttpSelfHostServer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IdentityModel.Claims;
using System.Net;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Security;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using System.Web.Http.SelfHost.Channels;
using System.Web.Http.SelfHost.Properties;
using System.Web.Http.SelfHost.ServiceModel.Channels;

namespace System.Web.Http.SelfHost
{
    /// <summary>
    /// Implementation of an <see cref="HttpServer"/> which listens directly to HTTP.
    /// </summary>
    public sealed class HttpSelfHostServer : HttpServer
    {
        internal const string SecurityKey = "Security";

        private static readonly AsyncCallback _onCloseListenerComplete = new AsyncCallback(OnCloseListenerComplete);
        private static readonly AsyncCallback _onCloseChannelComplete = new AsyncCallback(OnCloseChannelComplete);

        private static readonly TimeSpan _acceptTimeout = TimeSpan.MaxValue;
        private static readonly TimeSpan _receiveTimeout = TimeSpan.MaxValue;

        private static readonly Func<HttpRequestMessage, X509Certificate2> _retrieveClientCertificate = new Func<HttpRequestMessage, X509Certificate2>(RetrieveClientCertificate);

        // Window size gets increased if the ratio of outstanding requests to the window size is greater than IncreaseWindowSizeRatio
        // Window size gets decreased if the ratio of outstanding requests to the window size is less than DecreaseWindowsSizeRatio
        private const double IncreaseWindowSizeRatio = .8;
        private const double DecreaseWindowSizeRatio = .2;
        private const int InitialWindowSizeMultiplier = 8;
        private const int MinimumWindowSizeMultiplier = 1;
        private static readonly int InitialWindowSize = HttpSelfHostConfiguration.MultiplyByProcessorCount(InitialWindowSizeMultiplier);
        private static readonly int MinimumWindowSize = HttpSelfHostConfiguration.MultiplyByProcessorCount(MinimumWindowSizeMultiplier);

        private AsyncCallback _onOpenListenerComplete;
        private AsyncCallback _onAcceptChannelComplete;
        private AsyncCallback _onOpenChannelComplete;
        private AsyncCallback _onReceiveRequestContextComplete;
        private AsyncCallback _onReplyComplete;

        private ConcurrentBag<IReplyChannel> _channels = new ConcurrentBag<IReplyChannel>();
        private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();

        private bool _disposed;
        private HttpSelfHostConfiguration _configuration;
        private IChannelListener<IReplyChannel> _listener;
        private TaskCompletionSource<bool> _openTaskCompletionSource;
        private TaskCompletionSource<bool> _closeTaskCompletionSource;

        // State: 0 = new, 1 = open, 2 = closed
        private int _state;

        private int _requestsOutstanding;
        private int _windowSize;
        private readonly object _windowSizeLock = new object();

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpSelfHostServer"/> class.
        /// </summary>
        /// <param name="configuration">The configuration.</param>
        public HttpSelfHostServer(HttpSelfHostConfiguration configuration)
            : base(configuration)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            _configuration = configuration;
            InitializeCallbacks();
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpSelfHostServer"/> class.
        /// </summary>
        /// <param name="configuration">The configuration.</param>
        /// <param name="dispatcher">The dispatcher.</param>
        public HttpSelfHostServer(HttpSelfHostConfiguration configuration, HttpMessageHandler dispatcher)
            : base(configuration, dispatcher)
        {
            if (configuration == null)
            {
                throw Error.ArgumentNull("configuration");
            }

            _configuration = configuration;
            InitializeCallbacks();
        }

        /// <summary>
        /// Initialize async callbacks.
        /// </summary>
        private void InitializeCallbacks()
        {
            _onOpenListenerComplete = new AsyncCallback(OnOpenListenerComplete);
            _onAcceptChannelComplete = new AsyncCallback(OnAcceptChannelComplete);
            _onOpenChannelComplete = new AsyncCallback(OnOpenChannelComplete);
            _onReceiveRequestContextComplete = new AsyncCallback(OnReceiveRequestContextComplete);
            _onReplyComplete = new AsyncCallback(OnReplyComplete);
        }

        /// <summary>
        /// Opens the current <see cref="HttpServer"/> instance.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the asynchronous <see cref="HttpServer"/> open operation. Once this task completes successfully the server is running.</returns>
        public Task OpenAsync()
        {
            if (Interlocked.CompareExchange(ref _state, 1, 0) == 1)
            {
                throw Error.InvalidOperation(SRResources.HttpServerAlreadyRunning, typeof(HttpSelfHostServer).Name);
            }

            _openTaskCompletionSource = new TaskCompletionSource<bool>();
            BeginOpenListener(this);
            return _openTaskCompletionSource.Task;
        }

        /// <summary>
        /// Closes the current <see cref="HttpServer"/> instance.
        /// </summary>
        /// <returns>A <see cref="Task"/> representing the asynchronous <see cref="HttpServer"/> close operation.</returns>
        public Task CloseAsync()
        {
            if (Interlocked.CompareExchange(ref _state, 2, 1) != 1)
            {
                return TaskHelpers.Completed();
            }

            _closeTaskCompletionSource = new TaskCompletionSource<bool>();

            // Cancel requests currently being processed
            _cancellationTokenSource.Cancel();

            BeginCloseListener(this);
            return _closeTaskCompletionSource.Task;
        }

        /// <summary>
        /// Releases unmanaged and - optionally - managed resources
        /// </summary>
        /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged SRResources.</param>
        protected override void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                _disposed = true;
                if (_cancellationTokenSource != null)
                {
                    _cancellationTokenSource.Dispose();
                    _cancellationTokenSource = null;
                }
            }

            base.Dispose(disposing);
        }

        // async void is OK here. This is a fire and forget method and any exceptions that occur will be turned into
        // HTTP responses that get sent back to clients.
        private async void ProcessRequestContext(ChannelContext channelContext, RequestContext requestContext)
        {
            Contract.Assert(channelContext != null);
            Contract.Assert(requestContext != null);

            HttpResponseMessage response = await SendAsync(channelContext, requestContext);
            Message reply = response.ToMessage();
            BeginReply(new ReplyContext(channelContext, requestContext, reply));
        }

        private async Task<HttpResponseMessage> SendAsync(ChannelContext channelContext, RequestContext requestContext)
        {
            HttpRequestMessage request = null;
            try
            {
                request = CreateHttpRequestMessage(requestContext);
            }
            catch
            {
                return new HttpResponseMessage(HttpStatusCode.BadRequest);
            }

            // Submit request up the stack
            try
            {
                HttpResponseMessage response = await channelContext.Server.SendAsync(request, channelContext.Server._cancellationTokenSource.Token);

                if (response == null)
                {
                    response = request.CreateResponse(HttpStatusCode.InternalServerError);
                }

                return response;
            }
            catch (OperationCanceledException operationCanceledException)
            {
                return request.CreateErrorResponse(HttpStatusCode.ServiceUnavailable, SRResources.RequestCancelled, operationCanceledException);
            }
        }

        private HttpRequestMessage CreateHttpRequestMessage(RequestContext requestContext)
        {
            // Get the HTTP request from the WCF Message
            HttpRequestMessage request = requestContext.RequestMessage.ToHttpRequestMessage();
            if (request == null)
            {
                throw Error.InvalidOperation(SRResources.HttpMessageHandlerInvalidMessage, requestContext.RequestMessage.GetType());
            }

            // create principal information and add it the request for the windows auth case
            SetCurrentPrincipal(request);

            HttpRequestContext httpRequestContext = new SelfHostHttpRequestContext(requestContext, _configuration,
                request);
            request.SetRequestContext(httpRequestContext);

            // The following two properties are set for backwards compatibility only. The request context controls the
            // behavior for all cases except when accessing the property directly by key.

            // Add the retrieve client certificate delegate to the property bag to enable lookup later on
            request.Properties.Add(HttpPropertyKeys.RetrieveClientCertificateDelegateKey, _retrieveClientCertificate);

            // Add information about whether the request is local or not
            request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy<bool>(() => IsLocal(requestContext.RequestMessage)));
            return request;
        }

        internal static bool IsLocal(Message message)
        {
            RemoteEndpointMessageProperty remoteEndpointProperty;
            if (message.Properties.TryGetValue(RemoteEndpointMessageProperty.Name, out remoteEndpointProperty))
            {
                IPAddress remoteAddress;
                if (IPAddress.TryParse(remoteEndpointProperty.Address, out remoteAddress))
                {
                    return IPAddress.IsLoopback(remoteAddress);
                }
            }
            return false;
        }

        private static void SetCurrentPrincipal(HttpRequestMessage request)
        {
            SecurityMessageProperty property = request.GetSecurityMessageProperty();
            if (property != null)
            {
                ServiceSecurityContext context = property.ServiceSecurityContext;
                if (context != null && context.PrimaryIdentity != null)
                {
                    WindowsIdentity windowsIdentity = context.PrimaryIdentity as WindowsIdentity;

                    if (windowsIdentity != null)
                    {
                        Thread.CurrentPrincipal = new WindowsPrincipal(windowsIdentity);
                    }
                }
            }
        }

        internal static X509Certificate2 RetrieveClientCertificate(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            SecurityMessageProperty property = request.GetSecurityMessageProperty();
            X509Certificate2 result = null;

            if (property != null && property.ServiceSecurityContext != null && property.ServiceSecurityContext.AuthorizationContext != null)
            {
                X509CertificateClaimSet certClaimSet = null;
                foreach (ClaimSet claimSet in property.ServiceSecurityContext.AuthorizationContext.ClaimSets)
                {
                    certClaimSet = claimSet as X509CertificateClaimSet;

                    if (certClaimSet != null)
                    {
                        result = certClaimSet.X509Certificate;
                        break;
                    }
                }
            }

            return result;
        }

        private static void CancelTask(TaskCompletionSource<bool> taskCompletionSource)
        {
            Contract.Assert(taskCompletionSource != null);
            taskCompletionSource.TrySetCanceled();
        }

        private static void FaultTask(TaskCompletionSource<bool> taskCompletionSource, Exception exception)
        {
            Contract.Assert(taskCompletionSource != null);
            taskCompletionSource.TrySetException(exception);
        }

        private static void CompleteTask(TaskCompletionSource<bool> taskCompletionSource)
        {
            Contract.Assert(taskCompletionSource != null);
            taskCompletionSource.TrySetResult(true);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private void BeginOpenListener(HttpSelfHostServer server)
        {
            Contract.Assert(server != null);

            try
            {
                // Create WCF HTTP transport channel
                HttpBinding binding = new HttpBinding();

                // Get it configured
                BindingParameterCollection bindingParameters = server._configuration.ConfigureBinding(binding);
                if (bindingParameters == null)
                {
                    bindingParameters = new BindingParameterCollection();
                }

                // Build channel listener
                server._listener = binding.BuildChannelListener<IReplyChannel>(server._configuration.BaseAddress, bindingParameters);
                if (server._listener == null)
                {
                    throw Error.InvalidOperation(SRResources.InvalidChannelListener, typeof(IChannelListener).Name, typeof(IReplyChannel).Name);
                }

                IAsyncResult result = server._listener.BeginOpen(_onOpenListenerComplete, server);
                if (result.CompletedSynchronously)
                {
                    OpenListenerComplete(result);
                }
            }
            catch (Exception e)
            {
                FaultTask(server._openTaskCompletionSource, e);
            }
        }

        private void OnOpenListenerComplete(IAsyncResult result)
        {
            Contract.Assert(result != null);

            if (result.CompletedSynchronously)
            {
                return;
            }

            OpenListenerComplete(result);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private void OpenListenerComplete(IAsyncResult result)
        {
            HttpSelfHostServer server = (HttpSelfHostServer)result.AsyncState;
            Contract.Assert(server != null);
            Contract.Assert(server._listener != null);

            try
            {
                server._listener.EndOpen(result);

                // Start accepting channel
                BeginAcceptChannel(server);
            }
            catch (Exception e)
            {
                FaultTask(server._openTaskCompletionSource, e);
            }
        }

        private void BeginAcceptChannel(HttpSelfHostServer server)
        {
            Contract.Assert(server != null);
            Contract.Assert(server._listener != null);

            IAsyncResult result = BeginTryAcceptChannel(server, _onAcceptChannelComplete);
            if (result.CompletedSynchronously)
            {
                AcceptChannelComplete(result);
            }
        }

        private void OnAcceptChannelComplete(IAsyncResult result)
        {
            if (result.CompletedSynchronously)
            {
                return;
            }

            AcceptChannelComplete(result);
        }

        private void AcceptChannelComplete(IAsyncResult result)
        {
            Contract.Assert(result != null);

            HttpSelfHostServer server = (HttpSelfHostServer)result.AsyncState;
            Contract.Assert(server != null, "host cannot be null");
            Contract.Assert(server._listener != null, "host.listener cannot be null");

            IReplyChannel channel;
            if (EndTryAcceptChannel(result, out channel))
            {
                // If we didn't get a channel then we stop accepting new channels
                if (channel != null)
                {
                    server._channels.Add(channel);
                    BeginOpenChannel(new ChannelContext(server, channel));
                }
                else
                {
                    CancelTask(server._openTaskCompletionSource);
                }
            }
            else
            {
                // Start accepting next channel
                BeginAcceptChannel(server);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static IAsyncResult BeginTryAcceptChannel(HttpSelfHostServer server, AsyncCallback callback)
        {
            Contract.Assert(server != null);
            Contract.Assert(server._listener != null);
            Contract.Assert(callback != null);

            try
            {
                return server._listener.BeginAcceptChannel(_acceptTimeout, callback, server);
            }
            catch (CommunicationObjectAbortedException)
            {
                return new CompletedAsyncResult<bool>(true, callback, server);
            }
            catch (CommunicationObjectFaultedException)
            {
                return new CompletedAsyncResult<bool>(true, callback, server);
            }
            catch (TimeoutException)
            {
                return new CompletedAsyncResult<bool>(false, callback, server);
            }
            catch (CommunicationException)
            {
                return new CompletedAsyncResult<bool>(false, callback, server);
            }
            catch
            {
                return new CompletedAsyncResult<bool>(false, callback, server);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static bool EndTryAcceptChannel(IAsyncResult result, out IReplyChannel channel)
        {
            Contract.Assert(result != null);

            CompletedAsyncResult<bool> handlerResult = result as CompletedAsyncResult<bool>;
            if (handlerResult != null)
            {
                channel = null;
                return CompletedAsyncResult<bool>.End(handlerResult);
            }
            else
            {
                try
                {
                    HttpSelfHostServer server = (HttpSelfHostServer)result.AsyncState;
                    Contract.Assert(server != null);
                    Contract.Assert(server._listener != null);
                    channel = server._listener.EndAcceptChannel(result);
                    return true;
                }
                catch (CommunicationObjectAbortedException)
                {
                    channel = null;
                    return true;
                }
                catch (CommunicationObjectFaultedException)
                {
                    channel = null;
                    return true;
                }
                catch (TimeoutException)
                {
                    channel = null;
                    return false;
                }
                catch (CommunicationException)
                {
                    channel = null;
                    return false;
                }
                catch
                {
                    channel = null;
                    return false;
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private void BeginOpenChannel(ChannelContext channelContext)
        {
            Contract.Assert(channelContext != null);
            Contract.Assert(channelContext.Channel != null);

            try
            {
                IAsyncResult result = channelContext.Channel.BeginOpen(_onOpenChannelComplete, channelContext);
                if (result.CompletedSynchronously)
                {
                    OpenChannelComplete(result);
                }
            }
            catch (Exception e)
            {
                FaultTask(channelContext.Server._openTaskCompletionSource, e);
            }
        }

        private void OnOpenChannelComplete(IAsyncResult result)
        {
            Contract.Assert(result != null);

            if (result.CompletedSynchronously)
            {
                return;
            }

            OpenChannelComplete(result);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private void OpenChannelComplete(IAsyncResult result)
        {
            ChannelContext channelContext = (ChannelContext)result.AsyncState;
            Contract.Assert(channelContext != null);
            Contract.Assert(channelContext.Channel != null);

            try
            {
                channelContext.Channel.EndOpen(result);

                // The channel is open and we can complete the open task
                CompleteTask(channelContext.Server._openTaskCompletionSource);

                // Start pumping messages
                int initialWindowSize = Math.Min(InitialWindowSize, _configuration.MaxConcurrentRequests);
                Interlocked.Add(ref _windowSize, initialWindowSize);
                for (int index = 0; index < initialWindowSize; index++)
                {
                    BeginReceiveRequestContext(channelContext);
                }

                // Start accepting next channel
                BeginAcceptChannel(channelContext.Server);
            }
            catch (Exception e)
            {
                FaultTask(channelContext.Server._openTaskCompletionSource, e);
            }
        }

        private void BeginReceiveRequestContext(ChannelContext context)
        {
            Contract.Assert(context != null);

            if (context.Channel.State != CommunicationState.Opened)
            {
                return;
            }

            IAsyncResult result = BeginTryReceiveRequestContext(context, _onReceiveRequestContextComplete);
            if (result.CompletedSynchronously)
            {
                ReceiveRequestContextComplete(result);
            }
        }

        private void OnReceiveRequestContextComplete(IAsyncResult result)
        {
            if (result.CompletedSynchronously)
            {
                return;
            }

            ReceiveRequestContextComplete(result);
        }

        private void ReceiveRequestContextComplete(IAsyncResult result)
        {
            Contract.Assert(result != null);

            ChannelContext channelContext = (ChannelContext)result.AsyncState;
            Contract.Assert(channelContext != null);

            System.ServiceModel.Channels.RequestContext requestContext;
            if (EndTryReceiveRequestContext(result, out requestContext))
            {
                if (requestContext != null)
                {
                    Interlocked.Increment(ref _requestsOutstanding);
                    if (TryIncreaseWindowSize())
                    {
                        // Spin off an additional BeginReceiveRequest to increase the window size by 1
                        BeginReceiveRequestContext(channelContext);
                    }
                    ProcessRequestContext(channelContext, requestContext);
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static IAsyncResult BeginTryReceiveRequestContext(ChannelContext channelContext, AsyncCallback callback)
        {
            Contract.Assert(channelContext != null);
            Contract.Assert(callback != null);

            try
            {
                return channelContext.Channel.BeginTryReceiveRequest(_receiveTimeout, callback, channelContext);
            }
            catch (CommunicationObjectAbortedException)
            {
                return new CompletedAsyncResult<bool>(true, callback, channelContext);
            }
            catch (CommunicationObjectFaultedException)
            {
                return new CompletedAsyncResult<bool>(true, callback, channelContext);
            }
            catch (CommunicationException)
            {
                return new CompletedAsyncResult<bool>(false, callback, channelContext);
            }
            catch (TimeoutException)
            {
                return new CompletedAsyncResult<bool>(false, callback, channelContext);
            }
            catch
            {
                return new CompletedAsyncResult<bool>(false, callback, channelContext);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static bool EndTryReceiveRequestContext(IAsyncResult result, out System.ServiceModel.Channels.RequestContext requestContext)
        {
            Contract.Assert(result != null);

            CompletedAsyncResult<bool> handlerResult = result as CompletedAsyncResult<bool>;
            if (handlerResult != null)
            {
                requestContext = null;
                return CompletedAsyncResult<bool>.End(handlerResult);
            }
            else
            {
                try
                {
                    ChannelContext channelContext = (ChannelContext)result.AsyncState;
                    Contract.Assert(channelContext != null, "context cannot be null");
                    return channelContext.Channel.EndTryReceiveRequest(result, out requestContext);
                }
                catch (CommunicationObjectAbortedException)
                {
                    requestContext = null;
                    return true;
                }
                catch (CommunicationObjectFaultedException)
                {
                    requestContext = null;
                    return true;
                }
                catch (CommunicationException)
                {
                    requestContext = null;
                    return false;
                }
                catch (TimeoutException)
                {
                    requestContext = null;
                    return false;
                }
                catch
                {
                    requestContext = null;
                    return false;
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private void BeginReply(ReplyContext replyContext)
        {
            Contract.Assert(replyContext != null);

            try
            {
                IAsyncResult result = replyContext.RequestContext.BeginReply(replyContext.Reply, _onReplyComplete, replyContext);
                if (result.CompletedSynchronously)
                {
                    ReplyComplete(result);
                }
            }
            catch
            {
                Interlocked.Decrement(ref _requestsOutstanding);
                BeginNextRequest(replyContext.ChannelContext);
                replyContext.Dispose();
            }
        }

        private void OnReplyComplete(IAsyncResult result)
        {
            Contract.Assert(result != null);

            if (result.CompletedSynchronously)
            {
                return;
            }

            ReplyComplete(result);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private void ReplyComplete(IAsyncResult result)
        {
            ReplyContext replyContext = (ReplyContext)result.AsyncState;
            Contract.Assert(replyContext != null);

            try
            {
                replyContext.RequestContext.EndReply(result);
            }
            catch
            {
            }
            finally
            {
                Interlocked.Decrement(ref _requestsOutstanding);
                BeginNextRequest(replyContext.ChannelContext);
                replyContext.Dispose();
            }
        }

        private void BeginNextRequest(ChannelContext context)
        {
            if (TryDecreaseWindowSize())
            {
                // Decrease the window size by 1 by avoiding calling BeginReceiveRequest
                return;
            }

            BeginReceiveRequestContext(context);
        }

        private bool TryIncreaseWindowSize()
        {
            if (ShouldIncreaseWindowSize())
            {
                // If we can't get the lock, just keep the window size the same
                // It's better to keep the window size the same than risk affecting performance by waiting on a lock
                // And if the lock is taken, some other thread is already updating the window size to a better value
                if (Monitor.TryEnter(_windowSizeLock))
                {
                    try
                    {
                        // Recheck that we should increase the window size to guard for changes between the time we take the lock and the time we increase the window size
                        if (ShouldIncreaseWindowSize())
                        {
                            // Increase Window Size
                            _windowSize++;
                            return true;
                        }
                    }
                    finally
                    {
                        Monitor.Exit(_windowSizeLock);
                    }
                }
            }
            return false;
        }

        private bool TryDecreaseWindowSize()
        {
            if (ShouldDecreaseWindowSize())
            {
                // If we can't get the lock, just keep the window size the same
                // It's better to keep the window size the same than risk affecting performance by waiting on a lock
                // And if the lock is taken, some other thread is already updating the window size to a better value
                if (Monitor.TryEnter(_windowSizeLock))
                {
                    try
                    {
                        // Recheck that we should decrease the window size to guard for changes between the time we take the lock and the time we increase the window size
                        if (ShouldDecreaseWindowSize())
                        {
                            _windowSize--;
                            return true;
                        }
                    }
                    finally
                    {
                        Monitor.Exit(_windowSizeLock);
                    }
                }
            }
            return false;
        }

        private bool ShouldIncreaseWindowSize()
        {
            return _windowSize < _configuration.MaxConcurrentRequests && _requestsOutstanding > _windowSize * IncreaseWindowSizeRatio;
        }

        private bool ShouldDecreaseWindowSize()
        {
            return _windowSize > MinimumWindowSize && _requestsOutstanding < _windowSize * DecreaseWindowSizeRatio;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static void BeginCloseListener(HttpSelfHostServer server)
        {
            Contract.Assert(server != null);

            try
            {
                if (server._listener != null)
                {
                    IAsyncResult result = server._listener.BeginClose(_onCloseListenerComplete, server);
                    if (result.CompletedSynchronously)
                    {
                        CloseListenerComplete(result);
                    }
                }
            }
            catch
            {
                CloseNextChannel(server);
            }
        }

        private static void OnCloseListenerComplete(IAsyncResult result)
        {
            Contract.Assert(result != null);

            if (result.CompletedSynchronously)
            {
                return;
            }

            CloseListenerComplete(result);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static void CloseListenerComplete(IAsyncResult result)
        {
            HttpSelfHostServer server = (HttpSelfHostServer)result.AsyncState;
            Contract.Assert(server != null);
            Contract.Assert(server._listener != null);

            try
            {
                server._listener.EndClose(result);
            }
            catch
            {
            }
            finally
            {
                CloseNextChannel(server);
            }
        }

        private static void CloseNextChannel(HttpSelfHostServer server)
        {
            Contract.Assert(server != null);

            IReplyChannel channel;
            if (server._channels.TryTake(out channel))
            {
                BeginCloseChannel(new ChannelContext(server, channel));
            }
            else
            {
                CompleteTask(server._closeTaskCompletionSource);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static void BeginCloseChannel(ChannelContext channelContext)
        {
            Contract.Assert(channelContext != null);

            try
            {
                IAsyncResult result = channelContext.Channel.BeginClose(_onCloseChannelComplete, channelContext);
                if (result.CompletedSynchronously)
                {
                    CloseChannelComplete(result);
                }
            }
            catch
            {
                CloseNextChannel(channelContext.Server);
            }
        }

        private static void OnCloseChannelComplete(IAsyncResult result)
        {
            Contract.Assert(result != null);

            if (result.CompletedSynchronously)
            {
                return;
            }

            CloseChannelComplete(result);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
        private static void CloseChannelComplete(IAsyncResult result)
        {
            ChannelContext channelContext = (ChannelContext)result.AsyncState;
            Contract.Assert(channelContext != null);

            try
            {
                channelContext.Channel.EndClose(result);
            }
            catch
            {
            }
            finally
            {
                CloseNextChannel(channelContext.Server);
            }
        }

        /// <summary>
        /// Provides context for receiving an <see cref="System.ServiceModel.Channels.RequestContext"/> instance asynchronously.
        /// </summary>
        private class ChannelContext
        {
            /// <summary>
            /// Initializes a new instance of the <see cref="ChannelContext"/> class.
            /// </summary>
            /// <param name="server">The host to associate with this context.</param>
            /// <param name="channel">The channel to associate with this channel.</param>
            public ChannelContext(HttpSelfHostServer server, IReplyChannel channel)
            {
                Contract.Assert(server != null);
                Contract.Assert(channel != null);
                Server = server;
                Channel = channel;
            }

            /// <summary>
            /// Gets the <see cref="HttpSelfHostServer"/> instance.
            /// </summary>
            /// <value>
            /// The <see cref="HttpSelfHostServer"/> instance.
            /// </value>
            public HttpSelfHostServer Server { get; private set; }

            /// <summary>
            /// Gets the <see cref="IReplyChannel"/> instance.
            /// </summary>
            /// <value>
            /// The <see cref="System.ServiceModel.Channels.RequestContext"/> instance.
            /// </value>
            public IReplyChannel Channel { get; private set; }
        }

        /// <summary>
        /// Provides context for sending a <see cref="System.ServiceModel.Channels.Message"/> instance asynchronously in response
        /// to a request.
        /// </summary>
        private class ReplyContext : IDisposable
        {
            private bool _disposed;

            /// <summary>
            /// Initializes a new instance of the <see cref="ChannelContext"/> class.
            /// </summary>
            /// <param name="channelContext">The channel context to associate with this reply context.</param>
            /// <param name="requestContext">The request context to associate with this reply context.</param>
            /// <param name="reply">The reply to associate with this reply context.</param>
            public ReplyContext(ChannelContext channelContext, RequestContext requestContext, Message reply)
            {
                Contract.Assert(channelContext != null);
                Contract.Assert(requestContext != null);
                Contract.Assert(reply != null);

                ChannelContext = channelContext;
                RequestContext = requestContext;
                Reply = reply;
            }

            /// <summary>
            /// Gets the <see cref="ChannelContext"/> instance.
            /// </summary>
            /// <value>
            /// The <see cref="ChannelContext"/> instance.
            /// </value>
            public ChannelContext ChannelContext { get; private set; }

            /// <summary>
            /// Gets the <see cref="System.ServiceModel.Channels.RequestContext"/> instance.
            /// </summary>
            /// <value>
            /// The <see cref="System.ServiceModel.Channels.RequestContext"/> instance.
            /// </value>
            public RequestContext RequestContext { get; private set; }

            /// <summary>
            /// Gets the reply <see cref="System.ServiceModel.Channels.Message"/> instance.
            /// </summary>
            /// <value>
            /// The reply <see cref="System.ServiceModel.Channels.Message"/> instance.
            /// </value>
            public Message Reply { get; private set; }

            /// <summary>
            /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged SRResources.
            /// </summary>
            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            /// <summary>
            /// Releases unmanaged and - optionally - managed resources
            /// </summary>
            /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged SRResources.</param>
            [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to fail here so we have to catch all exceptions.")]
            protected virtual void Dispose(bool disposing)
            {
                if (!_disposed)
                {
                    if (disposing)
                    {
                        // RequestContext.Close can throw if the client disconnects before it finishes receiving the response
                        // Catch here to avoid throwing in a Dispose method
                        try
                        {
                            RequestContext.Close();
                        }
                        catch
                        {
                        }

                        // HttpMessage.Close can throw if the request message throws in its Dispose implementation
                        // Catch here to avoid throwing in a Dispose method
                        try
                        {
                            Reply.Close();
                        }
                        catch
                        {
                        }
                    }

                    _disposed = true;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;

[assembly: AssemblyTitle("System.Web.Http.SelfHost")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.Http.SelfHost.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/System.Web.Http.SelfHost/Properties/SRResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.239
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.SelfHost.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class SRResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SRResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.SelfHost.Properties.SRResources", typeof(SRResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End cannot be called twice on an AsyncResult..
        /// </summary>
        internal static string AsyncResultAlreadyEnded {
            get {
                return ResourceManager.GetString("AsyncResultAlreadyEnded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The IAsyncResult implementation &apos;{0}&apos; tried to complete a single operation multiple times. This could be caused by an incorrect application IAsyncResult implementation or other extensibility code, such as an IAsyncResult that returns incorrect CompletedSynchronously values or invokes the AsyncCallback multiple times..
        /// </summary>
        internal static string AsyncResultCompletedTwice {
            get {
                return ResourceManager.GetString("AsyncResultCompletedTwice", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The size quota for this stream ({0}) has been exceeded..
        /// </summary>
        internal static string BufferedOutputStreamQuotaExceeded {
            get {
                return ResourceManager.GetString("BufferedOutputStreamQuotaExceeded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ClientCredentialType must be set to Certificate when a X509CertificateValidator is specified on the HttpSelfHostConfiguration..
        /// </summary>
        internal static string CannotUseOtherClientCredentialTypeWithX509CertificateValidator {
            get {
                return ResourceManager.GetString("CannotUseOtherClientCredentialTypeWithX509CertificateValidator", resourceCulture);
            }
        }

        /// <summary>
        ///   Looks up a localized string similar to ClientCredentialType must be set to Certificate when a UserNamePasswordValidator is specified on the HttpSelfHostConfiguration..
        /// </summary>
        internal static string CannotUseOtherClientCredentialTypeWithUserNamePasswordValidator
        {
            get
            {
                return ResourceManager.GetString("CannotUseOtherClientCredentialTypeWithUserNamePasswordValidator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Certificate-based client authentication is not supported in TransportCredentialOnly security mode. Select the Transport security mode..
        /// </summary>
        internal static string CertificateUnsupportedForHttpTransportCredentialOnly {
            get {
                return ResourceManager.GetString("CertificateUnsupportedForHttpTransportCredentialOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; type does not support building &apos;{1}&apos; instances..
        /// </summary>
        internal static string ChannelFactoryNotSupported {
            get {
                return ResourceManager.GetString("ChannelFactoryNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; type does not support the &apos;{1}&apos; channel shape. Implement the &apos;{2}&apos; channel shape to use this type..
        /// </summary>
        internal static string ChannelShapeNotSupported {
            get {
                return ResourceManager.GetString("ChannelShapeNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The message version of the outgoing message ({0}) does not match that of the encoder ({1}). Make sure the binding is configured with the same version as the message..
        /// </summary>
        internal static string EncoderMessageVersionMismatch {
            get {
                return ResourceManager.GetString("EncoderMessageVersionMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; type does not support a session encoder..
        /// </summary>
        internal static string HttpMessageEncoderFactoryDoesNotSupportSessionEncoder {
            get {
                return ResourceManager.GetString("HttpMessageEncoderFactoryDoesNotSupportSessionEncoder", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not obtain an HTTP request from message of type &apos;{0}&apos;..
        /// </summary>
        internal static string HttpMessageHandlerInvalidMessage {
            get {
                return ResourceManager.GetString("HttpMessageHandlerInvalidMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This &apos;{0}&apos; instance has already been started once. To start another instance, please create a new &apos;{0}&apos; object and start that..
        /// </summary>
        internal static string HttpServerAlreadyRunning {
            get {
                return ResourceManager.GetString("HttpServerAlreadyRunning", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The inner listener factory of {0} must be set before this operation..
        /// </summary>
        internal static string InnerListenerFactoryNotSet {
            get {
                return ResourceManager.GetString("InnerListenerFactoryNotSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An incorrect IAsyncResult was provided to an &apos;End&apos; method. The IAsyncResult object passed to &apos;End&apos; must be the one returned from the matching &apos;Begin&apos; or passed to the callback provided to &apos;Begin&apos;..
        /// </summary>
        internal static string InvalidAsyncResult {
            get {
                return ResourceManager.GetString("InvalidAsyncResult", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An incorrect implementation of the IAsyncResult interface may be returning incorrect values from the CompletedSynchronously property or calling the AsyncCallback more than once. The type {0} could be the incorrect implementation..
        /// </summary>
        internal static string InvalidAsyncResultImplementation {
            get {
                return ResourceManager.GetString("InvalidAsyncResultImplementation", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An incorrect implementation of the IAsyncResult interface may be returning incorrect values from the CompletedSynchronously property or calling the AsyncCallback more than once..
        /// </summary>
        internal static string InvalidAsyncResultImplementationGeneric {
            get {
                return ResourceManager.GetString("InvalidAsyncResultImplementationGeneric", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error creating &apos;{0}&apos; instance using &apos;{1}&apos;..
        /// </summary>
        internal static string InvalidChannelListener {
            get {
                return ResourceManager.GetString("InvalidChannelListener", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A null value was returned from an async &apos;Begin&apos; method or passed to an AsyncCallback. Async &apos;Begin&apos; implementations must return a non-null IAsyncResult and pass the same IAsyncResult object as the parameter to the AsyncCallback..
        /// </summary>
        internal static string InvalidNullAsyncResult {
            get {
                return ResourceManager.GetString("InvalidNullAsyncResult", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTTP request message body with a content length of &apos;{0}&apos; bytes..
        /// </summary>
        internal static string MessageBodyIsHttpRequestMessageWithKnownContentLength {
            get {
                return ResourceManager.GetString("MessageBodyIsHttpRequestMessageWithKnownContentLength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTTP request message body with an undetermined content length..
        /// </summary>
        internal static string MessageBodyIsHttpRequestMessageWithUnknownContentLength {
            get {
                return ResourceManager.GetString("MessageBodyIsHttpRequestMessageWithUnknownContentLength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTTP response message body with a content length of &apos;{0}&apos; bytes..
        /// </summary>
        internal static string MessageBodyIsHttpResponseMessageWithKnownContentLength {
            get {
                return ResourceManager.GetString("MessageBodyIsHttpResponseMessageWithKnownContentLength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTTP response message body with an undetermined content length..
        /// </summary>
        internal static string MessageBodyIsHttpResponseMessageWithUnknownContentLength {
            get {
                return ResourceManager.GetString("MessageBodyIsHttpResponseMessageWithUnknownContentLength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; is closed and can no longer be used..
        /// </summary>
        internal static string MessageClosed {
            get {
                return ResourceManager.GetString("MessageClosed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The response message is not valid for the encoder used by the &apos;{0}&apos; binding, which requires that the response message have been created with the &apos;{1}&apos; extension method on the &apos;{2}&apos; class..
        /// </summary>
        internal static string MessageInvalidForHttpMessageEncoder {
            get {
                return ResourceManager.GetString("MessageInvalidForHttpMessageEncoder", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The message instance does not support being read, written out or copied. Use the &apos;{0}&apos; or &apos;{1}&apos; extension methods on the &apos;{2}&apos; class to access the message content..
        /// </summary>
        internal static string MessageReadWriteCopyNotSupported {
            get {
                return ResourceManager.GetString("MessageReadWriteCopyNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The message instance is non-empty but the &apos;{0}&apos; extension method on the &apos;{1}&apos; class returned null. Message instances that do not support the &apos;{0}&apos; extension method must be empty. .
        /// </summary>
        internal static string NonHttpMessageMustBeEmpty {
            get {
                return ResourceManager.GetString("NonHttpMessageMustBeEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nonnegative number required.
        /// </summary>
        internal static string NonnegativeNumberRequired {
            get {
                return ResourceManager.GetString("NonnegativeNumberRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; type supports only MessageVersion.None. .
        /// </summary>
        internal static string OnlyMessageVersionNoneSupportedOnHttpMessageEncodingBindingElement {
            get {
                return ResourceManager.GetString("OnlyMessageVersionNoneSupportedOnHttpMessageEncodingBindingElement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value of the &apos;{0}&apos; parameter must be less than or equal to the value of the &apos;{1}&apos; parameter..
        /// </summary>
        internal static string ParameterMustBeLessThanOrEqualSecondParameter {
            get {
                return ResourceManager.GetString("ParameterMustBeLessThanOrEqualSecondParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Read not supported on this stream..
        /// </summary>
        internal static string ReadNotSupported {
            get {
                return ResourceManager.GetString("ReadNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Processing of the request was cancelled..
        /// </summary>
        internal static string RequestCancelled {
            get {
                return ResourceManager.GetString("RequestCancelled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The incoming message does not have the required &apos;{0}&apos; property of type &apos;{1}&apos;..
        /// </summary>
        internal static string RequestMissingHttpRequestMessageProperty {
            get {
                return ResourceManager.GetString("RequestMissingHttpRequestMessageProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The incoming message does not have the required &apos;To&apos; header..
        /// </summary>
        internal static string RequestMissingToHeader {
            get {
                return ResourceManager.GetString("RequestMissingToHeader", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Seek not supported on this stream..
        /// </summary>
        internal static string SeekNotSupported {
            get {
                return ResourceManager.GetString("SeekNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be non-negative..
        /// </summary>
        internal static string ValueMustBeNonNegative {
            get {
                return ResourceManager.GetString("ValueMustBeNonNegative", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/Properties/SRResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="AsyncResultAlreadyEnded" xml:space="preserve">
    <value>End cannot be called twice on an AsyncResult.</value>
  </data>
  <data name="AsyncResultCompletedTwice" xml:space="preserve">
    <value>The IAsyncResult implementation '{0}' tried to complete a single operation multiple times. This could be caused by an incorrect application IAsyncResult implementation or other extensibility code, such as an IAsyncResult that returns incorrect CompletedSynchronously values or invokes the AsyncCallback multiple times.</value>
  </data>
  <data name="CannotUseOtherClientCredentialTypeWithUserNamePasswordValidator" xml:space="preserve">
    <value>ClientCredentialType must be set to Basic when a UserNamePasswordValidator is specified on the HttpSelfHostConfiguration.</value>
  </data>
  <data name="CannotUseOtherClientCredentialTypeWithX509CertificateValidator" xml:space="preserve">
    <value>ClientCredentialType must be set to Certificate when a X509CertificateValidator is specified on the HttpSelfHostConfiguration.</value>
  </data>
  <data name="CertificateUnsupportedForHttpTransportCredentialOnly" xml:space="preserve">
    <value>Certificate-based client authentication is not supported in TransportCredentialOnly security mode. Select the Transport security mode.</value>
  </data>
  <data name="ChannelFactoryNotSupported" xml:space="preserve">
    <value>The '{0}' type does not support building '{1}' instances.</value>
  </data>
  <data name="ChannelShapeNotSupported" xml:space="preserve">
    <value>The '{0}' type does not support the '{1}' channel shape. Implement the '{2}' channel shape to use this type.</value>
  </data>
  <data name="EncoderMessageVersionMismatch" xml:space="preserve">
    <value>The message version of the outgoing message ({0}) does not match that of the encoder ({1}). Make sure the binding is configured with the same version as the message.</value>
  </data>
  <data name="HttpMessageEncoderFactoryDoesNotSupportSessionEncoder" xml:space="preserve">
    <value>The '{0}' type does not support a session encoder.</value>
  </data>
  <data name="HttpMessageHandlerInvalidMessage" xml:space="preserve">
    <value>Could not obtain an HTTP request from message of type '{0}'.</value>
  </data>
  <data name="HttpServerAlreadyRunning" xml:space="preserve">
    <value>This '{0}' instance has already been started once. To start another instance, please create a new '{0}' object and start that.</value>
  </data>
  <data name="InnerListenerFactoryNotSet" xml:space="preserve">
    <value>The inner listener factory of {0} must be set before this operation.</value>
  </data>
  <data name="InvalidAsyncResult" xml:space="preserve">
    <value>An incorrect IAsyncResult was provided to an 'End' method. The IAsyncResult object passed to 'End' must be the one returned from the matching 'Begin' or passed to the callback provided to 'Begin'.</value>
  </data>
  <data name="InvalidAsyncResultImplementation" xml:space="preserve">
    <value>An incorrect implementation of the IAsyncResult interface may be returning incorrect values from the CompletedSynchronously property or calling the AsyncCallback more than once. The type {0} could be the incorrect implementation.</value>
  </data>
  <data name="InvalidAsyncResultImplementationGeneric" xml:space="preserve">
    <value>An incorrect implementation of the IAsyncResult interface may be returning incorrect values from the CompletedSynchronously property or calling the AsyncCallback more than once.</value>
  </data>
  <data name="InvalidChannelListener" xml:space="preserve">
    <value>Error creating '{0}' instance using '{1}'.</value>
  </data>
  <data name="InvalidNullAsyncResult" xml:space="preserve">
    <value>A null value was returned from an async 'Begin' method or passed to an AsyncCallback. Async 'Begin' implementations must return a non-null IAsyncResult and pass the same IAsyncResult object as the parameter to the AsyncCallback.</value>
  </data>
  <data name="MessageBodyIsHttpRequestMessageWithKnownContentLength" xml:space="preserve">
    <value>HTTP request message body with a content length of '{0}' bytes.</value>
  </data>
  <data name="MessageBodyIsHttpRequestMessageWithUnknownContentLength" xml:space="preserve">
    <value>HTTP request message body with an undetermined content length.</value>
  </data>
  <data name="MessageBodyIsHttpResponseMessageWithKnownContentLength" xml:space="preserve">
    <value>HTTP response message body with a content length of '{0}' bytes.</value>
  </data>
  <data name="MessageBodyIsHttpResponseMessageWithUnknownContentLength" xml:space="preserve">
    <value>HTTP response message body with an undetermined content length.</value>
  </data>
  <data name="MessageClosed" xml:space="preserve">
    <value>The '{0}' is closed and can no longer be used.</value>
  </data>
  <data name="MessageInvalidForHttpMessageEncoder" xml:space="preserve">
    <value>The response message is not valid for the encoder used by the '{0}' binding, which requires that the response message have been created with the '{1}' extension method on the '{2}' class.</value>
  </data>
  <data name="MessageReadWriteCopyNotSupported" xml:space="preserve">
    <value>The message instance does not support being read, written out or copied. Use the '{0}' or '{1}' extension methods on the '{2}' class to access the message content.</value>
  </data>
  <data name="NonHttpMessageMustBeEmpty" xml:space="preserve">
    <value>The message instance is non-empty but the '{0}' extension method on the '{1}' class returned null. Message instances that do not support the '{0}' extension method must be empty. </value>
  </data>
  <data name="NonnegativeNumberRequired" xml:space="preserve">
    <value>Nonnegative number required</value>
  </data>
  <data name="OnlyMessageVersionNoneSupportedOnHttpMessageEncodingBindingElement" xml:space="preserve">
    <value>The '{0}' type supports only MessageVersion.None. </value>
  </data>
  <data name="ParameterMustBeLessThanOrEqualSecondParameter" xml:space="preserve">
    <value>The value of the '{0}' parameter must be less than or equal to the value of the '{1}' parameter.</value>
  </data>
  <data name="RequestMissingHttpRequestMessageProperty" xml:space="preserve">
    <value>The incoming message does not have the required '{0}' property of type '{1}'.</value>
  </data>
  <data name="RequestMissingToHeader" xml:space="preserve">
    <value>The incoming message does not have the required 'To' header.</value>
  </data>
  <data name="BufferedOutputStreamQuotaExceeded" xml:space="preserve">
    <value>The size quota for this stream ({0}) has been exceeded.</value>
  </data>
  <data name="ReadNotSupported" xml:space="preserve">
    <value>Read not supported on this stream.</value>
  </data>
  <data name="SeekNotSupported" xml:space="preserve">
    <value>Seek not supported on this stream.</value>
  </data>
  <data name="ValueMustBeNonNegative" xml:space="preserve">
    <value>Value must be non-negative.</value>
  </data>
  <data name="RequestCancelled" xml:space="preserve">
    <value>Processing of the request was cancelled.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Http.SelfHost/SelfHostHttpRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IdentityModel.Claims;
using System.Net;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Security;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using System.Web.Http.SelfHost.Channels;
using System.Web.Http.SelfHost.Properties;
using System.Web.Http.SelfHost.ServiceModel.Channels;

namespace System.Web.Http.SelfHost
{
    internal class SelfHostHttpRequestContext : HttpRequestContext
    {
        private readonly RequestContext _requestContext;
        private readonly HttpRequestMessage _request;

        private HttpConfiguration _configuration;

        private X509Certificate2 _clientCertificate;
        private bool _clientCertificateSet;

        private bool _includeErrorDetail;
        private bool _includeErrorDetailSet;

        private bool _isLocal;
        private bool _isLocalSet;

        private UrlHelper _url;
        private bool _urlSet;

        private string _virtualPathRoot;
        private bool _virtualPathRootSet;

        public SelfHostHttpRequestContext(RequestContext requestContext, HttpConfiguration configuration,
            HttpRequestMessage request)
        {
            Contract.Assert(requestContext != null);
            Contract.Assert(configuration != null);
            Contract.Assert(request != null);
            _requestContext = requestContext;
            _configuration = configuration;
            _request = request;
        }

        public RequestContext RequestContext
        {
            get { return _requestContext; }
        }

        public HttpRequestMessage Request
        {
            get { return _request; }
        }

        // RouteData is not overridden; it is provided in a later point in the pipeline (HttpRoutingDispatcher).

        public override X509Certificate2 ClientCertificate
        {
            get
            {
                if (!_clientCertificateSet)
                {
                    _clientCertificate = HttpSelfHostServer.RetrieveClientCertificate(_request);
                    _clientCertificateSet = true;
                }

                return _clientCertificate;
            }
            set
            {
                _clientCertificate = value;
                _clientCertificateSet = true;
            }
        }

        public override HttpConfiguration Configuration
        {
            get
            {
                return _configuration;
            }
            set
            {
                _configuration = value;
            }
        }

        public override bool IncludeErrorDetail
        {
            get
            {
                if (!_includeErrorDetailSet)
                {
                    IncludeErrorDetailPolicy includeErrorDetailPolicy;

                    if (_configuration != null)
                    {
                        includeErrorDetailPolicy = _configuration.IncludeErrorDetailPolicy;
                    }
                    else
                    {
                        includeErrorDetailPolicy = IncludeErrorDetailPolicy.Default;
                    }

                    bool value;

                    switch (includeErrorDetailPolicy)
                    {
                        case IncludeErrorDetailPolicy.Default:
                        case IncludeErrorDetailPolicy.LocalOnly:
                            value = IsLocal;
                            break;

                        case IncludeErrorDetailPolicy.Always:
                            value = true;
                            break;

                        case IncludeErrorDetailPolicy.Never:
                        default:
                            value = false;
                            break;
                    }

                    _includeErrorDetail = value;
                    _includeErrorDetailSet = true;
                }

                return _includeErrorDetail;
            }
            set
            {
                _includeErrorDetail = value;
                _includeErrorDetailSet = true;
            }
        }

        public override bool IsLocal
        {
            get
            {
                if (!_isLocalSet)
                {
                    _isLocal = HttpSelfHostServer.IsLocal(_requestContext.RequestMessage);
                    _isLocalSet = true;
                }

                return _isLocal;
            }
            set
            {
                _isLocal = value;
                _isLocalSet = true;
            }
        }

        public override IPrincipal Principal
        {
            get
            {
                return Thread.CurrentPrincipal;
            }
            set
            {
                Thread.CurrentPrincipal = value;
            }
        }

        public override UrlHelper Url
        {
            get
            {
                if (!_urlSet)
                {
                    _url = new UrlHelper(_request);
                    _urlSet = true;
                }

                return _url;
            }
            set
            {
                _url = value;
                _urlSet = true;
            }
        }

        public override string VirtualPathRoot
        {
            get
            {
                if (!_virtualPathRootSet)
                {
                    string value;

                    if (_configuration != null)
                    {
                        value = _configuration.VirtualPathRoot;
                    }
                    else
                    {
                        value = "/";
                    }

                    _virtualPathRoot = value;
                    _virtualPathRootSet = true;
                }

                return _virtualPathRoot;
            }
            set
            {
                _virtualPathRoot = value;
                _virtualPathRootSet = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/AsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Threading;
using System.Web.Http.SelfHost.Properties;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    // AsyncResult starts acquired; Complete releases.
    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Ported from WCF")]
    internal abstract class AsyncResult : IAsyncResult
    {
        private static AsyncCallback _asyncCompletionWrapperCallback;
        private readonly AsyncCallback _completionCallback;
        private bool _completedSynchronously;
        private bool _endCalled;
        private Exception _exception;
        private bool _isCompleted;
        private AsyncCompletion _nextAsyncCompletion;
        private readonly object _state;
        private Action _beforePrepareAsyncCompletionAction;
        private Func<IAsyncResult, bool> _checkSyncValidationFunc;
        private ManualResetEvent _manualResetEvent;
        private readonly object _manualResetEventLock = new object();

        protected AsyncResult(AsyncCallback callback, object state)
        {
            _completionCallback = callback;
            _state = state;
        }

        /// <summary>
        /// Can be utilized by subclasses to write core completion code for both the sync and async paths
        /// in one location, signalling chainable synchronous completion with the boolean result,
        /// and leveraging PrepareAsyncCompletion for conversion to an AsyncCallback.
        /// </summary>
        /// <remarks>NOTE: requires that "this" is passed in as the state object to the asynchronous sub-call being used with a completion routine.</remarks>
        protected delegate bool AsyncCompletion(IAsyncResult result);

        public object AsyncState
        {
            get { return _state; }
        }

        public WaitHandle AsyncWaitHandle
        {
            get
            {
                lock (_manualResetEventLock)
                {
                    if (_manualResetEvent == null)
                    {
                        _manualResetEvent = new ManualResetEvent(_isCompleted);
                    }
                }

                return _manualResetEvent;
            }
        }

        public bool CompletedSynchronously
        {
            get { return _completedSynchronously; }
        }

        public bool HasCallback
        {
            get { return _completionCallback != null; }
        }

        public bool IsCompleted
        {
            get { return _isCompleted; }
        }

        // used in conjunction with PrepareAsyncCompletion to allow for finally blocks
        protected Action<AsyncResult, Exception> OnCompleting { get; set; }

        // subclasses like TraceAsyncResult can use this to wrap the callback functionality in a scope
        protected Action<AsyncCallback, IAsyncResult> VirtualCallback { get; set; }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is propagated or FailFast")]
        protected void Complete(bool didCompleteSynchronously)
        {
            if (_isCompleted)
            {
                throw Error.InvalidOperation(SRResources.AsyncResultCompletedTwice, GetType());
            }

            _completedSynchronously = didCompleteSynchronously;
            if (OnCompleting != null)
            {
                // Allow exception replacement, like a catch/throw pattern.
                try
                {
                    OnCompleting(this, _exception);
                }
                catch (Exception e)
                {
                    _exception = e;
                }
            }

            if (didCompleteSynchronously)
            {
                // If we completedSynchronously, then there's no chance that the manualResetEvent was created so
                // we don't need to worry about a race
                Contract.Assert(_manualResetEvent == null, "No ManualResetEvent should be created for a synchronous AsyncResult.");
                _isCompleted = true;
            }
            else
            {
                lock (_manualResetEventLock)
                {
                    _isCompleted = true;
                    if (_manualResetEvent != null)
                    {
                        _manualResetEvent.Set();
                    }
                }
            }

            if (_completionCallback != null)
            {
                try
                {
                    if (VirtualCallback != null)
                    {
                        VirtualCallback(_completionCallback, this);
                    }
                    else
                    {
                        _completionCallback(this);
                    }
                }
#pragma warning disable 1634
#pragma warning suppress 56500 // transferring exception to another thread
                catch (Exception e)
                {
                    // String is not resourced because it occurs only in debug build, only with a fatal assert,
                    // and because it appears as an unused resource in a release build
                    Contract.Assert(false, Error.Format("{0}{1}{2}", "Async Callback threw an exception.", Environment.NewLine, e.ToString()));
                }
#pragma warning restore 1634
            }
        }

        protected void Complete(bool didCompleteSynchronously, Exception error)
        {
            _exception = error;
            Complete(didCompleteSynchronously);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is propagated")]
        private static void AsyncCompletionWrapperCallback(IAsyncResult result)
        {
            if (result == null)
            {
                throw Error.InvalidOperation(SRResources.InvalidNullAsyncResult);
            }
            if (result.CompletedSynchronously)
            {
                return;
            }

            AsyncResult thisPtr = (AsyncResult)result.AsyncState;
            if (!thisPtr.OnContinueAsyncCompletion(result))
            {
                return;
            }

            AsyncCompletion callback = thisPtr.GetNextCompletion();
            if (callback == null)
            {
                ThrowInvalidAsyncResult(result);
            }

            bool completeSelf = false;
            Exception completionException = null;
            try
            {
                completeSelf = callback(result);
            }
            catch (Exception e)
            {
                completeSelf = true;
                completionException = e;
            }

            if (completeSelf)
            {
                thisPtr.Complete(false, completionException);
            }
        }

        // Note: this should be only derived by the TransactedAsyncResult
        protected virtual bool OnContinueAsyncCompletion(IAsyncResult result)
        {
            return true;
        }

        // Note: this should be used only by the TransactedAsyncResult
        protected void SetBeforePrepareAsyncCompletionAction(Action completionAction)
        {
            _beforePrepareAsyncCompletionAction = completionAction;
        }

        // Note: this should be used only by the TransactedAsyncResult
        protected void SetCheckSyncValidationFunc(Func<IAsyncResult, bool> validationFunc)
        {
            _checkSyncValidationFunc = validationFunc;
        }

        protected AsyncCallback PrepareAsyncCompletion(AsyncCompletion callback)
        {
            if (_beforePrepareAsyncCompletionAction != null)
            {
                _beforePrepareAsyncCompletionAction();
            }

            _nextAsyncCompletion = callback;
            if (AsyncResult._asyncCompletionWrapperCallback == null)
            {
                AsyncResult._asyncCompletionWrapperCallback = new AsyncCallback(AsyncCompletionWrapperCallback);
            }
            return AsyncResult._asyncCompletionWrapperCallback;
        }

        protected bool CheckSyncContinue(IAsyncResult result)
        {
            AsyncCompletion dummy;
            return TryContinueHelper(result, out dummy);
        }

        protected bool SyncContinue(IAsyncResult result)
        {
            AsyncCompletion callback;
            if (TryContinueHelper(result, out callback))
            {
                return callback(result);
            }
            else
            {
                return false;
            }
        }

        private bool TryContinueHelper(IAsyncResult result, out AsyncCompletion callback)
        {
            if (result == null)
            {
                throw Error.InvalidOperation(SRResources.InvalidNullAsyncResult);
            }

            callback = null;
            if (_checkSyncValidationFunc != null)
            {
                if (!_checkSyncValidationFunc(result))
                {
                    return false;
                }
            }
            else if (!result.CompletedSynchronously)
            {
                return false;
            }

            callback = GetNextCompletion();
            if (callback == null)
            {
                ThrowInvalidAsyncResult("Only call Check/SyncContinue once per async operation (once per PrepareAsyncCompletion).");
            }
            return true;
        }

        private AsyncCompletion GetNextCompletion()
        {
            AsyncCompletion result = _nextAsyncCompletion;
            _nextAsyncCompletion = null;
            return result;
        }

        protected static void ThrowInvalidAsyncResult(IAsyncResult result)
        {
            if (result == null)
            {
                throw Error.ArgumentNull("result");
            }

            throw Error.InvalidOperation(SRResources.InvalidAsyncResultImplementation, result.GetType());
        }

        protected static void ThrowInvalidAsyncResult(string debugText)
        {
            string message = SRResources.InvalidAsyncResultImplementationGeneric;
            if (debugText != null)
            {
#if DEBUG
                message += " " + debugText;
#endif
            }
            throw Error.InvalidOperation(message);
        }

        [SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "Existing API")]
        protected static TAsyncResult End<TAsyncResult>(IAsyncResult result)
            where TAsyncResult : AsyncResult
        {
            if (result == null)
            {
                throw Error.ArgumentNull("result");
            }

            TAsyncResult asyncResult = result as TAsyncResult;

            if (asyncResult == null)
            {
                throw Error.Argument("result", SRResources.InvalidAsyncResult);
            }

            if (asyncResult._endCalled)
            {
                throw Error.InvalidOperation(SRResources.AsyncResultAlreadyEnded);
            }

            asyncResult._endCalled = true;

            if (!asyncResult._isCompleted)
            {
                asyncResult.AsyncWaitHandle.WaitOne();
            }

            if (asyncResult._manualResetEvent != null)
            {
                asyncResult._manualResetEvent.Close();
            }

            if (asyncResult._exception != null)
            {
                throw asyncResult._exception;
            }

            return asyncResult;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/BufferManagerOutputStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;
using System.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal class BufferManagerOutputStream : BufferedOutputStream
    {
        private readonly string _quotaExceededString;

        public BufferManagerOutputStream(string quotaExceededString, int initialSize, int maxSize, BufferManager bufferManager)
            : base(initialSize, maxSize, bufferManager)
        {
            _quotaExceededString = quotaExceededString;
        }

        public void Init(int initialSize, int maxSizeQuota, BufferManager bufferManager)
        {
            Init(initialSize, maxSizeQuota, maxSizeQuota, bufferManager);
        }

        public void Init(int initialSize, int maxSizeQuota, int effectiveMaxSize, BufferManager bufferManager)
        {
            Reinitialize(initialSize, maxSizeQuota, effectiveMaxSize, bufferManager);
        }

        protected override Exception CreateQuotaExceededException(int maxSizeQuota)
        {
            string excMsg = Error.Format(_quotaExceededString, maxSizeQuota);
            return new QuotaExceededException(excMsg);
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/BufferedOutputStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.Properties;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal class BufferedOutputStream : Stream
    {
        private BufferManager _bufferManager;

        private byte[][] _chunks;

        private int _chunkCount;
        private byte[] _currentChunk;
        private int _currentChunkSize;
        private int _maxSize;
        private int _theMaxSizeQuota;
        private int _totalSize;
        private bool _callerReturnsBuffer;

        [SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields", Justification = "Used for internal checking")]
        private bool _bufferReturned;

        [SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields", Justification = "Used for internal checking")]
        private bool _initialized;

        // requires an explicit call to Init() by the caller
        public BufferedOutputStream()
        {
            _chunks = new byte[4][];
        }

        public BufferedOutputStream(int initialSize, int maxSize, BufferManager bufferManager)
            : this()
        {
            Reinitialize(initialSize, maxSize, bufferManager);
        }

        public override bool CanRead
        {
            get { return false; }
        }

        public override bool CanSeek
        {
            get { return false; }
        }

        public override bool CanWrite
        {
            get { return true; }
        }

        public override long Length
        {
            get { return _totalSize; }
        }

        public override long Position
        {
            get { throw Error.NotSupported(SRResources.SeekNotSupported); }

            set { throw Error.NotSupported(SRResources.SeekNotSupported); }
        }

        public void Reinitialize(int initialSize, int maxSizeQuota, BufferManager bufferManager)
        {
            Reinitialize(initialSize, maxSizeQuota, maxSizeQuota, bufferManager);
        }

        public void Reinitialize(int initialSize, int maxSizeQuota, int effectiveMaxSize, BufferManager bufferManager)
        {
            Contract.Assert(!_initialized, "Clear must be called before re-initializing stream");

            if (bufferManager == null)
            {
                throw Error.ArgumentNull("bufferManager");
            }

            _theMaxSizeQuota = maxSizeQuota;
            _maxSize = effectiveMaxSize;
            _bufferManager = bufferManager;
            _currentChunk = bufferManager.TakeBuffer(initialSize);
            _currentChunkSize = 0;
            _totalSize = 0;
            _chunkCount = 1;
            _chunks[0] = _currentChunk;
            _initialized = true;
        }

        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            throw Error.NotSupported(SRResources.ReadNotSupported);
        }

        public override int EndRead(IAsyncResult asyncResult)
        {
            throw Error.NotSupported(SRResources.ReadNotSupported);
        }

        public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            Write(buffer, offset, count);
            return new CompletedAsyncResult(callback, state);
        }

        public override void EndWrite(IAsyncResult asyncResult)
        {
            CompletedAsyncResult.End(asyncResult);
        }

        public void Clear()
        {
            if (!_callerReturnsBuffer)
            {
                for (int i = 0; i < _chunkCount; i++)
                {
                    _bufferManager.ReturnBuffer(_chunks[i]);
                    _chunks[i] = null;
                }
            }

            _callerReturnsBuffer = false;
            _initialized = false;
            _bufferReturned = false;
            _chunkCount = 0;
            _currentChunk = null;
        }

        public override void Close()
        {
            // Called directly or via base.Dispose, ensure all buffers are returned to the BufferManager
            Clear();
        }

        public override void Flush()
        {
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            throw Error.NotSupported(SRResources.ReadNotSupported);
        }

        public override int ReadByte()
        {
            throw Error.NotSupported(SRResources.ReadNotSupported);
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            throw Error.NotSupported(SRResources.SeekNotSupported);
        }

        public override void SetLength(long value)
        {
            throw Error.NotSupported(SRResources.SeekNotSupported);
        }

        public MemoryStream ToMemoryStream()
        {
            int bufferSize;
            byte[] buffer = ToArray(out bufferSize);
            return new MemoryStream(buffer, 0, bufferSize);
        }

        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", Justification = "Out parameter is fine here.")]
        public byte[] ToArray(out int bufferSize)
        {
            Contract.Assert(_initialized, "No data to return from uninitialized stream");
            Contract.Assert(!_bufferReturned, "ToArray cannot be called more than once");

            byte[] buffer;
            if (_chunkCount == 1)
            {
                buffer = _currentChunk;
                bufferSize = _currentChunkSize;
                _callerReturnsBuffer = true;
            }
            else
            {
                buffer = _bufferManager.TakeBuffer(_totalSize);
                int offset = 0;
                int count = _chunkCount - 1;
                for (int i = 0; i < count; i++)
                {
                    byte[] chunk = _chunks[i];
                    Buffer.BlockCopy(chunk, 0, buffer, offset, chunk.Length);
                    offset += chunk.Length;
                }

                Buffer.BlockCopy(_currentChunk, 0, buffer, offset, _currentChunkSize);
                bufferSize = _totalSize;
            }

            _bufferReturned = true;
            return buffer;
        }

        public void Skip(int size)
        {
            WriteCore(null, 0, size);
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            WriteCore(buffer, offset, count);
        }

        public override void WriteByte(byte value)
        {
            Contract.Assert(_initialized, "Cannot write to uninitialized stream");
            Contract.Assert(!_bufferReturned, "Cannot write to stream once ToArray has been called.");

            if (_totalSize == _maxSize)
            {
                throw CreateQuotaExceededException(_maxSize);
            }

            if (_currentChunkSize == _currentChunk.Length)
            {
                AllocNextChunk(1);
            }

            _currentChunk[_currentChunkSize++] = value;
        }

        protected virtual Exception CreateQuotaExceededException(int maxSizeQuota)
        {
            return new InvalidOperationException(Error.Format(SRResources.BufferedOutputStreamQuotaExceeded, maxSizeQuota));
        }

        private void WriteCore(byte[] buffer, int offset, int size)
        {
            Contract.Assert(_initialized, "Cannot write to uninitialized stream");
            Contract.Assert(!_bufferReturned, "Cannot write to stream once ToArray has been called.");

            if (size < 0)
            {
                throw Error.ArgumentOutOfRange("size", size, SRResources.ValueMustBeNonNegative);
            }

            if ((Int32.MaxValue - size) < _totalSize)
            {
                throw CreateQuotaExceededException(_theMaxSizeQuota);
            }

            int newTotalSize = _totalSize + size;
            if (newTotalSize > _maxSize)
            {
                throw CreateQuotaExceededException(_theMaxSizeQuota);
            }

            int remainingSizeInChunk = _currentChunk.Length - _currentChunkSize;
            if (size > remainingSizeInChunk)
            {
                if (remainingSizeInChunk > 0)
                {
                    if (buffer != null)
                    {
                        Buffer.BlockCopy(buffer, offset, _currentChunk, _currentChunkSize, remainingSizeInChunk);
                    }

                    _currentChunkSize = _currentChunk.Length;
                    offset += remainingSizeInChunk;
                    size -= remainingSizeInChunk;
                }

                AllocNextChunk(size);
            }

            if (buffer != null)
            {
                Buffer.BlockCopy(buffer, offset, _currentChunk, _currentChunkSize, size);
            }

            _totalSize = newTotalSize;
            _currentChunkSize += size;
        }

        private void AllocNextChunk(int minimumChunkSize)
        {
            int newChunkSize;
            if (_currentChunk.Length > (Int32.MaxValue / 2))
            {
                newChunkSize = Int32.MaxValue;
            }
            else
            {
                newChunkSize = _currentChunk.Length * 2;
            }

            if (minimumChunkSize > newChunkSize)
            {
                newChunkSize = minimumChunkSize;
            }

            byte[] newChunk = _bufferManager.TakeBuffer(newChunkSize);
            if (_chunkCount == _chunks.Length)
            {
                byte[][] newChunks = new byte[_chunks.Length * 2][];
                Array.Copy(_chunks, newChunks, _chunks.Length);
                _chunks = newChunks;
            }

            _chunks[_chunkCount++] = newChunk;
            _currentChunk = newChunk;
            _currentChunkSize = 0;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/ChannelAcceptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;
using System.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal abstract class ChannelAcceptor<TChannel> : CommunicationObject, IChannelAcceptor<TChannel>
        where TChannel : class, IChannel
    {
        private ChannelManagerBase _channelManager;

        protected ChannelAcceptor(ChannelManagerBase channelManager)
        {
            _channelManager = channelManager;
        }

        protected ChannelManagerBase ChannelManager
        {
            get { return _channelManager; }
        }

        protected override TimeSpan DefaultCloseTimeout
        {
            get { return ((IDefaultCommunicationTimeouts)_channelManager).CloseTimeout; }
        }

        protected override TimeSpan DefaultOpenTimeout
        {
            get { return ((IDefaultCommunicationTimeouts)_channelManager).OpenTimeout; }
        }

        public abstract TChannel AcceptChannel(TimeSpan timeout);

        public abstract IAsyncResult BeginAcceptChannel(TimeSpan timeout, AsyncCallback callback, object state);

        public abstract TChannel EndAcceptChannel(IAsyncResult result);

        public abstract bool WaitForChannel(TimeSpan timeout);

        public abstract IAsyncResult BeginWaitForChannel(TimeSpan timeout, AsyncCallback callback, object state);

        public abstract bool EndWaitForChannel(IAsyncResult result);

        protected override void OnAbort()
        {
        }

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return new CompletedAsyncResult(callback, state);
        }

        protected override void OnEndClose(IAsyncResult result)
        {
            CompletedAsyncResult.End(result);
        }

        protected override void OnClose(TimeSpan timeout)
        {
        }

        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return new CompletedAsyncResult(callback, state);
        }

        protected override void OnEndOpen(IAsyncResult result)
        {
            CompletedAsyncResult.End(result);
        }

        protected override void OnOpen(TimeSpan timeout)
        {
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/ChannelBindingUtility.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Authentication.ExtendedProtection;
using System.Security.Authentication.ExtendedProtection.Configuration;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal static class ChannelBindingUtility
    {
        private static ExtendedProtectionPolicy disabledPolicy = new ExtendedProtectionPolicy(PolicyEnforcement.Never);
        private static ExtendedProtectionPolicy defaultPolicy = disabledPolicy;

        public static bool IsDefaultPolicy(ExtendedProtectionPolicy policy)
        {
            return Object.ReferenceEquals(policy, defaultPolicy);
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/CompletedAsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    //An AsyncResult that completes as soon as it is instantiated.
    internal class CompletedAsyncResult : AsyncResult
    {
        public CompletedAsyncResult(AsyncCallback callback, object state)
            : base(callback, state)
        {
            Complete(true);
        }

        public static void End(IAsyncResult result)
        {
            Contract.Assert(result != null, "CompletedAsyncResult was null.");
            Contract.Assert(result.IsCompleted, "CompletedAsyncResult was not completed!");
            AsyncResult.End<CompletedAsyncResult>(result);
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/CompletedAsyncResultOfT.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal class CompletedAsyncResult<T> : AsyncResult
    {
        private T data;

        public CompletedAsyncResult(T data, AsyncCallback callback, object state)
            : base(callback, state)
        {
            this.data = data;
            Complete(true);
        }

        public static T End(IAsyncResult result)
        {
            Contract.Assert(result != null, "CompletedAsyncResult<T> was null.");
            Contract.Assert(result.IsCompleted, "CompletedAsyncResult<T> was not completed!");
            CompletedAsyncResult<T> completedResult = AsyncResult.End<CompletedAsyncResult<T>>(result);
            return completedResult.data;
        }
    }
}

================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/HttpTransportDefaults.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal static class HttpTransportDefaults
    {
        internal const HostNameComparisonMode HostNameComparisonMode = System.ServiceModel.HostNameComparisonMode.StrongWildcard;
        internal const TransferMode TransferMode = System.ServiceModel.TransferMode.Buffered;
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/IChannelAcceptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;
using System.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal interface IChannelAcceptor<TChannel> : ICommunicationObject
        where TChannel : class, IChannel
    {
        TChannel AcceptChannel(TimeSpan timeout);

        IAsyncResult BeginAcceptChannel(TimeSpan timeout, AsyncCallback callback, object state);

        TChannel EndAcceptChannel(IAsyncResult result);

        bool WaitForChannel(TimeSpan timeout);

        IAsyncResult BeginWaitForChannel(TimeSpan timeout, AsyncCallback callback, object state);

        bool EndWaitForChannel(IAsyncResult result);
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/LayeredChannel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal abstract class LayeredChannel<TInnerChannel> : ChannelBase
        where TInnerChannel : class, IChannel
    {
        private TInnerChannel _innerChannel;
        private EventHandler _onInnerChannelFaulted;

        protected LayeredChannel(ChannelManagerBase channelManager, TInnerChannel innerChannel)
            : base(channelManager)
        {
            Contract.Assert(innerChannel != null);

            _innerChannel = innerChannel;
            _onInnerChannelFaulted = new EventHandler(OnInnerChannelFaulted);
            _innerChannel.Faulted += _onInnerChannelFaulted;
        }

        protected TInnerChannel InnerChannel
        {
            get { return _innerChannel; }
        }

        public override T GetProperty<T>()
        {
            T baseProperty = base.GetProperty<T>();
            if (baseProperty != null)
            {
                return baseProperty;
            }

            return InnerChannel.GetProperty<T>();
        }

        protected override void OnClosing()
        {
            _innerChannel.Faulted -= _onInnerChannelFaulted;
            base.OnClosing();
        }

        protected override void OnAbort()
        {
            _innerChannel.Abort();
        }

        protected override void OnClose(TimeSpan timeout)
        {
            _innerChannel.Close(timeout);
        }

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return _innerChannel.BeginClose(timeout, callback, state);
        }

        protected override void OnEndClose(IAsyncResult result)
        {
            _innerChannel.EndClose(result);
        }

        protected override void OnOpen(TimeSpan timeout)
        {
            _innerChannel.Open(timeout);
        }

        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return _innerChannel.BeginOpen(timeout, callback, state);
        }

        protected override void OnEndOpen(IAsyncResult result)
        {
            _innerChannel.EndOpen(result);
        }

        private void OnInnerChannelFaulted(object sender, EventArgs e)
        {
            Fault();
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/LayeredChannelAcceptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel.Channels;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal abstract class LayeredChannelAcceptor<TChannel, TInnerChannel> : ChannelAcceptor<TChannel>
        where TChannel : class, IChannel
        where TInnerChannel : class, IChannel
    {
        private IChannelListener<TInnerChannel> _innerListener;

        protected LayeredChannelAcceptor(ChannelManagerBase channelManager, IChannelListener<TInnerChannel> innerListener)
            : base(channelManager)
        {
            _innerListener = innerListener;
        }

        public override TChannel AcceptChannel(TimeSpan timeout)
        {
            TInnerChannel innerChannel = _innerListener.AcceptChannel(timeout);
            if (innerChannel == null)
            {
                return null;
            }
            else
            {
                return OnAcceptChannel(innerChannel);
            }
        }

        public override IAsyncResult BeginAcceptChannel(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return _innerListener.BeginAcceptChannel(timeout, callback, state);
        }

        public override TChannel EndAcceptChannel(IAsyncResult result)
        {
            TInnerChannel innerChannel = _innerListener.EndAcceptChannel(result);
            if (innerChannel == null)
            {
                return null;
            }
            else
            {
                return OnAcceptChannel(innerChannel);
            }
        }

        public override bool WaitForChannel(TimeSpan timeout)
        {
            return _innerListener.WaitForChannel(timeout);
        }

        public override IAsyncResult BeginWaitForChannel(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return _innerListener.BeginWaitForChannel(timeout, callback, state);
        }

        public override bool EndWaitForChannel(IAsyncResult result)
        {
            return _innerListener.EndWaitForChannel(result);
        }

        protected abstract TChannel OnAcceptChannel(TInnerChannel innerChannel);
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/LayeredChannelListener.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.Properties;

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal abstract class LayeredChannelListener<TChannel> : ChannelListenerBase<TChannel>
        where TChannel : class, IChannel
    {
        private IChannelListener _innerChannelListener;
        private bool _sharedInnerListener;
        private EventHandler _onInnerListenerFaulted;

        protected LayeredChannelListener(bool sharedInnerListener, IDefaultCommunicationTimeouts timeouts, IChannelListener innerChannelListener)
            : base(timeouts)
        {
            _sharedInnerListener = sharedInnerListener;
            _innerChannelListener = innerChannelListener;
            _onInnerListenerFaulted = new EventHandler(OnInnerListenerFaulted);
            if (_innerChannelListener != null)
            {
                _innerChannelListener.Faulted += _onInnerListenerFaulted;
            }
        }

        protected LayeredChannelListener(bool sharedInnerListener, IDefaultCommunicationTimeouts timeouts)
            : this(sharedInnerListener, timeouts, null)
        {
        }

        protected LayeredChannelListener(bool sharedInnerListener)
            : this(sharedInnerListener, null, null)
        {
        }

        protected LayeredChannelListener(IDefaultCommunicationTimeouts timeouts, IChannelListener innerChannelListener)
            : this(false, timeouts, innerChannelListener)
        {
        }

        public override Uri Uri
        {
            get { return GetInnerListenerSnapshot().Uri; }
        }

        internal virtual IChannelListener InnerChannelListener
        {
            get { return _innerChannelListener; }

            set
            {
                lock (ThisLock)
                {
                    ThrowIfDisposedOrImmutable();
                    if (_innerChannelListener != null)
                    {
                        _innerChannelListener.Faulted -= _onInnerListenerFaulted;
                    }

                    _innerChannelListener = value;
                    if (_innerChannelListener != null)
                    {
                        _innerChannelListener.Faulted += _onInnerListenerFaulted;
                    }
                }
            }
        }

        internal bool SharedInnerListener
        {
            get { return _sharedInnerListener; }
        }

        public override T GetProperty<T>()
        {
            T baseProperty = base.GetProperty<T>();
            if (baseProperty != null)
            {
                return baseProperty;
            }

            IChannelListener channelListener = InnerChannelListener;
            if (channelListener != null)
            {
                return channelListener.GetProperty<T>();
            }
            else
            {
                return default(T);
            }
        }

        internal void ThrowIfInnerListenerNotSet()
        {
            if (InnerChannelListener == null)
            {
                throw Error.InvalidOperation(SRResources.InnerListenerFactoryNotSet, GetType().ToString());
            }
        }

        internal IChannelListener GetInnerListenerSnapshot()
        {
            IChannelListener innerListener = InnerChannelListener;

            if (innerListener == null)
            {
                throw Error.InvalidOperation(SRResources.InnerListenerFactoryNotSet, GetType().ToString());
            }

            return innerListener;
        }

        protected override void OnOpening()
        {
            base.OnOpening();
            ThrowIfInnerListenerNotSet();
        }

        protected override void OnOpen(TimeSpan timeout)
        {
            if (InnerChannelListener != null && !_sharedInnerListener)
            {
                InnerChannelListener.Open(timeout);
            }
        }

        protected override void OnEndOpen(IAsyncResult result)
        {
            OpenAsyncResult.End(result);
        }

        protected override IAsyncResult OnBeginOpen(TimeSpan timeout, AsyncCallback callback, object state)
        {
            return new OpenAsyncResult(InnerChannelListener, _sharedInnerListener, timeout, callback, state);
        }

        protected override void OnClose(TimeSpan timeout)
        {
            OnCloseOrAbort();
            if (InnerChannelListener != null && !_sharedInnerListener)
            {
                InnerChannelListener.Close(timeout);
            }
        }

        protected override void OnEndClose(IAsyncResult result)
        {
            CloseAsyncResult.End(result);
        }

        protected override IAsyncResult OnBeginClose(TimeSpan timeout, AsyncCallback callback, object state)
        {
            OnCloseOrAbort();
            return new CloseAsyncResult(InnerChannelListener, _sharedInnerListener, timeout, callback, state);
        }

        protected override void OnAbort()
        {
            lock (ThisLock)
            {
                OnCloseOrAbort();
            }

            IChannelListener channelListener = InnerChannelListener;
            if (channelListener != null && !_sharedInnerListener)
            {
                channelListener.Abort();
            }
        }

        private void OnInnerListenerFaulted(object sender, EventArgs e)
        {
            // if our inner listener faulted, we should fault as well
            Fault();
        }

        private void OnCloseOrAbort()
        {
            IChannelListener channelListener = InnerChannelListener;
            if (channelListener != null)
            {
                channelListener.Faulted -= _onInnerListenerFaulted;
            }
        }

        private class CloseAsyncResult : AsyncResult
        {
            private static AsyncCallback _onCloseComplete = new AsyncCallback(OnCloseComplete);

            private ICommunicationObject _communicationObject;

            public CloseAsyncResult(ICommunicationObject communicationObject, bool sharedInnerListener, TimeSpan timeout, AsyncCallback callback, object state)
                : base(callback, state)
            {
                _communicationObject = communicationObject;

                if (_communicationObject == null || sharedInnerListener)
                {
                    Complete(true);
                    return;
                }

                IAsyncResult result = _communicationObject.BeginClose(timeout, _onCloseComplete, this);

                if (result.CompletedSynchronously)
                {
                    _communicationObject.EndClose(result);
                    Complete(true);
                }
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<CloseAsyncResult>(result);
            }

            [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is propagated.")]
            private static void OnCloseComplete(IAsyncResult result)
            {
                if (result.CompletedSynchronously)
                {
                    return;
                }

                CloseAsyncResult thisPtr = (CloseAsyncResult)result.AsyncState;
                Exception exception = null;

                try
                {
                    thisPtr._communicationObject.EndClose(result);
                }
                catch (Exception e)
                {
                    exception = e;
                }

                thisPtr.Complete(false, exception);
            }
        }

        private class OpenAsyncResult : AsyncResult
        {
            private static AsyncCallback _onOpenComplete = new AsyncCallback(OnOpenComplete);

            private ICommunicationObject _communicationObject;

            public OpenAsyncResult(ICommunicationObject communicationObject, bool sharedInnerListener, TimeSpan timeout, AsyncCallback callback, object state)
                : base(callback, state)
            {
                _communicationObject = communicationObject;

                if (_communicationObject == null || sharedInnerListener)
                {
                    Complete(true);
                    return;
                }

                IAsyncResult result = _communicationObject.BeginOpen(timeout, _onOpenComplete, this);
                if (result.CompletedSynchronously)
                {
                    _communicationObject.EndOpen(result);
                    Complete(true);
                }
            }

            public static void End(IAsyncResult result)
            {
                AsyncResult.End<OpenAsyncResult>(result);
            }

            [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exception is propagated.")]
            private static void OnOpenComplete(IAsyncResult result)
            {
                if (result.CompletedSynchronously)
                {
                    return;
                }

                OpenAsyncResult thisPtr = (OpenAsyncResult)result.AsyncState;
                Exception exception = null;

                try
                {
                    thisPtr._communicationObject.EndOpen(result);
                }
                catch (Exception e)
                {
                    exception = e;
                }

                thisPtr.Complete(false, exception);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/Channels/TransportDefaults.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.SelfHost.ServiceModel.Channels
{
    internal static class TransportDefaults
    {
        internal const long MaxReceivedMessageSize = 65536;
        internal const long MaxBufferPoolSize = 512 * 1024;
        internal const int MaxBufferSize = (int)MaxReceivedMessageSize;
        internal const int MaxFaultSize = MaxBufferSize;
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/HostNameComparisonModeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;

namespace System.Web.Http.SelfHost.ServiceModel
{
    internal static class HostNameComparisonModeHelper
    {
        public static bool IsDefined(HostNameComparisonMode value)
        {
            return
                value == HostNameComparisonMode.StrongWildcard
                || value == HostNameComparisonMode.Exact
                || value == HostNameComparisonMode.WeakWildcard;
        }

        public static void Validate(HostNameComparisonMode value, string parameterName)
        {
            if (!IsDefined(value))
            {
                throw Error.InvalidEnumArgument(parameterName, (int)value, typeof(HostNameComparisonMode));
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/HttpClientCredentialTypeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.ServiceModel;

namespace System.Web.Http.SelfHost.ServiceModel
{
    internal static class HttpClientCredentialTypeHelper
    {
        internal static AuthenticationSchemes MapToAuthenticationScheme(HttpClientCredentialType clientCredentialType)
        {
            switch (clientCredentialType)
            {
                case HttpClientCredentialType.None:
                case HttpClientCredentialType.Certificate:
                    return AuthenticationSchemes.Anonymous;

                case HttpClientCredentialType.Basic:
                    return AuthenticationSchemes.Basic;

                case HttpClientCredentialType.Digest:
                    return AuthenticationSchemes.Digest;

                case HttpClientCredentialType.Ntlm:
                    return AuthenticationSchemes.Ntlm;

                case HttpClientCredentialType.Windows:
                    return AuthenticationSchemes.Negotiate;
            }

            Contract.Assert(false, "Invalid clientCredentialType " + clientCredentialType);
            return AuthenticationSchemes.Anonymous;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/HttpProxyCredentialTypeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.ServiceModel;

namespace System.Web.Http.SelfHost.ServiceModel
{
    internal static class HttpProxyCredentialTypeHelper
    {
        internal static AuthenticationSchemes MapToAuthenticationScheme(HttpProxyCredentialType proxyCredentialType)
        {
            switch (proxyCredentialType)
            {
                case HttpProxyCredentialType.None:
                    return AuthenticationSchemes.Anonymous;

                case HttpProxyCredentialType.Basic:
                    return AuthenticationSchemes.Basic;

                case HttpProxyCredentialType.Digest:
                    return AuthenticationSchemes.Digest;

                case HttpProxyCredentialType.Ntlm:
                    return AuthenticationSchemes.Ntlm;

                case HttpProxyCredentialType.Windows:
                    return AuthenticationSchemes.Negotiate;
            }

            Contract.Assert(false, "Invalid proxyCredentialType " + proxyCredentialType);
            return AuthenticationSchemes.Anonymous;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/HttpTransportSecurityExtensionMethods.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.Web.Http.SelfHost.Properties;

namespace System.Web.Http.SelfHost.ServiceModel
{
    internal static class HttpTransportSecurityExtensionMethods
    {
        internal static void ConfigureTransportProtectionAndAuthentication(this HttpTransportSecurity httpTransportSecurity, HttpsTransportBindingElement httpsTransportBindingElement)
        {
            Contract.Assert(httpTransportSecurity != null);
            Contract.Assert(httpsTransportBindingElement != null);

            httpTransportSecurity.ConfigureAuthentication(httpsTransportBindingElement);
            httpsTransportBindingElement.RequireClientCertificate = httpTransportSecurity.ClientCredentialType == HttpClientCredentialType.Certificate;
        }

        internal static void ConfigureTransportAuthentication(this HttpTransportSecurity httpTransportSecurity, HttpTransportBindingElement httpTransportBindingElement)
        {
            Contract.Assert(httpTransportSecurity != null);
            Contract.Assert(httpTransportBindingElement != null);

            if (httpTransportSecurity.ClientCredentialType == HttpClientCredentialType.Certificate)
            {
                throw Error.InvalidOperation(SRResources.CertificateUnsupportedForHttpTransportCredentialOnly);
            }

            httpTransportSecurity.ConfigureAuthentication(httpTransportBindingElement);
        }

        internal static void DisableTransportAuthentication(this HttpTransportSecurity httpTransportSecurity, HttpTransportBindingElement httpTransportBindingElement)
        {
            Contract.Assert(httpTransportSecurity != null);
            Contract.Assert(httpTransportBindingElement != null);

            httpTransportBindingElement.AuthenticationScheme = AuthenticationSchemes.Anonymous;
            httpTransportBindingElement.ProxyAuthenticationScheme = AuthenticationSchemes.Anonymous;
            httpTransportBindingElement.Realm = String.Empty;
            httpTransportBindingElement.ExtendedProtectionPolicy = httpTransportSecurity.ExtendedProtectionPolicy;
        }

        private static void ConfigureAuthentication(this HttpTransportSecurity httpTransportSecurity, HttpTransportBindingElement httpTransportBindingElement)
        {
            Contract.Assert(httpTransportSecurity != null);
            Contract.Assert(httpTransportBindingElement != null);

            httpTransportBindingElement.AuthenticationScheme = HttpClientCredentialTypeHelper.MapToAuthenticationScheme(httpTransportSecurity.ClientCredentialType);
            httpTransportBindingElement.ProxyAuthenticationScheme = HttpProxyCredentialTypeHelper.MapToAuthenticationScheme(httpTransportSecurity.ProxyCredentialType);
            httpTransportBindingElement.Realm = httpTransportSecurity.Realm;
            httpTransportBindingElement.ExtendedProtectionPolicy = httpTransportSecurity.ExtendedProtectionPolicy;
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/ServiceModel/TransferModeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;

namespace System.Web.Http.SelfHost.ServiceModel
{
    internal static class TransferModeHelper
    {
        public static bool IsDefined(TransferMode transferMode)
        {
            return transferMode == TransferMode.Buffered ||
                   transferMode == TransferMode.Streamed ||
                   transferMode == TransferMode.StreamedRequest ||
                   transferMode == TransferMode.StreamedResponse;
        }

        public static void Validate(TransferMode value, string parameterValue)
        {
            if (!IsDefined(value))
            {
                throw Error.InvalidEnumArgument(parameterValue, (int)value, typeof(TransferMode));
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SelfHost/System.Web.Http.SelfHost.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.SelfHost</RootNamespace>
    <AssemblyName>System.Web.Http.SelfHost</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.IdentityModel" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.ServiceModel" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\Common\DictionaryExtensions.cs">
      <Link>Common\DictionaryExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\Error.cs">
      <Link>Common\Error.cs</Link>
    </Compile>
    <Compile Include="..\Common\HttpMethodHelper.cs">
      <Link>Common\HttpMethodHelper.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpers.cs">
      <Link>Common\TaskHelpers.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpersExtensions.cs">
      <Link>Common\TaskHelpersExtensions.cs</Link>
    </Compile>
    <Compile Include="HttpRequestMessageExtensions.cs" />
    <Compile Include="Properties\SRResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>SRResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Channels\HttpMessage.cs" />
    <Compile Include="Channels\HttpMessageEncoderFactory.cs" />
    <Compile Include="Channels\HttpMessageEncodingBindingElement.cs" />
    <Compile Include="Channels\HttpMessageEncodingChannelListener.cs" />
    <Compile Include="Channels\HttpMessageEncodingReplyChannel.cs" />
    <Compile Include="Channels\HttpMessageEncodingRequestContext.cs" />
    <Compile Include="Channels\HttpMessageExtensions.cs" />
    <Compile Include="Channels\HttpBinding.cs" />
    <Compile Include="Channels\HttpBindingSecurity.cs" />
    <Compile Include="Channels\HttpBindingSecurityMode.cs" />
    <Compile Include="Channels\HttpBindingSecurityModeHelper.cs" />
    <Compile Include="HttpSelfHostConfiguration.cs" />
    <Compile Include="HttpSelfHostServer.cs" />
    <Compile Include="SelfHostHttpRequestContext.cs" />
    <Compile Include="ServiceModel\Channels\AsyncResult.cs" />
    <Compile Include="ServiceModel\Channels\BufferedOutputStream.cs" />
    <Compile Include="ServiceModel\Channels\BufferManagerOutputStream.cs" />
    <Compile Include="ServiceModel\Channels\ChannelAcceptor.cs" />
    <Compile Include="ServiceModel\Channels\ChannelBindingUtility.cs" />
    <Compile Include="ServiceModel\Channels\CompletedAsyncResult.cs" />
    <Compile Include="ServiceModel\Channels\HttpTransportDefaults.cs" />
    <Compile Include="ServiceModel\Channels\IChannelAcceptor.cs" />
    <Compile Include="ServiceModel\Channels\LayeredChannel.cs" />
    <Compile Include="ServiceModel\Channels\LayeredChannelAcceptor.cs" />
    <Compile Include="ServiceModel\Channels\LayeredChannelListener.cs" />
    <Compile Include="ServiceModel\Channels\TransportDefaults.cs" />
    <Compile Include="ServiceModel\Channels\CompletedAsyncResultOfT.cs" />
    <Compile Include="ServiceModel\HostNameComparisonModeHelper.cs" />
    <Compile Include="ServiceModel\HttpClientCredentialTypeHelper.cs" />
    <Compile Include="ServiceModel\HttpProxyCredentialTypeHelper.cs" />
    <Compile Include="ServiceModel\HttpTransportSecurityExtensionMethods.cs" />
    <Compile Include="ServiceModel\TransferModeHelper.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Link>Properties\CommonWebApiResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonWebApiResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\SRResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>SRResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml">
      <Link>CodeAnalysisDictionary.xml</Link>
    </CodeAnalysisDictionary>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Http.SignalR/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http")]
[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "This is until SignalR gets signed.")]


================================================
FILE: src/System.Web.Http.SignalR/HubController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Hubs;

namespace System.Web.Http
{
    /// <summary>
    /// Defines a base class for <see cref="ApiController"/> that exposes functionality for calling back
    /// to clients connected to a particular SignalR hub.
    /// </summary>
    [CLSCompliant(false)]
    public abstract class HubController : HubControllerBase
    {
        private string _hubName;

        /// <summary>
        /// Initializes a new instance of the <see cref="HubController" /> class.
        /// </summary>
        /// <param name="hubName">Name of the hub as specified by the <see cref="HubNameAttribute"/>.</param>
        protected HubController(string hubName)
        {
            if (hubName == null)
            {
                throw Error.ArgumentNull("hubName");
            }
            _hubName = hubName;
        }

        /// <summary>
        /// Gets the <see cref="IHubContext"/> for the associated hub.
        /// </summary>
        protected override IHubContext HubContext
        {
            get
            {
                Contract.Assert(ConnectionManager != null);
                return ConnectionManager.GetHubContext(_hubName);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SignalR/HubControllerBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Web.Http.Properties;
using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Hubs;
using Microsoft.AspNet.SignalR.Infrastructure;

namespace System.Web.Http
{
    /// <summary>
    /// Defines a base class for <see cref="ApiController"/> that exposes functionality for calling back
    /// to clients connected to a particular SignalR hub.
    /// </summary>
    [CLSCompliant(false)]
    public abstract class HubControllerBase : ApiController
    {
        private IConnectionManager _connectionManager;

        /// <summary>
        /// Initializes a new instance of the <see cref="HubControllerBase" /> class.
        /// </summary>
        protected HubControllerBase()
        {
        }

        /// <summary>
        /// Gets an <see cref="IHubConnectionContext"/> that represents the clients connected to the hub.
        /// </summary>
        public IHubConnectionContext Clients
        {
            get
            {
                if (HubContext == null)
                {
                    throw Error.InvalidOperation(SRResources.NullHubContext, GetType().Name);
                }
                return HubContext.Clients;
            }
        }

        /// <summary>
        /// Gets the <see cref="IGroupManager"/> for the hub.
        /// </summary>
        public IGroupManager Groups
        {
            get
            {
                if (HubContext == null)
                {
                    throw Error.InvalidOperation(SRResources.NullHubContext, GetType().Name);
                }
                return HubContext.Groups;
            }
        }

        /// <summary>
        /// Gets the <see cref="IHubContext"/> for the associated hub.
        /// </summary>
        protected abstract IHubContext HubContext
        {
            get;
        }

        /// <summary>
        /// Gets the <see cref="IConnectionManager"/> used to resolve hub contexts. The connection manager will
        /// be resolved by the controller's <see cref="HttpConfiguration"/> dependency resolver if the service is
        /// available. Otherwise, the default GlobalHost <see cref="IConnectionManager"/> will be returned instead.
        /// </summary>
        protected IConnectionManager ConnectionManager
        {
            get
            {
                if (_connectionManager == null)
                {
                    _connectionManager = ResolveConnectionManager();
                }
                return _connectionManager;
            }
        }

        private IConnectionManager ResolveConnectionManager()
        {
            if (Configuration != null)
            {
                Contract.Assert(Configuration.DependencyResolver != null);
                IConnectionManager connectionManager = Configuration.DependencyResolver.GetService(typeof(IConnectionManager)) as IConnectionManager;
                if (connectionManager != null)
                {
                    return connectionManager;
                }
            }

            // If connection manager cannot be resolved by DependencyResolver, use the default connection manager instead.
            return GlobalHost.ConnectionManager;
        }
    }
}

================================================
FILE: src/System.Web.Http.SignalR/HubControllerOfTHub.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Hubs;

namespace System.Web.Http
{
    /// <summary>
    /// Defines a base class for <see cref="ApiController"/> that exposes functionality for calling back
    /// to clients connected to a particular SignalR hub.
    /// </summary>
    /// <typeparam name="THub">The type of the hub. Must implement the <see cref="IHub"/> interface.</typeparam>
    [CLSCompliant(false)]
    public abstract class HubController<THub> : HubControllerBase where THub : IHub
    {
        /// <summary>
        /// Gets the <see cref="IHubContext"/> for the associated hub.
        /// </summary>
        protected override IHubContext HubContext
        {
            get
            {
                Contract.Assert(ConnectionManager != null);
                return ConnectionManager.GetHubContext<THub>();
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SignalR/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;

[assembly: AssemblyTitle("System.Web.Http.SignalR")]
[assembly: AssemblyDescription("")]

[assembly: InternalsVisibleTo("System.Web.Http.SignalR.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/System.Web.Http.SignalR/Properties/SRResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.17929
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class SRResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SRResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.Properties.SRResources", typeof(SRResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No hub context could be found for the HubController of type &apos;{0}&apos;..
        /// </summary>
        internal static string NullHubContext {
            get {
                return ResourceManager.GetString("NullHubContext", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.SignalR/Properties/SRResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="NullHubContext" xml:space="preserve">
    <value>No hub context could be found for the HubController of type '{0}'.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Http.SignalR/System.Web.Http.SignalR.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{8A607AC9-E7DD-4B74-A0B1-47FC95B9838B}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http</RootNamespace>
    <AssemblyName>System.Web.Http.SignalR</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Microsoft.AspNet.SignalR.Core">
      <HintPath>..\..\packages\Microsoft.AspNet.SignalR.Core.1.0.0\lib\net40\Microsoft.AspNet.SignalR.Core.dll</HintPath>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.XML" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\Error.cs">
      <Link>Common\Error.cs</Link>
    </Compile>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="HubController.cs" />
    <Compile Include="HubControllerBase.cs" />
    <Compile Include="HubControllerOfTHub.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\SRResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>SRResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Link>Properties\CommonWebApiResources.resx</Link>
    </EmbeddedResource>
    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
    </Compile>
    <EmbeddedResource Include="Properties\SRResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>SRResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Http.SignalR/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.AspNet.SignalR.Core" version="1.0.0" targetFramework="net45" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.Http.Tracing/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "These assemblies are delay-signed.")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#NotSupported(System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#InvalidOperation(System.Exception,System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#InvalidOperation(System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#InvalidEnumArgument(System.String,System.Int32,System.Type)", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#OperationCanceled(System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#OperationCanceled()", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ObjectDisposed(System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#KeyNotFound(System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#KeyNotFound()", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ArgumentMustBeLessThanOrEqualTo(System.String,System.Object,System.Object)", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ArgumentMustBeGreaterThanOrEqualTo(System.String,System.Object,System.Object)", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ArgumentNullOrEmpty(System.String)", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#PropertyNull()", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ArgumentUriHasQueryOrFragment(System.String,System.Uri)", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ArgumentNull(System.String,System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ArgumentUriNotHttpOrHttpsScheme(System.String,System.Uri)", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#Argument(System.String,System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#Argument(System.String,System.Object[])", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Scope = "member", Target = "System.Web.Http.Error.#ArgumentUriNotAbsolute(System.String,System.Uri)", Justification = "Error imported from main project")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http", Justification = "Small extension project, distinct namespace")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http.Tracing", Justification = "Small extension project, distinct namespace")]

================================================
FILE: src/System.Web.Http.Tracing/HttpConfigurationExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.Http.Tracing;

namespace System.Web.Http
{
    /// <summary>
    /// This static class contains helper methods related to the registration
    /// of <see cref="ITraceWriter"/> instances.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class HttpConfigurationTracingExtensions
    {
        /// <summary>
        /// Creates and registers an <see cref="ITraceWriter"/> implementation to use
        /// for this application.
        /// </summary>
        /// <param name="configuration">The <see cref="HttpConfiguration"/> for which
        /// to register the created trace writer.</param>
        /// <remarks>The returned SystemDiagnosticsTraceWriter may be further configured to change it's default settings.</remarks>
        /// <returns>The <see cref="SystemDiagnosticsTraceWriter"/> which was created and registered.</returns>
        public static SystemDiagnosticsTraceWriter EnableSystemDiagnosticsTracing(this HttpConfiguration configuration)
        {
            if (configuration == null)
            {
                throw new ArgumentNullException("configuration");
            }

            SystemDiagnosticsTraceWriter traceWriter =
                new SystemDiagnosticsTraceWriter()
                {
                    MinimumLevel = TraceLevel.Info,
                    IsVerbose = false
                };

            configuration.Services.Replace(typeof(ITraceWriter), traceWriter);

            return traceWriter;
        }
    }
}

================================================
FILE: src/System.Web.Http.Tracing/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;
using System.Runtime.InteropServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.
[assembly: AssemblyTitle("System.Web.Http.Tracing")]
[assembly: AssemblyDescription("")]

// The following GUID is for the ID of the typelib if this project is exposed to COM
[assembly: Guid("8a696567-259c-46ed-b431-4179725fbe80")]


================================================
FILE: src/System.Web.Http.Tracing/Properties/SRResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.34003
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.Tracing.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class SRResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SRResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.Tracing.Properties.SRResources", typeof(SRResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Category=&apos;{0}&apos;.
        /// </summary>
        internal static string CategoryFormat {
            get {
                return ResourceManager.GetString("CategoryFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Exception={0}.
        /// </summary>
        internal static string ExceptionFormat {
            get {
                return ResourceManager.GetString("ExceptionFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Method={0}.
        /// </summary>
        internal static string HttpMethodFormat {
            get {
                return ResourceManager.GetString("HttpMethodFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Status={0} ({1}).
        /// </summary>
        internal static string HttpStatusFormat {
            get {
                return ResourceManager.GetString("HttpStatusFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Id={0}.
        /// </summary>
        internal static string IdFormat {
            get {
                return ResourceManager.GetString("IdFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Message=&apos;{0}&apos;.
        /// </summary>
        internal static string MessageFormat {
            get {
                return ResourceManager.GetString("MessageFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Operation={0}.{1}.
        /// </summary>
        internal static string OperationFormat {
            get {
                return ResourceManager.GetString("OperationFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Request.
        /// </summary>
        internal static string ShortRequestFormat {
            get {
                return ResourceManager.GetString("ShortRequestFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Response.
        /// </summary>
        internal static string ShortResponseFormat {
            get {
                return ResourceManager.GetString("ShortResponseFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [{0}] Level={1}, Kind={2}.
        /// </summary>
        internal static string TimeLevelKindFormat {
            get {
                return ResourceManager.GetString("TimeLevelKindFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [{0}] Request received.
        /// </summary>
        internal static string TimeRequestFormat {
            get {
                return ResourceManager.GetString("TimeRequestFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [{0}] Sending response.
        /// </summary>
        internal static string TimeResponseFormat {
            get {
                return ResourceManager.GetString("TimeResponseFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TraceLevel property must be a value between TraceLevel.Off and TraceLevel.Fatal, inclusive..
        /// </summary>
        internal static string TraceLevelOutOfRange {
            get {
                return ResourceManager.GetString("TraceLevelOutOfRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Url={0}.
        /// </summary>
        internal static string UrlFormat {
            get {
                return ResourceManager.GetString("UrlFormat", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Tracing/Properties/SRResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="CategoryFormat" xml:space="preserve">
    <value>Category='{0}'</value>
  </data>
  <data name="ExceptionFormat" xml:space="preserve">
    <value>Exception={0}</value>
  </data>
  <data name="HttpMethodFormat" xml:space="preserve">
    <value>Method={0}</value>
  </data>
  <data name="HttpStatusFormat" xml:space="preserve">
    <value>Status={0} ({1})</value>
  </data>
  <data name="IdFormat" xml:space="preserve">
    <value>Id={0}</value>
  </data>
  <data name="MessageFormat" xml:space="preserve">
    <value>Message='{0}'</value>
  </data>
  <data name="OperationFormat" xml:space="preserve">
    <value>Operation={0}.{1}</value>
  </data>
  <data name="ShortRequestFormat" xml:space="preserve">
    <value>Request</value>
  </data>
  <data name="ShortResponseFormat" xml:space="preserve">
    <value>Response</value>
  </data>
  <data name="TimeLevelKindFormat" xml:space="preserve">
    <value>[{0}] Level={1}, Kind={2}</value>
  </data>
  <data name="TimeRequestFormat" xml:space="preserve">
    <value>[{0}] Request received</value>
  </data>
  <data name="TimeResponseFormat" xml:space="preserve">
    <value>[{0}] Sending response</value>
  </data>
  <data name="TraceLevelOutOfRange" xml:space="preserve">
    <value>The TraceLevel property must be a value between TraceLevel.Off and TraceLevel.Fatal, inclusive.</value>
  </data>
  <data name="UrlFormat" xml:space="preserve">
    <value>Url={0}</value>
  </data>
</root>

================================================
FILE: src/System.Web.Http.Tracing/System.Web.Http.Tracing.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{6E81EF98-8F5C-4EED-8B37-456991CA56FD}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.Tracing</RootNamespace>
    <AssemblyName>System.Web.Http.Tracing</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\Common\Error.cs">
      <Link>Common\Error.cs</Link>
    </Compile>
    <Compile Include="..\Common\TraceWriterExceptionMapper.cs">
      <Link>Common\TraceWriterExceptionMapper.cs</Link>
    </Compile>
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="HttpConfigurationExtensions.cs" />
    <Compile Include="SystemDiagnosticsTraceWriter.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Properties\SRResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>SRResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Link>Properties\CommonWebApiResources.resx</Link>
    </EmbeddedResource>
    <EmbeddedResource Include="Properties\SRResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>SRResources.Designer.cs</LastGenOutput>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Http.Tracing/SystemDiagnosticsTraceWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net.Http;
using System.Web.Http.Tracing.Properties;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Implementation of <see cref="ITraceWriter"/> that traces to <see cref="System.Diagnostics.Trace"/>
    /// </summary>
    public class SystemDiagnosticsTraceWriter : ITraceWriter
    {
        // Duplicate of internal category name traced by WebApi for start/end of request
        private const string SystemWebHttpRequestCategory = "System.Web.Http.Request";

        private static readonly TraceEventType[] TraceLevelToTraceEventType = new TraceEventType[]
        {
            // TraceLevel.Off
            (TraceEventType)0,

            // TraceLevel.Debug
            TraceEventType.Verbose,

            // TraceLevel.Info
            TraceEventType.Information,

            // TraceLevel.Warn
            TraceEventType.Warning,

            // TraceLevel.Error
            TraceEventType.Error,

            // TraceLevel.Fatal
            TraceEventType.Critical
        };

        private TraceLevel _minLevel = TraceLevel.Info;

        /// <summary>
        /// Gets or sets the minimum trace level.
        /// </summary>
        /// <value>
        /// Any <see cref="System.Web.Http.Tracing.TraceLevel"/> below this
        /// level will be ignored. The default for this property
        /// is <see cref="TraceLevel.Info"/>.
        /// </value>
        public TraceLevel MinimumLevel
        {
            get
            {
                return _minLevel;
            }
            set
            {
                if (value < TraceLevel.Off || value > TraceLevel.Fatal)
                {
                    throw Error.ArgumentOutOfRange("value",
                                                    value,
                                                    SRResources.TraceLevelOutOfRange);
                }

                _minLevel = value;
            }
        }

        /// <summary>
        /// Gets or sets a value indicating whether the formatted message
        /// should be the verbose format, meaning it displays all fields
        /// of the <see cref="TraceRecord"/>.
        /// </summary>
        /// <value><c>true</c> means all <see cref="TraceRecord"/> fields
        /// will be traced, <c>false</c> means only minimal information
        /// will be traced. The default value is <c>false</c>.</value>
        public bool IsVerbose { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="TraceSource"/> to which the
        /// traces will be sent.
        /// </summary>
        /// <value>
        /// This property allows a custom <see cref="TraceSource"/> 
        /// to be used when writing the traces.
        /// This allows an application to configure and use its
        /// own <see cref="TraceSource"/> other than the default
        /// <see cref="System.Diagnostics.Trace"/>.
        /// If the value is <c>null</c>, this trace writer will
        /// send traces to <see cref="System.Diagnostics.Trace"/>.
        /// </value>
        public TraceSource TraceSource { get; set; }

        /// <summary>
        /// Writes a trace to <see cref="System.Diagnostics.Trace"/> if the
        /// <paramref name="level"/> is greater than or equal <see cref="MinimumLevel"/>.
        /// </summary>
        /// <param name="request">The <see cref="HttpRequestMessage"/> associated with this trace. 
        /// It may be <c>null</c> but the resulting trace will contain no correlation ID.</param>
        /// <param name="category">The category for the trace. This can be any user-defined
        /// value. It is not interpreted by this implementation but is written to the trace.</param>
        /// <param name="level">The <see cref="TraceLevel"/> of this trace. If it is less than
        /// <see cref="MinimumLevel"/>, this trace request will be ignored.</param>
        /// <param name="traceAction">The user callback to invoke to fill in a <see cref="TraceRecord"/>
        /// with additional information to add to the trace.</param>
        public virtual void Trace(HttpRequestMessage request, string category, TraceLevel level, Action<TraceRecord> traceAction)
        {
            if (category == null)
            {
                throw Error.ArgumentNull("category");
            }

            if (traceAction == null)
            {
                throw Error.ArgumentNull("traceAction");
            }

            if (level < TraceLevel.Off || level > TraceLevel.Fatal)
            {
                throw Error.ArgumentOutOfRange("level",
                                                level,
                                                SRResources.TraceLevelOutOfRange);
            }

            if (MinimumLevel == TraceLevel.Off || level < MinimumLevel)
            {
                return;
            }

            TraceRecord traceRecord = new TraceRecord(request, category, level);
            traceAction(traceRecord);
            TranslateHttpResponseException(traceRecord);
            string message = Format(traceRecord);
            if (!String.IsNullOrEmpty(message))
            {
                // Level may have changed in Translate above
                TraceMessage(traceRecord.Level, message);
            }
        }

        /// <summary>
        /// Formats the contents of the given <see cref="TraceRecord"/> into
        /// a single string containing comma-separated name-value pairs
        /// for each <see cref="TraceRecord"/> property.
        /// </summary>
        /// <param name="traceRecord">The <see cref="TraceRecord"/> from which 
        /// to produce the result.</param>
        /// <returns>A string containing comma-separated name-value pairs.</returns>
        public virtual string Format(TraceRecord traceRecord)
        {
            if (traceRecord == null)
            {
                throw Error.ArgumentNull("traceRecord");
            }

            // The first and last traces are injected by the tracing system itself.
            // We use these to format unique strings identifying the incoming request
            // and the outgoing response.
            if (String.Equals(traceRecord.Category, SystemWebHttpRequestCategory, StringComparison.Ordinal))
            {
                return FormatRequestEnvelope(traceRecord);
            }

            List<string> messages = new List<string>();

            if (!IsVerbose)
            {
                // In short format mode, we trace only End traces because it is
                // where the results of each operation will appear.
                if (traceRecord.Kind == TraceKind.Begin)
                {
                    return null;
                }
            }
            else
            {
                messages.Add(Error.Format(SRResources.TimeLevelKindFormat,
                                            FormatDateTime(traceRecord.Timestamp),
                                            traceRecord.Level.ToString(),
                                            traceRecord.Kind.ToString()));

                if (!String.IsNullOrEmpty(traceRecord.Category))
                {
                    messages.Add(Error.Format(SRResources.CategoryFormat, traceRecord.Category));
                }

                messages.Add(Error.Format(SRResources.IdFormat, traceRecord.RequestId.ToString()));
            }

            if (!String.IsNullOrEmpty(traceRecord.Message))
            {
                messages.Add(Error.Format(SRResources.MessageFormat, traceRecord.Message));
            }

            if (traceRecord.Operator != null || traceRecord.Operation != null)
            {
                messages.Add(Error.Format(SRResources.OperationFormat, traceRecord.Operator, traceRecord.Operation));
            }

            if (traceRecord.Status != 0)
            {
                messages.Add(Error.Format(SRResources.HttpStatusFormat, (int)traceRecord.Status, traceRecord.Status.ToString()));
            }

            if (traceRecord.Exception != null)
            {
                messages.Add(Error.Format(SRResources.ExceptionFormat, traceRecord.Exception.ToString()));
            }

            return String.Join(", ", messages);
        }

        /// <summary>
        /// Formats the given <see cref="TraceRecord"/> into a string describing
        /// either the initial receipt of the incoming request or the final send
        /// of the response, depending on <see cref="TraceKind"/>.
        /// </summary>
        /// <param name="traceRecord">The <see cref="TraceRecord"/> from which to 
        /// produce the result.</param>
        /// <returns>A string containing comma-separated name-value pairs.</returns>
        public virtual string FormatRequestEnvelope(TraceRecord traceRecord)
        {
            if (traceRecord == null)
            {
                throw Error.ArgumentNull("traceRecord");
            }

            List<string> messages = new List<string>();

            if (IsVerbose)
            {
                messages.Add(Error.Format((traceRecord.Kind == TraceKind.Begin)
                                                ? SRResources.TimeRequestFormat
                                                : SRResources.TimeResponseFormat,
                                            FormatDateTime(traceRecord.Timestamp)));
            }
            else
            {
                messages.Add((traceRecord.Kind == TraceKind.Begin)
                                ? SRResources.ShortRequestFormat
                                : SRResources.ShortResponseFormat);
            }

            if (traceRecord.Status != 0)
            {
                messages.Add(Error.Format(SRResources.HttpStatusFormat, (int)traceRecord.Status, traceRecord.Status.ToString()));
            }

            if (traceRecord.Request != null)
            {
                messages.Add(Error.Format(SRResources.HttpMethodFormat, traceRecord.Request.Method));

                if (traceRecord.Request.RequestUri != null)
                {
                    messages.Add(Error.Format(SRResources.UrlFormat, traceRecord.Request.RequestUri.ToString()));
                }
            }

            if (IsVerbose)
            {
                messages.Add(Error.Format(SRResources.IdFormat, traceRecord.RequestId.ToString()));
            }

            // The Message and Exception fields do not contain interesting information unless
            // there is a problem, so they appear after the more informative trace information.
            if (!String.IsNullOrEmpty(traceRecord.Message))
            {
                messages.Add(Error.Format(SRResources.MessageFormat, traceRecord.Message));
            }

            if (traceRecord.Exception != null)
            {
                messages.Add(Error.Format(SRResources.ExceptionFormat, traceRecord.Exception.ToString()));
            }

            return String.Join(", ", messages);
        }

        /// <summary>
        /// Examines the given <see cref="TraceRecord"/> to determine whether it
        /// contains an <see cref="HttpResponseException"/> and if so, modifies
        /// the <see cref="TraceRecord"/> to capture more detailed information.
        /// </summary>
        /// <param name="traceRecord">The <see cref="TraceRecord"/> to examine and modify.</param>
        public virtual void TranslateHttpResponseException(TraceRecord traceRecord)
        {
            if (traceRecord == null)
            {
                throw Error.ArgumentNull("traceRecord");
            }

            TraceWriterExceptionMapper.TranslateHttpResponseException(traceRecord);
        }

        /// <summary>
        /// Formats a <see cref="DateTime"/> for the trace.
        /// </summary>
        /// <remarks>
        /// The default implementation uses the ISO 8601 convention
        /// for round-trippable dates so they can be parsed.
        /// </remarks>
        /// <param name="dateTime">The <see cref="DateTime"/></param>
        /// <returns>The <see cref="DateTime"/> formatted as a string</returns>
        public virtual string FormatDateTime(DateTime dateTime)
        {
            // The 'o' format is ISO 8601 for a round-trippable DateTime.
            // It is culture-invariant and can be parsed.
            return dateTime.ToString("o", CultureInfo.InvariantCulture);
        }

        private void TraceMessage(TraceLevel level, string message)
        {
            Contract.Assert(level >= TraceLevel.Off && level <= TraceLevel.Fatal);

            // If the user registered a custom TraceSource, we write a trace event to it
            // directly, preserving the event type.
            TraceSource traceSource = TraceSource;
            if (traceSource != null)
            {
                traceSource.TraceEvent(eventType: TraceLevelToTraceEventType[(int)level], id: 0, message: message);
                return;
            }

            // If there is no custom TraceSource, trace to System.Diagnostics.Trace.
            // But System.Diagnostics.Trace does not offer a public API to trace
            // TraceEventType.Verbose or TraceEventType.Critical, meaning our
            // TraceLevel.Debug and TraceLevel.Fatal cannot be report directly.
            // Consequently, we translate Verbose to Trace.WriteLine and
            // Critical to TraceEventType.Error.
            // Windows Azure Diagnostics' TraceListener already translates
            // a WriteLine to a Verbose, so on Azure the Debug trace will be
            // handled properly.
            switch (level)
            {
                case TraceLevel.Off:
                    return;

                case TraceLevel.Debug:
                    System.Diagnostics.Trace.WriteLine(message);
                    return;

                case TraceLevel.Info:
                    System.Diagnostics.Trace.TraceInformation(message);
                    return;

                case TraceLevel.Warn:
                    System.Diagnostics.Trace.TraceWarning(message);
                    return;

                case TraceLevel.Error:
                case TraceLevel.Fatal:
                    System.Diagnostics.Trace.TraceError(message);
                    return;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.Tracing/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.Http.WebHost/GlobalConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.WebHost;
using System.Web.Http.WebHost.Routing;
using System.Web.Routing;

namespace System.Web.Http
{
    /// <summary>
    /// Provides a global <see cref="T:System.Web.Http.HttpConfiguration"/> for ASP.NET applications.
    /// </summary>
    public static class GlobalConfiguration
    {
        private static Lazy<HttpConfiguration> _configuration = CreateConfiguration();

        private static Lazy<HttpMessageHandler> _defaultHandler = CreateDefaultHandler();

        private static Lazy<HttpServer> _defaultServer = CreateDefaultServer();

        /// <summary>
        /// Gets the global <see cref="T:System.Web.Http.HttpConfiguration"/>.
        /// </summary>
        public static HttpConfiguration Configuration
        {
            get { return _configuration.Value; }
        }

        /// <summary>
        /// Gets the default message handler that will be called for all requests.
        /// </summary>
        public static HttpMessageHandler DefaultHandler
        {
            get { return _defaultHandler.Value; }
        }

        /// <summary>
        /// Gets the global <see cref="T:System.Web.Http.HttpServer"/>.
        /// </summary>
        public static HttpServer DefaultServer
        {
            get { return _defaultServer.Value; }
        }

        /// <summary>
        /// Performs configuration for <see cref="GlobalConfiguration.Configuration"/> and ensures that it is
        /// initialized.
        /// </summary>
        /// <param name="configurationCallback">The callback that will perform the configuration.</param>
        public static void Configure(Action<HttpConfiguration> configurationCallback)
        {
            if (configurationCallback == null)
            {
                throw new ArgumentNullException("configurationCallback");
            }

            configurationCallback.Invoke(Configuration);
            Configuration.EnsureInitialized();
        }

        internal static void Reset()
        {
            _configuration = CreateConfiguration();
            _defaultHandler = CreateDefaultHandler();
            _defaultServer = CreateDefaultServer();
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000",
            Justification = "It does not appear possible for this construction code to throw.")]
        private static Lazy<HttpConfiguration> CreateConfiguration()
        {
            return new Lazy<HttpConfiguration>(() =>
            {
                HttpConfiguration config = new HttpConfiguration(new HostedHttpRouteCollection(RouteTable.Routes));
                ServicesContainer services = config.Services;
                Contract.Assert(services != null);
                services.Replace(typeof(IAssembliesResolver), new WebHostAssembliesResolver());
                services.Replace(typeof(IHttpControllerTypeResolver), new WebHostHttpControllerTypeResolver());
                services.Replace(typeof(IHostBufferPolicySelector), new WebHostBufferPolicySelector());
                services.Replace(typeof(IExceptionHandler),
                    new WebHostExceptionHandler(services.GetExceptionHandler()));
                return config;
            });
        }

        private static Lazy<HttpMessageHandler> CreateDefaultHandler()
        {
            return new Lazy<HttpMessageHandler>(() => new HttpRoutingDispatcher(_configuration.Value));
        }

        private static Lazy<HttpServer> CreateDefaultServer()
        {
            return new Lazy<HttpServer>(() => new HttpServer(_configuration.Value, _defaultHandler.Value));
        }
    }
}

================================================
FILE: src/System.Web.Http.WebHost/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "These assemblies are delay-signed.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Justification = "Classes are grouped logically for user clarity.", Scope = "Namespace", Target = "System.Net.Http")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Justification = "Classes are grouped logically for user clarity.", Scope = "Namespace", Target = "System.Web.Http.WebHost")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Justification = "Classes are here so that they're shared with the main DLL's namespace", Scope = "Namespace", Target = "System.Web.Http")]
[assembly: SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Scope = "member", Target = "System.Web.Http.GlobalConfiguration.#.cctor()")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Http.WebHost.Routing", Justification = "This is the most logical namespace for this type.")]
[assembly: SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Scope = "member", Target = "System.Web.Http.WebHost.HttpControllerHandler.#.cctor()", Justification = "HttpServer is disposed by HttpMessageInvoker.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "Bufferless", Scope = "resource", Target = "System.Web.Http.WebHost.Properties.SRResources.resources", Justification = "The term Bufferless comes from the API")]


================================================
FILE: src/System.Web.Http.WebHost/HttpBatchContextWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Net.Http;
using System.Security.Principal;
using System.Web.Http.WebHost.Routing;

namespace System.Web.Http.WebHost
{
    internal class HttpBatchContextWrapper : HttpContextBase
    {
        private HttpRequestMessageWrapper _httpRequestWrapper;
        private HttpContextBase _httpContextBase;
        private Hashtable _items;

        public HttpBatchContextWrapper(HttpContextBase httpContext, HttpRequestMessage httpRequest)
        {
            _httpContextBase = httpContext;
            _items = new Hashtable();
            _httpRequestWrapper = new HttpRequestMessageWrapper(httpContext.Request.ApplicationPath, httpRequest);
        }

        public override HttpRequestBase Request
        {
            get { return _httpRequestWrapper; }
        }

        public override HttpResponseBase Response
        {
            get { return _httpContextBase.Response; }
        }

        public override IDictionary Items
        {
            get { return _items; }
        }

        public override IPrincipal User
        {
            get
            {
                return _httpContextBase.User;
            }
            set
            {
                _httpContextBase.User = value;
            }
        }
    }
}

================================================
FILE: src/System.Web.Http.WebHost/HttpControllerHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Runtime.ExceptionServices;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Configuration;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using System.Web.Http.WebHost.Properties;
using System.Web.Http.WebHost.Routing;
using System.Web.Routing;

namespace System.Web.Http.WebHost
{
    /// <summary>
    /// An <see cref="HttpTaskAsyncHandler"/> that uses an <see cref="HttpServer"/> to process ASP.NET requests asynchronously.
    /// </summary>
    [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "This class is a coordinator, so this coupling is expected.")]
    [SuppressMessage("Microsoft.Design", "CA1001:Implement IDisposable", Justification = "HttpMessageInvoker doesn’t have any resources of its own to dispose.")]
    public class HttpControllerHandler : HttpTaskAsyncHandler
    {
        // See Microsoft.Owin.Host.SystemWeb.
        internal static readonly string OwinEnvironmentHttpContextKey = "owin.Environment";

        internal static readonly string OwinEnvironmentKey = "MS_OwinEnvironment";

        private static readonly Lazy<Action<HttpContextBase>> _suppressRedirectAction =
            new Lazy<Action<HttpContextBase>>(
                () =>
                {
                    // If the behavior is explicitly disabled, do nothing
                    if (!SuppressFormsAuthRedirectHelper.GetEnabled(WebConfigurationManager.AppSettings))
                    {
                        return httpContext => { };
                    }

                    return httpContext => httpContext.Response.SuppressFormsAuthenticationRedirect = true;
                });

        private static readonly Lazy<IHostBufferPolicySelector> _bufferPolicySelector =
            new Lazy<IHostBufferPolicySelector>(() => GlobalConfiguration.Configuration.Services.GetHostBufferPolicySelector());

        private static readonly Lazy<IExceptionHandler> _exceptionHandler = new Lazy<IExceptionHandler>(() =>
            ExceptionServices.GetHandler(GlobalConfiguration.Configuration));
        private static readonly Lazy<IExceptionLogger> _exceptionLogger = new Lazy<IExceptionLogger>(() =>
            ExceptionServices.GetLogger(GlobalConfiguration.Configuration));

        private static readonly Func<HttpRequestMessage, X509Certificate2> _retrieveClientCertificate = new Func<HttpRequestMessage, X509Certificate2>(RetrieveClientCertificate);

        private readonly IHttpRouteData _routeData;
        private readonly HttpMessageInvoker _server;

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpControllerHandler"/> class.
        /// </summary>
        /// <param name="routeData">The route data.</param>
        public HttpControllerHandler(RouteData routeData)
            : this(routeData, GlobalConfiguration.DefaultServer)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpControllerHandler"/> class.
        /// </summary>
        /// <param name="routeData">The route data.</param>
        /// <param name="handler">The message handler to dispatch requests to.</param>
        public HttpControllerHandler(RouteData routeData, HttpMessageHandler handler)
        {
            if (routeData == null)
            {
                throw Error.ArgumentNull("routeData");
            }
            if (handler == null)
            {
                throw Error.ArgumentNull("handler");
            }

            _routeData = new HostedHttpRouteData(routeData);
            _server = new HttpMessageInvoker(handler);
        }

        public override Task ProcessRequestAsync(HttpContext context)
        {
            return ProcessRequestAsyncCore(new HttpContextWrapper(context));
        }

        internal async Task ProcessRequestAsyncCore(HttpContextBase contextBase)
        {
            HttpRequestMessage request = contextBase.GetHttpRequestMessage() ?? ConvertRequest(contextBase);

            // Add route data
            request.SetRouteData(_routeData);
            CancellationToken cancellationToken = contextBase.Response.GetClientDisconnectedTokenWhenFixed();
            HttpResponseMessage response = null;

            try
            {
                response = await _server.SendAsync(request, cancellationToken);
                await CopyResponseAsync(contextBase, request, response, _exceptionLogger.Value, _exceptionHandler.Value,
                    cancellationToken);
            }
            catch (OperationCanceledException)
            {
                // HttpTaskAsyncHandler treats a canceled task as an unhandled exception (logged to Application event
                // log). Instead of returning a canceled task, abort the request and return a completed task.
                contextBase.Request.Abort();
            }
            finally
            {
                // The other HttpTaskAsyncHandler is HttpRouteExceptionHandler; it has similar cleanup logic.
                request.DisposeRequestResources();
                request.Dispose();

                if (response != null)
                {
                    response.Dispose();
                }
            }
        }

        private static void CopyHeaders(HttpHeaders from, HttpContextBase to)
        {
            Contract.Assert(from != null);
            Contract.Assert(to != null);

            foreach (var header in from)
            {
                string name = header.Key;
                foreach (var value in header.Value)
                {
                    to.Response.AppendHeader(name, value);
                }
            }
        }

        private static void AddHeaderToHttpRequestMessage(HttpRequestMessage httpRequestMessage, string headerName, string[] headerValues)
        {
            Contract.Assert(httpRequestMessage != null);
            Contract.Assert(headerName != null);
            Contract.Assert(headerValues != null);

            if (!httpRequestMessage.Headers.TryAddWithoutValidation(headerName, headerValues))
            {
                httpRequestMessage.Content.Headers.TryAddWithoutValidation(headerName, headerValues);
            }
        }

        internal static async Task CopyResponseAsync(HttpContextBase httpContextBase, HttpRequestMessage request,
            HttpResponseMessage response, IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler,
            CancellationToken cancellationToken)
        {
            Contract.Assert(httpContextBase != null);
            Contract.Assert(request != null);

            // A null response creates a 500 with no content
            if (response == null)
            {
                SetEmptyErrorResponse(httpContextBase.Response);
                return;
            }

            if (!await CopyResponseStatusAndHeadersAsync(httpContextBase, request, response, exceptionLogger,
                cancellationToken))
            {
                return;
            }

            // TODO 335085: Consider this when coming up with our caching story
            if (response.Headers.CacheControl == null)
            {
                // DevDiv2 #332323. ASP.NET by default always emits a cache-control: private header.
                // However, we don't want requests to be cached by default.
                // If nobody set an explicit CacheControl then explicitly set to no-cache to override the
                // default behavior. This will cause the following response headers to be emitted:
                //     Cache-Control: no-cache
                //     Pragma: no-cache
                //     Expires: -1
                httpContextBase.Response.Cache.SetCacheability(HttpCacheability.NoCache);
            }

            // Asynchronously write the response body.  If there is no body, we use
            // a completed task to share the Finally() below.
            // The response-writing task will not fault -- it handles errors internally.
            if (response.Content != null)
            {
                await WriteResponseContentAsync(httpContextBase, request, response, exceptionLogger, exceptionHandler, cancellationToken);
            }
        }

        internal static HttpRequestMessage ConvertRequest(HttpContextBase httpContextBase)
        {
            return ConvertRequest(httpContextBase, _bufferPolicySelector.Value);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller becomes owner")]
        internal static HttpRequestMessage ConvertRequest(HttpContextBase httpContextBase, IHostBufferPolicySelector policySelector)
        {
            Contract.Assert(httpContextBase != null);

            HttpRequestBase requestBase = httpContextBase.Request;
            HttpMethod method = HttpMethodHelper.GetHttpMethod(requestBase.HttpMethod);
            Uri uri = requestBase.Url;
            HttpRequestMessage request = new HttpRequestMessage(method, uri);

            // Choose a buffered or bufferless input stream based on user's policy
            bool bufferInput = policySelector == null ? true : policySelector.UseBufferedInputStream(httpContextBase);
            request.Content = GetStreamContent(requestBase, bufferInput);

            foreach (string headerName in requestBase.Headers)
            {
                string[] values = requestBase.Headers.GetValues(headerName);
                AddHeaderToHttpRequestMessage(request, headerName, values);
            }

            // Add context to enable route lookup later on
            request.SetHttpContext(httpContextBase);

            HttpRequestContext requestContext = new WebHostHttpRequestContext(httpContextBase, requestBase, request);
            request.SetRequestContext(requestContext);

            IDictionary httpContextItems = httpContextBase.Items;

            // Add the OWIN environment, when available (such as when using the OWIN integrated pipeline HTTP module).
            if (httpContextItems != null && httpContextItems.Contains(OwinEnvironmentHttpContextKey))
            {
                request.Properties.Add(OwinEnvironmentKey, httpContextItems[OwinEnvironmentHttpContextKey]);
            }

            // The following three properties are set for backwards compatibility only. The request context controls
            // the behavior for all cases except when accessing the property directly by key.

            // Add the retrieve client certificate delegate to the property bag to enable lookup later on
            request.Properties.Add(HttpPropertyKeys.RetrieveClientCertificateDelegateKey, _retrieveClientCertificate);

            // Add information about whether the request is local or not
            request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy<bool>(() => requestBase.IsLocal));

            // Add information about whether custom errors are enabled for this request or not
            request.Properties.Add(HttpPropertyKeys.IncludeErrorDetailKey, new Lazy<bool>(() => !httpContextBase.IsCustomErrorEnabled));

            return request;
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Caller becomes owner")]
        private static HttpContent GetStreamContent(HttpRequestBase requestBase, bool bufferInput)
        {
            if (bufferInput)
            {
                return new LazyStreamContent(() =>
                {
                    if (requestBase.ReadEntityBodyMode == ReadEntityBodyMode.None)
                    {
                        return new SeekableBufferedRequestStream(requestBase);
                    }
                    else if (requestBase.ReadEntityBodyMode == ReadEntityBodyMode.Classic)
                    {
                        requestBase.InputStream.Position = 0;
                        return requestBase.InputStream;
                    }
                    else if (requestBase.ReadEntityBodyMode == ReadEntityBodyMode.Buffered)
                    {
                        if (requestBase.GetBufferedInputStream().Position > 0)
                        {
                            // If GetBufferedInputStream() was completely read, we can continue accessing it via Request.InputStream.
                            // If it was partially read, accessing InputStream will throw, but at that point we have no
                            // way of recovering.
                            requestBase.InputStream.Position = 0;
                            return requestBase.InputStream;
                        }
                        return new SeekableBufferedRequestStream(requestBase);
                    }
                    else
                    {
                        Contract.Assert(requestBase.ReadEntityBodyMode == ReadEntityBodyMode.Bufferless);
                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                          SRResources.RequestBodyAlreadyReadInMode,
                                                                          ReadEntityBodyMode.Bufferless));
                    }
                });
            }
            else
            {
                return new LazyStreamContent(() =>
                {
                    if (requestBase.ReadEntityBodyMode == ReadEntityBodyMode.None)
                    {
                        return requestBase.GetBufferlessInputStream();
                    }
                    else if (requestBase.ReadEntityBodyMode == ReadEntityBodyMode.Classic)
                    {
                        // The user intended that the request be read in a bufferless manner, but we are starting with a buffered stream.
                        // To maintain compatibility with legacy behavior, we'll throw in this case.
                        throw new InvalidOperationException(SRResources.RequestStreamCannotBeReadBufferless);
                    }
                    else if (requestBase.ReadEntityBodyMode == ReadEntityBodyMode.Bufferless)
                    {
                        Stream bufferlessInputStream = requestBase.GetBufferlessInputStream();
                        if (bufferlessInputStream.Position > 0)
                        {
                            throw new InvalidOperationException(SRResources.RequestBodyAlreadyRead);
                        }
                        return bufferlessInputStream;
                    }
                    else
                    {
                        Contract.Assert(requestBase.ReadEntityBodyMode == ReadEntityBodyMode.Buffered);
                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SRResources.RequestBodyAlreadyReadInMode, ReadEntityBodyMode.Buffered));
                    }
                });
            }
        }

        /// <summary>
        /// Prevents the <see cref="T:System.Web.Security.FormsAuthenticationModule"/> from altering a 401 response to 302 by
        /// setting <see cref="P:System.Web.HttpResponseBase.SuppressFormsAuthenticationRedirect" /> to <c>true</c> if available.
        /// </summary>
        /// <param name="httpContextBase">The HTTP context base.</param>
        internal static void EnsureSuppressFormsAuthenticationRedirect(HttpContextBase httpContextBase)
        {
            Contract.Assert(httpContextBase != null);

            // Only if the response is status code is 401
            if (httpContextBase.Response.StatusCode == (int)HttpStatusCode.Unauthorized)
            {
                _suppressRedirectAction.Value(httpContextBase);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "unused", Justification = "unused variable necessary to call getter")]
        private static Task WriteResponseContentAsync(HttpContextBase httpContextBase, HttpRequestMessage request,
            HttpResponseMessage response, IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler,
            CancellationToken cancellationToken)
        {
            Contract.Assert(httpContextBase != null);
            Contract.Assert(response != null);
            Contract.Assert(request != null);
            Contract.Assert(response.Content != null);

            HttpResponseBase httpResponseBase = httpContextBase.Response;
            HttpContent responseContent = response.Content;

            CopyHeaders(responseContent.Headers, httpContextBase);

            // PrepareHeadersAsync already evaluated the buffer policy.
            bool isBuffered = httpResponseBase.BufferOutput;

            return isBuffered
                    ? WriteBufferedResponseContentAsync(httpContextBase, request, response, exceptionLogger, exceptionHandler, cancellationToken)
                    : WriteStreamedResponseContentAsync(httpContextBase, request, response, exceptionLogger, cancellationToken);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "All exceptions caught here become error responses")]
        internal static async Task WriteStreamedResponseContentAsync(HttpContextBase httpContextBase,
            HttpRequestMessage request, HttpResponseMessage response, IExceptionLogger exceptionLogger,
            CancellationToken cancellationToken)
        {
            Contract.Assert(httpContextBase != null);
            Contract.Assert(httpContextBase.Response != null);
            Contract.Assert(request != null);
            Contract.Assert(response != null);
            Contract.Assert(response.Content != null);

            Exception exception = null;
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                // Copy the HttpContent into the output stream asynchronously.
                await response.Content.CopyToAsync(httpContextBase.Response.OutputStream);
                return;
            }
            catch (OperationCanceledException)
            {
                // Propogate the canceled task without calling exception loggers.
                throw;
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            Contract.Assert(exception != null);

            ExceptionContextCatchBlock catchBlock = WebHostExceptionCatchBlocks.HttpControllerHandlerStreamContent;
            ExceptionContext exceptionContext = new ExceptionContext(exception, catchBlock, request, response);
            await exceptionLogger.LogAsync(exceptionContext, cancellationToken);

            // Streamed content may have been written and cannot be recalled.
            // Our only choice is to abort the connection.
            httpContextBase.Request.Abort();
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "continuation task owned by caller")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "All exceptions caught here become error responses")]
        internal static async Task WriteBufferedResponseContentAsync(HttpContextBase httpContextBase,
            HttpRequestMessage request, HttpResponseMessage response, IExceptionLogger exceptionLogger,
            IExceptionHandler exceptionHandler, CancellationToken cancellationToken)
        {
            Contract.Assert(httpContextBase != null);
            Contract.Assert(httpContextBase.Response != null);
            Contract.Assert(request != null);
            Contract.Assert(response != null);
            Contract.Assert(response.Content != null);

            HttpResponseBase httpResponseBase = httpContextBase.Response;

            // Return a task that writes the response body asynchronously.
            // We guarantee we will handle all error responses internally
            // and always return a non-faulted task, except for custom error handlers that choose to propagate these
            // exceptions.
            ExceptionDispatchInfo exceptionInfo;
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                // Copy the HttpContent into the output stream asynchronously.
                await response.Content.CopyToAsync(httpResponseBase.OutputStream);
                return;
            }
            catch (OperationCanceledException)
            {
                // Propogate the canceled task without calling exception loggers or handlers.
                throw;
            }
            catch (Exception exception)
            {
                // Can't use await inside a catch block
                exceptionInfo = ExceptionDispatchInfo.Capture(exception);
            }

            Debug.Assert(exceptionInfo.SourceException != null);

            // If we were using a buffered stream, we can still set the headers and status code, and we can create an
            // error response with the exception.
            // We create a continuation task to write an error response that will run after returning from this Catch()
            // but before other continuations the caller appends to this task.
            // The error response writing task handles errors internally and will not show as faulted, except for
            // custom error handlers that choose to propagate these exceptions.
            ExceptionContextCatchBlock catchBlock = WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent;

            if (!await CopyErrorResponseAsync(catchBlock, httpContextBase, request, response,
                exceptionInfo.SourceException, exceptionLogger, exceptionHandler, cancellationToken))
            {
                exceptionInfo.Throw();
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "All exceptions caught here become error responses")]
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "errorResponse gets disposed in the async continuation")]
        internal static async Task<bool> CopyErrorResponseAsync(ExceptionContextCatchBlock catchBlock,
            HttpContextBase httpContextBase, HttpRequestMessage request, HttpResponseMessage response,
            Exception exception, IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler,
            CancellationToken cancellationToken)
        {
            Contract.Assert(httpContextBase != null);
            Contract.Assert(httpContextBase.Response != null);
            Contract.Assert(request != null);
            Contract.Assert(exception != null);
            Contract.Assert(catchBlock != null);
            Contract.Assert(catchBlock.CallsHandler);

            HttpResponseBase httpResponseBase = httpContextBase.Response;
            HttpResponseMessage errorResponse = null;
            HttpResponseException responseException = exception as HttpResponseException;

            // Ensure all headers and content are cleared to eliminate any partial results.
            ClearContentAndHeaders(httpResponseBase);

            // If the exception we are handling is HttpResponseException,
            // that becomes the error response.
            if (responseException != null)
            {
                errorResponse = responseException.Response;
            }
            else
            {
                ExceptionContext exceptionContext = new ExceptionContext(exception, catchBlock, request)
                {
                    Response = response
                };
                await exceptionLogger.LogAsync(exceptionContext, cancellationToken);
                errorResponse = await exceptionHandler.HandleAsync(exceptionContext, cancellationToken);

                if (errorResponse == null)
                {
                    return false;
                }
            }

            Contract.Assert(errorResponse != null);
            if (!await CopyResponseStatusAndHeadersAsync(httpContextBase, request, errorResponse, exceptionLogger,
                cancellationToken))
            {
                // Don't rethrow the original exception unless explicitly requested to do so. In this case, the
                // exception handler indicated it wanted to handle the exception; it simply failed create a stable
                // response to send.
                return true;
            }

            // The error response may return a null content if content negotiation
            // fails to find a formatter, or this may be an HttpResponseException without
            // content.  In either case, cleanup and return a completed task.

            if (errorResponse.Content == null)
            {
                errorResponse.Dispose();
                return true;
            }

            CopyHeaders(errorResponse.Content.Headers, httpContextBase);

            await WriteErrorResponseContentAsync(httpResponseBase, request, errorResponse, cancellationToken,
                exceptionLogger);
            return true;
        }

        private static async Task WriteErrorResponseContentAsync(HttpResponseBase httpResponseBase,
            HttpRequestMessage request, HttpResponseMessage errorResponse, CancellationToken cancellationToken,
            IExceptionLogger exceptionLogger)
        {
            HttpRequestMessage ignoreUnused = request;

            try
            {
                Exception exception = null;
                cancellationToken.ThrowIfCancellationRequested();

                try
                {
                    // Asynchronously write the content of the new error HttpResponseMessage
                    await errorResponse.Content.CopyToAsync(httpResponseBase.OutputStream);
                    return;
                }
                catch (OperationCanceledException)
                {
                    // Propogate the canceled task without calling exception loggers.
                    throw;
                }
                catch (Exception ex)
                {
                    exception = ex;
                }

                Contract.Assert(exception != null);

                ExceptionContext exceptionContext = new ExceptionContext(exception,
                    WebHostExceptionCatchBlocks.HttpControllerHandlerBufferError, request, errorResponse);
                await exceptionLogger.LogAsync(exceptionContext, cancellationToken);

                // Failure writing the error response.  Likely cause is a formatter
                // serialization exception.  Create empty error response and
                // return a non-faulted task.
                SetEmptyErrorResponse(httpResponseBase);
            }
            finally
            {
                // Dispose the temporary HttpResponseMessage carrying the error response
                errorResponse.Dispose();
            }
        }

        private static async Task<bool> CopyResponseStatusAndHeadersAsync(HttpContextBase httpContextBase,
            HttpRequestMessage request, HttpResponseMessage response, IExceptionLogger exceptionLogger,
            CancellationToken cancellationToken)
        {
            Contract.Assert(httpContextBase != null);
            HttpResponseBase httpResponseBase = httpContextBase.Response;
            httpResponseBase.StatusCode = (int)response.StatusCode;
            httpResponseBase.StatusDescription = response.ReasonPhrase;
            httpResponseBase.TrySkipIisCustomErrors = true;
            EnsureSuppressFormsAuthenticationRedirect(httpContextBase);

            if (!await PrepareHeadersAsync(httpResponseBase, request, response, exceptionLogger, cancellationToken))
            {
                return false;
            }

            CopyHeaders(response.Headers, httpContextBase);
            return true;
        }

        // Prepares Content-Length and Transfer-Encoding headers.
        [SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "unused", Justification = "unused variable necessary to call getter")]
        internal static async Task<bool> PrepareHeadersAsync(HttpResponseBase responseBase, HttpRequestMessage request,
            HttpResponseMessage response, IExceptionLogger exceptionLogger, CancellationToken cancellationToken)
        {
            Contract.Assert(response != null);
            HttpResponseHeaders responseHeaders = response.Headers;
            Contract.Assert(responseHeaders != null);
            HttpContent content = response.Content;
            bool isTransferEncodingChunked = responseHeaders.TransferEncodingChunked == true;
            HttpHeaderValueCollection<TransferCodingHeaderValue> transferEncoding = responseHeaders.TransferEncoding;

            if (content != null)
            {
                HttpContentHeaders contentHeaders = content.Headers;
                Contract.Assert(contentHeaders != null);

                if (isTransferEncodingChunked)
                {
                    // According to section 4.4 of the HTTP 1.1 spec, HTTP responses that use chunked transfer
                    // encoding must not have a content length set. Chunked should take precedence over content
                    // length in this case because chunked is always set explicitly by users while the Content-Length
                    // header can be added implicitly by System.Net.Http.
                    contentHeaders.ContentLength = null;
                }
                else
                {
                    Exception exception = null;

                    // Copy the response content headers only after ensuring they are complete.
                    // We ask for Content-Length first because HttpContent lazily computes this
                    // and only afterwards writes the value into the content headers.
                    try
                    {
                        var unused = contentHeaders.ContentLength;
                    }
                    catch (Exception ex)
                    {
                        exception = ex;
                    }

                    if (exception != null)
                    {
                        ExceptionContext exceptionContext = new ExceptionContext(exception,
                            WebHostExceptionCatchBlocks.HttpControllerHandlerComputeContentLength, request, response);
                        await exceptionLogger.LogAsync(exceptionContext, cancellationToken);

                        SetEmptyErrorResponse(responseBase);
                        return false;
                    }
                }

                // Select output buffering based on the user-controlled buffering policy
                bool isBuffered = _bufferPolicySelector.Value != null ?
                    _bufferPolicySelector.Value.UseBufferedOutputStream(response) : true;
                responseBase.BufferOutput = isBuffered;
            }

            // Ignore the Transfer-Encoding header if it is just "chunked"; the host will provide it when no
            // Content-Length is present and BufferOutput is disabled (and this method guarantees those conditions).
            // HttpClient sets this header when it receives chunked content, but HttpContent does not include the
            // frames. The ASP.NET contract is to set this header only when writing chunked frames to the stream.
            // A Web API caller who desires custom framing would need to do a different Transfer-Encoding (such as
            // "identity, chunked").
            if (isTransferEncodingChunked && transferEncoding.Count == 1)
            {
                transferEncoding.Clear();

                // In the case of a conflict between a Transfer-Encoding: chunked header and the output buffering
                // policy, honor the Transnfer-Encoding: chunked header and ignore the buffer policy.
                // If output buffering is not disabled, ASP.NET will not write the TransferEncoding: chunked header.
                responseBase.BufferOutput = false;
            }

            return true;
        }

        private static void ClearContentAndHeaders(HttpResponseBase httpResponseBase)
        {
            httpResponseBase.Clear();

            // Despite what the documentation indicates, calling Clear on its own doesn't fully clear the headers.
            httpResponseBase.ClearHeaders();
        }

        private static void SetEmptyErrorResponse(HttpResponseBase httpResponseBase)
        {
            ClearContentAndHeaders(httpResponseBase);
            httpResponseBase.StatusCode = (int)HttpStatusCode.InternalServerError;
            httpResponseBase.SuppressContent = true;
        }

        private static X509Certificate2 RetrieveClientCertificate(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            X509Certificate2 result = null;

            HttpContextBase httpContextBase = request.GetHttpContext();
            if (httpContextBase != null)
            {
                if (httpContextBase.Request.ClientCertificate.Certificate != null && httpContextBase.Request.ClientCertificate.Certificate.Length > 0)
                {
                    result = new X509Certificate2(httpContextBase.Request.ClientCertificate.Certificate);
                }
            }

            return result;
        }

        private class DelegatingStreamContent : StreamContent
        {
            public DelegatingStreamContent(Stream stream)
                : base(stream)
            {
            }

            public Task WriteToStreamAsync(Stream stream, TransportContext context)
            {
                return SerializeToStreamAsync(stream, context);
            }

            public Task<Stream> GetContentReadStreamAsync()
            {
                return CreateContentReadStreamAsync();
            }

            protected override bool TryComputeLength(out long length)
            {
                // Do not attempt to calculate length because SeekableBufferedRequestStream (for example)
                // may report 0 until the underlying Stream has been read to end.
                length = 0L;
                return false;
            }
        }

        private class LazyStreamContent : HttpContent
        {
            private readonly Func<Stream> _getStream;
            private DelegatingStreamContent _streamContent;

            public LazyStreamContent(Func<Stream> getStream)
            {
                _getStream = getStream;
            }

            private DelegatingStreamContent StreamContent
            {
                get
                {
                    if (_streamContent == null)
                    {
                        _streamContent = new DelegatingStreamContent(_getStream());
                    }
                    return _streamContent;
                }
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return StreamContent.WriteToStreamAsync(stream, context);
            }

            protected override Task<Stream> CreateContentReadStreamAsync()
            {
                return StreamContent.GetContentReadStreamAsync();
            }

            protected override bool TryComputeLength(out long length)
            {
                // Do not attempt to calculate length because SeekableBufferedRequestStream (for example)
                // may report 0 until the underlying Stream has been read to end.
                length = 0L;
                return false;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/HttpControllerRouteHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;

namespace System.Web.Http.WebHost
{
    /// <summary>
    /// A <see cref="IRouteHandler"/> that returns instances of <see cref="HttpControllerHandler"/> that
    /// can pass requests to a given <see cref="HttpServer"/> instance.
    /// </summary>
    public class HttpControllerRouteHandler : IRouteHandler
    {
        private static readonly Lazy<HttpControllerRouteHandler> _instance =
            new Lazy<HttpControllerRouteHandler>(() => new HttpControllerRouteHandler(), isThreadSafe: true);

        /// <summary>
        /// Initializes a new instance of the <see cref="HttpControllerRouteHandler"/> class.
        /// </summary>
        protected HttpControllerRouteHandler()
        {
        }

        /// <summary>
        /// Gets the singleton <see cref="HttpControllerRouteHandler"/> instance.
        /// </summary>
        public static HttpControllerRouteHandler Instance
        {
            get { return _instance.Value; }
        }

        /// <summary>
        /// Provides the object that processes the request.
        /// </summary>
        /// <param name="requestContext">An object that encapsulates information about the request.</param>
        /// <returns>
        /// An object that processes the request.
        /// </returns>
        IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext)
        {
            return GetHttpHandler(requestContext);
        }

        /// <summary>
        /// Provides the object that processes the request.
        /// </summary>
        /// <param name="requestContext">An object that encapsulates information about the request.</param>
        /// <returns>
        /// An object that processes the request.
        /// </returns>
        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            return new HttpControllerHandler(requestContext.RouteData);
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/HttpControllerTypeCacheSerializer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web.Http.Dispatcher;
using System.Web.Http.WebHost.Properties;
using System.Xml;

namespace System.Web.Http.WebHost
{
    // Processes files with this format:
    //
    // <typeCache lastModified=... mvcVersionId=...>
    //   <assembly name=...>
    //     <module versionId=...>
    //       <type>...</type>
    //     </module>
    //   </assembly>
    // </typeCache>
    //
    // This is used to store caches of files between AppDomain resets, leading to improved cold boot time
    // and more efficient use of memory.

    /// <summary>
    /// Manages serializing and deserializing the cache managed by <see cref="HttpControllerTypeCache"/>.
    /// </summary>
    internal sealed class HttpControllerTypeCacheSerializer
    {
        private static readonly Guid _mvcVersionId = typeof(HttpControllerTypeCacheSerializer).Module.ModuleVersionId;

        // used for unit testing

        private DateTime CurrentDate
        {
            get { return CurrentDateOverride ?? DateTime.Now; }
        }

        internal DateTime? CurrentDateOverride { get; set; }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is an instance method for consistency with the SerializeTypes() method.")]
        public ICollection<Type> DeserializeTypes(TextReader input)
        {
            // DevDiv: 314059: TypeCacheSerializer should use regular serialization instead of DOM
            XmlDocument doc = new XmlDocument();
            doc.Load(input);
            XmlElement rootElement = doc.DocumentElement;

            Guid readMvcVersionId = new Guid(rootElement.Attributes["mvcVersionId"].Value);
            if (readMvcVersionId != _mvcVersionId)
            {
                // The cache is outdated because the cache file was produced by a different version
                // of MVC.
                return null;
            }

            List<Type> deserializedTypes = new List<Type>();
            foreach (XmlNode assemblyNode in rootElement.ChildNodes)
            {
                string assemblyName = assemblyNode.Attributes["name"].Value;
                Assembly assembly = Assembly.Load(assemblyName);

                foreach (XmlNode moduleNode in assemblyNode.ChildNodes)
                {
                    Guid moduleVersionId = new Guid(moduleNode.Attributes["versionId"].Value);

                    foreach (XmlNode typeNode in moduleNode.ChildNodes)
                    {
                        string typeName = typeNode.InnerText;
                        Type type = assembly.GetType(typeName);
                        if (type == null || type.Module.ModuleVersionId != moduleVersionId)
                        {
                            // The cache is outdated because we couldn't find a previously recorded
                            // type or the type's containing module was modified.
                            return null;
                        }
                        else
                        {
                            deserializedTypes.Add(type);
                        }
                    }
                }
            }

            return deserializedTypes;
        }

        public void SerializeTypes(IEnumerable<Type> types, TextWriter output)
        {
            var groupedByAssembly = from type in types
                                    group type by type.Module
                                    into groupedByModule
                                    group groupedByModule by groupedByModule.Key.Assembly;

            XmlDocument doc = new XmlDocument();
            doc.AppendChild(doc.CreateComment(SRResources.TypeCache_DoNotModify));

            XmlElement typeCacheElement = doc.CreateElement("typeCache");
            doc.AppendChild(typeCacheElement);
            typeCacheElement.SetAttribute("lastModified", CurrentDate.ToString(CultureInfo.InvariantCulture));
            typeCacheElement.SetAttribute("mvcVersionId", _mvcVersionId.ToString());

            foreach (var assemblyGroup in groupedByAssembly)
            {
                XmlElement assemblyElement = doc.CreateElement("assembly");
                typeCacheElement.AppendChild(assemblyElement);
                assemblyElement.SetAttribute("name", assemblyGroup.Key.FullName);

                foreach (var moduleGroup in assemblyGroup)
                {
                    XmlElement moduleElement = doc.CreateElement("module");
                    assemblyElement.AppendChild(moduleElement);
                    moduleElement.SetAttribute("versionId", moduleGroup.Key.ModuleVersionId.ToString());

                    foreach (Type type in moduleGroup)
                    {
                        XmlElement typeElement = doc.CreateElement("type");
                        moduleElement.AppendChild(typeElement);
                        typeElement.AppendChild(doc.CreateTextNode(type.FullName));
                    }
                }
            }

            doc.Save(output);
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/HttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;

namespace System.Web.Http.WebHost
{
    internal static class HttpRequestMessageExtensions
    {
        private const string HttpContextBaseKey = "MS_HttpContext";
        private const string HttpBatchContextKey = "MS_HttpBatchContext";

        public static HttpContextBase GetHttpContext(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            HttpContextBase context;

            if (request.IsBatchRequest())
            {
                if (!request.Properties.TryGetValue(HttpBatchContextKey, out context))
                {
                    if (request.Properties.TryGetValue(HttpContextBaseKey, out context))
                    {
                        context = new HttpBatchContextWrapper(context, request);
                        request.Properties[HttpBatchContextKey] = context;
                    }
                    else
                    {
                        context = null;
                    }
                }
            }
            else if (!request.Properties.TryGetValue(HttpContextBaseKey, out context))
            {
                context = null;
            }

            return context;
        }

        public static void SetHttpContext(this HttpRequestMessage request, HttpContextBase context)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            request.Properties[HttpContextBaseKey] = context;
        }
    }
}

================================================
FILE: src/System.Web.Http.WebHost/HttpResponseBaseExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Threading;

namespace System.Web.Http.WebHost
{
    internal static class HttpResponseBaseExtensions
    {
        private static readonly bool _isSystemWebVersion451OrGreater = IsSystemWebVersion451OrGreater();
        private static readonly bool _isClientDisconnectedTokenAvailable = IsClientDisconnectedTokenAvailable();

        public static CancellationToken GetClientDisconnectedTokenWhenFixed(this HttpResponseBase response)
        {
            if (response == null)
            {
                throw new ArgumentNullException("response");
            }

            // On some platforms/configurations, accessing response.ClientDisconnectedToken would always throw.
            // Also, on .NET 4.5 and earlier, using response.ClientDisconnectedToken can cause application crashes.
            // Gracefully degrade to CancellationToken.None unless ClientDisconnectedToken is both available and
            // reliable.
            if (!_isClientDisconnectedTokenAvailable || !_isSystemWebVersion451OrGreater)
            {
                return CancellationToken.None;
            }

            return response.ClientDisconnectedToken;
        }

        private static bool IsClientDisconnectedTokenAvailable()
        {
            // Accessing HttpResponse.ClientDisconnectedToken throws PlatformNotSupportedException unless both:
            // 1) Using IIS 7.5 or newer, and
            // 2) Using integrated pipeline
            Version iis75 = new Version(7, 5);
            Version iisVersion = HttpRuntime.IISVersion;
            return iisVersion != null && iisVersion >= iis75 && HttpRuntime.UsingIntegratedPipeline;
        }

        private static bool IsSystemWebVersion451OrGreater()
        {
            Assembly systemWeb = typeof(HttpContextBase).Assembly;
            // System.Web.AspNetEventSource only exists in .NET 4.5.1 and will not be back-ported to .NET 4.5.
            return systemWeb.GetType("System.Web.AspNetEventSource") != null;
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;

namespace System.Web.Http.WebHost
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    [Obsolete("Use of this type is not recommended because it no longer has initialization logic.")]
    public static class PreApplicationStartCode
    {
        private static bool _startWasCalled;

        public static void Start()
        {
            // Guard against multiple calls. All Start calls are made on same thread, so no lock needed here
            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            // We need to keep this for App-Compat reasons. Prior to 4.5 we registered a module here.
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using System.Web.Http.WebHost;

[assembly: AssemblyTitle("System.Web.Http.WebHost")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.Http.WebHost.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/System.Web.Http.WebHost/Properties/SRResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.34003
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http.WebHost.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class SRResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal SRResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.WebHost.Properties.SRResources", typeof(SRResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to read the entity body. A portion of the request stream has already been read..
        /// </summary>
        internal static string RequestBodyAlreadyRead {
            get {
                return ResourceManager.GetString("RequestBodyAlreadyRead", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to read the entity body. The request stream has already been read in &apos;{0}&apos; mode..
        /// </summary>
        internal static string RequestBodyAlreadyReadInMode {
            get {
                return ResourceManager.GetString("RequestBodyAlreadyReadInMode", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to read the entity body in Bufferless mode. The request stream has already been buffered..
        /// </summary>
        internal static string RequestStreamCannotBeReadBufferless {
            get {
                return ResourceManager.GetString("RequestStreamCannotBeReadBufferless", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constraint entry &apos;{0}&apos; on the route with route template &apos;{1}&apos; must have a string value or be of a type which implements &apos;{2}&apos; or &apos;{3}&apos;..
        /// </summary>
        internal static string Route_ValidationMustBeStringOrCustomConstraint {
            get {
                return ResourceManager.GetString("Route_ValidationMustBeStringOrCustomConstraint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This operation is not supported by &apos;{0}&apos;..
        /// </summary>
        internal static string RouteCollectionNotSupported {
            get {
                return ResourceManager.GetString("RouteCollectionNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The index cannot be less than 0 or equal to or larger than the number of items in the collection..
        /// </summary>
        internal static string RouteCollectionOutOfRange {
            get {
                return ResourceManager.GetString("RouteCollectionOutOfRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This operation is only supported by directly calling it on &apos;{0}&apos;..
        /// </summary>
        internal static string RouteCollectionUseDirectly {
            get {
                return ResourceManager.GetString("RouteCollectionUseDirectly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; type failed to serialize the response body..
        /// </summary>
        internal static string Serialize_Response_Failed {
            get {
                return ResourceManager.GetString("Serialize_Response_Failed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; type failed to serialize the response body for content type &apos;{1}&apos;..
        /// </summary>
        internal static string Serialize_Response_Failed_MediaType {
            get {
                return ResourceManager.GetString("Serialize_Response_Failed_MediaType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This file is automatically generated. Please do not modify the contents of this file..
        /// </summary>
        internal static string TypeCache_DoNotModify {
            get {
                return ResourceManager.GetString("TypeCache_DoNotModify", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}.{1} must not be null..
        /// </summary>
        internal static string TypePropertyMustNotBeNull {
            get {
                return ResourceManager.GetString("TypePropertyMustNotBeNull", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Properties/SRResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="RequestBodyAlreadyRead" xml:space="preserve">
    <value>Unable to read the entity body. A portion of the request stream has already been read.</value>
  </data>
  <data name="RequestBodyAlreadyReadInMode" xml:space="preserve">
    <value>Unable to read the entity body. The request stream has already been read in '{0}' mode.</value>
  </data>
  <data name="RequestStreamCannotBeReadBufferless" xml:space="preserve">
    <value>Unable to read the entity body in Bufferless mode. The request stream has already been buffered.</value>
  </data>
  <data name="RouteCollectionNotSupported" xml:space="preserve">
    <value>This operation is not supported by '{0}'.</value>
  </data>
  <data name="RouteCollectionOutOfRange" xml:space="preserve">
    <value>The index cannot be less than 0 or equal to or larger than the number of items in the collection.</value>
  </data>
  <data name="RouteCollectionUseDirectly" xml:space="preserve">
    <value>This operation is only supported by directly calling it on '{0}'.</value>
  </data>
  <data name="Route_ValidationMustBeStringOrCustomConstraint" xml:space="preserve">
    <value>The constraint entry '{0}' on the route with route template '{1}' must have a string value or be of a type which implements '{2}' or '{3}'.</value>
  </data>
  <data name="Serialize_Response_Failed" xml:space="preserve">
    <value>The '{0}' type failed to serialize the response body.</value>
  </data>
  <data name="Serialize_Response_Failed_MediaType" xml:space="preserve">
    <value>The '{0}' type failed to serialize the response body for content type '{1}'.</value>
  </data>
  <data name="TypeCache_DoNotModify" xml:space="preserve">
    <value>This file is automatically generated. Please do not modify the contents of this file.</value>
  </data>
  <data name="TypePropertyMustNotBeNull" xml:space="preserve">
    <value>{0}.{1} must not be null.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Http.WebHost/RouteCollectionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Net.Http;
using System.Web.Http.Routing;
using System.Web.Http.WebHost.Routing;
using System.Web.Routing;

namespace System.Web.Http
{
    /// <summary>
    /// Extension methods for <see cref="RouteCollection"/>
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class RouteCollectionExtensions
    {
        /// <summary>
        /// Maps the specified route template.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static Route MapHttpRoute(this RouteCollection routes, string name, string routeTemplate)
        {
            return MapHttpRoute(routes, name, routeTemplate, defaults: null, constraints: null, handler: null);
        }

        /// <summary>
        /// Maps the specified route template and sets default constraints, and namespaces.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static Route MapHttpRoute(this RouteCollection routes, string name, string routeTemplate, object defaults)
        {
            return MapHttpRoute(routes, name, routeTemplate, defaults, constraints: null, handler: null);
        }

        /// <summary>
        /// Maps the specified route template and sets default route values, constraints, and namespaces.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <param name="constraints">A set of expressions that specify values for <paramref name="routeTemplate"/>.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static Route MapHttpRoute(this RouteCollection routes, string name, string routeTemplate, object defaults, object constraints)
        {
            return MapHttpRoute(routes, name, routeTemplate, defaults, constraints, handler: null);
        }

        /// <summary>
        /// Maps the specified route template and sets default route values, constraints, namespaces, and end-point message handler.
        /// </summary>
        /// <param name="routes">A collection of routes for the application.</param>
        /// <param name="name">The name of the route to map.</param>
        /// <param name="routeTemplate">The route template for the route.</param>
        /// <param name="defaults">An object that contains default route values.</param>
        /// <param name="constraints">A set of expressions that specify values for <paramref name="routeTemplate"/>.</param>
        /// <param name="handler">The handler to which the request will be dispatched.</param>
        /// <returns>A reference to the mapped route.</returns>
        public static Route MapHttpRoute(this RouteCollection routes, string name, string routeTemplate, object defaults, object constraints, HttpMessageHandler handler)
        {
            if (routes == null)
            {
                throw Error.ArgumentNull("routes");
            }

            HttpRouteValueDictionary defaultsDictionary = new HttpRouteValueDictionary(defaults);
            HttpRouteValueDictionary constraintsDictionary = new HttpRouteValueDictionary(constraints);
            HostedHttpRoute httpRoute = (HostedHttpRoute)GlobalConfiguration.Configuration.Routes.CreateRoute(routeTemplate, defaultsDictionary, constraintsDictionary, dataTokens: null, handler: handler);
            Route route = httpRoute.OriginalRoute;
            routes.Add(name, route);
            return route;
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HostedHttpRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Routing;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    internal class HostedHttpRoute : IHttpRoute
    {
        public HostedHttpRoute(string uriTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> dataTokens, HttpMessageHandler handler)
        {
            RouteValueDictionary routeDefaults = defaults != null ? new RouteValueDictionary(defaults) : null;
            RouteValueDictionary routeConstraints = constraints != null ? new RouteValueDictionary(constraints) : null;
            RouteValueDictionary routeDataTokens = dataTokens != null ? new RouteValueDictionary(dataTokens) : null;
            OriginalRoute = new HttpWebRoute(uriTemplate, routeDefaults, routeConstraints, routeDataTokens, HttpControllerRouteHandler.Instance, this);
            Handler = handler;
        }

        public string RouteTemplate
        {
            get { return OriginalRoute.Url; }
        }

        public IDictionary<string, object> Defaults
        {
            get { return OriginalRoute.Defaults; }
        }

        public IDictionary<string, object> Constraints
        {
            get { return OriginalRoute.Constraints; }
        }

        public IDictionary<string, object> DataTokens
        {
            get { return OriginalRoute.DataTokens; }
        }

        public HttpMessageHandler Handler { get; private set; }

        internal Route OriginalRoute { get; private set; }

        public IHttpRouteData GetRouteData(string rootVirtualPath, HttpRequestMessage request)
        {
            if (rootVirtualPath == null)
            {
                throw Error.ArgumentNull("rootVirtualPath");
            }

            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpContextBase httpContextBase = request.GetHttpContext();
            if (httpContextBase == null)
            {
                httpContextBase = new HttpRequestMessageContextWrapper(rootVirtualPath, request);
            }

            RouteData routeData = OriginalRoute.GetRouteData(httpContextBase);
            if (routeData != null)
            {
                return new HostedHttpRouteData(routeData);
            }

            return null;
        }

        public IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, IDictionary<string, object> values)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpContextBase httpContextBase = request.GetHttpContext();
            if (httpContextBase != null)
            {
                HostedHttpRouteData routeData = request.GetRouteData() as HostedHttpRouteData;
                if (routeData != null)
                {
                    RequestContext requestContext = new RequestContext(httpContextBase, routeData.OriginalRouteData);
                    VirtualPathData virtualPathData = OriginalRoute.GetVirtualPath(requestContext, new RouteValueDictionary(values));
                    if (virtualPathData != null)
                    {
                        return new HostedHttpVirtualPathData(virtualPathData, routeData.Route);
                    }
                }
            }

            return null;
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HostedHttpRouteCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Web.Hosting;
using System.Web.Http.Routing;
using System.Web.Http.WebHost.Properties;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    internal class HostedHttpRouteCollection : HttpRouteCollection
    {
        private readonly RouteCollection _routeCollection;
        private readonly string _virtualPathRoot;

        public HostedHttpRouteCollection(RouteCollection routeCollection)
            : this(routeCollection, virtualPathRoot: null)
        {
        }

        public HostedHttpRouteCollection(RouteCollection routeCollection, string virtualPathRoot)
        {
            if (routeCollection == null)
            {
                throw Error.ArgumentNull("routeCollection");
            }

            _routeCollection = routeCollection;
            _virtualPathRoot = virtualPathRoot;
        }

        /// <inheritdoc/>
        public override string VirtualPathRoot
        {
            get
            {
                if (_virtualPathRoot == null)
                {
                    return HostingEnvironment.ApplicationVirtualPath;
                }
                else
                {
                    return _virtualPathRoot;
                }
            }
        }

        /// <inheritdoc/>
        public override int Count
        {
            get { return _routeCollection.Count; }
        }

        /// <inheritdoc/>
        public override IHttpRoute this[string name]
        {
            get
            {
                HttpWebRoute route = _routeCollection[name] as HttpWebRoute;
                if (route != null)
                {
                    return route.HttpRoute;
                }

                throw Error.KeyNotFound();
            }
        }

        /// <inheritdoc/>
        public override IHttpRoute this[int index]
        {
            get
            {
                HttpWebRoute route = _routeCollection[index] as HttpWebRoute;
                if (route != null)
                {
                    return route.HttpRoute;
                }

                throw Error.ArgumentOutOfRange("index", index, SRResources.RouteCollectionOutOfRange);
            }
        }

        /// <inheritdoc/>
        public override IHttpRouteData GetRouteData(HttpRequestMessage request)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpContextBase httpContextBase = request.GetHttpContext();
            if (httpContextBase == null)
            {
                httpContextBase = new HttpRequestMessageContextWrapper(VirtualPathRoot, request);
            }

            if (httpContextBase.GetHttpRequestMessage() == null)
            {
                httpContextBase.SetHttpRequestMessage(request);
            }

            RouteData routeData = _routeCollection.GetRouteData(httpContextBase);
            // If the match is from an IgnoreRoute, do not return a RouteData but return a null, which will be treated as a 404 NoRouteMatched.
            if (routeData != null && !(routeData.RouteHandler is System.Web.Routing.StopRoutingHandler))
            {
                return new HostedHttpRouteData(routeData);
            }

            return null;
        }

        /// <inheritdoc/>
        public override IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, string name, IDictionary<string, object> values)
        {
            if (request == null)
            {
                throw Error.ArgumentNull("request");
            }

            HttpContextBase httpContextBase = request.GetHttpContext();
            if (httpContextBase == null)
            {
                httpContextBase = new HttpRequestMessageContextWrapper(VirtualPathRoot, request);
            }

            if (httpContextBase.GetHttpRequestMessage() == null)
            {
                httpContextBase.SetHttpRequestMessage(request);
            }

            IHttpRouteData routeData = request.GetRouteData();
            if (routeData == null)
            {
                return null;
            }

            RequestContext requestContext = new RequestContext(httpContextBase, routeData.ToRouteData());
            RouteValueDictionary routeValues = values != null ? new RouteValueDictionary(values) : new RouteValueDictionary();
            VirtualPathData virtualPathData = _routeCollection.GetVirtualPath(requestContext, name, routeValues);

            if (virtualPathData != null)
            {
                // If the route is not an HttpWebRoute, try getting a virtual path without the httproute key in the route value dictionary
                // This ensures that httproute isn't picked up by non-WebAPI routes that might pollute the virtual path with httproute
                if (!(virtualPathData.Route is HttpWebRoute))
                {
                    if (routeValues.Remove(HttpWebRoute.HttpRouteKey))
                    {
                        VirtualPathData virtualPathDataWithoutHttpRouteValue = _routeCollection.GetVirtualPath(requestContext, name, routeValues);
                        if (virtualPathDataWithoutHttpRouteValue != null)
                        {
                            virtualPathData = virtualPathDataWithoutHttpRouteValue;
                        }
                    }
                }

                return new HostedHttpVirtualPathData(virtualPathData, routeData.Route);
            }

            return null;
        }

        /// <inheritdoc/>
        public override IHttpRoute CreateRoute(string uriTemplate, IDictionary<string, object> defaults, IDictionary<string, object> constraints, IDictionary<string, object> dataTokens, HttpMessageHandler handler)
        {
            if (constraints != null)
            {
                foreach (var constraint in constraints)
                {
                    ValidateConstraint(uriTemplate, constraint.Key, constraint.Value);
                }
            }

            return new HostedHttpRoute(uriTemplate, defaults, constraints, dataTokens, handler);
        }

        /// <inheritdoc/>
        protected override void ValidateConstraint(string routeTemplate, string name, object constraint)
        {
            // In WebHost the constraint might be IHttpRouteConstraint or IRouteConstraint (System.Web) or a string
            HttpWebRoute.ValidateConstraint(routeTemplate, name, constraint);
        }

        /// <inheritdoc/>
        public override void Add(string name, IHttpRoute route)
        {
            _routeCollection.Add(name, route.ToRoute());
        }

        /// <inheritdoc/>
        public override void Clear()
        {
            _routeCollection.Clear();
        }

        /// <inheritdoc/>
        public override bool Contains(IHttpRoute item)
        {
            foreach (RouteBase route in _routeCollection)
            {
                HttpWebRoute webRoute = route as HttpWebRoute;
                if (webRoute != null && webRoute.HttpRoute == item)
                {
                    return true;
                }
            }

            return false;
        }

        /// <inheritdoc/>
        public override bool ContainsKey(string name)
        {
            return _routeCollection[name] != null;
        }

        /// <inheritdoc/>
        public override void CopyTo(IHttpRoute[] array, int arrayIndex)
        {
            throw NotSupportedByHostedRouteCollection();
        }

        /// <inheritdoc/>
        public override void CopyTo(KeyValuePair<string, IHttpRoute>[] array, int arrayIndex)
        {
            throw NotSupportedByRouteCollection();
        }

        /// <inheritdoc/>
        public override void Insert(int index, string name, IHttpRoute value)
        {
            throw NotSupportedByRouteCollection();
        }

        /// <inheritdoc/>
        public override bool Remove(string name)
        {
            throw NotSupportedByRouteCollection();
        }

        /// <inheritdoc/>
        public override IEnumerator<IHttpRoute> GetEnumerator()
        {
            // Here we only care about Web API routes.
            return _routeCollection
                .OfType<HttpWebRoute>()
                .Select(httpWebRoute => httpWebRoute.HttpRoute)
                .GetEnumerator();
        }

        /// <inheritdoc/>
        public override bool TryGetValue(string name, out IHttpRoute route)
        {
            HttpWebRoute rt = _routeCollection[name] as HttpWebRoute;
            if (rt != null)
            {
                route = rt.HttpRoute;
                return true;
            }

            route = null;
            return false;
        }

        private static NotSupportedException NotSupportedByRouteCollection()
        {
            return Error.NotSupported(SRResources.RouteCollectionNotSupported, typeof(HostedHttpRouteCollection).Name);
        }

        private static NotSupportedException NotSupportedByHostedRouteCollection()
        {
            return Error.NotSupported(SRResources.RouteCollectionUseDirectly, typeof(RouteCollection).Name);
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HostedHttpRouteData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Routing;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    internal class HostedHttpRouteData : IHttpRouteData
    {
        public HostedHttpRouteData(RouteData routeData)
        {
            if (routeData == null)
            {
                throw Error.ArgumentNull("routeData");
            }

            OriginalRouteData = routeData;

            HttpWebRoute route = routeData.Route as HttpWebRoute;
            Route = route == null ? null : route.HttpRoute;
        }

        public IHttpRoute Route { get; private set; }

        public IDictionary<string, object> Values
        {
            get { return OriginalRouteData.Values; }
        }

        internal RouteData OriginalRouteData { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HostedHttpVirtualPathData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Routing;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    internal class HostedHttpVirtualPathData : IHttpVirtualPathData
    {
        private readonly VirtualPathData _virtualPath;

        public HostedHttpVirtualPathData(VirtualPathData virtualPath, IHttpRoute httpRoute)
        {
            if (virtualPath == null)
            {
                throw Error.ArgumentNull("route");
            }

            _virtualPath = virtualPath;
            Route = httpRoute;
        }

        public IHttpRoute Route { get; private set; }

        public string VirtualPath
        {
            get { return _virtualPath.VirtualPath; }
            set
            {
                if (value == null)
                {
                    throw Error.PropertyNull();
                }
                _virtualPath.VirtualPath = value;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpContextBaseExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;

namespace System.Web.Http.WebHost.Routing
{
    internal static class HttpContextBaseExtensions
    {
        internal static readonly string HttpRequestMessageKey = "MS_HttpRequestMessage";

        public static HttpRequestMessage GetHttpRequestMessage(this HttpContextBase context)
        {
            if (context == null)
            {
                throw Error.ArgumentNull("context");
            }

            if (context.Items == null || !context.Items.Contains(HttpRequestMessageKey))
            {
                return null;
            }

            return context.Items[HttpRequestMessageKey] as HttpRequestMessage;
        }

        public static void SetHttpRequestMessage(this HttpContextBase context, HttpRequestMessage request)
        {
            if (context.Items != null)
            {
                context.Items.Add(HttpRequestMessageKey, request);
            }
        }

        public static HttpRequestMessage GetOrCreateHttpRequestMessage(this HttpContextBase context)
        {
            if (context == null)
            {
                throw Error.ArgumentNull("context");
            }

            HttpRequestMessage request = context.GetHttpRequestMessage();
            if (request == null)
            {
                request = HttpControllerHandler.ConvertRequest(context);
                context.SetHttpRequestMessage(request);
            }

            return request;
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpRequestMessageContextWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Net.Http;

namespace System.Web.Http.WebHost.Routing
{
    internal class HttpRequestMessageContextWrapper : HttpContextBase
    {
        private HttpRequestMessageWrapper _httpWrapper;

        // Using Hashtable to be consistent with HttpContext.Items
        private Hashtable _items;

        public HttpRequestMessageContextWrapper(string virtualPathRoot, HttpRequestMessage httpRequest)
        {
            _httpWrapper = new HttpRequestMessageWrapper(virtualPathRoot, httpRequest);
            _items = new Hashtable();
        }

        public override HttpRequestBase Request
        {
            get { return _httpWrapper; }
        }

        public override IDictionary Items
        {
            get { return _items; }
        }
    }
}

================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpRequestMessageWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Net.Http;
using System.Web.Http.Hosting;

namespace System.Web.Http.WebHost.Routing
{
    internal class HttpRequestMessageWrapper : HttpRequestBase
    {
        private readonly string _virtualPathRoot;
        private readonly HttpRequestMessage _httpRequest;

        public HttpRequestMessageWrapper(string virtualPathRoot, HttpRequestMessage httpRequest)
        {
            if (virtualPathRoot == null)
            {
                throw Http.Error.ArgumentNull("virtualPathRoot");
            }

            if (httpRequest == null)
            {
                throw Http.Error.ArgumentNull("httpRequest");
            }

            _virtualPathRoot = virtualPathRoot;
            _httpRequest = httpRequest;
        }

        public override string ApplicationPath
        {
            get { return _virtualPathRoot; }
        }

        public override string AppRelativeCurrentExecutionFilePath
        {
            get
            {
                string absolutePath = Path;
                if (absolutePath.StartsWith(_virtualPathRoot, StringComparison.OrdinalIgnoreCase))
                {
                    string relativePath = _virtualPathRoot.Length == 1 ? absolutePath : absolutePath.Substring(_virtualPathRoot.Length);
                    return "~" + relativePath.TrimEnd('/');
                }
                return null;
            }
        }

        public override string CurrentExecutionFilePath
        {
            get { return FilePath; }
        }

        public override string FilePath
        {
            get
            {
                string absolutePath = Path;
                if (absolutePath.StartsWith(_virtualPathRoot, StringComparison.OrdinalIgnoreCase))
                {
                    return absolutePath.TrimEnd('/');
                }
                return null;
            }
        }

        public override string HttpMethod
        {
            get { return _httpRequest.Method.ToString(); }
        }

        public override bool IsLocal
        {
            get { return _httpRequest.IsLocal(); }
        }

        public override string Path
        {
            get
            {
                // All of the HttpContextBase methods are supposed to return paths that are unescaped
                // and begin with '/'. Don't use Uri.AbsolutePath here because it's escaped.
                return "/" + _httpRequest.RequestUri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
            }
        }

        public override string PathInfo
        {
            get { return String.Empty; }
        }

        public override NameValueCollection QueryString
        {
            get { return _httpRequest.RequestUri.ParseQueryString(); }
        }

        public override string RawUrl
        {
            get 
            {
                // All of the HttpContextBase methods are supposed to return paths that are unescaped
                // and begin with '/'. Don't use Uri.PathAndQuery here because it's escaped.
                return _httpRequest.RequestUri.GetComponents(UriComponents.PathAndQuery, UriFormat.Unescaped); 
            }
        }

        public override string RequestType
        {
            get { return _httpRequest.Method.ToString(); }
        }

        public override Uri Url
        {
            get { return _httpRequest.RequestUri; }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpRouteDataExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Routing;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    internal static class HttpRouteDataExtensions
    {
        public static RouteData ToRouteData(this IHttpRouteData httpRouteData)
        {
            if (httpRouteData == null)
            {
                throw Error.ArgumentNull("httpRouteData");
            }

            HostedHttpRouteData hostedHttpRouteData = httpRouteData as HostedHttpRouteData;
            if (hostedHttpRouteData != null)
            {
                return hostedHttpRouteData.OriginalRouteData;
            }

            Route route = httpRouteData.Route.ToRoute();
            RouteData result = new RouteData(route, HttpControllerRouteHandler.Instance);
            foreach (KeyValuePair<string, object> pair in httpRouteData.Values)
            {
                result.Values.Add(pair.Key, pair.Value);
            }
            return result;
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpRouteExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;

namespace System.Web.Http.WebHost.Routing
{
    /// <summary>Represents a handler that asynchronously handles an unhandled exception from routing.</summary>
    internal class HttpRouteExceptionHandler : HttpTaskAsyncHandler
    {
        private readonly ExceptionDispatchInfo _exceptionInfo;
        private readonly IExceptionLogger _exceptionLogger;
        private readonly IExceptionHandler _exceptionHandler;

        public HttpRouteExceptionHandler(ExceptionDispatchInfo exceptionInfo)
            : this(exceptionInfo, ExceptionServices.GetLogger(GlobalConfiguration.Configuration),
            ExceptionServices.GetHandler(GlobalConfiguration.Configuration))
        {
        }

        internal HttpRouteExceptionHandler(ExceptionDispatchInfo exceptionInfo,
            IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler)
        {
            Contract.Assert(exceptionInfo != null);
            Contract.Assert(exceptionLogger != null);
            Contract.Assert(exceptionHandler != null);

            _exceptionInfo = exceptionInfo;
            _exceptionLogger = exceptionLogger;
            _exceptionHandler = exceptionHandler;
        }

        internal ExceptionDispatchInfo ExceptionInfo
        {
            get { return _exceptionInfo; }
        }

        internal IExceptionLogger ExceptionLogger
        {
            get { return _exceptionLogger; }
        }

        internal IExceptionHandler ExceptionHandler
        {
            get { return _exceptionHandler; }
        }

        public override Task ProcessRequestAsync(HttpContext context)
        {
            return ProcessRequestAsync(new HttpContextWrapper(context));
        }

        internal async Task ProcessRequestAsync(HttpContextBase context)
        {
            Exception exception = _exceptionInfo.SourceException;
            Contract.Assert(exception != null);

            OperationCanceledException canceledException = exception as OperationCanceledException;
            if (canceledException != null)
            {
                // If the route throws a cancelation exception, then we'll abort the request instead of
                // reporting an 'error'. We don't expect this to happen, but aborting the request is 
                // consistent with our behavior in other hosts.
                context.Request.Abort();
                return;
            }

            HttpRequestMessage request = context.GetOrCreateHttpRequestMessage();
            HttpResponseMessage response = null;
            CancellationToken cancellationToken = context.Response.GetClientDisconnectedTokenWhenFixed();

            HttpResponseException responseException = exception as HttpResponseException;

            try
            {
                if (responseException != null)
                {
                    response = responseException.Response;
                    Contract.Assert(response != null);

                    // This method call is hardened and designed not to throw exceptions (since they won't be caught
                    // and handled further by its callers).
                    await HttpControllerHandler.CopyResponseAsync(context, request, response, _exceptionLogger,
                        _exceptionHandler, cancellationToken);
                }
                else
                {
                    // This method call is hardened and designed not to throw exceptions (since they won't be caught and
                    // handled further by its callers).
                    bool handled = await HttpControllerHandler.CopyErrorResponseAsync(
                        WebHostExceptionCatchBlocks.HttpWebRoute, context, request, null,
                        _exceptionInfo.SourceException, _exceptionLogger, _exceptionHandler, cancellationToken);

                    if (!handled)
                    {
                        _exceptionInfo.Throw();
                    }
                }
            }
            catch (OperationCanceledException)
            {
                // This block handles cancellations that might occur while we're writing an 'error' response.
                //
                // HttpTaskAsyncHandler treats a canceled task as an unhandled exception (logged to Application event
                // log). Instead of returning a canceled task, abort the request and return a completed task.
                context.Request.Abort();
            }
            finally
            {
                // The other HttpTaskAsyncHandler is HttpControllerHandler; it has similar cleanup logic.
                request.DisposeRequestResources();
                request.Dispose();

                if (response != null)
                {
                    response.Dispose();
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpRouteExceptionRouteHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Runtime.ExceptionServices;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    /// <summary>Represents a route handler that asynchronously handles an unhandled exception from routing.</summary>
    internal class HttpRouteExceptionRouteHandler : IRouteHandler
    {
        private readonly ExceptionDispatchInfo _exceptionInfo;

        public HttpRouteExceptionRouteHandler(ExceptionDispatchInfo exceptionInfo)
        {
            Contract.Assert(exceptionInfo != null);
            _exceptionInfo = exceptionInfo;
        }

        internal ExceptionDispatchInfo ExceptionInfo
        {
            get { return _exceptionInfo; }
        }

        public IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            return new HttpRouteExceptionHandler(_exceptionInfo);
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpRouteExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Routing;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    internal static class HttpRouteExtensions
    {
        public static Route ToRoute(this IHttpRoute httpRoute)
        {
            if (httpRoute == null)
            {
                throw Error.ArgumentNull("httpRoute");
            }

            HostedHttpRoute hostedHttpRoute = httpRoute as HostedHttpRoute;
            if (hostedHttpRoute != null)
            {
                return hostedHttpRoute.OriginalRoute;
            }

            IRouteHandler handler =
                (httpRoute.Handler is System.Web.Http.Routing.StopRoutingHandler) ? (new System.Web.Routing.StopRoutingHandler() as IRouteHandler) : HttpControllerRouteHandler.Instance;

            return new HttpWebRoute(
                httpRoute.RouteTemplate,
                MakeRouteValueDictionary(httpRoute.Defaults),
                MakeRouteValueDictionary(httpRoute.Constraints),
                MakeRouteValueDictionary(httpRoute.DataTokens),
                handler,
                httpRoute);
        }

        private static RouteValueDictionary MakeRouteValueDictionary(IDictionary<string, object> dictionary)
        {
            return dictionary == null
                ? new RouteValueDictionary()
                : new RouteValueDictionary(dictionary);
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/Routing/HttpWebRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Routing;
using System.Web.Http.WebHost.Properties;
using System.Web.Routing;

namespace System.Web.Http.WebHost.Routing
{
    /// <summary>
    /// Mimics the System.Web.Routing.Route class to work better for Web API scenarios. The only
    /// difference between the base class and this class is that this one will match only when
    /// a special "httproute" key is specified when generating URLs. There is no special behavior
    /// for incoming URLs.
    /// </summary>
    internal class HttpWebRoute : Route
    {
        /// <summary>
        /// Key used to signify that a route URL generation request should include HTTP routes (e.g. Web API).
        /// If this key is not specified then no HTTP routes will match.
        /// </summary>
        internal const string HttpRouteKey = "httproute";

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "Matches the base class's parameter names.")]
        public HttpWebRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, IRouteHandler routeHandler, IHttpRoute httpRoute)
            : base(url, defaults, constraints, dataTokens, routeHandler)
        {
            if (httpRoute == null)
            {
                throw Error.ArgumentNull("httpRoute");
            }

            HttpRoute = httpRoute;
        }

        /// <summary>
        /// Gets the <see cref="IHttpRoute"/> associated with this <see cref="HttpWebRoute"/>.
        /// </summary>
        public IHttpRoute HttpRoute { get; private set; }

        protected override bool ProcessConstraint(HttpContextBase httpContext, object constraint, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
        {
            // The base class will validate that a constraint is either a string or IRoutingConstraint inside its
            // ProcessConstraint method. We're doing the validation up front here because we also support 
            // IHttpRouteConstraint and we want the error message to reflect all three valid possibilities.
            ValidateConstraint(HttpRoute.RouteTemplate, parameterName, constraint);

            IHttpRouteConstraint httpRouteConstraint = constraint as IHttpRouteConstraint;
            if (httpRouteConstraint != null)
            {
                HttpRequestMessage request = httpContext.GetOrCreateHttpRequestMessage();
                return httpRouteConstraint.Match(request, HttpRoute, parameterName, values, ConvertRouteDirection(routeDirection));
            }

            return base.ProcessConstraint(httpContext, constraint, parameterName, values, routeDirection);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "Top-level catch block for unhandled routing exceptions.")]
        public override RouteData GetRouteData(HttpContextBase httpContext)
        {
            try
            {
                if (HttpRoute is HostedHttpRoute)
                {
                    return base.GetRouteData(httpContext);
                }
                else
                {
                    // if user passed us a custom IHttpRoute, then we should invoke their function instead of the base
                    HttpRequestMessage request = httpContext.GetOrCreateHttpRequestMessage();
                    IHttpRouteData data = HttpRoute.GetRouteData(httpContext.Request.ApplicationPath, request);
                    return data == null ? null : data.ToRouteData();
                }
            }
            catch (Exception exception)
            {
                // Processing an exception involves async work, and this method is synchronous.
                // Instead of waiting on the async work here, it's better to return a handler that will deal with the
                // exception asynchronously during its request processing method.
                ExceptionDispatchInfo exceptionInfo = ExceptionDispatchInfo.Capture(exception);
                return new RouteData(this, new HttpRouteExceptionRouteHandler(exceptionInfo));
            }
        }

        public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
        {
            // Only perform URL generation if the "httproute" key was specified. This allows these
            // routes to be ignored when a regular MVC app tries to generate URLs. Without this special
            // key an HTTP route used for Web API would normally take over almost all the routes in a
            // typical app.
            if (!values.ContainsKey(HttpRouteKey))
            {
                return null;
            }
            // Remove the value from the collection so that it doesn't affect the generated URL
            RouteValueDictionary newValues = GetRouteDictionaryWithoutHttpRouteKey(values);

            if (HttpRoute is HostedHttpRoute)
            {
                return base.GetVirtualPath(requestContext, newValues);
            }
            else
            {
                // if user passed us a custom IHttpRoute, then we should invoke their function instead of the base
                HttpRequestMessage request = requestContext.HttpContext.GetOrCreateHttpRequestMessage();
                IHttpVirtualPathData virtualPathData = HttpRoute.GetVirtualPath(request, values);

                return virtualPathData == null ? null : new VirtualPathData(this, virtualPathData.VirtualPath);
            }
        }

        private static RouteValueDictionary GetRouteDictionaryWithoutHttpRouteKey(IDictionary<string, object> routeValues)
        {
            var newRouteValues = new RouteValueDictionary();
            foreach (var routeValue in routeValues)
            {
                if (!String.Equals(routeValue.Key, HttpRouteKey, StringComparison.OrdinalIgnoreCase))
                {
                    newRouteValues.Add(routeValue.Key, routeValue.Value);
                }
            }
            return newRouteValues;
        }

        private static HttpRouteDirection ConvertRouteDirection(RouteDirection routeDirection)
        {
            if (routeDirection == RouteDirection.IncomingRequest)
            {
                return HttpRouteDirection.UriResolution;
            }

            if (routeDirection == RouteDirection.UrlGeneration)
            {
                return HttpRouteDirection.UriGeneration;
            }

            throw Error.InvalidEnumArgument("routeDirection", (int)routeDirection, typeof(RouteDirection));
        }

        // Validates that this constraint is of a type that HttpWebRoute can process. This is not valid to
        // call when a route inherits from HttpWebRoute - as the derived class can handle any types of 
        // constraints it wants to support.
        internal static void ValidateConstraint(string routeTemplate, string name, object constraint)
        {
            if (constraint is IHttpRouteConstraint)
            {
                return;
            }

            // This validation is repeated in the call to base.ProcessConstraint, but if we do it here we can give a
            // better error message. base.ProcessConstraint doesn't handle IHttpRouteConstraint, but this class does.
            if (constraint is IRouteConstraint)
            {
                return;
            }

            if (constraint is string)
            {
                return;
            }

            throw CreateInvalidConstraintTypeException(routeTemplate, name);
        }

        private static Exception CreateInvalidConstraintTypeException(string routeTemplate, string name)
        {
            return Error.InvalidOperation(
                SRResources.Route_ValidationMustBeStringOrCustomConstraint,
                name,
                routeTemplate,
                typeof(IHttpRouteConstraint).FullName,
                typeof(IRouteConstraint).FullName);
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/SeekableBufferedRequestStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.WebHost
{
    internal class SeekableBufferedRequestStream : NonOwnedStream
    {
        private const int ReadBufferSize = 1024;

        private readonly HttpRequestBase _request;

        private bool _isReadToEndComplete;

        public SeekableBufferedRequestStream(HttpRequestBase request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            _request = request;
            InnerStream = request.GetBufferedInputStream();
        }

        public override bool CanSeek
        {
            get
            {
                return !IsDisposed;
            }
        }

        public override long Position
        {
            get
            {
                ThrowIfDisposed();
                return InnerStream.Position;
            }
            set
            {
                ThrowIfDisposed();
                Seek(value, SeekOrigin.Begin);
            }
        }

        public override int EndRead(IAsyncResult asyncResult)
        {
            ThrowIfDisposed();

            int bytesRead = InnerStream.EndRead(asyncResult);
            if (bytesRead == 0 && !_isReadToEndComplete)
            {
                SwapToSeekableStream();
            }

            return bytesRead;
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            ThrowIfDisposed();

            int bytesRead = InnerStream.Read(buffer, offset, count);
            if (bytesRead == 0 && !_isReadToEndComplete)
            {
                SwapToSeekableStream();
            }

            return bytesRead;
        }

        public async override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
        {
            ThrowIfDisposed();

            int bytesRead = await InnerStream.ReadAsync(buffer, offset, count, cancellationToken);
            if (bytesRead == 0 && !_isReadToEndComplete)
            {
                SwapToSeekableStream();
            }

            return bytesRead;
        }

        public override int ReadByte()
        {
            ThrowIfDisposed();

            int result = InnerStream.ReadByte();
            if (result == -1 && !_isReadToEndComplete)
            {
                SwapToSeekableStream();
            }

            return result;
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            ThrowIfDisposed();

            long currentPosition = InnerStream.Position;
            long? newPosition = null;
            switch (origin)
            {
                case SeekOrigin.Begin:
                    newPosition = offset;
                    break;
                case SeekOrigin.Current:
                    newPosition = currentPosition + offset;
                    break;
                case SeekOrigin.End:
                    // We have to check Length here because we might not know the length in some scenarios. 
                    // If we don't know, then we just do the safe thing and force a read to end.
                    if (Length >= 0)
                    {
                        newPosition = Length + offset;
                    }
                    break;
                default:
                    throw new InvalidEnumArgumentException("origin", (int)origin, typeof(SeekOrigin));
            }

            if (newPosition == currentPosition)
            {
                // This is a no-op, we want to short circuit because we do significant work on a seek.
                return currentPosition;
            }

            if (!_isReadToEndComplete)
            {
                // The current stream is the one returned from GetBufferedInputStream(), and it's not
                // seekable in the web host case.
                //
                // We need to read the non-seekable stream to the end, which will populate the seekable stream
                // that's provided by .InputStream. This is only done for the side-effect, and we just ignore the
                // data, it's already being buffered for us.
                //
                // This is done synchronously, because we need to block the calling thread so that the result of
                // Seek can be returned.
                byte[] buffer = new byte[ReadBufferSize];
                while (InnerStream.Read(buffer, 0, buffer.Length) > 0)
                {
                }

                SwapToSeekableStream();
            }

            return InnerStream.Seek(offset, origin);
        }

        private void SwapToSeekableStream()
        {
            // At this point we've actually read the non-seekable stream to the end, and we're about to swap streams
            // and toggle the value of _isReadToEndComplete. Reading the non-seekable stream to the end will populate
            // InnerStream with the buffered data, so we can use it for all future operations.
            Debug.Assert(!_isReadToEndComplete);

            Stream seekableStream = _request.InputStream;
            seekableStream.Position = InnerStream.Position;
            InnerStream = seekableStream;

            _isReadToEndComplete = true;
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/SuppressFormsAuthRedirectHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Specialized;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Net;
using System.Reflection;
using System.Web.Configuration;
using System.Web.Security;

namespace System.Web.Http.WebHost
{
    /// <summary>
    /// Helper methods for Suppressing Form Authentication Redirect
    /// </summary>
    internal static class SuppressFormsAuthRedirectHelper
    {
        internal static readonly string AppSettingsSuppressFormsAuthenticationRedirectKey = "webapi:EnableSuppressRedirect";

        /// <summary>
        /// Returns whether the module is explicitly enabled or not
        /// </summary>
        internal static bool GetEnabled(NameValueCollection appSettings)
        {
            string disableSuppressRedirect = appSettings.Get(AppSettingsSuppressFormsAuthenticationRedirectKey);

            if (!String.IsNullOrEmpty(disableSuppressRedirect))
            {
                bool enabled;

                // anything but "false" will return true, which is the default behavior
                if (Boolean.TryParse(disableSuppressRedirect, out enabled))
                {
                    if (!enabled)
                    {
                        return false;
                    }
                }
            }

            return true;
        }
    }
}

================================================
FILE: src/System.Web.Http.WebHost/System.Web.Http.WebHost.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{A0187BC2-8325-4BB2-8697-7F955CF4173E}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.WebHost</RootNamespace>
    <AssemblyName>System.Web.Http.WebHost</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Web" />
    <Reference Include="System.XML" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\Common\DictionaryExtensions.cs">
      <Link>Common\DictionaryExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\Error.cs">
      <Link>Common\Error.cs</Link>
    </Compile>
    <Compile Include="..\Common\HttpMethodHelper.cs">
      <Link>Common\HttpMethodHelper.cs</Link>
    </Compile>
    <Compile Include="..\Common\NonOwnedStream.cs">
      <Link>Common\NonOwnedStream.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpers.cs">
      <Link>Common\TaskHelpers.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpersExtensions.cs">
      <Link>Common\TaskHelpersExtensions.cs</Link>
    </Compile>
    <Compile Include="HttpResponseBaseExtensions.cs" />
    <Compile Include="Routing\HttpRouteExceptionHandler.cs" />
    <Compile Include="Routing\HttpRouteExceptionRouteHandler.cs" />
    <Compile Include="SeekableBufferedRequestStream.cs" />
    <Compile Include="WebHostExceptionCatchBlocks.cs" />
    <Compile Include="HttpBatchContextWrapper.cs" />
    <Compile Include="HttpRequestMessageExtensions.cs" />
    <Compile Include="Routing\HttpRequestMessageWrapper.cs" />
    <Compile Include="Routing\HttpRequestMessageContextWrapper.cs" />
    <Compile Include="WebHostBufferPolicySelector.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="HttpControllerTypeCacheSerializer.cs" />
    <Compile Include="Routing\HttpContextBaseExtensions.cs" />
    <Compile Include="WebHostExceptionHandler.cs" />
    <Compile Include="WebHostHttpControllerTypeResolver.cs" />
    <Compile Include="Routing\HostedHttpRouteCollection.cs" />
    <Compile Include="Routing\HostedHttpRoute.cs" />
    <Compile Include="Routing\HostedHttpRouteData.cs" />
    <Compile Include="Routing\HostedHttpVirtualPathData.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="GlobalConfiguration.cs" />
    <Compile Include="Routing\HttpRouteDataExtensions.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Routing\HttpRouteExtensions.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Routing\HttpWebRoute.cs" />
    <Compile Include="SuppressFormsAuthRedirectHelper.cs" />
    <Compile Include="WebHostAssembliesResolver.cs" />
    <Compile Include="Properties\SRResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>SRResources.resx</DependentUpon>
    </Compile>
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="HttpControllerHandler.cs" />
    <Compile Include="HttpControllerRouteHandler.cs" />
    <Compile Include="RouteCollectionExtensions.cs" />
    <Compile Include="TaskWrapperAsyncResult.cs" />
    <Compile Include="WebHostHttpRequestContext.cs" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\CommonWebApiResources.Designer.cs">
      <Link>Properties\CommonWebApiResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonWebApiResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\Common\CommonWebApiResources.resx">
      <Link>Properties\CommonWebApiResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonWebApiResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\SRResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>SRResources.Designer.cs</LastGenOutput>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml">
      <Link>CodeAnalysisDictionary.xml</Link>
    </CodeAnalysisDictionary>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Http.WebHost/TaskWrapperAsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.WebHost
{
    /// <summary>
    /// Wraps a <see cref="Task"/>, optionally overriding the State object (since the Task Asynchronous Pattern doesn't normally use it).
    /// </summary>
    /// <remarks>Class copied from System.Web.Mvc, but with modifications</remarks>
    internal sealed class TaskWrapperAsyncResult : IAsyncResult
    {
        private bool? _completedSynchronously;

        /// <summary>
        /// Initializes a new instance of the <see cref="TaskWrapperAsyncResult"/> class.
        /// </summary>
        /// <param name="task">The <see cref="Task"/> to wrap.</param>
        /// <param name="asyncState">User-defined object that qualifies or contains information about an asynchronous operation.</param>
        public TaskWrapperAsyncResult(Task task, object asyncState)
        {
            if (task == null)
            {
                throw Error.ArgumentNull("task");
            }

            Task = task;
            AsyncState = asyncState;
        }

        /// <summary>
        /// Gets a user-defined object that qualifies or contains information about an asynchronous operation.
        /// </summary>
        /// <returns>A user-defined object that qualifies or contains information about an asynchronous operation.</returns>
        public object AsyncState { get; private set; }

        /// <summary>
        /// Gets a <see cref="T:System.Threading.WaitHandle"/> that is used to wait for an asynchronous operation to complete.
        /// </summary>
        /// <returns>A <see cref="T:System.Threading.WaitHandle"/> that is used to wait for an asynchronous operation to complete.</returns>
        public WaitHandle AsyncWaitHandle
        {
            get { return ((IAsyncResult)Task).AsyncWaitHandle; }
        }

        /// <summary>
        /// Gets a value indicating whether the asynchronous operation completed synchronously.
        /// </summary>
        /// <returns>true if the asynchronous operation completed synchronously; otherwise, false.</returns>
        public bool CompletedSynchronously
        {
            get { return _completedSynchronously ?? ((IAsyncResult)Task).CompletedSynchronously; }
            internal set { _completedSynchronously = value; }
        }

        /// <summary>
        /// Gets a value indicating whether the asynchronous operation has completed.
        /// </summary>
        /// <returns>true if the operation is complete; otherwise, false.</returns>
        public bool IsCompleted
        {
            get { return ((IAsyncResult)Task).IsCompleted; }
        }

        /// <summary>
        /// Gets the task.
        /// </summary>
        public Task Task { get; private set; }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/WebHostAssembliesResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web.Compilation;
using System.Web.Http.Dispatcher;

namespace System.Web.Http.WebHost
{
    /// <summary>
    /// Provides an implementation of <see cref="IAssembliesResolver"/> using <see cref="BuildManager"/>.
    /// </summary>
    internal sealed class WebHostAssembliesResolver : IAssembliesResolver
    {
        /// <summary>
        /// Returns a list of assemblies that will be searched for types that implement IHttpController, such as ApiController.
        /// </summary>
        /// <returns>An <see cref="ICollection{Assembly}" /> of assemblies.</returns>
        ICollection<Assembly> IAssembliesResolver.GetAssemblies()
        {
            return BuildManager.GetReferencedAssemblies().OfType<Assembly>().ToList();
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/WebHostBufferPolicySelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web;
using System.Web.Http.Hosting;

namespace System.Web.Http.WebHost
{
    /// <summary>
    /// Provides an implementation of <see cref="IHostBufferPolicySelector"/> suited for use
    /// in an ASP.NET environment which provides direct support for input and output buffering.
    /// </summary>
    public class WebHostBufferPolicySelector : IHostBufferPolicySelector
    {
        /// <summary>
        /// Determines whether the host should buffer the entity body when processing a request with content.
        /// </summary>
        /// <param name="hostContext">The host-specific context.  In this case, it is an instance
        /// of <see cref="HttpContextBase"/>.</param>
        /// <returns><c>true</c> if buffering should be used; otherwise a streamed request should be used.</returns>
        public virtual bool UseBufferedInputStream(object hostContext)
        {
            if (hostContext == null)
            {
                throw Error.ArgumentNull("hostContext");
            }

            return true;
        }

        /// <summary>
        /// Determines whether the host should buffer the <see cref="HttpResponseMessage"/> entity body.
        /// </summary>
        /// <param name="response">The <see cref="HttpResponseMessage"/>response for which to determine
        /// whether host output buffering should be used for the response entity body.</param>
        /// <returns><c>true</c> if buffering should be used; otherwise a streamed response should be used.</returns>
        public virtual bool UseBufferedOutputStream(HttpResponseMessage response)
        {
            if (response == null)
            {
                throw Error.ArgumentNull("response");
            }

            // Any HttpContent that knows its length is presumably already buffered internally.
            HttpContent content = response.Content;
            if (content != null)
            {
                long? contentLength = content.Headers.ContentLength;
                if (contentLength.HasValue && contentLength.Value >= 0)
                {
                    return false;
                }

                // Content length is null or -1 (meaning not known).  
                // Buffer any HttpContent except StreamContent and PushStreamContent
                return !(content is StreamContent || content is PushStreamContent);
            }

            return false;
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/WebHostExceptionCatchBlocks.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.WebHost.Routing;

namespace System.Web.Http.WebHost
{
    /// <summary>Provides the catch blocks used within this assembly.</summary>
    public static class WebHostExceptionCatchBlocks
    {
        private static readonly ExceptionContextCatchBlock _httpControllerHandlerBufferContent =
            new ExceptionContextCatchBlock(typeof(HttpControllerHandler).Name + ".BufferContent", isTopLevel: true,
                callsHandler: true);
        private static readonly ExceptionContextCatchBlock _httpControllerHandlerBufferError =
            new ExceptionContextCatchBlock(typeof(HttpControllerHandler).Name + ".BufferError", isTopLevel: true,
                callsHandler: false);
        private static readonly ExceptionContextCatchBlock _httpControllerHandlerComputeContentLength =
            new ExceptionContextCatchBlock(typeof(HttpControllerHandler).Name + ".ComputeContentLength",
                isTopLevel: true, callsHandler: false);
        private static readonly ExceptionContextCatchBlock _httpControllerHandlerStreamContent =
            new ExceptionContextCatchBlock(typeof(HttpControllerHandler).Name + ".StreamContent", isTopLevel: true,
                callsHandler: false);
        private static readonly ExceptionContextCatchBlock _httpWebRoute =
            new ExceptionContextCatchBlock(typeof(HttpWebRoute).Name, isTopLevel: true, callsHandler: true);

        /// <summary>
        /// Gets the label for the catch block in
        /// <see cref="HttpControllerHandler"/>.WriteBufferedResponseContentAsync.
        /// </summary>
        /// <remarks>
        /// This catch block handles exceptions when writing the <see cref="HttpContent"/> under an
        /// <see cref="IHostBufferPolicySelector"/> that buffers.
        /// </remarks>
        public static ExceptionContextCatchBlock HttpControllerHandlerBufferContent
        {
            get { return _httpControllerHandlerBufferContent; }
        }

        /// <summary>
        /// Gets the label for the catch block in <see cref="HttpControllerHandler"/>.WriteErrorResponseContentAsync.
        /// </summary>
        /// <remarks>
        /// This catch block handles exceptions when writing the <see cref="HttpContent"/> of the error response itself
        /// (after <see cref="HttpControllerHandlerBufferContent"/> or <see cref="HttpWebRoute"/>).
        /// </remarks>
        public static ExceptionContextCatchBlock HttpControllerHandlerBufferError
        {
            get { return _httpControllerHandlerBufferError; }
        }

        /// <summary>
        /// Gets the label for the catch block in <see cref="HttpControllerHandler"/>.ComputeContentLength.
        /// </summary>
        /// <remarks>
        /// This catch block handles exceptions when calling <see cref="HttpContent.TryComputeLength"/>.
        /// </remarks>
        public static ExceptionContextCatchBlock HttpControllerHandlerComputeContentLength
        {
            get { return _httpControllerHandlerComputeContentLength; }
        }

        /// <summary>
        /// Gets the label for the catch block in
        /// <see cref="HttpControllerHandler"/>.WriteStreamedResponseContentAsync.
        /// </summary>
        /// <remarks>
        /// This catch block handles exceptions when writing the <see cref="HttpContent"/> under an
        /// <see cref="IHostBufferPolicySelector"/> that does not buffer.
        /// </remarks>
        public static ExceptionContextCatchBlock HttpControllerHandlerStreamContent
        {
            get { return _httpControllerHandlerStreamContent; }
        }

        /// <summary>Gets the label for the catch block in <see cref="HttpWebRoute"/>.GetRouteData.</summary>
        public static ExceptionContextCatchBlock HttpWebRoute
        {
            get { return _httpWebRoute; }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/WebHostExceptionHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Results;
using System.Web.Http.WebHost.Properties;

namespace System.Web.Http.WebHost
{
    /// <summary>Provides the default implementation for handling exceptions within Web API web host.</summary>
    /// <remarks>
    /// This class preserves the legacy behavior of catch blocks and is the the default registered IExceptionHandler
    /// for web host.
    /// </remarks>
    internal class WebHostExceptionHandler : IExceptionHandler
    {
        private readonly IExceptionHandler _innerHandler;

        public WebHostExceptionHandler(IExceptionHandler innerHandler)
        {
            Contract.Assert(innerHandler != null);
            _innerHandler = innerHandler;
        }

        public IExceptionHandler InnerHandler
        {
            get { return _innerHandler; }
        }

        public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);

            if (exceptionContext.CatchBlock ==
                WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent)
            {
                HandleWebHostBufferedContentException(context);
                return TaskHelpers.Completed();
            }

            return _innerHandler.HandleAsync(context, cancellationToken);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope",
            Justification = "We already shipped this code; avoiding even minor breaking changes in error handling.")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "All exceptions caught here become error responses")]
        private static void HandleWebHostBufferedContentException(ExceptionHandlerContext context)
        {
            Contract.Assert(context != null);

            ExceptionContext exceptionContext = context.ExceptionContext;
            Contract.Assert(exceptionContext != null);

            Exception exception = exceptionContext.Exception;
            Contract.Assert(exception != null);

            HttpRequestMessage request = exceptionContext.Request;

            if (request == null)
            {
                throw new ArgumentException(Error.Format(SRResources.TypePropertyMustNotBeNull,
                    typeof(ExceptionContext).Name, "Request"), "context");
            }

            HttpResponseMessage response = exceptionContext.Response;

            if (response == null)
            {
                throw new ArgumentException(Error.Format(SRResources.TypePropertyMustNotBeNull,
                    typeof(ExceptionContext).Name, "Response"), "context");
            }

            HttpContent responseContent = response.Content;

            if (responseContent == null)
            {
                throw new ArgumentException(Error.Format(SRResources.TypePropertyMustNotBeNull,
                    typeof(HttpResponseMessage).Name, "Content"), "context");
            }

            HttpResponseMessage errorResponse;

            // Create a 500 response with content containing an explanatory message and
            // stack trace, subject to content negotiation and policy for error details.
            try
            {
                MediaTypeHeaderValue mediaType = responseContent.Headers.ContentType;
                string messageDetails = (mediaType != null)
                                            ? Error.Format(
                                                SRResources.Serialize_Response_Failed_MediaType,
                                                responseContent.GetType().Name,
                                                mediaType)
                                            : Error.Format(
                                                SRResources.Serialize_Response_Failed,
                                                responseContent.GetType().Name);

                errorResponse = request.CreateErrorResponse(
                                            HttpStatusCode.InternalServerError,
                                            new InvalidOperationException(messageDetails, exception));

                // CreateErrorResponse will choose 406 if it cannot find a formatter,
                // but we want our default error response to be 500 always
                errorResponse.StatusCode = HttpStatusCode.InternalServerError;
            }
            catch
            {
                // Failed creating an HttpResponseMessage for the error response.
                // This can happen for missing config, missing conneg service, etc.
                // Create an empty error response and return a non-faulted task.
                errorResponse = request.CreateResponse(HttpStatusCode.InternalServerError);
            }

            context.Result = new ResponseMessageResult(errorResponse);
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/WebHostHttpControllerTypeResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Web.Compilation;
using System.Web.Http.Dispatcher;

namespace System.Web.Http.WebHost
{
    /// <summary>
    /// Wraps ASP build manager
    /// </summary>
    internal sealed class WebHostHttpControllerTypeResolver : DefaultHttpControllerTypeResolver
    {
        private const string TypeCacheName = "MS-ApiControllerTypeCache.xml";

        /// <summary>
        /// Returns a list of controllers available for the application.
        /// </summary>
        /// <returns>An <see cref="ICollection{Type}" /> of controllers.</returns>
        public override ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
        {
            HttpControllerTypeCacheSerializer serializer = new HttpControllerTypeCacheSerializer();

            // First, try reading from the cache on disk
            List<Type> matchingTypes = ReadTypesFromCache(TypeCacheName, IsControllerTypePredicate, serializer);
            if (matchingTypes != null)
            {
                return matchingTypes;
            }

            // If reading from the cache failed, enumerate over every assembly looking for a matching type
            matchingTypes = base.GetControllerTypes(assembliesResolver).ToList();

            // Finally, save the cache back to disk
            SaveTypesToCache(TypeCacheName, matchingTypes, serializer);

            return matchingTypes;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Cache failures are not fatal, and the code should continue executing normally.")]
        private static List<Type> ReadTypesFromCache(string cacheName, Predicate<Type> predicate, HttpControllerTypeCacheSerializer serializer)
        {
            try
            {
                Stream stream = BuildManager.ReadCachedFile(cacheName);
                if (stream != null)
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        ICollection<Type> deserializedTypes = serializer.DeserializeTypes(reader);
                        if (deserializedTypes != null && deserializedTypes.All(type => predicate(type)))
                        {
                            // If all read types still match the predicate, success!
                            return deserializedTypes.ToList();
                        }
                    }
                }
            }
            catch
            {
                // cache failures are not considered fatal -- keep running.
            }

            return null;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Cache failures are not fatal, and the code should continue executing normally.")]
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Disposed later")]
        private static void SaveTypesToCache(string cacheName, IEnumerable<Type> matchingTypes, HttpControllerTypeCacheSerializer serializer)
        {
            try
            {
                Stream stream = BuildManager.CreateCachedFile(cacheName);
                if (stream != null)
                {
                    using (StreamWriter writer = new StreamWriter(stream))
                    {
                        serializer.SerializeTypes(matchingTypes, writer);
                    }
                }
            }
            catch
            {
                // cache failures are not considered fatal -- keep running.
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/WebHostHttpRequestContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;

namespace System.Web.Http.WebHost
{
    internal class WebHostHttpRequestContext : HttpRequestContext
    {
        private readonly HttpContextBase _contextBase;
        private readonly HttpRequestBase _requestBase;
        private readonly HttpRequestMessage _request;

        private X509Certificate2 _clientCertificate;
        private bool _clientCertificateSet;

        private HttpConfiguration _configuration;
        private bool _configurationSet;

        private bool _includeErrorDetail;
        private bool _includeErrorDetailSet;

        private bool _isLocal;
        private bool _isLocalSet;

        private UrlHelper _url;
        private bool _urlSet;

        private string _virtualPathRoot;
        private bool _virtualPathRootSet;

        public WebHostHttpRequestContext(HttpContextBase contextBase, HttpRequestBase requestBase,
            HttpRequestMessage request)
        {
            Contract.Assert(contextBase != null);
            Contract.Assert(requestBase != null);
            Contract.Assert(request != null);
            _contextBase = contextBase;
            _requestBase = requestBase;
            _request = request;
        }

        public HttpContextBase Context
        {
            get { return _contextBase; }
        }

        public HttpRequestBase WebRequest
        {
            get { return _requestBase; }
        }

        public HttpRequestMessage Request
        {
            get { return _request; }
        }

        // RouteData is not overridden; it is provided by a later point in the pipeline
        //  (HttpControllerHandler.ProcessRequestAsyncCore).

        public override X509Certificate2 ClientCertificate
        {
            get
            {
                if (!_clientCertificateSet)
                {
                    X509Certificate2 value;

                    if (_requestBase.ClientCertificate != null && _requestBase.ClientCertificate.Certificate != null
                        && _requestBase.ClientCertificate.Certificate.Length > 0)
                    {
                        value = new X509Certificate2(_requestBase.ClientCertificate.Certificate);
                    }
                    else
                    {
                        value = null;
                    }

                    _clientCertificate = value;
                    _clientCertificateSet = true;
                }

                return _clientCertificate;
            }
            set
            {
                _clientCertificate = value;
                _clientCertificateSet = true;
            }
        }

        public override HttpConfiguration Configuration
        {
            get
            {
                if (!_configurationSet)
                {
                    _configuration = GlobalConfiguration.Configuration;
                    _configurationSet = true;
                }

                return _configuration;
            }
            set
            {
                _configuration = value;
                _configurationSet = true;
            }
        }

        public override bool IncludeErrorDetail
        {
            get
            {
                if (!_includeErrorDetailSet)
                {
                    IncludeErrorDetailPolicy includeErrorDetailPolicy;

                    if (_configuration != null)
                    {
                        includeErrorDetailPolicy = _configuration.IncludeErrorDetailPolicy;
                    }
                    else
                    {
                        includeErrorDetailPolicy = IncludeErrorDetailPolicy.Default;
                    }

                    bool value;

                    switch (includeErrorDetailPolicy)
                    {
                        case IncludeErrorDetailPolicy.Default:
                            value = !_contextBase.IsCustomErrorEnabled;
                            break;

                        case IncludeErrorDetailPolicy.LocalOnly:
                            value = IsLocal;
                            break;

                        case IncludeErrorDetailPolicy.Always:
                            value = true;
                            break;

                        case IncludeErrorDetailPolicy.Never:
                        default:
                            value = false;
                            break;
                    }

                    _includeErrorDetail = value;
                    _includeErrorDetailSet = true;
                }

                return _includeErrorDetail;
            }
            set
            {
                _includeErrorDetail = value;
                _includeErrorDetailSet = true;
            }
        }

        public override bool IsLocal
        {
            get
            {
                if (!_isLocalSet)
                {
                    _isLocal = _requestBase.IsLocal;
                    _isLocalSet = true;
                }

                return _isLocal;
            }
            set
            {
                _isLocal = value;
                _isLocalSet = true;
            }
        }

        public override IPrincipal Principal
        {
            get
            {
                return _contextBase.User;
            }
            set
            {
                _contextBase.User = value;
                Thread.CurrentPrincipal = value;
            }
        }

        public override UrlHelper Url
        {
            get
            {
                if (!_urlSet)
                {
                    _url = new UrlHelper(_request);
                    _urlSet = true;
                }

                return _url;
            }
            set
            {
                _url = value;
                _urlSet = true;
            }
        }

        public override string VirtualPathRoot
        {
            get
            {
                if (!_virtualPathRootSet)
                {
                    string value;

                    if (_configuration != null)
                    {
                        value = _configuration.VirtualPathRoot;
                    }
                    else
                    {
                        value = null;
                    }

                    _virtualPathRoot = value;
                    _virtualPathRootSet = true;
                }

                return _virtualPathRoot;
            }
            set
            {
                _virtualPathRoot = value;
                _virtualPathRootSet = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Http.WebHost/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.Mvc/AcceptVerbsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification = "The accessor is exposed as an ICollection<string>.")]
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class AcceptVerbsAttribute : ActionMethodSelectorAttribute
    {
        public AcceptVerbsAttribute(HttpVerbs verbs)
            : this(EnumToArray(verbs))
        {
        }

        public AcceptVerbsAttribute(params string[] verbs)
        {
            if (verbs == null || verbs.Length == 0)
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "verbs");
            }

            Verbs = new ReadOnlyCollection<string>(verbs);
        }

        public ICollection<string> Verbs { get; private set; }

        private static void AddEntryToList(HttpVerbs verbs, HttpVerbs match, List<string> verbList, string entryText)
        {
            if ((verbs & match) != 0)
            {
                verbList.Add(entryText);
            }
        }

        internal static string[] EnumToArray(HttpVerbs verbs)
        {
            List<string> verbList = new List<string>();

            AddEntryToList(verbs, HttpVerbs.Get, verbList, "GET");
            AddEntryToList(verbs, HttpVerbs.Post, verbList, "POST");
            AddEntryToList(verbs, HttpVerbs.Put, verbList, "PUT");
            AddEntryToList(verbs, HttpVerbs.Delete, verbList, "DELETE");
            AddEntryToList(verbs, HttpVerbs.Head, verbList, "HEAD");
            AddEntryToList(verbs, HttpVerbs.Patch, verbList, "PATCH");
            AddEntryToList(verbs, HttpVerbs.Options, verbList, "OPTIONS");

            return verbList.ToArray();
        }

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            string incomingVerb = controllerContext.HttpContext.Request.GetHttpMethodOverride();

            return Verbs.Contains(incomingVerb, StringComparer.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public abstract class ActionDescriptor : ICustomAttributeProvider, IUniquelyIdentifiable
    {
        private static readonly ActionMethodDispatcherCache _staticDispatcherCache = new ActionMethodDispatcherCache();

        private static readonly ActionSelector[] _emptySelectors = new ActionSelector[0];
        private static readonly ActionNameSelector[] _emptyNameSelectors = new ActionNameSelector[0];
        private string _uniqueId;
        private ActionMethodDispatcherCache _instanceDispatcherCache;

        protected ActionDescriptor()
        {
        }

        public abstract string ActionName { get; }

        public abstract ControllerDescriptor ControllerDescriptor { get; }

        internal ActionMethodDispatcherCache DispatcherCache
        {
            get
            {
                if (_instanceDispatcherCache == null)
                {
                    _instanceDispatcherCache = _staticDispatcherCache;
                }
                return _instanceDispatcherCache;
            }
            set { _instanceDispatcherCache = value; }
        }

        [SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces", Justification = "This is overridden elsewhere in System.Web.Mvc")]
        public virtual string UniqueId
        {
            get 
            {
                if (_uniqueId == null)
                {
                    _uniqueId = CreateUniqueId();
                }
                return _uniqueId; 
            }
        }

        private string CreateUniqueId()
        {
            return DescriptorUtil.CreateUniqueId(GetType(), ControllerDescriptor, ActionName);
        }

        public abstract object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters);

        internal static object ExtractParameterFromDictionary(ParameterInfo parameterInfo, IDictionary<string, object> parameters, MethodInfo methodInfo)
        {
            object value;

            if (!parameters.TryGetValue(parameterInfo.Name, out value))
            {
                // the key should always be present, even if the parameter value is null
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_ParameterNotInDictionary,
                                               parameterInfo.Name, parameterInfo.ParameterType, methodInfo, methodInfo.DeclaringType);
                throw new ArgumentException(message, "parameters");
            }

            if (value == null && !TypeHelpers.TypeAllowsNullValue(parameterInfo.ParameterType))
            {
                // tried to pass a null value for a non-nullable parameter type
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_ParameterCannotBeNull,
                                               parameterInfo.Name, parameterInfo.ParameterType, methodInfo, methodInfo.DeclaringType);
                throw new ArgumentException(message, "parameters");
            }

            if (value != null && !parameterInfo.ParameterType.IsInstanceOfType(value))
            {
                // value was supplied but is not of the proper type
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_ParameterValueHasWrongType,
                                               parameterInfo.Name, methodInfo, methodInfo.DeclaringType, value.GetType(), parameterInfo.ParameterType);
                throw new ArgumentException(message, "parameters");
            }

            return value;
        }

        internal static object ExtractParameterOrDefaultFromDictionary(ParameterInfo parameterInfo, IDictionary<string, object> parameters)
        {
            Type parameterType = parameterInfo.ParameterType;

            object value;
            parameters.TryGetValue(parameterInfo.Name, out value);

            // if wrong type, replace with default instance
            if (parameterType.IsInstanceOfType(value))
            {
                return value;
            }
            else
            {
                object defaultValue;
                if (ParameterInfoUtil.TryGetDefaultValue(parameterInfo, out defaultValue))
                {
                    return defaultValue;
                }
                else
                {
                    return TypeHelpers.GetDefaultValue(parameterType);
                }
            }
        }

        public virtual object[] GetCustomAttributes(bool inherit)
        {
            return GetCustomAttributes(typeof(object), inherit);
        }

        public virtual object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }

            return (object[])Array.CreateInstance(attributeType, 0);
        }

        public virtual IEnumerable<FilterAttribute> GetFilterAttributes(bool useCache)
        {
            return GetCustomAttributes(typeof(FilterAttribute), inherit: true).Cast<FilterAttribute>();
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        [Obsolete("Please call System.Web.Mvc.FilterProviders.Providers.GetFilters() now.", true)]
        public virtual FilterInfo GetFilters()
        {
            return new FilterInfo();
        }

        public abstract ParameterDescriptor[] GetParameters();

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method may perform non-trivial work.")]
        public virtual ICollection<ActionSelector> GetSelectors()
        {
            return _emptySelectors;
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method may perform non-trivial work.")]
        internal virtual ICollection<ActionNameSelector> GetNameSelectors()
        {
            return _emptyNameSelectors;
        }

        public virtual bool IsDefined(Type attributeType, bool inherit)
        {
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }

            return false;
        }

        internal static string VerifyActionMethodIsCallable(MethodInfo methodInfo)
        {
            // we can't call static methods
            if (methodInfo.IsStatic)
            {
                return String.Format(CultureInfo.CurrentCulture,
                                     MvcResources.ReflectedActionDescriptor_CannotCallStaticMethod,
                                     methodInfo,
                                     methodInfo.ReflectedType.FullName);
            }

            // we can't call instance methods where the 'this' parameter is a type other than ControllerBase
            if (!typeof(ControllerBase).IsAssignableFrom(methodInfo.ReflectedType))
            {
                return String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_CannotCallInstanceMethodOnNonControllerType,
                                     methodInfo, methodInfo.ReflectedType.FullName);
            }

            // we can't call methods with open generic type parameters
            if (methodInfo.ContainsGenericParameters)
            {
                return String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_CannotCallOpenGenericMethods,
                                     methodInfo, methodInfo.ReflectedType.FullName);
            }

            // we can't call methods with ref/out parameters
            ParameterInfo[] parameterInfos = methodInfo.GetParameters();
            foreach (ParameterInfo parameterInfo in parameterInfos)
            {
                if (parameterInfo.IsOut || parameterInfo.ParameterType.IsByRef)
                {
                    return String.Format(CultureInfo.CurrentCulture, MvcResources.ReflectedActionDescriptor_CannotCallMethodsWithOutOrRefParameters,
                                         methodInfo, methodInfo.ReflectedType.FullName, parameterInfo);
                }
            }

            // we can call this method
            return null;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionDescriptorHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;

namespace System.Web.Mvc
{
    internal static class ActionDescriptorHelper
    {
        public static ICollection<ActionSelector> GetSelectors(MethodInfo methodInfo)
        {
            ActionMethodSelectorAttribute[] attrs = (ActionMethodSelectorAttribute[])methodInfo.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), inherit: true);
            ActionSelector[] selectors = Array.ConvertAll(attrs, attr => (ActionSelector)(controllerContext => attr.IsValidForRequest(controllerContext, methodInfo)));
            return selectors;
        }

        public static ICollection<ActionNameSelector> GetNameSelectors(MethodInfo methodInfo)
        {
            ActionNameSelectorAttribute[] attrs = (ActionNameSelectorAttribute[])methodInfo.GetCustomAttributes(typeof(ActionNameSelectorAttribute), inherit: true);
            ActionNameSelector[] selectors = Array.ConvertAll(attrs, attr => (ActionNameSelector)((controllerContext, actionName) => attr.IsValidName(controllerContext, actionName, methodInfo)));
            return selectors;
        }

        public static bool IsDefined(MemberInfo methodInfo, Type attributeType, bool inherit)
        {
            return methodInfo.IsDefined(attributeType, inherit);
        }

        public static object[] GetCustomAttributes(MemberInfo methodInfo, bool inherit)
        {
            return methodInfo.GetCustomAttributes(inherit);
        }

        public static object[] GetCustomAttributes(MemberInfo methodInfo, Type attributeType, bool inherit)
        {
            return methodInfo.GetCustomAttributes(attributeType, inherit);
        }

        public static ParameterDescriptor[] GetParameters(ActionDescriptor actionDescriptor, MethodInfo methodInfo, ref ParameterDescriptor[] parametersCache)
        {
            ParameterDescriptor[] parameters = LazilyFetchParametersCollection(actionDescriptor, methodInfo, ref parametersCache);

            // need to clone array so that user modifications aren't accidentally stored
            return (ParameterDescriptor[])parameters.Clone();
        }

        private static ParameterDescriptor[] LazilyFetchParametersCollection(ActionDescriptor actionDescriptor, MethodInfo methodInfo, ref ParameterDescriptor[] parametersCache)
        {
            // Frequently called, so ensure the delegates remain static
            return DescriptorUtil.LazilyFetchOrCreateDescriptors(
                cacheLocation: ref parametersCache,
                initializer: (CreateDescriptorState state) => state.MethodInfo.GetParameters(),
                converter: (ParameterInfo parameterInfo, CreateDescriptorState state) => new ReflectedParameterDescriptor(parameterInfo, state.ActionDescriptor),
                state: new CreateDescriptorState() { ActionDescriptor = actionDescriptor, MethodInfo = methodInfo });
        }

        // Used to pass generic arguments to frequently called delegates, so keep as a struct to prevent heap allocation
        private struct CreateDescriptorState
        {
            internal ActionDescriptor ActionDescriptor;
            internal MethodInfo MethodInfo;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionExecutedContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class ActionExecutedContext : ControllerContext
    {
        private ActionResult _result;

        // parameterless constructor used for mocking
        public ActionExecutedContext()
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public ActionExecutedContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor, bool canceled, Exception exception)
            : base(controllerContext)
        {
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            ActionDescriptor = actionDescriptor;
            Canceled = canceled;
            Exception = exception;
        }

        public virtual ActionDescriptor ActionDescriptor { get; set; }

        public virtual bool Canceled { get; set; }

        public virtual Exception Exception { get; set; }

        public bool ExceptionHandled { get; set; }

        public ActionResult Result
        {
            get { return _result ?? EmptyResult.Instance; }
            set { _result = value; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionExecutingContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class ActionExecutingContext : ControllerContext
    {
        // parameterless constructor used for mocking
        public ActionExecutingContext()
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public ActionExecutingContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> actionParameters)
            : base(controllerContext)
        {
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }
            if (actionParameters == null)
            {
                throw new ArgumentNullException("actionParameters");
            }

            ActionDescriptor = actionDescriptor;
            ActionParameters = actionParameters;
        }

        public virtual ActionDescriptor ActionDescriptor { get; set; }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "The property setter is only here to support mocking this type and should not be called at runtime.")]
        public virtual IDictionary<string, object> ActionParameters { get; set; }

        public ActionResult Result { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionFilterAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public abstract class ActionFilterAttribute : FilterAttribute, IActionFilter, IResultFilter
    {
        // The OnXxx() methods are virtual rather than abstract so that a developer need override
        // only the ones that interest him.

        public virtual void OnActionExecuting(ActionExecutingContext filterContext)
        {
        }

        public virtual void OnActionExecuted(ActionExecutedContext filterContext)
        {
        }

        public virtual void OnResultExecuting(ResultExecutingContext filterContext)
        {
        }

        public virtual void OnResultExecuted(ResultExecutedContext filterContext)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionMethodDispatcher.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;

namespace System.Web.Mvc
{
    // The methods in this class don't perform error checking; that is the responsibility of the
    // caller.
    internal sealed class ActionMethodDispatcher
    {
        private ActionExecutor _executor;

        public ActionMethodDispatcher(MethodInfo methodInfo)
        {
            _executor = GetExecutor(methodInfo);
            MethodInfo = methodInfo;
        }

        private delegate object ActionExecutor(ControllerBase controller, object[] parameters);

        private delegate void VoidActionExecutor(ControllerBase controller, object[] parameters);

        public MethodInfo MethodInfo { get; private set; }

        public object Execute(ControllerBase controller, object[] parameters)
        {
            return _executor(controller, parameters);
        }

        private static ActionExecutor GetExecutor(MethodInfo methodInfo)
        {
            // Parameters to executor
            ParameterExpression controllerParameter = Expression.Parameter(typeof(ControllerBase), "controller");
            ParameterExpression parametersParameter = Expression.Parameter(typeof(object[]), "parameters");

            // Build parameter list
            List<Expression> parameters = new List<Expression>();
            ParameterInfo[] paramInfos = methodInfo.GetParameters();
            for (int i = 0; i < paramInfos.Length; i++)
            {
                ParameterInfo paramInfo = paramInfos[i];
                BinaryExpression valueObj = Expression.ArrayIndex(parametersParameter, Expression.Constant(i));
                UnaryExpression valueCast = Expression.Convert(valueObj, paramInfo.ParameterType);

                // valueCast is "(Ti) parameters[i]"
                parameters.Add(valueCast);
            }

            // Call method
            UnaryExpression instanceCast = (!methodInfo.IsStatic) ? Expression.Convert(controllerParameter, methodInfo.ReflectedType) : null;
            MethodCallExpression methodCall = methodCall = Expression.Call(instanceCast, methodInfo, parameters);

            // methodCall is "((TController) controller) method((T0) parameters[0], (T1) parameters[1], ...)"
            // Create function
            if (methodCall.Type == typeof(void))
            {
                Expression<VoidActionExecutor> lambda = Expression.Lambda<VoidActionExecutor>(methodCall, controllerParameter, parametersParameter);
                VoidActionExecutor voidExecutor = lambda.Compile();
                return WrapVoidAction(voidExecutor);
            }
            else
            {
                // must coerce methodCall to match ActionExecutor signature
                UnaryExpression castMethodCall = Expression.Convert(methodCall, typeof(object));
                Expression<ActionExecutor> lambda = Expression.Lambda<ActionExecutor>(castMethodCall, controllerParameter, parametersParameter);
                return lambda.Compile();
            }
        }

        private static ActionExecutor WrapVoidAction(VoidActionExecutor executor)
        {
            return delegate(ControllerBase controller, object[] parameters)
            {
                executor(controller, parameters);
                return null;
            };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionMethodDispatcherCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    internal sealed class ActionMethodDispatcherCache : ReaderWriterCache<MethodInfo, ActionMethodDispatcher>
    {
        public ActionMethodDispatcherCache()
        {
        }

        public ActionMethodDispatcher GetDispatcher(MethodInfo methodInfo)
        {
            // Frequently called, so ensure delegate remains static
            return FetchOrCreateItem(methodInfo, (MethodInfo methodInfoInner) => new ActionMethodDispatcher(methodInfoInner), methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionMethodSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    internal sealed class ActionMethodSelector : ActionMethodSelectorBase
    {
        public ActionMethodSelector(Type controllerType)            
        {
            Initialize(controllerType);
        }
                
        protected override bool IsValidActionMethod(MethodInfo methodInfo)
        {
            return !(methodInfo.IsSpecialName ||
                     methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(Controller)));
        }        
    }
}


================================================
FILE: src/System.Web.Mvc/ActionMethodSelectorAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public abstract class ActionMethodSelectorAttribute : Attribute
    {
        /// <summary>
        /// Determines whether the action method selection is valid for the specified controller context.
        /// </summary>
        /// <param name="controllerContext">The controller context.</param>
        /// <param name="methodInfo">Information about the action method.</param>
        /// <returns><see langword="true"/> if the action method selection is valid for the specified controller context; otherwise, <see langword="false"/>.</returns>
        public abstract bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo);
    }
}


================================================
FILE: src/System.Web.Mvc/ActionMethodSelectorBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using System.Web.Mvc.Async;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;
using System.Web.Routing;

namespace System.Web.Mvc
{
    // Common base class for Async and Sync action selectors
    internal abstract class ActionMethodSelectorBase
    {
        private StandardRouteActionMethodCache _standardRouteCache;

        protected void Initialize(Type controllerType)
        {
            ControllerType = controllerType;

            var allMethods = ControllerType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public);
            ActionMethods = Array.FindAll(allMethods, IsValidActionMethod);

            // The attribute routing mapper will remove methods from this set as they are mapped.
            // The lookup tables are initialized lazily to ensure that direct routing's changes are respected.
            StandardRouteMethods = new HashSet<MethodInfo>(ActionMethods);
        }

        public Type ControllerType { get; private set; }

        /// <summary>
        /// All action methods.
        /// </summary>
        public MethodInfo[] ActionMethods { get; private set; }

        /// <summary>
        /// Methods with no direct route, reachable via standard routing only
        /// </summary>
        public HashSet<MethodInfo> StandardRouteMethods { get; private set; }

        /// <summary>
        /// Methods which have ActionNameSelectorAttributes - these methods have dynamic functionality
        /// and might choose to opt-in to any request.
        /// </summary>
        public MethodInfo[] AliasedMethods 
        { 
            get 
            {
                return StandardRouteCache.AliasedMethods;
            }
        }

        /// <summary>
        /// Methods which do not have ActionNameSelectorAttributes - these are selected statically by name.
        /// </summary>
        public ILookup<string, MethodInfo> NonAliasedMethods
        {
            get
            {
                return StandardRouteCache.NonAliasedMethods;
            }
        }

        private StandardRouteActionMethodCache StandardRouteCache
        {
            get
            {
                if (_standardRouteCache == null)
                {
                    // This data structure is immutable, so it's safe for multiple threads to race to create it.
                    _standardRouteCache = CreateStandardRouteCache();
                }

                return _standardRouteCache;
            }
        }

        protected AmbiguousMatchException CreateAmbiguousActionMatchException(IEnumerable<MethodInfo> ambiguousMethods, string actionName)
        {
            string ambiguityList = CreateAmbiguousMatchList(ambiguousMethods);
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ActionMethodSelector_AmbiguousMatch,
                                           actionName, ControllerType.Name, ambiguityList);
            return new AmbiguousMatchException(message);
        }

        protected AmbiguousMatchException CreateAmbiguousMethodMatchException(IEnumerable<MethodInfo> ambiguousMethods, string methodName)
        {
            string ambiguityList = CreateAmbiguousMatchList(ambiguousMethods);
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.AsyncActionMethodSelector_AmbiguousMethodMatch,
                                           methodName, ControllerType.Name, ambiguityList);
            return new AmbiguousMatchException(message);
        }

        protected static string CreateAmbiguousMatchList(IEnumerable<MethodInfo> ambiguousMethods)
        {
            StringBuilder exceptionMessageBuilder = new StringBuilder();
            foreach (MethodInfo methodInfo in ambiguousMethods)
            {
                string controllerAction = Convert.ToString(methodInfo, CultureInfo.CurrentCulture);
                string controllerType = methodInfo.DeclaringType.FullName;

                exceptionMessageBuilder.AppendLine();
                exceptionMessageBuilder.AppendFormat(CultureInfo.CurrentCulture, MvcResources.ActionMethodSelector_AmbiguousMatchType, controllerAction, controllerType);
            }

            return exceptionMessageBuilder.ToString();
        }

        private static bool IsMethodDecoratedWithAliasingAttribute(MethodInfo methodInfo)
        {
            return methodInfo.IsDefined(typeof(ActionNameSelectorAttribute), true /* inherit */);
        }

        protected abstract bool IsValidActionMethod(MethodInfo methodInfo);

        // Get the method name (before applying Aliasing attributes).
        protected virtual string GetCanonicalMethodName(MethodInfo methodInfo)
        {
            string methodName = methodInfo.Name;
            return methodName;
        }

        private StandardRouteActionMethodCache CreateStandardRouteCache()
        {
            var cache = new StandardRouteActionMethodCache();
            cache.AliasedMethods = StandardRouteMethods.Where(IsMethodDecoratedWithAliasingAttribute).ToArray();
            cache.NonAliasedMethods = StandardRouteMethods
                .Except(cache.AliasedMethods)
                .ToLookup(GetCanonicalMethodName, StringComparer.OrdinalIgnoreCase);

            return cache;
        }

        protected List<MethodInfo> FindActionMethods(ControllerContext controllerContext, string actionName)
        {
            List<MethodInfo> matches = new List<MethodInfo>();

            var cache = StandardRouteCache;

            // Performance sensitive, so avoid foreach
            for (int i = 0; i < cache.AliasedMethods.Length; i++)
            {
                MethodInfo method = cache.AliasedMethods[i];
                if (IsMatchingAliasedMethod(method, controllerContext, actionName))
                {
                    matches.Add(method);
                }
            }
            matches.AddRange(cache.NonAliasedMethods[actionName]);
            RunSelectionFilters(controllerContext, matches);
            return matches;
        }

        protected static bool IsMatchingAliasedMethod(MethodInfo method, ControllerContext controllerContext, string actionName)
        {
            // return if aliased method is opting in to this request
            // to opt in, all attributes defined on the method must return true
            ReadOnlyCollection<ActionNameSelectorAttribute> attributes = ReflectedAttributeCache.GetActionNameSelectorAttributes(method);
            // Caching count is faster for ReadOnlyCollection
            int attributeCount = attributes.Count;
            // Performance sensitive, so avoid foreach
            for (int i = 0; i < attributeCount; i++)
            {
                if (!attributes[i].IsValidName(controllerContext, actionName, method))
                {
                    return false;
                }
            }
            return true;
        }

        protected static bool IsValidMethodSelector(ReadOnlyCollection<ActionMethodSelectorAttribute> attributes, ControllerContext controllerContext, MethodInfo method)
        {
            int attributeCount = attributes.Count;
            Contract.Assert(attributeCount > 0);
            for (int i = 0; i < attributeCount; i++)
            {
                if (!attributes[i].IsValidForRequest(controllerContext, method))
                {
                    return false;
                }
            }
            return true;
        }

        protected static void RunSelectionFilters(ControllerContext controllerContext, List<MethodInfo> methodInfos)
        {
            // Filter depending on the selection attribute.
            // Methods with valid selection attributes override all others.
            // Methods with one or more invalid selection attributes are removed.

            bool hasValidSelectionAttributes = false;
            // loop backwards for fastest removal
            for (int i = methodInfos.Count - 1; i >= 0; i--)
            {
                MethodInfo methodInfo = methodInfos[i];
                ReadOnlyCollection<ActionMethodSelectorAttribute> attrs = ReflectedAttributeCache.GetActionMethodSelectorAttributesCollection(methodInfo);
                if (attrs.Count == 0)
                {
                    // case 1: this method does not have a MethodSelectionAttribute

                    if (hasValidSelectionAttributes)
                    {
                        // if there is already method with a valid selection attribute, remove method without one
                        methodInfos.RemoveAt(i);
                    }
                }
                else if (IsValidMethodSelector(attrs, controllerContext, methodInfo))
                {
                    // case 2: this method has MethodSelectionAttributes that are all valid

                    // if a matching action method had a selection attribute, consider it more specific than a matching action method
                    // without a selection attribute
                    if (!hasValidSelectionAttributes)
                    {
                        // when the first selection attribute is discovered, remove any items later in the list without selection attributes
                        if (i + 1 < methodInfos.Count)
                        {
                            methodInfos.RemoveFrom(i + 1);
                        }
                        hasValidSelectionAttributes = true;
                    }
                }
                else
                {
                    // case 3: this method has a method selection attribute but it is not valid

                    // remove the method since it is opting out of this request
                    methodInfos.RemoveAt(i);
                }
            }
        }

        // Get the action name for the method.         
        public string GetActionName(MethodInfo methodInfo)
        {
            // Check for ActionName attribute
            object[] nameAttributes = methodInfo.GetCustomAttributes(typeof(ActionNameAttribute), inherit: true);
            if (nameAttributes.Length > 0)
            {
                ActionNameAttribute nameAttribute = nameAttributes[0] as ActionNameAttribute;
                if (nameAttribute != null)
                {
                    return nameAttribute.Name;
                }
            }

            return GetCanonicalMethodName(methodInfo);
        }

        public MethodInfo FindActionMethod(ControllerContext controllerContext, string actionName)
        {
            if (controllerContext == null)
            {
                throw Error.ArgumentNull("controllerContext");
            }

            if (actionName == null)
            {
                throw Error.ArgumentNull("actionName");
            }

            List<MethodInfo> finalMethods = FindActionMethods(controllerContext, actionName);

            switch (finalMethods.Count)
            {
                case 0:
                    return null;

                case 1:
                    return finalMethods[0];

                default:
                    throw CreateAmbiguousActionMatchException(finalMethods, actionName);
            }
        }

        private class StandardRouteActionMethodCache
        {
            public MethodInfo[] AliasedMethods { get; set; }

            public ILookup<string, MethodInfo> NonAliasedMethods { get; set; }
        }
    }
}

================================================
FILE: src/System.Web.Mvc/ActionNameAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class ActionNameAttribute : ActionNameSelectorAttribute
    {
        public ActionNameAttribute(string name)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
            }

            Name = name;
        }

        public string Name { get; private set; }

        public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo)
        {
            return String.Equals(actionName, Name, StringComparison.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ActionNameSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal delegate bool ActionNameSelector(ControllerContext controllerContext, string actionName);
}

================================================
FILE: src/System.Web.Mvc/ActionNameSelectorAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public abstract class ActionNameSelectorAttribute : Attribute
    {
        public abstract bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo);
    }
}


================================================
FILE: src/System.Web.Mvc/ActionResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public abstract class ActionResult
    {
        public abstract void ExecuteResult(ControllerContext context);
    }
}


================================================
FILE: src/System.Web.Mvc/ActionSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public delegate bool ActionSelector(ControllerContext controllerContext);
}


================================================
FILE: src/System.Web.Mvc/AdditionalMetaDataAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface | AttributeTargets.Property, AllowMultiple = true)]
    public sealed class AdditionalMetadataAttribute : Attribute, IMetadataAware
    {
        private object _typeId = new object();

        public AdditionalMetadataAttribute(string name, object value)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            Name = name;
            Value = value;
        }

        public override object TypeId
        {
            get { return _typeId; }
        }

        public string Name { get; private set; }

        public object Value { get; private set; }

        public void OnMetadataCreated(ModelMetadata metadata)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }

            metadata.AdditionalValues[Name] = Value;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Ajax/AjaxExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Html;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc.Ajax
{
    public static class AjaxExtensions
    {
        private const string LinkOnClickFormat = "Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), {0});";
        private const string FormOnClickValue = "Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));";
        private const string FormOnSubmitFormat = "Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), {0});";

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, AjaxOptions ajaxOptions)
        {
            return ActionLink(ajaxHelper, linkText, actionName, (string)null /* controllerName */, ajaxOptions);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, object routeValues, AjaxOptions ajaxOptions)
        {
            return ActionLink(ajaxHelper, linkText, actionName, (string)null /* controllerName */, routeValues, ajaxOptions);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            return ActionLink(ajaxHelper, linkText, actionName, (string)null /* controllerName */, routeValues, ajaxOptions, htmlAttributes);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions)
        {
            return ActionLink(ajaxHelper, linkText, actionName, (string)null /* controllerName */, routeValues, ajaxOptions);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            return ActionLink(ajaxHelper, linkText, actionName, (string)null /* controllerName */, routeValues, ajaxOptions, htmlAttributes);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, string controllerName, AjaxOptions ajaxOptions)
        {
            return ActionLink(ajaxHelper, linkText, actionName, controllerName, null /* values */, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, string controllerName, object routeValues, AjaxOptions ajaxOptions)
        {
            return ActionLink(ajaxHelper, linkText, actionName, controllerName, routeValues, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, string controllerName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            RouteValueDictionary newValues = TypeHelper.ObjectToDictionary(routeValues);
            RouteValueDictionary newAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            return ActionLink(ajaxHelper, linkText, actionName, controllerName, newValues, ajaxOptions, newAttributes);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, string controllerName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions)
        {
            return ActionLink(ajaxHelper, linkText, actionName, controllerName, routeValues, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, string controllerName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }

            string targetUrl = UrlHelper.GenerateUrl(null, actionName, controllerName, routeValues, ajaxHelper.RouteCollection, ajaxHelper.ViewContext.RequestContext, true /* includeImplicitMvcValues */);

            return MvcHtmlString.Create(GenerateLink(ajaxHelper, linkText, targetUrl, GetAjaxOptions(ajaxOptions), htmlAttributes));
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, string controllerName, string protocol, string hostName, string fragment, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            RouteValueDictionary newValues = TypeHelper.ObjectToDictionary(routeValues);
            RouteValueDictionary newAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            return ActionLink(ajaxHelper, linkText, actionName, controllerName, protocol, hostName, fragment, newValues, ajaxOptions, newAttributes);
        }

        public static MvcHtmlString ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, string controllerName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }

            string targetUrl = UrlHelper.GenerateUrl(null /* routeName */, actionName, controllerName, protocol, hostName, fragment, routeValues, ajaxHelper.RouteCollection, ajaxHelper.ViewContext.RequestContext, true /* includeImplicitMvcValues */);

            return MvcHtmlString.Create(GenerateLink(ajaxHelper, linkText, targetUrl, ajaxOptions, htmlAttributes));
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, AjaxOptions ajaxOptions)
        {
            string formAction = ajaxHelper.ViewContext.HttpContext.Request.RawUrl;
            return FormHelper(ajaxHelper, formAction, ajaxOptions, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, AjaxOptions ajaxOptions)
        {
            return BeginForm(ajaxHelper, actionName, (string)null /* controllerName */, ajaxOptions);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, object routeValues, AjaxOptions ajaxOptions)
        {
            return BeginForm(ajaxHelper, actionName, (string)null /* controllerName */, routeValues, ajaxOptions);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            return BeginForm(ajaxHelper, actionName, (string)null /* controllerName */, routeValues, ajaxOptions, htmlAttributes);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions)
        {
            return BeginForm(ajaxHelper, actionName, (string)null /* controllerName */, routeValues, ajaxOptions);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            return BeginForm(ajaxHelper, actionName, (string)null /* controllerName */, routeValues, ajaxOptions, htmlAttributes);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, string controllerName, AjaxOptions ajaxOptions)
        {
            return BeginForm(ajaxHelper, actionName, controllerName, null /* values */, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, string controllerName, object routeValues, AjaxOptions ajaxOptions)
        {
            return BeginForm(ajaxHelper, actionName, controllerName, routeValues, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, string controllerName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            RouteValueDictionary newValues = new RouteValueDictionary(routeValues);
            RouteValueDictionary newAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            return BeginForm(ajaxHelper, actionName, controllerName, newValues, ajaxOptions, newAttributes);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, string controllerName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions)
        {
            return BeginForm(ajaxHelper, actionName, controllerName, routeValues, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcForm BeginForm(this AjaxHelper ajaxHelper, string actionName, string controllerName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            // get target URL
            string formAction = UrlHelper.GenerateUrl(null, actionName, controllerName, routeValues ?? new RouteValueDictionary(), ajaxHelper.RouteCollection, ajaxHelper.ViewContext.RequestContext, true /* includeImplicitMvcValues */);
            return FormHelper(ajaxHelper, formAction, ajaxOptions, htmlAttributes);
        }

        public static MvcForm BeginRouteForm(this AjaxHelper ajaxHelper, string routeName, AjaxOptions ajaxOptions)
        {
            return BeginRouteForm(ajaxHelper, routeName, null /* routeValues */, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcForm BeginRouteForm(this AjaxHelper ajaxHelper, string routeName, object routeValues, AjaxOptions ajaxOptions)
        {
            return BeginRouteForm(ajaxHelper, routeName, (object)routeValues, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcForm BeginRouteForm(this AjaxHelper ajaxHelper, string routeName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            RouteValueDictionary newAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            return BeginRouteForm(ajaxHelper, routeName, new RouteValueDictionary(routeValues), ajaxOptions, newAttributes);
        }

        public static MvcForm BeginRouteForm(this AjaxHelper ajaxHelper, string routeName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions)
        {
            return BeginRouteForm(ajaxHelper, routeName, routeValues, ajaxOptions, null /* htmlAttributes */);
        }

        public static MvcForm BeginRouteForm(this AjaxHelper ajaxHelper, string routeName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            string formAction = UrlHelper.GenerateUrl(routeName, null /* actionName */, null /* controllerName */, routeValues ?? new RouteValueDictionary(), ajaxHelper.RouteCollection, ajaxHelper.ViewContext.RequestContext, false /* includeImplicitMvcValues */);
            return FormHelper(ajaxHelper, formAction, ajaxOptions, htmlAttributes);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "You don't want to dispose of this object unless you intend to write to the response")]
        private static MvcForm FormHelper(this AjaxHelper ajaxHelper, string formAction, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            TagBuilder builder = new TagBuilder("form");
            builder.MergeAttributes(htmlAttributes);
            builder.MergeAttribute("action", formAction);
            builder.MergeAttribute("method", "post");

            ajaxOptions = GetAjaxOptions(ajaxOptions);

            if (ajaxHelper.ViewContext.UnobtrusiveJavaScriptEnabled)
            {
                builder.MergeAttributes(ajaxOptions.ToUnobtrusiveHtmlAttributes());
            }
            else
            {
                builder.MergeAttribute("onclick", FormOnClickValue);
                builder.MergeAttribute("onsubmit", GenerateAjaxScript(ajaxOptions, FormOnSubmitFormat));
            }

            if (ajaxHelper.ViewContext.ClientValidationEnabled)
            {
                // forms must have an ID for client validation
                builder.GenerateId(ajaxHelper.ViewContext.FormIdGenerator());
            }

            ajaxHelper.ViewContext.Writer.Write(builder.ToString(TagRenderMode.StartTag));
            MvcForm theForm = new MvcForm(ajaxHelper.ViewContext);

            if (ajaxHelper.ViewContext.ClientValidationEnabled)
            {
                ajaxHelper.ViewContext.FormContext.FormId = builder.Attributes["id"];
            }

            return theForm;
        }

        public static MvcHtmlString GlobalizationScript(this AjaxHelper ajaxHelper)
        {
            return GlobalizationScript(ajaxHelper, CultureInfo.CurrentCulture);
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "ajaxHelper", Justification = "This is an extension method")]
        public static MvcHtmlString GlobalizationScript(this AjaxHelper ajaxHelper, CultureInfo cultureInfo)
        {
            return GlobalizationScriptHelper(AjaxHelper.GlobalizationScriptPath, cultureInfo);
        }

        internal static MvcHtmlString GlobalizationScriptHelper(string scriptPath, CultureInfo cultureInfo)
        {
            if (cultureInfo == null)
            {
                throw new ArgumentNullException("cultureInfo");
            }

            TagBuilder tagBuilder = new TagBuilder("script");
            tagBuilder.MergeAttribute("type", "text/javascript");

            string src = VirtualPathUtility.AppendTrailingSlash(scriptPath) + HttpUtility.UrlEncode(cultureInfo.Name) + ".js";
            tagBuilder.MergeAttribute("src", src);

            return tagBuilder.ToMvcHtmlString(TagRenderMode.Normal);
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, object routeValues, AjaxOptions ajaxOptions)
        {
            return RouteLink(ajaxHelper, linkText, null /* routeName */, new RouteValueDictionary(routeValues), ajaxOptions,
                             new Dictionary<string, object>());
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            return RouteLink(ajaxHelper, linkText, null /* routeName */, new RouteValueDictionary(routeValues), ajaxOptions,
                             HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, RouteValueDictionary routeValues, AjaxOptions ajaxOptions)
        {
            return RouteLink(ajaxHelper, linkText, null /* routeName */, routeValues, ajaxOptions,
                             new Dictionary<string, object>());
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            return RouteLink(ajaxHelper, linkText, null /* routeName */, routeValues, ajaxOptions, htmlAttributes);
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, AjaxOptions ajaxOptions)
        {
            return RouteLink(ajaxHelper, linkText, routeName, new RouteValueDictionary(), ajaxOptions,
                             new Dictionary<string, object>());
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            return RouteLink(ajaxHelper, linkText, routeName, new RouteValueDictionary(), ajaxOptions, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            return RouteLink(ajaxHelper, linkText, routeName, new RouteValueDictionary(), ajaxOptions, htmlAttributes);
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, object routeValues, AjaxOptions ajaxOptions)
        {
            return RouteLink(ajaxHelper, linkText, routeName, new RouteValueDictionary(routeValues), ajaxOptions,
                             new Dictionary<string, object>());
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            return RouteLink(ajaxHelper, linkText, routeName, new RouteValueDictionary(routeValues), ajaxOptions,
                             HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions)
        {
            return RouteLink(ajaxHelper, linkText, routeName, routeValues, ajaxOptions, new Dictionary<string, object>());
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }

            string targetUrl = UrlHelper.GenerateUrl(routeName, null /* actionName */, null /* controllerName */, routeValues ?? new RouteValueDictionary(), ajaxHelper.RouteCollection, ajaxHelper.ViewContext.RequestContext, false /* includeImplicitMvcValues */);

            return MvcHtmlString.Create(GenerateLink(ajaxHelper, linkText, targetUrl, GetAjaxOptions(ajaxOptions), htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this AjaxHelper ajaxHelper, string linkText, string routeName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }

            string targetUrl = UrlHelper.GenerateUrl(routeName, null /* actionName */, null /* controllerName */, protocol, hostName, fragment, routeValues ?? new RouteValueDictionary(), ajaxHelper.RouteCollection, ajaxHelper.ViewContext.RequestContext, false /* includeImplicitMvcValues */);

            return MvcHtmlString.Create(GenerateLink(ajaxHelper, linkText, targetUrl, GetAjaxOptions(ajaxOptions), htmlAttributes));
        }

        private static string GenerateLink(AjaxHelper ajaxHelper, string linkText, string targetUrl, AjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
        {
            TagBuilder tag = new TagBuilder("a")
            {
                InnerHtml = HttpUtility.HtmlEncode(linkText)
            };

            tag.MergeAttributes(htmlAttributes);
            tag.MergeAttribute("href", targetUrl);

            if (ajaxHelper.ViewContext.UnobtrusiveJavaScriptEnabled)
            {
                tag.MergeAttributes(ajaxOptions.ToUnobtrusiveHtmlAttributes());
            }
            else
            {
                tag.MergeAttribute("onclick", GenerateAjaxScript(ajaxOptions, LinkOnClickFormat));
            }

            return tag.ToString(TagRenderMode.Normal);
        }

        private static string GenerateAjaxScript(AjaxOptions ajaxOptions, string scriptFormat)
        {
            string optionsString = ajaxOptions.ToJavascriptString();
            return String.Format(CultureInfo.InvariantCulture, scriptFormat, optionsString);
        }

        private static AjaxOptions GetAjaxOptions(AjaxOptions ajaxOptions)
        {
            return (ajaxOptions != null) ? ajaxOptions : new AjaxOptions();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Ajax/AjaxOptions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text;
using System.Text.RegularExpressions;

namespace System.Web.Mvc.Ajax
{
    public class AjaxOptions
    {
        private static readonly Regex _idRegex = new Regex(@"[.:[\]]");
        private string _confirm;
        private string _httpMethod;
        private InsertionMode _insertionMode = InsertionMode.Replace;
        private string _loadingElementId;
        private string _onBegin;
        private string _onComplete;
        private string _onFailure;
        private string _onSuccess;
        private string _updateTargetId;
        private string _url;

        public string Confirm
        {
            get { return _confirm ?? String.Empty; }
            set { _confirm = value; }
        }

        public string HttpMethod
        {
            get { return _httpMethod ?? String.Empty; }
            set { _httpMethod = value; }
        }

        public InsertionMode InsertionMode
        {
            get { return _insertionMode; }
            set
            {
                switch (value)
                {
                    case InsertionMode.Replace:
                    case InsertionMode.InsertAfter:
                    case InsertionMode.InsertBefore:
                    case InsertionMode.ReplaceWith:
                        _insertionMode = value;
                        return;

                    default:
                        throw new ArgumentOutOfRangeException("value");
                }
            }
        }

        internal string InsertionModeString
        {
            get
            {
                switch (InsertionMode)
                {
                    case InsertionMode.Replace:
                        return "Sys.Mvc.InsertionMode.replace";
                    case InsertionMode.InsertBefore:
                        return "Sys.Mvc.InsertionMode.insertBefore";
                    case InsertionMode.InsertAfter:
                        return "Sys.Mvc.InsertionMode.insertAfter";
                    default:
                        return ((int)InsertionMode).ToString(CultureInfo.InvariantCulture);
                }
            }
        }

        internal string InsertionModeUnobtrusive
        {
            get
            {
                switch (InsertionMode)
                {
                    case InsertionMode.Replace:
                        return "replace";
                    case InsertionMode.InsertBefore:
                        return "before";
                    case InsertionMode.InsertAfter:
                        return "after";
                    case InsertionMode.ReplaceWith:
                        return "replace-with";
                    default:
                        return ((int)InsertionMode).ToString(CultureInfo.InvariantCulture);
                }
            }
        }

        public int LoadingElementDuration { get; set; }

        public string LoadingElementId
        {
            get { return _loadingElementId ?? String.Empty; }
            set { _loadingElementId = value; }
        }

        public string OnBegin
        {
            get { return _onBegin ?? String.Empty; }
            set { _onBegin = value; }
        }

        public string OnComplete
        {
            get { return _onComplete ?? String.Empty; }
            set { _onComplete = value; }
        }

        public string OnFailure
        {
            get { return _onFailure ?? String.Empty; }
            set { _onFailure = value; }
        }

        public string OnSuccess
        {
            get { return _onSuccess ?? String.Empty; }
            set { _onSuccess = value; }
        }

        public string UpdateTargetId
        {
            get { return _updateTargetId ?? String.Empty; }
            set { _updateTargetId = value; }
        }

        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "This property is used by the optionsBuilder which always accepts a string.")]
        public string Url
        {
            get { return _url ?? String.Empty; }
            set { _url = value; }
        }

        public bool AllowCache { get; set; }

        internal string ToJavascriptString()
        {
            // creates a string of the form { key1: value1, key2 : value2, ... }
            // This method is used for generating obtrusive JavaScript (using MicrosoftMvcAjax.js) which is no longer 
            // actively maintained. Consequently, we'll ignore the AllowCache option if it's set for this code path.
            StringBuilder optionsBuilder = new StringBuilder("{");
            optionsBuilder.AppendFormat(CultureInfo.InvariantCulture, " insertionMode: {0},", InsertionModeString);
            optionsBuilder.Append(PropertyStringIfSpecified("confirm", Confirm));
            optionsBuilder.Append(PropertyStringIfSpecified("httpMethod", HttpMethod));
            optionsBuilder.Append(PropertyStringIfSpecified("loadingElementId", LoadingElementId));
            optionsBuilder.Append(PropertyStringIfSpecified("updateTargetId", UpdateTargetId));
            optionsBuilder.Append(PropertyStringIfSpecified("url", Url));
            optionsBuilder.Append(EventStringIfSpecified("onBegin", OnBegin));
            optionsBuilder.Append(EventStringIfSpecified("onComplete", OnComplete));
            optionsBuilder.Append(EventStringIfSpecified("onFailure", OnFailure));
            optionsBuilder.Append(EventStringIfSpecified("onSuccess", OnSuccess));
            optionsBuilder.Length--;
            optionsBuilder.Append(" }");
            return optionsBuilder.ToString();
        }

        public IDictionary<string, object> ToUnobtrusiveHtmlAttributes()
        {
            var result = new Dictionary<string, object>
            {
                { "data-ajax", "true" },
            };

            AddToDictionaryIfSpecified(result, "data-ajax-url", Url);
            AddToDictionaryIfSpecified(result, "data-ajax-method", HttpMethod);
            AddToDictionaryIfSpecified(result, "data-ajax-confirm", Confirm);

            AddToDictionaryIfSpecified(result, "data-ajax-begin", OnBegin);
            AddToDictionaryIfSpecified(result, "data-ajax-complete", OnComplete);
            AddToDictionaryIfSpecified(result, "data-ajax-failure", OnFailure);
            AddToDictionaryIfSpecified(result, "data-ajax-success", OnSuccess);

            if (AllowCache)
            {
                // On the client, the absence of the data-ajax-cache attribute is equivalent to setting it to false.
                // Consequently we'll only set it if the user wants to opt into caching. 
                AddToDictionaryIfSpecified(result, "data-ajax-cache", "true");
            }

            if (!String.IsNullOrWhiteSpace(LoadingElementId))
            {
                result.Add("data-ajax-loading", EscapeIdSelector(LoadingElementId));

                if (LoadingElementDuration > 0)
                {
                    result.Add("data-ajax-loading-duration", LoadingElementDuration);
                }
            }

            if (!String.IsNullOrWhiteSpace(UpdateTargetId))
            {
                result.Add("data-ajax-update", EscapeIdSelector(UpdateTargetId));
                result.Add("data-ajax-mode", InsertionModeUnobtrusive);
            }

            return result;
        }

        // Helpers

        private static void AddToDictionaryIfSpecified(IDictionary<string, object> dictionary, string name, string value)
        {
            if (!String.IsNullOrWhiteSpace(value))
            {
                dictionary.Add(name, value);
            }
        }

        private static string EventStringIfSpecified(string propertyName, string handler)
        {
            if (!String.IsNullOrEmpty(handler))
            {
                return String.Format(CultureInfo.InvariantCulture, " {0}: Function.createDelegate(this, {1}),", propertyName, handler.ToString());
            }
            return String.Empty;
        }

        private static string PropertyStringIfSpecified(string propertyName, string propertyValue)
        {
            if (!String.IsNullOrEmpty(propertyValue))
            {
                string escapedPropertyValue = propertyValue.Replace("'", @"\'");
                return String.Format(CultureInfo.InvariantCulture, " {0}: '{1}',", propertyName, escapedPropertyValue);
            }
            return String.Empty;
        }

        private static string EscapeIdSelector(string selector)
        {
            // The string returned by this function is used as a value for jQuery's selector. The characters dot, colon and 
            // square brackets are valid id characters but need to be properly escaped since they have special meaning. For
            // e.g., for the id a.b, $('#a.b') would cause ".b" to treated as a class selector. The correct way to specify
            // this selector would be to escape the dot to get $('#a\.b').
            // See http://learn.jquery.com/using-jquery-core/faq/how-do-i-select-an-element-by-an-id-that-has-characters-used-in-css-notation/
            return '#' + _idRegex.Replace(selector, @"\$&");
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Ajax/InsertionMode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Ajax
{
    public enum InsertionMode
    {
        /// <summary>
        /// Replace the contents of the element.
        /// </summary>
        Replace = 0,

        /// <summary>
        /// Insert before the element.
        /// </summary>
        InsertBefore = 1,

        /// <summary>
        /// Insert after the element.
        /// </summary>
        InsertAfter = 2,

        /// <summary>
        /// Replace the entire element.
        /// </summary>
        ReplaceWith = 3
    }
}


================================================
FILE: src/System.Web.Mvc/AjaxHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Routing;

namespace System.Web.Mvc
{
    public class AjaxHelper
    {
        private static string _globalizationScriptPath;

        private DynamicViewDataDictionary _dynamicViewDataDictionary;

        public AjaxHelper(ViewContext viewContext, IViewDataContainer viewDataContainer)
            : this(viewContext, viewDataContainer, RouteTable.Routes)
        {
        }

        public AjaxHelper(ViewContext viewContext, IViewDataContainer viewDataContainer, RouteCollection routeCollection)
        {
            if (viewContext == null)
            {
                throw new ArgumentNullException("viewContext");
            }
            if (viewDataContainer == null)
            {
                throw new ArgumentNullException("viewDataContainer");
            }
            if (routeCollection == null)
            {
                throw new ArgumentNullException("routeCollection");
            }
            ViewContext = viewContext;
            ViewDataContainer = viewDataContainer;
            RouteCollection = routeCollection;
        }

        public static string GlobalizationScriptPath
        {
            get
            {
                if (String.IsNullOrEmpty(_globalizationScriptPath))
                {
                    _globalizationScriptPath = "~/Scripts/Globalization";
                }
                return _globalizationScriptPath;
            }
            set { _globalizationScriptPath = value; }
        }

        public RouteCollection RouteCollection { get; private set; }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewDataDictionary == null)
                {
                    _dynamicViewDataDictionary = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewDataDictionary;
            }
        }

        public ViewContext ViewContext { get; private set; }

        public ViewDataDictionary ViewData
        {
            get { return ViewDataContainer.ViewData; }
        }

        public IViewDataContainer ViewDataContainer { get; internal set; }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Instance method for consistency with other helpers.")]
        public string JavaScriptStringEncode(string message)
        {
            if (String.IsNullOrEmpty(message))
            {
                return message;
            }

            return HttpUtility.JavaScriptStringEncode(message);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AjaxHelperOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;

namespace System.Web.Mvc
{
    public class AjaxHelper<TModel> : AjaxHelper
    {
        private DynamicViewDataDictionary _dynamicViewDataDictionary;
        private ViewDataDictionary<TModel> _viewData;

        public AjaxHelper(ViewContext viewContext, IViewDataContainer viewDataContainer)
            : this(viewContext, viewDataContainer, RouteTable.Routes)
        {
        }

        public AjaxHelper(ViewContext viewContext, IViewDataContainer viewDataContainer, RouteCollection routeCollection)
            : base(viewContext, viewDataContainer, routeCollection)
        {
            _viewData = new ViewDataDictionary<TModel>(viewDataContainer.ViewData);
        }

        public new dynamic ViewBag
        {
            get
            {
                if (_dynamicViewDataDictionary == null)
                {
                    _dynamicViewDataDictionary = new DynamicViewDataDictionary(() => ViewData);
                }

                return _dynamicViewDataDictionary;
            }
        }

        public new ViewDataDictionary<TModel> ViewData
        {
            get { return _viewData; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AjaxRequestExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class AjaxRequestExtensions
    {
        public static bool IsAjaxRequest(this HttpRequestBase request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            return (request["X-Requested-With"] == "XMLHttpRequest") || ((request.Headers != null) && (request.Headers["X-Requested-With"] == "XMLHttpRequest"));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AllowAnonymousAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Actions and controllers with the AllowAnonymous attribute are skipped by the Authorize attribute
    /// on authorization. See AccountController.cs in the project template for an example.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class AllowAnonymousAttribute : Attribute
    {
    }
}


================================================
FILE: src/System.Web.Mvc/AllowHtmlAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    // This attribute can be applied to a model property to specify that the particular property to
    // which it is applied should not go through request validation.

    [AttributeUsage(AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class AllowHtmlAttribute : Attribute, IMetadataAware
    {
        public void OnMetadataCreated(ModelMetadata metadata)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }

            metadata.RequestValidationEnabled = false;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AreaHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Routing;
using System.Web.Routing;

namespace System.Web.Mvc
{
    internal static class AreaHelpers
    {
        public static string GetAreaName(RouteBase route)
        {
            IRouteWithArea routeWithArea = route as IRouteWithArea;
            if (routeWithArea != null)
            {
                return routeWithArea.Area;
            }

            Route castRoute = route as Route;
            if (castRoute != null && castRoute.DataTokens != null)
            {
                return castRoute.DataTokens[RouteDataTokenKeys.Area] as string;
            }

            return null;
        }

        public static string GetAreaName(RouteData routeData)
        {
            object area;
            if (routeData.DataTokens.TryGetValue(RouteDataTokenKeys.Area, out area))
            {
                return area as string;
            }

            return GetAreaName(routeData.Route);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AreaReference.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Controls interpretation of a controller name when constructing a <see cref="RemoteAttribute"/>.
    /// </summary>
    public enum AreaReference
    {
        /// <summary>
        /// Find the controller in the current area.
        /// </summary>
        UseCurrent = 0,

        /// <summary>
        /// Find the controller in the root area.
        /// </summary>
        UseRoot = 1,
    }
}


================================================
FILE: src/System.Web.Mvc/AreaRegistration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Routing;

namespace System.Web.Mvc
{
    public abstract class AreaRegistration
    {
        private const string TypeCacheName = "MVC-AreaRegistrationTypeCache.xml";

        public abstract string AreaName { get; }

        internal void CreateContextAndRegister(RouteCollection routes, object state)
        {
            AreaRegistrationContext context = new AreaRegistrationContext(AreaName, routes, state);

            string thisNamespace = GetType().Namespace;
            if (thisNamespace != null)
            {
                context.Namespaces.Add(thisNamespace + ".*");
            }

            RegisterArea(context);
        }

        private static bool IsAreaRegistrationType(Type type)
        {
            return
                typeof(AreaRegistration).IsAssignableFrom(type) &&
                type.GetConstructor(Type.EmptyTypes) != null;
        }

        public static void RegisterAllAreas()
        {
            RegisterAllAreas(null);
        }

        public static void RegisterAllAreas(object state)
        {
            RegisterAllAreas(RouteTable.Routes, new BuildManagerWrapper(), state);
        }

        internal static void RegisterAllAreas(RouteCollection routes, IBuildManager buildManager, object state)
        {
            List<Type> areaRegistrationTypes = TypeCacheUtil.GetFilteredTypesFromAssemblies(TypeCacheName, IsAreaRegistrationType, buildManager);
            foreach (Type areaRegistrationType in areaRegistrationTypes)
            {
                AreaRegistration registration = (AreaRegistration)Activator.CreateInstance(areaRegistrationType);
                registration.CreateContextAndRegister(routes, state);
            }
        }

        public abstract void RegisterArea(AreaRegistrationContext context);
    }
}


================================================
FILE: src/System.Web.Mvc/AreaRegistrationContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Mvc.Routing;
using System.Web.Routing;

namespace System.Web.Mvc
{
    public class AreaRegistrationContext
    {
        private readonly HashSet<string> _namespaces = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        public AreaRegistrationContext(string areaName, RouteCollection routes)
            : this(areaName, routes, null)
        {
        }

        public AreaRegistrationContext(string areaName, RouteCollection routes, object state)
        {
            if (String.IsNullOrEmpty(areaName))
            {
                throw Error.ParameterCannotBeNullOrEmpty("areaName");
            }
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            AreaName = areaName;
            Routes = routes;
            State = state;
        }

        public string AreaName { get; private set; }

        public ICollection<string> Namespaces
        {
            get { return _namespaces; }
        }

        public RouteCollection Routes { get; private set; }

        public object State { get; private set; }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public Route MapRoute(string name, string url)
        {
            return MapRoute(name, url, (object)null /* defaults */);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public Route MapRoute(string name, string url, object defaults)
        {
            return MapRoute(name, url, defaults, (object)null /* constraints */);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public Route MapRoute(string name, string url, object defaults, object constraints)
        {
            return MapRoute(name, url, defaults, constraints, null /* namespaces */);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public Route MapRoute(string name, string url, string[] namespaces)
        {
            return MapRoute(name, url, (object)null /* defaults */, namespaces);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public Route MapRoute(string name, string url, object defaults, string[] namespaces)
        {
            return MapRoute(name, url, defaults, null /* constraints */, namespaces);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public Route MapRoute(string name, string url, object defaults, object constraints, string[] namespaces)
        {
            if (namespaces == null && Namespaces != null)
            {
                namespaces = Namespaces.ToArray();
            }

            Route route = Routes.MapRoute(name, url, defaults, constraints, namespaces);
            route.DataTokens[RouteDataTokenKeys.Area] = AreaName;

            // disabling the namespace lookup fallback mechanism keeps this areas from accidentally picking up
            // controllers belonging to other areas
            bool useNamespaceFallback = (namespaces == null || namespaces.Length == 0);
            route.DataTokens[RouteDataTokenKeys.UseNamespaceFallback] = useNamespaceFallback;

            return route;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AssociatedMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    // This class provides a good implementation of ModelMetadataProvider for people who will be
    // using traditional classes with properties. It uses the buddy class support from
    // DataAnnotations, and consolidates the three operations down to a single override
    // for reading the attribute values and creating the metadata class.
    public abstract class AssociatedMetadataProvider : ModelMetadataProvider
    {
        private static void ApplyMetadataAwareAttributes(IEnumerable<Attribute> attributes, ModelMetadata result)
        {
            foreach (IMetadataAware awareAttribute in attributes.OfType<IMetadataAware>())
            {
                awareAttribute.OnMetadataCreated(result);
            }
        }

        protected abstract ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName);

        protected virtual IEnumerable<Attribute> FilterAttributes(Type containerType, PropertyDescriptor propertyDescriptor, IEnumerable<Attribute> attributes)
        {
            if (typeof(ViewPage).IsAssignableFrom(containerType) || typeof(ViewUserControl).IsAssignableFrom(containerType))
            {
                return attributes.Where(a => !(a is ReadOnlyAttribute));
            }

            return attributes;
        }

        public override IEnumerable<ModelMetadata> GetMetadataForProperties(object container, Type containerType)
        {
            if (containerType == null)
            {
                throw new ArgumentNullException("containerType");
            }

            PropertyDescriptorCollection properties = GetTypeDescriptor(containerType).GetProperties();

            // The return value is sorted from the ModelMetadata type, so returning as an array is best for performance
            ModelMetadata[] metadata = new ModelMetadata[properties.Count];
            for (int i = 0; i < properties.Count; i++)
            {
                PropertyDescriptor property = properties[i];
                Func<object> modelAccessor = container == null ? null : GetPropertyValueAccessor(container, property);
                ModelMetadata propertyMetadata = GetMetadataForProperty(modelAccessor, containerType, property);
                if (propertyMetadata != null)
                {
                    propertyMetadata.Container = container;
                }
                metadata[i] = propertyMetadata;
            }
            return metadata;
        }

        public override ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, string propertyName)
        {
            if (containerType == null)
            {
                throw new ArgumentNullException("containerType");
            }
            if (String.IsNullOrEmpty(propertyName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "propertyName");
            }

            ICustomTypeDescriptor typeDescriptor = GetTypeDescriptor(containerType);
            PropertyDescriptor property = typeDescriptor.GetProperties().Find(propertyName, true);
            if (property == null)
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Common_PropertyNotFound,
                        containerType.FullName, propertyName));
            }

            return GetMetadataForProperty(modelAccessor, containerType, property);
        }

        protected virtual ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, PropertyDescriptor propertyDescriptor)
        {
            IEnumerable<Attribute> attributes = FilterAttributes(containerType, propertyDescriptor, new AttributeList(propertyDescriptor.Attributes));
            ModelMetadata result = CreateMetadata(attributes, containerType, modelAccessor, propertyDescriptor.PropertyType, propertyDescriptor.Name);
            ApplyMetadataAwareAttributes(attributes, result);
            return result;
        }

        public override ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }

            AttributeList attributes = new AttributeList(GetTypeDescriptor(modelType).GetAttributes());
            ModelMetadata result = CreateMetadata(attributes, null /* containerType */, modelAccessor, modelType, null /* propertyName */);
            ApplyMetadataAwareAttributes(attributes, result);
            return result;
        }

        private static Func<object> GetPropertyValueAccessor(object container, PropertyDescriptor property)
        {
            return () => property.GetValue(container);
        }

        protected virtual ICustomTypeDescriptor GetTypeDescriptor(Type type)
        {
            return TypeDescriptorHelper.Get(type);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AssociatedValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public abstract class AssociatedValidatorProvider : ModelValidatorProvider
    {
        protected virtual ICustomTypeDescriptor GetTypeDescriptor(Type type)
        {
            return TypeDescriptorHelper.Get(type);
        }

        public sealed override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            if (metadata.ContainerType != null && !String.IsNullOrEmpty(metadata.PropertyName))
            {
                return GetValidatorsForProperty(metadata, context);
            }

            return GetValidatorsForType(metadata, context);
        }

        protected abstract IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes);

        private IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, ControllerContext context)
        {
            ICustomTypeDescriptor typeDescriptor = GetTypeDescriptor(metadata.ContainerType);
            PropertyDescriptor property = typeDescriptor.GetProperties().Find(metadata.PropertyName, true);
            if (property == null)
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Common_PropertyNotFound,
                        metadata.ContainerType.FullName, metadata.PropertyName),
                    "metadata");
            }
            return GetValidators(metadata, context, new AttributeList(property.Attributes));
        }

        private IEnumerable<ModelValidator> GetValidatorsForType(ModelMetadata metadata, ControllerContext context)
        {
            return GetValidators(metadata, context, new AttributeList(GetTypeDescriptor(metadata.ModelType).GetAttributes()));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/ActionDescriptorCreator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    internal delegate ActionDescriptor ActionDescriptorCreator(string actionName, ControllerDescriptor controllerDescriptor);
}


================================================
FILE: src/System.Web.Mvc/Async/AsyncActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc.Async
{
    public abstract class AsyncActionDescriptor : ActionDescriptor
    {
        public abstract IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state);

        public abstract object EndExecute(IAsyncResult asyncResult);

        public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters)
        {
            string errorMessage = String.Format(CultureInfo.CurrentCulture, MvcResources.AsyncActionDescriptor_CannotExecuteSynchronously,
                                                ActionName);

            throw new InvalidOperationException(errorMessage);
        }

        internal static AsyncManager GetAsyncManager(ControllerBase controller)
        {
            IAsyncManagerContainer helperContainer = controller as IAsyncManagerContainer;
            if (helperContainer == null)
            {
                throw Error.AsyncCommon_ControllerMustImplementIAsyncManagerContainer(controller.GetType());
            }

            return helperContainer.AsyncManager;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/AsyncActionMethodSelector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;

namespace System.Web.Mvc.Async
{
    internal sealed class AsyncActionMethodSelector : ActionMethodSelectorBase
    {
        // This flag controls async action binding for backwards compat since Controller now supports async. 
        // Set to true for classes that derive from AsyncController. In this case, FooAsync/FooCompleted is 
        // bound as a single async action pair "Foo". If false, they're bound as 2 separate sync actions. 
        // Practically, if this is false, then IsAsyncSuffixedMethod and IsCompeltedSuffixedMethod return false.
        private readonly bool _allowLegacyAsyncActions;

        public AsyncActionMethodSelector(Type controllerType, bool allowLegacyAsyncActions = true)
        {
            _allowLegacyAsyncActions = allowLegacyAsyncActions;
            Initialize(controllerType);
        }
        
        public ActionDescriptorCreator FindAction(ControllerContext controllerContext, string actionName)
        {
            MethodInfo method = FindActionMethod(controllerContext, actionName);

            if (method == null)
            {
                return null;
            }

            return GetActionDescriptorDelegate(method);
        }

        internal bool AllowLegacyAsyncActions
        {
            get { return _allowLegacyAsyncActions; }
        }

        // This method and GetMethodInfo need to stay in sync, we need to be able to
        // get a method info from each type of action descriptor we create.
        internal ActionDescriptorCreator GetActionDescriptorDelegate(MethodInfo entryMethod)
        {
            // Does the action return a Task?
            if (entryMethod.ReturnType != null && typeof(Task).IsAssignableFrom(entryMethod.ReturnType))
            {
                return (actionName, controllerDescriptor) => new TaskAsyncActionDescriptor(entryMethod, actionName, controllerDescriptor);
            }

            // Is this the FooAsync() / FooCompleted() pattern?
            if (IsAsyncSuffixedMethod(entryMethod))
            {
                string completionMethodName = entryMethod.Name.Substring(0, entryMethod.Name.Length - "Async".Length) + "Completed";
                MethodInfo completionMethod = GetMethodByName(completionMethodName);
                if (completionMethod != null)
                {
                    return (actionName, controllerDescriptor) => new ReflectedAsyncActionDescriptor(entryMethod, completionMethod, actionName, controllerDescriptor);
                }
                else
                {
                    throw Error.AsyncActionMethodSelector_CouldNotFindMethod(completionMethodName, ControllerType);
                }
            }

            // Fallback to synchronous method
            return (actionName, controllerDescriptor) => new ReflectedActionDescriptor(entryMethod, actionName, controllerDescriptor);
        }

        protected override bool IsValidActionMethod(MethodInfo methodInfo)
        {
            return IsValidActionMethod(methodInfo, true /* stripInfrastructureMethods */);
        }

        private bool IsValidActionMethod(MethodInfo methodInfo, bool stripInfrastructureMethods)
        {
            if (methodInfo.IsSpecialName)
            {
                // not a normal method, e.g. a constructor or an event
                return false;
            }

            if (methodInfo.GetBaseDefinition().DeclaringType.IsAssignableFrom(typeof(AsyncController)))
            {
                // is a method on Object, ControllerBase, Controller, or AsyncController
                return false;
            }

            if (stripInfrastructureMethods)
            {
                if (IsCompletedSuffixedMethod(methodInfo))
                {
                    // do not match FooCompleted() methods, as these are infrastructure methods
                    return false;
                }
            }

            return true;
        }

        protected override string GetCanonicalMethodName(MethodInfo methodInfo)
        {
            string methodName = methodInfo.Name;
            return (IsAsyncSuffixedMethod(methodInfo))
                       ? methodName.Substring(0, methodName.Length - "Async".Length)
                       : methodName;
        }

        private bool IsAsyncSuffixedMethod(MethodInfo methodInfo)
        {
            return _allowLegacyAsyncActions && methodInfo.Name.EndsWith("Async", StringComparison.OrdinalIgnoreCase);
        }

        private bool IsCompletedSuffixedMethod(MethodInfo methodInfo)
        {
            return _allowLegacyAsyncActions && methodInfo.Name.EndsWith("Completed", StringComparison.OrdinalIgnoreCase);
        }

        private MethodInfo GetMethodByName(string methodName)
        {
            List<MethodInfo> methods = (from MethodInfo methodInfo in ControllerType.GetMember(methodName, MemberTypes.Method, BindingFlags.Instance | BindingFlags.Public | BindingFlags.InvokeMethod | BindingFlags.IgnoreCase)
                                        where IsValidActionMethod(methodInfo, false /* stripInfrastructureMethods */)
                                        select methodInfo).ToList();

            switch (methods.Count)
            {
                case 0:
                    return null;

                case 1:
                    return methods[0];

                default:
                    throw CreateAmbiguousMethodMatchException(methods, methodName);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/AsyncControllerActionInvoker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Threading;
using System.Web.Mvc.Filters;
using System.Web.Mvc.Routing;

namespace System.Web.Mvc.Async
{
    public class AsyncControllerActionInvoker : ControllerActionInvoker, IAsyncActionInvoker
    {
        private static readonly object _invokeActionTag = new object();
        private static readonly object _invokeActionMethodTag = new object();
        private static readonly object _invokeActionMethodWithFiltersTag = new object();

        [SuppressMessage("Microsoft.Maintainability", "CA1500:VariableNamesShouldNotMatchFieldNames", Justification = "FxCop unable to handle what new compiler generates.")]
        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Refactoring to reduce coupling not currently justified.")]
        public virtual IAsyncResult BeginInvokeAction(ControllerContext controllerContext, string actionName, AsyncCallback callback, object state)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            Contract.Assert(controllerContext.RouteData != null);
            if (String.IsNullOrEmpty(actionName) && !controllerContext.RouteData.HasDirectRouteMatch())
            {
                throw Error.ParameterCannotBeNullOrEmpty("actionName");
            }

            ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext);
            ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName);
            if (actionDescriptor != null)
            {
                FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);
                Action continuation = null;

                BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
                {
                    try
                    {
                        AuthenticationContext authenticationContext = InvokeAuthenticationFilters(controllerContext,
                            filterInfo.AuthenticationFilters, actionDescriptor);
                        if (authenticationContext.Result != null)
                        {
                            // An authentication filter signaled that we should short-circuit the request. Let all
                            // authentication filters contribute to an action result (to combine authentication
                            // challenges). Then, run this action result.
                            AuthenticationChallengeContext challengeContext =
                                InvokeAuthenticationFiltersChallenge(controllerContext,
                                filterInfo.AuthenticationFilters, actionDescriptor, authenticationContext.Result);
                            continuation = () => InvokeActionResult(controllerContext,
                                challengeContext.Result ?? authenticationContext.Result);
                        }
                        else
                        {
                            AuthorizationContext authorizationContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor);
                            if (authorizationContext.Result != null)
                            {
                                // An authorization filter signaled that we should short-circuit the request. Let all
                                // authentication filters contribute to an action result (to combine authentication
                                // challenges). Then, run this action result.
                                AuthenticationChallengeContext challengeContext =
                                    InvokeAuthenticationFiltersChallenge(controllerContext,
                                    filterInfo.AuthenticationFilters, actionDescriptor, authorizationContext.Result);
                                continuation = () => InvokeActionResult(controllerContext,
                                    challengeContext.Result ?? authorizationContext.Result);
                            }
                            else
                            {
                                if (controllerContext.Controller.ValidateRequest)
                                {
                                    ValidateRequest(controllerContext);
                                }

                                IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor);
                                IAsyncResult asyncResult = BeginInvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters, asyncCallback, asyncState);
                                continuation = () =>
                                {
                                    ActionExecutedContext postActionContext = EndInvokeActionMethodWithFilters(asyncResult);
                                    // The action succeeded. Let all authentication filters contribute to an action
                                    // result (to combine authentication challenges; some authentication filters need
                                    // to do negotiation even on a successful result). Then, run this action result.
                                    AuthenticationChallengeContext challengeContext =
                                        InvokeAuthenticationFiltersChallenge(controllerContext,
                                        filterInfo.AuthenticationFilters, actionDescriptor,
                                        postActionContext.Result);
                                    InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters,
                                        challengeContext.Result ?? postActionContext.Result);
                                };
                                return asyncResult;
                            }
                        }
                    }
                    catch (ThreadAbortException)
                    {
                        // This type of exception occurs as a result of Response.Redirect(), but we special-case so that
                        // the filters don't see this as an error.
                        throw;
                    }
                    catch (Exception ex)
                    {
                        // something blew up, so execute the exception filters
                        ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex);
                        if (!exceptionContext.ExceptionHandled)
                        {
                            throw;
                        }

                        continuation = () => InvokeActionResult(controllerContext, exceptionContext.Result);
                    }

                    return BeginInvokeAction_MakeSynchronousAsyncResult(asyncCallback, asyncState);
                };

                EndInvokeDelegate<bool> endDelegate = delegate(IAsyncResult asyncResult)
                {
                    try
                    {
                        continuation();
                    }
                    catch (ThreadAbortException)
                    {
                        // This type of exception occurs as a result of Response.Redirect(), but we special-case so that
                        // the filters don't see this as an error.
                        throw;
                    }
                    catch (Exception ex)
                    {
                        // something blew up, so execute the exception filters
                        ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex);
                        if (!exceptionContext.ExceptionHandled)
                        {
                            throw;
                        }
                        InvokeActionResult(controllerContext, exceptionContext.Result);
                    }

                    return true;
                };

                return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeActionTag);
            }
            else
            {
                // Notify the controller that no action was found.
                return BeginInvokeAction_ActionNotFound(callback, state);
            }
        }

        private static IAsyncResult BeginInvokeAction_ActionNotFound(AsyncCallback callback, object state)
        {
            BeginInvokeDelegate beginDelegate = BeginInvokeAction_MakeSynchronousAsyncResult;

            EndInvokeDelegate<bool> endDelegate = delegate(IAsyncResult asyncResult)
            {
                return false;
            };

            return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeActionTag);
        }

        private static IAsyncResult BeginInvokeAction_MakeSynchronousAsyncResult(AsyncCallback callback, object state)
        {
            SimpleAsyncResult asyncResult = new SimpleAsyncResult(state);
            asyncResult.MarkCompleted(true /* completedSynchronously */, callback);
            return asyncResult;
        }

        protected internal virtual IAsyncResult BeginInvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters, AsyncCallback callback, object state)
        {
            AsyncActionDescriptor asyncActionDescriptor = actionDescriptor as AsyncActionDescriptor;
            if (asyncActionDescriptor != null)
            {
                return BeginInvokeAsynchronousActionMethod(controllerContext, asyncActionDescriptor, parameters, callback, state);
            }
            else
            {
                return BeginInvokeSynchronousActionMethod(controllerContext, actionDescriptor, parameters, callback, state);
            }
        }

        protected internal virtual IAsyncResult BeginInvokeActionMethodWithFilters(ControllerContext controllerContext, IList<IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters, AsyncCallback callback, object state)
        {
            Func<ActionExecutedContext> endContinuation = null;

            BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
            {
                AsyncInvocationWithFilters invocation = new AsyncInvocationWithFilters(this, controllerContext, actionDescriptor, filters, parameters, asyncCallback, asyncState);

                const int StartingFilterIndex = 0;
                endContinuation = invocation.InvokeActionMethodFilterAsynchronouslyRecursive(StartingFilterIndex);

                if (invocation.InnerAsyncResult != null)
                {
                    // we're just waiting for the inner result to complete
                    return invocation.InnerAsyncResult;
                }
                else
                {
                    // something was short-circuited and the action was not called, so this was a synchronous operation
                    SimpleAsyncResult newAsyncResult = new SimpleAsyncResult(asyncState);
                    newAsyncResult.MarkCompleted(completedSynchronously: true, callback: asyncCallback);
                    return newAsyncResult;
                }
            };

            EndInvokeDelegate<ActionExecutedContext> endDelegate = delegate(IAsyncResult asyncResult)
            {
                return endContinuation();
            };

            return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeActionMethodWithFiltersTag);
        }

        private IAsyncResult BeginInvokeAsynchronousActionMethod(ControllerContext controllerContext, AsyncActionDescriptor actionDescriptor, IDictionary<string, object> parameters, AsyncCallback callback, object state)
        {
            BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
            {
                return actionDescriptor.BeginExecute(controllerContext, parameters, asyncCallback, asyncState);
            };

            EndInvokeDelegate<ActionResult> endDelegate = delegate(IAsyncResult asyncResult)
            {
                object returnValue = actionDescriptor.EndExecute(asyncResult);
                ActionResult result = CreateActionResult(controllerContext, actionDescriptor, returnValue);
                return result;
            };

            return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _invokeActionMethodTag);
        }

        private IAsyncResult BeginInvokeSynchronousActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters, AsyncCallback callback, object state)
        {
            // Frequently called so ensure delegate remains static and arguments do not allocate
            EndInvokeDelegate<ActionInvocation, ActionResult> endInvokeFunc = (asyncResult, innerInvokeState) =>
                {
                    return innerInvokeState.InvokeSynchronousActionMethod();
                };
            ActionInvocation endInvokeState = new ActionInvocation(this, controllerContext, actionDescriptor, parameters);
            return AsyncResultWrapper.BeginSynchronous(callback, state, endInvokeFunc, endInvokeState, _invokeActionMethodTag);
        }

        public virtual bool EndInvokeAction(IAsyncResult asyncResult)
        {
            return AsyncResultWrapper.End<bool>(asyncResult, _invokeActionTag);
        }

        protected internal virtual ActionResult EndInvokeActionMethod(IAsyncResult asyncResult)
        {
            return AsyncResultWrapper.End<ActionResult>(asyncResult, _invokeActionMethodTag);
        }

        protected internal virtual ActionExecutedContext EndInvokeActionMethodWithFilters(IAsyncResult asyncResult)
        {
            return AsyncResultWrapper.End<ActionExecutedContext>(asyncResult, _invokeActionMethodWithFiltersTag);
        }

        protected override ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext)
        {
            // Frequently called, so ensure delegate is static
            Type controllerType = controllerContext.Controller.GetType();
            ControllerDescriptor controllerDescriptor = DescriptorCache.GetDescriptor(
                controllerType: controllerType,
                creator: ReflectedAsyncControllerDescriptor.DefaultDescriptorFactory,
                state: controllerType);
            return controllerDescriptor;
        }

        // Keep as value type to avoid per-call allocation
        private struct ActionInvocation
        {
            private readonly AsyncControllerActionInvoker _invoker;
            private readonly ControllerContext _controllerContext;
            private readonly ActionDescriptor _actionDescriptor;
            private readonly IDictionary<string, object> _parameters;

            internal ActionInvocation(AsyncControllerActionInvoker invoker, ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
            {
                Contract.Assert(invoker != null);
                Contract.Assert(controllerContext != null);
                Contract.Assert(actionDescriptor != null);
                Contract.Assert(parameters != null);

                _invoker = invoker;
                _controllerContext = controllerContext;
                _actionDescriptor = actionDescriptor;
                _parameters = parameters;
            }

            internal ActionResult InvokeSynchronousActionMethod()
            {
                return _invoker.InvokeActionMethod(_controllerContext, _actionDescriptor, _parameters);
            }
        }

        // Large and passed to many function calls, so keep as a reference type to minimize copying
        private class AsyncInvocationWithFilters
        {
            private readonly AsyncControllerActionInvoker _invoker;
            private readonly ControllerContext _controllerContext;
            private readonly ActionDescriptor _actionDescriptor;
            private readonly IList<IActionFilter> _filters;
            private readonly IDictionary<string, object> _parameters;
            private readonly AsyncCallback _asyncCallback;
            private readonly object _asyncState;
            private readonly int _filterCount;
            private readonly ActionExecutingContext _preContext;

            internal IAsyncResult InnerAsyncResult;

            internal AsyncInvocationWithFilters(AsyncControllerActionInvoker invoker, ControllerContext controllerContext, ActionDescriptor actionDescriptor, IList<IActionFilter> filters, IDictionary<string, object> parameters, AsyncCallback asyncCallback, object asyncState)
            {
                Contract.Assert(invoker != null);
                Contract.Assert(controllerContext != null);
                Contract.Assert(actionDescriptor != null);
                Contract.Assert(filters != null);
                Contract.Assert(parameters != null);

                _invoker = invoker;
                _controllerContext = controllerContext;
                _actionDescriptor = actionDescriptor;
                _filters = filters;
                _parameters = parameters;
                _asyncCallback = asyncCallback;
                _asyncState = asyncState;

                _preContext = new ActionExecutingContext(controllerContext, actionDescriptor, parameters);
                // For IList<T> it is faster to cache the count
                _filterCount = _filters.Count;
            }

            internal Func<ActionExecutedContext> InvokeActionMethodFilterAsynchronouslyRecursive(int filterIndex)
            {
                // Performance-sensitive

                // For compatability, the following behavior must be maintained
                //   The OnActionExecuting events must fire in forward order
                //   The Begin and End events must fire
                //   The OnActionExecuted events must fire in reverse order
                //   Earlier filters can process the results and exceptions from the handling of later filters
                // This is achieved by calling recursively and moving through the filter list forwards

                // If there are no more filters to recurse over, create the main result
                if (filterIndex > _filterCount - 1)
                {
                    InnerAsyncResult = _invoker.BeginInvokeActionMethod(_controllerContext, _actionDescriptor, _parameters, _asyncCallback, _asyncState);
                    return () =>
                           new ActionExecutedContext(_controllerContext, _actionDescriptor, canceled: false, exception: null)
                           {
                               Result = _invoker.EndInvokeActionMethod(InnerAsyncResult)
                           };
                }

                // Otherwise process the filters recursively
                IActionFilter filter = _filters[filterIndex];
                ActionExecutingContext preContext = _preContext;
                filter.OnActionExecuting(preContext);
                if (preContext.Result != null)
                {
                    ActionExecutedContext shortCircuitedPostContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, canceled: true, exception: null)
                    {
                        Result = preContext.Result
                    };
                    return () => shortCircuitedPostContext;
                }

                // There is a nested try / catch block here that contains much the same logic as the outer block.
                // Since an exception can occur on either side of the asynchronous invocation, we need guards on
                // on both sides. In the code below, the second side is represented by the nested delegate. This
                // is really just a parallel of the synchronous ControllerActionInvoker.InvokeActionMethodFilter()
                // method.

                try
                {
                    // Use the filters in forward direction
                    int nextFilterIndex = filterIndex + 1;
                    Func<ActionExecutedContext> continuation = InvokeActionMethodFilterAsynchronouslyRecursive(nextFilterIndex);

                    // add our own continuation, then return the new function
                    return () =>
                    {
                        ActionExecutedContext postContext;
                        bool wasError = true;

                        try
                        {
                            postContext = continuation();
                            wasError = false;
                        }
                        catch (ThreadAbortException)
                        {
                            // This type of exception occurs as a result of Response.Redirect(), but we special-case so that
                            // the filters don't see this as an error.
                            postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, canceled: false, exception: null);
                            filter.OnActionExecuted(postContext);
                            throw;
                        }
                        catch (Exception ex)
                        {
                            postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, canceled: false, exception: ex);
                            filter.OnActionExecuted(postContext);
                            if (!postContext.ExceptionHandled)
                            {
                                throw;
                            }
                        }
                        if (!wasError)
                        {
                            filter.OnActionExecuted(postContext);
                        }

                        return postContext;
                    };
                }
                catch (ThreadAbortException)
                {
                    // This type of exception occurs as a result of Response.Redirect(), but we special-case so that
                    // the filters don't see this as an error.
                    ActionExecutedContext postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, canceled: false, exception: null);
                    filter.OnActionExecuted(postContext);
                    throw;
                }
                catch (Exception ex)
                {
                    ActionExecutedContext postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, canceled: false, exception: ex);
                    filter.OnActionExecuted(postContext);
                    if (postContext.ExceptionHandled)
                    {
                        return () => postContext;
                    }
                    else
                    {
                        throw;
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/AsyncManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Threading;

namespace System.Web.Mvc.Async
{
    public class AsyncManager
    {
        private readonly SynchronizationContext _syncContext;

        /// <summary>
        /// default timeout is 45 sec
        /// </summary>
        /// <remarks>
        /// from: http://msdn.microsoft.com/en-us/library/system.web.ui.page.asynctimeout.aspx
        /// </remarks>
        private int _timeout = 45 * 1000;

        public AsyncManager()
            : this(null /* syncContext */)
        {
        }

        public AsyncManager(SynchronizationContext syncContext)
        {
            _syncContext = syncContext ?? SynchronizationContextUtil.GetSynchronizationContext();

            OutstandingOperations = new OperationCounter();
            OutstandingOperations.Completed += delegate
            {
                Finish();
            };

            Parameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        }

        public event EventHandler Finished;

        public OperationCounter OutstandingOperations { get; private set; }

        public IDictionary<string, object> Parameters { get; private set; }

        /// <summary>
        /// Measured in milliseconds, Timeout.Infinite means 'no timeout'
        /// </summary>
        public int Timeout
        {
            get { return _timeout; }
            set
            {
                if (value < -1)
                {
                    throw Error.AsyncCommon_InvalidTimeout("value");
                }
                _timeout = value;
            }
        }

        /// <summary>
        /// The developer may call this function to signal that all operations are complete instead of
        /// waiting for the operation counter to reach zero.
        /// </summary>
        public virtual void Finish()
        {
            EventHandler handler = Finished;
            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }

        /// <summary>
        /// Executes a callback in the current synchronization context, which gives access to HttpContext and related items.
        /// </summary>
        /// <param name="action"></param>
        public virtual void Sync(Action action)
        {
            _syncContext.Sync(action);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/AsyncResultWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Threading;

namespace System.Web.Mvc.Async
{
    // This class is used for the following pattern:

    // public IAsyncResult BeginInner(..., callback, state);
    // public TInnerResult EndInner(asyncResult);
    // public IAsyncResult BeginOuter(..., callback, state);
    // public TOuterResult EndOuter(asyncResult);

    // That is, Begin/EndOuter() wrap Begin/EndInner(), potentially with pre- and post-processing.

    [DebuggerNonUserCode]
    internal static class AsyncResultWrapper
    {
        // helper methods

        private static readonly EndInvokeDelegate<Action, AsyncVoid> _voidEndInvoke = (IAsyncResult asyncResult, Action action) =>
        {
            action();
            return default(AsyncVoid);
        };

        // kicks off an asynchronous operation

        public static IAsyncResult Begin<TResult>(AsyncCallback callback, object state, BeginInvokeDelegate beginDelegate, EndInvokeDelegate<TResult> endDelegate, object tag = null, int timeout = Timeout.Infinite)
        {
            WrappedAsyncResult<TResult> asyncResult = new WrappedAsyncResult<TResult>(beginDelegate, endDelegate, tag, callbackSyncContext: null);
            asyncResult.Begin(callback, state, timeout);
            return asyncResult;
        }

        public static IAsyncResult Begin<TResult, TState>(AsyncCallback callback, object callbackState, BeginInvokeDelegate<TState> beginDelegate, EndInvokeDelegate<TState, TResult> endDelegate, TState invokeState, object tag = null, int timeout = Timeout.Infinite, SynchronizationContext callbackSyncContext = null)
        {
            WrappedAsyncResult<TResult, TState> asyncResult = new WrappedAsyncResult<TResult, TState>(beginDelegate, endDelegate, invokeState, tag, callbackSyncContext);
            asyncResult.Begin(callback, callbackState, timeout);
            return asyncResult;
        }

        public static IAsyncResult Begin<TState>(AsyncCallback callback, object callbackState, BeginInvokeDelegate<TState> beginDelegate, EndInvokeVoidDelegate<TState> endDelegate, TState invokeState, object tag = null, int timeout = Timeout.Infinite, SynchronizationContext callbackSyncContext = null)
        {
            WrappedAsyncVoid<TState> asyncResult = new WrappedAsyncVoid<TState>(beginDelegate, endDelegate, invokeState, tag, callbackSyncContext);
            asyncResult.Begin(callback, callbackState, timeout);
            return asyncResult;
        }

        // wraps a synchronous operation in an asynchronous wrapper, but still completes synchronously

        public static IAsyncResult BeginSynchronous<TResult, TState>(AsyncCallback callback, object callbackState, EndInvokeDelegate<TState, TResult> func, TState funcState, object tag)
        {
            // Frequently called, so use static delegates

            // Inline delegates that take a generic argument from a generic method don't get cached by the compiler so use a field from a static generic class
            BeginInvokeDelegate<TState> beginDelegate = CachedDelegates<TState>.CompletedBeginInvoke;

            // Pass in the blocking function as the End() method
            WrappedAsyncResult<TResult, TState> asyncResult = new WrappedAsyncResult<TResult, TState>(beginDelegate, func, funcState, tag, callbackSyncContext: null);
            asyncResult.Begin(callback, callbackState, Timeout.Infinite);
            return asyncResult;
        }

        public static IAsyncResult BeginSynchronous(AsyncCallback callback, object state, Action action, object tag)
        {
            return BeginSynchronous<AsyncVoid, Action>(callback, state, _voidEndInvoke, action, tag);
        }

        // completes an asynchronous operation

        public static TResult End<TResult>(IAsyncResult asyncResult)
        {
            return End<TResult>(asyncResult, tag: null);
        }

        public static TResult End<TResult>(IAsyncResult asyncResult, object tag)
        {
            return WrappedAsyncResultBase<TResult>.Cast(asyncResult, tag).End();
        }

        public static void End(IAsyncResult asyncResult)
        {
            End(asyncResult, tag: null);
        }

        public static void End(IAsyncResult asyncResult, object tag)
        {
            End<AsyncVoid>(asyncResult, tag);
        }

        private static class CachedDelegates<TState>
        {
            internal static BeginInvokeDelegate<TState> CompletedBeginInvoke = (AsyncCallback asyncCallback, object asyncState, TState invokeState) =>
            {
                // Begin() doesn't perform any work on its own and returns immediately.
                SimpleAsyncResult innerAsyncResult = new SimpleAsyncResult(asyncState);
                innerAsyncResult.MarkCompleted(completedSynchronously: true, callback: asyncCallback);
                return innerAsyncResult;
            };
        }

        [DebuggerNonUserCode]
        [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "The Timer will be disposed of either when it fires or when the operation completes successfully.")]
        private abstract class WrappedAsyncResultBase<TResult> : IAsyncResult
        {
            private const int AsyncStateNone = 0;
            private const int AsyncStateBeginUnwound = 1;
            private const int AsyncStateCallbackFired = 2;

            private int _asyncState;
            private readonly object _beginDelegateLockObj = new object();
            private readonly SingleEntryGate _endExecutedGate = new SingleEntryGate(); // prevent End() from being called twice
            private readonly SingleEntryGate _handleCallbackGate = new SingleEntryGate(); // prevent callback from being handled multiple times
            private readonly object _tag; // prevent an instance of this type from being passed to the wrong End() method
            private IAsyncResult _innerAsyncResult;
            private AsyncCallback _originalCallback;
            private volatile bool _timedOut;
            private Timer _timer;
            private readonly SynchronizationContext _callbackSyncContext;

            protected WrappedAsyncResultBase(object tag, SynchronizationContext callbackSyncContext)
            {
                _tag = tag;
                _callbackSyncContext = callbackSyncContext;
            }

            public object AsyncState
            {
                get { return _innerAsyncResult.AsyncState; }
            }

            public WaitHandle AsyncWaitHandle
            {
                get { return null; }
            }

            public bool CompletedSynchronously { get; private set; }

            public bool IsCompleted
            {
                get { return _timedOut || _innerAsyncResult.IsCompleted; }
            }

            // kicks off the process, instantiates a timer if requested
            public void Begin(AsyncCallback callback, object state, int timeout)
            {
                _originalCallback = callback;

                // Force the target Begin() operation to complete before the callback can continue,
                // since the target operation might perform post-processing of the data.
                lock (_beginDelegateLockObj)
                {
                    _innerAsyncResult = CallBeginDelegate(HandleAsynchronousCompletion, state);

                    // If the callback has already fired, then the completion routine has no-oped and we
                    // can just treat this as if it were a normal synchronous completion.
                    int originalState = Interlocked.Exchange(ref _asyncState, AsyncStateBeginUnwound);
                    bool callbackAlreadyFired = (originalState == AsyncStateCallbackFired);

                    CompletedSynchronously = callbackAlreadyFired || _innerAsyncResult.CompletedSynchronously;

                    if (!CompletedSynchronously)
                    {
                        if (timeout > Timeout.Infinite)
                        {
                            CreateTimer(timeout);
                        }
                    }
                }

                if (CompletedSynchronously)
                {
                    if (callback != null)
                    {
                        callback(this);
                    }
                }
            }

            protected abstract IAsyncResult CallBeginDelegate(AsyncCallback callback, object callbackState);

            protected abstract TResult CallEndDelegate(IAsyncResult asyncResult);

            public static WrappedAsyncResultBase<TResult> Cast(IAsyncResult asyncResult, object tag)
            {
                if (asyncResult == null)
                {
                    throw new ArgumentNullException("asyncResult");
                }

                WrappedAsyncResultBase<TResult> castResult = asyncResult as WrappedAsyncResultBase<TResult>;
                if (castResult != null && Equals(castResult._tag, tag))
                {
                    return castResult;
                }
                else
                {
                    throw Error.AsyncCommon_InvalidAsyncResult("asyncResult");
                }
            }

            private void CallbackUsingSyncContext()
            {
                _callbackSyncContext.Sync(() => _originalCallback(this));
            }

            private void CreateTimer(int timeout)
            {
                // this method should be called within a lock(_beginDelegateLockObj)
                _timer = new Timer(HandleTimeout, null, timeout, Timeout.Infinite /* disable periodic signaling */);
            }

            public TResult End()
            {
                if (!_endExecutedGate.TryEnter())
                {
                    throw Error.AsyncCommon_AsyncResultAlreadyConsumed();
                }

                if (_timedOut)
                {
                    throw new TimeoutException();
                }
                WaitForBeginToCompleteAndDestroyTimer();

                return CallEndDelegate(_innerAsyncResult);
            }

            private void ExecuteAsynchronousCallback(bool timedOut)
            {
                WaitForBeginToCompleteAndDestroyTimer();

                if (_handleCallbackGate.TryEnter())
                {
                    _timedOut = timedOut;
                    if (_originalCallback != null)
                    {
                        if (_callbackSyncContext != null)
                        {
                            CallbackUsingSyncContext();
                        }
                        else
                        {
                            _originalCallback(this);
                        }
                    }
                }
            }

            private void HandleAsynchronousCompletion(IAsyncResult asyncResult)
            {
                // Transition the async state to CALLBACK_FIRED. If the Begin* method hasn't yet unwound,
                // then we can no-op here since the Begin method will query the _asyncState field and
                // treat this as a regular synchronous completion.
                int originalState = Interlocked.Exchange(ref _asyncState, AsyncStateCallbackFired);
                if (originalState != AsyncStateBeginUnwound)
                {
                    return;
                }

                ExecuteAsynchronousCallback(timedOut: false);
            }

            private void HandleTimeout(object state)
            {
                ExecuteAsynchronousCallback(timedOut: true);
            }

            private void WaitForBeginToCompleteAndDestroyTimer()
            {
                lock (_beginDelegateLockObj)
                {
                    // Wait for the target Begin() method to complete, as it might be performing
                    // post-processing. This also forces a memory barrier, so _innerAsyncResult
                    // is guaranteed to be non-null at this point.

                    if (_timer != null)
                    {
                        _timer.Dispose();
                    }
                    _timer = null;
                }
            }
        }

        private sealed class WrappedAsyncResult<TResult> : WrappedAsyncResultBase<TResult>
        {
            private readonly BeginInvokeDelegate _beginDelegate;
            private readonly EndInvokeDelegate<TResult> _endDelegate;

            public WrappedAsyncResult(BeginInvokeDelegate beginDelegate, EndInvokeDelegate<TResult> endDelegate, object tag, SynchronizationContext callbackSyncContext)
                : base(tag, callbackSyncContext)
            {
                _beginDelegate = beginDelegate;
                _endDelegate = endDelegate;
            }

            protected override IAsyncResult CallBeginDelegate(AsyncCallback callback, object callbackState)
            {
                return _beginDelegate(callback, callbackState);
            }

            protected override TResult CallEndDelegate(IAsyncResult asyncResult)
            {
                return _endDelegate(asyncResult);
            }
        }

        private sealed class WrappedAsyncResult<TResult, TState> : WrappedAsyncResultBase<TResult>
        {
            private readonly BeginInvokeDelegate<TState> _beginDelegate;
            private readonly EndInvokeDelegate<TState, TResult> _endDelegate;
            private readonly TState _state;

            public WrappedAsyncResult(BeginInvokeDelegate<TState> beginDelegate, EndInvokeDelegate<TState, TResult> endDelegate, TState state, object tag, SynchronizationContext callbackSyncContext)
                : base(tag, callbackSyncContext)
            {
                _beginDelegate = beginDelegate;
                _endDelegate = endDelegate;
                _state = state;
            }

            protected override TResult CallEndDelegate(IAsyncResult asyncResult)
            {
                return _endDelegate(asyncResult, _state);
            }

            protected override IAsyncResult CallBeginDelegate(AsyncCallback callback, object callbackState)
            {
                return _beginDelegate(callback, callbackState, _state);
            }
        }

        private sealed class WrappedAsyncVoid<TState> : WrappedAsyncResultBase<AsyncVoid>
        {
            private readonly BeginInvokeDelegate<TState> _beginDelegate;
            private readonly EndInvokeVoidDelegate<TState> _endDelegate;
            private readonly TState _state;

            public WrappedAsyncVoid(BeginInvokeDelegate<TState> beginDelegate, EndInvokeVoidDelegate<TState> endDelegate, TState state, object tag, SynchronizationContext callbackSyncContext)
                : base(tag, callbackSyncContext)
            {
                _beginDelegate = beginDelegate;
                _endDelegate = endDelegate;
                _state = state;
            }

            protected override AsyncVoid CallEndDelegate(IAsyncResult asyncResult)
            {
                _endDelegate(asyncResult, _state);
                return default(AsyncVoid);
            }

            protected override IAsyncResult CallBeginDelegate(AsyncCallback callback, object callbackState)
            {
                return _beginDelegate(callback, callbackState, _state);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/AsyncVoid.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    // Dummy type used for passing something resembling 'void' to the async delegate functions
    internal struct AsyncVoid
    {
    }
}


================================================
FILE: src/System.Web.Mvc/Async/BeginInvokeDelegate.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    internal delegate IAsyncResult BeginInvokeDelegate(AsyncCallback callback, object state);
}


================================================
FILE: src/System.Web.Mvc/Async/BeginInvokeDelegateOfTState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    internal delegate IAsyncResult BeginInvokeDelegate<TState>(AsyncCallback callback, object callbackState, TState invokeState);
}


================================================
FILE: src/System.Web.Mvc/Async/EndInvokeDelegateOfTResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    internal delegate TResult EndInvokeDelegate<TResult>(IAsyncResult asyncResult);
}


================================================
FILE: src/System.Web.Mvc/Async/EndInvokeDelegateOfTResultTState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    internal delegate TResult EndInvokeDelegate<TState, TResult>(IAsyncResult asyncResult, TState state);
}


================================================
FILE: src/System.Web.Mvc/Async/EndInvokeVoidDelegate.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    internal delegate void EndInvokeVoidDelegate<TState>(IAsyncResult asyncResult, TState state);
}


================================================
FILE: src/System.Web.Mvc/Async/IAsyncActionInvoker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    public interface IAsyncActionInvoker : IActionInvoker
    {
        IAsyncResult BeginInvokeAction(ControllerContext controllerContext, string actionName, AsyncCallback callback, object state);
        bool EndInvokeAction(IAsyncResult asyncResult);
    }
}


================================================
FILE: src/System.Web.Mvc/Async/IAsyncActionInvokerFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    /// <summary>
    /// Used to create an <see cref="IAsyncActionInvoker"/> instance for the current request.
    /// </summary>
    public interface IAsyncActionInvokerFactory
    {
        /// <summary>
        /// Creates an instance of async action invoker for the current request.
        /// </summary>
        /// <returns>The created <see cref="IAsyncActionInvoker"/>.</returns>
        IAsyncActionInvoker CreateInstance();
    }
}


================================================
FILE: src/System.Web.Mvc/Async/IAsyncController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;

namespace System.Web.Mvc.Async
{
    public interface IAsyncController : IController
    {
        IAsyncResult BeginExecute(RequestContext requestContext, AsyncCallback callback, object state);
        void EndExecute(IAsyncResult asyncResult);
    }
}


================================================
FILE: src/System.Web.Mvc/Async/IAsyncManagerContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    public interface IAsyncManagerContainer
    {
        AsyncManager AsyncManager { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/OperationCounter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc.Async
{
    public sealed class OperationCounter
    {
        private int _count;

        public event EventHandler Completed;

        public int Count
        {
            get { return Thread.VolatileRead(ref _count); }
        }

        private int AddAndExecuteCallbackIfCompleted(int value)
        {
            int newCount = Interlocked.Add(ref _count, value);
            if (newCount == 0)
            {
                OnCompleted();
            }

            return newCount;
        }

        public int Decrement()
        {
            return AddAndExecuteCallbackIfCompleted(-1);
        }

        public int Decrement(int value)
        {
            return AddAndExecuteCallbackIfCompleted(-value);
        }

        public int Increment()
        {
            return AddAndExecuteCallbackIfCompleted(1);
        }

        public int Increment(int value)
        {
            return AddAndExecuteCallbackIfCompleted(value);
        }

        private void OnCompleted()
        {
            EventHandler handler = Completed;
            if (handler != null)
            {
                handler(this, EventArgs.Empty);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/ReflectedAsyncActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;

namespace System.Web.Mvc.Async
{
    public class ReflectedAsyncActionDescriptor : AsyncActionDescriptor, IMethodInfoActionDescriptor
    {
        private readonly object _executeTag = new object();

        private readonly string _actionName;
        private readonly ControllerDescriptor _controllerDescriptor;
        private readonly Lazy<string> _uniqueId;
        private ParameterDescriptor[] _parametersCache;

        public ReflectedAsyncActionDescriptor(MethodInfo asyncMethodInfo, MethodInfo completedMethodInfo, string actionName, ControllerDescriptor controllerDescriptor)
            : this(asyncMethodInfo, completedMethodInfo, actionName, controllerDescriptor, true /* validateMethods */)
        {
        }

        internal ReflectedAsyncActionDescriptor(MethodInfo asyncMethodInfo, MethodInfo completedMethodInfo, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethods)
        {
            if (asyncMethodInfo == null)
            {
                throw new ArgumentNullException("asyncMethodInfo");
            }
            if (completedMethodInfo == null)
            {
                throw new ArgumentNullException("completedMethodInfo");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw Error.ParameterCannotBeNullOrEmpty("actionName");
            }
            if (controllerDescriptor == null)
            {
                throw new ArgumentNullException("controllerDescriptor");
            }

            if (validateMethods)
            {
                string asyncFailedMessage = VerifyActionMethodIsCallable(asyncMethodInfo);
                if (asyncFailedMessage != null)
                {
                    throw new ArgumentException(asyncFailedMessage, "asyncMethodInfo");
                }

                string completedFailedMessage = VerifyActionMethodIsCallable(completedMethodInfo);
                if (completedFailedMessage != null)
                {
                    throw new ArgumentException(completedFailedMessage, "completedMethodInfo");
                }
            }

            AsyncMethodInfo = asyncMethodInfo;
            CompletedMethodInfo = completedMethodInfo;
            _actionName = actionName;
            _controllerDescriptor = controllerDescriptor;
            _uniqueId = new Lazy<string>(CreateUniqueId);
        }

        public override string ActionName
        {
            get { return _actionName; }
        }

        public MethodInfo AsyncMethodInfo { get; private set; }

        public MethodInfo CompletedMethodInfo { get; private set; }

        public override ControllerDescriptor ControllerDescriptor
        {
            get { return _controllerDescriptor; }
        }

        public MethodInfo MethodInfo
        {
            get { return AsyncMethodInfo; }
        }

        public override string UniqueId
        {
            get { return _uniqueId.Value; }
        }

        public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            AsyncManager asyncManager = GetAsyncManager(controllerContext.Controller);

            BeginInvokeDelegate beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState)
            {
                // call the XxxAsync() method
                ParameterInfo[] parameterInfos = AsyncMethodInfo.GetParameters();
                var rawParameterValues = from parameterInfo in parameterInfos
                                         select ExtractParameterFromDictionary(parameterInfo, parameters, AsyncMethodInfo);
                object[] parametersArray = rawParameterValues.ToArray();

                TriggerListener listener = new TriggerListener();
                SimpleAsyncResult asyncResult = new SimpleAsyncResult(asyncState);

                // hook the Finished event to notify us upon completion
                Trigger finishTrigger = listener.CreateTrigger();
                asyncManager.Finished += delegate
                {
                    finishTrigger.Fire();
                };
                asyncManager.OutstandingOperations.Increment();

                // to simplify the logic, force the rest of the pipeline to execute in an asynchronous callback
                listener.SetContinuation(() => ThreadPool.QueueUserWorkItem(_ => asyncResult.MarkCompleted(false /* completedSynchronously */, asyncCallback)));

                // the inner operation might complete synchronously, so all setup work has to be done before this point
                ActionMethodDispatcher dispatcher = DispatcherCache.GetDispatcher(AsyncMethodInfo);
                dispatcher.Execute(controllerContext.Controller, parametersArray); // ignore return value from this method

                // now that the XxxAsync() method has completed, kick off any pending operations
                asyncManager.OutstandingOperations.Decrement();
                listener.Activate();
                return asyncResult;
            };

            EndInvokeDelegate<object> endDelegate = delegate(IAsyncResult asyncResult)
            {
                // call the XxxCompleted() method
                ParameterInfo[] completionParametersInfos = CompletedMethodInfo.GetParameters();
                var rawCompletionParameterValues = from parameterInfo in completionParametersInfos
                                                   select ExtractParameterOrDefaultFromDictionary(parameterInfo, asyncManager.Parameters);
                object[] completionParametersArray = rawCompletionParameterValues.ToArray();

                ActionMethodDispatcher dispatcher = DispatcherCache.GetDispatcher(CompletedMethodInfo);
                object actionReturnValue = dispatcher.Execute(controllerContext.Controller, completionParametersArray);
                return actionReturnValue;
            };

            return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, _executeTag, asyncManager.Timeout);
        }

        private string CreateUniqueId()
        {
            return base.UniqueId + DescriptorUtil.CreateUniqueId(AsyncMethodInfo, CompletedMethodInfo);
        }

        public override object EndExecute(IAsyncResult asyncResult)
        {
            return AsyncResultWrapper.End<object>(asyncResult, _executeTag);
        }

        public override object[] GetCustomAttributes(bool inherit)
        {
            return ActionDescriptorHelper.GetCustomAttributes(AsyncMethodInfo, inherit);
        }

        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return ActionDescriptorHelper.GetCustomAttributes(AsyncMethodInfo, attributeType, inherit);
        }

        public override IEnumerable<FilterAttribute> GetFilterAttributes(bool useCache)
        {
            if (useCache && GetType() == typeof(ReflectedAsyncActionDescriptor))
            {
                // Do not look at cache in types derived from this type because they might incorrectly implement GetCustomAttributes
                return ReflectedAttributeCache.GetMethodFilterAttributes(AsyncMethodInfo);
            }
            return base.GetFilterAttributes(useCache);
        }

        public override ParameterDescriptor[] GetParameters()
        {
            return ActionDescriptorHelper.GetParameters(this, AsyncMethodInfo, ref _parametersCache);
        }

        public override ICollection<ActionSelector> GetSelectors()
        {
            return ActionDescriptorHelper.GetSelectors(AsyncMethodInfo);
        }

        internal override ICollection<ActionNameSelector> GetNameSelectors()
        {
            return ActionDescriptorHelper.GetNameSelectors(AsyncMethodInfo);
        }

        public override bool IsDefined(Type attributeType, bool inherit)
        {
            return ActionDescriptorHelper.IsDefined(AsyncMethodInfo, attributeType, inherit);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/ReflectedAsyncControllerDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc.Async
{
    public class ReflectedAsyncControllerDescriptor : ControllerDescriptor
    {
        internal static readonly Func<Type, ControllerDescriptor> DefaultDescriptorFactory =
            (type) => new ReflectedAsyncControllerDescriptor(type);

        private static readonly ActionDescriptor[] _emptyCanonicalActions = new ActionDescriptor[0];

        private readonly Type _controllerType;
        private readonly AsyncActionMethodSelector _selector;

        public ReflectedAsyncControllerDescriptor(Type controllerType)
        {
            if (controllerType == null)
            {
                throw new ArgumentNullException("controllerType");
            }

            _controllerType = controllerType;
            bool allowLegacyAsyncActions = AllowLegacyAsyncActions(_controllerType);
            _selector = new AsyncActionMethodSelector(_controllerType, allowLegacyAsyncActions);
        }

        public sealed override Type ControllerType
        {
            get { return _controllerType; }
        }

        internal AsyncActionMethodSelector Selector
        {
            get { return _selector; }
        }

        /// <summary>
        /// Determines if we should bind "Foo" to FooAsync/FooCompleted pattern. 
        /// </summary>
        /// <param name="controllerType"></param>
        /// <returns></returns>
        private static bool AllowLegacyAsyncActions(Type controllerType)
        {
            if (typeof(AsyncController).IsAssignableFrom(controllerType))
            {
                return true;
            }
            if (typeof(Controller).IsAssignableFrom(controllerType))
            {
                // for backwards compat. Controller now supports IAsyncController, 
                // but still use synchronous bindings patterns. 
                return false;
            }
            if (!typeof(IAsyncController).IsAssignableFrom(controllerType))
            {
                return false;
            }
            return true;
        }

        public override ActionDescriptor FindAction(ControllerContext controllerContext, string actionName)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw Error.ParameterCannotBeNullOrEmpty("actionName");
            }

            ActionDescriptorCreator creator = _selector.FindAction(controllerContext, actionName);
            if (creator == null)
            {
                return null;
            }

            return creator(actionName, this);
        }

        public override ActionDescriptor[] GetCanonicalActions()
        {
            // everything is looked up dymanically, so there are no 'canonical' actions
            return _emptyCanonicalActions;
        }

        public override object[] GetCustomAttributes(bool inherit)
        {
            return ControllerType.GetCustomAttributes(inherit);
        }

        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return ControllerType.GetCustomAttributes(attributeType, inherit);
        }

        public override IEnumerable<FilterAttribute> GetFilterAttributes(bool useCache)
        {
            if (useCache && GetType() == typeof(ReflectedAsyncControllerDescriptor))
            {
                // Do not look at cache in types derived from this type because they might incorrectly implement GetCustomAttributes
                return ReflectedAttributeCache.GetTypeFilterAttributes(ControllerType);
            }
            return base.GetFilterAttributes(useCache);
        }

        public override bool IsDefined(Type attributeType, bool inherit)
        {
            return ControllerType.IsDefined(attributeType, inherit);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/SimpleAsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc.Async
{
    internal sealed class SimpleAsyncResult : IAsyncResult
    {
        private readonly object _asyncState;
        private bool _completedSynchronously;
        private volatile bool _isCompleted;

        public SimpleAsyncResult(object asyncState)
        {
            _asyncState = asyncState;
        }

        public object AsyncState
        {
            get { return _asyncState; }
        }

        // ASP.NET IAsyncResult objects should never expose a WaitHandle due to potential deadlocking
        public WaitHandle AsyncWaitHandle
        {
            get { return null; }
        }

        public bool CompletedSynchronously
        {
            get { return _completedSynchronously; }
        }

        public bool IsCompleted
        {
            get { return _isCompleted; }
        }

        // Proper order of execution:
        // 1. Set the CompletedSynchronously property to the correct value
        // 2. Set the IsCompleted flag
        // 3. Execute the callback
        // 4. Signal the WaitHandle (which we don't have)
        public void MarkCompleted(bool completedSynchronously, AsyncCallback callback)
        {
            _completedSynchronously = completedSynchronously;
            _isCompleted = true;

            if (callback != null)
            {
                callback(this);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/SingleEntryGate.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc.Async
{
    // used to synchronize access to a single-use consumable resource
    internal sealed class SingleEntryGate
    {
        private const int NotEntered = 0;
        private const int Entered = 1;

        private int _status;

        // returns true if this is the first call to TryEnter(), false otherwise
        public bool TryEnter()
        {
            int oldStatus = Interlocked.Exchange(ref _status, Entered);
            return (oldStatus == NotEntered);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/SynchronizationContextUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Threading;

namespace System.Web.Mvc.Async
{
    internal static class SynchronizationContextUtil
    {
        public static SynchronizationContext GetSynchronizationContext()
        {
            // In a runtime environment, SynchronizationContext.Current will be set to an instance
            // of AspNetSynchronizationContext. In a unit test environment, the Current property
            // won't be set and we have to create one on the fly.
            return SynchronizationContext.Current ?? new SynchronizationContext();
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is swallowed and immediately re-thrown")]
        public static T Sync<T>(this SynchronizationContext syncContext, Func<T> func)
        {
            T theValue = default(T);
            Exception thrownException = null;

            syncContext.Send(o =>
            {
                try
                {
                    theValue = func();
                }
                catch (Exception ex)
                {
                    // by default, the AspNetSynchronizationContext type will swallow thrown exceptions,
                    // so we need to save and propagate them
                    thrownException = ex;
                }
            }, null);

            if (thrownException != null)
            {
                throw Error.SynchronizationContextUtil_ExceptionThrown(thrownException);
            }
            return theValue;
        }

        public static void Sync(this SynchronizationContext syncContext, Action action)
        {
            Sync<AsyncVoid>(syncContext, () =>
            {
                action();
                return default(AsyncVoid);
            });
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/SynchronousOperationException.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.Serialization;

namespace System.Web.Mvc.Async
{
    // This exception type is thrown by the SynchronizationContextUtil helper class since the AspNetSynchronizationContext
    // type swallows exceptions. The inner exception contains the data the user cares about.

    [Serializable]
    public sealed class SynchronousOperationException : HttpException
    {
        public SynchronousOperationException()
        {
        }

        private SynchronousOperationException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }

        public SynchronousOperationException(string message)
            : base(message)
        {
        }

        public SynchronousOperationException(string message, Exception innerException)
            : base(message, innerException)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/TaskAsyncActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc.Async
{
    /// <summary>
    /// When an action method returns either Task or Task{T} the TaskAsyncActionDescriptor provides information about the action.
    /// </summary>
    public class TaskAsyncActionDescriptor : AsyncActionDescriptor, IMethodInfoActionDescriptor
    {
        /// <summary>
        /// dictionary to hold methods that can read Task{T}.Result
        /// </summary>
        private static readonly ConcurrentDictionary<Type, Func<object, object>> _taskValueExtractors = new ConcurrentDictionary<Type, Func<object, object>>();
        private readonly string _actionName;
        private readonly ControllerDescriptor _controllerDescriptor;
        private readonly Lazy<string> _uniqueId;
        private ParameterDescriptor[] _parametersCache;

        public TaskAsyncActionDescriptor(MethodInfo taskMethodInfo, string actionName, ControllerDescriptor controllerDescriptor)
            : this(taskMethodInfo, actionName, controllerDescriptor, validateMethod: true)
        {
        }

        internal TaskAsyncActionDescriptor(MethodInfo taskMethodInfo, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethod)
        {
            if (taskMethodInfo == null)
            {
                throw new ArgumentNullException("taskMethodInfo");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw Error.ParameterCannotBeNullOrEmpty("actionName");
            }
            if (controllerDescriptor == null)
            {
                throw new ArgumentNullException("controllerDescriptor");
            }

            if (validateMethod)
            {
                string taskFailedMessage = VerifyActionMethodIsCallable(taskMethodInfo);
                if (taskFailedMessage != null)
                {
                    throw new ArgumentException(taskFailedMessage, "taskMethodInfo");
                }
            }

            TaskMethodInfo = taskMethodInfo;
            _actionName = actionName;
            _controllerDescriptor = controllerDescriptor;
            _uniqueId = new Lazy<string>(CreateUniqueId);
        }

        public override string ActionName
        {
            get { return _actionName; }
        }

        public MethodInfo TaskMethodInfo { get; private set; }

        public override ControllerDescriptor ControllerDescriptor
        {
            get { return _controllerDescriptor; }
        }

        public MethodInfo MethodInfo
        {
            get { return TaskMethodInfo; }
        }

        public override string UniqueId
        {
            get { return _uniqueId.Value; }
        }

        private string CreateUniqueId()
        {
            var builder = new StringBuilder(base.UniqueId);
            DescriptorUtil.AppendUniqueId(builder, MethodInfo);
            return builder.ToString();
        }

        [SuppressMessage("Microsoft.Web.FxCop", "MW1201:DoNotCallProblematicMethodsOnTask", Justification = "This is commented in great detail.")]
        public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            ParameterInfo[] parameterInfos = TaskMethodInfo.GetParameters();
            var rawParameterValues = from parameterInfo in parameterInfos
                                     select ExtractParameterFromDictionary(parameterInfo, parameters, TaskMethodInfo);
            object[] parametersArray = rawParameterValues.ToArray();

            CancellationTokenSource tokenSource = null;
            bool disposedTimer = false;
            Timer taskCancelledTimer = null;
            bool taskCancelledTimerRequired = false;

            int timeout = GetAsyncManager(controllerContext.Controller).Timeout;

            for (int i = 0; i < parametersArray.Length; i++)
            {
                if (default(CancellationToken).Equals(parametersArray[i]))
                {
                    tokenSource = new CancellationTokenSource();
                    parametersArray[i] = tokenSource.Token;

                    // If there is a timeout we will create a timer to cancel the task when the
                    // timeout expires.
                    taskCancelledTimerRequired = timeout > Timeout.Infinite;
                    break;
                }
            }

            ActionMethodDispatcher dispatcher = DispatcherCache.GetDispatcher(TaskMethodInfo);

            if (taskCancelledTimerRequired)
            {
                taskCancelledTimer = new Timer(_ =>
                {
                    lock (tokenSource)
                    {
                        if (!disposedTimer)
                        {
                            tokenSource.Cancel();
                        }
                    }
                }, state: null, dueTime: timeout, period: Timeout.Infinite);
            }

            Task taskUser = dispatcher.Execute(controllerContext.Controller, parametersArray) as Task;
            Action cleanupAtEndExecute = () =>
            {
                // Cleanup code that's run in EndExecute, after we've waited on the task value.

                if (taskCancelledTimer != null)
                {
                    // Timer callback may still fire after Dispose is called.
                    taskCancelledTimer.Dispose();
                }

                if (tokenSource != null)
                {
                    lock (tokenSource)
                    {
                        disposedTimer = true;
                        tokenSource.Dispose();
                        if (tokenSource.IsCancellationRequested)
                        {
                            // Give Timeout exceptions higher priority over other exceptions, mainly OperationCancelled exceptions
                            // that were signaled with out timeout token.
                            throw new TimeoutException();
                        }
                    }
                }
            };

            TaskWrapperAsyncResult result = new TaskWrapperAsyncResult(taskUser, state, cleanupAtEndExecute);

            // if user supplied a callback, invoke that when their task has finished running.
            if (callback != null)
            {
                if (taskUser.IsCompleted)
                {
                    // If the underlying task is already finished, from our caller's perspective this is just
                    // a synchronous completion.
                    result.CompletedSynchronously = true;
                    callback(result);
                }
                else
                {
                    // If the underlying task isn't yet finished, from our caller's perspective this will be
                    // an asynchronous completion. We'll use ContinueWith instead of Finally for two reasons:
                    //
                    // - Finally propagates the antecedent Task's exception, which we don't need to do here.
                    //   Out caller will eventually call EndExecute, which correctly observes the
                    //   antecedent Task's exception anyway if it faulted.
                    //
                    // - Finally invokes the callback on the captured SynchronizationContext, which is
                    //   unnecessary when using APM (Begin / End). APM assumes that the callback is invoked
                    //   on an arbitrary ThreadPool thread with no SynchronizationContext set up, so
                    //   ContinueWith gets us closer to the desired semantic.
                    result.CompletedSynchronously = false;
                    taskUser.ContinueWith(_ =>
                    {
                        callback(result);
                    });
                }
            }

            return result;
        }

        public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters)
        {
            string errorMessage = String.Format(CultureInfo.CurrentCulture, MvcResources.TaskAsyncActionDescriptor_CannotExecuteSynchronously,
                                                ActionName);

            throw new InvalidOperationException(errorMessage);
        }

        public override object EndExecute(IAsyncResult asyncResult)
        {
            TaskWrapperAsyncResult wrapperResult = (TaskWrapperAsyncResult)asyncResult;

            // Throw an exception with the correct call stack
            try
            {
                wrapperResult.Task.ThrowIfFaulted();
            }
            finally
            {
                if (wrapperResult.CleanupThunk != null)
                {
                    wrapperResult.CleanupThunk();
                }
            }

            // Extract the result of the task if there is a result
            return _taskValueExtractors.GetOrAdd(TaskMethodInfo.ReturnType, CreateTaskValueExtractor)(wrapperResult.Task);
        }

        private static Func<object, object> CreateTaskValueExtractor(Type taskType)
        {
            // Task<T>?
            if (taskType.IsGenericType && taskType.GetGenericTypeDefinition() == typeof(Task<>))
            {
                // lambda = arg => (object)(((Task<T>)arg).Result)
                var arg = Expression.Parameter(typeof(object));
                var castArg = Expression.Convert(arg, taskType);
                var fieldAccess = Expression.Property(castArg, "Result");
                var castResult = Expression.Convert(fieldAccess, typeof(object));
                var lambda = Expression.Lambda<Func<object, object>>(castResult, arg);
                return lambda.Compile();
            }

            // Any exceptions should be thrown before getting the task value so just return null.
            return theTask =>
            {
                return null;
            };
        }

        public override object[] GetCustomAttributes(bool inherit)
        {
            return ActionDescriptorHelper.GetCustomAttributes(TaskMethodInfo, inherit);
        }

        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return ActionDescriptorHelper.GetCustomAttributes(TaskMethodInfo, attributeType, inherit);
        }

        public override ParameterDescriptor[] GetParameters()
        {
            return ActionDescriptorHelper.GetParameters(this, TaskMethodInfo, ref _parametersCache);
        }

        public override ICollection<ActionSelector> GetSelectors()
        {
            return ActionDescriptorHelper.GetSelectors(TaskMethodInfo);
        }

        internal override ICollection<ActionNameSelector> GetNameSelectors()
        {
            return ActionDescriptorHelper.GetNameSelectors(TaskMethodInfo);
        }

        public override bool IsDefined(Type attributeType, bool inherit)
        {
            return ActionDescriptorHelper.IsDefined(TaskMethodInfo, attributeType, inherit);
        }

        public override IEnumerable<FilterAttribute> GetFilterAttributes(bool useCache)
        {
            if (useCache && GetType() == typeof(TaskAsyncActionDescriptor))
            {
                // Do not look at cache in types derived from this type because they might incorrectly implement GetCustomAttributes
                return ReflectedAttributeCache.GetMethodFilterAttributes(TaskMethodInfo);
            }
            return base.GetFilterAttributes(useCache);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/TaskWrapperAsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Mvc.Async
{
    /// <summary>
    /// Wraps a <see cref="Task"/> class, optionally overriding the State object (since the Task Asynchronous Pattern doesn't normally use it).
    /// Copied from System.Web.
    /// </summary>
    internal sealed class TaskWrapperAsyncResult : IAsyncResult
    {
        private bool? _completedSynchronously;

        internal TaskWrapperAsyncResult(Task task, object asyncState, Action cleanupThunk = null)
        {
            Task = task;
            AsyncState = asyncState;
            CleanupThunk = cleanupThunk;
        }

        public object AsyncState { get; private set; }

        public WaitHandle AsyncWaitHandle
        {
            get { return ((IAsyncResult)Task).AsyncWaitHandle; }
        }

        /// <summary>
        /// Cleanup logic to run after Task is finished
        /// </summary>
        public Action CleanupThunk { get; private set; }

        /// <summary>
        /// Gets a value indicating whether the asynchronous operation completed synchronously.
        /// </summary>
        /// <returns>true if the asynchronous operation completed synchronously; otherwise, false.</returns>
        public bool CompletedSynchronously
        {
            get { return _completedSynchronously ?? ((IAsyncResult)Task).CompletedSynchronously; }
            internal set { _completedSynchronously = value; }
        }

        public bool IsCompleted
        {
            get { return ((IAsyncResult)Task).IsCompleted; }
        }

        internal Task Task { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/Trigger.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Async
{
    // Provides a trigger for the TriggerListener class.

    internal sealed class Trigger
    {
        private readonly Action _fireAction;

        // Constructor should only be called by TriggerListener.
        internal Trigger(Action fireAction)
        {
            _fireAction = fireAction;
        }

        public void Fire()
        {
            _fireAction();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Async/TriggerListener.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc.Async
{
    // This class is used to wait for triggers and a continuation. When the continuation has been provded
    // and all triggers have been fired, the continuation is called. Similar to WaitHandle.WaitAll().
    // New instances of this type are initially in the inactive state; activation is enabled by a call
    // to Activate().

    // This class is thread-safe.

    internal sealed class TriggerListener
    {
        private readonly Trigger _activateTrigger;
        private readonly SingleEntryGate _continuationFiredGate = new SingleEntryGate();
        private readonly Trigger _setContinuationTrigger;
        private volatile Action _continuation;
        private int _outstandingTriggers;

        public TriggerListener()
        {
            _activateTrigger = CreateTrigger();
            _setContinuationTrigger = CreateTrigger();
        }

        public void Activate()
        {
            _activateTrigger.Fire();
        }

        public Trigger CreateTrigger()
        {
            Interlocked.Increment(ref _outstandingTriggers);

            SingleEntryGate triggerFiredGate = new SingleEntryGate();
            return new Trigger(() =>
            {
                if (triggerFiredGate.TryEnter())
                {
                    HandleTriggerFired();
                }
            });
        }

        private void HandleTriggerFired()
        {
            if (Interlocked.Decrement(ref _outstandingTriggers) == 0)
            {
                if (_continuationFiredGate.TryEnter())
                {
                    _continuation();
                }
            }
        }

        public void SetContinuation(Action continuation)
        {
            if (continuation != null)
            {
                _continuation = continuation;
                _setContinuationTrigger.Fire();
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AsyncController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    // Controller now supports asynchronous operations.
    // This class only exists 
    // a) for backwards compat for callers that derive from it,
    // b) ActionMethodSelector can detect it to bind to ActionAsync/ActionCompleted patterns. 
    public abstract class AsyncController : Controller
    {
    }
}


================================================
FILE: src/System.Web.Mvc/AsyncTimeoutAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc.Async;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "Unsealed so that subclassed types can set properties in the default constructor.")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public class AsyncTimeoutAttribute : ActionFilterAttribute
    {
        // duration is specified in milliseconds
        public AsyncTimeoutAttribute(int duration)
        {
            if (duration < -1)
            {
                throw Error.AsyncCommon_InvalidTimeout("duration");
            }

            Duration = duration;
        }

        public int Duration { get; private set; }

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            IAsyncManagerContainer container = filterContext.Controller as IAsyncManagerContainer;
            if (container == null)
            {
                throw Error.AsyncCommon_ControllerMustImplementIAsyncManagerContainer(filterContext.Controller.GetType());
            }

            container.AsyncManager.Timeout = Duration;

            base.OnActionExecuting(filterContext);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/AuthorizationContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class AuthorizationContext : ControllerContext
    {
        // parameterless constructor used for mocking
        public AuthorizationContext()
        {
        }

        [Obsolete("The recommended alternative is the constructor AuthorizationContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor).")]
        public AuthorizationContext(ControllerContext controllerContext)
            : base(controllerContext)
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public AuthorizationContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            : base(controllerContext)
        {
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            ActionDescriptor = actionDescriptor;
        }

        public virtual ActionDescriptor ActionDescriptor { get; set; }

        public ActionResult Result { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/AuthorizeAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Security.Principal;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "Unsealed so that subclassed types can set properties in the default constructor or override our behavior.")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public class AuthorizeAttribute : FilterAttribute, IAuthorizationFilter
    {
        private static readonly char[] _splitParameter = new[] { ',' };
        private readonly object _typeId = new object();

        private string _roles;
        private string[] _rolesSplit = new string[0];
        private string _users;
        private string[] _usersSplit = new string[0];

        public string Roles
        {
            get { return _roles ?? String.Empty; }
            set
            {
                _roles = value;
                _rolesSplit = SplitString(value);
            }
        }

        public override object TypeId
        {
            get { return _typeId; }
        }

        public string Users
        {
            get { return _users ?? String.Empty; }
            set
            {
                _users = value;
                _usersSplit = SplitString(value);
            }
        }

        // This method must be thread-safe since it is called by the thread-safe OnCacheAuthorization() method.
        protected virtual bool AuthorizeCore(HttpContextBase httpContext)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }

            IPrincipal user = httpContext.User;
            if (!user.Identity.IsAuthenticated)
            {
                return false;
            }

            if (_usersSplit.Length > 0 && !_usersSplit.Contains(user.Identity.Name, StringComparer.OrdinalIgnoreCase))
            {
                return false;
            }

            if (_rolesSplit.Length > 0 && !_rolesSplit.Any(user.IsInRole))
            {
                return false;
            }

            return true;
        }

        private void CacheValidateHandler(HttpContext context, object data, ref HttpValidationStatus validationStatus)
        {
            validationStatus = OnCacheAuthorization(new HttpContextWrapper(context));
        }

        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            if (OutputCacheAttribute.IsChildActionCacheActive(filterContext))
            {
                // If a child action cache block is active, we need to fail immediately, even if authorization
                // would have succeeded. The reason is that there's no way to hook a callback to rerun
                // authorization before the fragment is served from the cache, so we can't guarantee that this
                // filter will be re-run on subsequent requests.
                throw new InvalidOperationException(MvcResources.AuthorizeAttribute_CannotUseWithinChildActionCache);
            }

            bool skipAuthorization = filterContext.ActionDescriptor.IsDefined(typeof(AllowAnonymousAttribute), inherit: true)
                                     || filterContext.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(AllowAnonymousAttribute), inherit: true);

            if (skipAuthorization)
            {
                return;
            }

            if (AuthorizeCore(filterContext.HttpContext))
            {
                // ** IMPORTANT **
                // Since we're performing authorization at the action level, the authorization code runs
                // after the output caching module. In the worst case this could allow an authorized user
                // to cause the page to be cached, then an unauthorized user would later be served the
                // cached page. We work around this by telling proxies not to cache the sensitive page,
                // then we hook our custom authorization code into the caching mechanism so that we have
                // the final say on whether a page should be served from the cache.

                HttpCachePolicyBase cachePolicy = filterContext.HttpContext.Response.Cache;
                cachePolicy.SetProxyMaxAge(new TimeSpan(0));
                cachePolicy.AddValidationCallback(CacheValidateHandler, null /* data */);
            }
            else
            {
                HandleUnauthorizedRequest(filterContext);
            }
        }

        protected virtual void HandleUnauthorizedRequest(AuthorizationContext filterContext)
        {
            // Returns HTTP 401 - see comment in HttpUnauthorizedResult.cs.
            filterContext.Result = new HttpUnauthorizedResult();
        }

        // This method must be thread-safe since it is called by the caching module.
        protected virtual HttpValidationStatus OnCacheAuthorization(HttpContextBase httpContext)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }

            bool isAuthorized = AuthorizeCore(httpContext);
            return (isAuthorized) ? HttpValidationStatus.Valid : HttpValidationStatus.IgnoreThisRequest;
        }

        internal static string[] SplitString(string original)
        {
            if (String.IsNullOrEmpty(original))
            {
                return new string[0];
            }

            var split = from piece in original.Split(_splitParameter)
                        let trimmed = piece.Trim()
                        where !String.IsNullOrEmpty(trimmed)
                        select trimmed;
            return split.ToArray();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/BindAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter, AllowMultiple = false, Inherited = true)]
    public sealed class BindAttribute : Attribute
    {
        private string _exclude;
        private string[] _excludeSplit = new string[0];
        private string _include;
        private string[] _includeSplit = new string[0];

        public string Exclude
        {
            get { return _exclude ?? String.Empty; }
            set
            {
                _exclude = value;
                _excludeSplit = AuthorizeAttribute.SplitString(value);
            }
        }

        public string Include
        {
            get { return _include ?? String.Empty; }
            set
            {
                _include = value;
                _includeSplit = AuthorizeAttribute.SplitString(value);
            }
        }

        public string Prefix { get; set; }

        internal static bool IsPropertyAllowed(string propertyName, ICollection<string> includeProperties, ICollection<string> excludeProperties)
        {
            // We allow a property to be bound if its both in the include list AND not in the exclude list.
            // An empty include list implies all properties are allowed.
            // An empty exclude list implies no properties are disallowed.
            bool includeProperty = (includeProperties == null) || (includeProperties.Count == 0) || includeProperties.Contains(propertyName, StringComparer.OrdinalIgnoreCase);
            bool excludeProperty = (excludeProperties != null) && excludeProperties.Contains(propertyName, StringComparer.OrdinalIgnoreCase);
            return includeProperty && !excludeProperty;
        }

        public bool IsPropertyAllowed(string propertyName)
        {
            return IsPropertyAllowed(propertyName, _includeSplit, _excludeSplit);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/BuildManagerCompiledView.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public abstract class BuildManagerCompiledView : IView
    {
        internal IViewPageActivator ViewPageActivator;
        private IBuildManager _buildManager;
        private ControllerContext _controllerContext;

        protected BuildManagerCompiledView(ControllerContext controllerContext, string viewPath)
            : this(controllerContext, viewPath, null)
        {
        }

        protected BuildManagerCompiledView(ControllerContext controllerContext, string viewPath, IViewPageActivator viewPageActivator)
            : this(controllerContext, viewPath, viewPageActivator, null)
        {
        }

        internal BuildManagerCompiledView(ControllerContext controllerContext, string viewPath, IViewPageActivator viewPageActivator, IDependencyResolver dependencyResolver)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (String.IsNullOrEmpty(viewPath))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "viewPath");
            }

            _controllerContext = controllerContext;

            ViewPath = viewPath;

            ViewPageActivator = viewPageActivator ?? new BuildManagerViewEngine.DefaultViewPageActivator(dependencyResolver);
        }

        internal IBuildManager BuildManager
        {
            get
            {
                if (_buildManager == null)
                {
                    _buildManager = new BuildManagerWrapper();
                }
                return _buildManager;
            }
            set { _buildManager = value; }
        }

        public string ViewPath { get; protected set; }

        public virtual void Render(ViewContext viewContext, TextWriter writer)
        {
            if (viewContext == null)
            {
                throw new ArgumentNullException("viewContext");
            }

            object instance = null;

            Type type = BuildManager.GetCompiledType(ViewPath);
            if (type != null)
            {
                instance = ViewPageActivator.Create(_controllerContext, type);
            }

            if (instance == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.CshtmlView_ViewCouldNotBeCreated,
                        ViewPath));
            }

            RenderView(viewContext, writer, instance);
        }

        protected abstract void RenderView(ViewContext viewContext, TextWriter writer, object instance);
    }
}


================================================
FILE: src/System.Web.Mvc/BuildManagerViewEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Threading;
using System.Web.Hosting;
using System.Web.WebPages;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Mvc
{
    public abstract class BuildManagerViewEngine : VirtualPathProviderViewEngine
    {
        private static object _isPrecompiledNonUpdateableSiteInitializedLock = new object();
        private static bool _isPrecompiledNonUpdateableSite;
        private static bool _isPrecompiledNonUpdateableSiteInitialized;
        private static FileExistenceCache _sharedFileExistsCache;

        private IBuildManager _buildManager;
        private IViewPageActivator _viewPageActivator;
        private IResolver<IViewPageActivator> _activatorResolver;
        private FileExistenceCache _fileExistsCache;

        protected BuildManagerViewEngine()
            : this(null, null, null, null)
        {
        }

        protected BuildManagerViewEngine(IViewPageActivator viewPageActivator)
            : this(viewPageActivator, null, null, null)
        {
        }

        internal BuildManagerViewEngine(IViewPageActivator viewPageActivator, IResolver<IViewPageActivator> activatorResolver,
            IDependencyResolver dependencyResolver, VirtualPathProvider pathProvider)
        {
            if (viewPageActivator != null)
            {
                _viewPageActivator = viewPageActivator;
            }
            else
            {
                _activatorResolver = activatorResolver ?? new SingleServiceResolver<IViewPageActivator>(
                                                              () => null,
                                                              new DefaultViewPageActivator(dependencyResolver),
                                                              "BuildManagerViewEngine constructor");
            }

            if (pathProvider != null)
            {
                Func<VirtualPathProvider> providerFunc = () => pathProvider;
                _fileExistsCache = new FileExistenceCache(providerFunc);
                VirtualPathProviderFunc = providerFunc;
            }
            else
            {
                if (_sharedFileExistsCache == null)
                {
                    // Startup initialization race is OK providing service remains read-only
                    _sharedFileExistsCache = new FileExistenceCache(() => HostingEnvironment.VirtualPathProvider);
                }

                _fileExistsCache = _sharedFileExistsCache;
            }
        }

        internal IBuildManager BuildManager
        {
            get
            {
                if (_buildManager == null)
                {
                    _buildManager = new BuildManagerWrapper();
                }
                return _buildManager;
            }
            set { _buildManager = value; }
        }

        protected IViewPageActivator ViewPageActivator
        {
            get
            {
                if (_viewPageActivator != null)
                {
                    return _viewPageActivator;
                }
                _viewPageActivator = _activatorResolver.Current;
                return _viewPageActivator;
            }
        }

        protected virtual bool IsPrecompiledNonUpdateableSite
        {
            get
            {
                return LazyInitializer.EnsureInitialized(ref _isPrecompiledNonUpdateableSite,
                                                         ref _isPrecompiledNonUpdateableSiteInitialized,
                                                         ref _isPrecompiledNonUpdateableSiteInitializedLock,
                                                         GetPrecompiledNonUpdateable);
            }
        }

        protected override bool FileExists(ControllerContext controllerContext, string virtualPath)
        {
            // When dealing with non-updateable precompiled views, the view files may not exist on disk. The correct
            // way to check for existence of a file in this case is by querying the BuildManager.
            // For all other scenarios, checking for files on disk is faster and should suffice.
            Contract.Assert(_fileExistsCache != null);
            return _fileExistsCache.FileExists(virtualPath) ||
                   (IsPrecompiledNonUpdateableSite && BuildManager.FileExists(virtualPath));
        }

        private static bool GetPrecompiledNonUpdateable()
        {
            IVirtualPathUtility virtualPathUtility = new VirtualPathUtilityWrapper();
            return WebPages.BuildManagerWrapper.IsNonUpdateablePrecompiledApp(HostingEnvironment.VirtualPathProvider,
                                                                              virtualPathUtility);
        }

        internal class DefaultViewPageActivator : IViewPageActivator
        {
            private Func<IDependencyResolver> _resolverThunk;

            public DefaultViewPageActivator()
                : this(null)
            {
            }

            public DefaultViewPageActivator(IDependencyResolver resolver)
            {
                if (resolver == null)
                {
                    _resolverThunk = () => DependencyResolver.Current;
                }
                else
                {
                    _resolverThunk = () => resolver;
                }
            }

            public object Create(ControllerContext controllerContext, Type type)
            {
                try
                {
                    return _resolverThunk().GetService(type) ?? Activator.CreateInstance(type);
                }
                catch (MissingMethodException exception)
                {
                    // Ensure thrown exception contains the type name.  Might be down a few levels.
                    MissingMethodException replacementException =
                        TypeHelpers.EnsureDebuggableException(exception, type.FullName);
                    if (replacementException != null)
                    {
                        throw replacementException;
                    }

                    throw;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/BuildManagerWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.IO;
using System.Web.Compilation;

namespace System.Web.Mvc
{
    internal sealed class BuildManagerWrapper : IBuildManager
    {
        bool IBuildManager.FileExists(string virtualPath)
        {
            return BuildManager.GetObjectFactory(virtualPath, throwIfNotFound: false) != null;
        }

        Type IBuildManager.GetCompiledType(string virtualPath)
        {
            return BuildManager.GetCompiledType(virtualPath);
        }

        ICollection IBuildManager.GetReferencedAssemblies()
        {
            return BuildManager.GetReferencedAssemblies();
        }

        Stream IBuildManager.ReadCachedFile(string fileName)
        {
            return BuildManager.ReadCachedFile(fileName);
        }

        Stream IBuildManager.CreateCachedFile(string fileName)
        {
            return BuildManager.CreateCachedFile(fileName);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ByteArrayModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ByteArrayModelBinder : IModelBinder
    {
        public virtual object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            if (bindingContext == null)
            {
                throw new ArgumentNullException("bindingContext");
            }

            ValueProviderResult valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);

            // case 1: there was no <input ... /> element containing this data
            if (valueResult == null)
            {
                return null;
            }

            string value = valueResult.AttemptedValue;

            // case 2: there was an <input ... /> element but it was left blank
            if (String.IsNullOrEmpty(value))
            {
                return null;
            }

            // Future proofing. If the byte array is actually an instance of System.Data.Linq.Binary
            // then we need to remove these quotes put in place by the ToString() method.
            string realValue = value.Replace("\"", String.Empty);
            return Convert.FromBase64String(realValue);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CachedAssociatedMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Runtime.Caching;

namespace System.Web.Mvc
{
    public abstract class CachedAssociatedMetadataProvider<TModelMetadata> : AssociatedMetadataProvider
        where TModelMetadata : ModelMetadata
    {
        private static ConcurrentDictionary<Type, string> _typeIds = new ConcurrentDictionary<Type, string>();
        private string _cacheKeyPrefix;
        private CacheItemPolicy _cacheItemPolicy = new CacheItemPolicy { SlidingExpiration = TimeSpan.FromMinutes(20) };
        private ObjectCache _prototypeCache;

        protected internal CacheItemPolicy CacheItemPolicy
        {
            get { return _cacheItemPolicy; }
            set { _cacheItemPolicy = value; }
        }

        protected string CacheKeyPrefix
        {
            get
            {
                if (_cacheKeyPrefix == null)
                {
                    _cacheKeyPrefix = "MetadataPrototypes::" + GetType().GUID.ToString("B");
                }
                return _cacheKeyPrefix;
            }
        }

        protected internal ObjectCache PrototypeCache
        {
            get { return _prototypeCache ?? MemoryCache.Default; }
            set { _prototypeCache = value; }
        }

        protected sealed override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
        {
            // If metadata is being created for a property then containerType != null && propertyName != null
            // If metadata is being created for a type then containerType == null && propertyName == null, so we have to use modelType for the cache key.
            Type typeForCache = containerType ?? modelType;
            string cacheKey = GetCacheKey(typeForCache, propertyName);
            TModelMetadata prototype = PrototypeCache.Get(cacheKey) as TModelMetadata;
            if (prototype == null)
            {
                prototype = CreateMetadataPrototype(attributes, containerType, modelType, propertyName);
                PrototypeCache.Add(cacheKey, prototype, CacheItemPolicy);
            }

            return CreateMetadataFromPrototype(prototype, modelAccessor);
        }

        // New override for creating the prototype metadata (without the accessor)
        protected abstract TModelMetadata CreateMetadataPrototype(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName);

        // New override for applying the prototype + modelAccess to yield the final metadata
        protected abstract TModelMetadata CreateMetadataFromPrototype(TModelMetadata prototype, Func<object> modelAccessor);

        internal string GetCacheKey(Type type, string propertyName = null)
        {
            propertyName = propertyName ?? String.Empty;
            return CacheKeyPrefix + GetTypeId(type) + propertyName;
        }

        public sealed override ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, string propertyName)
        {
            return base.GetMetadataForProperty(modelAccessor, containerType, propertyName);
        }

        protected sealed override ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, PropertyDescriptor propertyDescriptor)
        {
            return base.GetMetadataForProperty(modelAccessor, containerType, propertyDescriptor);
        }

        public sealed override IEnumerable<ModelMetadata> GetMetadataForProperties(object container, Type containerType)
        {
            return base.GetMetadataForProperties(container, containerType);
        }

        public sealed override ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType)
        {
            return base.GetMetadataForType(modelAccessor, modelType);
        }

        private static string GetTypeId(Type type)
        {
            // It's fine using a random Guid since we store the mapping for types to guids.
            return _typeIds.GetOrAdd(type, _ => Guid.NewGuid().ToString("B"));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CachedDataAnnotationsMetadataAttributes.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;

namespace System.Web.Mvc
{
    public class CachedDataAnnotationsMetadataAttributes
    {
        public CachedDataAnnotationsMetadataAttributes(Attribute[] attributes)
        {
            DataType = attributes.OfType<DataTypeAttribute>().FirstOrDefault();
            Display = attributes.OfType<DisplayAttribute>().FirstOrDefault();
            DisplayColumn = attributes.OfType<DisplayColumnAttribute>().FirstOrDefault();
            DisplayFormat = attributes.OfType<DisplayFormatAttribute>().FirstOrDefault();
            DisplayName = attributes.OfType<DisplayNameAttribute>().FirstOrDefault();
            Editable = attributes.OfType<EditableAttribute>().FirstOrDefault();
            HiddenInput = attributes.OfType<HiddenInputAttribute>().FirstOrDefault();
            ReadOnly = attributes.OfType<ReadOnlyAttribute>().FirstOrDefault();
            Required = attributes.OfType<RequiredAttribute>().FirstOrDefault();
            ScaffoldColumn = attributes.OfType<ScaffoldColumnAttribute>().FirstOrDefault();

            var uiHintAttributes = attributes.OfType<UIHintAttribute>();
            UIHint = uiHintAttributes.FirstOrDefault(a => String.Equals(a.PresentationLayer, "MVC", StringComparison.OrdinalIgnoreCase))
                     ?? uiHintAttributes.FirstOrDefault(a => String.IsNullOrEmpty(a.PresentationLayer));

            if (DisplayFormat == null && DataType != null)
            {
                DisplayFormat = DataType.DisplayFormat;
            }
        }

        public DataTypeAttribute DataType { get; protected set; }

        public DisplayAttribute Display { get; protected set; }

        public DisplayColumnAttribute DisplayColumn { get; protected set; }

        public DisplayFormatAttribute DisplayFormat { get; protected set; }

        public DisplayNameAttribute DisplayName { get; protected set; }

        public EditableAttribute Editable { get; protected set; }

        public HiddenInputAttribute HiddenInput { get; protected set; }

        public ReadOnlyAttribute ReadOnly { get; protected set; }

        public RequiredAttribute Required { get; protected set; }

        public ScaffoldColumnAttribute ScaffoldColumn { get; protected set; }

        public UIHintAttribute UIHint { get; protected set; }
    }
}


================================================
FILE: src/System.Web.Mvc/CachedDataAnnotationsModelMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class CachedDataAnnotationsModelMetadata : CachedModelMetadata<CachedDataAnnotationsMetadataAttributes>
    {
        private bool _isEditFormatStringFromCache;

        public CachedDataAnnotationsModelMetadata(CachedDataAnnotationsModelMetadata prototype, Func<object> modelAccessor)
            : base(prototype, modelAccessor)
        {
        }

        public CachedDataAnnotationsModelMetadata(CachedDataAnnotationsModelMetadataProvider provider, Type containerType, Type modelType, string propertyName, IEnumerable<Attribute> attributes)
            : base(provider, containerType, modelType, propertyName, new CachedDataAnnotationsMetadataAttributes(attributes.ToArray()))
        {
        }

        protected override bool ComputeConvertEmptyStringToNull()
        {
            return PrototypeCache.DisplayFormat != null
                       ? PrototypeCache.DisplayFormat.ConvertEmptyStringToNull
                       : base.ComputeConvertEmptyStringToNull();
        }

        protected override string ComputeDataTypeName()
        {
            if (PrototypeCache.DataType != null)
            {
                return PrototypeCache.DataType.ToDataTypeName();
            }

            if (PrototypeCache.DisplayFormat != null && !PrototypeCache.DisplayFormat.HtmlEncode)
            {
                return DataTypeUtil.HtmlTypeName;
            }

            return base.ComputeDataTypeName();
        }

        protected override string ComputeDescription()
        {
            return PrototypeCache.Display != null
                       ? PrototypeCache.Display.GetDescription()
                       : base.ComputeDescription();
        }

        protected override string ComputeDisplayFormatString()
        {
            return PrototypeCache.DisplayFormat != null
                       ? PrototypeCache.DisplayFormat.DataFormatString
                       : base.ComputeDisplayFormatString();
        }

        protected override string ComputeDisplayName()
        {
            string result = null;

            if (PrototypeCache.Display != null)
            {
                result = PrototypeCache.Display.GetName();
            }

            if (result == null && PrototypeCache.DisplayName != null)
            {
                result = PrototypeCache.DisplayName.DisplayName;
            }

            return result ?? base.ComputeDisplayName();
        }

        protected override string ComputeEditFormatString()
        {
            if (PrototypeCache.DisplayFormat != null && PrototypeCache.DisplayFormat.ApplyFormatInEditMode)
            {
                _isEditFormatStringFromCache = true;
                return PrototypeCache.DisplayFormat.DataFormatString;
            }

            return base.ComputeEditFormatString();
        }

        protected override bool ComputeHasNonDefaultEditFormat()
        {
            if (!String.IsNullOrEmpty(EditFormatString) && _isEditFormatStringFromCache)
            {
                // Have a non-empty EditFormatString based on [DisplayFormat] from our cache
                if (PrototypeCache.DataType == null)
                {
                    // Attributes include no [DataType]; [DisplayFormat] was applied directly
                    return true;
                }

                if (PrototypeCache.DataType.DisplayFormat != PrototypeCache.DisplayFormat)
                {
                    // Attributes include separate [DataType] and [DisplayFormat]; [DisplayFormat] provided override
                    return true;
                }

                if (PrototypeCache.DataType.GetType() != typeof(DataTypeAttribute))
                {
                    // Attributes include [DisplayFormat] copied from [DataType] and [DataType] was of a subclass.
                    // Assume the [DataType] constructor used the protected DisplayFormat setter to override its
                    // default.  That is derived [DataType] provided override.
                    return true;
                }
            }

            return base.ComputeHasNonDefaultEditFormat();
        }

        protected override bool ComputeHideSurroundingHtml()
        {
            return PrototypeCache.HiddenInput != null
                       ? !PrototypeCache.HiddenInput.DisplayValue
                       : base.ComputeHideSurroundingHtml();
        }

        protected override bool ComputeHtmlEncode()
        {
            return (PrototypeCache.DisplayFormat != null)
                ? PrototypeCache.DisplayFormat.HtmlEncode
                : base.ComputeHtmlEncode();
        }

        protected override bool ComputeIsReadOnly()
        {
            if (PrototypeCache.Editable != null)
            {
                return !PrototypeCache.Editable.AllowEdit;
            }

            if (PrototypeCache.ReadOnly != null)
            {
                return PrototypeCache.ReadOnly.IsReadOnly;
            }

            return base.ComputeIsReadOnly();
        }

        protected override bool ComputeIsRequired()
        {
            return PrototypeCache.Required != null
                       ? true
                       : base.ComputeIsRequired();
        }

        protected override string ComputeNullDisplayText()
        {
            return PrototypeCache.DisplayFormat != null
                       ? PrototypeCache.DisplayFormat.NullDisplayText
                       : base.ComputeNullDisplayText();
        }

        protected override int ComputeOrder()
        {
            int? result = null;

            if (PrototypeCache.Display != null)
            {
                result = PrototypeCache.Display.GetOrder();
            }

            return result ?? base.ComputeOrder();
        }

        protected override string ComputeShortDisplayName()
        {
            return PrototypeCache.Display != null
                       ? PrototypeCache.Display.GetShortName()
                       : base.ComputeShortDisplayName();
        }

        protected override bool ComputeShowForDisplay()
        {
            return PrototypeCache.ScaffoldColumn != null
                       ? PrototypeCache.ScaffoldColumn.Scaffold
                       : base.ComputeShowForDisplay();
        }

        protected override bool ComputeShowForEdit()
        {
            return PrototypeCache.ScaffoldColumn != null
                       ? PrototypeCache.ScaffoldColumn.Scaffold
                       : base.ComputeShowForEdit();
        }

        protected override string ComputeSimpleDisplayText()
        {
            if (Model != null)
            {
                if (PrototypeCache.DisplayColumn != null && !String.IsNullOrEmpty(PrototypeCache.DisplayColumn.DisplayColumn))
                {
                    PropertyInfo displayColumnProperty = ModelType.GetProperty(PrototypeCache.DisplayColumn.DisplayColumn, BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
                    ValidateDisplayColumnAttribute(PrototypeCache.DisplayColumn, displayColumnProperty, ModelType);

                    object simpleDisplayTextValue = displayColumnProperty.GetValue(Model, new object[0]);
                    if (simpleDisplayTextValue != null)
                    {
                        return simpleDisplayTextValue.ToString();
                    }
                }
            }

            return base.ComputeSimpleDisplayText();
        }

        protected override string ComputeTemplateHint()
        {
            if (PrototypeCache.UIHint != null)
            {
                return PrototypeCache.UIHint.UIHint;
            }

            if (PrototypeCache.HiddenInput != null)
            {
                return "HiddenInput";
            }

            return base.ComputeTemplateHint();
        }

        protected override string ComputeWatermark()
        {
            return PrototypeCache.Display != null
                       ? PrototypeCache.Display.GetPrompt()
                       : base.ComputeWatermark();
        }

        private static void ValidateDisplayColumnAttribute(DisplayColumnAttribute displayColumnAttribute, PropertyInfo displayColumnProperty, Type modelType)
        {
            if (displayColumnProperty == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DataAnnotationsModelMetadataProvider_UnknownProperty,
                        modelType.FullName, displayColumnAttribute.DisplayColumn));
            }
            if (displayColumnProperty.GetGetMethod() == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DataAnnotationsModelMetadataProvider_UnreadableProperty,
                        modelType.FullName, displayColumnAttribute.DisplayColumn));
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CachedDataAnnotationsModelMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public class CachedDataAnnotationsModelMetadataProvider : CachedAssociatedMetadataProvider<CachedDataAnnotationsModelMetadata>
    {
        protected override CachedDataAnnotationsModelMetadata CreateMetadataPrototype(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName)
        {
            return new CachedDataAnnotationsModelMetadata(this, containerType, modelType, propertyName, attributes);
        }

        protected override CachedDataAnnotationsModelMetadata CreateMetadataFromPrototype(CachedDataAnnotationsModelMetadata prototype, Func<object> modelAccessor)
        {
            return new CachedDataAnnotationsModelMetadata(prototype, modelAccessor);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CachedModelMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    // This class assumes that model metadata is expensive to create, and allows the user to
    // stash a cache object that can be copied around as a prototype to make creation and
    // computation quicker. It delegates the retrieval of values to getter methods, the results
    // of which are cached on a per-metadata-instance basis.
    //
    // This allows flexible caching strategies: either caching the source of information across
    // instances or caching of the actual information itself, depending on what the developer
    // decides to put into the prototype cache.
    public abstract class CachedModelMetadata<TPrototypeCache> : ModelMetadata
    {
        private bool _convertEmptyStringToNull;
        private string _dataTypeName;
        private string _description;
        private string _displayFormatString;
        private string _displayName;
        private string _editFormatString;
        private bool _hasNonDefaultEditFormat;
        private bool _hideSurroundingHtml;
        private bool _htmlEncode;
        private bool _isReadOnly;
        private bool _isRequired;
        private string _nullDisplayText;
        private int _order;
        private string _shortDisplayName;
        private bool _showForDisplay;
        private bool _showForEdit;
        private string _templateHint;
        private string _watermark;

        private bool _convertEmptyStringToNullComputed;
        private bool _dataTypeNameComputed;
        private bool _descriptionComputed;
        private bool _displayFormatStringComputed;
        private bool _displayNameComputed;
        private bool _editFormatStringComputed;
        private bool _hasNonDefaultEditFormatComputed;
        private bool _hideSurroundingHtmlComputed;
        private bool _htmlEncodeComputed;
        private bool _isReadOnlyComputed;
        private bool _isRequiredComputed;
        private bool _nullDisplayTextComputed;
        private bool _orderComputed;
        private bool _shortDisplayNameComputed;
        private bool _showForDisplayComputed;
        private bool _showForEditComputed;
        private bool _templateHintComputed;
        private bool _watermarkComputed;

        // Constructor for creating real instances of the metadata class based on a prototype
        protected CachedModelMetadata(CachedModelMetadata<TPrototypeCache> prototype, Func<object> modelAccessor)
            : base(prototype.Provider, prototype.ContainerType, modelAccessor, prototype.ModelType, prototype.PropertyName)
        {
            PrototypeCache = prototype.PrototypeCache;
        }

        // Constructor for creating the prototype instances of the metadata class
        protected CachedModelMetadata(CachedDataAnnotationsModelMetadataProvider provider, Type containerType, Type modelType, string propertyName, TPrototypeCache prototypeCache)
            : base(provider, containerType, null /* modelAccessor */, modelType, propertyName)
        {
            PrototypeCache = prototypeCache;
        }

        public sealed override bool ConvertEmptyStringToNull
        {
            get
            {
                if (!_convertEmptyStringToNullComputed)
                {
                    _convertEmptyStringToNull = ComputeConvertEmptyStringToNull();
                    _convertEmptyStringToNullComputed = true;
                }
                return _convertEmptyStringToNull;
            }
            set
            {
                _convertEmptyStringToNull = value;
                _convertEmptyStringToNullComputed = true;
            }
        }

        public sealed override string DataTypeName
        {
            get
            {
                if (!_dataTypeNameComputed)
                {
                    _dataTypeName = ComputeDataTypeName();
                    _dataTypeNameComputed = true;
                }
                return _dataTypeName;
            }
            set
            {
                _dataTypeName = value;
                _dataTypeNameComputed = true;
            }
        }

        public sealed override string Description
        {
            get
            {
                if (!_descriptionComputed)
                {
                    _description = ComputeDescription();
                    _descriptionComputed = true;
                }
                return _description;
            }
            set
            {
                _description = value;
                _descriptionComputed = true;
            }
        }

        public sealed override string DisplayFormatString
        {
            get
            {
                if (!_displayFormatStringComputed)
                {
                    _displayFormatString = ComputeDisplayFormatString();
                    _displayFormatStringComputed = true;
                }
                return _displayFormatString;
            }
            set
            {
                _displayFormatString = value;
                _displayFormatStringComputed = true;
            }
        }

        public sealed override string DisplayName
        {
            get
            {
                if (!_displayNameComputed)
                {
                    _displayName = ComputeDisplayName();
                    _displayNameComputed = true;
                }
                return _displayName;
            }
            set
            {
                _displayName = value;
                _displayNameComputed = true;
            }
        }

        public sealed override string EditFormatString
        {
            get
            {
                if (!_editFormatStringComputed)
                {
                    _editFormatString = ComputeEditFormatString();
                    _editFormatStringComputed = true;
                }
                return _editFormatString;
            }
            set
            {
                _editFormatString = value;
                _editFormatStringComputed = true;
            }
        }

        internal sealed override bool HasNonDefaultEditFormat
        {
            get
            {
                if (!_hasNonDefaultEditFormatComputed)
                {
                    _hasNonDefaultEditFormat = ComputeHasNonDefaultEditFormat();
                    _hasNonDefaultEditFormatComputed = true;
                }

                return _hasNonDefaultEditFormat;
            }
            set
            {
                _hasNonDefaultEditFormat = value;
                _hasNonDefaultEditFormatComputed = true;
            }
        }

        public sealed override bool HideSurroundingHtml
        {
            get
            {
                if (!_hideSurroundingHtmlComputed)
                {
                    _hideSurroundingHtml = ComputeHideSurroundingHtml();
                    _hideSurroundingHtmlComputed = true;
                }
                return _hideSurroundingHtml;
            }
            set
            {
                _hideSurroundingHtml = value;
                _hideSurroundingHtmlComputed = true;
            }
        }

        public sealed override bool HtmlEncode
        {
            get
            {
                if (!_htmlEncodeComputed)
                {
                    _htmlEncode = ComputeHtmlEncode();
                    _htmlEncodeComputed = true;
                }
                return _htmlEncode;
            }
            set
            {
                _htmlEncode = value;
                _htmlEncodeComputed = true;
            }
        }

        public sealed override bool IsReadOnly
        {
            get
            {
                if (!_isReadOnlyComputed)
                {
                    _isReadOnly = ComputeIsReadOnly();
                    _isReadOnlyComputed = true;
                }
                return _isReadOnly;
            }
            set
            {
                _isReadOnly = value;
                _isReadOnlyComputed = true;
            }
        }

        public sealed override bool IsRequired
        {
            get
            {
                if (!_isRequiredComputed)
                {
                    _isRequired = ComputeIsRequired();
                    _isRequiredComputed = true;
                }
                return _isRequired;
            }
            set
            {
                _isRequired = value;
                _isRequiredComputed = true;
            }
        }

        public sealed override string NullDisplayText
        {
            get
            {
                if (!_nullDisplayTextComputed)
                {
                    _nullDisplayText = ComputeNullDisplayText();
                    _nullDisplayTextComputed = true;
                }
                return _nullDisplayText;
            }
            set
            {
                _nullDisplayText = value;
                _nullDisplayTextComputed = true;
            }
        }

        public sealed override int Order
        {
            get
            {
                if (!_orderComputed)
                {
                    _order = ComputeOrder();
                    _orderComputed = true;
                }
                return _order;
            }
            set
            {
                _order = value;
                _orderComputed = true;
            }
        }

        protected TPrototypeCache PrototypeCache { get; set; }

        public sealed override string ShortDisplayName
        {
            get
            {
                if (!_shortDisplayNameComputed)
                {
                    _shortDisplayName = ComputeShortDisplayName();
                    _shortDisplayNameComputed = true;
                }
                return _shortDisplayName;
            }
            set
            {
                _shortDisplayName = value;
                _shortDisplayNameComputed = true;
            }
        }

        public sealed override bool ShowForDisplay
        {
            get
            {
                if (!_showForDisplayComputed)
                {
                    _showForDisplay = ComputeShowForDisplay();
                    _showForDisplayComputed = true;
                }
                return _showForDisplay;
            }
            set
            {
                _showForDisplay = value;
                _showForDisplayComputed = true;
            }
        }

        public sealed override bool ShowForEdit
        {
            get
            {
                if (!_showForEditComputed)
                {
                    _showForEdit = ComputeShowForEdit();
                    _showForEditComputed = true;
                }
                return _showForEdit;
            }
            set
            {
                _showForEdit = value;
                _showForEditComputed = true;
            }
        }

        public sealed override string SimpleDisplayText
        {
            get
            {
                // This is already cached in the base class with an appropriate override available
                return base.SimpleDisplayText;
            }
            set { base.SimpleDisplayText = value; }
        }

        public sealed override string TemplateHint
        {
            get
            {
                if (!_templateHintComputed)
                {
                    _templateHint = ComputeTemplateHint();
                    _templateHintComputed = true;
                }
                return _templateHint;
            }
            set
            {
                _templateHint = value;
                _templateHintComputed = true;
            }
        }

        public sealed override string Watermark
        {
            get
            {
                if (!_watermarkComputed)
                {
                    _watermark = ComputeWatermark();
                    _watermarkComputed = true;
                }
                return _watermark;
            }
            set
            {
                _watermark = value;
                _watermarkComputed = true;
            }
        }

        protected virtual bool ComputeConvertEmptyStringToNull()
        {
            return base.ConvertEmptyStringToNull;
        }

        protected virtual string ComputeDataTypeName()
        {
            return base.DataTypeName;
        }

        protected virtual string ComputeDescription()
        {
            return base.Description;
        }

        protected virtual string ComputeDisplayFormatString()
        {
            return base.DisplayFormatString;
        }

        protected virtual string ComputeDisplayName()
        {
            return base.DisplayName;
        }

        protected virtual string ComputeEditFormatString()
        {
            return base.EditFormatString;
        }

        protected virtual bool ComputeHasNonDefaultEditFormat()
        {
            return base.HasNonDefaultEditFormat;
        }

        protected virtual bool ComputeHideSurroundingHtml()
        {
            return base.HideSurroundingHtml;
        }

        protected virtual bool ComputeHtmlEncode()
        {
            return base.HtmlEncode;
        }

        protected virtual bool ComputeIsReadOnly()
        {
            return base.IsReadOnly;
        }

        protected virtual bool ComputeIsRequired()
        {
            return base.IsRequired;
        }

        protected virtual string ComputeNullDisplayText()
        {
            return base.NullDisplayText;
        }

        protected virtual int ComputeOrder()
        {
            return base.Order;
        }

        protected virtual string ComputeShortDisplayName()
        {
            return base.ShortDisplayName;
        }

        protected virtual bool ComputeShowForDisplay()
        {
            return base.ShowForDisplay;
        }

        protected virtual bool ComputeShowForEdit()
        {
            return base.ShowForEdit;
        }

        protected virtual string ComputeSimpleDisplayText()
        {
            return base.GetSimpleDisplayText();
        }

        protected virtual string ComputeTemplateHint()
        {
            return base.TemplateHint;
        }

        protected virtual string ComputeWatermark()
        {
            return base.Watermark;
        }

        protected sealed override string GetSimpleDisplayText()
        {
            // Rename for consistency
            return ComputeSimpleDisplayText();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CancellationTokenModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc
{
    public class CancellationTokenModelBinder : IModelBinder
    {
        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            return default(CancellationToken);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ChildActionOnlyAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class ChildActionOnlyAttribute : FilterAttribute, IAuthorizationFilter
    {
        public void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            if (!filterContext.IsChildAction)
            {
                throw Error.ChildActionOnlyAttribute_MustBeInChildRequest(filterContext.ActionDescriptor);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ChildActionValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;

namespace System.Web.Mvc
{
    public sealed class ChildActionValueProvider : DictionaryValueProvider<object>
    {
        private static string _childActionValuesKey = Guid.NewGuid().ToString();

        public ChildActionValueProvider(ControllerContext controllerContext)
            : base(controllerContext.RouteData.Values, CultureInfo.InvariantCulture)
        {
        }

        internal static string ChildActionValuesKey
        {
            get { return _childActionValuesKey; }
        }

        public override ValueProviderResult GetValue(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            ValueProviderResult explicitValues = base.GetValue(ChildActionValuesKey);
            if (explicitValues != null)
            {
                DictionaryValueProvider<object> rawExplicitValues = explicitValues.RawValue as DictionaryValueProvider<object>;
                if (rawExplicitValues != null)
                {
                    return rawExplicitValues.GetValue(key);
                }
            }

            return null;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ChildActionValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public sealed class ChildActionValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            return new ChildActionValueProvider(controllerContext);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ClientDataTypeModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ClientDataTypeModelValidatorProvider : ModelValidatorProvider
    {
        private static readonly HashSet<Type> _numericTypes = new HashSet<Type>(new Type[]
        {
            typeof(byte), typeof(sbyte),
            typeof(short), typeof(ushort),
            typeof(int), typeof(uint),
            typeof(long), typeof(ulong),
            typeof(float), typeof(double), typeof(decimal)
        });

        private static string _resourceClassKey;

        public static string ResourceClassKey
        {
            get { return _resourceClassKey ?? String.Empty; }
            set { _resourceClassKey = value; }
        }

        public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            return GetValidatorsImpl(metadata, context);
        }

        private static IEnumerable<ModelValidator> GetValidatorsImpl(ModelMetadata metadata, ControllerContext context)
        {
            Type type = metadata.ModelType;

            if (IsDateTimeType(type, metadata))
            {
                yield return new DateModelValidator(metadata, context);
            }

            if (IsNumericType(type))
            {
                yield return new NumericModelValidator(metadata, context);
            }
        }

        private static bool IsNumericType(Type type)
        {
            return _numericTypes.Contains(GetTypeToValidate(type));
        }

        private static bool IsDateTimeType(Type type, ModelMetadata metadata)
        {
            return typeof(DateTime) == GetTypeToValidate(type)
                && !String.Equals(metadata.DataTypeName, "Time", StringComparison.OrdinalIgnoreCase);
        }

        private static Type GetTypeToValidate(Type type)
        {
            return Nullable.GetUnderlyingType(type) ?? type; // strip off the Nullable<>
        }

        // If the user specified a ResourceClassKey try to load the resource they specified.
        // If the class key is invalid, an exception will be thrown.
        // If the class key is valid but the resource is not found, it returns null, in which
        // case it will fall back to the MVC default error message.
        private static string GetUserResourceString(ControllerContext controllerContext, string resourceName)
        {
            string result = null;

            if (!String.IsNullOrEmpty(ResourceClassKey) && (controllerContext != null) && (controllerContext.HttpContext != null))
            {
                result = controllerContext.HttpContext.GetGlobalResourceObject(ResourceClassKey, resourceName, CultureInfo.CurrentUICulture) as string;
            }

            return result;
        }

        private static string GetFieldMustBeNumericResource(ControllerContext controllerContext)
        {
            return GetUserResourceString(controllerContext, "FieldMustBeNumeric") ?? MvcResources.ClientDataTypeModelValidatorProvider_FieldMustBeNumeric;
        }

        private static string GetFieldMustBeDateResource(ControllerContext controllerContext)
        {
            return GetUserResourceString(controllerContext, "FieldMustBeDate") ?? MvcResources.ClientDataTypeModelValidatorProvider_FieldMustBeDate;
        }

        internal class ClientModelValidator : ModelValidator
        {
            private string _errorMessage;
            private string _validationType;

            public ClientModelValidator(ModelMetadata metadata, ControllerContext controllerContext, string validationType, string errorMessage)
                : base(metadata, controllerContext)
            {
                if (String.IsNullOrEmpty(validationType))
                {
                    throw new ArgumentException(MvcResources.Common_NullOrEmpty, "validationType");
                }

                if (String.IsNullOrEmpty(errorMessage))
                {
                    throw new ArgumentException(MvcResources.Common_NullOrEmpty, "errorMessage");
                }

                _validationType = validationType;
                _errorMessage = errorMessage;
            }

            public sealed override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
            {
                ModelClientValidationRule rule = new ModelClientValidationRule()
                {
                    ValidationType = _validationType,
                    ErrorMessage = FormatErrorMessage(Metadata.GetDisplayName())
                };

                return new ModelClientValidationRule[] { rule };
            }

            private string FormatErrorMessage(string displayName)
            {
                // use CurrentCulture since this message is intended for the site visitor
                return String.Format(CultureInfo.CurrentCulture, _errorMessage, displayName);
            }

            public sealed override IEnumerable<ModelValidationResult> Validate(object container)
            {
                // this is not a server-side validator
                return Enumerable.Empty<ModelValidationResult>();
            }
        }

        internal sealed class DateModelValidator : ClientModelValidator
        {
            public DateModelValidator(ModelMetadata metadata, ControllerContext controllerContext)
                : base(metadata, controllerContext, "date", GetFieldMustBeDateResource(controllerContext))
            {
            }
        }

        internal sealed class NumericModelValidator : ClientModelValidator
        {
            public NumericModelValidator(ModelMetadata metadata, ControllerContext controllerContext)
                : base(metadata, controllerContext, "number", GetFieldMustBeNumericResource(controllerContext))
            {
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CompareAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [Obsolete("The recommended alternative is to use the System.ComponentModel.DataAnnotations.CompareAttribute type, which has the same functionality as this type.")]
    [AttributeUsage(AttributeTargets.Property)]
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This attribute is designed to be a base class for other attributes.")]
    public class CompareAttribute : ValidationAttribute, IClientValidatable
    {
        public CompareAttribute(string otherProperty)
            : base(MvcResources.CompareAttribute_MustMatch)
        {
            if (otherProperty == null)
            {
                throw new ArgumentNullException("otherProperty");
            }
            OtherProperty = otherProperty;
        }

        public string OtherProperty { get; private set; }

        public string OtherPropertyDisplayName { get; internal set; }

        public override string FormatErrorMessage(string name)
        {
            return String.Format(CultureInfo.CurrentCulture, ErrorMessageString, name, OtherPropertyDisplayName ?? OtherProperty);
        }

        protected override ValidationResult IsValid(object value, ValidationContext validationContext)
        {
            PropertyInfo otherPropertyInfo = validationContext.ObjectType.GetProperty(OtherProperty);
            if (otherPropertyInfo == null)
            {
                return new ValidationResult(String.Format(CultureInfo.CurrentCulture, MvcResources.CompareAttribute_UnknownProperty, OtherProperty));
            }

            object otherPropertyValue = otherPropertyInfo.GetValue(validationContext.ObjectInstance, null);
            if (!Equals(value, otherPropertyValue))
            {
                if (OtherPropertyDisplayName == null)
                {
                    OtherPropertyDisplayName = ModelMetadataProviders.Current.GetMetadataForProperty(() => validationContext.ObjectInstance, validationContext.ObjectType, OtherProperty).GetDisplayName();
                }
                return new ValidationResult(FormatErrorMessage(validationContext.DisplayName));
            }
            return null;
        }

        public static string FormatPropertyForClientValidation(string property)
        {
            if (property == null)
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "property");
            }
            return "*." + property;
        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            if (metadata.ContainerType != null)
            {
                if (OtherPropertyDisplayName == null)
                {
                    OtherPropertyDisplayName = ModelMetadataProviders.Current.GetMetadataForProperty(() => metadata.Model, metadata.ContainerType, OtherProperty).GetDisplayName();
                }
            }
            yield return new ModelClientValidationEqualToRule(FormatErrorMessage(metadata.GetDisplayName()), FormatPropertyForClientValidation(OtherProperty));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CompareAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Globalization;
using DataAnnotationsCompareAttribute = System.ComponentModel.DataAnnotations.CompareAttribute;

namespace System.Web.Mvc
{
    internal class CompareAttributeAdapter : DataAnnotationsModelValidator<DataAnnotationsCompareAttribute>
    {
        public CompareAttributeAdapter(ModelMetadata metadata, ControllerContext context, DataAnnotationsCompareAttribute attribute)
            : base(metadata, context, new CompareAttributeWrapper(attribute, metadata))
        {
            Contract.Assert(attribute.GetType() == typeof(DataAnnotationsCompareAttribute));
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            yield return new ModelClientValidationEqualToRule(ErrorMessage, FormatPropertyForClientValidation(Attribute.OtherProperty));
        }

        private static string FormatPropertyForClientValidation(string property)
        {
            Contract.Assert(property != null);

            return "*." + property;
        }

        // Wrapper for CompareAttribute that will eagerly get the OtherPropertyDisplayName and use it on the error message for client validation.
        // The System.ComponentModel.DataAnnotations.CompareAttribute doesn't populate the OtherPropertyDisplayName until after IsValid() 
        // is called. Therefore, by the time we get the error message for client validation, the display name is not populated and won't be used.
        private sealed class CompareAttributeWrapper : DataAnnotationsCompareAttribute
        {
            private readonly string _otherPropertyDisplayName;

            public CompareAttributeWrapper(DataAnnotationsCompareAttribute attribute, ModelMetadata metadata)
                : base(attribute.OtherProperty)
            {
                _otherPropertyDisplayName = attribute.OtherPropertyDisplayName;
                if (_otherPropertyDisplayName == null && metadata.ContainerType != null)
                {
                    _otherPropertyDisplayName = ModelMetadataProviders.Current.GetMetadataForProperty(() => metadata.Model, metadata.ContainerType, attribute.OtherProperty).GetDisplayName();
                }

                if (_otherPropertyDisplayName == null)
                {
                    _otherPropertyDisplayName = attribute.OtherProperty;
                }

                // Copy settable properties from wrapped attribute. Don't reset default message accessor (set as
                // CompareAttribute constructor calls ValidationAttribute constructor) when all properties are null to
                // preserve default error message. Reset the message accessor when just ErrorMessageResourceType is
                // non-null to ensure correct InvalidOperationException.
                if (!String.IsNullOrEmpty(attribute.ErrorMessage) ||
                    !String.IsNullOrEmpty(attribute.ErrorMessageResourceName) ||
                    attribute.ErrorMessageResourceType != null)
                {
                    ErrorMessage = attribute.ErrorMessage;
                    ErrorMessageResourceName = attribute.ErrorMessageResourceName;
                    ErrorMessageResourceType = attribute.ErrorMessageResourceType;
                }
            }

            public override string FormatErrorMessage(string name)
            {
                return String.Format(CultureInfo.CurrentCulture, ErrorMessageString, name, _otherPropertyDisplayName);
            }
        }
    }
}

================================================
FILE: src/System.Web.Mvc/ContentResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text;

namespace System.Web.Mvc
{
    public class ContentResult : ActionResult
    {
        public string Content { get; set; }

        public Encoding ContentEncoding { get; set; }

        public string ContentType { get; set; }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpResponseBase response = context.HttpContext.Response;

            if (!String.IsNullOrEmpty(ContentType))
            {
                response.ContentType = ContentType;
            }
            if (ContentEncoding != null)
            {
                response.ContentEncoding = ContentEncoding;
            }
            if (Content != null)
            {
                response.Write(Content);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Controller.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.IO;
using System.Security.Principal;
using System.Text;
using System.Web.Mvc.Async;
using System.Web.Mvc.Filters;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;
using System.Web.Profile;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Class complexity dictated by public surface area")]
    public abstract class Controller : ControllerBase, IActionFilter, IAuthenticationFilter, IAuthorizationFilter, IDisposable, IExceptionFilter, IResultFilter, IAsyncController, IAsyncManagerContainer
    {
        private static readonly object _executeTag = new object();
        private static readonly object _executeCoreTag = new object();

        private readonly AsyncManager _asyncManager = new AsyncManager();
        private IActionInvoker _actionInvoker;
        private ModelBinderDictionary _binders;
        private RouteCollection _routeCollection;
        private ITempDataProvider _tempDataProvider;
        private ViewEngineCollection _viewEngineCollection;

        private IDependencyResolver _resolver;

        /// <summary>
        /// Represents a replaceable dependency resolver providing services.
        /// By default, it uses the <see cref="DependencyResolver.CurrentCache"/>. 
        /// </summary>
        public IDependencyResolver Resolver
        {
            get { return _resolver ?? DependencyResolver.CurrentCache; }
            set { _resolver = value; }
        }

        public AsyncManager AsyncManager
        {
            get { return _asyncManager; }
        }

        /// <summary>
        /// This is for backwards compat. MVC 4.0 starts allowing Controller to support asynchronous patterns.
        /// This means ExecuteCore doesn't get called on derived classes. Derived classes can override this
        /// flag and set to true if they still need ExecuteCore to be called.
        /// </summary>
        protected virtual bool DisableAsyncSupport
        {
            get { return false; }
        }

        public IActionInvoker ActionInvoker
        {
            get
            {
                if (_actionInvoker == null)
                {
                    _actionInvoker = CreateActionInvoker();
                }
                return _actionInvoker;
            }
            set { _actionInvoker = value; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "Property is settable so that the dictionary can be provided for unit testing purposes.")]
        protected internal ModelBinderDictionary Binders
        {
            get
            {
                if (_binders == null)
                {
                    _binders = ModelBinders.Binders;
                }
                return _binders;
            }
            set { _binders = value; }
        }

        public HttpContextBase HttpContext
        {
            get { return ControllerContext == null ? null : ControllerContext.HttpContext; }
        }

        public ModelStateDictionary ModelState
        {
            get { return ViewData.ModelState; }
        }

        public ProfileBase Profile
        {
            get { return HttpContext == null ? null : HttpContext.Profile; }
        }

        public HttpRequestBase Request
        {
            get { return HttpContext == null ? null : HttpContext.Request; }
        }

        public HttpResponseBase Response
        {
            get { return HttpContext == null ? null : HttpContext.Response; }
        }

        internal RouteCollection RouteCollection
        {
            get
            {
                if (_routeCollection == null)
                {
                    _routeCollection = RouteTable.Routes;
                }
                return _routeCollection;
            }
            set { _routeCollection = value; }
        }

        public RouteData RouteData
        {
            get { return ControllerContext == null ? null : ControllerContext.RouteData; }
        }

        public HttpServerUtilityBase Server
        {
            get { return HttpContext == null ? null : HttpContext.Server; }
        }

        public HttpSessionStateBase Session
        {
            get { return HttpContext == null ? null : HttpContext.Session; }
        }

        public ITempDataProvider TempDataProvider
        {
            get
            {
                if (_tempDataProvider == null)
                {
                    _tempDataProvider = CreateTempDataProvider();
                }
                return _tempDataProvider;
            }
            set { _tempDataProvider = value; }
        }

        public UrlHelper Url { get; set; }

        public IPrincipal User
        {
            get { return HttpContext == null ? null : HttpContext.User; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This entire type is meant to be mutable.")]
        public ViewEngineCollection ViewEngineCollection
        {
            get { return _viewEngineCollection ?? ViewEngines.Engines; }
            set { _viewEngineCollection = value; }
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", MessageId = "0#", Justification = "'Content' refers to ContentResult type; 'content' refers to ContentResult.Content property.")]
        protected internal ContentResult Content(string content)
        {
            return Content(content, null /* contentType */);
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", MessageId = "0#", Justification = "'Content' refers to ContentResult type; 'content' refers to ContentResult.Content property.")]
        protected internal ContentResult Content(string content, string contentType)
        {
            return Content(content, contentType, null /* contentEncoding */);
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", MessageId = "0#", Justification = "'Content' refers to ContentResult type; 'content' refers to ContentResult.Content property.")]
        protected internal virtual ContentResult Content(string content, string contentType, Encoding contentEncoding)
        {
            return new ContentResult
            {
                Content = content,
                ContentType = contentType,
                ContentEncoding = contentEncoding
            };
        }

        protected virtual IActionInvoker CreateActionInvoker()
        {
            // Controller supports asynchronous operations by default. 
            // Those factories can be customized in order to create an action invoker for each request.
            IAsyncActionInvokerFactory asyncActionInvokerFactory = Resolver.GetService<IAsyncActionInvokerFactory>();
            if (asyncActionInvokerFactory != null)
            {
                return asyncActionInvokerFactory.CreateInstance();
            }
            IActionInvokerFactory actionInvokerFactory = Resolver.GetService<IActionInvokerFactory>();
            if (actionInvokerFactory != null)
            {
                return actionInvokerFactory.CreateInstance();
            }

            // Note that getting a service from the current cache will return the same instance for every request.
            return Resolver.GetService<IAsyncActionInvoker>() ??
                Resolver.GetService<IActionInvoker>() ??
                new AsyncControllerActionInvoker();
        }

        protected virtual ITempDataProvider CreateTempDataProvider()
        {
            // The factory can be customized in order to create an ITempDataProvider for the controller.
            ITempDataProviderFactory tempDataProviderFactory = Resolver.GetService<ITempDataProviderFactory>();
            if (tempDataProviderFactory != null)
            {
                return tempDataProviderFactory.CreateInstance();
            }

            // Note that getting a service from the current cache will return the same instance for every controller.
            return Resolver.GetService<ITempDataProvider>() ?? new SessionStateTempDataProvider();
        }

        // The default invoker will never match methods defined on the Controller type, so
        // the Dispose() method is not web-callable.  However, in general, since implicitly-
        // implemented interface methods are public, they are web-callable unless decorated with
        // [NonAction].
        public void Dispose()
        {
            Dispose(true /* disposing */);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
        }

        protected override void ExecuteCore()
        {
            // If code in this method needs to be updated, please also check the BeginExecuteCore() and
            // EndExecuteCore() methods of AsyncController to see if that code also must be updated.

            PossiblyLoadTempData();
            try
            {
                string actionName = GetActionName(RouteData);
                if (!ActionInvoker.InvokeAction(ControllerContext, actionName))
                {
                    HandleUnknownAction(actionName);
                }
            }
            finally
            {
                PossiblySaveTempData();
            }
        }

        protected internal FileContentResult File(byte[] fileContents, string contentType)
        {
            return File(fileContents, contentType, null /* fileDownloadName */);
        }

        protected internal virtual FileContentResult File(byte[] fileContents, string contentType, string fileDownloadName)
        {
            return new FileContentResult(fileContents, contentType) { FileDownloadName = fileDownloadName };
        }

        protected internal FileStreamResult File(Stream fileStream, string contentType)
        {
            return File(fileStream, contentType, null /* fileDownloadName */);
        }

        protected internal virtual FileStreamResult File(Stream fileStream, string contentType, string fileDownloadName)
        {
            return new FileStreamResult(fileStream, contentType) { FileDownloadName = fileDownloadName };
        }

        protected internal FilePathResult File(string fileName, string contentType)
        {
            return File(fileName, contentType, null /* fileDownloadName */);
        }

        protected internal virtual FilePathResult File(string fileName, string contentType, string fileDownloadName)
        {
            return new FilePathResult(fileName, contentType) { FileDownloadName = fileDownloadName };
        }

        private static string GetActionName(RouteData routeData)
        {
            Contract.Assert(routeData != null);

            // If this is an attribute routing match then the 'RouteData' has a list of sub-matches rather than
            // the traditional controller and action values. When the match is an attribute routing match
            // we'll pass null to the action selector, and let it choose a sub-match to use.
            if (routeData.HasDirectRouteMatch())
            {
                return null;
            }
            else
            {
                return routeData.GetRequiredString("action");
            }
        }

        protected virtual void HandleUnknownAction(string actionName)
        {
            // If this is a direct route we might not yet have an action name
            if (String.IsNullOrEmpty(actionName))
            {
                throw new HttpException(404, String.Format(CultureInfo.CurrentCulture,
                                           MvcResources.Controller_UnknownAction_NoActionName, GetType().FullName));
            }
            else
            {
                throw new HttpException(404, String.Format(CultureInfo.CurrentCulture,
                                                           MvcResources.Controller_UnknownAction, actionName, GetType().FullName));
            }
        }

        protected internal HttpNotFoundResult HttpNotFound()
        {
            return HttpNotFound(null);
        }

        protected internal virtual HttpNotFoundResult HttpNotFound(string statusDescription)
        {
            return new HttpNotFoundResult(statusDescription);
        }

        protected internal virtual JavaScriptResult JavaScript(string script)
        {
            return new JavaScriptResult { Script = script };
        }

        protected internal JsonResult Json(object data)
        {
            return Json(data, null /* contentType */, null /* contentEncoding */, JsonRequestBehavior.DenyGet);
        }

        protected internal JsonResult Json(object data, string contentType)
        {
            return Json(data, contentType, null /* contentEncoding */, JsonRequestBehavior.DenyGet);
        }

        protected internal virtual JsonResult Json(object data, string contentType, Encoding contentEncoding)
        {
            return Json(data, contentType, contentEncoding, JsonRequestBehavior.DenyGet);
        }

        protected internal JsonResult Json(object data, JsonRequestBehavior behavior)
        {
            return Json(data, null /* contentType */, null /* contentEncoding */, behavior);
        }

        protected internal JsonResult Json(object data, string contentType, JsonRequestBehavior behavior)
        {
            return Json(data, contentType, null /* contentEncoding */, behavior);
        }

        protected internal virtual JsonResult Json(object data, string contentType, Encoding contentEncoding, JsonRequestBehavior behavior)
        {
            return new JsonResult
            {
                Data = data,
                ContentType = contentType,
                ContentEncoding = contentEncoding,
                JsonRequestBehavior = behavior
            };
        }

        protected override void Initialize(RequestContext requestContext)
        {
            base.Initialize(requestContext);
            Url = new UrlHelper(requestContext);
        }

        protected virtual void OnActionExecuting(ActionExecutingContext filterContext)
        {
        }

        protected virtual void OnActionExecuted(ActionExecutedContext filterContext)
        {
        }

        protected virtual void OnAuthentication(AuthenticationContext filterContext)
        {
        }

        protected virtual void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext)
        {
        }

        protected virtual void OnAuthorization(AuthorizationContext filterContext)
        {
        }

        protected virtual void OnException(ExceptionContext filterContext)
        {
        }

        protected virtual void OnResultExecuted(ResultExecutedContext filterContext)
        {
        }

        protected virtual void OnResultExecuting(ResultExecutingContext filterContext)
        {
        }

        protected internal PartialViewResult PartialView()
        {
            return PartialView(null /* viewName */, null /* model */);
        }

        protected internal PartialViewResult PartialView(object model)
        {
            return PartialView(null /* viewName */, model);
        }

        protected internal PartialViewResult PartialView(string viewName)
        {
            return PartialView(viewName, null /* model */);
        }

        protected internal virtual PartialViewResult PartialView(string viewName, object model)
        {
            if (model != null)
            {
                ViewData.Model = model;
            }

            return new PartialViewResult
            {
                ViewName = viewName,
                ViewData = ViewData,
                TempData = TempData,
                ViewEngineCollection = ViewEngineCollection
            };
        }

        internal void PossiblyLoadTempData()
        {
            if (!ControllerContext.IsChildAction)
            {
                TempData.Load(ControllerContext, TempDataProvider);
            }
        }

        internal void PossiblySaveTempData()
        {
            if (!ControllerContext.IsChildAction)
            {
                TempData.Save(ControllerContext, TempDataProvider);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "Response.Redirect() takes its URI as a string parameter.")]
        protected internal virtual RedirectResult Redirect(string url)
        {
            if (String.IsNullOrEmpty(url))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "url");
            }

            return new RedirectResult(url);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "Response.RedirectPermanent() takes its URI as a string parameter.")]
        protected internal virtual RedirectResult RedirectPermanent(string url)
        {
            if (String.IsNullOrEmpty(url))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "url");
            }

            return new RedirectResult(url, permanent: true);
        }

        protected internal RedirectToRouteResult RedirectToAction(string actionName)
        {
            return RedirectToAction(actionName, (RouteValueDictionary)null);
        }

        protected internal RedirectToRouteResult RedirectToAction(string actionName, object routeValues)
        {
            return RedirectToAction(actionName, TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal RedirectToRouteResult RedirectToAction(string actionName, RouteValueDictionary routeValues)
        {
            return RedirectToAction(actionName, null /* controllerName */, routeValues);
        }

        protected internal RedirectToRouteResult RedirectToAction(string actionName, string controllerName)
        {
            return RedirectToAction(actionName, controllerName, (RouteValueDictionary)null);
        }

        protected internal RedirectToRouteResult RedirectToAction(string actionName, string controllerName, object routeValues)
        {
            return RedirectToAction(actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal virtual RedirectToRouteResult RedirectToAction(string actionName, string controllerName, RouteValueDictionary routeValues)
        {
            RouteValueDictionary mergedRouteValues;

            if (RouteData == null)
            {
                mergedRouteValues = RouteValuesHelpers.MergeRouteValues(actionName, controllerName, null, routeValues, includeImplicitMvcValues: true);
            }
            else
            {
                mergedRouteValues = RouteValuesHelpers.MergeRouteValues(actionName, controllerName, RouteData.Values, routeValues, includeImplicitMvcValues: true);
            }

            return new RedirectToRouteResult(mergedRouteValues);
        }

        protected internal RedirectToRouteResult RedirectToActionPermanent(string actionName)
        {
            return RedirectToActionPermanent(actionName, (RouteValueDictionary)null);
        }

        protected internal RedirectToRouteResult RedirectToActionPermanent(string actionName, object routeValues)
        {
            return RedirectToActionPermanent(actionName, TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal RedirectToRouteResult RedirectToActionPermanent(string actionName, RouteValueDictionary routeValues)
        {
            return RedirectToActionPermanent(actionName, null /* controllerName */, routeValues);
        }

        protected internal RedirectToRouteResult RedirectToActionPermanent(string actionName, string controllerName)
        {
            return RedirectToActionPermanent(actionName, controllerName, (RouteValueDictionary)null);
        }

        protected internal RedirectToRouteResult RedirectToActionPermanent(string actionName, string controllerName, object routeValues)
        {
            return RedirectToActionPermanent(actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal virtual RedirectToRouteResult RedirectToActionPermanent(string actionName, string controllerName, RouteValueDictionary routeValues)
        {
            RouteValueDictionary implicitRouteValues = (RouteData != null) ? RouteData.Values : null;

            RouteValueDictionary mergedRouteValues =
                RouteValuesHelpers.MergeRouteValues(actionName, controllerName, implicitRouteValues, routeValues, includeImplicitMvcValues: true);

            return new RedirectToRouteResult(null, mergedRouteValues, permanent: true);
        }

        protected internal RedirectToRouteResult RedirectToRoute(object routeValues)
        {
            return RedirectToRoute(TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal RedirectToRouteResult RedirectToRoute(RouteValueDictionary routeValues)
        {
            return RedirectToRoute(null /* routeName */, routeValues);
        }

        protected internal RedirectToRouteResult RedirectToRoute(string routeName)
        {
            return RedirectToRoute(routeName, (RouteValueDictionary)null);
        }

        protected internal RedirectToRouteResult RedirectToRoute(string routeName, object routeValues)
        {
            return RedirectToRoute(routeName, TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal virtual RedirectToRouteResult RedirectToRoute(string routeName, RouteValueDictionary routeValues)
        {
            return new RedirectToRouteResult(routeName, RouteValuesHelpers.GetRouteValues(routeValues));
        }

        protected internal RedirectToRouteResult RedirectToRoutePermanent(object routeValues)
        {
            return RedirectToRoutePermanent(TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal RedirectToRouteResult RedirectToRoutePermanent(RouteValueDictionary routeValues)
        {
            return RedirectToRoutePermanent(null /* routeName */, routeValues);
        }

        protected internal RedirectToRouteResult RedirectToRoutePermanent(string routeName)
        {
            return RedirectToRoutePermanent(routeName, (RouteValueDictionary)null);
        }

        protected internal RedirectToRouteResult RedirectToRoutePermanent(string routeName, object routeValues)
        {
            return RedirectToRoutePermanent(routeName, TypeHelper.ObjectToDictionary(routeValues));
        }

        protected internal virtual RedirectToRouteResult RedirectToRoutePermanent(string routeName, RouteValueDictionary routeValues)
        {
            return new RedirectToRouteResult(routeName, RouteValuesHelpers.GetRouteValues(routeValues), permanent: true);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model) where TModel : class
        {
            return TryUpdateModel(model, null, null, null, ValueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string prefix) where TModel : class
        {
            return TryUpdateModel(model, prefix, null, null, ValueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string[] includeProperties) where TModel : class
        {
            return TryUpdateModel(model, null, includeProperties, null, ValueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string prefix, string[] includeProperties) where TModel : class
        {
            return TryUpdateModel(model, prefix, includeProperties, null, ValueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, string[] excludeProperties) where TModel : class
        {
            return TryUpdateModel(model, prefix, includeProperties, excludeProperties, ValueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, IValueProvider valueProvider) where TModel : class
        {
            return TryUpdateModel(model, null, null, null, valueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string prefix, IValueProvider valueProvider) where TModel : class
        {
            return TryUpdateModel(model, prefix, null, null, valueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string[] includeProperties, IValueProvider valueProvider) where TModel : class
        {
            return TryUpdateModel(model, null, includeProperties, null, valueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, IValueProvider valueProvider) where TModel : class
        {
            return TryUpdateModel(model, prefix, includeProperties, null, valueProvider);
        }

        protected internal bool TryUpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, string[] excludeProperties, IValueProvider valueProvider) where TModel : class
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }
            if (valueProvider == null)
            {
                throw new ArgumentNullException("valueProvider");
            }

            Predicate<string> propertyFilter = propertyName => BindAttribute.IsPropertyAllowed(propertyName, includeProperties, excludeProperties);
            IModelBinder binder = Binders.GetBinder(typeof(TModel));

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(TModel)),
                ModelName = prefix,
                ModelState = ModelState,
                PropertyFilter = propertyFilter,
                ValueProvider = valueProvider
            };
            binder.BindModel(ControllerContext, bindingContext);
            return ModelState.IsValid;
        }

        protected internal bool TryValidateModel(object model)
        {
            return TryValidateModel(model, null /* prefix */);
        }

        protected internal bool TryValidateModel(object model, string prefix)
        {
            if (model == null)
            {
                throw new ArgumentNullException("model");
            }

            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType());

            foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(metadata, ControllerContext).Validate(null))
            {
                ModelState.AddModelError(DefaultModelBinder.CreateSubPropertyName(prefix, validationResult.MemberName), validationResult.Message);
            }

            return ModelState.IsValid;
        }

        protected internal void UpdateModel<TModel>(TModel model) where TModel : class
        {
            UpdateModel(model, null, null, null, ValueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string prefix) where TModel : class
        {
            UpdateModel(model, prefix, null, null, ValueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string[] includeProperties) where TModel : class
        {
            UpdateModel(model, null, includeProperties, null, ValueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string prefix, string[] includeProperties) where TModel : class
        {
            UpdateModel(model, prefix, includeProperties, null, ValueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, string[] excludeProperties) where TModel : class
        {
            UpdateModel(model, prefix, includeProperties, excludeProperties, ValueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, IValueProvider valueProvider) where TModel : class
        {
            UpdateModel(model, null, null, null, valueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string prefix, IValueProvider valueProvider) where TModel : class
        {
            UpdateModel(model, prefix, null, null, valueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string[] includeProperties, IValueProvider valueProvider) where TModel : class
        {
            UpdateModel(model, null, includeProperties, null, valueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, IValueProvider valueProvider) where TModel : class
        {
            UpdateModel(model, prefix, includeProperties, null, valueProvider);
        }

        protected internal void UpdateModel<TModel>(TModel model, string prefix, string[] includeProperties, string[] excludeProperties, IValueProvider valueProvider) where TModel : class
        {
            bool success = TryUpdateModel(model, prefix, includeProperties, excludeProperties, valueProvider);
            if (!success)
            {
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.Controller_UpdateModel_UpdateUnsuccessful,
                                               typeof(TModel).FullName);
                throw new InvalidOperationException(message);
            }
        }

        protected internal void ValidateModel(object model)
        {
            ValidateModel(model, null /* prefix */);
        }

        protected internal void ValidateModel(object model, string prefix)
        {
            if (!TryValidateModel(model, prefix))
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Controller_Validate_ValidationFailed,
                        model.GetType().FullName));
            }
        }

        protected internal ViewResult View()
        {
            return View(viewName: null, masterName: null, model: null);
        }

        protected internal ViewResult View(object model)
        {
            return View(null /* viewName */, null /* masterName */, model);
        }

        protected internal ViewResult View(string viewName)
        {
            return View(viewName, masterName: null, model: null);
        }

        protected internal ViewResult View(string viewName, string masterName)
        {
            return View(viewName, masterName, null /* model */);
        }

        protected internal ViewResult View(string viewName, object model)
        {
            return View(viewName, null /* masterName */, model);
        }

        protected internal virtual ViewResult View(string viewName, string masterName, object model)
        {
            if (model != null)
            {
                ViewData.Model = model;
            }

            return new ViewResult
            {
                ViewName = viewName,
                MasterName = masterName,
                ViewData = ViewData,
                TempData = TempData,
                ViewEngineCollection = ViewEngineCollection
            };
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", MessageId = "0#", Justification = "The method name 'View' is a convenient shorthand for 'CreateViewResult'.")]
        protected internal ViewResult View(IView view)
        {
            return View(view, null /* model */);
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", MessageId = "0#", Justification = "The method name 'View' is a convenient shorthand for 'CreateViewResult'.")]
        protected internal virtual ViewResult View(IView view, object model)
        {
            if (model != null)
            {
                ViewData.Model = model;
            }

            return new ViewResult
            {
                View = view,
                ViewData = ViewData,
                TempData = TempData
            };
        }

        IAsyncResult IAsyncController.BeginExecute(RequestContext requestContext, AsyncCallback callback, object state)
        {
            return BeginExecute(requestContext, callback, state);
        }

        void IAsyncController.EndExecute(IAsyncResult asyncResult)
        {
            EndExecute(asyncResult);
        }

        protected virtual IAsyncResult BeginExecute(RequestContext requestContext, AsyncCallback callback, object state)
        {
            if (DisableAsyncSupport)
            {
                // For backwards compat, we can disallow async support and just chain to the sync Execute() function.
                Action action = () =>
                {
                    Execute(requestContext);
                };

                return AsyncResultWrapper.BeginSynchronous(callback, state, action, _executeTag);
            }
            else
            {
                if (requestContext == null)
                {
                    throw new ArgumentNullException("requestContext");
                }

                // Support Asynchronous behavior. 
                // Execute/ExecuteCore are no longer called.

                VerifyExecuteCalledOnce();
                Initialize(requestContext);

                // Ensure delegates continue to use the C# Compiler static delegate caching optimization.
                BeginInvokeDelegate<Controller> beginDelegate = (AsyncCallback asyncCallback, object callbackState, Controller controller) =>
                    {
                        return controller.BeginExecuteCore(asyncCallback, callbackState);
                    };
                EndInvokeVoidDelegate<Controller> endDelegate = (IAsyncResult asyncResult, Controller controller) =>
                    {
                        controller.EndExecuteCore(asyncResult);
                    };
                return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, this, _executeTag);
            }
        }

        protected virtual IAsyncResult BeginExecuteCore(AsyncCallback callback, object state)
        {
            // If code in this method needs to be updated, please also check the ExecuteCore() method
            // of Controller to see if that code also must be updated.
            PossiblyLoadTempData();
            try
            {
                string actionName = GetActionName(RouteData);
                IActionInvoker invoker = ActionInvoker;
                IAsyncActionInvoker asyncInvoker = invoker as IAsyncActionInvoker;
                if (asyncInvoker != null)
                {
                    // asynchronous invocation
                    // Ensure delegates continue to use the C# Compiler static delegate caching optimization.
                    BeginInvokeDelegate<ExecuteCoreState> beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState, ExecuteCoreState innerState)
                    {
                        return innerState.AsyncInvoker.BeginInvokeAction(innerState.Controller.ControllerContext, innerState.ActionName, asyncCallback, asyncState);
                    };

                    EndInvokeVoidDelegate<ExecuteCoreState> endDelegate = delegate(IAsyncResult asyncResult, ExecuteCoreState innerState)
                    {
                        if (!innerState.AsyncInvoker.EndInvokeAction(asyncResult))
                        {
                            innerState.Controller.HandleUnknownAction(innerState.ActionName);
                        }
                    };
                    ExecuteCoreState executeState = new ExecuteCoreState() { Controller = this, AsyncInvoker = asyncInvoker, ActionName = actionName };

                    return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, executeState, _executeCoreTag);
                }
                else
                {
                    // synchronous invocation
                    Action action = () =>
                    {
                        if (!invoker.InvokeAction(ControllerContext, actionName))
                        {
                            HandleUnknownAction(actionName);
                        }
                    };
                    return AsyncResultWrapper.BeginSynchronous(callback, state, action, _executeCoreTag);
                }
            }
            catch
            {
                PossiblySaveTempData();
                throw;
            }
        }

        protected virtual void EndExecute(IAsyncResult asyncResult)
        {
            AsyncResultWrapper.End(asyncResult, _executeTag);
        }

        protected virtual void EndExecuteCore(IAsyncResult asyncResult)
        {
            // If code in this method needs to be updated, please also check the ExecuteCore() method
            // of Controller to see if that code also must be updated.

            try
            {
                AsyncResultWrapper.End(asyncResult, _executeCoreTag);
            }
            finally
            {
                PossiblySaveTempData();
            }
        }

        #region IActionFilter Members

        void IActionFilter.OnActionExecuting(ActionExecutingContext filterContext)
        {
            OnActionExecuting(filterContext);
        }

        void IActionFilter.OnActionExecuted(ActionExecutedContext filterContext)
        {
            OnActionExecuted(filterContext);
        }

        #endregion

        #region IAuthenticationFilter Members

        void IAuthenticationFilter.OnAuthentication(AuthenticationContext filterContext)
        {
            OnAuthentication(filterContext);
        }

        void IAuthenticationFilter.OnAuthenticationChallenge(AuthenticationChallengeContext filterContext)
        {
            OnAuthenticationChallenge(filterContext);
        }

        #endregion

        #region IAuthorizationFilter Members

        void IAuthorizationFilter.OnAuthorization(AuthorizationContext filterContext)
        {
            OnAuthorization(filterContext);
        }

        #endregion

        #region IExceptionFilter Members

        void IExceptionFilter.OnException(ExceptionContext filterContext)
        {
            OnException(filterContext);
        }

        #endregion

        #region IResultFilter Members

        void IResultFilter.OnResultExecuting(ResultExecutingContext filterContext)
        {
            OnResultExecuting(filterContext);
        }

        void IResultFilter.OnResultExecuted(ResultExecutedContext filterContext)
        {
            OnResultExecuted(filterContext);
        }

        #endregion

        // Keep as value type to avoid allocating
        private struct ExecuteCoreState
        {
            internal IAsyncActionInvoker AsyncInvoker;
            internal Controller Controller;
            internal string ActionName;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerActionInvoker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Security.Principal;
using System.Threading;
using System.Web.Mvc.Filters;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;
using System.Web.Routing;
using Microsoft.Web.Infrastructure.DynamicValidationHelper;

namespace System.Web.Mvc
{
    [SuppressMessage(
        "Microsoft.Maintainability", 
        "CA1506:AvoidExcessiveClassCoupling",
        Justification = "This class has to work with both traditional and direct routing, which is the cause of the high" +
        "number of classes it uses.")]
    public class ControllerActionInvoker : IActionInvoker
    {
        private static readonly ControllerDescriptorCache _staticDescriptorCache = new ControllerDescriptorCache();

        private ModelBinderDictionary _binders;
        private Func<ControllerContext, ActionDescriptor, IEnumerable<Filter>> _getFiltersThunk = FilterProviders.Providers.GetFilters;
        private ControllerDescriptorCache _instanceDescriptorCache;

        public ControllerActionInvoker()
        {
        }

        internal ControllerActionInvoker(params object[] filters)
            : this()
        {
            if (filters != null)
            {
                _getFiltersThunk = (cc, ad) => filters.Select(f => new Filter(f, FilterScope.Action, null));
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "Property is settable so that the dictionary can be provided for unit testing purposes.")]
        protected internal ModelBinderDictionary Binders
        {
            get
            {
                if (_binders == null)
                {
                    _binders = ModelBinders.Binders;
                }
                return _binders;
            }
            set { _binders = value; }
        }

        internal ControllerDescriptorCache DescriptorCache
        {
            get
            {
                if (_instanceDescriptorCache == null)
                {
                    _instanceDescriptorCache = _staticDescriptorCache;
                }
                return _instanceDescriptorCache;
            }
            set { _instanceDescriptorCache = value; }
        }

        protected virtual ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
        {
            if (actionReturnValue == null)
            {
                return new EmptyResult();
            }

            ActionResult actionResult = (actionReturnValue as ActionResult) ??
                                        new ContentResult { Content = Convert.ToString(actionReturnValue, CultureInfo.InvariantCulture) };
            return actionResult;
        }

        protected virtual ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext)
        {
            // Frequently called, so ensure delegate is static
            Type controllerType = controllerContext.Controller.GetType();
            ControllerDescriptor controllerDescriptor = DescriptorCache.GetDescriptor(
                controllerType: controllerType,
                creator: (Type innerType) => new ReflectedControllerDescriptor(innerType),
                state: controllerType);
            return controllerDescriptor;
        }

        protected virtual ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
        {
            Contract.Assert(controllerContext != null);
            Contract.Assert(controllerContext.RouteData != null);
            Contract.Assert(controllerDescriptor != null);

            if (controllerContext.RouteData.HasDirectRouteMatch())
            {
                List<DirectRouteCandidate> candidates = GetDirectRouteCandidates(controllerContext);

                DirectRouteCandidate bestCandidate = DirectRouteCandidate.SelectBestCandidate(candidates, controllerContext);
                if (bestCandidate == null)
                {
                    return null;
                }
                else
                {
                    // We need to stash the RouteData of the matched route into the context, so it can be
                    // used for binding.
                    controllerContext.RouteData = bestCandidate.RouteData;
                    controllerContext.RequestContext.RouteData = bestCandidate.RouteData;

                    // We need to remove any optional parameters that haven't gotten a value (See MvcHandler)
                    bestCandidate.RouteData.Values.RemoveFromDictionary((entry) => entry.Value == UrlParameter.Optional);

                    return bestCandidate.ActionDescriptor;
                }
            }
            else
            {
                ActionDescriptor actionDescriptor = controllerDescriptor.FindAction(controllerContext, actionName);
                return actionDescriptor;
            }
        }

        private static List<DirectRouteCandidate> GetDirectRouteCandidates(ControllerContext controllerContext)
        {
            Debug.Assert(controllerContext != null);
            Debug.Assert(controllerContext.RouteData != null);

            List<DirectRouteCandidate> candiates = new List<DirectRouteCandidate>();

            RouteData routeData = controllerContext.RouteData;
            foreach (var directRoute in routeData.GetDirectRouteMatches())
            {
                if (directRoute == null)
                {
                    continue;
                }

                ControllerDescriptor controllerDescriptor = directRoute.GetTargetControllerDescriptor();
                if (controllerDescriptor == null)
                {
                    throw new InvalidOperationException(MvcResources.DirectRoute_MissingControllerDescriptor);
                }

                ActionDescriptor[] actionDescriptors = directRoute.GetTargetActionDescriptors();
                if (actionDescriptors == null || actionDescriptors.Length == 0)
                {
                    throw new InvalidOperationException(MvcResources.DirectRoute_MissingActionDescriptors);
                }

                foreach (var actionDescriptor in actionDescriptors)
                {
                    if (actionDescriptor != null)
                    {
                        candiates.Add(new DirectRouteCandidate()
                        {
                            ActionDescriptor = actionDescriptor,
                            ActionNameSelectors = actionDescriptor.GetNameSelectors(),
                            ActionSelectors = actionDescriptor.GetSelectors(),
                            Order = directRoute.GetOrder(),
                            Precedence = directRoute.GetPrecedence(),
                            RouteData = directRoute,
                        });
                    }
                }
            }

            return candiates;
        }

        protected virtual FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            return new FilterInfo(_getFiltersThunk(controllerContext, actionDescriptor));
        }

        private IModelBinder GetModelBinder(ParameterDescriptor parameterDescriptor)
        {
            // look on the parameter itself, then look in the global table
            return parameterDescriptor.BindingInfo.Binder ?? Binders.GetBinder(parameterDescriptor.ParameterType);
        }

        protected virtual object GetParameterValue(ControllerContext controllerContext, ParameterDescriptor parameterDescriptor)
        {
            // collect all of the necessary binding properties
            Type parameterType = parameterDescriptor.ParameterType;
            IModelBinder binder = GetModelBinder(parameterDescriptor);
            IValueProvider valueProvider = controllerContext.Controller.ValueProvider;
            string parameterName = parameterDescriptor.BindingInfo.Prefix ?? parameterDescriptor.ParameterName;
            Predicate<string> propertyFilter = GetPropertyFilter(parameterDescriptor);

            // finally, call into the binder
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                FallbackToEmptyPrefix = (parameterDescriptor.BindingInfo.Prefix == null), // only fall back if prefix not specified
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, parameterType),
                ModelName = parameterName,
                ModelState = controllerContext.Controller.ViewData.ModelState,
                PropertyFilter = propertyFilter,
                ValueProvider = valueProvider
            };

            object result = binder.BindModel(controllerContext, bindingContext);
            return result ?? parameterDescriptor.DefaultValue;
        }

        protected virtual IDictionary<string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            Dictionary<string, object> parametersDict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            ParameterDescriptor[] parameterDescriptors = actionDescriptor.GetParameters();

            foreach (ParameterDescriptor parameterDescriptor in parameterDescriptors)
            {
                parametersDict[parameterDescriptor.ParameterName] = GetParameterValue(controllerContext, parameterDescriptor);
            }
            return parametersDict;
        }

        private static Predicate<string> GetPropertyFilter(ParameterDescriptor parameterDescriptor)
        {
            ParameterBindingInfo bindingInfo = parameterDescriptor.BindingInfo;
            return propertyName => BindAttribute.IsPropertyAllowed(propertyName, bindingInfo.Include, bindingInfo.Exclude);
        }

        public virtual bool InvokeAction(ControllerContext controllerContext, string actionName)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            Contract.Assert(controllerContext.RouteData != null);
            if (String.IsNullOrEmpty(actionName) && !controllerContext.RouteData.HasDirectRouteMatch())
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
            }

            ControllerDescriptor controllerDescriptor = GetControllerDescriptor(controllerContext);
            ActionDescriptor actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName);

            if (actionDescriptor != null)
            {
                FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor);

                try
                {
                    AuthenticationContext authenticationContext = InvokeAuthenticationFilters(controllerContext, filterInfo.AuthenticationFilters, actionDescriptor);

                    if (authenticationContext.Result != null)
                    {
                        // An authentication filter signaled that we should short-circuit the request. Let all
                        // authentication filters contribute to an action result (to combine authentication
                        // challenges). Then, run this action result.
                        AuthenticationChallengeContext challengeContext = InvokeAuthenticationFiltersChallenge(
                            controllerContext, filterInfo.AuthenticationFilters, actionDescriptor,
                            authenticationContext.Result);
                        InvokeActionResult(controllerContext, challengeContext.Result ?? authenticationContext.Result);
                    }
                    else
                    {
                        AuthorizationContext authorizationContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor);
                        if (authorizationContext.Result != null)
                        {
                            // An authorization filter signaled that we should short-circuit the request. Let all
                            // authentication filters contribute to an action result (to combine authentication
                            // challenges). Then, run this action result.
                            AuthenticationChallengeContext challengeContext = InvokeAuthenticationFiltersChallenge(
                                controllerContext, filterInfo.AuthenticationFilters, actionDescriptor,
                                authorizationContext.Result);
                            InvokeActionResult(controllerContext, challengeContext.Result ?? authorizationContext.Result);
                        }
                        else
                        {
                            if (controllerContext.Controller.ValidateRequest)
                            {
                                ValidateRequest(controllerContext);
                            }

                            IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor);
                            ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters);

                            // The action succeeded. Let all authentication filters contribute to an action result (to
                            // combine authentication challenges; some authentication filters need to do negotiation
                            // even on a successful result). Then, run this action result.
                            AuthenticationChallengeContext challengeContext = InvokeAuthenticationFiltersChallenge(
                                controllerContext, filterInfo.AuthenticationFilters, actionDescriptor,
                                postActionContext.Result);
                            InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters,
                                challengeContext.Result ?? postActionContext.Result);
                        }
                    }
                }
                catch (ThreadAbortException)
                {
                    // This type of exception occurs as a result of Response.Redirect(), but we special-case so that
                    // the filters don't see this as an error.
                    throw;
                }
                catch (Exception ex)
                {
                    // something blew up, so execute the exception filters
                    ExceptionContext exceptionContext = InvokeExceptionFilters(controllerContext, filterInfo.ExceptionFilters, ex);
                    if (!exceptionContext.ExceptionHandled)
                    {
                        throw;
                    }
                    InvokeActionResult(controllerContext, exceptionContext.Result);
                }

                return true;
            }

            // notify controller that no method matched
            return false;
        }

        protected virtual ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
        {
            object returnValue = actionDescriptor.Execute(controllerContext, parameters);
            ActionResult result = CreateActionResult(controllerContext, actionDescriptor, returnValue);
            return result;
        }

        internal static ActionExecutedContext InvokeActionMethodFilter(IActionFilter filter, ActionExecutingContext preContext, Func<ActionExecutedContext> continuation)
        {
            filter.OnActionExecuting(preContext);
            if (preContext.Result != null)
            {
                return new ActionExecutedContext(preContext, preContext.ActionDescriptor, true /* canceled */, null /* exception */)
                {
                    Result = preContext.Result
                };
            }

            bool wasError = false;
            ActionExecutedContext postContext = null;
            try
            {
                postContext = continuation();
            }
            catch (ThreadAbortException)
            {
                // This type of exception occurs as a result of Response.Redirect(), but we special-case so that
                // the filters don't see this as an error.
                postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, false /* canceled */, null /* exception */);
                filter.OnActionExecuted(postContext);
                throw;
            }
            catch (Exception ex)
            {
                wasError = true;
                postContext = new ActionExecutedContext(preContext, preContext.ActionDescriptor, false /* canceled */, ex);
                filter.OnActionExecuted(postContext);
                if (!postContext.ExceptionHandled)
                {
                    throw;
                }
            }
            if (!wasError)
            {
                filter.OnActionExecuted(postContext);
            }
            return postContext;
        }

        protected virtual ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList<IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
        {
            ActionExecutingContext preContext = new ActionExecutingContext(controllerContext, actionDescriptor, parameters);
            Func<ActionExecutedContext> continuation = () =>
                                                       new ActionExecutedContext(controllerContext, actionDescriptor, false /* canceled */, null /* exception */)
                                                       {
                                                           Result = InvokeActionMethod(controllerContext, actionDescriptor, parameters)
                                                       };

            // need to reverse the filter list because the continuations are built up backward
            Func<ActionExecutedContext> thunk = filters.Reverse().Aggregate(continuation,
                                                                            (next, filter) => () => InvokeActionMethodFilter(filter, preContext, next));
            return thunk();
        }

        protected virtual void InvokeActionResult(ControllerContext controllerContext, ActionResult actionResult)
        {
            actionResult.ExecuteResult(controllerContext);
        }

        private ResultExecutedContext InvokeActionResultFilterRecursive(IList<IResultFilter> filters, int filterIndex, ResultExecutingContext preContext, ControllerContext controllerContext, ActionResult actionResult)
        {
            // Performance-sensitive

            // For compatbility, the following behavior must be maintained
            //   The OnResultExecuting events must fire in forward order
            //   The InvokeActionResult must then fire
            //   The OnResultExecuted events must fire in reverse order
            //   Earlier filters can process the results and exceptions from the handling of later filters
            // This is achieved by calling recursively and moving through the filter list forwards

            // If there are no more filters to recurse over, create the main result
            if (filterIndex > filters.Count - 1)
            {
                InvokeActionResult(controllerContext, actionResult);
                return new ResultExecutedContext(controllerContext, actionResult, canceled: false, exception: null);
            }

            // Otherwise process the filters recursively
            IResultFilter filter = filters[filterIndex];
            filter.OnResultExecuting(preContext);
            if (preContext.Cancel)
            {
                return new ResultExecutedContext(preContext, preContext.Result, canceled: true, exception: null);
            }

            bool wasError = false;
            ResultExecutedContext postContext = null;
            try
            {
                // Use the filters in forward direction
                int nextFilterIndex = filterIndex + 1;
                postContext = InvokeActionResultFilterRecursive(filters, nextFilterIndex, preContext, controllerContext, actionResult);
            }
            catch (ThreadAbortException)
            {
                // This type of exception occurs as a result of Response.Redirect(), but we special-case so that
                // the filters don't see this as an error.
                postContext = new ResultExecutedContext(preContext, preContext.Result, canceled: false, exception: null);
                filter.OnResultExecuted(postContext);
                throw;
            }
            catch (Exception ex)
            {
                wasError = true;
                postContext = new ResultExecutedContext(preContext, preContext.Result, canceled: false, exception: ex);
                filter.OnResultExecuted(postContext);
                if (!postContext.ExceptionHandled)
                {
                    throw;
                }
            }
            if (!wasError)
            {
                filter.OnResultExecuted(postContext);
            }
            return postContext;
        }

        protected virtual ResultExecutedContext InvokeActionResultWithFilters(ControllerContext controllerContext, IList<IResultFilter> filters, ActionResult actionResult)
        {
            ResultExecutingContext preContext = new ResultExecutingContext(controllerContext, actionResult);

            int startingFilterIndex = 0;
            return InvokeActionResultFilterRecursive(filters, startingFilterIndex, preContext, controllerContext, actionResult);
        }

        protected virtual AuthenticationContext InvokeAuthenticationFilters(ControllerContext controllerContext,
            IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            Contract.Assert(controllerContext.HttpContext != null);
            IPrincipal originalPrincipal = controllerContext.HttpContext.User;
            AuthenticationContext context = new AuthenticationContext(controllerContext, actionDescriptor,
                originalPrincipal);
            foreach (IAuthenticationFilter filter in filters)
            {
                filter.OnAuthentication(context);
                // short-circuit evaluation when an error occurs
                if (context.Result != null)
                {
                    break;
                }
            }

            IPrincipal newPrincipal = context.Principal;

            if (newPrincipal != originalPrincipal)
            {
                Contract.Assert(context.HttpContext != null);
                context.HttpContext.User = newPrincipal;
                Thread.CurrentPrincipal = newPrincipal;
            }

            return context;
        }

        protected virtual AuthenticationChallengeContext InvokeAuthenticationFiltersChallenge(
            ControllerContext controllerContext, IList<IAuthenticationFilter> filters,
            ActionDescriptor actionDescriptor, ActionResult result)
        {
            AuthenticationChallengeContext context = new AuthenticationChallengeContext(controllerContext,
                actionDescriptor, result);
            foreach (IAuthenticationFilter filter in filters)
            {
                filter.OnAuthenticationChallenge(context);
                // unlike other filter types, don't short-circuit evaluation when context.Result != null (since it
                // starts out that way, and multiple filters may add challenges to the result)
            }

            return context;
        }

        protected virtual AuthorizationContext InvokeAuthorizationFilters(ControllerContext controllerContext, IList<IAuthorizationFilter> filters, ActionDescriptor actionDescriptor)
        {
            AuthorizationContext context = new AuthorizationContext(controllerContext, actionDescriptor);
            foreach (IAuthorizationFilter filter in filters)
            {
                filter.OnAuthorization(context);
                // short-circuit evaluation when an error occurs
                if (context.Result != null)
                {
                    break;
                }
            }

            return context;
        }

        protected virtual ExceptionContext InvokeExceptionFilters(ControllerContext controllerContext, IList<IExceptionFilter> filters, Exception exception)
        {
            ExceptionContext context = new ExceptionContext(controllerContext, exception);
            foreach (IExceptionFilter filter in filters.Reverse())
            {
                filter.OnException(context);
            }

            return context;
        }

        internal static void ValidateRequest(ControllerContext controllerContext)
        {
            if (controllerContext.IsChildAction)
            {
                return;
            }

            // DevDiv 214040: Enable Request Validation by default for all controller requests
            // 
            // Earlier versions of this method dereferenced Request.RawUrl to force validation of
            // that field. This was necessary for Routing before ASP.NET v4, which read the incoming
            // path from RawUrl. Request validation has been moved earlier in the pipeline by default and
            // routing no longer consumes this property, so we don't have to either.

            // Tolerate null HttpContext for testing
            HttpContext currentContext = HttpContext.Current;
            if (currentContext != null)
            {
                ValidationUtility.EnableDynamicValidation(currentContext);
            }

            controllerContext.HttpContext.Request.ValidateInput();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Async;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.WebPages.Scope;

namespace System.Web.Mvc
{
    public abstract class ControllerBase : IController
    {
        private readonly SingleEntryGate _executeWasCalledGate = new SingleEntryGate();

        private DynamicViewDataDictionary _dynamicViewDataDictionary;
        private TempDataDictionary _tempDataDictionary;
        private bool _validateRequest = true;
        private IValueProvider _valueProvider;
        private ViewDataDictionary _viewDataDictionary;

        public ControllerContext ControllerContext { get; set; }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This property is settable so that unit tests can provide mock implementations.")]
        public TempDataDictionary TempData
        {
            get
            {
                if (ControllerContext != null && ControllerContext.IsChildAction)
                {
                    return ControllerContext.ParentActionViewContext.TempData;
                }
                if (_tempDataDictionary == null)
                {
                    _tempDataDictionary = new TempDataDictionary();
                }
                return _tempDataDictionary;
            }
            set { _tempDataDictionary = value; }
        }

        public bool ValidateRequest
        {
            get { return _validateRequest; }
            set { _validateRequest = value; }
        }

        public IValueProvider ValueProvider
        {
            get
            {
                if (_valueProvider == null)
                {
                    _valueProvider = ValueProviderFactories.Factories.GetValueProvider(ControllerContext);
                }
                return _valueProvider;
            }
            set { _valueProvider = value; }
        }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewDataDictionary == null)
                {
                    _dynamicViewDataDictionary = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewDataDictionary;
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This property is settable so that unit tests can provide mock implementations.")]
        public ViewDataDictionary ViewData
        {
            get
            {
                if (_viewDataDictionary == null)
                {
                    _viewDataDictionary = new ViewDataDictionary();
                }
                return _viewDataDictionary;
            }
            set { _viewDataDictionary = value; }
        }

        protected virtual void Execute(RequestContext requestContext)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (requestContext.HttpContext == null)
            {
                throw new ArgumentException(MvcResources.ControllerBase_CannotExecuteWithNullHttpContext, "requestContext");
            }

            VerifyExecuteCalledOnce();
            Initialize(requestContext);

            using (ScopeStorage.CreateTransientScope())
            {
                ExecuteCore();
            }
        }

        protected abstract void ExecuteCore();

        protected virtual void Initialize(RequestContext requestContext)
        {
            ControllerContext = new ControllerContext(requestContext, this);
        }

        internal void VerifyExecuteCalledOnce()
        {
            if (!_executeWasCalledGate.TryEnter())
            {
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ControllerBase_CannotHandleMultipleRequests, GetType());
                throw new InvalidOperationException(message);
            }
        }

        #region IController Members

        void IController.Execute(RequestContext requestContext)
        {
            Execute(requestContext);
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ControllerBuilder
    {
        private static ControllerBuilder _instance = new ControllerBuilder();
        private Func<IControllerFactory> _factoryThunk = () => null;
        private HashSet<string> _namespaces = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        private IResolver<IControllerFactory> _serviceResolver;

        public ControllerBuilder()
            : this(null)
        {
        }

        internal ControllerBuilder(IResolver<IControllerFactory> serviceResolver)
        {
            _serviceResolver = serviceResolver ?? new SingleServiceResolver<IControllerFactory>(
                                                      () => _factoryThunk(),
                                                      new DefaultControllerFactory { ControllerBuilder = this },
                                                      "ControllerBuilder.GetControllerFactory");
        }

        public static ControllerBuilder Current
        {
            get { return _instance; }
        }

        public HashSet<string> DefaultNamespaces
        {
            get { return _namespaces; }
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Calling method multiple times might return different objects.")]
        public IControllerFactory GetControllerFactory()
        {
            return _serviceResolver.Current;
        }

        public void SetControllerFactory(IControllerFactory controllerFactory)
        {
            if (controllerFactory == null)
            {
                throw new ArgumentNullException("controllerFactory");
            }

            _factoryThunk = () => controllerFactory;
        }

        public void SetControllerFactory(Type controllerFactoryType)
        {
            if (controllerFactoryType == null)
            {
                throw new ArgumentNullException("controllerFactoryType");
            }
            if (!typeof(IControllerFactory).IsAssignableFrom(controllerFactoryType))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.ControllerBuilder_MissingIControllerFactory,
                        controllerFactoryType),
                    "controllerFactoryType");
            }

            _factoryThunk = delegate
            {
                try
                {
                    return (IControllerFactory)Activator.CreateInstance(controllerFactoryType);
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            MvcResources.ControllerBuilder_ErrorCreatingControllerFactory,
                            controllerFactoryType),
                        ex);
                }
            };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    // Though many of the properties on ControllerContext and its subclassed types are virtual, there are still sealed
    // properties (like ControllerContext.RequestContext, ActionExecutingContext.Result, etc.). If these properties
    // were virtual, a mocking framework might override them with incorrect behavior (property getters would return
    // null, property setters would be no-ops). By sealing these properties, we are forcing them to have the default
    // "get or store a value" semantics that they were intended to have.

    public class ControllerContext
    {
        internal const string ParentActionViewContextToken = "ParentActionViewContext";
        private HttpContextBase _httpContext;
        private RequestContext _requestContext;
        private RouteData _routeData;

        // parameterless constructor used for mocking
        public ControllerContext()
        {
        }

        // copy constructor - allows for subclassed types to take an existing ControllerContext as a parameter
        // and we'll automatically set the appropriate properties
        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        protected ControllerContext(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            Controller = controllerContext.Controller;
            RequestContext = controllerContext.RequestContext;
        }

        public ControllerContext(HttpContextBase httpContext, RouteData routeData, ControllerBase controller)
            : this(new RequestContext(httpContext, routeData), controller)
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public ControllerContext(RequestContext requestContext, ControllerBase controller)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (controller == null)
            {
                throw new ArgumentNullException("controller");
            }

            RequestContext = requestContext;
            Controller = controller;
        }

        public virtual ControllerBase Controller { get; set; }

        public IDisplayMode DisplayMode
        {
            get { return DisplayModeProvider.GetDisplayMode(HttpContext); }
            set { DisplayModeProvider.SetDisplayMode(HttpContext, value); }
        }

        public virtual HttpContextBase HttpContext
        {
            get
            {
                if (_httpContext == null)
                {
                    _httpContext = (_requestContext != null) ? _requestContext.HttpContext : new EmptyHttpContext();
                }
                return _httpContext;
            }
            set { _httpContext = value; }
        }

        public virtual bool IsChildAction
        {
            get
            {
                RouteData routeData = RouteData;
                if (routeData == null)
                {
                    return false;
                }
                return routeData.DataTokens.ContainsKey(ParentActionViewContextToken);
            }
        }

        public ViewContext ParentActionViewContext
        {
            get { return RouteData.DataTokens[ParentActionViewContextToken] as ViewContext; }
        }

        public RequestContext RequestContext
        {
            get
            {
                if (_requestContext == null)
                {
                    // still need explicit calls to constructors since the property getters are virtual and might return null
                    HttpContextBase httpContext = HttpContext ?? new EmptyHttpContext();
                    RouteData routeData = RouteData ?? new RouteData();

                    _requestContext = new RequestContext(httpContext, routeData);
                }
                return _requestContext;
            }
            set { _requestContext = value; }
        }

        public virtual RouteData RouteData
        {
            get
            {
                if (_routeData == null)
                {
                    _routeData = (_requestContext != null) ? _requestContext.RouteData : new RouteData();
                }
                return _routeData;
            }
            set { _routeData = value; }
        }

        private sealed class EmptyHttpContext : HttpContextBase
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;

namespace System.Web.Mvc
{
    public abstract class ControllerDescriptor : ICustomAttributeProvider, IUniquelyIdentifiable
    {
        private readonly Lazy<string> _uniqueId;

        protected ControllerDescriptor()
        {
            _uniqueId = new Lazy<string>(CreateUniqueId);
        }

        public virtual string ControllerName
        {
            get
            {
                string typeName = ControllerType.Name;
                if (typeName.EndsWith("Controller", StringComparison.OrdinalIgnoreCase))
                {
                    return typeName.Substring(0, typeName.Length - "Controller".Length);
                }

                return typeName;
            }
        }

        public abstract Type ControllerType { get; }

        [SuppressMessage("Microsoft.Security", "CA2119:SealMethodsThatSatisfyPrivateInterfaces", Justification = "This is overridden elsewhere in System.Web.Mvc")]
        public virtual string UniqueId
        {
            get { return _uniqueId.Value; }
        }

        private string CreateUniqueId()
        {
            return DescriptorUtil.CreateUniqueId(GetType(), ControllerName, ControllerType);
        }

        public abstract ActionDescriptor FindAction(ControllerContext controllerContext, string actionName);

        public abstract ActionDescriptor[] GetCanonicalActions();

        public virtual object[] GetCustomAttributes(bool inherit)
        {
            return GetCustomAttributes(typeof(object), inherit);
        }

        public virtual object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }

            return (object[])Array.CreateInstance(attributeType, 0);
        }

        public virtual IEnumerable<FilterAttribute> GetFilterAttributes(bool useCache)
        {
            return GetCustomAttributes(typeof(FilterAttribute), inherit: true).Cast<FilterAttribute>();
        }

        public virtual bool IsDefined(Type attributeType, bool inherit)
        {
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }

            return false;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerDescriptorCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal sealed class ControllerDescriptorCache : ReaderWriterCache<Type, ControllerDescriptor>
    {
        public ControllerDescriptorCache()
        {
        }

        public ControllerDescriptor GetDescriptor(Type controllerType, Func<ControllerDescriptor> creator)
        {
            return FetchOrCreateItem(controllerType, creator);
        }

        internal ControllerDescriptor GetDescriptor<TArgument>(Type controllerType, Func<TArgument, ControllerDescriptor> creator, TArgument state)
        {
            return FetchOrCreateItem(controllerType, creator, state);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerDescriptorExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;

namespace System.Web.Mvc
{
    internal static class ControllerDescriptorExtensions
    {
        public static string GetAreaName(this ControllerDescriptor controllerDescriptor, RouteAreaAttribute area)
        {
            if (area == null)
            {
                return null;
            }

            if (area.AreaName != null)
            {
                return area.AreaName;
            }
            if (controllerDescriptor.ControllerType.Namespace != null)
            {
                return controllerDescriptor.ControllerType.Namespace.Split('.').Last();
            }

            throw Error.InvalidOperation(MvcResources.AttributeRouting_CouldNotInferAreaNameFromMissingNamespace, controllerDescriptor.ControllerName);
        }

        public static RouteAreaAttribute GetAreaFrom(this ControllerDescriptor controllerDescriptor)
        {
            RouteAreaAttribute areaAttribute =
                controllerDescriptor.GetCustomAttributes(typeof(RouteAreaAttribute), inherit: true)
                                    .Cast<RouteAreaAttribute>()
                                    .FirstOrDefault();
            return areaAttribute;
        }
    }
}

================================================
FILE: src/System.Web.Mvc/ControllerInstanceFilterProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public class ControllerInstanceFilterProvider : IFilterProvider
    {
        public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            if (controllerContext.Controller != null)
            {
                // Use FilterScope.First and Order of Int32.MinValue to ensure controller instance methods always run first
                yield return new Filter(controllerContext.Controller, FilterScope.First, Int32.MinValue);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ControllerTypeCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace System.Web.Mvc
{
    internal sealed class ControllerTypeCache
    {
        private const string TypeCacheName = "MVC-ControllerTypeCache.xml";

        private volatile Dictionary<string, ILookup<string, Type>> _cache;
        private object _lockObj = new object();

        internal int Count
        {
            get
            {
                int count = 0;
                foreach (var lookup in _cache.Values)
                {
                    foreach (var grouping in lookup)
                    {
                        count += grouping.Count();
                    }
                }
                return count;
            }
        }

        internal IReadOnlyList<Type> GetControllerTypes()
        {
            return new ReadOnlyCollection<Type>(_cache.Values.SelectMany(lookup => lookup.SelectMany(t => t)).ToList());
        }

        public void EnsureInitialized(IBuildManager buildManager)
        {
            if (_cache == null)
            {
                lock (_lockObj)
                {
                    if (_cache == null)
                    {
                        List<Type> controllerTypes = TypeCacheUtil.GetFilteredTypesFromAssemblies(TypeCacheName, IsControllerType, buildManager);
                        var groupedByName = controllerTypes.GroupBy(
                            t => t.Name.Substring(0, t.Name.Length - "Controller".Length),
                            StringComparer.OrdinalIgnoreCase);
                        _cache = groupedByName.ToDictionary(
                            g => g.Key,
                            g => g.ToLookup(t => t.Namespace ?? String.Empty, StringComparer.OrdinalIgnoreCase),
                            StringComparer.OrdinalIgnoreCase);
                    }
                }
            }
        }

        public ICollection<Type> GetControllerTypes(string controllerName, HashSet<string> namespaces)
        {
            HashSet<Type> matchingTypes = new HashSet<Type>();

            ILookup<string, Type> namespaceLookup;
            if (_cache.TryGetValue(controllerName, out namespaceLookup))
            {
                // this friendly name was located in the cache, now cycle through namespaces
                if (namespaces != null)
                {
                    foreach (string requestedNamespace in namespaces)
                    {
                        foreach (var targetNamespaceGrouping in namespaceLookup)
                        {
                            if (IsNamespaceMatch(requestedNamespace, targetNamespaceGrouping.Key))
                            {
                                matchingTypes.UnionWith(targetNamespaceGrouping);
                            }
                        }
                    }
                }
                else
                {
                    // if the namespaces parameter is null, search *every* namespace
                    foreach (var namespaceGroup in namespaceLookup)
                    {
                        matchingTypes.UnionWith(namespaceGroup);
                    }
                }
            }

            return matchingTypes;
        }

        internal static bool IsControllerType(Type t)
        {
            return
                t != null &&
                t.IsPublic &&
                t.Name.EndsWith("Controller", StringComparison.OrdinalIgnoreCase) &&
                !t.IsAbstract &&
                typeof(IController).IsAssignableFrom(t);
        }

        internal static bool IsNamespaceMatch(string requestedNamespace, string targetNamespace)
        {
            // degenerate cases
            if (requestedNamespace == null)
            {
                return false;
            }
            else if (requestedNamespace.Length == 0)
            {
                return true;
            }

            if (!requestedNamespace.EndsWith(".*", StringComparison.OrdinalIgnoreCase))
            {
                // looking for exact namespace match
                return String.Equals(requestedNamespace, targetNamespace, StringComparison.OrdinalIgnoreCase);
            }
            else
            {
                // looking for exact or sub-namespace match
                requestedNamespace = requestedNamespace.Substring(0, requestedNamespace.Length - ".*".Length);
                if (!targetNamespace.StartsWith(requestedNamespace, StringComparison.OrdinalIgnoreCase))
                {
                    return false;
                }

                if (requestedNamespace.Length == targetNamespace.Length)
                {
                    // exact match
                    return true;
                }
                else if (targetNamespace[requestedNamespace.Length] == '.')
                {
                    // good prefix match, e.g. requestedNamespace = "Foo.Bar" and targetNamespace = "Foo.Bar.Baz"
                    return true;
                }
                else
                {
                    // bad prefix match, e.g. requestedNamespace = "Foo.Bar" and targetNamespace = "Foo.Bar2"
                    return false;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/CopyOnWriteDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;

namespace System.Web.Mvc
{
    /// <summary>
    /// A <see cref="IDictionary{TKey, TValue}"/> that defers creating a shallow copy of the source dictionary until
    /// a mutative operation has been performed on it.
    /// </summary>
    internal class CopyOnWriteDictionary<TKey, TValue> : IDictionary<TKey, TValue>
    {
        private readonly IDictionary<TKey, TValue> _sourceDictionary;
        private readonly IEqualityComparer<TKey> _comparer;
        private IDictionary<TKey, TValue> _innerDictionary;

        public CopyOnWriteDictionary(IDictionary<TKey, TValue> sourceDictionary,
                                     IEqualityComparer<TKey> comparer)
        {
            Contract.Assert(sourceDictionary != null);
            Contract.Assert(comparer != null);

            _sourceDictionary = sourceDictionary;
            _comparer = comparer;
        }

        private IDictionary<TKey, TValue> ReadDictionary
        {
            get
            {
                return _innerDictionary ?? _sourceDictionary;
            }
        }

        private IDictionary<TKey, TValue> WriteDictionary
        {
            get
            {
                if (_innerDictionary == null)
                {
                    _innerDictionary = new Dictionary<TKey, TValue>(_sourceDictionary,
                                                                    _comparer);
                }

                return _innerDictionary;
            }
        }

        public virtual ICollection<TKey> Keys
        {
            get
            {
                return ReadDictionary.Keys;
            }
        }

        public virtual ICollection<TValue> Values
        {
            get
            {
                return ReadDictionary.Values;
            }
        }

        public virtual int Count
        {
            get
            {
                return ReadDictionary.Count;
            }
        }

        public virtual bool IsReadOnly
        {
            get
            {
                return false;
            }
        }

        public virtual TValue this[TKey key]
        {
            get
            {
                return ReadDictionary[key];
            }
            set
            {
                WriteDictionary[key] = value;
            }
        }

        public virtual bool ContainsKey(TKey key)
        {
            return ReadDictionary.ContainsKey(key);
        }

        public virtual void Add(TKey key, TValue value)
        {
            WriteDictionary.Add(key, value);
        }

        public virtual bool Remove(TKey key)
        {
            return WriteDictionary.Remove(key);
        }

        public virtual bool TryGetValue(TKey key, out TValue value)
        {
            return ReadDictionary.TryGetValue(key, out value);
        }

        public virtual void Add(KeyValuePair<TKey, TValue> item)
        {
            WriteDictionary.Add(item);
        }

        public virtual void Clear()
        {
            WriteDictionary.Clear();
        }

        public virtual bool Contains(KeyValuePair<TKey, TValue> item)
        {
            return ReadDictionary.Contains(item);
        }

        public virtual void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
        {
            ReadDictionary.CopyTo(array, arrayIndex);
        }

        public bool Remove(KeyValuePair<TKey, TValue> item)
        {
            return WriteDictionary.Remove(item);
        }

        public virtual IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
        {
            return ReadDictionary.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}

================================================
FILE: src/System.Web.Mvc/CustomModelBinderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    [AttributeUsage(ValidTargets, AllowMultiple = false, Inherited = false)]
    public abstract class CustomModelBinderAttribute : Attribute
    {
        internal const AttributeTargets ValidTargets = AttributeTargets.Class | AttributeTargets.Enum | AttributeTargets.Interface | AttributeTargets.Parameter | AttributeTargets.Struct;

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method can potentially perform a non-trivial amount of work.")]
        public abstract IModelBinder GetBinder();
    }
}


================================================
FILE: src/System.Web.Mvc/DataAnnotationsModelMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class DataAnnotationsModelMetadata : ModelMetadata
    {
        private DisplayColumnAttribute _displayColumnAttribute;

        public DataAnnotationsModelMetadata(DataAnnotationsModelMetadataProvider provider, Type containerType,
                                            Func<object> modelAccessor, Type modelType, string propertyName,
                                            DisplayColumnAttribute displayColumnAttribute)
            : base(provider, containerType, modelAccessor, modelType, propertyName)
        {
            _displayColumnAttribute = displayColumnAttribute;
        }

        protected override string GetSimpleDisplayText()
        {
            if (Model != null)
            {
                if (_displayColumnAttribute != null && !String.IsNullOrEmpty(_displayColumnAttribute.DisplayColumn))
                {
                    PropertyInfo displayColumnProperty = ModelType.GetProperty(_displayColumnAttribute.DisplayColumn, BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
                    ValidateDisplayColumnAttribute(_displayColumnAttribute, displayColumnProperty, ModelType);

                    object simpleDisplayTextValue = displayColumnProperty.GetValue(Model, new object[0]);
                    if (simpleDisplayTextValue != null)
                    {
                        return simpleDisplayTextValue.ToString();
                    }
                }
            }

            return base.GetSimpleDisplayText();
        }

        private static void ValidateDisplayColumnAttribute(DisplayColumnAttribute displayColumnAttribute, PropertyInfo displayColumnProperty, Type modelType)
        {
            if (displayColumnProperty == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DataAnnotationsModelMetadataProvider_UnknownProperty,
                        modelType.FullName, displayColumnAttribute.DisplayColumn));
            }
            if (displayColumnProperty.GetGetMethod() == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DataAnnotationsModelMetadataProvider_UnreadableProperty,
                        modelType.FullName, displayColumnAttribute.DisplayColumn));
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DataAnnotationsModelMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;

namespace System.Web.Mvc
{
    public class DataAnnotationsModelMetadataProvider : AssociatedMetadataProvider
    {
        protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
        {
            List<Attribute> attributeList = new List<Attribute>(attributes);
            DisplayColumnAttribute displayColumnAttribute = attributeList.OfType<DisplayColumnAttribute>().FirstOrDefault();
            DataAnnotationsModelMetadata result = new DataAnnotationsModelMetadata(this, containerType, modelAccessor, modelType, propertyName, displayColumnAttribute);

            // Do [HiddenInput] before [UIHint], so you can override the template hint
            HiddenInputAttribute hiddenInputAttribute = attributeList.OfType<HiddenInputAttribute>().FirstOrDefault();
            if (hiddenInputAttribute != null)
            {
                result.TemplateHint = "HiddenInput";
                result.HideSurroundingHtml = !hiddenInputAttribute.DisplayValue;
            }

            // We prefer [UIHint("...", PresentationLayer = "MVC")] but will fall back to [UIHint("...")]
            IEnumerable<UIHintAttribute> uiHintAttributes = attributeList.OfType<UIHintAttribute>();
            UIHintAttribute uiHintAttribute = uiHintAttributes.FirstOrDefault(a => String.Equals(a.PresentationLayer, "MVC", StringComparison.OrdinalIgnoreCase))
                                              ?? uiHintAttributes.FirstOrDefault(a => String.IsNullOrEmpty(a.PresentationLayer));
            if (uiHintAttribute != null)
            {
                result.TemplateHint = uiHintAttribute.UIHint;
            }

            EditableAttribute editable = attributes.OfType<EditableAttribute>().FirstOrDefault();
            if (editable != null)
            {
                result.IsReadOnly = !editable.AllowEdit;
            }
            else
            {
                ReadOnlyAttribute readOnlyAttribute = attributeList.OfType<ReadOnlyAttribute>().FirstOrDefault();
                if (readOnlyAttribute != null)
                {
                    result.IsReadOnly = readOnlyAttribute.IsReadOnly;
                }
            }

            DataTypeAttribute dataTypeAttribute = attributeList.OfType<DataTypeAttribute>().FirstOrDefault();
            DisplayFormatAttribute displayFormatAttribute = attributeList.OfType<DisplayFormatAttribute>().FirstOrDefault();
            SetFromDataTypeAndDisplayAttributes(result, dataTypeAttribute, displayFormatAttribute);

            ScaffoldColumnAttribute scaffoldColumnAttribute = attributeList.OfType<ScaffoldColumnAttribute>().FirstOrDefault();
            if (scaffoldColumnAttribute != null)
            {
                result.ShowForDisplay = result.ShowForEdit = scaffoldColumnAttribute.Scaffold;
            }

            DisplayAttribute display = attributes.OfType<DisplayAttribute>().FirstOrDefault();
            string name = null;
            if (display != null)
            {
                result.Description = display.GetDescription();
                result.ShortDisplayName = display.GetShortName();
                result.Watermark = display.GetPrompt();
                result.Order = display.GetOrder() ?? ModelMetadata.DefaultOrder;

                name = display.GetName();
            }

            if (name != null)
            {
                result.DisplayName = name;
            }
            else
            {
                DisplayNameAttribute displayNameAttribute = attributeList.OfType<DisplayNameAttribute>().FirstOrDefault();
                if (displayNameAttribute != null)
                {
                    result.DisplayName = displayNameAttribute.DisplayName;
                }
            }

            RequiredAttribute requiredAttribute = attributeList.OfType<RequiredAttribute>().FirstOrDefault();
            if (requiredAttribute != null)
            {
                result.IsRequired = true;
            }

            return result;
        }

        private static void SetFromDataTypeAndDisplayAttributes(DataAnnotationsModelMetadata result,
            DataTypeAttribute dataTypeAttribute, DisplayFormatAttribute displayFormatAttribute)
        {
            if (dataTypeAttribute != null)
            {
                result.DataTypeName = dataTypeAttribute.ToDataTypeName();
            }

            if (displayFormatAttribute == null && dataTypeAttribute != null)
            {
                displayFormatAttribute = dataTypeAttribute.DisplayFormat;

                // If DisplayFormat value was non-null and this [DataType] is of a subclass, assume the [DataType]
                // constructor used the protected DisplayFormat setter to override its default. Note deriving from
                // [DataType] but preserving DataFormatString and ApplyFormatInEditMode results in
                // HasNonDefaultEditFormat==true.
                if (displayFormatAttribute != null && dataTypeAttribute.GetType() != typeof(DataTypeAttribute))
                {
                    result.HasNonDefaultEditFormat = true;
                }
            }
            else if (displayFormatAttribute != null)
            {
                result.HasNonDefaultEditFormat = true;
            }

            if (displayFormatAttribute != null)
            {
                result.NullDisplayText = displayFormatAttribute.NullDisplayText;
                result.DisplayFormatString = displayFormatAttribute.DataFormatString;
                result.ConvertEmptyStringToNull = displayFormatAttribute.ConvertEmptyStringToNull;
                result.HtmlEncode = displayFormatAttribute.HtmlEncode;

                if (displayFormatAttribute.ApplyFormatInEditMode)
                {
                    result.EditFormatString = displayFormatAttribute.DataFormatString;
                }

                if (!displayFormatAttribute.HtmlEncode && String.IsNullOrWhiteSpace(result.DataTypeName))
                {
                    result.DataTypeName = DataTypeUtil.HtmlTypeName;
                }

                // Regardless of HasNonDefaultEditFormat calculation above, treat missing EditFormatString as the
                // default.  Note the corner case of a [DataType] subclass overriding a non-empty default to apply a
                // [DisplayFormat] lacking DataFormatString or with ApplyFormatInEditMode==false results in
                // HasNonDefaultEditFormat==false.
                if (String.IsNullOrEmpty(result.EditFormatString))
                {
                    result.HasNonDefaultEditFormat = false;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DataAnnotationsModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;

namespace System.Web.Mvc
{
    public class DataAnnotationsModelValidator : ModelValidator
    {
        public DataAnnotationsModelValidator(ModelMetadata metadata, ControllerContext context, ValidationAttribute attribute)
            : base(metadata, context)
        {
            if (attribute == null)
            {
                throw new ArgumentNullException("attribute");
            }

            Attribute = attribute;
        }

        protected internal ValidationAttribute Attribute { get; private set; }

        protected internal string ErrorMessage
        {
            get { return Attribute.FormatErrorMessage(Metadata.GetDisplayName()); }
        }

        public override bool IsRequired
        {
            get { return Attribute is RequiredAttribute; }
        }

        internal static ModelValidator Create(ModelMetadata metadata, ControllerContext context, ValidationAttribute attribute)
        {
            return new DataAnnotationsModelValidator(metadata, context, attribute);
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            IEnumerable<ModelClientValidationRule> results = base.GetClientValidationRules();

            IClientValidatable clientValidatable = Attribute as IClientValidatable;
            if (clientValidatable != null)
            {
                results = results.Concat(clientValidatable.GetClientValidationRules(Metadata, ControllerContext));
            }

            return results;
        }

        public override IEnumerable<ModelValidationResult> Validate(object container)
        {
            // Per the WCF RIA Services team, instance can never be null (if you have
            // no parent, you pass yourself for the "instance" parameter).
            string memberName = Metadata.PropertyName ?? Metadata.ModelType.Name;
            ValidationContext context = new ValidationContext(container ?? Metadata.Model)
            {
                DisplayName = Metadata.GetDisplayName(),
                MemberName = memberName
            };

            ValidationResult result = Attribute.GetValidationResult(Metadata.Model, context);
            if (result != ValidationResult.Success)
            {
                // ModelValidationResult.MemberName is used by invoking validators (such as ModelValidator) to 
                // construct the ModelKey for ModelStateDictionary. When validating at type level we want to append the 
                // returned MemberNames if specified (e.g. person.Address.FirstName). For property validation, the 
                // ModelKey can be constructed using the ModelMetadata and we should ignore MemberName (we don't want 
                // (person.Name.Name). However the invoking validator does not have a way to distinguish between these two 
                // cases. Consequently we'll only set MemberName if this validation returns a MemberName that is different
                // from the property being validated.

                string errorMemberName = result.MemberNames.FirstOrDefault();
                if (String.Equals(errorMemberName, memberName, StringComparison.Ordinal))
                {
                    errorMemberName = null;
                }

                var validationResult = new ModelValidationResult
                {
                    Message = result.ErrorMessage,
                    MemberName = errorMemberName
                };

                return new ModelValidationResult[] { validationResult };
            }

            return Enumerable.Empty<ModelValidationResult>();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DataAnnotationsModelValidatorOfTAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    public class DataAnnotationsModelValidator<TAttribute> : DataAnnotationsModelValidator
        where TAttribute : ValidationAttribute
    {
        public DataAnnotationsModelValidator(ModelMetadata metadata, ControllerContext context, TAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        protected new TAttribute Attribute
        {
            get { return (TAttribute)base.Attribute; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DataAnnotationsModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Web.Mvc.Properties;
using System.Web.Security;
using DataAnnotationsCompareAttribute = System.ComponentModel.DataAnnotations.CompareAttribute;

namespace System.Web.Mvc
{
    // A factory for validators based on ValidationAttribute
    public delegate ModelValidator DataAnnotationsModelValidationFactory(ModelMetadata metadata, ControllerContext context, ValidationAttribute attribute);

    // A factory for validators based on IValidatableObject
    public delegate ModelValidator DataAnnotationsValidatableObjectAdapterFactory(ModelMetadata metadata, ControllerContext context);

    /// <summary>
    /// An implementation of <see cref="ModelValidatorProvider"/> which providers validators
    /// for attributes which derive from <see cref="ValidationAttribute"/>. It also provides
    /// a validator for types which implement <see cref="IValidatableObject"/>. To support
    /// client side validation, you can either register adapters through the static methods
    /// on this class, or by having your validation attributes implement
    /// <see cref="IClientValidatable"/>. The logic to support IClientValidatable
    /// is implemented in <see cref="DataAnnotationsModelValidator"/>.
    /// </summary>
    public class DataAnnotationsModelValidatorProvider : AssociatedValidatorProvider
    {
        private static bool _addImplicitRequiredAttributeForValueTypes = true;
        private static ReaderWriterLockSlim _adaptersLock = new ReaderWriterLockSlim();

        // Factories for validation attributes

        internal static DataAnnotationsModelValidationFactory DefaultAttributeFactory =
            (metadata, context, attribute) => new DataAnnotationsModelValidator(metadata, context, attribute);

        internal static Dictionary<Type, DataAnnotationsModelValidationFactory> AttributeFactories = BuildAttributeFactoriesDictionary();

        // Factories for IValidatableObject models

        internal static DataAnnotationsValidatableObjectAdapterFactory DefaultValidatableFactory =
            (metadata, context) => new ValidatableObjectAdapter(metadata, context);

        internal static Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory> ValidatableFactories = new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();

        public static bool AddImplicitRequiredAttributeForValueTypes
        {
            get { return _addImplicitRequiredAttributeForValueTypes; }
            set { _addImplicitRequiredAttributeForValueTypes = value; }
        }

        protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes)
        {
            _adaptersLock.EnterReadLock();

            try
            {
                List<ModelValidator> results = new List<ModelValidator>();

                // Add an implied [Required] attribute for any non-nullable value type,
                // unless they've configured us not to do that.
                if (AddImplicitRequiredAttributeForValueTypes &&
                    metadata.IsRequired &&
                    !attributes.Any(a => a is RequiredAttribute))
                {
                    attributes = attributes.Concat(new[] { new RequiredAttribute() });
                }

                // Produce a validator for each validation attribute we find
                foreach (ValidationAttribute attribute in attributes.OfType<ValidationAttribute>())
                {
                    DataAnnotationsModelValidationFactory factory;
                    if (!AttributeFactories.TryGetValue(attribute.GetType(), out factory))
                    {
                        factory = DefaultAttributeFactory;
                    }
                    results.Add(factory(metadata, context, attribute));
                }

                // Produce a validator if the type supports IValidatableObject
                if (typeof(IValidatableObject).IsAssignableFrom(metadata.ModelType))
                {
                    DataAnnotationsValidatableObjectAdapterFactory factory;
                    if (!ValidatableFactories.TryGetValue(metadata.ModelType, out factory))
                    {
                        factory = DefaultValidatableFactory;
                    }
                    results.Add(factory(metadata, context));
                }

                return results;
            }
            finally
            {
                _adaptersLock.ExitReadLock();
            }
        }

        #region Validation attribute adapter registration

        public static void RegisterAdapter(Type attributeType, Type adapterType)
        {
            ValidateAttributeType(attributeType);
            ValidateAttributeAdapterType(adapterType);
            ConstructorInfo constructor = GetAttributeAdapterConstructor(attributeType, adapterType);

            _adaptersLock.EnterWriteLock();

            try
            {
                AttributeFactories[attributeType] = (metadata, context, attribute) => (ModelValidator)constructor.Invoke(new object[] { metadata, context, attribute });
            }
            finally
            {
                _adaptersLock.ExitWriteLock();
            }
        }

        public static void RegisterAdapterFactory(Type attributeType, DataAnnotationsModelValidationFactory factory)
        {
            ValidateAttributeType(attributeType);
            ValidateAttributeFactory(factory);

            _adaptersLock.EnterWriteLock();

            try
            {
                AttributeFactories[attributeType] = factory;
            }
            finally
            {
                _adaptersLock.ExitWriteLock();
            }
        }

        public static void RegisterDefaultAdapter(Type adapterType)
        {
            ValidateAttributeAdapterType(adapterType);
            ConstructorInfo constructor = GetAttributeAdapterConstructor(typeof(ValidationAttribute), adapterType);

            DefaultAttributeFactory = (metadata, context, attribute) => (ModelValidator)constructor.Invoke(new object[] { metadata, context, attribute });
        }

        public static void RegisterDefaultAdapterFactory(DataAnnotationsModelValidationFactory factory)
        {
            ValidateAttributeFactory(factory);

            DefaultAttributeFactory = factory;
        }

        // Helpers 

        private static ConstructorInfo GetAttributeAdapterConstructor(Type attributeType, Type adapterType)
        {
            ConstructorInfo constructor = adapterType.GetConstructor(new[] { typeof(ModelMetadata), typeof(ControllerContext), attributeType });
            if (constructor == null)
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DataAnnotationsModelValidatorProvider_ConstructorRequirements,
                        adapterType.FullName,
                        typeof(ModelMetadata).FullName,
                        typeof(ControllerContext).FullName,
                        attributeType.FullName),
                    "adapterType");
            }

            return constructor;
        }

        private static void ValidateAttributeAdapterType(Type adapterType)
        {
            if (adapterType == null)
            {
                throw new ArgumentNullException("adapterType");
            }
            if (!typeof(ModelValidator).IsAssignableFrom(adapterType))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Common_TypeMustDriveFromType,
                        adapterType.FullName,
                        typeof(ModelValidator).FullName),
                    "adapterType");
            }
        }

        private static void ValidateAttributeType(Type attributeType)
        {
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }
            if (!typeof(ValidationAttribute).IsAssignableFrom(attributeType))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Common_TypeMustDriveFromType,
                        attributeType.FullName,
                        typeof(ValidationAttribute).FullName),
                    "attributeType");
            }
        }

        private static void ValidateAttributeFactory(DataAnnotationsModelValidationFactory factory)
        {
            if (factory == null)
            {
                throw new ArgumentNullException("factory");
            }
        }

        #endregion

        #region IValidatableObject adapter registration

        /// <summary>
        /// Registers an adapter type for the given <paramref name="modelType"/>, which must
        /// implement <see cref="IValidatableObject"/>. The adapter type must derive from
        /// <see cref="ModelValidator"/> and it must contain a public constructor
        /// which takes two parameters of types <see cref="ModelMetadata"/> and
        /// <see cref="ControllerContext"/>.
        /// </summary>
        public static void RegisterValidatableObjectAdapter(Type modelType, Type adapterType)
        {
            ValidateValidatableModelType(modelType);
            ValidateValidatableAdapterType(adapterType);
            ConstructorInfo constructor = GetValidatableAdapterConstructor(adapterType);

            _adaptersLock.EnterWriteLock();

            try
            {
                ValidatableFactories[modelType] = (metadata, context) => (ModelValidator)constructor.Invoke(new object[] { metadata, context });
            }
            finally
            {
                _adaptersLock.ExitWriteLock();
            }
        }

        /// <summary>
        /// Registers an adapter factory for the given <paramref name="modelType"/>, which must
        /// implement <see cref="IValidatableObject"/>.
        /// </summary>
        public static void RegisterValidatableObjectAdapterFactory(Type modelType, DataAnnotationsValidatableObjectAdapterFactory factory)
        {
            ValidateValidatableModelType(modelType);
            ValidateValidatableFactory(factory);

            _adaptersLock.EnterWriteLock();

            try
            {
                ValidatableFactories[modelType] = factory;
            }
            finally
            {
                _adaptersLock.ExitWriteLock();
            }
        }

        /// <summary>
        /// Registers the default adapter type for objects which implement
        /// <see cref="IValidatableObject"/>. The adapter type must derive from
        /// <see cref="ModelValidator"/> and it must contain a public constructor
        /// which takes two parameters of types <see cref="ModelMetadata"/> and
        /// <see cref="ControllerContext"/>.
        /// </summary>
        public static void RegisterDefaultValidatableObjectAdapter(Type adapterType)
        {
            ValidateValidatableAdapterType(adapterType);
            ConstructorInfo constructor = GetValidatableAdapterConstructor(adapterType);

            DefaultValidatableFactory = (metadata, context) => (ModelValidator)constructor.Invoke(new object[] { metadata, context });
        }

        /// <summary>
        /// Registers the default adapter factory for objects which implement
        /// <see cref="IValidatableObject"/>.
        /// </summary>
        public static void RegisterDefaultValidatableObjectAdapterFactory(DataAnnotationsValidatableObjectAdapterFactory factory)
        {
            ValidateValidatableFactory(factory);

            DefaultValidatableFactory = factory;
        }

        // Helpers 

        private static ConstructorInfo GetValidatableAdapterConstructor(Type adapterType)
        {
            ConstructorInfo constructor = adapterType.GetConstructor(new[] { typeof(ModelMetadata), typeof(ControllerContext) });
            if (constructor == null)
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements,
                        adapterType.FullName,
                        typeof(ModelMetadata).FullName,
                        typeof(ControllerContext).FullName),
                    "adapterType");
            }

            return constructor;
        }

        private static void ValidateValidatableAdapterType(Type adapterType)
        {
            if (adapterType == null)
            {
                throw new ArgumentNullException("adapterType");
            }
            if (!typeof(ModelValidator).IsAssignableFrom(adapterType))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Common_TypeMustDriveFromType,
                        adapterType.FullName,
                        typeof(ModelValidator).FullName),
                    "adapterType");
            }
        }

        private static void ValidateValidatableModelType(Type modelType)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }
            if (!typeof(IValidatableObject).IsAssignableFrom(modelType))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Common_TypeMustDriveFromType,
                        modelType.FullName,
                        typeof(IValidatableObject).FullName),
                    "modelType");
            }
        }

        private static void ValidateValidatableFactory(DataAnnotationsValidatableObjectAdapterFactory factory)
        {
            if (factory == null)
            {
                throw new ArgumentNullException("factory");
            }
        }

        #endregion

        private static Dictionary<Type, DataAnnotationsModelValidationFactory> BuildAttributeFactoriesDictionary()
        {
            var dict = new Dictionary<Type, DataAnnotationsModelValidationFactory>();

            AddValidationAttributeAdapter(dict, typeof(RangeAttribute),
                (metadata, context, attribute) => new RangeAttributeAdapter(metadata, context, (RangeAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(RegularExpressionAttribute),
                (metadata, context, attribute) => new RegularExpressionAttributeAdapter(metadata, context, (RegularExpressionAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(RequiredAttribute),
                (metadata, context, attribute) => new RequiredAttributeAdapter(metadata, context, (RequiredAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(StringLengthAttribute),
                (metadata, context, attribute) => new StringLengthAttributeAdapter(metadata, context, (StringLengthAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(MaxLengthAttribute),
                (metadata, context, attribute) => new MaxLengthAttributeAdapter(metadata, context, (MaxLengthAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(MinLengthAttribute),
                (metadata, context, attribute) => new MinLengthAttributeAdapter(metadata, context, (MinLengthAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(MembershipPasswordAttribute),
                    (metadata, context, attribute) => new MembershipPasswordAttributeAdapter(metadata, context, (MembershipPasswordAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(DataAnnotationsCompareAttribute),
                    (metadata, context, attribute) => new CompareAttributeAdapter(metadata, context, (DataAnnotationsCompareAttribute)attribute));

            AddValidationAttributeAdapter(dict, typeof(FileExtensionsAttribute),
                   (metadata, context, attribute) => new FileExtensionsAttributeAdapter(metadata, context, (FileExtensionsAttribute)attribute));

            AddDataTypeAttributeAdapter(dict, typeof(CreditCardAttribute), "creditcard");
            AddDataTypeAttributeAdapter(dict, typeof(EmailAddressAttribute), "email");
            AddDataTypeAttributeAdapter(dict, typeof(PhoneAttribute), "phone");
            AddDataTypeAttributeAdapter(dict, typeof(UrlAttribute), "url");

            return dict;
        }

        private static void AddValidationAttributeAdapter(Dictionary<Type, DataAnnotationsModelValidationFactory> dictionary, Type validataionAttributeType, DataAnnotationsModelValidationFactory factory)
        {
            Contract.Assert(dictionary != null);
            if (validataionAttributeType != null)
            {
                dictionary.Add(validataionAttributeType, factory);
            }
        }

        private static void AddDataTypeAttributeAdapter(Dictionary<Type, DataAnnotationsModelValidationFactory> dictionary, Type attributeType, string ruleName)
        {
            AddValidationAttributeAdapter(
                dictionary,
                attributeType,
                (metadata, context, attribute) => new DataTypeAttributeAdapter(metadata, context, (DataTypeAttribute)attribute, ruleName));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DataErrorInfoModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;

namespace System.Web.Mvc
{
    public class DataErrorInfoModelValidatorProvider : ModelValidatorProvider
    {
        public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            return GetValidatorsImpl(metadata, context);
        }

        private static IEnumerable<ModelValidator> GetValidatorsImpl(ModelMetadata metadata, ControllerContext context)
        {
            // If the metadata describes a model that implements IDataErrorInfo, we should call its
            // Error property at the appropriate time.
            if (TypeImplementsIDataErrorInfo(metadata.ModelType))
            {
                yield return new DataErrorInfoClassModelValidator(metadata, context);
            }

            // If the metadata describes a property of a container that implements IDataErrorInfo,
            // we should call its Item indexer at the appropriate time.
            if (TypeImplementsIDataErrorInfo(metadata.ContainerType))
            {
                yield return new DataErrorInfoPropertyModelValidator(metadata, context);
            }
        }

        private static bool TypeImplementsIDataErrorInfo(Type type)
        {
            return typeof(IDataErrorInfo).IsAssignableFrom(type);
        }

        internal sealed class DataErrorInfoClassModelValidator : ModelValidator
        {
            public DataErrorInfoClassModelValidator(ModelMetadata metadata, ControllerContext controllerContext)
                : base(metadata, controllerContext)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                IDataErrorInfo castModel = Metadata.Model as IDataErrorInfo;
                if (castModel != null)
                {
                    string errorMessage = castModel.Error;
                    if (!String.IsNullOrEmpty(errorMessage))
                    {
                        return new ModelValidationResult[]
                        {
                            new ModelValidationResult() { Message = errorMessage }
                        };
                    }
                }
                return Enumerable.Empty<ModelValidationResult>();
            }
        }

        internal sealed class DataErrorInfoPropertyModelValidator : ModelValidator
        {
            public DataErrorInfoPropertyModelValidator(ModelMetadata metadata, ControllerContext controllerContext)
                : base(metadata, controllerContext)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                IDataErrorInfo castContainer = container as IDataErrorInfo;
                if (castContainer != null && !String.Equals(Metadata.PropertyName, "error", StringComparison.OrdinalIgnoreCase))
                {
                    string errorMessage = castContainer[Metadata.PropertyName];
                    if (!String.IsNullOrEmpty(errorMessage))
                    {
                        return new ModelValidationResult[]
                        {
                            new ModelValidationResult() { Message = errorMessage }
                        };
                    }
                }
                return Enumerable.Empty<ModelValidationResult>();
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DataTypeAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    /// <summary>
    /// A validation adapter that is used to map <see cref="DataTypeAttribute"/>'s to a single client side validation rule.
    /// </summary>
    internal class DataTypeAttributeAdapter : DataAnnotationsModelValidator
    {
        public DataTypeAttributeAdapter(ModelMetadata metadata, ControllerContext context, DataTypeAttribute attribute, string ruleName)
            : base(metadata, context, attribute)
        {
            if (String.IsNullOrEmpty(ruleName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "ruleName");
            }
            RuleName = ruleName;
        }

        public string RuleName { get; set; }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            yield return new ModelClientValidationRule
            {
                ValidationType = RuleName,
                ErrorMessage = ErrorMessage
            };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DataTypeUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    internal static class DataTypeUtil
    {
        private static readonly string CreditCardTypeName = DataType.CreditCard.ToString();
        private static readonly string CurrencyTypeName = DataType.Currency.ToString();
        private static readonly string DateTypeName = DataType.Date.ToString();
        private static readonly string DateTimeTypeName = DataType.DateTime.ToString();
        private static readonly string DurationTypeName = DataType.Duration.ToString();
        private static readonly string EmailAddressTypeName = DataType.EmailAddress.ToString();
        internal static readonly string HtmlTypeName = DataType.Html.ToString();
        private static readonly string ImageUrlTypeName = DataType.ImageUrl.ToString();
        private static readonly string MultiLineTextTypeName = DataType.MultilineText.ToString();
        private static readonly string PasswordTypeName = DataType.Password.ToString();
        private static readonly string PhoneNumberTypeName = DataType.PhoneNumber.ToString();
        private static readonly string PostalCodeTypeName = DataType.PostalCode.ToString();
        private static readonly string TextTypeName = DataType.Text.ToString();
        private static readonly string TimeTypeName = DataType.Time.ToString();
        private static readonly string UploadTypeName = DataType.Upload.ToString();
        private static readonly string UrlTypeName = DataType.Url.ToString();

        private static readonly Lazy<Dictionary<object, string>> _dataTypeToName = new Lazy<Dictionary<object, string>>(CreateDataTypeToName, isThreadSafe: true);

        // This is a faster version of GetDataTypeName(). It internally calls ToString() on the enum
        // value, which can be quite slow because of value verification.
        internal static string ToDataTypeName(this DataTypeAttribute attribute, Func<DataTypeAttribute, Boolean> isDataType = null)
        {
            if (isDataType == null)
            {
                isDataType = t => t.GetType().Equals(typeof(DataTypeAttribute));
            }

            // GetDataTypeName is virtual, so this is only safe if they haven't derived from DataTypeAttribute.
            // However, if they derive from DataTypeAttribute, they can help their own perf by overriding GetDataTypeName
            // and returning an appropriate string without invoking the ToString() on the enum.
            if (isDataType(attribute))
            {
                // Statically known dataTypes are handled separately for performance
                string name = KnownDataTypeToString(attribute.DataType);
                if (name == null)
                {
                    // Unknown types fallback to a dictionary lookup.
                    // Code running on .NET 4.5 will not enter this code for statically known data types.
                    // Versions of .NET greater than 4.5 will enter this code for any new data types added to those frameworks
                    _dataTypeToName.Value.TryGetValue(attribute.DataType, out name);
                }

                if (name != null)
                {
                    return name;
                }
            }

            return attribute.GetDataTypeName();
        }

        private static string KnownDataTypeToString(DataType dataType)
        {
            switch (dataType)
            {
                case DataType.CreditCard:
                    return CreditCardTypeName;
                case DataType.Currency:
                    return CurrencyTypeName;
                case DataType.Date:
                    return DateTypeName;
                case DataType.DateTime:
                    return DateTimeTypeName;
                case DataType.Duration:
                    return DurationTypeName;
                case DataType.EmailAddress:
                    return EmailAddressTypeName;
                case DataType.Html:
                    return HtmlTypeName;
                case DataType.ImageUrl:
                    return ImageUrlTypeName;
                case DataType.MultilineText:
                    return MultiLineTextTypeName;
                case DataType.Password:
                    return PasswordTypeName;
                case DataType.PhoneNumber:
                    return PhoneNumberTypeName;
                case DataType.PostalCode:
                    return PostalCodeTypeName;
                case DataType.Text:
                    return TextTypeName;
                case DataType.Time:
                    return TimeTypeName;
                case DataType.Upload:
                    return UploadTypeName;
                case DataType.Url:
                    return UrlTypeName;
            }

            return null;
        }

        private static Dictionary<object, string> CreateDataTypeToName()
        {
            Dictionary<object, string> dataTypeToName = new Dictionary<object, string>();
            foreach (DataType dataTypeValue in Enum.GetValues(typeof(DataType)))
            {
                // Don't add to the dictionary any of the statically known types.
                // This is a workingset size optimization.
                if (dataTypeValue != DataType.Custom && KnownDataTypeToString(dataTypeValue) == null)
                {
                    string name = Enum.GetName(typeof(DataType), dataTypeValue);
                    dataTypeToName[dataTypeValue] = name;
                }
            }

            return dataTypeToName;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DefaultControllerFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;
using System.Web.Routing;
using System.Web.SessionState;

namespace System.Web.Mvc
{
    public class DefaultControllerFactory : IControllerFactory
    {
        private static readonly ConcurrentDictionary<Type, SessionStateBehavior> _sessionStateCache = new ConcurrentDictionary<Type, SessionStateBehavior>();
        private static ControllerTypeCache _staticControllerTypeCache = new ControllerTypeCache();
        private IBuildManager _buildManager;
        private IResolver<IControllerActivator> _activatorResolver;
        private IControllerActivator _controllerActivator;
        private ControllerBuilder _controllerBuilder;
        private ControllerTypeCache _instanceControllerTypeCache;

        public DefaultControllerFactory()
            : this(null, null, null)
        {
        }

        public DefaultControllerFactory(IControllerActivator controllerActivator)
            : this(controllerActivator, null, null)
        {
        }

        internal DefaultControllerFactory(IControllerActivator controllerActivator, IResolver<IControllerActivator> activatorResolver, IDependencyResolver dependencyResolver)
        {
            if (controllerActivator != null)
            {
                _controllerActivator = controllerActivator;
            }
            else
            {
                _activatorResolver = activatorResolver ?? new SingleServiceResolver<IControllerActivator>(
                                                              () => null,
                                                              new DefaultControllerActivator(dependencyResolver),
                                                              "DefaultControllerFactory constructor");
            }
        }

        private IControllerActivator ControllerActivator
        {
            get
            {
                if (_controllerActivator != null)
                {
                    return _controllerActivator;
                }
                _controllerActivator = _activatorResolver.Current;
                return _controllerActivator;
            }
        }

        internal IBuildManager BuildManager
        {
            get
            {
                if (_buildManager == null)
                {
                    _buildManager = new BuildManagerWrapper();
                }
                return _buildManager;
            }
            set { _buildManager = value; }
        }

        internal ControllerBuilder ControllerBuilder
        {
            get { return _controllerBuilder ?? ControllerBuilder.Current; }
            set { _controllerBuilder = value; }
        }

        internal ControllerTypeCache ControllerTypeCache
        {
            get { return _instanceControllerTypeCache ?? _staticControllerTypeCache; }
            set { _instanceControllerTypeCache = value; }
        }

        internal static InvalidOperationException CreateAmbiguousControllerException(RouteBase route, string controllerName, ICollection<Type> matchingTypes)
        {
            // we need to generate an exception containing all the controller types
            StringBuilder typeList = new StringBuilder();
            foreach (Type matchedType in matchingTypes)
            {
                typeList.AppendLine();
                typeList.Append(matchedType.FullName);
            }

            string errorText;
            Route castRoute = route as Route;
            if (castRoute != null)
            {
                errorText = String.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ControllerNameAmbiguous_WithRouteUrl,
                                          controllerName, castRoute.Url, typeList, Environment.NewLine);
            }
            else
            {
                errorText = String.Format(CultureInfo.CurrentCulture, MvcResources.DefaultControllerFactory_ControllerNameAmbiguous_WithoutRouteUrl,
                                          controllerName, typeList, Environment.NewLine);
            }

            return new InvalidOperationException(errorText);
        }

        private static InvalidOperationException CreateDirectRouteAmbiguousControllerException(ICollection<Type> matchingTypes)
        {
            // we need to generate an exception containing all the controller types
            StringBuilder typeList = new StringBuilder();
            foreach (Type matchedType in matchingTypes)
            {
                typeList.AppendLine();
                typeList.Append(matchedType.FullName);
            }

            string errorText = String.Format(
                CultureInfo.CurrentCulture,
                MvcResources.DefaultControllerFactory_DirectRouteAmbiguous,
                typeList,
                Environment.NewLine);

            return new InvalidOperationException(errorText);
        }

        public virtual IController CreateController(RequestContext requestContext, string controllerName)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }

            if (String.IsNullOrEmpty(controllerName) &&
                (requestContext.RouteData == null || !requestContext.RouteData.HasDirectRouteMatch()))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
            }

            Type controllerType = GetControllerType(requestContext, controllerName);
            IController controller = GetControllerInstance(requestContext, controllerType);
            return controller;
        }

        protected internal virtual IController GetControllerInstance(RequestContext requestContext, Type controllerType)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (controllerType == null)
            {
                throw new HttpException(404,
                                        String.Format(
                                            CultureInfo.CurrentCulture,
                                            MvcResources.DefaultControllerFactory_NoControllerFound,
                                            requestContext.HttpContext.Request.Path));
            }
            if (!typeof(IController).IsAssignableFrom(controllerType))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DefaultControllerFactory_TypeDoesNotSubclassControllerBase,
                        controllerType),
                    "controllerType");
            }

            return ControllerActivator.Create(requestContext, controllerType);
        }

        protected internal virtual SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, Type controllerType)
        {
            if (controllerType == null)
            {
                return SessionStateBehavior.Default;
            }

            return _sessionStateCache.GetOrAdd(
                controllerType,
                type =>
                {
                    var attr = type.GetCustomAttributes(typeof(SessionStateAttribute), inherit: true)
                        .OfType<SessionStateAttribute>()
                        .FirstOrDefault();

                    return (attr != null) ? attr.Behavior : SessionStateBehavior.Default;
                });
        }

        protected internal virtual Type GetControllerType(RequestContext requestContext, string controllerName)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }

            if (String.IsNullOrEmpty(controllerName) &&
                (requestContext.RouteData == null || !requestContext.RouteData.HasDirectRouteMatch()))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
            }

            RouteData routeData = requestContext.RouteData;
            if (routeData != null && routeData.HasDirectRouteMatch())
            {
                return GetControllerTypeFromDirectRoute(routeData);
            }

            // first search in the current route's namespace collection
            object routeNamespacesObj;
            Type match;
            if (routeData != null && routeData.DataTokens.TryGetValue(RouteDataTokenKeys.Namespaces, out routeNamespacesObj))
            {
                IEnumerable<string> routeNamespaces = routeNamespacesObj as IEnumerable<string>;
                if (routeNamespaces != null && routeNamespaces.Any())
                {
                    HashSet<string> namespaceHash = new HashSet<string>(routeNamespaces, StringComparer.OrdinalIgnoreCase);
                    match = GetControllerTypeWithinNamespaces(routeData.Route, controllerName, namespaceHash);

                    // the UseNamespaceFallback key might not exist, in which case its value is implicitly "true"
                    if (match != null || false.Equals(routeData.DataTokens[RouteDataTokenKeys.UseNamespaceFallback]))
                    {
                        // got a match or the route requested we stop looking
                        return match;
                    }
                }
            }

            // then search in the application's default namespace collection
            RouteBase route = routeData == null ? null : routeData.Route;
            if (ControllerBuilder.DefaultNamespaces.Count > 0)
            {
                HashSet<string> namespaceDefaults = new HashSet<string>(ControllerBuilder.DefaultNamespaces, StringComparer.OrdinalIgnoreCase);
                match = GetControllerTypeWithinNamespaces(route, controllerName, namespaceDefaults);
                if (match != null)
                {
                    return match;
                }
            }

            // if all else fails, search every namespace
            return GetControllerTypeWithinNamespaces(route, controllerName, null /* namespaces */);
        }

        private static Type GetControllerTypeFromDirectRoute(RouteData routeData)
        {
            Contract.Assert(routeData != null);

            var matchingRouteDatas = routeData.GetDirectRouteMatches();

            List<Type> controllerTypes = new List<Type>();
            foreach (var directRouteData in matchingRouteDatas)
            {
                if (directRouteData != null)
                {
                    Type controllerType = directRouteData.GetTargetControllerType();
                    if (controllerType == null)
                    {
                        // We don't expect this to happen, but it could happen if some code messes with the 
                        // route data tokens and removes the key we're looking for. 
                        throw new InvalidOperationException(MvcResources.DirectRoute_MissingControllerType);
                    }

                    if (!controllerTypes.Contains(controllerType))
                    {
                        controllerTypes.Add(controllerType);
                    }
                }
            }

            // We only want to handle the case where all matched direct routes refer to the same controller.
            // Handling the multiple-controllers case would put attribute routing down a totally different
            // path than traditional routing.
            if (controllerTypes.Count == 0)
            {
                return null;
            }
            else if (controllerTypes.Count == 1)
            {
                return controllerTypes[0];
            }
            else
            {
                throw CreateDirectRouteAmbiguousControllerException(controllerTypes);
            }
        }

        private Type GetControllerTypeWithinNamespaces(RouteBase route, string controllerName, HashSet<string> namespaces)
        {
            // Once the master list of controllers has been created we can quickly index into it
            ControllerTypeCache.EnsureInitialized(BuildManager);

            ICollection<Type> matchingTypes = ControllerTypeCache.GetControllerTypes(controllerName, namespaces);
            switch (matchingTypes.Count)
            {
                case 0:
                    // no matching types
                    return null;

                case 1:
                    // single matching type
                    return matchingTypes.First();

                default:
                    // multiple matching types
                    throw CreateAmbiguousControllerException(route, controllerName, matchingTypes);
            }
        }

        public virtual void ReleaseController(IController controller)
        {
            IDisposable disposable = controller as IDisposable;
            if (disposable != null)
            {
                disposable.Dispose();
            }
        }

        internal IReadOnlyList<Type> GetControllerTypes()
        {
            ControllerTypeCache.EnsureInitialized(BuildManager);
            return ControllerTypeCache.GetControllerTypes();
        }

        SessionStateBehavior IControllerFactory.GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (String.IsNullOrEmpty(controllerName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
            }

            Type controllerType = GetControllerType(requestContext, controllerName);
            return GetControllerSessionBehavior(requestContext, controllerType);
        }

        private class DefaultControllerActivator : IControllerActivator
        {
            private Func<IDependencyResolver> _resolverThunk;

            public DefaultControllerActivator()
                : this(null)
            {
            }

            public DefaultControllerActivator(IDependencyResolver resolver)
            {
                if (resolver == null)
                {
                    _resolverThunk = () => DependencyResolver.Current;
                }
                else
                {
                    _resolverThunk = () => resolver;
                }
            }

            public IController Create(RequestContext requestContext, Type controllerType)
            {
                try
                {
                    return (IController)(_resolverThunk().GetService(controllerType) ?? Activator.CreateInstance(controllerType));
                }
                catch (Exception ex)
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            MvcResources.DefaultControllerFactory_ErrorCreatingController,
                            controllerType),
                        ex);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DefaultModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class DefaultModelBinder : IModelBinder
    {
        private static string _resourceClassKey;
        private ModelBinderDictionary _binders;

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "Property is settable so that the dictionary can be provided for unit testing purposes.")]
        protected internal ModelBinderDictionary Binders
        {
            get
            {
                if (_binders == null)
                {
                    _binders = ModelBinders.Binders;
                }
                return _binders;
            }
            set { _binders = value; }
        }

        public static string ResourceClassKey
        {
            get { return _resourceClassKey ?? String.Empty; }
            set { _resourceClassKey = value; }
        }

        private static void AddValueRequiredMessageToModelState(ControllerContext controllerContext, ModelStateDictionary modelState, string modelStateKey, Type elementType, object value)
        {
            if (value == null && !TypeHelpers.TypeAllowsNullValue(elementType) && modelState.IsValidField(modelStateKey))
            {
                modelState.AddModelError(modelStateKey, GetValueRequiredResource(controllerContext));
            }
        }

        internal void BindComplexElementalModel(ControllerContext controllerContext, ModelBindingContext bindingContext, object model)
        {
            // need to replace the property filter + model object and create an inner binding context
            ModelBindingContext newBindingContext = CreateComplexElementalModelBindingContext(controllerContext, bindingContext, model);

            // validation
            if (OnModelUpdating(controllerContext, newBindingContext))
            {
                BindProperties(controllerContext, newBindingContext);
                OnModelUpdated(controllerContext, newBindingContext);
            }
        }

        internal object BindComplexModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            object model = bindingContext.Model;
            Type modelType = bindingContext.ModelType;

            // if we're being asked to create an array, create a list instead, then coerce to an array after the list is created
            if (model == null && modelType.IsArray)
            {
                Type elementType = modelType.GetElementType();
                Type listType = typeof(List<>).MakeGenericType(elementType);
                object collection = CreateModel(controllerContext, bindingContext, listType);

                ModelBindingContext arrayBindingContext = new ModelBindingContext()
                {
                    ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => collection, listType),
                    ModelName = bindingContext.ModelName,
                    ModelState = bindingContext.ModelState,
                    PropertyFilter = bindingContext.PropertyFilter,
                    ValueProvider = bindingContext.ValueProvider
                };
                IList list = (IList)UpdateCollection(controllerContext, arrayBindingContext, elementType);

                if (list == null)
                {
                    return null;
                }

                Array array = Array.CreateInstance(elementType, list.Count);
                list.CopyTo(array, 0);
                return array;
            }

            if (model == null)
            {
                model = CreateModel(controllerContext, bindingContext, modelType);
            }

            // special-case IDictionary<,> and ICollection<>
            Type dictionaryType = TypeHelpers.ExtractGenericInterface(modelType, typeof(IDictionary<,>));
            if (dictionaryType != null)
            {
                Type[] genericArguments = dictionaryType.GetGenericArguments();
                Type keyType = genericArguments[0];
                Type valueType = genericArguments[1];

                ModelBindingContext dictionaryBindingContext = new ModelBindingContext()
                {
                    ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, modelType),
                    ModelName = bindingContext.ModelName,
                    ModelState = bindingContext.ModelState,
                    PropertyFilter = bindingContext.PropertyFilter,
                    ValueProvider = bindingContext.ValueProvider
                };
                object dictionary = UpdateDictionary(controllerContext, dictionaryBindingContext, keyType, valueType);
                return dictionary;
            }

            Type enumerableType = TypeHelpers.ExtractGenericInterface(modelType, typeof(IEnumerable<>));
            if (enumerableType != null)
            {
                Type elementType = enumerableType.GetGenericArguments()[0];

                Type collectionType = typeof(ICollection<>).MakeGenericType(elementType);
                if (collectionType.IsInstanceOfType(model))
                {
                    ModelBindingContext collectionBindingContext = new ModelBindingContext()
                    {
                        ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, modelType),
                        ModelName = bindingContext.ModelName,
                        ModelState = bindingContext.ModelState,
                        PropertyFilter = bindingContext.PropertyFilter,
                        ValueProvider = bindingContext.ValueProvider
                    };
                    object collection = UpdateCollection(controllerContext, collectionBindingContext, elementType);
                    return collection;
                }
            }

            // otherwise, just update the properties on the complex type
            BindComplexElementalModel(controllerContext, bindingContext, model);
            return model;
        }

        public virtual object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            RuntimeHelpers.EnsureSufficientExecutionStack();

            if (bindingContext == null)
            {
                throw new ArgumentNullException("bindingContext");
            }

            bool performedFallback = false;

            if (!String.IsNullOrEmpty(bindingContext.ModelName) && !bindingContext.ValueProvider.ContainsPrefix(bindingContext.ModelName))
            {
                // We couldn't find any entry that began with the prefix. If this is the top-level element, fall back
                // to the empty prefix.
                if (bindingContext.FallbackToEmptyPrefix)
                {
                    bindingContext = new ModelBindingContext()
                    {
                        ModelMetadata = bindingContext.ModelMetadata,
                        ModelState = bindingContext.ModelState,
                        PropertyFilter = bindingContext.PropertyFilter,
                        ValueProvider = bindingContext.ValueProvider
                    };
                    performedFallback = true;
                }
                else
                {
                    return null;
                }
            }

            // Simple model = int, string, etc.; determined by calling TypeConverter.CanConvertFrom(typeof(string))
            // or by seeing if a value in the request exactly matches the name of the model we're binding.
            // Complex type = everything else.
            if (!performedFallback)
            {
                bool performRequestValidation = ShouldPerformRequestValidation(controllerContext, bindingContext);
                ValueProviderResult valueProviderResult = bindingContext.UnvalidatedValueProvider.GetValue(bindingContext.ModelName, skipValidation: !performRequestValidation);
                if (valueProviderResult != null)
                {
                    return BindSimpleModel(controllerContext, bindingContext, valueProviderResult);
                }
            }
            if (!bindingContext.ModelMetadata.IsComplexType)
            {
                return null;
            }

            return BindComplexModel(controllerContext, bindingContext);
        }

        private void BindProperties(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            PropertyDescriptorCollection properties = GetModelProperties(controllerContext, bindingContext);
            Predicate<string> propertyFilter = bindingContext.PropertyFilter;

            // Loop is a performance sensitive codepath so avoid using enumerators.
            for (int i = 0; i < properties.Count; i++)
            {
                PropertyDescriptor property = properties[i];
                if (ShouldUpdateProperty(property, propertyFilter))
                {
                    BindProperty(controllerContext, bindingContext, property);
                }
            }
        }

        protected virtual void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor)
        {
            // need to skip properties that aren't part of the request, else we might hit a StackOverflowException
            string fullPropertyKey = CreateSubPropertyName(bindingContext.ModelName, propertyDescriptor.Name);
            if (!bindingContext.ValueProvider.ContainsPrefix(fullPropertyKey))
            {
                return;
            }

            // call into the property's model binder
            IModelBinder propertyBinder = Binders.GetBinder(propertyDescriptor.PropertyType);
            object originalPropertyValue = propertyDescriptor.GetValue(bindingContext.Model);
            ModelMetadata propertyMetadata = bindingContext.PropertyMetadata[propertyDescriptor.Name];
            propertyMetadata.Model = originalPropertyValue;
            ModelBindingContext innerBindingContext = new ModelBindingContext()
            {
                ModelMetadata = propertyMetadata,
                ModelName = fullPropertyKey,
                ModelState = bindingContext.ModelState,
                ValueProvider = bindingContext.ValueProvider
            };
            object newPropertyValue = GetPropertyValue(controllerContext, innerBindingContext, propertyDescriptor, propertyBinder);
            propertyMetadata.Model = newPropertyValue;

            // validation
            ModelState modelState = bindingContext.ModelState[fullPropertyKey];
            if (modelState == null || modelState.Errors.Count == 0)
            {
                if (OnPropertyValidating(controllerContext, bindingContext, propertyDescriptor, newPropertyValue))
                {
                    SetProperty(controllerContext, bindingContext, propertyDescriptor, newPropertyValue);
                    OnPropertyValidated(controllerContext, bindingContext, propertyDescriptor, newPropertyValue);
                }
            }
            else
            {
                SetProperty(controllerContext, bindingContext, propertyDescriptor, newPropertyValue);

                // Convert FormatExceptions (type conversion failures) into InvalidValue messages
                foreach (ModelError error in modelState.Errors.Where(err => String.IsNullOrEmpty(err.ErrorMessage) && err.Exception != null).ToList())
                {
                    for (Exception exception = error.Exception; exception != null; exception = exception.InnerException)
                    {
                        // We only consider "known" type of exception and do not make too aggressive changes here
                        if (exception is FormatException || exception is OverflowException)
                        {
                            string displayName = propertyMetadata.GetDisplayName();
                            string errorMessageTemplate = GetValueInvalidResource(controllerContext);
                            string errorMessage = String.Format(CultureInfo.CurrentCulture, errorMessageTemplate, modelState.Value.AttemptedValue, displayName);
                            modelState.Errors.Remove(error);
                            modelState.Errors.Add(errorMessage);
                            break;
                        }
                    }
                }
            }
        }

        internal object BindSimpleModel(ControllerContext controllerContext, ModelBindingContext bindingContext, ValueProviderResult valueProviderResult)
        {
            bindingContext.ModelState.SetModelValue(bindingContext.ModelName, valueProviderResult);

            // if the value provider returns an instance of the requested data type, we can just short-circuit
            // the evaluation and return that instance
            if (bindingContext.ModelType.IsInstanceOfType(valueProviderResult.RawValue))
            {
                return valueProviderResult.RawValue;
            }

            // since a string is an IEnumerable<char>, we want it to skip the two checks immediately following
            if (bindingContext.ModelType != typeof(string))
            {
                // conversion results in 3 cases, as below
                if (bindingContext.ModelType.IsArray)
                {
                    // case 1: user asked for an array
                    // ValueProviderResult.ConvertTo() understands array types, so pass in the array type directly
                    object modelArray = ConvertProviderResult(bindingContext.ModelState, bindingContext.ModelName, valueProviderResult, bindingContext.ModelType);
                    return modelArray;
                }

                Type enumerableType = TypeHelpers.ExtractGenericInterface(bindingContext.ModelType, typeof(IEnumerable<>));
                if (enumerableType != null)
                {
                    // case 2: user asked for a collection rather than an array
                    // need to call ConvertTo() on the array type, then copy the array to the collection
                    object modelCollection = CreateModel(controllerContext, bindingContext, bindingContext.ModelType);
                    Type elementType = enumerableType.GetGenericArguments()[0];
                    Type arrayType = elementType.MakeArrayType();
                    object modelArray = ConvertProviderResult(bindingContext.ModelState, bindingContext.ModelName, valueProviderResult, arrayType);

                    Type collectionType = typeof(ICollection<>).MakeGenericType(elementType);
                    if (collectionType.IsInstanceOfType(modelCollection))
                    {
                        CollectionHelpers.ReplaceCollection(elementType, modelCollection, modelArray);
                    }
                    return modelCollection;
                }
            }

            // case 3: user asked for an individual element
            object model = ConvertProviderResult(bindingContext.ModelState, bindingContext.ModelName, valueProviderResult, bindingContext.ModelType);
            return model;
        }

        private static bool CanUpdateReadonlyTypedReference(Type type)
        {
            // value types aren't strictly immutable, but because they have copy-by-value semantics
            // we can't update a value type that is marked readonly
            if (type.IsValueType)
            {
                return false;
            }

            // arrays are mutable, but because we can't change their length we shouldn't try
            // to update an array that is referenced readonly
            if (type.IsArray)
            {
                return false;
            }

            // special-case known common immutable types
            if (type == typeof(string))
            {
                return false;
            }

            return true;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Mvc.ValueProviderResult.ConvertTo(System.Type)", Justification = "The target object should make the correct culture determination, not this method.")]
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We're recording this exception so that we can act on it later.")]
        private static object ConvertProviderResult(ModelStateDictionary modelState, string modelStateKey, ValueProviderResult valueProviderResult, Type destinationType)
        {
            try
            {
                object convertedValue = valueProviderResult.ConvertTo(destinationType);
                return convertedValue;
            }
            catch (Exception ex)
            {
                modelState.AddModelError(modelStateKey, ex);
                return null;
            }
        }

        internal ModelBindingContext CreateComplexElementalModelBindingContext(ControllerContext controllerContext, ModelBindingContext bindingContext, object model)
        {
            BindAttribute bindAttr = (BindAttribute)GetTypeDescriptor(controllerContext, bindingContext).GetAttributes()[typeof(BindAttribute)];
            Predicate<string> newPropertyFilter = (bindAttr != null)
                                                      ? propertyName => bindAttr.IsPropertyAllowed(propertyName) && bindingContext.PropertyFilter(propertyName)
                                                      : bindingContext.PropertyFilter;

            ModelBindingContext newBindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, bindingContext.ModelType),
                ModelName = bindingContext.ModelName,
                ModelState = bindingContext.ModelState,
                PropertyFilter = newPropertyFilter,
                ValueProvider = bindingContext.ValueProvider
            };

            return newBindingContext;
        }

        protected virtual object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType)
        {
            // fallback to the type's default constructor
            Type typeToCreate = modelType;

            // we can understand some collection interfaces, e.g. IList<>, IDictionary<,>
            if (modelType.IsGenericType)
            {
                Type genericTypeDefinition = modelType.GetGenericTypeDefinition();
                if (genericTypeDefinition == typeof(IDictionary<,>))
                {
                    typeToCreate = typeof(Dictionary<,>).MakeGenericType(modelType.GetGenericArguments());
                }
                else if (genericTypeDefinition == typeof(IEnumerable<>) || genericTypeDefinition == typeof(ICollection<>) || genericTypeDefinition == typeof(IList<>))
                {
                    typeToCreate = typeof(List<>).MakeGenericType(modelType.GetGenericArguments());
                }
            }

            try
            {
                return Activator.CreateInstance(typeToCreate);
            }
            catch (MissingMethodException exception)
            {
                // Ensure thrown exception contains the type name.  Might be down a few levels.
                MissingMethodException replacementException =
                    TypeHelpers.EnsureDebuggableException(exception, typeToCreate.FullName);
                if (replacementException != null)
                {
                    throw replacementException;
                }

                throw;
            }
        }

        protected static string CreateSubIndexName(string prefix, int index)
        {
            return String.Format(CultureInfo.InvariantCulture, "{0}[{1}]", prefix, index);
        }

        protected static string CreateSubIndexName(string prefix, string index)
        {
            return String.Format(CultureInfo.InvariantCulture, "{0}[{1}]", prefix, index);
        }

        protected internal static string CreateSubPropertyName(string prefix, string propertyName)
        {
            if (String.IsNullOrEmpty(prefix))
            {
                return propertyName;
            }
            else if (String.IsNullOrEmpty(propertyName))
            {
                return prefix;
            }
            else
            {
                return prefix + "." + propertyName;
            }
        }

        protected IEnumerable<PropertyDescriptor> GetFilteredModelProperties(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            // Performance note: Retain for compatibility only. Faster version inlined
            PropertyDescriptorCollection properties = GetModelProperties(controllerContext, bindingContext);
            Predicate<string> propertyFilter = bindingContext.PropertyFilter;

            return from PropertyDescriptor property in properties
                   where ShouldUpdateProperty(property, propertyFilter)
                   select property;
        }

        [SuppressMessage("Microsoft.Globalization", "CA1304:SpecifyCultureInfo", MessageId = "System.Web.Mvc.ValueProviderResult.ConvertTo(System.Type)", Justification = "ValueProviderResult already handles culture conversion appropriately.")]
        private static void GetIndexes(ModelBindingContext bindingContext, out bool stopOnIndexNotFound, out IEnumerable<string> indexes)
        {
            string indexKey = CreateSubPropertyName(bindingContext.ModelName, "index");
            ValueProviderResult valueProviderResult = bindingContext.ValueProvider.GetValue(indexKey);

            if (valueProviderResult != null)
            {
                string[] indexesArray = valueProviderResult.ConvertTo(typeof(string[])) as string[];
                if (indexesArray != null)
                {
                    stopOnIndexNotFound = false;
                    indexes = indexesArray;
                    return;
                }
            }

            // just use a simple zero-based system
            stopOnIndexNotFound = true;
            indexes = GetZeroBasedIndexes();
        }

        protected virtual PropertyDescriptorCollection GetModelProperties(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            return GetTypeDescriptor(controllerContext, bindingContext).GetProperties();
        }

        protected virtual object GetPropertyValue(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, IModelBinder propertyBinder)
        {
            object value = propertyBinder.BindModel(controllerContext, bindingContext);

            if (bindingContext.ModelMetadata.ConvertEmptyStringToNull && Equals(value, String.Empty))
            {
                return null;
            }

            return value;
        }

        protected virtual ICustomTypeDescriptor GetTypeDescriptor(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            return TypeDescriptorHelper.Get(bindingContext.ModelType);
        }

        // If the user specified a ResourceClassKey try to load the resource they specified.
        // If the class key is invalid, an exception will be thrown.
        // If the class key is valid but the resource is not found, it returns null, in which
        // case it will fall back to the MVC default error message.
        private static string GetUserResourceString(ControllerContext controllerContext, string resourceName)
        {
            string result = null;

            if (!String.IsNullOrEmpty(ResourceClassKey) && (controllerContext != null) && (controllerContext.HttpContext != null))
            {
                result = controllerContext.HttpContext.GetGlobalResourceObject(ResourceClassKey, resourceName, CultureInfo.CurrentUICulture) as string;
            }

            return result;
        }

        private static string GetValueInvalidResource(ControllerContext controllerContext)
        {
            return GetUserResourceString(controllerContext, "PropertyValueInvalid") ?? MvcResources.DefaultModelBinder_ValueInvalid;
        }

        private static string GetValueRequiredResource(ControllerContext controllerContext)
        {
            return GetUserResourceString(controllerContext, "PropertyValueRequired") ?? MvcResources.DefaultModelBinder_ValueRequired;
        }

        private static IEnumerable<string> GetZeroBasedIndexes()
        {
            int i = 0;
            while (true)
            {
                yield return i.ToString(CultureInfo.InvariantCulture);
                i++;
            }
        }

        protected static bool IsModelValid(ModelBindingContext bindingContext)
        {
            if (bindingContext == null)
            {
                throw new ArgumentNullException("bindingContext");
            }
            if (String.IsNullOrEmpty(bindingContext.ModelName))
            {
                return bindingContext.ModelState.IsValid;
            }
            return bindingContext.ModelState.IsValidField(bindingContext.ModelName);
        }

        protected virtual void OnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            Dictionary<string, bool> startedValid = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

            foreach (ModelValidationResult validationResult in ModelValidator.GetModelValidator(bindingContext.ModelMetadata, controllerContext).Validate(null))
            {
                string subPropertyName = CreateSubPropertyName(bindingContext.ModelName, validationResult.MemberName);

                if (!startedValid.ContainsKey(subPropertyName))
                {
                    startedValid[subPropertyName] = bindingContext.ModelState.IsValidField(subPropertyName);
                }

                if (startedValid[subPropertyName])
                {
                    bindingContext.ModelState.AddModelError(subPropertyName, validationResult.Message);
                }
            }
        }

        protected virtual bool OnModelUpdating(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            // default implementation does nothing
            return true;
        }

        protected virtual void OnPropertyValidated(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, object value)
        {
            // default implementation does nothing
        }

        protected virtual bool OnPropertyValidating(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, object value)
        {
            // default implementation does nothing
            return true;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We're recording this exception so that we can act on it later.")]
        protected virtual void SetProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor propertyDescriptor, object value)
        {
            ModelMetadata propertyMetadata = bindingContext.PropertyMetadata[propertyDescriptor.Name];
            propertyMetadata.Model = value;
            string modelStateKey = CreateSubPropertyName(bindingContext.ModelName, propertyMetadata.PropertyName);

            // If the value is null, and the validation system can find a Required validator for
            // us, we'd prefer to run it before we attempt to set the value; otherwise, property
            // setters which throw on null (f.e., Entity Framework properties which are backed by
            // non-nullable strings in the DB) will get their error message in ahead of us.
            //
            // We are effectively using the special validator -- Required -- as a helper to the
            // binding system, which is why this code is here instead of in the Validating/Validated
            // methods, which are really the old-school validation hooks.
            if (value == null && bindingContext.ModelState.IsValidField(modelStateKey))
            {
                ModelValidator requiredValidator = ModelValidatorProviders.Providers.GetValidators(propertyMetadata, controllerContext).Where(v => v.IsRequired).FirstOrDefault();
                if (requiredValidator != null)
                {
                    foreach (ModelValidationResult validationResult in requiredValidator.Validate(bindingContext.Model))
                    {
                        bindingContext.ModelState.AddModelError(modelStateKey, validationResult.Message);
                    }
                }
            }

            bool isNullValueOnNonNullableType =
                value == null &&
                !TypeHelpers.TypeAllowsNullValue(propertyDescriptor.PropertyType);

            // Try to set a value into the property unless we know it will fail (read-only
            // properties and null values with non-nullable types)
            if (!propertyDescriptor.IsReadOnly && !isNullValueOnNonNullableType)
            {
                try
                {
                    propertyDescriptor.SetValue(bindingContext.Model, value);
                }
                catch (Exception ex)
                {
                    // Only add if we're not already invalid
                    if (bindingContext.ModelState.IsValidField(modelStateKey))
                    {
                        bindingContext.ModelState.AddModelError(modelStateKey, ex);
                    }
                }
            }

            // Last chance for an error on null values with non-nullable types, we'll use
            // the default "A value is required." message.
            if (isNullValueOnNonNullableType && bindingContext.ModelState.IsValidField(modelStateKey))
            {
                bindingContext.ModelState.AddModelError(modelStateKey, GetValueRequiredResource(controllerContext));
            }
        }

        private static bool ShouldPerformRequestValidation(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            if (controllerContext == null || controllerContext.Controller == null || bindingContext == null || bindingContext.ModelMetadata == null)
            {
                // To make unit testing easier, if the caller hasn't specified enough contextual information we just default
                // to always pulling the data from a collection that goes through request validation.
                return true;
            }

            // We should perform request validation only if both the controller and the model ask for it. This is the
            // default behavior for both. If either the controller (via [ValidateInput(false)]) or the model (via [AllowHtml])
            // opts out, we don't validate.
            return (controllerContext.Controller.ValidateRequest && bindingContext.ModelMetadata.RequestValidationEnabled);
        }

        private static bool ShouldUpdateProperty(PropertyDescriptor property, Predicate<string> propertyFilter)
        {
            if (property.IsReadOnly && !CanUpdateReadonlyTypedReference(property.PropertyType))
            {
                return false;
            }

            // if this property is rejected by the filter, move on
            if (!propertyFilter(property.Name))
            {
                return false;
            }

            // otherwise, allow
            return true;
        }

        internal object UpdateCollection(ControllerContext controllerContext, ModelBindingContext bindingContext, Type elementType)
        {
            bool stopOnIndexNotFound;
            IEnumerable<string> indexes;
            GetIndexes(bindingContext, out stopOnIndexNotFound, out indexes);
            IModelBinder elementBinder = Binders.GetBinder(elementType);

            // build up a list of items from the request
            List<object> modelList = new List<object>();
            foreach (string currentIndex in indexes)
            {
                string subIndexKey = CreateSubIndexName(bindingContext.ModelName, currentIndex);
                if (!bindingContext.ValueProvider.ContainsPrefix(subIndexKey))
                {
                    if (stopOnIndexNotFound)
                    {
                        // we ran out of elements to pull
                        break;
                    }
                    else
                    {
                        continue;
                    }
                }

                ModelBindingContext innerContext = new ModelBindingContext()
                {
                    ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, elementType),
                    ModelName = subIndexKey,
                    ModelState = bindingContext.ModelState,
                    PropertyFilter = bindingContext.PropertyFilter,
                    ValueProvider = bindingContext.ValueProvider
                };
                object thisElement = elementBinder.BindModel(controllerContext, innerContext);

                // we need to merge model errors up
                AddValueRequiredMessageToModelState(controllerContext, bindingContext.ModelState, subIndexKey, elementType, thisElement);
                modelList.Add(thisElement);
            }

            // if there weren't any elements at all in the request, just return
            if (modelList.Count == 0)
            {
                return null;
            }

            // replace the original collection
            object collection = bindingContext.Model;
            CollectionHelpers.ReplaceCollection(elementType, collection, modelList);
            return collection;
        }

        internal object UpdateDictionary(ControllerContext controllerContext, ModelBindingContext bindingContext, Type keyType, Type valueType)
        {
            bool stopOnIndexNotFound;
            IEnumerable<string> indexes;
            GetIndexes(bindingContext, out stopOnIndexNotFound, out indexes);

            IModelBinder keyBinder = Binders.GetBinder(keyType);
            IModelBinder valueBinder = Binders.GetBinder(valueType);

            // build up a list of items from the request
            List<KeyValuePair<object, object>> modelList = new List<KeyValuePair<object, object>>();
            foreach (string currentIndex in indexes)
            {
                string subIndexKey = CreateSubIndexName(bindingContext.ModelName, currentIndex);
                string keyFieldKey = CreateSubPropertyName(subIndexKey, "key");
                string valueFieldKey = CreateSubPropertyName(subIndexKey, "value");

                if (!(bindingContext.ValueProvider.ContainsPrefix(keyFieldKey) && bindingContext.ValueProvider.ContainsPrefix(valueFieldKey)))
                {
                    if (stopOnIndexNotFound)
                    {
                        // we ran out of elements to pull
                        break;
                    }
                    else
                    {
                        continue;
                    }
                }

                // bind the key
                ModelBindingContext keyBindingContext = new ModelBindingContext()
                {
                    ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, keyType),
                    ModelName = keyFieldKey,
                    ModelState = bindingContext.ModelState,
                    ValueProvider = bindingContext.ValueProvider
                };
                object thisKey = keyBinder.BindModel(controllerContext, keyBindingContext);

                // we need to merge model errors up
                AddValueRequiredMessageToModelState(controllerContext, bindingContext.ModelState, keyFieldKey, keyType, thisKey);
                if (!keyType.IsInstanceOfType(thisKey))
                {
                    // we can't add an invalid key, so just move on
                    continue;
                }

                // bind the value
                modelList.Add(CreateEntryForModel(controllerContext, bindingContext, valueType, valueBinder, valueFieldKey, thisKey));
            }

            // Let's try another method
            if (modelList.Count == 0)
            {
                IEnumerableValueProvider enumerableValueProvider = bindingContext.ValueProvider as IEnumerableValueProvider;
                if (enumerableValueProvider != null)
                {
                    IDictionary<string, string> keys = enumerableValueProvider.GetKeysFromPrefix(bindingContext.ModelName);
                    foreach (var thisKey in keys)
                    {
                        modelList.Add(CreateEntryForModel(controllerContext, bindingContext, valueType, valueBinder, thisKey.Value, thisKey.Key));
                    }
                }
            }

            // replace the original collection
            object dictionary = bindingContext.Model;
            CollectionHelpers.ReplaceDictionary(keyType, valueType, dictionary, modelList);
            return dictionary;
        }

        private static KeyValuePair<object, object> CreateEntryForModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type valueType, IModelBinder valueBinder, string modelName, object modelKey)
        {
            ModelBindingContext valueBindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, valueType),
                ModelName = modelName,
                ModelState = bindingContext.ModelState,
                PropertyFilter = bindingContext.PropertyFilter,
                ValueProvider = bindingContext.ValueProvider
            };
            object thisValue = valueBinder.BindModel(controllerContext, valueBindingContext);
            AddValueRequiredMessageToModelState(controllerContext, bindingContext.ModelState, modelName, valueType, thisValue);
            return new KeyValuePair<object, object>(modelKey, thisValue);
        }

        // This helper type is used because we're working with strongly-typed collections, but we don't know the Ts
        // ahead of time. By using the generic methods below, we can consolidate the collection-specific code in a
        // single helper type rather than having reflection-based calls spread throughout the DefaultModelBinder type.
        // There is a single point of entry to each of the methods below, so they're fairly simple to maintain.

        private static class CollectionHelpers
        {
            private static readonly MethodInfo _replaceCollectionMethod = typeof(CollectionHelpers).GetMethod("ReplaceCollectionImpl", BindingFlags.Static | BindingFlags.NonPublic);
            private static readonly MethodInfo _replaceDictionaryMethod = typeof(CollectionHelpers).GetMethod("ReplaceDictionaryImpl", BindingFlags.Static | BindingFlags.NonPublic);

            [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
            public static void ReplaceCollection(Type collectionType, object collection, object newContents)
            {
                MethodInfo targetMethod = _replaceCollectionMethod.MakeGenericMethod(collectionType);
                targetMethod.Invoke(null, new object[] { collection, newContents });
            }

            private static void ReplaceCollectionImpl<T>(ICollection<T> collection, IEnumerable newContents)
            {
                collection.Clear();
                if (newContents != null)
                {
                    foreach (object item in newContents)
                    {
                        // if the item was not a T, some conversion failed. the error message will be propagated,
                        // but in the meanwhile we need to make a placeholder element in the array.
                        T castItem = (item is T) ? (T)item : default(T);
                        collection.Add(castItem);
                    }
                }
            }

            [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
            public static void ReplaceDictionary(Type keyType, Type valueType, object dictionary, object newContents)
            {
                MethodInfo targetMethod = _replaceDictionaryMethod.MakeGenericMethod(keyType, valueType);
                targetMethod.Invoke(null, new object[] { dictionary, newContents });
            }

            private static void ReplaceDictionaryImpl<TKey, TValue>(IDictionary<TKey, TValue> dictionary, IEnumerable<KeyValuePair<object, object>> newContents)
            {
                dictionary.Clear();
                foreach (KeyValuePair<object, object> item in newContents)
                {
                    if (item.Key is TKey)
                    {
                        // if the item was not a T, some conversion failed. the error message will be propagated,
                        // but in the meanwhile we need to make a placeholder element in the dictionary.
                        TKey castKey = (TKey)item.Key; // this cast shouldn't fail
                        TValue castValue = (item.Value is TValue) ? (TValue)item.Value : default(TValue);
                        dictionary[castKey] = castValue;
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DefaultViewLocationCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Caching;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class DefaultViewLocationCache : IViewLocationCache
    {
        private static readonly TimeSpan _defaultTimeSpan = new TimeSpan(0, 15, 0);

        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes", Justification = "The reference type is immutable. ")]
        public static readonly IViewLocationCache Null = new NullViewLocationCache();

        public DefaultViewLocationCache()
            : this(_defaultTimeSpan)
        {
        }

        public DefaultViewLocationCache(TimeSpan timeSpan)
        {
            if (timeSpan.Ticks < 0)
            {
                throw new InvalidOperationException(MvcResources.DefaultViewLocationCache_NegativeTimeSpan);
            }
            TimeSpan = timeSpan;
        }

        public TimeSpan TimeSpan { get; private set; }

        #region IViewLocationCache Members

        public string GetViewLocation(HttpContextBase httpContext, string key)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }
            return (string)httpContext.Cache[key];
        }

        public void InsertViewLocation(HttpContextBase httpContext, string key, string virtualPath)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }
            httpContext.Cache.Insert(key, virtualPath, null /* dependencies */, Cache.NoAbsoluteExpiration, TimeSpan);
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/DependencyResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class DependencyResolver
    {
        private static DependencyResolver _instance = new DependencyResolver();

        private IDependencyResolver _current;

        /// <summary>
        /// Cache should always be a new CacheDependencyResolver(_current).
        /// </summary>
        private CacheDependencyResolver _currentCache;

        public DependencyResolver()
        {
            InnerSetResolver(new DefaultDependencyResolver());
        }

        public static IDependencyResolver Current
        {
            get { return _instance.InnerCurrent; }
        }

        internal static IDependencyResolver CurrentCache
        {
            get { return _instance.InnerCurrentCache; }
        }

        public IDependencyResolver InnerCurrent
        {
            get { return _current; }
        }

        /// <summary>
        /// Provides caching over results returned by Current.
        /// </summary>
        internal IDependencyResolver InnerCurrentCache
        {
            get { return _currentCache; }
        }

        public static void SetResolver(IDependencyResolver resolver)
        {
            _instance.InnerSetResolver(resolver);
        }

        public static void SetResolver(object commonServiceLocator)
        {
            _instance.InnerSetResolver(commonServiceLocator);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types.")]
        public static void SetResolver(Func<Type, object> getService, Func<Type, IEnumerable<object>> getServices)
        {
            _instance.InnerSetResolver(getService, getServices);
        }

        public void InnerSetResolver(IDependencyResolver resolver)
        {
            if (resolver == null)
            {
                throw new ArgumentNullException("resolver");
            }

            _current = resolver;
            _currentCache = new CacheDependencyResolver(_current);
        }

        public void InnerSetResolver(object commonServiceLocator)
        {
            if (commonServiceLocator == null)
            {
                throw new ArgumentNullException("commonServiceLocator");
            }

            Type locatorType = commonServiceLocator.GetType();
            MethodInfo getInstance = locatorType.GetMethod("GetInstance", new[] { typeof(Type) });
            MethodInfo getInstances = locatorType.GetMethod("GetAllInstances", new[] { typeof(Type) });

            if (getInstance == null ||
                getInstance.ReturnType != typeof(object) ||
                getInstances == null ||
                getInstances.ReturnType != typeof(IEnumerable<object>))
            {
                throw new ArgumentException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.DependencyResolver_DoesNotImplementICommonServiceLocator,
                        locatorType.FullName),
                    "commonServiceLocator");
            }

            var getService = (Func<Type, object>)Delegate.CreateDelegate(typeof(Func<Type, object>), commonServiceLocator, getInstance);
            var getServices = (Func<Type, IEnumerable<object>>)Delegate.CreateDelegate(typeof(Func<Type, IEnumerable<object>>), commonServiceLocator, getInstances);

            InnerSetResolver(new DelegateBasedDependencyResolver(getService, getServices));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types.")]
        public void InnerSetResolver(Func<Type, object> getService, Func<Type, IEnumerable<object>> getServices)
        {
            if (getService == null)
            {
                throw new ArgumentNullException("getService");
            }
            if (getServices == null)
            {
                throw new ArgumentNullException("getServices");
            }

            InnerSetResolver(new DelegateBasedDependencyResolver(getService, getServices));
        }

        /// <summary>
        /// Wraps an IDependencyResolver and ensures single instance per-type.
        /// </summary>
        /// <remarks>
        /// Note it's possible for multiple threads to race and call the _resolver service multiple times.
        /// We'll pick one winner and ignore the others and still guarantee a unique instance.
        /// </remarks>
        private sealed class CacheDependencyResolver : IDependencyResolver
        {
            private readonly ConcurrentDictionary<Type, object> _cache = new ConcurrentDictionary<Type, object>();
            private readonly ConcurrentDictionary<Type, IEnumerable<object>> _cacheMultiple = new ConcurrentDictionary<Type, IEnumerable<object>>();
            private readonly Func<Type, object> _getServiceDelegate;
            private readonly Func<Type, IEnumerable<object>> _getServicesDelegate;

            private readonly IDependencyResolver _resolver;

            public CacheDependencyResolver(IDependencyResolver resolver)
            {
                _resolver = resolver;
                _getServiceDelegate = _resolver.GetService;
                _getServicesDelegate = _resolver.GetServices;
            }

            public object GetService(Type serviceType)
            {
                // Use a saved delegate to prevent per-call delegate allocation
                return _cache.GetOrAdd(serviceType, _getServiceDelegate);
            }

            public IEnumerable<object> GetServices(Type serviceType)
            {
                // Use a saved delegate to prevent per-call delegate allocation
                return _cacheMultiple.GetOrAdd(serviceType, _getServicesDelegate);
            }
        }

        private class DefaultDependencyResolver : IDependencyResolver
        {
            [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method might throw exceptions whose type we cannot strongly link against; namely, ActivationException from common service locator")]
            public object GetService(Type serviceType)
            {
                // Since attempting to create an instance of an interface or an abstract type results in an exception, immediately return null
                // to improve performance and the debugging experience with first-chance exceptions enabled.
                if (serviceType.IsInterface || serviceType.IsAbstract)
                {
                    return null;
                }

                try
                {
                    return Activator.CreateInstance(serviceType);
                }
                catch
                {
                    return null;
                }
            }

            public IEnumerable<object> GetServices(Type serviceType)
            {
                return Enumerable.Empty<object>();
            }
        }

        private class DelegateBasedDependencyResolver : IDependencyResolver
        {
            private Func<Type, object> _getService;
            private Func<Type, IEnumerable<object>> _getServices;

            public DelegateBasedDependencyResolver(Func<Type, object> getService, Func<Type, IEnumerable<object>> getServices)
            {
                _getService = getService;
                _getServices = getServices;
            }

            [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This method might throw exceptions whose type we cannot strongly link against; namely, ActivationException from common service locator")]
            public object GetService(Type type)
            {
                try
                {
                    return _getService.Invoke(type);
                }
                catch
                {
                    return null;
                }
            }

            public IEnumerable<object> GetServices(Type type)
            {
                return _getServices(type);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DependencyResolverExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    public static class DependencyResolverExtensions
    {
        public static TService GetService<TService>(this IDependencyResolver resolver)
        {
            return (TService)resolver.GetService(typeof(TService));
        }

        public static IEnumerable<TService> GetServices<TService>(this IDependencyResolver resolver)
        {
            return resolver.GetServices(typeof(TService)).Cast<TService>();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DescriptorUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using System.Text;
using System.Threading;

namespace System.Web.Mvc
{
    internal static class DescriptorUtil
    {
        private static void AppendPartToUniqueIdBuilder(StringBuilder builder, object part)
        {
            if (part == null)
            {
                builder.Append("[-1]");
            }
            else
            {
                string partString = Convert.ToString(part, CultureInfo.InvariantCulture);
                builder.AppendFormat("[{0}]{1}", partString.Length, partString);
            }
        }

        public static void AppendUniqueId(StringBuilder builder, object part)
        {
            // We can special-case certain part types
            MemberInfo memberInfo = part as MemberInfo;
            if (memberInfo != null)
            {
                AppendPartToUniqueIdBuilder(builder, memberInfo.Module.ModuleVersionId);
                AppendPartToUniqueIdBuilder(builder, memberInfo.MetadataToken);
                return;
            }

            IUniquelyIdentifiable uniquelyIdentifiable = part as IUniquelyIdentifiable;
            if (uniquelyIdentifiable != null)
            {
                AppendPartToUniqueIdBuilder(builder, uniquelyIdentifiable.UniqueId);
                return;
            }

            AppendPartToUniqueIdBuilder(builder, part);
        }

        public static string CreateUniqueId(object part0, object part1)
        {
            StringBuilder builder = new StringBuilder();
            AppendUniqueId(builder, part0);
            AppendUniqueId(builder, part1);
            return builder.ToString();
        }

        public static string CreateUniqueId(object part0, object part1, object part2)
        {
            StringBuilder builder = new StringBuilder();
            AppendUniqueId(builder, part0);
            AppendUniqueId(builder, part1);
            AppendUniqueId(builder, part2);
            return builder.ToString();
        }

        public static TDescriptor[] LazilyFetchOrCreateDescriptors<TReflection, TDescriptor, TArgument>(
            ref TDescriptor[] cacheLocation,
            Func<TArgument, TReflection[]> initializer,
            Func<TReflection, TArgument, TDescriptor> converter,
            TArgument state)
        {
            // did we already calculate this once?
            TDescriptor[] existingCache = Interlocked.CompareExchange(ref cacheLocation, null, null);
            if (existingCache != null)
            {
                return existingCache;
            }

            // Note: since this code operates on arrays it is more efficient to call simple array operations
            // instead of LINQ-y extension methods such as Select and Where. DO NOT attempt to simplify this
            // without testing the performance impact.
            TReflection[] memberInfos = initializer(state);
            List<TDescriptor> descriptorsList = new List<TDescriptor>(memberInfos.Length);
            for (int i = 0; i < memberInfos.Length; i++)
            {
                TDescriptor descriptor = converter(memberInfos[i], state);
                if (descriptor != null)
                {
                    descriptorsList.Add(descriptor);
                }
            }
            TDescriptor[] descriptors = descriptorsList.ToArray();

            TDescriptor[] updatedCache = Interlocked.CompareExchange(ref cacheLocation, descriptors, null);
            return updatedCache ?? descriptors;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DictionaryHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    internal static class DictionaryHelpers
    {
        public static IEnumerable<KeyValuePair<string, TValue>> FindKeysWithPrefix<TValue>(IDictionary<string, TValue> dictionary, string prefix)
        {
            TValue exactMatchValue;
            if (dictionary.TryGetValue(prefix, out exactMatchValue))
            {
                yield return new KeyValuePair<string, TValue>(prefix, exactMatchValue);
            }

            foreach (var entry in dictionary)
            {
                string key = entry.Key;

                if (key.Length <= prefix.Length)
                {
                    continue;
                }

                if (!key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                {
                    continue;
                }

                char charAfterPrefix = key[prefix.Length];
                switch (charAfterPrefix)
                {
                    case '[':
                    case '.':
                        yield return entry;
                        break;
                }
            }
        }

        public static bool DoesAnyKeyHavePrefix<TValue>(IDictionary<string, TValue> dictionary, string prefix)
        {
            return FindKeysWithPrefix(dictionary, prefix).Any();
        }

        public static TValue GetOrDefault<TKey, TValue>(this IDictionary<TKey, TValue> dict, TKey key, TValue @default)
        {
            TValue value;
            if (dict.TryGetValue(key, out value))
            {
                return value;
            }
            return @default;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DictionaryValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;

namespace System.Web.Mvc
{
    public class DictionaryValueProvider<TValue> : IValueProvider, IEnumerableValueProvider
    {
        private PrefixContainer _prefixContainer;
        private readonly Dictionary<string, ValueProviderResult> _values = new Dictionary<string, ValueProviderResult>(StringComparer.OrdinalIgnoreCase);

        public DictionaryValueProvider(IDictionary<string, TValue> dictionary, CultureInfo culture)
        {
            if (dictionary == null)
            {
                throw new ArgumentNullException("dictionary");
            }

            foreach (KeyValuePair<string, TValue> entry in dictionary)
            {
                object rawValue = entry.Value;
                string attemptedValue = Convert.ToString(rawValue, culture);
                _values[entry.Key] = new ValueProviderResult(rawValue, attemptedValue, culture);
            }
        }

        private PrefixContainer PrefixContainer
        {
            get
            {
                if (_prefixContainer == null)
                {
                    // Race condition on initialization has no side effects
                    _prefixContainer = new PrefixContainer(_values.Keys);
                }
                return _prefixContainer;
            }
        }

        public virtual bool ContainsPrefix(string prefix)
        {
            return PrefixContainer.ContainsPrefix(prefix);
        }

        public virtual ValueProviderResult GetValue(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            ValueProviderResult valueProviderResult;
            _values.TryGetValue(key, out valueProviderResult);
            return valueProviderResult;
        }

        public virtual IDictionary<string, string> GetKeysFromPrefix(string prefix)
        {
            return PrefixContainer.GetKeysFromPrefix(prefix);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/DynamicViewDataDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;

namespace System.Web.Mvc
{
    internal sealed class DynamicViewDataDictionary : DynamicObject
    {
        private readonly Func<ViewDataDictionary> _viewDataThunk;

        public DynamicViewDataDictionary(Func<ViewDataDictionary> viewDataThunk)
        {
            _viewDataThunk = viewDataThunk;
        }

        private ViewDataDictionary ViewData
        {
            get
            {
                ViewDataDictionary viewData = _viewDataThunk();
                Debug.Assert(viewData != null);
                return viewData;
            }
        }

        // Implementing this function improves the debugging experience as it provides the debugger with the list of all
        // the properties currently defined on the object
        public override IEnumerable<string> GetDynamicMemberNames()
        {
            return ViewData.Keys;
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            result = ViewData[binder.Name];
            // since ViewDataDictionary always returns a result even if the key does not exist, always return true
            return true;
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            ViewData[binder.Name] = value;
            // you can always set a key in the dictionary so return true
            return true;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/EmptyModelMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public class EmptyModelMetadataProvider : AssociatedMetadataProvider
    {
        protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
        {
            return new ModelMetadata(this, containerType, modelAccessor, modelType, propertyName);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/EmptyModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    public class EmptyModelValidatorProvider : ModelValidatorProvider
    {
        public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
        {
            return Enumerable.Empty<ModelValidator>();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/EmptyResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    // represents a result that doesn't do anything, like a controller action returning null
    public class EmptyResult : ActionResult
    {
        private static readonly EmptyResult _singleton = new EmptyResult();

        internal static EmptyResult Instance
        {
            get { return _singleton; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Error.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Mvc.Async;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    internal static class Error
    {
        public static InvalidOperationException AsyncActionMethodSelector_CouldNotFindMethod(string methodName, Type controllerType)
        {
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.AsyncActionMethodSelector_CouldNotFindMethod,
                                           methodName, controllerType);
            return new InvalidOperationException(message);
        }

        public static InvalidOperationException AsyncCommon_AsyncResultAlreadyConsumed()
        {
            return new InvalidOperationException(MvcResources.AsyncCommon_AsyncResultAlreadyConsumed);
        }

        public static InvalidOperationException AsyncCommon_ControllerMustImplementIAsyncManagerContainer(Type actualControllerType)
        {
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.AsyncCommon_ControllerMustImplementIAsyncManagerContainer,
                                           actualControllerType);
            return new InvalidOperationException(message);
        }

        public static ArgumentException AsyncCommon_InvalidAsyncResult(string parameterName)
        {
            return new ArgumentException(MvcResources.AsyncCommon_InvalidAsyncResult, parameterName);
        }

        public static ArgumentOutOfRangeException AsyncCommon_InvalidTimeout(string parameterName)
        {
            return new ArgumentOutOfRangeException(parameterName, MvcResources.AsyncCommon_InvalidTimeout);
        }

        public static InvalidOperationException ChildActionOnlyAttribute_MustBeInChildRequest(ActionDescriptor actionDescriptor)
        {
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ChildActionOnlyAttribute_MustBeInChildRequest,
                                           actionDescriptor.ActionName);
            return new InvalidOperationException(message);
        }

        public static ArgumentException ParameterCannotBeNullOrEmpty(string parameterName)
        {
            return new ArgumentException(MvcResources.Common_NullOrEmpty, parameterName);
        }

        public static InvalidOperationException PropertyCannotBeNullOrEmpty(string propertyName)
        {
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.Common_PropertyCannotBeNullOrEmpty,
                                           propertyName);
            return new InvalidOperationException(message);
        }

        public static SynchronousOperationException SynchronizationContextUtil_ExceptionThrown(Exception innerException)
        {
            return new SynchronousOperationException(MvcResources.SynchronizationContextUtil_ExceptionThrown, innerException);
        }

        public static InvalidOperationException ViewDataDictionary_WrongTModelType(Type valueType, Type modelType)
        {
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ViewDataDictionary_WrongTModelType,
                                           valueType, modelType);
            return new InvalidOperationException(message);
        }

        public static InvalidOperationException ViewDataDictionary_ModelCannotBeNull(Type modelType)
        {
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ViewDataDictionary_ModelCannotBeNull,
                                           modelType);
            return new InvalidOperationException(message);
        }

        public static ArgumentOutOfRangeException ArgumentMustBeGreaterThanOrEqualTo(string parameterName, int actualValue, int minValue)
        {
            string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ArgumentMustBeGreaterThanOrEqualTo,
                                           minValue);
            return new ArgumentOutOfRangeException(parameterName, actualValue, message);
        }

        public static Exception ArgumentNull(string parameterName)
        {
            return new ArgumentNullException(parameterName);
        }

        public static InvalidOperationException InvalidOperation(string messageFormat, params object[] args)
        {
            string message = String.Format(CultureInfo.CurrentCulture, messageFormat, args);
            return new InvalidOperationException(message);
        }

        internal static string Format(string format, params object[] args)
        {
            return String.Format(CultureInfo.CurrentCulture, format, args);
        }

        internal static ArgumentException Argument(string parameterName, string messageFormat, params object[] messageArgs)
        {
            return new ArgumentException(Error.Format(messageFormat, messageArgs), parameterName);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExceptionContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class ExceptionContext : ControllerContext
    {
        private ActionResult _result;

        // parameterless constructor used for mocking
        public ExceptionContext()
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public ExceptionContext(ControllerContext controllerContext, Exception exception)
            : base(controllerContext)
        {
            if (exception == null)
            {
                throw new ArgumentNullException("exception");
            }

            Exception = exception;
        }

        public virtual Exception Exception { get; set; }

        public bool ExceptionHandled { get; set; }

        public ActionResult Result
        {
            get { return _result ?? EmptyResult.Instance; }
            set { _result = value; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Mvc.ExpressionUtil;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public static class ExpressionHelper
    {
        public static string GetExpressionText(string expression)
        {
            return
                String.Equals(expression, "model", StringComparison.OrdinalIgnoreCase)
                    ? String.Empty // If it's exactly "model", then give them an empty string, to replicate the lambda behavior
                    : expression;
        }

        public static string GetExpressionText(LambdaExpression expression)
        {
            // Split apart the expression string for property/field accessors to create its name
            Stack<string> nameParts = new Stack<string>();
            Expression part = expression.Body;

            while (part != null)
            {
                if (part.NodeType == ExpressionType.Call)
                {
                    MethodCallExpression methodExpression = (MethodCallExpression)part;

                    if (!IsSingleArgumentIndexer(methodExpression))
                    {
                        // Unsupported
                        break;
                    }

                    nameParts.Push(
                        GetIndexerInvocation(
                            methodExpression.Arguments.Single(),
                            expression.Parameters.ToArray()));

                    part = methodExpression.Object;
                }
                else if (part.NodeType == ExpressionType.ArrayIndex)
                {
                    BinaryExpression binaryExpression = (BinaryExpression)part;

                    nameParts.Push(
                        GetIndexerInvocation(
                            binaryExpression.Right,
                            expression.Parameters.ToArray()));

                    part = binaryExpression.Left;
                }
                else if (part.NodeType == ExpressionType.MemberAccess)
                {
                    MemberExpression memberExpressionPart = (MemberExpression)part;
                    var name = memberExpressionPart.Member.Name;

                    // If identifier contains "__", it is "reserved for use by the implementation" and likely compiler-
                    // or Razor-generated e.g. the name of a field in a delegate's generated class.
                    if (name.Contains("__"))
                    {
                        // Exit loop. Should have the entire name because previous MemberAccess has same name as the
                        // leftmost expression node (a variable).
                        break;
                    }

                    nameParts.Push("." + name);
                    part = memberExpressionPart.Expression;
                }
                else if (part.NodeType == ExpressionType.Parameter)
                {
                    // Dev10 Bug #907611
                    // When the expression is parameter based (m => m.Something...), we'll push an empty
                    // string onto the stack and stop evaluating. The extra empty string makes sure that
                    // we don't accidentally cut off too much of m => m.Model.
                    nameParts.Push(String.Empty);

                    // Exit loop. Have the entire name because the parameter cannot be used as an indexer; always the
                    // leftmost expression node.
                    break;
                }
                else
                {
                    // Unsupported
                    break;
                }
            }

            // If parts start with "model", then strip that part away.
            if (nameParts.Count > 0 && String.Equals(nameParts.Peek(), ".model", StringComparison.OrdinalIgnoreCase))
            {
                nameParts.Pop();
            }

            if (nameParts.Count > 0)
            {
                return nameParts.Aggregate((left, right) => left + right).TrimStart('.');
            }

            return String.Empty;
        }

        private static string GetIndexerInvocation(Expression expression, ParameterExpression[] parameters)
        {
            Expression converted = Expression.Convert(expression, typeof(object));
            ParameterExpression fakeParameter = Expression.Parameter(typeof(object), null);
            Expression<Func<object, object>> lambda = Expression.Lambda<Func<object, object>>(converted, fakeParameter);
            Func<object, object> func;

            try
            {
                func = CachedExpressionCompiler.Process(lambda);
            }
            catch (InvalidOperationException ex)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.ExpressionHelper_InvalidIndexerExpression,
                        expression,
                        parameters[0].Name),
                    ex);
            }

            return "[" + Convert.ToString(func(null), CultureInfo.InvariantCulture) + "]";
        }

        internal static bool IsSingleArgumentIndexer(Expression expression)
        {
            MethodCallExpression methodExpression = expression as MethodCallExpression;
            if (methodExpression == null || methodExpression.Arguments.Count != 1)
            {
                return false;
            }

            return methodExpression.Method
                .DeclaringType
                .GetDefaultMembers()
                .OfType<PropertyInfo>()
                .Any(p => p.GetGetMethod() == methodExpression.Method);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/BinaryExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // BinaryExpression fingerprint class
    // Useful for things like array[index]

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class BinaryExpressionFingerprint : ExpressionFingerprint
    {
        public BinaryExpressionFingerprint(ExpressionType nodeType, Type type, MethodInfo method)
            : base(nodeType, type)
        {
            // Other properties on BinaryExpression (like IsLifted / IsLiftedToNull) are simply derived
            // from Type and NodeType, so they're not necessary for inclusion in the fingerprint.

            Method = method;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.binaryexpression.method.aspx
        public MethodInfo Method { get; private set; }

        public override bool Equals(object obj)
        {
            BinaryExpressionFingerprint other = obj as BinaryExpressionFingerprint;
            return (other != null)
                   && Equals(this.Method, other.Method)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Method);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/CachedExpressionCompiler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;

namespace System.Web.Mvc.ExpressionUtil
{
    internal static class CachedExpressionCompiler
    {
        // This is the entry point to the cached expression compilation system. The system
        // will try to turn the expression into an actual delegate as quickly as possible,
        // relying on cache lookups and other techniques to save time if appropriate.
        // If the provided expression is particularly obscure and the system doesn't know
        // how to handle it, we'll just compile the expression as normal.
        public static Func<TModel, TValue> Process<TModel, TValue>(Expression<Func<TModel, TValue>> lambdaExpression)
        {
            return Compiler<TModel, TValue>.Compile(lambdaExpression);
        }

        private static class Compiler<TIn, TOut>
        {
            private static Func<TIn, TOut> _identityFunc;

            private static readonly ConcurrentDictionary<MemberInfo, Func<TIn, TOut>> _simpleMemberAccessDict =
                new ConcurrentDictionary<MemberInfo, Func<TIn, TOut>>();

            private static readonly ConcurrentDictionary<MemberInfo, Func<object, TOut>> _constMemberAccessDict =
                new ConcurrentDictionary<MemberInfo, Func<object, TOut>>();

            private static readonly ConcurrentDictionary<ExpressionFingerprintChain, Hoisted<TIn, TOut>> _fingerprintedCache =
                new ConcurrentDictionary<ExpressionFingerprintChain, Hoisted<TIn, TOut>>();

            public static Func<TIn, TOut> Compile(Expression<Func<TIn, TOut>> expr)
            {
                return CompileFromIdentityFunc(expr)
                       ?? CompileFromConstLookup(expr)
                       ?? CompileFromMemberAccess(expr)
                       ?? CompileFromFingerprint(expr)
                       ?? CompileSlow(expr);
            }

            private static Func<TIn, TOut> CompileFromConstLookup(Expression<Func<TIn, TOut>> expr)
            {
                ConstantExpression constExpr = expr.Body as ConstantExpression;
                if (constExpr != null)
                {
                    // model => {const}

                    TOut constantValue = (TOut)constExpr.Value;
                    return _ => constantValue;
                }

                return null;
            }

            private static Func<TIn, TOut> CompileFromIdentityFunc(Expression<Func<TIn, TOut>> expr)
            {
                if (expr.Body == expr.Parameters[0])
                {
                    // model => model

                    // don't need to lock, as all identity funcs are identical
                    if (_identityFunc == null)
                    {
                        _identityFunc = expr.Compile();
                    }

                    return _identityFunc;
                }

                return null;
            }

            private static Func<TIn, TOut> CompileFromFingerprint(Expression<Func<TIn, TOut>> expr)
            {
                List<object> capturedConstants;
                ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

                if (fingerprint != null)
                {
                    var del = _fingerprintedCache.GetOrAdd(fingerprint, _ =>
                    {
                        // Fingerprinting succeeded, but there was a cache miss. Rewrite the expression
                        // and add the rewritten expression to the cache.

                        var hoistedExpr = HoistingExpressionVisitor<TIn, TOut>.Hoist(expr);
                        return hoistedExpr.Compile();
                    });
                    return model => del(model, capturedConstants);
                }

                // couldn't be fingerprinted
                return null;
            }

            private static Func<TIn, TOut> CompileFromMemberAccess(Expression<Func<TIn, TOut>> expr)
            {
                // Performance tests show that on the x64 platform, special-casing static member and
                // captured local variable accesses is faster than letting the fingerprinting system
                // handle them. On the x86 platform, the fingerprinting system is faster, but only
                // by around one microsecond, so it's not worth it to complicate the logic here with
                // an architecture check.

                MemberExpression memberExpr = expr.Body as MemberExpression;
                if (memberExpr != null)
                {
                    if (memberExpr.Expression == expr.Parameters[0] || memberExpr.Expression == null)
                    {
                        // model => model.Member or model => StaticMember
                        return _simpleMemberAccessDict.GetOrAdd(memberExpr.Member, _ => expr.Compile());
                    }

                    ConstantExpression constExpr = memberExpr.Expression as ConstantExpression;
                    if (constExpr != null)
                    {
                        // model => {const}.Member (captured local variable)
                        var del = _constMemberAccessDict.GetOrAdd(memberExpr.Member, _ =>
                        {
                            // rewrite as capturedLocal => ((TDeclaringType)capturedLocal).Member
                            var constParamExpr = Expression.Parameter(typeof(object), "capturedLocal");
                            var constCastExpr = Expression.Convert(constParamExpr, memberExpr.Member.DeclaringType);
                            var newMemberAccessExpr = memberExpr.Update(constCastExpr);
                            var newLambdaExpr = Expression.Lambda<Func<object, TOut>>(newMemberAccessExpr, constParamExpr);
                            return newLambdaExpr.Compile();
                        });

                        object capturedLocal = constExpr.Value;
                        return _ => del(capturedLocal);
                    }
                }

                return null;
            }

            private static Func<TIn, TOut> CompileSlow(Expression<Func<TIn, TOut>> expr)
            {
                // fallback compilation system - just compile the expression directly
                return expr.Compile();
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/ConditionalExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // ConditionalExpression fingerprint class
    // Expression of form (test) ? ifTrue : ifFalse

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class ConditionalExpressionFingerprint : ExpressionFingerprint
    {
        public ConditionalExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on ConditionalExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            ConditionalExpressionFingerprint other = obj as ConditionalExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/ConstantExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // ConstantExpression fingerprint class
    //
    // A ConstantExpression might represent a captured local variable, so we can't compile
    // the value directly into the cached function. Instead, a placeholder is generated
    // and the value is hoisted into a local variables array. This placeholder can then
    // be compiled and cached, and the array lookup happens at runtime.

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class ConstantExpressionFingerprint : ExpressionFingerprint
    {
        public ConstantExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on ConstantExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            ConstantExpressionFingerprint other = obj as ConstantExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/DefaultExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // DefaultExpression fingerprint class
    // Expression of form default(T)

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class DefaultExpressionFingerprint : ExpressionFingerprint
    {
        public DefaultExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on DefaultExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            DefaultExpressionFingerprint other = obj as DefaultExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/ExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;

namespace System.Web.Mvc.ExpressionUtil
{
    // Serves as the base class for all expression fingerprints. Provides a default implementation
    // of GetHashCode().

    internal abstract class ExpressionFingerprint
    {
        protected ExpressionFingerprint(ExpressionType nodeType, Type type)
        {
            NodeType = nodeType;
            Type = type;
        }

        // the type of expression node, e.g. OP_ADD, MEMBER_ACCESS, etc.
        public ExpressionType NodeType { get; private set; }

        // the CLR type resulting from this expression, e.g. int, string, etc.
        public Type Type { get; private set; }

        internal virtual void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddInt32((int)NodeType);
            combiner.AddObject(Type);
        }

        protected bool Equals(ExpressionFingerprint other)
        {
            return (other != null)
                   && (this.NodeType == other.NodeType)
                   && Equals(this.Type, other.Type);
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as ExpressionFingerprint);
        }

        public override int GetHashCode()
        {
            HashCodeCombiner combiner = new HashCodeCombiner();
            AddToHashCodeCombiner(combiner);
            return combiner.CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/ExpressionFingerprintChain.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc.ExpressionUtil
{
    // Expression fingerprint chain class
    // Contains information used for generalizing, comparing, and recreating Expression instances
    //
    // Since Expression objects are immutable and are recreated for every invocation of an expression
    // helper method, they can't be compared directly. Fingerprinting Expression objects allows
    // information about them to be abstracted away, and the fingerprints can be directly compared.
    // Consider the process of fingerprinting that all values (parameters, constants, etc.) are hoisted
    // and replaced with dummies. What remains can be decomposed into a sequence of operations on specific
    // types and specific inputs.
    //
    // Some sample fingerprints chains:
    //
    // 2 + 4 -> OP_ADD, CONST:int, NULL, CONST:int
    // 2 + 8 -> OP_ADD, CONST:int, NULL, CONST:int
    // 2.0 + 4.0 -> OP_ADD, CONST:double, NULL, CONST:double
    //
    // 2 + 4 and 2 + 8 have the same fingerprint, but 2.0 + 4.0 has a different fingerprint since its
    // underlying types differ. Note that this looks a bit like prefix notation and is a side effect
    // of how the ExpressionVisitor class recurses into expressions. (Occasionally there will be a NULL
    // in the fingerprint chain, which depending on context can denote a static member, a null Conversion
    // in a BinaryExpression, and so forth.)
    //
    // "Hello " + "world" -> OP_ADD, CONST:string, NULL, CONST:string
    // "Hello " + {model} -> OP_ADD, CONST:string, NULL, PARAM_0:string
    //
    // These string concatenations have different fingerprints since the inputs are provided differently:
    // one is a constant, the other is a parameter.
    //
    // ({model} ?? "sample").Length -> MEMBER_ACCESS(String.Length), OP_COALESCE, PARAM_0:string, NULL, CONST:string
    // ({model} ?? "other sample").Length -> MEMBER_ACCESS(String.Length), OP_COALESCE, PARAM_0:string, NULL, CONST:string
    //
    // These expressions have the same fingerprint since all constants of the same underlying type are
    // treated equally.
    //
    // It's also important that the fingerprints don't reference the actual Expression objects that were
    // used to generate them, as the fingerprints will be cached, and caching a fingerprint that references
    // an Expression will root the Expression (and any objects it references).

    internal sealed class ExpressionFingerprintChain : IEquatable<ExpressionFingerprintChain>
    {
        public readonly List<ExpressionFingerprint> Elements = new List<ExpressionFingerprint>();

        public bool Equals(ExpressionFingerprintChain other)
        {
            // Two chains are considered equal if two elements appearing in the same index in
            // each chain are equal (value equality, not referential equality).

            if (other == null)
            {
                return false;
            }

            if (this.Elements.Count != other.Elements.Count)
            {
                return false;
            }

            for (int i = 0; i < this.Elements.Count; i++)
            {
                if (!Equals(this.Elements[i], other.Elements[i]))
                {
                    return false;
                }
            }

            return true;
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as ExpressionFingerprintChain);
        }

        public override int GetHashCode()
        {
            HashCodeCombiner combiner = new HashCodeCombiner();
            Elements.ForEach(combiner.AddFingerprint);
            return combiner.CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/FingerprintingExpressionVisitor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;

namespace System.Web.Mvc.ExpressionUtil
{
    // This is a visitor which produces a fingerprint of an expression. It doesn't
    // rewrite the expression in a form which can be compiled and cached.

    internal sealed class FingerprintingExpressionVisitor : ExpressionVisitor
    {
        private readonly List<object> _seenConstants = new List<object>();
        private readonly List<ParameterExpression> _seenParameters = new List<ParameterExpression>();
        private readonly ExpressionFingerprintChain _currentChain = new ExpressionFingerprintChain();
        private bool _gaveUp;

        private FingerprintingExpressionVisitor()
        {
        }

        private T GiveUp<T>(T node)
        {
            // We don't understand this node, so just quit.

            _gaveUp = true;
            return node;
        }

        // Returns the fingerprint chain + captured constants list for this expression, or null
        // if the expression couldn't be fingerprinted.
        public static ExpressionFingerprintChain GetFingerprintChain(Expression expr, out List<object> capturedConstants)
        {
            FingerprintingExpressionVisitor visitor = new FingerprintingExpressionVisitor();
            visitor.Visit(expr);

            if (visitor._gaveUp)
            {
                capturedConstants = null;
                return null;
            }
            else
            {
                capturedConstants = visitor._seenConstants;
                return visitor._currentChain;
            }
        }

        public override Expression Visit(Expression node)
        {
            if (node == null)
            {
                _currentChain.Elements.Add(null);
                return null;
            }
            else
            {
                return base.Visit(node);
            }
        }

        protected override Expression VisitBinary(BinaryExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new BinaryExpressionFingerprint(node.NodeType, node.Type, node.Method));
            return base.VisitBinary(node);
        }

        protected override Expression VisitBlock(BlockExpression node)
        {
            return GiveUp(node);
        }

        protected override CatchBlock VisitCatchBlock(CatchBlock node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitConditional(ConditionalExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new ConditionalExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitConditional(node);
        }

        protected override Expression VisitConstant(ConstantExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }

            _seenConstants.Add(node.Value);
            _currentChain.Elements.Add(new ConstantExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitConstant(node);
        }

        protected override Expression VisitDebugInfo(DebugInfoExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitDefault(DefaultExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new DefaultExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitDefault(node);
        }

        protected override Expression VisitDynamic(DynamicExpression node)
        {
            return GiveUp(node);
        }

        protected override ElementInit VisitElementInit(ElementInit node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitExtension(Expression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitGoto(GotoExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitIndex(IndexExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new IndexExpressionFingerprint(node.NodeType, node.Type, node.Indexer));
            return base.VisitIndex(node);
        }

        protected override Expression VisitInvocation(InvocationExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitLabel(LabelExpression node)
        {
            return GiveUp(node);
        }

        protected override LabelTarget VisitLabelTarget(LabelTarget node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitLambda<T>(Expression<T> node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new LambdaExpressionFingerprint(node.NodeType, node.Type));
            return base.VisitLambda<T>(node);
        }

        protected override Expression VisitListInit(ListInitExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitLoop(LoopExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitMember(MemberExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new MemberExpressionFingerprint(node.NodeType, node.Type, node.Member));
            return base.VisitMember(node);
        }

        protected override MemberAssignment VisitMemberAssignment(MemberAssignment node)
        {
            return GiveUp(node);
        }

        protected override MemberBinding VisitMemberBinding(MemberBinding node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitMemberInit(MemberInitExpression node)
        {
            return GiveUp(node);
        }

        protected override MemberListBinding VisitMemberListBinding(MemberListBinding node)
        {
            return GiveUp(node);
        }

        protected override MemberMemberBinding VisitMemberMemberBinding(MemberMemberBinding node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new MethodCallExpressionFingerprint(node.NodeType, node.Type, node.Method));
            return base.VisitMethodCall(node);
        }

        protected override Expression VisitNew(NewExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitNewArray(NewArrayExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitParameter(ParameterExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }

            int parameterIndex = _seenParameters.IndexOf(node);
            if (parameterIndex < 0)
            {
                // first time seeing this parameter
                parameterIndex = _seenParameters.Count;
                _seenParameters.Add(node);
            }

            _currentChain.Elements.Add(new ParameterExpressionFingerprint(node.NodeType, node.Type, parameterIndex));
            return base.VisitParameter(node);
        }

        protected override Expression VisitRuntimeVariables(RuntimeVariablesExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitSwitch(SwitchExpression node)
        {
            return GiveUp(node);
        }

        protected override SwitchCase VisitSwitchCase(SwitchCase node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitTry(TryExpression node)
        {
            return GiveUp(node);
        }

        protected override Expression VisitTypeBinary(TypeBinaryExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new TypeBinaryExpressionFingerprint(node.NodeType, node.Type, node.TypeOperand));
            return base.VisitTypeBinary(node);
        }

        protected override Expression VisitUnary(UnaryExpression node)
        {
            if (_gaveUp)
            {
                return node;
            }
            _currentChain.Elements.Add(new UnaryExpressionFingerprint(node.NodeType, node.Type, node.Method));
            return base.VisitUnary(node);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/HashCodeCombiner.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;

namespace System.Web.Mvc.ExpressionUtil
{
    // based on System.Web.Util.HashCodeCombiner
    internal class HashCodeCombiner
    {
        private long _combinedHash64 = 0x1505L;

        public int CombinedHash
        {
            get { return _combinedHash64.GetHashCode(); }
        }

        public void AddFingerprint(ExpressionFingerprint fingerprint)
        {
            if (fingerprint != null)
            {
                fingerprint.AddToHashCodeCombiner(this);
            }
            else
            {
                AddInt32(0);
            }
        }

        public void AddEnumerable(IEnumerable e)
        {
            if (e == null)
            {
                AddInt32(0);
            }
            else
            {
                int count = 0;
                foreach (object o in e)
                {
                    AddObject(o);
                    count++;
                }
                AddInt32(count);
            }
        }

        public void AddInt32(int i)
        {
            _combinedHash64 = ((_combinedHash64 << 5) + _combinedHash64) ^ i;
        }

        public void AddObject(object o)
        {
            int hashCode = (o != null) ? o.GetHashCode() : 0;
            AddInt32(hashCode);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/Hoisted.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc.ExpressionUtil
{
    internal delegate TValue Hoisted<TModel, TValue>(TModel model, List<object> capturedConstants);
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/HoistingExpressionVisitor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;

namespace System.Web.Mvc.ExpressionUtil
{
    // This is a visitor which rewrites constant expressions as parameter lookups. It's meant
    // to produce an expression which can be cached safely.

    internal sealed class HoistingExpressionVisitor<TIn, TOut> : ExpressionVisitor
    {
        private static readonly ParameterExpression _hoistedConstantsParamExpr = Expression.Parameter(typeof(List<object>), "hoistedConstants");
        private int _numConstantsProcessed;

        // factory will create instance
        private HoistingExpressionVisitor()
        {
        }

        public static Expression<Hoisted<TIn, TOut>> Hoist(Expression<Func<TIn, TOut>> expr)
        {
            // rewrite Expression<Func<TIn, TOut>> as Expression<Hoisted<TIn, TOut>>

            var visitor = new HoistingExpressionVisitor<TIn, TOut>();
            var rewrittenBodyExpr = visitor.Visit(expr.Body);
            var rewrittenLambdaExpr = Expression.Lambda<Hoisted<TIn, TOut>>(rewrittenBodyExpr, expr.Parameters[0], _hoistedConstantsParamExpr);
            return rewrittenLambdaExpr;
        }

        protected override Expression VisitConstant(ConstantExpression node)
        {
            // rewrite the constant expression as (TConst)hoistedConstants[i];
            return Expression.Convert(Expression.Property(_hoistedConstantsParamExpr, "Item", Expression.Constant(_numConstantsProcessed++)), node.Type);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/IndexExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // IndexExpression fingerprint class
    // Represents certain forms of array access or indexer property access

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class IndexExpressionFingerprint : ExpressionFingerprint
    {
        public IndexExpressionFingerprint(ExpressionType nodeType, Type type, PropertyInfo indexer)
            : base(nodeType, type)
        {
            // Other properties on IndexExpression (like the argument count) are simply derived
            // from Type and Indexer, so they're not necessary for inclusion in the fingerprint.

            Indexer = indexer;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.indexexpression.indexer.aspx
        public PropertyInfo Indexer { get; private set; }

        public override bool Equals(object obj)
        {
            IndexExpressionFingerprint other = obj as IndexExpressionFingerprint;
            return (other != null)
                   && Equals(this.Indexer, other.Indexer)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Indexer);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/LambdaExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // LambdaExpression fingerprint class
    // Represents a lambda expression (root element in Expression<T>)

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class LambdaExpressionFingerprint : ExpressionFingerprint
    {
        public LambdaExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
            // There are no properties on LambdaExpression that are worth including in
            // the fingerprint.
        }

        public override bool Equals(object obj)
        {
            LambdaExpressionFingerprint other = obj as LambdaExpressionFingerprint;
            return (other != null)
                   && this.Equals(other);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/MemberExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // MemberExpression fingerprint class
    // Expression of form xxx.FieldOrProperty

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class MemberExpressionFingerprint : ExpressionFingerprint
    {
        public MemberExpressionFingerprint(ExpressionType nodeType, Type type, MemberInfo member)
            : base(nodeType, type)
        {
            Member = member;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.memberexpression.member.aspx
        public MemberInfo Member { get; private set; }

        public override bool Equals(object obj)
        {
            MemberExpressionFingerprint other = obj as MemberExpressionFingerprint;
            return (other != null)
                   && Equals(this.Member, other.Member)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Member);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/MethodCallExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // MethodCallExpression fingerprint class
    // Expression of form xxx.Foo(...), xxx[...] (get_Item()), etc.

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class MethodCallExpressionFingerprint : ExpressionFingerprint
    {
        public MethodCallExpressionFingerprint(ExpressionType nodeType, Type type, MethodInfo method)
            : base(nodeType, type)
        {
            // Other properties on MethodCallExpression (like the argument count) are simply derived
            // from Type and Indexer, so they're not necessary for inclusion in the fingerprint.

            Method = method;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.methodcallexpression.method.aspx
        public MethodInfo Method { get; private set; }

        public override bool Equals(object obj)
        {
            MethodCallExpressionFingerprint other = obj as MethodCallExpressionFingerprint;
            return (other != null)
                   && Equals(this.Method, other.Method)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Method);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/ParameterExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // ParameterExpression fingerprint class
    // Can represent the model parameter or an inner parameter in an open lambda expression

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class ParameterExpressionFingerprint : ExpressionFingerprint
    {
        public ParameterExpressionFingerprint(ExpressionType nodeType, Type type, int parameterIndex)
            : base(nodeType, type)
        {
            ParameterIndex = parameterIndex;
        }

        // Parameter position within the overall expression, used to maintain alpha equivalence.
        public int ParameterIndex { get; private set; }

        public override bool Equals(object obj)
        {
            ParameterExpressionFingerprint other = obj as ParameterExpressionFingerprint;
            return (other != null)
                   && (this.ParameterIndex == other.ParameterIndex)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddInt32(ParameterIndex);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/TypeBinaryExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // TypeBinary fingerprint class
    // Expression of form "obj is T"

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class TypeBinaryExpressionFingerprint : ExpressionFingerprint
    {
        public TypeBinaryExpressionFingerprint(ExpressionType nodeType, Type type, Type typeOperand)
            : base(nodeType, type)
        {
            TypeOperand = typeOperand;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.typebinaryexpression.typeoperand.aspx
        public Type TypeOperand { get; private set; }

        public override bool Equals(object obj)
        {
            TypeBinaryExpressionFingerprint other = obj as TypeBinaryExpressionFingerprint;
            return (other != null)
                   && Equals(this.TypeOperand, other.TypeOperand)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(TypeOperand);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ExpressionUtil/UnaryExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Reflection;

#pragma warning disable 659 // overrides AddToHashCodeCombiner instead

namespace System.Web.Mvc.ExpressionUtil
{
    // UnaryExpression fingerprint class
    // The most common appearance of a UnaryExpression is a cast or other conversion operator

    [SuppressMessage("Microsoft.Usage", "CA2218:OverrideGetHashCodeOnOverridingEquals", Justification = "Overrides AddToHashCodeCombiner() instead.")]
    internal sealed class UnaryExpressionFingerprint : ExpressionFingerprint
    {
        public UnaryExpressionFingerprint(ExpressionType nodeType, Type type, MethodInfo method)
            : base(nodeType, type)
        {
            // Other properties on UnaryExpression (like IsLifted / IsLiftedToNull) are simply derived
            // from Type and NodeType, so they're not necessary for inclusion in the fingerprint.

            Method = method;
        }

        // http://msdn.microsoft.com/en-us/library/system.linq.expressions.unaryexpression.method.aspx
        public MethodInfo Method { get; private set; }

        public override bool Equals(object obj)
        {
            UnaryExpressionFingerprint other = obj as UnaryExpressionFingerprint;
            return (other != null)
                   && Equals(this.Method, other.Method)
                   && this.Equals(other);
        }

        internal override void AddToHashCodeCombiner(HashCodeCombiner combiner)
        {
            combiner.AddObject(Method);
            base.AddToHashCodeCombiner(combiner);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FieldValidationMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace System.Web.Mvc
{
    public class FieldValidationMetadata
    {
        private readonly Collection<ModelClientValidationRule> _validationRules = new Collection<ModelClientValidationRule>();
        private string _fieldName;

        public string FieldName
        {
            get { return _fieldName ?? String.Empty; }
            set { _fieldName = value; }
        }

        public bool ReplaceValidationMessageContents { get; set; }

        public string ValidationMessageId { get; set; }

        public ICollection<ModelClientValidationRule> ValidationRules
        {
            get { return _validationRules; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FileContentResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class FileContentResult : FileResult
    {
        public FileContentResult(byte[] fileContents, string contentType)
            : base(contentType)
        {
            if (fileContents == null)
            {
                throw new ArgumentNullException("fileContents");
            }

            FileContents = fileContents;
        }

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "There's no reason to tamper-proof this array since it's supplied to the type's constructor.")]
        public byte[] FileContents { get; private set; }

        protected override void WriteFile(HttpResponseBase response)
        {
            response.OutputStream.Write(FileContents, 0, FileContents.Length);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FileExtensionsAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    internal class FileExtensionsAttributeAdapter : DataAnnotationsModelValidator<FileExtensionsAttribute>
    {
        public FileExtensionsAttributeAdapter(ModelMetadata metadata, ControllerContext context, FileExtensionsAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            var rule = new ModelClientValidationRule
            {
                ValidationType = "extension",
                ErrorMessage = ErrorMessage
            };
            rule.ValidationParameters["extension"] = Attribute.Extensions;
            yield return rule;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FilePathResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class FilePathResult : FileResult
    {
        public FilePathResult(string fileName, string contentType)
            : base(contentType)
        {
            if (String.IsNullOrEmpty(fileName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "fileName");
            }

            FileName = fileName;
        }

        public string FileName { get; private set; }

        protected override void WriteFile(HttpResponseBase response)
        {
            response.TransmitFile(FileName);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FileResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Mime;
using System.Text;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public abstract class FileResult : ActionResult
    {
        private string _fileDownloadName;

        protected FileResult(string contentType)
        {
            if (String.IsNullOrEmpty(contentType))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "contentType");
            }

            ContentType = contentType;
        }

        public string ContentType { get; private set; }

        public string FileDownloadName
        {
            get { return _fileDownloadName ?? String.Empty; }
            set { _fileDownloadName = value; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpResponseBase response = context.HttpContext.Response;
            response.ContentType = ContentType;

            if (!String.IsNullOrEmpty(FileDownloadName))
            {
                // From RFC 2183, Sec. 2.3:
                // The sender may want to suggest a filename to be used if the entity is
                // detached and stored in a separate file. If the receiving MUA writes
                // the entity to a file, the suggested filename should be used as a
                // basis for the actual filename, where possible.
                string headerValue = ContentDispositionUtil.GetHeaderValue(FileDownloadName);
                context.HttpContext.Response.AddHeader("Content-Disposition", headerValue);
            }

            WriteFile(response);
        }

        protected abstract void WriteFile(HttpResponseBase response);

        internal static class ContentDispositionUtil
        {
            private const string HexDigits = "0123456789ABCDEF";

            private static void AddByteToStringBuilder(byte b, StringBuilder builder)
            {
                builder.Append('%');

                int i = b;
                AddHexDigitToStringBuilder(i >> 4, builder);
                AddHexDigitToStringBuilder(i % 16, builder);
            }

            private static void AddHexDigitToStringBuilder(int digit, StringBuilder builder)
            {
                builder.Append(HexDigits[digit]);
            }

            private static string CreateRfc2231HeaderValue(string filename)
            {
                StringBuilder builder = new StringBuilder("attachment; filename*=UTF-8''");

                byte[] filenameBytes = Encoding.UTF8.GetBytes(filename);
                foreach (byte b in filenameBytes)
                {
                    if (IsByteValidHeaderValueCharacter(b))
                    {
                        builder.Append((char)b);
                    }
                    else
                    {
                        AddByteToStringBuilder(b, builder);
                    }
                }

                return builder.ToString();
            }

            public static string GetHeaderValue(string fileName)
            {
                // If fileName contains any Unicode characters, encode according
                // to RFC 2231 (with clarifications from RFC 5987)
                foreach (char c in fileName)
                {
                    if ((int)c > 127)
                    {
                        return CreateRfc2231HeaderValue(fileName);
                    }
                }

                // Knowing there are no Unicode characters in this fileName, rely on
                // ContentDisposition.ToString() to encode properly.
                // In .Net 4.0, ContentDisposition.ToString() throws FormatException if
                // the file name contains Unicode characters.
                // In .Net 4.5, ContentDisposition.ToString() no longer throws FormatException
                // if it contains Unicode, and it will not encode Unicode as we require here.
                // The Unicode test above is identical to the 4.0 FormatException test,
                // allowing this helper to give the same results in 4.0 and 4.5.         
                ContentDisposition disposition = new ContentDisposition() { FileName = fileName };
                return disposition.ToString();
            }

            // Application of RFC 2231 Encoding to Hypertext Transfer Protocol (HTTP) Header Fields, sec. 3.2
            // http://greenbytes.de/tech/webdav/draft-reschke-rfc2231-in-http-latest.html
            private static bool IsByteValidHeaderValueCharacter(byte b)
            {
                if ((byte)'0' <= b && b <= (byte)'9')
                {
                    return true; // is digit
                }
                if ((byte)'a' <= b && b <= (byte)'z')
                {
                    return true; // lowercase letter
                }
                if ((byte)'A' <= b && b <= (byte)'Z')
                {
                    return true; // uppercase letter
                }

                switch (b)
                {
                    case (byte)'-':
                    case (byte)'.':
                    case (byte)'_':
                    case (byte)'~':
                    case (byte)':':
                    case (byte)'!':
                    case (byte)'$':
                    case (byte)'&':
                    case (byte)'+':
                        return true;
                }

                return false;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FileStreamResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.Mvc
{
    public class FileStreamResult : FileResult
    {
        // default buffer size as defined in BufferedStream type
        private const int BufferSize = 0x1000;

        public FileStreamResult(Stream fileStream, string contentType)
            : base(contentType)
        {
            if (fileStream == null)
            {
                throw new ArgumentNullException("fileStream");
            }

            FileStream = fileStream;
        }

        public Stream FileStream { get; private set; }

        protected override void WriteFile(HttpResponseBase response)
        {
            // grab chunks of data and write to the output stream
            Stream outputStream = response.OutputStream;
            using (FileStream)
            {
                byte[] buffer = new byte[BufferSize];

                while (true)
                {
                    int bytesRead = FileStream.Read(buffer, 0, BufferSize);
                    if (bytesRead == 0)
                    {
                        // no more data
                        break;
                    }

                    outputStream.Write(buffer, 0, bytesRead);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Filter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class Filter
    {
        public const int DefaultOrder = -1;

        public Filter(object instance, FilterScope scope, int? order)
        {
            if (instance == null)
            {
                throw new ArgumentNullException("instance");
            }

            if (order == null)
            {
                IMvcFilter mvcFilter = instance as IMvcFilter;
                if (mvcFilter != null)
                {
                    order = mvcFilter.Order;
                }
            }

            Instance = instance;
            Order = order ?? DefaultOrder;
            Scope = scope;
        }

        public object Instance { get; protected set; }

        public int Order { get; protected set; }

        public FilterScope Scope { get; protected set; }
    }
}


================================================
FILE: src/System.Web.Mvc/FilterAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Linq;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public abstract class FilterAttribute : Attribute, IMvcFilter
    {
        private static readonly ConcurrentDictionary<Type, bool> _multiuseAttributeCache = new ConcurrentDictionary<Type, bool>();
        private int _order = Filter.DefaultOrder;

        public bool AllowMultiple
        {
            get { return AllowsMultiple(GetType()); }
        }

        public int Order
        {
            get { return _order; }
            set
            {
                if (value < Filter.DefaultOrder)
                {
                    throw new ArgumentOutOfRangeException("value", MvcResources.FilterAttribute_OrderOutOfRange);
                }
                _order = value;
            }
        }

        private static bool AllowsMultiple(Type attributeType)
        {
            return _multiuseAttributeCache.GetOrAdd(
                attributeType,
                type => type.GetCustomAttributes(typeof(AttributeUsageAttribute), true)
                            .Cast<AttributeUsageAttribute>()
                            .First()
                            .AllowMultiple);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FilterAttributeFilterProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    public class FilterAttributeFilterProvider : IFilterProvider
    {
        private readonly bool _cacheAttributeInstances;

        public FilterAttributeFilterProvider()
            : this(true)
        {
        }

        public FilterAttributeFilterProvider(bool cacheAttributeInstances)
        {
            _cacheAttributeInstances = cacheAttributeInstances;
        }

        protected virtual IEnumerable<FilterAttribute> GetActionAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            return actionDescriptor.GetFilterAttributes(_cacheAttributeInstances);
        }

        protected virtual IEnumerable<FilterAttribute> GetControllerAttributes(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            return actionDescriptor.ControllerDescriptor.GetFilterAttributes(_cacheAttributeInstances);
        }

        public virtual IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            // Results are low in number in the common case so use yield return to avoid creating intermediate collections or nested enumerables
            if (controllerContext.Controller != null)
            {
                foreach (FilterAttribute attr in GetControllerAttributes(controllerContext, actionDescriptor))
                {
                    yield return new Filter(attr, FilterScope.Controller, order: null);
                }
                foreach (FilterAttribute attr in GetActionAttributes(controllerContext, actionDescriptor))
                {
                    yield return new Filter(attr, FilterScope.Action, order: null);
                }
            }             
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FilterInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Web.Mvc.Filters;

namespace System.Web.Mvc
{
    public class FilterInfo
    {
        private readonly List<IActionFilter> _actionFilters = new List<IActionFilter>();
        private readonly List<IAuthenticationFilter> _authenticationFilters = new List<IAuthenticationFilter>();
        private readonly List<IAuthorizationFilter> _authorizationFilters = new List<IAuthorizationFilter>();
        private readonly List<IExceptionFilter> _exceptionFilters = new List<IExceptionFilter>();
        private readonly List<IResultFilter> _resultFilters = new List<IResultFilter>();

        public FilterInfo()
        {
        }

        public FilterInfo(IEnumerable<Filter> filters)
        {
            // Determine the override scope for each filter type and cache the filters list.
            OverrideFilterInfo processed = ProcessOverrideFilters(filters);
            // Split the cached filters list based on filter type and override scope.
            SplitFilters(processed);
        }

        public IList<IActionFilter> ActionFilters
        {
            get { return _actionFilters; }
        }

        public IList<IAuthenticationFilter> AuthenticationFilters
        {
            get { return _authenticationFilters; }
        }

        public IList<IAuthorizationFilter> AuthorizationFilters
        {
            get { return _authorizationFilters; }
        }

        public IList<IExceptionFilter> ExceptionFilters
        {
            get { return _exceptionFilters; }
        }

        public IList<IResultFilter> ResultFilters
        {
            get { return _resultFilters; }
        }

        private static OverrideFilterInfo ProcessOverrideFilters(IEnumerable<Filter> filters)
        {
            OverrideFilterInfo result = new OverrideFilterInfo
            {
                ActionOverrideScope = FilterScope.First,
                AuthenticationOverrideScope = FilterScope.First,
                AuthorizationOverrideScope = FilterScope.First,
                ExceptionOverrideScope = FilterScope.First,
                ResultOverrideScope = FilterScope.First,
                Filters = new List<Filter>()
            };

            // Evaluate the 'filters' enumerable only once since the operation can be quite expensive.
            foreach (Filter filter in filters)
            {
                if (filter == null)
                {
                    continue;
                }
                IOverrideFilter overrideFilter = filter.Instance as IOverrideFilter;

                if (overrideFilter != null)
                {
                    if (overrideFilter.FiltersToOverride == typeof(IActionFilter)
                        && filter.Scope >= result.ActionOverrideScope)
                    {
                        result.ActionOverrideScope = filter.Scope;
                    }
                    else if (overrideFilter.FiltersToOverride == typeof(IAuthenticationFilter)
                        && filter.Scope >= result.AuthenticationOverrideScope)
                    {
                        result.AuthenticationOverrideScope = filter.Scope;
                    }
                    else if (overrideFilter.FiltersToOverride == typeof(IAuthorizationFilter)
                        && filter.Scope >= result.AuthorizationOverrideScope)
                    {
                        result.AuthorizationOverrideScope = filter.Scope;
                    }
                    else if (overrideFilter.FiltersToOverride == typeof(IExceptionFilter)
                        && filter.Scope >= result.ExceptionOverrideScope)
                    {
                        result.ExceptionOverrideScope = filter.Scope;
                    }
                    else if (overrideFilter.FiltersToOverride == typeof(IResultFilter)
                        && filter.Scope >= result.ResultOverrideScope)
                    {
                        result.ResultOverrideScope = filter.Scope;
                    }
                }

                // Cache filters to avoid having to enumerate it again (expensive). Do so here to avoid an extra loop.
                result.Filters.Add(filter);
            }

            return result;
        }

        private void SplitFilters(OverrideFilterInfo info)
        {
            Contract.Assert(info.Filters != null);

            foreach (Filter filter in info.Filters)
            {
                Contract.Assert(filter != null);

                IActionFilter actionFilter = filter.Instance as IActionFilter;

                if (actionFilter != null && filter.Scope >= info.ActionOverrideScope)
                {
                    _actionFilters.Add(actionFilter);
                }

                IAuthenticationFilter authenticationFilter = filter.Instance as IAuthenticationFilter;

                if (authenticationFilter != null && filter.Scope >= info.AuthenticationOverrideScope)
                {
                    _authenticationFilters.Add(authenticationFilter);
                }

                IAuthorizationFilter authorizationFilter = filter.Instance as IAuthorizationFilter;

                if (authorizationFilter != null && filter.Scope >= info.AuthorizationOverrideScope)
                {
                    _authorizationFilters.Add(authorizationFilter);
                }

                IExceptionFilter exceptionFilter = filter.Instance as IExceptionFilter;

                if (exceptionFilter != null && filter.Scope >= info.ExceptionOverrideScope)
                {
                    _exceptionFilters.Add(exceptionFilter);
                }

                IResultFilter resultFilter = filter.Instance as IResultFilter;

                if (resultFilter != null && filter.Scope >= info.ResultOverrideScope)
                {
                    _resultFilters.Add(resultFilter);
                }
            }
        }

        private struct OverrideFilterInfo
        {
            public FilterScope ActionOverrideScope;
            public FilterScope AuthenticationOverrideScope;
            public FilterScope AuthorizationOverrideScope;
            public FilterScope ExceptionOverrideScope;
            public FilterScope ResultOverrideScope;

            public List<Filter> Filters;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FilterProviderCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace System.Web.Mvc
{
    public class FilterProviderCollection : Collection<IFilterProvider>
    {
        private static FilterComparer _filterComparer = new FilterComparer();
        private IFilterProvider[] _combinedItems;
        private IDependencyResolver _dependencyResolver;

        public FilterProviderCollection()
        {
        }

        public FilterProviderCollection(IList<IFilterProvider> providers)
            : base(providers)
        {
        }

        internal FilterProviderCollection(IList<IFilterProvider> list, IDependencyResolver dependencyResolver)
            : base(list)
        {
            _dependencyResolver = dependencyResolver;
        }

        internal IFilterProvider[] CombinedItems
        {
            get
            {
                IFilterProvider[] combinedItems = _combinedItems;
                if (combinedItems == null)
                {
                    combinedItems = MultiServiceResolver.GetCombined<IFilterProvider>(Items, _dependencyResolver);
                    _combinedItems = combinedItems;
                }
                return combinedItems;
            }
        }

        private static bool AllowMultiple(object filterInstance)
        {
            IMvcFilter mvcFilter = filterInstance as IMvcFilter;
            if (mvcFilter == null)
            {
                return true;
            }

            return mvcFilter.AllowMultiple;
        }

        public IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            IFilterProvider[] providers = CombinedItems;
            List<Filter> filters = new List<Filter>();
            for (int i = 0; i < providers.Length; i++)
            {
                IFilterProvider provider = providers[i];
                foreach (Filter filter in provider.GetFilters(controllerContext, actionDescriptor))
                {
                    filters.Add(filter);
                }
            }

            filters.Sort(_filterComparer);

            if (filters.Count > 1)
            {
                RemoveDuplicates(filters);
            }
            return filters;
        }

        private static void RemoveDuplicates(List<Filter> filters)
        {
            HashSet<Type> visitedTypes = new HashSet<Type>();

            // Remove duplicates from the back forward
            for (int i = filters.Count - 1; i >= 0; i--)
            {
                Filter filter = filters[i];
                object filterInstance = filter.Instance;
                Type filterInstanceType = filterInstance.GetType();

                if (!visitedTypes.Contains(filterInstanceType) || AllowMultiple(filterInstance))
                {
                    visitedTypes.Add(filterInstanceType);
                }
                else
                {
                    filters.RemoveAt(i);                        
                }
            }
        }

        protected override void ClearItems()
        {
            _combinedItems = null;
            base.ClearItems();
        }

        protected override void InsertItem(int index, IFilterProvider item)
        {
            _combinedItems = null;
            base.InsertItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            _combinedItems = null;
            base.RemoveItem(index);
        }

        protected override void SetItem(int index, IFilterProvider item)
        {
            _combinedItems = null;
            base.SetItem(index, item);
        }

        private class FilterComparer : IComparer<Filter>
        {
            public int Compare(Filter x, Filter y)
            {
                // Nulls always have to be less than non-nulls
                if (x == null && y == null)
                {
                    return 0;
                }
                if (x == null)
                {
                    return -1;
                }
                if (y == null)
                {
                    return 1;
                }

                // Sort first by order...

                if (x.Order < y.Order)
                {
                    return -1;
                }
                if (x.Order > y.Order)
                {
                    return 1;
                }

                // ...then by scope

                if (x.Scope < y.Scope)
                {
                    return -1;
                }
                if (x.Scope > y.Scope)
                {
                    return 1;
                }

                return 0;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FilterProviders.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class FilterProviders
    {
        static FilterProviders()
        {
            Providers = new FilterProviderCollection();
            Providers.Add(GlobalFilters.Filters);
            Providers.Add(new FilterAttributeFilterProvider());
            Providers.Add(new ControllerInstanceFilterProvider());
        }

        public static FilterProviderCollection Providers { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/FilterScope.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public enum FilterScope
    {
        First = 0,
        Global = 10,
        Controller = 20,
        Action = 30,
        Last = 100,
    }
}


================================================
FILE: src/System.Web.Mvc/Filters/AuthenticationChallengeContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Filters
{
    /// <summary>
    /// Represents an authentication challenge context containing information for executing an authentication
    /// challenge.
    /// </summary>
    public class AuthenticationChallengeContext : ControllerContext
    {
        private ActionDescriptor _actionDescriptor;
        private ActionResult _result;

        /// <summary>Initializes a new instance of the <see cref="AuthenticationChallengeContext"/> class.</summary>
        /// <remarks>This constructor should only be used for unit testing purposes.</remarks>
        public AuthenticationChallengeContext()
        {
        }

        /// <summary>Initializes a new instance of the <see cref="AuthenticationChallengeContext"/> class.</summary>
        /// <param name="controllerContext">The controller context.</param>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <param name="result">The current action result.</param>
        public AuthenticationChallengeContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor,
            ActionResult result)
            : base(controllerContext)
        {
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            _actionDescriptor = actionDescriptor;
            _result = result;
        }

        /// <summary>Gets or sets the action descriptor.</summary>
        public ActionDescriptor ActionDescriptor
        {
            get
            {
                return _actionDescriptor;
            }
            set
            {
                _actionDescriptor = value;
            }
        }

        /// <summary>Gets or sets the action result to execute.</summary>
        /// <remarks>
        /// Authentication filters wishing to add an authentication challenge will often chain the result (set the
        /// value to an action result that executes the previous value and then does something additional, such as add
        /// a WWW-Authenticate header).
        /// </remarks>
        public ActionResult Result
        {
            get
            {
                return _result;
            }
            set
            {
                _result = value;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Filters/AuthenticationContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Principal;

namespace System.Web.Mvc.Filters
{
    /// <summary>Represents an authentication context containing information for performing authentication.</summary>
    public class AuthenticationContext : ControllerContext
    {
        /// <summary>Initializes a new instance of the <see cref="AuthenticationContext"/> class.</summary>
        /// <remarks>This constructor should only be used for unit testing purposes.</remarks>
        public AuthenticationContext()
        {
        }

        /// <summary>Initializes a new instance of the <see cref="AuthenticationContext"/> class.</summary>
        /// <param name="controllerContext">The controller context.</param>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <param name="principal">The current principal.</param>
        public AuthenticationContext(ControllerContext controllerContext, ActionDescriptor actionDescriptor,
            IPrincipal principal)
            : base(controllerContext)
        {
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            ActionDescriptor = actionDescriptor;
            Principal = principal;
        }

        /// <summary>Gets or sets the action descriptor.</summary>
        public ActionDescriptor ActionDescriptor { get; set; }

        /// <summary>Gets or sets the currently authenticated principal.</summary>
        public IPrincipal Principal { get; set; }

        /// <summary>
        /// Gets or sets the error result, which indicates that authentication was attempted and failed.
        /// </summary>
        public ActionResult Result { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/Filters/IAuthenticationFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Filters
{
    /// <summary>Defines a filter that performs authentication.</summary>
    public interface IAuthenticationFilter
    {
        /// <summary>Authenticates the request.</summary>
        /// <param name="filterContext">The context to use for authentication.</param>
        void OnAuthentication(AuthenticationContext filterContext);

        /// <summary>Adds an authentication challenge to the current <see cref="ActionResult"/>.</summary>
        /// <param name="filterContext">The context to use for the authentication challenge.</param>
        void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext);
    }
}


================================================
FILE: src/System.Web.Mvc/Filters/IOverrideFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Filters
{
    /// <summary>Defines a filter that overrides other filters.</summary>
    public interface IOverrideFilter
    {
        /// <summary>Gets the type of filters to override.</summary>
        /// <remarks>
        /// The following types of filters may be overridden:
        /// <list type="bullet">
        /// <item><description><see cref="IActionFilter"/></description></item>
        /// <item><description><see cref="IAuthenticationFilter"/></description></item>
        /// <item><description><see cref="IAuthorizationFilter"/></description></item>
        /// <item><description><see cref="IExceptionFilter"/></description></item>
        /// <item><description><see cref="IResultFilter"/></description></item>
        /// </list>
        /// </remarks>
        Type FiltersToOverride { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/FormCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Helpers;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Usage", "CA2237:MarkISerializableTypesWithSerializable", Justification = "It is not anticipated that users will need to serialize this type.")]
    [SuppressMessage("Microsoft.Design", "CA1035:ICollectionImplementationsHaveStronglyTypedMembers", Justification = "It is not anticipated that users will call FormCollection.CopyTo().")]
    [FormCollectionBinder]
    public sealed class FormCollection : NameValueCollection, IValueProvider
    {
        public FormCollection()
        {
        }

        public FormCollection(NameValueCollection collection)
        {
            if (collection == null)
            {
                throw new ArgumentNullException("collection");
            }

            Add(collection);
        }

        internal FormCollection(ControllerBase controller, Func<NameValueCollection> validatedValuesThunk, Func<NameValueCollection> unvalidatedValuesThunk)
        {
            Add(controller == null || controller.ValidateRequest ? validatedValuesThunk() : unvalidatedValuesThunk());
        }

        public ValueProviderResult GetValue(string name)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            string[] rawValue = GetValues(name);
            if (rawValue == null)
            {
                return null;
            }

            string attemptedValue = this[name];
            return new ValueProviderResult(rawValue, attemptedValue, CultureInfo.CurrentCulture);
        }

        public IValueProvider ToValueProvider()
        {
            return this;
        }

        #region IValueProvider Members

        bool IValueProvider.ContainsPrefix(string prefix)
        {
            return ValueProviderUtil.CollectionContainsPrefix(AllKeys, prefix);
        }

        ValueProviderResult IValueProvider.GetValue(string key)
        {
            return GetValue(key);
        }

        #endregion

        private sealed class FormCollectionBinderAttribute : CustomModelBinderAttribute
        {
            // since the FormCollectionModelBinder.BindModel() method is thread-safe, we only need to keep
            // a single instance of the binder around
            private static readonly FormCollectionModelBinder _binder = new FormCollectionModelBinder();

            public override IModelBinder GetBinder()
            {
                return _binder;
            }

            // this class is used for generating a FormCollection object
            private sealed class FormCollectionModelBinder : IModelBinder
            {
                public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
                {
                    if (controllerContext == null)
                    {
                        throw new ArgumentNullException("controllerContext");
                    }

                    return new FormCollection(controllerContext.Controller,
                                              () => controllerContext.HttpContext.Request.Form,
                                              () => controllerContext.HttpContext.Request.Unvalidated.Form);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FormContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Script.Serialization;

namespace System.Web.Mvc
{
    public class FormContext
    {
        private readonly Dictionary<string, FieldValidationMetadata> _fieldValidators = new Dictionary<string, FieldValidationMetadata>();
        private readonly Dictionary<string, bool> _renderedFields = new Dictionary<string, bool>();

        public IDictionary<string, FieldValidationMetadata> FieldValidators
        {
            get { return _fieldValidators; }
        }

        public string FormId { get; set; }

        public bool ReplaceValidationSummary { get; set; }

        public string ValidationSummaryId { get; set; }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Performs a potentially time-consuming conversion.")]
        public string GetJsonValidationMetadata()
        {
            JavaScriptSerializer serializer = new JavaScriptSerializer();

            SortedDictionary<string, object> dict = new SortedDictionary<string, object>()
            {
                { "Fields", FieldValidators.Values },
                { "FormId", FormId }
            };
            if (!String.IsNullOrEmpty(ValidationSummaryId))
            {
                dict["ValidationSummaryId"] = ValidationSummaryId;
            }
            dict["ReplaceValidationSummary"] = ReplaceValidationSummary;

            return serializer.Serialize(dict);
        }

        public FieldValidationMetadata GetValidationMetadataForField(string fieldName)
        {
            return GetValidationMetadataForField(fieldName, false /* createIfNotFound */);
        }

        public FieldValidationMetadata GetValidationMetadataForField(string fieldName, bool createIfNotFound)
        {
            if (String.IsNullOrEmpty(fieldName))
            {
                throw Error.ParameterCannotBeNullOrEmpty("fieldName");
            }

            FieldValidationMetadata metadata;
            if (!FieldValidators.TryGetValue(fieldName, out metadata))
            {
                if (createIfNotFound)
                {
                    metadata = new FieldValidationMetadata()
                    {
                        FieldName = fieldName
                    };
                    FieldValidators[fieldName] = metadata;
                }
            }
            return metadata;
        }

        public bool RenderedField(string fieldName)
        {
            bool result;
            _renderedFields.TryGetValue(fieldName, out result);
            return result;
        }

        public void RenderedField(string fieldName, bool value)
        {
            _renderedFields[fieldName] = value;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FormMethod.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public enum FormMethod
    {
        Get,
        Post
    }
}


================================================
FILE: src/System.Web.Mvc/FormValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Helpers;

namespace System.Web.Mvc
{
    public sealed class FormValueProvider : NameValueCollectionValueProvider
    {
        public FormValueProvider(ControllerContext controllerContext)
            : this(controllerContext, new UnvalidatedRequestValuesWrapper(controllerContext.HttpContext.Request.Unvalidated))
        {
        }

        // For unit testing
        internal FormValueProvider(ControllerContext controllerContext, IUnvalidatedRequestValues unvalidatedValues)
            : base(controllerContext.HttpContext.Request.Form, unvalidatedValues.Form, CultureInfo.CurrentCulture)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/FormValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Helpers;

namespace System.Web.Mvc
{
    public sealed class FormValueProviderFactory : ValueProviderFactory
    {
        private readonly UnvalidatedRequestValuesAccessor _unvalidatedValuesAccessor;

        public FormValueProviderFactory()
            : this(null)
        {
        }

        // For unit testing
        internal FormValueProviderFactory(UnvalidatedRequestValuesAccessor unvalidatedValuesAccessor)
        {
            _unvalidatedValuesAccessor = unvalidatedValuesAccessor ?? (cc => new UnvalidatedRequestValuesWrapper(cc.HttpContext.Request.Unvalidated));
        }

        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            return new FormValueProvider(controllerContext, _unvalidatedValuesAccessor(controllerContext));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/GlobalFilterCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc.Filters;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public sealed class GlobalFilterCollection : IEnumerable<Filter>, IFilterProvider
    {
        private List<Filter> _filters = new List<Filter>();

        public int Count
        {
            get { return _filters.Count; }
        }

        public void Add(object filter)
        {
            AddInternal(filter, order: null);
        }

        public void Add(object filter, int order)
        {
            AddInternal(filter, order);
        }

        private void AddInternal(object filter, int? order)
        {
            ValidateFilterInstance(filter);
            _filters.Add(new Filter(filter, FilterScope.Global, order));
        }

        public void Clear()
        {
            _filters.Clear();
        }

        public bool Contains(object filter)
        {
            return _filters.Any(f => f.Instance == filter);
        }

        public IEnumerator<Filter> GetEnumerator()
        {
            return _filters.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _filters.GetEnumerator();
        }

        IEnumerable<Filter> IFilterProvider.GetFilters(ControllerContext controllerContext,
            ActionDescriptor actionDescriptor)
        {
            return this;
        }

        public void Remove(object filter)
        {
            _filters.RemoveAll(f => f.Instance == filter);
        }

        private static void ValidateFilterInstance(object instance)
        {
            if (instance != null && !(
                instance is IActionFilter ||
                instance is IAuthorizationFilter ||
                instance is IExceptionFilter ||
                instance is IResultFilter ||
                instance is IAuthenticationFilter))
            {
                throw Error.InvalidOperation(MvcResources.GlobalFilterCollection_UnsupportedFilterInstance,
                    typeof(IAuthorizationFilter).FullName,
                    typeof(IActionFilter).FullName,
                    typeof(IResultFilter).FullName,
                    typeof(IExceptionFilter).FullName,
                    typeof(IAuthenticationFilter).FullName);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/GlobalFilters.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class GlobalFilters
    {
        static GlobalFilters()
        {
            Filters = new GlobalFilterCollection();
        }

        public static GlobalFilterCollection Filters { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project. 
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc. 
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File". 
// You do not need to add suppressions to this file manually. 

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "Assembly is delay-signed.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Mvc.Ajax", Justification = "Helpers reside within a separate namespace to support alternate helper classes.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope = "member", Target = "System.Web.Mvc.TempDataDictionary.#System.Collections.Generic.ICollection`1<System.Collections.Generic.KeyValuePair`2<System.String,System.Object>>.Contains(System.Collections.Generic.KeyValuePair`2<System.String,System.Object>)", Justification = "There are no defined scenarios for wanting to derive from this class, but we don't want to prevent it either.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope = "member", Target = "System.Web.Mvc.TempDataDictionary.#System.Collections.Generic.ICollection`1<System.Collections.Generic.KeyValuePair`2<System.String,System.Object>>.CopyTo(System.Collections.Generic.KeyValuePair`2<System.String,System.Object>[],System.Int32)", Justification = "There are no defined scenarios for wanting to derive from this class, but we don't want to prevent it either.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Scope = "member", Target = "System.Web.Mvc.TempDataDictionary.#System.Collections.Generic.ICollection`1<System.Collections.Generic.KeyValuePair`2<System.String,System.Object>>.IsReadOnly", Justification = "There are no defined scenarios for wanting to derive from this class, but we don't want to prevent it either.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "Param", Scope = "resource", Target = "System.Web.Mvc.Properties.MvcResources.resources", Justification = "This is the name that matches ASP.NET")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Mvc.Razor", Justification = "This is a grouping of functionally similar components, thus a namespace is a valid way to group them.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Mvc.Filters", Justification = "Starting to move away from one big namespace. We have to start (small) somewhere.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Mvc.Routing", Justification = "Starting to move away from one big namespace. We have to start (small) somewhere.")]

================================================
FILE: src/System.Web.Mvc/HandleErrorAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This attribute is AllowMultiple = true and users might want to override behavior.")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
    public class HandleErrorAttribute : FilterAttribute, IExceptionFilter
    {
        private const string DefaultView = "Error";

        private readonly object _typeId = new object();

        private Type _exceptionType = typeof(Exception);
        private string _master;
        private string _view;

        public Type ExceptionType
        {
            get { return _exceptionType; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                if (!typeof(Exception).IsAssignableFrom(value))
                {
                    throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                              MvcResources.ExceptionViewAttribute_NonExceptionType, value.FullName));
                }

                _exceptionType = value;
            }
        }

        public string Master
        {
            get { return _master ?? String.Empty; }
            set { _master = value; }
        }

        public override object TypeId
        {
            get { return _typeId; }
        }

        public string View
        {
            get { return (!String.IsNullOrEmpty(_view)) ? _view : DefaultView; }
            set { _view = value; }
        }

        public virtual void OnException(ExceptionContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }
            if (filterContext.IsChildAction)
            {
                return;
            }

            // If custom errors are disabled, we need to let the normal ASP.NET exception handler
            // execute so that the user can see useful debugging information.
            if (filterContext.ExceptionHandled || !filterContext.HttpContext.IsCustomErrorEnabled)
            {
                return;
            }

            Exception exception = filterContext.Exception;

            // If this is not an HTTP 500 (for example, if somebody throws an HTTP 404 from an action method),
            // ignore it.
            if (new HttpException(null, exception).GetHttpCode() != 500)
            {
                return;
            }

            if (!ExceptionType.IsInstanceOfType(exception))
            {
                return;
            }

            string controllerName = (string)filterContext.RouteData.Values["controller"];
            string actionName = (string)filterContext.RouteData.Values["action"];
            HandleErrorInfo model = new HandleErrorInfo(filterContext.Exception, controllerName, actionName);
            filterContext.Result = new ViewResult
            {
                ViewName = View,
                MasterName = Master,
                ViewData = new ViewDataDictionary<HandleErrorInfo>(model),
                TempData = filterContext.Controller.TempData
            };
            filterContext.ExceptionHandled = true;
            filterContext.HttpContext.Response.Clear();
            filterContext.HttpContext.Response.StatusCode = 500;

            // Certain versions of IIS will sometimes use their own error page when
            // they detect a server error. Setting this property indicates that we
            // want it to try to render ASP.NET MVC's error page instead.
            filterContext.HttpContext.Response.TrySkipIisCustomErrors = true;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HandleErrorInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class HandleErrorInfo
    {
        public HandleErrorInfo(Exception exception, string controllerName, string actionName)
        {
            if (exception == null)
            {
                throw new ArgumentNullException("exception");
            }
            if (String.IsNullOrEmpty(controllerName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controllerName");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
            }

            Exception = exception;
            ControllerName = controllerName;
            ActionName = actionName;
        }

        public string ActionName { get; private set; }

        public string ControllerName { get; private set; }

        public Exception Exception { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/HiddenInputAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property, AllowMultiple = false, Inherited = true)]
    public sealed class HiddenInputAttribute : Attribute
    {
        public HiddenInputAttribute()
        {
            DisplayValue = true;
        }

        public bool DisplayValue { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/ChildActionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc.Html
{
    public static class ChildActionExtensions
    {
        // Action

        public static MvcHtmlString Action(this HtmlHelper htmlHelper, string actionName)
        {
            return Action(htmlHelper, actionName, null /* controllerName */, null /* routeValues */);
        }

        public static MvcHtmlString Action(this HtmlHelper htmlHelper, string actionName, object routeValues)
        {
            return Action(htmlHelper, actionName, null /* controllerName */, TypeHelper.ObjectToDictionary(routeValues));
        }

        public static MvcHtmlString Action(this HtmlHelper htmlHelper, string actionName, RouteValueDictionary routeValues)
        {
            return Action(htmlHelper, actionName, null /* controllerName */, routeValues);
        }

        public static MvcHtmlString Action(this HtmlHelper htmlHelper, string actionName, string controllerName)
        {
            return Action(htmlHelper, actionName, controllerName, null /* routeValues */);
        }

        public static MvcHtmlString Action(this HtmlHelper htmlHelper, string actionName, string controllerName, object routeValues)
        {
            return Action(htmlHelper, actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues));
        }

        public static MvcHtmlString Action(this HtmlHelper htmlHelper, string actionName, string controllerName, RouteValueDictionary routeValues)
        {
            using (StringWriter writer = new StringWriter(CultureInfo.CurrentCulture))
            {
                ActionHelper(htmlHelper, actionName, controllerName, routeValues, writer);
                return MvcHtmlString.Create(writer.ToString());
            }
        }

        // RenderAction

        public static void RenderAction(this HtmlHelper htmlHelper, string actionName)
        {
            RenderAction(htmlHelper, actionName, null /* controllerName */, null /* routeValues */);
        }

        public static void RenderAction(this HtmlHelper htmlHelper, string actionName, object routeValues)
        {
            RenderAction(htmlHelper, actionName, null /* controllerName */, TypeHelper.ObjectToDictionary(routeValues));
        }

        public static void RenderAction(this HtmlHelper htmlHelper, string actionName, RouteValueDictionary routeValues)
        {
            RenderAction(htmlHelper, actionName, null /* controllerName */, routeValues);
        }

        public static void RenderAction(this HtmlHelper htmlHelper, string actionName, string controllerName)
        {
            RenderAction(htmlHelper, actionName, controllerName, null /* routeValues */);
        }

        public static void RenderAction(this HtmlHelper htmlHelper, string actionName, string controllerName, object routeValues)
        {
            RenderAction(htmlHelper, actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues));
        }

        public static void RenderAction(this HtmlHelper htmlHelper, string actionName, string controllerName, RouteValueDictionary routeValues)
        {
            ActionHelper(htmlHelper, actionName, controllerName, routeValues, htmlHelper.ViewContext.Writer);
        }

        // Helpers

        internal static void ActionHelper(HtmlHelper htmlHelper, string actionName, string controllerName, RouteValueDictionary routeValues, TextWriter textWriter)
        {
            if (htmlHelper == null)
            {
                throw new ArgumentNullException("htmlHelper");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
            }

            RouteValueDictionary additionalRouteValues = routeValues;
            routeValues = MergeDictionaries(routeValues, htmlHelper.ViewContext.RouteData.Values);

            routeValues["action"] = actionName;
            if (!String.IsNullOrEmpty(controllerName))
            {
                routeValues["controller"] = controllerName;
            }

            bool usingAreas;
            VirtualPathData vpd = htmlHelper.RouteCollection.GetVirtualPathForArea(htmlHelper.ViewContext.RequestContext, null /* name */, routeValues, out usingAreas);
            if (vpd == null)
            {
                throw new InvalidOperationException(MvcResources.Common_NoRouteMatched);
            }

            if (usingAreas)
            {
                routeValues.Remove("area");
                if (additionalRouteValues != null)
                {
                    additionalRouteValues.Remove("area");
                }
            }

            if (additionalRouteValues != null)
            {
                routeValues[ChildActionValueProvider.ChildActionValuesKey] = new DictionaryValueProvider<object>(additionalRouteValues, CultureInfo.InvariantCulture);
            }

            RouteData routeData = CreateRouteData(vpd.Route, routeValues, vpd.DataTokens, htmlHelper.ViewContext);
            HttpContextBase httpContext = htmlHelper.ViewContext.HttpContext;
            RequestContext requestContext = new RequestContext(httpContext, routeData);
            ChildActionMvcHandler handler = new ChildActionMvcHandler(requestContext);
            httpContext.Server.Execute(HttpHandlerUtil.WrapForServerExecute(handler), textWriter, true /* preserveForm */);
        }

        private static RouteData CreateRouteData(RouteBase route, RouteValueDictionary routeValues, RouteValueDictionary dataTokens, ViewContext parentViewContext)
        {
            RouteData routeData = new RouteData();

            foreach (KeyValuePair<string, object> kvp in routeValues)
            {
                routeData.Values.Add(kvp.Key, kvp.Value);
            }

            foreach (KeyValuePair<string, object> kvp in dataTokens)
            {
                routeData.DataTokens.Add(kvp.Key, kvp.Value);
            }

            routeData.Route = route;
            routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = parentViewContext;

            // It's possible that the outgoing route is a direct route - in which case it's not possible to reach using
            // the action name and controller name. We need to check for that case to determine if we need to create a 
            // 'direct route' routedata to reach it.
            if (route.IsDirectRoute())
            {
                // Codeplex-2136 - ControllerContext.IsChildAction returns false inside Controller.Initialize()
                //
                // We're constructing a 'temp' route data to wrap the route data for the match we're invoking via
                // an attribute route. The ControllerContext will look at datatokens to see if it's being invoked
                // as a child action. 
                //
                // By sticking the view context on both route data ControllerContext will do the right thing
                // at all parts of the pipeline.
                var directRouteData = RouteCollectionRoute.CreateDirectRouteMatch(route, new List<RouteData>() { routeData });
                directRouteData.DataTokens[ControllerContext.ParentActionViewContextToken] = parentViewContext;
                return directRouteData;
            }
            else
            {
                return routeData;
            }
        }

        private static RouteValueDictionary MergeDictionaries(params RouteValueDictionary[] dictionaries)
        {
            // Merge existing route values with the user provided values
            var result = new RouteValueDictionary();

            foreach (RouteValueDictionary dictionary in dictionaries.Where(d => d != null))
            {
                foreach (KeyValuePair<string, object> kvp in dictionary)
                {
                    if (!result.ContainsKey(kvp.Key))
                    {
                        result.Add(kvp.Key, kvp.Value);
                    }
                }
            }

            return result;
        }

        internal class ChildActionMvcHandler : MvcHandler
        {
            public ChildActionMvcHandler(RequestContext context)
                : base(context)
            {
            }

            protected internal override void AddVersionHeader(HttpContextBase httpContext)
            {
                // No version header for child actions
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/DefaultDisplayTemplates.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Mvc.Properties;
using System.Web.UI.WebControls;

namespace System.Web.Mvc.Html
{
    internal static class DefaultDisplayTemplates
    {
        internal static string BooleanTemplate(HtmlHelper html)
        {
            bool? value = null;
            if (html.ViewContext.ViewData.Model != null)
            {
                value = Convert.ToBoolean(html.ViewContext.ViewData.Model, CultureInfo.InvariantCulture);
            }

            return html.ViewContext.ViewData.ModelMetadata.IsNullableValueType
                       ? BooleanTemplateDropDownList(value)
                       : BooleanTemplateCheckbox(value ?? false);
        }

        private static string BooleanTemplateCheckbox(bool value)
        {
            TagBuilder inputTag = new TagBuilder("input");
            inputTag.AddCssClass("check-box");
            inputTag.Attributes["disabled"] = "disabled";
            inputTag.Attributes["type"] = "checkbox";
            if (value)
            {
                inputTag.Attributes["checked"] = "checked";
            }

            return inputTag.ToString(TagRenderMode.SelfClosing);
        }

        private static string BooleanTemplateDropDownList(bool? value)
        {
            StringBuilder builder = new StringBuilder();

            TagBuilder selectTag = new TagBuilder("select");
            selectTag.AddCssClass("list-box");
            selectTag.AddCssClass("tri-state");
            selectTag.Attributes["disabled"] = "disabled";
            builder.Append(selectTag.ToString(TagRenderMode.StartTag));

            foreach (SelectListItem item in DefaultEditorTemplates.TriStateValues(value))
            {
                builder.Append(SelectExtensions.ListItemToOption(item));
            }

            builder.Append(selectTag.ToString(TagRenderMode.EndTag));
            return builder.ToString();
        }

        internal static string CollectionTemplate(HtmlHelper html)
        {
            return CollectionTemplate(html, TemplateHelpers.TemplateHelper);
        }

        internal static string CollectionTemplate(HtmlHelper html, TemplateHelpers.TemplateHelperDelegate templateHelper)
        {
            object model = html.ViewContext.ViewData.ModelMetadata.Model;
            if (model == null)
            {
                return String.Empty;
            }

            IEnumerable collection = model as IEnumerable;
            if (collection == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Templates_TypeMustImplementIEnumerable,
                        model.GetType().FullName));
            }

            Type typeInCollection = typeof(string);
            Type genericEnumerableType = TypeHelpers.ExtractGenericInterface(collection.GetType(), typeof(IEnumerable<>));
            if (genericEnumerableType != null)
            {
                typeInCollection = genericEnumerableType.GetGenericArguments()[0];
            }
            bool typeInCollectionIsNullableValueType = TypeHelpers.IsNullableValueType(typeInCollection);

            string oldPrefix = html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix;

            try
            {
                html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = String.Empty;

                string fieldNameBase = oldPrefix;
                StringBuilder result = new StringBuilder();
                int index = 0;

                foreach (object item in collection)
                {
                    Type itemType = typeInCollection;
                    if (item != null && !typeInCollectionIsNullableValueType)
                    {
                        itemType = item.GetType();
                    }
                    ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => item, itemType);
                    string fieldName = String.Format(CultureInfo.InvariantCulture, "{0}[{1}]", fieldNameBase, index++);
                    string output = templateHelper(html, metadata, fieldName, null /* templateName */, DataBoundControlMode.ReadOnly, null /* additionalViewData */);
                    result.Append(output);
                }

                return result.ToString();
            }
            finally
            {
                html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = oldPrefix;
            }
        }

        internal static string DecimalTemplate(HtmlHelper html)
        {
            if (html.ViewContext.ViewData.TemplateInfo.FormattedModelValue == html.ViewContext.ViewData.ModelMetadata.Model)
            {
                html.ViewContext.ViewData.TemplateInfo.FormattedModelValue = String.Format(CultureInfo.CurrentCulture, "{0:0.00}", html.ViewContext.ViewData.ModelMetadata.Model);
            }

            return StringTemplate(html);
        }

        internal static string EmailAddressTemplate(HtmlHelper html)
        {
            return String.Format(CultureInfo.InvariantCulture,
                                 "<a href=\"mailto:{0}\">{1}</a>",
                                 html.AttributeEncode(html.ViewContext.ViewData.Model),
                                 html.Encode(html.ViewContext.ViewData.TemplateInfo.FormattedModelValue));
        }

        internal static string HiddenInputTemplate(HtmlHelper html)
        {
            if (html.ViewContext.ViewData.ModelMetadata.HideSurroundingHtml)
            {
                return String.Empty;
            }
            return StringTemplate(html);
        }

        internal static string HtmlTemplate(HtmlHelper html)
        {
            return html.ViewContext.ViewData.TemplateInfo.FormattedModelValue.ToString();
        }

        internal static string ObjectTemplate(HtmlHelper html)
        {
            return ObjectTemplate(html, TemplateHelpers.TemplateHelper);
        }

        internal static string ObjectTemplate(HtmlHelper html, TemplateHelpers.TemplateHelperDelegate templateHelper)
        {
            ViewDataDictionary viewData = html.ViewContext.ViewData;
            TemplateInfo templateInfo = viewData.TemplateInfo;
            ModelMetadata modelMetadata = viewData.ModelMetadata;
            StringBuilder builder = new StringBuilder();

            if (modelMetadata.Model == null)
            {
                // DDB #225237
                return modelMetadata.NullDisplayText;
            }

            if (templateInfo.TemplateDepth > 1)
            {
                // DDB #224751
                string text = modelMetadata.SimpleDisplayText;
                if (modelMetadata.HtmlEncode)
                {
                    text = html.Encode(text);
                }

                return text;
            }

            foreach (ModelMetadata propertyMetadata in modelMetadata.Properties.Where(pm => ShouldShow(pm, templateInfo)))
            {
                if (!propertyMetadata.HideSurroundingHtml)
                {
                    string label = propertyMetadata.GetDisplayName();
                    if (!String.IsNullOrEmpty(label))
                    {
                        builder.AppendFormat(CultureInfo.InvariantCulture, "<div class=\"display-label\">{0}</div>", label);
                        builder.AppendLine();
                    }

                    builder.Append("<div class=\"display-field\">");
                }

                builder.Append(templateHelper(html, propertyMetadata, propertyMetadata.PropertyName, null /* templateName */, DataBoundControlMode.ReadOnly, null /* additionalViewData */));

                if (!propertyMetadata.HideSurroundingHtml)
                {
                    builder.AppendLine("</div>");
                }
            }

            return builder.ToString();
        }

        private static bool ShouldShow(ModelMetadata metadata, TemplateInfo templateInfo)
        {
            return
                metadata.ShowForDisplay
                && metadata.ModelType != typeof(EntityState)
                && !metadata.IsComplexType
                && !templateInfo.Visited(metadata);
        }

        internal static string StringTemplate(HtmlHelper html)
        {
            return html.Encode(html.ViewContext.ViewData.TemplateInfo.FormattedModelValue);
        }

        internal static string UrlTemplate(HtmlHelper html)
        {
            return String.Format(CultureInfo.InvariantCulture,
                                 "<a href=\"{0}\">{1}</a>",
                                 html.AttributeEncode(html.ViewContext.ViewData.Model),
                                 html.Encode(html.ViewContext.ViewData.TemplateInfo.FormattedModelValue));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/DefaultEditorTemplates.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Data;
using System.Data.Linq;
using System.Drawing;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Configuration;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.UI.WebControls;

namespace System.Web.Mvc.Html
{
    internal static class DefaultEditorTemplates
    {
        private const string HtmlAttributeKey = "htmlAttributes";
        private const string UsePasswordValue = "Switch.System.Web.Mvc.UsePasswordValue";

        internal static string BooleanTemplate(HtmlHelper html)
        {
            bool? value = null;
            if (html.ViewContext.ViewData.Model != null)
            {
                value = Convert.ToBoolean(html.ViewContext.ViewData.Model, CultureInfo.InvariantCulture);
            }

            return html.ViewContext.ViewData.ModelMetadata.IsNullableValueType
                       ? BooleanTemplateDropDownList(html, value)
                       : BooleanTemplateCheckbox(html, value ?? false);
        }

        private static string BooleanTemplateCheckbox(HtmlHelper html, bool value)
        {
            return html.CheckBox(String.Empty, value, CreateHtmlAttributes(html, "check-box")).ToHtmlString();
        }

        private static string BooleanTemplateDropDownList(HtmlHelper html, bool? value)
        {
            return html.DropDownList(String.Empty, TriStateValues(value), CreateHtmlAttributes(html, "list-box tri-state")).ToHtmlString();
        }

        internal static string CollectionTemplate(HtmlHelper html)
        {
            return CollectionTemplate(html, TemplateHelpers.TemplateHelper);
        }

        internal static string CollectionTemplate(HtmlHelper html, TemplateHelpers.TemplateHelperDelegate templateHelper)
        {
            ViewDataDictionary viewData = html.ViewContext.ViewData;
            object model = viewData.ModelMetadata.Model;
            if (model == null)
            {
                return String.Empty;
            }

            IEnumerable collection = model as IEnumerable;
            if (collection == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.Templates_TypeMustImplementIEnumerable,
                        model.GetType().FullName));
            }

            Type typeInCollection = typeof(string);
            Type genericEnumerableType = TypeHelpers.ExtractGenericInterface(collection.GetType(), typeof(IEnumerable<>));
            if (genericEnumerableType != null)
            {
                typeInCollection = genericEnumerableType.GetGenericArguments()[0];
            }
            bool typeInCollectionIsNullableValueType = TypeHelpers.IsNullableValueType(typeInCollection);

            string oldPrefix = viewData.TemplateInfo.HtmlFieldPrefix;

            try
            {
                viewData.TemplateInfo.HtmlFieldPrefix = String.Empty;

                string fieldNameBase = oldPrefix;
                StringBuilder result = new StringBuilder();
                int index = 0;

                foreach (object item in collection)
                {
                    Type itemType = typeInCollection;
                    if (item != null && !typeInCollectionIsNullableValueType)
                    {
                        itemType = item.GetType();
                    }
                    ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => item, itemType);
                    string fieldName = String.Format(CultureInfo.InvariantCulture, "{0}[{1}]", fieldNameBase, index++);
                    string output = templateHelper(html, metadata, fieldName, null /* templateName */, DataBoundControlMode.Edit, null /* additionalViewData */);
                    result.Append(output);
                }

                return result.ToString();
            }
            finally
            {
                viewData.TemplateInfo.HtmlFieldPrefix = oldPrefix;
            }
        }

        internal static string DecimalTemplate(HtmlHelper html)
        {
            if (html.ViewContext.ViewData.TemplateInfo.FormattedModelValue == html.ViewContext.ViewData.ModelMetadata.Model)
            {
                html.ViewContext.ViewData.TemplateInfo.FormattedModelValue = String.Format(CultureInfo.CurrentCulture, "{0:0.00}", html.ViewContext.ViewData.ModelMetadata.Model);
            }

            return StringTemplate(html);
        }

        internal static string HiddenInputTemplate(HtmlHelper html)
        {
            string result;
            ViewDataDictionary viewData = html.ViewContext.ViewData;
            if (viewData.ModelMetadata.HideSurroundingHtml)
            {
                result = String.Empty;
            }
            else
            {
                result = DefaultDisplayTemplates.StringTemplate(html);
            }

            object model = viewData.Model;

            Binary modelAsBinary = model as Binary;
            if (modelAsBinary != null)
            {
                model = Convert.ToBase64String(modelAsBinary.ToArray());
            }
            else
            {
                byte[] modelAsByteArray = model as byte[];
                if (modelAsByteArray != null)
                {
                    model = Convert.ToBase64String(modelAsByteArray);
                }
            }

            object htmlAttributesObject = viewData[HtmlAttributeKey];
            IDictionary<string, object> htmlAttributesDict = htmlAttributesObject as IDictionary<string, object>;

            MvcHtmlString hiddenResult;

            if (htmlAttributesDict != null)
            {
                hiddenResult = html.Hidden(String.Empty, model, htmlAttributesDict);
            }
            else
            {
                hiddenResult = html.Hidden(String.Empty, model, htmlAttributesObject);
            }

            result += hiddenResult.ToHtmlString();

            return result;
        }

        internal static string MultilineTextTemplate(HtmlHelper html)
        {
            return html.TextArea(String.Empty,
                                 html.ViewContext.ViewData.TemplateInfo.FormattedModelValue.ToString(),
                                 0 /* rows */, 0 /* columns */,
                                 CreateHtmlAttributes(html, "text-box multi-line")).ToHtmlString();
        }

        private static IDictionary<string, object> CreateHtmlAttributes(HtmlHelper html, string className, string inputType = null)
        {
            object htmlAttributesObject = html.ViewContext.ViewData[HtmlAttributeKey];
            if (htmlAttributesObject != null)
            {
                return MergeHtmlAttributes(htmlAttributesObject, className, inputType);
            }

            var htmlAttributes = new Dictionary<string, object>()
            {
                { "class", className }
            };
            if (inputType != null)
            {
                htmlAttributes.Add("type", inputType);
            }
            return htmlAttributes;
        }

        private static IDictionary<string, object> MergeHtmlAttributes(object htmlAttributesObject, string className, string inputType)
        {
            IDictionary<string, object> htmlAttributesDict = htmlAttributesObject as IDictionary<string, object>;

            RouteValueDictionary htmlAttributes = (htmlAttributesDict != null) ? new RouteValueDictionary(htmlAttributesDict)
                : HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributesObject);

            string htmlClassName;
            if (htmlAttributes.TryGetValue("class", out htmlClassName))
            {
                htmlClassName += " " + className;
                htmlAttributes["class"] = htmlClassName;
            }
            else
            {
                htmlAttributes.Add("class", className);
            }

            // The input type from the provided htmlAttributes overrides the inputType parameter.
            if (inputType != null && !htmlAttributes.ContainsKey("type"))
            {
                htmlAttributes.Add("type", inputType);
            }

            return htmlAttributes;
        }

        internal static string ObjectTemplate(HtmlHelper html)
        {
            return ObjectTemplate(html, TemplateHelpers.TemplateHelper);
        }

        internal static string ObjectTemplate(HtmlHelper html, TemplateHelpers.TemplateHelperDelegate templateHelper)
        {
            ViewDataDictionary viewData = html.ViewContext.ViewData;
            TemplateInfo templateInfo = viewData.TemplateInfo;
            ModelMetadata modelMetadata = viewData.ModelMetadata;
            StringBuilder builder = new StringBuilder();

            if (templateInfo.TemplateDepth > 1)
            {
                if (modelMetadata.Model == null)
                {
                    return modelMetadata.NullDisplayText;
                }

                // DDB #224751
                string text = modelMetadata.SimpleDisplayText;
                if (modelMetadata.HtmlEncode)
                {
                    text = html.Encode(text);
                }

                return text;
            }

            foreach (ModelMetadata propertyMetadata in modelMetadata.Properties.Where(pm => ShouldShow(pm, templateInfo)))
            {
                if (!propertyMetadata.HideSurroundingHtml)
                {
                    string label = LabelExtensions.LabelHelper(html, propertyMetadata, propertyMetadata.PropertyName).ToHtmlString();
                    if (!String.IsNullOrEmpty(label))
                    {
                        builder.AppendFormat(CultureInfo.InvariantCulture, "<div class=\"editor-label\">{0}</div>\r\n", label);
                    }

                    builder.Append("<div class=\"editor-field\">");
                }

                builder.Append(templateHelper(html, propertyMetadata, propertyMetadata.PropertyName, null /* templateName */, DataBoundControlMode.Edit, null /* additionalViewData */));

                if (!propertyMetadata.HideSurroundingHtml)
                {
                    builder.Append(" ");
                    builder.Append(html.ValidationMessage(propertyMetadata.PropertyName));
                    builder.Append("</div>\r\n");
                }
            }

            return builder.ToString();
        }

        internal static string PasswordTemplate(HtmlHelper html)
        {
            object value = null;
            var usePasswordStrings = WebConfigurationManager.AppSettings.GetValues(UsePasswordValue);
            bool usePasswordValue;
            if (usePasswordStrings != null &&
                usePasswordStrings.Length > 0 &&
                bool.TryParse(usePasswordStrings[0], out usePasswordValue) &&
                usePasswordValue)
            {
                value = html.ViewContext.ViewData.TemplateInfo.FormattedModelValue;
            }

            return html.Password(
                name: String.Empty,
                value: value,
                htmlAttributes: CreateHtmlAttributes(html, "text-box single-line password")).ToHtmlString();
        }

        private static bool ShouldShow(ModelMetadata metadata, TemplateInfo templateInfo)
        {
            return
                metadata.ShowForEdit
                && metadata.ModelType != typeof(EntityState)
                && !metadata.IsComplexType
                && !templateInfo.Visited(metadata);
        }

        internal static string StringTemplate(HtmlHelper html)
        {
            return HtmlInputTemplateHelper(html);
        }

        internal static string PhoneNumberInputTemplate(HtmlHelper html)
        {
            return HtmlInputTemplateHelper(html, inputType: "tel");
        }

        internal static string UrlInputTemplate(HtmlHelper html)
        {
            return HtmlInputTemplateHelper(html, inputType: "url");
        }

        internal static string EmailAddressInputTemplate(HtmlHelper html)
        {
            return HtmlInputTemplateHelper(html, inputType: "email");
        }

        internal static string DateTimeInputTemplate(HtmlHelper html)
        {
            ApplyRfc3339DateFormattingIfNeeded(html, "{0:yyyy-MM-ddTHH:mm:ss.fffK}");
            return HtmlInputTemplateHelper(html, inputType: "datetime");
        }

        internal static string DateTimeLocalInputTemplate(HtmlHelper html)
        {
            ApplyRfc3339DateFormattingIfNeeded(html, "{0:yyyy-MM-ddTHH:mm:ss.fff}");
            return HtmlInputTemplateHelper(html, inputType: "datetime-local");
        }

        internal static string DateInputTemplate(HtmlHelper html)
        {
            ApplyRfc3339DateFormattingIfNeeded(html, "{0:yyyy-MM-dd}");
            return HtmlInputTemplateHelper(html, inputType: "date");
        }

        internal static string TimeInputTemplate(HtmlHelper html)
        {
            ApplyRfc3339DateFormattingIfNeeded(html, "{0:HH:mm:ss.fff}");
            return HtmlInputTemplateHelper(html, inputType: "time");
        }

        internal static string NumberInputTemplate(HtmlHelper html)
        {
            return HtmlInputTemplateHelper(html, inputType: "number");
        }

        internal static string ColorInputTemplate(HtmlHelper html)
        {
            string value = null;
            if (html.ViewContext.ViewData.Model != null)
            {
                if (html.ViewContext.ViewData.Model is Color)
                {
                    Color color = (Color)html.ViewContext.ViewData.Model;
                    value = String.Format(CultureInfo.InvariantCulture, "#{0:X2}{1:X2}{2:X2}", color.R, color.G, color.B);
                }
                else
                {
                    value = html.ViewContext.ViewData.Model.ToString();
                }
            }

            return HtmlInputTemplateHelper(html, "color", value);
        }

        private static void ApplyRfc3339DateFormattingIfNeeded(HtmlHelper html, string format)
        {
            if (html.Html5DateRenderingMode != Html5DateRenderingMode.Rfc3339)
            {
                return;
            }

            ModelMetadata metadata = html.ViewContext.ViewData.ModelMetadata;
            object value = metadata.Model;
            if (html.ViewContext.ViewData.TemplateInfo.FormattedModelValue != value && metadata.HasNonDefaultEditFormat)
            {
                return;
            }

            if (value is DateTime || value is DateTimeOffset)
            {
                html.ViewContext.ViewData.TemplateInfo.FormattedModelValue = String.Format(CultureInfo.InvariantCulture, format, value);
            }
        }

        private static string HtmlInputTemplateHelper(HtmlHelper html, string inputType = null)
        {
            return HtmlInputTemplateHelper(html, inputType, html.ViewContext.ViewData.TemplateInfo.FormattedModelValue);
        }

        private static string HtmlInputTemplateHelper(HtmlHelper html, string inputType, object value)
        {
            return html.TextBox(
                    name: String.Empty,
                    value: value,
                    htmlAttributes: CreateHtmlAttributes(html, className: "text-box single-line", inputType: inputType))
                .ToHtmlString();
        }

        internal static List<SelectListItem> TriStateValues(bool? value)
        {
            return new List<SelectListItem>
            {
                new SelectListItem { Text = MvcResources.Common_TriState_NotSet, Value = String.Empty, Selected = !value.HasValue },
                new SelectListItem { Text = MvcResources.Common_TriState_True, Value = "true", Selected = value.HasValue && value.Value },
                new SelectListItem { Text = MvcResources.Common_TriState_False, Value = "false", Selected = value.HasValue && !value.Value },
            };
        }
    }
}

================================================
FILE: src/System.Web.Mvc/Html/DisplayExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Web.UI.WebControls;

namespace System.Web.Mvc.Html
{
    public static class DisplayExtensions
    {
        public static MvcHtmlString Display(this HtmlHelper html, string expression)
        {
            return TemplateHelpers.Template(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, null /* additionalViewData */);
        }

        public static MvcHtmlString Display(this HtmlHelper html, string expression, object additionalViewData)
        {
            return TemplateHelpers.Template(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, additionalViewData);
        }

        public static MvcHtmlString Display(this HtmlHelper html, string expression, string templateName)
        {
            return TemplateHelpers.Template(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, null /* additionalViewData */);
        }

        public static MvcHtmlString Display(this HtmlHelper html, string expression, string templateName, object additionalViewData)
        {
            return TemplateHelpers.Template(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, additionalViewData);
        }

        public static MvcHtmlString Display(this HtmlHelper html, string expression, string templateName, string htmlFieldName)
        {
            return TemplateHelpers.Template(html, expression, templateName, htmlFieldName, DataBoundControlMode.ReadOnly, null /* additionalViewData */);
        }

        public static MvcHtmlString Display(this HtmlHelper html, string expression, string templateName, string htmlFieldName, object additionalViewData)
        {
            return TemplateHelpers.Template(html, expression, templateName, htmlFieldName, DataBoundControlMode.ReadOnly, additionalViewData);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression)
        {
            return TemplateHelpers.TemplateFor(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, null /* additionalViewData */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, object additionalViewData)
        {
            return TemplateHelpers.TemplateFor(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, additionalViewData);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, null /* additionalViewData */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName, object additionalViewData)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.ReadOnly, additionalViewData);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName, string htmlFieldName)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, htmlFieldName, DataBoundControlMode.ReadOnly, null /* additionalViewData */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName, string htmlFieldName, object additionalViewData)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, htmlFieldName, DataBoundControlMode.ReadOnly, additionalViewData);
        }

        public static MvcHtmlString DisplayForModel(this HtmlHelper html)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, null /* templateName */, DataBoundControlMode.ReadOnly, null /* additionalViewData */));
        }

        public static MvcHtmlString DisplayForModel(this HtmlHelper html, object additionalViewData)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, null /* templateName */, DataBoundControlMode.ReadOnly, additionalViewData));
        }

        public static MvcHtmlString DisplayForModel(this HtmlHelper html, string templateName)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, templateName, DataBoundControlMode.ReadOnly, null /* additionalViewData */));
        }

        public static MvcHtmlString DisplayForModel(this HtmlHelper html, string templateName, object additionalViewData)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, templateName, DataBoundControlMode.ReadOnly, additionalViewData));
        }

        public static MvcHtmlString DisplayForModel(this HtmlHelper html, string templateName, string htmlFieldName)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, htmlFieldName, templateName, DataBoundControlMode.ReadOnly, null /* additionalViewData */));
        }

        public static MvcHtmlString DisplayForModel(this HtmlHelper html, string templateName, string htmlFieldName, object additionalViewData)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, htmlFieldName, templateName, DataBoundControlMode.ReadOnly, additionalViewData));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/DisplayNameExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;

namespace System.Web.Mvc.Html
{
    public static class DisplayNameExtensions
    {
        public static MvcHtmlString DisplayName(this HtmlHelper html, string expression)
        {
            return DisplayNameInternal(html, expression, metadataProvider: null);
        }

        internal static MvcHtmlString DisplayNameInternal(this HtmlHelper html, string expression, ModelMetadataProvider metadataProvider)
        {
            return DisplayNameHelper(ModelMetadata.FromStringExpression(expression, html.ViewData, metadataProvider),
                                     expression);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayNameFor<TModel, TValue>(this HtmlHelper<IEnumerable<TModel>> html, Expression<Func<TModel, TValue>> expression)
        {
            return DisplayNameForInternal(html, expression, metadataProvider: null);
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", Justification = "This is an extension method")]
        internal static MvcHtmlString DisplayNameForInternal<TModel, TValue>(this HtmlHelper<IEnumerable<TModel>> html, Expression<Func<TModel, TValue>> expression, ModelMetadataProvider metadataProvider)
        {
            return DisplayNameHelper(ModelMetadata.FromLambdaExpression(expression, new ViewDataDictionary<TModel>(), metadataProvider),
                                     ExpressionHelper.GetExpressionText(expression));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayNameFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression)
        {
            return DisplayNameForInternal(html, expression, metadataProvider: null);
        }

        internal static MvcHtmlString DisplayNameForInternal<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, ModelMetadataProvider metadataProvider)
        {
            return DisplayNameHelper(ModelMetadata.FromLambdaExpression(expression, html.ViewData, metadataProvider),
                                     ExpressionHelper.GetExpressionText(expression));
        }

        public static MvcHtmlString DisplayNameForModel(this HtmlHelper html)
        {
            return DisplayNameHelper(html.ViewData.ModelMetadata, String.Empty);
        }

        internal static MvcHtmlString DisplayNameHelper(ModelMetadata metadata, string htmlFieldName)
        {
            // We don't call ModelMetadata.GetDisplayName here because we want to fall back to the field name rather than the ModelType.
            // This is similar to how the LabelHelpers get the text of a label.
            string resolvedDisplayName = metadata.DisplayName ?? metadata.PropertyName ?? htmlFieldName.Split('.').Last();

            return new MvcHtmlString(HttpUtility.HtmlEncode(resolvedDisplayName));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/DisplayTextExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

namespace System.Web.Mvc.Html
{
    public static class DisplayTextExtensions
    {
        public static MvcHtmlString DisplayText(this HtmlHelper html, string name)
        {
            return DisplayTextHelper(html, ModelMetadata.FromStringExpression(name, html.ViewContext.ViewData));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DisplayTextFor<TModel, TResult>(this HtmlHelper<TModel> html, Expression<Func<TModel, TResult>> expression)
        {
            return DisplayTextHelper(html, ModelMetadata.FromLambdaExpression(expression, html.ViewData));
        }

        private static MvcHtmlString DisplayTextHelper(HtmlHelper html, ModelMetadata metadata)
        {
            string text = metadata.SimpleDisplayText;
            if (metadata.HtmlEncode)
            {
                text = html.Encode(text);
            }

            return MvcHtmlString.Create(text);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/EditorExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;
using System.Web.UI.WebControls;

namespace System.Web.Mvc.Html
{
    public static class EditorExtensions
    {
        public static MvcHtmlString Editor(this HtmlHelper html, string expression)
        {
            return TemplateHelpers.Template(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.Edit, null /* additionalViewData */);
        }

        public static MvcHtmlString Editor(this HtmlHelper html, string expression, object additionalViewData)
        {
            return TemplateHelpers.Template(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.Edit, additionalViewData);
        }

        public static MvcHtmlString Editor(this HtmlHelper html, string expression, string templateName)
        {
            return TemplateHelpers.Template(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.Edit, null /* additionalViewData */);
        }

        public static MvcHtmlString Editor(this HtmlHelper html, string expression, string templateName, object additionalViewData)
        {
            return TemplateHelpers.Template(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.Edit, additionalViewData);
        }

        public static MvcHtmlString Editor(this HtmlHelper html, string expression, string templateName, string htmlFieldName)
        {
            return TemplateHelpers.Template(html, expression, templateName, htmlFieldName, DataBoundControlMode.Edit, null /* additionalViewData */);
        }

        public static MvcHtmlString Editor(this HtmlHelper html, string expression, string templateName, string htmlFieldName, object additionalViewData)
        {
            return TemplateHelpers.Template(html, expression, templateName, htmlFieldName, DataBoundControlMode.Edit, additionalViewData);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EditorFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression)
        {
            return TemplateHelpers.TemplateFor(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.Edit, null /* additionalViewData */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EditorFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, object additionalViewData)
        {
            return TemplateHelpers.TemplateFor(html, expression, null /* templateName */, null /* htmlFieldName */, DataBoundControlMode.Edit, additionalViewData);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EditorFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.Edit, null /* additionalViewData */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EditorFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName, object additionalViewData)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, null /* htmlFieldName */, DataBoundControlMode.Edit, additionalViewData);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EditorFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName, string htmlFieldName)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, htmlFieldName, DataBoundControlMode.Edit, null /* additionalViewData */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EditorFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string templateName, string htmlFieldName, object additionalViewData)
        {
            return TemplateHelpers.TemplateFor(html, expression, templateName, htmlFieldName, DataBoundControlMode.Edit, additionalViewData);
        }

        public static MvcHtmlString EditorForModel(this HtmlHelper html)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, null /* templateName */, DataBoundControlMode.Edit, null /* additionalViewData */));
        }

        public static MvcHtmlString EditorForModel(this HtmlHelper html, object additionalViewData)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, null /* templateName */, DataBoundControlMode.Edit, additionalViewData));
        }

        public static MvcHtmlString EditorForModel(this HtmlHelper html, string templateName)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, templateName, DataBoundControlMode.Edit, null /* additionalViewData */));
        }

        public static MvcHtmlString EditorForModel(this HtmlHelper html, string templateName, object additionalViewData)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, String.Empty, templateName, DataBoundControlMode.Edit, additionalViewData));
        }

        public static MvcHtmlString EditorForModel(this HtmlHelper html, string templateName, string htmlFieldName)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, htmlFieldName, templateName, DataBoundControlMode.Edit, null /* additionalViewData */));
        }

        public static MvcHtmlString EditorForModel(this HtmlHelper html, string templateName, string htmlFieldName, object additionalViewData)
        {
            return MvcHtmlString.Create(TemplateHelpers.TemplateHelper(html, html.ViewData.ModelMetadata, htmlFieldName, templateName, DataBoundControlMode.Edit, additionalViewData));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/EnumHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.Contracts;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc.Html
{
    public static class EnumHelper
    {
        /// <summary>
        /// Gets a value indicating whether the given <paramref name="type"/> or an expression of this
        /// <see cref="Type"/> is suitable for use in <see cref="GetSelectList(Type)"/> and <see
        /// cref="SelectExtensions.EnumDropDownListFor{TModel,TEnum}(HtmlHelper{TModel}, Expression{Func{TModel, TEnum}})"/>
        /// calls.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> to check.</param>
        /// <returns>
        /// <see langword="true"/> if <see cref="GetSelectList(Type)"/> will not throw when passed given
        /// <see cref="Type"/> and <see
        /// cref="SelectExtensions.EnumDropDownListFor{TModel,TEnum}(HtmlHelper{TModel}, Expression{Func{TModel, TEnum}})"/>
        /// will not throw when passed an expression of this <see cref="Type"/>; <see langword="false"/> otherwise.
        /// </returns>
        /// <remarks>
        /// Currently returns <see langref="true"/> if the <paramref name="type"/> parameter is
        /// non-<see langref="null"/>, is an <see langref="enum"/> type, and does not have a
        /// <see cref="FlagsAttribute"/> attribute.
        /// </remarks>
        public static bool IsValidForEnumHelper(Type type)
        {
            bool isValid = false;
            if (type != null)
            {
                // Type.IsEnum is false for Nullable<T> even if T is an enum.  Check underlying type (if any).
                // Do not support Enum type itself -- IsEnum property is false for that class.
                Type checkedType = Nullable.GetUnderlyingType(type) ?? type;
                if (checkedType.IsEnum)
                {
                    isValid = !HasFlagsInternal(checkedType);
                }
            }

            return isValid;
        }

        /// <summary>
        /// Gets a value indicating whether the given <paramref name="metadata"/> or associated expression is suitable
        /// for use in <see cref="GetSelectList(ModelMetadata)"/> and <see
        /// cref="SelectExtensions.EnumDropDownListFor{TModel,TEnum}(HtmlHelper{TModel}, Expression{Func{TModel, TEnum}})"/>
        /// calls.
        /// </summary>
        /// <param name="metadata">The <see cref="ModelMetadata"/> to check.</param>
        /// <returns>
        /// <see langword="true"/> if <see cref="GetSelectList(ModelMetadata)"/> will return not throw when passed
        /// given <see cref="ModelMetadata"/> and <see
        /// cref="SelectExtensions.EnumDropDownListFor{TModel,TEnum}(HtmlHelper{TModel}, Expression{Func{TModel, TEnum}})"/>
        /// will not throw when passed associated expression; <see langword="false"/> otherwise.
        /// </returns>
        /// <remarks>
        /// Currently returns <see langref="true"/> if the <paramref name="metadata"/> parameter is
        /// non-<see langref="null"/> and <see cref="IsValidForEnumHelper(Type)"/> returns <see langref="true"/> for
        /// <c>metadata.ModelType</c>.
        /// </remarks>
        public static bool IsValidForEnumHelper(ModelMetadata metadata)
        {
            return metadata != null && IsValidForEnumHelper(metadata.ModelType);
        }

        /// <summary>
        /// Gets a list of <see cref="SelectListItem"/> objects corresponding to enum constants defined in the given
        /// <paramref name="type"/>.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> to evaluate.</param>
        /// <returns> An <see cref="IList{SelectListItem}"/> for the given <paramref name="type"/>.</returns>
        /// <remarks>
        /// Throws if <see cref="IsValidForEnumHelper(Type)"/> returns <see langref="false"/> for the given
        /// <paramref name="type"/>.
        /// </remarks>
        public static IList<SelectListItem> GetSelectList(Type type)
        {
            if (type == null)
            {
                throw Error.ArgumentNull("type");
            }

            if (!IsValidForEnumHelper(type))
            {
                throw Error.Argument("type", MvcResources.EnumHelper_InvalidParameterType, type.FullName);
            }

            IList<SelectListItem> selectList = new List<SelectListItem>();

            // According to HTML5: "The first child option element of a select element with a required attribute and
            // without a multiple attribute, and whose size is "1", must have either an empty value attribute, or must
            // have no text content."  SelectExtensions.DropDownList[For]() methods often generate a matching
            // <select/>.  Empty value for Nullable<T>, empty text for round-tripping an unrecognized value, or option
            // label serves in some cases.  But otherwise, ignoring this does not cause problems in either IE or Chrome.
            Type checkedType = Nullable.GetUnderlyingType(type) ?? type;
            if (checkedType != type)
            {
                // Underlying type was non-null so handle Nullable<T>; ensure returned list has a spot for null
                selectList.Add(new SelectListItem { Text = String.Empty, Value = String.Empty, });
            }

            // Populate the list
            const BindingFlags BindingFlags =
                BindingFlags.DeclaredOnly | BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static;
            foreach (FieldInfo field in checkedType.GetFields(BindingFlags))
            {
                // fieldValue will be an numeric type (byte, ...)
                object fieldValue = field.GetRawConstantValue();

                selectList.Add(new SelectListItem { Text = GetDisplayName(field), Value = fieldValue.ToString(), });
            }

            return selectList;
        }

        /// <summary>
        /// Gets a list of <see cref="SelectListItem"/> objects corresponding to enum constants defined in the given
        /// <paramref name="metadata"/>.
        /// </summary>
        /// <param name="metadata">The <see cref="ModelMetadata"/> to evaluate.</param>
        /// <returns> An <see cref="IList{SelectListItem}"/> for the given <paramref name="metadata"/>.</returns>
        /// <remarks>
        /// Throws if <see cref="IsValidForEnumHelper(ModelMetadata)"/> returns <see langref="false"/> for the given
        /// <paramref name="metadata"/>.
        /// </remarks>
        public static IList<SelectListItem> GetSelectList(ModelMetadata metadata)
        {
            if (metadata == null)
            {
                throw Error.ArgumentNull("metadata");
            }

            if (metadata.ModelType == null)
            {
                throw Error.Argument("metadata", MvcResources.EnumHelper_InvalidMetadataParameter);
            }

            if (!IsValidForEnumHelper(metadata))
            {
                throw Error.Argument("metadata", MvcResources.EnumHelper_InvalidParameterType,
                    metadata.ModelType.FullName);
            }

            return GetSelectList(metadata.ModelType);
        }

        /// <summary>
        /// Gets a list of <see cref="SelectListItem"/> objects corresponding to enum constants defined in the given
        /// <paramref name="type"/>.  Also ensures the <paramref name="value"/> will round-trip even if it does not
        /// match a defined constant and sets the <c>Selected</c> property to <see langref="true"/> for one element in
        /// the returned list -- matching the <paramref name="value"/>.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> to evaluate.</param>
        /// <param name="value">Value from <see cref="Type"/> <paramref name="type"/> to select.</param>
        /// <returns>
        /// An <see cref="IList{SelectListItem}"/> for the given <paramref name="type"/>, possibly extended to
        /// include an unrecognized <paramref name="value"/>.
        /// </returns>
        /// <remarks>
        /// Throws if <see cref="IsValidForEnumHelper(Type)"/> returns <see langref="false"/> for the given
        /// <paramref name="type"/> or if a non-null <paramref name="value"/> has a different <see cref="Type"/> than
        /// <paramref name="type"/>.
        /// </remarks>
        public static IList<SelectListItem> GetSelectList(Type type, Enum value)
        {
            IList<SelectListItem> selectList = GetSelectList(type);

            Type valueType = (value == null) ? null : value.GetType();
            if (valueType != null && valueType != type && valueType != Nullable.GetUnderlyingType(type))
            {
                throw Error.Argument("value", MvcResources.EnumHelper_InvalidValueParameter, valueType.FullName,
                    type.FullName);
            }

            if (value == null && selectList.Count != 0 && String.IsNullOrEmpty(selectList[0].Value))
            {
                // Type is Nullable<T>; use existing entry to round trip null value
                selectList[0].Selected = true;
            }
            else
            {
                // If null, use default for this (non-Nullable<T>) enum -- always has 0 integral value
                string valueString = (value == null) ? "0" : value.ToString("d");

                // Select the last matching item, imitating what at least IE and Chrome highlight when multiple
                // elements in a <select/> element have a selected attribute.
                bool foundSelected = false;
                for (int i = selectList.Count - 1; !foundSelected && i >= 0; --i)
                {
                    SelectListItem item = selectList[i];
                    item.Selected = (valueString == item.Value);
                    foundSelected |= item.Selected;
                }

                // Round trip the current value
                if (!foundSelected)
                {
                    if (selectList.Count != 0 && String.IsNullOrEmpty(selectList[0].Value))
                    {
                        // Type is Nullable<T>; use existing entry for round trip
                        selectList[0].Selected = true;
                        selectList[0].Value = valueString;
                    }
                    else
                    {
                        // Add new entry which does not display value to user
                        selectList.Insert(0,
                            new SelectListItem { Selected = true, Text = String.Empty, Value = valueString, });
                    }
                }
            }

            return selectList;
        }

        /// <summary>
        /// Gets a list of <see cref="SelectListItem"/> objects corresponding to enum constants defined in the given
        /// <paramref name="metadata"/>.  Also ensures the <paramref name="value"/> will round-trip even if it does not
        /// match a defined constant and sets the <c>Selected</c> property to <see langref="true"/> for one element in
        /// the returned list -- matching the <paramref name="value"/>.
        /// </summary>
        /// <param name="metadata">The <see cref="ModelMetadata"/> to evaluate.</param>
        /// <param name="value">Value from <see cref="Type"/> of <paramref name="metadata"/> to select.</param>
        /// <returns>
        /// An <see cref="IList{SelectListItem}"/> for the given <paramref name="metadata"/>, possibly extended to
        /// include an unrecognized <paramref name="value"/>.
        /// </returns>
        /// <remarks>
        /// Throws if <see cref="IsValidForEnumHelper(ModelMetadata)"/> returns <see langref="false"/> for the given
        /// <paramref name="metadata"/> or if a non-null <paramref name="value"/> has a different <see cref="Type"/>
        /// than <c>metadata.ModelType</c>.
        /// </remarks>
        public static IList<SelectListItem> GetSelectList(ModelMetadata metadata, Enum value)
        {
            if (metadata == null)
            {
                throw Error.ArgumentNull("metadata");
            }

            if (metadata.ModelType == null)
            {
                throw Error.Argument("metadata", MvcResources.EnumHelper_InvalidMetadataParameter);
            }

            if (!IsValidForEnumHelper(metadata))
            {
                throw Error.Argument("metadata", MvcResources.EnumHelper_InvalidParameterType,
                    metadata.ModelType.FullName);
            }

            return GetSelectList(metadata.ModelType, value);
        }

        internal static bool HasFlags(Type type)
        {
            Contract.Assert(type != null);

            Type checkedType = Nullable.GetUnderlyingType(type) ?? type;
            return HasFlagsInternal(checkedType);
        }

        private static bool HasFlagsInternal(Type type)
        {
            Contract.Assert(type != null);

            FlagsAttribute attribute = type.GetCustomAttribute<FlagsAttribute>(inherit: false);
            return attribute != null;
        }

        // Return non-empty name specified in a [Display] attribute for the given field, if any; field's name otherwise
        private static string GetDisplayName(FieldInfo field)
        {
            DisplayAttribute display = field.GetCustomAttribute<DisplayAttribute>(inherit: false);
            if (display != null)
            {
                string name = display.GetName();
                if (!String.IsNullOrEmpty(name))
                {
                    return name;
                }
            }

            return field.Name;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/FormExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc.Html
{
    public static class FormExtensions
    {
        public static MvcForm BeginForm(this HtmlHelper htmlHelper)
        {
            // generates <form action="{current url}" method="post">...</form>
            string formAction = htmlHelper.ViewContext.HttpContext.Request.RawUrl;
            return FormHelper(htmlHelper, formAction, FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, object routeValues)
        {
            return BeginForm(htmlHelper, null, null, TypeHelper.ObjectToDictionary(routeValues), FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, RouteValueDictionary routeValues)
        {
            return BeginForm(htmlHelper, null, null, routeValues, FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName)
        {
            return BeginForm(htmlHelper, actionName, controllerName, new RouteValueDictionary(), FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, object routeValues)
        {
            return BeginForm(htmlHelper, actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues), FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, RouteValueDictionary routeValues)
        {
            return BeginForm(htmlHelper, actionName, controllerName, routeValues, FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, FormMethod method)
        {
            return BeginForm(htmlHelper, actionName, controllerName, new RouteValueDictionary(), method, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, object routeValues, FormMethod method)
        {
            return BeginForm(htmlHelper, actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues), method, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, RouteValueDictionary routeValues, FormMethod method)
        {
            return BeginForm(htmlHelper, actionName, controllerName, routeValues, method, new RouteValueDictionary());
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, FormMethod method, object htmlAttributes)
        {
            return BeginForm(htmlHelper, actionName, controllerName, new RouteValueDictionary(), method, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, FormMethod method, IDictionary<string, object> htmlAttributes)
        {
            return BeginForm(htmlHelper, actionName, controllerName, new RouteValueDictionary(), method, htmlAttributes);
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, object routeValues, FormMethod method, object htmlAttributes)
        {
            return BeginForm(htmlHelper, actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues), method, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcForm BeginForm(this HtmlHelper htmlHelper, string actionName, string controllerName, RouteValueDictionary routeValues, FormMethod method, IDictionary<string, object> htmlAttributes)
        {
            string formAction = UrlHelper.GenerateUrl(null /* routeName */, actionName, controllerName, routeValues, htmlHelper.RouteCollection, htmlHelper.ViewContext.RequestContext, true /* includeImplicitMvcValues */);
            return FormHelper(htmlHelper, formAction, method, htmlAttributes);
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, object routeValues)
        {
            return BeginRouteForm(htmlHelper, null /* routeName */, TypeHelper.ObjectToDictionary(routeValues), FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, RouteValueDictionary routeValues)
        {
            return BeginRouteForm(htmlHelper, null /* routeName */, routeValues, FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName)
        {
            return BeginRouteForm(htmlHelper, routeName, new RouteValueDictionary(), FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, object routeValues)
        {
            return BeginRouteForm(htmlHelper, routeName, TypeHelper.ObjectToDictionary(routeValues), FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, RouteValueDictionary routeValues)
        {
            return BeginRouteForm(htmlHelper, routeName, routeValues, FormMethod.Post, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, FormMethod method)
        {
            return BeginRouteForm(htmlHelper, routeName, new RouteValueDictionary(), method, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, object routeValues, FormMethod method)
        {
            return BeginRouteForm(htmlHelper, routeName, TypeHelper.ObjectToDictionary(routeValues), method, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, RouteValueDictionary routeValues, FormMethod method)
        {
            return BeginRouteForm(htmlHelper, routeName, routeValues, method, new RouteValueDictionary());
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, FormMethod method, object htmlAttributes)
        {
            return BeginRouteForm(htmlHelper, routeName, new RouteValueDictionary(), method, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, FormMethod method, IDictionary<string, object> htmlAttributes)
        {
            return BeginRouteForm(htmlHelper, routeName, new RouteValueDictionary(), method, htmlAttributes);
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, object routeValues, FormMethod method, object htmlAttributes)
        {
            return BeginRouteForm(htmlHelper, routeName, TypeHelper.ObjectToDictionary(routeValues), method, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcForm BeginRouteForm(this HtmlHelper htmlHelper, string routeName, RouteValueDictionary routeValues, FormMethod method, IDictionary<string, object> htmlAttributes)
        {
            string formAction = UrlHelper.GenerateUrl(routeName, null, null, routeValues, htmlHelper.RouteCollection, htmlHelper.ViewContext.RequestContext, false /* includeImplicitMvcValues */);
            return FormHelper(htmlHelper, formAction, method, htmlAttributes);
        }

        public static void EndForm(this HtmlHelper htmlHelper)
        {
            EndForm(htmlHelper.ViewContext);
        }

        internal static void EndForm(ViewContext viewContext)
        {
            viewContext.Writer.Write("</form>");
            viewContext.OutputClientValidation();
            viewContext.FormContext = null;
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Because disposing the object would write to the response stream, you don't want to prematurely dispose of this object.")]
        private static MvcForm FormHelper(this HtmlHelper htmlHelper, string formAction, FormMethod method, IDictionary<string, object> htmlAttributes)
        {
            TagBuilder tagBuilder = new TagBuilder("form");
            tagBuilder.MergeAttributes(htmlAttributes);
            // action is implicitly generated, so htmlAttributes take precedence.
            tagBuilder.MergeAttribute("action", formAction);
            // method is an explicit parameter, so it takes precedence over the htmlAttributes.
            tagBuilder.MergeAttribute("method", HtmlHelper.GetFormMethodString(method), true);

            bool traditionalJavascriptEnabled = htmlHelper.ViewContext.ClientValidationEnabled
                                                && !htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled;

            if (traditionalJavascriptEnabled)
            {
                // forms must have an ID for client validation
                tagBuilder.GenerateId(htmlHelper.ViewContext.FormIdGenerator());
            }

            htmlHelper.ViewContext.Writer.Write(tagBuilder.ToString(TagRenderMode.StartTag));
            MvcForm theForm = new MvcForm(htmlHelper.ViewContext);

            if (traditionalJavascriptEnabled)
            {
                htmlHelper.ViewContext.FormContext.FormId = tagBuilder.Attributes["id"];
            }

            return theForm;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/InputExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Data.Linq;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq.Expressions;
using System.Text;
using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc.Html
{
    public static class InputExtensions
    {
        // CheckBox

        public static MvcHtmlString CheckBox(this HtmlHelper htmlHelper, string name)
        {
            return CheckBox(htmlHelper, name, htmlAttributes: (object)null);
        }

        public static MvcHtmlString CheckBox(this HtmlHelper htmlHelper, string name, bool isChecked)
        {
            return CheckBox(htmlHelper, name, isChecked, htmlAttributes: (object)null);
        }

        public static MvcHtmlString CheckBox(this HtmlHelper htmlHelper, string name, bool isChecked, object htmlAttributes)
        {
            return CheckBox(htmlHelper, name, isChecked, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString CheckBox(this HtmlHelper htmlHelper, string name, object htmlAttributes)
        {
            return CheckBox(htmlHelper, name, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString CheckBox(this HtmlHelper htmlHelper, string name, IDictionary<string, object> htmlAttributes)
        {
            return CheckBoxHelper(htmlHelper, metadata: null, name: name, isChecked: null, htmlAttributes: htmlAttributes);
        }

        public static MvcHtmlString CheckBox(this HtmlHelper htmlHelper, string name, bool isChecked, IDictionary<string, object> htmlAttributes)
        {
            return CheckBoxHelper(htmlHelper, metadata: null, name: name, isChecked: isChecked, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString CheckBoxFor<TModel>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, bool>> expression)
        {
            return CheckBoxFor(htmlHelper, expression, htmlAttributes: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString CheckBoxFor<TModel>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, bool>> expression, object htmlAttributes)
        {
            return CheckBoxFor(htmlHelper, expression, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString CheckBoxFor<TModel>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, bool>> expression, IDictionary<string, object> htmlAttributes)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            bool? isChecked = null;
            if (metadata.Model != null)
            {
                bool modelChecked;
                if (Boolean.TryParse(metadata.Model.ToString(), out modelChecked))
                {
                    isChecked = modelChecked;
                }
            }

            return CheckBoxHelper(htmlHelper, metadata, ExpressionHelper.GetExpressionText(expression), isChecked, htmlAttributes);
        }

        private static MvcHtmlString CheckBoxHelper(HtmlHelper htmlHelper, ModelMetadata metadata, string name, bool? isChecked, IDictionary<string, object> htmlAttributes)
        {
            RouteValueDictionary attributes = ToRouteValueDictionary(htmlAttributes);

            bool explicitValue = isChecked.HasValue;
            if (explicitValue)
            {
                attributes.Remove("checked"); // Explicit value must override dictionary
            }

            return InputHelper(htmlHelper,
                               InputType.CheckBox,
                               metadata,
                               name,
                               value: "true",
                               useViewData: !explicitValue,
                               isChecked: isChecked ?? false,
                               setId: true,
                               isExplicitValue: false,
                               format: null,
                               htmlAttributes: attributes);
        }

        // Hidden

        public static MvcHtmlString Hidden(this HtmlHelper htmlHelper, string name)
        {
            return Hidden(htmlHelper, name, value: null, htmlAttributes: null);
        }

        public static MvcHtmlString Hidden(this HtmlHelper htmlHelper, string name, object value)
        {
            return Hidden(htmlHelper, name, value, htmlAttributes: null);
        }

        public static MvcHtmlString Hidden(this HtmlHelper htmlHelper, string name, object value, object htmlAttributes)
        {
            return Hidden(htmlHelper, name, value, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString Hidden(this HtmlHelper htmlHelper, string name, object value, IDictionary<string, object> htmlAttributes)
        {
            return HiddenHelper(htmlHelper,
                                metadata: null,
                                value: value,
                                useViewData: value == null,
                                expression: name,
                                htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString HiddenFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            return HiddenFor(htmlHelper, expression, (IDictionary<string, object>)null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString HiddenFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object htmlAttributes)
        {
            return HiddenFor(htmlHelper, expression, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString HiddenFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IDictionary<string, object> htmlAttributes)
        {
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            return HiddenHelper(htmlHelper,
                                metadata,
                                metadata.Model,
                                false,
                                ExpressionHelper.GetExpressionText(expression),
                                htmlAttributes);
        }

        private static MvcHtmlString HiddenHelper(HtmlHelper htmlHelper, ModelMetadata metadata, object value, bool useViewData, string expression, IDictionary<string, object> htmlAttributes)
        {
            Binary binaryValue = value as Binary;
            if (binaryValue != null)
            {
                value = binaryValue.ToArray();
            }

            byte[] byteArrayValue = value as byte[];
            if (byteArrayValue != null)
            {
                value = Convert.ToBase64String(byteArrayValue);
            }

            return InputHelper(htmlHelper,
                               InputType.Hidden,
                               metadata,
                               expression,
                               value,
                               useViewData,
                               isChecked: false,
                               setId: true,
                               isExplicitValue: true,
                               format: null,
                               htmlAttributes: htmlAttributes);
        }

        // Password

        public static MvcHtmlString Password(this HtmlHelper htmlHelper, string name)
        {
            return Password(htmlHelper, name, value: null);
        }

        public static MvcHtmlString Password(this HtmlHelper htmlHelper, string name, object value)
        {
            return Password(htmlHelper, name, value, htmlAttributes: null);
        }

        public static MvcHtmlString Password(this HtmlHelper htmlHelper, string name, object value, object htmlAttributes)
        {
            return Password(htmlHelper, name, value, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString Password(this HtmlHelper htmlHelper, string name, object value, IDictionary<string, object> htmlAttributes)
        {
            return PasswordHelper(htmlHelper, metadata: null, name: name, value: value, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString PasswordFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            return PasswordFor(htmlHelper, expression, htmlAttributes: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString PasswordFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object htmlAttributes)
        {
            return PasswordFor(htmlHelper, expression, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString PasswordFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IDictionary<string, object> htmlAttributes)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            return PasswordHelper(htmlHelper,
                                  ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData),
                                  ExpressionHelper.GetExpressionText(expression),
                                  value: null,
                                  htmlAttributes: htmlAttributes);
        }

        private static MvcHtmlString PasswordHelper(HtmlHelper htmlHelper, ModelMetadata metadata, string name, object value, IDictionary<string, object> htmlAttributes)
        {
            return InputHelper(htmlHelper,
                               InputType.Password,
                               metadata,
                               name,
                               value,
                               useViewData: false,
                               isChecked: false,
                               setId: true,
                               isExplicitValue: true,
                               format: null,
                               htmlAttributes: htmlAttributes);
        }

        // RadioButton

        public static MvcHtmlString RadioButton(this HtmlHelper htmlHelper, string name, object value)
        {
            return RadioButton(htmlHelper, name, value, htmlAttributes: (object)null);
        }

        public static MvcHtmlString RadioButton(this HtmlHelper htmlHelper, string name, object value, object htmlAttributes)
        {
            return RadioButton(htmlHelper, name, value, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RadioButton(this HtmlHelper htmlHelper, string name, object value, IDictionary<string, object> htmlAttributes)
        {
            // Determine whether or not to render the checked attribute based on the contents of ViewData.
            string valueString = Convert.ToString(value, CultureInfo.CurrentCulture);
            bool isChecked = (!String.IsNullOrEmpty(name)) && (String.Equals(htmlHelper.EvalString(name), valueString, StringComparison.OrdinalIgnoreCase));
            // checked attributes is implicit, so we need to ensure that the dictionary takes precedence.
            RouteValueDictionary attributes = ToRouteValueDictionary(htmlAttributes);
            if (attributes.ContainsKey("checked"))
            {
                return InputHelper(htmlHelper,
                                   InputType.Radio,
                                   metadata: null,
                                   name: name,
                                   value: value,
                                   useViewData: false,
                                   isChecked: false,
                                   setId: true,
                                   isExplicitValue: true,
                                   format: null,
                                   htmlAttributes: attributes);
            }

            return RadioButton(htmlHelper, name, value, isChecked, htmlAttributes);
        }

        public static MvcHtmlString RadioButton(this HtmlHelper htmlHelper, string name, object value, bool isChecked)
        {
            return RadioButton(htmlHelper, name, value, isChecked, htmlAttributes: (object)null);
        }

        public static MvcHtmlString RadioButton(this HtmlHelper htmlHelper, string name, object value, bool isChecked, object htmlAttributes)
        {
            return RadioButton(htmlHelper, name, value, isChecked, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RadioButton(this HtmlHelper htmlHelper, string name, object value, bool isChecked, IDictionary<string, object> htmlAttributes)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }
            // checked attribute is an explicit parameter so it takes precedence.
            RouteValueDictionary attributes = ToRouteValueDictionary(htmlAttributes);
            attributes.Remove("checked");
            return InputHelper(htmlHelper,
                               InputType.Radio,
                               metadata: null,
                               name: name,
                               value: value,
                               useViewData: false,
                               isChecked: isChecked,
                               setId: true,
                               isExplicitValue: true,
                               format: null,
                               htmlAttributes: attributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString RadioButtonFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object value)
        {
            return RadioButtonFor(htmlHelper, expression, value, htmlAttributes: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString RadioButtonFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object value, object htmlAttributes)
        {
            return RadioButtonFor(htmlHelper, expression, value, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString RadioButtonFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object value, IDictionary<string, object> htmlAttributes)
        {
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            return RadioButtonHelper(htmlHelper,
                                     metadata,
                                     metadata.Model,
                                     ExpressionHelper.GetExpressionText(expression),
                                     value,
                                     null /* isChecked */,
                                     htmlAttributes);
        }

        private static MvcHtmlString RadioButtonHelper(HtmlHelper htmlHelper, ModelMetadata metadata, object model, string name, object value, bool? isChecked, IDictionary<string, object> htmlAttributes)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            RouteValueDictionary attributes = ToRouteValueDictionary(htmlAttributes);

            bool explicitValue = isChecked.HasValue;
            if (explicitValue)
            {
                attributes.Remove("checked"); // Explicit value must override dictionary
            }
            else
            {
                string valueString = Convert.ToString(value, CultureInfo.CurrentCulture);
                isChecked = model != null &&
                            !String.IsNullOrEmpty(htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name)) &&
                            String.Equals(model.ToString(), valueString, StringComparison.OrdinalIgnoreCase);
            }

            return InputHelper(htmlHelper,
                               InputType.Radio,
                               metadata,
                               name,
                               value,
                               useViewData: false,
                               isChecked: isChecked ?? false,
                               setId: true,
                               isExplicitValue: true,
                               format: null,
                               htmlAttributes: attributes);
        }

        // TextBox

        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name)
        {
            return TextBox(htmlHelper, name, value: null);
        }

        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name, object value)
        {
            return TextBox(htmlHelper, name, value, format: null);
        }

        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name, object value, string format)
        {
            return TextBox(htmlHelper, name, value, format, htmlAttributes: (object)null);
        }

        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name, object value, object htmlAttributes)
        {
            return TextBox(htmlHelper, name, value, format: null, htmlAttributes: htmlAttributes);
        }

        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name, object value, string format, object htmlAttributes)
        {
            return TextBox(htmlHelper, name, value, format, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name, object value, IDictionary<string, object> htmlAttributes)
        {
            return TextBox(htmlHelper, name, value, format: null, htmlAttributes: htmlAttributes);
        }

        public static MvcHtmlString TextBox(this HtmlHelper htmlHelper, string name, object value, string format, IDictionary<string, object> htmlAttributes)
        {
            return InputHelper(htmlHelper,
                               InputType.Text,
                               metadata: null,
                               name: name,
                               value: value,
                               useViewData: (value == null),
                               isChecked: false,
                               setId: true,
                               isExplicitValue: true,
                               format: format,
                               htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            return htmlHelper.TextBoxFor(expression, format: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string format)
        {
            return htmlHelper.TextBoxFor(expression, format, (IDictionary<string, object>)null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object htmlAttributes)
        {
            return htmlHelper.TextBoxFor(expression, format: null, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string format, object htmlAttributes)
        {
            return htmlHelper.TextBoxFor(expression, format: format, htmlAttributes: HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IDictionary<string, object> htmlAttributes)
        {
            return htmlHelper.TextBoxFor(expression, format: null, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string format, IDictionary<string, object> htmlAttributes)
        {
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            return TextBoxHelper(htmlHelper,
                                 metadata,
                                 metadata.Model,
                                 ExpressionHelper.GetExpressionText(expression),
                                 format,
                                 htmlAttributes);
        }

        private static MvcHtmlString TextBoxHelper(this HtmlHelper htmlHelper, ModelMetadata metadata, object model, string expression, string format, IDictionary<string, object> htmlAttributes)
        {
            return InputHelper(htmlHelper,
                               InputType.Text,
                               metadata,
                               expression,
                               model,
                               useViewData: false,
                               isChecked: false,
                               setId: true,
                               isExplicitValue: true,
                               format: format,
                               htmlAttributes: htmlAttributes);
        }

        // Helper methods

        private static MvcHtmlString InputHelper(HtmlHelper htmlHelper, InputType inputType, ModelMetadata metadata, string name, object value, bool useViewData, bool isChecked, bool setId, bool isExplicitValue, string format, IDictionary<string, object> htmlAttributes)
        {
            string fullName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            if (String.IsNullOrEmpty(fullName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
            }

            TagBuilder tagBuilder = new TagBuilder("input");
            tagBuilder.MergeAttributes(htmlAttributes);
            tagBuilder.MergeAttribute("type", HtmlHelper.GetInputTypeString(inputType));
            tagBuilder.MergeAttribute("name", fullName, true);

            string valueParameter = htmlHelper.FormatValue(value, format);
            bool usedModelState = false;

            switch (inputType)
            {
                case InputType.CheckBox:
                    bool? modelStateWasChecked = htmlHelper.GetModelStateValue(fullName, typeof(bool)) as bool?;
                    if (modelStateWasChecked.HasValue)
                    {
                        isChecked = modelStateWasChecked.Value;
                        usedModelState = true;
                    }
                    goto case InputType.Radio;
                case InputType.Radio:
                    if (!usedModelState)
                    {
                        string modelStateValue = htmlHelper.GetModelStateValue(fullName, typeof(string)) as string;
                        if (modelStateValue != null)
                        {
                            isChecked = String.Equals(modelStateValue, valueParameter, StringComparison.Ordinal);
                            usedModelState = true;
                        }
                    }
                    if (!usedModelState && useViewData)
                    {
                        isChecked = htmlHelper.EvalBoolean(fullName);
                    }
                    if (isChecked)
                    {
                        tagBuilder.MergeAttribute("checked", "checked");
                    }
                    tagBuilder.MergeAttribute("value", valueParameter, isExplicitValue);
                    break;
                case InputType.Password:
                    if (value != null)
                    {
                        tagBuilder.MergeAttribute("value", valueParameter, isExplicitValue);
                    }
                    break;
                default:
                    string attemptedValue = (string)htmlHelper.GetModelStateValue(fullName, typeof(string));
                    tagBuilder.MergeAttribute("value", attemptedValue ?? ((useViewData) ? htmlHelper.EvalString(fullName, format) : valueParameter), isExplicitValue);
                    break;
            }

            if (setId)
            {
                tagBuilder.GenerateId(fullName);
            }

            // If there are any errors for a named field, we add the css attribute.
            ModelState modelState;
            if (htmlHelper.ViewData.ModelState.TryGetValue(fullName, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }

            tagBuilder.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata));

            if (inputType == InputType.CheckBox)
            {
                // Render an additional <input type="hidden".../> for checkboxes. This
                // addresses scenarios where unchecked checkboxes are not sent in the request.
                // Sending a hidden input makes it possible to know that the checkbox was present
                // on the page when the request was submitted.
                StringBuilder inputItemBuilder = new StringBuilder();
                inputItemBuilder.Append(tagBuilder.ToString(TagRenderMode.SelfClosing));

                TagBuilder hiddenInput = new TagBuilder("input");
                hiddenInput.MergeAttribute("type", HtmlHelper.GetInputTypeString(InputType.Hidden));
                hiddenInput.MergeAttribute("name", fullName);
                hiddenInput.MergeAttribute("value", "false");
                inputItemBuilder.Append(hiddenInput.ToString(TagRenderMode.SelfClosing));
                return MvcHtmlString.Create(inputItemBuilder.ToString());
            }

            return tagBuilder.ToMvcHtmlString(TagRenderMode.SelfClosing);
        }

        private static RouteValueDictionary ToRouteValueDictionary(IDictionary<string, object> dictionary)
        {
            return dictionary == null ? new RouteValueDictionary() : new RouteValueDictionary(dictionary);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/LabelExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;

namespace System.Web.Mvc.Html
{
    public static class LabelExtensions
    {
        public static MvcHtmlString Label(this HtmlHelper html, string expression)
        {
            return Label(html,
                         expression,
                         labelText: null);
        }

        public static MvcHtmlString Label(this HtmlHelper html, string expression, string labelText)
        {
            return Label(html, expression, labelText, htmlAttributes: null, metadataProvider: null);
        }

        public static MvcHtmlString Label(this HtmlHelper html, string expression, object htmlAttributes)
        {
            return Label(html, expression, labelText: null, htmlAttributes: htmlAttributes, metadataProvider: null);
        }

        public static MvcHtmlString Label(this HtmlHelper html, string expression, IDictionary<string, object> htmlAttributes)
        {
            return Label(html, expression, labelText: null, htmlAttributes: htmlAttributes, metadataProvider: null);
        }

        public static MvcHtmlString Label(this HtmlHelper html, string expression, string labelText, object htmlAttributes)
        {
            return Label(html, expression, labelText, htmlAttributes, metadataProvider: null);
        }

        public static MvcHtmlString Label(this HtmlHelper html, string expression, string labelText, IDictionary<string, object> htmlAttributes)
        {
            return Label(html, expression, labelText, htmlAttributes, metadataProvider: null);
        }

        internal static MvcHtmlString Label(this HtmlHelper html, string expression, string labelText, object htmlAttributes, ModelMetadataProvider metadataProvider)
        {
            return Label(html,
                         expression,
                         labelText,
                         HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes),
                         metadataProvider);
        }

        internal static MvcHtmlString Label(this HtmlHelper html, string expression, string labelText, IDictionary<string, object> htmlAttributes, ModelMetadataProvider metadataProvider)
        {
            return LabelHelper(html,
                               ModelMetadata.FromStringExpression(expression, html.ViewData, metadataProvider),
                               expression,
                               labelText,
                               htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression)
        {
            return LabelFor<TModel, TValue>(html, expression, labelText: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string labelText)
        {
            return LabelFor(html, expression, labelText, htmlAttributes: null, metadataProvider: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, object htmlAttributes)
        {
            return LabelFor(html, expression, labelText: null, htmlAttributes: htmlAttributes, metadataProvider: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, IDictionary<string, object> htmlAttributes)
        {
            return LabelFor(html, expression, labelText: null, htmlAttributes: htmlAttributes, metadataProvider: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string labelText, object htmlAttributes)
        {
            return LabelFor(html, expression, labelText, htmlAttributes, metadataProvider: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string labelText, IDictionary<string, object> htmlAttributes)
        {
            return LabelFor(html, expression, labelText, htmlAttributes, metadataProvider: null);
        }

        internal static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string labelText, object htmlAttributes, ModelMetadataProvider metadataProvider)
        {
            return LabelFor(html,
                            expression,
                            labelText,
                            HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes),
                            metadataProvider);
        }

        internal static MvcHtmlString LabelFor<TModel, TValue>(this HtmlHelper<TModel> html, Expression<Func<TModel, TValue>> expression, string labelText, IDictionary<string, object> htmlAttributes, ModelMetadataProvider metadataProvider)
        {
            return LabelHelper(html,
                               ModelMetadata.FromLambdaExpression(expression, html.ViewData, metadataProvider),
                               ExpressionHelper.GetExpressionText(expression),
                               labelText,
                               htmlAttributes);
        }

        public static MvcHtmlString LabelForModel(this HtmlHelper html)
        {
            return LabelForModel(html, labelText: null);
        }

        public static MvcHtmlString LabelForModel(this HtmlHelper html, string labelText)
        {
            return LabelHelper(html, html.ViewData.ModelMetadata, String.Empty, labelText);
        }

        public static MvcHtmlString LabelForModel(this HtmlHelper html, object htmlAttributes)
        {
            return LabelHelper(html, html.ViewData.ModelMetadata, String.Empty, labelText: null, htmlAttributes: HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString LabelForModel(this HtmlHelper html, IDictionary<string, object> htmlAttributes)
        {
            return LabelHelper(html, html.ViewData.ModelMetadata, String.Empty, labelText: null, htmlAttributes: htmlAttributes);
        }

        public static MvcHtmlString LabelForModel(this HtmlHelper html, string labelText, object htmlAttributes)
        {
            return LabelHelper(html, html.ViewData.ModelMetadata, String.Empty, labelText, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString LabelForModel(this HtmlHelper html, string labelText, IDictionary<string, object> htmlAttributes)
        {
            return LabelHelper(html, html.ViewData.ModelMetadata, String.Empty, labelText, htmlAttributes);
        }

        internal static MvcHtmlString LabelHelper(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string labelText = null, IDictionary<string, object> htmlAttributes = null)
        {
            string resolvedLabelText = labelText ?? metadata.DisplayName ?? metadata.PropertyName ?? htmlFieldName.Split('.').Last();
            if (String.IsNullOrEmpty(resolvedLabelText))
            {
                return MvcHtmlString.Empty;
            }

            TagBuilder tag = new TagBuilder("label");
            tag.Attributes.Add("for", TagBuilder.CreateSanitizedId(html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(htmlFieldName)));
            tag.SetInnerText(resolvedLabelText);
            tag.MergeAttributes(htmlAttributes, replaceExisting: true);
            return tag.ToMvcHtmlString(TagRenderMode.Normal);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/LinkExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc.Html
{
    public static class LinkExtensions
    {
        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName)
        {
            return ActionLink(htmlHelper, linkText, actionName, null /* controllerName */, new RouteValueDictionary(), new RouteValueDictionary());
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, object routeValues)
        {
            return ActionLink(htmlHelper, linkText, actionName, null /* controllerName */, TypeHelper.ObjectToDictionary(routeValues), new RouteValueDictionary());
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, object routeValues, object htmlAttributes)
        {
            return ActionLink(htmlHelper, linkText, actionName, null /* controllerName */, TypeHelper.ObjectToDictionary(routeValues), HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, RouteValueDictionary routeValues)
        {
            return ActionLink(htmlHelper, linkText, actionName, null /* controllerName */, routeValues, new RouteValueDictionary());
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            return ActionLink(htmlHelper, linkText, actionName, null /* controllerName */, routeValues, htmlAttributes);
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName)
        {
            return ActionLink(htmlHelper, linkText, actionName, controllerName, new RouteValueDictionary(), new RouteValueDictionary());
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName, object routeValues, object htmlAttributes)
        {
            return ActionLink(htmlHelper, linkText, actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues), HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }
            return MvcHtmlString.Create(HtmlHelper.GenerateLink(htmlHelper.ViewContext.RequestContext, htmlHelper.RouteCollection, linkText, null /* routeName */, actionName, controllerName, routeValues, htmlAttributes));
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName, string protocol, string hostName, string fragment, object routeValues, object htmlAttributes)
        {
            return ActionLink(htmlHelper, linkText, actionName, controllerName, protocol, hostName, fragment, TypeHelper.ObjectToDictionary(routeValues), HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString ActionLink(this HtmlHelper htmlHelper, string linkText, string actionName, string controllerName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }
            return MvcHtmlString.Create(HtmlHelper.GenerateLink(htmlHelper.ViewContext.RequestContext, htmlHelper.RouteCollection, linkText, null /* routeName */, actionName, controllerName, protocol, hostName, fragment, routeValues, htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, object routeValues)
        {
            return RouteLink(htmlHelper, linkText, TypeHelper.ObjectToDictionary(routeValues));
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, RouteValueDictionary routeValues)
        {
            return RouteLink(htmlHelper, linkText, routeValues, new RouteValueDictionary());
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName)
        {
            return RouteLink(htmlHelper, linkText, routeName, (object)null /* routeValues */);
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName, object routeValues)
        {
            return RouteLink(htmlHelper, linkText, routeName, TypeHelper.ObjectToDictionary(routeValues));
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName, RouteValueDictionary routeValues)
        {
            return RouteLink(htmlHelper, linkText, routeName, routeValues, new RouteValueDictionary());
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, object routeValues, object htmlAttributes)
        {
            return RouteLink(htmlHelper, linkText, TypeHelper.ObjectToDictionary(routeValues), HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            return RouteLink(htmlHelper, linkText, null /* routeName */, routeValues, htmlAttributes);
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName, object routeValues, object htmlAttributes)
        {
            return RouteLink(htmlHelper, linkText, routeName, TypeHelper.ObjectToDictionary(routeValues), HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }
            return MvcHtmlString.Create(HtmlHelper.GenerateRouteLink(htmlHelper.ViewContext.RequestContext, htmlHelper.RouteCollection, linkText, routeName, routeValues, htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName, string protocol, string hostName, string fragment, object routeValues, object htmlAttributes)
        {
            return RouteLink(htmlHelper, linkText, routeName, protocol, hostName, fragment, TypeHelper.ObjectToDictionary(routeValues), HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString RouteLink(this HtmlHelper htmlHelper, string linkText, string routeName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(linkText))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "linkText");
            }
            return MvcHtmlString.Create(HtmlHelper.GenerateRouteLink(htmlHelper.ViewContext.RequestContext, htmlHelper.RouteCollection, linkText, routeName, protocol, hostName, fragment, routeValues, htmlAttributes));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/MvcForm.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc.Html
{
    public class MvcForm : IDisposable
    {
        private readonly ViewContext _viewContext;
        private bool _disposed;

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "httpResponse", Justification = "This method existed in MVC 1.0 and has been deprecated.")]
        [Obsolete("This constructor is obsolete, because its functionality has been moved to MvcForm(ViewContext) now.", true /* error */)]
        public MvcForm(HttpResponseBase httpResponse)
        {
            throw new InvalidOperationException(MvcResources.MvcForm_ConstructorObsolete);
        }

        public MvcForm(ViewContext viewContext)
        {
            if (viewContext == null)
            {
                throw new ArgumentNullException("viewContext");
            }

            _viewContext = viewContext;

            // push the new FormContext
            _viewContext.FormContext = new FormContext();
        }

        public void Dispose()
        {
            Dispose(true /* disposing */);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_disposed)
            {
                _disposed = true;
                FormExtensions.EndForm(_viewContext);
            }
        }

        public void EndForm()
        {
            Dispose(true);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/NameExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

namespace System.Web.Mvc.Html
{
    public static class NameExtensions
    {
        public static MvcHtmlString Id(this HtmlHelper html, string name)
        {
            return MvcHtmlString.Create(html.AttributeEncode(html.ViewData.TemplateInfo.GetFullHtmlFieldId(name)));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]
        public static MvcHtmlString IdFor<TModel, TProperty>(this HtmlHelper<TModel> html, Expression<Func<TModel, TProperty>> expression)
        {
            return Id(html, ExpressionHelper.GetExpressionText(expression));
        }

        public static MvcHtmlString IdForModel(this HtmlHelper html)
        {
            return Id(html, String.Empty);
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", MessageId = "1#", Justification = "This is a shipped API.")]
        public static MvcHtmlString Name(this HtmlHelper html, string name)
        {
            return MvcHtmlString.Create(html.AttributeEncode(html.ViewData.TemplateInfo.GetFullHtmlFieldName(name)));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]
        public static MvcHtmlString NameFor<TModel, TProperty>(this HtmlHelper<TModel> html, Expression<Func<TModel, TProperty>> expression)
        {
            return Name(html, ExpressionHelper.GetExpressionText(expression));
        }

        public static MvcHtmlString NameForModel(this HtmlHelper html)
        {
            return Name(html, String.Empty);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/PartialExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;

namespace System.Web.Mvc.Html
{
    public static class PartialExtensions
    {
        public static MvcHtmlString Partial(this HtmlHelper htmlHelper, string partialViewName)
        {
            return Partial(htmlHelper, partialViewName, null /* model */, htmlHelper.ViewData);
        }

        public static MvcHtmlString Partial(this HtmlHelper htmlHelper, string partialViewName, ViewDataDictionary viewData)
        {
            return Partial(htmlHelper, partialViewName, null /* model */, viewData);
        }

        public static MvcHtmlString Partial(this HtmlHelper htmlHelper, string partialViewName, object model)
        {
            return Partial(htmlHelper, partialViewName, model, htmlHelper.ViewData);
        }

        public static MvcHtmlString Partial(this HtmlHelper htmlHelper, string partialViewName, object model, ViewDataDictionary viewData)
        {
            using (StringWriter writer = new StringWriter(CultureInfo.CurrentCulture))
            {
                htmlHelper.RenderPartialInternal(partialViewName, viewData, model, writer, ViewEngines.Engines);
                return MvcHtmlString.Create(writer.ToString());
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/RenderPartialExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Html
{
    public static class RenderPartialExtensions
    {
        // Renders the partial view with the parent's view data and model
        public static void RenderPartial(this HtmlHelper htmlHelper, string partialViewName)
        {
            htmlHelper.RenderPartialInternal(partialViewName, htmlHelper.ViewData, null /* model */, htmlHelper.ViewContext.Writer, ViewEngines.Engines);
        }

        // Renders the partial view with the given view data and, implicitly, the given view data's model
        public static void RenderPartial(this HtmlHelper htmlHelper, string partialViewName, ViewDataDictionary viewData)
        {
            htmlHelper.RenderPartialInternal(partialViewName, viewData, null /* model */, htmlHelper.ViewContext.Writer, ViewEngines.Engines);
        }

        // Renders the partial view with an empty view data and the given model
        public static void RenderPartial(this HtmlHelper htmlHelper, string partialViewName, object model)
        {
            htmlHelper.RenderPartialInternal(partialViewName, htmlHelper.ViewData, model, htmlHelper.ViewContext.Writer, ViewEngines.Engines);
        }

        // Renders the partial view with a copy of the given view data plus the given model
        public static void RenderPartial(this HtmlHelper htmlHelper, string partialViewName, object model, ViewDataDictionary viewData)
        {
            htmlHelper.RenderPartialInternal(partialViewName, viewData, model, htmlHelper.ViewContext.Writer, ViewEngines.Engines);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/SelectExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc.Html
{
    public static class SelectExtensions
    {
        // DropDownList

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name)
        {
            return DropDownList(htmlHelper, name, null /* selectList */, null /* optionLabel */, null /* htmlAttributes */);
        }

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, string optionLabel)
        {
            return DropDownList(htmlHelper, name, null /* selectList */, optionLabel, null /* htmlAttributes */);
        }

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList)
        {
            return DropDownList(htmlHelper, name, selectList, null /* optionLabel */, null /* htmlAttributes */);
        }

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return DropDownList(htmlHelper, name, selectList, null /* optionLabel */, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            return DropDownList(htmlHelper, name, selectList, null /* optionLabel */, htmlAttributes);
        }

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, string optionLabel)
        {
            return DropDownList(htmlHelper, name, selectList, optionLabel, null /* htmlAttributes */);
        }

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, string optionLabel, object htmlAttributes)
        {
            return DropDownList(htmlHelper, name, selectList, optionLabel, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString DropDownList(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, string optionLabel, IDictionary<string, object> htmlAttributes)
        {
            return DropDownListHelper(htmlHelper, metadata: null, expression: name, selectList: selectList, optionLabel: optionLabel, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList)
        {
            return DropDownListFor(htmlHelper, expression, selectList, null /* optionLabel */, null /* htmlAttributes */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return DropDownListFor(htmlHelper, expression, selectList, null /* optionLabel */, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            return DropDownListFor(htmlHelper, expression, selectList, null /* optionLabel */, htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, string optionLabel)
        {
            return DropDownListFor(htmlHelper, expression, selectList, optionLabel, null /* htmlAttributes */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, string optionLabel, object htmlAttributes)
        {
            return DropDownListFor(htmlHelper, expression, selectList, optionLabel, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString DropDownListFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, string optionLabel, IDictionary<string, object> htmlAttributes)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

            return DropDownListHelper(htmlHelper, metadata, ExpressionHelper.GetExpressionText(expression), selectList, optionLabel, htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper,
            Expression<Func<TModel, TEnum>> expression)
        {
            return EnumDropDownListFor(htmlHelper, expression, optionLabel: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper,
            Expression<Func<TModel, TEnum>> expression, object htmlAttributes)
        {
            return EnumDropDownListFor(htmlHelper, expression, optionLabel: null, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper,
            Expression<Func<TModel, TEnum>> expression, IDictionary<string, object> htmlAttributes)
        {
            return EnumDropDownListFor(htmlHelper, expression, optionLabel: null, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper,
            Expression<Func<TModel, TEnum>> expression, string optionLabel)
        {
            return EnumDropDownListFor(htmlHelper, expression, optionLabel, (IDictionary<string, object>)null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper,
            Expression<Func<TModel, TEnum>> expression, string optionLabel, object htmlAttributes)
        {
            return EnumDropDownListFor(htmlHelper, expression, optionLabel,
                HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        // Unable to constrain TEnum.  Cannot include IComparable, IConvertible, IFormattable because Nullable<T> does
        // not implement those interfaces (and Int32 does).  Enum alone is not compatible with expression restrictions
        // because that requires a cast from all enum types.  And the struct generic constraint disallows passing a
        // Nullable<T> expression.
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString EnumDropDownListFor<TModel, TEnum>(this HtmlHelper<TModel> htmlHelper,
            Expression<Func<TModel, TEnum>> expression, string optionLabel, IDictionary<string, object> htmlAttributes)
        {
            if (expression == null)
            {
                throw Error.ArgumentNull("expression");
            }

            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            if (metadata == null)
            {
                throw Error.Argument("expression", MvcResources.SelectExtensions_InvalidExpressionParameterNoMetadata,
                    expression.ToString());
            }

            if (metadata.ModelType == null)
            {
                throw Error.Argument("expression", MvcResources.SelectExtensions_InvalidExpressionParameterNoModelType,
                    expression.ToString());
            }

            if (!EnumHelper.IsValidForEnumHelper(metadata.ModelType))
            {
                string formatString;
                if (EnumHelper.HasFlags(metadata.ModelType))
                {
                    formatString = MvcResources.SelectExtensions_InvalidExpressionParameterTypeHasFlags;
                }
                else
                {
                    formatString = MvcResources.SelectExtensions_InvalidExpressionParameterType;
                }

                throw Error.Argument("expression", formatString, metadata.ModelType.FullName, "Flags");
            }

            // Run through same processing as SelectInternal() to determine selected value and ensure it is included
            // in the select list.
            string expressionName = ExpressionHelper.GetExpressionText(expression);
            string expressionFullName =
                htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(expressionName);
            Enum currentValue = null;
            if (!String.IsNullOrEmpty(expressionFullName))
            {
                currentValue = htmlHelper.GetModelStateValue(expressionFullName, metadata.ModelType) as Enum;
            }

            if (currentValue == null && !String.IsNullOrEmpty(expressionName))
            {
                // Ignore any select list (enumerable with this name) in the view data
                currentValue = htmlHelper.ViewData.Eval(expressionName) as Enum;
            }

            if (currentValue == null)
            {
                currentValue = metadata.Model as Enum;
            }

            IList<SelectListItem> selectList = EnumHelper.GetSelectList(metadata.ModelType, currentValue);
            if (!String.IsNullOrEmpty(optionLabel) && selectList.Count != 0 && String.IsNullOrEmpty(selectList[0].Text))
            {
                // Were given an optionLabel and the select list has a blank initial slot.  Combine.
                selectList[0].Text = optionLabel;

                // Use the option label just once; don't pass it down the lower-level helpers.
                optionLabel = null;
            }

            return DropDownListHelper(htmlHelper, metadata, expressionName, selectList, optionLabel, htmlAttributes);
        }

        private static MvcHtmlString DropDownListHelper(HtmlHelper htmlHelper, ModelMetadata metadata, string expression, IEnumerable<SelectListItem> selectList, string optionLabel, IDictionary<string, object> htmlAttributes)
        {
            return SelectInternal(htmlHelper, metadata, optionLabel, expression, selectList, allowMultiple: false, htmlAttributes: htmlAttributes);
        }

        // ListBox

        public static MvcHtmlString ListBox(this HtmlHelper htmlHelper, string name)
        {
            return ListBox(htmlHelper, name, null /* selectList */, null /* htmlAttributes */);
        }

        public static MvcHtmlString ListBox(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList)
        {
            return ListBox(htmlHelper, name, selectList, (IDictionary<string, object>)null);
        }

        public static MvcHtmlString ListBox(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return ListBox(htmlHelper, name, selectList, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString ListBox(this HtmlHelper htmlHelper, string name, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            return ListBoxHelper(htmlHelper, metadata: null, name: name, selectList: selectList, htmlAttributes: htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ListBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList)
        {
            return ListBoxFor(htmlHelper, expression, selectList, null /* htmlAttributes */);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ListBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return ListBoxFor(htmlHelper, expression, selectList, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Users cannot use anonymous methods with the LambdaExpression type")]
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ListBoxFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);

            return ListBoxHelper(htmlHelper,
                                 metadata,
                                 ExpressionHelper.GetExpressionText(expression),
                                 selectList,
                                 htmlAttributes);
        }

        private static MvcHtmlString ListBoxHelper(HtmlHelper htmlHelper, ModelMetadata metadata, string name, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            return SelectInternal(htmlHelper, metadata, optionLabel: null, name: name, selectList: selectList, allowMultiple: true, htmlAttributes: htmlAttributes);
        }

        // Helper methods

        private static IEnumerable<SelectListItem> GetSelectData(this HtmlHelper htmlHelper, string name)
        {
            object o = null;
            if (htmlHelper.ViewData != null && !String.IsNullOrEmpty(name))
            {
                o = htmlHelper.ViewData.Eval(name);
            }
            if (o == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.HtmlHelper_MissingSelectData,
                        name,
                        "IEnumerable<SelectListItem>"));
            }
            IEnumerable<SelectListItem> selectList = o as IEnumerable<SelectListItem>;
            if (selectList == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.HtmlHelper_WrongSelectDataType,
                        name,
                        o.GetType().FullName,
                        "IEnumerable<SelectListItem>"));
            }
            return selectList;
        }

        internal static string ListItemToOption(SelectListItem item)
        {
            TagBuilder builder = new TagBuilder("option")
            {
                InnerHtml = HttpUtility.HtmlEncode(item.Text)
            };
            if (item.Value != null)
            {
                builder.Attributes["value"] = item.Value;
            }
            if (item.Selected)
            {
                builder.Attributes["selected"] = "selected";
            }
            if (item.Disabled)
            {
                builder.Attributes["disabled"] = "disabled";
            }
            return builder.ToString(TagRenderMode.Normal);
        }

        private static IEnumerable<SelectListItem> GetSelectListWithDefaultValue(IEnumerable<SelectListItem> selectList, object defaultValue, bool allowMultiple)
        {
            IEnumerable defaultValues;

            if (allowMultiple)
            {
                defaultValues = defaultValue as IEnumerable;
                if (defaultValues == null || defaultValues is string)
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            MvcResources.HtmlHelper_SelectExpressionNotEnumerable,
                            "expression"));
                }
            }
            else
            {
                defaultValues = new[] { defaultValue };
            }

            IEnumerable<string> values = from object value in defaultValues
                                         select Convert.ToString(value, CultureInfo.CurrentCulture);

            // ToString() by default returns an enum value's name.  But selectList may use numeric values.
            IEnumerable<string> enumValues = from Enum value in defaultValues.OfType<Enum>()
                                             select value.ToString("d");
            values = values.Concat(enumValues);

            HashSet<string> selectedValues = new HashSet<string>(values, StringComparer.OrdinalIgnoreCase);
            List<SelectListItem> newSelectList = new List<SelectListItem>();

            foreach (SelectListItem item in selectList)
            {
                item.Selected = (item.Value != null) ? selectedValues.Contains(item.Value) : selectedValues.Contains(item.Text);
                newSelectList.Add(item);
            }
            return newSelectList;
        }

        private static MvcHtmlString SelectInternal(this HtmlHelper htmlHelper, ModelMetadata metadata,
            string optionLabel, string name, IEnumerable<SelectListItem> selectList, bool allowMultiple,
            IDictionary<string, object> htmlAttributes)
        {
            string fullName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            if (String.IsNullOrEmpty(fullName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
            }

            bool usedViewData = false;

            // If we got a null selectList, try to use ViewData to get the list of items.
            if (selectList == null)
            {
                selectList = htmlHelper.GetSelectData(name);
                usedViewData = true;
            }

            object defaultValue = (allowMultiple) ? htmlHelper.GetModelStateValue(fullName, typeof(string[])) : htmlHelper.GetModelStateValue(fullName, typeof(string));

            // If we haven't already used ViewData to get the entire list of items then we need to
            // use the ViewData-supplied value before using the parameter-supplied value.
            if (defaultValue == null)
            {
                if (!usedViewData && !String.IsNullOrEmpty(name))
                {
                    defaultValue = htmlHelper.ViewData.Eval(name);
                }
                else if (metadata != null)
                {
                    defaultValue = metadata.Model;
                }
            }

            if (defaultValue != null)
            {
                selectList = GetSelectListWithDefaultValue(selectList, defaultValue, allowMultiple);
            }

            // Convert each ListItem to an <option> tag and wrap them with <optgroup> if requested.
            StringBuilder listItemBuilder = BuildItems(optionLabel, selectList);

            TagBuilder tagBuilder = new TagBuilder("select")
            {
                InnerHtml = listItemBuilder.ToString()
            };
            tagBuilder.MergeAttributes(htmlAttributes);
            tagBuilder.MergeAttribute("name", fullName, true /* replaceExisting */);
            tagBuilder.GenerateId(fullName);
            if (allowMultiple)
            {
                tagBuilder.MergeAttribute("multiple", "multiple");
            }

            // If there are any errors for a named field, we add the css attribute.
            ModelState modelState;
            if (htmlHelper.ViewData.ModelState.TryGetValue(fullName, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }

            tagBuilder.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata));

            return tagBuilder.ToMvcHtmlString(TagRenderMode.Normal);
        }

        private static StringBuilder BuildItems(string optionLabel, IEnumerable<SelectListItem> selectList)
        {
            StringBuilder listItemBuilder = new StringBuilder();

            // Make optionLabel the first item that gets rendered.
            if (optionLabel != null)
            {
                listItemBuilder.AppendLine(ListItemToOption(new SelectListItem()
                {
                    Text = optionLabel,
                    Value = String.Empty,
                    Selected = false
                }));
            }

            // Group items in the SelectList if requested.
            // Treat each item with Group == null as a member of a unique group
            // so they are added according to the original order.
            IEnumerable<IGrouping<int, SelectListItem>> groupedSelectList = selectList.GroupBy<SelectListItem, int>(
                i => (i.Group == null) ? i.GetHashCode() : i.Group.GetHashCode());
            foreach (IGrouping<int, SelectListItem> group in groupedSelectList)
            {
                SelectListGroup optGroup = group.First().Group;

                // Wrap if requested.
                TagBuilder groupBuilder = null;
                if (optGroup != null)
                {
                    groupBuilder = new TagBuilder("optgroup");
                    if (optGroup.Name != null)
                    {
                        groupBuilder.MergeAttribute("label", optGroup.Name);
                    }
                    if (optGroup.Disabled)
                    {
                        groupBuilder.MergeAttribute("disabled", "disabled");
                    }
                    listItemBuilder.AppendLine(groupBuilder.ToString(TagRenderMode.StartTag));
                }

                foreach (SelectListItem item in group)
                {
                    listItemBuilder.AppendLine(ListItemToOption(item));
                }

                if (optGroup != null)
                {
                    listItemBuilder.AppendLine(groupBuilder.ToString(TagRenderMode.EndTag));
                }
            }

            return listItemBuilder;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/TemplateHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.UI.WebControls;
using System.Web.WebPages;

namespace System.Web.Mvc.Html
{
    internal static class TemplateHelpers
    {
        private static readonly Dictionary<DataBoundControlMode, string> _modeViewPaths =
            new Dictionary<DataBoundControlMode, string>
            {
                { DataBoundControlMode.ReadOnly, "DisplayTemplates" },
                { DataBoundControlMode.Edit, "EditorTemplates" }
            };

        private static readonly Dictionary<string, Func<HtmlHelper, string>> _defaultDisplayActions =
            new Dictionary<string, Func<HtmlHelper, string>>(StringComparer.OrdinalIgnoreCase)
            {
                { "EmailAddress", DefaultDisplayTemplates.EmailAddressTemplate },
                { "HiddenInput", DefaultDisplayTemplates.HiddenInputTemplate },
                { "Html", DefaultDisplayTemplates.HtmlTemplate },
                { "Text", DefaultDisplayTemplates.StringTemplate },
                { "Url", DefaultDisplayTemplates.UrlTemplate },
                { "Collection", DefaultDisplayTemplates.CollectionTemplate },
                { typeof(bool).Name, DefaultDisplayTemplates.BooleanTemplate },
                { typeof(decimal).Name, DefaultDisplayTemplates.DecimalTemplate },
                { typeof(string).Name, DefaultDisplayTemplates.StringTemplate },
                { typeof(object).Name, DefaultDisplayTemplates.ObjectTemplate },
            };

        private static readonly Dictionary<string, Func<HtmlHelper, string>> _defaultEditorActions =
            new Dictionary<string, Func<HtmlHelper, string>>(StringComparer.OrdinalIgnoreCase)
            {
                { "HiddenInput", DefaultEditorTemplates.HiddenInputTemplate },
                { "MultilineText", DefaultEditorTemplates.MultilineTextTemplate },
                { "Password", DefaultEditorTemplates.PasswordTemplate },
                { "Text", DefaultEditorTemplates.StringTemplate },
                { "Collection", DefaultEditorTemplates.CollectionTemplate },
                { "PhoneNumber", DefaultEditorTemplates.PhoneNumberInputTemplate },
                { "Url", DefaultEditorTemplates.UrlInputTemplate },
                { "EmailAddress", DefaultEditorTemplates.EmailAddressInputTemplate },
                { "DateTime", DefaultEditorTemplates.DateTimeInputTemplate },
                { "DateTime-local", DefaultEditorTemplates.DateTimeLocalInputTemplate },
                { "Date", DefaultEditorTemplates.DateInputTemplate },
                { "Time", DefaultEditorTemplates.TimeInputTemplate },
                { typeof(Color).Name, DefaultEditorTemplates.ColorInputTemplate },
                { typeof(byte).Name, DefaultEditorTemplates.NumberInputTemplate },
                { typeof(sbyte).Name, DefaultEditorTemplates.NumberInputTemplate },
                { typeof(int).Name, DefaultEditorTemplates.NumberInputTemplate },
                { typeof(uint).Name, DefaultEditorTemplates.NumberInputTemplate },
                { typeof(long).Name, DefaultEditorTemplates.NumberInputTemplate },
                { typeof(ulong).Name, DefaultEditorTemplates.NumberInputTemplate },
                { typeof(bool).Name, DefaultEditorTemplates.BooleanTemplate },
                { typeof(decimal).Name, DefaultEditorTemplates.DecimalTemplate },
                { typeof(string).Name, DefaultEditorTemplates.StringTemplate },
                { typeof(object).Name, DefaultEditorTemplates.ObjectTemplate },
            };

        internal static string CacheItemId = Guid.NewGuid().ToString();

        internal delegate string ExecuteTemplateDelegate(HtmlHelper html, ViewDataDictionary viewData, string templateName,
                                                         DataBoundControlMode mode, GetViewNamesDelegate getViewNames,
                                                         GetDefaultActionsDelegate getDefaultActions);

        internal delegate Dictionary<string, Func<HtmlHelper, string>> GetDefaultActionsDelegate(DataBoundControlMode mode);

        internal delegate IEnumerable<string> GetViewNamesDelegate(ModelMetadata metadata, params string[] templateHints);

        internal delegate string TemplateHelperDelegate(HtmlHelper html, ModelMetadata metadata, string htmlFieldName,
                                                        string templateName, DataBoundControlMode mode, object additionalViewData);

        internal static string ExecuteTemplate(HtmlHelper html, ViewDataDictionary viewData, string templateName, DataBoundControlMode mode, GetViewNamesDelegate getViewNames, GetDefaultActionsDelegate getDefaultActions)
        {
            Dictionary<string, ActionCacheItem> actionCache = GetActionCache(html);
            Dictionary<string, Func<HtmlHelper, string>> defaultActions = getDefaultActions(mode);
            string modeViewPath = _modeViewPaths[mode];

            foreach (string viewName in getViewNames(viewData.ModelMetadata, templateName, viewData.ModelMetadata.TemplateHint, viewData.ModelMetadata.DataTypeName))
            {
                string fullViewName = modeViewPath + "/" + viewName;
                ActionCacheItem cacheItem;

                if (actionCache.TryGetValue(fullViewName, out cacheItem))
                {
                    if (cacheItem != null)
                    {
                        return cacheItem.Execute(html, viewData);
                    }
                }
                else
                {
                    ViewEngineResult viewEngineResult = ViewEngines.Engines.FindPartialView(html.ViewContext, fullViewName);
                    if (viewEngineResult.View != null)
                    {
                        actionCache[fullViewName] = new ActionCacheViewItem { ViewName = fullViewName };

                        using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
                        {
                            viewEngineResult.View.Render(new ViewContext(html.ViewContext, viewEngineResult.View, viewData, html.ViewContext.TempData, writer), writer);
                            return writer.ToString();
                        }
                    }

                    Func<HtmlHelper, string> defaultAction;
                    if (defaultActions.TryGetValue(viewName, out defaultAction))
                    {
                        actionCache[fullViewName] = new ActionCacheCodeItem { Action = defaultAction };
                        return defaultAction(MakeHtmlHelper(html, viewData));
                    }

                    actionCache[fullViewName] = null;
                }
            }

            throw new InvalidOperationException(
                String.Format(
                    CultureInfo.CurrentCulture,
                    MvcResources.TemplateHelpers_NoTemplate,
                    viewData.ModelMetadata.RealModelType.FullName));
        }

        internal static Dictionary<string, ActionCacheItem> GetActionCache(HtmlHelper html)
        {
            HttpContextBase context = html.ViewContext.HttpContext;
            Dictionary<string, ActionCacheItem> result;

            if (!context.Items.Contains(CacheItemId))
            {
                result = new Dictionary<string, ActionCacheItem>();
                context.Items[CacheItemId] = result;
            }
            else
            {
                result = (Dictionary<string, ActionCacheItem>)context.Items[CacheItemId];
            }

            return result;
        }

        internal static Dictionary<string, Func<HtmlHelper, string>> GetDefaultActions(DataBoundControlMode mode)
        {
            return mode == DataBoundControlMode.ReadOnly ? _defaultDisplayActions : _defaultEditorActions;
        }

        internal static IEnumerable<string> GetViewNames(ModelMetadata metadata, params string[] templateHints)
        {
            foreach (string templateHint in templateHints.Where(s => !String.IsNullOrEmpty(s)))
            {
                yield return templateHint;
            }

            // We don't want to search for Nullable<T>, we want to search for T (which should handle both T and Nullable<T>)
            Type fieldType = Nullable.GetUnderlyingType(metadata.RealModelType) ?? metadata.RealModelType;

            // TODO: Make better string names for generic types
            yield return fieldType.Name;

            if (fieldType == typeof(string))
            {
                // Nothing more to provide
                yield break;
            }
            else if (!metadata.IsComplexType)
            {
                // IsEnum is false for the Enum class itself
                if (fieldType.IsEnum)
                {
                    // Same as fieldType.BaseType.Name in this case
                    yield return "Enum";
                }
                else if (fieldType == typeof(DateTimeOffset))
                {
                    yield return "DateTime";
                }

                yield return "String";
            }
            else if (fieldType.IsInterface)
            {
                if (typeof(IEnumerable).IsAssignableFrom(fieldType))
                {
                    yield return "Collection";
                }

                yield return "Object";
            }
            else
            {
                bool isEnumerable = typeof(IEnumerable).IsAssignableFrom(fieldType);

                while (true)
                {
                    fieldType = fieldType.BaseType;
                    if (fieldType == null)
                    {
                        break;
                    }

                    if (isEnumerable && fieldType == typeof(Object))
                    {
                        yield return "Collection";
                    }

                    yield return fieldType.Name;
                }
            }
        }

        internal static MvcHtmlString Template(HtmlHelper html, string expression, string templateName, string htmlFieldName, DataBoundControlMode mode, object additionalViewData)
        {
            return MvcHtmlString.Create(Template(html, expression, templateName, htmlFieldName, mode, additionalViewData, TemplateHelper));
        }

        // Unit testing version
        internal static string Template(HtmlHelper html, string expression, string templateName, string htmlFieldName,
                                        DataBoundControlMode mode, object additionalViewData, TemplateHelperDelegate templateHelper)
        {
            return templateHelper(html,
                                  ModelMetadata.FromStringExpression(expression, html.ViewData),
                                  htmlFieldName ?? ExpressionHelper.GetExpressionText(expression),
                                  templateName,
                                  mode,
                                  additionalViewData);
        }

        internal static MvcHtmlString TemplateFor<TContainer, TValue>(this HtmlHelper<TContainer> html, Expression<Func<TContainer, TValue>> expression,
                                                                      string templateName, string htmlFieldName, DataBoundControlMode mode,
                                                                      object additionalViewData)
        {
            return MvcHtmlString.Create(TemplateFor(html, expression, templateName, htmlFieldName, mode, additionalViewData, TemplateHelper));
        }

        // Unit testing version
        internal static string TemplateFor<TContainer, TValue>(this HtmlHelper<TContainer> html, Expression<Func<TContainer, TValue>> expression,
                                                               string templateName, string htmlFieldName, DataBoundControlMode mode,
                                                               object additionalViewData, TemplateHelperDelegate templateHelper)
        {
            return templateHelper(html,
                                  ModelMetadata.FromLambdaExpression(expression, html.ViewData),
                                  htmlFieldName ?? ExpressionHelper.GetExpressionText(expression),
                                  templateName,
                                  mode,
                                  additionalViewData);
        }

        internal static string TemplateHelper(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData)
        {
            return TemplateHelper(html, metadata, htmlFieldName, templateName, mode, additionalViewData, ExecuteTemplate);
        }

        internal static string TemplateHelper(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData, ExecuteTemplateDelegate executeTemplate)
        {
            // TODO: Convert Editor into Display if model.IsReadOnly is true? Need to be careful about this because
            // the Model property on the ViewPage/ViewUserControl is get-only, so the type descriptor automatically
            // decorates it with a [ReadOnly] attribute...

            if (metadata.ConvertEmptyStringToNull && String.Empty.Equals(metadata.Model))
            {
                metadata.Model = null;
            }

            object formattedModelValue = metadata.Model;
            if (metadata.Model == null && mode == DataBoundControlMode.ReadOnly)
            {
                formattedModelValue = metadata.NullDisplayText;
            }

            string formatString = mode == DataBoundControlMode.ReadOnly ? metadata.DisplayFormatString : metadata.EditFormatString;
            if (metadata.Model != null && !String.IsNullOrEmpty(formatString))
            {
                formattedModelValue = String.Format(CultureInfo.CurrentCulture, formatString, metadata.Model);
            }

            // Normally this shouldn't happen, unless someone writes their own custom Object templates which
            // don't check to make sure that the object hasn't already been displayed
            object visitedObjectsKey = metadata.Model ?? metadata.RealModelType;
            if (html.ViewDataContainer.ViewData.TemplateInfo.VisitedObjects.Contains(visitedObjectsKey))
            {
                // DDB #224750
                return String.Empty;
            }

            ViewDataDictionary viewData = new ViewDataDictionary(html.ViewDataContainer.ViewData)
            {
                Model = metadata.Model,
                ModelMetadata = metadata,
                TemplateInfo = new TemplateInfo
                {
                    FormattedModelValue = formattedModelValue,
                    HtmlFieldPrefix = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(htmlFieldName),
                    VisitedObjects = new HashSet<object>(html.ViewContext.ViewData.TemplateInfo.VisitedObjects), // DDB #224750
                }
            };

            if (additionalViewData != null)
            {
                foreach (KeyValuePair<string, object> kvp in TypeHelper.ObjectToDictionary(additionalViewData))
                {
                    viewData[kvp.Key] = kvp.Value;
                }
            }

            viewData.TemplateInfo.VisitedObjects.Add(visitedObjectsKey); // DDB #224750

            return executeTemplate(html, viewData, templateName, mode, GetViewNames, GetDefaultActions);
        }

        // Helpers

        private static HtmlHelper MakeHtmlHelper(HtmlHelper html, ViewDataDictionary viewData)
        {
            var newHelper = new HtmlHelper(
                new ViewContext(html.ViewContext, html.ViewContext.View, viewData, html.ViewContext.TempData, html.ViewContext.Writer),
                new ViewDataContainer(viewData));
            newHelper.Html5DateRenderingMode = html.Html5DateRenderingMode;
            return newHelper;
        }

        internal class ActionCacheCodeItem : ActionCacheItem
        {
            public Func<HtmlHelper, string> Action { get; set; }

            public override string Execute(HtmlHelper html, ViewDataDictionary viewData)
            {
                return Action(MakeHtmlHelper(html, viewData));
            }
        }

        internal abstract class ActionCacheItem
        {
            public abstract string Execute(HtmlHelper html, ViewDataDictionary viewData);
        }

        internal class ActionCacheViewItem : ActionCacheItem
        {
            public string ViewName { get; set; }

            public override string Execute(HtmlHelper html, ViewDataDictionary viewData)
            {
                ViewEngineResult viewEngineResult = ViewEngines.Engines.FindPartialView(html.ViewContext, ViewName);
                using (StringWriter writer = new StringWriter(CultureInfo.InvariantCulture))
                {
                    viewEngineResult.View.Render(new ViewContext(html.ViewContext, viewEngineResult.View, viewData, html.ViewContext.TempData, writer), writer);
                    return writer.ToString();
                }
            }
        }

        private class ViewDataContainer : IViewDataContainer
        {
            public ViewDataContainer(ViewDataDictionary viewData)
            {
                ViewData = viewData;
            }

            public ViewDataDictionary ViewData { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/TextAreaExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq.Expressions;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc.Html
{
    public static class TextAreaExtensions
    {
        // These values are similar to the defaults used by WebForms
        // when using <asp:TextBox TextMode="MultiLine"> without specifying
        // the Rows and Columns attributes.
        private const int TextAreaRows = 2;
        private const int TextAreaColumns = 20;

        private static Dictionary<string, object> implicitRowsAndColumns = new Dictionary<string, object>
        {
            { "rows", TextAreaRows.ToString(CultureInfo.InvariantCulture) },
            { "cols", TextAreaColumns.ToString(CultureInfo.InvariantCulture) },
        };

        private static Dictionary<string, object> GetRowsAndColumnsDictionary(int rows, int columns)
        {
            if (rows < 0)
            {
                throw new ArgumentOutOfRangeException("rows", MvcResources.HtmlHelper_TextAreaParameterOutOfRange);
            }
            if (columns < 0)
            {
                throw new ArgumentOutOfRangeException("columns", MvcResources.HtmlHelper_TextAreaParameterOutOfRange);
            }

            Dictionary<string, object> result = new Dictionary<string, object>();
            if (rows > 0)
            {
                result.Add("rows", rows.ToString(CultureInfo.InvariantCulture));
            }
            if (columns > 0)
            {
                result.Add("cols", columns.ToString(CultureInfo.InvariantCulture));
            }

            return result;
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name)
        {
            return TextArea(htmlHelper, name, null /* value */, null /* htmlAttributes */);
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, object htmlAttributes)
        {
            return TextArea(htmlHelper, name, null /* value */, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, IDictionary<string, object> htmlAttributes)
        {
            return TextArea(htmlHelper, name, null /* value */, htmlAttributes);
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, string value)
        {
            return TextArea(htmlHelper, name, value, null /* htmlAttributes */);
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, string value, object htmlAttributes)
        {
            return TextArea(htmlHelper, name, value, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, string value, IDictionary<string, object> htmlAttributes)
        {
            ModelMetadata metadata = ModelMetadata.FromStringExpression(name, htmlHelper.ViewContext.ViewData);
            if (value != null)
            {
                metadata.Model = value;
            }

            return TextAreaHelper(htmlHelper, metadata, name, implicitRowsAndColumns, htmlAttributes);
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, string value, int rows, int columns, object htmlAttributes)
        {
            return TextArea(htmlHelper, name, value, rows, columns, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public static MvcHtmlString TextArea(this HtmlHelper htmlHelper, string name, string value, int rows, int columns, IDictionary<string, object> htmlAttributes)
        {
            ModelMetadata metadata = ModelMetadata.FromStringExpression(name, htmlHelper.ViewContext.ViewData);
            if (value != null)
            {
                metadata.Model = value;
            }

            return TextAreaHelper(htmlHelper, metadata, name, GetRowsAndColumnsDictionary(rows, columns), htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextAreaFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            return TextAreaFor(htmlHelper, expression, (IDictionary<string, object>)null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextAreaFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, object htmlAttributes)
        {
            return TextAreaFor(htmlHelper, expression, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextAreaFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, IDictionary<string, object> htmlAttributes)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            return TextAreaHelper(htmlHelper,
                                  ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData),
                                  ExpressionHelper.GetExpressionText(expression),
                                  implicitRowsAndColumns,
                                  htmlAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextAreaFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, int rows, int columns, object htmlAttributes)
        {
            return TextAreaFor(htmlHelper, expression, rows, columns, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString TextAreaFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, int rows, int columns, IDictionary<string, object> htmlAttributes)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }

            return TextAreaHelper(htmlHelper,
                                  ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData),
                                  ExpressionHelper.GetExpressionText(expression),
                                  GetRowsAndColumnsDictionary(rows, columns),
                                  htmlAttributes);
        }

        [SuppressMessage("Microsoft.Usage", "CA2208:InstantiateArgumentExceptionsCorrectly", Justification = "If this fails, it is because the string-based version had an empty 'name' parameter")]
        internal static MvcHtmlString TextAreaHelper(HtmlHelper htmlHelper, ModelMetadata modelMetadata, string name, IDictionary<string, object> rowsAndColumns, IDictionary<string, object> htmlAttributes, string innerHtmlPrefix = null)
        {
            string fullName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            if (String.IsNullOrEmpty(fullName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "name");
            }

            TagBuilder tagBuilder = new TagBuilder("textarea");
            tagBuilder.GenerateId(fullName);
            tagBuilder.MergeAttributes(htmlAttributes, true);
            tagBuilder.MergeAttributes(rowsAndColumns, rowsAndColumns != implicitRowsAndColumns); // Only force explicit rows/cols
            tagBuilder.MergeAttribute("name", fullName, true);

            // If there are any errors for a named field, we add the CSS attribute.
            ModelState modelState;
            if (htmlHelper.ViewData.ModelState.TryGetValue(fullName, out modelState) && modelState.Errors.Count > 0)
            {
                tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
            }

            tagBuilder.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(name, modelMetadata));

            string value;
            if (modelState != null && modelState.Value != null)
            {
                value = modelState.Value.AttemptedValue;
            }
            else if (modelMetadata.Model != null)
            {
                value = modelMetadata.Model.ToString();
            }
            else
            {
                value = String.Empty;
            }

            // The first newline is always trimmed when a TextArea is rendered, so we add an extra one
            // in case the value being rendered is something like "\r\nHello".
            tagBuilder.InnerHtml = (innerHtmlPrefix ?? Environment.NewLine) + HttpUtility.HtmlEncode(value);

            return tagBuilder.ToMvcHtmlString(TagRenderMode.Normal);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/ValidationExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc.Html
{
    public static class ValidationExtensions
    {
        private const string HiddenListItem = @"<li style=""display:none""></li>";
        private static string _resourceClassKey;

        public static string ResourceClassKey
        {
            get { return _resourceClassKey ?? String.Empty; }
            set { _resourceClassKey = value; }
        }

        private static FieldValidationMetadata ApplyFieldValidationMetadata(HtmlHelper htmlHelper, ModelMetadata modelMetadata, string modelName)
        {
            FormContext formContext = htmlHelper.ViewContext.FormContext;
            FieldValidationMetadata fieldMetadata = formContext.GetValidationMetadataForField(modelName, true /* createIfNotFound */);

            // write rules to context object
            IEnumerable<ModelValidator> validators = ModelValidatorProviders.Providers.GetValidators(modelMetadata, htmlHelper.ViewContext);
            foreach (ModelClientValidationRule rule in validators.SelectMany(v => v.GetClientValidationRules()))
            {
                fieldMetadata.ValidationRules.Add(rule);
            }

            return fieldMetadata;
        }

        private static string GetInvalidPropertyValueResource(HttpContextBase httpContext)
        {
            string resourceValue = null;
            if (!String.IsNullOrEmpty(ResourceClassKey) && (httpContext != null))
            {
                // If the user specified a ResourceClassKey try to load the resource they specified.
                // If the class key is invalid, an exception will be thrown.
                // If the class key is valid but the resource is not found, it returns null, in which
                // case it will fall back to the MVC default error message.
                resourceValue = httpContext.GetGlobalResourceObject(ResourceClassKey, "InvalidPropertyValue", CultureInfo.CurrentUICulture) as string;
            }
            return resourceValue ?? MvcResources.Common_ValueNotValidForProperty;
        }

        private static string GetUserErrorMessageOrDefault(HttpContextBase httpContext, ModelError error, ModelState modelState)
        {
            if (!String.IsNullOrEmpty(error.ErrorMessage))
            {
                return error.ErrorMessage;
            }
            if (modelState == null)
            {
                return null;
            }

            string attemptedValue = (modelState.Value != null) ? modelState.Value.AttemptedValue : null;
            return String.Format(CultureInfo.CurrentCulture, GetInvalidPropertyValueResource(httpContext), attemptedValue);
        }

        // Validate

        public static void Validate(this HtmlHelper htmlHelper, string modelName)
        {
            if (modelName == null)
            {
                throw new ArgumentNullException("modelName");
            }

            ValidateHelper(htmlHelper,
                           ModelMetadata.FromStringExpression(modelName, htmlHelper.ViewContext.ViewData),
                           modelName);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static void ValidateFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            ValidateHelper(htmlHelper,
                           ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData),
                           ExpressionHelper.GetExpressionText(expression));
        }

        private static void ValidateHelper(HtmlHelper htmlHelper, ModelMetadata modelMetadata, string expression)
        {
            FormContext formContext = htmlHelper.ViewContext.GetFormContextForClientValidation();
            if (formContext == null || htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled)
            {
                return; // nothing to do
            }

            string modelName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(expression);
            ApplyFieldValidationMetadata(htmlHelper, modelMetadata, modelName);
        }

        // ValidationMessage

        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName)
        {
            return ValidationMessage(htmlHelper, modelName, validationMessage: null, htmlAttributes: new RouteValueDictionary());
        }

        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName, object htmlAttributes)
        {
            return ValidationMessage(htmlHelper, modelName, validationMessage: null, htmlAttributes: HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        /// <summary>
        /// Displays a validation message if an error exists for the specified entry in the
        /// <see cref="ModelStateDictionary"/> object.
        /// </summary>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="modelName">The name of the entry being validated.</param>
        /// <param name="htmlAttributes">An object that contains the HTML attributes for the element.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the entry is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper,
                                                      string modelName,
                                                      object htmlAttributes,
                                                      string tag)
        {
            return ValidationMessage(htmlHelper,
                                     modelName,
                                     validationMessage: null,
                                     htmlAttributes: HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes),
                                     tag: tag);
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", Justification = "'validationMessage' refers to the message that will be rendered by the ValidationMessage helper.")]
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName, string validationMessage)
        {
            return ValidationMessage(htmlHelper, modelName, validationMessage, new RouteValueDictionary());
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", Justification = "'validationMessage' refers to the message that will be rendered by the ValidationMessage helper.")]
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName, string validationMessage, object htmlAttributes)
        {
            return ValidationMessage(htmlHelper, modelName, validationMessage, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        /// <summary>
        /// Displays a validation message if an error exists for the specified entry in the
        /// <see cref="ModelStateDictionary"/> object.
        /// </summary>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="modelName">The name of the entry being validated.</param>
        /// <param name="validationMessage">The message to display if the specified entry contains an error.</param>
        /// <param name="htmlAttributes">An object that contains the HTML attributes for the element.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the entry is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", Justification =
            "'validationMessage' refers to the message that will be rendered by the ValidationMessage helper.")]
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper,
                                                      string modelName,
                                                      string validationMessage,
                                                      object htmlAttributes,
                                                      string tag)
        {
            return ValidationMessage(htmlHelper,
                                     modelName,
                                     validationMessage,
                                     HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes),
                                     tag);
        }

        /// <summary>
        /// Displays a validation message if an error exists for the specified entry in the
        /// <see cref="ModelStateDictionary"/> object.
        /// </summary>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="modelName">The name of the entry being validated.</param>
        /// <param name="validationMessage">The message to display if the specified entry contains an error.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the entry is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", Justification =
            "'validationMessage' refers to the message that will be rendered by the ValidationMessage helper.")]
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper,
                                                      string modelName,
                                                      string validationMessage,
                                                      string tag)
        {
            return ValidationMessage(htmlHelper,
                                     modelName,
                                     validationMessage,
                                     htmlAttributes: new RouteValueDictionary(),
                                     tag: tag);
        }

        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName, IDictionary<string, object> htmlAttributes)
        {
            return ValidationMessage(htmlHelper, modelName, validationMessage: null, htmlAttributes: htmlAttributes);
        }

        /// <summary>
        /// Displays a validation message if an error exists for the specified entry in the
        /// <see cref="ModelStateDictionary"/> object.
        /// </summary>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="modelName">The name of the entry being validated.</param>
        /// <param name="htmlAttributes">An <see cref="IDictionary{TKey,TValue}"/> that contains the HTML attributes
        /// for the element.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the entry is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper,
                                                      string modelName,
                                                      IDictionary<string, object> htmlAttributes,
                                                      string tag)
        {
            return ValidationMessage(htmlHelper,
                                     modelName,
                                     validationMessage: null,
                                     htmlAttributes: htmlAttributes,
                                     tag: tag);
        }

        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", Justification = "'validationMessage' refers to the message that will be rendered by the ValidationMessage helper.")]
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper, string modelName, string validationMessage, IDictionary<string, object> htmlAttributes)
        {
            return ValidationMessage(htmlHelper, modelName, validationMessage, htmlAttributes, tag: null);
        }

        /// <summary>
        /// Displays a validation message if an error exists for the specified entry in the
        /// <see cref="ModelStateDictionary"/> object.
        /// </summary>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="modelName">The name of the model object being validated.</param>
        /// <param name="validationMessage">The message to display if the specified entry contains an error.</param>
        /// <param name="htmlAttributes">An <see cref="IDictionary{TKey,TValue}"/> that contains the HTML attributes
        /// for the element.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the model object is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        [SuppressMessage("Microsoft.Naming", "CA1719:ParameterNamesShouldNotMatchMemberNames", Justification =
            "'validationMessage' refers to the message that will be rendered by the ValidationMessage helper.")]
        public static MvcHtmlString ValidationMessage(this HtmlHelper htmlHelper,
                                                      string modelName,
                                                      string validationMessage,
                                                      IDictionary<string, object> htmlAttributes,
                                                      string tag)
        {
            if (modelName == null)
            {
                throw new ArgumentNullException("modelName");
            }

            return ValidationMessageHelper(htmlHelper,
                                           ModelMetadata.FromStringExpression(modelName, htmlHelper.ViewContext.ViewData),
                                           modelName,
                                           validationMessage,
                                           htmlAttributes,
                                           tag);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression)
        {
            return ValidationMessageFor(htmlHelper, expression, validationMessage: null, htmlAttributes: new RouteValueDictionary());
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string validationMessage)
        {
            return ValidationMessageFor(htmlHelper, expression, validationMessage, new RouteValueDictionary());
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string validationMessage, object htmlAttributes)
        {
            return ValidationMessageFor(htmlHelper, expression, validationMessage, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper, Expression<Func<TModel, TProperty>> expression, string validationMessage, IDictionary<string, object> htmlAttributes)
        {
            return ValidationMessageFor(htmlHelper,
                                        expression,
                                        validationMessage,
                                        htmlAttributes,
                                        tag: null);
        }

        /// <summary>
        /// Returns the HTML markup for a validation-error message for the specified expression.
        /// </summary>
        /// <typeparam name="TModel">The type of the model.</typeparam>
        /// <typeparam name="TProperty">The type of the property.</typeparam>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="expression">An expression that identifies the object that contains the properties to render.
        /// </param>
        /// <param name="validationMessage">The message to display if a validation error occurs.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the model object is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification =
            "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper,
                                                                            Expression<Func<TModel, TProperty>> expression,
                                                                            string validationMessage,
                                                                            string tag)
        {
            return ValidationMessageFor(htmlHelper,
                                        expression,
                                        validationMessage,
                                        htmlAttributes: null,
                                        tag: tag);
        }

        /// <summary>
        /// Returns the HTML markup for a validation-error message for the specified expression.
        /// </summary>
        /// <typeparam name="TModel">The type of the model.</typeparam>
        /// <typeparam name="TProperty">The type of the property.</typeparam>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="expression">An expression that identifies the object that contains the properties to render.
        /// </param>
        /// <param name="validationMessage">The message to display if a validation error occurs.</param>
        /// <param name="htmlAttributes">An object that contains the HTML attributes for the element.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the model object is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification =
            "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper,
                                                                            Expression<Func<TModel, TProperty>> expression,
                                                                            string validationMessage,
                                                                            object htmlAttributes,
                                                                            string tag)
        {
            return ValidationMessageFor(htmlHelper,
                                        expression,
                                        validationMessage,
                                        HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes),
                                        tag);
        }

        /// <summary>
        /// Returns the HTML markup for a validation-error message for the specified expression.
        /// </summary>
        /// <typeparam name="TModel">The type of the model.</typeparam>
        /// <typeparam name="TProperty">The type of the property.</typeparam>
        /// <param name="htmlHelper">The HTML helper instance that this method operates on.</param>
        /// <param name="expression">An expression that identifies the object that contains the properties to render.
        /// </param>
        /// <param name="validationMessage">The message to display if a validation error occurs.</param>
        /// <param name="htmlAttributes">An <see cref="IDictionary{TKey,TValue}"/> that contains the HTML attributes
        /// for the element.</param>
        /// <param name="tag">The tag to be set for the wrapping HTML element of the validation message.</param>
        /// <returns>null if the model object is valid and client-side validation is disabled.
        /// Otherwise, a <paramref name="tag"/> element that contains an error message.</returns>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification =
            "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValidationMessageFor<TModel, TProperty>(this HtmlHelper<TModel> htmlHelper,
                                                                            Expression<Func<TModel, TProperty>> expression,
                                                                            string validationMessage,
                                                                            IDictionary<string, object> htmlAttributes,
                                                                            string tag)
        {
            return ValidationMessageHelper(htmlHelper,
                                           ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData),
                                           ExpressionHelper.GetExpressionText(expression),
                                           validationMessage,
                                           htmlAttributes,
                                           tag);
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Normalization to lowercase is a common requirement for JavaScript and HTML values")]
        private static MvcHtmlString ValidationMessageHelper(this HtmlHelper htmlHelper, ModelMetadata modelMetadata, string expression, string validationMessage, IDictionary<string, object> htmlAttributes, string tag)
        {
            string modelName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(expression);
            FormContext formContext = htmlHelper.ViewContext.GetFormContextForClientValidation();

            if (!htmlHelper.ViewData.ModelState.ContainsKey(modelName) && formContext == null)
            {
                return null;
            }

            ModelState modelState = htmlHelper.ViewData.ModelState[modelName];
            ModelErrorCollection modelErrors = (modelState == null) ? null : modelState.Errors;
            ModelError modelError = (((modelErrors == null) || (modelErrors.Count == 0)) ? null : modelErrors.FirstOrDefault(m => !String.IsNullOrEmpty(m.ErrorMessage)) ?? modelErrors[0]);

            if (modelError == null && formContext == null)
            {
                return null;
            }

            if (String.IsNullOrEmpty(tag))
            {
                tag = htmlHelper.ViewContext.ValidationMessageElement;
            }

            TagBuilder builder = new TagBuilder(tag);
            builder.MergeAttributes(htmlAttributes);
            builder.AddCssClass((modelError != null) ? HtmlHelper.ValidationMessageCssClassName : HtmlHelper.ValidationMessageValidCssClassName);

            if (!String.IsNullOrEmpty(validationMessage))
            {
                builder.SetInnerText(validationMessage);
            }
            else if (modelError != null)
            {
                builder.SetInnerText(GetUserErrorMessageOrDefault(htmlHelper.ViewContext.HttpContext, modelError, modelState));
            }

            if (formContext != null)
            {
                bool replaceValidationMessageContents = String.IsNullOrEmpty(validationMessage);

                if (htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled)
                {
                    builder.MergeAttribute("data-valmsg-for", modelName);
                    builder.MergeAttribute("data-valmsg-replace", replaceValidationMessageContents.ToString().ToLowerInvariant());
                }
                else
                {
                    FieldValidationMetadata fieldMetadata = ApplyFieldValidationMetadata(htmlHelper, modelMetadata, modelName);
                    // rules will already have been written to the metadata object
                    fieldMetadata.ReplaceValidationMessageContents = replaceValidationMessageContents; // only replace contents if no explicit message was specified

                    // client validation always requires an ID
                    builder.GenerateId(modelName + "_validationMessage");
                    fieldMetadata.ValidationMessageId = builder.Attributes["id"];
                }
            }

            return builder.ToMvcHtmlString(TagRenderMode.Normal);
        }

        // ValidationSummary

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors: false);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, bool excludePropertyErrors)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors, message: null);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, string message)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors: false, message: message, htmlAttributes: (object)null, headingTag: null);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, string message, string headingTag)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors: false, message: message, htmlAttributes: (object)null, headingTag: headingTag);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, bool excludePropertyErrors, string message)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors, message, htmlAttributes: (object)null, headingTag: null);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, bool excludePropertyErrors, string message, string headingTag)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors, message, htmlAttributes: (object)null, headingTag: headingTag);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, string message, object htmlAttributes)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors: false, message: message, htmlAttributes: HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes), headingTag: null);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, string message, object htmlAttributes, string headingTag)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors: false, message: message, htmlAttributes: HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes), headingTag: headingTag);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, bool excludePropertyErrors, string message, object htmlAttributes)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors, message, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes), null);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, bool excludePropertyErrors, string message, object htmlAttributes, string headingTag)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors, message, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes), headingTag);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, string message, IDictionary<string, object> htmlAttributes)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors: false, message: message, htmlAttributes: htmlAttributes, headingTag: null);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, string message, IDictionary<string, object> htmlAttributes, string headingTag)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors: false, message: message, htmlAttributes: htmlAttributes, headingTag: headingTag);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, bool excludePropertyErrors, string message, IDictionary<string, object> htmlAttributes)
        {
            return ValidationSummary(htmlHelper, excludePropertyErrors, message, htmlAttributes, null);
        }

        public static MvcHtmlString ValidationSummary(this HtmlHelper htmlHelper, bool excludePropertyErrors, string message, IDictionary<string, object> htmlAttributes, string headingTag)
        {
            if (htmlHelper == null)
            {
                throw new ArgumentNullException("htmlHelper");
            }

            FormContext formContext = htmlHelper.ViewContext.GetFormContextForClientValidation();
            if (htmlHelper.ViewData.ModelState.IsValid)
            {
                if (formContext == null)
                {
                    // No client side validation
                    return null;
                }
                // TODO: This isn't really about unobtrusive; can we fix up non-unobtrusive to get rid of this, too?
                if (htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled && excludePropertyErrors)
                {
                    // No client-side updates
                    return null;
                }
            }

            string messageSpan;
            if (!String.IsNullOrEmpty(message))
            {
                if (String.IsNullOrEmpty(headingTag))
                {
                    headingTag = htmlHelper.ViewContext.ValidationSummaryMessageElement;
                }

                TagBuilder spanTag = new TagBuilder(headingTag);
                spanTag.SetInnerText(message);
                messageSpan = spanTag.ToString(TagRenderMode.Normal) + Environment.NewLine;
            }
            else
            {
                messageSpan = null;
            }

            StringBuilder htmlSummary = new StringBuilder();
            TagBuilder unorderedList = new TagBuilder("ul");

            IEnumerable<ModelState> modelStates = GetModelStateList(htmlHelper, excludePropertyErrors);

            foreach (ModelState modelState in modelStates)
            {
                foreach (ModelError modelError in modelState.Errors)
                {
                    string errorText = GetUserErrorMessageOrDefault(htmlHelper.ViewContext.HttpContext, modelError, null /* modelState */);
                    if (!String.IsNullOrEmpty(errorText))
                    {
                        TagBuilder listItem = new TagBuilder("li");
                        listItem.SetInnerText(errorText);
                        htmlSummary.AppendLine(listItem.ToString(TagRenderMode.Normal));
                    }
                }
            }

            if (htmlSummary.Length == 0)
            {
                htmlSummary.AppendLine(HiddenListItem);
            }

            unorderedList.InnerHtml = htmlSummary.ToString();

            TagBuilder divBuilder = new TagBuilder("div");
            divBuilder.MergeAttributes(htmlAttributes);
            divBuilder.AddCssClass((htmlHelper.ViewData.ModelState.IsValid) ? HtmlHelper.ValidationSummaryValidCssClassName : HtmlHelper.ValidationSummaryCssClassName);
            divBuilder.InnerHtml = messageSpan + unorderedList.ToString(TagRenderMode.Normal);

            if (formContext != null)
            {
                if (htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled)
                {
                    if (!excludePropertyErrors)
                    {
                        // Only put errors in the validation summary if they're supposed to be included there
                        divBuilder.MergeAttribute("data-valmsg-summary", "true");
                    }
                }
                else
                {
                    // client val summaries need an ID
                    divBuilder.GenerateId("validationSummary");
                    formContext.ValidationSummaryId = divBuilder.Attributes["id"];
                    formContext.ReplaceValidationSummary = !excludePropertyErrors;
                }
            }
            return divBuilder.ToMvcHtmlString(TagRenderMode.Normal);
        }

        // Returns non-null list of model states, which caller will render in order provided.
        private static IEnumerable<ModelState> GetModelStateList(HtmlHelper htmlHelper, bool excludePropertyErrors)
        {
            if (excludePropertyErrors)
            {
                ModelState ms;
                htmlHelper.ViewData.ModelState.TryGetValue(htmlHelper.ViewData.TemplateInfo.HtmlFieldPrefix, out ms);
                if (ms != null)
                {
                    return new ModelState[] { ms };
                }

                return new ModelState[0];
            }
            else
            {
                // Sort modelStates to respect the ordering in the metadata.                 
                // ModelState doesn't refer to ModelMetadata, but we can correlate via the property name.
                Dictionary<string, int> ordering = new Dictionary<string, int>();

                var metadata = htmlHelper.ViewData.ModelMetadata;
                if (metadata != null)
                {
                    foreach (ModelMetadata m in metadata.Properties)
                    {
                        ordering[m.PropertyName] = m.Order;
                    }
                }

                return from kv in htmlHelper.ViewData.ModelState
                       let name = kv.Key
                       orderby ordering.GetOrDefault(name, ModelMetadata.DefaultOrder)
                       select kv.Value;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html/ValueExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Linq.Expressions;

namespace System.Web.Mvc.Html
{
    public static class ValueExtensions
    {
        public static MvcHtmlString Value(this HtmlHelper html, string name)
        {
            return Value(html, name, format: null);
        }

        public static MvcHtmlString Value(this HtmlHelper html, string name, string format)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            return ValueForHelper(html, name, value: null, format: format, useViewData: true);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValueFor<TModel, TProperty>(this HtmlHelper<TModel> html, Expression<Func<TModel, TProperty>> expression)
        {
            return ValueFor(html, expression, format: null);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static MvcHtmlString ValueFor<TModel, TProperty>(this HtmlHelper<TModel> html, Expression<Func<TModel, TProperty>> expression, string format)
        {
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            return ValueForHelper(html, ExpressionHelper.GetExpressionText(expression), metadata.Model, format, useViewData: false);
        }

        public static MvcHtmlString ValueForModel(this HtmlHelper html)
        {
            return ValueForModel(html, format: null);
        }

        public static MvcHtmlString ValueForModel(this HtmlHelper html, string format)
        {
            return Value(html, String.Empty, format);
        }

        internal static MvcHtmlString ValueForHelper(HtmlHelper html, string name, object value, string format, bool useViewData)
        {
            string fullName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            string attemptedValue = (string)html.GetModelStateValue(fullName, typeof(string));
            string resolvedValue;

            if (attemptedValue != null)
            {
                // case 1: if ModelState has a value then it's already formatted so ignore format string
                resolvedValue = attemptedValue;
            }
            else if (useViewData)
            {
                if (name.Length == 0)
                {
                    // case 2(a): format the value from ModelMetadata for the current model
                    ModelMetadata metadata = ModelMetadata.FromStringExpression(String.Empty, html.ViewContext.ViewData);
                    resolvedValue = html.FormatValue(metadata.Model, format);
                }
                else
                {
                    // case 2(b): format the value from ViewData
                    resolvedValue = html.EvalString(name, format);
                }
            }
            else
            {
                // case 3: format the explicit value from ModelMetadata
                resolvedValue = html.FormatValue(value, format);
            }

            return MvcHtmlString.Create(html.AttributeEncode(resolvedValue));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Html5DateRenderingMode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Controls the value-rendering method For HTML5 input elements of types such as date, time, datetime and datetime-local.
    /// </summary>
    public enum Html5DateRenderingMode
    {
        /// <summary>
        /// Render date and time values according to the current culture's ToString behavior.
        /// </summary>
        CurrentCulture = 0,

        /// <summary>
        /// Render date and time values as Rfc3339 compliant strings to support HTML5 date and time types of input elements.
        /// </summary>
        Rfc3339,
    }
}

================================================
FILE: src/System.Web.Mvc/HtmlHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.Helpers;
using System.Web.Mvc.Html;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.WebPages;
using System.Web.WebPages.Scope;

namespace System.Web.Mvc
{
    public class HtmlHelper
    {
        public static readonly string ValidationInputCssClassName = "input-validation-error";
        public static readonly string ValidationInputValidCssClassName = "input-validation-valid";
        public static readonly string ValidationMessageCssClassName = "field-validation-error";
        public static readonly string ValidationMessageValidCssClassName = "field-validation-valid";
        public static readonly string ValidationSummaryCssClassName = "validation-summary-errors";
        public static readonly string ValidationSummaryValidCssClassName = "validation-summary-valid";

        private static readonly object _html5InputsModeKey = new object();

        private DynamicViewDataDictionary _dynamicViewDataDictionary;

        public HtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer)
            : this(viewContext, viewDataContainer, RouteTable.Routes)
        {
        }

        public HtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer, RouteCollection routeCollection)
        {
            if (viewContext == null)
            {
                throw new ArgumentNullException("viewContext");
            }
            if (viewDataContainer == null)
            {
                throw new ArgumentNullException("viewDataContainer");
            }
            if (routeCollection == null)
            {
                throw new ArgumentNullException("routeCollection");
            }

            ViewContext = viewContext;
            ViewDataContainer = viewDataContainer;
            RouteCollection = routeCollection;
            ClientValidationRuleFactory = (name, metadata) => ModelValidatorProviders.Providers.GetValidators(metadata ?? ModelMetadata.FromStringExpression(name, ViewData), ViewContext).SelectMany(v => v.GetClientValidationRules());
        }

        public static bool ClientValidationEnabled
        {
            get { return ViewContext.GetClientValidationEnabled(); }
            set { ViewContext.SetClientValidationEnabled(value); }
        }

        public static string IdAttributeDotReplacement
        {
            get { return WebPages.Html.HtmlHelper.IdAttributeDotReplacement; }
            set { WebPages.Html.HtmlHelper.IdAttributeDotReplacement = value; }
        }

        internal Func<string, ModelMetadata, IEnumerable<ModelClientValidationRule>> ClientValidationRuleFactory { get; set; }

        public RouteCollection RouteCollection { get; private set; }

        public static bool UnobtrusiveJavaScriptEnabled
        {
            get { return ViewContext.GetUnobtrusiveJavaScriptEnabled(); }
            set { ViewContext.SetUnobtrusiveJavaScriptEnabled(value); }
        }

        /// <summary>
        /// Element name used to wrap a top-level message in
        /// <see cref="ValidationExtensions.ValidationSummary(HtmlHelper)"/> and other overloads.
        /// </summary>
        public static string ValidationSummaryMessageElement
        {
            get { return ViewContext.GetValidationSummaryMessageElement(); }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    throw Error.ParameterCannotBeNullOrEmpty("value");
                }

                ViewContext.SetValidationSummaryMessageElement(value);
            }
        }

        /// <summary>
        /// Element name used to wrap the validation message generated by
        /// <see cref="ValidationExtensions.ValidationMessage(HtmlHelper, String)"/> and other overloads.
        /// </summary>
        public static string ValidationMessageElement
        {
            get { return ViewContext.GetValidationMessageElement(); }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    throw Error.ParameterCannotBeNullOrEmpty("value");
                }

                ViewContext.SetValidationMessageElement(value);
            }
        }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewDataDictionary == null)
                {
                    _dynamicViewDataDictionary = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewDataDictionary;
            }
        }

        public ViewContext ViewContext { get; private set; }

        public ViewDataDictionary ViewData
        {
            get { return ViewDataContainer.ViewData; }
        }

        public IViewDataContainer ViewDataContainer { get; internal set; }

        /// <summary>
        /// Creates a dictionary of HTML attributes from the input object, 
        /// translating underscores to dashes.
        /// </summary>
        /// <example>
        /// <c>new { data_name="value" }</c> will translate to the entry <c>{ "data-name" , "value" }</c>
        /// in the resulting dictionary.
        /// </example>
        /// <param name="htmlAttributes">Anonymous object describing HTML attributes.</param>
        /// <returns>A dictionary that represents HTML attributes.</returns>
        public static RouteValueDictionary AnonymousObjectToHtmlAttributes(object htmlAttributes)
        {
            return System.Web.WebPages.Html.HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public MvcHtmlString AntiForgeryToken()
        {
            return new MvcHtmlString(AntiForgery.GetHtml().ToString());
        }

        /// <summary>
        /// Set this property to <see cref="Mvc.Html5DateRenderingMode.Rfc3339"/> to have templated helpers such as Html.EditorFor render date and time
        /// values as Rfc3339 compliant strings.
        /// </summary>
        /// <remarks>
        /// The scope of this setting is for the current view alone. Sub views and parent views
        /// will default to <see cref="Mvc.Html5DateRenderingMode.CurrentCulture"/> unless explicitly set otherwise.
        /// </remarks>
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "The usage of the property is as an instance property of the helper.")]
        public Html5DateRenderingMode Html5DateRenderingMode
        {
            get
            {
                object value;
                if (ScopeStorage.CurrentScope.TryGetValue(_html5InputsModeKey, out value))
                {
                    return (Html5DateRenderingMode)value;
                }
                return default(Html5DateRenderingMode);
            }
            set
            {
                ScopeStorage.CurrentScope[_html5InputsModeKey] = value;
            }
        }

        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AdditionalDataProvider", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AntiForgeryConfig", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AntiForgeryToken", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "httpCookies", Justification = "API name.")]
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Method is obsolete.")]
        [Obsolete("This method is deprecated. Use the AntiForgeryToken() method instead. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.", error: true)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public MvcHtmlString AntiForgeryToken(string salt)
        {
            if (!String.IsNullOrEmpty(salt))
            {
                throw new NotSupportedException("This method is deprecated. Use the AntiForgeryToken() method instead. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.");
            }

            return AntiForgeryToken();
        }

        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AdditionalDataProvider", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AntiForgeryConfig", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AntiForgeryToken", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "httpCookies", Justification = "API name.")]
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Method is obsolete.")]
        [Obsolete("This method is deprecated. Use the AntiForgeryToken() method instead. To specify a custom domain for the generated cookie, use the <httpCookies> configuration element. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.", error: true)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public MvcHtmlString AntiForgeryToken(string salt, string domain, string path)
        {
            if (!String.IsNullOrEmpty(salt) || !String.IsNullOrEmpty(domain) || !String.IsNullOrEmpty(path))
            {
                throw new NotSupportedException("This method is deprecated. Use the AntiForgeryToken() method instead. To specify a custom domain for the generated cookie, use the <httpCookies> configuration element. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.");
            }

            return AntiForgeryToken();
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public string AttributeEncode(string value)
        {
            return (!String.IsNullOrEmpty(value)) ? HttpUtility.HtmlAttributeEncode(value) : String.Empty;
        }

        public string AttributeEncode(object value)
        {
            return AttributeEncode(Convert.ToString(value, CultureInfo.InvariantCulture));
        }

        public void EnableClientValidation()
        {
            EnableClientValidation(enabled: true);
        }

        public void EnableClientValidation(bool enabled)
        {
            ViewContext.ClientValidationEnabled = enabled;
        }

        public void EnableUnobtrusiveJavaScript()
        {
            EnableUnobtrusiveJavaScript(enabled: true);
        }

        public void EnableUnobtrusiveJavaScript(bool enabled)
        {
            ViewContext.UnobtrusiveJavaScriptEnabled = enabled;
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public string Encode(string value)
        {
            return (!String.IsNullOrEmpty(value)) ? HttpUtility.HtmlEncode(value) : String.Empty;
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public string Encode(object value)
        {
            return value != null ? HttpUtility.HtmlEncode(value) : String.Empty;
        }

        internal string EvalString(string key)
        {
            return Convert.ToString(ViewData.Eval(key), CultureInfo.CurrentCulture);
        }

        internal string EvalString(string key, string format)
        {
            return Convert.ToString(ViewData.Eval(key, format), CultureInfo.CurrentCulture);
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public string FormatValue(object value, string format)
        {
            return ViewDataDictionary.FormatValueInternal(value, format);
        }

        internal bool EvalBoolean(string key)
        {
            return Convert.ToBoolean(ViewData.Eval(key), CultureInfo.InvariantCulture);
        }

        internal static IView FindPartialView(ViewContext viewContext, string partialViewName, ViewEngineCollection viewEngineCollection)
        {
            ViewEngineResult result = viewEngineCollection.FindPartialView(viewContext, partialViewName);
            if (result.View != null)
            {
                return result.View;
            }

            StringBuilder locationsText = new StringBuilder();
            foreach (string location in result.SearchedLocations)
            {
                locationsText.AppendLine();
                locationsText.Append(location);
            }

            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                              MvcResources.Common_PartialViewNotFound, partialViewName, locationsText));
        }

        public static string GenerateIdFromName(string name)
        {
            return GenerateIdFromName(name, IdAttributeDotReplacement);
        }

        public static string GenerateIdFromName(string name, string idAttributeDotReplacement)
        {
            if (name == null)
            {
                throw new ArgumentNullException("name");
            }

            if (idAttributeDotReplacement == null)
            {
                throw new ArgumentNullException("idAttributeDotReplacement");
            }

            // TagBuilder.CreateSanitizedId returns null for empty strings, return String.Empty instead to avoid breaking change
            if (name.Length == 0)
            {
                return String.Empty;
            }

            return TagBuilder.CreateSanitizedId(name, idAttributeDotReplacement);
        }

        public static string GenerateLink(RequestContext requestContext, RouteCollection routeCollection, string linkText, string routeName, string actionName, string controllerName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            return GenerateLink(requestContext, routeCollection, linkText, routeName, actionName, controllerName, null /* protocol */, null /* hostName */, null /* fragment */, routeValues, htmlAttributes);
        }

        public static string GenerateLink(RequestContext requestContext, RouteCollection routeCollection, string linkText, string routeName, string actionName, string controllerName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            return GenerateLinkInternal(requestContext, routeCollection, linkText, routeName, actionName, controllerName, protocol, hostName, fragment, routeValues, htmlAttributes, true /* includeImplicitMvcValues */);
        }

        private static string GenerateLinkInternal(RequestContext requestContext, RouteCollection routeCollection, string linkText, string routeName, string actionName, string controllerName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes, bool includeImplicitMvcValues)
        {
            string url = UrlHelper.GenerateUrl(routeName, actionName, controllerName, protocol, hostName, fragment, routeValues, routeCollection, requestContext, includeImplicitMvcValues);
            TagBuilder tagBuilder = new TagBuilder("a")
            {
                InnerHtml = (!String.IsNullOrEmpty(linkText)) ? HttpUtility.HtmlEncode(linkText) : String.Empty
            };
            tagBuilder.MergeAttributes(htmlAttributes);
            tagBuilder.MergeAttribute("href", url);
            return tagBuilder.ToString(TagRenderMode.Normal);
        }

        public static string GenerateRouteLink(RequestContext requestContext, RouteCollection routeCollection, string linkText, string routeName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            return GenerateRouteLink(requestContext, routeCollection, linkText, routeName, null /* protocol */, null /* hostName */, null /* fragment */, routeValues, htmlAttributes);
        }

        public static string GenerateRouteLink(RequestContext requestContext, RouteCollection routeCollection, string linkText, string routeName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
        {
            return GenerateLinkInternal(requestContext, routeCollection, linkText, routeName, null /* actionName */, null /* controllerName */, protocol, hostName, fragment, routeValues, htmlAttributes, false /* includeImplicitMvcValues */);
        }

        public static string GetFormMethodString(FormMethod method)
        {
            switch (method)
            {
                case FormMethod.Get:
                    return "get";
                case FormMethod.Post:
                    return "post";
                default:
                    return "post";
            }
        }

        public static string GetInputTypeString(InputType inputType)
        {
            switch (inputType)
            {
                case InputType.CheckBox:
                    return "checkbox";
                case InputType.Hidden:
                    return "hidden";
                case InputType.Password:
                    return "password";
                case InputType.Radio:
                    return "radio";
                case InputType.Text:
                    return "text";
                default:
                    return "text";
            }
        }

        internal object GetModelStateValue(string key, Type destinationType)
        {
            ModelState modelState;
            if (ViewData.ModelState.TryGetValue(key, out modelState))
            {
                if (modelState.Value != null)
                {
                    return modelState.Value.ConvertTo(destinationType, null /* culture */);
                }
            }
            return null;
        }

        public IDictionary<string, object> GetUnobtrusiveValidationAttributes(string name)
        {
            return GetUnobtrusiveValidationAttributes(name, metadata: null);
        }

        // Only render attributes if unobtrusive client-side validation is enabled, and then only if we've
        // never rendered validation for a field with this name in this form. Also, if there's no form context,
        // then we can't render the attributes (we'd have no <form> to attach them to).
        public IDictionary<string, object> GetUnobtrusiveValidationAttributes(string name, ModelMetadata metadata)
        {
            Dictionary<string, object> results = new Dictionary<string, object>();

            // The ordering of these 3 checks (and the early exits) is for performance reasons.
            if (!ViewContext.UnobtrusiveJavaScriptEnabled)
            {
                return results;
            }

            FormContext formContext = ViewContext.GetFormContextForClientValidation();
            if (formContext == null)
            {
                return results;
            }

            string fullName = ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            if (formContext.RenderedField(fullName))
            {
                return results;
            }

            formContext.RenderedField(fullName, true);

            IEnumerable<ModelClientValidationRule> clientRules = ClientValidationRuleFactory(name, metadata);
            UnobtrusiveValidationAttributesGenerator.GetValidationAttributes(clientRules, results);

            return results;
        }

        public MvcHtmlString HttpMethodOverride(HttpVerbs httpVerb)
        {
            string httpMethod;
            switch (httpVerb)
            {
                case HttpVerbs.Delete:
                    httpMethod = "DELETE";
                    break;
                case HttpVerbs.Head:
                    httpMethod = "HEAD";
                    break;
                case HttpVerbs.Put:
                    httpMethod = "PUT";
                    break;
                case HttpVerbs.Patch:
                    httpMethod = "PATCH";
                    break;
                case HttpVerbs.Options:
                    httpMethod = "OPTIONS";
                    break;
                default:
                    throw new ArgumentException(MvcResources.HtmlHelper_InvalidHttpVerb, "httpVerb");
            }

            return HttpMethodOverride(httpMethod);
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public MvcHtmlString HttpMethodOverride(string httpMethod)
        {
            if (String.IsNullOrEmpty(httpMethod))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "httpMethod");
            }
            if (String.Equals(httpMethod, "GET", StringComparison.OrdinalIgnoreCase) ||
                String.Equals(httpMethod, "POST", StringComparison.OrdinalIgnoreCase))
            {
                throw new ArgumentException(MvcResources.HtmlHelper_InvalidHttpMethod, "httpMethod");
            }

            TagBuilder tagBuilder = new TagBuilder("input");
            tagBuilder.Attributes["type"] = "hidden";
            tagBuilder.Attributes["name"] = HttpRequestExtensions.XHttpMethodOverrideKey;
            tagBuilder.Attributes["value"] = httpMethod;

            return tagBuilder.ToMvcHtmlString(TagRenderMode.SelfClosing);
        }

        /// <summary>
        /// Wraps HTML markup in an IHtmlString, which will enable HTML markup to be
        /// rendered to the output without getting HTML encoded.
        /// </summary>
        /// <param name="value">HTML markup string.</param>
        /// <returns>An IHtmlString that represents HTML markup.</returns>
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public IHtmlString Raw(string value)
        {
            return new HtmlString(value);
        }

        /// <summary>
        /// Wraps HTML markup from the string representation of an object in an IHtmlString,
        /// which will enable HTML markup to be rendered to the output without getting HTML encoded.
        /// </summary>
        /// <param name="value">object with string representation as HTML markup</param>
        /// <returns>An IHtmlString that represents HTML markup.</returns>
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public IHtmlString Raw(object value)
        {
            return new HtmlString(value == null ? null : value.ToString());
        }

        internal virtual void RenderPartialInternal(string partialViewName, ViewDataDictionary viewData, object model, TextWriter writer, ViewEngineCollection viewEngineCollection)
        {
            if (String.IsNullOrEmpty(partialViewName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "partialViewName");
            }

            ViewDataDictionary newViewData = null;

            if (model == null)
            {
                if (viewData == null)
                {
                    newViewData = new ViewDataDictionary(ViewData);
                }
                else
                {
                    newViewData = new ViewDataDictionary(viewData);
                }
            }
            else
            {
                if (viewData == null)
                {
                    newViewData = new ViewDataDictionary(model);
                }
                else
                {
                    newViewData = new ViewDataDictionary(viewData) { Model = model };
                }
            }

            ViewContext newViewContext = new ViewContext(ViewContext, ViewContext.View, newViewData, ViewContext.TempData, writer);
            IView view = FindPartialView(newViewContext, partialViewName, viewEngineCollection);
            view.Render(newViewContext, writer);
        }

        /// <summary>
        /// Set element name used to wrap a top-level message in
        /// <see cref="ValidationExtensions.ValidationSummary(HtmlHelper)"/> and other overloads.
        /// </summary>
        public void SetValidationSummaryMessageElement(string elementName)
        {
            if (String.IsNullOrEmpty(elementName))
            {
                throw Error.ParameterCannotBeNullOrEmpty("elementName");
            }

            ViewContext.ValidationSummaryMessageElement = elementName;
        }

        /// <summary>
        /// Set element name used to wrap the validation message generated by
        /// <see cref="ValidationExtensions.ValidationMessage(HtmlHelper, String)"/> and other overloads.
        /// </summary>
        public void SetValidationMessageElement(string elementName)
        {
            if (String.IsNullOrEmpty(elementName))
            {
                throw Error.ParameterCannotBeNullOrEmpty("elementName");
            }

            ViewContext.ValidationMessageElement = elementName;
        }

        /// <summary>
        /// Creates a dictionary from an object, by adding each public instance property as a key with its associated 
        /// value to the dictionary. It will expose public properties from derived types as well. This is typically used
        /// with objects of an anonymous type.
        /// </summary>
        /// <example>
        /// <c>new { property_name = "value" }</c> will translate to the entry <c>{ "property_name" , "value" }</c>
        /// in the resulting dictionary.
        /// </example>
        /// <param name="value">The object to be converted.</param>
        /// <returns>The created dictionary of property names and property values.</returns>
        public static IDictionary<string, object> ObjectToDictionary(object value)
        {
            return TypeHelper.ObjectToDictionary(value);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HtmlHelperOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;

namespace System.Web.Mvc
{
    public class HtmlHelper<TModel> : HtmlHelper
    {
        private DynamicViewDataDictionary _dynamicViewDataDictionary;
        private ViewDataDictionary<TModel> _viewData;

        public HtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer)
            : this(viewContext, viewDataContainer, RouteTable.Routes)
        {
        }

        public HtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer, RouteCollection routeCollection)
            : base(viewContext, viewDataContainer, routeCollection)
        {
            _viewData = new ViewDataDictionary<TModel>(viewDataContainer.ViewData);
        }

        public new dynamic ViewBag
        {
            get
            {
                if (_dynamicViewDataDictionary == null)
                {
                    _dynamicViewDataDictionary = new DynamicViewDataDictionary(() => ViewData);
                }

                return _dynamicViewDataDictionary;
            }
        }

        public new ViewDataDictionary<TModel> ViewData
        {
            get { return _viewData; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpDeleteAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpDeleteAttribute : ActionMethodSelectorAttribute
    {
        private static readonly AcceptVerbsAttribute _innerAttribute = new AcceptVerbsAttribute(HttpVerbs.Delete);

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return _innerAttribute.IsValidForRequest(controllerContext, methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpFileCollectionValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;

namespace System.Web.Mvc
{
    public sealed class HttpFileCollectionValueProvider : DictionaryValueProvider<HttpPostedFileBase[]>
    {
        private static readonly Dictionary<string, HttpPostedFileBase[]> _emptyDictionary = new Dictionary<string, HttpPostedFileBase[]>();

        public HttpFileCollectionValueProvider(ControllerContext controllerContext)
            : base(GetHttpPostedFileDictionary(controllerContext), CultureInfo.InvariantCulture)
        {
        }

        private static Dictionary<string, HttpPostedFileBase[]> GetHttpPostedFileDictionary(ControllerContext controllerContext)
        {
            HttpFileCollectionBase files = controllerContext.HttpContext.Request.Files;

            // fast-track common case of no files
            if (files.Count == 0)
            {
                return _emptyDictionary;
            }

            // build up the 1:many file mapping
            List<KeyValuePair<string, HttpPostedFileBase>> mapping = new List<KeyValuePair<string, HttpPostedFileBase>>();
            string[] allKeys = files.AllKeys;
            for (int i = 0; i < files.Count; i++)
            {
                string key = allKeys[i];
                if (key != null)
                {
                    HttpPostedFileBase file = HttpPostedFileBaseModelBinder.ChooseFileOrNull(files[i]);
                    mapping.Add(new KeyValuePair<string, HttpPostedFileBase>(key, file));
                }
            }

            // turn the mapping into a 1:many dictionary
            var grouped = mapping.GroupBy(el => el.Key, el => el.Value, StringComparer.OrdinalIgnoreCase);
            return grouped.ToDictionary(g => g.Key, g => g.ToArray(), StringComparer.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpFileCollectionValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public sealed class HttpFileCollectionValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            return new HttpFileCollectionValueProvider(controllerContext);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpGetAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpGetAttribute : ActionMethodSelectorAttribute
    {
        private static readonly AcceptVerbsAttribute _innerAttribute = new AcceptVerbsAttribute(HttpVerbs.Get);

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return _innerAttribute.IsValidForRequest(controllerContext, methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpHandlerUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc.Properties;
using System.Web.UI;

namespace System.Web.Mvc
{
    internal static class HttpHandlerUtil
    {
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The Dispose on Page doesn't do anything by default, and we control both of these internal types.")]
        public static IHttpHandler WrapForServerExecute(IHttpHandler httpHandler)
        {
            // Since Server.Execute() doesn't propagate HttpExceptions where the status code is
            // anything other than 500, we need to wrap these exceptions ourselves.
            IHttpAsyncHandler asyncHandler = httpHandler as IHttpAsyncHandler;
            return (asyncHandler != null) ? new ServerExecuteHttpHandlerAsyncWrapper(asyncHandler) : new ServerExecuteHttpHandlerWrapper(httpHandler);
        }

        private sealed class ServerExecuteHttpHandlerAsyncWrapper : ServerExecuteHttpHandlerWrapper, IHttpAsyncHandler
        {
            private readonly IHttpAsyncHandler _httpHandler;

            public ServerExecuteHttpHandlerAsyncWrapper(IHttpAsyncHandler httpHandler)
                : base(httpHandler)
            {
                _httpHandler = httpHandler;
            }

            public IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
            {
                return Wrap(() => _httpHandler.BeginProcessRequest(context, cb, extraData));
            }

            public void EndProcessRequest(IAsyncResult result)
            {
                Wrap(() => _httpHandler.EndProcessRequest(result));
            }
        }

        /// <remarks>
        /// Server.Execute() requires that the provided IHttpHandler subclass Page.
        /// </remarks>
        internal class ServerExecuteHttpHandlerWrapper : Page
        {
            private readonly IHttpHandler _httpHandler;

            public ServerExecuteHttpHandlerWrapper(IHttpHandler httpHandler)
            {
                _httpHandler = httpHandler;
            }

            internal IHttpHandler InnerHandler
            {
                get { return _httpHandler; }
            }

            public override void ProcessRequest(HttpContext context)
            {
                Wrap(() => _httpHandler.ProcessRequest(context));
            }

            protected static void Wrap(Action action)
            {
                Wrap(delegate
                {
                    action();
                    return (object)null;
                });
            }

            protected static TResult Wrap<TResult>(Func<TResult> func)
            {
                try
                {
                    return func();
                }
                catch (HttpException he)
                {
                    if (he.GetHttpCode() == 500)
                    {
                        throw; // doesn't need to be wrapped
                    }
                    else
                    {
                        HttpException newHe = new HttpException(500, MvcResources.ViewPageHttpHandlerWrapper_ExceptionOccurred, he);
                        throw newHe;
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpHeadAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpHeadAttribute : ActionMethodSelectorAttribute
    {
        private static readonly AcceptVerbsAttribute _innerAttribute = new AcceptVerbsAttribute(HttpVerbs.Head);

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return _innerAttribute.IsValidForRequest(controllerContext, methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpNotFoundResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;

namespace System.Web.Mvc
{
    public class HttpNotFoundResult : HttpStatusCodeResult
    {
        public HttpNotFoundResult()
            : this(null)
        {
        }

        // NotFound is equivalent to HTTP status 404.
        public HttpNotFoundResult(string statusDescription)
            : base(HttpStatusCode.NotFound, statusDescription)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpOptionsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpOptionsAttribute : ActionMethodSelectorAttribute
    {
        private static readonly AcceptVerbsAttribute _innerAttribute = new AcceptVerbsAttribute(HttpVerbs.Options);

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return _innerAttribute.IsValidForRequest(controllerContext, methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpPatchAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpPatchAttribute : ActionMethodSelectorAttribute
    {
        private static readonly AcceptVerbsAttribute _innerAttribute = new AcceptVerbsAttribute(HttpVerbs.Patch);

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return _innerAttribute.IsValidForRequest(controllerContext, methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpPostAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpPostAttribute : ActionMethodSelectorAttribute
    {
        private static readonly AcceptVerbsAttribute _innerAttribute = new AcceptVerbsAttribute(HttpVerbs.Post);

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return _innerAttribute.IsValidForRequest(controllerContext, methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpPostedFileBaseModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class HttpPostedFileBaseModelBinder : IModelBinder
    {
        public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (bindingContext == null)
            {
                throw new ArgumentNullException("bindingContext");
            }

            HttpPostedFileBase theFile = controllerContext.HttpContext.Request.Files[bindingContext.ModelName];
            return ChooseFileOrNull(theFile);
        }

        // helper that returns the original file if there was content uploaded, null if empty
        internal static HttpPostedFileBase ChooseFileOrNull(HttpPostedFileBase rawFile)
        {
            // case 1: there was no <input type="file" ... /> element in the post
            if (rawFile == null)
            {
                return null;
            }

            // case 2: there was an <input type="file" ... /> element in the post, but it was left blank
            if (rawFile.ContentLength == 0 && String.IsNullOrEmpty(rawFile.FileName))
            {
                return null;
            }

            // case 3: the file was posted
            return rawFile;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpPutAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class HttpPutAttribute : ActionMethodSelectorAttribute
    {
        private static readonly AcceptVerbsAttribute _innerAttribute = new AcceptVerbsAttribute(HttpVerbs.Put);

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return _innerAttribute.IsValidForRequest(controllerContext, methodInfo);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpRequestExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class HttpRequestExtensions
    {
        internal const string XHttpMethodOverrideKey = "X-HTTP-Method-Override";

        public static string GetHttpMethodOverride(this HttpRequestBase request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            string incomingVerb = request.HttpMethod;

            if (!String.Equals(incomingVerb, "POST", StringComparison.OrdinalIgnoreCase))
            {
                return incomingVerb;
            }

            string verbOverride = null;
            string headerOverrideValue = request.Headers[XHttpMethodOverrideKey];
            if (!String.IsNullOrEmpty(headerOverrideValue))
            {
                verbOverride = headerOverrideValue;
            }
            else
            {
                string formOverrideValue = request.Form[XHttpMethodOverrideKey];
                if (!String.IsNullOrEmpty(formOverrideValue))
                {
                    verbOverride = formOverrideValue;
                }
                else
                {
                    string queryStringOverrideValue = request.QueryString[XHttpMethodOverrideKey];
                    if (!String.IsNullOrEmpty(queryStringOverrideValue))
                    {
                        verbOverride = queryStringOverrideValue;
                    }
                }
            }
            if (verbOverride != null)
            {
                if (!String.Equals(verbOverride, "GET", StringComparison.OrdinalIgnoreCase) &&
                    !String.Equals(verbOverride, "POST", StringComparison.OrdinalIgnoreCase))
                {
                    incomingVerb = verbOverride;
                }
            }
            return incomingVerb;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpStatusCodeResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;

namespace System.Web.Mvc
{
    public class HttpStatusCodeResult : ActionResult
    {
        public HttpStatusCodeResult(int statusCode)
            : this(statusCode, null)
        {
        }

        public HttpStatusCodeResult(HttpStatusCode statusCode)
            : this(statusCode, null)
        {
        }

        public HttpStatusCodeResult(HttpStatusCode statusCode, string statusDescription)
            : this((int)statusCode, statusDescription)
        {
        }

        public HttpStatusCodeResult(int statusCode, string statusDescription)
        {
            StatusCode = statusCode;
            StatusDescription = statusDescription;
        }

        public int StatusCode { get; private set; }

        public string StatusDescription { get; private set; }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            context.HttpContext.Response.StatusCode = StatusCode;
            if (StatusDescription != null)
            {
                context.HttpContext.Response.StatusDescription = StatusDescription;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpUnauthorizedResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;

namespace System.Web.Mvc
{
    public class HttpUnauthorizedResult : HttpStatusCodeResult
    {
        public HttpUnauthorizedResult()
            : this(null)
        {
        }

        // Unauthorized is equivalent to HTTP status 401, the status code for unauthorized
        // access. Other code might intercept this and perform some special logic. For
        // example, the FormsAuthenticationModule looks for 401 responses and instead
        // redirects the user to the login page.
        public HttpUnauthorizedResult(string statusDescription)
            : base(HttpStatusCode.Unauthorized, statusDescription)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/HttpVerbs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    [Flags]
    public enum HttpVerbs
    {
        Get = 1 << 0,
        Post = 1 << 1,
        Put = 1 << 2,
        Delete = 1 << 3,
        Head = 1 << 4,
        Patch = 1 << 5,
        Options = 1 << 6,
    }
}


================================================
FILE: src/System.Web.Mvc/IActionFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IActionFilter
    {
        void OnActionExecuting(ActionExecutingContext filterContext);
        void OnActionExecuted(ActionExecutedContext filterContext);
    }
}


================================================
FILE: src/System.Web.Mvc/IActionInvoker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IActionInvoker
    {
        bool InvokeAction(ControllerContext controllerContext, string actionName);
    }
}


================================================
FILE: src/System.Web.Mvc/IActionInvokerFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Used to create an <see cref="IActionInvoker"/> instance for the current request.
    /// </summary>
    public interface IActionInvokerFactory
    {
        /// <summary>
        /// Creates an instance of action invoker for the current request.
        /// </summary>
        /// <returns>The created <see cref="IActionInvoker"/>.</returns>
        IActionInvoker CreateInstance();
    }
}


================================================
FILE: src/System.Web.Mvc/IAuthorizationFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IAuthorizationFilter
    {
        void OnAuthorization(AuthorizationContext filterContext);
    }
}


================================================
FILE: src/System.Web.Mvc/IBuildManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.IO;

namespace System.Web.Mvc
{
    internal interface IBuildManager
    {
        bool FileExists(string virtualPath);
        Type GetCompiledType(string virtualPath);
        ICollection GetReferencedAssemblies();
        Stream ReadCachedFile(string fileName);
        Stream CreateCachedFile(string fileName);
    }
}


================================================
FILE: src/System.Web.Mvc/IClientValidatable.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    // The purpose of this interface is to make something as supporting client-side
    // validation, which could be discovered at runtime by whatever validation
    // framework you're using. Because this interface is designed to be independent
    // of underlying implementation details, where you apply this interface will
    // depend on your specific validation framework.
    //
    // For DataAnnotations, you'll apply this interface to your validation attribute
    // (the class which derives from ValidationAttribute). When you've implemented
    // this interface, it will alleviate the need of writing a validator and registering
    // it with the DataAnnotationsModelValidatorProvider.
    public interface IClientValidatable
    {
        IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context);
    }
}


================================================
FILE: src/System.Web.Mvc/IController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;

namespace System.Web.Mvc
{
    public interface IController
    {
        void Execute(RequestContext requestContext);
    }
}


================================================
FILE: src/System.Web.Mvc/IControllerActivator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;

namespace System.Web.Mvc
{
    public interface IControllerActivator
    {
        IController Create(RequestContext requestContext, Type controllerType);
    }
}


================================================
FILE: src/System.Web.Mvc/IControllerFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using System.Web.SessionState;

namespace System.Web.Mvc
{
    public interface IControllerFactory
    {
        IController CreateController(RequestContext requestContext, string controllerName);
        SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName);
        void ReleaseController(IController controller);
    }
}


================================================
FILE: src/System.Web.Mvc/IDependencyResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public interface IDependencyResolver
    {
        object GetService(Type serviceType);
        IEnumerable<object> GetServices(Type serviceType);
    }
}


================================================
FILE: src/System.Web.Mvc/IEnumerableValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    // Represents a special IValueProvider that has the ability to be enumerable.
    public interface IEnumerableValueProvider : IValueProvider
    {
        IDictionary<string, string> GetKeysFromPrefix(string prefix);
    }
}


================================================
FILE: src/System.Web.Mvc/IExceptionFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IExceptionFilter
    {
        void OnException(ExceptionContext filterContext);
    }
}


================================================
FILE: src/System.Web.Mvc/IFilterProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public interface IFilterProvider
    {
        IEnumerable<Filter> GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor);
    }
}


================================================
FILE: src/System.Web.Mvc/IMetadataAware.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    // This interface is implemented by attributes which wish to contribute to the
    // ModelMetadata creation process without needing to write a custom metadata
    // provider. It is consumed by AssociatedMetadataProvider, so this behavior is
    // automatically inherited by all classes which derive from it (notably, the
    // DataAnnotationsModelMetadataProvider).
    public interface IMetadataAware
    {
        void OnMetadataCreated(ModelMetadata metadata);
    }
}


================================================
FILE: src/System.Web.Mvc/IMethodInfoActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    /// <summary>
    /// An optional interface for <see cref="ActionDescriptor" /> types which provide a <see cref="MethodInfo" />.
    /// </summary>
    public interface IMethodInfoActionDescriptor
    {
        /// <summary>
        /// Gets the MethodInfo
        /// </summary>
        MethodInfo MethodInfo
        {
            get;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/IModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IModelBinder
    {
        object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext);
    }
}


================================================
FILE: src/System.Web.Mvc/IModelBinderProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IModelBinderProvider
    {
        IModelBinder GetBinder(Type modelType);
    }
}


================================================
FILE: src/System.Web.Mvc/IMvcControlBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal interface IMvcControlBuilder
    {
        string Inherits { set; }
    }
}


================================================
FILE: src/System.Web.Mvc/IMvcFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IMvcFilter
    {
        bool AllowMultiple { get; }
        int Order { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/IResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal interface IResolver<T>
    {
        T Current { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/IResultFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IResultFilter
    {
        void OnResultExecuting(ResultExecutingContext filterContext);
        void OnResultExecuted(ResultExecutedContext filterContext);
    }
}


================================================
FILE: src/System.Web.Mvc/IRouteWithArea.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IRouteWithArea
    {
        string Area { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/ITempDataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public interface ITempDataProvider
    {
        IDictionary<string, object> LoadTempData(ControllerContext controllerContext);
        void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values);
    }
}


================================================
FILE: src/System.Web.Mvc/ITempDataProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Used to create an <see cref="ITempDataProvider"/> instance for the controller.
    /// </summary>
    public interface ITempDataProviderFactory
    {
        /// <summary>
        /// Creates an instance of <see cref="ITempDataProvider"/> for the controller.
        /// </summary>
        /// <returns>The created <see cref="ITempDataProvider"/>.</returns>
        ITempDataProvider CreateInstance();
    }
}


================================================
FILE: src/System.Web.Mvc/IUniquelyIdentifiable.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal interface IUniquelyIdentifiable
    {
        string UniqueId { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/IUnvalidatedRequestValues.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;

namespace System.Web.Mvc
{
    // Used for mocking the UnvalidatedRequestValues type in System.Web.WebPages

    internal interface IUnvalidatedRequestValues
    {
        NameValueCollection Form { get; }
        NameValueCollection QueryString { get; }
        string this[string key] { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/IUnvalidatedValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    // Represents a special IValueProvider that has the ability to skip request validation.
    public interface IUnvalidatedValueProvider : IValueProvider
    {
        ValueProviderResult GetValue(string key, bool skipValidation);
    }
}


================================================
FILE: src/System.Web.Mvc/IValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Defines the methods that are required for a value provider in ASP.NET MVC.
    /// </summary>
    public interface IValueProvider
    {
        /// <summary>
        /// Determines whether the collection contains the specified prefix.
        /// </summary>
        /// <param name="prefix">The prefix to search for.</param>
        /// <returns>true if the collection contains the specified prefix; otherwise, false.</returns>
        bool ContainsPrefix(string prefix);

        /// <summary>
        /// Retrieves a value object using the specified key.
        /// </summary>
        /// <param name="key">The key of the value object to retrieve.</param>
        /// <returns>The value object for the specified key. If the exact key is not found, null.</returns>
        ValueProviderResult GetValue(string key);
    }
}


================================================
FILE: src/System.Web.Mvc/IView.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.Mvc
{
    public interface IView
    {
        void Render(ViewContext viewContext, TextWriter writer);
    }
}


================================================
FILE: src/System.Web.Mvc/IViewDataContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public interface IViewDataContainer
    {
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is the mechanism by which the ViewPage / ViewUserControl get their ViewDataDictionary objects.")]
        ViewDataDictionary ViewData { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/IViewEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IViewEngine
    {
        ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache);
        ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache);
        void ReleaseView(ControllerContext controllerContext, IView view);
    }
}


================================================
FILE: src/System.Web.Mvc/IViewLocationCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IViewLocationCache
    {
        string GetViewLocation(HttpContextBase httpContext, string key);
        void InsertViewLocation(HttpContextBase httpContext, string key, string virtualPath);
    }
}


================================================
FILE: src/System.Web.Mvc/IViewPageActivator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public interface IViewPageActivator
    {
        object Create(ControllerContext controllerContext, Type type);
    }
}


================================================
FILE: src/System.Web.Mvc/IViewStartPageChild.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal interface IViewStartPageChild
    {
        HtmlHelper<object> Html { get; }
        UrlHelper Url { get; }
        ViewContext ViewContext { get; }
    }
}


================================================
FILE: src/System.Web.Mvc/InputType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public enum InputType
    {
        CheckBox,
        Hidden,
        Password,
        Radio,
        Text
    }
}


================================================
FILE: src/System.Web.Mvc/JQueryFormValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;

namespace System.Web.Mvc
{
    /// <summary>
    /// The JQuery Form Value provider is used to handle JQuery formatted data in
    /// request Forms.
    /// </summary>
    public class JQueryFormValueProvider : NameValueCollectionValueProvider
    {
        /// <summary>
        /// Constructs a new instance of the JQuery form ValueProvider
        /// </summary>
        /// <param name="controllerContext">The context on which the ValueProvider operates.</param>
        public JQueryFormValueProvider(
                    ControllerContext controllerContext)
                : this(controllerContext,
                        new UnvalidatedRequestValuesWrapper(
                                controllerContext.HttpContext.Request.Unvalidated))
        {
        }

        // For unit testing
        internal JQueryFormValueProvider(
                        ControllerContext controllerContext,
                        IUnvalidatedRequestValues unvalidatedValues)
            : base(controllerContext.HttpContext.Request.Form, 
                        unvalidatedValues.Form,
                        CultureInfo.CurrentCulture,
                        jQueryToMvcRequestNormalizationRequired: true)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/JQueryFormValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Provides the necessary ValueProvider to handle JQuery Form data.
    /// </summary>
    public sealed class JQueryFormValueProviderFactory : ValueProviderFactory
    {
        private readonly UnvalidatedRequestValuesAccessor _unvalidatedValuesAccessor;

        /// <summary>
        /// Constructs a new instance of the factory which provides JQuery form ValueProviders.
        /// </summary>
        public JQueryFormValueProviderFactory()
            : this(unvalidatedValuesAccessor: null)
        {
        }

        // For unit testing
        internal JQueryFormValueProviderFactory(UnvalidatedRequestValuesAccessor unvalidatedValuesAccessor)
        {
            _unvalidatedValuesAccessor = unvalidatedValuesAccessor ??
                                       (cc => new UnvalidatedRequestValuesWrapper(cc.HttpContext.Request.Unvalidated));
        }

        /// <summary>
        /// Returns the suitable ValueProvider.
        /// </summary>
        /// <param name="controllerContext">The context on which the ValueProvider should operate.</param>
        /// <returns></returns>
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            return new JQueryFormValueProvider(controllerContext, _unvalidatedValuesAccessor(controllerContext));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/JavaScript/jquery.unobtrusive-ajax.js
================================================
/*!
** Unobtrusive Ajax support library for jQuery
** Copyright (C) Microsoft Corporation. All rights reserved.
*/

/*jslint white: true, browser: true, onevar: true, undef: true, nomen: true, eqeqeq: true, plusplus: true, bitwise: true, regexp: true, newcap: true, immed: true, strict: false */
/*global window: false, jQuery: false */

(function ($) {
    var data_click = "unobtrusiveAjaxClick",
        data_target = "unobtrusiveAjaxClickTarget",
        data_validation = "unobtrusiveValidation";

    function getFunction(code, argNames) {
        var fn = window, parts = (code || "").split(".");
        while (fn && parts.length) {
            fn = fn[parts.shift()];
        }
        if (typeof (fn) === "function") {
            return fn;
        }
        argNames.push(code);
        return Function.constructor.apply(null, argNames);
    }

    function isMethodProxySafe(method) {
        return method === "GET" || method === "POST";
    }

    function asyncOnBeforeSend(xhr, method) {
        if (!isMethodProxySafe(method)) {
            xhr.setRequestHeader("X-HTTP-Method-Override", method);
        }
    }

    function asyncOnSuccess(element, data, contentType) {
        var mode;

        if (contentType.indexOf("application/x-javascript") !== -1) {  // jQuery already executes JavaScript for us
            return;
        }

        mode = (element.getAttribute("data-ajax-mode") || "").toUpperCase();
        $(element.getAttribute("data-ajax-update")).each(function (i, update) {
            switch (mode) {
            case "BEFORE":
                $(update).prepend(data);
                break;
            case "AFTER":
                $(update).append(data);
                break;
            case "REPLACE-WITH":
                $(update).replaceWith(data);
                break;
            default:
                $(update).html(data);
                break;
            }
        });
    }

    function asyncRequest(element, options) {
        var confirm, loading, method, duration;

        confirm = element.getAttribute("data-ajax-confirm");
        if (confirm && !window.confirm(confirm)) {
            return;
        }

        loading = $(element.getAttribute("data-ajax-loading"));
        duration = parseInt(element.getAttribute("data-ajax-loading-duration"), 10) || 0;

        $.extend(options, {
            type: element.getAttribute("data-ajax-method") || undefined,
            url: element.getAttribute("data-ajax-url") || undefined,
            cache: !!element.getAttribute("data-ajax-cache"),
            beforeSend: function (xhr) {
                var result;
                asyncOnBeforeSend(xhr, method);
                result = getFunction(element.getAttribute("data-ajax-begin"), ["xhr"]).apply(element, arguments);
                if (result !== false) {
                    loading.show(duration);
                }
                return result;
            },
            complete: function () {
                loading.hide(duration);
                getFunction(element.getAttribute("data-ajax-complete"), ["xhr", "status"]).apply(element, arguments);
            },
            success: function (data, status, xhr) {
                asyncOnSuccess(element, data, xhr.getResponseHeader("Content-Type") || "text/html");
                getFunction(element.getAttribute("data-ajax-success"), ["data", "status", "xhr"]).apply(element, arguments);
            },
            error: function () {
                getFunction(element.getAttribute("data-ajax-failure"), ["xhr", "status", "error"]).apply(element, arguments);
            }
        });

        options.data.push({ name: "X-Requested-With", value: "XMLHttpRequest" });

        method = options.type.toUpperCase();
        if (!isMethodProxySafe(method)) {
            options.type = "POST";
            options.data.push({ name: "X-HTTP-Method-Override", value: method });
        }

        $.ajax(options);
    }

    function validate(form) {
        var validationInfo = $(form).data(data_validation);
        return !validationInfo || !validationInfo.validate || validationInfo.validate();
    }

    $(document).on("click", "a[data-ajax=true]", function (evt) {
        evt.preventDefault();
        asyncRequest(this, {
            url: this.href,
            type: "GET",
            data: []
        });
    });

    $(document).on("click", "form[data-ajax=true] input[type=image]", function (evt) {
        var name = evt.target.name,
            target = $(evt.target),
            form = $(target.parents("form")[0]),
            offset = target.offset();

        form.data(data_click, [
            { name: name + ".x", value: Math.round(evt.pageX - offset.left) },
            { name: name + ".y", value: Math.round(evt.pageY - offset.top) }
        ]);

        setTimeout(function () {
            form.removeData(data_click);
        }, 0);
    });

    $(document).on("click", "form[data-ajax=true] :submit", function (evt) {
        var name = evt.currentTarget.name,
            target = $(evt.target),
            form = $(target.parents("form")[0]);

        form.data(data_click, name ? [{ name: name, value: evt.currentTarget.value }] : []);
        form.data(data_target, target);

        setTimeout(function () {
            form.removeData(data_click);
            form.removeData(data_target);
        }, 0);
    });

    $(document).on("submit", "form[data-ajax=true]", function (evt) {
        var clickInfo = $(this).data(data_click) || [],
            clickTarget = $(this).data(data_target),
            isCancel = clickTarget && clickTarget.hasClass("cancel");
        evt.preventDefault();
        if (!isCancel && !validate(this)) {
            return;
        }
        asyncRequest(this, {
            url: this.action,
            type: this.method || "GET",
            data: clickInfo.concat($(this).serializeArray())
        });
    });
}(jQuery));

================================================
FILE: src/System.Web.Mvc/JavaScript/jquery.validate.unobtrusive.js
================================================
/*!
** Unobtrusive validation support library for jQuery and jQuery Validate
** Copyright (C) Microsoft Corporation. All rights reserved.
*/

/*jslint white: true, browser: true, onevar: true, undef: true, nomen: true, eqeqeq: true, plusplus: true, bitwise: true, regexp: true, newcap: true, immed: true, strict: false */
/*global document: false, jQuery: false */

(function ($) {
    var $jQval = $.validator,
        adapters,
        data_validation = "unobtrusiveValidation";

    function setValidationValues(options, ruleName, value) {
        options.rules[ruleName] = value;
        if (options.message) {
            options.messages[ruleName] = options.message;
        }
    }

    function splitAndTrim(value) {
        return value.replace(/^\s+|\s+$/g, "").split(/\s*,\s*/g);
    }

    function escapeAttributeValue(value) {
        // As mentioned on http://api.jquery.com/category/selectors/
        return value.replace(/([!"#$%&'()*+,./:;<=>?@\[\\\]^`{|}~])/g, "\\$1");
    }

    function getModelPrefix(fieldName) {
        return fieldName.substr(0, fieldName.lastIndexOf(".") + 1);
    }

    function appendModelPrefix(value, prefix) {
        if (value.indexOf("*.") === 0) {
            value = value.replace("*.", prefix);
        }
        return value;
    }

    function onError(error, inputElement) {  // 'this' is the form element
        var container = $(this).find("[data-valmsg-for='" + escapeAttributeValue(inputElement[0].name) + "']"),
            replaceAttrValue = container.attr("data-valmsg-replace"),
            replace = replaceAttrValue ? $.parseJSON(replaceAttrValue) !== false : null;

        container.removeClass("field-validation-valid").addClass("field-validation-error");
        error.data("unobtrusiveContainer", container);

        if (replace) {
            container.empty();
            error.removeClass("input-validation-error").appendTo(container);
        }
        else {
            error.hide();
        }
    }

    function onErrors(event, validator) {  // 'this' is the form element
        var container = $(this).find("[data-valmsg-summary=true]"),
            list = container.find("ul");

        if (list && list.length && validator.errorList.length) {
            list.empty();
            container.addClass("validation-summary-errors").removeClass("validation-summary-valid");

            $.each(validator.errorList, function () {
                $("<li />").html(this.message).appendTo(list);
            });
        }
    }

    function onSuccess(error) {  // 'this' is the form element
        var container = error.data("unobtrusiveContainer"),
            replaceAttrValue = container.attr("data-valmsg-replace"),
            replace = replaceAttrValue ? $.parseJSON(replaceAttrValue) : null;

        if (container) {
            container.addClass("field-validation-valid").removeClass("field-validation-error");
            error.removeData("unobtrusiveContainer");

            if (replace) {
                container.empty();
            }
        }
    }

    function onReset(event) {  // 'this' is the form element
        var $form = $(this),
            key = '__jquery_unobtrusive_validation_form_reset';
        if ($form.data(key)) {
            return;
        }
        // Set a flag that indicates we're currently resetting the form.
        $form.data(key, true);
        try {
            $form.data("validator").resetForm();
        } finally {
            $form.removeData(key);
        }

        $form.find(".validation-summary-errors")
            .addClass("validation-summary-valid")
            .removeClass("validation-summary-errors");
        $form.find(".field-validation-error")
            .addClass("field-validation-valid")
            .removeClass("field-validation-error")
            .removeData("unobtrusiveContainer")
            .find(">*")  // If we were using valmsg-replace, get the underlying error
                .removeData("unobtrusiveContainer");
    }

    function validationInfo(form) {
        var $form = $(form),
            result = $form.data(data_validation),
            onResetProxy = $.proxy(onReset, form),
            defaultOptions = $jQval.unobtrusive.options || {},
            execInContext = function (name, args) {
                var func = defaultOptions[name];
                func && $.isFunction(func) && func.apply(form, args);
            }

        if (!result) {
            result = {
                options: {  // options structure passed to jQuery Validate's validate() method
                    errorClass: defaultOptions.errorClass || "input-validation-error",
                    errorElement: defaultOptions.errorElement || "span",
                    errorPlacement: function () {
                        onError.apply(form, arguments);
                        execInContext("errorPlacement", arguments);
                    },
                    invalidHandler: function () {
                        onErrors.apply(form, arguments);
                        execInContext("invalidHandler", arguments);
                    },
                    messages: {},
                    rules: {},
                    success: function () {
                        onSuccess.apply(form, arguments);
                        execInContext("success", arguments);
                    }
                },
                attachValidation: function () {
                    $form
                        .off("reset." + data_validation, onResetProxy)
                        .on("reset." + data_validation, onResetProxy)
                        .validate(this.options);
                },
                validate: function () {  // a validation function that is called by unobtrusive Ajax
                    $form.validate();
                    return $form.valid();
                }
            };
            $form.data(data_validation, result);
        }

        return result;
    }

    $jQval.unobtrusive = {
        adapters: [],

        parseElement: function (element, skipAttach) {
            /// <summary>
            /// Parses a single HTML element for unobtrusive validation attributes.
            /// </summary>
            /// <param name="element" domElement="true">The HTML element to be parsed.</param>
            /// <param name="skipAttach" type="Boolean">[Optional] true to skip attaching the
            /// validation to the form. If parsing just this single element, you should specify true.
            /// If parsing several elements, you should specify false, and manually attach the validation
            /// to the form when you are finished. The default is false.</param>
            var $element = $(element),
                form = $element.parents("form")[0],
                valInfo, rules, messages;

            if (!form) {  // Cannot do client-side validation without a form
                return;
            }

            valInfo = validationInfo(form);
            valInfo.options.rules[element.name] = rules = {};
            valInfo.options.messages[element.name] = messages = {};

            $.each(this.adapters, function () {
                var prefix = "data-val-" + this.name,
                    message = $element.attr(prefix),
                    paramValues = {};

                if (message !== undefined) {  // Compare against undefined, because an empty message is legal (and falsy)
                    prefix += "-";

                    $.each(this.params, function () {
                        paramValues[this] = $element.attr(prefix + this);
                    });

                    this.adapt({
                        element: element,
                        form: form,
                        message: message,
                        params: paramValues,
                        rules: rules,
                        messages: messages
                    });
                }
            });

            $.extend(rules, { "__dummy__": true });

            if (!skipAttach) {
                valInfo.attachValidation();
            }
        },

        parse: function (selector) {
            /// <summary>
            /// Parses all the HTML elements in the specified selector. It looks for input elements decorated
            /// with the [data-val=true] attribute value and enables validation according to the data-val-*
            /// attribute values.
            /// </summary>
            /// <param name="selector" type="String">Any valid jQuery selector.</param>

            // $forms includes all forms in selector's DOM hierarchy (parent, children and self) that have at least one
            // element with data-val=true
            var $selector = $(selector),
                $forms = $selector.parents()
                                  .addBack()
                                  .filter("form")
                                  .add($selector.find("form"))
                                  .has("[data-val=true]");

            $selector.find("[data-val=true]").each(function () {
                $jQval.unobtrusive.parseElement(this, true);
            });

            $forms.each(function () {
                var info = validationInfo(this);
                if (info) {
                    info.attachValidation();
                }
            });
        }
    };

    adapters = $jQval.unobtrusive.adapters;

    adapters.add = function (adapterName, params, fn) {
        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation.</summary>
        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
        /// in the data-val-nnnn HTML attribute (where nnnn is the adapter name).</param>
        /// <param name="params" type="Array" optional="true">[Optional] An array of parameter names (strings) that will
        /// be extracted from the data-val-nnnn-mmmm HTML attributes (where nnnn is the adapter name, and
        /// mmmm is the parameter name).</param>
        /// <param name="fn" type="Function">The function to call, which adapts the values from the HTML
        /// attributes into jQuery Validate rules and/or messages.</param>
        /// <returns type="jQuery.validator.unobtrusive.adapters" />
        if (!fn) {  // Called with no params, just a function
            fn = params;
            params = [];
        }
        this.push({ name: adapterName, params: params, adapt: fn });
        return this;
    };

    adapters.addBool = function (adapterName, ruleName) {
        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation, where
        /// the jQuery Validate validation rule has no parameter values.</summary>
        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
        /// in the data-val-nnnn HTML attribute (where nnnn is the adapter name).</param>
        /// <param name="ruleName" type="String" optional="true">[Optional] The name of the jQuery Validate rule. If not provided, the value
        /// of adapterName will be used instead.</param>
        /// <returns type="jQuery.validator.unobtrusive.adapters" />
        return this.add(adapterName, function (options) {
            setValidationValues(options, ruleName || adapterName, true);
        });
    };

    adapters.addMinMax = function (adapterName, minRuleName, maxRuleName, minMaxRuleName, minAttribute, maxAttribute) {
        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation, where
        /// the jQuery Validate validation has three potential rules (one for min-only, one for max-only, and
        /// one for min-and-max). The HTML parameters are expected to be named -min and -max.</summary>
        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
        /// in the data-val-nnnn HTML attribute (where nnnn is the adapter name).</param>
        /// <param name="minRuleName" type="String">The name of the jQuery Validate rule to be used when you only
        /// have a minimum value.</param>
        /// <param name="maxRuleName" type="String">The name of the jQuery Validate rule to be used when you only
        /// have a maximum value.</param>
        /// <param name="minMaxRuleName" type="String">The name of the jQuery Validate rule to be used when you
        /// have both a minimum and maximum value.</param>
        /// <param name="minAttribute" type="String" optional="true">[Optional] The name of the HTML attribute that
        /// contains the minimum value. The default is "min".</param>
        /// <param name="maxAttribute" type="String" optional="true">[Optional] The name of the HTML attribute that
        /// contains the maximum value. The default is "max".</param>
        /// <returns type="jQuery.validator.unobtrusive.adapters" />
        return this.add(adapterName, [minAttribute || "min", maxAttribute || "max"], function (options) {
            var min = options.params.min,
                max = options.params.max;

            if (min && max) {
                setValidationValues(options, minMaxRuleName, [min, max]);
            }
            else if (min) {
                setValidationValues(options, minRuleName, min);
            }
            else if (max) {
                setValidationValues(options, maxRuleName, max);
            }
        });
    };

    adapters.addSingleVal = function (adapterName, attribute, ruleName) {
        /// <summary>Adds a new adapter to convert unobtrusive HTML into a jQuery Validate validation, where
        /// the jQuery Validate validation rule has a single value.</summary>
        /// <param name="adapterName" type="String">The name of the adapter to be added. This matches the name used
        /// in the data-val-nnnn HTML attribute(where nnnn is the adapter name).</param>
        /// <param name="attribute" type="String">[Optional] The name of the HTML attribute that contains the value.
        /// The default is "val".</param>
        /// <param name="ruleName" type="String" optional="true">[Optional] The name of the jQuery Validate rule. If not provided, the value
        /// of adapterName will be used instead.</param>
        /// <returns type="jQuery.validator.unobtrusive.adapters" />
        return this.add(adapterName, [attribute || "val"], function (options) {
            setValidationValues(options, ruleName || adapterName, options.params[attribute]);
        });
    };

    $jQval.addMethod("__dummy__", function (value, element, params) {
        return true;
    });

    $jQval.addMethod("regex", function (value, element, params) {
        var match;
        if (this.optional(element)) {
            return true;
        }

        match = new RegExp(params).exec(value);
        return (match && (match.index === 0) && (match[0].length === value.length));
    });

    $jQval.addMethod("nonalphamin", function (value, element, nonalphamin) {
        var match;
        if (nonalphamin) {
            match = value.match(/\W/g);
            match = match && match.length >= nonalphamin;
        }
        return match;
    });

    if ($jQval.methods.extension) {
        adapters.addSingleVal("accept", "mimtype");
        adapters.addSingleVal("extension", "extension");
    } else {
        // for backward compatibility, when the 'extension' validation method does not exist, such as with versions
        // of JQuery Validation plugin prior to 1.10, we should use the 'accept' method for
        // validating the extension, and ignore mime-type validations as they are not supported.
        adapters.addSingleVal("extension", "extension", "accept");
    }

    adapters.addSingleVal("regex", "pattern");
    adapters.addBool("creditcard").addBool("date").addBool("digits").addBool("email").addBool("number").addBool("url");
    adapters.addMinMax("length", "minlength", "maxlength", "rangelength").addMinMax("range", "min", "max", "range");
    adapters.addMinMax("minlength", "minlength").addMinMax("maxlength", "minlength", "maxlength");
    adapters.add("equalto", ["other"], function (options) {
        var prefix = getModelPrefix(options.element.name),
            other = options.params.other,
            fullOtherName = appendModelPrefix(other, prefix),
            element = $(options.form).find(":input").filter("[name='" + escapeAttributeValue(fullOtherName) + "']")[0];

        setValidationValues(options, "equalTo", element);
    });
    adapters.add("required", function (options) {
        // jQuery Validate equates "required" with "mandatory" for checkbox elements
        if (options.element.tagName.toUpperCase() !== "INPUT" || options.element.type.toUpperCase() !== "CHECKBOX") {
            setValidationValues(options, "required", true);
        }
    });
    adapters.add("remote", ["url", "type", "additionalfields"], function (options) {
        var value = {
            url: options.params.url,
            type: options.params.type || "GET",
            data: {}
        },
            prefix = getModelPrefix(options.element.name);

        $.each(splitAndTrim(options.params.additionalfields || options.element.name), function (i, fieldName) {
            var paramName = appendModelPrefix(fieldName, prefix);
            value.data[paramName] = function () {
                var field = $(options.form).find(":input").filter("[name='" + escapeAttributeValue(paramName) + "']");
                // For checkboxes and radio buttons, only pick up values from checked fields.
                if (field.is(":checkbox")) {
                    return field.filter(":checked").val() || field.filter(":hidden").val() || '';
                }
                else if (field.is(":radio")) {
                    return field.filter(":checked").val() || '';
                }
                return field.val();
            };
        });

        setValidationValues(options, "remote", value);
    });
    adapters.add("password", ["min", "nonalphamin", "regex"], function (options) {
        if (options.params.min) {
            setValidationValues(options, "minlength", options.params.min);
        }
        if (options.params.nonalphamin) {
            setValidationValues(options, "nonalphamin", options.params.nonalphamin);
        }
        if (options.params.regex) {
            setValidationValues(options, "regex", options.params.regex);
        }
    });

    $(function () {
        $jQval.unobtrusive.parse(document);
    });
}(jQuery));

================================================
FILE: src/System.Web.Mvc/JavaScriptResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class JavaScriptResult : ActionResult
    {
        public string Script { get; set; }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }

            HttpResponseBase response = context.HttpContext.Response;
            response.ContentType = "application/x-javascript";

            if (Script != null)
            {
                response.Write(Script);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/JsonRequestBehavior.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public enum JsonRequestBehavior
    {
        AllowGet,
        DenyGet,
    }
}


================================================
FILE: src/System.Web.Mvc/JsonResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text;
using System.Web.Mvc.Properties;
using System.Web.Script.Serialization;

namespace System.Web.Mvc
{
    public class JsonResult : ActionResult
    {
        public JsonResult()
        {
            JsonRequestBehavior = JsonRequestBehavior.DenyGet;
        }

        public Encoding ContentEncoding { get; set; }

        public string ContentType { get; set; }

        public object Data { get; set; }

        public JsonRequestBehavior JsonRequestBehavior { get; set; }

        /// <summary>
        /// When set MaxJsonLength passed to the JavaScriptSerializer.
        /// </summary>
        public int? MaxJsonLength { get; set; }

        /// <summary>
        /// When set RecursionLimit passed to the JavaScriptSerializer.
        /// </summary>
        public int? RecursionLimit { get; set; }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (JsonRequestBehavior == JsonRequestBehavior.DenyGet &&
                String.Equals(context.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(MvcResources.JsonRequest_GetNotAllowed);
            }

            HttpResponseBase response = context.HttpContext.Response;

            if (!String.IsNullOrEmpty(ContentType))
            {
                response.ContentType = ContentType;
            }
            else
            {
                response.ContentType = "application/json";
            }
            if (ContentEncoding != null)
            {
                response.ContentEncoding = ContentEncoding;
            }
            if (Data != null)
            {
                JavaScriptSerializer serializer = new JavaScriptSerializer();
                if (MaxJsonLength.HasValue)
                {
                    serializer.MaxJsonLength = MaxJsonLength.Value;
                }
                if (RecursionLimit.HasValue)
                {
                    serializer.RecursionLimit = RecursionLimit.Value;
                }
                response.Write(serializer.Serialize(Data));
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/JsonValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Configuration;
using System.Globalization;
using System.IO;
using System.Web.Mvc.Properties;
using System.Web.Script.Serialization;

namespace System.Web.Mvc
{
    public sealed class JsonValueProviderFactory : ValueProviderFactory
    {
        private static void AddToBackingStore(EntryLimitedDictionary backingStore, string prefix, object value)
        {
            IDictionary<string, object> d = value as IDictionary<string, object>;
            if (d != null)
            {
                foreach (KeyValuePair<string, object> entry in d)
                {
                    AddToBackingStore(backingStore, MakePropertyKey(prefix, entry.Key), entry.Value);
                }
                return;
            }

            IList l = value as IList;
            if (l != null)
            {
                for (int i = 0; i < l.Count; i++)
                {
                    AddToBackingStore(backingStore, MakeArrayKey(prefix, i), l[i]);
                }
                return;
            }

            // primitive
            backingStore.Add(prefix, value);
        }

        private static object GetDeserializedObject(ControllerContext controllerContext)
        {
            if (!controllerContext.HttpContext.Request.ContentType.StartsWith("application/json", StringComparison.OrdinalIgnoreCase))
            {
                // not JSON request
                return null;
            }

            StreamReader reader = new StreamReader(controllerContext.HttpContext.Request.InputStream);
            string bodyText = reader.ReadToEnd();
            if (String.IsNullOrEmpty(bodyText))
            {
                // no JSON data
                return null;
            }

            JavaScriptSerializer serializer = new JavaScriptSerializer();
            object jsonData = serializer.DeserializeObject(bodyText);
            return jsonData;
        }

        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            object jsonData = GetDeserializedObject(controllerContext);
            if (jsonData == null)
            {
                return null;
            }

            Dictionary<string, object> backingStore = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            EntryLimitedDictionary backingStoreWrapper = new EntryLimitedDictionary(backingStore);
            AddToBackingStore(backingStoreWrapper, String.Empty, jsonData);
            return new DictionaryValueProvider<object>(backingStore, CultureInfo.CurrentCulture);
        }

        private static string MakeArrayKey(string prefix, int index)
        {
            return prefix + "[" + index.ToString(CultureInfo.InvariantCulture) + "]";
        }

        private static string MakePropertyKey(string prefix, string propertyName)
        {
            return (String.IsNullOrEmpty(prefix)) ? propertyName : prefix + "." + propertyName;
        }

        private class EntryLimitedDictionary
        {
            private static int _maximumDepth = GetMaximumDepth();
            private readonly IDictionary<string, object> _innerDictionary;
            private int _itemCount = 0;

            public EntryLimitedDictionary(IDictionary<string, object> innerDictionary)
            {
                _innerDictionary = innerDictionary;
            }

            public void Add(string key, object value)
            {
                if (++_itemCount > _maximumDepth)
                {
                    throw new InvalidOperationException(MvcResources.JsonValueProviderFactory_RequestTooLarge);
                }

                _innerDictionary.Add(key, value);
            }

            private static int GetMaximumDepth()
            {
                NameValueCollection appSettings = ConfigurationManager.AppSettings;
                if (appSettings != null)
                {
                    string[] valueArray = appSettings.GetValues("aspnet:MaxJsonDeserializerMembers");
                    if (valueArray != null && valueArray.Length > 0)
                    {
                        int result;
                        if (Int32.TryParse(valueArray[0], out result))
                        {
                            return result;
                        }
                    }
                }

                return 1000; // Fallback default
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/LinqBinaryModelBinder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Data.Linq;

namespace System.Web.Mvc
{
    public class LinqBinaryModelBinder : ByteArrayModelBinder
    {
        public override object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
        {
            byte[] byteValue = (byte[])base.BindModel(controllerContext, bindingContext);
            if (byteValue == null)
            {
                return null;
            }

            return new Binary(byteValue);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/MaxLengthAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    public class MaxLengthAttributeAdapter : DataAnnotationsModelValidator<MaxLengthAttribute>
    {
        public MaxLengthAttributeAdapter(ModelMetadata metadata, ControllerContext context, MaxLengthAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            return new[] { new ModelClientValidationMaxLengthRule(ErrorMessage, Attribute.Length) };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/MembershipPasswordAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Security;

namespace System.Web.Mvc
{
    internal class MembershipPasswordAttributeAdapter : DataAnnotationsModelValidator<MembershipPasswordAttribute>
    {
        public MembershipPasswordAttributeAdapter(ModelMetadata metadata, ControllerContext context, MembershipPasswordAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            yield return new ModelClientValidationMembershipPasswordRule(ErrorMessage, Attribute.MinRequiredPasswordLength, Attribute.MinRequiredNonAlphanumericCharacters, Attribute.PasswordStrengthRegularExpression);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/MinLengthAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    public class MinLengthAttributeAdapter : DataAnnotationsModelValidator<MinLengthAttribute>
    {
        public MinLengthAttributeAdapter(ModelMetadata metadata, ControllerContext context, MinLengthAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            return new[] { new ModelClientValidationMinLengthRule(ErrorMessage, Attribute.Length) };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelBinderAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [AttributeUsage(ValidTargets, AllowMultiple = false, Inherited = false)]
    public sealed class ModelBinderAttribute : CustomModelBinderAttribute
    {
        public ModelBinderAttribute(Type binderType)
        {
            if (binderType == null)
            {
                throw new ArgumentNullException("binderType");
            }
            if (!typeof(IModelBinder).IsAssignableFrom(binderType))
            {
                string message = String.Format(CultureInfo.CurrentCulture,
                                               MvcResources.ModelBinderAttribute_TypeNotIModelBinder, binderType.FullName);
                throw new ArgumentException(message, "binderType");
            }

            BinderType = binderType;
        }

        public Type BinderType { get; private set; }

        public override IModelBinder GetBinder()
        {
            try
            {
                return (IModelBinder)Activator.CreateInstance(BinderType);
            }
            catch (Exception ex)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.ModelBinderAttribute_ErrorCreatingModelBinder,
                        BinderType.FullName),
                    ex);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelBinderDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ModelBinderDictionary : IDictionary<Type, IModelBinder>
    {
        private readonly Dictionary<Type, IModelBinder> _innerDictionary = new Dictionary<Type, IModelBinder>();
        private IModelBinder _defaultBinder;
        private ModelBinderProviderCollection _modelBinderProviders;

        public ModelBinderDictionary()
            : this(ModelBinderProviders.BinderProviders)
        {
        }

        internal ModelBinderDictionary(ModelBinderProviderCollection modelBinderProviders)
        {
            _modelBinderProviders = modelBinderProviders;
        }

        public int Count
        {
            get { return _innerDictionary.Count; }
        }

        public IModelBinder DefaultBinder
        {
            get
            {
                if (_defaultBinder == null)
                {
                    _defaultBinder = new DefaultModelBinder();
                }
                return _defaultBinder;
            }
            set { _defaultBinder = value; }
        }

        public bool IsReadOnly
        {
            get { return ((IDictionary<Type, IModelBinder>)_innerDictionary).IsReadOnly; }
        }

        public ICollection<Type> Keys
        {
            get { return _innerDictionary.Keys; }
        }

        public ICollection<IModelBinder> Values
        {
            get { return _innerDictionary.Values; }
        }

        public IModelBinder this[Type key]
        {
            get
            {
                IModelBinder binder;
                _innerDictionary.TryGetValue(key, out binder);
                return binder;
            }
            set { _innerDictionary[key] = value; }
        }

        public void Add(KeyValuePair<Type, IModelBinder> item)
        {
            ((IDictionary<Type, IModelBinder>)_innerDictionary).Add(item);
        }

        public void Add(Type key, IModelBinder value)
        {
            _innerDictionary.Add(key, value);
        }

        public void Clear()
        {
            _innerDictionary.Clear();
        }

        public bool Contains(KeyValuePair<Type, IModelBinder> item)
        {
            return ((IDictionary<Type, IModelBinder>)_innerDictionary).Contains(item);
        }

        public bool ContainsKey(Type key)
        {
            return _innerDictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<Type, IModelBinder>[] array, int arrayIndex)
        {
            ((IDictionary<Type, IModelBinder>)_innerDictionary).CopyTo(array, arrayIndex);
        }

        public IModelBinder GetBinder(Type modelType)
        {
            return GetBinder(modelType, true /* fallbackToDefault */);
        }

        public virtual IModelBinder GetBinder(Type modelType, bool fallbackToDefault)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }

            return GetBinder(modelType, (fallbackToDefault) ? DefaultBinder : null);
        }

        private IModelBinder GetBinder(Type modelType, IModelBinder fallbackBinder)
        {
            // Try to look up a binder for this type. We use this order of precedence:
            // 1. Binder returned from provider
            // 2. Binder registered in the global table
            // 3. Binder attribute defined on the type
            // 4. Supplied fallback binder

            IModelBinder binder = _modelBinderProviders.GetBinder(modelType);
            if (binder != null)
            {
                return binder;
            }

            if (_innerDictionary.TryGetValue(modelType, out binder))
            {
                return binder;
            }

            // Function is called frequently, so ensure the error delegate is stateless
            binder = ModelBinders.GetBinderFromAttributes(modelType, (Type errorModel) =>
                {
                    throw new InvalidOperationException(
                        String.Format(CultureInfo.CurrentCulture, MvcResources.ModelBinderDictionary_MultipleAttributes, errorModel.FullName));
                });

            return binder ?? fallbackBinder;
        }

        public IEnumerator<KeyValuePair<Type, IModelBinder>> GetEnumerator()
        {
            return _innerDictionary.GetEnumerator();
        }

        public bool Remove(KeyValuePair<Type, IModelBinder> item)
        {
            return ((IDictionary<Type, IModelBinder>)_innerDictionary).Remove(item);
        }

        public bool Remove(Type key)
        {
            return _innerDictionary.Remove(key);
        }

        public bool TryGetValue(Type key, out IModelBinder value)
        {
            return _innerDictionary.TryGetValue(key, out value);
        }

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_innerDictionary).GetEnumerator();
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/ModelBinderProviderCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace System.Web.Mvc
{
    public class ModelBinderProviderCollection : Collection<IModelBinderProvider>
    {
        private IModelBinderProvider[] _combinedItems;
        private IDependencyResolver _dependencyResolver;

        public ModelBinderProviderCollection()
        {
        }

        public ModelBinderProviderCollection(IList<IModelBinderProvider> list)
            : base(list)
        {
        }

        internal ModelBinderProviderCollection(IList<IModelBinderProvider> list, IDependencyResolver dependencyResolver)
            : base(list)
        {
            _dependencyResolver = dependencyResolver;
        }

        internal IModelBinderProvider[] CombinedItems
        {
            get
            {
                IModelBinderProvider[] combinedItems = _combinedItems;
                if (combinedItems == null)
                {
                    combinedItems = MultiServiceResolver.GetCombined<IModelBinderProvider>(Items, _dependencyResolver);
                    _combinedItems = combinedItems;
                }
                return combinedItems;
            }
        }

        protected override void ClearItems()
        {
            _combinedItems = null;
            base.ClearItems();
        }

        protected override void InsertItem(int index, IModelBinderProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.InsertItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            _combinedItems = null;
            base.RemoveItem(index);
        }

        protected override void SetItem(int index, IModelBinderProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.SetItem(index, item);
        }

        public IModelBinder GetBinder(Type modelType)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }

            // Performance sensitive.
            IModelBinderProvider[] providers = CombinedItems;
            for (int i = 0; i < providers.Length; i++)
            {
                IModelBinder binder = providers[i].GetBinder(modelType);
                if (binder != null)
                {
                    return binder;
                }
            }
            return null;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelBinderProviders.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class ModelBinderProviders
    {
        private static readonly ModelBinderProviderCollection _binderProviders = new ModelBinderProviderCollection
        {
        };

        public static ModelBinderProviderCollection BinderProviders
        {
            get { return _binderProviders; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelBinders.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Data.Linq;
using System.Linq;
using System.Reflection;
using System.Threading;

namespace System.Web.Mvc
{
    public static class ModelBinders
    {
        private static readonly ModelBinderDictionary _binders = CreateDefaultBinderDictionary();

        public static ModelBinderDictionary Binders
        {
            get { return _binders; }
        }

        internal static IModelBinder GetBinderFromAttributes(Type type, Action<Type> errorAction)
        {
            AttributeList allAttrs = new AttributeList(TypeDescriptorHelper.Get(type).GetAttributes());
            CustomModelBinderAttribute binder = allAttrs.SingleOfTypeDefaultOrError<Attribute, CustomModelBinderAttribute, Type>(errorAction, type);
            return binder == null ? null : binder.GetBinder();
        }

        internal static IModelBinder GetBinderFromAttributes(ICustomAttributeProvider element, Action<ICustomAttributeProvider> errorAction)
        {
            CustomModelBinderAttribute[] attrs = (CustomModelBinderAttribute[])element.GetCustomAttributes(typeof(CustomModelBinderAttribute), true /* inherit */);
            // For compatibility, return null if no attributes.
            if (attrs == null)
            {                
                return null;
            }
            CustomModelBinderAttribute binder = attrs.SingleDefaultOrError(errorAction, element);
            return binder == null ? null : binder.GetBinder();
        }

        private static ModelBinderDictionary CreateDefaultBinderDictionary()
        {
            // We can't add a binder to the HttpPostedFileBase type as an attribute, so we'll just
            // prepopulate the dictionary as a convenience to users.

            ModelBinderDictionary binders = new ModelBinderDictionary()
            {
                { typeof(HttpPostedFileBase), new HttpPostedFileBaseModelBinder() },
                { typeof(byte[]), new ByteArrayModelBinder() },
                { typeof(Binary), new LinqBinaryModelBinder() },
                { typeof(CancellationToken), new CancellationTokenModelBinder() }
            };
            return binders;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelBindingContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ModelBindingContext
    {
        private static readonly Predicate<string> _defaultPropertyFilter = _ => true;

        private string _modelName = String.Empty;
        private ModelStateDictionary _modelState;
        private Predicate<string> _propertyFilter;
        private Dictionary<string, ModelMetadata> _propertyMetadata;

        public ModelBindingContext()
            : this(null)
        {
        }

        // copies certain values that won't change between parent and child objects,
        // e.g. ValueProvider, ModelState
        public ModelBindingContext(ModelBindingContext bindingContext)
        {
            if (bindingContext != null)
            {
                ModelState = bindingContext.ModelState;
                ValueProvider = bindingContext.ValueProvider;
            }
        }

        public bool FallbackToEmptyPrefix { get; set; }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "value", Justification = "Cannot remove setter as that's a breaking change")]
        public object Model
        {
            get { return ModelMetadata.Model; }
            set { throw new InvalidOperationException(MvcResources.ModelMetadata_PropertyNotSettable); }
        }

        public ModelMetadata ModelMetadata { get; set; }

        public string ModelName
        {
            get
            {
                return _modelName;
            }
            set 
            {
                _modelName = value ?? String.Empty;
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "The containing type is mutable.")]
        public ModelStateDictionary ModelState
        {
            get
            {
                if (_modelState == null)
                {
                    _modelState = new ModelStateDictionary();
                }
                return _modelState;
            }
            set { _modelState = value; }
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "value", Justification = "Cannot remove setter as that's a breaking change")]
        public Type ModelType
        {
            get { return ModelMetadata.ModelType; }
            set { throw new InvalidOperationException(MvcResources.ModelMetadata_PropertyNotSettable); }
        }

        public Predicate<string> PropertyFilter
        {
            get
            {
                if (_propertyFilter == null)
                {
                    _propertyFilter = _defaultPropertyFilter;
                }
                return _propertyFilter;
            }
            set { _propertyFilter = value; }
        }

        public IDictionary<string, ModelMetadata> PropertyMetadata
        {
            get
            {
                if (_propertyMetadata == null)
                {
                    _propertyMetadata = ModelMetadata.PropertiesAsArray.ToDictionaryFast(m => m.PropertyName, StringComparer.OrdinalIgnoreCase);
                }

                return _propertyMetadata;
            }
        }

        public IValueProvider ValueProvider { get; set; }

        internal IUnvalidatedValueProvider UnvalidatedValueProvider
        {
            get { return (ValueProvider as IUnvalidatedValueProvider) ?? new UnvalidatedValueProviderWrapper(ValueProvider); }
        }

        // Used to wrap an IValueProvider in an IUnvalidatedValueProvider
        private sealed class UnvalidatedValueProviderWrapper : IValueProvider, IUnvalidatedValueProvider
        {
            private readonly IValueProvider _backingProvider;

            public UnvalidatedValueProviderWrapper(IValueProvider backingProvider)
            {
                _backingProvider = backingProvider;
            }

            public ValueProviderResult GetValue(string key, bool skipValidation)
            {
                // 'skipValidation' isn't understood by the backing provider and can be ignored
                return GetValue(key);
            }

            public bool ContainsPrefix(string prefix)
            {
                return _backingProvider.ContainsPrefix(prefix);
            }

            public ValueProviderResult GetValue(string key)
            {
                return _backingProvider.GetValue(key);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelError.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    [Serializable]
    public class ModelError
    {
        public ModelError(Exception exception)
            : this(exception, null /* errorMessage */)
        {
        }

        public ModelError(Exception exception, string errorMessage)
            : this(errorMessage)
        {
            if (exception == null)
            {
                throw new ArgumentNullException("exception");
            }

            Exception = exception;
        }

        public ModelError(string errorMessage)
        {
            ErrorMessage = errorMessage ?? String.Empty;
        }

        public Exception Exception { get; private set; }

        public string ErrorMessage { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelErrorCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;

namespace System.Web.Mvc
{
    [Serializable]
    public class ModelErrorCollection : Collection<ModelError>
    {
        public void Add(Exception exception)
        {
            Add(new ModelError(exception));
        }

        public void Add(string errorMessage)
        {
            Add(new ModelError(errorMessage));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelMetadata.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Mvc.ExpressionUtil;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ModelMetadata
    {
        public const int DefaultOrder = 10000;

        private readonly Type _containerType;
        private readonly Type _modelType;
        private readonly string _propertyName;

        /// <summary>
        /// Explicit backing store for the things we want initialized by default, so don't have to call
        /// the protected virtual setters of an auto-generated property
        /// </summary>
        private Dictionary<string, object> _additionalValues = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        private bool _convertEmptyStringToNull = true;
        private bool _htmlEncode = true;
        private bool _isRequired;
        private object _model;
        private Func<object> _modelAccessor;
        private int _order = DefaultOrder;
        private IEnumerable<ModelMetadata> _properties;
        private ModelMetadata[] _propertiesInternal;
        private Type _realModelType;
        private bool _requestValidationEnabled = true;
        private bool _showForDisplay = true;
        private bool _showForEdit = true;
        private string _simpleDisplayText;

        public ModelMetadata(ModelMetadataProvider provider, Type containerType, Func<object> modelAccessor, Type modelType, string propertyName)
        {
            if (provider == null)
            {
                throw new ArgumentNullException("provider");
            }
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }

            Provider = provider;

            _containerType = containerType;
            _isRequired = !TypeHelpers.TypeAllowsNullValue(modelType);
            _modelAccessor = modelAccessor;
            _modelType = modelType;
            _propertyName = propertyName;
        }

        public virtual Dictionary<string, object> AdditionalValues
        {
            get { return _additionalValues; }
        }

        /// <summary>
        /// A reference to the model's container object. Will be non-null if the model represents a property.
        /// </summary>
        public object Container { get; set; }

        public Type ContainerType
        {
            get { return _containerType; }
        }

        public virtual bool ConvertEmptyStringToNull
        {
            get { return _convertEmptyStringToNull; }
            set { _convertEmptyStringToNull = value; }
        }

        public virtual string DataTypeName { get; set; }

        public virtual string Description { get; set; }

        public virtual string DisplayFormatString { get; set; }

        [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods", Justification = "The method is a delegating helper to choose among multiple property values")]
        public virtual string DisplayName { get; set; }

        public virtual string EditFormatString { get; set; }

        internal virtual bool HasNonDefaultEditFormat { get; set; }

        public virtual bool HideSurroundingHtml { get; set; }

        public virtual bool HtmlEncode
        {
            get { return _htmlEncode; }
            set { _htmlEncode = value; }
        }

        public virtual bool IsComplexType
        {
            get { return !(TypeDescriptor.GetConverter(ModelType).CanConvertFrom(typeof(string))); }
        }

        public bool IsNullableValueType
        {
            get { return TypeHelpers.IsNullableValueType(ModelType); }
        }

        public virtual bool IsReadOnly { get; set; }

        public virtual bool IsRequired
        {
            get { return _isRequired; }
            set { _isRequired = value; }
        }

        public object Model
        {
            get
            {
                if (_modelAccessor != null)
                {
                    _model = _modelAccessor();
                    _modelAccessor = null;
                }
                return _model;
            }
            set
            {
                _model = value;
                _modelAccessor = null;
                _properties = null;
                _realModelType = null;
            }
        }

        public Type ModelType
        {
            get { return _modelType; }
        }

        public virtual string NullDisplayText { get; set; }

        public virtual int Order
        {
            get { return _order; }
            set { _order = value; }
        }

        public virtual IEnumerable<ModelMetadata> Properties
        {
            get
            {
                if (_properties == null)
                {
                    IEnumerable<ModelMetadata> originalProperties = Provider.GetMetadataForProperties(Model, RealModelType);
                    // This will be returned as a copied out array in the common case, so reuse the returned array for performance.
                    _propertiesInternal = SortProperties(originalProperties.AsArray());
                    _properties = new ReadOnlyCollection<ModelMetadata>(_propertiesInternal);
                }
                return _properties;
            }
        }

        internal ModelMetadata[] PropertiesAsArray 
        {
            get
            {
                IEnumerable<ModelMetadata> virtualProperties = Properties;
                if (Object.ReferenceEquals(virtualProperties, _properties))
                {
                    Contract.Assert(_propertiesInternal != null);
                    return _propertiesInternal;
                }
                return virtualProperties.AsArray();
            }
        }

        public string PropertyName
        {
            get { return _propertyName; }
        }

        protected ModelMetadataProvider Provider { get; set; }

        internal Type RealModelType
        {
            get
            {
                if (_realModelType == null)
                {
                    _realModelType = ModelType;

                    // Don't call GetType() if the model is Nullable<T>, because it will
                    // turn Nullable<T> into T for non-null values
                    if (Model != null && !TypeHelpers.IsNullableValueType(ModelType))
                    {
                        _realModelType = Model.GetType();
                    }
                }

                return _realModelType;
            }
        }

        public virtual bool RequestValidationEnabled
        {
            get { return _requestValidationEnabled; }
            set { _requestValidationEnabled = value; }
        }

        public virtual string ShortDisplayName { get; set; }

        public virtual bool ShowForDisplay
        {
            get { return _showForDisplay; }
            set { _showForDisplay = value; }
        }

        public virtual bool ShowForEdit
        {
            get { return _showForEdit; }
            set { _showForEdit = value; }
        }

        [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods", Justification = "This property delegates to the method when the user has not yet set a simple display text value.")]
        public virtual string SimpleDisplayText
        {
            get
            {
                if (_simpleDisplayText == null)
                {
                    _simpleDisplayText = GetSimpleDisplayText();
                }
                return _simpleDisplayText;
            }
            set { _simpleDisplayText = value; }
        }

        public virtual string TemplateHint { get; set; }

        public virtual string Watermark { get; set; }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This is an appropriate nesting of generic types")]
        public static ModelMetadata FromLambdaExpression<TParameter, TValue>(Expression<Func<TParameter, TValue>> expression,
                                                                             ViewDataDictionary<TParameter> viewData)
        {
            return FromLambdaExpression(expression, viewData, metadataProvider: null);
        }

        internal static ModelMetadata FromLambdaExpression<TParameter, TValue>(Expression<Func<TParameter, TValue>> expression,
                                                                               ViewDataDictionary<TParameter> viewData,
                                                                               ModelMetadataProvider metadataProvider)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }
            if (viewData == null)
            {
                throw new ArgumentNullException("viewData");
            }

            string propertyName = null;
            Type containerType = null;
            bool legalExpression = false;

            // Need to verify the expression is valid; it needs to at least end in something
            // that we can convert to a meaningful string for model binding purposes

            switch (expression.Body.NodeType)
            {
                case ExpressionType.ArrayIndex:
                    // ArrayIndex always means a single-dimensional indexer; multi-dimensional indexer is a method call to Get()
                    legalExpression = true;
                    break;

                case ExpressionType.Call:
                    // Only legal method call is a single argument indexer/DefaultMember call
                    legalExpression = ExpressionHelper.IsSingleArgumentIndexer(expression.Body);
                    break;

                case ExpressionType.MemberAccess:
                    // Property/field access is always legal
                    MemberExpression memberExpression = (MemberExpression)expression.Body;
                    propertyName = memberExpression.Member is PropertyInfo ? memberExpression.Member.Name : null;
                    containerType = memberExpression.Expression.Type;
                    legalExpression = true;
                    break;

                case ExpressionType.Parameter:
                    // Parameter expression means "model => model", so we delegate to FromModel
                    return FromModel(viewData, metadataProvider);
            }

            if (!legalExpression)
            {
                throw new InvalidOperationException(MvcResources.TemplateHelpers_TemplateLimitations);
            }

            TParameter container = viewData.Model;
            Func<object> modelAccessor = () =>
            {
                try
                {
                    return CachedExpressionCompiler.Process(expression)(container);
                }
                catch (NullReferenceException)
                {
                    return null;
                }
            };

            return GetMetadataFromProvider(modelAccessor, typeof(TValue), propertyName, container, containerType, metadataProvider);
        }

        private static ModelMetadata FromModel(ViewDataDictionary viewData, ModelMetadataProvider metadataProvider)
        {
            return viewData.ModelMetadata ?? GetMetadataFromProvider(null, typeof(string), null, null, null, metadataProvider);
        }

        public static ModelMetadata FromStringExpression(string expression, ViewDataDictionary viewData)
        {
            return FromStringExpression(expression, viewData, metadataProvider: null);
        }

        internal static ModelMetadata FromStringExpression(string expression, ViewDataDictionary viewData, ModelMetadataProvider metadataProvider)
        {
            if (expression == null)
            {
                throw new ArgumentNullException("expression");
            }
            if (viewData == null)
            {
                throw new ArgumentNullException("viewData");
            }
            if (expression.Length == 0)
            {
                // Empty string really means "model metadata for the current model"
                return FromModel(viewData, metadataProvider);
            }

            ViewDataInfo vdi = viewData.GetViewDataInfo(expression);
            object container = null;
            Type containerType = null;
            Type modelType = null;
            Func<object> modelAccessor = null;
            string propertyName = null;

            if (vdi != null)
            {
                if (vdi.Container != null)
                {
                    container = vdi.Container;
                    containerType = vdi.Container.GetType();
                }

                modelAccessor = () => vdi.Value;

                if (vdi.PropertyDescriptor != null)
                {
                    propertyName = vdi.PropertyDescriptor.Name;
                    modelType = vdi.PropertyDescriptor.PropertyType;
                }
                else if (vdi.Value != null)
                {
                    // We only need to delay accessing properties (for LINQ to SQL)
                    modelType = vdi.Value.GetType();
                }
            }
            else if (viewData.ModelMetadata != null)
            {
                //  Try getting a property from ModelMetadata if we couldn't find an answer in ViewData
                ModelMetadata propertyMetadata = viewData.ModelMetadata.Properties.Where(p => p.PropertyName == expression).FirstOrDefault();
                if (propertyMetadata != null)
                {
                    return propertyMetadata;
                }
            }

            return GetMetadataFromProvider(modelAccessor, modelType ?? typeof(string), propertyName, container, containerType, metadataProvider);
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "The method is a delegating helper to choose among multiple property values")]
        public string GetDisplayName()
        {
            return DisplayName ?? PropertyName ?? ModelType.Name;
        }

        private static ModelMetadata GetMetadataFromProvider(Func<object> modelAccessor, Type modelType, string propertyName, object container, Type containerType, ModelMetadataProvider metadataProvider)
        {
            metadataProvider = metadataProvider ?? ModelMetadataProviders.Current;
            if (containerType != null && !String.IsNullOrEmpty(propertyName))
            {
                ModelMetadata metadata = metadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName);
                if (metadata != null)
                {
                    metadata.Container = container;
                }
                return metadata;
            }
            return metadataProvider.GetMetadataForType(modelAccessor, modelType);
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method is used to resolve the simple display text when it was not explicitly set through other means.")]
        protected virtual string GetSimpleDisplayText()
        {
            if (Model == null)
            {
                return NullDisplayText;
            }

            string toStringResult = Convert.ToString(Model, CultureInfo.CurrentCulture);
            if (toStringResult == null)
            {
                return String.Empty;
            }

            if (!toStringResult.Equals(Model.GetType().FullName, StringComparison.Ordinal))
            {
                return toStringResult;
            }

            ModelMetadata firstProperty = Properties.FirstOrDefault();
            if (firstProperty == null)
            {
                return String.Empty;
            }

            if (firstProperty.Model == null)
            {
                return firstProperty.NullDisplayText;
            }

            return Convert.ToString(firstProperty.Model, CultureInfo.CurrentCulture);
        }

        public virtual IEnumerable<ModelValidator> GetValidators(ControllerContext context)
        {
            return ModelValidatorProviders.Providers.GetValidators(this, context);
        }

        private static ModelMetadata[] SortProperties(ModelMetadata[] properties)
        {
            // Performance-senstive
            // Common case is that properties do not need sorting
            int? previousOrder = null;
            bool needSort = false;
            for (int i = 0; i < properties.Length; i++)
            {
                ModelMetadata metadata = properties[i];
                if (previousOrder != null && previousOrder > metadata.Order)
                {
                    needSort = true;
                    break;
                }
                previousOrder = metadata.Order;
            }
            if (!needSort)
            {
                return properties;
            }
            // For compatibility the sort must be stable so use OrderBy rather than Array.Sort
            return properties.OrderBy(m => m.Order).ToArray();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelMetadataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public abstract class ModelMetadataProvider
    {
        public abstract IEnumerable<ModelMetadata> GetMetadataForProperties(object container, Type containerType);

        public abstract ModelMetadata GetMetadataForProperty(Func<object> modelAccessor, Type containerType, string propertyName);

        public abstract ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType);
    }
}


================================================
FILE: src/System.Web.Mvc/ModelMetadataProviders.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ModelMetadataProviders
    {
        private static ModelMetadataProviders _instance = new ModelMetadataProviders();
        private ModelMetadataProvider _currentProvider;
        private IResolver<ModelMetadataProvider> _resolver;

        internal ModelMetadataProviders(IResolver<ModelMetadataProvider> resolver = null)
        {
            _resolver = resolver ?? new SingleServiceResolver<ModelMetadataProvider>(
                                        () => _currentProvider,
                                        new CachedDataAnnotationsModelMetadataProvider(),
                                        "ModelMetadataProviders.Current");
        }

        public static ModelMetadataProvider Current
        {
            get { return _instance.CurrentInternal; }
            set { _instance.CurrentInternal = value; }
        }

        internal ModelMetadataProvider CurrentInternal
        {
            get { return _resolver.Current; }
            set { _currentProvider = value ?? new EmptyModelMetadataProvider(); }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    [Serializable]
    public class ModelState
    {
        private ModelErrorCollection _errors = new ModelErrorCollection();

        public ValueProviderResult Value { get; set; }

        public ModelErrorCollection Errors
        {
            get { return _errors; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelStateDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    [Serializable]
    public class ModelStateDictionary : IDictionary<string, ModelState>
    {
        private readonly IDictionary<string, ModelState> _innerDictionary;

        public ModelStateDictionary()
        {
            _innerDictionary = new Dictionary<string, ModelState>(StringComparer.OrdinalIgnoreCase);
        }

        public ModelStateDictionary(ModelStateDictionary dictionary)
        {
            if (dictionary == null)
            {
                throw new ArgumentNullException("dictionary");
            }

            _innerDictionary = new CopyOnWriteDictionary<string, ModelState>(dictionary,
                                                                             StringComparer.OrdinalIgnoreCase);
        }

        public int Count
        {
            get { return _innerDictionary.Count; }
        }

        public bool IsReadOnly
        {
            get { return _innerDictionary.IsReadOnly; }
        }

        public bool IsValid
        {
            get { return Values.All(modelState => modelState.Errors.Count == 0); }
        }

        public ICollection<string> Keys
        {
            get { return _innerDictionary.Keys; }
        }

        public ICollection<ModelState> Values
        {
            get { return _innerDictionary.Values; }
        }

        public ModelState this[string key]
        {
            get
            {
                ModelState value;
                _innerDictionary.TryGetValue(key, out value);
                return value;
            }
            set { _innerDictionary[key] = value; }
        }

        // For unit testing
        internal IDictionary<string, ModelState> InnerDictionary
        {
            get { return _innerDictionary; }
        }

        public void Add(KeyValuePair<string, ModelState> item)
        {
            _innerDictionary.Add(item);
        }

        public void Add(string key, ModelState value)
        {
            _innerDictionary.Add(key, value);
        }

        public void AddModelError(string key, Exception exception)
        {
            GetModelStateForKey(key).Errors.Add(exception);
        }

        public void AddModelError(string key, string errorMessage)
        {
            GetModelStateForKey(key).Errors.Add(errorMessage);
        }

        public void Clear()
        {
            _innerDictionary.Clear();
        }

        public bool Contains(KeyValuePair<string, ModelState> item)
        {
            return _innerDictionary.Contains(item);
        }

        public bool ContainsKey(string key)
        {
            return _innerDictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<string, ModelState>[] array, int arrayIndex)
        {
            _innerDictionary.CopyTo(array, arrayIndex);
        }

        public IEnumerator<KeyValuePair<string, ModelState>> GetEnumerator()
        {
            return _innerDictionary.GetEnumerator();
        }

        private ModelState GetModelStateForKey(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            ModelState modelState;
            if (!TryGetValue(key, out modelState))
            {
                modelState = new ModelState();
                this[key] = modelState;
            }

            return modelState;
        }

        public bool IsValidField(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            // if the key is not found in the dictionary, we just say that it's valid (since there are no errors)
            return DictionaryHelpers.FindKeysWithPrefix(this, key).All(entry => entry.Value.Errors.Count == 0);
        }

        public void Merge(ModelStateDictionary dictionary)
        {
            if (dictionary == null)
            {
                return;
            }

            foreach (var entry in dictionary)
            {
                this[entry.Key] = entry.Value;
            }
        }

        public bool Remove(KeyValuePair<string, ModelState> item)
        {
            return _innerDictionary.Remove(item);
        }

        public bool Remove(string key)
        {
            return _innerDictionary.Remove(key);
        }

        public void SetModelValue(string key, ValueProviderResult value)
        {
            GetModelStateForKey(key).Value = value;
        }

        public bool TryGetValue(string key, out ModelState value)
        {
            return _innerDictionary.TryGetValue(key, out value);
        }

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/ModelValidationResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ModelValidationResult
    {
        private string _memberName;
        private string _message;

        public string MemberName
        {
            get { return _memberName ?? String.Empty; }
            set { _memberName = value; }
        }

        public string Message
        {
            get { return _message ?? String.Empty; }
            set { _message = value; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

namespace System.Web.Mvc
{
    public abstract class ModelValidator
    {
        protected ModelValidator(ModelMetadata metadata, ControllerContext controllerContext)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            Metadata = metadata;
            ControllerContext = controllerContext;
        }

        protected internal ControllerContext ControllerContext { get; private set; }

        public virtual bool IsRequired
        {
            get { return false; }
        }

        protected internal ModelMetadata Metadata { get; private set; }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method may perform non-trivial work.")]
        public virtual IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            return Enumerable.Empty<ModelClientValidationRule>();
        }

        public static ModelValidator GetModelValidator(ModelMetadata metadata, ControllerContext context)
        {
            return new CompositeModelValidator(metadata, context);
        }

        public abstract IEnumerable<ModelValidationResult> Validate(object container);

        private class CompositeModelValidator : ModelValidator
        {
            public CompositeModelValidator(ModelMetadata metadata, ControllerContext controllerContext)
                : base(metadata, controllerContext)
            {
            }

            private static ModelValidationResult CreateSubPropertyResult(ModelMetadata propertyMetadata, ModelValidationResult propertyResult)
            {
                return new ModelValidationResult
                {
                    MemberName = DefaultModelBinder.CreateSubPropertyName(propertyMetadata.PropertyName, propertyResult.MemberName),
                    Message = propertyResult.Message
                };
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                bool propertiesValid = true;

                ModelMetadata[] properties = Metadata.PropertiesAsArray;

                // Performance sensitive loops
                for (int propertyIndex = 0; propertyIndex < properties.Length; propertyIndex++)
                {
                    ModelMetadata propertyMetadata = properties[propertyIndex];
                    foreach (ModelValidator propertyValidator in propertyMetadata.GetValidators(ControllerContext))
                    {
                        foreach (ModelValidationResult propertyResult in propertyValidator.Validate(Metadata.Model))
                        {
                            propertiesValid = false;
                            yield return CreateSubPropertyResult(propertyMetadata, propertyResult);
                        }
                    }
                }

                if (propertiesValid)
                {
                    foreach (ModelValidator typeValidator in Metadata.GetValidators(ControllerContext))
                    {
                        foreach (ModelValidationResult typeResult in typeValidator.Validate(container))
                        {
                            yield return typeResult;
                        }
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelValidatorProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public abstract class ModelValidatorProvider
    {
        public abstract IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context);
    }
}


================================================
FILE: src/System.Web.Mvc/ModelValidatorProviderCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace System.Web.Mvc
{
    public class ModelValidatorProviderCollection : Collection<ModelValidatorProvider>
    {
        private ModelValidatorProvider[] _combinedItems;
        private IDependencyResolver _dependencyResolver;

        public ModelValidatorProviderCollection()
        {
        }

        public ModelValidatorProviderCollection(IList<ModelValidatorProvider> list)
            : base(list)
        {
        }

        internal ModelValidatorProviderCollection(IList<ModelValidatorProvider> list, IDependencyResolver dependencyResolver)
            : base(list)
        {
            _dependencyResolver = dependencyResolver;
        }

        internal ModelValidatorProvider[] CombinedItems
        {
            get 
            {
                ModelValidatorProvider[] combinedItems = _combinedItems;
                if (combinedItems == null)
                {
                    combinedItems = MultiServiceResolver.GetCombined<ModelValidatorProvider>(Items, _dependencyResolver);
                    _combinedItems = combinedItems;
                }
                return combinedItems;
            }
        }

        protected override void ClearItems()
        {
            _combinedItems = null;
            base.ClearItems();
        }

        protected override void InsertItem(int index, ModelValidatorProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.InsertItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            _combinedItems = null;
            base.RemoveItem(index);
        }

        protected override void SetItem(int index, ModelValidatorProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.SetItem(index, item);
        }

        public IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
        {
            ModelValidatorProvider[] combined = CombinedItems;
            for (int i = 0; i < combined.Length; i++)
            {
                ModelValidatorProvider provider = combined[i];
                foreach (ModelValidator validator in provider.GetValidators(metadata, context))
                {
                    yield return validator;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ModelValidatorProviders.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class ModelValidatorProviders
    {
        private static readonly ModelValidatorProviderCollection _providers = new ModelValidatorProviderCollection()
        {
            new DataAnnotationsModelValidatorProvider(),
            new DataErrorInfoModelValidatorProvider(),
            new ClientDataTypeModelValidatorProvider()
        };

        public static ModelValidatorProviderCollection Providers
        {
            get { return _providers; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/MultiSelectList.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Web.UI;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Multi", Justification = "FxCop won't accept this in the custom dictionary, so we're suppressing it in source")]
    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "This is a shipped API")]
    public class MultiSelectList : IEnumerable<SelectListItem>
    {
        private IList<SelectListGroup> _groups;

        public MultiSelectList(IEnumerable items)
            : this(items, selectedValues: null)
        {
        }

        public MultiSelectList(IEnumerable items, IEnumerable selectedValues)
            : this(items, dataValueField: null, dataTextField: null, selectedValues: selectedValues)
        {
        }

        /// <summary>
        /// Initializes a new instance of the MultiSelectList class by using the items to include in the list, 
        /// the selected values, the disabled values.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="selectedValues">The selected values field. Used to match the Selected property of the 
        /// corresponding <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>>
        public MultiSelectList(IEnumerable items, IEnumerable selectedValues, IEnumerable disabledValues)
            : this(items,
                   dataValueField: null,
                   dataTextField: null,
                   selectedValues: selectedValues,
                   disabledValues: disabledValues)
        {
        }

        public MultiSelectList(IEnumerable items, string dataValueField, string dataTextField)
            : this(items, dataValueField, dataTextField, selectedValues: null)
        {
        }

        public MultiSelectList(IEnumerable items, string dataValueField, string dataTextField, IEnumerable selectedValues)
            : this(items, dataValueField, dataTextField, dataGroupField: null, selectedValues: selectedValues)
        {
        }

        /// <summary>
        /// Initializes a new instance of the MultiSelectList class by using the items to include in the list, 
        /// the data value field, the data text field, and the data group field.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataGroupField">The data group field. Used to match the Group property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        public MultiSelectList(IEnumerable items, string dataValueField, string dataTextField, string dataGroupField)
            : this(items, dataValueField, dataTextField, dataGroupField: dataGroupField, selectedValues: null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the MultiSelectList class by using the items to include in the list, 
        /// the data value field, the data text field, the selected values, and the disabled values.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValues">The selected values field. Used to match the Selected property of the 
        /// corresponding <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>>
        public MultiSelectList(IEnumerable items,
                               string dataValueField,
                               string dataTextField,
                               IEnumerable selectedValues,
                               IEnumerable disabledValues)
            : this(items,
                   dataValueField,
                   dataTextField,
                   dataGroupField: null,
                   selectedValues: selectedValues,
                   disabledValues: disabledValues)
        {
        }

        /// <summary>
        /// Initializes a new instance of the MultiSelectList class by using the items to include in the list, 
        /// the data value field, the data text field, the data group field, and the selected values.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataGroupField">The data group field. Used to match the Group property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValues">The selected values field. Used to match the Selected property of the 
        /// corresponding <see cref="SelectListItem"/>.</param>
        public MultiSelectList(IEnumerable items,
                               string dataValueField,
                               string dataTextField,
                               string dataGroupField,
                               IEnumerable selectedValues)
            : this(items, dataValueField, dataTextField, dataGroupField, selectedValues, disabledValues: null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the MultiSelectList class by using the items to include in the list,
        /// the data value field, the data text field, the data group field, the selected values, and the disabled
        /// values.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataGroupField">The data group field. Used to match the Group property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValues">The selected values field. Used to match the Selected property of the 
        /// corresponding <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        public MultiSelectList(IEnumerable items,
                               string dataValueField,
                               string dataTextField,
                               string dataGroupField,
                               IEnumerable selectedValues,
                               IEnumerable disabledValues)
            : this(items,
                   dataValueField,
                   dataTextField,
                   dataGroupField,
                   selectedValues,
                   disabledValues,
                   disabledGroups: null)
        {
        }

        /// <summary>
        /// Initializes a new instance of the MultiSelectList class by using the items to include in the list, 
        /// the data value field, the data text field, the data group field, the selected values, the disabled values,
        /// and the disabled groups.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataGroupField">The data group field. Used to match the Group property of the corresponding 
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValues">The selected values field. Used to match the Selected property of the 
        /// corresponding <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="disabledGroups">The disabled groups. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListGroup"/>.</param>
        public MultiSelectList(IEnumerable items,
                               string dataValueField,
                               string dataTextField,
                               string dataGroupField,
                               IEnumerable selectedValues,
                               IEnumerable disabledValues,
                               IEnumerable disabledGroups)
        {
            if (items == null)
            {
                throw new ArgumentNullException("items");
            }

            Items = items;
            DataValueField = dataValueField;
            DataTextField = dataTextField;
            SelectedValues = selectedValues;
            DataGroupField = dataGroupField;
            DisabledValues = disabledValues;
            DisabledGroups = disabledGroups;

            if (DataGroupField != null)
            {
                _groups = new List<SelectListGroup>();
            }
        }

        /// <summary>
        /// Gets the data group field.
        /// </summary>
        public string DataGroupField { get; private set; }

        public string DataTextField { get; private set; }

        public string DataValueField { get; private set; }

        /// <summary>
        /// Gets the disabled groups.
        /// </summary>
        public IEnumerable DisabledGroups { get; private set; }

        /// <summary>
        /// Gets the disabled values.
        /// </summary>
        public IEnumerable DisabledValues { get; private set; }

        public IEnumerable Items { get; private set; }

        public IEnumerable SelectedValues { get; private set; }

        public virtual IEnumerator<SelectListItem> GetEnumerator()
        {
            return GetListItems().GetEnumerator();
        }

        internal IList<SelectListItem> GetListItems()
        {
            return (!String.IsNullOrEmpty(DataValueField))
                       ? GetListItemsWithValueField()
                       : GetListItemsWithoutValueField();
        }

        private IList<SelectListItem> GetListItemsWithValueField()
        {
            HashSet<string> selectedValues = GetStringHashSet(SelectedValues);
            HashSet<string> disabledValues = GetStringHashSet(DisabledValues);
            HashSet<string> disabledGroups = GetStringHashSet(DisabledGroups);

            IEnumerable<SelectListItem> listItems = Items.Cast<object>().Select(item =>
            {
                string value = Eval(item, DataValueField);
                return new SelectListItem
                {
                    Group = GetGroup(item, disabledGroups),
                    Value = value,
                    Text = Eval(item, DataTextField),
                    Selected = selectedValues.Contains(value),
                    Disabled = disabledValues.Contains(value),
                };
            });

            return listItems.ToList();
        }

        private IList<SelectListItem> GetListItemsWithoutValueField()
        {
            HashSet<object> selectedValues = GetObjectHashSet(SelectedValues);
            HashSet<object> disabledValues = GetObjectHashSet(DisabledValues);
            HashSet<string> disabledGroups = GetStringHashSet(DisabledGroups);

            IEnumerable<SelectListItem> listItems = Items.Cast<object>().Select(item =>
            {
                return new SelectListItem
                {
                    Group = GetGroup(item, disabledGroups),
                    Text = Eval(item, DataTextField),
                    Selected = selectedValues.Contains(item),
                    Disabled = disabledValues.Contains(item),
                };
            });

            return listItems.ToList();
        }

        private static string Eval(object container, string expression)
        {
            object value = container;
            if (!String.IsNullOrEmpty(expression))
            {
                value = DataBinder.Eval(container, expression);
            }
            return Convert.ToString(value, CultureInfo.CurrentCulture);
        }

        private SelectListGroup GetGroup(object container, HashSet<string> disabledGroups)
        {
            if (_groups == null)
            {
                return null;
            }

            string groupName = Eval(container, DataGroupField);
            if (String.IsNullOrEmpty(groupName))
            {
                return null;
            }

            // We use StringComparison.CurrentCulture because the group name is used to display as the value of 
            // optgroup HTML tag's label attribute.
            SelectListGroup group = _groups.FirstOrDefault(
                g => String.Equals(g.Name, groupName, StringComparison.CurrentCulture));
            if (group == null)
            {
                group = new SelectListGroup() { Name = groupName, Disabled = disabledGroups.Contains(groupName) };
                _groups.Add(group);
            }

            return group;
        }

        private static HashSet<string> GetStringHashSet(IEnumerable values)
        {
            HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            if (values != null)
            {
                hashSet.UnionWith(
                    values.Cast<object>().Select(value => Convert.ToString(value, CultureInfo.CurrentCulture)));
            }
            return hashSet;
        }

        private static HashSet<object> GetObjectHashSet(IEnumerable values)
        {
            HashSet<object> hashSet = new HashSet<object>();
            if (values != null)
            {
                hashSet.UnionWith(values.Cast<object>());
            }
            return hashSet;
        }

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/MultiServiceResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    internal static class MultiServiceResolver        
    {
        internal static TService[] GetCombined<TService>(IList<TService> items, IDependencyResolver resolver = null) where TService : class
        {           
            if (resolver == null)
            {
                resolver = DependencyResolver.Current;
            }
            IEnumerable<TService> services = resolver.GetServices<TService>();
            return services.Concat(items).ToArray();
        } 
    }
}


================================================
FILE: src/System.Web.Mvc/MvcFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public abstract class MvcFilter : IMvcFilter
    {
        protected MvcFilter()
        {
        }

        protected MvcFilter(bool allowMultiple, int order)
        {
            AllowMultiple = allowMultiple;
            Order = order;
        }

        public bool AllowMultiple { get; private set; }

        public int Order { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/MvcHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Web.Mvc.Async;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.SessionState;
using Microsoft.Web.Infrastructure.DynamicValidationHelper;

namespace System.Web.Mvc
{
    public class MvcHandler : IHttpAsyncHandler, IHttpHandler, IRequiresSessionState
    {
        private static readonly object _processRequestTag = new object();

        internal static readonly string MvcVersion = GetMvcVersionString();
        public static readonly string MvcVersionHeaderName = "X-AspNetMvc-Version";
        private ControllerBuilder _controllerBuilder;

        public MvcHandler(RequestContext requestContext)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }

            RequestContext = requestContext;
        }

        internal ControllerBuilder ControllerBuilder
        {
            get
            {
                if (_controllerBuilder == null)
                {
                    _controllerBuilder = ControllerBuilder.Current;
                }
                return _controllerBuilder;
            }
            set { _controllerBuilder = value; }
        }

        public static bool DisableMvcResponseHeader { get; set; }

        protected virtual bool IsReusable
        {
            get { return false; }
        }

        public RequestContext RequestContext { get; private set; }

        protected internal virtual void AddVersionHeader(HttpContextBase httpContext)
        {
            if (!DisableMvcResponseHeader)
            {
                httpContext.Response.AppendHeader(MvcVersionHeaderName, MvcVersion);
            }
        }

        protected virtual IAsyncResult BeginProcessRequest(HttpContext httpContext, AsyncCallback callback, object state)
        {
            HttpContextBase httpContextBase = new HttpContextWrapper(httpContext);
            return BeginProcessRequest(httpContextBase, callback, state);
        }

        protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
        {
            IController controller;
            IControllerFactory factory;
            ProcessRequestInit(httpContext, out controller, out factory);

            IAsyncController asyncController = controller as IAsyncController;
            if (asyncController != null)
            {
                // asynchronous controller

                // Ensure delegates continue to use the C# Compiler static delegate caching optimization.
                BeginInvokeDelegate<ProcessRequestState> beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState, ProcessRequestState innerState)
                {
                    try
                    {
                        return innerState.AsyncController.BeginExecute(innerState.RequestContext, asyncCallback, asyncState);
                    }
                    catch
                    {
                        innerState.ReleaseController();
                        throw;
                    }
                };

                EndInvokeVoidDelegate<ProcessRequestState> endDelegate = delegate(IAsyncResult asyncResult, ProcessRequestState innerState)
                {
                    try
                    {
                        innerState.AsyncController.EndExecute(asyncResult);
                    }
                    finally
                    {
                        innerState.ReleaseController();
                    }
                };
                ProcessRequestState outerState = new ProcessRequestState() 
                {
                    AsyncController = asyncController, Factory = factory, RequestContext = RequestContext
                };
                
                SynchronizationContext callbackSyncContext = SynchronizationContextUtil.GetSynchronizationContext();
                return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, outerState, _processRequestTag, callbackSyncContext: callbackSyncContext);
            }
            else
            {
                // synchronous controller
                Action action = delegate
                {
                    try
                    {
                        controller.Execute(RequestContext);
                    }
                    finally
                    {
                        factory.ReleaseController(controller);
                    }
                };

                return AsyncResultWrapper.BeginSynchronous(callback, state, action, _processRequestTag);
            }
        }

        protected internal virtual void EndProcessRequest(IAsyncResult asyncResult)
        {
            AsyncResultWrapper.End(asyncResult, _processRequestTag);
        }

        private static string GetMvcVersionString()
        {
            // DevDiv 216459:
            // This code originally used Assembly.GetName(), but that requires FileIOPermission, which isn't granted in
            // medium trust. However, Assembly.FullName *is* accessible in medium trust.
            return new AssemblyName(typeof(MvcHandler).Assembly.FullName).Version.ToString(2);
        }

        protected virtual void ProcessRequest(HttpContext httpContext)
        {
            HttpContextBase httpContextBase = new HttpContextWrapper(httpContext);
            ProcessRequest(httpContextBase);
        }

        protected internal virtual void ProcessRequest(HttpContextBase httpContext)
        {
            IController controller;
            IControllerFactory factory;
            ProcessRequestInit(httpContext, out controller, out factory);

            try
            {
                controller.Execute(RequestContext);
            }
            finally
            {
                factory.ReleaseController(controller);
            }
        }

        private void ProcessRequestInit(HttpContextBase httpContext, out IController controller, out IControllerFactory factory)
        {
            // If request validation has already been enabled, make it lazy. This allows attributes like [HttpPost] (which looks
            // at Request.Form) to work correctly without triggering full validation.
            // Tolerate null HttpContext for testing.
            HttpContext currentContext = HttpContext.Current;
            if (currentContext != null)
            {
                bool? isRequestValidationEnabled = ValidationUtility.IsValidationEnabled(currentContext);
                if (isRequestValidationEnabled == true)
                {
                    ValidationUtility.EnableDynamicValidation(currentContext);
                }
            }

            AddVersionHeader(httpContext);
            RemoveOptionalRoutingParameters();

            // Get the controller type
            string controllerName = RequestContext.RouteData.GetRequiredString("controller");

            // Instantiate the controller and call Execute
            factory = ControllerBuilder.GetControllerFactory();
            controller = factory.CreateController(RequestContext, controllerName);
            if (controller == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.ControllerBuilder_FactoryReturnedNull,
                        factory.GetType(),
                        controllerName));
            }
        }

        private void RemoveOptionalRoutingParameters()
        {
            RouteValueDictionary rvd = RequestContext.RouteData.Values;

            // Ensure delegate is stateless
            rvd.RemoveFromDictionary((entry) => entry.Value == UrlParameter.Optional);
        }

        #region IHttpHandler Members

        bool IHttpHandler.IsReusable
        {
            get { return IsReusable; }
        }

        void IHttpHandler.ProcessRequest(HttpContext httpContext)
        {
            ProcessRequest(httpContext);
        }

        #endregion

        #region IHttpAsyncHandler Members

        IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
        {
            return BeginProcessRequest(context, cb, extraData);
        }

        void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result)
        {
            EndProcessRequest(result);
        }

        #endregion

        // Keep as value type to avoid allocating
        private struct ProcessRequestState
        {
            internal IAsyncController AsyncController;
            internal IControllerFactory Factory;
            internal RequestContext RequestContext;

            internal void ReleaseController()
            {
                Factory.ReleaseController(AsyncController);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/MvcHtmlString.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public sealed class MvcHtmlString : HtmlString
    {
        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes", Justification = "MvcHtmlString is immutable")]
        public static readonly MvcHtmlString Empty = Create(String.Empty);

        private readonly string _value;

        public MvcHtmlString(string value)
            : base(value ?? String.Empty)
        {
            _value = value ?? String.Empty;
        }

        public static MvcHtmlString Create(string value)
        {
            return new MvcHtmlString(value);
        }

        public static bool IsNullOrEmpty(MvcHtmlString value)
        {
            return (value == null || value._value.Length == 0);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/MvcHttpHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Async;
using System.Web.Routing;
using System.Web.SessionState;

namespace System.Web.Mvc
{
    public class MvcHttpHandler : UrlRoutingHandler, IHttpAsyncHandler, IRequiresSessionState
    {
        private static readonly object _processRequestTag = new object();

        protected virtual IAsyncResult BeginProcessRequest(HttpContext httpContext, AsyncCallback callback, object state)
        {
            HttpContextBase httpContextBase = new HttpContextWrapper(httpContext);
            return BeginProcessRequest(httpContextBase, callback, state);
        }

        protected internal virtual IAsyncResult BeginProcessRequest(HttpContextBase httpContext, AsyncCallback callback, object state)
        {
            IHttpHandler httpHandler = GetHttpHandler(httpContext);
            IHttpAsyncHandler httpAsyncHandler = httpHandler as IHttpAsyncHandler;

            if (httpAsyncHandler != null)
            {
                // asynchronous handler

                // Ensure delegates continue to use the C# Compiler static delegate caching optimization.
                BeginInvokeDelegate<IHttpAsyncHandler> beginDelegate = delegate(AsyncCallback asyncCallback, object asyncState, IHttpAsyncHandler innerHandler)
                {
                    return innerHandler.BeginProcessRequest(HttpContext.Current, asyncCallback, asyncState);
                };
                EndInvokeVoidDelegate<IHttpAsyncHandler> endDelegate = delegate(IAsyncResult asyncResult, IHttpAsyncHandler innerHandler)
                {
                    innerHandler.EndProcessRequest(asyncResult);
                };
                return AsyncResultWrapper.Begin(callback, state, beginDelegate, endDelegate, httpAsyncHandler, _processRequestTag);
            }
            else
            {
                // synchronous handler
                Action action = delegate
                {
                    httpHandler.ProcessRequest(HttpContext.Current);
                };
                return AsyncResultWrapper.BeginSynchronous(callback, state, action, _processRequestTag);
            }
        }

        protected internal virtual void EndProcessRequest(IAsyncResult asyncResult)
        {
            AsyncResultWrapper.End(asyncResult, _processRequestTag);
        }

        private static IHttpHandler GetHttpHandler(HttpContextBase httpContext)
        {
            DummyHttpHandler dummyHandler = new DummyHttpHandler();
            dummyHandler.PublicProcessRequest(httpContext);
            return dummyHandler.HttpHandler;
        }

        // synchronous code
        protected override void VerifyAndProcessRequest(IHttpHandler httpHandler, HttpContextBase httpContext)
        {
            if (httpHandler == null)
            {
                throw new ArgumentNullException("httpHandler");
            }

            httpHandler.ProcessRequest(HttpContext.Current);
        }

        #region IHttpAsyncHandler Members

        IAsyncResult IHttpAsyncHandler.BeginProcessRequest(HttpContext context, AsyncCallback cb, object extraData)
        {
            return BeginProcessRequest(context, cb, extraData);
        }

        void IHttpAsyncHandler.EndProcessRequest(IAsyncResult result)
        {
            EndProcessRequest(result);
        }

        #endregion

        // Since UrlRoutingHandler.ProcessRequest() does the heavy lifting of looking at the RouteCollection for
        // a matching route, we need to call into it. However, that method is also responsible for kicking off
        // the synchronous request, and we can't allow it to do that. The purpose of this dummy class is to run
        // only the lookup portion of UrlRoutingHandler.ProcessRequest(), then intercept the handler it returns
        // and execute it asynchronously.

        private sealed class DummyHttpHandler : UrlRoutingHandler
        {
            public IHttpHandler HttpHandler;

            public void PublicProcessRequest(HttpContextBase httpContext)
            {
                ProcessRequest(httpContext);
            }

            protected override void VerifyAndProcessRequest(IHttpHandler httpHandler, HttpContextBase httpContext)
            {
                // don't process the request, just store a reference to it
                HttpHandler = httpHandler;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/MvcRouteHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.SessionState;

namespace System.Web.Mvc
{
    public class MvcRouteHandler : IRouteHandler
    {
        private IControllerFactory _controllerFactory;

        public MvcRouteHandler()
        {
        }

        public MvcRouteHandler(IControllerFactory controllerFactory)
        {
            _controllerFactory = controllerFactory;
        }

        protected virtual IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            requestContext.HttpContext.SetSessionStateBehavior(GetSessionStateBehavior(requestContext));
            return new MvcHandler(requestContext);
        }

        protected virtual SessionStateBehavior GetSessionStateBehavior(RequestContext requestContext)
        {
            string controllerName = (string)requestContext.RouteData.Values["controller"];
            if (String.IsNullOrWhiteSpace(controllerName))
            {
                throw new InvalidOperationException(MvcResources.MvcRouteHandler_RouteValuesHasNoController);
            }

            IControllerFactory controllerFactory = _controllerFactory ?? ControllerBuilder.Current.GetControllerFactory();
            return controllerFactory.GetControllerSessionBehavior(requestContext, controllerName);
        }

        #region IRouteHandler Members

        IHttpHandler IRouteHandler.GetHttpHandler(RequestContext requestContext)
        {
            return GetHttpHandler(requestContext);
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/MvcWebRazorHostFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Razor;
using System.Web.WebPages.Razor;

namespace System.Web.Mvc
{
    public class MvcWebRazorHostFactory : WebRazorHostFactory
    {
        public override WebPageRazorHost CreateHost(string virtualPath, string physicalPath)
        {
            WebPageRazorHost host = base.CreateHost(virtualPath, physicalPath);

            if (!host.IsSpecialPage)
            {
                return new MvcWebPageRazorHost(virtualPath, physicalPath);
            }

            return host;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/NameValueCollectionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;

namespace System.Web.Mvc
{
    public static class NameValueCollectionExtensions
    {
        public static void CopyTo(this NameValueCollection collection, IDictionary<string, object> destination)
        {
            CopyTo(collection, destination, false /* replaceEntries */);
        }

        public static void CopyTo(this NameValueCollection collection, IDictionary<string, object> destination, bool replaceEntries)
        {
            if (collection == null)
            {
                throw new ArgumentNullException("collection");
            }
            if (destination == null)
            {
                throw new ArgumentNullException("destination");
            }

            foreach (string key in collection.Keys)
            {
                if (replaceEntries || !destination.ContainsKey(key))
                {
                    destination[key] = collection[key];
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/NameValueCollectionValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [SuppressMessage("StyleCop.CSharp.NamingRules",
                            "SA1305:FieldNamesMustNotUseHungarianNotation",
                            Target = "jQueryToMvcRequestNormalizationRequired",
                            Justification = "jQuery is usually spelled like this. Hence suppressing this message.")]
    public class NameValueCollectionValueProvider : IValueProvider, IUnvalidatedValueProvider, IEnumerableValueProvider
    {
        private PrefixContainer _prefixContainer;
        private NameValueCollection _collection;
        private NameValueCollection _unvalidatedCollection;
        private CultureInfo _culture;
        private bool _jQueryToMvcRequestNormalizationRequired;

        private Dictionary<string, ValueProviderResultPlaceholder> _values = null;
                
        public NameValueCollectionValueProvider(NameValueCollection collection, CultureInfo culture)
            : this(collection, unvalidatedCollection: null, culture: culture)
        {
        }

        public NameValueCollectionValueProvider(
                        NameValueCollection collection, NameValueCollection unvalidatedCollection, CultureInfo culture)
            : this(collection, unvalidatedCollection, culture, jQueryToMvcRequestNormalizationRequired: false)
        {
        }

        /// <summary>
        /// Initializes Name Value collection provider.
        /// </summary>
        /// <param name="collection">Key value collection from request.</param>
        /// <param name="unvalidatedCollection">Unvalidated key value collection from the request.</param>
        /// <param name="culture">Culture with which the values are to be used.</param>
        /// <param name="jQueryToMvcRequestNormalizationRequired">jQuery POST when sending complex Javascript 
        /// objects to server does not encode in the way understandable by MVC. This flag should be set
        /// if the request should be normalized to MVC form - https://aspnetwebstack.codeplex.com/workitem/1564. </param>
        [SuppressMessage("Microsoft.Naming",
                            "CA1704:IdentifiersShouldBeSpelledCorrectly",
                            MessageId = "j",
                            Justification = "jQuery is not accepted as a valid variable name in this class")]
        public NameValueCollectionValueProvider(
                            NameValueCollection collection, 
                            NameValueCollection unvalidatedCollection, 
                            CultureInfo culture, 
                            bool jQueryToMvcRequestNormalizationRequired)
        {
            if (collection == null)
            {
                throw new ArgumentNullException("collection");
            }

            _unvalidatedCollection = unvalidatedCollection ?? collection;
            _collection = collection;
            _culture = culture;
            _jQueryToMvcRequestNormalizationRequired = jQueryToMvcRequestNormalizationRequired;
        }

        private Dictionary<string, ValueProviderResultPlaceholder> Values
        {
            get
            {
                if (_values == null)
                {
                    _values = InitializeCollectionValues();
                }

                return _values;
            }
        }
        
        private PrefixContainer PrefixContainer
        {
            get
            {
                if (_prefixContainer == null)
                {
                    // Race condition on initialization has no side effects
                    _prefixContainer = new PrefixContainer(Values.Keys);
                }
                return _prefixContainer;
            }
        }

        public virtual bool ContainsPrefix(string prefix)
        {
            return PrefixContainer.ContainsPrefix(prefix);
        }

        public virtual ValueProviderResult GetValue(string key)
        {
            return GetValue(key, skipValidation: false);
        }

        public virtual ValueProviderResult GetValue(string key, bool skipValidation)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            ValueProviderResultPlaceholder placeholder;
            Values.TryGetValue(key, out placeholder);
            if (placeholder == null)
            {
                return null;
            }
            else
            {
                return (skipValidation) ? placeholder.UnvalidatedResult : placeholder.ValidatedResult;
            }
        }

        public virtual IDictionary<string, string> GetKeysFromPrefix(string prefix)
        {
            return PrefixContainer.GetKeysFromPrefix(prefix);
        }

        private Dictionary<string, ValueProviderResultPlaceholder> InitializeCollectionValues()
        {
            Dictionary<string, ValueProviderResultPlaceholder> tempValues =
                            new Dictionary<string, ValueProviderResultPlaceholder>(StringComparer.OrdinalIgnoreCase);

            // Need to read keys from the unvalidated collection, as M.W.I's granular request validation is a bit touchy
            // and validated entries at the time the key or value is looked at. For example, GetKey() will throw if the
            // value fails request validation, even though the value's not being looked at (M.W.I can't tell the difference).

            foreach (string key in _unvalidatedCollection)
            {
                if (key != null)
                {
                    string normalizedKey = key;
                    if (_jQueryToMvcRequestNormalizationRequired)
                    {
                        normalizedKey = NormalizeJQueryToMvc(key);
                    }

                    // need to look up values lazily, as eagerly looking at the collection might trigger validation
                    tempValues[normalizedKey] =
                        new ValueProviderResultPlaceholder(key, _collection, _unvalidatedCollection, _culture);
                }
            }

            return tempValues;
        }

        // This code is borrowed from WebAPI FormDataCollectionExtensions.cs 
        // This is a helper method to use Model Binding over a JQuery syntax. 
        // Normalize from JQuery to MVC keys. The model binding infrastructure uses MVC keys
        // x[] --> x
        // [] --> ""
        // x[12] --> x[12]
        // x[field]  --> x.field, where field is not a number
        private static string NormalizeJQueryToMvc(string key)
        {
            if (key == null)
            {
                return String.Empty;
            }

            StringBuilder sb = null;
            int i = 0;
            while (true)
            {
                int indexOpen = key.IndexOf('[', i);
                if (indexOpen < 0)
                {
                    // Fast path, no normalization needed.
                    // This skips the string conversion and allocating the string builder.
                    if (i == 0)
                    {
                        return key;
                    }

                    sb = sb ?? new StringBuilder();
                    sb.Append(key, i, key.Length - i);
                    break; // no more brackets
                }

                sb = sb ?? new StringBuilder();
                sb.Append(key, i, indexOpen - i); // everything up to "["

                // Find closing bracket.
                int indexClose = key.IndexOf(']', indexOpen);
                if (indexClose == -1)
                {
                    throw Error.Argument("key", MvcResources.JQuerySyntaxMissingClosingBracket);
                }

                if (indexClose == indexOpen + 1)
                {
                    // Empty bracket. Signifies array. Just remove. 
                }
                else
                {
                    if (Char.IsDigit(key[indexOpen + 1]))
                    {
                        // array index. Leave unchanged. 
                        sb.Append(key, indexOpen, indexClose - indexOpen + 1);
                    }
                    else
                    {
                        // Field name.  Convert to dot notation. 
                        sb.Append('.');
                        sb.Append(key, indexOpen + 1, indexClose - indexOpen - 1);
                    }
                }

                i = indexClose + 1;
                if (i >= key.Length)
                {
                    break; // end of string
                }
            }
            return sb.ToString();
        }

        // Placeholder that can store a validated (in relation to request validation) or unvalidated
        // ValueProviderResult for a given key.
        private sealed class ValueProviderResultPlaceholder
        {
            private ValueProviderResult _validatedResult;
            private ValueProviderResult _unvalidatedResult;
            private string _key;
            private NameValueCollection _validatedCollection;
            private NameValueCollection _unvalidatedCollection;
            private CultureInfo _culture;

            public ValueProviderResultPlaceholder(string key, NameValueCollection validatedCollection, NameValueCollection unvalidatedCollection, CultureInfo culture)
            {
                _key = key;
                _validatedCollection = validatedCollection;
                _unvalidatedCollection = unvalidatedCollection;
                _culture = culture;
            }

            public ValueProviderResult ValidatedResult
            {
                get 
                {
                    if (_validatedResult == null)
                    {
                        _validatedResult = GetResultFromCollection(_key, _validatedCollection, _culture);
                    }
                    return _validatedResult;
                }
            }

            public ValueProviderResult UnvalidatedResult
            {
                get 
                {
                    if (_unvalidatedResult == null)
                    {
                        _unvalidatedResult = GetResultFromCollection(_key, _unvalidatedCollection, _culture);
                    }
                    return _unvalidatedResult;
                }
            }

            private static ValueProviderResult GetResultFromCollection(string key, NameValueCollection collection, CultureInfo culture)
            {
                string[] rawValue = collection.GetValues(key);
                string attemptedValue = collection[key];
                return new ValueProviderResult(rawValue, attemptedValue, culture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/NoAsyncTimeoutAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class NoAsyncTimeoutAttribute : AsyncTimeoutAttribute
    {
        public NoAsyncTimeoutAttribute()
            : base(Timeout.Infinite)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/NonActionAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class NonActionAttribute : ActionMethodSelectorAttribute
    {
        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return false;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/NullViewLocationCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal sealed class NullViewLocationCache : IViewLocationCache
    {
        #region IViewLocationCache Members

        public string GetViewLocation(HttpContextBase httpContext, string key)
        {
            return null;
        }

        public void InsertViewLocation(HttpContextBase httpContext, string key, string virtualPath)
        {
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/OutputCacheAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Runtime.Caching;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Web.Mvc.Properties;
using System.Web.UI;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "Unsealed so that subclassed types can set properties in the default constructor.")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public class OutputCacheAttribute : ActionFilterAttribute, IExceptionFilter
    {
        private const string CacheKeyPrefix = "_MvcChildActionCache_";
        private static readonly char[] _splitParameter = new[] { ';' };
        private static ObjectCache _childActionCache;
        private static object _childActionFilterFinishCallbackKey = new object();
        private readonly Func<string[]> _splitVaryByParamThunk;
        private OutputCacheParameters _cacheSettings = new OutputCacheParameters { VaryByParam = "*" };
        private Func<ObjectCache> _childActionCacheThunk = () => ChildActionCache;
        private bool _locationWasSet;
        private bool _noStoreWasSet;
        private string[] _tokenizedVaryByParams;

        public OutputCacheAttribute()
        {
            _splitVaryByParamThunk = () => GetTokenizedVaryByParam(VaryByParam);
        }

        internal OutputCacheAttribute(ObjectCache childActionCache)
            : this()
        {
            _childActionCacheThunk = () => childActionCache;
        }

        public string CacheProfile
        {
            get { return _cacheSettings.CacheProfile ?? String.Empty; }
            set { _cacheSettings.CacheProfile = value; }
        }

        internal OutputCacheParameters CacheSettings
        {
            get { return _cacheSettings; }
        }

        public static ObjectCache ChildActionCache
        {
            get { return _childActionCache ?? MemoryCache.Default; }
            set { _childActionCache = value; }
        }

        private ObjectCache ChildActionCacheInternal
        {
            get { return _childActionCacheThunk(); }
        }

        public int Duration
        {
            get { return _cacheSettings.Duration; }
            set { _cacheSettings.Duration = value; }
        }

        public OutputCacheLocation Location
        {
            get { return _cacheSettings.Location; }
            set
            {
                _cacheSettings.Location = value;
                _locationWasSet = true;
            }
        }

        public bool NoStore
        {
            get { return _cacheSettings.NoStore; }
            set
            {
                _cacheSettings.NoStore = value;
                _noStoreWasSet = true;
            }
        }

        public string SqlDependency
        {
            get { return _cacheSettings.SqlDependency ?? String.Empty; }
            set { _cacheSettings.SqlDependency = value; }
        }

        public string VaryByContentEncoding
        {
            get { return _cacheSettings.VaryByContentEncoding ?? String.Empty; }
            set { _cacheSettings.VaryByContentEncoding = value; }
        }

        public string VaryByCustom
        {
            get { return _cacheSettings.VaryByCustom ?? String.Empty; }
            set { _cacheSettings.VaryByCustom = value; }
        }

        public string VaryByHeader
        {
            get { return _cacheSettings.VaryByHeader ?? String.Empty; }
            set { _cacheSettings.VaryByHeader = value; }
        }

        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Param", Justification = "Matches the @ OutputCache page directive. Suppressed in source because this is a special case suppression.")]
        public string VaryByParam
        {
            get { return _cacheSettings.VaryByParam ?? String.Empty; }
            set
            {
                // Reset the tokenized values if the property gets modified.
                _tokenizedVaryByParams = null;
                _cacheSettings.VaryByParam = value;
            }
        }

        private static void ClearChildActionFilterFinishCallback(ControllerContext controllerContext)
        {
            controllerContext.HttpContext.Items.Remove(_childActionFilterFinishCallbackKey);
        }

        private static void CompleteChildAction(ControllerContext filterContext, bool wasException)
        {
            Action<bool> callback = GetChildActionFilterFinishCallback(filterContext);

            if (callback != null)
            {
                ClearChildActionFilterFinishCallback(filterContext);
                callback(wasException);
            }
        }

        private static Action<bool> GetChildActionFilterFinishCallback(ControllerContext controllerContext)
        {
            return controllerContext.HttpContext.Items[_childActionFilterFinishCallbackKey] as Action<bool>;
        }

        internal string GetChildActionUniqueId(ActionExecutingContext filterContext)
        {
            StringBuilder uniqueIdBuilder = new StringBuilder();

            // Start with a prefix, presuming that we share the cache with other users
            uniqueIdBuilder.Append(CacheKeyPrefix);

            // Unique ID of the action description
            uniqueIdBuilder.Append(filterContext.ActionDescriptor.UniqueId);

            // Unique ID from the VaryByCustom settings, if any
            DescriptorUtil.AppendUniqueId(uniqueIdBuilder, VaryByCustom);
            if (!String.IsNullOrEmpty(VaryByCustom))
            {
                string varyByCustomResult = filterContext.HttpContext.ApplicationInstance.GetVaryByCustomString(HttpContext.Current, VaryByCustom);
                uniqueIdBuilder.Append(varyByCustomResult);
            }

            // Unique ID from the VaryByParam settings, if any
            BuildUniqueIdFromActionParameters(uniqueIdBuilder, filterContext);

            // The key is typically too long to be useful, so we use a cryptographic hash
            // as the actual key (better randomization and key distribution, so small vary
            // values will generate dramtically different keys).
            using (SHA256Cng sha = new SHA256Cng())
            {
                return Convert.ToBase64String(sha.ComputeHash(Encoding.UTF8.GetBytes(uniqueIdBuilder.ToString())));
            }
        }

        internal void BuildUniqueIdFromActionParameters(
            StringBuilder builder,
            ActionExecutingContext filterContext)
        {
            if (String.Equals(VaryByParam, "none", StringComparison.OrdinalIgnoreCase))
            {
                // nothing to do
                return;
            }

            if (String.Equals(VaryByParam, "*", StringComparison.Ordinal))
            {
                // use all available key/value pairs. Keys need to be sorted so we end up with a stable identifier.
                IEnumerable<KeyValuePair<string, object>> orderedParameters = filterContext
                                                                .ActionParameters
                                                                .OrderBy(k => k.Key, StringComparer.OrdinalIgnoreCase);

                foreach (KeyValuePair<string, object> item in orderedParameters)
                {
                    DescriptorUtil.AppendUniqueId(builder, item.Key.ToUpperInvariant());
                    DescriptorUtil.AppendUniqueId(builder, item.Value);
                }

                return;
            }

            LazyInitializer.EnsureInitialized(ref _tokenizedVaryByParams,
                                              _splitVaryByParamThunk);

            // By default, filterContext.ActionParameter is a case insensitive (StringComparer.OrdinalIgnoreCase)
            // dictionary. If the user has replaced it with a dictionary that uses a different comparer, we'll
            // wrap it in a Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)
            // This allows us to lookup values for action parameters when the VaryByParam token key differs in case.
            Dictionary<string, object> keyValues = GetCaseInsensitiveActionParametersDictionary(
                                                        filterContext.ActionParameters);
            for (int i = 0; i < _tokenizedVaryByParams.Length; i++)
            {
                string key = _tokenizedVaryByParams[i];
                DescriptorUtil.AppendUniqueId(builder, key);

                object value;
                keyValues.TryGetValue(key, out value);
                DescriptorUtil.AppendUniqueId(builder, value);
            }
        }

        public static bool IsChildActionCacheActive(ControllerContext controllerContext)
        {
            return GetChildActionFilterFinishCallback(controllerContext) != null;
        }

        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            // Complete the request if the child action threw an exception
            if (filterContext.IsChildAction && filterContext.Exception != null)
            {
                CompleteChildAction(filterContext, wasException: true);
            }
        }

        public override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            if (filterContext.IsChildAction)
            {
                // Skip validation and caching if there's no caching on the server for this action. It's ok to 
                // explicitly disable caching for a child action, but it will be ignored if the parent action
                // is using caching.
                if (IsServerSideCacheDisabled())
                {
                    return;
                }

                ValidateChildActionConfiguration();

                // Already actively being captured? (i.e., cached child action inside of cached child action)
                // Realistically, this needs write substitution to do properly (including things like authentication)
                if (GetChildActionFilterFinishCallback(filterContext) != null)
                {
                    throw new InvalidOperationException(MvcResources.OutputCacheAttribute_CannotNestChildCache);
                }

                // Already cached?
                string uniqueId = GetChildActionUniqueId(filterContext);
                string cachedValue = ChildActionCacheInternal.Get(uniqueId) as string;
                if (cachedValue != null)
                {
                    filterContext.Result = new ContentResult() { Content = cachedValue };
                    return;
                }

                // Swap in a new TextWriter so we can capture the output
                StringWriter cachingWriter = new StringWriter(CultureInfo.InvariantCulture);
                TextWriter originalWriter = filterContext.HttpContext.Response.Output;
                filterContext.HttpContext.Response.Output = cachingWriter;

                // Set a finish callback to clean up
                SetChildActionFilterFinishCallback(filterContext, wasException =>
                {
                    // Restore original writer
                    filterContext.HttpContext.Response.Output = originalWriter;

                    // Grab output and write it
                    string capturedText = cachingWriter.ToString();
                    filterContext.HttpContext.Response.Write(capturedText);

                    // Only cache output if this wasn't an error
                    if (!wasException)
                    {
                        ChildActionCacheInternal.Add(uniqueId, capturedText, DateTimeOffset.UtcNow.AddSeconds(Duration));
                    }
                });
            }
        }

        public void OnException(ExceptionContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            if (filterContext.IsChildAction)
            {
                CompleteChildAction(filterContext, wasException: true);
            }
        }

        public override void OnResultExecuting(ResultExecutingContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            if (!filterContext.IsChildAction)
            {
                // we need to call ProcessRequest() since there's no other way to set the Page.Response intrinsic
                using (OutputCachedPage page = new OutputCachedPage(_cacheSettings))
                {
                    page.ProcessRequest(HttpContext.Current);
                }
            }
        }

        public override void OnResultExecuted(ResultExecutedContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            if (filterContext.IsChildAction)
            {
                CompleteChildAction(filterContext, wasException: filterContext.Exception != null);
            }
        }

        private static void SetChildActionFilterFinishCallback(ControllerContext controllerContext, Action<bool> callback)
        {
            controllerContext.HttpContext.Items[_childActionFilterFinishCallbackKey] = callback;
        }

        private void ValidateChildActionConfiguration()
        {
            if (!String.IsNullOrWhiteSpace(CacheProfile) ||
                !String.IsNullOrWhiteSpace(SqlDependency) ||
                !String.IsNullOrWhiteSpace(VaryByContentEncoding) ||
                !String.IsNullOrWhiteSpace(VaryByHeader) ||
                _locationWasSet || _noStoreWasSet)
            {
                throw new InvalidOperationException(MvcResources.OutputCacheAttribute_ChildAction_UnsupportedSetting);
            }

            if (Duration <= 0)
            {
                throw new InvalidOperationException(MvcResources.OutputCacheAttribute_InvalidDuration);
            }

            if (String.IsNullOrWhiteSpace(VaryByParam))
            {
                throw new InvalidOperationException(MvcResources.OutputCacheAttribute_InvalidVaryByParam);
            }
        }

        private bool IsServerSideCacheDisabled()
        {
            switch (Location)
            {
                case OutputCacheLocation.None:
                case OutputCacheLocation.Client:
                case OutputCacheLocation.Downstream:
                    return true;

                default:
                    return false;
            }
        }

        private static string[] GetTokenizedVaryByParam(string varyByParam)
        {
            // Vary by specific parameters
            IEnumerable<string> splitTokens = from part in varyByParam.Split(_splitParameter)
                                              let trimmed = part.Trim()
                                              where !String.IsNullOrEmpty(trimmed)
                                              select trimmed.ToUpperInvariant();
            return splitTokens.ToArray();
        }

        private static Dictionary<string, object> GetCaseInsensitiveActionParametersDictionary(
            IDictionary<string, object> actionParameters)
        {
            // The ControllerActionInvoker starts off with a Dictionary<string, object> with
            // StringComparer.OrdinalIgnoreCase. Check if we are working with this type to start with.
            // If not produce a new dictionary from the existing one.

            var dictionary = actionParameters as Dictionary<string, object>;
            if (dictionary != null && dictionary.Comparer == StringComparer.OrdinalIgnoreCase)
            {
                return dictionary;
            }

            return new Dictionary<string, object>(actionParameters, StringComparer.OrdinalIgnoreCase);
        }

        [SuppressMessage("ASP.NET.Security", "CA5328:ValidateRequestShouldBeEnabled", Justification = "Instances of this type are not created in response to direct user input.")]
        private sealed class OutputCachedPage : Page
        {
            private OutputCacheParameters _cacheSettings;

            public OutputCachedPage(OutputCacheParameters cacheSettings)
            {
                // Tracing requires Page IDs to be unique.
                ID = Guid.NewGuid().ToString();
                _cacheSettings = cacheSettings;
            }

            protected override void FrameworkInitialize()
            {
                // when you put the <%@ OutputCache %> directive on a page, the generated code calls InitOutputCache() from here
                base.FrameworkInitialize();
                InitOutputCache(_cacheSettings);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/OverrideActionFiltersAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc
{
    /// <summary>Represents a filter attribute that overrides action filters defined at a higher level.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideActionFiltersAttribute : FilterAttribute, IOverrideFilter
    {
        /// <inheritdoc />
        public Type FiltersToOverride
        {
            get { return typeof(IActionFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/OverrideAuthenticationAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc
{
    /// <summary>
    /// Represents a filter attribute that overrides authentication filters defined at a higher level.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideAuthenticationAttribute : FilterAttribute, IOverrideFilter
    {
        /// <inheritdoc />
        public Type FiltersToOverride
        {
            get { return typeof(IAuthenticationFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/OverrideAuthorizationAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc
{
    /// <summary>
    /// Represents a filter attribute that overrides authorization filters defined at a higher level.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideAuthorizationAttribute : FilterAttribute, IOverrideFilter
    {
        /// <inheritdoc />
        public Type FiltersToOverride
        {
            get { return typeof(IAuthorizationFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/OverrideExceptionFiltersAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc
{
    /// <summary>Represents a filter attribute that overrides exception filters defined at a higher level.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideExceptionFiltersAttribute : FilterAttribute, IOverrideFilter
    {
        /// <inheritdoc />
        public Type FiltersToOverride
        {
            get { return typeof(IExceptionFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/OverrideResultFiltersAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc
{
    /// <summary>Represents a filter attribute that overrides result filters defined at a higher level.</summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public sealed class OverrideResultFiltersAttribute : FilterAttribute, IOverrideFilter
    {
        /// <inheritdoc />
        public Type FiltersToOverride
        {
            get { return typeof(IResultFilter); }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ParameterBindingInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public abstract class ParameterBindingInfo
    {
        public virtual IModelBinder Binder
        {
            get { return null; }
        }

        public virtual ICollection<string> Exclude
        {
            get { return new string[0]; }
        }

        public virtual ICollection<string> Include
        {
            get { return new string[0]; }
        }

        public virtual string Prefix
        {
            get { return null; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ParameterDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    public abstract class ParameterDescriptor : ICustomAttributeProvider
    {
        private static readonly EmptyParameterBindingInfo _emptyBindingInfo = new EmptyParameterBindingInfo();

        public abstract ActionDescriptor ActionDescriptor { get; }

        public virtual ParameterBindingInfo BindingInfo
        {
            get { return _emptyBindingInfo; }
        }

        public virtual object DefaultValue
        {
            get { return null; }
        }

        public abstract string ParameterName { get; }

        public abstract Type ParameterType { get; }

        public virtual object[] GetCustomAttributes(bool inherit)
        {
            return GetCustomAttributes(typeof(object), inherit);
        }

        public virtual object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }

            return (object[])Array.CreateInstance(attributeType, 0);
        }

        public virtual bool IsDefined(Type attributeType, bool inherit)
        {
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }

            return false;
        }

        private sealed class EmptyParameterBindingInfo : ParameterBindingInfo
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ParameterInfoUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Reflection;

namespace System.Web.Mvc
{
    internal static class ParameterInfoUtil
    {
        public static bool TryGetDefaultValue(ParameterInfo parameterInfo, out object value)
        {
            // this will get the default value as seen by the VB / C# compilers
            // if no value was baked in, RawDefaultValue returns DBNull.Value
            object defaultValue = parameterInfo.DefaultValue;
            if (defaultValue != DBNull.Value)
            {
                value = defaultValue;
                return true;
            }

            // if the compiler did not bake in a default value, check the [DefaultValue] attribute
            DefaultValueAttribute[] attrs = (DefaultValueAttribute[])parameterInfo.GetCustomAttributes(typeof(DefaultValueAttribute), false);
            if (attrs == null || attrs.Length == 0)
            {
                value = default(object);
                return false;
            }
            else
            {
                value = attrs[0].Value;
                return true;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/PartialViewResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Text;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class PartialViewResult : ViewResultBase
    {
        protected override ViewEngineResult FindView(ControllerContext context)
        {
            ViewEngineResult result = ViewEngineCollection.FindPartialView(context, ViewName);
            if (result.View != null)
            {
                return result;
            }

            // we need to generate an exception containing all the locations we searched
            StringBuilder locationsText = new StringBuilder();
            foreach (string location in result.SearchedLocations)
            {
                locationsText.AppendLine();
                locationsText.Append(location);
            }
            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                              MvcResources.Common_PartialViewNotFound, ViewName, locationsText));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.WebPages.Scope;

namespace System.Web.Mvc
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        private static bool _startWasCalled;

        public static void Start()
        {
            // Guard against multiple calls. All Start calls are made on same thread, so no lock needed here
            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            WebPages.Razor.PreApplicationStartCode.Start();
            WebPages.PreApplicationStartCode.Start();

            ViewContext.GlobalScopeThunk = () => ScopeStorage.CurrentScope;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Web;
using System.Web.Mvc;

[assembly: AssemblyTitle("System.Web.Mvc.dll")]
[assembly: AssemblyDescription("System.Web.Mvc.dll")]
[assembly: Guid("4b5f4208-c6b0-4c37-9a41-63325ffa52ad")]

[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
[assembly: InternalsVisibleTo("System.Web.Mvc.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]
[assembly: TypeForwardedTo(typeof(TagBuilder))]
[assembly: TypeForwardedTo(typeof(TagRenderMode))]
[assembly: TypeForwardedTo(typeof(HttpAntiForgeryException))]
[assembly: TypeForwardedTo(typeof(ModelClientValidationEqualToRule))]
[assembly: TypeForwardedTo(typeof(ModelClientValidationRangeRule))]
[assembly: TypeForwardedTo(typeof(ModelClientValidationRegexRule))]
[assembly: TypeForwardedTo(typeof(ModelClientValidationRemoteRule))]
[assembly: TypeForwardedTo(typeof(ModelClientValidationRequiredRule))]
[assembly: TypeForwardedTo(typeof(ModelClientValidationRule))]
[assembly: TypeForwardedTo(typeof(ModelClientValidationStringLengthRule))]


================================================
FILE: src/System.Web.Mvc/Properties/MvcResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.34003
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Mvc.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class MvcResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal MvcResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Mvc.Properties.MvcResources", typeof(MvcResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The current request for action &apos;{0}&apos; on controller type &apos;{1}&apos; is ambiguous between the following action methods:{2}.
        /// </summary>
        internal static string ActionMethodSelector_AmbiguousMatch {
            get {
                return ResourceManager.GetString("ActionMethodSelector_AmbiguousMatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} on type {1}.
        /// </summary>
        internal static string ActionMethodSelector_AmbiguousMatchType {
            get {
                return ResourceManager.GetString("ActionMethodSelector_AmbiguousMatchType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be greater than or equal to {0}..
        /// </summary>
        internal static string ArgumentMustBeGreaterThanOrEqualTo {
            get {
                return ResourceManager.GetString("ArgumentMustBeGreaterThanOrEqualTo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The asynchronous action method &apos;{0}&apos; cannot be executed synchronously..
        /// </summary>
        internal static string AsyncActionDescriptor_CannotExecuteSynchronously {
            get {
                return ResourceManager.GetString("AsyncActionDescriptor_CannotExecuteSynchronously", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lookup for method &apos;{0}&apos; on controller type &apos;{1}&apos; failed because of an ambiguity between the following methods:{2}.
        /// </summary>
        internal static string AsyncActionMethodSelector_AmbiguousMethodMatch {
            get {
                return ResourceManager.GetString("AsyncActionMethodSelector_AmbiguousMethodMatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not locate a method named &apos;{0}&apos; on controller type {1}..
        /// </summary>
        internal static string AsyncActionMethodSelector_CouldNotFindMethod {
            get {
                return ResourceManager.GetString("AsyncActionMethodSelector_CouldNotFindMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided IAsyncResult has already been consumed..
        /// </summary>
        internal static string AsyncCommon_AsyncResultAlreadyConsumed {
            get {
                return ResourceManager.GetString("AsyncCommon_AsyncResultAlreadyConsumed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The controller of type &apos;{0}&apos; must subclass AsyncController or implement the IAsyncManagerContainer interface..
        /// </summary>
        internal static string AsyncCommon_ControllerMustImplementIAsyncManagerContainer {
            get {
                return ResourceManager.GetString("AsyncCommon_ControllerMustImplementIAsyncManagerContainer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided IAsyncResult is not valid for this method..
        /// </summary>
        internal static string AsyncCommon_InvalidAsyncResult {
            get {
                return ResourceManager.GetString("AsyncCommon_InvalidAsyncResult", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The timeout value must be non-negative or Timeout.Infinite..
        /// </summary>
        internal static string AsyncCommon_InvalidTimeout {
            get {
                return ResourceManager.GetString("AsyncCommon_InvalidTimeout", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not infer area name for the controller &apos;{0}&apos; because it does not have a namespace..
        /// </summary>
        internal static string AttributeRouting_CouldNotInferAreaNameFromMissingNamespace {
            get {
                return ResourceManager.GetString("AttributeRouting_CouldNotInferAreaNameFromMissingNamespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to AuthorizeAttribute cannot be used within a child action caching block..
        /// </summary>
        internal static string AuthorizeAttribute_CannotUseWithinChildActionCache {
            get {
                return ResourceManager.GetString("AuthorizeAttribute_CannotUseWithinChildActionCache", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The action &apos;{0}&apos; is accessible only by a child request..
        /// </summary>
        internal static string ChildActionOnlyAttribute_MustBeInChildRequest {
            get {
                return ResourceManager.GetString("ChildActionOnlyAttribute_MustBeInChildRequest", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The field {0} must be a date..
        /// </summary>
        internal static string ClientDataTypeModelValidatorProvider_FieldMustBeDate {
            get {
                return ResourceManager.GetString("ClientDataTypeModelValidatorProvider_FieldMustBeDate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The field {0} must be a number..
        /// </summary>
        internal static string ClientDataTypeModelValidatorProvider_FieldMustBeNumeric {
            get {
                return ResourceManager.GetString("ClientDataTypeModelValidatorProvider_FieldMustBeNumeric", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No route in the route table matches the supplied values..
        /// </summary>
        internal static string Common_NoRouteMatched {
            get {
                return ResourceManager.GetString("Common_NoRouteMatched", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value cannot be null or empty..
        /// </summary>
        internal static string Common_NullOrEmpty {
            get {
                return ResourceManager.GetString("Common_NullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The partial view &apos;{0}&apos; was not found or no view engine supports the searched locations. The following locations were searched:{1}.
        /// </summary>
        internal static string Common_PartialViewNotFound {
            get {
                return ResourceManager.GetString("Common_PartialViewNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property &apos;{0}&apos; cannot be null or empty..
        /// </summary>
        internal static string Common_PropertyCannotBeNullOrEmpty {
            get {
                return ResourceManager.GetString("Common_PropertyCannotBeNullOrEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property {0}.{1} could not be found..
        /// </summary>
        internal static string Common_PropertyNotFound {
            get {
                return ResourceManager.GetString("Common_PropertyNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to False.
        /// </summary>
        internal static string Common_TriState_False {
            get {
                return ResourceManager.GetString("Common_TriState_False", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Not Set.
        /// </summary>
        internal static string Common_TriState_NotSet {
            get {
                return ResourceManager.GetString("Common_TriState_NotSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to True.
        /// </summary>
        internal static string Common_TriState_True {
            get {
                return ResourceManager.GetString("Common_TriState_True", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type {0} must derive from {1}.
        /// </summary>
        internal static string Common_TypeMustDriveFromType {
            get {
                return ResourceManager.GetString("Common_TypeMustDriveFromType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value &apos;{0}&apos; is invalid..
        /// </summary>
        internal static string Common_ValueNotValidForProperty {
            get {
                return ResourceManager.GetString("Common_ValueNotValidForProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The view &apos;{0}&apos; or its master was not found or no view engine supports the searched locations. The following locations were searched:{1}.
        /// </summary>
        internal static string Common_ViewNotFound {
            get {
                return ResourceManager.GetString("Common_ViewNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; and &apos;{1}&apos; do not match..
        /// </summary>
        internal static string CompareAttribute_MustMatch {
            get {
                return ResourceManager.GetString("CompareAttribute_MustMatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not find a property named {0}..
        /// </summary>
        internal static string CompareAttribute_UnknownProperty {
            get {
                return ResourceManager.GetString("CompareAttribute_UnknownProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A public action method &apos;{0}&apos; was not found on controller &apos;{1}&apos;..
        /// </summary>
        internal static string Controller_UnknownAction {
            get {
                return ResourceManager.GetString("Controller_UnknownAction", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No matching action was found on controller &apos;{0}&apos;. This can happen when a controller uses RouteAttribute for routing, but no action on that controller matches the request..
        /// </summary>
        internal static string Controller_UnknownAction_NoActionName {
            get {
                return ResourceManager.GetString("Controller_UnknownAction_NoActionName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model of type &apos;{0}&apos; could not be updated..
        /// </summary>
        internal static string Controller_UpdateModel_UpdateUnsuccessful {
            get {
                return ResourceManager.GetString("Controller_UpdateModel_UpdateUnsuccessful", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model of type &apos;{0}&apos; is not valid..
        /// </summary>
        internal static string Controller_Validate_ValidationFailed {
            get {
                return ResourceManager.GetString("Controller_Validate_ValidationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot execute Controller with a null HttpContext..
        /// </summary>
        internal static string ControllerBase_CannotExecuteWithNullHttpContext {
            get {
                return ResourceManager.GetString("ControllerBase_CannotExecuteWithNullHttpContext", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A single instance of controller &apos;{0}&apos; cannot be used to handle multiple requests. If a custom controller factory is in use, make sure that it creates a new instance of the controller for each request..
        /// </summary>
        internal static string ControllerBase_CannotHandleMultipleRequests {
            get {
                return ResourceManager.GetString("ControllerBase_CannotHandleMultipleRequests", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error occurred when trying to create the IControllerFactory &apos;{0}&apos;. Make sure that the controller factory has a public parameterless constructor..
        /// </summary>
        internal static string ControllerBuilder_ErrorCreatingControllerFactory {
            get {
                return ResourceManager.GetString("ControllerBuilder_ErrorCreatingControllerFactory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The IControllerFactory &apos;{0}&apos; did not return a controller for the name &apos;{1}&apos;..
        /// </summary>
        internal static string ControllerBuilder_FactoryReturnedNull {
            get {
                return ResourceManager.GetString("ControllerBuilder_FactoryReturnedNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The controller factory type &apos;{0}&apos; must implement the IControllerFactory interface..
        /// </summary>
        internal static string ControllerBuilder_MissingIControllerFactory {
            get {
                return ResourceManager.GetString("ControllerBuilder_MissingIControllerFactory", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The view found at &apos;{0}&apos; was not created..
        /// </summary>
        internal static string CshtmlView_ViewCouldNotBeCreated {
            get {
                return ResourceManager.GetString("CshtmlView_ViewCouldNotBeCreated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The view at &apos;{0}&apos; must derive from WebViewPage, or WebViewPage&lt;TModel&gt;..
        /// </summary>
        internal static string CshtmlView_WrongViewBase {
            get {
                return ResourceManager.GetString("CshtmlView_WrongViewBase", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} has a DisplayColumn attribute for {1}, but property {1} does not exist..
        /// </summary>
        internal static string DataAnnotationsModelMetadataProvider_UnknownProperty {
            get {
                return ResourceManager.GetString("DataAnnotationsModelMetadataProvider_UnknownProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} has a DisplayColumn attribute for {1}, but property {1} does not have a public getter..
        /// </summary>
        internal static string DataAnnotationsModelMetadataProvider_UnreadableProperty {
            get {
                return ResourceManager.GetString("DataAnnotationsModelMetadataProvider_UnreadableProperty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type {0} must have a public constructor which accepts three parameters of types {1}, {2}, and {3}.
        /// </summary>
        internal static string DataAnnotationsModelValidatorProvider_ConstructorRequirements {
            get {
                return ResourceManager.GetString("DataAnnotationsModelValidatorProvider_ConstructorRequirements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type {0} must have a public constructor which accepts two parameters of types {1} and {2}..
        /// </summary>
        internal static string DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements {
            get {
                return ResourceManager.GetString("DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple types were found that match the controller named &apos;{0}&apos;. This can happen if the route that services this request does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the &apos;MapRoute&apos; method that takes a &apos;namespaces&apos; parameter.{2}{2}The request for &apos;{0}&apos; has found the following matching controllers:{1}.
        /// </summary>
        internal static string DefaultControllerFactory_ControllerNameAmbiguous_WithoutRouteUrl {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_ControllerNameAmbiguous_WithoutRouteUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple types were found that match the controller named &apos;{0}&apos;. This can happen if the route that services this request (&apos;{1}&apos;) does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the &apos;MapRoute&apos; method that takes a &apos;namespaces&apos; parameter.{3}{3}The request for &apos;{0}&apos; has found the following matching controllers:{2}.
        /// </summary>
        internal static string DefaultControllerFactory_ControllerNameAmbiguous_WithRouteUrl {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_ControllerNameAmbiguous_WithRouteUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple controller types were found that match the URL. This can happen if attribute routes on multiple controllers match the requested URL.{1}{1}The request has found the following matching controller types: {0}.
        /// </summary>
        internal static string DefaultControllerFactory_DirectRouteAmbiguous {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_DirectRouteAmbiguous", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error occurred when trying to create a controller of type &apos;{0}&apos;. Make sure that the controller has a parameterless public constructor..
        /// </summary>
        internal static string DefaultControllerFactory_ErrorCreatingController {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_ErrorCreatingController", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The controller for path &apos;{0}&apos; was not found or does not implement IController..
        /// </summary>
        internal static string DefaultControllerFactory_NoControllerFound {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_NoControllerFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The controller type &apos;{0}&apos; must implement IController..
        /// </summary>
        internal static string DefaultControllerFactory_TypeDoesNotSubclassControllerBase {
            get {
                return ResourceManager.GetString("DefaultControllerFactory_TypeDoesNotSubclassControllerBase", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constructor to use for activating the constraint type &apos;{0}&apos; is ambiguous. Multiple constructors were found with the following number of parameters: {1}..
        /// </summary>
        internal static string DefaultInlineConstraintResolver_AmbiguousCtors {
            get {
                return ResourceManager.GetString("DefaultInlineConstraintResolver_AmbiguousCtors", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not find a constructor for constraint type &apos;{0}&apos; with the following number of parameters: {1}..
        /// </summary>
        internal static string DefaultInlineConstraintResolver_CouldNotFindCtor {
            get {
                return ResourceManager.GetString("DefaultInlineConstraintResolver_CouldNotFindCtor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constraint type &apos;{0}&apos; which is mapped to constraint key &apos;{1}&apos; must implement the IRouteConstraint interface..
        /// </summary>
        internal static string DefaultInlineConstraintResolver_TypeNotConstraint {
            get {
                return ResourceManager.GetString("DefaultInlineConstraintResolver_TypeNotConstraint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value &apos;{0}&apos; is not valid for {1}..
        /// </summary>
        internal static string DefaultModelBinder_ValueInvalid {
            get {
                return ResourceManager.GetString("DefaultModelBinder_ValueInvalid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A value is required..
        /// </summary>
        internal static string DefaultModelBinder_ValueRequired {
            get {
                return ResourceManager.GetString("DefaultModelBinder_ValueRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The number of ticks for the TimeSpan value must be greater than or equal to 0..
        /// </summary>
        internal static string DefaultViewLocationCache_NegativeTimeSpan {
            get {
                return ResourceManager.GetString("DefaultViewLocationCache_NegativeTimeSpan", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type {0} does not appear to implement Microsoft.Practices.ServiceLocation.IServiceLocator..
        /// </summary>
        internal static string DependencyResolver_DoesNotImplementICommonServiceLocator {
            get {
                return ResourceManager.GetString("DependencyResolver_DoesNotImplementICommonServiceLocator", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The current request is ambiguous between the following action methods:{0}.
        /// </summary>
        internal static string DirectRoute_AmbiguousMatch {
            get {
                return ResourceManager.GetString("DirectRoute_AmbiguousMatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A direct route for an action method cannot use the parameter &apos;action&apos;. Specify a literal path in place of this parameter to create a route to the action..
        /// </summary>
        internal static string DirectRoute_InvalidParameter_Action {
            get {
                return ResourceManager.GetString("DirectRoute_InvalidParameter_Action", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A direct route cannot use the parameter &apos;controller&apos;. Specify a literal path in place of this parameter to create a route to a controller..
        /// </summary>
        internal static string DirectRoute_InvalidParameter_Controller {
            get {
                return ResourceManager.GetString("DirectRoute_InvalidParameter_Controller", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route does not have any associated action descriptors. Routing requires that each direct route map to a non-empty set of actions..
        /// </summary>
        internal static string DirectRoute_MissingActionDescriptors {
            get {
                return ResourceManager.GetString("DirectRoute_MissingActionDescriptors", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route does not have an associated controller descriptor. Routing requires that each direct route map to a single controller..
        /// </summary>
        internal static string DirectRoute_MissingControllerDescriptor {
            get {
                return ResourceManager.GetString("DirectRoute_MissingControllerDescriptor", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route does not have an associated controller type. Routing requires that each direct route map to a single controller type..
        /// </summary>
        internal static string DirectRoute_MissingControllerType {
            get {
                return ResourceManager.GetString("DirectRoute_MissingControllerType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Direct routing does not support per-route route handlers..
        /// </summary>
        internal static string DirectRoute_RouteHandlerNotSupported {
            get {
                return ResourceManager.GetString("DirectRoute_RouteHandlerNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ModelType property must not be null..
        /// </summary>
        internal static string EnumHelper_InvalidMetadataParameter {
            get {
                return ResourceManager.GetString("EnumHelper_InvalidMetadataParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Type &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string EnumHelper_InvalidParameterType {
            get {
                return ResourceManager.GetString("EnumHelper_InvalidParameterType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid value parameter type &apos;{0}&apos;. Must match type parameter &apos;{1}&apos;..
        /// </summary>
        internal static string EnumHelper_InvalidValueParameter {
            get {
                return ResourceManager.GetString("EnumHelper_InvalidValueParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; does not inherit from Exception..
        /// </summary>
        internal static string ExceptionViewAttribute_NonExceptionType {
            get {
                return ResourceManager.GetString("ExceptionViewAttribute_NonExceptionType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The expression compiler was unable to evaluate the indexer expression &apos;{0}&apos; because it references the model parameter &apos;{1}&apos; which is unavailable..
        /// </summary>
        internal static string ExpressionHelper_InvalidIndexerExpression {
            get {
                return ResourceManager.GetString("ExpressionHelper_InvalidIndexerExpression", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Order must be greater than or equal to -1..
        /// </summary>
        internal static string FilterAttribute_OrderOutOfRange {
            get {
                return ResourceManager.GetString("FilterAttribute_OrderOutOfRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The given filter instance must implement one or more of the following filter interfaces: {0}, {1}, {2}, {3}, {4}..
        /// </summary>
        internal static string GlobalFilterCollection_UnsupportedFilterInstance {
            get {
                return ResourceManager.GetString("GlobalFilterCollection_UnsupportedFilterInstance", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The GET and POST HTTP methods are not supported..
        /// </summary>
        internal static string HtmlHelper_InvalidHttpMethod {
            get {
                return ResourceManager.GetString("HtmlHelper_InvalidHttpMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The specified HttpVerbs value is not supported. The supported values are Delete, Head, Put, Options, and Patch..
        /// </summary>
        internal static string HtmlHelper_InvalidHttpVerb {
            get {
                return ResourceManager.GetString("HtmlHelper_InvalidHttpVerb", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There is no ViewData item of type &apos;{1}&apos; that has the key &apos;{0}&apos;..
        /// </summary>
        internal static string HtmlHelper_MissingSelectData {
            get {
                return ResourceManager.GetString("HtmlHelper_MissingSelectData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter &apos;{0}&apos; must evaluate to an IEnumerable when multiple selection is allowed..
        /// </summary>
        internal static string HtmlHelper_SelectExpressionNotEnumerable {
            get {
                return ResourceManager.GetString("HtmlHelper_SelectExpressionNotEnumerable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The value must be greater than or equal to zero..
        /// </summary>
        internal static string HtmlHelper_TextAreaParameterOutOfRange {
            get {
                return ResourceManager.GetString("HtmlHelper_TextAreaParameterOutOfRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ViewData item that has the key &apos;{0}&apos; is of type &apos;{1}&apos; but must be of type &apos;{2}&apos;..
        /// </summary>
        internal static string HtmlHelper_WrongSelectDataType {
            get {
                return ResourceManager.GetString("HtmlHelper_WrongSelectDataType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The inline constraint resolver of type &apos;{0}&apos; was unable to resolve the following inline constraint: &apos;{1}&apos;..
        /// </summary>
        internal static string HttpRouteBuilder_CouldNotResolveConstraint {
            get {
                return ResourceManager.GetString("HttpRouteBuilder_CouldNotResolveConstraint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The key is invalid JQuery syntax because it is missing a closing bracket..
        /// </summary>
        internal static string JQuerySyntaxMissingClosingBracket {
            get {
                return ResourceManager.GetString("JQuerySyntaxMissingClosingBracket", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This request has been blocked because sensitive information could be disclosed to third party web sites when this is used in a GET request. To allow GET requests, set JsonRequestBehavior to AllowGet..
        /// </summary>
        internal static string JsonRequest_GetNotAllowed {
            get {
                return ResourceManager.GetString("JsonRequest_GetNotAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The JSON request was too large to be deserialized..
        /// </summary>
        internal static string JsonValueProviderFactory_RequestTooLarge {
            get {
                return ResourceManager.GetString("JsonValueProviderFactory_RequestTooLarge", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An error occurred when trying to create the IModelBinder &apos;{0}&apos;. Make sure that the binder has a public parameterless constructor..
        /// </summary>
        internal static string ModelBinderAttribute_ErrorCreatingModelBinder {
            get {
                return ResourceManager.GetString("ModelBinderAttribute_ErrorCreatingModelBinder", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; does not implement the IModelBinder interface..
        /// </summary>
        internal static string ModelBinderAttribute_TypeNotIModelBinder {
            get {
                return ResourceManager.GetString("ModelBinderAttribute_TypeNotIModelBinder", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The type &apos;{0}&apos; contains multiple attributes that inherit from CustomModelBinderAttribute..
        /// </summary>
        internal static string ModelBinderDictionary_MultipleAttributes {
            get {
                return ResourceManager.GetString("ModelBinderDictionary_MultipleAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This property setter is obsolete, because its value is derived from ModelMetadata.Model now..
        /// </summary>
        internal static string ModelMetadata_PropertyNotSettable {
            get {
                return ResourceManager.GetString("ModelMetadata_PropertyNotSettable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This constructor is obsolete, because its functionality has been moved to MvcForm(ViewContext) now..
        /// </summary>
        internal static string MvcForm_ConstructorObsolete {
            get {
                return ResourceManager.GetString("MvcForm_ConstructorObsolete", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;inherits&apos; keyword is not allowed when a &apos;{0}&apos; keyword is used..
        /// </summary>
        internal static string MvcRazorCodeParser_CannotHaveModelAndInheritsKeyword {
            get {
                return ResourceManager.GetString("MvcRazorCodeParser_CannotHaveModelAndInheritsKeyword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;{0}&apos; keyword must be followed by a type name on the same line..
        /// </summary>
        internal static string MvcRazorCodeParser_ModelKeywordMustBeFollowedByTypeName {
            get {
                return ResourceManager.GetString("MvcRazorCodeParser_ModelKeywordMustBeFollowedByTypeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only one &apos;{0}&apos; statement is allowed in a file..
        /// </summary>
        internal static string MvcRazorCodeParser_OnlyOneModelStatementIsAllowed {
            get {
                return ResourceManager.GetString("MvcRazorCodeParser_OnlyOneModelStatementIsAllowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The matched route does not include a &apos;controller&apos; route value, which is required..
        /// </summary>
        internal static string MvcRouteHandler_RouteValuesHasNoController {
            get {
                return ResourceManager.GetString("MvcRouteHandler_RouteValuesHasNoController", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OutputCacheAttribute is not allowed on child actions which are children of an already cached child action..
        /// </summary>
        internal static string OutputCacheAttribute_CannotNestChildCache {
            get {
                return ResourceManager.GetString("OutputCacheAttribute_CannotNestChildCache", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OutputCacheAttribute for child actions only supports Duration, VaryByCustom, and VaryByParam values. Please do not set CacheProfile, Location, NoStore, SqlDependency, VaryByContentEncoding, or VaryByHeader values for child actions..
        /// </summary>
        internal static string OutputCacheAttribute_ChildAction_UnsupportedSetting {
            get {
                return ResourceManager.GetString("OutputCacheAttribute_ChildAction_UnsupportedSetting", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Duration must be a positive number..
        /// </summary>
        internal static string OutputCacheAttribute_InvalidDuration {
            get {
                return ResourceManager.GetString("OutputCacheAttribute_InvalidDuration", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to VaryByParam must be &apos;*&apos;, &apos;none&apos;, or a semicolon-delimited list of keys..
        /// </summary>
        internal static string OutputCacheAttribute_InvalidVaryByParam {
            get {
                return ResourceManager.GetString("OutputCacheAttribute_InvalidVaryByParam", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Child actions are not allowed to perform redirect actions..
        /// </summary>
        internal static string RedirectAction_CannotRedirectInChildAction {
            get {
                return ResourceManager.GetString("RedirectAction_CannotRedirectInChildAction", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot create a descriptor for instance method &apos;{0}&apos; on type &apos;{1}&apos; because the type does not derive from ControllerBase..
        /// </summary>
        internal static string ReflectedActionDescriptor_CannotCallInstanceMethodOnNonControllerType {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_CannotCallInstanceMethodOnNonControllerType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot call action method &apos;{0}&apos; on controller &apos;{1}&apos; because the parameter &apos;{2}&apos; is passed by reference..
        /// </summary>
        internal static string ReflectedActionDescriptor_CannotCallMethodsWithOutOrRefParameters {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_CannotCallMethodsWithOutOrRefParameters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot call action method &apos;{0}&apos; on controller &apos;{1}&apos; because the action method is a generic method..
        /// </summary>
        internal static string ReflectedActionDescriptor_CannotCallOpenGenericMethods {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_CannotCallOpenGenericMethods", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot call action method &apos;{0}&apos; on controller &apos;{1}&apos; because the action method is a static method..
        /// </summary>
        internal static string ReflectedActionDescriptor_CannotCallStaticMethod {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_CannotCallStaticMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameters dictionary contains a null entry for parameter &apos;{0}&apos; of non-nullable type &apos;{1}&apos; for method &apos;{2}&apos; in &apos;{3}&apos;. An optional parameter must be a reference type, a nullable type, or be declared as an optional parameter..
        /// </summary>
        internal static string ReflectedActionDescriptor_ParameterCannotBeNull {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_ParameterCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameters dictionary does not contain an entry for parameter &apos;{0}&apos; of type &apos;{1}&apos; for method &apos;{2}&apos; in &apos;{3}&apos;. The dictionary must contain an entry for each parameter, including parameters that have null values..
        /// </summary>
        internal static string ReflectedActionDescriptor_ParameterNotInDictionary {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_ParameterNotInDictionary", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameters dictionary contains an invalid entry for parameter &apos;{0}&apos; for method &apos;{1}&apos; in &apos;{2}&apos;. The dictionary contains a value of type &apos;{3}&apos;, but the parameter requires a value of type &apos;{4}&apos;..
        /// </summary>
        internal static string ReflectedActionDescriptor_ParameterValueHasWrongType {
            get {
                return ResourceManager.GetString("ReflectedActionDescriptor_ParameterValueHasWrongType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter &apos;{0}&apos; on method &apos;{1}&apos; contains multiple attributes that inherit from CustomModelBinderAttribute..
        /// </summary>
        internal static string ReflectedParameterBindingInfo_MultipleConverterAttributes {
            get {
                return ResourceManager.GetString("ReflectedParameterBindingInfo_MultipleConverterAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No url for remote validation could be found..
        /// </summary>
        internal static string RemoteAttribute_NoUrlFound {
            get {
                return ResourceManager.GetString("RemoteAttribute_NoUrlFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &apos;{0}&apos; is invalid..
        /// </summary>
        internal static string RemoteAttribute_RemoteValidationFailed {
            get {
                return ResourceManager.GetString("RemoteAttribute_RemoteValidationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The requested resource can only be accessed via SSL..
        /// </summary>
        internal static string RequireHttpsAttribute_MustUseSsl {
            get {
                return ResourceManager.GetString("RequireHttpsAttribute_MustUseSsl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path segment that contains more than one section, such as a literal section or a parameter, cannot contain a catch-all parameter..
        /// </summary>
        internal static string Route_CannotHaveCatchAllInMultiSegment {
            get {
                return ResourceManager.GetString("Route_CannotHaveCatchAllInMultiSegment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A path segment cannot contain two consecutive parameters. They must be separated by a &apos;/&apos; or by a literal string..
        /// </summary>
        internal static string Route_CannotHaveConsecutiveParameters {
            get {
                return ResourceManager.GetString("Route_CannotHaveConsecutiveParameters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route template separator character &apos;/&apos; cannot appear consecutively. It must be separated by either a parameter or a literal value..
        /// </summary>
        internal static string Route_CannotHaveConsecutiveSeparators {
            get {
                return ResourceManager.GetString("Route_CannotHaveConsecutiveSeparators", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A catch-all parameter can only appear as the last segment of the route template..
        /// </summary>
        internal static string Route_CatchAllMustBeLast {
            get {
                return ResourceManager.GetString("Route_CatchAllMustBeLast", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The constraint entry &apos;{0}&apos; on the route with route template &apos;{1}&apos; must have a string value or be of a type which implements &apos;{2}&apos;..
        /// </summary>
        internal static string Route_InvalidConstraint {
            get {
                return ResourceManager.GetString("Route_InvalidConstraint", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route parameter name &apos;{0}&apos; is invalid. Route parameter names must be non-empty and cannot contain these characters: &quot;{{&quot;, &quot;}}&quot;, &quot;/&quot;, &quot;?&quot;.
        /// </summary>
        internal static string Route_InvalidParameterName {
            get {
                return ResourceManager.GetString("Route_InvalidParameterName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route template cannot start with a &apos;/&apos; or &apos;~&apos; character and it cannot contain a &apos;?&apos; character..
        /// </summary>
        internal static string Route_InvalidRouteTemplate {
            get {
                return ResourceManager.GetString("Route_InvalidRouteTemplate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There is an incomplete parameter in this path segment: &apos;{0}&apos;. Check that each &apos;{{&apos; character has a matching &apos;}}&apos; character..
        /// </summary>
        internal static string Route_MismatchedParameter {
            get {
                return ResourceManager.GetString("Route_MismatchedParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route parameter name &apos;{0}&apos; appears more than one time in the route template..
        /// </summary>
        internal static string Route_RepeatedParameter {
            get {
                return ResourceManager.GetString("Route_RepeatedParameter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The prefix &apos;{0}&apos; of the route area named &apos;{1}&apos; on the controller named &apos;{2}&apos; cannot end with a forward slash..
        /// </summary>
        internal static string RouteAreaPrefix_CannotEnd_WithForwardSlash {
            get {
                return ResourceManager.GetString("RouteAreaPrefix_CannotEnd_WithForwardSlash", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route prefix &apos;{0}&apos; on the controller named &apos;{1}&apos; cannot begin or end with a forward slash..
        /// </summary>
        internal static string RoutePrefix_CannotStartOrEnd_WithForwardSlash {
            get {
                return ResourceManager.GetString("RoutePrefix_CannotStartOrEnd_WithForwardSlash", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Only one route prefix attribute is supported. Remove extra attributes from the controller of type &apos;{0}&apos;..
        /// </summary>
        internal static string RoutePrefix_CannotSupportMultiRoutePrefix {
            get {
                return ResourceManager.GetString("RoutePrefix_CannotSupportMultiRoutePrefix", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The property &apos;prefix&apos; from route prefix attribute on controller of type &apos;{0}&apos; cannot be null..
        /// </summary>
        internal static string RoutePrefix_PrefixCannotBeNull {
            get {
                return ResourceManager.GetString("RoutePrefix_PrefixCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The route template &apos;{0}&apos; on the action named &apos;{1}&apos; on the controller named &apos;{2}&apos; cannot begin with a forward slash..
        /// </summary>
        internal static string RouteTemplate_CannotStart_WithForwardSlash {
            get {
                return ResourceManager.GetString("RouteTemplate_CannotStart_WithForwardSlash", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to determine ModelMetadata for expression &apos;{0}&apos;..
        /// </summary>
        internal static string SelectExtensions_InvalidExpressionParameterNoMetadata {
            get {
                return ResourceManager.GetString("SelectExtensions_InvalidExpressionParameterNoMetadata", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to determine type of expression &apos;{0}&apos;..
        /// </summary>
        internal static string SelectExtensions_InvalidExpressionParameterNoModelType {
            get {
                return ResourceManager.GetString("SelectExtensions_InvalidExpressionParameterNoModelType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return type &apos;{0}&apos; is not supported..
        /// </summary>
        internal static string SelectExtensions_InvalidExpressionParameterType {
            get {
                return ResourceManager.GetString("SelectExtensions_InvalidExpressionParameterType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Return type &apos;{0}&apos; is not supported. Type must not have a &apos;{1}&apos; attribute..
        /// </summary>
        internal static string SelectExtensions_InvalidExpressionParameterTypeHasFlags {
            get {
                return ResourceManager.GetString("SelectExtensions_InvalidExpressionParameterTypeHasFlags", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The SessionStateTempDataProvider class requires session state to be enabled..
        /// </summary>
        internal static string SessionStateTempDataProvider_SessionStateDisabled {
            get {
                return ResourceManager.GetString("SessionStateTempDataProvider_SessionStateDisabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An instance of {0} was found in the resolver as well as a custom registered provider in {1}. Please set only one or the other..
        /// </summary>
        internal static string SingleServiceResolver_CannotRegisterTwoInstances {
            get {
                return ResourceManager.GetString("SingleServiceResolver_CannotRegisterTwoInstances", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A route named &apos;{0}&apos; is already in the route collection. Route names must be unique.
        ///
        ///Duplicates:
        ///{1}
        ///{2}.
        /// </summary>
        internal static string SubRouteCollection_DuplicateRouteName {
            get {
                return ResourceManager.GetString("SubRouteCollection_DuplicateRouteName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An operation that crossed a synchronization context failed. See the inner exception for more information..
        /// </summary>
        internal static string SynchronizationContextUtil_ExceptionThrown {
            get {
                return ResourceManager.GetString("SynchronizationContextUtil_ExceptionThrown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The asynchronous action method &apos;{0}&apos; returns a Task, which cannot be executed synchronously..
        /// </summary>
        internal static string TaskAsyncActionDescriptor_CannotExecuteSynchronously {
            get {
                return ResourceManager.GetString("TaskAsyncActionDescriptor_CannotExecuteSynchronously", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to locate an appropriate template for type {0}..
        /// </summary>
        internal static string TemplateHelpers_NoTemplate {
            get {
                return ResourceManager.GetString("TemplateHelpers_NoTemplate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions..
        /// </summary>
        internal static string TemplateHelpers_TemplateLimitations {
            get {
                return ResourceManager.GetString("TemplateHelpers_TemplateLimitations", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Collection template was used with an object of type &apos;{0}&apos;, which does not implement System.IEnumerable..
        /// </summary>
        internal static string Templates_TypeMustImplementIEnumerable {
            get {
                return ResourceManager.GetString("Templates_TypeMustImplementIEnumerable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This file is automatically generated. Please do not modify the contents of this file..
        /// </summary>
        internal static string TypeCache_DoNotModify {
            get {
                return ResourceManager.GetString("TypeCache_DoNotModify", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0} Object type &apos;{1}&apos;..
        /// </summary>
        internal static string TypeHelpers_CannotCreateInstance {
            get {
                return ResourceManager.GetString("TypeHelpers_CannotCreateInstance", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to {0}.{1} must not return null..
        /// </summary>
        internal static string TypeMethodMustNotReturnNull {
            get {
                return ResourceManager.GetString("TypeMethodMustNotReturnNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model object inside the metadata claimed to be compatible with {0}, but was actually {1}..
        /// </summary>
        internal static string ValidatableObjectAdapter_IncompatibleType {
            get {
                return ResourceManager.GetString("ValidatableObjectAdapter_IncompatibleType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter conversion from type &apos;{0}&apos; to type &apos;{1}&apos; failed. See the inner exception for more information..
        /// </summary>
        internal static string ValueProviderResult_ConversionThrew {
            get {
                return ResourceManager.GetString("ValueProviderResult_ConversionThrew", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter conversion from type &apos;{0}&apos; to type &apos;{1}&apos; failed because no type converter can convert between these types..
        /// </summary>
        internal static string ValueProviderResult_NoConverterExists {
            get {
                return ResourceManager.GetString("ValueProviderResult_NoConverterExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model item passed into the dictionary is null, but this dictionary requires a non-null model item of type &apos;{0}&apos;..
        /// </summary>
        internal static string ViewDataDictionary_ModelCannotBeNull {
            get {
                return ResourceManager.GetString("ViewDataDictionary_ModelCannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The model item passed into the dictionary is of type &apos;{0}&apos;, but this dictionary requires a model item of type &apos;{1}&apos;..
        /// </summary>
        internal static string ViewDataDictionary_WrongTModelType {
            get {
                return ResourceManager.GetString("ViewDataDictionary_WrongTModelType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A ViewMasterPage can be used only with content pages that derive from ViewPage or ViewPage&lt;TModel&gt;..
        /// </summary>
        internal static string ViewMasterPage_RequiresViewPage {
            get {
                return ResourceManager.GetString("ViewMasterPage_RequiresViewPage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Execution of the child request failed. Please examine the InnerException for more information..
        /// </summary>
        internal static string ViewPageHttpHandlerWrapper_ExceptionOccurred {
            get {
                return ResourceManager.GetString("ViewPageHttpHandlerWrapper_ExceptionOccurred", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A ViewStartPage can be used only with with a page that derives from WebViewPage or another ViewStartPage..
        /// </summary>
        internal static string ViewStartPage_RequiresMvcRazorView {
            get {
                return ResourceManager.GetString("ViewStartPage_RequiresMvcRazorView", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ViewUserControl &apos;{0}&apos; cannot find an IViewDataContainer object. The ViewUserControl must be inside a ViewPage, a ViewMasterPage, or another ViewUserControl..
        /// </summary>
        internal static string ViewUserControl_RequiresViewDataProvider {
            get {
                return ResourceManager.GetString("ViewUserControl_RequiresViewDataProvider", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A ViewUserControl can be used only in pages that derive from ViewPage or ViewPage&lt;TModel&gt;..
        /// </summary>
        internal static string ViewUserControl_RequiresViewPage {
            get {
                return ResourceManager.GetString("ViewUserControl_RequiresViewPage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A master name cannot be specified when the view is a ViewUserControl..
        /// </summary>
        internal static string WebFormViewEngine_UserControlCannotHaveMaster {
            get {
                return ResourceManager.GetString("WebFormViewEngine_UserControlCannotHaveMaster", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The view at &apos;{0}&apos; must derive from ViewPage, ViewPage&lt;TModel&gt;, ViewUserControl, or ViewUserControl&lt;TModel&gt;..
        /// </summary>
        internal static string WebFormViewEngine_WrongViewBase {
            get {
                return ResourceManager.GetString("WebFormViewEngine_WrongViewBase", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Properties/MvcResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="ActionMethodSelector_AmbiguousMatch" xml:space="preserve">
    <value>The current request for action '{0}' on controller type '{1}' is ambiguous between the following action methods:{2}</value>
  </data>
  <data name="Common_NoRouteMatched" xml:space="preserve">
    <value>No route in the route table matches the supplied values.</value>
  </data>
  <data name="Common_NullOrEmpty" xml:space="preserve">
    <value>Value cannot be null or empty.</value>
  </data>
  <data name="Common_PartialViewNotFound" xml:space="preserve">
    <value>The partial view '{0}' was not found or no view engine supports the searched locations. The following locations were searched:{1}</value>
  </data>
  <data name="Common_PropertyCannotBeNullOrEmpty" xml:space="preserve">
    <value>The property '{0}' cannot be null or empty.</value>
  </data>
  <data name="Common_ViewNotFound" xml:space="preserve">
    <value>The view '{0}' or its master was not found or no view engine supports the searched locations. The following locations were searched:{1}</value>
  </data>
  <data name="ControllerBuilder_ErrorCreatingControllerFactory" xml:space="preserve">
    <value>An error occurred when trying to create the IControllerFactory '{0}'. Make sure that the controller factory has a public parameterless constructor.</value>
  </data>
  <data name="ControllerBuilder_FactoryReturnedNull" xml:space="preserve">
    <value>The IControllerFactory '{0}' did not return a controller for the name '{1}'.</value>
  </data>
  <data name="ControllerBuilder_MissingIControllerFactory" xml:space="preserve">
    <value>The controller factory type '{0}' must implement the IControllerFactory interface.</value>
  </data>
  <data name="Controller_UnknownAction" xml:space="preserve">
    <value>A public action method '{0}' was not found on controller '{1}'.</value>
  </data>
  <data name="DefaultControllerFactory_ErrorCreatingController" xml:space="preserve">
    <value>An error occurred when trying to create a controller of type '{0}'. Make sure that the controller has a parameterless public constructor.</value>
  </data>
  <data name="DefaultControllerFactory_NoControllerFound" xml:space="preserve">
    <value>The controller for path '{0}' was not found or does not implement IController.</value>
  </data>
  <data name="DefaultControllerFactory_TypeDoesNotSubclassControllerBase" xml:space="preserve">
    <value>The controller type '{0}' must implement IController.</value>
  </data>
  <data name="ValueProviderResult_ConversionThrew" xml:space="preserve">
    <value>The parameter conversion from type '{0}' to type '{1}' failed. See the inner exception for more information.</value>
  </data>
  <data name="ValueProviderResult_NoConverterExists" xml:space="preserve">
    <value>The parameter conversion from type '{0}' to type '{1}' failed because no type converter can convert between these types.</value>
  </data>
  <data name="ExceptionViewAttribute_NonExceptionType" xml:space="preserve">
    <value>The type '{0}' does not inherit from Exception.</value>
  </data>
  <data name="FilterAttribute_OrderOutOfRange" xml:space="preserve">
    <value>Order must be greater than or equal to -1.</value>
  </data>
  <data name="HtmlHelper_MissingSelectData" xml:space="preserve">
    <value>There is no ViewData item of type '{1}' that has the key '{0}'.</value>
  </data>
  <data name="HtmlHelper_TextAreaParameterOutOfRange" xml:space="preserve">
    <value>The value must be greater than or equal to zero.</value>
  </data>
  <data name="HtmlHelper_WrongSelectDataType" xml:space="preserve">
    <value>The ViewData item that has the key '{0}' is of type '{1}' but must be of type '{2}'.</value>
  </data>
  <data name="ModelBinderAttribute_ErrorCreatingModelBinder" xml:space="preserve">
    <value>An error occurred when trying to create the IModelBinder '{0}'. Make sure that the binder has a public parameterless constructor.</value>
  </data>
  <data name="ModelBinderAttribute_TypeNotIModelBinder" xml:space="preserve">
    <value>The type '{0}' does not implement the IModelBinder interface.</value>
  </data>
  <data name="ModelBinderDictionary_MultipleAttributes" xml:space="preserve">
    <value>The type '{0}' contains multiple attributes that inherit from CustomModelBinderAttribute.</value>
  </data>
  <data name="SessionStateTempDataProvider_SessionStateDisabled" xml:space="preserve">
    <value>The SessionStateTempDataProvider class requires session state to be enabled.</value>
  </data>
  <data name="ViewDataDictionary_WrongTModelType" xml:space="preserve">
    <value>The model item passed into the dictionary is of type '{0}', but this dictionary requires a model item of type '{1}'.</value>
  </data>
  <data name="ViewMasterPage_RequiresViewPage" xml:space="preserve">
    <value>A ViewMasterPage can be used only with content pages that derive from ViewPage or ViewPage&lt;TModel&gt;.</value>
  </data>
  <data name="ViewUserControl_RequiresViewDataProvider" xml:space="preserve">
    <value>The ViewUserControl '{0}' cannot find an IViewDataContainer object. The ViewUserControl must be inside a ViewPage, a ViewMasterPage, or another ViewUserControl.</value>
  </data>
  <data name="ViewUserControl_RequiresViewPage" xml:space="preserve">
    <value>A ViewUserControl can be used only in pages that derive from ViewPage or ViewPage&lt;TModel&gt;.</value>
  </data>
  <data name="WebFormViewEngine_UserControlCannotHaveMaster" xml:space="preserve">
    <value>A master name cannot be specified when the view is a ViewUserControl.</value>
  </data>
  <data name="WebFormViewEngine_WrongViewBase" xml:space="preserve">
    <value>The view at '{0}' must derive from ViewPage, ViewPage&lt;TModel&gt;, ViewUserControl, or ViewUserControl&lt;TModel&gt;.</value>
  </data>
  <data name="Common_ValueNotValidForProperty" xml:space="preserve">
    <value>The value '{0}' is invalid.</value>
  </data>
  <data name="ActionMethodSelector_AmbiguousMatchType" xml:space="preserve">
    <value>{0} on type {1}</value>
  </data>
  <data name="Controller_UpdateModel_UpdateUnsuccessful" xml:space="preserve">
    <value>The model of type '{0}' could not be updated.</value>
  </data>
  <data name="DefaultModelBinder_ValueRequired" xml:space="preserve">
    <value>A value is required.</value>
  </data>
  <data name="ReflectedActionDescriptor_ParameterCannotBeNull" xml:space="preserve">
    <value>The parameters dictionary contains a null entry for parameter '{0}' of non-nullable type '{1}' for method '{2}' in '{3}'. An optional parameter must be a reference type, a nullable type, or be declared as an optional parameter.</value>
  </data>
  <data name="ReflectedActionDescriptor_ParameterNotInDictionary" xml:space="preserve">
    <value>The parameters dictionary does not contain an entry for parameter '{0}' of type '{1}' for method '{2}' in '{3}'. The dictionary must contain an entry for each parameter, including parameters that have null values.</value>
  </data>
  <data name="ReflectedActionDescriptor_ParameterValueHasWrongType" xml:space="preserve">
    <value>The parameters dictionary contains an invalid entry for parameter '{0}' for method '{1}' in '{2}'. The dictionary contains a value of type '{3}', but the parameter requires a value of type '{4}'.</value>
  </data>
  <data name="ReflectedParameterBindingInfo_MultipleConverterAttributes" xml:space="preserve">
    <value>The parameter '{0}' on method '{1}' contains multiple attributes that inherit from CustomModelBinderAttribute.</value>
  </data>
  <data name="ReflectedActionDescriptor_CannotCallInstanceMethodOnNonControllerType" xml:space="preserve">
    <value>Cannot create a descriptor for instance method '{0}' on type '{1}' because the type does not derive from ControllerBase.</value>
  </data>
  <data name="ReflectedActionDescriptor_CannotCallMethodsWithOutOrRefParameters" xml:space="preserve">
    <value>Cannot call action method '{0}' on controller '{1}' because the parameter '{2}' is passed by reference.</value>
  </data>
  <data name="ReflectedActionDescriptor_CannotCallOpenGenericMethods" xml:space="preserve">
    <value>Cannot call action method '{0}' on controller '{1}' because the action method is a generic method.</value>
  </data>
  <data name="Route_CannotHaveCatchAllInMultiSegment" xml:space="preserve">
    <value>A path segment that contains more than one section, such as a literal section or a parameter, cannot contain a catch-all parameter.</value>
  </data>
  <data name="Route_CannotHaveConsecutiveParameters" xml:space="preserve">
    <value>A path segment cannot contain two consecutive parameters. They must be separated by a '/' or by a literal string.</value>
  </data>
  <data name="Route_CannotHaveConsecutiveSeparators" xml:space="preserve">
    <value>The route template separator character '/' cannot appear consecutively. It must be separated by either a parameter or a literal value.</value>
  </data>
  <data name="Route_CatchAllMustBeLast" xml:space="preserve">
    <value>A catch-all parameter can only appear as the last segment of the route template.</value>
  </data>
  <data name="Route_InvalidParameterName" xml:space="preserve">
    <value>The route parameter name '{0}' is invalid. Route parameter names must be non-empty and cannot contain these characters: "{{", "}}", "/", "?"</value>
  </data>
  <data name="Route_InvalidRouteTemplate" xml:space="preserve">
    <value>The route template cannot start with a '/' or '~' character and it cannot contain a '?' character.</value>
  </data>
  <data name="Route_MismatchedParameter" xml:space="preserve">
    <value>There is an incomplete parameter in this path segment: '{0}'. Check that each '{{' character has a matching '}}' character.</value>
  </data>
  <data name="Route_RepeatedParameter" xml:space="preserve">
    <value>The route parameter name '{0}' appears more than one time in the route template.</value>
  </data>
  <data name="DefaultViewLocationCache_NegativeTimeSpan" xml:space="preserve">
    <value>The number of ticks for the TimeSpan value must be greater than or equal to 0.</value>
  </data>
  <data name="DefaultModelBinder_ValueInvalid" xml:space="preserve">
    <value>The value '{0}' is not valid for {1}.</value>
  </data>
  <data name="TemplateHelpers_TemplateLimitations" xml:space="preserve">
    <value>Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.</value>
  </data>
  <data name="Common_TriState_False" xml:space="preserve">
    <value>False</value>
  </data>
  <data name="Common_TriState_NotSet" xml:space="preserve">
    <value>Not Set</value>
  </data>
  <data name="Common_TriState_True" xml:space="preserve">
    <value>True</value>
  </data>
  <data name="ControllerBase_CannotHandleMultipleRequests" xml:space="preserve">
    <value>A single instance of controller '{0}' cannot be used to handle multiple requests. If a custom controller factory is in use, make sure that it creates a new instance of the controller for each request.</value>
  </data>
  <data name="Common_PropertyNotFound" xml:space="preserve">
    <value>The property {0}.{1} could not be found.</value>
  </data>
  <data name="DataAnnotationsModelMetadataProvider_UnknownProperty" xml:space="preserve">
    <value>{0} has a DisplayColumn attribute for {1}, but property {1} does not exist.</value>
  </data>
  <data name="DataAnnotationsModelMetadataProvider_UnreadableProperty" xml:space="preserve">
    <value>{0} has a DisplayColumn attribute for {1}, but property {1} does not have a public getter.</value>
  </data>
  <data name="TemplateHelpers_NoTemplate" xml:space="preserve">
    <value>Unable to locate an appropriate template for type {0}.</value>
  </data>
  <data name="RequireHttpsAttribute_MustUseSsl" xml:space="preserve">
    <value>The requested resource can only be accessed via SSL.</value>
  </data>
  <data name="HtmlHelper_InvalidHttpVerb" xml:space="preserve">
    <value>The specified HttpVerbs value is not supported. The supported values are Delete, Head, Put, Options, and Patch.</value>
  </data>
  <data name="HtmlHelper_InvalidHttpMethod" xml:space="preserve">
    <value>The GET and POST HTTP methods are not supported.</value>
  </data>
  <data name="JsonRequest_GetNotAllowed" xml:space="preserve">
    <value>This request has been blocked because sensitive information could be disclosed to third party web sites when this is used in a GET request. To allow GET requests, set JsonRequestBehavior to AllowGet.</value>
  </data>
  <data name="ModelMetadata_PropertyNotSettable" xml:space="preserve">
    <value>This property setter is obsolete, because its value is derived from ModelMetadata.Model now.</value>
  </data>
  <data name="ViewDataDictionary_ModelCannotBeNull" xml:space="preserve">
    <value>The model item passed into the dictionary is null, but this dictionary requires a non-null model item of type '{0}'.</value>
  </data>
  <data name="Common_TypeMustDriveFromType" xml:space="preserve">
    <value>The type {0} must derive from {1}</value>
  </data>
  <data name="DataAnnotationsModelValidatorProvider_ConstructorRequirements" xml:space="preserve">
    <value>The type {0} must have a public constructor which accepts three parameters of types {1}, {2}, and {3}</value>
  </data>
  <data name="ViewPageHttpHandlerWrapper_ExceptionOccurred" xml:space="preserve">
    <value>Execution of the child request failed. Please examine the InnerException for more information.</value>
  </data>
  <data name="RedirectAction_CannotRedirectInChildAction" xml:space="preserve">
    <value>Child actions are not allowed to perform redirect actions.</value>
  </data>
  <data name="AsyncCommon_AsyncResultAlreadyConsumed" xml:space="preserve">
    <value>The provided IAsyncResult has already been consumed.</value>
  </data>
  <data name="AsyncCommon_InvalidAsyncResult" xml:space="preserve">
    <value>The provided IAsyncResult is not valid for this method.</value>
  </data>
  <data name="SynchronizationContextUtil_ExceptionThrown" xml:space="preserve">
    <value>An operation that crossed a synchronization context failed. See the inner exception for more information.</value>
  </data>
  <data name="AsyncCommon_ControllerMustImplementIAsyncManagerContainer" xml:space="preserve">
    <value>The controller of type '{0}' must subclass AsyncController or implement the IAsyncManagerContainer interface.</value>
  </data>
  <data name="AsyncCommon_InvalidTimeout" xml:space="preserve">
    <value>The timeout value must be non-negative or Timeout.Infinite.</value>
  </data>
  <data name="AsyncActionMethodSelector_AmbiguousMethodMatch" xml:space="preserve">
    <value>Lookup for method '{0}' on controller type '{1}' failed because of an ambiguity between the following methods:{2}</value>
  </data>
  <data name="AsyncActionMethodSelector_CouldNotFindMethod" xml:space="preserve">
    <value>Could not locate a method named '{0}' on controller type {1}.</value>
  </data>
  <data name="ChildActionOnlyAttribute_MustBeInChildRequest" xml:space="preserve">
    <value>The action '{0}' is accessible only by a child request.</value>
  </data>
  <data name="Templates_TypeMustImplementIEnumerable" xml:space="preserve">
    <value>The Collection template was used with an object of type '{0}', which does not implement System.IEnumerable.</value>
  </data>
  <data name="TypeCache_DoNotModify" xml:space="preserve">
    <value>This file is automatically generated. Please do not modify the contents of this file.</value>
  </data>
  <data name="ClientDataTypeModelValidatorProvider_FieldMustBeNumeric" xml:space="preserve">
    <value>The field {0} must be a number.</value>
  </data>
  <data name="ExpressionHelper_InvalidIndexerExpression" xml:space="preserve">
    <value>The expression compiler was unable to evaluate the indexer expression '{0}' because it references the model parameter '{1}' which is unavailable.</value>
  </data>
  <data name="Controller_Validate_ValidationFailed" xml:space="preserve">
    <value>The model of type '{0}' is not valid.</value>
  </data>
  <data name="DefaultControllerFactory_ControllerNameAmbiguous_WithoutRouteUrl" xml:space="preserve">
    <value>Multiple types were found that match the controller named '{0}'. This can happen if the route that services this request does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' parameter.{2}{2}The request for '{0}' has found the following matching controllers:{1}</value>
  </data>
  <data name="DefaultControllerFactory_ControllerNameAmbiguous_WithRouteUrl" xml:space="preserve">
    <value>Multiple types were found that match the controller named '{0}'. This can happen if the route that services this request ('{1}') does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' parameter.{3}{3}The request for '{0}' has found the following matching controllers:{2}</value>
  </data>
  <data name="DataAnnotationsModelValidatorProvider_ValidatableConstructorRequirements" xml:space="preserve">
    <value>The type {0} must have a public constructor which accepts two parameters of types {1} and {2}.</value>
  </data>
  <data name="ValidatableObjectAdapter_IncompatibleType" xml:space="preserve">
    <value>The model object inside the metadata claimed to be compatible with {0}, but was actually {1}.</value>
  </data>
  <data name="CshtmlView_ViewCouldNotBeCreated" xml:space="preserve">
    <value>The view found at '{0}' was not created.</value>
  </data>
  <data name="CshtmlView_WrongViewBase" xml:space="preserve">
    <value>The view at '{0}' must derive from WebViewPage, or WebViewPage&lt;TModel&gt;.</value>
  </data>
  <data name="ReflectedActionDescriptor_CannotCallStaticMethod" xml:space="preserve">
    <value>Cannot call action method '{0}' on controller '{1}' because the action method is a static method.</value>
  </data>
  <data name="MvcRazorCodeParser_ModelKeywordMustBeFollowedByTypeName" xml:space="preserve">
    <value>The '{0}' keyword must be followed by a type name on the same line.</value>
  </data>
  <data name="MvcRazorCodeParser_CannotHaveModelAndInheritsKeyword" xml:space="preserve">
    <value>The 'inherits' keyword is not allowed when a '{0}' keyword is used.</value>
  </data>
  <data name="MvcRazorCodeParser_OnlyOneModelStatementIsAllowed" xml:space="preserve">
    <value>Only one '{0}' statement is allowed in a file.</value>
  </data>
  <data name="SingleServiceResolver_CannotRegisterTwoInstances" xml:space="preserve">
    <value>An instance of {0} was found in the resolver as well as a custom registered provider in {1}. Please set only one or the other.</value>
  </data>
  <data name="DependencyResolver_DoesNotImplementICommonServiceLocator" xml:space="preserve">
    <value>The type {0} does not appear to implement Microsoft.Practices.ServiceLocation.IServiceLocator.</value>
  </data>
  <data name="ViewStartPage_RequiresMvcRazorView" xml:space="preserve">
    <value>A ViewStartPage can be used only with with a page that derives from WebViewPage or another ViewStartPage.</value>
  </data>
  <data name="ControllerBase_CannotExecuteWithNullHttpContext" xml:space="preserve">
    <value>Cannot execute Controller with a null HttpContext.</value>
  </data>
  <data name="CompareAttribute_MustMatch" xml:space="preserve">
    <value>'{0}' and '{1}' do not match.</value>
  </data>
  <data name="RemoteAttribute_RemoteValidationFailed" xml:space="preserve">
    <value>'{0}' is invalid.</value>
  </data>
  <data name="RemoteAttribute_NoUrlFound" xml:space="preserve">
    <value>No url for remote validation could be found.</value>
  </data>
  <data name="AuthorizeAttribute_CannotUseWithinChildActionCache" xml:space="preserve">
    <value>AuthorizeAttribute cannot be used within a child action caching block.</value>
  </data>
  <data name="OutputCacheAttribute_InvalidDuration" xml:space="preserve">
    <value>Duration must be a positive number.</value>
  </data>
  <data name="OutputCacheAttribute_InvalidVaryByParam" xml:space="preserve">
    <value>VaryByParam must be '*', 'none', or a semicolon-delimited list of keys.</value>
  </data>
  <data name="OutputCacheAttribute_ChildAction_UnsupportedSetting" xml:space="preserve">
    <value>OutputCacheAttribute for child actions only supports Duration, VaryByCustom, and VaryByParam values. Please do not set CacheProfile, Location, NoStore, SqlDependency, VaryByContentEncoding, or VaryByHeader values for child actions.</value>
  </data>
  <data name="OutputCacheAttribute_CannotNestChildCache" xml:space="preserve">
    <value>OutputCacheAttribute is not allowed on child actions which are children of an already cached child action.</value>
  </data>
  <data name="CompareAttribute_UnknownProperty" xml:space="preserve">
    <value>Could not find a property named {0}.</value>
  </data>
  <data name="HtmlHelper_SelectExpressionNotEnumerable" xml:space="preserve">
    <value>The parameter '{0}' must evaluate to an IEnumerable when multiple selection is allowed.</value>
  </data>
  <data name="MvcRouteHandler_RouteValuesHasNoController" xml:space="preserve">
    <value>The matched route does not include a 'controller' route value, which is required.</value>
  </data>
  <data name="ClientDataTypeModelValidatorProvider_FieldMustBeDate" xml:space="preserve">
    <value>The field {0} must be a date.</value>
  </data>
  <data name="TaskAsyncActionDescriptor_CannotExecuteSynchronously" xml:space="preserve">
    <value>The asynchronous action method '{0}' returns a Task, which cannot be executed synchronously.</value>
  </data>
  <data name="AsyncActionDescriptor_CannotExecuteSynchronously" xml:space="preserve">
    <value>The asynchronous action method '{0}' cannot be executed synchronously.</value>
  </data>
  <data name="MvcForm_ConstructorObsolete" xml:space="preserve">
    <value>This constructor is obsolete, because its functionality has been moved to MvcForm(ViewContext) now.</value>
  </data>
  <data name="JsonValueProviderFactory_RequestTooLarge" xml:space="preserve">
    <value>The JSON request was too large to be deserialized.</value>
  </data>
  <data name="GlobalFilterCollection_UnsupportedFilterInstance" xml:space="preserve">
    <value>The given filter instance must implement one or more of the following filter interfaces: {0}, {1}, {2}, {3}, {4}.</value>
  </data>
  <data name="ArgumentMustBeGreaterThanOrEqualTo" xml:space="preserve">
    <value>Value must be greater than or equal to {0}.</value>
  </data>
  <data name="DefaultInlineConstraintResolver_AmbiguousCtors" xml:space="preserve">
    <value>The constructor to use for activating the constraint type '{0}' is ambiguous. Multiple constructors were found with the following number of parameters: {1}.</value>
  </data>
  <data name="DefaultInlineConstraintResolver_CouldNotFindCtor" xml:space="preserve">
    <value>Could not find a constructor for constraint type '{0}' with the following number of parameters: {1}.</value>
  </data>
  <data name="DefaultInlineConstraintResolver_TypeNotConstraint" xml:space="preserve">
    <value>The constraint type '{0}' which is mapped to constraint key '{1}' must implement the IRouteConstraint interface.</value>
  </data>
  <data name="HttpRouteBuilder_CouldNotResolveConstraint" xml:space="preserve">
    <value>The inline constraint resolver of type '{0}' was unable to resolve the following inline constraint: '{1}'.</value>
  </data>
  <data name="RouteTemplate_CannotStart_WithForwardSlash" xml:space="preserve">
    <value>The route template '{0}' on the action named '{1}' on the controller named '{2}' cannot begin with a forward slash.</value>
  </data>
  <data name="AttributeRouting_CouldNotInferAreaNameFromMissingNamespace" xml:space="preserve">
    <value>Could not infer area name for the controller '{0}' because it does not have a namespace.</value>
  </data>
  <data name="RouteAreaPrefix_CannotEnd_WithForwardSlash" xml:space="preserve">
    <value>The prefix '{0}' of the route area named '{1}' on the controller named '{2}' cannot end with a forward slash.</value>
  </data>
  <data name="RoutePrefix_CannotStartOrEnd_WithForwardSlash" xml:space="preserve">
    <value>The route prefix '{0}' on the controller named '{1}' cannot begin or end with a forward slash.</value>
  </data>
  <data name="TypeHelpers_CannotCreateInstance" xml:space="preserve">
    <value>{0} Object type '{1}'.</value>
  </data>
  <data name="EnumHelper_InvalidMetadataParameter" xml:space="preserve">
    <value>ModelType property must not be null.</value>
  </data>
  <data name="EnumHelper_InvalidValueParameter" xml:space="preserve">
    <value>Invalid value parameter type '{0}'. Must match type parameter '{1}'.</value>
  </data>
  <data name="EnumHelper_InvalidParameterType" xml:space="preserve">
    <value>Type '{0}' is not supported.</value>
  </data>
  <data name="SelectExtensions_InvalidExpressionParameterNoMetadata" xml:space="preserve">
    <value>Unable to determine ModelMetadata for expression '{0}'.</value>
  </data>
  <data name="SelectExtensions_InvalidExpressionParameterNoModelType" xml:space="preserve">
    <value>Unable to determine type of expression '{0}'.</value>
  </data>
  <data name="SelectExtensions_InvalidExpressionParameterType" xml:space="preserve">
    <value>Return type '{0}' is not supported.</value>
  </data>
  <data name="SelectExtensions_InvalidExpressionParameterTypeHasFlags" xml:space="preserve">
    <value>Return type '{0}' is not supported. Type must not have a '{1}' attribute.</value>
  </data>
  <data name="DefaultControllerFactory_DirectRouteAmbiguous" xml:space="preserve">
    <value>Multiple controller types were found that match the URL. This can happen if attribute routes on multiple controllers match the requested URL.{1}{1}The request has found the following matching controller types: {0}</value>
  </data>
  <data name="DirectRoute_AmbiguousMatch" xml:space="preserve">
    <value>The current request is ambiguous between the following action methods:{0}</value>
  </data>
  <data name="Controller_UnknownAction_NoActionName" xml:space="preserve">
    <value>No matching action was found on controller '{0}'. This can happen when a controller uses RouteAttribute for routing, but no action on that controller matches the request.</value>
  </data>
  <data name="DirectRoute_MissingControllerType" xml:space="preserve">
    <value>The route does not have an associated controller type. Routing requires that each direct route map to a single controller type.</value>
  </data>
  <data name="DirectRoute_MissingActionDescriptors" xml:space="preserve">
    <value>The route does not have any associated action descriptors. Routing requires that each direct route map to a non-empty set of actions.</value>
  </data>
  <data name="DirectRoute_MissingControllerDescriptor" xml:space="preserve">
    <value>The route does not have an associated controller descriptor. Routing requires that each direct route map to a single controller.</value>
  </data>
  <data name="SubRouteCollection_DuplicateRouteName" xml:space="preserve">
    <value>A route named '{0}' is already in the route collection. Route names must be unique.

Duplicates:
{1}
{2}</value>
  </data>
  <data name="TypeMethodMustNotReturnNull" xml:space="preserve">
    <value>{0}.{1} must not return null.</value>
  </data>
  <data name="RoutePrefix_CannotSupportMultiRoutePrefix" xml:space="preserve">
    <value>Only one route prefix attribute is supported. Remove extra attributes from the controller of type '{0}'.</value>
  </data>
  <data name="RoutePrefix_PrefixCannotBeNull" xml:space="preserve">
    <value>The property 'prefix' from route prefix attribute on controller of type '{0}' cannot be null.</value>
  </data>
  <data name="Route_InvalidConstraint" xml:space="preserve">
    <value>The constraint entry '{0}' on the route with route template '{1}' must have a string value or be of a type which implements '{2}'.</value>
  </data>
  <data name="DirectRoute_RouteHandlerNotSupported" xml:space="preserve">
    <value>Direct routing does not support per-route route handlers.</value>
  </data>
  <data name="DirectRoute_InvalidParameter_Action" xml:space="preserve">
    <value>A direct route for an action method cannot use the parameter 'action'. Specify a literal path in place of this parameter to create a route to the action.</value>
  </data>
  <data name="DirectRoute_InvalidParameter_Controller" xml:space="preserve">
    <value>A direct route cannot use the parameter 'controller'. Specify a literal path in place of this parameter to create a route to a controller.</value>
  </data>
  <data name="JQuerySyntaxMissingClosingBracket" xml:space="preserve">
    <value>The key is invalid JQuery syntax because it is missing a closing bracket.</value>
  </data>
</root>

================================================
FILE: src/System.Web.Mvc/QueryStringValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Helpers;

namespace System.Web.Mvc
{
    public sealed class QueryStringValueProvider : NameValueCollectionValueProvider
    {
        // QueryString should use the invariant culture since it's part of the URL, and the URL should be
        // interpreted in a uniform fashion regardless of the origin of a particular request.
        public QueryStringValueProvider(ControllerContext controllerContext)
            : this(controllerContext, new UnvalidatedRequestValuesWrapper(controllerContext.HttpContext.Request.Unvalidated))
        {
        }

        // For unit testing
        internal QueryStringValueProvider(ControllerContext controllerContext, IUnvalidatedRequestValues unvalidatedValues)
            : base(controllerContext.HttpContext.Request.QueryString, unvalidatedValues.QueryString, CultureInfo.InvariantCulture)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/QueryStringValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Helpers;

namespace System.Web.Mvc
{
    public sealed class QueryStringValueProviderFactory : ValueProviderFactory
    {
        private readonly UnvalidatedRequestValuesAccessor _unvalidatedValuesAccessor;

        public QueryStringValueProviderFactory()
            : this(null)
        {
        }

        // For unit testing
        internal QueryStringValueProviderFactory(UnvalidatedRequestValuesAccessor unvalidatedValuesAccessor)
        {
            _unvalidatedValuesAccessor = unvalidatedValuesAccessor ?? (cc => new UnvalidatedRequestValuesWrapper(cc.HttpContext.Request.Unvalidated));
        }

        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            return new QueryStringValueProvider(controllerContext, _unvalidatedValuesAccessor(controllerContext));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RangeAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    public class RangeAttributeAdapter : DataAnnotationsModelValidator<RangeAttribute>
    {
        public RangeAttributeAdapter(ModelMetadata metadata, ControllerContext context, RangeAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            string errorMessage = ErrorMessage; // Per Dev10 Bug #923283, need to make sure ErrorMessage is called before Minimum/Maximum
            return new[] { new ModelClientValidationRangeRule(errorMessage, Attribute.Minimum, Attribute.Maximum) };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Razor/MvcCSharpRazorCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.Razor;
using System.Web.Razor.Generator;

namespace System.Web.Mvc.Razor
{
    internal class MvcCSharpRazorCodeGenerator : CSharpRazorCodeGenerator
    {
        private const string DefaultModelTypeName = "dynamic";

        public MvcCSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host)
            : base(className, rootNamespaceName, sourceFileName, host)
        {
            var mvcHost = host as MvcWebPageRazorHost;
            if (mvcHost != null && !mvcHost.IsSpecialPage)
            {
                // set the default model type to "dynamic" (Dev10 bug 935656)
                // don't set it for "special" pages (such as "_viewStart.cshtml")
                SetBaseType(DefaultModelTypeName);
            }
        }

        private void SetBaseType(string modelTypeName)
        {
            var baseType = new CodeTypeReference(Context.Host.DefaultBaseClass + "<" + modelTypeName + ">");
            Context.GeneratedClass.BaseTypes.Clear();
            Context.GeneratedClass.BaseTypes.Add(baseType);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Razor/MvcCSharpRazorCodeParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Mvc.Properties;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Text;

namespace System.Web.Mvc.Razor
{
    public class MvcCSharpRazorCodeParser : CSharpCodeParser
    {
        private const string ModelKeyword = "model";
        private const string GenericTypeFormatString = "{0}<{1}>";
        private SourceLocation? _endInheritsLocation;
        private bool _modelStatementFound;

        public MvcCSharpRazorCodeParser()
        {
            MapDirectives(ModelDirective, ModelKeyword);
        }

        protected override void InheritsDirective()
        {
            // Verify we're on the right keyword and accept
            AssertDirective(SyntaxConstants.CSharp.InheritsKeyword);
            AcceptAndMoveNext();
            _endInheritsLocation = CurrentLocation;

            InheritsDirectiveCore();
            CheckForInheritsAndModelStatements();
        }

        private void CheckForInheritsAndModelStatements()
        {
            if (_modelStatementFound && _endInheritsLocation.HasValue)
            {
                Context.OnError(_endInheritsLocation.Value, String.Format(CultureInfo.CurrentCulture, MvcResources.MvcRazorCodeParser_CannotHaveModelAndInheritsKeyword, ModelKeyword));
            }
        }

        protected virtual void ModelDirective()
        {
            // Verify we're on the right keyword and accept
            AssertDirective(ModelKeyword);
            AcceptAndMoveNext();

            SourceLocation endModelLocation = CurrentLocation;

            BaseTypeDirective(
                String.Format(CultureInfo.CurrentCulture,
                              MvcResources.MvcRazorCodeParser_ModelKeywordMustBeFollowedByTypeName, ModelKeyword),
                CreateModelCodeGenerator);

            if (_modelStatementFound)
            {
                Context.OnError(endModelLocation, String.Format(CultureInfo.CurrentCulture, MvcResources.MvcRazorCodeParser_OnlyOneModelStatementIsAllowed, ModelKeyword));
            }

            _modelStatementFound = true;

            CheckForInheritsAndModelStatements();
        }

        private SpanCodeGenerator CreateModelCodeGenerator(string model)
        {
            return new SetModelTypeCodeGenerator(model, GenericTypeFormatString);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Razor/MvcVBRazorCodeParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Linq;
using System.Web.Mvc.Properties;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Mvc.Razor
{
    public class MvcVBRazorCodeParser : VBCodeParser
    {
        internal const string ModelTypeKeyword = "ModelType";
        private const string GenericTypeFormatString = "{0}(Of {1})";
        private SourceLocation? _endInheritsLocation;
        private bool _modelStatementFound;

        public MvcVBRazorCodeParser()
        {
            MapDirective(ModelTypeKeyword, ModelTypeDirective);
        }

        protected override bool InheritsStatement()
        {
            // Verify we're on the right keyword and accept
            Assert(VBKeyword.Inherits);
            VBSymbol inherits = CurrentSymbol;
            NextToken();
            _endInheritsLocation = CurrentLocation;
            PutCurrentBack();
            PutBack(inherits);
            EnsureCurrent();

            bool result = base.InheritsStatement();
            CheckForInheritsAndModelStatements();
            return result;
        }

        private void CheckForInheritsAndModelStatements()
        {
            if (_modelStatementFound && _endInheritsLocation.HasValue)
            {
                Context.OnError(_endInheritsLocation.Value, String.Format(CultureInfo.CurrentCulture, MvcResources.MvcRazorCodeParser_CannotHaveModelAndInheritsKeyword, ModelTypeKeyword));
            }
        }

        protected virtual bool ModelTypeDirective()
        {
            AssertDirective(ModelTypeKeyword);

            Span.CodeGenerator = SpanCodeGenerator.Null;
            Context.CurrentBlock.Type = BlockType.Directive;

            AcceptAndMoveNext();
            SourceLocation endModelLocation = CurrentLocation;

            if (At(VBSymbolType.WhiteSpace))
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }

            AcceptWhile(VBSymbolType.WhiteSpace);
            Output(SpanKind.MetaCode);

            if (_modelStatementFound)
            {
                Context.OnError(endModelLocation, String.Format(CultureInfo.CurrentCulture, MvcResources.MvcRazorCodeParser_OnlyOneModelStatementIsAllowed, ModelTypeKeyword));
            }
            _modelStatementFound = true;

            if (EndOfFile || At(VBSymbolType.WhiteSpace) || At(VBSymbolType.NewLine))
            {
                Context.OnError(endModelLocation, MvcResources.MvcRazorCodeParser_ModelKeywordMustBeFollowedByTypeName, ModelTypeKeyword);
            }

            // Just accept to a newline
            AcceptUntil(VBSymbolType.NewLine);
            if (!Context.DesignTimeMode)
            {
                // We want the newline to be treated as code, but it causes issues at design-time.
                Optional(VBSymbolType.NewLine);
            }

            string baseType = String.Concat(Span.Symbols.Select(s => s.Content)).Trim();
            Span.CodeGenerator = new SetModelTypeCodeGenerator(baseType, GenericTypeFormatString);

            CheckForInheritsAndModelStatements();
            Output(SpanKind.Code);
            return false;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Razor/MvcWebPageRazorHost.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.WebPages.Razor;

namespace System.Web.Mvc.Razor
{
    [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "WebPage", Justification = "The class name is derived from the name of the base type")]
    public class MvcWebPageRazorHost : WebPageRazorHost
    {
        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The NamespaceImports property should not be virtual. This is a temporary fix.")]
        public MvcWebPageRazorHost(string virtualPath, string physicalPath)
            : base(virtualPath, physicalPath)
        {
            RegisterSpecialFile(RazorViewEngine.ViewStartFileName, typeof(ViewStartPage));

            DefaultPageBaseClass = typeof(WebViewPage).FullName;

            // REVIEW get rid of the namespace import to not force additional references in default MVC projects
            GetRidOfNamespace("System.Web.WebPages.Html");
        }

        public override RazorCodeGenerator DecorateCodeGenerator(RazorCodeGenerator incomingCodeGenerator)
        {
            if (incomingCodeGenerator is CSharpRazorCodeGenerator)
            {
                return new MvcCSharpRazorCodeGenerator(incomingCodeGenerator.ClassName,
                                                       incomingCodeGenerator.RootNamespaceName,
                                                       incomingCodeGenerator.SourceFileName,
                                                       incomingCodeGenerator.Host);
            }
            else
            {
                return base.DecorateCodeGenerator(incomingCodeGenerator);
            }
        }

        public override ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
        {
            if (incomingCodeParser is CSharpCodeParser)
            {
                return new MvcCSharpRazorCodeParser();
            }
            else if (incomingCodeParser is VBCodeParser)
            {
                return new MvcVBRazorCodeParser();
            }
            else
            {
                return base.DecorateCodeParser(incomingCodeParser);
            }
        }

        private void GetRidOfNamespace(string ns)
        {
            Debug.Assert(NamespaceImports.Contains(ns), ns + " is not a default namespace anymore");
            if (NamespaceImports.Contains(ns))
            {
                NamespaceImports.Remove(ns);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Razor/SetModelTypeCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Mvc.ExpressionUtil;
using System.Web.Razor.Generator;

namespace System.Web.Mvc.Razor
{
    internal class SetModelTypeCodeGenerator : SetBaseTypeCodeGenerator
    {
        private string _genericTypeFormat;

        public SetModelTypeCodeGenerator(string modelType, string genericTypeFormat)
            : base(modelType)
        {
            _genericTypeFormat = genericTypeFormat;
        }

        protected override string ResolveType(CodeGeneratorContext context, string baseType)
        {
            return String.Format(
                CultureInfo.InvariantCulture,
                _genericTypeFormat,
                context.Host.DefaultBaseClass,
                baseType);
        }

        public override bool Equals(object obj)
        {
            SetModelTypeCodeGenerator other = obj as SetModelTypeCodeGenerator;
            return other != null &&
                   base.Equals(obj) &&
                   String.Equals(_genericTypeFormat, other._genericTypeFormat, StringComparison.Ordinal);
        }

        public override int GetHashCode()
        {
            var combiner = new HashCodeCombiner();
            combiner.AddInt32(base.GetHashCode());
            combiner.AddObject(_genericTypeFormat);
            return combiner.CombinedHash;
        }

        public override string ToString()
        {
            return "Model:" + BaseType;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Razor/StartPageLookupDelegate.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages;

namespace System.Web.Mvc.Razor
{
    internal delegate WebPageRenderingBase StartPageLookupDelegate(WebPageRenderingBase page, string fileName, IEnumerable<string> supportedExtensions);
}


================================================
FILE: src/System.Web.Mvc/RazorView.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Razor;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    public class RazorView : BuildManagerCompiledView
    {
        public RazorView(ControllerContext controllerContext, string viewPath, string layoutPath, bool runViewStartPages, IEnumerable<string> viewStartFileExtensions)
            : this(controllerContext, viewPath, layoutPath, runViewStartPages, viewStartFileExtensions, null)
        {
        }

        public RazorView(ControllerContext controllerContext, string viewPath, string layoutPath, bool runViewStartPages, IEnumerable<string> viewStartFileExtensions, IViewPageActivator viewPageActivator)
            : base(controllerContext, viewPath, viewPageActivator)
        {
            LayoutPath = layoutPath ?? String.Empty;
            RunViewStartPages = runViewStartPages;
            StartPageLookup = StartPage.GetStartPage;
            ViewStartFileExtensions = viewStartFileExtensions ?? Enumerable.Empty<string>();
        }

        public string LayoutPath { get; private set; }

        public bool RunViewStartPages { get; private set; }

        internal StartPageLookupDelegate StartPageLookup { get; set; }

        internal IVirtualPathFactory VirtualPathFactory { get; set; }

        internal DisplayModeProvider DisplayModeProvider { get; set; }

        public IEnumerable<string> ViewStartFileExtensions { get; private set; }

        protected override void RenderView(ViewContext viewContext, TextWriter writer, object instance)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }

            WebViewPage webViewPage = instance as WebViewPage;
            if (webViewPage == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.CshtmlView_WrongViewBase,
                        ViewPath));
            }

            // An overriden master layout might have been specified when the ViewActionResult got returned.
            // We need to hold on to it so that we can set it on the inner page once it has executed.
            webViewPage.OverridenLayoutPath = LayoutPath;
            webViewPage.VirtualPath = ViewPath;
            webViewPage.ViewContext = viewContext;
            webViewPage.ViewData = viewContext.ViewData;

            webViewPage.InitHelpers();

            if (VirtualPathFactory != null)
            {
                webViewPage.VirtualPathFactory = VirtualPathFactory;
            }
            if (DisplayModeProvider != null)
            {
                webViewPage.DisplayModeProvider = DisplayModeProvider;
            }

            WebPageRenderingBase startPage = null;
            if (RunViewStartPages)
            {
                startPage = StartPageLookup(webViewPage, RazorViewEngine.ViewStartFileName, ViewStartFileExtensions);
            }
            webViewPage.ExecutePageHierarchy(new WebPageContext(context: viewContext.HttpContext, page: null, model: null), writer, startPage);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RazorViewEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class RazorViewEngine : BuildManagerViewEngine
    {
        internal static readonly string ViewStartFileName = "_ViewStart";

        public RazorViewEngine()
            : this(null)
        {
        }

        public RazorViewEngine(IViewPageActivator viewPageActivator)
            : base(viewPageActivator)
        {
            AreaViewLocationFormats = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.cshtml",
                "~/Areas/{2}/Views/{1}/{0}.vbhtml",
                "~/Areas/{2}/Views/Shared/{0}.cshtml",
                "~/Areas/{2}/Views/Shared/{0}.vbhtml"
            };
            AreaMasterLocationFormats = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.cshtml",
                "~/Areas/{2}/Views/{1}/{0}.vbhtml",
                "~/Areas/{2}/Views/Shared/{0}.cshtml",
                "~/Areas/{2}/Views/Shared/{0}.vbhtml"
            };
            AreaPartialViewLocationFormats = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.cshtml",
                "~/Areas/{2}/Views/{1}/{0}.vbhtml",
                "~/Areas/{2}/Views/Shared/{0}.cshtml",
                "~/Areas/{2}/Views/Shared/{0}.vbhtml"
            };

            ViewLocationFormats = new[]
            {
                "~/Views/{1}/{0}.cshtml",
                "~/Views/{1}/{0}.vbhtml",
                "~/Views/Shared/{0}.cshtml",
                "~/Views/Shared/{0}.vbhtml"
            };
            MasterLocationFormats = new[]
            {
                "~/Views/{1}/{0}.cshtml",
                "~/Views/{1}/{0}.vbhtml",
                "~/Views/Shared/{0}.cshtml",
                "~/Views/Shared/{0}.vbhtml"
            };
            PartialViewLocationFormats = new[]
            {
                "~/Views/{1}/{0}.cshtml",
                "~/Views/{1}/{0}.vbhtml",
                "~/Views/Shared/{0}.cshtml",
                "~/Views/Shared/{0}.vbhtml"
            };

            FileExtensions = new[]
            {
                "cshtml",
                "vbhtml",
            };
        }

        protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
        {
            return new RazorView(controllerContext, partialPath,
                                 layoutPath: null, runViewStartPages: false, viewStartFileExtensions: FileExtensions, viewPageActivator: ViewPageActivator)
            {
                DisplayModeProvider = DisplayModeProvider
            };
        }

        protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
        {
            var view = new RazorView(controllerContext, viewPath,
                                     layoutPath: masterPath, runViewStartPages: true, viewStartFileExtensions: FileExtensions, viewPageActivator: ViewPageActivator)
            {
                DisplayModeProvider = DisplayModeProvider
            };
            return view;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ReaderWriterCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Threading;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "Instances of this type are meant to be singletons.")]
    internal abstract class ReaderWriterCache<TKey, TValue>
    {
        private readonly Dictionary<TKey, TValue> _cache;
        private readonly ReaderWriterLockSlim _readerWriterLock = new ReaderWriterLockSlim();

        protected ReaderWriterCache()
            : this(null)
        {
        }

        protected ReaderWriterCache(IEqualityComparer<TKey> comparer)
        {
            _cache = new Dictionary<TKey, TValue>(comparer);
        }

        protected Dictionary<TKey, TValue> Cache
        {
            get { return _cache; }
        }

        protected TValue FetchOrCreateItem(TKey key, Func<TValue> creator)
        {
            // Passing the delegate as an argument allows the inline delegate to be static
            return FetchOrCreateItem(key, (Func<TValue> innerCreator) => innerCreator(), creator);
        }

        protected TValue FetchOrCreateItem<TArgument>(TKey key, Func<TArgument, TValue> creator, TArgument state)
        {
            // first, see if the item already exists in the cache
            _readerWriterLock.EnterReadLock();
            try
            {
                TValue existingEntry;
                if (_cache.TryGetValue(key, out existingEntry))
                {
                    return existingEntry;
                }
            }
            finally
            {
                _readerWriterLock.ExitReadLock();
            }

            // insert the new item into the cache
            TValue newEntry = creator(state);
            _readerWriterLock.EnterWriteLock();
            try
            {
                TValue existingEntry;
                if (_cache.TryGetValue(key, out existingEntry))
                {
                    // another thread already inserted an item, so use that one
                    return existingEntry;
                }

                _cache[key] = newEntry;
                return newEntry;
            }
            finally
            {
                _readerWriterLock.ExitWriteLock();
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RedirectResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    // represents a result that performs a redirection given some URI
    public class RedirectResult : ActionResult
    {
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "Response.Redirect() takes its URI as a string parameter.")]
        public RedirectResult(string url)
            : this(url, permanent: false)
        {
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "Response.Redirect() takes its URI as a string parameter.")]
        public RedirectResult(string url, bool permanent)
        {
            if (String.IsNullOrEmpty(url))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "url");
            }

            Permanent = permanent;
            Url = url;
        }

        public bool Permanent { get; private set; }

        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "Response.Redirect() takes its URI as a string parameter.")]
        public string Url { get; private set; }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (context.IsChildAction)
            {
                throw new InvalidOperationException(MvcResources.RedirectAction_CannotRedirectInChildAction);
            }

            string destinationUrl = UrlHelper.GenerateContentUrl(Url, context.HttpContext);
            context.Controller.TempData.Keep();

            if (Permanent)
            {
                context.HttpContext.Response.RedirectPermanent(destinationUrl, endResponse: false);
            }
            else
            {
                context.HttpContext.Response.Redirect(destinationUrl, endResponse: false);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RedirectToRouteResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc
{
    // represents a result that performs a redirection given some values dictionary
    public class RedirectToRouteResult : ActionResult
    {
        private RouteCollection _routes;

        public RedirectToRouteResult(RouteValueDictionary routeValues)
            :
                this(null, routeValues)
        {
        }

        public RedirectToRouteResult(string routeName, RouteValueDictionary routeValues)
            : this(routeName, routeValues, permanent: false)
        {
        }

        public RedirectToRouteResult(string routeName, RouteValueDictionary routeValues, bool permanent)
        {
            Permanent = permanent;
            RouteName = routeName ?? String.Empty;
            RouteValues = routeValues ?? new RouteValueDictionary();
        }

        public bool Permanent { get; private set; }

        public string RouteName { get; private set; }

        public RouteValueDictionary RouteValues { get; private set; }

        internal RouteCollection Routes
        {
            get
            {
                if (_routes == null)
                {
                    _routes = RouteTable.Routes;
                }
                return _routes;
            }
            set { _routes = value; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (context.IsChildAction)
            {
                throw new InvalidOperationException(MvcResources.RedirectAction_CannotRedirectInChildAction);
            }

            string destinationUrl = UrlHelper.GenerateUrl(RouteName, null /* actionName */, null /* controllerName */, RouteValues, Routes, context.RequestContext, false /* includeImplicitMvcValues */);
            if (String.IsNullOrEmpty(destinationUrl))
            {
                throw new InvalidOperationException(MvcResources.Common_NoRouteMatched);
            }

            context.Controller.TempData.Keep();

            if (Permanent)
            {
                context.HttpContext.Response.RedirectPermanent(destinationUrl, endResponse: false);
            }
            else
            {
                context.HttpContext.Response.Redirect(destinationUrl, endResponse: false);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ReflectedActionDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ReflectedActionDescriptor : ActionDescriptor, IMethodInfoActionDescriptor
    {
        private readonly string _actionName;
        private readonly ControllerDescriptor _controllerDescriptor;
        private string _uniqueId;
        private ParameterDescriptor[] _parametersCache;

        public ReflectedActionDescriptor(MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor)
            : this(methodInfo, actionName, controllerDescriptor, true /* validateMethod */)
        {
        }

        internal ReflectedActionDescriptor(MethodInfo methodInfo, string actionName, ControllerDescriptor controllerDescriptor, bool validateMethod)
        {
            if (methodInfo == null)
            {
                throw new ArgumentNullException("methodInfo");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
            }
            if (controllerDescriptor == null)
            {
                throw new ArgumentNullException("controllerDescriptor");
            }

            if (validateMethod)
            {
                string failedMessage = VerifyActionMethodIsCallable(methodInfo);
                if (failedMessage != null)
                {
                    throw new ArgumentException(failedMessage, "methodInfo");
                }
            }

            MethodInfo = methodInfo;
            _actionName = actionName;
            _controllerDescriptor = controllerDescriptor;
        }

        public override string ActionName
        {
            get { return _actionName; }
        }

        public override ControllerDescriptor ControllerDescriptor
        {
            get { return _controllerDescriptor; }
        }

        public MethodInfo MethodInfo { get; private set; }

        public override string UniqueId
        {
            get 
            {
                if (_uniqueId == null)
                {
                    _uniqueId = CreateUniqueId();
                }
                return _uniqueId; 
            }
        }

        private string CreateUniqueId()
        {
            var builder = new StringBuilder(base.UniqueId);
            DescriptorUtil.AppendUniqueId(builder, MethodInfo);
            return builder.ToString();
        }

        public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (parameters == null)
            {
                throw new ArgumentNullException("parameters");
            }

            // Performance sensitive so avoid Linq or delegates.
            ParameterInfo[] parameterInfos = MethodInfo.GetParameters();
            object[] parametersArray = new object[parameterInfos.Length];
            for (int i = 0; i < parameterInfos.Length; i++)
            {
                ParameterInfo parameterInfo = parameterInfos[i];
                object parameter = ExtractParameterFromDictionary(parameterInfo, parameters, MethodInfo);
                parametersArray[i] = parameter;
            }

            ActionMethodDispatcher dispatcher = DispatcherCache.GetDispatcher(MethodInfo);
            object actionReturnValue = dispatcher.Execute(controllerContext.Controller, parametersArray);
            return actionReturnValue;
        }

        public override object[] GetCustomAttributes(bool inherit)
        {
            return ActionDescriptorHelper.GetCustomAttributes(MethodInfo, inherit);
        }

        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return ActionDescriptorHelper.GetCustomAttributes(MethodInfo, attributeType, inherit);
        }

        public override IEnumerable<FilterAttribute> GetFilterAttributes(bool useCache)
        {
            if (useCache && GetType() == typeof(ReflectedActionDescriptor))
            {
                // Do not look at cache in types derived from this type because they might incorrectly implement GetCustomAttributes
                return ReflectedAttributeCache.GetMethodFilterAttributes(MethodInfo);
            }
            return base.GetFilterAttributes(useCache);
        }

        public override ParameterDescriptor[] GetParameters()
        {
            return ActionDescriptorHelper.GetParameters(this, MethodInfo, ref _parametersCache);
        }

        public override ICollection<ActionSelector> GetSelectors()
        {
            return ActionDescriptorHelper.GetSelectors(MethodInfo);
        }

        internal override ICollection<ActionNameSelector> GetNameSelectors()
        {
            return ActionDescriptorHelper.GetNameSelectors(MethodInfo);
        }

        public override bool IsDefined(Type attributeType, bool inherit)
        {
            return ActionDescriptorHelper.IsDefined(MethodInfo, attributeType, inherit);
        }

        internal static ReflectedActionDescriptor TryCreateDescriptor(MethodInfo methodInfo, string name, ControllerDescriptor controllerDescriptor)
        {
            ReflectedActionDescriptor descriptor = new ReflectedActionDescriptor(methodInfo, name, controllerDescriptor, false /* validateMethod */);
            string failedMessage = VerifyActionMethodIsCallable(methodInfo);
            return (failedMessage == null) ? descriptor : null;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ReflectedAttributeCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;

namespace System.Web.Mvc
{
    internal static class ReflectedAttributeCache
    {
        private static readonly ConcurrentDictionary<MethodInfo, ReadOnlyCollection<ActionMethodSelectorAttribute>> _actionMethodSelectorAttributeCache = new ConcurrentDictionary<MethodInfo, ReadOnlyCollection<ActionMethodSelectorAttribute>>();
        private static readonly ConcurrentDictionary<MethodInfo, ReadOnlyCollection<ActionNameSelectorAttribute>> _actionNameSelectorAttributeCache = new ConcurrentDictionary<MethodInfo, ReadOnlyCollection<ActionNameSelectorAttribute>>();
        private static readonly ConcurrentDictionary<MethodInfo, ReadOnlyCollection<FilterAttribute>> _methodFilterAttributeCache = new ConcurrentDictionary<MethodInfo, ReadOnlyCollection<FilterAttribute>>();

        private static readonly ConcurrentDictionary<Type, ReadOnlyCollection<FilterAttribute>> _typeFilterAttributeCache = new ConcurrentDictionary<Type, ReadOnlyCollection<FilterAttribute>>();

        public static ReadOnlyCollection<FilterAttribute> GetTypeFilterAttributes(Type type)
        {
            return GetAttributes(_typeFilterAttributeCache, type);
        }

        public static ReadOnlyCollection<FilterAttribute> GetMethodFilterAttributes(MethodInfo methodInfo)
        {
            return GetAttributes(_methodFilterAttributeCache, methodInfo);
        }

        public static ReadOnlyCollection<ActionMethodSelectorAttribute> GetActionMethodSelectorAttributesCollection(MethodInfo methodInfo)
        {
            return GetAttributes(_actionMethodSelectorAttributeCache, methodInfo);
        }

        public static ReadOnlyCollection<ActionNameSelectorAttribute> GetActionNameSelectorAttributes(MethodInfo methodInfo)
        {
            return GetAttributes(_actionNameSelectorAttributeCache, methodInfo);
        }

        private static ReadOnlyCollection<TAttribute> GetAttributes<TMemberInfo, TAttribute>(ConcurrentDictionary<TMemberInfo, ReadOnlyCollection<TAttribute>> lookup, TMemberInfo memberInfo)
            where TAttribute : Attribute
            where TMemberInfo : MemberInfo
        {
            Debug.Assert(memberInfo != null);
            Debug.Assert(lookup != null);
            // Frequently called, so use a static delegate
            // An inline delegate cannot be used because the C# compiler does not cache inline delegates that reference generic method arguments
            return lookup.GetOrAdd(
                memberInfo,
                CachedDelegates<TMemberInfo, TAttribute>.GetCustomAttributes);
        }

        private static class CachedDelegates<TMemberInfo, TAttribute>
            where TAttribute : Attribute
            where TMemberInfo : MemberInfo
        {
            internal static Func<TMemberInfo, ReadOnlyCollection<TAttribute>> GetCustomAttributes = (TMemberInfo memberInfo) =>
            {
                return new ReadOnlyCollection<TAttribute>((TAttribute[])memberInfo.GetCustomAttributes(typeof(TAttribute), inherit: true));
            };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ReflectedControllerDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ReflectedControllerDescriptor : ControllerDescriptor
    {
        private readonly Type _controllerType;
        private readonly ActionMethodSelector _selector;
        private ActionDescriptor[] _canonicalActionsCache;

        public ReflectedControllerDescriptor(Type controllerType)
        {
            if (controllerType == null)
            {
                throw new ArgumentNullException("controllerType");
            }

            _controllerType = controllerType;
            _selector = new ActionMethodSelector(_controllerType);
        }

        public sealed override Type ControllerType
        {
            get { return _controllerType; }
        }

        public override ActionDescriptor FindAction(ControllerContext controllerContext, string actionName)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (String.IsNullOrEmpty(actionName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "actionName");
            }

            MethodInfo matched = _selector.FindActionMethod(controllerContext, actionName);
            if (matched == null)
            {
                return null;
            }

            return new ReflectedActionDescriptor(matched, actionName, this);
        }

        private MethodInfo[] GetAllActionMethodsFromSelector()
        {
            return _selector.StandardRouteMethods.ToArray();
        }

        public override ActionDescriptor[] GetCanonicalActions()
        {
            ActionDescriptor[] actions = LazilyFetchCanonicalActionsCollection();

            // need to clone array so that user modifications aren't accidentally stored
            return (ActionDescriptor[])actions.Clone();
        }

        public override object[] GetCustomAttributes(bool inherit)
        {
            return ControllerType.GetCustomAttributes(inherit);
        }

        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return ControllerType.GetCustomAttributes(attributeType, inherit);
        }

        public override IEnumerable<FilterAttribute> GetFilterAttributes(bool useCache)
        {
            if (useCache && GetType() == typeof(ReflectedControllerDescriptor))
            {
                // Do not look at cache in types derived from this type because they might incorrectly implement GetCustomAttributes
                return ReflectedAttributeCache.GetTypeFilterAttributes(ControllerType);
            }
            return base.GetFilterAttributes(useCache);
        }

        public override bool IsDefined(Type attributeType, bool inherit)
        {
            return ControllerType.IsDefined(attributeType, inherit);
        }

        private ActionDescriptor[] LazilyFetchCanonicalActionsCollection()
        {
            return DescriptorUtil.LazilyFetchOrCreateDescriptors(
                cacheLocation: ref _canonicalActionsCache,
                initializer: (ReflectedControllerDescriptor state) => state.GetAllActionMethodsFromSelector(),
                converter: (MethodInfo methodInfo, ReflectedControllerDescriptor state) => ReflectedActionDescriptor.TryCreateDescriptor(methodInfo, methodInfo.Name, state),
                state: this);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ReflectedParameterBindingInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Reflection;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    internal class ReflectedParameterBindingInfo : ParameterBindingInfo
    {
        private readonly ParameterInfo _parameterInfo;
        private ICollection<string> _exclude = new string[0];
        private ICollection<string> _include = new string[0];
        private string _prefix;

        public ReflectedParameterBindingInfo(ParameterInfo parameterInfo)
        {
            _parameterInfo = parameterInfo;
            ReadSettingsFromBindAttribute();
        }

        public override IModelBinder Binder
        {
            get
            {
                IModelBinder binder = ModelBinders.GetBinderFromAttributes(
                    _parameterInfo,
                    (ICustomAttributeProvider errorArg) =>
                    {
                        ParameterInfo parameterInfo = (ParameterInfo)errorArg;
                        throw new InvalidOperationException(
                            String.Format(
                                CultureInfo.CurrentCulture,
                                MvcResources.ReflectedParameterBindingInfo_MultipleConverterAttributes,
                                parameterInfo.Name,
                                parameterInfo.Member));
                    });

                return binder;
            }
        }

        public override ICollection<string> Exclude
        {
            get { return _exclude; }
        }

        public override ICollection<string> Include
        {
            get { return _include; }
        }

        public override string Prefix
        {
            get { return _prefix; }
        }

        private void ReadSettingsFromBindAttribute()
        {
            BindAttribute attr = (BindAttribute)Attribute.GetCustomAttribute(_parameterInfo, typeof(BindAttribute));
            if (attr == null)
            {
                return;
            }

            _exclude = new ReadOnlyCollection<string>(AuthorizeAttribute.SplitString(attr.Exclude));
            _include = new ReadOnlyCollection<string>(AuthorizeAttribute.SplitString(attr.Include));
            _prefix = attr.Prefix;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ReflectedParameterDescriptor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Mvc
{
    public class ReflectedParameterDescriptor : ParameterDescriptor
    {
        private readonly ActionDescriptor _actionDescriptor;
        private readonly ReflectedParameterBindingInfo _bindingInfo;

        public ReflectedParameterDescriptor(ParameterInfo parameterInfo, ActionDescriptor actionDescriptor)
        {
            if (parameterInfo == null)
            {
                throw new ArgumentNullException("parameterInfo");
            }
            if (actionDescriptor == null)
            {
                throw new ArgumentNullException("actionDescriptor");
            }

            ParameterInfo = parameterInfo;
            _actionDescriptor = actionDescriptor;
            _bindingInfo = new ReflectedParameterBindingInfo(parameterInfo);
        }

        public override ActionDescriptor ActionDescriptor
        {
            get { return _actionDescriptor; }
        }

        public override ParameterBindingInfo BindingInfo
        {
            get { return _bindingInfo; }
        }

        public override object DefaultValue
        {
            get
            {
                object value;
                if (ParameterInfoUtil.TryGetDefaultValue(ParameterInfo, out value))
                {
                    return value;
                }
                else
                {
                    return base.DefaultValue;
                }
            }
        }

        public ParameterInfo ParameterInfo { get; private set; }

        public override string ParameterName
        {
            get { return ParameterInfo.Name; }
        }

        public override Type ParameterType
        {
            get { return ParameterInfo.ParameterType; }
        }

        public override object[] GetCustomAttributes(bool inherit)
        {
            return ParameterInfo.GetCustomAttributes(inherit);
        }

        public override object[] GetCustomAttributes(Type attributeType, bool inherit)
        {
            return ParameterInfo.GetCustomAttributes(attributeType, inherit);
        }

        public override bool IsDefined(Type attributeType, bool inherit)
        {
            return ParameterInfo.IsDefined(attributeType, inherit);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RegularExpressionAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    public class RegularExpressionAttributeAdapter : DataAnnotationsModelValidator<RegularExpressionAttribute>
    {
        public RegularExpressionAttributeAdapter(ModelMetadata metadata, ControllerContext context, RegularExpressionAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            return new[] { new ModelClientValidationRegexRule(ErrorMessage, Attribute.Pattern) };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RemoteAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Property)]
    [SuppressMessage("Microsoft.Design", "CA1019:DefineAccessorsForAttributeArguments", Justification = "The constructor parameters are used to feed RouteData, which is public.")]
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This attribute is designed to be a base class for other attributes.")]
    public class RemoteAttribute : ValidationAttribute, IClientValidatable
    {
        private string _additionalFields;
        private string[] _additonalFieldsSplit = new string[0];

        protected RemoteAttribute()
            : base(MvcResources.RemoteAttribute_RemoteValidationFailed)
        {
            RouteData = new RouteValueDictionary();
        }

        public RemoteAttribute(string routeName)
            : this()
        {
            if (String.IsNullOrWhiteSpace(routeName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "routeName");
            }

            RouteName = routeName;
        }

        public RemoteAttribute(string action, string controller)
            :
                this(action, controller, null /* areaName */)
        {
        }

        public RemoteAttribute(string action, string controller, string areaName)
            : this()
        {
            if (String.IsNullOrWhiteSpace(action))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "action");
            }
            if (String.IsNullOrWhiteSpace(controller))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "controller");
            }

            RouteData["controller"] = controller;
            RouteData["action"] = action;

            if (!String.IsNullOrWhiteSpace(areaName))
            {
                RouteData["area"] = areaName;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RemoteAttribute"/> class.
        /// </summary>
        /// <param name="action">The route name.</param>
        /// <param name="controller">The name of the controller.</param>
        /// <param name="areaReference">
        /// Find the controller in the root if <see cref="AreaReference.UseRoot"/>. Otherwise look in the current area.
        /// </param>
        public RemoteAttribute(string action, string controller, AreaReference areaReference)
            : this(action, controller)
        {
            if (areaReference == AreaReference.UseRoot)
            {
                RouteData["area"] = null;
            }
        }

        public string HttpMethod { get; set; }

        public string AdditionalFields
        {
            get { return _additionalFields ?? String.Empty; }
            set
            {
                _additionalFields = value;
                _additonalFieldsSplit = AuthorizeAttribute.SplitString(value);
            }
        }

        protected RouteValueDictionary RouteData { get; private set; }

        protected string RouteName { get; set; }

        protected virtual RouteCollection Routes
        {
            get { return RouteTable.Routes; }
        }

        public string FormatAdditionalFieldsForClientValidation(string property)
        {
            if (String.IsNullOrEmpty(property))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "property");
            }

            string delimitedAdditionalFields = FormatPropertyForClientValidation(property);

            foreach (string field in _additonalFieldsSplit)
            {
                delimitedAdditionalFields += "," + FormatPropertyForClientValidation(field);
            }

            return delimitedAdditionalFields;
        }

        public static string FormatPropertyForClientValidation(string property)
        {
            if (String.IsNullOrEmpty(property))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "property");
            }
            return "*." + property;
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "The value is a not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        protected virtual string GetUrl(ControllerContext controllerContext)
        {
            var pathData = Routes.GetVirtualPathForArea(controllerContext.RequestContext,
                                                        RouteName,
                                                        RouteData);

            if (pathData == null)
            {
                throw new InvalidOperationException(MvcResources.RemoteAttribute_NoUrlFound);
            }

            return pathData.VirtualPath;
        }

        public override string FormatErrorMessage(string name)
        {
            return String.Format(CultureInfo.CurrentCulture, ErrorMessageString, name);
        }

        public override bool IsValid(object value)
        {
            return true;
        }

        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            yield return new ModelClientValidationRemoteRule(FormatErrorMessage(metadata.GetDisplayName()), GetUrl(context), HttpMethod, FormatAdditionalFieldsForClientValidation(metadata.PropertyName));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RequireHttpsAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "Unsealed because type contains virtual extensibility points.")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public class RequireHttpsAttribute : FilterAttribute, IAuthorizationFilter
    {
        public RequireHttpsAttribute()
            : this(permanent: false)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RequireHttpsAttribute"/> class.
        /// </summary>
        /// <param name="permanent">Whether the redirect to HTTPS should be a permanent redirect.</param>
        public RequireHttpsAttribute(bool permanent)
        {
            this.Permanent = permanent;
        }

        /// <summary>
        /// Gets a value indicating whether the redirect to HTTPS should be a permanent redirect.
        /// </summary>
        public bool Permanent { get; private set; }

        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            if (!filterContext.HttpContext.Request.IsSecureConnection)
            {
                HandleNonHttpsRequest(filterContext);
            }
        }

        protected virtual void HandleNonHttpsRequest(AuthorizationContext filterContext)
        {
            // only redirect for GET requests, otherwise the browser might not propagate the verb and request
            // body correctly.

            if (!String.Equals(filterContext.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(MvcResources.RequireHttpsAttribute_MustUseSsl);
            }

            // redirect to HTTPS version of page
            string url = "https://" + filterContext.HttpContext.Request.Url.Host + filterContext.HttpContext.Request.RawUrl;
            filterContext.Result = new RedirectResult(url, this.Permanent);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RequiredAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    public class RequiredAttributeAdapter : DataAnnotationsModelValidator<RequiredAttribute>
    {
        public RequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            return new[] { new ModelClientValidationRequiredRule(ErrorMessage) };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ResultExecutedContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class ResultExecutedContext : ControllerContext
    {
        // parameterless constructor used for mocking
        public ResultExecutedContext()
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public ResultExecutedContext(ControllerContext controllerContext, ActionResult result, bool canceled, Exception exception)
            : base(controllerContext)
        {
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            Result = result;
            Canceled = canceled;
            Exception = exception;
        }

        public virtual bool Canceled { get; set; }

        public virtual Exception Exception { get; set; }

        public bool ExceptionHandled { get; set; }

        public virtual ActionResult Result { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/ResultExecutingContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class ResultExecutingContext : ControllerContext
    {
        // parameterless constructor used for mocking
        public ResultExecutingContext()
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public ResultExecutingContext(ControllerContext controllerContext, ActionResult result)
            : base(controllerContext)
        {
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            Result = result;
        }

        public bool Cancel { get; set; }

        public virtual ActionResult Result { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/RouteAreaAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Routing;

namespace System.Web.Mvc
{
    /// <summary>
    /// Defines the area to set for all the routes defined in this controller.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public sealed class RouteAreaAttribute : Attribute
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RouteAreaAttribute" /> class.
        /// </summary>
        /// <remarks>An attempt will be made to infer the area name from the target controller's namespace.</remarks>
        public RouteAreaAttribute()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RouteAreaAttribute" /> class.
        /// </summary>
        /// <param name="areaName">The name of the area. 
        /// If the value is null, an attempt will be made to infer the area name from the target controller's namespace.
        /// </param>
        public RouteAreaAttribute(string areaName)
        {
            AreaName = areaName;
        }

        /// <summary>
        /// The area name to set for all the routes defined in the controller.
        /// If the value is null, an attempt will be made to infer the area name from the target controller's namespace.
        /// </summary>
        public string AreaName { get; private set; }

        /// <summary>
        /// The URL prefix to apply to the routes of this area. Defaults to the area's name.
        /// </summary>
        public string AreaPrefix { get; set; }
    }
}

================================================
FILE: src/System.Web.Mvc/RouteAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Web.Mvc.Routing;

namespace System.Web.Mvc
{
    /// <summary>
    /// Place on a controller or action to expose it directly via a route. 
    /// When placed on a controller, it applies to actions that do not have any <see cref="RouteAttribute"/>s on them.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
    public sealed class RouteAttribute : Attribute, IDirectRouteFactory, IRouteInfoProvider
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RouteAttribute" /> class.
        /// </summary>
        public RouteAttribute() : this(String.Empty)
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RouteAttribute" /> class.
        /// </summary>
        /// <param name="template">The route template describing the URI pattern to match against.</param>
        public RouteAttribute(string template)
        {
            if (template == null)
            {
                throw Error.ArgumentNull("template");
            }
            Template = template;
        }

        /// <inheritdoc />
        public string Name { get; set; }

        /// <inheritdoc />
        public int Order { get; set; }
        
        /// <inheritdoc />
        public string Template { get; private set; }

        RouteEntry IDirectRouteFactory.CreateRoute(DirectRouteFactoryContext context)
        {
            Contract.Assert(context != null);

            IDirectRouteBuilder builder = context.CreateBuilder(Template);
            Contract.Assert(builder != null);

            builder.Name = Name;
            builder.Order = Order;
            return builder.Build();
        }
    }
}

================================================
FILE: src/System.Web.Mvc/RouteCollectionExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    public static class RouteCollectionExtensions
    {
        // This method returns a new RouteCollection containing only routes that matched a particular area.
        // The Boolean out parameter is just a flag specifying whether any registered routes were area-aware.
        private static RouteCollection FilterRouteCollectionByArea(RouteCollection routes, string areaName, out bool usingAreas)
        {
            if (areaName == null)
            {
                areaName = String.Empty;
            }

            usingAreas = false;

            // Ensure that we continue using the same settings as the previous route collection
            // if we are using areas and the route collection is exchanged
            RouteCollection filteredRoutes = new RouteCollection()
            {
                AppendTrailingSlash = routes.AppendTrailingSlash,
                LowercaseUrls = routes.LowercaseUrls,
                RouteExistingFiles = routes.RouteExistingFiles
            };

            using (routes.GetReadLock())
            {
                foreach (RouteBase route in routes)
                {
                    string thisAreaName = AreaHelpers.GetAreaName(route) ?? String.Empty;
                    usingAreas |= (thisAreaName.Length > 0);
                    if (String.Equals(thisAreaName, areaName, StringComparison.OrdinalIgnoreCase))
                    {
                        filteredRoutes.Add(route);
                    }
                }
            }

            // if areas are not in use, the filtered route collection might be incorrect
            return (usingAreas) ? filteredRoutes : routes;
        }

        public static VirtualPathData GetVirtualPathForArea(this RouteCollection routes, RequestContext requestContext, RouteValueDictionary values)
        {
            return GetVirtualPathForArea(routes, requestContext, null /* name */, values);
        }

        public static VirtualPathData GetVirtualPathForArea(this RouteCollection routes, RequestContext requestContext, string name, RouteValueDictionary values)
        {
            bool usingAreas; // don't care about this value
            return GetVirtualPathForArea(routes, requestContext, name, values, out usingAreas);
        }

        internal static VirtualPathData GetVirtualPathForArea(this RouteCollection routes, RequestContext requestContext, string name, RouteValueDictionary values, out bool usingAreas)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            if (!String.IsNullOrEmpty(name))
            {
                // the route name is a stronger qualifier than the area name, so just pipe it through
                usingAreas = false;
                return routes.GetVirtualPath(requestContext, name, values);
            }

            string targetArea = null;
            if (values != null)
            {
                object targetAreaRawValue;
                if (values.TryGetValue("area", out targetAreaRawValue))
                {
                    targetArea = targetAreaRawValue as string;
                }
                else
                {
                    // set target area to current area
                    if (requestContext != null)
                    {
                        targetArea = AreaHelpers.GetAreaName(requestContext.RouteData);
                    }
                }
            }

            // need to apply a correction to the RVD if areas are in use
            RouteValueDictionary correctedValues = values;
            RouteCollection filteredRoutes = FilterRouteCollectionByArea(routes, targetArea, out usingAreas);
            if (usingAreas)
            {
                correctedValues = new RouteValueDictionary(values);
                correctedValues.Remove("area");
            }

            VirtualPathData vpd = filteredRoutes.GetVirtualPath(requestContext, correctedValues);
            return vpd;
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static void IgnoreRoute(this RouteCollection routes, string url)
        {
            IgnoreRoute(routes, url, null /* constraints */);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static void IgnoreRoute(this RouteCollection routes, string url, object constraints)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }
            if (url == null)
            {
                throw new ArgumentNullException("url");
            }

            IgnoreRouteInternal route = new IgnoreRouteInternal(url)
            {
                Constraints = CreateRouteValueDictionaryUncached(constraints)
            };

            ConstraintValidation.Validate(route);

            routes.Add(route);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static Route MapRoute(this RouteCollection routes, string name, string url)
        {
            return MapRoute(routes, name, url, null /* defaults */, (object)null /* constraints */);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults)
        {
            return MapRoute(routes, name, url, defaults, (object)null /* constraints */);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints)
        {
            return MapRoute(routes, name, url, defaults, constraints, null /* namespaces */);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static Route MapRoute(this RouteCollection routes, string name, string url, string[] namespaces)
        {
            return MapRoute(routes, name, url, null /* defaults */, null /* constraints */, namespaces);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, string[] namespaces)
        {
            return MapRoute(routes, name, url, defaults, null /* constraints */, namespaces);
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "2#", Justification = "This is not a regular URL as it may contain special routing characters.")]
        public static Route MapRoute(this RouteCollection routes, string name, string url, object defaults, object constraints, string[] namespaces)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }
            if (url == null)
            {
                throw new ArgumentNullException("url");
            }

            Route route = new Route(url, new MvcRouteHandler())
            {
                Defaults = CreateRouteValueDictionaryUncached(defaults),
                Constraints = CreateRouteValueDictionaryUncached(constraints),
                DataTokens = new RouteValueDictionary()
            };

            ConstraintValidation.Validate(route);

            if ((namespaces != null) && (namespaces.Length > 0))
            {
                route.DataTokens[RouteDataTokenKeys.Namespaces] = namespaces;
            }

            routes.Add(name, route);

            return route;
        }

        /// <summary>
        /// The callers to this method are used at startup only, thus it's a bit better to use
        /// the uncached method because it will run faster for the first few times, and will not
        /// consume memory long term.
        /// </summary>
        private static RouteValueDictionary CreateRouteValueDictionaryUncached(object values)
        {
            var dictionary = values as IDictionary<string, object>;
            if (dictionary != null)
            {
                return new RouteValueDictionary(dictionary);
            }

            return TypeHelper.ObjectToDictionaryUncached(values);
        }

        private sealed class IgnoreRouteInternal : Route
        {
            public IgnoreRouteInternal(string url)
                : base(url, new StopRoutingHandler())
            {
            }

            public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary routeValues)
            {
                // Never match during route generation. This avoids the scenario where an IgnoreRoute with
                // fairly relaxed constraints ends up eagerly matching all generated URLs.
                return null;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RouteDataValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;

namespace System.Web.Mvc
{
    public sealed class RouteDataValueProvider : DictionaryValueProvider<object>
    {
        // RouteData should use the invariant culture since it's part of the URL, and the URL should be
        // interpreted in a uniform fashion regardless of the origin of a particular request.
        public RouteDataValueProvider(ControllerContext controllerContext)
            : base(controllerContext.RouteData.Values, CultureInfo.InvariantCulture)
        {
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RouteDataValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public sealed class RouteDataValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            return new RouteDataValueProvider(controllerContext);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/RoutePrefixAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc.Routing;

namespace System.Web.Mvc
{
    /// <summary>
    /// Annotates a controller with a route prefix that applies to all actions within the controller.
    /// </summary>
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "This attribute is intended to be extended by the user.")]
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
    public class RoutePrefixAttribute : Attribute, IRoutePrefix
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RoutePrefixAttribute" /> class without specifying any parameters.
        /// </summary>
        protected RoutePrefixAttribute()
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RoutePrefixAttribute" /> class.
        /// </summary>
        /// <param name="prefix">The route prefix for the controller.</param>
        public RoutePrefixAttribute(string prefix)
        {
            if (prefix == null)
            {
                throw new ArgumentNullException("prefix");
            }

            Prefix = prefix;
        }

        /// <summary>
        /// Gets the route prefix.
        /// </summary>
        public virtual string Prefix { get; private set; }
    }
}

================================================
FILE: src/System.Web.Mvc/RouteValuesHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Routing;

namespace System.Web.Mvc
{
    internal static class RouteValuesHelpers
    {
        public static RouteValueDictionary GetRouteValues(RouteValueDictionary routeValues)
        {
            return (routeValues != null) ? new RouteValueDictionary(routeValues) : new RouteValueDictionary();
        }

        public static RouteValueDictionary MergeRouteValues(string actionName, string controllerName, RouteValueDictionary implicitRouteValues, RouteValueDictionary routeValues, bool includeImplicitMvcValues)
        {
            // Create a new dictionary containing implicit and auto-generated values
            RouteValueDictionary mergedRouteValues = new RouteValueDictionary();

            if (includeImplicitMvcValues)
            {
                // We only include MVC-specific values like 'controller' and 'action' if we are generating an action link.
                // If we are generating a route link [as to MapRoute("Foo", "any/url", new { controller = ... })], including
                // the current controller name will cause the route match to fail if the current controller is not the same
                // as the destination controller.

                object implicitValue;
                if (implicitRouteValues != null && implicitRouteValues.TryGetValue("action", out implicitValue))
                {
                    mergedRouteValues["action"] = implicitValue;
                }

                if (implicitRouteValues != null && implicitRouteValues.TryGetValue("controller", out implicitValue))
                {
                    mergedRouteValues["controller"] = implicitValue;
                }
            }

            // Merge values from the user's dictionary/object
            if (routeValues != null)
            {
                foreach (KeyValuePair<string, object> routeElement in GetRouteValues(routeValues))
                {
                    mergedRouteValues[routeElement.Key] = routeElement.Value;
                }
            }

            // Merge explicit parameters when not null
            if (actionName != null)
            {
                mergedRouteValues["action"] = actionName;
            }

            if (controllerName != null)
            {
                mergedRouteValues["controller"] = controllerName;
            }

            return mergedRouteValues;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Routing/AttributeRoutingMapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.Mvc.Async;
using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    /// <remarks>
    /// Corresponds to the Web API implementation of attribute routing in
    /// System.Web.Http.Routing.AttributeRoutingMapper.
    /// </remarks>
    internal static class AttributeRoutingMapper
    {
        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes">The route collection.</param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.
        /// </param>
        public static void MapAttributeRoutes(RouteCollection routes, IInlineConstraintResolver constraintResolver)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            MapAttributeRoutes(routes, constraintResolver, new DefaultDirectRouteProvider());
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes">The route collection.</param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.
        /// </param>
        /// <param name="directRouteProvider">
        /// The <see cref="IDirectRouteProvider"/> to use for mapping routes from controller types.
        /// </param>
        public static void MapAttributeRoutes(
            RouteCollection routes, 
            IInlineConstraintResolver constraintResolver, 
            IDirectRouteProvider directRouteProvider)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            if (directRouteProvider == null)
            {
                throw new ArgumentNullException("directRouteProvider");
            }

            DefaultControllerFactory typesLocator =
                DependencyResolver.Current.GetService<IControllerFactory>() as DefaultControllerFactory
                ?? ControllerBuilder.Current.GetControllerFactory() as DefaultControllerFactory
                ?? new DefaultControllerFactory();

            IReadOnlyList<Type> controllerTypes = typesLocator.GetControllerTypes();

            MapAttributeRoutes(routes, controllerTypes, constraintResolver, directRouteProvider);
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes">The route collection.</param>
        /// <param name="controllerTypes">The controller types to scan.</param>
        public static void MapAttributeRoutes(RouteCollection routes, IEnumerable<Type> controllerTypes)
        {
            MapAttributeRoutes(routes, controllerTypes, new DefaultInlineConstraintResolver());
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes">The route collection.</param>
        /// <param name="controllerTypes">The controller types to scan.</param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.
        /// </param>
        public static void MapAttributeRoutes(RouteCollection routes, IEnumerable<Type> controllerTypes,
            IInlineConstraintResolver constraintResolver)
        {
            MapAttributeRoutes(routes, controllerTypes, constraintResolver, new DefaultDirectRouteProvider());
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes">The route collection.</param>
        /// <param name="controllerTypes">The controller types to scan.</param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.
        /// </param>
        /// <param name="directRouteProvider">
        /// The <see cref="IDirectRouteProvider"/> to use for mapping routes from controller types.
        /// </param>
        public static void MapAttributeRoutes(RouteCollection routes, IEnumerable<Type> controllerTypes,
            IInlineConstraintResolver constraintResolver, IDirectRouteProvider directRouteProvider)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            if (controllerTypes == null)
            {
                throw new ArgumentNullException("controllerTypes");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            if (directRouteProvider == null)
            {
                throw new ArgumentNullException("directRouteProvider");
            }

            SubRouteCollection subRoutes = new SubRouteCollection();
            AddRouteEntries(subRoutes, controllerTypes, constraintResolver, directRouteProvider);
            IReadOnlyCollection<RouteEntry> entries = subRoutes.Entries;

            if (entries.Count > 0)
            {
                RouteCollectionRoute aggregrateRoute = new RouteCollectionRoute(subRoutes);
                routes.Add(aggregrateRoute);

                // This sort is here to enforce a static ordering for link generation using these routes. 
                // We don't apply dynamic criteria like ActionSelectors on link generation, but we can use the static
                // ones.
                //
                // Routes to actions are placed first because they are considered more specific. A route to an action
                // will only match for link generation if the action name was supplied, so this is essential for
                // correctness. Without this a controller-level route could be 'greedy' and generate a link when
                // the action-level route was intended.
                RouteEntry[] sorted = entries
                    .OrderBy(r => r.Route.GetOrder())
                    .ThenBy(r => r.Route.GetTargetIsAction() ? 0 : 1)
                    .ThenBy(r => r.Route.GetPrecedence())
                    .ToArray();

                AddGenerationHooksForSubRoutes(routes, sorted);
            }
        }

        // just for testing
        internal static IReadOnlyCollection<RouteEntry> GetAttributeRoutes(Type controllerType)
        {
            SubRouteCollection collector = new SubRouteCollection();
            AddRouteEntries(
                collector, 
                new Type[] { controllerType }, 
                new DefaultInlineConstraintResolver(), 
                new DefaultDirectRouteProvider());

            return collector.Entries;
        }

        // Add generation hooks for the Attribute-routing subroutes. 
        // This lets us generate urls for routes supplied by attr-based routing.
        private static void AddGenerationHooksForSubRoutes(RouteCollection routeTable, IList<RouteEntry> entries)
        {
            Contract.Assert(entries != null);

            foreach (RouteEntry entry in entries)
            {
                Contract.Assert(entry != null);
                Route route = entry.Route;
                Contract.Assert(route != null);
                RouteBase linkGenerationRoute = new LinkGenerationRoute(route);
                string name = entry.Name;

                if (name == null)
                {
                    routeTable.Add(linkGenerationRoute);
                }
                else
                {
                    routeTable.Add(name, linkGenerationRoute);
                }
            }
        }

        internal static void AddRouteEntries(SubRouteCollection collector, IEnumerable<Type> controllerTypes,
            IInlineConstraintResolver constraintResolver, IDirectRouteProvider directRouteProvider)
        {
            IEnumerable<ReflectedAsyncControllerDescriptor> controllers = GetControllerDescriptors(controllerTypes);

            foreach (ReflectedAsyncControllerDescriptor controller in controllers)
            {
                List<ActionDescriptor> actions = GetActionDescriptors(controller);

                IReadOnlyCollection<RouteEntry> entries = directRouteProvider.GetDirectRoutes(controller, actions, constraintResolver);
                if (entries == null)
                {
                    throw Error.InvalidOperation(
                        MvcResources.TypeMethodMustNotReturnNull,
                        typeof(IDirectRouteProvider).Name, 
                        "GetDirectRoutes");
                }

                foreach (RouteEntry entry in entries)
                {
                    if (entry == null)
                    {
                        throw Error.InvalidOperation(
                            MvcResources.TypeMethodMustNotReturnNull,
                            typeof(IDirectRouteProvider).Name, 
                            "GetDirectRoutes");
                    }

                    DirectRouteBuilder.ValidateRouteEntry(entry);

                    // This marks the action/controller as unreachable via traditional routing.
                    if (entry.Route.GetTargetIsAction())
                    {
                        var actionDescriptors = entry.Route.GetTargetActionDescriptors();
                        Contract.Assert(actionDescriptors != null && actionDescriptors.Any());

                        foreach (var actionDescriptor in actionDescriptors.OfType<IMethodInfoActionDescriptor>())
                        {
                            var methodInfo = actionDescriptor.MethodInfo;
                            if (methodInfo != null)
                            {
                                controller.Selector.StandardRouteMethods.Remove(methodInfo);
                            }
                        }
                    }
                    else
                    {
                        // This is a controller-level route - no actions in this controller are reachable via
                        // traditional routes.
                        controller.Selector.StandardRouteMethods.Clear();
                    }
                }

                collector.AddRange(entries);
            }
        }

        private static IEnumerable<ReflectedAsyncControllerDescriptor> GetControllerDescriptors(IEnumerable<Type> controllerTypes)
        {
            Contract.Assert(controllerTypes != null);

            Func<Type, ControllerDescriptor> descriptorFactory = ReflectedAsyncControllerDescriptor.DefaultDescriptorFactory;
            ControllerDescriptorCache descriptorsCache = new AsyncControllerActionInvoker().DescriptorCache;

            return 
                controllerTypes
                .Select(type => descriptorsCache.GetDescriptor(type, descriptorFactory, type))
                .Cast<ReflectedAsyncControllerDescriptor>();
        }

        private static List<ActionDescriptor> GetActionDescriptors(ReflectedAsyncControllerDescriptor controller)
        {
            Contract.Assert(controller != null);

            AsyncActionMethodSelector actionSelector = controller.Selector;

            var actions = new List<ActionDescriptor>();
            foreach (MethodInfo method in actionSelector.ActionMethods)
            {
                string actionName = actionSelector.GetActionName(method);
                ActionDescriptorCreator creator = actionSelector.GetActionDescriptorDelegate(method);
                Debug.Assert(creator != null);

                ActionDescriptor action = creator(actionName, controller);
                actions.Add(action);
            }

            return actions;
        }
    }
}

================================================
FILE: src/System.Web.Mvc/Routing/ConstraintValidation.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    /// <summary>
    /// Validates that the constraints on a Route are of a type that can be processed by <see cref="System.Web.Routing.Route" />.
    /// </summary>
    /// <remarks>
    /// This validation is only applicable when the <see cref="System.Web.Routing.Route" /> is one that we created. A user-defined
    /// type that is derived from <see cref="System.Web.Routing.RouteBase" /> may have different semantics.
    /// 
    /// The logic here is duplicated from System.Web, but we need it to validate correctness of routes on startup. Since we can't 
    /// change System.Web, this just lives in a static class for MVC.
    /// </remarks>
    internal static class ConstraintValidation
    {
        public static void Validate(Route route)
        {
            Contract.Assert(route != null);
            Contract.Assert(route.Url != null);

            if (route.Constraints == null)
            {
                return;
            }

            foreach (var kvp in route.Constraints)
            {
                if (kvp.Value is string)
                {
                    continue;
                }

                if (kvp.Value is IRouteConstraint)
                {
                    continue;
                }

                throw Error.InvalidOperation(
                    MvcResources.Route_InvalidConstraint,
                    kvp.Key,
                    route.Url,
                    typeof(IRouteConstraint).FullName);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Routing/DefaultDirectRouteProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    public class DefaultDirectRouteProvider : IDirectRouteProvider
    {
        /// <summary>
        /// Gets direct routes for the given controller descriptor and action descriptors based on 
        /// <see cref="IDirectRouteFactory"/> attributes.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="actionDescriptors">The action descriptors for all actions.</param>
        /// <param name="constraintResolver">The constraint resolver.</param>
        /// <returns>A set of route entries.</returns>
        /// <remarks>
        /// The implementation returns route entries for the given controller and actions. 
        /// 
        /// Any actions that have associated <see cref="IDirectRouteFactory"/> instances will produce route
        /// entries that route direct to those actions.
        /// 
        /// Any actions that do not have an associated <see cref="IDirectRouteFactory"/> instances will be
        /// associated with the controller. If the controller has any associated <see cref="IDirectRouteProvider"/>
        /// instances, then route entries will be created for the controller and associated actions.
        /// </remarks>
        public virtual IReadOnlyList<RouteEntry> GetDirectRoutes(
            ControllerDescriptor controllerDescriptor,
            IReadOnlyList<ActionDescriptor> actionDescriptors,
            IInlineConstraintResolver constraintResolver)
        {
            List<RouteEntry> entries = new List<RouteEntry>();

            List<ActionDescriptor> actionsWithoutRoutes = new List<ActionDescriptor>();

            foreach (ActionDescriptor action in actionDescriptors)
            {
                IReadOnlyList<IDirectRouteFactory> factories = GetActionRouteFactories(action);

                if (factories != null && factories.Count > 0)
                {
                    IReadOnlyCollection<RouteEntry> actionEntries = GetActionDirectRoutes(action, factories, constraintResolver);
                    if (actionEntries != null)
                    {
                        entries.AddRange(actionEntries);
                    }
                }
                else
                {
                    // IF there are no routes on the specific action, attach it to the controller routes (if any).
                    actionsWithoutRoutes.Add(action);
                }
            }

            if (actionsWithoutRoutes.Count > 0)
            {
                IReadOnlyList<IDirectRouteFactory> controllerFactories = GetControllerRouteFactories(controllerDescriptor);
                if (controllerFactories != null && controllerFactories.Count > 0)
                {
                    IReadOnlyCollection<RouteEntry> controllerEntries = GetControllerDirectRoutes(
                        controllerDescriptor,
                        actionsWithoutRoutes,
                        controllerFactories,
                        constraintResolver);

                    if (controllerEntries != null)
                    {
                        entries.AddRange(controllerEntries);
                    }
                }
            }

            return entries;
        }

        /// <summary>
        /// Gets route factories for the given controller descriptor.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <returns>A set of route factories.</returns>
        /// <remarks>
        /// The implementation returns <see cref="IDirectRouteFactory"/> instances based on attributes on the controller.
        /// </remarks>
        protected virtual IReadOnlyList<IDirectRouteFactory> GetControllerRouteFactories(ControllerDescriptor controllerDescriptor)
        {
            object[] attributes = controllerDescriptor.GetCustomAttributes(inherit: false);
            IEnumerable<IDirectRouteFactory> newFactories = attributes.OfType<IDirectRouteFactory>();
            IEnumerable<IRouteInfoProvider> oldProviders = attributes.OfType<IRouteInfoProvider>();

            List<IDirectRouteFactory> combined = new List<IDirectRouteFactory>();
            combined.AddRange(newFactories);

            foreach (IRouteInfoProvider oldProvider in oldProviders)
            {
                if (oldProvider is IDirectRouteFactory)
                {
                    continue;
                }

                combined.Add(new RouteInfoDirectRouteFactory(oldProvider));
            }

            return combined;
        }

        /// <summary>
        /// Gets a set of route factories for the given action descriptor.
        /// </summary>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <returns>A set of route factories.</returns>
        /// <remarks>
        /// The implementation returns <see cref="IDirectRouteFactory"/> instances based on attributes on the action. Returns
        /// null if the action was defined on a base class of this controller.
        /// </remarks>
        protected virtual IReadOnlyList<IDirectRouteFactory> GetActionRouteFactories(ActionDescriptor actionDescriptor)
        {
            // Skip Route attributes on inherited actions.
            IMethodInfoActionDescriptor methodInfoActionDescriptor = actionDescriptor as IMethodInfoActionDescriptor;
            if (methodInfoActionDescriptor != null &&
                methodInfoActionDescriptor.MethodInfo != null &&
                actionDescriptor.ControllerDescriptor != null &&
                methodInfoActionDescriptor.MethodInfo.DeclaringType != actionDescriptor.ControllerDescriptor.ControllerType)
            {
                return null;
            }

            object[] attributes = actionDescriptor.GetCustomAttributes(inherit: false);
            IEnumerable<IDirectRouteFactory> newFactories = attributes.OfType<IDirectRouteFactory>();
            IEnumerable<IRouteInfoProvider> oldProviders = attributes.OfType<IRouteInfoProvider>();

            List<IDirectRouteFactory> combined = new List<IDirectRouteFactory>();
            combined.AddRange(newFactories);

            foreach (IRouteInfoProvider oldProvider in oldProviders)
            {
                if (oldProvider is IDirectRouteFactory)
                {
                    continue;
                }

                combined.Add(new RouteInfoDirectRouteFactory(oldProvider));
            }

            return combined;
        }

        /// <summary>
        /// Creates <see cref="RouteEntry"/> instances based on the provided factories, controller and actions. The route
        /// entries provided direct routing to the provided controller and can reach the set of provided actions.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="actionDescriptors">The action descriptors.</param>
        /// <param name="factories">The direct route factories.</param>
        /// <param name="constraintResolver">The constraint resolver.</param>
        /// <returns>A set of route entries.</returns>
        protected virtual IReadOnlyList<RouteEntry> GetControllerDirectRoutes(
            ControllerDescriptor controllerDescriptor,
            IReadOnlyList<ActionDescriptor> actionDescriptors,
            IReadOnlyList<IDirectRouteFactory> factories,
            IInlineConstraintResolver constraintResolver)
        {
            return CreateRouteEntries(
                GetAreaPrefix(controllerDescriptor),
                GetRoutePrefix(controllerDescriptor),
                factories,
                actionDescriptors,
                constraintResolver,
                targetIsAction: false);
        }

        /// <summary>
        /// Creates <see cref="RouteEntry"/> instances based on the provided factories and action. The route entries
        /// provide direct routing to the provided action.
        /// </summary>
        /// <param name="actionDescriptor">The action descriptor.</param>
        /// <param name="factories">The direct route factories.</param>
        /// <param name="constraintResolver">The constraint resolver.</param>
        /// <returns>A set of route entries.</returns>
        protected virtual IReadOnlyList<RouteEntry> GetActionDirectRoutes(
            ActionDescriptor actionDescriptor,
            IReadOnlyList<IDirectRouteFactory> factories,
            IInlineConstraintResolver constraintResolver)
        {
            return CreateRouteEntries(
                GetAreaPrefix(actionDescriptor.ControllerDescriptor),
                GetRoutePrefix(actionDescriptor.ControllerDescriptor),
                factories,
                new ActionDescriptor[] { actionDescriptor },
                constraintResolver,
                targetIsAction: true);
        }

        /// <summary>
        /// Gets the route prefix from the provided controller.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <returns>The route prefix or null.</returns>
        protected virtual string GetRoutePrefix(ControllerDescriptor controllerDescriptor)
        {
            IRoutePrefix[] attributes = controllerDescriptor.GetCustomAttributes(inherit: false).OfType<IRoutePrefix>().ToArray();

            if (attributes == null)
            {
                return null;
            }

            if (attributes.Length > 1)
            {
                string errorMessage = Error.Format(
                    MvcResources.RoutePrefix_CannotSupportMultiRoutePrefix,
                    controllerDescriptor.ControllerType.FullName);
                throw new InvalidOperationException(errorMessage);
            }

            if (attributes.Length == 1)
            {
                IRoutePrefix attribute = attributes[0];

                if (attribute != null)
                {
                    string prefix = attribute.Prefix;
                    if (prefix == null)
                    {
                        string errorMessage = Error.Format(
                            MvcResources.RoutePrefix_PrefixCannotBeNull,
                            controllerDescriptor.ControllerType.FullName);
                        throw new InvalidOperationException(errorMessage);
                    }

                    if (prefix.StartsWith("/", StringComparison.Ordinal)
                        || prefix.EndsWith("/", StringComparison.Ordinal))
                    {
                        string errorMessage = Error.Format(
                            MvcResources.RoutePrefix_CannotStartOrEnd_WithForwardSlash, prefix,
                            controllerDescriptor.ControllerName);
                        throw new InvalidOperationException(errorMessage);
                    }

                    return prefix;
                }
            }

            return null;
        }

        /// <summary>
        /// Gets the area prefix from the provided controller.
        /// </summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <returns>The area prefix or null.</returns>
        protected virtual string GetAreaPrefix(ControllerDescriptor controllerDescriptor)
        {
            RouteAreaAttribute area = controllerDescriptor.GetAreaFrom();
            string areaName = controllerDescriptor.GetAreaName(area);
            string areaPrefix = area != null ? area.AreaPrefix ?? area.AreaName : null;

            ValidateAreaPrefixTemplate(areaPrefix, areaName, controllerDescriptor);

            return areaPrefix;
        }

        private static IReadOnlyList<RouteEntry> CreateRouteEntries(
            string areaPrefix,
            string controllerPrefix,
            IReadOnlyCollection<IDirectRouteFactory> factories,
            IReadOnlyCollection<ActionDescriptor> actions,
            IInlineConstraintResolver constraintResolver,
            bool targetIsAction)
        {
            List<RouteEntry> entries = new List<RouteEntry>();
            foreach (IDirectRouteFactory factory in factories)
            {
                RouteEntry entry = CreateRouteEntry(areaPrefix, controllerPrefix, factory, actions, constraintResolver, targetIsAction);
                entries.Add(entry);
            }

            return entries;
        }

        // Internal for testing
        internal static RouteEntry CreateRouteEntry(
            string areaPrefix,
            string controllerPrefix,
            IDirectRouteFactory factory,
            IReadOnlyCollection<ActionDescriptor> actions,
            IInlineConstraintResolver constraintResolver,
            bool targetIsAction)
        {
            Contract.Assert(factory != null);

            DirectRouteFactoryContext context = new DirectRouteFactoryContext(
                areaPrefix, 
                controllerPrefix, 
                actions, 
                constraintResolver, 
                targetIsAction);

            RouteEntry entry = factory.CreateRoute(context);

            if (entry == null)
            {
                throw Error.InvalidOperation(
                    MvcResources.TypeMethodMustNotReturnNull,
                    typeof(IDirectRouteFactory).Name, 
                    "CreateRoute");
            }

            DirectRouteBuilder.ValidateRouteEntry(entry);

            return entry;
        }

        private static void ValidateAreaPrefixTemplate(string areaPrefix, string areaName, ControllerDescriptor controllerDescriptor)
        {
            if (areaPrefix != null && areaPrefix.EndsWith("/", StringComparison.Ordinal))
            {
                string errorMessage = Error.Format(MvcResources.RouteAreaPrefix_CannotEnd_WithForwardSlash,
                                                   areaPrefix, areaName, controllerDescriptor.ControllerName);
                throw new InvalidOperationException(errorMessage);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Routing/DirectRouteCandidate.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.Mvc.Async;
using System.Web.Mvc.Properties;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    /// <summary>
    /// Represents a candidate action found via a direct route.
    /// </summary>
    /// <remarks>
    /// Members are get/set for testability of the 'best-match' algorithm.
    /// </remarks>
    internal class DirectRouteCandidate
    {
        public ActionDescriptor ActionDescriptor
        {
            get;
            set;
        }

        public IEnumerable<ActionNameSelector> ActionNameSelectors
        {
            get;
            set;
        }

        public IEnumerable<ActionSelector> ActionSelectors
        {
            get;
            set;
        }

        public ControllerDescriptor ControllerDescriptor
        {
            get;
            set;
        }

        public bool HasActionNameSelectors
        {
            get
            {
                return ActionNameSelectors != null && ActionNameSelectors.Any();
            }
        }

        public bool HasActionSelectors
        {
            get
            {
                return ActionSelectors != null && ActionSelectors.Any();
            }
        }

        public int Order
        {
            get;
            set;
        }

        public decimal Precedence
        {
            get;
            set;
        }

        public RouteData RouteData
        {
            get;
            set;
        }

        public static DirectRouteCandidate SelectBestCandidate(List<DirectRouteCandidate> candidates, ControllerContext controllerContext)
        {
            Debug.Assert(controllerContext != null);
            Debug.Assert(candidates != null);

            // These filters will allow actions to opt-out of execution via the provided public extensibility points.
            List<DirectRouteCandidate> filteredByActionName = ApplyActionNameFilters(candidates, controllerContext);
            List<DirectRouteCandidate> applicableCandidates = ApplyActionSelectors(filteredByActionName, controllerContext);

            // At this point all of the remaining actions are applicable - now we're just trying to find the
            // most specific match.
            //
            // Order is first, because it's the 'override' to our algorithm
            List<DirectRouteCandidate> filteredByOrder = FilterByOrder(applicableCandidates);
            List<DirectRouteCandidate> filteredByPrecedence = FilterByPrecedence(filteredByOrder);

            if (filteredByPrecedence.Count == 0)
            {
                return null;
            }
            else if (filteredByPrecedence.Count == 1)
            {
                return filteredByPrecedence[0];
            }
            else
            {
                throw CreateAmbiguiousMatchException(candidates);
            }
        }

        private static AmbiguousMatchException CreateAmbiguiousMatchException(List<DirectRouteCandidate> candidates)
        {
            string ambiguityList = CreateAmbiguousMatchList(candidates);
            string message = String.Format(
                CultureInfo.CurrentCulture,
                MvcResources.DirectRoute_AmbiguousMatch,
                ambiguityList);

            return new AmbiguousMatchException(message);
        }

        protected static string CreateAmbiguousMatchList(IEnumerable<DirectRouteCandidate> candidates)
        {
            StringBuilder exceptionMessageBuilder = new StringBuilder();
            foreach (DirectRouteCandidate candidate in candidates)
            {
                MethodInfo method = null;

                ReflectedActionDescriptor reflectedActionDescriptor = candidate.ActionDescriptor as ReflectedActionDescriptor;
                if (reflectedActionDescriptor == null)
                {
                    ReflectedAsyncActionDescriptor reflectedAsyncActionDescriptor = candidate.ActionDescriptor as ReflectedAsyncActionDescriptor;
                    if (reflectedAsyncActionDescriptor != null)
                    {
                        method = reflectedAsyncActionDescriptor.AsyncMethodInfo;
                    }
                }
                else
                {
                    method = reflectedActionDescriptor.MethodInfo;
                }

                string controllerAction = method == null ? candidate.ActionDescriptor.ActionName : Convert.ToString(method, CultureInfo.CurrentCulture);
                string controllerType = method.DeclaringType.FullName;

                exceptionMessageBuilder.AppendLine();
                exceptionMessageBuilder.AppendFormat(CultureInfo.CurrentCulture, MvcResources.ActionMethodSelector_AmbiguousMatchType, controllerAction, controllerType);
            }

            return exceptionMessageBuilder.ToString();
        }

        private static List<DirectRouteCandidate> ApplyActionNameFilters(List<DirectRouteCandidate> candidates, ControllerContext controllerContext)
        {
            List<DirectRouteCandidate> filtered = new List<DirectRouteCandidate>();
            foreach (DirectRouteCandidate candidate in candidates)
            {
                string actionName;
                candidate.RouteData.Values.TryGetValue<string>("action", out actionName);

                if (candidate.HasActionNameSelectors)
                {
                    // For the sake of consistency - we still want to call the action name selectors even if
                    // this route was matched without providing an action name.
                    actionName = actionName ?? candidate.ActionDescriptor.ActionName;

                    if (candidate.ActionNameSelectors.All(selector => selector(controllerContext, actionName)))
                    {
                        filtered.Add(candidate);
                    }
                }
                else if (actionName != null)
                {
                    if (String.Equals(actionName, candidate.ActionDescriptor.ActionName, StringComparison.OrdinalIgnoreCase))
                    {
                        filtered.Add(candidate);
                    }
                }
                else
                {
                    // No name-based filtering applies for this route.
                    filtered.Add(candidate);
                }
            }

            return filtered;
        }

        private static List<DirectRouteCandidate> ApplyActionSelectors(List<DirectRouteCandidate> candidates, ControllerContext controllerContext)
        {
            List<DirectRouteCandidate> matchesWithActionSelectors = new List<DirectRouteCandidate>();
            List<DirectRouteCandidate> matchesWithoutActionSelectors = new List<DirectRouteCandidate>();

            foreach (DirectRouteCandidate candidate in candidates)
            {
                if (candidate.HasActionSelectors)
                {
                    if (candidate.ActionSelectors.All(selector => selector(controllerContext)))
                    {
                        matchesWithActionSelectors.Add(candidate);
                    }
                }
                else
                {
                    matchesWithoutActionSelectors.Add(candidate);
                }
            }

            return matchesWithActionSelectors.Any() ? matchesWithActionSelectors : matchesWithoutActionSelectors;
        }

        private static List<DirectRouteCandidate> FilterByOrder(List<DirectRouteCandidate> candidates)
        {
            if (!candidates.Any())
            {
                return candidates;
            }

            int minimum = candidates.Min(c => c.Order);
            return candidates.Where(c => c.Order == minimum).AsList();
        }

        private static List<DirectRouteCandidate> FilterByPrecedence(List<DirectRouteCandidate> candidates)
        {
            if (!candidates.Any())
            {
                return candidates;
            }

            decimal minimum = candidates.Min(c => c.Precedence);
            return candidates.Where(c => c.Precedence == minimum).AsList();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Routing/DirectRouteExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    internal static class DirectRouteExtensions
    {
        /// <summary>
        /// Gets the precedence or this route.
        /// </summary>
        public static decimal GetPrecedence(this RouteData routeData)
        {
            return GetRouteDataTokenValue<decimal>(routeData, RouteDataTokenKeys.Precedence);
        }

        /// <summary>
        /// Gets the precedence or this route.
        /// </summary>
        public static decimal GetPrecedence(this Route route)
        {
            return GetRouteDataTokenValue<decimal>(route, RouteDataTokenKeys.Precedence);
        }

        /// <summary>
        /// Sets the precedence of this Route.
        /// </summary>
        public static void SetPrecedence(this Route route, decimal precedence)
        {
            SetRouteDataTokenValue(route, RouteDataTokenKeys.Precedence, precedence);
        }

        /// <summary>
        /// Gets the order or this route.
        /// </summary>
        public static int GetOrder(this RouteData routeData)
        {
            return GetRouteDataTokenValue<int>(routeData, RouteDataTokenKeys.Order);
        }

        /// <summary>
        /// Gets the order or this route.
        /// </summary>
        public static int GetOrder(this Route route)
        {
            return GetRouteDataTokenValue<int>(route, RouteDataTokenKeys.Order);
        }

        /// <summary>
        /// Sets the order of this Route.
        /// </summary>
        public static void SetOrder(this Route route, int order)
        {
            SetRouteDataTokenValue(route, RouteDataTokenKeys.Order, order);
        }

        /// <summary>
        /// Gets a value indicating whether or not the route is a direct route to an action.
        /// </summary>
        public static bool GetTargetIsAction(this RouteData routeData)
        {
            return GetRouteDataTokenValue<bool>(routeData, RouteDataTokenKeys.TargetIsAction);
        }

        /// <summary>
        /// Gets a value indicating whether or not the route is a direct route to an action.
        /// </summary>
        public static bool GetTargetIsAction(this Route route)
        {
            return GetRouteDataTokenValue<bool>(route, RouteDataTokenKeys.TargetIsAction);
        }

        /// <summary>
        /// Sets a value indicating whether or not the route is a direct route to an action.
        /// </summary>
        public static void SetTargetIsAction(this Route route, bool targetIsAction)
        {
            SetRouteDataTokenValue(route, RouteDataTokenKeys.TargetIsAction, targetIsAction);
        }

        /// <summary>
        /// Gets the ControllerDescriptor that matches this Route.
        /// </summary>
        public static ControllerDescriptor GetTargetControllerDescriptor(this Route route)
        {
            var actions = GetTargetActionDescriptors(route);
            ControllerDescriptor controller = null;

            foreach (var action in actions)
            {
                if (controller == null)
                {
                    controller = action.ControllerDescriptor;
                }
                else if (controller != action.ControllerDescriptor)
                {
                    // Don't provide a single controller descriptor if multiple controllers match.
                    return null;
                }
            }

            return controller;
        }

        /// <summary>
        /// Gets the ControllerDescriptor that matches this Route.
        /// </summary>
        public static ControllerDescriptor GetTargetControllerDescriptor(this RouteData routeData)
        {
            var actions = GetTargetActionDescriptors(routeData);
            ControllerDescriptor controller = null;

            foreach (var action in actions)
            {
                if (controller == null)
                {
                    controller = action.ControllerDescriptor;
                }
                else if (controller != action.ControllerDescriptor)
                {
                    // Don't provide a single controller descriptor if multiple controllers match.
                    return null;
                }
            }

            return controller;
        }

        public static Type GetTargetControllerType(this RouteData routeData)
        {
            ControllerDescriptor controllerDescriptor = routeData.GetTargetControllerDescriptor();
            return controllerDescriptor == null ? null : controllerDescriptor.ControllerType;
        }

        /// <summary>
        /// Gets the target actions that can be matched if this route is matched.
        /// </summary>
        public static ActionDescriptor[] GetTargetActionDescriptors(this RouteData routeData)
        {
            return GetRouteDataTokenValue<ActionDescriptor[]>(routeData, RouteDataTokenKeys.Actions);
        }

        /// <summary>
        /// Gets the target actions that can be matched if this route is matched.
        /// </summary>
        public static ActionDescriptor[] GetTargetActionDescriptors(this Route route)
        {
            return GetRouteDataTokenValue<ActionDescriptor[]>(route, RouteDataTokenKeys.Actions);
        }

        /// <summary>
        /// Sets the target actions that can be matched if this route is matched.
        /// </summary>
        public static void SetTargetActionDescriptors(this Route route, ActionDescriptor[] actionDescriptors)
        {
            if (actionDescriptors == null || actionDescriptors.Length == 0)
            {
                throw Error.ParameterCannotBeNullOrEmpty("actionDescriptors");
            }

            SetRouteDataTokenValue(route, RouteDataTokenKeys.Actions, actionDescriptors);
        }

        public static bool HasDirectRouteMatch(this RouteData routeData)
        {
            if (routeData == null)
            {
                throw Error.ArgumentNull("routeData");
            }

            return routeData.Values.ContainsKey(RouteDataTokenKeys.DirectRouteMatches);
        }

        public static IEnumerable<RouteData> GetDirectRouteMatches(this RouteData routeData)
        {
            return GetRouteDataValue<IEnumerable<RouteData>>(routeData, RouteDataTokenKeys.DirectRouteMatches) ?? Enumerable.Empty<RouteData>();
        }

        public static void SetDirectRouteMatches(this RouteData routeData, IEnumerable<RouteData> matches)
        {
            if (matches == null || !matches.Any())
            {
                throw Error.ParameterCannotBeNullOrEmpty("matches");
            }

            SetRouteDataValue(routeData, RouteDataTokenKeys.DirectRouteMatches, matches);
        }

        public static bool IsDirectRoute(this RouteBase routeBase)
        {
            Route route = routeBase as Route;
            if (route == null)
            {
                return false;
            }
            else
            {
                // All direct routes need to have actions associated.
                return route.GetTargetActionDescriptors() != null;
            }
        }

        private static T GetRouteDataTokenValue<T>(this Route route, string key)
        {
            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            T value;
            if (route.DataTokens != null && route.DataTokens.TryGetValue(key, out value))
            {
                return value;
            }
            else
            {
                return default(T);
            }
        }

        private static T GetRouteDataTokenValue<T>(this RouteData routeData, string key)
        {
            if (routeData == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            return GetRouteDataTokenValue<T>(routeData.Route as Route, key);
        }

        private static void SetRouteDataTokenValue<T>(this Route route, string key, T value)
        {
            if (route == null)
            {
                throw Error.ArgumentNull("route");
            }

            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            if (route.DataTokens == null)
            {
                route.DataTokens = new RouteValueDictionary();
            }

            route.DataTokens[key] = value;
        }

        private static T GetRouteDataValue<T>(this RouteData routeData, string key)
        {
            if (routeData == null)
            {
                throw Error.ArgumentNull("routeData");
            }

            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            T value;
            if (routeData.Values.TryGetValue(key, out value))
            {
                return value;
            }
            else
            {
                return default(T);
            }
        }

        private static void SetRouteDataValue<T>(this RouteData routeData, string key, T value)
        {
            if (routeData == null)
            {
                throw Error.ArgumentNull("routeData");
            }

            if (key == null)
            {
                throw Error.ArgumentNull("key");
            }

            routeData.Values[key] = value;
        }
    }
}

================================================
FILE: src/System.Web.Mvc/Routing/IDirectRouteProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
#if ASPNETWEBAPI
using System.Web.Http.Controllers;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    /// <summary>
    /// Defines a provider for routes that directly target action descriptors (attribute routes).
    /// </summary>
    public interface IDirectRouteProvider
    {
        /// <summary>Gets the direct routes for a controller.</summary>
        /// <param name="controllerDescriptor">The controller descriptor.</param>
        /// <param name="actionDescriptors">The action descriptors.</param>
        /// <param name="constraintResolver">The inline constraint resolver.</param>
        /// <returns>A set of route entries for the controller.</returns>
#if ASPNETWEBAPI
        IReadOnlyList<RouteEntry> GetDirectRoutes(
            HttpControllerDescriptor controllerDescriptor, 
            IReadOnlyList<HttpActionDescriptor> actionDescriptors,
            IInlineConstraintResolver constraintResolver);
#else
        IReadOnlyList<RouteEntry> GetDirectRoutes(
            ControllerDescriptor controllerDescriptor,
            IReadOnlyList<ActionDescriptor> actionDescriptors,
            IInlineConstraintResolver constraintResolver);
#endif
    }
}


================================================
FILE: src/System.Web.Mvc/Routing/IRouteInfoProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    /// <summary>
    /// Provides information for building a <see cref="Route"/>.
    /// </summary>
    public interface IRouteInfoProvider
    {
        /// <summary>
        /// Gets the name of the route to generate.
        /// </summary>
        string Name { get; }

        /// <summary>
        /// Gets the route template describing the URI pattern to match against.
        /// </summary>
        string Template { get; }    
    }
}

================================================
FILE: src/System.Web.Mvc/Routing/LinkGenerationRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    /// <summary>
    /// Adapts a named direct route into a top-level entry in the route table that can only be used
    /// for generating a link (GetVirtualPath). We use these because the subroutes produced by direct
    /// routing, don't go into the main collection and so can't be matched by name.
    /// </summary>
    /// <remarks>
    /// Parallel to the Web API implementation of attribute routing in System.Web.Http.Routing.LinkGenerationRoute.
    /// </remarks>
    internal class LinkGenerationRoute : Route
    {
        private readonly Route _innerRoute;

        public LinkGenerationRoute(Route innerRoute)
            : base(innerRoute.Url, innerRoute.Defaults, innerRoute.Constraints, innerRoute.DataTokens,
            innerRoute.RouteHandler)
        {
            if (innerRoute == null)
            {
                throw Error.ArgumentNull("innerRoute");
            }

            _innerRoute = innerRoute;
        }

        public override RouteData GetRouteData(HttpContextBase httpContext)
        {
            // Claims no routes
            return null;
        }

        public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
        {
            return _innerRoute.GetVirtualPath(requestContext, values);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Routing/ParsedRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;

namespace System.Web.Mvc.Routing
{
    internal class ParsedRoute
    {
        public ParsedRoute(IList<PathSegment> pathSegments)
        {
            {
                Contract.Assert(pathSegments != null);
                PathSegments = pathSegments;
            }
        }

        public IList<PathSegment> PathSegments { get; private set; }
    }
}

================================================
FILE: src/System.Web.Mvc/Routing/RouteBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    /// <summary>
    /// Obsolete, use <see cref="System.Web.Mvc.Routing.RouteFactoryAttribute"/> to customize generated attribute
    /// routes.
    /// </summary>
    [Obsolete(
        "Obsolete, do not use. To create custom Routes with attribute routing, use " +
        "System.Web.Mvc.Routing.RouteFactoryAttribute")]
    public class RouteBuilder
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="RouteBuilder" /> class using the default inline constraint resolver.
        /// </summary>
        public RouteBuilder()
            : this(new DefaultInlineConstraintResolver())
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RouteBuilder" /> class.
        /// </summary>
        /// <param name="constraintResolver">The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints.</param>
        public RouteBuilder(IInlineConstraintResolver constraintResolver)
        {
            if (constraintResolver == null)
            {
                throw Error.ArgumentNull("constraintResolver");
            }

            ConstraintResolver = constraintResolver;
        }

        public IInlineConstraintResolver ConstraintResolver { get; private set; }

        /// <summary>
        /// Builds an <see cref="Route"/> for a particular controller.
        /// </summary>
        /// <param name="routeTemplate">The tokenized route template for the route.</param>
        /// <param name="controllerDescriptor">The controller the route attribute has been applied on.</param>
        /// <returns>The generated <see cref="Route"/>.</returns>
        public Route BuildDirectRoute(string routeTemplate, ControllerDescriptor controllerDescriptor)
        {
            if (routeTemplate == null)
            {
                throw Error.ArgumentNull("routeTemplate");
            }

            if (controllerDescriptor == null)
            {
                throw Error.ArgumentNull("controllerDescriptor");
            }
                        
            string controllerName = controllerDescriptor.ControllerName;
                        
            RouteAreaAttribute area = controllerDescriptor.GetAreaFrom();
            string areaName = controllerDescriptor.GetAreaName(area);

            RouteValueDictionary defaults = new RouteValueDictionary
            {
                { "controller", controllerName }
            };

            Type controllerType = controllerDescriptor.ControllerType;

            RouteValueDictionary dataTokens = new RouteValueDictionary();
            if (areaName != null)
            {
                dataTokens.Add(RouteDataTokenKeys.Area, areaName);
                dataTokens.Add(RouteDataTokenKeys.UseNamespaceFallback, value: false);
                if (controllerType != null)
                {
                    dataTokens.Add(RouteDataTokenKeys.Namespaces, new[] { controllerType.Namespace });
                }
            }

            RouteValueDictionary constraints = new RouteValueDictionary();
            string detokenizedRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(routeTemplate, defaults, constraints, ConstraintResolver);

            Route route = new Route(detokenizedRouteTemplate, new MvcRouteHandler())
            {
                Defaults = defaults,
                Constraints = constraints,
                DataTokens = dataTokens
            };

            return route;
        }

        /// <summary>
        /// Builds an <see cref="Route"/> for a particular action.
        /// </summary>
        /// <param name="routeTemplate">The tokenized route template for the route.</param>
        /// <param name="allowedMethods">The HTTP methods supported by the route. A null value specify that all possible methods are supported.</param>
        /// <param name="controllerName">The name of the associated controller.</param>
        /// <param name="actionName">The name of the associated action.</param>
        /// <param name="targetMethod">The method that the route attribute has been applied on.</param>
        /// <param name="areaName"></param>
        /// <returns>The generated <see cref="Route"/>.</returns>
        public Route BuildDirectRoute(string routeTemplate, IEnumerable<string> allowedMethods, string controllerName, string actionName, MethodInfo targetMethod, string areaName)
        {
            if (routeTemplate == null)
            {
                throw Error.ArgumentNull("routeTemplate");
            }

            if (controllerName == null)
            {
                throw Error.ArgumentNull("controllerName");
            }

            if (actionName == null)
            {
                throw Error.ArgumentNull("actionName");
            }

            RouteValueDictionary defaults = new RouteValueDictionary
            {
                { "controller", controllerName },
                { "action", actionName }
            };

            RouteValueDictionary constraints = new RouteValueDictionary();
            if (allowedMethods != null)
            {
                string[] array = allowedMethods.ToArray();
                if (array.Length > 0)
                {
                    // Current method constraint implementation is inefficient since it matches before running the constraint.
                    // Consider checking the HTTP method first in a custom route as a performance optimization.
                    constraints.Add("httpMethod", new HttpMethodConstraint(array));
                }
            }

            RouteValueDictionary dataTokens = new RouteValueDictionary();
            if (areaName != null)
            {
                dataTokens.Add(RouteDataTokenKeys.Area, areaName);
                dataTokens.Add(RouteDataTokenKeys.UseNamespaceFallback, value: false);
                if (targetMethod.DeclaringType != null)
                {
                    dataTokens.Add(RouteDataTokenKeys.Namespaces, new[] { targetMethod.DeclaringType.Namespace });
                }
            }

            string detokenizedRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(routeTemplate, defaults, constraints, ConstraintResolver);

            return BuildDirectRoute(defaults, constraints, dataTokens, detokenizedRouteTemplate, targetMethod);
        }

        /// <summary>
        /// Builds an <see cref="Route"/>.
        /// </summary>
        /// <param name="defaults">The route defaults.</param>
        /// <param name="constraints">The route constraints.</param>
        /// <param name="dataTokens"></param>
        /// <param name="routeTemplate">The detokenized route template.</param>
        /// <param name="targetMethod">The method that the route attribute has been applied on.</param>
        /// <returns>The generated <see cref="Route"/>.</returns>
        public virtual Route BuildDirectRoute(RouteValueDictionary defaults, RouteValueDictionary constraints, RouteValueDictionary dataTokens, string routeTemplate, MethodInfo targetMethod)
        {
            Route route = new Route(routeTemplate, new MvcRouteHandler())
            {
                Defaults = defaults,
                Constraints = constraints,
                DataTokens = dataTokens
            };

            return route;
        }
    }
}

================================================
FILE: src/System.Web.Mvc/Routing/RouteCollectionAttributeRoutingExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Routing;
using System.Web.Routing;

namespace System.Web.Mvc
{
    // Corresponds to the Web API implementation of attribute routing in System.Web.Http.HttpConfigurationExtensions.
    public static class RouteCollectionAttributeRoutingExtensions
    {
        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes"></param>
        public static void MapMvcAttributeRoutes(this RouteCollection routes)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            AttributeRoutingMapper.MapAttributeRoutes(routes, new DefaultInlineConstraintResolver());
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.
        /// </param>
        public static void MapMvcAttributeRoutes(this RouteCollection routes,
            IInlineConstraintResolver constraintResolver)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            AttributeRoutingMapper.MapAttributeRoutes(routes, constraintResolver);
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="directRouteProvider">
        /// The <see cref="IDirectRouteProvider"/> to use for mapping routes.
        /// </param>
        public static void MapMvcAttributeRoutes(
            this RouteCollection routes,
            IDirectRouteProvider directRouteProvider)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            if (directRouteProvider == null)
            {
                throw new ArgumentNullException("directRouteProvider");
            }

            AttributeRoutingMapper.MapAttributeRoutes(routes, new DefaultInlineConstraintResolver(), directRouteProvider);
        }

        /// <summary>
        /// Maps the attribute-defined routes for the application.
        /// </summary>
        /// <param name="routes"></param>
        /// <param name="constraintResolver">
        /// The <see cref="IInlineConstraintResolver"/> to use for resolving inline constraints in route templates.
        /// </param>
        /// <param name="directRouteProvider">
        /// The <see cref="IDirectRouteProvider"/> to use for mapping routes.
        /// </param>
        public static void MapMvcAttributeRoutes(
            this RouteCollection routes,
            IInlineConstraintResolver constraintResolver,
            IDirectRouteProvider directRouteProvider)
        {
            if (routes == null)
            {
                throw new ArgumentNullException("routes");
            }

            if (constraintResolver == null)
            {
                throw new ArgumentNullException("constraintResolver");
            }

            if (directRouteProvider == null)
            {
                throw new ArgumentNullException("directRouteProvider");
            }

            AttributeRoutingMapper.MapAttributeRoutes(routes, constraintResolver, directRouteProvider);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/Routing/RouteCollectionRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Web.Routing;

namespace System.Web.Mvc.Routing
{
    /// <summary>
    /// A single route that is the composite of multiple "sub routes".  
    /// </summary>
    /// <remarks>
    /// Corresponds to the Web API implementation of attribute routing in System.Web.Http.Routing.RouteCollectionRoute.
    /// </remarks>
    internal class RouteCollectionRoute : RouteBase, IReadOnlyCollection<RouteBase>
    {
        private readonly IReadOnlyCollection<RouteBase> _subRoutes;

        public RouteCollectionRoute(IReadOnlyCollection<RouteBase> subRoutes)
        {
            if (subRoutes == null)
            {
                throw new ArgumentNullException("subRoutes");
            }

            _subRoutes = subRoutes;
        }

        public override RouteData GetRouteData(HttpContextBase httpContext)
        {
            List<RouteData> matches = new List<RouteData>();
            foreach (RouteBase route in _subRoutes)
            {
                var match = route.GetRouteData(httpContext);
                if (match != null)
                {
                    matches.Add(match);
                }
            }

            return CreateDirectRouteMatch(this, matches);
        }

        public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
        {
            // Link generation is not supported via the RouteCollectionRoute - see LinkGenerationRoute.
            return null;
        }

        public int Count
        {
            get { return _subRoutes.Count; }
        }

        public IEnumerator<RouteBase> GetEnumerator()
        {
            return _subRoutes.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _subRoutes.GetEnumerator();
        }

        public static RouteData CreateDirectRouteMatch(RouteBase route, List<RouteData> matches)
        {
            if (matches.Count == 0)
            {
                return null;
            }
            else
            {
                var routeData = new RouteData();
                routeData.Route = route;
                routeData.RouteHandler = new MvcRouteHandler();
                routeData.SetDirectRouteMatches(matches);

                // At a few points in the code (MvcRouteHandler, MvcHandler) we need to look up the controller
                // by name. For the purposes of error handling/debugging, it's helpful if we can have a name
                // in this code to pass through.
                //
                // Inside the DefaultControllerFactory we'll double check the route data and throw if we have
                // multiple controller matches, but for now let's just use the controller of the first match.
                ControllerDescriptor controllerDescriptor = matches[0].GetTargetControllerDescriptor();
                if (controllerDescriptor != null)
                {
                    routeData.Values[RouteDataTokenKeys.Controller] = controllerDescriptor.ControllerName;
                }

                return routeData;
            }
        }
    }
}

================================================
FILE: src/System.Web.Mvc/Routing/RouteDataTokenKeys.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Routing
{
    internal class RouteDataTokenKeys
    {
        public const string UseNamespaceFallback = "UseNamespaceFallback";
        public const string Namespaces = "Namespaces";
        public const string Area = "area";
        public const string Controller = "controller";

        // Used to provide the action descriptors to consider for attribute routing
        public const string Actions = "MS_DirectRouteActions";

        // Used to allow customer-provided disambiguation between multiple matching attribute routes
        public const string Order = "MS_DirectRouteOrder";

        // Used to prioritize routes to actions for link generation
        public const string TargetIsAction = "MS_DirectRouteTargetIsAction";

        // Used to allow URI constraint-based disambiguation between multiple matching attribute routes
        public const string Precedence = "MS_DirectRoutePrecedence";

        public const string DirectRouteMatches = "MS_DirectRouteMatches";
    }
}

================================================
FILE: src/System.Web.Mvc/SelectList.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Naming", "CA1710:IdentifiersShouldHaveCorrectSuffix", Justification = "This is a shipped API")]
    public class SelectList : MultiSelectList
    {
        public SelectList(IEnumerable items)
            : this(items, selectedValue: null)
        {
        }

        public SelectList(IEnumerable items, object selectedValue)
            : this(items, dataValueField: null, dataTextField: null, selectedValue: selectedValue)
        {
        }

        /// <summary>
        /// Initializes a new instance of the SelectList class by using the specified items for the list,
        /// the selected value, and the disabled values.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="selectedValue">The selected value. Used to match the Selected property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        public SelectList(IEnumerable items, object selectedValue, IEnumerable disabledValues)
            : this(items,
                   dataValueField: null,
                   dataTextField: null,
                   selectedValue: selectedValue,
                   disabledValues: disabledValues)
        {
        }

        public SelectList(IEnumerable items, string dataValueField, string dataTextField)
            : this(items, dataValueField, dataTextField, selectedValue: null)
        {
        }

        public SelectList(IEnumerable items, string dataValueField, string dataTextField, object selectedValue)
            : base(items, dataValueField, dataTextField, ToEnumerable(selectedValue))
        {
            SelectedValue = selectedValue;
        }

        /// <summary>
        /// Initializes a new instance of the SelectList class by using the specified items for the list,
        /// the data value field, the data text field, the data group field, and the selected value.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataGroupField">The data group field. Used to match the Group property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValue">The selected value. Used to match the Selected property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        public SelectList(IEnumerable items,
                          string dataValueField,
                          string dataTextField,
                          string dataGroupField,
                          object selectedValue)
            : base(items, dataValueField, dataTextField, dataGroupField, ToEnumerable(selectedValue))
        {
            SelectedValue = selectedValue;
        }

        /// <summary>
        /// Initializes a new instance of the SelectList class by using the specified items for the list,
        /// the data value field, the data text field, the selected value, and the disabled values.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValue">The selected value. Used to match the Selected property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        public SelectList(IEnumerable items,
                          string dataValueField,
                          string dataTextField,
                          object selectedValue,
                          IEnumerable disabledValues)
            : base(items, dataValueField, dataTextField, ToEnumerable(selectedValue), disabledValues)
        {
            SelectedValue = selectedValue;
        }

        /// <summary>
        /// Initializes a new instance of the SelectList class by using the specified items for the list,
        /// the data value field, the data text field, the data group field, the selected value, and the disabled
        /// values.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataGroupField">The data group field. Used to match the Group property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValue">The selected value. Used to match the Selected property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        public SelectList(IEnumerable items,
                          string dataValueField,
                          string dataTextField,
                          string dataGroupField,
                          object selectedValue,
                          IEnumerable disabledValues)
            : base(items, dataValueField, dataTextField, dataGroupField, ToEnumerable(selectedValue), disabledValues)
        {
            SelectedValue = selectedValue;
        }

        /// <summary>
        /// Initializes a new instance of the SelectList class by using the specified items for the list,
        /// the data value field, the data text field, the data group field. the selected value, the disabled values,
        /// and the disabled groups.
        /// </summary>
        /// <param name="items">The items used to build each <see cref="SelectListItem"/> of the list.</param>
        /// <param name="dataValueField">The data value field. Used to match the Value property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataTextField">The data text field. Used to match the Text property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="dataGroupField">The data group field. Used to match the Group property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="selectedValue">The selected value. Used to match the Selected property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="disabledValues">The disabled values. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListItem"/>.</param>
        /// <param name="disabledGroups">The disabled groups. Used to match the Disabled property of the corresponding
        /// <see cref="SelectListGroup"/>.</param>
        public SelectList(IEnumerable items,
                          string dataValueField,
                          string dataTextField,
                          string dataGroupField,
                          object selectedValue,
                          IEnumerable disabledValues,
                          IEnumerable disabledGroups)
            : base(items,
                   dataValueField,
                   dataTextField,
                   dataGroupField,
                   ToEnumerable(selectedValue),
                   disabledValues,
                   disabledGroups)
        {
            SelectedValue = selectedValue;
        }

        public object SelectedValue { get; private set; }

        private static IEnumerable ToEnumerable(object selectedValue)
        {
            return (selectedValue != null) ? new object[] { selectedValue } : null;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/SelectListGroup.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    /// <summary>
    /// Represents the optgroup HTML element and its attributes.
    /// In a select list, multiple groups with the same name are supported.
    /// They are compared with reference equality.
    /// </summary>
    public class SelectListGroup
    {
        /// <summary>
        /// Gets or sets a value that indicates whether this <see cref="SelectListGroup"/> is disabled. 
        /// </summary>
        public bool Disabled { get; set; }

        /// <summary>
        /// Represents the value of the optgroup's label.
        /// </summary>
        public string Name { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/SelectListItem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class SelectListItem
    {
        /// <summary>
        /// Gets or sets a value that indicates whether this <see cref="SelectListItem"/> is disabled.
        /// </summary>
        public bool Disabled { get; set; }

        /// <summary>
        /// Represents the optgroup HTML element this item is wrapped into.
        /// In a select list, multiple groups with the same name are supported.
        /// They are compared with reference equality.
        /// </summary>
        public SelectListGroup Group { get; set; }

        public bool Selected { get; set; }

        public string Text { get; set; }

        public string Value { get; set; }
    }
}


================================================
FILE: src/System.Web.Mvc/SessionStateAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.SessionState;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public sealed class SessionStateAttribute : Attribute
    {
        public SessionStateAttribute(SessionStateBehavior behavior)
        {
            Behavior = behavior;
        }

        public SessionStateBehavior Behavior { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/SessionStateTempDataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class SessionStateTempDataProvider : ITempDataProvider
    {
        internal const string TempDataSessionStateKey = "__ControllerTempData";

        public virtual IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
        {
            HttpSessionStateBase session = controllerContext.HttpContext.Session;

            if (session != null)
            {
                Dictionary<string, object> tempDataDictionary = session[TempDataSessionStateKey] as Dictionary<string, object>;

                if (tempDataDictionary != null)
                {
                    // If we got it from Session, remove it so that no other request gets it
                    session.Remove(TempDataSessionStateKey);
                    return tempDataDictionary;
                }
            }

            return new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        }

        public virtual void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }

            HttpSessionStateBase session = controllerContext.HttpContext.Session;
            bool isDirty = (values != null && values.Count > 0);

            if (session == null)
            {
                if (isDirty)
                {
                    throw new InvalidOperationException(MvcResources.SessionStateTempDataProvider_SessionStateDisabled);
                }
            }
            else
            {
                if (isDirty)
                {
                    session[TempDataSessionStateKey] = values;
                }
                else
                {
                    // Since the default implementation of Remove() (from SessionStateItemCollection) dirties the
                    // collection, we shouldn't call it unless we really do need to remove the existing key.
                    if (session[TempDataSessionStateKey] != null)
                    {
                        session.Remove(TempDataSessionStateKey);
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/SingleServiceResolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    internal class SingleServiceResolver<TService> : IResolver<TService>
        where TService : class
    {
        private Lazy<TService> _currentValueFromResolver;
        private Func<TService> _currentValueThunk;
        private TService _defaultValue;
        private Func<IDependencyResolver> _resolverThunk;
        private string _callerMethodName;

        public SingleServiceResolver(Func<TService> currentValueThunk, TService defaultValue, string callerMethodName)
        {
            if (currentValueThunk == null)
            {
                throw new ArgumentNullException("currentValueThunk");
            }
            if (defaultValue == null)
            {
                throw new ArgumentNullException("defaultValue");
            }

            _resolverThunk = () => DependencyResolver.Current;
            _currentValueFromResolver = new Lazy<TService>(GetValueFromResolver);
            _currentValueThunk = currentValueThunk;
            _defaultValue = defaultValue;
            _callerMethodName = callerMethodName;
        }

        internal SingleServiceResolver(Func<TService> staticAccessor, TService defaultValue, IDependencyResolver resolver, string callerMethodName)
            : this(staticAccessor, defaultValue, callerMethodName)
        {
            if (resolver != null)
            {
                _resolverThunk = () => resolver;
            }
        }

        public TService Current
        {
            get { return _currentValueFromResolver.Value ?? _currentValueThunk() ?? _defaultValue; }
        }

        private TService GetValueFromResolver()
        {
            TService result = _resolverThunk().GetService<TService>();

            if (result != null && _currentValueThunk() != null)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, MvcResources.SingleServiceResolver_CannotRegisterTwoInstances, typeof(TService).Name.ToString(), _callerMethodName));
            }

            return result;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/StringLengthAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    public class StringLengthAttributeAdapter : DataAnnotationsModelValidator<StringLengthAttribute>
    {
        public StringLengthAttributeAdapter(ModelMetadata metadata, ControllerContext context, StringLengthAttribute attribute)
            : base(metadata, context, attribute)
        {
        }

        public override IEnumerable<ModelClientValidationRule> GetClientValidationRules()
        {
            return new[] { new ModelClientValidationStringLengthRule(ErrorMessage, Attribute.MinimumLength, Attribute.MaximumLength) };
        }
    }
}


================================================
FILE: src/System.Web.Mvc/System.Web.Mvc.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{3D3FFD8A-624D-4E9B-954B-E1C105507975}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Mvc</RootNamespace>
    <AssemblyName>System.Web.Mvc</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
    <NoWarn>1591</NoWarn>
    <BaseAddress>1609891840</BaseAddress>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <Private>True</Private>
      <HintPath>..\..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Entity" />
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Runtime.Caching" />
    <Reference Include="System.Web" />
    <Reference Include="System.Data" />
    <Reference Include="System.Web.Abstractions" />
    <Reference Include="System.Web.Extensions" />
    <Reference Include="System.Web.Routing" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\Common\AttributeList.cs">
      <Link>Common\AttributeList.cs</Link>
    </Compile>
    <Compile Include="..\Common\DictionaryExtensions.cs">
      <Link>Common\DictionaryExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\ListWrapperCollection.cs">
      <Link>Common\ListWrapperCollection.cs</Link>
    </Compile>
    <Compile Include="..\Common\PrefixContainer.cs">
      <Link>Common\PrefixContainer.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DirectRouteBuilder.cs">
      <Link>Routing\DirectRouteBuilder.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DirectRouteFactoryContext.cs">
      <Link>Routing\DirectRouteFactoryContext.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IDirectRouteBuilder.cs">
      <Link>Routing\IDirectRouteBuilder.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IDirectRouteFactory.cs">
      <Link>Routing\IDirectRouteFactory.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IInlineConstraintResolver.cs">
      <Link>Routing\IInlineConstraintResolver.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteEntry.cs">
      <Link>Routing\RouteEntry.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteFactoryAttribute.cs">
      <Link>Routing\RouteFactoryAttribute.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteInfoDirectRouteFactory.cs">
      <Link>Routing\RouteInfoDirectRouteFactory.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteParser.cs">
      <Link>Routing\RouteParser.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RoutePrecedence.cs">
      <Link>Routing\RoutePrecedence.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpers.cs">
      <Link>Common\TaskHelpers.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpersExtensions.cs">
      <Link>Common\TaskHelpersExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\AlphaRouteConstraint.cs">
      <Link>Routing\Constraints\AlphaRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\BoolRouteConstraint.cs">
      <Link>Routing\Constraints\BoolRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\CompoundRouteConstraint.cs">
      <Link>Routing\Constraints\CompoundRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\DateTimeRouteConstraint.cs">
      <Link>Routing\Constraints\DateTimeRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\DecimalRouteConstraint.cs">
      <Link>Routing\Constraints\DecimalRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\DoubleRouteConstraint.cs">
      <Link>Routing\Constraints\DoubleRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\FloatRouteConstraint.cs">
      <Link>Routing\Constraints\FloatRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\GuidRouteConstraint.cs">
      <Link>Routing\Constraints\GuidRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\IntRouteConstraint.cs">
      <Link>Routing\Constraints\IntRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\LengthRouteConstraint.cs">
      <Link>Routing\Constraints\LengthRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\LongRouteConstraint.cs">
      <Link>Routing\Constraints\LongRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MaxLengthRouteConstraint.cs">
      <Link>Routing\Constraints\MaxLengthRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MaxRouteConstraint.cs">
      <Link>Routing\Constraints\MaxRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MinLengthRouteConstraint.cs">
      <Link>Routing\Constraints\MinLengthRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\MinRouteConstraint.cs">
      <Link>Routing\Constraints\MinRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\RangeRouteConstraintBase.cs">
      <Link>Routing\Constraints\RangeRouteConstraintBase.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\RegexRouteConstraint.cs">
      <Link>Routing\Constraints\RegexRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\Constraints\OptionalRouteConstraint.cs">
      <Link>Routing\Constraints\OptionalRouteConstraint.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DefaultInlineConstraintResolver.cs">
      <Link>Routing\DefaultInlineConstraintResolver.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\InlineRouteTemplateParser.cs">
      <Link>Routing\InlineRouteTemplateParser.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\SubRouteCollection.cs">
      <Link>Routing\SubRouteCollection.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\IRoutePrefix.cs">
      <Link>Routing\IRoutePrefix.cs</Link>
    </Compile>
    <Compile Include="ActionMethodSelectorBase.cs" />
    <Compile Include="ActionNameSelector.cs" />
    <Compile Include="AreaReference.cs" />
    <Compile Include="ControllerDescriptorExtensions.cs" />
    <Compile Include="Async\IAsyncActionInvokerFactory.cs" />
    <Compile Include="CopyOnWriteDictionary.cs" />
    <Compile Include="IActionInvokerFactory.cs" />
    <Compile Include="IMethodInfoActionDescriptor.cs" />
    <Compile Include="ITempDataProviderFactory.cs" />
    <Compile Include="JQueryFormValueProvider.cs" />
    <Compile Include="JQueryFormValueProviderFactory.cs" />
    <Compile Include="Routing\DefaultDirectRouteProvider.cs" />
    <Compile Include="Routing\IDirectRouteProvider.cs" />
    <Compile Include="SelectListGroup.cs" />
    <Compile Include="Html\EnumHelper.cs" />
    <Compile Include="MaxLengthAttributeAdapter.cs" />
    <Compile Include="MinLengthAttributeAdapter.cs" />
    <Compile Include="Properties\MvcResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>MvcResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Routing\ConstraintValidation.cs" />
    <Compile Include="Routing\DirectRouteCandidate.cs" />
    <Compile Include="Routing\LinkGenerationRoute.cs" />
    <Compile Include="Routing\RouteCollectionRoute.cs" />
    <Compile Include="Routing\ParsedRoute.cs" />
    <Compile Include="..\Common\Routing\PathContentSegment.cs">
      <Link>Routing\PathContentSegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathLiteralSubsegment.cs">
      <Link>Routing\PathLiteralSubsegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathParameterSubsegment.cs">
      <Link>Routing\PathParameterSubsegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathSegment.cs">
      <Link>Routing\PathSegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathSeparatorSegment.cs">
      <Link>Routing\PathSeparatorSegment.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\PathSubsegment.cs">
      <Link>Routing\PathSubsegment.cs</Link>
    </Compile>
    <Compile Include="AdditionalMetaDataAttribute.cs" />
    <Compile Include="AllowAnonymousAttribute.cs" />
    <Compile Include="ActionDescriptorHelper.cs" />
    <Compile Include="Async\BeginInvokeDelegateOfTState.cs" />
    <Compile Include="Async\TaskAsyncActionDescriptor.cs" />
    <Compile Include="Async\TaskWrapperAsyncResult.cs" />
    <Compile Include="Filters\AuthenticationChallengeContext.cs" />
    <Compile Include="Filters\AuthenticationContext.cs" />
    <Compile Include="BuildManagerCompiledView.cs" />
    <Compile Include="BuildManagerViewEngine.cs" />
    <Compile Include="CachedAssociatedMetadataProvider.cs" />
    <Compile Include="CachedDataAnnotationsMetadataAttributes.cs" />
    <Compile Include="CachedDataAnnotationsModelMetadata.cs" />
    <Compile Include="CachedDataAnnotationsModelMetadataProvider.cs" />
    <Compile Include="CachedModelMetadata.cs" />
    <Compile Include="CancellationTokenModelBinder.cs" />
    <Compile Include="CompareAttributeAdapter.cs" />
    <Compile Include="DataTypeAttributeAdapter.cs" />
    <Compile Include="Async\EndInvokeDelegateOfTResultTState.cs" />
    <Compile Include="Async\EndInvokeVoidDelegate.cs" />
    <Compile Include="FileExtensionsAttributeAdapter.cs" />
    <Compile Include="Filters\IAuthenticationFilter.cs" />
    <Compile Include="Filters\IOverrideFilter.cs" />
    <Compile Include="Html5DateRenderingMode.cs" />
    <Compile Include="RouteAttribute.cs" />
    <Compile Include="MembershipPasswordAttributeAdapter.cs" />
    <Compile Include="CompareAttribute.cs" />
    <Compile Include="ChildActionValueProvider.cs" />
    <Compile Include="ChildActionValueProviderFactory.cs" />
    <Compile Include="HttpHeadAttribute.cs" />
    <Compile Include="HttpOptionsAttribute.cs" />
    <Compile Include="HttpPatchAttribute.cs" />
    <Compile Include="IEnumerableValueProvider.cs" />
    <Compile Include="DataTypeUtil.cs" />
    <Compile Include="Html\DisplayNameExtensions.cs" />
    <Compile Include="Html\NameExtensions.cs" />
    <Compile Include="Html\ValueExtensions.cs" />
    <Compile Include="OverrideActionFiltersAttribute.cs" />
    <Compile Include="OverrideAuthenticationAttribute.cs" />
    <Compile Include="OverrideAuthorizationAttribute.cs" />
    <Compile Include="OverrideExceptionFiltersAttribute.cs" />
    <Compile Include="OverrideResultFiltersAttribute.cs" />
    <Compile Include="Razor\MvcCSharpRazorCodeGenerator.cs" />
    <Compile Include="Razor\SetModelTypeCodeGenerator.cs" />
    <Compile Include="ReflectedAttributeCache.cs" />
    <Compile Include="RouteAreaAttribute.cs" />
    <Compile Include="Routing\AttributeRoutingMapper.cs" />
    <Compile Include="Routing\DirectRouteExtensions.cs" />
    <Compile Include="Routing\IRouteInfoProvider.cs" />
    <Compile Include="Routing\RouteBuilder.cs" />
    <Compile Include="Routing\RouteCollectionAttributeRoutingExtensions.cs" />
    <Compile Include="RoutePrefixAttribute.cs" />
    <Compile Include="Routing\RouteDataTokenKeys.cs" />
    <Compile Include="SessionStateAttribute.cs" />
    <Compile Include="AllowHtmlAttribute.cs" />
    <Compile Include="UnvalidatedRequestValuesAccessor.cs" />
    <Compile Include="UnvalidatedRequestValuesWrapper.cs" />
    <Compile Include="IUnvalidatedRequestValues.cs" />
    <Compile Include="IUnvalidatedValueProvider.cs" />
    <Compile Include="DependencyResolverExtensions.cs" />
    <Compile Include="ExpressionUtil\BinaryExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\CachedExpressionCompiler.cs" />
    <Compile Include="ExpressionUtil\ConditionalExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ConstantExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\DefaultExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ExpressionFingerprintChain.cs" />
    <Compile Include="ExpressionUtil\FingerprintingExpressionVisitor.cs" />
    <Compile Include="ExpressionUtil\HashCodeCombiner.cs" />
    <Compile Include="ExpressionUtil\Hoisted.cs" />
    <Compile Include="ExpressionUtil\HoistingExpressionVisitor.cs" />
    <Compile Include="ExpressionUtil\IndexExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\LambdaExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\MemberExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\MethodCallExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\ParameterExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\TypeBinaryExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\UnaryExpressionFingerprint.cs" />
    <Compile Include="IControllerActivator.cs" />
    <Compile Include="IModelBinderProvider.cs" />
    <Compile Include="IUniquelyIdentifiable.cs" />
    <Compile Include="IViewStartPageChild.cs" />
    <Compile Include="IResolver.cs" />
    <Compile Include="ControllerInstanceFilterProvider.cs" />
    <Compile Include="RazorView.cs" />
    <Compile Include="RazorViewEngine.cs" />
    <Compile Include="DynamicViewDataDictionary.cs" />
    <Compile Include="Filter.cs" />
    <Compile Include="FilterAttributeFilterProvider.cs" />
    <Compile Include="FilterProviderCollection.cs" />
    <Compile Include="FilterProviders.cs" />
    <Compile Include="FilterScope.cs" />
    <Compile Include="GlobalFilterCollection.cs" />
    <Compile Include="GlobalFilters.cs" />
    <Compile Include="IFilterProvider.cs" />
    <Compile Include="IMvcFilter.cs" />
    <Compile Include="IViewPageActivator.cs" />
    <Compile Include="ModelBinderProviderCollection.cs" />
    <Compile Include="ModelBinderProviders.cs" />
    <Compile Include="MultiServiceResolver.cs" />
    <Compile Include="Razor\MvcCSharpRazorCodeParser.cs" />
    <Compile Include="MvcFilter.cs" />
    <Compile Include="Razor\MvcVBRazorCodeParser.cs" />
    <Compile Include="Razor\MvcWebPageRazorHost.cs" />
    <Compile Include="MvcWebRazorHostFactory.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="RemoteAttribute.cs" />
    <Compile Include="SingleServiceResolver.cs" />
    <Compile Include="Razor\StartPageLookupDelegate.cs" />
    <Compile Include="TagBuilderExtensions.cs" />
    <Compile Include="ViewStartPage.cs" />
    <Compile Include="WebViewPage.cs" />
    <Compile Include="WebViewPageOfTModel.cs" />
    <Compile Include="HttpNotFoundResult.cs" />
    <Compile Include="HttpStatusCodeResult.cs" />
    <Compile Include="IMvcControlBuilder.cs" />
    <Compile Include="AssociatedMetadataProvider.cs" />
    <Compile Include="ActionExecutedContext.cs" />
    <Compile Include="ActionExecutingContext.cs" />
    <Compile Include="ClientDataTypeModelValidatorProvider.cs" />
    <Compile Include="AssociatedValidatorProvider.cs" />
    <Compile Include="Async\ActionDescriptorCreator.cs" />
    <Compile Include="Async\AsyncActionDescriptor.cs" />
    <Compile Include="Async\AsyncActionMethodSelector.cs" />
    <Compile Include="Async\AsyncControllerActionInvoker.cs" />
    <Compile Include="Async\SynchronousOperationException.cs" />
    <Compile Include="Async\AsyncManager.cs" />
    <Compile Include="AsyncTimeoutAttribute.cs" />
    <Compile Include="Async\BeginInvokeDelegate.cs" />
    <Compile Include="Async\AsyncResultWrapper.cs" />
    <Compile Include="Async\AsyncVoid.cs" />
    <Compile Include="AsyncController.cs" />
    <Compile Include="Async\IAsyncController.cs" />
    <Compile Include="Async\IAsyncActionInvoker.cs" />
    <Compile Include="Async\IAsyncManagerContainer.cs" />
    <Compile Include="IClientValidatable.cs" />
    <Compile Include="IMetadataAware.cs" />
    <Compile Include="IDependencyResolver.cs" />
    <Compile Include="JsonValueProviderFactory.cs" />
    <Compile Include="DependencyResolver.cs" />
    <Compile Include="UrlParameter.cs" />
    <Compile Include="FormValueProvider.cs" />
    <Compile Include="FormValueProviderFactory.cs" />
    <Compile Include="HttpFileCollectionValueProvider.cs" />
    <Compile Include="HttpFileCollectionValueProviderFactory.cs" />
    <Compile Include="QueryStringValueProvider.cs" />
    <Compile Include="QueryStringValueProviderFactory.cs" />
    <Compile Include="RangeAttributeAdapter.cs" />
    <Compile Include="RegularExpressionAttributeAdapter.cs" />
    <Compile Include="RequiredAttributeAdapter.cs" />
    <Compile Include="RouteDataValueProvider.cs" />
    <Compile Include="RouteDataValueProviderFactory.cs" />
    <Compile Include="StringLengthAttributeAdapter.cs" />
    <Compile Include="TypeCacheUtil.cs" />
    <Compile Include="TypeCacheSerializer.cs" />
    <Compile Include="Html\DisplayTextExtensions.cs" />
    <Compile Include="NoAsyncTimeoutAttribute.cs" />
    <Compile Include="Async\OperationCounter.cs" />
    <Compile Include="Async\ReflectedAsyncActionDescriptor.cs" />
    <Compile Include="Async\ReflectedAsyncControllerDescriptor.cs" />
    <Compile Include="Async\Trigger.cs" />
    <Compile Include="Async\TriggerListener.cs" />
    <Compile Include="Async\SimpleAsyncResult.cs" />
    <Compile Include="Async\EndInvokeDelegateOfTResult.cs" />
    <Compile Include="Async\SynchronizationContextUtil.cs" />
    <Compile Include="AuthorizationContext.cs" />
    <Compile Include="ByteArrayModelBinder.cs" />
    <Compile Include="ControllerContext.cs" />
    <Compile Include="Html\ChildActionExtensions.cs" />
    <Compile Include="ParameterInfoUtil.cs" />
    <Compile Include="HttpHandlerUtil.cs" />
    <Compile Include="ChildActionOnlyAttribute.cs" />
    <Compile Include="TypeDescriptorHelper.cs" />
    <Compile Include="ValidatableObjectAdapter.cs" />
    <Compile Include="ValueProviderFactories.cs" />
    <Compile Include="ValueProviderFactory.cs" />
    <Compile Include="ValueProviderFactoryCollection.cs" />
    <Compile Include="ValueProviderCollection.cs" />
    <Compile Include="DictionaryValueProvider.cs" />
    <Compile Include="NameValueCollectionValueProvider.cs" />
    <Compile Include="ValueProviderUtil.cs" />
    <Compile Include="IValueProvider.cs" />
    <Compile Include="DataErrorInfoModelValidatorProvider.cs" />
    <Compile Include="ModelValidatorProviderCollection.cs" />
    <Compile Include="DataAnnotationsModelMetadata.cs" />
    <Compile Include="HiddenInputAttribute.cs" />
    <Compile Include="HttpGetAttribute.cs" />
    <Compile Include="HttpPutAttribute.cs" />
    <Compile Include="HttpDeleteAttribute.cs" />
    <Compile Include="MvcHtmlString.cs" />
    <Compile Include="DataAnnotationsModelValidator.cs" />
    <Compile Include="DataAnnotationsModelValidatorProvider.cs" />
    <Compile Include="DataAnnotationsModelValidatorOfTAttribute.cs" />
    <Compile Include="EmptyModelValidatorProvider.cs" />
    <Compile Include="ExpressionHelper.cs" />
    <Compile Include="FieldValidationMetadata.cs" />
    <Compile Include="FormContext.cs" />
    <Compile Include="JsonRequestBehavior.cs" />
    <Compile Include="ModelValidationResult.cs" />
    <Compile Include="ModelValidator.cs" />
    <Compile Include="ModelValidatorProvider.cs" />
    <Compile Include="ModelValidatorProviders.cs" />
    <Compile Include="RequireHttpsAttribute.cs" />
    <Compile Include="HttpRequestExtensions.cs" />
    <Compile Include="DataAnnotationsModelMetadataProvider.cs" />
    <Compile Include="EmptyModelMetadataProvider.cs" />
    <Compile Include="ModelMetadata.cs" />
    <Compile Include="ModelMetadataProvider.cs" />
    <Compile Include="ModelMetadataProviders.cs" />
    <Compile Include="AreaHelpers.cs" />
    <Compile Include="AreaRegistration.cs" />
    <Compile Include="AreaRegistrationContext.cs" />
    <Compile Include="Error.cs" />
    <Compile Include="IRouteWithArea.cs" />
    <Compile Include="Async\SingleEntryGate.cs" />
    <Compile Include="Html\PartialExtensions.cs" />
    <Compile Include="LinqBinaryModelBinder.cs" />
    <Compile Include="TryGetValueDelegate.cs" />
    <Compile Include="ViewDataInfo.cs" />
    <Compile Include="Html\DefaultDisplayTemplates.cs" />
    <Compile Include="Html\DefaultEditorTemplates.cs" />
    <Compile Include="Html\DisplayExtensions.cs" />
    <Compile Include="Html\EditorExtensions.cs" />
    <Compile Include="Html\LabelExtensions.cs" />
    <Compile Include="Html\TemplateHelpers.cs" />
    <Compile Include="HttpPostAttribute.cs" />
    <Compile Include="ExceptionContext.cs" />
    <Compile Include="ResultExecutedContext.cs" />
    <Compile Include="ResultExecutingContext.cs" />
    <Compile Include="TemplateInfo.cs" />
    <Compile Include="ValidateAntiForgeryTokenAttribute.cs" />
    <Compile Include="JavaScriptResult.cs" />
    <Compile Include="ActionDescriptor.cs" />
    <Compile Include="ActionMethodDispatcher.cs" />
    <Compile Include="ActionMethodSelector.cs" />
    <Compile Include="ActionMethodSelectorAttribute.cs" />
    <Compile Include="ActionNameSelectorAttribute.cs" />
    <Compile Include="AuthorizeAttribute.cs" />
    <Compile Include="Ajax\AjaxOptions.cs" />
    <Compile Include="Ajax\AjaxExtensions.cs" />
    <Compile Include="ActionMethodDispatcherCache.cs" />
    <Compile Include="BindAttribute.cs" />
    <Compile Include="ControllerBase.cs" />
    <Compile Include="ActionNameAttribute.cs" />
    <Compile Include="AcceptVerbsAttribute.cs" />
    <Compile Include="AjaxHelperOfTModel.cs" />
    <Compile Include="HtmlHelperOfTModel.cs" />
    <Compile Include="DictionaryHelpers.cs" />
    <Compile Include="AjaxRequestExtensions.cs" />
    <Compile Include="ModelBinderDictionary.cs" />
    <Compile Include="ValueProviderDictionary.cs" />
    <Compile Include="ViewContext.cs" />
    <Compile Include="ViewMasterPageControlBuilder.cs" />
    <Compile Include="ViewTemplateUserControl.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ViewTemplateUserControlOfTModel.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ViewType.cs" />
    <Compile Include="ViewTypeControlBuilder.cs" />
    <Compile Include="ViewUserControlControlBuilder.cs" />
    <Compile Include="ViewPageControlBuilder.cs" />
    <Compile Include="ViewTypeParserFilter.cs" />
    <Compile Include="DefaultViewLocationCache.cs" />
    <Compile Include="FormCollection.cs" />
    <Compile Include="HttpPostedFileBaseModelBinder.cs" />
    <Compile Include="NullViewLocationCache.cs" />
    <Compile Include="ValidateInputAttribute.cs" />
    <Compile Include="FileContentResult.cs" />
    <Compile Include="FilePathResult.cs" />
    <Compile Include="FileResult.cs" />
    <Compile Include="FileStreamResult.cs" />
    <Compile Include="InputType.cs" />
    <Compile Include="ControllerDescriptorCache.cs" />
    <Compile Include="ReflectedParameterBindingInfo.cs" />
    <Compile Include="ParameterBindingInfo.cs" />
    <Compile Include="ReaderWriterCache.cs" />
    <Compile Include="DescriptorUtil.cs" />
    <Compile Include="ReflectedControllerDescriptor.cs" />
    <Compile Include="ControllerDescriptor.cs" />
    <Compile Include="ActionSelector.cs" />
    <Compile Include="ReflectedActionDescriptor.cs" />
    <Compile Include="Html\MvcForm.cs" />
    <Compile Include="HttpVerbs.cs" />
    <Compile Include="DefaultModelBinder.cs" />
    <Compile Include="ModelBindingContext.cs" />
    <Compile Include="ParameterDescriptor.cs" />
    <Compile Include="RouteValuesHelpers.cs" />
    <Compile Include="SelectListItem.cs" />
    <Compile Include="ReflectedParameterDescriptor.cs" />
    <Compile Include="ValueProviderResult.cs" />
    <Compile Include="CustomModelBinderAttribute.cs" />
    <Compile Include="FormMethod.cs" />
    <Compile Include="Html\FormExtensions.cs" />
    <Compile Include="Html\InputExtensions.cs" />
    <Compile Include="Html\RenderPartialExtensions.cs" />
    <Compile Include="Html\SelectExtensions.cs" />
    <Compile Include="Html\TextAreaExtensions.cs" />
    <Compile Include="Html\ValidationExtensions.cs" />
    <Compile Include="IModelBinder.cs" />
    <Compile Include="Html\LinkExtensions.cs" />
    <Compile Include="ModelBinderAttribute.cs" />
    <Compile Include="ModelBinders.cs" />
    <Compile Include="ModelStateDictionary.cs" />
    <Compile Include="ModelState.cs" />
    <Compile Include="ModelErrorCollection.cs" />
    <Compile Include="ModelError.cs" />
    <Compile Include="Ajax\InsertionMode.cs" />
    <Compile Include="HandleErrorAttribute.cs" />
    <Compile Include="HandleErrorInfo.cs" />
    <Compile Include="HttpUnauthorizedResult.cs" />
    <Compile Include="IActionInvoker.cs" />
    <Compile Include="IView.cs" />
    <Compile Include="IViewLocationCache.cs" />
    <Compile Include="MvcHttpHandler.cs" />
    <Compile Include="PartialViewResult.cs" />
    <Compile Include="SessionStateTempDataProvider.cs" />
    <Compile Include="ITempDataProvider.cs" />
    <Compile Include="OutputCacheAttribute.cs" />
    <Compile Include="FilterInfo.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="ActionFilterAttribute.cs" />
    <Compile Include="ActionResult.cs" />
    <Compile Include="AjaxHelper.cs" />
    <Compile Include="BuildManagerWrapper.cs" />
    <Compile Include="Controller.cs" />
    <Compile Include="ControllerActionInvoker.cs" />
    <Compile Include="ControllerBuilder.cs" />
    <Compile Include="ControllerTypeCache.cs" />
    <Compile Include="ContentResult.cs" />
    <Compile Include="FilterAttribute.cs" />
    <Compile Include="IResultFilter.cs" />
    <Compile Include="IExceptionFilter.cs" />
    <Compile Include="IAuthorizationFilter.cs" />
    <Compile Include="JsonResult.cs" />
    <Compile Include="NameValueCollectionExtensions.cs" />
    <Compile Include="ViewDataDictionaryOfTModel.cs" />
    <Compile Include="EmptyResult.cs" />
    <Compile Include="MultiSelectList.cs" />
    <Compile Include="RedirectResult.cs" />
    <Compile Include="RedirectToRouteResult.cs" />
    <Compile Include="DefaultControllerFactory.cs" />
    <Compile Include="HtmlHelper.cs" />
    <Compile Include="IActionFilter.cs" />
    <Compile Include="IBuildManager.cs" />
    <Compile Include="IController.cs" />
    <Compile Include="IControllerFactory.cs" />
    <Compile Include="IViewDataContainer.cs" />
    <Compile Include="IViewEngine.cs" />
    <Compile Include="MvcHandler.cs" />
    <Compile Include="MvcRouteHandler.cs" />
    <Compile Include="NonActionAttribute.cs" />
    <Compile Include="RouteCollectionExtensions.cs" />
    <Compile Include="SelectList.cs" />
    <Compile Include="TempDataDictionary.cs" />
    <Compile Include="TypeHelpers.cs" />
    <Compile Include="UrlHelper.cs" />
    <Compile Include="ViewDataDictionary.cs" />
    <Compile Include="ViewEngineCollection.cs" />
    <Compile Include="ViewEngineResult.cs" />
    <Compile Include="ViewEngines.cs" />
    <Compile Include="ViewMasterPage.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ViewMasterPageOfTModel.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ViewPage.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ViewPageOfTModel.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ViewResult.cs" />
    <Compile Include="ViewResultBase.cs" />
    <Compile Include="ViewUserControl.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="ViewUserControlOfTModel.cs">
      <SubType>ASPXCodeBehind</SubType>
    </Compile>
    <Compile Include="VirtualPathProviderViewEngine.cs" />
    <Compile Include="WebFormView.cs" />
    <Compile Include="WebFormViewEngine.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\MvcResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <SubType>Designer</SubType>
      <LastGenOutput>MvcResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="JavaScript\jquery.unobtrusive-ajax.js" />
    <None Include="JavaScript\jquery.validate.unobtrusive.js" />
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup />
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="AfterBuild">
    <ItemGroup>
      <ScriptFiles Include="JavaScript\*.js" />
    </ItemGroup>
    <Copy SourceFiles="@(ScriptFiles)" DestinationFolder="$(OutputPath)" SkipUnchangedFiles="true" />
  </Target>
</Project>

================================================
FILE: src/System.Web.Mvc/TagBuilderExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;

namespace System.Web.Mvc
{
    internal static class TagBuilderExtensions
    {
        internal static MvcHtmlString ToMvcHtmlString(this TagBuilder tagBuilder, TagRenderMode renderMode)
        {
            Debug.Assert(tagBuilder != null);
            return new MvcHtmlString(tagBuilder.ToString(renderMode));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/TempDataDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace System.Web.Mvc
{
    public class TempDataDictionary : IDictionary<string, object>
    {
        internal const string TempDataSerializationKey = "__tempData";

        private Dictionary<string, object> _data;
        private HashSet<string> _initialKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        private HashSet<string> _retainedKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        public TempDataDictionary()
        {
            _data = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        }

        public int Count
        {
            get { return _data.Count; }
        }

        public ICollection<string> Keys
        {
            get { return _data.Keys; }
        }

        public ICollection<object> Values
        {
            get { return _data.Values; }
        }

        bool ICollection<KeyValuePair<string, object>>.IsReadOnly
        {
            get { return ((ICollection<KeyValuePair<string, object>>)_data).IsReadOnly; }
        }

        public object this[string key]
        {
            get
            {
                object value;
                if (TryGetValue(key, out value))
                {
                    _initialKeys.Remove(key);
                    return value;
                }
                return null;
            }
            set
            {
                _data[key] = value;
                _initialKeys.Add(key);
            }
        }

        public void Keep()
        {
            _retainedKeys.Clear();
            _retainedKeys.UnionWith(_data.Keys);
        }

        public void Keep(string key)
        {
            _retainedKeys.Add(key);
        }

        public void Load(ControllerContext controllerContext, ITempDataProvider tempDataProvider)
        {
            IDictionary<string, object> providerDictionary = tempDataProvider.LoadTempData(controllerContext);
            _data = (providerDictionary != null)
                ? new Dictionary<string, object>(providerDictionary, StringComparer.OrdinalIgnoreCase)
                : new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            _initialKeys = new HashSet<string>(_data.Keys, StringComparer.OrdinalIgnoreCase);
            _retainedKeys.Clear();
        }

        public object Peek(string key)
        {
            object value;
            _data.TryGetValue(key, out value);
            return value;
        }

        public void Save(ControllerContext controllerContext, ITempDataProvider tempDataProvider)
        {
            // Frequently called so ensure delegate is stateless
            _data.RemoveFromDictionary((KeyValuePair<string, object> entry, TempDataDictionary tempData) =>
                {
                    string key = entry.Key;
                    return !tempData._initialKeys.Contains(key) 
                        && !tempData._retainedKeys.Contains(key);
                }, this);

            tempDataProvider.SaveTempData(controllerContext, _data);
        }

        public void Add(string key, object value)
        {
            _data.Add(key, value);
            _initialKeys.Add(key);
        }

        public void Clear()
        {
            _data.Clear();
            _retainedKeys.Clear();
            _initialKeys.Clear();
        }

        public bool ContainsKey(string key)
        {
            return _data.ContainsKey(key);
        }

        public bool ContainsValue(object value)
        {
            return _data.ContainsValue(value);
        }

        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
        {
            return new TempDataDictionaryEnumerator(this);
        }

        public bool Remove(string key)
        {
            _retainedKeys.Remove(key);
            _initialKeys.Remove(key);
            return _data.Remove(key);
        }

        public bool TryGetValue(string key, out object value)
        {
            _initialKeys.Remove(key);
            return _data.TryGetValue(key, out value);
        }

        void ICollection<KeyValuePair<string, object>>.CopyTo(KeyValuePair<string, object>[] array, int index)
        {
            ((ICollection<KeyValuePair<string, object>>)_data).CopyTo(array, index);
        }

        void ICollection<KeyValuePair<string, object>>.Add(KeyValuePair<string, object> keyValuePair)
        {
            _initialKeys.Add(keyValuePair.Key);
            ((ICollection<KeyValuePair<string, object>>)_data).Add(keyValuePair);
        }

        bool ICollection<KeyValuePair<string, object>>.Contains(KeyValuePair<string, object> keyValuePair)
        {
            return ((ICollection<KeyValuePair<string, object>>)_data).Contains(keyValuePair);
        }

        bool ICollection<KeyValuePair<string, object>>.Remove(KeyValuePair<string, object> keyValuePair)
        {
            _initialKeys.Remove(keyValuePair.Key);
            return ((ICollection<KeyValuePair<string, object>>)_data).Remove(keyValuePair);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return new TempDataDictionaryEnumerator(this);
        }

        private sealed class TempDataDictionaryEnumerator : IEnumerator<KeyValuePair<string, object>>
        {
            private IEnumerator<KeyValuePair<string, object>> _enumerator;
            private TempDataDictionary _tempData;

            public TempDataDictionaryEnumerator(TempDataDictionary tempData)
            {
                _tempData = tempData;
                _enumerator = _tempData._data.GetEnumerator();
            }

            public KeyValuePair<string, object> Current
            {
                get
                {
                    KeyValuePair<string, object> kvp = _enumerator.Current;
                    _tempData._initialKeys.Remove(kvp.Key);
                    return kvp;
                }
            }

            object IEnumerator.Current
            {
                get { return Current; }
            }

            public bool MoveNext()
            {
                return _enumerator.MoveNext();
            }

            public void Reset()
            {
                _enumerator.Reset();
            }

            void IDisposable.Dispose()
            {
                _enumerator.Dispose();
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/TemplateInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public class TemplateInfo
    {
        private string _htmlFieldPrefix;
        private object _formattedModelValue;
        private HashSet<object> _visitedObjects;

        public object FormattedModelValue
        {
            get { return _formattedModelValue ?? String.Empty; }
            set { _formattedModelValue = value; }
        }

        public string HtmlFieldPrefix
        {
            get { return _htmlFieldPrefix ?? String.Empty; }
            set { _htmlFieldPrefix = value; }
        }

        public int TemplateDepth
        {
            get { return VisitedObjects.Count; }
        }

        // DDB #224750 - Keep a collection of visited objects to prevent infinite recursion
        internal HashSet<object> VisitedObjects
        {
            get
            {
                if (_visitedObjects == null)
                {
                    _visitedObjects = new HashSet<object>();
                }
                return _visitedObjects;
            }
            set { _visitedObjects = value; }
        }

        public string GetFullHtmlFieldId(string partialFieldName)
        {
            return HtmlHelper.GenerateIdFromName(GetFullHtmlFieldName(partialFieldName));
        }

        public string GetFullHtmlFieldName(string partialFieldName)
        {
            if (partialFieldName != null && partialFieldName.StartsWith("[", StringComparison.Ordinal))
            {
                // See Codeplex #544 - the partialFieldName might represent an indexer access, in which case combining
                // with a 'dot' would be invalid.
                return HtmlFieldPrefix + partialFieldName;
            }
            else
            {
                // This uses "combine and trim" because either or both of these values might be empty
                return (HtmlFieldPrefix + "." + (partialFieldName ?? String.Empty)).Trim('.');
            }
        }

        public bool Visited(ModelMetadata metadata)
        {
            return VisitedObjects.Contains(metadata.Model ?? metadata.ModelType);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/TryGetValueDelegate.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal delegate bool TryGetValueDelegate(object dictionary, string key, out object value);
}


================================================
FILE: src/System.Web.Mvc/TypeCacheSerializer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Properties;
using System.Xml;

namespace System.Web.Mvc
{
    // Processes files with this format:
    //
    // <typeCache lastModified=... mvcVersionId=...>
    //   <assembly name=...>
    //     <module versionId=...>
    //       <type>...</type>
    //     </module>
    //   </assembly>
    // </typeCache>
    //
    // This is used to store caches of files between AppDomain resets, leading to improved cold boot time
    // and more efficient use of memory.

    internal sealed class TypeCacheSerializer
    {
        private static readonly Guid _mvcVersionId = typeof(TypeCacheSerializer).Module.ModuleVersionId;

        // used for unit testing

        private DateTime CurrentDate
        {
            get { return CurrentDateOverride ?? DateTime.Now; }
        }

        internal DateTime? CurrentDateOverride { get; set; }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This is an instance method for consistency with the SerializeTypes() method.")]
        public List<Type> DeserializeTypes(TextReader input)
        {
            XmlDocument doc = new XmlDocument();
            doc.Load(input);
            XmlElement rootElement = doc.DocumentElement;

            Guid readMvcVersionId = new Guid(rootElement.Attributes["mvcVersionId"].Value);
            if (readMvcVersionId != _mvcVersionId)
            {
                // The cache is outdated because the cache file was produced by a different version
                // of MVC.
                return null;
            }

            List<Type> deserializedTypes = new List<Type>();
            foreach (XmlNode assemblyNode in rootElement.ChildNodes)
            {
                string assemblyName = assemblyNode.Attributes["name"].Value;
                Assembly assembly = Assembly.Load(assemblyName);

                foreach (XmlNode moduleNode in assemblyNode.ChildNodes)
                {
                    Guid moduleVersionId = new Guid(moduleNode.Attributes["versionId"].Value);

                    foreach (XmlNode typeNode in moduleNode.ChildNodes)
                    {
                        string typeName = typeNode.InnerText;
                        Type type = assembly.GetType(typeName);
                        if (type == null || type.Module.ModuleVersionId != moduleVersionId)
                        {
                            // The cache is outdated because we couldn't find a previously recorded
                            // type or the type's containing module was modified.
                            return null;
                        }
                        else
                        {
                            deserializedTypes.Add(type);
                        }
                    }
                }
            }

            return deserializedTypes;
        }

        public void SerializeTypes(IEnumerable<Type> types, TextWriter output)
        {
            var groupedByAssembly = from type in types
                                    group type by type.Module
                                        into groupedByModule
                                        group groupedByModule by groupedByModule.Key.Assembly;

            XmlDocument doc = new XmlDocument();
            doc.AppendChild(doc.CreateComment(MvcResources.TypeCache_DoNotModify));

            XmlElement typeCacheElement = doc.CreateElement("typeCache");
            doc.AppendChild(typeCacheElement);
            typeCacheElement.SetAttribute("lastModified", CurrentDate.ToString(CultureInfo.InvariantCulture));
            typeCacheElement.SetAttribute("mvcVersionId", _mvcVersionId.ToString());

            foreach (var assemblyGroup in groupedByAssembly)
            {
                XmlElement assemblyElement = doc.CreateElement("assembly");
                typeCacheElement.AppendChild(assemblyElement);
                assemblyElement.SetAttribute("name", assemblyGroup.Key.FullName);

                foreach (var moduleGroup in assemblyGroup)
                {
                    XmlElement moduleElement = doc.CreateElement("module");
                    assemblyElement.AppendChild(moduleElement);
                    moduleElement.SetAttribute("versionId", moduleGroup.Key.ModuleVersionId.ToString());

                    foreach (Type type in moduleGroup)
                    {
                        XmlElement typeElement = doc.CreateElement("type");
                        moduleElement.AppendChild(typeElement);
                        typeElement.AppendChild(doc.CreateTextNode(type.FullName));
                    }
                }
            }

            doc.Save(output);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/TypeCacheUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;

namespace System.Web.Mvc
{
    internal static class TypeCacheUtil
    {
        private static IEnumerable<Type> FilterTypesInAssemblies(IBuildManager buildManager, Predicate<Type> predicate)
        {
            // Go through all assemblies referenced by the application and search for types matching a predicate
            IEnumerable<Type> typesSoFar = Type.EmptyTypes;

            ICollection assemblies = buildManager.GetReferencedAssemblies();
            foreach (Assembly assembly in assemblies)
            {
                Type[] typesInAsm;
                try
                {
                    typesInAsm = assembly.GetTypes();
                }
                catch (ReflectionTypeLoadException ex)
                {
                    typesInAsm = ex.Types;
                }
                typesSoFar = typesSoFar.Concat(typesInAsm);
            }
            return typesSoFar.Where(type => TypeIsPublicClass(type) && predicate(type));
        }

        public static List<Type> GetFilteredTypesFromAssemblies(string cacheName, Predicate<Type> predicate, IBuildManager buildManager)
        {
            TypeCacheSerializer serializer = new TypeCacheSerializer();

            // first, try reading from the cache on disk
            List<Type> matchingTypes = ReadTypesFromCache(cacheName, predicate, buildManager, serializer);
            if (matchingTypes != null)
            {
                return matchingTypes;
            }

            // if reading from the cache failed, enumerate over every assembly looking for a matching type
            matchingTypes = FilterTypesInAssemblies(buildManager, predicate).ToList();

            // finally, save the cache back to disk
            SaveTypesToCache(cacheName, matchingTypes, buildManager, serializer);

            return matchingTypes;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Cache failures are not fatal, and the code should continue executing normally.")]
        internal static List<Type> ReadTypesFromCache(string cacheName, Predicate<Type> predicate, IBuildManager buildManager, TypeCacheSerializer serializer)
        {
            try
            {
                Stream stream = buildManager.ReadCachedFile(cacheName);
                if (stream != null)
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        List<Type> deserializedTypes = serializer.DeserializeTypes(reader);
                        if (deserializedTypes != null && deserializedTypes.All(type => TypeIsPublicClass(type) && predicate(type)))
                        {
                            // If all read types still match the predicate, success!
                            return deserializedTypes;
                        }
                    }
                }
            }
            catch
            {
            }

            return null;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Cache failures are not fatal, and the code should continue executing normally.")]
        internal static void SaveTypesToCache(string cacheName, IList<Type> matchingTypes, IBuildManager buildManager, TypeCacheSerializer serializer)
        {
            try
            {
                Stream stream = buildManager.CreateCachedFile(cacheName);
                if (stream != null)
                {
                    using (StreamWriter writer = new StreamWriter(stream))
                    {
                        serializer.SerializeTypes(matchingTypes, writer);
                    }
                }
            }
            catch
            {
            }
        }

        private static bool TypeIsPublicClass(Type type)
        {
            return (type != null && type.IsPublic && type.IsClass && !type.IsAbstract);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/TypeDescriptorHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.ComponentModel.DataAnnotations;

namespace System.Web.Mvc
{
    internal static class TypeDescriptorHelper
    {
        public static ICustomTypeDescriptor Get(Type type)
        {
            return new AssociatedMetadataTypeTypeDescriptionProvider(type).GetTypeDescriptor(type);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/TypeHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Reflection;
using System.Threading;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    internal static class TypeHelpers
    {
        private static readonly Dictionary<Type, TryGetValueDelegate> _tryGetValueDelegateCache = new Dictionary<Type, TryGetValueDelegate>();
        private static readonly ReaderWriterLockSlim _tryGetValueDelegateCacheLock = new ReaderWriterLockSlim();

        private static readonly MethodInfo _strongTryGetValueImplInfo = typeof(TypeHelpers).GetMethod("StrongTryGetValueImpl", BindingFlags.NonPublic | BindingFlags.Static);

        public static readonly Assembly MsCorLibAssembly = typeof(string).Assembly;
        public static readonly Assembly MvcAssembly = typeof(Controller).Assembly;
        public static readonly Assembly SystemWebAssembly = typeof(HttpContext).Assembly;

        // method is used primarily for lighting up new .NET Framework features even if MVC targets the previous version
        // thisParameter is the 'this' parameter if target method is instance method, should be null for static method
        public static TDelegate CreateDelegate<TDelegate>(Assembly assembly, string typeName, string methodName, object thisParameter) where TDelegate : class
        {
            // ensure target type exists
            Type targetType = assembly.GetType(typeName, false /* throwOnError */);
            if (targetType == null)
            {
                return null;
            }

            return CreateDelegate<TDelegate>(targetType, methodName, thisParameter);
        }

        public static TDelegate CreateDelegate<TDelegate>(Type targetType, string methodName, object thisParameter) where TDelegate : class
        {
            // ensure target method exists
            ParameterInfo[] delegateParameters = typeof(TDelegate).GetMethod("Invoke").GetParameters();
            Type[] argumentTypes = Array.ConvertAll(delegateParameters, pInfo => pInfo.ParameterType);
            MethodInfo targetMethod = targetType.GetMethod(methodName, argumentTypes);
            if (targetMethod == null)
            {
                return null;
            }

            TDelegate d = Delegate.CreateDelegate(typeof(TDelegate), thisParameter, targetMethod, false /* throwOnBindFailure */) as TDelegate;
            return d;
        }

        public static TryGetValueDelegate CreateTryGetValueDelegate(Type targetType)
        {
            TryGetValueDelegate result;

            _tryGetValueDelegateCacheLock.EnterReadLock();
            try
            {
                if (_tryGetValueDelegateCache.TryGetValue(targetType, out result))
                {
                    return result;
                }
            }
            finally
            {
                _tryGetValueDelegateCacheLock.ExitReadLock();
            }

            Type dictionaryType = ExtractGenericInterface(targetType, typeof(IDictionary<,>));

            // just wrap a call to the underlying IDictionary<TKey, TValue>.TryGetValue() where string can be cast to TKey
            if (dictionaryType != null)
            {
                Type[] typeArguments = dictionaryType.GetGenericArguments();
                Type keyType = typeArguments[0];
                Type returnType = typeArguments[1];

                if (keyType.IsAssignableFrom(typeof(string)))
                {
                    MethodInfo strongImplInfo = _strongTryGetValueImplInfo.MakeGenericMethod(keyType, returnType);
                    result = (TryGetValueDelegate)Delegate.CreateDelegate(typeof(TryGetValueDelegate), strongImplInfo);
                }
            }

            // wrap a call to the underlying IDictionary.Item()
            if (result == null && typeof(IDictionary).IsAssignableFrom(targetType))
            {
                result = TryGetValueFromNonGenericDictionary;
            }

            _tryGetValueDelegateCacheLock.EnterWriteLock();
            try
            {
                _tryGetValueDelegateCache[targetType] = result;
            }
            finally
            {
                _tryGetValueDelegateCacheLock.ExitWriteLock();
            }

            return result;
        }

        public static Type ExtractGenericInterface(Type queryType, Type interfaceType)
        {
            if (MatchesGenericType(queryType, interfaceType))
            {
                return queryType;
            }
            Type[] queryTypeInterfaces = queryType.GetInterfaces();
            return MatchGenericTypeFirstOrDefault(queryTypeInterfaces, interfaceType);
        }

        public static object GetDefaultValue(Type type)
        {
            return (TypeAllowsNullValue(type)) ? null : Activator.CreateInstance(type);
        }

        public static bool IsCompatibleObject<T>(object value)
        {
            return (value is T || (value == null && TypeAllowsNullValue(typeof(T))));
        }

        public static bool IsNullableValueType(Type type)
        {
            return Nullable.GetUnderlyingType(type) != null;
        }

        /// <summary>
        /// Provide a new <see cref="MissingMethodException"/> if original Message does not contain given full Type name.
        /// </summary>
        /// <param name="originalException"><see cref="MissingMethodException"/> to check.</param>
        /// <param name="fullTypeName">Full Type name which Message should contain.</param>
        /// <returns>New <see cref="MissingMethodException"/> if an update is required; null otherwise.</returns>
        public static MissingMethodException EnsureDebuggableException(
            MissingMethodException originalException,
            string fullTypeName)
        {
            MissingMethodException replacementException = null;
            if (!originalException.Message.Contains(fullTypeName))
            {
                string message = String.Format(
                    CultureInfo.CurrentCulture,
                    MvcResources.TypeHelpers_CannotCreateInstance,
                    originalException.Message,
                    fullTypeName);
                replacementException = new MissingMethodException(message, originalException);
            }

            return replacementException;
        }

        private static bool MatchesGenericType(Type type, Type matchType)
        {
            return type.IsGenericType && type.GetGenericTypeDefinition() == matchType;
        }

        private static Type MatchGenericTypeFirstOrDefault(Type[] types, Type matchType)
        {
            for (int i = 0; i < types.Length; i++)
            {
                Type type = types[i];
                if (MatchesGenericType(type, matchType))
                {
                    return type;
                }
            }
            return null;
        }

        private static bool StrongTryGetValueImpl<TKey, TValue>(object dictionary, string key, out object value)
        {
            IDictionary<TKey, TValue> strongDict = (IDictionary<TKey, TValue>)dictionary;

            TValue strongValue;
            bool retVal = strongDict.TryGetValue((TKey)(object)key, out strongValue);
            value = strongValue;
            return retVal;
        }

        private static bool TryGetValueFromNonGenericDictionary(object dictionary, string key, out object value)
        {
            IDictionary weakDict = (IDictionary)dictionary;

            bool containsKey = weakDict.Contains(key);
            value = (containsKey) ? weakDict[key] : null;
            return containsKey;
        }

        public static bool TypeAllowsNullValue(Type type)
        {
            return (!type.IsValueType || IsNullableValueType(type));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/UnvalidatedRequestValuesAccessor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal delegate IUnvalidatedRequestValues UnvalidatedRequestValuesAccessor(ControllerContext controllerContext);
}


================================================
FILE: src/System.Web.Mvc/UnvalidatedRequestValuesWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;

namespace System.Web.Mvc
{
    // Concrete implementation for the IUnvalidatedRequestValues helper interface

    internal sealed class UnvalidatedRequestValuesWrapper : IUnvalidatedRequestValues
    {
        private readonly UnvalidatedRequestValuesBase _unvalidatedValues;

        public UnvalidatedRequestValuesWrapper(UnvalidatedRequestValuesBase unvalidatedValues)
        {
            _unvalidatedValues = unvalidatedValues;
        }

        public NameValueCollection Form
        {
            get { return _unvalidatedValues.Form; }
        }

        public NameValueCollection QueryString
        {
            get { return _unvalidatedValues.QueryString; }
        }

        public string this[string key]
        {
            get { return _unvalidatedValues[key]; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/UrlHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Properties;
using System.Web.Routing;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    public class UrlHelper
    {
        /// <summary>
        /// Key used to signify that a route URL generation request should include HTTP routes (e.g. Web API).
        /// If this key is not specified then no HTTP routes will match.
        /// </summary>
        private const string HttpRouteKey = "httproute";

        /// <summary>
        /// Initializes a new instance of the <see cref="UrlHelper"/> class.
        /// </summary>
        /// <remarks>The default constructor is intended for use by unit testing only.</remarks>
        public UrlHelper()
        {
        }

        public UrlHelper(RequestContext requestContext)
            : this(requestContext, RouteTable.Routes)
        {
        }

        public UrlHelper(RequestContext requestContext, RouteCollection routeCollection)
        {
            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }
            if (routeCollection == null)
            {
                throw new ArgumentNullException("routeCollection");
            }
            RequestContext = requestContext;
            RouteCollection = routeCollection;
        }

        public RequestContext RequestContext { get; private set; }

        public RouteCollection RouteCollection { get; private set; }

        public virtual string Action()
        {
            return RequestContext.HttpContext.Request.RawUrl;
        }

        public virtual string Action(string actionName)
        {
            return GenerateUrl(null /* routeName */, actionName, null, (RouteValueDictionary)null /* routeValues */);
        }

        public virtual string Action(string actionName, object routeValues)
        {
            return GenerateUrl(null /* routeName */, actionName, null /* controllerName */, TypeHelper.ObjectToDictionary(routeValues));
        }

        public virtual string Action(string actionName, RouteValueDictionary routeValues)
        {
            return GenerateUrl(null /* routeName */, actionName, null /* controllerName */, routeValues);
        }

        public virtual string Action(string actionName, string controllerName)
        {
            return GenerateUrl(null /* routeName */, actionName, controllerName, (RouteValueDictionary)null /* routeValues */);
        }

        public virtual string Action(string actionName, string controllerName, object routeValues)
        {
            return GenerateUrl(null /* routeName */, actionName, controllerName, TypeHelper.ObjectToDictionary(routeValues));
        }

        public virtual string Action(string actionName, string controllerName, RouteValueDictionary routeValues)
        {
            return GenerateUrl(null /* routeName */, actionName, controllerName, routeValues);
        }

        public virtual string Action(string actionName, string controllerName, RouteValueDictionary routeValues, string protocol)
        {
            return GenerateUrl(null /* routeName */, actionName, controllerName, protocol, null /* hostName */, null /* fragment */, routeValues, RouteCollection, RequestContext, true /* includeImplicitMvcValues */);
        }

        public virtual string Action(string actionName, string controllerName, object routeValues, string protocol)
        {
            return GenerateUrl(null /* routeName */, actionName, controllerName, protocol, null /* hostName */, null /* fragment */, TypeHelper.ObjectToDictionary(routeValues), RouteCollection, RequestContext, true /* includeImplicitMvcValues */);
        }

        public virtual string Action(string actionName, string controllerName, RouteValueDictionary routeValues, string protocol, string hostName)
        {
            return GenerateUrl(null /* routeName */, actionName, controllerName, protocol, hostName, null /* fragment */, routeValues, RouteCollection, RequestContext, true /* includeImplicitMvcValues */);
        }

        public virtual string Content(string contentPath)
        {
            return GenerateContentUrl(contentPath, RequestContext.HttpContext);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public static string GenerateContentUrl(string contentPath, HttpContextBase httpContext)
        {
            if (String.IsNullOrEmpty(contentPath))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "contentPath");
            }

            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }

            if (contentPath[0] == '~')
            {
                return UrlUtil.GenerateClientUrl(httpContext, contentPath);
            }
            else
            {
                return contentPath;
            }
        }

        //REVIEW: Should we have an overload that takes Uri?
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", Justification = "Needs to take same parameters as HttpUtility.UrlEncode()")]
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "For consistency, all helpers are instance methods.")]
        public virtual string Encode(string url)
        {
            return HttpUtility.UrlEncode(url);
        }

        private string GenerateUrl(string routeName, string actionName, string controllerName, RouteValueDictionary routeValues)
        {
            return GenerateUrl(routeName, actionName, controllerName, routeValues, RouteCollection, RequestContext, true /* includeImplicitMvcValues */);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public static string GenerateUrl(string routeName, string actionName, string controllerName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, RouteCollection routeCollection, RequestContext requestContext, bool includeImplicitMvcValues)
        {
            string url = GenerateUrl(routeName, actionName, controllerName, routeValues, routeCollection, requestContext, includeImplicitMvcValues);

            if (url != null)
            {
                if (!String.IsNullOrEmpty(fragment))
                {
                    url = url + "#" + fragment;
                }

                if (!String.IsNullOrEmpty(protocol) || !String.IsNullOrEmpty(hostName))
                {
                    Uri requestUrl = requestContext.HttpContext.Request.Url;
                    protocol = (!String.IsNullOrEmpty(protocol)) ? protocol : Uri.UriSchemeHttp;
                    hostName = (!String.IsNullOrEmpty(hostName)) ? hostName : requestUrl.Host;

                    string port = String.Empty;
                    string requestProtocol = requestUrl.Scheme;

                    if (String.Equals(protocol, requestProtocol, StringComparison.OrdinalIgnoreCase))
                    {
                        port = requestUrl.IsDefaultPort ? String.Empty : (":" + Convert.ToString(requestUrl.Port, CultureInfo.InvariantCulture));
                    }

                    url = protocol + Uri.SchemeDelimiter + hostName + port + url;
                }
            }

            return url;
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public static string GenerateUrl(string routeName, string actionName, string controllerName, RouteValueDictionary routeValues, RouteCollection routeCollection, RequestContext requestContext, bool includeImplicitMvcValues)
        {
            if (routeCollection == null)
            {
                throw new ArgumentNullException("routeCollection");
            }

            if (requestContext == null)
            {
                throw new ArgumentNullException("requestContext");
            }

            RouteValueDictionary mergedRouteValues = RouteValuesHelpers.MergeRouteValues(actionName, controllerName, requestContext.RouteData.Values, routeValues, includeImplicitMvcValues);

            VirtualPathData vpd = routeCollection.GetVirtualPathForArea(requestContext, routeName, mergedRouteValues);
            if (vpd == null)
            {
                return null;
            }

            string modifiedUrl = UrlUtil.GenerateClientUrl(requestContext.HttpContext, vpd.VirtualPath);
            return modifiedUrl;
        }

        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "0#", Justification = "Response.Redirect() takes its URI as a string parameter.")]
        public virtual bool IsLocalUrl(string url)
        {
            // TODO this should call the System.Web.dll API once it gets added to the framework and MVC takes a dependency on it.
            return RequestExtensions.IsUrlLocalToHost(RequestContext.HttpContext.Request, url);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string RouteUrl(object routeValues)
        {
            return RouteUrl(null /* routeName */, routeValues);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string RouteUrl(RouteValueDictionary routeValues)
        {
            return RouteUrl(null /* routeName */, routeValues);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string RouteUrl(string routeName)
        {
            return RouteUrl(routeName, (object)null /* routeValues */);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string RouteUrl(string routeName, object routeValues)
        {
            return RouteUrl(routeName, routeValues, null /* protocol */);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string RouteUrl(string routeName, RouteValueDictionary routeValues)
        {
            return RouteUrl(routeName, routeValues, null /* protocol */, null /* hostName */);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string RouteUrl(string routeName, object routeValues, string protocol)
        {
            return GenerateUrl(routeName, null /* actionName */, null /* controllerName */, protocol, null /* hostName */, null /* fragment */, TypeHelper.ObjectToDictionary(routeValues), RouteCollection, RequestContext, false /* includeImplicitMvcValues */);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string RouteUrl(string routeName, RouteValueDictionary routeValues, string protocol, string hostName)
        {
            return GenerateUrl(routeName, null /* actionName */, null /* controllerName */, protocol, hostName, null /* fragment */, routeValues, RouteCollection, RequestContext, false /* includeImplicitMvcValues */);
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string HttpRouteUrl(string routeName, object routeValues)
        {
            return HttpRouteUrl(routeName, TypeHelper.ObjectToDictionary(routeValues));
        }

        [SuppressMessage("Microsoft.Design", "CA1055:UriReturnValuesShouldNotBeStrings", Justification = "As the return value will used only for rendering, string return value is more appropriate.")]
        public virtual string HttpRouteUrl(string routeName, RouteValueDictionary routeValues)
        {
            if (routeValues == null)
            {
                // If no route values were passed in at all we have to create a new dictionary
                // so that we can add the extra "httproute" key.
                routeValues = new RouteValueDictionary();
                routeValues.Add(HttpRouteKey, true);
            }
            else
            {
                // Copy the dictionary to add the extra "httproute" key used by all Web API routes to
                // disambiguate them from other MVC routes.
                routeValues = new RouteValueDictionary(routeValues);
                if (!routeValues.ContainsKey(HttpRouteKey))
                {
                    routeValues.Add(HttpRouteKey, true);
                }
            }

            return GenerateUrl(routeName,
                actionName: null,
                controllerName: null,
                protocol: null,
                hostName: null,
                fragment: null,
                routeValues: routeValues,
                routeCollection: RouteCollection,
                requestContext: RequestContext,
                includeImplicitMvcValues: false);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/UrlParameter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public sealed class UrlParameter
    {
        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes", Justification = "This type is immutable.")]
        public static readonly UrlParameter Optional = new UrlParameter();

        // singleton constructor
        private UrlParameter()
        {
        }

        public override string ToString()
        {
            return String.Empty;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValidatableObjectAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ValidatableObjectAdapter : ModelValidator
    {
        public ValidatableObjectAdapter(ModelMetadata metadata, ControllerContext context)
            : base(metadata, context)
        {
        }

        public override IEnumerable<ModelValidationResult> Validate(object container)
        {
            // NOTE: Container is never used here, because IValidatableObject doesn't give you
            // any way to get access to your container.

            object model = Metadata.Model;
            if (model == null)
            {
                return Enumerable.Empty<ModelValidationResult>();
            }

            IValidatableObject validatable = model as IValidatableObject;
            if (validatable == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.ValidatableObjectAdapter_IncompatibleType,
                        typeof(IValidatableObject).FullName,
                        model.GetType().FullName));
            }

            ValidationContext validationContext = new ValidationContext(validatable, null, null);
            return ConvertResults(validatable.Validate(validationContext));
        }

        private static IEnumerable<ModelValidationResult> ConvertResults(IEnumerable<ValidationResult> results)
        {
            foreach (ValidationResult result in results)
            {
                if (result != ValidationResult.Success)
                {
                    if (result.MemberNames == null || !result.MemberNames.Any())
                    {
                        yield return new ModelValidationResult { Message = result.ErrorMessage };
                    }
                    else
                    {
                        foreach (string memberName in result.MemberNames)
                        {
                            yield return new ModelValidationResult { Message = result.ErrorMessage, MemberName = memberName };
                        }
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValidateAntiForgeryTokenAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Web.Helpers;

namespace System.Web.Mvc
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public sealed class ValidateAntiForgeryTokenAttribute : FilterAttribute, IAuthorizationFilter
    {
        private string _salt;

        public ValidateAntiForgeryTokenAttribute()
            : this(AntiForgery.Validate)
        {
        }

        internal ValidateAntiForgeryTokenAttribute(Action validateAction)
        {
            Debug.Assert(validateAction != null);
            ValidateAction = validateAction;
        }

        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AdditionalDataProvider", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AntiForgeryConfig", Justification = "API name.")]
        [Obsolete("The 'Salt' property is deprecated. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.", error: true)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public string Salt
        {
            get { return _salt; }
            set
            {
                if (!String.IsNullOrEmpty(value))
                {
                    throw new NotSupportedException("The 'Salt' property is deprecated. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.");
                }
                _salt = value;
            }
        }

        internal Action ValidateAction { get; private set; }

        public void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            ValidateAction();
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValidateInputAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    [SuppressMessage("Microsoft.Performance", "CA1813:AvoidUnsealedAttributes", Justification = "No compelling performance reason to seal this type.")]
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
    public class ValidateInputAttribute : FilterAttribute, IAuthorizationFilter
    {
        public ValidateInputAttribute(bool enableValidation)
        {
            EnableValidation = enableValidation;
        }

        public bool EnableValidation { get; private set; }

        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            filterContext.Controller.ValidateRequest = EnableValidation;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValueProviderCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace System.Web.Mvc
{
    public class ValueProviderCollection : Collection<IValueProvider>, IValueProvider, IUnvalidatedValueProvider, IEnumerableValueProvider
    {
        public ValueProviderCollection()
        {
        }

        public ValueProviderCollection(IList<IValueProvider> list)
            : base(list)
        {
        }

        public virtual bool ContainsPrefix(string prefix)
        {
            // Performance sensitive, so avoid Linq and delegates
            // Saving Count is faster for looping over Collection<T>
            int itemCount = Count;
            for (int i = 0; i < itemCount; i++)
            {
                if (this[i].ContainsPrefix(prefix))
                {
                    return true;
                }
            }
            return false;
        }

        public virtual ValueProviderResult GetValue(string key)
        {
            return GetValue(key, skipValidation: false);
        }

        public virtual ValueProviderResult GetValue(string key, bool skipValidation)
        {
            // Performance sensitive.
            // Caching the count is faster for Collection<T>
            int providerCount = Count;
            for (int i = 0; i < providerCount; i++)
            {
                ValueProviderResult result = GetValueFromProvider(this[i], key, skipValidation);
                if (result != null)
                {
                    return result;
                }
            }
            return null;
        }

        public virtual IDictionary<string, string> GetKeysFromPrefix(string prefix)
        {
            return (from provider in this
                    let result = GetKeysFromPrefixFromProvider(provider, prefix)
                    where result != null && result.Any()
                    select result).FirstOrDefault() ?? new Dictionary<string, string>();
        }

        internal static ValueProviderResult GetValueFromProvider(IValueProvider provider, string key, bool skipValidation)
        {
            // Since IUnvalidatedValueProvider is a superset of IValueProvider, it's always OK to use the
            // IUnvalidatedValueProvider-supplied members if they're present. Otherwise just call the
            // normal IValueProvider members.

            IUnvalidatedValueProvider unvalidatedProvider = provider as IUnvalidatedValueProvider;
            return (unvalidatedProvider != null) ? unvalidatedProvider.GetValue(key, skipValidation) : provider.GetValue(key);
        }

        internal static IDictionary<string, string> GetKeysFromPrefixFromProvider(IValueProvider provider, string prefix)
        {
            IEnumerableValueProvider enumeratedProvider = provider as IEnumerableValueProvider;
            return (enumeratedProvider != null) ? enumeratedProvider.GetKeysFromPrefix(prefix) : null;
        }

        protected override void InsertItem(int index, IValueProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            base.InsertItem(index, item);
        }

        protected override void SetItem(int index, IValueProvider item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            base.SetItem(index, item);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValueProviderDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Routing;

namespace System.Web.Mvc
{
    [Obsolete("The recommended alternative is to use one of the specific ValueProvider types, such as FormValueProvider.")]
    public class ValueProviderDictionary : IDictionary<string, ValueProviderResult>, IValueProvider
    {
        private readonly Dictionary<string, ValueProviderResult> _dictionary = new Dictionary<string, ValueProviderResult>(StringComparer.OrdinalIgnoreCase);

        public ValueProviderDictionary(ControllerContext controllerContext)
        {
            ControllerContext = controllerContext;
            if (controllerContext != null)
            {
                PopulateDictionary();
            }
        }

        public ControllerContext ControllerContext { get; private set; }

        public int Count
        {
            get { return ((ICollection<KeyValuePair<string, ValueProviderResult>>)Dictionary).Count; }
        }

        internal Dictionary<string, ValueProviderResult> Dictionary
        {
            get { return _dictionary; }
        }

        public bool IsReadOnly
        {
            get { return ((ICollection<KeyValuePair<string, ValueProviderResult>>)Dictionary).IsReadOnly; }
        }

        public ICollection<string> Keys
        {
            get { return Dictionary.Keys; }
        }

        public ValueProviderResult this[string key]
        {
            get
            {
                ValueProviderResult result;
                Dictionary.TryGetValue(key, out result);
                return result;
            }
            set { Dictionary[key] = value; }
        }

        public ICollection<ValueProviderResult> Values
        {
            get { return Dictionary.Values; }
        }

        public void Add(KeyValuePair<string, ValueProviderResult> item)
        {
            ((ICollection<KeyValuePair<string, ValueProviderResult>>)Dictionary).Add(item);
        }

        public void Add(string key, object value)
        {
            string attemptedValue = Convert.ToString(value, CultureInfo.InvariantCulture);
            ValueProviderResult valueProviderResult = new ValueProviderResult(value, attemptedValue, CultureInfo.InvariantCulture);
            Add(key, valueProviderResult);
        }

        public void Add(string key, ValueProviderResult value)
        {
            Dictionary.Add(key, value);
        }

        private void AddToDictionaryIfNotPresent(string key, ValueProviderResult result)
        {
            if (!String.IsNullOrEmpty(key))
            {
                if (!Dictionary.ContainsKey(key))
                {
                    Dictionary.Add(key, result);
                }
            }
        }

        public void Clear()
        {
            ((ICollection<KeyValuePair<string, ValueProviderResult>>)Dictionary).Clear();
        }

        public bool Contains(KeyValuePair<string, ValueProviderResult> item)
        {
            return ((ICollection<KeyValuePair<string, ValueProviderResult>>)Dictionary).Contains(item);
        }

        public bool ContainsKey(string key)
        {
            return Dictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<string, ValueProviderResult>[] array, int arrayIndex)
        {
            ((ICollection<KeyValuePair<string, ValueProviderResult>>)Dictionary).CopyTo(array, arrayIndex);
        }

        public IEnumerator<KeyValuePair<string, ValueProviderResult>> GetEnumerator()
        {
            return ((IEnumerable<KeyValuePair<string, ValueProviderResult>>)Dictionary).GetEnumerator();
        }

        private void PopulateDictionary()
        {
            CultureInfo currentCulture = CultureInfo.CurrentCulture;
            CultureInfo invariantCulture = CultureInfo.InvariantCulture;

            // We use this order of precedence to populate the dictionary:
            // 1. Request form submission (should be culture-aware)
            // 2. Values from the RouteData (could be from the typed-in URL or from the route's default values)
            // 3. URI query string

            NameValueCollection form = ControllerContext.HttpContext.Request.Form;
            if (form != null)
            {
                string[] keys = form.AllKeys;
                foreach (string key in keys)
                {
                    string[] rawValue = form.GetValues(key);
                    string attemptedValue = form[key];
                    ValueProviderResult result = new ValueProviderResult(rawValue, attemptedValue, currentCulture);
                    AddToDictionaryIfNotPresent(key, result);
                }
            }

            RouteValueDictionary routeValues = ControllerContext.RouteData.Values;
            if (routeValues != null)
            {
                foreach (var kvp in routeValues)
                {
                    string key = kvp.Key;
                    object rawValue = kvp.Value;
                    string attemptedValue = Convert.ToString(rawValue, invariantCulture);
                    ValueProviderResult result = new ValueProviderResult(rawValue, attemptedValue, invariantCulture);
                    AddToDictionaryIfNotPresent(key, result);
                }
            }

            NameValueCollection queryString = ControllerContext.HttpContext.Request.QueryString;
            if (queryString != null)
            {
                string[] keys = queryString.AllKeys;
                foreach (string key in keys)
                {
                    string[] rawValue = queryString.GetValues(key);
                    string attemptedValue = queryString[key];
                    ValueProviderResult result = new ValueProviderResult(rawValue, attemptedValue, invariantCulture);
                    AddToDictionaryIfNotPresent(key, result);
                }
            }
        }

        public bool Remove(KeyValuePair<string, ValueProviderResult> item)
        {
            return ((ICollection<KeyValuePair<string, ValueProviderResult>>)Dictionary).Remove(item);
        }

        public bool Remove(string key)
        {
            return Dictionary.Remove(key);
        }

        public bool TryGetValue(string key, out ValueProviderResult value)
        {
            return Dictionary.TryGetValue(key, out value);
        }

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)Dictionary).GetEnumerator();
        }

        #endregion

        #region IValueProvider Members

        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The declaring type is obsolete, so there is little benefit to exposing this as a virtual method.")]
        bool IValueProvider.ContainsPrefix(string prefix)
        {
            if (prefix == null)
            {
                throw new ArgumentNullException("prefix");
            }

            return ValueProviderUtil.CollectionContainsPrefix(Keys, prefix);
        }

        [SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The declaring type is obsolete, so there is little benefit to exposing this as a virtual method.")]
        ValueProviderResult IValueProvider.GetValue(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            ValueProviderResult valueProviderResult;
            TryGetValue(key, out valueProviderResult);
            return valueProviderResult;
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/ValueProviderFactories.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class ValueProviderFactories
    {
        private static readonly ValueProviderFactoryCollection _factories = new ValueProviderFactoryCollection()
        {
            new ChildActionValueProviderFactory(),
            new FormValueProviderFactory(),
            new JsonValueProviderFactory(),
            new RouteDataValueProviderFactory(),
            new QueryStringValueProviderFactory(),
            new HttpFileCollectionValueProviderFactory(),
            new JQueryFormValueProviderFactory()
        };

        public static ValueProviderFactoryCollection Factories
        {
            get { return _factories; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public abstract class ValueProviderFactory
    {
        public abstract IValueProvider GetValueProvider(ControllerContext controllerContext);
    }
}


================================================
FILE: src/System.Web.Mvc/ValueProviderFactoryCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;

namespace System.Web.Mvc
{
    public class ValueProviderFactoryCollection : Collection<ValueProviderFactory>
    {
        private ValueProviderFactory[] _combinedItems;
        private IDependencyResolver _dependencyResolver;

        public ValueProviderFactoryCollection()
        {
        }

        public ValueProviderFactoryCollection(IList<ValueProviderFactory> list)
            : base(list)
        {
        }

        internal ValueProviderFactoryCollection(IList<ValueProviderFactory> list, IDependencyResolver dependencyResolver)
            : base(list)
        {
            _dependencyResolver = dependencyResolver;
        }

        internal ValueProviderFactory[] CombinedItems
        {
            get
            {
                ValueProviderFactory[] combinedItems = _combinedItems;
                if (combinedItems == null)
                {
                    combinedItems = MultiServiceResolver.GetCombined<ValueProviderFactory>(Items, _dependencyResolver);
                    _combinedItems = combinedItems;
                }
                return combinedItems;
            }
        }

        public IValueProvider GetValueProvider(ControllerContext controllerContext)
        {
            ValueProviderFactory[] current = CombinedItems;
            List<IValueProvider> providers = new List<IValueProvider>(current.Length);
            for (int i = 0; i < current.Length; i++)
            {
                ValueProviderFactory factory = current[i];
                IValueProvider provider = factory.GetValueProvider(controllerContext);
                if (provider != null)
                {
                    providers.Add(provider);
                }
            }
            return new ValueProviderCollection(providers);
        }

        protected override void ClearItems()
        {
            _combinedItems = null;
            base.ClearItems();
        }

        protected override void InsertItem(int index, ValueProviderFactory item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.InsertItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            _combinedItems = null;
            base.RemoveItem(index);
        }

        protected override void SetItem(int index, ValueProviderFactory item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.SetItem(index, item);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValueProviderResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    [Serializable]
    public class ValueProviderResult
    {
        private static readonly CultureInfo _staticCulture = CultureInfo.InvariantCulture;
        private CultureInfo _instanceCulture;

        // default constructor so that subclassed types can set the properties themselves
        protected ValueProviderResult()
        {
        }

        public ValueProviderResult(object rawValue, string attemptedValue, CultureInfo culture)
        {
            RawValue = rawValue;
            AttemptedValue = attemptedValue;
            Culture = culture;
        }

        public string AttemptedValue { get; protected set; }

        public CultureInfo Culture
        {
            get
            {
                if (_instanceCulture == null)
                {
                    _instanceCulture = _staticCulture;
                }
                return _instanceCulture;
            }
            protected set { _instanceCulture = value; }
        }

        public object RawValue { get; protected set; }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Conversion failure is not fatal")]
        private static object ConvertSimpleType(CultureInfo culture, object value, Type destinationType)
        {
            if (value == null || destinationType.IsInstanceOfType(value))
            {
                return value;
            }

            // if this is a user-input value but the user didn't type anything, return no value
            string valueAsString = value as string;
            if (valueAsString != null && String.IsNullOrWhiteSpace(valueAsString))
            {
                return null;
            }

            // In case of a Nullable object, we extract the underlying type and try to convert it.
            Type underlyingType = Nullable.GetUnderlyingType(destinationType);

            if (underlyingType != null)
            {
                destinationType = underlyingType;
            }

            // String doesn't provide convertibles to interesting types, and thus it will typically throw rather than succeed.
            if (valueAsString == null)
            {
                // If the source type implements IConvertible, try that first
                IConvertible convertible = value as IConvertible;
                if (convertible != null)
                {
                    try
                    {
                        return convertible.ToType(destinationType, culture);
                    }
                    catch
                    {
                    }
                }
            }

            // Last resort, look for a type converter
            TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
            bool canConvertFrom = converter.CanConvertFrom(value.GetType());
            if (!canConvertFrom)
            {
                converter = TypeDescriptor.GetConverter(value.GetType());
            }
            if (!(canConvertFrom || converter.CanConvertTo(destinationType)))
            {
                // EnumConverter cannot convert integer, so we verify manually
                if (destinationType.IsEnum && value is int)
                {
                    return Enum.ToObject(destinationType, (int)value);
                }

                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_NoConverterExists,
                                               value.GetType().FullName, destinationType.FullName);
                throw new InvalidOperationException(message);
            }

            try
            {
                object convertedValue = (canConvertFrom)
                                            ? converter.ConvertFrom(null /* context */, culture, value)
                                            : converter.ConvertTo(null /* context */, culture, value, destinationType);
                return convertedValue;
            }
            catch (Exception ex)
            {
                string message = String.Format(CultureInfo.CurrentCulture, MvcResources.ValueProviderResult_ConversionThrew,
                                               value.GetType().FullName, destinationType.FullName);
                throw new InvalidOperationException(message, ex);
            }
        }

        public object ConvertTo(Type type)
        {
            return ConvertTo(type, null /* culture */);
        }

        public virtual object ConvertTo(Type type, CultureInfo culture)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            CultureInfo cultureToUse = culture ?? Culture;
            return UnwrapPossibleArrayType(cultureToUse, RawValue, type);
        }

        private static object UnwrapPossibleArrayType(CultureInfo culture, object value, Type destinationType)
        {
            if (value == null || destinationType.IsInstanceOfType(value))
            {
                return value;
            }

            // array conversion results in four cases, as below
            Array valueAsArray = value as Array;
            if (destinationType.IsArray)
            {
                Type destinationElementType = destinationType.GetElementType();
                if (valueAsArray != null)
                {
                    // case 1: both destination + source type are arrays, so convert each element
                    IList converted = Array.CreateInstance(destinationElementType, valueAsArray.Length);
                    for (int i = 0; i < valueAsArray.Length; i++)
                    {
                        converted[i] = ConvertSimpleType(culture, valueAsArray.GetValue(i), destinationElementType);
                    }
                    return converted;
                }
                else
                {
                    // case 2: destination type is array but source is single element, so wrap element in array + convert
                    object element = ConvertSimpleType(culture, value, destinationElementType);
                    IList converted = Array.CreateInstance(destinationElementType, 1);
                    converted[0] = element;
                    return converted;
                }
            }
            else if (valueAsArray != null)
            {
                // case 3: destination type is single element but source is array, so extract first element + convert
                if (valueAsArray.Length > 0)
                {
                    value = valueAsArray.GetValue(0);
                    return ConvertSimpleType(culture, value, destinationType);
                }
                else
                {
                    // case 3(a): source is empty array, so can't perform conversion
                    return null;
                }
            }
            // case 4: both destination + source type are single elements, so convert
            return ConvertSimpleType(culture, value, destinationType);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ValueProviderUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    internal static class ValueProviderUtil
    {
        public static bool CollectionContainsPrefix(IEnumerable<string> collection, string prefix)
        {
            foreach (string key in collection)
            {
                if (key != null)
                {
                    if (prefix.Length == 0)
                    {
                        return true; // shortcut - non-null key matches empty prefix
                    }

                    if (key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                    {
                        if (key.Length == prefix.Length)
                        {
                            return true; // exact match
                        }
                        else
                        {
                            switch (key[prefix.Length])
                            {
                                case '.': // known separator characters
                                case '[':
                                    return true;
                            }
                        }
                    }
                }
            }

            return false; // nothing found
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Web.Mvc.Html;
using System.Web.WebPages.Scope;

namespace System.Web.Mvc
{
    public class ViewContext : ControllerContext
    {
        private const string ClientValidationScript = @"<script type=""text/javascript"">
//<![CDATA[
if (!window.mvcClientValidationMetadata) {{ window.mvcClientValidationMetadata = []; }}
window.mvcClientValidationMetadata.push({0});
//]]>
</script>";

        internal static readonly string ClientValidationKeyName = "ClientValidationEnabled";
        internal static readonly string UnobtrusiveJavaScriptKeyName = "UnobtrusiveJavaScriptEnabled";
        internal static readonly string ValidationSummaryMessageElementKeyName = "ValidationSummaryMessageElement";
        internal static readonly string ValidationMessageElementKeyName = "ValidationMessageElement";

        // Some values have to be stored in HttpContext.Items in order to be propagated between calls
        // to RenderPartial(), RenderAction(), etc.
        private static readonly object _formContextKey = new object();
        private static readonly object _lastFormNumKey = new object();

        private Func<IDictionary<object, object>> _scopeThunk;
        private IDictionary<object, object> _transientScope;

        private DynamicViewDataDictionary _dynamicViewDataDictionary;
        private Func<string> _formIdGenerator;

        // We need a default FormContext if the user uses html <form> instead of an MvcForm
        private FormContext _defaultFormContext = new FormContext();

        // parameterless constructor used for mocking
        public ViewContext()
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The virtual property setters are only to support mocking frameworks, in which case this constructor shouldn't be called anyway.")]
        public ViewContext(ControllerContext controllerContext, IView view, ViewDataDictionary viewData, TempDataDictionary tempData, TextWriter writer)
            : base(controllerContext)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (view == null)
            {
                throw new ArgumentNullException("view");
            }
            if (viewData == null)
            {
                throw new ArgumentNullException("viewData");
            }
            if (tempData == null)
            {
                throw new ArgumentNullException("tempData");
            }
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }

            View = view;
            ViewData = viewData;
            Writer = writer;
            TempData = tempData;
        }

        public virtual bool ClientValidationEnabled
        {
            get { return GetClientValidationEnabled(Scope, HttpContext); }
            set { SetClientValidationEnabled(value, Scope, HttpContext); }
        }

        public virtual FormContext FormContext
        {
            get
            {
                // Never return a null form context, this is important for validation purposes
                return HttpContext.Items[_formContextKey] as FormContext ?? _defaultFormContext;
            }
            set { HttpContext.Items[_formContextKey] = value; }
        }

        internal Func<string> FormIdGenerator
        {
            get
            {
                if (_formIdGenerator == null)
                {
                    _formIdGenerator = DefaultFormIdGenerator;
                }
                return _formIdGenerator;
            }
            set { _formIdGenerator = value; }
        }

        internal static Func<IDictionary<object, object>> GlobalScopeThunk { get; set; }

        private IDictionary<object, object> Scope
        {
            get
            {
                if (ScopeThunk != null)
                {
                    return ScopeThunk();
                }
                if (_transientScope == null)
                {
                    _transientScope = new Dictionary<object, object>();
                }
                return _transientScope;
            }
        }

        internal Func<IDictionary<object, object>> ScopeThunk
        {
            get { return _scopeThunk ?? GlobalScopeThunk; }
            set { _scopeThunk = value; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "The property setter is only here to support mocking this type and should not be called at runtime.")]
        public virtual TempDataDictionary TempData { get; set; }

        public virtual bool UnobtrusiveJavaScriptEnabled
        {
            get { return GetUnobtrusiveJavaScriptEnabled(Scope, HttpContext); }
            set { SetUnobtrusiveJavaScriptEnabled(value, Scope, HttpContext); }
        }

        /// <summary>
        /// Element name used to wrap a top-level message generated by
        /// <see cref="ValidationExtensions.ValidationSummary(HtmlHelper)"/> and other overloads.
        /// </summary>
        public virtual string ValidationSummaryMessageElement
        {
            get { return GetValidationSummaryMessageElement(Scope, HttpContext); }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    throw Error.ParameterCannotBeNullOrEmpty("value");
                }

                SetValidationSummaryMessageElement(value, Scope, HttpContext);
            }
        }

        /// <summary>
        /// Element name used to wrap a top-level message generated by
        /// <see cref="ValidationExtensions.ValidationMessage(HtmlHelper, String)"/> and other overloads.
        /// </summary>
        public virtual string ValidationMessageElement
        {
            get { return GetValidationMessageElement(Scope, HttpContext); }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    throw Error.ParameterCannotBeNullOrEmpty("value");
                }

                SetValidationMessageElement(value, Scope, HttpContext);
            }
        }

        public virtual IView View { get; set; }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewDataDictionary == null)
                {
                    _dynamicViewDataDictionary = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewDataDictionary;
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "The property setter is only here to support mocking this type and should not be called at runtime.")]
        public virtual ViewDataDictionary ViewData { get; set; }

        public virtual TextWriter Writer { get; set; }

        private string DefaultFormIdGenerator()
        {
            int formNum = IncrementFormCount(HttpContext.Items);
            return String.Format(CultureInfo.InvariantCulture, "form{0}", formNum);
        }

        internal static bool GetClientValidationEnabled(IDictionary<object, object> scope = null, HttpContextBase httpContext = null)
        {
            return ScopeCache.Get(scope, httpContext).ClientValidationEnabled;
        }

        internal FormContext GetFormContextForClientValidation()
        {
            return (ClientValidationEnabled) ? FormContext : null;
        }

        internal static bool GetUnobtrusiveJavaScriptEnabled(IDictionary<object, object> scope = null, HttpContextBase httpContext = null)
        {
            return ScopeCache.Get(scope, httpContext).UnobtrusiveJavaScriptEnabled;
        }

        internal static string GetValidationSummaryMessageElement(
            IDictionary<object, object> scope = null,
            HttpContextBase httpContext = null)
        {
            return ScopeCache.Get(scope, httpContext).ValidationSummaryMessageElement;
        }

        internal static string GetValidationMessageElement(
            IDictionary<object, object> scope = null,
            HttpContextBase httpContext = null)
        {
            return ScopeCache.Get(scope, httpContext).ValidationMessageElement;
        }

        private static int IncrementFormCount(IDictionary items)
        {
            object lastFormNum = items[_lastFormNumKey];
            int newFormNum = (lastFormNum != null) ? ((int)lastFormNum) + 1 : 0;
            items[_lastFormNumKey] = newFormNum;
            return newFormNum;
        }

        public void OutputClientValidation()
        {
            FormContext formContext = GetFormContextForClientValidation();
            if (formContext == null || UnobtrusiveJavaScriptEnabled)
            {
                return; // do nothing
            }

            string scriptWithCorrectNewLines = ClientValidationScript.Replace("\r\n", Environment.NewLine);
            string validationJson = formContext.GetJsonValidationMetadata();
            string formatted = String.Format(CultureInfo.InvariantCulture, scriptWithCorrectNewLines, validationJson);

            Writer.Write(formatted);
        }

        internal static void SetClientValidationEnabled(bool enabled, IDictionary<object, object> scope = null, HttpContextBase httpContext = null)
        {
            ScopeCache.Get(scope, httpContext).ClientValidationEnabled = enabled;
        }

        internal static void SetUnobtrusiveJavaScriptEnabled(bool enabled, IDictionary<object, object> scope = null, HttpContextBase httpContext = null)
        {
            ScopeCache.Get(scope, httpContext).UnobtrusiveJavaScriptEnabled = enabled;
        }

        internal static void SetValidationSummaryMessageElement(
            string elementName,
            IDictionary<object, object> scope = null,
            HttpContextBase httpContext = null)
        {
            ScopeCache.Get(scope, httpContext).ValidationSummaryMessageElement = elementName;
        }

        internal static void SetValidationMessageElement(
            string elementName,
            IDictionary<object, object> scope = null,
            HttpContextBase httpContext = null)
        {
            ScopeCache.Get(scope, httpContext).ValidationMessageElement = elementName;
        }

        private static TValue ScopeGet<TValue>(IDictionary<object, object> scope, string name, TValue defaultValue = default(TValue))
        {
            object result;
            if (scope.TryGetValue(name, out result))
            {
                return (TValue)Convert.ChangeType(result, typeof(TValue), CultureInfo.InvariantCulture);
            }
            return defaultValue;
        }

        private sealed class ScopeCache
        {
            private static readonly object _cacheKey = new object();
            private bool _clientValidationEnabled;
            private IDictionary<object, object> _scope;
            private bool _unobtrusiveJavaScriptEnabled;
            private string _validationSummaryMessageElement;
            private string _validationMessageElement;

            private ScopeCache(IDictionary<object, object> scope)
            {
                _scope = scope;

                _clientValidationEnabled = ScopeGet(scope, ClientValidationKeyName, false);
                _unobtrusiveJavaScriptEnabled = ScopeGet(scope, UnobtrusiveJavaScriptKeyName, false);
                _validationSummaryMessageElement = ScopeGet(scope, ValidationSummaryMessageElementKeyName, "span");
                _validationMessageElement = ScopeGet(scope, ValidationMessageElementKeyName, "span");
            }

            public bool ClientValidationEnabled
            {
                get { return _clientValidationEnabled; }
                set
                {
                    _clientValidationEnabled = value;
                    _scope[ClientValidationKeyName] = value;
                }
            }

            public bool UnobtrusiveJavaScriptEnabled
            {
                get { return _unobtrusiveJavaScriptEnabled; }
                set
                {
                    _unobtrusiveJavaScriptEnabled = value;
                    _scope[UnobtrusiveJavaScriptKeyName] = value;
                }
            }

            public string ValidationSummaryMessageElement
            {
                get { return _validationSummaryMessageElement; }
                set
                {
                    _validationSummaryMessageElement = value;
                    _scope[ValidationSummaryMessageElementKeyName] = value;
                }
            }

            public string ValidationMessageElement
            {
                get { return _validationMessageElement; }
                set
                {
                    _validationMessageElement = value;
                    _scope[ValidationMessageElementKeyName] = value;
                }
            }

            public static ScopeCache Get(IDictionary<object, object> scope, HttpContextBase httpContext)
            {
                if (httpContext == null && Web.HttpContext.Current != null)
                {
                    httpContext = new HttpContextWrapper(Web.HttpContext.Current);
                }

                ScopeCache result = null;
                scope = scope ?? ScopeStorage.CurrentScope;

                if (httpContext != null)
                {
                    result = httpContext.Items[_cacheKey] as ScopeCache;
                }

                if (result == null || result._scope != scope)
                {
                    result = new ScopeCache(scope);

                    if (httpContext != null)
                    {
                        httpContext.Items[_cacheKey] = result;
                    }
                }

                return result;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewDataDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    // TODO: Unit test ModelState interaction with VDD

    public class ViewDataDictionary : IDictionary<string, object>
    {
        private readonly IDictionary<string, object> _innerDictionary;
        private readonly ModelStateDictionary _modelState;
        private object _model;
        private ModelMetadata _modelMetadata;
        private TemplateInfo _templateMetadata;

        public ViewDataDictionary()
            : this((object)null)
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "See note on SetModel() method.")]
        public ViewDataDictionary(object model)
        {
            Model = model;
            _innerDictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            _modelState = new ModelStateDictionary();
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "See note on SetModel() method.")]
        public ViewDataDictionary(ViewDataDictionary dictionary)
        {
            if (dictionary == null)
            {
                throw new ArgumentNullException("dictionary");
            }

            _innerDictionary = new CopyOnWriteDictionary<string, object>(dictionary, StringComparer.OrdinalIgnoreCase);
            _modelState = new ModelStateDictionary(dictionary.ModelState);

            Model = dictionary.Model;
            TemplateInfo = dictionary.TemplateInfo;

            // PERF: Don't unnecessarily instantiate the model metadata
            _modelMetadata = dictionary._modelMetadata;
        }

        public int Count
        {
            get { return _innerDictionary.Count; }
        }

        public bool IsReadOnly
        {
            get { return _innerDictionary.IsReadOnly; }
        }

        public ICollection<string> Keys
        {
            get { return _innerDictionary.Keys; }
        }

        public object Model
        {
            get { return _model; }
            set
            {
                _modelMetadata = null;
                SetModel(value);
            }
        }

        public virtual ModelMetadata ModelMetadata
        {
            get
            {
                if (_modelMetadata == null && _model != null)
                {
                    _modelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => _model, _model.GetType());
                }
                return _modelMetadata;
            }
            set { _modelMetadata = value; }
        }

        public ModelStateDictionary ModelState
        {
            get { return _modelState; }
        }

        public TemplateInfo TemplateInfo
        {
            get
            {
                if (_templateMetadata == null)
                {
                    _templateMetadata = new TemplateInfo();
                }
                return _templateMetadata;
            }
            set { _templateMetadata = value; }
        }

        public ICollection<object> Values
        {
            get { return _innerDictionary.Values; }
        }

        public object this[string key]
        {
            get
            {
                object value;
                _innerDictionary.TryGetValue(key, out value);
                return value;
            }
            set { _innerDictionary[key] = value; }
        }

        // For unit testing
        internal IDictionary<string, object> InnerDictionary
        {
            get { return _innerDictionary; }
        }

        public void Add(KeyValuePair<string, object> item)
        {
            _innerDictionary.Add(item);
        }

        public void Add(string key, object value)
        {
            _innerDictionary.Add(key, value);
        }

        public void Clear()
        {
            _innerDictionary.Clear();
        }

        public bool Contains(KeyValuePair<string, object> item)
        {
            return _innerDictionary.Contains(item);
        }

        public bool ContainsKey(string key)
        {
            return _innerDictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<string, object>[] array, int arrayIndex)
        {
            _innerDictionary.CopyTo(array, arrayIndex);
        }

        public object Eval(string expression)
        {
            ViewDataInfo info = GetViewDataInfo(expression);
            return (info != null) ? info.Value : null;
        }

        public string Eval(string expression, string format)
        {
            object value = Eval(expression);
            return FormatValueInternal(value, format);
        }

        internal static string FormatValueInternal(object value, string format)
        {
            if (value == null)
            {
                return String.Empty;
            }

            if (String.IsNullOrEmpty(format))
            {
                return Convert.ToString(value, CultureInfo.CurrentCulture);
            }
            else
            {
                return String.Format(CultureInfo.CurrentCulture, format, value);
            }
        }

        public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
        {
            return _innerDictionary.GetEnumerator();
        }

        public ViewDataInfo GetViewDataInfo(string expression)
        {
            if (String.IsNullOrEmpty(expression))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "expression");
            }

            return ViewDataEvaluator.Eval(this, expression);
        }

        public bool Remove(KeyValuePair<string, object> item)
        {
            return _innerDictionary.Remove(item);
        }

        public bool Remove(string key)
        {
            return _innerDictionary.Remove(key);
        }

        // This method will execute before the derived type's instance constructor executes. Derived types must
        // be aware of this and should plan accordingly. For example, the logic in SetModel() should be simple
        // enough so as not to depend on the "this" pointer referencing a fully constructed object.
        protected virtual void SetModel(object value)
        {
            _model = value;
        }

        public bool TryGetValue(string key, out object value)
        {
            return _innerDictionary.TryGetValue(key, out value);
        }

        internal static class ViewDataEvaluator
        {
            public static ViewDataInfo Eval(ViewDataDictionary vdd, string expression)
            {
                //Given an expression "foo.bar.baz" we look up the following (pseudocode):
                //  this["foo.bar.baz.quux"]
                //  this["foo.bar.baz"]["quux"]
                //  this["foo.bar"]["baz.quux]
                //  this["foo.bar"]["baz"]["quux"]
                //  this["foo"]["bar.baz.quux"]
                //  this["foo"]["bar.baz"]["quux"]
                //  this["foo"]["bar"]["baz.quux"]
                //  this["foo"]["bar"]["baz"]["quux"]

                ViewDataInfo evaluated = EvalComplexExpression(vdd, expression);
                return evaluated;
            }

            private static ViewDataInfo EvalComplexExpression(object indexableObject, string expression)
            {
                foreach (ExpressionPair expressionPair in GetRightToLeftExpressions(expression))
                {
                    string subExpression = expressionPair.Left;
                    string postExpression = expressionPair.Right;

                    ViewDataInfo subTargetInfo = GetPropertyValue(indexableObject, subExpression);
                    if (subTargetInfo != null)
                    {
                        if (String.IsNullOrEmpty(postExpression))
                        {
                            return subTargetInfo;
                        }

                        if (subTargetInfo.Value != null)
                        {
                            ViewDataInfo potential = EvalComplexExpression(subTargetInfo.Value, postExpression);
                            if (potential != null)
                            {
                                return potential;
                            }
                        }
                    }
                }
                return null;
            }

            private static IEnumerable<ExpressionPair> GetRightToLeftExpressions(string expression)
            {
                // Produces an enumeration of all the combinations of complex property names
                // given a complex expression. See the list above for an example of the result
                // of the enumeration.

                yield return new ExpressionPair(expression, String.Empty);

                int lastDot = expression.LastIndexOf('.');

                string subExpression = expression;
                string postExpression = String.Empty;

                while (lastDot > -1)
                {
                    subExpression = expression.Substring(0, lastDot);
                    postExpression = expression.Substring(lastDot + 1);
                    yield return new ExpressionPair(subExpression, postExpression);

                    lastDot = subExpression.LastIndexOf('.');
                }
            }

            private static ViewDataInfo GetIndexedPropertyValue(object indexableObject, string key)
            {
                IDictionary<string, object> dict = indexableObject as IDictionary<string, object>;
                object value = null;
                bool success = false;

                if (dict != null)
                {
                    success = dict.TryGetValue(key, out value);
                }
                else
                {
                    TryGetValueDelegate tgvDel = TypeHelpers.CreateTryGetValueDelegate(indexableObject.GetType());
                    if (tgvDel != null)
                    {
                        success = tgvDel(indexableObject, key, out value);
                    }
                }

                if (success)
                {
                    return new ViewDataInfo()
                    {
                        Container = indexableObject,
                        Value = value
                    };
                }

                return null;
            }

            private static ViewDataInfo GetPropertyValue(object container, string propertyName)
            {
                // This method handles one "segment" of a complex property expression

                // First, we try to evaluate the property based on its indexer
                ViewDataInfo value = GetIndexedPropertyValue(container, propertyName);
                if (value != null)
                {
                    return value;
                }

                // If the indexer didn't return anything useful, continue...

                // If the container is a ViewDataDictionary then treat its Model property
                // as the container instead of the ViewDataDictionary itself.
                ViewDataDictionary vdd = container as ViewDataDictionary;
                if (vdd != null)
                {
                    container = vdd.Model;
                }

                // If the container is null, we're out of options
                if (container == null)
                {
                    return null;
                }

                // Second, we try to use PropertyDescriptors and treat the expression as a property name
                PropertyDescriptor descriptor = TypeDescriptor.GetProperties(container).Find(propertyName, true);
                if (descriptor == null)
                {
                    return null;
                }

                return new ViewDataInfo(() => descriptor.GetValue(container))
                {
                    Container = container,
                    PropertyDescriptor = descriptor
                };
            }

            private struct ExpressionPair
            {
                public readonly string Left;
                public readonly string Right;

                public ExpressionPair(string left, string right)
                {
                    Left = left;
                    Right = right;
                }
            }
        }

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _innerDictionary.GetEnumerator();
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.Mvc/ViewDataDictionaryOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ViewDataDictionary<TModel> : ViewDataDictionary
    {
        public ViewDataDictionary()
            :
                base(default(TModel))
        {
        }

        public ViewDataDictionary(TModel model)
            :
                base(model)
        {
        }

        public ViewDataDictionary(ViewDataDictionary viewDataDictionary)
            :
                base(viewDataDictionary)
        {
        }

        public new TModel Model
        {
            get { return (TModel)base.Model; }
            set { SetModel(value); }
        }

        public override ModelMetadata ModelMetadata
        {
            get
            {
                ModelMetadata result = base.ModelMetadata;
                if (result == null)
                {
                    result = base.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(TModel));
                }
                return result;
            }
            set { base.ModelMetadata = value; }
        }

        protected override void SetModel(object value)
        {
            bool castWillSucceed = TypeHelpers.IsCompatibleObject<TModel>(value);

            if (castWillSucceed)
            {
                base.SetModel((TModel)value);
            }
            else
            {
                InvalidOperationException exception = (value != null)
                                                          ? Error.ViewDataDictionary_WrongTModelType(value.GetType(), typeof(TModel))
                                                          : Error.ViewDataDictionary_ModelCannotBeNull(typeof(TModel));
                throw exception;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewDataInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;

namespace System.Web.Mvc
{
    public class ViewDataInfo
    {
        private object _value;
        private Func<object> _valueAccessor;

        public ViewDataInfo()
        {
        }

        public ViewDataInfo(Func<object> valueAccessor)
        {
            _valueAccessor = valueAccessor;
        }

        public object Container { get; set; }

        public PropertyDescriptor PropertyDescriptor { get; set; }

        public object Value
        {
            get
            {
                if (_valueAccessor != null)
                {
                    _value = _valueAccessor();
                    _valueAccessor = null;
                }

                return _value;
            }
            set
            {
                _value = value;
                _valueAccessor = null;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewEngineCollection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ViewEngineCollection : Collection<IViewEngine>
    {
        private IViewEngine[] _combinedItems;
        private IDependencyResolver _dependencyResolver;

        public ViewEngineCollection()
        {
        }

        public ViewEngineCollection(IList<IViewEngine> list)
            : base(list)
        {
        }

        internal ViewEngineCollection(IList<IViewEngine> list, IDependencyResolver dependencyResolver)
            : base(list)
        {
            _dependencyResolver = dependencyResolver;
        }

        internal IViewEngine[] CombinedItems
        {
            get
            {
                IViewEngine[] combinedItems = _combinedItems;
                if (combinedItems == null)
                {
                    combinedItems = MultiServiceResolver.GetCombined<IViewEngine>(Items, _dependencyResolver);
                    _combinedItems = combinedItems;
                }
                return combinedItems;
            }
        }

        protected override void ClearItems()
        {
            _combinedItems = null;
            base.ClearItems();
        }

        protected override void InsertItem(int index, IViewEngine item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.InsertItem(index, item);
        }

        protected override void RemoveItem(int index)
        {
            _combinedItems = null;
            base.RemoveItem(index);
        }

        protected override void SetItem(int index, IViewEngine item)
        {
            if (item == null)
            {
                throw new ArgumentNullException("item");
            }
            _combinedItems = null;
            base.SetItem(index, item);
        }

        private ViewEngineResult Find(Func<IViewEngine, ViewEngineResult> cacheLocator, Func<IViewEngine, ViewEngineResult> locator)
        {
            // First, look up using the cacheLocator and do not track the searched paths in non-matching view engines
            // Then, look up using the normal locator and track the searched paths so that an error view engine can be returned
            return Find(cacheLocator, trackSearchedPaths: false)
                   ?? Find(locator, trackSearchedPaths: true);
        }

        private ViewEngineResult Find(Func<IViewEngine, ViewEngineResult> lookup, bool trackSearchedPaths)
        {
            // Returns
            //    1st result
            // OR list of searched paths (if trackSearchedPaths == true)
            // OR null
            ViewEngineResult result;

            List<string> searched = null;
            if (trackSearchedPaths)
            {
                searched = new List<string>();
            }

            foreach (IViewEngine engine in CombinedItems)
            {
                if (engine != null)
                {
                    result = lookup(engine);

                    if (result.View != null)
                    {
                        return result;
                    }

                    if (trackSearchedPaths)
                    {
                        searched.AddRange(result.SearchedLocations);
                    }
                }
            }

            if (trackSearchedPaths)
            {
                // Remove duplicate search paths since multiple view engines could have potentially looked at the same path
                return new ViewEngineResult(searched.Distinct().ToList());
            }
            else
            {
                return null;
            }
        }

        public virtual ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (String.IsNullOrEmpty(partialViewName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "partialViewName");
            }

            return Find(e => e.FindPartialView(controllerContext, partialViewName, true),
                        e => e.FindPartialView(controllerContext, partialViewName, false));
        }

        public virtual ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (String.IsNullOrEmpty(viewName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "viewName");
            }

            return Find(e => e.FindView(controllerContext, viewName, masterName, true),
                        e => e.FindView(controllerContext, viewName, masterName, false));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewEngineResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Mvc
{
    public class ViewEngineResult
    {
        public ViewEngineResult(IEnumerable<string> searchedLocations)
        {
            if (searchedLocations == null)
            {
                throw new ArgumentNullException("searchedLocations");
            }

            SearchedLocations = searchedLocations;
        }

        public ViewEngineResult(IView view, IViewEngine viewEngine)
        {
            if (view == null)
            {
                throw new ArgumentNullException("view");
            }
            if (viewEngine == null)
            {
                throw new ArgumentNullException("viewEngine");
            }

            View = view;
            ViewEngine = viewEngine;
        }

        public IEnumerable<string> SearchedLocations { get; private set; }

        public IView View { get; private set; }

        public IViewEngine ViewEngine { get; private set; }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewEngines.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public static class ViewEngines
    {
        private static readonly ViewEngineCollection _engines = new ViewEngineCollection
        {
            new WebFormViewEngine(),
            new RazorViewEngine(),
        };

        public static ViewEngineCollection Engines
        {
            get { return _engines; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewMasterPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Mvc.Properties;
using System.Web.UI;

namespace System.Web.Mvc
{
    [FileLevelControlBuilder(typeof(ViewMasterPageControlBuilder))]
    public class ViewMasterPage : MasterPage
    {
        public AjaxHelper<object> Ajax
        {
            get { return ViewPage.Ajax; }
        }

        public HtmlHelper<object> Html
        {
            get { return ViewPage.Html; }
        }

        public object Model
        {
            get { return ViewData.Model; }
        }

        public TempDataDictionary TempData
        {
            get { return ViewPage.TempData; }
        }

        public UrlHelper Url
        {
            get { return ViewPage.Url; }
        }

        public dynamic ViewBag
        {
            get { return ViewPage.ViewBag; }
        }

        public ViewContext ViewContext
        {
            get { return ViewPage.ViewContext; }
        }

        public ViewDataDictionary ViewData
        {
            get { return ViewPage.ViewData; }
        }

        internal ViewPage ViewPage
        {
            get
            {
                ViewPage viewPage = Page as ViewPage;
                if (viewPage == null)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, MvcResources.ViewMasterPage_RequiresViewPage));
                }
                return viewPage;
            }
        }

        public HtmlTextWriter Writer
        {
            get { return ViewPage.Writer; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewMasterPageControlBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.UI;

namespace System.Web.Mvc
{
    internal sealed class ViewMasterPageControlBuilder : FileLevelMasterPageControlBuilder, IMvcControlBuilder
    {
        public string Inherits { get; set; }

        public override void ProcessGeneratedCode(CodeCompileUnit codeCompileUnit, CodeTypeDeclaration baseType, CodeTypeDeclaration derivedType, CodeMemberMethod buildMethod, CodeMemberMethod dataBindingMethod)
        {
            if (!String.IsNullOrWhiteSpace(Inherits))
            {
                derivedType.BaseTypes[0] = new CodeTypeReference(Inherits);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewMasterPageOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ViewMasterPage<TModel> : ViewMasterPage
    {
        private AjaxHelper<TModel> _ajaxHelper;
        private HtmlHelper<TModel> _htmlHelper;
        private ViewDataDictionary<TModel> _viewData;

        public new AjaxHelper<TModel> Ajax
        {
            get
            {
                if (_ajaxHelper == null)
                {
                    _ajaxHelper = new AjaxHelper<TModel>(ViewContext, ViewPage);
                }
                return _ajaxHelper;
            }
        }

        public new HtmlHelper<TModel> Html
        {
            get
            {
                if (_htmlHelper == null)
                {
                    _htmlHelper = new HtmlHelper<TModel>(ViewContext, ViewPage);
                }
                return _htmlHelper;
            }
        }

        public new TModel Model
        {
            get { return ViewData.Model; }
        }

        public new ViewDataDictionary<TModel> ViewData
        {
            get
            {
                if (_viewData == null)
                {
                    _viewData = new ViewDataDictionary<TModel>(ViewPage.ViewData);
                }
                return _viewData;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Text;
using System.Web.UI;

namespace System.Web.Mvc
{
    [FileLevelControlBuilder(typeof(ViewPageControlBuilder))]
    public class ViewPage : Page, IViewDataContainer
    {
        [ThreadStatic]
        private static int _nextId;

        private DynamicViewDataDictionary _dynamicViewData;
        private string _masterLocation;

        private ViewDataDictionary _viewData;

        public AjaxHelper<object> Ajax { get; set; }

        public HtmlHelper<object> Html { get; set; }

        public string MasterLocation
        {
            get { return _masterLocation ?? String.Empty; }
            set { _masterLocation = value; }
        }

        public object Model
        {
            get { return ViewData.Model; }
        }

        public TempDataDictionary TempData
        {
            get { return ViewContext.TempData; }
        }

        public UrlHelper Url { get; set; }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewData == null)
                {
                    _dynamicViewData = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewData;
            }
        }

        public ViewContext ViewContext { get; set; }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is the mechanism by which the ViewPage gets its ViewDataDictionary object.")]
        public ViewDataDictionary ViewData
        {
            get
            {
                if (_viewData == null)
                {
                    SetViewData(new ViewDataDictionary());
                }
                return _viewData;
            }
            set { SetViewData(value); }
        }

        public HtmlTextWriter Writer { get; private set; }

        public virtual void InitHelpers()
        {
            Ajax = new AjaxHelper<object>(ViewContext, this);
            Html = new HtmlHelper<object>(ViewContext, this);
            Url = new UrlHelper(ViewContext.RequestContext);
        }

        internal static string NextId()
        {
            return (++_nextId).ToString(CultureInfo.InvariantCulture);
        }

        protected override void OnPreInit(EventArgs e)
        {
            base.OnPreInit(e);

            if (!String.IsNullOrEmpty(MasterLocation))
            {
                MasterPageFile = MasterLocation;
            }
        }

        public override void ProcessRequest(HttpContext context)
        {
            // Tracing requires IDs to be unique.
            ID = NextId();

            base.ProcessRequest(context);
        }

        protected override void Render(HtmlTextWriter writer)
        {
            Writer = writer;
            try
            {
                base.Render(writer);
            }
            finally
            {
                Writer = null;
            }
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The object is disposed in the finally block of the method")]
        public virtual void RenderView(ViewContext viewContext)
        {
            ViewContext = viewContext;
            InitHelpers();

            bool createdSwitchWriter = false;
            SwitchWriter switchWriter = viewContext.HttpContext.Response.Output as SwitchWriter;

            try
            {
                if (switchWriter == null)
                {
                    switchWriter = new SwitchWriter();
                    createdSwitchWriter = true;
                }

                using (switchWriter.Scope(viewContext.Writer))
                {
                    if (createdSwitchWriter)
                    {
                        // It's safe to reset the _nextId within a Server.Execute() since it pushes a new TraceContext onto
                        // the stack, so there won't be an ID conflict.
                        int originalNextId = _nextId;
                        try
                        {
                            _nextId = 0;
                            viewContext.HttpContext.Server.Execute(HttpHandlerUtil.WrapForServerExecute(this), switchWriter, true /* preserveForm */);
                        }
                        finally
                        {
                            // Restore the original _nextId in case this isn't actually the outermost view, since resetting
                            // the _nextId may now cause trace ID conflicts in the outer view.
                            _nextId = originalNextId;
                        }
                    }
                    else
                    {
                        ProcessRequest(HttpContext.Current);
                    }
                }
            }
            finally
            {
                if (createdSwitchWriter)
                {
                    switchWriter.Dispose();
                }
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "textWriter", Justification = "This method existed in MVC 1.0 and has been deprecated.")]
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This method existed in MVC 1.0 and has been deprecated.")]
        [Obsolete("The TextWriter is now provided by the ViewContext object passed to the RenderView method.", true /* error */)]
        public void SetTextWriter(TextWriter textWriter)
        {
            // this is now a no-op
        }

        protected virtual void SetViewData(ViewDataDictionary viewData)
        {
            _viewData = viewData;
        }

        internal class SwitchWriter : TextWriter
        {
            public SwitchWriter()
                : base(CultureInfo.CurrentCulture)
            {
            }

            public override Encoding Encoding
            {
                get { return InnerWriter.Encoding; }
            }

            public override IFormatProvider FormatProvider
            {
                get { return InnerWriter.FormatProvider; }
            }

            internal TextWriter InnerWriter { get; set; }

            public override string NewLine
            {
                get { return InnerWriter.NewLine; }
                set { InnerWriter.NewLine = value; }
            }

            public override void Close()
            {
                InnerWriter.Close();
            }

            public override void Flush()
            {
                InnerWriter.Flush();
            }

            public IDisposable Scope(TextWriter writer)
            {
                WriterScope scope = new WriterScope(this, InnerWriter);

                try
                {
                    if (writer != this)
                    {
                        InnerWriter = writer;
                    }

                    return scope;
                }
                catch
                {
                    scope.Dispose();
                    throw;
                }
            }

            public override void Write(bool value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(char value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(char[] buffer)
            {
                InnerWriter.Write(buffer);
            }

            public override void Write(char[] buffer, int index, int count)
            {
                InnerWriter.Write(buffer, index, count);
            }

            public override void Write(decimal value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(double value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(float value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(int value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(long value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(object value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(string format, object arg0)
            {
                InnerWriter.Write(format, arg0);
            }

            public override void Write(string format, object arg0, object arg1)
            {
                InnerWriter.Write(format, arg0, arg1);
            }

            public override void Write(string format, object arg0, object arg1, object arg2)
            {
                InnerWriter.Write(format, arg0, arg1, arg2);
            }

            public override void Write(string format, params object[] arg)
            {
                InnerWriter.Write(format, arg);
            }

            public override void Write(string value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(uint value)
            {
                InnerWriter.Write(value);
            }

            public override void Write(ulong value)
            {
                InnerWriter.Write(value);
            }

            public override void WriteLine()
            {
                InnerWriter.WriteLine();
            }

            public override void WriteLine(bool value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(char value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(char[] buffer)
            {
                InnerWriter.WriteLine(buffer);
            }

            public override void WriteLine(char[] buffer, int index, int count)
            {
                InnerWriter.WriteLine(buffer, index, count);
            }

            public override void WriteLine(decimal value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(double value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(float value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(int value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(long value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(object value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(string format, object arg0)
            {
                InnerWriter.WriteLine(format, arg0);
            }

            public override void WriteLine(string format, object arg0, object arg1)
            {
                InnerWriter.WriteLine(format, arg0, arg1);
            }

            public override void WriteLine(string format, object arg0, object arg1, object arg2)
            {
                InnerWriter.WriteLine(format, arg0, arg1, arg2);
            }

            public override void WriteLine(string format, params object[] arg)
            {
                InnerWriter.WriteLine(format, arg);
            }

            public override void WriteLine(string value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(uint value)
            {
                InnerWriter.WriteLine(value);
            }

            public override void WriteLine(ulong value)
            {
                InnerWriter.WriteLine(value);
            }

            private sealed class WriterScope : IDisposable
            {
                private SwitchWriter _switchWriter;
                private TextWriter _writerToRestore;

                public WriterScope(SwitchWriter switchWriter, TextWriter writerToRestore)
                {
                    _switchWriter = switchWriter;
                    _writerToRestore = writerToRestore;
                }

                public void Dispose()
                {
                    _switchWriter.InnerWriter = _writerToRestore;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewPageControlBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.UI;

namespace System.Web.Mvc
{
    internal sealed class ViewPageControlBuilder : FileLevelPageControlBuilder, IMvcControlBuilder
    {
        public string Inherits { get; set; }

        public override void ProcessGeneratedCode(CodeCompileUnit codeCompileUnit, CodeTypeDeclaration baseType, CodeTypeDeclaration derivedType, CodeMemberMethod buildMethod, CodeMemberMethod dataBindingMethod)
        {
            if (!String.IsNullOrWhiteSpace(Inherits))
            {
                derivedType.BaseTypes[0] = new CodeTypeReference(Inherits);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewPageOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class ViewPage<TModel> : ViewPage
    {
        private ViewDataDictionary<TModel> _viewData;

        public new AjaxHelper<TModel> Ajax { get; set; }

        public new HtmlHelper<TModel> Html { get; set; }

        public new TModel Model
        {
            get { return ViewData.Model; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is settable for unit testing purposes")]
        public new ViewDataDictionary<TModel> ViewData
        {
            get
            {
                if (_viewData == null)
                {
                    SetViewData(new ViewDataDictionary<TModel>());
                }
                return _viewData;
            }
            set { SetViewData(value); }
        }

        public override void InitHelpers()
        {
            base.InitHelpers();

            Ajax = new AjaxHelper<TModel>(ViewContext, this);
            Html = new HtmlHelper<TModel>(ViewContext, this);
        }

        protected override void SetViewData(ViewDataDictionary viewData)
        {
            _viewData = new ViewDataDictionary<TModel>(viewData);

            base.SetViewData(_viewData);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Text;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class ViewResult : ViewResultBase
    {
        private string _masterName;

        public string MasterName
        {
            get { return _masterName ?? String.Empty; }
            set { _masterName = value; }
        }

        protected override ViewEngineResult FindView(ControllerContext context)
        {
            ViewEngineResult result = ViewEngineCollection.FindView(context, ViewName, MasterName);
            if (result.View != null)
            {
                return result;
            }

            // we need to generate an exception containing all the locations we searched
            StringBuilder locationsText = new StringBuilder();
            foreach (string location in result.SearchedLocations)
            {
                locationsText.AppendLine();
                locationsText.Append(location);
            }
            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                              MvcResources.Common_ViewNotFound, ViewName, locationsText));
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewResultBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.IO;

namespace System.Web.Mvc
{
    public abstract class ViewResultBase : ActionResult
    {
        private DynamicViewDataDictionary _dynamicViewData;
        private TempDataDictionary _tempData;
        private ViewDataDictionary _viewData;
        private ViewEngineCollection _viewEngineCollection;
        private string _viewName;

        public object Model
        {
            get { return ViewData.Model; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This entire type is meant to be mutable.")]
        public TempDataDictionary TempData
        {
            get
            {
                if (_tempData == null)
                {
                    _tempData = new TempDataDictionary();
                }
                return _tempData;
            }
            set { _tempData = value; }
        }

        public IView View { get; set; }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewData == null)
                {
                    _dynamicViewData = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewData;
            }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This entire type is meant to be mutable.")]
        public ViewDataDictionary ViewData
        {
            get
            {
                if (_viewData == null)
                {
                    _viewData = new ViewDataDictionary();
                }
                return _viewData;
            }
            set { _viewData = value; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This entire type is meant to be mutable.")]
        public ViewEngineCollection ViewEngineCollection
        {
            get { return _viewEngineCollection ?? ViewEngines.Engines; }
            set { _viewEngineCollection = value; }
        }

        public string ViewName
        {
            get { return _viewName ?? String.Empty; }
            set { _viewName = value; }
        }

        public override void ExecuteResult(ControllerContext context)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            if (String.IsNullOrEmpty(ViewName))
            {
                ViewName = context.RouteData.GetRequiredString("action");
            }

            ViewEngineResult result = null;

            if (View == null)
            {
                result = FindView(context);
                View = result.View;
            }

            TextWriter writer = context.HttpContext.Response.Output;
            ViewContext viewContext = new ViewContext(context, View, ViewData, TempData, writer);
            View.Render(viewContext, writer);

            if (result != null)
            {
                result.ViewEngine.ReleaseView(context, View);
            }
        }

        protected abstract ViewEngineResult FindView(ControllerContext context);
    }
}


================================================
FILE: src/System.Web.Mvc/ViewStartPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Properties;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    public abstract class ViewStartPage : StartPage, IViewStartPageChild
    {
        private IViewStartPageChild _viewStartPageChild;

        public HtmlHelper<object> Html
        {
            get { return ViewStartPageChild.Html; }
        }

        public UrlHelper Url
        {
            get { return ViewStartPageChild.Url; }
        }

        public ViewContext ViewContext
        {
            get { return ViewStartPageChild.ViewContext; }
        }

        internal IViewStartPageChild ViewStartPageChild
        {
            get
            {
                if (_viewStartPageChild == null)
                {
                    IViewStartPageChild child = ChildPage as IViewStartPageChild;
                    if (child == null)
                    {
                        throw new InvalidOperationException(MvcResources.ViewStartPage_RequiresMvcRazorView);
                    }
                    _viewStartPageChild = child;
                }

                return _viewStartPageChild;
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewTemplateUserControl.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ViewTemplateUserControl : ViewTemplateUserControl<object>
    {
    }
}


================================================
FILE: src/System.Web.Mvc/ViewTemplateUserControlOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ViewTemplateUserControl<TModel> : ViewUserControl<TModel>
    {
        protected string FormattedModelValue
        {
            get { return ViewData.TemplateInfo.FormattedModelValue.ToString(); }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.UI;

namespace System.Web.Mvc
{
    [ControlBuilder(typeof(ViewTypeControlBuilder))]
    [NonVisualControl]
    public class ViewType : Control
    {
        private string _typeName;

        [DefaultValue("")]
        public string TypeName
        {
            get { return _typeName ?? String.Empty; }
            set { _typeName = value; }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewTypeControlBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections;
using System.Web.UI;

namespace System.Web.Mvc
{
    internal sealed class ViewTypeControlBuilder : ControlBuilder
    {
        private string _typeName;

        public override void Init(TemplateParser parser, ControlBuilder parentBuilder, Type type, string tagName, string id, IDictionary attribs)
        {
            base.Init(parser, parentBuilder, type, tagName, id, attribs);

            _typeName = (string)attribs["typename"];
        }

        public override void ProcessGeneratedCode(
            CodeCompileUnit codeCompileUnit,
            CodeTypeDeclaration baseType,
            CodeTypeDeclaration derivedType,
            CodeMemberMethod buildMethod,
            CodeMemberMethod dataBindingMethod)
        {
            // Override the view's base type with the explicit base type
            derivedType.BaseTypes[0] = new CodeTypeReference(_typeName);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewTypeParserFilter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.UI;

namespace System.Web.Mvc
{
    // This class is referenced dynamically by the web.config built by project templates.
    // Do not delete this class based on it not being statically referenced by product code.

    internal class ViewTypeParserFilter : PageParserFilter
    {
        private static Dictionary<string, Type> _directiveBaseTypeMappings = new Dictionary<string, Type>
        {
            { "page", typeof(ViewPage) },
            { "control", typeof(ViewUserControl) },
            { "master", typeof(ViewMasterPage) },
        };

        private string _inherits;

        public ViewTypeParserFilter()
        {
        }

        public override bool AllowCode
        {
            get { return true; }
        }

        public override int NumberOfControlsAllowed
        {
            get { return -1; }
        }

        public override int NumberOfDirectDependenciesAllowed
        {
            get { return -1; }
        }

        public override int TotalNumberOfDependenciesAllowed
        {
            get { return -1; }
        }

        public override void PreprocessDirective(string directiveName, IDictionary attributes)
        {
            base.PreprocessDirective(directiveName, attributes);

            Type baseType;
            if (_directiveBaseTypeMappings.TryGetValue(directiveName, out baseType))
            {
                string inheritsAttribute = attributes["inherits"] as string;

                // Since the ASP.NET page parser doesn't understand native generic syntax, we
                // need to swap out whatever the user provided with the default base type for
                // the given directive (page vs. control vs. master). We stash the old value
                // and swap it back in inside the control builder. Our "is this generic?"
                // check here really only works for C# and VB.NET, since we're checking for
                // < or ( in the type name.
                //
                // We only change generic directives, because doing so breaks back-compat
                // for property setters on @Page, @Control, and @Master directives. The user
                // can work around this breaking behavior by using a non-generic inherits
                // directive, or by using the CLR syntax for generic type names.

                if (inheritsAttribute != null && inheritsAttribute.IndexOfAny(new[] { '<', '(' }) > 0)
                {
                    attributes["inherits"] = baseType.FullName;
                    _inherits = inheritsAttribute;
                }
            }
        }

        public override void ParseComplete(ControlBuilder rootBuilder)
        {
            base.ParseComplete(rootBuilder);

            IMvcControlBuilder builder = rootBuilder as IMvcControlBuilder;
            if (builder != null)
            {
                builder.Inherits = _inherits;
            }
        }

        // Everything else in this class is unrelated to our 'inherits' handling.
        // Since PageParserFilter blocks everything by default, we need to unblock it

        public override bool AllowBaseType(Type baseType)
        {
            return true;
        }

        public override bool AllowControl(Type controlType, ControlBuilder builder)
        {
            return true;
        }

        public override bool AllowVirtualReference(string referenceVirtualPath, VirtualReferenceType referenceType)
        {
            return true;
        }

        public override bool AllowServerSideInclude(string includeVirtualPath)
        {
            return true;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewUserControl.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Web.Mvc.Properties;
using System.Web.UI;

namespace System.Web.Mvc
{
    [FileLevelControlBuilder(typeof(ViewUserControlControlBuilder))]
    public class ViewUserControl : UserControl, IViewDataContainer
    {
        private AjaxHelper<object> _ajaxHelper;
        private DynamicViewDataDictionary _dynamicViewData;
        private HtmlHelper<object> _htmlHelper;
        private ViewContext _viewContext;
        private ViewDataDictionary _viewData;
        private string _viewDataKey;

        public AjaxHelper<object> Ajax
        {
            get
            {
                if (_ajaxHelper == null)
                {
                    _ajaxHelper = new AjaxHelper<object>(ViewContext, this);
                }
                return _ajaxHelper;
            }
        }

        public HtmlHelper<object> Html
        {
            get
            {
                if (_htmlHelper == null)
                {
                    _htmlHelper = new HtmlHelper<object>(ViewContext, this);
                }
                return _htmlHelper;
            }
        }

        public object Model
        {
            get { return ViewData.Model; }
        }

        public TempDataDictionary TempData
        {
            get { return ViewPage.TempData; }
        }

        public UrlHelper Url
        {
            get { return ViewPage.Url; }
        }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewData == null)
                {
                    _dynamicViewData = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewData;
            }
        }

        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ViewContext ViewContext
        {
            get { return _viewContext ?? ViewPage.ViewContext; }
            set { _viewContext = value; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is the mechanism by which the ViewUserControl gets its ViewDataDictionary object.")]
        [Browsable(false)]
        [DesignerSerializationVisibility(DesignerSerializationVisibility.Hidden)]
        public ViewDataDictionary ViewData
        {
            get
            {
                EnsureViewData();
                return _viewData;
            }
            set { SetViewData(value); }
        }

        [DefaultValue("")]
        public string ViewDataKey
        {
            get { return _viewDataKey ?? String.Empty; }
            set { _viewDataKey = value; }
        }

        internal ViewPage ViewPage
        {
            get
            {
                ViewPage viewPage = Page as ViewPage;
                if (viewPage == null)
                {
                    throw new InvalidOperationException(MvcResources.ViewUserControl_RequiresViewPage);
                }
                return viewPage;
            }
        }

        public HtmlTextWriter Writer
        {
            get { return ViewPage.Writer; }
        }

        protected virtual void SetViewData(ViewDataDictionary viewData)
        {
            _viewData = viewData;
        }

        protected void EnsureViewData()
        {
            if (_viewData != null)
            {
                return;
            }

            // Get the ViewData for this ViewUserControl, optionally using the specified ViewDataKey
            IViewDataContainer vdc = GetViewDataContainer(this);
            if (vdc == null)
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        MvcResources.ViewUserControl_RequiresViewDataProvider,
                        AppRelativeVirtualPath));
            }

            ViewDataDictionary myViewData = vdc.ViewData;

            // If we have a ViewDataKey, try to extract the ViewData from the dictionary, otherwise
            // return the container's ViewData.
            if (!String.IsNullOrEmpty(ViewDataKey))
            {
                object target = myViewData.Eval(ViewDataKey);
                myViewData = target as ViewDataDictionary ?? new ViewDataDictionary(myViewData) { Model = target };
            }

            SetViewData(myViewData);
        }

        private static IViewDataContainer GetViewDataContainer(Control control)
        {
            // Walk up the control hierarchy until we find someone that implements IViewDataContainer
            while (control != null)
            {
                control = control.Parent;
                IViewDataContainer vdc = control as IViewDataContainer;
                if (vdc != null)
                {
                    return vdc;
                }
            }
            return null;
        }

        public virtual void RenderView(ViewContext viewContext)
        {
            using (ViewUserControlContainerPage containerPage = new ViewUserControlContainerPage(this))
            {
                RenderViewAndRestoreContentType(containerPage, viewContext);
            }
        }

        internal static void RenderViewAndRestoreContentType(ViewPage containerPage, ViewContext viewContext)
        {
            // We need to restore the Content-Type since Page.SetIntrinsics() will reset it. It's not possible
            // to work around the call to SetIntrinsics() since the control's render method requires the
            // containing page's Response property to be non-null, and SetIntrinsics() is the only way to set
            // this.
            string savedContentType = viewContext.HttpContext.Response.ContentType;
            containerPage.RenderView(viewContext);
            viewContext.HttpContext.Response.ContentType = savedContentType;
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "textWriter", Justification = "This method existed in MVC 1.0 and has been deprecated.")]
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This method existed in MVC 1.0 and has been deprecated.")]
        [Obsolete("The TextWriter is now provided by the ViewContext object passed to the RenderView method.", true /* error */)]
        public void SetTextWriter(TextWriter textWriter)
        {
            // this is now a no-op
        }

        private sealed class ViewUserControlContainerPage : ViewPage
        {
            private readonly ViewUserControl _userControl;

            public ViewUserControlContainerPage(ViewUserControl userControl)
            {
                _userControl = userControl;
            }

            public override void ProcessRequest(HttpContext context)
            {
                _userControl.ID = NextId();
                Controls.Add(_userControl);

                base.ProcessRequest(context);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewUserControlControlBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.UI;

namespace System.Web.Mvc
{
    internal sealed class ViewUserControlControlBuilder : FileLevelUserControlBuilder, IMvcControlBuilder
    {
        public string Inherits { get; set; }

        public override void ProcessGeneratedCode(CodeCompileUnit codeCompileUnit, CodeTypeDeclaration baseType, CodeTypeDeclaration derivedType, CodeMemberMethod buildMethod, CodeMemberMethod dataBindingMethod)
        {
            if (!String.IsNullOrWhiteSpace(Inherits))
            {
                derivedType.BaseTypes[0] = new CodeTypeReference(Inherits);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/ViewUserControlOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public class ViewUserControl<TModel> : ViewUserControl
    {
        private AjaxHelper<TModel> _ajaxHelper;
        private HtmlHelper<TModel> _htmlHelper;
        private ViewDataDictionary<TModel> _viewData;

        public new AjaxHelper<TModel> Ajax
        {
            get
            {
                if (_ajaxHelper == null)
                {
                    _ajaxHelper = new AjaxHelper<TModel>(ViewContext, this);
                }
                return _ajaxHelper;
            }
        }

        public new HtmlHelper<TModel> Html
        {
            get
            {
                if (_htmlHelper == null)
                {
                    _htmlHelper = new HtmlHelper<TModel>(ViewContext, this);
                }
                return _htmlHelper;
            }
        }

        public new TModel Model
        {
            get { return ViewData.Model; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is settable for unit testing purposes")]
        public new ViewDataDictionary<TModel> ViewData
        {
            get
            {
                EnsureViewData();
                return _viewData;
            }
            set { SetViewData(value); }
        }

        protected override void SetViewData(ViewDataDictionary viewData)
        {
            _viewData = new ViewDataDictionary<TModel>(viewData);

            base.SetViewData(_viewData);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/VirtualPathProviderViewEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web.Hosting;
using System.Web.Mvc.Properties;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    public abstract class VirtualPathProviderViewEngine : IViewEngine
    {
        // format is ":ViewCacheEntry:{cacheType}:{prefix}:{name}:{controllerName}:{areaName}:"
        private const string CacheKeyFormat = ":ViewCacheEntry:{0}:{1}:{2}:{3}:{4}:";
        private const string CacheKeyPrefixMaster = "Master";
        private const string CacheKeyPrefixPartial = "Partial";
        private const string CacheKeyPrefixView = "View";
        private static readonly string[] _emptyLocations = new string[0];
        private DisplayModeProvider _displayModeProvider;

        private Func<VirtualPathProvider> _vppFunc = () => HostingEnvironment.VirtualPathProvider;
        internal Func<string, string> GetExtensionThunk = VirtualPathUtility.GetExtension;
        private IViewLocationCache _viewLocationCache;

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] AreaMasterLocationFormats { get; set; }

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] AreaPartialViewLocationFormats { get; set; }

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] AreaViewLocationFormats { get; set; }

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] FileExtensions { get; set; }

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] MasterLocationFormats { get; set; }

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] PartialViewLocationFormats { get; set; }

        // Neither DefaultViewLocationCache.Null nor a DefaultViewLocationCache instance maintain internal state. Fine
        // if multiple threads race to initialize _viewLocationCache.
        public IViewLocationCache ViewLocationCache
        {
            get
            {
                if (_viewLocationCache == null)
                {
                    if (HttpContext.Current == null || HttpContext.Current.IsDebuggingEnabled)
                    {
                        _viewLocationCache = DefaultViewLocationCache.Null;
                    }
                    else
                    {
                        _viewLocationCache = new DefaultViewLocationCache();
                    }
                }

                return _viewLocationCache;
            }
            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }

                _viewLocationCache = value;
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays", Justification = "This is a shipped API")]
        public string[] ViewLocationFormats { get; set; }

        // Likely exists for testing only
        protected VirtualPathProvider VirtualPathProvider
        {
            get { return _vppFunc(); }
            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }

                _vppFunc = () => value;
            }
        }

        // Provided for testing only; setter used in BuildManagerViewEngine but only for test scenarios
        internal Func<VirtualPathProvider> VirtualPathProviderFunc
        {
            get { return _vppFunc; }
            set
            {
                if (value == null)
                {
                    throw Error.ArgumentNull("value");
                }

                _vppFunc = value;
            }
        }

        protected internal DisplayModeProvider DisplayModeProvider
        {
            get { return _displayModeProvider ?? DisplayModeProvider.Instance; }
            set { _displayModeProvider = value; }
        }

        internal virtual string CreateCacheKey(string prefix, string name, string controllerName, string areaName)
        {
            return String.Format(CultureInfo.InvariantCulture, CacheKeyFormat,
                                 GetType().AssemblyQualifiedName, prefix, name, controllerName, areaName);
        }

        internal static string AppendDisplayModeToCacheKey(string cacheKey, string displayMode)
        {
            // key format is ":ViewCacheEntry:{cacheType}:{prefix}:{name}:{controllerName}:{areaName}:"
            // so append "{displayMode}:" to the key
            return cacheKey + displayMode + ":";
        }

        protected abstract IView CreatePartialView(ControllerContext controllerContext, string partialPath);

        protected abstract IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath);

        protected virtual bool FileExists(ControllerContext controllerContext, string virtualPath)
        {
            return VirtualPathProvider.FileExists(virtualPath);
        }

        public virtual ViewEngineResult FindPartialView(ControllerContext controllerContext, string partialViewName, bool useCache)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (String.IsNullOrEmpty(partialViewName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "partialViewName");
            }

            string[] searched;
            string controllerName = controllerContext.RouteData.GetRequiredString("controller");
            string partialPath = GetPath(controllerContext, PartialViewLocationFormats, AreaPartialViewLocationFormats, "PartialViewLocationFormats", partialViewName, controllerName, CacheKeyPrefixPartial, useCache, out searched);

            if (String.IsNullOrEmpty(partialPath))
            {
                return new ViewEngineResult(searched);
            }

            return new ViewEngineResult(CreatePartialView(controllerContext, partialPath), this);
        }

        public virtual ViewEngineResult FindView(ControllerContext controllerContext, string viewName, string masterName, bool useCache)
        {
            if (controllerContext == null)
            {
                throw new ArgumentNullException("controllerContext");
            }
            if (String.IsNullOrEmpty(viewName))
            {
                throw new ArgumentException(MvcResources.Common_NullOrEmpty, "viewName");
            }

            string[] viewLocationsSearched;
            string[] masterLocationsSearched;

            string controllerName = controllerContext.RouteData.GetRequiredString("controller");
            string viewPath = GetPath(controllerContext, ViewLocationFormats, AreaViewLocationFormats, "ViewLocationFormats", viewName, controllerName, CacheKeyPrefixView, useCache, out viewLocationsSearched);
            string masterPath = GetPath(controllerContext, MasterLocationFormats, AreaMasterLocationFormats, "MasterLocationFormats", masterName, controllerName, CacheKeyPrefixMaster, useCache, out masterLocationsSearched);

            if (String.IsNullOrEmpty(viewPath) || (String.IsNullOrEmpty(masterPath) && !String.IsNullOrEmpty(masterName)))
            {
                return new ViewEngineResult(viewLocationsSearched.Union(masterLocationsSearched));
            }

            return new ViewEngineResult(CreateView(controllerContext, viewPath, masterPath), this);
        }

        private string GetPath(ControllerContext controllerContext, string[] locations, string[] areaLocations, string locationsPropertyName, string name, string controllerName, string cacheKeyPrefix, bool useCache, out string[] searchedLocations)
        {
            searchedLocations = _emptyLocations;

            if (String.IsNullOrEmpty(name))
            {
                return String.Empty;
            }

            string areaName = AreaHelpers.GetAreaName(controllerContext.RouteData);
            bool usingAreas = !String.IsNullOrEmpty(areaName);
            List<ViewLocation> viewLocations = GetViewLocations(locations, (usingAreas) ? areaLocations : null);

            if (viewLocations.Count == 0)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                  MvcResources.Common_PropertyCannotBeNullOrEmpty, locationsPropertyName));
            }

            bool nameRepresentsPath = IsSpecificPath(name);
            string cacheKey = CreateCacheKey(cacheKeyPrefix, name, (nameRepresentsPath) ? String.Empty : controllerName, areaName);

            if (useCache)
            {
                // Only look at cached display modes that can handle the context.
                IEnumerable<IDisplayMode> possibleDisplayModes = DisplayModeProvider.GetAvailableDisplayModesForContext(controllerContext.HttpContext, controllerContext.DisplayMode);
                foreach (IDisplayMode displayMode in possibleDisplayModes)
                {
                    string cachedLocation = ViewLocationCache.GetViewLocation(controllerContext.HttpContext, AppendDisplayModeToCacheKey(cacheKey, displayMode.DisplayModeId));

                    if (cachedLocation == null)
                    {
                        // If any matching display mode location is not in the cache, fall back to the uncached behavior, which will repopulate all of our caches.
                        return null;
                    }

                    // A non-empty cachedLocation indicates that we have a matching file on disk. Return that result.
                    if (cachedLocation.Length > 0)
                    {
                        if (controllerContext.DisplayMode == null)
                        {
                            controllerContext.DisplayMode = displayMode;
                        }

                        return cachedLocation;
                    }
                    // An empty cachedLocation value indicates that we don't have a matching file on disk. Keep going down the list of possible display modes.
                }

                // GetPath is called again without using the cache.
                return null;
            }
            else
            {
                return nameRepresentsPath
                    ? GetPathFromSpecificName(controllerContext, name, cacheKey, ref searchedLocations)
                    : GetPathFromGeneralName(controllerContext, viewLocations, name, controllerName, areaName, cacheKey, ref searchedLocations);
            }
        }

        private string GetPathFromGeneralName(ControllerContext controllerContext, List<ViewLocation> locations, string name, string controllerName, string areaName, string cacheKey, ref string[] searchedLocations)
        {
            string result = String.Empty;
            searchedLocations = new string[locations.Count];

            for (int i = 0; i < locations.Count; i++)
            {
                ViewLocation location = locations[i];
                string virtualPath = location.Format(name, controllerName, areaName);
                DisplayInfo virtualPathDisplayInfo = DisplayModeProvider.GetDisplayInfoForVirtualPath(virtualPath, controllerContext.HttpContext, path => FileExists(controllerContext, path), controllerContext.DisplayMode);

                if (virtualPathDisplayInfo != null)
                {
                    string resolvedVirtualPath = virtualPathDisplayInfo.FilePath;

                    searchedLocations = _emptyLocations;
                    result = resolvedVirtualPath;
                    ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, AppendDisplayModeToCacheKey(cacheKey, virtualPathDisplayInfo.DisplayMode.DisplayModeId), result);

                    if (controllerContext.DisplayMode == null)
                    {
                        controllerContext.DisplayMode = virtualPathDisplayInfo.DisplayMode;
                    }

                    // Populate the cache for all other display modes. We want to cache both file system hits and misses so that we can distinguish
                    // in future requests whether a file's status was evicted from the cache (null value) or if the file doesn't exist (empty string).
                    IEnumerable<IDisplayMode> allDisplayModes = DisplayModeProvider.Modes;
                    foreach (IDisplayMode displayMode in allDisplayModes)
                    {
                        if (displayMode.DisplayModeId != virtualPathDisplayInfo.DisplayMode.DisplayModeId)
                        {
                            DisplayInfo displayInfoToCache = displayMode.GetDisplayInfo(controllerContext.HttpContext, virtualPath, virtualPathExists: path => FileExists(controllerContext, path));

                            string cacheValue = String.Empty;
                            if (displayInfoToCache != null && displayInfoToCache.FilePath != null)
                            {
                                cacheValue = displayInfoToCache.FilePath;
                            }
                            ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, AppendDisplayModeToCacheKey(cacheKey, displayMode.DisplayModeId), cacheValue);
                        }
                    }
                    break;
                }

                searchedLocations[i] = virtualPath;
            }

            return result;
        }

        private string GetPathFromSpecificName(ControllerContext controllerContext, string name, string cacheKey, ref string[] searchedLocations)
        {
            string result = name;

            if (!(FilePathIsSupported(name) && FileExists(controllerContext, name)))
            {
                result = String.Empty;
                searchedLocations = new[] { name };
            }

            ViewLocationCache.InsertViewLocation(controllerContext.HttpContext, cacheKey, result);
            return result;
        }

        private bool FilePathIsSupported(string virtualPath)
        {
            if (FileExtensions == null)
            {
                // legacy behavior for custom ViewEngine that might not set the FileExtensions property
                return true;
            }
            else
            {
                // get rid of the '.' because the FileExtensions property expects extensions withouth a dot.
                string extension = GetExtensionThunk(virtualPath).TrimStart('.');
                return FileExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);
            }
        }

        private static List<ViewLocation> GetViewLocations(string[] viewLocationFormats, string[] areaViewLocationFormats)
        {
            List<ViewLocation> allLocations = new List<ViewLocation>();

            if (areaViewLocationFormats != null)
            {
                foreach (string areaViewLocationFormat in areaViewLocationFormats)
                {
                    allLocations.Add(new AreaAwareViewLocation(areaViewLocationFormat));
                }
            }

            if (viewLocationFormats != null)
            {
                foreach (string viewLocationFormat in viewLocationFormats)
                {
                    allLocations.Add(new ViewLocation(viewLocationFormat));
                }
            }

            return allLocations;
        }

        private static bool IsSpecificPath(string name)
        {
            char c = name[0];
            return (c == '~' || c == '/');
        }

        public virtual void ReleaseView(ControllerContext controllerContext, IView view)
        {
            IDisposable disposable = view as IDisposable;
            if (disposable != null)
            {
                disposable.Dispose();
            }
        }

        private class AreaAwareViewLocation : ViewLocation
        {
            public AreaAwareViewLocation(string virtualPathFormatString)
                : base(virtualPathFormatString)
            {
            }

            public override string Format(string viewName, string controllerName, string areaName)
            {
                return String.Format(CultureInfo.InvariantCulture, _virtualPathFormatString, viewName, controllerName, areaName);
            }
        }

        private class ViewLocation
        {
            protected string _virtualPathFormatString;

            public ViewLocation(string virtualPathFormatString)
            {
                _virtualPathFormatString = virtualPathFormatString;
            }

            public virtual string Format(string viewName, string controllerName, string areaName)
            {
                return String.Format(CultureInfo.InvariantCulture, _virtualPathFormatString, viewName, controllerName);
            }
        }
    }
}


================================================
FILE: src/System.Web.Mvc/WebFormView.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;
using System.Web.Mvc.Properties;

namespace System.Web.Mvc
{
    public class WebFormView : BuildManagerCompiledView
    {
        public WebFormView(ControllerContext controllerContext, string viewPath)
            : this(controllerContext, viewPath, null, null)
        {
        }

        public WebFormView(ControllerContext controllerContext, string viewPath, string masterPath)
            : this(controllerContext, viewPath, masterPath, null)
        {
        }

        public WebFormView(ControllerContext controllerContext, string viewPath, string masterPath, IViewPageActivator viewPageActivator)
            : base(controllerContext, viewPath, viewPageActivator)
        {
            MasterPath = masterPath ?? String.Empty;
        }

        public string MasterPath { get; private set; }

        protected override void RenderView(ViewContext viewContext, TextWriter writer, object instance)
        {
            ViewPage viewPage = instance as ViewPage;
            if (viewPage != null)
            {
                RenderViewPage(viewContext, viewPage);
                return;
            }

            ViewUserControl viewUserControl = instance as ViewUserControl;
            if (viewUserControl != null)
            {
                RenderViewUserControl(viewContext, viewUserControl);
                return;
            }

            throw new InvalidOperationException(
                String.Format(
                    CultureInfo.CurrentCulture,
                    MvcResources.WebFormViewEngine_WrongViewBase,
                    ViewPath));
        }

        private void RenderViewPage(ViewContext context, ViewPage page)
        {
            if (!String.IsNullOrEmpty(MasterPath))
            {
                page.MasterLocation = MasterPath;
            }

            page.ViewData = context.ViewData;
            page.RenderView(context);
        }

        private void RenderViewUserControl(ViewContext context, ViewUserControl control)
        {
            if (!String.IsNullOrEmpty(MasterPath))
            {
                throw new InvalidOperationException(MvcResources.WebFormViewEngine_UserControlCannotHaveMaster);
            }

            control.ViewData = context.ViewData;
            control.RenderView(context);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/WebFormViewEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class WebFormViewEngine : BuildManagerViewEngine
    {
        public WebFormViewEngine()
            : this(null)
        {
        }

        public WebFormViewEngine(IViewPageActivator viewPageActivator)
            : base(viewPageActivator)
        {
            MasterLocationFormats = new[]
            {
                "~/Views/{1}/{0}.master",
                "~/Views/Shared/{0}.master"
            };

            AreaMasterLocationFormats = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.master",
                "~/Areas/{2}/Views/Shared/{0}.master",
            };

            ViewLocationFormats = new[]
            {
                "~/Views/{1}/{0}.aspx",
                "~/Views/{1}/{0}.ascx",
                "~/Views/Shared/{0}.aspx",
                "~/Views/Shared/{0}.ascx"
            };

            AreaViewLocationFormats = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.aspx",
                "~/Areas/{2}/Views/{1}/{0}.ascx",
                "~/Areas/{2}/Views/Shared/{0}.aspx",
                "~/Areas/{2}/Views/Shared/{0}.ascx",
            };

            PartialViewLocationFormats = ViewLocationFormats;
            AreaPartialViewLocationFormats = AreaViewLocationFormats;

            FileExtensions = new[]
            {
                "aspx",
                "ascx",
                "master",
            };
        }

        protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
        {
            return new WebFormView(controllerContext, partialPath, null, ViewPageActivator);
        }

        protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
        {
            return new WebFormView(controllerContext, viewPath, masterPath, ViewPageActivator);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/WebViewPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Web.Mvc.Properties;
using System.Web.WebPages;

namespace System.Web.Mvc
{
    public abstract class WebViewPage : WebPageBase, IViewDataContainer, IViewStartPageChild
    {
        private ViewDataDictionary _viewData;
        private DynamicViewDataDictionary _dynamicViewData;
        private HttpContextBase _context;
        private HtmlHelper<object> _html;
        private AjaxHelper<object> _ajax;

        public override HttpContextBase Context
        {
            // REVIEW why are we forced to override this?
            get { return _context ?? ViewContext.HttpContext; }
            set { _context = value; }
        }

        public HtmlHelper<object> Html
        {
            get
            {
                if (_html == null && ViewContext != null)
                {
                    _html = new HtmlHelper<object>(ViewContext, this);
                }
                return _html;
            }
            set
            {
                _html = value;
            }
        }

        public AjaxHelper<object> Ajax
        {
            get
            {
                if (_ajax == null && ViewContext != null)
                {
                    _ajax = new AjaxHelper<object>(ViewContext, this);
                }
                return _ajax;
            }
            set
            {
                _ajax = value;
            }
        }

        public object Model
        {
            get { return ViewData.Model; }
        }

        internal string OverridenLayoutPath { get; set; }

        public TempDataDictionary TempData
        {
            get { return ViewContext.TempData; }
        }

        public UrlHelper Url { get; set; }

        public dynamic ViewBag
        {
            get
            {
                if (_dynamicViewData == null)
                {
                    _dynamicViewData = new DynamicViewDataDictionary(() => ViewData);
                }
                return _dynamicViewData;
            }
        }

        public ViewContext ViewContext { get; set; }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is the mechanism by which the ViewPage gets its ViewDataDictionary object.")]
        public ViewDataDictionary ViewData
        {
            get
            {
                if (_viewData == null)
                {
                    SetViewData(new ViewDataDictionary());
                }
                return _viewData;
            }
            set { SetViewData(value); }
        }

        protected override void ConfigurePage(WebPageBase parentPage)
        {
            var baseViewPage = parentPage as WebViewPage;
            if (baseViewPage == null)
            {
                // TODO : review if this check is even necessary.
                // When this method is called by the framework parentPage should already be an instance of WebViewPage
                // Need to review what happens if this method gets called in Plan9 pointing at an MVC view
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, MvcResources.CshtmlView_WrongViewBase, parentPage.VirtualPath));
            }

            // Set ViewContext and ViewData here so that the layout page inherits ViewData from the main page
            ViewContext = baseViewPage.ViewContext;
            ViewData = baseViewPage.ViewData;
            InitHelpers();
        }

        public override void ExecutePageHierarchy()
        {
            // Change the Writer so that things like Html.BeginForm work correctly
            TextWriter oldWriter = ViewContext.Writer;
            ViewContext.Writer = Output;

            base.ExecutePageHierarchy();

            // Overwrite LayoutPage so that returning a view with a custom master page works.
            if (!String.IsNullOrEmpty(OverridenLayoutPath))
            {
                Layout = OverridenLayoutPath;
            }

            // Restore the old View Context Writer
            ViewContext.Writer = oldWriter;
        }

        public virtual void InitHelpers()
        {
            // Html and Ajax helpers are lazily initialized since they are not directly visible to a Razor page.
            // In order to ensure back-compat, in the event that this instance gets re-used, we'll reset these
            // properties so they get reinitialized the very next time they get accessed.
            Html = null;
            Ajax = null;
            Url = new UrlHelper(ViewContext.RequestContext);
        }

        protected virtual void SetViewData(ViewDataDictionary viewData)
        {
            _viewData = viewData;
        }
    }
}


================================================
FILE: src/System.Web.Mvc/WebViewPageOfTModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Mvc
{
    public abstract class WebViewPage<TModel> : WebViewPage
    {
        private ViewDataDictionary<TModel> _viewData;

        public new AjaxHelper<TModel> Ajax { get; set; }

        public new HtmlHelper<TModel> Html { get; set; }

        public new TModel Model
        {
            get { return ViewData.Model; }
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "This is the mechanism by which the ViewPage gets its ViewDataDictionary object.")]
        public new ViewDataDictionary<TModel> ViewData
        {
            get
            {
                if (_viewData == null)
                {
                    SetViewData(new ViewDataDictionary<TModel>());
                }
                return _viewData;
            }
            set { SetViewData(value); }
        }

        public override void InitHelpers()
        {
            base.InitHelpers();

            Ajax = new AjaxHelper<TModel>(ViewContext, this);
            Html = new HtmlHelper<TModel>(ViewContext, this);
        }

        protected override void SetViewData(ViewDataDictionary viewData)
        {
            _viewData = new ViewDataDictionary<TModel>(viewData);

            base.SetViewData(_viewData);
        }
    }
}


================================================
FILE: src/System.Web.Mvc/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.Razor/CSharpRazorCodeLanguage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using Microsoft.CSharp;

namespace System.Web.Razor
{
    /// <summary>
    /// Defines the C# Code Language for Razor
    /// </summary>
    public class CSharpRazorCodeLanguage : RazorCodeLanguage
    {
        private const string CSharpLanguageName = "csharp";

        /// <summary>
        /// Returns the name of the language: "csharp"
        /// </summary>
        public override string LanguageName
        {
            get { return CSharpLanguageName; }
        }

        /// <summary>
        /// Returns the type of the CodeDOM provider for this language
        /// </summary>
        public override Type CodeDomProviderType
        {
            get { return typeof(CSharpCodeProvider); }
        }

        /// <summary>
        /// Constructs a new instance of the code parser for this language
        /// </summary>
        public override ParserBase CreateCodeParser()
        {
            return new CSharpCodeParser();
        }

        /// <summary>
        /// Constructs a new instance of the code generator for this language with the specified settings
        /// </summary>
        public override RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host)
        {
            return new CSharpRazorCodeGenerator(className, rootNamespaceName, sourceFileName, host);
        }
    }
}


================================================
FILE: src/System.Web.Razor/DocumentParseCompleteEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;

namespace System.Web.Razor
{
    /// <summary>
    /// Arguments for the DocumentParseComplete event in RazorEditorParser
    /// </summary>
    public class DocumentParseCompleteEventArgs : EventArgs
    {
        /// <summary>
        /// Indicates if the tree structure has actually changed since the previous reparse.
        /// </summary>
        public bool TreeStructureChanged { get; set; }

        /// <summary>
        /// The results of the code generation and parsing
        /// </summary>
        public GeneratorResults GeneratorResults { get; set; }

        /// <summary>
        /// The TextChange which triggered the reparse
        /// </summary>
        public TextChange SourceChange { get; set; }
    }
}


================================================
FILE: src/System.Web.Razor/Editor/AutoCompleteEditHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Editor;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Parser.SyntaxTree
{
    public class AutoCompleteEditHandler : SpanEditHandler
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public AutoCompleteEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer)
            : base(tokenizer)
        {
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public AutoCompleteEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer, AcceptedCharacters accepted)
            : base(tokenizer, accepted)
        {
        }

        public bool AutoCompleteAtEndOfSpan { get; set; }
        public string AutoCompleteString { get; set; }

        protected override PartialParseResult CanAcceptChange(Span target, TextChange normalizedChange)
        {
            if (((AutoCompleteAtEndOfSpan && IsAtEndOfSpan(target, normalizedChange)) || IsAtEndOfFirstLine(target, normalizedChange)) &&
                normalizedChange.IsInsert &&
                ParserHelpers.IsNewLine(normalizedChange.NewText) &&
                AutoCompleteString != null)
            {
                return PartialParseResult.Rejected | PartialParseResult.AutoCompleteBlock;
            }
            return PartialParseResult.Rejected;
        }

        public override string ToString()
        {
            return base.ToString() + ",AutoComplete:[" + (AutoCompleteString ?? "<null>") + "]" + (AutoCompleteAtEndOfSpan ? ";AtEnd" : ";AtEOL");
        }

        public override bool Equals(object obj)
        {
            AutoCompleteEditHandler other = obj as AutoCompleteEditHandler;
            return base.Equals(obj) &&
                   other != null &&
                   String.Equals(other.AutoCompleteString, AutoCompleteString, StringComparison.Ordinal) &&
                   AutoCompleteAtEndOfSpan == other.AutoCompleteAtEndOfSpan;
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(base.GetHashCode())
                .Add(AutoCompleteString)
                .CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Editor/BackgroundParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Utils;

namespace System.Web.Razor.Editor
{
    internal class BackgroundParser : IDisposable
    {
        private MainThreadState _main;
        private BackgroundThread _bg;

        public BackgroundParser(RazorEngineHost host, string fileName)
        {
            _main = new MainThreadState(fileName);
            _bg = new BackgroundThread(_main, host, fileName);

            _main.ResultsReady += (sender, args) => OnResultsReady(args);
        }

        /// <summary>
        /// Fired on the main thread.
        /// </summary>
        public event EventHandler<DocumentParseCompleteEventArgs> ResultsReady;

        public bool IsIdle
        {
            get { return _main.IsIdle; }
        }

        public void Start()
        {
            _bg.Start();
        }

        public void Cancel()
        {
            _main.Cancel();
        }

        public void QueueChange(TextChange change)
        {
            _main.QueueChange(change);
        }

        [SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "_main", Justification = "MainThreadState is disposed when the background thread shuts down")]
        public void Dispose()
        {
            _main.Cancel();
        }

        public IDisposable SynchronizeMainThreadState()
        {
            return _main.Lock();
        }

        protected virtual void OnResultsReady(DocumentParseCompleteEventArgs args)
        {
            var handler = ResultsReady;
            if (handler != null)
            {
                handler(this, args);
            }
        }

        internal static bool TreesAreDifferent(Block leftTree, Block rightTree, IEnumerable<TextChange> changes)
        {
            return TreesAreDifferent(leftTree, rightTree, changes, CancellationToken.None);
        }

        internal static bool TreesAreDifferent(Block leftTree, Block rightTree, IEnumerable<TextChange> changes, CancellationToken cancelToken)
        {
            // Apply all the pending changes to the original tree
            // PERF: If this becomes a bottleneck, we can probably do it the other way around,
            //  i.e. visit the tree and find applicable changes for each node.
            foreach (TextChange change in changes)
            {
                cancelToken.ThrowIfCancellationRequested();
                Span changeOwner = leftTree.LocateOwner(change);

                // Apply the change to the tree
                if (changeOwner == null)
                {
                    return true;
                }
                EditResult result = changeOwner.EditHandler.ApplyChange(changeOwner, change, force: true);
                changeOwner.ReplaceWith(result.EditedSpan);
            }

            // Now compare the trees
            bool treesDifferent = !leftTree.EquivalentTo(rightTree);
            return treesDifferent;
        }

        private abstract class ThreadStateBase
        {
#if DEBUG
            private int _id = -1;
#endif
            protected ThreadStateBase()
            {
            }

            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This method is only empty in Release builds. In Debug builds it contains references to instance variables")]
            [Conditional("DEBUG")]
            protected void SetThreadId(int id)
            {
#if DEBUG
                _id = id;
#endif
            }

            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This method is only empty in Release builds. In Debug builds it contains references to instance variables")]
            [Conditional("DEBUG")]
            protected void EnsureOnThread()
            {
#if DEBUG
                Debug.Assert(_id != -1, "SetThreadId was never called!");
                Debug.Assert(Thread.CurrentThread.ManagedThreadId == _id, "Called from an unexpected thread!");
#endif
            }

            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This method is only empty in Release builds. In Debug builds it contains references to instance variables")]
            [Conditional("DEBUG")]
            protected void EnsureNotOnThread()
            {
#if DEBUG
                Debug.Assert(_id != -1, "SetThreadId was never called!");
                Debug.Assert(Thread.CurrentThread.ManagedThreadId != _id, "Called from an unexpected thread!");
#endif
            }
        }

        private class MainThreadState : ThreadStateBase, IDisposable
        {
            private CancellationTokenSource _cancelSource = new CancellationTokenSource();
            private ManualResetEventSlim _hasParcel = new ManualResetEventSlim(false);
            private CancellationTokenSource _currentParcelCancelSource;

            [SuppressMessage("Microsoft.Performance", "CA1823:AvoidUnusedPrivateFields", Justification = "Field is used in debug code and may be used later")]
            private string _fileName;
            private object _stateLock = new object();
            private IList<TextChange> _changes = new List<TextChange>();

            public MainThreadState(string fileName)
            {
                _fileName = fileName;

                SetThreadId(Thread.CurrentThread.ManagedThreadId);
            }

            public event EventHandler<DocumentParseCompleteEventArgs> ResultsReady;

            public CancellationToken CancelToken
            {
                get { return _cancelSource.Token; }
            }

            public bool IsIdle
            {
                get
                {
                    lock (_stateLock)
                    {
                        return _currentParcelCancelSource == null;
                    }
                }
            }

            public void Cancel()
            {
                EnsureOnThread();
                _cancelSource.Cancel();
            }

            public IDisposable Lock()
            {
                Monitor.Enter(_stateLock);
                return new DisposableAction(() => Monitor.Exit(_stateLock));
            }

            public void QueueChange(TextChange change)
            {
                RazorEditorTrace.TraceLine(RazorResources.Trace_QueuingParse, Path.GetFileName(_fileName), change);
                EnsureOnThread();
                lock (_stateLock)
                {
                    // CurrentParcel token source is not null ==> There's a parse underway
                    if (_currentParcelCancelSource != null)
                    {
                        _currentParcelCancelSource.Cancel();
                    }

                    _changes.Add(change);
                    _hasParcel.Set();
                }
            }

            public WorkParcel GetParcel()
            {
                EnsureNotOnThread(); // Only the background thread can get a parcel
                _hasParcel.Wait(_cancelSource.Token);
                _hasParcel.Reset();
                lock (_stateLock)
                {
                    // Create a cancellation source for this parcel
                    _currentParcelCancelSource = new CancellationTokenSource();

                    var changes = _changes;
                    _changes = new List<TextChange>();
                    return new WorkParcel(changes, _currentParcelCancelSource.Token);
                }
            }

            public void ReturnParcel(DocumentParseCompleteEventArgs args)
            {
                lock (_stateLock)
                {
                    // Clear the current parcel cancellation source
                    if (_currentParcelCancelSource != null)
                    {
                        _currentParcelCancelSource.Dispose();
                        _currentParcelCancelSource = null;
                    }

                    // If there are things waiting to be parsed, just don't fire the event because we're already out of date
                    if (_changes.Any())
                    {
                        return;
                    }
                }
                var handler = ResultsReady;
                if (handler != null)
                {
                    handler(this, args);
                }
            }

            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            protected virtual void Dispose(bool disposing)
            {
                if (disposing)
                {
                    if (_currentParcelCancelSource != null)
                    {
                        _currentParcelCancelSource.Dispose();
                        _currentParcelCancelSource = null;
                    }
                    _cancelSource.Dispose();
                    _hasParcel.Dispose();
                }
            }
        }

        private class BackgroundThread : ThreadStateBase
        {
            private MainThreadState _main;
            private Thread _backgroundThread;
            private CancellationToken _shutdownToken;
            private RazorEngineHost _host;
            private string _fileName;
            private Block _currentParseTree;
            private IList<TextChange> _previouslyDiscarded = new List<TextChange>();

            public BackgroundThread(MainThreadState main, RazorEngineHost host, string fileName)
            {
                // Run on MAIN thread!
                _main = main;
                _backgroundThread = new Thread(WorkerLoop);
                _shutdownToken = _main.CancelToken;
                _host = host;
                _fileName = fileName;

                SetThreadId(_backgroundThread.ManagedThreadId);
            }

            // **** ANY THREAD ****
            public void Start()
            {
                _backgroundThread.Start();
            }

            // **** BACKGROUND THREAD ****
            private void WorkerLoop()
            {
                long? elapsedMs = null;
                string fileNameOnly = Path.GetFileName(_fileName);
#if EDITOR_TRACING
                Stopwatch sw = new Stopwatch();
#endif

                try
                {
                    RazorEditorTrace.TraceLine(RazorResources.Trace_BackgroundThreadStart, fileNameOnly);
                    EnsureOnThread();
                    while (!_shutdownToken.IsCancellationRequested)
                    {
                        // Grab the parcel of work to do
                        WorkParcel parcel = _main.GetParcel();
                        if (parcel.Changes.Any())
                        {
                            RazorEditorTrace.TraceLine(RazorResources.Trace_ChangesArrived, fileNameOnly, parcel.Changes.Count);
                            try
                            {
                                DocumentParseCompleteEventArgs args = null;
                                using (var linkedCancel = CancellationTokenSource.CreateLinkedTokenSource(_shutdownToken, parcel.CancelToken))
                                {
                                    if (!linkedCancel.IsCancellationRequested)
                                    {
                                        // Collect ALL changes
#if EDITOR_TRACING
                                        if (_previouslyDiscarded != null && _previouslyDiscarded.Any())
                                        {
                                            RazorEditorTrace.TraceLine(RazorResources.Trace_CollectedDiscardedChanges, fileNameOnly, _previouslyDiscarded.Count);
                                        }
#endif
                                        List<TextChange> allChanges;

                                        if (_previouslyDiscarded != null)
                                        {
                                            allChanges = Enumerable.Concat(_previouslyDiscarded, parcel.Changes).ToList();
                                        }
                                        else
                                        {
                                            allChanges = parcel.Changes.ToList();
                                        }

                                        TextChange finalChange = allChanges.Last();
#if EDITOR_TRACING
                                        sw.Start();
#endif
                                        GeneratorResults results = ParseChange(finalChange.NewBuffer, linkedCancel.Token);
#if EDITOR_TRACING
                                        sw.Stop();
                                        elapsedMs = sw.ElapsedMilliseconds;
                                        sw.Reset();
#endif
                                        RazorEditorTrace.TraceLine(
                                            RazorResources.Trace_ParseComplete,
                                            fileNameOnly,
                                            elapsedMs.HasValue ? elapsedMs.Value.ToString(CultureInfo.InvariantCulture) : "?");

                                        if (results != null && !linkedCancel.IsCancellationRequested)
                                        {
                                            // Clear discarded changes list
                                            _previouslyDiscarded = null;

                                            // Take the current tree and check for differences
#if EDITOR_TRACING
                                            sw.Start();
#endif
                                            bool treeStructureChanged = _currentParseTree == null || TreesAreDifferent(_currentParseTree, results.Document, allChanges, parcel.CancelToken);
#if EDITOR_TRACING
                                            sw.Stop();
                                            elapsedMs = sw.ElapsedMilliseconds;
                                            sw.Reset();
#endif
                                            _currentParseTree = results.Document;
                                            RazorEditorTrace.TraceLine(RazorResources.Trace_TreesCompared,
                                                fileNameOnly,
                                                elapsedMs.HasValue ? elapsedMs.Value.ToString(CultureInfo.InvariantCulture) : "?",
                                                treeStructureChanged);

                                            // Build Arguments
                                            args = new DocumentParseCompleteEventArgs()
                                            {
                                                GeneratorResults = results,
                                                SourceChange = finalChange,
                                                TreeStructureChanged = treeStructureChanged
                                            };
                                        }
                                        else
                                        {
                                            // Parse completed but we were cancelled in the mean time. Add these to the discarded changes set
                                            RazorEditorTrace.TraceLine(RazorResources.Trace_ChangesDiscarded, fileNameOnly, allChanges.Count);
                                            _previouslyDiscarded = allChanges;
                                        }

#if CHECK_TREE
                                            if (args != null)
                                            {
                                                // Rewind the buffer and sanity check the line mappings
                                                finalChange.NewBuffer.Position = 0;
                                                int lineCount = finalChange.NewBuffer.ReadToEnd().Split(new string[] { Environment.NewLine, "\r", "\n" }, StringSplitOptions.None).Count();
                                                Debug.Assert(
                                                    !args.GeneratorResults.DesignTimeLineMappings.Any(pair => pair.Value.StartLine > lineCount),
                                                    "Found a design-time line mapping referring to a line outside the source file!");
                                                Debug.Assert(
                                                    !args.GeneratorResults.Document.Flatten().Any(span => span.Start.LineIndex > lineCount),
                                                    "Found a span with a line number outside the source file");
                                                Debug.Assert(
                                                    !args.GeneratorResults.Document.Flatten().Any(span => span.Start.AbsoluteIndex > parcel.NewBuffer.Length),
                                                    "Found a span with an absolute offset outside the source file");
                                            }
#endif
                                    }
                                }
                                if (args != null)
                                {
                                    _main.ReturnParcel(args);
                                }
                            }
                            catch (OperationCanceledException)
                            {
                            }
                        }
                        else
                        {
                            RazorEditorTrace.TraceLine(RazorResources.Trace_NoChangesArrived, fileNameOnly, parcel.Changes.Count);
                            Thread.Yield();
                        }
                    }
                }
                catch (OperationCanceledException)
                {
                    // Do nothing. Just shut down.
                }
                finally
                {
                    RazorEditorTrace.TraceLine(RazorResources.Trace_BackgroundThreadShutdown, fileNameOnly);

                    // Clean up main thread resources
                    _main.Dispose();
                }
            }

            private GeneratorResults ParseChange(ITextBuffer buffer, CancellationToken token)
            {
                EnsureOnThread();

                // Create a template engine
                RazorTemplateEngine engine = new RazorTemplateEngine(_host);

                // Seek the buffer to the beginning
                buffer.Position = 0;

                try
                {
                    return engine.GenerateCode(
                        input: buffer,
                        className: null,
                        rootNamespace: null,
                        sourceFileName: _fileName,
                        cancelToken: token);
                }
                catch (OperationCanceledException)
                {
                    return null;
                }
            }
        }

        private class WorkParcel
        {
            public WorkParcel(IList<TextChange> changes, CancellationToken cancelToken)
            {
                Changes = changes;
                CancelToken = cancelToken;
            }

            public CancellationToken CancelToken { get; private set; }
            public IList<TextChange> Changes { get; private set; }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Editor/EditResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Editor
{
    public class EditResult
    {
        public EditResult(PartialParseResult result, SpanBuilder editedSpan)
        {
            Result = result;
            EditedSpan = editedSpan;
        }

        public PartialParseResult Result { get; set; }
        public SpanBuilder EditedSpan { get; set; }
    }
}


================================================
FILE: src/System.Web.Razor/Editor/EditorHints.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Editor
{
    /// <summary>
    /// Used within <see cref="F:SpanEditHandler.EditorHints"/>.
    /// </summary>
    [Flags]
    public enum EditorHints
    {
        /// <summary>
        /// The default (Markup or Code) editor behavior for Statement completion should be used.
        /// Editors can always use the default behavior, even if the span is labeled with a different CompletionType.
        /// </summary>
        None = 0, // 0000 0000

        /// <summary>
        /// Indicates that Virtual Path completion should be used for this span if the editor supports it.
        /// Editors need not support this mode of completion, and will use the default (<see cref="F:EditorHints.None"/>) behavior
        /// if they do not support it.
        /// </summary>
        VirtualPath = 1, // 0000 0001

        /// <summary>
        /// Indicates that this span's content contains the path to the layout page for this document.
        /// </summary>
        LayoutPage = 2, // 0000 0010
    }
}


================================================
FILE: src/System.Web.Razor/Editor/ImplicitExpressionEditHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Editor
{
    public class ImplicitExpressionEditHandler : SpanEditHandler
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public ImplicitExpressionEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer, ISet<string> keywords, bool acceptTrailingDot)
            : base(tokenizer)
        {
            Initialize(keywords, acceptTrailingDot);
        }

        public bool AcceptTrailingDot { get; private set; }
        public ISet<string> Keywords { get; private set; }

        public override string ToString()
        {
            return String.Format(CultureInfo.InvariantCulture, "{0};ImplicitExpression[{1}];K{2}", base.ToString(), AcceptTrailingDot ? "ATD" : "RTD", Keywords.Count);
        }

        public override bool Equals(object obj)
        {
            ImplicitExpressionEditHandler other = obj as ImplicitExpressionEditHandler;
            return other != null &&
                   base.Equals(other) &&
                   Keywords.SetEquals(other.Keywords) &&
                   AcceptTrailingDot == other.AcceptTrailingDot;
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(base.GetHashCode())
                .Add(AcceptTrailingDot)
                .Add(Keywords)
                .CombinedHash;
        }

        protected override PartialParseResult CanAcceptChange(Span target, TextChange normalizedChange)
        {
            if (AcceptedCharacters == AcceptedCharacters.Any)
            {
                return PartialParseResult.Rejected;
            }

            // In some editors intellisense insertions are handled as "dotless commits".  If an intellisense selection is confirmed 
            // via something like '.' a dotless commit will append a '.' and then insert the remaining intellisense selection prior 
            // to the appended '.'.  This 'if' statement attempts to accept the intermediate steps of a dotless commit via 
            // intellisense.  It will accept two cases:
            //     1. '@foo.' -> '@foobaz.'.
            //     2. '@foobaz..' -> '@foobaz.bar.'. Includes Sub-cases '@foobaz()..' -> '@foobaz().bar.' etc.
            // The key distinction being the double '.' in the second case.
            if (IsDotlessCommitInsertion(target, normalizedChange))
            {
                return HandleDotlessCommitInsertion(target);
            }

            if (IsAcceptableIdentifierReplacement(target, normalizedChange))
            {
                return TryAcceptChange(target, normalizedChange);
            }

            if (IsAcceptableReplace(target, normalizedChange))
            {
                return HandleReplacement(target, normalizedChange);
            }
            int changeRelativePosition = normalizedChange.OldPosition - target.Start.AbsoluteIndex;

            // Get the edit context
            char? lastChar = null;
            if (changeRelativePosition > 0 && target.Content.Length > 0)
            {
                lastChar = target.Content[changeRelativePosition - 1];
            }

            // Don't support 0->1 length edits
            if (lastChar == null)
            {
                return PartialParseResult.Rejected;
            }

            // Accepts cases when insertions are made at the end of a span or '.' is inserted within a span.
            if (IsAcceptableInsertion(target, normalizedChange))
            {
                // Handle the insertion
                return HandleInsertion(target, lastChar.Value, normalizedChange);
            }

            if (IsAcceptableDeletion(target, normalizedChange))
            {
                return HandleDeletion(target, lastChar.Value, normalizedChange);
            }

            return PartialParseResult.Rejected;
        }

        private void Initialize(ISet<string> keywords, bool acceptTrailingDot)
        {
            Keywords = keywords ?? new HashSet<string>();
            AcceptTrailingDot = acceptTrailingDot;
        }

        // A dotless commit is the process of inserting a '.' with an intellisense selection.
        private static bool IsDotlessCommitInsertion(Span target, TextChange change)
        {
            return IsNewDotlessCommitInsertion(target, change) || IsSecondaryDotlessCommitInsertion(target, change);
        }

        // Completing 'DateTime' in intellisense with a '.' could result in: '@DateT' -> '@DateT.' -> '@DateTime.' which is accepted.
        private static bool IsNewDotlessCommitInsertion(Span target, TextChange change)
        {
            return !IsAtEndOfSpan(target, change) &&
                   change.NewPosition > 0 &&
                   change.NewLength > 0 &&
                   target.Content.Last() == '.' &&
                   ParserHelpers.IsIdentifier(change.NewText, requireIdentifierStart: false) &&
                   (change.OldLength == 0 || ParserHelpers.IsIdentifier(change.OldText, requireIdentifierStart: false));
        }

        // Once a dotless commit has been performed you then have something like '@DateTime.'.  This scenario is used to detect the
        // situation when you try to perform another dotless commit resulting in a textchange with '..'.  Completing 'DateTime.Now' 
        // in intellisense with a '.' could result in: '@DateTime.' -> '@DateTime..' -> '@DateTime.Now.' which is accepted.
        private static bool IsSecondaryDotlessCommitInsertion(Span target, TextChange change)
        {
            // Do not need to worry about other punctuation, just looking for double '.' (after change)
            return change.NewLength == 1 &&
                   !String.IsNullOrEmpty(target.Content) &&
                   target.Content.Last() == '.' &&
                   change.NewText == "." &&
                   change.OldLength == 0;
        }

        private bool IsAcceptableIdentifierReplacement(Span target, TextChange change)
        {
            if (!change.IsReplace)
            {
                return false;
            }

            foreach (ISymbol isymbol in target.Symbols)
            {
                CSharpSymbol symbol = isymbol as CSharpSymbol;

                if (symbol == null)
                {
                    break;
                }

                int symbolStartIndex = target.Start.AbsoluteIndex + symbol.Start.AbsoluteIndex;
                int symbolEndIndex = symbolStartIndex + symbol.Content.Length;

                // We're looking for the first symbol that contains the TextChange.
                if (symbolEndIndex > change.OldPosition)
                {
                    if (symbolEndIndex >= change.OldPosition + change.OldLength && symbol.Type == CSharpSymbolType.Identifier)
                    {
                        // The symbol we're changing happens to be an identifier. Need to check if its transformed state is also one.
                        // We do this transformation logic to capture the case that the new text change happens to not be an identifier;
                        // i.e. "5". Alone, it's numeric, within an identifier it's classified as identifier.
                        string transformedContent = change.ApplyChange(symbol.Content, symbolStartIndex);
                        IEnumerable<ISymbol> newSymbols = Tokenizer(transformedContent);

                        if (newSymbols.Count() != 1)
                        {
                            // The transformed content resulted in more than one symbol; we can only replace a single identifier with
                            // another single identifier.
                            break;
                        }

                        CSharpSymbol newSymbol = (CSharpSymbol)newSymbols.First();
                        if (newSymbol.Type == CSharpSymbolType.Identifier)
                        {
                            return true;
                        }
                    }

                    // Change is touching a non-identifier symbol or spans multiple symbols.

                    break;
                }
            }

            return false;
        }

        private static bool IsAcceptableReplace(Span target, TextChange change)
        {
            return IsEndReplace(target, change) ||
                   (change.IsReplace && RemainingIsWhitespace(target, change));
        }

        private static bool IsAcceptableDeletion(Span target, TextChange change)
        {
            return IsEndDeletion(target, change) ||
                   (change.IsDelete && RemainingIsWhitespace(target, change));
        }

        // Acceptable insertions can occur at the end of a span or when a '.' is inserted within a span.
        private static bool IsAcceptableInsertion(Span target, TextChange change)
        {
            return change.IsInsert &&
                   (IsAcceptableEndInsertion(target, change) ||
                   IsAcceptableInnerInsertion(target, change));
        }

        // Accepts character insertions at the end of spans.  AKA: '@foo' -> '@fooo' or '@foo' -> '@foo   ' etc.
        private static bool IsAcceptableEndInsertion(Span target, TextChange change)
        {
            Debug.Assert(change.IsInsert);

            return IsAtEndOfSpan(target, change) ||
                   RemainingIsWhitespace(target, change);
        }

        // Accepts '.' insertions in the middle of spans. Ex: '@foo.baz.bar' -> '@foo..baz.bar'
        // This is meant to allow intellisense when editing a span.
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "target", Justification = "The 'target' parameter is used in Debug to validate that the function is called in the correct context.")]
        private static bool IsAcceptableInnerInsertion(Span target, TextChange change)
        {
            Debug.Assert(change.IsInsert);

            // Ensure that we're actually inserting in the middle of a span and not at the end.
            // This case will fail if the IsAcceptableEndInsertion does not capture an end insertion correctly.
            Debug.Assert(!IsAtEndOfSpan(target, change));

            return change.NewPosition > 0 &&
                   change.NewText == ".";
        }

        private static bool RemainingIsWhitespace(Span target, TextChange change)
        {
            int offset = (change.OldPosition - target.Start.AbsoluteIndex) + change.OldLength;
            return String.IsNullOrWhiteSpace(target.Content.Substring(offset));
        }

        private PartialParseResult HandleDotlessCommitInsertion(Span target)
        {
            PartialParseResult result = PartialParseResult.Accepted;
            if (!AcceptTrailingDot && target.Content.LastOrDefault() == '.')
            {
                result |= PartialParseResult.Provisional;
            }
            return result;
        }

        private PartialParseResult HandleReplacement(Span target, TextChange change)
        {
            // Special Case for IntelliSense commits.
            //  When IntelliSense commits, we get two changes (for example user typed "Date", then committed "DateTime" by pressing ".")
            //  1. Insert "." at the end of this span
            //  2. Replace the "Date." at the end of the span with "DateTime."
            //  We need partial parsing to accept case #2.
            string oldText = GetOldText(target, change);

            PartialParseResult result = PartialParseResult.Rejected;
            if (EndsWithDot(oldText) && EndsWithDot(change.NewText))
            {
                result = PartialParseResult.Accepted;
                if (!AcceptTrailingDot)
                {
                    result |= PartialParseResult.Provisional;
                }
            }
            return result;
        }

        private PartialParseResult HandleDeletion(Span target, char previousChar, TextChange change)
        {
            // What's left after deleting?
            if (previousChar == '.')
            {
                return TryAcceptChange(target, change, PartialParseResult.Accepted | PartialParseResult.Provisional);
            }
            else if (ParserHelpers.IsIdentifierPart(previousChar))
            {
                return TryAcceptChange(target, change);
            }
            else
            {
                return PartialParseResult.Rejected;
            }
        }

        private PartialParseResult HandleInsertion(Span target, char previousChar, TextChange change)
        {
            // What are we inserting after?
            if (previousChar == '.')
            {
                return HandleInsertionAfterDot(target, change);
            }
            else if (ParserHelpers.IsIdentifierPart(previousChar) || previousChar == ')' || previousChar == ']')
            {
                return HandleInsertionAfterIdPart(target, change);
            }
            else
            {
                return PartialParseResult.Rejected;
            }
        }

        private PartialParseResult HandleInsertionAfterIdPart(Span target, TextChange change)
        {
            // If the insertion is a full identifier part, accept it
            if (ParserHelpers.IsIdentifier(change.NewText, requireIdentifierStart: false))
            {
                return TryAcceptChange(target, change);
            }
            else if (EndsWithDot(change.NewText))
            {
                // Accept it, possibly provisionally
                PartialParseResult result = PartialParseResult.Accepted;
                if (!AcceptTrailingDot)
                {
                    result |= PartialParseResult.Provisional;
                }
                return TryAcceptChange(target, change, result);
            }
            else
            {
                return PartialParseResult.Rejected;
            }
        }

        private static bool EndsWithDot(string content)
        {
            return (content.Length == 1 && content[0] == '.') ||
                   (content[content.Length - 1] == '.' &&
                    content.Take(content.Length - 1).All(ParserHelpers.IsIdentifierPart));
        }

        private PartialParseResult HandleInsertionAfterDot(Span target, TextChange change)
        {
            // If the insertion is a full identifier or another dot, accept it
            if (ParserHelpers.IsIdentifier(change.NewText) || change.NewText == ".")
            {
                return TryAcceptChange(target, change);
            }
            return PartialParseResult.Rejected;
        }

        private PartialParseResult TryAcceptChange(Span target, TextChange change, PartialParseResult acceptResult = PartialParseResult.Accepted)
        {
            string content = change.ApplyChange(target);
            if (StartsWithKeyword(content))
            {
                return PartialParseResult.Rejected | PartialParseResult.SpanContextChanged;
            }

            return acceptResult;
        }

        private bool StartsWithKeyword(string newContent)
        {
            using (StringReader reader = new StringReader(newContent))
            {
                return Keywords.Contains(reader.ReadWhile(ParserHelpers.IsIdentifierPart));
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Editor/RazorEditorTrace.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;

namespace System.Web.Razor.Editor
{
    internal static class RazorEditorTrace
    {
        private static bool? _enabled;

        private static bool IsEnabled()
        {
            if (_enabled == null)
            {
                bool enabled;
                if (Boolean.TryParse(Environment.GetEnvironmentVariable("RAZOR_EDITOR_TRACE"), out enabled))
                {
                    Trace.WriteLine(String.Format(
                        CultureInfo.CurrentCulture,
                        RazorResources.Trace_Startup,
                        enabled ? RazorResources.Trace_Enabled : RazorResources.Trace_Disabled));
                    _enabled = enabled;
                }
                else
                {
                    _enabled = false;
                }
            }
            return _enabled.Value;
        }

        [Conditional("EDITOR_TRACING")]
        public static void TraceLine(string format, params object[] args)
        {
            if (IsEnabled())
            {
                Trace.WriteLine(String.Format(
                    CultureInfo.CurrentCulture,
                    RazorResources.Trace_Format,
                    String.Format(CultureInfo.CurrentCulture, format, args)));
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Editor/SingleLineMarkupEditHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Editor
{
    public class SingleLineMarkupEditHandler : SpanEditHandler
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public SingleLineMarkupEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer)
            : base(tokenizer)
        {
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public SingleLineMarkupEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer, AcceptedCharacters accepted)
            : base(tokenizer, accepted)
        {
        }
    }
}


================================================
FILE: src/System.Web.Razor/Editor/SpanEditHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Editor
{
    // Manages edits to a span
    public class SpanEditHandler
    {
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public SpanEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer)
            : this(tokenizer, AcceptedCharacters.Any)
        {
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public SpanEditHandler(Func<string, IEnumerable<ISymbol>> tokenizer, AcceptedCharacters accepted)
        {
            AcceptedCharacters = accepted;
            Tokenizer = tokenizer;
        }

        public AcceptedCharacters AcceptedCharacters { get; set; }

        /// <summary>
        /// Provides a set of hints to editors which may be manipulating the document in which this span is located.
        /// </summary>
        public EditorHints EditorHints { get; set; }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public Func<string, IEnumerable<ISymbol>> Tokenizer { get; set; }

        public static SpanEditHandler CreateDefault()
        {
            return CreateDefault(s => Enumerable.Empty<ISymbol>());
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended delegate type and requires this level of nesting.")]
        public static SpanEditHandler CreateDefault(Func<string, IEnumerable<ISymbol>> tokenizer)
        {
            return new SpanEditHandler(tokenizer);
        }

        public virtual EditResult ApplyChange(Span target, TextChange change)
        {
            return ApplyChange(target, change, force: false);
        }

        public virtual EditResult ApplyChange(Span target, TextChange change, bool force)
        {
            PartialParseResult result = PartialParseResult.Accepted;
            TextChange normalized = change.Normalize();
            if (!force)
            {
                result = CanAcceptChange(target, normalized);
            }

            // If the change is accepted then apply the change
            if (result.HasFlag(PartialParseResult.Accepted))
            {
                return new EditResult(result, UpdateSpan(target, normalized));
            }
            return new EditResult(result, new SpanBuilder(target));
        }

        public virtual bool OwnsChange(Span target, TextChange change)
        {
            int end = target.Start.AbsoluteIndex + target.Length;
            int changeOldEnd = change.OldPosition + change.OldLength;
            return change.OldPosition >= target.Start.AbsoluteIndex &&
                   (changeOldEnd < end || (changeOldEnd == end && AcceptedCharacters != AcceptedCharacters.None));
        }

        protected virtual PartialParseResult CanAcceptChange(Span target, TextChange normalizedChange)
        {
            return PartialParseResult.Rejected;
        }

        protected virtual SpanBuilder UpdateSpan(Span target, TextChange normalizedChange)
        {
            string newContent = normalizedChange.ApplyChange(target);
            SpanBuilder newSpan = new SpanBuilder(target);
            newSpan.ClearSymbols();
            foreach (ISymbol sym in Tokenizer(newContent))
            {
                sym.OffsetStart(target.Start);
                newSpan.Accept(sym);
            }
            if (target.Next != null)
            {
                SourceLocation newEnd = SourceLocationTracker.CalculateNewLocation(target.Start, newContent);
                target.Next.ChangeStart(newEnd);
            }
            return newSpan;
        }

        protected internal static bool IsAtEndOfFirstLine(Span target, TextChange change)
        {
            int endOfFirstLine = target.Content.IndexOfAny(new char[] { (char)0x000d, (char)0x000a, (char)0x2028, (char)0x2029 });
            return (endOfFirstLine == -1 || (change.OldPosition - target.Start.AbsoluteIndex) <= endOfFirstLine);
        }

        /// <summary>
        /// Returns true if the specified change is an insertion of text at the end of this span.
        /// </summary>
        protected internal static bool IsEndInsertion(Span target, TextChange change)
        {
            return change.IsInsert && IsAtEndOfSpan(target, change);
        }

        /// <summary>
        /// Returns true if the specified change is an insertion of text at the end of this span.
        /// </summary>
        protected internal static bool IsEndDeletion(Span target, TextChange change)
        {
            return change.IsDelete && IsAtEndOfSpan(target, change);
        }

        /// <summary>
        /// Returns true if the specified change is a replacement of text at the end of this span.
        /// </summary>
        protected internal static bool IsEndReplace(Span target, TextChange change)
        {
            return change.IsReplace && IsAtEndOfSpan(target, change);
        }

        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "This method should only be used on Spans")]
        protected internal static bool IsAtEndOfSpan(Span target, TextChange change)
        {
            return (change.OldPosition + change.OldLength) == (target.Start.AbsoluteIndex + target.Length);
        }

        /// <summary>
        /// Returns the old text referenced by the change.
        /// </summary>
        /// <remarks>
        /// If the content has already been updated by applying the change, this data will be _invalid_
        /// </remarks>
        protected internal static string GetOldText(Span target, TextChange change)
        {
            return target.Content.Substring(change.OldPosition - target.Start.AbsoluteIndex, change.OldLength);
        }

        // Is the specified span to the right of this span and immediately adjacent?
        internal static bool IsAdjacentOnRight(Span target, Span other)
        {
            return target.Start.AbsoluteIndex < other.Start.AbsoluteIndex && target.Start.AbsoluteIndex + target.Length == other.Start.AbsoluteIndex;
        }

        // Is the specified span to the left of this span and immediately adjacent?
        internal static bool IsAdjacentOnLeft(Span target, Span other)
        {
            return other.Start.AbsoluteIndex < target.Start.AbsoluteIndex && other.Start.AbsoluteIndex + other.Length == target.Start.AbsoluteIndex;
        }

        public override string ToString()
        {
            return GetType().Name + ";Accepts:" + AcceptedCharacters + ((EditorHints == EditorHints.None) ? String.Empty : (";Hints: " + EditorHints.ToString()));
        }

        public override bool Equals(object obj)
        {
            SpanEditHandler other = obj as SpanEditHandler;
            return other != null &&
                   AcceptedCharacters == other.AcceptedCharacters &&
                   EditorHints == other.EditorHints;
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(AcceptedCharacters)
                .Add(EditorHints)
                .CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/AddImportCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class AddImportCodeGenerator : SpanCodeGenerator
    {
        public AddImportCodeGenerator(string ns, int namespaceKeywordLength)
        {
            Namespace = ns;
            NamespaceKeywordLength = namespaceKeywordLength;
        }

        public string Namespace { get; private set; }
        public int NamespaceKeywordLength { get; set; }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            // Try to find the namespace in the existing imports
            string ns = Namespace;
            if (!String.IsNullOrEmpty(ns) && Char.IsWhiteSpace(ns[0]))
            {
                ns = ns.Substring(1);
            }

            CodeNamespaceImport import = context.Namespace
                .Imports
                .OfType<CodeNamespaceImport>()
                .Where(i => String.Equals(i.Namespace, ns.Trim(), StringComparison.Ordinal))
                .FirstOrDefault();

            if (import == null)
            {
                // It doesn't exist, create it
                import = new CodeNamespaceImport(ns);
                context.Namespace.Imports.Add(import);
            }

            // Attach our info to the existing/new import.
            import.LinePragma = context.GenerateLinePragma(target);
        }

        public override string ToString()
        {
            return "Import:" + Namespace + ";KwdLen:" + NamespaceKeywordLength;
        }

        public override bool Equals(object obj)
        {
            AddImportCodeGenerator other = obj as AddImportCodeGenerator;
            return other != null &&
                   String.Equals(Namespace, other.Namespace, StringComparison.Ordinal) &&
                   NamespaceKeywordLength == other.NamespaceKeywordLength;
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Namespace)
                .Add(NamespaceKeywordLength)
                .CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/AttributeBlockCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class AttributeBlockCodeGenerator : BlockCodeGenerator
    {
        public AttributeBlockCodeGenerator(string name, LocationTagged<string> prefix, LocationTagged<string> suffix)
        {
            Name = name;
            Prefix = prefix;
            Suffix = suffix;
        }

        public string Name { get; private set; }
        public LocationTagged<string> Prefix { get; private set; }
        public LocationTagged<string> Suffix { get; private set; }

        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            if (context.Host.DesignTimeMode)
            {
                return; // Don't generate anything!
            }
            context.FlushBufferedStatement();
            context.AddStatement(context.BuildCodeString(cw =>
            {
                if (!String.IsNullOrEmpty(context.TargetWriterName))
                {
                    cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeToMethodName);
                    cw.WriteSnippet(context.TargetWriterName);
                    cw.WriteParameterSeparator();
                }
                else
                {
                    cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteAttributeMethodName);
                }
                cw.WriteStringLiteral(Name);
                cw.WriteParameterSeparator();
                cw.WriteLocationTaggedString(Prefix);
                cw.WriteParameterSeparator();
                cw.WriteLocationTaggedString(Suffix);

                // In VB, we need a line continuation
                cw.WriteLineContinuation();
            }));
        }

        public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
            if (context.Host.DesignTimeMode)
            {
                return; // Don't generate anything!
            }
            context.FlushBufferedStatement();
            context.AddStatement(context.BuildCodeString(cw =>
            {
                cw.WriteEndMethodInvoke();
                cw.WriteEndStatement();
            }));
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "Attr:{0},{1:F},{2:F}", Name, Prefix, Suffix);
        }

        public override bool Equals(object obj)
        {
            AttributeBlockCodeGenerator other = obj as AttributeBlockCodeGenerator;
            return other != null &&
                   String.Equals(other.Name, Name, StringComparison.Ordinal) &&
                   Equals(other.Prefix, Prefix) &&
                   Equals(other.Suffix, Suffix);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Name)
                .Add(Prefix)
                .Add(Suffix)
                .CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/BaseCodeWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Generator
{
    internal abstract class BaseCodeWriter : CodeWriter
    {
        public override void WriteSnippet(string snippet)
        {
            InnerWriter.Write(snippet);
        }

        protected internal override void EmitStartMethodInvoke(string methodName)
        {
            EmitStartMethodInvoke(methodName, new string[0]);
        }

        protected internal override void EmitStartMethodInvoke(string methodName, params string[] genericArguments)
        {
            InnerWriter.Write(methodName);
            if (genericArguments != null && genericArguments.Length > 0)
            {
                WriteStartGenerics();
                for (int i = 0; i < genericArguments.Length; i++)
                {
                    if (i > 0)
                    {
                        WriteParameterSeparator();
                    }
                    WriteSnippet(genericArguments[i]);
                }
                WriteEndGenerics();
            }

            InnerWriter.Write("(");
        }

        protected internal override void EmitEndMethodInvoke()
        {
            InnerWriter.Write(")");
        }

        protected internal override void EmitEndConstructor()
        {
            InnerWriter.Write(")");
        }

        protected internal override void EmitEndLambdaExpression()
        {
        }

        public override void WriteParameterSeparator()
        {
            InnerWriter.Write(", ");
        }

        protected internal void WriteCommaSeparatedList<T>(T[] items, Action<T> writeItemAction)
        {
            for (int i = 0; i < items.Length; i++)
            {
                if (i > 0)
                {
                    InnerWriter.Write(", ");
                }
                writeItemAction(items[i]);
            }
        }

        protected internal virtual void WriteStartGenerics()
        {
        }

        protected internal virtual void WriteEndGenerics()
        {
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/BlockCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public abstract class BlockCodeGenerator : IBlockCodeGenerator
    {
        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes", Justification = "This class has no instance state")]
        public static readonly IBlockCodeGenerator Null = new NullBlockCodeGenerator();

        public virtual void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
        }

        public virtual void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
        }

        public override bool Equals(object obj)
        {
            return (obj as IBlockCodeGenerator) != null;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        private class NullBlockCodeGenerator : IBlockCodeGenerator
        {
            public void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
            {
            }

            public void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
            {
            }

            public override string ToString()
            {
                return "None";
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/CSharpCodeWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;

namespace System.Web.Razor.Generator
{
    internal class CSharpCodeWriter : BaseCodeWriter
    {
        protected internal override void WriteStartGenerics()
        {
            InnerWriter.Write("<");
        }

        protected internal override void WriteEndGenerics()
        {
            InnerWriter.Write(">");
        }

        public override int WriteVariableDeclaration(string type, string name, string value)
        {
            InnerWriter.Write(type);
            InnerWriter.Write(" ");
            InnerWriter.Write(name);
            if (!String.IsNullOrEmpty(value))
            {
                InnerWriter.Write(" = ");
                InnerWriter.Write(value);
            }
            else
            {
                InnerWriter.Write(" = null");
            }
            return 0;
        }

        public override void WriteDisableUnusedFieldWarningPragma()
        {
            InnerWriter.Write("#pragma warning disable 219");
        }

        public override void WriteRestoreUnusedFieldWarningPragma()
        {
            InnerWriter.Write("#pragma warning restore 219");
        }

        public override void WriteStringLiteral(string literal)
        {
            if (literal == null)
            {
                throw new ArgumentNullException("literal");
            }

            // From CSharpCodeProvider in CodeDOM
            //  If the string is short, use C style quoting (e.g "\r\n")
            //  Also do it if it is too long to fit in one line
            //  If the string contains '\0', verbatim style won't work.
            if (literal.Length >= 256 && literal.Length <= 1500 && literal.IndexOf('\0') == -1)
            {
                WriteVerbatimStringLiteral(literal);
            }
            else
            {
                WriteCStyleStringLiteral(literal);
            }
        }

        private void WriteVerbatimStringLiteral(string literal)
        {
            // From CSharpCodeGenerator.QuoteSnippetStringVerbatim in CodeDOM
            InnerWriter.Write("@\"");
            for (int i = 0; i < literal.Length; i++)
            {
                if (literal[i] == '\"')
                {
                    InnerWriter.Write("\"\"");
                }
                else
                {
                    InnerWriter.Write(literal[i]);
                }
            }
            InnerWriter.Write("\"");
        }

        private void WriteCStyleStringLiteral(string literal)
        {
            // From CSharpCodeGenerator.QuoteSnippetStringCStyle in CodeDOM
            InnerWriter.Write("\"");
            for (int i = 0; i < literal.Length; i++)
            {
                switch (literal[i])
                {
                    case '\r':
                        InnerWriter.Write("\\r");
                        break;
                    case '\t':
                        InnerWriter.Write("\\t");
                        break;
                    case '\"':
                        InnerWriter.Write("\\\"");
                        break;
                    case '\'':
                        InnerWriter.Write("\\\'");
                        break;
                    case '\\':
                        InnerWriter.Write("\\\\");
                        break;
                    case '\0':
                        InnerWriter.Write("\\\0");
                        break;
                    case '\n':
                        InnerWriter.Write("\\n");
                        break;
                    case '\u2028':
                    case '\u2029':
                        // Inlined CSharpCodeGenerator.AppendEscapedChar
                        InnerWriter.Write("\\u");
                        InnerWriter.Write(((int)literal[i]).ToString("X4", CultureInfo.InvariantCulture));
                        break;
                    default:
                        InnerWriter.Write(literal[i]);
                        break;
                }
                if (i > 0 && i % 80 == 0)
                {
                    // If current character is a high surrogate and the following 
                    // character is a low surrogate, don't break them. 
                    // Otherwise when we write the string to a file, we might lose 
                    // the characters.
                    if (Char.IsHighSurrogate(literal[i])
                        && (i < literal.Length - 1)
                        && Char.IsLowSurrogate(literal[i + 1]))
                    {
                        InnerWriter.Write(literal[++i]);
                    }

                    InnerWriter.Write("\" +");
                    InnerWriter.Write(Environment.NewLine);
                    InnerWriter.Write('\"');
                }
            }
            InnerWriter.Write("\"");
        }

        public override void WriteEndStatement()
        {
            InnerWriter.WriteLine(";");
        }

        public override void WriteIdentifier(string identifier)
        {
            InnerWriter.Write("@" + identifier);
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Lowercase is intended here. C# boolean literals are all lowercase")]
        public override void WriteBooleanLiteral(bool value)
        {
            WriteSnippet(value.ToString().ToLowerInvariant());
        }

        protected internal override void EmitStartLambdaExpression(string[] parameterNames)
        {
            if (parameterNames == null)
            {
                throw new ArgumentNullException("parameterNames");
            }

            if (parameterNames.Length == 0 || parameterNames.Length > 1)
            {
                InnerWriter.Write("(");
            }
            WriteCommaSeparatedList(parameterNames, InnerWriter.Write);
            if (parameterNames.Length == 0 || parameterNames.Length > 1)
            {
                InnerWriter.Write(")");
            }
            InnerWriter.Write(" => ");
        }

        protected internal override void EmitStartLambdaDelegate(string[] parameterNames)
        {
            if (parameterNames == null)
            {
                throw new ArgumentNullException("parameterNames");
            }

            EmitStartLambdaExpression(parameterNames);
            InnerWriter.WriteLine("{");
        }

        protected internal override void EmitEndLambdaDelegate()
        {
            InnerWriter.Write("}");
        }

        protected internal override void EmitStartConstructor(string typeName)
        {
            if (typeName == null)
            {
                throw new ArgumentNullException("typeName");
            }

            InnerWriter.Write("new ");
            InnerWriter.Write(typeName);
            InnerWriter.Write("(");
        }

        public override void WriteReturn()
        {
            InnerWriter.Write("return ");
        }

        public override void WriteLinePragma(int? lineNumber, string fileName)
        {
            InnerWriter.WriteLine();
            if (lineNumber != null)
            {
                InnerWriter.Write("#line ");
                InnerWriter.Write(lineNumber);
                InnerWriter.Write(" \"");
                InnerWriter.Write(fileName);
                InnerWriter.Write("\"");
                InnerWriter.WriteLine();
            }
            else
            {
                InnerWriter.WriteLine("#line default");
                InnerWriter.WriteLine("#line hidden");
            }
        }

        public override void WriteHiddenLinePragma()
        {
            InnerWriter.WriteLine("#line hidden");
        }

        public override void WriteHelperHeaderPrefix(string templateTypeName, bool isStatic)
        {
            InnerWriter.Write("public ");
            if (isStatic)
            {
                InnerWriter.Write("static ");
            }
            InnerWriter.Write(templateTypeName);
            InnerWriter.Write(" ");
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/CSharpRazorCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.Razor.Generator
{
    public class CSharpRazorCodeGenerator : RazorCodeGenerator
    {
        private const string HiddenLinePragma = "#line hidden";

        public CSharpRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host)
            : base(className, rootNamespaceName, sourceFileName, host)
        {
        }

        internal override Func<CodeWriter> CodeWriterFactory
        {
            get { return () => new CSharpCodeWriter(); }
        }

        [SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "System.CodeDom.CodeSnippetTypeMember.#ctor(System.String)", Justification = "Value is never to be localized")]
        protected override void Initialize(CodeGeneratorContext context)
        {
            base.Initialize(context);

            context.GeneratedClass.Members.Insert(0, new CodeSnippetTypeMember(HiddenLinePragma));
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/CodeGenerationCompleteEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class CodeGenerationCompleteEventArgs : EventArgs
    {
        public CodeGenerationCompleteEventArgs(string virtualPath, string physicalPath, CodeCompileUnit generatedCode)
        {
            if (String.IsNullOrEmpty(virtualPath))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "virtualPath");
            }
            if (generatedCode == null)
            {
                throw new ArgumentNullException("generatedCode");
            }
            VirtualPath = virtualPath;
            PhysicalPath = physicalPath;
            GeneratedCode = generatedCode;
        }

        public CodeCompileUnit GeneratedCode { get; private set; }
        public string VirtualPath { get; private set; }
        public string PhysicalPath { get; private set; }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/CodeGeneratorContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Utils;

namespace System.Web.Razor.Generator
{
    public class CodeGeneratorContext
    {
        private const string DesignTimeHelperMethodName = "__RazorDesignTimeHelpers__";

        private int _nextDesignTimePragmaId = 1;
        private bool _expressionHelperVariableWriten;
        private CodeMemberMethod _designTimeHelperMethod;
        private StatementBuffer _currentBuffer = new StatementBuffer();

        private CodeGeneratorContext()
        {
            ExpressionRenderingMode = ExpressionRenderingMode.WriteToOutput;
        }

        // Internal/Private state. Technically consumers might want to use some of these but they can implement them independently if necessary.
        // It's way safer to make them internal for now, especially with the code generator stuff in a bit of flux.
        internal ExpressionRenderingMode ExpressionRenderingMode { get; set; }
        private Action<string, CodeLinePragma> StatementCollector { get; set; }
        private Func<CodeWriter> CodeWriterFactory { get; set; }

        public string SourceFile { get; internal set; }
        public CodeCompileUnit CompileUnit { get; internal set; }
        public CodeNamespace Namespace { get; internal set; }
        public CodeTypeDeclaration GeneratedClass { get; internal set; }
        public RazorEngineHost Host { get; private set; }
        public IDictionary<int, GeneratedCodeMapping> CodeMappings { get; private set; }
        public string TargetWriterName { get; set; }
        public CodeMemberMethod TargetMethod { get; set; }

        public string CurrentBufferedStatement
        {
            get { return _currentBuffer == null ? String.Empty : _currentBuffer.Builder.ToString(); }
        }

        public static CodeGeneratorContext Create(RazorEngineHost host, string className, string rootNamespace, string sourceFile, bool shouldGenerateLinePragmas)
        {
            return Create(host, null, className, rootNamespace, sourceFile, shouldGenerateLinePragmas);
        }

        internal static CodeGeneratorContext Create(RazorEngineHost host, Func<CodeWriter> writerFactory, string className, string rootNamespace, string sourceFile, bool shouldGenerateLinePragmas)
        {
            CodeGeneratorContext context = new CodeGeneratorContext()
            {
                Host = host,
                CodeWriterFactory = writerFactory,
                SourceFile = shouldGenerateLinePragmas ? sourceFile : null,
                CompileUnit = new CodeCompileUnit(),
                Namespace = new CodeNamespace(rootNamespace),
                GeneratedClass = new CodeTypeDeclaration(className)
                {
                    IsClass = true
                },
                TargetMethod = new CodeMemberMethod()
                {
                    Name = host.GeneratedClassContext.ExecuteMethodName,
                    Attributes = MemberAttributes.Override | MemberAttributes.Public
                },
                CodeMappings = new Dictionary<int, GeneratedCodeMapping>()
            };
            context.CompileUnit.Namespaces.Add(context.Namespace);
            context.Namespace.Types.Add(context.GeneratedClass);
            context.GeneratedClass.Members.Add(context.TargetMethod);

            context.Namespace.Imports.AddRange(host.NamespaceImports
                                                   .Select(s => new CodeNamespaceImport(s))
                                                   .ToArray());

            return context;
        }

        public void AddDesignTimeHelperStatement(CodeSnippetStatement statement)
        {
            if (_designTimeHelperMethod == null)
            {
                _designTimeHelperMethod = new CodeMemberMethod()
                {
                    Name = DesignTimeHelperMethodName,
                    Attributes = MemberAttributes.Private
                };
                _designTimeHelperMethod.Statements.Add(
                    new CodeSnippetStatement(BuildCodeString(cw => cw.WriteDisableUnusedFieldWarningPragma())));
                _designTimeHelperMethod.Statements.Add(
                    new CodeSnippetStatement(BuildCodeString(cw => cw.WriteRestoreUnusedFieldWarningPragma())));
                GeneratedClass.Members.Insert(0, _designTimeHelperMethod);
            }
            _designTimeHelperMethod.Statements.Insert(_designTimeHelperMethod.Statements.Count - 1, statement);
        }

        [SuppressMessage("Microsoft.Usage", "CA2233:OperationsShouldNotOverflow", MessageId = "generatedCodeStart+1", Justification = "There is no risk of overflow in this case")]
        public int AddCodeMapping(SourceLocation sourceLocation, int generatedCodeStart, int generatedCodeLength)
        {
            if (generatedCodeStart == Int32.MaxValue)
            {
                throw new ArgumentOutOfRangeException("generatedCodeStart");
            }

            GeneratedCodeMapping mapping = new GeneratedCodeMapping(
                startOffset: sourceLocation.AbsoluteIndex,
                startLine: sourceLocation.LineIndex + 1,
                startColumn: sourceLocation.CharacterIndex + 1,
                startGeneratedColumn: generatedCodeStart + 1,
                codeLength: generatedCodeLength);

            int id = _nextDesignTimePragmaId++;
            CodeMappings[id] = mapping;
            return id;
        }

        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "This method requires that a Span be provided")]
        public CodeLinePragma GenerateLinePragma(Span target)
        {
            return GenerateLinePragma(target, 0);
        }

        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "This method requires that a Span be provided")]
        public CodeLinePragma GenerateLinePragma(Span target, int generatedCodeStart)
        {
            return GenerateLinePragma(target, generatedCodeStart, target.Content.Length);
        }

        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "This method requires that a Span be provided")]
        public CodeLinePragma GenerateLinePragma(Span target, int generatedCodeStart, int codeLength)
        {
            return GenerateLinePragma(target.Start, generatedCodeStart, codeLength);
        }

        public CodeLinePragma GenerateLinePragma(SourceLocation start, int generatedCodeStart, int codeLength)
        {
            if (!String.IsNullOrEmpty(SourceFile))
            {
                if (Host.DesignTimeMode)
                {
                    int mappingId = AddCodeMapping(start, generatedCodeStart, codeLength);
                    return new CodeLinePragma(SourceFile, mappingId);
                }
                return new CodeLinePragma(SourceFile, start.LineIndex + 1);
            }
            return null;
        }

        public void BufferStatementFragment(Span sourceSpan)
        {
            BufferStatementFragment(sourceSpan.Content, sourceSpan);
        }

        public void BufferStatementFragment(string fragment)
        {
            BufferStatementFragment(fragment, null);
        }

        public void BufferStatementFragment(string fragment, Span sourceSpan)
        {
            if (sourceSpan != null && _currentBuffer.LinePragmaSpan == null)
            {
                _currentBuffer.LinePragmaSpan = sourceSpan;

                // Pad the output as necessary
                int start = _currentBuffer.Builder.Length;
                if (_currentBuffer.GeneratedCodeStart != null)
                {
                    start = _currentBuffer.GeneratedCodeStart.Value;
                }

                int paddingLength; // unused, in this case there is enough context in the original code to calculate the right padding length
                                   // (padded.Length - _currentBuffer.Builder.Length)

                string padded = CodeGeneratorPaddingHelper.Pad(Host, _currentBuffer.Builder.ToString(), sourceSpan, start, out paddingLength);
                _currentBuffer.GeneratedCodeStart = start + (padded.Length - _currentBuffer.Builder.Length);
                _currentBuffer.Builder.Clear();
                _currentBuffer.Builder.Append(padded);
            }
            _currentBuffer.Builder.Append(fragment);
        }

        public void MarkStartOfGeneratedCode()
        {
            _currentBuffer.MarkStart();
        }

        public void MarkEndOfGeneratedCode()
        {
            _currentBuffer.MarkEnd();
        }

        public void FlushBufferedStatement()
        {
            if (_currentBuffer.Builder.Length > 0)
            {
                CodeLinePragma pragma = null;
                if (_currentBuffer.LinePragmaSpan != null)
                {
                    int start = _currentBuffer.Builder.Length;
                    if (_currentBuffer.GeneratedCodeStart != null)
                    {
                        start = _currentBuffer.GeneratedCodeStart.Value;
                    }
                    int len = _currentBuffer.Builder.Length - start;
                    if (_currentBuffer.CodeLength != null)
                    {
                        len = _currentBuffer.CodeLength.Value;
                    }
                    pragma = GenerateLinePragma(_currentBuffer.LinePragmaSpan, start, len);
                }
                AddStatement(_currentBuffer.Builder.ToString(), pragma);
                _currentBuffer.Reset();
            }
        }

        public void AddStatement(string generatedCode)
        {
            AddStatement(generatedCode, null);
        }

        public void AddStatement(string body, CodeLinePragma pragma)
        {
            if (StatementCollector == null)
            {
                TargetMethod.Statements.Add(new CodeSnippetStatement(body) { LinePragma = pragma });
            }
            else
            {
                StatementCollector(body, pragma);
            }
        }

        public void EnsureExpressionHelperVariable()
        {
            if (!_expressionHelperVariableWriten)
            {
                GeneratedClass.Members.Insert(0,
                                              new CodeMemberField(typeof(object), "__o")
                                              {
                                                  Attributes = MemberAttributes.Private | MemberAttributes.Static
                                              });
                _expressionHelperVariableWriten = true;
            }
        }

        public IDisposable ChangeStatementCollector(Action<string, CodeLinePragma> collector)
        {
            Action<string, CodeLinePragma> oldCollector = StatementCollector;
            StatementCollector = collector;
            return new DisposableAction(() =>
            {
                StatementCollector = oldCollector;
            });
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "We explicitly want the lower-case string here")]
        public void AddContextCall(Span contentSpan, string methodName, bool isLiteral)
        {
            AddStatement(BuildCodeString(cw =>
            {
                cw.WriteStartMethodInvoke(methodName);
                if (!String.IsNullOrEmpty(TargetWriterName))
                {
                    cw.WriteSnippet(TargetWriterName);
                    cw.WriteParameterSeparator();
                }
                cw.WriteStringLiteral(Host.InstrumentedSourceFilePath);
                cw.WriteParameterSeparator();
                cw.WriteSnippet(contentSpan.Start.AbsoluteIndex.ToString(CultureInfo.InvariantCulture));
                cw.WriteParameterSeparator();
                cw.WriteSnippet(contentSpan.Content.Length.ToString(CultureInfo.InvariantCulture));
                cw.WriteParameterSeparator();
                cw.WriteSnippet(isLiteral.ToString().ToLowerInvariant());
                cw.WriteEndMethodInvoke();
                cw.WriteEndStatement();
            }));
        }

        internal CodeWriter CreateCodeWriter()
        {
            Debug.Assert(CodeWriterFactory != null);
            if (CodeWriterFactory == null)
            {
                throw new InvalidOperationException(RazorResources.CreateCodeWriter_NoCodeWriter);
            }
            return CodeWriterFactory();
        }

        internal string BuildCodeString(Action<CodeWriter> action)
        {
            using (CodeWriter cw = CodeWriterFactory())
            {
                action(cw);
                return cw.Content;
            }
        }

        private class StatementBuffer
        {
            public StringBuilder Builder = new StringBuilder();
            public int? GeneratedCodeStart;
            public int? CodeLength;
            public Span LinePragmaSpan;

            public void Reset()
            {
                Builder.Clear();
                GeneratedCodeStart = null;
                CodeLength = null;
                LinePragmaSpan = null;
            }

            public void MarkStart()
            {
                GeneratedCodeStart = Builder.Length;
            }

            public void MarkEnd()
            {
                CodeLength = Builder.Length - GeneratedCodeStart;
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/CodeGeneratorPaddingHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    internal static class CodeGeneratorPaddingHelper
    {
        private static readonly char[] _newLineChars = { '\r', '\n' };

        // there is some duplicity of code here, but its very simple and since this is a host path, I'd rather not create another class to encapsulate the data.
        public static int PaddingCharCount(RazorEngineHost host, Span target, int generatedStart)
        {
            int padding = CalculatePadding(host, target, generatedStart);

            if (host.DesignTimeMode && host.IsIndentingWithTabs)
            {
                int spaces;
                int tabs = Math.DivRem(padding, host.TabSize, out spaces);

                return tabs + spaces;
            }
            else
            {
                return padding;
            }
        }

        // Special case for statement padding to account for brace positioning in the editor.
        public static string PadStatement(RazorEngineHost host, string code, Span target, ref int startGeneratedCode, out int paddingCharCount)
        {
            if (host == null)
            {
                throw new ArgumentNullException("host");
            }

            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            // We are passing 0 rather than startgeneratedcode intentionally (keeping v2 behavior).
            int padding = CalculatePadding(host, target, 0);

            // We treat statement padding specially so for brace positioning, so that in the following example:
            //   @if (foo > 0)
            //   {
            //   }
            //
            // the braces shows up under the @ rather than under the if.
            if (host.DesignTimeMode &&
                padding > 0 &&
                target.Previous.Kind == SpanKind.Transition && // target.Previous is guaranteed to be none null if you got any padding.
                String.Equals(target.Previous.Content, SyntaxConstants.TransitionString))
            {
                padding--;
                startGeneratedCode--;
            }

            string generatedCode = PadInternal(host, code, padding, out paddingCharCount);

            return generatedCode;
        }

        public static string Pad(RazorEngineHost host, string code, Span target, out int paddingCharCount)
        {
            int padding = CalculatePadding(host, target, 0);

            return PadInternal(host, code, padding, out paddingCharCount);
        }

        public static string Pad(RazorEngineHost host, string code, Span target, int generatedStart, out int paddingCharCount)
        {
            int padding = CalculatePadding(host, target, generatedStart);

            return PadInternal(host, code, padding, out paddingCharCount);
        }

        // internal for unit testing only, not intended to be used directly in code
        internal static int CalculatePadding(RazorEngineHost host, Span target, int generatedStart)
        {
            if (host == null)
            {
                throw new ArgumentNullException("host");
            }

            if (target == null)
            {
                throw new ArgumentNullException("target");
            }

            int padding;

            padding = CollectSpacesAndTabs(target, host.TabSize) - generatedStart;

            // if we add generated text that is longer than the padding we wanted to insert we have no recourse and we have to skip padding
            // example:
            // Razor code at column zero: @somecode()
            // Generated code will be:
            // In design time: __o = somecode();
            // In Run time: Write(somecode());
            //
            // In both cases the padding would have been 1 space to remote the space the @ symbol takes, which will be smaller than the 6 chars the hidden generated code takes.
            if (padding < 0)
            {
                padding = 0;
            }

            return padding;
        }

        private static string PadInternal(RazorEngineHost host, string code, int padding, out int paddingCharCount)
        {
            if (host.DesignTimeMode && host.IsIndentingWithTabs)
            {
                int spaces;
                int tabs = Math.DivRem(padding, host.TabSize, out spaces);

                paddingCharCount = tabs + spaces;

                return new string('\t', tabs) + new string(' ', spaces) + code;
            }
            else
            {
                paddingCharCount = padding;
                return code.PadLeft(padding + code.Length, ' ');
            }
        }

        private static int CollectSpacesAndTabs(Span target, int tabSize)
        {
            Span firstSpanInLine = target;

            string currentContent = null;

            while (firstSpanInLine.Previous != null)
            {
                // When scanning previous spans we need to be break down the spans with spaces.
                // Because the parser doesn't so for example a span looking like \n\n\t needs to be broken down, and we should just grab the \t.
                String previousContent = firstSpanInLine.Previous.Content ?? String.Empty;

                int lastNewLineIndex = previousContent.LastIndexOfAny(_newLineChars);

                if (lastNewLineIndex < 0)
                {
                    firstSpanInLine = firstSpanInLine.Previous;
                }
                else
                {
                    if (lastNewLineIndex != previousContent.Length - 1)
                    {
                        firstSpanInLine = firstSpanInLine.Previous;
                        currentContent = previousContent.Substring(lastNewLineIndex + 1);
                    }

                    break;
                }
            }

            // We need to walk from the beginning of the line, because space + tab(tabSize) = tabSize columns, but tab(tabSize) + space = tabSize+1 columns.
            Span currentSpanInLine = firstSpanInLine;

            if (currentContent == null)
            {
                currentContent = currentSpanInLine.Content;
            }

            int padding = 0;
            while (currentSpanInLine != target)
            {
                if (currentContent != null)
                {
                    for (int i = 0; i < currentContent.Length; i++)
                    {
                        if (currentContent[i] == '\t')
                        {
                            // Example:
                            // <space><space><tab><tab>:
                            // iter 1) 1
                            // iter 2) 2
                            // iter 3) 4 = 2 + (4 - 2)
                            // iter 4) 8 = 4 + (4 - 0)
                            padding = padding + (tabSize - (padding % tabSize));
                        }
                        else
                        {
                            padding++;
                        }
                    }
                }

                currentSpanInLine = currentSpanInLine.Next;
                currentContent = currentSpanInLine.Content;
            }

            return padding;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/CodeWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Globalization;
using System.IO;

namespace System.Web.Razor.Generator
{
    // Utility class which helps write code snippets
    internal abstract class CodeWriter : IDisposable
    {
        private StringWriter _writer;

        protected CodeWriter()
        {
        }

        private enum WriterMode
        {
            Constructor,
            MethodCall,
            LambdaDelegate,
            LambdaExpression
        }

        public string Content
        {
            get { return InnerWriter.ToString(); }
        }

        public StringWriter InnerWriter
        {
            get
            {
                if (_writer == null)
                {
                    _writer = new StringWriter(CultureInfo.InvariantCulture);
                }
                return _writer;
            }
        }

        public virtual bool SupportsMidStatementLinePragmas
        {
            get { return true; }
        }

        public abstract void WriteParameterSeparator();
        public abstract void WriteReturn();
        public abstract void WriteLinePragma(int? lineNumber, string fileName);
        public abstract void WriteHelperHeaderPrefix(string templateTypeName, bool isStatic);
        public abstract void WriteSnippet(string snippet);
        public abstract void WriteStringLiteral(string literal);
        public abstract int WriteVariableDeclaration(string type, string name, string value);

        public virtual void WriteLinePragma()
        {
            WriteLinePragma(null);
        }

        public virtual void WriteLinePragma(CodeLinePragma pragma)
        {
            if (pragma == null)
            {
                WriteLinePragma(null, null);
            }
            else
            {
                WriteLinePragma(pragma.LineNumber, pragma.FileName);
            }
        }

        public virtual void WriteHiddenLinePragma()
        {
        }

        public virtual void WriteDisableUnusedFieldWarningPragma()
        {
        }

        public virtual void WriteRestoreUnusedFieldWarningPragma()
        {
        }

        public virtual void WriteIdentifier(string identifier)
        {
            InnerWriter.Write(identifier);
        }

        public virtual void WriteHelperHeaderSuffix(string templateTypeName)
        {
        }

        public virtual void WriteHelperTrailer()
        {
        }

        public void WriteStartMethodInvoke(string methodName)
        {
            EmitStartMethodInvoke(methodName);
        }

        public void WriteStartMethodInvoke(string methodName, params string[] genericArguments)
        {
            EmitStartMethodInvoke(methodName, genericArguments);
        }

        public void WriteEndMethodInvoke()
        {
            EmitEndMethodInvoke();
        }

        public virtual void WriteEndStatement()
        {
        }

        public virtual void WriteStartAssignment(string variableName)
        {
            InnerWriter.Write(variableName);
            InnerWriter.Write(" = ");
        }

        public void WriteStartLambdaExpression(params string[] parameterNames)
        {
            EmitStartLambdaExpression(parameterNames);
        }

        public void WriteStartConstructor(string typeName)
        {
            EmitStartConstructor(typeName);
        }

        public void WriteStartLambdaDelegate(params string[] parameterNames)
        {
            EmitStartLambdaDelegate(parameterNames);
        }

        public void WriteEndLambdaExpression()
        {
            EmitEndLambdaExpression();
        }

        public void WriteEndConstructor()
        {
            EmitEndConstructor();
        }

        public void WriteEndLambdaDelegate()
        {
            EmitEndLambdaDelegate();
        }

        public virtual void WriteLineContinuation()
        {
        }

        public virtual void WriteBooleanLiteral(bool value)
        {
            WriteSnippet(value.ToString(CultureInfo.InvariantCulture));
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        public void Clear()
        {
            if (InnerWriter != null)
            {
                InnerWriter.GetStringBuilder().Clear();
            }
        }

        public CodeSnippetStatement ToStatement()
        {
            return new CodeSnippetStatement(Content);
        }

        public CodeSnippetTypeMember ToTypeMember()
        {
            return new CodeSnippetTypeMember(Content);
        }

        protected internal abstract void EmitStartLambdaDelegate(string[] parameterNames);
        protected internal abstract void EmitStartLambdaExpression(string[] parameterNames);
        protected internal abstract void EmitStartConstructor(string typeName);
        protected internal abstract void EmitStartMethodInvoke(string methodName);

        protected internal virtual void EmitStartMethodInvoke(string methodName, params string[] genericArguments)
        {
            EmitStartMethodInvoke(methodName);
        }

        protected internal abstract void EmitEndLambdaDelegate();
        protected internal abstract void EmitEndLambdaExpression();
        protected internal abstract void EmitEndConstructor();
        protected internal abstract void EmitEndMethodInvoke();

        protected virtual void Dispose(bool disposing)
        {
            if (disposing && _writer != null)
            {
                _writer.Dispose();
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/CodeWriterExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Razor.Text;

namespace System.Web.Razor.Generator
{
    internal static class CodeWriterExtensions
    {
        public static void WriteLocationTaggedString(this CodeWriter writer, LocationTagged<string> value)
        {
            writer.WriteStartMethodInvoke("Tuple.Create");
            writer.WriteStringLiteral(value.Value);
            writer.WriteParameterSeparator();
            writer.WriteSnippet(value.Location.AbsoluteIndex.ToString(CultureInfo.CurrentCulture));
            writer.WriteEndMethodInvoke();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/DynamicAttributeBlockCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class DynamicAttributeBlockCodeGenerator : BlockCodeGenerator
    {
        private const string ValueWriterName = "__razor_attribute_value_writer";
        private string _oldTargetWriter;
        private bool _isExpression;
        private ExpressionRenderingMode _oldRenderingMode;

        public DynamicAttributeBlockCodeGenerator(LocationTagged<string> prefix, int offset, int line, int col)
            : this(prefix, new SourceLocation(offset, line, col))
        {
        }

        public DynamicAttributeBlockCodeGenerator(LocationTagged<string> prefix, SourceLocation valueStart)
        {
            Prefix = prefix;
            ValueStart = valueStart;
        }

        public LocationTagged<string> Prefix { get; private set; }
        public SourceLocation ValueStart { get; private set; }

        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            if (context.Host.DesignTimeMode)
            {
                return; // Don't generate anything!
            }

            // What kind of block is nested within
            string generatedCode;
            Block child = target.Children.Where(n => n.IsBlock).Cast<Block>().FirstOrDefault();
            if (child != null && child.Type == BlockType.Expression)
            {
                _isExpression = true;
                generatedCode = context.BuildCodeString(cw =>
                {
                    cw.WriteParameterSeparator();
                    cw.WriteStartMethodInvoke("Tuple.Create");
                    cw.WriteLocationTaggedString(Prefix);
                    cw.WriteParameterSeparator();
                    cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32");
                });

                _oldRenderingMode = context.ExpressionRenderingMode;
                context.ExpressionRenderingMode = ExpressionRenderingMode.InjectCode;
            }
            else
            {
                generatedCode = context.BuildCodeString(cw =>
                {
                    cw.WriteParameterSeparator();
                    cw.WriteStartMethodInvoke("Tuple.Create");
                    cw.WriteLocationTaggedString(Prefix);
                    cw.WriteParameterSeparator();
                    cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32");
                    cw.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName);
                    cw.WriteStartLambdaDelegate(ValueWriterName);
                });
            }

            context.MarkEndOfGeneratedCode();
            context.BufferStatementFragment(generatedCode);

            _oldTargetWriter = context.TargetWriterName;
            context.TargetWriterName = ValueWriterName;
        }

        public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
            if (context.Host.DesignTimeMode)
            {
                return; // Don't generate anything!
            }

            string generatedCode;
            if (_isExpression)
            {
                generatedCode = context.BuildCodeString(cw =>
                {
                    cw.WriteParameterSeparator();
                    cw.WriteSnippet(ValueStart.AbsoluteIndex.ToString(CultureInfo.CurrentCulture));
                    cw.WriteEndMethodInvoke();
                    cw.WriteParameterSeparator();
                    // literal: false - This attribute value is not a literal value, it is dynamically generated
                    cw.WriteBooleanLiteral(false);
                    cw.WriteEndMethodInvoke();
                    cw.WriteLineContinuation();
                });
                context.ExpressionRenderingMode = _oldRenderingMode;
            }
            else
            {
                generatedCode = context.BuildCodeString(cw =>
                {
                    cw.WriteEndLambdaDelegate();
                    cw.WriteEndConstructor();
                    cw.WriteParameterSeparator();
                    cw.WriteSnippet(ValueStart.AbsoluteIndex.ToString(CultureInfo.CurrentCulture));
                    cw.WriteEndMethodInvoke();
                    cw.WriteParameterSeparator();
                    // literal: false - This attribute value is not a literal value, it is dynamically generated
                    cw.WriteBooleanLiteral(false);
                    cw.WriteEndMethodInvoke();
                    cw.WriteLineContinuation();
                });
            }

            context.AddStatement(generatedCode);
            context.TargetWriterName = _oldTargetWriter;
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "DynAttr:{0:F}", Prefix);
        }

        public override bool Equals(object obj)
        {
            DynamicAttributeBlockCodeGenerator other = obj as DynamicAttributeBlockCodeGenerator;
            return other != null &&
                   Equals(other.Prefix, Prefix);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Prefix)
                .CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/ExpressionCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class ExpressionCodeGenerator : HybridCodeGenerator
    {
        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
            {
                Span contentSpan = target.Children
                    .OfType<Span>()
                    .Where(s => s.Kind == SpanKind.Code || s.Kind == SpanKind.Markup)
                    .FirstOrDefault();

                if (contentSpan != null)
                {
                    context.AddContextCall(contentSpan, context.Host.GeneratedClassContext.BeginContextMethodName, false);
                }
            }

            string writeInvocation = context.BuildCodeString(cw =>
            {
                if (context.Host.DesignTimeMode)
                {
                    context.EnsureExpressionHelperVariable();
                    cw.WriteStartAssignment("__o");
                }
                else if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
                {
                    if (!String.IsNullOrEmpty(context.TargetWriterName))
                    {
                        cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteToMethodName);
                        cw.WriteSnippet(context.TargetWriterName);
                        cw.WriteParameterSeparator();
                    }
                    else
                    {
                        cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteMethodName);
                    }
                }
            });

            context.BufferStatementFragment(writeInvocation);
            context.MarkStartOfGeneratedCode();
        }

        public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
            string endBlock = context.BuildCodeString(cw =>
            {
                if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
                {
                    if (!context.Host.DesignTimeMode)
                    {
                        cw.WriteEndMethodInvoke();
                    }
                    cw.WriteEndStatement();
                }
                else
                {
                    cw.WriteLineContinuation();
                }
            });

            context.MarkEndOfGeneratedCode();
            context.BufferStatementFragment(endBlock);
            context.FlushBufferedStatement();

            if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
            {
                Span contentSpan = target.Children
                    .OfType<Span>()
                    .Where(s => s.Kind == SpanKind.Code || s.Kind == SpanKind.Markup)
                    .FirstOrDefault();

                if (contentSpan != null)
                {
                    context.AddContextCall(contentSpan, context.Host.GeneratedClassContext.EndContextMethodName, false);
                }
            }
        }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            Span sourceSpan = null;
            if (context.CreateCodeWriter().SupportsMidStatementLinePragmas || context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
            {
                sourceSpan = target;
            }
            context.BufferStatementFragment(target.Content, sourceSpan);
        }

        public override string ToString()
        {
            return "Expr";
        }

        public override bool Equals(object obj)
        {
            return obj is ExpressionCodeGenerator;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/ExpressionRenderingMode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Generator
{
    public enum ExpressionRenderingMode
    {
        /// <summary>
        /// Indicates that expressions should be written to the output stream
        /// </summary>
        /// <example>
        /// If @foo is rendered with WriteToOutput, the code generator would output the following code:
        /// 
        /// Write(foo);
        /// </example>
        WriteToOutput,

        /// <summary>
        /// Indicates that expressions should simply be placed as-is in the code, and the context in which
        /// the code exists will be used to render it
        /// </summary>
        /// <example>
        /// If @foo is rendered with InjectCode, the code generator would output the following code:
        /// 
        /// foo
        /// </example>
        InjectCode
    }
}


================================================
FILE: src/System.Web.Razor/Generator/GeneratedClassContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public struct GeneratedClassContext
    {
        public static readonly string DefaultWriteMethodName = "Write";
        public static readonly string DefaultWriteLiteralMethodName = "WriteLiteral";
        public static readonly string DefaultExecuteMethodName = "Execute";
        public static readonly string DefaultLayoutPropertyName = "Layout";
        public static readonly string DefaultWriteAttributeMethodName = "WriteAttribute";
        public static readonly string DefaultWriteAttributeToMethodName = "WriteAttributeTo";

        public static readonly GeneratedClassContext Default = new GeneratedClassContext(DefaultExecuteMethodName,
                                                                                         DefaultWriteMethodName,
                                                                                         DefaultWriteLiteralMethodName);

        public GeneratedClassContext(string executeMethodName, string writeMethodName, string writeLiteralMethodName)
            : this()
        {
            if (String.IsNullOrEmpty(executeMethodName))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          CommonResources.Argument_Cannot_Be_Null_Or_Empty,
                                                          "executeMethodName"),
                                            "executeMethodName");
            }
            if (String.IsNullOrEmpty(writeMethodName))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          CommonResources.Argument_Cannot_Be_Null_Or_Empty,
                                                          "writeMethodName"),
                                            "writeMethodName");
            }
            if (String.IsNullOrEmpty(writeLiteralMethodName))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
                                                          CommonResources.Argument_Cannot_Be_Null_Or_Empty,
                                                          "writeLiteralMethodName"),
                                            "writeLiteralMethodName");
            }

            WriteMethodName = writeMethodName;
            WriteLiteralMethodName = writeLiteralMethodName;
            ExecuteMethodName = executeMethodName;

            WriteToMethodName = null;
            WriteLiteralToMethodName = null;
            TemplateTypeName = null;
            DefineSectionMethodName = null;

            LayoutPropertyName = DefaultLayoutPropertyName;
            WriteAttributeMethodName = DefaultWriteAttributeMethodName;
            WriteAttributeToMethodName = DefaultWriteAttributeToMethodName;
        }

        public GeneratedClassContext(string executeMethodName,
                                     string writeMethodName,
                                     string writeLiteralMethodName,
                                     string writeToMethodName,
                                     string writeLiteralToMethodName,
                                     string templateTypeName)
            : this(executeMethodName, writeMethodName, writeLiteralMethodName)
        {
            WriteToMethodName = writeToMethodName;
            WriteLiteralToMethodName = writeLiteralToMethodName;
            TemplateTypeName = templateTypeName;
        }

        public GeneratedClassContext(string executeMethodName,
                                     string writeMethodName,
                                     string writeLiteralMethodName,
                                     string writeToMethodName,
                                     string writeLiteralToMethodName,
                                     string templateTypeName,
                                     string defineSectionMethodName)
            : this(executeMethodName, writeMethodName, writeLiteralMethodName, writeToMethodName, writeLiteralToMethodName, templateTypeName)
        {
            DefineSectionMethodName = defineSectionMethodName;
        }

        public GeneratedClassContext(string executeMethodName,
                                     string writeMethodName,
                                     string writeLiteralMethodName,
                                     string writeToMethodName,
                                     string writeLiteralToMethodName,
                                     string templateTypeName,
                                     string defineSectionMethodName,
                                     string beginContextMethodName,
                                     string endContextMethodName)
            : this(executeMethodName, writeMethodName, writeLiteralMethodName, writeToMethodName, writeLiteralToMethodName, templateTypeName, defineSectionMethodName)
        {
            BeginContextMethodName = beginContextMethodName;
            EndContextMethodName = endContextMethodName;
        }

        public string WriteMethodName { get; private set; }
        public string WriteLiteralMethodName { get; private set; }
        public string WriteToMethodName { get; private set; }
        public string WriteLiteralToMethodName { get; private set; }
        public string ExecuteMethodName { get; private set; }

        // Optional Items
        public string BeginContextMethodName { get; set; }
        public string EndContextMethodName { get; set; }
        public string LayoutPropertyName { get; set; }
        public string DefineSectionMethodName { get; set; }
        public string TemplateTypeName { get; set; }
        public string WriteAttributeMethodName { get; set; }
        public string WriteAttributeToMethodName { get; set; }

        [SuppressMessage("Microsoft.Design", "CA1056:UriPropertiesShouldNotBeStrings", Justification = "Property is not a URL property")]
        public string ResolveUrlMethodName { get; set; }

        public bool AllowSections
        {
            get { return !String.IsNullOrEmpty(DefineSectionMethodName); }
        }

        public bool AllowTemplates
        {
            get { return !String.IsNullOrEmpty(TemplateTypeName); }
        }

        public bool SupportsInstrumentation
        {
            get { return !String.IsNullOrEmpty(BeginContextMethodName) && !String.IsNullOrEmpty(EndContextMethodName); }
        }

        public override bool Equals(object obj)
        {
            if (!(obj is GeneratedClassContext))
            {
                return false;
            }
            GeneratedClassContext other = (GeneratedClassContext)obj;
            return String.Equals(DefineSectionMethodName, other.DefineSectionMethodName, StringComparison.Ordinal) &&
                   String.Equals(WriteMethodName, other.WriteMethodName, StringComparison.Ordinal) &&
                   String.Equals(WriteLiteralMethodName, other.WriteLiteralMethodName, StringComparison.Ordinal) &&
                   String.Equals(WriteToMethodName, other.WriteToMethodName, StringComparison.Ordinal) &&
                   String.Equals(WriteLiteralToMethodName, other.WriteLiteralToMethodName, StringComparison.Ordinal) &&
                   String.Equals(ExecuteMethodName, other.ExecuteMethodName, StringComparison.Ordinal) &&
                   String.Equals(TemplateTypeName, other.TemplateTypeName, StringComparison.Ordinal) &&
                   String.Equals(BeginContextMethodName, other.BeginContextMethodName, StringComparison.Ordinal) &&
                   String.Equals(EndContextMethodName, other.EndContextMethodName, StringComparison.Ordinal);
        }

        public override int GetHashCode()
        {
            // TODO: Use HashCodeCombiner
            return DefineSectionMethodName.GetHashCode() ^
                   WriteMethodName.GetHashCode() ^
                   WriteLiteralMethodName.GetHashCode() ^
                   WriteToMethodName.GetHashCode() ^
                   WriteLiteralToMethodName.GetHashCode() ^
                   ExecuteMethodName.GetHashCode() ^
                   TemplateTypeName.GetHashCode() ^
                   BeginContextMethodName.GetHashCode() ^
                   EndContextMethodName.GetHashCode();
        }

        public static bool operator ==(GeneratedClassContext left, GeneratedClassContext right)
        {
            return left.Equals(right);
        }

        public static bool operator !=(GeneratedClassContext left, GeneratedClassContext right)
        {
            return !left.Equals(right);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/GeneratedCodeMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public struct GeneratedCodeMapping
    {
        public GeneratedCodeMapping(int startLine, int startColumn, int startGeneratedColumn, int codeLength)
            : this(null, startLine, startColumn, startGeneratedColumn, codeLength)
        {
        }

        public GeneratedCodeMapping(int startOffset, int startLine, int startColumn, int startGeneratedColumn, int codeLength)
            : this((int?)startOffset, startLine, startColumn, startGeneratedColumn, codeLength)
        {
        }

        private GeneratedCodeMapping(int? startOffset, int startLine, int startColumn, int startGeneratedColumn, int codeLength)
            : this()
        {
            if (startLine < 0)
            {
                throw new ArgumentOutOfRangeException("startLine", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "startLine", "0"));
            }
            if (startColumn < 0)
            {
                throw new ArgumentOutOfRangeException("startColumn", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "startColumn", "0"));
            }
            if (startGeneratedColumn < 0)
            {
                throw new ArgumentOutOfRangeException("startGeneratedColumn", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "startGeneratedColumn", "0"));
            }
            if (codeLength < 0)
            {
                throw new ArgumentOutOfRangeException("codeLength", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "codeLength", "0"));
            }

            StartOffset = startOffset;
            StartLine = startLine;
            StartColumn = startColumn;
            StartGeneratedColumn = startGeneratedColumn;
            CodeLength = codeLength;
        }

        public int? StartOffset { get; set; }
        public int CodeLength { get; set; }
        public int StartColumn { get; set; }
        public int StartGeneratedColumn { get; set; }
        public int StartLine { get; set; }

        public override bool Equals(object obj)
        {
            if (!(obj is GeneratedCodeMapping))
            {
                return false;
            }
            GeneratedCodeMapping other = (GeneratedCodeMapping)obj;
            return CodeLength == other.CodeLength &&
                   StartColumn == other.StartColumn &&
                   StartGeneratedColumn == other.StartGeneratedColumn &&
                   StartLine == other.StartLine &&
                   // Null means it matches the other no matter what.
                   (StartOffset == null || other.StartOffset == null || StartOffset.Equals(other.StartOffset));
        }

        public override string ToString()
        {
            return String.Format(
                CultureInfo.CurrentCulture,
                "({0}, {1}, {2}) -> (?, {3}) [{4}]",
                StartOffset == null ? "?" : StartOffset.Value.ToString(CultureInfo.CurrentCulture),
                StartLine,
                StartColumn,
                StartGeneratedColumn,
                CodeLength);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(CodeLength)
                .Add(StartColumn)
                .Add(StartGeneratedColumn)
                .Add(StartLine)
                .Add(StartOffset)
                .CombinedHash;
        }

        public static bool operator ==(GeneratedCodeMapping left, GeneratedCodeMapping right)
        {
            return left.Equals(right);
        }

        public static bool operator !=(GeneratedCodeMapping left, GeneratedCodeMapping right)
        {
            return !left.Equals(right);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/HelperCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Globalization;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class HelperCodeGenerator : BlockCodeGenerator
    {
        private const string HelperWriterName = "__razor_helper_writer";

        private CodeWriter _writer;
        private string _oldWriter;
        private IDisposable _statementCollectorToken;

        public HelperCodeGenerator(LocationTagged<string> signature, bool headerComplete)
        {
            Signature = signature;
            HeaderComplete = headerComplete;
        }

        public LocationTagged<string> Signature { get; private set; }
        public LocationTagged<string> Footer { get; set; }
        public bool HeaderComplete { get; private set; }

        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            _writer = context.CreateCodeWriter();

            string prefix = context.BuildCodeString(
                cw => cw.WriteHelperHeaderPrefix(context.Host.GeneratedClassContext.TemplateTypeName, context.Host.StaticHelpers));

            _writer.WriteLinePragma(
                context.GenerateLinePragma(Signature.Location, prefix.Length, Signature.Value.Length));
            _writer.WriteSnippet(prefix);
            _writer.WriteSnippet(Signature);
            if (HeaderComplete)
            {
                _writer.WriteHelperHeaderSuffix(context.Host.GeneratedClassContext.TemplateTypeName);
            }
            _writer.WriteLinePragma(null);
            if (HeaderComplete)
            {
                _writer.WriteReturn();
                _writer.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName);
                _writer.WriteStartLambdaDelegate(HelperWriterName);
            }

            _statementCollectorToken = context.ChangeStatementCollector(AddStatementToHelper);
            _oldWriter = context.TargetWriterName;
            context.TargetWriterName = HelperWriterName;
        }

        public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
            _statementCollectorToken.Dispose();
            if (HeaderComplete)
            {
                _writer.WriteEndLambdaDelegate();
                _writer.WriteEndConstructor();
                _writer.WriteEndStatement();
            }
            if (Footer != null && !String.IsNullOrEmpty(Footer.Value))
            {
                _writer.WriteLinePragma(
                    context.GenerateLinePragma(Footer.Location, 0, Footer.Value.Length));
                _writer.WriteSnippet(Footer);
                _writer.WriteLinePragma();
            }
            _writer.WriteHelperTrailer();

            context.GeneratedClass.Members.Add(new CodeSnippetTypeMember(_writer.Content));
            context.TargetWriterName = _oldWriter;
        }

        public override bool Equals(object obj)
        {
            HelperCodeGenerator other = obj as HelperCodeGenerator;
            return other != null &&
                   base.Equals(other) &&
                   HeaderComplete == other.HeaderComplete &&
                   Equals(Signature, other.Signature);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(base.GetHashCode())
                .Add(Signature)
                .CombinedHash;
        }

        public override string ToString()
        {
            return "Helper:" + Signature.ToString("F", CultureInfo.CurrentCulture) + ";" + (HeaderComplete ? "C" : "I");
        }

        private void AddStatementToHelper(string statement, CodeLinePragma pragma)
        {
            if (pragma != null)
            {
                _writer.WriteLinePragma(pragma);
            }
            _writer.WriteSnippet(statement);
            _writer.InnerWriter.WriteLine(); // CodeDOM normally inserts an extra line so we need to do so here.
            if (pragma != null)
            {
                _writer.WriteLinePragma();
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/HybridCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public abstract class HybridCodeGenerator : ISpanCodeGenerator, IBlockCodeGenerator
    {
        public virtual void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
        }

        public virtual void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
        }

        public virtual void GenerateCode(Span target, CodeGeneratorContext context)
        {
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/IBlockCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public interface IBlockCodeGenerator
    {
        void GenerateStartBlockCode(Block target, CodeGeneratorContext context);
        void GenerateEndBlockCode(Block target, CodeGeneratorContext context);
    }
}


================================================
FILE: src/System.Web.Razor/Generator/ISpanCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public interface ISpanCodeGenerator
    {
        void GenerateCode(Span target, CodeGeneratorContext context);
    }
}


================================================
FILE: src/System.Web.Razor/Generator/LiteralAttributeCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class LiteralAttributeCodeGenerator : SpanCodeGenerator
    {
        public LiteralAttributeCodeGenerator(LocationTagged<string> prefix, LocationTagged<SpanCodeGenerator> valueGenerator)
        {
            Prefix = prefix;
            ValueGenerator = valueGenerator;
        }

        public LiteralAttributeCodeGenerator(LocationTagged<string> prefix, LocationTagged<string> value)
        {
            Prefix = prefix;
            Value = value;
        }

        public LocationTagged<string> Prefix { get; private set; }
        public LocationTagged<string> Value { get; private set; }
        public LocationTagged<SpanCodeGenerator> ValueGenerator { get; private set; }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            if (context.Host.DesignTimeMode)
            {
                return;
            }
            ExpressionRenderingMode oldMode = context.ExpressionRenderingMode;
            context.BufferStatementFragment(context.BuildCodeString(cw =>
            {
                cw.WriteParameterSeparator();
                cw.WriteStartMethodInvoke("Tuple.Create");
                cw.WriteLocationTaggedString(Prefix);
                cw.WriteParameterSeparator();
                if (ValueGenerator != null)
                {
                    cw.WriteStartMethodInvoke("Tuple.Create", "System.Object", "System.Int32");
                    context.ExpressionRenderingMode = ExpressionRenderingMode.InjectCode;
                }
                else
                {
                    cw.WriteLocationTaggedString(Value);
                    cw.WriteParameterSeparator();
                    // literal: true - This attribute value is a literal value
                    cw.WriteBooleanLiteral(true);
                    cw.WriteEndMethodInvoke();

                    // In VB, we need a line continuation
                    cw.WriteLineContinuation();
                }
            }));
            if (ValueGenerator != null)
            {
                ValueGenerator.Value.GenerateCode(target, context);
                context.FlushBufferedStatement();
                context.ExpressionRenderingMode = oldMode;
                context.AddStatement(context.BuildCodeString(cw =>
                {
                    cw.WriteParameterSeparator();
                    cw.WriteSnippet(ValueGenerator.Location.AbsoluteIndex.ToString(CultureInfo.CurrentCulture));
                    cw.WriteEndMethodInvoke();
                    cw.WriteParameterSeparator();
                    // literal: false - This attribute value is not a literal value, it is dynamically generated
                    cw.WriteBooleanLiteral(false);
                    cw.WriteEndMethodInvoke();

                    // In VB, we need a line continuation
                    cw.WriteLineContinuation();
                }));
            }
            else
            {
                context.FlushBufferedStatement();
            }
        }

        public override string ToString()
        {
            if (ValueGenerator == null)
            {
                return String.Format(CultureInfo.CurrentCulture, "LitAttr:{0:F},{1:F}", Prefix, Value);
            }
            else
            {
                return String.Format(CultureInfo.CurrentCulture, "LitAttr:{0:F},<Sub:{1:F}>", Prefix, ValueGenerator);
            }
        }

        public override bool Equals(object obj)
        {
            LiteralAttributeCodeGenerator other = obj as LiteralAttributeCodeGenerator;
            return other != null &&
                   Equals(other.Prefix, Prefix) &&
                   Equals(other.Value, Value) &&
                   Equals(other.ValueGenerator, ValueGenerator);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Prefix)
                .Add(Value)
                .Add(ValueGenerator)
                .CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/MarkupCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class MarkupCodeGenerator : SpanCodeGenerator
    {
        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            if (!context.Host.DesignTimeMode && String.IsNullOrEmpty(target.Content))
            {
                return;
            }

            if (context.Host.EnableInstrumentation)
            {
                context.AddContextCall(target, context.Host.GeneratedClassContext.BeginContextMethodName, isLiteral: true);
            }

            if (!String.IsNullOrEmpty(target.Content) && !context.Host.DesignTimeMode)
            {
                string code = context.BuildCodeString(cw =>
                {
                    if (!String.IsNullOrEmpty(context.TargetWriterName))
                    {
                        cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteLiteralToMethodName);
                        cw.WriteSnippet(context.TargetWriterName);
                        cw.WriteParameterSeparator();
                    }
                    else
                    {
                        cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteLiteralMethodName);
                    }
                    cw.WriteStringLiteral(target.Content);
                    cw.WriteEndMethodInvoke();
                    cw.WriteEndStatement();
                });
                context.AddStatement(code);
            }

            if (context.Host.EnableInstrumentation)
            {
                context.AddContextCall(target, context.Host.GeneratedClassContext.EndContextMethodName, isLiteral: true);
            }
        }

        public override string ToString()
        {
            return "Markup";
        }

        public override bool Equals(object obj)
        {
            return obj is MarkupCodeGenerator;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/RazorCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Linq;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public abstract class RazorCodeGenerator : ParserVisitor
    {
        private CodeGeneratorContext _context;

        protected RazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host)
        {
            if (String.IsNullOrEmpty(className))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "className");
            }
            if (rootNamespaceName == null)
            {
                throw new ArgumentNullException("rootNamespaceName");
            }
            if (host == null)
            {
                throw new ArgumentNullException("host");
            }

            ClassName = className;
            RootNamespaceName = rootNamespaceName;
            SourceFileName = sourceFileName;
            GenerateLinePragmas = String.IsNullOrEmpty(SourceFileName) ? false : true;
            Host = host;
        }

        // Data pulled from constructor
        public string ClassName { get; private set; }
        public string RootNamespaceName { get; private set; }
        public string SourceFileName { get; private set; }
        public RazorEngineHost Host { get; private set; }

        // Generation settings
        public bool GenerateLinePragmas { get; set; }
        public bool DesignTimeMode { get; set; }

        public CodeGeneratorContext Context
        {
            get
            {
                EnsureContextInitialized();
                return _context;
            }
        }

        internal virtual Func<CodeWriter> CodeWriterFactory
        {
            get { return null; }
        }

        public override void VisitStartBlock(Block block)
        {
            block.CodeGenerator.GenerateStartBlockCode(block, Context);
        }

        public override void VisitEndBlock(Block block)
        {
            block.CodeGenerator.GenerateEndBlockCode(block, Context);
        }

        public override void VisitSpan(Span span)
        {
            span.CodeGenerator.GenerateCode(span, Context);
        }

        public override void OnComplete()
        {
            Context.FlushBufferedStatement();
        }

        private void EnsureContextInitialized()
        {
            if (_context == null)
            {
                _context = CodeGeneratorContext.Create(Host, CodeWriterFactory, ClassName, RootNamespaceName, SourceFileName, GenerateLinePragmas);
                Initialize(_context);
            }
        }

        protected virtual void Initialize(CodeGeneratorContext context)
        {
            context.Namespace.Imports.AddRange(Host.NamespaceImports.Select(s => new CodeNamespaceImport(s)).ToArray());

            if (!String.IsNullOrEmpty(Host.DefaultBaseClass))
            {
                context.GeneratedClass.BaseTypes.Add(new CodeTypeReference(Host.DefaultBaseClass));
            }

            // Dev10 Bug 937438: Generate explicit Parameter-less constructor on Razor generated class
            context.GeneratedClass.Members.Add(new CodeConstructor() { Attributes = MemberAttributes.Public });
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/RazorCommentCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class RazorCommentCodeGenerator : BlockCodeGenerator
    {
        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            // Flush the buffered statement since we're interrupting it with a comment.
            if (!String.IsNullOrEmpty(context.CurrentBufferedStatement))
            {
                context.MarkEndOfGeneratedCode();
                context.BufferStatementFragment(context.BuildCodeString(cw => cw.WriteLineContinuation()));
            }
            context.FlushBufferedStatement();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/RazorDirectiveAttributeCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class RazorDirectiveAttributeCodeGenerator : SpanCodeGenerator
    {
        public RazorDirectiveAttributeCodeGenerator(string name, string value)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            Name = name;
            Value = value ?? String.Empty; // Coerce to empty string if it was null.
        }

        public string Name { get; private set; }

        public string Value { get; private set; }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            var attributeType = new CodeTypeReference(typeof(RazorDirectiveAttribute));
            var attributeDeclaration = new CodeAttributeDeclaration(
                attributeType,
                new CodeAttributeArgument(new CodePrimitiveExpression(Name)),
                new CodeAttributeArgument(new CodePrimitiveExpression(Value)));
            context.GeneratedClass.CustomAttributes.Add(attributeDeclaration);
        }

        public override string ToString()
        {
            return "Directive: " + Name + ", Value: " + Value;
        }

        public override bool Equals(object obj)
        {
            RazorDirectiveAttributeCodeGenerator other = obj as RazorDirectiveAttributeCodeGenerator;
            return other != null &&
                   Name.Equals(other.Name, StringComparison.OrdinalIgnoreCase) &&
                   Value.Equals(other.Value, StringComparison.OrdinalIgnoreCase);
        }

        public override int GetHashCode()
        {
            return Tuple.Create(Name.ToUpperInvariant(), Value.ToUpperInvariant())
                .GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/ResolveUrlCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class ResolveUrlCodeGenerator : SpanCodeGenerator
    {
        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            // Check if the host supports it
            if (String.IsNullOrEmpty(context.Host.GeneratedClassContext.ResolveUrlMethodName))
            {
                // Nope, just use the default MarkupCodeGenerator behavior
                new MarkupCodeGenerator().GenerateCode(target, context);
                return;
            }

            if (!context.Host.DesignTimeMode && String.IsNullOrEmpty(target.Content))
            {
                return;
            }

            if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
            {
                // Add a non-literal context call (non-literal because the expanded URL will not match the source character-by-character)
                context.AddContextCall(target, context.Host.GeneratedClassContext.BeginContextMethodName, isLiteral: false);
            }

            if (!String.IsNullOrEmpty(target.Content) && !context.Host.DesignTimeMode)
            {
                string code = context.BuildCodeString(cw =>
                {
                    if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
                    {
                        if (!String.IsNullOrEmpty(context.TargetWriterName))
                        {
                            cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteLiteralToMethodName);
                            cw.WriteSnippet(context.TargetWriterName);
                            cw.WriteParameterSeparator();
                        }
                        else
                        {
                            cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.WriteLiteralMethodName);
                        }
                    }
                    cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.ResolveUrlMethodName);
                    cw.WriteStringLiteral(target.Content);
                    cw.WriteEndMethodInvoke();

                    if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
                    {
                        cw.WriteEndMethodInvoke();
                        cw.WriteEndStatement();
                    }
                    else
                    {
                        cw.WriteLineContinuation();
                    }
                });
                if (context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
                {
                    context.AddStatement(code);
                }
                else
                {
                    context.BufferStatementFragment(code);
                }
            }

            if (context.Host.EnableInstrumentation && context.ExpressionRenderingMode == ExpressionRenderingMode.WriteToOutput)
            {
                context.AddContextCall(target, context.Host.GeneratedClassContext.EndContextMethodName, isLiteral: false);
            }
        }

        public override string ToString()
        {
            return "VirtualPath";
        }

        public override bool Equals(object obj)
        {
            return obj is ResolveUrlCodeGenerator;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/SectionCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Generator
{
    public class SectionCodeGenerator : BlockCodeGenerator
    {
        public SectionCodeGenerator(string sectionName)
        {
            SectionName = sectionName;
        }

        public string SectionName { get; private set; }

        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            string startBlock = context.BuildCodeString(cw =>
            {
                cw.WriteStartMethodInvoke(context.Host.GeneratedClassContext.DefineSectionMethodName);
                cw.WriteStringLiteral(SectionName);
                cw.WriteParameterSeparator();
                cw.WriteStartLambdaDelegate();
            });
            context.AddStatement(startBlock);
        }

        public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
            string startBlock = context.BuildCodeString(cw =>
            {
                cw.WriteEndLambdaDelegate();
                cw.WriteEndMethodInvoke();
                cw.WriteEndStatement();
            });
            context.AddStatement(startBlock);
        }

        public override bool Equals(object obj)
        {
            SectionCodeGenerator other = obj as SectionCodeGenerator;
            return other != null &&
                   base.Equals(other) &&
                   String.Equals(SectionName, other.SectionName, StringComparison.Ordinal);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(base.GetHashCode())
                .Add(SectionName)
                .CombinedHash;
        }

        public override string ToString()
        {
            return "Section:" + SectionName;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/SetBaseTypeCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class SetBaseTypeCodeGenerator : SpanCodeGenerator
    {
        public SetBaseTypeCodeGenerator(string baseType)
        {
            BaseType = baseType;
        }

        public string BaseType { get; private set; }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            context.GeneratedClass.BaseTypes.Clear();
            context.GeneratedClass.BaseTypes.Add(new CodeTypeReference(ResolveType(context, BaseType.Trim())));

            if (context.Host.DesignTimeMode)
            {
                int generatedCodeStart = 0;
                string code = context.BuildCodeString(cw =>
                {
                    generatedCodeStart = cw.WriteVariableDeclaration(target.Content, "__inheritsHelper", null);
                    cw.WriteEndStatement();
                });

                int paddingCharCount;

                CodeSnippetStatement stmt = new CodeSnippetStatement(
                    CodeGeneratorPaddingHelper.Pad(context.Host, code, target, generatedCodeStart, out paddingCharCount))
                {
                    LinePragma = context.GenerateLinePragma(target, generatedCodeStart + paddingCharCount)
                };
                context.AddDesignTimeHelperStatement(stmt);
            }
        }

        protected virtual string ResolveType(CodeGeneratorContext context, string baseType)
        {
            return baseType;
        }

        public override string ToString()
        {
            return "Base:" + BaseType;
        }

        public override bool Equals(object obj)
        {
            SetBaseTypeCodeGenerator other = obj as SetBaseTypeCodeGenerator;
            return other != null &&
                   String.Equals(BaseType, other.BaseType, StringComparison.Ordinal);
        }

        public override int GetHashCode()
        {
            return BaseType.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/SetLayoutCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class SetLayoutCodeGenerator : SpanCodeGenerator
    {
        public SetLayoutCodeGenerator(string layoutPath)
        {
            LayoutPath = layoutPath;
        }

        public string LayoutPath { get; set; }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            if (!context.Host.DesignTimeMode && !String.IsNullOrEmpty(context.Host.GeneratedClassContext.LayoutPropertyName))
            {
                context.TargetMethod.Statements.Add(
                    new CodeAssignStatement(
                        new CodePropertyReferenceExpression(null, context.Host.GeneratedClassContext.LayoutPropertyName),
                        new CodePrimitiveExpression(LayoutPath)));
            }
        }

        public override string ToString()
        {
            return "Layout: " + LayoutPath;
        }

        public override bool Equals(object obj)
        {
            SetLayoutCodeGenerator other = obj as SetLayoutCodeGenerator;
            return other != null && String.Equals(other.LayoutPath, LayoutPath, StringComparison.Ordinal);
        }

        public override int GetHashCode()
        {
            return LayoutPath.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/SetVBOptionCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class SetVBOptionCodeGenerator : SpanCodeGenerator
    {
        public static readonly string StrictCodeDomOptionName = "AllowLateBound";
        public static readonly string ExplicitCodeDomOptionName = "RequireVariableDeclaration";

        public SetVBOptionCodeGenerator(string optionName, bool value)
        {
            OptionName = optionName;
            Value = value;
        }

        // CodeDOM Option Name, which is NOT the same as the VB Option Name
        public string OptionName { get; private set; }
        public bool Value { get; private set; }

        public static SetVBOptionCodeGenerator Strict(bool onOffValue)
        {
            // Strict On = AllowLateBound Off
            return new SetVBOptionCodeGenerator(StrictCodeDomOptionName, !onOffValue);
        }

        public static SetVBOptionCodeGenerator Explicit(bool onOffValue)
        {
            return new SetVBOptionCodeGenerator(ExplicitCodeDomOptionName, onOffValue);
        }

        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            context.CompileUnit.UserData[OptionName] = Value;
        }

        public override string ToString()
        {
            return "Option:" + OptionName + "=" + Value;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/SpanCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public abstract class SpanCodeGenerator : ISpanCodeGenerator
    {
        [SuppressMessage("Microsoft.Security", "CA2104:DoNotDeclareReadOnlyMutableReferenceTypes", Justification = "This class has no instance state")]
        public static readonly ISpanCodeGenerator Null = new NullSpanCodeGenerator();

        public virtual void GenerateCode(Span target, CodeGeneratorContext context)
        {
        }

        public override bool Equals(object obj)
        {
            return (obj as ISpanCodeGenerator) != null;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        private class NullSpanCodeGenerator : ISpanCodeGenerator
        {
            public void GenerateCode(Span target, CodeGeneratorContext context)
            {
            }

            public override string ToString()
            {
                return "None";
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/StatementCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class StatementCodeGenerator : SpanCodeGenerator
    {
        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            context.FlushBufferedStatement();

            string generatedCode = context.BuildCodeString(cw =>
            {
                cw.WriteSnippet(target.Content);
            });

            int startGeneratedCode = target.Start.CharacterIndex;
            int paddingCharCount;
            generatedCode = CodeGeneratorPaddingHelper.PadStatement(context.Host, generatedCode, target, ref startGeneratedCode, out paddingCharCount);

            context.AddStatement(
                generatedCode,
                context.GenerateLinePragma(target, paddingCharCount));
        }

        public override string ToString()
        {
            return "Stmt";
        }

        public override bool Equals(object obj)
        {
            return obj is StatementCodeGenerator;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/TemplateBlockCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class TemplateBlockCodeGenerator : BlockCodeGenerator
    {
        private const string TemplateWriterName = "__razor_template_writer";
        private const string ItemParameterName = "item";

        private string _oldTargetWriter;

        public override void GenerateStartBlockCode(Block target, CodeGeneratorContext context)
        {
            string generatedCode = context.BuildCodeString(cw =>
            {
                cw.WriteStartLambdaExpression(ItemParameterName);
                cw.WriteStartConstructor(context.Host.GeneratedClassContext.TemplateTypeName);
                cw.WriteStartLambdaDelegate(TemplateWriterName);
            });

            context.MarkEndOfGeneratedCode();
            context.BufferStatementFragment(generatedCode);
            context.FlushBufferedStatement();

            _oldTargetWriter = context.TargetWriterName;
            context.TargetWriterName = TemplateWriterName;
        }

        public override void GenerateEndBlockCode(Block target, CodeGeneratorContext context)
        {
            string generatedCode = context.BuildCodeString(cw =>
            {
                cw.WriteEndLambdaDelegate();
                cw.WriteEndConstructor();
                cw.WriteEndLambdaExpression();
            });

            context.BufferStatementFragment(generatedCode);
            context.TargetWriterName = _oldTargetWriter;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/TypeMemberCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Diagnostics.Contracts;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Generator
{
    public class TypeMemberCodeGenerator : SpanCodeGenerator
    {
        public override void GenerateCode(Span target, CodeGeneratorContext context)
        {
            string generatedCode = context.BuildCodeString(cw =>
            {
                cw.WriteSnippet(target.Content);
            });

            int paddingCharCount;
            string paddedCode = CodeGeneratorPaddingHelper.Pad(context.Host, generatedCode, target, out paddingCharCount);

            Contract.Assert(paddingCharCount > 0);

            context.GeneratedClass.Members.Add(
                new CodeSnippetTypeMember(paddedCode)
                {
                    LinePragma = context.GenerateLinePragma(target, paddingCharCount)
                });
        }

        public override string ToString()
        {
            return "TypeMember";
        }

        public override bool Equals(object obj)
        {
            return obj is TypeMemberCodeGenerator;
        }

        // C# complains at us if we don't provide an implementation, even one like this
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/VBCodeWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Generator
{
    internal class VBCodeWriter : BaseCodeWriter
    {
        public override bool SupportsMidStatementLinePragmas
        {
            get { return false; }
        }

        protected internal override void WriteStartGenerics()
        {
            InnerWriter.Write("(Of ");
        }

        protected internal override void WriteEndGenerics()
        {
            InnerWriter.Write(")");
        }

        public override void WriteLineContinuation()
        {
            InnerWriter.Write(" _");
        }

        public override int WriteVariableDeclaration(string type, string name, string value)
        {
            InnerWriter.Write("Dim ");
            InnerWriter.Write(name);
            InnerWriter.Write(" As ");
            int typePos = InnerWriter.GetStringBuilder().Length;
            InnerWriter.Write(type);
            if (!String.IsNullOrEmpty(value))
            {
                InnerWriter.Write(" = ");
                InnerWriter.Write(value);
            }
            else
            {
                InnerWriter.Write(" = Nothing");
            }
            return typePos;
        }

        public override void WriteStringLiteral(string literal)
        {
            bool inQuotes = true;
            InnerWriter.Write("\"");
            for (int i = 0; i < literal.Length; i++)
            {
                switch (literal[i])
                {
                    case '\t':
                    case '\n':
                    case '\r':
                    case '\0':
                    case '\u2028':
                    case '\u2029':
                        // Exit quotes
                        EnsureOutOfQuotes(ref inQuotes);

                        // Write concat character
                        InnerWriter.Write("&");

                        // Write character literal
                        WriteCharLiteral(literal[i]);
                        break;
                    case '"':
                    case '“':
                    case '”':
                    case (char)0xff02:
                        EnsureInQuotes(ref inQuotes);
                        InnerWriter.Write(literal[i]);
                        InnerWriter.Write(literal[i]);
                        break;
                    default:
                        EnsureInQuotes(ref inQuotes);
                        InnerWriter.Write(literal[i]);
                        break;
                }
                if (i > 0 && (i % 80) == 0)
                {
                    if ((Char.IsHighSurrogate(literal[i]) && (i < (literal.Length - 1))) && Char.IsLowSurrogate(literal[i + 1]))
                    {
                        InnerWriter.Write(literal[++i]);
                    }
                    if (inQuotes)
                    {
                        InnerWriter.Write("\"");
                    }
                    inQuotes = true;
                    InnerWriter.Write("& _ ");
                    InnerWriter.Write(Environment.NewLine);
                    InnerWriter.Write('"');
                }
            }
            EnsureOutOfQuotes(ref inQuotes);
        }

        protected internal override void EmitStartLambdaExpression(string[] parameterNames)
        {
            InnerWriter.Write("Function (");
            WriteCommaSeparatedList(parameterNames, InnerWriter.Write);
            InnerWriter.Write(") ");
        }

        protected internal override void EmitStartConstructor(string typeName)
        {
            InnerWriter.Write("New ");
            InnerWriter.Write(typeName);
            InnerWriter.Write("(");
        }

        protected internal override void EmitStartLambdaDelegate(string[] parameterNames)
        {
            InnerWriter.Write("Sub (");
            WriteCommaSeparatedList(parameterNames, InnerWriter.Write);
            InnerWriter.WriteLine(")");
        }

        protected internal override void EmitEndLambdaDelegate()
        {
            InnerWriter.Write("End Sub");
        }

        private void WriteCharLiteral(char literal)
        {
            InnerWriter.Write("Global.Microsoft.VisualBasic.ChrW(");
            InnerWriter.Write((int)literal);
            InnerWriter.Write(")");
        }

        private void EnsureInQuotes(ref bool inQuotes)
        {
            if (!inQuotes)
            {
                InnerWriter.Write("&\"");
                inQuotes = true;
            }
        }

        private void EnsureOutOfQuotes(ref bool inQuotes)
        {
            if (inQuotes)
            {
                InnerWriter.Write("\"");
                inQuotes = false;
            }
        }

        public override void WriteReturn()
        {
            InnerWriter.Write("Return ");
        }

        public override void WriteLinePragma(int? lineNumber, string fileName)
        {
            InnerWriter.WriteLine();
            if (lineNumber != null)
            {
                InnerWriter.Write("#ExternalSource(\"");
                InnerWriter.Write(fileName);
                InnerWriter.Write("\", ");
                InnerWriter.Write(lineNumber);
                InnerWriter.WriteLine(")");
            }
            else
            {
                InnerWriter.WriteLine("#End ExternalSource");
            }
        }

        public override void WriteHelperHeaderPrefix(string templateTypeName, bool isStatic)
        {
            InnerWriter.Write("Public ");
            if (isStatic)
            {
                InnerWriter.Write("Shared ");
            }
            InnerWriter.Write("Function ");
        }

        public override void WriteHelperHeaderSuffix(string templateTypeName)
        {
            InnerWriter.Write(" As ");
            InnerWriter.WriteLine(templateTypeName);
        }

        public override void WriteHelperTrailer()
        {
            InnerWriter.WriteLine("End Function");
        }

        public override void WriteEndStatement()
        {
            InnerWriter.WriteLine();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Generator/VBRazorCodeGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Generator
{
    public class VBRazorCodeGenerator : RazorCodeGenerator
    {
        public VBRazorCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host)
            : base(className, rootNamespaceName, sourceFileName, host)
        {
        }

        internal override Func<CodeWriter> CodeWriterFactory
        {
            get { return () => new VBCodeWriter(); }
        }
    }
}


================================================
FILE: src/System.Web.Razor/GeneratorResults.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections.Generic;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor
{
    /// <summary>
    /// Represents results from code generation (and parsing, since that is a pre-requisite of code generation)
    /// </summary>
    /// <remarks>
    /// Since this inherits from ParserResults, it has all the data from ParserResults, and simply adds code generation data
    /// </remarks>
    public class GeneratorResults : ParserResults
    {
        public GeneratorResults(ParserResults parserResults,
                                CodeCompileUnit generatedCode,
                                IDictionary<int, GeneratedCodeMapping> designTimeLineMappings)
            : this(parserResults.Document, parserResults.ParserErrors, generatedCode, designTimeLineMappings)
        {
        }

        public GeneratorResults(Block document,
                                IList<RazorError> parserErrors,
                                CodeCompileUnit generatedCode,
                                IDictionary<int, GeneratedCodeMapping> designTimeLineMappings)
            : this(parserErrors.Count == 0, document, parserErrors, generatedCode, designTimeLineMappings)
        {
        }

        protected GeneratorResults(bool success,
                                   Block document,
                                   IList<RazorError> parserErrors,
                                   CodeCompileUnit generatedCode,
                                   IDictionary<int, GeneratedCodeMapping> designTimeLineMappings)
            : base(success, document, parserErrors)
        {
            GeneratedCode = generatedCode;
            DesignTimeLineMappings = designTimeLineMappings;
        }

        /// <summary>
        /// The generated code
        /// </summary>
        public CodeCompileUnit GeneratedCode { get; private set; }

        /// <summary>
        /// If design-time mode was used in the Code Generator, this will contain the dictionary
        /// of design-time generated code mappings
        /// </summary>
        public IDictionary<int, GeneratedCodeMapping> DesignTimeLineMappings { get; private set; }
    }
}


================================================
FILE: src/System.Web.Razor/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project. 
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc. 
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File". 
// You do not need to add suppressions to this file manually. 

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "br", Scope = "resource", Target = "System.Web.Razor.Resources.RazorResources.resources", Justification = "Resource is referencing html tag")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Razor.Tokenizer.Symbols", Justification = "These namespaces are design to group classes by function. They will be reviewed to ensure they remain relevant.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Razor.Tokenizer", Justification = "These namespaces are design to group classes by function. They will be reviewed to ensure they remain relevant.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Razor.Text", Justification = "These namespaces are design to group classes by function. They will be reviewed to ensure they remain relevant.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Razor.Parser", Justification = "These namespaces are design to group classes by function. They will be reviewed to ensure they remain relevant.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Razor.Editor", Justification = "These namespaces are design to group classes by function. They will be reviewed to ensure they remain relevant.")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Razor", Justification = "These namespaces are design to group classes by function. They will be reviewed to ensure they remain relevant.")]
[assembly: SuppressMessage("Microsoft.Web.FxCop", "MW1000:UnusedResourceUsageRule", Justification = "There are numerous unused resources due to VB being disabled. This rule will be re-run after VB is restored")]


================================================
FILE: src/System.Web.Razor/Parser/BalancingModes.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Parser
{
    [Flags]
    public enum BalancingModes
    {
        None = 0,
        BacktrackOnFailure = 1,
        NoErrorOnFailure = 2,
        AllowCommentsAndTemplates = 4,
        AllowEmbeddedTransitions = 8
    }
}


================================================
FILE: src/System.Web.Razor/Parser/CSharpCodeParser.Directives.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class CSharpCodeParser
    {
        private void SetupDirectives()
        {
            MapDirectives(InheritsDirective, SyntaxConstants.CSharp.InheritsKeyword);
            MapDirectives(FunctionsDirective, SyntaxConstants.CSharp.FunctionsKeyword);
            MapDirectives(SectionDirective, SyntaxConstants.CSharp.SectionKeyword);
            MapDirectives(HelperDirective, SyntaxConstants.CSharp.HelperKeyword);
            MapDirectives(LayoutDirective, SyntaxConstants.CSharp.LayoutKeyword);
            MapDirectives(SessionStateDirective, SyntaxConstants.CSharp.SessionStateKeyword);
        }

        protected virtual void LayoutDirective()
        {
            AssertDirective(SyntaxConstants.CSharp.LayoutKeyword);
            AcceptAndMoveNext();
            Context.CurrentBlock.Type = BlockType.Directive;

            // Accept spaces, but not newlines
            bool foundSomeWhitespace = At(CSharpSymbolType.WhiteSpace);
            AcceptWhile(CSharpSymbolType.WhiteSpace);
            Output(SpanKind.MetaCode, foundSomeWhitespace ? AcceptedCharacters.None : AcceptedCharacters.Any);

            // First non-whitespace character starts the Layout Page, then newline ends it
            AcceptUntil(CSharpSymbolType.NewLine);
            Span.CodeGenerator = new SetLayoutCodeGenerator(Span.GetContent());
            Span.EditHandler.EditorHints = EditorHints.LayoutPage | EditorHints.VirtualPath;
            bool foundNewline = Optional(CSharpSymbolType.NewLine);
            AddMarkerSymbolIfNecessary();
            Output(SpanKind.MetaCode, foundNewline ? AcceptedCharacters.None : AcceptedCharacters.Any);
        }

        protected virtual void SessionStateDirective()
        {
            AssertDirective(SyntaxConstants.CSharp.SessionStateKeyword);
            AcceptAndMoveNext();

            SessionStateDirectiveCore();
        }

        protected void SessionStateDirectiveCore()
        {
            SessionStateTypeDirective(RazorResources.ParserEror_SessionDirectiveMissingValue, (key, value) => new RazorDirectiveAttributeCodeGenerator(key, value));
        }

        protected void SessionStateTypeDirective(string noValueError, Func<string, string, SpanCodeGenerator> createCodeGenerator)
        {
            // Set the block type
            Context.CurrentBlock.Type = BlockType.Directive;

            // Accept whitespace
            CSharpSymbol remainingWs = AcceptSingleWhiteSpaceCharacter();

            if (Span.Symbols.Count > 1)
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }

            Output(SpanKind.MetaCode);

            if (remainingWs != null)
            {
                Accept(remainingWs);
            }
            AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true));

            // Parse a Type Name
            if (!ValidSessionStateValue())
            {
                Context.OnError(CurrentLocation, noValueError);
            }

            // Pull out the type name
            string sessionStateValue = String.Concat(
                Span.Symbols
                    .Cast<CSharpSymbol>()
                    .Select(sym => sym.Content)).Trim();

            // Set up code generation
            Span.CodeGenerator = createCodeGenerator(SyntaxConstants.CSharp.SessionStateKeyword, sessionStateValue);

            // Output the span and finish the block
            CompleteBlock();
            Output(SpanKind.Code);
        }

        protected virtual bool ValidSessionStateValue()
        {
            return Optional(CSharpSymbolType.Identifier);
        }

        [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "Coupling will be reviewed at a later date")]
        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "C# Keywords are always lower-case")]
        protected virtual void HelperDirective()
        {
            bool nested = Context.IsWithin(BlockType.Helper);

            // Set the block and span type
            Context.CurrentBlock.Type = BlockType.Helper;

            // Verify we're on "helper" and accept
            AssertDirective(SyntaxConstants.CSharp.HelperKeyword);
            Block block = new Block(CurrentSymbol.Content.ToString().ToLowerInvariant(), CurrentLocation);
            AcceptAndMoveNext();

            if (nested)
            {
                Context.OnError(CurrentLocation, RazorResources.ParseError_Helpers_Cannot_Be_Nested);
            }

            // Accept a single whitespace character if present, if not, we should stop now
            if (!At(CSharpSymbolType.WhiteSpace))
            {
                string error;
                if (At(CSharpSymbolType.NewLine))
                {
                    error = RazorResources.ErrorComponent_Newline;
                }
                else if (EndOfFile)
                {
                    error = RazorResources.ErrorComponent_EndOfFile;
                }
                else
                {
                    error = String.Format(CultureInfo.CurrentCulture, RazorResources.ErrorComponent_Character, CurrentSymbol.Content);
                }

                Context.OnError(
                    CurrentLocation,
                    RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                    error);
                PutCurrentBack();
                Output(SpanKind.MetaCode);
                return;
            }

            CSharpSymbol remainingWs = AcceptSingleWhiteSpaceCharacter();

            // Output metacode and continue
            Output(SpanKind.MetaCode);
            if (remainingWs != null)
            {
                Accept(remainingWs);
            }
            AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true)); // Don't accept newlines.

            // Expecting an identifier (helper name)
            bool errorReported = !Required(CSharpSymbolType.Identifier, errorIfNotFound: true, errorBase: RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start);
            if (!errorReported)
            {
                Assert(CSharpSymbolType.Identifier);
                AcceptAndMoveNext();
            }

            AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true));

            // Expecting parameter list start: "("
            SourceLocation bracketErrorPos = CurrentLocation;
            if (!Optional(CSharpSymbolType.LeftParenthesis))
            {
                if (!errorReported)
                {
                    errorReported = true;
                    Context.OnError(
                        CurrentLocation,
                        RazorResources.ParseError_MissingCharAfterHelperName,
                        "(");
                }
            }
            else
            {
                SourceLocation bracketStart = CurrentLocation;
                if (!Balance(BalancingModes.NoErrorOnFailure,
                             CSharpSymbolType.LeftParenthesis,
                             CSharpSymbolType.RightParenthesis,
                             bracketStart))
                {
                    errorReported = true;
                    Context.OnError(
                        bracketErrorPos,
                        RazorResources.ParseError_UnterminatedHelperParameterList);
                }
                Optional(CSharpSymbolType.RightParenthesis);
            }

            int bookmark = CurrentLocation.AbsoluteIndex;
            IEnumerable<CSharpSymbol> ws = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: true));

            // Expecting a "{"
            SourceLocation errorLocation = CurrentLocation;
            bool headerComplete = At(CSharpSymbolType.LeftBrace);
            if (headerComplete)
            {
                Accept(ws);
                AcceptAndMoveNext();
            }
            else
            {
                Context.Source.Position = bookmark;
                NextToken();
                AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true));
                if (!errorReported)
                {
                    Context.OnError(
                        errorLocation,
                        RazorResources.ParseError_MissingCharAfterHelperParameters,
                        Language.GetSample(CSharpSymbolType.LeftBrace));
                }
            }

            // Grab the signature and build the code generator
            AddMarkerSymbolIfNecessary();
            LocationTagged<string> signature = Span.GetContent();
            HelperCodeGenerator blockGen = new HelperCodeGenerator(signature, headerComplete);
            Context.CurrentBlock.CodeGenerator = blockGen;

            // The block will generate appropriate code, 
            Span.CodeGenerator = SpanCodeGenerator.Null;

            if (!headerComplete)
            {
                CompleteBlock();
                Output(SpanKind.Code);
                return;
            }
            else
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                Output(SpanKind.Code);
            }

            // We're valid, so parse the nested block
            AutoCompleteEditHandler bodyEditHandler = new AutoCompleteEditHandler(Language.TokenizeString);
            using (PushSpanConfig(DefaultSpanConfig))
            {
                using (Context.StartBlock(BlockType.Statement))
                {
                    Span.EditHandler = bodyEditHandler;
                    CodeBlock(false, block);
                    CompleteBlock(insertMarkerIfNecessary: true);
                    Output(SpanKind.Code);
                }
            }
            Initialize(Span);

            EnsureCurrent();

            Span.CodeGenerator = SpanCodeGenerator.Null; // The block will generate the footer code.
            if (!Optional(CSharpSymbolType.RightBrace))
            {
                // The } is missing, so set the initial signature span to use it as an autocomplete string
                bodyEditHandler.AutoCompleteString = "}";

                // Need to be able to accept anything to properly handle the autocomplete
                bodyEditHandler.AcceptedCharacters = AcceptedCharacters.Any;
            }
            else
            {
                blockGen.Footer = Span.GetContent();
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }
            CompleteBlock();
            Output(SpanKind.Code);
        }

        protected virtual void SectionDirective()
        {
            bool nested = Context.IsWithin(BlockType.Section);
            bool errorReported = false;

            // Set the block and span type
            Context.CurrentBlock.Type = BlockType.Section;

            // Verify we're on "section" and accept
            AssertDirective(SyntaxConstants.CSharp.SectionKeyword);
            AcceptAndMoveNext();

            if (nested)
            {
                Context.OnError(CurrentLocation, String.Format(CultureInfo.CurrentCulture, RazorResources.ParseError_Sections_Cannot_Be_Nested, RazorResources.SectionExample_CS));
                errorReported = true;
            }

            IEnumerable<CSharpSymbol> ws = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: false));

            // Get the section name
            string sectionName = String.Empty;
            if (!Required(CSharpSymbolType.Identifier,
                          errorIfNotFound: true,
                          errorBase: RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start))
            {
                if (!errorReported)
                {
                    errorReported = true;
                }

                PutCurrentBack();
                PutBack(ws);
                AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: false));
            }
            else
            {
                Accept(ws);
                sectionName = CurrentSymbol.Content;
                AcceptAndMoveNext();
            }
            Context.CurrentBlock.CodeGenerator = new SectionCodeGenerator(sectionName);

            SourceLocation errorLocation = CurrentLocation;
            ws = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: false));

            // Get the starting brace
            bool sawStartingBrace = At(CSharpSymbolType.LeftBrace);
            if (!sawStartingBrace)
            {
                if (!errorReported)
                {
                    errorReported = true;
                    Context.OnError(errorLocation, RazorResources.ParseError_MissingOpenBraceAfterSection);
                }

                PutCurrentBack();
                PutBack(ws);
                AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: false));
                Optional(CSharpSymbolType.NewLine);
                Output(SpanKind.MetaCode);
                CompleteBlock();
                return;
            }
            else
            {
                Accept(ws);
            }

            // Set up edit handler
            AutoCompleteEditHandler editHandler = new AutoCompleteEditHandler(Language.TokenizeString) { AutoCompleteAtEndOfSpan = true };

            Span.EditHandler = editHandler;
            Span.Accept(CurrentSymbol);

            // Output Metacode then switch to section parser
            Output(SpanKind.MetaCode);
            SectionBlock("{", "}", caseSensitive: true);

            Span.CodeGenerator = SpanCodeGenerator.Null;
            // Check for the terminating "}"
            if (!Optional(CSharpSymbolType.RightBrace))
            {
                editHandler.AutoCompleteString = "}";
                Context.OnError(CurrentLocation,
                                RazorResources.ParseError_Expected_X,
                                Language.GetSample(CSharpSymbolType.RightBrace));
            }
            else
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }
            CompleteBlock(insertMarkerIfNecessary: false, captureWhitespaceToEndOfLine: true);
            Output(SpanKind.MetaCode);
            return;
        }

        protected virtual void FunctionsDirective()
        {
            // Set the block type
            Context.CurrentBlock.Type = BlockType.Functions;

            // Verify we're on "functions" and accept
            AssertDirective(SyntaxConstants.CSharp.FunctionsKeyword);
            Block block = new Block(CurrentSymbol);
            AcceptAndMoveNext();

            AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: false));

            if (!At(CSharpSymbolType.LeftBrace))
            {
                Context.OnError(CurrentLocation,
                                RazorResources.ParseError_Expected_X,
                                Language.GetSample(CSharpSymbolType.LeftBrace));
                CompleteBlock();
                Output(SpanKind.MetaCode);
                return;
            }
            else
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }

            // Capture start point and continue
            SourceLocation blockStart = CurrentLocation;
            AcceptAndMoveNext();

            // Output what we've seen and continue
            Output(SpanKind.MetaCode);

            AutoCompleteEditHandler editHandler = new AutoCompleteEditHandler(Language.TokenizeString);
            Span.EditHandler = editHandler;

            Balance(BalancingModes.NoErrorOnFailure, CSharpSymbolType.LeftBrace, CSharpSymbolType.RightBrace, blockStart);
            Span.CodeGenerator = new TypeMemberCodeGenerator();
            if (!At(CSharpSymbolType.RightBrace))
            {
                editHandler.AutoCompleteString = "}";
                Context.OnError(block.Start, RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, block.Name, "}", "{");
                CompleteBlock();
                Output(SpanKind.Code);
            }
            else
            {
                Output(SpanKind.Code);
                Assert(CSharpSymbolType.RightBrace);
                Span.CodeGenerator = SpanCodeGenerator.Null;
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                AcceptAndMoveNext();
                CompleteBlock();
                Output(SpanKind.MetaCode);
            }
        }

        protected virtual void InheritsDirective()
        {
            // Verify we're on the right keyword and accept
            AssertDirective(SyntaxConstants.CSharp.InheritsKeyword);
            AcceptAndMoveNext();

            InheritsDirectiveCore();
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "directive", Justification = "This only occurs in Release builds, where this method is empty by design")]
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This only occurs in Release builds, where this method is empty by design")]
        [Conditional("DEBUG")]
        protected void AssertDirective(string directive)
        {
            Assert(CSharpSymbolType.Identifier);
            Debug.Assert(String.Equals(CurrentSymbol.Content, directive, StringComparison.Ordinal));
        }

        protected void InheritsDirectiveCore()
        {
            BaseTypeDirective(RazorResources.ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName, baseType => new SetBaseTypeCodeGenerator(baseType));
        }

        protected void BaseTypeDirective(string noTypeNameError, Func<string, SpanCodeGenerator> createCodeGenerator)
        {
            // Set the block type
            Context.CurrentBlock.Type = BlockType.Directive;

            // Accept whitespace
            CSharpSymbol remainingWs = AcceptSingleWhiteSpaceCharacter();

            if (Span.Symbols.Count > 1)
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }

            Output(SpanKind.MetaCode);

            if (remainingWs != null)
            {
                Accept(remainingWs);
            }
            AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true));

            if (EndOfFile || At(CSharpSymbolType.WhiteSpace) || At(CSharpSymbolType.NewLine))
            {
                Context.OnError(CurrentLocation, noTypeNameError);
            }

            // Parse to the end of the line
            AcceptUntil(CSharpSymbolType.NewLine);
            if (!Context.DesignTimeMode)
            {
                // We want the newline to be treated as code, but it causes issues at design-time.
                Optional(CSharpSymbolType.NewLine);
            }

            // Pull out the type name
            string baseType = Span.GetContent();

            // Set up code generation
            Span.CodeGenerator = createCodeGenerator(baseType.Trim());

            // Output the span and finish the block
            CompleteBlock();
            Output(SpanKind.Code);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/CSharpCodeParser.Statements.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class CSharpCodeParser
    {
        private void SetUpKeywords()
        {
            MapKeywords(ConditionalBlock, CSharpKeyword.For, CSharpKeyword.Foreach, CSharpKeyword.While, CSharpKeyword.Switch, CSharpKeyword.Lock);
            MapKeywords(CaseStatement, false, CSharpKeyword.Case, CSharpKeyword.Default);
            MapKeywords(IfStatement, CSharpKeyword.If);
            MapKeywords(TryStatement, CSharpKeyword.Try);
            MapKeywords(UsingKeyword, CSharpKeyword.Using);
            MapKeywords(DoStatement, CSharpKeyword.Do);
            MapKeywords(ReservedDirective, CSharpKeyword.Namespace, CSharpKeyword.Class);
        }

        protected virtual void ReservedDirective(bool topLevel)
        {
            Context.OnError(CurrentLocation, String.Format(CultureInfo.CurrentCulture, RazorResources.ParseError_ReservedWord, CurrentSymbol.Content));
            AcceptAndMoveNext();
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            Span.CodeGenerator = SpanCodeGenerator.Null;
            Context.CurrentBlock.Type = BlockType.Directive;
            CompleteBlock();
            Output(SpanKind.MetaCode);
        }

        private void KeywordBlock(bool topLevel)
        {
            HandleKeyword(topLevel, () =>
            {
                Context.CurrentBlock.Type = BlockType.Expression;
                Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();
                ImplicitExpression();
            });
        }

        private void CaseStatement(bool topLevel)
        {
            Assert(CSharpSymbolType.Keyword);
            Debug.Assert(CurrentSymbol.Keyword != null &&
                         (CurrentSymbol.Keyword.Value == CSharpKeyword.Case ||
                          CurrentSymbol.Keyword.Value == CSharpKeyword.Default));
            AcceptUntil(CSharpSymbolType.Colon);
            Optional(CSharpSymbolType.Colon);
        }

        private void DoStatement(bool topLevel)
        {
            Assert(CSharpKeyword.Do);
            UnconditionalBlock();
            WhileClause();
            if (topLevel)
            {
                CompleteBlock();
            }
        }

        private void WhileClause()
        {
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;
            IEnumerable<CSharpSymbol> ws = SkipToNextImportantToken();

            if (At(CSharpKeyword.While))
            {
                Accept(ws);
                Assert(CSharpKeyword.While);
                AcceptAndMoveNext();
                AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));
                if (AcceptCondition() && Optional(CSharpSymbolType.Semicolon))
                {
                    Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                }
            }
            else
            {
                PutCurrentBack();
                PutBack(ws);
            }
        }

        private void UsingKeyword(bool topLevel)
        {
            Assert(CSharpKeyword.Using);
            Block block = new Block(CurrentSymbol);
            AcceptAndMoveNext();
            AcceptWhile(IsSpacingToken(includeNewLines: false, includeComments: true));

            if (At(CSharpSymbolType.LeftParenthesis))
            {
                // using ( ==> Using Statement
                UsingStatement(block);
            }
            else if (At(CSharpSymbolType.Identifier))
            {
                // using Identifier ==> Using Declaration
                if (!topLevel)
                {
                    Context.OnError(block.Start, RazorResources.ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock);
                    StandardStatement();
                }
                else
                {
                    UsingDeclaration();
                }
            }

            if (topLevel)
            {
                CompleteBlock();
            }
        }

        private void UsingDeclaration()
        {
            // Set block type to directive
            Context.CurrentBlock.Type = BlockType.Directive;

            // Parse a type name
            Assert(CSharpSymbolType.Identifier);
            NamespaceOrTypeName();
            IEnumerable<CSharpSymbol> ws = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: true));
            if (At(CSharpSymbolType.Assign))
            {
                // Alias
                Accept(ws);
                Assert(CSharpSymbolType.Assign);
                AcceptAndMoveNext();

                AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));

                // One more namespace or type name
                NamespaceOrTypeName();
            }
            else
            {
                PutCurrentBack();
                PutBack(ws);
            }

            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.AnyExceptNewline;
            Span.CodeGenerator = new AddImportCodeGenerator(
                Span.GetContent(syms => syms.Skip(1)), // Skip "using"
                SyntaxConstants.CSharp.UsingKeywordLength);

            // Optional ";"
            if (EnsureCurrent())
            {
                Optional(CSharpSymbolType.Semicolon);
            }
        }

        private bool NamespaceOrTypeName()
        {
            if (Optional(CSharpSymbolType.Identifier) || Optional(CSharpSymbolType.Keyword))
            {
                Optional(CSharpSymbolType.QuestionMark); // Nullable
                if (Optional(CSharpSymbolType.DoubleColon))
                {
                    if (!Optional(CSharpSymbolType.Identifier))
                    {
                        Optional(CSharpSymbolType.Keyword);
                    }
                }
                if (At(CSharpSymbolType.LessThan))
                {
                    TypeArgumentList();
                }
                if (Optional(CSharpSymbolType.Dot))
                {
                    NamespaceOrTypeName();
                }
                while (At(CSharpSymbolType.LeftBracket))
                {
                    Balance(BalancingModes.None);
                    Optional(CSharpSymbolType.RightBracket);
                }
                return true;
            }
            else
            {
                return false;
            }
        }

        private void TypeArgumentList()
        {
            Assert(CSharpSymbolType.LessThan);
            Balance(BalancingModes.None);
            Optional(CSharpSymbolType.GreaterThan);
        }

        private void UsingStatement(Block block)
        {
            Assert(CSharpSymbolType.LeftParenthesis);

            // Parse condition
            if (AcceptCondition())
            {
                AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));

                // Parse code block
                ExpectCodeBlock(block);
            }
        }

        private void TryStatement(bool topLevel)
        {
            Assert(CSharpKeyword.Try);
            UnconditionalBlock();
            AfterTryClause();
            if (topLevel)
            {
                CompleteBlock();
            }
        }

        private void IfStatement(bool topLevel)
        {
            Assert(CSharpKeyword.If);
            ConditionalBlock(topLevel: false);
            AfterIfClause();
            if (topLevel)
            {
                CompleteBlock();
            }
        }

        private void AfterTryClause()
        {
            // Grab whitespace
            IEnumerable<CSharpSymbol> ws = SkipToNextImportantToken();

            // Check for a catch or finally part
            if (At(CSharpKeyword.Catch))
            {
                Accept(ws);
                Assert(CSharpKeyword.Catch);
                ConditionalBlock(topLevel: false);
                AfterTryClause();
            }
            else if (At(CSharpKeyword.Finally))
            {
                Accept(ws);
                Assert(CSharpKeyword.Finally);
                UnconditionalBlock();
            }
            else
            {
                // Return whitespace and end the block
                PutCurrentBack();
                PutBack(ws);
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;
            }
        }

        private void AfterIfClause()
        {
            // Grab whitespace and razor comments
            IEnumerable<CSharpSymbol> ws = SkipToNextImportantToken();

            // Check for an else part
            if (At(CSharpKeyword.Else))
            {
                Accept(ws);
                Assert(CSharpKeyword.Else);
                ElseClause();
            }
            else
            {
                // No else, return whitespace
                PutCurrentBack();
                PutBack(ws);
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;
            }
        }

        private void ElseClause()
        {
            if (!At(CSharpKeyword.Else))
            {
                return;
            }
            Block block = new Block(CurrentSymbol);

            AcceptAndMoveNext();
            AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));
            if (At(CSharpKeyword.If))
            {
                // ElseIf
                block.Name = SyntaxConstants.CSharp.ElseIfKeyword;
                ConditionalBlock(block);
                AfterIfClause();
            }
            else if (!EndOfFile)
            {
                // Else
                ExpectCodeBlock(block);
            }
        }

        private void ExpectCodeBlock(Block block)
        {
            if (!EndOfFile)
            {
                // Check for "{" to make sure we're at a block
                if (!At(CSharpSymbolType.LeftBrace))
                {
                    Context.OnError(CurrentLocation,
                                    RazorResources.ParseError_SingleLine_ControlFlowStatements_Not_Allowed,
                                    Language.GetSample(CSharpSymbolType.LeftBrace),
                                    CurrentSymbol.Content);
                }

                // Parse the statement and then we're done
                Statement(block);
            }
        }

        private void UnconditionalBlock()
        {
            Assert(CSharpSymbolType.Keyword);
            Block block = new Block(CurrentSymbol);
            AcceptAndMoveNext();
            AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));
            ExpectCodeBlock(block);
        }

        private void ConditionalBlock(bool topLevel)
        {
            Assert(CSharpSymbolType.Keyword);
            Block block = new Block(CurrentSymbol);
            ConditionalBlock(block);
            if (topLevel)
            {
                CompleteBlock();
            }
        }

        private void ConditionalBlock(Block block)
        {
            AcceptAndMoveNext();
            AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));

            // Parse the condition, if present (if not present, we'll let the C# compiler complain)
            if (AcceptCondition())
            {
                AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));
                ExpectCodeBlock(block);
            }
        }

        private bool AcceptCondition()
        {
            if (At(CSharpSymbolType.LeftParenthesis))
            {
                bool complete = Balance(BalancingModes.BacktrackOnFailure | BalancingModes.AllowCommentsAndTemplates);
                if (!complete)
                {
                    AcceptUntil(CSharpSymbolType.NewLine);
                }
                else
                {
                    Optional(CSharpSymbolType.RightParenthesis);
                }
                return complete;
            }
            return true;
        }

        private void Statement()
        {
            Statement(null);
        }

        private void Statement(Block block)
        {
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;

            // Accept whitespace but always keep the last whitespace node so we can put it back if necessary
            CSharpSymbol lastWs = AcceptWhiteSpaceInLines();
            Debug.Assert(lastWs == null || (lastWs.Start.AbsoluteIndex + lastWs.Content.Length == CurrentLocation.AbsoluteIndex));

            if (EndOfFile)
            {
                if (lastWs != null)
                {
                    Accept(lastWs);
                }
                return;
            }

            CSharpSymbolType type = CurrentSymbol.Type;
            SourceLocation loc = CurrentLocation;

            bool isSingleLineMarkup = type == CSharpSymbolType.Transition && NextIs(CSharpSymbolType.Colon);
            bool isMarkup = isSingleLineMarkup ||
                            type == CSharpSymbolType.LessThan ||
                            (type == CSharpSymbolType.Transition && NextIs(CSharpSymbolType.LessThan));

            if (Context.DesignTimeMode || !isMarkup)
            {
                // CODE owns whitespace, MARKUP owns it ONLY in DesignTimeMode.
                if (lastWs != null)
                {
                    Accept(lastWs);
                }
            }
            else
            {
                // MARKUP owns whitespace EXCEPT in DesignTimeMode.
                PutCurrentBack();
                PutBack(lastWs);
            }

            if (isMarkup)
            {
                if (type == CSharpSymbolType.Transition && !isSingleLineMarkup)
                {
                    Context.OnError(loc, RazorResources.ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start);
                }

                // Markup block
                Output(SpanKind.Code);
                if (Context.DesignTimeMode && CurrentSymbol != null && (CurrentSymbol.Type == CSharpSymbolType.LessThan || CurrentSymbol.Type == CSharpSymbolType.Transition))
                {
                    PutCurrentBack();
                }
                OtherParserBlock();
            }
            else
            {
                // What kind of statement is this?
                HandleStatement(block, type);
            }
        }

        private void HandleStatement(Block block, CSharpSymbolType type)
        {
            switch (type)
            {
                case CSharpSymbolType.RazorCommentTransition:
                    Output(SpanKind.Code);
                    RazorComment();
                    Statement(block);
                    break;
                case CSharpSymbolType.LeftBrace:
                    // Verbatim Block
                    block = block ?? new Block(RazorResources.BlockName_Code, CurrentLocation);
                    AcceptAndMoveNext();
                    CodeBlock(block);
                    break;
                case CSharpSymbolType.Keyword:
                    // Keyword block
                    HandleKeyword(false, StandardStatement);
                    break;
                case CSharpSymbolType.Transition:
                    // Embedded Expression block
                    EmbeddedExpression();
                    break;
                case CSharpSymbolType.RightBrace:
                    // Possible end of Code Block, just run the continuation
                    break;
                case CSharpSymbolType.Comment:
                    AcceptAndMoveNext();
                    break;
                default:
                    // Other statement
                    StandardStatement();
                    break;
            }
        }

        private void EmbeddedExpression()
        {
            // First, verify the type of the block
            Assert(CSharpSymbolType.Transition);
            CSharpSymbol transition = CurrentSymbol;
            NextToken();

            if (At(CSharpSymbolType.Transition))
            {
                // Escaped "@"
                Output(SpanKind.Code);

                // Output "@" as hidden span
                Accept(transition);
                Span.CodeGenerator = SpanCodeGenerator.Null;
                Output(SpanKind.Code);

                Assert(CSharpSymbolType.Transition);
                AcceptAndMoveNext();
                StandardStatement();
            }
            else
            {
                // Throw errors as necessary, but continue parsing
                if (At(CSharpSymbolType.Keyword))
                {
                    Context.OnError(CurrentLocation,
                                    RazorResources.ParseError_Unexpected_Keyword_After_At,
                                    CSharpLanguageCharacteristics.GetKeyword(CurrentSymbol.Keyword.Value));
                }
                else if (At(CSharpSymbolType.LeftBrace))
                {
                    Context.OnError(CurrentLocation, RazorResources.ParseError_Unexpected_Nested_CodeBlock);
                }

                // @( or @foo - Nested expression, parse a child block
                PutCurrentBack();
                PutBack(transition);

                // Before exiting, add a marker span if necessary
                AddMarkerSymbolIfNecessary();

                NestedBlock();
            }
        }

        private void StandardStatement()
        {
            while (!EndOfFile)
            {
                int bookmark = CurrentLocation.AbsoluteIndex;
                IEnumerable<CSharpSymbol> read = ReadWhile(sym => sym.Type != CSharpSymbolType.Semicolon &&
                                                                  sym.Type != CSharpSymbolType.RazorCommentTransition &&
                                                                  sym.Type != CSharpSymbolType.Transition &&
                                                                  sym.Type != CSharpSymbolType.LeftBrace &&
                                                                  sym.Type != CSharpSymbolType.LeftParenthesis &&
                                                                  sym.Type != CSharpSymbolType.LeftBracket &&
                                                                  sym.Type != CSharpSymbolType.RightBrace);
                if (At(CSharpSymbolType.LeftBrace) || At(CSharpSymbolType.LeftParenthesis) || At(CSharpSymbolType.LeftBracket))
                {
                    Accept(read);
                    if (Balance(BalancingModes.AllowCommentsAndTemplates | BalancingModes.BacktrackOnFailure))
                    {
                        Optional(CSharpSymbolType.RightBrace);
                    }
                    else
                    {
                        // Recovery
                        AcceptUntil(CSharpSymbolType.LessThan, CSharpSymbolType.RightBrace);
                        return;
                    }
                }
                else if (At(CSharpSymbolType.Transition) && (NextIs(CSharpSymbolType.LessThan, CSharpSymbolType.Colon)))
                {
                    Accept(read);
                    Output(SpanKind.Code);
                    Template();
                }
                else if (At(CSharpSymbolType.RazorCommentTransition))
                {
                    Accept(read);
                    RazorComment();
                }
                else if (At(CSharpSymbolType.Semicolon))
                {
                    Accept(read);
                    AcceptAndMoveNext();
                    return;
                }
                else if (At(CSharpSymbolType.RightBrace))
                {
                    Accept(read);
                    return;
                }
                else
                {
                    Context.Source.Position = bookmark;
                    NextToken();
                    AcceptUntil(CSharpSymbolType.LessThan, CSharpSymbolType.RightBrace);
                    return;
                }
            }
        }

        private void CodeBlock(Block block)
        {
            CodeBlock(true, block);
        }

        private void CodeBlock(bool acceptTerminatingBrace, Block block)
        {
            EnsureCurrent();
            while (!EndOfFile && !At(CSharpSymbolType.RightBrace))
            {
                // Parse a statement, then return here
                Statement();
                EnsureCurrent();
            }

            if (EndOfFile)
            {
                Context.OnError(block.Start, RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, block.Name, '}', '{');
            }
            else if (acceptTerminatingBrace)
            {
                Assert(CSharpSymbolType.RightBrace);
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                AcceptAndMoveNext();
            }
        }

        private void HandleKeyword(bool topLevel, Action fallback)
        {
            Debug.Assert(CurrentSymbol.Type == CSharpSymbolType.Keyword && CurrentSymbol.Keyword != null);
            Action<bool> handler;
            if (_keywordParsers.TryGetValue(CurrentSymbol.Keyword.Value, out handler))
            {
                handler(topLevel);
            }
            else
            {
                fallback();
            }
        }

        private IEnumerable<CSharpSymbol> SkipToNextImportantToken()
        {
            while (!EndOfFile)
            {
                IEnumerable<CSharpSymbol> ws = ReadWhile(IsSpacingToken(includeNewLines: true, includeComments: true));
                if (At(CSharpSymbolType.RazorCommentTransition))
                {
                    Accept(ws);
                    Span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;
                    RazorComment();
                }
                else
                {
                    return ws;
                }
            }
            return Enumerable.Empty<CSharpSymbol>();
        }

        // Common code for Parsers, but FxCop REALLY doesn't like it in the base class.. moving it here for now.
        protected override void OutputSpanBeforeRazorComment()
        {
            AddMarkerSymbolIfNecessary();
            Output(SpanKind.Code);
        }

        protected class Block
        {
            public Block(string name, SourceLocation start)
            {
                Name = name;
                Start = start;
            }

            public Block(CSharpSymbol symbol)
                : this(GetName(symbol), symbol.Start)
            {
            }

            public string Name { get; set; }
            public SourceLocation Start { get; set; }

            private static string GetName(CSharpSymbol sym)
            {
                if (sym.Type == CSharpSymbolType.Keyword)
                {
                    return CSharpLanguageCharacteristics.GetKeyword(sym.Keyword.Value);
                }
                return sym.Content;
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/CSharpCodeParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class CSharpCodeParser : TokenizerBackedParser<CSharpTokenizer, CSharpSymbol, CSharpSymbolType>
    {
        internal static readonly int UsingKeywordLength = 5; // using

        internal static ISet<string> DefaultKeywords = new HashSet<string>()
        {
            "if",
            "do",
            "try",
            "for",
            "foreach",
            "while",
            "switch",
            "lock",
            "using",
            "section",
            "inherits",
            "helper",
            "functions",
            "namespace",
            "class",
            "layout",
            "sessionstate"
        };

        private Dictionary<string, Action> _directiveParsers = new Dictionary<string, Action>();
        private Dictionary<CSharpKeyword, Action<bool>> _keywordParsers = new Dictionary<CSharpKeyword, Action<bool>>();

        public CSharpCodeParser()
        {
            Keywords = new HashSet<string>();
            SetUpKeywords();
            SetupDirectives();
        }

        protected internal ISet<string> Keywords { get; private set; }

        public bool IsNested { get; set; }

        protected override ParserBase OtherParser
        {
            get { return Context.MarkupParser; }
        }

        protected override LanguageCharacteristics<CSharpTokenizer, CSharpSymbol, CSharpSymbolType> Language
        {
            get { return CSharpLanguageCharacteristics.Instance; }
        }

        protected void MapDirectives(Action handler, params string[] directives)
        {
            foreach (string directive in directives)
            {
                _directiveParsers.Add(directive, handler);
                Keywords.Add(directive);
            }
        }

        protected bool TryGetDirectiveHandler(string directive, out Action handler)
        {
            return _directiveParsers.TryGetValue(directive, out handler);
        }

        private void MapKeywords(Action<bool> handler, params CSharpKeyword[] keywords)
        {
            MapKeywords(handler, topLevel: true, keywords: keywords);
        }

        private void MapKeywords(Action<bool> handler, bool topLevel, params CSharpKeyword[] keywords)
        {
            foreach (CSharpKeyword keyword in keywords)
            {
                _keywordParsers.Add(keyword, handler);
                if (topLevel)
                {
                    Keywords.Add(CSharpLanguageCharacteristics.GetKeyword(keyword));
                }
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This only occurs in Release builds, where this method is empty by design")]
        [Conditional("DEBUG")]
        internal void Assert(CSharpKeyword expectedKeyword)
        {
            Debug.Assert(CurrentSymbol.Type == CSharpSymbolType.Keyword && CurrentSymbol.Keyword.HasValue && CurrentSymbol.Keyword.Value == expectedKeyword);
        }

        protected internal bool At(CSharpKeyword keyword)
        {
            return At(CSharpSymbolType.Keyword) && CurrentSymbol.Keyword.HasValue && CurrentSymbol.Keyword.Value == keyword;
        }

        protected internal bool AcceptIf(CSharpKeyword keyword)
        {
            if (At(keyword))
            {
                AcceptAndMoveNext();
                return true;
            }
            return false;
        }

        protected static Func<CSharpSymbol, bool> IsSpacingToken(bool includeNewLines, bool includeComments)
        {
            return sym => sym.Type == CSharpSymbolType.WhiteSpace ||
                          (includeNewLines && sym.Type == CSharpSymbolType.NewLine) ||
                          (includeComments && sym.Type == CSharpSymbolType.Comment);
        }

        public override void ParseBlock()
        {
            using (PushSpanConfig(DefaultSpanConfig))
            {
                if (Context == null)
                {
                    throw new InvalidOperationException(RazorResources.Parser_Context_Not_Set);
                }

                // Unless changed, the block is a statement block
                using (Context.StartBlock(BlockType.Statement))
                {
                    NextToken();

                    AcceptWhile(IsSpacingToken(includeNewLines: true, includeComments: true));

                    CSharpSymbol current = CurrentSymbol;
                    if (At(CSharpSymbolType.StringLiteral) && CurrentSymbol.Content.Length > 0 && CurrentSymbol.Content[0] == SyntaxConstants.TransitionCharacter)
                    {
                        Tuple<CSharpSymbol, CSharpSymbol> split = Language.SplitSymbol(CurrentSymbol, 1, CSharpSymbolType.Transition);
                        current = split.Item1;
                        Context.Source.Position = split.Item2.Start.AbsoluteIndex;
                        NextToken();
                    }
                    else if (At(CSharpSymbolType.Transition))
                    {
                        NextToken();
                    }

                    // Accept "@" if we see it, but if we don't, that's OK. We assume we were started for a good reason
                    if (current.Type == CSharpSymbolType.Transition)
                    {
                        if (Span.Symbols.Count > 0)
                        {
                            Output(SpanKind.Code);
                        }
                        AtTransition(current);
                    }
                    else
                    {
                        // No "@" => Jump straight to AfterTransition
                        AfterTransition();
                    }
                    Output(SpanKind.Code);
                }
            }
        }

        private void DefaultSpanConfig(SpanBuilder span)
        {
            span.EditHandler = SpanEditHandler.CreateDefault(Language.TokenizeString);
            span.CodeGenerator = new StatementCodeGenerator();
        }

        private void AtTransition(CSharpSymbol current)
        {
            Debug.Assert(current.Type == CSharpSymbolType.Transition);
            Accept(current);
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            Span.CodeGenerator = SpanCodeGenerator.Null;

            // Output the "@" span and continue here
            Output(SpanKind.Transition);
            AfterTransition();
        }

        private void AfterTransition()
        {
            using (PushSpanConfig(DefaultSpanConfig))
            {
                EnsureCurrent();
                try
                {
                    // What type of block is this?
                    if (!EndOfFile)
                    {
                        if (CurrentSymbol.Type == CSharpSymbolType.LeftParenthesis)
                        {
                            Context.CurrentBlock.Type = BlockType.Expression;
                            Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();
                            ExplicitExpression();
                            return;
                        }
                        else if (CurrentSymbol.Type == CSharpSymbolType.Identifier)
                        {
                            Action handler;
                            if (TryGetDirectiveHandler(CurrentSymbol.Content, out handler))
                            {
                                Span.CodeGenerator = SpanCodeGenerator.Null;
                                handler();
                                return;
                            }
                            else
                            {
                                Context.CurrentBlock.Type = BlockType.Expression;
                                Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();
                                ImplicitExpression();
                                return;
                            }
                        }
                        else if (CurrentSymbol.Type == CSharpSymbolType.Keyword)
                        {
                            KeywordBlock(topLevel: true);
                            return;
                        }
                        else if (CurrentSymbol.Type == CSharpSymbolType.LeftBrace)
                        {
                            VerbatimBlock();
                            return;
                        }
                    }

                    // Invalid character
                    Context.CurrentBlock.Type = BlockType.Expression;
                    Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();
                    AddMarkerSymbolIfNecessary();
                    Span.CodeGenerator = new ExpressionCodeGenerator();
                    Span.EditHandler = new ImplicitExpressionEditHandler(
                        Language.TokenizeString,
                        DefaultKeywords,
                        acceptTrailingDot: IsNested)
                        {
                            AcceptedCharacters = AcceptedCharacters.NonWhiteSpace
                        };
                    if (At(CSharpSymbolType.WhiteSpace) || At(CSharpSymbolType.NewLine))
                    {
                        Context.OnError(CurrentLocation, RazorResources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_CS);
                    }
                    else if (EndOfFile)
                    {
                        Context.OnError(CurrentLocation, RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock);
                    }
                    else
                    {
                        Context.OnError(CurrentLocation, RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS, CurrentSymbol.Content);
                    }
                }
                finally
                {
                    // Always put current character back in the buffer for the next parser.
                    PutCurrentBack();
                }
            }
        }

        private void VerbatimBlock()
        {
            Assert(CSharpSymbolType.LeftBrace);
            Block block = new Block(RazorResources.BlockName_Code, CurrentLocation);
            AcceptAndMoveNext();

            // Set up the "{" span and output
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            Span.CodeGenerator = SpanCodeGenerator.Null;
            Output(SpanKind.MetaCode);

            // Set up auto-complete and parse the code block
            AutoCompleteEditHandler editHandler = new AutoCompleteEditHandler(Language.TokenizeString);
            Span.EditHandler = editHandler;
            CodeBlock(false, block);

            Span.CodeGenerator = new StatementCodeGenerator();
            AddMarkerSymbolIfNecessary();
            if (!At(CSharpSymbolType.RightBrace))
            {
                editHandler.AutoCompleteString = "}";
            }
            Output(SpanKind.Code);

            if (Optional(CSharpSymbolType.RightBrace))
            {
                // Set up the "}" span
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                Span.CodeGenerator = SpanCodeGenerator.Null;
            }

            if (!At(CSharpSymbolType.WhiteSpace) && !At(CSharpSymbolType.NewLine))
            {
                PutCurrentBack();
            }

            CompleteBlock(insertMarkerIfNecessary: false);
            Output(SpanKind.MetaCode);
        }

        private void ImplicitExpression()
        {
            Context.CurrentBlock.Type = BlockType.Expression;
            Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();

            using (PushSpanConfig(span =>
            {
                span.EditHandler = new ImplicitExpressionEditHandler(Language.TokenizeString, Keywords, acceptTrailingDot: IsNested);
                span.EditHandler.AcceptedCharacters = AcceptedCharacters.NonWhiteSpace;
                span.CodeGenerator = new ExpressionCodeGenerator();
            }))
            {
                do
                {
                    if (AtIdentifier(allowKeywords: true))
                    {
                        AcceptAndMoveNext();
                    }
                }
                while (MethodCallOrArrayIndex());

                PutCurrentBack();
                Output(SpanKind.Code);
            }
        }

        private bool MethodCallOrArrayIndex()
        {
            if (!EndOfFile)
            {
                if (CurrentSymbol.Type == CSharpSymbolType.LeftParenthesis || CurrentSymbol.Type == CSharpSymbolType.LeftBracket)
                {
                    // If we end within "(", whitespace is fine
                    Span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;

                    CSharpSymbolType right;
                    bool success;

                    using (PushSpanConfig((span, prev) =>
                    {
                        prev(span);
                        span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;
                    }))
                    {
                        right = Language.FlipBracket(CurrentSymbol.Type);
                        success = Balance(BalancingModes.BacktrackOnFailure | BalancingModes.AllowCommentsAndTemplates);
                    }

                    if (!success)
                    {
                        AcceptUntil(CSharpSymbolType.LessThan);
                    }
                    if (At(right))
                    {
                        AcceptAndMoveNext();
                        Span.EditHandler.AcceptedCharacters = AcceptedCharacters.NonWhiteSpace;
                    }
                    return MethodCallOrArrayIndex();
                }
                if (CurrentSymbol.Type == CSharpSymbolType.Dot)
                {
                    CSharpSymbol dot = CurrentSymbol;
                    if (NextToken())
                    {
                        if (At(CSharpSymbolType.Identifier) || At(CSharpSymbolType.Keyword))
                        {
                            // Accept the dot and return to the start
                            Accept(dot);
                            return true; // continue
                        }
                        else
                        {
                            // Put the symbol back
                            PutCurrentBack();
                        }
                    }
                    if (!IsNested)
                    {
                        // Put the "." back
                        PutBack(dot);
                    }
                    else
                    {
                        Accept(dot);
                    }
                }
                else if (!At(CSharpSymbolType.WhiteSpace) && !At(CSharpSymbolType.NewLine))
                {
                    PutCurrentBack();
                }
            }

            // Implicit Expression is complete
            return false;
        }

        private void CompleteBlock()
        {
            CompleteBlock(insertMarkerIfNecessary: true);
        }

        private void CompleteBlock(bool insertMarkerIfNecessary)
        {
            CompleteBlock(insertMarkerIfNecessary, captureWhitespaceToEndOfLine: insertMarkerIfNecessary);
        }

        private void CompleteBlock(bool insertMarkerIfNecessary, bool captureWhitespaceToEndOfLine)
        {
            if (insertMarkerIfNecessary && Context.LastAcceptedCharacters != AcceptedCharacters.Any)
            {
                AddMarkerSymbolIfNecessary();
            }

            EnsureCurrent();

            // Read whitespace, but not newlines
            // If we're not inserting a marker span, we don't need to capture whitespace
            if (!Context.WhiteSpaceIsSignificantToAncestorBlock &&
                Context.CurrentBlock.Type != BlockType.Expression &&
                captureWhitespaceToEndOfLine &&
                !Context.DesignTimeMode &&
                !IsNested)
            {
                CaptureWhitespaceAtEndOfCodeOnlyLine();
            }
            else
            {
                PutCurrentBack();
            }
        }

        private void CaptureWhitespaceAtEndOfCodeOnlyLine()
        {
            IEnumerable<CSharpSymbol> ws = ReadWhile(sym => sym.Type == CSharpSymbolType.WhiteSpace);
            if (At(CSharpSymbolType.NewLine))
            {
                Accept(ws);
                AcceptAndMoveNext();
                PutCurrentBack();
            }
            else
            {
                PutCurrentBack();
                PutBack(ws);
            }
        }

        private void ConfigureExplicitExpressionSpan(SpanBuilder sb)
        {
            sb.EditHandler = SpanEditHandler.CreateDefault(Language.TokenizeString);
            sb.CodeGenerator = new ExpressionCodeGenerator();
        }

        private void ExplicitExpression()
        {
            Block block = new Block(RazorResources.BlockName_ExplicitExpression, CurrentLocation);
            Assert(CSharpSymbolType.LeftParenthesis);
            AcceptAndMoveNext();
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            Span.CodeGenerator = SpanCodeGenerator.Null;
            Output(SpanKind.MetaCode);
            using (PushSpanConfig(ConfigureExplicitExpressionSpan))
            {
                bool success = Balance(
                    BalancingModes.BacktrackOnFailure | BalancingModes.NoErrorOnFailure | BalancingModes.AllowCommentsAndTemplates,
                    CSharpSymbolType.LeftParenthesis,
                    CSharpSymbolType.RightParenthesis,
                    block.Start);

                if (!success)
                {
                    AcceptUntil(CSharpSymbolType.LessThan);
                    Context.OnError(block.Start, RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, block.Name, ")", "(");
                }

                // If necessary, put an empty-content marker symbol here
                if (Span.Symbols.Count == 0)
                {
                    Accept(new CSharpSymbol(CurrentLocation, String.Empty, CSharpSymbolType.Unknown));
                }

                // Output the content span and then capture the ")"
                Output(SpanKind.Code);
            }
            Optional(CSharpSymbolType.RightParenthesis);
            if (!EndOfFile)
            {
                PutCurrentBack();
            }
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            Span.CodeGenerator = SpanCodeGenerator.Null;
            CompleteBlock(insertMarkerIfNecessary: false);
            Output(SpanKind.MetaCode);
        }

        private void Template()
        {
            if (Context.IsWithin(BlockType.Template))
            {
                Context.OnError(CurrentLocation, RazorResources.ParseError_InlineMarkup_Blocks_Cannot_Be_Nested);
            }
            Output(SpanKind.Code);
            using (Context.StartBlock(BlockType.Template))
            {
                Context.CurrentBlock.CodeGenerator = new TemplateBlockCodeGenerator();
                PutCurrentBack();
                OtherParserBlock();
            }
        }

        private void OtherParserBlock()
        {
            ParseWithOtherParser(p => p.ParseBlock());
        }

        private void SectionBlock(string left, string right, bool caseSensitive)
        {
            ParseWithOtherParser(p => p.ParseSection(Tuple.Create(left, right), caseSensitive));
        }

        private void NestedBlock()
        {
            Output(SpanKind.Code);
            bool wasNested = IsNested;
            IsNested = true;
            using (PushSpanConfig())
            {
                ParseBlock();
            }
            Initialize(Span);
            IsNested = wasNested;
            NextToken();
        }

        protected override bool IsAtEmbeddedTransition(bool allowTemplatesAndComments, bool allowTransitions)
        {
            // No embedded transitions in C#, so ignore that param
            return allowTemplatesAndComments
                   && ((Language.IsTransition(CurrentSymbol)
                        && NextIs(CSharpSymbolType.LessThan, CSharpSymbolType.Colon))
                       || Language.IsCommentStart(CurrentSymbol));
        }

        protected override void HandleEmbeddedTransition()
        {
            if (Language.IsTransition(CurrentSymbol))
            {
                PutCurrentBack();
                Template();
            }
            else if (Language.IsCommentStart(CurrentSymbol))
            {
                RazorComment();
            }
        }

        private void ParseWithOtherParser(Action<ParserBase> parseAction)
        {
            using (PushSpanConfig())
            {
                Context.SwitchActiveParser();
                parseAction(Context.MarkupParser);
                Context.SwitchActiveParser();
            }
            Initialize(Span);
            NextToken();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/CSharpLanguageCharacteristics.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public class CSharpLanguageCharacteristics : LanguageCharacteristics<CSharpTokenizer, CSharpSymbol, CSharpSymbolType>
    {
        private static readonly CSharpLanguageCharacteristics _instance = new CSharpLanguageCharacteristics();

        private static Dictionary<CSharpSymbolType, string> _symbolSamples = new Dictionary<CSharpSymbolType, string>()
        {
            { CSharpSymbolType.Arrow, "->" },
            { CSharpSymbolType.Minus, "-" },
            { CSharpSymbolType.Decrement, "--" },
            { CSharpSymbolType.MinusAssign, "-=" },
            { CSharpSymbolType.NotEqual, "!=" },
            { CSharpSymbolType.Not, "!" },
            { CSharpSymbolType.Modulo, "%" },
            { CSharpSymbolType.ModuloAssign, "%=" },
            { CSharpSymbolType.AndAssign, "&=" },
            { CSharpSymbolType.And, "&" },
            { CSharpSymbolType.DoubleAnd, "&&" },
            { CSharpSymbolType.LeftParenthesis, "(" },
            { CSharpSymbolType.RightParenthesis, ")" },
            { CSharpSymbolType.Star, "*" },
            { CSharpSymbolType.MultiplyAssign, "*=" },
            { CSharpSymbolType.Comma, "," },
            { CSharpSymbolType.Dot, "." },
            { CSharpSymbolType.Slash, "/" },
            { CSharpSymbolType.DivideAssign, "/=" },
            { CSharpSymbolType.DoubleColon, "::" },
            { CSharpSymbolType.Colon, ":" },
            { CSharpSymbolType.Semicolon, ";" },
            { CSharpSymbolType.QuestionMark, "?" },
            { CSharpSymbolType.NullCoalesce, "??" },
            { CSharpSymbolType.RightBracket, "]" },
            { CSharpSymbolType.LeftBracket, "[" },
            { CSharpSymbolType.XorAssign, "^=" },
            { CSharpSymbolType.Xor, "^" },
            { CSharpSymbolType.LeftBrace, "{" },
            { CSharpSymbolType.OrAssign, "|=" },
            { CSharpSymbolType.DoubleOr, "||" },
            { CSharpSymbolType.Or, "|" },
            { CSharpSymbolType.RightBrace, "}" },
            { CSharpSymbolType.Tilde, "~" },
            { CSharpSymbolType.Plus, "+" },
            { CSharpSymbolType.PlusAssign, "+=" },
            { CSharpSymbolType.Increment, "++" },
            { CSharpSymbolType.LessThan, "<" },
            { CSharpSymbolType.LessThanEqual, "<=" },
            { CSharpSymbolType.LeftShift, "<<" },
            { CSharpSymbolType.LeftShiftAssign, "<<=" },
            { CSharpSymbolType.Assign, "=" },
            { CSharpSymbolType.Equals, "==" },
            { CSharpSymbolType.GreaterThan, ">" },
            { CSharpSymbolType.GreaterThanEqual, ">=" },
            { CSharpSymbolType.RightShift, ">>" },
            { CSharpSymbolType.RightShiftAssign, ">>>" },
            { CSharpSymbolType.Hash, "#" },
            { CSharpSymbolType.Transition, "@" },
        };

        private CSharpLanguageCharacteristics()
        {
        }

        public static CSharpLanguageCharacteristics Instance
        {
            get { return _instance; }
        }

        public override CSharpTokenizer CreateTokenizer(ITextDocument source)
        {
            return new CSharpTokenizer(source);
        }

        protected override CSharpSymbol CreateSymbol(SourceLocation location, string content, CSharpSymbolType type, IEnumerable<RazorError> errors)
        {
            return new CSharpSymbol(location, content, type, errors);
        }

        public override string GetSample(CSharpSymbolType type)
        {
            return GetSymbolSample(type);
        }

        public override CSharpSymbol CreateMarkerSymbol(SourceLocation location)
        {
            return new CSharpSymbol(location, String.Empty, CSharpSymbolType.Unknown);
        }

        public override CSharpSymbolType GetKnownSymbolType(KnownSymbolType type)
        {
            switch (type)
            {
                case KnownSymbolType.Identifier:
                    return CSharpSymbolType.Identifier;
                case KnownSymbolType.Keyword:
                    return CSharpSymbolType.Keyword;
                case KnownSymbolType.NewLine:
                    return CSharpSymbolType.NewLine;
                case KnownSymbolType.WhiteSpace:
                    return CSharpSymbolType.WhiteSpace;
                case KnownSymbolType.Transition:
                    return CSharpSymbolType.Transition;
                case KnownSymbolType.CommentStart:
                    return CSharpSymbolType.RazorCommentTransition;
                case KnownSymbolType.CommentStar:
                    return CSharpSymbolType.RazorCommentStar;
                case KnownSymbolType.CommentBody:
                    return CSharpSymbolType.RazorComment;
                default:
                    return CSharpSymbolType.Unknown;
            }
        }

        public override CSharpSymbolType FlipBracket(CSharpSymbolType bracket)
        {
            switch (bracket)
            {
                case CSharpSymbolType.LeftBrace:
                    return CSharpSymbolType.RightBrace;
                case CSharpSymbolType.LeftBracket:
                    return CSharpSymbolType.RightBracket;
                case CSharpSymbolType.LeftParenthesis:
                    return CSharpSymbolType.RightParenthesis;
                case CSharpSymbolType.LessThan:
                    return CSharpSymbolType.GreaterThan;
                case CSharpSymbolType.RightBrace:
                    return CSharpSymbolType.LeftBrace;
                case CSharpSymbolType.RightBracket:
                    return CSharpSymbolType.LeftBracket;
                case CSharpSymbolType.RightParenthesis:
                    return CSharpSymbolType.LeftParenthesis;
                case CSharpSymbolType.GreaterThan:
                    return CSharpSymbolType.LessThan;
                default:
                    Debug.Fail("FlipBracket must be called with a bracket character");
                    return CSharpSymbolType.Unknown;
            }
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "C# Keywords are lower-case")]
        public static string GetKeyword(CSharpKeyword keyword)
        {
            return keyword.ToString().ToLowerInvariant();
        }

        public static string GetSymbolSample(CSharpSymbolType type)
        {
            string sample;
            if (!_symbolSamples.TryGetValue(type, out sample))
            {
                switch (type)
                {
                    case CSharpSymbolType.Identifier:
                        return RazorResources.CSharpSymbol_Identifier;
                    case CSharpSymbolType.Keyword:
                        return RazorResources.CSharpSymbol_Keyword;
                    case CSharpSymbolType.IntegerLiteral:
                        return RazorResources.CSharpSymbol_IntegerLiteral;
                    case CSharpSymbolType.NewLine:
                        return RazorResources.CSharpSymbol_Newline;
                    case CSharpSymbolType.WhiteSpace:
                        return RazorResources.CSharpSymbol_Whitespace;
                    case CSharpSymbolType.Comment:
                        return RazorResources.CSharpSymbol_Comment;
                    case CSharpSymbolType.RealLiteral:
                        return RazorResources.CSharpSymbol_RealLiteral;
                    case CSharpSymbolType.CharacterLiteral:
                        return RazorResources.CSharpSymbol_CharacterLiteral;
                    case CSharpSymbolType.StringLiteral:
                        return RazorResources.CSharpSymbol_StringLiteral;
                    default:
                        return RazorResources.Symbol_Unknown;
                }
            }
            return sample;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/CallbackVisitor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Parser
{
    public class CallbackVisitor : ParserVisitor
    {
        private Action<Span> _spanCallback;
        private Action<RazorError> _errorCallback;
        private Action<BlockType> _endBlockCallback;
        private Action<BlockType> _startBlockCallback;
        private Action _completeCallback;

        public CallbackVisitor(Action<Span> spanCallback)
            : this(spanCallback, _ =>
            {
            })
        {
        }

        public CallbackVisitor(Action<Span> spanCallback, Action<RazorError> errorCallback)
            : this(spanCallback, errorCallback, _ =>
            {
            }, _ =>
            {
            })
        {
        }

        public CallbackVisitor(Action<Span> spanCallback, Action<RazorError> errorCallback, Action<BlockType> startBlockCallback, Action<BlockType> endBlockCallback)
            : this(spanCallback, errorCallback, startBlockCallback, endBlockCallback, () =>
            {
            })
        {
        }

        public CallbackVisitor(Action<Span> spanCallback, Action<RazorError> errorCallback, Action<BlockType> startBlockCallback, Action<BlockType> endBlockCallback, Action completeCallback)
        {
            _spanCallback = spanCallback;
            _errorCallback = errorCallback;
            _startBlockCallback = startBlockCallback;
            _endBlockCallback = endBlockCallback;
            _completeCallback = completeCallback;
        }

        public SynchronizationContext SynchronizationContext { get; set; }

        public override void VisitStartBlock(Block block)
        {
            base.VisitStartBlock(block);
            RaiseCallback(SynchronizationContext, block.Type, _startBlockCallback);
        }

        public override void VisitSpan(Span span)
        {
            base.VisitSpan(span);
            RaiseCallback(SynchronizationContext, span, _spanCallback);
        }

        public override void VisitEndBlock(Block block)
        {
            base.VisitEndBlock(block);
            RaiseCallback(SynchronizationContext, block.Type, _endBlockCallback);
        }

        public override void VisitError(RazorError err)
        {
            base.VisitError(err);
            RaiseCallback(SynchronizationContext, err, _errorCallback);
        }

        public override void OnComplete()
        {
            base.OnComplete();
            RaiseCallback<object>(SynchronizationContext, null, _ => _completeCallback());
        }

        private static void RaiseCallback<T>(SynchronizationContext syncContext, T param, Action<T> callback)
        {
            if (callback != null)
            {
                if (syncContext != null)
                {
                    syncContext.Post(state => callback((T)state), param);
                }
                else
                {
                    callback(param);
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/ConditionalAttributeCollapser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;

namespace System.Web.Razor.Parser
{
    internal class ConditionalAttributeCollapser : MarkupRewriter
    {
        public ConditionalAttributeCollapser(Action<SpanBuilder, SourceLocation, string> markupSpanFactory) : base(markupSpanFactory)
        {
        }

        protected override bool CanRewrite(Block block)
        {
            AttributeBlockCodeGenerator gen = block.CodeGenerator as AttributeBlockCodeGenerator;
            return gen != null && block.Children.Any() && block.Children.All(IsLiteralAttributeValue);
        }

        protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
        {
            // Collect the content of this node
            string content = String.Concat(block.Children.Cast<Span>().Select(s => s.Content));

            // Create a new span containing this content
            SpanBuilder span = new SpanBuilder();
            span.EditHandler = new SpanEditHandler(HtmlTokenizer.Tokenize);
            FillSpan(span, block.Children.Cast<Span>().First().Start, content);
            return span.Build();
        }

        private bool IsLiteralAttributeValue(SyntaxTreeNode node)
        {
            if (node.IsBlock)
            {
                return false;
            }
            Span span = node as Span;
            Debug.Assert(span != null);

            LiteralAttributeCodeGenerator litGen = span.CodeGenerator as LiteralAttributeCodeGenerator;

            return span != null &&
                   ((litGen != null && litGen.ValueGenerator == null) ||
                    span.CodeGenerator == SpanCodeGenerator.Null ||
                    span.CodeGenerator is MarkupCodeGenerator);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/HtmlLanguageCharacteristics.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public class HtmlLanguageCharacteristics : LanguageCharacteristics<HtmlTokenizer, HtmlSymbol, HtmlSymbolType>
    {
        private static readonly HtmlLanguageCharacteristics _instance = new HtmlLanguageCharacteristics();

        private HtmlLanguageCharacteristics()
        {
        }

        public static HtmlLanguageCharacteristics Instance
        {
            get { return _instance; }
        }

        public override string GetSample(HtmlSymbolType type)
        {
            switch (type)
            {
                case HtmlSymbolType.Text:
                    return RazorResources.HtmlSymbol_Text;
                case HtmlSymbolType.WhiteSpace:
                    return RazorResources.HtmlSymbol_WhiteSpace;
                case HtmlSymbolType.NewLine:
                    return RazorResources.HtmlSymbol_NewLine;
                case HtmlSymbolType.OpenAngle:
                    return "<";
                case HtmlSymbolType.Bang:
                    return "!";
                case HtmlSymbolType.Solidus:
                    return "/";
                case HtmlSymbolType.QuestionMark:
                    return "?";
                case HtmlSymbolType.DoubleHyphen:
                    return "--";
                case HtmlSymbolType.LeftBracket:
                    return "[";
                case HtmlSymbolType.CloseAngle:
                    return ">";
                case HtmlSymbolType.RightBracket:
                    return "]";
                case HtmlSymbolType.Equals:
                    return "=";
                case HtmlSymbolType.DoubleQuote:
                    return "\"";
                case HtmlSymbolType.SingleQuote:
                    return "'";
                case HtmlSymbolType.Transition:
                    return "@";
                case HtmlSymbolType.Colon:
                    return ":";
                case HtmlSymbolType.RazorComment:
                    return RazorResources.HtmlSymbol_RazorComment;
                case HtmlSymbolType.RazorCommentStar:
                    return "*";
                case HtmlSymbolType.RazorCommentTransition:
                    return "@";
                default:
                    return RazorResources.Symbol_Unknown;
            }
        }

        public override HtmlTokenizer CreateTokenizer(ITextDocument source)
        {
            return new HtmlTokenizer(source);
        }

        public override HtmlSymbolType FlipBracket(HtmlSymbolType bracket)
        {
            switch (bracket)
            {
                case HtmlSymbolType.LeftBracket:
                    return HtmlSymbolType.RightBracket;
                case HtmlSymbolType.OpenAngle:
                    return HtmlSymbolType.CloseAngle;
                case HtmlSymbolType.RightBracket:
                    return HtmlSymbolType.LeftBracket;
                case HtmlSymbolType.CloseAngle:
                    return HtmlSymbolType.OpenAngle;
                default:
                    Debug.Fail("FlipBracket must be called with a bracket character");
                    return HtmlSymbolType.Unknown;
            }
        }

        public override HtmlSymbol CreateMarkerSymbol(SourceLocation location)
        {
            return new HtmlSymbol(location, String.Empty, HtmlSymbolType.Unknown);
        }

        public override HtmlSymbolType GetKnownSymbolType(KnownSymbolType type)
        {
            switch (type)
            {
                case KnownSymbolType.CommentStart:
                    return HtmlSymbolType.RazorCommentTransition;
                case KnownSymbolType.CommentStar:
                    return HtmlSymbolType.RazorCommentStar;
                case KnownSymbolType.CommentBody:
                    return HtmlSymbolType.RazorComment;
                case KnownSymbolType.Identifier:
                    return HtmlSymbolType.Text;
                case KnownSymbolType.Keyword:
                    return HtmlSymbolType.Text;
                case KnownSymbolType.NewLine:
                    return HtmlSymbolType.NewLine;
                case KnownSymbolType.Transition:
                    return HtmlSymbolType.Transition;
                case KnownSymbolType.WhiteSpace:
                    return HtmlSymbolType.WhiteSpace;
                default:
                    return HtmlSymbolType.Unknown;
            }
        }

        protected override HtmlSymbol CreateSymbol(SourceLocation location, string content, HtmlSymbolType type, IEnumerable<RazorError> errors)
        {
            return new HtmlSymbol(location, content, type, errors);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/HtmlMarkupParser.Block.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class HtmlMarkupParser
    {
        private SourceLocation _lastTagStart = SourceLocation.Zero;
        private HtmlSymbol _bufferedOpenAngle;

        public override void ParseBlock()
        {
            if (Context == null)
            {
                throw new InvalidOperationException(RazorResources.Parser_Context_Not_Set);
            }

            using (PushSpanConfig(DefaultMarkupSpan))
            {
                using (Context.StartBlock(BlockType.Markup))
                {
                    if (!NextToken())
                    {
                        return;
                    }

                    AcceptWhile(IsSpacingToken(includeNewLines: true));

                    if (CurrentSymbol.Type == HtmlSymbolType.OpenAngle)
                    {
                        // "<" => Implicit Tag Block
                        TagBlock(new Stack<Tuple<HtmlSymbol, SourceLocation>>());
                    }
                    else if (CurrentSymbol.Type == HtmlSymbolType.Transition)
                    {
                        // "@" => Explicit Tag/Single Line Block OR Template
                        Output(SpanKind.Markup);

                        // Definitely have a transition span
                        Assert(HtmlSymbolType.Transition);
                        AcceptAndMoveNext();
                        Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                        Span.CodeGenerator = SpanCodeGenerator.Null;
                        Output(SpanKind.Transition);
                        if (At(HtmlSymbolType.Transition))
                        {
                            Span.CodeGenerator = SpanCodeGenerator.Null;
                            AcceptAndMoveNext();
                            Output(SpanKind.MetaCode);
                        }
                        AfterTransition();
                    }
                    else
                    {
                        Context.OnError(CurrentSymbol.Start, RazorResources.ParseError_MarkupBlock_Must_Start_With_Tag);
                    }
                    Output(SpanKind.Markup);
                }
            }
        }

        private void DefaultMarkupSpan(SpanBuilder span)
        {
            span.CodeGenerator = new MarkupCodeGenerator();
            span.EditHandler = new SpanEditHandler(Language.TokenizeString, AcceptedCharacters.Any);
        }

        private void AfterTransition()
        {
            // "@:" => Explicit Single Line Block
            if (CurrentSymbol.Type == HtmlSymbolType.Text && CurrentSymbol.Content.Length > 0 && CurrentSymbol.Content[0] == ':')
            {
                // Split the token
                Tuple<HtmlSymbol, HtmlSymbol> split = Language.SplitSymbol(CurrentSymbol, 1, HtmlSymbolType.Colon);

                // The first part (left) is added to this span and we return a MetaCode span
                Accept(split.Item1);
                Span.CodeGenerator = SpanCodeGenerator.Null;
                Output(SpanKind.MetaCode);
                if (split.Item2 != null)
                {
                    Accept(split.Item2);
                }
                NextToken();
                SingleLineMarkup();
            }
            else if (CurrentSymbol.Type == HtmlSymbolType.OpenAngle)
            {
                TagBlock(new Stack<Tuple<HtmlSymbol, SourceLocation>>());
            }
        }

        private void SingleLineMarkup()
        {
            // Parse until a newline, it's that simple!
            // First, signal to code parser that whitespace is significant to us.
            bool old = Context.WhiteSpaceIsSignificantToAncestorBlock;
            Context.WhiteSpaceIsSignificantToAncestorBlock = true;
            Span.EditHandler = new SingleLineMarkupEditHandler(Language.TokenizeString);
            SkipToAndParseCode(HtmlSymbolType.NewLine);
            if (!EndOfFile && CurrentSymbol.Type == HtmlSymbolType.NewLine)
            {
                AcceptAndMoveNext();
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }
            PutCurrentBack();
            Context.WhiteSpaceIsSignificantToAncestorBlock = old;
            Output(SpanKind.Markup);
        }

        private void TagBlock(Stack<Tuple<HtmlSymbol, SourceLocation>> tags)
        {
            // Skip Whitespace and Text
            bool complete = false;
            do
            {
                SkipToAndParseCode(HtmlSymbolType.OpenAngle);
                if (EndOfFile)
                {
                    EndTagBlock(tags, complete: true);
                }
                else
                {
                    _bufferedOpenAngle = null;
                    _lastTagStart = CurrentLocation;
                    Assert(HtmlSymbolType.OpenAngle);
                    _bufferedOpenAngle = CurrentSymbol;
                    SourceLocation tagStart = CurrentLocation;
                    if (!NextToken())
                    {
                        Accept(_bufferedOpenAngle);
                        EndTagBlock(tags, complete: false);
                    }
                    else
                    {
                        complete = AfterTagStart(tagStart, tags);
                    }
                }
            }
            while (tags.Count > 0);

            EndTagBlock(tags, complete);
        }

        private bool AfterTagStart(SourceLocation tagStart, Stack<Tuple<HtmlSymbol, SourceLocation>> tags)
        {
            if (!EndOfFile)
            {
                switch (CurrentSymbol.Type)
                {
                    case HtmlSymbolType.Solidus:
                        // End Tag
                        return EndTag(tagStart, tags);
                    case HtmlSymbolType.Bang:
                        // Comment
                        Accept(_bufferedOpenAngle);
                        return BangTag();
                    case HtmlSymbolType.QuestionMark:
                        // XML PI
                        Accept(_bufferedOpenAngle);
                        return XmlPI();
                    default:
                        // Start Tag
                        return StartTag(tags);
                }
            }
            if (tags.Count == 0)
            {
                Context.OnError(CurrentLocation, RazorResources.ParseError_OuterTagMissingName);
            }
            return false;
        }

        private bool XmlPI()
        {
            // Accept "?"
            Assert(HtmlSymbolType.QuestionMark);
            AcceptAndMoveNext();
            return AcceptUntilAll(HtmlSymbolType.QuestionMark, HtmlSymbolType.CloseAngle);
        }

        private bool BangTag()
        {
            // Accept "!"
            Assert(HtmlSymbolType.Bang);

            if (AcceptAndMoveNext())
            {
                if (CurrentSymbol.Type == HtmlSymbolType.DoubleHyphen)
                {
                    AcceptAndMoveNext();
                    return AcceptUntilAll(HtmlSymbolType.DoubleHyphen, HtmlSymbolType.CloseAngle);
                }
                else if (CurrentSymbol.Type == HtmlSymbolType.LeftBracket)
                {
                    if (AcceptAndMoveNext())
                    {
                        return CData();
                    }
                }
                else
                {
                    AcceptAndMoveNext();
                    return AcceptUntilAll(HtmlSymbolType.CloseAngle);
                }
            }

            return false;
        }

        private bool CData()
        {
            if (CurrentSymbol.Type == HtmlSymbolType.Text && String.Equals(CurrentSymbol.Content, "cdata", StringComparison.OrdinalIgnoreCase))
            {
                if (AcceptAndMoveNext())
                {
                    if (CurrentSymbol.Type == HtmlSymbolType.LeftBracket)
                    {
                        return AcceptUntilAll(HtmlSymbolType.RightBracket, HtmlSymbolType.RightBracket, HtmlSymbolType.CloseAngle);
                    }
                }
            }

            return false;
        }

        private bool EndTag(SourceLocation tagStart, Stack<Tuple<HtmlSymbol, SourceLocation>> tags)
        {
            // Accept "/" and move next
            Assert(HtmlSymbolType.Solidus);
            HtmlSymbol solidus = CurrentSymbol;
            if (!NextToken())
            {
                Accept(_bufferedOpenAngle);
                Accept(solidus);
                return false;
            }
            else
            {
                string tagName = String.Empty;
                if (At(HtmlSymbolType.Text))
                {
                    tagName = CurrentSymbol.Content;
                }
                bool matched = RemoveTag(tags, tagName, tagStart);

                if (tags.Count == 0 &&
                    String.Equals(tagName, SyntaxConstants.TextTagName, StringComparison.OrdinalIgnoreCase) &&
                    matched)
                {
                    Output(SpanKind.Markup);
                    return EndTextTag(solidus);
                }
                Accept(_bufferedOpenAngle);
                Accept(solidus);

                AcceptUntil(HtmlSymbolType.CloseAngle);

                // Accept the ">"
                return Optional(HtmlSymbolType.CloseAngle);
            }
        }

        private bool EndTextTag(HtmlSymbol solidus)
        {
            SourceLocation start = _bufferedOpenAngle.Start;

            Accept(_bufferedOpenAngle);
            Accept(solidus);

            Assert(HtmlSymbolType.Text);
            AcceptAndMoveNext();

            bool seenCloseAngle = Optional(HtmlSymbolType.CloseAngle);

            if (!seenCloseAngle)
            {
                Context.OnError(start, RazorResources.ParseError_TextTagCannotContainAttributes);
            }
            else
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }

            Span.CodeGenerator = SpanCodeGenerator.Null;
            Output(SpanKind.Transition);
            return seenCloseAngle;
        }

        private bool IsTagRecoveryStopPoint(HtmlSymbol sym)
        {
            return sym.Type == HtmlSymbolType.CloseAngle ||
                   sym.Type == HtmlSymbolType.Solidus ||
                   sym.Type == HtmlSymbolType.OpenAngle ||
                   sym.Type == HtmlSymbolType.SingleQuote ||
                   sym.Type == HtmlSymbolType.DoubleQuote;
        }

        private void TagContent()
        {
            if (!At(HtmlSymbolType.WhiteSpace))
            {
                // We should be right after the tag name, so if there's no whitespace, something is wrong
                RecoverToEndOfTag();
            }
            else
            {
                // We are here ($): <tag$ foo="bar" biz="~/Baz" />
                while (!EndOfFile && !IsEndOfTag())
                {
                    BeforeAttribute();
                }
            }
        }

        private bool IsEndOfTag()
        {
            if (At(HtmlSymbolType.Solidus))
            {
                if (NextIs(HtmlSymbolType.CloseAngle))
                {
                    return true;
                }
                else
                {
                    AcceptAndMoveNext();
                }
            }
            return At(HtmlSymbolType.CloseAngle) || At(HtmlSymbolType.OpenAngle);
        }

        private void BeforeAttribute()
        {
            // http://dev.w3.org/html5/spec/tokenization.html#before-attribute-name-state
            // Capture whitespace
            var whitespace = ReadWhile(sym => sym.Type == HtmlSymbolType.WhiteSpace || sym.Type == HtmlSymbolType.NewLine);

            if (At(HtmlSymbolType.Transition))
            {
                // Transition outside of attribute value => Switch to recovery mode
                Accept(whitespace);
                RecoverToEndOfTag();
                return;
            }

            // http://dev.w3.org/html5/spec/tokenization.html#attribute-name-state
            // Read the 'name' (i.e. read until the '=' or whitespace/newline)
            var name = Enumerable.Empty<HtmlSymbol>();
            if (At(HtmlSymbolType.Text))
            {
                name = ReadWhile(sym =>
                                 sym.Type != HtmlSymbolType.WhiteSpace &&
                                 sym.Type != HtmlSymbolType.NewLine &&
                                 sym.Type != HtmlSymbolType.Equals &&
                                 sym.Type != HtmlSymbolType.CloseAngle &&
                                 sym.Type != HtmlSymbolType.OpenAngle &&
                                 (sym.Type != HtmlSymbolType.Solidus || !NextIs(HtmlSymbolType.CloseAngle)));
            }
            else
            {
                // Unexpected character in tag, enter recovery
                Accept(whitespace);
                RecoverToEndOfTag();
                return;
            }

            if (!At(HtmlSymbolType.Equals))
            {
                // Saw a space or newline after the name, so just skip this attribute and continue around the loop
                Accept(whitespace);
                Accept(name);
                return;
            }

            Output(SpanKind.Markup);

            // Start a new markup block for the attribute
            using (Context.StartBlock(BlockType.Markup))
            {
                AttributePrefix(whitespace, name);
            }
        }

        private void AttributePrefix(IEnumerable<HtmlSymbol> whitespace, IEnumerable<HtmlSymbol> nameSymbols)
        {
            // First, determine if this is a 'data-' attribute (since those can't use conditional attributes)
            LocationTagged<string> name = nameSymbols.GetContent(Span.Start);
            bool attributeCanBeConditional = !name.Value.StartsWith("data-", StringComparison.OrdinalIgnoreCase);

            // Accept the whitespace and name
            Accept(whitespace);
            Accept(nameSymbols);
            Assert(HtmlSymbolType.Equals); // We should be at "="
            AcceptAndMoveNext();
            HtmlSymbolType quote = HtmlSymbolType.Unknown;
            if (At(HtmlSymbolType.SingleQuote) || At(HtmlSymbolType.DoubleQuote))
            {
                quote = CurrentSymbol.Type;
                AcceptAndMoveNext();
            }

            // We now have the prefix: (i.e. '      foo="')
            LocationTagged<string> prefix = Span.GetContent();

            if (attributeCanBeConditional)
            {
                Span.CodeGenerator = SpanCodeGenerator.Null; // The block code generator will render the prefix
                Output(SpanKind.Markup);

                // Read the values
                while (!EndOfFile && !IsEndOfAttributeValue(quote, CurrentSymbol))
                {
                    AttributeValue(quote);
                }

                // Capture the suffix
                LocationTagged<string> suffix = new LocationTagged<string>(String.Empty, CurrentLocation);
                if (quote != HtmlSymbolType.Unknown && At(quote))
                {
                    suffix = CurrentSymbol.GetContent();
                    AcceptAndMoveNext();
                }

                if (Span.Symbols.Count > 0)
                {
                    Span.CodeGenerator = SpanCodeGenerator.Null; // Again, block code generator will render the suffix
                    Output(SpanKind.Markup);
                }

                // Create the block code generator
                Context.CurrentBlock.CodeGenerator = new AttributeBlockCodeGenerator(
                    name, prefix, suffix);
            }
            else
            {
                // Not a "conditional" attribute, so just read the value
                SkipToAndParseCode(sym => IsEndOfAttributeValue(quote, sym));
                if (quote != HtmlSymbolType.Unknown)
                {
                    Optional(quote);
                }
                Output(SpanKind.Markup);
            }
        }

        private void AttributeValue(HtmlSymbolType quote)
        {
            SourceLocation prefixStart = CurrentLocation;
            var prefix = ReadWhile(sym => sym.Type == HtmlSymbolType.WhiteSpace || sym.Type == HtmlSymbolType.NewLine);
            Accept(prefix);

            if (At(HtmlSymbolType.Transition))
            {
                SourceLocation valueStart = CurrentLocation;
                PutCurrentBack();

                // Output the prefix but as a null-span. DynamicAttributeBlockCodeGenerator will render it
                Span.CodeGenerator = SpanCodeGenerator.Null;

                // Dynamic value, start a new block and set the code generator
                using (Context.StartBlock(BlockType.Markup))
                {
                    Context.CurrentBlock.CodeGenerator = new DynamicAttributeBlockCodeGenerator(prefix.GetContent(prefixStart), valueStart);

                    OtherParserBlock();
                }
            }
            else if (At(HtmlSymbolType.Text) && CurrentSymbol.Content.Length > 0 && CurrentSymbol.Content[0] == '~' && NextIs(HtmlSymbolType.Solidus))
            {
                // Virtual Path value
                SourceLocation valueStart = CurrentLocation;
                VirtualPath();
                Span.CodeGenerator = new LiteralAttributeCodeGenerator(
                    prefix.GetContent(prefixStart),
                    new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), valueStart));
            }
            else
            {
                // Literal value
                // 'quote' should be "Unknown" if not quoted and symbols coming from the tokenizer should never have "Unknown" type.
                var value = ReadWhile(sym =>
                    // These three conditions find separators which break the attribute value into portions
                                      sym.Type != HtmlSymbolType.WhiteSpace &&
                                      sym.Type != HtmlSymbolType.NewLine &&
                                      sym.Type != HtmlSymbolType.Transition &&
                                          // This condition checks for the end of the attribute value (it repeats some of the checks above but for now that's ok)
                                      !IsEndOfAttributeValue(quote, sym));
                Accept(value);
                Span.CodeGenerator = new LiteralAttributeCodeGenerator(prefix.GetContent(prefixStart), value.GetContent(prefixStart));
            }
            Output(SpanKind.Markup);
        }

        private bool IsEndOfAttributeValue(HtmlSymbolType quote, HtmlSymbol sym)
        {
            return EndOfFile || sym == null ||
                   (quote != HtmlSymbolType.Unknown
                        ? sym.Type == quote // If quoted, just wait for the quote
                        : IsUnquotedEndOfAttributeValue(sym));
        }

        private bool IsUnquotedEndOfAttributeValue(HtmlSymbol sym)
        {
            // If unquoted, we have a larger set of terminating characters: 
            // http://dev.w3.org/html5/spec/tokenization.html#attribute-value-unquoted-state
            // Also we need to detect "/" and ">"
            return sym.Type == HtmlSymbolType.DoubleQuote ||
                   sym.Type == HtmlSymbolType.SingleQuote ||
                   sym.Type == HtmlSymbolType.OpenAngle ||
                   sym.Type == HtmlSymbolType.Equals ||
                   (sym.Type == HtmlSymbolType.Solidus && NextIs(HtmlSymbolType.CloseAngle)) ||
                   sym.Type == HtmlSymbolType.CloseAngle ||
                   sym.Type == HtmlSymbolType.WhiteSpace ||
                   sym.Type == HtmlSymbolType.NewLine;
        }

        private void VirtualPath()
        {
            Assert(HtmlSymbolType.Text);
            Debug.Assert(CurrentSymbol.Content.Length > 0 && CurrentSymbol.Content[0] == '~');

            // Parse until a transition symbol, whitespace, newline or quote. We support only a fairly minimal subset of Virtual Paths
            AcceptUntil(HtmlSymbolType.Transition, HtmlSymbolType.WhiteSpace, HtmlSymbolType.NewLine, HtmlSymbolType.SingleQuote, HtmlSymbolType.DoubleQuote);

            // Output a Virtual Path span
            Span.EditHandler.EditorHints = EditorHints.VirtualPath;
        }

        private void RecoverToEndOfTag()
        {
            // Accept until ">", "/" or "<", but parse code
            while (!EndOfFile)
            {
                SkipToAndParseCode(IsTagRecoveryStopPoint);
                if (!EndOfFile)
                {
                    EnsureCurrent();
                    switch (CurrentSymbol.Type)
                    {
                        case HtmlSymbolType.SingleQuote:
                        case HtmlSymbolType.DoubleQuote:
                            ParseQuoted();
                            break;
                        case HtmlSymbolType.OpenAngle:
                        // Another "<" means this tag is invalid.
                        case HtmlSymbolType.Solidus:
                        // Empty tag
                        case HtmlSymbolType.CloseAngle:
                            // End of tag
                            return;
                        default:
                            AcceptAndMoveNext();
                            break;
                    }
                }
            }
        }

        private void ParseQuoted()
        {
            HtmlSymbolType type = CurrentSymbol.Type;
            AcceptAndMoveNext();
            ParseQuoted(type);
        }

        private void ParseQuoted(HtmlSymbolType type)
        {
            SkipToAndParseCode(type);
            if (!EndOfFile)
            {
                Assert(type);
                AcceptAndMoveNext();
            }
        }

        private bool StartTag(Stack<Tuple<HtmlSymbol, SourceLocation>> tags)
        {
            // If we're at text, it's the name, otherwise the name is ""
            HtmlSymbol tagName;
            if (At(HtmlSymbolType.Text))
            {
                tagName = CurrentSymbol;
            }
            else
            {
                tagName = new HtmlSymbol(CurrentLocation, String.Empty, HtmlSymbolType.Unknown);
            }

            Tuple<HtmlSymbol, SourceLocation> tag = Tuple.Create(tagName, _lastTagStart);

            if (tags.Count == 0 && String.Equals(tag.Item1.Content, SyntaxConstants.TextTagName, StringComparison.OrdinalIgnoreCase))
            {
                Output(SpanKind.Markup);
                Span.CodeGenerator = SpanCodeGenerator.Null;

                Accept(_bufferedOpenAngle);
                Assert(HtmlSymbolType.Text);

                AcceptAndMoveNext();

                int bookmark = CurrentLocation.AbsoluteIndex;
                IEnumerable<HtmlSymbol> tokens = ReadWhile(IsSpacingToken(includeNewLines: true));
                bool empty = At(HtmlSymbolType.Solidus);
                if (empty)
                {
                    Accept(tokens);
                    Assert(HtmlSymbolType.Solidus);
                    AcceptAndMoveNext();
                    bookmark = CurrentLocation.AbsoluteIndex;
                    tokens = ReadWhile(IsSpacingToken(includeNewLines: true));
                }

                if (!Optional(HtmlSymbolType.CloseAngle))
                {
                    Context.Source.Position = bookmark;
                    NextToken();
                    Context.OnError(tag.Item2, RazorResources.ParseError_TextTagCannotContainAttributes);
                }
                else
                {
                    Accept(tokens);
                    Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                }

                if (!empty)
                {
                    tags.Push(tag);
                }
                Output(SpanKind.Transition);
                return true;
            }
            Accept(_bufferedOpenAngle);
            Optional(HtmlSymbolType.Text);
            return RestOfTag(tag, tags);
        }

        private bool RestOfTag(Tuple<HtmlSymbol, SourceLocation> tag, Stack<Tuple<HtmlSymbol, SourceLocation>> tags)
        {
            TagContent();

            // We are now at a possible end of the tag
            // Found '<', so we just abort this tag.
            if (At(HtmlSymbolType.OpenAngle))
            {
                return false;
            }

            bool isEmpty = At(HtmlSymbolType.Solidus);
            // Found a solidus, so don't accept it but DON'T push the tag to the stack
            if (isEmpty)
            {
                AcceptAndMoveNext();
            }

            // Check for the '>' to determine if the tag is finished
            bool seenClose = Optional(HtmlSymbolType.CloseAngle);
            if (!seenClose)
            {
                Context.OnError(tag.Item2, RazorResources.ParseError_UnfinishedTag, tag.Item1.Content);
            }
            else
            {
                if (!isEmpty)
                {
                    // Is this a void element?
                    string tagName = tag.Item1.Content.Trim();
                    if (VoidElements.Contains(tagName))
                    {
                        // Technically, void elements like "meta" are not allowed to have end tags. Just in case they do,
                        // we need to look ahead at the next set of tokens. If we see "<", "/", tag name, accept it and the ">" following it
                        // Place a bookmark
                        int bookmark = CurrentLocation.AbsoluteIndex;

                        // Skip whitespace
                        IEnumerable<HtmlSymbol> ws = ReadWhile(IsSpacingToken(includeNewLines: true));

                        // Open Angle
                        if (At(HtmlSymbolType.OpenAngle) && NextIs(HtmlSymbolType.Solidus))
                        {
                            HtmlSymbol openAngle = CurrentSymbol;
                            NextToken();
                            Assert(HtmlSymbolType.Solidus);
                            HtmlSymbol solidus = CurrentSymbol;
                            NextToken();
                            if (At(HtmlSymbolType.Text) && String.Equals(CurrentSymbol.Content, tagName, StringComparison.OrdinalIgnoreCase))
                            {
                                // Accept up to here
                                Accept(ws);
                                Accept(openAngle);
                                Accept(solidus);
                                AcceptAndMoveNext();

                                // Accept to '>', '<' or EOF
                                AcceptUntil(HtmlSymbolType.CloseAngle, HtmlSymbolType.OpenAngle);
                                // Accept the '>' if we saw it. And if we do see it, we're complete
                                return Optional(HtmlSymbolType.CloseAngle);
                            } // At(HtmlSymbolType.Text) && String.Equals(CurrentSymbol.Content, tagName, StringComparison.OrdinalIgnoreCase)
                        } // At(HtmlSymbolType.OpenAngle) && NextIs(HtmlSymbolType.Solidus)

                        // Go back to the bookmark and just finish this tag at the close angle
                        Context.Source.Position = bookmark;
                        NextToken();
                    }
                    else if (String.Equals(tagName, "script", StringComparison.OrdinalIgnoreCase))
                    {
                        SkipToEndScriptAndParseCode();
                    }
                    else
                    {
                        // Push the tag on to the stack
                        tags.Push(tag);
                    }
                }
            }
            return seenClose;
        }

        private void SkipToEndScriptAndParseCode()
        {
            // Special case for <script>: Skip to end of script tag and parse code
            bool seenEndScript = false;
            while (!seenEndScript && !EndOfFile)
            {
                SkipToAndParseCode(HtmlSymbolType.OpenAngle);
                SourceLocation tagStart = CurrentLocation;
                AcceptAndMoveNext();
                AcceptWhile(HtmlSymbolType.WhiteSpace);
                if (Optional(HtmlSymbolType.Solidus))
                {
                    AcceptWhile(HtmlSymbolType.WhiteSpace);
                    if (At(HtmlSymbolType.Text) && String.Equals(CurrentSymbol.Content, "script", StringComparison.OrdinalIgnoreCase))
                    {
                        // </script!
                        SkipToAndParseCode(HtmlSymbolType.CloseAngle);
                        if (!Optional(HtmlSymbolType.CloseAngle))
                        {
                            Context.OnError(tagStart, RazorResources.ParseError_UnfinishedTag, "script");
                        }
                        seenEndScript = true;
                    }
                }
            }
        }

        private bool AcceptUntilAll(params HtmlSymbolType[] endSequence)
        {
            while (!EndOfFile)
            {
                SkipToAndParseCode(endSequence[0]);
                if (AcceptAll(endSequence))
                {
                    return true;
                }
            }
            Debug.Assert(EndOfFile);
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;
            return false;
        }

        private bool RemoveTag(Stack<Tuple<HtmlSymbol, SourceLocation>> tags, string tagName, SourceLocation tagStart)
        {
            Tuple<HtmlSymbol, SourceLocation> currentTag = null;
            while (tags.Count > 0)
            {
                currentTag = tags.Pop();
                if (String.Equals(tagName, currentTag.Item1.Content, StringComparison.OrdinalIgnoreCase))
                {
                    // Matched the tag
                    return true;
                }
            }
            if (currentTag != null)
            {
                Context.OnError(currentTag.Item2, RazorResources.ParseError_MissingEndTag, currentTag.Item1.Content);
            }
            else
            {
                Context.OnError(tagStart, RazorResources.ParseError_UnexpectedEndTag, tagName);
            }
            return false;
        }

        private void EndTagBlock(Stack<Tuple<HtmlSymbol, SourceLocation>> tags, bool complete)
        {
            if (tags.Count > 0)
            {
                // Ended because of EOF, not matching close tag.  Throw error for last tag
                while (tags.Count > 1)
                {
                    tags.Pop();
                }
                Tuple<HtmlSymbol, SourceLocation> tag = tags.Pop();
                Context.OnError(tag.Item2, RazorResources.ParseError_MissingEndTag, tag.Item1.Content);
            }
            else if (complete)
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }
            tags.Clear();
            if (!Context.DesignTimeMode)
            {
                AcceptWhile(HtmlSymbolType.WhiteSpace);
                if (!EndOfFile && CurrentSymbol.Type == HtmlSymbolType.NewLine)
                {
                    AcceptAndMoveNext();
                }
            }
            else if (Span.EditHandler.AcceptedCharacters == AcceptedCharacters.Any)
            {
                AcceptWhile(HtmlSymbolType.WhiteSpace);
                Optional(HtmlSymbolType.NewLine);
            }
            PutCurrentBack();

            if (!complete)
            {
                AddMarkerSymbolIfNecessary();
            }
            Output(SpanKind.Markup);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/HtmlMarkupParser.Document.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class HtmlMarkupParser
    {
        public override void ParseDocument()
        {
            if (Context == null)
            {
                throw new InvalidOperationException(RazorResources.Parser_Context_Not_Set);
            }

            using (PushSpanConfig(DefaultMarkupSpan))
            {
                using (Context.StartBlock(BlockType.Markup))
                {
                    NextToken();
                    while (!EndOfFile)
                    {
                        SkipToAndParseCode(HtmlSymbolType.OpenAngle);
                        ScanTagInDocumentContext();
                    }
                    AddMarkerSymbolIfNecessary();
                    Output(SpanKind.Markup);
                }
            }
        }

        /// <summary>
        /// Reads the content of a tag (if present) in the MarkupDocument (or MarkupSection) context,
        /// where we don't care about maintaining a stack of tags.
        /// </summary>
        /// <returns>A boolean indicating if we scanned at least one tag.</returns>
        private bool ScanTagInDocumentContext()
        {
            if (Optional(HtmlSymbolType.OpenAngle))
            {
                if (At(HtmlSymbolType.Bang))
                {
                    BangTag();
                    return true;
                }
                else if (At(HtmlSymbolType.QuestionMark))
                {
                    XmlPI();
                    return true;
                }
                else if (!At(HtmlSymbolType.Solidus))
                {
                    bool scriptTag = At(HtmlSymbolType.Text) &&
                                     String.Equals(CurrentSymbol.Content, "script", StringComparison.OrdinalIgnoreCase);
                    Optional(HtmlSymbolType.Text);
                    TagContent(); // Parse the tag, don't care about the content
                    Optional(HtmlSymbolType.Solidus);
                    Optional(HtmlSymbolType.CloseAngle);
                    if (scriptTag)
                    {
                        SkipToEndScriptAndParseCode();
                    }
                    return true;
                }
            }
            return false;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/HtmlMarkupParser.Section.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class HtmlMarkupParser
    {
        private bool CaseSensitive { get; set; }

        private StringComparison Comparison
        {
            get { return CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase; }
        }

        public override void ParseSection(Tuple<string, string> nestingSequences, bool caseSensitive)
        {
            if (Context == null)
            {
                throw new InvalidOperationException(RazorResources.Parser_Context_Not_Set);
            }

            using (PushSpanConfig(DefaultMarkupSpan))
            {
                using (Context.StartBlock(BlockType.Markup))
                {
                    NextToken();
                    CaseSensitive = caseSensitive;
                    if (nestingSequences.Item1 == null)
                    {
                        NonNestingSection(nestingSequences.Item2.Split());
                    }
                    else
                    {
                        NestingSection(nestingSequences);
                    }
                    AddMarkerSymbolIfNecessary();
                    Output(SpanKind.Markup);
                }
            }
        }

        private void NonNestingSection(string[] nestingSequenceComponents)
        {
            do
            {
                SkipToAndParseCode(sym => sym.Type == HtmlSymbolType.OpenAngle || AtEnd(nestingSequenceComponents));
                ScanTagInDocumentContext();
                if (!EndOfFile && AtEnd(nestingSequenceComponents))
                {
                    break;
                }
            }
            while (!EndOfFile);

            PutCurrentBack();
        }

        private void NestingSection(Tuple<string, string> nestingSequences)
        {
            int nesting = 1;
            while (nesting > 0 && !EndOfFile)
            {
                SkipToAndParseCode(sym =>
                    sym.Type == HtmlSymbolType.Text ||
                    sym.Type == HtmlSymbolType.OpenAngle);
                if (At(HtmlSymbolType.Text))
                {
                    nesting += ProcessTextToken(nestingSequences, nesting);
                    if (CurrentSymbol != null)
                    {
                        AcceptAndMoveNext();
                    }
                    else if (nesting > 0)
                    {
                        NextToken();
                    }
                }
                else
                {
                    ScanTagInDocumentContext();
                }
            }
        }

        private bool AtEnd(string[] nestingSequenceComponents)
        {
            EnsureCurrent();
            if (String.Equals(CurrentSymbol.Content, nestingSequenceComponents[0], Comparison))
            {
                int bookmark = CurrentSymbol.Start.AbsoluteIndex;
                try
                {
                    foreach (string component in nestingSequenceComponents)
                    {
                        if (!EndOfFile && !String.Equals(CurrentSymbol.Content, component, Comparison))
                        {
                            return false;
                        }
                        NextToken();
                        while (!EndOfFile && IsSpacingToken(includeNewLines: true)(CurrentSymbol))
                        {
                            NextToken();
                        }
                    }
                    return true;
                }
                finally
                {
                    Context.Source.Position = bookmark;
                    NextToken();
                }
            }
            return false;
        }

        private int ProcessTextToken(Tuple<string, string> nestingSequences, int currentNesting)
        {
            for (int i = 0; i < CurrentSymbol.Content.Length; i++)
            {
                int nestingDelta = HandleNestingSequence(nestingSequences.Item1, i, currentNesting, 1);
                if (nestingDelta == 0)
                {
                    nestingDelta = HandleNestingSequence(nestingSequences.Item2, i, currentNesting, -1);
                }

                if (nestingDelta != 0)
                {
                    return nestingDelta;
                }
            }
            return 0;
        }

        private int HandleNestingSequence(string sequence, int position, int currentNesting, int retIfMatched)
        {
            if (sequence != null &&
                CurrentSymbol.Content[position] == sequence[0] &&
                position + sequence.Length <= CurrentSymbol.Content.Length)
            {
                string possibleStart = CurrentSymbol.Content.Substring(position, sequence.Length);
                if (String.Equals(possibleStart, sequence, Comparison))
                {
                    // Capture the current symbol and "put it back" (really we just want to clear CurrentSymbol)
                    int bookmark = Context.Source.Position;
                    HtmlSymbol sym = CurrentSymbol;
                    PutCurrentBack();

                    // Carve up the symbol
                    Tuple<HtmlSymbol, HtmlSymbol> pair = Language.SplitSymbol(sym, position, HtmlSymbolType.Text);
                    HtmlSymbol preSequence = pair.Item1;
                    Debug.Assert(pair.Item2 != null);
                    pair = Language.SplitSymbol(pair.Item2, sequence.Length, HtmlSymbolType.Text);
                    HtmlSymbol sequenceToken = pair.Item1;
                    HtmlSymbol postSequence = pair.Item2;

                    // Accept the first chunk (up to the nesting sequence we just saw)
                    if (!String.IsNullOrEmpty(preSequence.Content))
                    {
                        Accept(preSequence);
                    }

                    if (currentNesting + retIfMatched == 0)
                    {
                        // This is 'popping' the final entry on the stack of nesting sequences
                        // A caller higher in the parsing stack will accept the sequence token, so advance
                        // to it
                        Context.Source.Position = sequenceToken.Start.AbsoluteIndex;
                    }
                    else
                    {
                        // This isn't the end of the last nesting sequence, accept the token and keep going
                        Accept(sequenceToken);

                        // Position at the start of the postSequence symbol
                        if (postSequence != null)
                        {
                            Context.Source.Position = postSequence.Start.AbsoluteIndex;
                        }
                        else
                        {
                            Context.Source.Position = bookmark;
                        }
                    }

                    // Return the value we were asked to return if matched, since we found a nesting sequence
                    return retIfMatched;
                }
            }
            return 0;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/HtmlMarkupParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class HtmlMarkupParser : TokenizerBackedParser<HtmlTokenizer, HtmlSymbol, HtmlSymbolType>
    {
        //From http://dev.w3.org/html5/spec/Overview.html#elements-0
        private ISet<string> _voidElements = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            "area",
            "base",
            "br",
            "col",
            "command",
            "embed",
            "hr",
            "img",
            "input",
            "keygen",
            "link",
            "meta",
            "param",
            "source",
            "track",
            "wbr"
        };

        public ISet<string> VoidElements
        {
            get { return _voidElements; }
        }

        protected override ParserBase OtherParser
        {
            get { return Context.CodeParser; }
        }

        protected override LanguageCharacteristics<HtmlTokenizer, HtmlSymbol, HtmlSymbolType> Language
        {
            get { return HtmlLanguageCharacteristics.Instance; }
        }

        public override void BuildSpan(SpanBuilder span, SourceLocation start, string content)
        {
            span.Kind = SpanKind.Markup;
            span.CodeGenerator = new MarkupCodeGenerator();
            base.BuildSpan(span, start, content);
        }

        protected override void OutputSpanBeforeRazorComment()
        {
            Output(SpanKind.Markup);
        }

        protected void SkipToAndParseCode(HtmlSymbolType type)
        {
            SkipToAndParseCode(sym => sym.Type == type);
        }

        protected void SkipToAndParseCode(Func<HtmlSymbol, bool> condition)
        {
            HtmlSymbol last = null;
            bool startOfLine = false;
            while (!EndOfFile && !condition(CurrentSymbol))
            {
                if (At(HtmlSymbolType.NewLine))
                {
                    if (last != null)
                    {
                        Accept(last);
                    }

                    // Mark the start of a new line
                    startOfLine = true;
                    last = null;
                    AcceptAndMoveNext();
                }
                else if (At(HtmlSymbolType.Transition))
                {
                    HtmlSymbol transition = CurrentSymbol;
                    NextToken();
                    if (At(HtmlSymbolType.Transition))
                    {
                        if (last != null)
                        {
                            Accept(last);
                            last = null;
                        }
                        Output(SpanKind.Markup);
                        Accept(transition);
                        Span.CodeGenerator = SpanCodeGenerator.Null;
                        Output(SpanKind.Markup);
                        AcceptAndMoveNext();
                        continue; // while
                    }
                    else
                    {
                        if (!EndOfFile)
                        {
                            PutCurrentBack();
                        }
                        PutBack(transition);
                    }

                    // Handle whitespace rewriting
                    if (last != null)
                    {
                        if (!Context.DesignTimeMode && last.Type == HtmlSymbolType.WhiteSpace && startOfLine)
                        {
                            // Put the whitespace back too
                            startOfLine = false;
                            PutBack(last);
                            last = null;
                        }
                        else
                        {
                            // Accept last
                            Accept(last);
                            last = null;
                        }
                    }

                    OtherParserBlock();
                }
                else if (At(HtmlSymbolType.RazorCommentTransition))
                {
                    if (last != null)
                    {
                        Accept(last);
                        last = null;
                    }
                    AddMarkerSymbolIfNecessary();
                    Output(SpanKind.Markup);
                    RazorComment();
                }
                else
                {
                    // As long as we see whitespace, we're still at the "start" of the line
                    startOfLine &= At(HtmlSymbolType.WhiteSpace);

                    // If there's a last token, accept it
                    if (last != null)
                    {
                        Accept(last);
                        last = null;
                    }

                    // Advance
                    last = CurrentSymbol;
                    NextToken();
                }
            }

            if (last != null)
            {
                Accept(last);
            }
        }

        protected static Func<HtmlSymbol, bool> IsSpacingToken(bool includeNewLines)
        {
            return sym => sym.Type == HtmlSymbolType.WhiteSpace || (includeNewLines && sym.Type == HtmlSymbolType.NewLine);
        }

        private void OtherParserBlock()
        {
            AddMarkerSymbolIfNecessary();
            Output(SpanKind.Markup);
            using (PushSpanConfig())
            {
                Context.SwitchActiveParser();
                Context.CodeParser.ParseBlock();
                Context.SwitchActiveParser();
            }
            Initialize(Span);
            NextToken();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/ISyntaxTreeRewriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Parser
{
    internal interface ISyntaxTreeRewriter
    {
        Block Rewrite(Block input);
    }
}


================================================
FILE: src/System.Web.Razor/Parser/LanguageCharacteristics.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    [SuppressMessage("Microsoft.Design", "CA1005:AvoidExcessiveParametersOnGenericTypes", Justification = "All generic type parameters are required")]
    public abstract class LanguageCharacteristics<TTokenizer, TSymbol, TSymbolType>
        where TTokenizer : Tokenizer<TSymbol, TSymbolType>
        where TSymbol : SymbolBase<TSymbolType>
    {
        public abstract string GetSample(TSymbolType type);
        public abstract TTokenizer CreateTokenizer(ITextDocument source);
        public abstract TSymbolType FlipBracket(TSymbolType bracket);
        public abstract TSymbol CreateMarkerSymbol(SourceLocation location);

        public virtual IEnumerable<TSymbol> TokenizeString(string content)
        {
            return TokenizeString(SourceLocation.Zero, content);
        }

        public virtual IEnumerable<TSymbol> TokenizeString(SourceLocation start, string input)
        {
            using (SeekableTextReader reader = new SeekableTextReader(input))
            {
                TTokenizer tok = CreateTokenizer(reader);
                TSymbol sym;
                while ((sym = tok.NextSymbol()) != null)
                {
                    sym.OffsetStart(start);
                    yield return sym;
                }
            }
        }

        public virtual bool IsWhiteSpace(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.WhiteSpace);
        }

        public virtual bool IsNewLine(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.NewLine);
        }

        public virtual bool IsIdentifier(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.Identifier);
        }

        public virtual bool IsKeyword(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.Keyword);
        }

        public virtual bool IsTransition(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.Transition);
        }

        public virtual bool IsCommentStart(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.CommentStart);
        }

        public virtual bool IsCommentStar(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.CommentStar);
        }

        public virtual bool IsCommentBody(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.CommentBody);
        }

        public virtual bool IsUnknown(TSymbol symbol)
        {
            return IsKnownSymbolType(symbol, KnownSymbolType.Unknown);
        }

        public virtual bool IsKnownSymbolType(TSymbol symbol, KnownSymbolType type)
        {
            return symbol != null && Equals(symbol.Type, GetKnownSymbolType(type));
        }

        public virtual Tuple<TSymbol, TSymbol> SplitSymbol(TSymbol symbol, int splitAt, TSymbolType leftType)
        {
            TSymbol left = CreateSymbol(symbol.Start, symbol.Content.Substring(0, splitAt), leftType, Enumerable.Empty<RazorError>());
            TSymbol right = null;
            if (splitAt < symbol.Content.Length)
            {
                right = CreateSymbol(SourceLocationTracker.CalculateNewLocation(symbol.Start, left.Content), symbol.Content.Substring(splitAt), symbol.Type, symbol.Errors);
            }
            return Tuple.Create(left, right);
        }

        public abstract TSymbolType GetKnownSymbolType(KnownSymbolType type);

        public virtual bool KnowsSymbolType(KnownSymbolType type)
        {
            return type == KnownSymbolType.Unknown || !Equals(GetKnownSymbolType(type), GetKnownSymbolType(KnownSymbolType.Unknown));
        }

        protected abstract TSymbol CreateSymbol(SourceLocation location, string content, TSymbolType type, IEnumerable<RazorError> errors);
    }
}


================================================
FILE: src/System.Web.Razor/Parser/MarkupCollapser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor.Parser
{
    internal class MarkupCollapser : MarkupRewriter
    {
        public MarkupCollapser(Action<SpanBuilder, SourceLocation, string> markupSpanFactory) : base(markupSpanFactory)
        {
        }

        protected override bool CanRewrite(Span span)
        {
            return span.Kind == SpanKind.Markup && span.CodeGenerator is MarkupCodeGenerator;
        }

        protected override SyntaxTreeNode RewriteSpan(BlockBuilder parent, Span span)
        {
            // Only rewrite if we have a previous that is also markup (CanRewrite does this check for us!)
            Span previous = parent.Children.LastOrDefault() as Span;
            if (previous == null || !CanRewrite(previous))
            {
                return span;
            }

            // Merge spans
            parent.Children.Remove(previous);
            SpanBuilder merged = new SpanBuilder();
            FillSpan(merged, previous.Start, previous.Content + span.Content);
            return merged.Build();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/MarkupRewriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor.Parser
{
    internal abstract class MarkupRewriter : ParserVisitor, ISyntaxTreeRewriter
    {
        private Stack<BlockBuilder> _blocks = new Stack<BlockBuilder>();
        private Action<SpanBuilder, SourceLocation, string> _markupSpanFactory;

        protected MarkupRewriter(Action<SpanBuilder, SourceLocation, string> markupSpanFactory)
        {
            if (markupSpanFactory == null)
            {
                throw new ArgumentNullException("markupSpanFactory");
            }
            _markupSpanFactory = markupSpanFactory;
        }

        protected BlockBuilder Parent
        {
            get { return _blocks.Count > 0 ? _blocks.Peek() : null; }
        }

        public virtual Block Rewrite(Block input)
        {
            input.Accept(this);
            Debug.Assert(_blocks.Count == 1);
            return _blocks.Pop().Build();
        }

        public override void VisitBlock(Block block)
        {
            if (CanRewrite(block))
            {
                SyntaxTreeNode newNode = RewriteBlock(_blocks.Peek(), block);
                if (newNode != null)
                {
                    _blocks.Peek().Children.Add(newNode);
                }
            }
            else
            {
                // Not rewritable.
                BlockBuilder builder = new BlockBuilder(block);
                builder.Children.Clear();
                _blocks.Push(builder);
                base.VisitBlock(block);
                Debug.Assert(ReferenceEquals(builder, _blocks.Peek()));

                if (_blocks.Count > 1)
                {
                    _blocks.Pop();
                    _blocks.Peek().Children.Add(builder.Build());
                }
            }
        }

        public override void VisitSpan(Span span)
        {
            if (CanRewrite(span))
            {
                SyntaxTreeNode newNode = RewriteSpan(_blocks.Peek(), span);
                if (newNode != null)
                {
                    _blocks.Peek().Children.Add(newNode);
                }
            }
            else
            {
                _blocks.Peek().Children.Add(span);
            }
        }

        protected virtual bool CanRewrite(Block block)
        {
            return false;
        }

        protected virtual bool CanRewrite(Span span)
        {
            return false;
        }

        protected virtual SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
        {
            throw new NotImplementedException();
        }

        protected virtual SyntaxTreeNode RewriteSpan(BlockBuilder parent, Span span)
        {
            throw new NotImplementedException();
        }

        protected void FillSpan(SpanBuilder builder, SourceLocation start, string content)
        {
            _markupSpanFactory(builder, start, content);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/ParserBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;

namespace System.Web.Razor.Parser
{
    public abstract class ParserBase
    {
        private ParserContext _context;

        public virtual ParserContext Context
        {
            get { return _context; }
            set
            {
                Debug.Assert(_context == null, "Context has already been set for this parser!");
                _context = value;
                _context.AssertOnOwnerTask();
            }
        }

        public virtual bool IsMarkupParser
        {
            get { return false; }
        }

        protected abstract ParserBase OtherParser { get; }

        public abstract void BuildSpan(SpanBuilder span, SourceLocation start, string content);

        public abstract void ParseBlock();

        // Markup Parsers need the ParseDocument and ParseSection methods since the markup parser is the first parser to hit the document 
        // and the logic may be different than the ParseBlock method.
        public virtual void ParseDocument()
        {
            Debug.Assert(IsMarkupParser);
            throw new NotSupportedException(RazorResources.ParserIsNotAMarkupParser);
        }

        public virtual void ParseSection(Tuple<string, string> nestingSequences, bool caseSensitive)
        {
            Debug.Assert(IsMarkupParser);
            throw new NotSupportedException(RazorResources.ParserIsNotAMarkupParser);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/ParserContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Utils;

namespace System.Web.Razor.Parser
{
    public partial class ParserContext
    {
        private int? _ownerTaskId;

        private bool _terminated = false;

        private Stack<BlockBuilder> _blockStack = new Stack<BlockBuilder>();

        public ParserContext(ITextDocument source, ParserBase codeParser, ParserBase markupParser, ParserBase activeParser)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }
            if (codeParser == null)
            {
                throw new ArgumentNullException("codeParser");
            }
            if (markupParser == null)
            {
                throw new ArgumentNullException("markupParser");
            }
            if (activeParser == null)
            {
                throw new ArgumentNullException("activeParser");
            }
            if (activeParser != codeParser && activeParser != markupParser)
            {
                throw new ArgumentException(RazorResources.ActiveParser_Must_Be_Code_Or_Markup_Parser, "activeParser");
            }

            CaptureOwnerTask();

            Source = new TextDocumentReader(source);
            CodeParser = codeParser;
            MarkupParser = markupParser;
            ActiveParser = activeParser;
            Errors = new List<RazorError>();
        }

        public IList<RazorError> Errors { get; private set; }
        public TextDocumentReader Source { get; set; }
        public ParserBase CodeParser { get; private set; }
        public ParserBase MarkupParser { get; private set; }
        public ParserBase ActiveParser { get; private set; }
        public bool DesignTimeMode { get; set; }

        public BlockBuilder CurrentBlock
        {
            get { return _blockStack.Peek(); }
        }

        public Span LastSpan { get; private set; }
        public bool WhiteSpaceIsSignificantToAncestorBlock { get; set; }

        public AcceptedCharacters LastAcceptedCharacters
        {
            get
            {
                if (LastSpan == null)
                {
                    return AcceptedCharacters.None;
                }
                return LastSpan.EditHandler.AcceptedCharacters;
            }
        }

        internal Stack<BlockBuilder> BlockStack
        {
            get { return _blockStack; }
        }

        public char CurrentCharacter
        {
            get
            {
                if (_terminated)
                {
                    return '\0';
                }
#if DEBUG
                if (CheckInfiniteLoop())
                {
                    return '\0';
                }
#endif
                int ch = Source.Peek();
                if (ch == -1)
                {
                    return '\0';
                }
                return (char)ch;
            }
        }

        public bool EndOfFile
        {
            get { return _terminated || Source.Peek() == -1; }
        }

        public void AddSpan(Span span)
        {
            EnusreNotTerminated();
            if (_blockStack.Count == 0)
            {
                throw new InvalidOperationException(RazorResources.ParserContext_NoCurrentBlock);
            }
            _blockStack.Peek().Children.Add(span);
            LastSpan = span;
        }

        /// <summary>
        /// Starts a block of the specified type
        /// </summary>
        /// <param name="blockType">The type of the block to start</param>
        public IDisposable StartBlock(BlockType blockType)
        {
            EnusreNotTerminated();
            AssertOnOwnerTask();
            _blockStack.Push(new BlockBuilder() { Type = blockType });
            return new DisposableAction(EndBlock);
        }

        /// <summary>
        /// Starts a block
        /// </summary>
        public IDisposable StartBlock()
        {
            EnusreNotTerminated();
            AssertOnOwnerTask();
            _blockStack.Push(new BlockBuilder());
            return new DisposableAction(EndBlock);
        }

        /// <summary>
        /// Ends the current block
        /// </summary>
        public void EndBlock()
        {
            EnusreNotTerminated();
            AssertOnOwnerTask();

            if (_blockStack.Count == 0)
            {
                throw new InvalidOperationException(RazorResources.EndBlock_Called_Without_Matching_StartBlock);
            }
            if (_blockStack.Count > 1)
            {
                BlockBuilder block = _blockStack.Pop();
                _blockStack.Peek().Children.Add(block.Build());
            }
            else
            {
                // If we're at 1, terminate the parser
                _terminated = true;
            }
        }

        /// <summary>
        /// Gets a boolean indicating if any of the ancestors of the current block is of the specified type
        /// </summary>
        public bool IsWithin(BlockType type)
        {
            return _blockStack.Any(b => b.Type == type);
        }

        public void SwitchActiveParser()
        {
            EnusreNotTerminated();
            AssertOnOwnerTask();
            if (ReferenceEquals(ActiveParser, CodeParser))
            {
                ActiveParser = MarkupParser;
            }
            else
            {
                ActiveParser = CodeParser;
            }
        }

        public void OnError(SourceLocation location, string message)
        {
            EnusreNotTerminated();
            AssertOnOwnerTask();
            Errors.Add(new RazorError(message, location));
        }

        public void OnError(SourceLocation location, string message, params object[] args)
        {
            EnusreNotTerminated();
            AssertOnOwnerTask();
            OnError(location, String.Format(CultureInfo.CurrentCulture, message, args));
        }

        public ParserResults CompleteParse()
        {
            if (_blockStack.Count == 0)
            {
                throw new InvalidOperationException(RazorResources.ParserContext_CannotCompleteTree_NoRootBlock);
            }
            if (_blockStack.Count != 1)
            {
                throw new InvalidOperationException(RazorResources.ParserContext_CannotCompleteTree_OutstandingBlocks);
            }
            return new ParserResults(_blockStack.Pop().Build(), Errors);
        }

        [Conditional("DEBUG")]
        internal void CaptureOwnerTask()
        {
            if (Task.CurrentId != null)
            {
                _ownerTaskId = Task.CurrentId;
            }
        }

        [Conditional("DEBUG")]
        internal void AssertOnOwnerTask()
        {
            if (_ownerTaskId != null)
            {
                Debug.Assert(_ownerTaskId == Task.CurrentId);
            }
        }

        [Conditional("DEBUG")]
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "The method body is empty in Release builds")]
        internal void AssertCurrent(char expected)
        {
            Debug.Assert(CurrentCharacter == expected);
        }

        private void EnusreNotTerminated()
        {
            if (_terminated)
            {
                throw new InvalidOperationException(RazorResources.ParserContext_ParseComplete);
            }
        }
    }

    // Debug Helpers

#if DEBUG
    [DebuggerDisplay("{Unparsed}")]
    public partial class ParserContext
    {
        private const int InfiniteLoopCountThreshold = 1000;
        private int _infiniteLoopGuardCount = 0;
        private SourceLocation? _infiniteLoopGuardLocation = null;

        internal string Unparsed
        {
            get
            {
                string remaining = Source.ReadToEnd();
                Source.Position -= remaining.Length;
                return remaining;
            }
        }

        private bool CheckInfiniteLoop()
        {
            // Infinite loop guard
            //  Basically, if this property is accessed 1000 times in a row without having advanced the source reader to the next position, we
            //  cause a parser error
            if (_infiniteLoopGuardLocation != null)
            {
                if (Source.Location == _infiniteLoopGuardLocation.Value)
                {
                    _infiniteLoopGuardCount++;
                    if (_infiniteLoopGuardCount > InfiniteLoopCountThreshold)
                    {
                        Debug.Fail("An internal parser error is causing an infinite loop at this location.");
                        _terminated = true;
                        return true;
                    }
                }
                else
                {
                    _infiniteLoopGuardCount = 0;
                }
            }
            _infiniteLoopGuardLocation = Source.Location;
            return false;
        }
    }
#endif
}


================================================
FILE: src/System.Web.Razor/Parser/ParserHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;

namespace System.Web.Razor.Parser
{
    public static class ParserHelpers
    {
        public static bool IsNewLine(char value)
        {
            return value == '\r' // Carriage return
                   || value == '\n' // Linefeed
                   || value == '\u0085' // Next Line
                   || value == '\u2028' // Line separator
                   || value == '\u2029'; // Paragraph separator
        }

        public static bool IsNewLine(string value)
        {
            return (value.Length == 1 && (IsNewLine(value[0]))) ||
                   (String.Equals(value, "\r\n", StringComparison.Ordinal));
        }

        // Returns true if the character is Whitespace and NOT a newline
        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "Whitespace", Justification = "This would be a breaking change in a shipping API")]
        public static bool IsWhitespace(char value)
        {
            return value == ' ' ||
                   value == '\f' ||
                   value == '\t' ||
                   value == '\u000B' || // Vertical Tab
                   Char.GetUnicodeCategory(value) == UnicodeCategory.SpaceSeparator;
        }

        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "Whitespace", Justification = "This would be a breaking change in a shipping API")]
        public static bool IsWhitespaceOrNewLine(char value)
        {
            return IsWhitespace(value) || IsNewLine(value);
        }

        public static bool IsIdentifier(string value)
        {
            return IsIdentifier(value, requireIdentifierStart: true);
        }

        public static bool IsIdentifier(string value, bool requireIdentifierStart)
        {
            IEnumerable<char> identifierPart = value;
            if (requireIdentifierStart)
            {
                identifierPart = identifierPart.Skip(1);
            }
            return (!requireIdentifierStart || IsIdentifierStart(value[0])) && identifierPart.All(IsIdentifierPart);
        }

        public static bool IsHexDigit(char value)
        {
            return (value >= '0' && value <= '9') || (value >= 'A' && value <= 'F') || (value >= 'a' && value <= 'f');
        }

        public static bool IsIdentifierStart(char value)
        {
            return value == '_' || IsLetter(value);
        }

        public static bool IsIdentifierPart(char value)
        {
            return IsLetter(value)
                   || IsDecimalDigit(value)
                   || IsConnecting(value)
                   || IsCombining(value)
                   || IsFormatting(value);
        }

        public static bool IsTerminatingCharToken(char value)
        {
            return IsNewLine(value) || value == '\'';
        }

        public static bool IsTerminatingQuotedStringToken(char value)
        {
            return IsNewLine(value) || value == '"';
        }

        public static bool IsDecimalDigit(char value)
        {
            return Char.GetUnicodeCategory(value) == UnicodeCategory.DecimalDigitNumber;
        }

        public static bool IsLetterOrDecimalDigit(char value)
        {
            return IsLetter(value) || IsDecimalDigit(value);
        }

        public static bool IsLetter(char value)
        {
            var cat = Char.GetUnicodeCategory(value);
            return cat == UnicodeCategory.UppercaseLetter
                   || cat == UnicodeCategory.LowercaseLetter
                   || cat == UnicodeCategory.TitlecaseLetter
                   || cat == UnicodeCategory.ModifierLetter
                   || cat == UnicodeCategory.OtherLetter
                   || cat == UnicodeCategory.LetterNumber;
        }

        public static bool IsFormatting(char value)
        {
            return Char.GetUnicodeCategory(value) == UnicodeCategory.Format;
        }

        public static bool IsCombining(char value)
        {
            var cat = Char.GetUnicodeCategory(value);
            return cat == UnicodeCategory.SpacingCombiningMark || cat == UnicodeCategory.NonSpacingMark;
        }

        public static bool IsConnecting(char value)
        {
            return Char.GetUnicodeCategory(value) == UnicodeCategory.ConnectorPunctuation;
        }

        public static string SanitizeClassName(string inputName)
        {
            if (!IsIdentifierStart(inputName[0]) && IsIdentifierPart(inputName[0]))
            {
                inputName = "_" + inputName;
            }

            return new String((from value in inputName
                               select IsIdentifierPart(value) ? value : '_')
                                  .ToArray());
        }

        public static bool IsEmailPart(char character)
        {
            // Source: http://tools.ietf.org/html/rfc5322#section-3.4.1
            // We restrict the allowed characters to alpha-numerics and '_' in order to ensure we cover most of the cases where an
            // email address is intended without restricting the usage of code within JavaScript, CSS, and other contexts.
            return Char.IsLetter(character) || Char.IsDigit(character) || character == '_';
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/ParserVisitor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Parser
{
    public abstract class ParserVisitor
    {
        public CancellationToken? CancelToken { get; set; }

        public virtual void VisitBlock(Block block)
        {
            VisitStartBlock(block);
            foreach (SyntaxTreeNode node in block.Children)
            {
                node.Accept(this);
            }
            VisitEndBlock(block);
        }

        public virtual void VisitStartBlock(Block block)
        {
            ThrowIfCanceled();
        }

        public virtual void VisitSpan(Span span)
        {
            ThrowIfCanceled();
        }

        public virtual void VisitEndBlock(Block block)
        {
            ThrowIfCanceled();
        }

        public virtual void VisitError(RazorError err)
        {
            ThrowIfCanceled();
        }

        public virtual void OnComplete()
        {
            ThrowIfCanceled();
        }

        public virtual void ThrowIfCanceled()
        {
            if (CancelToken != null && CancelToken.Value.IsCancellationRequested)
            {
                throw new OperationCanceledException();
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/ParserVisitorExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Parser
{
    public static class ParserVisitorExtensions
    {
        public static void Visit(this ParserVisitor self, ParserResults result)
        {
            if (self == null)
            {
                throw new ArgumentNullException("self");
            }
            if (result == null)
            {
                throw new ArgumentNullException("result");
            }

            result.Document.Accept(self);
            foreach (RazorError error in result.ParserErrors)
            {
                self.VisitError(error);
            }
            self.OnComplete();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/RazorParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor.Parser
{
    public class RazorParser
    {
        public RazorParser(ParserBase codeParser, ParserBase markupParser)
        {
            if (codeParser == null)
            {
                throw new ArgumentNullException("codeParser");
            }
            if (markupParser == null)
            {
                throw new ArgumentNullException("markupParser");
            }

            MarkupParser = markupParser;
            CodeParser = codeParser;

            Optimizers = new List<ISyntaxTreeRewriter>()
            {
                // Move whitespace from start of expression block to markup
                new WhiteSpaceRewriter(MarkupParser.BuildSpan),
                // Collapse conditional attributes where the entire value is literal
                new ConditionalAttributeCollapser(MarkupParser.BuildSpan),
            };
        }

        internal ParserBase CodeParser { get; private set; }
        internal ParserBase MarkupParser { get; private set; }
        internal IList<ISyntaxTreeRewriter> Optimizers { get; private set; }

        public bool DesignTimeMode { get; set; }

        public virtual void Parse(TextReader input, ParserVisitor visitor)
        {
            ParserResults results = ParseCore(new SeekableTextReader(input));

            // Replay the results on the visitor
            visitor.Visit(results);
        }

        public virtual ParserResults Parse(TextReader input)
        {
            return ParseCore(new SeekableTextReader(input));
        }

        public virtual ParserResults Parse(ITextDocument input)
        {
            return ParseCore(input);
        }

#pragma warning disable 0618
        [Obsolete("Lookahead-based readers have been deprecated, use overrides which accept a TextReader or ITextDocument instead")]
        public virtual void Parse(LookaheadTextReader input, ParserVisitor visitor)
        {
            ParserResults results = ParseCore(new SeekableTextReader(input));

            // Replay the results on the visitor
            visitor.Visit(results);
        }

        [Obsolete("Lookahead-based readers have been deprecated, use overrides which accept a TextReader or ITextDocument instead")]
        public virtual ParserResults Parse(LookaheadTextReader input)
        {
            return ParseCore(new SeekableTextReader(input));
        }
#pragma warning restore 0618

        public virtual Task CreateParseTask(TextReader input, Action<Span> spanCallback, Action<RazorError> errorCallback)
        {
            return CreateParseTask(input, new CallbackVisitor(spanCallback, errorCallback));
        }

        public virtual Task CreateParseTask(TextReader input, Action<Span> spanCallback, Action<RazorError> errorCallback, SynchronizationContext context)
        {
            return CreateParseTask(input, new CallbackVisitor(spanCallback, errorCallback) { SynchronizationContext = context });
        }

        public virtual Task CreateParseTask(TextReader input, Action<Span> spanCallback, Action<RazorError> errorCallback, CancellationToken cancelToken)
        {
            return CreateParseTask(input, new CallbackVisitor(spanCallback, errorCallback) { CancelToken = cancelToken });
        }

        public virtual Task CreateParseTask(TextReader input, Action<Span> spanCallback, Action<RazorError> errorCallback, SynchronizationContext context, CancellationToken cancelToken)
        {
            return CreateParseTask(input, new CallbackVisitor(spanCallback, errorCallback)
            {
                SynchronizationContext = context,
                CancelToken = cancelToken
            });
        }

        [SuppressMessage("Microsoft.Web.FxCop", "MW1200:DoNotConstructTaskInstances", Justification = "This rule is not applicable to this assembly.")]
        public virtual Task CreateParseTask(TextReader input,
                                            ParserVisitor consumer)
        {
            return new Task(() =>
            {
                try
                {
                    Parse(input, consumer);
                }
                catch (OperationCanceledException)
                {
                    return; // Just return if we're cancelled.
                }
            });
        }

        private ParserResults ParseCore(ITextDocument input)
        {
            // Setup the parser context
            ParserContext context = new ParserContext(input, CodeParser, MarkupParser, MarkupParser)
            {
                DesignTimeMode = DesignTimeMode
            };

            MarkupParser.Context = context;
            CodeParser.Context = context;

            // Execute the parse
            MarkupParser.ParseDocument();

            // Get the result
            ParserResults results = context.CompleteParse();

            // Rewrite whitespace if supported
            Block current = results.Document;
            foreach (ISyntaxTreeRewriter rewriter in Optimizers)
            {
                current = rewriter.Rewrite(current);
            }

            // Link the leaf nodes into a chain
            Span prev = null;
            foreach (Span node in current.Flatten())
            {
                node.Previous = prev;
                if (prev != null)
                {
                    prev.Next = node;
                }
                prev = node;
            }

            // Return the new result
            return new ParserResults(current, results.ParserErrors);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxConstants.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Razor.Parser
{
    public static class SyntaxConstants
    {
        public static readonly string TextTagName = "text";
        public static readonly char TransitionCharacter = '@';
        public static readonly string TransitionString = "@";
        public static readonly string StartCommentSequence = "@*";
        public static readonly string EndCommentSequence = "*@";

        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", Justification = "Class is nested to provide better organization")]
        [SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces", Justification = "This type name should not cause a conflict")]
        public static class CSharp
        {
            public static readonly int UsingKeywordLength = 5;
            public static readonly string InheritsKeyword = "inherits";
            public static readonly string FunctionsKeyword = "functions";
            public static readonly string SectionKeyword = "section";
            public static readonly string HelperKeyword = "helper";
            public static readonly string ElseIfKeyword = "else if";
            public static readonly string NamespaceKeyword = "namespace";
            public static readonly string ClassKeyword = "class";
            public static readonly string LayoutKeyword = "layout";
            public static readonly string SessionStateKeyword = "sessionstate";
        }

        [SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible", Justification = "Class is nested to provide better organization")]
        public static class VB
        {
            public static readonly int ImportsKeywordLength = 7;
            public static readonly string EndKeyword = "End";
            public static readonly string CodeKeyword = "Code";
            public static readonly string FunctionsKeyword = "Functions";
            public static readonly string SectionKeyword = "Section";
            public static readonly string StrictKeyword = "Strict";
            public static readonly string ExplicitKeyword = "Explicit";
            public static readonly string OffKeyword = "Off";
            public static readonly string HelperKeyword = "Helper";
            public static readonly string SelectCaseKeyword = "Select Case";
            public static readonly string LayoutKeyword = "Layout";
            public static readonly string EndCodeKeyword = "End Code";
            public static readonly string EndHelperKeyword = "End Helper";
            public static readonly string EndFunctionsKeyword = "End Functions";
            public static readonly string EndSectionKeyword = "End Section";
            public static readonly string SessionStateKeyword = "SessionState";
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/AcceptedCharacters.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Razor.Parser.SyntaxTree
{
    [Flags]
    public enum AcceptedCharacters
    {
        None = 0,
        NewLine = 1,
        WhiteSpace = 2,

        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "NonWhite", Justification = "This is not a compound word, it is two words")]
        NonWhiteSpace = 4,

        AllWhiteSpace = NewLine | WhiteSpace,
        Any = AllWhiteSpace | NonWhiteSpace,

        [SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "Newline", Justification = "This would be a breaking change to a previous released API")]
        AnyExceptNewline = NonWhiteSpace | WhiteSpace
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/Block.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web.Razor.Generator;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;

namespace System.Web.Razor.Parser.SyntaxTree
{
    public class Block : SyntaxTreeNode
    {
        public Block(BlockBuilder source)
        {
            if (source.Type == null)
            {
                throw new InvalidOperationException(RazorResources.Block_Type_Not_Specified);
            }
            Type = source.Type.Value;
            Children = source.Children;
            Name = source.Name;
            CodeGenerator = source.CodeGenerator;
            source.Reset();

            foreach (SyntaxTreeNode node in Children)
            {
                node.Parent = this;
            }
        }

        internal Block(BlockType type, IEnumerable<SyntaxTreeNode> contents, IBlockCodeGenerator generator)
        {
            Type = type;
            CodeGenerator = generator;
            Children = contents;
        }

        [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods", Justification = "Type is the most appropriate name for this property and there is little chance of confusion with GetType")]
        public BlockType Type { get; private set; }

        public IEnumerable<SyntaxTreeNode> Children { get; private set; }
        public string Name { get; private set; }
        public IBlockCodeGenerator CodeGenerator { get; private set; }

        public override bool IsBlock
        {
            get { return true; }
        }

        public override SourceLocation Start
        {
            get
            {
                SyntaxTreeNode child = Children.FirstOrDefault();
                if (child == null)
                {
                    return SourceLocation.Zero;
                }
                else
                {
                    return child.Start;
                }
            }
        }

        public override int Length
        {
            get { return Children.Sum(child => child.Length); }
        }

        public Span FindFirstDescendentSpan()
        {
            SyntaxTreeNode current = this;
            while (current != null && current.IsBlock)
            {
                current = ((Block)current).Children.FirstOrDefault();
            }
            return current as Span;
        }

        public Span FindLastDescendentSpan()
        {
            SyntaxTreeNode current = this;
            while (current != null && current.IsBlock)
            {
                current = ((Block)current).Children.LastOrDefault();
            }
            return current as Span;
        }

        public override void Accept(ParserVisitor visitor)
        {
            visitor.VisitBlock(this);
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "{0} Block at {1}::{2} (Gen:{3})", Type, Start, Length, CodeGenerator);
        }

        public override bool Equals(object obj)
        {
            Block other = obj as Block;
            return other != null &&
                   Type == other.Type &&
                   Equals(CodeGenerator, other.CodeGenerator) &&
                   ChildrenEqual(Children, other.Children);
        }

        public override int GetHashCode()
        {
            return (int)Type;
        }

        public IEnumerable<Span> Flatten()
        {
            // Create an enumerable that flattens the tree for use by syntax highlighters, etc.
            foreach (SyntaxTreeNode element in Children)
            {
                Span span = element as Span;
                if (span != null)
                {
                    yield return span;
                }
                else
                {
                    Block block = element as Block;
                    foreach (Span childSpan in block.Flatten())
                    {
                        yield return childSpan;
                    }
                }
            }
        }

        public Span LocateOwner(TextChange change)
        {
            // Ask each child recursively
            Span owner = null;
            foreach (SyntaxTreeNode element in Children)
            {
                Span span = element as Span;
                if (span == null)
                {
                    owner = ((Block)element).LocateOwner(change);
                }
                else
                {
                    if (change.OldPosition < span.Start.AbsoluteIndex)
                    {
                        // Early escape for cases where changes overlap multiple spans
                        // In those cases, the span will return false, and we don't want to search the whole tree
                        // So if the current span starts after the change, we know we've searched as far as we need to
                        break;
                    }
                    owner = span.EditHandler.OwnsChange(span, change) ? span : owner;
                }

                if (owner != null)
                {
                    break;
                }
            }
            return owner;
        }

        private static bool ChildrenEqual(IEnumerable<SyntaxTreeNode> left, IEnumerable<SyntaxTreeNode> right)
        {
            IEnumerator<SyntaxTreeNode> leftEnum = left.GetEnumerator();
            IEnumerator<SyntaxTreeNode> rightEnum = right.GetEnumerator();
            while (leftEnum.MoveNext())
            {
                if (!rightEnum.MoveNext() || // More items in left than in right
                    !Equals(leftEnum.Current, rightEnum.Current))
                {
                    // Nodes are not equal
                    return false;
                }
            }
            if (rightEnum.MoveNext())
            {
                // More items in right than left
                return false;
            }
            return true;
        }

        public override bool EquivalentTo(SyntaxTreeNode node)
        {
            Block other = node as Block;
            if (other == null || other.Type != Type)
            {
                return false;
            }
            return Enumerable.SequenceEqual(Children, other.Children, new EquivalenceComparer());
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/BlockBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Generator;

namespace System.Web.Razor.Parser.SyntaxTree
{
    public class BlockBuilder
    {
        public BlockBuilder()
        {
            Reset();
        }

        public BlockBuilder(Block original)
        {
            Type = original.Type;
            Children = new List<SyntaxTreeNode>(original.Children);
            Name = original.Name;
            CodeGenerator = original.CodeGenerator;
        }

        [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods", Justification = "Type is the most appropriate name for this property and there is little chance of confusion with GetType")]
        public BlockType? Type { get; set; }

        public IList<SyntaxTreeNode> Children { get; private set; }
        public string Name { get; set; }
        public IBlockCodeGenerator CodeGenerator { get; set; }

        public Block Build()
        {
            return new Block(this);
        }

        public void Reset()
        {
            Type = null;
            Name = null;
            Children = new List<SyntaxTreeNode>();
            CodeGenerator = BlockCodeGenerator.Null;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/BlockType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Parser.SyntaxTree
{
    public enum BlockType
    {
        // Code
        Statement,
        Directive,
        Functions,
        Expression,
        Helper,

        // Markup
        Markup,
        Section,
        Template,

        // Special
        Comment
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/EquivalenceComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Razor.Parser.SyntaxTree
{
    internal class EquivalenceComparer : IEqualityComparer<SyntaxTreeNode>
    {
        public bool Equals(SyntaxTreeNode x, SyntaxTreeNode y)
        {
            return x.EquivalentTo(y);
        }

        public int GetHashCode(SyntaxTreeNode obj)
        {
            return obj.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/RazorError.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Razor.Text;

namespace System.Web.Razor.Parser.SyntaxTree
{
    public class RazorError : IEquatable<RazorError>
    {
        public RazorError(string message, SourceLocation location)
            : this(message, location, 1)
        {
        }

        public RazorError(string message, int absoluteIndex, int lineIndex, int columnIndex)
            : this(message, new SourceLocation(absoluteIndex, lineIndex, columnIndex))
        {
        }

        public RazorError(string message, SourceLocation location, int length)
        {
            Message = message;
            Location = location;
            Length = length;
        }

        public RazorError(string message, int absoluteIndex, int lineIndex, int columnIndex, int length)
            : this(message, new SourceLocation(absoluteIndex, lineIndex, columnIndex), length)
        {
        }

        public string Message { get; private set; }
        public SourceLocation Location { get; private set; }
        public int Length { get; private set; }

        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "Error @ {0}({2}) - [{1}]", Location, Message, Length);
        }

        public override bool Equals(object obj)
        {
            RazorError err = obj as RazorError;
            return (err != null) && (Equals(err));
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        public bool Equals(RazorError other)
        {
            return String.Equals(other.Message, Message, StringComparison.Ordinal) &&
                   Location.Equals(other.Location);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/Span.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Parser.SyntaxTree
{
    public class Span : SyntaxTreeNode
    {
        private SourceLocation _start;

        public Span(SpanBuilder builder)
        {
            ReplaceWith(builder);
        }

        public SpanKind Kind { get; protected set; }
        public IEnumerable<ISymbol> Symbols { get; protected set; }

        // Allow test code to re-link spans
        public Span Previous { get; protected internal set; }
        public Span Next { get; protected internal set; }

        public SpanEditHandler EditHandler { get; protected set; }
        public ISpanCodeGenerator CodeGenerator { get; protected set; }

        public override bool IsBlock
        {
            get { return false; }
        }

        public override int Length
        {
            get { return Content.Length; }
        }

        public override SourceLocation Start
        {
            get { return _start; }
        }

        public string Content { get; private set; }

        public void Change(Action<SpanBuilder> changes)
        {
            SpanBuilder builder = new SpanBuilder(this);
            changes(builder);
            ReplaceWith(builder);
        }

        public void ReplaceWith(SpanBuilder builder)
        {
            Debug.Assert(!builder.Symbols.Any() || builder.Symbols.All(s => s != null));

            Kind = builder.Kind;
            Symbols = builder.Symbols;
            EditHandler = builder.EditHandler;
            CodeGenerator = builder.CodeGenerator ?? SpanCodeGenerator.Null;
            _start = builder.Start;

            // Since we took references to the values in SpanBuilder, clear its references out
            builder.Reset();

            // Calculate other properties
            Content = Symbols.Aggregate(new StringBuilder(), (sb, sym) => sb.Append(sym.Content), sb => sb.ToString());
        }

        /// <summary>
        /// Accepts the specified visitor
        /// </summary>
        /// <remarks>
        /// Calls the VisitSpan method on the specified visitor, passing in this
        /// </remarks>
        public override void Accept(ParserVisitor visitor)
        {
            visitor.VisitSpan(this);
        }

        public override string ToString()
        {
            StringBuilder builder = new StringBuilder();
            builder.Append(Kind);
            builder.AppendFormat(" Span at {0}::{1} - [{2}]", Start, Length, Content);
            builder.Append(" Edit: <");
            builder.Append(EditHandler.ToString());
            builder.Append(">");
            builder.Append(" Gen: <");
            builder.Append(CodeGenerator.ToString());
            builder.Append("> {");
            builder.Append(String.Join(";", Symbols.GroupBy(sym => sym.GetType()).Select(grp => String.Concat(grp.Key.Name, ":", grp.Count()))));
            builder.Append("}");
            return builder.ToString();
        }

        public void ChangeStart(SourceLocation newStart)
        {
            _start = newStart;
            Span current = this;
            SourceLocationTracker tracker = new SourceLocationTracker(newStart);
            tracker.UpdateLocation(Content);
            while ((current = current.Next) != null)
            {
                current._start = tracker.CurrentLocation;
                tracker.UpdateLocation(current.Content);
            }
        }

        internal void SetStart(SourceLocation newStart)
        {
            _start = newStart;
        }

        /// <summary>
        /// Checks that the specified span is equivalent to the other in that it has the same start point and content.
        /// </summary>
        public override bool EquivalentTo(SyntaxTreeNode node)
        {
            Span other = node as Span;
            return other != null &&
                   Kind.Equals(other.Kind) &&
                   Start.Equals(other.Start) &&
                   EditHandler.Equals(other.EditHandler) &&
                   String.Equals(other.Content, Content, StringComparison.Ordinal);
        }

        public override bool Equals(object obj)
        {
            Span other = obj as Span;
            return other != null &&
                   Kind.Equals(other.Kind) &&
                   EditHandler.Equals(other.EditHandler) &&
                   CodeGenerator.Equals(other.CodeGenerator) &&
                   Symbols.SequenceEqual(other.Symbols);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add((int)Kind)
                .Add(Start)
                .Add(Content)
                .CombinedHash;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/SpanBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser.SyntaxTree
{
    public class SpanBuilder
    {
        private IList<ISymbol> _symbols = new List<ISymbol>();
        private SourceLocationTracker _tracker = new SourceLocationTracker();

        public SpanBuilder(Span original)
        {
            Kind = original.Kind;
            _symbols = new List<ISymbol>(original.Symbols);
            EditHandler = original.EditHandler;
            CodeGenerator = original.CodeGenerator;
            Start = original.Start;
        }

        public SpanBuilder()
        {
            Reset();
        }

        public SourceLocation Start { get; set; }
        public SpanKind Kind { get; set; }

        public ReadOnlyCollection<ISymbol> Symbols
        {
            get { return new ReadOnlyCollection<ISymbol>(_symbols); }
        }

        public SpanEditHandler EditHandler { get; set; }
        public ISpanCodeGenerator CodeGenerator { get; set; }

        public void Reset()
        {
            _symbols = new List<ISymbol>();
            EditHandler = SpanEditHandler.CreateDefault(s => Enumerable.Empty<ISymbol>());
            CodeGenerator = SpanCodeGenerator.Null;
            Start = SourceLocation.Zero;
        }

        public Span Build()
        {
            return new Span(this);
        }

        public void ClearSymbols()
        {
            _symbols.Clear();
        }

        // Short-cut method for adding a symbol
        public void Accept(ISymbol symbol)
        {
            if (symbol == null)
            {
                return;
            }

            if (_symbols.Count == 0)
            {
                Start = symbol.Start;
                symbol.ChangeStart(SourceLocation.Zero);
                _tracker.CurrentLocation = SourceLocation.Zero;
            }
            else
            {
                symbol.ChangeStart(_tracker.CurrentLocation);
            }

            _symbols.Add(symbol);
            _tracker.UpdateLocation(symbol.Content);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/SpanKind.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Parser.SyntaxTree
{
    public enum SpanKind
    {
        Transition,
        MetaCode,
        Comment,
        Code,
        Markup
    }
}


================================================
FILE: src/System.Web.Razor/Parser/SyntaxTree/SyntaxTreeNode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;

namespace System.Web.Razor.Parser.SyntaxTree
{
    public abstract class SyntaxTreeNode
    {
        public Block Parent { get; internal set; }

        /// <summary>
        /// Returns true if this element is a block (to avoid casting)
        /// </summary>
        public abstract bool IsBlock { get; }

        /// <summary>
        /// The length of all the content contained in this node
        /// </summary>
        public abstract int Length { get; }

        /// <summary>
        /// The start point of this node
        /// </summary>
        public abstract SourceLocation Start { get; }

        /// <summary>
        /// Accepts a parser visitor, calling the appropriate visit method and passing in this instance
        /// </summary>
        /// <param name="visitor">The visitor to accept</param>
        public abstract void Accept(ParserVisitor visitor);

        /// <summary>
        /// Determines if the specified node is equivalent to this node
        /// </summary>
        /// <param name="node">The node to compare this node with</param>
        /// <returns>
        /// true if the provided node has all the same content and metadata, though the specific quantity and type of symbols may be different.
        /// </returns>
        public abstract bool EquivalentTo(SyntaxTreeNode node);
    }
}


================================================
FILE: src/System.Web.Razor/Parser/TextReaderExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Text;

namespace System.Web.Razor.Parser
{
    internal static class TextReaderExtensions
    {
        public static string ReadUntil(this TextReader reader, char terminator)
        {
            return ReadUntil(reader, terminator, inclusive: false);
        }

        public static string ReadUntil(this TextReader reader, char terminator, bool inclusive)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }

            // Rather not allocate an array to use ReadUntil(TextReader, params char[]) so we'll just call the predicate version directly
            return reader.ReadUntil(c => c == terminator, inclusive);
        }

        public static string ReadUntil(this TextReader reader, params char[] terminators)
        {
            // NOTE: Using named parameters would be difficult here, hence the inline comment
            return reader.ReadUntil(inclusive: false, terminators: terminators);
        }

        public static string ReadUntil(this TextReader reader, bool inclusive, params char[] terminators)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            if (terminators == null)
            {
                throw new ArgumentNullException("terminators");
            }

            return reader.ReadUntil(c => terminators.Any(tc => tc == c), inclusive: inclusive);
        }

        public static string ReadUntil(this TextReader reader, Predicate<char> condition)
        {
            return reader.ReadUntil(condition, inclusive: false);
        }

        public static string ReadUntil(this TextReader reader, Predicate<char> condition, bool inclusive)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            if (condition == null)
            {
                throw new ArgumentNullException("condition");
            }

            StringBuilder builder = new StringBuilder();
            int ch = -1;
            while ((ch = reader.Peek()) != -1 && !condition((char)ch))
            {
                reader.Read(); // Advance the reader
                builder.Append((char)ch);
            }

            if (inclusive && reader.Peek() != -1)
            {
                builder.Append((char)reader.Read());
            }

            return builder.ToString();
        }

        public static string ReadWhile(this TextReader reader, Predicate<char> condition)
        {
            return reader.ReadWhile(condition, inclusive: false);
        }

        public static string ReadWhile(this TextReader reader, Predicate<char> condition, bool inclusive)
        {
            if (reader == null)
            {
                throw new ArgumentNullException("reader");
            }
            if (condition == null)
            {
                throw new ArgumentNullException("condition");
            }

            return reader.ReadUntil(ch => !condition(ch), inclusive);
        }

        public static string ReadWhiteSpace(this TextReader reader)
        {
            return reader.ReadWhile(c => Char.IsWhiteSpace(c));
        }

        public static string ReadUntilWhiteSpace(this TextReader reader)
        {
            return reader.ReadUntil(c => Char.IsWhiteSpace(c));
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/TokenizerBackedParser.Helpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;
using System.Web.Razor.Utils;

namespace System.Web.Razor.Parser
{
    public abstract partial class TokenizerBackedParser<TTokenizer, TSymbol, TSymbolType> : ParserBase
        where TTokenizer : Tokenizer<TSymbol, TSymbolType>
        where TSymbol : SymbolBase<TSymbolType>
    {
        // Helpers
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This only occurs in Release builds, where this method is empty by design")]
        [Conditional("DEBUG")]
        internal void Assert(TSymbolType expectedType)
        {
            Debug.Assert(!EndOfFile && Equals(CurrentSymbol.Type, expectedType));
        }

        protected internal void PutBack(TSymbol symbol)
        {
            if (symbol != null)
            {
                Tokenizer.PutBack(symbol);
            }
        }

        /// <summary>
        /// Put the specified symbols back in the input stream. The provided list MUST be in the ORDER THE SYMBOLS WERE READ. The
        /// list WILL be reversed and the Putback(TSymbol) will be called on each item.
        /// </summary>
        /// <remarks>
        /// If a document contains symbols: a, b, c, d, e, f
        /// and AcceptWhile or AcceptUntil is used to collect until d
        /// the list returned by AcceptWhile/Until will contain: a, b, c IN THAT ORDER
        /// that is the correct format for providing to this method. The caller of this method would,
        /// in that case, want to put c, b and a back into the stream, so "a, b, c" is the CORRECT order
        /// </remarks>
        protected internal void PutBack(IEnumerable<TSymbol> symbols)
        {
            foreach (TSymbol symbol in symbols.Reverse())
            {
                PutBack(symbol);
            }
        }

        protected internal void PutCurrentBack()
        {
            if (!EndOfFile && CurrentSymbol != null)
            {
                PutBack(CurrentSymbol);
            }
        }

        protected internal bool Balance(BalancingModes mode)
        {
            TSymbolType left = CurrentSymbol.Type;
            TSymbolType right = Language.FlipBracket(left);
            SourceLocation start = CurrentLocation;
            AcceptAndMoveNext();
            if (EndOfFile && !mode.HasFlag(BalancingModes.NoErrorOnFailure))
            {
                Context.OnError(start,
                                RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                Language.GetSample(left),
                                Language.GetSample(right));
            }

            return Balance(mode, left, right, start);
        }

        protected internal bool Balance(BalancingModes mode, TSymbolType left, TSymbolType right, SourceLocation start)
        {
            int startPosition = CurrentLocation.AbsoluteIndex;
            int nesting = 1;
            if (!EndOfFile)
            {
                IList<TSymbol> syms = new List<TSymbol>();
                do
                {
                    if (IsAtEmbeddedTransition(
                        mode.HasFlag(BalancingModes.AllowCommentsAndTemplates),
                        mode.HasFlag(BalancingModes.AllowEmbeddedTransitions)))
                    {
                        Accept(syms);
                        syms.Clear();
                        HandleEmbeddedTransition();

                        // Reset backtracking since we've already outputted some spans.
                        startPosition = CurrentLocation.AbsoluteIndex;
                    }
                    if (At(left))
                    {
                        nesting++;
                    }
                    else if (At(right))
                    {
                        nesting--;
                    }
                    if (nesting > 0)
                    {
                        syms.Add(CurrentSymbol);
                    }
                }
                while (nesting > 0 && NextToken());

                if (nesting > 0)
                {
                    if (!mode.HasFlag(BalancingModes.NoErrorOnFailure))
                    {
                        Context.OnError(start,
                                        RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                        Language.GetSample(left),
                                        Language.GetSample(right));
                    }
                    if (mode.HasFlag(BalancingModes.BacktrackOnFailure))
                    {
                        Context.Source.Position = startPosition;
                        NextToken();
                    }
                    else
                    {
                        Accept(syms);
                    }
                }
                else
                {
                    // Accept all the symbols we saw
                    Accept(syms);
                }
            }
            return nesting == 0;
        }

        protected internal bool NextIs(TSymbolType type)
        {
            return NextIs(sym => sym != null && Equals(type, sym.Type));
        }

        protected internal bool NextIs(params TSymbolType[] types)
        {
            return NextIs(sym => sym != null && types.Any(t => Equals(t, sym.Type)));
        }

        protected internal bool NextIs(Func<TSymbol, bool> condition)
        {
            TSymbol cur = CurrentSymbol;
            NextToken();
            bool result = condition(CurrentSymbol);
            PutCurrentBack();
            PutBack(cur);
            EnsureCurrent();
            return result;
        }

        protected internal bool Was(TSymbolType type)
        {
            return PreviousSymbol != null && Equals(PreviousSymbol.Type, type);
        }

        protected internal bool At(TSymbolType type)
        {
            return !EndOfFile && CurrentSymbol != null && Equals(CurrentSymbol.Type, type);
        }

        protected internal bool AcceptAndMoveNext()
        {
            Accept(CurrentSymbol);
            return NextToken();
        }

        protected TSymbol AcceptSingleWhiteSpaceCharacter()
        {
            if (Language.IsWhiteSpace(CurrentSymbol))
            {
                Tuple<TSymbol, TSymbol> pair = Language.SplitSymbol(CurrentSymbol, 1, Language.GetKnownSymbolType(KnownSymbolType.WhiteSpace));
                Accept(pair.Item1);
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                NextToken();
                return pair.Item2;
            }
            return null;
        }

        protected internal void Accept(IEnumerable<TSymbol> symbols)
        {
            foreach (TSymbol symbol in symbols)
            {
                Accept(symbol);
            }
        }

        protected internal void Accept(TSymbol symbol)
        {
            if (symbol != null)
            {
                foreach (RazorError error in symbol.Errors)
                {
                    Context.Errors.Add(error);
                }
                Span.Accept(symbol);
            }
        }

        protected internal bool AcceptAll(params TSymbolType[] types)
        {
            foreach (TSymbolType type in types)
            {
                if (CurrentSymbol == null || !Equals(CurrentSymbol.Type, type))
                {
                    return false;
                }
                AcceptAndMoveNext();
            }
            return true;
        }

        protected internal void AddMarkerSymbolIfNecessary()
        {
            AddMarkerSymbolIfNecessary(CurrentLocation);
        }

        protected internal void AddMarkerSymbolIfNecessary(SourceLocation location)
        {
            if (Span.Symbols.Count == 0 && Context.LastAcceptedCharacters != AcceptedCharacters.Any)
            {
                Accept(Language.CreateMarkerSymbol(location));
            }
        }

        protected internal void Output(SpanKind kind)
        {
            Configure(kind, null);
            Output();
        }

        protected internal void Output(SpanKind kind, AcceptedCharacters accepts)
        {
            Configure(kind, accepts);
            Output();
        }

        protected internal void Output(AcceptedCharacters accepts)
        {
            Configure(null, accepts);
            Output();
        }

        private void Output()
        {
            if (Span.Symbols.Count > 0)
            {
                Context.AddSpan(Span.Build());
                Initialize(Span);
            }
        }

        protected IDisposable PushSpanConfig()
        {
            return PushSpanConfig(newConfig: (Action<SpanBuilder, Action<SpanBuilder>>)null);
        }

        protected IDisposable PushSpanConfig(Action<SpanBuilder> newConfig)
        {
            return PushSpanConfig(newConfig == null ? (Action<SpanBuilder, Action<SpanBuilder>>)null : (span, _) => newConfig(span));
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "The Action<T> parameters are preferred over custom delegates")]
        protected IDisposable PushSpanConfig(Action<SpanBuilder, Action<SpanBuilder>> newConfig)
        {
            Action<SpanBuilder> old = SpanConfig;
            ConfigureSpan(newConfig);
            return new DisposableAction(() => SpanConfig = old);
        }

        protected void ConfigureSpan(Action<SpanBuilder> config)
        {
            SpanConfig = config;
            Initialize(Span);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "The Action<T> parameters are preferred over custom delegates")]
        protected void ConfigureSpan(Action<SpanBuilder, Action<SpanBuilder>> config)
        {
            Action<SpanBuilder> prev = SpanConfig;
            if (config == null)
            {
                SpanConfig = null;
            }
            else
            {
                SpanConfig = span => config(span, prev);
            }
            Initialize(Span);
        }

        protected internal void Expected(KnownSymbolType type)
        {
            Expected(Language.GetKnownSymbolType(type));
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "types", Justification = "It is used in debug builds")]
        protected internal void Expected(params TSymbolType[] types)
        {
            Debug.Assert(!EndOfFile && CurrentSymbol != null && types.Contains(CurrentSymbol.Type));
            AcceptAndMoveNext();
        }

        protected internal bool Optional(KnownSymbolType type)
        {
            return Optional(Language.GetKnownSymbolType(type));
        }

        protected internal bool Optional(TSymbolType type)
        {
            if (At(type))
            {
                AcceptAndMoveNext();
                return true;
            }
            return false;
        }

        protected internal bool Required(TSymbolType expected, bool errorIfNotFound, string errorBase)
        {
            bool found = At(expected);
            if (!found && errorIfNotFound)
            {
                string error;
                if (Language.IsNewLine(CurrentSymbol))
                {
                    error = RazorResources.ErrorComponent_Newline;
                }
                else if (Language.IsWhiteSpace(CurrentSymbol))
                {
                    error = RazorResources.ErrorComponent_Whitespace;
                }
                else if (EndOfFile)
                {
                    error = RazorResources.ErrorComponent_EndOfFile;
                }
                else
                {
                    error = String.Format(CultureInfo.CurrentCulture, RazorResources.ErrorComponent_Character, CurrentSymbol.Content);
                }

                Context.OnError(
                    CurrentLocation,
                    errorBase,
                    error);
            }
            return found;
        }

        protected bool EnsureCurrent()
        {
            if (CurrentSymbol == null)
            {
                return NextToken();
            }
            return true;
        }

        protected internal void AcceptWhile(TSymbolType type)
        {
            AcceptWhile(sym => Equals(type, sym.Type));
        }

        // We want to avoid array allocations and enumeration where possible, so we use the same technique as String.Format
        protected internal void AcceptWhile(TSymbolType type1, TSymbolType type2)
        {
            AcceptWhile(sym => Equals(type1, sym.Type) || Equals(type2, sym.Type));
        }

        protected internal void AcceptWhile(TSymbolType type1, TSymbolType type2, TSymbolType type3)
        {
            AcceptWhile(sym => Equals(type1, sym.Type) || Equals(type2, sym.Type) || Equals(type3, sym.Type));
        }

        protected internal void AcceptWhile(params TSymbolType[] types)
        {
            AcceptWhile(sym => types.Any(expected => Equals(expected, sym.Type)));
        }

        protected internal void AcceptUntil(TSymbolType type)
        {
            AcceptWhile(sym => !Equals(type, sym.Type));
        }

        // We want to avoid array allocations and enumeration where possible, so we use the same technique as String.Format
        protected internal void AcceptUntil(TSymbolType type1, TSymbolType type2)
        {
            AcceptWhile(sym => !Equals(type1, sym.Type) && !Equals(type2, sym.Type));
        }

        protected internal void AcceptUntil(TSymbolType type1, TSymbolType type2, TSymbolType type3)
        {
            AcceptWhile(sym => !Equals(type1, sym.Type) && !Equals(type2, sym.Type) && !Equals(type3, sym.Type));
        }

        protected internal void AcceptUntil(params TSymbolType[] types)
        {
            AcceptWhile(sym => types.All(expected => !Equals(expected, sym.Type)));
        }

        protected internal void AcceptWhile(Func<TSymbol, bool> condition)
        {
            Accept(ReadWhileLazy(condition));
        }

        protected internal IEnumerable<TSymbol> ReadWhile(Func<TSymbol, bool> condition)
        {
            return ReadWhileLazy(condition).ToList();
        }

        protected TSymbol AcceptWhiteSpaceInLines()
        {
            TSymbol lastWs = null;
            while (Language.IsWhiteSpace(CurrentSymbol) || Language.IsNewLine(CurrentSymbol))
            {
                // Capture the previous whitespace node
                if (lastWs != null)
                {
                    Accept(lastWs);
                }

                if (Language.IsWhiteSpace(CurrentSymbol))
                {
                    lastWs = CurrentSymbol;
                }
                else if (Language.IsNewLine(CurrentSymbol))
                {
                    // Accept newline and reset last whitespace tracker
                    Accept(CurrentSymbol);
                    lastWs = null;
                }

                Tokenizer.Next();
            }
            return lastWs;
        }

        protected bool AtIdentifier(bool allowKeywords)
        {
            return CurrentSymbol != null &&
                   (Language.IsIdentifier(CurrentSymbol) ||
                    (allowKeywords && Language.IsKeyword(CurrentSymbol)));
        }

        // Don't open this to sub classes because it's lazy but it looks eager.
        // You have to advance the Enumerable to read the next characters.
        internal IEnumerable<TSymbol> ReadWhileLazy(Func<TSymbol, bool> condition)
        {
            while (EnsureCurrent() && condition(CurrentSymbol))
            {
                yield return CurrentSymbol;
                NextToken();
            }
        }

        private void Configure(SpanKind? kind, AcceptedCharacters? accepts)
        {
            if (kind != null)
            {
                Span.Kind = kind.Value;
            }
            if (accepts != null)
            {
                Span.EditHandler.AcceptedCharacters = accepts.Value;
            }
        }

        protected virtual void OutputSpanBeforeRazorComment()
        {
            throw new InvalidOperationException(RazorResources.Language_Does_Not_Support_RazorComment);
        }

        private void CommentSpanConfig(SpanBuilder span)
        {
            span.CodeGenerator = SpanCodeGenerator.Null;
            span.EditHandler = SpanEditHandler.CreateDefault(Language.TokenizeString);
        }

        protected void RazorComment()
        {
            if (!Language.KnowsSymbolType(KnownSymbolType.CommentStart) ||
                !Language.KnowsSymbolType(KnownSymbolType.CommentStar) ||
                !Language.KnowsSymbolType(KnownSymbolType.CommentBody))
            {
                throw new InvalidOperationException(RazorResources.Language_Does_Not_Support_RazorComment);
            }
            OutputSpanBeforeRazorComment();
            using (PushSpanConfig(CommentSpanConfig))
            {
                using (Context.StartBlock(BlockType.Comment))
                {
                    Context.CurrentBlock.CodeGenerator = new RazorCommentCodeGenerator();
                    SourceLocation start = CurrentLocation;

                    Expected(KnownSymbolType.CommentStart);
                    Output(SpanKind.Transition, AcceptedCharacters.None);

                    Expected(KnownSymbolType.CommentStar);
                    Output(SpanKind.MetaCode, AcceptedCharacters.None);

                    Optional(KnownSymbolType.CommentBody);
                    AddMarkerSymbolIfNecessary();
                    Output(SpanKind.Comment);

                    bool errorReported = false;
                    if (!Optional(KnownSymbolType.CommentStar))
                    {
                        errorReported = true;
                        Context.OnError(start, RazorResources.ParseError_RazorComment_Not_Terminated);
                    }
                    else
                    {
                        Output(SpanKind.MetaCode, AcceptedCharacters.None);
                    }

                    if (!Optional(KnownSymbolType.CommentStart))
                    {
                        if (!errorReported)
                        {
                            errorReported = true;
                            Context.OnError(start, RazorResources.ParseError_RazorComment_Not_Terminated);
                        }
                    }
                    else
                    {
                        Output(SpanKind.Transition, AcceptedCharacters.None);
                    }
                }
            }
            Initialize(Span);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/TokenizerBackedParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    [SuppressMessage("Microsoft.Design", "CA1005:AvoidExcessiveParametersOnGenericTypes", Justification = "All generic type parameters are required")]
    public abstract partial class TokenizerBackedParser<TTokenizer, TSymbol, TSymbolType> : ParserBase
        where TTokenizer : Tokenizer<TSymbol, TSymbolType>
        where TSymbol : SymbolBase<TSymbolType>
    {
        private TokenizerView<TTokenizer, TSymbol, TSymbolType> _tokenizer;

        protected TokenizerBackedParser()
        {
            Span = new SpanBuilder();
        }

        protected SpanBuilder Span { get; set; }

        protected TokenizerView<TTokenizer, TSymbol, TSymbolType> Tokenizer
        {
            get { return _tokenizer ?? InitTokenizer(); }
        }

        protected Action<SpanBuilder> SpanConfig { get; set; }

        protected TSymbol CurrentSymbol
        {
            get { return Tokenizer.Current; }
        }

        protected TSymbol PreviousSymbol { get; private set; }

        protected SourceLocation CurrentLocation
        {
            get { return (EndOfFile || CurrentSymbol == null) ? Context.Source.Location : CurrentSymbol.Start; }
        }

        protected bool EndOfFile
        {
            get { return Tokenizer.EndOfFile; }
        }

        protected abstract LanguageCharacteristics<TTokenizer, TSymbol, TSymbolType> Language { get; }

        protected virtual void HandleEmbeddedTransition()
        {
        }

        protected virtual bool IsAtEmbeddedTransition(bool allowTemplatesAndComments, bool allowTransitions)
        {
            return false;
        }

        public override void BuildSpan(SpanBuilder span, SourceLocation start, string content)
        {
            foreach (ISymbol sym in Language.TokenizeString(start, content))
            {
                span.Accept(sym);
            }
        }

        protected void Initialize(SpanBuilder span)
        {
            if (SpanConfig != null)
            {
                SpanConfig(span);
            }
        }

        protected internal bool NextToken()
        {
            PreviousSymbol = CurrentSymbol;
            return Tokenizer.Next();
        }

        private TokenizerView<TTokenizer, TSymbol, TSymbolType> InitTokenizer()
        {
            return _tokenizer = new TokenizerView<TTokenizer, TSymbol, TSymbolType>(Language.CreateTokenizer(Context.Source));
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/VBCodeParser.Directives.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class VBCodeParser : TokenizerBackedParser<VBTokenizer, VBSymbol, VBSymbolType>
    {
        private void SetUpDirectives()
        {
            MapDirective(SyntaxConstants.VB.CodeKeyword, EndTerminatedDirective(SyntaxConstants.VB.CodeKeyword,
                                                                                BlockType.Statement,
                                                                                new StatementCodeGenerator(),
                                                                                allowMarkup: true));
            MapDirective(SyntaxConstants.VB.FunctionsKeyword, EndTerminatedDirective(SyntaxConstants.VB.FunctionsKeyword,
                                                                                     BlockType.Functions,
                                                                                     new TypeMemberCodeGenerator(),
                                                                                     allowMarkup: false));
            MapDirective(SyntaxConstants.VB.SectionKeyword, SectionDirective);
            MapDirective(SyntaxConstants.VB.HelperKeyword, HelperDirective);

            MapDirective(SyntaxConstants.VB.LayoutKeyword, LayoutDirective);
            MapDirective(SyntaxConstants.VB.SessionStateKeyword, SessionStateDirective);
        }

        protected virtual bool LayoutDirective()
        {
            AssertDirective(SyntaxConstants.VB.LayoutKeyword);
            AcceptAndMoveNext();
            Context.CurrentBlock.Type = BlockType.Directive;

            // Accept spaces, but not newlines
            bool foundSomeWhitespace = At(VBSymbolType.WhiteSpace);
            AcceptWhile(VBSymbolType.WhiteSpace);
            Output(SpanKind.MetaCode, foundSomeWhitespace ? AcceptedCharacters.None : AcceptedCharacters.Any);

            // First non-whitespace character starts the Layout Page, then newline ends it
            AcceptUntil(VBSymbolType.NewLine);
            Span.CodeGenerator = new SetLayoutCodeGenerator(Span.GetContent());
            Span.EditHandler.EditorHints = EditorHints.LayoutPage | EditorHints.VirtualPath;
            bool foundNewline = Optional(VBSymbolType.NewLine);
            AddMarkerSymbolIfNecessary();
            Output(SpanKind.MetaCode, foundNewline ? AcceptedCharacters.None : AcceptedCharacters.Any);
            return true;
        }

        protected virtual bool SessionStateDirective()
        {
            AssertDirective(SyntaxConstants.VB.SessionStateKeyword);
            AcceptAndMoveNext();
            Context.CurrentBlock.Type = BlockType.Directive;

            // Accept spaces, but not newlines
            bool foundSomeWhitespace = At(VBSymbolType.WhiteSpace);
            AcceptWhile(VBSymbolType.WhiteSpace);
            Output(SpanKind.MetaCode, foundSomeWhitespace ? AcceptedCharacters.None : AcceptedCharacters.Any);

            // First non-whitespace character starts the session state directive, then newline ends it
            AcceptUntil(VBSymbolType.NewLine);
            var value = String.Concat(Span.Symbols.Select(sym => sym.Content));
            Span.CodeGenerator = new RazorDirectiveAttributeCodeGenerator(SyntaxConstants.VB.SessionStateKeyword, value);
            bool foundNewline = Optional(VBSymbolType.NewLine);
            AddMarkerSymbolIfNecessary();
            Output(SpanKind.MetaCode, foundNewline ? AcceptedCharacters.None : AcceptedCharacters.Any);
            return true;
        }

        protected virtual bool HelperDirective()
        {
            if (Context.IsWithin(BlockType.Helper))
            {
                Context.OnError(CurrentLocation, RazorResources.ParseError_Helpers_Cannot_Be_Nested);
            }

            Context.CurrentBlock.Type = BlockType.Helper;
            SourceLocation blockStart = CurrentLocation;

            AssertDirective(SyntaxConstants.VB.HelperKeyword);
            AcceptAndMoveNext();

            VBSymbolType firstAfterKeyword = VBSymbolType.Unknown;
            if (CurrentSymbol != null)
            {
                firstAfterKeyword = CurrentSymbol.Type;
            }

            VBSymbol remainingWs = null;
            if (At(VBSymbolType.NewLine))
            {
                // Accept a _single_ new line, we'll be aborting later.
                AcceptAndMoveNext();
            }
            else
            {
                remainingWs = AcceptSingleWhiteSpaceCharacter();
            }
            if (firstAfterKeyword == VBSymbolType.WhiteSpace || firstAfterKeyword == VBSymbolType.NewLine)
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }
            Output(SpanKind.MetaCode);
            if (firstAfterKeyword != VBSymbolType.WhiteSpace)
            {
                string error;
                if (At(VBSymbolType.NewLine))
                {
                    error = RazorResources.ErrorComponent_Newline;
                }
                else if (EndOfFile)
                {
                    error = RazorResources.ErrorComponent_EndOfFile;
                }
                else
                {
                    error = String.Format(CultureInfo.CurrentCulture, RazorResources.ErrorComponent_Character, CurrentSymbol.Content);
                }

                Context.OnError(
                    CurrentLocation,
                    RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                    error);

                // Bail out.
                PutCurrentBack();
                Output(SpanKind.Code);
                return false;
            }

            if (remainingWs != null)
            {
                Accept(remainingWs);
            }

            bool errorReported = !Required(VBSymbolType.Identifier, RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start);

            AcceptWhile(VBSymbolType.WhiteSpace);

            SourceLocation parensStart = CurrentLocation;
            bool headerComplete = false;
            if (!Optional(VBSymbolType.LeftParenthesis))
            {
                if (!errorReported)
                {
                    errorReported = true;
                    Context.OnError(CurrentLocation,
                                    RazorResources.ParseError_MissingCharAfterHelperName,
                                    VBSymbol.GetSample(VBSymbolType.LeftParenthesis));
                }
            }
            else if (!Balance(BalancingModes.NoErrorOnFailure, VBSymbolType.LeftParenthesis, VBSymbolType.RightParenthesis, parensStart))
            {
                Context.OnError(parensStart, RazorResources.ParseError_UnterminatedHelperParameterList);
            }
            else
            {
                Expected(VBSymbolType.RightParenthesis);
                headerComplete = true;
            }

            AddMarkerSymbolIfNecessary();
            Context.CurrentBlock.CodeGenerator = new HelperCodeGenerator(
                Span.GetContent(),
                headerComplete);
            AutoCompleteEditHandler editHandler = new AutoCompleteEditHandler(Language.TokenizeString);
            Span.EditHandler = editHandler;
            Output(SpanKind.Code);

            if (headerComplete)
            {
                bool old = IsNested;
                IsNested = true;
                using (Context.StartBlock(BlockType.Statement))
                {
                    using (PushSpanConfig(StatementBlockSpanConfiguration(new StatementCodeGenerator())))
                    {
                        try
                        {
                            if (!EndTerminatedDirectiveBody(SyntaxConstants.VB.HelperKeyword, blockStart, allowAllTransitions: true))
                            {
                                if (Context.LastAcceptedCharacters != AcceptedCharacters.Any)
                                {
                                    AddMarkerSymbolIfNecessary();
                                }

                                editHandler.AutoCompleteString = SyntaxConstants.VB.EndHelperKeyword;
                                return false;
                            }
                            else
                            {
                                return true;
                            }
                        }
                        finally
                        {
                            Output(SpanKind.Code);
                            IsNested = old;
                        }
                    }
                }
            }
            else
            {
                Output(SpanKind.Code);
            }
            PutCurrentBack();
            return false;
        }

        protected virtual bool SectionDirective()
        {
            SourceLocation start = CurrentLocation;
            AssertDirective(SyntaxConstants.VB.SectionKeyword);
            AcceptAndMoveNext();

            if (Context.IsWithin(BlockType.Section))
            {
                Context.OnError(CurrentLocation, RazorResources.ParseError_Sections_Cannot_Be_Nested, RazorResources.SectionExample_VB);
            }

            if (At(VBSymbolType.NewLine))
            {
                AcceptAndMoveNext();
            }
            else
            {
                AcceptVBSpaces();
            }
            string sectionName = null;
            if (!At(VBSymbolType.Identifier))
            {
                Context.OnError(CurrentLocation,
                                RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start,
                                GetCurrentSymbolDisplay());
            }
            else
            {
                sectionName = CurrentSymbol.Content;
                AcceptAndMoveNext();
            }
            Context.CurrentBlock.Type = BlockType.Section;
            Context.CurrentBlock.CodeGenerator = new SectionCodeGenerator(sectionName ?? String.Empty);

            AutoCompleteEditHandler editHandler = new AutoCompleteEditHandler(Language.TokenizeString);
            Span.EditHandler = editHandler;

            PutCurrentBack();

            Output(SpanKind.MetaCode);

            // Parse the section
            OtherParserBlock(null, SyntaxConstants.VB.EndSectionKeyword);

            Span.CodeGenerator = SpanCodeGenerator.Null;
            bool complete = false;
            if (!At(VBKeyword.End))
            {
                Context.OnError(start,
                                RazorResources.ParseError_BlockNotTerminated,
                                SyntaxConstants.VB.SectionKeyword,
                                SyntaxConstants.VB.EndSectionKeyword);
                editHandler.AutoCompleteString = SyntaxConstants.VB.EndSectionKeyword;
            }
            else
            {
                AcceptAndMoveNext();
                AcceptWhile(VBSymbolType.WhiteSpace);
                if (!At(SyntaxConstants.VB.SectionKeyword))
                {
                    Context.OnError(start,
                                    RazorResources.ParseError_BlockNotTerminated,
                                    SyntaxConstants.VB.SectionKeyword,
                                    SyntaxConstants.VB.EndSectionKeyword);
                }
                else
                {
                    AcceptAndMoveNext();
                    Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                    complete = true;
                }
            }
            PutCurrentBack();
            Output(SpanKind.MetaCode);
            return complete;
        }

        protected virtual Func<bool> EndTerminatedDirective(string directive, BlockType blockType, SpanCodeGenerator codeGenerator, bool allowMarkup)
        {
            return () =>
            {
                SourceLocation blockStart = CurrentLocation;
                Context.CurrentBlock.Type = blockType;
                AssertDirective(directive);
                AcceptAndMoveNext();

                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                Span.CodeGenerator = SpanCodeGenerator.Null;
                Output(SpanKind.MetaCode);

                using (PushSpanConfig(StatementBlockSpanConfiguration(codeGenerator)))
                {
                    AutoCompleteEditHandler editHandler = new AutoCompleteEditHandler(Language.TokenizeString);
                    Span.EditHandler = editHandler;

                    if (!EndTerminatedDirectiveBody(directive, blockStart, allowMarkup))
                    {
                        editHandler.AutoCompleteString = String.Concat(SyntaxConstants.VB.EndKeyword, " ", directive);
                        return false;
                    }
                    return true;
                }
            };
        }

        protected virtual bool EndTerminatedDirectiveBody(string directive, SourceLocation blockStart, bool allowAllTransitions)
        {
            while (!EndOfFile)
            {
                VBSymbol lastWhitespace = AcceptWhiteSpaceInLines();
                if (IsAtEmbeddedTransition(allowTemplatesAndComments: allowAllTransitions, allowTransitions: allowAllTransitions))
                {
                    HandleEmbeddedTransition(lastWhitespace);
                }
                else
                {
                    if (At(VBKeyword.End))
                    {
                        Accept(lastWhitespace);
                        VBSymbol end = CurrentSymbol;
                        NextToken();
                        IEnumerable<VBSymbol> ws = ReadVBSpaces();
                        if (At(directive))
                        {
                            if (Context.LastAcceptedCharacters != AcceptedCharacters.Any)
                            {
                                AddMarkerSymbolIfNecessary(end.Start);
                            }
                            Output(SpanKind.Code);
                            Accept(end);
                            Accept(ws);
                            AcceptAndMoveNext();
                            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                            Span.CodeGenerator = SpanCodeGenerator.Null;
                            Output(SpanKind.MetaCode);
                            return true;
                        }
                        else
                        {
                            Accept(end);
                            Accept(ws);
                            AcceptAndMoveNext();
                        }
                    }
                    else
                    {
                        Accept(lastWhitespace);
                        AcceptAndMoveNext();
                    }
                }
            }

            // This is a language keyword, so it does not need to be localized
            Context.OnError(blockStart, RazorResources.ParseError_BlockNotTerminated, directive, String.Concat(SyntaxConstants.VB.EndKeyword, " ", directive));
            return false;
        }

        protected bool At(string directive)
        {
            return At(VBSymbolType.Identifier) && String.Equals(CurrentSymbol.Content, directive, StringComparison.OrdinalIgnoreCase);
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "'this' is used in DEBUG builds")]
        [Conditional("DEBUG")]
        protected void AssertDirective(string directive)
        {
            Assert(VBSymbolType.Identifier);
            Debug.Assert(String.Equals(directive, CurrentSymbol.Content, StringComparison.OrdinalIgnoreCase));
        }

        private string GetCurrentSymbolDisplay()
        {
            if (EndOfFile)
            {
                return RazorResources.ErrorComponent_EndOfFile;
            }
            else if (At(VBSymbolType.NewLine))
            {
                return RazorResources.ErrorComponent_Newline;
            }
            else if (At(VBSymbolType.WhiteSpace))
            {
                return RazorResources.ErrorComponent_Whitespace;
            }
            else
            {
                return String.Format(CultureInfo.CurrentCulture, RazorResources.ErrorComponent_Character, CurrentSymbol.Content);
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/VBCodeParser.Statements.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class VBCodeParser : TokenizerBackedParser<VBTokenizer, VBSymbol, VBSymbolType>
    {
        private void SetUpKeywords()
        {
            MapKeyword(VBKeyword.Using, EndTerminatedStatement(VBKeyword.Using, supportsExit: false, supportsContinue: false)); // http://msdn.microsoft.com/en-us/library/htd05whh.aspx
            MapKeyword(VBKeyword.While, EndTerminatedStatement(VBKeyword.While, supportsExit: true, supportsContinue: true)); // http://msdn.microsoft.com/en-us/library/zh1f56zs.aspx
            MapKeyword(VBKeyword.If, EndTerminatedStatement(VBKeyword.If, supportsExit: false, supportsContinue: false)); // http://msdn.microsoft.com/en-us/library/752y8abs.aspx
            MapKeyword(VBKeyword.Select, EndTerminatedStatement(VBKeyword.Select, supportsExit: true, supportsContinue: false, blockName: SyntaxConstants.VB.SelectCaseKeyword)); // http://msdn.microsoft.com/en-us/library/cy37t14y.aspx
            MapKeyword(VBKeyword.Try, EndTerminatedStatement(VBKeyword.Try, supportsExit: true, supportsContinue: false)); // http://msdn.microsoft.com/en-us/library/fk6t46tz.aspx
            MapKeyword(VBKeyword.With, EndTerminatedStatement(VBKeyword.With, supportsExit: false, supportsContinue: false)); // http://msdn.microsoft.com/en-us/library/wc500chb.aspx
            MapKeyword(VBKeyword.SyncLock, EndTerminatedStatement(VBKeyword.SyncLock, supportsExit: false, supportsContinue: false)); // http://msdn.microsoft.com/en-us/library/3a86s51t.aspx

            // http://msdn.microsoft.com/en-us/library/5z06z1kb.aspx
            // http://msdn.microsoft.com/en-us/library/5ebk1751.aspx
            MapKeyword(VBKeyword.For, KeywordTerminatedStatement(VBKeyword.For, VBKeyword.Next, supportsExit: true, supportsContinue: true));
            MapKeyword(VBKeyword.Do, KeywordTerminatedStatement(VBKeyword.Do, VBKeyword.Loop, supportsExit: true, supportsContinue: true)); // http://msdn.microsoft.com/en-us/library/eked04a7.aspx

            MapKeyword(VBKeyword.Imports, ImportsStatement);
            MapKeyword(VBKeyword.Option, OptionStatement);
            MapKeyword(VBKeyword.Inherits, InheritsStatement);

            MapKeyword(VBKeyword.Class, ReservedWord);
            MapKeyword(VBKeyword.Namespace, ReservedWord);
        }

        protected virtual bool InheritsStatement()
        {
            Assert(VBKeyword.Inherits);

            Span.CodeGenerator = SpanCodeGenerator.Null;
            Context.CurrentBlock.Type = BlockType.Directive;

            AcceptAndMoveNext();
            SourceLocation endInherits = CurrentLocation;

            if (At(VBSymbolType.WhiteSpace))
            {
                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            }

            AcceptWhile(VBSymbolType.WhiteSpace);
            Output(SpanKind.MetaCode);

            if (EndOfFile || At(VBSymbolType.WhiteSpace) || At(VBSymbolType.NewLine))
            {
                Context.OnError(endInherits, RazorResources.ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName);
            }

            // Just accept to a newline
            AcceptUntil(VBSymbolType.NewLine);
            if (!Context.DesignTimeMode)
            {
                // We want the newline to be treated as code, but it causes issues at design-time.
                Optional(VBSymbolType.NewLine);
            }

            string baseType = Span.GetContent();
            Span.CodeGenerator = new SetBaseTypeCodeGenerator(baseType.Trim());

            Output(SpanKind.Code);
            return false;
        }

        protected virtual bool OptionStatement()
        {
            try
            {
                Context.CurrentBlock.Type = BlockType.Directive;

                Assert(VBKeyword.Option);
                AcceptAndMoveNext();
                AcceptWhile(VBSymbolType.WhiteSpace);
                if (!At(VBSymbolType.Identifier))
                {
                    if (CurrentSymbol != null)
                    {
                        Context.OnError(CurrentLocation, String.Format(CultureInfo.CurrentCulture,
                                                                       RazorResources.ParseError_Unexpected,
                                                                       CurrentSymbol.Content));
                    }
                    return false;
                }
                SourceLocation optionLoc = CurrentLocation;
                string option = CurrentSymbol.Content;
                AcceptAndMoveNext();

                AcceptWhile(VBSymbolType.WhiteSpace);
                bool boolVal;
                if (At(VBKeyword.On))
                {
                    AcceptAndMoveNext();
                    boolVal = true;
                }
                else if (At(VBSymbolType.Identifier))
                {
                    if (String.Equals(CurrentSymbol.Content, SyntaxConstants.VB.OffKeyword, StringComparison.OrdinalIgnoreCase))
                    {
                        AcceptAndMoveNext();
                        boolVal = false;
                    }
                    else
                    {
                        Context.OnError(CurrentLocation, String.Format(CultureInfo.CurrentCulture,
                                                                       RazorResources.ParseError_InvalidOptionValue,
                                                                       option,
                                                                       CurrentSymbol.Content));
                        AcceptAndMoveNext();
                        return false;
                    }
                }
                else
                {
                    if (!EndOfFile)
                    {
                        Context.OnError(CurrentLocation, String.Format(CultureInfo.CurrentCulture,
                                                                       RazorResources.ParseError_Unexpected,
                                                                       CurrentSymbol.Content));
                        AcceptAndMoveNext();
                    }
                    return false;
                }

                if (String.Equals(option, SyntaxConstants.VB.StrictKeyword, StringComparison.OrdinalIgnoreCase))
                {
                    Span.CodeGenerator = SetVBOptionCodeGenerator.Strict(boolVal);
                }
                else if (String.Equals(option, SyntaxConstants.VB.ExplicitKeyword, StringComparison.OrdinalIgnoreCase))
                {
                    Span.CodeGenerator = SetVBOptionCodeGenerator.Explicit(boolVal);
                }
                else
                {
                    Span.CodeGenerator = new SetVBOptionCodeGenerator(option, boolVal);
                    Context.OnError(optionLoc, RazorResources.ParseError_UnknownOption, option);
                }
            }
            finally
            {
                if (Span.Symbols.Count > 0)
                {
                    Output(SpanKind.MetaCode);
                }
            }
            return true;
        }

        protected virtual bool ImportsStatement()
        {
            Context.CurrentBlock.Type = BlockType.Directive;
            Assert(VBKeyword.Imports);
            AcceptAndMoveNext();

            AcceptVBSpaces();
            if (At(VBSymbolType.WhiteSpace) || At(VBSymbolType.NewLine))
            {
                Context.OnError(CurrentLocation, RazorResources.ParseError_NamespaceOrTypeAliasExpected);
            }

            // Just accept to a newline
            AcceptUntil(VBSymbolType.NewLine);
            Optional(VBSymbolType.NewLine);

            string ns = String.Concat(Span.Symbols.Skip(1).Select(s => s.Content));
            Span.CodeGenerator = new AddImportCodeGenerator(ns, SyntaxConstants.VB.ImportsKeywordLength);

            Output(SpanKind.MetaCode);
            return false;
        }

        protected virtual Func<bool> EndTerminatedStatement(VBKeyword keyword, bool supportsExit, bool supportsContinue)
        {
            return EndTerminatedStatement(keyword, supportsExit, supportsContinue, blockName: keyword.ToString());
        }

        protected virtual Func<bool> EndTerminatedStatement(VBKeyword keyword, bool supportsExit, bool supportsContinue, string blockName)
        {
            return () =>
            {
                using (PushSpanConfig(StatementBlockSpanConfiguration(new StatementCodeGenerator())))
                {
                    SourceLocation blockStart = CurrentLocation;
                    Assert(keyword);
                    AcceptAndMoveNext();

                    while (!EndOfFile)
                    {
                        VBSymbol lastWhitespace = AcceptWhiteSpaceInLines();
                        if (IsAtEmbeddedTransition(allowTemplatesAndComments: true, allowTransitions: true))
                        {
                            HandleEmbeddedTransition(lastWhitespace);
                        }
                        else
                        {
                            Accept(lastWhitespace);

                            if ((supportsExit && At(VBKeyword.Exit)) || (supportsContinue && At(VBKeyword.Continue)))
                            {
                                HandleExitOrContinue(keyword);
                            }
                            else if (At(VBKeyword.End))
                            {
                                AcceptAndMoveNext();
                                AcceptVBSpaces();
                                if (At(keyword))
                                {
                                    AcceptAndMoveNext();
                                    if (!Context.DesignTimeMode)
                                    {
                                        Optional(VBSymbolType.NewLine);
                                    }
                                    Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                                    return false;
                                }
                            }
                            else if (At(keyword))
                            {
                                // Parse nested statement
                                EndTerminatedStatement(keyword, supportsExit, supportsContinue)();
                            }
                            else if (!EndOfFile)
                            {
                                AcceptAndMoveNext();
                            }
                        }
                    }

                    Context.OnError(blockStart,
                                    RazorResources.ParseError_BlockNotTerminated,
                                    blockName,
                                    // This is a language keyword, so it does not need to be localized
                                    String.Concat(VBKeyword.End, " ", keyword));
                    return false;
                }
            };
        }

        protected virtual Func<bool> KeywordTerminatedStatement(VBKeyword start, VBKeyword terminator, bool supportsExit, bool supportsContinue)
        {
            return () =>
            {
                using (PushSpanConfig(StatementBlockSpanConfiguration(new StatementCodeGenerator())))
                {
                    SourceLocation blockStart = CurrentLocation;
                    Assert(start);
                    AcceptAndMoveNext();
                    while (!EndOfFile)
                    {
                        VBSymbol lastWhitespace = AcceptWhiteSpaceInLines();
                        if (IsAtEmbeddedTransition(allowTemplatesAndComments: true, allowTransitions: true))
                        {
                            HandleEmbeddedTransition(lastWhitespace);
                        }
                        else
                        {
                            Accept(lastWhitespace);
                            if ((supportsExit && At(VBKeyword.Exit)) || (supportsContinue && At(VBKeyword.Continue)))
                            {
                                HandleExitOrContinue(start);
                            }
                            else if (At(start))
                            {
                                // Parse nested statement
                                KeywordTerminatedStatement(start, terminator, supportsExit, supportsContinue)();
                            }
                            else if (At(terminator))
                            {
                                AcceptUntil(VBSymbolType.NewLine);
                                Optional(VBSymbolType.NewLine);
                                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.AnyExceptNewline;
                                return false;
                            }
                            else if (!EndOfFile)
                            {
                                AcceptAndMoveNext();
                            }
                        }
                    }

                    Context.OnError(blockStart,
                                    RazorResources.ParseError_BlockNotTerminated,
                                    start, terminator);
                    return false;
                }
            };
        }

        protected void HandleExitOrContinue(VBKeyword keyword)
        {
            Assert(VBSymbolType.Keyword);
            Debug.Assert(CurrentSymbol.Keyword == VBKeyword.Continue || CurrentSymbol.Keyword == VBKeyword.Exit);

            // Accept, read whitespace and look for the next keyword
            AcceptAndMoveNext();
            AcceptWhile(VBSymbolType.WhiteSpace);

            // If this is the start keyword, skip it and continue (to avoid starting a nested statement block)
            Optional(keyword);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/VBCodeParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public partial class VBCodeParser : TokenizerBackedParser<VBTokenizer, VBSymbol, VBSymbolType>
    {
        internal static ISet<string> DefaultKeywords = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
        {
            "functions",
            "code",
            "section",
            "do",
            "while",
            "if",
            "select",
            "for",
            "try",
            "with",
            "synclock",
            "using",
            "imports",
            "inherits",
            "option",
            "helper",
            "namespace",
            "class",
            "layout",
            "sessionstate"
        };

        private Dictionary<VBKeyword, Func<bool>> _keywordHandlers = new Dictionary<VBKeyword, Func<bool>>();
        private Dictionary<string, Func<bool>> _directiveHandlers = new Dictionary<string, Func<bool>>(StringComparer.OrdinalIgnoreCase);

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "Necessary state is initialized before calling virtual methods")]
        public VBCodeParser()
        {
            DirectParentIsCode = false;
            Keywords = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
            SetUpKeywords();
            SetUpDirectives();
        }

        protected internal ISet<string> Keywords { get; private set; }

        protected override LanguageCharacteristics<VBTokenizer, VBSymbol, VBSymbolType> Language
        {
            get { return VBLanguageCharacteristics.Instance; }
        }

        protected override ParserBase OtherParser
        {
            get { return Context.MarkupParser; }
        }

        private bool IsNested { get; set; }
        private bool DirectParentIsCode { get; set; }

        protected override bool IsAtEmbeddedTransition(bool allowTemplatesAndComments, bool allowTransitions)
        {
            return (allowTransitions && Language.IsTransition(CurrentSymbol) && !Was(VBSymbolType.Dot)) ||
                   (allowTemplatesAndComments && Language.IsCommentStart(CurrentSymbol)) ||
                   (Language.IsTransition(CurrentSymbol) && NextIs(VBSymbolType.Transition));
        }

        protected override void HandleEmbeddedTransition()
        {
            HandleEmbeddedTransition(null);
        }

        protected void HandleEmbeddedTransition(VBSymbol lastWhiteSpace)
        {
            if (At(VBSymbolType.RazorCommentTransition))
            {
                Accept(lastWhiteSpace);
                RazorComment();
            }
            else if ((At(VBSymbolType.Transition) && !Was(VBSymbolType.Dot)))
            {
                HandleTransition(lastWhiteSpace);
            }
        }

        public override void ParseBlock()
        {
            if (Context == null)
            {
                throw new InvalidOperationException(RazorResources.Parser_Context_Not_Set);
            }
            using (PushSpanConfig())
            {
                if (Context == null)
                {
                    throw new InvalidOperationException(RazorResources.Parser_Context_Not_Set);
                }

                Initialize(Span);
                NextToken();
                using (Context.StartBlock())
                {
                    IEnumerable<VBSymbol> syms = ReadWhile(sym => sym.Type == VBSymbolType.WhiteSpace);
                    if (At(VBSymbolType.Transition))
                    {
                        Accept(syms);
                        Span.CodeGenerator = new StatementCodeGenerator();
                        Output(SpanKind.Code);
                    }
                    else
                    {
                        PutBack(syms);
                        EnsureCurrent();
                    }

                    // Allow a transition span, but don't require it
                    if (Optional(VBSymbolType.Transition))
                    {
                        Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                        Span.CodeGenerator = SpanCodeGenerator.Null;
                        Output(SpanKind.Transition);
                    }

                    Context.CurrentBlock.Type = BlockType.Expression;
                    Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();

                    // Determine the type of the block
                    bool isComplete = false;
                    Action<SpanBuilder> config = null;
                    if (!EndOfFile)
                    {
                        switch (CurrentSymbol.Type)
                        {
                            case VBSymbolType.Identifier:
                                if (!TryDirectiveBlock(ref isComplete))
                                {
                                    ImplicitExpression();
                                }
                                break;
                            case VBSymbolType.LeftParenthesis:
                                isComplete = ExplicitExpression();
                                break;
                            case VBSymbolType.Keyword:
                                Context.CurrentBlock.Type = BlockType.Statement;
                                Context.CurrentBlock.CodeGenerator = BlockCodeGenerator.Null;
                                isComplete = KeywordBlock();
                                break;
                            case VBSymbolType.WhiteSpace:
                            case VBSymbolType.NewLine:
                                config = ImplictExpressionSpanConfig;
                                Context.OnError(CurrentLocation,
                                                RazorResources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_VB);
                                break;
                            default:
                                config = ImplictExpressionSpanConfig;
                                Context.OnError(CurrentLocation,
                                                RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_VB,
                                                CurrentSymbol.Content);
                                break;
                        }
                    }
                    else
                    {
                        config = ImplictExpressionSpanConfig;
                        Context.OnError(CurrentLocation,
                                        RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock);
                    }
                    using (PushSpanConfig(config))
                    {
                        if (!isComplete && Span.Symbols.Count == 0 && Context.LastAcceptedCharacters != AcceptedCharacters.Any)
                        {
                            AddMarkerSymbolIfNecessary();
                        }
                        Output(SpanKind.Code);
                        PutCurrentBack();
                    }
                }
            }
        }

        private void ImplictExpressionSpanConfig(SpanBuilder span)
        {
            span.CodeGenerator = new ExpressionCodeGenerator();
            span.EditHandler = new ImplicitExpressionEditHandler(
                Language.TokenizeString,
                Keywords,
                acceptTrailingDot: DirectParentIsCode)
            {
                AcceptedCharacters = AcceptedCharacters.NonWhiteSpace
            };
        }

        private Action<SpanBuilder> StatementBlockSpanConfiguration(SpanCodeGenerator codeGenerator)
        {
            return span =>
            {
                span.Kind = SpanKind.Code;
                span.CodeGenerator = codeGenerator;
                span.EditHandler = SpanEditHandler.CreateDefault(Language.TokenizeString);
            };
        }

        // Pass "complete" flag by ref, not out because some paths may not change it.
        private bool TryDirectiveBlock(ref bool complete)
        {
            Assert(VBSymbolType.Identifier);
            Func<bool> handler;
            if (_directiveHandlers.TryGetValue(CurrentSymbol.Content, out handler))
            {
                Context.CurrentBlock.CodeGenerator = BlockCodeGenerator.Null;
                complete = handler();
                return true;
            }
            return false;
        }

        private bool KeywordBlock()
        {
            Assert(VBSymbolType.Keyword);
            Func<bool> handler;
            if (_keywordHandlers.TryGetValue(CurrentSymbol.Keyword.Value, out handler))
            {
                Span.CodeGenerator = new StatementCodeGenerator();
                Context.CurrentBlock.Type = BlockType.Statement;
                return handler();
            }
            else
            {
                ImplicitExpression();
                return false;
            }
        }

        private bool ExplicitExpression()
        {
            Context.CurrentBlock.Type = BlockType.Expression;
            Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();
            SourceLocation start = CurrentLocation;
            Expected(VBSymbolType.LeftParenthesis);
            Span.CodeGenerator = SpanCodeGenerator.Null;
            Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
            Output(SpanKind.MetaCode);

            Span.CodeGenerator = new ExpressionCodeGenerator();
            using (PushSpanConfig(span => span.CodeGenerator = new ExpressionCodeGenerator()))
            {
                if (!Balance(BalancingModes.NoErrorOnFailure |
                             BalancingModes.BacktrackOnFailure |
                             BalancingModes.AllowCommentsAndTemplates,
                             VBSymbolType.LeftParenthesis,
                             VBSymbolType.RightParenthesis,
                             start))
                {
                    Context.OnError(start,
                                    RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                    RazorResources.BlockName_ExplicitExpression,
                                    VBSymbol.GetSample(VBSymbolType.RightParenthesis),
                                    VBSymbol.GetSample(VBSymbolType.LeftParenthesis));
                    AcceptUntil(VBSymbolType.NewLine);
                    AddMarkerSymbolIfNecessary();
                    Output(SpanKind.Code);
                    PutCurrentBack();
                    return false;
                }
                else
                {
                    AddMarkerSymbolIfNecessary();
                    Output(SpanKind.Code);
                    Expected(VBSymbolType.RightParenthesis);
                    Span.EditHandler.AcceptedCharacters = AcceptedCharacters.None;
                    Span.CodeGenerator = SpanCodeGenerator.Null;
                    Output(SpanKind.MetaCode);
                    PutCurrentBack();
                    return true;
                }
            }
        }

        private void ImplicitExpression()
        {
            Context.CurrentBlock.Type = BlockType.Expression;
            Context.CurrentBlock.CodeGenerator = new ExpressionCodeGenerator();
            using (PushSpanConfig(ImplictExpressionSpanConfig))
            {
                Expected(VBSymbolType.Identifier, VBSymbolType.Keyword);
                Span.CodeGenerator = new ExpressionCodeGenerator();
                while (!EndOfFile)
                {
                    switch (CurrentSymbol.Type)
                    {
                        case VBSymbolType.LeftParenthesis:
                            SourceLocation start = CurrentLocation;
                            AcceptAndMoveNext();

                            Action<SpanBuilder> oldConfig = SpanConfig;
                            using (PushSpanConfig())
                            {
                                ConfigureSpan(span =>
                                {
                                    oldConfig(span);
                                    span.EditHandler.AcceptedCharacters = AcceptedCharacters.Any;
                                });
                                Balance(BalancingModes.AllowCommentsAndTemplates,
                                        VBSymbolType.LeftParenthesis,
                                        VBSymbolType.RightParenthesis,
                                        start);
                            }
                            if (Optional(VBSymbolType.RightParenthesis))
                            {
                                Span.EditHandler.AcceptedCharacters = AcceptedCharacters.NonWhiteSpace;
                            }
                            break;
                        case VBSymbolType.Dot:
                            VBSymbol dot = CurrentSymbol;
                            NextToken();
                            if (At(VBSymbolType.Identifier) || At(VBSymbolType.Keyword))
                            {
                                Accept(dot);
                                AcceptAndMoveNext();
                            }
                            else if (At(VBSymbolType.Transition))
                            {
                                VBSymbol at = CurrentSymbol;
                                NextToken();
                                if (At(VBSymbolType.Identifier) || At(VBSymbolType.Keyword))
                                {
                                    Accept(dot);
                                    Accept(at);
                                    AcceptAndMoveNext();
                                }
                                else
                                {
                                    PutBack(at);
                                    PutBack(dot);
                                }
                            }
                            else
                            {
                                PutCurrentBack();
                                if (IsNested)
                                {
                                    Accept(dot);
                                }
                                else
                                {
                                    PutBack(dot);
                                }
                                return;
                            }
                            break;
                        default:
                            PutCurrentBack();
                            return;
                    }
                }
            }
        }

        protected void MapKeyword(VBKeyword keyword, Func<bool> action)
        {
            _keywordHandlers[keyword] = action;
            Keywords.Add(keyword.ToString());
        }

        protected void MapDirective(string directive, Func<bool> action)
        {
            _directiveHandlers[directive] = action;
            Keywords.Add(directive);
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This only occurs in Release builds, where this method is empty by design")]
        [Conditional("DEBUG")]
        protected void Assert(VBKeyword keyword)
        {
            Debug.Assert(CurrentSymbol.Type == VBSymbolType.Keyword && CurrentSymbol.Keyword == keyword);
        }

        protected bool At(VBKeyword keyword)
        {
            return At(VBSymbolType.Keyword) && CurrentSymbol.Keyword == keyword;
        }

        protected void OtherParserBlock()
        {
            OtherParserBlock(null, null);
        }

        protected void OtherParserBlock(string startSequence, string endSequence)
        {
            using (PushSpanConfig())
            {
                if (Span.Symbols.Count > 0)
                {
                    Output(SpanKind.Code);
                }

                Context.SwitchActiveParser();

                bool old = DirectParentIsCode;
                DirectParentIsCode = false;

                Debug.Assert(ReferenceEquals(Context.ActiveParser, Context.MarkupParser));
                if (!String.IsNullOrEmpty(startSequence) || !String.IsNullOrEmpty(endSequence))
                {
                    Context.MarkupParser.ParseSection(Tuple.Create(startSequence, endSequence), false);
                }
                else
                {
                    Context.MarkupParser.ParseBlock();
                }

                DirectParentIsCode = old;

                Context.SwitchActiveParser();
                EnsureCurrent();
            }
            Initialize(Span);
        }

        protected void HandleTransition(VBSymbol lastWhiteSpace)
        {
            if (At(VBSymbolType.RazorCommentTransition))
            {
                Accept(lastWhiteSpace);
                RazorComment();
                return;
            }

            // Check the next character
            VBSymbol transition = CurrentSymbol;
            NextToken();
            if (At(VBSymbolType.LessThan) || At(VBSymbolType.Colon))
            {
                // Put the transition back
                PutCurrentBack();
                PutBack(transition);

                // If we're in design-time mode, accept the whitespace, otherwise put it back
                if (Context.DesignTimeMode)
                {
                    Accept(lastWhiteSpace);
                }
                else
                {
                    PutBack(lastWhiteSpace);
                }

                // Switch to markup
                OtherParserBlock();
            }
            else if (At(VBSymbolType.Transition))
            {
                if (Context.IsWithin(BlockType.Template))
                {
                    Context.OnError(transition.Start, RazorResources.ParseError_InlineMarkup_Blocks_Cannot_Be_Nested);
                }
                Accept(lastWhiteSpace);
                VBSymbol transition2 = CurrentSymbol;
                NextToken();
                if (At(VBSymbolType.LessThan) || At(VBSymbolType.Colon))
                {
                    PutCurrentBack();
                    PutBack(transition2);
                    PutBack(transition);
                    Output(SpanKind.Code);

                    // Start a template block and switch to Markup
                    using (Context.StartBlock(BlockType.Template))
                    {
                        Context.CurrentBlock.CodeGenerator = new TemplateBlockCodeGenerator();
                        OtherParserBlock();
                        Initialize(Span);
                    }
                }
                else
                {
                    Accept(transition);
                    Accept(transition2);
                }
            }
            else
            {
                Accept(lastWhiteSpace);

                PutCurrentBack();
                PutBack(transition);

                bool old = IsNested;
                IsNested = true;
                NestedBlock();
                IsNested = old;
            }
        }

        protected override void OutputSpanBeforeRazorComment()
        {
            Output(SpanKind.Code);
        }

        protected bool ReservedWord()
        {
            Context.CurrentBlock.Type = BlockType.Directive;
            Context.OnError(CurrentLocation, RazorResources.ParseError_ReservedWord, CurrentSymbol.Content);
            Span.CodeGenerator = SpanCodeGenerator.Null;
            AcceptAndMoveNext();
            Output(SpanKind.MetaCode, AcceptedCharacters.None);
            return true;
        }

        protected void NestedBlock()
        {
            using (PushSpanConfig())
            {
                Output(SpanKind.Code);

                bool old = DirectParentIsCode;
                DirectParentIsCode = true;

                ParseBlock();

                DirectParentIsCode = old;
            }
            Initialize(Span);
        }

        protected bool Required(VBSymbolType expected, string errorBase)
        {
            if (!Optional(expected))
            {
                Context.OnError(CurrentLocation, errorBase, GetCurrentSymbolDisplay());
                return false;
            }
            return true;
        }

        protected bool Optional(VBKeyword keyword)
        {
            if (At(keyword))
            {
                AcceptAndMoveNext();
                return true;
            }
            return false;
        }

        protected void AcceptVBSpaces()
        {
            Accept(ReadVBSpacesLazy());
        }

        protected IEnumerable<VBSymbol> ReadVBSpaces()
        {
            return ReadVBSpacesLazy().ToList();
        }

        public bool IsDirectiveDefined(string directive)
        {
            return _directiveHandlers.ContainsKey(directive);
        }

        private IEnumerable<VBSymbol> ReadVBSpacesLazy()
        {
            foreach (var symbol in ReadWhileLazy(sym => sym.Type == VBSymbolType.WhiteSpace))
            {
                yield return symbol;
            }
            while (At(VBSymbolType.LineContinuation))
            {
                int bookmark = CurrentLocation.AbsoluteIndex;
                VBSymbol under = CurrentSymbol;
                NextToken();
                if (At(VBSymbolType.NewLine))
                {
                    yield return under;
                    yield return CurrentSymbol;
                    NextToken();
                    foreach (var symbol in ReadVBSpaces())
                    {
                        yield return symbol;
                    }
                }
                else
                {
                    Context.Source.Position = bookmark;
                    NextToken();
                    yield break;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/VBLanguageCharacteristics.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Parser
{
    public class VBLanguageCharacteristics : LanguageCharacteristics<VBTokenizer, VBSymbol, VBSymbolType>
    {
        private static readonly VBLanguageCharacteristics _instance = new VBLanguageCharacteristics();

        private VBLanguageCharacteristics()
        {
        }

        public static VBLanguageCharacteristics Instance
        {
            get { return _instance; }
        }

        public override VBTokenizer CreateTokenizer(ITextDocument source)
        {
            return new VBTokenizer(source);
        }

        public override string GetSample(VBSymbolType type)
        {
            return VBSymbol.GetSample(type);
        }

        public override VBSymbolType FlipBracket(VBSymbolType bracket)
        {
            switch (bracket)
            {
                case VBSymbolType.LeftBrace:
                    return VBSymbolType.RightBrace;
                case VBSymbolType.LeftBracket:
                    return VBSymbolType.RightBracket;
                case VBSymbolType.LeftParenthesis:
                    return VBSymbolType.RightParenthesis;
                case VBSymbolType.RightBrace:
                    return VBSymbolType.LeftBrace;
                case VBSymbolType.RightBracket:
                    return VBSymbolType.LeftBracket;
                case VBSymbolType.RightParenthesis:
                    return VBSymbolType.LeftParenthesis;
                default:
                    return VBSymbolType.Unknown;
            }
        }

        public override VBSymbol CreateMarkerSymbol(SourceLocation location)
        {
            return new VBSymbol(location, String.Empty, VBSymbolType.Unknown);
        }

        public override VBSymbolType GetKnownSymbolType(KnownSymbolType type)
        {
            switch (type)
            {
                case KnownSymbolType.CommentStart:
                    return VBSymbolType.RazorCommentTransition;
                case KnownSymbolType.CommentStar:
                    return VBSymbolType.RazorCommentStar;
                case KnownSymbolType.CommentBody:
                    return VBSymbolType.RazorComment;
                case KnownSymbolType.Identifier:
                    return VBSymbolType.Identifier;
                case KnownSymbolType.Keyword:
                    return VBSymbolType.Keyword;
                case KnownSymbolType.NewLine:
                    return VBSymbolType.NewLine;
                case KnownSymbolType.Transition:
                    return VBSymbolType.Transition;
                case KnownSymbolType.WhiteSpace:
                    return VBSymbolType.WhiteSpace;
                default:
                    return VBSymbolType.Unknown;
            }
        }

        protected override VBSymbol CreateSymbol(SourceLocation location, string content, VBSymbolType type, IEnumerable<RazorError> errors)
        {
            return new VBSymbol(location, content, type, errors);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Parser/WhitespaceRewriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor.Parser
{
    internal class WhiteSpaceRewriter : MarkupRewriter
    {
        public WhiteSpaceRewriter(Action<SpanBuilder, SourceLocation, string> markupSpanFactory) : base(markupSpanFactory)
        {
        }

        protected override bool CanRewrite(Block block)
        {
            return block.Type == BlockType.Expression && Parent != null;
        }

        //public override void VisitBlock(Block block)
        //{
        //    BlockBuilder parent = null;
        //    if (_blocks.Count > 0)
        //    {
        //        parent = _blocks.Peek();
        //    }
        //    BlockBuilder newBlock = new BlockBuilder(block);
        //    newBlock.Children.Clear();
        //    _blocks.Push(newBlock);
        //    if (block.Type == BlockType.Expression && parent != null)
        //    {
        //        VisitExpressionBlock(block, parent);
        //    }
        //    else
        //    {
        //        base.VisitBlock(block);
        //    }
        //    if (_blocks.Count > 1)
        //    {
        //        parent.Children.Add(_blocks.Pop().Build());
        //    }
        //}

        //public override void VisitSpan(Span span)
        //{
        //    Debug.Assert(_blocks.Count > 0);
        //    _blocks.Peek().Children.Add(span);
        //}

        protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
        {
            BlockBuilder newBlock = new BlockBuilder(block);
            newBlock.Children.Clear();
            Span ws = block.Children.FirstOrDefault() as Span;
            IEnumerable<SyntaxTreeNode> newNodes = block.Children;
            if (ws.Content.All(Char.IsWhiteSpace))
            {
                // Add this node to the parent
                SpanBuilder builder = new SpanBuilder(ws);
                builder.ClearSymbols();
                FillSpan(builder, ws.Start, ws.Content);
                parent.Children.Add(builder.Build());

                // Remove the old whitespace node
                newNodes = block.Children.Skip(1);
            }

            foreach (SyntaxTreeNode node in newNodes)
            {
                newBlock.Children.Add(node);
            }
            return newBlock.Build();
        }
    }
}


================================================
FILE: src/System.Web.Razor/ParserResults.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor
{
    /// <summary>
    /// Represents the results of parsing a Razor document
    /// </summary>
    public class ParserResults
    {
        public ParserResults(Block document, IList<RazorError> parserErrors)
            : this(parserErrors == null || parserErrors.Count == 0, document, parserErrors)
        {
        }

        protected ParserResults(bool success, Block document, IList<RazorError> errors)
        {
            Success = success;
            Document = document;
            ParserErrors = errors ?? new List<RazorError>();
        }

        /// <summary>
        /// Indicates if parsing was successful (no errors)
        /// </summary>
        public bool Success { get; private set; }

        /// <summary>
        /// The root node in the document's syntax tree
        /// </summary>
        public Block Document { get; private set; }

        /// <summary>
        /// The list of errors which occurred during parsing.
        /// </summary>
        public IList<RazorError> ParserErrors { get; private set; }
    }
}


================================================
FILE: src/System.Web.Razor/PartialParseResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Razor
{
    // Flags:
    //  Provisional, ContextChanged, Accepted, Rejected
    //  000001 1  - Rejected,
    //  000010 2  - Accepted
    //  000100 4  - Provisional
    //  001000 8  - Context Changed
    //  010000 16 - Auto Complete Block

    /// <summary>
    /// The result of attempting an incremental parse
    /// </summary>
    /// <remarks>
    /// Either the Accepted or Rejected flag is ALWAYS set.  
    /// Additionally, Provisional may be set with Accepted and SpanContextChanged may be set with Rejected.
    /// Provisional may NOT be set with Rejected and SpanContextChanged may NOT be set with Accepted.
    /// </remarks>
    [Flags]
    [SuppressMessage("Microsoft.Naming", "CA1714:FlagsEnumsShouldHavePluralNames", Justification = "The singular name is more appropriate here")]
    public enum PartialParseResult
    {
        /// <summary>
        /// Indicates that the edit could not be accepted and that a reparse is underway.
        /// </summary>
        Rejected = 1,

        /// <summary>
        /// Indicates that the edit was accepted and has been added to the parse tree
        /// </summary>
        Accepted = 2,

        /// <summary>
        /// Indicates that the edit was accepted, but that a reparse should be forced when idle time is available
        /// since the edit may be misclassified
        /// </summary>
        /// <remarks>
        /// This generally occurs when a "." is typed in an Implicit Expression, since editors require that this
        /// be assigned to Code in order to properly support features like IntelliSense.  However, if no further edits
        /// occur following the ".", it should be treated as Markup.
        /// </remarks>
        Provisional = 4,

        /// <summary>
        /// Indicates that the edit caused a change in the span's context and that if any statement completions were active prior to starting this
        /// partial parse, they should be reinitialized.
        /// </summary>
        SpanContextChanged = 8,

        /// <summary>
        /// Indicates that the edit requires an auto completion to occur
        /// </summary>
        AutoCompleteBlock = 16
    }
}


================================================
FILE: src/System.Web.Razor/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("System.Web.Razor")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.Razor.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Web.WebPages.Razor.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("Microsoft.WebPages.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/System.Web.Razor/RazorCodeLanguage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;

namespace System.Web.Razor
{
    /// <summary>
    /// Represents a code language in Razor.
    /// </summary>
    public abstract class RazorCodeLanguage
    {
        private static IDictionary<string, RazorCodeLanguage> _services = new Dictionary<string, RazorCodeLanguage>(StringComparer.OrdinalIgnoreCase)
        {
            { "cshtml", new CSharpRazorCodeLanguage() },
            { "vbhtml", new VBRazorCodeLanguage() }
        };

        /// <summary>
        /// Gets the list of registered languages mapped to file extensions (without a ".")
        /// </summary>
        public static IDictionary<string, RazorCodeLanguage> Languages
        {
            get { return _services; }
        }

        /// <summary>
        /// The name of the language (for use in System.Web.Compilation.BuildProvider.GetDefaultCompilerTypeForLanguage)
        /// </summary>
        public abstract string LanguageName { get; }

        /// <summary>
        /// The type of the CodeDOM provider for this language
        /// </summary>
        public abstract Type CodeDomProviderType { get; }

        /// <summary>
        /// Gets the RazorCodeLanguage registered for the specified file extension
        /// </summary>
        /// <param name="fileExtension">The extension, with or without a "."</param>
        /// <returns>The language registered for that extension</returns>
        public static RazorCodeLanguage GetLanguageByExtension(string fileExtension)
        {
            RazorCodeLanguage service = null;
            Languages.TryGetValue(fileExtension.TrimStart('.'), out service);
            return service;
        }

        /// <summary>
        /// Constructs the code parser.  Must return a new instance on EVERY call to ensure thread-safety
        /// </summary>
        public abstract ParserBase CreateCodeParser();

        /// <summary>
        /// Constructs the code generator.  Must return a new instance on EVERY call to ensure thread-safety
        /// </summary>
        public abstract RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host);
    }
}


================================================
FILE: src/System.Web.Razor/RazorDebugHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if DEBUG

using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor
{
    internal static class RazorDebugHelpers
    {
        private static bool _outputDebuggingEnabled = IsDebuggingEnabled();

        private static readonly Dictionary<char, string> _printableEscapeChars = new Dictionary<char, string>
        {
            { '\0', "\\0" },
            { '\\', "\\\\" },
            { '\'', "'" },
            { '\"', "\\\"" },
            { '\a', "\\a" },
            { '\b', "\\b" },
            { '\f', "\\f" },
            { '\n', "\\n" },
            { '\r', "\\r" },
            { '\t', "\\t" },
            { '\v', "\\v" },
        };

        internal static bool OutputDebuggingEnabled
        {
            get { return _outputDebuggingEnabled; }
        }

        [SuppressMessage("Microsoft.Security", "CA2141:TransparentMethodsMustNotSatisfyLinkDemandsFxCopRule", Justification = "This is debug only")]
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "This is debug only")]
        [SuppressMessage("Microsoft.Globalization", "CA1305:SpecifyIFormatProvider", MessageId = "System.IO.StringWriter.#ctor", Justification = "This is debug only")]
        internal static void WriteGeneratedCode(string sourceFile, CodeCompileUnit codeCompileUnit)
        {
            if (!OutputDebuggingEnabled)
            {
                return;
            }

            RunTask(() =>
            {
                string extension = Path.GetExtension(sourceFile);
                RazorCodeLanguage language = RazorCodeLanguage.GetLanguageByExtension(extension);
                CodeDomProvider provider = CodeDomProvider.CreateProvider(language.LanguageName);

                using (var writer = new StringWriter())
                {
                    // Trim the html part of cshtml or vbhtml
                    string outputExtension = extension.Substring(0, 3);
                    string outputFileName = Normalize(sourceFile) + "_generated" + outputExtension;
                    string outputPath = Path.Combine(Path.GetDirectoryName(sourceFile), outputFileName);

                    // REVIEW: Do these options need to be tweaked?
                    provider.GenerateCodeFromCompileUnit(codeCompileUnit, writer, new CodeGeneratorOptions());
                    File.WriteAllText(outputPath, writer.ToString());
                }
            });
        }

        internal static void WriteDebugTree(string sourceFile, Block document, PartialParseResult result, TextChange change, RazorEditorParser parser, bool treeStructureChanged)
        {
            if (!OutputDebuggingEnabled)
            {
                return;
            }

            RunTask(() =>
            {
                string outputFileName = Normalize(sourceFile) + "_tree";
                string outputPath = Path.Combine(Path.GetDirectoryName(sourceFile), outputFileName);

                var treeBuilder = new StringBuilder();
                WriteTree(document, treeBuilder);
                treeBuilder.AppendLine();
                treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Last Change: {0}", change);
                treeBuilder.AppendLine();
                treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Normalized To: {0}", change.Normalize());
                treeBuilder.AppendLine();
                treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Partial Parse Result: {0}", result);
                treeBuilder.AppendLine();
                if (result.HasFlag(PartialParseResult.Rejected))
                {
                    treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Tree Structure Changed: {0}", treeStructureChanged);
                    treeBuilder.AppendLine();
                }
                if (result.HasFlag(PartialParseResult.AutoCompleteBlock))
                {
                    treeBuilder.AppendFormat(CultureInfo.CurrentCulture, "Auto Complete Insert String: \"{0}\"", parser.GetAutoCompleteString());
                    treeBuilder.AppendLine();
                }
                File.WriteAllText(outputPath, treeBuilder.ToString());
            });
        }

        private static void WriteTree(SyntaxTreeNode node, StringBuilder treeBuilder, int depth = 0)
        {
            if (node == null)
            {
                return;
            }
            if (depth > 1)
            {
                WriteIndent(treeBuilder, depth);
            }

            if (depth > 0)
            {
                treeBuilder.Append("|-- ");
            }

            treeBuilder.AppendLine(ConvertEscapseSequences(node.ToString()));
            if (node.IsBlock)
            {
                foreach (SyntaxTreeNode child in ((Block)node).Children)
                {
                    WriteTree(child, treeBuilder, depth + 1);
                }
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This is debug only")]
        [SuppressMessage("Microsoft.Web.FxCop", "MW1202:DoNotUseProblematicTaskTypes", Justification = "This rule is not applicable to this assembly.")]
        [SuppressMessage("Microsoft.Web.FxCop", "MW1201:DoNotCallProblematicMethodsOnTask", Justification = "This rule is not applicable to this assembly.")]
        private static void RunTask(Action action)
        {
            Task.Factory.StartNew(() =>
            {
                try
                {
                    action();
                }
                catch
                {
                    // Catch all errors since this is just a debug helper
                }
            });
        }

        private static void WriteIndent(StringBuilder sb, int depth)
        {
            for (int i = 0; i < (depth - 1) * 4; ++i)
            {
                if (i % 4 == 0)
                {
                    sb.Append("|");
                }
                else
                {
                    sb.Append(" ");
                }
            }
        }

        private static string Normalize(string path)
        {
            return Path.GetFileName(path).Replace('.', '_');
        }

        private static string ConvertEscapseSequences(string value)
        {
            StringBuilder sb = new StringBuilder();
            foreach (var ch in value)
            {
                sb.Append(GetCharValue(ch));
            }
            return sb.ToString();
        }

        private static string GetCharValue(char ch)
        {
            string value;
            if (_printableEscapeChars.TryGetValue(ch, out value))
            {
                return value;
            }
            return ch.ToString();
        }

        private static bool IsDebuggingEnabled()
        {
            bool enabled;
            return Boolean.TryParse(Environment.GetEnvironmentVariable("RAZOR_DEBUG"), out enabled) && enabled;
        }
    }
}

#endif


================================================
FILE: src/System.Web.Razor/RazorDirectiveAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor
{
    /// <summary>
    /// Specifies a Razor directive that is rendered as an attribute on the generated class. 
    /// </summary>
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)]
    public sealed class RazorDirectiveAttribute : Attribute
    {
        private readonly object _typeId = new object();

        public RazorDirectiveAttribute(string name, string value)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            Name = name;
            Value = value;
        }

        public override object TypeId
        {
            get { return _typeId; }
        }

        public string Name { get; private set; }

        public string Value { get; private set; }

        public override bool Equals(object obj)
        {
            RazorDirectiveAttribute attribute = obj as RazorDirectiveAttribute;
            return attribute != null &&
                   Name.Equals(attribute.Name, StringComparison.OrdinalIgnoreCase) &&
                   StringComparer.OrdinalIgnoreCase.Equals(Value, attribute.Value);
        }

        public override int GetHashCode()
        {
            return (StringComparer.OrdinalIgnoreCase.GetHashCode(Name) * 31) +
                   (Value == null ? 0 : StringComparer.OrdinalIgnoreCase.GetHashCode(Value));
        }
    }
}


================================================
FILE: src/System.Web.Razor/RazorEditorParser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Threading;
using System.Web.Razor.Editor;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor
{
    /// <summary>
    /// Parser used by editors to avoid reparsing the entire document on each text change
    /// </summary>
    /// <remarks>
    /// This parser is designed to allow editors to avoid having to worry about incremental parsing.
    /// The CheckForStructureChanges method can be called with every change made by a user in an editor and
    /// the parser will provide a result indicating if it was able to incrementally reparse the document.
    /// 
    /// The general workflow for editors with this parser is:
    /// 0. User edits document
    /// 1. Editor builds TextChange structure describing the edit and providing a reference to the _updated_ text buffer
    /// 2. Editor calls CheckForStructureChanges passing in that change.
    /// 3. Parser determines if the change can be simply applied to an existing parse tree node
    ///   a.  If it can, the Parser updates its parse tree and returns PartialParseResult.Accepted
    ///   b.  If it can not, the Parser starts a background parse task and return PartialParseResult.Rejected
    /// NOTE: Additional flags can be applied to the PartialParseResult, see that enum for more details.  However,
    ///       the Accepted or Rejected flags will ALWAYS be present
    /// 
    /// A change can only be incrementally parsed if a single, unique, Span (see System.Web.Razor.Parser.SyntaxTree) in the syntax tree can
    /// be identified as owning the entire change.  For example, if a change overlaps with multiple spans, the change cannot be
    /// parsed incrementally and a full reparse is necessary.  A Span "owns" a change if the change occurs either a) entirely
    /// within it's boundaries or b) it is a pure insertion (see TextChange) at the end of a Span whose CanGrow flag (see Span) is
    /// true.
    /// 
    /// Even if a single unique Span owner can be identified, it's possible the edit will cause the Span to split or merge with other
    /// Spans, in which case, a full reparse is necessary to identify the extent of the changes to the tree.
    /// 
    /// When the RazorEditorParser returns Accepted, it updates CurrentParseTree immediately.  However, the editor is expected to
    /// update it's own data structures independently.  It can use CurrentParseTree to do this, as soon as the editor returns from
    /// CheckForStructureChanges, but it should (ideally) have logic for doing so without needing the new tree.
    /// 
    /// When Rejected is returned by CheckForStructureChanges, a background parse task has _already_ been started.  When that task
    /// finishes, the DocumentStructureChanged event will be fired containing the new generated code, parse tree and a reference to
    /// the original TextChange that caused the reparse, to allow the editor to resolve the new tree against any changes made since 
    /// calling CheckForStructureChanges.
    /// 
    /// If a call to CheckForStructureChanges occurs while a reparse is already in-progress, the reparse is cancelled IMMEDIATELY
    /// and Rejected is returned without attempting to reparse.  This means that if a conusmer calls CheckForStructureChanges, which
    /// returns Rejected, then calls it again before DocumentParseComplete is fired, it will only recieve one DocumentParseComplete
    /// event, for the second change.
    /// </remarks>
    public class RazorEditorParser : IDisposable
    {
        // Lock for this document
        private Span _lastChangeOwner;
        private Span _lastAutoCompleteSpan;
        private BackgroundParser _parser;
        private Block _currentParseTree;

        /// <summary>
        /// Constructs the editor parser.  One instance should be used per active editor.  This
        /// instance _can_ be shared among reparses, but should _never_ be shared between documents.
        /// </summary>
        /// <param name="host">The <see cref="RazorEngineHost"/> which defines the environment in which the generated code will live.  <see cref="F:RazorEngineHost.DesignTimeMode"/> should be set if design-time code mappings are desired</param>
        /// <param name="sourceFileName">The physical path to use in line pragmas</param>
        public RazorEditorParser(RazorEngineHost host, string sourceFileName)
        {
            if (host == null)
            {
                throw new ArgumentNullException("host");
            }
            if (String.IsNullOrEmpty(sourceFileName))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "sourceFileName");
            }

            Host = host;
            FileName = sourceFileName;
            _parser = new BackgroundParser(host, sourceFileName);
            _parser.ResultsReady += (sender, args) => OnDocumentParseComplete(args);
            _parser.Start();
        }

        /// <summary>
        /// Event fired when a full reparse of the document completes
        /// </summary>
        public event EventHandler<DocumentParseCompleteEventArgs> DocumentParseComplete;

        public RazorEngineHost Host { get; private set; }
        public string FileName { get; private set; }
        public bool LastResultProvisional { get; private set; }
        public Block CurrentParseTree
        {
            get { return _currentParseTree; }
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Since this method is heavily affected by side-effects, particularly calls to CheckForStructureChanges, it should not be made into a property")]
        public virtual string GetAutoCompleteString()
        {
            if (_lastAutoCompleteSpan != null)
            {
                AutoCompleteEditHandler editHandler = _lastAutoCompleteSpan.EditHandler as AutoCompleteEditHandler;
                if (editHandler != null)
                {
                    return editHandler.AutoCompleteString;
                }
            }
            return null;
        }

        /// <summary>
        /// Determines if a change will cause a structural change to the document and if not, applies it to the existing tree.
        /// If a structural change would occur, automatically starts a reparse
        /// </summary>
        /// <remarks>
        /// NOTE: The initial incremental parsing check and actual incremental parsing (if possible) occurs
        /// on the callers thread.  However, if a full reparse is needed, this occurs on a background thread.
        /// </remarks>
        /// <param name="change">The change to apply to the parse tree</param>
        /// <returns>A PartialParseResult value indicating the result of the incremental parse</returns>
        public virtual PartialParseResult CheckForStructureChanges(TextChange change)
        {
            // Validate the change
            long? elapsedMs = null;
#if EDITOR_TRACING
            Stopwatch sw = new Stopwatch();
            sw.Start();
#endif
            RazorEditorTrace.TraceLine(RazorResources.Trace_EditorReceivedChange, Path.GetFileName(FileName), change);
            if (change.NewBuffer == null)
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentUICulture,
                                                          RazorResources.Structure_Member_CannotBeNull,
                                                          "Buffer",
                                                          "TextChange"), "change");
            }

            PartialParseResult result = PartialParseResult.Rejected;

            // If there isn't already a parse underway, try partial-parsing
            string changeString = String.Empty;
            using (_parser.SynchronizeMainThreadState())
            {
                // Capture the string value of the change while we're synchronized
                changeString = change.ToString();

                // Check if we can partial-parse
                if (CurrentParseTree != null && _parser.IsIdle)
                {
                    result = TryPartialParse(change);
                }
            }

            // If partial parsing failed or there were outstanding parser tasks, start a full reparse
            if (result.HasFlag(PartialParseResult.Rejected))
            {
                _parser.QueueChange(change);
            }

            // Otherwise, remember if this was provisionally accepted for next partial parse
            LastResultProvisional = result.HasFlag(PartialParseResult.Provisional);
            VerifyFlagsAreValid(result);

#if EDITOR_TRACING
            sw.Stop();
            elapsedMs = sw.ElapsedMilliseconds;
            sw.Reset();
#endif
            RazorEditorTrace.TraceLine(RazorResources.Trace_EditorProcessedChange, Path.GetFileName(FileName), changeString, elapsedMs.HasValue ? elapsedMs.Value.ToString(CultureInfo.InvariantCulture) : "?", result.ToString());
            return result;
        }

        /// <summary>
        /// Disposes of this parser.  Should be called when the editor window is closed and the document is unloaded.
        /// </summary>
        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        [SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "_cancelTokenSource", Justification = "The cancellation token is owned by the worker thread, so it is disposed there")]
        [SuppressMessage("Microsoft.Usage", "CA2213:DisposableFieldsShouldBeDisposed", MessageId = "_changeReceived", Justification = "The change received event is owned by the worker thread, so it is disposed there")]
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                _parser.Dispose();
            }
        }

        private PartialParseResult TryPartialParse(TextChange change)
        {
            PartialParseResult result = PartialParseResult.Rejected;

            // Try the last change owner
            if (_lastChangeOwner != null && _lastChangeOwner.EditHandler.OwnsChange(_lastChangeOwner, change))
            {
                EditResult editResult = _lastChangeOwner.EditHandler.ApplyChange(_lastChangeOwner, change);
                result = editResult.Result;
                if (!editResult.Result.HasFlag(PartialParseResult.Rejected))
                {
                    _lastChangeOwner.ReplaceWith(editResult.EditedSpan);
                }

                return result;
            }

            // Locate the span responsible for this change
            _lastChangeOwner = CurrentParseTree.LocateOwner(change);

            if (LastResultProvisional)
            {
                // Last change owner couldn't accept this, so we must do a full reparse
                result = PartialParseResult.Rejected;
            }
            else if (_lastChangeOwner != null)
            {
                EditResult editRes = _lastChangeOwner.EditHandler.ApplyChange(_lastChangeOwner, change);
                result = editRes.Result;
                if (!editRes.Result.HasFlag(PartialParseResult.Rejected))
                {
                    _lastChangeOwner.ReplaceWith(editRes.EditedSpan);
                }
                if (result.HasFlag(PartialParseResult.AutoCompleteBlock))
                {
                    _lastAutoCompleteSpan = _lastChangeOwner;
                }
                else
                {
                    _lastAutoCompleteSpan = null;
                }
            }
            return result;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Exceptions are being caught here intentionally")]
        private void OnDocumentParseComplete(DocumentParseCompleteEventArgs args)
        {
            using (_parser.SynchronizeMainThreadState())
            {
                _currentParseTree = args.GeneratorResults.Document;
                _lastChangeOwner = null;
            }

            Debug.Assert(args != null, "Event arguments cannot be null");
            EventHandler<DocumentParseCompleteEventArgs> handler = DocumentParseComplete;
            if (handler != null)
            {
                try
                {
                    handler(this, args);
                }
                catch (Exception ex)
                {
                    Debug.WriteLine("[RzEd] Document Parse Complete Handler Threw: " + ex.ToString());
                }
            }
        }

        [Conditional("DEBUG")]
        private static void VerifyFlagsAreValid(PartialParseResult result)
        {
            Debug.Assert(result.HasFlag(PartialParseResult.Accepted) ||
                         result.HasFlag(PartialParseResult.Rejected),
                         "Partial Parse result does not have either of Accepted or Rejected flags set");
            Debug.Assert(result.HasFlag(PartialParseResult.Rejected) ||
                         !result.HasFlag(PartialParseResult.SpanContextChanged),
                         "Partial Parse result was Accepted AND had SpanContextChanged flag set");
            Debug.Assert(result.HasFlag(PartialParseResult.Rejected) ||
                         !result.HasFlag(PartialParseResult.AutoCompleteBlock),
                         "Partial Parse result was Accepted AND had AutoCompleteBlock flag set");
            Debug.Assert(result.HasFlag(PartialParseResult.Accepted) ||
                         !result.HasFlag(PartialParseResult.Provisional),
                         "Partial Parse result was Rejected AND had Provisional flag set");
        }
    }
}


================================================
FILE: src/System.Web.Razor/RazorEngineHost.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;

namespace System.Web.Razor
{
    /// <summary>
    /// Defines the environment in which a Razor template will live
    /// </summary>
    /// <remarks>
    /// The host defines the following things:
    /// * What method names will be used for rendering markup, expressions etc.  For example "Write", "WriteLiteral"
    /// * The namespace imports to be added to every page generated via this host
    /// * The default Base Class to inherit the generated class from
    /// * The default Class Name and Namespace for the generated class (can be overridden by parameters in RazorTemplateEngine.GeneratedCode)
    /// * The language of the code in a Razor page
    /// * The markup, code parsers and code generators to use (the system will select defaults, but a Host gets a change to augment them)
    ///     ** See DecorateNNN methods
    /// * Additional code to add to the generated code (see PostProcessGeneratedCode)
    /// </remarks>
    public class RazorEngineHost
    {
        internal const string InternalDefaultClassName = "__CompiledTemplate";
        internal const string InternalDefaultNamespace = "Razor";

        private bool _instrumentationActive = false;
        private Func<ParserBase> _markupParserFactory;

        private int _tabSize = 4;

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The code path is safe, it is a property setter and not dependent on other state")]
        protected RazorEngineHost()
        {
            GeneratedClassContext = GeneratedClassContext.Default;
            NamespaceImports = new HashSet<string>();
            DesignTimeMode = false;
            DefaultNamespace = InternalDefaultNamespace;
            DefaultClassName = InternalDefaultClassName;
            EnableInstrumentation = false;
        }

        /// <summary>
        /// Creates a host which uses the specified code language and the HTML markup language
        /// </summary>
        /// <param name="codeLanguage">The code language to use</param>
        public RazorEngineHost(RazorCodeLanguage codeLanguage)
            : this(codeLanguage, () => new HtmlMarkupParser())
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The code path is safe, it is a property setter and not dependent on other state")]
        public RazorEngineHost(RazorCodeLanguage codeLanguage, Func<ParserBase> markupParserFactory)
            : this()
        {
            if (codeLanguage == null)
            {
                throw new ArgumentNullException("codeLanguage");
            }
            if (markupParserFactory == null)
            {
                throw new ArgumentNullException("markupParserFactory");
            }

            CodeLanguage = codeLanguage;
            _markupParserFactory = markupParserFactory;
        }

        /// <summary>
        /// Details about the methods and types that should be used to generate code for Razor constructs
        /// </summary>
        public virtual GeneratedClassContext GeneratedClassContext { get; set; }

        /// <summary>
        /// A list of namespaces to import in the generated file
        /// </summary>
        public virtual ISet<string> NamespaceImports { get; private set; }

        /// <summary>
        /// The base-class of the generated class
        /// </summary>
        public virtual string DefaultBaseClass { get; set; }

        /// <summary>
        /// Indiciates if the parser and code generator should run in design-time mode
        /// </summary>
        public virtual bool DesignTimeMode { get; set; }

        /// <summary>
        /// The name of the generated class
        /// </summary>
        public virtual string DefaultClassName { get; set; }

        /// <summary>
        /// The namespace which will contain the generated class
        /// </summary>
        public virtual string DefaultNamespace { get; set; }

        /// <summary>
        /// Boolean indicating if helper methods should be instance methods or static methods
        /// </summary>
        public virtual bool StaticHelpers { get; set; }

        /// <summary>
        /// The language of the code within the Razor template.
        /// </summary>
        public virtual RazorCodeLanguage CodeLanguage { get; protected set; }

        /// <summary>
        /// Boolean indicating if instrumentation code should be injected into the output page
        /// </summary>
        public virtual bool EnableInstrumentation
        {
            // Always disable instrumentation in DesignTimeMode.
            get { return !DesignTimeMode && _instrumentationActive; }
            set { _instrumentationActive = value; }
        }

        /// <summary>
        /// Gets or sets whether the design time editor is using tabs or spaces for indentation.
        /// </summary>
        public virtual bool IsIndentingWithTabs { get; set; }

        /// <summary>
        /// Tab size used by the hosting editor, when indenting with tabs.
        /// </summary>
        public virtual int TabSize
        {
            get
            {
                return _tabSize;
            }

            set
            {
                _tabSize = Math.Max(value, 1);
            }
        }

        /// <summary>
        /// Gets or sets the path to use for this document when generating Instrumentation calls
        /// </summary>
        public virtual string InstrumentedSourceFilePath { get; set; }

        /// <summary>
        /// Constructs the markup parser.  Must return a new instance on EVERY call to ensure thread-safety
        /// </summary>
        public virtual ParserBase CreateMarkupParser()
        {
            if (_markupParserFactory != null)
            {
                return _markupParserFactory();
            }
            return null;
        }

        /// <summary>
        /// Gets an instance of the code parser and is provided an opportunity to decorate or replace it
        /// </summary>
        /// <param name="incomingCodeParser">The code parser</param>
        /// <returns>Either the same code parser, after modifications, or a different code parser</returns>
        public virtual ParserBase DecorateCodeParser(ParserBase incomingCodeParser)
        {
            if (incomingCodeParser == null)
            {
                throw new ArgumentNullException("incomingCodeParser");
            }
            return incomingCodeParser;
        }

        /// <summary>
        /// Gets an instance of the markup parser and is provided an opportunity to decorate or replace it
        /// </summary>
        /// <param name="incomingMarkupParser">The markup parser</param>
        /// <returns>Either the same markup parser, after modifications, or a different markup parser</returns>
        public virtual ParserBase DecorateMarkupParser(ParserBase incomingMarkupParser)
        {
            if (incomingMarkupParser == null)
            {
                throw new ArgumentNullException("incomingMarkupParser");
            }
            return incomingMarkupParser;
        }

        /// <summary>
        /// Gets an instance of the code generator and is provided an opportunity to decorate or replace it
        /// </summary>
        /// <param name="incomingCodeGenerator">The code generator</param>
        /// <returns>Either the same code generator, after modifications, or a different code generator</returns>
        public virtual RazorCodeGenerator DecorateCodeGenerator(RazorCodeGenerator incomingCodeGenerator)
        {
            if (incomingCodeGenerator == null)
            {
                throw new ArgumentNullException("incomingCodeGenerator");
            }
            return incomingCodeGenerator;
        }

        /// <summary>
        /// Gets the important CodeDOM nodes generated by the code generator and has a chance to add to them.
        /// </summary>
        /// <remarks>
        /// All the other parameter values can be located by traversing tree in the codeCompileUnit node, they
        /// are simply provided for convenience
        /// </remarks>
        /// <param name="context">The current <see cref="CodeGeneratorContext"/>.</param>
        public virtual void PostProcessGeneratedCode(CodeGeneratorContext context)
        {
#pragma warning disable 0618
            PostProcessGeneratedCode(context.CompileUnit, context.Namespace, context.GeneratedClass, context.TargetMethod);
#pragma warning restore 0618
        }

        [Obsolete("This method is obsolete, use the override which takes a CodeGeneratorContext instead")]
        public virtual void PostProcessGeneratedCode(CodeCompileUnit codeCompileUnit, CodeNamespace generatedNamespace, CodeTypeDeclaration generatedClass, CodeMemberMethod executeMethod)
        {
            if (codeCompileUnit == null)
            {
                throw new ArgumentNullException("codeCompileUnit");
            }
            if (generatedNamespace == null)
            {
                throw new ArgumentNullException("generatedNamespace");
            }
            if (generatedClass == null)
            {
                throw new ArgumentNullException("generatedClass");
            }
            if (executeMethod == null)
            {
                throw new ArgumentNullException("executeMethod");
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/RazorTemplateEngine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Threading;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Text;

namespace System.Web.Razor
{
    /// <summary>
    /// Entry-point to the Razor Template Engine
    /// </summary>
    public class RazorTemplateEngine
    {
        public static readonly string DefaultClassName = "Template";
        public static readonly string DefaultNamespace = String.Empty;

        /// <summary>
        /// Constructs a new RazorTemplateEngine with the specified host
        /// </summary>
        /// <param name="host">The host which defines the environment in which the generated template code will live</param>
        public RazorTemplateEngine(RazorEngineHost host)
        {
            if (host == null)
            {
                throw new ArgumentNullException("host");
            }

            Host = host;
        }

        /// <summary>
        /// The RazorEngineHost which defines the environment in which the generated template code will live
        /// </summary>
        public RazorEngineHost Host { get; private set; }

        public ParserResults ParseTemplate(ITextBuffer input)
        {
            return ParseTemplate(input, null);
        }

        /// <summary>
        /// Parses the template specified by the TextBuffer and returns it's result
        /// </summary>
        /// <remarks>
        /// IMPORTANT: This does NOT need to be called before GeneratedCode! GenerateCode will automatically
        /// parse the document first.
        /// 
        /// The cancel token provided can be used to cancel the parse.  However, please note
        /// that the parse occurs _synchronously_, on the callers thread.  This parameter is 
        /// provided so that if the caller is in a background thread with a CancellationToken, 
        /// it can pass it along to the parser.
        /// </remarks>
        /// <param name="input">The input text to parse</param>
        /// <param name="cancelToken">A token used to cancel the parser</param>
        /// <returns>The resulting parse tree</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Input object would be disposed if we dispose the wrapper.  We don't own the input so we don't want to dispose it")]
        public ParserResults ParseTemplate(ITextBuffer input, CancellationToken? cancelToken)
        {
            return ParseTemplateCore(input.ToDocument(), cancelToken);
        }

        // See ParseTemplate(ITextBuffer, CancellationToken?), 
        // this overload simply wraps a TextReader in a TextBuffer (see ITextBuffer and BufferingTextReader)
        public ParserResults ParseTemplate(TextReader input)
        {
            return ParseTemplate(input, null);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Input object would be disposed if we dispose the wrapper.  We don't own the input so we don't want to dispose it")]
        public ParserResults ParseTemplate(TextReader input, CancellationToken? cancelToken)
        {
            return ParseTemplateCore(new SeekableTextReader(input), cancelToken);
        }

        protected internal virtual ParserResults ParseTemplateCore(ITextDocument input, CancellationToken? cancelToken)
        {
            // Construct the parser
            RazorParser parser = CreateParser();
            Debug.Assert(parser != null);
            return parser.Parse(input);
        }

        public GeneratorResults GenerateCode(ITextBuffer input)
        {
            return GenerateCode(input, null, null, null, null);
        }

        public GeneratorResults GenerateCode(ITextBuffer input, CancellationToken? cancelToken)
        {
            return GenerateCode(input, null, null, null, cancelToken);
        }

        public GeneratorResults GenerateCode(ITextBuffer input, string className, string rootNamespace, string sourceFileName)
        {
            return GenerateCode(input, className, rootNamespace, sourceFileName, null);
        }

        /// <summary>
        /// Parses the template specified by the TextBuffer, generates code for it, and returns the constructed CodeDOM tree
        /// </summary>
        /// <remarks>
        /// The cancel token provided can be used to cancel the parse.  However, please note
        /// that the parse occurs _synchronously_, on the callers thread.  This parameter is 
        /// provided so that if the caller is in a background thread with a CancellationToken, 
        /// it can pass it along to the parser.
        /// 
        /// The className, rootNamespace and sourceFileName parameters are optional and override the default
        /// specified by the Host.  For example, the WebPageRazorHost in System.Web.WebPages.Razor configures the
        /// Class Name, Root Namespace and Source File Name based on the virtual path of the page being compiled.
        /// However, the built-in RazorEngineHost class uses constant defaults, so the caller will likely want to 
        /// change them using these parameters
        /// </remarks>
        /// <param name="input">The input text to parse</param>
        /// <param name="cancelToken">A token used to cancel the parser</param>
        /// <param name="className">The name of the generated class, overriding whatever is specified in the Host.  The default value (defined in the Host) can be used by providing null for this argument</param>
        /// <param name="rootNamespace">The namespace in which the generated class will reside, overriding whatever is specified in the Host.  The default value (defined in the Host) can be used by providing null for this argument</param>
        /// <param name="sourceFileName">The file name to use in line pragmas, usually the original Razor file, overriding whatever is specified in the Host.  The default value (defined in the Host) can be used by providing null for this argument</param>
        /// <returns>The resulting parse tree AND generated Code DOM tree</returns>
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Input object would be disposed if we dispose the wrapper.  We don't own the input so we don't want to dispose it")]
        public GeneratorResults GenerateCode(ITextBuffer input, string className, string rootNamespace, string sourceFileName, CancellationToken? cancelToken)
        {
            return GenerateCodeCore(input.ToDocument(), className, rootNamespace, sourceFileName, cancelToken);
        }

        // See GenerateCode override which takes ITextBuffer, and BufferingTextReader for details.
        public GeneratorResults GenerateCode(TextReader input)
        {
            return GenerateCode(input, null, null, null, null);
        }

        public GeneratorResults GenerateCode(TextReader input, CancellationToken? cancelToken)
        {
            return GenerateCode(input, null, null, null, cancelToken);
        }

        public GeneratorResults GenerateCode(TextReader input, string className, string rootNamespace, string sourceFileName)
        {
            return GenerateCode(input, className, rootNamespace, sourceFileName, null);
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Input object would be disposed if we dispose the wrapper.  We don't own the input so we don't want to dispose it")]
        public GeneratorResults GenerateCode(TextReader input, string className, string rootNamespace, string sourceFileName, CancellationToken? cancelToken)
        {
            return GenerateCodeCore(new SeekableTextReader(input), className, rootNamespace, sourceFileName, cancelToken);
        }

        protected internal virtual GeneratorResults GenerateCodeCore(ITextDocument input, string className, string rootNamespace, string sourceFileName, CancellationToken? cancelToken)
        {
            className = (className ?? Host.DefaultClassName) ?? DefaultClassName;
            rootNamespace = (rootNamespace ?? Host.DefaultNamespace) ?? DefaultNamespace;

            // Run the parser
            RazorParser parser = CreateParser();
            Debug.Assert(parser != null);
            ParserResults results = parser.Parse(input);

            // Generate code
            RazorCodeGenerator generator = CreateCodeGenerator(className, rootNamespace, sourceFileName);
            generator.DesignTimeMode = Host.DesignTimeMode;
            generator.Visit(results);

            // Post process code
            Host.PostProcessGeneratedCode(generator.Context);

            // Extract design-time mappings
            IDictionary<int, GeneratedCodeMapping> designTimeLineMappings = null;
            if (Host.DesignTimeMode)
            {
                designTimeLineMappings = generator.Context.CodeMappings;
            }

            // Collect results and return
            return new GeneratorResults(results, generator.Context.CompileUnit, designTimeLineMappings);
        }

        protected internal virtual RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespace, string sourceFileName)
        {
            return Host.DecorateCodeGenerator(
                Host.CodeLanguage.CreateCodeGenerator(className, rootNamespace, sourceFileName, Host));
        }

        protected internal virtual RazorParser CreateParser()
        {
            ParserBase codeParser = Host.CodeLanguage.CreateCodeParser();
            ParserBase markupParser = Host.CreateMarkupParser();

            return new RazorParser(Host.DecorateCodeParser(codeParser),
                                   Host.DecorateMarkupParser(markupParser))
            {
                DesignTimeMode = Host.DesignTimeMode
            };
        }
    }
}


================================================
FILE: src/System.Web.Razor/Resources/RazorResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.34011
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Razor.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class RazorResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal RazorResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Razor.Resources.RazorResources", typeof(RazorResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The active parser must the same as either the markup or code parser..
        /// </summary>
        internal static string ActiveParser_Must_Be_Code_Or_Markup_Parser {
            get {
                return ResourceManager.GetString("ActiveParser_Must_Be_Code_Or_Markup_Parser", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Block cannot be built because a Type has not been specified in the BlockBuilder.
        /// </summary>
        internal static string Block_Type_Not_Specified {
            get {
                return ResourceManager.GetString("Block_Type_Not_Specified", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to code.
        /// </summary>
        internal static string BlockName_Code {
            get {
                return ResourceManager.GetString("BlockName_Code", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to explicit expression.
        /// </summary>
        internal static string BlockName_ExplicitExpression {
            get {
                return ResourceManager.GetString("BlockName_ExplicitExpression", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;CancelBacktrack&quot; method can be called only while in a look-ahead process started with the &quot;BeginLookahead&quot; method..
        /// </summary>
        internal static string CancelBacktrack_Must_Be_Called_Within_Lookahead {
            get {
                return ResourceManager.GetString("CancelBacktrack_Must_Be_Called_Within_Lookahead", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot call CreateCodeWriter, a CodeWriter was not provided to the Create method.
        /// </summary>
        internal static string CreateCodeWriter_NoCodeWriter {
            get {
                return ResourceManager.GetString("CreateCodeWriter_NoCodeWriter", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;character literal&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_CharacterLiteral {
            get {
                return ResourceManager.GetString("CSharpSymbol_CharacterLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;comment&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_Comment {
            get {
                return ResourceManager.GetString("CSharpSymbol_Comment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;identifier&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_Identifier {
            get {
                return ResourceManager.GetString("CSharpSymbol_Identifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;integer literal&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_IntegerLiteral {
            get {
                return ResourceManager.GetString("CSharpSymbol_IntegerLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;keyword&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_Keyword {
            get {
                return ResourceManager.GetString("CSharpSymbol_Keyword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;newline sequence&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_Newline {
            get {
                return ResourceManager.GetString("CSharpSymbol_Newline", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;real literal&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_RealLiteral {
            get {
                return ResourceManager.GetString("CSharpSymbol_RealLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;string literal&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_StringLiteral {
            get {
                return ResourceManager.GetString("CSharpSymbol_StringLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;white space&gt;&gt;.
        /// </summary>
        internal static string CSharpSymbol_Whitespace {
            get {
                return ResourceManager.GetString("CSharpSymbol_Whitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;EndBlock&quot; was called without a matching call to &quot;StartBlock&quot;..
        /// </summary>
        internal static string EndBlock_Called_Without_Matching_StartBlock {
            get {
                return ResourceManager.GetString("EndBlock_Called_Without_Matching_StartBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; character.
        /// </summary>
        internal static string ErrorComponent_Character {
            get {
                return ResourceManager.GetString("ErrorComponent_Character", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to end of file.
        /// </summary>
        internal static string ErrorComponent_EndOfFile {
            get {
                return ResourceManager.GetString("ErrorComponent_EndOfFile", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to line break.
        /// </summary>
        internal static string ErrorComponent_Newline {
            get {
                return ResourceManager.GetString("ErrorComponent_Newline", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to space or line break.
        /// </summary>
        internal static string ErrorComponent_Whitespace {
            get {
                return ResourceManager.GetString("ErrorComponent_Whitespace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;newline sequence&gt;&gt;.
        /// </summary>
        internal static string HtmlSymbol_NewLine {
            get {
                return ResourceManager.GetString("HtmlSymbol_NewLine", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;razor comment&gt;&gt;.
        /// </summary>
        internal static string HtmlSymbol_RazorComment {
            get {
                return ResourceManager.GetString("HtmlSymbol_RazorComment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;text&gt;&gt;.
        /// </summary>
        internal static string HtmlSymbol_Text {
            get {
                return ResourceManager.GetString("HtmlSymbol_Text", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;white space&gt;&gt;.
        /// </summary>
        internal static string HtmlSymbol_WhiteSpace {
            get {
                return ResourceManager.GetString("HtmlSymbol_WhiteSpace", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot use built-in RazorComment handler, language characteristics does not define the CommentStart, CommentStar and CommentBody known symbol types or parser does not override TokenizerBackedParser.OutputSpanBeforeRazorComment.
        /// </summary>
        internal static string Language_Does_Not_Support_RazorComment {
            get {
                return ResourceManager.GetString("Language_Does_Not_Support_RazorComment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;@&quot; character must be followed by a &quot;:&quot;, &quot;(&quot;, or a C# identifier.  If you intended to switch to markup, use an HTML start tag, for example:
        ///
        ///@if(isLoggedIn) {
        ///    &lt;p&gt;Hello, @user!&lt;/p&gt;
        ///}.
        /// </summary>
        internal static string ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start {
            get {
                return ResourceManager.GetString("ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End of file was reached before the end of the block comment.  All comments started with &quot;/*&quot; sequence must be terminated with a matching &quot;*/&quot; sequence..
        /// </summary>
        internal static string ParseError_BlockComment_Not_Terminated {
            get {
                return ResourceManager.GetString("ParseError_BlockComment_Not_Terminated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;{0}&quot; block was not terminated.  All &quot;{0}&quot; statements must be terminated with a matching &quot;{1}&quot;..
        /// </summary>
        internal static string ParseError_BlockNotTerminated {
            get {
                return ResourceManager.GetString("ParseError_BlockNotTerminated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An opening &quot;{0}&quot; is missing the corresponding closing &quot;{1}&quot;..
        /// </summary>
        internal static string ParseError_Expected_CloseBracket_Before_EOF {
            get {
                return ResourceManager.GetString("ParseError_Expected_CloseBracket_Before_EOF", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} block is missing a closing &quot;{1}&quot; character.  Make sure you have a matching &quot;{1}&quot; character for all the &quot;{2}&quot; characters within this block, and that none of the &quot;{1}&quot; characters are being interpreted as markup..
        /// </summary>
        internal static string ParseError_Expected_EndOfBlock_Before_EOF {
            get {
                return ResourceManager.GetString("ParseError_Expected_EndOfBlock_Before_EOF", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected &quot;{0}&quot;..
        /// </summary>
        internal static string ParseError_Expected_X {
            get {
                return ResourceManager.GetString("ParseError_Expected_X", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Helper blocks cannot be nested within each other..
        /// </summary>
        internal static string ParseError_Helpers_Cannot_Be_Nested {
            get {
                return ResourceManager.GetString("ParseError_Helpers_Cannot_Be_Nested", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;inherits&apos; keyword must be followed by a type name on the same line..
        /// </summary>
        internal static string ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName {
            get {
                return ResourceManager.GetString("ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Inline markup blocks (@&lt;p&gt;Content&lt;/p&gt;) cannot be nested.  Only one level of inline markup is allowed..
        /// </summary>
        internal static string ParseError_InlineMarkup_Blocks_Cannot_Be_Nested {
            get {
                return ResourceManager.GetString("ParseError_InlineMarkup_Blocks_Cannot_Be_Nested", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{1}&quot; is not a valid value for the &quot;{0}&quot; option. The &quot;Option {0}&quot; statement must be followed by either &quot;On&quot; or &quot;Off&quot;. .
        /// </summary>
        internal static string ParseError_InvalidOptionValue {
            get {
                return ResourceManager.GetString("ParseError_InvalidOptionValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Markup in a code block must start with a tag and all start tags must be matched with end tags.  Do not use unclosed tags like &quot;&lt;br&gt;&quot;.  Instead use self-closing tags like &quot;&lt;br/&gt;&quot;..
        /// </summary>
        internal static string ParseError_MarkupBlock_Must_Start_With_Tag {
            get {
                return ResourceManager.GetString("ParseError_MarkupBlock_Must_Start_With_Tag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected a &quot;{0}&quot; after the helper name..
        /// </summary>
        internal static string ParseError_MissingCharAfterHelperName {
            get {
                return ResourceManager.GetString("ParseError_MissingCharAfterHelperName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected a &quot;{0}&quot; after the helper parameters..
        /// </summary>
        internal static string ParseError_MissingCharAfterHelperParameters {
            get {
                return ResourceManager.GetString("ParseError_MissingCharAfterHelperParameters", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;{0}&quot; element was not closed.  All elements must be either self-closing or have a matching end tag..
        /// </summary>
        internal static string ParseError_MissingEndTag {
            get {
                return ResourceManager.GetString("ParseError_MissingEndTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sections cannot be empty.  The &quot;@section&quot; keyword must be followed by a block of markup surrounded by &quot;{}&quot;.  For example:
        ///
        ///@section Sidebar {
        ///   &lt;!-- Markup and text goes here --&gt;
        ///}.
        /// </summary>
        internal static string ParseError_MissingOpenBraceAfterSection {
            get {
                return ResourceManager.GetString("ParseError_MissingOpenBraceAfterSection", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Namespace imports and type aliases cannot be placed within code blocks.  They must immediately follow an &quot;@&quot; character in markup.  It is recommended that you put them at the top of the page, as in the following example:
        ///
        ///@using System.Drawing;
        ///@{
        ///    // OK here to use types from System.Drawing in the page.
        ///}.
        /// </summary>
        internal static string ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;Imports&quot; keyword must be followed by a namespace or a type alias on the same line..
        /// </summary>
        internal static string ParseError_NamespaceOrTypeAliasExpected {
            get {
                return ResourceManager.GetString("ParseError_NamespaceOrTypeAliasExpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Outer tag is missing a name. The first character of a markup block must be an HTML tag with a valid name..
        /// </summary>
        internal static string ParseError_OuterTagMissingName {
            get {
                return ResourceManager.GetString("ParseError_OuterTagMissingName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End of file was reached before the end of the block comment.  All comments that start with the &quot;@*&quot; sequence must be terminated with a matching &quot;*@&quot; sequence..
        /// </summary>
        internal static string ParseError_RazorComment_Not_Terminated {
            get {
                return ResourceManager.GetString("ParseError_RazorComment_Not_Terminated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; is a reserved word and cannot be used in implicit expressions.  An explicit expression (&quot;@()&quot;) must be used..
        /// </summary>
        internal static string ParseError_ReservedWord {
            get {
                return ResourceManager.GetString("ParseError_ReservedWord", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Section blocks (&quot;{0}&quot;) cannot be nested.  Only one level of section blocks are allowed..
        /// </summary>
        internal static string ParseError_Sections_Cannot_Be_Nested {
            get {
                return ResourceManager.GetString("ParseError_Sections_Cannot_Be_Nested", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expected a &quot;{0}&quot; but found a &quot;{1}&quot;.  Block statements must be enclosed in &quot;{{&quot; and &quot;}}&quot;.  You cannot use single-statement control-flow statements in CSHTML pages. For example, the following is not allowed:
        ///
        ///@if(isLoggedIn)
        ///    &lt;p&gt;Hello, @user&lt;/p&gt;
        ///
        ///Instead, wrap the contents of the block in &quot;{{}}&quot;:
        ///
        ///@if(isLoggedIn) {{
        ///    &lt;p&gt;Hello, @user&lt;/p&gt;
        ///}}.
        /// </summary>
        internal static string ParseError_SingleLine_ControlFlowStatements_Not_Allowed {
            get {
                return ResourceManager.GetString("ParseError_SingleLine_ControlFlowStatements_Not_Allowed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;&lt;text&gt;&quot; and &quot;&lt;/text&gt;&quot; tags cannot contain attributes..
        /// </summary>
        internal static string ParseError_TextTagCannotContainAttributes {
            get {
                return ResourceManager.GetString("ParseError_TextTagCannotContainAttributes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected &quot;{0}&quot;.
        /// </summary>
        internal static string ParseError_Unexpected {
            get {
                return ResourceManager.GetString("ParseError_Unexpected", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected {0} after helper keyword.  All helpers must have a name which starts with an &quot;_&quot; or alphabetic character. The remaining characters must be either &quot;_&quot; or alphanumeric..
        /// </summary>
        internal static string ParseError_Unexpected_Character_At_Helper_Name_Start {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Character_At_Helper_Name_Start", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected {0} after section keyword.  Section names must start with an &quot;_&quot; or alphabetic character, and the remaining characters must be either &quot;_&quot; or alphanumeric..
        /// </summary>
        internal static string ParseError_Unexpected_Character_At_Section_Name_Start {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Character_At_Section_Name_Start", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; is not valid at the start of a code block.  Only identifiers, keywords, comments, &quot;(&quot; and &quot;{{&quot; are valid..
        /// </summary>
        internal static string ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &quot;{0}&quot; is not valid at the start of a code block.  Only identifiers, keywords, comments, and &quot;(&quot; are valid..
        /// </summary>
        internal static string ParseError_Unexpected_Character_At_Start_Of_CodeBlock_VB {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Character_At_Start_Of_CodeBlock_VB", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End-of-file was found after the &quot;@&quot; character.  &quot;@&quot; must be followed by a valid code block.  If you want to output an &quot;@&quot;, escape it using the sequence: &quot;@@&quot;.
        /// </summary>
        internal static string ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected &quot;{0}&quot; keyword after &quot;@&quot; character.  Once inside code, you do not need to prefix constructs like &quot;{0}&quot; with &quot;@&quot;..
        /// </summary>
        internal static string ParseError_Unexpected_Keyword_After_At {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Keyword_After_At", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unexpected &quot;{&quot; after &quot;@&quot; character. Once inside the body of a code block (@if {}, @{}, etc.) you do not need to use &quot;@{&quot; to switch to code..
        /// </summary>
        internal static string ParseError_Unexpected_Nested_CodeBlock {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_Nested_CodeBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A space or line break was encountered after the &quot;@&quot; character.  Only valid identifiers, keywords, comments, &quot;(&quot; and &quot;{&quot; are valid at the start of a code block and they must occur immediately following &quot;@&quot; with no space in between..
        /// </summary>
        internal static string ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_CS {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_CS", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A space or line break was encountered after the &quot;@&quot; character.  Only valid identifiers, keywords, comments, and &quot;(&quot; are valid at the start of a code block and they must occur immediately following &quot;@&quot; with no space in between..
        /// </summary>
        internal static string ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_VB {
            get {
                return ResourceManager.GetString("ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_VB", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Encountered end tag &quot;{0}&quot; with no matching start tag.  Are your start/end tags properly balanced?.
        /// </summary>
        internal static string ParseError_UnexpectedEndTag {
            get {
                return ResourceManager.GetString("ParseError_UnexpectedEndTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to End of file or an unexpected character was reached before the &quot;{0}&quot; tag could be parsed.  Elements inside markup blocks must be complete. They must either be self-closing (&quot;&lt;br /&gt;&quot;) or have matching end tags (&quot;&lt;p&gt;Hello&lt;/p&gt;&quot;).  If you intended to display a &quot;&lt;&quot; character, use the &quot;&amp;lt;&quot; HTML entity..
        /// </summary>
        internal static string ParseError_UnfinishedTag {
            get {
                return ResourceManager.GetString("ParseError_UnfinishedTag", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unknown option: &quot;{0}&quot;..
        /// </summary>
        internal static string ParseError_UnknownOption {
            get {
                return ResourceManager.GetString("ParseError_UnknownOption", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unterminated string literal. Strings that start with a quotation mark (&quot;) must be terminated before the end of the line.  However, strings that start with @ and a quotation mark (@&quot;) can span multiple lines. Closing HTML tags within a string literal may trigger this error message..
        /// </summary>
        internal static string ParseError_Unterminated_String_Literal {
            get {
                return ResourceManager.GetString("ParseError_Unterminated_String_Literal", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Helper parameter list is missing a closing &quot;)&quot;..
        /// </summary>
        internal static string ParseError_UnterminatedHelperParameterList {
            get {
                return ResourceManager.GetString("ParseError_UnterminatedHelperParameterList", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parser was started with a null Context property.  The Context property must be set BEFORE calling any methods on the parser..
        /// </summary>
        internal static string Parser_Context_Not_Set {
            get {
                return ResourceManager.GetString("Parser_Context_Not_Set", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot complete the tree, StartBlock must be called at least once..
        /// </summary>
        internal static string ParserContext_CannotCompleteTree_NoRootBlock {
            get {
                return ResourceManager.GetString("ParserContext_CannotCompleteTree_NoRootBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot complete the tree, there are still open blocks..
        /// </summary>
        internal static string ParserContext_CannotCompleteTree_OutstandingBlocks {
            get {
                return ResourceManager.GetString("ParserContext_CannotCompleteTree_OutstandingBlocks", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot finish span, there is no current block. Call StartBlock at least once before finishing a span.
        /// </summary>
        internal static string ParserContext_NoCurrentBlock {
            get {
                return ResourceManager.GetString("ParserContext_NoCurrentBlock", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot complete action, the parser has finished. Only CompleteParse can be called to extract the final parser results after the parser has finished.
        /// </summary>
        internal static string ParserContext_ParseComplete {
            get {
                return ResourceManager.GetString("ParserContext_ParseComplete", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Missing value for session state directive..
        /// </summary>
        internal static string ParserEror_SessionDirectiveMissingValue {
            get {
                return ResourceManager.GetString("ParserEror_SessionDirectiveMissingValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parser provided to the ParserContext was not a Markup Parser..
        /// </summary>
        internal static string ParserIsNotAMarkupParser {
            get {
                return ResourceManager.GetString("ParserIsNotAMarkupParser", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to @section Header { ... }.
        /// </summary>
        internal static string SectionExample_CS {
            get {
                return ResourceManager.GetString("SectionExample_CS", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to @Section Header ... End Section.
        /// </summary>
        internal static string SectionExample_VB {
            get {
                return ResourceManager.GetString("SectionExample_VB", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The {0} property of the {1} structure cannot be null..
        /// </summary>
        internal static string Structure_Member_CannotBeNull {
            get {
                return ResourceManager.GetString("Structure_Member_CannotBeNull", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;unknown&gt;&gt;.
        /// </summary>
        internal static string Symbol_Unknown {
            get {
                return ResourceManager.GetString("Symbol_Unknown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cannot resume this symbol. Only the symbol immediately preceding the current one can be resumed..
        /// </summary>
        internal static string Tokenizer_CannotResumeSymbolUnlessIsPrevious {
            get {
                return ResourceManager.GetString("Tokenizer_CannotResumeSymbolUnlessIsPrevious", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In order to put a symbol back, it must have been the symbol which ended at the current position. The specified symbol ends at {0}, but the current position is {1}.
        /// </summary>
        internal static string TokenizerView_CannotPutBack {
            get {
                return ResourceManager.GetString("TokenizerView_CannotPutBack", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] Shutdown.
        /// </summary>
        internal static string Trace_BackgroundThreadShutdown {
            get {
                return ResourceManager.GetString("Trace_BackgroundThreadShutdown", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] Startup.
        /// </summary>
        internal static string Trace_BackgroundThreadStart {
            get {
                return ResourceManager.GetString("Trace_BackgroundThreadStart", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] {1} changes arrived.
        /// </summary>
        internal static string Trace_ChangesArrived {
            get {
                return ResourceManager.GetString("Trace_ChangesArrived", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] Discarded {1} changes.
        /// </summary>
        internal static string Trace_ChangesDiscarded {
            get {
                return ResourceManager.GetString("Trace_ChangesDiscarded", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] Collecting {1} discarded changes.
        /// </summary>
        internal static string Trace_CollectedDiscardedChanges {
            get {
                return ResourceManager.GetString("Trace_CollectedDiscardedChanges", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disabled.
        /// </summary>
        internal static string Trace_Disabled {
            get {
                return ResourceManager.GetString("Trace_Disabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [P][{0}] {3} Change in {2} milliseconds: {1}.
        /// </summary>
        internal static string Trace_EditorProcessedChange {
            get {
                return ResourceManager.GetString("Trace_EditorProcessedChange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [P][{0}] Received Change: {1}.
        /// </summary>
        internal static string Trace_EditorReceivedChange {
            get {
                return ResourceManager.GetString("Trace_EditorReceivedChange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enabled.
        /// </summary>
        internal static string Trace_Enabled {
            get {
                return ResourceManager.GetString("Trace_Enabled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [Razor] {0}.
        /// </summary>
        internal static string Trace_Format {
            get {
                return ResourceManager.GetString("Trace_Format", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] no changes arrived?.
        /// </summary>
        internal static string Trace_NoChangesArrived {
            get {
                return ResourceManager.GetString("Trace_NoChangesArrived", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] Parse Complete in {1} milliseconds.
        /// </summary>
        internal static string Trace_ParseComplete {
            get {
                return ResourceManager.GetString("Trace_ParseComplete", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [M][{0}] Queuing Parse for: {1}.
        /// </summary>
        internal static string Trace_QueuingParse {
            get {
                return ResourceManager.GetString("Trace_QueuingParse", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [Razor] Editor Tracing {0}.
        /// </summary>
        internal static string Trace_Startup {
            get {
                return ResourceManager.GetString("Trace_Startup", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to [BG][{0}] Trees Compared in {1} milliseconds. Different = {2}.
        /// </summary>
        internal static string Trace_TreesCompared {
            get {
                return ResourceManager.GetString("Trace_TreesCompared", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;character literal&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_CharacterLiteral {
            get {
                return ResourceManager.GetString("VBSymbol_CharacterLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;comment&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_Comment {
            get {
                return ResourceManager.GetString("VBSymbol_Comment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;date literal&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_DateLiteral {
            get {
                return ResourceManager.GetString("VBSymbol_DateLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;floating point literal&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_FloatingPointLiteral {
            get {
                return ResourceManager.GetString("VBSymbol_FloatingPointLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;identifier&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_Identifier {
            get {
                return ResourceManager.GetString("VBSymbol_Identifier", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;integer literal&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_IntegerLiteral {
            get {
                return ResourceManager.GetString("VBSymbol_IntegerLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;keyword&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_Keyword {
            get {
                return ResourceManager.GetString("VBSymbol_Keyword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;newline sequence&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_NewLine {
            get {
                return ResourceManager.GetString("VBSymbol_NewLine", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;razor comment&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_RazorComment {
            get {
                return ResourceManager.GetString("VBSymbol_RazorComment", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;string literal&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_StringLiteral {
            get {
                return ResourceManager.GetString("VBSymbol_StringLiteral", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;&lt;white space&gt;&gt;.
        /// </summary>
        internal static string VBSymbol_WhiteSpace {
            get {
                return ResourceManager.GetString("VBSymbol_WhiteSpace", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Resources/RazorResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="ActiveParser_Must_Be_Code_Or_Markup_Parser" xml:space="preserve">
    <value>The active parser must the same as either the markup or code parser.</value>
  </data>
  <data name="BlockName_Code" xml:space="preserve">
    <value>code</value>
    <comment>This is a literal used when composing ParserError_* messages. Most blocks are named by the keyword that starts them, for example "if".  However, for those without keywords, a (localizable) name must be used.  This literal is ALWAYS used mid-sentence, thus should not be capitalized.</comment>
  </data>
  <data name="BlockName_ExplicitExpression" xml:space="preserve">
    <value>explicit expression</value>
    <comment>This is a literal used when composing ParserError_* messages. Most blocks are named by the keyword that starts them, for example "if".  However, for those without keywords, a (localizable) name must be used.  This literal is ALWAYS used mid-sentence, thus should not be capitalized.</comment>
  </data>
  <data name="CancelBacktrack_Must_Be_Called_Within_Lookahead" xml:space="preserve">
    <value>The "CancelBacktrack" method can be called only while in a look-ahead process started with the "BeginLookahead" method.</value>
  </data>
  <data name="EndBlock_Called_Without_Matching_StartBlock" xml:space="preserve">
    <value>"EndBlock" was called without a matching call to "StartBlock".</value>
  </data>
  <data name="ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start" xml:space="preserve">
    <value>The "@" character must be followed by a ":", "(", or a C# identifier.  If you intended to switch to markup, use an HTML start tag, for example:

@if(isLoggedIn) {
    &lt;p&gt;Hello, @user!&lt;/p&gt;
}</value>
  </data>
  <data name="ParseError_BlockComment_Not_Terminated" xml:space="preserve">
    <value>End of file was reached before the end of the block comment.  All comments started with "/*" sequence must be terminated with a matching "*/" sequence.</value>
  </data>
  <data name="ParseError_Expected_CloseBracket_Before_EOF" xml:space="preserve">
    <value>An opening "{0}" is missing the corresponding closing "{1}".</value>
  </data>
  <data name="ParseError_Expected_EndOfBlock_Before_EOF" xml:space="preserve">
    <value>The {0} block is missing a closing "{1}" character.  Make sure you have a matching "{1}" character for all the "{2}" characters within this block, and that none of the "{1}" characters are being interpreted as markup.</value>
  </data>
  <data name="ParseError_Expected_X" xml:space="preserve">
    <value>Expected "{0}".</value>
  </data>
  <data name="ParseError_InlineMarkup_Blocks_Cannot_Be_Nested" xml:space="preserve">
    <value>Inline markup blocks (@&lt;p&gt;Content&lt;/p&gt;) cannot be nested.  Only one level of inline markup is allowed.</value>
  </data>
  <data name="ParseError_MarkupBlock_Must_Start_With_Tag" xml:space="preserve">
    <value>Markup in a code block must start with a tag and all start tags must be matched with end tags.  Do not use unclosed tags like "&lt;br&gt;".  Instead use self-closing tags like "&lt;br/&gt;".</value>
  </data>
  <data name="ParseError_MissingEndTag" xml:space="preserve">
    <value>The "{0}" element was not closed.  All elements must be either self-closing or have a matching end tag.</value>
  </data>
  <data name="ParseError_MissingOpenBraceAfterSection" xml:space="preserve">
    <value>Sections cannot be empty.  The "@section" keyword must be followed by a block of markup surrounded by "{}".  For example:

@section Sidebar {
   &lt;!-- Markup and text goes here --&gt;
}</value>
  </data>
  <data name="ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock" xml:space="preserve">
    <value>Namespace imports and type aliases cannot be placed within code blocks.  They must immediately follow an "@" character in markup.  It is recommended that you put them at the top of the page, as in the following example:

@using System.Drawing;
@{
    // OK here to use types from System.Drawing in the page.
}</value>
  </data>
  <data name="ParseError_Sections_Cannot_Be_Nested" xml:space="preserve">
    <value>Section blocks ("{0}") cannot be nested.  Only one level of section blocks are allowed.</value>
    <comment>{0} is one of SectionExample_VB or SectionExample_CS based on the language.</comment>
  </data>
  <data name="ParseError_SingleLine_ControlFlowStatements_Not_Allowed" xml:space="preserve">
    <value>Expected a "{0}" but found a "{1}".  Block statements must be enclosed in "{{" and "}}".  You cannot use single-statement control-flow statements in CSHTML pages. For example, the following is not allowed:

@if(isLoggedIn)
    &lt;p&gt;Hello, @user&lt;/p&gt;

Instead, wrap the contents of the block in "{{}}":

@if(isLoggedIn) {{
    &lt;p&gt;Hello, @user&lt;/p&gt;
}}</value>
    <comment>{0} is only ever a single character</comment>
  </data>
  <data name="ParseError_UnexpectedEndTag" xml:space="preserve">
    <value>Encountered end tag "{0}" with no matching start tag.  Are your start/end tags properly balanced?</value>
  </data>
  <data name="ParseError_Unexpected_Character_At_Section_Name_Start" xml:space="preserve">
    <value>Unexpected {0} after section keyword.  Section names must start with an "_" or alphabetic character, and the remaining characters must be either "_" or alphanumeric.</value>
  </data>
  <data name="ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS" xml:space="preserve">
    <value>"{0}" is not valid at the start of a code block.  Only identifiers, keywords, comments, "(" and "{{" are valid.</value>
    <comment>"{{" is an escape sequence for String.Format, when outputted to the user it will be displayed as "{"</comment>
  </data>
  <data name="ParseError_UnfinishedTag" xml:space="preserve">
    <value>End of file or an unexpected character was reached before the "{0}" tag could be parsed.  Elements inside markup blocks must be complete. They must either be self-closing ("&lt;br /&gt;") or have matching end tags ("&lt;p&gt;Hello&lt;/p&gt;").  If you intended to display a "&lt;" character, use the "&amp;lt;" HTML entity.</value>
  </data>
  <data name="ParseError_Unterminated_String_Literal" xml:space="preserve">
    <value>Unterminated string literal. Strings that start with a quotation mark (") must be terminated before the end of the line.  However, strings that start with @ and a quotation mark (@") can span multiple lines. Closing HTML tags within a string literal may trigger this error message.</value>
  </data>
  <data name="ParseError_InvalidOptionValue" xml:space="preserve">
    <value>"{1}" is not a valid value for the "{0}" option. The "Option {0}" statement must be followed by either "On" or "Off". </value>
    <comment>{0} is either Strict or Explicit and represent VB's "Option Strict" and "Option Explicit" keywords</comment>
  </data>
  <data name="ParseError_UnknownOption" xml:space="preserve">
    <value>Unknown option: "{0}".</value>
  </data>
  <data name="ParseError_BlockNotTerminated" xml:space="preserve">
    <value>The "{0}" block was not terminated.  All "{0}" statements must be terminated with a matching "{1}".</value>
  </data>
  <data name="SectionExample_CS" xml:space="preserve">
    <value>@section Header { ... }</value>
    <comment>In CSHTML, the @section keyword is case-sensitive and lowercase (as with all C# keywords)</comment>
  </data>
  <data name="ParseError_TextTagCannotContainAttributes" xml:space="preserve">
    <value>"&lt;text&gt;" and "&lt;/text&gt;" tags cannot contain attributes.</value>
  </data>
  <data name="ParseError_NamespaceOrTypeAliasExpected" xml:space="preserve">
    <value>The "Imports" keyword must be followed by a namespace or a type alias on the same line.</value>
  </data>
  <data name="ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_CS" xml:space="preserve">
    <value>A space or line break was encountered after the "@" character.  Only valid identifiers, keywords, comments, "(" and "{" are valid at the start of a code block and they must occur immediately following "@" with no space in between.</value>
  </data>
  <data name="ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName" xml:space="preserve">
    <value>The 'inherits' keyword must be followed by a type name on the same line.</value>
  </data>
  <data name="ParseError_OuterTagMissingName" xml:space="preserve">
    <value>Outer tag is missing a name. The first character of a markup block must be an HTML tag with a valid name.</value>
  </data>
  <data name="ParseError_RazorComment_Not_Terminated" xml:space="preserve">
    <value>End of file was reached before the end of the block comment.  All comments that start with the "@*" sequence must be terminated with a matching "*@" sequence.</value>
  </data>
  <data name="ErrorComponent_Character" xml:space="preserve">
    <value>"{0}" character</value>
  </data>
  <data name="ErrorComponent_EndOfFile" xml:space="preserve">
    <value>end of file</value>
  </data>
  <data name="ErrorComponent_Whitespace" xml:space="preserve">
    <value>space or line break</value>
  </data>
  <data name="ParseError_Unexpected_Character_At_Start_Of_CodeBlock_VB" xml:space="preserve">
    <value>"{0}" is not valid at the start of a code block.  Only identifiers, keywords, comments, and "(" are valid.</value>
  </data>
  <data name="ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock" xml:space="preserve">
    <value>End-of-file was found after the "@" character.  "@" must be followed by a valid code block.  If you want to output an "@", escape it using the sequence: "@@"</value>
  </data>
  <data name="ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_VB" xml:space="preserve">
    <value>A space or line break was encountered after the "@" character.  Only valid identifiers, keywords, comments, and "(" are valid at the start of a code block and they must occur immediately following "@" with no space in between.</value>
  </data>
  <data name="Structure_Member_CannotBeNull" xml:space="preserve">
    <value>The {0} property of the {1} structure cannot be null.</value>
  </data>
  <data name="ParseError_MissingCharAfterHelperParameters" xml:space="preserve">
    <value>Expected a "{0}" after the helper parameters.</value>
  </data>
  <data name="ParseError_MissingCharAfterHelperName" xml:space="preserve">
    <value>Expected a "{0}" after the helper name.</value>
  </data>
  <data name="ParseError_UnterminatedHelperParameterList" xml:space="preserve">
    <value>Helper parameter list is missing a closing ")".</value>
  </data>
  <data name="ParseError_Helpers_Cannot_Be_Nested" xml:space="preserve">
    <value>Helper blocks cannot be nested within each other.</value>
  </data>
  <data name="Parser_Context_Not_Set" xml:space="preserve">
    <value>Parser was started with a null Context property.  The Context property must be set BEFORE calling any methods on the parser.</value>
  </data>
  <data name="ParseError_Unexpected_Keyword_After_At" xml:space="preserve">
    <value>Unexpected "{0}" keyword after "@" character.  Once inside code, you do not need to prefix constructs like "{0}" with "@".</value>
  </data>
  <data name="ParseError_ReservedWord" xml:space="preserve">
    <value>"{0}" is a reserved word and cannot be used in implicit expressions.  An explicit expression ("@()") must be used.</value>
  </data>
  <data name="ParseError_Unexpected_Character_At_Helper_Name_Start" xml:space="preserve">
    <value>Unexpected {0} after helper keyword.  All helpers must have a name which starts with an "_" or alphabetic character. The remaining characters must be either "_" or alphanumeric.</value>
  </data>
  <data name="Tokenizer_CannotResumeSymbolUnlessIsPrevious" xml:space="preserve">
    <value>Cannot resume this symbol. Only the symbol immediately preceding the current one can be resumed.</value>
  </data>
  <data name="ParserContext_NoCurrentBlock" xml:space="preserve">
    <value>Cannot finish span, there is no current block. Call StartBlock at least once before finishing a span</value>
  </data>
  <data name="ParserContext_CannotCompleteTree_OutstandingBlocks" xml:space="preserve">
    <value>Cannot complete the tree, there are still open blocks.</value>
  </data>
  <data name="ParserContext_CannotCompleteTree_NoRootBlock" xml:space="preserve">
    <value>Cannot complete the tree, StartBlock must be called at least once.</value>
  </data>
  <data name="ParserContext_ParseComplete" xml:space="preserve">
    <value>Cannot complete action, the parser has finished. Only CompleteParse can be called to extract the final parser results after the parser has finished</value>
  </data>
  <data name="Block_Type_Not_Specified" xml:space="preserve">
    <value>Block cannot be built because a Type has not been specified in the BlockBuilder</value>
  </data>
  <data name="CSharpSymbol_CharacterLiteral" xml:space="preserve">
    <value>&lt;&lt;character literal&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_Comment" xml:space="preserve">
    <value>&lt;&lt;comment&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_Identifier" xml:space="preserve">
    <value>&lt;&lt;identifier&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_IntegerLiteral" xml:space="preserve">
    <value>&lt;&lt;integer literal&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_Keyword" xml:space="preserve">
    <value>&lt;&lt;keyword&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_Newline" xml:space="preserve">
    <value>&lt;&lt;newline sequence&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_RealLiteral" xml:space="preserve">
    <value>&lt;&lt;real literal&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_StringLiteral" xml:space="preserve">
    <value>&lt;&lt;string literal&gt;&gt;</value>
  </data>
  <data name="CSharpSymbol_Whitespace" xml:space="preserve">
    <value>&lt;&lt;white space&gt;&gt;</value>
  </data>
  <data name="Symbol_Unknown" xml:space="preserve">
    <value>&lt;&lt;unknown&gt;&gt;</value>
  </data>
  <data name="TokenizerView_CannotPutBack" xml:space="preserve">
    <value>In order to put a symbol back, it must have been the symbol which ended at the current position. The specified symbol ends at {0}, but the current position is {1}</value>
  </data>
  <data name="ParseError_Unexpected" xml:space="preserve">
    <value>Unexpected "{0}"</value>
  </data>
  <data name="ParseError_Unexpected_Nested_CodeBlock" xml:space="preserve">
    <value>Unexpected "{" after "@" character. Once inside the body of a code block (@if {}, @{}, etc.) you do not need to use "@{" to switch to code.</value>
  </data>
  <data name="ErrorComponent_Newline" xml:space="preserve">
    <value>line break</value>
  </data>
  <data name="SectionExample_VB" xml:space="preserve">
    <value>@Section Header ... End Section</value>
    <comment>In VBHTML, the @Section keyword is case-insensitive (as with all VB keywords), but the standard practice is to Title Case it</comment>
  </data>
  <data name="VBSymbol_CharacterLiteral" xml:space="preserve">
    <value>&lt;&lt;character literal&gt;&gt;</value>
  </data>
  <data name="VBSymbol_Comment" xml:space="preserve">
    <value>&lt;&lt;comment&gt;&gt;</value>
  </data>
  <data name="VBSymbol_DateLiteral" xml:space="preserve">
    <value>&lt;&lt;date literal&gt;&gt;</value>
  </data>
  <data name="VBSymbol_FloatingPointLiteral" xml:space="preserve">
    <value>&lt;&lt;floating point literal&gt;&gt;</value>
  </data>
  <data name="VBSymbol_Identifier" xml:space="preserve">
    <value>&lt;&lt;identifier&gt;&gt;</value>
  </data>
  <data name="VBSymbol_IntegerLiteral" xml:space="preserve">
    <value>&lt;&lt;integer literal&gt;&gt;</value>
  </data>
  <data name="VBSymbol_Keyword" xml:space="preserve">
    <value>&lt;&lt;keyword&gt;&gt;</value>
  </data>
  <data name="VBSymbol_NewLine" xml:space="preserve">
    <value>&lt;&lt;newline sequence&gt;&gt;</value>
  </data>
  <data name="VBSymbol_RazorComment" xml:space="preserve">
    <value>&lt;&lt;razor comment&gt;&gt;</value>
  </data>
  <data name="VBSymbol_StringLiteral" xml:space="preserve">
    <value>&lt;&lt;string literal&gt;&gt;</value>
  </data>
  <data name="VBSymbol_WhiteSpace" xml:space="preserve">
    <value>&lt;&lt;white space&gt;&gt;</value>
  </data>
  <data name="HtmlSymbol_NewLine" xml:space="preserve">
    <value>&lt;&lt;newline sequence&gt;&gt;</value>
  </data>
  <data name="HtmlSymbol_RazorComment" xml:space="preserve">
    <value>&lt;&lt;razor comment&gt;&gt;</value>
  </data>
  <data name="HtmlSymbol_Text" xml:space="preserve">
    <value>&lt;&lt;text&gt;&gt;</value>
  </data>
  <data name="HtmlSymbol_WhiteSpace" xml:space="preserve">
    <value>&lt;&lt;white space&gt;&gt;</value>
  </data>
  <data name="ParserIsNotAMarkupParser" xml:space="preserve">
    <value>The parser provided to the ParserContext was not a Markup Parser.</value>
  </data>
  <data name="Language_Does_Not_Support_RazorComment" xml:space="preserve">
    <value>Cannot use built-in RazorComment handler, language characteristics does not define the CommentStart, CommentStar and CommentBody known symbol types or parser does not override TokenizerBackedParser.OutputSpanBeforeRazorComment</value>
  </data>
  <data name="ParserEror_SessionDirectiveMissingValue" xml:space="preserve">
    <value>Missing value for session state directive.</value>
  </data>
  <data name="CreateCodeWriter_NoCodeWriter" xml:space="preserve">
    <value>Cannot call CreateCodeWriter, a CodeWriter was not provided to the Create method</value>
    <comment>This error should not be seen by users, it should only appear to internal developers, but I'm putting it in resources just in case</comment>
  </data>
  <data name="Trace_BackgroundThreadShutdown" xml:space="preserve">
    <value>[BG][{0}] Shutdown</value>
  </data>
  <data name="Trace_BackgroundThreadStart" xml:space="preserve">
    <value>[BG][{0}] Startup</value>
  </data>
  <data name="Trace_ChangesArrived" xml:space="preserve">
    <value>[BG][{0}] {1} changes arrived</value>
  </data>
  <data name="Trace_ChangesDiscarded" xml:space="preserve">
    <value>[BG][{0}] Discarded {1} changes</value>
  </data>
  <data name="Trace_CollectedDiscardedChanges" xml:space="preserve">
    <value>[BG][{0}] Collecting {1} discarded changes</value>
  </data>
  <data name="Trace_Disabled" xml:space="preserve">
    <value>Disabled</value>
  </data>
  <data name="Trace_EditorProcessedChange" xml:space="preserve">
    <value>[P][{0}] {3} Change in {2} milliseconds: {1}</value>
  </data>
  <data name="Trace_EditorReceivedChange" xml:space="preserve">
    <value>[P][{0}] Received Change: {1}</value>
  </data>
  <data name="Trace_Enabled" xml:space="preserve">
    <value>Enabled</value>
  </data>
  <data name="Trace_Format" xml:space="preserve">
    <value>[Razor] {0}</value>
  </data>
  <data name="Trace_NoChangesArrived" xml:space="preserve">
    <value>[BG][{0}] no changes arrived?</value>
  </data>
  <data name="Trace_ParseComplete" xml:space="preserve">
    <value>[BG][{0}] Parse Complete in {1} milliseconds</value>
  </data>
  <data name="Trace_QueuingParse" xml:space="preserve">
    <value>[M][{0}] Queuing Parse for: {1}</value>
  </data>
  <data name="Trace_Startup" xml:space="preserve">
    <value>[Razor] Editor Tracing {0}</value>
  </data>
  <data name="Trace_TreesCompared" xml:space="preserve">
    <value>[BG][{0}] Trees Compared in {1} milliseconds. Different = {2}</value>
  </data>
</root>

================================================
FILE: src/System.Web.Razor/StateMachine.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor
{
    public abstract class StateMachine<TReturn>
    {
        protected delegate StateResult State();

        protected abstract State StartState { get; }

        protected State CurrentState { get; set; }

        protected virtual TReturn Turn()
        {
            if (CurrentState != null)
            {
                StateResult result;
                do
                {
                    // Keep running until we get a null result or output
                    result = CurrentState();
                    CurrentState = result.Next;
                }
                while (result != null && !result.HasOutput);

                if (result == null)
                {
                    return default(TReturn); // Terminated
                }
                return result.Output;
            }
            return default(TReturn);
        }

        /// <summary>
        /// Returns a result indicating that the machine should stop executing and return null output.
        /// </summary>
        protected StateResult Stop()
        {
            return null;
        }

        /// <summary>
        /// Returns a result indicating that this state has no output and the machine should immediately invoke the specified state
        /// </summary>
        /// <remarks>
        /// By returning no output, the state machine will invoke the next state immediately, before returning
        /// controller to the caller of <see cref="Turn"/>
        /// </remarks>
        protected StateResult Transition(State newState)
        {
            return new StateResult(newState);
        }

        /// <summary>
        /// Returns a result containing the specified output and indicating that the next call to
        /// <see cref="Turn"/> should invoke the provided state.
        /// </summary>
        protected StateResult Transition(TReturn output, State newState)
        {
            return new StateResult(output, newState);
        }

        /// <summary>
        /// Returns a result indicating that this state has no output and the machine should remain in this state
        /// </summary>
        /// <remarks>
        /// By returning no output, the state machine will re-invoke the current state again before returning
        /// controller to the caller of <see cref="Turn"/>
        /// </remarks>
        protected StateResult Stay()
        {
            return new StateResult(CurrentState);
        }

        /// <summary>
        /// Returns a result containing the specified output and indicating that the next call to
        /// <see cref="Turn"/> should re-invoke the current state.
        /// </summary>
        protected StateResult Stay(TReturn output)
        {
            return new StateResult(output, CurrentState);
        }

        protected class StateResult
        {
            public StateResult(State next)
            {
                HasOutput = false;
                Next = next;
            }

            public StateResult(TReturn output, State next)
            {
                HasOutput = true;
                Output = output;
                Next = next;
            }

            public bool HasOutput { get; set; }
            public TReturn Output { get; set; }
            public State Next { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.Razor/System.Web.Razor.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{8F18041B-9410-4C36-A9C5-067813DF5F31}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>System.Web.Razor</RootNamespace>
    <AssemblyName>System.Web.Razor</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DefineConstants>$(DefineConstants);EDITOR_TRACING</DefineConstants>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\Common\HashCodeCombiner.cs">
      <Link>Common\HashCodeCombiner.cs</Link>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="DocumentParseCompleteEventArgs.cs" />
    <Compile Include="Editor\AutoCompleteEditHandler.cs" />
    <Compile Include="Editor\BackgroundParser.cs" />
    <Compile Include="Editor\RazorEditorTrace.cs" />
    <Compile Include="Generator\AttributeBlockCodeGenerator.cs" />
    <Compile Include="Generator\CodeWriterExtensions.cs" />
    <Compile Include="Generator\DynamicAttributeBlockCodeGenerator.cs" />
    <Compile Include="Generator\ExpressionRenderingMode.cs" />
    <Compile Include="Generator\LiteralAttributeCodeGenerator.cs" />
    <Compile Include="Generator\RazorCommentCodeGenerator.cs" />
    <Compile Include="Generator\SetLayoutCodeGenerator.cs" />
    <Compile Include="Editor\SingleLineMarkupEditHandler.cs" />
    <Compile Include="Editor\SpanEditHandler.cs" />
    <Compile Include="Editor\EditResult.cs" />
    <Compile Include="Editor\ImplicitExpressionEditHandler.cs" />
    <Compile Include="Editor\EditorHints.cs" />
    <Compile Include="Generator\AddImportCodeGenerator.cs" />
    <Compile Include="Generator\BlockCodeGenerator.cs" />
    <Compile Include="Generator\CodeGeneratorPaddingHelper.cs" />
    <Compile Include="Generator\CodeGeneratorContext.cs" />
    <Compile Include="Generator\CodeWriter.cs" />
    <Compile Include="Generator\BaseCodeWriter.cs" />
    <Compile Include="Generator\RazorDirectiveAttributeCodeGenerator.cs" />
    <Compile Include="Generator\CSharpCodeWriter.cs" />
    <Compile Include="Generator\ExpressionCodeGenerator.cs" />
    <Compile Include="Generator\GeneratedClassContext.cs" />
    <Compile Include="Generator\HybridCodeGenerator.cs" />
    <Compile Include="Generator\IBlockCodeGenerator.cs" />
    <Compile Include="Generator\ISpanCodeGenerator.cs" />
    <Compile Include="Generator\MarkupCodeGenerator.cs" />
    <Compile Include="Generator\ResolveUrlCodeGenerator.cs" />
    <Compile Include="Generator\SetBaseTypeCodeGenerator.cs" />
    <Compile Include="Generator\HelperCodeGenerator.cs" />
    <Compile Include="Generator\SectionCodeGenerator.cs" />
    <Compile Include="Generator\SetVBOptionCodeGenerator.cs" />
    <Compile Include="Generator\SpanCodeGenerator.cs" />
    <Compile Include="Generator\StatementCodeGenerator.cs" />
    <Compile Include="Generator\TemplateBlockCodeGenerator.cs" />
    <Compile Include="Generator\TypeMemberCodeGenerator.cs" />
    <Compile Include="Generator\VBCodeWriter.cs" />
    <Compile Include="Parser\BalancingModes.cs" />
    <Compile Include="Parser\CallbackVisitor.cs" />
    <Compile Include="Parser\ConditionalAttributeCollapser.cs" />
    <Compile Include="Parser\CSharpCodeParser.Directives.cs" />
    <Compile Include="Parser\CSharpCodeParser.Statements.cs" />
    <Compile Include="Parser\CSharpCodeParser.cs" />
    <Compile Include="Parser\CSharpLanguageCharacteristics.cs" />
    <Compile Include="Parser\HtmlLanguageCharacteristics.cs" />
    <Compile Include="Parser\HtmlMarkupParser.Block.cs" />
    <Compile Include="Parser\HtmlMarkupParser.Document.cs" />
    <Compile Include="Parser\HtmlMarkupParser.cs" />
    <Compile Include="Parser\HtmlMarkupParser.Section.cs" />
    <Compile Include="Parser\ISyntaxTreeRewriter.cs" />
    <Compile Include="Parser\LanguageCharacteristics.cs" />
    <Compile Include="Parser\MarkupCollapser.cs" />
    <Compile Include="Parser\MarkupRewriter.cs" />
    <Compile Include="Parser\ParserHelpers.cs" />
    <Compile Include="Parser\ParserVisitor.cs" />
    <Compile Include="Parser\ParserVisitorExtensions.cs" />
    <Compile Include="Parser\SyntaxConstants.cs" />
    <Compile Include="Parser\SyntaxTree\AcceptedCharacters.cs" />
    <Compile Include="Parser\SyntaxTree\BlockBuilder.cs" />
    <Compile Include="Parser\SyntaxTree\EquivalenceComparer.cs" />
    <Compile Include="Parser\SyntaxTree\SpanBuilder.cs" />
    <Compile Include="Parser\TextReaderExtensions.cs" />
    <Compile Include="Parser\TokenizerBackedParser.cs" />
    <Compile Include="Parser\TokenizerBackedParser.Helpers.cs" />
    <Compile Include="Parser\VBCodeParser.cs" />
    <Compile Include="Parser\VBCodeParser.Directives.cs" />
    <Compile Include="Parser\VBLanguageCharacteristics.cs" />
    <Compile Include="Parser\WhitespaceRewriter.cs" />
    <Compile Include="PartialParseResult.cs" />
    <Compile Include="RazorDebugHelpers.cs" />
    <Compile Include="RazorDirectiveAttribute.cs" />
    <Compile Include="RazorEditorParser.cs" />
    <Compile Include="Generator\CodeGenerationCompleteEventArgs.cs" />
    <Compile Include="Generator\GeneratedCodeMapping.cs" />
    <Compile Include="Generator\RazorCodeGenerator.cs" />
    <Compile Include="GeneratorResults.cs" />
    <Compile Include="RazorEngineHost.cs" />
    <Compile Include="RazorTemplateEngine.cs" />
    <Compile Include="StateMachine.cs" />
    <Compile Include="Text\BufferingTextReader.cs" />
    <Compile Include="Text\LookaheadToken.cs" />
    <Compile Include="Text\LocationTagged.cs" />
    <Compile Include="Text\SeekableTextReader.cs" />
    <Compile Include="Text\LineTrackingStringBuffer.cs" />
    <Compile Include="Text\LookaheadTextReader.cs" />
    <Compile Include="Text\TextExtensions.cs" />
    <Compile Include="Text\TextBufferReader.cs" />
    <Compile Include="Text\TextDocumentReader.cs" />
    <Compile Include="Tokenizer\ITokenizer.cs" />
    <Compile Include="Tokenizer\Symbols\ISymbol.cs" />
    <Compile Include="Tokenizer\Symbols\KnownSymbolType.cs" />
    <Compile Include="Tokenizer\Symbols\SymbolExtensions.cs" />
    <Compile Include="Tokenizer\Symbols\SymbolTypeSuppressions.cs" />
    <Compile Include="Tokenizer\TokenizerView.cs" />
    <Compile Include="Tokenizer\VBKeywordDetector.cs" />
    <Compile Include="Tokenizer\VBHelpers.cs" />
    <Compile Include="Tokenizer\CSharpHelpers.cs" />
    <Compile Include="Tokenizer\CSharpKeywordDetector.cs" />
    <Compile Include="Tokenizer\CSharpTokenizer.cs" />
    <Compile Include="Tokenizer\HtmlTokenizer.cs" />
    <Compile Include="Tokenizer\Symbols\VBKeyword.cs" />
    <Compile Include="Tokenizer\Symbols\VBSymbol.cs" />
    <Compile Include="Tokenizer\Symbols\VBSymbolType.cs" />
    <Compile Include="Tokenizer\Symbols\CSharpKeyword.cs" />
    <Compile Include="Tokenizer\Symbols\CSharpSymbol.cs" />
    <Compile Include="Tokenizer\Symbols\CSharpSymbolType.cs" />
    <Compile Include="Tokenizer\Symbols\HtmlSymbol.cs" />
    <Compile Include="Tokenizer\Symbols\HtmlSymbolType.cs" />
    <Compile Include="Tokenizer\Symbols\SymbolBase.cs" />
    <Compile Include="Tokenizer\Tokenizer.cs" />
    <Compile Include="Tokenizer\VBTokenizer.cs" />
    <Compile Include="Tokenizer\XmlHelpers.cs" />
    <Compile Include="Utils\CharUtils.cs" />
    <Compile Include="VBRazorCodeLanguage.cs" />
    <Compile Include="Generator\CSharpRazorCodeGenerator.cs" />
    <Compile Include="Parser\SyntaxTree\BlockType.cs" />
    <Compile Include="Parser\SyntaxTree\Block.cs" />
    <Compile Include="Parser\SyntaxTree\RazorError.cs" />
    <Compile Include="ParserResults.cs" />
    <Compile Include="Parser\SyntaxTree\SyntaxTreeNode.cs" />
    <Compile Include="Parser\SyntaxTree\SpanKind.cs" />
    <Compile Include="Parser\ParserContext.cs" />
    <Compile Include="Parser\RazorParser.cs" />
    <Compile Include="Text\ITextBuffer.cs" />
    <Compile Include="Text\SourceLocationTracker.cs" />
    <Compile Include="RazorCodeLanguage.cs" />
    <Compile Include="CSharpRazorCodeLanguage.cs" />
    <Compile Include="Utils\DisposableAction.cs" />
    <Compile Include="Utils\EnumUtil.cs" />
    <Compile Include="Utils\EnumeratorExtensions.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="Parser\ParserBase.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Resources\RazorResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>RazorResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Text\SourceLocation.cs" />
    <Compile Include="Text\TextChange.cs" />
    <Compile Include="Text\TextChangeType.cs" />
    <Compile Include="Parser\SyntaxTree\Span.cs" />
    <Compile Include="Generator\VBRazorCodeGenerator.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\RazorResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>RazorResources.Designer.cs</LastGenOutput>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Parser\VBCodeParser.Statements.cs" />
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.Razor/Text/BufferingTextReader.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Web.Razor.Resources;
using System.Web.Razor.Utils;

namespace System.Web.Razor.Text
{
    public class BufferingTextReader : LookaheadTextReader
    {
        private Stack<BacktrackContext> _backtrackStack = new Stack<BacktrackContext>();
        private int _currentBufferPosition;

        private int _currentCharacter;
        private SourceLocationTracker _locationTracker;

        public BufferingTextReader(TextReader source)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            InnerReader = source;
            _locationTracker = new SourceLocationTracker();

            UpdateCurrentCharacter();
        }

        internal StringBuilder Buffer { get; set; }
        internal bool Buffering { get; set; }
        internal TextReader InnerReader { get; private set; }

        public override SourceLocation CurrentLocation
        {
            get { return _locationTracker.CurrentLocation; }
        }

        protected virtual int CurrentCharacter
        {
            get { return _currentCharacter; }
        }

        public override int Read()
        {
            int ch = CurrentCharacter;
            NextCharacter();
            return ch;
        }

        // TODO: Optimize Read(char[],int,int) to copy direct from the buffer where possible

        public override int Peek()
        {
            return CurrentCharacter;
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                InnerReader.Dispose();
            }
            base.Dispose(disposing);
        }

        public override IDisposable BeginLookahead()
        {
            // Is this our first lookahead?
            if (Buffer == null)
            {
                // Yes, setup the backtrack buffer
                Buffer = new StringBuilder();
            }

            if (!Buffering)
            {
                // We're not already buffering, so we need to expand the buffer to hold the first character
                ExpandBuffer();
                Buffering = true;
            }

            // Mark the position to return to when we backtrack
            // Use the closures and the "using" statement rather than an explicit stack
            BacktrackContext context = new BacktrackContext()
            {
                BufferIndex = _currentBufferPosition,
                Location = CurrentLocation
            };
            _backtrackStack.Push(context);
            return new DisposableAction(() =>
            {
                EndLookahead(context);
            });
        }

        // REVIEW: This really doesn't sound like the best name for this...
        public override void CancelBacktrack()
        {
            if (_backtrackStack.Count == 0)
            {
                throw new InvalidOperationException(RazorResources.CancelBacktrack_Must_Be_Called_Within_Lookahead);
            }
            // Just pop the current backtrack context so that when the lookahead ends, it won't be backtracked
            _backtrackStack.Pop();
        }

        private void EndLookahead(BacktrackContext context)
        {
            // If the specified context is not the one on the stack, it was popped by a call to DoNotBacktrack
            if (_backtrackStack.Count > 0 && ReferenceEquals(_backtrackStack.Peek(), context))
            {
                _backtrackStack.Pop();
                _currentBufferPosition = context.BufferIndex;
                _locationTracker.CurrentLocation = context.Location;

                UpdateCurrentCharacter();
            }
        }

        protected virtual void NextCharacter()
        {
            int prevChar = CurrentCharacter;
            if (prevChar == -1)
            {
                return; // We're at the end of the source
            }

            if (Buffering)
            {
                if (_currentBufferPosition >= Buffer.Length - 1)
                {
                    // If there are no more lookaheads (thus no need to continue with the buffer) we can just clean up the buffer
                    if (_backtrackStack.Count == 0)
                    {
                        // Reset the buffer
                        Buffer.Length = 0;
                        _currentBufferPosition = 0;
                        Buffering = false;
                    }
                    else if (!ExpandBuffer())
                    {
                        // Failed to expand the buffer, because we're at the end of the source
                        _currentBufferPosition = Buffer.Length; // Force the position past the end of the buffer
                    }
                }
                else
                {
                    // Not at the end yet, just advance the buffer pointer
                    _currentBufferPosition++;
                }
            }
            else
            {
                // Just act like normal
                InnerReader.Read(); // Don't care about the return value, Peek() is used to get characters from the source
            }

            UpdateCurrentCharacter();
            _locationTracker.UpdateLocation((char)prevChar, (char)CurrentCharacter);
        }

        protected bool ExpandBuffer()
        {
            // Pull another character into the buffer and update the position
            int ch = InnerReader.Read();

            // Only append the character to the buffer if there actually is one
            if (ch != -1)
            {
                Buffer.Append((char)ch);
                _currentBufferPosition = Buffer.Length - 1;
                return true;
            }
            return false;
        }

        private void UpdateCurrentCharacter()
        {
            if (Buffering && _currentBufferPosition < Buffer.Length)
            {
                // Read from the buffer
                _currentCharacter = (int)Buffer[_currentBufferPosition];
            }
            else
            {
                // No buffer? Peek from the source
                _currentCharacter = InnerReader.Peek();
            }
        }

        private class BacktrackContext
        {
            public int BufferIndex { get; set; }
            public SourceLocation Location { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/ITextBuffer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Text
{
    public interface ITextBuffer
    {
        int Length { get; }
        int Position { get; set; }
        int Read();
        int Peek();
    }

    // TextBuffer with Location tracking
    public interface ITextDocument : ITextBuffer
    {
        SourceLocation Location { get; }
    }
}


================================================
FILE: src/System.Web.Razor/Text/LineTrackingStringBuffer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Text;
using System.Web.Razor.Parser;

namespace System.Web.Razor.Text
{
    internal class LineTrackingStringBuffer
    {
        private TextLine _currentLine;
        private TextLine _endLine;
        private IList<TextLine> _lines;

        public LineTrackingStringBuffer()
        {
            _endLine = new TextLine(0, 0);
            _lines = new List<TextLine>() { _endLine };
        }

        public int Length
        {
            get { return _endLine.End; }
        }

        public SourceLocation EndLocation
        {
            get { return new SourceLocation(Length, _lines.Count - 1, _lines[_lines.Count - 1].Length); }
        }

        public void Append(string content)
        {
            for (int i = 0; i < content.Length; i++)
            {
                AppendCore(content[i]);

                // \r on it's own: Start a new line, otherwise wait for \n
                // Other Newline: Start a new line
                if ((content[i] == '\r' && (i + 1 == content.Length || content[i + 1] != '\n')) || (content[i] != '\r' && ParserHelpers.IsNewLine(content[i])))
                {
                    PushNewLine();
                }
            }
        }

        public CharacterReference CharAt(int absoluteIndex)
        {
            TextLine line = FindLine(absoluteIndex);
            if (line == null)
            {
                throw new ArgumentOutOfRangeException("absoluteIndex");
            }
            int idx = absoluteIndex - line.Start;
            return new CharacterReference(line.Content[idx], new SourceLocation(absoluteIndex, line.Index, idx));
        }

        private void PushNewLine()
        {
            _endLine = new TextLine(_endLine.End, _endLine.Index + 1);
            _lines.Add(_endLine);
        }

        private void AppendCore(char chr)
        {
            Debug.Assert(_lines.Count > 0);
            _lines[_lines.Count - 1].Content.Append(chr);
        }

        private TextLine FindLine(int absoluteIndex)
        {
            TextLine selected = null;

            if (_currentLine != null)
            {
                if (_currentLine.Contains(absoluteIndex))
                {
                    // This index is on the last read line
                    selected = _currentLine;
                }
                else if (absoluteIndex > _currentLine.Index && _currentLine.Index + 1 < _lines.Count)
                {
                    // This index is ahead of the last read line
                    selected = ScanLines(absoluteIndex, _currentLine.Index);
                }
            }

            // Have we found a line yet?
            if (selected == null)
            {
                // Scan from line 0
                selected = ScanLines(absoluteIndex, 0);
            }

            Debug.Assert(selected == null || selected.Contains(absoluteIndex));
            _currentLine = selected;
            return selected;
        }

        private TextLine ScanLines(int absoluteIndex, int startPos)
        {
            for (int i = 0; i < _lines.Count; i++)
            {
                int idx = (i + startPos) % _lines.Count;
                Debug.Assert(idx >= 0 && idx < _lines.Count);

                if (_lines[idx].Contains(absoluteIndex))
                {
                    return _lines[idx];
                }
            }
            return null;
        }

        internal class CharacterReference
        {
            public CharacterReference(char character, SourceLocation location)
            {
                Character = character;
                Location = location;
            }

            public char Character { get; private set; }
            public SourceLocation Location { get; private set; }
        }

        private class TextLine
        {
            private StringBuilder _content = new StringBuilder();

            public TextLine(int start, int index)
            {
                Start = start;
                Index = index;
            }

            public StringBuilder Content
            {
                get { return _content; }
            }

            public int Length
            {
                get { return Content.Length; }
            }

            public int Start { get; set; }
            public int Index { get; set; }

            public int End
            {
                get { return Start + Length; }
            }

            public bool Contains(int index)
            {
                return index < End && index >= Start;
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/LocationTagged.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Globalization;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Text
{
    [DebuggerDisplay("({Location})\"{Value}\"")]
    public class LocationTagged<T> : IFormattable
    {
        private LocationTagged()
        {
            Location = SourceLocation.Undefined;
            Value = default(T);
        }

        public LocationTagged(T value, int offset, int line, int col)
            : this(value, new SourceLocation(offset, line, col))
        {
        }

        public LocationTagged(T value, SourceLocation location)
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            Location = location;
            Value = value;
        }

        public SourceLocation Location { get; private set; }
        public T Value { get; private set; }

        public override bool Equals(object obj)
        {
            LocationTagged<T> other = obj as LocationTagged<T>;
            return other != null &&
                   Equals(other.Location, Location) &&
                   Equals(other.Value, Value);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Location)
                .Add(Value)
                .CombinedHash;
        }

        public override string ToString()
        {
            return Value.ToString();
        }

        public string ToString(string format, IFormatProvider formatProvider)
        {
            if (String.IsNullOrEmpty(format))
            {
                format = "P";
            }
            if (formatProvider == null)
            {
                formatProvider = CultureInfo.CurrentCulture;
            }
            switch (format.ToUpperInvariant())
            {
                case "F":
                    return String.Format(formatProvider, "{0}@{1}", Value, Location);
                default:
                    return Value.ToString();
            }
        }

        public static implicit operator T(LocationTagged<T> value)
        {
            return value.Value;
        }

        public static bool operator ==(LocationTagged<T> left, LocationTagged<T> right)
        {
            return Equals(left, right);
        }

        public static bool operator !=(LocationTagged<T> left, LocationTagged<T> right)
        {
            return !Equals(left, right);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/LookaheadTextReader.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.Razor.Text
{
    public abstract class LookaheadTextReader : TextReader
    {
        public abstract SourceLocation CurrentLocation { get; }
        public abstract IDisposable BeginLookahead();
        public abstract void CancelBacktrack();
    }
}


================================================
FILE: src/System.Web.Razor/Text/LookaheadToken.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Text
{
    public class LookaheadToken : IDisposable
    {
        private Action _cancelAction;
        private bool _accepted;

        public LookaheadToken(Action cancelAction)
        {
            _cancelAction = cancelAction;
        }

        public void Accept()
        {
            _accepted = true;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (!_accepted)
            {
                _cancelAction();
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/SeekableTextReader.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.Razor.Text
{
    public class SeekableTextReader : TextReader, ITextDocument
    {
        private int _position = 0;
        private LineTrackingStringBuffer _buffer = new LineTrackingStringBuffer();
        private SourceLocation _location = SourceLocation.Zero;
        private char? _current;

        public SeekableTextReader(string content)
        {
            _buffer.Append(content);
            UpdateState();
        }

        public SeekableTextReader(TextReader source)
            : this(source.ReadToEnd())
        {
        }

        public SeekableTextReader(ITextBuffer buffer)
            : this(buffer.ReadToEnd())
        {
        }

        public SourceLocation Location
        {
            get { return _location; }
        }

        public int Length
        {
            get { return _buffer.Length; }
        }

        public int Position
        {
            get { return _position; }
            set
            {
                if (_position != value)
                {
                    _position = value;
                    UpdateState();
                }
            }
        }

        internal LineTrackingStringBuffer Buffer
        {
            get { return _buffer; }
        }

        public override int Read()
        {
            if (_current == null)
            {
                return -1;
            }
            char chr = _current.Value;
            _position++;
            UpdateState();
            return chr;
        }

        public override int Peek()
        {
            if (_current == null)
            {
                return -1;
            }
            return _current.Value;
        }

        private void UpdateState()
        {
            if (_position < _buffer.Length)
            {
                LineTrackingStringBuffer.CharacterReference chr = _buffer.CharAt(_position);
                _current = chr.Character;
                _location = chr.Location;
            }
            else if (_buffer.Length == 0)
            {
                _current = null;
                _location = SourceLocation.Zero;
            }
            else
            {
                _current = null;
                _location = _buffer.EndLocation;
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/SourceLocation.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;

namespace System.Web.Razor.Text
{
    [Serializable]
    public struct SourceLocation : IEquatable<SourceLocation>, IComparable<SourceLocation>
    {
        public static readonly SourceLocation Undefined = CreateUndefined();
        public static readonly SourceLocation Zero = new SourceLocation(0, 0, 0);

        private int _absoluteIndex;
        private int _lineIndex;
        private int _characterIndex;

        public SourceLocation(int absoluteIndex, int lineIndex, int characterIndex)
        {
            _absoluteIndex = absoluteIndex;
            _lineIndex = lineIndex;
            _characterIndex = characterIndex;
        }

        public int AbsoluteIndex
        {
            get { return _absoluteIndex; }
        }

        /// <summary>
        /// Gets the 1-based index of the line referred to by this Source Location.
        /// </summary>
        public int LineIndex
        {
            get { return _lineIndex; }
        }

        public int CharacterIndex
        {
            get { return _characterIndex; }
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "({0}:{1},{2})", AbsoluteIndex, LineIndex, CharacterIndex);
        }

        public override bool Equals(object obj)
        {
            return (obj is SourceLocation) && Equals((SourceLocation)obj);
        }

        public override int GetHashCode()
        {
            // LineIndex and CharacterIndex can be calculated from AbsoluteIndex and the document content.
            return AbsoluteIndex;
        }

        public bool Equals(SourceLocation other)
        {
            return AbsoluteIndex == other.AbsoluteIndex &&
                   LineIndex == other.LineIndex &&
                   CharacterIndex == other.CharacterIndex;
        }

        public int CompareTo(SourceLocation other)
        {
            return AbsoluteIndex.CompareTo(other.AbsoluteIndex);
        }

        public static SourceLocation Advance(SourceLocation left, string text)
        {
            SourceLocationTracker tracker = new SourceLocationTracker(left);
            tracker.UpdateLocation(text);
            return tracker.CurrentLocation;
        }

        public static SourceLocation Add(SourceLocation left, SourceLocation right)
        {
            if (right.LineIndex > 0)
            {
                // Column index doesn't matter
                return new SourceLocation(left.AbsoluteIndex + right.AbsoluteIndex, left.LineIndex + right.LineIndex, right.CharacterIndex);
            }
            else
            {
                return new SourceLocation(left.AbsoluteIndex + right.AbsoluteIndex, left.LineIndex + right.LineIndex, left.CharacterIndex + right.CharacterIndex);
            }
        }

        public static SourceLocation Subtract(SourceLocation left, SourceLocation right)
        {
            return new SourceLocation(left.AbsoluteIndex - right.AbsoluteIndex,
                                      left.LineIndex - right.LineIndex,
                                      left.LineIndex != right.LineIndex ? left.CharacterIndex : left.CharacterIndex - right.CharacterIndex);
        }

        private static SourceLocation CreateUndefined()
        {
            SourceLocation sl = new SourceLocation();
            sl._absoluteIndex = -1;
            sl._lineIndex = -1;
            sl._characterIndex = -1;
            return sl;
        }

        public static bool operator <(SourceLocation left, SourceLocation right)
        {
            return left.CompareTo(right) < 0;
        }

        public static bool operator >(SourceLocation left, SourceLocation right)
        {
            return left.CompareTo(right) > 0;
        }

        public static bool operator ==(SourceLocation left, SourceLocation right)
        {
            return left.Equals(right);
        }

        public static bool operator !=(SourceLocation left, SourceLocation right)
        {
            return !left.Equals(right);
        }

        public static SourceLocation operator +(SourceLocation left, SourceLocation right)
        {
            return Add(left, right);
        }

        public static SourceLocation operator -(SourceLocation left, SourceLocation right)
        {
            return Subtract(left, right);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/SourceLocationTracker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;

namespace System.Web.Razor.Text
{
    public class SourceLocationTracker
    {
        private int _absoluteIndex = 0;
        private int _characterIndex = 0;
        private int _lineIndex = 0;
        private SourceLocation _currentLocation;

        public SourceLocationTracker()
            : this(SourceLocation.Zero)
        {
        }

        public SourceLocationTracker(SourceLocation currentLocation)
        {
            CurrentLocation = currentLocation;

            UpdateInternalState();
        }

        public SourceLocation CurrentLocation
        {
            get
            {
                return _currentLocation;
            }
            set
            {
                if (_currentLocation != value)
                {
                    _currentLocation = value;
                    UpdateInternalState();
                }
            }
        }

        public void UpdateLocation(char characterRead, char nextCharacter)
        {
            UpdateCharacterCore(characterRead, nextCharacter);
            RecalculateSourceLocation();
        }

        public SourceLocationTracker UpdateLocation(string content)
        {
            for (int i = 0; i < content.Length; i++)
            {
                char nextCharacter = '\0';
                if (i < content.Length - 1)
                {
                    nextCharacter = content[i + 1];
                }
                UpdateCharacterCore(content[i], nextCharacter);
            }
            RecalculateSourceLocation();
            return this;
        }

        private void UpdateCharacterCore(char characterRead, char nextCharacter)
        {
            _absoluteIndex++;

            if (ParserHelpers.IsNewLine(characterRead) && (characterRead != '\r' || nextCharacter != '\n'))
            {
                _lineIndex++;
                _characterIndex = 0;
            }
            else
            {
                _characterIndex++;
            }
        }

        private void UpdateInternalState()
        {
            _absoluteIndex = CurrentLocation.AbsoluteIndex;
            _characterIndex = CurrentLocation.CharacterIndex;
            _lineIndex = CurrentLocation.LineIndex;
        }

        private void RecalculateSourceLocation()
        {
            _currentLocation = new SourceLocation(_absoluteIndex, _lineIndex, _characterIndex);
        }

        public static SourceLocation CalculateNewLocation(SourceLocation lastPosition, string newContent)
        {
            return new SourceLocationTracker(lastPosition).UpdateLocation(newContent).CurrentLocation;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/TextBufferReader.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Resources;
using System.Web.Razor.Utils;

namespace System.Web.Razor.Text
{
    public class TextBufferReader : LookaheadTextReader
    {
        private Stack<BacktrackContext> _bookmarks = new Stack<BacktrackContext>();
        private SourceLocationTracker _tracker = new SourceLocationTracker();

        public TextBufferReader(ITextBuffer buffer)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }

            InnerBuffer = buffer;
        }

        internal ITextBuffer InnerBuffer { get; private set; }

        public override SourceLocation CurrentLocation
        {
            get { return _tracker.CurrentLocation; }
        }

        public override int Peek()
        {
            return InnerBuffer.Peek();
        }

        public override int Read()
        {
            int read = InnerBuffer.Read();
            if (read != -1)
            {
                char nextChar = '\0';
                int next = Peek();
                if (next != -1)
                {
                    nextChar = (char)next;
                }
                _tracker.UpdateLocation((char)read, nextChar);
            }
            return read;
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                IDisposable disposable = InnerBuffer as IDisposable;
                if (disposable != null)
                {
                    disposable.Dispose();
                }
            }
            base.Dispose(disposing);
        }

        public override IDisposable BeginLookahead()
        {
            BacktrackContext context = new BacktrackContext() { Location = CurrentLocation };
            _bookmarks.Push(context);
            return new DisposableAction(() =>
            {
                EndLookahead(context);
            });
        }

        public override void CancelBacktrack()
        {
            if (_bookmarks.Count == 0)
            {
                throw new InvalidOperationException(RazorResources.CancelBacktrack_Must_Be_Called_Within_Lookahead);
            }
            _bookmarks.Pop();
        }

        private void EndLookahead(BacktrackContext context)
        {
            if (_bookmarks.Count > 0 && ReferenceEquals(_bookmarks.Peek(), context))
            {
                // Backtrack wasn't cancelled, so pop it
                _bookmarks.Pop();

                // Set the new current location
                _tracker.CurrentLocation = context.Location;
                InnerBuffer.Position = context.Location.AbsoluteIndex;
            }
        }

        /// <summary>
        /// Need a class for reference equality to support cancelling backtrack.
        /// </summary>
        private class BacktrackContext
        {
            public SourceLocation Location { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/TextChange.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Globalization;
using System.Text;
using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Text
{
    public struct TextChange
    {
        private string _newText;
        private string _oldText;

        /// <summary>
        /// Constructor for changes where the position hasn't moved (primarily for tests)
        /// </summary>
        internal TextChange(int position, int oldLength, ITextBuffer oldBuffer, int newLength, ITextBuffer newBuffer)
            : this(position, oldLength, oldBuffer, position, newLength, newBuffer)
        {
        }

        public TextChange(int oldPosition, int oldLength, ITextBuffer oldBuffer, int newPosition, int newLength, ITextBuffer newBuffer)
            : this()
        {
            if (oldPosition < 0)
            {
                throw new ArgumentOutOfRangeException("oldPosition", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "0"));
            }
            if (newPosition < 0)
            {
                throw new ArgumentOutOfRangeException("newPosition", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "0"));
            }
            if (oldLength < 0)
            {
                throw new ArgumentOutOfRangeException("oldLength", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "0"));
            }
            if (newLength < 0)
            {
                throw new ArgumentOutOfRangeException("newLength", String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Must_Be_GreaterThanOrEqualTo, "0"));
            }
            if (oldBuffer == null)
            {
                throw new ArgumentNullException("oldBuffer");
            }
            if (newBuffer == null)
            {
                throw new ArgumentNullException("newBuffer");
            }

            OldPosition = oldPosition;
            NewPosition = newPosition;
            OldLength = oldLength;
            NewLength = newLength;
            NewBuffer = newBuffer;
            OldBuffer = oldBuffer;
        }

        public int OldPosition { get; private set; }
        public int NewPosition { get; private set; }
        public int OldLength { get; private set; }
        public int NewLength { get; private set; }
        public ITextBuffer NewBuffer { get; private set; }
        public ITextBuffer OldBuffer { get; private set; }

        /// <remark>
        /// Note: This property is not thread safe, and will move position on the textbuffer while being read.
        /// https://aspnetwebstack.codeplex.com/workitem/1317, tracks making this immutable and improving the access
        /// to ITextBuffer to be thread safe.
        /// </remark>
        public string OldText
        {
            get
            {
                if (_oldText == null && OldBuffer != null)
                {
                    _oldText = GetText(OldBuffer, OldPosition, OldLength);
                }
                return _oldText;
            }
        }

        /// <remark>
        /// Note: This property is not thread safe, and will move position on the textbuffer while being read.
        /// https://aspnetwebstack.codeplex.com/workitem/1317, tracks making this immutable and improving the access
        /// to ITextBuffer to be thread safe.
        /// </remark>
        public string NewText
        {
            get
            {
                if (_newText == null)
                {
                    _newText = GetText(NewBuffer, NewPosition, NewLength);
                }
                return _newText;
            }
        }

        public bool IsInsert
        {
            get { return OldLength == 0 && NewLength > 0; }
        }

        public bool IsDelete
        {
            get { return OldLength > 0 && NewLength == 0; }
        }

        public bool IsReplace
        {
            get { return OldLength > 0 && NewLength > 0; }
        }

        public override bool Equals(object obj)
        {
            if (!(obj is TextChange))
            {
                return false;
            }
            TextChange change = (TextChange)obj;
            return (change.OldPosition == OldPosition) &&
                   (change.NewPosition == NewPosition) &&
                   (change.OldLength == OldLength) &&
                   (change.NewLength == NewLength) &&
                   OldBuffer.Equals(change.OldBuffer) &&
                   NewBuffer.Equals(change.NewBuffer);
        }

        public string ApplyChange(string content, int changeOffset)
        {
            int changeRelativePosition = OldPosition - changeOffset;

            Debug.Assert(changeRelativePosition >= 0);
            return content.Remove(changeRelativePosition, OldLength)
                .Insert(changeRelativePosition, NewText);
        }

        /// <summary>
        /// Applies the text change to the content of the span and returns the new content.
        /// This method doesn't update the span content.
        /// </summary>
        public string ApplyChange(Span span)
        {
            return ApplyChange(span.Content, span.Start.AbsoluteIndex);
        }

        public override int GetHashCode()
        {
            return OldPosition ^ NewPosition ^ OldLength ^ NewLength ^ NewBuffer.GetHashCode() ^ OldBuffer.GetHashCode();
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.CurrentCulture, "({0}:{1}) \"{3}\" -> ({0}:{2}) \"{4}\"", OldPosition, OldLength, NewLength, OldText, NewText);
        }

        /// <summary>
        /// Removes a common prefix from the edit to turn IntelliSense replacements into insertions where possible
        /// </summary>
        /// <returns>A normalized text change</returns>
        public TextChange Normalize()
        {
            if (OldBuffer != null && IsReplace && NewLength > OldLength && NewText.StartsWith(OldText, StringComparison.Ordinal) && NewPosition == OldPosition)
            {
                // Normalize the change into an insertion of the uncommon suffix (i.e. strip out the common prefix)
                return new TextChange(oldPosition: OldPosition + OldLength,
                                      oldLength: 0,
                                      oldBuffer: OldBuffer,
                                      newPosition: OldPosition + OldLength,
                                      newLength: NewLength - OldLength,
                                      newBuffer: NewBuffer);
            }
            return this;
        }

        private static string GetText(ITextBuffer buffer, int position, int length)
        {
            // Optimization for the common case of one char inserts, in this case we don't even need to seek the buffer.
            if (length == 0)
            {
                return String.Empty;
            }

            int oldPosition = buffer.Position;
            try
            {
                buffer.Position = position;

                // Optimization for the common case of one char inserts, in this case we seek the buffer.
                if (length == 1)
                {
                    return ((char)buffer.Read()).ToString();
                }
                else
                {
                    var builder = new StringBuilder();
                    for (int i = 0; i < length; i++)
                    {
                        char c = (char)buffer.Read();
                        builder.Append(c);

                        // This check is probably not necessary, will revisit when fixing https://aspnetwebstack.codeplex.com/workitem/1317
                        if (Char.IsHighSurrogate(c))
                        {
                            builder.Append((char)buffer.Read());
                        }
                    }
                    return builder.ToString();
                }
            }
            finally
            {
                buffer.Position = oldPosition;
            }
        }

        public static bool operator ==(TextChange left, TextChange right)
        {
            return left.Equals(right);
        }

        public static bool operator !=(TextChange left, TextChange right)
        {
            return !left.Equals(right);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/TextChangeType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Text
{
    public enum TextChangeType
    {
        Insert,
        Remove
    }
}


================================================
FILE: src/System.Web.Razor/Text/TextDocumentReader.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.Razor.Text
{
    public class TextDocumentReader : TextReader, ITextDocument
    {
        public TextDocumentReader(ITextDocument source)
        {
            Document = source;
        }

        internal ITextDocument Document { get; private set; }

        public SourceLocation Location
        {
            get { return Document.Location; }
        }

        public int Length
        {
            get { return Document.Length; }
        }

        public int Position
        {
            get { return Document.Position; }
            set { Document.Position = value; }
        }

        public override int Read()
        {
            return Document.Read();
        }

        public override int Peek()
        {
            return Document.Peek();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Text/TextExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Text;

namespace System.Web.Razor.Text
{
    internal static class TextExtensions
    {
        public static void Seek(this ITextBuffer self, int characters)
        {
            self.Position += characters;
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The consumer is expected to dispose this object")]
        public static ITextDocument ToDocument(this ITextBuffer self)
        {
            ITextDocument ret = self as ITextDocument;
            if (ret == null)
            {
                ret = new SeekableTextReader(self);
            }
            return ret;
        }

        public static LookaheadToken BeginLookahead(this ITextBuffer self)
        {
            int start = self.Position;
            return new LookaheadToken(() =>
            {
                self.Position = start;
            });
        }

        public static string ReadToEnd(this ITextBuffer self)
        {
            StringBuilder builder = new StringBuilder();
            int read;
            while ((read = self.Read()) != -1)
            {
                builder.Append((char)read);
            }
            return builder.ToString();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/CSharpHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;

namespace System.Web.Razor.Tokenizer
{
    public static class CSharpHelpers
    {
        // CSharp Spec §2.4.2
        public static bool IsIdentifierStart(char character)
        {
            return Char.IsLetter(character) ||
                   character == '_' ||
                   Char.GetUnicodeCategory(character) == UnicodeCategory.LetterNumber; // Ln
        }

        public static bool IsIdentifierPart(char character)
        {
            return Char.IsDigit(character) ||
                   IsIdentifierStart(character) ||
                   IsIdentifierPartByUnicodeCategory(character);
        }

        public static bool IsRealLiteralSuffix(char character)
        {
            return character == 'F' ||
                   character == 'f' ||
                   character == 'D' ||
                   character == 'd' ||
                   character == 'M' ||
                   character == 'm';
        }

        private static bool IsIdentifierPartByUnicodeCategory(char character)
        {
            UnicodeCategory category = Char.GetUnicodeCategory(character);
            return category == UnicodeCategory.NonSpacingMark || // Mn
                   category == UnicodeCategory.SpacingCombiningMark || // Mc
                   category == UnicodeCategory.ConnectorPunctuation || // Pc
                   category == UnicodeCategory.Format; // Cf
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/CSharpKeywordDetector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    internal static class CSharpKeywordDetector
    {
        private static readonly Dictionary<string, CSharpKeyword> _keywords = new Dictionary<string, CSharpKeyword>(StringComparer.Ordinal)
        {
            { "abstract", CSharpKeyword.Abstract },
            { "byte", CSharpKeyword.Byte },
            { "class", CSharpKeyword.Class },
            { "delegate", CSharpKeyword.Delegate },
            { "event", CSharpKeyword.Event },
            { "fixed", CSharpKeyword.Fixed },
            { "if", CSharpKeyword.If },
            { "internal", CSharpKeyword.Internal },
            { "new", CSharpKeyword.New },
            { "override", CSharpKeyword.Override },
            { "readonly", CSharpKeyword.Readonly },
            { "short", CSharpKeyword.Short },
            { "struct", CSharpKeyword.Struct },
            { "try", CSharpKeyword.Try },
            { "unsafe", CSharpKeyword.Unsafe },
            { "volatile", CSharpKeyword.Volatile },
            { "as", CSharpKeyword.As },
            { "do", CSharpKeyword.Do },
            { "is", CSharpKeyword.Is },
            { "params", CSharpKeyword.Params },
            { "ref", CSharpKeyword.Ref },
            { "switch", CSharpKeyword.Switch },
            { "ushort", CSharpKeyword.Ushort },
            { "while", CSharpKeyword.While },
            { "case", CSharpKeyword.Case },
            { "const", CSharpKeyword.Const },
            { "explicit", CSharpKeyword.Explicit },
            { "float", CSharpKeyword.Float },
            { "null", CSharpKeyword.Null },
            { "sizeof", CSharpKeyword.Sizeof },
            { "typeof", CSharpKeyword.Typeof },
            { "implicit", CSharpKeyword.Implicit },
            { "private", CSharpKeyword.Private },
            { "this", CSharpKeyword.This },
            { "using", CSharpKeyword.Using },
            { "extern", CSharpKeyword.Extern },
            { "return", CSharpKeyword.Return },
            { "stackalloc", CSharpKeyword.Stackalloc },
            { "uint", CSharpKeyword.Uint },
            { "base", CSharpKeyword.Base },
            { "catch", CSharpKeyword.Catch },
            { "continue", CSharpKeyword.Continue },
            { "double", CSharpKeyword.Double },
            { "for", CSharpKeyword.For },
            { "in", CSharpKeyword.In },
            { "lock", CSharpKeyword.Lock },
            { "object", CSharpKeyword.Object },
            { "protected", CSharpKeyword.Protected },
            { "static", CSharpKeyword.Static },
            { "false", CSharpKeyword.False },
            { "public", CSharpKeyword.Public },
            { "sbyte", CSharpKeyword.Sbyte },
            { "throw", CSharpKeyword.Throw },
            { "virtual", CSharpKeyword.Virtual },
            { "decimal", CSharpKeyword.Decimal },
            { "else", CSharpKeyword.Else },
            { "operator", CSharpKeyword.Operator },
            { "string", CSharpKeyword.String },
            { "ulong", CSharpKeyword.Ulong },
            { "bool", CSharpKeyword.Bool },
            { "char", CSharpKeyword.Char },
            { "default", CSharpKeyword.Default },
            { "foreach", CSharpKeyword.Foreach },
            { "long", CSharpKeyword.Long },
            { "void", CSharpKeyword.Void },
            { "enum", CSharpKeyword.Enum },
            { "finally", CSharpKeyword.Finally },
            { "int", CSharpKeyword.Int },
            { "out", CSharpKeyword.Out },
            { "sealed", CSharpKeyword.Sealed },
            { "true", CSharpKeyword.True },
            { "goto", CSharpKeyword.Goto },
            { "unchecked", CSharpKeyword.Unchecked },
            { "interface", CSharpKeyword.Interface },
            { "break", CSharpKeyword.Break },
            { "checked", CSharpKeyword.Checked },
            { "namespace", CSharpKeyword.Namespace }
        };

        public static CSharpKeyword? SymbolTypeForIdentifier(string id)
        {
            CSharpKeyword type;
            if (!_keywords.TryGetValue(id, out type))
            {
                return null;
            }
            return type;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/CSharpTokenizer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    public class CSharpTokenizer : Tokenizer<CSharpSymbol, CSharpSymbolType>
    {
        private Dictionary<char, Func<CSharpSymbolType>> _operatorHandlers;

        public CSharpTokenizer(ITextDocument source)
            : base(source)
        {
            CurrentState = Data;

            _operatorHandlers = new Dictionary<char, Func<CSharpSymbolType>>()
            {
                { '-', MinusOperator },
                { '<', LessThanOperator },
                { '>', GreaterThanOperator },
                { '&', CreateTwoCharOperatorHandler(CSharpSymbolType.And, '=', CSharpSymbolType.AndAssign, '&', CSharpSymbolType.DoubleAnd) },
                { '|', CreateTwoCharOperatorHandler(CSharpSymbolType.Or, '=', CSharpSymbolType.OrAssign, '|', CSharpSymbolType.DoubleOr) },
                { '+', CreateTwoCharOperatorHandler(CSharpSymbolType.Plus, '=', CSharpSymbolType.PlusAssign, '+', CSharpSymbolType.Increment) },
                { '=', CreateTwoCharOperatorHandler(CSharpSymbolType.Assign, '=', CSharpSymbolType.Equals, '>', CSharpSymbolType.GreaterThanEqual) },
                { '!', CreateTwoCharOperatorHandler(CSharpSymbolType.Not, '=', CSharpSymbolType.NotEqual) },
                { '%', CreateTwoCharOperatorHandler(CSharpSymbolType.Modulo, '=', CSharpSymbolType.ModuloAssign) },
                { '*', CreateTwoCharOperatorHandler(CSharpSymbolType.Star, '=', CSharpSymbolType.MultiplyAssign) },
                { ':', CreateTwoCharOperatorHandler(CSharpSymbolType.Colon, ':', CSharpSymbolType.DoubleColon) },
                { '?', CreateTwoCharOperatorHandler(CSharpSymbolType.QuestionMark, '?', CSharpSymbolType.NullCoalesce) },
                { '^', CreateTwoCharOperatorHandler(CSharpSymbolType.Xor, '=', CSharpSymbolType.XorAssign) },
                { '(', () => CSharpSymbolType.LeftParenthesis },
                { ')', () => CSharpSymbolType.RightParenthesis },
                { '{', () => CSharpSymbolType.LeftBrace },
                { '}', () => CSharpSymbolType.RightBrace },
                { '[', () => CSharpSymbolType.LeftBracket },
                { ']', () => CSharpSymbolType.RightBracket },
                { ',', () => CSharpSymbolType.Comma },
                { ';', () => CSharpSymbolType.Semicolon },
                { '~', () => CSharpSymbolType.Tilde },
                { '#', () => CSharpSymbolType.Hash }
            };
        }

        protected override State StartState
        {
            get { return Data; }
        }

        public override CSharpSymbolType RazorCommentType
        {
            get { return CSharpSymbolType.RazorComment; }
        }

        public override CSharpSymbolType RazorCommentTransitionType
        {
            get { return CSharpSymbolType.RazorCommentTransition; }
        }

        public override CSharpSymbolType RazorCommentStarType
        {
            get { return CSharpSymbolType.RazorCommentStar; }
        }

        protected override CSharpSymbol CreateSymbol(SourceLocation start, string content, CSharpSymbolType type, IEnumerable<RazorError> errors)
        {
            return new CSharpSymbol(start, content, type, errors);
        }

        private StateResult Data()
        {
            if (ParserHelpers.IsNewLine(CurrentCharacter))
            {
                // CSharp Spec §2.3.1
                bool checkTwoCharNewline = CurrentCharacter == '\r';
                TakeCurrent();
                if (checkTwoCharNewline && CurrentCharacter == '\n')
                {
                    TakeCurrent();
                }
                return Stay(EndSymbol(CSharpSymbolType.NewLine));
            }
            else if (ParserHelpers.IsWhitespace(CurrentCharacter))
            {
                // CSharp Spec §2.3.3
                TakeUntil(c => !ParserHelpers.IsWhitespace(c));
                return Stay(EndSymbol(CSharpSymbolType.WhiteSpace));
            }
            else if (CSharpHelpers.IsIdentifierStart(CurrentCharacter))
            {
                return Identifier();
            }
            else if (Char.IsDigit(CurrentCharacter))
            {
                return NumericLiteral();
            }
            switch (CurrentCharacter)
            {
                case '@':
                    return AtSymbol();
                case '\'':
                    TakeCurrent();
                    return Transition(() => QuotedLiteral('\'', CSharpSymbolType.CharacterLiteral));
                case '"':
                    TakeCurrent();
                    return Transition(() => QuotedLiteral('"', CSharpSymbolType.StringLiteral));
                case '.':
                    if (Char.IsDigit(Peek()))
                    {
                        return RealLiteral();
                    }
                    return Stay(Single(CSharpSymbolType.Dot));
                case '/':
                    TakeCurrent();
                    if (CurrentCharacter == '/')
                    {
                        TakeCurrent();
                        return SingleLineComment();
                    }
                    else if (CurrentCharacter == '*')
                    {
                        TakeCurrent();
                        return Transition(BlockComment);
                    }
                    else if (CurrentCharacter == '=')
                    {
                        TakeCurrent();
                        return Stay(EndSymbol(CSharpSymbolType.DivideAssign));
                    }
                    else
                    {
                        return Stay(EndSymbol(CSharpSymbolType.Slash));
                    }
                default:
                    return Stay(EndSymbol(Operator()));
            }
        }

        private StateResult AtSymbol()
        {
            TakeCurrent();
            if (CurrentCharacter == '"')
            {
                TakeCurrent();
                return Transition(VerbatimStringLiteral);
            }
            else if (CurrentCharacter == '*')
            {
                return Transition(EndSymbol(CSharpSymbolType.RazorCommentTransition), AfterRazorCommentTransition);
            }
            else if (CurrentCharacter == '@')
            {
                // Could be escaped comment transition
                return Transition(EndSymbol(CSharpSymbolType.Transition), () =>
                {
                    TakeCurrent();
                    return Transition(EndSymbol(CSharpSymbolType.Transition), Data);
                });
            }
            return Stay(EndSymbol(CSharpSymbolType.Transition));
        }

        private CSharpSymbolType Operator()
        {
            char first = CurrentCharacter;
            TakeCurrent();
            Func<CSharpSymbolType> handler;
            if (_operatorHandlers.TryGetValue(first, out handler))
            {
                return handler();
            }
            return CSharpSymbolType.Unknown;
        }

        private CSharpSymbolType LessThanOperator()
        {
            if (CurrentCharacter == '=')
            {
                TakeCurrent();
                return CSharpSymbolType.LessThanEqual;
            }
            return CSharpSymbolType.LessThan;
        }

        private CSharpSymbolType GreaterThanOperator()
        {
            if (CurrentCharacter == '=')
            {
                TakeCurrent();
                return CSharpSymbolType.GreaterThanEqual;
            }
            return CSharpSymbolType.GreaterThan;
        }

        private CSharpSymbolType MinusOperator()
        {
            if (CurrentCharacter == '>')
            {
                TakeCurrent();
                return CSharpSymbolType.Arrow;
            }
            else if (CurrentCharacter == '-')
            {
                TakeCurrent();
                return CSharpSymbolType.Decrement;
            }
            else if (CurrentCharacter == '=')
            {
                TakeCurrent();
                return CSharpSymbolType.MinusAssign;
            }
            return CSharpSymbolType.Minus;
        }

        private Func<CSharpSymbolType> CreateTwoCharOperatorHandler(CSharpSymbolType typeIfOnlyFirst, char second, CSharpSymbolType typeIfBoth)
        {
            return () =>
            {
                if (CurrentCharacter == second)
                {
                    TakeCurrent();
                    return typeIfBoth;
                }
                return typeIfOnlyFirst;
            };
        }

        private Func<CSharpSymbolType> CreateTwoCharOperatorHandler(CSharpSymbolType typeIfOnlyFirst, char option1, CSharpSymbolType typeIfOption1, char option2, CSharpSymbolType typeIfOption2)
        {
            return () =>
            {
                if (CurrentCharacter == option1)
                {
                    TakeCurrent();
                    return typeIfOption1;
                }
                else if (CurrentCharacter == option2)
                {
                    TakeCurrent();
                    return typeIfOption2;
                }
                return typeIfOnlyFirst;
            };
        }

        private StateResult VerbatimStringLiteral()
        {
            TakeUntil(c => c == '"');
            if (CurrentCharacter == '"')
            {
                TakeCurrent();
                if (CurrentCharacter == '"')
                {
                    TakeCurrent();
                    // Stay in the literal, this is an escaped "
                    return Stay();
                }
            }
            else if (EndOfFile)
            {
                CurrentErrors.Add(new RazorError(RazorResources.ParseError_Unterminated_String_Literal, CurrentStart));
            }
            return Transition(EndSymbol(CSharpSymbolType.StringLiteral), Data);
        }

        private StateResult QuotedLiteral(char quote, CSharpSymbolType literalType)
        {
            TakeUntil(c => c == '\\' || c == quote || ParserHelpers.IsNewLine(c));
            if (CurrentCharacter == '\\')
            {
                TakeCurrent(); // Take the '\'
                
                // If the next char is the same quote that started this
                if (CurrentCharacter == quote || CurrentCharacter == '\\')
                {
                    TakeCurrent(); // Take it so that we don't prematurely end the literal.
                }
                return Stay();
            }
            else if (EndOfFile || ParserHelpers.IsNewLine(CurrentCharacter))
            {
                CurrentErrors.Add(new RazorError(RazorResources.ParseError_Unterminated_String_Literal, CurrentStart));
            }
            else
            {
                TakeCurrent(); // No-op if at EOF
            }
            return Transition(EndSymbol(literalType), Data);
        }

        // CSharp Spec §2.3.2
        private StateResult BlockComment()
        {
            TakeUntil(c => c == '*');
            if (EndOfFile)
            {
                CurrentErrors.Add(new RazorError(RazorResources.ParseError_BlockComment_Not_Terminated, CurrentStart));
                return Transition(EndSymbol(CSharpSymbolType.Comment), Data);
            }
            if (CurrentCharacter == '*')
            {
                TakeCurrent();
                if (CurrentCharacter == '/')
                {
                    TakeCurrent();
                    return Transition(EndSymbol(CSharpSymbolType.Comment), Data);
                }
            }
            return Stay();
        }

        // CSharp Spec §2.3.2
        private StateResult SingleLineComment()
        {
            TakeUntil(c => ParserHelpers.IsNewLine(c));
            return Stay(EndSymbol(CSharpSymbolType.Comment));
        }

        // CSharp Spec §2.4.4
        private StateResult NumericLiteral()
        {
            if (TakeAll("0x", caseSensitive: true))
            {
                return HexLiteral();
            }
            else
            {
                return DecimalLiteral();
            }
        }

        private StateResult HexLiteral()
        {
            TakeUntil(c => !ParserHelpers.IsHexDigit(c));
            TakeIntegerSuffix();
            return Stay(EndSymbol(CSharpSymbolType.IntegerLiteral));
        }

        private StateResult DecimalLiteral()
        {
            TakeUntil(c => !Char.IsDigit(c));
            if (CurrentCharacter == '.' && Char.IsDigit(Peek()))
            {
                return RealLiteral();
            }
            else if (CSharpHelpers.IsRealLiteralSuffix(CurrentCharacter) ||
                     CurrentCharacter == 'E' || CurrentCharacter == 'e')
            {
                return RealLiteralExponentPart();
            }
            else
            {
                TakeIntegerSuffix();
                return Stay(EndSymbol(CSharpSymbolType.IntegerLiteral));
            }
        }

        private StateResult RealLiteralExponentPart()
        {
            if (CurrentCharacter == 'E' || CurrentCharacter == 'e')
            {
                TakeCurrent();
                if (CurrentCharacter == '+' || CurrentCharacter == '-')
                {
                    TakeCurrent();
                }
                TakeUntil(c => !Char.IsDigit(c));
            }
            if (CSharpHelpers.IsRealLiteralSuffix(CurrentCharacter))
            {
                TakeCurrent();
            }
            return Stay(EndSymbol(CSharpSymbolType.RealLiteral));
        }

        // CSharp Spec §2.4.4.3
        private StateResult RealLiteral()
        {
            AssertCurrent('.');
            TakeCurrent();
            Debug.Assert(Char.IsDigit(CurrentCharacter));
            TakeUntil(c => !Char.IsDigit(c));
            return RealLiteralExponentPart();
        }

        private void TakeIntegerSuffix()
        {
            if (Char.ToLowerInvariant(CurrentCharacter) == 'u')
            {
                TakeCurrent();
                if (Char.ToLowerInvariant(CurrentCharacter) == 'l')
                {
                    TakeCurrent();
                }
            }
            else if (Char.ToLowerInvariant(CurrentCharacter) == 'l')
            {
                TakeCurrent();
                if (Char.ToLowerInvariant(CurrentCharacter) == 'u')
                {
                    TakeCurrent();
                }
            }
        }

        // CSharp Spec §2.4.2
        private StateResult Identifier()
        {
            Debug.Assert(CSharpHelpers.IsIdentifierStart(CurrentCharacter));
            TakeCurrent();
            TakeUntil(c => !CSharpHelpers.IsIdentifierPart(c));
            CSharpSymbol sym = null;
            if (HaveContent)
            {
                CSharpKeyword? kwd = CSharpKeywordDetector.SymbolTypeForIdentifier(Buffer.ToString());
                CSharpSymbolType type = CSharpSymbolType.Identifier;
                if (kwd != null)
                {
                    type = CSharpSymbolType.Keyword;
                }
                sym = new CSharpSymbol(CurrentStart, Buffer.ToString(), type) { Keyword = kwd };
            }
            StartSymbol();
            return Stay(sym);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/HtmlTokenizer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    // Tokenizer _loosely_ based on http://dev.w3.org/html5/spec/Overview.html#tokenization
    public class HtmlTokenizer : Tokenizer<HtmlSymbol, HtmlSymbolType>
    {
        private const char TransitionChar = '@';

        public HtmlTokenizer(ITextDocument source)
            : base(source)
        {
            CurrentState = Data;
        }

        protected override State StartState
        {
            get { return Data; }
        }

        public override HtmlSymbolType RazorCommentType
        {
            get { return HtmlSymbolType.RazorComment; }
        }

        public override HtmlSymbolType RazorCommentTransitionType
        {
            get { return HtmlSymbolType.RazorCommentTransition; }
        }

        public override HtmlSymbolType RazorCommentStarType
        {
            get { return HtmlSymbolType.RazorCommentStar; }
        }

        internal static IEnumerable<HtmlSymbol> Tokenize(string content)
        {
            using (SeekableTextReader reader = new SeekableTextReader(content))
            {
                HtmlTokenizer tok = new HtmlTokenizer(reader);
                HtmlSymbol sym;
                while ((sym = tok.NextSymbol()) != null)
                {
                    yield return sym;
                }
            }
        }

        protected override HtmlSymbol CreateSymbol(SourceLocation start, string content, HtmlSymbolType type, IEnumerable<RazorError> errors)
        {
            return new HtmlSymbol(start, content, type, errors);
        }

        // http://dev.w3.org/html5/spec/Overview.html#data-state
        private StateResult Data()
        {
            if (ParserHelpers.IsWhitespace(CurrentCharacter))
            {
                return Stay(Whitespace());
            }
            else if (ParserHelpers.IsNewLine(CurrentCharacter))
            {
                return Stay(Newline());
            }
            else if (CurrentCharacter == '@')
            {
                TakeCurrent();
                if (CurrentCharacter == '*')
                {
                    return Transition(EndSymbol(HtmlSymbolType.RazorCommentTransition), AfterRazorCommentTransition);
                }
                else if (CurrentCharacter == '@')
                {
                    // Could be escaped comment transition
                    return Transition(EndSymbol(HtmlSymbolType.Transition), () =>
                    {
                        TakeCurrent();
                        return Transition(EndSymbol(HtmlSymbolType.Transition), Data);
                    });
                }
                return Stay(EndSymbol(HtmlSymbolType.Transition));
            }
            else if (AtSymbol())
            {
                return Stay(Symbol());
            }
            else
            {
                return Transition(Text);
            }
        }

        private StateResult Text()
        {
            char prev = '\0';
            while (!EndOfFile && !ParserHelpers.IsWhitespaceOrNewLine(CurrentCharacter) && !AtSymbol())
            {
                prev = CurrentCharacter;
                TakeCurrent();
            }

            if (CurrentCharacter == '@')
            {
                char next = Peek();
                if (ParserHelpers.IsLetterOrDecimalDigit(prev) && ParserHelpers.IsLetterOrDecimalDigit(next))
                {
                    TakeCurrent(); // Take the "@"
                    return Stay(); // Stay in the Text state
                }
            }

            // Output the Text token and return to the Data state to tokenize the next character (if there is one)
            return Transition(EndSymbol(HtmlSymbolType.Text), Data);
        }

        private HtmlSymbol Symbol()
        {
            Debug.Assert(AtSymbol());
            char sym = CurrentCharacter;
            TakeCurrent();
            switch (sym)
            {
                case '<':
                    return EndSymbol(HtmlSymbolType.OpenAngle);
                case '!':
                    return EndSymbol(HtmlSymbolType.Bang);
                case '/':
                    return EndSymbol(HtmlSymbolType.Solidus);
                case '?':
                    return EndSymbol(HtmlSymbolType.QuestionMark);
                case '[':
                    return EndSymbol(HtmlSymbolType.LeftBracket);
                case '>':
                    return EndSymbol(HtmlSymbolType.CloseAngle);
                case ']':
                    return EndSymbol(HtmlSymbolType.RightBracket);
                case '=':
                    return EndSymbol(HtmlSymbolType.Equals);
                case '"':
                    return EndSymbol(HtmlSymbolType.DoubleQuote);
                case '\'':
                    return EndSymbol(HtmlSymbolType.SingleQuote);
                case '-':
                    Debug.Assert(CurrentCharacter == '-');
                    TakeCurrent();
                    return EndSymbol(HtmlSymbolType.DoubleHyphen);
                default:
                    Debug.Fail("Unexpected symbol!");
                    return EndSymbol(HtmlSymbolType.Unknown);
            }
        }

        private HtmlSymbol Whitespace()
        {
            while (ParserHelpers.IsWhitespace(CurrentCharacter))
            {
                TakeCurrent();
            }
            return EndSymbol(HtmlSymbolType.WhiteSpace);
        }

        private HtmlSymbol Newline()
        {
            Debug.Assert(ParserHelpers.IsNewLine(CurrentCharacter));
            // CSharp Spec §2.3.1
            bool checkTwoCharNewline = CurrentCharacter == '\r';
            TakeCurrent();
            if (checkTwoCharNewline && CurrentCharacter == '\n')
            {
                TakeCurrent();
            }
            return EndSymbol(HtmlSymbolType.NewLine);
        }

        private bool AtSymbol()
        {
            return CurrentCharacter == '<' ||
                   CurrentCharacter == '<' ||
                   CurrentCharacter == '!' ||
                   CurrentCharacter == '/' ||
                   CurrentCharacter == '?' ||
                   CurrentCharacter == '[' ||
                   CurrentCharacter == '>' ||
                   CurrentCharacter == ']' ||
                   CurrentCharacter == '=' ||
                   CurrentCharacter == '"' ||
                   CurrentCharacter == '\'' ||
                   CurrentCharacter == '@' ||
                   (CurrentCharacter == '-' && Peek() == '-');
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/ITokenizer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    public interface ITokenizer
    {
        ISymbol NextSymbol();
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/CSharpKeyword.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Tokenizer.Symbols
{
    public enum CSharpKeyword
    {
        Abstract,
        Byte,
        Class,
        Delegate,
        Event,
        Fixed,
        If,
        Internal,
        New,
        Override,
        Readonly,
        Short,
        Struct,
        Try,
        Unsafe,
        Volatile,
        As,
        Do,
        Is,
        Params,
        Ref,
        Switch,
        Ushort,
        While,
        Case,
        Const,
        Explicit,
        Float,
        Null,
        Sizeof,
        Typeof,
        Implicit,
        Private,
        This,
        Using,
        Extern,
        Return,
        Stackalloc,
        Uint,
        Base,
        Catch,
        Continue,
        Double,
        For,
        In,
        Lock,
        Object,
        Protected,
        Static,
        False,
        Public,
        Sbyte,
        Throw,
        Virtual,
        Decimal,
        Else,
        Operator,
        String,
        Ulong,
        Bool,
        Char,
        Default,
        Foreach,
        Long,
        Void,
        Enum,
        Finally,
        Int,
        Out,
        Sealed,
        True,
        Goto,
        Unchecked,
        Interface,
        Break,
        Checked,
        Namespace
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/CSharpSymbol.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor.Tokenizer.Symbols
{
    public class CSharpSymbol : SymbolBase<CSharpSymbolType>
    {
        // Helper constructor
        public CSharpSymbol(int offset, int line, int column, string content, CSharpSymbolType type)
            : this(new SourceLocation(offset, line, column), content, type, Enumerable.Empty<RazorError>())
        {
        }

        public CSharpSymbol(SourceLocation start, string content, CSharpSymbolType type)
            : this(start, content, type, Enumerable.Empty<RazorError>())
        {
        }

        public CSharpSymbol(int offset, int line, int column, string content, CSharpSymbolType type, IEnumerable<RazorError> errors)
            : base(new SourceLocation(offset, line, column), content, type, errors)
        {
        }

        public CSharpSymbol(SourceLocation start, string content, CSharpSymbolType type, IEnumerable<RazorError> errors)
            : base(start, content, type, errors)
        {
        }

        public bool? EscapedIdentifier { get; set; }
        public CSharpKeyword? Keyword { get; set; }

        public override bool Equals(object obj)
        {
            CSharpSymbol other = obj as CSharpSymbol;
            return base.Equals(obj) && other.Keyword == Keyword;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode() ^ Keyword.GetHashCode();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/CSharpSymbolType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Tokenizer.Symbols
{
    public enum CSharpSymbolType
    {
        Unknown,
        Identifier,
        Keyword,
        IntegerLiteral,
        NewLine,
        WhiteSpace,
        Comment,
        RealLiteral,
        CharacterLiteral,
        StringLiteral,

        // Operators
        Arrow,
        Minus,
        Decrement,
        MinusAssign,
        NotEqual,
        Not,
        Modulo,
        ModuloAssign,
        AndAssign,
        And,
        DoubleAnd,
        LeftParenthesis,
        RightParenthesis,
        Star,
        MultiplyAssign,
        Comma,
        Dot,
        Slash,
        DivideAssign,
        DoubleColon,
        Colon,
        Semicolon,
        QuestionMark,
        NullCoalesce,
        RightBracket,
        LeftBracket,
        XorAssign,
        Xor,
        LeftBrace,
        OrAssign,
        DoubleOr,
        Or,
        RightBrace,
        Tilde,
        Plus,
        PlusAssign,
        Increment,
        LessThan,
        LessThanEqual,
        LeftShift,
        LeftShiftAssign,
        Assign,
        Equals,
        GreaterThan,
        GreaterThanEqual,
        RightShift,
        RightShiftAssign,
        Hash,
        Transition,

        // Razor specific
        RazorCommentTransition,
        RazorCommentStar,
        RazorComment
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/HtmlSymbol.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor.Tokenizer.Symbols
{
    public class HtmlSymbol : SymbolBase<HtmlSymbolType>
    {
        // Helper constructor
        public HtmlSymbol(int offset, int line, int column, string content, HtmlSymbolType type)
            : this(new SourceLocation(offset, line, column), content, type, Enumerable.Empty<RazorError>())
        {
        }

        public HtmlSymbol(SourceLocation start, string content, HtmlSymbolType type)
            : base(start, content, type, Enumerable.Empty<RazorError>())
        {
        }

        public HtmlSymbol(int offset, int line, int column, string content, HtmlSymbolType type, IEnumerable<RazorError> errors)
            : base(new SourceLocation(offset, line, column), content, type, errors)
        {
        }

        public HtmlSymbol(SourceLocation start, string content, HtmlSymbolType type, IEnumerable<RazorError> errors)
            : base(start, content, type, errors)
        {
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/HtmlSymbolType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Tokenizer.Symbols
{
    public enum HtmlSymbolType
    {
        Unknown,
        Text, // Text which isn't one of the below
        WhiteSpace, // Non-newline Whitespace
        NewLine, // Newline
        OpenAngle, // <
        Bang, // !
        Solidus, // /
        QuestionMark, // ?
        DoubleHyphen, // --
        LeftBracket, // [
        CloseAngle, // >
        RightBracket, // ]
        Equals, // =
        DoubleQuote, // "
        SingleQuote, // '
        Transition, // @
        Colon,
        RazorComment,
        RazorCommentStar,
        RazorCommentTransition
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/ISymbol.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;

namespace System.Web.Razor.Tokenizer.Symbols
{
    public interface ISymbol
    {
        SourceLocation Start { get; }
        string Content { get; }

        void OffsetStart(SourceLocation documentStart);
        void ChangeStart(SourceLocation newStart);
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/KnownSymbolType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Tokenizer.Symbols
{
    public enum KnownSymbolType
    {
        WhiteSpace,
        NewLine,
        Identifier,
        Keyword,
        Transition,
        Unknown,
        CommentStart,
        CommentStar,
        CommentBody
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/SymbolBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Tokenizer.Symbols
{
    public abstract class SymbolBase<TType> : ISymbol
    {
        protected SymbolBase(SourceLocation start, string content, TType type, IEnumerable<RazorError> errors)
        {
            if (content == null)
            {
                throw new ArgumentNullException("content");
            }
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            Start = start;
            Content = content;
            Type = type;
            Errors = errors;
        }

        public SourceLocation Start { get; private set; }
        public string Content { get; private set; }
        public IEnumerable<RazorError> Errors { get; private set; }

        [SuppressMessage("Microsoft.Naming", "CA1721:PropertyNamesShouldNotMatchGetMethods", Justification = "This is the most appropriate name for this property and conflicts are unlikely")]
        public TType Type { get; private set; }

        public override bool Equals(object obj)
        {
            SymbolBase<TType> other = obj as SymbolBase<TType>;
            return other != null &&
                   Start.Equals(other.Start) &&
                   String.Equals(Content, other.Content, StringComparison.Ordinal) &&
                   Type.Equals(other.Type);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Start)
                .Add(Content)
                .Add(Type)
                .CombinedHash;
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.InvariantCulture, "{0} {1} - [{2}]", Start, Type, Content);
        }

        public void OffsetStart(SourceLocation documentStart)
        {
            Start = documentStart + Start;
        }

        public void ChangeStart(SourceLocation newStart)
        {
            Start = newStart;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/SymbolExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;

namespace System.Web.Razor.Tokenizer.Symbols
{
    public static class SymbolExtensions
    {
        public static LocationTagged<string> GetContent(this SpanBuilder span)
        {
            return GetContent(span, e => e);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Func<T> is the recommended type for generic delegates and requires this level of nesting")]
        public static LocationTagged<string> GetContent(this SpanBuilder span, Func<IEnumerable<ISymbol>, IEnumerable<ISymbol>> filter)
        {
            return GetContent(filter(span.Symbols), span.Start);
        }

        public static LocationTagged<string> GetContent(this IEnumerable<ISymbol> symbols, SourceLocation spanStart)
        {
            if (symbols.Any())
            {
                return new LocationTagged<string>(String.Concat(symbols.Select(s => s.Content)), spanStart + symbols.First().Start);
            }
            else
            {
                return new LocationTagged<string>(String.Empty, spanStart);
            }
        }

        public static LocationTagged<string> GetContent(this ISymbol symbol)
        {
            return new LocationTagged<string>(symbol.Content, symbol.Start);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/SymbolTypeSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// Centralized all the supressions for the CSharpSymbolType and VBSymbolType enum members here for clarity. They are
// not in the CodeAnalysisDictionary because they are special case exclusions

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Foreach", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Foreach", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "Readonly", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Readonly", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Sbyte", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Sbyte", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Sizeof", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Sizeof", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Stackalloc", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Stackalloc", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Typeof", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Typeof", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Uint", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Uint", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Ulong", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Ulong", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Ushort", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.CSharpKeyword.#Ushort", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Val", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.VBKeyword.#ByVal", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Sng", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.VBKeyword.#CSng", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "ReDim", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.VBKeyword.#ReDim", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "Re", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.VBKeyword.#ReDim", Justification = Justifications.SymbolTypeNames)]
[assembly: SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Str", Scope = "member", Target = "System.Web.Razor.Tokenizer.Symbols.VBKeyword.#CStr", Justification = Justifications.SymbolTypeNames)]

internal static partial class Justifications
{
    internal const string SymbolTypeNames = "Symbol Type Names are spelled according to the language keyword or token they represent";
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/VBKeyword.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Razor.Tokenizer.Symbols
{
    public enum VBKeyword
    {
        AddHandler,
        AndAlso,
        Byte,
        Catch,
        CDate,
        CInt,
        Const,
        CSng,

        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Lng", Justification = "This is a VB Keyword. Note: Excluded here because it is a specific case")]
        CULng,
        Declare,
        DirectCast,
        Else,
        Enum,
        Exit,
        Friend,
        GetXmlNamespace,
        Handles,
        In,
        Is,
        Like,
        Mod,
        MyBase,
        New,
        AddressOf,
        As,
        ByVal,
        CBool,

        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Dbl", Justification = "This is a VB Keyword. Note: Excluded here because it is a specific case")]
        CDbl,
        Class,
        Continue,
        CStr,
        CUShort,
        Default,
        Do,
        ElseIf,
        Erase,
        False,
        Function,
        Global,
        If,
        Inherits,
        IsNot,
        Long,
        Module,
        MyClass,
        Next,
        Alias,
        Boolean,
        Call,
        CByte,
        CDec,

        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Lng", Justification = "This is a VB Keyword. Note: Excluded here because it is a specific case")]
        CLng,
        CSByte,
        CType,
        Date,
        Delegate,
        Double,
        End,
        Error,
        Finally,
        Get,
        GoSub,
        Implements,
        Integer,
        Let,
        Loop,
        MustInherit,
        Namespace,
        Not,
        And,
        ByRef,
        Case,
        CChar,
        Char,
        CObj,
        CShort,
        CUInt,
        Decimal,
        Dim,
        Each,
        EndIf,
        Event,
        For,
        GetType,
        GoTo,
        Imports,
        Interface,
        Lib,
        Me,
        MustOverride,
        Narrowing,
        Nothing,
        NotInheritable,
        On,
        Or,
        Overrides,
        Property,
        ReadOnly,
        Resume,
        Set,
        Single,
        String,
        Then,
        Try,
        ULong,
        Wend,
        With,
        NotOverridable,
        Operator,
        OrElse,
        ParamArray,
        Protected,
        ReDim,
        Return,
        Shadows,
        Static,
        Structure,
        Throw,
        TryCast,
        UShort,
        When,
        WithEvents,
        Object,
        Option,
        Overloads,
        Partial,
        Public,
        Rem,
        SByte,
        Shared,
        Step,
        Sub,
        To,
        TypeOf,
        Using,
        While,
        WriteOnly,
        Of,
        Optional,
        Overridable,
        Private,
        RaiseEvent,
        RemoveHandler,
        Select,
        Short,
        Stop,
        SyncLock,
        True,
        UInteger,
        Variant,
        Widening,
        Xor
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/VBSymbol.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;

namespace System.Web.Razor.Tokenizer.Symbols
{
    public class VBSymbol : SymbolBase<VBSymbolType>
    {
        // Helper constructor
        private static Dictionary<VBSymbolType, string> _symbolSamples = new Dictionary<VBSymbolType, string>()
        {
            { VBSymbolType.LineContinuation, "_" },
            { VBSymbolType.LeftParenthesis, "(" },
            { VBSymbolType.RightParenthesis, ")" },
            { VBSymbolType.LeftBracket, "[" },
            { VBSymbolType.RightBracket, "]" },
            { VBSymbolType.LeftBrace, "{" },
            { VBSymbolType.RightBrace, "}" },
            { VBSymbolType.Bang, "!" },
            { VBSymbolType.Hash, "#" },
            { VBSymbolType.Comma, "," },
            { VBSymbolType.Dot, "." },
            { VBSymbolType.Colon, ":" },
            { VBSymbolType.QuestionMark, "?" },
            { VBSymbolType.Concatenation, "&" },
            { VBSymbolType.Multiply, "*" },
            { VBSymbolType.Add, "+" },
            { VBSymbolType.Subtract, "-" },
            { VBSymbolType.Divide, "/" },
            { VBSymbolType.IntegerDivide, "\\" },
            { VBSymbolType.Exponentiation, "^" },
            { VBSymbolType.Equal, "=" },
            { VBSymbolType.LessThan, "<" },
            { VBSymbolType.GreaterThan, ">" },
            { VBSymbolType.Dollar, "$" },
            { VBSymbolType.Transition, "@" },
            { VBSymbolType.RazorCommentTransition, "@" },
            { VBSymbolType.RazorCommentStar, "*" }
        };

        public VBSymbol(int offset, int line, int column, string content, VBSymbolType type)
            : this(new SourceLocation(offset, line, column), content, type, Enumerable.Empty<RazorError>())
        {
        }

        public VBSymbol(SourceLocation start, string content, VBSymbolType type)
            : this(start, content, type, Enumerable.Empty<RazorError>())
        {
        }

        public VBSymbol(int offset, int line, int column, string content, VBSymbolType type, IEnumerable<RazorError> errors)
            : base(new SourceLocation(offset, line, column), content, type, errors)
        {
        }

        public VBSymbol(SourceLocation start, string content, VBSymbolType type, IEnumerable<RazorError> errors)
            : base(start, content, type, errors)
        {
        }

        public VBKeyword? Keyword { get; set; }

        public override bool Equals(object obj)
        {
            VBSymbol other = obj as VBSymbol;
            return base.Equals(obj) && other.Keyword == Keyword;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode() ^ Keyword.GetHashCode();
        }

        public static string GetSample(VBSymbolType type)
        {
            string sample;
            if (!_symbolSamples.TryGetValue(type, out sample))
            {
                switch (type)
                {
                    case VBSymbolType.WhiteSpace:
                        return RazorResources.VBSymbol_WhiteSpace;
                    case VBSymbolType.NewLine:
                        return RazorResources.VBSymbol_NewLine;
                    case VBSymbolType.Comment:
                        return RazorResources.VBSymbol_Comment;
                    case VBSymbolType.Identifier:
                        return RazorResources.VBSymbol_Identifier;
                    case VBSymbolType.Keyword:
                        return RazorResources.VBSymbol_Keyword;
                    case VBSymbolType.IntegerLiteral:
                        return RazorResources.VBSymbol_IntegerLiteral;
                    case VBSymbolType.FloatingPointLiteral:
                        return RazorResources.VBSymbol_FloatingPointLiteral;
                    case VBSymbolType.StringLiteral:
                        return RazorResources.VBSymbol_StringLiteral;
                    case VBSymbolType.CharacterLiteral:
                        return RazorResources.VBSymbol_CharacterLiteral;
                    case VBSymbolType.DateLiteral:
                        return RazorResources.VBSymbol_DateLiteral;
                    case VBSymbolType.RazorComment:
                        return RazorResources.VBSymbol_RazorComment;
                    default:
                        return RazorResources.Symbol_Unknown;
                }
            }
            return sample;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Symbols/VBSymbolType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Tokenizer.Symbols
{
    public enum VBSymbolType
    {
        Unknown,
        WhiteSpace,
        NewLine,
        LineContinuation,
        Comment,
        Identifier,
        Keyword,
        IntegerLiteral,
        FloatingPointLiteral,
        StringLiteral,
        CharacterLiteral,
        DateLiteral,
        LeftParenthesis,
        RightBrace,
        LeftBrace,
        RightParenthesis,
        Hash,
        Bang,
        Comma,
        Dot,
        Colon,
        Concatenation,
        QuestionMark,
        Subtract,
        Multiply,
        Add,
        Divide,
        IntegerDivide,
        Exponentiation,
        LessThan,
        GreaterThan,
        Equal,
        RightBracket,
        LeftBracket,
        Dollar,
        Transition,

        RazorCommentTransition,
        RazorCommentStar,
        RazorComment
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/Tokenizer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    public abstract partial class Tokenizer<TSymbol, TSymbolType> : StateMachine<TSymbol>, ITokenizer
        where TSymbol : SymbolBase<TSymbolType>
    {
        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "TextDocumentReader does not require disposal")]
        protected Tokenizer(ITextDocument source)
        {
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }
            Source = new TextDocumentReader(source);
            Buffer = new StringBuilder();
            CurrentErrors = new List<RazorError>();
            StartSymbol();
        }

        public TextDocumentReader Source { get; private set; }

        protected StringBuilder Buffer { get; private set; }

        protected bool EndOfFile
        {
            get { return Source.Peek() == -1; }
        }

        protected IList<RazorError> CurrentErrors { get; private set; }

        public abstract TSymbolType RazorCommentStarType { get; }
        public abstract TSymbolType RazorCommentType { get; }
        public abstract TSymbolType RazorCommentTransitionType { get; }

        protected bool HaveContent
        {
            get { return Buffer.Length > 0; }
        }

        protected char CurrentCharacter
        {
            get
            {
                int peek = Source.Peek();
                return peek == -1 ? '\0' : (char)peek;
            }
        }

        protected SourceLocation CurrentLocation
        {
            get { return Source.Location; }
        }

        protected SourceLocation CurrentStart { get; private set; }

        public virtual TSymbol NextSymbol()
        {
            // Post-Condition: Buffer should be empty at the start of Next()
            Debug.Assert(Buffer.Length == 0);
            StartSymbol();

            if (EndOfFile)
            {
                return null;
            }
            TSymbol sym = Turn();

            // Post-Condition: Buffer should be empty at the end of Next()
            Debug.Assert(Buffer.Length == 0);

            return sym;
        }

        public void Reset()
        {
            CurrentState = StartState;
        }

        protected abstract TSymbol CreateSymbol(SourceLocation start, string content, TSymbolType type, IEnumerable<RazorError> errors);

        protected TSymbol Single(TSymbolType type)
        {
            TakeCurrent();
            return EndSymbol(type);
        }

        protected bool TakeString(string input, bool caseSensitive)
        {
            int position = 0;
            Func<char, char> charFilter = c => c;
            if (caseSensitive)
            {
                charFilter = Char.ToLower;
            }
            while (!EndOfFile && position < input.Length && charFilter(CurrentCharacter) == charFilter(input[position++]))
            {
                TakeCurrent();
            }
            return position == input.Length;
        }

        protected void StartSymbol()
        {
            Buffer.Clear();
            CurrentStart = CurrentLocation;
            CurrentErrors.Clear();
        }

        protected TSymbol EndSymbol(TSymbolType type)
        {
            return EndSymbol(CurrentStart, type);
        }

        protected TSymbol EndSymbol(SourceLocation start, TSymbolType type)
        {
            TSymbol sym = null;
            if (HaveContent)
            {
                sym = CreateSymbol(start, Buffer.ToString(), type, CurrentErrors.ToArray());
            }
            StartSymbol();
            return sym;
        }

        protected void ResumeSymbol(TSymbol previous)
        {
            // Verify the symbol can be resumed
            if (previous.Start.AbsoluteIndex + previous.Content.Length != CurrentStart.AbsoluteIndex)
            {
                throw new InvalidOperationException(RazorResources.Tokenizer_CannotResumeSymbolUnlessIsPrevious);
            }

            // Reset the start point
            CurrentStart = previous.Start;

            // Capture the current buffer content
            string newContent = Buffer.ToString();

            // Clear the buffer, then put the old content back and add the new content to the end
            Buffer.Clear();
            Buffer.Append(previous.Content);
            Buffer.Append(newContent);
        }

        protected bool TakeUntil(Func<char, bool> predicate)
        {
            // Take all the characters up to the end character
            while (!EndOfFile && !predicate(CurrentCharacter))
            {
                TakeCurrent();
            }

            // Why did we end?
            return !EndOfFile;
        }

        protected Func<char, bool> CharOrWhiteSpace(char character)
        {
            return c => c == character || ParserHelpers.IsWhitespace(c) || ParserHelpers.IsNewLine(c);
        }

        protected void TakeCurrent()
        {
            if (EndOfFile)
            {
                return;
            } // No-op
            Buffer.Append(CurrentCharacter);
            MoveNext();
        }

        protected void MoveNext()
        {
#if DEBUG
            _read.Append(CurrentCharacter);
#endif
            Source.Read();
        }

        protected bool TakeAll(string expected, bool caseSensitive)
        {
            return Lookahead(expected, takeIfMatch: true, caseSensitive: caseSensitive);
        }

        protected bool At(string expected, bool caseSensitive)
        {
            return Lookahead(expected, takeIfMatch: false, caseSensitive: caseSensitive);
        }

        protected char Peek()
        {
            using (LookaheadToken lookahead = Source.BeginLookahead())
            {
                MoveNext();
                return CurrentCharacter;
            }
        }

        protected StateResult AfterRazorCommentTransition()
        {
            if (CurrentCharacter != '*')
            {
                // We've been moved since last time we were asked for a symbol... reset the state
                return Transition(StartState);
            }
            AssertCurrent('*');
            TakeCurrent();
            return Transition(EndSymbol(RazorCommentStarType), RazorCommentBody);
        }

        protected StateResult RazorCommentBody()
        {
            TakeUntil(c => c == '*');
            if (CurrentCharacter == '*')
            {
                char star = CurrentCharacter;
                SourceLocation start = CurrentLocation;
                MoveNext();
                if (!EndOfFile && CurrentCharacter == '@')
                {
                    State next = () =>
                    {
                        Buffer.Append(star);
                        return Transition(EndSymbol(start, RazorCommentStarType), () =>
                        {
                            if (CurrentCharacter != '@')
                            {
                                // We've been moved since last time we were asked for a symbol... reset the state
                                return Transition(StartState);
                            }
                            TakeCurrent();
                            return Transition(EndSymbol(RazorCommentTransitionType), StartState);
                        });
                    };

                    if (HaveContent)
                    {
                        return Transition(EndSymbol(RazorCommentType), next);
                    }
                    else
                    {
                        return Transition(next);
                    }
                }
                else
                {
                    Buffer.Append(star);
                    return Stay();
                }
            }
            return Transition(EndSymbol(RazorCommentType), StartState);
        }

        private bool Lookahead(string expected, bool takeIfMatch, bool caseSensitive)
        {
            Func<char, char> filter = c => c;
            if (!caseSensitive)
            {
                filter = Char.ToLowerInvariant;
            }

            if (expected.Length == 0 || filter(CurrentCharacter) != filter(expected[0]))
            {
                return false;
            }

            // Capture the current buffer content in case we have to backtrack
            string oldBuffer = null;
            if (takeIfMatch)
            {
                Buffer.ToString();
            }

            using (LookaheadToken lookahead = Source.BeginLookahead())
            {
                for (int i = 0; i < expected.Length; i++)
                {
                    if (filter(CurrentCharacter) != filter(expected[i]))
                    {
                        if (takeIfMatch)
                        {
                            // Clear the buffer and put the old buffer text back
                            Buffer.Clear();
                            Buffer.Append(oldBuffer);
                        }
                        // Return without accepting lookahead (thus rejecting it)
                        return false;
                    }
                    if (takeIfMatch)
                    {
                        TakeCurrent();
                    }
                    else
                    {
                        MoveNext();
                    }
                }
                if (takeIfMatch)
                {
                    lookahead.Accept();
                }
            }
            return true;
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This only occurs in Release builds, where this method is empty by design")]
        [Conditional("DEBUG")]
        internal void AssertCurrent(char current)
        {
            Debug.Assert(CurrentCharacter == current, "CurrentCharacter Assumption violated", "Assumed that the current character would be {0}, but it is actually {1}", current, CurrentCharacter);
        }

        ISymbol ITokenizer.NextSymbol()
        {
            return (ISymbol)NextSymbol();
        }
    }

#if DEBUG
    [DebuggerDisplay("{DebugDisplay}")]
    public partial class Tokenizer<TSymbol, TSymbolType>
    {
        private StringBuilder _read = new StringBuilder();

        public string DebugDisplay
        {
            get { return String.Format(CultureInfo.InvariantCulture, "[{0}] [{1}] [{2}]", _read.ToString(), CurrentCharacter, Remaining); }
        }

        public string Remaining
        {
            get
            {
                string remaining = Source.ReadToEnd();
                Source.Seek(-remaining.Length);
                return remaining;
            }
        }
    }
#endif
}


================================================
FILE: src/System.Web.Razor/Tokenizer/TokenizerView.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    [SuppressMessage("Microsoft.Design", "CA1005:AvoidExcessiveParametersOnGenericTypes", Justification = "All generic parameters are required")]
    public class TokenizerView<TTokenizer, TSymbol, TSymbolType>
        where TTokenizer : Tokenizer<TSymbol, TSymbolType>
        where TSymbol : SymbolBase<TSymbolType>
    {
        public TokenizerView(TTokenizer tokenizer)
        {
            Tokenizer = tokenizer;
        }

        public TTokenizer Tokenizer { get; private set; }
        public bool EndOfFile { get; private set; }
        public TSymbol Current { get; private set; }

        public ITextDocument Source
        {
            get { return Tokenizer.Source; }
        }

        public bool Next()
        {
            Current = Tokenizer.NextSymbol();
            EndOfFile = (Current == null);
            return !EndOfFile;
        }

        public void PutBack(TSymbol symbol)
        {
            Debug.Assert(Source.Position == symbol.Start.AbsoluteIndex + symbol.Content.Length);
            if (Source.Position != symbol.Start.AbsoluteIndex + symbol.Content.Length)
            {
                // We've already passed this symbol
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  RazorResources.TokenizerView_CannotPutBack,
                                  symbol.Start.AbsoluteIndex + symbol.Content.Length,
                                  Source.Position));
            }
            Source.Position -= symbol.Content.Length;
            Current = null;
            EndOfFile = Source.Position >= Source.Length;
            Tokenizer.Reset();
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/VBHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Tokenizer
{
    public static class VBHelpers
    {
        public static bool IsSingleQuote(char character)
        {
            return character == '\'' || character == '‘' || character == '’';
        }

        public static bool IsDoubleQuote(char character)
        {
            return character == '"' || character == '“' || character == '”';
        }

        public static bool IsOctalDigit(char character)
        {
            return character >= '0' && character <= '7';
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/VBKeywordDetector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    internal static class VBKeywordDetector
    {
        private static readonly Dictionary<string, VBKeyword> _keywords = new Dictionary<string, VBKeyword>(StringComparer.OrdinalIgnoreCase)
        {
            { "addhandler", VBKeyword.AddHandler },
            { "andalso", VBKeyword.AndAlso },
            { "byte", VBKeyword.Byte },
            { "catch", VBKeyword.Catch },
            { "cdate", VBKeyword.CDate },
            { "cint", VBKeyword.CInt },
            { "const", VBKeyword.Const },
            { "csng", VBKeyword.CSng },
            { "culng", VBKeyword.CULng },
            { "declare", VBKeyword.Declare },
            { "directcast", VBKeyword.DirectCast },
            { "else", VBKeyword.Else },
            { "enum", VBKeyword.Enum },
            { "exit", VBKeyword.Exit },
            { "friend", VBKeyword.Friend },
            { "getxmlnamespace", VBKeyword.GetXmlNamespace },
            { "handles", VBKeyword.Handles },
            { "in", VBKeyword.In },
            { "is", VBKeyword.Is },
            { "like", VBKeyword.Like },
            { "mod", VBKeyword.Mod },
            { "mybase", VBKeyword.MyBase },
            { "new", VBKeyword.New },
            { "addressof", VBKeyword.AddressOf },
            { "as", VBKeyword.As },
            { "byval", VBKeyword.ByVal },
            { "cbool", VBKeyword.CBool },
            { "cdbl", VBKeyword.CDbl },
            { "class", VBKeyword.Class },
            { "continue", VBKeyword.Continue },
            { "cstr", VBKeyword.CStr },
            { "cushort", VBKeyword.CUShort },
            { "default", VBKeyword.Default },
            { "do", VBKeyword.Do },
            { "elseif", VBKeyword.ElseIf },
            { "erase", VBKeyword.Erase },
            { "false", VBKeyword.False },
            { "function", VBKeyword.Function },
            { "global", VBKeyword.Global },
            { "if", VBKeyword.If },
            { "inherits", VBKeyword.Inherits },
            { "isnot", VBKeyword.IsNot },
            { "long", VBKeyword.Long },
            { "module", VBKeyword.Module },
            { "myclass", VBKeyword.MyClass },
            { "next", VBKeyword.Next },
            { "alias", VBKeyword.Alias },
            { "boolean", VBKeyword.Boolean },
            { "call", VBKeyword.Call },
            { "cbyte", VBKeyword.CByte },
            { "cdec", VBKeyword.CDec },
            { "clng", VBKeyword.CLng },
            { "csbyte", VBKeyword.CSByte },
            { "ctype", VBKeyword.CType },
            { "date", VBKeyword.Date },
            { "delegate", VBKeyword.Delegate },
            { "double", VBKeyword.Double },
            { "end", VBKeyword.End },
            { "error", VBKeyword.Error },
            { "finally", VBKeyword.Finally },
            { "get", VBKeyword.Get },
            { "gosub", VBKeyword.GoSub },
            { "implements", VBKeyword.Implements },
            { "integer", VBKeyword.Integer },
            { "let", VBKeyword.Let },
            { "loop", VBKeyword.Loop },
            { "mustinherit", VBKeyword.MustInherit },
            { "namespace", VBKeyword.Namespace },
            { "not", VBKeyword.Not },
            { "and", VBKeyword.And },
            { "byref", VBKeyword.ByRef },
            { "case", VBKeyword.Case },
            { "cchar", VBKeyword.CChar },
            { "char", VBKeyword.Char },
            { "cobj", VBKeyword.CObj },
            { "cshort", VBKeyword.CShort },
            { "cuint", VBKeyword.CUInt },
            { "decimal", VBKeyword.Decimal },
            { "dim", VBKeyword.Dim },
            { "each", VBKeyword.Each },
            { "endif", VBKeyword.EndIf },
            { "event", VBKeyword.Event },
            { "for", VBKeyword.For },
            { "gettype", VBKeyword.GetType },
            { "goto", VBKeyword.GoTo },
            { "imports", VBKeyword.Imports },
            { "interface", VBKeyword.Interface },
            { "lib", VBKeyword.Lib },
            { "me", VBKeyword.Me },
            { "mustoverride", VBKeyword.MustOverride },
            { "narrowing", VBKeyword.Narrowing },
            { "nothing", VBKeyword.Nothing },
            { "notinheritable", VBKeyword.NotInheritable },
            { "on", VBKeyword.On },
            { "or", VBKeyword.Or },
            { "overrides", VBKeyword.Overrides },
            { "property", VBKeyword.Property },
            { "rem", VBKeyword.Rem },
            { "readonly", VBKeyword.ReadOnly },
            { "resume", VBKeyword.Resume },
            { "set", VBKeyword.Set },
            { "single", VBKeyword.Single },
            { "string", VBKeyword.String },
            { "then", VBKeyword.Then },
            { "try", VBKeyword.Try },
            { "ulong", VBKeyword.ULong },
            { "wend", VBKeyword.Wend },
            { "with", VBKeyword.With },
            { "notoverridable", VBKeyword.NotOverridable },
            { "operator", VBKeyword.Operator },
            { "orelse", VBKeyword.OrElse },
            { "paramarray", VBKeyword.ParamArray },
            { "protected", VBKeyword.Protected },
            { "redim", VBKeyword.ReDim },
            { "return", VBKeyword.Return },
            { "shadows", VBKeyword.Shadows },
            { "static", VBKeyword.Static },
            { "structure", VBKeyword.Structure },
            { "throw", VBKeyword.Throw },
            { "trycast", VBKeyword.TryCast },
            { "ushort", VBKeyword.UShort },
            { "when", VBKeyword.When },
            { "withevents", VBKeyword.WithEvents },
            { "object", VBKeyword.Object },
            { "option", VBKeyword.Option },
            { "overloads", VBKeyword.Overloads },
            { "partial", VBKeyword.Partial },
            { "public", VBKeyword.Public },
            { "sbyte", VBKeyword.SByte },
            { "shared", VBKeyword.Shared },
            { "step", VBKeyword.Step },
            { "sub", VBKeyword.Sub },
            { "to", VBKeyword.To },
            { "typeof", VBKeyword.TypeOf },
            { "using", VBKeyword.Using },
            { "while", VBKeyword.While },
            { "writeonly", VBKeyword.WriteOnly },
            { "of", VBKeyword.Of },
            { "optional", VBKeyword.Optional },
            { "overridable", VBKeyword.Overridable },
            { "private", VBKeyword.Private },
            { "raiseevent", VBKeyword.RaiseEvent },
            { "removehandler", VBKeyword.RemoveHandler },
            { "select", VBKeyword.Select },
            { "short", VBKeyword.Short },
            { "stop", VBKeyword.Stop },
            { "synclock", VBKeyword.SyncLock },
            { "true", VBKeyword.True },
            { "uinteger", VBKeyword.UInteger },
            { "variant", VBKeyword.Variant },
            { "widening", VBKeyword.Widening },
            { "xor", VBKeyword.Xor }
        };

        public static VBKeyword? GetKeyword(string id)
        {
            VBKeyword type;
            if (!_keywords.TryGetValue(id, out type))
            {
                return null;
            }
            return type;
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/VBTokenizer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Tokenizer
{
    public class VBTokenizer : Tokenizer<VBSymbol, VBSymbolType>
    {
        private static Dictionary<char, VBSymbolType> _operatorTable = new Dictionary<char, VBSymbolType>()
        {
            { '_', VBSymbolType.LineContinuation },
            { '(', VBSymbolType.LeftParenthesis },
            { ')', VBSymbolType.RightParenthesis },
            { '[', VBSymbolType.LeftBracket },
            { ']', VBSymbolType.RightBracket },
            { '{', VBSymbolType.LeftBrace },
            { '}', VBSymbolType.RightBrace },
            { '!', VBSymbolType.Bang },
            { '#', VBSymbolType.Hash },
            { ',', VBSymbolType.Comma },
            { '.', VBSymbolType.Dot },
            { ':', VBSymbolType.Colon },
            { '?', VBSymbolType.QuestionMark },
            { '&', VBSymbolType.Concatenation },
            { '*', VBSymbolType.Multiply },
            { '+', VBSymbolType.Add },
            { '-', VBSymbolType.Subtract },
            { '/', VBSymbolType.Divide },
            { '\\', VBSymbolType.IntegerDivide },
            { '^', VBSymbolType.Exponentiation },
            { '=', VBSymbolType.Equal },
            { '<', VBSymbolType.LessThan },
            { '>', VBSymbolType.GreaterThan },
            { '$', VBSymbolType.Dollar },
        };

        public VBTokenizer(ITextDocument source)
            : base(source)
        {
            CurrentState = Data;
        }

        protected override State StartState
        {
            get { return Data; }
        }

        public override VBSymbolType RazorCommentType
        {
            get { return VBSymbolType.RazorComment; }
        }

        public override VBSymbolType RazorCommentTransitionType
        {
            get { return VBSymbolType.RazorCommentTransition; }
        }

        public override VBSymbolType RazorCommentStarType
        {
            get { return VBSymbolType.RazorCommentStar; }
        }

        internal static IEnumerable<VBSymbol> Tokenize(string content)
        {
            using (SeekableTextReader reader = new SeekableTextReader(content))
            {
                VBTokenizer tok = new VBTokenizer(reader);
                VBSymbol sym;
                while ((sym = tok.NextSymbol()) != null)
                {
                    yield return sym;
                }
            }
        }

        protected override VBSymbol CreateSymbol(SourceLocation start, string content, VBSymbolType type, IEnumerable<RazorError> errors)
        {
            return new VBSymbol(start, content, type, errors);
        }

        private StateResult Data()
        {
            // We are accepting more characters and whitespace/newlines then the VB Spec defines, to simplify things
            // Since the code must still be compiled by a VB compiler, this will not cause adverse effects.
            if (ParserHelpers.IsNewLine(CurrentCharacter))
            {
                // VB Spec §2.1.1
                bool checkTwoCharNewline = CurrentCharacter == '\r';
                TakeCurrent();
                if (checkTwoCharNewline && CurrentCharacter == '\n')
                {
                    TakeCurrent();
                }
                return Stay(EndSymbol(VBSymbolType.NewLine));
            }
            else if (ParserHelpers.IsWhitespace(CurrentCharacter))
            {
                // CSharp Spec §2.1.3
                TakeUntil(c => !ParserHelpers.IsWhitespace(c));
                return Stay(EndSymbol(VBSymbolType.WhiteSpace));
            }
            else if (VBHelpers.IsSingleQuote(CurrentCharacter))
            {
                TakeCurrent();
                return CommentBody();
            }
            else if (IsIdentifierStart())
            {
                return Identifier();
            }
            else if (Char.IsDigit(CurrentCharacter))
            {
                return DecimalLiteral();
            }
            else if (CurrentCharacter == '&')
            {
                char next = Char.ToLower(Peek(), CultureInfo.InvariantCulture);
                if (next == 'h')
                {
                    return HexLiteral();
                }
                else if (next == 'o')
                {
                    return OctLiteral();
                }
            }
            else if (CurrentCharacter == '.' && Char.IsDigit(Peek()))
            {
                return FloatingPointLiteralEnd();
            }
            else if (VBHelpers.IsDoubleQuote(CurrentCharacter))
            {
                TakeCurrent();
                return Transition(QuotedLiteral);
            }
            else if (AtDateLiteral())
            {
                return DateLiteral();
            }
            else if (CurrentCharacter == '@')
            {
                TakeCurrent();
                if (CurrentCharacter == '*')
                {
                    return Transition(EndSymbol(VBSymbolType.RazorCommentTransition), AfterRazorCommentTransition);
                }
                else if (CurrentCharacter == '@')
                {
                    // Could be escaped comment transition
                    return Transition(EndSymbol(VBSymbolType.Transition), () =>
                    {
                        TakeCurrent();
                        return Transition(EndSymbol(VBSymbolType.Transition), Data);
                    });
                }
                else
                {
                    return Stay(EndSymbol(VBSymbolType.Transition));
                }
            }
            return Stay(EndSymbol(Operator()));
        }

        private StateResult DateLiteral()
        {
            AssertCurrent('#');
            TakeCurrent();
            TakeUntil(c => c == '#' || ParserHelpers.IsNewLine(c));
            if (CurrentCharacter == '#')
            {
                TakeCurrent();
            }
            return Stay(EndSymbol(VBSymbolType.DateLiteral));
        }

        private bool AtDateLiteral()
        {
            if (CurrentCharacter != '#')
            {
                return false;
            }
            int start = Source.Position;
            try
            {
                MoveNext();
                while (ParserHelpers.IsWhitespace(CurrentCharacter))
                {
                    MoveNext();
                }
                return Char.IsDigit(CurrentCharacter);
            }
            finally
            {
                Source.Position = start;
            }
        }

        private StateResult QuotedLiteral()
        {
            TakeUntil(c => VBHelpers.IsDoubleQuote(c) || ParserHelpers.IsNewLine(c));
            if (VBHelpers.IsDoubleQuote(CurrentCharacter))
            {
                TakeCurrent();
                if (VBHelpers.IsDoubleQuote(CurrentCharacter))
                {
                    // Escape sequence, remain in the string
                    TakeCurrent();
                    return Stay();
                }
            }

            VBSymbolType type = VBSymbolType.StringLiteral;
            if (Char.ToLowerInvariant(CurrentCharacter) == 'c')
            {
                TakeCurrent();
                type = VBSymbolType.CharacterLiteral;
            }
            return Transition(EndSymbol(type), Data);
        }

        private StateResult DecimalLiteral()
        {
            TakeUntil(c => !Char.IsDigit(c));
            char lower = Char.ToLowerInvariant(CurrentCharacter);
            if (IsFloatTypeSuffix(lower) || lower == '.' || lower == 'e')
            {
                return FloatingPointLiteralEnd();
            }
            else
            {
                TakeIntTypeSuffix();
                return Stay(EndSymbol(VBSymbolType.IntegerLiteral));
            }
        }

        private static bool IsFloatTypeSuffix(char chr)
        {
            chr = Char.ToLowerInvariant(chr);
            return chr == 'f' || chr == 'r' || chr == 'd';
        }

        private StateResult FloatingPointLiteralEnd()
        {
            if (CurrentCharacter == '.')
            {
                TakeCurrent();
                TakeUntil(c => !Char.IsDigit(c));
            }
            if (Char.ToLowerInvariant(CurrentCharacter) == 'e')
            {
                TakeCurrent();
                if (CurrentCharacter == '+' || CurrentCharacter == '-')
                {
                    TakeCurrent();
                }
                TakeUntil(c => !Char.IsDigit(c));
            }
            if (IsFloatTypeSuffix(CurrentCharacter))
            {
                TakeCurrent();
            }
            return Stay(EndSymbol(VBSymbolType.FloatingPointLiteral));
        }

        private StateResult HexLiteral()
        {
            AssertCurrent('&');
            TakeCurrent();
            Debug.Assert(Char.ToLowerInvariant(CurrentCharacter) == 'h');
            TakeCurrent();
            TakeUntil(c => !ParserHelpers.IsHexDigit(c));
            TakeIntTypeSuffix();
            return Stay(EndSymbol(VBSymbolType.IntegerLiteral));
        }

        private StateResult OctLiteral()
        {
            AssertCurrent('&');
            TakeCurrent();
            Debug.Assert(Char.ToLowerInvariant(CurrentCharacter) == 'o');
            TakeCurrent();
            TakeUntil(c => !VBHelpers.IsOctalDigit(c));
            TakeIntTypeSuffix();
            return Stay(EndSymbol(VBSymbolType.IntegerLiteral));
        }

        private VBSymbolType Operator()
        {
            char op = CurrentCharacter;
            TakeCurrent();
            VBSymbolType ret;
            if (_operatorTable.TryGetValue(op, out ret))
            {
                return ret;
            }
            return VBSymbolType.Unknown;
        }

        private void TakeIntTypeSuffix()
        {
            // Take the "U" in US, UI, UL
            if (Char.ToLowerInvariant(CurrentCharacter) == 'u')
            {
                TakeCurrent(); // Unsigned Prefix
            }

            // Take the S, I or L integer suffix
            if (IsIntegerSuffix(CurrentCharacter))
            {
                TakeCurrent();
            }
        }

        private static bool IsIntegerSuffix(char chr)
        {
            chr = Char.ToLowerInvariant(chr);
            return chr == 's' || chr == 'i' || chr == 'l';
        }

        private StateResult CommentBody()
        {
            TakeUntil(ParserHelpers.IsNewLine);
            return Stay(EndSymbol(VBSymbolType.Comment));
        }

        private StateResult Identifier()
        {
            bool isEscaped = false;
            if (CurrentCharacter == '[')
            {
                TakeCurrent();
                isEscaped = true;
            }
            TakeUntil(c => !ParserHelpers.IsIdentifierPart(c));

            // If we're escaped, take the ']'
            if (isEscaped)
            {
                if (CurrentCharacter == ']')
                {
                    TakeCurrent();
                }
            }

            // Check for Keywords and build the symbol
            VBKeyword? keyword = VBKeywordDetector.GetKeyword(Buffer.ToString());
            if (keyword == VBKeyword.Rem)
            {
                return CommentBody();
            }

            VBSymbol sym = new VBSymbol(CurrentStart, Buffer.ToString(), keyword == null ? VBSymbolType.Identifier : VBSymbolType.Keyword)
            {
                Keyword = keyword
            };

            StartSymbol();

            return Stay(sym);
        }

        private bool IsIdentifierStart()
        {
            if (CurrentCharacter == '_')
            {
                // VB Spec §2.2:
                //  If an identifier begins with an underscore, it must contain at least one other valid identifier character to disambiguate it from a line continuation.
                return ParserHelpers.IsIdentifierPart(Peek());
            }
            if (CurrentCharacter == '[')
            {
                return ParserHelpers.IsIdentifierPart(Peek());
            }
            return ParserHelpers.IsIdentifierStart(CurrentCharacter);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Tokenizer/XmlHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Tokenizer
{
    internal static class XmlHelpers
    {
        public static bool IsXmlNameStartChar(char chr)
        {
            // [4] NameStartChar    ::= ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | 
            //                          [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | 
            //                          [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
            // http://www.w3.org/TR/REC-xml/#NT-Name

            return Char.IsLetter(chr) ||
                   chr == ':' ||
                   chr == '_' ||
                   IsInRange(chr, 0xC0, 0xD6) ||
                   IsInRange(chr, 0xD8, 0xF6) ||
                   IsInRange(chr, 0xF8, 0x2FF) ||
                   IsInRange(chr, 0x370, 0x37D) ||
                   IsInRange(chr, 0x37F, 0x1FFF) ||
                   IsInRange(chr, 0x200C, 0x200D) ||
                   IsInRange(chr, 0x2070, 0x218F) ||
                   IsInRange(chr, 0x2C00, 0x2FEF) ||
                   IsInRange(chr, 0x3001, 0xD7FF) ||
                   IsInRange(chr, 0xF900, 0xFDCF) ||
                   IsInRange(chr, 0xFDF0, 0xFFFD) ||
                   IsInRange(chr, 0x10000, 0xEFFFF);
        }

        public static bool IsXmlNameChar(char chr)
        {
            // [4a] NameChar     ::= NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
            // http://www.w3.org/TR/REC-xml/#NT-Name
            return Char.IsDigit(chr) ||
                   IsXmlNameStartChar(chr) ||
                   chr == '-' ||
                   chr == '.' ||
                   chr == '·' || // (U+00B7 is middle dot: ·)
                   IsInRange(chr, 0x0300, 0x036F) ||
                   IsInRange(chr, 0x203F, 0x2040);
        }

        public static bool IsInRange(char chr, int low, int high)
        {
            return ((int)chr >= low) && ((int)chr <= high);
        }
    }
}


================================================
FILE: src/System.Web.Razor/Utils/CharUtils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Utils
{
    internal static class CharUtils
    {
        internal static bool IsNonNewLineWhitespace(char c)
        {
            return Char.IsWhiteSpace(c) && !IsNewLine(c);
        }

        internal static bool IsNewLine(char c)
        {
            return c == 0x000d // Carriage return
                   || c == 0x000a // Linefeed
                   || c == 0x2028 // Line separator
                   || c == 0x2029; // Paragraph separator
        }
    }
}


================================================
FILE: src/System.Web.Razor/Utils/DisposableAction.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Utils
{
    internal class DisposableAction : IDisposable
    {
        private Action _action;

        public DisposableAction(Action action)
        {
            if (action == null)
            {
                throw new ArgumentNullException("action");
            }
            _action = action;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            // If we were disposed by the finalizer it's because the user didn't use a "using" block, so don't do anything!
            if (disposing)
            {
                _action();
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Utils/EnumUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Razor.Utils
{
    internal static class EnumUtil
    {
        public static IEnumerable<T> Single<T>(T item)
        {
            yield return item;
        }

        public static IEnumerable<T> Prepend<T>(T item, IEnumerable<T> enumerable)
        {
            yield return item;
            foreach (T t in enumerable)
            {
                yield return t;
            }
        }
    }
}


================================================
FILE: src/System.Web.Razor/Utils/EnumeratorExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.Razor.Utils
{
    internal static class EnumeratorExtensions
    {
        public static IEnumerable<T> Flatten<T>(this IEnumerable<IEnumerable<T>> source)
        {
            return source.SelectMany(e => e);
        }
    }
}


================================================
FILE: src/System.Web.Razor/VBRazorCodeLanguage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using Microsoft.VisualBasic;

namespace System.Web.Razor
{
    /// <summary>
    /// Defines the Visual Basic Code Language for Razor
    /// </summary>
    public class VBRazorCodeLanguage : RazorCodeLanguage
    {
        private const string VBLanguageName = "vb";

        /// <summary>
        /// Returns the name of the language: "vb"
        /// </summary>
        public override string LanguageName
        {
            get { return VBLanguageName; }
        }

        /// <summary>
        /// Returns the type of the CodeDOM provider for this language
        /// </summary>
        public override Type CodeDomProviderType
        {
            get { return typeof(VBCodeProvider); }
        }

        /// <summary>
        /// Constructs a new instance of the code parser for this language
        /// </summary>
        public override ParserBase CreateCodeParser()
        {
            return new VBCodeParser();
        }

        /// <summary>
        /// Constructs a new instance of the code generator for this language with the specified settings
        /// </summary>
        public override RazorCodeGenerator CreateCodeGenerator(string className, string rootNamespaceName, string sourceFileName, RazorEngineHost host)
        {
            return new VBRazorCodeGenerator(className, rootNamespaceName, sourceFileName, host);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationPart.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web.Routing;
using System.Web.WebPages.ApplicationParts;
using System.Web.WebPages.Resources;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    public class ApplicationPart
    {
        private const string ModuleRootSyntax = "@/";
        private const string ResourceVirtualPathRoot = "~/r.ashx/";
        private const string ResourceRoute = "r.ashx/{module}/{*path}";
        private static readonly LazyAction _initApplicationPart = new LazyAction(InitApplicationParts);
        private static ApplicationPartRegistry _partRegistry;
        private readonly Lazy<IDictionary<string, string>> _applicationPartResources;
        private readonly Lazy<string> _applicationPartName;

        public ApplicationPart(Assembly assembly, string rootVirtualPath)
            : this(new ResourceAssembly(assembly), rootVirtualPath)
        {
        }

        internal ApplicationPart(IResourceAssembly assembly, string rootVirtualPath)
        {
            if (String.IsNullOrEmpty(rootVirtualPath))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "rootVirtualPath");
            }

            // Make sure the root path ends with a slash
            if (!rootVirtualPath.EndsWith("/", StringComparison.Ordinal))
            {
                rootVirtualPath += "/";
            }

            Assembly = assembly;
            RootVirtualPath = rootVirtualPath;
            _applicationPartResources = new Lazy<IDictionary<string, string>>(() => Assembly.GetManifestResourceNames().ToDictionary(key => key, key => key, StringComparer.OrdinalIgnoreCase));
            _applicationPartName = new Lazy<string>(() => Assembly.Name);
        }

        internal IResourceAssembly Assembly { get; private set; }

        internal string RootVirtualPath { get; private set; }

        internal string Name
        {
            get { return _applicationPartName.Value; }
        }

        internal IDictionary<string, string> ApplicationPartResources
        {
            get { return _applicationPartResources.Value; }
        }

        // REVIEW: Do we need an Unregister?
        // Register an assembly as an application module, which makes its compiled web pages
        // and embedded resources available
        public static void Register(ApplicationPart applicationPart)
        {
            // Ensure the registry is ready and the route handlers are set up
            _initApplicationPart.EnsurePerformed();
            Debug.Assert(_partRegistry != null, "Part registry should be initialized");

            _partRegistry.Register(applicationPart);
        }

        public static string ProcessVirtualPath(Assembly assembly, string baseVirtualPath, string virtualPath)
        {
            if (_partRegistry == null)
            {
                // This was called without registering a part.
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebPageResources.ApplicationPart_ModuleNotRegistered, assembly));
            }

            ApplicationPart applicationPart = _partRegistry[new ResourceAssembly(assembly)];
            if (applicationPart == null)
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  WebPageResources.ApplicationPart_ModuleNotRegistered,
                                  assembly));
            }

            return applicationPart.ProcessVirtualPath(baseVirtualPath, virtualPath);
        }

        internal static IEnumerable<ApplicationPart> GetRegisteredParts()
        {
            _initApplicationPart.EnsurePerformed();
            return _partRegistry.RegisteredParts;
        }

        private string ProcessVirtualPath(string baseVirtualPath, string virtualPath)
        {
            virtualPath = ResolveVirtualPath(RootVirtualPath, baseVirtualPath, virtualPath);
            if (!virtualPath.StartsWith(RootVirtualPath, StringComparison.OrdinalIgnoreCase))
            {
                return virtualPath;
            }

            // Remove the root package path from the path, since the resource name doesn't use it
            // e.g. ~/admin/Debugger/Sub Folder/foo.jpg ==> ~/Sub Folder/foo.jpg
            string packageVirtualPath = "~/" + virtualPath.Substring(RootVirtualPath.Length);

            string resourceName = GetResourceNameFromVirtualPath(packageVirtualPath);

            // If the assembly doesn't contains that resource, don't change the path
            if (!ApplicationPartResources.ContainsKey(resourceName))
            {
                return virtualPath;
            }

            // The resource exists, so return a special path that will be handled by the resource handler
            return GetResourceVirtualPath(virtualPath);
        }

        /// <summary>
        /// Expands a virtual path by replacing a leading "@" with the application part root
        /// or combining it with the specified baseVirtualPath
        /// </summary>
        internal static string ResolveVirtualPath(string applicationRoot, string baseVirtualPath, string virtualPath)
        {
            // If it starts with @/, replace that with the package root
            // e.g. @/Sub Folder/foo.jpg ==> ~/admin/Debugger/Sub Folder/foo.jpg
            if (virtualPath.StartsWith(ModuleRootSyntax, StringComparison.OrdinalIgnoreCase))
            {
                return applicationRoot + virtualPath.Substring(ModuleRootSyntax.Length);
            }
            else
            {
                // Resolve if relative to the base
                return VirtualPathUtility.Combine(baseVirtualPath, virtualPath);
            }
        }

        internal Stream GetResourceStream(string virtualPath)
        {
            string resourceName = GetResourceNameFromVirtualPath(virtualPath);
            string normalizedResourceName;
            if (ApplicationPartResources.TryGetValue(resourceName, out normalizedResourceName))
            {
                // Return the resource stream
                return Assembly.GetManifestResourceStream(normalizedResourceName);
            }
            return null;
        }

        // Get the name of an embedded resource based on a virtual path
        private string GetResourceNameFromVirtualPath(string virtualPath)
        {
            return GetResourceNameFromVirtualPath(Name, virtualPath);
        }

        internal static string GetResourceNameFromVirtualPath(string moduleName, string virtualPath)
        {
            // Make sure path starts with ~/
            if (!virtualPath.StartsWith("~/", StringComparison.Ordinal))
            {
                virtualPath = "~/" + virtualPath;
            }

            // Get the directory part of the path
            // e.g. ~/Sub Folder/foo.jpg ==> ~/Sub Folder/
            string dir = VirtualPathUtility.GetDirectory(virtualPath);

            // Get rid of the starting ~/
            // e.g. ~/Sub Folder/ ==> Sub Folder/
            if (dir.Length >= 2)
            {
                dir = dir.Substring(2);
            }

            // Replace / with . and spaces with _
            // TODO: other special chars need to be replaced by _ as well
            // e.g. Sub Folder/ ==> Sub_Folder.
            dir = dir.Replace('/', '.');
            dir = dir.Replace(' ', '_');

            // Get the file name part.  That part of the resource names is the same as in the virtual path,
            // so no replacements are needed
            // e.g. ~/Sub Folder/foo.jpg ==> foo.jpg
            string fileName = Path.GetFileName(virtualPath);

            // Put them back together, and prepend the assembly name
            // e.g. DebuggerAssembly.Sub_Folder.foo.jpg
            return moduleName + "." + dir + fileName;
        }

        // Get a virtual path that uses the resource handler from a regular virtual path
        private string GetResourceVirtualPath(string virtualPath)
        {
            return GetResourceVirtualPath(Name, RootVirtualPath, virtualPath);
        }

        internal static string GetResourceVirtualPath(string moduleName, string moduleRoot, string virtualPath)
        {
            // The path should always start with the root of the module. Skip it.
            Debug.Assert(virtualPath.StartsWith(moduleRoot, StringComparison.OrdinalIgnoreCase));
            virtualPath = virtualPath.Substring(moduleRoot.Length).TrimStart('/');

            // Make a path to the resource through our resource route, e.g. ~/r.ashx/sub/foo.jpg
            // e.g. ~/admin/Debugger/Sub Folder/foo.jpg ==> ~/r.ashx/DebuggerPackageName/Sub Folder/foo.jpg
            return ResourceVirtualPathRoot + HttpUtility.UrlPathEncode(moduleName) + "/" + virtualPath;
        }

        private static void InitApplicationParts()
        {
            // Register the virtual path factory
            var virtualPathFactory = new DictionaryBasedVirtualPathFactory();
            VirtualPathFactoryManager.RegisterVirtualPathFactory(virtualPathFactory);

            // Intantiate the part registry
            _partRegistry = new ApplicationPartRegistry(virtualPathFactory);

            // Register the resource route
            RouteTable.Routes.Add(new Route(ResourceRoute, new ResourceRouteHandler(_partRegistry)));
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationParts/ApplicationPartRegistry.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages.ApplicationParts
{
    internal class ApplicationPartRegistry
    {
        // Page types that we could serve
        private static readonly Type _webPageType = typeof(WebPageRenderingBase);
        private readonly DictionaryBasedVirtualPathFactory _virtualPathFactory;
        private readonly ConcurrentDictionary<string, bool> _registeredVirtualPaths;
        private readonly ConcurrentDictionary<IResourceAssembly, ApplicationPart> _applicationParts;

        public ApplicationPartRegistry(DictionaryBasedVirtualPathFactory pathFactory)
        {
            _applicationParts = new ConcurrentDictionary<IResourceAssembly, ApplicationPart>();
            _registeredVirtualPaths = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
            _virtualPathFactory = pathFactory;
        }

        public IEnumerable<ApplicationPart> RegisteredParts
        {
            get { return _applicationParts.Values; }
        }

        public ApplicationPart this[string name]
        {
            get { return _applicationParts.Values.FirstOrDefault(appPart => appPart.Name.Equals(name, StringComparison.OrdinalIgnoreCase)); }
        }

        public ApplicationPart this[IResourceAssembly assembly]
        {
            get
            {
                ApplicationPart part;
                if (!_applicationParts.TryGetValue(assembly, out part))
                {
                    part = null;
                }
                return part;
            }
        }

        // Register an assembly as an application module, which makes its compiled web pages
        // and embedded resources available
        public void Register(ApplicationPart applicationPart)
        {
            Register(applicationPart, registerPageAction: null); // Use default action which creates a new page
        }

        // Register an assembly as an application module, which makes its compiled web pages
        // and embedded resources available
        internal void Register(ApplicationPart applicationPart, Func<object> registerPageAction)
        {
            // Throw if this assembly has been registered
            if (_applicationParts.ContainsKey(applicationPart.Assembly))
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  WebPageResources.ApplicationPart_ModuleAlreadyRegistered, applicationPart.Assembly));
            }

            // Throw if the virtual path is already in use
            if (_registeredVirtualPaths.ContainsKey(applicationPart.RootVirtualPath))
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  WebPageResources.ApplicationPart_ModuleAlreadyRegisteredForVirtualPath, applicationPart.RootVirtualPath));
            }

            // REVIEW: Should we register the app-part after we scan the assembly for webpages?
            // Add the part to the list
            if (_applicationParts.TryAdd(applicationPart.Assembly, applicationPart))
            {
                // We don't really care about the value
                _registeredVirtualPaths.TryAdd(applicationPart.RootVirtualPath, true);

                // Get all of the web page types
                var webPageTypes = from type in applicationPart.Assembly.GetTypes()
                                   where type.IsSubclassOf(_webPageType)
                                   select type;

                // Register each of page with the plan9
                foreach (Type webPageType in webPageTypes)
                {
                    RegisterWebPage(applicationPart, webPageType, registerPageAction);
                }
            }
        }

        private void RegisterWebPage(ApplicationPart module, Type webPageType, Func<object> registerPageAction)
        {
            var virtualPathAttribute = webPageType.GetCustomAttributes(typeof(PageVirtualPathAttribute), false)
                .Cast<PageVirtualPathAttribute>()
                .SingleOrDefault();

            // Ignore it if it doesn't have a PageVirtualPathAttribute
            if (virtualPathAttribute == null)
            {
                return;
            }

            // Get the path of the page relative to the module root
            string virtualPath = GetRootRelativeVirtualPath(module.RootVirtualPath, virtualPathAttribute.VirtualPath);

            // Create a factory for the page type
            Func<object> pageFactory = registerPageAction ?? NewTypeInstance(webPageType);

            // Register a page factory for it
            _virtualPathFactory.RegisterPath(virtualPath, pageFactory);
        }

        private static Func<object> NewTypeInstance(Type type)
        {
            return Expression.Lambda<Func<object>>(Expression.New(type)).Compile();
        }

        internal static string GetRootRelativeVirtualPath(string rootVirtualPath, string pageVirtualPath)
        {
            string virtualPath = pageVirtualPath;

            // Trim the ~/ prefix, since we want it to be relative to the module base path
            if (virtualPath.StartsWith("~/", StringComparison.Ordinal))
            {
                virtualPath = virtualPath.Substring(2);
            }

            if (!rootVirtualPath.EndsWith("/", StringComparison.OrdinalIgnoreCase))
            {
                rootVirtualPath += "/";
            }

            // Combine it with the root
            virtualPath = VirtualPathUtility.Combine(rootVirtualPath, virtualPath);
            return virtualPath;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationParts/DictionaryBasedVirtualPathFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;

namespace System.Web.WebPages.ApplicationParts
{
    // IVirtualPathFactory that keeps track of a mapping from virtual paths to handler factories
    internal class DictionaryBasedVirtualPathFactory : IVirtualPathFactory
    {
        private Dictionary<string, Func<object>> _factories = new Dictionary<string, Func<object>>(StringComparer.OrdinalIgnoreCase);

        internal void RegisterPath(string virtualPath, Func<object> factory)
        {
            _factories[virtualPath] = factory;
        }

        public bool Exists(string virtualPath)
        {
            return _factories.ContainsKey(virtualPath);
        }

        public object CreateInstance(string virtualPath)
        {
            // Instantiate an object for the path
            // Note that this fails if it doesn't exist.  PathExists is assumed to have been called first
            Debug.Assert(Exists(virtualPath));
            return _factories[virtualPath]();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationParts/IResourceAssembly.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;

namespace System.Web.WebPages.ApplicationParts
{
    // For unit testing purpose since Assembly is not Moqable
    internal interface IResourceAssembly
    {
        string Name { get; }
        Stream GetManifestResourceStream(string name);
        IEnumerable<string> GetManifestResourceNames();
        IEnumerable<Type> GetTypes();
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationParts/LazyAction.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;

namespace System.Web.WebPages.ApplicationParts
{
    internal class LazyAction
    {
        private Lazy<object> _lazyAction;

        public LazyAction(Action action)
        {
            Debug.Assert(action != null, "action should not be null");
            // Setup the lazy object to run our action and just return null 
            // since we don't care about the value
            _lazyAction = new Lazy<object>(() =>
            {
                action();
                return null;
            });
        }

        public object EnsurePerformed()
        {
            // REVIEW: This isn't used we're just exploiting the use of Lazy<T> to execute 
            // our action once in a thread safe way
            // It would be nice if the framework had Unit (i.e a better void type so we could type Func<Unit> -> Action) 
            return _lazyAction.Value;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationParts/ResourceAssembly.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;

namespace System.Web.WebPages.ApplicationParts
{
    // Implementation of IResourceAssembly over a standard assembly
    internal class ResourceAssembly : IResourceAssembly
    {
        private readonly Assembly _assembly;

        public ResourceAssembly(Assembly assembly)
        {
            if (assembly == null)
            {
                throw new ArgumentNullException("assembly");
            }
            _assembly = assembly;
        }

        public string Name
        {
            get
            {
                // Need this for medium trust
                AssemblyName assemblyName = new AssemblyName(_assembly.FullName);
                Debug.Assert(assemblyName != null, "Assembly name should not be null");
                // Use the assembly short name
                return assemblyName.Name;
            }
        }

        public Stream GetManifestResourceStream(string name)
        {
            return _assembly.GetManifestResourceStream(name);
        }

        public IEnumerable<string> GetManifestResourceNames()
        {
            return _assembly.GetManifestResourceNames();
        }

        public IEnumerable<Type> GetTypes()
        {
            return _assembly.GetExportedTypes();
        }

        public override bool Equals(object obj)
        {
            var otherAssembly = obj as ResourceAssembly;
            return otherAssembly != null && otherAssembly._assembly.Equals(_assembly);
        }

        public override int GetHashCode()
        {
            return _assembly.GetHashCode();
        }

        public override String ToString()
        {
            return _assembly.ToString();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationParts/ResourceHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.WebPages.Resources;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.ApplicationParts
{
    // Used to serve static resource files (e.g. .jpg, .css, .js) that live inside appliaction modules
    internal class ResourceHandler : IHttpHandler
    {
        private readonly string _path;
        private readonly ApplicationPart _applicationPart;

        public ResourceHandler(ApplicationPart applicationPart, string path)
        {
            if (applicationPart == null)
            {
                throw new ArgumentNullException("applicationPart");
            }

            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }

            _applicationPart = applicationPart;
            _path = path;
        }

        public bool IsReusable
        {
            get { return true; }
        }

        public void ProcessRequest(HttpContext context)
        {
            ProcessRequest(new HttpResponseWrapper(context.Response));
        }

        internal void ProcessRequest(HttpResponseBase response)
        {
            string virtualPath = _path;

            // Make sure it starts with ~/
            if (!virtualPath.StartsWith("~/", StringComparison.Ordinal))
            {
                virtualPath = "~/" + virtualPath;
            }

            // Get the resource stream for this virtual path
            using (var stream = _applicationPart.GetResourceStream(virtualPath))
            {
                if (stream == null)
                {
                    throw new HttpException(404, String.Format(
                        CultureInfo.CurrentCulture,
                        WebPageResources.ApplicationPart_ResourceNotFound, _path));
                }

                // Set the mime type based on the file extension
                response.ContentType = MimeMapping.GetMimeMapping(virtualPath);

                // Copy it to the response
                stream.CopyTo(response.OutputStream);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationParts/ResourceRouteHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Routing;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages.ApplicationParts
{
    internal class ResourceRouteHandler : IRouteHandler
    {
        private ApplicationPartRegistry _partRegistry;

        public ResourceRouteHandler(ApplicationPartRegistry partRegistry)
        {
            _partRegistry = partRegistry;
        }

        public IHttpHandler GetHttpHandler(RequestContext requestContext)
        {
            // Get the package name and static resource path from the route
            string partName = (string)requestContext.RouteData.GetRequiredString("module");

            // Try to find an application module by this name
            ApplicationPart module = _partRegistry[partName];

            // Throw an exception if we can't find the module by name
            if (module == null)
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  WebPageResources.ApplicationPart_ModuleCannotBeFound, partName));
            }

            // Get the resource path
            string path = (string)requestContext.RouteData.GetRequiredString("path");

            // Return the resource handler for this module and path
            return new ResourceHandler(module, path);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/ApplicationStartPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Threading;
using System.Web.Caching;
using System.Web.Hosting;
using Microsoft.Web.Infrastructure;

namespace System.Web.WebPages
{
    public abstract class ApplicationStartPage : WebPageExecutingBase
    {
        private static readonly Action<Action> _safeExecuteStartPageThunk = GetSafeExecuteStartPageThunk();
        public static readonly string StartPageVirtualPath = "~/_appstart.";
        public static readonly string CacheKeyPrefix = "__AppStartPage__";

        public HttpApplication Application { get; internal set; }

        public override HttpContextBase Context
        {
            get { return new HttpContextWrapper(Application.Context); }
        }

        public static HtmlString Markup { get; private set; }

        internal static Exception Exception { get; private set; }

        public TextWriter Output { get; internal set; }

        public override string VirtualPath
        {
            get { return StartPageVirtualPath; }
            set
            {
                // The virtual path for the start page is fixed for now.
                throw new NotSupportedException();
            }
        }

        internal void ExecuteInternal()
        {
            // See comments in GetSafeExecuteStartPageThunk().
            _safeExecuteStartPageThunk(() =>
            {
                Output = new StringWriter(CultureInfo.InvariantCulture);
                Execute();
                Markup = new HtmlString(Output.ToString());
            });
        }

        internal static void ExecuteStartPage(HttpApplication application)
        {
            ExecuteStartPage(application,
                             vpath => MonitorFile(vpath),
                             VirtualPathFactoryManager.Instance,
                             WebPageHttpHandler.GetRegisteredExtensions());
        }

        internal static void ExecuteStartPage(HttpApplication application, Action<string> monitorFile, IVirtualPathFactory virtualPathFactory, IEnumerable<string> supportedExtensions)
        {
            try
            {
                ExecuteStartPageInternal(application, monitorFile, virtualPathFactory, supportedExtensions);
            }
            catch (Exception e)
            {
                // Throw it as a HttpException so as to
                // display the original stack trace information.
                Exception = e;
                throw new HttpException(null, e);
            }
        }

        internal static void ExecuteStartPageInternal(HttpApplication application, Action<string> monitorFile, IVirtualPathFactory virtualPathFactory, IEnumerable<string> supportedExtensions)
        {
            ApplicationStartPage startPage = null;

            foreach (var extension in supportedExtensions)
            {
                var vpath = StartPageVirtualPath + extension;

                // We need to monitor regardless of existence because the user could add/remove the
                // file at any time.
                monitorFile(vpath);
                if (!virtualPathFactory.Exists(vpath))
                {
                    continue;
                }

                if (startPage == null)
                {
                    startPage = virtualPathFactory.CreateInstance<ApplicationStartPage>(vpath);
                    startPage.Application = application;
                    startPage.VirtualPathFactory = virtualPathFactory;
                    startPage.ExecuteInternal();
                }
            }
        }

        private static Action<Action> GetSafeExecuteStartPageThunk()
        {
            // Programmatically detect if this version of System.Web.dll suffers from a bug in
            // which HttpUtility.HtmlEncode can't be called from Application_Start, and if so
            // set the current HttpContext to null to work around it.
            //
            // See Dev10 #906296 and Dev10 #898600 for more information.

            if (typeof(HttpResponse).GetProperty("DisableCustomHttpEncoder", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly) != null)
            {
                // this version suffers from the bug
                return HttpContextHelper.ExecuteInNullContext;
            }
            else
            {
                // this version does not suffer from the bug
                return action => action();
            }
        }

        private static void InitiateShutdown(string key, object value, CacheItemRemovedReason reason)
        {
            // Only handle case when the dependency has changed.
            if (reason != CacheItemRemovedReason.DependencyChanged)
            {
                return;
            }

            ThreadPool.QueueUserWorkItem(new WaitCallback(ShutdownCallBack));
        }

        private static void MonitorFile(string virtualPath)
        {
            var virtualPathDependencies = new List<string>();
            virtualPathDependencies.Add(virtualPath);
            CacheDependency cacheDependency = HostingEnvironment.VirtualPathProvider.GetCacheDependency(
                virtualPath, virtualPathDependencies, DateTime.UtcNow);
            var key = CacheKeyPrefix + virtualPath;

            HttpRuntime.Cache.Insert(key, virtualPath, cacheDependency,
                                     Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration,
                                     CacheItemPriority.NotRemovable, new CacheItemRemovedCallback(InitiateShutdown));
        }

        private static void ShutdownCallBack(object state)
        {
            InfrastructureHelper.UnloadAppDomain();
        }

        public override void Write(HelperResult result)
        {
            if (result != null)
            {
                result.WriteTo(Output);
            }
        }

        public override void WriteLiteral(object value)
        {
            Output.Write(value);
        }

        public override void Write(object value)
        {
            Output.Write(HttpUtility.HtmlEncode(value));
        }

        protected internal override TextWriter GetOutputWriter()
        {
            return Output;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/AttributeValue.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Web.WebPages.Instrumentation;

namespace System.Web.WebPages
{
    public class AttributeValue
    {
        public AttributeValue(PositionTagged<string> prefix, PositionTagged<object> value, bool literal)
        {
            Prefix = prefix;
            Value = value;
            Literal = literal;
        }

        public PositionTagged<string> Prefix { get; private set; }
        public PositionTagged<object> Value { get; private set; }
        public bool Literal { get; private set; }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "We are using tuples here to avoid dependencies from Razor to WebPages")]
        public static AttributeValue FromTuple(Tuple<Tuple<string, int>, Tuple<object, int>, bool> value)
        {
            return new AttributeValue(value.Item1, value.Item2, value.Item3);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "We are using tuples here to avoid dependencies from Razor to WebPages")]
        public static AttributeValue FromTuple(Tuple<Tuple<string, int>, Tuple<string, int>, bool> value)
        {
            return new AttributeValue(value.Item1, new PositionTagged<object>(value.Item2.Item1, value.Item2.Item2), value.Item3);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "We are using tuples here to avoid dependencies from Razor to WebPages")]
        public static implicit operator AttributeValue(Tuple<Tuple<string, int>, Tuple<object, int>, bool> value)
        {
            return FromTuple(value);
        }

        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "We are using tuples here to avoid dependencies from Razor to WebPages")]
        public static implicit operator AttributeValue(Tuple<Tuple<string, int>, Tuple<string, int>, bool> value)
        {
            return FromTuple(value);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/BrowserHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Hosting;

namespace System.Web.WebPages
{
    /// <summary>
    /// Extension methods used to determine what browser a visitor wants to be seen as using.
    /// </summary>
    public static class BrowserHelpers
    {
        /// <summary>
        /// Stock IE6 user agent string
        /// </summary>
        private const string DesktopUserAgent = "Mozilla/4.0 (compatible; MSIE 6.1; Windows XP)";

        /// <summary>
        /// Stock Windows Mobile 6.0 user agent string
        /// </summary>
        private const string MobileUserAgent = "Mozilla/4.0 (compatible; MSIE 6.0; Windows CE; IEMobile 8.12; MSIEMobile 6.0)";

        private static readonly object _browserOverrideKey = new object();
        private static readonly object _userAgentKey = new object();

        /// <summary>
        /// Clears the set browser for the request. After clearing the browser the overridden browser will be the browser for the request.
        /// </summary>
        public static void ClearOverriddenBrowser(this HttpContextBase httpContext)
        {
            SetOverriddenBrowser(httpContext, userAgent: null);
        }

        // Default implementation to generate an HttpBrowserCapabilities object using the current HttpCapabilitiesProvider
        private static HttpBrowserCapabilitiesBase CreateOverriddenBrowser(string userAgent)
        {
            HttpBrowserCapabilities overriddenBrowser = new HttpContext(new UserAgentWorkerRequest(userAgent)).Request.Browser;
            return new HttpBrowserCapabilitiesWrapper(overriddenBrowser);
        }

        /// <summary>
        /// Gets the overridden browser for the request based on the overridden user agent.
        /// If no overridden user agent is set, returns the browser for the request.
        /// </summary>
        public static HttpBrowserCapabilitiesBase GetOverriddenBrowser(this HttpContextBase httpContext)
        {
            return GetOverriddenBrowser(httpContext, createBrowser: null);
        }

        /// <summary>
        /// Internal GetOverriddenBrowser overload to allow the browser creation function to changed. Defaults to CreateOverridenBrowser if createBrowser is null.
        /// </summary>
        internal static HttpBrowserCapabilitiesBase GetOverriddenBrowser(this HttpContextBase httpContext, Func<string, HttpBrowserCapabilitiesBase> createBrowser)
        {
            HttpBrowserCapabilitiesBase overriddenBrowser = (HttpBrowserCapabilitiesBase)httpContext.Items[_browserOverrideKey];

            if (overriddenBrowser == null)
            {
                string overriddenUserAgent = GetOverriddenUserAgent(httpContext);

                if (!String.Equals(overriddenUserAgent, httpContext.Request.UserAgent, StringComparison.OrdinalIgnoreCase))
                {
                    if (createBrowser != null)
                    {
                        overriddenBrowser = createBrowser(overriddenUserAgent);
                    }
                    else
                    {
                        overriddenBrowser = CreateOverriddenBrowser(overriddenUserAgent);
                    }
                }
                else
                {
                    overriddenBrowser = httpContext.Request.Browser;
                }

                httpContext.Items[_browserOverrideKey] = overriddenBrowser;
            }

            return overriddenBrowser;
        }

        /// <summary>
        /// Gets the overridden user agent for the request. If no overridden user agent is set, returns the user agent for the request.
        /// </summary>
        public static string GetOverriddenUserAgent(this HttpContextBase httpContext)
        {
            return (string)httpContext.Items[_userAgentKey] ??
                   BrowserOverrideStores.Current.GetOverriddenUserAgent(httpContext) ??
                   httpContext.Request.UserAgent;
        }

        /// <summary>
        /// Gets a string that varies based upon the type of the browser. Can be used to override
        /// System.Web.HttpApplication.GetVaryByCustomString to differentiate cache keys based on
        /// the overridden browser.
        /// </summary>
        public static string GetVaryByCustomStringForOverriddenBrowser(this HttpContext httpContext)
        {
            return GetVaryByCustomStringForOverriddenBrowser(new HttpContextWrapper(httpContext));
        }

        /// <summary>
        /// Gets a string that varies based upon the type of the browser. Can be used to override
        /// System.Web.HttpApplication.GetVaryByCustomString to differentiate cache keys based on
        /// the overridden browser.
        /// </summary>
        public static string GetVaryByCustomStringForOverriddenBrowser(this HttpContextBase httpContext)
        {
            return GetOverriddenBrowser(httpContext, createBrowser: null).Type;
        }

        /// <summary>
        /// Sets the overridden user agent for the request using a BrowserOverride.
        /// </summary>
        public static void SetOverriddenBrowser(this HttpContextBase httpContext, BrowserOverride browserOverride)
        {
            string userAgent = null;

            switch (browserOverride)
            {
                case BrowserOverride.Desktop:
                    // bug:262389 override only if the request was not made from a browser or the browser is not of a desktop device
                    if (httpContext.Request.Browser == null || httpContext.Request.Browser.IsMobileDevice)
                    {
                        userAgent = DesktopUserAgent;
                    }
                    break;
                case BrowserOverride.Mobile:
                    if (httpContext.Request.Browser == null || !httpContext.Request.Browser.IsMobileDevice)
                    {
                        userAgent = MobileUserAgent;
                    }
                    break;
            }

            if (userAgent != null)
            {
                SetOverriddenBrowser(httpContext, userAgent);
            }
            else
            {
                ClearOverriddenBrowser(httpContext);
            }
        }

        /// <summary>
        /// Sets the overridden user agent for the request using a string
        /// </summary>
        public static void SetOverriddenBrowser(this HttpContextBase httpContext, string userAgent)
        {
            // Set the overridden user agent and clear the overridden browser
            // so that it can be generated from the new overridden user agent.
            httpContext.Items[_userAgentKey] = userAgent;
            httpContext.Items[_browserOverrideKey] = null;

            BrowserOverrideStores.Current.SetOverriddenUserAgent(httpContext, userAgent);
        }

        private sealed class UserAgentWorkerRequest : SimpleWorkerRequest
        {
            private readonly string _userAgent;

            public UserAgentWorkerRequest(string userAgent)
                : base(String.Empty, String.Empty, output: null)
            {
                _userAgent = userAgent;
            }

            public override string GetKnownRequestHeader(int index)
            {
                return index == HeaderUserAgent ? _userAgent : null;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/BrowserOverride.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// BrowserOverrides can be used by BrowserHelpers to override the browser for a particular request.
    /// </summary>
    public enum BrowserOverride
    {
        Desktop,
        Mobile
    }
}


================================================
FILE: src/System.Web.WebPages/BrowserOverrideStore.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// The current BrowserOverrideStore is used to get and set the user agent of a request.
    /// For an example see CookieBasedBrowserOverrideStore.
    /// </summary>
    public abstract class BrowserOverrideStore
    {
        public abstract string GetOverriddenUserAgent(HttpContextBase httpContext);
        public abstract void SetOverriddenUserAgent(HttpContextBase httpContext, string userAgent);
    }
}


================================================
FILE: src/System.Web.WebPages/BrowserOverrideStores.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    public class BrowserOverrideStores
    {
        private static BrowserOverrideStores _instance = new BrowserOverrideStores();
        private BrowserOverrideStore _currentOverrideStore = new CookieBrowserOverrideStore();

        /// <summary>
        /// The current BrowserOverrideStore
        /// </summary>
        public static BrowserOverrideStore Current
        {
            get { return _instance.CurrentInternal; }
            set { _instance.CurrentInternal = value; }
        }

        internal BrowserOverrideStore CurrentInternal
        {
            get { return _currentOverrideStore; }
            set { _currentOverrideStore = value ?? new RequestBrowserOverrideStore(); }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/BuildManagerWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Linq;
using System.Web.Caching;
using System.Web.Compilation;
using System.Web.Hosting;
using System.Web.Util;
using System.Xml.Linq;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    /// <summary>
    /// Wraps the caching and instantiation of paths of the BuildManager. 
    /// In case of precompiled non-updateable sites, the only way to verify if a file exists is to call BuildManager.GetObjectFactory. However this method is less performant than
    /// VirtualPathProvider.FileExists which is used for all other scenarios. In this class, we optimize for the first scenario by storing the results of GetObjectFactory for a 
    /// long duration.
    /// </summary>
    internal sealed class BuildManagerWrapper : IVirtualPathFactory
    {
        internal static readonly Guid KeyGuid = Guid.NewGuid();
        private static readonly TimeSpan _objectFactoryCacheDuration = TimeSpan.FromMinutes(1);
        private readonly IVirtualPathUtility _virtualPathUtility;
        private readonly Func<VirtualPathProvider> _vppFunc;
        private readonly bool _isPrecompiled;
        private readonly FileExistenceCache _vppCache;
        private IEnumerable<string> _supportedExtensions;

        public BuildManagerWrapper()
            : this(() => HostingEnvironment.VirtualPathProvider, new VirtualPathUtilityWrapper())
        {
        }

        public BuildManagerWrapper(VirtualPathProvider vpp, IVirtualPathUtility virtualPathUtility)
            : this(() => vpp, virtualPathUtility)
        {
            Contract.Assert(vpp != null);
        }

        public BuildManagerWrapper(Func<VirtualPathProvider> vppFunc, IVirtualPathUtility virtualPathUtility)
        {
            Contract.Assert(vppFunc != null);
            Contract.Assert(virtualPathUtility != null);

            _vppFunc = vppFunc;
            _virtualPathUtility = virtualPathUtility;
            _isPrecompiled = IsNonUpdatablePrecompiledApp();
            if (!_isPrecompiled)
            {
                _vppCache = new FileExistenceCache(vppFunc);
            }
        }

        public IEnumerable<string> SupportedExtensions
        {
            get { return _supportedExtensions ?? WebPageHttpHandler.GetRegisteredExtensions(); }
            set { _supportedExtensions = value; }
        }

        /// <summary>
        /// Determines if a page exists in the website. 
        /// This method switches between a long duration cache or a short duration FileExistenceCache depending on whether the site is precompiled. 
        /// This is an optimization because BuildManager.GetObjectFactory is comparably slower than performing VirtualPathFactory.Exists
        /// </summary>
        public bool Exists(string virtualPath)
        {
            if (_isPrecompiled)
            {
                return ExistsInPrecompiledSite(virtualPath);
            }
            return ExistsInVpp(virtualPath);
        }

        internal bool IsNonUpdatablePrecompiledApp()
        {
            VirtualPathProvider vpp = _vppFunc();
            // VirtualPathProvider currently null in some test scenarios e.g. PreApplicationStartCodeTest.StartTest
            if (vpp == null)
            {
                return false;
            }
            return IsNonUpdateablePrecompiledApp(vpp, _virtualPathUtility);
        }

        /// <summary>
        /// An app's is precompiled for our purposes if 
        /// (a) it has a PreCompiledApp.config file in the site root, 
        /// (b) The PreCompiledApp.config says that the app is not Updatable.
        /// </summary>
        /// <remarks>
        /// This code is based on System.Web.DynamicData.Misc.IsNonUpdatablePrecompiledAppNoCache (DynamicData)
        /// </remarks>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "We want to replicate the behavior of BuildManager which catches all exceptions.")]
        internal static bool IsNonUpdateablePrecompiledApp(VirtualPathProvider vpp, IVirtualPathUtility virtualPathUtility)
        {
            var virtualPath = virtualPathUtility.ToAbsolute("~/PrecompiledApp.config");
            if (!vpp.FileExists(virtualPath))
            {
                return false;
            }

            XDocument document;
            using (Stream stream = vpp.GetFile(virtualPath).Open())
            {
                try
                {
                    document = XDocument.Load(stream);
                }
                catch
                {
                    // If we are unable to load the file, ignore it. The BuildManager behaves identically.
                    return false;
                }
            }

            if (document.Root == null || !document.Root.Name.LocalName.Equals("precompiledApp", StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }
            var updatableAttribute = document.Root.Attribute("updatable");
            if (updatableAttribute != null)
            {
                bool result;
                return Boolean.TryParse(updatableAttribute.Value, out result) && (result == false);
            }
            return false;
        }

        private bool ExistsInPrecompiledSite(string virtualPath)
        {
            var key = GetKeyFromVirtualPath(virtualPath);

            // We assume that the key is unique enough to avoid collisions.
            var buildManagerResult = (BuildManagerResult)HttpRuntime.Cache.Get(key);
            if (buildManagerResult == null)
            {
                // For precompiled apps, we cache the ObjectFactory and use it in the CreateInstance method. 
                var objectFactory = GetObjectFactory(virtualPath);
                buildManagerResult = new BuildManagerResult { ObjectFactory = objectFactory, Exists = objectFactory != null };
                // Cache the result with a sliding expiration for a long duration. 
                HttpRuntime.Cache.Add(key, buildManagerResult, null, Cache.NoAbsoluteExpiration, _objectFactoryCacheDuration, CacheItemPriority.Low, null);
            }
            return buildManagerResult.Exists;
        }

        /// <summary>
        /// Determines if a site exists in the VirtualPathProvider.
        /// Results of hits are cached for a very short amount of time in the FileExistenceCache.
        /// </summary>
        private bool ExistsInVpp(string virtualPath)
        {
            Debug.Assert(_vppCache != null);
            return _vppCache.FileExists(virtualPath);
        }

        /// <summary>
        /// Determines if an ObjectFactory exists for the virtualPath. 
        /// The BuildManager complains if we pass in extensions that aren't registered for compilation. So we ensure that the virtual path is not 
        /// extensionless and that it is one of the extension
        /// </summary>
        private IWebObjectFactory GetObjectFactory(string virtualPath)
        {
            if (IsPathExtensionSupported(virtualPath))
            {
                return BuildManager.GetObjectFactory(virtualPath, throwIfNotFound: false);
            }
            return null;
        }

        public object CreateInstance(string virtualPath)
        {
            return CreateInstanceOfType<object>(virtualPath);
        }

        public T CreateInstanceOfType<T>(string virtualPath) where T : class
        {
            if (_isPrecompiled)
            {
                var buildManagerResult = (BuildManagerResult)HttpRuntime.Cache.Get(GetKeyFromVirtualPath(virtualPath));
                // The cache could have evicted our results. In this case, we'll simply fall through to CreateInstanceFromVirtualPath
                if (buildManagerResult != null)
                {
                    Debug.Assert(buildManagerResult.Exists && buildManagerResult.ObjectFactory != null, "This method must only be called if the file exists.");
                    return buildManagerResult.ObjectFactory.CreateInstance() as T;
                }
            }

            return (T)BuildManager.CreateInstanceFromVirtualPath(virtualPath, typeof(T));
        }

        /// <summary>
        /// Determines if the extension is one of the extensions registered with WebPageHttpHandler. 
        /// </summary>
        public bool IsPathExtensionSupported(string virtualPath)
        {
            string extension = PathUtil.GetExtension(virtualPath);
            return !String.IsNullOrEmpty(extension)
                   && SupportedExtensions.Contains(extension.Substring(1), StringComparer.OrdinalIgnoreCase);
        }

        /// <summary>
        /// Creates a reasonably unique key for a given virtual path by concatenating it with a Guid.
        /// </summary>
        private static string GetKeyFromVirtualPath(string virtualPath)
        {
            return KeyGuid.ToString() + "_" + virtualPath;
        }

        private class BuildManagerResult
        {
            public bool Exists { get; set; }

            public IWebObjectFactory ObjectFactory { get; set; }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Common/DisposableAction.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    internal class DisposableAction : IDisposable
    {
        private Action _action;
        private bool _hasDisposed;

        public DisposableAction(Action action)
        {
            if (action == null)
            {
                throw new ArgumentNullException("action");
            }
            _action = action;
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            // If we were disposed by the finalizer it's because the user didn't use a "using" block, so don't do anything!
            if (disposing)
            {
                lock (this)
                {
                    if (!_hasDisposed)
                    {
                        _hasDisposed = true;
                        _action();
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/CookieBrowserOverrideStore.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// The default BrowserOverrideStore. Gets overridden user agent for a request from a cookie.
    /// Creates a cookie to set the overridden user agent.
    /// </summary>
    public class CookieBrowserOverrideStore : BrowserOverrideStore
    {
        internal static readonly string BrowserOverrideCookieName = ".ASPXBrowserOverride";
        private readonly int _daysToExpire;

        /// <summary>
        /// Creates the BrowserOverrideStore setting any browser override cookie to expire in 7 days.
        /// </summary>
        public CookieBrowserOverrideStore()
            : this(daysToExpire: 7)
        {
        }

        /// <summary>
        /// Constructor to control the expiration of the browser override cookie.
        /// </summary>
        public CookieBrowserOverrideStore(int daysToExpire)
        {
            _daysToExpire = daysToExpire;
        }

        /// <summary>
        /// Looks for a user agent by searching for the browser override cookie. If no cookie is found
        /// returns null.
        /// </summary>
        public override string GetOverriddenUserAgent(HttpContextBase httpContext)
        {
            // Check the response to see if the cookie has been set somewhere in the current request.
            HttpCookieCollection responseCookies = httpContext.Response.Cookies;
            // NOTE: Only look for the key (via AllKeys) so a new cookie is not automatically created.
            string[] cookieNames = responseCookies.AllKeys;
            // NOTE: use a simple for loop since it performs an order of magnitude faster than .Contains()
            // and this is a hot path that gets executed for every request.
            for (int i = 0; i < cookieNames.Length; i++)
            {
                // HttpCookieCollection uses OrdinalIgnoreCase comparison for its keys
                if (String.Equals(cookieNames[i], BrowserOverrideCookieName, StringComparison.OrdinalIgnoreCase))
                {
                    HttpCookie currentOverriddenBrowserCookie = responseCookies[BrowserOverrideCookieName];

                    if (currentOverriddenBrowserCookie.Value != null)
                    {
                        return currentOverriddenBrowserCookie.Value;
                    }
                    else
                    {
                        // The cookie has no value. It was cleared on the current request so return null.
                        return null;
                    }
                }
            }

            // If there was no cookie found in the response check the request.
            var requestOverrideCookie = httpContext.Request.Cookies[BrowserOverrideCookieName];
            if (requestOverrideCookie != null)
            {
                return requestOverrideCookie.Value;
            }

            return null;
        }

        /// <summary>
        /// Adds a browser override cookie with the set user agent to the response of the current request.
        /// If the user agent is null the browser override cookie is set to expire, otherwise its expiration is set
        /// to daysToExpire, specified when CookieBasedOverrideStore is created.
        /// </summary>
        public override void SetOverriddenUserAgent(HttpContextBase httpContext, string userAgent)
        {
            HttpCookie browserOverrideCookie = new HttpCookie(BrowserOverrideCookieName, HttpUtility.UrlEncode(userAgent));

            if (userAgent == null)
            {
                browserOverrideCookie.Expires = DateTime.Now.AddDays(-1);
            }
            else
            {
                // Only set expiration if the cookie should live longer than the current session
                if (_daysToExpire > 0)
                {
                    browserOverrideCookie.Expires = DateTime.Now.AddDays(_daysToExpire);
                }
            }

            httpContext.Response.Cookies.Remove(BrowserOverrideCookieName);
            httpContext.Response.Cookies.Add(browserOverrideCookie);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/DefaultDisplayMode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.WebPages
{
    /// <summary>
    /// The <see cref="DefaultDisplayMode"/> can take any suffix and determine if there is a corresponding
    /// file that exists given a path and request by transforming the path to contain the suffix.
    /// Add a new DefaultDisplayMode to the Modes collection to handle a new suffix or inherit from
    /// DefaultDisplayMode to provide custom logic to transform paths with a suffix.
    /// </summary>
    public class DefaultDisplayMode : IDisplayMode
    {
        private readonly string _suffix;

        public DefaultDisplayMode()
            : this(DisplayModeProvider.DefaultDisplayModeId)
        {
        }

        public DefaultDisplayMode(string suffix)
        {
            _suffix = suffix ?? String.Empty;
        }

        /// <summary>
        /// When set, the <see cref="DefaultDisplayMode"/> will only be available to return Display Info for a request
        /// if the ContextCondition evaluates to true.
        /// </summary>
        public Func<HttpContextBase, bool> ContextCondition { get; set; }

        public virtual string DisplayModeId
        {
            get { return _suffix; }
        }

        public bool CanHandleContext(HttpContextBase httpContext)
        {
            return ContextCondition == null || ContextCondition(httpContext);
        }

        /// <summary>
        /// Returns DisplayInfo with the transformed path if it exists.
        /// </summary>
        public virtual DisplayInfo GetDisplayInfo(HttpContextBase httpContext, string virtualPath, Func<string, bool> virtualPathExists)
        {
            string transformedFilename = TransformPath(virtualPath, _suffix);
            if (transformedFilename != null && virtualPathExists(transformedFilename))
            {
                return new DisplayInfo(transformedFilename, this);
            }

            return null;
        }

        /// <summary>
        /// Transforms paths according to the following rules:
        /// \some\path.blah\file.txt.zip -> \some\path.blah\file.txt.suffix.zip
        /// \some\path.blah\file -> \some\path.blah\file.suffix
        /// </summary>
        protected virtual string TransformPath(string virtualPath, string suffix)
        {
            if (String.IsNullOrEmpty(suffix))
            {
                return virtualPath;
            }

            string extension = Path.GetExtension(virtualPath);
            return Path.ChangeExtension(virtualPath, suffix + extension);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/DisplayInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// DisplayInfo wraps the resolved file path and IDisplayMode for a request and path.
    /// The returned IDisplayMode can be used to resolve other page elements for the request.
    /// </summary>
    public class DisplayInfo
    {
        public DisplayInfo(string filePath, IDisplayMode displayMode)
        {
            if (filePath == null)
            {
                throw new ArgumentNullException("filePath");
            }

            if (displayMode == null)
            {
                throw new ArgumentNullException("displayMode");
            }

            FilePath = filePath;
            DisplayMode = displayMode;
        }

        /// <summary>
        /// The Display Mode used to resolve a virtual path.
        /// </summary>
        public IDisplayMode DisplayMode { get; private set; }

        /// <summary>
        /// Resolved path of a file that exists.
        /// </summary>
        public string FilePath { get; private set; }
    }
}


================================================
FILE: src/System.Web.WebPages/DisplayModeProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.WebPages
{
    public sealed class DisplayModeProvider
    {
        public static readonly string MobileDisplayModeId = "Mobile";
        public static readonly string DefaultDisplayModeId = String.Empty;
        private static readonly object _displayModeKey = new object();
        private static readonly DisplayModeProvider _instance = new DisplayModeProvider();

        private readonly List<IDisplayMode> _displayModes = new List<IDisplayMode>
        {
            new DefaultDisplayMode(MobileDisplayModeId)
            {
                ContextCondition = context => context.GetOverriddenBrowser().IsMobileDevice
            },
            new DefaultDisplayMode()
        };

        internal DisplayModeProvider()
        {
            // The type is a psuedo-singleton. A user would gain nothing from constructing it since we won't use anything but DisplayModeProvider.Instance internally.
        }

        /// <summary>
        /// Restricts the search for Display Info to Display Modes either equal to or following the current
        /// Display Mode in Modes. For example, a page being rendered in the Default Display Mode will not
        /// display Mobile partial views in order to achieve a consistent look and feel.
        /// </summary>
        public bool RequireConsistentDisplayMode { get; set; }

        public static DisplayModeProvider Instance
        {
            get { return _instance; }
        }

        /// <summary>
        /// All Display Modes that are available to handle a request.
        /// </summary>
        public IList<IDisplayMode> Modes
        {
            get { return _displayModes; }
        }

        private int FindFirstAvailableDisplayMode(IDisplayMode currentDisplayMode, bool requireConsistentDisplayMode)
        {
            if (requireConsistentDisplayMode && currentDisplayMode != null)
            {
                int first = _displayModes.IndexOf(currentDisplayMode);
                return (first >= 0) ? first : _displayModes.Count;
            }
            return 0;
        }

        /// <summary>
        /// Returns any IDisplayMode that can handle the given request.
        /// </summary>
        public IEnumerable<IDisplayMode> GetAvailableDisplayModesForContext(HttpContextBase httpContext, IDisplayMode currentDisplayMode)
        {
            return GetAvailableDisplayModesForContext(httpContext, currentDisplayMode, RequireConsistentDisplayMode);
        }

        internal IEnumerable<IDisplayMode> GetAvailableDisplayModesForContext(HttpContextBase httpContext, IDisplayMode currentDisplayMode, bool requireConsistentDisplayMode)
        {
            int first = FindFirstAvailableDisplayMode(currentDisplayMode, requireConsistentDisplayMode);
            for (int i = first; i < _displayModes.Count; i++)
            {
                IDisplayMode mode = _displayModes[i];
                if (mode.CanHandleContext(httpContext))
                {
                    yield return mode;
                }
            }
        }

        /// <summary>
        /// Returns DisplayInfo from the first IDisplayMode in Modes that can handle the given request and locate the virtual path.
        /// If currentDisplayMode is not null and RequireConsistentDisplayMode is set to true the search for DisplayInfo will only
        /// start with the currentDisplayMode.
        /// </summary>
        public DisplayInfo GetDisplayInfoForVirtualPath(string virtualPath, HttpContextBase httpContext, Func<string, bool> virtualPathExists, IDisplayMode currentDisplayMode)
        {
            return GetDisplayInfoForVirtualPath(virtualPath, httpContext, virtualPathExists, currentDisplayMode, RequireConsistentDisplayMode);
        }

        internal DisplayInfo GetDisplayInfoForVirtualPath(string virtualPath, HttpContextBase httpContext, Func<string, bool> virtualPathExists, IDisplayMode currentDisplayMode,
                                                          bool requireConsistentDisplayMode)
        {
            // Performance sensitive
            int first = FindFirstAvailableDisplayMode(currentDisplayMode, requireConsistentDisplayMode);
            for (int i = first; i < _displayModes.Count; i++)
            {
                IDisplayMode mode = _displayModes[i];
                if (mode.CanHandleContext(httpContext))
                {
                    DisplayInfo info = mode.GetDisplayInfo(httpContext, virtualPath, virtualPathExists);
                    if (info != null)
                    {
                        return info;
                    }
                }
            }
            return null;
        }

        internal static IDisplayMode GetDisplayMode(HttpContextBase context)
        {
            return context != null ? context.Items[_displayModeKey] as IDisplayMode : null;
        }

        internal static void SetDisplayMode(HttpContextBase context, IDisplayMode displayMode)
        {
            if (context != null)
            {
                context.Items[_displayModeKey] = displayMode;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/DynamicHttpApplicationState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Dynamic;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages
{
    internal class DynamicHttpApplicationState : DynamicObject
    {
        private HttpApplicationStateBase _state;

        public DynamicHttpApplicationState(HttpApplicationStateBase state)
        {
            _state = state;
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            result = _state[binder.Name];
            // We return true here because HttpApplicationState returns null if the key is not
            // in the dictionary, so we simply pass on the returned value.
            return true;
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            _state[binder.Name] = value;
            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            if (indexes == null || indexes.Length != 1)
            {
                throw new ArgumentException(WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);
            }

            result = null;
            string key = indexes[0] as string;
            if (key != null)
            {
                result = _state[key];
            }
            else if (indexes[0] is int)
            {
                result = _state[(int)indexes[0]];
            }
            else
            {
                // HttpApplicationState only supports keys of type string and int when getting values, so any attempt 
                // to use other types will result in an error. We throw an exception here to explain to the user what is wrong.
                // Returning false will instead cause a runtime binder exception which might be confusing to the user.
                throw new ArgumentException(WebPageResources.DynamicHttpApplicationState_UseOnlyStringOrIntToGet);
            }
            return true;
        }

        public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
        {
            if (indexes == null || indexes.Length != 1)
            {
                throw new ArgumentException(WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);
            }

            string key = indexes[0] as string;
            if (key != null)
            {
                _state[key] = value;
                return true;
            }
            else
            {
                // HttpApplicationState only supports keys of type string when setting values, so any attempt 
                // to use other types will result in an error. We throw an exception here to explain to the user what is wrong.
                // Returning false will instead cause a runtime binder error which might be confusing to the user.
                throw new ArgumentException(WebPageResources.DynamicHttpApplicationState_UseOnlyStringToSet);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/DynamicPageDataDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages
{
    /// <summary>
    /// This is a wrapper around PageDataDictionary[[dynamic]] which allows dynamic
    /// access (e.g. dict.Foo). Like PageDataDictionary, it returns null if the key is not found, 
    /// instead of throwing an exception.
    /// This class is intended to be used as DynamicPageDataDictionary[[dynamic]]
    /// </summary>
    // This is a generic type because C# does not allow implementing an interface 
    // involving dynamic types (implementing IDictionary<object, dynamic> causes
    // a compile error 
    // http://blogs.msdn.com/cburrows/archive/2009/02/04/c-dynamic-part-vii.aspx).
    internal class DynamicPageDataDictionary<TValue> : DynamicObject, IDictionary<object, TValue>
    {
        private PageDataDictionary<TValue> _data;

        public DynamicPageDataDictionary(PageDataDictionary<TValue> dictionary)
        {
            _data = dictionary;
        }

        public ICollection<object> Keys
        {
            get { return _data.Keys; }
        }

        public ICollection<TValue> Values
        {
            get { return _data.Values; }
        }

        public int Count
        {
            get { return _data.Count; }
        }

        public bool IsReadOnly
        {
            get { return _data.IsReadOnly; }
        }

        public TValue this[object key]
        {
            get { return _data[key]; }
            set { _data[key] = value; }
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            result = _data[binder.Name];
            // We return true here because PageDataDictionary returns null if the key is not
            // in the dictionary, so we simply pass on the returned value.
            return true;
        }

        public override bool TrySetMember(SetMemberBinder binder, object value)
        {
            // This cast should always succeed assuming TValue is dynamic.
            TValue v = (TValue)value;
            _data[binder.Name] = v;
            return true;
        }

        public override bool TryGetIndex(GetIndexBinder binder, object[] indexes, out object result)
        {
            if (indexes == null || indexes.Length != 1)
            {
                throw new ArgumentException(WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);
            }

            result = _data[indexes[0]];
            // We return true here because PageDataDictionary returns null if the key is not
            // in the dictionary, so we simply pass on the returned value.
            return true;
        }

        public override bool TrySetIndex(SetIndexBinder binder, object[] indexes, object value)
        {
            if (indexes == null || indexes.Length != 1)
            {
                throw new ArgumentException(WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);
            }

            // This cast should always succeed assuming TValue is dynamic.
            _data[indexes[0]] = (TValue)value;
            return true;
        }

        public void Add(object key, TValue value)
        {
            _data.Add(key, value);
        }

        public bool ContainsKey(object key)
        {
            return _data.ContainsKey(key);
        }

        public bool Remove(object key)
        {
            return _data.Remove(key);
        }

        public bool TryGetValue(object key, out TValue value)
        {
            return _data.TryGetValue(key, out value);
        }

        public void Add(KeyValuePair<object, TValue> item)
        {
            _data.Add(item);
        }

        public void Clear()
        {
            _data.Clear();
        }

        public bool Contains(KeyValuePair<object, TValue> item)
        {
            return _data.Contains(item);
        }

        public void CopyTo(KeyValuePair<object, TValue>[] array, int arrayIndex)
        {
            _data.CopyTo(array, arrayIndex);
        }

        public bool Remove(KeyValuePair<object, TValue> item)
        {
            return _data.Remove(item.Key);
        }

        public IEnumerator<KeyValuePair<object, TValue>> GetEnumerator()
        {
            return _data.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _data.GetEnumerator();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/FileExistenceCache.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Threading;
using System.Web.Hosting;

namespace System.Web.WebPages
{
    /// <summary>
    /// This class caches the result of VirtualPathProvider.FileExists for a short
    /// period of time, and recomputes it if necessary.
    /// 
    /// The default VPP MapPathBasedVirtualPathProvider caches the result of
    /// the FileExists call with the appropriate dependencies, so it is less
    /// expensive on subsequent calls, but it still needs to do MapPath which can 
    /// take quite some time.
    /// </summary>
    internal class FileExistenceCache
    {
        private const int TicksPerMillisecond = 10000;
        private readonly Func<VirtualPathProvider> _virtualPathProviderFunc;
        private readonly Func<string, bool> _virtualPathFileExists;
        private ConcurrentDictionary<string, bool> _cache;
        private long _creationTick;
        private int _ticksBeforeReset;

        // Overload used mainly for testing
        public FileExistenceCache(VirtualPathProvider virtualPathProvider, int milliSecondsBeforeReset = 1000)
            : this(() => virtualPathProvider, milliSecondsBeforeReset)
        {
            Contract.Assert(virtualPathProvider != null);
        }

        public FileExistenceCache(Func<VirtualPathProvider> virtualPathProviderFunc, int milliSecondsBeforeReset = 1000)
        {
            Contract.Assert(virtualPathProviderFunc != null);

            _virtualPathProviderFunc = virtualPathProviderFunc;
            _virtualPathFileExists = path => _virtualPathProviderFunc().FileExists(path);
            _ticksBeforeReset = milliSecondsBeforeReset * TicksPerMillisecond;
            Reset();
        }

        // Use the VPP returned by the HostingEnvironment unless a custom vpp is passed in (mainly for testing purposes)
        public VirtualPathProvider VirtualPathProvider
        {
            get { return _virtualPathProviderFunc(); }
        }

        public int MilliSecondsBeforeReset
        {
            get { return _ticksBeforeReset / TicksPerMillisecond; }
            internal set { _ticksBeforeReset = value * TicksPerMillisecond; }
        }

        internal IDictionary<string, bool> CacheInternal
        {
            get { return _cache; }
        }

        public bool TimeExceeded
        {
            get { return (DateTime.UtcNow.Ticks - Interlocked.Read(ref _creationTick)) > _ticksBeforeReset; }
        }

        public void Reset()
        {
            _cache = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

            DateTime now = DateTime.UtcNow;
            long tick = now.Ticks;

            Interlocked.Exchange(ref _creationTick, tick);
        }

        public bool FileExists(string virtualPath)
        {
            if (TimeExceeded)
            {
                Reset();
            }

            return _cache.GetOrAdd(virtualPath, _virtualPathFileExists);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc.
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File".
// You do not need to add suppressions to this file manually.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.WebPages.Html", Justification = "The namespace contains types specific to Razor. It allows a way for MVC Razor host to identify and remove the namespace")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Mvc", Justification = "This namespace contains TagBuilder and other types forwarded from System.Web.Mvc. The namespace must stay the way it is for type forwarding to work")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.WebPages.Instrumentation", Justification = "This namespace contains Instrumentation types and represents an isolated set of functionality.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "accesscontrolservice", Scope = "resource", Target = "System.Web.WebPages.Resources.WebPageResources.resources", Justification = "This is part of a URL.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "identityprovider", Scope = "resource", Target = "System.Web.WebPages.Resources.WebPageResources.resources", Justification = "This is part of a URL.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "nameidentifier", Scope = "resource", Target = "System.Web.WebPages.Resources.WebPageResources.resources", Justification = "This is part of a URL.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1703:ResourceStringsShouldBeSpelledCorrectly", MessageId = "xmlsoap", Scope = "resource", Target = "System.Web.WebPages.Resources.WebPageResources.resources", Justification = "This is part of a URL.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces", Scope = "type", Target = "System.Web.Helpers.Validation")]


================================================
FILE: src/System.Web.WebPages/HelperPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Security.Principal;
using System.Web.Caching;
using System.Web.WebPages.Html;
using System.Web.WebPages.Instrumentation;

namespace System.Web.WebPages
{
    [SuppressMessage("Microsoft.Design", "CA1053:StaticHolderTypesShouldNotHaveConstructors", Justification = "Even though this is essentially a static class, we need helper classes to inherit from it to get their static methods")]
    public class HelperPage
    {
        private static WebPageContext _pageContext;
        private static InstrumentationService _instrumentationService = null;

        private static InstrumentationService InstrumentationService
        {
            get
            {
                if (_instrumentationService == null)
                {
                    _instrumentationService = new InstrumentationService();
                }
                return _instrumentationService;
            }
        }

        public static HttpContextBase Context
        {
            get { return new HttpContextWrapper(HttpContext.Current); }
        }

        public static WebPageRenderingBase CurrentPage
        {
            get { return PageContext.Page; }
        }

        public static dynamic Page
        {
            get { return CurrentPage.Page; }
        }

        public static dynamic Model
        {
            get
            {
                WebPage currentWebPage = CurrentPage as WebPage;
                if (currentWebPage == null)
                {
                    return null;
                }
                return currentWebPage.Model;
            }
        }

        public static ModelStateDictionary ModelState
        {
            get
            {
                WebPage currentWebPage = CurrentPage as WebPage;
                if (currentWebPage == null)
                {
                    return null;
                }
                return currentWebPage.ModelState;
            }
        }

        public static HtmlHelper Html
        {
            get
            {
                WebPage currentWebPage = CurrentPage as WebPage;
                if (currentWebPage == null)
                {
                    return null;
                }
                return currentWebPage.Html;
            }
        }

        public static WebPageContext PageContext
        {
            get { return _pageContext ?? WebPageContext.Current; }
            set { _pageContext = value; }
        }

        public static HttpApplicationStateBase AppState
        {
            get
            {
                if (Context != null)
                {
                    return Context.Application;
                }
                return null;
            }
        }

        public static dynamic App
        {
            get { return CurrentPage.App; }
        }

        public static string VirtualPath
        {
            get { return PageContext.Page.VirtualPath; }
        }

        public static Cache Cache
        {
            get
            {
                if (Context != null)
                {
                    return Context.Cache;
                }
                return null;
            }
        }

        public static HttpRequestBase Request
        {
            get
            {
                if (Context != null)
                {
                    return Context.Request;
                }
                return null;
            }
        }

        public static HttpResponseBase Response
        {
            get
            {
                if (Context != null)
                {
                    return Context.Response;
                }
                return null;
            }
        }

        public static HttpServerUtilityBase Server
        {
            get
            {
                if (Context != null)
                {
                    return Context.Server;
                }
                return null;
            }
        }

        public static HttpSessionStateBase Session
        {
            get
            {
                if (Context != null)
                {
                    return Context.Session;
                }
                return null;
            }
        }

        public static IList<string> UrlData
        {
            get { return CurrentPage.UrlData; }
        }

        public static IPrincipal User
        {
            get { return CurrentPage.User; }
        }

        public static bool IsPost
        {
            get { return CurrentPage.IsPost; }
        }

        public static bool IsAjax
        {
            get { return CurrentPage.IsAjax; }
        }

        public static IDictionary<object, dynamic> PageData
        {
            get { return PageContext.PageData; }
        }

        protected static string HelperVirtualPath { get; set; }

        public static string Href(string path, params object[] pathParts)
        {
            return CurrentPage.Href(path, pathParts);
        }

        public static void WriteTo(TextWriter writer, object value)
        {
            WebPageBase.WriteTo(writer, value);
        }

        public static void WriteLiteralTo(TextWriter writer, object value)
        {
            WebPageBase.WriteLiteralTo(writer, value);
        }

        public static void WriteTo(TextWriter writer, HelperResult value)
        {
            WebPageBase.WriteTo(writer, value);
        }

        public static void WriteLiteralTo(TextWriter writer, HelperResult value)
        {
            WebPageBase.WriteLiteralTo(writer, value);
        }

        public static void WriteAttributeTo(TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values)
        {
            CurrentPage.WriteAttributeTo(VirtualPath, writer, name, prefix, suffix, values);
        }

        public static void BeginContext(string virtualPath, int startPosition, int length, bool isLiteral)
        {
            BeginContext(PageContext.Page.GetOutputWriter(), virtualPath, startPosition, length, isLiteral);
        }

        public static void BeginContext(TextWriter writer, string virtualPath, int startPosition, int length, bool isLiteral)
        {
            // Double check that the instrumentation service is active because WriteAttribute always calls this
            if (InstrumentationService.IsAvailable)
            {
                InstrumentationService.BeginContext(Context,
                                                    virtualPath,
                                                    writer,
                                                    startPosition,
                                                    length,
                                                    isLiteral);
            }
        }

        public static void EndContext(string virtualPath, int startPosition, int length, bool isLiteral)
        {
            EndContext(PageContext.Page.GetOutputWriter(), virtualPath, startPosition, length, isLiteral);
        }

        public static void EndContext(TextWriter writer, string virtualPath, int startPosition, int length, bool isLiteral)
        {
            // Double check that the instrumentation service is active because WriteAttribute always calls this
            if (InstrumentationService.IsAvailable)
            {
                InstrumentationService.EndContext(Context,
                                                  virtualPath,
                                                  writer,
                                                  startPosition,
                                                  length,
                                                  isLiteral);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/HelperResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;

namespace System.Web.WebPages
{
    public class HelperResult : IHtmlString
    {
        private readonly Action<TextWriter> _action;

        public HelperResult(Action<TextWriter> action)
        {
            if (action == null)
            {
                throw new ArgumentNullException("action");
            }
            _action = action;
        }

        public string ToHtmlString()
        {
            return ToString();
        }

        public override string ToString()
        {
            using (var writer = new StringWriter(CultureInfo.InvariantCulture))
            {
                _action(writer);
                return writer.ToString();
            }
        }

        public void WriteTo(TextWriter writer)
        {
            _action(writer);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiForgery.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Web.Helpers.AntiXsrf;
using System.Web.Helpers.Claims;
using System.Web.Mvc;
using System.Web.WebPages.Resources;

namespace System.Web.Helpers
{
    /// <summary>
    /// Provides access to the anti-forgery system, which provides protection against
    /// Cross-site Request Forgery (XSRF, also called CSRF) attacks.
    /// </summary>
    public static class AntiForgery
    {
        private static readonly AntiForgeryWorker _worker = CreateSingletonAntiForgeryWorker();

        private static AntiForgeryWorker CreateSingletonAntiForgeryWorker()
        {
            // initialize the dependency chain

            IAntiForgeryConfig config = new AntiForgeryConfigWrapper();
            IAntiForgeryTokenSerializer serializer = new AntiForgeryTokenSerializer(MachineKey45CryptoSystem.Instance);
            ITokenStore tokenStore = new AntiForgeryTokenStore(config, serializer);
            IClaimUidExtractor claimUidExtractor = new ClaimUidExtractor(config, ClaimsIdentityConverter.Default);
            ITokenValidator tokenValidator = new TokenValidator(config, claimUidExtractor);

            return new AntiForgeryWorker(serializer, config, tokenStore, tokenValidator);
        }

        /// <summary>
        /// Generates an anti-forgery token for this request. This token can
        /// be validated by calling the Validate() method.
        /// </summary>
        /// <returns>An HTML string corresponding to an &lt;input type="hidden"&gt;
        /// element. This element should be put inside a &lt;form&gt;.</returns>
        /// <remarks>
        /// This method has a side effect: it may set a response cookie.
        /// </remarks>
        public static HtmlString GetHtml()
        {
            if (HttpContext.Current == null)
            {
                throw new ArgumentException(WebPageResources.HttpContextUnavailable);
            }

            TagBuilder retVal = _worker.GetFormInputElement(new HttpContextWrapper(HttpContext.Current));
            return retVal.ToHtmlString(TagRenderMode.SelfClosing);
        }

        /// <summary>
        /// Generates an anti-forgery token pair (cookie and form token) for this request.
        /// This method is similar to GetHtml(), but this method gives the caller control
        /// over how to persist the returned values. To validate these tokens, call the
        /// appropriate overload of Validate.
        /// </summary>
        /// <param name="oldCookieToken">The anti-forgery token - if any - that already existed
        /// for this request. May be null. The anti-forgery system will try to reuse this cookie
        /// value when generating a matching form token.</param>
        /// <param name="newCookieToken">Will contain a new cookie value if the old cookie token
        /// was null or invalid. If this value is non-null when the method completes, the caller
        /// must persist this value in the form of a response cookie, and the existing cookie value
        /// should be discarded. If this value is null when the method completes, the existing
        /// cookie value was valid and needn't be modified.</param>
        /// <param name="formToken">The value that should be stored in the &lt;form&gt;. The caller
        /// should take care not to accidentally swap the cookie and form tokens.</param>
        /// <remarks>
        /// Unlike the GetHtml() method, this method has no side effect. The caller
        /// is responsible for setting the response cookie and injecting the returned
        /// form token as appropriate.
        /// </remarks>
        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "1#", Justification = "Method is intended for advanced audiences.")]
        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "2#", Justification = "Method is intended for advanced audiences.")]
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public static void GetTokens(string oldCookieToken, out string newCookieToken, out string formToken)
        {
            if (HttpContext.Current == null)
            {
                throw new ArgumentException(WebPageResources.HttpContextUnavailable);
            }

            _worker.GetTokens(new HttpContextWrapper(HttpContext.Current), oldCookieToken, out newCookieToken, out formToken);
        }

        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AdditionalDataProvider", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "AntiForgeryConfig", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "GetHtml", Justification = "API name.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "httpCookies", Justification = "API name.")]
        [Obsolete("This method is deprecated. Use the GetHtml() method instead. To specify a custom domain for the generated cookie, use the <httpCookies> configuration element. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.", error: true)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static HtmlString GetHtml(HttpContextBase httpContext, string salt, string domain, string path)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }

            if (!String.IsNullOrEmpty(salt) || !String.IsNullOrEmpty(domain) || !String.IsNullOrEmpty(path))
            {
                throw new NotSupportedException("This method is deprecated. Use the GetHtml() method instead. To specify a custom domain for the generated cookie, use the <httpCookies> configuration element. To specify custom data to be embedded within the token, use the static AntiForgeryConfig.AdditionalDataProvider property.");
            }

            TagBuilder retVal = _worker.GetFormInputElement(httpContext);
            return retVal.ToHtmlString(TagRenderMode.SelfClosing);
        }

        /// <summary>
        /// Validates an anti-forgery token that was supplied for this request.
        /// The anti-forgery token may be generated by calling GetHtml().
        /// </summary>
        /// <remarks>
        /// Throws an HttpAntiForgeryException if validation fails.
        /// </remarks>
        public static void Validate()
        {
            if (HttpContext.Current == null)
            {
                throw new ArgumentException(WebPageResources.HttpContextUnavailable);
            }

            _worker.Validate(new HttpContextWrapper(HttpContext.Current));
        }

        /// <summary>
        /// Validates an anti-forgery token pair that was generated by the GetTokens method.
        /// </summary>
        /// <param name="cookieToken">The token that was supplied in the request cookie.</param>
        /// <param name="formToken">The token that was supplied in the request form body.</param>
        /// <remarks>
        /// Throws an HttpAntiForgeryException if validation fails.
        /// </remarks>
        [EditorBrowsable(EditorBrowsableState.Advanced)]
        public static void Validate(string cookieToken, string formToken)
        {
            if (HttpContext.Current == null)
            {
                throw new ArgumentException(WebPageResources.HttpContextUnavailable);
            }

            _worker.Validate(new HttpContextWrapper(HttpContext.Current), cookieToken, formToken);
        }

        [Obsolete("This method is deprecated. Use the Validate() method instead.", error: true)]
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static void Validate(HttpContextBase httpContext, string salt)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }

            if (!String.IsNullOrEmpty(salt))
            {
                throw new NotSupportedException("This method is deprecated. Use the Validate() method instead.");
            }

            _worker.Validate(httpContext);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiForgeryConfig.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Text;

namespace System.Web.Helpers
{
    /// <summary>
    /// Provides programmatic configuration for the anti-forgery token system.
    /// </summary>
    public static class AntiForgeryConfig
    {
        internal const string AntiForgeryTokenFieldName = "__RequestVerificationToken";

        private static string _cookieName;
        private static string _uniqueClaimTypeIdentifier;

        /// <summary>
        /// Specifies an object that can provide additional data to put into all
        /// generated tokens and that can validate additional data in incoming
        /// tokens.
        /// </summary>
        public static IAntiForgeryAdditionalDataProvider AdditionalDataProvider
        {
            get;
            set;
        }

        /// <summary>
        /// Specifies the name of the cookie that is used by the anti-forgery
        /// system.
        /// </summary>
        /// <remarks>
        /// If an explicit name is not provided, the system will automatically
        /// generate a name.
        /// </remarks>
        public static string CookieName
        {
            get
            {
                if (_cookieName == null)
                {
                    _cookieName = GetAntiForgeryCookieName();
                }
                return _cookieName;
            }
            set
            {
                _cookieName = value;
            }
        }

        /// <summary>
        /// Specifies whether SSL is required for the anti-forgery system
        /// to operate. If this setting is 'true' and a non-SSL request
        /// comes into the system, all anti-forgery APIs will fail.
        /// </summary>
        public static bool RequireSsl
        {
            get;
            set;
        }

        /// <summary>
        /// Specifies whether to suppress the generation of X-Frame-Options header
        /// which is used to prevent ClickJacking. By default, the X-Frame-Options
        /// header is generated with the value SAMEORIGIN. If this setting is 'true', 
        /// the X-Frame-Options header will not be generated for the response.
        /// </summary>
        public static bool SuppressXFrameOptionsHeader
        {
            get;
            set;
        }

        /// <summary>
        /// Specifies whether the anti-forgery system should skip checking
        /// for conditions that might indicate misuse of the system. Please
        /// use caution when setting this switch, as improper use could open
        /// security holes in the application.
        /// </summary>
        /// <remarks>
        /// Setting this switch will disable several checks, including:
        /// - Identity.IsAuthenticated = true without Identity.Name being set
        /// - special-casing claims-based identities
        /// </remarks>
        [EditorBrowsable(EditorBrowsableState.Never)]
        public static bool SuppressIdentityHeuristicChecks
        {
            get;
            set;
        }

        /// <summary>
        /// If claims-based authorization is in use, specifies the claim
        /// type from the identity that is used to uniquely identify the
        /// user. If this property is set, all claims-based identities
        /// <em>must</em> return unique values for this claim type.
        /// </summary>
        /// <remarks>
        /// If claims-based authorization is in use and this property has
        /// not been set, the anti-forgery system will automatically look
        /// for claim types "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier"
        /// and "http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider".
        /// </remarks>
        public static string UniqueClaimTypeIdentifier
        {
            get
            {
                return _uniqueClaimTypeIdentifier ?? String.Empty;
            }
            set
            {
                _uniqueClaimTypeIdentifier = value;
            }
        }

        private static string GetAntiForgeryCookieName()
        {
            return GetAntiForgeryCookieName(HttpRuntime.AppDomainAppVirtualPath);
        }

        // If the app path is provided, we're generating a cookie name rather than a field name, and the cookie names should
        // be unique so that a development server cookie and an IIS cookie - both running on localhost - don't stomp on
        // each other.
        internal static string GetAntiForgeryCookieName(string appPath)
        {
            if (String.IsNullOrEmpty(appPath) || appPath == "/")
            {
                return AntiForgeryTokenFieldName;
            }
            else
            {
                return AntiForgeryTokenFieldName + "_" + HttpServerUtility.UrlTokenEncode(Encoding.UTF8.GetBytes(appPath));
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/AntiForgeryConfigWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf
{
    internal sealed class AntiForgeryConfigWrapper : IAntiForgeryConfig
    {
        public IAntiForgeryAdditionalDataProvider AdditionalDataProvider
        {
            get
            {
                return AntiForgeryConfig.AdditionalDataProvider;
            }
        }

        public string CookieName
        {
            get { return AntiForgeryConfig.CookieName; }
        }

        public string FormFieldName
        {
            get { return AntiForgeryConfig.AntiForgeryTokenFieldName; }
        }

        public bool RequireSSL
        {
            get { return AntiForgeryConfig.RequireSsl; }
        }

        public bool SuppressIdentityHeuristicChecks
        {
            get { return AntiForgeryConfig.SuppressIdentityHeuristicChecks; }
        }

        public string UniqueClaimTypeIdentifier
        {
            get { return AntiForgeryConfig.UniqueClaimTypeIdentifier; }
        }

        public bool SuppressXFrameOptionsHeader
        {
            get { return AntiForgeryConfig.SuppressXFrameOptionsHeader; }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/AntiForgeryToken.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf
{
    // Represents the security token for the Anti-XSRF system.
    // The token is a random 128-bit value that correlates the session with the request body.
    internal sealed class AntiForgeryToken
    {
        internal const int SecurityTokenBitLength = 128;
        internal const int ClaimUidBitLength = 256;

        private string _additionalData;
        private BinaryBlob _securityToken;
        private string _username;

        public string AdditionalData
        {
            get
            {
                return _additionalData ?? String.Empty;
            }
            set
            {
                _additionalData = value;
            }
        }

        public BinaryBlob ClaimUid { get; set; }

        public bool IsSessionToken { get; set; }

        public BinaryBlob SecurityToken
        {
            get
            {
                if (_securityToken == null)
                {
                    _securityToken = new BinaryBlob(SecurityTokenBitLength);
                }
                return _securityToken;
            }
            set
            {
                _securityToken = value;
            }
        }

        public string Username
        {
            get
            {
                return _username ?? String.Empty;
            }
            set
            {
                _username = value;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/AntiForgeryTokenSerializer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.IO;
using System.Web.Mvc;

namespace System.Web.Helpers.AntiXsrf
{
    internal sealed class AntiForgeryTokenSerializer : IAntiForgeryTokenSerializer
    {
        private const byte TokenVersion = 0x01;
        private readonly ICryptoSystem _cryptoSystem;

        internal AntiForgeryTokenSerializer(ICryptoSystem cryptoSystem)
        {
            _cryptoSystem = cryptoSystem;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Failures are homogenized; caller handles appropriately.")]
        [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "MemoryStream is safe for multi-dispose.")]
        public AntiForgeryToken Deserialize(string serializedToken)
        {
            try
            {
                using (MemoryStream stream = new MemoryStream(_cryptoSystem.Unprotect(serializedToken)))
                {
                    using (BinaryReader reader = new BinaryReader(stream))
                    {
                        AntiForgeryToken token = DeserializeImpl(reader);
                        if (token != null)
                        {
                            return token;
                        }
                    }
                }
            }
            catch
            {
                // swallow all exceptions - homogenize error if something went wrong
            }

            // if we reached this point, something went wrong deserializing
            throw HttpAntiForgeryException.CreateDeserializationFailedException();
        }

        /* The serialized format of the anti-XSRF token is as follows:
         * Version: 1 byte integer
         * SecurityToken: 16 byte binary blob
         * IsSessionToken: 1 byte Boolean
         * [if IsSessionToken = true]
         *   +- IsClaimsBased: 1 byte Boolean
         *   |  [if IsClaimsBased = true]
         *   |    `- ClaimUid: 32 byte binary blob
         *   |  [if IsClaimsBased = false]
         *   |    `- Username: UTF-8 string with 7-bit integer length prefix
         *   `- AdditionalData: UTF-8 string with 7-bit integer length prefix
         */
        private static AntiForgeryToken DeserializeImpl(BinaryReader reader)
        {
            // we can only consume tokens of the same serialized version that we generate
            byte embeddedVersion = reader.ReadByte();
            if (embeddedVersion != TokenVersion)
            {
                return null;
            }

            AntiForgeryToken deserializedToken = new AntiForgeryToken();
            byte[] securityTokenBytes = reader.ReadBytes(AntiForgeryToken.SecurityTokenBitLength / 8);
            deserializedToken.SecurityToken = new BinaryBlob(AntiForgeryToken.SecurityTokenBitLength, securityTokenBytes);
            deserializedToken.IsSessionToken = reader.ReadBoolean();

            if (!deserializedToken.IsSessionToken)
            {
                bool isClaimsBased = reader.ReadBoolean();
                if (isClaimsBased)
                {
                    byte[] claimUidBytes = reader.ReadBytes(AntiForgeryToken.ClaimUidBitLength / 8);
                    deserializedToken.ClaimUid = new BinaryBlob(AntiForgeryToken.ClaimUidBitLength, claimUidBytes);
                }
                else
                {
                    deserializedToken.Username = reader.ReadString();
                }

                deserializedToken.AdditionalData = reader.ReadString();
            }

            // if there's still unconsumed data in the stream, fail
            if (reader.BaseStream.ReadByte() != -1)
            {
                return null;
            }

            // success
            return deserializedToken;
        }

        [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "MemoryStream is safe for multi-dispose.")]
        public string Serialize(AntiForgeryToken token)
        {
            Contract.Assert(token != null);

            using (MemoryStream stream = new MemoryStream())
            {
                using (BinaryWriter writer = new BinaryWriter(stream))
                {
                    writer.Write(TokenVersion);
                    writer.Write(token.SecurityToken.GetData());
                    writer.Write(token.IsSessionToken);

                    if (!token.IsSessionToken)
                    {
                        if (token.ClaimUid != null)
                        {
                            writer.Write(true /* isClaimsBased */);
                            writer.Write(token.ClaimUid.GetData());
                        }
                        else
                        {
                            writer.Write(false /* isClaimsBased */);
                            writer.Write(token.Username);
                        }

                        writer.Write(token.AdditionalData);
                    }

                    writer.Flush();
                    return _cryptoSystem.Protect(stream.ToArray());
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/AntiForgeryTokenStore.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Web.Mvc;

namespace System.Web.Helpers.AntiXsrf
{
    // Saves anti-XSRF tokens split between HttpRequest.Cookies and HttpRequest.Form
    internal sealed class AntiForgeryTokenStore : ITokenStore
    {
        private readonly IAntiForgeryConfig _config;
        private readonly IAntiForgeryTokenSerializer _serializer;

        internal AntiForgeryTokenStore(IAntiForgeryConfig config, IAntiForgeryTokenSerializer serializer)
        {
            _config = config;
            _serializer = serializer;
        }

        public AntiForgeryToken GetCookieToken(HttpContextBase httpContext)
        {
            HttpCookie cookie = httpContext.Request.Cookies[_config.CookieName];
            if (cookie == null || String.IsNullOrEmpty(cookie.Value))
            {
                // did not exist
                return null;
            }

            return _serializer.Deserialize(cookie.Value);
        }

        public AntiForgeryToken GetFormToken(HttpContextBase httpContext)
        {
            string value = httpContext.Request.Form[_config.FormFieldName];
            if (String.IsNullOrEmpty(value))
            {
                // did not exist
                return null;
            }

            return _serializer.Deserialize(value);
        }

        public void SaveCookieToken(HttpContextBase httpContext, AntiForgeryToken token)
        {
            string serializedToken = _serializer.Serialize(token);
            HttpCookie newCookie = new HttpCookie(_config.CookieName, serializedToken)
            {
                HttpOnly = true
            };

            // Note: don't use "newCookie.Secure = _config.RequireSSL;" since the default
            // value of newCookie.Secure is automatically populated from the <httpCookies>
            // config element.
            if (_config.RequireSSL)
            {
                newCookie.Secure = true;
            }

            httpContext.Response.Cookies.Set(newCookie);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/AntiForgeryWorker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Security.Principal;
using System.Web.Mvc;
using System.Web.WebPages.Resources;

namespace System.Web.Helpers.AntiXsrf
{
    internal sealed class AntiForgeryWorker
    {
        private readonly IAntiForgeryConfig _config;
        private readonly IAntiForgeryTokenSerializer _serializer;
        private readonly ITokenStore _tokenStore;
        private readonly ITokenValidator _validator;

        internal AntiForgeryWorker(IAntiForgeryTokenSerializer serializer, IAntiForgeryConfig config, ITokenStore tokenStore, ITokenValidator validator)
        {
            _serializer = serializer;
            _config = config;
            _tokenStore = tokenStore;
            _validator = validator;
        }

        private void CheckSSLConfig(HttpContextBase httpContext)
        {
            if (_config.RequireSSL && !httpContext.Request.IsSecureConnection)
            {
                throw new InvalidOperationException(WebPageResources.AntiForgeryWorker_RequireSSL);
            }
        }

        private AntiForgeryToken DeserializeToken(string serializedToken)
        {
            return (!String.IsNullOrEmpty(serializedToken))
                ? _serializer.Deserialize(serializedToken)
                : null;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Caller will just regenerate token in case of failure.")]
        private AntiForgeryToken DeserializeTokenNoThrow(string serializedToken)
        {
            try
            {
                return DeserializeToken(serializedToken);
            }
            catch
            {
                // ignore failures since we'll just generate a new token
                return null;
            }
        }

        private static IIdentity ExtractIdentity(HttpContextBase httpContext)
        {
            if (httpContext != null)
            {
                IPrincipal user = httpContext.User;
                if (user != null)
                {
                    return user.Identity;
                }
            }
            return null;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Caller will just regenerate token in case of failure.")]
        private AntiForgeryToken GetCookieTokenNoThrow(HttpContextBase httpContext)
        {
            try
            {
                return _tokenStore.GetCookieToken(httpContext);
            }
            catch
            {
                // ignore failures since we'll just generate a new token
                return null;
            }
        }

        // [ ENTRY POINT ]
        // Generates an anti-XSRF token pair for the current user. The return
        // value is the hidden input form element that should be rendered in
        // the <form>. This method has a side effect: it may set a response
        // cookie.
        public TagBuilder GetFormInputElement(HttpContextBase httpContext)
        {
            CheckSSLConfig(httpContext);

            AntiForgeryToken oldCookieToken = GetCookieTokenNoThrow(httpContext);
            AntiForgeryToken newCookieToken, formToken;
            GetTokens(httpContext, oldCookieToken, out newCookieToken, out formToken);

            if (newCookieToken != null)
            {
                // If a new cookie was generated, persist it.
                _tokenStore.SaveCookieToken(httpContext, newCookieToken);
            }

            if (!_config.SuppressXFrameOptionsHeader)
            {
                // Adding X-Frame-Options header to prevent ClickJacking. See
                // http://tools.ietf.org/html/draft-ietf-websec-x-frame-options-10
                // for more information.
                const string FrameHeaderName = "X-Frame-Options";
                if (httpContext.Response.Headers[FrameHeaderName] == null)
                {
                    httpContext.Response.AddHeader(FrameHeaderName, "SAMEORIGIN");
                }
            }

            // <input type="hidden" name="__AntiForgeryToken" value="..." />
            TagBuilder retVal = new TagBuilder("input");
            retVal.Attributes["type"] = "hidden";
            retVal.Attributes["name"] = _config.FormFieldName;
            retVal.Attributes["value"] = _serializer.Serialize(formToken);
            return retVal;
        }

        // [ ENTRY POINT ]
        // Generates a (cookie, form) serialized token pair for the current user.
        // The caller may specify an existing cookie value if one exists. If the
        // 'new cookie value' out param is non-null, the caller *must* persist
        // the new value to cookie storage since the original value was null or
        // invalid. This method is side-effect free.
        public void GetTokens(HttpContextBase httpContext, string serializedOldCookieToken, out string serializedNewCookieToken, out string serializedFormToken)
        {
            CheckSSLConfig(httpContext);

            AntiForgeryToken oldCookieToken = DeserializeTokenNoThrow(serializedOldCookieToken);
            AntiForgeryToken newCookieToken, formToken;
            GetTokens(httpContext, oldCookieToken, out newCookieToken, out formToken);

            serializedNewCookieToken = Serialize(newCookieToken);
            serializedFormToken = Serialize(formToken);
        }

        private void GetTokens(HttpContextBase httpContext, AntiForgeryToken oldCookieToken, out AntiForgeryToken newCookieToken, out AntiForgeryToken formToken)
        {
            newCookieToken = null;
            if (!_validator.IsCookieTokenValid(oldCookieToken))
            {
                // Need to make sure we're always operating with a good cookie token.
                oldCookieToken = newCookieToken = _validator.GenerateCookieToken();
            }

            Contract.Assert(_validator.IsCookieTokenValid(oldCookieToken));
            formToken = _validator.GenerateFormToken(httpContext, ExtractIdentity(httpContext), oldCookieToken);
        }

        private string Serialize(AntiForgeryToken token)
        {
            return (token != null) ? _serializer.Serialize(token) : null;
        }

        // [ ENTRY POINT ]
        // Given an HttpContext, validates that the anti-XSRF tokens contained
        // in the cookies & form are OK for this request.
        public void Validate(HttpContextBase httpContext)
        {
            CheckSSLConfig(httpContext);

            // Extract cookie & form tokens
            AntiForgeryToken cookieToken = _tokenStore.GetCookieToken(httpContext);
            AntiForgeryToken formToken = _tokenStore.GetFormToken(httpContext);

            // Validate
            _validator.ValidateTokens(httpContext, ExtractIdentity(httpContext), cookieToken, formToken);
        }

        // [ ENTRY POINT ]
        // Given the serialized string representations of a cookie & form token,
        // validates that the pair is OK for this request.
        public void Validate(HttpContextBase httpContext, string cookieToken, string formToken)
        {
            CheckSSLConfig(httpContext);

            // Extract cookie & form tokens
            AntiForgeryToken deserializedCookieToken = DeserializeToken(cookieToken);
            AntiForgeryToken deserializedFormToken = DeserializeToken(formToken);

            // Validate
            _validator.ValidateTokens(httpContext, ExtractIdentity(httpContext), deserializedCookieToken, deserializedFormToken);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/BinaryBlob.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Diagnostics.Contracts;
using System.Globalization;
using System.Security.Cryptography;
using System.Text;

namespace System.Web.Helpers.AntiXsrf
{
    // Represents a binary blob (token) that contains random data.
    // Useful for binary data inside a serialized stream.
    [DebuggerDisplay("{DebuggerString}")]
    internal sealed class BinaryBlob : IEquatable<BinaryBlob>
    {
        private static readonly RNGCryptoServiceProvider _prng = new RNGCryptoServiceProvider();

        private readonly byte[] _data;

        // Generates a new token using a specified bit length.
        public BinaryBlob(int bitLength)
            : this(bitLength, GenerateNewToken(bitLength))
        {
        }

        // Generates a token using an existing binary value.
        public BinaryBlob(int bitLength, byte[] data)
        {
            if (bitLength < 32 || bitLength % 8 != 0)
            {
                throw new ArgumentOutOfRangeException("bitLength");
            }
            if (data == null || data.Length != bitLength / 8)
            {
                throw new ArgumentOutOfRangeException("data");
            }

            _data = data;
        }

        public int BitLength
        {
            get
            {
                return checked(_data.Length * 8);
            }
        }

        [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode", Justification = "Called by debugger.")]
        private string DebuggerString
        {
            get
            {
                StringBuilder sb = new StringBuilder("0x", 2 + (_data.Length * 2));
                for (int i = 0; i < _data.Length; i++)
                {
                    sb.AppendFormat(CultureInfo.InvariantCulture, "{0:x2}", _data[i]);
                }
                return sb.ToString();
            }
        }

        public override bool Equals(object obj)
        {
            return Equals(obj as BinaryBlob);
        }

        public bool Equals(BinaryBlob other)
        {
            if (other == null)
            {
                return false;
            }

            Contract.Assert(this._data.Length == other._data.Length);
            return CryptoUtil.AreByteArraysEqual(this._data, other._data);
        }

        public byte[] GetData()
        {
            return _data;
        }

        public override int GetHashCode()
        {
            // Since data should contain uniformly-distributed entropy, the
            // first 32 bits can serve as the hash code.
            Contract.Assert(_data != null && _data.Length >= (32 / 8));
            return BitConverter.ToInt32(_data, 0);
        }

        private static byte[] GenerateNewToken(int bitLength)
        {
            byte[] data = new byte[bitLength / 8];
            _prng.GetBytes(data);
            return data;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/ClaimUidExtractor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Linq;
using System.Security.Principal;
using System.Web.Helpers.Claims;
using System.Web.WebPages.Resources;

namespace System.Web.Helpers.AntiXsrf
{
    internal sealed class ClaimUidExtractor : IClaimUidExtractor
    {
        internal const string NameIdentifierClaimType = "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier";
        internal const string IdentityProviderClaimType = "http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider";

        private readonly ClaimsIdentityConverter _claimsIdentityConverter;
        private readonly IAntiForgeryConfig _config;

        internal ClaimUidExtractor(IAntiForgeryConfig config, ClaimsIdentityConverter claimsIdentityConverter)
        {
            _config = config;
            _claimsIdentityConverter = claimsIdentityConverter;
        }

        public BinaryBlob ExtractClaimUid(IIdentity identity)
        {
            if (identity == null || !identity.IsAuthenticated || _config.SuppressIdentityHeuristicChecks)
            {
                // Skip anonymous users
                // Skip when claims-based checks are disabled
                return null;
            }

            ClaimsIdentity claimsIdentity = _claimsIdentityConverter.TryConvert(identity);
            if (claimsIdentity == null)
            {
                // not a claims-based identity
                return null;
            }

            string[] uniqueIdentifierParameters = GetUniqueIdentifierParameters(claimsIdentity, _config.UniqueClaimTypeIdentifier);
            byte[] claimUidBytes = CryptoUtil.ComputeSHA256(uniqueIdentifierParameters);
            return new BinaryBlob(256, claimUidBytes);
        }

        internal static string[] GetUniqueIdentifierParameters(ClaimsIdentity claimsIdentity, string uniqueClaimTypeIdentifier)
        {
            var claims = claimsIdentity.GetClaims();

            // The application developer might not want to use our default behavior
            // and instead might want us to use a claim he knows is unique within
            // the security realm of his application. (Perhaps he has crafted this
            // claim himself.)
            if (!String.IsNullOrEmpty(uniqueClaimTypeIdentifier))
            {
                Claim matchingClaim = claims.SingleOrDefault(claim => String.Equals(uniqueClaimTypeIdentifier, claim.ClaimType, StringComparison.Ordinal));
                if (matchingClaim == null || String.IsNullOrEmpty(matchingClaim.Value))
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebPageResources.ClaimUidExtractor_ClaimNotPresent, uniqueClaimTypeIdentifier));
                }

                return new string[]
                {
                    uniqueClaimTypeIdentifier,
                    matchingClaim.Value
                };
            }

            // By default, we look for 'nameIdentifier' and 'identityProvider' claims.
            // For a correctly configured ACS consumer, this tuple will uniquely
            // identify a user of the application. We assume that a well-behaved
            // identity provider will never assign the same name identifier to multiple
            // users within its security realm, and we assume that ACS has been
            // configured so that each identity provider has a unique 'identityProvider'
            // claim.
            Claim nameIdentifierClaim = claims.SingleOrDefault(claim => String.Equals(NameIdentifierClaimType, claim.ClaimType, StringComparison.Ordinal));
            Claim identityProviderClaim = claims.SingleOrDefault(claim => String.Equals(IdentityProviderClaimType, claim.ClaimType, StringComparison.Ordinal));
            if (nameIdentifierClaim == null || String.IsNullOrEmpty(nameIdentifierClaim.Value)
                || identityProviderClaim == null || String.IsNullOrEmpty(identityProviderClaim.Value))
            {
                throw new InvalidOperationException(WebPageResources.ClaimUidExtractor_DefaultClaimsNotPresent);
            }

            return new string[]
            {
                NameIdentifierClaimType,
                nameIdentifierClaim.Value,
                IdentityProviderClaimType,
                identityProviderClaim.Value
            };
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/IAntiForgeryConfig.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf
{
    // Provides configuration information about the anti-forgery system.
    internal interface IAntiForgeryConfig
    {
        // Provides additional data to go into the tokens.
        IAntiForgeryAdditionalDataProvider AdditionalDataProvider { get; }

        // Name of the cookie to use.
        string CookieName { get; }

        // Name of the form field to use.
        string FormFieldName { get; }

        // Whether SSL is mandatory for this request.
        bool RequireSSL { get; }

        // Skip ClaimsIdentity & related logic.
        bool SuppressIdentityHeuristicChecks { get; }

        // ClaimType to use for ClaimsIdentity.
        string UniqueClaimTypeIdentifier { get; }

        // Skip X-FRAME-OPTIONS header.
        bool SuppressXFrameOptionsHeader { get; }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/IAntiForgeryTokenSerializer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf
{
    // Abstracts out the serialization process for an anti-forgery token
    internal interface IAntiForgeryTokenSerializer
    {
        AntiForgeryToken Deserialize(string serializedToken);
        string Serialize(AntiForgeryToken token);
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/IClaimUidExtractor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Principal;

namespace System.Web.Helpers.AntiXsrf
{
    // Can extract unique identifers for a claims-based identity
    internal interface IClaimUidExtractor
    {
        BinaryBlob ExtractClaimUid(IIdentity identity);
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/ICryptoSystem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf
{
    // Provides an abstraction around the cryptographic subsystem for the anti-XSRF helpers.
    internal interface ICryptoSystem
    {
        string Protect(byte[] data);
        byte[] Unprotect(string protectedData);
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/ITokenStore.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf
{
    // Provides an abstraction around how tokens are persisted and retrieved for a request
    internal interface ITokenStore
    {
        AntiForgeryToken GetCookieToken(HttpContextBase httpContext);
        AntiForgeryToken GetFormToken(HttpContextBase httpContext);
        void SaveCookieToken(HttpContextBase httpContext, AntiForgeryToken token);
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/ITokenValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Principal;

namespace System.Web.Helpers.AntiXsrf
{
    // Provides an abstraction around something that can validate anti-XSRF tokens
    internal interface ITokenValidator
    {
        // Generates a new random cookie token.
        AntiForgeryToken GenerateCookieToken();

        // Given a cookie token, generates a corresponding form token.
        // The incoming cookie token must be valid.
        AntiForgeryToken GenerateFormToken(HttpContextBase httpContext, IIdentity identity, AntiForgeryToken cookieToken);

        // Determines whether an existing cookie token is valid (well-formed).
        // If it is not, the caller must call GenerateCookieToken() before calling GenerateFormToken().
        bool IsCookieTokenValid(AntiForgeryToken cookieToken);

        // Validates a (cookie, form) token pair.
        void ValidateTokens(HttpContextBase httpContext, IIdentity identity, AntiForgeryToken cookieToken, AntiForgeryToken formToken);
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/MachineKey45CryptoSystem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Security;

namespace System.Web.Helpers.AntiXsrf
{
    // Interfaces with the System.Web.MachineKey static class using the 4.5 Protect / Unprotect methods.
    internal sealed class MachineKey45CryptoSystem : ICryptoSystem
    {
        private static readonly string[] _purposes = new string[] { "System.Web.Helpers.AntiXsrf.AntiForgeryToken.v1" };
        private static readonly MachineKey45CryptoSystem _singletonInstance = GetSingletonInstance();

        public static MachineKey45CryptoSystem Instance
        {
            get
            {
                return _singletonInstance;
            }
        }

        private static MachineKey45CryptoSystem GetSingletonInstance()
        {
            return new MachineKey45CryptoSystem();
        }

        public string Protect(byte[] data)
        {
            byte[] rawProtectedBytes = MachineKey.Protect(data, _purposes);
            return HttpServerUtility.UrlTokenEncode(rawProtectedBytes);
        }

        public byte[] Unprotect(string protectedData)
        {
            byte[] rawProtectedBytes = HttpServerUtility.UrlTokenDecode(protectedData);
            return MachineKey.Unprotect(rawProtectedBytes, _purposes);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/AntiXsrf/TokenValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.Globalization;
using System.Security.Principal;
using System.Web.Mvc;
using System.Web.WebPages.Resources;

namespace System.Web.Helpers.AntiXsrf
{
    internal sealed class TokenValidator : ITokenValidator
    {
        private readonly IClaimUidExtractor _claimUidExtractor;
        private readonly IAntiForgeryConfig _config;

        internal TokenValidator(IAntiForgeryConfig config, IClaimUidExtractor claimUidExtractor)
        {
            _config = config;
            _claimUidExtractor = claimUidExtractor;
        }

        public AntiForgeryToken GenerateCookieToken()
        {
            return new AntiForgeryToken()
            {
                // SecurityToken will be populated automatically.
                IsSessionToken = true
            };
        }

        public AntiForgeryToken GenerateFormToken(HttpContextBase httpContext, IIdentity identity, AntiForgeryToken cookieToken)
        {
            Contract.Assert(IsCookieTokenValid(cookieToken));

            AntiForgeryToken formToken = new AntiForgeryToken()
            {
                SecurityToken = cookieToken.SecurityToken,
                IsSessionToken = false
            };

            bool requireAuthenticatedUserHeuristicChecks = false;
            // populate Username and ClaimUid
            if (identity != null && identity.IsAuthenticated)
            {
                if (!_config.SuppressIdentityHeuristicChecks)
                {
                    // If the user is authenticated and heuristic checks are not suppressed,
                    // then Username, ClaimUid, or AdditionalData must be set.
                    requireAuthenticatedUserHeuristicChecks = true;
                }

                formToken.ClaimUid = _claimUidExtractor.ExtractClaimUid(identity);
                if (formToken.ClaimUid == null)
                {
                    formToken.Username = identity.Name;
                }
            }

            // populate AdditionalData
            if (_config.AdditionalDataProvider != null)
            {
                formToken.AdditionalData = _config.AdditionalDataProvider.GetAdditionalData(httpContext);
            }

            if (requireAuthenticatedUserHeuristicChecks
                && String.IsNullOrEmpty(formToken.Username)
                && formToken.ClaimUid == null
                && String.IsNullOrEmpty(formToken.AdditionalData))
            {
                // Application says user is authenticated, but we have no identifier for the user.
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                    WebPageResources.TokenValidator_AuthenticatedUserWithoutUsername, identity.GetType()));
            }

            return formToken;
        }

        public bool IsCookieTokenValid(AntiForgeryToken cookieToken)
        {
            return (cookieToken != null && cookieToken.IsSessionToken);
        }

        public void ValidateTokens(HttpContextBase httpContext, IIdentity identity, AntiForgeryToken sessionToken, AntiForgeryToken fieldToken)
        {
            // Were the tokens even present at all?
            if (sessionToken == null)
            {
                throw HttpAntiForgeryException.CreateCookieMissingException(_config.CookieName);
            }
            if (fieldToken == null)
            {
                throw HttpAntiForgeryException.CreateFormFieldMissingException(_config.FormFieldName);
            }

            // Do the tokens have the correct format?
            if (!sessionToken.IsSessionToken || fieldToken.IsSessionToken)
            {
                throw HttpAntiForgeryException.CreateTokensSwappedException(_config.CookieName, _config.FormFieldName);
            }

            // Are the security tokens embedded in each incoming token identical?
            if (!Equals(sessionToken.SecurityToken, fieldToken.SecurityToken))
            {
                throw HttpAntiForgeryException.CreateSecurityTokenMismatchException();
            }

            // Is the incoming token meant for the current user?
            string currentUsername = String.Empty;
            BinaryBlob currentClaimUid = null;

            if (identity != null && identity.IsAuthenticated)
            {
                currentClaimUid = _claimUidExtractor.ExtractClaimUid(identity);
                if (currentClaimUid == null)
                {
                    currentUsername = identity.Name ?? String.Empty;
                }
            }

            // OpenID and other similar authentication schemes use URIs for the username.
            // These should be treated as case-sensitive.
            bool useCaseSensitiveUsernameComparison = currentUsername.StartsWith("http://", StringComparison.OrdinalIgnoreCase)
                || currentUsername.StartsWith("https://", StringComparison.OrdinalIgnoreCase);

            if (!String.Equals(fieldToken.Username, currentUsername, (useCaseSensitiveUsernameComparison) ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase))
            {
                throw HttpAntiForgeryException.CreateUsernameMismatchException(fieldToken.Username, currentUsername);
            }
            if (!Equals(fieldToken.ClaimUid, currentClaimUid))
            {
                throw HttpAntiForgeryException.CreateClaimUidMismatchException();
            }

            // Is the AdditionalData valid?
            if (_config.AdditionalDataProvider != null && !_config.AdditionalDataProvider.ValidateAdditionalData(httpContext, fieldToken.AdditionalData))
            {
                throw HttpAntiForgeryException.CreateAdditionalDataCheckFailedException();
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/Claims/Claim.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.Helpers.Claims
{
    // Represents a Claim; serves as an abstraction around the WIF SDK and 4.5 Claim types since
    // we can't compile directly against them.
    internal sealed class Claim
    {
        public Claim(string claimType, string value)
        {
            ClaimType = claimType;
            Value = value;
        }

        public string ClaimType { get; private set; }

        public string Value { get; private set; }

        // Creates a Claim from a TClaim object (duck typing).
        //
        // The TClaim must have the following shape:
        // class TClaim {
        //   string ClaimType { get; } // or just 'Type'
        //   string Value { get; }
        // }
        internal static Claim Create<TClaim>(TClaim claim)
        {
            return ClaimFactory<TClaim>.Create(claim);
        }

        private static class ClaimFactory<TClaim>
        {
            private static readonly Func<TClaim, string> _claimTypeGetter = CreateClaimTypeGetter();
            private static readonly Func<TClaim, string> _valueGetter = CreateValueGetter();

            public static Claim Create(TClaim claim)
            {
                return new Claim(_claimTypeGetter(claim), _valueGetter(claim));
            }

            private static Func<TClaim, string> CreateClaimTypeGetter()
            {
                // the claim type might go by one of two different property names
                return CreateGeneralPropertyGetter("ClaimType") ?? CreateGeneralPropertyGetter("Type");
            }

            private static Func<TClaim, string> CreateGeneralPropertyGetter(string propertyName)
            {
                PropertyInfo propInfo = typeof(TClaim).GetProperty(propertyName, BindingFlags.Public | BindingFlags.Instance, null, typeof(string), Type.EmptyTypes, null);
                if (propInfo == null)
                {
                    return null;
                }

                MethodInfo propGetter = propInfo.GetGetMethod();

                // For improved perf, instance methods can be treated as static methods by leaving
                // the 'this' parameter unbound. Virtual dispatch for the property getter will
                // still take place as expected.
                return (Func<TClaim, string>)Delegate.CreateDelegate(typeof(Func<TClaim, string>), propGetter);
            }

            private static Func<TClaim, string> CreateValueGetter()
            {
                return CreateGeneralPropertyGetter("Value");
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/Claims/ClaimsIdentity.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Security.Principal;

namespace System.Web.Helpers.Claims
{
    // Represents a ClaimsIdentity; serves as an abstraction around the WIF SDK and 4.5
    // ClaimIdentity types since we can't compile directly against them.
    internal abstract class ClaimsIdentity
    {
        public abstract IEnumerable<Claim> GetClaims();

        // Attempts to convert an IIdentity into a ClaimsIdentity;
        // returns null if the conversion fails (duck typing).
        //
        // The TClaimsIdentity must have the following shape:
        // class TClaimsIdentity : IIdentity {
        //   TClaimsCollection Claims { get; }
        // }
        // where TClaimsCollection is assignable to IEnumerable<TClaim>,
        // and where TClaim is valid for Claim.Create<TClaim>.
        internal static ClaimsIdentity TryConvert<TClaimsIdentity, TClaim>(IIdentity identity)
            where TClaimsIdentity : class, IIdentity
        {
            TClaimsIdentity castClaimsIdentity = identity as TClaimsIdentity;
            return (castClaimsIdentity != null)
                ? new ClaimsIdentityImpl<TClaimsIdentity, TClaim>(castClaimsIdentity)
                : null;
        }

        private sealed class ClaimsIdentityImpl<TClaimsIdentity, TClaim> : ClaimsIdentity
            where TClaimsIdentity : class, IIdentity
        {
            private static readonly Func<TClaimsIdentity, IEnumerable<TClaim>> _claimsGetter = CreateClaimsGetter();

            private readonly TClaimsIdentity _claimsIdentity;

            public ClaimsIdentityImpl(TClaimsIdentity claimsIdentity)
            {
                _claimsIdentity = claimsIdentity;
            }

            private static Func<TClaimsIdentity, IEnumerable<TClaim>> CreateClaimsGetter()
            {
                PropertyInfo propInfo = typeof(TClaimsIdentity).GetProperty("Claims", BindingFlags.Public | BindingFlags.Instance);
                MethodInfo propGetter = propInfo.GetGetMethod();

                // For improved perf, instance methods can be treated as static methods by leaving
                // the 'this' parameter unbound. Virtual dispatch for the property getter will
                // still take place as expected.
                return (Func<TClaimsIdentity, IEnumerable<TClaim>>)Delegate.CreateDelegate(typeof(Func<TClaimsIdentity, IEnumerable<TClaim>>), propGetter);
            }

            public override IEnumerable<Claim> GetClaims()
            {
                return _claimsGetter(_claimsIdentity).Select(Claim.Create);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/Claims/ClaimsIdentityConverter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using System.Security.Principal;
using System.Web.Security;

namespace System.Web.Helpers.Claims
{
    // Can convert IIdentity instances into our ClaimsIdentity wrapper.
    internal sealed class ClaimsIdentityConverter
    {
        private static readonly MethodInfo _claimsIdentityTryConvertOpenMethod = typeof(ClaimsIdentity).GetMethod("TryConvert", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
        private static readonly ClaimsIdentityConverter _default = new ClaimsIdentityConverter(GetDefaultConverters());

        private readonly Func<IIdentity, ClaimsIdentity>[] _converters;

        // Internal for unit testing; nobody should ever be calling this in production.
        internal ClaimsIdentityConverter(Func<IIdentity, ClaimsIdentity>[] converters)
        {
            _converters = converters;
        }

        // By default, we understand the ClaimsIdentity / Claim types included
        // with the WIF SDK and FX 4.5.
        public static ClaimsIdentityConverter Default
        {
            get
            {
                return _default;
            }
        }

        private static bool IsGrandfatheredIdentityType(IIdentity claimsIdentity)
        {
            // These specific types might also be claims-based types depending on
            // the version of the framework we're running, but we don't want to
            // treat them as claims-based types since we know their Name property
            // will suffice as a unique identifier within the security realm of the
            // current application.
            return claimsIdentity is FormsIdentity
                || claimsIdentity is WindowsIdentity
                || claimsIdentity is GenericIdentity;
        }

        public ClaimsIdentity TryConvert(IIdentity identity)
        {
            if (IsGrandfatheredIdentityType(identity))
            {
                return null;
            }

            // loop through all registered converters until one matches
            for (int i = 0; i < _converters.Length; i++)
            {
                ClaimsIdentity retVal = _converters[i](identity);
                if (retVal != null)
                {
                    return retVal;
                }
            }

            return null;
        }

        private static void AddToList(IList<Func<IIdentity, ClaimsIdentity>> converters, Type claimsIdentityType, Type claimType)
        {
            if (claimsIdentityType != null && claimType != null)
            {
                MethodInfo tryConvertClosedMethod = _claimsIdentityTryConvertOpenMethod.MakeGenericMethod(claimsIdentityType, claimType);
                Func<IIdentity, ClaimsIdentity> converter = (Func<IIdentity, ClaimsIdentity>)Delegate.CreateDelegate(typeof(Func<IIdentity, ClaimsIdentity>), tryConvertClosedMethod);
                converters.Add(converter);
            }
        }

        private static Func<IIdentity, ClaimsIdentity>[] GetDefaultConverters()
        {
            List<Func<IIdentity, ClaimsIdentity>> converters = new List<Func<IIdentity, ClaimsIdentity>>();

            // WIF SDK is only available in full trust scenarios
            if (AppDomain.CurrentDomain.IsHomogenous && AppDomain.CurrentDomain.IsFullyTrusted)
            {
                Type claimsIdentityType = Type.GetType("Microsoft.IdentityModel.Claims.IClaimsIdentity, Microsoft.IdentityModel, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
                Type claimType = Type.GetType("Microsoft.IdentityModel.Claims.Claim, Microsoft.IdentityModel, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");
                AddToList(converters, claimsIdentityType, claimType);
            }

            // 4.5 ClaimsIdentity type
            {
                Module mscorlibModule = typeof(object).Module;
                Type claimsIdentityType = mscorlibModule.GetType("System.Security.Claims.ClaimsIdentity");
                Type claimType = mscorlibModule.GetType("System.Security.Claims.Claim");
                AddToList(converters, claimsIdentityType, claimType);
            }

            return converters.ToArray();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/CryptoUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Security.Cryptography;

namespace System.Web.Helpers
{
    internal static class CryptoUtil
    {
        // This method is specially written to take the same amount of time
        // regardless of where 'a' and 'b' differ. Please do not optimize it.
        public static bool AreByteArraysEqual(byte[] a, byte[] b)
        {
            if (a == null || b == null || a.Length != b.Length)
            {
                return false;
            }

            bool areEqual = true;
            for (int i = 0; i < a.Length; i++)
            {
                areEqual &= (a[i] == b[i]);
            }
            return areEqual;
        }

        // Computes a SHA256 hash over all of the input parameters.
        // Each parameter is UTF8 encoded and preceded by a 7-bit encoded
        // integer describing the encoded byte length of the string.
        [SuppressMessage("Microsoft.Usage", "CA2202:Do not dispose objects multiple times", Justification = "MemoryStream is resilient to double-Dispose")]
        public static byte[] ComputeSHA256(IList<string> parameters)
        {
            using (MemoryStream ms = new MemoryStream())
            {
                using (BinaryWriter bw = new BinaryWriter(ms))
                {
                    foreach (string parameter in parameters)
                    {
                        bw.Write(parameter); // also writes the length as a prefix; unambiguous
                    }
                    bw.Flush();

                    using (SHA256Cng sha256 = new SHA256Cng())
                    {
                        byte[] retVal = sha256.ComputeHash(ms.GetBuffer(), 0, checked((int)ms.Length));
                        return retVal;
                    }
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/IAntiForgeryAdditionalDataProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers
{
    /// <summary>
    /// Allows providing or validating additional custom data for anti-forgery tokens.
    /// For example, the developer could use this to supply a nonce when the token is
    /// generated, then he could validate the nonce when the token is validated.
    /// </summary>
    /// <remarks>
    /// The anti-forgery system already embeds the client's username within the
    /// generated tokens. This interface provides and consumes <em>supplemental</em>
    /// data. If an incoming anti-forgery token contains supplemental data but no
    /// additional data provider is configured, the supplemental data will not be
    /// validated.
    /// </remarks>
    public interface IAntiForgeryAdditionalDataProvider
    {
        /// <summary>
        /// Provides additional data to be stored for the anti-forgery tokens generated
        /// during this request.
        /// </summary>
        /// <param name="context">Information about the current request.</param>
        /// <returns>Supplemental data to embed within the anti-forgery token.</returns>
        string GetAdditionalData(HttpContextBase context);

        /// <summary>
        /// Validates additional data that was embedded inside an incoming anti-forgery
        /// token.
        /// </summary>
        /// <param name="context">Information about the current request.</param>
        /// <param name="additionalData">Supplemental data that was embedded within the token.</param>
        /// <returns>True if the data is valid; false if the data is invalid.</returns>
        bool ValidateAdditionalData(HttpContextBase context, string additionalData);
    }
}


================================================
FILE: src/System.Web.WebPages/Helpers/UnvalidatedRequestValues.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;

namespace System.Web.Helpers
{
    // Provides access to Request.* collections, except that these have not gone through request validation.
    [Obsolete("Use System.Web.HttpRequest.Unvalidated instead.")]
    public sealed class UnvalidatedRequestValues
    {
        private readonly HttpRequestBase _request;

        internal UnvalidatedRequestValues(HttpRequestBase request)
        {
            _request = request;
        }

        public NameValueCollection Form
        {
            get { return _request.Unvalidated.Form; }
        }

        public NameValueCollection QueryString
        {
            get { return _request.Unvalidated.QueryString; }
        }

        public string this[string key]
        {
            get
            {
                return _request.Unvalidated[key];
            }
        }
    }
}

================================================
FILE: src/System.Web.WebPages/Helpers/Validation.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.Helpers
{
    [Obsolete("Use System.Web.HttpRequest.Unvalidated instead.")]
    public static class Validation
    {
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "request",
            Justification = "Parameter is only meant for making this show up as 'Request.Unvalidated()', which closely resembles FX45 syntax.")]
#pragma warning disable 0618 // Obsolete System.Web.Helpers.UnvalidatedRequestValues
        public static UnvalidatedRequestValues Unvalidated(this HttpRequestBase request)
#pragma warning restore
        {
            return Unvalidated((HttpRequest)null);
        }

        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "request",
            Justification = "Parameter is only meant for making this show up as 'Request.Unvalidated()', which closely resembles FX45 syntax.")]
#pragma warning disable 0618 // Obsolete System.Web.Helpers.UnvalidatedRequestValues
        public static UnvalidatedRequestValues Unvalidated(this HttpRequest request)
#pragma warning restore
        {
            // We don't actually need the request object; we'll get HttpContext.Current directly.
            HttpContext context = HttpContext.Current;
#pragma warning disable 0618 // Obsolete System.Web.Helpers.UnvalidatedRequestValues
            return new UnvalidatedRequestValues(new HttpRequestWrapper(context.Request));
#pragma warning restore
        }

        public static string Unvalidated(this HttpRequestBase request, string key)
        {
            return Unvalidated(request)[key];
        }

        public static string Unvalidated(this HttpRequest request, string key)
        {
            return Unvalidated(request)[key];
        }
    }
}

================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.Checkbox.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        public IHtmlString CheckBox(string name)
        {
            return CheckBox(name, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString CheckBox(string name, object htmlAttributes)
        {
            return CheckBox(name, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString CheckBox(string name, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildCheckBox(name, null, htmlAttributes);
        }

        public IHtmlString CheckBox(string name, bool isChecked)
        {
            return CheckBox(name, isChecked, (IDictionary<string, object>)null);
        }

        public IHtmlString CheckBox(string name, bool isChecked, object htmlAttributes)
        {
            return CheckBox(name, isChecked, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString CheckBox(string name, bool isChecked, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            return BuildCheckBox(name, isChecked, htmlAttributes);
        }

        private IHtmlString BuildCheckBox(string name, bool? isChecked, IDictionary<string, object> attributes)
        {
            TagBuilder builder = new TagBuilder("input");
            builder.MergeAttribute("type", "checkbox", replaceExisting: true);
            builder.GenerateId(name);
            builder.MergeAttributes(attributes, replaceExisting: true);
            builder.MergeAttribute("name", name, replaceExisting: true);

            if (UnobtrusiveJavaScriptEnabled)
            {
                var validationAttributes = _validationHelper.GetUnobtrusiveValidationAttributes(name);
                builder.MergeAttributes(validationAttributes, replaceExisting: false);
            }

            var model = ModelState[name];
            if (model != null && model.Value != null)
            {
                bool modelValue = (bool)ConvertTo(model.Value, typeof(bool));
                isChecked = isChecked ?? modelValue;
            }
            if (isChecked.HasValue)
            {
                if (isChecked.Value == true)
                {
                    builder.MergeAttribute("checked", "checked", replaceExisting: true);
                }
                else
                {
                    builder.Attributes.Remove("checked");
                }
            }

            AddErrorClass(builder, name);
            return builder.ToHtmlString(TagRenderMode.SelfClosing);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.Input.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Data.Linq;
using System.Diagnostics.CodeAnalysis;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        private enum InputType
        {
            Text,
            Password,
            Hidden
        }

        public IHtmlString TextBox(string name)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildInputField(name, InputType.Text, value: null, isExplicitValue: false,
                                   attributes: (IDictionary<string, object>)null);
        }

        public IHtmlString TextBox(string name, object value)
        {
            return TextBox(name, value, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString TextBox(string name, object value, object htmlAttributes)
        {
            return TextBox(name, value, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString TextBox(string name, object value, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildInputField(name, InputType.Text, value, isExplicitValue: true, attributes: htmlAttributes);
        }

        public IHtmlString Hidden(string name)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildInputField(name, InputType.Hidden, value: null, isExplicitValue: false,
                                   attributes: (IDictionary<string, object>)null);
        }

        public IHtmlString Hidden(string name, object value)
        {
            return Hidden(name, value, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString Hidden(string name, object value, object htmlAttributes)
        {
            return Hidden(name, value, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString Hidden(string name, object value, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildInputField(name, InputType.Hidden, GetHiddenFieldValue(value), isExplicitValue: true,
                                   attributes: htmlAttributes);
        }

        private static object GetHiddenFieldValue(object value)
        {
            Binary binaryValue = value as Binary;
            if (binaryValue != null)
            {
                value = binaryValue.ToArray();
            }

            byte[] byteArrayValue = value as byte[];
            if (byteArrayValue != null)
            {
                value = Convert.ToBase64String(byteArrayValue);
            }

            return value;
        }

        public IHtmlString Password(string name)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildInputField(name, InputType.Password, null, isExplicitValue: false,
                                   attributes: (IDictionary<string, object>)null);
        }

        public IHtmlString Password(string name, object value)
        {
            return Password(name, value, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString Password(string name, object value, object htmlAttributes)
        {
            return Password(name, value, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString Password(string name, object value, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildInputField(name, InputType.Password, value, isExplicitValue: true, attributes: htmlAttributes);
        }

        private IHtmlString BuildInputField(string name, InputType type, object value, bool isExplicitValue,
                                            IDictionary<string, object> attributes)
        {
            TagBuilder tagBuilder = new TagBuilder("input");
            // Implicit parameters
            tagBuilder.MergeAttribute("type", GetInputTypeString(type));
            tagBuilder.GenerateId(name);

            // Overwrite implicit
            tagBuilder.MergeAttributes(attributes, replaceExisting: true);

            if (UnobtrusiveJavaScriptEnabled)
            {
                // Add validation attributes
                var validationAttributes = _validationHelper.GetUnobtrusiveValidationAttributes(name);
                tagBuilder.MergeAttributes(validationAttributes, replaceExisting: false);
            }

            // Function arguments
            tagBuilder.MergeAttribute("name", name, replaceExisting: true);
            var modelState = ModelState[name];
            if ((type != InputType.Password) && modelState != null)
            {
                // Don't use model values for passwords
                value = value ?? modelState.Value ?? String.Empty;
            }

            if ((type != InputType.Password) || ((type == InputType.Password) && (value != null)))
            {
                // Review: Do we really need to be this pedantic about sticking to mvc?
                tagBuilder.MergeAttribute("value", (string)ConvertTo(value, typeof(string)), replaceExisting: isExplicitValue);
            }

            AddErrorClass(tagBuilder, name);
            return tagBuilder.ToHtmlString(TagRenderMode.SelfClosing);
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Input types are specified in lower case")]
        private static string GetInputTypeString(InputType inputType)
        {
            if (!Enum.IsDefined(typeof(InputType), inputType))
            {
                inputType = InputType.Text;
            }
            return inputType.ToString().ToLowerInvariant();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.Internal.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.Web.Mvc;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        private void AddErrorClass(TagBuilder tagBuilder, string name)
        {
            if (!ModelState.IsValidField(name))
            {
                tagBuilder.AddCssClass(ValidationInputCssClassName);
            }
        }

        private static object ConvertTo(object value, Type type)
        {
            Debug.Assert(type != null);
            return UnwrapPossibleArrayType(value, type, CultureInfo.InvariantCulture);
        }

        private static object UnwrapPossibleArrayType(object value, Type destinationType, CultureInfo culture)
        {
            if (value == null || destinationType.IsInstanceOfType(value))
            {
                return value;
            }

            // array conversion results in four cases, as below
            Array valueAsArray = value as Array;
            if (destinationType.IsArray)
            {
                Type destinationElementType = destinationType.GetElementType();
                if (valueAsArray != null)
                {
                    // case 1: both destination + source type are arrays, so convert each element
                    IList converted = Array.CreateInstance(destinationElementType, valueAsArray.Length);
                    for (int i = 0; i < valueAsArray.Length; i++)
                    {
                        converted[i] = ConvertSimpleType(valueAsArray.GetValue(i), destinationElementType, culture);
                    }
                    return converted;
                }
                else
                {
                    // case 2: destination type is array but source is single element, so wrap element in array + convert
                    object element = ConvertSimpleType(value, destinationElementType, culture);
                    IList converted = Array.CreateInstance(destinationElementType, 1);
                    converted[0] = element;
                    return converted;
                }
            }
            else if (valueAsArray != null)
            {
                // case 3: destination type is single element but source is array, so extract first element + convert
                if (valueAsArray.Length > 0)
                {
                    value = valueAsArray.GetValue(0);
                    return ConvertSimpleType(value, destinationType, culture);
                }
                else
                {
                    // case 3(a): source is empty array, so can't perform conversion
                    return null;
                }
            }
            // case 4: both destination + source type are single elements, so convert
            return ConvertSimpleType(value, destinationType, culture);
        }

        private static object ConvertSimpleType(object value, Type destinationType, CultureInfo culture)
        {
            if (value == null || destinationType.IsInstanceOfType(value))
            {
                return value;
            }

            // if this is a user-input value but the user didn't type anything, return no value
            string valueAsString = value as string;
            if (valueAsString != null && valueAsString.Trim().Length == 0)
            {
                return null;
            }

            TypeConverter converter = TypeDescriptor.GetConverter(destinationType);
            bool canConvertFrom = converter.CanConvertFrom(value.GetType());
            if (!canConvertFrom)
            {
                converter = TypeDescriptor.GetConverter(value.GetType());
            }
            if (!(canConvertFrom || converter.CanConvertTo(destinationType)))
            {
                string message = String.Format(CultureInfo.CurrentCulture, WebPageResources.HtmlHelper_NoConverterExists,
                                               value.GetType().FullName, destinationType.FullName);
                throw new InvalidOperationException(message);
            }

            try
            {
                object convertedValue = (canConvertFrom)
                                            ? converter.ConvertFrom(context: null, culture: culture, value: value)
                                            : converter.ConvertTo(context: null, culture: culture, value: value, destinationType: destinationType);
                return convertedValue;
            }
            catch (Exception ex)
            {
                string message = String.Format(CultureInfo.CurrentUICulture, WebPageResources.HtmlHelper_ConversionThrew,
                                               value.GetType().FullName, destinationType.FullName);
                throw new InvalidOperationException(message, ex);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.Label.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        public IHtmlString Label(string labelText)
        {
            return Label(labelText, null, (IDictionary<string, object>)null);
        }

        public IHtmlString Label(string labelText, string labelFor)
        {
            return Label(labelText, labelFor, (IDictionary<string, object>)null);
        }

        public IHtmlString Label(string labelText, object attributes)
        {
            return Label(labelText, null, AnonymousObjectToHtmlAttributes(attributes));
        }

        public IHtmlString Label(string labelText, string labelFor, object attributes)
        {
            return Label(labelText, labelFor, AnonymousObjectToHtmlAttributes(attributes));
        }

        public IHtmlString Label(string labelText, string labelFor, IDictionary<string, object> attributes)
        {
            if (String.IsNullOrEmpty(labelText))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "labelText");
            }

            labelFor = labelFor ?? labelText;

            TagBuilder tag = new TagBuilder("label") { InnerHtml = Encode(labelText) };

            if (!String.IsNullOrEmpty(labelFor))
            {
                tag.MergeAttribute("for", labelFor);
            }
            tag.MergeAttributes(attributes, false);

            return tag.ToHtmlString(TagRenderMode.Normal);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.Radio.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        public IHtmlString RadioButton(string name, object value)
        {
            return RadioButton(name, value, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString RadioButton(string name, object value, object htmlAttributes)
        {
            return RadioButton(name, value, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString RadioButton(string name, object value, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildRadioButton(name, value, isChecked: null, attributes: htmlAttributes);
        }

        public IHtmlString RadioButton(string name, object value, bool isChecked)
        {
            return RadioButton(name, value, isChecked, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString RadioButton(string name, object value, bool isChecked, object htmlAttributes)
        {
            return RadioButton(name, value, isChecked, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString RadioButton(string name, object value, bool isChecked, IDictionary<string, object> htmlAttributes)
        {
            if (name == null)
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            return BuildRadioButton(name, value, isChecked, htmlAttributes);
        }

        private IHtmlString BuildRadioButton(string name, object value, bool? isChecked, IDictionary<string, object> attributes)
        {
            string valueString = ConvertTo(value, typeof(string)) as string;

            TagBuilder builder = new TagBuilder("input");
            builder.MergeAttribute("type", "radio", true);
            builder.GenerateId(name);
            builder.MergeAttributes(attributes, replaceExisting: true);

            builder.MergeAttribute("value", valueString, replaceExisting: true);
            builder.MergeAttribute("name", name, replaceExisting: true);

            if (UnobtrusiveJavaScriptEnabled)
            {
                // Add validation attributes
                var validationAttributes = _validationHelper.GetUnobtrusiveValidationAttributes(name);
                builder.MergeAttributes(validationAttributes, replaceExisting: false);
            }

            var modelState = ModelState[name];
            string modelValue = null;
            if (modelState != null)
            {
                modelValue = ConvertTo(modelState.Value, typeof(string)) as string;
                isChecked = isChecked ?? String.Equals(modelValue, valueString, StringComparison.OrdinalIgnoreCase);
            }

            if (isChecked.HasValue)
            {
                // Overrides attribute values
                if (isChecked.Value)
                {
                    builder.MergeAttribute("checked", "checked", true);
                }
                else
                {
                    builder.Attributes.Remove("checked");
                }
            }

            AddErrorClass(builder, name);

            return builder.ToHtmlString(TagRenderMode.SelfClosing);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.Select.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        public IHtmlString ListBox(string name, IEnumerable<SelectListItem> selectList)
        {
            return ListBox(name, defaultOption: null, selectList: selectList, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList)
        {
            return ListBox(name, defaultOption: defaultOption, selectList: selectList, selectedValues: null,
                           htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString ListBox(string name, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return ListBox(name, defaultOption: null, selectList: selectList, selectedValues: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ListBox(string name, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            return ListBox(name, defaultOption: null, selectList: selectList, selectedValues: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList,
                                   IDictionary<string, object> htmlAttributes)
        {
            return ListBox(name, defaultOption, selectList, selectedValues: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return ListBox(name, defaultOption: defaultOption, selectList: selectList, selectedValues: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList, object selectedValues,
                                   IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            return BuildListBox(name, defaultOption: defaultOption, selectList: selectList,
                                selectedValues: selectedValues, size: null, allowMultiple: false, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList, object selectedValues,
                                   object htmlAttributes)
        {
            return ListBox(name, defaultOption: defaultOption, selectList: selectList,
                           selectedValues: selectedValues, htmlAttributes: AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString ListBox(string name, IEnumerable<SelectListItem> selectList,
                                   object selectedValues, int size, bool allowMultiple)
        {
            return ListBox(name, defaultOption: null, selectList: selectList, selectedValues: selectedValues, size: size,
                           allowMultiple: allowMultiple, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList,
                                   object selectedValues, int size, bool allowMultiple)
        {
            return ListBox(name, defaultOption: defaultOption, selectList: selectList, selectedValues: selectedValues,
                           size: size, allowMultiple: allowMultiple, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList,
                                   object selectedValues, int size, bool allowMultiple, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildListBox(name, defaultOption, selectList, selectedValues, size, allowMultiple, htmlAttributes);
        }

        public IHtmlString ListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList,
                                   object selectedValues, int size, bool allowMultiple, object htmlAttributes)
        {
            return ListBox(name, defaultOption, selectList, selectedValues, size, allowMultiple, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        private IHtmlString BuildListBox(string name, string defaultOption, IEnumerable<SelectListItem> selectList,
                                         object selectedValues, int? size, bool allowMultiple, IDictionary<string, object> htmlAttributes)
        {
            var modelState = ModelState[name];
            if (modelState != null)
            {
                selectedValues = selectedValues ?? ModelState[name].Value;
            }

            if (selectedValues != null)
            {
                IEnumerable values = (allowMultiple) ? ConvertTo(selectedValues, typeof(string[])) as string[]
                                         : new[] { ConvertTo(selectedValues, typeof(string)) };

                HashSet<string> selectedValueSet = new HashSet<string>(from object value in values
                                                                       select Convert.ToString(value, CultureInfo.CurrentCulture),
                                                                       StringComparer.OrdinalIgnoreCase);
                List<SelectListItem> newSelectList = new List<SelectListItem>();

                bool previousSelected = false;
                foreach (SelectListItem item in selectList)
                {
                    bool selected = false;
                    // If the user's specified allowed multiple to be false
                    // only pick up the first item that was selected.
                    if (allowMultiple || !previousSelected)
                    {
                        selected = item.Selected || selectedValueSet.Contains(item.Value ?? item.Text);
                    }
                    previousSelected = previousSelected | selected;

                    newSelectList.Add(new SelectListItem(item) { Selected = selected });
                }
                selectList = newSelectList;
            }

            TagBuilder tagBuilder = new TagBuilder("select")
            {
                InnerHtml = BuildListOptions(selectList, defaultOption)
            };

            if (UnobtrusiveJavaScriptEnabled)
            {
                // Add validation attributes
                var validationAttributes = _validationHelper.GetUnobtrusiveValidationAttributes(name);
                tagBuilder.MergeAttributes(validationAttributes, replaceExisting: false);
            }

            tagBuilder.GenerateId(name);
            tagBuilder.MergeAttributes(htmlAttributes);

            tagBuilder.MergeAttribute("name", name, replaceExisting: true);
            if (size.HasValue)
            {
                tagBuilder.MergeAttribute("size", size.ToString(), true);
            }
            if (allowMultiple)
            {
                tagBuilder.MergeAttribute("multiple", "multiple");
            }
            else if (tagBuilder.Attributes.ContainsKey("multiple"))
            {
                tagBuilder.Attributes.Remove("multiple");
            }

            // If there are any errors for a named field, we add the css attribute.
            AddErrorClass(tagBuilder, name);

            return tagBuilder.ToHtmlString(TagRenderMode.Normal);
        }

        public IHtmlString DropDownList(string name, IEnumerable<SelectListItem> selectList)
        {
            return DropDownList(name, defaultOption: null, selectList: selectList, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString DropDownList(string name, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return DropDownList(name, defaultOption: null, selectList: selectList, selectedValue: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString DropDownList(string name, IEnumerable<SelectListItem> selectList, IDictionary<string, object> htmlAttributes)
        {
            return DropDownList(name, defaultOption: null, selectList: selectList, selectedValue: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString DropDownList(string name, string defaultOption, IEnumerable<SelectListItem> selectList)
        {
            return DropDownList(name, defaultOption, selectList, selectedValue: null, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString DropDownList(string name, string defaultOption, IEnumerable<SelectListItem> selectList,
                                        IDictionary<string, object> htmlAttributes)
        {
            return DropDownList(name, defaultOption, selectList, selectedValue: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString DropDownList(string name, string defaultOption, IEnumerable<SelectListItem> selectList, object htmlAttributes)
        {
            return DropDownList(name, defaultOption: defaultOption, selectList: selectList, selectedValue: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString DropDownList(string name, string defaultOption, IEnumerable<SelectListItem> selectList, object selectedValue,
                                        IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            return BuildDropDownList(name, defaultOption, selectList, selectedValue, htmlAttributes: htmlAttributes);
        }

        public IHtmlString DropDownList(string name, string defaultOption, IEnumerable<SelectListItem> selectList, object selectedValue,
                                        object htmlAttributes)
        {
            return DropDownList(name, defaultOption, selectList, selectedValue, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        private IHtmlString BuildDropDownList(string name, string defaultOption, IEnumerable<SelectListItem> selectList,
                                              object selectedValue, IDictionary<string, object> htmlAttributes)
        {
            var modelState = ModelState[name];
            if (modelState != null)
            {
                selectedValue = selectedValue ?? ModelState[name].Value;
            }
            selectedValue = ConvertTo(selectedValue, typeof(string));

            if (selectedValue != null)
            {
                var newSelectList = new List<SelectListItem>(from item in selectList
                                                             select new SelectListItem(item));
                var comparer = StringComparer.InvariantCultureIgnoreCase;
                var selectedItem = newSelectList.FirstOrDefault(item => item.Selected || comparer.Equals(item.Value ?? item.Text, selectedValue));
                if (selectedItem != default(SelectListItem))
                {
                    selectedItem.Selected = true;
                    selectList = newSelectList;
                }
            }

            TagBuilder tagBuilder = new TagBuilder("select")
            {
                InnerHtml = BuildListOptions(selectList, defaultOption)
            };
            tagBuilder.MergeAttributes(htmlAttributes);
            tagBuilder.MergeAttribute("name", name, replaceExisting: true);
            tagBuilder.GenerateId(name);
            if (UnobtrusiveJavaScriptEnabled)
            {
                var validationAttributes = _validationHelper.GetUnobtrusiveValidationAttributes(name);
                tagBuilder.MergeAttributes(validationAttributes, replaceExisting: false);
            }

            // If there are any errors for a named field, we add the css attribute.
            AddErrorClass(tagBuilder, name);

            return tagBuilder.ToHtmlString(TagRenderMode.Normal);
        }

        private static string BuildListOptions(IEnumerable<SelectListItem> selectList, string optionText)
        {
            StringBuilder builder = new StringBuilder().AppendLine();
            if (optionText != null)
            {
                builder.AppendLine(ListItemToOption(new SelectListItem { Text = optionText, Value = String.Empty }));
            }
            if (selectList != null)
            {
                foreach (var item in selectList)
                {
                    builder.AppendLine(ListItemToOption(item));
                }
            }
            return builder.ToString();
        }

        private static string ListItemToOption(SelectListItem item)
        {
            TagBuilder builder = new TagBuilder("option")
            {
                InnerHtml = HttpUtility.HtmlEncode(item.Text)
            };
            if (item.Value != null)
            {
                builder.Attributes["value"] = item.Value;
            }
            if (item.Selected)
            {
                builder.Attributes["selected"] = "selected";
            }
            return builder.ToString(TagRenderMode.Normal);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.TextArea.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        // Values from mvc
        private const int TextAreaRows = 2;
        private const int TextAreaColumns = 20;

        private static readonly IDictionary<string, object> _implicitRowsAndColumns = new Dictionary<string, object>
        {
            { "rows", TextAreaRows.ToString(CultureInfo.InvariantCulture) },
            { "cols", TextAreaColumns.ToString(CultureInfo.InvariantCulture) },
        };

        private static IDictionary<string, object> GetRowsAndColumnsDictionary(int rows, int columns)
        {
            Dictionary<string, object> result = new Dictionary<string, object>();
            if (rows > 0)
            {
                result.Add("rows", rows.ToString(CultureInfo.InvariantCulture));
            }
            if (columns > 0)
            {
                result.Add("cols", columns.ToString(CultureInfo.InvariantCulture));
            }
            return result;
        }

        public IHtmlString TextArea(string name)
        {
            return TextArea(name, value: null, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString TextArea(string name, object htmlAttributes)
        {
            return TextArea(name, value: null, htmlAttributes: AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString TextArea(string name, IDictionary<string, object> htmlAttributes)
        {
            return TextArea(name, value: null, htmlAttributes: htmlAttributes);
        }

        public IHtmlString TextArea(string name, string value)
        {
            return TextArea(name, value, (IDictionary<string, object>)null);
        }

        public IHtmlString TextArea(string name, string value, object htmlAttributes)
        {
            return TextArea(name, value, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString TextArea(string name, string value, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }

            return BuildTextArea(name, value, _implicitRowsAndColumns, htmlAttributes);
        }

        public IHtmlString TextArea(string name, string value, int rows, int columns,
                                    object htmlAttributes)
        {
            return TextArea(name, value, rows, columns, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString TextArea(string name, string value, int rows, int columns,
                                    IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            return BuildTextArea(name, value, GetRowsAndColumnsDictionary(rows, columns), htmlAttributes);
        }

        private IHtmlString BuildTextArea(string name, string value, IDictionary<string, object> rowsAndColumnsDictionary,
                                          IDictionary<string, object> htmlAttributes)
        {
            TagBuilder tagBuilder = new TagBuilder("textarea");

            if (UnobtrusiveJavaScriptEnabled)
            {
                // Add validation attributes
                var validationAttributes = _validationHelper.GetUnobtrusiveValidationAttributes(name);
                tagBuilder.MergeAttributes(validationAttributes, replaceExisting: false);
            }

            // Add user specified htmlAttributes
            tagBuilder.MergeAttributes(htmlAttributes);

            tagBuilder.MergeAttributes(rowsAndColumnsDictionary, rowsAndColumnsDictionary != _implicitRowsAndColumns);

            // Value becomes the inner html of the textarea element
            var modelState = ModelState[name];
            if (modelState != null)
            {
                value = value ?? Convert.ToString(ModelState[name].Value, CultureInfo.CurrentCulture);
            }
            tagBuilder.InnerHtml = Encode(value);

            //Assign name and id
            tagBuilder.MergeAttribute("name", name);
            tagBuilder.GenerateId(name);

            AddErrorClass(tagBuilder, name);

            return tagBuilder.ToHtmlString(TagRenderMode.Normal);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.Validation.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        public IHtmlString ValidationMessage(string name)
        {
            return ValidationMessage(name, null, null);
        }

        public IHtmlString ValidationMessage(string name, string message)
        {
            return ValidationMessage(name, message, (IDictionary<string, object>)null);
        }

        public IHtmlString ValidationMessage(string name, object htmlAttributes)
        {
            return ValidationMessage(name, null, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString ValidationMessage(string name, IDictionary<string, object> htmlAttributes)
        {
            return ValidationMessage(name, null, htmlAttributes);
        }

        public IHtmlString ValidationMessage(string name, string message, object htmlAttributes)
        {
            return ValidationMessage(name, message, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString ValidationMessage(string name, string message, IDictionary<string, object> htmlAttributes)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            return BuildValidationMessage(name, message, htmlAttributes);
        }

        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase",
            Justification = "Normalization to lowercase is a common requirement for JavaScript and HTML values")]
        private IHtmlString BuildValidationMessage(string name, string message, IDictionary<string, object> htmlAttributes)
        {
            var modelState = ModelState[name];
            IEnumerable<string> errors = null;
            if (modelState != null)
            {
                errors = modelState.Errors;
            }
            bool hasError = errors != null && errors.Any();
            if (!hasError && !UnobtrusiveJavaScriptEnabled)
            {
                // If unobtrusive validation is enabled, we need to generate an empty span with the "val-for" attribute"
                return null;
            }
            else
            {
                string error = null;
                if (hasError)
                {
                    error = message ?? errors.First();
                }

                TagBuilder tagBuilder = new TagBuilder("span") { InnerHtml = Encode(error) };
                tagBuilder.MergeAttributes(htmlAttributes);
                if (UnobtrusiveJavaScriptEnabled)
                {
                    bool replaceValidationMessageContents = String.IsNullOrEmpty(message);
                    tagBuilder.MergeAttribute("data-valmsg-for", name);
                    tagBuilder.MergeAttribute("data-valmsg-replace", replaceValidationMessageContents.ToString().ToLowerInvariant());
                }
                tagBuilder.AddCssClass(hasError ? ValidationMessageCssClassName : ValidationMessageValidCssClassName);
                return tagBuilder.ToHtmlString(TagRenderMode.Normal);
            }
        }

        public IHtmlString ValidationSummary()
        {
            return BuildValidationSummary(message: null, excludeFieldErrors: false, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString ValidationSummary(string message)
        {
            return BuildValidationSummary(message: message, excludeFieldErrors: false, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString ValidationSummary(bool excludeFieldErrors)
        {
            return ValidationSummary(message: null, excludeFieldErrors: excludeFieldErrors, htmlAttributes: (IDictionary<string, object>)null);
        }

        public IHtmlString ValidationSummary(object htmlAttributes)
        {
            return ValidationSummary(message: null, excludeFieldErrors: false, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ValidationSummary(IDictionary<string, object> htmlAttributes)
        {
            return ValidationSummary(message: null, excludeFieldErrors: false, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ValidationSummary(string message, object htmlAttributes)
        {
            return ValidationSummary(message, excludeFieldErrors: false, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ValidationSummary(string message, IDictionary<string, object> htmlAttributes)
        {
            return ValidationSummary(message, excludeFieldErrors: false, htmlAttributes: htmlAttributes);
        }

        public IHtmlString ValidationSummary(string message, bool excludeFieldErrors, object htmlAttributes)
        {
            return ValidationSummary(message, excludeFieldErrors, AnonymousObjectToHtmlAttributes(htmlAttributes));
        }

        public IHtmlString ValidationSummary(string message, bool excludeFieldErrors, IDictionary<string, object> htmlAttributes)
        {
            return BuildValidationSummary(message, excludeFieldErrors, htmlAttributes);
        }

        private IHtmlString BuildValidationSummary(string message, bool excludeFieldErrors, IDictionary<string, object> htmlAttributes)
        {
            IEnumerable<string> errors = null;
            if (excludeFieldErrors)
            {
                // Review: Is there a better way to share the form field name between this and ModelStateDictionary?
                var formModelState = ModelState[ModelStateDictionary.FormFieldKey];
                if (formModelState != null)
                {
                    errors = formModelState.Errors;
                }
            }
            else
            {
                errors = ModelState.SelectMany(c => c.Value.Errors);
            }

            bool hasErrors = errors != null && errors.Any();
            if (!hasErrors && (!UnobtrusiveJavaScriptEnabled || excludeFieldErrors))
            {
                // If no errors are found and we do not have unobtrusive validation enabled or if the summary is not meant to display field errors, don't generate the summary.
                return null;
            }
            else
            {
                TagBuilder tagBuilder = new TagBuilder("div");
                tagBuilder.MergeAttributes(htmlAttributes);
                tagBuilder.AddCssClass(hasErrors ? ValidationSummaryClass : ValidationSummaryValidClass);
                if (UnobtrusiveJavaScriptEnabled && !excludeFieldErrors)
                {
                    tagBuilder.MergeAttribute("data-valmsg-summary", "true");
                }

                StringBuilder builder = new StringBuilder();
                if (message != null)
                {
                    builder.Append("<span>");
                    builder.Append(Encode(message));
                    builder.AppendLine("</span>");
                }
                builder.AppendLine("<ul>");
                foreach (var error in errors)
                {
                    builder.Append("<li>");
                    builder.Append(Encode(error));
                    builder.AppendLine("</li>");
                }
                builder.Append("</ul>");

                tagBuilder.InnerHtml = builder.ToString();
                return tagBuilder.ToHtmlString(TagRenderMode.Normal);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/HtmlHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Routing;
using System.Web.WebPages.Scope;

namespace System.Web.WebPages.Html
{
    public partial class HtmlHelper
    {
        internal const string DefaultValidationInputErrorCssClass = "input-validation-error";
        private const string DefaultValidationInputValidCssClass = "input-validation-valid";
        private const string DefaultValidationMessageErrorCssClass = "field-validation-error";
        private const string DefaultValidationMessageValidCssClass = "field-validation-valid";
        private const string DefaultValidationSummaryErrorCssClass = "validation-summary-errors";
        private const string DefaultValidationSummaryValidCssClassName = "validation-summary-valid";
        private static readonly object _validationMesssageErrorClassKey = new object();
        private static readonly object _validationMessageValidClassKey = new object();
        private static readonly object _validationInputErrorClassKey = new object();
        private static readonly object _validationInputValidClassKey = new object();
        private static readonly object _validationSummaryClassKey = new object();
        private static readonly object _validationSummaryValidClassKey = new object();
        private static readonly object _unobtrusiveValidationKey = new object();
        private static string _idAttributeDotReplacement;
        private readonly ValidationHelper _validationHelper;

        internal HtmlHelper(ModelStateDictionary modelState, ValidationHelper validationHelper)
        {
            ModelState = modelState;
            _validationHelper = validationHelper;
        }

        // This property got copied from MVC's HtmlHelper along with TagBuilder.
        // It was a global property in MVC so it should not have scoped semantics here either.
        public static string IdAttributeDotReplacement
        {
            get
            {
                if (String.IsNullOrEmpty(_idAttributeDotReplacement))
                {
                    _idAttributeDotReplacement = "_";
                }
                return _idAttributeDotReplacement;
            }
            set { _idAttributeDotReplacement = value; }
        }

        public static string ValidationInputValidCssClassName
        {
            get { return ScopeStorage.CurrentScope[_validationInputValidClassKey] as string ?? DefaultValidationInputValidCssClass; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                ScopeStorage.CurrentScope[_validationInputValidClassKey] = value;
            }
        }

        public static string ValidationInputCssClassName
        {
            get { return ScopeStorage.CurrentScope[_validationInputErrorClassKey] as string ?? DefaultValidationInputErrorCssClass; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                ScopeStorage.CurrentScope[_validationInputErrorClassKey] = value;
            }
        }

        public static string ValidationMessageValidCssClassName
        {
            get { return ScopeStorage.CurrentScope[_validationMessageValidClassKey] as string ?? DefaultValidationMessageValidCssClass; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                ScopeStorage.CurrentScope[_validationMessageValidClassKey] = value;
            }
        }

        public static string ValidationMessageCssClassName
        {
            get { return ScopeStorage.CurrentScope[_validationMesssageErrorClassKey] as string ?? DefaultValidationMessageErrorCssClass; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                ScopeStorage.CurrentScope[_validationMesssageErrorClassKey] = value;
            }
        }

        public static string ValidationSummaryClass
        {
            get { return ScopeStorage.CurrentScope[_validationSummaryClassKey] as string ?? DefaultValidationSummaryErrorCssClass; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                ScopeStorage.CurrentScope[_validationSummaryClassKey] = value;
            }
        }

        public static string ValidationSummaryValidClass
        {
            get { return ScopeStorage.CurrentScope[_validationSummaryValidClassKey] as string ?? DefaultValidationSummaryValidCssClassName; }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                ScopeStorage.CurrentScope[_validationSummaryValidClassKey] = value;
            }
        }

        public static bool UnobtrusiveJavaScriptEnabled
        {
            get
            {
                bool? value = (bool?)ScopeStorage.CurrentScope[_unobtrusiveValidationKey];
                return value ?? true;
            }
            set { ScopeStorage.CurrentScope[_unobtrusiveValidationKey] = value; }
        }

        private ModelStateDictionary ModelState { get; set; }

        public string AttributeEncode(object value)
        {
            return AttributeEncode(Convert.ToString(value, CultureInfo.InvariantCulture));
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic",
            Justification = "For consistency, all helpers are instance methods.")]
        public string AttributeEncode(string value)
        {
            if (String.IsNullOrEmpty(value))
            {
                return String.Empty;
            }
            else
            {
                return HttpUtility.HtmlAttributeEncode(value);
            }
        }

        public string Encode(object value)
        {
            return Encode(Convert.ToString(value, CultureInfo.InvariantCulture));
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic",
            Justification = "For consistency, all helpers are instance methods.")]
        public string Encode(string value)
        {
            if (String.IsNullOrEmpty(value))
            {
                return String.Empty;
            }
            else
            {
                return HttpUtility.HtmlEncode(value);
            }
        }

        /// <summary>
        /// Wraps HTML markup in an IHtmlString, which will enable HTML markup to be
        /// rendered to the output without getting HTML encoded.
        /// </summary>
        /// <param name="value">HTML markup string.</param>
        /// <returns>An IHtmlString that represents HTML markup.</returns>
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic",
            Justification = "For consistency, all helpers are instance methods.")]
        public IHtmlString Raw(string value)
        {
            return new HtmlString(value);
        }

        /// <summary>
        /// Wraps HTML markup from the string representation of an object in an IHtmlString,
        /// which will enable HTML markup to be rendered to the output without getting HTML encoded.
        /// </summary>
        /// <param name="value">object with string representation as HTML markup</param>
        /// <returns>An IHtmlString that represents HTML markup.</returns>
        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic",
            Justification = "For consistency, all helpers are instance methods.")]
        public IHtmlString Raw(object value)
        {
            return new HtmlString(value == null ? null : value.ToString());
        }

        /// <summary>
        /// Creates a dictionary of HTML attributes from the input object, 
        /// translating underscores to dashes.
        /// </summary>
        /// <example>
        /// new <c>{ data_name="value" }</c> will translate to the entry <c>{ "data-name" , "value" }</c>
        /// in the resulting dictionary.
        /// </example>
        /// <param name="htmlAttributes">Anonymous object describing HTML attributes.</param>
        /// <returns>A dictionary that represents HTML attributes.</returns>
        public static RouteValueDictionary AnonymousObjectToHtmlAttributes(object htmlAttributes)
        {
            RouteValueDictionary result = new RouteValueDictionary();

            if (htmlAttributes != null)
            {
                foreach (PropertyHelper property in HtmlAttributePropertyHelper.GetProperties(htmlAttributes))
                {
                    result.Add(property.Name, property.GetValue(htmlAttributes));
                }
            }

            return result;
        }

        /// <summary>
        /// Creates a dictionary from an object, by adding each public instance property as a key with its associated 
        /// value to the dictionary. It will expose public properties from derived types as well. This is typically used
        /// with objects of an anonymous type.
        /// </summary>
        /// <example>
        /// <c>new { property_name = "value" }</c> will translate to the entry <c>{ "property_name" , "value" }</c>
        /// in the resulting dictionary.
        /// </example>
        /// <param name="value">The object to be converted.</param>
        /// <returns>The created dictionary of property names and property values.</returns>
        public static IDictionary<string, object> ObjectToDictionary(object value)
        {
            return TypeHelper.ObjectToDictionary(value);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/ModelState.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.WebPages.Html
{
    public class ModelState
    {
        private List<string> _errors = new List<string>();

        public IList<string> Errors
        {
            get { return _errors; }
        }

        public object Value { get; set; }
    }
}


================================================
FILE: src/System.Web.WebPages/Html/ModelStateDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace System.Web.WebPages.Html
{
    // Most of the code for this class is copied from MVC 2.0
    public class ModelStateDictionary : IDictionary<string, ModelState>
    {
        internal const string FormFieldKey = "_FORM";
        private readonly Dictionary<string, ModelState> _innerDictionary = new Dictionary<string, ModelState>(StringComparer.OrdinalIgnoreCase);

        public ModelStateDictionary()
        {
        }

        public ModelStateDictionary(ModelStateDictionary dictionary)
        {
            if (dictionary == null)
            {
                throw new ArgumentNullException("dictionary");
            }

            foreach (var entry in dictionary)
            {
                _innerDictionary.Add(entry.Key, entry.Value);
            }
        }

        public int Count
        {
            get { return _innerDictionary.Count; }
        }

        public bool IsReadOnly
        {
            get { return ((IDictionary<string, ModelState>)_innerDictionary).IsReadOnly; }
        }

        public bool IsValid
        {
            get { return !Values.SelectMany(modelState => modelState.Errors).Any(); }
        }

        public ICollection<string> Keys
        {
            get { return _innerDictionary.Keys; }
        }

        public ICollection<ModelState> Values
        {
            get { return _innerDictionary.Values; }
        }

        public ModelState this[string key]
        {
            get
            {
                ModelState value;
                _innerDictionary.TryGetValue(key, out value);
                return value;
            }
            set { _innerDictionary[key] = value; }
        }

        public void Add(KeyValuePair<string, ModelState> item)
        {
            ((IDictionary<string, ModelState>)_innerDictionary).Add(item);
        }

        public void Add(string key, ModelState value)
        {
            _innerDictionary.Add(key, value);
        }

        public void AddError(string key, string errorMessage)
        {
            GetModelStateForKey(key).Errors.Add(errorMessage);
        }

        public void AddFormError(string errorMessage)
        {
            GetModelStateForKey(FormFieldKey).Errors.Add(errorMessage);
        }

        public void Clear()
        {
            _innerDictionary.Clear();
        }

        public bool Contains(KeyValuePair<string, ModelState> item)
        {
            return ((IDictionary<string, ModelState>)_innerDictionary).Contains(item);
        }

        public bool ContainsKey(string key)
        {
            return _innerDictionary.ContainsKey(key);
        }

        public void CopyTo(KeyValuePair<string, ModelState>[] array, int arrayIndex)
        {
            ((IDictionary<string, ModelState>)_innerDictionary).CopyTo(array, arrayIndex);
        }

        public IEnumerator<KeyValuePair<string, ModelState>> GetEnumerator()
        {
            return _innerDictionary.GetEnumerator();
        }

        private ModelState GetModelStateForKey(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            ModelState modelState;
            if (!TryGetValue(key, out modelState))
            {
                modelState = new ModelState();
                _innerDictionary[key] = modelState;
            }

            return modelState;
        }

        public bool IsValidField(string key)
        {
            if (key == null)
            {
                throw new ArgumentNullException("key");
            }

            // if the key is not found in the dictionary, we just say that it's valid (since there are no errors)
            ModelState modelState = this[key];
            return (modelState == null) || !modelState.Errors.Any();
        }

        public void Merge(ModelStateDictionary dictionary)
        {
            if (dictionary == null)
            {
                return;
            }

            foreach (var entry in dictionary)
            {
                this[entry.Key] = entry.Value;
            }
        }

        public bool Remove(KeyValuePair<string, ModelState> item)
        {
            return ((IDictionary<string, ModelState>)_innerDictionary).Remove(item);
        }

        public bool Remove(string key)
        {
            return _innerDictionary.Remove(key);
        }

        public bool TryGetValue(string key, out ModelState value)
        {
            return _innerDictionary.TryGetValue(key, out value);
        }

        public void SetModelValue(string key, object value)
        {
            ModelState state = GetModelStateForKey(key);
            state.Value = value;
        }

        #region IEnumerable Members

        IEnumerator IEnumerable.GetEnumerator()
        {
            return ((IEnumerable)_innerDictionary).GetEnumerator();
        }

        #endregion
    }
}


================================================
FILE: src/System.Web.WebPages/Html/SelectListItem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages.Html
{
    public class SelectListItem
    {
        public SelectListItem()
        {
        }

        public SelectListItem(SelectListItem item)
        {
            Text = item.Text;
            Value = item.Value;
            Selected = item.Selected;
        }

        public string Text { get; set; }

        public string Value { get; set; }

        public bool Selected { get; set; }
    }
}


================================================
FILE: src/System.Web.WebPages/HttpContextExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.WebPages
{
    public static class HttpContextExtensions
    {
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "Response.Redirect() takes its URI as a string parameter.")]
        public static void RedirectLocal(this HttpContextBase context, string url)
        {
            if (context.Request.IsUrlLocalToHost(url))
            {
                context.Response.Redirect(url);
            }
            else
            {
                context.Response.Redirect("~/");
            }
        }

        public static void RegisterForDispose(this HttpContextBase context, IDisposable resource)
        {
            if (context == null)
            {
                throw new ArgumentNullException("context");
            }
            RequestResourceTracker.RegisterForDispose(context, resource);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/IDisplayMode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// An interface that provides DisplayInfo for a virtual path and request. An IDisplayMode may modify the virtual path before checking
    /// if it exists. CanHandleContext is called to determine if the Display Mode is available to return display info for the request.
    /// GetDisplayInfo should return null if the virtual path does not exist. For an example implementation, see DefaultDisplayMode.
    /// DisplayModeId is used to cache the non-null result of a call to GetDisplayInfo and should be unique for each Display Mode. See
    /// DisplayModes for the built-in Display Modes and their ids.
    /// </summary>
    public interface IDisplayMode
    {
        string DisplayModeId { get; }
        bool CanHandleContext(HttpContextBase httpContext);
        DisplayInfo GetDisplayInfo(HttpContextBase httpContext, string virtualPath, Func<string, bool> virtualPathExists);
    }
}


================================================
FILE: src/System.Web.WebPages/ITemplateFile.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// An interface that provides information about the current executing file.
    /// WebPageRenderingBase implements this type so that all pages excluding AppStart pages could be queried to identify the 
    /// current executing file.
    /// </summary>
    public interface ITemplateFile
    {
        TemplateFileInfo TemplateInfo { get; }
    }
}


================================================
FILE: src/System.Web.WebPages/IVirtualPathFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    // Implemented by classes that can create object instances from virtual path.
    // Those implementations can completely bypass the BuildManager (e.g. for dynamic language pages)
    public interface IVirtualPathFactory
    {
        bool Exists(string virtualPath);
        object CreateInstance(string virtualPath);
    }
}


================================================
FILE: src/System.Web.WebPages/IVirtualPathUtility.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.Internal.Web.Utils
{
    internal interface IVirtualPathUtility
    {
        string Combine(string basePath, string relativePath);

        string ToAbsolute(string virtualPath);
    }
}


================================================
FILE: src/System.Web.WebPages/IWebPageRequestExecutor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    // An executor is a class that can take over the execution of a WebPage. This can be used to
    // implement features like AJAX callback methods on the page (like WebForms Page Methods)
    public interface IWebPageRequestExecutor
    {
        bool Execute(WebPage page);
    }
}


================================================
FILE: src/System.Web.WebPages/Instrumentation/HttpContextAdapter.Availability.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

namespace System.Web.WebPages.Instrumentation
{
    internal partial class HttpContextAdapter
    {
        private static readonly bool _isInstrumentationAvailable = typeof(HttpContext).GetProperty("PageInstrumentation", BindingFlags.Instance | BindingFlags.Public) != null;

        internal static bool IsInstrumentationAvailable
        {
            get { return _isInstrumentationAvailable; }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Instrumentation/HttpContextAdapter.generated.cs
================================================
using System.CodeDom.Compiler;

namespace System.Web.WebPages.Instrumentation
{
    [GeneratedCode("Microsoft.Web.CodeGen.DynamicCallerGenerator", "1.0.0.0")]
    internal partial class HttpContextAdapter
    {
        internal PageInstrumentationServiceAdapter PageInstrumentation
        {
            get { return new PageInstrumentationServiceAdapter((object)Adaptee.PageInstrumentation); }
        }

        // BEGIN Adaptor Infrastructure Code
        private static readonly Type _TargetType = typeof(HttpContext);
        internal dynamic Adaptee { get; private set; }

        internal HttpContextAdapter(object existing)
        {
            Adaptee = existing;
        }

        // END Adaptor Infrastructure Code
    }
}


================================================
FILE: src/System.Web.WebPages/Instrumentation/HttpContextAdapter.tt
================================================
<#@ template debug="false" hostspecific="true" language="C#" inherits="Microsoft.Web.CodeGen.DynamicCallerGenerator" #>
<#@ import namespace="System.Reflection" #>
<#@ assembly name="$(SolutionDir)\tools\Microsoft.Web.CodeGen\Microsoft.Web.CodeGen.dll" #>
<#@ output extension=".cs" #>
<#
TargetNamespace = "System.Web.WebPages.Instrumentation";

Include(MemberTypes.Property, "PageInstrumentation");

Map(
	"System.Web.Instrumentation.PageInstrumentationService",
	"System.Web.WebPages.Instrumentation.PageInstrumentationServiceAdapter",
	s => {#><#=s#>.Adaptee<#},
	s => {#>new PageInstrumentationServiceAdapter(<#=s#>)<#}
);

WriteAdaptor(
	"System.Web.HttpContext", 
	Host.ResolvePath(@"..\..\..\ReferenceAssemblies\NetFx\Dev11\System.Web.dll")
); 
#>

================================================
FILE: src/System.Web.WebPages/Instrumentation/InstrumentationService.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.IO;

namespace System.Web.WebPages.Instrumentation
{
    public class InstrumentationService
    {
        private static readonly bool _isAvailable = HttpContextAdapter.IsInstrumentationAvailable;
        private bool _localIsAvailable = _isAvailable && PageInstrumentationServiceAdapter.IsEnabled;

        private PageInstrumentationServiceAdapter _instrumentationServiceAdapter;
        private bool _isInstrumentationServiceAdapterInitialized;

        public InstrumentationService()
        {
            ExtractInstrumentationService = GetInstrumentationServiceUncached;
            CreateContext = CreateSystemWebContext;
        }

        public bool IsAvailable
        {
            get { return _localIsAvailable; }
            internal set { _localIsAvailable = value; }
        }

        internal Func<HttpContextBase, PageInstrumentationServiceAdapter> ExtractInstrumentationService { get; set; }
        internal Func<string, TextWriter, int, int, bool, PageExecutionContextAdapter> CreateContext { get; set; }

        public void BeginContext(HttpContextBase context, string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            if (IsAvailable)
            {
                PageInstrumentationServiceAdapter instrumentationService = GetInstrumentationService(context);
                if (instrumentationService != null && instrumentationService.ExecutionListeners.Count > 0)
                {
                    var instrumentationContext = CreateContext(virtualPath, writer, startPosition, length, isLiteral);
                    foreach (PageExecutionListenerAdapter listener in instrumentationService.ExecutionListeners)
                    {
                        listener.BeginContext(instrumentationContext);
                    }
                }
            }
        }

        public void EndContext(HttpContextBase context, string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            if (IsAvailable)
            {
                PageInstrumentationServiceAdapter instrumentationService = GetInstrumentationService(context);
                if (instrumentationService != null && instrumentationService.ExecutionListeners.Count > 0)
                {
                    var instrumentationContext = CreateContext(virtualPath, writer, startPosition, length, isLiteral);
                    foreach (PageExecutionListenerAdapter listener in instrumentationService.ExecutionListeners)
                    {
                        listener.EndContext(instrumentationContext);
                    }
                }
            }
        }

        private static PageExecutionContextAdapter CreateSystemWebContext(string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            return new PageExecutionContextAdapter()
            {
                VirtualPath = virtualPath,
                TextWriter = writer,
                StartPosition = startPosition,
                Length = length,
                IsLiteral = isLiteral
            };
        }

        private PageInstrumentationServiceAdapter GetInstrumentationService(HttpContextBase context)
        {
            // There seems to be the potential for the adapter to be null.
            if (!_isInstrumentationServiceAdapterInitialized)
            {
                _instrumentationServiceAdapter = ExtractInstrumentationService(context);

                _isInstrumentationServiceAdapterInitialized = true;
            }

            return _instrumentationServiceAdapter;
        }

        private PageInstrumentationServiceAdapter GetInstrumentationServiceUncached(HttpContextBase context)
        {
            HttpContextAdapter ctx = new HttpContextAdapter(context);
            return ctx.PageInstrumentation;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Instrumentation/PageExecutionContextAdapter.generated.cs
================================================
using System.CodeDom.Compiler;
using System.IO;
using System.Linq.Expressions;

namespace System.Web.WebPages.Instrumentation
{
    [GeneratedCode("Microsoft.Web.CodeGen.DynamicCallerGenerator", "1.0.0.0")]
    internal partial class PageExecutionContextAdapter
    {
        internal bool IsLiteral
        {
            get { return Adaptee.IsLiteral; }
            set { Adaptee.IsLiteral = value; }
        }

        internal int Length
        {
            get { return Adaptee.Length; }
            set { Adaptee.Length = value; }
        }

        internal int StartPosition
        {
            get { return Adaptee.StartPosition; }
            set { Adaptee.StartPosition = value; }
        }

        internal TextWriter TextWriter
        {
            get { return Adaptee.TextWriter; }
            set { Adaptee.TextWriter = value; }
        }

        internal string VirtualPath
        {
            get { return Adaptee.VirtualPath; }
            set { Adaptee.VirtualPath = value; }
        }

        private static class _CallSite_ctor_1
        {
            public static Func<object> Site;

            static _CallSite_ctor_1()
            {
                Site = Expression.Lambda<Func<object>>(
                    Expression.New(_TargetType.GetConstructor(new Type[] { })))
                    .Compile();
            }
        }

        internal PageExecutionContextAdapter()
        {
            Adaptee = _CallSite_ctor_1.Site();
        }

        // BEGIN Adaptor Infrastructure Code
        private static readonly Type _TargetType = typeof(HttpContext).Assembly.GetType("System.Web.Instrumentation.PageExecutionContext");
        internal dynamic Adaptee { get; private set; }

        internal PageExecutionContextAdapter(object existing)
        {
            Adaptee = existing;
        }

        // END Adaptor Infrastructure Code
    }
}


================================================
FILE: src/System.Web.WebPages/Instrumentation/PageExecutionContextAdapter.tt
================================================
<#@ template debug="false" hostspecific="true" language="C#" inherits="Microsoft.Web.CodeGen.DynamicCallerGenerator" #>
<#@ assembly name="$(SolutionDir)\tools\Microsoft.Web.CodeGen\Microsoft.Web.CodeGen.dll" #>
<#@ output extension=".cs" #>
<# 
TargetNamespace = "System.Web.WebPages.Instrumentation";
WriteAdaptor(
	"System.Web.Instrumentation.PageExecutionContext", 
	Host.ResolvePath(@"..\..\..\ReferenceAssemblies\NetFx\Dev11\System.Web.dll")
); #>

================================================
FILE: src/System.Web.WebPages/Instrumentation/PageExecutionListenerAdapter.generated.cs
================================================
using System.CodeDom.Compiler;

namespace System.Web.WebPages.Instrumentation
{
    [GeneratedCode("Microsoft.Web.CodeGen.DynamicCallerGenerator", "1.0.0.0")]
    internal partial class PageExecutionListenerAdapter
    {
        internal void BeginContext(PageExecutionContextAdapter context)
        {
            Adaptee.BeginContext(context.Adaptee);
        }

        internal void EndContext(PageExecutionContextAdapter context)
        {
            Adaptee.EndContext(context.Adaptee);
        }

        // BEGIN Adaptor Infrastructure Code
        private static readonly Type _TargetType = typeof(HttpContext).Assembly.GetType("System.Web.Instrumentation.PageExecutionListener");
        internal dynamic Adaptee { get; private set; }

        internal PageExecutionListenerAdapter(object existing)
        {
            Adaptee = existing;
        }

        // END Adaptor Infrastructure Code
    }
}


================================================
FILE: src/System.Web.WebPages/Instrumentation/PageExecutionListenerAdapter.tt
================================================
<#@ template debug="false" hostspecific="true" language="C#" inherits="Microsoft.Web.CodeGen.DynamicCallerGenerator" #>
<#@ assembly name="$(SolutionDir)\tools\Microsoft.Web.CodeGen\Microsoft.Web.CodeGen.dll" #>
<#@ output extension=".cs" #>
<# 
TargetNamespace = "System.Web.WebPages.Instrumentation";
Map(
	"System.Web.Instrumentation.PageExecutionContext", 
	"System.Web.WebPages.Instrumentation.PageExecutionContextAdapter", 
	s => {#><#=s#>.Adaptee<#}
);
WriteAdaptor(
	"System.Web.Instrumentation.PageExecutionListener", 
	Host.ResolvePath(@"..\..\..\ReferenceAssemblies\NetFx\Dev11\System.Web.dll")
); #>

================================================
FILE: src/System.Web.WebPages/Instrumentation/PageInstrumentationServiceAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace System.Web.WebPages.Instrumentation
{
    internal partial class PageInstrumentationServiceAdapter
    {
        private static readonly Type _targetType = typeof(HttpContext).Assembly.GetType("System.Web.Instrumentation.PageInstrumentationService");
        private IReadOnlyList<PageExecutionListenerAdapter> _listenerAdapters;

        internal PageInstrumentationServiceAdapter()
        {
            Adaptee = _CallSite_ctor_2.Site();
        }

        internal PageInstrumentationServiceAdapter(object existing)
        {
            Adaptee = existing;
        }

        internal IReadOnlyList<PageExecutionListenerAdapter> ExecutionListeners
        {
            get
            {
                if (_listenerAdapters == null)
                {
                    IEnumerable<dynamic> inner = Adaptee.ExecutionListeners;
                    // Bug 235916: If we pass the type as an object, the callsite is limited to wherever the object is assigned to 
                    // dynamic which avoids private reflection issues in partial trust.
                    _listenerAdapters = inner.Select(listener => new PageExecutionListenerAdapter((object)listener)).ToList();
                }

                return _listenerAdapters;
            }
        }

        internal static bool IsEnabled
        {
            get { return _CallSite_IsEnabled_1.Getter(); }
            set { _CallSite_IsEnabled_1.Setter(value); }
        }

        internal dynamic Adaptee { get; private set; }

        private static class _CallSite_IsEnabled_1
        {
            public static Func<bool> Getter;
            public static Action<bool> Setter;

            [SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline", Justification = "Fields cannot be initialized at declaration")]
            static _CallSite_IsEnabled_1()
            {
                PropertyInfo prop = null;
                if (_targetType != null)
                {
                    prop = _targetType.GetProperty("IsEnabled", BindingFlags.Static | BindingFlags.Public, Type.DefaultBinder, typeof(bool), Type.EmptyTypes, new ParameterModifier[0]);
                }
                if (prop != null)
                {
                    Getter = Expression.Lambda<Func<bool>>(Expression.Property(null, prop)).Compile();
                    ParameterExpression value = Expression.Parameter(typeof(bool));
                    Setter = Expression.Lambda<Action<bool>>(
                        Expression.Assign(Expression.Property(null, prop), value), value).Compile();
                }
                else
                {
                    Getter = () => false;
                    Setter = _ =>
                    {
                    };
                }
            }
        }

        private static class _CallSite_ctor_2
        {
            public static Func<object> Site;

            [SuppressMessage("Microsoft.Performance", "CA1810:InitializeReferenceTypeStaticFieldsInline", Justification = "Fields cannot be initialized at declaration")]
            static _CallSite_ctor_2()
            {
                if (_targetType != null)
                {
                    Site = Expression.Lambda<Func<object>>(
                        Expression.New(
                            _targetType.GetConstructor(new Type[] { })))
                        .Compile();
                }
                else
                {
                    Site = () => null;
                }
            }
        }

        // END Adaptor Infrastructure Code
    }
}


================================================
FILE: src/System.Web.WebPages/Instrumentation/PositionTagged.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Instrumentation
{
    [DebuggerDisplay("({Position})\"{Value}\"")]
    public class PositionTagged<T>
    {
        private PositionTagged()
        {
            Position = 0;
            Value = default(T);
        }

        public PositionTagged(T value, int offset)
        {
            Position = offset;
            Value = value;
        }

        public int Position { get; private set; }
        public T Value { get; private set; }

        public override bool Equals(object obj)
        {
            PositionTagged<T> other = obj as PositionTagged<T>;
            return other != null &&
                   other.Position == Position &&
                   Equals(other.Value, Value);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Position)
                .Add(Value)
                .CombinedHash;
        }

        public override string ToString()
        {
            return Value.ToString();
        }

        public static implicit operator T(PositionTagged<T> value)
        {
            return value.Value;
        }

        public static implicit operator PositionTagged<T>(Tuple<T, int> value)
        {
            return new PositionTagged<T>(value.Item1, value.Item2);
        }

        public static bool operator ==(PositionTagged<T> left, PositionTagged<T> right)
        {
            return Equals(left, right);
        }

        public static bool operator !=(PositionTagged<T> left, PositionTagged<T> right)
        {
            return !Equals(left, right);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/MimeMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.IO;

namespace Microsoft.Internal.Web.Utils
{
    internal static class MimeMapping
    {
        private static readonly IDictionary<string, string> _mimeMappings = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
        {
            { ".*", "application/octet-stream" },
            { ".323", "text/h323" },
            { ".aaf", "application/octet-stream" },
            { ".aca", "application/octet-stream" },
            { ".accdb", "application/msaccess" },
            { ".accde", "application/msaccess" },
            { ".accdt", "application/msaccess" },
            { ".acx", "application/internet-property-stream" },
            { ".afm", "application/octet-stream" },
            { ".ai", "application/postscript" },
            { ".aif", "audio/x-aiff" },
            { ".aifc", "audio/aiff" },
            { ".aiff", "audio/aiff" },
            { ".application", "application/x-ms-application" },
            { ".art", "image/x-jg" },
            { ".asd", "application/octet-stream" },
            { ".asf", "video/x-ms-asf" },
            { ".asi", "application/octet-stream" },
            { ".asm", "text/plain" },
            { ".asr", "video/x-ms-asf" },
            { ".asx", "video/x-ms-asf" },
            { ".atom", "application/atom+xml" },
            { ".au", "audio/basic" },
            { ".avi", "video/x-msvideo" },
            { ".axs", "application/olescript" },
            { ".bas", "text/plain" },
            { ".bcpio", "application/x-bcpio" },
            { ".bin", "application/octet-stream" },
            { ".bmp", "image/bmp" },
            { ".c", "text/plain" },
            { ".cab", "application/octet-stream" },
            { ".calx", "application/vnd.ms-office.calx" },
            { ".cat", "application/vnd.ms-pki.seccat" },
            { ".cdf", "application/x-cdf" },
            { ".chm", "application/octet-stream" },
            { ".class", "application/x-java-applet" },
            { ".clp", "application/x-msclip" },
            { ".cmx", "image/x-cmx" },
            { ".cnf", "text/plain" },
            { ".cod", "image/cis-cod" },
            { ".cpio", "application/x-cpio" },
            { ".cpp", "text/plain" },
            { ".crd", "application/x-mscardfile" },
            { ".crl", "application/pkix-crl" },
            { ".crt", "application/x-x509-ca-cert" },
            { ".csh", "application/x-csh" },
            { ".css", "text/css" },
            { ".csv", "application/octet-stream" },
            { ".cur", "application/octet-stream" },
            { ".dcr", "application/x-director" },
            { ".deploy", "application/octet-stream" },
            { ".der", "application/x-x509-ca-cert" },
            { ".dib", "image/bmp" },
            { ".dir", "application/x-director" },
            { ".disco", "text/xml" },
            { ".dll", "application/x-msdownload" },
            { ".dll.config", "text/xml" },
            { ".dlm", "text/dlm" },
            { ".doc", "application/msword" },
            { ".docm", "application/vnd.ms-word.document.macroEnabled.12" },
            { ".docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document" },
            { ".dot", "application/msword" },
            { ".dotm", "application/vnd.ms-word.template.macroEnabled.12" },
            { ".dotx", "application/vnd.openxmlformats-officedocument.wordprocessingml.template" },
            { ".dsp", "application/octet-stream" },
            { ".dtd", "text/xml" },
            { ".dvi", "application/x-dvi" },
            { ".dwf", "drawing/x-dwf" },
            { ".dwp", "application/octet-stream" },
            { ".dxr", "application/x-director" },
            { ".eml", "message/rfc822" },
            { ".emz", "application/octet-stream" },
            { ".eot", "application/octet-stream" },
            { ".eps", "application/postscript" },
            { ".etx", "text/x-setext" },
            { ".evy", "application/envoy" },
            { ".exe", "application/octet-stream" },
            { ".exe.config", "text/xml" },
            { ".fdf", "application/vnd.fdf" },
            { ".fif", "application/fractals" },
            { ".fla", "application/octet-stream" },
            { ".flr", "x-world/x-vrml" },
            { ".flv", "video/x-flv" },
            { ".gif", "image/gif" },
            { ".gtar", "application/x-gtar" },
            { ".gz", "application/x-gzip" },
            { ".h", "text/plain" },
            { ".hdf", "application/x-hdf" },
            { ".hdml", "text/x-hdml" },
            { ".hhc", "application/x-oleobject" },
            { ".hhk", "application/octet-stream" },
            { ".hhp", "application/octet-stream" },
            { ".hlp", "application/winhlp" },
            { ".hqx", "application/mac-binhex40" },
            { ".hta", "application/hta" },
            { ".htc", "text/x-component" },
            { ".htm", "text/html" },
            { ".html", "text/html" },
            { ".htt", "text/webviewhtml" },
            { ".hxt", "text/html" },
            { ".ico", "image/x-icon" },
            { ".ics", "application/octet-stream" },
            { ".ief", "image/ief" },
            { ".iii", "application/x-iphone" },
            { ".inf", "application/octet-stream" },
            { ".ins", "application/x-internet-signup" },
            { ".isp", "application/x-internet-signup" },
            { ".IVF", "video/x-ivf" },
            { ".jar", "application/java-archive" },
            { ".java", "application/octet-stream" },
            { ".jck", "application/liquidmotion" },
            { ".jcz", "application/liquidmotion" },
            { ".jfif", "image/pjpeg" },
            { ".jpb", "application/octet-stream" },
            { ".jpe", "image/jpeg" },
            { ".jpeg", "image/jpeg" },
            { ".jpg", "image/jpeg" },
            { ".js", "application/x-javascript" },
            { ".jsx", "text/jscript" },
            { ".latex", "application/x-latex" },
            { ".lit", "application/x-ms-reader" },
            { ".lpk", "application/octet-stream" },
            { ".lsf", "video/x-la-asf" },
            { ".lsx", "video/x-la-asf" },
            { ".lzh", "application/octet-stream" },
            { ".m13", "application/x-msmediaview" },
            { ".m14", "application/x-msmediaview" },
            { ".m1v", "video/mpeg" },
            { ".m3u", "audio/x-mpegurl" },
            { ".man", "application/x-troff-man" },
            { ".manifest", "application/x-ms-manifest" },
            { ".map", "text/plain" },
            { ".mdb", "application/x-msaccess" },
            { ".mdp", "application/octet-stream" },
            { ".me", "application/x-troff-me" },
            { ".mht", "message/rfc822" },
            { ".mhtml", "message/rfc822" },
            { ".mid", "audio/mid" },
            { ".midi", "audio/mid" },
            { ".mix", "application/octet-stream" },
            { ".mmf", "application/x-smaf" },
            { ".mno", "text/xml" },
            { ".mny", "application/x-msmoney" },
            { ".mov", "video/quicktime" },
            { ".movie", "video/x-sgi-movie" },
            { ".mp2", "video/mpeg" },
            { ".mp3", "audio/mpeg" },
            { ".mpa", "video/mpeg" },
            { ".mpe", "video/mpeg" },
            { ".mpeg", "video/mpeg" },
            { ".mpg", "video/mpeg" },
            { ".mpp", "application/vnd.ms-project" },
            { ".mpv2", "video/mpeg" },
            { ".ms", "application/x-troff-ms" },
            { ".msi", "application/octet-stream" },
            { ".mso", "application/octet-stream" },
            { ".mvb", "application/x-msmediaview" },
            { ".mvc", "application/x-miva-compiled" },
            { ".nc", "application/x-netcdf" },
            { ".nsc", "video/x-ms-asf" },
            { ".nws", "message/rfc822" },
            { ".ocx", "application/octet-stream" },
            { ".oda", "application/oda" },
            { ".odc", "text/x-ms-odc" },
            { ".ods", "application/oleobject" },
            { ".one", "application/onenote" },
            { ".onea", "application/onenote" },
            { ".onetoc", "application/onenote" },
            { ".onetoc2", "application/onenote" },
            { ".onetmp", "application/onenote" },
            { ".onepkg", "application/onenote" },
            { ".osdx", "application/opensearchdescription+xml" },
            { ".p10", "application/pkcs10" },
            { ".p12", "application/x-pkcs12" },
            { ".p7b", "application/x-pkcs7-certificates" },
            { ".p7c", "application/pkcs7-mime" },
            { ".p7m", "application/pkcs7-mime" },
            { ".p7r", "application/x-pkcs7-certreqresp" },
            { ".p7s", "application/pkcs7-signature" },
            { ".pbm", "image/x-portable-bitmap" },
            { ".pcx", "application/octet-stream" },
            { ".pcz", "application/octet-stream" },
            { ".pdf", "application/pdf" },
            { ".pfb", "application/octet-stream" },
            { ".pfm", "application/octet-stream" },
            { ".pfx", "application/x-pkcs12" },
            { ".pgm", "image/x-portable-graymap" },
            { ".pko", "application/vnd.ms-pki.pko" },
            { ".pma", "application/x-perfmon" },
            { ".pmc", "application/x-perfmon" },
            { ".pml", "application/x-perfmon" },
            { ".pmr", "application/x-perfmon" },
            { ".pmw", "application/x-perfmon" },
            { ".png", "image/png" },
            { ".pnm", "image/x-portable-anymap" },
            { ".pnz", "image/png" },
            { ".pot", "application/vnd.ms-powerpoint" },
            { ".potm", "application/vnd.ms-powerpoint.template.macroEnabled.12" },
            { ".potx", "application/vnd.openxmlformats-officedocument.presentationml.template" },
            { ".ppam", "application/vnd.ms-powerpoint.addin.macroEnabled.12" },
            { ".ppm", "image/x-portable-pixmap" },
            { ".pps", "application/vnd.ms-powerpoint" },
            { ".ppsm", "application/vnd.ms-powerpoint.slideshow.macroEnabled.12" },
            { ".ppsx", "application/vnd.openxmlformats-officedocument.presentationml.slideshow" },
            { ".ppt", "application/vnd.ms-powerpoint" },
            { ".pptm", "application/vnd.ms-powerpoint.presentation.macroEnabled.12" },
            { ".pptx", "application/vnd.openxmlformats-officedocument.presentationml.presentation" },
            { ".prf", "application/pics-rules" },
            { ".prm", "application/octet-stream" },
            { ".prx", "application/octet-stream" },
            { ".ps", "application/postscript" },
            { ".psd", "application/octet-stream" },
            { ".psm", "application/octet-stream" },
            { ".psp", "application/octet-stream" },
            { ".pub", "application/x-mspublisher" },
            { ".qt", "video/quicktime" },
            { ".qtl", "application/x-quicktimeplayer" },
            { ".qxd", "application/octet-stream" },
            { ".ra", "audio/x-pn-realaudio" },
            { ".ram", "audio/x-pn-realaudio" },
            { ".rar", "application/octet-stream" },
            { ".ras", "image/x-cmu-raster" },
            { ".rf", "image/vnd.rn-realflash" },
            { ".rgb", "image/x-rgb" },
            { ".rm", "application/vnd.rn-realmedia" },
            { ".rmi", "audio/mid" },
            { ".roff", "application/x-troff" },
            { ".rpm", "audio/x-pn-realaudio-plugin" },
            { ".rtf", "application/rtf" },
            { ".rtx", "text/richtext" },
            { ".scd", "application/x-msschedule" },
            { ".sct", "text/scriptlet" },
            { ".sea", "application/octet-stream" },
            { ".setpay", "application/set-payment-initiation" },
            { ".setreg", "application/set-registration-initiation" },
            { ".sgml", "text/sgml" },
            { ".sh", "application/x-sh" },
            { ".shar", "application/x-shar" },
            { ".sit", "application/x-stuffit" },
            { ".sldm", "application/vnd.ms-powerpoint.slide.macroEnabled.12" },
            { ".sldx", "application/vnd.openxmlformats-officedocument.presentationml.slide" },
            { ".smd", "audio/x-smd" },
            { ".smi", "application/octet-stream" },
            { ".smx", "audio/x-smd" },
            { ".smz", "audio/x-smd" },
            { ".snd", "audio/basic" },
            { ".snp", "application/octet-stream" },
            { ".spc", "application/x-pkcs7-certificates" },
            { ".spl", "application/futuresplash" },
            { ".src", "application/x-wais-source" },
            { ".ssm", "application/streamingmedia" },
            { ".sst", "application/vnd.ms-pki.certstore" },
            { ".stl", "application/vnd.ms-pki.stl" },
            { ".sv4cpio", "application/x-sv4cpio" },
            { ".sv4crc", "application/x-sv4crc" },
            { ".swf", "application/x-shockwave-flash" },
            { ".t", "application/x-troff" },
            { ".tar", "application/x-tar" },
            { ".tcl", "application/x-tcl" },
            { ".tex", "application/x-tex" },
            { ".texi", "application/x-texinfo" },
            { ".texinfo", "application/x-texinfo" },
            { ".tgz", "application/x-compressed" },
            { ".thmx", "application/vnd.ms-officetheme" },
            { ".thn", "application/octet-stream" },
            { ".tif", "image/tiff" },
            { ".tiff", "image/tiff" },
            { ".toc", "application/octet-stream" },
            { ".tr", "application/x-troff" },
            { ".trm", "application/x-msterminal" },
            { ".tsv", "text/tab-separated-values" },
            { ".ttf", "application/octet-stream" },
            { ".txt", "text/plain" },
            { ".u32", "application/octet-stream" },
            { ".uls", "text/iuls" },
            { ".ustar", "application/x-ustar" },
            { ".vbs", "text/vbscript" },
            { ".vcf", "text/x-vcard" },
            { ".vcs", "text/plain" },
            { ".vdx", "application/vnd.ms-visio.viewer" },
            { ".vml", "text/xml" },
            { ".vsd", "application/vnd.visio" },
            { ".vss", "application/vnd.visio" },
            { ".vst", "application/vnd.visio" },
            { ".vsto", "application/x-ms-vsto" },
            { ".vsw", "application/vnd.visio" },
            { ".vsx", "application/vnd.visio" },
            { ".vtx", "application/vnd.visio" },
            { ".wav", "audio/wav" },
            { ".wax", "audio/x-ms-wax" },
            { ".wbmp", "image/vnd.wap.wbmp" },
            { ".wcm", "application/vnd.ms-works" },
            { ".wdb", "application/vnd.ms-works" },
            { ".wks", "application/vnd.ms-works" },
            { ".wm", "video/x-ms-wm" },
            { ".wma", "audio/x-ms-wma" },
            { ".wmd", "application/x-ms-wmd" },
            { ".wmf", "application/x-msmetafile" },
            { ".wml", "text/vnd.wap.wml" },
            { ".wmlc", "application/vnd.wap.wmlc" },
            { ".wmls", "text/vnd.wap.wmlscript" },
            { ".wmlsc", "application/vnd.wap.wmlscriptc" },
            { ".wmp", "video/x-ms-wmp" },
            { ".wmv", "video/x-ms-wmv" },
            { ".wmx", "video/x-ms-wmx" },
            { ".wmz", "application/x-ms-wmz" },
            { ".wps", "application/vnd.ms-works" },
            { ".wri", "application/x-mswrite" },
            { ".wrl", "x-world/x-vrml" },
            { ".wrz", "x-world/x-vrml" },
            { ".wsdl", "text/xml" },
            { ".wvx", "video/x-ms-wvx" },
            { ".x", "application/directx" },
            { ".xaf", "x-world/x-vrml" },
            { ".xaml", "application/xaml+xml" },
            { ".xap", "application/x-silverlight-app" },
            { ".xbap", "application/x-ms-xbap" },
            { ".xbm", "image/x-xbitmap" },
            { ".xdr", "text/plain" },
            { ".xla", "application/vnd.ms-excel" },
            { ".xlam", "application/vnd.ms-excel.addin.macroEnabled.12" },
            { ".xlc", "application/vnd.ms-excel" },
            { ".xlm", "application/vnd.ms-excel" },
            { ".xls", "application/vnd.ms-excel" },
            { ".xlsb", "application/vnd.ms-excel.sheet.binary.macroEnabled.12" },
            { ".xlsm", "application/vnd.ms-excel.sheet.macroEnabled.12" },
            { ".xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" },
            { ".xlt", "application/vnd.ms-excel" },
            { ".xltm", "application/vnd.ms-excel.template.macroEnabled.12" },
            { ".xltx", "application/vnd.openxmlformats-officedocument.spreadsheetml.template" },
            { ".xlw", "application/vnd.ms-excel" },
            { ".xml", "text/xml" },
            { ".xof", "x-world/x-vrml" },
            { ".xpm", "image/x-xpixmap" },
            { ".xps", "application/vnd.ms-xpsdocument" },
            { ".xsd", "text/xml" },
            { ".xsf", "text/xml" },
            { ".xsl", "text/xml" },
            { ".xslt", "text/xml" },
            { ".xsn", "application/octet-stream" },
            { ".xtp", "application/octet-stream" },
            { ".xwd", "image/x-xwindowdump" },
            { ".z", "application/x-compress" },
            { ".zip", "application/x-zip-compressed" }
        };

        internal static string GetMimeMapping(string fileName)
        {
            if (fileName == null)
            {
                throw new ArgumentNullException("fileName");
            }

            string contentType = null;
            string extension = Path.GetExtension(fileName);
            if (_mimeMappings.TryGetValue(extension, out contentType))
            {
                return contentType;
            }
            return _mimeMappings[".*"];
        }

        internal static void AddMimeMapping(string extension, string mimeType)
        {
            _mimeMappings.Add(extension, mimeType);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/HttpAntiForgeryException.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Web.WebPages.Resources;

namespace System.Web.Mvc
{
    [Serializable]
    [TypeForwardedFrom("System.Web.Mvc, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public sealed class HttpAntiForgeryException : HttpException
    {
        public HttpAntiForgeryException()
        {
        }

        private HttpAntiForgeryException(SerializationInfo info, StreamingContext context)
            : base(info, context)
        {
        }

        public HttpAntiForgeryException(string message)
            : base(message)
        {
        }

        private HttpAntiForgeryException(string message, params object[] args)
            : this(String.Format(CultureInfo.CurrentCulture, message, args))
        {
        }

        public HttpAntiForgeryException(string message, Exception innerException)
            : base(message, innerException)
        {
        }

        internal static HttpAntiForgeryException CreateAdditionalDataCheckFailedException()
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_AdditionalDataCheckFailed);
        }

        internal static HttpAntiForgeryException CreateClaimUidMismatchException()
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_ClaimUidMismatch);
        }

        internal static HttpAntiForgeryException CreateCookieMissingException(string cookieName)
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_CookieMissing, cookieName);
        }

        internal static HttpAntiForgeryException CreateDeserializationFailedException()
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_DeserializationFailed);
        }

        internal static HttpAntiForgeryException CreateFormFieldMissingException(string formFieldName)
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_FormFieldMissing, formFieldName);
        }

        internal static HttpAntiForgeryException CreateSecurityTokenMismatchException()
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_SecurityTokenMismatch);
        }

        internal static HttpAntiForgeryException CreateTokensSwappedException(string cookieName, string formFieldName)
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_TokensSwapped, cookieName, formFieldName);
        }

        internal static HttpAntiForgeryException CreateUsernameMismatchException(string usernameInToken, string currentUsername)
        {
            return new HttpAntiForgeryException(WebPageResources.AntiForgeryToken_UsernameMismatch, usernameInToken, currentUsername);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationEqualToRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class ModelClientValidationEqualToRule : ModelClientValidationRule
    {
        public ModelClientValidationEqualToRule(string errorMessage, object other)
        {
            ErrorMessage = errorMessage;
            ValidationType = "equalto";
            ValidationParameters["other"] = other;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationMaxLengthRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ModelClientValidationMaxLengthRule : ModelClientValidationRule
    {
        public ModelClientValidationMaxLengthRule(string errorMessage, int maximumLength)
        {
            ErrorMessage = errorMessage;
            ValidationType = "maxlength";
            ValidationParameters["max"] = maximumLength;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationMembershipPasswordRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    internal class ModelClientValidationMembershipPasswordRule : ModelClientValidationRule
    {
        public ModelClientValidationMembershipPasswordRule(string errorMessage, int minRequiredPasswordLength, int minRequiredNonAlphanumericCharacters, string passwordStrengthRegularExpression)
        {
            ErrorMessage = errorMessage;
            ValidationType = "password";

            if (minRequiredPasswordLength != 0)
            {
                ValidationParameters["min"] = minRequiredPasswordLength;
            }

            if (minRequiredNonAlphanumericCharacters != 0)
            {
                ValidationParameters["nonalphamin"] = minRequiredNonAlphanumericCharacters;
            }

            if (!String.IsNullOrEmpty(passwordStrengthRegularExpression))
            {
                ValidationParameters["regex"] = passwordStrengthRegularExpression;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationMinLengthRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc
{
    public class ModelClientValidationMinLengthRule : ModelClientValidationRule
    {
        public ModelClientValidationMinLengthRule(string errorMessage, int minimumLength)
        {
            ErrorMessage = errorMessage;
            ValidationType = "minlength";
            ValidationParameters["min"] = minimumLength;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationRangeRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class ModelClientValidationRangeRule : ModelClientValidationRule
    {
        public ModelClientValidationRangeRule(string errorMessage, object minValue, object maxValue)
        {
            ErrorMessage = errorMessage;
            ValidationType = "range";
            ValidationParameters["min"] = minValue;
            ValidationParameters["max"] = maxValue;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationRegexRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class ModelClientValidationRegexRule : ModelClientValidationRule
    {
        public ModelClientValidationRegexRule(string errorMessage, string pattern)
        {
            ErrorMessage = errorMessage;
            ValidationType = "regex";
            ValidationParameters.Add("pattern", pattern);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationRemoteRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class ModelClientValidationRemoteRule : ModelClientValidationRule
    {
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", Justification = "The value is a not a regular URL since it may contain ~/ ASP.NET-specific characters")]
        public ModelClientValidationRemoteRule(string errorMessage, string url, string httpMethod, string additionalFields)
        {
            ErrorMessage = errorMessage;
            ValidationType = "remote";
            ValidationParameters["url"] = url;

            if (!String.IsNullOrEmpty(httpMethod))
            {
                ValidationParameters["type"] = httpMethod;
            }

            ValidationParameters["additionalfields"] = additionalFields;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationRequiredRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class ModelClientValidationRequiredRule : ModelClientValidationRule
    {
        public ModelClientValidationRequiredRule(string errorMessage)
        {
            ErrorMessage = errorMessage;
            ValidationType = "required";
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class ModelClientValidationRule
    {
        private readonly Dictionary<string, object> _validationParameters = new Dictionary<string, object>();
        private string _validationType;

        public string ErrorMessage { get; set; }

        public IDictionary<string, object> ValidationParameters
        {
            get { return _validationParameters; }
        }

        public string ValidationType
        {
            get { return _validationType ?? String.Empty; }
            set { _validationType = value; }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/ModelClientValidationStringLengthRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class ModelClientValidationStringLengthRule : ModelClientValidationRule
    {
        public ModelClientValidationStringLengthRule(string errorMessage, int minimumLength, int maximumLength)
        {
            ErrorMessage = errorMessage;
            ValidationType = "length";

            if (minimumLength != 0)
            {
                ValidationParameters["min"] = minimumLength;
            }

            if (maximumLength != Int32.MaxValue)
            {
                ValidationParameters["max"] = maximumLength;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/TagBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Runtime.CompilerServices;
using System.Text;
using System.Web.WebPages.Html;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public class TagBuilder
    {
        private string _idAttributeDotReplacement;

        private string _innerHtml;

        public TagBuilder(string tagName)
        {
            if (String.IsNullOrEmpty(tagName))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "tagName");
            }

            TagName = tagName;
            Attributes = new SortedDictionary<string, string>(StringComparer.Ordinal);
        }

        public IDictionary<string, string> Attributes { get; private set; }

        public string IdAttributeDotReplacement
        {
            get
            {
                if (String.IsNullOrEmpty(_idAttributeDotReplacement))
                {
                    _idAttributeDotReplacement = HtmlHelper.IdAttributeDotReplacement;
                }
                return _idAttributeDotReplacement;
            }
            set { _idAttributeDotReplacement = value; }
        }

        public string InnerHtml
        {
            get { return _innerHtml ?? String.Empty; }
            set { _innerHtml = value; }
        }

        public string TagName { get; private set; }

        public void AddCssClass(string value)
        {
            string currentValue;

            if (Attributes.TryGetValue("class", out currentValue))
            {
                Attributes["class"] = value + " " + currentValue;
            }
            else
            {
                Attributes["class"] = value;
            }
        }

        public static string CreateSanitizedId(string originalId)
        {
            return CreateSanitizedId(originalId, HtmlHelper.IdAttributeDotReplacement);
        }

        public static string CreateSanitizedId(string originalId, string invalidCharReplacement)
        {
            if (String.IsNullOrEmpty(originalId))
            {
                return null;
            }

            if (invalidCharReplacement == null)
            {
                throw new ArgumentNullException("invalidCharReplacement");
            }

            char firstChar = originalId[0];
            if (!Html401IdUtil.IsLetter(firstChar))
            {
                // the first character must be a letter
                return null;
            }

            StringBuilder sb = new StringBuilder(originalId.Length);
            sb.Append(firstChar);

            for (int i = 1; i < originalId.Length; i++)
            {
                char thisChar = originalId[i];
                if (Html401IdUtil.IsValidIdCharacter(thisChar))
                {
                    sb.Append(thisChar);
                }
                else
                {
                    sb.Append(invalidCharReplacement);
                }
            }

            return sb.ToString();
        }

        public void GenerateId(string name)
        {
            if (!Attributes.ContainsKey("id"))
            {
                string sanitizedId = CreateSanitizedId(name, IdAttributeDotReplacement);
                if (!String.IsNullOrEmpty(sanitizedId))
                {
                    Attributes["id"] = sanitizedId;
                }
            }
        }

        private void AppendAttributes(StringBuilder sb)
        {
            foreach (var attribute in Attributes)
            {
                string key = attribute.Key;
                if (String.Equals(key, "id", StringComparison.Ordinal /* case-sensitive */) && String.IsNullOrEmpty(attribute.Value))
                {
                    continue; // DevDiv Bugs #227595: don't output empty IDs
                }
                string value = HttpUtility.HtmlAttributeEncode(attribute.Value);
                sb.Append(' ')
                    .Append(key)
                    .Append("=\"")
                    .Append(value)
                    .Append('"');
            }
        }

        public void MergeAttribute(string key, string value)
        {
            MergeAttribute(key, value, replaceExisting: false);
        }

        public void MergeAttribute(string key, string value, bool replaceExisting)
        {
            if (String.IsNullOrEmpty(key))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "key");
            }

            if (replaceExisting || !Attributes.ContainsKey(key))
            {
                Attributes[key] = value;
            }
        }

        public void MergeAttributes<TKey, TValue>(IDictionary<TKey, TValue> attributes)
        {
            MergeAttributes(attributes, replaceExisting: false);
        }

        public void MergeAttributes<TKey, TValue>(IDictionary<TKey, TValue> attributes, bool replaceExisting)
        {
            if (attributes != null)
            {
                foreach (var entry in attributes)
                {
                    string key = Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
                    string value = Convert.ToString(entry.Value, CultureInfo.InvariantCulture);
                    MergeAttribute(key, value, replaceExisting);
                }
            }
        }

        public void SetInnerText(string innerText)
        {
            InnerHtml = HttpUtility.HtmlEncode(innerText);
        }

        internal HtmlString ToHtmlString(TagRenderMode renderMode)
        {
            return new HtmlString(ToString(renderMode));
        }

        public override string ToString()
        {
            return ToString(TagRenderMode.Normal);
        }

        public string ToString(TagRenderMode renderMode)
        {
            StringBuilder sb = new StringBuilder();
            switch (renderMode)
            {
                case TagRenderMode.StartTag:
                    sb.Append('<')
                        .Append(TagName);
                    AppendAttributes(sb);
                    sb.Append('>');
                    break;
                case TagRenderMode.EndTag:
                    sb.Append("</")
                        .Append(TagName)
                        .Append('>');
                    break;
                case TagRenderMode.SelfClosing:
                    sb.Append('<')
                        .Append(TagName);
                    AppendAttributes(sb);
                    sb.Append(" />");
                    break;
                default:
                    sb.Append('<')
                        .Append(TagName);
                    AppendAttributes(sb);
                    sb.Append('>')
                        .Append(InnerHtml)
                        .Append("</")
                        .Append(TagName)
                        .Append('>');
                    break;
            }
            return sb.ToString();
        }

        // Valid IDs are defined in http://www.w3.org/TR/html401/types.html#type-id
        private static class Html401IdUtil
        {
            private static bool IsAllowableSpecialCharacter(char c)
            {
                switch (c)
                {
                    case '-':
                    case '_':
                    case ':':
                        // note that we're specifically excluding the '.' character
                        return true;

                    default:
                        return false;
                }
            }

            private static bool IsDigit(char c)
            {
                return ('0' <= c && c <= '9');
            }

            public static bool IsLetter(char c)
            {
                return (('A' <= c && c <= 'Z') || ('a' <= c && c <= 'z'));
            }

            public static bool IsValidIdCharacter(char c)
            {
                return (IsLetter(c) || IsDigit(c) || IsAllowableSpecialCharacter(c));
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/TagRenderMode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.CompilerServices;

namespace System.Web.Mvc
{
    [TypeForwardedFrom("System.Web.Mvc, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
    public enum TagRenderMode
    {
        Normal,
        StartTag,
        EndTag,
        SelfClosing
    }
}


================================================
FILE: src/System.Web.WebPages/Mvc/UnobtrusiveValidationAttributesGenerator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.WebPages.Resources;

namespace System.Web.Mvc
{
    public static class UnobtrusiveValidationAttributesGenerator
    {
        public static void GetValidationAttributes(IEnumerable<ModelClientValidationRule> clientRules, IDictionary<string, object> results)
        {
            if (clientRules == null)
            {
                throw new ArgumentNullException("clientRules");
            }
            if (results == null)
            {
                throw new ArgumentNullException("results");
            }

            bool renderedRules = false;

            foreach (ModelClientValidationRule rule in clientRules)
            {
                renderedRules = true;
                string ruleName = "data-val-" + rule.ValidationType;

                ValidateUnobtrusiveValidationRule(rule, results, ruleName);

                results.Add(ruleName, rule.ErrorMessage ?? String.Empty);
                ruleName += "-";

                foreach (var kvp in rule.ValidationParameters)
                {
                    results.Add(ruleName + kvp.Key, kvp.Value ?? String.Empty);
                }
            }

            if (renderedRules)
            {
                results.Add("data-val", "true");
            }
        }

        private static void ValidateUnobtrusiveValidationRule(ModelClientValidationRule rule, IDictionary<string, object> resultsDictionary, string dictionaryKey)
        {
            if (String.IsNullOrWhiteSpace(rule.ValidationType))
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        WebPageResources.UnobtrusiveJavascript_ValidationTypeCannotBeEmpty,
                        rule.GetType().FullName));
            }

            if (resultsDictionary.ContainsKey(dictionaryKey))
            {
                throw new InvalidOperationException(
                    String.Format(
                        CultureInfo.CurrentCulture,
                        WebPageResources.UnobtrusiveJavascript_ValidationTypeMustBeUnique,
                        rule.ValidationType));
            }

            if (rule.ValidationType.Any(c => !Char.IsLower(c)))
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture, WebPageResources.UnobtrusiveJavascript_ValidationTypeMustBeLegal,
                                  rule.ValidationType,
                                  rule.GetType().FullName));
            }

            foreach (var key in rule.ValidationParameters.Keys)
            {
                if (String.IsNullOrWhiteSpace(key))
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            WebPageResources.UnobtrusiveJavascript_ValidationParameterCannotBeEmpty,
                            rule.GetType().FullName));
                }

                if (!Char.IsLower(key.First()) || key.Any(c => !Char.IsLower(c) && !Char.IsDigit(c)))
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            WebPageResources.UnobtrusiveJavascript_ValidationParameterMustBeLegal,
                            key,
                            rule.GetType().FullName));
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/PageDataDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;

namespace System.Web.WebPages
{
    /// <summary>
    /// This is a wrapper around Dictionary so that using PageData[key] returns null
    /// if the key is not found, instead of throwing an exception.
    /// </summary>
    // This is a generic type because C# does not allow implementing an interface 
    // involving dynamic types (implementing IDictionary<object, dynamic> causes
    // a compile error 
    // http://blogs.msdn.com/cburrows/archive/2009/02/04/c-dynamic-part-vii.aspx).
    internal class PageDataDictionary<TValue> : IDictionary<object, TValue>
    {
        private IDictionary<object, TValue> _data = new Dictionary<object, TValue>(new PageDataComparer());

        private IDictionary<string, TValue> _stringDictionary = new Dictionary<string, TValue>(StringComparer.OrdinalIgnoreCase);

        private IList<TValue> _indexedValues = new List<TValue>();

        internal IDictionary<object, TValue> Data
        {
            get { return _data; }
        }

        internal IDictionary<string, TValue> StringDictionary
        {
            get { return _stringDictionary; }
        }

        internal IList<TValue> IndexedValues
        {
            get { return _indexedValues; }
        }

        public ICollection<object> Keys
        {
            get
            {
                List<object> keys = new List<object>();
                keys.AddRange(_stringDictionary.Keys);
                for (int i = 0; i < _indexedValues.Count; i++)
                {
                    keys.Add(i);
                }
                foreach (var key in _data.Keys)
                {
                    if (!ContainsIndex(key) && !ContainsStringKey(key))
                    {
                        keys.Add(key);
                    }
                }
                return keys;
            }
        }

        public ICollection<TValue> Values
        {
            get
            {
                List<TValue> values = new List<TValue>();
                foreach (var key in Keys)
                {
                    values.Add(this[key]);
                }
                return values;
            }
        }

        internal ICollection<KeyValuePair<object, TValue>> Items
        {
            get
            {
                var items = new List<KeyValuePair<object, TValue>>();
                foreach (var key in Keys)
                {
                    var value = this[key];
                    var kvp = new KeyValuePair<object, TValue>(key, value);
                    items.Add(kvp);
                }
                return items;
            }
        }

        public int Count
        {
            get { return Items.Count; }
        }

        public bool IsReadOnly
        {
            get { return false; }
        }

        public TValue this[object key]
        {
            get
            {
                TValue v = default(TValue);
                TryGetValue(key, out v);
                return v;
            }

            // Note that this affects and updates the string dictionary and indexed list
            // only for existing keys found in these collections. 
            // Otherwise, the key/value goes into the _data dictionary.
            set
            {
                if (ContainsStringKey(key))
                {
                    _stringDictionary[(string)key] = value;
                }
                else if (ContainsIndex(key))
                {
                    _indexedValues[(int)key] = value;
                }
                else
                {
                    _data[key] = value;
                }
            }
        }

        public void Add(object key, TValue value)
        {
            _data.Add(key, value);
        }

        internal bool ContainsIndex(object o)
        {
            if (o is int)
            {
                return ContainsIndex((int)o);
            }
            else
            {
                return false;
            }
        }

        internal bool ContainsIndex(int index)
        {
            return _indexedValues.Count > index && index >= 0;
        }

        internal bool ContainsStringKey(object o)
        {
            string s = o as string;
            if (s != null)
            {
                return ContainsStringKey(s);
            }
            else
            {
                return false;
            }
        }

        internal bool ContainsStringKey(string key)
        {
            return _stringDictionary.ContainsKey(key);
        }

        public bool ContainsKey(object key)
        {
            if (ContainsIndex(key))
            {
                return true;
            }
            else if (ContainsStringKey(key))
            {
                return true;
            }
            else if (_data.ContainsKey(key))
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        // Note that if the key exists in more than one place, then only
        // the string dictionary and the indexed list will be updated.
        public bool Remove(object key)
        {
            if (ContainsStringKey(key))
            {
                return _stringDictionary.Remove((string)key);
            }
            else if (ContainsIndex(key))
            {
                return _indexedValues.Remove(_indexedValues[(int)key]);
            }
            else
            {
                return _data.Remove(key);
            }
        }

        public bool TryGetValue(object key, out TValue value)
        {
            if (ContainsStringKey(key))
            {
                return _stringDictionary.TryGetValue((string)key, out value);
            }
            else if (ContainsIndex(key))
            {
                value = _indexedValues[(int)key];
                return true;
            }
            else
            {
                return _data.TryGetValue(key, out value);
            }
        }

        public void Add(KeyValuePair<object, TValue> item)
        {
            this[item.Key] = item.Value;
        }

        public void Clear()
        {
            _stringDictionary.Clear();
            _indexedValues.Clear();
            _data.Clear();
        }

        public bool Contains(KeyValuePair<object, TValue> item)
        {
            return ContainsKey(item.Key) && Values.Contains(item.Value);
        }

        public void CopyTo(KeyValuePair<object, TValue>[] array, int arrayIndex)
        {
            Items.CopyTo(array, arrayIndex);
        }

        public bool Remove(KeyValuePair<object, TValue> item)
        {
            if (Contains(item))
            {
                return Remove((object)item.Key);
            }
            return false;
        }

        public IEnumerator<KeyValuePair<object, TValue>> GetEnumerator()
        {
            return Items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return Items.GetEnumerator();
        }

        // Creates a new PageData dictionary using only the original items from the pageData (excluding the string dictionary and indexed list),
        // and adding the parameters.
        internal static IDictionary<object, dynamic> CreatePageDataFromParameters(IDictionary<object, dynamic> previousPageData, params object[] data)
        {
            var oldPageData = previousPageData as PageDataDictionary<dynamic>;

            // Add the original items
            var pageData = new PageDataDictionary<dynamic>();
            foreach (var kvp in oldPageData.Data)
            {
                pageData.Data.Add(kvp);
            }

            if (data != null && data.Length > 0)
            {
                // Add items to the indexed list
                for (int i = 0; i < data.Length; i++)
                {
                    pageData.IndexedValues.Add(data[i]);
                }

                // Check for anonymous types, and add to the string dictionary
                object first = data[0];
                Type type = first.GetType();
                if (TypeHelper.IsAnonymousType(type))
                {
                    // Anonymous type
                    TypeHelper.AddAnonymousObjectToDictionary(pageData.StringDictionary, first);
                }

                // Check if the first element is of type IDictionary<string, object>
                if (typeof(IDictionary<string, object>).IsAssignableFrom(type))
                {
                    // Dictionary
                    var stringDictionary = first as IDictionary<string, object>;
                    foreach (var kvp in stringDictionary)
                    {
                        pageData.StringDictionary.Add(kvp);
                    }
                }
            }

            return pageData;
        }

        // This comparer treats only strings as case-insensitive, but still handles objects
        // of other types as well.
        private sealed class PageDataComparer : IEqualityComparer<object>
        {
            bool IEqualityComparer<object>.Equals(object x, object y)
            {
                var s1 = x as string;
                var s2 = y as string;
                if (s1 != null && s2 != null)
                {
                    return String.Equals(s1, s2, StringComparison.OrdinalIgnoreCase);
                }
                return Equals(x, y);
            }

            int IEqualityComparer<object>.GetHashCode(object obj)
            {
                var s = obj as string;
                if (s != null)
                {
                    return s.ToUpperInvariant().GetHashCode();
                }
                return obj.GetHashCode();
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/PageVirtualPathAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    // Attribute placed on a WebPage derived class that indicates the virtual path that it's associated with
    // This is used to support scenarios where pages are compiled ahead of time in external class libraries
    // Specifically, this is used by the RazorSingleFileGenerator.
    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
    public sealed class PageVirtualPathAttribute : Attribute
    {
        public PageVirtualPathAttribute(string virtualPath)
        {
            VirtualPath = virtualPath;
        }

        public string VirtualPath { get; private set; }
    }
}


================================================
FILE: src/System.Web.WebPages/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.UI;
using System.Web.WebPages.Scope;
using Microsoft.Web.Infrastructure.DynamicModuleHelper;

namespace System.Web.WebPages
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        // NOTE: Do not add public fields, methods, or other members to this class.
        // This class does not show up in Intellisense so members on it will not be
        // discoverable by users. Place new members on more appropriate classes that
        // relate to the public API (for example, a LoginUrl property should go on a
        // membership-related class).

        private static bool _startWasCalled;

        public static void Start()
        {
            // Even though ASP.NET will only call each PreAppStart once, we sometimes internally call one PreAppStart from 
            // another PreAppStart to ensure that things get initialized in the right order. ASP.NET does not guarantee the 
            // order so we have to guard against multiple calls.
            // All Start calls are made on same thread, so no lock needed here.

            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            WebPageHttpHandler.RegisterExtension("cshtml");
            WebPageHttpHandler.RegisterExtension("vbhtml");

            // Turn off the string resource behavior which would not work in our simple base page
            PageParser.EnableLongStringsAsResources = false;

            DynamicModuleUtility.RegisterModule(typeof(WebPageHttpModule));

            ScopeStorage.CurrentProvider = new AspNetRequestScopeStorageProvider();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using System.Web.WebPages;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("System.Web.WebPages")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.Mvc, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Web.Helpers, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Web.WebPages.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Web.Helpers.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("System.Web.WebPages.Administration.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]
[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.Helpers", Justification = "Namespace has more types in System.Web.Helpers.dll.")]


================================================
FILE: src/System.Web.WebPages/ReflectionDynamicObject.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Dynamic;
using System.Globalization;
using System.Reflection;

namespace System.Web.WebPages
{
    // Allows dynamic access over a CLR object via private reflection
    internal sealed class ReflectionDynamicObject : DynamicObject
    {
        private object RealObject { get; set; }

        public static object WrapObjectIfInternal(object o)
        {
            // If it's null, don't try to wrap it
            if (o == null)
            {
                return null;
            }

            // If it's public, leave it alone since the standard dynamic binder will work. Well, it won't work for
            // internal properties, but we're mostly concerned about supporting anonymous objects, which are never public
            if (o.GetType().IsPublic)
            {
                return o;
            }

            return new ReflectionDynamicObject() { RealObject = o };
        }

        // Called when a property is accessed
        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            // Get the property info
            PropertyInfo propInfo = RealObject.GetType().GetProperty(
                binder.Name,
                BindingFlags.GetProperty | BindingFlags.Instance | BindingFlags.Public);

            if (propInfo == null)
            {
                // If there is no such property, return null instead of failing. This allows optional parameters
                result = null;
            }
            else
            {
                // Get the property value
                result = propInfo.GetValue(RealObject, null);

                // Wrap the sub object if necessary. This allows nested anonymous objects to work.
                result = WrapObjectIfInternal(result);
            }

            return true;
        }

        // Called when a method is called
        public override bool TryInvokeMember(InvokeMemberBinder binder, object[] args, out object result)
        {
            result = RealObject.GetType().InvokeMember(
                binder.Name,
                BindingFlags.InvokeMethod | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                null,
                RealObject,
                args,
                CultureInfo.InvariantCulture);

            return true;
        }

        // Called when the dynamic object needs to be converted to a non dynamic object
        public override bool TryConvert(ConvertBinder binder, out object result)
        {
            result = RealObject;
            return true;
        }

        public override string ToString()
        {
            // Just return the original object's display string
            return RealObject.ToString();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/RequestBrowserOverrideStore.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// RequestBrowserOverrideStore simply returns the user agent of the current request.
    /// </summary>
    internal sealed class RequestBrowserOverrideStore : BrowserOverrideStore
    {
        public override string GetOverriddenUserAgent(HttpContextBase httpContext)
        {
            return httpContext.Request.UserAgent;
        }

        public override void SetOverriddenUserAgent(HttpContextBase httpContext, string userAgent)
        {
            return;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/RequestExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace System.Web.WebPages
{
    public static class RequestExtensions
    {
        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "request", Justification = "The request parameter is no longer being used but we do not want to break legacy callers.")]
        [SuppressMessage("Microsoft.Design", "CA1054:UriParametersShouldNotBeStrings", MessageId = "1#", Justification = "Response.Redirect() takes its URI as a string parameter.")]
        public static bool IsUrlLocalToHost(this HttpRequestBase request, string url)
        {
            return !url.IsEmpty() &&
                   ((url[0] == '/' && (url.Length == 1 || (url[1] != '/' && url[1] != '\\'))) || // "/" or "/foo" but not "//" or "/\"
                    (url.Length > 1 && url[0] == '~' && url[1] == '/')); // "~/" or "~/foo"
        }
    }
}


================================================
FILE: src/System.Web.WebPages/RequestResourceTracker.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.WebPages
{
    internal static class RequestResourceTracker
    {
        private static readonly object _resourcesKey = new object();

        private static List<SecureWeakReference> GetResources(HttpContextBase context)
        {
            var resources = (List<SecureWeakReference>)context.Items[_resourcesKey];
            if (resources == null)
            {
                resources = new List<SecureWeakReference>();
                context.Items[_resourcesKey] = resources;
            }

            return resources;
        }

        internal static void DisposeResources(HttpContextBase context)
        {
            var resources = GetResources(context);
            if (resources != null)
            {
                resources.ForEach(resource => resource.Dispose());
                resources.Clear();
            }
        }

        internal static void RegisterForDispose(HttpContextBase context, IDisposable resource)
        {
            var resources = GetResources(context);
            if (resources != null)
            {
                resources.Add(new SecureWeakReference(resource));
            }
        }

        internal static void RegisterForDispose(IDisposable resource)
        {
            var context = HttpContext.Current;
            if (context != null)
            {
                RegisterForDispose(new HttpContextWrapper(context), resource);
            }
        }

        private sealed class SecureWeakReference
        {
            private readonly WeakReference _reference;

            public SecureWeakReference(IDisposable reference)
            {
                _reference = new WeakReference(reference);
            }

            internal void Dispose()
            {
                var disposable = (IDisposable)_reference.Target;
                if (disposable != null)
                {
                    disposable.Dispose();
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Resources/WebPageResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.261
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.WebPages.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class WebPageResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal WebPageResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.WebPages.Resources.WebPageResources", typeof(WebPageResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided anti-forgery token failed a custom data check..
        /// </summary>
        internal static string AntiForgeryToken_AdditionalDataCheckFailed {
            get {
                return ResourceManager.GetString("AntiForgeryToken_AdditionalDataCheckFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided anti-forgery token was meant for a different claims-based user than the current user..
        /// </summary>
        internal static string AntiForgeryToken_ClaimUidMismatch {
            get {
                return ResourceManager.GetString("AntiForgeryToken_ClaimUidMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The required anti-forgery cookie &quot;{0}&quot; is not present..
        /// </summary>
        internal static string AntiForgeryToken_CookieMissing {
            get {
                return ResourceManager.GetString("AntiForgeryToken_CookieMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The anti-forgery token could not be decrypted. If this application is hosted by a Web Farm or cluster, ensure that all machines are running the same version of ASP.NET Web Pages and that the &lt;machineKey&gt; configuration specifies explicit encryption and validation keys. AutoGenerate cannot be used in a cluster..
        /// </summary>
        internal static string AntiForgeryToken_DeserializationFailed {
            get {
                return ResourceManager.GetString("AntiForgeryToken_DeserializationFailed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The required anti-forgery form field &quot;{0}&quot; is not present..
        /// </summary>
        internal static string AntiForgeryToken_FormFieldMissing {
            get {
                return ResourceManager.GetString("AntiForgeryToken_FormFieldMissing", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The anti-forgery cookie token and form field token do not match..
        /// </summary>
        internal static string AntiForgeryToken_SecurityTokenMismatch {
            get {
                return ResourceManager.GetString("AntiForgeryToken_SecurityTokenMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation of the provided anti-forgery token failed. The cookie &quot;{0}&quot; and the form field &quot;{1}&quot; were swapped..
        /// </summary>
        internal static string AntiForgeryToken_TokensSwapped {
            get {
                return ResourceManager.GetString("AntiForgeryToken_TokensSwapped", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided anti-forgery token was meant for user &quot;{0}&quot;, but the current user is &quot;{1}&quot;..
        /// </summary>
        internal static string AntiForgeryToken_UsernameMismatch {
            get {
                return ResourceManager.GetString("AntiForgeryToken_UsernameMismatch", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The anti-forgery system has the configuration value AntiForgeryConfig.RequireSsl = true, but the current request is not an SSL request..
        /// </summary>
        internal static string AntiForgeryWorker_RequireSSL {
            get {
                return ResourceManager.GetString("AntiForgeryWorker_RequireSSL", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The assembly &quot;{0}&quot; is already registered..
        /// </summary>
        internal static string ApplicationPart_ModuleAlreadyRegistered {
            get {
                return ResourceManager.GetString("ApplicationPart_ModuleAlreadyRegistered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An application module is already registered for virtual path &quot;{0}&quot;..
        /// </summary>
        internal static string ApplicationPart_ModuleAlreadyRegisteredForVirtualPath {
            get {
                return ResourceManager.GetString("ApplicationPart_ModuleAlreadyRegisteredForVirtualPath", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to find an application module with the name &quot;{0}&quot;..
        /// </summary>
        internal static string ApplicationPart_ModuleCannotBeFound {
            get {
                return ResourceManager.GetString("ApplicationPart_ModuleCannotBeFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The assembly &quot;{0}&quot; is not a registered application module..
        /// </summary>
        internal static string ApplicationPart_ModuleNotRegistered {
            get {
                return ResourceManager.GetString("ApplicationPart_ModuleNotRegistered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The resource file &quot;{0}&quot; could not be found..
        /// </summary>
        internal static string ApplicationPart_ResourceNotFound {
            get {
                return ResourceManager.GetString("ApplicationPart_ResourceNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A claim of type &apos;{0}&apos; was not present on the provided ClaimsIdentity..
        /// </summary>
        internal static string ClaimUidExtractor_ClaimNotPresent {
            get {
                return ResourceManager.GetString("ClaimUidExtractor_ClaimNotPresent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A claim of type &apos;http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier&apos; or &apos;http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider&apos; was not present on the provided ClaimsIdentity. To enable anti-forgery token support with claims-based authentication, please verify that the configured claims provider is providing both of these claims on the ClaimsIdentity instances it generates. If the configured claims provider instead uses a different claim type as a unique identif [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string ClaimUidExtractor_DefaultClaimsNotPresent {
            get {
                return ResourceManager.GetString("ClaimUidExtractor_DefaultClaimsNotPresent", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Index length must be exactly one..
        /// </summary>
        internal static string DynamicDictionary_InvalidNumberOfIndexes {
            get {
                return ResourceManager.GetString("DynamicDictionary_InvalidNumberOfIndexes", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Index must be of type string or int when getting a value..
        /// </summary>
        internal static string DynamicHttpApplicationState_UseOnlyStringOrIntToGet {
            get {
                return ResourceManager.GetString("DynamicHttpApplicationState_UseOnlyStringOrIntToGet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Index must be of type string when setting a value..
        /// </summary>
        internal static string DynamicHttpApplicationState_UseOnlyStringToSet {
            get {
                return ResourceManager.GetString("DynamicHttpApplicationState_UseOnlyStringToSet", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter conversion from type &quot;{0}&quot; to type &quot;{1}&quot; failed. See the inner exception for more information..
        /// </summary>
        internal static string HtmlHelper_ConversionThrew {
            get {
                return ResourceManager.GetString("HtmlHelper_ConversionThrew", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The parameter conversion from type &quot;{0}&quot; to type &quot;{1}&quot; failed because no type converter can convert between these types..
        /// </summary>
        internal static string HtmlHelper_NoConverterExists {
            get {
                return ResourceManager.GetString("HtmlHelper_NoConverterExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to An HttpContext is required to perform this operation. Check that this operation is being performed during a web request..
        /// </summary>
        internal static string HttpContextUnavailable {
            get {
                return ResourceManager.GetString("HttpContextUnavailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value &quot;{0}&quot; specified in &quot;{1}&quot; is an invalid value for the SessionState directive. Possible values are: &quot;{2}&quot;..
        /// </summary>
        internal static string SessionState_InvalidValue {
            get {
                return ResourceManager.GetString("SessionState_InvalidValue", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to At most one SessionState value can be declared per page..
        /// </summary>
        internal static string SessionState_TooManyValues {
            get {
                return ResourceManager.GetString("SessionState_TooManyValues", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to RequestScope cannot be created when _AppStart is executing..
        /// </summary>
        internal static string StateStorage_RequestScopeNotAvailable {
            get {
                return ResourceManager.GetString("StateStorage_RequestScopeNotAvailable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Storage scope is read only..
        /// </summary>
        internal static string StateStorage_ScopeIsReadOnly {
            get {
                return ResourceManager.GetString("StateStorage_ScopeIsReadOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Storage scopes cannot be created when _AppStart is executing..
        /// </summary>
        internal static string StateStorage_StorageScopesCannotBeCreated {
            get {
                return ResourceManager.GetString("StateStorage_StorageScopesCannotBeCreated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The provided identity of type &apos;{0}&apos; is marked IsAuthenticated = true but does not have a value for Name. By default, the anti-forgery system requires that all authenticated identities have a unique Name. If it is not possible to provide a unique Name for this identity, consider setting the static property AntiForgeryConfig.AdditionalDataProvider to an instance of a type that can provide some form of unique identifier for the current user..
        /// </summary>
        internal static string TokenValidator_AuthenticatedUserWithoutUsername {
            get {
                return ResourceManager.GetString("TokenValidator_AuthenticatedUserWithoutUsername", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation parameter names in unobtrusive client validation rules cannot be empty. Client rule type: {0}.
        /// </summary>
        internal static string UnobtrusiveJavascript_ValidationParameterCannotBeEmpty {
            get {
                return ResourceManager.GetString("UnobtrusiveJavascript_ValidationParameterCannotBeEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: {0}, client rule type: {1}.
        /// </summary>
        internal static string UnobtrusiveJavascript_ValidationParameterMustBeLegal {
            get {
                return ResourceManager.GetString("UnobtrusiveJavascript_ValidationParameterMustBeLegal", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation type names in unobtrusive client validation rules cannot be empty. Client rule type: {0}.
        /// </summary>
        internal static string UnobtrusiveJavascript_ValidationTypeCannotBeEmpty {
            get {
                return ResourceManager.GetString("UnobtrusiveJavascript_ValidationTypeCannotBeEmpty", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: &quot;{0}&quot;, client rule type: {1}.
        /// </summary>
        internal static string UnobtrusiveJavascript_ValidationTypeMustBeLegal {
            get {
                return ResourceManager.GetString("UnobtrusiveJavascript_ValidationTypeMustBeLegal", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation type names in unobtrusive client validation rules must be unique. The following validation type was seen more than once: {0}.
        /// </summary>
        internal static string UnobtrusiveJavascript_ValidationTypeMustBeUnique {
            get {
                return ResourceManager.GetString("UnobtrusiveJavascript_ValidationTypeMustBeUnique", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The UrlData collection is read-only..
        /// </summary>
        internal static string UrlData_ReadOnly {
            get {
                return ResourceManager.GetString("UrlData_ReadOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Input format is invalid..
        /// </summary>
        internal static string ValidationDefault_DataType {
            get {
                return ResourceManager.GetString("ValidationDefault_DataType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Values do not match..
        /// </summary>
        internal static string ValidationDefault_EqualsTo {
            get {
                return ResourceManager.GetString("ValidationDefault_EqualsTo", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be a decimal between {0} and {1}..
        /// </summary>
        internal static string ValidationDefault_FloatRange {
            get {
                return ResourceManager.GetString("ValidationDefault_FloatRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value must be an integer between {0} and {1}..
        /// </summary>
        internal static string ValidationDefault_IntegerRange {
            get {
                return ResourceManager.GetString("ValidationDefault_IntegerRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value is invalid..
        /// </summary>
        internal static string ValidationDefault_Regex {
            get {
                return ResourceManager.GetString("ValidationDefault_Regex", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This field is required..
        /// </summary>
        internal static string ValidationDefault_Required {
            get {
                return ResourceManager.GetString("ValidationDefault_Required", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Max length: {0}..
        /// </summary>
        internal static string ValidationDefault_StringLength {
            get {
                return ResourceManager.GetString("ValidationDefault_StringLength", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to String must be between {0} and {1} characters..
        /// </summary>
        internal static string ValidationDefault_StringLengthRange {
            get {
                return ResourceManager.GetString("ValidationDefault_StringLengthRange", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file &quot;{0}&quot; cannot be requested directly because it calls the &quot;{1}&quot; method..
        /// </summary>
        internal static string WebPage_CannotRequestDirectly {
            get {
                return ResourceManager.GetString("WebPage_CannotRequestDirectly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following file could not be rendered because its extension &quot;{0}&quot; might not be supported: &quot;{1}&quot;..
        /// </summary>
        internal static string WebPage_FileNotSupported {
            get {
                return ResourceManager.GetString("WebPage_FileNotSupported", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The file &quot;{0}&quot; could not be rendered, because it does not exist or is not a valid page..
        /// </summary>
        internal static string WebPage_InvalidPageType {
            get {
                return ResourceManager.GetString("WebPage_InvalidPageType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The layout page &quot;{0}&quot; could not be found at the following path: &quot;{1}&quot;..
        /// </summary>
        internal static string WebPage_LayoutPageNotFound {
            get {
                return ResourceManager.GetString("WebPage_LayoutPageNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;RenderBody&quot; method has already been called..
        /// </summary>
        internal static string WebPage_RenderBodyAlreadyCalled {
            get {
                return ResourceManager.GetString("WebPage_RenderBodyAlreadyCalled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;RenderBody&quot; method has not been called for layout page &quot;{0}&quot;..
        /// </summary>
        internal static string WebPage_RenderBodyNotCalled {
            get {
                return ResourceManager.GetString("WebPage_RenderBodyNotCalled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Section already defined: &quot;{0}&quot;..
        /// </summary>
        internal static string WebPage_SectionAleadyDefined {
            get {
                return ResourceManager.GetString("WebPage_SectionAleadyDefined", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;RenderSection&quot; method has already been called for the section named &quot;{0}&quot;..
        /// </summary>
        internal static string WebPage_SectionAleadyRendered {
            get {
                return ResourceManager.GetString("WebPage_SectionAleadyRendered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Section not defined: &quot;{0}&quot;..
        /// </summary>
        internal static string WebPage_SectionNotDefined {
            get {
                return ResourceManager.GetString("WebPage_SectionNotDefined", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following sections have been defined but have not been rendered for the layout page &quot;{0}&quot;: &quot;{1}&quot;..
        /// </summary>
        internal static string WebPage_SectionsNotRendered {
            get {
                return ResourceManager.GetString("WebPage_SectionsNotRendered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Files with leading underscores (&quot;_&quot;) cannot be served..
        /// </summary>
        internal static string WebPageRoute_UnderscoreBlocked {
            get {
                return ResourceManager.GetString("WebPageRoute_UnderscoreBlocked", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Resources/WebPageResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="AntiForgeryToken_AdditionalDataCheckFailed" xml:space="preserve">
    <value>The provided anti-forgery token failed a custom data check.</value>
  </data>
  <data name="AntiForgeryToken_ClaimUidMismatch" xml:space="preserve">
    <value>The provided anti-forgery token was meant for a different claims-based user than the current user.</value>
  </data>
  <data name="AntiForgeryToken_CookieMissing" xml:space="preserve">
    <value>The required anti-forgery cookie "{0}" is not present.</value>
  </data>
  <data name="AntiForgeryToken_DeserializationFailed" xml:space="preserve">
    <value>The anti-forgery token could not be decrypted. If this application is hosted by a Web Farm or cluster, ensure that all machines are running the same version of ASP.NET Web Pages and that the &lt;machineKey&gt; configuration specifies explicit encryption and validation keys. AutoGenerate cannot be used in a cluster.</value>
  </data>
  <data name="AntiForgeryToken_FormFieldMissing" xml:space="preserve">
    <value>The required anti-forgery form field "{0}" is not present.</value>
  </data>
  <data name="AntiForgeryToken_SecurityTokenMismatch" xml:space="preserve">
    <value>The anti-forgery cookie token and form field token do not match.</value>
  </data>
  <data name="AntiForgeryToken_TokensSwapped" xml:space="preserve">
    <value>Validation of the provided anti-forgery token failed. The cookie "{0}" and the form field "{1}" were swapped.</value>
  </data>
  <data name="AntiForgeryToken_UsernameMismatch" xml:space="preserve">
    <value>The provided anti-forgery token was meant for user "{0}", but the current user is "{1}".</value>
  </data>
  <data name="AntiForgeryWorker_RequireSSL" xml:space="preserve">
    <value>The anti-forgery system has the configuration value AntiForgeryConfig.RequireSsl = true, but the current request is not an SSL request.</value>
  </data>
  <data name="ApplicationPart_ModuleAlreadyRegistered" xml:space="preserve">
    <value>The assembly "{0}" is already registered.</value>
  </data>
  <data name="ApplicationPart_ModuleAlreadyRegisteredForVirtualPath" xml:space="preserve">
    <value>An application module is already registered for virtual path "{0}".</value>
  </data>
  <data name="ApplicationPart_ModuleCannotBeFound" xml:space="preserve">
    <value>Unable to find an application module with the name "{0}".</value>
  </data>
  <data name="ApplicationPart_ModuleNotRegistered" xml:space="preserve">
    <value>The assembly "{0}" is not a registered application module.</value>
  </data>
  <data name="ApplicationPart_ResourceNotFound" xml:space="preserve">
    <value>The resource file "{0}" could not be found.</value>
  </data>
  <data name="ClaimUidExtractor_ClaimNotPresent" xml:space="preserve">
    <value>A claim of type '{0}' was not present on the provided ClaimsIdentity.</value>
  </data>
  <data name="ClaimUidExtractor_DefaultClaimsNotPresent" xml:space="preserve">
    <value>A claim of type 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier' or 'http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider' was not present on the provided ClaimsIdentity. To enable anti-forgery token support with claims-based authentication, please verify that the configured claims provider is providing both of these claims on the ClaimsIdentity instances it generates. If the configured claims provider instead uses a different claim type as a unique identifier, it can be configured by setting the static property AntiForgeryConfig.UniqueClaimTypeIdentifier.</value>
  </data>
  <data name="DynamicDictionary_InvalidNumberOfIndexes" xml:space="preserve">
    <value>Index length must be exactly one.</value>
  </data>
  <data name="DynamicHttpApplicationState_UseOnlyStringOrIntToGet" xml:space="preserve">
    <value>Index must be of type string or int when getting a value.</value>
  </data>
  <data name="DynamicHttpApplicationState_UseOnlyStringToSet" xml:space="preserve">
    <value>Index must be of type string when setting a value.</value>
  </data>
  <data name="HtmlHelper_ConversionThrew" xml:space="preserve">
    <value>The parameter conversion from type "{0}" to type "{1}" failed. See the inner exception for more information.</value>
  </data>
  <data name="HtmlHelper_NoConverterExists" xml:space="preserve">
    <value>The parameter conversion from type "{0}" to type "{1}" failed because no type converter can convert between these types.</value>
  </data>
  <data name="HttpContextUnavailable" xml:space="preserve">
    <value>An HttpContext is required to perform this operation. Check that this operation is being performed during a web request.</value>
  </data>
  <data name="SessionState_InvalidValue" xml:space="preserve">
    <value>Value "{0}" specified in "{1}" is an invalid value for the SessionState directive. Possible values are: "{2}".</value>
  </data>
  <data name="SessionState_TooManyValues" xml:space="preserve">
    <value>At most one SessionState value can be declared per page.</value>
  </data>
  <data name="StateStorage_RequestScopeNotAvailable" xml:space="preserve">
    <value>RequestScope cannot be created when _AppStart is executing.</value>
  </data>
  <data name="StateStorage_ScopeIsReadOnly" xml:space="preserve">
    <value>Storage scope is read only.</value>
  </data>
  <data name="StateStorage_StorageScopesCannotBeCreated" xml:space="preserve">
    <value>Storage scopes cannot be created when _AppStart is executing.</value>
  </data>
  <data name="TokenValidator_AuthenticatedUserWithoutUsername" xml:space="preserve">
    <value>The provided identity of type '{0}' is marked IsAuthenticated = true but does not have a value for Name. By default, the anti-forgery system requires that all authenticated identities have a unique Name. If it is not possible to provide a unique Name for this identity, consider setting the static property AntiForgeryConfig.AdditionalDataProvider to an instance of a type that can provide some form of unique identifier for the current user.</value>
  </data>
  <data name="UnobtrusiveJavascript_ValidationParameterCannotBeEmpty" xml:space="preserve">
    <value>Validation parameter names in unobtrusive client validation rules cannot be empty. Client rule type: {0}</value>
  </data>
  <data name="UnobtrusiveJavascript_ValidationParameterMustBeLegal" xml:space="preserve">
    <value>Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: {0}, client rule type: {1}</value>
  </data>
  <data name="UnobtrusiveJavascript_ValidationTypeCannotBeEmpty" xml:space="preserve">
    <value>Validation type names in unobtrusive client validation rules cannot be empty. Client rule type: {0}</value>
  </data>
  <data name="UnobtrusiveJavascript_ValidationTypeMustBeLegal" xml:space="preserve">
    <value>Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: "{0}", client rule type: {1}</value>
  </data>
  <data name="UnobtrusiveJavascript_ValidationTypeMustBeUnique" xml:space="preserve">
    <value>Validation type names in unobtrusive client validation rules must be unique. The following validation type was seen more than once: {0}</value>
  </data>
  <data name="UrlData_ReadOnly" xml:space="preserve">
    <value>The UrlData collection is read-only.</value>
  </data>
  <data name="ValidationDefault_DataType" xml:space="preserve">
    <value>Input format is invalid.</value>
  </data>
  <data name="ValidationDefault_EqualsTo" xml:space="preserve">
    <value>Values do not match.</value>
  </data>
  <data name="ValidationDefault_FloatRange" xml:space="preserve">
    <value>Value must be a decimal between {0} and {1}.</value>
  </data>
  <data name="ValidationDefault_IntegerRange" xml:space="preserve">
    <value>Value must be an integer between {0} and {1}.</value>
  </data>
  <data name="ValidationDefault_Regex" xml:space="preserve">
    <value>Value is invalid.</value>
  </data>
  <data name="ValidationDefault_Required" xml:space="preserve">
    <value>This field is required.</value>
  </data>
  <data name="ValidationDefault_StringLength" xml:space="preserve">
    <value>Max length: {0}.</value>
  </data>
  <data name="ValidationDefault_StringLengthRange" xml:space="preserve">
    <value>String must be between {0} and {1} characters.</value>
  </data>
  <data name="WebPageRoute_UnderscoreBlocked" xml:space="preserve">
    <value>Files with leading underscores ("_") cannot be served.</value>
  </data>
  <data name="WebPage_CannotRequestDirectly" xml:space="preserve">
    <value>The file "{0}" cannot be requested directly because it calls the "{1}" method.</value>
  </data>
  <data name="WebPage_FileNotSupported" xml:space="preserve">
    <value>The following file could not be rendered because its extension "{0}" might not be supported: "{1}".</value>
  </data>
  <data name="WebPage_InvalidPageType" xml:space="preserve">
    <value>The file "{0}" could not be rendered, because it does not exist or is not a valid page.</value>
  </data>
  <data name="WebPage_LayoutPageNotFound" xml:space="preserve">
    <value>The layout page "{0}" could not be found at the following path: "{1}".</value>
  </data>
  <data name="WebPage_RenderBodyAlreadyCalled" xml:space="preserve">
    <value>The "RenderBody" method has already been called.</value>
  </data>
  <data name="WebPage_RenderBodyNotCalled" xml:space="preserve">
    <value>The "RenderBody" method has not been called for layout page "{0}".</value>
  </data>
  <data name="WebPage_SectionAleadyDefined" xml:space="preserve">
    <value>Section already defined: "{0}".</value>
  </data>
  <data name="WebPage_SectionAleadyRendered" xml:space="preserve">
    <value>The "RenderSection" method has already been called for the section named "{0}".</value>
  </data>
  <data name="WebPage_SectionNotDefined" xml:space="preserve">
    <value>Section not defined: "{0}".</value>
  </data>
  <data name="WebPage_SectionsNotRendered" xml:space="preserve">
    <value>The following sections have been defined but have not been rendered for the layout page "{0}": "{1}".</value>
  </data>
</root>

================================================
FILE: src/System.Web.WebPages/ResponseExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Net;

namespace System.Web.WebPages
{
    public static class ResponseExtensions
    {
        public static void SetStatus(this HttpResponseBase response, HttpStatusCode httpStatusCode)
        {
            SetStatus(response, (int)httpStatusCode);
        }

        public static void SetStatus(this HttpResponseBase response, int httpStatusCode)
        {
            response.StatusCode = httpStatusCode;
            response.End();
        }

        public static void WriteBinary(this HttpResponseBase response, byte[] data, string mimeType)
        {
            response.ContentType = mimeType;
            WriteBinary(response, data);
        }

        public static void WriteBinary(this HttpResponseBase response, byte[] data)
        {
            response.OutputStream.Write(data, 0, data.Length);
        }

        // REVIEW: See what this is actually calling that's needed
        // Configure output caching for the request
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are not removing optional parameters from helpers")]
        public static void OutputCache(this HttpResponseBase response,
                                       int numberOfSeconds,
                                       bool sliding = false,
                                       IEnumerable<string> varyByParams = null,
                                       IEnumerable<string> varyByHeaders = null,
                                       IEnumerable<string> varyByContentEncodings = null,
                                       HttpCacheability cacheability = HttpCacheability.Public)
        {
            OutputCache(new HttpContextWrapper(HttpContext.Current), response.Cache, numberOfSeconds, sliding, varyByParams, varyByHeaders, varyByContentEncodings,
                        cacheability);
        }

        internal static void OutputCache(HttpContextBase httpContext,
                                         HttpCachePolicyBase cache,
                                         int numberOfSeconds,
                                         bool sliding,
                                         IEnumerable<string> varyByParams,
                                         IEnumerable<string> varyByHeaders,
                                         IEnumerable<string> varyByContentEncodings,
                                         HttpCacheability cacheability)
        {
            cache.SetCacheability(cacheability);
            cache.SetExpires(httpContext.Timestamp.AddSeconds(numberOfSeconds));
            cache.SetMaxAge(new TimeSpan(0, 0, numberOfSeconds));
            cache.SetValidUntilExpires(true);
            cache.SetLastModified(httpContext.Timestamp);
            cache.SetSlidingExpiration(sliding);

            if (varyByParams != null)
            {
                foreach (var p in varyByParams)
                {
                    cache.VaryByParams[p] = true;
                }
            }

            if (varyByHeaders != null)
            {
                foreach (var headerName in varyByHeaders)
                {
                    cache.VaryByHeaders[headerName] = true;
                }
            }

            if (varyByContentEncodings != null)
            {
                foreach (var contentEncoding in varyByContentEncodings)
                {
                    cache.VaryByContentEncodings[contentEncoding] = true;
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/ApplicationScopeStorageDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;

namespace System.Web.WebPages.Scope
{
    /// <summary>
    /// The application level storage context that uses a static dictionary as a backing store.
    /// </summary>
    internal class ApplicationScopeStorageDictionary : ScopeStorageDictionary
    {
        private static readonly IDictionary<object, object> _innerDictionary =
            new ConcurrentDictionary<object, object>(ScopeStorageComparer.Instance);

        public ApplicationScopeStorageDictionary()
            : this(new WebConfigScopeDictionary())
        {
        }

        public ApplicationScopeStorageDictionary(WebConfigScopeDictionary webConfigState)
            : base(baseScope: webConfigState, backingStore: _innerDictionary)
        {
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/AspNetRequestScopeStorageProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages.Scope
{
    public class AspNetRequestScopeStorageProvider : IScopeStorageProvider
    {
        private static readonly object _pageScopeKey = new object();
        private static readonly object _requestScopeKey = new object();
        private readonly HttpContextBase _httpContext;
        private readonly Func<bool> _appStartExecuted;

        public AspNetRequestScopeStorageProvider()
            : this(httpContext: null, appStartExecuted: () => WebPageHttpModule.AppStartExecuteCompleted)
        {
        }

        internal AspNetRequestScopeStorageProvider(HttpContextBase httpContext, Func<bool> appStartExecuted)
        {
            _httpContext = httpContext;
            _appStartExecuted = appStartExecuted;
            ApplicationScope = new ApplicationScopeStorageDictionary();
        }

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "The state storage API is designed to allow contexts to be set")]
        public IDictionary<object, object> CurrentScope
        {
            get { return PageScope ?? RequestScopeInternal ?? ApplicationScope; }
            set
            {
                if (!_appStartExecuted())
                {
                    // Disallow creating new contexts before the start page is executed. 
                    // This makes sense because our provider is scoped to a request.
                    throw new InvalidOperationException(WebPageResources.StateStorage_StorageScopesCannotBeCreated);
                }
                PageScope = value;
            }
        }

        public IDictionary<object, object> GlobalScope
        {
            get { return ApplicationScope; }
        }

        public IDictionary<object, object> ApplicationScope { get; private set; }

        public IDictionary<object, object> RequestScope
        {
            get
            {
                var requestContext = RequestScopeInternal;
                if (requestContext == null)
                {
                    throw new InvalidOperationException(WebPageResources.StateStorage_RequestScopeNotAvailable);
                }
                return requestContext;
            }
        }

        private HttpContextBase HttpContext
        {
            get
            {
                // If a http context is specifically provided, use that. Else return the value from System.Web.HttpContext.Current if its available.
                var currentHttpContext = Web.HttpContext.Current;
                return _httpContext ?? (currentHttpContext == null ? null : new HttpContextWrapper(currentHttpContext));
            }
        }

        private IDictionary<object, object> RequestScopeInternal
        {
            get
            {
                if (_appStartExecuted())
                {
                    var requestContext = (IDictionary<object, object>)HttpContext.Items[_requestScopeKey];
                    if (requestContext == null)
                    {
                        HttpContext.Items[_requestScopeKey] = requestContext = new ScopeStorageDictionary(ApplicationScope);
                    }
                    return requestContext;
                }
                return null;
            }
        }

        private IDictionary<object, object> PageScope
        {
            get
            {
                if (HttpContext == null)
                {
                    return null;
                }
                return (IDictionary<object, object>)HttpContext.Items[_pageScopeKey];
            }
            set
            {
                // This call would be guarded by the CurrentContext setter.
                Debug.Assert(HttpContext != null);
                HttpContext.Items[_pageScopeKey] = value;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/IScopeStorageProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.WebPages.Scope
{
    public interface IScopeStorageProvider
    {
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "The state storage API is designed to allow contexts to be set")]
        IDictionary<object, object> CurrentScope { get; set; }

        IDictionary<object, object> GlobalScope { get; }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/ScopeStorage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.WebPages.Scope
{
    public static class ScopeStorage
    {
        private static readonly IScopeStorageProvider _defaultStorageProvider = new StaticScopeStorageProvider();
        private static IScopeStorageProvider _stateStorageProvider;

        public static IScopeStorageProvider CurrentProvider
        {
            get { return _stateStorageProvider ?? _defaultStorageProvider; }
            set { _stateStorageProvider = value; }
        }

        public static IDictionary<object, object> CurrentScope
        {
            get { return CurrentProvider.CurrentScope; }
        }

        public static IDictionary<object, object> GlobalScope
        {
            get { return CurrentProvider.GlobalScope; }
        }

        public static IDisposable CreateTransientScope(IDictionary<object, object> context)
        {
            var currentContext = CurrentScope;
            CurrentProvider.CurrentScope = context;
            return new DisposableAction(() => CurrentProvider.CurrentScope = currentContext); // Return an IDisposable that pops the item back off
        }

        public static IDisposable CreateTransientScope()
        {
            return CreateTransientScope(new ScopeStorageDictionary(baseScope: CurrentScope));
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/ScopeStorageComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.WebPages.Scope
{
    /// <summary>
    /// Custom comparer for the context dictionaries
    /// The comparer treats strings as a special case, performing case insesitive comparison. 
    /// This guaratees that we remain consistent throughout the chain of contexts since PageData dictionary 
    /// behaves in this manner.
    /// </summary>
    internal class ScopeStorageComparer : IEqualityComparer<object>
    {
        private static IEqualityComparer<object> _instance;
        private readonly IEqualityComparer<object> _defaultComparer = EqualityComparer<object>.Default;
        private readonly IEqualityComparer<string> _stringComparer = StringComparer.OrdinalIgnoreCase;

        private ScopeStorageComparer()
        {
        }

        public static IEqualityComparer<object> Instance
        {
            get
            {
                if (_instance == null)
                {
                    _instance = new ScopeStorageComparer();
                }
                return _instance;
            }
        }

        [SuppressMessage("StyleCop.CSharp.NamingRules", "SA1305:FieldNamesMustNotUseHungarianNotation", Target = "xString, yString",
           Justification = "These names make most sense.")]
        public new bool Equals(object x, object y)
        {
            string xString = x as string;
            string yString = y as string;

            if ((xString != null) && (yString != null))
            {
                return _stringComparer.Equals(xString, yString);
            }

            return _defaultComparer.Equals(x, y);
        }

        public int GetHashCode(object obj)
        {
            string objString = obj as string;
            if (objString != null)
            {
                return _stringComparer.GetHashCode(objString);
            }

            return _defaultComparer.GetHashCode(obj);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/ScopeStorageDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

namespace System.Web.WebPages.Scope
{
    public class ScopeStorageDictionary : IDictionary<object, object>
    {
        private static readonly StateStorageKeyValueComparer _keyValueComparer = new StateStorageKeyValueComparer();
        private readonly IDictionary<object, object> _baseScope;
        private readonly IDictionary<object, object> _backingStore;

        public ScopeStorageDictionary()
            : this(baseScope: null)
        {
        }

        public ScopeStorageDictionary(IDictionary<object, object> baseScope)
            : this(baseScope: baseScope, backingStore: new Dictionary<object, object>(ScopeStorageComparer.Instance))
        {
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ScopeStorageDictionary"/> class.
        /// </summary>
        /// <param name="baseScope">The base scope.</param>
        /// <param name="backingStore">
        /// The dictionary to use as a storage. Since the dictionary would be used as-is, we expect the implementer to 
        /// use the same key-value comparison logic as we do here.
        /// </param>
        internal ScopeStorageDictionary(IDictionary<object, object> baseScope, IDictionary<object, object> backingStore)
        {
            _baseScope = baseScope;
            _backingStore = backingStore;
        }

        protected IDictionary<object, object> BackingStore
        {
            get { return _backingStore; }
        }

        protected IDictionary<object, object> BaseScope
        {
            get { return _baseScope; }
        }

        public virtual ICollection<object> Keys
        {
            get { return GetItems().Select(item => item.Key).ToList(); }
        }

        public virtual ICollection<object> Values
        {
            get { return GetItems().Select(item => item.Value).ToList(); }
        }

        public virtual int Count
        {
            get { return GetItems().Count(); }
        }

        public virtual bool IsReadOnly
        {
            get { return false; }
        }

        public object this[object key]
        {
            get
            {
                object value;
                TryGetValue(key, out value);
                return value;
            }
            set { SetValue(key, value); }
        }

        public virtual void SetValue(object key, object value)
        {
            _backingStore[key] = value;
        }

        public virtual bool TryGetValue(object key, out object value)
        {
            return _backingStore.TryGetValue(key, out value) || (_baseScope != null && _baseScope.TryGetValue(key, out value));
        }

        public virtual bool Remove(object key)
        {
            return _backingStore.Remove(key);
        }

        public virtual IEnumerator<KeyValuePair<object, object>> GetEnumerator()
        {
            return GetItems().GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public virtual void Add(object key, object value)
        {
            SetValue(key, value);
        }

        public virtual bool ContainsKey(object key)
        {
            return _backingStore.ContainsKey(key) || (_baseScope != null && _baseScope.ContainsKey(key));
        }

        public virtual void Add(KeyValuePair<object, object> item)
        {
            SetValue(item.Key, item.Value);
        }

        public virtual void Clear()
        {
            _backingStore.Clear();
        }

        public virtual bool Contains(KeyValuePair<object, object> item)
        {
            return _backingStore.Contains(item) || (_baseScope != null && _baseScope.Contains(item));
        }

        public virtual void CopyTo(KeyValuePair<object, object>[] array, int arrayIndex)
        {
            GetItems().ToList().CopyTo(array, arrayIndex);
        }

        public virtual bool Remove(KeyValuePair<object, object> item)
        {
            return _backingStore.Remove(item);
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This call might be expensive depending on how long the chain of contexts is")]
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "This method is implementation specific and is not meant to be exposed as a public API.")]
        protected virtual IEnumerable<KeyValuePair<object, object>> GetItems()
        {
            if (_baseScope == null)
            {
                return _backingStore;
            }
            return Enumerable.Concat(_backingStore, _baseScope).Distinct(_keyValueComparer);
        }

        private class StateStorageKeyValueComparer : IEqualityComparer<KeyValuePair<object, object>>
        {
            private IEqualityComparer<object> _stateStorageComparer = ScopeStorageComparer.Instance;

            public bool Equals(KeyValuePair<object, object> x, KeyValuePair<object, object> y)
            {
                return _stateStorageComparer.Equals(x.Key, y.Key);
            }

            public int GetHashCode(KeyValuePair<object, object> obj)
            {
                return _stateStorageComparer.GetHashCode(obj.Key);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/StaticScopeStorageProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;

namespace System.Web.WebPages.Scope
{
    public class StaticScopeStorageProvider : IScopeStorageProvider
    {
        private static readonly IDictionary<object, object> _defaultContext =
            new ScopeStorageDictionary(null, new ConcurrentDictionary<object, object>(ScopeStorageComparer.Instance));

        private IDictionary<object, object> _currentContext;

        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "The state storage API is designed to allow contexts to be set")]
        public IDictionary<object, object> CurrentScope
        {
            get { return _currentContext ?? _defaultContext; }
            set { _currentContext = value; }
        }

        public IDictionary<object, object> GlobalScope
        {
            get { return _defaultContext; }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Scope/WebConfigScopeStorageDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Web.Configuration;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages.Scope
{
    internal class WebConfigScopeDictionary : IDictionary<object, object>
    {
        private readonly Lazy<Dictionary<object, object>> _items;

        public WebConfigScopeDictionary()
            : this(WebConfigurationManager.AppSettings)
        {
        }

        public WebConfigScopeDictionary(NameValueCollection appSettings)
        {
            _items = new Lazy<Dictionary<object, object>>(() =>
                {
                    Dictionary<object, object> items = new Dictionary<object, object>(ScopeStorageComparer.Instance);
                    foreach (string key in appSettings.AllKeys)
                    {
                        items[key] = appSettings[key];
                    }
                    return items;
                });
        }

        private IDictionary<object, object> Items
        {
            get { return _items.Value; }
        }

        public ICollection<object> Keys
        {
            get { return Items.Keys; }
        }

        public ICollection<object> Values
        {
            get { return Items.Values; }
        }

        public int Count
        {
            get { return Items.Count; }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        public object this[object key]
        {
            get
            {
                object value;
                TryGetValue(key, out value);
                return value;
            }
            set { throw new NotSupportedException(WebPageResources.StateStorage_ScopeIsReadOnly); }
        }

        public bool TryGetValue(object key, out object value)
        {
            return Items.TryGetValue(key, out value);
        }

        public IEnumerator<KeyValuePair<object, object>> GetEnumerator()
        {
            return Items.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public void Add(object key, object value)
        {
            throw new NotSupportedException(WebPageResources.StateStorage_ScopeIsReadOnly);
        }

        public bool ContainsKey(object key)
        {
            return Items.ContainsKey(key);
        }

        public bool Remove(object key)
        {
            throw new NotSupportedException(WebPageResources.StateStorage_ScopeIsReadOnly);
        }

        public void Add(KeyValuePair<object, object> item)
        {
            throw new NotSupportedException(WebPageResources.StateStorage_ScopeIsReadOnly);
        }

        public void Clear()
        {
            throw new NotSupportedException(WebPageResources.StateStorage_ScopeIsReadOnly);
        }

        public bool Contains(KeyValuePair<object, object> item)
        {
            return Items.Contains(item);
        }

        public void CopyTo(KeyValuePair<object, object>[] array, int arrayIndex)
        {
            Items.CopyTo(array, arrayIndex);
        }

        public bool Remove(KeyValuePair<object, object> item)
        {
            throw new NotSupportedException(WebPageResources.StateStorage_ScopeIsReadOnly);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/SectionWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    public delegate void SectionWriter();
}


================================================
FILE: src/System.Web.WebPages/StartPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    /// <summary>
    /// Wrapper class to be used by _pagestart.cshtml files to call into
    /// the actual page.
    /// Most of the properties and methods just delegate the call to ChildPage.XXX
    /// </summary>
    public abstract class StartPage : WebPageRenderingBase
    {
        public WebPageRenderingBase ChildPage { get; set; }

        public override HttpContextBase Context
        {
            get { return ChildPage.Context; }
            set { ChildPage.Context = value; }
        }

        public override string Layout
        {
            get { return ChildPage.Layout; }
            set
            {
                if (value == null)
                {
                    ChildPage.Layout = null;
                }
                else
                {
                    ChildPage.Layout = NormalizeLayoutPagePath(value);
                }
            }
        }

        public override IDictionary<object, dynamic> PageData
        {
            get { return ChildPage.PageData; }
        }

        public override dynamic Page
        {
            get { return ChildPage.Page; }
        }

        internal bool RunPageCalled { get; set; }

        public override void ExecutePageHierarchy()
        {
            // Push the current pagestart on the stack. 
            TemplateStack.Push(Context, this);
            try
            {
                // Execute the developer-written code of the InitPage
                Execute();

                // If the child page wasn't explicitly run by the developer of the InitPage, then run it now.
                // The child page is either the next InitPage, or the final WebPage.
                if (!RunPageCalled)
                {
                    RunPage();
                }
            }
            finally
            {
                TemplateStack.Pop(Context);
            }
        }

        /// <summary>
        /// Returns either the root-most init page, or the provided page itself if no init page is found
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters",
            Justification = "Start Pages are instances of WebPageRenderingBase. It might be possible to have WebPageExecuting bases that are not in the same inheritance tree as StartPages")]
        public static WebPageRenderingBase GetStartPage(WebPageRenderingBase page, string fileName, IEnumerable<string> supportedExtensions)
        {
            if (page == null)
            {
                throw new ArgumentNullException("page");
            }
            if (String.IsNullOrEmpty(fileName))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "fileName"), "fileName");
            }
            if (supportedExtensions == null)
            {
                throw new ArgumentNullException("supportedExtensions");
            }

            // Use the page's VirtualPathFactory if available
            return GetStartPage(page, page.VirtualPathFactory ?? VirtualPathFactoryManager.Instance,
                                HttpRuntime.AppDomainAppVirtualPath, fileName, supportedExtensions);
        }

        internal static WebPageRenderingBase GetStartPage(WebPageRenderingBase page, IVirtualPathFactory virtualPathFactory, string appDomainAppVirtualPath,
                                                          string fileName, IEnumerable<string> supportedExtensions)
        {
            // Build up a list of pages to execute, such as one of the following:
            // ~/somepage.cshtml
            // ~/_pageStart.cshtml --> ~/somepage.cshtml
            // ~/_pageStart.cshtml --> ~/sub/_pageStart.cshtml --> ~/sub/somepage.cshtml
            WebPageRenderingBase currentPage = page;
            var pageDirectory = VirtualPathUtility.GetDirectory(page.VirtualPath);

            // Start with the requested page's directory, find the init page,
            // and then traverse up the hierarchy to find init pages all the
            // way up to the root of the app.
            while (!String.IsNullOrEmpty(pageDirectory) && pageDirectory != "/" && PathUtil.IsWithinAppRoot(appDomainAppVirtualPath, pageDirectory))
            {
                // Go through the list of supported extensions
                foreach (var extension in supportedExtensions)
                {
                    var virtualPath = VirtualPathUtility.Combine(pageDirectory, fileName + "." + extension);

                    // Can we build a file from the current path?
                    if (virtualPathFactory.Exists(virtualPath))
                    {
                        var parentStartPage = virtualPathFactory.CreateInstance<StartPage>(virtualPath);
                        parentStartPage.VirtualPath = virtualPath;
                        parentStartPage.ChildPage = currentPage;
                        parentStartPage.VirtualPathFactory = virtualPathFactory;
                        currentPage = parentStartPage;

                        break;
                    }
                }

                pageDirectory = currentPage.GetDirectory(pageDirectory);
            }

            // At this point 'currentPage' is the root-most StartPage (if there were
            // any StartPages at all) or it is the requested page itself.
            return currentPage;
        }

        public override HelperResult RenderPage(string path, params object[] data)
        {
            return ChildPage.RenderPage(NormalizePath(path), data);
        }

        public void RunPage()
        {
            RunPageCalled = true;
            //ChildPage.PageContext = PageContext;
            ChildPage.ExecutePageHierarchy();
        }

        public override void Write(HelperResult result)
        {
            ChildPage.Write(result);
        }

        public override void WriteLiteral(object value)
        {
            ChildPage.WriteLiteral(value);
        }

        public override void Write(object value)
        {
            ChildPage.Write(value);
        }

        protected internal override TextWriter GetOutputWriter()
        {
            return ChildPage.GetOutputWriter();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/StringExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;

namespace System.Web.WebPages
{
    public static class StringExtensions
    {
        public static bool IsEmpty(this string value)
        {
            return String.IsNullOrEmpty(value);
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "int", Justification = "We specificaly want type names")]
        public static int AsInt(this string value)
        {
            return AsInt(value, 0);
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "int", Justification = "We specificaly want type names")]
        public static int AsInt(this string value, int defaultValue)
        {
            int result;
            return Int32.TryParse(value, out result) ? result : defaultValue;
        }

        public static decimal AsDecimal(this string value)
        {
            // Decimal.TryParse does not work consistently for some locales. For instance for lt-LT, it accepts but ignores decimal values so "12.12" is parsed as 1212.
            return As<Decimal>(value);
        }

        public static decimal AsDecimal(this string value, decimal defaultValue)
        {
            return As<Decimal>(value, defaultValue);
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "float", Justification = "We specificaly want type names")]
        public static float AsFloat(this string value)
        {
            return AsFloat(value, default(float));
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "float", Justification = "We specificaly want type names")]
        public static float AsFloat(this string value, float defaultValue)
        {
            float result;
            return Single.TryParse(value, out result) ? result : defaultValue;
        }

        public static DateTime AsDateTime(this string value)
        {
            return AsDateTime(value, default(DateTime));
        }

        public static DateTime AsDateTime(this string value, DateTime defaultValue)
        {
            DateTime result;
            return DateTime.TryParse(value, out result) ? result : defaultValue;
        }

        public static TValue As<TValue>(this string value)
        {
            return As<TValue>(value, default(TValue));
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "bool", Justification = "We specificaly want type names")]
        public static bool AsBool(this string value)
        {
            return AsBool(value, default(bool));
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "bool", Justification = "We specificaly want type names")]
        public static bool AsBool(this string value, bool defaultValue)
        {
            bool result;
            return Boolean.TryParse(value, out result) ? result : defaultValue;
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We want to make this user friendly and return the default value on all failures")]
        public static TValue As<TValue>(this string value, TValue defaultValue)
        {
            try
            {
                TypeConverter converter = TypeDescriptor.GetConverter(typeof(TValue));
                if (converter.CanConvertFrom(typeof(string)))
                {
                    return (TValue)converter.ConvertFrom(value);
                }
                // try the other direction
                converter = TypeDescriptor.GetConverter(typeof(string));
                if (converter.CanConvertTo(typeof(TValue)))
                {
                    return (TValue)converter.ConvertTo(value, typeof(TValue));
                }
            }
            catch
            {
                // eat all exceptions and return the defaultValue, assumption is that its always a parse/format exception
            }
            return defaultValue;
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "bool", Justification = "We specificaly want type names")]
        public static bool IsBool(this string value)
        {
            bool result;
            return Boolean.TryParse(value, out result);
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "int", Justification = "We specificaly want type names")]
        public static bool IsInt(this string value)
        {
            int result;
            return Int32.TryParse(value, out result);
        }

        public static bool IsDecimal(this string value)
        {
            // For some reason, Decimal.TryParse incorrectly parses floating point values as decimal value for some cultures.
            // For example, 12.5 is parsed as 125 in lt-LT.
            return Is<Decimal>(value);
        }

        [SuppressMessage("Microsoft.Naming", "CA1720:IdentifiersShouldNotContainTypeNames", MessageId = "float", Justification = "We specificaly want type names")]
        public static bool IsFloat(this string value)
        {
            float result;
            return Single.TryParse(value, out result);
        }

        public static bool IsDateTime(this string value)
        {
            DateTime result;
            return DateTime.TryParse(value, out result);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "This is the identical to the way it is done in TypeConverter.IsValid"),
         SuppressMessage("Microsoft.Design", "CA1004:GenericMethodsShouldProvideTypeParameter", Justification = "This is the signature we want")]
        public static bool Is<TValue>(this string value)
        {
            TypeConverter converter = TypeDescriptor.GetConverter(typeof(TValue));
            if (converter != null)
            {
                try
                {
                    if ((value == null) || converter.CanConvertFrom(null, value.GetType()))
                    {
                        // TypeConverter.IsValid essentially does this - a try catch - but uses InvariantCulture to convert. 
                        converter.ConvertFrom(null, CultureInfo.CurrentCulture, value);
                        return true;
                    }
                }
                catch
                {
                }
            }
            return false;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/StringWriterExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Text;

namespace System.Web.WebPages
{
    internal static class StringWriterExtensions
    {
        public const int BufferSize = 1024;

        // Used to copy data from a string writer to avoid allocating the full string
        // which can end up on LOH (and cause memory fragmentation).
        public static void CopyTo(this StringWriter input, TextWriter output)
        {
            StringBuilder builder = input.GetStringBuilder();

            int remainingChars = builder.Length;
            int bufferSize = Math.Min(builder.Length, BufferSize);

            char[] buffer = new char[bufferSize];
            int currentPosition = 0;

            while (remainingChars > 0)
            {
                int copyLen = Math.Min(bufferSize, remainingChars);

                builder.CopyTo(currentPosition, buffer, 0, copyLen);

                output.Write(buffer, 0, copyLen);

                currentPosition += copyLen;
                remainingChars -= copyLen;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/System.Web.WebPages.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.WebPages</RootNamespace>
    <AssemblyName>System.Web.WebPages</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Web" />
    <Reference Include="System.XML" />
    <Reference Include="System.Xml.Linq" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\Common\CollectionExtensions.cs">
      <Link>Common\CollectionExtensions.cs</Link>
    </Compile>
    <Compile Include="..\Common\Empty.cs">
      <Link>Common\Empty.cs</Link>
    </Compile>
    <Compile Include="..\Common\HashCodeCombiner.cs">
      <Link>Common\HashCodeCombiner.cs</Link>
    </Compile>
    <Compile Include="..\Common\ListWrapperCollection.cs">
      <Link>Common\ListWrapperCollection.cs</Link>
    </Compile>
    <Compile Include="..\Common\PathHelpers.cs">
      <Link>Common\PathHelpers.cs</Link>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="ApplicationPart.cs" />
    <Compile Include="ApplicationParts\ApplicationPartRegistry.cs" />
    <Compile Include="ApplicationParts\DictionaryBasedVirtualPathFactory.cs" />
    <Compile Include="ApplicationParts\IResourceAssembly.cs" />
    <Compile Include="ApplicationParts\LazyAction.cs" />
    <Compile Include="ApplicationParts\ResourceAssembly.cs" />
    <Compile Include="ApplicationParts\ResourceHandler.cs" />
    <Compile Include="ApplicationParts\ResourceRouteHandler.cs" />
    <Compile Include="ApplicationStartPage.cs" />
    <Compile Include="AttributeValue.cs" />
    <Compile Include="BrowserOverrideStore.cs" />
    <Compile Include="BrowserOverrideStores.cs" />
    <Compile Include="BrowserOverride.cs" />
    <Compile Include="BuildManagerWrapper.cs" />
    <Compile Include="CookieBrowserOverrideStore.cs" />
    <Compile Include="DisplayInfo.cs" />
    <Compile Include="DisplayModeProvider.cs" />
    <Compile Include="BrowserHelpers.cs" />
    <Compile Include="Helpers\AntiXsrf\ClaimUidExtractor.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryTokenStore.cs" />
    <Compile Include="Helpers\AntiXsrf\MachineKey45CryptoSystem.cs" />
    <Compile Include="Helpers\AntiXsrf\ITokenStore.cs" />
    <Compile Include="Helpers\AntiXsrf\TokenValidator.cs" />
    <Compile Include="Helpers\AntiXsrf\ITokenValidator.cs" />
    <Compile Include="Helpers\AntiXsrf\IClaimUidExtractor.cs" />
    <Compile Include="Helpers\AntiXsrf\ICryptoSystem.cs" />
    <Compile Include="Helpers\Claims\Claim.cs" />
    <Compile Include="Helpers\Claims\ClaimsIdentity.cs" />
    <Compile Include="Helpers\Claims\ClaimsIdentityConverter.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryConfigWrapper.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryWorker.cs" />
    <Compile Include="Helpers\AntiXsrf\IAntiForgeryTokenSerializer.cs" />
    <Compile Include="Helpers\AntiXsrf\IAntiForgeryConfig.cs" />
    <Compile Include="Helpers\CryptoUtil.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryToken.cs" />
    <Compile Include="Helpers\AntiXsrf\BinaryBlob.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryTokenSerializer.cs" />
    <Compile Include="Helpers\AntiForgeryConfig.cs" />
    <Compile Include="Helpers\IAntiForgeryAdditionalDataProvider.cs" />
    <Compile Include="IDisplayMode.cs" />
    <Compile Include="DefaultDisplayMode.cs" />
    <Compile Include="FileExistenceCache.cs" />
    <Compile Include="Helpers\AntiForgery.cs" />
    <Compile Include="HttpContextExtensions.cs" />
    <Compile Include="Instrumentation\HttpContextAdapter.Availability.cs" />
    <Compile Include="Instrumentation\HttpContextAdapter.generated.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>HttpContextAdapter.tt</DependentUpon>
    </Compile>
    <Compile Include="Instrumentation\InstrumentationService.cs" />
    <Compile Include="Instrumentation\PageExecutionContextAdapter.generated.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>PageExecutionContextAdapter.tt</DependentUpon>
    </Compile>
    <Compile Include="Instrumentation\PageExecutionListenerAdapter.generated.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>PageExecutionListenerAdapter.tt</DependentUpon>
    </Compile>
    <Compile Include="Instrumentation\PageInstrumentationServiceAdapter.cs" />
    <Compile Include="Instrumentation\PositionTagged.cs" />
    <Compile Include="IVirtualPathUtility.cs" />
    <Compile Include="MimeMapping.cs" />
    <Compile Include="Mvc\ModelClientValidationEqualToRule.cs" />
    <Compile Include="Mvc\ModelClientValidationMinLengthRule.cs" />
    <Compile Include="Mvc\ModelClientValidationMembershipPasswordRule.cs" />
    <Compile Include="Mvc\ModelClientValidationRangeRule.cs" />
    <Compile Include="Mvc\ModelClientValidationRegexRule.cs" />
    <Compile Include="Mvc\ModelClientValidationRemoteRule.cs" />
    <Compile Include="Mvc\ModelClientValidationRequiredRule.cs" />
    <Compile Include="Mvc\ModelClientValidationRule.cs" />
    <Compile Include="Mvc\ModelClientValidationMaxLengthRule.cs" />
    <Compile Include="Mvc\ModelClientValidationStringLengthRule.cs" />
    <Compile Include="Mvc\UnobtrusiveValidationAttributesGenerator.cs" />
    <Compile Include="RequestBrowserOverrideStore.cs" />
    <Compile Include="StringWriterExtensions.cs" />
    <Compile Include="Utils\HtmlAttributePropertyHelper.cs" />
    <Compile Include="..\Common\PropertyHelper.cs" />
    <Compile Include="Utils\SessionStateUtil.cs" />
    <Compile Include="Utils\TypeHelper.cs" />
    <Compile Include="Utils\UrlRewriterHelper.cs" />
    <Compile Include="Utils\UrlUtil.cs" />
    <Compile Include="Validation\CompareValidator.cs" />
    <Compile Include="Validation\DataTypeValidator.cs" />
    <Compile Include="Validation\IValidator.cs" />
    <Compile Include="Validation\RequestFieldValidatorBase.cs" />
    <Compile Include="Validation\ValidationAttributeAdapter.cs" />
    <Compile Include="Validation\ValidationHelper.cs" />
    <Compile Include="Validation\Validator.cs" />
    <Compile Include="VirtualPathFactoryExtensions.cs" />
    <Compile Include="Mvc\HttpAntiForgeryException.cs" />
    <Compile Include="RequestExtensions.cs" />
    <Compile Include="Helpers\UnvalidatedRequestValues.cs" />
    <Compile Include="Helpers\Validation.cs" />
    <Compile Include="ITemplateFile.cs" />
    <Compile Include="Mvc\TagBuilder.cs" />
    <Compile Include="Mvc\TagRenderMode.cs" />
    <Compile Include="StartPage.cs" />
    <Compile Include="RequestResourceTracker.cs" />
    <Compile Include="DynamicHttpApplicationState.cs" />
    <Compile Include="DynamicPageDataDictionary.cs" />
    <Compile Include="Html\HtmlHelper.Checkbox.cs" />
    <Compile Include="Html\HtmlHelper.cs" />
    <Compile Include="Html\HtmlHelper.Input.cs" />
    <Compile Include="Html\HtmlHelper.Internal.cs" />
    <Compile Include="Html\HtmlHelper.Label.cs" />
    <Compile Include="Html\HtmlHelper.Radio.cs" />
    <Compile Include="Html\HtmlHelper.Select.cs" />
    <Compile Include="Html\HtmlHelper.TextArea.cs" />
    <Compile Include="Html\HtmlHelper.Validation.cs" />
    <Compile Include="Html\SelectListItem.cs" />
    <Compile Include="IVirtualPathFactory.cs" />
    <Compile Include="Scope\ApplicationScopeStorageDictionary.cs" />
    <Compile Include="Scope\AspNetRequestScopeStorageProvider.cs" />
    <Compile Include="Common\DisposableAction.cs" />
    <Compile Include="Scope\IScopeStorageProvider.cs" />
    <Compile Include="Scope\ScopeStorage.cs" />
    <Compile Include="Scope\ScopeStorageComparer.cs" />
    <Compile Include="Scope\ScopeStorageDictionary.cs" />
    <Compile Include="Scope\StaticScopeStorageProvider.cs" />
    <Compile Include="Scope\WebConfigScopeStorageDictionary.cs" />
    <Compile Include="TemplateFileInfo.cs" />
    <Compile Include="TemplateStack.cs" />
    <Compile Include="Utils\CultureUtil.cs" />
    <Compile Include="Utils\PathUtil.cs" />
    <Compile Include="VirtualPathUtilityWrapper.cs" />
    <Compile Include="WebPageHttpModule.cs" />
    <Compile Include="HelperPage.cs" />
    <Compile Include="HelperResult.cs" />
    <Compile Include="IWebPageRequestExecutor.cs" />
    <Compile Include="Html\ModelState.cs" />
    <Compile Include="Html\ModelStateDictionary.cs" />
    <Compile Include="WebPageRoute.cs" />
    <Compile Include="WebPageContext.cs" />
    <Compile Include="SectionWriter.cs" />
    <Compile Include="WebPageExecutingBase.cs" />
    <Compile Include="WebPageRenderingBase.cs" />
    <Compile Include="ReflectionDynamicObject.cs" />
    <Compile Include="ResponseExtensions.cs" />
    <Compile Include="PageDataDictionary.cs" />
    <Compile Include="PageVirtualPathAttribute.cs" />
    <Compile Include="UrlDataList.cs" />
    <Compile Include="StringExtensions.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="Resources\WebPageResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>WebPageResources.resx</DependentUpon>
    </Compile>
    <Compile Include="WebPageMatch.cs" />
    <Compile Include="VirtualPathFactoryManager.cs" />
    <Compile Include="WebPageBase.cs" />
    <Compile Include="WebPageHttpHandler.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="Utils\BuildManagerExceptionUtil.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="WebPage.cs" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\WebPageResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>WebPageResources.Designer.cs</LastGenOutput>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22BABB60-8F02-4027-AFFC-ACF069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="Instrumentation\HttpContextAdapter.tt">
      <Generator>TextTemplatingFileGenerator</Generator>
      <LastGenOutput>HttpContextAdapter.generated.cs</LastGenOutput>
    </None>
    <None Include="Instrumentation\PageExecutionContextAdapter.tt">
      <Generator>TextTemplatingFileGenerator</Generator>
      <LastGenOutput>PageExecutionContextAdapter.generated.cs</LastGenOutput>
    </None>
    <None Include="Instrumentation\PageExecutionListenerAdapter.tt">
      <Generator>TextTemplatingFileGenerator</Generator>
      <LastGenOutput>PageExecutionListenerAdapter.generated.cs</LastGenOutput>
    </None>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.WebPages/TemplateFileInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    /// <summary>
    /// TemplateFileInfo specifies properties of a template such as VirtualPath. 
    /// This type allows us to modify the behavior of ITemplateFile between releases without changing the interface.
    /// </summary>
    public class TemplateFileInfo
    {
        private readonly string _virtualPath;

        public TemplateFileInfo(string virtualPath)
        {
            _virtualPath = virtualPath;
        }

        public string VirtualPath
        {
            get { return _virtualPath; }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/TemplateStack.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;

namespace System.Web.WebPages
{
    /// <summary>
    /// Template stacks store a stack of template files. WebPageExecutingBase implements this type, so when executing Plan9 or Mvc WebViewPage,
    /// the stack would contain instances of the page. 
    /// The stack can be queried to identify properties of the current executing file such as the virtual path of the file.
    /// </summary>
    [SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix", Justification = "TemplateStack is a stack")]
    public static class TemplateStack
    {
        private static readonly object _contextKey = new object();

        public static ITemplateFile GetCurrentTemplate(HttpContextBase httpContext)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }
            return GetStack(httpContext).FirstOrDefault();
        }

        public static ITemplateFile Pop(HttpContextBase httpContext)
        {
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }
            return GetStack(httpContext).Pop();
        }

        public static void Push(HttpContextBase httpContext, ITemplateFile templateFile)
        {
            if (templateFile == null)
            {
                throw new ArgumentNullException("templateFile");
            }
            if (httpContext == null)
            {
                throw new ArgumentNullException("httpContext");
            }
            GetStack(httpContext).Push(templateFile);
        }

        private static Stack<ITemplateFile> GetStack(HttpContextBase httpContext)
        {
            var stack = httpContext.Items[_contextKey] as Stack<ITemplateFile>;
            if (stack == null)
            {
                stack = new Stack<ITemplateFile>();
                httpContext.Items[_contextKey] = stack;
            }
            return stack;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/UrlDataList.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages
{
    // Wrapper for list that lets us return empty string for non existant pieces of the Url
    internal class UrlDataList : IList<string>
    {
        private List<string> _urlData;

        public UrlDataList(string pathInfo)
        {
            if (String.IsNullOrEmpty(pathInfo))
            {
                _urlData = new List<string>();
            }
            else
            {
                _urlData = pathInfo.Split(new char[] { '/' }).ToList();
            }
        }

        public int Count
        {
            get { return _urlData.Count; }
        }

        public bool IsReadOnly
        {
            get { return true; }
        }

        public string this[int index]
        {
            get
            {
                // REVIEW: what about index < 0
                if (index >= _urlData.Count)
                {
                    return String.Empty;
                }
                return _urlData[index];
            }
            set { throw new NotSupportedException(WebPageResources.UrlData_ReadOnly); }
        }

        public int IndexOf(string item)
        {
            return _urlData.IndexOf(item);
        }

        public void Insert(int index, string item)
        {
            throw new NotSupportedException(WebPageResources.UrlData_ReadOnly);
        }

        public void RemoveAt(int index)
        {
            throw new NotSupportedException(WebPageResources.UrlData_ReadOnly);
        }

        public void Add(string item)
        {
            throw new NotSupportedException(WebPageResources.UrlData_ReadOnly);
        }

        public void Clear()
        {
            throw new NotSupportedException(WebPageResources.UrlData_ReadOnly);
        }

        public bool Contains(string item)
        {
            return _urlData.Contains(item);
        }

        public void CopyTo(string[] array, int arrayIndex)
        {
            _urlData.CopyTo(array, arrayIndex);
        }

        public bool Remove(string item)
        {
            throw new NotSupportedException(WebPageResources.UrlData_ReadOnly);
        }

        public IEnumerator<string> GetEnumerator()
        {
            return _urlData.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _urlData.GetEnumerator();
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/BuildManagerExceptionUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;
using System.Web.WebPages.Resources;
using Microsoft.Web.Infrastructure;

namespace System.Web.WebPages
{
    internal static class BuildManagerExceptionUtil
    {
        // Checks the exception to see if it is from CompilationUtil.GetBuildProviderTypeFromExtension, which will throw
        // an exception about an unsupported extension. 
        // Actual error format: There is no build provider registered for the extension '.txt'. You can register one in the <compilation><buildProviders> section in machine.config or web.config. Make sure is has a BuildProviderAppliesToAttribute attribute which includes the value 'Web' or 'All'. 
        internal static bool IsUnsupportedExtensionError(HttpException e)
        {
            Exception exception = e;

            // Go through the layers of exceptions to find if any of them is from GetBuildProviderTypeFromExtension
            while (exception != null)
            {
                var site = exception.TargetSite;
                if (site != null && site.Name == "GetBuildProviderTypeFromExtension" && site.DeclaringType != null && site.DeclaringType.Name == "CompilationUtil")
                {
                    return true;
                }
                exception = exception.InnerException;
            }
            return false;
        }

        internal static void ThrowIfUnsupportedExtension(string virtualPath, HttpException e)
        {
            if (IsUnsupportedExtensionError(e))
            {
                var extension = Path.GetExtension(virtualPath);
                throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_FileNotSupported, extension, virtualPath));
            }
        }

        internal static void ThrowIfCodeDomDefinedExtension(string virtualPath, HttpException e)
        {
            if (e is HttpCompileException)
            {
                var extension = Path.GetExtension(virtualPath);
                if (InfrastructureHelper.IsCodeDomDefinedExtension(extension))
                {
                    throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_FileNotSupported, extension, virtualPath));
                }
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/CultureUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Threading;

namespace System.Web.WebPages
{
    internal static class CultureUtil
    {
        internal static void SetCulture(Thread thread, HttpContextBase context, string cultureName)
        {
            Debug.Assert(!String.IsNullOrEmpty(cultureName));
            CultureInfo cultureInfo = GetCulture(context, cultureName);
            if (cultureInfo != null)
            {
                thread.CurrentCulture = cultureInfo;
            }
        }

        internal static void SetUICulture(Thread thread, HttpContextBase context, string cultureName)
        {
            Debug.Assert(!String.IsNullOrEmpty(cultureName));
            CultureInfo cultureInfo = GetCulture(context, cultureName);
            if (cultureInfo != null)
            {
                thread.CurrentUICulture = cultureInfo;
            }
        }

        private static CultureInfo GetCulture(HttpContextBase context, string cultureName)
        {
            if (cultureName.Equals("auto", StringComparison.OrdinalIgnoreCase))
            {
                return DetermineAutoCulture(context);
            }
            else
            {
                return CultureInfo.GetCultureInfo(cultureName);
            }
        }

        private static CultureInfo DetermineAutoCulture(HttpContextBase context)
        {
            HttpRequestBase request = context.Request;
            Debug.Assert(request != null); //This call is made from a WebPageExecutingBase. Request can never be null when inside a page.
            CultureInfo culture = null;

            if (request.UserLanguages != null)
            {
                string userLanguageEntry = request.UserLanguages.FirstOrDefault();
                if (!String.IsNullOrWhiteSpace(userLanguageEntry))
                {
                    // Check if user language has q parameter. E.g. something like this: "as-IN;q=0.3"
                    int index = userLanguageEntry.IndexOf(';');
                    if (index != -1)
                    {
                        userLanguageEntry = userLanguageEntry.Substring(0, index);
                    }

                    try
                    {
                        culture = new CultureInfo(userLanguageEntry);
                    }
                    catch (CultureNotFoundException)
                    {
                        // There is no easy way to ask if a given culture is invalid so we have to handle exception.  
                    }
                }
            }
            return culture;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/HtmlAttributePropertyHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Reflection;

namespace System.Web.WebPages
{
    internal class HtmlAttributePropertyHelper : PropertyHelper
    {
        private static ConcurrentDictionary<Type, PropertyHelper[]> _reflectionCache = new ConcurrentDictionary<Type, PropertyHelper[]>();

        public static new PropertyHelper[] GetProperties(object instance)
        {
            return GetProperties(instance, CreateInstance, _reflectionCache);
        }

        private static PropertyHelper CreateInstance(PropertyInfo property)
        {
            return new HtmlAttributePropertyHelper(property);
        }

        public HtmlAttributePropertyHelper(PropertyInfo property)
            : base(property)
        {
        }

        public override string Name
        {
            get
            {
                return base.Name;
            }

            protected set
            {
                base.Name = value == null ? null : value.Replace('_', '-');
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/PathUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.WebPages
{
    internal static class PathUtil
    {
        /// <summary>
        /// Path.GetExtension performs a CheckInvalidPathChars(path) which blows up for paths that do not translate to valid physical paths but are valid paths in ASP.NET
        /// This method is a near clone of Path.GetExtension without a call to CheckInvalidPathChars(path);
        /// </summary>
        internal static string GetExtension(string path)
        {
            if (String.IsNullOrEmpty(path))
            {
                return path;
            }
            int current = path.Length;
            while (--current >= 0)
            {
                char ch = path[current];
                if (ch == '.')
                {
                    if (current == path.Length - 1)
                    {
                        break;
                    }
                    return path.Substring(current);
                }
                if (ch == Path.DirectorySeparatorChar || ch == Path.AltDirectorySeparatorChar)
                {
                    break;
                }
            }
            return String.Empty;
        }

        internal static bool IsWithinAppRoot(string appDomainAppVirtualPath, string virtualPath)
        {
            if (appDomainAppVirtualPath == null)
            {
                // If the runtime has not been initialized, just return true.
                return true;
            }

            var absPath = virtualPath;
            if (!VirtualPathUtility.IsAbsolute(absPath))
            {
                absPath = VirtualPathUtility.ToAbsolute(absPath);
            }
            // We need to call this overload because it returns null if the path is not within the application root.
            // The overload calls into MakeVirtualPathAppRelative(string virtualPath, string applicationPath, bool nullIfNotInApp), with 
            // nullIfNotInApp set to true.
            return VirtualPathUtility.ToAppRelative(absPath, appDomainAppVirtualPath) != null;
        }

        /// <summary>
        /// Determines true if the path is simply "MyPath", and not app-relative "~/MyPath" or absolute "/MyApp/MyPath" or relative "../Test/MyPath"
        /// </summary>
        /// <returns>True if it is a not app-relative, absolute or relative.</returns>
        internal static bool IsSimpleName(string path)
        {
            if (VirtualPathUtility.IsAbsolute(path) || VirtualPathUtility.IsAppRelative(path))
            {
                return false;
            }
            if (path.StartsWith(".", StringComparison.OrdinalIgnoreCase))
            {
                return false;
            }
            return true;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/SessionStateUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Web.Razor;
using System.Web.SessionState;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages
{
    internal static class SessionStateUtil
    {
        private static readonly ConcurrentDictionary<Type, SessionStateBehavior?> _sessionStateBehaviorCache = new ConcurrentDictionary<Type, SessionStateBehavior?>();

        internal static void SetUpSessionState(HttpContextBase context, IHttpHandler handler)
        {
            SetUpSessionState(context, handler, _sessionStateBehaviorCache);
        }

        internal static void SetUpSessionState(HttpContextBase context, IHttpHandler handler, ConcurrentDictionary<Type, SessionStateBehavior?> cache)
        {
            WebPageHttpHandler webPageHandler = handler as WebPageHttpHandler;
            Debug.Assert(handler != null);
            SessionStateBehavior? sessionState = GetSessionStateBehavior(webPageHandler.RequestedPage, cache);

            if (sessionState != null)
            {
                // If the page explicitly specifies a session state value, return since it has the most priority.
                context.SetSessionStateBehavior(sessionState.Value);
                return;
            }

            WebPageRenderingBase page = webPageHandler.StartPage;
            StartPage startPage = null;
            do
            {
                // Drill down _AppStart and _PageStart.
                startPage = page as StartPage;
                if (startPage != null)
                {
                    sessionState = GetSessionStateBehavior(page, cache);
                    page = startPage.ChildPage;
                }
            }
            while (startPage != null);

            if (sessionState != null)
            {
                context.SetSessionStateBehavior(sessionState.Value);
            }
        }

        private static SessionStateBehavior? GetSessionStateBehavior(WebPageExecutingBase page, ConcurrentDictionary<Type, SessionStateBehavior?> cache)
        {
            return cache.GetOrAdd(page.GetType(), type =>
            {
                SessionStateBehavior sessionStateBehavior = SessionStateBehavior.Default;
                var attributes = (RazorDirectiveAttribute[])type.GetCustomAttributes(typeof(RazorDirectiveAttribute), inherit: false);
                var directiveAttributes = attributes.Where(attr => StringComparer.OrdinalIgnoreCase.Equals("sessionstate", attr.Name))
                    .ToList();

                if (!directiveAttributes.Any())
                {
                    return null;
                }
                if (directiveAttributes.Count > 1)
                {
                    throw new InvalidOperationException(WebPageResources.SessionState_TooManyValues);
                }
                var directiveAttribute = directiveAttributes[0];
                if (!Enum.TryParse<SessionStateBehavior>(directiveAttribute.Value, ignoreCase: true, result: out sessionStateBehavior))
                {
                    var values = Enum.GetValues(typeof(SessionStateBehavior)).Cast<SessionStateBehavior>().Select(s => s.ToString());
                    throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, WebPageResources.SessionState_InvalidValue,
                                                              directiveAttribute.Value, page.VirtualPath, String.Join(", ", values)));
                }
                return sessionStateBehavior;
            });
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/TypeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web.Routing;

namespace System.Web.WebPages
{
    internal static class TypeHelper
    {
        /// <summary>
        /// Given an object of anonymous type, add each property as a key and associated with its value to a dictionary.
        ///
        /// This helper will cache accessors and types, and is intended when the anonymous object is accessed multiple
        /// times throughout the lifetime of the web application.
        /// </summary>
        public static RouteValueDictionary ObjectToDictionary(object value)
        {
            RouteValueDictionary dictionary = new RouteValueDictionary();

            if (value != null)
            {
                foreach (PropertyHelper helper in PropertyHelper.GetProperties(value))
                {
                    dictionary.Add(helper.Name, helper.GetValue(value));
                }
            }

            return dictionary;
        }

        /// <summary>
        /// Given an object of anonymous type, add each property as a key and associated with its value to a dictionary.
        ///
        /// This helper will not cache accessors and types, and is intended when the anonymous object is accessed once
        /// or very few times throughout the lifetime of the web application.
        /// </summary>
        public static RouteValueDictionary ObjectToDictionaryUncached(object value)
        {
            RouteValueDictionary dictionary = new RouteValueDictionary();

            if (value != null)
            {
                foreach (PropertyHelper helper in PropertyHelper.GetProperties(value))
                {
                    dictionary.Add(helper.Name, helper.GetValue(value));
                }
            }

            return dictionary;
        }

        /// <summary>
        /// Given an object of anonymous type, add each property as a key and associated with its value to the given dictionary.
        /// </summary>
        public static void AddAnonymousObjectToDictionary(IDictionary<string, object> dictionary, object value)
        {
            var values = ObjectToDictionary(value);
            foreach (var item in values)
            {
                dictionary.Add(item);
            }
        }

        /// <remarks>This code is copied from http://www.liensberger.it/web/blog/?p=191 </remarks>
        public static bool IsAnonymousType(Type type)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            // TODO: The only way to detect anonymous types right now.
            return Attribute.IsDefined(type, typeof(CompilerGeneratedAttribute), false)
                   && type.IsGenericType && type.Name.Contains("AnonymousType")
                   && (type.Name.StartsWith("<>", StringComparison.OrdinalIgnoreCase) || type.Name.StartsWith("VB$", StringComparison.OrdinalIgnoreCase))
                   && (type.Attributes & TypeAttributes.NotPublic) == TypeAttributes.NotPublic;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/UrlRewriterHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;

namespace System.Web.WebPages
{
    internal class UrlRewriterHelper
    {
        // internal for tests
        internal const string UrlWasRewrittenServerVar = "IIS_WasUrlRewritten";
        internal const string UrlRewriterEnabledServerVar = "IIS_UrlRewriteModule";

        internal const string UrlWasRequestRewrittenTrueValue = "true";
        internal const string UrlWasRequestRewrittenFalseValue = "false";

        private object _lockObject = new object();
        private bool _urlRewriterIsTurnedOnValue;
        private volatile bool _urlRewriterIsTurnedOnCalculated = false;

        private static bool WasThisRequestRewritten(HttpContextBase httpContext)
        {
            if (httpContext.Items.Contains(UrlWasRewrittenServerVar))
            {
                return Object.Equals(httpContext.Items[UrlWasRewrittenServerVar], UrlWasRequestRewrittenTrueValue);
            }
            else
            {
                HttpWorkerRequest httpWorkerRequest = (HttpWorkerRequest)httpContext.GetService(typeof(HttpWorkerRequest));
                bool requestWasRewritten = (httpWorkerRequest != null && httpWorkerRequest.GetServerVariable(UrlWasRewrittenServerVar) != null);

                if (requestWasRewritten)
                {
                    httpContext.Items.Add(UrlWasRewrittenServerVar, UrlWasRequestRewrittenTrueValue);
                }
                else
                {
                    httpContext.Items.Add(UrlWasRewrittenServerVar, UrlWasRequestRewrittenFalseValue);
                }

                return requestWasRewritten;
            }
        }

        private bool IsUrlRewriterTurnedOn(HttpContextBase httpContext)
        {
            // Need to do double-check locking because a single instance of this class is shared in the entire app domain (see PathHelpers)
            if (!_urlRewriterIsTurnedOnCalculated)
            {
                lock (_lockObject)
                {
                    if (!_urlRewriterIsTurnedOnCalculated)
                    {
                        HttpWorkerRequest httpWorkerRequest = (HttpWorkerRequest)httpContext.GetService(typeof(HttpWorkerRequest));
                        bool urlRewriterIsEnabled = (httpWorkerRequest != null && httpWorkerRequest.GetServerVariable(UrlRewriterEnabledServerVar) != null);
                        _urlRewriterIsTurnedOnValue = urlRewriterIsEnabled;
                        _urlRewriterIsTurnedOnCalculated = true;
                    }
                }
            }
            return _urlRewriterIsTurnedOnValue;
        }

        public virtual bool WasRequestRewritten(HttpContextBase httpContext)
        {
            return IsUrlRewriterTurnedOn(httpContext) && WasThisRequestRewritten(httpContext);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Utils/UrlUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Web.Routing;

namespace System.Web.WebPages
{
    internal static class UrlUtil
    {
        private static UrlRewriterHelper _urlRewriterHelper = new UrlRewriterHelper();

        // this method can accept an app-relative path or an absolute path for contentPath
        public static string GenerateClientUrl(HttpContextBase httpContext, string contentPath)
        {
            if (String.IsNullOrEmpty(contentPath))
            {
                return contentPath;
            }

            // many of the methods we call internally can't handle query strings properly, so just strip it out for
            // the time being
            string query;
            contentPath = StripQuery(contentPath, out query);

            // many of the methods we call internally can't handle query strings properly, so tack it on after processing
            // the virtual app path and url rewrites
            if (String.IsNullOrEmpty(query))
            {
                return GenerateClientUrlInternal(httpContext, contentPath);
            }
            else
            {
                return GenerateClientUrlInternal(httpContext, contentPath) + query;
            }
        }

        public static string GenerateClientUrl(HttpContextBase httpContext, string basePath, string path, params object[] pathParts)
        {
            if (String.IsNullOrEmpty(path))
            {
                return path;
            }

            if (pathParts != null)
            {
                for (int i = 0; i < pathParts.Length; i++)
                {
                    if (pathParts[i] == null)
                    {
                        throw new ArgumentNullException("pathParts");
                    }
                }
            }

            if (basePath != null)
            {
                path = VirtualPathUtility.Combine(basePath, path);
            }

            string query;
            string processedPath = BuildUrl(path, out query, pathParts);

            // many of the methods we call internally can't handle query strings properly, so tack it on after processing
            // the virtual app path and url rewrites
            if (String.IsNullOrEmpty(query))
            {
                return GenerateClientUrlInternal(httpContext, processedPath);
            }
            else
            {
                return GenerateClientUrlInternal(httpContext, processedPath) + query;
            }
        }

        private static string GenerateClientUrlInternal(HttpContextBase httpContext, string contentPath)
        {
            if (String.IsNullOrEmpty(contentPath))
            {
                return contentPath;
            }

            // can't call VirtualPathUtility.IsAppRelative since it throws on some inputs
            bool isAppRelative = contentPath[0] == '~';
            if (isAppRelative)
            {
                string absoluteContentPath = VirtualPathUtility.ToAbsolute(contentPath, httpContext.Request.ApplicationPath);
                return GenerateClientUrlInternal(httpContext, absoluteContentPath);
            }

            // we only want to manipulate the path if URL rewriting is active for this request, else we risk breaking the generated URL
            bool wasRequestRewritten = _urlRewriterHelper.WasRequestRewritten(httpContext);
            if (!wasRequestRewritten)
            {
                return contentPath;
            }

            // Since the rawUrl represents what the user sees in his browser, it is what we want to use as the base
            // of our absolute paths. For example, consider mysite.example.com/foo, which is internally
            // rewritten to content.example.com/mysite/foo. When we want to generate a link to ~/bar, we want to
            // base it from / instead of /foo, otherwise the user ends up seeing mysite.example.com/foo/bar,
            // which is incorrect.
            string relativeUrlToDestination = MakeRelative(httpContext.Request.Path, contentPath);
            string absoluteUrlToDestination = MakeAbsolute(httpContext.Request.RawUrl, relativeUrlToDestination);
            return absoluteUrlToDestination;
        }

        public static string MakeAbsolute(string basePath, string relativePath)
        {
            // The Combine() method can't handle query strings on the base path, so we trim it off.
            string query;
            basePath = StripQuery(basePath, out query);
            return VirtualPathUtility.Combine(basePath, relativePath);
        }

        public static string MakeRelative(string fromPath, string toPath)
        {
            string relativeUrl = VirtualPathUtility.MakeRelative(fromPath, toPath);
            if (String.IsNullOrEmpty(relativeUrl) || relativeUrl[0] == '?')
            {
                // Sometimes VirtualPathUtility.MakeRelative() will return an empty string when it meant to return '.',
                // but links to {empty string} are browser dependent. We replace it with an explicit path to force
                // consistency across browsers.
                relativeUrl = "./" + relativeUrl;
            }
            return relativeUrl;
        }

        private static string StripQuery(string path, out string query)
        {
            int queryIndex = path.IndexOf('?');
            if (queryIndex >= 0)
            {
                query = path.Substring(queryIndex);
                return path.Substring(0, queryIndex);
            }
            else
            {
                query = null;
                return path;
            }
        }

        internal static void ResetUrlRewriterHelper()
        {
            _urlRewriterHelper = new UrlRewriterHelper();
        }

        internal static string BuildUrl(string path, out string query, params object[] pathParts)
        {
            // Performance senstive 
            // 
            // This code branches on the number of path-parts to either favor string.Concat or StringBuilder 
            // for performance. The most common case (for WebPages) will provide a single int value as a 
            // path-part - string.Concat can be more efficient when we know the number of strings to join.
            if (pathParts == null || pathParts.Length == 0)
            {
                query = String.Empty;
                return HttpUtility.UrlPathEncode(path);
            }
            else if (pathParts.Length == 1)
            {
                object pathPart = pathParts[0];
                if (IsDisplayableType(pathPart.GetType()))
                {
                    string displayablePath = Convert.ToString(pathPart, CultureInfo.InvariantCulture);
                    path = path + "/" + displayablePath;
                    query = String.Empty;
                    return HttpUtility.UrlPathEncode(path);
                }
                else
                {
                    StringBuilder queryBuilder = new StringBuilder();
                    AppendToQueryString(queryBuilder, pathPart);

                    query = queryBuilder.ToString();
                    return HttpUtility.UrlPathEncode(path);
                }
            }
            else
            {
                StringBuilder pathBuilder = new StringBuilder(path);
                StringBuilder queryBuilder = new StringBuilder();

                for (int i = 0; i < pathParts.Length; i++)
                {
                    object pathPart = pathParts[i];
                    if (IsDisplayableType(pathPart.GetType()))
                    {
                        var displayablePath = Convert.ToString(pathPart, CultureInfo.InvariantCulture);
                        pathBuilder.Append('/');
                        pathBuilder.Append(displayablePath);
                    }
                    else
                    {
                        AppendToQueryString(queryBuilder, pathPart);
                    }
                }

                query = queryBuilder.ToString();
                return HttpUtility.UrlPathEncode(pathBuilder.ToString());
            }
        }

        private static void AppendToQueryString(StringBuilder queryString, object obj)
        {
            // If this method is called, then obj isn't a type that we can put in the path, instead
            // we want to format it as key-value pairs for the query string. The mostly likely 
            // user scenario for this is an anonymous type.
            IDictionary<string, object> dictionary = TypeHelper.ObjectToDictionary(obj);

            foreach (var item in dictionary)
            {
                if (queryString.Length == 0)
                {
                    queryString.Append('?');
                }
                else
                {
                    queryString.Append('&');
                }

                string stringValue = Convert.ToString(item.Value, CultureInfo.InvariantCulture);

                queryString.Append(HttpUtility.UrlEncode(item.Key))
                    .Append('=')
                    .Append(HttpUtility.UrlEncode(stringValue));
            }
        }

        /// <summary>
        /// Determines if a type is displayable as part of a Url path.
        /// </summary>
        /// <remarks>
        /// If a type is a displayable type, then we format values of that type as part of the Url Path. If not, then
        /// we attempt to create a RouteValueDictionary, and encode the value as key-value pairs in the query string.
        /// 
        /// We determine if a type is displayable by whether or not it implements any interfaces. The built-in simple
        /// types like Int32 implement IFormattable, which will be used to convert it to a string. 
        /// 
        /// Primarily we do this check to allow anonymous types to represent key-value pairs (anonymous types don't 
        /// implement any interfaces). 
        /// </remarks>
        private static bool IsDisplayableType(Type t)
        {
            return t.GetInterfaces().Length > 0;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Validation/CompareValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Web.Mvc;

namespace System.Web.WebPages
{
    internal class CompareValidator : RequestFieldValidatorBase
    {
        private readonly string _otherField;
        private readonly ModelClientValidationEqualToRule _clientValidationRule;

        public CompareValidator(string otherField, string errorMessage)
            : base(errorMessage)
        {
            Debug.Assert(!String.IsNullOrEmpty(otherField));
            _otherField = otherField;
            _clientValidationRule = new ModelClientValidationEqualToRule(errorMessage, otherField);
        }

        public override ModelClientValidationRule ClientValidationRule
        {
            get { return _clientValidationRule; }
        }

        protected override bool IsValid(HttpContextBase httpContext, string value)
        {
            string otherValue = GetRequestValue(httpContext.Request, _otherField);
            return String.Equals(value, otherValue, StringComparison.CurrentCulture);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Validation/DataTypeValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    internal class DataTypeValidator : RequestFieldValidatorBase
    {
        private readonly SupportedValidationDataType _dataType;

        public DataTypeValidator(SupportedValidationDataType type, string errorMessage = null)
            : base(errorMessage)
        {
            _dataType = type;
        }

        public enum SupportedValidationDataType
        {
            DateTime,
            Decimal,
            Url,
            Integer,
            Float
        }

        protected override bool IsValid(HttpContextBase httpContext, string value)
        {
            if (String.IsNullOrEmpty(value))
            {
                return true;
            }

            switch (_dataType)
            {
                case SupportedValidationDataType.DateTime:
                    return value.IsDateTime();
                case SupportedValidationDataType.Float:
                    return value.IsFloat();
                case SupportedValidationDataType.Decimal:
                    return value.IsDecimal();
                case SupportedValidationDataType.Integer:
                    return value.IsInt();
                case SupportedValidationDataType.Url:
                    return Uri.IsWellFormedUriString(value, UriKind.Absolute);
            }
            return true;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Validation/IValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;

namespace System.Web.WebPages
{
    public interface IValidator
    {
        ModelClientValidationRule ClientValidationRule { get; }
        ValidationResult Validate(ValidationContext validationContext);
    }
}


================================================
FILE: src/System.Web.WebPages/Validation/RequestFieldValidatorBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Web.Helpers;
using System.Web.Mvc;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    public abstract class RequestFieldValidatorBase : IValidator
    {
        private readonly string _errorMessage;
        private readonly bool _useUnvalidatedValues;

        protected RequestFieldValidatorBase(string errorMessage)
            : this(errorMessage, useUnvalidatedValues: false)
        {
        }

        protected RequestFieldValidatorBase(string errorMessage, bool useUnvalidatedValues)
        {
            if (String.IsNullOrEmpty(errorMessage))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "errorMessage");
            }

            _errorMessage = errorMessage;
            _useUnvalidatedValues = useUnvalidatedValues;
        }

        public virtual ModelClientValidationRule ClientValidationRule
        {
            get { return null; }
        }

        /// <summary>
        /// Meant for unit tests that causes RequestFieldValidatorBase to basically ignore the unvalidated field requirement.
        /// </summary>
        internal static bool IgnoreUseUnvalidatedValues { get; set; }

        protected abstract bool IsValid(HttpContextBase httpContext, string value);

        public virtual ValidationResult Validate(ValidationContext validationContext)
        {
            var httpContext = GetHttpContext(validationContext);
            var field = validationContext.MemberName;
            var fieldValue = GetRequestValue(httpContext.Request, field);

            if (IsValid(httpContext, fieldValue))
            {
                return ValidationResult.Success;
            }
            return new ValidationResult(_errorMessage, memberNames: new[] { field });
        }

        protected static HttpContextBase GetHttpContext(ValidationContext validationContext)
        {
            Debug.Assert(validationContext.ObjectInstance is HttpContextBase, "For our validation context, ObjectInstance must be an HttpContextBase instance.");
            return (HttpContextBase)validationContext.ObjectInstance;
        }

        protected string GetRequestValue(HttpRequestBase request, string field)
        {
            if (IgnoreUseUnvalidatedValues)
            {
                // Make sure we do not set this when we are hosted since this is only meant for unit test scenarios.
                Debug.Assert(HttpContext.Current == null, "This flag should not be set when we are hosted.");
                return request.Form[field];
            }
            return _useUnvalidatedValues ? request.Unvalidated[field] : request.Form[field];
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Validation/ValidationAttributeAdapter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Web.Mvc;

namespace System.Web.WebPages
{
    internal class ValidationAttributeAdapter : RequestFieldValidatorBase
    {
        private readonly ValidationAttribute _attribute;
        private readonly ModelClientValidationRule _clientValidationRule;

        public ValidationAttributeAdapter(ValidationAttribute attribute, string errorMessage, ModelClientValidationRule clientValidationRule)
            :
                this(attribute, errorMessage, clientValidationRule, useUnvalidatedValues: false)
        {
        }

        public ValidationAttributeAdapter(ValidationAttribute attribute, string errorMessage, ModelClientValidationRule clientValidationRule, bool useUnvalidatedValues)
            : base(errorMessage, useUnvalidatedValues)
        {
            _attribute = attribute;
            _clientValidationRule = clientValidationRule;
        }

        public ValidationAttribute Attribute
        {
            get { return _attribute; }
        }

        public override ModelClientValidationRule ClientValidationRule
        {
            get { return _clientValidationRule; }
        }

        protected override bool IsValid(HttpContextBase httpContext, string value)
        {
            return _attribute.IsValid(value);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Validation/ValidationHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Web.Mvc;
using System.Web.WebPages.Html;
using System.Web.WebPages.Scope;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    public sealed class ValidationHelper
    {
        private static readonly object _invalidCssClassKey = new object();
        private static readonly object _validCssClassKey = new object();
        private static IDictionary<object, object> _scopeOverride;

        private readonly Dictionary<string, List<IValidator>> _validators = new Dictionary<string, List<IValidator>>(StringComparer.OrdinalIgnoreCase);
        private readonly HttpContextBase _httpContext;
        private readonly ModelStateDictionary _modelStateDictionary;

        internal ValidationHelper(HttpContextBase httpContext, ModelStateDictionary modelStateDictionary)
        {
            Debug.Assert(httpContext != null);
            Debug.Assert(modelStateDictionary != null);

            _httpContext = httpContext;
            _modelStateDictionary = modelStateDictionary;
        }

        public static string ValidCssClass
        {
            get
            {
                object value;
                if (!Scope.TryGetValue(_validCssClassKey, out value))
                {
                    return null;
                }
                return value as string;
            }
            set { Scope[_validCssClassKey] = value; }
        }

        public static string InvalidCssClass
        {
            get
            {
                object value;
                if (!Scope.TryGetValue(_invalidCssClassKey, out value))
                {
                    return HtmlHelper.DefaultValidationInputErrorCssClass;
                }
                return value as string;
            }
            set { Scope[_invalidCssClassKey] = value; }
        }

        [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "This makes it easier for a user to read this value without knowing of this type.")]
        public string FormField
        {
            get { return ModelStateDictionary.FormFieldKey; }
        }

        internal static IDictionary<object, object> Scope
        {
            get { return _scopeOverride ?? ScopeStorage.CurrentScope; }
        }

        public void RequireField(string field)
        {
            RequireField(field, errorMessage: null);
        }

        public void RequireField(string field, string errorMessage)
        {
            if (String.IsNullOrEmpty(field))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "field");
            }
            Add(field, Validator.Required(errorMessage: errorMessage));
        }

        public void RequireFields(params string[] fields)
        {
            if (fields == null)
            {
                throw new ArgumentNullException("fields");
            }
            foreach (var field in fields)
            {
                RequireField(field);
            }
        }

        public void Add(string field, params IValidator[] validators)
        {
            if (String.IsNullOrEmpty(field))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "field");
            }
            if ((validators == null) || validators.Any(v => v == null))
            {
                throw new ArgumentNullException("validators");
            }

            AddFieldValidators(field, validators);
        }

        public void Add(IEnumerable<string> fields, params IValidator[] validators)
        {
            if (fields == null)
            {
                throw new ArgumentNullException("fields");
            }
            if (validators == null)
            {
                throw new ArgumentNullException("validators");
            }
            foreach (var field in fields)
            {
                Add(field, validators);
            }
        }

        public void AddFormError(string errorMessage)
        {
            _modelStateDictionary.AddFormError(errorMessage);
        }

        public bool IsValid(params string[] fields)
        {
            // Don't need to validate fields as we treat empty fields as all in Validate.
            return !Validate(fields).Any();
        }

        public IEnumerable<ValidationResult> Validate(params string[] fields)
        {
            IEnumerable<string> keys = fields;
            if (fields == null || !fields.Any())
            {
                // If no fields are present, validate all of them.
                keys = _validators.Keys.Concat(new[] { FormField });
            }
            return ValidateFieldsAndUpdateModelState(keys);
        }

        public IEnumerable<string> GetErrors(params string[] fields)
        {
            // Don't need to validate fields as we treat empty fields as all in Validate.
            return Validate(fields).Select(r => r.ErrorMessage);
        }

        public HtmlString For(string field)
        {
            if (String.IsNullOrEmpty(field))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "field");
            }

            var clientRules = GetClientValidationRules(field);
            return GenerateHtmlFromClientValidationRules(clientRules);
        }

        public HtmlString ClassFor(string field)
        {
            if (_httpContext != null && String.Equals("POST", _httpContext.Request.HttpMethod, StringComparison.OrdinalIgnoreCase))
            {
                string cssClass = IsValid(field) ? ValidationHelper.ValidCssClass : ValidationHelper.InvalidCssClass;
                return cssClass == null ? null : new HtmlString(cssClass);
            }
            return null;
        }

        internal static IDisposable OverrideScope()
        {
            _scopeOverride = new Dictionary<object, object>();
            return new DisposableAction(() => _scopeOverride = null);
        }

        internal IDictionary<string, object> GetUnobtrusiveValidationAttributes(string field)
        {
            var clientRules = GetClientValidationRules(field);
            var attributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            UnobtrusiveValidationAttributesGenerator.GetValidationAttributes(clientRules, attributes);
            return attributes;
        }

        private IEnumerable<ValidationResult> ValidateFieldsAndUpdateModelState(IEnumerable<string> fields)
        {
            var validationContext = new ValidationContext(_httpContext, serviceProvider: null, items: null);
            var validationResults = new List<ValidationResult>();
            foreach (var field in fields)
            {
                IEnumerable<ValidationResult> fieldResults = ValidateField(field, validationContext);
                IEnumerable<string> errors = fieldResults.Select(c => c.ErrorMessage);
                ModelState modelState = _modelStateDictionary[field];
                if (modelState != null && modelState.Errors.Any())
                {
                    errors = errors.Except(modelState.Errors, StringComparer.OrdinalIgnoreCase);

                    // If there were other validation errors that were added via ModelState, add them to the collection.
                    fieldResults = fieldResults.Concat(modelState.Errors.Select(e => new ValidationResult(e, new[] { field })));
                }

                foreach (var errorMessage in errors)
                {
                    // Only add errors that haven't been encountered before. This is to prevent from the same error message being duplicated 
                    // if a call is made multiple times
                    _modelStateDictionary.AddError(field, errorMessage);
                }

                validationResults.AddRange(fieldResults);
            }
            return validationResults;
        }

        private void AddFieldValidators(string field, params IValidator[] validators)
        {
            List<IValidator> fieldValidators = null;
            if (!_validators.TryGetValue(field, out fieldValidators))
            {
                fieldValidators = new List<IValidator>();
                _validators[field] = fieldValidators;
            }
            foreach (var validator in validators)
            {
                fieldValidators.Add(validator);
            }
        }

        private IEnumerable<ValidationResult> ValidateField(string field, ValidationContext context)
        {
            List<IValidator> fieldValidators;
            if (!_validators.TryGetValue(field, out fieldValidators))
            {
                return Enumerable.Empty<ValidationResult>();
            }
            context.MemberName = field;
            return fieldValidators.Select(f => f.Validate(context))
                .Where(result => result != ValidationResult.Success);
        }

        private IEnumerable<ModelClientValidationRule> GetClientValidationRules(string field)
        {
            List<IValidator> fieldValidators = null;
            if (!_validators.TryGetValue(field, out fieldValidators))
            {
                return Enumerable.Empty<ModelClientValidationRule>();
            }

            return from item in fieldValidators
                   let clientRule = item.ClientValidationRule
                   where clientRule != null
                   select clientRule;
        }

        internal static HtmlString GenerateHtmlFromClientValidationRules(IEnumerable<ModelClientValidationRule> clientRules)
        {
            if (!clientRules.Any())
            {
                return null;
            }

            var attributes = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            UnobtrusiveValidationAttributesGenerator.GetValidationAttributes(clientRules, attributes);

            var stringBuilder = new StringBuilder();
            foreach (var attribute in attributes)
            {
                string key = attribute.Key;
                string value = HttpUtility.HtmlEncode(Convert.ToString(attribute.Value, CultureInfo.InvariantCulture));
                stringBuilder.Append(key)
                    .Append("=\"")
                    .Append(value)
                    .Append('"')
                    .Append(' ');
            }

            // Trim trailing whitespace
            if (stringBuilder.Length > 0)
            {
                stringBuilder.Length--;
            }

            return new HtmlString(stringBuilder.ToString());
        }
    }
}


================================================
FILE: src/System.Web.WebPages/Validation/Validator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Web.Mvc;
using System.Web.WebPages.Resources;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    public abstract class Validator
    {
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Required(string errorMessage = null)
        {
            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_Required);
            var clientAttributes = new ModelClientValidationRequiredRule(errorMessage);
            // We don't care if the value is unsafe when verifying that it is required.
            return new ValidationAttributeAdapter(new RequiredAttribute(), errorMessage, clientAttributes, useUnvalidatedValues: true);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Range(int minValue, int maxValue, string errorMessage = null)
        {
            errorMessage = String.Format(CultureInfo.CurrentCulture, DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_IntegerRange), minValue, maxValue);
            var clientAttributes = new ModelClientValidationRangeRule(errorMessage, minValue, maxValue);
            return new ValidationAttributeAdapter(new RangeAttribute(minValue, maxValue), errorMessage, clientAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Range(double minValue, double maxValue, string errorMessage = null)
        {
            errorMessage = String.Format(CultureInfo.CurrentCulture, DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_FloatRange), minValue, maxValue);
            var clientAttributes = new ModelClientValidationRangeRule(errorMessage, minValue, maxValue);
            return new ValidationAttributeAdapter(new RangeAttribute(minValue, maxValue), errorMessage, clientAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator StringLength(int maxLength, int minLength = 0, string errorMessage = null)
        {
            if (minLength == 0)
            {
                errorMessage = String.Format(CultureInfo.CurrentCulture, DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_StringLength), maxLength);
            }
            else
            {
                errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_StringLengthRange);
                errorMessage = String.Format(CultureInfo.CurrentCulture, errorMessage, minLength, maxLength);
            }
            var clientAttributes = new ModelClientValidationStringLengthRule(errorMessage, minLength, maxLength);

            // We don't care if the value is unsafe when checking the length of the request field passed to us.
            return new ValidationAttributeAdapter(new StringLengthAttribute(maxLength) { MinimumLength = minLength }, errorMessage, clientAttributes,
                                                  useUnvalidatedValues: true);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Regex(string pattern, string errorMessage = null)
        {
            if (String.IsNullOrEmpty(pattern))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "pattern");
            }

            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_Regex);
            var clientAttributes = new ModelClientValidationRegexRule(errorMessage, pattern);
            return new ValidationAttributeAdapter(new RegularExpressionAttribute(pattern), errorMessage, clientAttributes);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator EqualsTo(string otherFieldName, string errorMessage = null)
        {
            if (String.IsNullOrEmpty(otherFieldName))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "otherFieldName");
            }

            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_EqualsTo);
            return new CompareValidator(otherFieldName, errorMessage);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator DateTime(string errorMessage = null)
        {
            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_DataType);
            return new DataTypeValidator(DataTypeValidator.SupportedValidationDataType.DateTime, errorMessage);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Decimal(string errorMessage = null)
        {
            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_DataType);
            return new DataTypeValidator(DataTypeValidator.SupportedValidationDataType.Decimal, errorMessage);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Integer(string errorMessage = null)
        {
            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_DataType);
            return new DataTypeValidator(DataTypeValidator.SupportedValidationDataType.Integer, errorMessage);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Url(string errorMessage = null)
        {
            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_DataType);
            return new DataTypeValidator(DataTypeValidator.SupportedValidationDataType.Url, errorMessage);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "We are ok using default parameters for helpers")]
        public static IValidator Float(string errorMessage = null)
        {
            errorMessage = DefaultIfEmpty(errorMessage, WebPageResources.ValidationDefault_DataType);
            return new DataTypeValidator(DataTypeValidator.SupportedValidationDataType.Float, errorMessage);
        }

        private static string DefaultIfEmpty(string errorMessage, string defaultErrorMessage)
        {
            if (String.IsNullOrEmpty(errorMessage))
            {
                return defaultErrorMessage;
            }
            return errorMessage;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/VirtualPathFactoryExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    internal static class VirtualPathFactoryExtensions
    {
        public static T CreateInstance<T>(this IVirtualPathFactory factory, string virtualPath) where T : class
        {
            var virtualPathFactoryManager = factory as VirtualPathFactoryManager;
            if (virtualPathFactoryManager != null)
            {
                return virtualPathFactoryManager.CreateInstanceOfType<T>(virtualPath);
            }
            var buildManagerFactory = factory as BuildManagerWrapper;
            if (buildManagerFactory != null)
            {
                return buildManagerFactory.CreateInstanceOfType<T>(virtualPath);
            }

            return factory.CreateInstance(virtualPath) as T;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/VirtualPathFactoryManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.WebPages
{
    // This class encapsulates the creation of objects from virtual paths.  The creation is either performed via BuildBanager API's, or
    // by using explicitly registered factories (which happens through ApplicationPart.Register).
    public class VirtualPathFactoryManager : IVirtualPathFactory
    {
        private static readonly Lazy<VirtualPathFactoryManager> _instance = new Lazy<VirtualPathFactoryManager>(() => new VirtualPathFactoryManager(new BuildManagerWrapper()));
        private static Func<string, bool> _instancePathExists;
        private readonly LinkedList<IVirtualPathFactory> _virtualPathFactories = new LinkedList<IVirtualPathFactory>();

        internal VirtualPathFactoryManager(IVirtualPathFactory defaultFactory)
        {
            _virtualPathFactories.AddFirst(defaultFactory);
        }

        // Get the VirtualPathFactoryManager singleton instance
        internal static VirtualPathFactoryManager Instance
        {
            get { return _instance.Value; }
        }

        internal static Func<string, bool> InstancePathExists
        {
            get 
            {
                if (_instancePathExists == null)
                {
                    _instancePathExists = Instance.Exists;
                }
                return _instancePathExists;
            }
        }

        internal IEnumerable<IVirtualPathFactory> RegisteredFactories
        {
            get { return _virtualPathFactories; }
        }

        public static void RegisterVirtualPathFactory(IVirtualPathFactory virtualPathFactory)
        {
            Instance.RegisterVirtualPathFactoryInternal(virtualPathFactory);
        }

        internal void RegisterVirtualPathFactoryInternal(IVirtualPathFactory virtualPathFactory)
        {
            _virtualPathFactories.AddBefore(_virtualPathFactories.Last, virtualPathFactory);
        }

        public bool Exists(string virtualPath)
        {
            // Performance sensitive so avoid Linq and delegates
            foreach (IVirtualPathFactory factory in _virtualPathFactories)
            {
                if (factory.Exists(virtualPath))
                {
                    return true;
                }
            }
            return false;
        }

        public object CreateInstance(string virtualPath)
        {
            return CreateInstanceOfType<object>(virtualPath);
        }

        internal T CreateInstanceOfType<T>(string virtualPath) where T : class
        {
            var virtualPathFactory = _virtualPathFactories.FirstOrDefault(f => f.Exists(virtualPath));
            if (virtualPathFactory != null)
            {
                return virtualPathFactory.CreateInstance<T>(virtualPath);
            }
            return null;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/VirtualPathUtilityWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web;

namespace Microsoft.Internal.Web.Utils
{
    internal sealed class VirtualPathUtilityWrapper : IVirtualPathUtility
    {
        public string Combine(string basePath, string relativePath)
        {
            return VirtualPathUtility.Combine(basePath, relativePath);
        }

        public string ToAbsolute(string virtualPath)
        {
            return VirtualPathUtility.ToAbsolute(virtualPath);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPage.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Web.WebPages.Html;
using System.Web.WebPages.Scope;

namespace System.Web.WebPages
{
    [SuppressMessage("Microsoft.Maintainability", "CA1506:AvoidExcessiveClassCoupling", Justification = "This is a core class which needs to have references to many other classes")]
    public abstract class WebPage : WebPageBase
    {
        private static readonly List<IWebPageRequestExecutor> _executors = new List<IWebPageRequestExecutor>();

        private HttpContextBase _context;
        // Expose the model as dynamic
        private dynamic _model;

        // True if this is a 'top level' page (URL addressable), vs a 'satellite' page like a user control or master
        internal bool TopLevelPage { get; set; }

        public override HttpContextBase Context
        {
            get
            {
                if (_context == null)
                {
                    return PageContext.HttpContext;
                }
                return _context;
            }
            set { _context = value; }
        }

        public HtmlHelper Html { get; private set; }

        public ValidationHelper Validation
        {
            get { return PageContext.Validation; }
        }

        public dynamic Model
        {
            get
            {
                if (_model == null)
                {
                    // Instead of directly returning the model, we wrap it in our own custom DynamicObject.
                    // This allows it to perform private reflection, which would normally fail. This is useful
                    // when dealing with anonymous objects, which are always internal
                    _model = ReflectionDynamicObject.WrapObjectIfInternal(PageContext.Model);
                }
                return _model;
            }
        }

        public ModelStateDictionary ModelState
        {
            get { return PageContext.ModelState; }
        }

        public static void RegisterPageExecutor(IWebPageRequestExecutor executor)
        {
            _executors.Add(executor);
        }

        public override void ExecutePageHierarchy()
        {
            using (ScopeStorage.CreateTransientScope(new ScopeStorageDictionary(ScopeStorage.CurrentScope, PageData)))
            {
                ExecutePageHierarchy(_executors);
            }
        }

        internal void ExecutePageHierarchy(IEnumerable<IWebPageRequestExecutor> executors)
        {
            // Call all the executors until we find one that wants to handle it. This is used to implement features
            // such as AJAX Page methods without having to bake them into the framework.
            // Note that we only do this for 'top level' pages, as these are request-level executors that should not run for each user control/master
            if (!TopLevelPage || !executors.Any(executor => executor.Execute(this)))
            {
                // No executor handled the request, so use normal processing
                base.ExecutePageHierarchy();
            }
        }

        public override HelperResult RenderPage(string path, params object[] data)
        {
            return base.RenderPage(path, data);
        }

        protected override void InitializePage()
        {
            base.InitializePage();

            Html = new HtmlHelper(ModelState, Validation);
        }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Text;
using System.Web.WebPages.Resources;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable", Justification = "This is temporary (elipton)")]
    public abstract class WebPageBase : WebPageRenderingBase
    {
        // Keep track of which sections RenderSection has already been called on
        private readonly HashSet<string> _renderedSections = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        // Keep track of whether RenderBody has been called
        private bool _renderedBody = false;
        // Action for rendering the body within a layout page
        private Action<TextWriter> _body;

        private StringWriter _tempWriter;
        private TextWriter _currentWriter;

        private DynamicPageDataDictionary<dynamic> _dynamicPageData;

        public override string Layout { get; set; }

        public TextWriter Output
        {
            get { return OutputStack.Peek(); }
        }

        public Stack<TextWriter> OutputStack
        {
            get { return PageContext.OutputStack; }
        }

        public override IDictionary<object, dynamic> PageData
        {
            get { return PageContext.PageData; }
        }

        public override dynamic Page
        {
            get
            {
                if (_dynamicPageData == null)
                {
                    _dynamicPageData = new DynamicPageDataDictionary<dynamic>((PageDataDictionary<dynamic>)PageData);
                }
                return _dynamicPageData;
            }
        }

        // Retrieves the sections defined in the calling page. If this is null, that means
        // this page has been requested directly.
        private Dictionary<string, SectionWriter> PreviousSectionWriters
        {
            get
            {
                var top = SectionWritersStack.Pop();
                var previous = SectionWritersStack.Count > 0 ? SectionWritersStack.Peek() : null;
                SectionWritersStack.Push(top);
                return previous;
            }
        }

        // Retrieves the current Dictionary of sectionWriters on the stack without poping it.
        // There should be at least one on the stack which is added when the Render(ViewData,TextWriter)
        // is called.
        private Dictionary<string, SectionWriter> SectionWriters
        {
            get { return SectionWritersStack.Peek(); }
        }

        private Stack<Dictionary<string, SectionWriter>> SectionWritersStack
        {
            get { return PageContext.SectionWritersStack; }
        }

        protected virtual void ConfigurePage(WebPageBase parentPage)
        {
        }

        public static WebPageBase CreateInstanceFromVirtualPath(string virtualPath)
        {
            return CreateInstanceFromVirtualPath(virtualPath, VirtualPathFactoryManager.Instance);
        }

        internal static WebPageBase CreateInstanceFromVirtualPath(string virtualPath, IVirtualPathFactory virtualPathFactory)
        {
            // Get the compiled object
            try
            {
                WebPageBase webPage = virtualPathFactory.CreateInstance<WebPageBase>(virtualPath);

                // Give it its virtual path
                webPage.VirtualPath = virtualPath;

                // Assign it the VirtualPathFactory
                webPage.VirtualPathFactory = virtualPathFactory;

                return webPage;
            }
            catch (HttpException e)
            {
                BuildManagerExceptionUtil.ThrowIfUnsupportedExtension(virtualPath, e);
                throw;
            }
        }

        /// <summary>
        /// Attempts to create a WebPageBase instance from a virtualPath and wraps complex compiler exceptions with simpler messages
        /// </summary>
        protected virtual WebPageBase CreatePageFromVirtualPath(string virtualPath, HttpContextBase httpContext, Func<string, bool> virtualPathExists, DisplayModeProvider displayModeProvider, IDisplayMode displayMode)
        {
            try
            {
                DisplayInfo resolvedDisplayInfo = displayModeProvider.GetDisplayInfoForVirtualPath(virtualPath, httpContext, virtualPathExists, displayMode);

                if (resolvedDisplayInfo != null)
                {
                    var webPage = VirtualPathFactory.CreateInstance<WebPageBase>(resolvedDisplayInfo.FilePath);

                    if (webPage != null)
                    {
                        // Give it its virtual path
                        webPage.VirtualPath = virtualPath;
                        webPage.VirtualPathFactory = VirtualPathFactory;
                        webPage.DisplayModeProvider = DisplayModeProvider;

                        return webPage;
                    }
                }
            }
            catch (HttpException e)
            {
                // If the path uses an unregistered extension, such as Foo.txt,
                // then an error regarding build providers will be thrown.
                // Check if this is the case and throw a simpler error.
                BuildManagerExceptionUtil.ThrowIfUnsupportedExtension(virtualPath, e);

                // If the path uses an extension registered with codedom, such as Foo.js,
                // then an unfriendly compilation error might get thrown by the underlying compiler.
                // Check if this is the case and throw a simpler error.
                BuildManagerExceptionUtil.ThrowIfCodeDomDefinedExtension(virtualPath, e);

                // Rethrow any errors
                throw;
            }
            // The page is missing, could not be compiled or is of an invalid type.
            throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_InvalidPageType, virtualPath));
        }

        private WebPageContext CreatePageContextFromParameters(bool isLayoutPage, params object[] data)
        {
            object first = null;
            if (data != null && data.Length > 0)
            {
                first = data[0];
            }

            var pageData = PageDataDictionary<dynamic>.CreatePageDataFromParameters(PageData, data);

            return WebPageContext.CreateNestedPageContext(PageContext, pageData, first, isLayoutPage);
        }

        public void DefineSection(string name, SectionWriter action)
        {
            if (SectionWriters.ContainsKey(name))
            {
                throw new HttpException(String.Format(CultureInfo.InvariantCulture, WebPageResources.WebPage_SectionAleadyDefined, name));
            }
            SectionWriters[name] = action;
        }

        internal void EnsurePageCanBeRequestedDirectly(string methodName)
        {
            if (PreviousSectionWriters == null)
            {
                throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_CannotRequestDirectly, VirtualPath, methodName));
            }
        }

        public void ExecutePageHierarchy(WebPageContext pageContext, TextWriter writer)
        {
            ExecutePageHierarchy(pageContext, writer, startPage: null);
        }

        // This method is only used by WebPageBase to allow passing in the view context and writer.
        public void ExecutePageHierarchy(WebPageContext pageContext, TextWriter writer, WebPageRenderingBase startPage)
        {
            PushContext(pageContext, writer);

            if (startPage != null)
            {
                if (startPage != this)
                {
                    var startPageContext = WebPageContext.CreateNestedPageContext<object>(parentContext: pageContext, pageData: null, model: null, isLayoutPage: false);
                    startPageContext.Page = startPage;
                    startPage.PageContext = startPageContext;
                }
                startPage.ExecutePageHierarchy();
            }
            else
            {
                ExecutePageHierarchy();
            }
            PopContext();
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We really don't care if SourceHeader fails, and we don't want it to fail any real requests ever")]
        public override void ExecutePageHierarchy()
        {
            // Unlike InitPages, for a WebPage there is no hierarchy - it is always
            // the last file to execute in the chain. There can still be layout pages
            // and partial pages, but they are never part of the hierarchy.

            // (add server header for falcon debugging)
            // call to MapPath() is expensive. If we are not emiting source files to header, 
            // don't bother to populate the SourceFiles collection. This saves perf significantly.
            if (WebPageHttpHandler.ShouldGenerateSourceHeader(Context))
            {
                try
                {
                    string vp = VirtualPath;
                    if (vp != null)
                    {
                        string path = Context.Request.MapPath(vp);
                        if (!path.IsEmpty())
                        {
                            PageContext.SourceFiles.Add(path);
                        }
                    }
                }
                catch
                {
                    // we really don't care if this ever fails, so we swallow all exceptions
                }
            }

            TemplateStack.Push(Context, this);
            try
            {
                // Execute the developer-written code of the WebPage
                Execute();
            }
            finally
            {
                TemplateStack.Pop(Context);
            }
        }

        protected virtual void InitializePage()
        {
        }

        public bool IsSectionDefined(string name)
        {
            EnsurePageCanBeRequestedDirectly("IsSectionDefined");
            return PreviousSectionWriters.ContainsKey(name);
        }

        public void PopContext()
        {
            // Using the CopyTo extension method on the _tempWriter instead of .ToString()
            // to avoid allocating large strings that then end up on the Large object heap.
            OutputStack.Pop();

            if (!String.IsNullOrEmpty(Layout))
            {
                string layoutPagePath = NormalizeLayoutPagePath(Layout);

                // If a layout file was specified, render it passing our page content.
                OutputStack.Push(_currentWriter);
                RenderSurrounding(
                    layoutPagePath,
                    _tempWriter.CopyTo);
                OutputStack.Pop();
            }
            else
            {
                // Otherwise, just render the page.
                _tempWriter.CopyTo(_currentWriter);
            }

            VerifyRenderedBodyOrSections();
            SectionWritersStack.Pop();
        }

        public void PushContext(WebPageContext pageContext, TextWriter writer)
        {
            _currentWriter = writer;
            PageContext = pageContext;
            pageContext.Page = this;

            InitializePage();

            // Create a temporary writer
            _tempWriter = new StringWriter(CultureInfo.InvariantCulture);

            // Render the page into it
            OutputStack.Push(_tempWriter);
            SectionWritersStack.Push(new Dictionary<string, SectionWriter>(StringComparer.OrdinalIgnoreCase));

            // If the body is defined in the ViewData, remove it and store it on the instance
            // so that it won't affect rendering of partial pages when they call VerifyRenderedBodyOrSections
            if (PageContext.BodyAction != null)
            {
                _body = PageContext.BodyAction;
                PageContext.BodyAction = null;
            }
        }

        public HelperResult RenderBody()
        {
            EnsurePageCanBeRequestedDirectly("RenderBody");

            if (_renderedBody)
            {
                throw new HttpException(WebPageResources.WebPage_RenderBodyAlreadyCalled);
            }
            _renderedBody = true;

            // _body should have previously been set in Render(ViewContext,TextWriter) if it
            // was available in the ViewData.
            if (_body != null)
            {
                return new HelperResult(tw => _body(tw));
            }
            else
            {
                throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_CannotRequestDirectly, VirtualPath, "RenderBody"));
            }
        }

        public override HelperResult RenderPage(string path, params object[] data)
        {
            return RenderPageCore(path, isLayoutPage: false, data: data);
        }

        private HelperResult RenderPageCore(string path, bool isLayoutPage, object[] data)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }

            return new HelperResult(writer =>
            {
                path = NormalizePath(path);
                WebPageBase subPage = CreatePageFromVirtualPath(path, Context, VirtualPathFactory.Exists, DisplayModeProvider, DisplayMode);
                var pageContext = CreatePageContextFromParameters(isLayoutPage, data);

                subPage.ConfigurePage(this);
                subPage.ExecutePageHierarchy(pageContext, writer);
            });
        }

        public HelperResult RenderSection(string name)
        {
            return RenderSection(name, required: true);
        }

        public HelperResult RenderSection(string name, bool required)
        {
            EnsurePageCanBeRequestedDirectly("RenderSection");

            if (PreviousSectionWriters.ContainsKey(name))
            {
                var result = new HelperResult(tw =>
                {
                    if (_renderedSections.Contains(name))
                    {
                        throw new HttpException(String.Format(CultureInfo.InvariantCulture, WebPageResources.WebPage_SectionAleadyRendered, name));
                    }
                    var body = PreviousSectionWriters[name];
                    // Since the body can also call RenderSection, we need to temporarily remove
                    // the current sections from the stack.
                    var top = SectionWritersStack.Pop();

                    bool pushed = false;
                    try
                    {
                        if (Output != tw)
                        {
                            OutputStack.Push(tw);
                            pushed = true;
                        }

                        body();
                    }
                    finally
                    {
                        if (pushed)
                        {
                            OutputStack.Pop();
                        }
                    }
                    SectionWritersStack.Push(top);
                    _renderedSections.Add(name);
                });
                return result;
            }
            else if (required)
            {
                // If the section is not found, and it is not optional, throw an error.
                throw new HttpException(String.Format(CultureInfo.InvariantCulture, WebPageResources.WebPage_SectionNotDefined, name));
            }
            else
            {
                // If the section is optional and not found, then don't do anything.
                return null;
            }
        }

        private void RenderSurrounding(string partialViewName, Action<TextWriter> body)
        {
            // Save the previous body action and set ours instead.
            // This value will be retrieved by the sub-page being rendered when it runs
            // Render(ViewData, TextWriter).
            var priorValue = PageContext.BodyAction;
            PageContext.BodyAction = body;

            // Render the layout file
            Write(RenderPageCore(partialViewName, isLayoutPage: true, data: new object[0]));

            // Restore the state
            PageContext.BodyAction = priorValue;
        }

        // Verifies that RenderBody is called, or that RenderSection is called for all sections
        private void VerifyRenderedBodyOrSections()
        {
            // The _body will be set within a layout page because PageContext.BodyAction was set by RenderSurrounding, 
            // which is only called in the case of rendering layout pages.
            // Using RenderPage will not result in a _body being set in a partial page, thus the following checks for
            // sections should not apply when RenderPage is called.
            // Dev10 bug 928341 
            if (_body != null)
            {
                if (SectionWritersStack.Count > 1 && PreviousSectionWriters != null && PreviousSectionWriters.Count > 0)
                {
                    // There are sections defined. Check that all sections have been rendered.
                    StringBuilder sectionsNotRendered = new StringBuilder();
                    foreach (var name in PreviousSectionWriters.Keys)
                    {
                        if (!_renderedSections.Contains(name))
                        {
                            if (sectionsNotRendered.Length > 0)
                            {
                                sectionsNotRendered.Append("; ");
                            }
                            sectionsNotRendered.Append(name);
                        }
                    }
                    if (sectionsNotRendered.Length > 0)
                    {
                        throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_SectionsNotRendered, VirtualPath, sectionsNotRendered.ToString()));
                    }
                }
                else if (!_renderedBody)
                {
                    // There are no sections defined, but RenderBody was NOT called.
                    // If a body was defined, then RenderBody should have been called.
                    throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_RenderBodyNotCalled, VirtualPath));
                }
            }
        }

        public override void Write(HelperResult result)
        {
            WriteTo(Output, result);
        }

        public override void Write(object value)
        {
            WriteTo(Output, value);
        }

        public override void WriteLiteral(object value)
        {
            Output.Write(value);
        }

        protected internal override TextWriter GetOutputWriter()
        {
            return Output;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Web.WebPages.Html;

namespace System.Web.WebPages
{
    // Class for containing various pieces of data required by a WebPage
    public class WebPageContext
    {
        private static readonly object _sourceFileKey = new object();
        private Stack<TextWriter> _outputStack;
        private Stack<Dictionary<string, SectionWriter>> _sectionWritersStack;
        private IDictionary<object, dynamic> _pageData;
        private ValidationHelper _validation;
        private ModelStateDictionary _modelStateDictionary;

        public WebPageContext()
            : this(context: null, page: null, model: null)
        {
        }

        public WebPageContext(HttpContextBase context, WebPageRenderingBase page, object model)
        {
            HttpContext = context;
            Page = page;
            Model = model;
        }

        public static WebPageContext Current
        {
            get
            {
                // The TemplateStack stores instances of WebPageRenderingBase. 
                // Retrieve the top-most item from the stack and cast it to WebPageBase. 
                var httpContext = Web.HttpContext.Current;
                if (httpContext != null)
                {
                    var contextWrapper = new HttpContextWrapper(httpContext);
                    var currentTemplate = TemplateStack.GetCurrentTemplate(contextWrapper);
                    var currentPage = (currentTemplate as WebPageRenderingBase);

                    return (currentPage == null) ? null : currentPage.PageContext;
                }
                return null;
            }
        }

        internal HttpContextBase HttpContext { get; set; }

        public object Model { get; internal set; }

        internal ModelStateDictionary ModelState
        {
            get
            {
                if (_modelStateDictionary == null)
                {
                    _modelStateDictionary = new ModelStateDictionary();
                }
                return _modelStateDictionary;
            }
            private set { _modelStateDictionary = value; }
        }

        internal ValidationHelper Validation
        {
            get
            {
                if (_validation == null)
                {
                    Debug.Assert(HttpContext != null, "HttpContext must be initalized for Validation to work.");
                    _validation = new ValidationHelper(HttpContext, ModelState);
                }
                return _validation;
            }
            private set { _validation = value; }
        }

        internal Action<TextWriter> BodyAction { get; set; }

        internal Stack<TextWriter> OutputStack
        {
            get
            {
                if (_outputStack == null)
                {
                    _outputStack = new Stack<TextWriter>();
                }
                return _outputStack;
            }
            set { _outputStack = value; }
        }

        public WebPageRenderingBase Page { get; internal set; }

        public IDictionary<object, dynamic> PageData
        {
            get
            {
                if (_pageData == null)
                {
                    _pageData = new PageDataDictionary<dynamic>();
                }
                return _pageData;
            }
            internal set { _pageData = value; }
        }

        internal Stack<Dictionary<string, SectionWriter>> SectionWritersStack
        {
            get
            {
                if (_sectionWritersStack == null)
                {
                    _sectionWritersStack = new Stack<Dictionary<string, SectionWriter>>();
                }
                return _sectionWritersStack;
            }
            set { _sectionWritersStack = value; }
        }

        // NOTE: We use a hashset because order doesn't matter and we want to eliminate duplicates
        internal HashSet<string> SourceFiles
        {
            get
            {
                HashSet<string> sourceFiles = HttpContext.Items[_sourceFileKey] as HashSet<string>;
                if (sourceFiles == null)
                {
                    sourceFiles = new HashSet<string>();
                    HttpContext.Items[_sourceFileKey] = sourceFiles;
                }
                return sourceFiles;
            }
        }

        internal static WebPageContext CreateNestedPageContext<TModel>(WebPageContext parentContext, IDictionary<object, dynamic> pageData, TModel model, bool isLayoutPage)
        {
            var nestedContext = new WebPageContext
            {
                HttpContext = parentContext.HttpContext,
                OutputStack = parentContext.OutputStack,
                Validation = parentContext.Validation,
                PageData = pageData,
                Model = model,
                ModelState = parentContext.ModelState,
            };

            if (isLayoutPage)
            {
                nestedContext.BodyAction = parentContext.BodyAction;
                nestedContext.SectionWritersStack = parentContext.SectionWritersStack;
            }
            return nestedContext;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageExecutingBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Web.WebPages.Instrumentation;
using System.Web.WebPages.Resources;

/*
WebPage class hierarchy

WebPageExecutingBase                        The base class for all Plan9 files (_pagestart, _appstart, and regular pages)
    ApplicationStartPage                    Used for _appstart.cshtml
    WebPageRenderingBase
        StartPage                           Used for _pagestart.cshtml
        WebPageBase
            WebPage                         Plan9Pages
            ViewWebPage?                    MVC Views
HelperPage                                  Base class for Web Pages in App_Code.
*/

namespace System.Web.WebPages
{
    // The base class for all CSHTML files (_pagestart, _appstart, and regular pages)
    public abstract class WebPageExecutingBase
    {
        private IVirtualPathFactory _virtualPathFactory;
        private DynamicHttpApplicationState _dynamicAppState;
        private InstrumentationService _instrumentationService = null;

        internal InstrumentationService InstrumentationService
        {
            get
            {
                if (_instrumentationService == null)
                {
                    _instrumentationService = new InstrumentationService();
                }
                return _instrumentationService;
            }
            set { _instrumentationService = value; }
        }

        public virtual HttpApplicationStateBase AppState
        {
            get
            {
                if (Context != null)
                {
                    return Context.Application;
                }
                return null;
            }
        }

        public virtual dynamic App
        {
            get
            {
                if (_dynamicAppState == null && AppState != null)
                {
                    _dynamicAppState = new DynamicHttpApplicationState(AppState);
                }
                return _dynamicAppState;
            }
        }

        public virtual HttpContextBase Context { get; set; }

        public virtual string VirtualPath { get; set; }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public virtual IVirtualPathFactory VirtualPathFactory
        {
            get { return _virtualPathFactory ?? VirtualPathFactoryManager.Instance; }
            set { _virtualPathFactory = value; }
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public abstract void Execute();

        public virtual string Href(string path, params object[] pathParts)
        {
            return UrlUtil.GenerateClientUrl(Context, VirtualPath, path, pathParts);
        }

        protected internal void BeginContext(int startPosition, int length, bool isLiteral)
        {
            BeginContext(GetOutputWriter(), VirtualPath, startPosition, length, isLiteral);
        }

        protected internal void BeginContext(string virtualPath, int startPosition, int length, bool isLiteral)
        {
            BeginContext(GetOutputWriter(), virtualPath, startPosition, length, isLiteral);
        }

        protected internal void BeginContext(TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            BeginContext(writer, VirtualPath, startPosition, length, isLiteral);
        }

        protected internal void BeginContext(TextWriter writer, string virtualPath, int startPosition, int length, bool isLiteral)
        {
            // Double check that the instrumentation service is active because WriteAttribute always calls this
            if (InstrumentationService.IsAvailable)
            {
                InstrumentationService.BeginContext(Context,
                                                    virtualPath,
                                                    writer,
                                                    startPosition,
                                                    length,
                                                    isLiteral);
            }
        }

        protected internal void EndContext(int startPosition, int length, bool isLiteral)
        {
            EndContext(GetOutputWriter(), VirtualPath, startPosition, length, isLiteral);
        }

        protected internal void EndContext(string virtualPath, int startPosition, int length, bool isLiteral)
        {
            EndContext(GetOutputWriter(), virtualPath, startPosition, length, isLiteral);
        }

        protected internal void EndContext(TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            EndContext(writer, VirtualPath, startPosition, length, isLiteral);
        }

        protected internal void EndContext(TextWriter writer, string virtualPath, int startPosition, int length, bool isLiteral)
        {
            // Double check that the instrumentation service is active because WriteAttribute always calls this
            if (InstrumentationService.IsAvailable)
            {
                InstrumentationService.EndContext(Context,
                                                  virtualPath,
                                                  writer,
                                                  startPosition,
                                                  length,
                                                  isLiteral);
            }
        }

        internal virtual string GetDirectory(string virtualPath)
        {
            return VirtualPathUtility.GetDirectory(virtualPath);
        }

        /// <summary>
        /// Normalizes path relative to the current virtual path and throws if a file does not exist at the location.
        /// </summary>
        protected internal virtual string NormalizeLayoutPagePath(string layoutPagePath)
        {
            var virtualPath = NormalizePath(layoutPagePath);
            // Look for it as specified, either absolute, relative or same folder
            if (VirtualPathFactory.Exists(virtualPath))
            {
                return virtualPath;
            }
            throw new HttpException(String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_LayoutPageNotFound, layoutPagePath, virtualPath));
        }

        public virtual string NormalizePath(string path)
        {
            // If it's relative, resolve it
            return VirtualPathUtility.Combine(VirtualPath, path);
        }

        public abstract void Write(HelperResult result);

        public abstract void Write(object value);

        public abstract void WriteLiteral(object value);

        public virtual void WriteAttribute(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values)
        {
            WriteAttributeTo(GetOutputWriter(), name, prefix, suffix, values);
        }

        public virtual void WriteAttributeTo(TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values)
        {
            WriteAttributeTo(VirtualPath, writer, name, prefix, suffix, values);
        }

        protected internal virtual void WriteAttributeTo(string pageVirtualPath, TextWriter writer, string name, PositionTagged<string> prefix, PositionTagged<string> suffix, params AttributeValue[] values)
        {
            bool first = true;
            bool wroteSomething = false;
            if (values.Length == 0)
            {
                // Explicitly empty attribute, so write the prefix and suffix
                WritePositionTaggedLiteral(writer, pageVirtualPath, prefix);
                WritePositionTaggedLiteral(writer, pageVirtualPath, suffix);
            }
            else
            {
                for (int i = 0; i < values.Length; i++)
                {
                    AttributeValue attrVal = values[i];
                    PositionTagged<object> val = attrVal.Value;
                    PositionTagged<string> next = i == values.Length - 1 ?
                        suffix : // End of the list, grab the suffix
                        values[i + 1].Prefix; // Still in the list, grab the next prefix

                    if (val.Value == null)
                    {
                        // Nothing to write
                        continue;
                    }

                    // The special cases here are that the value we're writing might already be a string, or that the 
                    // value might be a bool. If the value is the bool 'true' we want to write the attribute name instead
                    // of the string 'true'. If the value is the bool 'false' we don't want to write anything.
                    //
                    // Otherwise the value is another object (perhaps an IHtmlString), and we'll ask it to format itself.
                    string stringValue;

                    // Intentionally using is+cast here for performance reasons. This is more performant than as+bool? 
                    // because of boxing.
                    if (val.Value is bool)
                    {
                        if ((bool)val.Value)
                        {
                            stringValue = name;
                        }
                        else
                        {
                            continue;
                        }
                    }
                    else
                    {
                        stringValue = val.Value as string;
                    }

                    if (first)
                    {
                        WritePositionTaggedLiteral(writer, pageVirtualPath, prefix);
                        first = false;
                    }
                    else
                    {
                        WritePositionTaggedLiteral(writer, pageVirtualPath, attrVal.Prefix);
                    }

                    // Calculate length of the source span by the position of the next value (or suffix)
                    int sourceLength = next.Position - attrVal.Value.Position;

                    BeginContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal);

                    // The extra branching here is to ensure that we call the Write*To(string) overload when
                    // possible.
                    if (attrVal.Literal && stringValue != null)
                    {
                        WriteLiteralTo(writer, stringValue);
                    }
                    else if (attrVal.Literal)
                    {
                        WriteLiteralTo(writer, val.Value);
                    }
                    else if (stringValue != null)
                    {
                        WriteTo(writer, stringValue);
                    }
                    else
                    {
                        WriteTo(writer, val.Value);
                    }

                    EndContext(writer, pageVirtualPath, attrVal.Value.Position, sourceLength, isLiteral: attrVal.Literal);
                    wroteSomething = true;
                }
                if (wroteSomething)
                {
                    WritePositionTaggedLiteral(writer, pageVirtualPath, suffix);
                }
            }
        }

        private void WritePositionTaggedLiteral(TextWriter writer, string pageVirtualPath, string value, int position)
        {
            BeginContext(writer, pageVirtualPath, position, value.Length, isLiteral: true);
            WriteLiteralTo(writer, value);
            EndContext(writer, pageVirtualPath, position, value.Length, isLiteral: true);
        }

        private void WritePositionTaggedLiteral(TextWriter writer, string pageVirtualPath, PositionTagged<string> value)
        {
            WritePositionTaggedLiteral(writer, pageVirtualPath, value.Value, value.Position);
        }

        // This method is called by generated code and needs to stay in sync with the parser
        public static void WriteTo(TextWriter writer, HelperResult content)
        {
            if (content != null)
            {
                content.WriteTo(writer);
            }
        }

        // This method is called by generated code and needs to stay in sync with the parser
        public static void WriteTo(TextWriter writer, object content)
        {
            writer.Write(HttpUtility.HtmlEncode(content));
        }

        // Perf optimization to avoid calling string.ToString when we already know the type is a string.
        private static void WriteTo(TextWriter writer, string content)
        {
            writer.Write(HttpUtility.HtmlEncode(content));
        }

        // This method is called by generated code and needs to stay in sync with the parser
        public static void WriteLiteralTo(TextWriter writer, object content)
        {
            writer.Write(content);
        }

        // Perf optimization to avoid calling string.ToString when we already know the type is a string.
        private static void WriteLiteralTo(TextWriter writer, string content)
        {
            writer.Write(content);
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "A method is more appropriate in this case since a property likely already exists to hold this value")]
        protected internal virtual TextWriter GetOutputWriter()
        {
            return TextWriter.Null;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageHttpHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Reflection;
using System.Security;
using System.Text;
using System.Web.SessionState;
using Microsoft.Web.Infrastructure.DynamicValidationHelper;

namespace System.Web.WebPages
{
    public class WebPageHttpHandler : IHttpHandler, IRequiresSessionState
    {
        internal const string StartPageFileName = "_PageStart";
        public static readonly string WebPagesVersionHeaderName = "X-AspNetWebPages-Version";
        private static string[] _supportedExtensions = Empty<string>.Array;
        internal static readonly string WebPagesVersion = GetVersionString();
        private readonly WebPage _webPage;
        private readonly Lazy<WebPageRenderingBase> _startPage;

        public WebPageHttpHandler(WebPage webPage)
            : this(webPage, new Lazy<WebPageRenderingBase>(() => System.Web.WebPages.StartPage.GetStartPage(webPage, StartPageFileName, GetRegisteredExtensions())))
        {
        }

        internal WebPageHttpHandler(WebPage webPage, Lazy<WebPageRenderingBase> startPage)
        {
            if (webPage == null)
            {
                throw new ArgumentNullException("webPage");
            }
            _webPage = webPage;
            _startPage = startPage;
        }

        public static bool DisableWebPagesResponseHeader { get; set; }

        public virtual bool IsReusable
        {
            get { return false; }
        }

        internal WebPage RequestedPage
        {
            get { return _webPage; }
        }

        internal WebPageRenderingBase StartPage
        {
            get { return _startPage.Value; }
        }

        internal static string[] SupportedExtensions
        {
            get { return _supportedExtensions; }
        }

        internal static void AddVersionHeader(HttpContextBase httpContext)
        {
            if (!DisableWebPagesResponseHeader)
            {
                httpContext.Response.AppendHeader(WebPagesVersionHeaderName, WebPagesVersion);
            }
        }

        public static IHttpHandler CreateFromVirtualPath(string virtualPath)
        {
            return CreateFromVirtualPath(virtualPath, VirtualPathFactoryManager.Instance);
        }

        internal static IHttpHandler CreateFromVirtualPath(string virtualPath, IVirtualPathFactory virtualPathFactory)
        {
            // We will try to create a WebPage from our factory. If this fails, we assume that the virtual path maps to an IHttpHandler.
            // Instantiate the page from the virtual path
            WebPage page = virtualPathFactory.CreateInstance<WebPage>(virtualPath);

            // If it's not a page, assume it's a regular handler
            if (page == null)
            {
                return virtualPathFactory.CreateInstance<IHttpHandler>(virtualPath);
            }

            // Mark it as a 'top level' page (as opposed to a user control or master)
            page.TopLevelPage = true;

            // Give it its virtual path
            page.VirtualPath = virtualPath;

            // Assign it the object factory
            page.VirtualPathFactory = virtualPathFactory;

            // Return a handler over it
            return new WebPageHttpHandler(page);
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "We don't want a property")]
        public static ReadOnlyCollection<string> GetRegisteredExtensions()
        {
            return new ReadOnlyCollection<string>(_supportedExtensions);
        }

        private static string GetVersionString()
        {
            // DevDiv 216459:
            // This code originally used Assembly.GetName(), but that requires FileIOPermission, which isn't granted in
            // medium trust. However, Assembly.FullName *is* accessible in medium trust.
            return new AssemblyName(typeof(WebPageHttpHandler).Assembly.FullName).Version.ToString(2);
        }

        private static bool HandleError(Exception e)
        {
            // This method is similar to System.Web.UI.Page.HandleError

            // Don't touch security exception
            if (e is SecurityException)
            {
                return false;
            }

            throw new HttpUnhandledException(null, e);
        }

        internal static void GenerateSourceFilesHeader(WebPageContext context)
        {
            if (context.SourceFiles.Any())
            {
                var files = String.Join("|", context.SourceFiles);
                // Since the characters in the value are files that may include characters outside of the ASCII set, header encoding as specified in RFC2047. 
                // =?<charset>?<encoding>?...?= 
                // In the following case, UTF8 is used with base64 encoding 
                var encodedText = "=?UTF-8?B?" + Convert.ToBase64String(Encoding.UTF8.GetBytes(files)) + "?=";
                context.HttpContext.Response.AddHeader("X-SourceFiles", encodedText);
            }
        }

        public virtual void ProcessRequest(HttpContext context)
        {
            ProcessRequestInternal(context);
        }

        internal void ProcessRequestInternal(HttpContext context)
        {
            // enable dynamic validation for this request
            ValidationUtility.EnableDynamicValidation(context);
            context.Request.ValidateInput();

            HttpContextBase contextBase = new HttpContextWrapper(context);
            ProcessRequestInternal(contextBase);
        }

        internal void ProcessRequestInternal(HttpContextBase httpContext)
        {
            try
            {
                //WebSecurity.Context = contextBase;
                AddVersionHeader(httpContext);

                // This is also the point where a Plan9 request truly begins execution

                // We call ExecutePageHierarchy on the requested page, passing in the possible initPage, so that
                // the requested page can take care of the necessary push/pop context and trigger the call to
                // the initPage.
                _webPage.ExecutePageHierarchy(new WebPageContext { HttpContext = httpContext }, httpContext.Response.Output, StartPage);

                if (ShouldGenerateSourceHeader(httpContext))
                {
                    GenerateSourceFilesHeader(_webPage.PageContext);
                }
            }
            catch (Exception e)
            {
                if (!HandleError(e))
                {
                    throw;
                }
            }
        }

        public static void RegisterExtension(string extension)
        {
            // Note: we don't lock or check for duplicates because we only expect this method to be called during PreAppStart
            // Long lived data with few writes and many reads, so reallocate the array each time.
            _supportedExtensions = _supportedExtensions.AppendAndReallocate(extension);
        }

        internal static bool ShouldGenerateSourceHeader(HttpContextBase context)
        {
            return context.Request.IsLocal;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageHttpModule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    internal class WebPageHttpModule : IHttpModule
    {
        internal static EventHandler Initialize;
        internal static EventHandler ApplicationStart;
        internal static EventHandler BeginRequest;
        internal static EventHandler EndRequest;
        private static bool _appStartExecuted = false;
        private static readonly object _appStartExecutedLock = new object();
        private static readonly object _hasBeenRegisteredKey = new object();

        internal static bool AppStartExecuteCompleted { get; set; }

        public void Dispose()
        {
        }

        public void Init(HttpApplication application)
        {
            if (application.Context.Items[_hasBeenRegisteredKey] != null)
            {
                // registration for this module has already run for this HttpApplication instance
                return;
            }

            application.Context.Items[_hasBeenRegisteredKey] = true;

            InitApplication(application);
        }

        internal static void InitApplication(HttpApplication application)
        {
            // We need to run StartApplication first, so that any exception thrown during execution of the StartPage gets
            // recorded on StartPage.Exception
            StartApplication(application);
            InitializeApplication(application);
        }

        internal static void InitializeApplication(HttpApplication application)
        {
            InitializeApplication(application, OnApplicationPostResolveRequestCache, Initialize);
        }

        internal static void InitializeApplication(HttpApplication application, EventHandler onApplicationPostResolveRequestCache, EventHandler initialize)
        {
            if (initialize != null)
            {
                initialize(application, EventArgs.Empty);
            }
            application.PostResolveRequestCache += onApplicationPostResolveRequestCache;
            if (ApplicationStartPage.Exception != null || BeginRequest != null)
            {
                application.BeginRequest += OnBeginRequest;
            }

            application.EndRequest += OnEndRequest;
        }

        internal static void StartApplication(HttpApplication application)
        {
            StartApplication(application, ApplicationStartPage.ExecuteStartPage, ApplicationStart);
        }

        internal static void StartApplication(HttpApplication application, Action<HttpApplication> executeStartPage, EventHandler applicationStart)
        {
            // Application start events should happen only once per application life time.
            lock (_appStartExecutedLock)
            {
                if (!_appStartExecuted)
                {
                    _appStartExecuted = true;

                    executeStartPage(application);
                    AppStartExecuteCompleted = true;
                    if (applicationStart != null)
                    {
                        applicationStart(application, EventArgs.Empty);
                    }
                }
            }
        }

        internal static void OnApplicationPostResolveRequestCache(object sender, EventArgs e)
        {
            HttpContextBase context = new HttpContextWrapper(((HttpApplication)sender).Context);
            new WebPageRoute().DoPostResolveRequestCache(context);
        }

        internal static void OnBeginRequest(object sender, EventArgs e)
        {
            if (ApplicationStartPage.Exception != null)
            {
                // Throw it as a HttpException so as to
                // display the original stack trace information.
                throw new HttpException(null, ApplicationStartPage.Exception);
            }
            if (BeginRequest != null)
            {
                BeginRequest(sender, e);
            }
        }

        internal static void OnEndRequest(object sender, EventArgs e)
        {
            if (EndRequest != null)
            {
                EndRequest(sender, e);
            }

            var app = (HttpApplication)sender;
            RequestResourceTracker.DisposeResources(new HttpContextWrapper(app.Context));
        }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageMatch.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages
{
    internal sealed class WebPageMatch
    {
        public WebPageMatch(string matchedPath, string pathInfo)
        {
            MatchedPath = matchedPath;
            PathInfo = pathInfo;
        }

        public string MatchedPath { get; private set; }

        public string PathInfo { get; private set; }
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageRenderingBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Security.Principal;
using System.Threading;
using System.Web.Caching;
using System.Web.Profile;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages
{
    public abstract class WebPageRenderingBase : WebPageExecutingBase, ITemplateFile
    {
        private IPrincipal _user;
        private UrlDataList _urlData;
        private TemplateFileInfo _templateFileInfo;
        private DisplayModeProvider _displayModeProvider;

        public virtual Cache Cache
        {
            get
            {
                if (Context != null)
                {
                    return Context.Cache;
                }
                return null;
            }
        }

        internal DisplayModeProvider DisplayModeProvider
        {
            get { return _displayModeProvider ?? DisplayModeProvider.Instance; }

            set { _displayModeProvider = value; }
        }

        protected internal IDisplayMode DisplayMode
        {
            get { return DisplayModeProvider.GetDisplayMode(Context); }
        }

        public abstract string Layout { get; set; }

        public abstract IDictionary<object, dynamic> PageData { get; }

        public abstract dynamic Page { get; }

        public WebPageContext PageContext { get; internal set; }

        public ProfileBase Profile
        {
            get
            {
                if (Context != null)
                {
                    return Context.Profile;
                }
                return null;
            }
        }

        public virtual HttpRequestBase Request
        {
            get
            {
                if (Context != null)
                {
                    return Context.Request;
                }
                return null;
            }
        }

        public virtual HttpResponseBase Response
        {
            get
            {
                if (Context != null)
                {
                    return Context.Response;
                }
                return null;
            }
        }

        public virtual HttpServerUtilityBase Server
        {
            get
            {
                if (Context != null)
                {
                    return Context.Server;
                }
                return null;
            }
        }

        public virtual HttpSessionStateBase Session
        {
            get
            {
                if (Context != null)
                {
                    return Context.Session;
                }
                return null;
            }
        }

        public virtual IList<string> UrlData
        {
            get
            {
                if (_urlData == null)
                {
                    WebPageMatch match = WebPageRoute.GetWebPageMatch(Context);
                    if (match != null)
                    {
                        _urlData = new UrlDataList(match.PathInfo);
                    }
                    else
                    {
                        // REVIEW: Can there ever be no route match?
                        _urlData = new UrlDataList(null);
                    }
                }
                return _urlData;
            }
        }

        public virtual IPrincipal User
        {
            get
            {
                if (_user == null)
                {
                    return Context.User;
                }
                return _user;
            }
            internal set { _user = value; }
        }

        public virtual TemplateFileInfo TemplateInfo
        {
            get
            {
                if (_templateFileInfo == null)
                {
                    _templateFileInfo = new TemplateFileInfo(VirtualPath);
                }
                return _templateFileInfo;
            }
        }

        public virtual bool IsPost
        {
            get { return Request.HttpMethod == "POST"; }
        }

        public virtual bool IsAjax
        {
            get
            {
                var request = Request;
                if (request == null)
                {
                    return false;
                }
                return (request["X-Requested-With"] == "XMLHttpRequest") || ((request.Headers != null) && (request.Headers["X-Requested-With"] == "XMLHttpRequest"));
            }
        }

        public string Culture
        {
            get { return Thread.CurrentThread.CurrentCulture.Name; }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    // GetCultureInfo accepts empty strings but throws for null strings. To maintain consistency in our string handling behavior, throw
                    throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "value");
                }
                CultureUtil.SetCulture(Thread.CurrentThread, Context, value);
            }
        }

        public string UICulture
        {
            get { return Thread.CurrentThread.CurrentUICulture.Name; }
            set
            {
                if (String.IsNullOrEmpty(value))
                {
                    // GetCultureInfo accepts empty strings but throws for null strings. To maintain consistency in our string handling behavior, throw
                    throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "value");
                }
                CultureUtil.SetUICulture(Thread.CurrentThread, Context, value);
            }
        }

        // Calls the Execute() method, and calls RunPage() if the page is an InitPage but
        // did not call RunPage().
        public abstract void ExecutePageHierarchy();

        public abstract HelperResult RenderPage(string path, params object[] data);
    }
}


================================================
FILE: src/System.Web.WebPages/WebPageRoute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Web.WebPages.Deployment;
using System.Web.WebPages.Resources;

namespace System.Web.WebPages
{
    internal sealed class WebPageRoute
    {
        private static readonly Lazy<bool> _isRootExplicitlyDisabled = new Lazy<bool>(() => WebPagesDeployment.IsExplicitlyDisabled("~/"));
        private bool? _isExplicitlyDisabled;

        internal bool IsExplicitlyDisabled
        {
            get { return _isExplicitlyDisabled ?? _isRootExplicitlyDisabled.Value; }
            set { _isExplicitlyDisabled = value; }
        }

        internal void DoPostResolveRequestCache(HttpContextBase context)
        {
            if (IsExplicitlyDisabled)
            {
                // If the root config is explicitly disabled, do not process the request.
                return;
            }

            // Parse incoming URL (we trim off the first two chars since they're always "~/")
            string requestPath = context.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + context.Request.PathInfo;
            string[] registeredExtensions = WebPageHttpHandler.SupportedExtensions;

            // Check if this request matches a file in the app
            WebPageMatch webpageRouteMatch = MatchRequest(requestPath, registeredExtensions, VirtualPathFactoryManager.InstancePathExists, context, DisplayModeProvider.Instance);
            if (webpageRouteMatch != null)
            {
                // If it matches then save some data for the WebPage's UrlData
                context.Items[typeof(WebPageMatch)] = webpageRouteMatch;

                string virtualPath = "~/" + webpageRouteMatch.MatchedPath;

                // Verify that this path is enabled before remapping
                if (!WebPagesDeployment.IsExplicitlyDisabled(virtualPath))
                {
                    IHttpHandler handler = WebPageHttpHandler.CreateFromVirtualPath(virtualPath);
                    if (handler != null)
                    {
                        SessionStateUtil.SetUpSessionState(context, handler);
                        // Remap to our handler
                        context.RemapHandler(handler);
                    }
                }
            }
            else
            {
                // Bug:904704 If its not a match, but to a supported extension, we want to return a 404 instead of a 403
                string extension = PathUtil.GetExtension(requestPath);
                foreach (string supportedExt in registeredExtensions)
                {
                    if (String.Equals("." + supportedExt, extension, StringComparison.OrdinalIgnoreCase))
                    {
                        throw new HttpException(404, null);
                    }
                }
            }
        }

        private static bool FileExists(string virtualPath, Func<string, bool> virtualPathExists)
        {
            var path = "~/" + virtualPath;
            return virtualPathExists(path);
        }

        internal static WebPageMatch GetWebPageMatch(HttpContextBase context)
        {
            WebPageMatch webPageMatch = (WebPageMatch)context.Items[typeof(WebPageMatch)];
            return webPageMatch;
        }

        private static string GetRouteLevelMatch(string pathValue, string[] supportedExtensions, Func<string, bool> virtualPathExists, HttpContextBase context, DisplayModeProvider displayModeProvider)
        {
            for (int i = 0; i < supportedExtensions.Length; i++)
            {
                string supportedExtension = supportedExtensions[i];

                // For performance, avoid multiple calls to String.Concat
                string virtualPath;
                // Only add the extension if it's not already there
                if (!PathHelpers.EndsWithExtension(pathValue, supportedExtension))
                {
                    virtualPath = "~/" + pathValue + "." + supportedExtension;
                }
                else
                {
                    virtualPath = "~/" + pathValue;
                }
                DisplayInfo virtualPathDisplayInfo = displayModeProvider.GetDisplayInfoForVirtualPath(virtualPath, context, virtualPathExists, currentDisplayMode: null);

                if (virtualPathDisplayInfo != null)
                {
                    // If there's an exact match on disk, return it unless it starts with an underscore
                    if (Path.GetFileName(virtualPathDisplayInfo.FilePath).StartsWith("_", StringComparison.OrdinalIgnoreCase))
                    {
                        throw new HttpException(404, WebPageResources.WebPageRoute_UnderscoreBlocked);
                    }

                    string resolvedVirtualPath = virtualPathDisplayInfo.FilePath;

                    // Matches are not expected to be virtual paths so remove the ~/ from the match
                    if (resolvedVirtualPath.StartsWith("~/", StringComparison.OrdinalIgnoreCase))
                    {
                        resolvedVirtualPath = resolvedVirtualPath.Remove(0, 2);
                    }

                    DisplayModeProvider.SetDisplayMode(context, virtualPathDisplayInfo.DisplayMode);

                    return resolvedVirtualPath;
                }
            }

            return null;
        }

        internal static WebPageMatch MatchRequest(string pathValue, string[] supportedExtensions, Func<string, bool> virtualPathExists, HttpContextBase context, DisplayModeProvider displayModes)
        {
            string currentLevel = String.Empty;
            string currentPathInfo = pathValue;

            // We can skip the file exists check and normal lookup for empty paths, but we still need to look for default pages
            if (!String.IsNullOrEmpty(pathValue))
            {
                // If the file exists and its not a supported extension, let the request go through
                if (FileExists(pathValue, virtualPathExists))
                {
                    // TODO: Look into switching to RawURL to eliminate the need for this issue
                    bool foundSupportedExtension = false;
                    for (int i = 0; i < supportedExtensions.Length; i++)
                    {
                        string supportedExtension = supportedExtensions[i];
                        if (PathHelpers.EndsWithExtension(pathValue, supportedExtension))
                        {
                            foundSupportedExtension = true;
                            break;
                        }
                    }

                    if (!foundSupportedExtension)
                    {
                        return null;
                    }
                }

                // For each trimmed part of the path try to add a known extension and
                // check if it matches a file in the application.
                currentLevel = pathValue;
                currentPathInfo = String.Empty;
                while (true)
                {
                    // Does the current route level patch any supported extension?
                    string routeLevelMatch = GetRouteLevelMatch(currentLevel, supportedExtensions, virtualPathExists, context, displayModes);
                    if (routeLevelMatch != null)
                    {
                        return new WebPageMatch(routeLevelMatch, currentPathInfo);
                    }

                    // Try to remove the last path segment (e.g. go from /foo/bar to /foo)
                    int indexOfLastSlash = currentLevel.LastIndexOf('/');
                    if (indexOfLastSlash == -1)
                    {
                        // If there are no more slashes, we're done
                        break;
                    }
                    else
                    {
                        // Chop off the last path segment to get to the next one
                        currentLevel = currentLevel.Substring(0, indexOfLastSlash);

                        // And save the path info in case there is a match
                        currentPathInfo = pathValue.Substring(indexOfLastSlash + 1);
                    }
                }
            }

            return MatchDefaultFiles(pathValue, supportedExtensions, virtualPathExists, context, displayModes, currentLevel);
        }

        private static WebPageMatch MatchDefaultFiles(string pathValue, string[] supportedExtensions, Func<string, bool> virtualPathExists, HttpContextBase context, DisplayModeProvider displayModes, string currentLevel)
        {
            // If we haven't found anything yet, now try looking for default.* or index.* at the current url
            currentLevel = pathValue;
            string currentLevelDefault;
            string currentLevelIndex;
            if (String.IsNullOrEmpty(currentLevel))
            {
                currentLevelDefault = "default";
                currentLevelIndex = "index";
            }
            else
            {
                if (currentLevel[currentLevel.Length - 1] != '/')
                {
                    currentLevel += "/";
                }
                currentLevelDefault = currentLevel + "default";
                currentLevelIndex = currentLevel + "index";
            }

            // Does the current route level match any supported extension?
            string defaultMatch = GetRouteLevelMatch(currentLevelDefault, supportedExtensions, virtualPathExists, context, displayModes);
            if (defaultMatch != null)
            {
                return new WebPageMatch(defaultMatch, String.Empty);
            }

            string indexMatch = GetRouteLevelMatch(currentLevelIndex, supportedExtensions, virtualPathExists, context, displayModes);
            if (indexMatch != null)
            {
                return new WebPageMatch(indexMatch, String.Empty);
            }

            return null;
        }
    }
}


================================================
FILE: src/System.Web.WebPages/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.WebPages.Administration/Default.cshtml
================================================
@* Generator: WebPage *@

@using System.Web.WebPages.Administration.PackageManager;
@{    
    Page.Title = AdminResources.Modules;
    var adminModules = from p in SiteAdmin.Modules
                       where !p.StartPageVirtualPath.Equals(SiteAdmin.AdminVirtualPath, StringComparison.OrdinalIgnoreCase)
                       orderby p.DisplayName
                       select p;
}

@if (!adminModules.Any() && !PackageManagerModule.Available) {
    <h3>@AdminResources.NoAdminModulesInstalled</h3>
}
else if (PackageManagerModule.Available && !adminModules.Any()) {
    // If no other module is available, take the user directly to the package manager
    Response.Redirect(Href("packages"));
    return;
}
else {
    <ul class="modules">
    @if (PackageManagerModule.Available) {
        <li>    
            <a href="@Href("packages")" title="@PackageManagerModule.ModuleName"><strong>@PackageManagerModule.ModuleName</strong></a>
            <div class="description">@PackageManagerModule.ModuleDescription</div>
        </li>
    }
    @if (adminModules.Any()) {
        foreach (var module in adminModules) {
            <li>
                <a href="@Href(module.StartPageVirtualPath)"><strong>@module.DisplayName</strong></a>
                <div class="description">
                    @module.Description
                </div>
            </li>
        }
    }
    </ul>
}

================================================
FILE: src/System.Web.WebPages.Administration/EnableInstructions.cshtml
================================================
@* Generator: WebPage *@

@using System.Globalization;

@{
    Page.Title = AdminResources.SecurityTitle;

    if(AdminSecurity.HasAdminPassword()) {
        SiteAdmin.RedirectToHome(Response);
        return;
    }

    string url = SiteAdmin.GetRedirectUrl(SiteAdmin.AdminVirtualPath);
}   

@Html.Raw(AdminResources.EnableInstructions)
<br />
<p>
    @Html.Raw(String.Format(CultureInfo.CurrentCulture, AdminResources.ContinueAfterEnableText, Html.Encode(Href(url))))
</p>



================================================
FILE: src/System.Web.WebPages.Administration/Framework/AdminSecurity.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Web.Helpers;
using System.Web.Hosting;
using System.Web.Security;

namespace System.Web.WebPages.Administration
{
    internal static class AdminSecurity
    {
        private const string AuthCookieName = ".ASPXADMINAUTH";
        private const string AdminUserNameToken = "ADMIN";

        // Bug941370: Renamed the file to .config to prevent IIS6 from serving this files.
        internal static readonly string AdminPasswordFile = VirtualPathUtility.Combine(SiteAdmin.AdminSettingsFolder, "Password.config");
        internal static readonly string TemporaryPasswordFile = VirtualPathUtility.Combine(SiteAdmin.AdminSettingsFolder, "_Password.config");

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We catch all exceptions to prevent any decryption failure results from being exposed.")]
        internal static bool IsAuthenticated(HttpRequestBase request)
        {
            HttpCookie authCookie = request.Cookies[AuthCookieName];

            // Not authenticated if there is no cookie
            if (authCookie == null)
            {
                return false;
            }

            try
            {
                return IsValidAuthCookie(authCookie);
            }
            catch
            {
                // If decryption fails, it may be a bad cookie
                return false;
            }
        }

        private static bool IsValidAuthCookie(HttpCookie authCookie)
        {
            // Decrypt the cookie and check the expired flag
            FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(authCookie.Value);

            // Ensure that the ticket hasn't expired and that the custom UserData string is our AdminUserNameToken
            return !ticket.Expired && ticket.UserData != null && ticket.UserData.Equals(AdminUserNameToken);
        }

        internal static void SetAuthCookie(HttpResponseBase response)
        {
            // Get an auth admin cookie
            HttpCookie cookie = GetAuthCookie();

            // Set the name to our auth cookie name
            cookie.Name = AuthCookieName;

            // Add it to the response
            response.Cookies.Add(cookie);
        }

        internal static HttpCookie GetAuthCookie()
        {
            // Create a new forms auth ticket for the admin section
            // Add the admin user name as user data so that we distinguish between a regular
            // ticket issued by ASP.NET's auth system versus our own            
            var ticket = new FormsAuthenticationTicket(2,
                                                       AdminUserNameToken,
                                                       DateTime.Now,
                                                       DateTime.Now.Add(FormsAuthentication.Timeout),
                                                       false,
                                                       AdminUserNameToken,
                                                       FormsAuthentication.FormsCookiePath);

            // Encrypt the ticket and create the cookie
            string encryptedValue = FormsAuthentication.Encrypt(ticket);
            var cookie = new HttpCookie(AuthCookieName, encryptedValue);
            cookie.HttpOnly = true;
            cookie.Path = ticket.CookiePath;

            return cookie;
        }

        internal static void DeleteAuthCookie(HttpResponseBase response)
        {
            // Expire the cookie
            var cookie = new HttpCookie(AuthCookieName);
            cookie.Expires = DateTime.Now.AddDays(-1);
            response.Cookies.Add(cookie);
        }

        internal static bool HasAdminPassword()
        {
            return HasAdminPassword(HostingEnvironment.VirtualPathProvider);
        }

        internal static bool HasAdminPassword(VirtualPathProvider vpp)
        {
            // REVIEW: Do we need to check for content as well?
            return vpp.FileExists(AdminPasswordFile);
        }

        internal static bool HasTemporaryPassword()
        {
            return HasTemporaryPassword(HostingEnvironment.VirtualPathProvider);
        }

        internal static bool HasTemporaryPassword(VirtualPathProvider vpp)
        {
            // REVIEW: Do we need to check for content as well?
            return vpp.FileExists(TemporaryPasswordFile);
        }

        internal static bool SaveTemporaryPassword(string password)
        {
            // When saving the admin password we store it in a dummy file so that we don't enable to the admin UI by default
            return SaveTemporaryPassword(password, GetTemporaryPasswordFileStream);
        }

        private static Stream GetTemporaryPasswordFileStream()
        {
            // Get the password directory and file name
            string passwordFilePath = HostingEnvironment.MapPath(TemporaryPasswordFile);
            string passwordFileDir = Path.GetDirectoryName(passwordFilePath);

            // Ensure password directory exists
            Directory.CreateDirectory(passwordFileDir);

            // Return the stream
            return File.OpenWrite(passwordFilePath);
        }

        internal static bool SaveTemporaryPassword(string password, Func<Stream> getPasswordFileStream)
        {
            Stream stream = null;
            try
            {
                // Get the password file stream
                stream = getPasswordFileStream();
            }
            catch (UnauthorizedAccessException)
            {
                // The user doesn't have write access to App_Data or the site root
                return false;
            }

            using (var writer = new StreamWriter(stream))
            {
                // Write the salty password
                writer.WriteLine(Crypto.HashPassword(password));
            }

            return true;
        }

        internal static bool CheckPassword(string password)
        {
            return CheckPassword(password, () =>
            {
                VirtualFile passwordFile = HostingEnvironment.VirtualPathProvider.GetFile(AdminPasswordFile);
                Debug.Assert(passwordFile != null, "password file should not be null");
                return passwordFile.Open();
            });
        }

        internal static bool CheckPassword(string password, Func<Stream> getPasswordFileStream)
        {
            string saltyPassword = null;

            Stream stream = getPasswordFileStream();
            using (StreamReader reader = new StreamReader(stream))
            {
                // Read the salted password
                saltyPassword = reader.ReadLine();
            }

            return Crypto.VerifyHashedPassword(saltyPassword, password);
        }

        /// <summary>
        /// Ensure that the current request is authorized. 
        /// If the request is authenticated, then we skip all other checks.
        /// </summary>
        internal static void Authorize(StartPage page)
        {
            Authorize(page, HostingEnvironment.VirtualPathProvider, VirtualPathUtility.ToAppRelative);
        }

        internal static void Authorize(StartPage page, VirtualPathProvider vpp, Func<string, string> makeAppRelative)
        {
            if (!IsAuthenticated(page.Request))
            {
                if (HasAdminPassword(vpp))
                {
                    // If there is a password file (Password.config) then we redirect to the login page
                    RedirectSafe(page, SiteAdmin.LoginVirtualPath, makeAppRelative);
                }
                else if (HasTemporaryPassword(vpp))
                {
                    // Dev 10 941521: Admin: Pass through returnurl into page that tells the user to rename _password.config
                    // If there is a disabled password file (_Password.config) then we redirect to the instructions page
                    RedirectSafe(page, SiteAdmin.EnableInstructionsVirtualPath, makeAppRelative);
                }
                else
                {
                    // The user hasn't done anything so redirect to the register page.
                    RedirectSafe(page, SiteAdmin.RegisterVirtualPath, makeAppRelative);
                }
            }
        }

        /// <summary>
        /// Doesn't do a redirect if the requesting page is itself the same as the virtual path.
        /// We need to do this since it is called from the _pagestart.cshtml which always runs.
        /// </summary>
        private static void RedirectSafe(StartPage page, string virtualPath, Func<string, string> makeAppRelative)
        {
            // Make sure we get the virtual path
            virtualPath = SiteAdmin.GetVirtualPath(virtualPath);

            if (!IsRequestingPage(page, virtualPath))
            {
                // Append the redirect url querystring
                virtualPath = SiteAdmin.GetRedirectUrl(page.Request, virtualPath, makeAppRelative);

                page.Context.Response.Redirect(virtualPath);
            }
        }

        /// <summary>
        /// Determines if the specified virtualPath is being requested. We do this by walking the page hierarchy
        /// and comparing the virtualPath with the child page's VirtualPath property (which in the case of ApplicationParts are compiled into the assembly
        /// using the PageVirtualPath attribute).
        /// </summary>
        internal static bool IsRequestingPage(this StartPage page, string virtualPath)
        {
            WebPageRenderingBase webPage = GetRootPage(page);

            return webPage.VirtualPath.Equals(virtualPath, StringComparison.OrdinalIgnoreCase);
        }

        /// <summary>
        /// Walks the page hierarcy to find the requested page.
        /// </summary>
        private static WebPageRenderingBase GetRootPage(StartPage page)
        {
            WebPageRenderingBase currentPage = null;
            while (page != null)
            {
                currentPage = page.ChildPage;
                page = currentPage as StartPage;
            }

            Debug.Assert(currentPage != null, "Should never be null");
            return currentPage;
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Administration/Framework/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;

namespace System.Web.WebPages.Administration
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        // NOTE: Do not add public fields, methods, or other members to this class.
        // This class does not show up in Intellisense so members on it will not be
        // discoverable by users. Place new members on more appropriate classes that
        // relate to the public API (for example, a LoginUrl property should go on a
        // membership-related class).

        private static bool _startWasCalled;

        public static void Start()
        {
            // Even though ASP.NET will only call each PreAppStart once, we sometimes internally call one PreAppStart from 
            // another PreAppStart to ensure that things get initialized in the right order. ASP.NET does not guarantee the 
            // order so we have to guard against multiple calls.
            // All Start calls are made on same thread, so no lock needed here.
            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            // Register the admin module
            SiteAdmin.RegisterAdminModule();
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Administration/Framework/SiteAdmin.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.Globalization;

namespace System.Web.WebPages.Administration
{
    public class SiteAdmin
    {
        internal const string DefaultAdminVirtualPath = "~/_Admin/";
        internal const string AdminSettingsFolder = "~/App_Data/Admin/";

        // Configuration settings
        private const string AdminVirtualPathAppSettingsKey = "asp:AdminFolderVirtualPath";
        private const string AdminEnabledAppSettingsKey = "asp:AdminManagerEnabled";

        private const string ReturnUrlQueryString = "ReturnUrl";

        // Virtual paths excluded from security. These urls are the same as the ones in the PageVirtulPath attribute.
        internal const string LoginVirtualPath = "~/Login.cshtml";
        internal const string LogoutVirtualPath = "~/Logout.cshtml";
        internal const string RegisterVirtualPath = "~/Register.cshtml";
        internal const string EnableInstructionsVirtualPath = "~/EnableInstructions.cshtml";

        private static ConcurrentDictionary<string, SiteAdmin> _adminModules = new ConcurrentDictionary<string, SiteAdmin>();

        // These only needs to be computed once per app domain
        private static readonly Lazy<bool?> _adminEnabled = new Lazy<bool?>(GetAdminEnabledSetting);
        private static readonly Lazy<string> _adminVirtualPath = new Lazy<string>(GetDefaultVirtualPath);

        private SiteAdmin(string startPageVirtualPath, string displayName, string description)
        {
            Debug.Assert(startPageVirtualPath != null, "startPageVirtualPath can't be null");
            Debug.Assert(displayName != null, "displayName can't be null");

            StartPageVirtualPath = startPageVirtualPath;
            DisplayName = displayName;
            Description = description;
        }

        public static string AdminVirtualPath
        {
            get { return _adminVirtualPath.Value; }
        }

        public string StartPageVirtualPath { get; private set; }

        public string DisplayName { get; private set; }

        public string Description { get; private set; }

        internal static bool Available
        {
            get
            {
                HttpContext context = HttpContext.Current;
                if (context != null && context.Request.IsLocal)
                {
                    // Check the configuration setting if there is any
                    if (_adminEnabled.Value != null)
                    {
                        return _adminEnabled.Value.Value;
                    }

                    // There was no setting so localhost is enough to verify availability
                    return true;
                }
                // If we're not on localhost then nothing is available
                return false;
            }
        }

        public static IEnumerable<SiteAdmin> Modules
        {
            get { return _adminModules.Values; }
        }

        internal static void RegisterAdminModule()
        {
            // Add a admin module as an application module (precompiled)
            ApplicationPart.Register(new ApplicationPart(typeof(SiteAdmin).Assembly, AdminVirtualPath));
        }

        private static bool? GetAdminEnabledSetting()
        {
            bool enabled;
            if (Boolean.TryParse(ConfigurationManager.AppSettings[AdminEnabledAppSettingsKey], out enabled))
            {
                return enabled;
            }

            return null;
        }

        public static string GetVirtualPath(string virtualPath)
        {
            if (virtualPath == null)
            {
                throw new ArgumentNullException("virtualPath");
            }

            // Don't add the virtual path more than once
            if (virtualPath.StartsWith(AdminVirtualPath, StringComparison.OrdinalIgnoreCase))
            {
                return virtualPath;
            }

            if (virtualPath.StartsWith("~/", StringComparison.OrdinalIgnoreCase))
            {
                virtualPath = virtualPath.Substring(2);
            }

            if (virtualPath.StartsWith("/", StringComparison.OrdinalIgnoreCase))
            {
                virtualPath = virtualPath.Substring(1);
            }
            return VirtualPathUtility.Combine(AdminVirtualPath, virtualPath);
        }

        public static void Register(string startPageVirtualPath, string displayName, string description)
        {
            if (startPageVirtualPath == null)
            {
                throw new ArgumentNullException("startPageVirtualPath");
            }

            if (displayName == null)
            {
                throw new ArgumentNullException("displayName");
            }

            // Get the virtual path relative to the admin virtual path
            string virtualPath = GetVirtualPath(startPageVirtualPath);

            // Register that under the admin root
            Register(new SiteAdmin(virtualPath, displayName, description));
        }

        private static string GetDefaultVirtualPath()
        {
            string virtualPath = ConfigurationManager.AppSettings[AdminVirtualPathAppSettingsKey];
            if (String.IsNullOrEmpty(virtualPath))
            {
                virtualPath = DefaultAdminVirtualPath;
            }

            if (!virtualPath.EndsWith("/", StringComparison.OrdinalIgnoreCase))
            {
                virtualPath += "/";
            }
            return virtualPath;
        }

        internal static void RedirectToLogin(HttpResponseBase response)
        {
            response.Redirect(GetVirtualPath(LoginVirtualPath));
        }

        internal static void RedirectToRegister(HttpResponseBase response)
        {
            response.Redirect(GetVirtualPath(RegisterVirtualPath));
        }

        internal static void RedirectToHome(HttpResponseBase response)
        {
            response.Redirect(AdminVirtualPath);
        }

        internal static void Register(SiteAdmin module)
        {
            if (_adminModules.ContainsKey(module.StartPageVirtualPath))
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  AdminResources.ModuleAlreadyRegistered, module.StartPageVirtualPath));
            }

            // Add to the list of registered modules
            _adminModules.TryAdd(module.StartPageVirtualPath, module);
        }

        internal static string GetReturnUrl(HttpRequestBase request)
        {
            // REVIEW: FormsAuthentication.GetReturlUrl also checks the form for the return url
            // do we need that?
            string returnUrl = request.QueryString[ReturnUrlQueryString];

            // If the return url query string doesn't exist or is empty
            // return the admin root virtual path
            if (String.IsNullOrEmpty(returnUrl))
            {
                return null;
            }

            // REVIEW: FormsAuthentication.GetReturnUrl checks if the url is dangerous
            // i.e it uses an internal helper in System.Web CrossSiteScriptingValidation.IsDangerousUrl.
            // Should we copy that behavior?

            if (!VirtualPathUtility.IsAppRelative(returnUrl))
            {
                // We only put app relative return urls in the query string (i.e starts with ~/)
                throw new InvalidOperationException(AdminResources.InvalidReturnUrl);
            }

            return returnUrl;
        }

        internal static string GetRedirectUrl(string redirectUrl)
        {
            var request = new HttpRequestWrapper(HttpContext.Current.Request);
            return GetRedirectUrl(request, redirectUrl, VirtualPathUtility.ToAppRelative);
        }

        internal static string GetRedirectUrl(HttpRequestBase request, string redirectUrl, Func<string, string> makeAppRelative)
        {
            // If there's already a return url then use it, otherwise the app relative url of the 
            // current request to redirect to after signing in
            string returnUrl = GetReturnUrl(request) ?? makeAppRelative(request.RawUrl);

            // Get the app relative path to the redirect url
            redirectUrl = GetVirtualPath(redirectUrl);

            // Get the current page with return url
            redirectUrl += "?" + ReturnUrlQueryString + "=" + HttpUtility.UrlEncode(returnUrl);

            return redirectUrl;
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Administration/Login.cshtml
================================================
@* Generator: WebPage *@

@using System.Globalization;
@{
    Page.Title = AdminResources.LoginTitle;

    // No admin password has been registered so redirect
    if(!AdminSecurity.HasAdminPassword()) {
        SiteAdmin.RedirectToRegister(Response);
        return;
    }

    if (IsPost) {
        AntiForgery.Validate();
        var password = Request.Form["password"];

        if (AdminSecurity.CheckPassword(password)) {
            // Get the return url
            var returnUrl = SiteAdmin.GetReturnUrl(Request) ?? SiteAdmin.AdminVirtualPath;

            // Set the admin auth cookie
            AdminSecurity.SetAuthCookie(Response);

            // Redirect to the return url
            Response.Redirect(returnUrl);
        }
        else {
            ModelState.AddError("password", AdminResources.Validation_PasswordIncorrect);
        }
    }
}

@section Head{
    <script type="text/javascript">
    function showForgotPasswordInfo(){
        document.getElementById('forgotPasswordInfo').style.display = '';
    }
    </script>
}

@Html.ValidationSummary()
<br />

<form method="post" action="">
    @AntiForgery.GetHtml()
    <fieldset>
    <ol>
        <li class="password">
            <label for="password">@AdminResources.Password:</label>
            @Html.Password("password") @Html.ValidationMessage("password", "*")
    </ol>
    <p class="form-actions">
        <input type="submit" value="@AdminResources.Login" />
    </p>
    </fieldset>
    <p>
        <a href="#" onclick="showForgotPasswordInfo(); return false;">@AdminResources.ForgotPassword</a>
    </p>
</form>
<br />
@{ 
    var passwordFileLocation = AdminSecurity.AdminPasswordFile.TrimStart('~', '/');
    var forgotPasswordHelp = String.Format(CultureInfo.CurrentCulture, AdminResources.AdminPasswordChangeInstructions, Html.Encode(passwordFileLocation));
}
<span id="forgotPasswordInfo" style="display: none">@Html.Raw(forgotPasswordHelp)</span>

================================================
FILE: src/System.Web.WebPages.Administration/Logout.cshtml
================================================
@* Generator: WebPage *@

@{    
    // Delete the admin auth cookie
    AdminSecurity.DeleteAuthCookie(Response);

    // Redirect home
    SiteAdmin.RedirectToHome(Response);
}


================================================
FILE: src/System.Web.WebPages.Administration/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using System.Web.WebPages.Administration;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("System.Web.WebPages.Administration")]
[assembly: AssemblyDescription("")]
[assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]
[assembly: InternalsVisibleTo("System.Web.WebPages.Administration.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/System.Web.WebPages.Administration/Register.cshtml
================================================
@* Generator: WebPage *@

@using System.Globalization;
@{
    Page.Title = AdminResources.RegisterTitle;
    var adminPath = SiteAdmin.AdminVirtualPath.TrimStart('~');
    Page.Desc = String.Format(CultureInfo.CurrentCulture, AdminResources.RegisterDesc, Html.Encode(adminPath));

    // If the password is already set the redirect to login
    if(AdminSecurity.HasAdminPassword()) {
        SiteAdmin.RedirectToLogin(Response);
        return;
    }

    if (IsPost) {
        AntiForgery.Validate();

        var password = Request.Form["password"];
        var reenteredPassword = Request.Form["repassword"];
        if (password.IsEmpty()) {
            ModelState.AddError("password", AdminResources.Validation_PasswordRequired); 
        }
        else if (password != reenteredPassword) {
            ModelState.AddError("repassword", AdminResources.Validation_PasswordsDoNotMatch);
        }

        if (ModelState.IsValid) {
            // Save the admin password
            if(AdminSecurity.SaveTemporaryPassword(password)) {
                // Get the return url
                var returnUrl = SiteAdmin.GetReturnUrl(Request) ?? SiteAdmin.AdminVirtualPath;

                // Redirect to the return url
                Response.Redirect(returnUrl);
            }
            else {
                // Add a validation error since creating the password.txt failed
                ModelState.AddFormError(AdminResources.AdminModuleRequiresAccessToAppData);
            }
            
        }
    }
}

<br/>

@Html.ValidationSummary()

<form method="post" action="">
@AntiForgery.GetHtml()
<fieldset>
    <ol>
        <li class="password">
            <label for="password">@AdminResources.EnterPassword</label>
            @Html.Password("password") @Html.ValidationMessage("password", "*")
        </li>
        <li class="password">
            <label>@AdminResources.ReenterPassword</label>
            @Html.Password("repassword") @Html.ValidationMessage("repassword", "*")
        </li>
    </ol>
    <p class="form-actions">
        <input type="submit" value="@AdminResources.CreatePassword" class="long-input" />
    </p>
</fieldset>
</form>


================================================
FILE: src/System.Web.WebPages.Administration/Resources/AdminResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.214
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.WebPages.Administration {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class AdminResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal AdminResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.WebPages.Administration.Resources.AdminResources", typeof(AdminResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Home.
        /// </summary>
        internal static string AdminHome {
            get {
                return ResourceManager.GetString("AdminHome", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Web Pages Administration.
        /// </summary>
        internal static string AdminModuleDisplayTitle {
            get {
                return ResourceManager.GetString("AdminModuleDisplayTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Admin Module requires write access to ~/App_Data.
        /// </summary>
        internal static string AdminModuleRequiresAccessToAppData {
            get {
                return ResourceManager.GetString("AdminModuleRequiresAccessToAppData", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ASP.NET Web Pages Administration.
        /// </summary>
        internal static string AdminModuleTitle {
            get {
                return ResourceManager.GetString("AdminModuleTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To reset the password, delete the &lt;strong&gt;{0}&lt;/strong&gt; file and revisit this page..
        /// </summary>
        internal static string AdminPasswordChangeInstructions {
            get {
                return ResourceManager.GetString("AdminPasswordChangeInstructions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;a href=&quot;{0}&quot;&gt;Click here&lt;/a&gt; to continue and verify your password after you have renamed the file to Password.config..
        /// </summary>
        internal static string ContinueAfterEnableText {
            get {
                return ResourceManager.GetString("ContinueAfterEnableText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create Password.
        /// </summary>
        internal static string CreatePassword {
            get {
                return ResourceManager.GetString("CreatePassword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For security reasons your password hash is saved in a file named _Password.config in the /App_Data/Admin/ folder of your website. To fully enable site administration, rename the file to Password.config by removing the underscore (_) character from the file name. If this is the first time you are seeing these instructions and you have not yet created a password, then remove the /App_Data/Admin/_Password.config file. This will remove a previously created password and allow you to create your own password.
        /// </summary>
        internal static string EnableInstructions {
            get {
                return ResourceManager.GetString("EnableInstructions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enter Password.
        /// </summary>
        internal static string EnterPassword {
            get {
                return ResourceManager.GetString("EnterPassword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Forgot Password?.
        /// </summary>
        internal static string ForgotPassword {
            get {
                return ResourceManager.GetString("ForgotPassword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The return URL specified for request redirection is invalid..
        /// </summary>
        internal static string InvalidReturnUrl {
            get {
                return ResourceManager.GetString("InvalidReturnUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Login.
        /// </summary>
        internal static string Login {
            get {
                return ResourceManager.GetString("Login", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Login to ASP.NET Web Pages Administration.
        /// </summary>
        internal static string LoginTitle {
            get {
                return ResourceManager.GetString("LoginTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Logo.
        /// </summary>
        internal static string LogoLabel {
            get {
                return ResourceManager.GetString("LogoLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Logout.
        /// </summary>
        internal static string Logout {
            get {
                return ResourceManager.GetString("Logout", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Module already registered for virtual path &apos;{0}&apos;.
        /// </summary>
        internal static string ModuleAlreadyRegistered {
            get {
                return ResourceManager.GetString("ModuleAlreadyRegistered", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Modules.
        /// </summary>
        internal static string Modules {
            get {
                return ResourceManager.GetString("Modules", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No modules are currently installed..
        /// </summary>
        internal static string NoAdminModulesInstalled {
            get {
                return ResourceManager.GetString("NoAdminModulesInstalled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Password.
        /// </summary>
        internal static string Password {
            get {
                return ResourceManager.GetString("Password", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Confirm Password.
        /// </summary>
        internal static string ReenterPassword {
            get {
                return ResourceManager.GetString("ReenterPassword", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Accessing pages in ASP.NET Web Pages Package Administration requires a password. You create the password the first time you visit a page in this directory..
        /// </summary>
        internal static string RegisterDesc {
            get {
                return ResourceManager.GetString("RegisterDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create a password.
        /// </summary>
        internal static string RegisterTitle {
            get {
                return ResourceManager.GetString("RegisterTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ASP.NET Web Pages Administration Security Check.
        /// </summary>
        internal static string SecurityTitle {
            get {
                return ResourceManager.GetString("SecurityTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The password in incorrect.
        /// </summary>
        internal static string Validation_PasswordIncorrect {
            get {
                return ResourceManager.GetString("Validation_PasswordIncorrect", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A password is required..
        /// </summary>
        internal static string Validation_PasswordRequired {
            get {
                return ResourceManager.GetString("Validation_PasswordRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Confirm password does not match password.
        /// </summary>
        internal static string Validation_PasswordsDoNotMatch {
            get {
                return ResourceManager.GetString("Validation_PasswordsDoNotMatch", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Administration/Resources/AdminResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="AdminModuleTitle" xml:space="preserve">
    <value>ASP.NET Web Pages Administration</value>
  </data>
  <data name="LoginTitle" xml:space="preserve">
    <value>Login to ASP.NET Web Pages Administration</value>
  </data>
  <data name="RegisterTitle" xml:space="preserve">
    <value>Create a password</value>
  </data>
  <data name="ModuleAlreadyRegistered" xml:space="preserve">
    <value>Module already registered for virtual path '{0}'</value>
  </data>
  <data name="NoAdminModulesInstalled" xml:space="preserve">
    <value>No modules are currently installed.</value>
  </data>
  <data name="Validation_PasswordIncorrect" xml:space="preserve">
    <value>The password in incorrect</value>
  </data>
  <data name="Validation_PasswordRequired" xml:space="preserve">
    <value>A password is required.</value>
  </data>
  <data name="Logout" xml:space="preserve">
    <value>Logout</value>
  </data>
  <data name="Login" xml:space="preserve">
    <value>Login</value>
  </data>
  <data name="Password" xml:space="preserve">
    <value>Password</value>
  </data>
  <data name="AdminModuleRequiresAccessToAppData" xml:space="preserve">
    <value>The Admin Module requires write access to ~/App_Data</value>
  </data>
  <data name="CreatePassword" xml:space="preserve">
    <value>Create Password</value>
  </data>
  <data name="InvalidReturnUrl" xml:space="preserve">
    <value>The return URL specified for request redirection is invalid.</value>
  </data>
  <data name="EnterPassword" xml:space="preserve">
    <value>Enter Password</value>
  </data>
  <data name="ReenterPassword" xml:space="preserve">
    <value>Confirm Password</value>
  </data>
  <data name="Validation_PasswordsDoNotMatch" xml:space="preserve">
    <value>Confirm password does not match password</value>
  </data>
  <data name="EnableInstructions" xml:space="preserve">
    <value>For security reasons your password hash is saved in a file named _Password.config in the /App_Data/Admin/ folder of your website. To fully enable site administration, rename the file to Password.config by removing the underscore (_) character from the file name. If this is the first time you are seeing these instructions and you have not yet created a password, then remove the /App_Data/Admin/_Password.config file. This will remove a previously created password and allow you to create your own password</value>
    <comment>This resource string will be printed without html encoding. Ensure parameters are html encoded.</comment>
  </data>
  <data name="AdminPasswordChangeInstructions" xml:space="preserve">
    <value>To reset the password, delete the &lt;strong&gt;{0}&lt;/strong&gt; file and revisit this page.</value>
    <comment>This resource string will be printed without html encoding. Ensure parameters are html encoded.</comment>
  </data>
  <data name="ForgotPassword" xml:space="preserve">
    <value>Forgot Password?</value>
  </data>
  <data name="Modules" xml:space="preserve">
    <value>Modules</value>
  </data>
  <data name="RegisterDesc" xml:space="preserve">
    <value>Accessing pages in ASP.NET Web Pages Package Administration requires a password. You create the password the first time you visit a page in this directory.</value>
  </data>
  <data name="AdminHome" xml:space="preserve">
    <value>Home</value>
  </data>
  <data name="AdminModuleDisplayTitle" xml:space="preserve">
    <value>Web Pages Administration</value>
  </data>
  <data name="LogoLabel" xml:space="preserve">
    <value>Logo</value>
  </data>
  <data name="ContinueAfterEnableText" xml:space="preserve">
    <value>&lt;a href="{0}"&gt;Click here&lt;/a&gt; to continue and verify your password after you have renamed the file to Password.config.</value>
    <comment>This resource string will be printed without html encoding. Ensure parameters are html encoded.</comment>
  </data>
  <data name="SecurityTitle" xml:space="preserve">
    <value>ASP.NET Web Pages Administration Security Check</value>
  </data>
</root>

================================================
FILE: src/System.Web.WebPages.Administration/Resources/PackageManagerResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.488
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.WebPages.Administration.PackageManager {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class PackageManagerResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal PackageManagerResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.WebPages.Administration.Resources.PackageManagerResources", typeof(PackageManagerResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add Package Source.
        /// </summary>
        internal static string AddPackageSourceLabel {
            get {
                return ResourceManager.GetString("AddPackageSourceLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Are you sure you want to uninstall &lt;strong&gt;{0}&lt;/strong&gt;?.
        /// </summary>
        internal static string AreYouSureUninstall {
            get {
                return ResourceManager.GetString("AreYouSureUninstall", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Author.
        /// </summary>
        internal static string AuthorsLabel {
            get {
                return ResourceManager.GetString("AuthorsLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Bad Request.
        /// </summary>
        internal static string BadRequest {
            get {
                return ResourceManager.GetString("BadRequest", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cancel.
        /// </summary>
        internal static string Cancel {
            get {
                return ResourceManager.GetString("Cancel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clear.
        /// </summary>
        internal static string ClearLabel {
            get {
                return ResourceManager.GetString("ClearLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Default.
        /// </summary>
        internal static string DefaultPackageSourceName {
            get {
                return ResourceManager.GetString("DefaultPackageSourceName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Delete.
        /// </summary>
        internal static string DeleteLabel {
            get {
                return ResourceManager.GetString("DeleteLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By clicking &quot;Install&quot; you agree to the license terms for the package(s) above. If you do not agree to the license terms, click &quot;Cancel.&quot; Each package is licensed to you by its owner. Microsoft is not responsible for, nor does it grant any licenses to, third-party packages..
        /// </summary>
        internal static string Disclaimer {
            get {
                return ResourceManager.GetString("Disclaimer", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Installed.
        /// </summary>
        internal static string InstalledLabel {
            get {
                return ResourceManager.GetString("InstalledLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Install.
        /// </summary>
        internal static string InstallPackage {
            get {
                return ResourceManager.GetString("InstallPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Installing package {0}..
        /// </summary>
        internal static string InstallPackageDesc {
            get {
                return ResourceManager.GetString("InstallPackageDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package &lt;strong&gt;{0}&lt;/strong&gt; was successfully installed..
        /// </summary>
        internal static string InstallSuccess {
            get {
                return ResourceManager.GetString("InstallSuccess", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to JavaScript is required to correctly view this page..
        /// </summary>
        internal static string JavascriptRequired {
            get {
                return ResourceManager.GetString("JavascriptRequired", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use this page to manage your package sources..
        /// </summary>
        internal static string ManageSourcesDesc {
            get {
                return ResourceManager.GetString("ManageSourcesDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Manage Package Sources.
        /// </summary>
        internal static string ManageSourcesTitle {
            get {
                return ResourceManager.GetString("ManageSourcesTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A collection of tools to automate the process of installing, upgrading, configuring, and removing packages from an ASP.NET application..
        /// </summary>
        internal static string ModuleDesc {
            get {
                return ResourceManager.GetString("ModuleDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package Manager.
        /// </summary>
        internal static string ModuleTitle {
            get {
                return ResourceManager.GetString("ModuleTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Next.
        /// </summary>
        internal static string NextText {
            get {
                return ResourceManager.GetString("NextText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No packages found..
        /// </summary>
        internal static string NoPackagesFound {
            get {
                return ResourceManager.GetString("NoPackagesFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No packages installed. &lt;p&gt;&lt;a href=&quot;{0}&quot;&gt;Install packages from an online feed&lt;/a&gt;&lt;/p&gt;.
        /// </summary>
        internal static string NoPackagesInstalled {
            get {
                return ResourceManager.GetString("NoPackagesInstalled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Default (All).
        /// </summary>
        internal static string NuGetFeed {
            get {
                return ResourceManager.GetString("NuGetFeed", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Online.
        /// </summary>
        internal static string OnlineLabel {
            get {
                return ResourceManager.GetString("OnlineLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error installing package &quot;{0}&quot;:.
        /// </summary>
        internal static string PackageInstallationError {
            get {
                return ResourceManager.GetString("PackageInstallationError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to read package source file. Ensure that the file &quot;{0}&quot; is writeable and the contents of the file have not been modified externally..
        /// </summary>
        internal static string PackageSourceFileInstructions {
            get {
                return ResourceManager.GetString("PackageSourceFileInstructions", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Source.
        /// </summary>
        internal static string PackageSourceLabel {
            get {
                return ResourceManager.GetString("PackageSourceLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error occurred uninstalling package &quot;{0}&quot;:.
        /// </summary>
        internal static string PackageUninstallationError {
            get {
                return ResourceManager.GetString("PackageUninstallationError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error occurred updating package &quot;{0}&quot;:.
        /// </summary>
        internal static string PackageUpdateError {
            get {
                return ResourceManager.GetString("PackageUpdateError", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Page.
        /// </summary>
        internal static string PageLabel {
            get {
                return ResourceManager.GetString("PageLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Previous.
        /// </summary>
        internal static string PreviousText {
            get {
                return ResourceManager.GetString("PreviousText", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Privacy Statement.
        /// </summary>
        internal static string PrivacyStatement {
            get {
                return ResourceManager.GetString("PrivacyStatement", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Remove Dependencies?.
        /// </summary>
        internal static string RemoveDependencies {
            get {
                return ResourceManager.GetString("RemoveDependencies", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restore Default .
        /// </summary>
        internal static string RestoreDefaultSources {
            get {
                return ResourceManager.GetString("RestoreDefaultSources", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Search.
        /// </summary>
        internal static string SearchLabel {
            get {
                return ResourceManager.GetString("SearchLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Packages.
        /// </summary>
        internal static string SectionTitle {
            get {
                return ResourceManager.GetString("SectionTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show.
        /// </summary>
        internal static string ShowLabel {
            get {
                return ResourceManager.GetString("ShowLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Name.
        /// </summary>
        internal static string SourceNameLabel {
            get {
                return ResourceManager.GetString("SourceNameLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Source.
        /// </summary>
        internal static string SourceUrlLabel {
            get {
                return ResourceManager.GetString("SourceUrlLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Uninstall.
        /// </summary>
        internal static string UninstallPackage {
            get {
                return ResourceManager.GetString("UninstallPackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Uninstalling package {0}..
        /// </summary>
        internal static string UninstallPackageDesc {
            get {
                return ResourceManager.GetString("UninstallPackageDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package &lt;strong&gt;{0}&lt;/strong&gt; was successfully uninstalled..
        /// </summary>
        internal static string UninstallSuccess {
            get {
                return ResourceManager.GetString("UninstallSuccess", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unknown framework assembly: &quot;{0}&quot;.
        /// </summary>
        internal static string UnknownFrameworkReference {
            get {
                return ResourceManager.GetString("UnknownFrameworkReference", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update.
        /// </summary>
        internal static string UpdatePackage {
            get {
                return ResourceManager.GetString("UpdatePackage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updating package {0} to version {1}..
        /// </summary>
        internal static string UpdatePackageDesc {
            get {
                return ResourceManager.GetString("UpdatePackageDesc", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Updates.
        /// </summary>
        internal static string UpdatesLabel {
            get {
                return ResourceManager.GetString("UpdatesLabel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Package &lt;strong&gt;{0}&lt;/strong&gt; was successfully updated..
        /// </summary>
        internal static string UpdateSuccess {
            get {
                return ResourceManager.GetString("UpdateSuccess", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid source url..
        /// </summary>
        internal static string Validation_InvalidPackageSourceUrl {
            get {
                return ResourceManager.GetString("Validation_InvalidPackageSourceUrl", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specified package source already exists..
        /// </summary>
        internal static string Validation_PackageSourceAlreadyExists {
            get {
                return ResourceManager.GetString("Validation_PackageSourceAlreadyExists", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to View License Terms.
        /// </summary>
        internal static string ViewLicenseTerms {
            get {
                return ResourceManager.GetString("ViewLicenseTerms", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to , .
        /// </summary>
        internal static string WordSeparator {
            get {
                return ResourceManager.GetString("WordSeparator", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Administration/Resources/PackageManagerResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="PackageSourceLabel" xml:space="preserve">
    <value>Source</value>
  </data>
  <data name="PageLabel" xml:space="preserve">
    <value>Page</value>
  </data>
  <data name="InstallPackage" xml:space="preserve">
    <value>Install</value>
  </data>
  <data name="DefaultPackageSourceName" xml:space="preserve">
    <value>Default</value>
  </data>
  <data name="NoPackagesFound" xml:space="preserve">
    <value>No packages found.</value>
  </data>
  <data name="PackageInstallationError" xml:space="preserve">
    <value>Error installing package "{0}":</value>
  </data>
  <data name="PackageUninstallationError" xml:space="preserve">
    <value>Error occurred uninstalling package "{0}":</value>
  </data>
  <data name="SearchLabel" xml:space="preserve">
    <value>Search</value>
  </data>
  <data name="UninstallPackage" xml:space="preserve">
    <value>Uninstall</value>
  </data>
  <data name="BadRequest" xml:space="preserve">
    <value>Bad Request</value>
  </data>
  <data name="ModuleDesc" xml:space="preserve">
    <value>A collection of tools to automate the process of installing, upgrading, configuring, and removing packages from an ASP.NET application.</value>
  </data>
  <data name="ModuleTitle" xml:space="preserve">
    <value>Package Manager</value>
  </data>
  <data name="NoPackagesInstalled" xml:space="preserve">
    <value>No packages installed. &lt;p&gt;&lt;a href="{0}"&gt;Install packages from an online feed&lt;/a&gt;&lt;/p&gt;</value>
    <comment>Not HTML encoding the text. Ensure params are encoded</comment>
  </data>
  <data name="AuthorsLabel" xml:space="preserve">
    <value>Author</value>
  </data>
  <data name="WordSeparator" xml:space="preserve">
    <value>, </value>
    <comment>String used as glue to join multiple words into a single comma separated string </comment>
  </data>
  <data name="Disclaimer" xml:space="preserve">
    <value>By clicking "Install" you agree to the license terms for the package(s) above. If you do not agree to the license terms, click "Cancel." Each package is licensed to you by its owner. Microsoft is not responsible for, nor does it grant any licenses to, third-party packages.</value>
  </data>
  <data name="InstallPackageDesc" xml:space="preserve">
    <value>Installing package {0}.</value>
  </data>
  <data name="UninstallPackageDesc" xml:space="preserve">
    <value>Uninstalling package {0}.</value>
  </data>
  <data name="AreYouSureUninstall" xml:space="preserve">
    <value>Are you sure you want to uninstall &lt;strong&gt;{0}&lt;/strong&gt;?</value>
    <comment>Not HTML encoding the text. Ensure params are encoded </comment>
  </data>
  <data name="Cancel" xml:space="preserve">
    <value>Cancel</value>
  </data>
  <data name="UninstallSuccess" xml:space="preserve">
    <value>Package &lt;strong&gt;{0}&lt;/strong&gt; was successfully uninstalled.</value>
    <comment>Not HTML encoding the text. Ensure params are encoded</comment>
  </data>
  <data name="UpdatePackage" xml:space="preserve">
    <value>Update</value>
  </data>
  <data name="JavascriptRequired" xml:space="preserve">
    <value>JavaScript is required to correctly view this page.</value>
  </data>
  <data name="ViewLicenseTerms" xml:space="preserve">
    <value>View License Terms</value>
  </data>
  <data name="InstallSuccess" xml:space="preserve">
    <value>Package &lt;strong&gt;{0}&lt;/strong&gt; was successfully installed.</value>
    <comment>Not HTML encoding the text. Ensure params are encoded</comment>
  </data>
  <data name="UpdatePackageDesc" xml:space="preserve">
    <value>Updating package {0} to version {1}.</value>
    <comment>Updating Foo 1.1 to version 1.3.</comment>
  </data>
  <data name="UpdateSuccess" xml:space="preserve">
    <value>Package &lt;strong&gt;{0}&lt;/strong&gt; was successfully updated.</value>
    <comment>Not HTML encoding the text. Ensure params are encoded</comment>
  </data>
  <data name="ClearLabel" xml:space="preserve">
    <value>Clear</value>
  </data>
  <data name="ManageSourcesDesc" xml:space="preserve">
    <value>Use this page to manage your package sources.</value>
  </data>
  <data name="AddPackageSourceLabel" xml:space="preserve">
    <value>Add Package Source</value>
  </data>
  <data name="DeleteLabel" xml:space="preserve">
    <value>Delete</value>
  </data>
  <data name="SourceNameLabel" xml:space="preserve">
    <value>Name</value>
  </data>
  <data name="SourceUrlLabel" xml:space="preserve">
    <value>Source</value>
  </data>
  <data name="ManageSourcesTitle" xml:space="preserve">
    <value>Manage Package Sources</value>
  </data>
  <data name="Validation_InvalidPackageSourceUrl" xml:space="preserve">
    <value>Invalid source url.</value>
  </data>
  <data name="PackageSourceFileInstructions" xml:space="preserve">
    <value>Unable to read package source file. Ensure that the file "{0}" is writeable and the contents of the file have not been modified externally.</value>
  </data>
  <data name="RestoreDefaultSources" xml:space="preserve">
    <value>Restore Default </value>
  </data>
  <data name="PackageUpdateError" xml:space="preserve">
    <value>Error occurred updating package "{0}":</value>
  </data>
  <data name="RemoveDependencies" xml:space="preserve">
    <value>Remove Dependencies?</value>
  </data>
  <data name="SectionTitle" xml:space="preserve">
    <value>Packages</value>
  </data>
  <data name="Validation_PackageSourceAlreadyExists" xml:space="preserve">
    <value>Specified package source already exists.</value>
  </data>
  <data name="ShowLabel" xml:space="preserve">
    <value>Show</value>
  </data>
  <data name="InstalledLabel" xml:space="preserve">
    <value>Installed</value>
  </data>
  <data name="OnlineLabel" xml:space="preserve">
    <value>Online</value>
  </data>
  <data name="UpdatesLabel" xml:space="preserve">
    <value>Updates</value>
  </data>
  <data name="NuGetFeed" xml:space="preserve">
    <value>Default (All)</value>
  </data>
  <data name="PrivacyStatement" xml:space="preserve">
    <value>Privacy Statement</value>
  </data>
  <data name="UnknownFrameworkReference" xml:space="preserve">
    <value>Unknown framework assembly: "{0}"</value>
  </data>
  <data name="NextText" xml:space="preserve">
    <value>Next</value>
  </data>
  <data name="PreviousText" xml:space="preserve">
    <value>Previous</value>
  </data>
</root>

================================================
FILE: src/System.Web.WebPages.Administration/Site.css
================================================
/* Reset
***************************************************************/

html, body, div, span, applet, object, iframe,
h1, h2, h3, h4, h5, h6, p, blockquote, pre,
a, abbr, acronym, address, big, cite, code,
del, dfn, em, font, img, ins, kbd, q, s, samp,
small, strike, strong, sub, sup, tt, var,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
	margin: 0;
	padding: 0;
	border: 0;
	outline: 0;
	font-weight: inherit;
	font-style: inherit;
	font-size: 100%;
	font-family: inherit;
	vertical-align: baseline;
}

/* Remember focus styles! */
:focus { outline: 0; }

body { line-height: 1.4em; color: black; background: white; }
ol, ul { list-style: none; }

/* Tables still need 'cellspacing="0"' in the markup */
table { border-collapse: separate; border-spacing: 0; }
caption, td { text-align: left;  }

thead th 
{
    font-weight: bold;
    text-align: center;
}

blockquote:before, blockquote:after,
q:before, q:after { content: ""; }
blockquote, q { quotes: "" ""; }

/* HTML 5 elements as block */  
header, footer, aside, nav, article { display: block; }

/* Clearing Floats
***************************************************************/

.group:after 
{
	content: ".";
	display: block;
	height: 0;
	clear: both;
	visibility: hidden;
}

/* General
***************************************************************/

/* Default font settings. 
The font-size 81.3% sets the base font to 13px 

Pixels 	EMs 	    Percent Points
6px 	0.462em 	46.2% 	5pt
7px 	0.538em 	53.8% 	5pt
8px 	0.615em 	61.5% 	6pt
9px 	0.692em 	69.2% 	7pt
10px 	0.769em 	76.9% 	8pt
11px 	0.846em 	84.6% 	8pt
12px 	0.923em 	92.3% 	9pt
13px 	1em 	    100% 	10pt
14px 	1.077em 	107.7% 	11pt
15px 	1.154em 	115.4% 	11pt
16px 	1.231em 	123.1% 	12pt
17px 	1.308em 	130.8% 	13pt
18px 	1.385em 	138.5% 	14pt
19px 	1.462em 	146.2% 	14pt
20px 	1.538em 	153.8% 	15pt
21px 	1.615em 	161.5% 	16pt
22px 	1.692em 	169.2% 	17pt
23px 	1.769em 	176.9% 	17pt
24px 	1.846em 	184.6% 	18pt
26px	2em			200%	20pt
*/

body {
    background-color: #ececec;	
  	font-size: 81.3%;
    font-family: Segoe UI,Trebuchet,"Helvetica Neue", Arial, Helvetica, sans-serif; color:#333;
    margin: 0;
    padding: 0;
    
/*CSS3 properties*/
    filter:progid:DXImageTransform.Microsoft.Gradient(GradientType=0, startColorstr='#ffffff',  endColorstr='#ececec');
	background: -webkit-gradient(linear, 0 0, 0 100%, from(#fff), to(#ececec)) fixed;
	background: -moz-linear-gradient(top, #fff, #ececec) fixed;  
}

a:link {
    color: #034af3;
    text-decoration: underline;
}

a:visited {
    color: #505abc;
}

a:hover {
    color: #1d60ff;
    text-decoration: none;
}

a:active {
    color: #12eb87;
}

/* Headings and Text Elements   
***************************************************************/

/* Headings */
h1, h2, h3, h4, h5, h6 { color: #385366; }

h1 { font-size: 184.6%; } /*24px*/
h2 { font-size: 176.9%; } /*23px*/
h3 { font-size: 153.8%; } /*20px*/
h4 { font-size: 138.5%; } /*18px*/
h5 { font-size: 123.1%; } /*16px*/
h6 { font-size: 107.7%; } /*14px*/

/* Text elements */
p  
{
    line-height: 18px; 
    margin-top: 10px;
}

.text-small { font-size: 84.6%; /*11px*/ }

strong 
{
    font-weight: bold;
}

code 
{
    display: block;
    margin: 5px 0px 5px 5px;
}

em 
{
    font-style: italic;
}

/* Layout   
***************************************************************/

#page {
    width: 90%;
    margin-left: auto;
    margin-right: auto;
}

#header {
    position: relative;
    margin-bottom: 0;
    color: #000;
    padding: 26px 26px 26px 0;
}

#main {
    padding: 30px 30px 15px 30px;
    background-color: #fff;
    margin: 0 0 30px 0;
    border: 1px solid #a6a6a6;
     
    /*CSS3 properties*/
    border-radius: 3px;
    -webkit-border-radius: 3px;
    -moz-border-radius: 3px;
	-webkit-box-shadow: 0px 0px 4px rgba(102, 102, 102, 0.3); 
	-moz-box-shadow: 0px 0px 4px rgba(102, 102, 102, 0.3);
	box-shadow: 0px 0px 4px rgba(102, 102, 102, 0.3);
	background: -webkit-gradient(linear, 0 0, 0 100%, from(#fff), to(#f3f3f3)) fixed;
	background: -moz-linear-gradient(top, #fff, #f3f3f3) fixed;
    filter:progid:DXImageTransform.Microsoft.Gradient(GradientType=0, startColorstr='#ffffff',  endColorstr='#f3f3f3');
}

#footer {
    padding: 10px 0;
    text-align: center;
    line-height: normal;
    margin: 0;
}

/* Site Title 
***************************************************************/

#header .site-title {
    float: left;
	color: #385366;
    padding: 5px;
    margin: 0;
    border: none;
}
    
    
#header .site-title span.aspnet {
	color:#3c89c8;
}

/* Login Display  
***************************************************************/

#settings {
    float: right;
    font-size: 123.1%; /*16px*/
    display: block;
    text-align: right;
    margin: 14px 0 0 0;
}

    #settings li {
        margin: 0;
        display: inline;
        list-style: none;
        padding: 0 0 0 5px;
    }
    
    
    #settings a:before 
    {
        margin-right: 10px;
        content: "["
    }
    
    #settings a:after 
    {
        margin-left: 10px;
        content: "]"
    }
    
    #settings a:link, #settings a:visited 
    {
        text-decoration: none;
        margin: 0 0 0 10px;        
        color:#034AF3;
    }

    #settings a:hover
    {
        text-decoration: underline;
    }

/* Tab Menu   
***************************************************************/

.nav li { font-size: 123.1%; } /*16px*/

ul#menu {
    clear: both;
    border-bottom: 1px #5c87b2 solid;
    padding: 0 0 2px 0;
    position: relative;
    text-align: right;
}

    ul#menu li {
        display: inline;
        list-style: none;

    }

        ul#menu li a {
            padding: 10px 20px 0 0;
            font-weight: bold;
            text-decoration: none;
            line-height: 2.8em;
            background-color: #e8eef4;
            color: #034af3;
            
            /*CSS3 properties*/
            border-radius: 4px 4px 0 0;
            -webkit-border-radius: 4px 4px 0 0;
            -moz-border-radius: 4px 4px 0 0;
        }

        ul#menu li a:hover {
            background-color: #fff;
            text-decoration: none;
        }

        ul#menu li a:active {
            background-color: #a6e2a6;
            text-decoration: none;
        }

        ul#menu li.selected a {
            background-color: #fff;
            color: #000;
        }
        
/* Page Title   
***************************************************************/

	.page-title {
	border-bottom: 1px solid #e8e6e6;
	margin: 0 0 26px 0;
	}
        
/* Forms   
***************************************************************/
fieldset {
    margin: 10px 0;
    padding: 10px;
    border: 1px solid #ccc;
}

    fieldset legend {
    	font-size: 123.1%; /*16px*/
        font-weight: 600;
        padding: 2px 4px 8px 4px;
    }
    
    fieldset ol {
        padding: 0;
        list-style: none;
    }
    
    fieldset ol li {
       	padding: 0 0 5px 0;
        }
    
    fieldset label {
        display: block;
        font-weight: bold;
    }
    
    fieldset label.checkbox {
        display: inline;
    }
    
     select, fieldset  input[type="text"], input[type="password"] {
        border: 1px solid #c4c4c4;
        color: #444;
        width: 300px;
		padding: 3px;
   
     	/*CSS3 properties*/
        border-radius: 3px;
  		-webkit-border-radius: 3px;
    	-moz-border-radius: 3px;
    }

	select {
	width: auto;
}

input[type="submit"],
input[type="reset"],
input[type="button"]
{
        font-size: 107.7%; /*14px*/
  		color:#333;
		background:#F5F5F5;
		border:1px solid #999;
		cursor:pointer;
		width:80px;
		padding: 1px;
		text-align:center;
		
		/*CSS3 properties*/
		filter:progid:DXImageTransform.Microsoft.Gradient(GradientType=0, startColorstr='#f5f5f5',  endColorstr='#cbcbcb');
		background: -webkit-gradient(linear, 0 0, 0 100%, from(#f5f5f5), to(#cbcbcb));
		background: -moz-linear-gradient(top, #f5f5f5, #cbcbcb);
		
		box-shadow: inset 0px 0px 1px rgba(255, 255, 255, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
		-webkit-box-shadow: inset 0px 0px 1px rgba(255, 255, 255, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3); 
		-moz-box-shadow: inset 0px 0px 1px rgba(255, 255, 255, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
		border-radius: 3px;
		-webkit-border-radius: 3px;
		-moz-border-radius: 3px;
    }
    

input[type="submit"]:hover,
input[type="reset"]:hover,
input[type="button"]:hover,
button:hover {
	text-decoration:none; 
	background: #62a9e2;
	color:#fff;
	border:1px solid #2e76b1;
	
	/*CSS3 properties*/	
	filter:progid:DXImageTransform.Microsoft.Gradient(GradientType=0, startColorstr='#62a9e2',  endColorstr='#3c89c8');
	background: -webkit-gradient(linear, 0 0, 0 100%, from(#62a9e2), to(#3c89c8));
	background: -moz-linear-gradient(top, #62a9e2, #3c89c8);
}

input[type="submit"]:active,
input[type="reset"]:active,
input[type="button"]:active,
button:active {
	text-decoration:none; 
	background: #62a9e2;
	color:#fff;
 	border:1px solid #093253;
 
 	/*CSS3 properties*/	
 	filter:progid:DXImageTransform.Microsoft.Gradient(GradientType=0, startColorstr='#72b8f2',  endColorstr='#3078b3');
 	background: -webkit-gradient(linear, 0 0, 0 100%, from(#72b8f2), to(#3078b3));
	background: -moz-linear-gradient(top, #72b8f2, #3078b3);
	box-shadow: inset 0px 0px 1px rgba(0, 0, 0, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
	-moz-box-shadow: inset 0px 0px 1px rgba(0, 0, 0, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
	-webkit-box-shadow: inset 0px 0px 1px rgba(0, 0, 0, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
}

input[type="submit"].long-input,
input[type="reset"].long-input,
input[type="button"].long-input,
button.long-input {
    width: 140px;
}

input[type="submit"]:focus::-moz-focus-inner, button:focus::-moz-focus-inner {
  border: 1px dotted transparent;
}

    
 /* Information and errors  
----------------------------------------------------------*/  
.message {
    clear: both;
    border: 1px solid;
    margin: 10px 0px;
    padding: 15px;
    font-weight: bold;
    
    /*CSS3 properties*/
    border-radius: 3px;
    -moz-border-radius: 3px;
    -webkit-border-radius: 3px;

	-moz-box-shadow: inset 0px 0px 1px rgba(0, 0, 0, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
	-webkit-box-shadow: inset 0px 0px 1px rgba(0, 0, 0, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
	box-shadow: inset 0px 0px 1px rgba(0, 0, 0, 1.0), 1px 1px 1px rgba(102, 102, 102, 0.3);
}

.info {
    background: #dddddd;
    color: #00529b;
}

.error {
    background: #ffe4e4;
    color: #d63301;
}

.success {
    background: #dff2bf;
    color: #43750E;
}

input[type="text"].validation-error, input[type="password"].validation-error { 
    border: solid 1px #d63301; 
    background-color: #ffccba;
    font-weight: inherit;
    font-size: inherit;
    color: inherit;
}

.validation-error {
    display: inline;
    color: #be3e16;
    font-weight: 600;
    font-size: 123.1%; /*16px*/
}

.page-title > h1
{
    margin-top: 0;
}

.page-title > span 
{
    font-style: italic;
}
.modules
{
    list-style-type: none;
    margin: 0 0 0 -15px;
}


.modules > li
{
    background: url(images/package.png) no-repeat 0 10%;
    padding: 0 0 0 30px;
}

.modules > li > a
{
    font-size: 123.1%; /*16px*/

}

#breadcrumbs
{
    font-size: 123.1%; /*16px*/
    margin:0 auto;
    display: block;
    height: 44px;
}

#breadcrumbs ul, #breadcrumbs  li 
{
    float:left;
    margin:0 8px;
    height: 100%;
}

#breadcrumbs ul 
{
    line-height: 20px;
    list-style: none outside none;
    padding: 0;
}


#breadcrumbs li.selected
{
    background:url("images/tabOn.gif") no-repeat scroll 45% bottom transparent;
    bottom: -1px;
    position: relative;
}

#breadcrumbs a, #breadcrumbs a:visited, #breadcrumbs a:active
{
    text-decoration: none;
    color:#034AF3;
}

.error ul 
{
    padding: 0;
    margin: 0;
}

.error ul li 
{
    list-style-type: none;

}

.page-settings 
{
    float: right;
    width: 5%;   
    text-transform: lowercase;
}

hr 
{
    border-top: none;
    border-left: none;
    border-right: none;
    border-bottom: 1px solid #E8E6E6;
}

/* Misc
***************************************************************/

.clear { clear: both; }

.left { float: left; }

.centered { text-align: center; }

.right { float: right; }

img.inline 
{
    vertical-align: text-bottom;
}





================================================
FILE: src/System.Web.WebPages.Administration/System.Web.WebPages.Administration.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.WebPages.Administration</RootNamespace>
    <AssemblyName>System.Web.WebPages.Administration</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="NuGet.Core, Version=1.6.30117.9648, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <Private>True</Private>
      <HintPath>..\..\packages\Nuget.Core.1.6.2\lib\net40\NuGet.Core.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Web" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="Framework\packages\RemoteAssembly.cs" />
    <Compile Include="Framework\packages\IPackagesSourceFile.cs" />
    <Compile Include="Framework\packages\IWebProjectManager.cs" />
    <Compile Include="Framework\packages\PackageSourceFile.cs" />
    <Compile Include="Framework\packages\WebProjectManager.cs" />
    <Compile Include="Framework\packages\WebProjectSystem.cs" />
    <Compile Include="Framework\SiteAdmin.cs" />
    <Compile Include="Framework\packages\WebPackageSource.cs" />
    <Compile Include="Framework\packages\PackageManagerModule.cs" />
    <Compile Include="Framework\packages\PageUtils.cs" />
    <Compile Include="Resources\PackageManagerResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>PackageManagerResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Resources\AdminResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>AdminResources.resx</DependentUpon>
    </Compile>
    <Compile Include="Framework\AdminSecurity.cs" />
    <Compile Include="Framework\PreApplicationStartCode.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="Framework\packages\PackageExtensions.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
    <RazorSrcFiles Include="_Layout.cshtml" />
    <RazorSrcFiles Include="Logout.cshtml" />
    <RazorSrcFiles Include="Register.cshtml" />
    <RazorSrcFiles Include="Login.cshtml" />
    <RazorSrcFiles Include="_pagestart.cshtml" />
    <RazorSrcFiles Include="Default.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\AdminResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>AdminResources.Designer.cs</LastGenOutput>
      <CustomToolNamespace>System.Web.WebPages.Administration</CustomToolNamespace>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\PackageManagerResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>PackageManagerResources.Designer.cs</LastGenOutput>
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </EmbeddedResource>
    <EmbeddedResource Include="Site.css" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="images\error.png" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="images\package.png" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22BABB60-8F02-4027-AFFC-ACF069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\WebMatrix.Data\WebMatrix.Data.csproj">
      <Project>{4D39BAAF-8A96-473E-AB79-C8A341885137}</Project>
      <Name>WebMatrix.Data</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9B7E3740-6161-4548-833C-4BBCA43B970E}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\WebMatrix.WebData\WebMatrix.WebData.csproj">
      <Project>{55A15F40-1435-4248-A7F2-2A146BB83586}</Project>
      <Name>WebMatrix.WebData</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="images\aspLogo.gif" />
    <EmbeddedResource Include="images\tabon.gif" />
    <EmbeddedResource Include="images\ok.png" />
    <EmbeddedResource Include="packages\scripts\PackageAction.js" />
    <EmbeddedResource Include="packages\scripts\Default.js" />
    <RazorSrcFiles Include="EnableInstructions.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\SourceFileInstructions.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\PackageSources.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\Install.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\Update.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\_Package.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\Default.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <EmbeddedResource Include="packages\images\error.png" />
    <EmbeddedResource Include="packages\images\package.png" />
    <EmbeddedResource Include="packages\Site.css" />
    <RazorSrcFiles Include="packages\Uninstall.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\_PackageDetails.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\_pagestart.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
    <RazorSrcFiles Include="packages\_Layout.cshtml">
      <CustomToolNamespace>System.Web.WebPages.Administration.PackageManager</CustomToolNamespace>
    </RazorSrcFiles>
  </ItemGroup>
  <ItemGroup>
    <Folder Include="packages\Resources\" />
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  
  <!-- Note: RazorGenerator.MsBuild uses Razor 3.0 \ Mvc 5.0 for generating views. In the event we update the Mvc parser, we'll need to ensure this package references the updated Mvc build -->
  <Import Project="..\..\packages\RazorGenerator.MsBuild.2.2.0\build\RazorGenerator.MsBuild.targets" Condition="Exists('..\..\packages\RazorGenerator.MsBuild.2.2.0\build\RazorGenerator.MsBuild.targets')" />
</Project>

================================================
FILE: src/System.Web.WebPages.Administration/_Layout.cshtml
================================================
@* Generator: WebPage *@

@{
    string title = Page.Title;
}

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
   <head>
      <title>@AdminResources.AdminModuleTitle@if (!title.IsEmpty()) { <text>- @title </text> }</title>
      <link href="@Href("Site.css")" rel="stylesheet" type="text/css" />
      @RenderSection("Head", required: false)
   </head>
   <body>
      <div id="page">
         <div id="header" class="group">
            <h1 class="site-title">
                <img src="@Href("images/aspLogo.gif")" alt="@AdminResources.LogoLabel" />
                <span class="aspnet">ASP.NET</span>&nbsp;@AdminResources.AdminModuleDisplayTitle
            </h1>
             <div id="settings">
                <span>
                    @RenderSection("PageSettings", required: false)
                    &nbsp;
                    @if (AdminSecurity.IsAuthenticated(Request)) {
                        <a href="@Href("Logout")">@AdminResources.Logout</a>
                    }
                </span>
             </div>
           </div>
           <div class="clear"></div>
           <div id="breadcrumbs" class="group">
           <ul>
           @{
                var firstCrumb = true;
                int current = 0;
            }
            @foreach(var item in Page.BreadCrumbs){
                current++;
                if(firstCrumb) {
                    firstCrumb = false;
                }
                else {
                    <li><span>&gt;</span></li>
                }
                <li @((current == Page.BreadCrumbs.Count) ? @Html.Raw("class=\"selected\"") : null)>
                <a href="@item.Item2" title="@item.Item1">@item.Item1</a>
                </li>
           }
           </ul>

        </div>
        <div id="main">
            @{
                string sectionTitle = Page.SectionTitle ?? title;
            }
            @if (!sectionTitle.IsEmpty()) {
                <div class="page-title">
                    <h1>@sectionTitle</h1>
                    @if (!String.IsNullOrEmpty(Page.Desc)) {
                        <span>@Page.Desc</span>
                    }
                </div>
            }          
            @RenderBody()
            <p />
        </div>
        <div id="footer">
            @RenderSection("Footer", required: false)
        </div>
      </div>
   </body>
</html>

================================================
FILE: src/System.Web.WebPages.Administration/_pagestart.cshtml
================================================
@* Generator: WebPage *@

@{
    // 404 if the admin page isn't available
    if (!SiteAdmin.Available) {
        Response.SetStatus(HttpStatusCode.NotFound);
        return;
    }
       
    AdminSecurity.Authorize(this);    
}

@{
    // Set up layout values
    var breadCrumbs = new List<Tuple<string, string>>();
    if (SiteAdmin.Modules.Any()) {
        breadCrumbs.Add(Tuple.Create(AdminResources.AdminHome, Href(SiteAdmin.AdminVirtualPath)));
    }
    PageData["BreadCrumbs"] = breadCrumbs;
    Layout = "_Layout.cshtml";  

    
    HtmlHelper.ValidationSummaryClass = "message error";
    HtmlHelper.ValidationInputCssClassName = "validation-error";

    // Force IE9 standards mode rendering
    Response.AddHeader("X-UA-Compatible", "IE=Edge");
}




================================================
FILE: src/System.Web.WebPages.Administration/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Nuget.Core" version="1.6.2" targetFramework="net45" />
  <package id="RazorGenerator.MsBuild" version="2.2.0" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.WebPages.Deployment/AppDomainHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Reflection;

namespace System.Web.WebPages.Deployment
{
    internal static class AppDomainHelper
    {
        public static IDictionary<string, IEnumerable<string>> GetBinAssemblyReferences(string appPath, string configPath)
        {
            string binDirectory = Path.Combine(appPath, "bin");
            if (!Directory.Exists(binDirectory))
            {
                return null;
            }

            AppDomain appDomain = null;
            try
            {
                var appDomainSetup = new AppDomainSetup
                {
                    ApplicationBase = appPath,
                    ConfigurationFile = configPath,
                    PrivateBinPath = binDirectory,
                };
                appDomain = AppDomain.CreateDomain(typeof(AppDomainHelper).Namespace, AppDomain.CurrentDomain.Evidence, appDomainSetup);

                var type = typeof(RemoteAssemblyLoader);
                var instance = (RemoteAssemblyLoader)appDomain.CreateInstanceAndUnwrap(type.Assembly.FullName, type.FullName);

                return Directory.EnumerateFiles(binDirectory, "*.dll")
                    .ToDictionary(assemblyPath => assemblyPath,
                                  assemblyPath => instance.GetReferences(assemblyPath));
            }
            finally
            {
                if (appDomain != null)
                {
                    AppDomain.Unload(appDomain);
                }
            }
        }

        private sealed class RemoteAssemblyLoader : MarshalByRefObject
        {
            [SuppressMessage("Microsoft.Performance", "CA1822:MarkMembersAsStatic", Justification = "Method needs to be instance level for cross domain invocation"),
             SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods", MessageId = "System.Reflection.Assembly.LoadFrom",
                 Justification = "We want to load this specific assembly.")]
            public IEnumerable<string> GetReferences(string assemblyPath)
            {
                var assembly = Assembly.LoadFrom(assemblyPath);
                return assembly.GetReferencedAssemblies()
                    .Select(asmName => Assembly.Load(asmName.FullName).FullName)
                    .Concat(new[] { assembly.FullName })
                    .ToArray();
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/AssemblyUtils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security;
using Microsoft.Internal.Web.Utils;
using Microsoft.Web.Infrastructure;

namespace System.Web.WebPages.Deployment
{
    internal static class AssemblyUtils
    {
        // Copied from AssemblyRefs.cs
        private const string SharedLibPublicKey = "31bf3856ad364e35";

        internal static readonly AssemblyName ThisAssemblyName = new AssemblyName(typeof(AssemblyUtils).Assembly.FullName);
        internal static readonly Version WebPagesV1Version = new Version(1, 0, 0, 0);
        private static readonly string _binFileName = Path.GetFileName(ThisAssemblyName.Name) + ".dll";

        // Special case MWI because it does not share the same assembly version as the rest of WebPages.
        private static readonly Version _mwiVersion = new AssemblyName(typeof(InfrastructureHelper).Assembly.FullName).Version;

        private static readonly AssemblyName _mwiAssemblyName = GetFullName("Microsoft.Web.Infrastructure", _mwiVersion);

        private static readonly AssemblyName[] _version1AssemblyList = new[]
        {
            _mwiAssemblyName,
            GetFullName("System.Web.Razor", WebPagesV1Version),
            GetFullName("System.Web.Helpers", WebPagesV1Version),
            GetFullName("System.Web.WebPages", WebPagesV1Version),
            GetFullName("System.Web.WebPages.Administration", WebPagesV1Version),
            GetFullName("System.Web.WebPages.Razor", WebPagesV1Version),
            GetFullName("WebMatrix.Data", WebPagesV1Version),
            GetFullName("WebMatrix.WebData", WebPagesV1Version)
        };

        private static readonly AssemblyName[] _versionCurrentAssemblyList = new[]
        {
            _mwiAssemblyName,
            GetFullName("System.Web.Razor", ThisAssemblyName.Version),
            GetFullName("System.Web.Helpers", ThisAssemblyName.Version),
            GetFullName("System.Web.WebPages", ThisAssemblyName.Version),
            GetFullName("System.Web.WebPages.Administration", ThisAssemblyName.Version),
            GetFullName("System.Web.WebPages.Razor", ThisAssemblyName.Version),
            GetFullName("WebMatrix.Data", ThisAssemblyName.Version),
            GetFullName("WebMatrix.WebData", ThisAssemblyName.Version)
        };

        internal static Version GetMaxWebPagesVersion()
        {
            return GetMaxWebPagesVersion(GetLoadedAssemblies());
        }

        internal static Version GetMaxWebPagesVersion(IEnumerable<AssemblyName> loadedAssemblies)
        {
            return GetWebPagesAssemblies(loadedAssemblies).Max(c => c.Version);
        }

        internal static bool IsVersionAvailable(Version version)
        {
            return IsVersionAvailable(GetLoadedAssemblies(), version);
        }

        internal static bool IsVersionAvailable(IEnumerable<AssemblyName> loadedAssemblies, Version version)
        {
            return GetWebPagesAssemblies(loadedAssemblies).Any(c => c.Version == version);
        }

        private static IEnumerable<AssemblyName> GetWebPagesAssemblies(IEnumerable<AssemblyName> loadedAssemblies)
        {
            return (from otherName in loadedAssemblies
                    where NamesMatch(ThisAssemblyName, otherName, matchVersion: false)
                    select otherName);
        }

        /// <summary>
        /// Returns the version of a System.Web.WebPages.Deployment.dll if it is present in the bin and matches the name and 
        /// public key token of the current assembly.
        /// </summary>
        /// <returns>Version from bin if present, null otherwise.</returns>
        internal static Version GetVersionFromBin(string binDirectory, IFileSystem fileSystem, Func<string, AssemblyName> getAssemblyNameThunk = null)
        {
            // If a version of the assembly is present both in the bin and the GAC, the GAC would win.
            // To work around this, we'll look for a physical file on disk with the same name as the current assembly and load it to determine the version.
            // Determine if the Deployment assembly is present in the bin
            var assemblyInBin = Path.Combine(binDirectory, _binFileName);
            if (fileSystem.FileExists(assemblyInBin))
            {
                try
                {
                    getAssemblyNameThunk = getAssemblyNameThunk ?? AssemblyName.GetAssemblyName;
                    AssemblyName assemblyName = getAssemblyNameThunk(assemblyInBin);
                    if (NamesMatch(ThisAssemblyName, assemblyName, matchVersion: false))
                    {
                        return assemblyName.Version;
                    }
                }
                catch (BadImageFormatException)
                {
                    // Do nothing. 
                }
                catch (SecurityException)
                {
                    // Do nothing
                }
                catch (FileLoadException)
                {
                    // Do nothing.
                }
            }
            return null;
        }

        internal static bool NamesMatch(AssemblyName left, AssemblyName right, bool matchVersion)
        {
            return Equals(left.Name, right.Name) &&
                   Equals(left.CultureInfo, right.CultureInfo) &&
                   Enumerable.SequenceEqual(left.GetPublicKeyToken(), right.GetPublicKeyToken()) &&
                   (!matchVersion || Equals(left.Version, right.Version));
        }

        internal static IEnumerable<AssemblyName> GetLoadedAssemblies()
        {
            return AppDomain.CurrentDomain.GetAssemblies()
                .Select(GetAssemblyName)
                .ToList();
        }

        internal static IEnumerable<AssemblyName> GetAssembliesForVersion(Version version)
        {
            if (version == WebPagesV1Version)
            {
                return _version1AssemblyList;
            }
            return _versionCurrentAssemblyList;
        }

        private static AssemblyName GetAssemblyName(Assembly assembly)
        {
            return new AssemblyName(assembly.FullName);
        }

        private static AssemblyName GetFullName(string name, Version version, string publicKeyToken)
        {
            return new AssemblyName(String.Format(CultureInfo.InvariantCulture,
                                                  "{0}, Version={1}, Culture=neutral, PublicKeyToken={2}",
                                                  name, version, publicKeyToken));
        }

        internal static AssemblyName GetFullName(string name, Version version)
        {
            return GetFullName(name, version, SharedLibPublicKey);
        }

        public static IDictionary<string, Version> GetAssembliesMatchingOtherVersions(IDictionary<string, IEnumerable<string>> references)
        {
            var webPagesAssemblies = AssemblyUtils.GetAssembliesForVersion(AssemblyUtils.ThisAssemblyName.Version);
            if (references == null || webPagesAssemblies == null || !webPagesAssemblies.Any())
            {
                return new Dictionary<string, Version>(0);
            }

            var matchingVersions = from item in references
                                   let matchedVersion = GetMatchingVersion(webPagesAssemblies, item.Value)
                                   where matchedVersion != null
                                   select new KeyValuePair<string, Version>(item.Key, matchedVersion);
            return matchingVersions.ToDictionary(k => k.Key, k => k.Value);
        }

        private static Version GetMatchingVersion(IEnumerable<AssemblyName> webPagesAssemblies, IEnumerable<string> references)
        {
            // Return assemblies that match in name but not in version.
            var matchingVersions = from webPagesAssembly in webPagesAssemblies
                                   from referenceName in references
                                   let referencedAssembly = new AssemblyName(referenceName)
                                   where AssemblyUtils.NamesMatch(webPagesAssembly, referencedAssembly, matchVersion: false) && webPagesAssembly.Version != referencedAssembly.Version
                                   select referencedAssembly.Version;
            return matchingVersions.FirstOrDefault();
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/BuildManagerWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Compilation;

namespace System.Web.WebPages.Deployment
{
    internal sealed class BuildManagerWrapper : IBuildManager
    {
        /// <summary>
        /// Reads a special cached file from %WindDir%\Microsoft.NET\Framework\vx.x\ASP.NET Temporary Files\&lt;x&gt;\&lt;y&gt;\UserCache that is 
        /// available across AppDomain recycles.
        /// </summary>
        public Stream ReadCachedFile(string path)
        {
            return BuildManager.ReadCachedFile(path);
        }

        /// <summary>
        /// Creates or opens a special cached file that is created under  %WindDir%\Microsoft.NET\Framework\vx.x\ASP.NET Temporary Files\&lt;x&gt;\&lt;y&gt;\UserCache that is 
        /// available across AppDomain recycles.
        /// </summary>
        public Stream CreateCachedFile(string path)
        {
            return BuildManager.CreateCachedFile(path);
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/Common/IFileSystem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;

namespace Microsoft.Internal.Web.Utils
{
    internal interface IFileSystem
    {
        bool FileExists(string path);

        Stream ReadFile(string path);

        Stream OpenFile(string path);

        IEnumerable<string> EnumerateFiles(string root);
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/Common/PhysicalFileSystem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;

namespace Microsoft.Internal.Web.Utils
{
    internal sealed class PhysicalFileSystem : IFileSystem
    {
        public bool FileExists(string path)
        {
            return File.Exists(path);
        }

        public Stream ReadFile(string path)
        {
            return File.OpenRead(path);
        }

        public Stream OpenFile(string path)
        {
            string directory = Path.GetDirectoryName(path);
            EnsureDirectory(directory);
            return File.OpenWrite(path);
        }

        public IEnumerable<string> EnumerateFiles(string path)
        {
            return Directory.EnumerateFiles(path);
        }

        private static void EnsureDirectory(string path)
        {
            if (!Directory.Exists(path))
            {
                Directory.CreateDirectory(path);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc.
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File".
// You do not need to add suppressions to this file manually.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "System.Web.WebPages.Deployment", Justification = "Namespace is present to match assembly name")]


================================================
FILE: src/System.Web.WebPages.Deployment/IBuildManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.WebPages.Deployment
{
    internal interface IBuildManager
    {
        Stream CreateCachedFile(string fileName);

        Stream ReadCachedFile(string fileName);
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Caching;
using System.Web.Compilation;
using System.Web.Configuration;
using System.Web.WebPages.Deployment.Resources;
using Microsoft.Internal.Web.Utils;
using Microsoft.Web.Infrastructure;

namespace System.Web.WebPages.Deployment
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        /// <summary>
        /// Key used to indicate to tooling that the compile exception we throw to refresh the app domain originated from us so that they can deal with it correctly. 
        /// </summary>
        private const string ToolingIndicatorKey = "WebPages.VersionChange";

        // NOTE: Do not add public fields, methods, or other members to this class.
        // This class does not show up in Intellisense so members on it will not be
        // discoverable by users. Place new members on more appropriate classes that
        // relate to the public API (for example, a LoginUrl property should go on a
        // membership-related class).
        private static readonly IFileSystem _physicalFileSystem = new PhysicalFileSystem();

        private static bool _startWasCalled;

        public static void Start()
        {
            // Even though ASP.NET will only call each PreAppStart once, we sometimes internally call one PreAppStart from 
            // another PreAppStart to ensure that things get initialized in the right order. ASP.NET does not guarantee the 
            // order so we have to guard against multiple calls.
            // All Start calls are made on same thread, so no lock needed here.

            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            StartCore();
        }

        internal static bool StartCore()
        {
            var buildManager = new BuildManagerWrapper();
            NameValueCollection appSettings = WebConfigurationManager.AppSettings;
            Action<Version> loadWebPages = LoadWebPages;
            Action registerForChangeNotification = RegisterForChangeNotifications;
            IEnumerable<AssemblyName> loadedAssemblies = AssemblyUtils.GetLoadedAssemblies();

            return StartCore(_physicalFileSystem, HttpRuntime.AppDomainAppPath, HttpRuntime.BinDirectory, appSettings, loadedAssemblies,
                             buildManager, loadWebPages, registerForChangeNotification);
        }

        // Adds Parameter for unit tests
        internal static bool StartCore(IFileSystem fileSystem, string appDomainAppPath, string binDirectory, NameValueCollection appSettings, IEnumerable<AssemblyName> loadedAssemblies,
                                       IBuildManager buildManager, Action<Version> loadWebPages, Action registerForChangeNotification, Func<string, AssemblyName> getAssemblyNameThunk = null)
        {
            if (WebPagesDeployment.IsExplicitlyDisabled(appSettings))
            {
                // If WebPages is explicitly disabled, exit.
                Debug.WriteLine("WebPages Bootstrapper v{0}: not loading WebPages since it is disabled", AssemblyUtils.ThisAssemblyName.Version);
                return false;
            }

            Version maxWebPagesVersion = AssemblyUtils.GetMaxWebPagesVersion(loadedAssemblies);
            Debug.Assert(maxWebPagesVersion != null, "Function must return some max value.");
            if (AssemblyUtils.ThisAssemblyName.Version != maxWebPagesVersion)
            {
                // Always let the highest version determine what needs to be done. This would make future proofing simpler.
                Debug.WriteLine("WebPages Bootstrapper v{0}: Higher version v{1} is available.", AssemblyUtils.ThisAssemblyName.Version, maxWebPagesVersion);
                return false;
            }

            var webPagesEnabled = WebPagesDeployment.IsEnabled(fileSystem, appDomainAppPath, appSettings);
            Version binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, fileSystem, getAssemblyNameThunk);
            Version configVersion = WebPagesDeployment.GetVersionFromConfig(appSettings);
            Version version = configVersion ?? binVersion ?? AssemblyUtils.WebPagesV1Version;

            // Asserts to ensure unit tests are set up correctly. So essentially, we're unit testing the unit tests. 
            Debug.Assert(version != null, "GetVersion always returns a version");
            Debug.Assert(binVersion == null || binVersion <= maxWebPagesVersion, "binVersion cannot be higher than max version");

            if ((binVersion != null) && (binVersion != version))
            {
                // Determine if there's a version conflict. A conflict could occur if there's a version specified in the bin which is different from the version specified in the 
                // config that is different.
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, ConfigurationResources.WebPagesVersionConflict, version, binVersion));
            }
            else if (binVersion != null)
            {
                // The rest of the code is only meant to be executed if we are executing from the GAC.
                // If a version is bin deployed, we don't need to do anything special to bootstrap.
                return false;
            }
            else if (!webPagesEnabled)
            {
                Debug.WriteLine("WebPages Bootstrapper v{0}: WebPages not enabled, registering for change notifications", AssemblyUtils.ThisAssemblyName.Version);
                // Register for change notifications under the application root
                registerForChangeNotification();
                return false;
            }
            else if (!AssemblyUtils.IsVersionAvailable(loadedAssemblies, version))
            {
                if (version == AssemblyUtils.WebPagesV1Version && configVersion == null && binVersion == null)
                {
                    // No version was specified. We're implicitly assuming that the site is a v1 site. However, the user does not have V1 binaries available. 
                    throw new InvalidOperationException(ConfigurationResources.WebPagesImplicitVersionFailure);
                }
                else 
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, ConfigurationResources.WebPagesVersionNotFound, version, AssemblyUtils.ThisAssemblyName.Version));
                }
            }

            Debug.WriteLine("WebPages Bootstrapper v{0}: loading version {1}, loading WebPages", AssemblyUtils.ThisAssemblyName.Version, version);
            // If the version the application was compiled earlier was different, invalidate compilation results by adding a file to the bin.
            InvalidateCompilationResultsIfVersionChanged(buildManager, fileSystem, binDirectory, version);
            loadWebPages(version);
            return true;
        }

        /// <summary>
        /// WebPages stores the version to be compiled against in AppSettings as &gt;add key="webpages:version" value="1.0" /&lt;. 
        /// Changing values AppSettings does not cause recompilation therefore we could run into a state where we have files compiled against v1 but the application is 
        /// currently v2.
        /// </summary>
        private static void InvalidateCompilationResultsIfVersionChanged(IBuildManager buildManager, IFileSystem fileSystem, string binDirectory, Version currentVersion)
        {
            Version previousVersion = WebPagesDeployment.GetPreviousRuntimeVersion(buildManager);

            // Persist the current version number in BuildManager's cached file
            WebPagesDeployment.PersistRuntimeVersion(buildManager, currentVersion);

            if (previousVersion == null)
            {
                // Do nothing.
            }
            else if (previousVersion != currentVersion)
            {
                // If the previous runtime version is different, perturb the bin directory so that it forces recompilation.
                WebPagesDeployment.ForceRecompile(fileSystem, binDirectory);
                var httpCompileException = new HttpCompileException(ConfigurationResources.WebPagesVersionChanges);
                // Indicator for tooling
                httpCompileException.Data[ToolingIndicatorKey] = true;
                throw httpCompileException;
            }
        }

        // Copied from xsp\System\Web\Compilation\BuildManager.cs
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Copied from System.Web.dll")]
        internal static ICollection<MethodInfo> GetPreStartInitMethodsFromAssemblyCollection(IEnumerable<Assembly> assemblies)
        {
            List<MethodInfo> methods = new List<MethodInfo>();
            foreach (Assembly assembly in assemblies)
            {
                PreApplicationStartMethodAttribute[] attributes = null;
                try
                {
                    attributes = (PreApplicationStartMethodAttribute[])assembly.GetCustomAttributes(typeof(PreApplicationStartMethodAttribute), inherit: true);
                }
                catch
                {
                    // GetCustomAttributes invokes the constructors of the attributes, so it is possible that they might throw unexpected exceptions.
                    // (Dev10 bug 831981)
                }

                if (attributes != null && attributes.Length != 0)
                {
                    Debug.Assert(attributes.Length == 1);
                    PreApplicationStartMethodAttribute attribute = attributes[0];
                    Debug.Assert(attribute != null);

                    MethodInfo method = null;
                    // Ensure the Type on the attribute is in the same assembly as the attribute itself
                    if (attribute.Type != null && !String.IsNullOrEmpty(attribute.MethodName) && attribute.Type.Assembly == assembly)
                    {
                        method = FindPreStartInitMethod(attribute.Type, attribute.MethodName);
                    }

                    if (method != null)
                    {
                        methods.Add(method);
                    }

                    // No-op if the attribute is invalid
                    /*
                    else {
                        throw new HttpException(SR.GetString(SR.Invalid_PreApplicationStartMethodAttribute_value,
                            assembly.FullName,
                            (attribute.Type != null ? attribute.Type.FullName : String.Empty),
                            attribute.MethodName));
                    }
                    */
                }
            }
            return methods;
        }

        // Copied from xsp\System\Web\Compilation\BuildManager.cs
        internal static MethodInfo FindPreStartInitMethod(Type type, string methodName)
        {
            Debug.Assert(type != null);
            Debug.Assert(!String.IsNullOrEmpty(methodName));
            MethodInfo method = null;
            if (type.IsPublic)
            {
                // Verify that type is public to avoid allowing internal code execution. This implementation will not match
                // nested public types.
                method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.Static | BindingFlags.IgnoreCase,
                                        binder: null,
                                        types: Type.EmptyTypes,
                                        modifiers: null);
            }
            return method;
        }

        [SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "The cache disposes of the dependency")]
        private static void RegisterForChangeNotifications()
        {
            string physicalPath = HttpRuntime.AppDomainAppPath;

            CacheDependency cacheDependency = new CacheDependency(physicalPath, DateTime.UtcNow);
            var key = WebPagesDeployment.CacheKeyPrefix + physicalPath;

            HttpRuntime.Cache.Insert(key, physicalPath, cacheDependency,
                                     Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration,
                                     CacheItemPriority.NotRemovable, new CacheItemRemovedCallback(OnChanged));
        }

        private static void OnChanged(string key, object value, CacheItemRemovedReason reason)
        {
            // Only handle case when the dependency has changed.
            if (reason != CacheItemRemovedReason.DependencyChanged)
            {
                return;
            }

            // Scan the app root for a webpages file
            if (WebPagesDeployment.AppRootContainsWebPagesFile(_physicalFileSystem, HttpRuntime.AppDomainAppPath))
            {
                // Unload the app domain so we register plan9 when the app restarts
                InfrastructureHelper.UnloadAppDomain();
            }
            else
            {
                // We need to re-register since the item was removed from the cache
                RegisterForChangeNotifications();
            }
        }

        private static void LoadWebPages(Version version)
        {
            IEnumerable<AssemblyName> assemblyList = AssemblyUtils.GetAssembliesForVersion(version);
            var assemblies = assemblyList.Select(LoadAssembly);

            foreach (var asm in assemblies)
            {
                BuildManager.AddReferencedAssembly(asm);
            }

            foreach (var m in GetPreStartInitMethodsFromAssemblyCollection(assemblies))
            {
                m.Invoke(null, null);
            }
        }

        private static Assembly LoadAssembly(AssemblyName name)
        {
            return Assembly.Load(name);
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using System.Web.WebPages.Deployment;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("System.Web.WebPages.Deployment")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.WebPages.Deployment.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]


================================================
FILE: src/System.Web.WebPages.Deployment/Resources/ConfigurationResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.269
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.WebPages.Deployment.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class ConfigurationResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal ConfigurationResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.WebPages.Deployment.Resources.ConfigurationResources", typeof(ConfigurationResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;InstallPath&quot; name was not found in the Web Pages registry key &quot;{0}&quot;..
        /// </summary>
        internal static string InstallPathNotFound {
            get {
                return ResourceManager.GetString("InstallPathNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not determine which version of ASP.NET Web Pages to use.
        ///
        ///In order to use this site, specify a version in the site’s web.config file. For more information, see the following article on the Microsoft support site: http://go.microsoft.com/fwlink/?LinkId=254126.
        /// </summary>
        internal static string WebPagesImplicitVersionFailure {
            get {
                return ResourceManager.GetString("WebPagesImplicitVersionFailure", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Web Pages registry key &quot;{0}&quot; does not exist..
        /// </summary>
        internal static string WebPagesRegistryKeyDoesNotExist {
            get {
                return ResourceManager.GetString("WebPagesRegistryKeyDoesNotExist", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Changes were detected in the Web Pages runtime version that require your application to be recompiled. Refresh your browser window to continue..
        /// </summary>
        internal static string WebPagesVersionChanges {
            get {
                return ResourceManager.GetString("WebPagesVersionChanges", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Conflicting versions of ASP.NET Web Pages detected: specified version is &quot;{0}&quot;, but the version in bin is &quot;{1}&quot;. To continue, remove files from the application&apos;s bin directory or remove the version specification in web.config..
        /// </summary>
        internal static string WebPagesVersionConflict {
            get {
                return ResourceManager.GetString("WebPagesVersionConflict", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specified Web Pages version &quot;{0}&quot; could not be found. Update your web.config to specify a different version. Current version: &quot;{1}&quot;..
        /// </summary>
        internal static string WebPagesVersionNotFound {
            get {
                return ResourceManager.GetString("WebPagesVersionNotFound", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/Resources/ConfigurationResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="InstallPathNotFound" xml:space="preserve">
    <value>The "InstallPath" name was not found in the Web Pages registry key "{0}".</value>
  </data>
  <data name="WebPagesImplicitVersionFailure" xml:space="preserve">
    <value>Could not determine which version of ASP.NET Web Pages to use.

In order to use this site, specify a version in the site’s web.config file. For more information, see the following article on the Microsoft support site: http://go.microsoft.com/fwlink/?LinkId=254126</value>
  </data>
  <data name="WebPagesRegistryKeyDoesNotExist" xml:space="preserve">
    <value>The Web Pages registry key "{0}" does not exist.</value>
  </data>
  <data name="WebPagesVersionChanges" xml:space="preserve">
    <value>Changes were detected in the Web Pages runtime version that require your application to be recompiled. Refresh your browser window to continue.</value>
  </data>
  <data name="WebPagesVersionConflict" xml:space="preserve">
    <value>Conflicting versions of ASP.NET Web Pages detected: specified version is "{0}", but the version in bin is "{1}". To continue, remove files from the application's bin directory or remove the version specification in web.config.</value>
  </data>
  <data name="WebPagesVersionNotFound" xml:space="preserve">
    <value>Specified Web Pages version "{0}" could not be found. Update your web.config to specify a different version. Current version: "{1}".</value>
  </data>
</root>

================================================
FILE: src/System.Web.WebPages.Deployment/System.Web.WebPages.Deployment.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{22BABB60-8F02-4027-AFFC-ACF069954536}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>System.Web.WebPages.Deployment</RootNamespace>
    <AssemblyName>System.Web.WebPages.Deployment</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Microsoft.Web.Infrastructure.1.0.0.0\lib\net40\Microsoft.Web.Infrastructure.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.configuration" />
    <Reference Include="System.Web" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="AppDomainHelper.cs" />
    <Compile Include="AssemblyUtils.cs" />
    <Compile Include="BuildManagerWrapper.cs" />
    <Compile Include="Common\IFileSystem.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Common\PhysicalFileSystem.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="IBuildManager.cs" />
    <Compile Include="Resources\ConfigurationResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>ConfigurationResources.resx</DependentUpon>
    </Compile>
    <Compile Include="WebPagesDeployment.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\ConfigurationResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>ConfigurationResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.WebPages.Deployment/WebPagesDeployment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Configuration;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web.Configuration;
using System.Web.Hosting;
using System.Web.WebPages.Deployment.Resources;
using Microsoft.Internal.Web.Utils;
using Microsoft.Win32;

namespace System.Web.WebPages.Deployment
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class WebPagesDeployment
    {
        private const string AppSettingsVersionKey = "webpages:Version";
        private const string AppSettingsEnabledKey = "webpages:Enabled";

        /// <summary>
        /// File name for a temporary file that we drop in bin to force recompilation.
        /// </summary>
        private const string ForceRecompilationFile = "WebPagesRecompilation.deleteme";

        private const string WebPagesRegistryKey = @"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\ASP.NET Web Pages\v{0}.{1}";
        internal static readonly string CacheKeyPrefix = "__System.Web.WebPages.Deployment__";
        private static readonly string[] _webPagesExtensions = new[] { ".cshtml", ".vbhtml" };
        private static readonly object _installPathNotFound = new object();
        private static readonly IFileSystem _fileSystem = new PhysicalFileSystem();

        /// <param name="path">Physical or virtual path to a directory where we need to determine the version of WebPages to be used.</param>
        /// <remarks>
        /// In a non-hosted scenario, this method would only look at a web.config that is present at the current path. Any config settings at an
        /// ancestor directory would not be considered.
        /// If we are unable to determine a version, we would assume that this is a v1 app.
        /// </remarks>
        public static Version GetVersionWithoutEnabledCheck(string path)
        {
            return GetVersionWithoutEnabledCheckInternal(path, AssemblyUtils.WebPagesV1Version);
        }

        public static Version GetExplicitWebPagesVersion(string path)
        {
            return GetVersionWithoutEnabledCheckInternal(path, defaultVersion: null);
        }

        [Obsolete("This method is obsolete and is meant for legacy code. Use GetVersionWithoutEnabled instead.")]
        public static Version GetVersion(string path)
        {
            return GetObsoleteVersionInternal(path, GetAppSettings(path), new PhysicalFileSystem());
        }

        /// <remarks>
        /// This is meant to test an obsolete method. Don't use this!
        /// </remarks>
        internal static Version GetObsoleteVersionInternal(string path, NameValueCollection configuration, IFileSystem fileSystem)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }

            var binDirectory = GetBinDirectory(path);
            var binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, _fileSystem);
            var version = GetVersionInternal(configuration, binVersion, defaultVersion: null);

            if (version != null)
            {
                // If a webpages version is available in config or bin, return it.
                return version;
            }
            else if (AppRootContainsWebPagesFile(fileSystem, path))
            {
                // If the path points to a WebPages site, return v1 as a fixed version.
                return AssemblyUtils.WebPagesV1Version;
            }
            return null;
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This operation might be expensive since it has to reflect over Assembly names.")]
        public static Version GetMaxVersion()
        {
            return AssemblyUtils.GetMaxWebPagesVersion();
        }

        /// <summary>
        /// Determines if Asp.Net Web Pages is enabled.
        /// Web Pages is enabled if there's a webPages:Enabled key in AppSettings is set to "true" or if there's a cshtml file in the current path
        /// and the key is not present.
        /// </summary>
        /// <param name="path">The path at which to determine if web pages is enabled.</param>
        /// <remarks>
        /// In a non-hosted scenario, this method would only look at a web.config that is present at the current path. Any config settings at an
        /// ancestor directory would not be considered.
        /// </remarks>
        public static bool IsEnabled(string path)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }

            return IsEnabled(_fileSystem, path, GetAppSettings(path));
        }

        /// <remarks>
        /// In a non-hosted scenario, this method would only look at a web.config that is present at the current path. Any config settings at an
        /// ancestor directory would not be considered.
        /// </remarks>
        public static bool IsExplicitlyDisabled(string path)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }
            return IsExplicitlyDisabled(GetAppSettings(path));
        }

        [EditorBrowsable(EditorBrowsableState.Never)]
        public static IDictionary<string, Version> GetIncompatibleDependencies(string appPath)
        {
            if (String.IsNullOrEmpty(appPath))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "appPath");
            }
            var configFilePath = Path.Combine(appPath, "web.config");

            var assemblyReferences = AppDomainHelper.GetBinAssemblyReferences(appPath, configFilePath);
            return AssemblyUtils.GetAssembliesMatchingOtherVersions(assemblyReferences);
        }

        internal static bool IsExplicitlyDisabled(NameValueCollection appSettings)
        {
            bool? enabled = GetEnabled(appSettings);
            return enabled.HasValue && enabled.Value == false;
        }

        internal static bool IsEnabled(IFileSystem fileSystem, string path, NameValueCollection appSettings)
        {
            bool? enabled = GetEnabled(appSettings);
            if (!enabled.HasValue)
            {
                return AppRootContainsWebPagesFile(fileSystem, path);
            }
            return enabled.Value;
        }

        /// <summary>
        /// Returns the value for webPages:Enabled AppSetting value in web.config.
        /// </summary>
        private static bool? GetEnabled(NameValueCollection appSettings)
        {
            string enabledSetting = appSettings.Get(AppSettingsEnabledKey);
            if (String.IsNullOrEmpty(enabledSetting))
            {
                return null;
            }
            else
            {
                return Boolean.Parse(enabledSetting);
            }
        }

        /// <summary>
        /// Returns the version of WebPages to be used for a specified path.
        /// </summary>
        /// <remarks>
        /// This method would always returns a value regardless of web pages is explicitly disabled (via config) or implicitly disabled (by virtue of not having a cshtml file) at 
        /// the specified path.
        /// </remarks>
        internal static Version GetVersionInternal(NameValueCollection appSettings, Version binVersion, Version defaultVersion)
        {
            // Return version values with the following precedence: 
            // 1) Version in config
            // 2) Version in bin
            // 3) defaultVersion.
            return GetVersionFromConfig(appSettings) ?? binVersion ?? defaultVersion;
        }

        private static Version GetVersionWithoutEnabledCheckInternal(string path, Version defaultVersion)
        {
            if (String.IsNullOrEmpty(path))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "path");
            }

            var binDirectory = GetBinDirectory(path);
            var binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, _fileSystem);

            return GetVersionInternal(GetAppSettings(path), binVersion, defaultVersion);
        }

        /// <summary>
        /// Gets full path to a folder that contains ASP.NET WebPages assemblies for a given version. Used by
        /// WebMatrix and Visual Studio so they know what to copy to an app's Bin folder or deploy to a hoster. 
        /// </summary>
        public static string GetAssemblyPath(Version version)
        {
            if (version == null)
            {
                throw new ArgumentNullException("version");
            }

            string webPagesRegistryKey = String.Format(CultureInfo.InvariantCulture, WebPagesRegistryKey, version.Major, version.Minor);

            object installPath = Registry.GetValue(webPagesRegistryKey, "InstallPath", _installPathNotFound);

            if (installPath == null)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                  ConfigurationResources.WebPagesRegistryKeyDoesNotExist, webPagesRegistryKey));
            }
            else if (installPath == _installPathNotFound)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                  ConfigurationResources.InstallPathNotFound, webPagesRegistryKey));
            }

            return Path.Combine((string)installPath, "Assemblies");
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This operation might be expensive since it has to reflect over Assembly names.")]
        public static IEnumerable<AssemblyName> GetWebPagesAssemblies()
        {
            return AssemblyUtils.GetAssembliesForVersion(AssemblyUtils.ThisAssemblyName.Version);
        }

        private static NameValueCollection GetAppSettings(string path)
        {
            if (path.StartsWith("~/", StringComparison.Ordinal))
            {
                // Path is virtual, assume we're hosted
                return (NameValueCollection)WebConfigurationManager.GetSection("appSettings", path);
            }
            else
            {
                // Path is physical, map it to an application
                WebConfigurationFileMap fileMap = new WebConfigurationFileMap();
                fileMap.VirtualDirectories.Add("/", new VirtualDirectoryMapping(path, true));
                var config = WebConfigurationManager.OpenMappedWebConfiguration(fileMap, "/");

                var appSettingsSection = config.AppSettings;
                var appSettings = new NameValueCollection();

                foreach (KeyValueConfigurationElement element in appSettingsSection.Settings)
                {
                    appSettings.Add(element.Key, element.Value);
                }
                return appSettings;
            }
        }

        internal static Version GetVersionFromConfig(NameValueCollection appSettings)
        {
            string version = appSettings.Get(AppSettingsVersionKey);
            // Version will be null if the config section is registered but not present in app web.config.
            if (!String.IsNullOrEmpty(version))
            {
                // Build and Revision are optional in config but required by Fusion, so we set them to 0 if unspecified in config.
                // Valid in config: "1.0", "1.0.0", "1.0.0.0"
                var fullVersion = new Version(version);
                if (fullVersion.Build == -1 || fullVersion.Revision == -1)
                {
                    fullVersion = new Version(fullVersion.Major, fullVersion.Minor,
                                              fullVersion.Build == -1 ? 0 : fullVersion.Build,
                                              fullVersion.Revision == -1 ? 0 : fullVersion.Revision);
                }
                return fullVersion;
            }
            return null;
        }

        internal static bool AppRootContainsWebPagesFile(IFileSystem fileSystem, string path)
        {
            var files = fileSystem.EnumerateFiles(path);
            return files.Any(IsWebPagesFile);
        }

        private static bool IsWebPagesFile(string file)
        {
            var extension = Path.GetExtension(file);
            return _webPagesExtensions.Contains(extension, StringComparer.OrdinalIgnoreCase);
        }

        /// <summary>
        /// HttpRuntime.BinDirectory is unavailable in design time and throws if we try to access it. To workaround this, if we aren't hosted,
        /// we will assume that the path that was passed to us is the application root.
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        private static string GetBinDirectory(string path)
        {
            if (HostingEnvironment.IsHosted)
            {
                return HttpRuntime.BinDirectory;
            }
            return Path.Combine(path, "bin");
        }

        /// <summary>
        /// Reads a previously persisted version number from build manager's cached directory.
        /// </summary>
        /// <returns>Null if a previous version number does not exist or is not a valid version number, read version number otherwise.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to throw an exception from this method.")]
        internal static Version GetPreviousRuntimeVersion(IBuildManager buildManagerFileSystem)
        {
            string fileName = GetCachedFileName();
            try
            {
                Stream stream = buildManagerFileSystem.ReadCachedFile(fileName);
                if (stream == null)
                {
                    return null;
                }

                using (StreamReader reader = new StreamReader(stream))
                {
                    string text = reader.ReadLine();
                    Version version;
                    if (Version.TryParse(text, out version))
                    {
                        return version;
                    }
                }
            }
            catch
            {
            }
            return null;
        }

        /// <summary>
        /// Persists the version number in a file under the build manager's cached directory.
        /// </summary>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to throw an exception from this method.")]
        internal static void PersistRuntimeVersion(IBuildManager buildManager, Version version)
        {
            string fileName = GetCachedFileName();
            try
            {
                Stream stream = buildManager.CreateCachedFile(fileName);
                using (var writer = new StreamWriter(stream))
                {
                    writer.WriteLine(version.ToString());
                }
            }
            catch
            {
            }
        }

        /// <summary>
        /// Forces recompilation of the application by dropping a file under bin.
        /// </summary>
        /// <param name="fileSystem">File system instance used to write a file to bin directory.</param>
        /// <param name="binDirectory">Path to bin directory of the application</param>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "We never want to throw an exception from this method.")]
        internal static void ForceRecompile(IFileSystem fileSystem, string binDirectory)
        {
            var fileToWrite = Path.Combine(binDirectory, ForceRecompilationFile);
            try
            {
                // Note: We should use BuildManager::ForceRecompile once that method makes it into System.Web.
                using (var writer = new StreamWriter(fileSystem.OpenFile(fileToWrite)))
                {
                    writer.WriteLine();
                }
            }
            catch
            {
            }
        }

        /// <summary>
        /// Name of the the temporary file used by BuildManager.CreateCachedFile / BuildManager.ReadCachedFile where we cache WebPages's version number. 
        /// </summary>
        /// <returns></returns>
        private static string GetCachedFileName()
        {
            return typeof(WebPagesDeployment).Namespace;
        }

        private static string RemoveTrailingSlash(string path)
        {
            if (!String.IsNullOrEmpty(path))
            {
                path = path.TrimEnd(Path.DirectorySeparatorChar);
            }
            return path;
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Deployment/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
</packages>

================================================
FILE: src/System.Web.WebPages.Razor/AssemblyBuilderWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.Compilation;

namespace System.Web.WebPages.Razor
{
    internal sealed class AssemblyBuilderWrapper : IAssemblyBuilder
    {
        public AssemblyBuilderWrapper(AssemblyBuilder builder)
        {
            if (builder == null)
            {
                throw new ArgumentNullException("builder");
            }

            InnerBuilder = builder;
        }

        internal AssemblyBuilder InnerBuilder { get; set; }

        public void AddCodeCompileUnit(BuildProvider buildProvider, CodeCompileUnit compileUnit)
        {
            InnerBuilder.AddCodeCompileUnit(buildProvider, compileUnit);
        }

        public void GenerateTypeFactory(string typeName)
        {
            InnerBuilder.GenerateTypeFactory(typeName);
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/CompilingPathEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages.Razor
{
    public class CompilingPathEventArgs : EventArgs
    {
        public CompilingPathEventArgs(string virtualPath, WebPageRazorHost host)
        {
            VirtualPath = virtualPath;
            Host = host;
        }

        public string VirtualPath { get; private set; }
        public WebPageRazorHost Host { get; set; }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/Configuration/HostSection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Configuration;

namespace System.Web.WebPages.Razor.Configuration
{
    public class HostSection : ConfigurationSection
    {
        public static readonly string SectionName = RazorWebSectionGroup.GroupName + "/host";

        private static readonly ConfigurationProperty _typeProperty =
            new ConfigurationProperty("factoryType",
                                      typeof(string),
                                      null,
                                      ConfigurationPropertyOptions.IsRequired);

        private bool _factoryTypeSet = false;
        private string _factoryType;

        [ConfigurationProperty("factoryType", IsRequired = true, DefaultValue = null)]
        public string FactoryType
        {
            get { return _factoryTypeSet ? _factoryType : (string)this[_typeProperty]; }
            set
            {
                _factoryType = value;
                _factoryTypeSet = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/Configuration/RazorPagesSection.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Configuration;
using System.Diagnostics.CodeAnalysis;
using System.Web.Configuration;

namespace System.Web.WebPages.Razor.Configuration
{
    public class RazorPagesSection : ConfigurationSection
    {
        public static readonly string SectionName = RazorWebSectionGroup.GroupName + "/pages";

        private static readonly ConfigurationProperty _pageBaseTypeProperty =
            new ConfigurationProperty("pageBaseType",
                                      typeof(string),
                                      null,
                                      ConfigurationPropertyOptions.IsRequired);

        private static readonly ConfigurationProperty _namespacesProperty =
            new ConfigurationProperty("namespaces",
                                      typeof(NamespaceCollection),
                                      null,
                                      ConfigurationPropertyOptions.IsRequired);

        private bool _pageBaseTypeSet = false;
        private bool _namespacesSet = false;

        private string _pageBaseType;
        private NamespaceCollection _namespaces;

        [ConfigurationProperty("pageBaseType", IsRequired = true)]
        public string PageBaseType
        {
            get { return _pageBaseTypeSet ? _pageBaseType : (string)this[_pageBaseTypeProperty]; }
            set
            {
                _pageBaseType = value;
                _pageBaseTypeSet = true;
            }
        }

        [ConfigurationProperty("namespaces", IsRequired = true)]
        [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "Being able to set this property is extremely useful for third-parties who are testing components which interact with the Razor configuration system")]
        public NamespaceCollection Namespaces
        {
            get { return _namespacesSet ? _namespaces : (NamespaceCollection)this[_namespacesProperty]; }
            set
            {
                _namespaces = value;
                _namespacesSet = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/Configuration/RazorWebSectionGroup.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Configuration;

namespace System.Web.WebPages.Razor.Configuration
{
    public class RazorWebSectionGroup : ConfigurationSectionGroup
    {
        public static readonly string GroupName = "system.web.webPages.razor";

        // Use flags instead of null values since tests may want to set the property to null
        private bool _hostSet = false;
        private bool _pagesSet = false;

        private HostSection _host;
        private RazorPagesSection _pages;

        [ConfigurationProperty("host", IsRequired = false)]
        public HostSection Host
        {
            get { return _hostSet ? _host : (HostSection)Sections["host"]; }
            set
            {
                _host = value;
                _hostSet = true;
            }
        }

        [ConfigurationProperty("pages", IsRequired = false)]
        public RazorPagesSection Pages
        {
            get { return _pagesSet ? _pages : (RazorPagesSection)Sections["pages"]; }
            set
            {
                _pages = value;
                _pagesSet = true;
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc.
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File".
// You do not need to add suppressions to this file manually.


================================================
FILE: src/System.Web.WebPages.Razor/HostingEnvironmentWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Hosting;

namespace System.Web.WebPages.Razor
{
    internal sealed class HostingEnvironmentWrapper : IHostingEnvironment
    {
        public string MapPath(string virtualPath)
        {
            return HostingEnvironment.MapPath(virtualPath);
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/IAssemblyBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.Compilation;

namespace System.Web.WebPages.Razor
{
    internal interface IAssemblyBuilder
    {
        void AddCodeCompileUnit(BuildProvider buildProvider, CodeCompileUnit compileUnit);
        void GenerateTypeFactory(string typeName);
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/IHostingEnvironment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.WebPages.Razor
{
    internal interface IHostingEnvironment
    {
        string MapPath(string virtualPath);
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Web.Compilation;

namespace System.Web.WebPages.Razor
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        // NOTE: Do not add public fields, methods, or other members to this class.
        // This class does not show up in Intellisense so members on it will not be
        // discoverable by users. Place new members on more appropriate classes that
        // relate to the public API (for example, a LoginUrl property should go on a
        // membership-related class).

        private static bool _startWasCalled;

        public static void Start()
        {
            // Even though ASP.NET will only call each PreAppStart once, we sometimes internally call one PreAppStart from 
            // another PreAppStart to ensure that things get initialized in the right order. ASP.NET does not guarantee the 
            // order so we have to guard against multiple calls.
            // All Start calls are made on same thread, so no lock needed here.

            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            BuildProvider.RegisterBuildProvider(".cshtml", typeof(RazorBuildProvider));
            BuildProvider.RegisterBuildProvider(".vbhtml", typeof(RazorBuildProvider));
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using System.Web.WebPages.Razor;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("System.Web.WebPages.Razor")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("System.Web.WebPages.Razor.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]


================================================
FILE: src/System.Web.WebPages.Razor/RazorBuildProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Security;
using System.Web.Compilation;
using System.Web.Razor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.WebPages.Razor
{
    [BuildProviderAppliesTo(BuildProviderAppliesTo.Web | BuildProviderAppliesTo.Code)]
    public class RazorBuildProvider : BuildProvider
    {
        private static bool? _isFullTrust;
        private CodeCompileUnit _generatedCode = null;
        private WebPageRazorHost _host = null;
        private IList _virtualPathDependencies;
        private IAssemblyBuilder _assemblyBuilder;
        public static event EventHandler<CodeGenerationCompleteEventArgs> CodeGenerationCompleted;

        internal event EventHandler<CodeGenerationCompleteEventArgs> CodeGenerationCompletedInternal
        {
            add { _codeGenerationCompletedInternal += value; }
            remove { _codeGenerationCompletedInternal -= value; }
        }

        public static event EventHandler CodeGenerationStarted;

        /// <summary>
        /// For unit testing.
        /// </summary>
        internal event EventHandler CodeGenerationStartedInternal
        {
            add { _codeGenerationStartedInternal += value; }
            remove { _codeGenerationStartedInternal -= value; }
        }

        public static event EventHandler<CompilingPathEventArgs> CompilingPath;

        /// <summary>
        /// For unit testing
        /// </summary>
        private event EventHandler<CodeGenerationCompleteEventArgs> _codeGenerationCompletedInternal;
        private event EventHandler _codeGenerationStartedInternal;

        internal WebPageRazorHost Host
        {
            get
            {
                if (_host == null)
                {
                    _host = CreateHost();
                }
                return _host;
            }
            set { _host = value; }
        }

        // Returns the base dependencies and any dependencies added via AddVirtualPathDependencies
        public override ICollection VirtualPathDependencies
        {
            get
            {
                if (_virtualPathDependencies != null)
                {
                    // Return a readonly wrapper so as to prevent users from modifying the collection directly.
                    return ArrayList.ReadOnly(_virtualPathDependencies);
                }
                else
                {
                    return base.VirtualPathDependencies;
                }
            }
        }

        public new string VirtualPath
        {
            get { return base.VirtualPath; }
        }

        public AssemblyBuilder AssemblyBuilder
        {
            get
            {
                var wrapper = _assemblyBuilder as AssemblyBuilderWrapper;
                if (wrapper != null)
                {
                    return wrapper.InnerBuilder;
                }
                else
                {
                    return null;
                }
            }
        }

        // For unit testing
        internal IAssemblyBuilder AssemblyBuilderInternal
        {
            get { return _assemblyBuilder; }
        }

        internal CodeCompileUnit GeneratedCode
        {
            get
            {
                EnsureGeneratedCode();
                return _generatedCode;
            }
            set { _generatedCode = value; }
        }

        public override CompilerType CodeCompilerType
        {
            get
            {
                EnsureGeneratedCode();
                CompilerType compilerType = GetDefaultCompilerTypeForLanguage(Host.CodeLanguage.LanguageName);
                if (_isFullTrust != false && Host.DefaultDebugCompilation)
                {
                    try
                    {
                        SetIncludeDebugInfoFlag(compilerType);
                        _isFullTrust = true;
                    }
                    catch (SecurityException)
                    {
                        _isFullTrust = false;
                    }
                }
                return compilerType;
            }
        }

        public void AddVirtualPathDependency(string dependency)
        {
            if (_virtualPathDependencies == null)
            {
                // Initialize the collection containing the base dependencies
                _virtualPathDependencies = new ArrayList(base.VirtualPathDependencies);
            }

            _virtualPathDependencies.Add(dependency);
        }

        public override Type GetGeneratedType(CompilerResults results)
        {
            return results.CompiledAssembly.GetType(String.Format(CultureInfo.CurrentCulture, "{0}.{1}", Host.DefaultNamespace, Host.DefaultClassName));
        }

        public override void GenerateCode(AssemblyBuilder assemblyBuilder)
        {
            GenerateCodeCore(new AssemblyBuilderWrapper(assemblyBuilder));
        }

        internal virtual void GenerateCodeCore(IAssemblyBuilder assemblyBuilder)
        {
            OnCodeGenerationStarted(assemblyBuilder);
            assemblyBuilder.AddCodeCompileUnit(this, GeneratedCode);
            assemblyBuilder.GenerateTypeFactory(String.Format(CultureInfo.InvariantCulture, "{0}.{1}", Host.DefaultNamespace, Host.DefaultClassName));
        }

        protected internal virtual TextReader InternalOpenReader()
        {
            return OpenReader();
        }

        protected internal virtual WebPageRazorHost CreateHost()
        {
            // Get the host from config
            WebPageRazorHost configuredHost = GetHostFromConfig();

            // Fire the event
            CompilingPathEventArgs args = new CompilingPathEventArgs(VirtualPath, configuredHost);
            OnBeforeCompilePath(args);

            // Return the host provided in the args, which may have been changed by the handler
            return args.Host;
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method performs significant work and a property would not be appropriate")]
        protected internal virtual WebPageRazorHost GetHostFromConfig()
        {
            return WebRazorHostFactory.CreateHostFromConfig(VirtualPath);
        }

        protected virtual void OnBeforeCompilePath(CompilingPathEventArgs args)
        {
            EventHandler<CompilingPathEventArgs> handler = CompilingPath;
            if (handler != null)
            {
                handler(this, args);
            }
        }

        private void OnCodeGenerationStarted(IAssemblyBuilder assemblyBuilder)
        {
            _assemblyBuilder = assemblyBuilder;
            EventHandler handler = _codeGenerationStartedInternal ?? CodeGenerationStarted;
            if (handler != null)
            {
                handler(this, null);
            }
        }

        private void OnCodeGenerationCompleted(CodeCompileUnit generatedCode)
        {
            EventHandler<CodeGenerationCompleteEventArgs> handler = _codeGenerationCompletedInternal ?? CodeGenerationCompleted;
            if (handler != null)
            {
                handler(this, new CodeGenerationCompleteEventArgs(Host.VirtualPath, Host.PhysicalPath, generatedCode));
            }
        }

        private void EnsureGeneratedCode()
        {
            if (_generatedCode == null)
            {
                RazorTemplateEngine engine = new RazorTemplateEngine(Host);
                GeneratorResults results = null;
                using (TextReader reader = InternalOpenReader())
                {
                    results = engine.GenerateCode(reader, className: null, rootNamespace: null, sourceFileName: Host.PhysicalPath);
                }
                if (!results.Success)
                {
                    throw CreateExceptionFromParserError(results.ParserErrors.Last(), VirtualPath);
                }
                _generatedCode = results.GeneratedCode;

                // Run the code gen complete event
                OnCodeGenerationCompleted(_generatedCode);
            }
        }

        private static HttpParseException CreateExceptionFromParserError(RazorError error, string virtualPath)
        {
            return new HttpParseException(error.Message + Environment.NewLine, null, virtualPath, null, error.Location.LineIndex + 1);
        }

        [SuppressMessage("Microsoft.Security", "CA2141:TransparentMethodsMustNotSatisfyLinkDemandsFxCopRule", Justification = "We are catching the SecurityException to detect medium trust")]
        private static void SetIncludeDebugInfoFlag(CompilerType compilerType)
        {
            compilerType.CompilerParameters.IncludeDebugInformation = true;
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/Resources/RazorWebResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.1
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.WebPages.Razor.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class RazorWebResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal RazorWebResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.WebPages.Razor.Resources.RazorWebResources", typeof(RazorWebResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not determine the code language for &quot;{0}&quot;..
        /// </summary>
        internal static string BuildProvider_No_CodeLanguageService_For_Path {
            get {
                return ResourceManager.GetString("BuildProvider_No_CodeLanguageService_For_Path", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Could not locate Razor Host Factory type: {0}.
        /// </summary>
        internal static string Could_Not_Locate_FactoryType {
            get {
                return ResourceManager.GetString("Could_Not_Locate_FactoryType", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/Resources/RazorWebResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="BuildProvider_No_CodeLanguageService_For_Path" xml:space="preserve">
    <value>Could not determine the code language for "{0}".</value>
  </data>
  <data name="Could_Not_Locate_FactoryType" xml:space="preserve">
    <value>Could not locate Razor Host Factory type: {0}</value>
  </data>
</root>

================================================
FILE: src/System.Web.WebPages.Razor/System.Web.WebPages.Razor.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>System.Web.WebPages.Razor</RootNamespace>
    <AssemblyName>System.Web.WebPages.Razor</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Web" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="AssemblyBuilderWrapper.cs" />
    <Compile Include="CompilingPathEventArgs.cs" />
    <Compile Include="Configuration\HostSection.cs" />
    <Compile Include="Configuration\RazorPagesSection.cs" />
    <Compile Include="Configuration\RazorWebSectionGroup.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="HostingEnvironmentWrapper.cs" />
    <Compile Include="IAssemblyBuilder.cs" />
    <Compile Include="IHostingEnvironment.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="RazorBuildProvider.cs" />
    <Compile Include="WebRazorHostFactory.cs" />
    <Compile Include="WebCodeRazorHost.cs" />
    <Compile Include="WebPageRazorHost.cs" />
    <Compile Include="Resources\RazorWebResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>RazorWebResources.resx</DependentUpon>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\RazorWebResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>RazorWebResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/System.Web.WebPages.Razor/WebCodeRazorHost.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Linq;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;

namespace System.Web.WebPages.Razor
{
    public class WebCodeRazorHost : WebPageRazorHost
    {
        private const string AppCodeDir = "App_Code";
        private const string HttpContextAccessorName = "Context";
        private static readonly string _helperPageBaseType = typeof(HelperPage).FullName;

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The code path is safe, it is a property setter and not dependent on other state")]
        public WebCodeRazorHost(string virtualPath)
            : base(virtualPath)
        {
            DefaultBaseClass = _helperPageBaseType;
            DefaultNamespace = DetermineNamespace(virtualPath);
            DefaultDebugCompilation = false;
            StaticHelpers = true;
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The code path is safe, it is a property setter and not dependent on other state")]
        public WebCodeRazorHost(string virtualPath, string physicalPath)
            : base(virtualPath, physicalPath)
        {
            DefaultBaseClass = _helperPageBaseType;
            DefaultNamespace = DetermineNamespace(virtualPath);
            DefaultDebugCompilation = false;
            StaticHelpers = true;
        }

        public override void PostProcessGeneratedCode(CodeGeneratorContext context)
        {
            base.PostProcessGeneratedCode(context);

            // Yank out the execute method (ignored in Razor Web Code pages)
            context.GeneratedClass.Members.Remove(context.TargetMethod);

            // Make ApplicationInstance static
            CodeMemberProperty appInstanceProperty =
                context.GeneratedClass.Members
                    .OfType<CodeMemberProperty>()
                    .Where(p => ApplicationInstancePropertyName
                                    .Equals(p.Name))
                    .SingleOrDefault();

            if (appInstanceProperty != null)
            {
                appInstanceProperty.Attributes |= MemberAttributes.Static;
            }
        }

        protected override string GetClassName(string virtualPath)
        {
            return ParserHelpers.SanitizeClassName(Path.GetFileNameWithoutExtension(virtualPath));
        }

        private static string DetermineNamespace(string virtualPath)
        {
            // Normailzize the virtual path
            virtualPath = virtualPath.Replace(Path.DirectorySeparatorChar, '/');

            // Get the directory
            virtualPath = GetDirectory(virtualPath);

            // Skip the App_Code segment if any
            int appCodeIndex = virtualPath.IndexOf(AppCodeDir, StringComparison.OrdinalIgnoreCase);
            if (appCodeIndex != -1)
            {
                virtualPath = virtualPath.Substring(appCodeIndex + AppCodeDir.Length);
            }

            // Get the segments removing any empty entries
            IEnumerable<string> segments = virtualPath.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);

            if (!segments.Any())
            {
                return WebDefaultNamespace;
            }

            return WebDefaultNamespace + "." + String.Join(".", segments);
        }

        private static string GetDirectory(string virtualPath)
        {
            int lastSlash = virtualPath.LastIndexOf('/');
            if (lastSlash != -1)
            {
                return virtualPath.Substring(0, lastSlash);
            }
            return String.Empty;
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/WebPageRazorHost.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Compilation;
using System.Web.Hosting;
using System.Web.Razor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.WebPages.Instrumentation;
using System.Web.WebPages.Razor.Resources;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Razor
{
    public class WebPageRazorHost : RazorEngineHost
    {
        // DevDiv Bug 941404 - Add a prefix and folder name to class names
        internal const string PageClassNamePrefix = "_Page_";
        internal const string ApplicationInstancePropertyName = "ApplicationInstance";
        internal const string ContextPropertyName = "Context";
        internal const string DefineSectionMethodName = "DefineSection";
        internal const string WebDefaultNamespace = "ASP";
        internal const string WriteToMethodName = "WriteTo";
        internal const string WriteLiteralToMethodName = "WriteLiteralTo";
        internal const string BeginContextMethodName = "BeginContext";
        internal const string EndContextMethodName = "EndContext";
        internal const string ResolveUrlMethodName = "Href";

        private const string ApplicationStartFileName = "_AppStart";
        private const string PageStartFileName = "_PageStart";

        internal static readonly string FallbackApplicationTypeName = typeof(HttpApplication).FullName;
        internal static readonly string PageBaseClass = typeof(WebPage).FullName;
        internal static readonly string TemplateTypeName = typeof(HelperResult).FullName;

        private static ConcurrentDictionary<string, object> _importedNamespaces = new ConcurrentDictionary<string, object>();
        private readonly Dictionary<string, string> _specialFileBaseTypes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

        private string _className;
        private RazorCodeLanguage _codeLanguage;
        private string _globalAsaxTypeName;
        private bool? _isSpecialPage;
        private string _physicalPath = null;
        private string _specialFileBaseClass;

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The code path is safe, it is a property setter and not dependent on other state")]
        private WebPageRazorHost()
        {
            NamespaceImports.Add("System");
            NamespaceImports.Add("System.Collections.Generic");
            NamespaceImports.Add("System.IO");
            NamespaceImports.Add("System.Linq");
            NamespaceImports.Add("System.Net");
            NamespaceImports.Add("System.Web");
            NamespaceImports.Add("System.Web.Helpers");
            NamespaceImports.Add("System.Web.Security");
            NamespaceImports.Add("System.Web.UI");
            NamespaceImports.Add("System.Web.WebPages");
            NamespaceImports.Add("System.Web.WebPages.Html");

            RegisterSpecialFile(ApplicationStartFileName, typeof(ApplicationStartPage));
            RegisterSpecialFile(PageStartFileName, typeof(StartPage));
            DefaultNamespace = WebDefaultNamespace;
            GeneratedClassContext = new GeneratedClassContext(GeneratedClassContext.DefaultExecuteMethodName,
                                                              GeneratedClassContext.DefaultWriteMethodName,
                                                              GeneratedClassContext.DefaultWriteLiteralMethodName,
                                                              WriteToMethodName,
                                                              WriteLiteralToMethodName,
                                                              TemplateTypeName,
                                                              DefineSectionMethodName,
                                                              BeginContextMethodName,
                                                              EndContextMethodName)
            {
                ResolveUrlMethodName = ResolveUrlMethodName
            };
            DefaultPageBaseClass = PageBaseClass;
            DefaultDebugCompilation = true;
            EnableInstrumentation = false;
        }

        public WebPageRazorHost(string virtualPath)
            : this(virtualPath, null)
        {
        }

        [SuppressMessage("Microsoft.Usage", "CA2214:DoNotCallOverridableMethodsInConstructors", Justification = "The code path is safe, it is a property setter and not dependent on other state")]
        public WebPageRazorHost(string virtualPath, string physicalPath)
            : this()
        {
            if (String.IsNullOrEmpty(virtualPath))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "virtualPath"), "virtualPath");
            }

            VirtualPath = virtualPath;

            PhysicalPath = physicalPath;
            DefaultClassName = GetClassName(VirtualPath);
            CodeLanguage = GetCodeLanguage();
            EnableInstrumentation = new InstrumentationService().IsAvailable;
        }

        public override RazorCodeLanguage CodeLanguage
        {
            get
            {
                if (_codeLanguage == null)
                {
                    _codeLanguage = GetCodeLanguage();
                }
                return _codeLanguage;
            }
            protected set { _codeLanguage = value; }
        }

        public override string DefaultBaseClass
        {
            get
            {
                if (base.DefaultBaseClass != null)
                {
                    return base.DefaultBaseClass;
                }
                if (IsSpecialPage)
                {
                    return SpecialPageBaseClass;
                }
                else
                {
                    return DefaultPageBaseClass;
                }
            }
            set { base.DefaultBaseClass = value; }
        }

        public override string DefaultClassName
        {
            get
            {
                if (_className == null)
                {
                    _className = GetClassName(VirtualPath);
                }
                return _className;
            }
            set { _className = value; }
        }

        public bool DefaultDebugCompilation { get; set; }

        public string DefaultPageBaseClass { get; set; }

        internal string GlobalAsaxTypeName
        {
            get { return _globalAsaxTypeName ?? (HostingEnvironment.IsHosted ? BuildManager.GetGlobalAsaxType().FullName : FallbackApplicationTypeName); }
            set { _globalAsaxTypeName = value; }
        }

        public bool IsSpecialPage
        {
            get
            {
                CheckForSpecialPage();
                return _isSpecialPage.Value;
            }
        }

        public string PhysicalPath
        {
            get
            {
                MapPhysicalPath();
                return _physicalPath;
            }
            set { _physicalPath = value; }
        }

        public override string InstrumentedSourceFilePath
        {
            get { return VirtualPath; }
            set { VirtualPath = value; }
        }

        private string SpecialPageBaseClass
        {
            get
            {
                CheckForSpecialPage();
                return _specialFileBaseClass;
            }
        }

        public string VirtualPath { get; private set; }

        /// <summary>
        /// Adds a namespace to the global imports list for this AppDomain
        /// </summary>
        /// <remarks>
        /// IMPORTANT: ALL uses of WebPageRazorHost (and derived classes) within the same AppDomain will share this list.
        /// Therefore this method should only be used in runtime scenarios, not in design-time scenarios where the Razor
        /// data structures for multiple files and projects may be shared within a single AppDomain.
        /// </remarks>
        /// <param name="ns">The namespace to add to the global imports list.</param>
        public static void AddGlobalImport(string ns)
        {
            if (String.IsNullOrEmpty(ns))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "ns"), "ns");
            }

            _importedNamespaces.TryAdd(ns, null);
        }

        private void CheckForSpecialPage()
        {
            if (!_isSpecialPage.HasValue)
            {
                string fileName = Path.GetFileNameWithoutExtension(VirtualPath);
                string baseType;
                if (_specialFileBaseTypes.TryGetValue(fileName, out baseType))
                {
                    _isSpecialPage = true;
                    _specialFileBaseClass = baseType;
                }
                else
                {
                    _isSpecialPage = false;
                }
            }
        }

        public override ParserBase CreateMarkupParser()
        {
            return new HtmlMarkupParser();
        }

        private static RazorCodeLanguage DetermineCodeLanguage(string fileName)
        {
            string extension = Path.GetExtension(fileName);

            // Use an if rather than else-if just in case Path.GetExtension returns null for some reason
            if (String.IsNullOrEmpty(extension))
            {
                return null;
            }
            if (extension[0] == '.')
            {
                extension = extension.Substring(1); // Trim off the dot
            }

            // Look up the language
            // At the moment this only deals with code languages: cs, vb, etc., but in theory we could have MarkupLanguageServices which allow for
            // interesting combinations like: vbcss, csxml, etc.
            RazorCodeLanguage language = GetLanguageByExtension(extension);
            return language;
        }

        protected virtual string GetClassName(string virtualPath)
        {
            // Remove "~/" and run through our santizer
            // For example, for ~/Foo/Bar/Baz.cshtml, the class name is _Page_Foo_Bar_Baz_cshtml
            return ParserHelpers.SanitizeClassName(PageClassNamePrefix + virtualPath.TrimStart('~', '/'));
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "Method involves significant processing and should not be a property")]
        protected virtual RazorCodeLanguage GetCodeLanguage()
        {
            RazorCodeLanguage language = DetermineCodeLanguage(VirtualPath);
            if (language == null && !String.IsNullOrEmpty(PhysicalPath))
            {
                language = DetermineCodeLanguage(PhysicalPath);
            }

            if (language == null)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, RazorWebResources.BuildProvider_No_CodeLanguageService_For_Path, VirtualPath));
            }

            return language;
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This method involves copying memory, so a property is not appropriate")]
        public static IEnumerable<string> GetGlobalImports()
        {
            return _importedNamespaces.ToArray().Select(pair => pair.Key);
        }

        private static RazorCodeLanguage GetLanguageByExtension(string extension)
        {
            return RazorCodeLanguage.GetLanguageByExtension(extension);
        }

        private void MapPhysicalPath()
        {
            if (_physicalPath == null && HostingEnvironment.IsHosted)
            {
                string path = HostingEnvironment.MapPath(VirtualPath);
                if (!String.IsNullOrEmpty(path) && File.Exists(path))
                {
                    _physicalPath = path;
                }
            }
        }

        public override void PostProcessGeneratedCode(CodeGeneratorContext context)
        {
            base.PostProcessGeneratedCode(context);

            // Add additional global imports
            context.Namespace.Imports.AddRange(GetGlobalImports().Select(s => new CodeNamespaceImport(s)).ToArray());

            // Create ApplicationInstance property
            CodeMemberProperty prop = new CodeMemberProperty()
            {
                Name = ApplicationInstancePropertyName,
                Type = new CodeTypeReference(GlobalAsaxTypeName),
                HasGet = true,
                HasSet = false,
                Attributes = MemberAttributes.Family | MemberAttributes.Final
            };
            prop.GetStatements.Add(
                new CodeMethodReturnStatement(
                    new CodeCastExpression(
                        new CodeTypeReference(GlobalAsaxTypeName),
                        new CodePropertyReferenceExpression(
                            new CodePropertyReferenceExpression(
                                null,
                                ContextPropertyName),
                            ApplicationInstancePropertyName))));
            context.GeneratedClass.Members.Insert(0, prop);
        }

        protected void RegisterSpecialFile(string fileName, Type baseType)
        {
            if (baseType == null)
            {
                throw new ArgumentNullException("baseType");
            }
            RegisterSpecialFile(fileName, baseType.FullName);
        }

        protected void RegisterSpecialFile(string fileName, string baseTypeName)
        {
            if (String.IsNullOrEmpty(fileName))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "fileName"), "fileName");
            }
            if (String.IsNullOrEmpty(baseTypeName))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "baseTypeName"), "baseTypeName");
            }

            _specialFileBaseTypes[fileName] = baseTypeName;
        }
    }
}


================================================
FILE: src/System.Web.WebPages.Razor/WebRazorHostFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Linq.Expressions;
using System.Web.Compilation;
using System.Web.Configuration;
using System.Web.Hosting;
using System.Web.WebPages.Razor.Configuration;
using System.Web.WebPages.Razor.Resources;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Razor
{
    public class WebRazorHostFactory
    {
        private static ConcurrentDictionary<string, Func<WebRazorHostFactory>> _factories =
            new ConcurrentDictionary<string, Func<WebRazorHostFactory>>(StringComparer.OrdinalIgnoreCase);

        internal static Func<string, Type> TypeFactory = DefaultTypeFactory;

        public static WebPageRazorHost CreateDefaultHost(string virtualPath)
        {
            return CreateDefaultHost(virtualPath, null);
        }

        public static WebPageRazorHost CreateDefaultHost(string virtualPath, string physicalPath)
        {
            return CreateHostFromConfigCore(null, virtualPath, physicalPath);
        }

        public static WebPageRazorHost CreateHostFromConfig(string virtualPath)
        {
            return CreateHostFromConfig(virtualPath, null);
        }

        public static WebPageRazorHost CreateHostFromConfig(string virtualPath, string physicalPath)
        {
            if (String.IsNullOrEmpty(virtualPath))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "virtualPath"), "virtualPath");
            }

            return CreateHostFromConfigCore(GetRazorSection(virtualPath), virtualPath, physicalPath);
        }

        public static WebPageRazorHost CreateHostFromConfig(RazorWebSectionGroup config, string virtualPath)
        {
            return CreateHostFromConfig(config, virtualPath, null);
        }

        public static WebPageRazorHost CreateHostFromConfig(RazorWebSectionGroup config, string virtualPath, string physicalPath)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            if (String.IsNullOrEmpty(virtualPath))
            {
                throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "virtualPath"), "virtualPath");
            }

            return CreateHostFromConfigCore(config, virtualPath, physicalPath);
        }

        internal static WebPageRazorHost CreateHostFromConfigCore(RazorWebSectionGroup config, string virtualPath, string physicalPath)
        {
            // Use the virtual path to select a host environment for the generated code
            // Do this check here because the App_Code host can't be overridden.

            // Make the path app relative
            virtualPath = EnsureAppRelative(virtualPath);

            WebPageRazorHost host;
            if (virtualPath.StartsWith("~/App_Code", StringComparison.OrdinalIgnoreCase))
            {
                // Under App_Code => It's a Web Code file
                host = new WebCodeRazorHost(virtualPath, physicalPath);
            }
            else
            {
                WebRazorHostFactory factory = null;
                if (config != null && config.Host != null && !String.IsNullOrEmpty(config.Host.FactoryType))
                {
                    Func<WebRazorHostFactory> factoryCreator = _factories.GetOrAdd(config.Host.FactoryType, CreateFactory);
                    Debug.Assert(factoryCreator != null); // CreateFactory should throw if there's an error creating the factory
                    factory = factoryCreator();
                }

                host = (factory ?? new WebRazorHostFactory()).CreateHost(virtualPath, physicalPath);

                if (config != null && config.Pages != null)
                {
                    ApplyConfigurationToHost(config.Pages, host);
                }
            }

            return host;
        }

        private static Func<WebRazorHostFactory> CreateFactory(string typeName)
        {
            Type factoryType = TypeFactory(typeName);
            if (factoryType == null)
            {
                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                                  RazorWebResources.Could_Not_Locate_FactoryType,
                                                                  typeName));
            }
            return Expression.Lambda<Func<WebRazorHostFactory>>(Expression.New(factoryType))
                .Compile();
        }

        public static void ApplyConfigurationToHost(RazorPagesSection config, WebPageRazorHost host)
        {
            host.DefaultPageBaseClass = config.PageBaseType;

            // Add imports
            foreach (string import in config.Namespaces.OfType<NamespaceInfo>().Select(ns => ns.Namespace))
            {
                host.NamespaceImports.Add(import);
            }
        }

        public virtual WebPageRazorHost CreateHost(string virtualPath, string physicalPath)
        {
            return new WebPageRazorHost(virtualPath, physicalPath);
        }

        internal static RazorWebSectionGroup GetRazorSection(string virtualPath)
        {
            // Get the individual sections (we can only use GetSection in medium trust) and then reconstruct the section group
            return new RazorWebSectionGroup()
            {
                Host = (HostSection)WebConfigurationManager.GetSection(HostSection.SectionName, virtualPath),
                Pages = (RazorPagesSection)WebConfigurationManager.GetSection(RazorPagesSection.SectionName, virtualPath)
            };
        }

#if CODE_COVERAGE
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        // JUSTIFICATION: VirtualPathUtility.ToAppRelative is only available in ASP.Net environment
#endif

        private static string EnsureAppRelative(string virtualPath)
        {
            if (HostingEnvironment.IsHosted)
            {
                virtualPath = VirtualPathUtility.ToAppRelative(virtualPath);
            }
            else
            {
                if (virtualPath.StartsWith("/", StringComparison.Ordinal))
                {
                    virtualPath = "~" + virtualPath;
                }
                else if (!virtualPath.StartsWith("~/", StringComparison.Ordinal))
                {
                    virtualPath = "~/" + virtualPath;
                }
            }
            return virtualPath;
        }

#if CODE_COVERAGE
        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
        // JUSTIFICATION: BuildManager.GetType is only available in ASP.Net environment
#endif

        private static Type DefaultTypeFactory(string typeName)
        {
            return BuildManager.GetType(typeName, false, false);
        }
    }
}


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ApiDescriptionExtensions.cs
================================================
using System;
using System.Text;
using System.Web;
using System.Web.Http.Description;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    public static class ApiDescriptionExtensions
    {
        /// <summary>
        /// Generates an URI-friendly ID for the <see cref="ApiDescription"/>. E.g. "Get-Values-id_name" instead of "GetValues/{id}?name={name}"
        /// </summary>
        /// <param name="description">The <see cref="ApiDescription"/>.</param>
        /// <returns>The ID as a string.</returns>
        public static string GetFriendlyId(this ApiDescription description)
        {
            string path = description.RelativePath;
            string[] urlParts = path.Split('?');
            string localPath = urlParts[0];
            string queryKeyString = null;
            if (urlParts.Length > 1)
            {
                string query = urlParts[1];
                string[] queryKeys = HttpUtility.ParseQueryString(query).AllKeys;
                queryKeyString = String.Join("_", queryKeys);
            }

            StringBuilder friendlyPath = new StringBuilder();
            friendlyPath.AppendFormat("{0}-{1}",
                description.HttpMethod.Method,
                localPath.Replace("/", "-").Replace("{", String.Empty).Replace("}", String.Empty));
            if (queryKeyString != null)
            {
                friendlyPath.AppendFormat("_{0}", queryKeyString.Replace('.', '-'));
            }
            return friendlyPath.ToString();
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/App_Start/HelpPageConfig.cs
================================================
// Uncomment the following to provide samples for PageResult<T>. Must also add the Microsoft.AspNet.WebApi.OData
// package to your project.
////#define Handle_PageResultOfT

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Net.Http.Headers;
using System.Reflection;
using System.Web;
using System.Web.Http;
#if Handle_PageResultOfT
using System.Web.Http.OData;
#endif

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// Use this class to customize the Help Page.
    /// For example you can set a custom <see cref="System.Web.Http.Description.IDocumentationProvider"/> to supply the documentation
    /// or you can provide the samples for the requests/responses.
    /// </summary>
    public static class HelpPageConfig
    {
        [SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters",
            MessageId = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.TextSample.#ctor(System.String)",
            Justification = "End users may choose to merge this string with existing localized resources.")]
        [SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly",
            MessageId = "bsonspec",
            Justification = "Part of a URI.")]
        public static void Register(HttpConfiguration config)
        {
            //// Uncomment the following to use the documentation from XML documentation file.
            //config.SetDocumentationProvider(new XmlDocumentationProvider(HttpContext.Current.Server.MapPath("~/App_Data/XmlDocument.xml")));

            //// Uncomment the following to use "sample string" as the sample for all actions that have string as the body parameter or return type.
            //// Also, the string arrays will be used for IEnumerable<string>. The sample objects will be serialized into different media type 
            //// formats by the available formatters.
            //config.SetSampleObjects(new Dictionary<Type, object>
            //{
            //    {typeof(string), "sample string"},
            //    {typeof(IEnumerable<string>), new string[]{"sample 1", "sample 2"}}
            //});

            // Extend the following to provide factories for types not handled automatically (those lacking parameterless
            // constructors) or for which you prefer to use non-default property values. Line below provides a fallback
            // since automatic handling will fail and GeneratePageResult handles only a single type.
#if Handle_PageResultOfT
            config.GetHelpPageSampleGenerator().SampleObjectFactories.Add(GeneratePageResult);
#endif

            // Extend the following to use a preset object directly as the sample for all actions that support a media
            // type, regardless of the body parameter or return type. The lines below avoid display of binary content.
            // The BsonMediaTypeFormatter (if available) is not used to serialize the TextSample object.
            config.SetSampleForMediaType(
                new TextSample("Binary JSON content. See http://bsonspec.org for details."),
                new MediaTypeHeaderValue("application/bson"));

            //// Uncomment the following to use "[0]=foo&[1]=bar" directly as the sample for all actions that support form URL encoded format
            //// and have IEnumerable<string> as the body parameter or return type.
            //config.SetSampleForType("[0]=foo&[1]=bar", new MediaTypeHeaderValue("application/x-www-form-urlencoded"), typeof(IEnumerable<string>));

            //// Uncomment the following to use "1234" directly as the request sample for media type "text/plain" on the controller named "Values"
            //// and action named "Put".
            //config.SetSampleRequest("1234", new MediaTypeHeaderValue("text/plain"), "Values", "Put");

            //// Uncomment the following to use the image on "../images/aspNetHome.png" directly as the response sample for media type "image/png"
            //// on the controller named "Values" and action named "Get" with parameter "id".
            //config.SetSampleResponse(new ImageSample("../images/aspNetHome.png"), new MediaTypeHeaderValue("image/png"), "Values", "Get", "id");

            //// Uncomment the following to correct the sample request when the action expects an HttpRequestMessage with ObjectContent<string>.
            //// The sample will be generated as if the controller named "Values" and action named "Get" were having string as the body parameter.
            //config.SetActualRequestType(typeof(string), "Values", "Get");

            //// Uncomment the following to correct the sample response when the action returns an HttpResponseMessage with ObjectContent<string>.
            //// The sample will be generated as if the controller named "Values" and action named "Post" were returning a string.
            //config.SetActualResponseType(typeof(string), "Values", "Post");
        }

#if Handle_PageResultOfT
        private static object GeneratePageResult(HelpPageSampleGenerator sampleGenerator, Type type)
        {
            if (type.IsGenericType)
            {
                Type openGenericType = type.GetGenericTypeDefinition();
                if (openGenericType == typeof(PageResult<>))
                {
                    // Get the T in PageResult<T>
                    Type[] typeParameters = type.GetGenericArguments();
                    Debug.Assert(typeParameters.Length == 1);

                    // Create an enumeration to pass as the first parameter to the PageResult<T> constuctor
                    Type itemsType = typeof(List<>).MakeGenericType(typeParameters);
                    object items = sampleGenerator.GetSampleObject(itemsType);

                    // Fill in the other information needed to invoke the PageResult<T> constuctor
                    Type[] parameterTypes = new Type[] { itemsType, typeof(Uri), typeof(long?), };
                    object[] parameters = new object[] { items, null, (long)ObjectGenerator.DefaultCollectionSize, };

                    // Call PageResult(IEnumerable<T> items, Uri nextPageLink, long? count) constructor
                    ConstructorInfo constructor = type.GetConstructor(parameterTypes);
                    return constructor.Invoke(parameters);
                }
            }

            return null;
        }
#endif
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Controllers/HelpController.cs
================================================
using System;
using System.Web.Http;
using System.Web.Mvc;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers
{
    /// <summary>
    /// The controller that will handle requests for the help page.
    /// </summary>
    public class HelpController : Controller
    {
        private const string ErrorViewName = "Error";

        public HelpController()
            : this(GlobalConfiguration.Configuration)
        {
        }

        public HelpController(HttpConfiguration config)
        {
            Configuration = config;
        }

        public HttpConfiguration Configuration { get; private set; }

        public ActionResult Index()
        {
            ViewBag.DocumentationProvider = Configuration.Services.GetDocumentationProvider();
            return View(Configuration.Services.GetApiExplorer().ApiDescriptions);
        }

        public ActionResult Api(string apiId)
        {
            if (!String.IsNullOrEmpty(apiId))
            {
                HelpPageApiModel apiModel = Configuration.GetHelpPageApiModel(apiId);
                if (apiModel != null)
                {
                    return View(apiModel);
                }
            }

            return View(ErrorViewName);
        }

        public ActionResult ResourceModel(string modelName)
        {
            if (!String.IsNullOrEmpty(modelName))
            {
                ModelDescriptionGenerator modelDescriptionGenerator = Configuration.GetModelDescriptionGenerator();
                ModelDescription modelDescription;
                if (modelDescriptionGenerator.GeneratedModels.TryGetValue(modelName, out modelDescription))
                {
                    return View(modelDescription);
                }
            }

            return View(ErrorViewName);
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/HelpPage.css
================================================
.help-page h1,
.help-page .h1,
.help-page h2,
.help-page .h2,
.help-page h3,
.help-page .h3,
#body.help-page,
.help-page-table th,
.help-page-table pre,
.help-page-table p {
    font-family: "Segoe UI Light", Frutiger, "Frutiger Linotype", "Dejavu Sans", "Helvetica Neue", Arial, sans-serif;
}

.help-page pre.wrapped {
    white-space: -moz-pre-wrap;
    white-space: -pre-wrap;
    white-space: -o-pre-wrap;
    white-space: pre-wrap;
}

.help-page .warning-message-container {
    margin-top: 20px;
    padding: 0 10px;
    color: #525252;
    background: #EFDCA9; 
    border: 1px solid #CCCCCC;
}

.help-page-table {
    width: 100%;
    border-collapse: collapse;
    text-align: left;
    margin: 0px 0px 20px 0px;
    border-top: 1px solid #D4D4D4;
}

.help-page-table th {
    text-align: left;
    font-weight: bold;
    border-bottom: 1px solid #D4D4D4;
    padding: 5px 6px 5px 6px;
}

.help-page-table td {
    border-bottom: 1px solid #D4D4D4;
    padding: 10px 8px 10px 8px;
    vertical-align: top;
}

.help-page-table pre,
.help-page-table p {
    margin: 0px;
    padding: 0px;
    font-family: inherit;
    font-size: 100%;
}

.help-page-table tbody tr:hover td {
    background-color: #F3F3F3;
}

.help-page a:hover {
    background-color: transparent;
}

.help-page .sample-header {
    border: 2px solid #D4D4D4;
    background: #00497E;
    color: #FFFFFF;
    padding: 8px 15px;
    border-bottom: none;
    display: inline-block;
    margin: 10px 0px 0px 0px;
}

.help-page .sample-content {
    display: block;
    border-width: 0;
    padding: 15px 20px;
    background: #FFFFFF;
    border: 2px solid #D4D4D4;
    margin: 0px 0px 10px 0px;
}

.help-page .api-name {
    width: 40%;
}

.help-page .api-documentation {
    width: 60%;
}

.help-page .parameter-name {
    width: 20%;
}

.help-page .parameter-documentation {
    width: 40%;
}

.help-page .parameter-type {
    width: 20%;
}

.help-page .parameter-annotations {
    width: 20%;
}

.help-page h1,
.help-page .h1 {
    font-size: 36px;
    line-height: normal;
}

.help-page h2,
.help-page .h2 {
    font-size: 24px;
}

.help-page h3,
.help-page .h3 {
    font-size: 20px;
}

#body.help-page {
    font-size: 14px;
    line-height: 143%;
    color: #333;
}

.help-page a {
    color: #0000EE;
    text-decoration: none;
}


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/HelpPageAreaRegistration.cs
================================================
using System.Web.Http;
using System.Web.Mvc;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    public class HelpPageAreaRegistration : AreaRegistration
    {
        public override string AreaName
        {
            get
            {
                return "HelpPage";
            }
        }

        public override void RegisterArea(AreaRegistrationContext context)
        {
            context.MapRoute(
                "HelpPage_Default",
                "Help/{action}/{apiId}",
                new { controller = "Help", action = "Index", apiId = UrlParameter.Optional });

            HelpPageConfig.Register(GlobalConfiguration.Configuration);
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/HelpPageConfigurationExtensions.cs
================================================
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Description;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    public static class HelpPageConfigurationExtensions
    {
        private const string ApiModelPrefix = "MS_HelpPageApiModel_";

        /// <summary>
        /// Sets the documentation provider for help page.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="documentationProvider">The documentation provider.</param>
        public static void SetDocumentationProvider(this HttpConfiguration config, IDocumentationProvider documentationProvider)
        {
            config.Services.Replace(typeof(IDocumentationProvider), documentationProvider);
        }

        /// <summary>
        /// Sets the objects that will be used by the formatters to produce sample requests/responses.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sampleObjects">The sample objects.</param>
        public static void SetSampleObjects(this HttpConfiguration config, IDictionary<Type, object> sampleObjects)
        {
            config.GetHelpPageSampleGenerator().SampleObjects = sampleObjects;
        }

        /// <summary>
        /// Sets the sample request directly for the specified media type and action.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sample">The sample request.</param>
        /// <param name="mediaType">The media type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        public static void SetSampleRequest(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName)
        {
            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, new[] { "*" }), sample);
        }

        /// <summary>
        /// Sets the sample request directly for the specified media type and action with parameters.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sample">The sample request.</param>
        /// <param name="mediaType">The media type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        public static void SetSampleRequest(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName, params string[] parameterNames)
        {
            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, parameterNames), sample);
        }

        /// <summary>
        /// Sets the sample request directly for the specified media type of the action.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sample">The sample response.</param>
        /// <param name="mediaType">The media type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        public static void SetSampleResponse(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName)
        {
            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, new[] { "*" }), sample);
        }

        /// <summary>
        /// Sets the sample response directly for the specified media type of the action with specific parameters.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sample">The sample response.</param>
        /// <param name="mediaType">The media type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        public static void SetSampleResponse(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, string controllerName, string actionName, params string[] parameterNames)
        {
            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, parameterNames), sample);
        }

        /// <summary>
        /// Sets the sample directly for all actions with the specified media type.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sample">The sample.</param>
        /// <param name="mediaType">The media type.</param>
        public static void SetSampleForMediaType(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType)
        {
            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType), sample);
        }

        /// <summary>
        /// Sets the sample directly for all actions with the specified type and media type.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sample">The sample.</param>
        /// <param name="mediaType">The media type.</param>
        /// <param name="type">The parameter type or return type of an action.</param>
        public static void SetSampleForType(this HttpConfiguration config, object sample, MediaTypeHeaderValue mediaType, Type type)
        {
            config.GetHelpPageSampleGenerator().ActionSamples.Add(new HelpPageSampleKey(mediaType, type), sample);
        }

        /// <summary>
        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
        /// The help page will use this information to produce more accurate request samples.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="type">The type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        public static void SetActualRequestType(this HttpConfiguration config, Type type, string controllerName, string actionName)
        {
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Request, controllerName, actionName, new[] { "*" }), type);
        }

        /// <summary>
        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
        /// The help page will use this information to produce more accurate request samples.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="type">The type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        public static void SetActualRequestType(this HttpConfiguration config, Type type, string controllerName, string actionName, params string[] parameterNames)
        {
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Request, controllerName, actionName, parameterNames), type);
        }

        /// <summary>
        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> returned as part of the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
        /// The help page will use this information to produce more accurate response samples.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="type">The type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        public static void SetActualResponseType(this HttpConfiguration config, Type type, string controllerName, string actionName)
        {
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Response, controllerName, actionName, new[] { "*" }), type);
        }

        /// <summary>
        /// Specifies the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> returned as part of the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
        /// The help page will use this information to produce more accurate response samples.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="type">The type.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        public static void SetActualResponseType(this HttpConfiguration config, Type type, string controllerName, string actionName, params string[] parameterNames)
        {
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Response, controllerName, actionName, parameterNames), type);
        }

        /// <summary>
        /// Gets the help page sample generator.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <returns>The help page sample generator.</returns>
        public static HelpPageSampleGenerator GetHelpPageSampleGenerator(this HttpConfiguration config)
        {
            return (HelpPageSampleGenerator)config.Properties.GetOrAdd(
                typeof(HelpPageSampleGenerator),
                k => new HelpPageSampleGenerator());
        }

        /// <summary>
        /// Sets the help page sample generator.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="sampleGenerator">The help page sample generator.</param>
        public static void SetHelpPageSampleGenerator(this HttpConfiguration config, HelpPageSampleGenerator sampleGenerator)
        {
            config.Properties.AddOrUpdate(
                typeof(HelpPageSampleGenerator),
                k => sampleGenerator,
                (k, o) => sampleGenerator);
        }

        /// <summary>
        /// Gets the model description generator.
        /// </summary>
        /// <param name="config">The configuration.</param>
        /// <returns>The <see cref="ModelDescriptionGenerator"/></returns>
        public static ModelDescriptionGenerator GetModelDescriptionGenerator(this HttpConfiguration config)
        {
            return (ModelDescriptionGenerator)config.Properties.GetOrAdd(
                typeof(ModelDescriptionGenerator),
                k => InitializeModelDescriptionGenerator(config));
        }

        /// <summary>
        /// Gets the model that represents an API displayed on the help page. The model is initialized on the first call and cached for subsequent calls.
        /// </summary>
        /// <param name="config">The <see cref="HttpConfiguration"/>.</param>
        /// <param name="apiDescriptionId">The <see cref="ApiDescription"/> ID.</param>
        /// <returns>
        /// An <see cref="HelpPageApiModel"/>
        /// </returns>
        public static HelpPageApiModel GetHelpPageApiModel(this HttpConfiguration config, string apiDescriptionId)
        {
            object model;
            string modelId = ApiModelPrefix + apiDescriptionId;
            if (!config.Properties.TryGetValue(modelId, out model))
            {
                Collection<ApiDescription> apiDescriptions = config.Services.GetApiExplorer().ApiDescriptions;
                ApiDescription apiDescription = apiDescriptions.FirstOrDefault(api => String.Equals(api.GetFriendlyId(), apiDescriptionId, StringComparison.OrdinalIgnoreCase));
                if (apiDescription != null)
                {
                    model = GenerateApiModel(apiDescription, config);
                    config.Properties.TryAdd(modelId, model);
                }
            }

            return (HelpPageApiModel)model;
        }

        private static HelpPageApiModel GenerateApiModel(ApiDescription apiDescription, HttpConfiguration config)
        {
            HelpPageApiModel apiModel = new HelpPageApiModel()
            {
                ApiDescription = apiDescription,
            };

            ModelDescriptionGenerator modelGenerator = config.GetModelDescriptionGenerator();
            HelpPageSampleGenerator sampleGenerator = config.GetHelpPageSampleGenerator();
            GenerateUriParameters(apiModel, modelGenerator);
            GenerateRequestModelDescription(apiModel, modelGenerator, sampleGenerator);
            GenerateResourceDescription(apiModel, modelGenerator);
            GenerateSamples(apiModel, sampleGenerator);

            return apiModel;
        }

        private static void GenerateUriParameters(HelpPageApiModel apiModel, ModelDescriptionGenerator modelGenerator)
        {
            ApiDescription apiDescription = apiModel.ApiDescription;
            foreach (ApiParameterDescription apiParameter in apiDescription.ParameterDescriptions)
            {
                if (apiParameter.Source == ApiParameterSource.FromUri)
                {
                    HttpParameterDescriptor parameterDescriptor = apiParameter.ParameterDescriptor;
                    Type parameterType = null;
                    ModelDescription typeDescription = null;
                    ComplexTypeModelDescription complexTypeDescription = null;
                    if (parameterDescriptor != null)
                    {
                        parameterType = parameterDescriptor.ParameterType;
                        typeDescription = modelGenerator.GetOrCreateModelDescription(parameterType);
                        complexTypeDescription = typeDescription as ComplexTypeModelDescription;
                    }

                    // Example:
                    // [TypeConverter(typeof(PointConverter))]
                    // public class Point
                    // {
                    //     public Point(int x, int y)
                    //     {
                    //         X = x;
                    //         Y = y;
                    //     }
                    //     public int X { get; set; }
                    //     public int Y { get; set; }
                    // }
                    // Class Point is bindable with a TypeConverter, so Point will be added to UriParameters collection.
                    // 
                    // public class Point
                    // {
                    //     public int X { get; set; }
                    //     public int Y { get; set; }
                    // }
                    // Regular complex class Point will have properties X and Y added to UriParameters collection.
                    if (complexTypeDescription != null
                        && !IsBindableWithTypeConverter(parameterType))
                    {
                        foreach (ParameterDescription uriParameter in complexTypeDescription.Properties)
                        {
                            apiModel.UriParameters.Add(uriParameter);
                        }
                    }
                    else if (parameterDescriptor != null)
                    {
                        ParameterDescription uriParameter =
                            AddParameterDescription(apiModel, apiParameter, typeDescription);

                        if (!parameterDescriptor.IsOptional)
                        {
                            uriParameter.Annotations.Add(new ParameterAnnotation() { Documentation = "Required" });
                        }

                        object defaultValue = parameterDescriptor.DefaultValue;
                        if (defaultValue != null)
                        {
                            uriParameter.Annotations.Add(new ParameterAnnotation() { Documentation = "Default value is " + Convert.ToString(defaultValue, CultureInfo.InvariantCulture) });
                        }
                    }
                    else
                    {
                        Debug.Assert(parameterDescriptor == null);

                        // If parameterDescriptor is null, this is an undeclared route parameter which only occurs
                        // when source is FromUri. Ignored in request model and among resource parameters but listed
                        // as a simple string here.
                        ModelDescription modelDescription = modelGenerator.GetOrCreateModelDescription(typeof(string));
                        AddParameterDescription(apiModel, apiParameter, modelDescription);
                    }
                }
            }
        }

        private static bool IsBindableWithTypeConverter(Type parameterType)
        {
            if (parameterType == null)
            {
                return false;
            }

            return TypeDescriptor.GetConverter(parameterType).CanConvertFrom(typeof(string));
        }

        private static ParameterDescription AddParameterDescription(HelpPageApiModel apiModel,
            ApiParameterDescription apiParameter, ModelDescription typeDescription)
        {
            ParameterDescription parameterDescription = new ParameterDescription
            {
                Name = apiParameter.Name,
                Documentation = apiParameter.Documentation,
                TypeDescription = typeDescription,
            };

            apiModel.UriParameters.Add(parameterDescription);
            return parameterDescription;
        }

        private static void GenerateRequestModelDescription(HelpPageApiModel apiModel, ModelDescriptionGenerator modelGenerator, HelpPageSampleGenerator sampleGenerator)
        {
            ApiDescription apiDescription = apiModel.ApiDescription;
            foreach (ApiParameterDescription apiParameter in apiDescription.ParameterDescriptions)
            {
                if (apiParameter.Source == ApiParameterSource.FromBody)
                {
                    Type parameterType = apiParameter.ParameterDescriptor.ParameterType;
                    apiModel.RequestModelDescription = modelGenerator.GetOrCreateModelDescription(parameterType);
                    apiModel.RequestDocumentation = apiParameter.Documentation;
                }
                else if (apiParameter.ParameterDescriptor != null &&
                    apiParameter.ParameterDescriptor.ParameterType == typeof(HttpRequestMessage))
                {
                    Type parameterType = sampleGenerator.ResolveHttpRequestMessageType(apiDescription);

                    if (parameterType != null)
                    {
                        apiModel.RequestModelDescription = modelGenerator.GetOrCreateModelDescription(parameterType);
                    }
                }
            }
        }

        private static void GenerateResourceDescription(HelpPageApiModel apiModel, ModelDescriptionGenerator modelGenerator)
        {
            ResponseDescription response = apiModel.ApiDescription.ResponseDescription;
            Type responseType = response.ResponseType ?? response.DeclaredType;
            if (responseType != null && responseType != typeof(void))
            {
                apiModel.ResourceDescription = modelGenerator.GetOrCreateModelDescription(responseType);
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is recorded as ErrorMessages.")]
        private static void GenerateSamples(HelpPageApiModel apiModel, HelpPageSampleGenerator sampleGenerator)
        {
            try
            {
                foreach (var item in sampleGenerator.GetSampleRequests(apiModel.ApiDescription))
                {
                    apiModel.SampleRequests.Add(item.Key, item.Value);
                    LogInvalidSampleAsError(apiModel, item.Value);
                }

                foreach (var item in sampleGenerator.GetSampleResponses(apiModel.ApiDescription))
                {
                    apiModel.SampleResponses.Add(item.Key, item.Value);
                    LogInvalidSampleAsError(apiModel, item.Value);
                }
            }
            catch (Exception e)
            {
                apiModel.ErrorMessages.Add(String.Format(CultureInfo.CurrentCulture,
                    "An exception has occurred while generating the sample. Exception message: {0}",
                    HelpPageSampleGenerator.UnwrapException(e).Message));
            }
        }

        private static bool TryGetResourceParameter(ApiDescription apiDescription, HttpConfiguration config, out ApiParameterDescription parameterDescription, out Type resourceType)
        {
            parameterDescription = apiDescription.ParameterDescriptions.FirstOrDefault(
                p => p.Source == ApiParameterSource.FromBody ||
                    (p.ParameterDescriptor != null && p.ParameterDescriptor.ParameterType == typeof(HttpRequestMessage)));

            if (parameterDescription == null)
            {
                resourceType = null;
                return false;
            }

            resourceType = parameterDescription.ParameterDescriptor.ParameterType;

            if (resourceType == typeof(HttpRequestMessage))
            {
                HelpPageSampleGenerator sampleGenerator = config.GetHelpPageSampleGenerator();
                resourceType = sampleGenerator.ResolveHttpRequestMessageType(apiDescription);
            }

            if (resourceType == null)
            {
                parameterDescription = null;
                return false;
            }

            return true;
        }

        private static ModelDescriptionGenerator InitializeModelDescriptionGenerator(HttpConfiguration config)
        {
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);
            Collection<ApiDescription> apis = config.Services.GetApiExplorer().ApiDescriptions;
            foreach (ApiDescription api in apis)
            {
                ApiParameterDescription parameterDescription;
                Type parameterType;
                if (TryGetResourceParameter(api, config, out parameterDescription, out parameterType))
                {
                    modelGenerator.GetOrCreateModelDescription(parameterType);
                }
            }
            return modelGenerator;
        }

        private static void LogInvalidSampleAsError(HelpPageApiModel apiModel, object sample)
        {
            InvalidSample invalidSample = sample as InvalidSample;
            if (invalidSample != null)
            {
                apiModel.ErrorMessages.Add(invalidSample.ErrorMessage);
            }
        }
    }
}


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/CollectionModelDescription.cs
================================================
namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class CollectionModelDescription : ModelDescription
    {
        public ModelDescription ElementDescription { get; set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/ComplexTypeModelDescription.cs
================================================
using System.Collections.ObjectModel;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class ComplexTypeModelDescription : ModelDescription
    {
        public ComplexTypeModelDescription()
        {
            Properties = new Collection<ParameterDescription>();
        }

        public Collection<ParameterDescription> Properties { get; private set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/DictionaryModelDescription.cs
================================================
namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class DictionaryModelDescription : KeyValuePairModelDescription
    {
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/EnumTypeModelDescription.cs
================================================
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class EnumTypeModelDescription : ModelDescription
    {
        public EnumTypeModelDescription()
        {
            Values = new Collection<EnumValueDescription>();
        }

        public Collection<EnumValueDescription> Values { get; private set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/EnumValueDescription.cs
================================================
namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class EnumValueDescription
    {
        public string Documentation { get; set; }

        public string Name { get; set; }

        public string Value { get; set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/IModelDocumentationProvider.cs
================================================
using System;
using System.Reflection;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public interface IModelDocumentationProvider
    {
        string GetDocumentation(MemberInfo member);

        string GetDocumentation(Type type);
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/KeyValuePairModelDescription.cs
================================================
namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class KeyValuePairModelDescription : ModelDescription
    {
        public ModelDescription KeyModelDescription { get; set; }

        public ModelDescription ValueModelDescription { get; set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/ModelDescription.cs
================================================
using System;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    /// <summary>
    /// Describes a type model.
    /// </summary>
    public abstract class ModelDescription
    {
        public string Documentation { get; set; }

        public Type ModelType { get; set; }

        public string Name { get; set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/ModelDescriptionGenerator.cs
================================================
using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Reflection;
using System.Runtime.Serialization;
using System.Web.Http;
using System.Web.Http.Description;
using System.Xml.Serialization;
using Newtonsoft.Json;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    /// <summary>
    /// Generates model descriptions for given types.
    /// </summary>
    public class ModelDescriptionGenerator
    {
        // Modify this to support more data annotation attributes.
        private readonly IDictionary<Type, Func<object, string>> AnnotationTextGenerator = new Dictionary<Type, Func<object, string>>
        {
            { typeof(RequiredAttribute), a => "Required" },
            { typeof(RangeAttribute), a =>
                {
                    RangeAttribute range = (RangeAttribute)a;
                    return String.Format(CultureInfo.CurrentCulture, "Range: inclusive between {0} and {1}", range.Minimum, range.Maximum);
                }
            },
            { typeof(MaxLengthAttribute), a =>
                {
                    MaxLengthAttribute maxLength = (MaxLengthAttribute)a;
                    return String.Format(CultureInfo.CurrentCulture, "Max length: {0}", maxLength.Length);
                }
            },
            { typeof(MinLengthAttribute), a =>
                {
                    MinLengthAttribute minLength = (MinLengthAttribute)a;
                    return String.Format(CultureInfo.CurrentCulture, "Min length: {0}", minLength.Length);
                }
            },
            { typeof(StringLengthAttribute), a =>
                {
                    StringLengthAttribute strLength = (StringLengthAttribute)a;
                    return String.Format(CultureInfo.CurrentCulture, "String length: inclusive between {0} and {1}", strLength.MinimumLength, strLength.MaximumLength);
                }
            },
            { typeof(DataTypeAttribute), a =>
                {
                    DataTypeAttribute dataType = (DataTypeAttribute)a;
                    return String.Format(CultureInfo.CurrentCulture, "Data type: {0}", dataType.CustomDataType ?? dataType.DataType.ToString());
                }
            },
            { typeof(RegularExpressionAttribute), a =>
                {
                    RegularExpressionAttribute regularExpression = (RegularExpressionAttribute)a;
                    return String.Format(CultureInfo.CurrentCulture, "Matching regular expression pattern: {0}", regularExpression.Pattern);
                }
            },
        };

        // Modify this to add more default documentations.
        private readonly IDictionary<Type, string> DefaultTypeDocumentation = new Dictionary<Type, string>
        {
            { typeof(Int16), "integer" },
            { typeof(Int32), "integer" },
            { typeof(Int64), "integer" },
            { typeof(UInt16), "unsigned integer" },
            { typeof(UInt32), "unsigned integer" },
            { typeof(UInt64), "unsigned integer" },
            { typeof(Byte), "byte" },
            { typeof(Char), "character" },
            { typeof(SByte), "signed byte" },
            { typeof(Uri), "URI" },
            { typeof(Single), "decimal number" },
            { typeof(Double), "decimal number" },
            { typeof(Decimal), "decimal number" },
            { typeof(String), "string" },
            { typeof(Guid), "globally unique identifier" },
            { typeof(TimeSpan), "time interval" },
            { typeof(DateTime), "date" },
            { typeof(DateTimeOffset), "date" },
            { typeof(Boolean), "boolean" },
        };

        private Lazy<IModelDocumentationProvider> _documentationProvider;

        public ModelDescriptionGenerator(HttpConfiguration config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }

            _documentationProvider = new Lazy<IModelDocumentationProvider>(() => config.Services.GetDocumentationProvider() as IModelDocumentationProvider);
            GeneratedModels = new Dictionary<string, ModelDescription>(StringComparer.OrdinalIgnoreCase);
        }

        public Dictionary<string, ModelDescription> GeneratedModels { get; private set; }

        private IModelDocumentationProvider DocumentationProvider
        {
            get
            {
                return _documentationProvider.Value;
            }
        }

        public ModelDescription GetOrCreateModelDescription(Type modelType)
        {
            if (modelType == null)
            {
                throw new ArgumentNullException("modelType");
            }

            Type underlyingType = Nullable.GetUnderlyingType(modelType);
            if (underlyingType != null)
            {
                modelType = underlyingType;
            }

            ModelDescription modelDescription;
            string modelName = ModelNameHelper.GetModelName(modelType);
            if (GeneratedModels.TryGetValue(modelName, out modelDescription))
            {
                if (modelType != modelDescription.ModelType)
                {
                    throw new InvalidOperationException(
                        String.Format(
                            CultureInfo.CurrentCulture,
                            "A model description could not be created. Duplicate model name '{0}' was found for types '{1}' and '{2}'. " +
                            "Use the [ModelName] attribute to change the model name for at least one of the types so that it has a unique name.",
                            modelName,
                            modelDescription.ModelType.FullName,
                            modelType.FullName));
                }

                return modelDescription;
            }

            if (DefaultTypeDocumentation.ContainsKey(modelType))
            {
                return GenerateSimpleTypeModelDescription(modelType);
            }

            if (modelType.IsEnum)
            {
                return GenerateEnumTypeModelDescription(modelType);
            }

            if (modelType.IsGenericType)
            {
                Type[] genericArguments = modelType.GetGenericArguments();

                if (genericArguments.Length == 1)
                {
                    Type enumerableType = typeof(IEnumerable<>).MakeGenericType(genericArguments);
                    if (enumerableType.IsAssignableFrom(modelType))
                    {
                        return GenerateCollectionModelDescription(modelType, genericArguments[0]);
                    }
                }
                if (genericArguments.Length == 2)
                {
                    Type dictionaryType = typeof(IDictionary<,>).MakeGenericType(genericArguments);
                    if (dictionaryType.IsAssignableFrom(modelType))
                    {
                        return GenerateDictionaryModelDescription(modelType, genericArguments[0], genericArguments[1]);
                    }

                    Type keyValuePairType = typeof(KeyValuePair<,>).MakeGenericType(genericArguments);
                    if (keyValuePairType.IsAssignableFrom(modelType))
                    {
                        return GenerateKeyValuePairModelDescription(modelType, genericArguments[0], genericArguments[1]);
                    }
                }
            }

            if (modelType.IsArray)
            {
                Type elementType = modelType.GetElementType();
                return GenerateCollectionModelDescription(modelType, elementType);
            }

            if (modelType == typeof(NameValueCollection))
            {
                return GenerateDictionaryModelDescription(modelType, typeof(string), typeof(string));
            }

            if (typeof(IDictionary).IsAssignableFrom(modelType))
            {
                return GenerateDictionaryModelDescription(modelType, typeof(object), typeof(object));
            }

            if (typeof(IEnumerable).IsAssignableFrom(modelType))
            {
                return GenerateCollectionModelDescription(modelType, typeof(object));
            }

            return GenerateComplexTypeModelDescription(modelType);
        }

        // Change this to provide different name for the member.
        private static string GetMemberName(MemberInfo member, bool hasDataContractAttribute)
        {
            JsonPropertyAttribute jsonProperty = member.GetCustomAttribute<JsonPropertyAttribute>();
            if (jsonProperty != null && !String.IsNullOrEmpty(jsonProperty.PropertyName))
            {
                return jsonProperty.PropertyName;
            }

            if (hasDataContractAttribute)
            {
                DataMemberAttribute dataMember = member.GetCustomAttribute<DataMemberAttribute>();
                if (dataMember != null && !String.IsNullOrEmpty(dataMember.Name))
                {
                    return dataMember.Name;
                }
            }

            return member.Name;
        }

        private static bool ShouldDisplayMember(MemberInfo member, bool hasDataContractAttribute)
        {
            JsonIgnoreAttribute jsonIgnore = member.GetCustomAttribute<JsonIgnoreAttribute>();
            XmlIgnoreAttribute xmlIgnore = member.GetCustomAttribute<XmlIgnoreAttribute>();
            IgnoreDataMemberAttribute ignoreDataMember = member.GetCustomAttribute<IgnoreDataMemberAttribute>();
            NonSerializedAttribute nonSerialized = member.GetCustomAttribute<NonSerializedAttribute>();
            ApiExplorerSettingsAttribute apiExplorerSetting = member.GetCustomAttribute<ApiExplorerSettingsAttribute>();

            bool hasMemberAttribute = member.DeclaringType.IsEnum ?
                member.GetCustomAttribute<EnumMemberAttribute>() != null :
                member.GetCustomAttribute<DataMemberAttribute>() != null;

            // Display member only if all the followings are true:
            // no JsonIgnoreAttribute
            // no XmlIgnoreAttribute
            // no IgnoreDataMemberAttribute
            // no NonSerializedAttribute
            // no ApiExplorerSettingsAttribute with IgnoreApi set to true
            // no DataContractAttribute without DataMemberAttribute or EnumMemberAttribute
            return jsonIgnore == null &&
                xmlIgnore == null &&
                ignoreDataMember == null &&
                nonSerialized == null &&
                (apiExplorerSetting == null || !apiExplorerSetting.IgnoreApi) &&
                (!hasDataContractAttribute || hasMemberAttribute);
        }

        private string CreateDefaultDocumentation(Type type)
        {
            string documentation;
            if (DefaultTypeDocumentation.TryGetValue(type, out documentation))
            {
                return documentation;
            }
            if (DocumentationProvider != null)
            {
                documentation = DocumentationProvider.GetDocumentation(type);
            }

            return documentation;
        }

        private void GenerateAnnotations(MemberInfo property, ParameterDescription propertyModel)
        {
            List<ParameterAnnotation> annotations = new List<ParameterAnnotation>();

            IEnumerable<Attribute> attributes = property.GetCustomAttributes();
            foreach (Attribute attribute in attributes)
            {
                Func<object, string> textGenerator;
                if (AnnotationTextGenerator.TryGetValue(attribute.GetType(), out textGenerator))
                {
                    annotations.Add(
                        new ParameterAnnotation
                        {
                            AnnotationAttribute = attribute,
                            Documentation = textGenerator(attribute)
                        });
                }
            }

            // Rearrange the annotations
            annotations.Sort((x, y) =>
            {
                // Special-case RequiredAttribute so that it shows up on top
                if (x.AnnotationAttribute is RequiredAttribute)
                {
                    return -1;
                }
                if (y.AnnotationAttribute is RequiredAttribute)
                {
                    return 1;
                }

                // Sort the rest based on alphabetic order of the documentation
                return String.Compare(x.Documentation, y.Documentation, StringComparison.OrdinalIgnoreCase);
            });

            foreach (ParameterAnnotation annotation in annotations)
            {
                propertyModel.Annotations.Add(annotation);
            }
        }

        private CollectionModelDescription GenerateCollectionModelDescription(Type modelType, Type elementType)
        {
            ModelDescription collectionModelDescription = GetOrCreateModelDescription(elementType);
            if (collectionModelDescription != null)
            {
                return new CollectionModelDescription
                {
                    Name = ModelNameHelper.GetModelName(modelType),
                    ModelType = modelType,
                    ElementDescription = collectionModelDescription
                };
            }

            return null;
        }

        private ModelDescription GenerateComplexTypeModelDescription(Type modelType)
        {
            ComplexTypeModelDescription complexModelDescription = new ComplexTypeModelDescription
            {
                Name = ModelNameHelper.GetModelName(modelType),
                ModelType = modelType,
                Documentation = CreateDefaultDocumentation(modelType)
            };

            GeneratedModels.Add(complexModelDescription.Name, complexModelDescription);
            bool hasDataContractAttribute = modelType.GetCustomAttribute<DataContractAttribute>() != null;
            PropertyInfo[] properties = modelType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (PropertyInfo property in properties)
            {
                if (ShouldDisplayMember(property, hasDataContractAttribute))
                {
                    ParameterDescription propertyModel = new ParameterDescription
                    {
                        Name = GetMemberName(property, hasDataContractAttribute)
                    };

                    if (DocumentationProvider != null)
                    {
                        propertyModel.Documentation = DocumentationProvider.GetDocumentation(property);
                    }

                    GenerateAnnotations(property, propertyModel);
                    complexModelDescription.Properties.Add(propertyModel);
                    propertyModel.TypeDescription = GetOrCreateModelDescription(property.PropertyType);
                }
            }

            FieldInfo[] fields = modelType.GetFields(BindingFlags.Public | BindingFlags.Instance);
            foreach (FieldInfo field in fields)
            {
                if (ShouldDisplayMember(field, hasDataContractAttribute))
                {
                    ParameterDescription propertyModel = new ParameterDescription
                    {
                        Name = GetMemberName(field, hasDataContractAttribute)
                    };

                    if (DocumentationProvider != null)
                    {
                        propertyModel.Documentation = DocumentationProvider.GetDocumentation(field);
                    }

                    complexModelDescription.Properties.Add(propertyModel);
                    propertyModel.TypeDescription = GetOrCreateModelDescription(field.FieldType);
                }
            }

            return complexModelDescription;
        }

        private DictionaryModelDescription GenerateDictionaryModelDescription(Type modelType, Type keyType, Type valueType)
        {
            ModelDescription keyModelDescription = GetOrCreateModelDescription(keyType);
            ModelDescription valueModelDescription = GetOrCreateModelDescription(valueType);

            return new DictionaryModelDescription
            {
                Name = ModelNameHelper.GetModelName(modelType),
                ModelType = modelType,
                KeyModelDescription = keyModelDescription,
                ValueModelDescription = valueModelDescription
            };
        }

        private EnumTypeModelDescription GenerateEnumTypeModelDescription(Type modelType)
        {
            EnumTypeModelDescription enumDescription = new EnumTypeModelDescription
            {
                Name = ModelNameHelper.GetModelName(modelType),
                ModelType = modelType,
                Documentation = CreateDefaultDocumentation(modelType)
            };
            bool hasDataContractAttribute = modelType.GetCustomAttribute<DataContractAttribute>() != null;
            foreach (FieldInfo field in modelType.GetFields(BindingFlags.Public | BindingFlags.Static))
            {
                if (ShouldDisplayMember(field, hasDataContractAttribute))
                {
                    EnumValueDescription enumValue = new EnumValueDescription
                    {
                        Name = field.Name,
                        Value = field.GetRawConstantValue().ToString()
                    };
                    if (DocumentationProvider != null)
                    {
                        enumValue.Documentation = DocumentationProvider.GetDocumentation(field);
                    }
                    enumDescription.Values.Add(enumValue);
                }
            }
            GeneratedModels.Add(enumDescription.Name, enumDescription);

            return enumDescription;
        }

        private KeyValuePairModelDescription GenerateKeyValuePairModelDescription(Type modelType, Type keyType, Type valueType)
        {
            ModelDescription keyModelDescription = GetOrCreateModelDescription(keyType);
            ModelDescription valueModelDescription = GetOrCreateModelDescription(valueType);

            return new KeyValuePairModelDescription
            {
                Name = ModelNameHelper.GetModelName(modelType),
                ModelType = modelType,
                KeyModelDescription = keyModelDescription,
                ValueModelDescription = valueModelDescription
            };
        }

        private ModelDescription GenerateSimpleTypeModelDescription(Type modelType)
        {
            SimpleTypeModelDescription simpleModelDescription = new SimpleTypeModelDescription
            {
                Name = ModelNameHelper.GetModelName(modelType),
                ModelType = modelType,
                Documentation = CreateDefaultDocumentation(modelType)
            };
            GeneratedModels.Add(simpleModelDescription.Name, simpleModelDescription);

            return simpleModelDescription;
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/ModelNameAttribute.cs
================================================
using System;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    /// <summary>
    /// Use this attribute to change the name of the <see cref="ModelDescription"/> generated for a type.
    /// </summary>
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, AllowMultiple = false, Inherited = false)]
    public sealed class ModelNameAttribute : Attribute
    {
        public ModelNameAttribute(string name)
        {
            Name = name;
        }

        public string Name { get; private set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/ModelNameHelper.cs
================================================
using System;
using System.Globalization;
using System.Linq;
using System.Reflection;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    internal static class ModelNameHelper
    {
        // Modify this to provide custom model name mapping.
        public static string GetModelName(Type type)
        {
            ModelNameAttribute modelNameAttribute = type.GetCustomAttribute<ModelNameAttribute>();
            if (modelNameAttribute != null && !String.IsNullOrEmpty(modelNameAttribute.Name))
            {
                return modelNameAttribute.Name;
            }

            string modelName = type.Name;
            if (type.IsGenericType)
            {
                // Format the generic type name to something like: GenericOfAgurment1AndArgument2
                Type genericType = type.GetGenericTypeDefinition();
                Type[] genericArguments = type.GetGenericArguments();
                string genericTypeName = genericType.Name;

                // Trim the generic parameter counts from the name
                genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf('`'));
                string[] argumentTypeNames = genericArguments.Select(t => GetModelName(t)).ToArray();
                modelName = String.Format(CultureInfo.InvariantCulture, "{0}Of{1}", genericTypeName, String.Join("And", argumentTypeNames));
            }

            return modelName;
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/ParameterAnnotation.cs
================================================
using System;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class ParameterAnnotation
    {
        public Attribute AnnotationAttribute { get; set; }

        public string Documentation { get; set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/ParameterDescription.cs
================================================
using System.Collections.Generic;
using System.Collections.ObjectModel;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class ParameterDescription
    {
        public ParameterDescription()
        {
            Annotations = new Collection<ParameterAnnotation>();
        }

        public Collection<ParameterAnnotation> Annotations { get; private set; }

        public string Documentation { get; set; }

        public string Name { get; set; }

        public ModelDescription TypeDescription { get; set; }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/ModelDescriptions/SimpleTypeModelDescription.cs
================================================
namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
{
    public class SimpleTypeModelDescription : ModelDescription
    {
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Models/HelpPageApiModel.cs
================================================
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http.Headers;
using System.Web.Http.Description;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
{
    /// <summary>
    /// The model that represents an API displayed on the help page.
    /// </summary>
    public class HelpPageApiModel
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HelpPageApiModel"/> class.
        /// </summary>
        public HelpPageApiModel()
        {
            UriParameters = new Collection<ParameterDescription>();
            SampleRequests = new Dictionary<MediaTypeHeaderValue, object>();
            SampleResponses = new Dictionary<MediaTypeHeaderValue, object>();
            ErrorMessages = new Collection<string>();
        }

        /// <summary>
        /// Gets or sets the <see cref="ApiDescription"/> that describes the API.
        /// </summary>
        public ApiDescription ApiDescription { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="ParameterDescription"/> collection that describes the URI parameters for the API.
        /// </summary>
        public Collection<ParameterDescription> UriParameters { get; private set; }

        /// <summary>
        /// Gets or sets the documentation for the request.
        /// </summary>
        public string RequestDocumentation { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="ModelDescription"/> that describes the request body.
        /// </summary>
        public ModelDescription RequestModelDescription { get; set; }

        /// <summary>
        /// Gets the request body parameter descriptions.
        /// </summary>
        public IList<ParameterDescription> RequestBodyParameters
        {
            get
            {
                return GetParameterDescriptions(RequestModelDescription);
            }
        }

        /// <summary>
        /// Gets or sets the <see cref="ModelDescription"/> that describes the resource.
        /// </summary>
        public ModelDescription ResourceDescription { get; set; }

        /// <summary>
        /// Gets the resource property descriptions.
        /// </summary>
        public IList<ParameterDescription> ResourceProperties
        {
            get
            {
                return GetParameterDescriptions(ResourceDescription);
            }
        }

        /// <summary>
        /// Gets the sample requests associated with the API.
        /// </summary>
        public IDictionary<MediaTypeHeaderValue, object> SampleRequests { get; private set; }

        /// <summary>
        /// Gets the sample responses associated with the API.
        /// </summary>
        public IDictionary<MediaTypeHeaderValue, object> SampleResponses { get; private set; }

        /// <summary>
        /// Gets the error messages associated with this model.
        /// </summary>
        public Collection<string> ErrorMessages { get; private set; }

        private static IList<ParameterDescription> GetParameterDescriptions(ModelDescription modelDescription)
        {
            ComplexTypeModelDescription complexTypeModelDescription = modelDescription as ComplexTypeModelDescription;
            if (complexTypeModelDescription != null)
            {
                return complexTypeModelDescription.Properties;
            }

            CollectionModelDescription collectionModelDescription = modelDescription as CollectionModelDescription;
            if (collectionModelDescription != null)
            {
                complexTypeModelDescription = collectionModelDescription.ElementDescription as ComplexTypeModelDescription;
                if (complexTypeModelDescription != null)
                {
                    return complexTypeModelDescription.Properties;
                }
            }

            return null;
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/SampleGeneration/HelpPageSampleGenerator.cs
================================================
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Web.Http.Description;
using System.Xml.Linq;
using Newtonsoft.Json;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// This class will generate the samples for the help page.
    /// </summary>
    public class HelpPageSampleGenerator
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="HelpPageSampleGenerator"/> class.
        /// </summary>
        public HelpPageSampleGenerator()
        {
            ActualHttpMessageTypes = new Dictionary<HelpPageSampleKey, Type>();
            ActionSamples = new Dictionary<HelpPageSampleKey, object>();
            SampleObjects = new Dictionary<Type, object>();
            SampleObjectFactories = new List<Func<HelpPageSampleGenerator, Type, object>>
            {
                DefaultSampleObjectFactory,
            };
        }

        /// <summary>
        /// Gets CLR types that are used as the content of <see cref="HttpRequestMessage"/> or <see cref="HttpResponseMessage"/>.
        /// </summary>
        public IDictionary<HelpPageSampleKey, Type> ActualHttpMessageTypes { get; internal set; }

        /// <summary>
        /// Gets the objects that are used directly as samples for certain actions.
        /// </summary>
        public IDictionary<HelpPageSampleKey, object> ActionSamples { get; internal set; }

        /// <summary>
        /// Gets the objects that are serialized as samples by the supported formatters.
        /// </summary>
        public IDictionary<Type, object> SampleObjects { get; internal set; }

        /// <summary>
        /// Gets factories for the objects that the supported formatters will serialize as samples. Processed in order,
        /// stopping when the factory successfully returns a non-<see langref="null"/> object.
        /// </summary>
        /// <remarks>
        /// Collection includes just <see cref="ObjectGenerator.GenerateObject(Type)"/> initially. Use
        /// <code>SampleObjectFactories.Insert(0, func)</code> to provide an override and
        /// <code>SampleObjectFactories.Add(func)</code> to provide a fallback.</remarks>
        [SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification = "This is an appropriate nesting of generic types")]
        public IList<Func<HelpPageSampleGenerator, Type, object>> SampleObjectFactories { get; private set; }

        /// <summary>
        /// Gets the request body samples for a given <see cref="ApiDescription"/>.
        /// </summary>
        /// <param name="api">The <see cref="ApiDescription"/>.</param>
        /// <returns>The samples keyed by media type.</returns>
        public IDictionary<MediaTypeHeaderValue, object> GetSampleRequests(ApiDescription api)
        {
            return GetSample(api, SampleDirection.Request);
        }

        /// <summary>
        /// Gets the response body samples for a given <see cref="ApiDescription"/>.
        /// </summary>
        /// <param name="api">The <see cref="ApiDescription"/>.</param>
        /// <returns>The samples keyed by media type.</returns>
        public IDictionary<MediaTypeHeaderValue, object> GetSampleResponses(ApiDescription api)
        {
            return GetSample(api, SampleDirection.Response);
        }

        /// <summary>
        /// Gets the request or response body samples.
        /// </summary>
        /// <param name="api">The <see cref="ApiDescription"/>.</param>
        /// <param name="sampleDirection">The value indicating whether the sample is for a request or for a response.</param>
        /// <returns>The samples keyed by media type.</returns>
        public virtual IDictionary<MediaTypeHeaderValue, object> GetSample(ApiDescription api, SampleDirection sampleDirection)
        {
            if (api == null)
            {
                throw new ArgumentNullException("api");
            }
            string controllerName = api.ActionDescriptor.ControllerDescriptor.ControllerName;
            string actionName = api.ActionDescriptor.ActionName;
            IEnumerable<string> parameterNames = api.ParameterDescriptions.Select(p => p.Name);
            Collection<MediaTypeFormatter> formatters;
            Type type = ResolveType(api, controllerName, actionName, parameterNames, sampleDirection, out formatters);
            var samples = new Dictionary<MediaTypeHeaderValue, object>();

            // Use the samples provided directly for actions
            var actionSamples = GetAllActionSamples(controllerName, actionName, parameterNames, sampleDirection);
            foreach (var actionSample in actionSamples)
            {
                samples.Add(actionSample.Key.MediaType, WrapSampleIfString(actionSample.Value));
            }

            // Do the sample generation based on formatters only if an action doesn't return an HttpResponseMessage.
            // Here we cannot rely on formatters because we don't know what's in the HttpResponseMessage, it might not even use formatters.
            if (type != null && !typeof(HttpResponseMessage).IsAssignableFrom(type))
            {
                object sampleObject = GetSampleObject(type);
                foreach (var formatter in formatters)
                {
                    foreach (MediaTypeHeaderValue mediaType in formatter.SupportedMediaTypes)
                    {
                        if (!samples.ContainsKey(mediaType))
                        {
                            object sample = GetActionSample(controllerName, actionName, parameterNames, type, formatter, mediaType, sampleDirection);

                            // If no sample found, try generate sample using formatter and sample object
                            if (sample == null && sampleObject != null)
                            {
                                sample = WriteSampleObjectUsingFormatter(formatter, sampleObject, type, mediaType);
                            }

                            samples.Add(mediaType, WrapSampleIfString(sample));
                        }
                    }
                }
            }

            return samples;
        }

        /// <summary>
        /// Search for samples that are provided directly through <see cref="ActionSamples"/>.
        /// </summary>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        /// <param name="type">The CLR type.</param>
        /// <param name="formatter">The formatter.</param>
        /// <param name="mediaType">The media type.</param>
        /// <param name="sampleDirection">The value indicating whether the sample is for a request or for a response.</param>
        /// <returns>The sample that matches the parameters.</returns>
        public virtual object GetActionSample(string controllerName, string actionName, IEnumerable<string> parameterNames, Type type, MediaTypeFormatter formatter, MediaTypeHeaderValue mediaType, SampleDirection sampleDirection)
        {
            object sample;

            // First, try to get the sample provided for the specified mediaType, sampleDirection, controllerName, actionName and parameterNames.
            // If not found, try to get the sample provided for the specified mediaType, sampleDirection, controllerName and actionName regardless of the parameterNames.
            // If still not found, try to get the sample provided for the specified mediaType and type.
            // Finally, try to get the sample provided for the specified mediaType.
            if (ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType, sampleDirection, controllerName, actionName, parameterNames), out sample) ||
                ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType, sampleDirection, controllerName, actionName, new[] { "*" }), out sample) ||
                ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType, type), out sample) ||
                ActionSamples.TryGetValue(new HelpPageSampleKey(mediaType), out sample))
            {
                return sample;
            }

            return null;
        }

        /// <summary>
        /// Gets the sample object that will be serialized by the formatters. 
        /// First, it will look at the <see cref="SampleObjects"/>. If no sample object is found, it will try to create
        /// one using <see cref="DefaultSampleObjectFactory"/> (which wraps an <see cref="ObjectGenerator"/>) and other
        /// factories in <see cref="SampleObjectFactories"/>.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns>The sample object.</returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification = "Even if all items in SampleObjectFactories throw, problem will be visible as missing sample.")]
        public virtual object GetSampleObject(Type type)
        {
            object sampleObject;

            if (!SampleObjects.TryGetValue(type, out sampleObject))
            {
                // No specific object available, try our factories.
                foreach (Func<HelpPageSampleGenerator, Type, object> factory in SampleObjectFactories)
                {
                    if (factory == null)
                    {
                        continue;
                    }

                    try
                    {
                        sampleObject = factory(this, type);
                        if (sampleObject != null)
                        {
                            break;
                        }
                    }
                    catch
                    {
                        // Ignore any problems encountered in the factory; go on to the next one (if any).
                    }
                }
            }

            return sampleObject;
        }

        /// <summary>
        /// Resolves the actual type of <see cref="System.Net.Http.ObjectContent{T}"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
        /// </summary>
        /// <param name="api">The <see cref="ApiDescription"/>.</param>
        /// <returns>The type.</returns>
        public virtual Type ResolveHttpRequestMessageType(ApiDescription api)
        {
            string controllerName = api.ActionDescriptor.ControllerDescriptor.ControllerName;
            string actionName = api.ActionDescriptor.ActionName;
            IEnumerable<string> parameterNames = api.ParameterDescriptions.Select(p => p.Name);
            Collection<MediaTypeFormatter> formatters;
            return ResolveType(api, controllerName, actionName, parameterNames, SampleDirection.Request, out formatters);
        }

        /// <summary>
        /// Resolves the type of the action parameter or return value when <see cref="HttpRequestMessage"/> or <see cref="HttpResponseMessage"/> is used.
        /// </summary>
        /// <param name="api">The <see cref="ApiDescription"/>.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        /// <param name="sampleDirection">The value indicating whether the sample is for a request or a response.</param>
        /// <param name="formatters">The formatters.</param>
        [SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", Justification = "This is only used in advanced scenarios.")]
        public virtual Type ResolveType(ApiDescription api, string controllerName, string actionName, IEnumerable<string> parameterNames, SampleDirection sampleDirection, out Collection<MediaTypeFormatter> formatters)
        {
            if (!Enum.IsDefined(typeof(SampleDirection), sampleDirection))
            {
                throw new InvalidEnumArgumentException("sampleDirection", (int)sampleDirection, typeof(SampleDirection));
            }
            if (api == null)
            {
                throw new ArgumentNullException("api");
            }
            Type type;
            if (ActualHttpMessageTypes.TryGetValue(new HelpPageSampleKey(sampleDirection, controllerName, actionName, parameterNames), out type) ||
                ActualHttpMessageTypes.TryGetValue(new HelpPageSampleKey(sampleDirection, controllerName, actionName, new[] { "*" }), out type))
            {
                // Re-compute the supported formatters based on type
                Collection<MediaTypeFormatter> newFormatters = new Collection<MediaTypeFormatter>();
                foreach (var formatter in api.ActionDescriptor.Configuration.Formatters)
                {
                    if (IsFormatSupported(sampleDirection, formatter, type))
                    {
                        newFormatters.Add(formatter);
                    }
                }
                formatters = newFormatters;
            }
            else
            {
                switch (sampleDirection)
                {
                    case SampleDirection.Request:
                        ApiParameterDescription requestBodyParameter = api.ParameterDescriptions.FirstOrDefault(p => p.Source == ApiParameterSource.FromBody);
                        type = requestBodyParameter == null ? null : requestBodyParameter.ParameterDescriptor.ParameterType;
                        formatters = api.SupportedRequestBodyFormatters;
                        break;
                    case SampleDirection.Response:
                    default:
                        type = api.ResponseDescription.ResponseType ?? api.ResponseDescription.DeclaredType;
                        formatters = api.SupportedResponseFormatters;
                        break;
                }
            }

            return type;
        }

        /// <summary>
        /// Writes the sample object using formatter.
        /// </summary>
        /// <param name="formatter">The formatter.</param>
        /// <param name="value">The value.</param>
        /// <param name="type">The type.</param>
        /// <param name="mediaType">Type of the media.</param>
        /// <returns></returns>
        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "The exception is recorded as InvalidSample.")]
        public virtual object WriteSampleObjectUsingFormatter(MediaTypeFormatter formatter, object value, Type type, MediaTypeHeaderValue mediaType)
        {
            if (formatter == null)
            {
                throw new ArgumentNullException("formatter");
            }
            if (mediaType == null)
            {
                throw new ArgumentNullException("mediaType");
            }

            object sample = String.Empty;
            MemoryStream ms = null;
            HttpContent content = null;
            try
            {
                if (formatter.CanWriteType(type))
                {
                    ms = new MemoryStream();
                    content = new ObjectContent(type, value, formatter, mediaType);
                    formatter.WriteToStreamAsync(type, value, ms, content, null).Wait();
                    ms.Position = 0;
                    StreamReader reader = new StreamReader(ms);
                    string serializedSampleString = reader.ReadToEnd();
                    if (mediaType.MediaType.ToUpperInvariant().Contains("XML"))
                    {
                        serializedSampleString = TryFormatXml(serializedSampleString);
                    }
                    else if (mediaType.MediaType.ToUpperInvariant().Contains("JSON"))
                    {
                        serializedSampleString = TryFormatJson(serializedSampleString);
                    }

                    sample = new TextSample(serializedSampleString);
                }
                else
                {
                    sample = new InvalidSample(String.Format(
                        CultureInfo.CurrentCulture,
                        "Failed to generate the sample for media type '{0}'. Cannot use formatter '{1}' to write type '{2}'.",
                        mediaType,
                        formatter.GetType().Name,
                        type.Name));
                }
            }
            catch (Exception e)
            {
                sample = new InvalidSample(String.Format(
                    CultureInfo.CurrentCulture,
                    "An exception has occurred while using the formatter '{0}' to generate sample for media type '{1}'. Exception message: {2}",
                    formatter.GetType().Name,
                    mediaType.MediaType,
                    UnwrapException(e).Message));
            }
            finally
            {
                if (ms != null)
                {
                    ms.Dispose();
                }
                if (content != null)
                {
                    content.Dispose();
                }
            }

            return sample;
        }

        internal static Exception UnwrapException(Exception exception)
        {
            AggregateException aggregateException = exception as AggregateException;
            if (aggregateException != null)
            {
                return aggregateException.Flatten().InnerException;
            }
            return exception;
        }

        // Default factory for sample objects
        private static object DefaultSampleObjectFactory(HelpPageSampleGenerator sampleGenerator, Type type)
        {
            // Try to create a default sample object
            ObjectGenerator objectGenerator = new ObjectGenerator();
            return objectGenerator.GenerateObject(type);
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Handling the failure by returning the original string.")]
        private static string TryFormatJson(string str)
        {
            try
            {
                object parsedJson = JsonConvert.DeserializeObject(str);
                return JsonConvert.SerializeObject(parsedJson, Formatting.Indented);
            }
            catch
            {
                // can't parse JSON, return the original string
                return str;
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Handling the failure by returning the original string.")]
        private static string TryFormatXml(string str)
        {
            try
            {
                XDocument xml = XDocument.Parse(str);
                return xml.ToString();
            }
            catch
            {
                // can't parse XML, return the original string
                return str;
            }
        }

        private static bool IsFormatSupported(SampleDirection sampleDirection, MediaTypeFormatter formatter, Type type)
        {
            switch (sampleDirection)
            {
                case SampleDirection.Request:
                    return formatter.CanReadType(type);
                case SampleDirection.Response:
                    return formatter.CanWriteType(type);
            }
            return false;
        }

        private IEnumerable<KeyValuePair<HelpPageSampleKey, object>> GetAllActionSamples(string controllerName, string actionName, IEnumerable<string> parameterNames, SampleDirection sampleDirection)
        {
            HashSet<string> parameterNamesSet = new HashSet<string>(parameterNames, StringComparer.OrdinalIgnoreCase);
            foreach (var sample in ActionSamples)
            {
                HelpPageSampleKey sampleKey = sample.Key;
                if (String.Equals(controllerName, sampleKey.ControllerName, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(actionName, sampleKey.ActionName, StringComparison.OrdinalIgnoreCase) &&
                    (sampleKey.ParameterNames.SetEquals(new[] { "*" }) || parameterNamesSet.SetEquals(sampleKey.ParameterNames)) &&
                    sampleDirection == sampleKey.SampleDirection)
                {
                    yield return sample;
                }
            }
        }

        private static object WrapSampleIfString(object sample)
        {
            string stringSample = sample as string;
            if (stringSample != null)
            {
                return new TextSample(stringSample);
            }

            return sample;
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/SampleGeneration/HelpPageSampleKey.cs
================================================
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Net.Http.Headers;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// This is used to identify the place where the sample should be applied.
    /// </summary>
    public class HelpPageSampleKey
    {
        /// <summary>
        /// Creates a new <see cref="HelpPageSampleKey"/> based on media type.
        /// </summary>
        /// <param name="mediaType">The media type.</param>
        public HelpPageSampleKey(MediaTypeHeaderValue mediaType)
        {
            if (mediaType == null)
            {
                throw new ArgumentNullException("mediaType");
            }

            ActionName = String.Empty;
            ControllerName = String.Empty;
            MediaType = mediaType;
            ParameterNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
        }

        /// <summary>
        /// Creates a new <see cref="HelpPageSampleKey"/> based on media type and CLR type.
        /// </summary>
        /// <param name="mediaType">The media type.</param>
        /// <param name="type">The CLR type.</param>
        public HelpPageSampleKey(MediaTypeHeaderValue mediaType, Type type)
            : this(mediaType)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            ParameterType = type;
        }

        /// <summary>
        /// Creates a new <see cref="HelpPageSampleKey"/> based on <see cref="SampleDirection"/>, controller name, action name and parameter names.
        /// </summary>
        /// <param name="sampleDirection">The <see cref="SampleDirection"/>.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        public HelpPageSampleKey(SampleDirection sampleDirection, string controllerName, string actionName, IEnumerable<string> parameterNames)
        {
            if (!Enum.IsDefined(typeof(SampleDirection), sampleDirection))
            {
                throw new InvalidEnumArgumentException("sampleDirection", (int)sampleDirection, typeof(SampleDirection));
            }
            if (controllerName == null)
            {
                throw new ArgumentNullException("controllerName");
            }
            if (actionName == null)
            {
                throw new ArgumentNullException("actionName");
            }
            if (parameterNames == null)
            {
                throw new ArgumentNullException("parameterNames");
            }

            ControllerName = controllerName;
            ActionName = actionName;
            ParameterNames = new HashSet<string>(parameterNames, StringComparer.OrdinalIgnoreCase);
            SampleDirection = sampleDirection;
        }

        /// <summary>
        /// Creates a new <see cref="HelpPageSampleKey"/> based on media type, <see cref="SampleDirection"/>, controller name, action name and parameter names.
        /// </summary>
        /// <param name="mediaType">The media type.</param>
        /// <param name="sampleDirection">The <see cref="SampleDirection"/>.</param>
        /// <param name="controllerName">Name of the controller.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="parameterNames">The parameter names.</param>
        public HelpPageSampleKey(MediaTypeHeaderValue mediaType, SampleDirection sampleDirection, string controllerName, string actionName, IEnumerable<string> parameterNames)
            : this(sampleDirection, controllerName, actionName, parameterNames)
        {
            if (mediaType == null)
            {
                throw new ArgumentNullException("mediaType");
            }

            MediaType = mediaType;
        }

        /// <summary>
        /// Gets the name of the controller.
        /// </summary>
        /// <value>
        /// The name of the controller.
        /// </value>
        public string ControllerName { get; private set; }

        /// <summary>
        /// Gets the name of the action.
        /// </summary>
        /// <value>
        /// The name of the action.
        /// </value>
        public string ActionName { get; private set; }

        /// <summary>
        /// Gets the media type.
        /// </summary>
        /// <value>
        /// The media type.
        /// </value>
        public MediaTypeHeaderValue MediaType { get; private set; }

        /// <summary>
        /// Gets the parameter names.
        /// </summary>
        public HashSet<string> ParameterNames { get; private set; }

        public Type ParameterType { get; private set; }

        /// <summary>
        /// Gets the <see cref="SampleDirection"/>.
        /// </summary>
        public SampleDirection? SampleDirection { get; private set; }

        public override bool Equals(object obj)
        {
            HelpPageSampleKey otherKey = obj as HelpPageSampleKey;
            if (otherKey == null)
            {
                return false;
            }

            return String.Equals(ControllerName, otherKey.ControllerName, StringComparison.OrdinalIgnoreCase) &&
                String.Equals(ActionName, otherKey.ActionName, StringComparison.OrdinalIgnoreCase) &&
                (MediaType == otherKey.MediaType || (MediaType != null && MediaType.Equals(otherKey.MediaType))) &&
                ParameterType == otherKey.ParameterType &&
                SampleDirection == otherKey.SampleDirection &&
                ParameterNames.SetEquals(otherKey.ParameterNames);
        }

        public override int GetHashCode()
        {
            int hashCode = ControllerName.ToUpperInvariant().GetHashCode() ^ ActionName.ToUpperInvariant().GetHashCode();
            if (MediaType != null)
            {
                hashCode ^= MediaType.GetHashCode();
            }
            if (SampleDirection != null)
            {
                hashCode ^= SampleDirection.GetHashCode();
            }
            if (ParameterType != null)
            {
                hashCode ^= ParameterType.GetHashCode();
            }
            foreach (string parameterName in ParameterNames)
            {
                hashCode ^= parameterName.ToUpperInvariant().GetHashCode();
            }

            return hashCode;
        }
    }
}


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/SampleGeneration/ImageSample.cs
================================================
using System;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// This represents an image sample on the help page. There's a display template named ImageSample associated with this class.
    /// </summary>
    public class ImageSample
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="ImageSample"/> class.
        /// </summary>
        /// <param name="src">The URL of an image.</param>
        public ImageSample(string src)
        {
            if (src == null)
            {
                throw new ArgumentNullException("src");
            }
            Src = src;
        }

        public string Src { get; private set; }

        public override bool Equals(object obj)
        {
            ImageSample other = obj as ImageSample;
            return other != null && Src == other.Src;
        }

        public override int GetHashCode()
        {
            return Src.GetHashCode();
        }

        public override string ToString()
        {
            return Src;
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/SampleGeneration/InvalidSample.cs
================================================
using System;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// This represents an invalid sample on the help page. There's a display template named InvalidSample associated with this class.
    /// </summary>
    public class InvalidSample
    {
        public InvalidSample(string errorMessage)
        {
            if (errorMessage == null)
            {
                throw new ArgumentNullException("errorMessage");
            }
            ErrorMessage = errorMessage;
        }

        public string ErrorMessage { get; private set; }

        public override bool Equals(object obj)
        {
            InvalidSample other = obj as InvalidSample;
            return other != null && ErrorMessage == other.ErrorMessage;
        }

        public override int GetHashCode()
        {
            return ErrorMessage.GetHashCode();
        }

        public override string ToString()
        {
            return ErrorMessage;
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/SampleGeneration/ObjectGenerator.cs
================================================
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq;
using System.Reflection;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// This class will create an object of a given type and populate it with sample data.
    /// </summary>
    public class ObjectGenerator
    {
        internal const int DefaultCollectionSize = 2;
        private readonly SimpleTypeObjectGenerator SimpleObjectGenerator = new SimpleTypeObjectGenerator();

        /// <summary>
        /// Generates an object for a given type. The type needs to be public, have a public default constructor and settable public properties/fields. Currently it supports the following types:
        /// Simple types: <see cref="int"/>, <see cref="string"/>, <see cref="Enum"/>, <see cref="DateTime"/>, <see cref="Uri"/>, etc.
        /// Complex types: POCO types.
        /// Nullables: <see cref="Nullable{T}"/>.
        /// Arrays: arrays of simple types or complex types.
        /// Key value pairs: <see cref="KeyValuePair{TKey,TValue}"/>
        /// Tuples: <see cref="Tuple{T1}"/>, <see cref="Tuple{T1,T2}"/>, etc
        /// Dictionaries: <see cref="IDictionary{TKey,TValue}"/> or anything deriving from <see cref="IDictionary{TKey,TValue}"/>.
        /// Collections: <see cref="IList{T}"/>, <see cref="IEnumerable{T}"/>, <see cref="ICollection{T}"/>, <see cref="IList"/>, <see cref="IEnumerable"/>, <see cref="ICollection"/> or anything deriving from <see cref="ICollection{T}"/> or <see cref="IList"/>.
        /// Queryables: <see cref="IQueryable"/>, <see cref="IQueryable{T}"/>.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <returns>An object of the given type.</returns>
        public object GenerateObject(Type type)
        {
            return GenerateObject(type, new Dictionary<Type, object>());
        }

        [SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification = "Here we just want to return null if anything goes wrong.")]
        private object GenerateObject(Type type, Dictionary<Type, object> createdObjectReferences)
        {
            try
            {
                if (SimpleTypeObjectGenerator.CanGenerateObject(type))
                {
                    return SimpleObjectGenerator.GenerateObject(type);
                }

                if (type.IsArray)
                {
                    return GenerateArray(type, DefaultCollectionSize, createdObjectReferences);
                }

                if (type.IsGenericType)
                {
                    return GenerateGenericType(type, DefaultCollectionSize, createdObjectReferences);
                }

                if (type == typeof(IDictionary))
                {
                    return GenerateDictionary(typeof(Hashtable), DefaultCollectionSize, createdObjectReferences);
                }

                if (typeof(IDictionary).IsAssignableFrom(type))
                {
                    return GenerateDictionary(type, DefaultCollectionSize, createdObjectReferences);
                }

                if (type == typeof(IList) ||
                    type == typeof(IEnumerable) ||
                    type == typeof(ICollection))
                {
                    return GenerateCollection(typeof(ArrayList), DefaultCollectionSize, createdObjectReferences);
                }

                if (typeof(IList).IsAssignableFrom(type))
                {
                    return GenerateCollection(type, DefaultCollectionSize, createdObjectReferences);
                }

                if (type == typeof(IQueryable))
                {
                    return GenerateQueryable(type, DefaultCollectionSize, createdObjectReferences);
                }

                if (type.IsEnum)
                {
                    return GenerateEnum(type);
                }

                if (type.IsPublic || type.IsNestedPublic)
                {
                    return GenerateComplexObject(type, createdObjectReferences);
                }
            }
            catch
            {
                // Returns null if anything fails
                return null;
            }

            return null;
        }

        private static object GenerateGenericType(Type type, int collectionSize, Dictionary<Type, object> createdObjectReferences)
        {
            Type genericTypeDefinition = type.GetGenericTypeDefinition();
            if (genericTypeDefinition == typeof(Nullable<>))
            {
                return GenerateNullable(type, createdObjectReferences);
            }

            if (genericTypeDefinition == typeof(KeyValuePair<,>))
            {
                return GenerateKeyValuePair(type, createdObjectReferences);
            }

            if (IsTuple(genericTypeDefinition))
            {
                return GenerateTuple(type, createdObjectReferences);
            }

            Type[] genericArguments = type.GetGenericArguments();
            if (genericArguments.Length == 1)
            {
                if (genericTypeDefinition == typeof(IList<>) ||
                    genericTypeDefinition == typeof(IEnumerable<>) ||
                    genericTypeDefinition == typeof(ICollection<>))
                {
                    Type collectionType = typeof(List<>).MakeGenericType(genericArguments);
                    return GenerateCollection(collectionType, collectionSize, createdObjectReferences);
                }

                if (genericTypeDefinition == typeof(IQueryable<>))
                {
                    return GenerateQueryable(type, collectionSize, createdObjectReferences);
                }

                Type closedCollectionType = typeof(ICollection<>).MakeGenericType(genericArguments[0]);
                if (closedCollectionType.IsAssignableFrom(type))
                {
                    return GenerateCollection(type, collectionSize, createdObjectReferences);
                }
            }

            if (genericArguments.Length == 2)
            {
                if (genericTypeDefinition == typeof(IDictionary<,>))
                {
                    Type dictionaryType = typeof(Dictionary<,>).MakeGenericType(genericArguments);
                    return GenerateDictionary(dictionaryType, collectionSize, createdObjectReferences);
                }

                Type closedDictionaryType = typeof(IDictionary<,>).MakeGenericType(genericArguments[0], genericArguments[1]);
                if (closedDictionaryType.IsAssignableFrom(type))
                {
                    return GenerateDictionary(type, collectionSize, createdObjectReferences);
                }
            }

            if (type.IsPublic || type.IsNestedPublic)
            {
                return GenerateComplexObject(type, createdObjectReferences);
            }

            return null;
        }

        private static object GenerateTuple(Type type, Dictionary<Type, object> createdObjectReferences)
        {
            Type[] genericArgs = type.GetGenericArguments();
            object[] parameterValues = new object[genericArgs.Length];
            bool failedToCreateTuple = true;
            ObjectGenerator objectGenerator = new ObjectGenerator();
            for (int i = 0; i < genericArgs.Length; i++)
            {
                parameterValues[i] = objectGenerator.GenerateObject(genericArgs[i], createdObjectReferences);
                failedToCreateTuple &= parameterValues[i] == null;
            }
            if (failedToCreateTuple)
            {
                return null;
            }
            object result = Activator.CreateInstance(type, parameterValues);
            return result;
        }

        private static bool IsTuple(Type genericTypeDefinition)
        {
            return genericTypeDefinition == typeof(Tuple<>) ||
                genericTypeDefinition == typeof(Tuple<,>) ||
                genericTypeDefinition == typeof(Tuple<,,>) ||
                genericTypeDefinition == typeof(Tuple<,,,>) ||
                genericTypeDefinition == typeof(Tuple<,,,,>) ||
                genericTypeDefinition == typeof(Tuple<,,,,,>) ||
                genericTypeDefinition == typeof(Tuple<,,,,,,>) ||
                genericTypeDefinition == typeof(Tuple<,,,,,,,>);
        }

        private static object GenerateKeyValuePair(Type keyValuePairType, Dictionary<Type, object> createdObjectReferences)
        {
            Type[] genericArgs = keyValuePairType.GetGenericArguments();
            Type typeK = genericArgs[0];
            Type typeV = genericArgs[1];
            ObjectGenerator objectGenerator = new ObjectGenerator();
            object keyObject = objectGenerator.GenerateObject(typeK, createdObjectReferences);
            object valueObject = objectGenerator.GenerateObject(typeV, createdObjectReferences);
            if (keyObject == null && valueObject == null)
            {
                // Failed to create key and values
                return null;
            }
            object result = Activator.CreateInstance(keyValuePairType, keyObject, valueObject);
            return result;
        }

        private static object GenerateArray(Type arrayType, int size, Dictionary<Type, object> createdObjectReferences)
        {
            Type type = arrayType.GetElementType();
            Array result = Array.CreateInstance(type, size);
            bool areAllElementsNull = true;
            ObjectGenerator objectGenerator = new ObjectGenerator();
            for (int i = 0; i < size; i++)
            {
                object element = objectGenerator.GenerateObject(type, createdObjectReferences);
                result.SetValue(element, i);
                areAllElementsNull &= element == null;
            }

            if (areAllElementsNull)
            {
                return null;
            }

            return result;
        }

        private static object GenerateDictionary(Type dictionaryType, int size, Dictionary<Type, object> createdObjectReferences)
        {
            Type typeK = typeof(object);
            Type typeV = typeof(object);
            if (dictionaryType.IsGenericType)
            {
                Type[] genericArgs = dictionaryType.GetGenericArguments();
                typeK = genericArgs[0];
                typeV = genericArgs[1];
            }

            object result = Activator.CreateInstance(dictionaryType);
            MethodInfo addMethod = dictionaryType.GetMethod("Add") ?? dictionaryType.GetMethod("TryAdd");
            MethodInfo containsMethod = dictionaryType.GetMethod("Contains") ?? dictionaryType.GetMethod("ContainsKey");
            ObjectGenerator objectGenerator = new ObjectGenerator();
            for (int i = 0; i < size; i++)
            {
                object newKey = objectGenerator.GenerateObject(typeK, createdObjectReferences);
                if (newKey == null)
                {
                    // Cannot generate a valid key
                    return null;
                }

                bool containsKey = (bool)containsMethod.Invoke(result, new object[] { newKey });
                if (!containsKey)
                {
                    object newValue = objectGenerator.GenerateObject(typeV, createdObjectReferences);
                    addMethod.Invoke(result, new object[] { newKey, newValue });
                }
            }

            return result;
        }

        private static object GenerateEnum(Type enumType)
        {
            Array possibleValues = Enum.GetValues(enumType);
            if (possibleValues.Length > 0)
            {
                return possibleValues.GetValue(0);
            }
            return null;
        }

        private static object GenerateQueryable(Type queryableType, int size, Dictionary<Type, object> createdObjectReferences)
        {
            bool isGeneric = queryableType.IsGenericType;
            object list;
            if (isGeneric)
            {
                Type listType = typeof(List<>).MakeGenericType(queryableType.GetGenericArguments());
                list = GenerateCollection(listType, size, createdObjectReferences);
            }
            else
            {
                list = GenerateArray(typeof(object[]), size, createdObjectReferences);
            }
            if (list == null)
            {
                return null;
            }
            if (isGeneric)
            {
                Type argumentType = typeof(IEnumerable<>).MakeGenericType(queryableType.GetGenericArguments());
                MethodInfo asQueryableMethod = typeof(Queryable).GetMethod("AsQueryable", new[] { argumentType });
                return asQueryableMethod.Invoke(null, new[] { list });
            }

            return Queryable.AsQueryable((IEnumerable)list);
        }

        private static object GenerateCollection(Type collectionType, int size, Dictionary<Type, object> createdObjectReferences)
        {
            Type type = collectionType.IsGenericType ?
                collectionType.GetGenericArguments()[0] :
                typeof(object);
            object result = Activator.CreateInstance(collectionType);
            MethodInfo addMethod = collectionType.GetMethod("Add");
            bool areAllElementsNull = true;
            ObjectGenerator objectGenerator = new ObjectGenerator();
            for (int i = 0; i < size; i++)
            {
                object element = objectGenerator.GenerateObject(type, createdObjectReferences);
                addMethod.Invoke(result, new object[] { element });
                areAllElementsNull &= element == null;
            }

            if (areAllElementsNull)
            {
                return null;
            }

            return result;
        }

        private static object GenerateNullable(Type nullableType, Dictionary<Type, object> createdObjectReferences)
        {
            Type type = nullableType.GetGenericArguments()[0];
            ObjectGenerator objectGenerator = new ObjectGenerator();
            return objectGenerator.GenerateObject(type, createdObjectReferences);
        }

        private static object GenerateComplexObject(Type type, Dictionary<Type, object> createdObjectReferences)
        {
            object result = null;

            if (createdObjectReferences.TryGetValue(type, out result))
            {
                // The object has been created already, just return it. This will handle the circular reference case.
                return result;
            }

            if (type.IsValueType)
            {
                result = Activator.CreateInstance(type);
            }
            else
            {
                ConstructorInfo defaultCtor = type.GetConstructor(Type.EmptyTypes);
                if (defaultCtor == null)
                {
                    // Cannot instantiate the type because it doesn't have a default constructor
                    return null;
                }

                result = defaultCtor.Invoke(new object[0]);
            }
            createdObjectReferences.Add(type, result);
            SetPublicProperties(type, result, createdObjectReferences);
            SetPublicFields(type, result, createdObjectReferences);
            return result;
        }

        private static void SetPublicProperties(Type type, object obj, Dictionary<Type, object> createdObjectReferences)
        {
            PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            ObjectGenerator objectGenerator = new ObjectGenerator();
            foreach (PropertyInfo property in properties)
            {
                if (property.CanWrite)
                {
                    object propertyValue = objectGenerator.GenerateObject(property.PropertyType, createdObjectReferences);
                    property.SetValue(obj, propertyValue, null);
                }
            }
        }

        private static void SetPublicFields(Type type, object obj, Dictionary<Type, object> createdObjectReferences)
        {
            FieldInfo[] fields = type.GetFields(BindingFlags.Public | BindingFlags.Instance);
            ObjectGenerator objectGenerator = new ObjectGenerator();
            foreach (FieldInfo field in fields)
            {
                object fieldValue = objectGenerator.GenerateObject(field.FieldType, createdObjectReferences);
                field.SetValue(obj, fieldValue);
            }
        }

        private class SimpleTypeObjectGenerator
        {
            private long _index = 0;
            private static readonly Dictionary<Type, Func<long, object>> DefaultGenerators = InitializeGenerators();

            [SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification = "These are simple type factories and cannot be split up.")]
            private static Dictionary<Type, Func<long, object>> InitializeGenerators()
            {
                return new Dictionary<Type, Func<long, object>>
                {
                    { typeof(Boolean), index => true },
                    { typeof(Byte), index => (Byte)64 },
                    { typeof(Char), index => (Char)65 },
                    { typeof(DateTime), index => DateTime.Now },
                    { typeof(DateTimeOffset), index => new DateTimeOffset(DateTime.Now) },
                    { typeof(DBNull), index => DBNull.Value },
                    { typeof(Decimal), index => (Decimal)index },
                    { typeof(Double), index => (Double)(index + 0.1) },
                    { typeof(Guid), index => Guid.NewGuid() },
                    { typeof(Int16), index => (Int16)(index % Int16.MaxValue) },
                    { typeof(Int32), index => (Int32)(index % Int32.MaxValue) },
                    { typeof(Int64), index => (Int64)index },
                    { typeof(Object), index => new object() },
                    { typeof(SByte), index => (SByte)64 },
                    { typeof(Single), index => (Single)(index + 0.1) },
                    { 
                        typeof(String), index =>
                        {
                            return String.Format(CultureInfo.CurrentCulture, "sample string {0}", index);
                        }
                    },
                    { 
                        typeof(TimeSpan), index =>
                        {
                            return TimeSpan.FromTicks(1234567);
                        }
                    },
                    { typeof(UInt16), index => (UInt16)(index % UInt16.MaxValue) },
                    { typeof(UInt32), index => (UInt32)(index % UInt32.MaxValue) },
                    { typeof(UInt64), index => (UInt64)index },
                    { 
                        typeof(Uri), index =>
                        {
                            return new Uri(String.Format(CultureInfo.CurrentCulture, "http://webapihelppage{0}.com", index));
                        }
                    },
                };
            }

            public static bool CanGenerateObject(Type type)
            {
                return DefaultGenerators.ContainsKey(type);
            }

            public object GenerateObject(Type type)
            {
                return DefaultGenerators[type](++_index);
            }
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/SampleGeneration/SampleDirection.cs
================================================
namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// Indicates whether the sample is used for request or response
    /// </summary>
    public enum SampleDirection
    {
        Request = 0,
        Response
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/SampleGeneration/TextSample.cs
================================================
using System;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// This represents a preformatted text sample on the help page. There's a display template named TextSample associated with this class.
    /// </summary>
    public class TextSample
    {
        public TextSample(string text)
        {
            if (text == null)
            {
                throw new ArgumentNullException("text");
            }
            Text = text;
        }

        public string Text { get; private set; }

        public override bool Equals(object obj)
        {
            TextSample other = obj as TextSample;
            return other != null && Text == other.Text;
        }

        public override int GetHashCode()
        {
            return Text.GetHashCode();
        }

        public override string ToString()
        {
            return Text;
        }
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/Api.cshtml
================================================
@using System.Web.Http
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
@model HelpPageApiModel

@{
    var description = Model.ApiDescription;
    ViewBag.Title = description.HttpMethod.Method + " " + description.RelativePath;
}

<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
<div id="body" class="help-page">
    <section class="featured">
        <div class="content-wrapper">
            <p>
                @Html.ActionLink("Help Page Home", "Index")
            </p>
        </div>
    </section>
    <section class="content-wrapper main-content clear-fix">
        @Html.DisplayForModel()
    </section>
</div>


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/ApiGroup.cshtml
================================================
@using System.Web.Http
@using System.Web.Http.Controllers
@using System.Web.Http.Description
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
@model IGrouping<HttpControllerDescriptor, ApiDescription>

@{
    var controllerDocumentation = ViewBag.DocumentationProvider != null ? 
        ViewBag.DocumentationProvider.GetDocumentation(Model.Key) : 
        null;
}

<h2 id="@Model.Key.ControllerName">@Model.Key.ControllerName</h2>
@if (!String.IsNullOrEmpty(controllerDocumentation))
{
    <p>@controllerDocumentation</p>
}
<table class="help-page-table">
    <thead>
        <tr><th>API</th><th>Description</th></tr>
    </thead>
    <tbody>
    @foreach (var api in Model)
    {
        <tr>
            <td class="api-name"><a href="@Url.Action("Api", "Help", new { apiId = api.GetFriendlyId() })">@api.HttpMethod.Method @api.RelativePath</a></td>
            <td class="api-documentation">
            @if (api.Documentation != null)
            {
                <p>@api.Documentation</p>
            }
            else
            {
                <p>No documentation available.</p>
            }
            </td>
        </tr>
    }
    </tbody>
</table>

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/CollectionModelDescription.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model CollectionModelDescription
@if (Model.ElementDescription is ComplexTypeModelDescription)
{
    @Html.DisplayFor(m => m.ElementDescription)
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/ComplexTypeModelDescription.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model ComplexTypeModelDescription
@Html.DisplayFor(m => m.Properties, "Parameters")

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/DictionaryModelDescription.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model DictionaryModelDescription
Dictionary of @Html.DisplayFor(m => Model.KeyModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.KeyModelDescription }) [key]
and @Html.DisplayFor(m => Model.ValueModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.ValueModelDescription }) [value]

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/EnumTypeModelDescription.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model EnumTypeModelDescription

<p>Possible enumeration values:</p>

<table class="help-page-table">
    <thead>
        <tr><th>Name</th><th>Value</th><th>Description</th></tr>
    </thead>
    <tbody>
        @foreach (EnumValueDescription value in Model.Values)
        {
            <tr>
                <td class="enum-name"><b>@value.Name</b></td>
                <td class="enum-value">
                    <p>@value.Value</p>
                </td>
                <td class="enum-description">
                    <p>@value.Documentation</p>
                </td>
            </tr>
        }
    </tbody>
</table>

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/HelpPageApiModel.cshtml
================================================
@using System.Web.Http
@using System.Web.Http.Description
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model HelpPageApiModel

@{
    ApiDescription description = Model.ApiDescription;
}
<h1>@description.HttpMethod.Method @description.RelativePath</h1>
<div>
    <p>@description.Documentation</p>

    <h2>Request Information</h2>

    <h3>URI Parameters</h3>
    @Html.DisplayFor(m => m.UriParameters, "Parameters")

    <h3>Body Parameters</h3>

    <p>@Model.RequestDocumentation</p>

    @if (Model.RequestModelDescription != null)
    {
        @Html.DisplayFor(m => m.RequestModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.RequestModelDescription })
        if (Model.RequestBodyParameters != null)
        {
            @Html.DisplayFor(m => m.RequestBodyParameters, "Parameters")
        }
    }
    else
    {
        <p>None.</p>
    }

    @if (Model.SampleRequests.Count > 0)
    {
        <h3>Request Formats</h3>
        @Html.DisplayFor(m => m.SampleRequests, "Samples")
    }

    <h2>Response Information</h2>

    <h3>Resource Description</h3>

    <p>@description.ResponseDescription.Documentation</p>

    @if (Model.ResourceDescription != null)
    {
        @Html.DisplayFor(m => m.ResourceDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.ResourceDescription })
        if (Model.ResourceProperties != null)
        {
            @Html.DisplayFor(m => m.ResourceProperties, "Parameters")
        }
    }
    else
    {
        <p>None.</p>
    }

    @if (Model.SampleResponses.Count > 0)
    {
        <h3>Response Formats</h3>
        @Html.DisplayFor(m => m.SampleResponses, "Samples")
    }

</div>

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/ImageSample.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@model ImageSample

<img src="@Model.Src" />

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/InvalidSample.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@model InvalidSample

@if (HttpContext.Current.IsDebuggingEnabled)
{
    <div class="warning-message-container">
        <p>@Model.ErrorMessage</p>
    </div>
}
else
{
    <p>Sample not available.</p>
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/KeyValuePairModelDescription.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model KeyValuePairModelDescription
Pair of @Html.DisplayFor(m => Model.KeyModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.KeyModelDescription }) [key]
and @Html.DisplayFor(m => Model.ValueModelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = Model.ValueModelDescription }) [value]

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/ModelDescriptionLink.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model Type
@{
    ModelDescription modelDescription = ViewBag.modelDescription;
    if (modelDescription is ComplexTypeModelDescription || modelDescription is EnumTypeModelDescription)
    {
        if (Model == typeof(Object))
        {
            @:Object
        }
        else
        {
            @Html.ActionLink(modelDescription.Name, "ResourceModel", "Help", new { modelName = modelDescription.Name }, null)
        }
    }
    else if (modelDescription is CollectionModelDescription)
    {
        var collectionDescription = modelDescription as CollectionModelDescription;
        var elementDescription = collectionDescription.ElementDescription;
        @:Collection of @Html.DisplayFor(m => elementDescription.ModelType, "ModelDescriptionLink", new { modelDescription = elementDescription })
    }
    else
    {
        @Html.DisplayFor(m => modelDescription)
    }
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/Parameters.cshtml
================================================
@using System.Collections.Generic
@using System.Collections.ObjectModel
@using System.Web.Http.Description
@using System.Threading
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model IList<ParameterDescription>

@if (Model.Count > 0)
{
    <table class="help-page-table">
        <thead>
            <tr><th>Name</th><th>Description</th><th>Type</th><th>Additional information</th></tr>
        </thead>
        <tbody>
            @foreach (ParameterDescription parameter in Model)
            {
                ModelDescription modelDescription = parameter.TypeDescription;
                <tr>
                    <td class="parameter-name">@parameter.Name</td>
                    <td class="parameter-documentation">
                        <p>@parameter.Documentation</p>
                    </td>
                    <td class="parameter-type">
                        @Html.DisplayFor(m => modelDescription.ModelType, "ModelDescriptionLink", new { modelDescription = modelDescription })
                    </td>
                    <td class="parameter-annotations">
                        @if (parameter.Annotations.Count > 0)
                        {
                            foreach (var annotation in parameter.Annotations)
                            {
                                <p>@annotation.Documentation</p>
                            }
                        }
                        else
                        {
                            <p>None.</p>
                        }
                    </td>
                </tr>
            }
        </tbody>
    </table>
}
else
{
    <p>None.</p>
}



================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/Samples.cshtml
================================================
@using System.Net.Http.Headers
@model Dictionary<MediaTypeHeaderValue, object>

@{
    // Group the samples into a single tab if they are the same.
    Dictionary<string, object> samples = Model.GroupBy(pair => pair.Value).ToDictionary(
        pair => String.Join(", ", pair.Select(m => m.Key.ToString()).ToArray()), 
        pair => pair.Key);
    var mediaTypes = samples.Keys;
}
<div>
    @foreach (var mediaType in mediaTypes)
    {
        <h4 class="sample-header">@mediaType</h4>
        <div class="sample-content">
            <span><b>Sample:</b></span>
            @{
                var sample = samples[mediaType];
                if (sample == null)
                {
                    <p>Sample not available.</p>
                }
                else
                {
                    @Html.DisplayFor(s => sample);
                }
            }
        </div>
    }
</div>

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/SimpleTypeModelDescription.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model SimpleTypeModelDescription
@Model.Documentation

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/DisplayTemplates/TextSample.cshtml
================================================
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@model TextSample

<pre class="wrapped">
@Model.Text
</pre>

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/Index.cshtml
================================================
@using System.Web.Http
@using System.Web.Http.Controllers
@using System.Web.Http.Description
@using System.Collections.ObjectModel
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
@model Collection<ApiDescription>

@{
    ViewBag.Title = "ASP.NET Web API Help Page";

    // Group APIs by controller
    ILookup<HttpControllerDescriptor, ApiDescription> apiGroups = Model.ToLookup(api => api.ActionDescriptor.ControllerDescriptor);
}

<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
<header class="help-page">
    <div class="content-wrapper">
        <div class="float-left">
            <h1>@ViewBag.Title</h1>
        </div>
    </div>
</header>
<div id="body" class="help-page">
    <section class="featured">
        <div class="content-wrapper">
            <h2>Introduction</h2>
            <p>
                Provide a general description of your APIs here.
            </p>
        </div>
    </section>
    <section class="content-wrapper main-content clear-fix">
        @foreach (var group in apiGroups)
        {
            @Html.DisplayFor(m => group, "ApiGroup")
        }
    </section>
</div>


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Help/ResourceModel.cshtml
================================================
@using System.Web.Http
@using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@model ModelDescription

<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
<div id="body" class="help-page">
    <section class="featured">
        <div class="content-wrapper">
            <p>
                @Html.ActionLink("Help Page Home", "Index")
            </p>
        </div>
    </section>
    <h1>@Model.Name</h1>
    <p>@Model.Documentation</p>
    <section class="content-wrapper main-content clear-fix">
        @Html.DisplayFor(m => Model)
    </section>
</div>


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Shared/_Layout.cshtml
================================================
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width" />
    <title>@ViewBag.Title</title>
    @RenderSection("scripts", required: false)
</head>
<body>
    @RenderBody()
</body>
</html>

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/Web.config
================================================
<?xml version="1.0"?>

<configuration>
  <configSections>
    <sectionGroup name="system.web.webPages.razor" type="System.Web.WebPages.Razor.Configuration.RazorWebSectionGroup, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
      <section name="host" type="System.Web.WebPages.Razor.Configuration.HostSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
      <section name="pages" type="System.Web.WebPages.Razor.Configuration.RazorPagesSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
    </sectionGroup>
  </configSections>

  <system.web.webPages.razor>
    <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=5.3.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
    <pages pageBaseType="System.Web.Mvc.WebViewPage">
      <namespaces>
        <add namespace="System.Web.Mvc" />
        <add namespace="System.Web.Mvc.Ajax" />
        <add namespace="System.Web.Mvc.Html" />
        <add namespace="System.Web.Routing" />
      </namespaces>
    </pages>
  </system.web.webPages.razor>

  <appSettings>
    <add key="webpages:Enabled" value="false" />
  </appSettings>

  <system.web>
    <compilation debug="true">
      <assemblies>
        <add assembly="System.Net.Http, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
      </assemblies>
    </compilation>
  </system.web>

  <system.webServer>
    <handlers>
      <remove name="BlockViewHandler"/>
      <add name="BlockViewHandler" path="*" verb="*" preCondition="integratedMode" type="System.Web.HttpNotFoundHandler" />
    </handlers>
  </system.webServer>
</configuration>


================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/Views/_ViewStart.cshtml
================================================
@{
    // Change the Layout path below to blend the look and feel of the help page with your existing web pages.
    Layout = "~/Areas/HelpPage/Views/Shared/_Layout.cshtml";
}

================================================
FILE: src/WebApiHelpPage/Areas/HelpPage/XmlDocumentationProvider.cs
================================================
using System;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Http.Controllers;
using System.Web.Http.Description;
using System.Xml.XPath;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;

namespace ROOT_PROJECT_NAMESPACE.Areas.HelpPage
{
    /// <summary>
    /// A custom <see cref="IDocumentationProvider"/> that reads the API documentation from an XML documentation file.
    /// </summary>
    public class XmlDocumentationProvider : IDocumentationProvider, IModelDocumentationProvider
    {
        private XPathNavigator _documentNavigator;
        private const string TypeExpression = "/doc/members/member[@name='T:{0}']";
        private const string MethodExpression = "/doc/members/member[@name='M:{0}']";
        private const string PropertyExpression = "/doc/members/member[@name='P:{0}']";
        private const string FieldExpression = "/doc/members/member[@name='F:{0}']";
        private const string ParameterExpression = "param[@name='{0}']";

        /// <summary>
        /// Initializes a new instance of the <see cref="XmlDocumentationProvider"/> class.
        /// </summary>
        /// <param name="documentPath">The physical path to XML document.</param>
        public XmlDocumentationProvider(string documentPath)
        {
            if (documentPath == null)
            {
                throw new ArgumentNullException("documentPath");
            }
            XPathDocument xpath = new XPathDocument(documentPath);
            _documentNavigator = xpath.CreateNavigator();
        }

        public string GetDocumentation(HttpControllerDescriptor controllerDescriptor)
        {
            XPathNavigator typeNode = GetTypeNode(controllerDescriptor.ControllerType);
            return GetTagValue(typeNode, "summary");
        }

        public virtual string GetDocumentation(HttpActionDescriptor actionDescriptor)
        {
            XPathNavigator methodNode = GetMethodNode(actionDescriptor);
            return GetTagValue(methodNode, "summary");
        }

        public virtual string GetDocumentation(HttpParameterDescriptor parameterDescriptor)
        {
            ReflectedHttpParameterDescriptor reflectedParameterDescriptor = parameterDescriptor as ReflectedHttpParameterDescriptor;
            if (reflectedParameterDescriptor != null)
            {
                XPathNavigator methodNode = GetMethodNode(reflectedParameterDescriptor.ActionDescriptor);
                if (methodNode != null)
                {
                    string parameterName = reflectedParameterDescriptor.ParameterInfo.Name;
                    XPathNavigator parameterNode = methodNode.SelectSingleNode(String.Format(CultureInfo.InvariantCulture, ParameterExpression, parameterName));
                    if (parameterNode != null)
                    {
                        return parameterNode.Value.Trim();
                    }
                }
            }

            return null;
        }

        public string GetResponseDocumentation(HttpActionDescriptor actionDescriptor)
        {
            XPathNavigator methodNode = GetMethodNode(actionDescriptor);
            return GetTagValue(methodNode, "returns");
        }

        public string GetDocumentation(MemberInfo member)
        {
            string memberName = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", GetTypeName(member.DeclaringType), member.Name);
            string expression = member.MemberType == MemberTypes.Field ? FieldExpression : PropertyExpression;
            string selectExpression = String.Format(CultureInfo.InvariantCulture, expression, memberName);
            XPathNavigator propertyNode = _documentNavigator.SelectSingleNode(selectExpression);
            return GetTagValue(propertyNode, "summary");
        }

        public string GetDocumentation(Type type)
        {
            XPathNavigator typeNode = GetTypeNode(type);
            return GetTagValue(typeNode, "summary");
        }

        private XPathNavigator GetMethodNode(HttpActionDescriptor actionDescriptor)
        {
            ReflectedHttpActionDescriptor reflectedActionDescriptor = actionDescriptor as ReflectedHttpActionDescriptor;
            if (reflectedActionDescriptor != null)
            {
                string selectExpression = String.Format(CultureInfo.InvariantCulture, MethodExpression, GetMemberName(reflectedActionDescriptor.MethodInfo));
                return _documentNavigator.SelectSingleNode(selectExpression);
            }

            return null;
        }

        private static string GetMemberName(MethodInfo method)
        {
            string name = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", GetTypeName(method.DeclaringType), method.Name);
            ParameterInfo[] parameters = method.GetParameters();
            if (parameters.Length != 0)
            {
                string[] parameterTypeNames = parameters.Select(param => GetTypeName(param.ParameterType)).ToArray();
                name += String.Format(CultureInfo.InvariantCulture, "({0})", String.Join(",", parameterTypeNames));
            }

            return name;
        }

        private static string GetTagValue(XPathNavigator parentNode, string tagName)
        {
            if (parentNode != null)
            {
                XPathNavigator node = parentNode.SelectSingleNode(tagName);
                if (node != null)
                {
                    return node.Value.Trim();
                }
            }

            return null;
        }

        private XPathNavigator GetTypeNode(Type type)
        {
            string controllerTypeName = GetTypeName(type);
            string selectExpression = String.Format(CultureInfo.InvariantCulture, TypeExpression, controllerTypeName);
            return _documentNavigator.SelectSingleNode(selectExpression);
        }

        private static string GetTypeName(Type type)
        {
            string name = type.FullName;
            if (type.IsGenericType)
            {
                // Format the generic type name to something like: Generic{System.Int32,System.String}
                Type genericType = type.GetGenericTypeDefinition();
                Type[] genericArguments = type.GetGenericArguments();
                string genericTypeName = genericType.FullName;

                // Trim the generic parameter counts from the name
                genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf('`'));
                string[] argumentTypeNames = genericArguments.Select(t => GetTypeName(t)).ToArray();
                name = String.Format(CultureInfo.InvariantCulture, "{0}{{{1}}}", genericTypeName, String.Join(",", argumentTypeNames));
            }
            if (type.IsNested)
            {
                // Changing the nested type name from OuterType+InnerType to OuterType.InnerType to match the XML documentation syntax.
                name = name.Replace("+", ".");
            }

            return name;
        }
    }
}


================================================
FILE: src/WebApiHelpPage/GlobalSuppressions.cs
================================================
// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc.
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File".
// You do not need to add suppressions to this file manually.

[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "NAMESPACE", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "NAMESPACE", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "NAMESPACE", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "PROJECT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "PROJECT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "PROJECT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ROOT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ROOT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ROOT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "config", Scope = "member", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.HelpPageConfig.#Register(System.Web.Http.HttpConfiguration)", Justification = "This parameter is part of the template and could be used later.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification = "The assembly will not be deployed because we distribute the source code.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Web.FxCop", "MW1201:DoNotCallProblematicMethodsOnTaskRule", Scope = "member", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.HelpPageSampleGenerator.#WriteSampleObjectUsingFormatter(System.Net.Http.Formatting.MediaTypeFormatter,System.Object,System.Type,System.Net.Http.Headers.MediaTypeHeaderValue)", Justification = "This is an internal FxCop rule and we ship the source file.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "ROOT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "PROJECT", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]
[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "NAMESPACE", Scope = "namespace", Target = "ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification = "This namespace will be replaced with the project namespace when the help page is installed.")]


================================================
FILE: src/WebApiHelpPage/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;
using System.Runtime.InteropServices;

[assembly: AssemblyTitle("WebApiHelpPage")]
[assembly: AssemblyDescription("")]
[assembly: Guid("aa22bcbc-83b3-466d-a421-9c561e3625b7")]

================================================
FILE: src/WebApiHelpPage/Settings.StyleCop
================================================
<StyleCopSettings Version="105">
  <Analyzers>
    <Analyzer AnalyzerId="Microsoft.Web.StyleCop.Rules">
      <Rules>
        <Rule Name="FileMustHaveHeader">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
  </Analyzers>
</StyleCopSettings>

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ApiDescriptionExtensions.vb
================================================
Imports System
Imports System.Runtime.CompilerServices
Imports System.Text
Imports System.Web
Imports System.Web.Http.Description

Namespace Areas.HelpPage
    Public Module ApiDescriptionExtensions
        '''<summary>
        '''Generates an URI-friendly ID for the <see cref="ApiDescription"/>. E.g. "Get-Values-id_name" instead of "GetValues/{id}?name={name}"
        '''</summary>
        '''<param name="description">The <see cref="ApiDescription"/>.</param>
        '''<returns>The ID as a string.</returns>
        <Extension()>
        Public Function GetFriendlyId(ByVal description As ApiDescription) As String
            Dim path As String = description.RelativePath
            Dim urlParts() As String = path.Split("?"c)
            Dim localPath As String = urlParts(0)

            Dim queryKeyString As String = Nothing

            If (urlParts.Length > 1) Then
                Dim query As String = urlParts(1)
                Dim queryKeys() As String = HttpUtility.ParseQueryString(query).AllKeys
                queryKeyString = String.Join("_", queryKeys)
            End If

            Dim friendlyPath As New StringBuilder

            friendlyPath.AppendFormat("{0}-{1}",
                description.HttpMethod.Method,
                localPath.Replace("/", "-").Replace("{", String.Empty).Replace("}", String.Empty))

            If (Not queryKeyString Is Nothing) Then
                friendlyPath.AppendFormat("_{0}", queryKeyString.Replace(".", "-"))
            End If

            GetFriendlyId = friendlyPath.ToString()
        End Function
    End Module
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/App_Start/HelpPageConfig.vb
================================================
' Uncomment the following to provide samples for PageResult(Of T). Must also add the Microsoft.AspNet.WebApi.OData
' package to your project.
''#Const Handle_PageResultOfT = 1

Imports System
Imports System.Collections
Imports System.Collections.Generic
Imports System.Diagnostics
Imports System.Diagnostics.CodeAnalysis
Imports System.Linq
Imports System.Net.Http.Headers
Imports System.Reflection
Imports System.Web
Imports System.Web.Http
#If Handle_PageResultOfT Then
Imports System.Web.Http.OData
#End If

Namespace Areas.HelpPage
    ''' <summary>
    ''' Use this class to customize the Help Page.
    ''' For example you can set a custom <see cref="System.Web.Http.Description.IDocumentationProvider"/> to supply the documentation
    ''' or you can provide the samples for the requests/responses.
    ''' </summary>
    Public Module HelpPageConfig
        <SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters",
            MessageId:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.TextSample.#ctor(System.String)",
            Justification:="End users may choose to merge this string with existing localized resources.")>
        <SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly",
            MessageId:="bsonspec",
            Justification:="Part of a URI.")>
        Public Sub Register(config As HttpConfiguration)
            '' Uncomment the following to use the documentation from XML documentation file.
            'config.SetDocumentationProvider(New XmlDocumentationProvider(HttpContext.Current.Server.MapPath("~/App_Data/XmlDocument.xml")))

            '' Uncomment the following to use "sample string" as the sample for all actions that have string as the body parameter or return type.
            '' Also, the string arrays will be used for IEnumerable(Of String). The sample objects will be serialized into different media type 
            '' formats by the available formatters.
            'config.SetSampleObjects(New Dictionary(Of Type, Object) From
            '{
            '     {GetType(String), "sample string"},
            '     {GetType(IEnumerable(Of String)), New String() {"sample 1", "sample 2"}}
            '})

            ' Extend the following to provide factories for types not handled automatically (those lacking parameterless
            ' constructors) or for which you prefer to use non-default property values. Line below provides a fallback
            ' since automatic handling will fail and GeneratePageResult handles only a single type.
#If Handle_PageResultOfT Then
            config.GetHelpPageSampleGenerator().SampleObjectFactories.Add(AddressOf GeneratePageResult)
#End If

            ' Extend the following to use a preset object directly as the sample for all actions that support a media
            ' type, regardless of the body parameter or return type. The lines below avoid display of binary content.
            ' The BsonMediaTypeFormatter (if available) is not used to serialize the TextSample object.
            config.SetSampleForMediaType(
                New TextSample("Binary JSON content. See http://bsonspec.org for details."),
                New MediaTypeHeaderValue("application/bson"))

            '' Uncomment the following to use "[0]=foo&[1]=bar" directly as the sample for all actions that support form URL encoded format
            '' and have IEnumerable(Of String) as the body parameter or return type.
            'config.SetSampleForType("[0]=foo&[1]=bar", New MediaTypeHeaderValue("application/x-www-form-urlencoded"), GetType(IEnumerable(Of String)))

            '' Uncomment the following to use "1234" directly as the request sample for media type "text/plain" on the controller named "Values"
            '' and action named "Put".
            'config.SetSampleRequest("1234", New MediaTypeHeaderValue("text/plain"), "Values", "Put")

            '' Uncomment the following to use the image on "../images/aspNetHome.png" directly as the response sample for media type "image/png"
            '' on the controller named "Values" and action named "Get" with parameter "id".
            'config.SetSampleResponse(New ImageSample("../images/aspNetHome.png"), New MediaTypeHeaderValue("image/png"), "Values", "Get", "id")

            '' Uncomment the following to correct the sample request when the action expects an HttpRequestMessage with ObjectContent(Of string).
            '' The sample will be generated as if the controller named "Values" and action named "Get" were having String as the body parameter.
            'config.SetActualRequestType(GetType(String), "Values", "Get")

            '' Uncomment the following to correct the sample response when the action returns an HttpResponseMessage with ObjectContent(Of String).
            '' The sample will be generated as if the controller named "Values" and action named "Post" were returning a String.
            'config.SetActualResponseType(GetType(String), "Values", "Post")
        End Sub

#If Handle_PageResultOfT Then
        Private Function GeneratePageResult(sampleGenerator As HelpPageSampleGenerator, type As Type) As Object
            If type.IsGenericType Then
                Dim openGenericType As Type = type.GetGenericTypeDefinition()
                If openGenericType = GetType(PageResult(Of )) Then
                    ' Get the T in PageResult(Of T)
                    Dim typeParameters() As Type = type.GetGenericArguments()
                    Debug.Assert(typeParameters.Length = 1)

                    ' Create an enumeration to pass as the first parameter to the PageResult(Of T) constuctor
                    Dim itemsType As Type = GetType(List(Of )).MakeGenericType(typeParameters)
                    Dim items As Object = sampleGenerator.GetSampleObject(itemsType)

                    ' Fill in the other information needed to invoke the PageResult(Of T) constuctor
                    Dim parameterTypes() As Type = New Type() {itemsType, GetType(Uri), GetType(Long?)}
                    Dim parameters() As Object = New Object() {items, Nothing, CLng(ObjectGenerator.DefaultCollectionSize)}

                    ' Call PageResult(items As IEnumerable(Of T), nextPageLink As Uri, count As Long?) constructor
                    Dim constructor As ConstructorInfo = type.GetConstructor(parameterTypes)
                    Return constructor.Invoke(parameters)
                End If
            End If

            Return Nothing
        End Function
#End If
    End Module
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Controllers/HelpController.vb
================================================
Imports System
Imports System.Web.Http
Imports System.Web.Mvc
Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions

Namespace Areas.HelpPage.Controllers
    ''' <summary>
    ''' The controller that will handle requests for the help page.
    ''' </summary>
    Public Class HelpController
        Inherits Controller

        Private Const ErrorViewName As String = "Error"
        Private httpConfiguration As HttpConfiguration

        Public Sub New()
            Me.New(GlobalConfiguration.Configuration)
        End Sub

        Public Sub New(config As HttpConfiguration)
            Configuration = config
        End Sub

        Public Property Configuration As HttpConfiguration
            Get
                Return httpConfiguration
            End Get
            Private Set(value As HttpConfiguration)
                httpConfiguration = value
            End Set
        End Property

        Public Function Index() As ActionResult
            ViewData("DocumentationProvider") = Configuration.Services.GetDocumentationProvider()
            Return View(Configuration.Services.GetApiExplorer().ApiDescriptions)
        End Function

        Public Function Api(apiId As String) As ActionResult
            If (Not String.IsNullOrEmpty(apiId)) Then
                Dim apiModel As HelpPageApiModel = Configuration.GetHelpPageApiModel(apiId)
                If (Not apiModel Is Nothing) Then
                    Return View(apiModel)
                End If
            End If
            Return View(ErrorViewName)
        End Function

        Public Function ResourceModel(modelName As String) As ActionResult
            If Not [String].IsNullOrEmpty(modelName) Then
                Dim modelDescriptionGenerator As ModelDescriptionGenerator = Configuration.GetModelDescriptionGenerator()
                Dim modelDescription As ModelDescription = Nothing
                If modelDescriptionGenerator.GeneratedModels.TryGetValue(modelName, modelDescription) Then
                    Return View(modelDescription)
                End If
            End If

            Return View(ErrorViewName)
        End Function
    End Class
End Namespace


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/HelpPage.css
================================================
.help-page h1,
.help-page .h1,
.help-page h2,
.help-page .h2,
.help-page h3,
.help-page .h3,
#body.help-page,
.help-page-table th,
.help-page-table pre,
.help-page-table p {
    font-family: "Segoe UI Light", Frutiger, "Frutiger Linotype", "Dejavu Sans", "Helvetica Neue", Arial, sans-serif;
}

.help-page pre.wrapped {
    white-space: -moz-pre-wrap;
    white-space: -pre-wrap;
    white-space: -o-pre-wrap;
    white-space: pre-wrap;
}

.help-page .warning-message-container {
    margin-top: 20px;
    padding: 0 10px;
    color: #525252;
    background: #EFDCA9; 
    border: 1px solid #CCCCCC;
}

.help-page-table {
    width: 100%;
    border-collapse: collapse;
    text-align: left;
    margin: 0px 0px 20px 0px;
    border-top: 1px solid #D4D4D4;
}

.help-page-table th {
    text-align: left;
    font-weight: bold;
    border-bottom: 1px solid #D4D4D4;
    padding: 5px 6px 5px 6px;
}

.help-page-table td {
    border-bottom: 1px solid #D4D4D4;
    padding: 10px 8px 10px 8px;
    vertical-align: top;
}

.help-page-table pre,
.help-page-table p {
    margin: 0px;
    padding: 0px;
    font-family: inherit;
    font-size: 100%;
}

.help-page-table tbody tr:hover td {
    background-color: #F3F3F3;
}

.help-page a:hover {
    background-color: transparent;
}

.help-page .sample-header {
    border: 2px solid #D4D4D4;
    background: #00497E;
    color: #FFFFFF;
    padding: 8px 15px;
    border-bottom: none;
    display: inline-block;
    margin: 10px 0px 0px 0px;
}

.help-page .sample-content {
    display: block;
    border-width: 0;
    padding: 15px 20px;
    background: #FFFFFF;
    border: 2px solid #D4D4D4;
    margin: 0px 0px 10px 0px;
}

.help-page .api-name {
    width: 40%;
}

.help-page .api-documentation {
    width: 60%;
}

.help-page .parameter-name {
    width: 20%;
}

.help-page .parameter-documentation {
    width: 40%;
}

.help-page .parameter-type {
    width: 20%;
}

.help-page .parameter-annotations {
    width: 20%;
}

.help-page h1,
.help-page .h1 {
    font-size: 36px;
    line-height: normal;
}

.help-page h2,
.help-page .h2 {
    font-size: 24px;
}

.help-page h3,
.help-page .h3 {
    font-size: 20px;
}

#body.help-page {
    font-size: 14px;
    line-height: 143%;
    color: #333;
}

.help-page a {
    color: #0000EE;
    text-decoration: none;
}


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/HelpPageAreaRegistration.vb
================================================
Imports System.Web.Http
Imports System.Web.Mvc

Namespace Areas.HelpPage
    Public Class HelpPageAreaRegistration
        Inherits AreaRegistration

        Public Overrides ReadOnly Property AreaName As String
            Get
                Return "HelpPage"
            End Get
        End Property

        Public Overrides Sub RegisterArea(context As AreaRegistrationContext)
            context.MapRoute(
                "HelpPage_Default",
                "Help/{action}/{apiId}",
                New With {.Controller = "Help", .action = "Index", .apiId = UrlParameter.Optional})
            HelpPageConfig.Register(GlobalConfiguration.Configuration)
        End Sub
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/HelpPageConfigurationExtensions.vb
================================================
Imports System
Imports System.Collections.Generic
Imports System.Collections.ObjectModel
Imports System.ComponentModel
Imports System.Diagnostics
Imports System.Diagnostics.CodeAnalysis
Imports System.Globalization
Imports System.Linq
Imports System.Net.Http
Imports System.Net.Http.Headers
Imports System.Runtime.CompilerServices
Imports System.Web.Http
Imports System.Web.Http.Controllers
Imports System.Web.Http.Description
Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions

Namespace Areas.HelpPage
    Public Module HelpPageConfigurationExtensions
        Private Const ApiModelPrefix As String = "MS_HelpPageApiModel_"

        ''' <summary>
        ''' Sets the documentation provider for help page.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="documentationProvider">The documentation provider.</param>
        <Extension()>
        Public Sub SetDocumentationProvider(ByVal config As HttpConfiguration, documentationProvider As IDocumentationProvider)
            config.Services.Replace(GetType(IDocumentationProvider), documentationProvider)
        End Sub

        ''' <summary>
        ''' Sets the objects that will be used by the formatters to produce sample requests/responses.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sampleObjects">The sample objects.</param>
        <Extension()>
        Public Sub SetSampleObjects(ByVal config As HttpConfiguration, sampleObjects As IDictionary(Of Type, Object))
            config.GetHelpPageSampleGenerator().SampleObjects = sampleObjects
        End Sub

        ''' <summary>
        ''' Sets the sample request directly for the specified media type and action.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sample">The sample request.</param>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        <Extension()>
        Public Sub SetSampleRequest(ByVal config As HttpConfiguration, sample As Object, mediaType As MediaTypeHeaderValue, controllerName As String, actionName As String)
            config.GetHelpPageSampleGenerator().ActionSamples.Add(New HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, New String() {"*"}), sample)
        End Sub

        ''' <summary>
        ''' Sets the sample request directly for the specified media type and action with parameters.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sample">The sample request.</param>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        <Extension()>
        Public Sub SetSampleRequest(ByVal config As HttpConfiguration, sample As Object, mediaType As MediaTypeHeaderValue, controllerName As String, actionName As String, ByVal ParamArray parameterNames() As String)
            config.GetHelpPageSampleGenerator().ActionSamples.Add(New HelpPageSampleKey(mediaType, SampleDirection.Request, controllerName, actionName, parameterNames), sample)
        End Sub

        ''' <summary>
        ''' Sets the sample request directly for the specified media type of the action.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sample">The sample response.</param>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        <Extension()>
        Public Sub SetSampleResponse(ByVal config As HttpConfiguration, sample As Object, mediaType As MediaTypeHeaderValue, controllerName As String, actionName As String)
            config.GetHelpPageSampleGenerator().ActionSamples.Add(New HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, New String() {"*"}), sample)
        End Sub

        ''' <summary>
        ''' Sets the sample response directly for the specified media type of the action with specific parameters.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sample">The sample response.</param>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        <Extension()>
        Public Sub SetSampleResponse(ByVal config As HttpConfiguration, sample As Object, mediaType As MediaTypeHeaderValue, controllerName As String, actionName As String, ByVal ParamArray parameterNames() As String)
            config.GetHelpPageSampleGenerator().ActionSamples.Add(New HelpPageSampleKey(mediaType, SampleDirection.Response, controllerName, actionName, parameterNames), sample)
        End Sub

        ''' <summary>
        ''' Sets the sample directly for all actions with the specified type.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sample">The sample.</param>
        ''' <param name="mediaType">The media type.</param>
        <Extension()>
        Public Sub SetSampleForMediaType(ByVal config As HttpConfiguration, sample As Object, mediaType As MediaTypeHeaderValue)
            config.GetHelpPageSampleGenerator().ActionSamples.Add(New HelpPageSampleKey(mediaType), sample)
        End Sub

        ''' <summary>
        ''' Sets the sample directly for all actions with the specified type and media type.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sample">The sample.</param>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="type">The parameter type or return type of an action.</param>
        <Extension()>
        Public Sub SetSampleForType(ByVal config As HttpConfiguration, sample As Object, mediaType As MediaTypeHeaderValue, type As Type)
            config.GetHelpPageSampleGenerator().ActionSamples.Add(New HelpPageSampleKey(mediaType, type), sample)
        End Sub

        ''' <summary>
        ''' Specifies the actual type of <see cref="System.Net.Http.ObjectContent(Of T)"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action. 
        ''' The help page will use this information to produce more accurate request samples.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="type">The type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        <Extension()>
        Public Sub SetActualRequestType(ByVal config As HttpConfiguration, type As Type, controllerName As String, actionName As String)
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(New HelpPageSampleKey(SampleDirection.Request, controllerName, actionName, New String() {"*"}), type)
        End Sub

        ''' <summary>
        ''' Specifies the actual type of <see cref="System.Net.Http.ObjectContent(Of T)"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action. 
        ''' The help page will use this information to produce more accurate request samples.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="type">The type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        <Extension()>
        Public Sub SetActualRequestType(ByVal config As HttpConfiguration, type As Type, controllerName As String, actionName As String, ByVal ParamArray parameterNames() As String)
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(New HelpPageSampleKey(SampleDirection.Request, controllerName, actionName, parameterNames), type)
        End Sub

        ''' <summary>
        ''' Specifies the actual type of <see cref="System.Net.Http.ObjectContent(Of T)"/> returned as part of the <see cref="System.Net.Http.HttpRequestMessage"/> in an action. 
        ''' The help page will use this information to produce more accurate response samples.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="type">The type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        <Extension()>
        Public Sub SetActualResponseType(ByVal config As HttpConfiguration, type As Type, controllerName As String, actionName As String)
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(New HelpPageSampleKey(SampleDirection.Response, controllerName, actionName, New String() {"*"}), type)
        End Sub

        ''' <summary>
        ''' Specifies the actual type of <see cref="System.Net.Http.ObjectContent(Of T)"/> returned as part of the <see cref="System.Net.Http.HttpRequestMessage"/> in an action. 
        ''' The help page will use this information to produce more accurate response samples.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="type">The type.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        <Extension()>
        Public Sub SetActualResponseType(ByVal config As HttpConfiguration, type As Type, controllerName As String, actionName As String, ByVal ParamArray parameterNames() As String)
            config.GetHelpPageSampleGenerator().ActualHttpMessageTypes.Add(New HelpPageSampleKey(SampleDirection.Response, controllerName, actionName, parameterNames), type)
        End Sub

        ''' <summary>
        ''' Gets the help page sample generator.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <returns>The help page sample generator.</returns>
        <Extension()>
        Public Function GetHelpPageSampleGenerator(ByVal config As HttpConfiguration) As HelpPageSampleGenerator
            Return DirectCast(config.Properties.GetOrAdd(
                GetType(HelpPageSampleGenerator),
                Function(k) New HelpPageSampleGenerator()), HelpPageSampleGenerator)
        End Function

        ''' <summary>
        ''' Gets the model description generator.
        ''' </summary>
        ''' <param name="config">The configuration.</param>
        ''' <returns>The <see cref="ModelDescriptionGenerator"/></returns>
        <Extension()>
        Public Function GetModelDescriptionGenerator(config As HttpConfiguration) As ModelDescriptionGenerator
            Return DirectCast(config.Properties.GetOrAdd(GetType(ModelDescriptionGenerator), Function(k) InitializeModelDescriptionGenerator(config)), ModelDescriptionGenerator)
        End Function

        ''' <summary>
        ''' Sets the help page sample generator.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="sampleGenerator">The help page sample generator.</param>
        <Extension()>
        Public Sub SetHelpPageSampleGenerator(ByVal config As HttpConfiguration, sampleGenerator As HelpPageSampleGenerator)
            config.Properties.AddOrUpdate(
                GetType(HelpPageSampleGenerator),
                Function(k) sampleGenerator,
                Function(k, o) sampleGenerator)
        End Sub

        ''' <summary>
        ''' Gets the model that represents an API displayed on the help page. The model is initialized on the first call and cached for subsequent calls.
        ''' </summary>
        ''' <param name="config">The <see cref="HttpConfiguration"/>.</param>
        ''' <param name="apiDescriptionId">The <see cref="ApiDescription"/> ID.</param>
        ''' <returns>
        ''' An <see cref="HelpPageApiModel"/>
        ''' </returns>

        <Extension()>
        Public Function GetHelpPageApiModel(ByVal config As HttpConfiguration, apiDescriptionId As String) As HelpPageApiModel
            Dim model As New Object

            Dim modelId As String = ApiModelPrefix + apiDescriptionId
            If (Not config.Properties.TryGetValue(modelId, model)) Then
                Dim apiDescriptions As Collection(Of ApiDescription) = config.Services.GetApiExplorer().ApiDescriptions
                Dim ApiDescription As ApiDescription = apiDescriptions.FirstOrDefault(Function(api) String.Equals(api.GetFriendlyId(), apiDescriptionId, StringComparison.OrdinalIgnoreCase))
                If (Not ApiDescription Is Nothing) Then
                    model = GenerateApiModel(ApiDescription, config)
                    config.Properties.TryAdd(modelId, model)
                End If
            End If
            Return DirectCast(model, HelpPageApiModel)
        End Function

        Public Function GenerateApiModel(apiDescription As ApiDescription, config As HttpConfiguration) As HelpPageApiModel
            Dim apiModel As New HelpPageApiModel() With {
                .ApiDescription = apiDescription
            }

            Dim sampleGenerator As HelpPageSampleGenerator = config.GetHelpPageSampleGenerator()
            Dim modelGenerator As ModelDescriptionGenerator = config.GetModelDescriptionGenerator()
            GenerateUriParameters(apiModel, modelGenerator)
            GenerateRequestModelDescription(apiModel, modelGenerator, sampleGenerator)
            GenerateResourceDescription(apiModel, modelGenerator)
            GenerateSamples(apiModel, sampleGenerator)

            Return apiModel
        End Function

        Private Sub GenerateUriParameters(apiModel As HelpPageApiModel, modelGenerator As ModelDescriptionGenerator)
            Dim apiDescription As ApiDescription = apiModel.ApiDescription
            For Each apiParameter As ApiParameterDescription In apiDescription.ParameterDescriptions
                If apiParameter.Source = ApiParameterSource.FromUri Then
                    Dim parameterDescriptor As HttpParameterDescriptor = apiParameter.ParameterDescriptor
                    Dim parameterType As Type = Nothing
                    Dim typeDescription As ModelDescription = Nothing
                    Dim complexTypeDescription As ComplexTypeModelDescription = Nothing
                    If parameterDescriptor IsNot Nothing Then
                        parameterType = parameterDescriptor.ParameterType
                        typeDescription = modelGenerator.GetOrCreateModelDescription(parameterType)
                        complexTypeDescription = TryCast(typeDescription, ComplexTypeModelDescription)
                    End If

                    '' Example:
                    '' <TypeConverter(GetType(PointConverter))>
                    '' Public Class Point
                    ''     Public Sub New(x As Integer, y As Integer)
                    ''         x = x
                    ''         y = y
                    ''     End Sub
                    ''     Public X As Integer
                    ''     Public Y As Integer
                    '' End Class
                    '' Class Point is bindable with a TypeConverter, so Point will be added to UriParameters collection.
                    ''
                    '' Public Class Point
                    ''     Public X As Integer
                    ''     Public Y As Integer
                    '' End Class
                    '' Regular complex class Point will have properties X and Y added to UriParameters collection.
                    If complexTypeDescription IsNot Nothing AndAlso Not IsBindableWithTypeConverter(parameterType) Then
                        For Each uriParameter As ParameterDescription In complexTypeDescription.Properties
                            apiModel.UriParameters.Add(uriParameter)
                        Next
                    ElseIf parameterDescriptor IsNot Nothing Then
                        Dim uriParameter As ParameterDescription =
                            AddParameterDescription(apiModel, apiParameter, typeDescription)

                        If Not parameterDescriptor.IsOptional Then
                            uriParameter.Annotations.Add(New ParameterAnnotation() With {
                                .Documentation = "Required"
                            })
                        End If

                        Dim defaultValue As Object = parameterDescriptor.DefaultValue
                        If defaultValue IsNot Nothing Then
                            uriParameter.Annotations.Add(New ParameterAnnotation() With {
                                .Documentation = "Default value is " & Convert.ToString(defaultValue, CultureInfo.InvariantCulture)
                            })
                        End If
                    Else
                        Debug.Assert(parameterDescriptor Is Nothing)

                        '' If parameterDescriptor is Nothing, this is an undeclared route parameter which only occurs
                        '' when source is FromUri. Ignored in request model and among resource parameters but listed
                        '' as a simple string here.
                        Dim modelDescription As ModelDescription =
                            modelGenerator.GetOrCreateModelDescription(GetType(String))
                        AddParameterDescription(apiModel, apiParameter, modelDescription)
                    End If
                End If
            Next
        End Sub

        Private Function IsBindableWithTypeConverter(type As Type) As Boolean
            If type Is Nothing Then
                Return False
            End If

            Return TypeDescriptor.GetConverter(type).CanConvertFrom(GetType(String))
        End Function

        Private Function AddParameterDescription(apiModel As HelpPageApiModel, apiParameter As ApiParameterDescription,
                                                 typeDescription As ModelDescription) As ParameterDescription
            Dim parameterDescription As New ParameterDescription() With
            {
                .Name = apiParameter.Name,
                .Documentation = apiParameter.Documentation,
                .TypeDescription = typeDescription
            }

            apiModel.UriParameters.Add(parameterDescription)
            Return parameterDescription
        End Function

        Private Sub GenerateRequestModelDescription(apiModel As HelpPageApiModel, modelGenerator As ModelDescriptionGenerator, sampleGenerator As HelpPageSampleGenerator)
            Dim apiDescription As ApiDescription = apiModel.ApiDescription
            For Each apiParameter As ApiParameterDescription In apiDescription.ParameterDescriptions
                If apiParameter.Source = ApiParameterSource.FromBody Then
                    Dim parameterType As Type = apiParameter.ParameterDescriptor.ParameterType
                    apiModel.RequestModelDescription = modelGenerator.GetOrCreateModelDescription(parameterType)
                    apiModel.RequestDocumentation = apiParameter.Documentation
                ElseIf apiParameter.ParameterDescriptor IsNot Nothing AndAlso
                    apiParameter.ParameterDescriptor.ParameterType = GetType(HttpRequestMessage) Then
                    Dim parameterType As Type = sampleGenerator.ResolveHttpRequestMessageType(apiDescription)

                    If parameterType IsNot Nothing Then
                        apiModel.RequestModelDescription = modelGenerator.GetOrCreateModelDescription(parameterType)
                    End If
                End If
            Next
        End Sub

        Private Sub GenerateResourceDescription(apiModel As HelpPageApiModel, modelGenerator As ModelDescriptionGenerator)
            Dim response As ResponseDescription = apiModel.ApiDescription.ResponseDescription
            Dim responseType As Type = If(response.ResponseType, response.DeclaredType)
            If responseType IsNot Nothing AndAlso responseType <> GetType(System.Void) Then
                apiModel.ResourceDescription = modelGenerator.GetOrCreateModelDescription(responseType)
            End If
        End Sub

        <SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification:="The exception is recorded as ErrorMessages.")>
        Private Sub GenerateSamples(apiModel As HelpPageApiModel, sampleGenerator As HelpPageSampleGenerator)
            Try
                For Each item In sampleGenerator.GetSampleRequests(apiModel.ApiDescription)
                    apiModel.SampleRequests.Add(item.Key, item.Value)
                    LogInvalidSampleAsError(apiModel, item.Value)
                Next

                For Each item In sampleGenerator.GetSampleResponses(apiModel.ApiDescription)
                    apiModel.SampleResponses.Add(item.Key, item.Value)
                    LogInvalidSampleAsError(apiModel, item.Value)
                Next
            Catch e As Exception
                apiModel.ErrorMessages.Add(String.Format(CultureInfo.CurrentCulture,
                                                         "An exception has occurred while generating the sample. Exception message: {0}",
                                                         HelpPageSampleGenerator.UnwrapException(e).Message))
            End Try
        End Sub

        Private Function TryGetResourceParameter(apiDescription As ApiDescription, config As HttpConfiguration, ByRef parameterDescription As ApiParameterDescription, ByRef resourceType As Type) As Boolean
            parameterDescription = apiDescription.ParameterDescriptions.FirstOrDefault(
                Function(p) p.Source = ApiParameterSource.FromBody OrElse
                    (p.ParameterDescriptor IsNot Nothing AndAlso p.ParameterDescriptor.ParameterType = GetType(HttpRequestMessage)))

            If parameterDescription Is Nothing Then
                resourceType = Nothing
                Return False
            End If

            resourceType = parameterDescription.ParameterDescriptor.ParameterType

            If resourceType = GetType(HttpRequestMessage) Then
                Dim sampleGenerator As HelpPageSampleGenerator = config.GetHelpPageSampleGenerator()
                resourceType = sampleGenerator.ResolveHttpRequestMessageType(apiDescription)
            End If

            If resourceType Is Nothing Then
                parameterDescription = Nothing
                Return False
            End If

            Return True
        End Function

        Private Function InitializeModelDescriptionGenerator(config As HttpConfiguration) As ModelDescriptionGenerator
            Dim modelGenerator As New ModelDescriptionGenerator(config)
            Dim apis As Collection(Of ApiDescription) = config.Services.GetApiExplorer().ApiDescriptions
            For Each api As ApiDescription In apis
                Dim parameterDescription As ApiParameterDescription = Nothing
                Dim parameterType As Type = Nothing
                If TryGetResourceParameter(api, config, parameterDescription, parameterType) Then
                    modelGenerator.GetOrCreateModelDescription(parameterType)
                End If
            Next
            Return modelGenerator
        End Function

        Private Sub LogInvalidSampleAsError(apiModel As HelpPageApiModel, sample As Object)
            Dim invalidSample As InvalidSample = TryCast(sample, InvalidSample)
            If (Not invalidSample Is Nothing) Then
                apiModel.ErrorMessages.Add(invalidSample.ErrorMessage)
            End If
        End Sub
    End Module
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/CollectionModelDescription.vb
================================================
Namespace Areas.HelpPage.ModelDescriptions
    Public Class CollectionModelDescription
        Inherits ModelDescription
        Private _elementDescription As ModelDescription

        Public Property ElementDescription() As ModelDescription
            Get
                Return _elementDescription
            End Get
            Set(value As ModelDescription)
                _elementDescription = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/ComplexTypeModelDescription.vb
================================================
Imports System.Collections.ObjectModel

Namespace Areas.HelpPage.ModelDescriptions
    Public Class ComplexTypeModelDescription
        Inherits ModelDescription
        Private _properties As Collection(Of ParameterDescription)

        Public Sub New()
            Properties = New Collection(Of ParameterDescription)()
        End Sub

        Public Property Properties() As Collection(Of ParameterDescription)
            Get
                Return _properties
            End Get
            Private Set(value As Collection(Of ParameterDescription))
                _properties = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/DictionaryModelDescription.vb
================================================
Namespace Areas.HelpPage.ModelDescriptions
    Public Class DictionaryModelDescription
        Inherits KeyValuePairModelDescription
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/EnumTypeModelDescription.vb
================================================
Imports System.Collections.Generic
Imports System.Collections.ObjectModel

Namespace Areas.HelpPage.ModelDescriptions
    Public Class EnumTypeModelDescription
        Inherits ModelDescription
        Private _values As Collection(Of EnumValueDescription)

        Public Sub New()
            Values = New Collection(Of EnumValueDescription)()
        End Sub

        Public Property Values() As Collection(Of EnumValueDescription)
            Get
                Return _values
            End Get
            Private Set(value As Collection(Of EnumValueDescription))
                _values = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/EnumValueDescription.vb
================================================
Namespace Areas.HelpPage.ModelDescriptions
    Public Class EnumValueDescription
        Private _documentation As String
        Private _value As String
        Private _name As String

        Public Property Documentation() As String
            Get
                Return _documentation
            End Get
            Set(value As String)
                _documentation = value
            End Set
        End Property

        Public Property Name() As String
            Get
                Return _name
            End Get
            Set(value As String)
                _name = value
            End Set
        End Property

        Public Property Value() As String
            Get
                Return _value
            End Get
            Set(value As String)
                _value = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/IModelDocumentationProvider.vb
================================================
Imports System
Imports System.Reflection

Namespace Areas.HelpPage.ModelDescriptions
    Public Interface IModelDocumentationProvider
        Function GetDocumentation(member As MemberInfo) As String
        Function GetDocumentation(type As Type) As String
    End Interface
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/KeyValuePairModelDescription.vb
================================================
Namespace Areas.HelpPage.ModelDescriptions
    Public Class KeyValuePairModelDescription
        Inherits ModelDescription
        Private _keyModelDescription As ModelDescription
        Private _valueModelDescription As ModelDescription

        Public Property KeyModelDescription() As ModelDescription
            Get
                Return _keyModelDescription
            End Get
            Set(value As ModelDescription)
                _keyModelDescription = value
            End Set
        End Property

        Public Property ValueModelDescription() As ModelDescription
            Get
                Return _valueModelDescription
            End Get
            Set(value As ModelDescription)
                _valueModelDescription = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/ModelDescription.vb
================================================
Imports System

Namespace Areas.HelpPage.ModelDescriptions
    ''' <summary>
    ''' Describes a type model.
    ''' </summary>
    Public MustInherit Class ModelDescription
        Private _name As String
        Private _documentation As String
        Private _modelType As Type

        Public Property Documentation() As String
            Get
                Return _documentation
            End Get
            Set(value As String)
                _documentation = value
            End Set
        End Property

        Public Property ModelType() As Type
            Get
                Return _modelType
            End Get
            Set(value As Type)
                _modelType = value
            End Set
        End Property

        Public Property Name() As String
            Get
                Return _name
            End Get
            Set(value As String)
                _name = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/ModelDescriptionGenerator.vb
================================================
Imports System
Imports System.Collections
Imports System.Collections.Generic
Imports System.Collections.Specialized
Imports System.ComponentModel.DataAnnotations
Imports System.Globalization
Imports System.Reflection
Imports System.Runtime.Serialization
Imports System.Web.Http
Imports System.Web.Http.Description
Imports System.Xml.Serialization
Imports Newtonsoft.Json

Namespace Areas.HelpPage.ModelDescriptions
    ''' <summary>
    ''' Generates model descriptions for given types.
    ''' </summary>
    Public Class ModelDescriptionGenerator
        ' Modify this to support more data annotation attributes.
        Private ReadOnly AnnotationTextGenerator As IDictionary(Of Type, Func(Of Object, String)) = New Dictionary(Of Type, Func(Of Object, String))() From { _
            {GetType(RequiredAttribute),
             Function(a) "Required"},
            {GetType(RangeAttribute),
             Function(a)
                 Dim range As RangeAttribute = DirectCast(a, RangeAttribute)
                 Return [String].Format(CultureInfo.CurrentCulture, "Range: inclusive between {0} and {1}", range.Minimum, range.Maximum)
             End Function},
            {GetType(MaxLengthAttribute),
             Function(a)
                 Dim maxLength As MaxLengthAttribute = DirectCast(a, MaxLengthAttribute)
                 Return [String].Format(CultureInfo.CurrentCulture, "Max length: {0}", maxLength.Length)
             End Function},
            {GetType(MinLengthAttribute),
             Function(a)
                 Dim minLength As MinLengthAttribute = DirectCast(a, MinLengthAttribute)
                 Return [String].Format(CultureInfo.CurrentCulture, "Min length: {0}", minLength.Length)
             End Function},
            {GetType(StringLengthAttribute),
             Function(a)
                 Dim strLength As StringLengthAttribute = DirectCast(a, StringLengthAttribute)
                 Return [String].Format(CultureInfo.CurrentCulture, "String length: inclusive between {0} and {1}", strLength.MinimumLength, strLength.MaximumLength)
             End Function},
            {GetType(DataTypeAttribute),
             Function(a)
                 Dim dataType As DataTypeAttribute = DirectCast(a, DataTypeAttribute)
                 Return [String].Format(CultureInfo.CurrentCulture, "Data type: {0}", If(dataType.CustomDataType, dataType.DataType.ToString()))
             End Function},
            {GetType(RegularExpressionAttribute),
             Function(a)
                 Dim regularExpression As RegularExpressionAttribute = DirectCast(a, RegularExpressionAttribute)
                 Return [String].Format(CultureInfo.CurrentCulture, "Matching regular expression pattern: {0}", regularExpression.Pattern)
             End Function}
        }

        ' Modify this to add more default documentations.
        Private ReadOnly DefaultTypeDocumentation As IDictionary(Of Type, String) = New Dictionary(Of Type, String)() From { _
            {GetType(Int16), "integer"},
            {GetType(Int32), "integer"},
            {GetType(Int64), "integer"},
            {GetType(UInt16), "unsigned integer"},
            {GetType(UInt32), "unsigned integer"},
            {GetType(UInt64), "unsigned integer"},
            {GetType([Byte]), "byte"},
            {GetType([Char]), "character"},
            {GetType([SByte]), "signed byte"},
            {GetType(Uri), "URI"},
            {GetType([Single]), "decimal number"},
            {GetType([Double]), "decimal number"},
            {GetType([Decimal]), "decimal number"},
            {GetType([String]), "string"},
            {GetType(Guid), "globally unique identifier"},
            {GetType(TimeSpan), "time interval"},
            {GetType(DateTime), "date"},
            {GetType(DateTimeOffset), "date"},
            {GetType([Boolean]), "boolean"}
        }

        Private _documentationProvider As Lazy(Of IModelDocumentationProvider)

        Public Sub New(config As HttpConfiguration)
            If config Is Nothing Then
                Throw New ArgumentNullException("config")
            End If

            _documentationProvider = New Lazy(Of IModelDocumentationProvider)(Function() TryCast(config.Services.GetDocumentationProvider(), IModelDocumentationProvider))
            GeneratedModels = New Dictionary(Of String, ModelDescription)(StringComparer.OrdinalIgnoreCase)
        End Sub

        Public Property GeneratedModels() As Dictionary(Of String, ModelDescription)
            Get
                Return m_GeneratedModels
            End Get
            Private Set(value As Dictionary(Of String, ModelDescription))
                m_GeneratedModels = value
            End Set
        End Property
        Private m_GeneratedModels As Dictionary(Of String, ModelDescription)

        Private ReadOnly Property DocumentationProvider() As IModelDocumentationProvider
            Get
                Return _documentationProvider.Value
            End Get
        End Property

        Public Function GetOrCreateModelDescription(modelType As Type) As ModelDescription
            If modelType Is Nothing Then
                Throw New ArgumentNullException("modelType")
            End If

            Dim underlyingType As Type = Nullable.GetUnderlyingType(modelType)
            If underlyingType IsNot Nothing Then
                modelType = underlyingType
            End If

            Dim modelDescription As ModelDescription = Nothing
            Dim modelName As String = ModelNameHelper.GetModelName(modelType)
            If GeneratedModels.TryGetValue(modelName, modelDescription) Then
                If modelType <> modelDescription.ModelType Then
                    Throw New InvalidOperationException([String].Format(CultureInfo.CurrentCulture, "A model description could not be created. Duplicate model name '{0}' was found for types '{1}' and '{2}'. " & "Use the [ModelName] attribute to change the model name for at least one of the types so that it has a unique name.", modelName, modelDescription.ModelType.FullName, modelType.FullName))
                End If

                Return modelDescription
            End If

            If DefaultTypeDocumentation.ContainsKey(modelType) Then
                Return GenerateSimpleTypeModelDescription(modelType)
            End If

            If modelType.IsEnum Then
                Return GenerateEnumTypeModelDescription(modelType)
            End If

            If modelType.IsGenericType Then
                Dim genericArguments As Type() = modelType.GetGenericArguments()

                If genericArguments.Length = 1 Then
                    Dim enumerableType As Type = GetType(IEnumerable(Of )).MakeGenericType(genericArguments)
                    If enumerableType.IsAssignableFrom(modelType) Then
                        Return GenerateCollectionModelDescription(modelType, genericArguments(0))
                    End If
                End If
                If genericArguments.Length = 2 Then
                    Dim dictionaryType As Type = GetType(IDictionary(Of ,)).MakeGenericType(genericArguments)
                    If dictionaryType.IsAssignableFrom(modelType) Then
                        Return GenerateDictionaryModelDescription(modelType, genericArguments(0), genericArguments(1))
                    End If

                    Dim keyValuePairType As Type = GetType(KeyValuePair(Of ,)).MakeGenericType(genericArguments)
                    If keyValuePairType.IsAssignableFrom(modelType) Then
                        Return GenerateKeyValuePairModelDescription(modelType, genericArguments(0), genericArguments(1))
                    End If
                End If
            End If

            If modelType.IsArray Then
                Dim elementType As Type = modelType.GetElementType()
                Return GenerateCollectionModelDescription(modelType, elementType)
            End If

            If modelType Is GetType(NameValueCollection) Then
                Return GenerateDictionaryModelDescription(modelType, GetType(String), GetType(String))
            End If

            If GetType(IDictionary).IsAssignableFrom(modelType) Then
                Return GenerateDictionaryModelDescription(modelType, GetType(Object), GetType(Object))
            End If

            If GetType(IEnumerable).IsAssignableFrom(modelType) Then
                Return GenerateCollectionModelDescription(modelType, GetType(Object))
            End If

            Return GenerateComplexTypeModelDescription(modelType)
        End Function

        ' Change this to provide different name for the member.
        Private Shared Function GetMemberName(member As MemberInfo, hasDataContractAttribute As Boolean) As String
            Dim jsonProperty As JsonPropertyAttribute = member.GetCustomAttribute(Of JsonPropertyAttribute)()
            If jsonProperty IsNot Nothing AndAlso Not [String].IsNullOrEmpty(jsonProperty.PropertyName) Then
                Return jsonProperty.PropertyName
            End If

            If hasDataContractAttribute Then
                Dim dataMember As DataMemberAttribute = member.GetCustomAttribute(Of DataMemberAttribute)()
                If dataMember IsNot Nothing AndAlso Not [String].IsNullOrEmpty(dataMember.Name) Then
                    Return dataMember.Name
                End If
            End If

            Return member.Name
        End Function

        Private Shared Function ShouldDisplayMember(member As MemberInfo, hasDataContractAttribute As Boolean) As Boolean
            Dim jsonIgnore As JsonIgnoreAttribute = member.GetCustomAttribute(Of JsonIgnoreAttribute)()
            Dim xmlIgnore As XmlIgnoreAttribute = member.GetCustomAttribute(Of XmlIgnoreAttribute)()
            Dim ignoreDataMember As IgnoreDataMemberAttribute = member.GetCustomAttribute(Of IgnoreDataMemberAttribute)()
            Dim nonSerialized As NonSerializedAttribute = member.GetCustomAttribute(Of NonSerializedAttribute)()
            Dim apiExplorerSetting As ApiExplorerSettingsAttribute = member.GetCustomAttribute(Of ApiExplorerSettingsAttribute)()

            Dim hasMemberAttribute As Boolean = If(member.DeclaringType.IsEnum, member.GetCustomAttribute(Of EnumMemberAttribute)() IsNot Nothing, member.GetCustomAttribute(Of DataMemberAttribute)() IsNot Nothing)

            ' Display member only if all the followings are true:
            ' no JsonIgnoreAttribute
            ' no XmlIgnoreAttribute
            ' no IgnoreDataMemberAttribute
            ' no NonSerializedAttribute
            ' no ApiExplorerSettingsAttribute with IgnoreApi set to true
            ' no DataContractAttribute without DataMemberAttribute or EnumMemberAttribute
            Return jsonIgnore Is Nothing AndAlso xmlIgnore Is Nothing AndAlso ignoreDataMember Is Nothing AndAlso nonSerialized Is Nothing AndAlso (apiExplorerSetting Is Nothing OrElse Not apiExplorerSetting.IgnoreApi) AndAlso (Not hasDataContractAttribute OrElse hasMemberAttribute)
        End Function

        Private Function CreateDefaultDocumentation(type As Type) As String
            Dim documentation As String = Nothing
            If DefaultTypeDocumentation.TryGetValue(type, documentation) Then
                Return documentation
            End If
            If DocumentationProvider IsNot Nothing Then
                documentation = DocumentationProvider.GetDocumentation(type)
            End If

            Return documentation
        End Function

        Private Sub GenerateAnnotations([property] As MemberInfo, propertyModel As ParameterDescription)
            Dim annotations As New List(Of ParameterAnnotation)()

            Dim attributes As IEnumerable(Of Attribute) = [property].GetCustomAttributes()
            For Each attribute As Attribute In attributes
                Dim textGenerator As Func(Of Object, String) = Nothing
                If AnnotationTextGenerator.TryGetValue(attribute.[GetType](), textGenerator) Then
                    annotations.Add(
                        New ParameterAnnotation() With {
                            .AnnotationAttribute = attribute,
                            .Documentation = textGenerator(attribute)
                        })
                End If
            Next

            ' Rearrange the annotations
            annotations.Sort(
                Function(x, y)
                    ' Special-case RequiredAttribute so that it shows up on top
                    If TypeOf x.AnnotationAttribute Is RequiredAttribute Then
                        Return -1
                    End If
                    If TypeOf y.AnnotationAttribute Is RequiredAttribute Then
                        Return 1
                    End If

                    ' Sort the rest based on alphabetic order of the documentation
                    Return [String].Compare(x.Documentation, y.Documentation, StringComparison.OrdinalIgnoreCase)

                End Function)

            For Each annotation As ParameterAnnotation In annotations
                propertyModel.Annotations.Add(annotation)
            Next
        End Sub

        Private Function GenerateCollectionModelDescription(modelType As Type, elementType As Type) As CollectionModelDescription
            Dim collectionModelDescription As ModelDescription = GetOrCreateModelDescription(elementType)
            If collectionModelDescription IsNot Nothing Then
                Return New CollectionModelDescription() With {
                    .Name = ModelNameHelper.GetModelName(modelType),
                    .ModelType = modelType,
                    .ElementDescription = collectionModelDescription
                }
            End If

            Return Nothing
        End Function

        Private Function GenerateComplexTypeModelDescription(modelType As Type) As ModelDescription
            Dim complexModelDescription As New ComplexTypeModelDescription() With {
                .Name = ModelNameHelper.GetModelName(modelType),
                .ModelType = modelType,
                .Documentation = CreateDefaultDocumentation(modelType)
            }

            GeneratedModels.Add(complexModelDescription.Name, complexModelDescription)
            Dim hasDataContractAttribute As Boolean = modelType.GetCustomAttribute(Of DataContractAttribute)() IsNot Nothing
            Dim properties As PropertyInfo() = modelType.GetProperties(BindingFlags.[Public] Or BindingFlags.Instance)
            For Each [property] As PropertyInfo In properties
                If ShouldDisplayMember([property], hasDataContractAttribute) Then
                    Dim propertyModel As New ParameterDescription() With {
                        .Name = GetMemberName([property], hasDataContractAttribute)
                    }

                    If DocumentationProvider IsNot Nothing Then
                        propertyModel.Documentation = DocumentationProvider.GetDocumentation([property])
                    End If

                    GenerateAnnotations([property], propertyModel)
                    complexModelDescription.Properties.Add(propertyModel)
                    propertyModel.TypeDescription = GetOrCreateModelDescription([property].PropertyType)
                End If
            Next

            Dim fields As FieldInfo() = modelType.GetFields(BindingFlags.[Public] Or BindingFlags.Instance)
            For Each field As FieldInfo In fields
                If ShouldDisplayMember(field, hasDataContractAttribute) Then
                    Dim propertyModel As New ParameterDescription() With {
                        .Name = GetMemberName(field, hasDataContractAttribute)
                    }

                    If DocumentationProvider IsNot Nothing Then
                        propertyModel.Documentation = DocumentationProvider.GetDocumentation(field)
                    End If

                    complexModelDescription.Properties.Add(propertyModel)
                    propertyModel.TypeDescription = GetOrCreateModelDescription(field.FieldType)
                End If
            Next

            Return complexModelDescription
        End Function

        Private Function GenerateDictionaryModelDescription(modelType As Type, keyType As Type, valueType As Type) As DictionaryModelDescription
            Dim keyModelDescription As ModelDescription = GetOrCreateModelDescription(keyType)
            Dim valueModelDescription As ModelDescription = GetOrCreateModelDescription(valueType)

            Return New DictionaryModelDescription() With {
                .Name = ModelNameHelper.GetModelName(modelType),
                .ModelType = modelType,
                .KeyModelDescription = keyModelDescription,
                .ValueModelDescription = valueModelDescription
            }
        End Function

        Private Function GenerateEnumTypeModelDescription(modelType As Type) As EnumTypeModelDescription
            Dim enumDescription As New EnumTypeModelDescription() With {
                .Name = ModelNameHelper.GetModelName(modelType),
                .ModelType = modelType,
                .Documentation = CreateDefaultDocumentation(modelType)
            }
            Dim hasDataContractAttribute As Boolean = modelType.GetCustomAttribute(Of DataContractAttribute)() IsNot Nothing
            For Each field As FieldInfo In modelType.GetFields(BindingFlags.[Public] Or BindingFlags.[Static])
                If ShouldDisplayMember(field, hasDataContractAttribute) Then
                    Dim enumValue As New EnumValueDescription() With {
                        .Name = field.Name,
                        .Value = field.GetRawConstantValue().ToString()
                    }
                    If DocumentationProvider IsNot Nothing Then
                        enumValue.Documentation = DocumentationProvider.GetDocumentation(field)
                    End If
                    enumDescription.Values.Add(enumValue)
                End If
            Next
            GeneratedModels.Add(enumDescription.Name, enumDescription)

            Return enumDescription
        End Function

        Private Function GenerateKeyValuePairModelDescription(modelType As Type, keyType As Type, valueType As Type) As KeyValuePairModelDescription
            Dim keyModelDescription As ModelDescription = GetOrCreateModelDescription(keyType)
            Dim valueModelDescription As ModelDescription = GetOrCreateModelDescription(valueType)

            Return New KeyValuePairModelDescription() With {
                .Name = ModelNameHelper.GetModelName(modelType),
                .ModelType = modelType,
                .KeyModelDescription = keyModelDescription,
                .ValueModelDescription = valueModelDescription
            }
        End Function

        Private Function GenerateSimpleTypeModelDescription(modelType As Type) As ModelDescription
            Dim simpleModelDescription As New SimpleTypeModelDescription() With {
                .Name = ModelNameHelper.GetModelName(modelType),
                .ModelType = modelType,
                .Documentation = CreateDefaultDocumentation(modelType)
            }
            GeneratedModels.Add(simpleModelDescription.Name, simpleModelDescription)

            Return simpleModelDescription
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/ModelNameAttribute.vb
================================================
Imports System

Namespace Areas.HelpPage.ModelDescriptions
    ''' <summary>
    ''' Use this attribute to change the name of the <see cref="ModelDescription"/> generated for a type.
    ''' </summary>
    <AttributeUsage(AttributeTargets.[Class] Or AttributeTargets.Struct Or AttributeTargets.[Enum], AllowMultiple:=False, Inherited:=False)> _
    Public NotInheritable Class ModelNameAttribute
        Inherits Attribute
        Private _name As String

        Public Sub New(name As String)
            _name = name
        End Sub

        Public Property Name() As String
            Get
                Return _name
            End Get
            Private Set(value As String)
                _name = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/ModelNameHelper.vb
================================================
Imports System
Imports System.Globalization
Imports System.Linq
Imports System.Reflection

Namespace Areas.HelpPage.ModelDescriptions
    Friend NotInheritable Class ModelNameHelper
        Private Sub New()
        End Sub

        ' Modify this to provide custom model name mapping.
        Public Shared Function GetModelName(type As Type) As String
            Dim modelNameAttribute As ModelNameAttribute = type.GetCustomAttribute(Of ModelNameAttribute)()
            If modelNameAttribute IsNot Nothing AndAlso Not [String].IsNullOrEmpty(modelNameAttribute.Name) Then
                Return modelNameAttribute.Name
            End If

            Dim modelName As String = type.Name
            If type.IsGenericType Then
                ' Format the generic type name to something like: GenericOfAgurment1AndArgument2
                Dim genericType As Type = type.GetGenericTypeDefinition()
                Dim genericArguments As Type() = type.GetGenericArguments()
                Dim genericTypeName As String = genericType.Name

                ' Trim the generic parameter counts from the name
                genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf("`"c))
                Dim argumentTypeNames As String() = genericArguments.[Select](Function(t) GetModelName(t)).ToArray()
                modelName = [String].Format(CultureInfo.InvariantCulture, "{0}Of{1}", genericTypeName, [String].Join("And", argumentTypeNames))
            End If

            Return modelName
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/ParameterAnnotation.vb
================================================
Imports System

Namespace Areas.HelpPage.ModelDescriptions
    Public Class ParameterAnnotation
        Private _annotationAttribute As Attribute
        Private _documentation As String

        Public Property AnnotationAttribute() As Attribute
            Get
                Return _annotationAttribute
            End Get
            Set(value As Attribute)
                _annotationAttribute = value
            End Set
        End Property

        Public Property Documentation() As String
            Get
                Return _documentation
            End Get
            Set(value As String)
                _documentation = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/ParameterDescription.vb
================================================
Imports System.Collections.Generic
Imports System.Collections.ObjectModel

Namespace Areas.HelpPage.ModelDescriptions
    Public Class ParameterDescription
        Private _annotations As Collection(Of ParameterAnnotation)
        Private _documentation As String
        Private _name As String
        Private _typeDescription As ModelDescription

        Public Sub New()
            Annotations = New Collection(Of ParameterAnnotation)()
        End Sub

        Public Property Annotations() As Collection(Of ParameterAnnotation)
            Get
                Return _annotations
            End Get
            Private Set(value As Collection(Of ParameterAnnotation))
                _annotations = value
            End Set
        End Property

        Public Property Documentation() As String
            Get
                Return _documentation
            End Get
            Set(value As String)
                _documentation = value
            End Set
        End Property

        Public Property Name() As String
            Get
                Return _name
            End Get
            Set(value As String)
                _name = value
            End Set
        End Property

        Public Property TypeDescription() As ModelDescription
            Get
                Return _typeDescription
            End Get
            Set(value As ModelDescription)
                _typeDescription = value
            End Set
        End Property
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/ModelDescriptions/SimpleTypeModelDescription.vb
================================================
Namespace Areas.HelpPage.ModelDescriptions
    Public Class SimpleTypeModelDescription
        Inherits ModelDescription
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Models/HelpPageApiModel.vb
================================================
Imports System.Collections.Generic
Imports System.Collections.ObjectModel
Imports System.Net.Http.Headers
Imports System.Web.Http.Description
Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions

Namespace Areas.HelpPage.Models
    ''' <summary>
    ''' The model that represents an API displayed on the help page.
    ''' </summary>
    Public Class HelpPageApiModel
        Private _sampleRequests As IDictionary(Of MediaTypeHeaderValue, Object)
        Private _sampleResponses As IDictionary(Of MediaTypeHeaderValue, Object)
        Private _errorMessages As Collection(Of String)
        Private _apiDescription As ApiDescription
        Private _uriParameters As Collection(Of ParameterDescription)
        Private _requestModelDescription As ModelDescription
        Private _resourceDescription As ModelDescription
        Private _requestDocumentation As String

        '''<summary>
        ''' Initializes a new instance of the <see cref="HelpPageApiModel"/> class.
        ''' </summary>
        Public Sub New()
            UriParameters = New Collection(Of ParameterDescription)
            SampleRequests = New Dictionary(Of MediaTypeHeaderValue, Object)
            SampleResponses = New Dictionary(Of MediaTypeHeaderValue, Object)
            ErrorMessages = New Collection(Of String)
        End Sub

        ''' <summary>
        ''' Gets or sets the <see cref="ApiDescription"/> that describes the API.
        ''' </summary>
        Public Property ApiDescription As ApiDescription
            Get
                Return _apiDescription
            End Get
            Set(value As ApiDescription)
                _apiDescription = value
            End Set
        End Property


        ''' <summary>
        ''' Gets or sets the <see cref="ParameterDescription"/> collection that describes the URI parameters for the API.
        ''' </summary>
        Public Property UriParameters() As Collection(Of ParameterDescription)
            Get
                Return _uriParameters
            End Get
            Private Set(value As Collection(Of ParameterDescription))
                _uriParameters = value
            End Set
        End Property

        ''' <summary>
        ''' Gets or sets the documentation for the request.
        ''' </summary>
        Public Property RequestDocumentation() As String
            Get
                Return _requestDocumentation
            End Get
            Set(value As String)
                _requestDocumentation = value
            End Set
        End Property

        ''' <summary>
        ''' Gets or sets the model description of the request body.
        ''' </summary>
        Public Property RequestModelDescription() As ModelDescription
            Get
                Return _requestModelDescription
            End Get
            Set(value As ModelDescription)
                _requestModelDescription = value
            End Set
        End Property

        ''' <summary>
        ''' Gets the request body parameter descriptions.
        ''' </summary>
        Public ReadOnly Property RequestBodyParameters() As IList(Of ParameterDescription)
            Get
                Return GetParameterDescriptions(RequestModelDescription)
            End Get
        End Property

        ''' <summary>
        ''' Gets or sets the <see cref="ModelDescription"/> that describes the resource.
        ''' </summary>
        Public Property ResourceDescription() As ModelDescription
            Get
                Return _resourceDescription
            End Get
            Set(value As ModelDescription)
                _resourceDescription = value
            End Set
        End Property

        ''' <summary>
        ''' Gets the resource property descriptions.
        ''' </summary>
        Public ReadOnly Property ResourceProperties() As IList(Of ParameterDescription)
            Get
                Return GetParameterDescriptions(ResourceDescription)
            End Get
        End Property

        ''' <summary>
        ''' Gets the sample requests associated with the API.
        ''' </summary>
        Public Property SampleRequests As IDictionary(Of MediaTypeHeaderValue, Object)
            Get
                Return _sampleRequests
            End Get
            Private Set(value As IDictionary(Of MediaTypeHeaderValue, Object))
                _sampleRequests = value
            End Set
        End Property

        ''' <summary>
        ''' Gets the sample responses associated with the API.
        ''' </summary>
        Public Property SampleResponses As IDictionary(Of MediaTypeHeaderValue, Object)
            Get
                Return _sampleResponses
            End Get
            Private Set(value As IDictionary(Of MediaTypeHeaderValue, Object))
                _sampleResponses = value
            End Set
        End Property

        ''' <summary>
        ''' Gets the error messages associated with this model.
        ''' </summary>
        Public Property ErrorMessages As Collection(Of String)
            Get
                Return _errorMessages
            End Get
            Private Set(value As Collection(Of String))
                _errorMessages = value
            End Set
        End Property

        Private Shared Function GetParameterDescriptions(modelDescription As ModelDescription) As IList(Of ParameterDescription)
            Dim complexTypeModelDescription As ComplexTypeModelDescription = TryCast(modelDescription, ComplexTypeModelDescription)
            If complexTypeModelDescription IsNot Nothing Then
                Return complexTypeModelDescription.Properties
            End If

            Dim collectionModelDescription As CollectionModelDescription = TryCast(modelDescription, CollectionModelDescription)
            If collectionModelDescription IsNot Nothing Then
                complexTypeModelDescription = TryCast(collectionModelDescription.ElementDescription, ComplexTypeModelDescription)
                If complexTypeModelDescription IsNot Nothing Then
                    Return complexTypeModelDescription.Properties
                End If
            End If

            Return Nothing
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/SampleGeneration/HelpPageSampleGenerator.vb
================================================
Imports System
Imports System.Collections.Generic
Imports System.Collections.ObjectModel
Imports System.ComponentModel
Imports System.Diagnostics.CodeAnalysis
Imports System.Globalization
Imports System.IO
Imports System.Linq
Imports System.Net.Http
Imports System.Net.Http.Formatting
Imports System.Net.Http.Headers
Imports System.Runtime.InteropServices
Imports System.Web.Http.Description
Imports System.Xml.Linq
Imports Newtonsoft.Json

Namespace Areas.HelpPage
    ''' <summary>
    ''' This class will generate the samples for the help page.
    ''' </summary>
    Public Class HelpPageSampleGenerator
        Private _actualHttpMessageTypes As IDictionary(Of HelpPageSampleKey, Type)
        Private _actionSamples As IDictionary(Of HelpPageSampleKey, Object)
        Private _sampleObjects As IDictionary(Of Type, Object)
        Private _sampleObjectFactories As IList(Of Func(Of HelpPageSampleGenerator, Type, Object))

        ''' <summary>
        ''' Initializes a new instance of the <see cref="HelpPageSampleGenerator"/> class.
        ''' </summary>
        Public Sub New()
            ActualHttpMessageTypes = New Dictionary(Of HelpPageSampleKey, Type)
            ActionSamples = New Dictionary(Of HelpPageSampleKey, Object)
            SampleObjects = New Dictionary(Of Type, Object)
            SampleObjectFactories = New List(Of Func(Of HelpPageSampleGenerator, Type, Object))
            SampleObjectFactories.Add(AddressOf DefaultSampleObjectFactory)
        End Sub

        ''' <summary>
        ''' Gets CLR types that are used as the content of <see cref="HttpRequestMessage"/> or <see cref="HttpResponseMessage"/>.
        ''' </summary>
        Public Property ActualHttpMessageTypes As IDictionary(Of HelpPageSampleKey, Type)
            Get
                Return _actualHttpMessageTypes
            End Get
            Friend Set(value As IDictionary(Of HelpPageSampleKey, Type))
                _actualHttpMessageTypes = value
            End Set
        End Property

        ''' <summary>
        ''' Gets the objects that are used directly as samples for certain actions.
        ''' </summary>
        Public Property ActionSamples As IDictionary(Of HelpPageSampleKey, Object)
            Get
                Return _actionSamples
            End Get
            Friend Set(value As IDictionary(Of HelpPageSampleKey, Object))
                _actionSamples = value
            End Set
        End Property

        ''' <summary>
        ''' Gets the objects that are serialized as samples by the supported formatters.
        ''' </summary>
        Public Property SampleObjects As IDictionary(Of Type, Object)
            Get
                Return _sampleObjects
            End Get
            Friend Set(value As IDictionary(Of Type, Object))
                _sampleObjects = value
            End Set
        End Property

        ''' <summary>
        ''' Gets factories for the objects that the supported formatters will serialize as samples. Processed in order,
        ''' stopping when the factory successfully returns a non-<see langref="null"/> object.
        ''' </summary>
        ''' <remarks>
        ''' Collection includes just <see cref="ObjectGenerator.GenerateObject"/> initially. Use
        ''' <code>SampleObjectFactories.Insert(0, func)</code> to provide an override and
        ''' <code>SampleObjectFactories.Add(func)</code> to provide a fallback.</remarks>
        <SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures",
            Justification:="This is an appropriate nesting of generic types")>
        Public Property SampleObjectFactories As IList(Of Func(Of HelpPageSampleGenerator, Type, Object))
            Get
                Return _sampleObjectFactories
            End Get
            Private Set(value As IList(Of Func(Of HelpPageSampleGenerator, Type, Object)))
                _sampleObjectFactories = value
            End Set
        End Property

        ''' <summary>
        ''' Gets the request body samples for a given <see cref="ApiDescription"/>.
        ''' </summary>
        ''' <param name="api">The <see cref="ApiDescription"/>.</param>
        ''' <returns>The samples keyed by media type.</returns>
        Public Function GetSampleRequests(api As ApiDescription) As IDictionary(Of MediaTypeHeaderValue, Object)
            Return GetSample(api, SampleDirection.Request)
        End Function

        ''' <summary>
        ''' Gets the response body samples for a given <see cref="ApiDescription"/>.
        ''' </summary>
        ''' <param name="api">The <see cref="ApiDescription"/>.</param>
        ''' <returns>The samples keyed by media type.</returns>
        Public Function GetSampleResponses(api As ApiDescription) As IDictionary(Of MediaTypeHeaderValue, Object)
            Return GetSample(api, SampleDirection.Response)
        End Function

        ''' <summary>
        ''' Gets the request or response body samples.
        ''' </summary>
        ''' <param name="api">The <see cref="ApiDescription"/>.</param>
        ''' <param name="sampleDirection">The value indicating whether the sample is for a request or for a response.</param>
        ''' <returns>The samples keyed by media type.</returns>
        Public Overridable Function GetSample(api As ApiDescription, sampleDirection As SampleDirection) As IDictionary(Of MediaTypeHeaderValue, Object)
            If (api Is Nothing) Then
                Throw New ArgumentNullException("api")
            End If

            Dim controllerName As String = api.ActionDescriptor.ControllerDescriptor.ControllerName
            Dim actionName As String = api.ActionDescriptor.ActionName
            Dim parameterNames As IEnumerable(Of String) = api.ParameterDescriptions.Select(Function(p) p.Name)
            Dim formatters As New Collection(Of MediaTypeFormatter)
            Dim type As Type = ResolveType(api, controllerName, actionName, parameterNames, sampleDirection, formatters)
            Dim samples As New Dictionary(Of MediaTypeHeaderValue, Object)

            ' Use the samples provided directly for actions
            Dim actionSamples = GetAllActionSamples(controllerName, actionName, parameterNames, sampleDirection)
            For Each actionSample In actionSamples
                samples.Add(actionSample.Key.MediaType, WrapSampleIfString(actionSample.Value))
            Next

            ' Do the sample generation based on formatters only if an action doesn't return an HttpResponseMessage.
            ' Here we cannot rely on formatters because we don't know what's in the HttpResponseMessage, it might not even use formatters.
            If (Not type Is Nothing AndAlso Not GetType(HttpResponseMessage).IsAssignableFrom(type)) Then
                Dim sampleObject As Object = GetSampleObject(type)
                For Each formatter In formatters
                    For Each mediaType As MediaTypeHeaderValue In formatter.SupportedMediaTypes
                        If (Not samples.ContainsKey(mediaType)) Then
                            Dim sample As Object = GetActionSample(controllerName, actionName, parameterNames, type, formatter, mediaType, sampleDirection)
                            ' If no sample found, try generate sample using formatter and sample object
                            If (sample Is Nothing And Not sampleObject Is Nothing) Then
                                sample = WriteSampleObjectUsingFormatter(formatter, sampleObject, type, mediaType)
                            End If

                            samples.Add(mediaType, WrapSampleIfString(sample))
                        End If
                    Next
                Next
            End If
            Return samples
        End Function

        ''' <summary>
        ''' Search for samples that are provided directly through <see cref="ActionSamples"/>.
        ''' </summary>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        ''' <param name="type">The CLR type.</param>
        ''' <param name="formatter">The formatter.</param>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="sampleDirection">The value indicating whether the sample is for a request or for a response.</param>
        ''' <returns>The sample that matches the parameters.</returns>
        Public Overridable Function GetActionSample(controllerName As String, actionName As String, parameterNames As IEnumerable(Of String), type As Type, formatter As MediaTypeFormatter, mediaType As MediaTypeHeaderValue, sampleDirection As SampleDirection) As Object
            Dim sample As New Object

            ' First, try to get the sample provided for the specified mediaType, sampleDirection, controllerName, actionName and parameterNames.
            ' If not found, try to get the sample provided for the specified mediaType, sampleDirection, controllerName and actionName regardless of the parameterNames.
            ' If still not found, try to get the sample provided for the specified mediaType and type.
            ' Finally, try to get the sample provided for the specified mediaType.
            If (ActionSamples.TryGetValue(New HelpPageSampleKey(mediaType, sampleDirection, controllerName, actionName, parameterNames), sample) OrElse
                ActionSamples.TryGetValue(New HelpPageSampleKey(mediaType, sampleDirection, controllerName, actionName, New String() {"*"}), sample) OrElse
                ActionSamples.TryGetValue(New HelpPageSampleKey(mediaType, type), sample) OrElse
                ActionSamples.TryGetValue(New HelpPageSampleKey(mediaType), sample)) Then
                Return sample
            End If
            Return Nothing
        End Function

        ''' <summary>
        ''' Gets the sample object that will be serialized by the formatters. 
        ''' First, it will look at the <see cref="SampleObjects"/>. If no sample object is found, it will try to create
        ''' one using <see cref="DefaultSampleObjectFactory"/> (which wraps an <see cref="ObjectGenerator"/>) and other
        ''' factories in <see cref="SampleObjectFactories"/>.
        ''' </summary>
        ''' <param name="type">The type.</param>
        ''' <returns>The sample object.</returns>
        <SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes",
            Justification:="Even if all items in SampleObjectFactories throw, problem will be visible as missing sample.")>
        Public Overridable Function GetSampleObject(type As Type) As Object
            Dim sampleObject As New Object

            If (Not SampleObjects.TryGetValue(type, sampleObject)) Then
                ' No specific object available, try our factories.
                For Each factory As Func(Of HelpPageSampleGenerator, Type, Object) In SampleObjectFactories
                    If factory Is Nothing Then
                        Continue For
                    End If

                    Try
                        sampleObject = factory(Me, type)
                        If sampleObject IsNot Nothing Then
                            Exit For
                        End If
                    Catch
                        ' Ignore any problems encountered in the factory; go on to the next one (if any).
                    End Try
                Next
            End If

            Return sampleObject
        End Function

        ''' <summary>
        ''' Resolves the actual type of <see cref="System.Net.Http.ObjectContent(Of T)"/> passed to the <see cref="System.Net.Http.HttpRequestMessage"/> in an action.
        ''' </summary>
        ''' <param name="api">The <see cref="ApiDescription"/>.</param>
        ''' <returns>The type.</returns>
        Public Overridable Function ResolveHttpRequestMessageType(api As ApiDescription) As Type
            Dim controllerName As String = api.ActionDescriptor.ControllerDescriptor.ControllerName
            Dim actionName As String = api.ActionDescriptor.ActionName
            Dim parameterNames As IEnumerable(Of String) = api.ParameterDescriptions.[Select](Function(p) p.Name)
            Dim formatters As Collection(Of MediaTypeFormatter) = Nothing
            Return ResolveType(api, controllerName, actionName, parameterNames, SampleDirection.Request, formatters)
        End Function

        ''' <summary>
        ''' Resolves the type of the action parameter or return value when <see cref="HttpRequestMessage"/> or <see cref="HttpResponseMessage"/> is used.
        ''' </summary>
        ''' <param name="api">The <see cref="ApiDescription"/>.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        ''' <param name="sampleDirection">The value indicating whether the sample is for a request or a response.</param>
        ''' <param name="formatters">The formatters.</param>
        <SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", Justification:="This is only used in advanced scenarios.")>
        Public Overridable Function ResolveType(api As ApiDescription, controllerName As String, actionName As String, parameterNames As IEnumerable(Of String), sampleDirection As SampleDirection, <Out()> ByRef formatters As Collection(Of MediaTypeFormatter)) As Type
            If (Not [Enum].IsDefined(GetType(SampleDirection), sampleDirection)) Then
                Throw New InvalidEnumArgumentException("sampleDirection", CInt(sampleDirection), GetType(SampleDirection))
            End If
            If (api Is Nothing) Then
                Throw New ArgumentNullException("api")
            End If
            Dim type As Type = GetType(Object)

            If (ActualHttpMessageTypes.TryGetValue(New HelpPageSampleKey(sampleDirection, controllerName, actionName, parameterNames), type) OrElse
                ActualHttpMessageTypes.TryGetValue(New HelpPageSampleKey(sampleDirection, controllerName, actionName, New String() {"*"}), type)) Then
                ' Re-compute the supported formatters based on type
                Dim newFormatters As New Collection(Of MediaTypeFormatter)
                For Each formatter In api.ActionDescriptor.Configuration.Formatters
                    If (IsFormatSupported(sampleDirection, formatter, type)) Then
                        newFormatters.Add(formatter)
                    End If
                Next

                formatters = newFormatters
            Else
                Select Case sampleDirection
                    Case sampleDirection.Request
                        Dim requestBodyParameter As ApiParameterDescription = api.ParameterDescriptions.FirstOrDefault(Function(p) p.Source = ApiParameterSource.FromBody)
                        type = If(requestBodyParameter Is Nothing, Nothing, requestBodyParameter.ParameterDescriptor.ParameterType)
                        formatters = api.SupportedRequestBodyFormatters
                    Case Else
                        'Case sampleDirection.Response
                        type = If(api.ResponseDescription.ResponseType, api.ResponseDescription.DeclaredType)
                        formatters = api.SupportedResponseFormatters
                End Select
            End If
            Return type
        End Function

        ''' <summary>
        ''' Writes the sample object using formatter.
        ''' </summary>
        ''' <param name="formatter">The formatter.</param>
        ''' <param name="value">The value.</param>
        ''' <param name="type">The type.</param>
        ''' <param name="mediaType">Type of the media.</param>
        ''' <returns></returns>
        <SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification:="The exception is recorded as InvalidSample.")>
        Public Overridable Function WriteSampleObjectUsingFormatter(formatter As MediaTypeFormatter, value As Object, type As Type, mediaType As MediaTypeHeaderValue) As Object
            If (formatter Is Nothing) Then
                Throw New ArgumentNullException("formatter")
            End If
            If (mediaType Is Nothing) Then
                Throw New ArgumentNullException("mediaType")
            End If

            Dim sample As Object = String.Empty
            Dim MS As MemoryStream = Nothing
            Dim content As HttpContent = Nothing
            Try
                If (formatter.CanWriteType(type)) Then
                    MS = New MemoryStream()
                    content = New ObjectContent(type, value, formatter, mediaType)
                    formatter.WriteToStreamAsync(type, value, MS, content, Nothing).Wait()
                    MS.Position = 0
                    Dim reader As New StreamReader(MS)
                    Dim serializedSampleString As String = reader.ReadToEnd()
                    If (mediaType.MediaType.ToUpperInvariant().Contains("XML")) Then
                        serializedSampleString = TryFormatXml(serializedSampleString)
                    ElseIf (mediaType.MediaType.ToUpperInvariant().Contains("JSON")) Then
                        serializedSampleString = TryFormatJson(serializedSampleString)
                    End If

                    sample = New TextSample(serializedSampleString)
                Else
                    sample = New InvalidSample(String.Format(
                        CultureInfo.CurrentCulture,
                        "Failed to generate the sample for media type '{0}'. Cannot use formatter '{1}' to write type '{2}'.",
                        mediaType,
                        formatter.GetType().Name,
                        type.Name))
                End If
            Catch e As Exception
                sample = New InvalidSample(String.Format(
                    CultureInfo.CurrentCulture,
                    "An exception has occurred while using the formatter '{0}' to generate sample for media type '{1}'. Exception message: {2}",
                    formatter.GetType().Name,
                    mediaType.MediaType,
                    UnwrapException(e).Message))
            Finally
                If (Not MS Is Nothing) Then
                    MS.Dispose()
                End If
                If (Not content Is Nothing) Then
                    content.Dispose()
                End If
            End Try
            Return sample
        End Function

        Friend Shared Function UnwrapException(exception As Exception) As Exception
            Dim aggregateException As AggregateException = TryCast(exception, AggregateException)
            If aggregateException IsNot Nothing Then
                Return aggregateException.Flatten().InnerException
            End If
            Return exception
        End Function

        Private Shared Function DefaultSampleObjectFactory(sampleGenerator As HelpPageSampleGenerator, type As Type) As Object
            ' Try create a default sample object
            Dim objectGenerator As New ObjectGenerator()
            Return objectGenerator.GenerateObject(type)
        End Function

        <SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification:="Handling the failure by returning the original string.")>
        Private Shared Function TryFormatJson(str As String) As String
            Try
                Dim parsedJson As Object = JsonConvert.DeserializeObject(str)
                Return JsonConvert.SerializeObject(parsedJson, Formatting.Indented)
            Catch
                ' can't parse JSON, return the original string
                Return str
            End Try
        End Function

        <SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification:="Handling the failure by returning the original string.")>
        Private Shared Function TryFormatXml(str As String) As String
            Try
                Dim Xml As XDocument = XDocument.Parse(str)
                Return Xml.ToString()
            Catch
                ' can't parse XML, return the original string
                Return str
            End Try
        End Function

        Private Shared Function IsFormatSupported(sampleDirection As SampleDirection, formatter As MediaTypeFormatter, type As Type) As Boolean
            Select Case sampleDirection
                Case sampleDirection.Request
                    Return formatter.CanReadType(type)
                Case sampleDirection.Response
                    Return formatter.CanWriteType(type)
            End Select
            Return False
        End Function

        Private Iterator Function GetAllActionSamples(controllerName As String, actionName As String, parameterNames As IEnumerable(Of String), sampleDirection As SampleDirection) As IEnumerable(Of KeyValuePair(Of HelpPageSampleKey, Object))
            Dim parameterNamesSet As New HashSet(Of String)(parameterNames, StringComparer.OrdinalIgnoreCase)
            For Each sample In ActionSamples
                Dim sampleKey As HelpPageSampleKey = sample.Key
                If (String.Equals(controllerName, sampleKey.ControllerName, StringComparison.OrdinalIgnoreCase) And
                        String.Equals(actionName, sampleKey.ActionName, StringComparison.OrdinalIgnoreCase) And
                        (sampleKey.ParameterNames.SetEquals(New String() {"*"}) Or parameterNamesSet.SetEquals(sampleKey.ParameterNames)) And
                        sampleDirection = sampleKey.SampleDirection) Then
                    Yield sample
                End If
            Next
        End Function

        Private Shared Function WrapSampleIfString(sample As Object) As Object
            Dim stringSample As String = TryCast(sample, String)
            If (Not stringSample Is Nothing) Then
                Return New TextSample(stringSample)
            End If
            Return sample
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/SampleGeneration/HelpPageSampleKey.vb
================================================
Imports System
Imports System.Collections.Generic
Imports System.ComponentModel
Imports System.Net.Http.Headers

Namespace Areas.HelpPage
    ''' <summary>
    ''' This is used to identify the place where the sample should be applied.
    ''' </summary>
    Public Class HelpPageSampleKey
        Private _actionName As String
        Private _controllerName As String
        Private _mediaType As MediaTypeHeaderValue
        Private _parameterNames As HashSet(Of String)
        Private _parameterType As Type
        Private _sampleDirection As Nullable(Of SampleDirection)

        ''' <summary>
        ''' Creates a new <see cref="HelpPageSampleKey"/> based on media type.
        ''' </summary>
        ''' <param name="mediaType">The media type.</param>
        Public Sub New(mediaType As MediaTypeHeaderValue)
            If (mediaType Is Nothing) Then
                Throw New ArgumentNullException("mediaType")
            End If

            _actionName = String.Empty
            _controllerName = String.Empty
            _parameterNames = New HashSet(Of String)(StringComparer.OrdinalIgnoreCase)
            _mediaType = mediaType
        End Sub

        ''' <summary>
        ''' Creates a new <see cref="HelpPageSampleKey"/> based on media type and CLR type.
        ''' </summary>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="type">The CLR type.</param>
        Public Sub New(mediaType As MediaTypeHeaderValue, type As Type)
            MyClass.New(mediaType)

            If (type Is Nothing) Then
                Throw New ArgumentNullException("type")
            End If

            _parameterType = type
        End Sub

        ''' <summary>
        ''' Creates a new <see cref="HelpPageSampleKey"/> based on <see cref="SampleDirection"/>, controller name, action name and parameter names.
        ''' </summary>
        ''' <param name="sampleDirection">The <see cref="SampleDirection"/>.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        Public Sub New(sampleDirection As SampleDirection, controllerName As String, actionName As String, parameterNames As IEnumerable(Of String))
            If (Not [Enum].IsDefined(GetType(SampleDirection), sampleDirection)) Then
                Throw New InvalidEnumArgumentException("sampleDirection", CInt(sampleDirection), GetType(SampleDirection))
            End If
            If (controllerName Is Nothing) Then
                Throw New ArgumentNullException("controllerName")
            End If
            If (actionName Is Nothing) Then
                Throw New ArgumentNullException("actionName")
            End If
            If (parameterNames Is Nothing) Then
                Throw New ArgumentNullException("parameterNames")
            End If

            _controllerName = controllerName
            _actionName = actionName
            _parameterNames = New HashSet(Of String)(parameterNames, StringComparer.OrdinalIgnoreCase)
            _sampleDirection = sampleDirection
        End Sub

        ''' <summary>
        ''' Creates a new <see cref="HelpPageSampleKey"/> based on media type, <see cref="SampleDirection"/>, controller name, action name and parameter names.
        ''' </summary>
        ''' <param name="mediaType">The media type.</param>
        ''' <param name="sampleDirection">The <see cref="SampleDirection"/>.</param>
        ''' <param name="controllerName">Name of the controller.</param>
        ''' <param name="actionName">Name of the action.</param>
        ''' <param name="parameterNames">The parameter names.</param>
        Public Sub New(mediaType As MediaTypeHeaderValue, sampleDirection As SampleDirection, controllerName As String, actionName As String, parameterNames As IEnumerable(Of String))
            MyClass.New(sampleDirection, controllerName, actionName, parameterNames)

            If (mediaType Is Nothing) Then
                Throw New ArgumentNullException("mediaType")
            End If

            _mediaType = mediaType
        End Sub

        ''' <summary>
        ''' Gets the name of the controller.
        ''' </summary>
        ''' <value>
        ''' The name of the controller.
        ''' </value>
        Public ReadOnly Property ControllerName As String
            Get
                Return _controllerName
            End Get
        End Property

        ''' <summary>
        ''' Gets the name of the action.
        ''' </summary>
        ''' <value>
        ''' The name of the action.
        ''' </value>
        Public ReadOnly Property ActionName As String
            Get
                Return _actionName
            End Get
        End Property

        ''' <summary>
        ''' Gets the media type.
        ''' </summary>
        ''' <value>
        ''' The media type.
        ''' </value>
        Public ReadOnly Property MediaType As MediaTypeHeaderValue
            Get
                Return _mediaType
            End Get
        End Property

        ''' <summary>
        ''' Gets the parameter names.
        ''' </summary>
        Public ReadOnly Property ParameterNames As HashSet(Of String)
            Get
                Return _parameterNames
            End Get
        End Property

        Public ReadOnly Property ParameterType As Type
            Get
                Return _parameterType
            End Get
        End Property

        ''' <summary>
        ''' Gets the <see cref="SampleDirection"/>.
        ''' </summary>
        Public ReadOnly Property SampleDirection As Nullable(Of SampleDirection)
            Get
                Return _sampleDirection
            End Get
        End Property

        Public Overrides Function Equals(obj As Object) As Boolean
            Dim otherKey As HelpPageSampleKey = TryCast(obj, HelpPageSampleKey)
            If (otherKey Is Nothing) Then
                Return False
            End If

            Return String.Equals(ControllerName, otherKey.ControllerName, StringComparison.OrdinalIgnoreCase) And
                String.Equals(ActionName, otherKey.ActionName, StringComparison.OrdinalIgnoreCase) And
                (MediaType Is otherKey.MediaType Or (Not MediaType Is Nothing AndAlso MediaType.Equals(otherKey.MediaType))) And
                ParameterType = otherKey.ParameterType And
                SampleDirection.Equals(otherKey.SampleDirection) And
                ParameterNames.SetEquals(otherKey.ParameterNames)
        End Function

        Public Overrides Function GetHashCode() As Integer
            Dim hashCode As Integer = ControllerName.ToUpperInvariant().GetHashCode() Xor ActionName.ToUpperInvariant().GetHashCode()
            If (Not MediaType Is Nothing) Then
                hashCode = hashCode Xor MediaType.GetHashCode()
            End If
            If (SampleDirection.HasValue) Then
                hashCode = hashCode Xor SampleDirection.GetHashCode()
            End If
            If (Not ParameterType Is Nothing) Then
                hashCode = hashCode Xor ParameterType.GetHashCode()
            End If
            For Each parameterName As String In ParameterNames
                hashCode = hashCode Xor parameterName.ToUpperInvariant().GetHashCode()
            Next
            Return hashCode
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/SampleGeneration/ImageSample.vb
================================================
Imports System

Namespace Areas.HelpPage
    ''' <summary>
    ''' This represents an image sample on the help page. There's a display template named ImageSample associated with this class.
    ''' </summary>
    Public Class ImageSample
        Private _src As String

        ''' <summary>
        ''' Initializes a new instance of the <see cref="ImageSample"/> class.
        ''' </summary>
        ''' <param name="src">The URL of an image.</param>
        Public Sub New(src As String)
            If (src Is Nothing) Then
                Throw New ArgumentNullException("src")
            End If
            Me.Src = src
        End Sub

        Public Property Src As String
            Get
                Return _src
            End Get
            Private Set(value As String)
                _src = value
            End Set
        End Property

        Public Overrides Function Equals(obj As Object) As Boolean
            Dim other As ImageSample = TryCast(obj, ImageSample)

            Return Not other Is Nothing AndAlso Src = other.Src
        End Function

        Public Overrides Function GetHashCode() As Integer
            Return Src.GetHashCode()
        End Function

        Public Overrides Function ToString() As String
            Return Src
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/SampleGeneration/InvalidSample.vb
================================================
Imports System

Namespace Areas.HelpPage
    ''' <summary>
    ''' This represents an invalid sample on the help page. There's a display template named InvalidSample associated with this class.
    ''' </summary>
    Public Class InvalidSample
        Private _errorMessage As String

        Public Sub New(errorMessage As String)
            If (errorMessage Is Nothing) Then
                Throw New ArgumentNullException("errorMessage")
            End If

            Me.ErrorMessage = errorMessage
        End Sub

        Public Property ErrorMessage As String
            Get
                Return _errorMessage
            End Get
            Private Set(value As String)
                _errorMessage = value
            End Set
        End Property

        Public Overrides Function Equals(obj As Object) As Boolean
            Dim other As InvalidSample = TryCast(obj, InvalidSample)
            Return Not other Is Nothing AndAlso ErrorMessage = other.ErrorMessage
        End Function

        Public Overrides Function GetHashCode() As Integer
            Return ErrorMessage.GetHashCode()
        End Function

        Public Overrides Function ToString() As String
            Return ErrorMessage
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/SampleGeneration/ObjectGenerator.vb
================================================
Imports System
Imports System.Collections
Imports System.Collections.Generic
Imports System.Diagnostics.CodeAnalysis
Imports System.Globalization
Imports System.Linq
Imports System.Reflection
Imports Microsoft.VisualBasic

Namespace Areas.HelpPage
    ''' <summary>
    ''' This class will create an object of a given type and populate it with sample data.
    ''' </summary>
    Public Class ObjectGenerator
        Friend Const DefaultCollectionSize As Integer = 2
        Private ReadOnly SimpleObjectGenerator As New SimpleTypeObjectGenerator()

        ''' <summary>
        ''' Generates an object for a given type. The type needs to be public, have a public default constructor and settable public properties/fields. Currently it supports the following types:
        ''' Simple types: <see cref="int"/>, <see cref="string"/>, <see cref="[Enum]"/>, <see cref="DateTime"/>, <see cref="Uri"/>, etc.
        ''' Complex types: POCO types.
        ''' Nullables: <see cref="Nullable(Of T)"/>.
        ''' Arrays: arrays of simple types or complex types.
        ''' Key value pairs: <see cref="KeyValuePair(Of TKey,TValue)"/>
        ''' Tuples: <see cref="Tuple(Of T1)"/>, <see cref="Tuple(Of T1,T2)"/>, etc
        ''' Dictionaries: <see cref="IDictionary(Of TKey,TValue)"/> or anything deriving from <see cref="IDictionary(Of TKey,TValue)"/>.
        ''' Collections: <see cref="IList(Of T)"/>, <see cref="IEnumerable(Of T)"/>, <see cref="ICollection(Of T)"/>, <see cref="IList"/>, <see cref="IEnumerable"/>, <see cref="ICollection"/> or anything deriving from <see cref="ICollection(Of T)"/> or <see cref="IList"/>.
        ''' Queryables: <see cref="System.Linq.IQueryable"/>, <see cref="IQueryable(Of T)"/>.
        ''' </summary>
        ''' <param name="type">The type.</param>
        ''' <returns>An object of the given type.</returns>
        Public Function GenerateObject(type As Type) As Object
            GenerateObject = GenerateObject(type, New Dictionary(Of Type, Object)())
        End Function

        <SuppressMessage("Microsoft.Design", "CA1031:DoNotCatchGeneralExceptionTypes", Justification:="Here we just want to return null if anything goes wrong.")>
        Private Function GenerateObject(type As Type, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Try
                If (SimpleTypeObjectGenerator.CanGenerateObject(type)) Then
                    Return SimpleObjectGenerator.GenerateObject(type)
                End If

                If (type.IsArray) Then
                    Return GenerateArray(type, DefaultCollectionSize, createdObjectReferences)
                End If

                If (type.IsGenericType) Then
                    Return GenerateGenericType(type, DefaultCollectionSize, createdObjectReferences)
                End If

                If (type Is GetType(IDictionary)) Then
                    Return GenerateDictionary(GetType(Hashtable), DefaultCollectionSize, createdObjectReferences)
                End If

                If (GetType(IDictionary).IsAssignableFrom(type)) Then
                    Return GenerateDictionary(type, DefaultCollectionSize, createdObjectReferences)
                End If

                If (type Is GetType(IList) Or
                        type Is GetType(IEnumerable) Or
                        type Is GetType(ICollection)) Then
                    Return GenerateCollection(GetType(ArrayList), DefaultCollectionSize, createdObjectReferences)
                End If

                If (GetType(IList).IsAssignableFrom(type)) Then
                    Return GenerateCollection(type, DefaultCollectionSize, createdObjectReferences)
                End If

                If (type Is GetType(IQueryable)) Then
                    Return GenerateQueryable(type, DefaultCollectionSize, createdObjectReferences)
                End If

                If (type.IsEnum) Then
                    Return GenerateEnum(type)
                End If

                If (type.IsPublic Or type.IsNestedPublic) Then
                    Return GenerateComplexObject(type, createdObjectReferences)
                End If
            Catch
                ' Returns Nothing if anything fails
                Return Nothing
            End Try

            Return Nothing
        End Function

        Private Shared Function GenerateGenericType(type As Type, collectionSize As Integer, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim genericTypeDefinition As Type = type.GetGenericTypeDefinition()

            If (genericTypeDefinition Is GetType(Nullable()) Or genericTypeDefinition Is GetType(Nullable(Of ))) Then
                Return GenerateNullable(type, createdObjectReferences)
            End If

            If (genericTypeDefinition Is GetType(KeyValuePair(Of ,))) Then
                Return GenerateKeyValuePair(type, createdObjectReferences)
            End If

            If (IsTuple(genericTypeDefinition)) Then
                Return GenerateTuple(type, createdObjectReferences)
            End If

            Dim genericArguments() As Type = type.GetGenericArguments()

            If (genericArguments.Length = 1) Then
                If (genericTypeDefinition Is GetType(IList(Of )) Or
                    genericTypeDefinition Is GetType(IEnumerable(Of )) Or
                    genericTypeDefinition Is GetType(ICollection(Of ))) Then

                    Dim collectionType As Type = GetType(List(Of )).MakeGenericType(genericArguments)
                    Return GenerateCollection(collectionType, collectionSize, createdObjectReferences)
                End If

                If (genericTypeDefinition Is GetType(IQueryable(Of ))) Then
                    Return GenerateQueryable(type, collectionSize, createdObjectReferences)
                End If

                Dim closedCollectionType As Type = GetType(ICollection(Of )).MakeGenericType(genericArguments(0))
                If (closedCollectionType.IsAssignableFrom(type)) Then
                    Return GenerateCollection(type, collectionSize, createdObjectReferences)
                End If
            End If

            If (genericArguments.Length = 2) Then
                If (genericTypeDefinition Is GetType(IDictionary(Of ,))) Then
                    Dim dictionaryType As Type = GetType(Dictionary(Of ,)).MakeGenericType(genericArguments)
                    Return GenerateDictionary(dictionaryType, collectionSize, createdObjectReferences)
                End If

                Dim closedDictionaryType As Type = GetType(IDictionary(Of ,)).MakeGenericType(genericArguments(0), genericArguments(1))
                If (closedDictionaryType.IsAssignableFrom(type)) Then
                    Return GenerateDictionary(type, collectionSize, createdObjectReferences)
                End If
            End If

            If (type.IsPublic Or type.IsNestedPublic) Then
                Return GenerateComplexObject(type, createdObjectReferences)
            End If

            Return Nothing
        End Function

        Private Shared Function GenerateTuple(type As Type, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim genericArgs() As Type = type.GetGenericArguments()
            Dim parameterValues(genericArgs.Length - 1) As Object
            Dim failedToCreateTuple As Boolean = True

            Dim objectGenerator As New ObjectGenerator()
            For i As Integer = 0 To genericArgs.Length - 1
                parameterValues(i) = objectGenerator.GenerateObject(genericArgs(i), createdObjectReferences)
                failedToCreateTuple = failedToCreateTuple And (parameterValues(i) Is Nothing)
            Next

            If (failedToCreateTuple) Then
                Return Nothing
            End If

            Return Activator.CreateInstance(type, parameterValues)
        End Function

        Private Shared Function IsTuple(genericTypeDefinition As Type) As Boolean
            Return (genericTypeDefinition Is GetType(Tuple(Of )) Or
                genericTypeDefinition Is GetType(Tuple(Of ,)) Or
                genericTypeDefinition Is GetType(Tuple(Of ,,)) Or
                genericTypeDefinition Is GetType(Tuple(Of ,,,)) Or
                genericTypeDefinition Is GetType(Tuple(Of ,,,,)) Or
                genericTypeDefinition Is GetType(Tuple(Of ,,,,,)) Or
                genericTypeDefinition Is GetType(Tuple(Of ,,,,,,)) Or
                genericTypeDefinition Is GetType(Tuple(Of ,,,,,,,)))
        End Function

        Private Shared Function GenerateKeyValuePair(keyValuePairType As Type, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim genericArgs() As Type = keyValuePairType.GetGenericArguments()
            Dim typeK As Type = genericArgs(0)
            Dim typeV As Type = genericArgs(1)

            Dim objectGenerator As New ObjectGenerator()

            Dim keyObject As Object = objectGenerator.GenerateObject(typeK, createdObjectReferences)
            Dim valueObject As Object = objectGenerator.GenerateObject(typeV, createdObjectReferences)
            If (keyObject Is Nothing And valueObject Is Nothing) Then
                ' Failed to create key and values
                Return Nothing
            End If

            Return Activator.CreateInstance(keyValuePairType, keyObject, valueObject)
        End Function

        Private Shared Function GenerateArray(arrayType As Type, size As Integer, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim type As Type = arrayType.GetElementType()
            Dim result As Array = Array.CreateInstance(type, size)
            Dim areAllElementsNothing As Boolean = True

            Dim objectGenerator As New ObjectGenerator()

            For i As Integer = 0 To size - 1
                Dim element As Object = objectGenerator.GenerateObject(type, createdObjectReferences)
                result.SetValue(element, i)
                areAllElementsNothing = areAllElementsNothing And (element Is Nothing)
            Next

            If (areAllElementsNothing) Then
                Return Nothing
            End If

            Return result
        End Function

        Private Shared Function GenerateDictionary(dictionaryType As Type, size As Integer, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim typeK As Type = GetType(Object)
            Dim typeV As Type = GetType(Object)
            If (dictionaryType.IsGenericType) Then
                Dim genericArgs() As Type = dictionaryType.GetGenericArguments()
                typeK = genericArgs(0)
                typeV = genericArgs(1)
            End If

            Dim result As Object = Activator.CreateInstance(dictionaryType)
            Dim addMethod As MethodInfo = If(dictionaryType.GetMethod("Add"), dictionaryType.GetMethod("TryAdd"))
            Dim containsMethod As MethodInfo = If(dictionaryType.GetMethod("Contains"), dictionaryType.GetMethod("ContainsKey"))

            Dim objectGenerator As New ObjectGenerator()

            For i As Integer = 0 To size - 1
                Dim newKey As Object = objectGenerator.GenerateObject(typeK, createdObjectReferences)
                If (newKey Is Nothing) Then
                    ' Cannot generate a valid key
                    Return Nothing
                End If

                Dim containsKey As Boolean = DirectCast(containsMethod.Invoke(result, New Object() {newKey}), Boolean)

                If Not containsKey Then
                    Dim newValue As Object = objectGenerator.GenerateObject(typeV, createdObjectReferences)
                    addMethod.Invoke(result, New Object() {newKey, newValue})
                End If
            Next

            Return result
        End Function

        Private Shared Function GenerateEnum(enumType As Type) As Object
            Dim possibleValues As Array = [Enum].GetValues(enumType)
            If possibleValues.Length > 0 Then
                Return possibleValues.GetValue(0)
            End If
            Return Nothing
        End Function

        Private Shared Function GenerateQueryable(queryableType As Type, size As Integer, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim isGeneric As Boolean = queryableType.IsGenericType
            Dim list As Object = Nothing
            If (isGeneric) Then
                Dim listType As Type = GetType(List(Of )).MakeGenericType(queryableType.GetGenericArguments())
                list = GenerateCollection(listType, size, createdObjectReferences)
            Else
                list = GenerateArray(GetType(Object()), size, createdObjectReferences)
            End If

            If (list Is Nothing) Then
                Return Nothing
            End If

            If (isGeneric) Then
                Dim argumentType As Type = GetType(IEnumerable(Of )).MakeGenericType(queryableType.GetGenericArguments())
                Dim asQueryableMethod As MethodInfo = GetType(Queryable).GetMethod("AsQueryable", New Type() {argumentType})
                Return asQueryableMethod.Invoke(Nothing, New Object() {list})
            End If

            Return Queryable.AsQueryable(DirectCast(list, IEnumerable))
        End Function

        Private Shared Function GenerateCollection(collectionType As Type, size As Integer, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim type As Type = If(collectionType.IsGenericType, collectionType.GetGenericArguments()(0), GetType(Object))

            Dim result As Object = Activator.CreateInstance(collectionType)
            Dim addMethod As MethodInfo = collectionType.GetMethod("Add")
            Dim areAllElementsNothing As Boolean = True
            Dim objectGenerator As New ObjectGenerator()

            For i As Integer = 0 To size - 1
                Dim element As Object = objectGenerator.GenerateObject(type, createdObjectReferences)
                addMethod.Invoke(result, New Object() {element})
                areAllElementsNothing = areAllElementsNothing And (element Is Nothing)
            Next

            If (areAllElementsNothing) Then
                Return Nothing
            End If

            Return result
        End Function

        Private Shared Function GenerateNullable(nullableType As Type, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim type As Type = nullableType.GetGenericArguments()(0)
            Dim objectGenerator As New ObjectGenerator()
            Return objectGenerator.GenerateObject(type, createdObjectReferences)
        End Function

        Private Shared Function GenerateComplexObject(type As Type, createdObjectReferences As Dictionary(Of Type, Object)) As Object
            Dim result As Object = Nothing

            If (createdObjectReferences.TryGetValue(type, result)) Then
                ' The object has been created already, just return it. This will handle the circular reference case.
                Return result
            End If

            If (type.IsValueType) Then
                result = Activator.CreateInstance(type)
            Else
                Dim defaultCtor As ConstructorInfo = type.GetConstructor(type.EmptyTypes)
                If (defaultCtor Is Nothing) Then
                    ' Cannot instantiate the type because it doesn't have a default constructor
                    Return Nothing
                End If

                result = defaultCtor.Invoke(New Object() {})
            End If

            createdObjectReferences.Add(type, result)
            SetPublicProperties(type, result, createdObjectReferences)
            SetPublicFields(type, result, createdObjectReferences)
            Return result
        End Function

        Private Shared Sub SetPublicProperties(type As Type, obj As Object, createdObjectReferences As Dictionary(Of Type, Object))
            Dim properties() As PropertyInfo = type.GetProperties(BindingFlags.Public Or BindingFlags.Instance)
            Dim objectGenerator As New ObjectGenerator()
            For Each prop As PropertyInfo In properties
                If (prop.CanWrite) Then
                    Dim propertyValue As Object = objectGenerator.GenerateObject(prop.PropertyType, createdObjectReferences)
                    prop.SetValue(obj, propertyValue, Nothing)
                End If
            Next
        End Sub

        Private Shared Sub SetPublicFields(type As Type, obj As Object, createdObjectReferences As Dictionary(Of Type, Object))
            Dim fields() As FieldInfo = type.GetFields(BindingFlags.Public Or BindingFlags.Instance)
            Dim objectGenerator As New ObjectGenerator()
            For Each field As FieldInfo In fields
                Dim fieldValue As Object = objectGenerator.GenerateObject(field.FieldType, createdObjectReferences)
                field.SetValue(obj, fieldValue)
            Next
        End Sub

        Private Class SimpleTypeObjectGenerator
            Private _index As Long = 0

            Private Shared ReadOnly DefaultGenerators As Dictionary(Of Type, Func(Of Long, Object)) = InitializeGenerators()

            <SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity", Justification:="These are simple type factories and cannot be split up.")>
            Private Shared Function InitializeGenerators() As Dictionary(Of Type, Func(Of Long, Object))
                Return New Dictionary(Of Type, Func(Of Long, Object)) From
                {
                    {GetType(Boolean), Function(index As Long) True},
                    {GetType(Byte), Function(index As Long) CByte(64)},
                    {GetType(Char), Function(index As Long) ChrW(65)},
                    {GetType(DateTime), Function(index As Long) DateTime.Now},
                    {GetType(DateTimeOffset), Function(index As Long) New DateTimeOffset(DateTime.Now)},
                    {GetType(DBNull), Function(index As Long) DBNull.Value},
                    {GetType(Decimal), Function(index As Long) CDec(index)},
                    {GetType(Double), Function(index As Long) CDbl(index) + 0.1},
                    {GetType(Guid), Function(index As Long) Guid.NewGuid()},
                    {GetType(Int16), Function(index As Long) CType(index Mod Int16.MaxValue, Int16)},
                    {GetType(Int32), Function(index As Long) CType(index Mod Int32.MaxValue, Int32)},
                    {GetType(Int64), Function(index As Long) CType(index, Int64)},
                    {GetType(Object), Function(index As Long) New Object},
                    {GetType(SByte), Function(index As Long) CSByte(64)},
                    {GetType(Single), Function(index As Long) CSng(index + 0.1)},
                    {GetType(String), Function(index As Long) String.Format(CultureInfo.CurrentCulture, "sample string {0}", index)},
                    {GetType(TimeSpan), Function(index As Long) TimeSpan.FromTicks(1234567)},
                    {GetType(UInt16), Function(index As Long) CType(index Mod UInt16.MaxValue, UInt16)},
                    {GetType(UInt32), Function(index As Long) CType(index Mod UInt32.MaxValue, UInt32)},
                    {GetType(UInt64), Function(index As Long) CType(index, UInt64)},
                    {GetType(Uri), Function(index As Long) New Uri(String.Format(CultureInfo.CurrentCulture, "http://webapihelppage{0}.com", index))}
                }
            End Function

            Public Shared Function CanGenerateObject(type As Type) As Boolean
                Return DefaultGenerators.ContainsKey(type)
            End Function

            Public Function GenerateObject(type As Type) As Object
                _index += 1
                Return DefaultGenerators(type)(_index)
            End Function
        End Class
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/SampleGeneration/SampleDirection.vb
================================================
Namespace Areas.HelpPage
    ''' <summary>
    ''' Indicates whether the sample is used for request or response
    ''' </summary>
    Public Enum SampleDirection
        Request = 0
        Response
    End Enum
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/SampleGeneration/TextSample.vb
================================================
Imports System

Namespace Areas.HelpPage
    ''' <summary>
    ''' This represents a preformatted text sample on the help page. There's a display template named TextSample associated with this class.
    ''' </summary>
    Public Class TextSample
        Private _text As String

        Public Sub New(text As String)
            If (text Is Nothing) Then
                Throw New ArgumentNullException("text")
            End If
            Me.Text = text
        End Sub

        Public Property Text As String
            Get
                Return _text
            End Get
            Private Set(value As String)
                _text = value
            End Set
        End Property

        Public Overrides Function Equals(obj As Object) As Boolean
            Equals = False
            Dim other As TextSample = TryCast(obj, TextSample)
            If Not (other Is Nothing) Then
                Equals = (Text = other.Text)
            End If
        End Function

        Public Overrides Function GetHashCode() As Integer
            Return Text.GetHashCode()
        End Function

        Public Overrides Function ToString() As String
            Return Text
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/Api.vbhtml
================================================
@Imports System.Web.Http
@Imports System.Web.Http.Description
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
@ModelType HelpPageApiModel

@Code
    Dim description As ApiDescription = Model.ApiDescription
    ViewData("Title") = description.HttpMethod.Method + " " + description.RelativePath
End Code

<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
<div id="body" class="help-page">
    <section class="featured">
        <div class="content-wrapper">
            <p>
                @Html.ActionLink("Help Page Home", "Index")
            </p>
        </div>
    </section>
    <section class="content-wrapper main-content clear-fix">
        @Html.DisplayForModel()
    </section>
</div>


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/ApiGroup.vbhtml
================================================
@Imports System.Web.Http
@Imports System.Web.Http.Controllers
@Imports System.Web.Http.Description
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@ModelType IGrouping(Of HttpControllerDescriptor, ApiDescription)

@Code
    Dim controllerDocumentation As String = If(Not ViewData("DocumentationProvider") Is Nothing,
        ViewData("DocumentationProvider").GetDocumentation(Model.Key),
        Nothing)
End Code

<h2 id="@Model.Key.ControllerName">@Model.Key.ControllerName</h2>
@If Not controllerDocumentation Is Nothing Then
    @<p>@controllerDocumentation</p>
End If
<table class="help-page-table">
    <thead>
        <tr><th>API</th><th>Description</th></tr>
    </thead>
    <tbody>
    @For Each api As ApiDescription In Model
        @<tr>
            <td class="api-name"><a href="@Url.Action("Api", "Help", routeValues:=New With {.apiId = api.GetFriendlyId()})">@api.HttpMethod.Method @api.RelativePath</a></td>
            <td class="api-documentation">
            @If Not api.Documentation Is Nothing Then
                @<p>@api.Documentation</p>
            Else
                @<p>No documentation available.</p>
            End If
            </td>
        </tr>
    Next
    </tbody>
</table>

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/CollectionModelDescription.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType CollectionModelDescription
@If TypeOf Model.ElementDescription Is ComplexTypeModelDescription Then
    @Html.DisplayFor(Function(m) m.ElementDescription)
End If

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/ComplexTypeModelDescription.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType ComplexTypeModelDescription
@Html.DisplayFor(Function(m) Model.Properties, "Parameters")


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/DictionaryModelDescription.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType DictionaryModelDescription
Dictionary of @Html.DisplayFor(Function(m) Model.KeyModelDescription.ModelType, "ModelDescriptionLink", New With { .modelDescription = Model.KeyModelDescription }) [key]
and @Html.DisplayFor(Function(m) Model.ValueModelDescription.ModelType, "ModelDescriptionLink", New With { .modelDescription = Model.ValueModelDescription }) [value]

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/EnumTypeModelDescription.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType EnumTypeModelDescription

<p>Possible enumeration values:</p>

<table class="help-page-table">
    <thead>
        <tr><th>Name</th><th>Value</th><th>Description</th></tr>
    </thead>
    <tbody>
        @For Each value As EnumValueDescription In Model.Values        
            @<tr>
                <td class="enum-name"><b>@value.Name</b></td>
                <td class="enum-value">
                    <p>@value.Value</p>
                </td>
                <td class="enum-description">
                    <p>@value.Documentation</p>
                </td>
            </tr>
        Next
    </tbody>
</table>

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/HelpPageApiModel.vbhtml
================================================
@Imports System.Web.Http
@Imports System.Web.Http.Description
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType HelpPageApiModel

@Code
    Dim description As ApiDescription = Model.ApiDescription
End Code

<h1>@description.HttpMethod.Method @description.RelativePath</h1>
<div>
    <p>@description.Documentation</p>

    <h2>Request Information</h2>

    <h3>URI Parameters</h3>
    @Html.DisplayFor(Function(m) m.UriParameters, "Parameters")

    <h3>Body Parameters</h3>

    <p>@Model.RequestDocumentation</p>

    @If Model.RequestModelDescription IsNot Nothing Then
        @Html.DisplayFor(Function(m) m.RequestModelDescription.ModelType, "ModelDescriptionLink", New With {.modelDescription = Model.RequestModelDescription})
        If Model.RequestBodyParameters IsNot Nothing Then
            @Html.DisplayFor(Function(m) m.RequestBodyParameters, "Parameters")
        End If 
    Else
        @<p>None.</p>
    End If

    @If Model.SampleRequests.Count > 0 Then
        @<h3>Request Formats</h3>
        @Html.DisplayFor(Function(m) m.SampleRequests, "Samples")
    End If 

    <h2>Response Information</h2>

    <h3>Resource Description</h3>

    <p>@description.ResponseDescription.Documentation</p>

    @If Model.ResourceDescription IsNot Nothing Then
        @Html.DisplayFor(Function(m) m.ResourceDescription.ModelType, "ModelDescriptionLink", New With {.modelDescription = Model.ResourceDescription})
        If Model.ResourceProperties IsNot Nothing Then
            @Html.DisplayFor(Function(m) m.ResourceProperties, "Parameters")
        End If
    Else
        @<p>None.</p>
    End If


    @If Model.SampleResponses.Count > 0 Then
        @<h3>Response Formats</h3>
        @Html.DisplayFor(Function(m) m.SampleResponses, "Samples")
    End If
</div>


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/ImageSample.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@ModelType ImageSample

<img src="@Model.Src" />

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/InvalidSample.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@ModelType InvalidSample

@If HttpContext.Current.IsDebuggingEnabled Then
    @<div class="warning-message-container">
        <p>@Model.ErrorMessage</p>
    </div>
Else
    @<p>Sample not available.</p>
End If

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/KeyValuePairModelDescription.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType KeyValuePairModelDescription
Pair of @Html.DisplayFor(Function(m) Model.KeyModelDescription.ModelType, "ModelDescriptionLink", New With { .modelDescription = Model.KeyModelDescription }) [key]
and @Html.DisplayFor(Function(m) Model.ValueModelDescription.ModelType, "ModelDescriptionLink", New With { .modelDescription = Model.ValueModelDescription }) [value]

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/ModelDescriptionLink.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType Type
@Code
    Dim modelDescription As ModelDescription = ViewBag.modelDescription
    If TypeOf modelDescription Is ComplexTypeModelDescription Or TypeOf modelDescription Is EnumTypeModelDescription Then
        If Model Is GetType(Object) Then
            @:Object
        Else
            @Html.ActionLink(modelDescription.Name, "ResourceModel", "Help", New With {.modelName = modelDescription.Name}, Nothing)
        End If
    ElseIf TypeOf modelDescription Is CollectionModelDescription Then
        Dim collectionDescription As CollectionModelDescription = DirectCast(modelDescription, CollectionModelDescription)
        Dim elementDescription As ModelDescription = collectionDescription.ElementDescription
        @:Collection of @Html.DisplayFor(Function(m) elementDescription.ModelType, "ModelDescriptionLink", New With {.modelDescription = elementDescription})
    Else
        @Html.DisplayFor(Function(m) modelDescription)
    End If
End Code


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/Parameters.vbhtml
================================================
@Imports System.Collections.ObjectModel
@Imports System.Web.Http.Description
@Imports System.Threading
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType IList(Of ParameterDescription)

@If Model.Count > 0 Then
    @<table class="help-page-table">
        <thead>
            <tr><th>Name</th><th>Description</th><th>Type</th><th>Additional information</th></tr>
        </thead>
        <tbody>
            @For Each parameter As ParameterDescription In Model
                Dim modelDescription As ModelDescription = parameter.TypeDescription
                @<tr>
                    <td class="parameter-name">@parameter.Name</td>
                    <td class="parameter-documentation">
                        <p>@parameter.Documentation</p>
                    </td>
                    <td class="parameter-type">
                        @Html.DisplayFor(Function(m) modelDescription.ModelType, "ModelDescriptionLink", New With {.modelDescription = modelDescription})
                    </td>
                    <td class="parameter-annotations">
                        @If parameter.Annotations.Count > 0 Then
                            @For Each annotation As ParameterAnnotation In parameter.Annotations
                                @<p>@annotation.Documentation</p>
                            Next
                        else
                            @<p>None.</p>
                        End If 
                    </td>
                </tr>
            Next
        </tbody>
    </table>
Else
    @<p>None.</p>
End If



================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/Samples.vbhtml
================================================
@Imports System.Net.Http.Headers
@ModelType Dictionary(Of MediaTypeHeaderValue, Object)

@Code
    'Group the samples into a single tab if they are the same.
    Dim samples As Dictionary(Of String, Object) = Model.GroupBy(Function(pair) pair.Value).ToDictionary(
        Function(pair) String.Join(", ", pair.Select(Function(m) m.Key.ToString()).ToArray()),
        Function(pair) pair.Key)
    Dim mediaTypes As Dictionary(Of String, Object).KeyCollection = samples.Keys
End Code
<div>
    @For Each mediaType As String In mediaTypes
        @<h4 class="sample-header">@mediaType</h4>
        @<div class="sample-content">
            <span><b>Sample:</b></span>
            @Code
            Dim sample As Object = samples(mediaType)
            If sample Is Nothing Then
                @<p>Sample not available.</p>
            Else
                @Html.DisplayFor(Function(s) sample)
            End If
            End code
        </div>
    Next
</div>

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/SimpleTypeModelDescription.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType SimpleTypeModelDescription
@Model.Documentation

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/DisplayTemplates/TextSample.vbhtml
================================================
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@ModelType TextSample

<pre class="wrapped">
@Model.Text
</pre>

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/Index.vbhtml
================================================
@Imports System.Web.Http
@Imports System.Web.Http.Controllers
@Imports System.Web.Http.Description
@Imports System.Collections.ObjectModel
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage
@ModelType Collection(Of ApiDescription)

@Code
    ViewData("Title") = "ASP.NET Web API Help Page"
    
    ' Group APIs by controller
    Dim apiGroups As ILookup(Of HttpControllerDescriptor, ApiDescription) = Model.ToLookup(Function(api) api.ActionDescriptor.ControllerDescriptor)
End Code

<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
<header class="help-page">
    <div class="content-wrapper">
        <div class="float-left">
            <h1>@ViewData("Title")</h1>
        </div>
    </div>
</header>
<div id="body" class="help-page">
    <section class="featured">
        <div class="content-wrapper">
            <h2>Introduction</h2>
            <p>
                Provide a general description of your APIs here.
            </p>
        </div>
    </section>
    <section class="content-wrapper main-content clear-fix">
        @For Each group As IGrouping(Of HttpControllerDescriptor, ApiDescription) In apiGroups
            @Html.DisplayFor(Function(m) group, "ApiGroup")
        Next
    </section>
</div>


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Help/ResourceModel.vbhtml
================================================
@Imports System.Web.Http
@Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions
@ModelType ModelDescription

<link type="text/css" href="~/Areas/HelpPage/HelpPage.css" rel="stylesheet" />
<div id="body" class="help-page">
    <section class="featured">
        <div class="content-wrapper">
            <p>
                @Html.ActionLink("Help Page Home", "Index")
            </p>
        </div>
    </section>
    <h1>@Model.Name</h1>
    <p>@Model.Documentation</p>
    <section class="content-wrapper main-content clear-fix">
        @Html.DisplayFor(Function(m) Model)
    </section>
</div>


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Shared/_Layout.vbhtml
================================================
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width" />
    <title>@ViewData("Title")</title>
    @RenderSection("scripts", required:=False)
</head>
<body>
    @RenderBody()
</body>
</html>

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/Web.config
================================================
<?xml version="1.0"?>

<configuration>
  <configSections>
    <sectionGroup name="system.web.webPages.razor" type="System.Web.WebPages.Razor.Configuration.RazorWebSectionGroup, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
      <section name="host" type="System.Web.WebPages.Razor.Configuration.HostSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
      <section name="pages" type="System.Web.WebPages.Razor.Configuration.RazorPagesSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
    </sectionGroup>
  </configSections>

  <system.web.webPages.razor>
    <host factoryType="System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=5.3.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
    <pages pageBaseType="System.Web.Mvc.WebViewPage">
      <namespaces>
        <add namespace="System.Web.Mvc" />
        <add namespace="System.Web.Mvc.Ajax" />
        <add namespace="System.Web.Mvc.Html" />
        <add namespace="System.Web.Routing" />
      </namespaces>
    </pages>
  </system.web.webPages.razor>

  <appSettings>
    <add key="webpages:Enabled" value="false" />
  </appSettings>

  <system.web>
    <compilation debug="true">
      <assemblies>
        <add assembly="System.Net.Http, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
      </assemblies>
    </compilation>
  </system.web>

  <system.webServer>
    <handlers>
      <remove name="BlockViewHandler"/>
      <add name="BlockViewHandler" path="*" verb="*" preCondition="integratedMode" type="System.Web.HttpNotFoundHandler" />
    </handlers>
  </system.webServer>
</configuration>


================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/Views/_ViewStart.vbhtml
================================================
@Code
    'Change the Layout path below to blend the look and feel of the help page with your existing web pages.
    Layout = "~/Areas/HelpPage/Views/Shared/_Layout.vbhtml"
End Code

================================================
FILE: src/WebApiHelpPage/VB/Areas/HelpPage/XmlDocumentationProvider.vb
================================================
Imports System
Imports System.Globalization
Imports System.Linq
Imports System.Reflection
Imports System.Web.Http.Controllers
Imports System.Web.Http.Description
Imports System.Xml.XPath
Imports ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions

Namespace Areas.HelpPage
    ''' <summary>
    ''' A custom <see cref="IDocumentationProvider"/> that reads the API documentation from an XML documentation file.
    ''' </summary>
    Public Class XmlDocumentationProvider
        Implements IDocumentationProvider
        Implements IModelDocumentationProvider

        Private _documentNavigator As XPathNavigator
        Private Const TypeExpression As String = "/doc/members/member[@name='T:{0}']"
        Private Const MethodExpression As String = "/doc/members/member[@name='M:{0}']"
        Private Const PropertyExpression As String = "/doc/members/member[@name='P:{0}']"
        Private Const FieldExpression As String = "/doc/members/member[@name='F:{0}']"
        Private Const ParameterExpression As String = "param[@name='{0}']"

        ''' <summary>
        ''' Initializes a new instance of the <see cref="XmlDocumentationProvider"/> class.
        ''' </summary>
        ''' <param name="documentPath">The physical path to XML document.</param>
        Public Sub New(documentPath As String)
            If (documentPath Is Nothing) Then
                Throw New ArgumentNullException("documentPath")
            End If
            Dim xpath As New XPathDocument(documentPath)
            _documentNavigator = xpath.CreateNavigator()
        End Sub

        Public Function GetDocumentation(controllerDescriptor As HttpControllerDescriptor) As String Implements IDocumentationProvider.GetDocumentation
            Dim typeNode As XPathNavigator = GetTypeNode(controllerDescriptor.ControllerType)
            Return GetTagValue(typeNode, "summary")
        End Function

        Public Function GetDocumentation(actionDescriptor As HttpActionDescriptor) As String Implements IDocumentationProvider.GetDocumentation
            Dim methodNode As XPathNavigator = GetMethodNode(actionDescriptor)
            Return GetTagValue(methodNode, "summary")
        End Function

        Public Function GetDocumentation(parameterDescriptor As HttpParameterDescriptor) As String Implements IDocumentationProvider.GetDocumentation
            Dim reflectedParameterDescriptor As ReflectedHttpParameterDescriptor = TryCast(parameterDescriptor, ReflectedHttpParameterDescriptor)
            If (Not reflectedParameterDescriptor Is Nothing) Then
                Dim methodNode As XPathNavigator = GetMethodNode(reflectedParameterDescriptor.ActionDescriptor)
                If (Not methodNode Is Nothing) Then
                    Dim parameterName As String = reflectedParameterDescriptor.ParameterInfo.Name
                    Dim parameterNode As XPathNavigator = methodNode.SelectSingleNode(String.Format(CultureInfo.InvariantCulture, ParameterExpression, parameterName))
                    If (Not parameterNode Is Nothing) Then
                        Return parameterNode.Value.Trim()
                    End If
                End If
            End If

            Return Nothing
        End Function

        Public Function GetResponseDocumentation(actionDescriptor As HttpActionDescriptor) As String Implements IDocumentationProvider.GetResponseDocumentation
            Dim methodNode As XPathNavigator = GetMethodNode(actionDescriptor)
            Return GetTagValue(methodNode, "returns")
        End Function

        Public Function GetDocumentation(member As MemberInfo) As String Implements IModelDocumentationProvider.GetDocumentation
            Dim memberName As String = [String].Format(CultureInfo.InvariantCulture, "{0}.{1}", GetTypeName(member.DeclaringType), member.Name)
            Dim expression As String = If(member.MemberType = MemberTypes.Field, FieldExpression, PropertyExpression)
            Dim selectExpression As String = [String].Format(CultureInfo.InvariantCulture, expression, memberName)
            Dim propertyNode As XPathNavigator = _documentNavigator.SelectSingleNode(selectExpression)
            Return GetTagValue(propertyNode, "summary")
        End Function

        Public Function GetDocumentation(type As Type) As String Implements IModelDocumentationProvider.GetDocumentation
            Dim typeNode As XPathNavigator = GetTypeNode(type)
            Return GetTagValue(typeNode, "summary")
        End Function

        Private Function GetMethodNode(actionDescriptor As HttpActionDescriptor) As XPathNavigator
            Dim reflectedActionDescriptor As ReflectedHttpActionDescriptor = TryCast(actionDescriptor, ReflectedHttpActionDescriptor)
            If (Not reflectedActionDescriptor Is Nothing) Then
                Dim selectExpression As String = String.Format(CultureInfo.InvariantCulture, MethodExpression, GetMemberName(reflectedActionDescriptor.MethodInfo))
                Return _documentNavigator.SelectSingleNode(selectExpression)
            End If

            Return Nothing
        End Function

        Private Shared Function GetMemberName(method As MethodInfo) As String
            Dim name As String = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", method.DeclaringType.FullName, method.Name)
            Dim parameters() As ParameterInfo = method.GetParameters()
            If (parameters.Length <> 0) Then
                Dim parameterTypeNames() As String = parameters.Select(Function(param) GetTypeName(param.ParameterType)).ToArray()
                name += String.Format(CultureInfo.InvariantCulture, "({0})", String.Join(",", parameterTypeNames))
            End If

            Return name
        End Function

        Private Shared Function GetTagValue(parentNode As XPathNavigator, tagName As String) As String
            If (Not parentNode Is Nothing) Then
                Dim node As XPathNavigator = parentNode.SelectSingleNode(tagName)
                If (Not node Is Nothing) Then
                    Return node.Value.Trim()
                End If
            End If

            Return Nothing
        End Function

        Private Function GetTypeNode(type As Type) As XPathNavigator
            Dim controllerTypeName As String = GetTypeName(type)
            Dim selectExpression As String = [String].Format(CultureInfo.InvariantCulture, TypeExpression, controllerTypeName)
            Return _documentNavigator.SelectSingleNode(selectExpression)
        End Function

        Private Shared Function GetTypeName(type As Type) As String
            Dim name As String = type.FullName
            If type.IsGenericType Then
                ' Format the generic type name to something like: Generic{System.Int32,System.String}
                Dim genericType As Type = type.GetGenericTypeDefinition()
                Dim genericArguments As Type() = type.GetGenericArguments()
                Dim genericTypeName As String = genericType.FullName

                ' Trim the generic parameter counts from the name
                genericTypeName = genericTypeName.Substring(0, genericTypeName.IndexOf("`"c))
                Dim argumentTypeNames As String() = genericArguments.[Select](Function(t) GetTypeName(t)).ToArray()
                name = [String].Format(CultureInfo.InvariantCulture, "{0}{{{1}}}", genericTypeName, [String].Join(",", argumentTypeNames))
            End If
            If type.IsNested Then
                ' Changing the nested type name from OuterType+InnerType to OuterType.InnerType to match the XML documentation syntax.
                name = name.Replace("+", ".")
            End If

            Return name
        End Function
    End Class
End Namespace

================================================
FILE: src/WebApiHelpPage/VB/GlobalSuppressions.vb
================================================
'
'
' This file is used by Code Analysis to maintain SuppressMessage 
' attributes that are applied to this project.
' Project-level suppressions either have no target or are given 
' a specific target and scoped to a namespace, type, member, etc.
'
' To add a suppression to this file, right-click the message in the 
' Code Analysis results, point to "Suppress Message", and click 
' "In Suppression File".
' You do not need to add suppressions to this file manually.

<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="NAMESPACE", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="NAMESPACE", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="NAMESPACE", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="PROJECT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="PROJECT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="PROJECT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="ROOT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="ROOT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="ROOT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId:="config", Scope:="member", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.HelpPageConfig.#Register(System.Web.Http.HttpConfiguration)", Justification:="This parameter is part of the template and could be used later.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA2210:AssembliesShouldHaveValidStrongNames", Justification:="The assembly will not be deployed because we distribute the source code.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Web.FxCop", "MW1201:DoNotCallProblematicMethodsOnTaskRule", Scope:="member", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.HelpPageSampleGenerator.#WriteSampleObjectUsingFormatter(System.Net.Http.Formatting.MediaTypeFormatter,System.Object,System.Type,System.Net.Http.Headers.MediaTypeHeaderValue)", Justification:="This is an internal FxCop rule and we ship the source file.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="ROOT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1707:IdentifiersShouldNotContainUnderscores", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="PROJECT", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 
<Assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId:="NAMESPACE", Scope:="namespace", Target:="ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions", Justification:="This namespace will be replaced with the project namespace when the help page is installed.")> 

================================================
FILE: src/WebApiHelpPage/VB/Properties/AssemblyInfo.vb
================================================
' Copyright (c) .NET Foundation. All rights reserved.
' Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

Imports System
Imports System.Reflection
Imports System.Runtime.InteropServices

<Assembly: AssemblyTitle("WebApiHelpPageVB")>
<Assembly: AssemblyDescription("")>
<Assembly: Guid("aa22bcbc-83b3-466d-a421-9c561e3625b7")>

================================================
FILE: src/WebApiHelpPage/VB/Settings.StyleCop
================================================
<StyleCopSettings Version="105">
  <Analyzers>
    <Analyzer AnalyzerId="Microsoft.Web.StyleCop.Rules">
      <Rules>
        <Rule Name="FileMustHaveHeader">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
  </Analyzers>
</StyleCopSettings>

================================================
FILE: src/WebApiHelpPage/VB/WebApiHelpPage.VB.nuspec
================================================
<?xml version="1.0" encoding="utf-8"?>
<package>
  <metadata>
    <id>Microsoft.AspNet.WebApi.HelpPage.VB</id>
    <version>5.1.0-alpha-0</version>
    <title>Microsoft ASP.NET Web API Help Page (VB)</title>
    <authors>Microsoft</authors>
    <owners>Microsoft</owners>
    <projectUrl>http://www.asp.net/web-api</projectUrl>
    <repository type="git" url="https://github.com/aspnet/AspNetWebStack"/>
    <description>The ASP.NET Web API Help Page automatically generates help page content for the web APIs on your site. Visitors to your help page can use this content to learn how to call your web APIs. Everything generated by the help page is fully customizable using ASP.NET MVC and Razor. ASP.NET Web API Help Page is a great addition to any ASP.NET Web API project.</description>
    <summary>The ASP.NET Web API Help Page automatically generates help page content for the web APIs on your site.</summary>
    <dependencies>
      <dependency id="Microsoft.AspNet.WebApi.WebHost" version="[5.1.0-rc1, 5.1.65535.65535)" />
      <dependency id="Microsoft.AspNet.Mvc" version="[5.1.0-rc1, 5.1.65535.65535)" />
      <dependency id="Microsoft.AspNet.Razor" version="[3.1.0-rc1, 3.1.65535.65535)" />
    </dependencies>
    <frameworkAssemblies>
      <frameworkAssembly assemblyName="System.Runtime.Serialization" />
      <frameworkAssembly assemblyName="System.ComponentModel.DataAnnotations"  />
    </frameworkAssemblies>
    <language>en-US</language>
    <tags>Microsoft AspNet WebApi AspNetWebApi HelpPage VB VisualBasic</tags>
  </metadata>
  <files>
    <file src="Areas\HelpPage\App_Start\HelpPageConfig.vb.pp" target="content\Areas\HelpPage\App_Start\HelpPageConfig.vb.pp" />
    <file src="Areas\HelpPage\Controllers\HelpController.vb.pp" target="content\Areas\HelpPage\Controllers\HelpController.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\CollectionModelDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\CollectionModelDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ComplexTypeModelDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\ComplexTypeModelDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\DictionaryModelDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\DictionaryModelDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\EnumTypeModelDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\EnumTypeModelDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\EnumValueDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\EnumValueDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\IModelDocumentationProvider.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\IModelDocumentationProvider.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\KeyValuePairModelDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\KeyValuePairModelDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelNameAttribute.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelNameAttribute.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelNameHelper.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelNameHelper.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelDescriptionGenerator.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelDescriptionGenerator.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ParameterDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\ParameterDescription.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ParameterAnnotation.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\ParameterAnnotation.vb.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\SimpleTypeModelDescription.vb.pp" target="content\Areas\HelpPage\ModelDescriptions\SimpleTypeModelDescription.vb.pp" />
    <file src="Areas\HelpPage\Models\HelpPageApiModel.vb.pp" target="content\Areas\HelpPage\Models\HelpPageApiModel.vb.pp" />
    <file src="Areas\HelpPage\SampleGeneration\HelpPageSampleGenerator.vb.pp" target="content\Areas\HelpPage\SampleGeneration\HelpPageSampleGenerator.vb.pp" />
    <file src="Areas\HelpPage\SampleGeneration\HelpPageSampleKey.vb.pp" target="content\Areas\HelpPage\SampleGeneration\HelpPageSampleKey.vb.pp" />
    <file src="Areas\HelpPage\SampleGeneration\ImageSample.vb.pp" target="content\Areas\HelpPage\SampleGeneration\ImageSample.vb.pp" />
    <file src="Areas\HelpPage\SampleGeneration\InvalidSample.vb.pp" target="content\Areas\HelpPage\SampleGeneration\InvalidSample.vb.pp" />
    <file src="Areas\HelpPage\SampleGeneration\ObjectGenerator.vb.pp" target="content\Areas\HelpPage\SampleGeneration\ObjectGenerator.vb.pp" />
    <file src="Areas\HelpPage\SampleGeneration\SampleDirection.vb.pp" target="content\Areas\HelpPage\SampleGeneration\SampleDirection.vb.pp" />
    <file src="Areas\HelpPage\SampleGeneration\TextSample.vb.pp" target="content\Areas\HelpPage\SampleGeneration\TextSample.vb.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ApiGroup.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ApiGroup.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\CollectionModelDescription.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\CollectionModelDescription.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ComplexTypeModelDescription.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ComplexTypeModelDescription.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\DictionaryModelDescription.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\DictionaryModelDescription.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\EnumTypeModelDescription.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\EnumTypeModelDescription.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\HelpPageApiModel.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\HelpPageApiModel.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ImageSample.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ImageSample.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\InvalidSample.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\InvalidSample.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\KeyValuePairModelDescription.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\KeyValuePairModelDescription.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ModelDescriptionLink.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ModelDescriptionLink.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\Parameters.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\Parameters.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\Samples.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\Samples.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\SimpleTypeModelDescription.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\SimpleTypeModelDescription.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\TextSample.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\TextSample.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\Api.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\Api.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\Index.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\Index.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Help\ResourceModel.vbhtml.pp" target="content\Areas\HelpPage\Views\Help\ResourceModel.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Shared\_Layout.vbhtml.pp" target="content\Areas\HelpPage\Views\Shared\_Layout.vbhtml.pp" />
    <file src="Areas\HelpPage\Views\Web.config" target="content\Areas\HelpPage\Views\Web.config" />
    <file src="Areas\HelpPage\Views\_ViewStart.vbhtml.pp" target="content\Areas\HelpPage\Views\_ViewStart.vbhtml.pp" />
    <file src="Areas\HelpPage\ApiDescriptionExtensions.vb.pp" target="content\Areas\HelpPage\ApiDescriptionExtensions.vb.pp" />
    <file src="Areas\HelpPage\HelpPage.css.pp" target="content\Areas\HelpPage\HelpPage.css.pp" />
    <file src="Areas\HelpPage\HelpPageAreaRegistration.vb.pp" target="content\Areas\HelpPage\HelpPageAreaRegistration.vb.pp" />
    <file src="Areas\HelpPage\HelpPageConfigurationExtensions.vb.pp" target="content\Areas\HelpPage\HelpPageConfigurationExtensions.vb.pp" />
    <file src="Areas\HelpPage\XmlDocumentationProvider.vb.pp" target="content\Areas\HelpPage\XmlDocumentationProvider.vb.pp" />
  </files>
</package>

================================================
FILE: src/WebApiHelpPage/VB/WebApiHelpPageVB.vbproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <Import Project="..\WebApiHelpPageMsBuildTasks.targets" />
  <PropertyGroup>
    <ProjectGuid>{22075D5A-E9A1-4E2D-ABA7-8E7CBF2A049E}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>ROOT_PROJECT_NAMESPACE</RootNamespace>
    <AssemblyName>WebApiHelpPageVB</AssemblyName>
    <DocumentationFile>$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\..\Strict.ruleset</CodeAnalysisRuleSet>
    <MyType>Windows</MyType>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <DefineConstants>
    </DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <DefineConstants>
    </DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'CodeAnalysis|AnyCPU'">
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <DefineConstants>CodeAnalysis</DefineConstants>
  </PropertyGroup>
  <PropertyGroup>
    <OptionExplicit>On</OptionExplicit>
  </PropertyGroup>
  <PropertyGroup>
    <OptionCompare>Binary</OptionCompare>
  </PropertyGroup>
  <PropertyGroup>
    <OptionStrict>Off</OptionStrict>
  </PropertyGroup>
  <PropertyGroup>
    <OptionInfer>On</OptionInfer>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Web" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.VisualBasic" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Areas\HelpPage\Controllers\HelpController.vb" />
    <Compile Include="Areas\HelpPage\App_Start\HelpPageConfig.vb" />
    <Compile Include="Areas\HelpPage\HelpPageAreaRegistration.vb" />
    <Compile Include="Areas\HelpPage\ApiDescriptionExtensions.vb" />
    <Compile Include="Areas\HelpPage\HelpPageConfigurationExtensions.vb" />
    <Compile Include="Areas\HelpPage\SampleGeneration\ObjectGenerator.vb" />
    <Compile Include="Areas\HelpPage\SampleGeneration\SampleDirection.vb" />
    <Compile Include="Areas\HelpPage\SampleGeneration\InvalidSample.vb" />
    <Compile Include="Areas\HelpPage\SampleGeneration\HelpPageSampleKey.vb" />
    <Compile Include="Areas\HelpPage\XmlDocumentationProvider.vb" />
    <Compile Include="Areas\HelpPage\Models\HelpPageApiModel.vb" />
    <Compile Include="Areas\HelpPage\SampleGeneration\TextSample.vb" />
    <Compile Include="Areas\HelpPage\SampleGeneration\HelpPageSampleGenerator.vb" />
    <Compile Include="Areas\HelpPage\SampleGeneration\ImageSample.vb" />
    <Compile Include="GlobalSuppressions.vb" />
    <Compile Include="Properties\AssemblyInfo.vb" />
  </ItemGroup>
  <ItemGroup>
    <None Include="Areas\HelpPage\Views\Help\Api.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ApiGroup.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\CollectionModelDescription.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ComplexTypeModelDescription.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\DictionaryModelDescription.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\EnumTypeModelDescription.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\HelpPageApiModel.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\InvalidSample.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ImageSample.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\KeyValuePairModelDescription.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ModelDescriptionLink.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\Parameters.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\Samples.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\SimpleTypeModelDescription.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\TextSample.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\Index.vbhtml" />
    <None Include="Areas\HelpPage\Views\Help\ResourceModel.vbhtml" />
    <None Include="Areas\HelpPage\Views\Web.config" />
    <None Include="Areas\HelpPage\Views\Shared\_Layout.vbhtml" />
    <None Include="Areas\HelpPage\Views\_ViewStart.vbhtml" />
    <None Include="packages.config">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Areas\HelpPage\HelpPage.css" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\CollectionModelDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ComplexTypeModelDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\DictionaryModelDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\EnumTypeModelDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\EnumValueDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\IModelDocumentationProvider.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\KeyValuePairModelDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelDescriptionGenerator.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelNameAttribute.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelNameHelper.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ParameterAnnotation.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ParameterDescription.vb" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\SimpleTypeModelDescription.vb" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\..\CommonAssemblyInfo.vb">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <Folder Include="My Project\" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9b7e3740-6161-4548-833c-4bbca43b970e}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.Http.WebHost\System.Web.Http.WebHost.csproj">
      <Project>{a0187bc2-8325-4bb2-8697-7f955cf4173e}</Project>
      <Name>System.Web.Http.WebHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3d3ffd8a-624d-4e9b-954b-e1c105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8f18041b-9410-4c36-a9c5-067813df5f31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22babb60-8f02-4027-affc-acf069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939b11a-fe4e-4ba1-8ad6-d97741ee314f}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76efa9c5-8d7e-4fdf-b710-e20f8b6b00d2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.VisualBasic.targets" />
  <Target Name="AfterBuild">
    <!--Build the NuGet package for help page-->
    <ItemGroup>
      <SourceFiles Include="Areas/**/*.*" />
    </ItemGroup>
    <MakeDir Directories="$(OutputPath)\NuGet" />
    <ConvertToNuGetTransformationFiles SourceFiles="@(SourceFiles)" OutputPath="$(OutputPath)VB\" OriginalNamespaceToken="ROOT_PROJECT_NAMESPACE" ReplacementNamespaceToken="$rootnamespace$" />
    <NuGetPack NuGetExe="..\..\..\.nuget\NuGet.exe" Source="$(ProjectDir)WebApiHelpPage.VB.nuspec" BasePath="$(OutputPath)VB" OutputDirectory="$(OutputPath)NuGet" />
  </Target>
</Project>

================================================
FILE: src/WebApiHelpPage/VB/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net40" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
</packages>

================================================
FILE: src/WebApiHelpPage/WebApiHelpPage.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <Import Project="WebApiHelpPageMsBuildTasks.targets" />
  <PropertyGroup>
    <ProjectGuid>{FEDFE6CA-8282-4C5B-A756-E97189690982}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>WebApiHelpPage</RootNamespace>
    <AssemblyName>WebApiHelpPage</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>False</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Web" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Areas\HelpPage\Controllers\HelpController.cs" />
    <Compile Include="Areas\HelpPage\App_Start\HelpPageConfig.cs" />
    <Compile Include="Areas\HelpPage\HelpPageAreaRegistration.cs" />
    <Compile Include="Areas\HelpPage\ApiDescriptionExtensions.cs" />
    <Compile Include="Areas\HelpPage\HelpPageConfigurationExtensions.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\CollectionModelDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ComplexTypeModelDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ParameterAnnotation.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\DictionaryModelDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\EnumTypeModelDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\EnumValueDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\IModelDocumentationProvider.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\KeyValuePairModelDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelDescriptionGenerator.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelNameAttribute.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ModelNameHelper.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\ParameterDescription.cs" />
    <Compile Include="Areas\HelpPage\ModelDescriptions\SimpleTypeModelDescription.cs" />
    <Compile Include="Areas\HelpPage\SampleGeneration\ObjectGenerator.cs" />
    <Compile Include="Areas\HelpPage\SampleGeneration\SampleDirection.cs" />
    <Compile Include="Areas\HelpPage\SampleGeneration\InvalidSample.cs" />
    <Compile Include="Areas\HelpPage\SampleGeneration\HelpPageSampleKey.cs" />
    <Compile Include="Areas\HelpPage\XmlDocumentationProvider.cs" />
    <Compile Include="Areas\HelpPage\Models\HelpPageApiModel.cs" />
    <Compile Include="Areas\HelpPage\SampleGeneration\TextSample.cs" />
    <Compile Include="Areas\HelpPage\SampleGeneration\HelpPageSampleGenerator.cs" />
    <Compile Include="Areas\HelpPage\SampleGeneration\ImageSample.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="Areas\HelpPage\Views\Help\Api.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ApiGroup.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\CollectionModelDescription.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ComplexTypeModelDescription.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\DictionaryModelDescription.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\EnumTypeModelDescription.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\HelpPageApiModel.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\InvalidSample.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ImageSample.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\KeyValuePairModelDescription.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\ModelDescriptionLink.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\Parameters.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\Samples.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\SimpleTypeModelDescription.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\DisplayTemplates\TextSample.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\Index.cshtml" />
    <None Include="Areas\HelpPage\Views\Help\ResourceModel.cshtml" />
    <None Include="Areas\HelpPage\Views\Web.config" />
    <None Include="Areas\HelpPage\Views\Shared\_Layout.cshtml" />
    <None Include="Areas\HelpPage\Views\_ViewStart.cshtml" />
    <None Include="packages.config">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="Areas\HelpPage\HelpPage.css" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9b7e3740-6161-4548-833c-4bbca43b970e}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http.WebHost\System.Web.Http.WebHost.csproj">
      <Project>{a0187bc2-8325-4bb2-8697-7f955cf4173e}</Project>
      <Name>System.Web.Http.WebHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3d3ffd8a-624d-4e9b-954b-e1c105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8f18041b-9410-4c36-a9c5-067813df5f31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22babb60-8f02-4027-affc-acf069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939b11a-fe4e-4ba1-8ad6-d97741ee314f}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76efa9c5-8d7e-4fdf-b710-e20f8b6b00d2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="AfterBuild">
    <!--Build the NuGet package for help page-->
    <ItemGroup>
      <SourceFiles Include="Areas/**/*.*" />
    </ItemGroup>
    <MakeDir Directories="$(OutputPath)\NuGet" />
    <ConvertToNuGetTransformationFiles SourceFiles="@(SourceFiles)" OutputPath="$(OutputPath)" OriginalNamespaceToken="ROOT_PROJECT_NAMESPACE" ReplacementNamespaceToken="$rootnamespace$" />
    <NuGetPack NuGetExe="..\..\.nuget\NuGet.exe" Source="$(ProjectDir)WebApiHelpPage.nuspec" BasePath="$(OutputPath)." OutputDirectory="$(OutputPath)NuGet" />
  </Target>
</Project>

================================================
FILE: src/WebApiHelpPage/WebApiHelpPage.nuspec
================================================
<?xml version="1.0" encoding="utf-8"?>
<package>
  <metadata>
    <id>Microsoft.AspNet.WebApi.HelpPage</id>
    <version>5.1.0-alpha-0</version>
    <title>Microsoft ASP.NET Web API Help Page</title>
    <authors>Microsoft</authors>
    <owners>Microsoft</owners>
    <projectUrl>http://www.asp.net/web-api</projectUrl>
    <repository type="git" url="https://github.com/aspnet/AspNetWebStack"/>
    <description>The ASP.NET Web API Help Page automatically generates help page content for the web APIs on your site. Visitors to your help page can use this content to learn how to call your web APIs. Everything generated by the help page is fully customizable using ASP.NET MVC and Razor. ASP.NET Web API Help Page is a great addition to any ASP.NET Web API project.</description>
    <summary>The ASP.NET Web API Help Page automatically generates help page content for the web APIs on your site.</summary>
    <dependencies>
      <dependency id="Microsoft.AspNet.WebApi.WebHost" version="[5.1.0-rc1, 5.1.65535.65535)" />
      <dependency id="Microsoft.AspNet.Mvc" version="[5.1.0-rc1, 5.1.65535.65535)" />
      <dependency id="Microsoft.AspNet.Razor" version="[3.1.0-rc1, 3.1.65535.65535)" />
    </dependencies>
    <frameworkAssemblies>
      <frameworkAssembly assemblyName="System.Runtime.Serialization" />
      <frameworkAssembly assemblyName="System.ComponentModel.DataAnnotations"  />
    </frameworkAssemblies>
    <language>en-US</language>
    <tags>Microsoft AspNet WebApi AspNetWebApi HelpPage</tags>
  </metadata>
  <files>
    <file src="Areas\HelpPage\App_Start\HelpPageConfig.cs.pp" target="content\Areas\HelpPage\App_Start\HelpPageConfig.cs.pp" />
    <file src="Areas\HelpPage\Controllers\HelpController.cs.pp" target="content\Areas\HelpPage\Controllers\HelpController.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\CollectionModelDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\CollectionModelDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ComplexTypeModelDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\ComplexTypeModelDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\DictionaryModelDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\DictionaryModelDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\EnumTypeModelDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\EnumTypeModelDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\EnumValueDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\EnumValueDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\IModelDocumentationProvider.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\IModelDocumentationProvider.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\KeyValuePairModelDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\KeyValuePairModelDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelNameAttribute.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelNameAttribute.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelNameHelper.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelNameHelper.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ModelDescriptionGenerator.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\ModelDescriptionGenerator.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ParameterDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\ParameterDescription.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\ParameterAnnotation.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\ParameterAnnotation.cs.pp" />
    <file src="Areas\HelpPage\ModelDescriptions\SimpleTypeModelDescription.cs.pp" target="content\Areas\HelpPage\ModelDescriptions\SimpleTypeModelDescription.cs.pp" />
    <file src="Areas\HelpPage\Models\HelpPageApiModel.cs.pp" target="content\Areas\HelpPage\Models\HelpPageApiModel.cs.pp" />
    <file src="Areas\HelpPage\SampleGeneration\HelpPageSampleGenerator.cs.pp" target="content\Areas\HelpPage\SampleGeneration\HelpPageSampleGenerator.cs.pp" />
    <file src="Areas\HelpPage\SampleGeneration\HelpPageSampleKey.cs.pp" target="content\Areas\HelpPage\SampleGeneration\HelpPageSampleKey.cs.pp" />
    <file src="Areas\HelpPage\SampleGeneration\ImageSample.cs.pp" target="content\Areas\HelpPage\SampleGeneration\ImageSample.cs.pp" />
    <file src="Areas\HelpPage\SampleGeneration\InvalidSample.cs.pp" target="content\Areas\HelpPage\SampleGeneration\InvalidSample.cs.pp" />
    <file src="Areas\HelpPage\SampleGeneration\ObjectGenerator.cs.pp" target="content\Areas\HelpPage\SampleGeneration\ObjectGenerator.cs.pp" />
    <file src="Areas\HelpPage\SampleGeneration\SampleDirection.cs.pp" target="content\Areas\HelpPage\SampleGeneration\SampleDirection.cs.pp" />
    <file src="Areas\HelpPage\SampleGeneration\TextSample.cs.pp" target="content\Areas\HelpPage\SampleGeneration\TextSample.cs.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ApiGroup.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ApiGroup.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\CollectionModelDescription.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\CollectionModelDescription.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ComplexTypeModelDescription.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ComplexTypeModelDescription.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\DictionaryModelDescription.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\DictionaryModelDescription.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\EnumTypeModelDescription.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\EnumTypeModelDescription.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\HelpPageApiModel.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\HelpPageApiModel.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ImageSample.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ImageSample.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\InvalidSample.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\InvalidSample.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\KeyValuePairModelDescription.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\KeyValuePairModelDescription.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\ModelDescriptionLink.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\ModelDescriptionLink.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\Parameters.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\Parameters.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\Samples.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\Samples.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\SimpleTypeModelDescription.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\SimpleTypeModelDescription.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\DisplayTemplates\TextSample.cshtml.pp" target="content\Areas\HelpPage\Views\Help\DisplayTemplates\TextSample.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\Api.cshtml.pp" target="content\Areas\HelpPage\Views\Help\Api.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\Index.cshtml.pp" target="content\Areas\HelpPage\Views\Help\Index.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Help\ResourceModel.cshtml.pp" target="content\Areas\HelpPage\Views\Help\ResourceModel.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Shared\_Layout.cshtml.pp" target="content\Areas\HelpPage\Views\Shared\_Layout.cshtml.pp" />
    <file src="Areas\HelpPage\Views\Web.config" target="content\Areas\HelpPage\Views\Web.config" />
    <file src="Areas\HelpPage\Views\_ViewStart.cshtml.pp" target="content\Areas\HelpPage\Views\_ViewStart.cshtml.pp" />
    <file src="Areas\HelpPage\ApiDescriptionExtensions.cs.pp" target="content\Areas\HelpPage\ApiDescriptionExtensions.cs.pp" />
    <file src="Areas\HelpPage\HelpPage.css.pp" target="content\Areas\HelpPage\HelpPage.css.pp" />
    <file src="Areas\HelpPage\HelpPageAreaRegistration.cs.pp" target="content\Areas\HelpPage\HelpPageAreaRegistration.cs.pp" />
    <file src="Areas\HelpPage\HelpPageConfigurationExtensions.cs.pp" target="content\Areas\HelpPage\HelpPageConfigurationExtensions.cs.pp" />
    <file src="Areas\HelpPage\XmlDocumentationProvider.cs.pp" target="content\Areas\HelpPage\XmlDocumentationProvider.cs.pp" />
  </files>
</package>

================================================
FILE: src/WebApiHelpPage/WebApiHelpPageMsBuildTasks.targets
================================================
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\tools\WebStack.tasks.targets"/>
  <UsingTask TaskName="NuGetPack" TaskFactory="CodeTaskFactory" AssemblyFile="$(CodeTaskFactoryAssemblyFile)">
    <ParameterGroup>
      <NuGetExe ParameterType="System.String" Required="true" />
      <Source ParameterType="System.String" Required="true" />
      <OutputDirectory ParameterType="System.String" Required="true" />
      <BasePath ParameterType="System.String" Required="true" />
    </ParameterGroup>
    <Task>
      <Reference Include="$(BuildTaskAssemblyReference)" />
      <Using Namespace="System.Net" />
      <Using Namespace="Microsoft.Build.Tasks" />
      <Code Type="Fragment" Language="cs">
        <![CDATA[
          try
          {
            NuGetExe = Path.GetFullPath(NuGetExe);

            if (!File.Exists(NuGetExe))
            {
              string tempFile = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

              try
              {
                Log.LogMessage("Downloading latest version of NuGet.exe...");
                WebClient webClient = new WebClient();
                webClient.DownloadFile("https://nuget.org/nuget.exe", tempFile);

                if (!File.Exists(NuGetExe))
                {
                  try
                  {
                    File.Move(tempFile, NuGetExe);
                  }
                  catch (IOException)
                  {
                    // Another project downloaded and moved the file before us. That's OK; just delete this duplicate
                    // temp copy and continue.
                  }
                }
              }
              finally
              {
                File.Delete(tempFile);
              }
            }
          }
          catch (Exception ex)
          {
              Log.LogErrorFromException(ex);
              return false;
          }

          Exec execTask = new Exec();
          execTask.BuildEngine = BuildEngine;
          execTask.HostObject = HostObject;

          execTask.Command = String.Format(@"""{0}"" pack ""{1}"" -OutputDirectory ""{2}"" -BasePath ""{3}""",
            NuGetExe, Path.GetFullPath(Source), Path.GetFullPath(OutputDirectory), Path.GetFullPath(BasePath));

          return execTask.Execute();
        ]]>
      </Code>
    </Task>
  </UsingTask>
  <UsingTask TaskName="ConvertToNuGetTransformationFiles" TaskFactory="CodeTaskFactory" AssemblyFile="$(CodeTaskFactoryAssemblyFile)">
    <ParameterGroup>
      <OutputPath ParameterType="System.String" Required="true" />
      <OriginalNamespaceToken ParameterType="System.String" Required="true" />
      <ReplacementNamespaceToken ParameterType="System.String" Required="true" />
      <SourceFiles ParameterType="Microsoft.Build.Framework.ITaskItem[]" Required="true" />
    </ParameterGroup>
    <Task>
      <Code Type="Fragment" Language="cs">
        <![CDATA[
          foreach (var sourceFile in SourceFiles)
          {
            string sourceFilePath = sourceFile.GetMetadata("FullPath");
            string relativeDirectory = sourceFile.GetMetadata("RelativeDir");
            string fileName = sourceFile.GetMetadata("Filename");
            string extension = sourceFile.GetMetadata("Extension");
            string destinationDirectory = Path.Combine(OutputPath, relativeDirectory);
            string destinationFilePath = Path.Combine(destinationDirectory, fileName + extension);

            DirectoryInfo dir = new DirectoryInfo(destinationDirectory);
            if (!dir.Exists)
            {
                dir.Create();
            }

            string content = File.ReadAllText(sourceFilePath);

            // Do the transformation for source code only
            if (extension.StartsWith(".cs") || extension.StartsWith(".vb"))
            {
              destinationFilePath += ".pp";
              content = content.Replace(OriginalNamespaceToken, ReplacementNamespaceToken);
            }

            File.WriteAllText(destinationFilePath, content, Encoding.UTF8); // Always write the file using UTF8 encoding with BOM.
          }
          return true;
        ]]>
      </Code>
    </Task>
  </UsingTask>
</Project>

================================================
FILE: src/WebApiHelpPage/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net45" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net45" />
</packages>

================================================
FILE: src/WebHelpers.ruleset
================================================
<?xml version="1.0" encoding="utf-8"?>
<RuleSet Name="FxCop rules for Web Helpers"  ToolsVersion="10.0">
    <Include Path="strict.ruleset" Action="Default" />
    <Rules AnalyzerId="Microsoft.Analyzers.ManagedCodeAnalysis" RuleNamespace="Microsoft.Rules.Managed">
        <Rule Id="CA1026" Action="None" />
    </Rules>
</RuleSet>

================================================
FILE: src/WebMatrix.Data/ConfigurationManagerWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Diagnostics;
using System.IO;
using System.Linq;

namespace WebMatrix.Data
{
    internal class ConfigurationManagerWrapper : IConfigurationManager
    {
        private readonly string _dataDirectory = null;
        private IDictionary<string, string> _appSettings;
        private IDictionary<string, IDbFileHandler> _handlers;

        public ConfigurationManagerWrapper(IDictionary<string, IDbFileHandler> handlers, string dataDirectory = null)
        {
            Debug.Assert(handlers != null, "handlers should not be null");
            _dataDirectory = dataDirectory ?? Database.DataDirectory;
            _handlers = handlers;
        }

        public IDictionary<string, string> AppSettings
        {
            get
            {
                if (_appSettings == null)
                {
                    _appSettings = (from string key in ConfigurationManager.AppSettings
                                    select key).ToDictionary(key => key, key => ConfigurationManager.AppSettings[key]);
                }
                return _appSettings;
            }
        }

        private static IConnectionConfiguration GetConnectionConfigurationFromConfig(string name)
        {
            ConnectionStringSettings setting = ConfigurationManager.ConnectionStrings[name];
            if (setting != null)
            {
                return new ConnectionConfiguration(setting.ProviderName, setting.ConnectionString);
            }
            return null;
        }

        public IConnectionConfiguration GetConnection(string name)
        {
            return GetConnection(name, GetConnectionConfigurationFromConfig, File.Exists);
        }

        // For unit testing
        internal IConnectionConfiguration GetConnection(string name, Func<string, IConnectionConfiguration> getConfigConnection, Func<string, bool> fileExists)
        {
            // First try config
            IConnectionConfiguration configuraitonConfig = getConfigConnection(name);
            if (configuraitonConfig != null)
            {
                return configuraitonConfig;
            }

            // Then try files under the |DataDirectory| with the supported extensions
            // REVIEW: We sort because we want to process mdf before sdf (we only have 2 entries)
            foreach (var handler in _handlers.OrderBy(h => h.Key))
            {
                string fileName = Path.Combine(_dataDirectory, name + handler.Key);
                if (fileExists(fileName))
                {
                    return handler.Value.GetConnectionConfiguration(fileName);
                }
            }

            return null;
        }
    }
}


================================================
FILE: src/WebMatrix.Data/ConnectionConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics;

namespace WebMatrix.Data
{
    internal class ConnectionConfiguration : IConnectionConfiguration
    {
        internal ConnectionConfiguration(string providerName, string connectionString)
            : this(new DbProviderFactoryWrapper(providerName), connectionString)
        {
        }

        internal ConnectionConfiguration(IDbProviderFactory providerFactory, string connectionString)
        {
            Debug.Assert(!String.IsNullOrEmpty(connectionString), "connectionString should not be null");

            ProviderFactory = providerFactory;
            ConnectionString = connectionString;
        }

        public IDbProviderFactory ProviderFactory { get; private set; }

        public string ConnectionString { get; private set; }
    }
}


================================================
FILE: src/WebMatrix.Data/ConnectionEventArgs.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Data.Common;

namespace WebMatrix.Data
{
    public class ConnectionEventArgs : EventArgs
    {
        public ConnectionEventArgs(DbConnection connection)
        {
            Connection = connection;
        }

        public DbConnection Connection { get; private set; }
    }
}


================================================
FILE: src/WebMatrix.Data/Database.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.Common;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using Microsoft.Internal.Web.Utils;
using WebMatrix.Data.Resources;

namespace WebMatrix.Data
{
    public class Database : IDisposable
    {
        internal const string SqlCeProviderName = "System.Data.SqlServerCe.4.0";
        internal const string SqlServerProviderName = "System.Data.SqlClient";

        private const string DefaultDataProviderAppSetting = "systemData:defaultProvider";
        internal static string DataDirectory = (string)AppDomain.CurrentDomain.GetData("DataDirectory") ?? Directory.GetCurrentDirectory();

        private static readonly IDictionary<string, IDbFileHandler> _databaseFileHandlers = new Dictionary<string, IDbFileHandler>(StringComparer.OrdinalIgnoreCase)
        {
            { ".sdf", new SqlCeDbFileHandler() },
            { ".mdf", new SqlServerDbFileHandler() }
        };

        private static readonly IConfigurationManager _configurationManager = new ConfigurationManagerWrapper(_databaseFileHandlers);
        private Func<DbConnection> _connectionFactory;
        private DbConnection _connection;

        internal Database(Func<DbConnection> connectionFactory)
        {
            _connectionFactory = connectionFactory;
        }

        public static event EventHandler<ConnectionEventArgs> ConnectionOpened
        {
            add { _connectionOpened += value; }
            remove { _connectionOpened -= value; }
        }

        private static event EventHandler<ConnectionEventArgs> _connectionOpened;

        public DbConnection Connection
        {
            get
            {
                if (_connection == null)
                {
                    _connection = _connectionFactory();
                }
                return _connection;
            }
        }

        public void Close()
        {
            Dispose();
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (_connection != null)
                {
                    _connection.Close();
                    _connection = null;
                }
            }
        }

        public dynamic QuerySingle(string commandText, params object[] args)
        {
            if (String.IsNullOrEmpty(commandText))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "commandText");
            }

            return QueryInternal(commandText, args).FirstOrDefault();
        }

        public IEnumerable<dynamic> Query(string commandText, params object[] parameters)
        {
            if (String.IsNullOrEmpty(commandText))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "commandText");
            }
            // Return a readonly collection
            return QueryInternal(commandText, parameters).ToList().AsReadOnly();
        }

        [SuppressMessage("Microsoft.Security", "CA2100:Review SQL queries for security vulnerabilities", Justification = "Users are responsible for ensuring the inputs to this method are SQL Injection sanitized")]
        private IEnumerable<dynamic> QueryInternal(string commandText, params object[] parameters)
        {
            EnsureConnectionOpen();

            DbCommand command = Connection.CreateCommand();
            command.CommandText = commandText;

            AddParameters(command, parameters);
            using (command)
            {
                IEnumerable<string> columnNames = null;
                using (DbDataReader reader = command.ExecuteReader())
                {
                    foreach (DbDataRecord record in reader)
                    {
                        if (columnNames == null)
                        {
                            columnNames = GetColumnNames(record);
                        }
                        yield return new DynamicRecord(columnNames, record);
                    }
                }
            }
        }

        private static IEnumerable<string> GetColumnNames(DbDataRecord record)
        {
            // Get all of the column names for this query
            for (int i = 0; i < record.FieldCount; i++)
            {
                yield return record.GetName(i);
            }
        }

        [SuppressMessage("Microsoft.Security", "CA2100:Review SQL queries for security vulnerabilities", Justification = "Users are responsible for ensuring the inputs to this method are SQL Injection sanitized")]
        public int Execute(string commandText, params object[] args)
        {
            if (String.IsNullOrEmpty(commandText))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "commandText");
            }

            EnsureConnectionOpen();

            DbCommand command = Connection.CreateCommand();
            command.CommandText = commandText;

            AddParameters(command, args);
            using (command)
            {
                return command.ExecuteNonQuery();
            }
        }

        [SuppressMessage("Microsoft.Design", "CA1024:UsePropertiesWhereAppropriate", Justification = "This makes a database request")]
        public dynamic GetLastInsertId()
        {
            // This method only support sql ce and sql server for now
            return QueryValue("SELECT @@Identity");
        }

        [SuppressMessage("Microsoft.Security", "CA2100:Review SQL queries for security vulnerabilities", Justification = "Users are responsible for ensuring the inputs to this method are SQL Injection sanitized")]
        public dynamic QueryValue(string commandText, params object[] args)
        {
            if (String.IsNullOrEmpty(commandText))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "commandText");
            }

            EnsureConnectionOpen();

            DbCommand command = Connection.CreateCommand();
            command.CommandText = commandText;

            AddParameters(command, args);
            using (command)
            {
                return command.ExecuteScalar();
            }
        }

        private void EnsureConnectionOpen()
        {
            // If the connection isn't open then open it
            if (Connection.State != ConnectionState.Open)
            {
                Connection.Open();

                // Raise the connection opened event
                OnConnectionOpened();
            }
        }

        private void OnConnectionOpened()
        {
            if (_connectionOpened != null)
            {
                _connectionOpened(this, new ConnectionEventArgs(Connection));
            }
        }

        private static void AddParameters(DbCommand command, object[] args)
        {
            if (args == null)
            {
                return;
            }

            // Create numbered parameters
            IEnumerable<DbParameter> parameters = args.Select((o, index) =>
            {
                var parameter = command.CreateParameter();
                parameter.ParameterName = index.ToString(CultureInfo.InvariantCulture);
                parameter.Value = o ?? DBNull.Value;
                return parameter;
            });

            foreach (var p in parameters)
            {
                command.Parameters.Add(p);
            }
        }

        public static Database OpenConnectionString(string connectionString)
        {
            return OpenConnectionString(connectionString, providerName: null);
        }

        public static Database OpenConnectionString(string connectionString, string providerName)
        {
            if (String.IsNullOrEmpty(connectionString))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "connectionString");
            }

            return OpenConnectionStringInternal(providerName, connectionString);
        }

        public static Database Open(string name)
        {
            if (String.IsNullOrEmpty(name))
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "name");
            }
            return OpenNamedConnection(name, _configurationManager);
        }

        internal static IConnectionConfiguration GetConnectionConfiguration(string fileName, IDictionary<string, IDbFileHandler> handlers)
        {
            string extension = Path.GetExtension(fileName);
            IDbFileHandler handler;
            if (handlers.TryGetValue(extension, out handler))
            {
                return handler.GetConnectionConfiguration(fileName);
            }

            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                              DataResources.UnableToDetermineDatabase, fileName));
        }

        private static Database OpenConnectionStringInternal(string providerName, string connectionString)
        {
            return OpenConnectionStringInternal(new DbProviderFactoryWrapper(providerName), connectionString);
        }

        private static Database OpenConnectionInternal(IConnectionConfiguration connectionConfig)
        {
            return OpenConnectionStringInternal(connectionConfig.ProviderFactory, connectionConfig.ConnectionString);
        }

        internal static Database OpenConnectionStringInternal(IDbProviderFactory providerFactory, string connectionString)
        {
            return new Database(() => providerFactory.CreateConnection(connectionString));
        }

        internal static Database OpenNamedConnection(string name, IConfigurationManager configurationManager)
        {
            // Opens a connection using the connection string setting with the specified name
            IConnectionConfiguration configuration = configurationManager.GetConnection(name);
            if (configuration != null)
            {
                // We've found one in the connection string setting in config so use it
                return OpenConnectionInternal(configuration);
            }

            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture,
                                                              DataResources.ConnectionStringNotFound, name));
        }

        internal static string GetDefaultProviderName()
        {
            string providerName;
            // Get the default provider name from config if there is any
            if (!_configurationManager.AppSettings.TryGetValue(DefaultDataProviderAppSetting, out providerName))
            {
                providerName = SqlCeProviderName;
            }

            return providerName;
        }
    }
}


================================================
FILE: src/WebMatrix.Data/DbProviderFactoryWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Data.Common;

namespace WebMatrix.Data
{
    internal class DbProviderFactoryWrapper : IDbProviderFactory
    {
        private string _providerName;
        private DbProviderFactory _providerFactory;

        public DbProviderFactoryWrapper(string providerName)
        {
            _providerName = providerName;
        }

        public DbConnection CreateConnection(string connectionString)
        {
            if (String.IsNullOrEmpty(_providerName))
            {
                // If the provider name is null or empty then use the default
                _providerName = Database.GetDefaultProviderName();
            }

            if (_providerFactory == null)
            {
                _providerFactory = DbProviderFactories.GetFactory(_providerName);
            }

            DbConnection connection = _providerFactory.CreateConnection();
            connection.ConnectionString = connectionString;
            return connection;
        }
    }
}


================================================
FILE: src/WebMatrix.Data/DynamicRecord.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Dynamic;
using System.Globalization;
using System.Linq;
using WebMatrix.Data.Resources;

namespace WebMatrix.Data
{
    public sealed class DynamicRecord : DynamicObject, ICustomTypeDescriptor
    {
        internal DynamicRecord(IEnumerable<string> columnNames, IDataRecord record)
        {
            Debug.Assert(record != null, "record should not be null");
            Debug.Assert(columnNames != null, "columnNames should not be null");

            Columns = columnNames.ToList();
            Record = record;
        }

        public IList<string> Columns { get; private set; }

        private IDataRecord Record { get; set; }

        public object this[string name]
        {
            get
            {
                VerifyColumn(name);
                return GetValue(Record[name]);
            }
        }

        public object this[int index]
        {
            get { return GetValue(Record[index]); }
        }

        public override bool TryGetMember(GetMemberBinder binder, out object result)
        {
            result = this[binder.Name];
            return true;
        }

        private static object GetValue(object value)
        {
            return DBNull.Value == value ? null : value;
        }

        public override IEnumerable<string> GetDynamicMemberNames()
        {
            return Columns;
        }

        private void VerifyColumn(string name)
        {
            // REVIEW: Perf
            if (!Columns.Contains(name, StringComparer.OrdinalIgnoreCase))
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  DataResources.InvalidColumnName, name));
            }
        }

        AttributeCollection ICustomTypeDescriptor.GetAttributes()
        {
            return AttributeCollection.Empty;
        }

        string ICustomTypeDescriptor.GetClassName()
        {
            return null;
        }

        string ICustomTypeDescriptor.GetComponentName()
        {
            return null;
        }

        TypeConverter ICustomTypeDescriptor.GetConverter()
        {
            return null;
        }

        EventDescriptor ICustomTypeDescriptor.GetDefaultEvent()
        {
            return null;
        }

        PropertyDescriptor ICustomTypeDescriptor.GetDefaultProperty()
        {
            return null;
        }

        object ICustomTypeDescriptor.GetEditor(Type editorBaseType)
        {
            return null;
        }

        EventDescriptorCollection ICustomTypeDescriptor.GetEvents(Attribute[] attributes)
        {
            return EventDescriptorCollection.Empty;
        }

        EventDescriptorCollection ICustomTypeDescriptor.GetEvents()
        {
            return EventDescriptorCollection.Empty;
        }

        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties(Attribute[] attributes)
        {
            return ((ICustomTypeDescriptor)this).GetProperties();
        }

        PropertyDescriptorCollection ICustomTypeDescriptor.GetProperties()
        {
            // Get the name and type for each column name
            var properties = from columnName in Columns
                             let columnIndex = Record.GetOrdinal(columnName)
                             let type = Record.GetFieldType(columnIndex)
                             select new DynamicPropertyDescriptor(columnName, type);

            return new PropertyDescriptorCollection(properties.ToArray(), readOnly: true);
        }

        object ICustomTypeDescriptor.GetPropertyOwner(PropertyDescriptor pd)
        {
            return this;
        }

        private class DynamicPropertyDescriptor : PropertyDescriptor
        {
            private static readonly Attribute[] _empty = new Attribute[0];
            private readonly Type _type;

            public DynamicPropertyDescriptor(string name, Type type)
                : base(name, _empty)
            {
                _type = type;
            }

            public override Type ComponentType
            {
                get { return typeof(DynamicRecord); }
            }

            public override bool IsReadOnly
            {
                get { return true; }
            }

            public override Type PropertyType
            {
                get { return _type; }
            }

            public override bool CanResetValue(object component)
            {
                return false;
            }

            public override object GetValue(object component)
            {
                DynamicRecord record = component as DynamicRecord;
                // REVIEW: Should we throw if the wrong object was passed in?
                if (record != null)
                {
                    return record[Name];
                }
                return null;
            }

            public override void ResetValue(object component)
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  DataResources.RecordIsReadOnly, Name));
            }

            public override void SetValue(object component, object value)
            {
                throw new InvalidOperationException(
                    String.Format(CultureInfo.CurrentCulture,
                                  DataResources.RecordIsReadOnly, Name));
            }

            public override bool ShouldSerializeValue(object component)
            {
                return false;
            }
        }
    }
}


================================================
FILE: src/WebMatrix.Data/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc.
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File".
// You do not need to add suppressions to this file manually.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "WebMatrix.Data", Justification = "WebMatrix.Data is a logical grouping of data-related helpers, and thus it belongs in its own namespace")]


================================================
FILE: src/WebMatrix.Data/IConfigurationManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace WebMatrix.Data
{
    internal interface IConfigurationManager
    {
        IDictionary<string, string> AppSettings { get; }
        IConnectionConfiguration GetConnection(string name);
    }
}


================================================
FILE: src/WebMatrix.Data/IConnectionConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace WebMatrix.Data
{
    internal interface IConnectionConfiguration
    {
        string ConnectionString { get; }
        IDbProviderFactory ProviderFactory { get; }
    }
}


================================================
FILE: src/WebMatrix.Data/IDbFileHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace WebMatrix.Data
{
    internal interface IDbFileHandler
    {
        IConnectionConfiguration GetConnectionConfiguration(string fileName);
    }
}


================================================
FILE: src/WebMatrix.Data/IDbProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Data.Common;

namespace WebMatrix.Data
{
    internal interface IDbProviderFactory
    {
        DbConnection CreateConnection(string connectionString);
    }
}


================================================
FILE: src/WebMatrix.Data/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("WebMatrix.Data")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("WebMatrix.Data.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("WebMatrix.WebData.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]


================================================
FILE: src/WebMatrix.Data/Resources/DataResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.1
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace WebMatrix.Data.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class DataResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal DataResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WebMatrix.Data.Resources.DataResources", typeof(DataResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Connection string &quot;{0}&quot; was not found..
        /// </summary>
        internal static string ConnectionStringNotFound {
            get {
                return ResourceManager.GetString("ConnectionStringNotFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invalid column name &quot;{0}&quot;..
        /// </summary>
        internal static string InvalidColumnName {
            get {
                return ResourceManager.GetString("InvalidColumnName", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to modify the value of column &quot;{0}&quot; because the record is read only..
        /// </summary>
        internal static string RecordIsReadOnly {
            get {
                return ResourceManager.GetString("RecordIsReadOnly", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unable to determine the provider for the database file &quot;{0}&quot;..
        /// </summary>
        internal static string UnableToDetermineDatabase {
            get {
                return ResourceManager.GetString("UnableToDetermineDatabase", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/WebMatrix.Data/Resources/DataResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="ConnectionStringNotFound" xml:space="preserve">
    <value>Connection string "{0}" was not found.</value>
  </data>
  <data name="InvalidColumnName" xml:space="preserve">
    <value>Invalid column name "{0}".</value>
  </data>
  <data name="RecordIsReadOnly" xml:space="preserve">
    <value>Unable to modify the value of column "{0}" because the record is read only.</value>
  </data>
  <data name="UnableToDetermineDatabase" xml:space="preserve">
    <value>Unable to determine the provider for the database file "{0}".</value>
  </data>
</root>

================================================
FILE: src/WebMatrix.Data/SqlCeDbFileHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics;
using System.Globalization;
using System.IO;

namespace WebMatrix.Data
{
    internal class SqlCeDbFileHandler : IDbFileHandler
    {
        private const string SqlCeConnectionStringFormat = @"Data Source={0};File Access Retry Timeout=10";

        public IConnectionConfiguration GetConnectionConfiguration(string fileName)
        {
            // Get the default provider name
            string providerName = Database.GetDefaultProviderName();
            Debug.Assert(!String.IsNullOrEmpty(providerName), "Provider name should not be null or empty");

            string connectionString = GetConnectionString(fileName);
            return new ConnectionConfiguration(providerName, connectionString);
        }

        public static string GetConnectionString(string fileName)
        {
            if (Path.IsPathRooted(fileName))
            {
                return String.Format(CultureInfo.InvariantCulture, SqlCeConnectionStringFormat, fileName);
            }

            // Use |DataDirectory| if the path isn't rooted
            string dataSource = @"|DataDirectory|\" + Path.GetFileName(fileName);
            return String.Format(CultureInfo.InvariantCulture, SqlCeConnectionStringFormat, dataSource);
        }
    }
}


================================================
FILE: src/WebMatrix.Data/SqlServerDbFileHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.IO;

namespace WebMatrix.Data
{
    internal class SqlServerDbFileHandler : IDbFileHandler
    {
        private const string SqlServerConnectionStringFormat = @"Data Source=.\SQLEXPRESS;AttachDbFilename={0};Initial Catalog={1};Integrated Security=True;User Instance=True;MultipleActiveResultSets=True";
        private const string SqlServerProviderName = "System.Data.SqlClient";

        public IConnectionConfiguration GetConnectionConfiguration(string fileName)
        {
            return new ConnectionConfiguration(SqlServerProviderName, GetConnectionString(fileName, Database.DataDirectory));
        }

        internal static string GetConnectionString(string fileName, string dataDirectory)
        {
            if (Path.IsPathRooted(fileName))
            {
                // Attach the db as the file name if it is rooted
                return String.Format(CultureInfo.InvariantCulture, SqlServerConnectionStringFormat, fileName, fileName);
            }

            // Use |DataDirectory| if the path isn't rooted
            string dataSource = @"|DataDirectory|\" + Path.GetFileName(fileName);
            // Set the full path for the initial catalog so we attach as that
            string initialCatalog = Path.Combine(dataDirectory, Path.GetFileName(fileName));
            return String.Format(CultureInfo.InvariantCulture, SqlServerConnectionStringFormat, dataSource, initialCatalog);
        }
    }
}


================================================
FILE: src/WebMatrix.Data/WebMatrix.Data.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{4D39BAAF-8A96-473E-AB79-C8A341885137}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>WebMatrix.Data</RootNamespace>
    <AssemblyName>WebMatrix.Data</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.configuration" />
    <Reference Include="System.Core" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="ConfigurationManagerWrapper.cs" />
    <Compile Include="ConnectionConfiguration.cs" />
    <Compile Include="ConnectionEventArgs.cs" />
    <Compile Include="Database.cs" />
    <Compile Include="DbProviderFactoryWrapper.cs" />
    <Compile Include="DynamicRecord.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="IConfigurationManager.cs" />
    <Compile Include="IConnectionConfiguration.cs" />
    <Compile Include="IDbFileHandler.cs" />
    <Compile Include="IDbProviderFactory.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Resources\DataResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>DataResources.resx</DependentUpon>
    </Compile>
    <Compile Include="SqlCeDbFileHandler.cs" />
    <Compile Include="SqlServerDbFileHandler.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\DataResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>DataResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/WebMatrix.WebData/ConfigUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Configuration;

namespace WebMatrix.WebData
{
    internal static class ConfigUtil
    {
        private static bool _simpleMembershipEnabled = IsSimpleMembershipEnabled();

        public static bool SimpleMembershipEnabled
        {
            get { return _simpleMembershipEnabled; }
        }

        private static bool IsSimpleMembershipEnabled()
        {
            string settingValue = ConfigurationManager.AppSettings[WebSecurity.EnableSimpleMembershipKey];
            bool enabled;
            if (!String.IsNullOrEmpty(settingValue) && Boolean.TryParse(settingValue, out enabled))
            {
                return enabled;
            }
            // Simple Membership is enabled by default, but attempts to delegate to the current provider if not initialized.
            return true;
        }

        internal static bool ShouldPreserveLoginUrl()
        {
            string settingValue = ConfigurationManager.AppSettings[FormsAuthenticationSettings.PreserveLoginUrlKey];
            bool preserveLoginUrl;
            if (!String.IsNullOrEmpty(settingValue) && Boolean.TryParse(settingValue, out preserveLoginUrl))
            {
                return preserveLoginUrl;
            }

            // For backwards compatible with WebPages 1.0, we override the loginUrl value if 
            // the PreserveLoginUrl key is not present.
            return false;
        }
    }
}


================================================
FILE: src/WebMatrix.WebData/DatabaseConnectionInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using WebMatrix.Data;

namespace WebMatrix.WebData
{
    internal class DatabaseConnectionInfo
    {
        private string _connectionStringName;
        private string _connectionString;

        private enum ConnectionType
        {
            ConnectionStringName = 0,
            ConnectionString = 1
        }

        public string ConnectionString
        {
            get { return _connectionString; }
            set
            {
                _connectionString = value;
                Type = ConnectionType.ConnectionString;
            }
        }

        public string ConnectionStringName
        {
            get { return _connectionStringName; }
            set
            {
                _connectionStringName = value;
                Type = ConnectionType.ConnectionStringName;
            }
        }

        public string ProviderName { get; set; }

        private ConnectionType Type { get; set; }

        public Database Connect()
        {
            switch (Type)
            {
                case ConnectionType.ConnectionString:
                    return Database.OpenConnectionString(ConnectionString, ProviderName);
                case ConnectionType.ConnectionStringName:
                    return Database.Open(ConnectionStringName);
                default:
                    return null;
            }
        }
    }
}


================================================
FILE: src/WebMatrix.WebData/DatabaseWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using WebMatrix.Data;

namespace WebMatrix.WebData
{
    internal class DatabaseWrapper : IDatabase
    {
        private readonly Database _database;

        public DatabaseWrapper(Database database)
        {
            _database = database;
        }

        public dynamic QuerySingle(string commandText, params object[] parameters)
        {
            return _database.QuerySingle(commandText, parameters);
        }

        public IEnumerable<dynamic> Query(string commandText, params object[] parameters)
        {
            return _database.Query(commandText, parameters);
        }

        public dynamic QueryValue(string commandText, params object[] parameters)
        {
            return _database.QueryValue(commandText, parameters);
        }

        public int Execute(string commandText, params object[] parameters)
        {
            return _database.Execute(commandText, parameters);
        }

        public void Dispose()
        {
            _database.Dispose();
        }
    }
}


================================================
FILE: src/WebMatrix.WebData/ExtendedMembershipProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Security;

namespace WebMatrix.WebData
{
    public abstract class ExtendedMembershipProvider : MembershipProvider
    {
        private const int OneDayInMinutes = 24 * 60;

        /// <summary>
        /// Deletes the OAuth and OpenID account with the specified provider name and provider user id.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        public virtual void DeleteOAuthAccount(string provider, string providerUserId)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Creates a new OAuth account with the specified data or update an existing one if it already exists.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="providerUserId">The provider userid.</param>
        /// <param name="userName">The username.</param>
        public virtual void CreateOrUpdateOAuthAccount(string provider, string providerUserId, string userName)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Gets the id of the user with the specified provider name and provider user id.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        /// <returns></returns>
        public virtual int GetUserIdFromOAuth(string provider, string providerUserId)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Gets the username of a user with the given id
        /// </summary>
        /// <param name="userId">The user id.</param>
        /// <returns></returns>
        public virtual string GetUserNameFromId(int userId)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Determines whether there exists a local account (as opposed to OAuth account) with the specified userId.
        /// </summary>
        /// <param name="userId">The user id to check for local account.</param>
        /// <returns>
        ///   <c>true</c> if there is a local account with the specified user id]; otherwise, <c>false</c>.
        /// </returns>
        public virtual bool HasLocalAccount(int userId)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Gets the OAuth token secret from the specified OAuth token.
        /// </summary>
        /// <param name="token">The token from which to retrieve secret.</param>
        /// <returns>The token secret of the specified token</returns>
        public virtual string GetOAuthTokenSecret(string token)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Stores the specified token and secret into database.
        /// </summary>
        /// <param name="requestToken">The token.</param>
        /// <param name="requestTokenSecret">The secret.</param>
        public virtual void StoreOAuthRequestToken(string requestToken, string requestTokenSecret)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Replaces the request token with access token and secret in the database.
        /// </summary>
        /// <param name="requestToken">The request token.</param>
        /// <param name="accessToken">The access token.</param>
        /// <param name="accessTokenSecret">The access token secret.</param>
        public virtual void ReplaceOAuthRequestTokenWithAccessToken(string requestToken, string accessToken, string accessTokenSecret)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Deletes the OAuth token from the backing store from the database.
        /// </summary>
        /// <param name="token">The token to be deleted.</param>
        public virtual void DeleteOAuthToken(string token)
        {
            throw new NotImplementedException();
        }

        /// <summary>
        /// Gets all OAuth accounts associated with the specified username
        /// </summary>
        /// <param name="userName">Name of the user.</param>
        /// <returns></returns>
        public abstract ICollection<OAuthAccountData> GetAccountsForUser(string userName);

        public virtual string CreateUserAndAccount(string userName, string password)
        {
            return CreateUserAndAccount(userName, password, requireConfirmation: false, values: null);
        }

        public virtual string CreateUserAndAccount(string userName, string password, bool requireConfirmation)
        {
            return CreateUserAndAccount(userName, password, requireConfirmation, values: null);
        }

        public virtual string CreateUserAndAccount(string userName, string password, IDictionary<string, object> values)
        {
            return CreateUserAndAccount(userName, password, requireConfirmation: false, values: values);
        }

        public abstract string CreateUserAndAccount(string userName, string password, bool requireConfirmation, IDictionary<string, object> values);

        public virtual string CreateAccount(string userName, string password)
        {
            return CreateAccount(userName, password, requireConfirmationToken: false);
        }

        public abstract string CreateAccount(string userName, string password, bool requireConfirmationToken);
        public abstract bool ConfirmAccount(string userName, string accountConfirmationToken);
        public abstract bool ConfirmAccount(string accountConfirmationToken);
        public abstract bool DeleteAccount(string userName);

        public virtual string GeneratePasswordResetToken(string userName)
        {
            return GeneratePasswordResetToken(userName, tokenExpirationInMinutesFromNow: OneDayInMinutes);
        }

        public abstract string GeneratePasswordResetToken(string userName, int tokenExpirationInMinutesFromNow);
        public abstract int GetUserIdFromPasswordResetToken(string token);
        public abstract bool IsConfirmed(string userName);
        public abstract bool ResetPasswordWithToken(string token, string newPassword);
        public abstract int GetPasswordFailuresSinceLastSuccess(string userName);
        public abstract DateTime GetCreateDate(string userName);
        public abstract DateTime GetPasswordChangedDate(string userName);
        public abstract DateTime GetLastPasswordFailureDate(string userName);

        internal virtual void VerifyInitialized()
        {
        }
    }
}


================================================
FILE: src/WebMatrix.WebData/FormsAuthenticationSettings.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.CodeAnalysis;

namespace WebMatrix.WebData
{
    /// <summary>
    /// Defines key names for use in a web.config &lt;appSettings&gt; section to override default settings.
    /// </summary>
    public static class FormsAuthenticationSettings
    {
        [SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Justification = "The term Login is used more frequently in ASP.Net")]
        public static readonly string LoginUrlKey = "loginUrl";

        [SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Justification = "The term Login is used more frequently in ASP.Net")]
        public static readonly string DefaultLoginUrl = "~/Account/Login";

        [SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Justification = "The term Login is used more frequently in ASP.Net")]
        public static readonly string PreserveLoginUrlKey = "PreserveLoginUrl";
    }
}


================================================
FILE: src/WebMatrix.WebData/GlobalSuppressions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// This file is used by Code Analysis to maintain SuppressMessage 
// attributes that are applied to this project.
// Project-level suppressions either have no target or are given 
// a specific target and scoped to a namespace, type, member, etc.
//
// To add a suppression to this file, right-click the message in the 
// Error List, point to "Suppress Message(s)", and click 
// "In Project Suppression File".
// You do not need to add suppressions to this file manually.

using System.Diagnostics.CodeAnalysis;

[assembly: SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "Username", Scope = "member", Target = "WebMatrix.WebData.ExtendedMembershipProvider.#GetUsernameFromId(System.Int32)", Justification = "Username is one word.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "username", Scope = "member", Target = "WebMatrix.WebData.ExtendedMembershipProvider.#GetAccountsForUser(System.String)", Justification = "Username is one word.")]
[assembly: SuppressMessage("Microsoft.Naming", "CA1702:CompoundWordsShouldBeCasedCorrectly", MessageId = "username", Scope = "member", Target = "WebMatrix.WebData.ExtendedMembershipProvider.#CreateOrUpdateOAuthAccount(System.String,System.String,System.String)", Justification = "Username is one word.")]


================================================
FILE: src/WebMatrix.WebData/IDatabase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;

namespace WebMatrix.WebData
{
    internal interface IDatabase : IDisposable
    {
        dynamic QuerySingle(string commandText, params object[] args);

        IEnumerable<dynamic> Query(string commandText, params object[] parameters);

        dynamic QueryValue(string commandText, params object[] parameters);

        int Execute(string commandText, params object[] args);
    }
}


================================================
FILE: src/WebMatrix.WebData/OAuthAccountData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using Microsoft.Internal.Web.Utils;

namespace WebMatrix.WebData
{
    /// <summary>
    /// Represents an OpenAuth and OpenID account.
    /// </summary>
    public class OAuthAccountData
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="OAuthAccountData"/> class.
        /// </summary>
        /// <param name="provider">The provider.</param>
        /// <param name="providerUserId">The provider user id.</param>
        public OAuthAccountData(string provider, string providerUserId)
        {
            if (String.IsNullOrEmpty(provider))
            {
                throw new ArgumentException(
                    String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "provider"),
                    "provider");
            }

            if (String.IsNullOrEmpty(providerUserId))
            {
                throw new ArgumentException(
                    String.Format(CultureInfo.CurrentCulture, CommonResources.Argument_Cannot_Be_Null_Or_Empty, "providerUserId"),
                    "providerUserId");
            }

            Provider = provider;
            ProviderUserId = providerUserId;
        }

        /// <summary>
        /// Gets the provider name.
        /// </summary>
        public string Provider { get; private set; }

        /// <summary>
        /// Gets the provider user id.
        /// </summary>
        public string ProviderUserId { get; private set; }
    }
}


================================================
FILE: src/WebMatrix.WebData/PreApplicationStartCode.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.ComponentModel;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.WebPages;
using System.Web.WebPages.Razor;
using WebMatrix.Data;

namespace WebMatrix.WebData
{
    [EditorBrowsable(EditorBrowsableState.Never)]
    public static class PreApplicationStartCode
    {
        // NOTE: Do not add public fields, methods, or other members to this class.
        // This class does not show up in Intellisense so members on it will not be
        // discoverable by users. Place new members on more appropriate classes that
        // relate to the public API (for example, a LoginUrl property should go on a
        // membership-related class).

        private const string LoginUrlKey = "loginUrl";

        private static bool _startWasCalled;

        public static void Start()
        {
            // Even though ASP.NET will only call each PreAppStart once, we sometimes internally call one PreAppStart from 
            // another PreAppStart to ensure that things get initialized in the right order. ASP.NET does not guarantee the 
            // order so we have to guard against multiple calls.
            // All Start calls are made on same thread, so no lock needed here.

            if (_startWasCalled)
            {
                return;
            }
            _startWasCalled = true;

            // Summary of Simple Membership startup behavior:
            //  1. If the appSetting enabledSimpleMembership is present and equal to "false", NEITHER SimpleMembership NOR AutoFormsAuth are activated
            //  2. If the appSetting is true, a non-boolean string or not present, BOTH may be activated
            //    a. SimpleMembership ONLY replaces the AspNetSqlMemberhipProvider, but it does replace it even if it isn't the default.  This
            //       means that anything accessing this provider by name will get Simple Membership, but if this provider is no longer the default
            //       then SimpleMembership does not affect the default
            //    b. SimpleMembership delegates to the previous default provider UNLESS WebSecurity.InitializeDatabaseConnection is called.

            // Initialize membership provider
            WebSecurity.PreAppStartInit();

            // Initialize Forms Authentication default configuration
            SetUpFormsAuthentication();

            // Wire up WebMatrix.Data's Database object to the ASP.NET Web Pages resource tracker
            Database.ConnectionOpened += OnConnectionOpened;

            // Auto import the WebMatrix.Data and WebMatrix.WebData namespaces to all apps that are executing.
            WebPageRazorHost.AddGlobalImport("WebMatrix.Data");
            WebPageRazorHost.AddGlobalImport("WebMatrix.WebData");
        }

        private static void OnConnectionOpened(object sender, ConnectionEventArgs e)
        {
            // Register all open connections for disposing at the end of the request
            HttpContext httpContext = HttpContext.Current;
            if (httpContext != null)
            {
                HttpContextWrapper httpContextWrapper = new HttpContextWrapper(httpContext);
                httpContextWrapper.RegisterForDispose(e.Connection);
            }
        }

        private static void SetUpFormsAuthentication()
        {
            if (ConfigUtil.SimpleMembershipEnabled)
            {
                NameValueCollection configurationData = new NameValueCollection();

                string appSettingsLoginUrl = ConfigurationManager.AppSettings[FormsAuthenticationSettings.LoginUrlKey];
                if (appSettingsLoginUrl != null)
                {
                    // Allow use of <add key="loginUrl" value="~/MyPath/LogOn" /> as a shortcut to specify
                    // a custom log in url
                    configurationData[LoginUrlKey] = appSettingsLoginUrl;
                }
                else if (!ConfigUtil.ShouldPreserveLoginUrl())
                {
                    // Otherwise, use the default login url, but only if PreserveLoginUrl != true
                    // If PreserveLoginUrl == true, we do not want to override FormsAuthentication's default
                    // behavior because trying to evaluate FormsAuthentication.LoginUrl at this point in a
                    // PreAppStart method would cause app-relative URLs to be evaluated incorrectly.
                    configurationData[LoginUrlKey] = FormsAuthenticationSettings.DefaultLoginUrl;
                }

                FormsAuthentication.EnableFormsAuthentication(configurationData);
            }
        }
    }
}


================================================
FILE: src/WebMatrix.WebData/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Runtime.CompilerServices;
using System.Web;
using WebMatrix.WebData;

// General Information about an assembly is controlled through the following 
// set of attributes. Change these attribute values to modify the information
// associated with an assembly.

[assembly: AssemblyTitle("WebMatrix.WebData")]
[assembly: AssemblyDescription("")]
[assembly: InternalsVisibleTo("WebPages.Functional.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: InternalsVisibleTo("WebMatrix.WebData.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")]
[assembly: PreApplicationStartMethod(typeof(PreApplicationStartCode), "Start")]


================================================
FILE: src/WebMatrix.WebData/Resources/WebDataResources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.488
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace WebMatrix.WebData.Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class WebDataResources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal WebDataResources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WebMatrix.WebData.Resources.WebDataResources", typeof(WebDataResources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Database operation failed..
        /// </summary>
        internal static string Security_DbFailure {
            get {
                return ResourceManager.GetString("Security_DbFailure", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No user table found that has the name &quot;{0}&quot;..
        /// </summary>
        internal static string Security_FailedToFindUserTable {
            get {
                return ResourceManager.GetString("Security_FailedToFindUserTable", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;WebSecurity.InitializeDatabaseConnection&quot; method can be called only once..
        /// </summary>
        internal static string Security_InitializeAlreadyCalled {
            get {
                return ResourceManager.GetString("Security_InitializeAlreadyCalled", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You must call the &quot;WebSecurity.InitializeDatabaseConnection&quot; method before you call any other method of the &quot;WebSecurity&quot; class. This call should be placed in an _AppStart.cshtml file in the root of your site..
        /// </summary>
        internal static string Security_InitializeMustBeCalledFirst {
            get {
                return ResourceManager.GetString("Security_InitializeMustBeCalledFirst", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No account exists for &quot;{0}&quot;..
        /// </summary>
        internal static string Security_NoAccountFound {
            get {
                return ResourceManager.GetString("Security_NoAccountFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To call this method, the &quot;Membership.Provider&quot; property must be an instance of &quot;ExtendedMembershipProvider&quot;..
        /// </summary>
        internal static string Security_NoExtendedMembershipProvider {
            get {
                return ResourceManager.GetString("Security_NoExtendedMembershipProvider", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No user found was found that has the name &quot;{0}&quot;..
        /// </summary>
        internal static string Security_NoUserFound {
            get {
                return ResourceManager.GetString("Security_NoUserFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Failed to store OAuth token to database..
        /// </summary>
        internal static string SimpleMembership_FailToStoreOAuthToken {
            get {
                return ResourceManager.GetString("SimpleMembership_FailToStoreOAuthToken", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The membership password is too long. (Maximum length is 128 characters)..
        /// </summary>
        internal static string SimpleMembership_PasswordTooLong {
            get {
                return ResourceManager.GetString("SimpleMembership_PasswordTooLong", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provider unrecognized attribute: &quot;{0}&quot;..
        /// </summary>
        internal static string SimpleMembership_ProviderUnrecognizedAttribute {
            get {
                return ResourceManager.GetString("SimpleMembership_ProviderUnrecognizedAttribute", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The role &quot;{0}&quot; cannot be deleted because there are still users in the role..
        /// </summary>
        internal static string SimpleRoleProvder_RolePopulated {
            get {
                return ResourceManager.GetString("SimpleRoleProvder_RolePopulated", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to User &quot;{0}&quot; is already in role &quot;{1}&quot;..
        /// </summary>
        internal static string SimpleRoleProvder_UserAlreadyInRole {
            get {
                return ResourceManager.GetString("SimpleRoleProvder_UserAlreadyInRole", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to User &quot;{0}&quot; is not in role &quot;{1}&quot;..
        /// </summary>
        internal static string SimpleRoleProvder_UserNotInRole {
            get {
                return ResourceManager.GetString("SimpleRoleProvder_UserNotInRole", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No role found that has the name &quot;{0}&quot;..
        /// </summary>
        internal static string SimpleRoleProvider_NoRoleFound {
            get {
                return ResourceManager.GetString("SimpleRoleProvider_NoRoleFound", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Role &quot;{0}&quot; already exists..
        /// </summary>
        internal static string SimpleRoleProvider_RoleExists {
            get {
                return ResourceManager.GetString("SimpleRoleProvider_RoleExists", resourceCulture);
            }
        }
    }
}


================================================
FILE: src/WebMatrix.WebData/Resources/WebDataResources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="Security_DbFailure" xml:space="preserve">
    <value>Database operation failed.</value>
  </data>
  <data name="Security_FailedToFindUserTable" xml:space="preserve">
    <value>No user table found that has the name "{0}".</value>
  </data>
  <data name="Security_InitializeAlreadyCalled" xml:space="preserve">
    <value>The "WebSecurity.InitializeDatabaseConnection" method can be called only once.</value>
  </data>
  <data name="Security_InitializeMustBeCalledFirst" xml:space="preserve">
    <value>You must call the "WebSecurity.InitializeDatabaseConnection" method before you call any other method of the "WebSecurity" class. This call should be placed in an _AppStart.cshtml file in the root of your site.</value>
  </data>
  <data name="Security_NoAccountFound" xml:space="preserve">
    <value>No account exists for "{0}".</value>
  </data>
  <data name="Security_NoExtendedMembershipProvider" xml:space="preserve">
    <value>To call this method, the "Membership.Provider" property must be an instance of "ExtendedMembershipProvider".</value>
  </data>
  <data name="Security_NoUserFound" xml:space="preserve">
    <value>No user found was found that has the name "{0}".</value>
  </data>
  <data name="SimpleMembership_FailToStoreOAuthToken" xml:space="preserve">
    <value>Failed to store OAuth token to database.</value>
  </data>
  <data name="SimpleMembership_PasswordTooLong" xml:space="preserve">
    <value>The membership password is too long. (Maximum length is 128 characters).</value>
  </data>
  <data name="SimpleMembership_ProviderUnrecognizedAttribute" xml:space="preserve">
    <value>Provider unrecognized attribute: "{0}".</value>
  </data>
  <data name="SimpleRoleProvder_RolePopulated" xml:space="preserve">
    <value>The role "{0}" cannot be deleted because there are still users in the role.</value>
  </data>
  <data name="SimpleRoleProvder_UserAlreadyInRole" xml:space="preserve">
    <value>User "{0}" is already in role "{1}".</value>
  </data>
  <data name="SimpleRoleProvder_UserNotInRole" xml:space="preserve">
    <value>User "{0}" is not in role "{1}".</value>
  </data>
  <data name="SimpleRoleProvider_NoRoleFound" xml:space="preserve">
    <value>No role found that has the name "{0}".</value>
  </data>
  <data name="SimpleRoleProvider_RoleExists" xml:space="preserve">
    <value>Role "{0}" already exists.</value>
  </data>
</root>

================================================
FILE: src/WebMatrix.WebData/SimpleMembershipProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Configuration.Provider;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Web;
using System.Web.Helpers;
using System.Web.Security;
using System.Web.WebPages;
using Microsoft.Internal.Web.Utils;
using WebMatrix.Data;
using WebMatrix.WebData.Resources;

namespace WebMatrix.WebData
{
    public class SimpleMembershipProvider : ExtendedMembershipProvider
    {
        private const int TokenSizeInBytes = 16;
        private readonly MembershipProvider _previousProvider;
        private SimpleMembershipProviderCasingBehavior _casingBehavior;

        public SimpleMembershipProvider()
            : this(null)
        {
        }

        public SimpleMembershipProvider(MembershipProvider previousProvider)
        {
            _previousProvider = previousProvider;
            if (_previousProvider != null)
            {
                _previousProvider.ValidatingPassword += (sender, args) =>
                {
                    if (!InitializeCalled)
                    {
                        OnValidatingPassword(args);
                    }
                };
            }
        }

        private MembershipProvider PreviousProvider
        {
            get
            {
                if (_previousProvider == null)
                {
                    throw new InvalidOperationException(WebDataResources.Security_InitializeMustBeCalledFirst);
                }
                else
                {
                    return _previousProvider;
                }
            }
        }

        // Public properties
        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool EnablePasswordRetrieval
        {
            get { return InitializeCalled ? false : PreviousProvider.EnablePasswordRetrieval; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool EnablePasswordReset
        {
            get { return InitializeCalled ? false : PreviousProvider.EnablePasswordReset; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool RequiresQuestionAndAnswer
        {
            get { return InitializeCalled ? false : PreviousProvider.RequiresQuestionAndAnswer; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool RequiresUniqueEmail
        {
            get { return InitializeCalled ? false : PreviousProvider.RequiresUniqueEmail; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override MembershipPasswordFormat PasswordFormat
        {
            get { return InitializeCalled ? MembershipPasswordFormat.Hashed : PreviousProvider.PasswordFormat; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override int MaxInvalidPasswordAttempts
        {
            get { return InitializeCalled ? Int32.MaxValue : PreviousProvider.MaxInvalidPasswordAttempts; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override int PasswordAttemptWindow
        {
            get { return InitializeCalled ? Int32.MaxValue : PreviousProvider.PasswordAttemptWindow; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override int MinRequiredPasswordLength
        {
            get { return InitializeCalled ? 0 : PreviousProvider.MinRequiredPasswordLength; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override int MinRequiredNonAlphanumericCharacters
        {
            get { return InitializeCalled ? 0 : PreviousProvider.MinRequiredNonAlphanumericCharacters; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string PasswordStrengthRegularExpression
        {
            get { return InitializeCalled ? String.Empty : PreviousProvider.PasswordStrengthRegularExpression; }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string ApplicationName
        {
            get
            {
                if (InitializeCalled)
                {
                    throw new NotSupportedException();
                }
                else
                {
                    return PreviousProvider.ApplicationName;
                }
            }
            set
            {
                if (InitializeCalled)
                {
                    throw new NotSupportedException();
                }
                else
                {
                    PreviousProvider.ApplicationName = value;
                }
            }
        }

        internal static string MembershipTableName
        {
            get { return "webpages_Membership"; }
        }

        internal static string OAuthMembershipTableName
        {
            get { return "webpages_OAuthMembership"; }
        }

        internal static string OAuthTokenTableName
        {
            get { return "webpages_OAuthToken"; }
        }

        private string SafeUserTableName
        {
            get { return "[" + UserTableName + "]"; }
        }

        private string SafeUserIdColumn
        {
            get { return "[" + UserIdColumn + "]"; }
        }

        private string SafeUserNameColumn
        {
            get { return "[" + UserNameColumn + "]"; }
        }

        // represents the User table for the app
        public string UserTableName { get; set; }

        // represents the User created UserName column, i.e. Email
        public string UserNameColumn { get; set; }

        // Represents the User created id column, i.e. ID;
        // REVIEW: we could get this from the primary key of UserTable in the future
        public string UserIdColumn { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="WebMatrix.WebData.SimpleMembershipProviderCasingBehavior"/> for this provider.
        /// </summary>
        /// <remarks>
        /// This value configures whether or not queries for user names normalize the user name to uppercase. See
        /// <see cref="WebMatrix.WebData.SimpleMembershipProviderCasingBehavior"/> for a full description.
        /// </remarks>
        public SimpleMembershipProviderCasingBehavior CasingBehavior
        {
            get
            {
                return _casingBehavior;
            }
            set
            {
                if (value < SimpleMembershipProviderCasingBehavior.NormalizeCasing || value > SimpleMembershipProviderCasingBehavior.RelyOnDatabaseCollation)
                {
                    throw new InvalidEnumArgumentException("value", (int)value, typeof(SimpleMembershipProviderCasingBehavior));
                }

                _casingBehavior = value;
            }
        }

        internal DatabaseConnectionInfo ConnectionInfo { get; set; }
        internal bool InitializeCalled { get; set; }

        internal override void VerifyInitialized()
        {
            if (!InitializeCalled)
            {
                throw new InvalidOperationException(WebDataResources.Security_InitializeMustBeCalledFirst);
            }
        }

        // Inherited from ProviderBase - The "previous provider" we get has already been initialized by the Config system,
        // so we shouldn't forward this call
        public override void Initialize(string name, NameValueCollection config)
        {
            if (config == null)
            {
                throw new ArgumentNullException("config");
            }
            if (String.IsNullOrEmpty(name))
            {
                name = "SimpleMembershipProvider";
            }
            if (String.IsNullOrEmpty(config["description"]))
            {
                config.Remove("description");
                config.Add("description", "Simple Membership Provider");
            }
            base.Initialize(name, config);

            config.Remove("connectionStringName");
            config.Remove("enablePasswordRetrieval");
            config.Remove("enablePasswordReset");
            config.Remove("requiresQuestionAndAnswer");
            config.Remove("applicationName");
            config.Remove("requiresUniqueEmail");
            config.Remove("maxInvalidPasswordAttempts");
            config.Remove("passwordAttemptWindow");
            config.Remove("passwordFormat");
            config.Remove("name");
            config.Remove("description");
            config.Remove("minRequiredPasswordLength");
            config.Remove("minRequiredNonalphanumericCharacters");
            config.Remove("passwordStrengthRegularExpression");
            config.Remove("hashAlgorithmType");

            if (config.Count > 0)
            {
                string attribUnrecognized = config.GetKey(0);
                if (!String.IsNullOrEmpty(attribUnrecognized))
                {
                    throw new ProviderException(String.Format(CultureInfo.CurrentCulture, WebDataResources.SimpleMembership_ProviderUnrecognizedAttribute, attribUnrecognized));
                }
            }
        }

        internal static bool CheckTableExists(IDatabase db, string tableName)
        {
            var query = db.QuerySingle(@"SELECT * from INFORMATION_SCHEMA.TABLES where TABLE_NAME = @0", tableName);
            return query != null;
        }

        internal void CreateTablesIfNeeded()
        {
            using (var db = ConnectToDatabase())
            {
                if (!CheckTableExists(db, UserTableName))
                {
                    db.Execute(@"CREATE TABLE " + SafeUserTableName + "(" + SafeUserIdColumn + " int NOT NULL PRIMARY KEY IDENTITY, " + SafeUserNameColumn + " nvarchar(56) NOT NULL UNIQUE)");
                }

                if (!CheckTableExists(db, OAuthMembershipTableName))
                {
                    db.Execute(@"CREATE TABLE " + OAuthMembershipTableName + " (Provider nvarchar(30) NOT NULL, ProviderUserId nvarchar(100) NOT NULL, UserId int NOT NULL, PRIMARY KEY (Provider, ProviderUserId))");
                }

                if (!CheckTableExists(db, MembershipTableName))
                {
                    db.Execute(@"CREATE TABLE " + MembershipTableName + @" (
                        UserId                                  int                 NOT NULL PRIMARY KEY,
                        CreateDate                              datetime            ,
                        ConfirmationToken                       nvarchar(128)       ,
                        IsConfirmed                             bit                 DEFAULT 0,
                        LastPasswordFailureDate                 datetime            ,
                        PasswordFailuresSinceLastSuccess         int                 NOT NULL DEFAULT 0,
                        Password                                nvarchar(128)       NOT NULL,
                        PasswordChangedDate                     datetime            ,
                        PasswordSalt                            nvarchar(128)       NOT NULL,
                        PasswordVerificationToken               nvarchar(128)       ,
                        PasswordVerificationTokenExpirationDate datetime)");
                    // TODO: Do we want to add FK constraint to user table too?
                    //                        CONSTRAINT fk_UserId FOREIGN KEY (UserId) REFERENCES "+UserTableName+"("+UserIdColumn+"))");
                }
            }
        }

        private static void CreateOAuthTokenTableIfNeeded(IDatabase db)
        {
            if (!CheckTableExists(db, OAuthTokenTableName))
            {
                db.Execute(@"CREATE TABLE " + OAuthTokenTableName + " (Token nvarchar(100) NOT NULL, Secret nvarchar(100) NOT NULL, PRIMARY KEY (Token))");
            }
        }

        // Not an override ==> Simple Membership MUST be enabled to use this method
        public int GetUserId(string userName)
        {
            VerifyInitialized();
            using (var db = ConnectToDatabase())
            {
                return GetUserId(db, userName);
            }
        }

        private int GetUserId(IDatabase db, string userName)
        {
            return GetUserId(db, SafeUserTableName, SafeUserNameColumn, SafeUserIdColumn, CasingBehavior, userName);
        }

        internal static int GetUserId(
            IDatabase db,
            string userTableName,
            string userNameColumn,
            string userIdColumn,
            SimpleMembershipProviderCasingBehavior casingBehavior,
            string userName)
        {
            dynamic result;
            if (casingBehavior == SimpleMembershipProviderCasingBehavior.NormalizeCasing)
            {
                // Casing is normalized in Sql to allow the database to normalize username according to its collation. The common issue 
                // that can occur here is the 'Turkish i problem', where the uppercase of 'i' is not 'I' in Turkish.
                result = db.QueryValue(@"SELECT " + userIdColumn + " FROM " + userTableName + " WHERE (UPPER(" + userNameColumn + ") = UPPER(@0))", userName);
            }
            else if (casingBehavior == SimpleMembershipProviderCasingBehavior.RelyOnDatabaseCollation)
            {
                // When this option is supplied we assume the database has been configured with an appropriate casing, and don't normalize 
                // the user name. This is performant but requires appropriate configuration on the database.
                result = db.QueryValue(@"SELECT " + userIdColumn + " FROM " + userTableName + " WHERE (" + userNameColumn + " = @0)", userName);
            }
            else
            {
                Debug.Fail("Unexpected enum value");
                return -1;
            }

            if (result != null)
            {
                return (int)result;
            }
            return -1;
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override int GetUserIdFromPasswordResetToken(string token)
        {
            VerifyInitialized();
            using (var db = ConnectToDatabase())
            {
                var result = db.QuerySingle(@"SELECT UserId FROM " + MembershipTableName + " WHERE (PasswordVerificationToken = @0)", token);
                if (result != null && result[0] != null)
                {
                    return (int)result[0];
                }
                return -1;
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool ChangePasswordQuestionAndAnswer(string username, string password, string newPasswordQuestion, string newPasswordAnswer)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.ChangePasswordQuestionAndAnswer(username, password, newPasswordQuestion, newPasswordAnswer);
            }
            throw new NotSupportedException();
        }

        /// <summary>
        /// Sets the confirmed flag for the username if it is correct.
        /// </summary>
        /// <returns>True if the account could be successfully confirmed. False if the username was not found or the confirmation token is invalid.</returns>
        /// <remarks>Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method</remarks>
        public override bool ConfirmAccount(string userName, string accountConfirmationToken)
        {
            VerifyInitialized();
            using (var db = ConnectToDatabase())
            {
                // We need to compare the token using a case insensitive comparison however it seems tricky to do this uniformly across databases when representing the token as a string. 
                // Therefore verify the case on the client
                var row = db.QuerySingle("SELECT m.[UserId], m.[ConfirmationToken] FROM " + MembershipTableName + " m JOIN " + SafeUserTableName + " u"
                                         + " ON m.[UserId] = u." + SafeUserIdColumn
                                         + " WHERE m.[ConfirmationToken] = @0 AND"
                                         + " u." + SafeUserNameColumn + " = @1", accountConfirmationToken, userName);
                if (row == null)
                {
                    return false;
                }
                int userId = row[0];
                string expectedToken = row[1];

                if (String.Equals(accountConfirmationToken, expectedToken, StringComparison.Ordinal))
                {
                    int affectedRows = db.Execute("UPDATE " + MembershipTableName + " SET [IsConfirmed] = 1 WHERE [UserId] = @0", userId);
                    return affectedRows > 0;
                }
                return false;
            }
        }

        /// <summary>
        /// Sets the confirmed flag for the username if it is correct.
        /// </summary>
        /// <returns>True if the account could be successfully confirmed. False if the username was not found or the confirmation token is invalid.</returns>
        /// <remarks>Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method.
        /// There is a tiny possibility where this method fails to work correctly. Two or more users could be assigned the same token but specified using different cases.
        /// A workaround for this would be to use the overload that accepts both the user name and confirmation token.
        /// </remarks>
        public override bool ConfirmAccount(string accountConfirmationToken)
        {
            VerifyInitialized();
            using (var db = ConnectToDatabase())
            {
                // We need to compare the token using a case insensitive comparison however it seems tricky to do this uniformly across databases when representing the token as a string. 
                // Therefore verify the case on the client
                var rows = db.Query("SELECT [UserId], [ConfirmationToken] FROM " + MembershipTableName + " WHERE [ConfirmationToken] = @0", accountConfirmationToken)
                    .Where(r => ((string)r[1]).Equals(accountConfirmationToken, StringComparison.Ordinal))
                    .ToList();
                Debug.Assert(rows.Count < 2, "By virtue of the fact that the ConfirmationToken is random and unique, we can never have two tokens that are identical.");
                if (!rows.Any())
                {
                    return false;
                }
                var row = rows.First();
                int userId = row[0];
                int affectedRows = db.Execute("UPDATE " + MembershipTableName + " SET [IsConfirmed] = 1 WHERE [UserId] = @0", userId);
                return affectedRows > 0;
            }
        }

        internal virtual IDatabase ConnectToDatabase()
        {
            return new DatabaseWrapper(ConnectionInfo.Connect());
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override string CreateAccount(string userName, string password, bool requireConfirmationToken)
        {
            VerifyInitialized();

            if (password.IsEmpty())
            {
                throw new MembershipCreateUserException(MembershipCreateStatus.InvalidPassword);
            }

            string hashedPassword = Crypto.HashPassword(password);
            if (hashedPassword.Length > 128)
            {
                throw new MembershipCreateUserException(MembershipCreateStatus.InvalidPassword);
            }

            if (userName.IsEmpty())
            {
                throw new MembershipCreateUserException(MembershipCreateStatus.InvalidUserName);
            }

            using (var db = ConnectToDatabase())
            {
                // Step 1: Check if the user exists in the Users table
                int uid = GetUserId(db, SafeUserTableName, SafeUserNameColumn, SafeUserIdColumn, CasingBehavior, userName);
                if (uid == -1)
                {
                    // User not found
                    throw new MembershipCreateUserException(MembershipCreateStatus.ProviderError);
                }

                // Step 2: Check if the user exists in the Membership table: Error if yes.
                var result = db.QuerySingle(@"SELECT COUNT(*) FROM [" + MembershipTableName + "] WHERE UserId = @0", uid);
                if (result[0] > 0)
                {
                    throw new MembershipCreateUserException(MembershipCreateStatus.DuplicateUserName);
                }

                // Step 3: Create user in Membership table
                string token = null;
                object dbtoken = DBNull.Value;
                if (requireConfirmationToken)
                {
                    token = GenerateToken();
                    dbtoken = token;
                }
                int defaultNumPasswordFailures = 0;

                int insert = db.Execute(@"INSERT INTO [" + MembershipTableName + "] (UserId, [Password], PasswordSalt, IsConfirmed, ConfirmationToken, CreateDate, PasswordChangedDate, PasswordFailuresSinceLastSuccess)"
                                        + " VALUES (@0, @1, @2, @3, @4, @5, @5, @6)", uid, hashedPassword, String.Empty /* salt column is unused */, !requireConfirmationToken, dbtoken, DateTime.UtcNow, defaultNumPasswordFailures);
                if (insert != 1)
                {
                    throw new MembershipCreateUserException(MembershipCreateStatus.ProviderError);
                }
                return token;
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override MembershipUser CreateUser(string username, string password, string email, string passwordQuestion, string passwordAnswer, bool isApproved, object providerUserKey, out MembershipCreateStatus status)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.CreateUser(username, password, email, passwordQuestion, passwordAnswer, isApproved, providerUserKey, out status);
            }
            throw new NotSupportedException();
        }

        private void CreateUserRow(IDatabase db, string userName, IDictionary<string, object> values)
        {
            // Make sure user doesn't exist
            int userId = GetUserId(db, userName);
            if (userId != -1)
            {
                throw new MembershipCreateUserException(MembershipCreateStatus.DuplicateUserName);
            }

            StringBuilder columnString = new StringBuilder();
            columnString.Append(SafeUserNameColumn);
            StringBuilder argsString = new StringBuilder();
            argsString.Append("@0");
            List<object> argsArray = new List<object>();
            argsArray.Add(userName);
            if (values != null)
            {
                int index = 1;
                foreach (string key in values.Keys)
                {
                    // Skip the user name column since we always generate that
                    if (String.Equals(UserNameColumn, key, StringComparison.OrdinalIgnoreCase))
                    {
                        continue;
                    }
                    columnString.Append(",").Append(key);
                    argsString.Append(",@").Append(index++);
                    object value = values[key];
                    if (value == null)
                    {
                        value = DBNull.Value;
                    }
                    argsArray.Add(value);
                }
            }

            int rows = db.Execute("INSERT INTO " + SafeUserTableName + " (" + columnString.ToString() + ") VALUES (" + argsString.ToString() + ")", argsArray.ToArray());
            if (rows != 1)
            {
                throw new MembershipCreateUserException(MembershipCreateStatus.ProviderError);
            }
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override string CreateUserAndAccount(string userName, string password, bool requireConfirmation, IDictionary<string, object> values)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                CreateUserRow(db, userName, values);
                return CreateAccount(userName, password, requireConfirmation);
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string GetPassword(string username, string answer)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetPassword(username, answer);
            }
            throw new NotSupportedException();
        }

        private static bool SetPassword(IDatabase db, int userId, string newPassword)
        {
            string hashedPassword = Crypto.HashPassword(newPassword);
            if (hashedPassword.Length > 128)
            {
                throw new ArgumentException(WebDataResources.SimpleMembership_PasswordTooLong);
            }

            // Update new password
            int result = db.Execute(@"UPDATE " + MembershipTableName + " SET Password=@0, PasswordSalt=@1, PasswordChangedDate=@2 WHERE UserId = @3", hashedPassword, String.Empty /* salt column is unused */, DateTime.UtcNow, userId);
            return result > 0;
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool ChangePassword(string username, string oldPassword, string newPassword)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.ChangePassword(username, oldPassword, newPassword);
            }

            // REVIEW: are commas special in the password?
            if (username.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "username");
            }
            if (oldPassword.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "oldPassword");
            }
            if (newPassword.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "newPassword");
            }

            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, username);
                if (userId == -1)
                {
                    return false; // User not found
                }

                // First check that the old credentials match
                if (!CheckPassword(db, userId, oldPassword))
                {
                    return false;
                }

                return SetPassword(db, userId, newPassword);
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string ResetPassword(string username, string answer)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.ResetPassword(username, answer);
            }
            throw new NotSupportedException();
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override MembershipUser GetUser(object providerUserKey, bool userIsOnline)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetUser(providerUserKey, userIsOnline);
            }
            throw new NotSupportedException();
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override MembershipUser GetUser(string username, bool userIsOnline)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetUser(username, userIsOnline);
            }

            // Due to a bug in v1, GetUser allows passing null / empty values.
            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, username);
                if (userId == -1)
                {
                    return null; // User not found
                }

                return new MembershipUser(Membership.Provider.Name, username, userId, null, null, null, true, false, DateTime.MinValue, DateTime.MinValue, DateTime.MinValue, DateTime.MinValue, DateTime.MinValue);
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string GetUserNameByEmail(string email)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetUserNameByEmail(email);
            }
            throw new NotSupportedException();
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override bool DeleteAccount(string userName)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, userName);
                if (userId == -1)
                {
                    return false; // User not found
                }

                int deleted = db.Execute(@"DELETE FROM " + MembershipTableName + " WHERE UserId = @0", userId);
                return (deleted == 1);
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool DeleteUser(string username, bool deleteAllRelatedData)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.DeleteUser(username, deleteAllRelatedData);
            }

            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, username);
                if (userId == -1)
                {
                    return false; // User not found
                }

                int deleted = db.Execute(@"DELETE FROM " + SafeUserTableName + " WHERE " + SafeUserIdColumn + " = @0", userId);
                bool returnValue = (deleted == 1);

                //if (deleteAllRelatedData) {
                // REVIEW: do we really want to delete from the user table?
                //}
                return returnValue;
            }
        }

        internal bool DeleteUserAndAccountInternal(string userName)
        {
            return (DeleteAccount(userName) && DeleteUser(userName, false));
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override MembershipUserCollection GetAllUsers(int pageIndex, int pageSize, out int totalRecords)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetAllUsers(pageIndex, pageSize, out totalRecords);
            }
            throw new NotSupportedException();
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override int GetNumberOfUsersOnline()
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetNumberOfUsersOnline();
            }
            throw new NotSupportedException();
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override MembershipUserCollection FindUsersByName(string usernameToMatch, int pageIndex, int pageSize, out int totalRecords)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.FindUsersByName(usernameToMatch, pageIndex, pageSize, out totalRecords);
            }
            throw new NotSupportedException();
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override MembershipUserCollection FindUsersByEmail(string emailToMatch, int pageIndex, int pageSize, out int totalRecords)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.FindUsersByEmail(emailToMatch, pageIndex, pageSize, out totalRecords);
            }
            throw new NotSupportedException();
        }

        private static int GetPasswordFailuresSinceLastSuccess(IDatabase db, int userId)
        {
            var failure = db.QueryValue(@"SELECT PasswordFailuresSinceLastSuccess FROM " + MembershipTableName + " WHERE (UserId = @0)", userId);
            if (failure != null)
            {
                return failure;
            }
            return -1;
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override int GetPasswordFailuresSinceLastSuccess(string userName)
        {
            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, userName);
                if (userId == -1)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoUserFound, userName));
                }

                return GetPasswordFailuresSinceLastSuccess(db, userId);
            }
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override DateTime GetCreateDate(string userName)
        {
            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, userName);
                if (userId == -1)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoUserFound, userName));
                }

                var createDate = db.QueryValue(@"SELECT CreateDate FROM " + MembershipTableName + " WHERE (UserId = @0)", userId);
                if (createDate != null)
                {
                    return createDate;
                }
                return DateTime.MinValue;
            }
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override DateTime GetPasswordChangedDate(string userName)
        {
            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, userName);
                if (userId == -1)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoUserFound, userName));
                }

                var pwdChangeDate = db.QuerySingle(@"SELECT PasswordChangedDate FROM " + MembershipTableName + " WHERE (UserId = @0)", userId);
                if (pwdChangeDate != null && pwdChangeDate[0] != null)
                {
                    return (DateTime)pwdChangeDate[0];
                }
                return DateTime.MinValue;
            }
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override DateTime GetLastPasswordFailureDate(string userName)
        {
            using (var db = ConnectToDatabase())
            {
                int userId = GetUserId(db, userName);
                if (userId == -1)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoUserFound, userName));
                }

                var failureDate = db.QuerySingle(@"SELECT LastPasswordFailureDate FROM " + MembershipTableName + " WHERE (UserId = @0)", userId);
                if (failureDate != null && failureDate[0] != null)
                {
                    return (DateTime)failureDate[0];
                }
                return DateTime.MinValue;
            }
        }

        private bool CheckPassword(IDatabase db, int userId, string password)
        {
            string hashedPassword = GetHashedPassword(db, userId);
            bool verificationSucceeded = (hashedPassword != null && Crypto.VerifyHashedPassword(hashedPassword, password));
            if (verificationSucceeded)
            {
                // Reset password failure count on successful credential check
                db.Execute(@"UPDATE " + MembershipTableName + " SET PasswordFailuresSinceLastSuccess = 0 WHERE (UserId = @0)", userId);
            }
            else
            {
                int failures = GetPasswordFailuresSinceLastSuccess(db, userId);
                if (failures != -1)
                {
                    db.Execute(@"UPDATE " + MembershipTableName + " SET PasswordFailuresSinceLastSuccess = @1, LastPasswordFailureDate = @2 WHERE (UserId = @0)", userId, failures + 1, DateTime.UtcNow);
                }
            }
            return verificationSucceeded;
        }

        private string GetHashedPassword(IDatabase db, int userId)
        {
            var pwdQuery = db.Query(@"SELECT m.[Password] " +
                                    @"FROM " + MembershipTableName + " m, " + SafeUserTableName + " u " +
                                    @"WHERE m.UserId = " + userId + " AND m.UserId = u." + SafeUserIdColumn).ToList();
            // REVIEW: Should get exactly one match, should we throw if we get > 1?
            if (pwdQuery.Count != 1)
            {
                return null;
            }
            return pwdQuery[0].Password;
        }

        // Ensures the user exists in the accounts table
        private int VerifyUserNameHasConfirmedAccount(IDatabase db, string username, bool throwException)
        {
            int userId = GetUserId(db, username);
            if (userId == -1)
            {
                if (throwException)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoUserFound, username));
                }
                else
                {
                    return -1;
                }
            }

            int result = db.QueryValue(@"SELECT COUNT(*) FROM " + MembershipTableName + " WHERE (UserId = @0 AND IsConfirmed = 1)", userId);
            if (result == 0)
            {
                if (throwException)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoAccountFound, username));
                }
                else
                {
                    return -1;
                }
            }
            return userId;
        }

        private static string GenerateToken()
        {
            using (var prng = new RNGCryptoServiceProvider())
            {
                return GenerateToken(prng);
            }
        }

        internal static string GenerateToken(RandomNumberGenerator generator)
        {
            byte[] tokenBytes = new byte[TokenSizeInBytes];
            generator.GetBytes(tokenBytes);
            return HttpServerUtility.UrlTokenEncode(tokenBytes);
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override string GeneratePasswordResetToken(string userName, int tokenExpirationInMinutesFromNow)
        {
            VerifyInitialized();
            if (userName.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "userName");
            }
            using (var db = ConnectToDatabase())
            {
                int userId = VerifyUserNameHasConfirmedAccount(db, userName, throwException: true);

                string token = db.QueryValue(@"SELECT PasswordVerificationToken FROM " + MembershipTableName + " WHERE (UserId = @0 AND PasswordVerificationTokenExpirationDate > @1)", userId, DateTime.UtcNow);
                if (token == null)
                {
                    token = GenerateToken();

                    int rows = db.Execute(@"UPDATE " + MembershipTableName + " SET PasswordVerificationToken = @0, PasswordVerificationTokenExpirationDate = @1 WHERE (UserId = @2)", token, DateTime.UtcNow.AddMinutes(tokenExpirationInMinutesFromNow), userId);
                    if (rows != 1)
                    {
                        throw new ProviderException(WebDataResources.Security_DbFailure);
                    }
                }
                else
                {
                    // TODO: should we update expiry again?
                }
                return token;
            }
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override bool IsConfirmed(string userName)
        {
            VerifyInitialized();
            if (userName.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "userName");
            }

            using (var db = ConnectToDatabase())
            {
                int userId = VerifyUserNameHasConfirmedAccount(db, userName, throwException: false);
                return (userId != -1);
            }
        }

        // Inherited from ExtendedMembershipProvider ==> Simple Membership MUST be enabled to use this method
        public override bool ResetPasswordWithToken(string token, string newPassword)
        {
            VerifyInitialized();
            if (newPassword.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "newPassword");
            }
            using (var db = ConnectToDatabase())
            {
                int? userId = db.QueryValue(@"SELECT UserId FROM " + MembershipTableName + " WHERE (PasswordVerificationToken = @0 AND PasswordVerificationTokenExpirationDate > @1)", token, DateTime.UtcNow);
                if (userId != null)
                {
                    bool success = SetPassword(db, userId.Value, newPassword);
                    if (success)
                    {
                        // Clear the Token on success
                        int rows = db.Execute(@"UPDATE " + MembershipTableName + " SET PasswordVerificationToken = NULL, PasswordVerificationTokenExpirationDate = NULL WHERE (UserId = @0)", userId);
                        if (rows != 1)
                        {
                            throw new ProviderException(WebDataResources.Security_DbFailure);
                        }
                    }
                    return success;
                }
                else
                {
                    return false;
                }
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override void UpdateUser(MembershipUser user)
        {
            if (!InitializeCalled)
            {
                PreviousProvider.UpdateUser(user);
            }
            else
            {
                throw new NotSupportedException();
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool UnlockUser(string userName)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.UnlockUser(userName);
            }
            throw new NotSupportedException();
        }

        internal void ValidateUserTable()
        {
            using (var db = ConnectToDatabase())
            {
                // GetUser will fail with an exception if the user table isn't set up properly
                try
                {
                    GetUserId(db, "z");
                }
                catch (Exception e)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, WebDataResources.Security_FailedToFindUserTable, UserTableName), e);
                }
            }
        }

        // Inherited from MembershipProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool ValidateUser(string username, string password)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.ValidateUser(username, password);
            }
            if (username.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "username");
            }
            if (password.IsEmpty())
            {
                throw new ArgumentException(CommonResources.Argument_Cannot_Be_Null_Or_Empty, "password");
            }

            using (var db = ConnectToDatabase())
            {
                int userId = VerifyUserNameHasConfirmedAccount(db, username, throwException: false);
                if (userId == -1)
                {
                    return false;
                }
                else
                {
                    return CheckPassword(db, userId, password);
                }
            }
        }

        public override string GetUserNameFromId(int userId)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                dynamic username = db.QueryValue("SELECT " + SafeUserNameColumn + " FROM " + SafeUserTableName + " WHERE (" + SafeUserIdColumn + "=@0)", userId);
                return (string)username;
            }
        }

        public override void CreateOrUpdateOAuthAccount(string provider, string providerUserId, string userName)
        {
            VerifyInitialized();

            if (userName.IsEmpty())
            {
                throw new MembershipCreateUserException(MembershipCreateStatus.ProviderError);
            }

            int userId = GetUserId(userName);
            if (userId == -1)
            {
                throw new MembershipCreateUserException(MembershipCreateStatus.InvalidUserName);
            }

            var oldUserId = GetUserIdFromOAuth(provider, providerUserId);
            using (var db = ConnectToDatabase())
            {
                if (oldUserId == -1)
                {
                    // account doesn't exist. create a new one.
                    int insert = db.Execute(@"INSERT INTO [" + OAuthMembershipTableName + "] (Provider, ProviderUserId, UserId) VALUES (@0, @1, @2)", provider, providerUserId, userId);
                    if (insert != 1)
                    {
                        throw new MembershipCreateUserException(MembershipCreateStatus.ProviderError);
                    }
                }
                else
                {
                    // account already exist. update it
                    int insert = db.Execute(@"UPDATE [" + OAuthMembershipTableName + "] SET UserId = @2 WHERE UPPER(Provider)=@0 AND UPPER(ProviderUserId)=@1", provider, providerUserId, userId);
                    if (insert != 1)
                    {
                        throw new MembershipCreateUserException(MembershipCreateStatus.ProviderError);
                    }
                }
            }
        }

        public override void DeleteOAuthAccount(string provider, string providerUserId)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                // account doesn't exist. create a new one.
                int insert = db.Execute(@"DELETE FROM [" + OAuthMembershipTableName + "] WHERE UPPER(Provider)=@0 AND UPPER(ProviderUserId)=@1", provider, providerUserId);
                if (insert != 1)
                {
                    throw new MembershipCreateUserException(MembershipCreateStatus.ProviderError);
                }
            }
        }

        public override int GetUserIdFromOAuth(string provider, string providerUserId)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                dynamic id = db.QueryValue(@"SELECT UserId FROM [" + OAuthMembershipTableName + "] WHERE UPPER(Provider)=@0 AND UPPER(ProviderUserId)=@1", provider.ToUpperInvariant(), providerUserId.ToUpperInvariant());
                if (id != null)
                {
                    return (int)id;
                }

                return -1;
            }
        }

        public override string GetOAuthTokenSecret(string token)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                CreateOAuthTokenTableIfNeeded(db);

                // Note that token is case-sensitive
                dynamic secret = db.QueryValue(@"SELECT Secret FROM [" + OAuthTokenTableName + "] WHERE Token=@0", token);
                return (string)secret;
            }
        }

        public override void StoreOAuthRequestToken(string requestToken, string requestTokenSecret)
        {
            VerifyInitialized();

            string existingSecret = GetOAuthTokenSecret(requestToken);
            if (existingSecret != null)
            {
                if (existingSecret == requestTokenSecret)
                {
                    // the record already exists
                    return;
                }

                using (var db = ConnectToDatabase())
                {
                    CreateOAuthTokenTableIfNeeded(db);

                    // the token exists with old secret, update it to new secret
                    db.Execute(@"UPDATE [" + OAuthTokenTableName + "] SET Secret = @1 WHERE Token = @0", requestToken, requestTokenSecret);
                }
            }
            else
            {
                using (var db = ConnectToDatabase())
                {
                    CreateOAuthTokenTableIfNeeded(db);

                    // insert new record
                    int insert = db.Execute(@"INSERT INTO [" + OAuthTokenTableName + "] (Token, Secret) VALUES(@0, @1)", requestToken, requestTokenSecret);
                    if (insert != 1)
                    {
                        throw new ProviderException(WebDataResources.SimpleMembership_FailToStoreOAuthToken);
                    }
                }
            }
        }

        /// <summary>
        /// Replaces the request token with access token and secret.
        /// </summary>
        /// <param name="requestToken">The request token.</param>
        /// <param name="accessToken">The access token.</param>
        /// <param name="accessTokenSecret">The access token secret.</param>
        public override void ReplaceOAuthRequestTokenWithAccessToken(string requestToken, string accessToken, string accessTokenSecret)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                CreateOAuthTokenTableIfNeeded(db);

                // insert new record
                db.Execute(@"DELETE FROM [" + OAuthTokenTableName + "] WHERE Token = @0", requestToken);

                // Although there are two different types of tokens, request token and access token,
                // we treat them the same in database records.
                StoreOAuthRequestToken(accessToken, accessTokenSecret);
            }
        }

        /// <summary>
        /// Deletes the OAuth token from the backing store from the database.
        /// </summary>
        /// <param name="token">The token to be deleted.</param>
        public override void DeleteOAuthToken(string token)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                CreateOAuthTokenTableIfNeeded(db);

                // Note that token is case-sensitive
                db.Execute(@"DELETE FROM [" + OAuthTokenTableName + "] WHERE Token=@0", token);
            }
        }

        public override ICollection<OAuthAccountData> GetAccountsForUser(string userName)
        {
            VerifyInitialized();

            int userId = GetUserId(userName);
            if (userId != -1)
            {
                using (var db = ConnectToDatabase())
                {
                    IEnumerable<dynamic> records = db.Query(@"SELECT Provider, ProviderUserId FROM [" + OAuthMembershipTableName + "] WHERE UserId=@0", userId);
                    if (records != null)
                    {
                        var accounts = new List<OAuthAccountData>();
                        foreach (DynamicRecord row in records)
                        {
                            accounts.Add(new OAuthAccountData((string)row["Provider"], (string)row["ProviderUserId"]));
                        }
                        return accounts;
                    }
                }
            }

            return new OAuthAccountData[0];
        }

        /// <summary>
        /// Determines whether there exists a local account (as opposed to OAuth account) with the specified userId.
        /// </summary>
        /// <param name="userId">The user id to check for local account.</param>
        /// <returns>
        ///   <c>true</c> if there is a local account with the specified user id]; otherwise, <c>false</c>.
        /// </returns>
        public override bool HasLocalAccount(int userId)
        {
            VerifyInitialized();

            using (var db = ConnectToDatabase())
            {
                dynamic id = db.QueryValue(@"SELECT UserId FROM [" + MembershipTableName + "] WHERE UserId=@0", userId);
                return id != null;
            }
        }
    }
}

================================================
FILE: src/WebMatrix.WebData/SimpleMembershipProviderCasingBehavior.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace WebMatrix.WebData
{
    /// <summary>
    /// Configures the behavior of SimpleMembershipProvider for the casing of user name queries.
    /// </summary>
    public enum SimpleMembershipProviderCasingBehavior
    {
        /// <summary>
        /// Uses the SQL Upper function to normalize the casing of user names for a case-insensitive comparison. 
        /// This is the default value.
        /// </summary>
        /// <remarks>
        /// This option uses the SQL Upper function to perform case-normalization. This guarantees that the 
        /// the user name is searched case-insensitively, but can have a performance impact when a large number
        /// of users exist.
        /// </remarks>
        NormalizeCasing,

        /// <summary>
        /// Relies on the database's configured collation to normalize casing for the comparison of user names. User
        /// names are provided to the database exactly as entered by the user.
        /// </summary>
        /// <remarks>
        /// This option relies on the configured collection of database table for user names to perform a correct comparison.
        /// This is guaranteed to be correct for the chosen collation and performant. Only choose this option if the table storing
        /// user names is configured with the desired collation.
        /// </remarks>
        RelyOnDatabaseCollation,
    }
}


================================================
FILE: src/WebMatrix.WebData/SimpleRoleProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Configuration.Provider;
using System.Globalization;
using System.Linq;
using System.Web.Security;
using WebMatrix.WebData.Resources;

namespace WebMatrix.WebData
{
    public class SimpleRoleProvider : RoleProvider
    {
        private RoleProvider _previousProvider;
        private SimpleMembershipProviderCasingBehavior _casingBehavior;

        public SimpleRoleProvider()
            : this(null)
        {
        }

        public SimpleRoleProvider(RoleProvider previousProvider)
        {
            _previousProvider = previousProvider;
        }

        private RoleProvider PreviousProvider
        {
            get
            {
                if (_previousProvider == null)
                {
                    throw new InvalidOperationException(WebDataResources.Security_InitializeMustBeCalledFirst);
                }
                else
                {
                    return _previousProvider;
                }
            }
        }

        private string SafeUserTableName
        {
            get { return "[" + UserTableName + "]"; }
        }

        private string SafeUserNameColumn
        {
            get { return "[" + UserNameColumn + "]"; }
        }

        private string SafeUserIdColumn
        {
            get { return "[" + UserIdColumn + "]"; }
        }

        internal static string RoleTableName
        {
            get { return "webpages_Roles"; }
        }

        internal static string UsersInRoleTableName
        {
            get { return "webpages_UsersInRoles"; }
        }

        // represents the User table for the app
        public string UserTableName { get; set; }

        // represents the User created UserName column, i.e. Email
        public string UserNameColumn { get; set; }

        // Represents the User created id column, i.e. ID;
        // REVIEW: we could get this from the primary key of UserTable in the future
        public string UserIdColumn { get; set; }

        /// <summary>
        /// Gets or sets the <see cref="WebMatrix.WebData.SimpleMembershipProviderCasingBehavior"/> for this provider.
        /// </summary>
        /// <remarks>
        /// This value configures whether or not queries for user names normalize the user name to uppercase. See
        /// <see cref="WebMatrix.WebData.SimpleMembershipProviderCasingBehavior"/> for a full description.
        /// </remarks>
        public SimpleMembershipProviderCasingBehavior CasingBehavior
        {
            get
            {
                return _casingBehavior;
            }
            set
            {
                if (value < SimpleMembershipProviderCasingBehavior.NormalizeCasing || value > SimpleMembershipProviderCasingBehavior.RelyOnDatabaseCollation)
                {
                    throw new InvalidEnumArgumentException("value", (int)value, typeof(SimpleMembershipProviderCasingBehavior));
                }

                _casingBehavior = value;
            }
        }

        internal DatabaseConnectionInfo ConnectionInfo { get; set; }
        internal bool InitializeCalled { get; set; }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string ApplicationName
        {
            get
            {
                if (InitializeCalled)
                {
                    throw new NotSupportedException();
                }
                else
                {
                    return PreviousProvider.ApplicationName;
                }
            }
            set
            {
                if (InitializeCalled)
                {
                    throw new NotSupportedException();
                }
                else
                {
                    PreviousProvider.ApplicationName = value;
                }
            }
        }

        private void VerifyInitialized()
        {
            if (!InitializeCalled)
            {
                throw new InvalidOperationException(WebDataResources.Security_InitializeMustBeCalledFirst);
            }
        }

        private IDatabase ConnectToDatabase()
        {
            return new DatabaseWrapper(ConnectionInfo.Connect());
        }

        internal void CreateTablesIfNeeded()
        {
            using (var db = ConnectToDatabase())
            {
                if (!SimpleMembershipProvider.CheckTableExists(db, RoleTableName))
                {
                    db.Execute(@"CREATE TABLE " + RoleTableName + @" (
                        RoleId                                  int                 NOT NULL PRIMARY KEY IDENTITY,
                        RoleName                                nvarchar(256)       NOT NULL UNIQUE)");

                    db.Execute(@"CREATE TABLE " + UsersInRoleTableName + @" (
                        UserId                                  int                 NOT NULL,
                        RoleId                                  int                 NOT NULL,
                        PRIMARY KEY (UserId, RoleId),
                        CONSTRAINT fk_UserId FOREIGN KEY (UserId) REFERENCES " + SafeUserTableName + "(" + SafeUserIdColumn + @"),
                        CONSTRAINT fk_RoleId FOREIGN KEY (RoleId) REFERENCES " + RoleTableName + "(RoleId) )");
                }
            }
        }

        private List<int> GetUserIdsFromNames(IDatabase db, string[] usernames)
        {
            List<int> userIds = new List<int>(usernames.Length);
            foreach (string username in usernames)
            {
                int id = SimpleMembershipProvider.GetUserId(db, SafeUserTableName, SafeUserNameColumn, SafeUserIdColumn, CasingBehavior, username);
                if (id == -1)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoUserFound, username));
                }
                userIds.Add(id);
            }
            return userIds;
        }

        private static List<int> GetRoleIdsFromNames(IDatabase db, string[] roleNames)
        {
            List<int> roleIds = new List<int>(roleNames.Length);
            foreach (string role in roleNames)
            {
                int id = FindRoleId(db, role);
                if (id == -1)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.SimpleRoleProvider_NoRoleFound, role));
                }
                roleIds.Add(id);
            }
            return roleIds;
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override void AddUsersToRoles(string[] usernames, string[] roleNames)
        {
            if (!InitializeCalled)
            {
                PreviousProvider.AddUsersToRoles(usernames, roleNames);
            }
            else
            {
                using (var db = ConnectToDatabase())
                {
                    int userCount = usernames.Length;
                    int roleCount = roleNames.Length;
                    List<int> userIds = GetUserIdsFromNames(db, usernames);
                    List<int> roleIds = GetRoleIdsFromNames(db, roleNames);

                    // Generate a INSERT INTO for each userid/rowid combination, where userIds are the first params, and roleIds follow
                    for (int uId = 0; uId < userCount; uId++)
                    {
                        for (int rId = 0; rId < roleCount; rId++)
                        {
                            if (IsUserInRole(usernames[uId], roleNames[rId]))
                            {
                                throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.SimpleRoleProvder_UserAlreadyInRole, usernames[uId], roleNames[rId]));
                            }

                            // REVIEW: is there a way to batch up these inserts?
                            int rows = db.Execute("INSERT INTO " + UsersInRoleTableName + " VALUES (" + userIds[uId] + "," + roleIds[rId] + "); ");
                            if (rows != 1)
                            {
                                throw new ProviderException(WebDataResources.Security_DbFailure);
                            }
                        }
                    }
                }
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override void CreateRole(string roleName)
        {
            if (!InitializeCalled)
            {
                PreviousProvider.CreateRole(roleName);
            }
            else
            {
                using (var db = ConnectToDatabase())
                {
                    int roleId = FindRoleId(db, roleName);
                    if (roleId != -1)
                    {
                        throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, WebDataResources.SimpleRoleProvider_RoleExists, roleName));
                    }

                    int rows = db.Execute("INSERT INTO " + RoleTableName + " (RoleName) VALUES (@0)", roleName);
                    if (rows != 1)
                    {
                        throw new ProviderException(WebDataResources.Security_DbFailure);
                    }
                }
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.DeleteRole(roleName, throwOnPopulatedRole);
            }
            using (var db = ConnectToDatabase())
            {
                int roleId = FindRoleId(db, roleName);
                if (roleId == -1)
                {
                    return false;
                }

                if (throwOnPopulatedRole)
                {
                    int usersInRole = db.Query(@"SELECT * FROM " + UsersInRoleTableName + " WHERE (RoleId = @0)", roleId).Count();
                    if (usersInRole > 0)
                    {
                        throw new InvalidOperationException(String.Format(CultureInfo.InvariantCulture, WebDataResources.SimpleRoleProvder_RolePopulated, roleName));
                    }
                }
                else
                {
                    // Delete any users in this role first
                    db.Execute(@"DELETE FROM " + UsersInRoleTableName + " WHERE (RoleId = @0)", roleId);
                }

                int rows = db.Execute(@"DELETE FROM " + RoleTableName + " WHERE (RoleId = @0)", roleId);
                return (rows == 1); // REVIEW: should this ever be > 1?
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string[] FindUsersInRole(string roleName, string usernameToMatch)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.FindUsersInRole(roleName, usernameToMatch);
            }
            using (var db = ConnectToDatabase())
            {
                // REVIEW: Is there any way to directly get out a string[]?
                List<dynamic> userNames = db.Query(@"SELECT u." + SafeUserNameColumn + " FROM " + SafeUserTableName + " u, " + UsersInRoleTableName + " ur, " + RoleTableName + " r Where (r.RoleName = @0 and ur.RoleId = r.RoleId and ur.UserId = u." + SafeUserIdColumn + " and u." + SafeUserNameColumn + " LIKE @1)", new object[] { roleName, usernameToMatch }).ToList();
                string[] users = new string[userNames.Count];
                for (int i = 0; i < userNames.Count; i++)
                {
                    users[i] = (string)userNames[i][0];
                }
                return users;
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string[] GetAllRoles()
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetAllRoles();
            }
            using (var db = ConnectToDatabase())
            {
                return db.Query(@"SELECT RoleName FROM " + RoleTableName).Select<dynamic, string>(d => (string)d[0]).ToArray();
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string[] GetRolesForUser(string username)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetRolesForUser(username);
            }
            using (var db = ConnectToDatabase())
            {
                int userId = SimpleMembershipProvider.GetUserId(db, SafeUserTableName, SafeUserNameColumn, SafeUserIdColumn, CasingBehavior, username);
                if (userId == -1)
                {
                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.Security_NoUserFound, username));
                }

                string query = @"SELECT r.RoleName FROM " + UsersInRoleTableName + " u, " + RoleTableName + " r Where (u.UserId = @0 and u.RoleId = r.RoleId) GROUP BY RoleName";
                return db.Query(query, new object[] { userId }).Select<dynamic, string>(d => (string)d[0]).ToArray();
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override string[] GetUsersInRole(string roleName)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.GetUsersInRole(roleName);
            }
            using (var db = ConnectToDatabase())
            {
                string query = @"SELECT u." + SafeUserNameColumn + " FROM " + SafeUserTableName + " u, " + UsersInRoleTableName + " ur, " + RoleTableName + " r Where (r.RoleName = @0 and ur.RoleId = r.RoleId and ur.UserId = u." + SafeUserIdColumn + ")";
                return db.Query(query, new object[] { roleName }).Select<dynamic, string>(d => (string)d[0]).ToArray();
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool IsUserInRole(string username, string roleName)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.IsUserInRole(username, roleName);
            }
            using (var db = ConnectToDatabase())
            {
                var count = db.QuerySingle("SELECT COUNT(*) FROM " + SafeUserTableName + " u, " + UsersInRoleTableName + " ur, " + RoleTableName + " r Where (u." + SafeUserNameColumn + " = @0 and r.RoleName = @1 and ur.RoleId = r.RoleId and ur.UserId = u." + SafeUserIdColumn + ")", username, roleName);
                return (count[0] == 1);
            }
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
        {
            if (!InitializeCalled)
            {
                PreviousProvider.RemoveUsersFromRoles(usernames, roleNames);
            }
            else
            {
                foreach (string rolename in roleNames)
                {
                    if (!RoleExists(rolename))
                    {
                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.SimpleRoleProvider_NoRoleFound, rolename));
                    }
                }

                foreach (string username in usernames)
                {
                    foreach (string rolename in roleNames)
                    {
                        if (!IsUserInRole(username, rolename))
                        {
                            throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, WebDataResources.SimpleRoleProvder_UserNotInRole, username, rolename));
                        }
                    }
                }

                using (var db = ConnectToDatabase())
                {
                    List<int> userIds = GetUserIdsFromNames(db, usernames);
                    List<int> roleIds = GetRoleIdsFromNames(db, roleNames);

                    foreach (int userId in userIds)
                    {
                        foreach (int roleId in roleIds)
                        {
                            // Review: Is there a way to do these all in one query?
                            int rows = db.Execute("DELETE FROM " + UsersInRoleTableName + " WHERE UserId = " + userId + " and RoleId = " + roleId);
                            if (rows != 1)
                            {
                                throw new ProviderException(WebDataResources.Security_DbFailure);
                            }
                        }
                    }
                }
            }
        }

        private static int FindRoleId(IDatabase db, string roleName)
        {
            var result = db.QuerySingle(@"SELECT RoleId FROM " + RoleTableName + " WHERE (RoleName = @0)", roleName);
            if (result == null)
            {
                return -1;
            }
            return (int)result[0];
        }

        // Inherited from RoleProvider ==> Forwarded to previous provider if this provider hasn't been initialized
        public override bool RoleExists(string roleName)
        {
            if (!InitializeCalled)
            {
                return PreviousProvider.RoleExists(roleName);
            }
            using (var db = ConnectToDatabase())
            {
                return (FindRoleId(db, roleName) != -1);
            }
        }
    }
}


================================================
FILE: src/WebMatrix.WebData/WebMatrix.WebData.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{55A15F40-1435-4248-A7F2-2A146BB83586}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>WebMatrix.WebData</RootNamespace>
    <AssemblyName>WebMatrix.WebData</AssemblyName>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <RunCodeAnalysis>$(CodeAnalysis)</RunCodeAnalysis>
    <CodeAnalysisRuleSet>..\Strict.ruleset</CodeAnalysisRuleSet>
    <DefineConstants>$(DefineConstants);ASPNETWEBPAGES</DefineConstants>
    <NoWarn>1591</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.ApplicationServices" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\CommonAssemblyInfo.cs">
      <Link>Properties\CommonAssemblyInfo.cs</Link>
    </Compile>
    <Compile Include="..\CommonResources.Designer.cs">
      <Link>Common\CommonResources.Designer.cs</Link>
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>CommonResources.resx</DependentUpon>
    </Compile>
    <Compile Include="..\GlobalSuppressions.cs">
      <Link>Common\GlobalSuppressions.cs</Link>
    </Compile>
    <Compile Include="ConfigUtil.cs" />
    <Compile Include="DatabaseConnectionInfo.cs" />
    <Compile Include="DatabaseWrapper.cs" />
    <Compile Include="ExtendedMembershipProvider.cs" />
    <Compile Include="FormsAuthenticationSettings.cs" />
    <Compile Include="GlobalSuppressions.cs" />
    <Compile Include="IDatabase.cs" />
    <Compile Include="OAuthAccountData.cs" />
    <Compile Include="PreApplicationStartCode.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Resources\WebDataResources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>WebDataResources.resx</DependentUpon>
    </Compile>
    <Compile Include="SimpleMembershipProvider.cs" />
    <Compile Include="SimpleMembershipProviderCasingBehavior.cs" />
    <Compile Include="SimpleRoleProvider.cs" />
    <Compile Include="WebSecurity.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9B7E3740-6161-4548-833C-4BBCA43B970E}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\WebMatrix.Data\WebMatrix.Data.csproj">
      <Project>{4D39BAAF-8A96-473E-AB79-C8A341885137}</Project>
      <Name>WebMatrix.Data</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\CommonResources.resx">
      <Link>Common\CommonResources.resx</Link>
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>CommonResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
    <EmbeddedResource Include="Resources\WebDataResources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>WebDataResources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDictionary Include="..\CodeAnalysisDictionary.xml" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
</Project>

================================================
FILE: src/WebMatrix.WebData/WebSecurity.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Web;
using System.Web.Routing;
using System.Web.Security;
using System.Web.WebPages;
using WebMatrix.WebData.Resources;

namespace WebMatrix.WebData
{
    public static class WebSecurity
    {
        public static readonly string EnableSimpleMembershipKey = "enableSimpleMembership";

        /// <summary>
        /// Gets a value indicating whether the <see cref="M:InitializeDatabaseConnection"/> method has been initialized.
        /// </summary>
        /// <value>
        ///   <c>true</c> if initialized; otherwise, <c>false</c>.
        /// </value>
        public static bool Initialized { get; private set; }

        public static int CurrentUserId
        {
            get { return GetUserId(CurrentUserName); }
        }

        public static string CurrentUserName
        {
            get { return Context.User.Identity.Name; }
        }

        public static bool HasUserId
        {
            get { return CurrentUserId != -1; }
        }

        public static bool IsAuthenticated
        {
            get { return Request.IsAuthenticated; }
        }

        internal static HttpContextBase Context
        {
            get { return new HttpContextWrapper(HttpContext.Current); }
        }

        internal static HttpRequestBase Request
        {
            get { return Context.Request; }
        }

        internal static HttpResponseBase Response
        {
            get { return Context.Response; }
        }

        internal static void PreAppStartInit()
        {
            // Allow use of <add key="EnableSimpleMembershipKey" value="false" /> to disable registration of membership/role providers as default.
            if (ConfigUtil.SimpleMembershipEnabled)
            {
                // called during PreAppStart, should also hook up the config for MembershipProviders?
                // Replace the AspNetSqlMembershipProvider (which is the default that is registered in root web.config)
                const string BuiltInMembershipProviderName = "AspNetSqlMembershipProvider";
                var builtInMembership = Membership.Providers[BuiltInMembershipProviderName];
                if (builtInMembership != null)
                {
                    var simpleMembership = CreateDefaultSimpleMembershipProvider(BuiltInMembershipProviderName, currentDefault: builtInMembership);
                    Membership.Providers.Remove(BuiltInMembershipProviderName);
                    Membership.Providers.Add(simpleMembership);
                }

                Roles.Enabled = true;
                const string BuiltInRolesProviderName = "AspNetSqlRoleProvider";
                var builtInRoles = Roles.Providers[BuiltInRolesProviderName];
                if (builtInRoles != null)
                {
                    var simpleRoles = CreateDefaultSimpleRoleProvider(BuiltInRolesProviderName, currentDefault: builtInRoles);
                    Roles.Providers.Remove(BuiltInRolesProviderName);
                    Roles.Providers.Add(simpleRoles);
                }
            }
        }

        private static ExtendedMembershipProvider VerifyProvider()
        {
            ExtendedMembershipProvider provider = Membership.Provider as ExtendedMembershipProvider;
            if (provider == null)
            {
                throw new InvalidOperationException(WebDataResources.Security_NoExtendedMembershipProvider);
            }
            provider.VerifyInitialized(); // Have the provider verify that it's initialized (only our SimpleMembershipProvider does anything here)
            return provider;
        }

        public static void InitializeDatabaseConnection(string connectionStringName, string userTableName, string userIdColumn, string userNameColumn, bool autoCreateTables)
        {
            InitializeDatabaseConnection(
                connectionStringName, 
                userTableName, 
                userIdColumn, 
                userNameColumn, 
                autoCreateTables, 
                SimpleMembershipProviderCasingBehavior.NormalizeCasing);
        }

        public static void InitializeDatabaseConnection(
            string connectionStringName, 
            string userTableName, 
            string userIdColumn, 
            string userNameColumn, 
            bool autoCreateTables,
            SimpleMembershipProviderCasingBehavior casingBehavior)
        {
            DatabaseConnectionInfo connect = new DatabaseConnectionInfo();
            connect.ConnectionStringName = connectionStringName;
            InitializeProviders(connect, userTableName, userIdColumn, userNameColumn, autoCreateTables, casingBehavior);
        }

        public static void InitializeDatabaseConnection(
            string connectionString, 
            string providerName, 
            string userTableName, 
            string userIdColumn, 
            string userNameColumn, 
            bool autoCreateTables)
        {
            InitializeDatabaseConnection(
                connectionString, 
                providerName, 
                userTableName, 
                userIdColumn, 
                userNameColumn, 
                autoCreateTables, 
                SimpleMembershipProviderCasingBehavior.NormalizeCasing);
        }

        public static void InitializeDatabaseConnection(
            string connectionString, 
            string providerName, 
            string userTableName, 
            string userIdColumn, 
            string userNameColumn,
            bool autoCreateTables,
            SimpleMembershipProviderCasingBehavior casingBehavior)
        {
            DatabaseConnectionInfo connect = new DatabaseConnectionInfo();
            connect.ConnectionString = connectionString;
            connect.ProviderName = providerName;
            InitializeProviders(connect, userTableName, userIdColumn, userNameColumn, autoCreateTables, casingBehavior);
        }

        private static void InitializeProviders(
            DatabaseConnectionInfo connect, 
            string userTableName, 
            string userIdColumn, 
            string userNameColumn, 
            bool autoCreateTables, 
            SimpleMembershipProviderCasingBehavior casingBehavior)
        {
            SimpleMembershipProvider simpleMembership = Membership.Provider as SimpleMembershipProvider;
            if (simpleMembership != null)
            {
                InitializeMembershipProvider(simpleMembership, connect, userTableName, userIdColumn, userNameColumn, autoCreateTables, casingBehavior);
            }

            SimpleRoleProvider simpleRoles = Roles.Provider as SimpleRoleProvider;
            if (simpleRoles != null)
            {
                InitializeRoleProvider(simpleRoles, connect, userTableName, userIdColumn, userNameColumn, autoCreateTables, casingBehavior);
            }

            Initialized = true;
        }

        internal static void InitializeMembershipProvider(
            SimpleMembershipProvider simpleMembership, 
            DatabaseConnectionInfo connect, 
            string userTableName, 
            string userIdColumn, 
            string userNameColumn, 
            bool createTables,
            SimpleMembershipProviderCasingBehavior casingBehavior)
        {
            if (simpleMembership.InitializeCalled)
            {
                throw new InvalidOperationException(WebDataResources.Security_InitializeAlreadyCalled);
            }

            simpleMembership.CasingBehavior = casingBehavior;
            simpleMembership.ConnectionInfo = connect;
            simpleMembership.UserIdColumn = userIdColumn;
            simpleMembership.UserNameColumn = userNameColumn;
            simpleMembership.UserTableName = userTableName;
            if (createTables)
            {
                simpleMembership.CreateTablesIfNeeded();
            }
            else
            {
                // We want to validate the user table if we aren't creating them
                simpleMembership.ValidateUserTable();
            }
            simpleMembership.InitializeCalled = true;
        }

        internal static void InitializeRoleProvider(
            SimpleRoleProvider simpleRoles, 
            DatabaseConnectionInfo connect, 
            string userTableName, 
            string userIdColumn, 
            string userNameColumn, 
            bool createTables,
            SimpleMembershipProviderCasingBehavior casingBehavior)
        {
            if (simpleRoles.InitializeCalled)
            {
                throw new InvalidOperationException(WebDataResources.Security_InitializeAlreadyCalled);
            }

            simpleRoles.CasingBehavior = casingBehavior;
            simpleRoles.ConnectionInfo = connect;
            simpleRoles.UserTableName = userTableName;
            simpleRoles.UserIdColumn = userIdColumn;
            simpleRoles.UserNameColumn = userNameColumn;

            if (createTables)
            {
                simpleRoles.CreateTablesIfNeeded();
            }
            simpleRoles.InitializeCalled = true;
        }

        private static SimpleMembershipProvider CreateDefaultSimpleMembershipProvider(string name, MembershipProvider currentDefault)
        {
            var membership = new SimpleMembershipProvider(previousProvider: currentDefault);
            NameValueCollection config = new NameValueCollection();
            membership.Initialize(name, config);
            return membership;
        }

        private static SimpleRoleProvider CreateDefaultSimpleRoleProvider(string name, RoleProvider currentDefault)
        {
            var roleProvider = new SimpleRoleProvider(previousProvider: currentDefault);
            NameValueCollection config = new NameValueCollection();
            roleProvider.Initialize(name, config);
            return roleProvider;
        }

        [SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Login", Justification = "Login is used more consistently in ASP.Net")]
        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "This is a helper class, and we are not removing optional parameters from methods in helper classes")]
        public static bool Login(string userName, string password, bool persistCookie = false)
        {
            VerifyProvider();
            bool success = Membership.ValidateUser(userName, password);
            if (success)
            {
                FormsAuthentication.SetAuthCookie(userName, persistCookie);
            }
            return success;
        }

        [SuppressMessage("Microsoft.Naming", "CA1726:UsePreferredTerms", MessageId = "Logout", Justification = "Login is used more consistently in ASP.Net")]
        public static void Logout()
        {
            VerifyProvider();
            FormsAuthentication.SignOut();
        }

        public static bool ChangePassword(string userName, string currentPassword, string newPassword)
        {
            VerifyProvider();
            bool success = false;
            try
            {
                var currentUser = Membership.GetUser(userName, true /* userIsOnline */);
                success = currentUser.ChangePassword(currentPassword, newPassword);
            }
            catch (ArgumentException)
            {
                // An argument exception is thrown if the new password does not meet the provider's requirements
            }

            return success;
        }

        public static bool ConfirmAccount(string accountConfirmationToken)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this
            return provider.ConfirmAccount(accountConfirmationToken);
        }

        public static bool ConfirmAccount(string userName, string accountConfirmationToken)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this
            return provider.ConfirmAccount(userName, accountConfirmationToken);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "This is a helper class, and we are not removing optional parameters from methods in helper classes")]
        public static string CreateAccount(string userName, string password, bool requireConfirmationToken = false)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.CreateAccount(userName, password, requireConfirmationToken);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "This is a helper class, and we are not removing optional parameters from methods in helper classes")]
        public static string CreateUserAndAccount(string userName, string password, object propertyValues = null, bool requireConfirmationToken = false)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            IDictionary<string, object> values = propertyValues as RouteValueDictionary;
            if (values == null && propertyValues != null)
            {
                var propertyValuesAsDictionary = propertyValues as IDictionary<string, object>;
                if (propertyValuesAsDictionary != null)
                {
                    values = new RouteValueDictionary(propertyValuesAsDictionary);
                }
                else
                {
                    values = new RouteValueDictionary(propertyValues);
                }
            }

            return provider.CreateUserAndAccount(userName, password, requireConfirmationToken, values);
        }

        [SuppressMessage("Microsoft.Design", "CA1026:DefaultParametersShouldNotBeUsed", Justification = "This is a helper class, and we are not removing optional parameters from methods in helper classes")]
        public static string GeneratePasswordResetToken(string userName, int tokenExpirationInMinutesFromNow = 1440)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.GeneratePasswordResetToken(userName, tokenExpirationInMinutesFromNow);
        }

        public static bool UserExists(string userName)
        {
            VerifyProvider();
            return Membership.GetUser(userName) != null;
        }

        public static int GetUserId(string userName)
        {
            VerifyProvider();
            MembershipUser user = Membership.GetUser(userName);
            if (user == null)
            {
                return -1;
            }

            // REVIEW: This cast is breaking the abstraction for the membershipprovider, we basically assume that userids are ints
            return (int)user.ProviderUserKey;
        }

        public static int GetUserIdFromPasswordResetToken(string token)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.GetUserIdFromPasswordResetToken(token);
        }

        public static bool IsCurrentUser(string userName)
        {
            VerifyProvider();
            return String.Equals(CurrentUserName, userName, StringComparison.OrdinalIgnoreCase);
        }

        public static bool IsConfirmed(string userName)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.IsConfirmed(userName);
        }

        // Make sure the logged on user is same as the one specified by the id
        private static bool IsUserLoggedOn(int userId)
        {
            VerifyProvider();
            return CurrentUserId == userId;
        }

        // Make sure the user was authenticated
        public static void RequireAuthenticatedUser()
        {
            VerifyProvider();
            var user = Context.User;
            if (user == null || !user.Identity.IsAuthenticated)
            {
                Response.SetStatus(HttpStatusCode.Unauthorized);
            }
        }

        // Make sure the user was authenticated
        public static void RequireUser(int userId)
        {
            VerifyProvider();
            if (!IsUserLoggedOn(userId))
            {
                Response.SetStatus(HttpStatusCode.Unauthorized);
            }
        }

        public static void RequireUser(string userName)
        {
            VerifyProvider();
            if (!String.Equals(CurrentUserName, userName, StringComparison.OrdinalIgnoreCase))
            {
                Response.SetStatus(HttpStatusCode.Unauthorized);
            }
        }

        public static void RequireRoles(params string[] roles)
        {
            VerifyProvider();
            foreach (string role in roles)
            {
                if (!Roles.IsUserInRole(CurrentUserName, role))
                {
                    Response.SetStatus(HttpStatusCode.Unauthorized);
                    return;
                }
            }
        }

        public static bool ResetPassword(string passwordResetToken, string newPassword)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this
            return provider.ResetPasswordWithToken(passwordResetToken, newPassword);
        }

        public static bool IsAccountLockedOut(string userName, int allowedPasswordAttempts, int intervalInSeconds)
        {
            VerifyProvider();
            return IsAccountLockedOut(userName, allowedPasswordAttempts, TimeSpan.FromSeconds(intervalInSeconds));
        }

        public static bool IsAccountLockedOut(string userName, int allowedPasswordAttempts, TimeSpan interval)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return IsAccountLockedOutInternal(provider, userName, allowedPasswordAttempts, interval);
        }

        internal static bool IsAccountLockedOutInternal(ExtendedMembershipProvider provider, string userName, int allowedPasswordAttempts, TimeSpan interval)
        {
            return (provider.GetUser(userName, false) != null &&
                    provider.GetPasswordFailuresSinceLastSuccess(userName) > allowedPasswordAttempts &&
                    provider.GetLastPasswordFailureDate(userName).Add(interval) > DateTime.UtcNow);
        }

        public static int GetPasswordFailuresSinceLastSuccess(string userName)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.GetPasswordFailuresSinceLastSuccess(userName);
        }

        public static DateTime GetCreateDate(string userName)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.GetCreateDate(userName);
        }

        public static DateTime GetPasswordChangedDate(string userName)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.GetPasswordChangedDate(userName);
        }

        public static DateTime GetLastPasswordFailureDate(string userName)
        {
            ExtendedMembershipProvider provider = VerifyProvider();
            Debug.Assert(provider != null); // VerifyProvider checks this

            return provider.GetLastPasswordFailureDate(userName);
        }
    }
}


================================================
FILE: test/Common/AttributeListTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.ComponentModel
{
    public class AttributeListTest
    {
        private readonly Attribute[] _testAttributes;
        private readonly AttributeCollection _collection;
        private readonly AttributeList _list;

        public AttributeListTest()
        {
            _testAttributes = new Attribute[] { new TestAttribute(), new DerivedAttribute(), new DerivedDerivedAttribute() };
            _collection = new AttributeCollection(_testAttributes);
            _list = new AttributeList(_collection);
        }

        [Fact]
        public void AttributeListCountMatchesWrapped()
        {
            Assert.Equal(_collection.Count, _list.Count);
        }

        [Fact]
        public void AttributeListIsReadOnlyTrue()
        {
            Assert.True(_list.IsReadOnly);
        }

        [Fact]
        public void AttributeListIndexerMatchesWrapped()
        {
            Assert.Equal(_collection[1], _list[1]);
        }

        [Fact]
        public void AttributeListAddThrows()
        {
            Assert.Throws<NotSupportedException>(() => _list.Add(null));
        }

        [Fact]
        public void AttributeListClearThrows()
        {
            Assert.Throws<NotSupportedException>(() => _list.Clear());
        }

        [Fact]
        public void AttributeListContainsWrappedTrue()
        {
            Attribute presentAttribute = _collection[2];
            Assert.Contains(presentAttribute, _list);
        }

        [Fact]
        public void AttributeListContainsMissingFalse()
        {
            Attribute missingAttribute = new MissingAttribute();
            Assert.DoesNotContain(missingAttribute, _list);
        }

        [Fact]
        public void AttributeListCopyToResultsEqual()
        {
            Attribute[] arrayCopy = new Attribute[3];
            _list.CopyTo(arrayCopy, 0);
            Assert.Equal(_list, arrayCopy);
        }

        [Fact]
        public void AttributeListIndexOfMatchesIndexer()
        {
            Assert.Equal(1, _list.IndexOf(_list[1]));
        }

        [Fact]
        public void AttributeListRemoveAtThrows()
        {
            Assert.Throws<NotSupportedException>(() => _list.RemoveAt(0));
            Assert.Throws<NotSupportedException>(() => ((ICollection<Attribute>)_list).Remove(_list[0]));
        }

        [Fact]
        public void AttributeListEnumerationMatchesWrapped()
        {
            int i = 0;
            foreach (Attribute attribute in _list)
            {
                Assert.Equal(_collection[i], attribute);
                i++;
            }
            Assert.Equal(_collection.Count, i);

            i = 0;
            IEnumerable asEumerable = _list as IEnumerable;
            foreach (Attribute attribute in asEumerable)
            {
                Assert.Equal(_collection[i], attribute);
                i++;
            }
            Assert.Equal(_collection.Count, i);
        }

        private class TestAttribute : Attribute
        {
            public TestAttribute() { }
        }

        private class DerivedAttribute: TestAttribute
        {
            public DerivedAttribute() { }
        }

        private class DerivedDerivedAttribute : DerivedAttribute
        {
            public DerivedDerivedAttribute() { }
        }

        private class MissingAttribute : Attribute
        {
            public MissingAttribute() { }
        }
    }
}


================================================
FILE: test/Common/CollectionExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Collections.Generic
{
    public class CollectionExtensionsTest
    {
        [Fact]
        public void AppendAndReallocateEmpty_ReturnsOne()
        {
            string[] empty = new string[0];

            string[] emptyAppended = empty.AppendAndReallocate("AppendedEmpty");

            string singleAppended = Assert.Single(emptyAppended);
            Assert.Equal("AppendedEmpty", singleAppended);
        }

        [Fact]
        public void AppendAndReallocateOne_ReturnsTwo()
        {
            string[] one = new string[] { "One" };

            string[] oneAppended = one.AppendAndReallocate("AppendedOne");

            Assert.Equal(2, oneAppended.Length);
            Assert.Equal("One", oneAppended[0]);
            Assert.Equal("AppendedOne", oneAppended[1]);
        }

        [Fact]
        public void AsArray_Array_ReturnsSameInstance()
        {
            object[] array = new object[] { new object(), new object() };

            object[] arrayAsArray = ((IEnumerable<object>)array).AsArray();

            Assert.Same(array, arrayAsArray);
        }

        [Fact]
        public void AsArray_Enumerable_Copies()
        {
            IList<object> list = new List<object>() { new object(), new object() };
            object[] listToArray = list.ToArray();

            object[] listAsArray = ((IEnumerable<object>)list).AsArray();

            Assert.Equal(listToArray, listAsArray);
        }

        [Fact]
        public void AsCollection_Collection_ReturnsSameInstance()
        {
            Collection<object> collection = new Collection<object>() { new object(), new object() };

            Collection<object> collectionAsCollection = ((IEnumerable<object>)collection).AsCollection();

            Assert.Same(collection, collectionAsCollection);
        }

        [Fact]
        public void AsCollection_Enumerable_Copies()
        {
            IEnumerable<object> enumerable = new LinkedList<object>(new object[] { new object(), new object() });

            Collection<object> enumerableAsCollection = ((IEnumerable<object>)enumerable).AsCollection();

            Assert.Equal(enumerable, ((IEnumerable<object>)enumerableAsCollection));
        }

        [Fact]
        public void AsCollection_IList_Wraps()
        {
            IList<object> list = new List<object>() { new object(), new object() };

            Collection<object> listAsCollection = list.AsCollection();
            list.Add(new object());

            Assert.Equal(list, listAsCollection.ToList());
        }

        [Fact]
        public void AsIList_IList_ReturnsSameInstance()
        {
            List<object> list = new List<object> { new object(), new object() };

            IList<object> listAsIList = ((IEnumerable<object>)list).AsIList();

            Assert.Same(list, listAsIList);
        }

        [Fact]
        public void AsIList_Enumerable_Copies()
        {
            LinkedList<object> enumerable = new LinkedList<object>();
            enumerable.AddLast(new object());
            enumerable.AddLast(new object());
            List<object> expected = enumerable.ToList();

            IList<object> enumerableAsIList = ((IEnumerable<object>)enumerable).AsIList();

            Assert.Equal(expected, enumerableAsIList);
            Assert.NotSame(expected, enumerableAsIList);
        }

        [Fact]
        public void AsList_List_ReturnsSameInstance()
        {
            List<object> list = new List<object> { new object(), new object() };

            List<object> listAsList = ((IEnumerable<object>)list).AsList();

            Assert.Same(list, listAsList);
        }

        [Fact]
        public void AsList_Enumerable_Copies()
        {
            List<object> list = new List<object>() { new object(), new object() };
            object[] array = list.ToArray();

            List<object> arrayAsList = ((IEnumerable<object>)array).AsList();

            Assert.Equal(list, arrayAsList);
            Assert.NotSame(list, arrayAsList);
            Assert.NotSame(array, arrayAsList);
        }

        [Fact]
        public void AsList_ListWrapperCollection_ReturnsSameInstance()
        {
            List<object> list = new List<object> { new object(), new object() };
            ListWrapperCollection<object> listWrapper = new ListWrapperCollection<object>(list);

            List<object> listWrapperAsList = ((IEnumerable<object>)listWrapper).AsList();

            Assert.Same(list, listWrapperAsList);
        }

        [Fact]
        void RemoveFromTwoElementsAtEnd_NoChange()
        {
            List<object> list = new List<object>() { new object(), new object() };
            List<object> listExpected = new List<object>(list);
            list.RemoveFrom(2);
            Assert.Equal(listExpected, list);
        }

        [Fact]
        void RemoveFromTwoElementsMiddle_ToOne()
        {
            List<object> list = new List<object>() { new object(), new object() };
            List<object> listExpected = new List<object>() { list[0] };
            list.RemoveFrom(1);
            Assert.Equal(listExpected, list);
        }

        [Fact]
        void RemoveFromTwoElementsStart_ToEmpty()
        {
            List<object> list = new List<object>() { new object(), new object() };
            List<object> listExpected = new List<object>();
            list.RemoveFrom(0);
            Assert.Equal(listExpected, list);
        }

        [Fact]
        void SingleDefaultOrErrorIListEmptyReturnsNull()
        {
            IList<object> empty = new List<object>();
            object errorArgument = new object();
            Action<object> errorAction = (object argument) =>
            {
                throw new InvalidOperationException();
            };

            Assert.Null(empty.SingleDefaultOrError(errorAction, errorArgument));
        }

        [Fact]
        public void SingleDefaultOrErrorIListSingleReturns()
        {
            IList<object> single = new List<object>() { new object() };
            object errorArgument = new object();
            Action<object> errorAction = (object argument) =>
            {
                throw new InvalidOperationException();
            };

            Assert.Equal(single[0], single.SingleDefaultOrError(errorAction, errorArgument));
        }

        [Fact]
        public void SingleDefaultOrErrorIListMultipleThrows()
        {
            IList<object> multiple = new List<object>() { new object(), new object() };
            object errorArgument = new object();
            Action<object> errorAction = (object argument) =>
            {
                Assert.Equal(errorArgument, argument);
                throw new InvalidOperationException();
            };

            Assert.Throws<InvalidOperationException>(() => multiple.SingleDefaultOrError(errorAction, errorArgument));
        }

        [Fact]
        public void SingleOfTypeDefaultOrErrorIListNoMatchReturnsNull()
        {
            IList<object> noMatch = new List<object>() { new object(), new object() };
            object errorArgument = new object();
            Action<object> errorAction = (object argument) =>
            {
                throw new InvalidOperationException();
            };

            Assert.Null(noMatch.SingleOfTypeDefaultOrError<object, string, object>(errorAction, errorArgument));
        }

        [Fact]
        public void SingleOfTypeDefaultOrErrorIListOneMatchReturns()
        {
            IList<object> singleMatch = new List<object>() { new object(), "Match", new object() };
            object errorArgument = new object();
            Action<object> errorAction = (object argument) =>
            {
                throw new InvalidOperationException();
            };

            Assert.Equal("Match", singleMatch.SingleOfTypeDefaultOrError<object, string, object>(errorAction, errorArgument));
        }

        [Fact]
        public void SingleOfTypeDefaultOrErrorIListMultipleMatchesThrows()
        {
            IList<object> multipleMatch = new List<object>() { new object(), "Match1", new object(), "Match2" };
            object errorArgument = new object();
            Action<object> errorAction = (object argument) =>
            {
                Assert.Equal(errorArgument, argument);
                throw new InvalidOperationException();
            };

            Assert.Throws<InvalidOperationException>(() => multipleMatch.SingleOfTypeDefaultOrError<object, string, object>(errorAction, errorArgument));
        }

        [Fact]
        public void ToArrayWithoutNullsICollectionNoNullsCopies()
        {
            ICollection<object> noNulls = new object[] { new object(), new object() };

            object[] noNullsresult = noNulls.ToArrayWithoutNulls();

            Assert.Equal(noNulls, noNullsresult);
        }

        [Fact]
        public void ToArrayWithoutNullsICollectionHasNullsRemovesNulls()
        {
            IList<object> hasNulls = new List<object>() { new object(), null, new object() };

            object[] hasNullsResult = ((ICollection<object>)hasNulls).ToArrayWithoutNulls();

            Assert.Equal(2, hasNullsResult.Length);
            Assert.Equal(hasNulls[0], hasNullsResult[0]);
            Assert.Equal(hasNulls[2], hasNullsResult[1]);
        }

        [Fact]
        public void ToDictionaryFastArray2Element()
        {
            string[] input = new string[] {"AA", "BB"};
            var expectedOutput = new Dictionary<string, string>() { { "A", "AA"}, {"B", "BB"}};
            Func<string, string> keySelector = (string value) => value.Substring(1);

            var result = input.ToDictionaryFast(keySelector, StringComparer.OrdinalIgnoreCase);

            Assert.Equal(expectedOutput, result);
            Assert.Equal(StringComparer.OrdinalIgnoreCase, result.Comparer);
        }

        [Fact]
        public void ToDictionaryFastIListList2Element()
        {
            string[] input = new string[] {"AA", "BB"};
            var expectedOutput = new Dictionary<string, string>() { { "A", "AA"}, {"B", "BB"}};
            Func<string, string> keySelector = (string value) => value.Substring(1);
            List<string> listInput = new List<string>(input);

            var listResult = listInput.ToDictionaryFast(keySelector, StringComparer.OrdinalIgnoreCase);

            Assert.Equal(expectedOutput, listResult);
            Assert.Equal(StringComparer.OrdinalIgnoreCase, listResult.Comparer);
        }

        [Fact]
        public void ToDictionaryFastIListArray2Element()
        {
            string[] input = new string[] { "AA", "BB" };
            var expectedOutput = new Dictionary<string, string>() { { "A", "AA" }, { "B", "BB" } };
            Func<string, string> keySelector = (string value) => value.Substring(1);
            IList<string> arrayAsList = input;

            var arrayResult = arrayAsList.ToDictionaryFast(keySelector, StringComparer.OrdinalIgnoreCase);

            Assert.Equal(expectedOutput, arrayResult);
            Assert.Equal(StringComparer.OrdinalIgnoreCase, arrayResult.Comparer);
        }

        [Fact]
        public void ToDictionaryFastIEnumerableArray2Element()
        {
            string[] input = new string[] {"AA", "BB"};
            var expectedOutput = new Dictionary<string, string>() { { "A", "AA"}, {"B", "BB"}};
            Func<string, string> keySelector = (string value) => value.Substring(1);

            var arrayResult = ((IEnumerable<string>)input).ToDictionaryFast(keySelector, StringComparer.OrdinalIgnoreCase);

            Assert.Equal(expectedOutput, arrayResult);
            Assert.Equal(StringComparer.OrdinalIgnoreCase, arrayResult.Comparer);
        }

        [Fact]
        public void ToDictionaryFastIEnumerableList2Element()
        {
            string[] input = new string[] { "AA", "BB" };
            var expectedOutput = new Dictionary<string, string>() { { "A", "AA" }, { "B", "BB" } };
            Func<string, string> keySelector = (string value) => value.Substring(1);
            List<string> listInput = new List<string>(input);

            var listResult = ((IEnumerable<string>)listInput).ToDictionaryFast(keySelector, StringComparer.OrdinalIgnoreCase);

            Assert.Equal(expectedOutput, listResult);
            Assert.Equal(StringComparer.OrdinalIgnoreCase, listResult.Comparer);
        }

        [Fact]
        public void ToDictionaryFastIEnumerableLinkedList2Element()
        {
            string[] input = new string[] { "AA", "BB" };
            var expectedOutput = new Dictionary<string, string>() { { "A", "AA" }, { "B", "BB" } };
            Func<string, string> keySelector = (string value) => value.Substring(1);
            LinkedList<string> linkedListInput = new LinkedList<string>(input);

            var enumerableResult = ((IEnumerable<string>)linkedListInput).ToDictionaryFast(keySelector, StringComparer.OrdinalIgnoreCase);

            Assert.Equal(expectedOutput, enumerableResult);
            Assert.Equal(StringComparer.OrdinalIgnoreCase, enumerableResult.Comparer);
        }
    }
}


================================================
FILE: test/Common/DictionaryExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net;
using Microsoft.TestCommon;

namespace System.Collections.Generic
{
    public class DictionaryExtensionsTest
    {
        public static TheoryDataSet<object> DictionaryValues
        {
            get
            {
                return new TheoryDataSet<object>
                {
                    "test",
                    new string[] { "A", "B", "C" },
                    8,
                    new List<int> {1, 2, 3},
                    1D,
                    (IEnumerable<double>)new List<double> { 1D, 2D, 3D },
                    new Uri("http://some.host"),
                    Guid.NewGuid(),
                    HttpStatusCode.NotImplemented,
                    new HttpStatusCode[] { HttpStatusCode.Accepted, HttpStatusCode.Ambiguous, HttpStatusCode.BadGateway }
                };
            }
        }

        [Fact]
        public void IsCorrectType()
        {
            Assert.Type.HasProperties(typeof(DictionaryExtensions), TypeAssert.TypeProperties.IsStatic | TypeAssert.TypeProperties.IsClass);
        }

        [Fact]
        public void RemoveFromDictionary_Args0_EvensRemoved()
        {
            Dictionary<object, int> dictionary = new Dictionary<object, int>();
            object object1 = new object();
            object object2 = new object();
            object object3 = new object();
            object object4 = new object();
            dictionary.Add(object1, 1);
            dictionary.Add(object2, 2);
            dictionary.Add(object3, 3);
            dictionary.Add(object4, 4);

            Func<KeyValuePair<object, int>, bool> removeAction = (KeyValuePair<object, int> entry) =>
            {
                // remove even values
                return (entry.Value % 2) == 0;
            };
            dictionary.RemoveFromDictionary(removeAction);

            Assert.Equal(2, dictionary.Count);
            Assert.True(dictionary.ContainsKey(object1));
            Assert.False(dictionary.ContainsKey(object2));
            Assert.True(dictionary.ContainsKey(object3));
            Assert.False(dictionary.ContainsKey(object4));
        }

        [Fact]
        public void RemoveFromDictionary_Args1_EvensRemoved()
        {
            Dictionary<object, int> dictionary = new Dictionary<object, int>();
            object object1 = new object();
            object object2 = new object();
            object object3 = new object();
            object object4 = new object();
            dictionary.Add(object1, 1);
            dictionary.Add(object2, 2);
            dictionary.Add(object3, 3);
            dictionary.Add(object4, 4);
            object expectedArgument = new object();

            Func<KeyValuePair<object, int>, object, bool> removeAction = (KeyValuePair<object, int> entry, object arg) =>
            {
                Assert.Equal(expectedArgument, arg);
                // remove even values
                return (entry.Value % 2) == 0;
            };
            dictionary.RemoveFromDictionary(removeAction, expectedArgument);

            Assert.Equal(2, dictionary.Count);
            Assert.True(dictionary.ContainsKey(object1));
            Assert.False(dictionary.ContainsKey(object2));
            Assert.True(dictionary.ContainsKey(object3));
            Assert.False(dictionary.ContainsKey(object4));
        }

        [Fact]
        public void TryGetValueThrowsOnNullKey()
        {
            IDictionary<string, object> dict = new Dictionary<string, object>();
            string value;
            Assert.ThrowsArgumentNull(() => dict.TryGetValue<string>(null, out value), "key");
        }

        [Fact]
        public void TryGetValueReturnsFalse()
        {
            // Arrange
            IDictionary<string, object> dict = new Dictionary<string, object>();

            // Act
            string resultValue = null;
            bool result = dict.TryGetValue("notfound", out resultValue);

            // Assert
            Assert.False(result);
            Assert.Null(resultValue);
        }

        [Theory]
        [PropertyData("DictionaryValues")]
        public void TryGetValueReturnsTrue<T>(T value)
        {
            // Arrange
            IDictionary<string, object> dict = new Dictionary<string, object>()
            {
                { "key", value }
            };


            // Act
            T resultValue;
            bool result = DictionaryExtensions.TryGetValue(dict, "key", out resultValue);

            // Assert
            Assert.True(result);
            Assert.Equal(typeof(T), resultValue.GetType());
            Assert.Equal(value, resultValue);
        }

        [Fact]
        public void FindKeysWithPrefixRecognizesRootChilden()
        {
            // Arrange
            IDictionary<string, int> dict = new Dictionary<string, int>()
            {
                { "[0]", 1 },
                { "Name", 2 },
                { "Address.Street", 3 },
                { "", 4 }
            };

            // Act
            List<int> results = DictionaryExtensions.FindKeysWithPrefix<int>(dict, "").Select(kvp => kvp.Value).ToList();

            // Assert
            Assert.Equal(4, results.Count);
            Assert.Contains(1, results);
            Assert.Contains(2, results);
            Assert.Contains(3, results);
            Assert.Contains(4, results);
        }
    }
}


================================================
FILE: test/Common/ErrorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class ErrorTest
    {
        [Fact]
        public void Format()
        {
            // Arrange
            string expected = "The formatted message";

            // Act
            string actual = Error.Format("The {0} message", "formatted");

            // Assert
            Assert.Equal(expected, actual);
        }
    }
}


================================================
FILE: test/Common/HttpMethodHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class HttpMethodHelperTest
    {
        public static TheoryDataSet<string, HttpMethod> CommonHttpMethods
        {
            get
            {
                return new TheoryDataSet<string, HttpMethod>
                {
                    { "Get", HttpMethod.Get },
                    { "Post", HttpMethod.Post },
                    { "Put", HttpMethod.Put },
                    { "Delete", HttpMethod.Delete },
                    { "Head", HttpMethod.Head },
                    { "Options", HttpMethod.Options },
                    { "Trace", HttpMethod.Trace },
                };
            }
        }

        public static TheoryDataSet<string> UncommonHttpMethods
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "Debug",
                    "Patch",
                    "Connect",
                    "Random",
                    "M-Get",
                };
            }
        }

        [Fact]
        public void GetHttpMethod_ReturnsNullOnNullorEmpty()
        {
            Assert.Null(HttpMethodHelper.GetHttpMethod(null));
            Assert.Null(HttpMethodHelper.GetHttpMethod(String.Empty));
        }

        [Theory]
        [PropertyData("CommonHttpMethods")]
        public void GetHttpMethod_RetunsStaticResult(string method, HttpMethod expectedMethod)
        {
            Assert.Same(expectedMethod, HttpMethodHelper.GetHttpMethod(method));
            Assert.Same(expectedMethod, HttpMethodHelper.GetHttpMethod(method.ToLowerInvariant()));
            Assert.Same(expectedMethod, HttpMethodHelper.GetHttpMethod(method.ToUpperInvariant()));
        }

        [Theory]
        [PropertyData("UncommonHttpMethods")]
        public void GetHttpMethod_RetunsNonStaticResult(string method)
        {
            Assert.Equal(method, HttpMethodHelper.GetHttpMethod(method).ToString());
        }
    }
}


================================================
FILE: test/Common/ListWrapperCollectionTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Collections.ObjectModel
{
    public class ListWrapperCollectionTests
    {
        [Fact]
        public void ListWrapperCollection_ItemsList_HasSameContents()
        {
            // Arrange
            ListWrapperCollection<object> listWrapper = new ListWrapperCollection<object>();

            // Act
            listWrapper.Add(new object());
            listWrapper.Add(new object());

            // Assert
            Assert.Equal(listWrapper, listWrapper.ItemsList);
        }

        [Fact]
        public void ListWrapperCollection_ItemsList_IsPassedInList()
        {
            // Arrange
            List<object> list = new List<object>() { new object(), new object() };
            ListWrapperCollection<object> listWrapper = new ListWrapperCollection<object>(list);

            // Act & Assert
            Assert.Same(list, listWrapper.ItemsList);
        }
    }
}


================================================
FILE: test/Common/PathHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web;
using Microsoft.TestCommon;

namespace System.Web.Test
{
    public class PathHelpersTest
    {
        [Theory]
        [InlineData("foo.Bar", "bar")]
        [InlineData("foo.bar", "bar")]
        [InlineData(".bar", "bar")]
        public void EndsWithExtensionReturnsTrue(string path, string extension)
        {
            Assert.True(PathHelpers.EndsWithExtension(path, extension));
        }

        [Theory]
        [InlineData("foo.Baz", "bar")]
        [InlineData("", "bar")]
        [InlineData("Bar", "bar")]
        [InlineData("fooBar", "bar")]
        public void EndsWithExtensionReturnsFalse(string path, string extension)
        {
            Assert.False(PathHelpers.EndsWithExtension(path, extension));
        }
    }
}


================================================
FILE: test/Common/PrefixContainerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web
{
    [CLSCompliant(false)]
    public class PrefixContainerTests
    {
        [Fact]
        public void Constructor_GuardClauses()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(() => new PrefixContainer(null), "values");
        }

        [Fact]
        public void ContainsPrefix_GuardClauses()
        {
            // Arrange
            var container = new PrefixContainer(new string[0]);

            // Act & assert
            Assert.ThrowsArgumentNull(() => container.ContainsPrefix(null), "prefix");
        }

        [Fact]
        public void ContainsPrefix_EmptyCollectionReturnsFalse()
        {
            // Arrange
            var container = new PrefixContainer(new string[0]);

            // Act & Assert
            Assert.False(container.ContainsPrefix(""));
        }

        [Fact]
        public void ContainsPrefix_ExactMatch()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "Hello" });

            // Act & Assert
            Assert.True(container.ContainsPrefix("Hello"));
        }

        [Fact]
        public void ContainsPrefix_MatchIsCaseInsensitive()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "Hello" });

            // Act & Assert
            Assert.True(container.ContainsPrefix("hello"));
        }

        [Fact]
        public void ContainsPrefix_MatchIsNotSimpleSubstringMatch()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "Hello" });

            // Act & Assert
            Assert.False(container.ContainsPrefix("He"));
        }

        [Fact]
        public void ContainsPrefix_NonEmptyCollectionReturnsTrueIfPrefixIsEmptyString()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "Hello" });

            // Act & Assert
            Assert.True(container.ContainsPrefix(""));
        }

        [Fact]
        public void ContainsPrefix_PrefixBoundaries()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "Hello.There[0]" });

            // Act & Assert
            Assert.True(container.ContainsPrefix("hello"));
            Assert.True(container.ContainsPrefix("hello.there"));
            Assert.True(container.ContainsPrefix("hello.there[0]"));
            Assert.False(container.ContainsPrefix("hello.there.0"));
        }

        [Theory]
        [InlineData("a")]
        [InlineData("a[d]")]
        [InlineData("c.b")]
        [InlineData("c.b.a")]
        public void ContainsPrefix_PositiveTests(string testValue)
        {
            // Arrange
            var container = new PrefixContainer(new[] { "a.b", "c.b.a", "a[d]", "a.c" });

            // Act & Assert
            Assert.True(container.ContainsPrefix(testValue));
        }

        [Theory]
        [InlineData("a.d")]
        [InlineData("b")]
        [InlineData("c.a")]
        [InlineData("c.b.a.a")]
        public void ContainsPrefix_NegativeTests(string testValue)
        {
            // Arrange
            var container = new PrefixContainer(new[] { "a.b", "c.b.a", "a[d]", "a.c" });

            // Act & Assert
            Assert.False(container.ContainsPrefix(testValue));
        }

        [Fact]
        public void ContainsPrefix_ShouldIdentifyCollectionWhenNonCollectionPropertyOccursOnBinarySearchBoundary()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "foo.a", "foo.b", "foo.c", "foo.d", "foo.esSomethingElse", "foo.es[0].a", "foo.es[0].b", "foo.es[0].c", "foo.es[0].d", "foo.es[0].e" });

            // Act & Assert
            Assert.True(container.ContainsPrefix("foo.es"));
        }

        [Fact]
        public void ContainsPrefix_ShouldIdentifyCollectionWhenNonCollectionPropertyDoesNotOccurOnBinarySearchBoundary()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "foo.a", "foo.b", "foo.c", "foo.d", "foo.esSomethingElse", "foo.es[0].a", "foo.es[0].b", "foo.es[0].c" });

            // Act & Assert
            Assert.True(container.ContainsPrefix("foo.es"));
        }

        [Fact]
        public void GetKeysFromPrefix_DotsNotation()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "foo.bar.baz", "something.other", "foo.baz", "foot.hello", "fo.nothing", "foo" });
            string prefix = "foo";

            // Act
            IDictionary<string, string> result = container.GetKeysFromPrefix(prefix);

            // Assert
            Assert.Equal(2, result.Count());
            Assert.True(result.ContainsKey("bar"));
            Assert.True(result.ContainsKey("baz"));
            Assert.Equal("foo.bar", result["bar"]);
            Assert.Equal("foo.baz", result["baz"]);
        }

        [Fact]
        public void GetKeysFromPrefix_BracketsNotation()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "foo[bar]baz", "something[other]", "foo[baz]", "foot[hello]", "fo[nothing]", "foo" });
            string prefix = "foo";

            // Act
            IDictionary<string, string> result = container.GetKeysFromPrefix(prefix);

            // Assert
            Assert.Equal(2, result.Count());
            Assert.True(result.ContainsKey("bar"));
            Assert.True(result.ContainsKey("baz"));
            Assert.Equal("foo[bar]", result["bar"]);
            Assert.Equal("foo[baz]", result["baz"]);
        }

        [Fact]
        public void GetKeysFromPrefix_MixedDotsAndBrackets()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "foo[bar]baz", "something[other]", "foo.baz", "foot[hello]", "fo[nothing]", "foo" });
            string prefix = "foo";

            // Act
            IDictionary<string, string> result = container.GetKeysFromPrefix(prefix);

            // Assert
            Assert.Equal(2, result.Count());
            Assert.True(result.ContainsKey("bar"));
            Assert.True(result.ContainsKey("baz"));
            Assert.Equal("foo[bar]", result["bar"]);
            Assert.Equal("foo.baz", result["baz"]);
        }

        [Fact]
        public void GetKeysFromPrefix_AllValues()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "foo[bar]baz", "something[other]", "foo.baz", "foot[hello]", "fo[nothing]", "foo" });
            string prefix = "";

            // Act
            IDictionary<string, string> result = container.GetKeysFromPrefix(prefix);

            // Assert
            Assert.Equal(4, result.Count());
            Assert.Equal("foo", result["foo"]);
            Assert.Equal("something", result["something"]);
            Assert.Equal("foot", result["foot"]);
            Assert.Equal("fo", result["fo"]);
        }

        [Fact]
        public void GetKeysFromPrefix_PrefixNotFound()
        {
            // Arrange
            var container = new PrefixContainer(new[] { "foo[bar]", "something[other]", "foo.baz", "foot[hello]", "fo[nothing]", "foo" });
            string prefix = "notfound";

            // Act
            IDictionary<string, string> result = container.GetKeysFromPrefix(prefix);

            // Assert
            Assert.Empty(result);
        }
    }
}

================================================
FILE: test/Common/Routing/DefaultInlineConstraintResolverTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if ASPNETWEBAPI
using System.Web.Http.Routing.Constraints;
#else
using System.Web.Mvc.Routing.Constraints;
#endif
using Microsoft.TestCommon;

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    public class DefaultInlineConstraintResolverTest
    {
        [Fact]
        public void ResolveConstraint_AlphaConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("alpha");

            Assert.IsType<AlphaRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_BoolConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("bool");

            Assert.IsType<BoolRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_CompoundConstraintIsNotRegistered()
        {
            Assert.Null(new DefaultInlineConstraintResolver().ResolveConstraint("compound"));
        }

        [Fact]
        public void ResolveConstraint_DateTimeConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("datetime");

            Assert.IsType<DateTimeRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_DecimalConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("decimal");

            Assert.IsType<DecimalRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_DoubleConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("double");

            Assert.IsType<DoubleRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_EnumNameConstraintIsNotRegistered()
        {
            Assert.Null(new DefaultInlineConstraintResolver().ResolveConstraint("enumname"));
        }

        [Fact]
        public void ResolveConstraint_EnumValueConstraintIsNotRegistered()
        {
            Assert.Null(new DefaultInlineConstraintResolver().ResolveConstraint("enumvalue"));
        }

        [Fact]
        public void ResolveConstraint_FloatConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("float");

            Assert.IsType<FloatRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_GuidConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("guid");

            Assert.IsType<GuidRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_IntConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("int");

            Assert.IsType<IntRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_LengthConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("length(5)");

            var lengthRouteConstraint = Assert.IsType<LengthRouteConstraint>(constraint);
            Assert.Equal(5, lengthRouteConstraint.Length);
        }

        [Fact]
        public void ResolveConstraint_LengthRangeConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("length(5, 10)");

            LengthRouteConstraint lengthConstraint = Assert.IsType<LengthRouteConstraint>(constraint);
            Assert.Equal(5, lengthConstraint.MinLength);
            Assert.Equal(10, lengthConstraint.MaxLength);
        }

        [Fact]
        public void ResolveConstraint_LongRangeConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("long");

            Assert.IsType<LongRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_MaxConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("max(10)");

            var maxRouteConstraint = Assert.IsType<MaxRouteConstraint>(constraint);
            Assert.Equal(10, maxRouteConstraint.Max);
        }

        [Fact]
        public void ResolveConstraint_MaxLengthConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("maxlength(10)");

            var maxLengthRouteConstraint = Assert.IsType<MaxLengthRouteConstraint>(constraint);
            Assert.Equal(10, maxLengthRouteConstraint.MaxLength);
        }

        [Fact]
        public void ResolveConstraint_MinConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("min(3)");

            var minRouteConstraint = Assert.IsType<MinRouteConstraint>(constraint);
            Assert.Equal(3, minRouteConstraint.Min);
        }

        [Fact]
        public void ResolveConstraint_MinLengthConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("minlength(3)");

            var minLengthRouteConstraint = Assert.IsType<MinLengthRouteConstraint>(constraint);
            Assert.Equal(3, minLengthRouteConstraint.MinLength);
        }

        [Fact]
        public void ResolveConstraint_OptionalConstraintIsNotRegistered()
        {
            Assert.Null(new DefaultInlineConstraintResolver().ResolveConstraint("optional"));
        }

        [Fact]
        public void ResolveConstraint_RangeConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("range(5, 10)");

            RangeRouteConstraint rangeConstraint = Assert.IsType<RangeRouteConstraint>(constraint);
            Assert.Equal(5, rangeConstraint.Min);
            Assert.Equal(10, rangeConstraint.Max);
        }

        [Fact]
        public void ResolveConstraint_RegexConstraint()
        {
            var constraint = new DefaultInlineConstraintResolver().ResolveConstraint("regex(abc,defg)");

            RegexRouteConstraint regexConstraint = Assert.IsType<RegexRouteConstraint>(constraint);
            Assert.Equal("abc,defg", regexConstraint.Pattern);
        }

        [Fact]
        public void ResolveConstraint_IntConstraintWithArgument_Throws()
        {
            Assert.Throws<InvalidOperationException>(
                () => new DefaultInlineConstraintResolver().ResolveConstraint("int(5)"),
               "Could not find a constructor for constraint type 'IntRouteConstraint' with the following number of parameters: 1.");
        }

        [Fact]
        public void ResolveConstraint_SupportsCustomConstraints()
        {
            var resolver = new DefaultInlineConstraintResolver();
            resolver.ConstraintMap.Add("custom", typeof(IntRouteConstraint));

            var constraint = resolver.ResolveConstraint("custom");

            Assert.IsType<IntRouteConstraint>(constraint);
        }

        [Fact]
        public void ResolveConstraint_CustomConstraintThatDoesNotImplementouteConstraintInterfact_Throws()
        {
            var resolver = new DefaultInlineConstraintResolver();
            resolver.ConstraintMap.Add("custom", typeof(string));

            Assert.Throws<InvalidOperationException>(
                () => resolver.ResolveConstraint("custom"),
#if ASPNETWEBAPI
                "The constraint type 'String' which is mapped to constraint key 'custom' must implement the IHttpRouteConstraint interface.");
#else
                "The constraint type 'String' which is mapped to constraint key 'custom' must implement the IRouteConstraint interface.");
#endif
        }
    }
}

================================================
FILE: test/Common/Routing/DirectRouteBuilderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
#if ASPNETWEBAPI
using System.Net.Http;
using System.Web.Http.Routing.Constraints;
#else
using System.Web.Mvc.Routing.Constraints;
#endif
using Microsoft.TestCommon;
using Moq;

#if ASPNETWEBAPI
using TActionDescriptor = System.Web.Http.Controllers.HttpActionDescriptor;
using TParsedRoute = System.Web.Http.Routing.HttpParsedRoute;
using TRouteValueDictionary = System.Web.Http.Routing.HttpRouteValueDictionary;
#else
using TActionDescriptor = System.Web.Mvc.ActionDescriptor;
using TParsedRoute = System.Web.Mvc.Routing.ParsedRoute;
using TRouteValueDictionary = System.Web.Routing.RouteValueDictionary;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    public class DirectRouteBuilderTests
    {
        [Fact]
        public void CreateRoute_ValidatesConstraintType_TRouteConstraint()
        {
            // Arrange
            var actions = GetActions();
            var builder = new DirectRouteBuilder(actions, targetIsAction: true);

            var constraint = new AlphaRouteConstraint();
            var constraints = new TRouteValueDictionary();
            constraints.Add("custom", constraint);
            builder.Constraints = constraints;

            // Act
            var routeEntry = builder.Build();

            // Assert
            Assert.NotNull(routeEntry.Route.Constraints["custom"]);
        }

        [Fact]
        public void BuildRoute_ValidatesConstraintType_StringRegex()
        {
            // Arrange
            var actions = GetActions();
            var builder = new DirectRouteBuilder(actions, targetIsAction: true);

            var constraint = "product|products";
            var constraints = new TRouteValueDictionary();
            constraints.Add("custom", constraint);
            builder.Constraints = constraints;

            // Act
            var routeEntry = builder.Build();

            // Assert
            Assert.NotNull(routeEntry.Route.Constraints["custom"]);
        }

        [Fact]
        public void BuildRoute_ValidatesConstraintType_InvalidType()
        {
            // Arrange
            var actions = GetActions();
            var builder = new DirectRouteBuilder(actions, targetIsAction: true);

            var constraint = new Uri("http://localhost/");
            var constraints = new TRouteValueDictionary();
            constraints.Add("custom", constraint);

            builder.Constraints = constraints;
            builder.Template = "c/{id}";

#if ASPNETWEBAPI
            string expectedMessage =
                "The constraint entry 'custom' on the route with route template 'c/{id}' " +
                "must have a string value or be of a type which implements 'System.Web.Http.Routing.IHttpRouteConstraint'.";
#else
            string expectedMessage =
                "The constraint entry 'custom' on the route with route template 'c/{id}' " +
                "must have a string value or be of a type which implements 'System.Web.Routing.IRouteConstraint'.";
#endif

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => builder.Build(), expectedMessage);
        }

        [Fact]
        public void BuildRoute_ValidatesAllowedParameters()
        {
            // Arrange
            var actions = GetActions();
            var builder = new MockDirectRouteBuilder(actions, targetIsAction: true);
            builder.Template = "{a}/{b}";

            // Act
            RouteEntry entry = builder.Build();

            // Assert
            Assert.NotNull(entry);
            Assert.Equal(1, builder.TimesValidateParametersCalled);
        }

        [Theory]
        [InlineData("{controller}", true)]
        [InlineData("{controller}", false)]
        [InlineData("{z}-abc-{controller}", true)]
        public void BuildRoute_ControllerParameterNotAllowed(string template, bool targetIsAction)
        {
            // Arrange
            var actions = GetActions();

            var expectedMessage =
                "A direct route cannot use the parameter 'controller'. " +
                "Specify a literal path in place of this parameter to create a route to a controller.";

            var builder = new MockDirectRouteBuilder(actions, targetIsAction);
            builder.Template = template;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => builder.Build(), expectedMessage);
            Assert.Equal(1, builder.TimesValidateParametersCalled);
        }

        [Fact]
        public void BuildRoute_ActionParameterAllowed_OnControllerRoute()
        {
            // Arrange
            var actions = GetActions();
            var builder = new MockDirectRouteBuilder(actions, targetIsAction: false);
            builder.Template = "{a}/{action}";

            // Act
            RouteEntry entry = builder.Build();

            // Assert
            Assert.NotNull(entry);
            Assert.Equal(1, builder.TimesValidateParametersCalled);
        }

        [Theory]
        [InlineData("{action}")]
        [InlineData("api/yy-{action}")]
        public void BuildRoute_ActionNotAllowed_OnActionRoute(string template)
        {
            // Arrange
            var actions = GetActions();

            var expectedMessage =
                "A direct route for an action method cannot use the parameter 'action'. " +
                "Specify a literal path in place of this parameter to create a route to the action.";

            var builder = new MockDirectRouteBuilder(actions, targetIsAction: true);
            builder.Template = template;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => builder.Build(), expectedMessage);
            Assert.Equal(1, builder.TimesValidateParametersCalled);
        }

#if ASPNETWEBAPI
        private IReadOnlyCollection<TActionDescriptor> GetActions()
        {
            var actions = new List<TActionDescriptor>()
            {
                new Mock<TActionDescriptor>().Object,
            };

            return actions.AsReadOnly();
        }
#else
        private IReadOnlyCollection<TActionDescriptor> GetActions()
        {
            var action = new Mock<ActionDescriptor>();
            action.SetupGet(a => a.ControllerDescriptor).Returns(new Mock<ControllerDescriptor>().Object);
            var actions = new List<ActionDescriptor>()
            {
                action.Object,
            };

            return actions.AsReadOnly();
        }
#endif

        private class MockDirectRouteBuilder : DirectRouteBuilder
        {
            public MockDirectRouteBuilder(IReadOnlyCollection<TActionDescriptor> actionDescriptors, bool targetIsAction)
                : base(actionDescriptors, targetIsAction)
            {
            }

            public int TimesValidateParametersCalled
            {
                get;
                private set;
            }

            internal override void ValidateParameters(TParsedRoute parsedRoute)
            {
                TimesValidateParametersCalled++;
                base.ValidateParameters(parsedRoute);
            }
        }
    }
}


================================================
FILE: test/Common/Routing/InlineRouteTemplateParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
#if ASPNETWEBAPI
using System.Web.Http.Routing.Constraints;
#else
using System.Web.Mvc.Routing.Constraints;
using System.Web.Routing;
#endif
using Microsoft.TestCommon;

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    public class InlineRouteTemplateParserTests
    {
#if ASPNETWEBAPI
        private static readonly RouteParameter OptionalParameter = RouteParameter.Optional;
#else
        private static readonly UrlParameter OptionalParameter = UrlParameter.Optional;
#endif

        [Fact]
        public void ParseRouteTemplate_ChainedConstraintAndDefault()
        {
            var result = Act(@"hello/{param:int=111111}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            Assert.Equal("111111", result.Defaults["param"]);
            Assert.IsType<IntRouteConstraint>(result.Constraints["param"]);
        }

        [Fact]
        public void ParseRouteTemplate_ChainedConstraintWithArgumentsAndDefault()
        {
            var result = Act(@"hello/{param:regex(\d+)=111111}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            Assert.Equal("111111", result.Defaults["param"]);
            var regexRouteConstraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\d+", regexRouteConstraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_ChainedConstraintAndOptional()
        {
            var result = Act(@"hello/{param:int?}");

            Assert.Equal("hello/{param}", result.RouteUrl);

            Assert.Equal(OptionalParameter, result.Defaults["param"]);

            var constraint = Assert.IsType<OptionalRouteConstraint>(result.Constraints["param"]);
            Assert.IsType<IntRouteConstraint>(constraint.InnerConstraint);
        }

        [Fact]
        public void ParseRouteTemplate_ChainedConstraintWithArgumentsAndOptional()
        {
            var result = Act(@"hello/{param:regex(\d+)?}");

            Assert.Equal("hello/{param}", result.RouteUrl);

            Assert.Equal(OptionalParameter, result.Defaults["param"]);

            var constraint = Assert.IsType<OptionalRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\d+", Assert.IsType<RegexRouteConstraint>(constraint.InnerConstraint).Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_ChainedConstraints()
        {
            var result = Act(@"hello/{param:regex(\d+):regex(\w+)}");

            Assert.Equal("hello/{param}", result.RouteUrl);

            CompoundRouteConstraint constraint = Assert.IsType<CompoundRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\d+", Assert.IsType<RegexRouteConstraint>(constraint.Constraints.ElementAt(0)).Pattern);
            Assert.Equal(@"\w+", Assert.IsType<RegexRouteConstraint>(constraint.Constraints.ElementAt(1)).Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_Constraint()
        {
            var result = Act(@"hello/{param:regex(\d+)}");

            Assert.Equal("hello/{param}", result.RouteUrl);

            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\d+", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_ConstraintsDefaultsAndOptionalsInMultipleSections()
        {
            var result = Act(@"some/url-{p1:alpha:length(3)=hello}/{p2=abc}/{p3?}");

            Assert.Equal("some/url-{p1}/{p2}/{p3}", result.RouteUrl);

            Assert.Equal("hello", result.Defaults["p1"]);
            Assert.Equal("abc", result.Defaults["p2"]);
            Assert.Equal(OptionalParameter, result.Defaults["p3"]);

            CompoundRouteConstraint constraint = Assert.IsType<CompoundRouteConstraint>(result.Constraints["p1"]);
            Assert.IsType<AlphaRouteConstraint>(constraint.Constraints.ElementAt(0));
            Assert.IsType<LengthRouteConstraint>(constraint.Constraints.ElementAt(1));
        }

        [Fact]
        public void ParseRouteTemplate_NoTokens()
        {
            var result = Act("hello/world");

            Assert.Equal("hello/world", result.RouteUrl);
        }

        [Fact]
        public void ParseRouteTemplate_OptionalParam()
        {
            var result = Act("hello/{param?}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            Assert.Equal(OptionalParameter, result.Defaults["param"]);
        }

        [Fact]
        public void ParseRouteTemplate_ParamDefault()
        {
            var result = Act("hello/{param=world}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            Assert.Equal("world", result.Defaults["param"]);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithClosingBraceInPattern()
        {
            var result = Act(@"hello/{param:regex(\})}");

            Assert.Equal("hello/{param}", result.RouteUrl);

            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\}", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithClosingParenInPattern()
        {
            var result = Act(@"hello/{param:regex(\))}");

            Assert.Equal("hello/{param}", result.RouteUrl);

            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\)", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithColonInPattern()
        {
            var result = Act(@"hello/{param:regex(:)}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@":", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithCommaInPattern()
        {
            var result = Act(@"hello/{param:regex(\w,\w)}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\w,\w", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithEqualsSignInPattern()
        {
            var result = Act(@"hello/{param:regex(=)}");

            Assert.Equal("hello/{param}", result.RouteUrl);

            Assert.DoesNotContain("param", result.Defaults.Keys);
            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"=", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithOpenBraceInPattern()
        {
            var result = Act(@"hello/{param:regex(\{)}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\{", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithOpenParenInPattern()
        {
            var result = Act(@"hello/{param:regex(\()}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\(", constraint.Pattern);
        }

        [Fact]
        public void ParseRouteTemplate_RegexConstraintWithQuestionMarkInPattern()
        {
            var result = Act(@"hello/{param:regex(\?)}");

            Assert.Equal("hello/{param}", result.RouteUrl);
            Assert.DoesNotContain("param", result.Defaults.Keys);
            var constraint = Assert.IsType<RegexRouteConstraint>(result.Constraints["param"]);
            Assert.Equal(@"\?", constraint.Pattern);
        }


        private ParseResult Act(string template)
        {
            var result = new ParseResult();
 #if ASPNETWEBAPI
            result.Constraints = new HttpRouteValueDictionary();
            result.Defaults = new HttpRouteValueDictionary();
#else
            result.Constraints = new RouteValueDictionary();
            result.Defaults = new RouteValueDictionary();
#endif
            result.RouteUrl = InlineRouteTemplateParser.ParseRouteTemplate(template, result.Defaults, result.Constraints, new DefaultInlineConstraintResolver());
            return result;
        }

        struct ParseResult
        {
            public string RouteUrl;
 #if ASPNETWEBAPI
            public HttpRouteValueDictionary Defaults;
            public HttpRouteValueDictionary Constraints;
#else
            public RouteValueDictionary Defaults;
            public RouteValueDictionary Constraints;
#endif
        }
    }
}


================================================
FILE: test/Common/Routing/RouteConstraintsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
#if ASPNETWEBAPI
using System.Net.Http;
using System.Web.Http.Routing.Constraints;
#else
using System.Web.Mvc.Routing.Constraints;
using System.Web.Routing;
#endif
using Microsoft.TestCommon;
using Moq;

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    public class RouteConstraintsTests
    {
        [Theory]
        [InlineData(42, true)]
        [InlineData("42", true)]
        [InlineData(3.14, false)]
        [InlineData("43.567", false)]
        [InlineData("42a", false)]
        public void IntRouteConstraintTests(object parameterValue, bool expected)
        {
            var constraint = new IntRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(42, true)]
        [InlineData("42", true)]
        [InlineData("9223372036854775807", true)]
        [InlineData(3.14, false)]
        [InlineData("43.567", false)]
        [InlineData("42a", false)]
        public void LongRouteConstraintTests(object parameterValue, bool expected)
        {
            var constraint = new LongRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(@"^\d{3}-\d{3}-\d{4}$", "406-555-0123", true)]
        [InlineData(@"^\d{3}$", "1234", false)]
        public void RegexRouteConstraintTests(string pattern, string parameterValue, bool expected)
        {
            var constraint = new RegexRouteConstraint(pattern);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("alpha", true)]
        [InlineData("a1pha", false)]
        [InlineData("", true)]
        public void AlphaRouteConstraintTests(string parameterValue, bool expected)
        {
            var constraint = new AlphaRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(long.MinValue, long.MaxValue, 2, true)]
        [InlineData(3, 5, 4, true)]
        [InlineData(3, 5, 5, true)]
        [InlineData(3, 5, 3, true)]
        [InlineData(3, 5, 6, false)]
        [InlineData(3, 5, 2, false)]
        [InlineData(3, 1, 2, false)]
        public void RangeRouteConstraintTests(long min, long max, int parameterValue, bool expected)
        {
            var constraint = new RangeRouteConstraint(min, max);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(3, 4, true)]
        [InlineData(3, 3, true)]
        [InlineData(3, 2, false)]
        public void MinRouteConstraintTests(long min, int parameterValue, bool expected)
        {
            var constraint = new MinRouteConstraint(min);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(3, 2, true)]
        [InlineData(3, 3, true)]
        [InlineData(3, 4, false)]
        public void MaxRouteConstraintTests(long max, int parameterValue, bool expected)
        {
            var constraint = new MaxRouteConstraint(max);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(3, "1234", true)]
        [InlineData(3, "123", true)]
        [InlineData(3, "12", false)]
        [InlineData(3, "", false)]
        public void MinLengthRouteConstraintTests(int min, string parameterValue, bool expected)
        {
            var constraint = new MinLengthRouteConstraint(min);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(3, "", true)]
        [InlineData(3, "12", true)]
        [InlineData(3, "123", true)]
        [InlineData(3, "1234", false)]
        public void MaxLengthRouteConstraintTests(int min, string parameterValue, bool expected)
        {
            var constraint = new MaxLengthRouteConstraint(min);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(3, "123", true)]
        [InlineData(3, "1234", false)]
        public void LengthRouteConstraint_ExactLength_Tests(int length, string parameterValue, bool expected)
        {
            var constraint = new LengthRouteConstraint(length);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(3, 5, "12", false)]
        [InlineData(3, 5, "123", true)]
        [InlineData(3, 5, "1234", true)]
        [InlineData(3, 5, "12345", true)]
        [InlineData(3, 5, "123456", false)]
        public void LengthRouteConstraint_Range_Tests(int min, int max, string parameterValue, bool expected)
        {
            var constraint = new LengthRouteConstraint(min, max);
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("12345678-1234-1234-1234-123456789012", false, true)]
        [InlineData("12345678-1234-1234-1234-123456789012", true, true)]
        [InlineData("12345678901234567890123456789012", false, true)]
        [InlineData("not-parseable-as-guid", false, false)]
        [InlineData(12, false, false)]
        public void GuidRouteConstraintTests(object parameterValue, bool parseBeforeTest, bool expected)
        {
            if (parseBeforeTest)
            {
                parameterValue = Guid.Parse(parameterValue.ToString());
            }
            var constraint = new GuidRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("3.14", true)]
        [InlineData(3.14f, true)]
        [InlineData("not-parseable-as-float", false)]
        [InlineData(false, false)]
        [InlineData("1.79769313486232E+300", false)]
        public void FloatRouteConstraintTests(object parameterValue, bool expected)
        {
            var constraint = new FloatRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("3.14", true)]
        [InlineData(3.14f, true)]
        [InlineData("1.79769313486232E+300", true)]
        [InlineData("not-parseable-as-double", false)]
        [InlineData(false, false)]
        public void DoubleRouteConstraintTests(object parameterValue, bool expected)
        {
            var constraint = new DoubleRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("3.14", true)]
        [InlineData("9223372036854775808.9223372036854775808", true)]
        [InlineData("1.79769313486232E+300", false)]
        [InlineData("not-parseable-as-decimal", false)]
        [InlineData(false, false)]
        public void DecimalRouteConstraintTests(object parameterValue, bool expected)
        {
            var constraint = new DecimalRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("12/25/2009", true)]
        [InlineData("12/25/2009 11:45:00 PM", true)]
        [InlineData("11:45:00 PM", true)]
        [InlineData("2009-05-12T11:45:00Z", true)]
        [InlineData("not-parseable-as-date", false)]
        [InlineData(false, false)]
        public void DateTimeRouteConstraint(object parameterValue, bool expected)
        {
            var constraint = new DateTimeRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("true", true)]
        [InlineData("false", true)]
        [InlineData(true, true)]
        [InlineData(false, true)]
        [InlineData(1, false)]
        [InlineData("not-parseable-as-bool", false)]
        public void BoolRouteConstraint(object parameterValue, bool expected)
        {
            var constraint = new BoolRouteConstraint();
            var actual = TestValue(constraint, parameterValue);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(null, false, true)]
        [InlineData("pass", true, true)]
        [InlineData("fail", true, false)]
        public void OptionalRouteConstraintTests(object parameterValue, bool shouldCallInner, bool expected)
        {
            // Arrange
            var inner = MockConstraintWithResult((string)parameterValue != "fail");

            // Act
            var constraint = new OptionalRouteConstraint(inner.Object);
#if ASPNETWEBAPI
            var optionalParameter = RouteParameter.Optional;
#else
            var optionalParameter = UrlParameter.Optional;
#endif
            var actual = TestValue(constraint, parameterValue ?? optionalParameter, route =>
            {
                route.Defaults.Add("fake", optionalParameter);
            });

            // Assert
            Assert.Equal(expected, actual);

            var timeMatchShouldHaveBeenCalled = shouldCallInner
                ? Times.Once()
                : Times.Never();

            AssertMatchWasCalled(inner, timeMatchShouldHaveBeenCalled);
        }

        [Theory]
        [InlineData(true, true, true)]
        [InlineData(true, false, false)]
        [InlineData(false, true, false)]
        [InlineData(false, false, false)]
        public void CompoundRouteConstraintTests(bool inner1Result, bool inner2Result, bool expected)
        {
            // Arrange
            var inner1 = MockConstraintWithResult(inner1Result);

            var inner2 = MockConstraintWithResult(inner2Result);

            // Act
            var constraint = new CompoundRouteConstraint(new[] { inner1.Object, inner2.Object });
            var actual = TestValue(constraint, null);

            // Assert
            Assert.Equal(expected, actual);
        }

#if ASPNETWEBAPI
        static Expression<Func<IHttpRouteConstraint, bool>> ConstraintMatchMethodExpression =
            c => c.Match(It.IsAny<HttpRequestMessage>(), It.IsAny<IHttpRoute>(), It.IsAny<string>(), It.IsAny<IDictionary<string, object>>(), It.IsAny<HttpRouteDirection>());

        private static Mock<IHttpRouteConstraint> MockConstraintWithResult(bool result)
        {
            var mock = new Mock<IHttpRouteConstraint>();
            mock.Setup(ConstraintMatchMethodExpression)
                 .Returns(result)
                 .Verifiable();
            return mock;
        }

        private static void AssertMatchWasCalled(Mock<IHttpRouteConstraint> mock, Times times)
        {
            mock.Verify(ConstraintMatchMethodExpression, times);
        }

        private static bool TestValue(IHttpRouteConstraint constraint, object value, Action<IHttpRoute> routeConfig = null)
        {
            HttpRequestMessage httpRequestMessage = new HttpRequestMessage();

            HttpRoute httpRoute = new HttpRoute();
            if (routeConfig != null)
            {
                routeConfig(httpRoute);
            }
            const string parameterName = "fake";
            HttpRouteValueDictionary values = new HttpRouteValueDictionary { { parameterName, value } };
            const HttpRouteDirection httpRouteDirection = HttpRouteDirection.UriResolution;

            return constraint.Match(httpRequestMessage, httpRoute, parameterName, values, httpRouteDirection);
        }
#else
        static Expression<Func<IRouteConstraint, bool>> ConstraintMatchMethodExpression =
            c => c.Match(It.IsAny<HttpContextBase>(), It.IsAny<Route>(), It.IsAny<string>(), It.IsAny<RouteValueDictionary>(), It.IsAny<RouteDirection>());

        private static Mock<IRouteConstraint> MockConstraintWithResult(bool result)
        {
            var mock = new Mock<IRouteConstraint>();
            mock.Setup(ConstraintMatchMethodExpression)
                 .Returns(result)
                 .Verifiable();
            return mock;
        }

        private static void AssertMatchWasCalled(Mock<IRouteConstraint> mock, Times times)
        {
            mock.Verify(ConstraintMatchMethodExpression, times);
        }

        private static bool TestValue(IRouteConstraint constraint, object value, Action<Route> routeConfig = null)
        {
            var context = new Mock<HttpContextBase>();

            Route route = new Route("", null);
            route.Defaults = new RouteValueDictionary();

            if (routeConfig != null)
            {
                routeConfig(route);
            }
            const string parameterName = "fake";
            RouteValueDictionary values = new RouteValueDictionary { { parameterName, value } };
            const RouteDirection routeDirection = RouteDirection.IncomingRequest;

            return constraint.Match(context.Object, route, parameterName, values, routeDirection);
        }
#endif

    }
}

================================================
FILE: test/Common/Routing/RouteFactoryAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
#if ASPNETWEBAPI
using System.Web.Http.Controllers;
#endif
using Microsoft.TestCommon;
using Moq;

#if ASPNETWEBAPI
using TActionDescriptor = System.Web.Http.Controllers.HttpActionDescriptor;
using TRoute = System.Web.Http.Routing.IHttpRoute;
using TRouteDictionary = System.Collections.Generic.IDictionary<string, object>;
using TRouteDictionaryConcrete = System.Web.Http.Routing.HttpRouteValueDictionary;
#else
using TActionDescriptor = System.Web.Mvc.ActionDescriptor;
using TRoute = System.Web.Routing.Route;
using TRouteDictionary = System.Web.Routing.RouteValueDictionary;
using TRouteDictionaryConcrete = System.Web.Routing.RouteValueDictionary;
#endif

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    public class RouteFactoryAttributeTests
    {
        [Fact]
        public void TemplateGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            string expectedTemplate = "RouteTemplate";
            RouteFactoryAttribute product = CreateProductUnderTest(expectedTemplate);

            // Act
            string template = product.Template;

            // Assert
            Assert.Same(expectedTemplate, template);
        }

        [Fact]
        public void NameGet_ReturnsNull()
        {
            // Arrange
            RouteFactoryAttribute product = CreateProductUnderTest();

            // Act
            string name = product.Name;

            // Assert
            Assert.Null(name);
        }

        [Fact]
        public void OrderGet_ReturnsZero()
        {
            // Arrange
            RouteFactoryAttribute product = CreateProductUnderTest();

            // Act
            int order = product.Order;

            // Assert
            Assert.Equal(0, order);
        }

        [Fact]
        public void ConstraintsGet_ReturnsNull()
        {
            // Arrange
            RouteFactoryAttribute product = CreateProductUnderTest();

            // Act
            TRouteDictionary constraints = product.Constraints;

            // Assert
            Assert.Null(constraints);
        }

        [Fact]
        public void CreateRoute_DelegatesToContextCreateBuilderBuild()
        {
            // Arrange
            string expectedTemplate = "RouteTemplate";
            IDirectRouteFactory product = CreateProductUnderTest(expectedTemplate);

            RouteEntry expectedEntry = CreateEntry();

            IDirectRouteBuilder builder = CreateBuilder(() => expectedEntry);
            DirectRouteFactoryContext context = CreateContext((template) => template == expectedTemplate ? builder :
                new DirectRouteBuilder(new TActionDescriptor[0], targetIsAction: true));

            // Act
            RouteEntry entry = product.CreateRoute(context);

            // Assert
            Assert.Same(expectedEntry, entry);
        }

        [Fact]
        public void CreateRoute_IfContextIsNull_Throws()
        {
            // Arrange
            DirectRouteFactoryContext context = null;
            IDirectRouteFactory product = CreateProductUnderTest();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.CreateRoute(context), "context");
        }

        [Fact]
        public void CreateRoute_UsesNamePropertyWhenBuilding()
        {
            // Arrange
            string expectedName = "RouteName";
            RouteFactoryAttribute product = CreateProductUnderTest();
            product.Name = expectedName;

            string name = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                name = builder.Name;
                return null;
            });
            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(expectedName, name);
        }

        [Fact]
        public void CreateRoute_UsesOrderPropertyWhenBuilding()
        {
            // Arrange
            int expectedOrder = 123;
            RouteFactoryAttribute product = CreateProductUnderTest();
            product.Order = expectedOrder;

            int order = 0;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                order = builder.Order;
                return null;
            });
            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Equal(expectedOrder, order);
        }

        [Fact]
        public void CreateRoute_IfBuilderDefaultsIsNull_UsesDefaultsPropertyWhenBuilding()
        {
            // Arrange
            TRouteDictionary expectedDefaults = new TRouteDictionaryConcrete();
            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.Defaults).Returns(expectedDefaults);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary defaults = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                defaults = builder.Defaults;
                return null;
            });
            Assert.Null(builder.Defaults); // Guard
            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(expectedDefaults, defaults);
        }

        [Fact]
        public void CreateRoute_IfBuilderDefaultsIsNotNull_UpdatesDefaultsFromPropertyWhenBuilding()
        {
            // Arrange
            TRouteDictionary existingDefaults = new TRouteDictionaryConcrete();
            string existingDefaultKey = "ExistingDefaultKey";
            object existingDefaultValue = "ExistingDefault";
            existingDefaults.Add(existingDefaultKey, existingDefaultValue);
            string conflictingDefaultKey = "ConflictingDefaultKey";
            object oldConflictingDefaultValue = "OldConflictingDefault";
            existingDefaults.Add(conflictingDefaultKey, oldConflictingDefaultValue);

            TRouteDictionary additionalDefaults = new TRouteDictionaryConcrete();
            string additionalDefaultKey = "NewDefaultKey";
            string additionalDefaultValue = "NewDefault";
            additionalDefaults.Add(additionalDefaultKey, additionalDefaultValue);
            string newConflictingDefaultValue = "NewConflictingDefault";
            additionalDefaults.Add(conflictingDefaultKey, newConflictingDefaultValue);

            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.Defaults).Returns(additionalDefaults);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary defaults = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                defaults = builder.Defaults;
                return null;
            });

            builder.Defaults = existingDefaults;

            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(existingDefaults, defaults);
            Assert.Equal(3, defaults.Count);
            Assert.True(defaults.ContainsKey(existingDefaultKey));
            Assert.Same(existingDefaultValue, defaults[existingDefaultKey]);
            Assert.True(defaults.ContainsKey(conflictingDefaultKey));
            Assert.Same(newConflictingDefaultValue, defaults[conflictingDefaultKey]);
            Assert.True(defaults.ContainsKey(additionalDefaultKey));
            Assert.Same(additionalDefaultValue, defaults[additionalDefaultKey]);
        }

        [Fact]
        public void CreateRoute_IfBuilderConstraintsIsNotNullAndDefaultsPropertyIsNull_UsesBuilderDefaults()
        {
            // Arrange
            TRouteDictionary existingDefaults = new TRouteDictionaryConcrete();

            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.Defaults).Returns((TRouteDictionary)null);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary defaults = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                defaults = builder.Defaults;
                return null;
            });

            builder.Defaults = existingDefaults;

            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(existingDefaults, defaults);
        }

        [Fact]
        public void CreateRoute_IfBuilderConstraintsIsNull_UsesConstraintsPropertyWhenBuilding()
        {
            // Arrange
            TRouteDictionary expectedConstraints = new TRouteDictionaryConcrete();
            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.Constraints).Returns(expectedConstraints);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary constraints = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                constraints = builder.Constraints;
                return null;
            });
            Assert.Null(builder.Constraints); // Guard
            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(expectedConstraints, constraints);
        }

        [Fact]
        public void CreateRoute_IfBuilderConstraintsIsNotNull_UpdatesConstraintsFromPropertyWhenBuilding()
        {
            // Arrange
            TRouteDictionary existingConstraints = new TRouteDictionaryConcrete();
            string existingConstraintKey = "ExistingConstraintKey";
            object existingConstraintValue = "ExistingConstraint";
            existingConstraints.Add(existingConstraintKey, existingConstraintValue);
            string conflictingConstraintKey = "ConflictingConstraintKey";
            object oldConflictingConstraintValue = "OldConflictingConstraint";
            existingConstraints.Add(conflictingConstraintKey, oldConflictingConstraintValue);

            TRouteDictionary additionalConstraints = new TRouteDictionaryConcrete();
            string additionalConstraintKey = "NewConstraintKey";
            string additionalConstraintValue = "NewConstraint";
            additionalConstraints.Add(additionalConstraintKey, additionalConstraintValue);
            string newConflictingConstraintValue = "NewConflictingConstraint";
            additionalConstraints.Add(conflictingConstraintKey, newConflictingConstraintValue);

            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.Constraints).Returns(additionalConstraints);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary constraints = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                constraints = builder.Constraints;
                return null;
            });

            builder.Constraints = existingConstraints;

            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(existingConstraints, constraints);
            Assert.Equal(3, constraints.Count);
            Assert.True(constraints.ContainsKey(existingConstraintKey));
            Assert.Same(existingConstraintValue, constraints[existingConstraintKey]);
            Assert.True(constraints.ContainsKey(conflictingConstraintKey));
            Assert.Same(newConflictingConstraintValue, constraints[conflictingConstraintKey]);
            Assert.True(constraints.ContainsKey(additionalConstraintKey));
            Assert.Same(additionalConstraintValue, constraints[additionalConstraintKey]);
        }

        [Fact]
        public void CreateRoute_IfBuilderConstraintsIsNotNullAndConstraintsPropertyIsNull_UsesBuilderConstraints()
        {
            // Arrange
            TRouteDictionary existingConstraints = new TRouteDictionaryConcrete();

            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.Constraints).Returns((TRouteDictionary)null);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary constraints = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                constraints = builder.Constraints;
                return null;
            });

            builder.Constraints = existingConstraints;

            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(existingConstraints, constraints);
        }

        [Fact]
        public void CreateRoute_IfBuilderDataTokensIsNull_UsesDataTokensPropertyWhenBuilding()
        {
            // Arrange
            TRouteDictionary expectedDataTokens = new TRouteDictionaryConcrete();
            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.DataTokens).Returns(expectedDataTokens);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary dataTokens = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                dataTokens = builder.DataTokens;
                return null;
            });
            Assert.Null(builder.DataTokens); // Guard
            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(expectedDataTokens, dataTokens);
        }

        [Fact]
        public void CreateRoute_IfBuilderDataTokensIsNotNull_UpdatesDataTokensFromPropertyWhenBuilding()
        {
            // Arrange
            TRouteDictionary existingDataTokens = new TRouteDictionaryConcrete();
            string existingDataTokenKey = "ExistingDataTokenKey";
            object existingDataTokenValue = "ExistingDataToken";
            existingDataTokens.Add(existingDataTokenKey, existingDataTokenValue);
            string conflictingDataTokenKey = "ConflictingDataTokenKey";
            object oldConflictingDataTokenValue = "OldConflictingDataToken";
            existingDataTokens.Add(conflictingDataTokenKey, oldConflictingDataTokenValue);

            TRouteDictionary additionalDataTokens = new TRouteDictionaryConcrete();
            string additionalDataTokenKey = "NewDataTokenKey";
            string additionalDataTokenValue = "NewDataToken";
            additionalDataTokens.Add(additionalDataTokenKey, additionalDataTokenValue);
            string newConflictingDataTokenValue = "NewConflictingDataToken";
            additionalDataTokens.Add(conflictingDataTokenKey, newConflictingDataTokenValue);

            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.DataTokens).Returns(additionalDataTokens);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary dataTokens = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                dataTokens = builder.DataTokens;
                return null;
            });

            builder.DataTokens = existingDataTokens;

            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(existingDataTokens, dataTokens);
            Assert.Equal(3, dataTokens.Count);
            Assert.True(dataTokens.ContainsKey(existingDataTokenKey));
            Assert.Same(existingDataTokenValue, dataTokens[existingDataTokenKey]);
            Assert.True(dataTokens.ContainsKey(conflictingDataTokenKey));
            Assert.Same(newConflictingDataTokenValue, dataTokens[conflictingDataTokenKey]);
            Assert.True(dataTokens.ContainsKey(additionalDataTokenKey));
            Assert.Same(additionalDataTokenValue, dataTokens[additionalDataTokenKey]);
        }

        [Fact]
        public void CreateRoute_IfBuilderDataTokensIsNotNullAndDataTokensPropertyIsNull_UsesBuilderDataTokens()
        {
            // Arrange
            TRouteDictionary existingDataTokens = new TRouteDictionaryConcrete();

            Mock<RouteFactoryAttribute> productMock = CreateProductUnderTestMock();
            productMock.SetupGet(p => p.DataTokens).Returns((TRouteDictionary)null);
            IDirectRouteFactory product = productMock.Object;

            RouteEntry expectedEntry = CreateEntry();

            TRouteDictionary dataTokens = null;
            IDirectRouteBuilder builder = null;
            builder = CreateBuilder(() =>
            {
                dataTokens = builder.DataTokens;
                return null;
            });

            builder.DataTokens = existingDataTokens;

            DirectRouteFactoryContext context = CreateContext((i) => builder);

            // Act
            RouteEntry ignore = product.CreateRoute(context);

            // Assert
            Assert.Same(existingDataTokens, dataTokens);
        }

        [Fact]
        public void AttributeUsage_IsAsSpecified()
        {
            // Act
            AttributeUsageAttribute usage = (AttributeUsageAttribute)Attribute.GetCustomAttribute(
                typeof(RouteFactoryAttribute), typeof(AttributeUsageAttribute));

            // Assert
            Assert.NotNull(usage);
            Assert.Equal(AttributeTargets.Class | AttributeTargets.Method, usage.ValidOn);
            Assert.False(usage.Inherited);
            Assert.True(usage.AllowMultiple);
        }

        private static IDirectRouteBuilder CreateBuilder(Func<RouteEntry> build)
        {
            return new LambdaDirectRouteBuilder(build);
        }

        private static DirectRouteFactoryContext CreateContext(Func<string, IDirectRouteBuilder> createBuilder)
        {
            return new LambdaDirectRouteFactoryContext(createBuilder);
        }

        private static RouteEntry CreateEntry()
        {
#if ASPNETWEBAPI
            TRoute route = new Mock<TRoute>(MockBehavior.Strict).Object;
#else
            TRoute route = new Mock<TRoute>(MockBehavior.Strict, null, null).Object;
#endif
            return new RouteEntry("IgnoreEntry", route);
        }

        private static RouteFactoryAttribute CreateProductUnderTest()
        {
            return CreateProductUnderTest("IgnoreTemplate");
        }

        private static RouteFactoryAttribute CreateProductUnderTest(string template)
        {
            return CreateProductUnderTestMock(template).Object;
        }

        private static Mock<RouteFactoryAttribute> CreateProductUnderTestMock()
        {
            return CreateProductUnderTestMock("IgnoreTemplate");
        }

        private static Mock<RouteFactoryAttribute> CreateProductUnderTestMock(string template)
        {
            Mock<RouteFactoryAttribute> mock = new Mock<RouteFactoryAttribute>(template);
            mock.CallBase = true;
            return mock;
        }

        private class LambdaDirectRouteFactoryContext : DirectRouteFactoryContext
        {
            private readonly Func<string, IDirectRouteBuilder> _createBuilder;

            public LambdaDirectRouteFactoryContext(Func<string, IDirectRouteBuilder> createBuilder)
#if ASPNETWEBAPI
                : base(null, new TActionDescriptor[] { new Mock<TActionDescriptor>().Object },
                new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object,
                targetIsAction: true)
#else
                : base(null, null, new TActionDescriptor[] { CreateStubActionDescriptor() },
                new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object, targetIsAction: true)
#endif
            {
                Contract.Assert(createBuilder != null);
                _createBuilder = createBuilder;
            }

            internal override IDirectRouteBuilder CreateBuilderInternal(string template)
            {
                return _createBuilder.Invoke(template);
            }

#if !ASPNETWEBAPI
            private static ActionDescriptor CreateStubActionDescriptor()
            {
                Mock<ActionDescriptor> mock = new Mock<TActionDescriptor>();
                mock.Setup(m => m.ControllerDescriptor).Returns(new Mock<ControllerDescriptor>().Object);
                return mock.Object;
            }
#endif
        }

        private class LambdaDirectRouteBuilder : DirectRouteBuilder
        {
            private readonly Func<RouteEntry> _build;

            public LambdaDirectRouteBuilder(Func<RouteEntry> build)
                : base(new TActionDescriptor[0], targetIsAction: true)
            {
                Contract.Assert(build != null);
                _build = build;
            }

            public override RouteEntry Build()
            {
                return _build.Invoke();
            }
        }
    }
}


================================================
FILE: test/Common/Routing/RoutePrecedenceTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if !ASPNETWEBAPI
using System.Web.Routing;
#endif
using Microsoft.TestCommon;

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    public class RoutePrecedenceTests
    {
        [Theory]
        [InlineData("Employees/{id}", "Employees/{id}")]
        [InlineData("abc", "def")]
        [InlineData("{x:alpha}", "{x:int}")]
        public void Compute_IsEqual(string xTemplate, string yTemplate)
        {
            // Arrange & Act
            var xPrededence = Compute(xTemplate);
            var yPrededence = Compute(yTemplate);

            // Assert
            Assert.Equal(xPrededence, yPrededence);
        }

        [Theory]
        [InlineData("abc", "a{x}")]
        [InlineData("abc", "{x}c")]
        [InlineData("abc", "{x:int}")]
        [InlineData("abc", "{x}")]
        [InlineData("abc", "{*x}")]
        [InlineData("{x:int}", "{x}")]
        [InlineData("{x:int}", "{*x}")]
        [InlineData("a{x}", "{x}")]
        [InlineData("{x}c", "{x}")]
        [InlineData("a{x}", "{*x}")]
        [InlineData("{x}c", "{*x}")]
        [InlineData("{x}", "{*x}")]
        [InlineData("{*x:maxlength(10)}", "{*x}")]
        [InlineData("abc/def", "abc/{x:int}")]
        [InlineData("abc/def", "abc/{x}")]
        [InlineData("abc/def", "abc/{*x}")]
        [InlineData("abc/{x:int}", "abc/{x}")]
        [InlineData("abc/{x:int}", "abc/{*x}")]
        [InlineData("abc/{x}", "abc/{*x}")]
        [InlineData("{x}/{y:int}", "{x}/{y}")]
        public void Compute_IsLessThan(string xTemplate, string yTemplate)
        {
            // Arrange & Act
            var xPrededence = Compute(xTemplate);
            var yPrededence = Compute(yTemplate);

            // Assert
            Assert.True(xPrededence < yPrededence);
        }

        private static decimal Compute(string template)
        {
            DefaultInlineConstraintResolver resolver = new DefaultInlineConstraintResolver();
#if ASPNETWEBAPI
            HttpRouteValueDictionary defaults = new HttpRouteValueDictionary();
            HttpRouteValueDictionary constraints = new HttpRouteValueDictionary();
#else
            RouteValueDictionary defaults = new RouteValueDictionary();
            RouteValueDictionary constraints = new RouteValueDictionary();
#endif
            string standardRouteTemplate = InlineRouteTemplateParser.ParseRouteTemplate(template,
                defaults, constraints, new DefaultInlineConstraintResolver());
            var parsedRoute = RouteParser.Parse(standardRouteTemplate);
            return RoutePrecedence.Compute(parsedRoute, constraints);
        }
    }
}

================================================
FILE: test/Common/Routing/SubRouteCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

#if !ASPNETWEBAPI
using System.Web.Routing;
#endif
using Microsoft.TestCommon;
using Moq;

#if ASPNETWEBAPI
namespace System.Web.Http.Routing
#else
namespace System.Web.Mvc.Routing
#endif
{
    public class SubRouteCollectionTest
    {
#if ASPNETWEBAPI
        [Fact]
        public void SubRouteCollection_Throws_OnDuplicateNamedRoute_WebAPI()
        {
            // Arrange
            var collection = new SubRouteCollection();
            var route1 = new HttpRoute("api/Person");
            var route2 = new HttpRoute("api/Car");

            collection.Add(new RouteEntry("route", route1));

            var expectedError =
                "A route named 'route' is already in the route collection. Route names must be unique.\r\n\r\n" +
                "Duplicates:" + Environment.NewLine +
                "api/Car" + Environment.NewLine +
                "api/Person";

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => collection.Add(new RouteEntry("route", route2)), expectedError);
        }
#else
        [Fact]
        public void SubRouteCollection_Throws_OnDuplicateNamedRoute_MVC()
        {
            // Arrange
            var collection = new SubRouteCollection();
            var route1 = new Route("Home/Index", new Mock<IRouteHandler>().Object);
            var route2 = new Route("Person/Index", new Mock<IRouteHandler>().Object);

            collection.Add(new RouteEntry("route", route1));

            var expectedError =
                "A route named 'route' is already in the route collection. Route names must be unique.\r\n\r\n" +
                "Duplicates:" + Environment.NewLine +
                "Person/Index" + Environment.NewLine +
                "Home/Index";

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => collection.Add(new RouteEntry("route", route2)), expectedError);
        }
#endif
    }
}


================================================
FILE: test/Common/TaskHelpersExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Threading.Tasks
{
    public class TaskHelpersExtensionsTest
    {
        // ----------------------------------------------------------------
        //   Task<object> Task<T>.CastToObject()

        [Fact, ForceGC]
        public async Task ConvertFromTaskOfStringShouldSucceed()
        {
            // Arrange
            var task = Task.FromResult("StringResult")
                .CastToObject();

            // Act
            var result = await task;

            // Assert
            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
            Assert.Equal("StringResult", (string)result);
        }

        [Fact, ForceGC]
        public async Task ConvertFromTaskOfIntShouldSucceed()
        {
            // Arrange
            var task = Task.FromResult(123)
                .CastToObject();

            // Act
            var result = await task;

            // Assert
            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
            Assert.Equal(123, (int)result);
        }

        [Fact, ForceGC]
        public async Task ConvertFromFaultedTaskOfObjectShouldBeHandled()
        {
            // Arrange
            var task = TaskHelpers.FromError<object>(new InvalidOperationException())
                .CastToObject();

            // Act & Assert
            await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal(TaskStatus.Faulted, task.Status);
        }

        [Fact, ForceGC]
        public async Task ConvertFromCancelledTaskOfStringShouldBeHandled()
        {
            // Arrange
            var task = TaskHelpers.Canceled<string>()
                .CastToObject();

            // Act & Assert
            await Assert.ThrowsAsync<TaskCanceledException>(() => task);
            Assert.Equal(TaskStatus.Canceled, task.Status);
        }

        // ----------------------------------------------------------------
        //   Task<object> Task.CastToObject()

        [Fact, ForceGC]
        public async Task ConvertFromTaskShouldSucceed()
        {
            // Arrange
            var task = TaskHelpers.Completed()
                .CastToObject();

            // Act
            var result = await task;

            // Assert
            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
            Assert.Null(result);
        }

        [Fact, ForceGC]
        public async Task ConvertFromFaultedTaskShouldBeHandled()
        {
            // Arrange
            var task = TaskHelpers.FromError(new InvalidOperationException())
                .CastToObject();

            // Act & Assert
            await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal(TaskStatus.Faulted, task.Status);
        }

        [Fact, ForceGC]
        public async Task ConvertFromCancelledTaskShouldBeHandled()
        {
            // Arrange
            var task = TaskHelpers.Canceled()
                .CastToObject();

            // Act & Assert
            await Assert.ThrowsAsync<TaskCanceledException>(() => task);
            Assert.Equal(TaskStatus.Canceled, task.Status);
        }

        // -----------------------------------------------------------------
        //  bool Task.TryGetResult(Task<TResult>, out TResult)

        [Fact, ForceGC]
        public void TryGetResult_CompleteTask_ReturnsTrueAndGivesResult()
        {
            // Arrange
            var task = Task.FromResult(42);

            // Act
            int value;
            bool result = task.TryGetResult(out value);

            // Assert
            Assert.True(result);
            Assert.Equal(42, value);
        }

        [Fact, ForceGC]
        public void TryGetResult_FaultedTask_ReturnsFalse()
        {
            // Arrange
            var task = TaskHelpers.FromError<int>(new Exception());

            // Act
            int value;
            bool result = task.TryGetResult(out value);

            // Assert
            Assert.False(result);
            var ex = task.Exception; // Observe the task exception
        }

        [Fact, ForceGC]
        public void TryGetResult_CanceledTask_ReturnsFalse()
        {
            // Arrange
            var task = TaskHelpers.Canceled<int>();

            // Act
            int value;
            bool result = task.TryGetResult(out value);

            // Assert
            Assert.False(result);
        }

        [Fact, ForceGC]
        public Task TryGetResult_IncompleteTask_ReturnsFalse()
        {
            // Arrange
            var incompleteTask = new Task<int>(() => 42);

            // Act
            int value;
            bool result = incompleteTask.TryGetResult(out value);

            // Assert
            Assert.False(result);

            incompleteTask.Start();
            return incompleteTask;  // Make sure the task gets observed
        }
    }
}


================================================
FILE: test/Common/TaskHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Threading.Tasks
{
    public class TaskHelpersTest
    {
        // -----------------------------------------------------------------
        //  TaskHelpers.Canceled

        [Fact]
        public void Canceled_ReturnsCanceledTask()
        {
            Task result = TaskHelpers.Canceled();

            Assert.NotNull(result);
            Assert.True(result.IsCanceled);
        }

        // -----------------------------------------------------------------
        //  TaskHelpers.Canceled<T>

        [Fact]
        public void Canceled_Generic_ReturnsCanceledTask()
        {
            Task<string> result = TaskHelpers.Canceled<string>();

            Assert.NotNull(result);
            Assert.True(result.IsCanceled);
        }

        // -----------------------------------------------------------------
        //  TaskHelpers.Completed

        [Fact]
        public void Completed_ReturnsCompletedTask()
        {
            Task result = TaskHelpers.Completed();

            Assert.NotNull(result);
            Assert.Equal(TaskStatus.RanToCompletion, result.Status);
        }

        // -----------------------------------------------------------------
        //  TaskHelpers.FromError

        [Fact]
        public void FromError_ReturnsFaultedTaskWithGivenException()
        {
            var exception = new Exception();

            Task result = TaskHelpers.FromError(exception);

            Assert.NotNull(result);
            Assert.True(result.IsFaulted);
            Assert.Same(exception, result.Exception.InnerException);
        }

        // -----------------------------------------------------------------
        //  TaskHelpers.FromError<T>

        [Fact]
        public void FromError_Generic_ReturnsFaultedTaskWithGivenException()
        {
            var exception = new Exception();

            Task<string> result = TaskHelpers.FromError<string>(exception);

            Assert.NotNull(result);
            Assert.True(result.IsFaulted);
            Assert.Same(exception, result.Exception.InnerException);
        }
    }
}


================================================
FILE: test/Common/TypeExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using Microsoft.TestCommon;

namespace System
{
    public class TypeExtensionsTest
    {
        [Theory]
        [InlineData(typeof(int), false)]
        [InlineData(typeof(string), true)]
        [InlineData(typeof(DateTime), false)]
        [InlineData(typeof(int?), true)]
        [InlineData(typeof(IEnumerable), true)]
        [InlineData(typeof(int[]), true)]
        [InlineData(typeof(string[]), true)]
        public void IsNullable_Returns_ExpectedValue(Type type, bool expectedResult)
        {
            Assert.Equal(expectedResult, type.IsNullable());
        }
    }
}


================================================
FILE: test/Common/UriQueryUtilityTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Net.Http.Formatting;
using System.Text;
using System.Web.Http;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class WebUtilityTest
    {
        public static TheoryDataSet<string, string, string> UriQueryData
        {
            get
            {
                return UriQueryTestData.UriQueryData;
            }
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(WebUtility),
                TypeAssert.TypeProperties.IsStatic | TypeAssert.TypeProperties.IsPublicVisibleClass);
        }

        [Fact]
        public void UrlEncode_ReturnsNull()
        {
            Assert.Null(WebUtility.UrlEncode(null));
        }

        [Fact]
        public void UrlDecode_ReturnsNull()
        {
            Assert.Null(WebUtility.UrlDecode(null));
        }

        [Fact]
        public void UrlDecode_ParsesEmptySegmentsCorrectly()
        {
            int iterations = 16;
            List<string> segments = new List<string>();

            for (int index = 1; index < iterations; index++)
            {
                segments.Add("&");
                string query = string.Join("", segments);
                NameValueCollection result = ParseQueryString(query);
                Assert.NotNull(result);

                // Because this is a NameValueCollection, the same name appears only once
                Assert.Single(result);

                // Values should be a comma separated list of empty strings
                string[] values = result[""].Split(new char[] { ',' });

                // We expect length+1 segment as the final '&' counts as a segment
                Assert.Equal(index + 1, values.Length);
                foreach (var value in values)
                {
                    Assert.Equal("", value);
                }
            }
        }

        [Theory]
        [InlineData("N", "N", "")]
        [InlineData("%26", "&", "")]
        [InlineData("foo=%u0026", "foo", "%u0026")]
        [PropertyData("UriQueryData")]
        public void UrlDecode_ParsesCorrectly(string segment, string resultName, string resultValue)
        {
            int iterations = 16;
            List<string> segments = new List<string>();

            for (int index = 1; index < iterations; index++)
            {
                segments.Add(segment);
                string query = CreateQuery(segments.ToArray());
                NameValueCollection result = ParseQueryString(query);
                Assert.NotNull(result);

                // Because this is a NameValueCollection, the same name appears only once
                Assert.Single(result);

                // Values should be a comma separated list of resultValue
                string[] values = result[resultName].Split(new char[] { ',' });
                Assert.Equal(index, values.Length);
                foreach (var value in values)
                {
                    Assert.Equal(resultValue, value);
                }
            }
        }

        private static string CreateQuery(params string[] segments)
        {
            StringBuilder buffer = new StringBuilder();
            bool first = true;
            foreach (string segment in segments)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    buffer.Append('&');
                }

                buffer.Append(segment);
            }

            return buffer.ToString();
        }

        private static NameValueCollection ParseQueryString(string query)
        {
            return new FormDataCollection(query).ReadAsNameValueCollection();
        }
    }
}

================================================
FILE: test/Directory.Build.props
================================================
<Project>
  <Import Project="..\Directory.Build.props" />

  <PropertyGroup>
    <IsPackable>false</IsPackable>
    <IsTestProject>true</IsTestProject>
    <TargetFrameworkVersion
        Condition=" '$(MSBuildProjectName)' != 'Microsoft.TestCommon' AND
          '$(MSBuildProjectName)' != 'System.Net.Http.Formatting.ns1_3.Test' AND
          '$(MSBuildProjectName)' != 'System.Net.Http.Formatting.ns2_0.Test' ">v4.6.2</TargetFrameworkVersion>
  </PropertyGroup>
</Project>


================================================
FILE: test/Directory.Build.targets
================================================
<Project>
  <Import Project="..\Directory.Build.targets" />
  <Import Project="..\packages\xunit.runner.msbuild.2.4.2\**\xunit.runner.msbuild.props"
      Condition="$(IsTestProject) and '$(MSBuildRuntimeType)' != 'Core' and '$(TargetFrameworkIdentifier)' == '.NETFramework'" />

  <Target Name="Test" DependsOnTargets="_TestWithVSTest;_TestWithDotnetTest;_TestWithRunner" />

  <!-- Building with `dotnet msbuild`: Use VSTest target. -->
  <Target
    Name="_TestWithVSTest"
    Condition="$(IsTestProject) and '$(MSBuildRuntimeType)' == 'Core'">

    <MSBuild Projects="$(MSBuildProjectFullPath)" Targets="VSTest" Properties="VSTestNoBuild=true" />
  </Target>

  <!-- Building with `msbuild` and in outer build or building .NET Core: Use `dotnet test`. -->
  <Target
    Name="_TestWithDotnetTest"
    Condition="$(IsTestProject) and '$(MSBuildRuntimeType)' != 'Core' and '$(TargetFrameworkIdentifier)' != '.NETFramework'">

    <Exec Command='dotnet test --no-restore --no-build --verbosity minimal --configuration $(Configuration) "$(MSBuildProjectFullPath)"'/>
  </Target>

  <!-- Building with `msbuild`, in inner build, and building .NET Framework: Use xUnit MSBuild runner. -->
  <Target
    Name="_TestWithRunner"
    Condition="$(IsTestProject) and '$(MSBuildRuntimeType)' != 'Core' and '$(TargetFrameworkIdentifier)' == '.NETFramework'">

    <ItemGroup Condition=" '@(TestAssembly)' == '' ">
      <TestAssembly Include="$(TargetPath)" />
    </ItemGroup>
    <xunit Assemblies="@(TestAssembly)" />
  </Target>
</Project>


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/App.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
  <appSettings>
    <add key="Facebook:AppId" value="123456" />
    <add key="Facebook:AppSecret" value="abcdefg" />
    <add key="Facebook:AppNamespace" value="MyApp" />
    <add key="Facebook:AppUrl" value="https://apps.newfacebook.example.com/myapp" />
    <add key="Facebook:AuthorizationRedirectPath" value="~/Authorize/Index" />
    <add key="Facebook:CannotCreateCookiesRedirectPath" value="~/NoCookies/Index" />
  </appSettings>
</configuration>

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/DefaultFacebookClientProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Facebook;
using Microsoft.AspNet.Facebook.Providers;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class DefaultFacebookClientProviderTest
    {
        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(() => new DefaultFacebookClientProvider(null), "configuration");
        }

        [Fact]
        public void CreateClient_ReturnsClientWithAppIdAndAppSecret()
        {
            string appId = "654321";
            string appSecret = "abcdefg123";
            FacebookConfiguration config = new FacebookConfiguration
            {
                AppId = appId,
                AppSecret = appSecret
            };
            DefaultFacebookClientProvider clientProvider = new DefaultFacebookClientProvider(config);
            FacebookClient client = clientProvider.CreateClient();

            Assert.Equal(appId, client.AppId);
            Assert.Equal(appSecret, client.AppSecret);
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/DefaultFacebookPermissionServiceTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.AspNet.Facebook.Providers;
using Microsoft.AspNet.Facebook.Test.Helpers;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class DefaultFacebookPermissionServiceTest
    {
        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(() => new DefaultFacebookPermissionService(null), "configuration");
        }

        [Fact]
        public void GetUserPermissions_ThrowsArgumentNullException()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            DefaultFacebookPermissionService permissionService = new DefaultFacebookPermissionService(config);

            Assert.ThrowsArgumentNull(() => permissionService.GetUserPermissions(null, "accessToken"), "userId");
            Assert.ThrowsArgumentNull(() => permissionService.GetUserPermissions("userId", null), "accessToken");
        }

        [Fact]
        public void GetUserPermissions_CallsGetOnFacebookClientWithExpectedPath()
        {
            LocalFacebookClient localClient = new LocalFacebookClient();
            FacebookConfiguration config = MockHelpers.CreateConfiguration(localClient);
            DefaultFacebookPermissionService permissionService = new DefaultFacebookPermissionService(config);

            permissionService.GetUserPermissions("123456", "sampleAccessToken");

            Assert.Equal("me/permissions", localClient.Path);
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookAuthorizeAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookAuthorizeAttributeTest
    {
        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(() => new FacebookAuthorizeAttribute(null), "permissions");
        }

        [Fact]
        public void Permissions_ReturnsExpectedValues()
        {
            string[] permissions = new[] { "email", "user_likes", "friends_likes" };
            FacebookAuthorizeAttribute authorizeAttribute = new FacebookAuthorizeAttribute(permissions);
            HashSet<string> permissionSet = new HashSet<string>(permissions);

            Assert.True(permissionSet.SetEquals(authorizeAttribute.Permissions));
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookAuthorizeFilterHookTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web;
using System.Web.Mvc;
using Microsoft.AspNet.Facebook.Authorization;
using Microsoft.AspNet.Facebook.Test.Helpers;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookAuthorizeFilterHookTest
    {
        [Theory]
        [InlineData("~/home/cannotcreatecookies", "https://apps.facebook.com/DefaultAppId/home/cannotcreatecookies")]
        [InlineData(null, "https://www.facebook.com/")]
        public void OnAuthorization_CannotCreateCookiesHookRedirectsToConfigValueOrDefault(
            string cannotCreateCookiesRedirectPath,
            string expectedRedirectPath)
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions", cannotCreateCookiesRedirectPath);
            var authorizeFilter = new FacebookAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext("http://contoso.com?__fb_mps=true", "email");

            // Act
            authorizeFilter.OnAuthorization(context);
            var result = context.Result as JavaScriptRedirectResult;

            // Assert
            Assert.Equal(result.RedirectUrl.AbsoluteUri, new Uri(expectedRedirectPath).AbsoluteUri);
        }

        [Fact]
        public void OnAuthorization_OnlyTriggersCannotCreateCookiesHook()
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomDefaultAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext("http://contoso.com?__fb_mps=true", "email");

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.True(authorizeFilter.CannotCreateCookiesHookTriggered);
            Assert.False(authorizeFilter.PermissionPromptHookTriggered);
            Assert.False(authorizeFilter.DeniedPermissionPromptHookTriggered);
        }

        [Theory]
        [InlineData("http://contoso.com?__fb_mps=true", "email", true)]
        [InlineData("http://contoso.com", "email", false)]
        [InlineData("http://contoso.com?__fb_mps=true", null, false)]
        public void OnAuthorization_TriggersCannotCreateCookiesHook(string requestUrl,
                                                                    string permission,
                                                                    bool expectedTrigger)
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomDefaultAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext(requestUrl, permission);

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Equal(expectedTrigger, authorizeFilter.CannotCreateCookiesHookTriggered);
        }

        [Theory]
        [InlineData("http://contoso.com", "email", true)]
        [InlineData("http://contoso.com?error=access_denied", "email", false)]
        [InlineData("http://contoso.com?error=access_denied", null, false)]
        public void OnAuthorization_TriggersPreHookPriorToPermissionsDialog(string requestUrl,
                                                                            string permission,
                                                                            bool expectedTrigger)
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomDefaultAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext(requestUrl, permission);

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Equal(expectedTrigger, authorizeFilter.PermissionPromptHookTriggered);
        }

        [Theory]
        [InlineData("http://contoso.com", "email", true)]
        [InlineData("http://contoso.com?error=access_denied", "email", false)]
        [InlineData("http://contoso.com?error=access_denied", null, false)]
        public void OnAuthorization_TriggersDeniedHook(string requestUrl, string permission, bool expectedTrigger)
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomDefaultAuthorizeFilter(config);
            var persistedCookies = new HttpCookieCollection();
            persistedCookies.Add(
                new HttpCookie(
                    PermissionHelper.RequestedPermissionCookieName, permission ?? string.Empty));
            var context = BuildSignedAuthorizationContext(requestUrl, permission, persistedCookies);

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Equal(expectedTrigger, authorizeFilter.DeniedPermissionPromptHookTriggered);
        }

        [Theory]
        [InlineData("http://contoso.com", "email", "email", true)]
        [InlineData("http://contoso.com", "email", "foo", false)]
        [InlineData("http://contoso.com?error=access_denied", "email", "email", false)]
        [InlineData("http://contoso.com?error=access_denied", "email", "foo", false)]
        [InlineData("http://contoso.com?error=access_denied", null, "foo", false)]
        public void OnAuthorization_TriggersDeniedHookWithRevokedPermissions(string requestUrl,
                                                                             string permission,
                                                                             string permissionInStatus,
                                                                             bool expectedTrigger)
        {
            var rawPermissionsStatus = new Dictionary<string, string>
            {
                { "permission", permissionInStatus },
                { "status", "declined" },
            };

            var data = new List<IDictionary<string, string>>(new[] { rawPermissionsStatus });

            // Arrange
            var config = BuildConfiguration("~/home/permissions", userPermissionsStatus:
                new PermissionsStatus(data));
            var authorizeFilter = new CustomDefaultAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext(requestUrl, permission);

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Equal(expectedTrigger, authorizeFilter.DeniedPermissionPromptHookTriggered);
        }

        [Theory]
        [InlineData("http://contoso.com", "email", true)]
        [InlineData("http://contoso.com?error=access_denied", "email", false)]
        [InlineData("http://contoso.com?error=access_denied", null, false)]
        public void OnAuthorization_TriggersDeniedHookAfterPersistingRequestedPermissions(string requestUrl,
                                                                                          string permission,
                                                                                          bool expectedTrigger)
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomDefaultAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext(requestUrl, permission);

            // Act
            authorizeFilter.OnAuthorization(context);

            // Here we're acting like a browser and adding the responses cookies to the "next" request's cookies
            var responseCookies = context.HttpContext.Response.Cookies;
            foreach (var cookieName in responseCookies.AllKeys)
            {
                context.HttpContext.Request.Cookies.Add(responseCookies[cookieName]);
            }

            // Assert
            Assert.False(authorizeFilter.DeniedPermissionPromptHookTriggered);

            // Act 2
            // We're making a "second" request essentially
            authorizeFilter.OnAuthorization(context);

            // Assert 2
            Assert.Equal(expectedTrigger, authorizeFilter.DeniedPermissionPromptHookTriggered);
        }

        [Fact]
        public void OnAuthorization_CannotCreateCookiesHookNullFlows()
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomInvalidAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext("http://contoso.com?__fb_mps=true", "email");

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Null(context.Result);
        }

        [Fact]
        public void OnAuthorization_PreHookNullTreatedLikeIgnoreResult()
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomInvalidAuthorizeFilter(config);
            var context = BuildSignedAuthorizationContext("http://contoso.com", "email");

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Null(context.Result);
        }

        [Fact]
        public void OnAuthorization_DeniedHookNullTreatedLikeIgnoreResult()
        {
            // Arrange
            var config = BuildConfiguration("~/home/permissions");
            var authorizeFilter = new CustomInvalidAuthorizeFilter(config);
            var persistedCookies = new HttpCookieCollection();
            persistedCookies.Add(
                new HttpCookie(
                    PermissionHelper.RequestedPermissionCookieName, "email"));
            var context = BuildSignedAuthorizationContext("http://contoso.com", "email", persistedCookies);

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Null(context.Result);
        }

        [Fact]
        public void OnAuthorization_CannotCreateCookiesHookCustomActionResultIsContextsResult()
        {
            // Arrange
            var tempUrl = "http://contoso.com?__fb_mps=true";
            var config = BuildConfiguration("~/home/permissions");
            var cannotCreateCookiesHookResult = new RedirectResult(tempUrl);
            var authorizeFilter = new CustomReturningAuthorizeFilter(config,
                                                                     cannotCreateCookiesHookResult,
                                                                     new RedirectResult(tempUrl),
                                                                     new RedirectResult(tempUrl));
            var context = BuildSignedAuthorizationContext(tempUrl, "email");

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Equal(cannotCreateCookiesHookResult, context.Result);
        }

        [Fact]
        public void OnAuthorization_PreHookCustomActionResultIsContextsResult()
        {
            // Arrange
            var tempUrl = "http://contoso.com";
            var config = BuildConfiguration("~/home/permissions");
            var preHookResult = new RedirectResult(tempUrl);
            var authorizeFilter = new CustomReturningAuthorizeFilter(config,
                                                                     new RedirectResult(tempUrl),
                                                                     preHookResult,
                                                                     new RedirectResult(tempUrl));
            var context = BuildSignedAuthorizationContext(tempUrl, "email");

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Equal(preHookResult, context.Result);
        }

        [Fact]
        public void OnAuthorization_DeniedHookCustomActionResultIsContextsResult()
        {
            // Arrange
            var tempUrl = "http://contoso.com";
            var config = BuildConfiguration("~/home/permissions");
            var deniedHookResult = new RedirectResult(tempUrl);
            var authorizeFilter = new CustomReturningAuthorizeFilter(config,
                                                                     new RedirectResult(tempUrl),
                                                                     new RedirectResult(tempUrl),
                                                                     deniedHookResult);
            var persistedCookies = new HttpCookieCollection();
            persistedCookies.Add(
                new HttpCookie(
                    PermissionHelper.RequestedPermissionCookieName, "email"));
            var context = BuildSignedAuthorizationContext(tempUrl, "email", persistedCookies);

            // Act
            authorizeFilter.OnAuthorization(context);

            // Assert
            Assert.Equal(deniedHookResult, context.Result);
        }

        // Helper methods and classes
        private FacebookConfiguration BuildConfiguration(string authorizationRedirectPath,
                                                         string cannotCreateCookiesRedirectPath = null,
                                                         PermissionsStatus userPermissionsStatus = null)
        {
            var client = MockHelpers.CreateFacebookClient();
            var permissionService = MockHelpers.CreatePermissionService(new[] { "" }, userPermissionsStatus);
            var config = MockHelpers.CreateConfiguration(client, permissionService);
            config.AuthorizationRedirectPath = authorizationRedirectPath;

            if (cannotCreateCookiesRedirectPath != null)
            {
                config.CannotCreateCookieRedirectPath = cannotCreateCookiesRedirectPath;
            }

            return config;
        }

        private AuthorizationContext BuildSignedAuthorizationContext(string requestUrl,
                                                                     string permission,
                                                                     HttpCookieCollection requestCookies = null)
        {
            var permissions = permission == null ? new string[0] : new string[] { permission };

            var requestUri = new Uri(requestUrl);

            var context = new AuthorizationContext(
                MockHelpers.CreateControllerContext(new NameValueCollection
                {
                    {"signed_request", "exampleSignedRequest"}
                },
                HttpUtility.ParseQueryString(requestUri.Query),
                requestUri,
                requestCookies),
                MockHelpers.CreateActionDescriptor(new[] { new FacebookAuthorizeAttribute(permissions) }));

            return context;
        }

        private class CustomInvalidAuthorizeFilter : FacebookAuthorizeFilter
        {
            public CustomInvalidAuthorizeFilter(FacebookConfiguration config)
                : base(config)
            { }

            protected override void OnCannotCreateCookies(PermissionContext context)
            {
                context.Result = null;
            }

            protected override void OnPermissionPrompt(PermissionContext context)
            {
                context.Result = null;
            }

            protected override void OnDeniedPermissionPrompt(PermissionContext context)
            {
                context.Result = null;
            }
        }

        private class CustomDefaultAuthorizeFilter : FacebookAuthorizeFilter
        {
            public CustomDefaultAuthorizeFilter(FacebookConfiguration config)
                : base(config)
            { }

            public bool CannotCreateCookiesHookTriggered { get; private set; }
            public bool PermissionPromptHookTriggered { get; private set; }
            public bool DeniedPermissionPromptHookTriggered { get; private set; }

            protected override void OnCannotCreateCookies(PermissionContext context)
            {
                CannotCreateCookiesHookTriggered = true;

                base.OnCannotCreateCookies(context);
            }

            protected override void OnPermissionPrompt(PermissionContext context)
            {
                PermissionPromptHookTriggered = true;

                base.OnPermissionPrompt(context);
            }

            protected override void OnDeniedPermissionPrompt(PermissionContext context)
            {
                DeniedPermissionPromptHookTriggered = true;

                base.OnDeniedPermissionPrompt(context);
            }
        }

        private class CustomReturningAuthorizeFilter : FacebookAuthorizeFilter
        {
            private ActionResult _cannotCreateCookieResult;
            private ActionResult _promptPermissionHookResult;
            private ActionResult _deniedPermissionPromptHookResult;

            public CustomReturningAuthorizeFilter(FacebookConfiguration config,
                                                  ActionResult cannotCreateCookieResult,
                                                  ActionResult promptPermissionHookResult,
                                                  ActionResult deniedPermissionPromptHookResult)
                : base(config)
            {
                _cannotCreateCookieResult = cannotCreateCookieResult;
                _promptPermissionHookResult = promptPermissionHookResult;
                _deniedPermissionPromptHookResult = deniedPermissionPromptHookResult;
            }

            protected override void OnCannotCreateCookies(PermissionContext context)
            {
                context.Result = _cannotCreateCookieResult;
            }

            protected override void OnPermissionPrompt(PermissionContext context)
            {
                context.Result = _promptPermissionHookResult;
            }

            protected override void OnDeniedPermissionPrompt(PermissionContext context)
            {
                context.Result = _deniedPermissionPromptHookResult;
            }
        }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookAuthorizeFilterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Specialized;
using System.Web;
using System.Web.Mvc;
using Facebook;
using Microsoft.AspNet.Facebook.Authorization;
using Microsoft.AspNet.Facebook.Client;
using Microsoft.AspNet.Facebook.Providers;
using Microsoft.AspNet.Facebook.Test.Helpers;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookAuthorizeFilterTest
    {
        [Fact]
        public void AddCookieVerificationQuery_AddsQueryParams()
        {
            // Arrange
            var collection = new NameValueCollection();
            var filter = new CustomAuthorizeFilter();

            // Act
            filter.ExposedAddCookieVerificationQuery(collection);

            // Assert
            Assert.NotEmpty(collection);
        }

        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(
                () => new FacebookAuthorizeFilter(null),
                "config");
        }

        [Fact]
        public void OnAuthorization_ThrowsArgumentNullException()
        {
            FacebookConfiguration config = MockHelpers.CreateConfiguration();
            FacebookAuthorizeFilter authorizeFilter = new FacebookAuthorizeFilter(config);
            Assert.ThrowsArgumentNull(
                () => authorizeFilter.OnAuthorization(null),
                "filterContext");
        }

        [Fact]
        public void CreateRedirectResult_StringEncodesTheRedirectUrl()
        {
            Uri uri = new Uri("http://example.com?query=4'; alert('hello world')");
            FacebookConfiguration config = MockHelpers.CreateConfiguration();
            FacebookAuthorizeFilter authorizeFilter = new FacebookAuthorizeFilter(config);

            ContentResult result = Assert.IsType<JavaScriptRedirectResult>(authorizeFilter.CreateRedirectResult(uri));
            Assert.Equal("text/html", result.ContentType);
            Assert.Equal(@"<script>window.top.location = 'http://example.com/?query=4\u0027;%20alert(\u0027hello%20world\u0027)';</script>", result.Content);
        }

        [Fact]
        public void OnAuthorization_RedirectsToOAuthDialog_WhenSignedRequestIsNull()
        {
            FacebookConfiguration config = MockHelpers.CreateConfiguration();
            FacebookAuthorizeFilter authorizeFilter = new FacebookAuthorizeFilter(config);
            AuthorizationContext context = new AuthorizationContext(
                MockHelpers.CreateControllerContext(),
                MockHelpers.CreateActionDescriptor(new[] { new FacebookAuthorizeAttribute("email") }));

            authorizeFilter.OnAuthorization(context);

            ContentResult result = Assert.IsType<JavaScriptRedirectResult>(context.Result);
            Assert.Equal("text/html", result.ContentType);
            Assert.Equal(
                "<script>window.top.location = 'https://www.facebook.com/dialog/oauth?redirect_uri=https%3A%2F%2Fapps.facebook.com%2FDefaultAppId%2F\\u0026client_id=DefaultAppId';</script>",
                result.Content);
        }

        [Fact]
        public void OnAuthorization_RedirectsToOAuthDialog_ForMissingPermissions()
        {
            FacebookClient client = MockHelpers.CreateFacebookClient();
            IFacebookPermissionService permissionService = MockHelpers.CreatePermissionService(new[] { "" });
            FacebookConfiguration config = MockHelpers.CreateConfiguration(client, permissionService);
            FacebookAuthorizeFilter authorizeFilter = new FacebookAuthorizeFilter(config);
            AuthorizationContext context = new AuthorizationContext(
                MockHelpers.CreateControllerContext(new NameValueCollection
                {
                    {"signed_request", "exampleSignedRequest"}
                }),
                MockHelpers.CreateActionDescriptor(new[] { new FacebookAuthorizeAttribute("email", "user_likes") }));

            authorizeFilter.OnAuthorization(context);

            ContentResult result = Assert.IsType<ShowPromptResult>(context.Result);
            Assert.Equal("text/html", result.ContentType);
            Assert.Equal(
                "<script>window.top.location = 'https://www.facebook.com/dialog/oauth?redirect_uri=example.com';</script>",
                result.Content);
        }

        [Theory]
        [InlineData("http://example.com", "https://www.facebook.com/dialog/oauth?redirect_uri=example.com")]
        [InlineData("http://example.com?error=access_denied", "https://apps.facebook.com/DefaultAppId/home/permissions?originUrl=https%3a%2f%2fapps.facebook.com%2fDefaultAppId%2f\\u0026permissions=email")]
        public void OnAuthorization_RedirectsToAuthorizationRedirectPath_OnlyWhenUserDeniedGrantingPermissions(string requestUrl, string expectedRedirectUrl)
        {
            FacebookClient client = MockHelpers.CreateFacebookClient();
            IFacebookPermissionService permissionService = MockHelpers.CreatePermissionService(new[] { "" });
            FacebookConfiguration config = MockHelpers.CreateConfiguration(client, permissionService);
            config.AuthorizationRedirectPath = "~/home/permissions";
            FacebookAuthorizeFilter authorizeFilter = new FacebookAuthorizeFilter(config);
            AuthorizationContext context = new AuthorizationContext(
                MockHelpers.CreateControllerContext(new NameValueCollection
                {
                    {"signed_request", "exampleSignedRequest"}
                },
                null,
                new Uri(requestUrl)),
                MockHelpers.CreateActionDescriptor(new[] { new FacebookAuthorizeAttribute("email") }));

            authorizeFilter.OnAuthorization(context);

            ContentResult result = Assert.IsAssignableFrom<JavaScriptRedirectResult>(context.Result);

            Assert.Equal("text/html", result.ContentType);
            Assert.Equal(
                String.Format("<script>window.top.location = '{0}';</script>", expectedRedirectUrl),
                result.Content);
        }

        private class CustomAuthorizeFilter : FacebookAuthorizeFilter
        {
            public CustomAuthorizeFilter()
                : base(new FacebookConfiguration())
            {
            }

            public void ExposedAddCookieVerificationQuery(NameValueCollection queries)
            {
                AddCookieVerificationQuery(queries);
            }
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookClientExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading.Tasks;
using Microsoft.AspNet.Facebook.Client;
using Microsoft.AspNet.Facebook.Test.Helpers;
using Microsoft.AspNet.Facebook.Test.Types;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookClientExtensionsTest
    {
        [Fact]
        public async Task GetCurrentUserAsyncOfT_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetCurrentUserAsync<SimpleUser>();

            Assert.Equal("me?fields=id,name,picture.fields(url)", client.Path);
        }

        [Fact]
        public async Task GetCurrentUserAsync_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetCurrentUserAsync();

            Assert.Equal("me", client.Path);
        }

        [Fact]
        public async Task GetCurrentUserFriendsAsyncOfT_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetCurrentUserFriendsAsync<SimpleUser>();

            Assert.Equal("me/friends?fields=id,name,picture.fields(url)", client.Path);
        }

        [Fact]
        public async Task GetCurrentUserFriendsAsync_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetCurrentUserFriendsAsync();

            Assert.Equal("me/friends", client.Path);
        }

        [Fact]
        public async Task GetCurrentUserPermissionsAsync_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetCurrentUserPermissionsAsync();

            Assert.Equal("me/permissions", client.Path);
        }

        [Fact]
        public async Task GetCurrentUserPhotosAsyncOfT_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetCurrentUserPhotosAsync<UserPhoto>();

            Assert.Equal("me/photos?fields=name,picture,source", client.Path);
        }

        [Fact]
        public async Task GetCurrentUserStatusesAsyncOfT_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetCurrentUserStatusesAsync<UserStatus>();

            Assert.Equal("me/statuses?fields=message,time", client.Path);
        }

        [Fact]
        public async Task GetFacebookObjectAsyncOfT_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetFacebookObjectAsync<FacebookConnection<FacebookPicture>>("me/picture");

            Assert.Equal("me/picture?fields=url", client.Path);
        }

        [Fact]
        public async Task GetFacebookObjectAsync_CallsGetTaskAsyncWithTheExpectedPath()
        {
            LocalFacebookClient client = new LocalFacebookClient();
            await client.GetFacebookObjectAsync("me/notes");

            Assert.Equal("me/notes", client.Path);
        }

        [Fact]
        public async Task GetFacebookObjectAsyncOfT_ThrowArgumentNullExceptions()
        {
            LocalFacebookClient client = null;
            await Assert.ThrowsArgumentNullAsync(() => client.GetFacebookObjectAsync<SimpleUser>("me"), "client");

            client = new LocalFacebookClient();
            await Assert.ThrowsArgumentNullAsync(() => client.GetFacebookObjectAsync<SimpleUser>(null), "objectPath");
        }

        [Fact]
        public async Task GetFacebookObjectAsync_ThrowArgumentNullExceptions()
        {
            LocalFacebookClient client = null;
            await Assert.ThrowsArgumentNullAsync(() => client.GetFacebookObjectAsync("me"), "client");

            client = new LocalFacebookClient();
            await Assert.ThrowsArgumentNullAsync(() => client.GetFacebookObjectAsync(null), "objectPath");
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookConfigurationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookConfigurationTest
    {
        [Fact]
        public void Default_Constructor()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            Assert.Null(config.AppId);
            Assert.Null(config.AppNamespace);
            Assert.Null(config.AppSecret);
            Assert.NotNull(config.AppUrl);
            Assert.Null(config.AuthorizationRedirectPath);
            Assert.Null(config.CannotCreateCookieRedirectPath);
            Assert.Null(config.ClientProvider);
            Assert.Null(config.PermissionService);
            Assert.NotNull(config.Properties);
        }

        [Fact]
        public void AppUrl_FromAppId()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppId = "654321";
            Assert.Equal("https://apps.facebook.com/654321", config.AppUrl);
        }

        [Fact]
        public void AppUrl_FromAppNamespace()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppId = "654321";
            config.AppNamespace = "MyCustomApp";
            Assert.Equal("https://apps.facebook.com/MyCustomApp", config.AppUrl);
        }

        [Fact]
        public void AppUrl_FromCustomUrl()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppId = "654321";
            config.AppNamespace = "MyCustomApp";
            config.AppUrl = "http://apps.example.com/myapp";
            Assert.Equal("http://apps.example.com/myapp", config.AppUrl);
        }

        [Fact]
        public void LoadFromAppSettings_ReadsFromAppConfig()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.LoadFromAppSettings();
            Assert.Equal("123456", config.AppId);
            Assert.Equal("abcdefg", config.AppSecret);
            Assert.Equal("MyApp", config.AppNamespace);
            Assert.Equal("~/Authorize/Index", config.AuthorizationRedirectPath);
            Assert.Equal("~/NoCookies/Index", config.CannotCreateCookieRedirectPath);
            Assert.Equal("https://apps.newfacebook.example.com/myapp", config.AppUrl);
        }

        [Fact]
        public void AuthorizationRedirectPath_ThrowsArgumentException()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            Assert.ThrowsArgument(() => config.AuthorizationRedirectPath = "Home/Permissions", "value");
        }

        [Fact]
        public void CannotCreateCookieRedirectPath_ThrowsArgumentException()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            Assert.ThrowsArgument(() => config.CannotCreateCookieRedirectPath = "Home/Permissions", "value");
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookContextModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Web.Mvc;
using Microsoft.AspNet.Facebook.ModelBinders;
using Microsoft.AspNet.Facebook.Providers;
using Microsoft.AspNet.Facebook.Test.Helpers;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookContextModelBinderTest
    {
        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(() => new FacebookContextModelBinder(null), "config");
        }

        [Fact]
        public void BindModel_ReturnsExpectedFacebookContext_WhenSignedRequestComesFromForm()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppSecret = "3e29b24f825e737d97aed5eb62df5076";
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            FacebookContextModelBinder contextBinder = new FacebookContextModelBinder(config);
            ControllerContext controllerContext = MockHelpers.CreateControllerContext(new NameValueCollection
            {
                {"signed_request", "x1yDEgacN3N5iu23Ji8NLYp9LGO1-cUXKHTJQrMqzVQ.eyJhbGdvcml0aG0iOiJITUFDLVNIQTI1NiIsImV4cGlyZXMiOjEzNTM5MTMyMDAsImlzc3VlZF9hdCI6MTM1MzkwNzQ5Miwib2F1dGhfdG9rZW4iOiJBQUFGUlJPcWtwZ01CQURBSjNQZk5vNldXMlJ5WkFSQ1hjU0daQlhpNTBLTG9wRzFwYmFwc2M2aThKY3h6WkFQN1pDSnlpcXVHYlc3WXlCam1aQjh0UWpyelZ2VTNrYm44b3N3WXR5czkzTWdaRFpEIiwidXNlciI6eyJjb3VudHJ5IjoidXMiLCJsb2NhbGUiOiJlbl9VUyIsImFnZSI6eyJtaW4iOjIxfX0sInVzZXJfaWQiOiIxNzgyNTkwMSJ9"}
            });
            ModelBindingContext modelBindingContext = new ModelBindingContext();

            FacebookContext context = Assert.IsType<FacebookContext>(contextBinder.BindModel(controllerContext, modelBindingContext));

            Assert.NotNull((object)context.SignedRequest);
            Assert.NotNull(context.AccessToken);
            Assert.Equal("17825901", context.UserId);
        }

        [Fact]
        public void BindModel_ReturnsExpectedFacebookContext_WhenSignedRequestComesFromQuery()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppSecret = "3e29b24f825e737d97aed5eb62df5076";
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            FacebookContextModelBinder contextBinder = new FacebookContextModelBinder(config);
            ControllerContext controllerContext = MockHelpers.CreateControllerContext(
                null,
                new NameValueCollection
                {
                    {"signed_request", "x1yDEgacN3N5iu23Ji8NLYp9LGO1-cUXKHTJQrMqzVQ.eyJhbGdvcml0aG0iOiJITUFDLVNIQTI1NiIsImV4cGlyZXMiOjEzNTM5MTMyMDAsImlzc3VlZF9hdCI6MTM1MzkwNzQ5Miwib2F1dGhfdG9rZW4iOiJBQUFGUlJPcWtwZ01CQURBSjNQZk5vNldXMlJ5WkFSQ1hjU0daQlhpNTBLTG9wRzFwYmFwc2M2aThKY3h6WkFQN1pDSnlpcXVHYlc3WXlCam1aQjh0UWpyelZ2VTNrYm44b3N3WXR5czkzTWdaRFpEIiwidXNlciI6eyJjb3VudHJ5IjoidXMiLCJsb2NhbGUiOiJlbl9VUyIsImFnZSI6eyJtaW4iOjIxfX0sInVzZXJfaWQiOiIxNzgyNTkwMSJ9"}
                });

            FacebookContext context = Assert.IsType<FacebookContext>(contextBinder.BindModel(controllerContext, new ModelBindingContext()));

            Assert.NotNull((object)context.SignedRequest);
            Assert.NotNull(context.AccessToken);
            Assert.Equal("17825901", context.UserId);
        }

        [Fact]
        public void BindModel_ReturnsInvalidModelState_WhenSignedRequestIsNull()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppSecret = "abcdef";
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            FacebookContextModelBinder contextBinder = new FacebookContextModelBinder(config);
            ControllerContext controllerContext = MockHelpers.CreateControllerContext();
            ModelBindingContext modelBindingContext = new ModelBindingContext();

            object context = contextBinder.BindModel(controllerContext, modelBindingContext);

            Assert.Null(context);
            Assert.False(modelBindingContext.ModelState.IsValid);
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookQueryHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Microsoft.AspNet.Facebook.Client;
using Microsoft.AspNet.Facebook.Test.Types;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookQueryHelperTest
    {
        [Theory]
        [InlineData(typeof(SimpleUser), "?fields=id,name,picture.fields(url)")]
        [InlineData(typeof(UserWithFriends), "?fields=id,name,picture.fields(url),friends.fields(id,name,picture.fields(url))")]
        [InlineData(typeof(UserTypeWithIgnoredProperties), "?fields=id")]
        [InlineData(typeof(UserTypeWithRenamedProperties), "?fields=id,name,picture.fields(url)")]
        [InlineData(typeof(UserTypeWithFieldModifiers), "?fields=id,name,picture.type(large).fields(url),friends.limit(5).fields(id,name,picture.fields(url))")]
        public void GetFields_ReturnsExpectedQuery(Type modelType, string expectedQuery)
        {
            Assert.Equal(expectedQuery, FacebookQueryHelper.GetFields(modelType));
        }

        [Theory]
        [InlineData(typeof(UserWithUserFriends))]
        [InlineData(typeof(UserContainingFriendsWithCycle))]
        public void GetFields_ThrowsExceptionWhenDetectsACycle(Type modelType)
        {
            Assert.Throws<InvalidOperationException>(
                () => FacebookQueryHelper.GetFields(modelType),
                Resources.CircularReferenceNotSupported);
        }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookRealtimeControllerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Microsoft.AspNet.Facebook.Models;
using Microsoft.AspNet.Facebook.Providers;
using Microsoft.AspNet.Facebook.Realtime;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookRealtimeControllerTest
    {
        private const string AppSignatureHeader1 = "sha1=dbb5c0bfaac69ffee7b633e88d85e107fba7ecca";
        private const string AppSecret1 = "f8ad79c0081a80bb885e2b280c3f8442";
        private const string AppSignatureHeader2 = "sha1=3ee3a233ca0c872cae6b40d38a99dff26bf8eb27";
        private const string AppSecret2 = "134cfa3691d1f51c64e70700f397ed20";
        private const string ContentString = "{\"object\":\"user\",\"entry\":[{\"uid\":\"17825901\",\"id\":\"17825901\",\"time\":1352251746,\"changed_fields\":[\"likes\"]}]}";

        [Fact]
        public void Overriding_VerificationToken()
        {
            var userRealTimeController = new UserRealtimeCallbackController();
            Assert.Null(userRealTimeController.VerifyToken);

            userRealTimeController = new UserRealtimeCallbackController(null, "foo");
            Assert.Equal("foo", userRealTimeController.VerifyToken);

            userRealTimeController = new UserRealtimeCallbackController(null, String.Empty);
            Assert.Equal(String.Empty, userRealTimeController.VerifyToken);
        }

        [Theory]
        [InlineData("123456", "foo")]
        [InlineData("654321", "bar")]
        public async Task Get_ReturnsOk_WithValidParameters(string challenge, string verifyToken)
        {
            var userRealTimeController = new UserRealtimeCallbackController(null, verifyToken);
            userRealTimeController.Request = new HttpRequestMessage();
            var subscriptionVerification = new SubscriptionVerification
            {
                Challenge = challenge,
                Mode = "subscribe",
                Verify_Token = verifyToken
            };
            Assert.Equal(challenge, await userRealTimeController.Get(subscriptionVerification).Content.ReadAsStringAsync());
        }

        [Theory]
        [InlineData(null, "foo", HttpStatusCode.BadRequest)]
        [InlineData("654321", null, HttpStatusCode.BadRequest)]
        [InlineData("654321", "", HttpStatusCode.BadRequest)]
        [InlineData("", "bar", HttpStatusCode.BadRequest)]
        [InlineData("654321", "bar", HttpStatusCode.OK)]
        public void Get_ReturnsExpectedStatusCode(string challenge, string verifyToken, HttpStatusCode expectedStatusCode)
        {
            var userRealTimeController = new UserRealtimeCallbackController(null, verifyToken);
            userRealTimeController.Request = new HttpRequestMessage();
            var subscriptionVerification = new SubscriptionVerification
            {
                Challenge = challenge,
                Mode = "subscribe",
                Verify_Token = "bar"
            };
            Assert.Equal(expectedStatusCode, userRealTimeController.Get(subscriptionVerification).StatusCode);
        }

        [Theory]
        [InlineData(ContentString, AppSignatureHeader1, AppSecret1)]
        [InlineData(ContentString, AppSignatureHeader2, AppSecret2)]
        public async Task Post_ReturnsOk_WithValidParameters(string contentString, string headerValue, string appSecret)
        {
            var userRealTimeController = new UserRealtimeCallbackController(appSecret, null);
            userRealTimeController.Request = new HttpRequestMessage
            {
                Content = new StringContent(contentString, Encoding.UTF8, "text/json")
            };
            var request = userRealTimeController.Request;
            request.Headers.Add("X-Hub-Signature", headerValue);
            Assert.Equal(HttpStatusCode.OK, (await userRealTimeController.Post()).StatusCode);
        }

        [Theory]
        [InlineData(ContentString, AppSignatureHeader1, AppSecret2)]
        [InlineData(ContentString, AppSignatureHeader2, AppSecret1)]
        [InlineData(ContentString, null, AppSecret2)]
        [InlineData(ContentString, AppSignatureHeader1, null)]
        public async Task Post_ReturnsBadRequest_WithInValidParameters(string contentString, string headerValue, string AppSecret)
        {
            var userRealTimeController = new UserRealtimeCallbackController(AppSecret, null);
            userRealTimeController.Request = new HttpRequestMessage
            {
                Content = new StringContent(contentString, Encoding.UTF8, "text/json")
            };
            var request = userRealTimeController.Request;
            if (headerValue != null)
            {
                request.Headers.Add("X-Hub-Signature", headerValue);
            }
            Assert.Equal(HttpStatusCode.BadRequest, (await userRealTimeController.Post()).StatusCode);
        }

        private sealed class UserRealtimeCallbackController : FacebookRealtimeUpdateController
        {
            private string _verifyToken;

            public UserRealtimeCallbackController() : this(null, null) { }

            public UserRealtimeCallbackController(string appSecret, string verifyToken)
            {
                // Avoid base class's fallback to static GlobalFacebookConfiguration.
                var config = new FacebookConfiguration();
                config.ClientProvider = new DefaultFacebookClientProvider(config);
                config.PermissionService = new DefaultFacebookPermissionService(config);
                config.AppSecret = appSecret;

                FacebookConfiguration = config;
                _verifyToken = verifyToken;
            }

            public override string VerifyToken
            {
                get
                {
                    return _verifyToken;
                }
            }

            public override Task HandleUpdateAsync(ChangeNotification notification)
            {
                return Task.FromResult(0);
            }
        }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/FacebookRedirectContextModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Web.Mvc;
using Microsoft.AspNet.Facebook.ModelBinders;
using Microsoft.AspNet.Facebook.Providers;
using Microsoft.AspNet.Facebook.Test.Helpers;
using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class FacebookRedirectContextModelBinderTest
    {
        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(() => new FacebookContextModelBinder(null), "config");
        }

        [Fact]
        public void BindModel_ReturnsExpectedFacebookRedirectContext()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppId = "123456";
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            FacebookRedirectContextModelBinder redirectContextBinder = new FacebookRedirectContextModelBinder(config);
            ControllerContext controllerContext = MockHelpers.CreateControllerContext(
                null,
                new NameValueCollection
                {
                    {"originUrl", "https://apps.facebook.com/123456/home/index"},
                    {"permissions", "email,user_likes"}
                });
            ModelBindingContext modelBindingContext = new ModelBindingContext();

            FacebookRedirectContext context = Assert.IsType<FacebookRedirectContext>(redirectContextBinder.BindModel(controllerContext, modelBindingContext));

            Assert.Equal("https://apps.facebook.com/123456/home/index", context.OriginUrl);
            // Redirect URL should not have any permissions on it.  That's handled by the authorization filter.
            Assert.Equal("https://www.facebook.com/dialog/oauth?redirect_uri=https%3A%2F%2Fapps.facebook.com%2F123456%2Fhome%2Findex&client_id=123456", context.RedirectUrl);
            Assert.Equal(2, context.RequiredPermissions.Length);
            Assert.Equal("email", context.RequiredPermissions[0]);
            Assert.Equal("user_likes", context.RequiredPermissions[1]);
            Assert.Same(config, context.Configuration);
        }

        [Fact]
        public void BindModel_ReturnsInvalidModelState_WhenOriginUrlIsNull()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppId = "123456";
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            FacebookRedirectContextModelBinder redirectContextBinder = new FacebookRedirectContextModelBinder(config);
            ControllerContext controllerContext = MockHelpers.CreateControllerContext(
                null,
                new NameValueCollection
                {
                    {"permissions", "email,user_likes"}
                });
            ModelBindingContext modelBindingContext = new ModelBindingContext();

            FacebookRedirectContext context = Assert.IsType<FacebookRedirectContext>(redirectContextBinder.BindModel(controllerContext, modelBindingContext));
            Assert.False(modelBindingContext.ModelState.IsValid);
        }

        [Fact]
        public void BindModel_ReturnsInvalidModelState_WhenOriginUrlIsExternal()
        {
            FacebookConfiguration config = new FacebookConfiguration();
            config.AppId = "123456";
            config.ClientProvider = new DefaultFacebookClientProvider(config);
            FacebookRedirectContextModelBinder redirectContextBinder = new FacebookRedirectContextModelBinder(config);
            ControllerContext controllerContext = MockHelpers.CreateControllerContext(
                null,
                new NameValueCollection
                {
                    {"originUrl", "https://example.com/123456/home/index"},
                    {"permissions", "email,user_likes"}
                });
            ModelBindingContext modelBindingContext = new ModelBindingContext();

            FacebookRedirectContext context = Assert.IsType<FacebookRedirectContext>(redirectContextBinder.BindModel(controllerContext, modelBindingContext));
            Assert.False(modelBindingContext.ModelState.IsValid);
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/GlobalFacebookConfigurationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace Microsoft.AspNet.Facebook.Test
{
    public class GlobalFacebookConfigurationTest
    {
        [Fact]
        public void Default_Configuration()
        {
            FacebookConfiguration config = GlobalFacebookConfiguration.Configuration;
            Assert.Null(config.AppId);
            Assert.Null(config.AppNamespace);
            Assert.Null(config.AppSecret);
            Assert.NotNull(config.AppUrl);
            Assert.Null(config.AuthorizationRedirectPath);
            Assert.NotNull(config.ClientProvider);
            Assert.NotNull(config.PermissionService);
            Assert.NotNull(config.Properties);
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Helpers/LocalFacebookClient.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Threading.Tasks;
using Facebook;

namespace Microsoft.AspNet.Facebook.Test.Helpers
{
    public class LocalFacebookClient : FacebookClient
    {
        public string Path { get; set; }

        public override Task<TResult> GetTaskAsync<TResult>(string path)
        {
            Path = path;
            return Task.FromResult<TResult>(Activator.CreateInstance<TResult>());
        }

        public override Task<object> GetTaskAsync(string path)
        {
            Path = path;
            return Task.FromResult(new object());
        }

        public override object Get(string path)
        {
            Path = path;
            return new object();
        }

        public override TResult Get<TResult>(string path)
        {
            Path = path;
            return Activator.CreateInstance<TResult>();
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Helpers/MockHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Dynamic;
using System.Web;
using System.Web.Mvc;
using Facebook;
using Microsoft.AspNet.Facebook.Providers;
using Moq;

namespace Microsoft.AspNet.Facebook.Test.Helpers
{
    internal class MockHelpers
    {
        public static ControllerContext CreateControllerContext(NameValueCollection requestFormData = null,
                                                                NameValueCollection requestQueryData = null,
                                                                Uri requestUrl = null,
                                                                HttpCookieCollection requestCookies = null)
        {
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            controllerContext.Setup(c => c.HttpContext.Response).Returns(new EmptyHttpResponse());
            controllerContext.Setup(c => c.HttpContext.Response.Cookies).Returns(new HttpCookieCollection());
            controllerContext.Setup(c => c.HttpContext.Items).Returns(new Dictionary<object, object>());
            controllerContext.Setup(c => c.HttpContext.Request.Url).Returns(requestUrl ?? new Uri("http://example.com"));
            controllerContext.Setup(c => c.HttpContext.Request.AppRelativeCurrentExecutionFilePath).Returns("~/");
            controllerContext.Setup(c => c.HttpContext.Request.Form).Returns(requestFormData ?? new NameValueCollection());
            controllerContext.Setup(c => c.HttpContext.Request.QueryString).Returns(requestQueryData ?? new NameValueCollection());
            controllerContext.Setup(c => c.HttpContext.Request.Cookies).Returns(requestCookies ?? new HttpCookieCollection());
            return controllerContext.Object;
        }

        public static ActionDescriptor CreateActionDescriptor(object[] actionAuthorizeAttributes = null, object[] controllerAuthorizeAttributes = null)
        {
            Mock<ActionDescriptor> actionDescriptor = new Mock<ActionDescriptor>();
            actionDescriptor.Setup(a => a.GetCustomAttributes(typeof(FacebookAuthorizeAttribute), true)).Returns(actionAuthorizeAttributes ?? new object[0]);
            actionDescriptor.Setup(a => a.ControllerDescriptor.GetCustomAttributes(typeof(FacebookAuthorizeAttribute), true)).Returns(controllerAuthorizeAttributes ?? new object[0]);
            return actionDescriptor.Object;
        }

        public static FacebookConfiguration CreateConfiguration(FacebookClient client = null, IFacebookPermissionService permissionService = null)
        {
            FacebookConfiguration config = new FacebookConfiguration();

            if (client == null)
            {
                config.ClientProvider = new DefaultFacebookClientProvider(config);
                config.AppId = "DefaultAppId";
                config.AppSecret = "DefaultAppSecret";
            }
            else
            {
                Mock<IFacebookClientProvider> clientProvider = new Mock<IFacebookClientProvider>();
                clientProvider.Setup(cp => cp.CreateClient()).Returns(client);
                config.ClientProvider = clientProvider.Object;
                config.AppId = client.AppId ?? "DefaultAppId";
                config.AppSecret = client.AppSecret ?? "DefaultAppSecret";
            }
            config.PermissionService = permissionService ?? new DefaultFacebookPermissionService(config);
            return config;
        }

        public static FacebookClient CreateFacebookClient()
        {
            Mock<FacebookClient> client = new Mock<FacebookClient>();
            dynamic signedRequestParameters = new ExpandoObject();
            signedRequestParameters.user_id = "sampleId";
            signedRequestParameters.oauth_token = "sampleToken";
            client.Setup(c => c.ParseSignedRequest(It.IsAny<string>())).Returns((object)signedRequestParameters);
            client.Setup(c => c.GetLoginUrl(It.IsAny<object>())).Returns(new Uri("https://www.facebook.com/dialog/oauth?redirect_uri=example.com"));
            return client.Object;
        }

        public static IFacebookPermissionService CreatePermissionService(string[] permissionsToReturn,
                                                                         PermissionsStatus permissionsStatusToReturn = null)
        {
            var client = new Mock<IFacebookPermissionService>();
            permissionsStatusToReturn = permissionsStatusToReturn ?? new PermissionsStatus(apiResult: null);

            client.Setup(p => p.GetUserPermissions(It.IsAny<string>(), It.IsAny<string>())).Returns(permissionsToReturn);
            client.Setup(p => p.GetUserPermissionsStatus(It.IsAny<string>(), It.IsAny<string>())).Returns(permissionsStatusToReturn);

            return client.Object;
        }

        private sealed class EmptyHttpResponse : HttpResponseBase
        {
        }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Microsoft.AspNet.Facebook.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{C3BEF382-C7C4-454D-B017-1EAC03E9A82C}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.AspNet.Facebook.Test</RootNamespace>
    <AssemblyName>Microsoft.AspNet.Facebook.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Facebook, Version=6.0.10.0, Culture=neutral, PublicKeyToken=58cb4f2111d1e6de, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Facebook.6.4.2\lib\net45\Facebook.dll</HintPath>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Web" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="FacebookAuthorizeAttributeTest.cs" />
    <Compile Include="FacebookAuthorizeFilterHookTest.cs" />
    <Compile Include="GlobalFacebookConfigurationTest.cs" />
    <Compile Include="FacebookAuthorizeFilterTest.cs" />
    <Compile Include="FacebookClientExtensionsTest.cs" />
    <Compile Include="FacebookQueryHelperTest.cs" />
    <Compile Include="DefaultFacebookPermissionServiceTest.cs" />
    <Compile Include="DefaultFacebookClientProviderTest.cs" />
    <Compile Include="FacebookRedirectContextModelBinderTest.cs" />
    <Compile Include="FacebookConfigurationTest.cs" />
    <Compile Include="FacebookContextModelBinderTest.cs" />
    <Compile Include="FacebookRealtimeControllerTest.cs" />
    <Compile Include="Helpers\MockHelpers.cs" />
    <Compile Include="Helpers\LocalFacebookClient.cs" />
    <Compile Include="Types\UserPhoto.cs" />
    <Compile Include="Types\UserStatus.cs" />
    <Compile Include="Types\UserTypeWithFieldModifiers.cs" />
    <Compile Include="Types\UserTypeWithRenamedProperties.cs" />
    <Compile Include="Types\UserTypeWithIgnoredProperties.cs" />
    <Compile Include="Types\UserTypesWithCycles.cs" />
    <Compile Include="Types\FacebookPicture.cs" />
    <Compile Include="Types\UserWithFriends.cs" />
    <Compile Include="Types\SimpleUser.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="App.config">
      <SubType>Designer</SubType>
    </None>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\Microsoft.AspNet.Facebook\Microsoft.AspNet.Facebook.csproj">
      <Project>{821a136c-7c6f-44c6-a9e6-c39b5bfb1483}</Project>
      <Name>Microsoft.AspNet.Facebook</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9b7e3740-6161-4548-833c-4bbca43b970e}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3d3ffd8a-624d-4e9b-954b-e1c105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8f18041b-9410-4c36-a9c5-067813df5f31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22babb60-8f02-4027-affc-acf069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939b11a-fe4e-4ba1-8ad6-d97741ee314f}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76efa9c5-8d7e-4fdf-b710-e20f8b6b00d2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{fccc4cb7-baf7-4a57-9f89-e5766fe536c0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/FacebookPicture.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class FacebookPicture
    {
        public string Url { get; set; }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/SimpleUser.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class SimpleUser
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public FacebookConnection<FacebookPicture> Picture { get; set; }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/UserPhoto.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class UserPhoto
    {
        public string Name { get; set; }

        public string Picture { get; set; }

        public string Source { get; set; }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/UserStatus.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class UserStatus
    {
        public string Message { get; set; }

        public long Time { get; set; }
    }
}

================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/UserTypeWithFieldModifiers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class UserTypeWithFieldModifiers
    {
        public string Id { get; set; }
        public string Name { get; set; }

        [FacebookFieldModifier("type(large)")]
        public FacebookConnection<FacebookPicture> Picture { get; set; }

        [FacebookFieldModifier("limit(5)")]
        public FacebookGroupConnection<SimpleUser> Friends { get; set; }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/UserTypeWithIgnoredProperties.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Newtonsoft.Json;
namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class UserTypeWithIgnoredProperties
    {
        public string Id { get; set; }

        [JsonIgnore]
        public string Name { get; set; }

        [JsonIgnore]
        public FacebookConnection<FacebookPicture> Picture { get; set; }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/UserTypeWithRenamedProperties.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Newtonsoft.Json;

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class UserTypeWithRenamedProperties
    {
        [JsonProperty("Id")]
        public string FacebookId { get; set; }

        public string Name { get; set; }

        [JsonProperty("picture")]
        public FacebookConnection<FacebookPicture> PictureConnection { get; set; }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/UserTypesWithCycles.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class UserWithUserFriends
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public FacebookGroupConnection<UserWithUserFriends> Friends { get; set; }
    }

    public class UserContainingFriendsWithCycle
    {
        public string Id { get; set; }
        public FacebookGroupConnection<UserWithUserFriends> Friends { get; set; }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/Types/UserWithFriends.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.AspNet.Facebook.Test.Types
{
    public class UserWithFriends
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public FacebookConnection<FacebookPicture> Picture { get; set; }
        public FacebookGroupConnection<SimpleUser> Friends { get; set; }
    }
}


================================================
FILE: test/Microsoft.AspNet.Facebook.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Facebook" version="6.4.2" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/Microsoft.TestCommon/AppDomainUtils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Reflection;
using System.Web.Compilation;
using System.Web.Hosting;

namespace System.Web.WebPages.TestUtils
{
    public static class AppDomainUtils
    {
        // Allow a test to modify static fields in an independent appdomain so that
        // other tests will not be affected.
        public static void RunInSeparateAppDomain(Action action)
        {
            RunInSeparateAppDomain(new AppDomainSetup(), action);
        }

        public static void RunInSeparateAppDomain(AppDomainSetup setup, Action action)
        {
            var dir = Path.GetDirectoryName(typeof(AppDomainUtils).Assembly.CodeBase).Replace("file:\\", "");
            setup.PrivateBinPath = dir;
            setup.ApplicationBase = dir;
            setup.ApplicationName = Guid.NewGuid().ToString();
            setup.ShadowCopyFiles = "true";
            setup.ShadowCopyDirectories = setup.ApplicationBase;
            setup.CachePath = Path.Combine(Path.GetTempPath(), setup.ApplicationName);

            AppDomain appDomain = null;
            try
            {
                appDomain = AppDomain.CreateDomain(setup.ApplicationName, null, setup);
                AppDomainHelper helper = appDomain.CreateInstanceAndUnwrap(typeof(AppDomainUtils).Assembly.FullName, typeof(AppDomainHelper).FullName) as AppDomainHelper;
                helper.Run(action);
            }
            finally
            {
                if (appDomain != null)
                {
                    AppDomain.Unload(appDomain);
                }
            }
        }

        public class AppDomainHelper : MarshalByRefObject
        {
            public void Run(Action action)
            {
                action();
            }
        }

        public static void SetPreAppStartStage()
        {
            var stage = typeof(BuildManager).GetProperty("PreStartInitStage", BindingFlags.Static | BindingFlags.NonPublic);
            var value = ((FieldInfo)typeof(BuildManager).Assembly.GetType("System.Web.Compilation.PreStartInitStage").GetMember("DuringPreStartInit")[0]).GetValue(null);
            stage.SetValue(null, value, new object[] { });
            SetAppData();
            var env = new HostingEnvironment();
        }

        public static void SetAppData()
        {
            var appdomain = AppDomain.CurrentDomain;
            // Set some dummy values to make the appdomain seem more like a ASP.NET hosted one
            appdomain.SetData(".appDomain", "*");
            appdomain.SetData(".appId", "appId");
            appdomain.SetData(".appPath", "appPath");
            appdomain.SetData(".appVPath", "/WebSite1");
            appdomain.SetData(".domainId", "1");
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Assert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon
{
    // This extends xUnit.net's Assert class, and makes it partial so that we can
    // organize the extension points by logical functionality (rather than dumping them
    // all into this single file).
    //
    // See files named XxxAssertions for root extensions to Assert.
    public partial class Assert : Xunit.Assert
    {
        public static readonly ReflectionAssert Reflection = new ReflectionAssert();

        public static readonly TypeAssert Type = new TypeAssert();

        public static readonly HttpAssert Http = new HttpAssert();

        public static readonly MediaTypeAssert MediaType = new MediaTypeAssert();

        public static readonly GenericTypeAssert GenericType = new GenericTypeAssert();

        public static readonly SerializerAssert Serializer = new SerializerAssert();

        public static readonly StreamAssert Stream = new StreamAssert();

        public static readonly TaskAssert Task = new TaskAssert();

        public static readonly XmlAssert Xml = new XmlAssert();

        // Method has been marked [Obsolete] in xUnit.net v2.0.0+.
        public static new void ReferenceEquals(object a, object b)
        {
            Same(a, b);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/CultureReplacer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Threading;

namespace Microsoft.TestCommon
{
    public class CultureReplacer : IDisposable
    {
        private const string _defaultCultureName = "en-GB";
        private const string _defaultUICultureName = "en-US";
        private static readonly CultureInfo _defaultCulture = CultureInfo.GetCultureInfo(_defaultCultureName);
        private readonly CultureInfo _originalCulture;
        private readonly CultureInfo _originalUICulture;
        private readonly long _threadId;

        // Culture => Formatting of dates/times/money/etc, defaults to en-GB because en-US is the same as InvariantCulture
        // We want to be able to find issues where the InvariantCulture is used, but a specific culture should be.
        //
        // UICulture => Language
        public CultureReplacer(string culture = _defaultCultureName, string uiCulture = _defaultUICultureName)
        {
            _originalCulture = Thread.CurrentThread.CurrentCulture;
            _originalUICulture = Thread.CurrentThread.CurrentUICulture;
            _threadId = Thread.CurrentThread.ManagedThreadId;

            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(culture);
            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(uiCulture);
        }

        /// <summary>
        /// The name of the culture that is used as the default value for Thread.CurrentCulture when CultureReplacer is used.
        /// </summary>
        public static string DefaultCultureName
        {
            get { return _defaultCultureName; }
        }

        /// <summary>
        /// The name of the culture that is used as the default value for Thread.UICurrentCulture when CultureReplacer is used.
        /// </summary>
        public static string DefaultUICultureName
        {
            get { return _defaultUICultureName; }
        }

        /// <summary>
        /// The culture that is used as the default value for Thread.CurrentCulture when CultureReplacer is used.
        /// </summary>
        public static CultureInfo DefaultCulture
        {
            get { return _defaultCulture; }
        }

        public void Dispose()
        {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing)
        {
            if (disposing)
            {
                Assert.True(Thread.CurrentThread.ManagedThreadId == _threadId, "The current thread is not the same as the thread invoking the constructor. This should never happen.");
                Thread.CurrentThread.CurrentCulture = _originalCulture;
                Thread.CurrentThread.CurrentUICulture = _originalUICulture;
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/DataAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Reflection;

namespace Microsoft.TestCommon
{
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
    public abstract class DataAttribute : Xunit.Sdk.DataAttribute
    {
        public abstract IEnumerable<Object[]> GetData(MethodInfo methodUnderTest, Type[] parameterTypes);

        public override IEnumerable<Object[]> GetData(MethodInfo methodUnderTest)
        {
            return GetData(methodUnderTest, parameterTypes: null);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/DictionaryEqualityComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace Microsoft.TestCommon
{
    public class DictionaryEqualityComparer : IEqualityComparer<IDictionary<string, object>>
    {
        public bool Equals(IDictionary<string, object> x, IDictionary<string, object> y)
        {
            if (x.Count != y.Count)
            {
                return false;
            }

            foreach (string key in x.Keys)
            {
                object xVal = x[key];
                object yVal;
                if (!y.TryGetValue(key, out yVal))
                {
                    return false;
                }

                if (xVal == null)
                {
                    if (yVal == null)
                    {
                        continue;
                    }

                    return false;
                }

                if (!xVal.Equals(yVal))
                {
                    return false;
                }
            }

            return true;
        }

        public int GetHashCode(IDictionary<string, object> obj)
        {
            return 1;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Directory.Build.props
================================================
<Project>
  <Import Project="..\Directory.Build.props" />

  <PropertyGroup>
    <!-- Set base intermediate output path early for ns1_3 but still exclude everything under the obj\ folder. -->
    <BaseIntermediateOutputPath Condition=" '$(Testing_NetStandard1_3)' == 'true' ">obj\ns1_3\</BaseIntermediateOutputPath>
    <DefaultItemExcludes>$(DefaultItemExcludes);obj\**</DefaultItemExcludes>
  </PropertyGroup>
</Project>


================================================
FILE: test/Microsoft.TestCommon/EnumHelperTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.TestCommon
{
    public abstract class EnumHelperTestBase<TEnum> where TEnum : IComparable, IFormattable, IConvertible
    {
        private Func<TEnum, bool> _isDefined;
        private Action<TEnum, string> _validate;
        private TEnum _undefined;

        /// <summary>
        /// Helper to verify that we validate enums correctly when passed as arguments etc.
        /// </summary>
        /// <param name="isDefined">A Func used to validate that a value is defined.</param>
        /// <param name="validate">A Func used to validate that a value is definded of throw an exception.</param>
        /// <param name="undefined">An undefined value.</param>
        protected EnumHelperTestBase(Func<TEnum, bool> isDefined, Action<TEnum, string> validate, TEnum undefined)
        {
            _isDefined = isDefined;
            _validate = validate;
            _undefined = undefined;
        }

        [Fact]
        public void IsDefined_ReturnsTrueForDefinedValues()
        {
            Array values = Enum.GetValues(typeof(TEnum));
            foreach (object value in values)
            {
                if (ValueExistsForFramework((TEnum)value))
                {
                    Assert.True(_isDefined((TEnum)value));
                }
                else
                {
                    Assert.False(_isDefined((TEnum)value));
                }
            }
        }

        [Fact]
        public void IsDefined_ReturnsFalseForUndefinedValues()
        {
            Assert.False(_isDefined(_undefined));
        }

        [Fact]
        public void Validate_DoesNotThrowForDefinedValues()
        {
            Array values = Enum.GetValues(typeof(TEnum));
            foreach (object value in values)
            {
                if (ValueExistsForFramework((TEnum)value))
                {
                    _validate((TEnum)value, "parameter");
                }
            }
        }

        [Fact]
        public void Validate_ThrowsForUndefinedValues()
        {
            AssertForUndefinedValue(
                () => _validate(_undefined, "parameter"),
                "parameter",
                (int)Convert.ChangeType(_undefined, typeof(int)),
                typeof(TEnum),
                allowDerivedExceptions: false);
        }

        /// <summary>
        /// Override this if InvalidEnumArgument is not supported in the targetted platform
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="invalidValue">The expected invalid value that should appear in the message</param>
        /// <param name="enumType">The type of the enumeration</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        protected virtual void AssertForUndefinedValue(Action testCode, string parameterName, int invalidValue, Type enumType, bool allowDerivedExceptions = false)
        {
            Assert.ThrowsInvalidEnumArgument(
                testCode,
                parameterName,
                invalidValue,
                enumType,
                allowDerivedExceptions);
        }

        /// <summary>
        /// Override this to determine if a given enum value for an enum exists in a given framework
        /// </summary>
        /// <param name="value"></param>
        /// <returns>Wheter the value exists</returns>
        protected virtual bool ValueExistsForFramework(TEnum value)
        {
            return true;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/ExceptionAssertions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using System.Reflection;
using System.Threading.Tasks;
using System.Web;
#if Testing_NetStandard1_3
using System.Web.Http;
#endif

namespace Microsoft.TestCommon
{
    public partial class Assert
    {
        // Method has been removed in xUnit.net v2.0.0+.
        public static void DoesNotThrow(Action testCode)
        {
            testCode();
        }

        /// <summary>
        /// Verifies that the exact exception is thrown (and not a derived exception type).
        /// </summary>
        /// <typeparam name="T">The type of the exception expected to be thrown</typeparam>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static new T Throws<T>(Action testCode)
            where T : Exception
        {
            return (T)Throws(typeof(T), testCode);
        }

        /// <summary>
        /// Verifies that the exact exception is thrown (and not a derived exception type).
        /// Generally used to test property accessors.
        /// </summary>
        /// <typeparam name="T">The type of the exception expected to be thrown</typeparam>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static new T Throws<T>(Func<object> testCode)
            where T : Exception
        {
            return (T)Throws(typeof(T), testCode);
        }

        /// <summary>
        /// Verifies that the exact exception is thrown (and not a derived exception type).
        /// </summary>
        /// <param name="exceptionType">The type of the exception expected to be thrown</param>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static new Exception Throws(Type exceptionType, Action testCode)
        {
            Exception exception = RecordException(testCode);
            return VerifyException(exceptionType, exception);
        }

        /// <summary>
        /// Verifies that the exact exception is thrown (and not a derived exception type).
        /// Generally used to test property accessors.
        /// </summary>
        /// <param name="exceptionType">The type of the exception expected to be thrown</param>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static new Exception Throws(Type exceptionType, Func<object> testCode)
        {
            return Throws(exceptionType, () => { testCode(); });
        }

        /// <summary>
        /// Verifies that an exception of the given type (or optionally a derived type) is thrown.
        /// </summary>
        /// <typeparam name="TException">The type of the exception expected to be thrown</typeparam>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static TException Throws<TException>(Action testCode, bool allowDerivedExceptions)
            where TException : Exception
        {
            Type exceptionType = typeof(TException);
            Exception exception = RecordException(testCode);

            TargetInvocationException tie = exception as TargetInvocationException;
            if (tie != null)
            {
                exception = tie.InnerException;
            }

            if (exception == null)
            {
                throw new ThrowsException(exceptionType);
            }

            var typedException = exception as TException;
            if (typedException == null || (!allowDerivedExceptions && typedException.GetType() != typeof(TException)))
            {
                throw new ThrowsException(exceptionType, exception);
            }

            return typedException;
        }

        /// <summary>
        /// Verifies that an exception of the given type (or optionally a derived type) is thrown.
        /// Generally used to test property accessors.
        /// </summary>
        /// <typeparam name="TException">The type of the exception expected to be thrown</typeparam>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static TException Throws<TException>(Func<object> testCode, bool allowDerivedExceptions)
            where TException : Exception
        {
            return Throws<TException>(() => { testCode(); }, allowDerivedExceptions);
        }

        /// <summary>
        /// Verifies that an exception of the given type (or optionally a derived type) is thrown.
        /// Also verifies that the exception message matches.
        /// </summary>
        /// <typeparam name="TException">The type of the exception expected to be thrown</typeparam>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="exceptionMessage">The exception message to verify</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static TException Throws<TException>(Action testCode, string exceptionMessage, bool allowDerivedExceptions = false)
            where TException : Exception
        {
            var ex = Throws<TException>(testCode, allowDerivedExceptions);
            VerifyExceptionMessage(ex, exceptionMessage);
            return ex;
        }

        /// <summary>
        /// Verifies that an exception of the given type (or optionally a derived type) is thrown.
        /// Also verified that the exception message matches.
        /// </summary>
        /// <typeparam name="TException">The type of the exception expected to be thrown</typeparam>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="exceptionMessage">The exception message to verify</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static TException Throws<TException>(Func<object> testCode, string exceptionMessage, bool allowDerivedExceptions = false)
            where TException : Exception
        {
            return Throws<TException>(() => { testCode(); }, exceptionMessage, allowDerivedExceptions);
        }

        /// <summary>
        /// Verifies that the code throws an <see cref="ArgumentException"/> (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentException ThrowsArgument(Action testCode, string paramName, bool allowDerivedExceptions = false)
        {
            var ex = Throws<ArgumentException>(testCode, allowDerivedExceptions);

            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies the given <paramref name="testCode"/> throws an <see cref="ArgumentException"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested.</param>
        /// <param name="paramName">The name of the parameter that should throw the exception.</param>
        /// <returns>A <see cref="Task"/> that on completion returns the exception that was thrown.</returns>
        public static async Task<ArgumentException> ThrowsArgumentAsync(Func<Task> testCode, string paramName)
        {
            var ex = await ThrowsAsync<ArgumentException>(testCode);
            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies that the code throws an <see cref="ArgumentException"/> (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="exceptionMessage">The exception message to verify</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentException ThrowsArgument(Action testCode, string paramName, string exceptionMessage, bool allowDerivedExceptions = false)
        {
            var ex = Throws<ArgumentException>(testCode, allowDerivedExceptions);

            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            VerifyExceptionMessage(ex, exceptionMessage, partialMatch: true);

            return ex;
        }

        /// <summary>
        /// Verifies that the <paramref name="testCode"/> throws an <see cref="ArgumentException"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested.</param>
        /// <param name="paramName">The name of the parameter that should throw the exception.</param>
        /// <param name="exceptionMessage">The exception message to verify (or a portion of the expected message).</param>
        /// <returns>A <see cref="Task"/> that on completion returns the exception that was thrown.</returns>
        public static async Task<ArgumentException> ThrowsArgumentAsync(Func<Task> testCode, string paramName, string exceptionMessage)
        {
            var ex = await ThrowsArgumentAsync(testCode, paramName);
            VerifyExceptionMessage(ex, exceptionMessage, partialMatch: true);

            return ex;
        }

        /// <summary>
        /// Verifies that the code throws an ArgumentException (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentException ThrowsArgument(Func<object> testCode, string paramName, bool allowDerivedExceptions = false)
        {
            var ex = Throws<ArgumentException>(testCode, allowDerivedExceptions);

            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies that the code throws an ArgumentNullException (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentNullException ThrowsArgumentNull(Action testCode, string paramName)
        {
            var ex = Throws<ArgumentNullException>(testCode, allowDerivedExceptions: false);

            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies that the <paramref name="testCode"/> throws an <see cref="ArgumentNullException"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested.</param>
        /// <param name="paramName">The name of the parameter that should throw the exception.</param>
        /// <returns>A <see cref="Task"/> that on completion returns the exception that was thrown.</returns>
        public static async Task<ArgumentNullException> ThrowsArgumentNullAsync(Func<Task> testCode, string paramName)
        {
            var ex = await ThrowsAsync<ArgumentNullException>(testCode);
            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies that the code throws an ArgumentNullException with the expected message that indicates that the value cannot
        /// be null or empty.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentException ThrowsArgumentNullOrEmpty(Action testCode, string paramName)
        {
            return Throws<ArgumentException>(testCode, "Value cannot be null or empty." + GetParameterMessage(paramName), allowDerivedExceptions: false);
        }

        /// <summary>
        /// Verifies that the code throws an ArgumentNullException with the expected message that indicates that the value cannot
        /// be null or empty string.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentException ThrowsArgumentNullOrEmptyString(Action testCode, string paramName)
        {
            return ThrowsArgument(testCode, paramName, "Value cannot be null or an empty string.", allowDerivedExceptions: true);
        }

        /// <summary>
        /// Verifies that the code throws an ArgumentOutOfRangeException (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="exceptionMessage">The exception message to verify</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <param name="actualValue">The actual value provided</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentOutOfRangeException ThrowsArgumentOutOfRange(Action testCode, string paramName, string exceptionMessage, bool allowDerivedExceptions = false, object actualValue = null)
        {
            if (exceptionMessage != null)
            {
                exceptionMessage = exceptionMessage + GetParameterMessage(paramName);
                if (actualValue != null)
                {
                    exceptionMessage += String.Format(CultureReplacer.DefaultCulture, "\r\nActual value was {0}.", actualValue);
                }
            }

            var ex = Throws<ArgumentOutOfRangeException>(testCode, exceptionMessage, allowDerivedExceptions);

            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies that the <paramref name="testCode"/> throws an <see cref="ArgumentOutOfRangeException"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested.</param>
        /// <param name="paramName">The name of the parameter that should throw the exception.</param>
        /// <param name="exceptionMessage">The exception message to verify (or a portion of the expected message).</param>
        /// <param name="actualValue">The actual value passed in for <paramref name="paramName"/>.</param>
        /// <returns>A <see cref="Task"/> that on completion returns the exception that was thrown.</returns>
        public static async Task<ArgumentOutOfRangeException> ThrowsArgumentOutOfRangeAsync(
            Func<Task> testCode,
            string paramName,
            string exceptionMessage,
            object actualValue = null)
        {
            if (exceptionMessage != null)
            {
                exceptionMessage = exceptionMessage + GetParameterMessage(paramName);
                if (actualValue != null)
                {
                    exceptionMessage += String.Format(CultureReplacer.DefaultCulture, "\r\nActual value was {0}.", actualValue);
                }
            }

            var ex = await ThrowsAsync<ArgumentOutOfRangeException>(testCode, exceptionMessage, partialMatch: true);
            if (paramName != null)
            {
                Equal(paramName, ex.ParamName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies that the code throws an <see cref="ArgumentOutOfRangeException"/> with the expected message that indicates that
        /// the value must be greater than the given <paramref name="value"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="actualValue">The actual value provided.</param>
        /// <param name="value">The expected limit value.</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentOutOfRangeException ThrowsArgumentGreaterThan(Action testCode, string paramName, string value, object actualValue = null)
        {
            return ThrowsArgumentOutOfRange(
                        testCode,
                        paramName,
                        String.Format(CultureReplacer.DefaultCulture, "Value must be greater than {0}.", value), false, actualValue);
        }

        /// <summary>
        /// Verifies that the code throws an <see cref="ArgumentOutOfRangeException"/> with the expected message that indicates that
        /// the value must be greater than or equal to the given value.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="value">The expected limit value.</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentOutOfRangeException ThrowsArgumentGreaterThanOrEqualTo(Action testCode, string paramName, string value, object actualValue = null)
        {
            return ThrowsArgumentOutOfRange(
                        testCode,
                        paramName,
                        String.Format(CultureReplacer.DefaultCulture, "Value must be greater than or equal to {0}.", value), false, actualValue);
        }

        /// <summary>
        /// Verifies that the <paramref name="testCode"/> throws an <see cref="ArgumentOutOfRangeException"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested.</param>
        /// <param name="paramName">The name of the parameter that should throw the exception.</param>
        /// <param name="value">The minimum allowed value for <paramref name="paramName"/>.</param>
        /// <param name="actualValue">The actual value passed in for <paramref name="paramName"/>.</param>
        /// <returns>A <see cref="Task"/> that on completion returns the exception that was thrown.</returns>
        public static Task<ArgumentOutOfRangeException> ThrowsArgumentGreaterThanOrEqualToAsync(
            Func<Task> testCode,
            string paramName,
            string value,
            object actualValue = null)
        {
            return ThrowsArgumentOutOfRangeAsync(
                testCode,
                paramName,
                String.Format(CultureReplacer.DefaultCulture, "Value must be greater than or equal to {0}.", value),
                actualValue);
        }


        /// <summary>
        /// Verifies that the code throws an <see cref="ArgumentOutOfRangeException"/> with the expected message that indicates that
        /// the value must be less than the given <paramref name="maxValue"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="actualValue">The actual value provided.</param>
        /// <param name="maxValue">The expected limit value.</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentOutOfRangeException ThrowsArgumentLessThan(Action testCode, string paramName, string maxValue, object actualValue = null)
        {
            return ThrowsArgumentOutOfRange(
                        testCode,
                        paramName,
                        String.Format(CultureReplacer.DefaultCulture, "Value must be less than {0}.", maxValue), false, actualValue);
        }

        /// <summary>
        /// Verifies that the code throws an <see cref="ArgumentOutOfRangeException"/> with the expected message that indicates that
        /// the value must be less than or equal to the given <paramref name="maxValue"/>.
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="actualValue">The actual value provided.</param>
        /// <param name="maxValue">The expected limit value.</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentOutOfRangeException ThrowsArgumentLessThanOrEqualTo(Action testCode, string paramName, string maxValue, object actualValue = null)
        {
            return ThrowsArgumentOutOfRange(
                        testCode,
                        paramName,
                        String.Format(CultureReplacer.DefaultCulture, "Value must be less than or equal to {0}.", maxValue), false, actualValue);
        }

#if !NETCOREAPP
        /// <summary>
        /// Verifies that the code throws an HttpException (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="exceptionMessage">The exception message to verify</param>
        /// <param name="httpCode">The expected HTTP status code of the exception</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static HttpException ThrowsHttpException(Action testCode, string exceptionMessage, int httpCode, bool allowDerivedExceptions = false)
        {
            var ex = Throws<HttpException>(testCode, exceptionMessage, allowDerivedExceptions);
            Equal(httpCode, ex.GetHttpCode());
            return ex;
        }
#endif

        /// <summary>
        /// Verifies that the code throws an InvalidEnumArgumentException (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="paramName">The name of the parameter that should throw the exception</param>
        /// <param name="invalidValue">The expected invalid value that should appear in the message</param>
        /// <param name="enumType">The type of the enumeration</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ArgumentException ThrowsInvalidEnumArgument(Action testCode, string paramName, int invalidValue, Type enumType, bool allowDerivedExceptions = false)
        {
            string message = String.Format(CultureReplacer.DefaultCulture,
                                           "The value of argument '{0}' ({1}) is invalid for Enum type '{2}'.{3}",
                                           paramName, invalidValue, enumType.Name, GetParameterMessage(paramName));

#if Testing_NetStandard1_3 // InvalidEnumArgumentException not available in netstandard1.3.
            return Throws<Error.InvalidEnumArgumentException>(testCode, message, allowDerivedExceptions);
#else
            return Throws<InvalidEnumArgumentException>(testCode, message, allowDerivedExceptions);
#endif
        }

        /// <summary>
        /// Verifies that the code throws an HttpException (or optionally any exception which derives from it).
        /// </summary>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <param name="objectName">The name of the object that was dispose</param>
        /// <param name="allowDerivedExceptions">Pass true to allow exceptions which derive from TException; pass false, otherwise</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        public static ObjectDisposedException ThrowsObjectDisposed(Action testCode, string objectName, bool allowDerivedExceptions = false)
        {
            var ex = Throws<ObjectDisposedException>(testCode, allowDerivedExceptions);

            if (objectName != null)
            {
                Equal(objectName, ex.ObjectName);
            }

            return ex;
        }

        /// <summary>
        /// Verifies that an exception of the given type is thrown.
        /// </summary>
        /// <typeparam name="TException">The type of the exception expected to be thrown</typeparam>
        /// <param name="testCode">A delegate to the code to be tested</param>
        /// <returns>The exception that was thrown, when successful</returns>
        /// <exception cref="ThrowsException">Thrown when an exception was not thrown, or when an exception of the incorrect type is thrown</exception>
        /// <remarks>
        /// Unlike other Throws* methods, this method does not enforce running the exception delegate with a known Thread Culture.
        /// </remarks>
        public static new async Task<TException> ThrowsAsync<TException>(Func<Task> testCode)
            where TException : Exception
        {
            Exception exception = null;
            try
            {
                // The 'testCode' Task might execute asynchronously in a different thread making it hard to enforce the thread culture.
                // The correct way to verify exception messages in such a scenario would be to run the task synchronously inside of a
                // culture enforced block.
                await testCode();
            }
            catch (Exception ex)
            {
                exception = ex;
            }
            VerifyException(typeof(TException), exception);
            return (TException)exception;
        }

        /// <summary>
        /// Verifies that the <paramref name="testCode"/> throws a <typeparamref name="TException"/>.
        /// </summary>
        /// <typeparam name="TException">The type of <see cref="Exception"/> expected to be thrown.</typeparam>
        /// <param name="testCode">A delegate to the code to be tested.</param>
        /// <param name="exceptionMessage">The exception message to verify (or a portion of the expected message).</param>
        /// <param name="partialMatch">
        /// If <paramref name="exceptionMessage"/> is <c>null</c>, ignores this parameter. Otherwise if this parameter
        /// is <c>true</c>, verifies the exception message contains <paramref name="exceptionMessage"/>. Otherwise,
        /// verifies the exception message exactly matches <paramref name="exceptionMessage"/>.
        /// </param>
        /// <returns>A <see cref="Task"/> that on completion returns the exception that was thrown.</returns>
        public static async Task<TException> ThrowsAsync<TException>(
            Func<Task> testCode,
            string exceptionMessage,
            bool partialMatch = false) where TException : Exception
        {
            var ex = await ThrowsAsync<TException>(testCode);
            VerifyExceptionMessage(ex, exceptionMessage, partialMatch);
            return ex;
        }

        private static string GetParameterMessage(string parameterName)
        {
#if NETCOREAPP3_1_OR_GREATER
            return " (Parameter '" + parameterName + "')";
#else
            return Environment.NewLine + "Parameter name: " + parameterName;
#endif
        }

        // We've re-implemented all the xUnit.net Throws code so that we can get this
        // updated implementation of RecordException which silently unwraps any instances
        // of AggregateException. In addition to unwrapping exceptions, this method ensures
        // that tests are executed in with a known set of Culture and UICulture. This prevents
        // tests from failing when executed on a non-English machine.
        private static new Exception RecordException(Action testCode)
        {
            try
            {
                using (new CultureReplacer())
                {
                    testCode();
                }
                return null;
            }
            catch (Exception exception)
            {
                return UnwrapException(exception);
            }
        }

        private static Exception UnwrapException(Exception exception)
        {
            AggregateException aggEx = exception as AggregateException;
            if (aggEx != null)
            {
                return aggEx.GetBaseException();
            }
            return exception;
        }

        private static Exception VerifyException(Type exceptionType, Exception exception)
        {
            if (exception == null)
            {
                throw new ThrowsException(exceptionType);
            }
            else if (exceptionType != exception.GetType())
            {
                throw new ThrowsException(exceptionType, exception);
            }

            return exception;
        }

        private static void VerifyExceptionMessage(Exception exception, string expectedMessage, bool partialMatch = false)
        {
            if (expectedMessage != null)
            {
                if (!partialMatch)
                {
                    Equal(expectedMessage, exception.Message);
                }
                else
                {
                    Contains(expectedMessage, exception.Message);
                }
            }
        }

        // Custom ThrowsException so we can filter the stack trace.
        [Serializable]
        private class ThrowsException : Xunit.Sdk.ThrowsException
        {
            public ThrowsException(Type type) : base(type) { }

            public ThrowsException(Type type, Exception ex) : base(type, ex) { }

            public override string StackTrace
            {
                get
                {
                    return ExceptionUtility.FilterStackTrace(base.StackTrace);
                }
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/ExceptionUtility.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;

// Variation of Xunit.Sdk.ExceptionUtility which helps with Exceptions and their stack traces.
namespace Microsoft.TestCommon
{
    public static class ExceptionUtility
    {
        public static string FilterStackTrace(string stack)
        {
            if (stack == null)
            {
                return null;
            }

            var results = new List<string>();
            foreach (var line in SplitLines(stack))
            {
                var trimmedLine = line.TrimStart();
                if (!ExcludeStackFrame(trimmedLine))
                {
                    results.Add(line);
                }
            }

            return string.Join(Environment.NewLine, results);
        }

        private static IEnumerable<string> SplitLines(string input)
        {
            while (true)
            {
                var index = input.IndexOf(Environment.NewLine, StringComparison.Ordinal);
                if (index < 0)
                {
                    yield return input;
                    break;
                }

                yield return input.Substring(0, index);
                input = input.Substring(index + Environment.NewLine.Length);
            }
        }

        private static bool ExcludeStackFrame(string stackFrame)
        {
            if (stackFrame.StartsWith("at Microsoft.TestCommon.Assert.", StringComparison.OrdinalIgnoreCase))
            {
                return true;
            }

            return false;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/FactAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// An override of <see cref="Xunit.FactAttribute"/> that provides extended capabilities.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    [XunitTestCaseDiscoverer("Microsoft.TestCommon.FactDiscoverer", "Microsoft.TestCommon")]
    public class FactAttribute : Xunit.FactAttribute
    {
        /// <summary>
        /// Instantiates a new instance of <see cref="FactAttribute"/>.
        /// </summary>
        public FactAttribute()
        {
            Platforms = Platform.All;
            PlatformJustification = "Unsupported platform (test runs on {0}, current platform is {1})";
        }

        /// <summary>
        /// Gets or set the platforms that the unit test is compatible with. Defaults to
        /// <see cref="Platform.All"/>.
        /// </summary>
        public Platform Platforms { get; set; }

        /// <summary>
        /// Gets or sets the platform skipping justification. This message can receive
        /// the supported platforms as {0}, and the current platform as {1}.
        /// </summary>
        public string PlatformJustification { get; set; }
    }
}

================================================
FILE: test/Microsoft.TestCommon/FactDiscoverer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using Xunit.Abstractions;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// An override of <see cref="Xunit.Sdk.FactDiscoverer"/> that provides extended capabilities.
    /// </summary>
    class FactDiscoverer : Xunit.Sdk.FactDiscoverer
    {
        private readonly IMessageSink _diagnosticMessageSink;

        /// <summary>
        /// Instantiates a new <see cref="FactDiscoverer"/> instance.
        /// </summary>
        /// <param name="diagnosticMessageSink">The <see cref="IMessageSink"/> used to send diagnostic messages.</param>
        public FactDiscoverer(IMessageSink diagnosticMessageSink)
            : base(diagnosticMessageSink)
        {
            _diagnosticMessageSink = diagnosticMessageSink;
        }

        /// <summary>
        /// Gets the platform that the unit test is currently running on.
        /// </summary>
        protected Platform Platform
        {
            get { return PlatformInfo.Platform; }
        }

        /// <inheritdoc/>
        public override IEnumerable<IXunitTestCase> Discover(
            ITestFrameworkDiscoveryOptions discoveryOptions,
            ITestMethod testMethod,
            IAttributeInfo factAttribute)
        {
            var baseCases = base.Discover(discoveryOptions, testMethod, factAttribute);
            if (!String.IsNullOrEmpty(factAttribute.GetNamedArgument<string>("Skip")))
            {
                // No need to change skipped tests.
                return baseCases;
            }

            var platforms = factAttribute.GetNamedArgument<Platform>("Platforms");
            if ((platforms & Platform) != 0)
            {
                // No need to change tests that should run on the current platform.
                return baseCases;
            }

            // Base implementation always returns a single test case.
            var baseCase = baseCases.FirstOrDefault();
            Contract.Assert(baseCase != null);
            if (baseCase is ExecutionErrorTestCase)
            {
                // No need to change an erroneous test.
                return baseCases;
            }

            if (!String.IsNullOrEmpty(baseCase.SkipReason))
            {
                // No need to change a skipped test. Covered to protect against changes in the base class.
                return baseCases;
            }

            // Replace test with its skipped equivalent.
            var platformJustification = factAttribute.GetNamedArgument<string>("PlatformJustification");
            var skipReason = String.Format(platformJustification, platforms.ToString().Replace(", ", " | "), Platform);
            var testCase = new SkippedXunitTestCase(
                _diagnosticMessageSink,
                discoveryOptions.MethodDisplayOrDefault(),
                TestMethodDisplayOptions.None,
                skipReason,
                baseCase.TestMethod,
                baseCase.TestMethodArguments);

            return new[] { testCase };
        }
    }
}

================================================
FILE: test/Microsoft.TestCommon/ForceGCAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;

namespace Microsoft.TestCommon
{
    public class ForceGCAttribute : Xunit.Sdk.BeforeAfterTestAttribute
    {
        public override void After(MethodInfo methodUnderTest)
        {
            GC.Collect(99);
            GC.Collect(99);
            GC.Collect(99);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/InlineDataAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Reflection;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    // Xunit.InlineDataAttribute is unfortunately sealed. Delegate to an instance to avoid duplicating its code.
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
    [DataDiscoverer("Xunit.Sdk.InlineDataDiscoverer", "xunit.core")]
    public class InlineDataAttribute : Xunit.Sdk.DataAttribute
    {
        Xunit.InlineDataAttribute _inner;

        public InlineDataAttribute(params object[] dataValues)
            : base()
        {
            _inner = new Xunit.InlineDataAttribute(dataValues);
        }

        public override IEnumerable<object[]> GetData(MethodInfo testMethod)
        {
            return _inner.GetData(testMethod);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/MatrixTheoryDataSet.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;

namespace Microsoft.TestCommon
{
    public class MatrixTheoryDataSet<T1, T2> : TheoryDataSet<T1, T2>
    {
        public MatrixTheoryDataSet(IEnumerable<T1> data1, IEnumerable<T2> data2)
        {
            Contract.Assert(data1 != null && data1.Any());
            Contract.Assert(data2 != null && data2.Any());

            foreach (T1 t1 in data1)
            {
                foreach (T2 t2 in data2)
                {
                    Add(t1, t2);
                }
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/MemberHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.TestUtil
{
    public static class MemberHelper
    {
        private static ConstructorInfo GetConstructorInfo(object instance, Type[] parameterTypes)
        {
            if (instance == null)
            {
                throw new ArgumentNullException("instance");
            }
            ConstructorInfo constructorInfo = instance.GetType().GetConstructor(parameterTypes);
            if (constructorInfo == null)
            {
                throw new ArgumentException(String.Format(
                    "A matching constructor on type '{0}' could not be found.",
                    instance.GetType().FullName));
            }
            return constructorInfo;
        }

        private static EventInfo GetEventInfo(object instance, string eventName)
        {
            if (instance == null)
            {
                throw new ArgumentNullException("instance");
            }
            if (String.IsNullOrEmpty(eventName))
            {
                throw new ArgumentException("An event must be specified.", "eventName");
            }
            EventInfo eventInfo = instance.GetType().GetEvent(eventName);
            if (eventInfo == null)
            {
                throw new ArgumentException(String.Format(
                    "An event named '{0}' on type '{1}' could not be found.",
                    eventName, instance.GetType().FullName));
            }
            return eventInfo;
        }

        private static MethodInfo GetMethodInfo(object instance, string methodName, Type[] types = null, MethodAttributes attrs = MethodAttributes.Public)
        {
            if (instance == null)
            {
                throw new ArgumentNullException("instance");
            }
            if (String.IsNullOrEmpty(methodName))
            {
                throw new ArgumentException("A method must be specified.", "methodName");
            }

            MethodInfo methodInfo;
            if (types != null)
            {
                methodInfo = instance.GetType().GetMethod(methodName,
                                                          BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                                                          null,
                                                          types,
                                                          null);
            }
            else
            {
                methodInfo = instance.GetType().GetMethod(methodName,
                                                          BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            }

            if (methodInfo == null)
            {
                throw new ArgumentException(String.Format(
                    "A method named '{0}' on type '{1}' could not be found.",
                    methodName, instance.GetType().FullName));
            }

            if ((methodInfo.Attributes & attrs) != attrs)
            {
                throw new ArgumentException(String.Format(
                    "Method '{0}' on type '{1}' with attributes '{2}' does not match the attributes '{3}'.",
                    methodName, instance.GetType().FullName, methodInfo.Attributes, attrs));
            }

            return methodInfo;
        }

        private static PropertyInfo GetPropertyInfo(object instance, string propertyName)
        {
            if (instance == null)
            {
                throw new ArgumentNullException("instance");
            }
            if (String.IsNullOrEmpty(propertyName))
            {
                throw new ArgumentException("A property must be specified.", "propertyName");
            }
            PropertyInfo propInfo = instance.GetType().GetProperty(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            if (propInfo == null)
            {
                throw new ArgumentException(String.Format(
                    "A property named '{0}' on type '{1}' could not be found.",
                    propertyName, instance.GetType().FullName));
            }
            return propInfo;
        }

        private static void TestAttribute<TAttribute>(MemberInfo memberInfo, TAttribute attributeValue)
            where TAttribute : Attribute
        {
            object[] attrs = memberInfo.GetCustomAttributes(typeof(TAttribute), true);

            if (attributeValue == null)
            {
                Assert.True(attrs.Length == 0, "Member should not have an attribute of type " + typeof(TAttribute));
            }
            else
            {
                Assert.True(attrs != null && attrs.Length > 0,
                            "Member does not have an attribute of type " + typeof(TAttribute));
                Assert.Equal(attributeValue, attrs[0]);
            }
        }

        public static void TestBooleanProperty(object instance, string propertyName, bool initialValue, bool testDefaultValue)
        {
            // Assert initial value
            TestGetPropertyValue(instance, propertyName, initialValue);

            if (testDefaultValue)
            {
                // Assert DefaultValue attribute matches inital value
                TestDefaultValue(instance, propertyName);
            }

            TestPropertyValue(instance, propertyName, true);
            TestPropertyValue(instance, propertyName, false);
        }

        public static void TestDefaultValue(object instance, string propertyName)
        {
            PropertyInfo propInfo = GetPropertyInfo(instance, propertyName);

            object initialValue = propInfo.GetValue(instance, null);
            TestAttribute(propInfo, new DefaultValueAttribute(initialValue));
        }

        public static void TestEvent<TEventArgs>(object instance, string eventName, TEventArgs eventArgs) where TEventArgs : EventArgs
        {
            EventInfo eventInfo = GetEventInfo(instance, eventName);

            // Assert category "Action"
            TestAttribute(eventInfo, new CategoryAttribute("Action"));

            // Call protected method with no event handlers, assert no error
            MethodInfo methodInfo = GetMethodInfo(instance, "On" + eventName, attrs: MethodAttributes.Family | MethodAttributes.Virtual);
            methodInfo.Invoke(instance, new object[] { eventArgs });

            // Attach handler, call method, assert fires once
            List<object> eventHandlerArgs = new List<object>();
            EventHandler<TEventArgs> handler = new EventHandler<TEventArgs>(delegate(object sender, TEventArgs t)
            {
                eventHandlerArgs.Add(sender);
                eventHandlerArgs.Add(t);
            });
            eventInfo.AddEventHandler(instance, handler);
            methodInfo.Invoke(instance, new object[] { eventArgs });
            Assert.Equal(new[] { instance, eventArgs }, eventHandlerArgs.ToArray());

            // Detach handler, call method, assert not fired
            eventHandlerArgs = new List<object>();
            eventInfo.RemoveEventHandler(instance, handler);
            methodInfo.Invoke(instance, new object[] { eventArgs });
            Assert.Empty(eventHandlerArgs);
        }

        public static void TestGetPropertyValue(object instance, string propertyName, object valueToCheck)
        {
            PropertyInfo propInfo = GetPropertyInfo(instance, propertyName);
            object value = propInfo.GetValue(instance, null);
            Assert.Equal(valueToCheck, value);
        }

        public static void TestEnumProperty<TEnumValue>(object instance, string propertyName, TEnumValue initialValue, bool testDefaultValue)
        {
            // Assert initial value
            TestGetPropertyValue(instance, propertyName, initialValue);

            if (testDefaultValue)
            {
                // Assert DefaultValue attribute matches inital value
                TestDefaultValue(instance, propertyName);
            }

            PropertyInfo propInfo = GetPropertyInfo(instance, propertyName);

            // Values are sorted numerically
            TEnumValue[] values = (TEnumValue[])Enum.GetValues(propInfo.PropertyType);

            // Assert get/set works for all valid enum values
            foreach (TEnumValue value in values)
            {
                TestPropertyValue(instance, propertyName, value);
            }

            // Assert ArgumentOutOfRangeException is thrown for value one less than smallest
            // enum value, and one more than largest enum value
            var targetException = Assert.Throws<TargetInvocationException>(() => propInfo.SetValue(instance, Convert.ToInt32(values[0]) - 1, null));
            Assert.IsType<ArgumentOutOfRangeException>(targetException.InnerException);

            targetException = Assert.Throws<TargetInvocationException>(() => propInfo.SetValue(instance, Convert.ToInt32(values[values.Length - 1]) + 1, null));
            Assert.IsType<ArgumentOutOfRangeException>(targetException.InnerException);
        }

        public static void TestInt32Property(object instance, string propertyName, int value1, int value2)
        {
            TestPropertyValue(instance, propertyName, value1);
            TestPropertyValue(instance, propertyName, value2);
        }

        public static void TestPropertyWithDefaultInstance(object instance, string propertyName, object valueToSet)
        {
            PropertyInfo propInfo = GetPropertyInfo(instance, propertyName);

            // Set to explicit property
            propInfo.SetValue(instance, valueToSet, null);
            object value = propInfo.GetValue(instance, null);
            Assert.Equal(valueToSet, value);

            // Set to null
            propInfo.SetValue(instance, null, null);
            value = propInfo.GetValue(instance, null);
            Assert.IsAssignableFrom(propInfo.PropertyType, value);
        }

        public static void TestPropertyWithDefaultInstance(object instance, string propertyName, object valueToSet, object defaultValue)
        {
            PropertyInfo propInfo = GetPropertyInfo(instance, propertyName);

            // Set to explicit property
            propInfo.SetValue(instance, valueToSet, null);
            object value = propInfo.GetValue(instance, null);
            Assert.Same(valueToSet, value);

            // Set to null
            propInfo.SetValue(instance, null, null);
            value = propInfo.GetValue(instance, null);
            Assert.Equal(defaultValue, value);
        }

        public static void TestPropertyValue(object instance, string propertyName, object value)
        {
            TestPropertyValue(instance, propertyName, value, value);
        }

        public static void TestPropertyValue(object instance, string propertyName, object valueToSet, object valueToCheck)
        {
            PropertyInfo propInfo = GetPropertyInfo(instance, propertyName);
            propInfo.SetValue(instance, valueToSet, null);
            object value = propInfo.GetValue(instance, null);
            Assert.Equal(valueToCheck, value);
        }

        public static void TestStringParams(object instance, Type[] constructorParameterTypes, object[] parameters)
        {
            ConstructorInfo ctor = GetConstructorInfo(instance, constructorParameterTypes);
            TestStringParams(ctor, instance, parameters);
        }

        public static void TestStringParams(object instance, string methodName, object[] parameters)
        {
            TestStringParams(instance, methodName, null, parameters);
        }

        public static void TestStringParams(object instance, string methodName, Type[] types, object[] parameters)
        {
            MethodInfo method = GetMethodInfo(instance, methodName, types);
            TestStringParams(method, instance, parameters);
        }

        private static void TestStringParams(MethodBase method, object instance, object[] parameters)
        {
            ParameterInfo[] parameterInfos = method.GetParameters();
            foreach (ParameterInfo parameterInfo in parameterInfos)
            {
                if (parameterInfo.ParameterType == typeof(String))
                {
                    object originalParameter = parameters[parameterInfo.Position];

                    parameters[parameterInfo.Position] = null;
                    Assert.ThrowsArgumentNullOrEmpty(
                        delegate()
                        {
                            try
                            {
                                method.Invoke(instance, parameters);
                            }
                            catch (TargetInvocationException e)
                            {
                                throw e.InnerException;
                            }
                        },
                        parameterInfo.Name);

                    parameters[parameterInfo.Position] = String.Empty;
                    Assert.ThrowsArgumentNullOrEmpty(
                        delegate()
                        {
                            try
                            {
                                method.Invoke(instance, parameters);
                            }
                            catch (TargetInvocationException e)
                            {
                                throw e.InnerException;
                            }
                        },
                        parameterInfo.Name);

                    parameters[parameterInfo.Position] = originalParameter;
                }
            }
        }

        public static void TestStringProperty(object instance, string propertyName, string initialValue,
                                              bool testDefaultValueAttribute = false, bool allowNullAndEmpty = true,
                                              string nullAndEmptyReturnValue = "")
        {
            // Assert initial value
            TestGetPropertyValue(instance, propertyName, initialValue);

            if (testDefaultValueAttribute)
            {
                // Assert DefaultValue attribute matches inital value
                TestDefaultValue(instance, propertyName);
            }

            if (allowNullAndEmpty)
            {
                // Assert get/set works for null
                TestPropertyValue(instance, propertyName, null, nullAndEmptyReturnValue);

                // Assert get/set works for String.Empty
                TestPropertyValue(instance, propertyName, String.Empty, nullAndEmptyReturnValue);
            }
            else
            {
                Assert.ThrowsArgumentNullOrEmpty(
                    delegate()
                    {
                        try
                        {
                            TestPropertyValue(instance, propertyName, null);
                        }
                        catch (TargetInvocationException e)
                        {
                            throw e.InnerException;
                        }
                    },
                    "value");
                Assert.ThrowsArgumentNullOrEmpty(
                    delegate()
                    {
                        try
                        {
                            TestPropertyValue(instance, propertyName, String.Empty);
                        }
                        catch (TargetInvocationException e)
                        {
                            throw e.InnerException;
                        }
                    },
                    "value");
            }

            // Assert get/set works for arbitrary value
            TestPropertyValue(instance, propertyName, "TestValue");
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/DataSets/CommonUnitTestDataSets.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.ObjectModel;
using Microsoft.TestCommon.Types;

namespace Microsoft.TestCommon
{
    public class CommonUnitTestDataSets
    {
        public static ValueTypeTestData<char> Chars { get { return TestData.CharTestData; } }
        public static ValueTypeTestData<int> Ints { get { return TestData.IntTestData; } }
        public static ValueTypeTestData<uint> Uints { get { return TestData.UintTestData; } }
        public static ValueTypeTestData<short> Shorts { get { return TestData.ShortTestData; } }
        public static ValueTypeTestData<ushort> Ushorts { get { return TestData.UshortTestData; } }
        public static ValueTypeTestData<long> Longs { get { return TestData.LongTestData; } }
        public static ValueTypeTestData<ulong> Ulongs { get { return TestData.UlongTestData; } }
        public static ValueTypeTestData<byte> Bytes { get { return TestData.ByteTestData; } }
        public static ValueTypeTestData<sbyte> SBytes { get { return TestData.SByteTestData; } }
        public static ValueTypeTestData<bool> Bools { get { return TestData.BoolTestData; } }
        public static ValueTypeTestData<double> Doubles { get { return TestData.DoubleTestData; } }
        public static ValueTypeTestData<float> Floats { get { return TestData.FloatTestData; } }
        public static ValueTypeTestData<DateTime> DateTimes { get { return TestData.DateTimeTestData; } }
        public static ValueTypeTestData<Decimal> Decimals { get { return TestData.DecimalTestData; } }
        public static ValueTypeTestData<TimeSpan> TimeSpans { get { return TestData.TimeSpanTestData; } }
        public static ValueTypeTestData<Guid> Guids { get { return TestData.GuidTestData; } }
        public static ValueTypeTestData<DateTimeOffset> DateTimeOffsets { get { return TestData.DateTimeOffsetTestData; } }
        public static ValueTypeTestData<SimpleEnum> SimpleEnums { get { return TestData.SimpleEnumTestData; } }
        public static ValueTypeTestData<LongEnum> LongEnums { get { return TestData.LongEnumTestData; } }
        public static ValueTypeTestData<FlagsEnum> FlagsEnums { get { return TestData.FlagsEnumTestData; } }
        public static TestData<string> EmptyStrings { get { return TestData.EmptyStrings; } }
        public static RefTypeTestData<string> Strings { get { return TestData.StringTestData; } }
        public static TestData<string> NonNullEmptyStrings { get { return TestData.NonNullEmptyStrings; } }
        public static RefTypeTestData<ISerializableType> ISerializableTypes { get { return TestData.ISerializableTypeTestData; } }
        public static ReadOnlyCollection<TestData> ValueTypeTestDataCollection { get { return TestData.ValueTypeTestDataCollection; } }
        public static ReadOnlyCollection<TestData> RefTypeTestDataCollection { get { return TestData.RefTypeTestDataCollection; } }
        public static ReadOnlyCollection<TestData> ValueAndRefTypeTestDataCollection { get { return TestData.ValueAndRefTypeTestDataCollection; } }
        public static ReadOnlyCollection<TestData> RepresentativeValueAndRefTypeTestDataCollection { get { return TestData.RepresentativeValueAndRefTypeTestDataCollection; } }
    }
}

================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/DataSets/RefTypeTestData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Microsoft.TestCommon
{
    public class RefTypeTestData<T> : TestData<T> where T : class
    {
        private Func<IEnumerable<T>> testDataProvider;
        private Func<IEnumerable<T>> derivedTypeTestDataProvider;
        private Func<IEnumerable<T>> knownTypeTestDataProvider;

        public RefTypeTestData(Func<IEnumerable<T>> testDataProvider)
        {
            if (testDataProvider == null)
            {
                throw new ArgumentNullException("testDataProvider");
            }

            this.testDataProvider = testDataProvider;
            this.RegisterTestDataVariation(TestDataVariations.WithNull, this.Type, GetNullTestData);
        }

        public RefTypeTestData(
            Func<IEnumerable<T>> testDataProvider,
            Func<IEnumerable<T>> derivedTypeTestDataProvider,
            Func<IEnumerable<T>> knownTypeTestDataProvider)
            : this(testDataProvider)
        {
            this.derivedTypeTestDataProvider = derivedTypeTestDataProvider;
            if (this.derivedTypeTestDataProvider != null)
            {
                this.RegisterTestDataVariation(TestDataVariations.AsDerivedType, this.Type, this.GetTestDataAsDerivedType);
            }

            this.knownTypeTestDataProvider = knownTypeTestDataProvider;
            if (this.knownTypeTestDataProvider != null)
            {
                this.RegisterTestDataVariation(TestDataVariations.AsKnownType, this.Type, this.GetTestDataAsDerivedKnownType);
            }
        }

        public T GetNullTestData()
        {
            return null;
        }

        public IEnumerable<T> GetTestDataAsDerivedType()
        {
            if (this.derivedTypeTestDataProvider != null)
            {
                return this.derivedTypeTestDataProvider();
            }

            return Enumerable.Empty<T>();
        }

        public IEnumerable<T> GetTestDataAsDerivedKnownType()
        {
            if (this.knownTypeTestDataProvider != null)
            {
                return this.knownTypeTestDataProvider();
            }

            return Enumerable.Empty<T>();
        }

        protected override IEnumerable<T> GetTypedTestData()
        {
            return this.testDataProvider();
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/DataSets/TestData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Microsoft.TestCommon.Types;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// A base class for test data.  A <see cref="TestData"/> instance is associated with a given type, and the <see cref="TestData"/> instance can
    /// provide instances of the given type to use as data in tests.  The same <see cref="TestData"/> instance can also provide instances
    /// of types related to the given type, such as a <see cref="List<>"/> of the type.  See the <see cref="TestDataVariations"/> enum for all the
    /// variations of test data that a <see cref="TestData"/> instance can provide.
    /// </summary>
    public abstract class TestData
    {
        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="char"/>.
        /// </summary>
        public static readonly ValueTypeTestData<char> CharTestData = new ValueTypeTestData<char>('a', Char.MinValue, Char.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="int"/>.
        /// </summary>
        public static readonly ValueTypeTestData<int> IntTestData = new ValueTypeTestData<int>(-1, 0, 1, Int32.MinValue, Int32.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="uint"/>.
        /// </summary>
        public static readonly ValueTypeTestData<uint> UintTestData = new ValueTypeTestData<uint>(0, 1, UInt32.MinValue, UInt32.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="short"/>.
        /// </summary>
        public static readonly ValueTypeTestData<short> ShortTestData = new ValueTypeTestData<short>(-1, 0, 1, Int16.MinValue, Int16.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="ushort"/>.
        /// </summary>
        public static readonly ValueTypeTestData<ushort> UshortTestData = new ValueTypeTestData<ushort>(0, 1, UInt16.MinValue, UInt16.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="long"/>.
        /// </summary>
        public static readonly ValueTypeTestData<long> LongTestData = new ValueTypeTestData<long>(-1, 0, 1, Int64.MinValue, Int64.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="ulong"/>.
        /// </summary>
        public static readonly ValueTypeTestData<ulong> UlongTestData = new ValueTypeTestData<ulong>(0, 1, UInt64.MinValue, UInt64.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="byte"/>.
        /// </summary>
        public static readonly ValueTypeTestData<byte> ByteTestData = new ValueTypeTestData<byte>(0, 1, Byte.MinValue, Byte.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="sbyte"/>.
        /// </summary>
        public static readonly ValueTypeTestData<sbyte> SByteTestData = new ValueTypeTestData<sbyte>(-1, 0, 1, SByte.MinValue, SByte.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="bool"/>.
        /// </summary>
        public static readonly ValueTypeTestData<bool> BoolTestData = new ValueTypeTestData<bool>(true, false);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="double"/>.
        /// </summary>
        public static readonly ValueTypeTestData<double> DoubleTestData = new ValueTypeTestData<double>(
            -1.0,
            0.0,
            1.0,
            double.MinValue,
            double.MaxValue,
            double.PositiveInfinity,
            double.NegativeInfinity);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="float"/>.
        /// </summary>
        public static readonly ValueTypeTestData<float> FloatTestData = new ValueTypeTestData<float>(
            -1.0f,
            0.0f,
            1.0f,
            float.MinValue,
            float.MaxValue,
            float.PositiveInfinity,
            float.NegativeInfinity);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="decimal"/>.
        /// </summary>
        public static readonly ValueTypeTestData<decimal> DecimalTestData = new ValueTypeTestData<decimal>(
            -1M,
            0M,
            1M,
            decimal.MinValue,
            decimal.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="DateTime"/>.
        /// </summary>
        public static readonly ValueTypeTestData<DateTime> DateTimeTestData = new ValueTypeTestData<DateTime>(
            DateTime.Now,
            DateTime.UtcNow,
            DateTime.MaxValue,
            DateTime.MinValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="TimeSpan"/>.
        /// </summary>
        public static readonly ValueTypeTestData<TimeSpan> TimeSpanTestData = new ValueTypeTestData<TimeSpan>(
            TimeSpan.MinValue,
            TimeSpan.MaxValue);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="Guid"/>.
        /// </summary>
        public static readonly ValueTypeTestData<Guid> GuidTestData = new ValueTypeTestData<Guid>(
            Guid.NewGuid(),
            Guid.Empty);

        /// <summary>
        /// Common <see cref="TestData"/> for a <see cref="DateTimeOffset"/>.
        /// </summary>
        public static readonly ValueTypeTestData<DateTimeOffset> DateTimeOffsetTestData = new ValueTypeTestData<DateTimeOffset>(
            DateTimeOffset.MaxValue,
            DateTimeOffset.MinValue,
            new DateTimeOffset(DateTime.Now));

        /// <summary>
        /// Common <see cref="TestData"/> for an <c>enum</c>.
        /// </summary>
        public static readonly ValueTypeTestData<SimpleEnum> SimpleEnumTestData = new ValueTypeTestData<SimpleEnum>(
            SimpleEnum.First,
            SimpleEnum.Second,
            SimpleEnum.Third);

        /// <summary>
        /// Common <see cref="TestData"/> for an <c>enum</c> implemented with a <see cref="long"/>.
        /// </summary>
        public static readonly ValueTypeTestData<LongEnum> LongEnumTestData = new ValueTypeTestData<LongEnum>(
            LongEnum.FirstLong,
            LongEnum.SecondLong,
            LongEnum.ThirdLong);

        /// <summary>
        /// Common <see cref="TestData"/> for an <c>enum</c> decorated with a <see cref="FlagsAttribtute"/>.
        /// </summary>
        public static readonly ValueTypeTestData<FlagsEnum> FlagsEnumTestData = new ValueTypeTestData<FlagsEnum>(
            FlagsEnum.One,
            FlagsEnum.Two,
            FlagsEnum.Four);

        /// <summary>
        /// Expected permutations of non supported file paths.
        /// </summary>
        public static readonly TestData<string> NotSupportedFilePaths = new RefTypeTestData<string>(() => new List<string>() {
            "cc:\\a\\b",
        });

        /// <summary>
        /// Expected permutations of invalid file paths.
        /// </summary>
        public static readonly TestData<string> InvalidNonNullFilePaths = new RefTypeTestData<string>(() => new List<string>() {
            String.Empty,
            "",
            " ",
            "  ",
            "\t\t \n ",
            "c:\\a<b",
            "c:\\a>b",
            "c:\\a\"b",
            "c:\\a\tb",
            "c:\\a|b",
            "c:\\a\bb",
            "c:\\a\0b",
        });

        /// <summary>
        /// All expected permutations of an empty string.
        /// </summary>
        public static readonly TestData<string> NonNullEmptyStrings = new RefTypeTestData<string>(() => new List<string>() { String.Empty, " ", "\t\r\n" });

        /// <summary>
        /// All expected permutations of an empty string.
        /// </summary>
        public static readonly TestData<string> EmptyStrings = new RefTypeTestData<string>(() => new List<string>() { null, String.Empty, " ", "\t\r\n" });

        /// <summary>
        ///  Common <see cref="TestData"/> for a <see cref="string"/>.
        /// </summary>
        public static readonly RefTypeTestData<string> StringTestData = new RefTypeTestData<string>(() => new List<string>() {
            "",
            " ",            // one space
            "  ",           // multiple spaces
            " data ",       // leading and trailing whitespace
            "\t\t \n ",
            "Some String!"});

        /// <summary>
        ///  Common <see cref="TestData"/> for a class that implements <see cref="ISerializable"/>.
        /// </summary>
        public static readonly RefTypeTestData<ISerializableType> ISerializableTypeTestData = new RefTypeTestData<ISerializableType>(
            ISerializableType.GetTestData);

        /// <summary>
        /// A read-only collection of value type test data.
        /// </summary>
        public static readonly ReadOnlyCollection<TestData> ValueTypeTestDataCollection = new ReadOnlyCollection<TestData>(new TestData[] {
            CharTestData,
            IntTestData,
            UintTestData,
            ShortTestData,
            UshortTestData,
            LongTestData,
            UlongTestData,
            ByteTestData,
            SByteTestData,
            BoolTestData,
            DoubleTestData,
            FloatTestData,
            DecimalTestData,
            TimeSpanTestData,
            GuidTestData,
            DateTimeOffsetTestData,
            SimpleEnumTestData,
            LongEnumTestData,
            FlagsEnumTestData});

        /// <summary>
        /// A read-only collection of reference type test data.
        /// </summary>
        public static readonly ReadOnlyCollection<TestData> RefTypeTestDataCollection = new ReadOnlyCollection<TestData>(new TestData[] {
            StringTestData,
            ISerializableTypeTestData});

        /// <summary>
        /// A read-only collection of value and reference type test data.
        /// </summary>
        public static readonly ReadOnlyCollection<TestData> ValueAndRefTypeTestDataCollection = new ReadOnlyCollection<TestData>(
            ValueTypeTestDataCollection.Concat(RefTypeTestDataCollection).ToList());

        /// <summary>
        /// A read-only collection of representative values and reference type test data.
        /// Uses where exhaustive coverage is not required.
        /// </summary>
        public static readonly ReadOnlyCollection<TestData> RepresentativeValueAndRefTypeTestDataCollection = new ReadOnlyCollection<TestData>(new TestData[] {
            IntTestData,
            BoolTestData,
            SimpleEnumTestData,
            StringTestData,
        });

        private Dictionary<TestDataVariations, TestDataVariationProvider> registeredTestDataVariations;


        /// <summary>
        /// Initializes a new instance of the <see cref="TestData"/> class.
        /// </summary>
        /// <param name="type">The type associated with the <see cref="TestData"/> instance.</param>
        protected TestData(Type type)
        {
            if (type.ContainsGenericParameters)
            {
                throw new InvalidOperationException("Only closed generic types are supported.");
            }

            this.Type = type;
            this.registeredTestDataVariations = new Dictionary<TestDataVariations, TestDataVariationProvider>();
        }

        /// <summary>
        /// Gets the type associated with the <see cref="TestData"/> instance.
        /// </summary>
        public Type Type { get; private set; }


        /// <summary>
        /// Gets the supported test data variations.
        /// </summary>
        /// <returns></returns>
        public IEnumerable<TestDataVariations> GetSupportedTestDataVariations()
        {
            return this.registeredTestDataVariations.Keys;
        }

        /// <summary>
        /// Gets the related type for the given test data variation or returns null if the <see cref="TestData"/> instance
        /// doesn't support the given variation.
        /// </summary>
        /// <param name="variation">The test data variation with which to create the related <see cref="Type"/>.</param>
        /// <returns>The related <see cref="Type"/> for the <see cref="TestData.Type"/> as given by the test data variation.</returns>
        /// <example>
        /// For example, if the given <see cref="TestData"/> was created for <see cref="string"/> test data and the varation parameter
        /// was <see cref="TestDataVariations.AsList"/> then the returned type would be <see cref="List<string>"/>.
        /// </example>
        public Type GetAsTypeOrNull(TestDataVariations variation)
        {
            TestDataVariationProvider testDataVariation = null;
            if (this.registeredTestDataVariations.TryGetValue(variation, out testDataVariation))
            {
                return testDataVariation.Type;
            }

            return null;
        }

        /// <summary>
        /// Gets test data for the given test data variation or returns null if the <see cref="TestData"/> instance
        /// doesn't support the given variation.
        /// </summary>
        /// <param name="variation">The test data variation with which to create the related test data.</param>
        /// <returns>Test data of the type specified by the <see cref="TestData.GetAsTypeOrNull"/> method.</returns>
        public object GetAsTestDataOrNull(TestDataVariations variation)
        {
            TestDataVariationProvider testDataVariation = null;
            if (this.registeredTestDataVariations.TryGetValue(variation, out testDataVariation))
            {
                return testDataVariation.TestDataProvider();
            }

            return null;
        }


        /// <summary>
        /// Allows derived classes to register a <paramref name="testDataProvider "/> <see cref="Func<>"/> that will
        /// provide test data for a given variation.
        /// </summary>
        /// <param name="variation">The variation with which to register the <paramref name="testDataProvider "/>r.</param>
        /// <param name="type">The type of the test data created by the <paramref name="testDataProvider "/></param>
        /// <param name="testDataProvider">A <see cref="Func<>"/> that will provide test data.</param>
        protected void RegisterTestDataVariation(TestDataVariations variation, Type type, Func<object> testDataProvider)
        {
            this.registeredTestDataVariations.Add(variation, new TestDataVariationProvider(type, testDataProvider));
        }

        private class TestDataVariationProvider
        {
            public TestDataVariationProvider(Type type, Func<object> testDataProvider)
            {
                this.Type = type;
                this.TestDataProvider = testDataProvider;
            }


            public Func<object> TestDataProvider { get; private set; }

            public Type Type { get; private set; }
        }
    }


    /// <summary>
    /// A generic base class for test data.
    /// </summary>
    /// <typeparam name="T">The type associated with the test data.</typeparam>
    public abstract class TestData<T> : TestData, IEnumerable<T>
    {
        private static readonly Type OpenIEnumerableType = typeof(IEnumerable<>);
        private static readonly Type OpenListType = typeof(List<>);
        private static readonly Type OpenIQueryableType = typeof(IQueryable<>);
        private static readonly Type OpenDictionaryType = typeof(Dictionary<,>);
        private static readonly Type OpenTestDataHolderType = typeof(TestDataHolder<>);

        /// <summary>
        /// Initializes a new instance of the <see cref="TestData&lt;T&gt;"/> class.
        /// </summary>
        protected TestData()
            : base(typeof(T))
        {
            Type[] typeParams = new Type[] { this.Type };
            Type[] dictionaryTypeParams = new Type[] { typeof(string), this.Type };

            Type arrayType = this.Type.MakeArrayType();
            Type listType = OpenListType.MakeGenericType(typeParams);
            Type iEnumerableType = OpenIEnumerableType.MakeGenericType(typeParams);
            Type iQueryableType = OpenIQueryableType.MakeGenericType(typeParams);
            Type dictionaryType = OpenDictionaryType.MakeGenericType(dictionaryTypeParams);
            Type testDataHolderType = OpenTestDataHolderType.MakeGenericType(typeParams);

            this.RegisterTestDataVariation(TestDataVariations.AsInstance, this.Type, () => GetTypedTestData());
            this.RegisterTestDataVariation(TestDataVariations.AsArray, arrayType, GetTestDataAsArray);
            this.RegisterTestDataVariation(TestDataVariations.AsIEnumerable, iEnumerableType, GetTestDataAsIEnumerable);
            this.RegisterTestDataVariation(TestDataVariations.AsIQueryable, iQueryableType, GetTestDataAsIQueryable);
            this.RegisterTestDataVariation(TestDataVariations.AsList, listType, GetTestDataAsList);
            this.RegisterTestDataVariation(TestDataVariations.AsDictionary, dictionaryType, GetTestDataAsDictionary);
            this.RegisterTestDataVariation(TestDataVariations.AsClassMember, testDataHolderType, GetTestDataInHolder);
        }

        public IEnumerator<T> GetEnumerator()
        {
            return (IEnumerator<T>)this.GetTypedTestData().ToList().GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator)this.GetTypedTestData().ToList().GetEnumerator();
        }

        /// <summary>
        /// Gets the test data as an array.
        /// </summary>
        /// <returns>An array of test data of the given type.</returns>
        public T[] GetTestDataAsArray()
        {
            return this.GetTypedTestData().ToArray();
        }

        /// <summary>
        /// Gets the test data as a <see cref="List<>"/>.
        /// </summary>
        /// <returns>A <see cref="List<>"/> of test data of the given type.</returns>
        public List<T> GetTestDataAsList()
        {
            return this.GetTypedTestData().ToList();
        }

        /// <summary>
        /// Gets the test data as an <see cref="IEnumerable<>"/>.
        /// </summary>
        /// <returns>An <see cref="IEnumerable<>"/> of test data of the given type.</returns>
        public IEnumerable<T> GetTestDataAsIEnumerable()
        {
            return this.GetTypedTestData().AsEnumerable();
        }

        /// <summary>
        /// Gets the test data as an <see cref="IQueryable<>"/>.
        /// </summary>
        /// <returns>An <see cref="IQueryable<>"/> of test data of the given type.</returns>
        public IQueryable<T> GetTestDataAsIQueryable()
        {
            return this.GetTypedTestData().AsQueryable();
        }

        public Dictionary<string, T> GetTestDataAsDictionary()
        {
            // Some TestData collections contain duplicates e.g. UintTestData contains both 0 and UInt32.MinValue.
            // Therefore use dictionaryKey, not _unused.ToString(). Do not reuse key to keep dictionaries consistent
            // if enumerated multiple times.
            int dictionaryKey = 0;
            return this.GetTypedTestData().ToDictionary(_unused => (dictionaryKey++).ToString());
        }

        public IEnumerable<TestDataHolder<T>> GetTestDataInHolder()
        {
            return this.GetTypedTestData().Select(value => new TestDataHolder<T> { V1 = value, });
        }

        /// <summary>
        /// Must be implemented by derived types to return test data of the given type.
        /// </summary>
        /// <returns>Test data of the given type.</returns>
        protected abstract IEnumerable<T> GetTypedTestData();
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/DataSets/TestDataHolder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// Equatable class wrapping a single instance of type <paramref name="T"/>. Equatable to ease test assertions.
    /// </summary>
    /// <typeparam name="T">The <see cref="Type"/> to wrap.</typeparam>
    public class TestDataHolder<T> : IEquatable<TestDataHolder<T>>
    {
        public T V1 { get; set; }

        bool IEquatable<TestDataHolder<T>>.Equals(TestDataHolder<T> other)
        {
            if (other == null)
            {
                return false;
            }

            return Object.Equals(V1, other.V1);
        }

        public override bool Equals(object obj)
        {
            TestDataHolder<T> that = obj as TestDataHolder<T>;
            return ((IEquatable<TestDataHolder<T>>)this).Equals(that);
        }

        public override int GetHashCode()
        {
            if (typeof(ValueType).IsAssignableFrom(typeof(T)) || V1 != null)
            {
                return V1.GetHashCode();
            }
            else
            {
                return 0;
            }
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.InvariantCulture, "{{ V1: '{0}' }}", V1);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/DataSets/TestDataVariations.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// An flags enum that can be used to indicate different variations of a given 
    /// <see cref="TestData"/> instance.
    /// </summary>
    [Flags]
    public enum TestDataVariations
    {
        /// <summary>
        /// An individual instance of a given <see cref="TestData"/> type.
        /// </summary>
        AsInstance = 0x1,

        /// <summary>
        /// An individual instance of a type that derives from a given <see cref="TestData"/> type.
        /// </summary>
        AsDerivedType = 0x2,

        /// <summary>
        /// An individual instance of a given <see cref="TestData"/> type that has a property value 
        /// that is a known type of the declared property type.
        /// </summary>
        AsKnownType = 0x4,

        /// <summary>
        /// A <see cref="Nullable<>"/> instance of a given <see cref="TestData"/> type.  Only applies to
        /// instances of <see cref="ValueTypeTestData"/>.
        /// </summary>
        AsNullable = 0x8,

        /// <summary>
        /// An instance of a <see cref="System.Collections.Generic.List<>"/> of a given <see cref="TestData"/> type.
        /// </summary>
        AsList = 0x10,

        /// <summary>
        /// An instance of a array of the <see cref="TestData"/> type.
        /// </summary>
        AsArray = 0x20,

        /// <summary>
        /// An instance of an <see cref="System.Collections.Generic.IEnumerable<>"/> of a given <see cref="TestData"/> type.
        /// </summary>
        AsIEnumerable = 0x40,

        /// <summary>
        /// An instance of an <see cref="System.Linq.IQueryable<>"/> of a given <see cref="TestData"/> type.
        /// </summary>
        AsIQueryable = 0x80,

        /// <summary>
        /// An instance of a DataContract type in which a given <see cref="TestData"/> type is a member.
        /// </summary>
        AsDataMember = 0x100,

        /// <summary>
        /// An instance of a type in which a given <see cref="TestData"/> type is decorated with a 
        /// <see cref="System.Xml.Serialization.XmlElementAttribute"/>.
        /// </summary>
        AsXmlElementProperty = 0x200,

        /// <summary>
        /// An instance of a <see cref="System.Collections.Generic.IDictionary{string,TValue}"/> of a given
        /// <see cref="TestData"/> type.
        /// </summary>
        AsDictionary = 0x400,

        /// <summary>
        /// Add a <c>null</c> instance of the given <see cref="TestData"/> type to the data set.  This variation is
        /// not included in <see cref="All"/> or other variation masks.
        /// </summary>
        WithNull = 0x800,

        /// <summary>
        /// Individual instances of <see cref="TestDataHolder{T}"/> containing the given <see cref="TestData"/>.  This
        /// variation is not included in <see cref="All"/> or other variation masks.
        /// </summary>
        AsClassMember = 0x1000,

        /// <summary>
        /// All of the flags for single instance variations of a given <see cref="TestData"/> type.
        /// </summary>
        AllSingleInstances = AsInstance | AsDerivedType | AsKnownType | AsNullable,

        /// <summary>
        /// All of the flags for collection variations of a given <see cref="TestData"/> type.
        /// </summary>
        AllCollections = AsList | AsArray | AsIEnumerable | AsIQueryable | AsDictionary,

        /// <summary>
        /// All of the flags for variations in which a given <see cref="TestData"/> type is a property on another type.
        /// </summary>
        AllProperties = AsDataMember | AsXmlElementProperty,

        /// <summary>
        /// All of the flags for interface collection variations of a given <see cref="TestData"/> type.
        /// </summary>
        AllInterfaces = AsIEnumerable | AsIQueryable,

        /// <summary>
        /// All of the flags except for the interface collection variations of a given <see cref="TestData"/> type.
        /// </summary>
        AllNonInterfaces = All & ~AllInterfaces,

        /// <summary>
        /// All of the flags for all of the variations of a given <see cref="TestData"/> type.
        /// </summary>
        All = AllSingleInstances | AllCollections | AllProperties
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/DataSets/ValueTypeTestData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Microsoft.TestCommon
{
    public class ValueTypeTestData<T> : TestData<T> where T : struct
    {
        private static readonly Type OpenNullableType = typeof(Nullable<>);
        private T[] testData;

        public ValueTypeTestData(params T[] testData)
            : base()
        {
            this.testData = testData;

            Type[] typeParams = new Type[] { this.Type };
            this.RegisterTestDataVariation(TestDataVariations.WithNull, OpenNullableType.MakeGenericType(typeParams), GetNullTestData);
            this.RegisterTestDataVariation(TestDataVariations.AsNullable, OpenNullableType.MakeGenericType(typeParams), GetTestDataAsNullable);
        }

        public object GetNullTestData()
        {
            return null;
        }

        public IEnumerable<Nullable<T>> GetTestDataAsNullable()
        {
            return this.GetTypedTestData().Select(d => new Nullable<T>(d));
        }

        protected override IEnumerable<T> GetTypedTestData()
        {
            return this.testData;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/GenericTypeAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;
using System.Reflection;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// MSTest assertion class to provide convenience and assert methods for generic types
    /// whose type parameters are not known at compile time.
    /// </summary>
    public class GenericTypeAssert
    {
        private static readonly GenericTypeAssert singleton = new GenericTypeAssert();

        public static GenericTypeAssert Singleton { get { return singleton; } }

        /// <summary>
        /// Asserts the given <paramref name="genericBaseType"/> is a generic type and creates a new
        /// bound generic type using <paramref name="genericParameterType"/>.  It then asserts there
        /// is a constructor that will accept <paramref name="parameterTypes"/> and returns it.
        /// </summary>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterType">The type of the single generic parameter to apply to create a bound generic type.</param>
        /// <param name="parameterTypes">The list of parameter types for a constructor that must exist.</param>
        /// <returns>The <see cref="ConstructorInfo"/> of that constructor which may be invoked to create that new generic type.</returns>
        public ConstructorInfo GetConstructor(Type genericBaseType, Type genericParameterType, params Type[] parameterTypes)
        {
            Assert.NotNull(genericBaseType);
            Assert.True(genericBaseType.IsGenericTypeDefinition);
            Assert.NotNull(genericParameterType);
            Assert.NotNull(parameterTypes);

            Type genericType = genericBaseType.MakeGenericType(new Type[] { genericParameterType });
            ConstructorInfo ctor = genericType.GetConstructor(parameterTypes);
            Assert.True(ctor != null, String.Format("Test error: failed to locate generic ctor for type '{0}<{1}>',", genericBaseType.Name, genericParameterType.Name));
            return ctor;
        }

        /// <summary>
        /// Asserts the given <paramref name="genericBaseType"/> is a generic type and creates a new
        /// bound generic type using <paramref name="genericParameterType"/>.  It then asserts there
        /// is a constructor that will accept <paramref name="parameterTypes"/> and returns it.
        /// </summary>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterTypes">The types of the generic parameters to apply to create a bound generic type.</param>
        /// <param name="parameterTypes">The list of parameter types for a constructor that must exist.</param>
        /// <returns>The <see cref="ConstructorInfo"/> of that constructor which may be invoked to create that new generic type.</returns>
        public ConstructorInfo GetConstructor(Type genericBaseType, Type[] genericParameterTypes, params Type[] parameterTypes)
        {
            Assert.NotNull(genericBaseType);
            Assert.True(genericBaseType.IsGenericTypeDefinition);
            Assert.NotNull(genericParameterTypes);
            Assert.NotNull(parameterTypes);

            Type genericType = genericBaseType.MakeGenericType(genericParameterTypes);
            ConstructorInfo ctor = genericType.GetConstructor(parameterTypes);
            Assert.True(ctor != null, String.Format("Test error: failed to locate generic ctor for type '{0}<>',", genericBaseType.Name));
            return ctor;
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from <see cref="parameterTypes"/>.
        /// </summary>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterType">The type of the single generic parameter to apply to create a bound generic type.</param>
        /// <param name="parameterTypes">The list of parameter types for a constructor that must exist.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor</param>
        /// <returns>The instance created by calling that constructor.</returns>
        public object InvokeConstructor(Type genericBaseType, Type genericParameterType, Type[] parameterTypes, object[] parameterValues)
        {
            ConstructorInfo ctor = GetConstructor(genericBaseType, genericParameterType, parameterTypes);
            Assert.NotNull(parameterValues);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            return ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from <see cref="parameterTypes"/>.
        /// </summary>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterTypse">The types of the generic parameters to apply to create a bound generic type.</param>
        /// <param name="parameterTypes">The list of parameter types for a constructor that must exist.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor</param>
        /// <returns>The instance created by calling that constructor.</returns>
        public object InvokeConstructor(Type genericBaseType, Type[] genericParameterTypes, Type[] parameterTypes, object[] parameterValues)
        {
            ConstructorInfo ctor = GetConstructor(genericBaseType, genericParameterTypes, parameterTypes);
            Assert.NotNull(parameterValues);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            return ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from the types of <paramref name="parameterValues"/>.
        /// </summary>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterType">The type of the single generic parameter to apply to create a bound generic type.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor.  It must be possible to determine the</param>
        /// <returns>The instance created by calling that constructor.</returns>
        public object InvokeConstructor(Type genericBaseType, Type genericParameterType, params object[] parameterValues)
        {
            Assert.NotNull(genericBaseType);
            Assert.True(genericBaseType.IsGenericTypeDefinition);
            Assert.NotNull(genericParameterType);

            Type genericType = genericBaseType.MakeGenericType(new Type[] { genericParameterType });

            ConstructorInfo ctor = FindConstructor(genericType, parameterValues);
            Assert.True(ctor != null, String.Format("Test error: failed to locate generic ctor for type '{0}<{1}>',", genericBaseType.Name, genericParameterType.Name));
            return ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from the types of <paramref name="parameterValues"/>.
        /// </summary>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterTypes">The types of the generic parameters to apply to create a bound generic type.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor.  It must be possible to determine the</param>
        /// <returns>The instance created by calling that constructor.</returns>
        public object InvokeConstructor(Type genericBaseType, Type[] genericParameterTypes, params object[] parameterValues)
        {
            Assert.NotNull(genericBaseType);
            Assert.True(genericBaseType.IsGenericTypeDefinition);
            Assert.NotNull(genericParameterTypes);

            Type genericType = genericBaseType.MakeGenericType(genericParameterTypes);

            ConstructorInfo ctor = FindConstructor(genericType, parameterValues);
            Assert.True(ctor != null, String.Format("Test error: failed to locate generic ctor for type '{0}<>',", genericBaseType.Name));
            return ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from <see cref="parameterTypes"/>.
        /// </summary>
        /// <typeparam name="T">The type of object the constuctor is expected to yield.</typeparam>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterType">The type of the single generic parameter to apply to create a bound generic type.</param>
        /// <param name="parameterTypes">The list of parameter types for a constructor that must exist.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor</param>
        /// <returns>An instance of type <typeparamref name="T"/>.</returns>
        public T InvokeConstructor<T>(Type genericBaseType, Type genericParameterType, Type[] parameterTypes, object[] parameterValues)
        {
            ConstructorInfo ctor = GetConstructor(genericBaseType, genericParameterType, parameterTypes);
            Assert.NotNull(parameterValues);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            return (T)ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from <see cref="parameterTypes"/>.
        /// </summary>
        /// <typeparam name="T">The type of object the constuctor is expected to yield.</typeparam>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterTypes">The types of the generic parameters to apply to create a bound generic type.</param>
        /// <param name="parameterTypes">The list of parameter types for a constructor that must exist.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor</param>
        /// <returns>An instance of type <typeparamref name="T"/>.</returns>
        public T InvokeConstructor<T>(Type genericBaseType, Type[] genericParameterTypes, Type[] parameterTypes, object[] parameterValues)
        {
            ConstructorInfo ctor = GetConstructor(genericBaseType, genericParameterTypes, parameterTypes);
            Assert.NotNull(parameterValues);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            return (T)ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from <see cref="parameterTypes"/>.
        /// </summary>
        /// <typeparam name="T">The type of object the constuctor is expected to yield.</typeparam>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterType">The type of the single generic parameter to apply to create a bound generic type.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor.  It must be possible to determine the</param>
        /// <returns>The instance created by calling that constructor.</returns>
        /// <returns>An instance of type <typeparamref name="T"/>.</returns>
        public T InvokeConstructor<T>(Type genericBaseType, Type genericParameterType, params object[] parameterValues)
        {
            Assert.NotNull(genericBaseType);
            Assert.True(genericBaseType.IsGenericTypeDefinition);
            Assert.NotNull(genericParameterType);

            Type genericType = genericBaseType.MakeGenericType(new Type[] { genericParameterType });

            ConstructorInfo ctor = FindConstructor(genericType, parameterValues);
            Assert.True(ctor != null, String.Format("Test error: failed to locate generic ctor for type '{0}<{1}>',", genericBaseType.Name, genericParameterType.Name));
            return (T)ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Creates a new bound generic type and invokes the constructor matched from <see cref="parameterTypes"/>.
        /// </summary>
        /// <typeparam name="T">The type of object the constuctor is expected to yield.</typeparam>
        /// <param name="genericBaseType">The unbound generic base type.</param>
        /// <param name="genericParameterTypes">The types of the generic parameters to apply to create a bound generic type.</param>
        /// <param name="parameterValues">The list of values to supply to the constructor.  It must be possible to determine the</param>
        /// <returns>The instance created by calling that constructor.</returns>
        /// <returns>An instance of type <typeparamref name="T"/>.</returns>
        public T InvokeConstructor<T>(Type genericBaseType, Type[] genericParameterTypes, params object[] parameterValues)
        {
            Assert.NotNull(genericBaseType);
            Assert.True(genericBaseType.IsGenericTypeDefinition);
            Assert.NotNull(genericParameterTypes);

            Type genericType = genericBaseType.MakeGenericType(genericParameterTypes);

            ConstructorInfo ctor = FindConstructor(genericType, parameterValues);
            Assert.True(ctor != null, String.Format("Test error: failed to locate generic ctor for type '{0}<>',", genericBaseType.Name));
            return (T)ctor.Invoke(parameterValues);
        }

        /// <summary>
        /// Asserts the given instance is one from a generic type of the specified parameter type.
        /// </summary>
        /// <typeparam name="T">The type of instance.</typeparam>
        /// <param name="instance">The instance to test.</param>
        /// <param name="genericTypeParameter">The type of the generic parameter to which the instance's generic type should have been bound.</param>
        public void IsCorrectGenericType<T>(T instance, Type genericTypeParameter) where T : class
        {
            Assert.NotNull(instance);
            Assert.NotNull(genericTypeParameter);
            Assert.True(instance.GetType().IsGenericType);
            Type[] genericArguments = instance.GetType().GetGenericArguments();
            Type genericArgument = Assert.Single(genericArguments);
            Assert.Equal(genericTypeParameter, genericArgument);
        }

        /// <summary>
        /// Invokes via Reflection the method on the given instance.
        /// </summary>
        /// <param name="instance">The instance to use.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="parameterTypes">The types of the parameters to the method.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeMethod(object instance, string methodName, Type[] parameterTypes, object[] parameterValues)
        {
            Assert.NotNull(instance);
            Assert.NotNull(parameterTypes);
            Assert.NotNull(parameterValues);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            MethodInfo methodInfo = instance.GetType().GetMethod(methodName, parameterTypes);
            Assert.NotNull(methodInfo);
            return methodInfo.Invoke(instance, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the static method on the given type.
        /// </summary>
        /// <param name="type">The type containing the method.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="parameterTypes">The types of the parameters to the method.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeMethod(Type type, string methodName, Type[] parameterTypes, object[] parameterValues)
        {
            Assert.NotNull(type);
            Assert.NotNull(parameterTypes);
            Assert.NotNull(parameterValues);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            MethodInfo methodInfo = type.GetMethod(methodName, parameterTypes);
            Assert.NotNull(methodInfo);
            return methodInfo.Invoke(null, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the static method on the given type.
        /// </summary>
        /// <param name="type">The type containing the method.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="genericParameterType">The generic parameter type of the method.</param>
        /// <param name="parameterTypes">The types of the parameters to the method.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public MethodInfo CreateGenericMethod(Type type, string methodName, Type genericParameterType, Type[] parameterTypes)
        {
            Assert.NotNull(type);
            Assert.NotNull(parameterTypes);
            Assert.NotNull(genericParameterType);
            //MethodInfo methodInfo = type.GetMethod(methodName, parameterTypes);
            MethodInfo methodInfo = type.GetMethods().Where((m) => m.Name.Equals(methodName, StringComparison.OrdinalIgnoreCase) && m.IsGenericMethod && AreAssignableFrom(m.GetParameters(), parameterTypes)).FirstOrDefault();
            Assert.NotNull(methodInfo);
            Assert.True(methodInfo.IsGenericMethod);
            MethodInfo genericMethod = methodInfo.MakeGenericMethod(genericParameterType);
            Assert.NotNull(genericMethod);
            return genericMethod;
        }

        /// <summary>
        /// Invokes via Reflection the static generic method on the given type.
        /// </summary>
        /// <param name="type">The type containing the method.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="genericParameterType">The generic parameter type of the method.</param>
        /// <param name="parameterTypes">The types of the parameters to the method.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeGenericMethod(Type type, string methodName, Type genericParameterType, Type[] parameterTypes, object[] parameterValues)
        {
            MethodInfo methodInfo = CreateGenericMethod(type, methodName, genericParameterType, parameterTypes);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            return methodInfo.Invoke(null, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the generic method on the given instance.
        /// </summary>
        /// <param name="instance">The instance on which to invoke the method.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="genericParameterType">The generic parameter type of the method.</param>
        /// <param name="parameterTypes">The types of the parameters to the method.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeGenericMethod(object instance, string methodName, Type genericParameterType, Type[] parameterTypes, object[] parameterValues)
        {
            Assert.NotNull(instance);
            MethodInfo methodInfo = CreateGenericMethod(instance.GetType(), methodName, genericParameterType, parameterTypes);
            Assert.Equal(parameterTypes.Length, parameterValues.Length);
            return methodInfo.Invoke(instance, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the generic method on the given instance.
        /// </summary>
        /// <typeparam name="T">The type of the return value from the method.</typeparam>
        /// <param name="instance">The instance on which to invoke the method.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="genericParameterType">The generic parameter type of the method.</param>
        /// <param name="parameterTypes">The types of the parameters to the method.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public T InvokeGenericMethod<T>(object instance, string methodName, Type genericParameterType, Type[] parameterTypes, object[] parameterValues)
        {
            return (T)InvokeGenericMethod(instance, methodName, genericParameterType, parameterTypes, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the method on the given instance.
        /// </summary>
        /// <param name="instance">The instance to use.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeMethod(object instance, string methodName, params object[] parameterValues)
        {
            Assert.NotNull(instance);
            MethodInfo methodInfo = FindMethod(instance.GetType(), methodName, parameterValues);
            Assert.NotNull(methodInfo);
            return methodInfo.Invoke(instance, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the static method on the given type.
        /// </summary>
        /// <param name="instance">The instance to use.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeMethod(Type type, string methodName, params object[] parameterValues)
        {
            Assert.NotNull(type);
            MethodInfo methodInfo = FindMethod(type, methodName, parameterValues);
            Assert.NotNull(methodInfo);
            return methodInfo.Invoke(null, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the method on the given instance.
        /// </summary>
        /// <param name="instance">The instance to use.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="genericParameterType">The type of the generic parameter.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeGenericMethod(object instance, string methodName, Type genericParameterType, params object[] parameterValues)
        {
            Assert.NotNull(instance);
            Assert.NotNull(genericParameterType);
            MethodInfo methodInfo = FindMethod(instance.GetType(), methodName, parameterValues);
            Assert.NotNull(methodInfo);
            Assert.True(methodInfo.IsGenericMethod);
            MethodInfo genericMethod = methodInfo.MakeGenericMethod(genericParameterType);
            return genericMethod.Invoke(instance, parameterValues);
        }

        /// <summary>
        /// Invokes via Reflection the method on the given instance.
        /// </summary>
        /// <param name="instance">The instance to use.</param>
        /// <param name="methodName">The name of the method to call.</param>
        /// <param name="genericParameterType">The type of the generic parameter.</param>
        /// <param name="parameterValues">The values to supply to the method.</param>
        /// <returns>The results of the method.</returns>
        public object InvokeGenericMethod(Type type, string methodName, Type genericParameterType, params object[] parameterValues)
        {
            Assert.NotNull(type);
            Assert.NotNull(genericParameterType);
            MethodInfo methodInfo = FindMethod(type, methodName, parameterValues);
            Assert.NotNull(methodInfo);
            Assert.True(methodInfo.IsGenericMethod);
            MethodInfo genericMethod = methodInfo.MakeGenericMethod(genericParameterType);
            return genericMethod.Invoke(null, parameterValues);
        }

        /// <summary>
        /// Retrieves the value from the specified property.
        /// </summary>
        /// <param name="instance">The instance containing the property value.</param>
        /// <param name="propertyName">The name of the property.</param>
        /// <param name="failureMessage">The error message to prefix any test assertions.</param>
        /// <returns>The value returned from the property.</returns>
        public object GetProperty(object instance, string propertyName, string failureMessage)
        {
            PropertyInfo propertyInfo = instance.GetType().GetProperty(propertyName);
            Assert.NotNull(propertyInfo);
            return propertyInfo.GetValue(instance, null);
        }

        private static bool AreAssignableFrom(Type[] parameterTypes, params object[] parameterValues)
        {
            Assert.NotNull(parameterTypes);
            Assert.NotNull(parameterValues);
            if (parameterTypes.Length != parameterValues.Length)
            {
                return false;
            }

            for (int i = 0; i < parameterTypes.Length; ++i)
            {
                if (!parameterTypes[i].IsInstanceOfType(parameterValues[i]))
                {
                    return false;
                }
            }

            return true;
        }

        private static bool AreAssignableFrom(ParameterInfo[] parameterInfos, params Type[] parameterTypes)
        {
            Assert.NotNull(parameterInfos);
            Assert.NotNull(parameterTypes);
            Type[] parameterInfoTypes = parameterInfos.Select<ParameterInfo, Type>((info) => info.ParameterType).ToArray();
            if (parameterInfoTypes.Length != parameterTypes.Length)
            {
                return false;
            }

            for (int i = 0; i < parameterInfoTypes.Length; ++i)
            {
                // Generic parameters are assumed to be assignable
                if (parameterInfoTypes[i].IsGenericParameter)
                {
                    continue;
                }

                if (!parameterInfoTypes[i].IsAssignableFrom(parameterTypes[i]))
                {
                    return false;
                }
            }

            return true;
        }

        private static bool AreAssignableFrom(ParameterInfo[] parameterInfos, params object[] parameterValues)
        {
            Assert.NotNull(parameterInfos);
            Assert.NotNull(parameterValues);
            Type[] parameterTypes = parameterInfos.Select<ParameterInfo, Type>((info) => info.ParameterType).ToArray();
            return AreAssignableFrom(parameterTypes, parameterValues);
        }

        private static ConstructorInfo FindConstructor(Type type, params object[] parameterValues)
        {
            Assert.NotNull(type);
            Assert.NotNull(parameterValues);
            return type.GetConstructors().FirstOrDefault((c) => AreAssignableFrom(c.GetParameters(), parameterValues));
        }

        private static MethodInfo FindMethod(Type type, string methodName, params object[] parameterValues)
        {
            Assert.NotNull(type);
            Assert.False(String.IsNullOrWhiteSpace(methodName));
            Assert.NotNull(parameterValues);
            return type.GetMethods().FirstOrDefault((m) => String.Equals(m.Name, methodName, StringComparison.Ordinal) && AreAssignableFrom(m.GetParameters(), parameterValues));
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/HttpAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.RegularExpressions;
using System.Threading.Tasks;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// Unit test utility for testing <see cref="HttpResponseMessage"/> instances.
    /// </summary>
    public class HttpAssert
    {
        private const string CommaSeperator = ", ";
        private static readonly HttpAssert singleton = new HttpAssert();

        public static HttpAssert Singleton { get { return singleton; } }

        /// <summary>
        /// Asserts that the expected <see cref="HttpRequestMessage"/> is equal to the actual <see cref="HttpRequestMessage"/>.
        /// </summary>
        /// <param name="expected">The expected <see cref="HttpRequestMessage"/>. Should not be <c>null</c>.</param>
        /// <param name="actual">The actual <see cref="HttpRequestMessage"/>. Should not be <c>null</c>.</param>
        public async Task EqualAsync(HttpRequestMessage expected, HttpRequestMessage actual)
        {
            Assert.NotNull(expected);
            Assert.NotNull(actual);

            Assert.Equal(expected.Version, actual.Version);
            Equal(expected.Headers, actual.Headers);

            if (expected.Content == null)
            {
                Assert.Null(actual.Content);
            }
            else
            {
                string expectedContent = CleanContentString(await expected.Content.ReadAsStringAsync());
                string actualContent = CleanContentString(await actual.Content.ReadAsStringAsync());
                Assert.Equal(expectedContent, actualContent);
                Equal(expected.Content.Headers, actual.Content.Headers);
            }
        }

        /// <summary>
        /// Asserts that the expected <see cref="HttpResponseMessage"/> is equal to the actual <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="expected">The expected <see cref="HttpResponseMessage"/>. Should not be <c>null</c>.</param>
        /// <param name="actual">The actual <see cref="HttpResponseMessage"/>. Should not be <c>null</c>.</param>
        public Task EqualAsync(HttpResponseMessage expected, HttpResponseMessage actual)
        {
            return EqualAsync(expected, actual, verifyContentStringCallback: null);
        }

        /// <summary>
        /// Asserts that the expected <see cref="HttpResponseMessage"/> is equal to the actual <see cref="HttpResponseMessage"/>.
        /// </summary>
        /// <param name="expected">The expected <see cref="HttpResponseMessage"/>. Should not be <c>null</c>.</param>
        /// <param name="actual">The actual <see cref="HttpResponseMessage"/>. Should not be <c>null</c>.</param>
        /// <param name="verifyContentCallback">The callback to verify the Content string. If it is null, Assert.Equal will be used. </param>
        public async Task EqualAsync(HttpResponseMessage expected, HttpResponseMessage actual, Action<string, string> verifyContentStringCallback)
        {
            Assert.NotNull(expected);
            Assert.NotNull(actual);

            Assert.Equal(expected.StatusCode, actual.StatusCode);
            Assert.Equal(expected.ReasonPhrase, actual.ReasonPhrase);
            Assert.Equal(expected.Version, actual.Version);
            Equal(expected.Headers, actual.Headers);

            if (expected.Content == null)
            {
                Assert.Null(actual.Content);
            }
            else
            {
                string expectedContent = CleanContentString(await expected.Content.ReadAsStringAsync());
                string actualContent = CleanContentString(await actual.Content.ReadAsStringAsync());
                if (verifyContentStringCallback != null)
                {
                    verifyContentStringCallback(expectedContent, actualContent);
                }
                else
                {
                    Assert.Equal(expectedContent, actualContent);
                }
                Equal(expected.Content.Headers, actual.Content.Headers);
            }
        }

        /// <summary>
        /// Asserts that the expected <see cref="HttpHeaders"/> instance is equal to the actual <see cref="actualHeaders"/> instance.
        /// </summary>
        /// <param name="expectedHeaders">The expected <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
        /// <param name="actualHeaders">The actual <see cref="HttpHeaders"/> instance. Should not be <c>null</c>.</param>
        public void Equal(HttpHeaders expectedHeaders, HttpHeaders actualHeaders)
        {
            Assert.NotNull(expectedHeaders);
            Assert.NotNull(actualHeaders);

            Assert.Equal(expectedHeaders.Count(), actualHeaders.Count());

            foreach (KeyValuePair<string, IEnumerable<string>> expectedHeader in expectedHeaders)
            {
                KeyValuePair<string, IEnumerable<string>> actualHeader = actualHeaders.FirstOrDefault(h => h.Key == expectedHeader.Key);
                if (expectedHeader.Key == "Date")
                {
                    HandleDateHeader(expectedHeader.Value.ToArray(), actualHeader.Value.ToArray());
                }
                else
                {
                    string expectedHeaderStr = string.Join(CommaSeperator, expectedHeader.Value);
                    string actualHeaderStr = string.Join(CommaSeperator, actualHeader.Value);
                    Assert.Equal(expectedHeaderStr, actualHeaderStr);
                }
            }
        }

        /// <summary>
        /// Asserts the given <see cref="HttpHeaders"/> contain the given <paramref name="values"/>
        /// for the given <paramref name="name"/>.
        /// </summary>
        /// <param name="headers">The <see cref="HttpHeaders"/> to examine.  It cannot be <c>null</c>.</param>
        /// <param name="name">The name of the header.  It cannot be empty.</param>
        /// <param name="values">The values that must all be present.  It cannot be null.</param>
        public void Contains(HttpHeaders headers, string name, params string[] values)
        {
            Assert.NotNull(headers);
            Assert.False(String.IsNullOrWhiteSpace(name), "Test error: name cannot be empty.");
            Assert.NotNull(values);

            IEnumerable<string> headerValues = null;
            bool foundIt = headers.TryGetValues(name, out headerValues);
            Assert.True(foundIt);

            foreach (string value in values)
            {
                Assert.Contains(value, headerValues);
            }
        }

        public bool IsKnownUnserializableType(Type type, Func<Type, bool> isTypeUnserializableCallback)
        {
            if (isTypeUnserializableCallback != null && isTypeUnserializableCallback(type))
            {
                return true;
            }

            if (type.IsGenericType)
            {
                if (typeof(IEnumerable).IsAssignableFrom(type))
                {
                    if (type.GetMethod("Add") == null)
                    {
                        return true;
                    }
                }

                // Generic type -- recursively analyze generic arguments
                return IsKnownUnserializableType(type.GetGenericArguments()[0], isTypeUnserializableCallback);
            }

            if (type.HasElementType && IsKnownUnserializableType(type.GetElementType(), isTypeUnserializableCallback))
            {
                return true;
            }

            return false;
        }

        public bool IsKnownUnserializable(Type type, object obj, Func<Type, bool> isTypeUnserializableCallback)
        {
            if (IsKnownUnserializableType(type, isTypeUnserializableCallback))
            {
                return true;
            }

            return obj != null && IsKnownUnserializableType(obj.GetType(), isTypeUnserializableCallback);
        }

        public bool IsKnownUnserializable(Type type, object obj)
        {
            return IsKnownUnserializable(type, obj, null);
        }

        public bool CanRoundTrip(Type type)
        {
            if (typeof(DateTime).IsAssignableFrom(type))
            {
                return false;
            }

            if (typeof(DateTimeOffset).IsAssignableFrom(type))
            {
                return false;
            }

            if (type.IsGenericType)
            {
                foreach (Type genericParameterType in type.GetGenericArguments())
                {
                    if (!CanRoundTrip(genericParameterType))
                    {
                        return false;
                    }
                }
            }

            if (type.HasElementType)
            {
                return CanRoundTrip(type.GetElementType());
            }

            return true;
        }

        private static void HandleDateHeader(string[] expectedDateHeaderValues, string[] actualDateHeaderValues)
        {
            Assert.Equal(expectedDateHeaderValues.Length, actualDateHeaderValues.Length);

            for (int i = 0; i < expectedDateHeaderValues.Length; i++)
            {
                DateTime expectedDateTime = DateTime.Parse(expectedDateHeaderValues[i]);
                DateTime actualDateTime = DateTime.Parse(actualDateHeaderValues[i]);

                Assert.Equal(expectedDateTime.Year, actualDateTime.Year);
                Assert.Equal(expectedDateTime.Month, actualDateTime.Month);
                Assert.Equal(expectedDateTime.Day, actualDateTime.Day);

                int hourDifference = Math.Abs(actualDateTime.Hour - expectedDateTime.Hour);
                Assert.True(hourDifference <= 1);

                int minuteDifference = Math.Abs(actualDateTime.Minute - expectedDateTime.Minute);
                Assert.True(minuteDifference <= 1);
            }
        }

        private static string CleanContentString(string content)
        {
            Assert.Null(content);

            string cleanedContent = null;

            // remove any port numbers from Uri's
            cleanedContent = Regex.Replace(content, ":\\d+", "");

            return cleanedContent;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/MediaTypeAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Net.Http.Headers;

namespace Microsoft.TestCommon
{
    public class MediaTypeAssert
    {
        private static readonly MediaTypeAssert singleton = new MediaTypeAssert();

        public static MediaTypeAssert Singleton { get { return singleton; } }

        public void AreEqual(MediaTypeHeaderValue expected, MediaTypeHeaderValue actual, string errorMessage)
        {
            if (expected != null || actual != null)
            {
                Assert.NotNull(expected);
                Assert.Equal(0, new MediaTypeHeaderValueComparer().Compare(expected, actual));
            }
        }

        public void AreEqual(MediaTypeHeaderValue expected, string actual, string errorMessage)
        {
            if (expected != null || !String.IsNullOrEmpty(actual))
            {
                MediaTypeHeaderValue actualMediaType = new MediaTypeHeaderValue(actual);
                Assert.NotNull(expected);
                Assert.Equal(0, new MediaTypeHeaderValueComparer().Compare(expected, actualMediaType));
            }
        }

        public void AreEqual(string expected, string actual, string errorMessage)
        {
            if (!String.IsNullOrEmpty(expected) || !String.IsNullOrEmpty(actual))
            {
                Assert.NotNull(expected);
                MediaTypeHeaderValue expectedMediaType = new MediaTypeHeaderValue(expected);
                MediaTypeHeaderValue actualMediaType = new MediaTypeHeaderValue(actual);
                Assert.Equal(0, new MediaTypeHeaderValueComparer().Compare(expectedMediaType, actualMediaType));
            }
        }

        public void AreEqual(string expected, MediaTypeHeaderValue actual, string errorMessage)
        {
            if (!String.IsNullOrEmpty(expected) || actual != null)
            {
                Assert.NotNull(expected);
                MediaTypeHeaderValue expectedMediaType = new MediaTypeHeaderValue(expected);
                Assert.Equal(0, new MediaTypeHeaderValueComparer().Compare(expectedMediaType, actual));
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/MediaTypeHeaderValueComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Net.Http.Headers;

namespace Microsoft.TestCommon
{
    public class MediaTypeHeaderValueComparer : IComparer<MediaTypeHeaderValue>
    {
        private static readonly MediaTypeHeaderValueComparer mediaTypeComparer = new MediaTypeHeaderValueComparer();

        public MediaTypeHeaderValueComparer()
        {
        }

        public static MediaTypeHeaderValueComparer Comparer
        {
            get
            {
                return mediaTypeComparer;
            }
        }

        public int Compare(MediaTypeHeaderValue mediaType1, MediaTypeHeaderValue mediaType2)
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(mediaType1);
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(mediaType2);

            int returnValue = CompareBasedOnQualityFactor(parsedMediaType1, parsedMediaType2);

            if (returnValue == 0)
            {
                if (!String.Equals(parsedMediaType1.Type, parsedMediaType2.Type, StringComparison.OrdinalIgnoreCase))
                {
                    if (parsedMediaType1.IsAllMediaRange)
                    {
                        return 1;
                    }
                    else if (parsedMediaType2.IsAllMediaRange)
                    {
                        return -1;
                    }
                }
                else if (!String.Equals(parsedMediaType1.SubType, parsedMediaType2.SubType, StringComparison.OrdinalIgnoreCase))
                {
                    if (parsedMediaType1.IsSubTypeMediaRange)
                    {
                        return 1;
                    }
                    else if (parsedMediaType2.IsSubTypeMediaRange)
                    {
                        return -1;
                    }
                }
                else
                {
                    if (!parsedMediaType1.HasNonQualityFactorParameter)
                    {
                        if (parsedMediaType2.HasNonQualityFactorParameter)
                        {
                            return 1;
                        }
                    }
                    else if (!parsedMediaType2.HasNonQualityFactorParameter)
                    {
                        return -1;
                    }
                }
            }

            return returnValue;
        }

        private static int CompareBasedOnQualityFactor(ParsedMediaTypeHeaderValue parsedMediaType1, ParsedMediaTypeHeaderValue parsedMediaType2)
        {
            double qualityDifference = parsedMediaType1.QualityFactor - parsedMediaType2.QualityFactor;
            if (qualityDifference < 0)
            {
                return 1;
            }
            else if (qualityDifference > 0)
            {
                return -1;
            }

            return 0;
        }
    }
}

================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/ParsedMediaTypeHeaderValue.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Net.Http.Headers;

namespace Microsoft.TestCommon
{
    internal class ParsedMediaTypeHeaderValue
    {
        private const string MediaRangeAsterisk = "*";
        private const char MediaTypeSubTypeDelimiter = '/';
        private const string QualityFactorParameterName = "q";
        private const double DefaultQualityFactor = 1.0;

        private MediaTypeHeaderValue mediaType;
        private string type;
        private string subType;
        private bool? hasNonQualityFactorParameter;
        private double? qualityFactor;

        public ParsedMediaTypeHeaderValue(MediaTypeHeaderValue mediaType)
        {
            this.mediaType = mediaType;
            string[] splitMediaType = mediaType.MediaType.Split(MediaTypeSubTypeDelimiter);
            this.type = splitMediaType[0];
            this.subType = splitMediaType[1];
        }

        public string Type
        {
            get
            {
                return this.type;
            }
        }

        public string SubType
        {
            get
            {
                return this.subType;
            }
        }

        public bool IsAllMediaRange
        {
            get
            {
                return this.IsSubTypeMediaRange && String.Equals(MediaRangeAsterisk, this.Type, StringComparison.Ordinal);
            }
        }

        public bool IsSubTypeMediaRange
        {
            get
            {
                return String.Equals(MediaRangeAsterisk, this.SubType, StringComparison.Ordinal);
            }
        }

        public bool HasNonQualityFactorParameter
        {
            get
            {
                if (!this.hasNonQualityFactorParameter.HasValue)
                {
                    this.hasNonQualityFactorParameter = false;
                    foreach (NameValueHeaderValue param in this.mediaType.Parameters)
                    {
                        if (!String.Equals(QualityFactorParameterName, param.Name, StringComparison.Ordinal))
                        {
                            this.hasNonQualityFactorParameter = true;
                        }
                    }
                }

                return this.hasNonQualityFactorParameter.Value;
            }
        }

        public string CharSet
        {
            get
            {
                return this.mediaType.CharSet;
            }
        }

        public double QualityFactor
        {
            get
            {
                if (!this.qualityFactor.HasValue)
                {
                    MediaTypeWithQualityHeaderValue mediaTypeWithQuality = this.mediaType as MediaTypeWithQualityHeaderValue;
                    if (mediaTypeWithQuality != null)
                    {
                        this.qualityFactor = mediaTypeWithQuality.Quality;
                    }

                    if (!this.qualityFactor.HasValue)
                    {
                        this.qualityFactor = DefaultQualityFactor;
                    }
                }

                return this.qualityFactor.Value;
            }
        }
    }
}

================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/RegexReplacement.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text.RegularExpressions;

namespace Microsoft.TestCommon
{
    public class RegexReplacement
    {
        Regex regex;
        string replacement;

        public RegexReplacement(Regex regex, string replacement)
        {
            this.regex = regex;
            this.replacement = replacement;
        }

        public RegexReplacement(string regex, string replacement)
        {
            this.regex = new Regex(regex);
            this.replacement = replacement;
        }

        public Regex Regex
        {
            get
            {
                return this.regex;
            }
        }

        public string Replacement
        {
            get
            {
                return this.replacement;
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/RuntimeEnvironment.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Microsoft.Win32;

namespace Microsoft.TestCommon
{
    public static class RuntimeEnvironment
    {
        private const string NetFx40FullSubKey = @"SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full";
        private const string Version = "Version";

        static RuntimeEnvironment()
        {
            object runtimeVersion = Registry.LocalMachine.OpenSubKey(RuntimeEnvironment.NetFx40FullSubKey).GetValue(RuntimeEnvironment.Version);
            string versionFor40String = runtimeVersion as string;
            if (versionFor40String != null)
            {
                VersionFor40 = new Version(versionFor40String);
            }
        }

        private static Version VersionFor40;

        public static bool IsVersion45Installed
        {
            get
            {
                return VersionFor40.Major > 4 || (VersionFor40.Major == 4 && VersionFor40.Minor >= 5);
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/SerializerAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Xml.Serialization;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// MSTest utility for testing code operating against a stream.
    /// </summary>
    public class SerializerAssert
    {
        private static SerializerAssert singleton = new SerializerAssert();

        public static SerializerAssert Singleton { get { return singleton; } }

        /// <summary>
        /// Creates a <see cref="Stream"/>, serializes <paramref name="objectInstance"/> to it using
        /// <see cref="XmlSerializer"/>, rewinds the stream and calls <see cref="codeThatChecks"/>.
        /// </summary>
        /// <param name="type">The type to serialize.  It cannot be <c>null</c>.</param>
        /// <param name="objectInstance">The value to serialize.</param>
        /// <param name="codeThatChecks">Code to check the contents of the stream.</param>
        public void UsingXmlSerializer(Type type, object objectInstance, Action<Stream> codeThatChecks)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            if (codeThatChecks == null)
            {
                throw new ArgumentNullException("codeThatChecks");
            }

            XmlSerializer serializer = new XmlSerializer(type);

            using (MemoryStream stream = new MemoryStream())
            {
                serializer.Serialize(stream, objectInstance);

                stream.Flush();
                stream.Seek(0L, SeekOrigin.Begin);

                codeThatChecks(stream);
            }
        }

        /// <summary>
        /// Creates a <see cref="Stream"/>, serializes <paramref name="objectInstance"/> to it using
        /// <see cref="XmlSerializer"/>, rewinds the stream and calls <see cref="codeThatChecks"/>.
        /// </summary>
        /// <typeparam name="T">The type to serialize.</typeparam>
        /// <param name="objectInstance">The value to serialize.</param>
        /// <param name="codeThatChecks">Code to check the contents of the stream.</param>
        public void UsingXmlSerializer<T>(T objectInstance, Action<Stream> codeThatChecks)
        {
            UsingXmlSerializer(typeof(T), objectInstance, codeThatChecks);
        }

        /// <summary>
        /// Creates a <see cref="Stream"/>, serializes <paramref name="objectInstance"/> to it using
        /// <see cref="DataContractSerializer"/>, rewinds the stream and calls <see cref="codeThatChecks"/>.
        /// </summary>
        /// <param name="type">The type to serialize.  It cannot be <c>null</c>.</param>
        /// <param name="objectInstance">The value to serialize.</param>
        /// <param name="codeThatChecks">Code to check the contents of the stream.</param>
        public void UsingDataContractSerializer(Type type, object objectInstance, Action<Stream> codeThatChecks)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            if (codeThatChecks == null)
            {
                throw new ArgumentNullException("codeThatChecks");
            }

            DataContractSerializer serializer = new DataContractSerializer(type);

            using (MemoryStream stream = new MemoryStream())
            {
                serializer.WriteObject(stream, objectInstance);

                stream.Flush();
                stream.Seek(0L, SeekOrigin.Begin);

                codeThatChecks(stream);
            }
        }

        /// <summary>
        /// Creates a <see cref="Stream"/>, serializes <paramref name="objectInstance"/> to it using
        /// <see cref="DataContractSerializer"/>, rewinds the stream and calls <see cref="codeThatChecks"/>.
        /// </summary>
        /// <typeparam name="T">The type to serialize.</typeparam>
        /// <param name="objectInstance">The value to serialize.</param>
        /// <param name="codeThatChecks">Code to check the contents of the stream.</param>
        public void UsingDataContractSerializer<T>(T objectInstance, Action<Stream> codeThatChecks)
        {
            UsingDataContractSerializer(typeof(T), objectInstance, codeThatChecks);
        }

        /// <summary>
        /// Creates a <see cref="Stream"/>, serializes <paramref name="objectInstance"/> to it using
        /// <see cref="DataContractJsonSerializer"/>, rewinds the stream and calls <see cref="codeThatChecks"/>.
        /// </summary>
        /// <param name="type">The type to serialize.  It cannot be <c>null</c>.</param>
        /// <param name="objectInstance">The value to serialize.</param>
        /// <param name="codeThatChecks">Code to check the contents of the stream.</param>
        public static void UsingDataContractJsonSerializer(Type type, object objectInstance, Action<Stream> codeThatChecks)
        {
            if (type == null)
            {
                throw new ArgumentNullException("type");
            }

            if (codeThatChecks == null)
            {
                throw new ArgumentNullException("codeThatChecks");
            }

            DataContractJsonSerializer serializer = new DataContractJsonSerializer(type);

            using (MemoryStream stream = new MemoryStream())
            {
                serializer.WriteObject(stream, objectInstance);

                stream.Flush();
                stream.Seek(0L, SeekOrigin.Begin);

                codeThatChecks(stream);
            }
        }

        /// <summary>
        /// Creates a <see cref="Stream"/>, serializes <paramref name="objectInstance"/> to it using
        /// <see cref="DataContractJsonSerializer"/>, rewinds the stream and calls <see cref="codeThatChecks"/>.
        /// </summary>
        /// <typeparam name="T">The type to serialize.</typeparam>
        /// <param name="objectInstance">The value to serialize.</param>
        /// <param name="codeThatChecks">Code to check the contents of the stream.</param>
        public void UsingDataContractJsonSerializer<T>(T objectInstance, Action<Stream> codeThatChecks)
        {
            UsingDataContractJsonSerializer(typeof(T), objectInstance, codeThatChecks);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/StreamAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.IO;
using System.Threading.Tasks;

namespace Microsoft.TestCommon
{
    //// TODO RONCAIN using System.Runtime.Serialization.Json;

    /// <summary>
    /// MSTest utility for testing code operating against a stream.
    /// </summary>
    public class StreamAssert
    {
        private static StreamAssert singleton = new StreamAssert();

        public static StreamAssert Singleton { get { return singleton; } }

        /// <summary>
        /// Creates a <see cref="MemoryStream"/>, invokes <paramref name="codeThatWrites"/> to write to it,
        /// rewinds the stream to the beginning and invokes <paramref name="codeThatReadsAsync"/>.
        /// </summary>
        /// <param name="codeThatWrites">Code to write to the stream. It cannot be <c>null</c>.</param>
        /// <param name="codeThatReadsAsync">Code that reads from the stream. It cannot be <c>null</c>.</param>
        public async Task WriteAndReadAsync(Func<MemoryStream, Task> codeThatWrites, Func<MemoryStream, Task> codeThatReadsAsync)
        {
            if (codeThatWrites == null)
            {
                throw new ArgumentNullException("codeThatWrites");
            }

            if (codeThatReadsAsync == null)
            {
                throw new ArgumentNullException("codeThatReads");
            }

            using (MemoryStream stream = new MemoryStream())
            {
                await codeThatWrites(stream);

                stream.Flush();
                stream.Seek(0L, SeekOrigin.Begin);

                await codeThatReadsAsync(stream);
            }
        }

        /// <summary>
        /// Creates a <see cref="Stream"/>, invokes <paramref name="codeThatWrites"/> to write to it,
        /// rewinds the stream to the beginning and invokes <paramref name="codeThatReads"/> to obtain
        /// the result to return from this method.
        /// </summary>
        /// <param name="codeThatWrites">Code to write to the stream.  It cannot be <c>null</c>.</param>
        /// <param name="codeThatReads">Code that reads from the stream and returns the result.  It cannot be <c>null</c>.</param>
        /// <returns>The value returned from <paramref name="codeThatReads"/>.</returns>
        public static object WriteAndReadResult(Action<Stream> codeThatWrites, Func<Stream, object> codeThatReads)
        {
            if (codeThatWrites == null)
            {
                throw new ArgumentNullException("codeThatWrites");
            }

            if (codeThatReads == null)
            {
                throw new ArgumentNullException("codeThatReads");
            }

            object result = null;
            using (MemoryStream stream = new MemoryStream())
            {
                codeThatWrites(stream);

                stream.Flush();
                stream.Seek(0L, SeekOrigin.Begin);

                result = codeThatReads(stream);
            }

            return result;
        }

        /// <summary>
        /// Creates a <see cref="Stream"/>, invokes <paramref name="codeThatWrites"/> to write to it,
        /// rewinds the stream to the beginning and invokes <paramref name="codeThatReads"/> to obtain
        /// the result to return from this method.
        /// </summary>
        /// <typeparam name="T">The type of the result expected.</typeparam>
        /// <param name="codeThatWrites">Code to write to the stream.  It cannot be <c>null</c>.</param>
        /// <param name="codeThatReads">Code that reads from the stream and returns the result.  It cannot be <c>null</c>.</param>
        /// <returns>The value returned from <paramref name="codeThatReads"/>.</returns>
        public T WriteAndReadResult<T>(Action<Stream> codeThatWrites, Func<Stream, object> codeThatReads)
        {
            return (T)WriteAndReadResult(codeThatWrites, codeThatReads);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/TaskAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading.Tasks;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// MSTest assert class to make assertions about tests using <see cref="Task"/>.
    /// </summary>
    public class TaskAssert
    {
        /// <summary>
        /// Asserts the given task has been started.  TAP guidelines are that all
        /// <see cref="Task"/> objects returned from public API's have been started.
        /// </summary>
        /// <param name="task">The <see cref="Task"/> to test.</param>
        public void IsStarted(Task task)
        {
            Assert.NotNull(task);
            Assert.True(task.Status != TaskStatus.Created);
        }

        /// <summary>
        /// Asserts the given task completes successfully.  This method will block the
        /// current thread waiting for the task, but will timeout if it does not complete.
        /// </summary>
        /// <param name="task">The <see cref="Task"/> to test.</param>
        public Task SucceedsAsync(Task task)
        {
            IsStarted(task);
            return task;
        }

        /// <summary>
        /// Asserts the given task completes successfully and returns a <typeparamref name="T"/> result.
        /// This method will block the current thread waiting for the task, but will timeout if it does not complete.
        /// </summary>
        /// <typeparam name="T">The result of the <see cref="Task"/>.</typeparam>
        /// <param name="task">The <see cref="Task"/> to test.</param>
        /// <returns>The result from that task.</returns>
        public Task<T> SucceedsWithResultAsync<T>(Task<T> task)
        {
            IsStarted(task);
            return task;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/TestDataSetAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;

namespace Microsoft.TestCommon
{
    public class TestDataSetAttribute : DataAttribute
    {
        public Type DeclaringType { get; set; }

        public string PropertyName { get; set; }

        public TestDataVariations TestDataVariations { get; set; }

        private IEnumerable<Tuple<Type, string>> ExtraDataSets { get; set; }

        public TestDataSetAttribute(Type declaringType, string propertyName, TestDataVariations testDataVariations = TestCommon.TestDataVariations.All)
        {
            DeclaringType = declaringType;
            PropertyName = propertyName;
            TestDataVariations = testDataVariations;
            ExtraDataSets = new List<Tuple<Type, string>>();
        }

        public TestDataSetAttribute(Type declaringType, string propertyName,
                                    Type declaringType1, string propertyName1,
                                    TestDataVariations testDataVariations = TestCommon.TestDataVariations.All)
            : this(declaringType, propertyName, testDataVariations)
        {
            ExtraDataSets = new List<Tuple<Type, string>> { Tuple.Create(declaringType1, propertyName1) };
        }

        public TestDataSetAttribute(Type declaringType, string propertyName,
            Type declaringType1, string propertyName1,
            Type declaringType2, string propertyName2,
            TestDataVariations testDataVariations = TestCommon.TestDataVariations.All)
            : this(declaringType, propertyName, testDataVariations)
        {
            ExtraDataSets = new List<Tuple<Type, string>> { Tuple.Create(declaringType1, propertyName1), Tuple.Create(declaringType2, propertyName2) };
        }

        public TestDataSetAttribute(Type declaringType, string propertyName,
            Type declaringType1, string propertyName1,
            Type declaringType2, string propertyName2,
            Type declaringType3, string propertyName3,
            TestDataVariations testDataVariations = TestCommon.TestDataVariations.All)
            : this(declaringType, propertyName, testDataVariations)
        {
            ExtraDataSets = new List<Tuple<Type, string>> { Tuple.Create(declaringType1, propertyName1), Tuple.Create(declaringType2, propertyName2), Tuple.Create(declaringType3, propertyName3) };
        }

        public TestDataSetAttribute(Type declaringType, string propertyName,
            Type declaringType1, string propertyName1,
            Type declaringType2, string propertyName2,
            Type declaringType3, string propertyName3,
            Type declaringType4, string propertyName4,
            TestDataVariations testDataVariations = TestCommon.TestDataVariations.All)
            : this(declaringType, propertyName, testDataVariations)
        {
            ExtraDataSets = new List<Tuple<Type, string>>
            {
                Tuple.Create(declaringType1, propertyName1), Tuple.Create(declaringType2, propertyName2),
                Tuple.Create(declaringType3, propertyName3), Tuple.Create(declaringType4, propertyName4)
            };
        }

        public override IEnumerable<object[]> GetData(MethodInfo methodUnderTest, Type[] parameterTypes)
        {
            IEnumerable<object[]> baseDataSet = GetBaseDataSet(DeclaringType, PropertyName, TestDataVariations);
            IEnumerable<IEnumerable<object[]>> extraDataSets = GetExtraDataSets();

            IEnumerable<IEnumerable<object[]>> finalDataSets = (new[] { baseDataSet }).Concat(extraDataSets);

            var datasets = CrossProduct(finalDataSets);

            return datasets;
        }

        private static IEnumerable<object[]> CrossProduct(IEnumerable<IEnumerable<object[]>> datasets)
        {
            if (datasets.Count() == 1)
            {
                foreach (var dataset in datasets.First())
                {
                    yield return dataset;
                }
            }
            else
            {
                IEnumerable<object[]> datasetLeft = datasets.First();
                IEnumerable<object[]> datasetRight = CrossProduct(datasets.Skip(1));

                foreach (var dataLeft in datasetLeft)
                {
                    foreach (var dataRight in datasetRight)
                    {
                        yield return dataLeft.Concat(dataRight).ToArray();
                    }
                }
            }
        }

        // The base data set(first one) can either be a TestDataSet or a TestDataSetCollection
        private static IEnumerable<object[]> GetBaseDataSet(Type declaringType, string propertyName, TestDataVariations variations)
        {
            return TryGetDataSetFromTestDataCollection(declaringType, propertyName, variations) ?? GetDataSet(declaringType, propertyName);
        }

        private IEnumerable<IEnumerable<object[]>> GetExtraDataSets()
        {
            foreach (var tuple in ExtraDataSets)
            {
                yield return GetDataSet(tuple.Item1, tuple.Item2);
            }
        }

        private static object GetTestDataPropertyValue(Type declaringType, string propertyName)
        {
            PropertyInfo property = declaringType.GetProperty(propertyName, BindingFlags.Static | BindingFlags.Public);

            if (property == null)
            {
                throw new ArgumentException(String.Format("Could not find public static property {0} on {1}", propertyName, declaringType.FullName));
            }
            else
            {
                return property.GetValue(null, null);
            }
        }

        private static IEnumerable<object[]> GetDataSet(Type declaringType, string propertyName)
        {
            object propertyValue = GetTestDataPropertyValue(declaringType, propertyName);

            // box the dataset items if the property is not a RefTypeTestData
            IEnumerable<object> value = (propertyValue as IEnumerable<object>) ?? (propertyValue as IEnumerable).Cast<object>();
            if (value == null)
            {
                throw new InvalidOperationException(String.Format("{0}.{1} is either null or does not implement IEnumerable", declaringType.FullName, propertyName));
            }

            IEnumerable<object[]> dataset = value as IEnumerable<object[]>;
            if (dataset != null)
            {
                return dataset;
            }
            else
            {
                return value.Select((data) => new object[] { data });
            }
        }

        private static IEnumerable<object[]> TryGetDataSetFromTestDataCollection(Type declaringType, string propertyName, TestDataVariations variations)
        {
            object propertyValue = GetTestDataPropertyValue(declaringType, propertyName);

            IEnumerable<TestData> testDataCollection = propertyValue as IEnumerable<TestData>;

            return testDataCollection == null ? null : GetDataSetFromTestDataCollection(testDataCollection, variations);
        }

        private static IEnumerable<object[]> GetDataSetFromTestDataCollection(IEnumerable<TestData> testDataCollection, TestDataVariations variations)
        {
            foreach (TestData testdataInstance in testDataCollection)
            {
                foreach (TestDataVariations variation in testdataInstance.GetSupportedTestDataVariations())
                {
                    if ((variation & variations) == variation)
                    {
                        Type variationType = testdataInstance.GetAsTypeOrNull(variation);
                        object testData = testdataInstance.GetAsTestDataOrNull(variation);
                        if (AsSingleInstances(variation))
                        {
                            foreach (object obj in (IEnumerable)testData)
                            {
                                yield return new object[] { variationType, obj };
                            }
                        }
                        else
                        {
                            yield return new object[] { variationType, testData };
                        }
                    }
                }
            }
        }

        private static bool AsSingleInstances(TestDataVariations variation)
        {
            return variation == TestDataVariations.AsInstance ||
                   variation == TestDataVariations.AsNullable ||
                   variation == TestDataVariations.AsDerivedType ||
                   variation == TestDataVariations.AsKnownType ||
                   variation == TestDataVariations.AsDataMember ||
                   variation == TestDataVariations.AsClassMember ||
                   variation == TestDataVariations.AsXmlElementProperty;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/TimeoutConstant.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon
{
    /// <summary>
    /// MSTest timeout constants for use with the <see cref="Microsoft.VisualStudio.TestTools.UnitTesting.TimeoutAttribute"/>.
    /// </summary>
    public class TimeoutConstant
    {
        private const int seconds = 1000;

        /// <summary>
        /// The default timeout for test methods.
        /// </summary>
        public const int DefaultTimeout = 30 * seconds;

        /// <summary>
        /// An extended timeout for longer running test methods.
        /// </summary>
        public const int ExtendedTimeout = 240 * seconds;
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/TypeAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// MSTest utility for testing that a given type has the expected properties such as being public, sealed, etc.
    /// </summary>
    public class TypeAssert
    {
        /// <summary>
        /// Specifies a set of type properties to test for using the <see cref="CheckProperty"/> method.
        /// This enumeration has a <see cref="FlagsAttribute"/> attribute that allows a bitwise combination of its member values.
        /// </summary>
        [Flags]
        public enum TypeProperties
        {
            /// <summary>
            /// Indicates that the type must be abstract.
            /// </summary>
            IsAbstract = 0x1,

            /// <summary>
            /// Indicates that the type must be a class.
            /// </summary>
            IsClass = 0x2,

            /// <summary>
            /// Indicates that the type must be a COM object.
            /// </summary>
            IsComObject = 0x4,

            /// <summary>
            /// Indicates that the type must be disposable.
            /// </summary>
            IsDisposable = 0x8,

            /// <summary>
            /// Indicates that the type must be an enum.
            /// </summary>
            IsEnum = 0x10,

            /// <summary>
            /// Indicates that the type must be a generic type.
            /// </summary>
            IsGenericType = 0x20,

            /// <summary>
            /// Indicates that the type must be a generic type definition.
            /// </summary>
            IsGenericTypeDefinition = 0x40,

            /// <summary>
            /// Indicates that the type must be an interface.
            /// </summary>
            IsInterface = 0x80,

            /// <summary>
            /// Indicates that the type must be nested and declared private.
            /// </summary>
            IsNestedPrivate = 0x100,

            /// <summary>
            /// Indicates that the type must be nested and declared public.
            /// </summary>
            IsNestedPublic = 0x200,

            /// <summary>
            /// Indicates that the type must be public.
            /// </summary>
            IsPublic = 0x400,

            /// <summary>
            /// Indicates that the type must be sealed.
            /// </summary>
            IsSealed = 0x800,

            /// <summary>
            /// Indicates that the type must be visible outside the assembly.
            /// </summary>
            IsVisible = 0x1000,

            /// <summary>
            /// Indicates that the type must be static.
            /// </summary>
            IsStatic = TypeAssert.TypeProperties.IsAbstract | TypeAssert.TypeProperties.IsSealed,

            /// <summary>
            /// Indicates that the type must be a public, visible class.
            /// </summary>
            IsPublicVisibleClass = TypeAssert.TypeProperties.IsClass | TypeAssert.TypeProperties.IsPublic | TypeAssert.TypeProperties.IsVisible
        }

        private static void CheckProperty(Type type, bool expected, bool actual, string property)
        {
            Assert.NotNull(type);
            Assert.True(expected == actual, String.Format("Type '{0}' should{1} be {2}.", type.FullName, expected ? "" : " NOT", property));
        }

        /// <summary>
        /// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
        /// The method asserts if one or more of the properties are not satisfied.
        /// </summary>
        /// <typeparam name="T">The type to test for properties.</typeparam>
        /// <param name="typeProperties">The set of type properties to test for.</param>
        public void HasProperties<T>(TypeProperties typeProperties)
        {
            HasProperties(typeof(T), typeProperties);
        }

        /// <summary>
        /// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
        /// The method asserts if one or more of the properties are not satisfied.
        /// </summary>
        /// <typeparam name="T">The type to test for properties.</typeparam>
        /// <typeparam name="TIsAssignableFrom">Verify that the type to test is assignable from this type.</typeparam>
        /// <param name="typeProperties">The set of type properties to test for.</param>
        public void HasProperties<T, TIsAssignableFrom>(TypeProperties typeProperties)
        {
            HasProperties(typeof(T), typeProperties, typeof(TIsAssignableFrom));
        }

        /// <summary>
        /// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
        /// The method asserts if one or more of the properties are not satisfied.
        /// </summary>
        /// <param name="type">The type to test for properties.</param>
        /// <param name="typeProperties">The set of type properties to test for.</param>
        public void HasProperties(Type type, TypeProperties typeProperties)
        {
            HasProperties(type, typeProperties, null);
        }

        /// <summary>
        /// Determines whether the specified type has a given set of properties such as being public, sealed, etc.
        /// The method asserts if one or more of the properties are not satisfied.
        /// </summary>
        /// <param name="type">The type to test for properties.</param>
        /// <param name="typeProperties">The set of type properties to test for.</param>
        /// <param name="isAssignableFrom">Verify that the type to test is assignable from this type.</param>
        public void HasProperties(Type type, TypeProperties typeProperties, Type isAssignableFrom)
        {
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsAbstract) > 0, type.IsAbstract, "abstract");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsClass) > 0, type.IsClass, "a class");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsComObject) > 0, type.IsCOMObject, "a COM object");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsDisposable) > 0, typeof(IDisposable).IsAssignableFrom(type), "disposable");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsEnum) > 0, type.IsEnum, "an enum");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsGenericType) > 0, type.IsGenericType, "a generic type");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsGenericTypeDefinition) > 0, type.IsGenericTypeDefinition, "a generic type definition");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsInterface) > 0, type.IsInterface, "an interface");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsNestedPrivate) > 0, type.IsNestedPrivate, "nested private");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsNestedPublic) > 0, type.IsNestedPublic, "nested public");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsPublic) > 0, type.IsPublic, "public");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsSealed) > 0, type.IsSealed, "sealed");
            TypeAssert.CheckProperty(type, (typeProperties & TypeProperties.IsVisible) > 0, type.IsVisible, "visible");
            if (isAssignableFrom != null)
            {
                TypeAssert.CheckProperty(type, true, isAssignableFrom.IsAssignableFrom(type), String.Format("assignable from {0}", isAssignableFrom.FullName));
            }
        }
    }
}

================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/ByteEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    public enum ByteEnum : byte
    {
        FirstByte,
        SecondByte,
        ThirdByte
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/FlagsEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.TestCommon.Types
{
    [Flags]
    public enum FlagsEnum
    {
        One = 0x1,
        Two = 0x2,
        Four = 0x4
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/INameAndIdContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    /// <summary>
    /// Tagging interface to assist comparing instances of these types.
    /// </summary>
    public interface INameAndIdContainer
    {
        string Name { get; set; }

        int Id { get; set; }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/ISerializableType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Runtime.Serialization;

namespace Microsoft.TestCommon.Types
{
    [Serializable]
    public class ISerializableType : ISerializable, INameAndIdContainer
    {
        private int id;
        private string name;

        public ISerializableType()
        {
        }

        public ISerializableType(int id, string name)
        {
            this.id = id;
            this.name = name;
        }

        public ISerializableType(SerializationInfo information, StreamingContext context)
        {
            this.id = information.GetInt32("Id");
            this.name = information.GetString("Name");
        }

        public int Id
        {
            get
            {
                return this.id;
            }

            set
            {
                this.IdSet = true;
                this.id = value;
            }
        }

        public string Name
        {
            get
            {
                return this.name;
            }

            set
            {
                this.NameSet = true;
                this.name = value;
            }

        }

        public bool IdSet { get; private set; }

        public bool NameSet { get; private set; }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("Id", this.Id);
            info.AddValue("Name", this.Name);
        }

        public static IEnumerable<ISerializableType> GetTestData()
        {
            return new ISerializableType[] { new ISerializableType(), new ISerializableType(1, "SomeName") };
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/LongEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    public enum LongEnum : long
    {
        FirstLong,
        SecondLong,
        ThirdLong,
        FourthLong
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/SByteEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    public enum SByteEnum : sbyte
    {
        FirstSByte,
        SecondSByte,
        ThirdSByte
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/ShortEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    public enum ShortEnum : short
    {
        FirstShort,
        SecondShort,
        ThirdShort
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/SimpleEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    public enum SimpleEnum
    {
        First,
        Second,
        Third,
        Fourth
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/UIntEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    public enum UIntEnum : uint
    {
        FirstUInt,
        SecondUInt,
        ThirdUInt
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/Types/UShortEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace Microsoft.TestCommon.Types
{
    public enum UShortEnum : ushort
    {
        FirstUShort,
        SecondUShort,
        ThirdUShort
    }
}


================================================
FILE: test/Microsoft.TestCommon/Microsoft/TestCommon/XmlAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Xml.Linq;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// Assert class that compares two XML strings for equality. Namespaces are ignored during comparison
    /// </summary>
    public class XmlAssert
    {
        public void Equal(string expected, string actual, params RegexReplacement[] regexReplacements)
        {
            if (regexReplacements != null)
            {
                for (int i = 0; i < regexReplacements.Length; i++)
                {
                    actual = regexReplacements[i].Regex.Replace(actual, regexReplacements[i].Replacement);
                }
            }

            Equal(XElement.Parse(expected), XElement.Parse(actual));
        }

        public void Equal(XElement expected, XElement actual)
        {
            Assert.Equal(Normalize(expected).ToString(), Normalize(actual).ToString());
        }

        private static XElement Normalize(XElement element)
        {
            if (element.HasElements)
            {
                return new XElement(
                    Encode(element.Name),
                    Normalize(element.Attributes()),
                    Normalize(element.Elements()));
            }

            if (element.IsEmpty)
            {
                return new XElement(
                    Encode(element.Name),
                    Normalize(element.Attributes()));
            }
            else
            {
                return new XElement(
                    Encode(element.Name),
                    Normalize(element.Attributes()),
                    element.Value);
            }
        }

        private static IEnumerable<XAttribute> Normalize(IEnumerable<XAttribute> attributes)
        {
            return attributes
                    .Where((attrib) => !attrib.IsNamespaceDeclaration)
                    .Select((attrib) => new XAttribute(Encode(attrib.Name), attrib.Value))
                    .OrderBy(a => a.Name.ToString());
        }

        private static IEnumerable<XElement> Normalize(IEnumerable<XElement> elements)
        {
            return elements
                    .Select(e => Normalize(e))
                    .OrderBy(a => a.ToString());
        }

        private static string Encode(XName name)
        {
            return string.Format("{0}_{1}", HttpUtility.UrlEncode(name.NamespaceName).Replace('%', '_'), name.LocalName);
        }
    }
}

================================================
FILE: test/Microsoft.TestCommon/Microsoft.TestCommon.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <TargetFrameworks>net462;netcoreapp2.1;net8.0</TargetFrameworks>
    <Configurations>$(Configurations);CodeAnalysis</Configurations>
    <DefineConstants
        Condition=" '$(Testing_NetStandard1_3)' == 'true' ">$(DefineConstants);Testing_NetStandard1_3</DefineConstants>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <OutputPath
        Condition=" '$(Testing_NetStandard1_3)' == 'true' ">$(OutputPath)ns1_3\</OutputPath>
  </PropertyGroup>

  <ItemGroup>
    <None Include="xunit.runner.json" CopyToOutputDirectory="PreserveNewest" />

    <!-- ns1_3 project brings in System.Net.Http from .NET Standard but doesn't expose that to us here. -->
    <PackageReference Include="System.Net.Http" Version="4.3.4"
        Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' AND '$(Testing_NetStandard1_3)' == 'true' " />
    <Reference Include="System.Net.Http"
        Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' AND '$(Testing_NetStandard1_3)' != 'true' " />

    <Reference Include="System.Web"
        Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' " />

    <PackageReference Include="Moq" Version="4.18.4" />
    <PackageReference Include="xunit.abstractions" Version="2.0.3" />
    <PackageReference Include="xunit.assert" Version="2.4.2" />
    <PackageReference Include="xunit.extensibility.core" Version="2.4.2" />
    <PackageReference Include="xunit.extensibility.execution" Version="2.4.2" />

    <Compile Remove="AppDomainUtils.cs;Microsoft\TestCommon\RuntimeEnvironment.cs;WebUtils.cs"
        Condition=" '$(TargetFrameworkIdentifier)' != '.NETFramework' " />

    <!-- To access Error.InvalidEnumArgumentException in this special case. -->
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting.ns1_3\System.Net.Http.Formatting.ns1_3.csproj"
        Condition=" '$(Testing_NetStandard1_3)' == 'true' " />
  </ItemGroup>
</Project>


================================================
FILE: test/Microsoft.TestCommon/Platform.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// An enumeration of known platforms that the unit test might be running under.
    /// </summary>
    [Flags]
    public enum Platform
    {
        /// <summary>
        /// A special value used to indicate that the test is valid on all known platforms.
        /// </summary>
        All = 0xFFFFFF,

        /// <summary>
        /// Indicates that the test wants to run on .NET 4 (when used with
        /// <see cref="FactAttribute.Platforms"/> and/or <see cref="TheoryAttribute.Platforms"/>),
        /// or that the current platform that the test is running on is .NET 4 (when used with the
        /// <see cref="PlatformInfo.Platform"/>, <see cref="FactDiscoverer.Platform"/>, and/or
        /// <see cref="TheoryDiscoverer.Platform"/>).
        /// </summary>
        Net40 = 0x01,

        /// <summary>
        /// Indicates that the test wants to run on .NET 4.5 (when used with
        /// <see cref="FactAttribute.Platforms"/> and/or <see cref="TheoryAttribute.Platforms"/>),
        /// or that the current platform that the test is running on is .NET 4.5 (when used with the
        /// <see cref="PlatformInfo.Platform"/>, <see cref="FactDiscoverer.Platform"/>, and/or
        /// <see cref="TheoryDiscoverer.Platform"/>).
        /// </summary>
        Net45 = 0x02,
    }
}


================================================
FILE: test/Microsoft.TestCommon/PlatformInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// Used to retrieve the currently running platform.
    /// </summary>
    public static class PlatformInfo
    {
        private const string _net45TypeName = "System.IWellKnownStringEqualityComparer, mscorlib, Version=4.0.0.0, PublicKeyToken=b77a5c561934e089";
        private const string _netCore20TypeName = "System.OrdinalCaseSensitiveComparer, system.private.corelib, Version=4.0.0.0, PublicKeyToken=7cec85d7bea7798e";
        private static Lazy<Platform> _platform = new Lazy<Platform>(GetPlatform, isThreadSafe: true);

        /// <summary>
        /// Gets the platform that the unit test is currently running on.
        /// </summary>
        public static Platform Platform
        {
            get { return _platform.Value; }
        }

        private static Platform GetPlatform()
        {
            if (Type.GetType(_netCore20TypeName, throwOnError: false) != null)
            {
                // Treat .NET Core 2.1 as a .NET 4.5 superset though internal types are different.
                return Platform.Net45;
            }

            if (Type.GetType(_net45TypeName, throwOnError: false) != null)
            {
                return Platform.Net45;
            }

            return Platform.Net40;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/PortReserver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.NetworkInformation;
using System.Threading;

namespace Microsoft.TestCommon
{
    [Xunit.CollectionDefinition("PortReserver Collection", DisableParallelization = true)]
    public class PortReserverCollection
    {
    }

    /// <summary>
    /// This class allocates ports while ensuring that:
    /// 1. Ports that are permanently taken (or taken for the duration of the test) are not being attempted to be used.
    /// 2. Ports are not shared across different tests (but you can allocate two different ports in the same test).
    ///
    /// Gotcha: If another application grabs a port during the test, we have a race condition.
    /// </summary>
    [DebuggerDisplay("Port: {PortNumber}, Port count for this app domain: {_appDomainOwnedPorts.Count}")]
    public class PortReserver : IDisposable
    {
        private Mutex _portMutex;
        private Thread _acquiredOn;

        // We use this list to hold on to all the ports used because the Mutex will be blown through on the same thread.
        // Theoretically we can do a thread local HashSet, but that makes dispose thread-dependent, or requires more complicated concurrency checks.
        // Since practically there is no perf issue or concern here, this keeps the code the simplest possible.
        private static HashSet<int> _appDomainOwnedPorts = new HashSet<int>();

        public int PortNumber
        {
            get;
            private set;
        }

        public PortReserver(int basePort = 50231)
        {
            if (basePort <= 0)
            {
                throw new ArgumentOutOfRangeException("basePort", "Argument must be greater than 0.");
            }

            // Grab a cross appdomain/cross process/cross thread lock, to ensure only one port is reserved at a time.
            using (Mutex mutex = GetGlobalMutex())
            {
                try
                {
                    var usedTCPPorts = new HashSet<int>();
                    foreach (var endPoint in ListUsedTCPPort())
                    {
                        usedTCPPorts.Add(endPoint.Port);
                    }

                    int port = basePort - 1;
                    while (true)
                    {
                        port++;

                        if (port > 65535)
                        {
                            throw new InvalidOperationException("Exceeded port range");
                        }

                        // AppDomainOwnedPorts check enables reserving two ports from the same thread in sequence.
                        // ListUsedTCPPort prevents port contention with other apps.
                        if (_appDomainOwnedPorts.Contains(port) || usedTCPPorts.Contains(port))
                        {
                            continue;
                        }

                        // Create a well known mutex
                        string mutexName = "WebStack-Port-" + port.ToString(CultureInfo.InvariantCulture);
                        _portMutex = new Mutex(initiallyOwned: false, name: mutexName);

                        // If no one else is using this port grab it.
                        if (_portMutex.WaitOne(millisecondsTimeout: 0))
                        {
                            _acquiredOn = Thread.CurrentThread;
                            break;
                        }

                        // dispose this mutex since the port it represents is not available.
                        _portMutex.Dispose();
                        _portMutex = null;
                    }

                    PortNumber = port;
                    _appDomainOwnedPorts.Add(port);
                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
        }

        public string BaseUri
        {
            get
            {
                return String.Format(CultureInfo.InvariantCulture, "http://localhost:{0}/", PortNumber);
            }
        }

        public void Dispose()
        {
            if (PortNumber == -1)
            {
                // Object already disposed
                return;
            }

            using (Mutex mutex = GetGlobalMutex())
            {
                try
                {
                    using (_portMutex)
                    {
                        if (_acquiredOn == Thread.CurrentThread)
                        {
                            _portMutex.ReleaseMutex();
                        }

                        _portMutex = null;
                    }

                    _appDomainOwnedPorts.Remove(PortNumber);
                    PortNumber = -1;
                }
                finally
                {
                    mutex.ReleaseMutex();
                }
            }
        }

        private static Mutex GetGlobalMutex()
        {
            const int timeoutInSeconds = 20;

            Mutex mutex = new Mutex(initiallyOwned: false, name: "WebStack-RandomPortAcquisition");
            if (!mutex.WaitOne(TimeSpan.FromSeconds(timeoutInSeconds)))
            {
                throw new InvalidOperationException(
                    String.Format("Unable to reserve global Mutex within {0} seconds.", timeoutInSeconds));
            }

            return mutex;
        }

        private static IPEndPoint[] ListUsedTCPPort()
        {
            IPGlobalProperties ipGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();

            return ipGlobalProperties.GetActiveTcpListeners()
                .Concat(ipGlobalProperties.GetActiveUdpListeners())
                .ToArray();
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/PreAppStartTestHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.WebPages.TestUtils
{
    public static class PreAppStartTestHelper
    {
        public static void TestPreAppStartClass(Type preAppStartType)
        {
            string typeMessage = String.Format("The type '{0}' must be static, public, and named 'PreApplicationStartCode'.", preAppStartType.FullName);
            Assert.True(preAppStartType.IsSealed && preAppStartType.IsAbstract && preAppStartType.IsPublic && preAppStartType.Name == "PreApplicationStartCode", typeMessage);

            string editorBrowsableMessage = String.Format("The only attribute on type '{0}' must be [EditorBrowsable(EditorBrowsableState.Never)].", preAppStartType.FullName);
            object[] attrs = preAppStartType.GetCustomAttributes(typeof(EditorBrowsableAttribute), true);
            Assert.True(attrs.Length == 1 && ((EditorBrowsableAttribute)attrs[0]).State == EditorBrowsableState.Never, editorBrowsableMessage);

            string startMethodMessage = String.Format("The only public member on type '{0}' must be a method called Start().", preAppStartType.FullName);
            MemberInfo[] publicMembers = preAppStartType.GetMembers(BindingFlags.Public | BindingFlags.Static);
            Assert.True(publicMembers.Length == 1, startMethodMessage);
            Assert.True(publicMembers[0].MemberType == MemberTypes.Method, startMethodMessage);
            Assert.True(publicMembers[0].Name == "Start", startMethodMessage);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/PreserveSyncContextAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// Preserves the current <see cref="SynchronizationContext"/>. Use this attribute on
    /// tests which modify the current <see cref="SynchronizationContext"/>.
    /// </summary>
    public class PreserveSyncContextAttribute : Xunit.Sdk.BeforeAfterTestAttribute
    {
        private SynchronizationContext _syncContext;

        public override void Before(System.Reflection.MethodInfo methodUnderTest)
        {
            _syncContext = SynchronizationContext.Current;
        }

        public override void After(System.Reflection.MethodInfo methodUnderTest)
        {
            SynchronizationContext.SetSynchronizationContext(_syncContext);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/PropertyDataAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;
using Xunit;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    // Xunit.MemberDataAttribute is unfortunately sealed. Duplicate its code here since method we need is protected.
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)]
    [DataDiscoverer("Xunit.Sdk.MemberDataDiscoverer", "xunit.core")]
    public class PropertyDataAttribute : MemberDataAttributeBase
    {
        public PropertyDataAttribute(string propertyName, params object[] parameters)
            : base(propertyName, parameters)
        {
        }

        public Type PropertyType
        {
            get
            {
                return MemberType;
            }
            set
            {
                MemberType = value;
            }
        }

        protected override object[] ConvertDataItem(MethodInfo testMethod, object item)
        {
            if (item == null)
            {
                return null;
            }

            var array = item as object[];
            if (array == null)
            {
                throw new ArgumentException(String.Format(
                    "Property {0} on {1} yielded an item that is not an object[].",
                    MemberName,
                    MemberType ?? testMethod.DeclaringType));
            }

            return array;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/ReflectionAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq.Expressions;
using System.Reflection;

namespace Microsoft.TestCommon
{
    public class ReflectionAssert
    {
        private static PropertyInfo GetPropertyInfo<T, TProp>(Expression<Func<T, TProp>> property)
        {
            if (property.Body is MemberExpression)
            {
                return (PropertyInfo)((MemberExpression)property.Body).Member;
            }
            else if (property.Body is UnaryExpression && property.Body.NodeType == ExpressionType.Convert)
            {
                return (PropertyInfo)((MemberExpression)((UnaryExpression)property.Body).Operand).Member;
            }
            else
            {
                throw new InvalidOperationException("Could not determine property from lambda expression.");
            }
        }

        private static void TestPropertyValue<TInstance, TValue>(TInstance instance, Func<TInstance, TValue> getFunc, Action<TInstance, TValue> setFunc, TValue valueToSet, TValue valueToCheck)
        {
            setFunc(instance, valueToSet);
            TValue newValue = getFunc(instance);
            Assert.Equal(valueToCheck, newValue);
        }

        private static void TestPropertyValue<TInstance, TValue>(TInstance instance, Func<TInstance, TValue> getFunc, Action<TInstance, TValue> setFunc, TValue value)
        {
            TestPropertyValue(instance, getFunc, setFunc, value, value);
        }

        public void Property<T, TResult>(T instance, Expression<Func<T, TResult>> propertyGetter, TResult expectedDefaultValue, bool allowNull = false, TResult roundTripTestValue = null) where TResult : class
        {
            PropertyInfo property = GetPropertyInfo(propertyGetter);
            Func<T, TResult> getFunc = (obj) => (TResult)property.GetValue(obj, index: null);
            Action<T, TResult> setFunc = (obj, value) => property.SetValue(obj, value, index: null);

            Assert.Equal(expectedDefaultValue, getFunc(instance));

            if (allowNull)
            {
                TestPropertyValue(instance, getFunc, setFunc, null);
            }
            else
            {
                Assert.ThrowsArgumentNull(() =>
                {
                    setFunc(instance, null);
                }, "value");
            }

            if (roundTripTestValue != null)
            {
                TestPropertyValue(instance, getFunc, setFunc, roundTripTestValue);
            }
        }

        public void IntegerProperty<T, TResult>(T instance, Expression<Func<T, TResult>> propertyGetter, TResult expectedDefaultValue,
            TResult? minLegalValue, TResult? illegalLowerValue,
            TResult? maxLegalValue, TResult? illegalUpperValue,
            TResult roundTripTestValue) where TResult : struct
        {
            PropertyInfo property = GetPropertyInfo(propertyGetter);
            Func<T, TResult> getFunc = (obj) => (TResult)property.GetValue(obj, index: null);
            Action<T, TResult> setFunc = (obj, value) => property.SetValue(obj, value, index: null);

            Assert.Equal(expectedDefaultValue, getFunc(instance));

            if (minLegalValue.HasValue)
            {
                TestPropertyValue(instance, getFunc, setFunc, minLegalValue.Value);
            }

            if (maxLegalValue.HasValue)
            {
                TestPropertyValue(instance, getFunc, setFunc, maxLegalValue.Value);
            }

            if (illegalLowerValue.HasValue)
            {
                Assert.ThrowsArgumentGreaterThanOrEqualTo(() => { setFunc(instance, illegalLowerValue.Value); }, "value", minLegalValue.Value.ToString(), illegalLowerValue.Value);
            }

            if (illegalUpperValue.HasValue)
            {
                Assert.ThrowsArgumentLessThanOrEqualTo(() => { setFunc(instance, illegalLowerValue.Value); }, "value", maxLegalValue.Value.ToString(), illegalUpperValue.Value);
            }

            TestPropertyValue(instance, getFunc, setFunc, roundTripTestValue);
        }

        public void NullableIntegerProperty<T, TResult>(T instance, Expression<Func<T, TResult?>> propertyGetter, TResult? expectedDefaultValue,
            TResult? minLegalValue, TResult? illegalLowerValue,
            TResult? maxLegalValue, TResult? illegalUpperValue,
            TResult roundTripTestValue) where TResult : struct
        {
            PropertyInfo property = GetPropertyInfo(propertyGetter);
            Func<T, TResult?> getFunc = (obj) => (TResult?)property.GetValue(obj, index: null);
            Action<T, TResult?> setFunc = (obj, value) => property.SetValue(obj, value, index: null);

            Assert.Equal(expectedDefaultValue, getFunc(instance));

            TestPropertyValue(instance, getFunc, setFunc, null);

            if (minLegalValue.HasValue)
            {
                TestPropertyValue(instance, getFunc, setFunc, minLegalValue.Value);
            }

            if (maxLegalValue.HasValue)
            {
                TestPropertyValue(instance, getFunc, setFunc, maxLegalValue.Value);
            }

            if (illegalLowerValue.HasValue)
            {
                Assert.ThrowsArgumentGreaterThanOrEqualTo(() => { setFunc(instance, illegalLowerValue.Value); }, "value", minLegalValue.Value.ToString(), illegalLowerValue.Value);
            }

            if (illegalUpperValue.HasValue)
            {
                Assert.ThrowsArgumentLessThanOrEqualTo(() => { setFunc(instance, illegalLowerValue.Value); }, "value", maxLegalValue.Value.ToString(), illegalUpperValue.Value);
            }

            TestPropertyValue(instance, getFunc, setFunc, roundTripTestValue);
        }

        public void BooleanProperty<T>(T instance, Expression<Func<T, bool>> propertyGetter, bool expectedDefaultValue)
        {
            PropertyInfo property = GetPropertyInfo(propertyGetter);
            Func<T, bool> getFunc = (obj) => (bool)property.GetValue(obj, index: null);
            Action<T, bool> setFunc = (obj, value) => property.SetValue(obj, value, index: null);

            Assert.Equal(expectedDefaultValue, getFunc(instance));

            TestPropertyValue(instance, getFunc, setFunc, !expectedDefaultValue);
        }

        public void EnumProperty<T, TResult>(T instance, Expression<Func<T, TResult>> propertyGetter, TResult expectedDefaultValue, TResult illegalValue, TResult roundTripTestValue) where TResult : struct
        {
            PropertyInfo property = GetPropertyInfo(propertyGetter);
            Func<T, TResult> getFunc = (obj) => (TResult)property.GetValue(obj, index: null);
            Action<T, TResult> setFunc = (obj, value) => property.SetValue(obj, value, index: null);

            Assert.Equal(expectedDefaultValue, getFunc(instance));

            Assert.ThrowsInvalidEnumArgument(() => { setFunc(instance, illegalValue); }, "value", Convert.ToInt32(illegalValue), typeof(TResult));

            TestPropertyValue(instance, getFunc, setFunc, roundTripTestValue);
        }

        public void EnumPropertyWithoutIllegalValueCheck<T, TResult>(T instance, Expression<Func<T, TResult>> propertyGetter, TResult expectedDefaultValue, TResult roundTripTestValue) where TResult : struct
        {
            PropertyInfo property = GetPropertyInfo(propertyGetter);
            Func<T, TResult> getFunc = (obj) => (TResult)property.GetValue(obj, index: null);
            Action<T, TResult> setFunc = (obj, value) => property.SetValue(obj, value, index: null);

            Assert.Equal(expectedDefaultValue, getFunc(instance));

            TestPropertyValue(instance, getFunc, setFunc, roundTripTestValue);
        }

        public void StringProperty<T>(T instance, Expression<Func<T, string>> propertyGetter, string expectedDefaultValue,
                                      bool allowNullAndEmpty = true, bool treatNullAsEmpty = true)
        {
            PropertyInfo property = GetPropertyInfo(propertyGetter);
            Func<T, string> getFunc = (obj) => (string)property.GetValue(obj, index: null);
            Action<T, string> setFunc = (obj, value) => property.SetValue(obj, value, index: null);

            Assert.Equal(expectedDefaultValue, getFunc(instance));

            if (allowNullAndEmpty)
            {
                // Assert get/set works for null
                TestPropertyValue(instance, getFunc, setFunc, null, treatNullAsEmpty ? String.Empty : null);

                // Assert get/set works for String.Empty
                TestPropertyValue(instance, getFunc, setFunc, String.Empty, String.Empty);
            }
            else
            {
                Assert.ThrowsArgumentNullOrEmpty(
                    delegate()
                    {
                        try
                        {
                            TestPropertyValue(instance, getFunc, setFunc, null);
                        }
                        catch (TargetInvocationException e)
                        {
                            throw e.InnerException;
                        }
                    },
                    "value");
                Assert.ThrowsArgumentNullOrEmpty(
                    delegate()
                    {
                        try
                        {
                            TestPropertyValue(instance, getFunc, setFunc, String.Empty);
                        }
                        catch (TargetInvocationException e)
                        {
                            throw e.InnerException;
                        }
                    },
                    "value");
            }

            // Assert get/set works for arbitrary value
            TestPropertyValue(instance, getFunc, setFunc, "TestValue");
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/ReplaceCultureAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Reflection;
using System.Threading;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// Replaces the current culture and UI culture for the test.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method)]
    public class ReplaceCultureAttribute : Xunit.Sdk.BeforeAfterTestAttribute
    {
        private CultureInfo _originalCulture;
        private CultureInfo _originalUICulture;

        public ReplaceCultureAttribute()
        {
            Culture = CultureReplacer.DefaultCultureName;
            UICulture = CultureReplacer.DefaultUICultureName;
        }

        /// <summary>
        /// Sets <see cref="Thread.CurrentCulture"/> for the test. Defaults to en-GB.
        /// </summary>
        /// <remarks>
        /// en-GB is used here as the default because en-US is equivalent to the InvariantCulture. We
        /// want to be able to find bugs where we're accidentally relying on the Invariant instead of the
        /// user's culture.
        /// </remarks>
        public string Culture { get; set; }

        /// <summary>
        /// Sets <see cref="Thread.CurrentUICulture"/> for the test. Defaults to en-US.
        /// </summary>
        public string UICulture { get; set; }

        public override void Before(MethodInfo methodUnderTest)
        {
            _originalCulture = Thread.CurrentThread.CurrentCulture;
            _originalUICulture = Thread.CurrentThread.CurrentUICulture;

            Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo(Culture);
            Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo(UICulture);
        }

        public override void After(MethodInfo methodUnderTest)
        {
            Thread.CurrentThread.CurrentCulture = _originalCulture;
            Thread.CurrentThread.CurrentUICulture = _originalUICulture;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/RestoreThreadPrincipalAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;
using System.Security.Principal;
using System.Threading;

namespace Microsoft.TestCommon
{
    public class RestoreThreadPrincipalAttribute : Xunit.Sdk.BeforeAfterTestAttribute
    {
        private IPrincipal _originalPrincipal;

        public override void Before(MethodInfo methodUnderTest)
        {
            _originalPrincipal = Thread.CurrentPrincipal;

            AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.NoPrincipal);

            Thread.CurrentPrincipal = null;
        }

        public override void After(MethodInfo methodUnderTest)
        {
            Thread.CurrentPrincipal = _originalPrincipal;

            AppDomain.CurrentDomain.SetPrincipalPolicy(PrincipalPolicy.UnauthenticatedPrincipal);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/SkippedXunitTestCase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Xunit.Abstractions;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// An <see cref="XunitTestCase"/> which is unconditionally skipped.
    /// </summary>
    /// <remarks>
    /// Similar to <c>Xunit.Sdk.XunitSkippedDataRowTestCase</c> but with a more general name. Besides, that will not
    /// exist until xUnit.net 2.2.0 is stable.
    /// </remarks>
    public class SkippedXunitTestCase : XunitTestCase
    {
        private readonly String _skipReason;

        /// <summary>
        /// Instantiates a new <see cref="SkippedXunitTestCase"/> instance.
        /// </summary>
        /// <param name="diagnosticMessageSink">The <see cref="IMessageSink"/> used to send diagnostic messages.</param>
        /// <param name="defaultMethodDisplay">Default <see cref="TestMethodDisplay"/>  to use (when not customized).</param>
        /// <param name="skipReason">The reason that this <see cref="SkippedXunitTestCase"/> will be skipped.</param>
        /// <param name="testMethod">The <see cref="ITestMethod"/> this test case belongs to.</param>
        /// <param name="testMethodArguments">The arguments for the test method.</param>
        public SkippedXunitTestCase(
            IMessageSink diagnosticMessageSink,
            TestMethodDisplay defaultMethodDisplay,
            TestMethodDisplayOptions defaultMethodDisplayOptions,
            String skipReason,
            ITestMethod testMethod,
            object[] testMethodArguments = null)
            : base(diagnosticMessageSink, defaultMethodDisplay, defaultMethodDisplayOptions, testMethod, testMethodArguments)
        {
            _skipReason = skipReason;
        }

        /// <inheritdoc/>
        protected override string GetSkipReason(IAttributeInfo factAttribute)
        {
            return _skipReason;
        }
    }
}

================================================
FILE: test/Microsoft.TestCommon/TestFile.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.WebPages.TestUtils
{
    public class TestFile
    {
        public const string ResourceNameFormat = "{0}.TestFiles.{1}";

        public string ResourceName { get; set; }
        public Assembly Assembly { get; set; }

        public TestFile(string resName, Assembly asm)
        {
            ResourceName = resName;
            Assembly = asm;
        }

        public static TestFile Create(string localResourceName)
        {
            return new TestFile(String.Format(ResourceNameFormat, Assembly.GetCallingAssembly().GetName().Name, localResourceName), Assembly.GetCallingAssembly());
        }

        public Stream OpenRead()
        {
            Stream strm = Assembly.GetManifestResourceStream(ResourceName);
            if (strm == null)
            {
                Assert.True(false, String.Format("Manifest resource: {0} not found", ResourceName));
            }
            return strm;
        }

        public byte[] ReadAllBytes()
        {
            using (Stream stream = OpenRead())
            {
                byte[] buffer = new byte[stream.Length];
                stream.Read(buffer, 0, buffer.Length);
                return buffer;
            }
        }

        public string ReadAllText()
        {
            using (StreamReader reader = new StreamReader(OpenRead()))
            {
                // The .Replace() calls normalize line endings, in case you get \n instead of \r\n
                // since all the unit tests rely on the assumption that the files will have \r\n endings.
                return reader.ReadToEnd().Replace("\r", "").Replace("\n", "\r\n");
            }
        }

        /// <summary>
        /// Saves the file to the specified path.
        /// </summary>
        public void Save(string filePath)
        {
            var directory = Path.GetDirectoryName(filePath);
            if (!Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }

            using (Stream outStream = File.Create(filePath))
            {
                using (Stream inStream = OpenRead())
                {
                    inStream.CopyTo(outStream);
                }
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/TestHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.TestUtil
{
    public static class UnitTestHelper
    {
        public static bool EnglishBuildAndOS
        {
            get
            {
                bool englishBuild = String.Equals(CultureInfo.CurrentCulture.TwoLetterISOLanguageName, "en",
                                                  StringComparison.OrdinalIgnoreCase);
                bool englishOS = String.Equals(CultureInfo.CurrentCulture.TwoLetterISOLanguageName, "en",
                                               StringComparison.OrdinalIgnoreCase);
                return englishBuild && englishOS;
            }
        }

        public static void AssertEqualsIgnoreWhitespace(string expected, string actual)
        {
            expected = new String(expected.Where(c => !Char.IsWhiteSpace(c)).ToArray());
            actual = new String(actual.Where(c => !Char.IsWhiteSpace(c)).ToArray());

            Assert.Equal(expected, actual, StringComparer.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/TheoryAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// An override of <see cref="Xunit.TheoryAttribute"/> that provides extended capabilities.
    /// </summary>
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    [XunitTestCaseDiscoverer("Microsoft.TestCommon.TheoryDiscoverer", "Microsoft.TestCommon")]
    public class TheoryAttribute : Xunit.TheoryAttribute
    {
        /// <summary>
        /// Instantiates a new instance of <see cref="TheoryAttribute"/>.
        /// </summary>
        public TheoryAttribute()
        {
            Platforms = Platform.All;
            PlatformJustification = "Unsupported platform (test runs on {0}, current platform is {1})";
        }

        /// <summary>
        /// Gets or set the platforms that the unit test is compatible with. Defaults to
        /// <see cref="Platform.All"/>.
        /// </summary>
        public Platform Platforms { get; set; }

        /// <summary>
        /// Gets or sets the platform skipping justification. This message can receive
        /// the supported platforms as {0}, and the current platform as {1}.
        /// </summary>
        public string PlatformJustification { get; set; }
    }
}

================================================
FILE: test/Microsoft.TestCommon/TheoryDataSet.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// Helper class for generating test data for XUnit's <see cref="Xunit.Extensions.TheoryAttribute"/>-based tests.
    /// Should be used in combination with <see cref="Xunit.Extensions.PropertyDataAttribute"/>.
    /// </summary>
    /// <typeparam name="TParam">First parameter type</typeparam>
    public class TheoryDataSet<TParam> : TheoryDataSet
    {
        public void Add(TParam p)
        {
            AddItem(p);
        }
    }

    /// <summary>
    /// Helper class for generating test data for XUnit's <see cref="Xunit.Extensions.TheoryAttribute"/>-based tests.
    /// Should be used in combination with <see cref="Xunit.Extensions.PropertyDataAttribute"/>.
    /// </summary>
    /// <typeparam name="TParam1">First parameter type</typeparam>
    /// <typeparam name="TParam2">Second parameter type</typeparam>
    public class TheoryDataSet<TParam1, TParam2> : TheoryDataSet
    {
        public void Add(TParam1 p1, TParam2 p2)
        {
            AddItem(p1, p2);
        }
    }

    /// <summary>
    /// Helper class for generating test data for XUnit's <see cref="Xunit.Extensions.TheoryAttribute"/>-based tests.
    /// Should be used in combination with <see cref="Xunit.Extensions.PropertyDataAttribute"/>.
    /// </summary>
    /// <typeparam name="TParam1">First parameter type</typeparam>
    /// <typeparam name="TParam2">Second parameter type</typeparam>
    /// <typeparam name="TParam3">Third parameter type</typeparam>
    public class TheoryDataSet<TParam1, TParam2, TParam3> : TheoryDataSet
    {
        public void Add(TParam1 p1, TParam2 p2, TParam3 p3)
        {
            AddItem(p1, p2, p3);
        }
    }

    /// <summary>
    /// Helper class for generating test data for XUnit's <see cref="Xunit.Extensions.TheoryAttribute"/>-based tests.
    /// Should be used in combination with <see cref="Xunit.Extensions.PropertyDataAttribute"/>.
    /// </summary>
    /// <typeparam name="TParam1">First parameter type</typeparam>
    /// <typeparam name="TParam2">Second parameter type</typeparam>
    /// <typeparam name="TParam3">Third parameter type</typeparam>
    /// <typeparam name="TParam4">Fourth parameter type</typeparam>
    public class TheoryDataSet<TParam1, TParam2, TParam3, TParam4> : TheoryDataSet
    {
        public void Add(TParam1 p1, TParam2 p2, TParam3 p3, TParam4 p4)
        {
            AddItem(p1, p2, p3, p4);
        }
    }

    /// <summary>
    /// Helper class for generating test data for XUnit's <see cref="Xunit.Extensions.TheoryAttribute"/>-based tests.
    /// Should be used in combination with <see cref="Xunit.Extensions.PropertyDataAttribute"/>.
    /// </summary>
    /// <typeparam name="TParam1">First parameter type</typeparam>
    /// <typeparam name="TParam2">Second parameter type</typeparam>
    /// <typeparam name="TParam3">Third parameter type</typeparam>
    /// <typeparam name="TParam4">Fourth parameter type</typeparam>
    /// <typeparam name="TParam5">Fifth parameter type</typeparam>
    public class TheoryDataSet<TParam1, TParam2, TParam3, TParam4, TParam5> : TheoryDataSet
    {
        public void Add(TParam1 p1, TParam2 p2, TParam3 p3, TParam4 p4, TParam5 p5)
        {
            AddItem(p1, p2, p3, p4, p5);
        }
    }

    /// <summary>
    /// Base class for <c>TheoryDataSet</c> classes.
    /// </summary>
    public abstract class TheoryDataSet : IEnumerable<object[]>
    {
        private readonly List<object[]> data = new List<object[]>();

        protected void AddItem(params object[] values)
        {
            data.Add(values);
        }

        public IEnumerator<object[]> GetEnumerator()
        {
            return data.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/TheoryDiscoverer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Xunit.Abstractions;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// An override of <see cref="Xunit.Sdk.TheoryDiscoverer"/> that provides extended capabilities.
    /// </summary>
    public class TheoryDiscoverer : Xunit.Sdk.TheoryDiscoverer
    {
        private readonly IMessageSink _diagnosticMessageSink;

        /// <summary>
        /// Instantiates a new <see cref="TheoryDiscoverer"/> instance.
        /// </summary>
        /// <param name="diagnosticMessageSink">The <see cref="IMessageSink"/> used to send diagnostic messages.</param>
        public TheoryDiscoverer(IMessageSink diagnosticMessageSink)
            : base(diagnosticMessageSink)
        {
            _diagnosticMessageSink = diagnosticMessageSink;
        }

        /// <summary>
        /// Gets the platform that the unit test is currently running on.
        /// </summary>
        protected Platform Platform
        {
            get { return PlatformInfo.Platform; }
        }

        /// <inheritdoc/>
        public override IEnumerable<IXunitTestCase> Discover(
            ITestFrameworkDiscoveryOptions discoveryOptions,
            ITestMethod testMethod,
            IAttributeInfo theoryAttribute)
        {
            var baseCases = base.Discover(discoveryOptions, testMethod, theoryAttribute);
            if (!String.IsNullOrEmpty(theoryAttribute.GetNamedArgument<string>("Skip")))
            {
                // No need to change skipped tests.
                return baseCases;
            }

            var platforms = theoryAttribute.GetNamedArgument<Platform>("Platforms");
            if ((platforms & Platform) != 0)
            {
                // No need to change tests that should run on the current platform.
                return baseCases;
            }

            // Update the individual test cases as needed: Skip test cases that would otherwise run.
            var testCases = new List<IXunitTestCase>();
            var platformJustification = theoryAttribute.GetNamedArgument<string>("PlatformJustification");
            var skipReason = String.Format(platformJustification, platforms.ToString().Replace(", ", " | "), Platform);
            foreach (var baseCase in baseCases)
            {
                if (baseCase is ExecutionErrorTestCase)
                {
                    // No need to change an erroneous test. Covered to protect against changes in the base class.
                    testCases.Add(baseCase);
                    continue;
                }

                if (!String.IsNullOrEmpty(baseCase.SkipReason))
                {
                    // No need to change a skipped test. Likely to hit this case only after xUnit.net has been updated
                    // to 2.2.0+, where [Data] also has a Skip property.
                    testCases.Add(baseCase);
                    continue;
                }

                var testCase = new SkippedXunitTestCase(
                    _diagnosticMessageSink,
                    discoveryOptions.MethodDisplayOrDefault(),
                    TestMethodDisplayOptions.None,
                    skipReason,
                    baseCase.TestMethod,
                    baseCase.TestMethodArguments);
                testCases.Add(testCase);
            }

            return testCases;
        }
    }
}

================================================
FILE: test/Microsoft.TestCommon/ThreadPoolSyncContext.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace Microsoft.TestCommon
{
    /// <summary>
    /// This is an implementation of SynchronizationContext that not only queues things on the thread pool for
    /// later work, but also ensures that it sets itself back as the synchronization context (something that the
    /// default implementatation of SynchronizationContext does not do).
    /// </summary>
    public class ThreadPoolSyncContext : SynchronizationContext
    {
        public override void Post(SendOrPostCallback d, object state)
        {
            ThreadPool.QueueUserWorkItem(_ =>
            {
                SynchronizationContext oldContext = SynchronizationContext.Current;
                SynchronizationContext.SetSynchronizationContext(this);
                d.Invoke(state);
                SynchronizationContext.SetSynchronizationContext(oldContext);
            }, null);
        }

        public override void Send(SendOrPostCallback d, object state)
        {
            SynchronizationContext oldContext = SynchronizationContext.Current;
            SynchronizationContext.SetSynchronizationContext(this);
            d.Invoke(state);
            SynchronizationContext.SetSynchronizationContext(oldContext);
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/TraitAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Xunit.Sdk;

namespace Microsoft.TestCommon
{
    // Xunit.MemberDataAttribute is unfortunately sealed. Duplicate its code here since there's nothing to it.
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, AllowMultiple = true)]
    [TraitDiscoverer("Xunit.Sdk.TraitDiscoverer", "xunit.core")]
    public class TraitAttribute : Attribute, ITraitAttribute
    {
        public TraitAttribute(string name, string value)
        {
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/VersionTestHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;

namespace Microsoft.TestCommon
{
    public static class VersionTestHelper
    {
        // returns a version for an assembly by using a type from the assembly
        // also verifies that type wasn't moved to another assembly.
        public static Version GetVersionFromAssembly(string assemblyName, Type typeFromAssembly)
        {
            Assembly assembly = typeFromAssembly.Assembly;

            Assert.Equal(assemblyName, assembly.GetName().Name);
            return assembly.GetName().Version;
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/WebUtils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Reflection;
using System.Web.UI;

namespace System.Web.WebPages.TestUtils
{
    public static class WebUtils
    {
        /// <summary>
        /// Creates an instance of HttpRuntime and assigns it (using magic) to the singleton instance of HttpRuntime. 
        /// Ensure that the returned value is disposed at the end of the test.
        /// </summary>
        /// <returns>Returns an IDisposable that restores the original HttpRuntime.</returns>
        public static IDisposable CreateHttpRuntime(string appVPath, string appPath = null)
        {
            var runtime = new HttpRuntime();
            var appDomainAppVPathField = typeof(HttpRuntime).GetField("_appDomainAppVPath", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
            appDomainAppVPathField.SetValue(runtime, CreateVirtualPath(appVPath));

            if (appPath != null)
            {
                var appDomainAppPathField = typeof(HttpRuntime).GetField("_appDomainAppPath", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
                appDomainAppPathField.SetValue(runtime, Path.GetFullPath(appPath));
            }

            GetTheRuntime().SetValue(null, runtime);
            var appDomainIdField = typeof(HttpRuntime).GetField("_appDomainId", BindingFlags.NonPublic | BindingFlags.Instance);
            appDomainIdField.SetValue(runtime, "test");

            return new DisposableAction(RestoreHttpRuntime);
        }

        internal static FieldInfo GetTheRuntime()
        {
            return typeof(HttpRuntime).GetField("_theRuntime", BindingFlags.NonPublic | BindingFlags.Static);
        }

        internal static void RestoreHttpRuntime()
        {
            GetTheRuntime().SetValue(null, null);
        }

        internal static object CreateVirtualPath(string path)
        {
            var vPath = typeof(Page).Assembly.GetType("System.Web.VirtualPath");
            var method = vPath.GetMethod("CreateNonRelativeTrailingSlash", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
            return method.Invoke(null, new object[] { path });
        }

        private class DisposableAction : IDisposable
        {
            private Action _action;
            private bool _hasDisposed;

            public DisposableAction(Action action)
            {
                if (action == null)
                {
                    throw new ArgumentNullException("action");
                }
                _action = action;
            }

            public void Dispose()
            {
                Dispose(true);
                GC.SuppressFinalize(this);
            }

            protected virtual void Dispose(bool disposing)
            {
                // If we were disposed by the finalizer it's because the user didn't use a "using" block, so don't do anything!
                if (disposing)
                {
                    lock (this)
                    {
                        if (!_hasDisposed)
                        {
                            _hasDisposed = true;
                            _action();
                        }
                    }
                }
            }
        }
    }
}


================================================
FILE: test/Microsoft.TestCommon/xunit.runner.json
================================================
{
  "diagnosticMessages": false,
  "preEnumerateTheories": false
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/AnalyticsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace Microsoft.Web.Helpers.Test
{
    public class AnalyticsTest
    {
        [Fact]
        public void GetYahooAnalyticsHtmlTest()
        {
            string account = "My_yahoo_account";
            string actual = Analytics.GetYahooHtml(account).ToString();
            Assert.True(actual.Contains(".yahoo.com") && actual.Contains("My_yahoo_account"));
        }

        [Fact]
        public void GetStatCounterAnalyticsHtmlTest()
        {
            int project = 31553;
            string security = "stat_security";
            string actual = Analytics.GetStatCounterHtml(project, security).ToString();
            Assert.True(actual.Contains("statcounter.com/counter/counter_xhtml.js") &&
                        actual.Contains(project.ToString()) && actual.Contains(security));
        }

        [Fact]
        public void GetGoogleAnalyticsHtmlTest()
        {
            string account = "My_google_account";
            string actual = Analytics.GetGoogleHtml(account).ToString();
            Assert.True(actual.Contains("google-analytics.com/ga.js") && actual.Contains("My_google_account"));
        }

        [Fact]
        public void GetGoogleAnalyticsEscapesJavascript()
        {
            string account = "My_\"google_account";
            string actual = Analytics.GetGoogleHtml(account).ToString();
            string expected = "<script type=\"text/javascript\">\n" +
                              "var gaJsHost = ((\"https:\" == document.location.protocol) ? \"https://ssl.\" : \"http://www.\");\n" +
                              "document.write(unescape(\"%3Cscript src='\" + gaJsHost + \"google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E\"));\n" +
                              "</script>\n" +
                              "<script type=\"text/javascript\">\n" +
                              "try{\n" +
                              "var pageTracker = _gat._getTracker(\"My_\\\"google_account\");\n" +
                              "pageTracker._trackPageview();\n" +
                              "} catch(err) {}\n" +
                              "</script>\n";
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expected, actual);
        }

        [Fact]
        public void GetGoogleAnalyticsAsyncHtmlTest()
        {
            string account = "My_google_account";
            string actual = Analytics.GetGoogleAsyncHtml(account).ToString();
            Assert.True(actual.Contains("google-analytics.com/ga.js") && actual.Contains("My_google_account"));
        }

        [Fact]
        public void GetGoogleAnalyticsAsyncHtmlEscapesJavaScript()
        {
            string account = "My_\"google_account";
            string actual = Analytics.GetGoogleAsyncHtml(account).ToString();
            string expected = "<script type=\"text/javascript\">\n" +
                              "var _gaq = _gaq || [];\n" +
                              "_gaq.push(['_setAccount', 'My_\\\"google_account']);\n" +
                              "_gaq.push(['_trackPageview']);\n" +
                              "(function() {\n" +
                              "var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;\n" +
                              "ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';\n" +
                              "var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);\n" +
                              "})();\n" +
                              "</script>\n";
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expected, actual);
        }

        [Fact]
        public void GetYahooAnalyticsEscapesJavascript()
        {
            string account = "My_\"yahoo_account";
            string actual = Analytics.GetYahooHtml(account).ToString();
            string expected = "<script type=\"text/javascript\">\n" +
                              "window.ysm_customData = new Object();\n" +
                              "window.ysm_customData.conversion = \"transId=,currency=,amount=\";\n" +
                              "var ysm_accountid = \"My_\\\"yahoo_account\";\n" +
                              "document.write(\"<SCR\" + \"IPT language='JavaScript' type='text/javascript' \"\n" +
                              "+ \"SRC=//\" + \"srv3.wa.marketingsolutions.yahoo.com\" + \"/script/ScriptServlet\" + \"?aid=\" + ysm_accountid\n" +
                              "+ \"></SCR\" + \"IPT>\");\n" +
                              "</script>\n";
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expected, actual);
        }

        [Fact]
        public void GetStatCounterAnalyticsEscapesCorrectly()
        {
            string account = "My_\"stat_account";
            string actual = Analytics.GetStatCounterHtml(2, account).ToString();
            string expected = "<script type=\"text/javascript\">\n" +
                              "var sc_project=2;\n" +
                              "var sc_invisible=1;\n" +
                              "var sc_security=\"My_\\\"stat_account\";\n" +
                              "var sc_text=2;\n" +
                              "var sc_https=1;\n" +
                              "var scJsHost = ((\"https:\" == document.location.protocol) ? \"https://secure.\" : \"http://www.\");\n" +
                              "document.write(\"<sc\" + \"ript type='text/javascript' src='\" + " +
                              "scJsHost + \"statcounter.com/counter/counter_xhtml.js'></\" + \"script>\");\n" +
                              "</script>\n\n" +
                              "<noscript>" +
                              "<div class=\"statcounter\">" +
                              "<a title=\"tumblrstatistics\" class=\"statcounter\" href=\"http://www.statcounter.com/tumblr/\">" +
                              "<img class=\"statcounter\" src=\"https://c.statcounter.com/2/0/My_&quot;stat_account/1/\" alt=\"tumblr statistics\"/>" +
                              "</a>" +
                              "</div>" +
                              "</noscript>";

            UnitTestHelper.AssertEqualsIgnoreWhitespace(expected, actual);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/FacebookTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web;
using System.Web.TestUtil;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Helpers.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class FacebookTest : IDisposable
    {
        public FacebookTest()
        {
            Facebook.AppId = "myapp'";
            Facebook.AppSecret = "myappsecret";
            Facebook.Language = "french";
        }

        [Fact]
        public void GetFacebookCookieInfoReturnsEmptyStringIfCookieIsNotPresent()
        {
            // Arrange
            var context = CreateHttpContext();

            // Act
            var info = Facebook.GetFacebookCookieInfo(context, "foo");

            // Assert
            Assert.Equal("", info);
        }

        [Fact]
        public void GetFacebookCookieInfoThrowsIfCookieIsNotValid()
        {
            // Arrange

            var context = CreateHttpContext(new Dictionary<string, string>
            {
                {"fbs_myapp'", "sig=malformed-signature&name=foo&val=bar&uid=MyFacebookName"},
                {"fbs_uid", "MyFacebookName"},
            });

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => Facebook.GetFacebookCookieInfo(context, "uid"), "Invalid Facebook cookie.");
        }

        [Fact]
        public void GetFacebookCookieReturnsUserIdIfCookieIsValid()
        {
            // Arrange
            var context = CreateHttpContext(new Dictionary<string, string>
            {
                {"fbs_myapp'", "sig=B2E6B3A21D0C9FA72E612BD6C3084807&name=foo&val=bar&uid=MyFacebookName"},
            });

            // Act
            var info = Facebook.GetFacebookCookieInfo(context, "uid");

            // Assert
            Assert.Equal("MyFacebookName", info);
        }

        [Fact]
        public void GetInitScriptsJSEncodesParameters()
        {
            // Arrange
            var expectedText = @"
                <div id=""fb-root""></div>
                <script type=""text/javascript"">
                    window.fbAsyncInit = function () {
                        FB.init({ appId: 'MyApp\u0027', status: true, cookie: true, xfbml: true });
                    };
                    (function () {
                        var e = document.createElement('script'); e.async = true;
                        e.src = document.location.protocol +
                        '//connect.facebook.net/French/all.js';
                        document.getElementById('fb-root').appendChild(e);
                    } ());

                    function loginRedirect(url) { window.location = url; }
                </script>
            ";

            // Act
            var actualText = Facebook.GetInitializationScripts();

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void LoginButtonTest()
        {
            // Arrange
            var expected40 = @"<fb:login-button autologoutlink=""True"" size=""extra-small"" length=""extra-long"" onlogin=""loginRedirect(&#39;http://www.test.com/facebook/?registerUrl=http%3a%2f%2fwww.test.com%2f&amp;returnUrl=http%3a%2f%2fww.test.com%2fLogin.cshtml&#39;)"" show-faces=""True"" perms=""email,none&quot;"">Awesome &quot;button text&quot;</fb:login-button>";
            var expected45 = @"<fb:login-button autologoutlink=""True"" size=""extra-small"" length=""extra-long"" onlogin=""loginRedirect(&#39;http://www.test.com/facebook/?registerUrl=http%3a%2f%2fwww.test.com%2f\u0026returnUrl=http%3a%2f%2fww.test.com%2fLogin.cshtml&#39;)"" show-faces=""True"" perms=""email,none&quot;"">Awesome &quot;button text&quot;</fb:login-button>";

            // Act
            var actualText = Facebook.LoginButton("http://www.test.com", "http://ww.test.com/Login.cshtml", "http://www.test.com/facebook/", "Awesome \"button text\"", true, "extra-small", "extra-long", true, "none\"");

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(RuntimeEnvironment.IsVersion45Installed ? expected45 : expected40, actualText.ToString());
        }

        [Fact]
        public void LoginButtonOnlyTagTest()
        {
            // Arrange
            var expectedText = @"<fb:login-button autologoutlink=""True"" size=""small"" length=""medium"" onlogin=""foobar();"" show-faces=""True"" perms=""none&quot;"">&quot;Awesome button text&quot;</fb:login-button>";

            // Act
            var actualText = Facebook.LoginButtonTagOnly("\"Awesome button text\"", true, "small", "medium", "foobar();", true, "none\"");

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void LikeButtonTest()
        {
            // Arrange
            var expectedText = @"<iframe src=""http://www.facebook.com/plugins/like.php?href=http%3a%2f%2fsomewebsite&amp;layout=modern&amp;show_faces=false&amp;width=300&amp;action=hop&amp;colorscheme=lighter&amp;height=30&amp;font=Comic+Sans&amp;locale=French&amp;ref=foo+bar"" scrolling=""no"" frameborder=""0"" style=""border:none; overflow:hidden; width:300px; height:30px;"" allowTransparency=""true""></iframe>";

            // Act
            var actualText = Facebook.LikeButton("http://somewebsite", "modern", false, 300, 30, "hop", "Comic Sans", "lighter", "foo bar");

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void CommentsWithNoXidTest()
        {
            // Arrange
            var expectedText = @"<fb:comments numposts=""3"" width=""300"" reverse=""true"" simple=""true"" ></fb:comments>";

            // Act
            var actualText = Facebook.Comments(null, 300, 3, true, true);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void CommentsWithXidTest()
        {
            // Arrange
            var expectedText = @"<fb:comments xid=""bar"" numposts=""3"" width=""300"" reverse=""true"" simple=""true"" ></fb:comments>";

            // Act
            var actualText = Facebook.Comments("bar", 300, 3, true, true);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void RecommendationsTest()
        {
            // Arrange
            var expectedText = @"<iframe src=""http://www.facebook.com/plugins/recommendations.php?site=http%3a%2f%2fsomesite&amp;width=100&amp;height=200&amp;header=False&amp;colorscheme=blue&amp;font=none&amp;border_color=black&amp;filter=All+posts&amp;ref=ref+label&amp;locale=french"" scrolling=""no"" frameborder=""0"" style=""border:none; overflow:hidden; width:100px; height:200px;"" allowTransparency=""true""></iframe>";

            // Act
            var actualText = Facebook.Recommendations("http://somesite", 100, 200, false, "blue", "none", "black", "All posts", "ref label");

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void LikeBoxTest()
        {
            // Arrange
            var expectedText = @"<iframe src=""http://www.facebook.com/plugins/likebox.php?href=http%3a%2f%2fsomesite&amp;width=100&amp;height=200&amp;header=False&amp;colorscheme=blue&amp;connections=5&amp;stream=True&amp;header=False&amp;locale=french"" scrolling=""no"" frameborder=""0"" style=""border:none; overflow:hidden; width:100px; height:200px;"" allowTransparency=""true""></iframe>";

            // Act
            var actualText = Facebook.LikeBox("http://somesite", 100, 200, "blue", 5, true, false);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void FacepileTest()
        {
            // Arrange
            var expectedText = @"<fb:facepile max-rows=""3"" width=""100""></fb:facepile>";

            // Act
            var actualText = Facebook.Facepile(3, 100);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void LiveStreamWithEmptyXidTest()
        {
            // Arrange
            var expectedText = @"<iframe src=""http://www.facebook.com/plugins/live_stream_box.php?app_id=myapp%27&amp;width=100&amp;height=100&amp;always_post_to_friends=True&amp;locale=french"" scrolling=""no"" frameborder=""0"" style=""border:none; overflow:hidden; width:100px; height:100px;"" allowTransparency=""true""></iframe>";

            // Act
            var actualText = Facebook.LiveStream(100, 100, "", "", true);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void LiveStreamWithXidValueTest()
        {
            // Arrange
            var expectedText = @"<iframe src=""http://www.facebook.com/plugins/live_stream_box.php?app_id=myapp%27&amp;width=100&amp;height=100&amp;always_post_to_friends=True&amp;locale=french&amp;xid=some-val&amp;via_url=http%3a%2f%2fmysite"" scrolling=""no"" frameborder=""0"" style=""border:none; overflow:hidden; width:100px; height:100px;"" allowTransparency=""true""></iframe>";

            // Act
            var actualText = Facebook.LiveStream(100, 100, "some-val", "http://mysite", true);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void ActivityStreamTest()
        {
            // Arrange
            var expectedText = @"<iframe src=""http://www.facebook.com/plugins/activity.php?site=http%3a%2f%2fmysite&amp;width=100&amp;height=120&amp;header=False&amp;colorscheme=gray&amp;font=Arial&amp;border_color=blue&amp;recommendations=True&amp;locale=french"" scrolling=""no"" frameborder=""0"" style=""border:none; overflow:hidden; width:300px; height:300px;"" allowTransparency=""true""></iframe>";

            // Act
            var actualText = Facebook.ActivityFeed("http://mysite", 100, 120, false, "gray", "Arial", "blue", true);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedText, actualText.ToString());
        }

        [Fact]
        public void FbmlNamespacesTest()
        {
            // Arrange
            var expectedText = @"xmlns:fb=""http://www.facebook.com/2008/fbml"" xmlns:og=""http://opengraphprotocol.org/schema/""";

            // Act
            var actualText = Facebook.FbmlNamespaces();

            // Assert
            Assert.Equal(expectedText, actualText.ToString());
        }

        private static HttpContextBase CreateHttpContext(IDictionary<string, string> cookieValues = null)
        {
            var context = new Mock<HttpContextBase>();
            var httpRequest = new Mock<HttpRequestBase>();
            var cookies = new HttpCookieCollection();
            httpRequest.Setup(c => c.Cookies).Returns(cookies);

            context.Setup(c => c.Request).Returns(httpRequest.Object);

            if (cookieValues != null)
            {
                foreach (var item in cookieValues)
                {
                    cookies.Add(new HttpCookie(item.Key, item.Value));
                }
            }

            return context.Object;
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. Facebook.AppId) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/FileUploadTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Web;
using System.Web.Helpers.Test;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Helpers.Test
{
    public class FileUploadTest
    {
        private const string _fileUploadScript = "<script type=\"text/javascript\"> if (!window[\"FileUploadHelper\"]) window[\"FileUploadHelper\"] = {};  FileUploadHelper.addInputElement = function(index, name) {  var inputElem = document.createElement(\"input\");  inputElem.type = \"file\";  inputElem.name = name;  var divElem = document.createElement(\"div\");  divElem.appendChild(inputElem.cloneNode(false));   var inputs = document.getElementById(\"file-upload-\" + index);  inputs.appendChild(divElem);  } </script>";

        [Fact]
        public void RenderThrowsWhenNumberOfFilesIsLessThanZero()
        {
            // Act and Assert
            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => FileUpload._GetHtml(GetContext(), name: null, initialNumberOfFiles: -2, allowMoreFilesToBeAdded: false, includeFormTag: false, addText: "", uploadText: "").ToString(),
                "initialNumberOfFiles", "0");
        }

        [Fact]
        public void ResultIncludesFormTagAndSubmitButtonWhenRequested()
        {
            // Arrange
            string expectedResult = @"<form action="""" enctype=""multipart/form-data"" method=""post""><div class=""file-upload"" id=""file-upload-0"">"
                                    + @"<div><input name=""fileUpload"" type=""file"" /></div></div>"
                                    + @"<div class=""file-upload-buttons""><input type=""submit"" value=""Upload"" /></div></form>";

            // Act
            var actualResult = FileUpload._GetHtml(GetContext(), name: null, initialNumberOfFiles: 1, allowMoreFilesToBeAdded: false, includeFormTag: true, addText: null, uploadText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult, actualResult.ToString());
        }

        [Fact]
        public void ResultDoesNotIncludeFormTagAndSubmitButtonWhenNotRequested()
        {
            // Arrange
            string expectedResult = @"<div class=""file-upload"" id=""file-upload-0""><div><input name=""fileUpload"" type=""file"" /></div></div>";

            // Act 
            var actualResult = FileUpload._GetHtml(GetContext(), name: null, initialNumberOfFiles: 1, allowMoreFilesToBeAdded: false, includeFormTag: false, addText: null, uploadText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult, actualResult.ToString());
        }

        [Fact]
        public void ResultIncludesCorrectNumberOfInputFields()
        {
            // Arrange
            string expectedResult = @"<div class=""file-upload"" id=""file-upload-0""><div><input name=""fileUpload"" type=""file"" /></div><div><input name=""fileUpload"" type=""file"" /></div>"
                                    + @"<div><input name=""fileUpload"" type=""file"" /></div></div>";

            // Act
            var actualResult = FileUpload._GetHtml(GetContext(), name: null, initialNumberOfFiles: 3, allowMoreFilesToBeAdded: false, includeFormTag: false, addText: null, uploadText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult, actualResult.ToString());
        }

        [Fact]
        public void ResultIncludesAnchorTagWithCorrectAddText()
        {
            // Arrange
            string customAddText = "Add More";
            string expectedResult = _fileUploadScript
                                    + @"<div class=""file-upload"" id=""file-upload-0""><div><input name=""fileUpload"" type=""file"" /></div></div>"
                                    + @"<div class=""file-upload-buttons""><a href=""#"" onclick=""FileUploadHelper.addInputElement(0, &quot;fileUpload&quot;); return false;"">" + customAddText + "</a></div>";

            // Act
            var result = FileUpload._GetHtml(GetContext(), name: null, allowMoreFilesToBeAdded: true, includeFormTag: false, addText: customAddText, initialNumberOfFiles: 1, uploadText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult, result.ToString());
        }

        [Fact]
        public void ResultDoesNotIncludeAnchorTagNorAddTextWhenNotRequested()
        {
            // Arrange
            string customAddText = "Add More";
            string expectedResult = @"<div class=""file-upload"" id=""file-upload-0""><div><input name=""fileUpload"" type=""file"" /></div></div>";

            // Act
            var result = FileUpload._GetHtml(GetContext(), name: null, allowMoreFilesToBeAdded: false, includeFormTag: false, addText: customAddText, uploadText: null, initialNumberOfFiles: 1);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult, result.ToString());
        }

        [Fact]
        public void ResultIncludesSubmitInputTagWithCustomUploadText()
        {
            // Arrange
            string customUploadText = "Now!";
            string expectedResult = @"<form action="""" enctype=""multipart/form-data"" method=""post""><div class=""file-upload"" id=""file-upload-0"">"
                                    + @"<div><input name=""fileUpload"" type=""file"" /></div></div>"
                                    + @"<div class=""file-upload-buttons""><input type=""submit"" value=""" + customUploadText + @""" /></div></form>";

            // Act
            var result = FileUpload._GetHtml(GetContext(), name: null, includeFormTag: true, uploadText: customUploadText, allowMoreFilesToBeAdded: false, initialNumberOfFiles: 1, addText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult, result.ToString());
        }

        [Fact]
        public void FileUploadGeneratesUniqueIdsForMultipleCallsForCommonRequest()
        {
            // Arrange
            var context = GetContext();
            string expectedResult1 = @"<div class=""file-upload"" id=""file-upload-0""><div><input name=""fileUpload"" type=""file"" /></div><div><input name=""fileUpload"" type=""file"" /></div>"
                                     + @"<div><input name=""fileUpload"" type=""file"" /></div></div>";
            string expectedResult2 = @"<form action="""" enctype=""multipart/form-data"" method=""post""><div class=""file-upload"" id=""file-upload-1""><div><input name=""fileUpload"" type=""file"" /></div>"
                                     + @"<div><input name=""fileUpload"" type=""file"" /></div></div><div class=""file-upload-buttons""><input type=""submit"" value=""Upload"" /></div></form>";

            // Act
            var result1 = FileUpload._GetHtml(context, name: null, initialNumberOfFiles: 3, allowMoreFilesToBeAdded: false, includeFormTag: false, addText: null, uploadText: null);
            var result2 = FileUpload._GetHtml(context, name: null, initialNumberOfFiles: 2, allowMoreFilesToBeAdded: false, includeFormTag: true, addText: null, uploadText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult1, result1.ToString());
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult2, result2.ToString());
        }

        [Fact]
        public void FileUploadGeneratesScriptOncePerRequest()
        {
            // Arrange
            var context = GetContext();
            string expectedResult1 = _fileUploadScript
                                     + @"<div class=""file-upload"" id=""file-upload-0""><div><input name=""fileUpload"" type=""file"" /></div></div>"
                                     + @"<div class=""file-upload-buttons""><a href=""#"" onclick=""FileUploadHelper.addInputElement(0, &quot;fileUpload&quot;); return false;"">Add more files</a></div>";
            string expectedResult2 = @"<form action="""" enctype=""multipart/form-data"" method=""post""><div class=""file-upload"" id=""file-upload-1""><div><input name=""fileUpload"" type=""file"" /></div></div>"
                                     + @"<div class=""file-upload-buttons""><a href=""#"" onclick=""FileUploadHelper.addInputElement(1, &quot;fileUpload&quot;); return false;"">Add more files</a><input type=""submit"" value=""Upload"" /></div></form>";
            string expectedResult3 = @"<form action="""" enctype=""multipart/form-data"" method=""post""><div class=""file-upload"" id=""file-upload-2"">"
                                     + @"<div><input name=""fileUpload"" type=""file"" /></div></div>"
                                     + @"<div class=""file-upload-buttons""><input type=""submit"" value=""Upload"" /></div></form>";

            // Act
            var result1 = FileUpload._GetHtml(context, name: null, initialNumberOfFiles: 1, allowMoreFilesToBeAdded: true, includeFormTag: false, addText: null, uploadText: null);
            var result2 = FileUpload._GetHtml(context, name: null, initialNumberOfFiles: 1, allowMoreFilesToBeAdded: true, includeFormTag: true, addText: null, uploadText: null);
            var result3 = FileUpload._GetHtml(context, name: null, initialNumberOfFiles: 1, allowMoreFilesToBeAdded: false, includeFormTag: true, addText: null, uploadText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult1, result1.ToString());
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult2, result2.ToString());
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult3, result3.ToString());
        }

        [Fact]
        public void FileUploadUsesNamePropertyInJavascript()
        {
            // Arrange
            var context = GetContext();
            string name = "foobar";
            string expectedResult = _fileUploadScript
                                    + @"<form action="""" enctype=""multipart/form-data"" method=""post""><div class=""file-upload"" id=""file-upload-0""><div><input name=""foobar"" type=""file"" /></div></div>"
                                    + @"<div class=""file-upload-buttons""><a href=""#"" onclick=""FileUploadHelper.addInputElement(0, &quot;foobar&quot;); return false;"">Add more files</a><input type=""submit"" value=""Upload"" /></div></form>";

            // Act
            var result = FileUpload._GetHtml(context, name: name, initialNumberOfFiles: 1, allowMoreFilesToBeAdded: true, includeFormTag: true, addText: null, uploadText: null);

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedResult, result.ToString());
        }

        [Fact]
        public void _GetHtmlWithDefaultArgumentsProducesValidXhtml()
        {
            // Act 
            var result = FileUpload._GetHtml(GetContext(), name: null, initialNumberOfFiles: 1, includeFormTag: false, allowMoreFilesToBeAdded: false, addText: null, uploadText: null);

            // Assert
            XhtmlAssert.Validate1_1(result, "div");
        }

        [Fact]
        public void _GetHtmlWithoutFormTagProducesValidXhtml()
        {
            // Act
            var result = FileUpload._GetHtml(GetContext(), name: null, includeFormTag: false, initialNumberOfFiles: 1, allowMoreFilesToBeAdded: false, addText: null, uploadText: null);

            XhtmlAssert.Validate1_1(result, "div");
        }

        private HttpContextBase GetContext()
        {
            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Items).Returns(new Hashtable());
            return context.Object;
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/GamerCardTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Helpers.Test;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace Microsoft.Web.Helpers.Test
{
    public class GamerCardTest
    {
        [Fact]
        public void RenderThrowsWhenGamertagIsEmpty()
        {
            // Act & Assert 
            Assert.ThrowsArgumentNullOrEmptyString(() => { GamerCard.GetHtml(String.Empty).ToString(); }, "gamerTag");
        }

        [Fact]
        public void RenderThrowsWhenGamertagIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => { GamerCard.GetHtml(null).ToString(); }, "gamerTag");
        }

        [Fact]
        public void RenderGeneratesProperMarkupWithSimpleGamertag()
        {
            // Arrange 
            string expectedHtml = "<iframe frameborder=\"0\" height=\"140\" scrolling=\"no\" src=\"http://gamercard.xbox.com/osbornm.card\" width=\"204\">osbornm</iframe>";

            // Act
            string html = GamerCard.GetHtml("osbornm").ToHtmlString();

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedHtml, html);
        }

        [Fact]
        public void RenderGeneratesProperMarkupWithComplexGamertag()
        {
            // Arrange 
            string expectedHtml = "<iframe frameborder=\"0\" height=\"140\" scrolling=\"no\" src=\"http://gamercard.xbox.com/matthew%20osborn&#39;s.card\" width=\"204\">matthew osborn&#39;s</iframe>";

            // Act
            string html = GamerCard.GetHtml("matthew osborn's").ToHtmlString();

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedHtml, html);
        }

        [Fact]
        public void RenderGeneratesValidXhtml()
        {
            XhtmlAssert.Validate1_0(
                GamerCard.GetHtml("osbornm")
                );
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/GravatarTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Helpers.Test;
using Microsoft.TestCommon;

namespace Microsoft.Web.Helpers.Test
{
    public class GravatarTest
    {
        [Fact]
        public void GetUrlDefaults()
        {
            string url = Gravatar.GetUrl("foo@bar.com");
            Assert.Equal("http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80", url);
        }

        [Fact]
        public void RenderEncodesDefaultImageUrl()
        {
            string render = Gravatar.GetHtml("foo@bar.com", defaultImage: "http://example.com/images/example.jpg").ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80&amp;d=http%3a%2f%2fexample.com%2fimages%2fexample.jpg\" alt=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RenderLowerCasesEmail()
        {
            string render = Gravatar.GetHtml("FOO@BAR.COM").ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80\" alt=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RendersValidXhtml()
        {
            XhtmlAssert.Validate1_1(Gravatar.GetHtml("foo@bar.com"));
        }

        [Fact]
        public void RenderThrowsWhenEmailIsEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Gravatar.GetHtml(String.Empty); }, "email");
        }

        [Fact]
        public void RenderThrowsWhenEmailIsNull()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Gravatar.GetHtml(null); }, "email");
        }

        [Fact]
        public void RenderThrowsWhenImageSizeIsLessThanZero()
        {
            Assert.ThrowsArgument(() => { Gravatar.GetHtml("foo@bar.com", imageSize: -1); }, "imageSize", "The Gravatar image size must be between 1 and 512 pixels.");
        }

        [Fact]
        public void RenderThrowsWhenImageSizeIsZero()
        {
            Assert.ThrowsArgument(() => { Gravatar.GetHtml("foo@bar.com", imageSize: 0); }, "imageSize", "The Gravatar image size must be between 1 and 512 pixels.");
        }

        [Fact]
        public void RenderThrowsWhenImageSizeIsGreaterThan512()
        {
            Assert.ThrowsArgument(() => { Gravatar.GetHtml("foo@bar.com", imageSize: 513); }, "imageSize", "The Gravatar image size must be between 1 and 512 pixels.");
        }

        [Fact]
        public void RenderTrimsEmail()
        {
            string render = Gravatar.GetHtml(" \t foo@bar.com\t\r\n").ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80\" alt=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RenderUsesDefaultImage()
        {
            string render = Gravatar.GetHtml("foo@bar.com", defaultImage: "wavatar").ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80&amp;d=wavatar\" alt=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RenderUsesImageSize()
        {
            string render = Gravatar.GetHtml("foo@bar.com", imageSize: 512).ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=512\" alt=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RenderUsesRating()
        {
            string render = Gravatar.GetHtml("foo@bar.com", rating: GravatarRating.G).ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80&amp;r=g\" alt=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RenderWithAttributes()
        {
            string render = Gravatar.GetHtml("foo@bar.com",
                                             attributes: new { id = "gravatar", alT = "<b>foo@bar.com</b>", srC = "ignored" }).ToString();
            // beware of attributes ordering in tests
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80\" alT=\"&lt;b>foo@bar.com&lt;/b>\" id=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RenderWithDefaults()
        {
            string render = Gravatar.GetHtml("foo@bar.com").ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8?s=80\" alt=\"gravatar\" />",
                render);
        }

        [Fact]
        public void RenderWithExtension()
        {
            string render = Gravatar.GetHtml("foo@bar.com", imageExtension: ".png").ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8.png?s=80\" alt=\"gravatar\" />",
                render);

            render = Gravatar.GetHtml("foo@bar.com", imageExtension: "xyz").ToString();
            Assert.Equal(
                "<img src=\"http://www.gravatar.com/avatar/f3ada405ce890b6f8204094deb12d8a8.xyz?s=80\" alt=\"gravatar\" />",
                render);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/LinkShareTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;
using System.Web;
using System.Web.Helpers.Test;
using System.Web.TestUtil;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;

namespace Microsoft.Web.Helpers.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class LinkShareTest : IDisposable
    {
        private static LinkShareSite[] _allLinkShareSites = new[]
        {
            LinkShareSite.Delicious, LinkShareSite.Digg,
            LinkShareSite.Facebook, LinkShareSite.Reddit, LinkShareSite.StumbleUpon, LinkShareSite.Twitter
        };

        [Fact]
        public void RenderWithFacebookFirst_ReturnsHtmlWithFacebookAndThenOthersTest()
        {
            string pageTitle = "page1";
            string pageLinkBack = "page link back";
            string twitterUserName = String.Empty;
            string twitterTag = String.Empty;
            string actual;
            actual = LinkShare.GetHtml(pageTitle, pageLinkBack, twitterUserName, twitterTag, LinkShareSite.Facebook, LinkShareSite.All).ToString();
            Assert.Contains("twitter.com", actual);
            int pos = actual.IndexOf("facebook.com");
            Assert.True(pos > 0);
            int pos2 = actual.IndexOf("reddit.com");
            Assert.True(pos2 > pos);
            pos2 = actual.IndexOf("digg.com");
            Assert.True(pos2 > pos);
        }

        [Fact]
        public void BitlyApiKeyThrowsWhenSetToNull()
        {
            Assert.ThrowsArgumentNull(() => LinkShare.BitlyApiKey = null, "value");
        }

        [Fact]
        public void BitlyApiKeyUsesScopeStorage()
        {
            // Arrange
            var value = "value";

            // Act
            LinkShare.BitlyApiKey = value;

            // Assert
            Assert.Equal(LinkShare.BitlyApiKey, value);
            Assert.Equal(ScopeStorage.CurrentScope[LinkShare._bitlyApiKey], value);
        }

        [Fact]
        public void BitlyLoginThrowsWhenSetToNull()
        {
            Assert.ThrowsArgumentNull(() => LinkShare.BitlyLogin = null, "value");
        }

        [Fact]
        public void BitlyLoginUsesScopeStorage()
        {
            // Arrange
            var value = "value";

            // Act
            LinkShare.BitlyLogin = value;

            // Assert
            Assert.Equal(LinkShare.BitlyLogin, value);
            Assert.Equal(ScopeStorage.CurrentScope[LinkShare._bitlyLogin], value);
        }

        [Fact]
        public void RenderWithNullPageTitle_ThrowsException()
        {
            Assert.ThrowsArgumentNullOrEmptyString(
                () => LinkShare.GetHtml(null).ToString(),
                "pageTitle");
        }

        [Fact]
        public void Render_WithFacebook_Works()
        {
            string actualHTML = LinkShare.GetHtml("page-title", "www.foo.com", linkSites: LinkShareSite.Facebook).ToString();
            string expectedHTML =
                "<a href=\"http://www.facebook.com/sharer.php?u=www.foo.com&amp;t=page-title\" target=\"_blank\" title=\"Share on Facebook\"><img alt=\"Share on Facebook\" src=\"http://facebook.com/favicon.ico\" style=\"border:0; height:16px; width:16px; margin:0 1px;\" title=\"Share on Facebook\" /></a>";
            UnitTestHelper.AssertEqualsIgnoreWhitespace(actualHTML, expectedHTML);
        }

        [Fact]
        public void Render_WithFacebookAndDigg_Works()
        {
            string actualHTML = LinkShare.GetHtml("page-title", "www.foo.com", linkSites: new[] { LinkShareSite.Facebook, LinkShareSite.Digg }).ToString();
            string expectedHTML =
                "<a href=\"http://www.facebook.com/sharer.php?u=www.foo.com&amp;t=page-title\" target=\"_blank\" title=\"Share on Facebook\"><img alt=\"Share on Facebook\" src=\"http://facebook.com/favicon.ico\" style=\"border:0; height:16px; width:16px; margin:0 1px;\" title=\"Share on Facebook\" /></a><a href=\"http://digg.com/submit?url=www.foo.com&amp;title=page-title\" target=\"_blank\" title=\"Digg!\"><img alt=\"Digg!\" src=\"http://digg.com/favicon.ico\" style=\"border:0; height:16px; width:16px; margin:0 1px;\" title=\"Digg!\" /></a>";
            UnitTestHelper.AssertEqualsIgnoreWhitespace(actualHTML, expectedHTML);
        }

        [Fact]
        public void Render_WithFacebook_RendersAnchorTitle()
        {
            string actualHTML = LinkShare.GetHtml("page-title", "www.foo.com", linkSites: LinkShareSite.Facebook).ToString();
            string expectedHtml = @"<a href=""http://www.facebook.com/sharer.php?u=www.foo.com&amp;t=page-title"" target=""_blank"" title=""Share on Facebook"">
                <img alt=""Share on Facebook"" src=""http://facebook.com/favicon.ico"" style=""border:0; height:16px; width:16px; margin:0 1px;"" title=""Share on Facebook"" />
                </a>";

            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedHtml, actualHTML);
        }

        [Fact]
        public void LinkShare_GetSitesInOrderReturnsAllSitesWhenArgumentIsNull()
        {
            // Act and Assert
            var result = LinkShare.GetSitesInOrder(linkSites: null);

            Assert.Equal(_allLinkShareSites, result.ToArray());
        }

        [Fact]
        public void LinkShare_GetSitesInOrderReturnsAllSitesWhenArgumentIEmpty()
        {
            // Act
            var result = LinkShare.GetSitesInOrder(linkSites: new LinkShareSite[] { });

            // Assert
            Assert.Equal(_allLinkShareSites, result.ToArray());
        }

        [Fact]
        public void LinkShare_GetSitesInOrderDoesNotReturnsGoogleBuzzForAll() {
            // Act
            var result = LinkShare.GetSitesInOrder(linkSites: new LinkShareSite[] { LinkShareSite.All });

            // Assert
            // 2 is the deprecated value for GoogleBuzz
            Assert.DoesNotContain(((LinkShareSite)2), result.ToArray());
        }

        [Fact]
        public void LinkShare_GetSitesInOrderReturnsAllSitesWhenAllIsFirstItem()
        {
            // Act
            var result = LinkShare.GetSitesInOrder(linkSites: new[] { LinkShareSite.All, LinkShareSite.Reddit });

            // Assert
            Assert.Equal(_allLinkShareSites, result.ToArray());
        }

        [Fact]
        public void LinkShare_GetSitesInOrderReturnsSitesInOrderWhenAllIsNotFirstItem()
        {
            // Act
            var result = LinkShare.GetSitesInOrder(linkSites: new[] { LinkShareSite.Reddit, LinkShareSite.Facebook, LinkShareSite.All });

            // Assert
            Assert.Equal(new[]
            {
                LinkShareSite.Reddit, LinkShareSite.Facebook, LinkShareSite.Delicious, LinkShareSite.Digg, LinkShareSite.StumbleUpon, LinkShareSite.Twitter
            }, result.ToArray());
        }

        [Fact]
        public void LinkShare_EncodesParameters()
        {
            // Arrange
            var expectedHtml =
                @"<a href=""http://reddit.com/submit?url=www.foo.com&amp;title=%26%26"" target=""_blank"" title=""Reddit!"">
                    <img alt=""Reddit!"" src=""http://www.Reddit.com/favicon.ico"" style=""border:0; height:16px; width:16px; margin:0 1px;"" title=""Reddit!"" />
                </a>
                <a href=""http://twitter.com/home/?status=%26%26%3a+www.foo.com%2c+(via+%40%40%3cTweeter+Bot%3e)+I+%3c3+Tweets"" target=""_blank"" title=""Share on Twitter"">
                    <img alt=""Share on Twitter"" src=""http://twitter.com/favicon.ico"" style=""border:0; height:16px; width:16px; margin:0 1px;"" title=""Share on Twitter"" />
                </a>";

            // Act
            var actualHtml = LinkShare.GetHtml("&&", "www.foo.com", "<Tweeter Bot>", "I <3 Tweets", LinkShareSite.Reddit, LinkShareSite.Twitter).ToString();

            // Assert
            UnitTestHelper.AssertEqualsIgnoreWhitespace(expectedHtml, actualHtml);
        }

        [Fact]
        public void LinkshareRendersValidXhtml()
        {
            string result = "<html> <head> \n <title> </title> \n </head> \n <body> <div> \n" +
                            LinkShare.GetHtml("any<>title", "my test page <>") +
                            "\n </div> </body> \n </html>";
            HtmlString htmlResult = new HtmlString(result);
            XhtmlAssert.Validate1_0(htmlResult);
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. LinkShare.BitlyApiKey) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/MapsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Linq;
using System.Web;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Helpers.Test
{
    public class MapsTest
    {
        [Fact]
        public void GetDirectionsQueryReturnsLocationIfNotEmpty()
        {
            // Arrange
            var location = "a%";
            var latitude = "12.34";
            var longitude = "-56.78";

            // Act
            string result = Maps.GetDirectionsQuery(location, latitude, longitude);

            // Assert
            Assert.Equal("a%25", result);
        }

        [Fact]
        public void GetDirectionsQueryReturnsLatitudeLongitudeIfLocationIsEmpty()
        {
            // Arrange
            var location = "";
            var latitude = "12.34%";
            var longitude = "-&56.78";

            // Act
            string result = Maps.GetDirectionsQuery(location, latitude, longitude);

            // Assert
            Assert.Equal("12.34%25%2c-%2656.78", result);
        }

        [Fact]
        public void GetDirectionsQueryUsesSpecifiedEncoder()
        {
            // Arrange
            var location = "24 gnidliuB tfosorciM";
            var latitude = "12.34%";
            var longitude = "-&56.78";
            Func<string, string> encoder = k => new String(k.Reverse().ToArray());

            // Act
            string result = Maps.GetDirectionsQuery(location, latitude, longitude, encoder);

            // Assert
            Assert.Equal("Microsoft Building 42", result);
        }

        [Fact]
        public void GetProviderHtml_DoesNotContainBadRazorCompilation()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Arrange
                var stubbedContext = new Mock<HttpContextBase>();
                var contextItems = new Hashtable();
                stubbedContext.SetupGet(x => x.Items).Returns(contextItems);
                Maps.GetCurrentHttpContext = () => stubbedContext.Object;

                // Act
                string bingResults = Maps.GetBingHtml("somekey", latitude: "100", longitude: "10").ToHtmlString();
                string googleResults = Maps.GetGoogleHtml(latitude: "100", longitude: "10").ToHtmlString();
                string mapQuestResults = Maps.GetMapQuestHtml("somekey", latitude: "100", longitude: "10").ToHtmlString();

                // Assert
                Assert.DoesNotContain("<text>", bingResults);
                Assert.DoesNotContain("<text>", googleResults);
                Assert.DoesNotContain("<text>", mapQuestResults);
            });
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/Microsoft.Web.Helpers.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{2C653A66-8159-4A41-954F-A67915DFDA87}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.Web.Helpers.Test</RootNamespace>
    <AssemblyName>Microsoft.Web.Helpers.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Web" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AnalyticsTest.cs" />
    <Compile Include="FacebookTest.cs" />
    <Compile Include="FileUploadTest.cs" />
    <Compile Include="GamerCardTest.cs" />
    <Compile Include="GravatarTest.cs" />
    <Compile Include="LinkShareTest.cs" />
    <Compile Include="MapsTest.cs" />
    <Compile Include="PreAppStartCodeTest.cs" />
    <Compile Include="ThemesTest.cs" />
    <Compile Include="VideoTest.cs" />
    <Compile Include="ReCaptchaTest.cs" />
    <Compile Include="UrlBuilderTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\Microsoft.Web.Helpers\Microsoft.Web.Helpers.csproj">
      <Project>{0C7CE809-0F72-4C19-8C64-D6573E4D9521}</Project>
      <Name>Microsoft.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9B7E3740-6161-4548-833C-4BBCA43B970E}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Helpers.Test\System.Web.Helpers.Test.csproj">
      <Project>{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}</Project>
      <Name>System.Web.Helpers.Test</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/Microsoft.Web.Helpers.Test/PreAppStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.WebPages.Razor;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace Microsoft.Web.Helpers.Test
{
    public class PreApplicationStartCodeTest
    {
        [Fact]
        public void StartTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Act
                AppDomainUtils.SetPreAppStartStage();
                PreApplicationStartCode.Start();

                // Assert
                var imports = WebPageRazorHost.GetGlobalImports();
                Assert.Contains(imports, ns => ns.Equals("Microsoft.Web.Helpers"));
            });
        }

        [Fact]
        public void TestPreAppStartClass()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/ReCaptchaTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web;
using System.Web.Helpers.Test;
using System.Web.TestUtil;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Helpers.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ReCaptchaTest : IDisposable
    {
        [Fact]
        public void ReCaptchaOptionsMissingWhenNoOptionsAndDefaultRendering()
        {
            var html = ReCaptcha.GetHtml(GetContext(), "PUBLIC_KEY");
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                @"<script src=""http://www.google.com/recaptcha/api/challenge?k=PUBLIC_KEY"" type=""text/javascript""></script>" +
                @"<noscript>" +
                @"<iframe frameborder=""0"" height=""300px"" src=""http://www.google.com/recaptcha/api/noscript?k=PUBLIC_KEY"" width=""500px""></iframe><br/><br/>" +
                @"<textarea cols=""40"" name=""recaptcha_challenge_field"" rows=""3""></textarea>" +
                @"<input name=""recaptcha_response_field"" type=""hidden"" value=""manual_challenge""/>" +
                @"</noscript>",
                html.ToString());
            XhtmlAssert.Validate1_0(html, addRoot: true);
        }

        [Fact]
        public void ReCaptchaOptionsWhenOneOptionAndDefaultRendering()
        {
            var html = ReCaptcha.GetHtml(GetContext(), "PUBLIC_KEY", options: new { theme = "white" });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                @"<script type=""text/javascript"">var RecaptchaOptions={""theme"":""white""};</script>" +
                @"<script src=""http://www.google.com/recaptcha/api/challenge?k=PUBLIC_KEY"" type=""text/javascript""></script>" +
                @"<noscript>" +
                @"<iframe frameborder=""0"" height=""300px"" src=""http://www.google.com/recaptcha/api/noscript?k=PUBLIC_KEY"" width=""500px""></iframe><br/><br/>" +
                @"<textarea cols=""40"" name=""recaptcha_challenge_field"" rows=""3""></textarea>" +
                @"<input name=""recaptcha_response_field"" type=""hidden"" value=""manual_challenge""/>" +
                @"</noscript>",
                html.ToString());
            XhtmlAssert.Validate1_0(html, addRoot: true);
        }

        [Fact]
        public void ReCaptchaOptionsWhenMultipleOptionsAndDefaultRendering()
        {
            var html = ReCaptcha.GetHtml(GetContext(), "PUBLIC_KEY", options: new { theme = "white", tabindex = 5 });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                @"<script type=""text/javascript"">var RecaptchaOptions={""theme"":""white"",""tabindex"":5};</script>" +
                @"<script src=""http://www.google.com/recaptcha/api/challenge?k=PUBLIC_KEY"" type=""text/javascript""></script>" +
                @"<noscript>" +
                @"<iframe frameborder=""0"" height=""300px"" src=""http://www.google.com/recaptcha/api/noscript?k=PUBLIC_KEY"" width=""500px""></iframe><br/><br/>" +
                @"<textarea cols=""40"" name=""recaptcha_challenge_field"" rows=""3""></textarea>" +
                @"<input name=""recaptcha_response_field"" type=""hidden"" value=""manual_challenge""/>" +
                @"</noscript>",
                html.ToString());
            XhtmlAssert.Validate1_0(html, addRoot: true);
        }

        [Fact]
        public void ReCaptchaOptionsWhenMultipleOptionsFromDictionaryAndDefaultRendering()
        {
            // verifies that a dictionary will serialize the same as a projection
            var options = new Dictionary<string, object> { { "theme", "white" }, { "tabindex", 5 } };
            var html = ReCaptcha.GetHtml(GetContext(), "PUBLIC_KEY", options: options);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                @"<script type=""text/javascript"">var RecaptchaOptions={""theme"":""white"",""tabindex"":5};</script>" +
                @"<script src=""http://www.google.com/recaptcha/api/challenge?k=PUBLIC_KEY"" type=""text/javascript""></script>" +
                @"<noscript>" +
                @"<iframe frameborder=""0"" height=""300px"" src=""http://www.google.com/recaptcha/api/noscript?k=PUBLIC_KEY"" width=""500px""></iframe><br/><br/>" +
                @"<textarea cols=""40"" name=""recaptcha_challenge_field"" rows=""3""></textarea>" +
                @"<input name=""recaptcha_response_field"" type=""hidden"" value=""manual_challenge""/>" +
                @"</noscript>",
                html.ToString());
            XhtmlAssert.Validate1_0(html, addRoot: true);
        }

        [Fact]
        public void RenderUsesLastError()
        {
            HttpContextBase context = GetContext();
            ReCaptcha.HandleValidateResponse(context, "false\nincorrect-captcha-sol");
            var html = ReCaptcha.GetHtml(context, "PUBLIC_KEY");
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                @"<script src=""http://www.google.com/recaptcha/api/challenge?k=PUBLIC_KEY&amp;error=incorrect-captcha-sol"" type=""text/javascript""></script>" +
                @"<noscript>" +
                @"<iframe frameborder=""0"" height=""300px"" src=""http://www.google.com/recaptcha/api/noscript?k=PUBLIC_KEY"" width=""500px""></iframe><br/><br/>" +
                @"<textarea cols=""40"" name=""recaptcha_challenge_field"" rows=""3""></textarea>" +
                @"<input name=""recaptcha_response_field"" type=""hidden"" value=""manual_challenge""/>" +
                @"</noscript>",
                html.ToString());
            XhtmlAssert.Validate1_0(html, addRoot: true);
        }

        [Fact]
        public void RenderWhenConnectionIsSecure()
        {
            var html = ReCaptcha.GetHtml(GetContext(isSecure: true), "PUBLIC_KEY");
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                @"<script src=""https://www.google.com/recaptcha/api/challenge?k=PUBLIC_KEY"" type=""text/javascript""></script>" +
                @"<noscript>" +
                @"<iframe frameborder=""0"" height=""300px"" src=""https://www.google.com/recaptcha/api/noscript?k=PUBLIC_KEY"" width=""500px""></iframe><br/><br/>" +
                @"<textarea cols=""40"" name=""recaptcha_challenge_field"" rows=""3""></textarea>" +
                @"<input name=""recaptcha_response_field"" type=""hidden"" value=""manual_challenge""/>" +
                @"</noscript>",
                html.ToString());
            XhtmlAssert.Validate1_0(html, addRoot: true);
        }

        [Fact]
        public void ValidateThrowsWhenRemoteAddressNotAvailable()
        {
            HttpContextBase context = GetContext();
            VirtualPathUtilityBase virtualPathUtility = GetVirtualPathUtility();
            context.Request.Form["recaptcha_challenge_field"] = "CHALLENGE";
            context.Request.Form["recaptcha_response_field"] = "RESPONSE";

            Assert.Throws<InvalidOperationException>(() => { ReCaptcha.Validate(context, privateKey: "PRIVATE_KEY", virtualPathUtility: virtualPathUtility).ToString(); }, "The captcha cannot be validated because the remote address was not found in the request.");
        }

        [Fact]
        public void ValidateReturnsFalseWhenChallengeNotPosted()
        {
            HttpContextBase context = GetContext();
            VirtualPathUtilityBase virtualPathUtility = GetVirtualPathUtility();
            context.Request.ServerVariables["REMOTE_ADDR"] = "127.0.0.1";

            Assert.False(ReCaptcha.Validate(context, privateKey: "PRIVATE_KEY", virtualPathUtility: virtualPathUtility));
        }

        [Fact]
        public void ValidatePostData()
        {
            HttpContextBase context = GetContext();
            VirtualPathUtilityBase virtualPathUtility = GetVirtualPathUtility();
            context.Request.ServerVariables["REMOTE_ADDR"] = "127.0.0.1";
            context.Request.Form["recaptcha_challenge_field"] = "CHALLENGE";
            context.Request.Form["recaptcha_response_field"] = "RESPONSE";

            Assert.Equal("privatekey=PRIVATE_KEY&remoteip=127.0.0.1&challenge=CHALLENGE&response=RESPONSE",
                         ReCaptcha.GetValidatePostData(context, "PRIVATE_KEY", virtualPathUtility));
        }

        [Fact]
        public void ValidatePostDataWhenNoResponse()
        {
            // Arrange
            HttpContextBase context = GetContext();
            VirtualPathUtilityBase virtualPathUtility = GetVirtualPathUtility();
            context.Request.ServerVariables["REMOTE_ADDR"] = "127.0.0.1";
            context.Request.Form["recaptcha_challenge_field"] = "CHALLENGE";

            // Act
            var validatePostData = ReCaptcha.GetValidatePostData(context, "PRIVATE_KEY", virtualPathUtility);

            // Assert
            Assert.Equal("privatekey=PRIVATE_KEY&remoteip=127.0.0.1&challenge=CHALLENGE&response=", validatePostData);
        }

        [Fact]
        public void ValidateResponseReturnsFalseOnEmptyReCaptchaResponse()
        {
            HttpContextBase context = GetContext();
            Assert.False(ReCaptcha.HandleValidateResponse(context, ""));
            Assert.Equal(String.Empty, ReCaptcha.GetLastError(context));
        }

        [Fact]
        public void ValidateResponseReturnsTrueOnSuccess()
        {
            HttpContextBase context = GetContext();
            Assert.True(ReCaptcha.HandleValidateResponse(context, "true\nsuccess"));
            Assert.Equal(String.Empty, ReCaptcha.GetLastError(context));
        }

        [Fact]
        public void ValidateResponseReturnsFalseOnError()
        {
            HttpContextBase context = GetContext();
            Assert.False(ReCaptcha.HandleValidateResponse(context, "false\nincorrect-captcha-sol"));
            Assert.Equal("incorrect-captcha-sol", ReCaptcha.GetLastError(context));
        }

        [Fact]
        public void ReCaptchaPrivateKeyThowsWhenSetToNull()
        {
            Assert.ThrowsArgumentNull(() => ReCaptcha.PrivateKey = null, "value");
        }

        [Fact]
        public void ReCaptchaPrivateKeyUsesScopeStorage()
        {
            // Arrange
            var value = "value";

            // Act
            ReCaptcha.PrivateKey = value;

            // Assert
            Assert.Equal(ReCaptcha.PrivateKey, value);
            Assert.Equal(ScopeStorage.CurrentScope[ReCaptcha._privateKey], value);
        }

        [Fact]
        public void PublicKeyThowsWhenSetToNull()
        {
            Assert.ThrowsArgumentNull(() => ReCaptcha.PublicKey = null, "value");
        }

        [Fact]
        public void ReCaptchaPublicKeyUsesScopeStorage()
        {
            // Arrange
            var value = "value";

            // Act
            ReCaptcha.PublicKey = value;

            // Assert
            Assert.Equal(ReCaptcha.PublicKey, value);
            Assert.Equal(ScopeStorage.CurrentScope[ReCaptcha._publicKey], value);
        }

        private HttpContextBase GetContext(bool isSecure = false)
        {
            // mock HttpRequest
            Mock<HttpRequestBase> requestMock = new Mock<HttpRequestBase>();
            requestMock.Setup(request => request.IsSecureConnection).Returns(isSecure);
            requestMock.Setup(request => request.Form).Returns(new NameValueCollection());
            requestMock.Setup(request => request.ServerVariables).Returns(new NameValueCollection());

            // mock HttpContext
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(context => context.Items).Returns(new Hashtable());
            contextMock.Setup(context => context.Request).Returns(requestMock.Object);
            return contextMock.Object;
        }

        private static VirtualPathUtilityBase GetVirtualPathUtility()
        {
            var virtualPathUtility = new Mock<VirtualPathUtilityBase>();
            virtualPathUtility.Setup(c => c.ToAbsolute(It.IsAny<string>())).Returns<string>(_ => _);

            return virtualPathUtility.Object;
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ReCaptcha.PrivateKey) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/ThemesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Hosting;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Helpers.Test
{
    public class ThemesTest
    {
        [Fact]
        public void Initialize_WithBadParams_Throws()
        {
            // Arrange
            var mockVpp = new Mock<VirtualPathProvider>().Object;
            var scope = new ScopeStorageDictionary();

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => new ThemesImplementation(mockVpp, scope).Initialize(null, "foo"), "themeDirectory");
            Assert.ThrowsArgumentNullOrEmptyString(() => new ThemesImplementation(mockVpp, scope).Initialize("", "foo"), "themeDirectory");

            Assert.ThrowsArgumentNullOrEmptyString(() => new ThemesImplementation(mockVpp, scope).Initialize("~/folder", null), "defaultTheme");
            Assert.ThrowsArgumentNullOrEmptyString(() => new ThemesImplementation(mockVpp, scope).Initialize("~/folder", ""), "defaultTheme");
        }

        [Fact]
        public void CurrentThemeThrowsIfAssignedNullOrEmpty()
        {
            // Arrange
            var mockVpp = new Mock<VirtualPathProvider>().Object;
            var scope = new ScopeStorageDictionary();
            var themesImpl = new ThemesImplementation(mockVpp, scope);

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => { themesImpl.CurrentTheme = null; }, "value");
            Assert.ThrowsArgumentNullOrEmptyString(() => { themesImpl.CurrentTheme = String.Empty; }, "value");
        }

        [Fact]
        public void InvokingPropertiesAndMethodsBeforeInitializationThrows()
        {
            // Arrange
            var mockVpp = new Mock<VirtualPathProvider>().Object;
            var scope = new ScopeStorageDictionary();
            var themesImpl = new ThemesImplementation(mockVpp, scope);

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => themesImpl.CurrentTheme = "Foo",
                                                              @"You must call the ""Themes.Initialize"" method before you call any other method of the ""Themes"" class.");

            Assert.Throws<InvalidOperationException>(() => { var x = themesImpl.CurrentTheme; },
                                                              @"You must call the ""Themes.Initialize"" method before you call any other method of the ""Themes"" class.");

            Assert.Throws<InvalidOperationException>(() => { var x = themesImpl.AvailableThemes; },
                                                              @"You must call the ""Themes.Initialize"" method before you call any other method of the ""Themes"" class.");

            Assert.Throws<InvalidOperationException>(() => { var x = themesImpl.DefaultTheme; },
                                                              @"You must call the ""Themes.Initialize"" method before you call any other method of the ""Themes"" class.");

            Assert.Throws<InvalidOperationException>(() => { var x = themesImpl.GetResourcePath("baz"); },
                                                              @"You must call the ""Themes.Initialize"" method before you call any other method of the ""Themes"" class.");

            Assert.Throws<InvalidOperationException>(() => { var x = themesImpl.GetResourcePath("baz", "some-file"); },
                                                              @"You must call the ""Themes.Initialize"" method before you call any other method of the ""Themes"" class.");
        }

        [Fact]
        public void InitializeThrowsIfDefaultThemeDirectoryDoesNotExist()
        {
            // Arrange
            var defaultTheme = "default-theme";
            var themeDirectory = "theme-directory";

            var scope = new ScopeStorageDictionary();
            var themesImpl = new ThemesImplementation(GetVirtualPathProvider(themeDirectory, new Dir("not-default-theme")), scope);

            // Act And Assert
            Assert.ThrowsArgument(
                () => themesImpl.Initialize(themeDirectory: themeDirectory, defaultTheme: defaultTheme),
                "defaultTheme",
                "Unknown theme 'default-theme'. Ensure that a directory labeled 'default-theme' exists under the theme directory.");
        }

        [Fact]
        public void ThemesImplUsesScopeStorageToStoreProperties()
        {
            // Arrange
            var defaultTheme = "default-theme";
            var themeDirectory = "theme-directory";

            var scope = new ScopeStorageDictionary();
            var themesImpl = new ThemesImplementation(GetVirtualPathProvider(themeDirectory, new Dir(defaultTheme)), scope);

            // Act
            themesImpl.Initialize(themeDirectory: themeDirectory, defaultTheme: defaultTheme);

            // Ensure Theme use scope storage to store properties
            Assert.Equal((object)true, scope[ThemesImplementation.ThemesInitializedKey]);
            Assert.Equal(themeDirectory, scope[ThemesImplementation.ThemeDirectoryKey]);
            Assert.Equal(defaultTheme, scope[ThemesImplementation.DefaultThemeKey]);
        }

        [Fact]
        public void ThemesImplUsesDefaultThemeWhenNoCurrentThemeIsSpecified()
        {
            // Arrange
            var defaultTheme = "default-theme";
            var themeDirectory = "theme-directory";

            var scope = new ScopeStorageDictionary();
            var themesImpl = new ThemesImplementation(GetVirtualPathProvider(themeDirectory, new Dir(defaultTheme)), scope);
            themesImpl.Initialize(themeDirectory, defaultTheme);

            // Act and Assert
            // CurrentTheme falls back to default theme when null
            Assert.Equal(themesImpl.CurrentTheme, defaultTheme);
        }

        [Fact]
        public void ThemesImplThrowsIfCurrentThemeIsInvalid()
        {
            // Arrange
            var defaultTheme = "default-theme";
            var themeDirectory = "theme-directory";
            var themesImpl = new ThemesImplementation(GetVirtualPathProvider(themeDirectory, new Dir(defaultTheme), new Dir("not-a-random-value")), new ScopeStorageDictionary());
            themesImpl.Initialize(themeDirectory, defaultTheme);

            // Act and Assert
            Assert.ThrowsArgument(() => themesImpl.CurrentTheme = "random-value",
                                                    "value",
                                                    "Unknown theme 'random-value'. Ensure that a directory labeled 'random-value' exists under the theme directory.");
        }

        [Fact]
        public void ThemesImplUsesScopeStorageToStoreCurrentTheme()
        {
            // Arrange
            var defaultTheme = "default-theme";
            var themeDirectory = "theme-directory";
            var currentThemeDir = "custom-theme-dir";
            var scope = new ScopeStorageDictionary();
            var themesImpl = new ThemesImplementation(GetVirtualPathProvider(themeDirectory, new Dir(defaultTheme), new Dir("custom-theme-dir")), scope);

            // Act
            themesImpl.Initialize(themeDirectory, defaultTheme);
            themesImpl.CurrentTheme = currentThemeDir;

            // Assert
            Assert.Equal(scope[ThemesImplementation.CurrentThemeKey], currentThemeDir);
        }

        [Fact]
        public void GetResourcePathThrowsIfCurrentDirectoryIsNull()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir(@"mobile", "wp7.css")));
            themesImpl.Initialize("themes", "default");

            // Act and Assert
            Assert.ThrowsArgumentNull(() => themesImpl.GetResourcePath(folder: null, fileName: "wp7.css"), "folder");
        }

        [Fact]
        public void GetResourcePathThrowsIfFileNameIsNullOrEmpty()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir(@"mobile", "wp7.css")));
            themesImpl.Initialize("themes", "default");

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => themesImpl.GetResourcePath(folder: String.Empty, fileName: null), "fileName");
            Assert.ThrowsArgumentNullOrEmptyString(() => themesImpl.GetResourcePath(folder: String.Empty, fileName: String.Empty), "fileName");
        }

        [Fact]
        public void GetResourcePathReturnsItemFromThemeRootIfAvailable()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir(@"mobile", "wp7.css")));
            themesImpl.Initialize("themes", "default");

            // Act
            themesImpl.CurrentTheme = "mobile";
            var themePath = themesImpl.GetResourcePath(fileName: "wp7.css");

            // Assert
            Assert.Equal(@"themes/mobile/wp7.css", themePath);
        }

        [Fact]
        public void GetResourcePathReturnsItemFromCurrentThemeDirectoryIfAvailable()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir(@"mobile\styles", "wp7.css"), new Dir(@"default\styles", "main.css")));
            themesImpl.Initialize("themes", "default");

            // Act
            themesImpl.CurrentTheme = "mobile";
            var themePath = themesImpl.GetResourcePath(folder: "styles", fileName: "wp7.css");

            // Assert
            Assert.Equal(@"themes/mobile/styles/wp7.css", themePath);
        }

        [Fact]
        public void GetResourcePathReturnsItemFromDefaultThemeDirectoryIfNotFoundInCurrentThemeDirectory()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir(@"mobile\styles", "wp7.css"), new Dir(@"default\styles", "main.css")));
            themesImpl.Initialize("themes", "default");

            // Act
            themesImpl.CurrentTheme = "mobile";
            var themePath = themesImpl.GetResourcePath(folder: "styles", fileName: "main.css");

            // Assert
            Assert.Equal(@"themes/default/styles/main.css", themePath);
        }

        [Fact]
        public void GetResourcePathReturnsNullIfDirectoryDoesNotExist()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir(@"mobile\styles", "wp7.css"), new Dir(@"default\styles", "main.css")));
            themesImpl.Initialize("themes", "default");

            // Act
            themesImpl.CurrentTheme = "mobile";
            var themePath = themesImpl.GetResourcePath(folder: "does-not-exist", fileName: "main.css");

            // Assert
            Assert.Null(themePath);
        }

        [Fact]
        public void GetResourcePathReturnsNullIfItemNotFoundInCurrentAndDefaultThemeDirectories()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir(@"mobile\styles", "wp7.css"), new Dir(@"default\styles", "main.css")));
            themesImpl.Initialize("themes", "default");

            // Act
            themesImpl.CurrentTheme = "mobile";
            var themePath = themesImpl.GetResourcePath(folder: "styles", fileName: "awesome-blinking-text.css");

            // Assert
            Assert.Null(themePath);
        }

        [Fact]
        public void AvaliableThemesReturnsTopLevelDirectoriesUnderThemeDirectory()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("mobile"), new Dir("rotary-phone")));
            // Act
            themesImpl.Initialize("themes", "default");
            var themes = themesImpl.AvailableThemes;

            // Assert
            Assert.Equal(3, themes.Count);
            Assert.Equal("default", themes[0]);
            Assert.Equal("mobile", themes[1]);
            Assert.Equal("rotary-phone", themes[2]);
        }

        /// <remarks>
        /// // folder structure:
        /// // /root
        /// //   /foo
        /// //      /bar.cs
        /// // testing that a file specified as foo/bar in folder root will return null
        /// </remarks>
        [Fact]
        public void FileWithSlash_ReturnsNull()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("root"), new Dir(@"root\foo", "wp7.css"), new Dir(@"default\styles", "main.css")));

            // Act
            var actual = themesImpl.FindMatchingFile("root", "foo/bar.cs");

            // Assert
            Assert.Null(actual);
        }

        [Fact]
        public void DirectoryWithNoFilesReturnsNull()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir("default"), new Dir("empty-dir")));

            // Act
            var actual = themesImpl.FindMatchingFile(@"themes\empty-dir", "main.css");

            // Assert
            Assert.Null(actual);
        }

        [Fact]
        public void MatchingFiles_ReturnsCorrectFile()
        {
            // Arrange
            var themesImpl = new ThemesImplementation(scopeStorage: new ScopeStorageDictionary(),
                                                      vpp: GetVirtualPathProvider("themes", new Dir(@"nomatchingfiles", "foo.cs")));

            // Act
            var bar = themesImpl.FindMatchingFile(@"themes\nomatchingfiles", "bar.cs");
            var foo = themesImpl.FindMatchingFile(@"themes\nomatchingfiles", "foo.cs");

            // Assert
            Assert.Null(bar);
            Assert.Equal(@"themes/nomatchingfiles/foo.cs", foo);
        }

        private static VirtualPathProvider GetVirtualPathProvider(string themeRoot, params Dir[] fileSystem)
        {
            var mockVpp = new Mock<VirtualPathProvider>();
            var dirRoot = new Mock<VirtualDirectory>(themeRoot);

            var themeDirectories = new List<VirtualDirectory>();
            foreach (var directory in fileSystem)
            {
                var dir = new Mock<VirtualDirectory>(directory.Name);
                var directoryPath = themeRoot + '\\' + directory.Name;
                dir.SetupGet(d => d.Name).Returns(directory.Name);
                mockVpp.Setup(c => c.GetDirectory(It.Is<string>(p => p.Equals(directoryPath, StringComparison.OrdinalIgnoreCase)))).Returns(dir.Object);

                var fileList = new List<VirtualFile>();
                foreach (var item in directory.Files)
                {
                    var filePath = directoryPath + '\\' + item;
                    var file = new Mock<VirtualFile>(filePath);
                    file.SetupGet(f => f.Name).Returns(item);
                    fileList.Add(file.Object);
                }

                dir.SetupGet(c => c.Files).Returns(fileList);
                themeDirectories.Add(dir.Object);
            }

            dirRoot.SetupGet(c => c.Directories).Returns(themeDirectories);
            mockVpp.Setup(c => c.GetDirectory(themeRoot)).Returns(dirRoot.Object);

            return mockVpp.Object;
        }

        private class Dir
        {
            public Dir(string name, params string[] files)
            {
                Name = name;
                Files = files;
            }

            public string Name { get; private set; }

            public IEnumerable<string> Files { get; private set; }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/UrlBuilderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.IO;
using System.Reflection;
using System.Text;
using System.Web;
using System.Web.UI;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Helpers.Test
{
    public class UrlBuilderTest
    {
        private static TestVirtualPathUtility _virtualPathUtility = new TestVirtualPathUtility();

        [Fact]
        public void UrlBuilderUsesPathAsIsIfPathIsAValidUri()
        {
            // Arrange
            var pagePath = "http://www.test.com/page-path";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);

            // Assert
            Assert.Equal("http://www.test.com/page-path", builder.Path);
        }

        [Fact]
        public void UrlBuilderUsesQueryComponentsIfPathIsAValidUri()
        {
            // Arrange
            var pagePath = "http://www.test.com/page-path.vbhtml?param=value&baz=biz";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);

            // Assert
            Assert.Equal("http://www.test.com/page-path.vbhtml", builder.Path);
            Assert.Equal("?param=value&baz=biz", builder.QueryString);
        }

        [Fact]
        public void UrlBuilderUsesUsesObjectParameterAsQueryString()
        {
            // Arrange
            var pagePath = "http://www.test.com/page-path.vbhtml?param=value&baz=biz";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);

            // Assert
            Assert.Equal("http://www.test.com/page-path.vbhtml", builder.Path);
            Assert.Equal("?param=value&baz=biz", builder.QueryString);
        }

        [Fact]
        public void UrlBuilderAppendsObjectParametersToPathWithQueryString()
        {
            // Arrange
            var pagePath = "http://www.test.com/page-path.vbhtml?param=value&baz=biz";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, new { param2 = "param2val" });

            // Assert
            Assert.Equal("http://www.test.com/page-path.vbhtml", builder.Path);
            Assert.Equal("?param=value&baz=biz&param2=param2val", builder.QueryString);
        }

        [Fact]
        public void UrlBuilderWithVirtualPathUsesVirtualPathUtility()
        {
            // Arrange
            var pagePath = "~/page";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);

            // Assert
            Assert.Equal("page", builder.Path);
        }

        [Fact]
        public void UrlBuilderDoesNotResolvePathIfContextIsNull()
        {
            // Arrange
            var pagePath = "~/foo/bar";

            // Act
            var builder = new UrlBuilder(null, _virtualPathUtility, pagePath, null);

            // Assert
            Assert.Equal(pagePath, builder.Path);
        }

        [Fact]
        public void UrlBuilderSetsPathToNullIfContextIsNullAndPagePathIsNotSpecified()
        {
            // Act
            var builder = new UrlBuilder(null, null, null, null);

            // Assert
            Assert.Null(builder.Path);
            Assert.True(String.IsNullOrEmpty(builder.ToString()));
        }

        [Fact]
        public void UrlBuilderWithVirtualPathAppendsObjectAsQueryString()
        {
            // Arrange
            var pagePath = "~/page";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, new { Foo = "bar", baz = "qux" });

            // Assert
            Assert.Equal("page", builder.Path);
            Assert.Equal("?Foo=bar&baz=qux", builder.QueryString);
        }

        [Fact]
        public void UrlBuilderWithVirtualPathExtractsQueryStringParameterFromPath()
        {
            // Arrange
            var pagePath = "~/dir/page?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);

            // Assert
            Assert.Equal("dir/page", builder.Path);
            Assert.Equal("?someparam=value", builder.QueryString);
        }

        [Fact]
        public void UrlBuilderWithVirtualPathAndQueryStringAppendsObjectAsQueryStringParams()
        {
            // Arrange
            var pagePath = "~/dir/page?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, new { someotherparam = "value2" });

            // Assert
            Assert.Equal("dir/page", builder.Path);
            Assert.Equal("?someparam=value&someotherparam=value2", builder.QueryString);
        }

        [Fact]
        public void AddPathAddsPathPortionToRelativeUrl()
        {
            // Arrange
            var pagePath = "~/dir/page?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddPath("foo").AddPath("bar/baz");

            // Assert
            Assert.Equal("dir/page/foo/bar/baz", builder.Path);
            Assert.Equal("?someparam=value", builder.QueryString);
        }

        [Fact]
        public void AddPathEncodesPathParams()
        {
            // Arrange
            var pagePath = "~/dir/page?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddPath("foo bar").AddPath("baz biz", "qux");

            // Assert
            Assert.Equal("dir/page/foo%20bar/baz%20biz/qux", builder.Path);
        }

        [Fact]
        public void AddPathAddsPathPortionToAbsoluteUrl()
        {
            // Arrange
            var pagePath = "http://some-site/dir/page?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddPath("foo").AddPath("bar/baz");

            // Assert
            Assert.Equal("http://some-site/dir/page/foo/bar/baz", builder.Path);
            Assert.Equal("?someparam=value", builder.QueryString);
        }

        [Fact]
        public void AddPathWithParamsArrayAddsPathPortionToRelativeUrl()
        {
            // Arrange
            var pagePath = "~/dir/page/?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddPath("foo", "bar", "baz").AddPath("qux");

            // Assert
            Assert.Equal("dir/page/foo/bar/baz/qux", builder.Path);
            Assert.Equal("?someparam=value", builder.QueryString);
        }

        [Fact]
        public void AddPathEnsuresSlashesAreNotRepeated()
        {
            // Arrange
            var pagePath = "~/dir/page/";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddPath("foo").AddPath("/bar/").AddPath("/baz");

            // Assert
            Assert.Equal("dir/page/foo/bar/baz", builder.Path);
        }

        [Fact]
        public void AddPathWithParamsEnsuresSlashAreNotRepeated()
        {
            // Arrange
            var pagePath = "~/dir/page/";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddPath("foo", "/bar/", "/baz").AddPath("qux/");

            // Assert
            Assert.Equal("dir/page/foo/bar/baz/qux/", builder.Path);
        }

        [Fact]
        public void AddPathWithParamsArrayAddsPathPortionToAbsoluteUrl()
        {
            // Arrange
            var pagePath = "http://www.test.com/dir/page/?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddPath("foo", "bar", "baz").AddPath("qux");

            // Assert
            Assert.Equal("http://www.test.com/dir/page/foo/bar/baz/qux", builder.Path);
            Assert.Equal("?someparam=value", builder.QueryString);
        }

        [Fact]
        public void UrlBuilderEncodesParameters()
        {
            // Arrange
            var pagePath = "~/dir/page/?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, new { Λ = "λ" });
            builder.AddParam(new { π = "is not a lie" }).AddParam("Π", "maybe a lie");
            // Assert
            Assert.Equal("?someparam=value&%ce%9b=%ce%bb&%cf%80=is+not+a+lie&%ce%a0=maybe+a+lie", builder.QueryString);
        }

        [Fact]
        public void AddParamAddsParamToQueryString()
        {
            // Arrange
            var pagePath = "http://www.test.com/dir/page/?someparam=value";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddParam("foo", "bar");

            // Assert
            Assert.Equal("?someparam=value&foo=bar", builder.QueryString);
        }

        [Fact]
        public void AddParamAddsQuestionMarkToQueryStringIfFirstParam()
        {
            // Arrange
            var pagePath = "~/dir/page";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddParam("foo", "bar").AddParam(new { baz = "qux", biz = "quark" });

            // Assert
            Assert.Equal("?foo=bar&baz=qux&biz=quark", builder.QueryString);
        }

        [Fact]
        public void AddParamIgnoresParametersWithEmptyKey()
        {
            // Arrange
            var pagePath = "~/dir/page";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddParam("", "bar").AddParam(new { baz = "", biz = "quark" }).AddParam("qux", null).AddParam(null, "somevalue");

            // Assert
            Assert.Equal("?baz=&biz=quark&qux=", builder.QueryString);
        }

        [Fact]
        public void ToStringConcatsPathAndQueryString()
        {
            // Arrange
            var pagePath = "~/dir/page";

            // Act
            var builder = new UrlBuilder(GetContext(), _virtualPathUtility, pagePath, null);
            builder.AddParam("foo", "bar").AddParam(new { baz = "qux", biz = "quark" });

            // Assert
            Assert.Equal("dir/page?foo=bar&baz=qux&biz=quark", builder.ToString());
        }

        [Fact]
        public void UrlBuilderWithRealVirtualPathUtilityTest()
        {
            // Arrange
            var pagePath = "~/world/test.aspx";
            try
            {
                // Act
                CreateHttpContext("default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx");
                CreateHttpRuntime("/WebSite1/");
                var builder = new UrlBuilder(pagePath, null);

                // Assert
                Assert.Equal(@"/WebSite1/world/test.aspx", builder.Path);
            }
            finally
            {
                RestoreHttpRuntime();
            }
        }

        private static HttpContextBase GetContext(params string[] virtualPaths)
        {
            var httpContext = new Mock<HttpContextBase>();
            var table = new Hashtable();
            httpContext.SetupGet(c => c.Items).Returns(table);

            foreach (var item in virtualPaths)
            {
                var page = new Mock<ITemplateFile>();
                page.SetupGet(p => p.TemplateInfo).Returns(new TemplateFileInfo(item));
                TemplateStack.Push(httpContext.Object, page.Object);
            }

            return httpContext.Object;
        }

        private class TestVirtualPathUtility : VirtualPathUtilityBase
        {
            public override string Combine(string basePath, string relativePath)
            {
                return basePath + '/' + relativePath.TrimStart('~', '/');
            }

            public override string ToAbsolute(string virtualPath)
            {
                return virtualPath.TrimStart('~', '/');
            }
        }

        internal static void CreateHttpRuntime(string appVPath)
        {
            var runtime = new HttpRuntime();
            var appDomainAppVPathField = typeof(HttpRuntime).GetField("_appDomainAppVPath", BindingFlags.NonPublic | BindingFlags.Static | BindingFlags.Instance);
            appDomainAppVPathField.SetValue(runtime, CreateVirtualPath(appVPath));
            GetTheRuntime().SetValue(null, runtime);
            var appDomainIdField = typeof(HttpRuntime).GetField("_appDomainId", BindingFlags.NonPublic | BindingFlags.Instance);
            appDomainIdField.SetValue(runtime, "test");
        }

        internal static FieldInfo GetTheRuntime()
        {
            return typeof(HttpRuntime).GetField("_theRuntime", BindingFlags.NonPublic | BindingFlags.Static);
        }

        internal static void RestoreHttpRuntime()
        {
            GetTheRuntime().SetValue(null, null);
        }

        // E.g. "default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx"
        internal static void CreateHttpContext(string filename, string url)
        {
            var request = new HttpRequest(filename, url, null);
            var httpContext = new HttpContext(request, new HttpResponse(new StringWriter(new StringBuilder())));
            HttpContext.Current = httpContext;
        }

        internal static void RestoreHttpContext()
        {
            HttpContext.Current = null;
        }

        internal static object CreateVirtualPath(string path)
        {
            var vPath = typeof(Page).Assembly.GetType("System.Web.VirtualPath");
            var method = vPath.GetMethod("CreateNonRelativeTrailingSlash", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
            return method.Invoke(null, new object[] { path });
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/VideoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Web;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Helpers.Test
{
    public class VideoTest
    {
        private VirtualPathUtilityWrapper _pathUtility = new VirtualPathUtilityWrapper();

        [Fact]
        public void FlashCannotOverrideHtmlAttributes()
        {
            Assert.ThrowsArgument(() => { Video.Flash(GetContext(), _pathUtility, "http://foo.bar.com/foo.swf", htmlAttributes: new { cLASSid = "CanNotOverride" }); }, "htmlAttributes", "Property \"cLASSid\" cannot be set through this argument.");
        }

        [Fact]
        public void FlashDefaults()
        {
            string html = Video.Flash(GetContext(), _pathUtility, "http://foo.bar.com/foo.swf").ToString().Replace("\r\n", "");
            Assert.StartsWith("<object classid=\"clsid:d27cdb6e-ae6d-11cf-96b8-444553540000\" " +
                "codebase=\"http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab\" type=\"application/x-oleobject\" >",
                html);
            Assert.Contains("<param name=\"movie\" value=\"http://foo.bar.com/foo.swf\" />", html);
            Assert.Contains("<embed src=\"http://foo.bar.com/foo.swf\" type=\"application/x-shockwave-flash\" />", html);
            Assert.EndsWith("</object>", html);
        }

        [Fact]
        public void FlashThrowsWhenPathIsEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Flash(GetContext(), _pathUtility, String.Empty); }, "path");
        }

        [Fact]
        public void FlashThrowsWhenPathIsNull()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Flash(GetContext(), _pathUtility, null); }, "path");
        }

        [Fact]
        public void FlashWithExposedOptions()
        {
            string html = Video.Flash(GetContext(), _pathUtility, "http://foo.bar.com/foo.swf", width: "100px", height: "100px",
                                      play: false, loop: false, menu: false, backgroundColor: "#000", quality: "Q", scale: "S", windowMode: "WM",
                                      baseUrl: "http://foo.bar.com/", version: "1.0.0.0", htmlAttributes: new { id = "fl" }, embedName: "efl").ToString().Replace("\r\n", "");

            Assert.StartsWith("<object classid=\"clsid:d27cdb6e-ae6d-11cf-96b8-444553540000\" " +
                "codebase=\"http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=1,0,0,0\" " +
                "height=\"100px\" id=\"fl\" type=\"application/x-oleobject\" width=\"100px\" >",
                html);
            Assert.Contains("<param name=\"play\" value=\"False\" />", html);
            Assert.Contains("<param name=\"loop\" value=\"False\" />", html);
            Assert.Contains("<param name=\"menu\" value=\"False\" />", html);
            Assert.Contains("<param name=\"bgColor\" value=\"#000\" />", html);
            Assert.Contains("<param name=\"quality\" value=\"Q\" />", html);
            Assert.Contains("<param name=\"scale\" value=\"S\" />", html);
            Assert.Contains("<param name=\"wmode\" value=\"WM\" />", html);
            Assert.Contains("<param name=\"base\" value=\"http://foo.bar.com/\" />", html);

            var embed = new Regex("<embed.*/>").Match(html);
            Assert.True(embed.Success);
            Assert.StartsWith("<embed src=\"http://foo.bar.com/foo.swf\" width=\"100px\" height=\"100px\" name=\"efl\" type=\"application/x-shockwave-flash\" ", embed.Value);
            Assert.Contains("play=\"False\"", embed.Value);
            Assert.Contains("loop=\"False\"", embed.Value);
            Assert.Contains("menu=\"False\"", embed.Value);
            Assert.Contains("bgColor=\"#000\"", embed.Value);
            Assert.Contains("quality=\"Q\"", embed.Value);
            Assert.Contains("scale=\"S\"", embed.Value);
            Assert.Contains("wmode=\"WM\"", embed.Value);
            Assert.Contains("base=\"http://foo.bar.com/\"", embed.Value);
        }

        [Fact]
        public void FlashWithUnexposedOptions()
        {
            string html = Video.Flash(GetContext(), _pathUtility, "http://foo.bar.com/foo.swf", options: new { X = "Y", Z = 123 }).ToString().Replace("\r\n", "");
            Assert.Contains("<param name=\"X\" value=\"Y\" />", html);
            Assert.Contains("<param name=\"Z\" value=\"123\" />", html);
            // note - can't guarantee order of optional params:
            Assert.True(
                html.Contains("<embed src=\"http://foo.bar.com/foo.swf\" type=\"application/x-shockwave-flash\" X=\"Y\" Z=\"123\" />") ||
                html.Contains("<embed src=\"http://foo.bar.com/foo.swf\" type=\"application/x-shockwave-flash\" Z=\"123\" X=\"Y\" />")
                );
        }

        [Fact]
        public void MediaPlayerCannotOverrideHtmlAttributes()
        {
            Assert.ThrowsArgument(() => { Video.MediaPlayer(GetContext(), _pathUtility, "http://foo.bar.com/foo.wmv", htmlAttributes: new { cODEbase = "CanNotOverride" }); }, "htmlAttributes", "Property \"cODEbase\" cannot be set through this argument.");
        }

        [Fact]
        public void MediaPlayerDefaults()
        {
            string html = Video.MediaPlayer(GetContext(), _pathUtility, "http://foo.bar.com/foo.wmv").ToString().Replace("\r\n", "");
            Assert.StartsWith("<object classid=\"clsid:6BF52A52-394A-11D3-B153-00C04F79FAA6\" >", html);
            Assert.Contains("<param name=\"URL\" value=\"http://foo.bar.com/foo.wmv\" />", html);
            Assert.Contains("<embed src=\"http://foo.bar.com/foo.wmv\" type=\"application/x-mplayer2\" />", html);
            Assert.EndsWith("</object>", html);
        }

        [Fact]
        public void MediaPlayerThrowsWhenPathIsEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.MediaPlayer(GetContext(), _pathUtility, String.Empty); }, "path");
        }

        [Fact]
        public void MediaPlayerThrowsWhenPathIsNull()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.MediaPlayer(GetContext(), _pathUtility, null); }, "path");
        }

        [Fact]
        public void MediaPlayerWithExposedOptions()
        {
            string html = Video.MediaPlayer(GetContext(), _pathUtility, "http://foo.bar.com/foo.wmv", width: "100px", height: "100px",
                                            autoStart: false, playCount: 2, uiMode: "UIMODE", stretchToFit: true, enableContextMenu: false, mute: true,
                                            volume: 1, baseUrl: "http://foo.bar.com/", htmlAttributes: new { id = "mp" }, embedName: "emp").ToString().Replace("\r\n", "");
            Assert.StartsWith("<object classid=\"clsid:6BF52A52-394A-11D3-B153-00C04F79FAA6\" height=\"100px\" id=\"mp\" width=\"100px\" >", html);
            Assert.Contains("<param name=\"URL\" value=\"http://foo.bar.com/foo.wmv\" />", html);
            Assert.Contains("<param name=\"autoStart\" value=\"False\" />", html);
            Assert.Contains("<param name=\"playCount\" value=\"2\" />", html);
            Assert.Contains("<param name=\"uiMode\" value=\"UIMODE\" />", html);
            Assert.Contains("<param name=\"stretchToFit\" value=\"True\" />", html);
            Assert.Contains("<param name=\"enableContextMenu\" value=\"False\" />", html);
            Assert.Contains("<param name=\"mute\" value=\"True\" />", html);
            Assert.Contains("<param name=\"volume\" value=\"1\" />", html);
            Assert.Contains("<param name=\"baseURL\" value=\"http://foo.bar.com/\" />", html);

            var embed = new Regex("<embed.*/>").Match(html);
            Assert.True(embed.Success);
            Assert.StartsWith("<embed src=\"http://foo.bar.com/foo.wmv\" width=\"100px\" height=\"100px\" name=\"emp\" type=\"application/x-mplayer2\" ", embed.Value);
            Assert.Contains("autoStart=\"False\"", embed.Value);
            Assert.Contains("playCount=\"2\"", embed.Value);
            Assert.Contains("uiMode=\"UIMODE\"", embed.Value);
            Assert.Contains("stretchToFit=\"True\"", embed.Value);
            Assert.Contains("enableContextMenu=\"False\"", embed.Value);
            Assert.Contains("mute=\"True\"", embed.Value);
            Assert.Contains("volume=\"1\"", embed.Value);
            Assert.Contains("baseURL=\"http://foo.bar.com/\"", embed.Value);
        }

        [Fact]
        public void MediaPlayerWithUnexposedOptions()
        {
            string html = Video.MediaPlayer(GetContext(), _pathUtility, "http://foo.bar.com/foo.wmv", options: new { X = "Y", Z = 123 }).ToString().Replace("\r\n", "");
            Assert.Contains("<param name=\"X\" value=\"Y\" />", html);
            Assert.Contains("<param name=\"Z\" value=\"123\" />", html);
            Assert.True(
                html.Contains("<embed src=\"http://foo.bar.com/foo.wmv\" type=\"application/x-mplayer2\" X=\"Y\" Z=\"123\" />") ||
                html.Contains("<embed src=\"http://foo.bar.com/foo.wmv\" type=\"application/x-mplayer2\" Z=\"123\" X=\"Y\" />")
                );
        }

        [Fact]
        public void SilverlightCannotOverrideHtmlAttributes()
        {
            Assert.ThrowsArgument(() =>
            {
                Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", "100px", "100px",
                                  htmlAttributes: new { WIDTH = "CanNotOverride" });
            }, "htmlAttributes", "Property \"WIDTH\" cannot be set through this argument.");
        }

        [Fact]
        public void SilverlightDefaults()
        {
            string html = Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", "100px", "100px").ToString().Replace("\r\n", "");
            Assert.StartsWith("<object data=\"data:application/x-silverlight-2,\" height=\"100px\" type=\"application/x-silverlight-2\" " +
                "width=\"100px\" >",
                html);
            Assert.Contains("<param name=\"source\" value=\"http://foo.bar.com/foo.xap\" />", html);
            Assert.Contains("<a href=\"http://go.microsoft.com/fwlink/?LinkID=149156\" style=\"text-decoration:none\">" +
                "<img src=\"http://go.microsoft.com/fwlink?LinkId=108181\" alt=\"Get Microsoft Silverlight\" " +
                "style=\"border-style:none\"/></a>", html);
            Assert.EndsWith("</object>", html);
        }

        [Fact]
        public void SilverlightThrowsWhenPathIsEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Silverlight(GetContext(), _pathUtility, String.Empty, "100px", "100px"); }, "path");
        }

        [Fact]
        public void SilverlightThrowsWhenPathIsNull()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Silverlight(GetContext(), _pathUtility, null, "100px", "100px"); }, "path");
        }

        [Fact]
        public void SilverlightThrowsWhenHeightIsEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", "100px", String.Empty); }, "height");
        }

        [Fact]
        public void SilverlightThrowsWhenHeightIsNull()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", "100px", null); }, "height");
        }

        [Fact]
        public void SilverlightThrowsWhenWidthIsEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", String.Empty, "100px"); }, "width");
        }

        [Fact]
        public void SilverlightThrowsWhenWidthIsNull()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => { Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", null, "100px"); }, "width");
        }

        [Fact]
        public void SilverlightWithExposedOptions()
        {
            string html = Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", width: "85%", height: "85%",
                                            backgroundColor: "red", initParameters: "X=Y", minimumVersion: "1.0.0.0", autoUpgrade: false,
                                            htmlAttributes: new { id = "sl" }).ToString().Replace("\r\n", "");
            Assert.StartsWith("<object data=\"data:application/x-silverlight-2,\" height=\"85%\" id=\"sl\" " +
                "type=\"application/x-silverlight-2\" width=\"85%\" >",
                html);
            Assert.Contains("<param name=\"background\" value=\"red\" />", html);
            Assert.Contains("<param name=\"initparams\" value=\"X=Y\" />", html);
            Assert.Contains("<param name=\"minruntimeversion\" value=\"1.0.0.0\" />", html);
            Assert.Contains("<param name=\"autoUpgrade\" value=\"False\" />", html);

            var embed = new Regex("<embed.*/>").Match(html);
            Assert.False(embed.Success);
        }

        [Fact]
        public void SilverlightWithUnexposedOptions()
        {
            string html = Video.Silverlight(GetContext(), _pathUtility, "http://foo.bar.com/foo.xap", width: "50px", height: "50px",
                                            options: new { X = "Y", Z = 123 }).ToString().Replace("\r\n", "");
            Assert.Contains("<param name=\"X\" value=\"Y\" />", html);
            Assert.Contains("<param name=\"Z\" value=\"123\" />", html);
        }

        [Fact]
        public void ValidatePathResolvesExistingLocalPath()
        {
            string path = Assembly.GetExecutingAssembly().Location;
            Mock<VirtualPathUtilityBase> pathUtility = new Mock<VirtualPathUtilityBase>();
            pathUtility.Setup(p => p.Combine(It.IsAny<string>(), It.IsAny<string>())).Returns(path);
            pathUtility.Setup(p => p.ToAbsolute(It.IsAny<string>())).Returns(path);

            Mock<HttpServerUtilityBase> serverMock = new Mock<HttpServerUtilityBase>();
            serverMock.Setup(s => s.MapPath(It.IsAny<string>())).Returns(path);
            HttpContextBase context = GetContext(serverMock.Object);

            string html = Video.Flash(context, pathUtility.Object, "foo.bar").ToString();
            Assert.StartsWith("<object", html);
            Assert.Contains(HttpUtility.HtmlAttributeEncode(HttpUtility.UrlPathEncode(path)), html);
        }

        [Fact]
        public void ValidatePathThrowsForNonExistingLocalPath()
        {
            string path = "c:\\does\\not\\exist.swf";
            Mock<VirtualPathUtilityBase> pathUtility = new Mock<VirtualPathUtilityBase>();
            pathUtility.Setup(p => p.Combine(It.IsAny<string>(), It.IsAny<string>())).Returns(path);
            pathUtility.Setup(p => p.ToAbsolute(It.IsAny<string>())).Returns(path);

            Mock<HttpServerUtilityBase> serverMock = new Mock<HttpServerUtilityBase>();
            serverMock.Setup(s => s.MapPath(It.IsAny<string>())).Returns(path);
            HttpContextBase context = GetContext(serverMock.Object);

            Assert.Throws<InvalidOperationException>(() => { Video.Flash(context, pathUtility.Object, "exist.swf"); }, "The media file \"exist.swf\" does not exist.");
        }

        private static HttpContextBase GetContext(HttpServerUtilityBase serverUtility = null)
        {
            // simple mocked context - won't reference as long as path starts with 'http'
            Mock<HttpRequestBase> requestMock = new Mock<HttpRequestBase>();
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(context => context.Request).Returns(requestMock.Object);
            contextMock.Setup(context => context.Server).Returns(serverUtility);
            return contextMock.Object;
        }
    }
}


================================================
FILE: test/Microsoft.Web.Helpers.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/Microsoft.Web.Mvc.Test/Controls/Test/DesignModeSite.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;

namespace Microsoft.Web.Mvc.Controls.Test
{
    public class DesignModeSite : ISite
    {
        IComponent ISite.Component
        {
            get { throw new NotImplementedException(); }
        }

        IContainer ISite.Container
        {
            get { throw new NotImplementedException(); }
        }

        bool ISite.DesignMode
        {
            get { return true; }
        }

        string ISite.Name
        {
            get { throw new NotImplementedException(); }
            set { throw new NotImplementedException(); }
        }

        object IServiceProvider.GetService(Type serviceType)
        {
            throw new NotImplementedException();
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Controls/Test/DropDownListTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Controls.Test
{
    public class DropDownListTest
    {
        [Fact]
        public void NameProperty()
        {
            // TODO: This
        }

        [Fact]
        public void RenderWithNoNameNotInDesignModeThrows()
        {
            // TODO: This
        }

        [Fact]
        public void RenderWithNoNameInDesignModeRendersWithSampleData()
        {
            // Setup
            DropDownList c = new DropDownList();

            // Execute
            string html = MvcTestHelper.GetControlRendering(c, true);

            // Verify
            Assert.Equal("<select>" + Environment.NewLine
                       + "\t<option>" + Environment.NewLine
                       + "\t\tSample Item" + Environment.NewLine
                       + "\t</option>" + Environment.NewLine
                       + "</select>",
                         html);
        }

        [Fact]
        public void RenderWithNoAttributes()
        {
            // Setup
            DropDownList c = new DropDownList();
            c.Name = "nameKey";

            ViewDataContainer vdc = new ViewDataContainer();
            vdc.Controls.Add(c);
            vdc.ViewData = new ViewDataDictionary();
            vdc.ViewData["nameKey"] = new SelectList(new[] { "aaa", "bbb", "ccc" }, "bbb");

            // Execute
            string html = MvcTestHelper.GetControlRendering(c, false);

            // Verify
            Assert.Equal("<select name=\"nameKey\">" + Environment.NewLine
                       + "\t<option>" + Environment.NewLine
                       + "\t\taaa" + Environment.NewLine
                       + "\t</option><option selected=\"selected\">" + Environment.NewLine
                       + "\t\tbbb" + Environment.NewLine
                       + "\t</option><option>" + Environment.NewLine
                       + "\t\tccc" + Environment.NewLine
                       + "\t</option>" + Environment.NewLine
                       + "</select>",
                         html);
        }

        [Fact]
        public void RenderWithTextsAndValues()
        {
            // Setup
            DropDownList c = new DropDownList();
            c.Name = "nameKey";

            ViewDataContainer vdc = new ViewDataContainer();
            vdc.Controls.Add(c);
            vdc.ViewData = new ViewDataDictionary();
            vdc.ViewData["nameKey"] = new SelectList(
                new[]
                {
                    new { Text = "aaa", Value = "111" },
                    new { Text = "bbb", Value = "222" },
                    new { Text = "ccc", Value = "333" }
                },
                "Value",
                "Text",
                "222");

            // Execute
            string html = MvcTestHelper.GetControlRendering(c, false);

            // Verify
            Assert.Equal("<select name=\"nameKey\">" + Environment.NewLine
                       + "\t<option value=\"111\">" + Environment.NewLine
                       + "\t\taaa" + Environment.NewLine
                       + "\t</option><option value=\"222\" selected=\"selected\">" + Environment.NewLine
                       + "\t\tbbb" + Environment.NewLine
                       + "\t</option><option value=\"333\">" + Environment.NewLine
                       + "\t\tccc" + Environment.NewLine
                       + "\t</option>" + Environment.NewLine
                       + "</select>", html);
        }

        [Fact]
        public void RenderWithNameAndIdRendersNameAndIdAttribute()
        {
            // Setup
            DropDownList c = new DropDownList();
            c.Name = "nameKey";
            c.ID = "someID";

            ViewDataContainer vdc = new ViewDataContainer();
            vdc.Controls.Add(c);
            vdc.ViewData = new ViewDataDictionary();
            vdc.ViewData["nameKey"] = new SelectList(new[] { "aaa", "bbb", "ccc" }, "bbb");

            // Execute
            string html = MvcTestHelper.GetControlRendering(c, false);

            // Verify
            Assert.Equal("<select id=\"someID\" name=\"nameKey\">" + Environment.NewLine
                       + "\t<option>" + Environment.NewLine
                       + "\t\taaa" + Environment.NewLine
                       + "\t</option><option selected=\"selected\">" + Environment.NewLine
                       + "\t\tbbb" + Environment.NewLine
                       + "\t</option><option>" + Environment.NewLine
                       + "\t\tccc" + Environment.NewLine
                       + "\t</option>" + Environment.NewLine
                       + "</select>",
                         html);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Controls/Test/MvcControlTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using System.Web.UI;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Controls.Test
{
    public class MvcControlTest
    {
        [Fact]
        public void AttributesProperty()
        {
            // Setup
            DummyMvcControl c = new DummyMvcControl();

            // Execute
            IDictionary<string, string> attrs = c.Attributes;

            // Verify
            Assert.NotNull(attrs);
            Assert.Empty(attrs);
        }

        [Fact]
        public void GetSetAttributes()
        {
            // Setup
            DummyMvcControl c = new DummyMvcControl();
            IAttributeAccessor attrAccessor = c;
            IDictionary<string, string> attrs = c.Attributes;

            // Execute and Verify
            string value;
            value = attrAccessor.GetAttribute("xyz");
            Assert.Null(value);

            attrAccessor.SetAttribute("a1", "v1");
            value = attrAccessor.GetAttribute("a1");
            Assert.Equal("v1", value);
            Assert.Single(attrs);
            value = c.Attributes["a1"];
            Assert.Equal("v1", value);
        }

        [Fact]
        public void EnableViewStateProperty()
        {
            DummyMvcControl c = new DummyMvcControl();
            Assert.True(c.EnableViewState);
            Assert.True((c).EnableViewState);

            c.EnableViewState = false;
            Assert.False(c.EnableViewState);
            Assert.False((c).EnableViewState);

            c.EnableViewState = true;
            Assert.True(c.EnableViewState);
            Assert.True((c).EnableViewState);
        }

        [Fact]
        public void ViewContextWithNoPageIsNull()
        {
            // Setup
            DummyMvcControl c = new DummyMvcControl();
            Control c1 = new Control();
            c1.Controls.Add(c);

            // Execute
            ViewContext vc = c.ViewContext;

            // Verify
            Assert.Null(vc);
        }

        private sealed class DummyMvcControl : MvcControl
        {
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Controls/Test/MvcTestHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.UI;

namespace Microsoft.Web.Mvc.Controls.Test
{
    public static class MvcTestHelper
    {
        public static string GetControlRendering(Control c, bool designMode)
        {
            if (designMode)
            {
                c.Site = new DesignModeSite();
            }
            HtmlTextWriter writer = new HtmlTextWriter(new StringWriter());
            c.RenderControl(writer);
            return writer.InnerWriter.ToString();
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Controls/Test/ViewDataContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using System.Web.UI;

namespace Microsoft.Web.Mvc.Controls.Test
{
    public class ViewDataContainer : Control, IViewDataContainer
    {
        public ViewDataDictionary ViewData { get; set; }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Microsoft.Web.Mvc.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{6C28DA70-60F1-4442-967F-591BF3962EC5}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.Web</RootNamespace>
    <AssemblyName>Microsoft.Web.Mvc.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <!-- Force signing off -->
    <SignAssembly>false</SignAssembly>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.Abstractions" />
    <Reference Include="System.Web.Routing" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Controls\Test\DesignModeSite.cs" />
    <Compile Include="Controls\Test\DropDownListTest.cs" />
    <Compile Include="Controls\Test\MvcControlTest.cs" />
    <Compile Include="Controls\Test\MvcTestHelper.cs" />
    <Compile Include="Controls\Test\ViewDataContainer.cs" />
    <Compile Include="ModelBinding\Test\BindingBehaviorAttributeTest.cs" />
    <Compile Include="ModelBinding\Test\BinaryDataModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\ExtensibleModelBinderAdapterTest.cs" />
    <Compile Include="ModelBinding\Test\ExtensibleModelBindingContextTest.cs" />
    <Compile Include="ModelBinding\Test\GenericModelBinderProviderTest.cs" />
    <Compile Include="Test\AreaHelpersTest.cs" />
    <Compile Include="ModelBinding\Test\CollectionModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\CollectionModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\CollectionModelBinderUtilTest.cs" />
    <Compile Include="ModelBinding\Test\ComplexModelDtoResultTest.cs" />
    <Compile Include="ModelBinding\Test\ComplexModelDtoTest.cs" />
    <Compile Include="ModelBinding\Test\ComplexModelDtoModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\ComplexModelDtoModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\ArrayModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\ArrayModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\DictionaryModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\DictionaryModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\KeyValuePairModelBinderUtilTest.cs" />
    <Compile Include="ModelBinding\Test\KeyValuePairModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\KeyValuePairModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\MutableObjectModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\MutableObjectModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\TypeConverterModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\TypeConverterModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\ModelBinderConfigTest.cs" />
    <Compile Include="ModelBinding\Test\SimpleModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\TypeMatchModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Test\TypeMatchModelBinderTest.cs" />
    <Compile Include="ModelBinding\Test\ModelBinderProviderCollectionTest.cs" />
    <Compile Include="ModelBinding\Test\ModelBinderUtilTest.cs" />
    <Compile Include="ModelBinding\Test\ModelValidationNodeTest.cs" />
    <Compile Include="ModelBinding\Test\ModelBinderProvidersTest.cs" />
    <Compile Include="Test\ButtonTest.cs" />
    <Compile Include="Test\ContentTypeAttributeTest.cs" />
    <Compile Include="Test\ControllerExtensionsTest.cs" />
    <Compile Include="Test\AjaxOnlyAttributeTest.cs" />
    <Compile Include="Test\AsyncManagerExtensionsTest.cs" />
    <Compile Include="Test\CookieValueProviderFactoryTest.cs" />
    <Compile Include="Test\AcceptAttributeTest.cs" />
    <Compile Include="Test\CreditCardAttributeTest.cs" />
    <Compile Include="Test\DynamicReflectionObjectTest.cs" />
    <Compile Include="Test\DynamicViewDataDictionaryTest.cs" />
    <Compile Include="Test\DynamicViewPageTest.cs" />
    <Compile Include="Test\EmailAddressAttribueTest.cs" />
    <Compile Include="Test\FileExtensionsAttributeTest.cs" />
    <Compile Include="Test\ModelCopierTest.cs" />
    <Compile Include="Test\ElementalValueProviderTest.cs" />
    <Compile Include="Test\UrlAttributeTest.cs" />
    <Compile Include="Test\ValueProviderUtilTest.cs" />
    <Compile Include="Test\TempDataValueProviderFactoryTest.cs" />
    <Compile Include="Test\SessionValueProviderFactoryTest.cs" />
    <Compile Include="Test\ServerVariablesValueProviderFactoryTest.cs" />
    <Compile Include="Test\CopyAsyncParametersAttributeTest.cs" />
    <Compile Include="Test\CssExtensionsTests.cs" />
    <Compile Include="Test\DeserializeAttributeTest.cs" />
    <Compile Include="Test\ScriptExtensionsTest.cs" />
    <Compile Include="Test\SerializationExtensionsTest.cs" />
    <Compile Include="Test\MvcSerializerTest.cs" />
    <Compile Include="Test\ExpressionHelperTest.cs" />
    <Compile Include="Test\MailToExtensionsTest.cs" />
    <Compile Include="Test\ReaderWriterCacheTest.cs" />
    <Compile Include="Test\RenderActionTest.cs" />
    <Compile Include="Test\SkipBindingAttributeTest.cs" />
    <Compile Include="Test\FormExtensionsTest.cs" />
    <Compile Include="Test\RadioExtensionsTest.cs" />
    <Compile Include="Test\SubmitImageExtensionsTest.cs" />
    <Compile Include="Test\ImageExtensionsTest.cs" />
    <Compile Include="Test\SubmitButtonExtensionsTest.cs" />
    <Compile Include="Test\TypeHelpersTest.cs" />
    <Compile Include="Test\VersionTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\Microsoft.Web.Mvc\Microsoft.Web.Mvc.csproj">
      <Project>{D3CF7430-6DA4-42B0-BD90-CA39D16687B2}</Project>
      <Name>Microsoft.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3D3FFD8A-624D-4E9B-954B-E1C105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Mvc.Test\System.Web.Mvc.Test.csproj">
      <Project>{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}</Project>
      <Name>System.Web.Mvc.Test</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ArrayModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ArrayModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<ArrayModelBinder<int>>(binder);
        }

        [Fact]
        public void GetBinder_ModelMetadataReturnsReadOnly_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo[0]", "42" },
                }
            };
            bindingContext.ModelMetadata.IsReadOnly = true;

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ICollection<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainPrefix_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
            };

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ArrayModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ArrayModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider
                {
                    { "someName[0]", "42" },
                    { "someName[1]", "84" }
                }
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, false /* suppressPrefixCheck */);

            // Act
            bool retVal = new ArrayModelBinder<int>().BindModel(controllerContext, bindingContext);

            // Assert
            Assert.True(retVal);

            int[] array = bindingContext.Model as int[];
            Assert.Equal(new[] { 42, 84 }, array);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/BinaryDataModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Data.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class BinaryDataModelBinderProviderTest
    {
        private static readonly byte[] _base64Bytes = new byte[] { 0x12, 0x20, 0x34, 0x40 };
        private const string _base64String = "EiA0QA==";

        [Fact]
        public void BindModel_BadValue_Fails()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(byte[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo", "not base64 encoded!" }
                }
            };

            BinaryDataModelBinderProvider binderProvider = new BinaryDataModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void BindModel_EmptyValue_Fails()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(byte[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo", "" }
                }
            };

            BinaryDataModelBinderProvider binderProvider = new BinaryDataModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void BindModel_GoodValue_ByteArray_Succeeds()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(byte[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo", _base64String }
                }
            };

            BinaryDataModelBinderProvider binderProvider = new BinaryDataModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(_base64Bytes, (byte[])bindingContext.Model);
        }

        [Fact]
        public void BindModel_GoodValue_LinqBinary_Succeeds()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(Binary)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo", _base64String }
                }
            };

            BinaryDataModelBinderProvider binderProvider = new BinaryDataModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.True(retVal);
            Binary binaryModel = Assert.IsType<Binary>(bindingContext.Model);
            Assert.Equal(_base64Bytes, binaryModel.ToArray());
        }

        [Fact]
        public void BindModel_NoValue_Fails()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(byte[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo.bar", _base64String }
                }
            };

            BinaryDataModelBinderProvider binderProvider = new BinaryDataModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void GetBinder_WrongModelType_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo", _base64String }
                }
            };

            BinaryDataModelBinderProvider binderProvider = new BinaryDataModelBinderProvider();

            // Act
            IExtensibleModelBinder modelBinder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(modelBinder);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/BindingBehaviorAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class BindingBehaviorAttributeTest
    {
        [Fact]
        public void Behavior_Property()
        {
            // Arrange
            BindingBehavior expectedBehavior = (BindingBehavior)(-20);

            // Act
            BindingBehaviorAttribute attr = new BindingBehaviorAttribute(expectedBehavior);

            // Assert
            Assert.Equal(expectedBehavior, attr.Behavior);
        }

        [Fact]
        public void TypeId_ReturnsSameValue()
        {
            // Arrange
            BindNeverAttribute neverAttr = new BindNeverAttribute();
            BindRequiredAttribute requiredAttr = new BindRequiredAttribute();

            // Act & assert
            Assert.Same(neverAttr.TypeId, requiredAttr.TypeId);
        }

        [Fact]
        public void BindNever_SetsBehavior()
        {
            // Act
            BindingBehaviorAttribute attr = new BindNeverAttribute();

            // Assert
            Assert.Equal(BindingBehavior.Never, attr.Behavior);
        }

        [Fact]
        public void BindRequired_SetsBehavior()
        {
            // Act
            BindingBehaviorAttribute attr = new BindRequiredAttribute();

            // Assert
            Assert.Equal(BindingBehavior.Required, attr.Behavior);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/CollectionModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class CollectionModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IEnumerable<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<CollectionModelBinder<int>>(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainPrefix_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IEnumerable<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
            };

            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/CollectionModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class CollectionModelBinderTest
    {
        [Fact]
        public void BindComplexCollectionFromIndexes_FiniteIndexes()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider
                {
                    { "someName[foo]", "42" },
                    { "someName[baz]", "200" }
                }
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, false /* suppressPrefixCheck */);

            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindComplexCollectionFromIndexes(controllerContext, bindingContext, new[] { "foo", "bar", "baz" });

            // Assert
            Assert.Equal(new[] { 42, 0, 200 }, boundCollection.ToArray());
            Assert.Equal(new[] { "someName[foo]", "someName[baz]" }, bindingContext.ValidationNode.ChildNodes.Select(o => o.ModelStateKey).ToArray());
        }

        [Fact]
        public void BindComplexCollectionFromIndexes_InfiniteIndexes()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider
                {
                    { "someName[0]", "42" },
                    { "someName[1]", "100" },
                    { "someName[3]", "400" }
                }
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, false /* suppressPrefixCheck */);

            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindComplexCollectionFromIndexes(controllerContext, bindingContext, null /* indexNames */);

            // Assert
            Assert.Equal(new[] { 42, 100 }, boundCollection.ToArray());
            Assert.Equal(new[] { "someName[0]", "someName[1]" }, bindingContext.ValidationNode.ChildNodes.Select(o => o.ModelStateKey).ToArray());
        }

        [Fact]
        public void BindModel_ComplexCollection()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider
                {
                    { "someName.index", new[] { "foo", "bar", "baz" } },
                    { "someName[foo]", "42" },
                    { "someName[bar]", "100" },
                    { "someName[baz]", "200" }
                }
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);

            CollectionModelBinder<int> modelBinder = new CollectionModelBinder<int>();

            // Act
            bool retVal = modelBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal(new[] { 42, 100, 200 }, ((List<int>)bindingContext.Model).ToArray());
        }

        [Fact]
        public void BindModel_SimpleCollection()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider
                {
                    { "someName", new[] { "42", "100", "200" } }
                }
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);

            CollectionModelBinder<int> modelBinder = new CollectionModelBinder<int>();

            // Act
            bool retVal = modelBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(new[] { 42, 100, 200 }, ((List<int>)bindingContext.Model).ToArray());
        }

        [Fact]
        public void BindSimpleCollection_RawValueIsEmptyCollection_ReturnsEmptyList()
        {
            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindSimpleCollection(null, null, new object[0], null);

            // Assert
            Assert.NotNull(boundCollection);
            Assert.Empty(boundCollection);
        }

        [Fact]
        public void BindSimpleCollection_RawValueIsNull_ReturnsNull()
        {
            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindSimpleCollection(null, null, null, null);

            // Assert
            Assert.Null(boundCollection);
        }

        [Fact]
        public void BindSimpleCollection_SubBinderDoesNotExist()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindSimpleCollection(controllerContext, bindingContext, new int[1], culture);

            // Assert
            Assert.Equal(new[] { 0 }, boundCollection.ToArray());
            Assert.Empty(bindingContext.ValidationNode.ChildNodes);
        }

        [Fact]
        public void BindSimpleCollection_SubBindingSucceeds()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            ModelValidationNode childValidationNode = null;
            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Equal("someName", mbc.ModelName);
                        childValidationNode = mbc.ValidationNode;
                        mbc.Model = 42;
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);

            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindSimpleCollection(controllerContext, bindingContext, new int[1], culture);

            // Assert
            Assert.Equal(new[] { 42 }, boundCollection.ToArray());
            Assert.Equal(new[] { childValidationNode }, bindingContext.ValidationNode.ChildNodes.ToArray());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/CollectionModelBinderUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class CollectionModelBinderUtilTest
    {
        [Fact]
        public void CreateOrReplaceCollection_OriginalModelImmutable_CreatesNewInstance()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => new ReadOnlyCollection<int>(new int[0]), typeof(ICollection<int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, new[] { 10, 20, 30 }, () => new List<int>());

            // Assert
            int[] newModel = (bindingContext.Model as ICollection<int>).ToArray();
            Assert.Equal(new[] { 10, 20, 30 }, newModel);
        }

        [Fact]
        public void CreateOrReplaceCollection_OriginalModelMutable_UpdatesOriginalInstance()
        {
            // Arrange
            List<int> originalInstance = new List<int> { 10, 20, 30 };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => originalInstance, typeof(ICollection<int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, new[] { 40, 50, 60 }, () => new List<int>());

            // Assert
            Assert.Same(originalInstance, bindingContext.Model);
            Assert.Equal(new[] { 40, 50, 60 }, originalInstance.ToArray());
        }

        [Fact]
        public void CreateOrReplaceCollection_OriginalModelNotCollection_CreatesNewInstance()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ICollection<int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, new[] { 10, 20, 30 }, () => new List<int>());

            // Assert
            int[] newModel = (bindingContext.Model as ICollection<int>).ToArray();
            Assert.Equal(new[] { 10, 20, 30 }, newModel);
        }

        [Fact]
        public void CreateOrReplaceDictionary_DisallowsDuplicateKeys()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(Dictionary<string, int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new[]
                {
                    new KeyValuePair<string, int>("forty-two", 40),
                    new KeyValuePair<string, int>("forty-two", 2),
                    new KeyValuePair<string, int>("forty-two", 42)
                },
                () => new Dictionary<string, int>());

            // Assert
            IDictionary<string, int> newModel = bindingContext.Model as IDictionary<string, int>;
            Assert.Equal(new[] { "forty-two" }, newModel.Keys.ToArray());
            Assert.Equal(42, newModel["forty-two"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_DisallowsNullKeys()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(Dictionary<string, int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new[]
                {
                    new KeyValuePair<string, int>("forty-two", 42),
                    new KeyValuePair<string, int>(null, 84)
                },
                () => new Dictionary<string, int>());

            // Assert
            IDictionary<string, int> newModel = bindingContext.Model as IDictionary<string, int>;
            Assert.Equal(new[] { "forty-two" }, newModel.Keys.ToArray());
            Assert.Equal(42, newModel["forty-two"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_OriginalModelImmutable_CreatesNewInstance()
        {
            // Arrange
            ReadOnlyDictionary<string, string> originalModel = new ReadOnlyDictionary<string, string>();

            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => originalModel, typeof(IDictionary<string, string>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new Dictionary<string, string>
                {
                    { "Hello", "World" }
                },
                () => new Dictionary<string, string>());

            // Assert
            IDictionary<string, string> newModel = bindingContext.Model as IDictionary<string, string>;
            Assert.NotSame(originalModel, newModel);
            Assert.Equal(new[] { "Hello" }, newModel.Keys.ToArray());
            Assert.Equal("World", newModel["Hello"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_OriginalModelMutable_UpdatesOriginalInstance()
        {
            // Arrange
            Dictionary<string, string> originalInstance = new Dictionary<string, string>
            {
                { "dog", "Canidae" },
                { "cat", "Felidae" }
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => originalInstance, typeof(IDictionary<string, string>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new Dictionary<string, string>
                {
                    { "horse", "Equidae" },
                    { "bear", "Ursidae" }
                },
                () => new Dictionary<string, string>());

            // Assert
            Assert.Same(originalInstance, bindingContext.Model);
            Assert.Equal(new[] { "horse", "bear" }, originalInstance.Keys.ToArray());
            Assert.Equal("Equidae", originalInstance["horse"]);
            Assert.Equal("Ursidae", originalInstance["bear"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_OriginalModelNotDictionary_CreatesNewInstance()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<string, string>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new Dictionary<string, string>
                {
                    { "horse", "Equidae" },
                    { "bear", "Ursidae" }
                },
                () => new Dictionary<string, string>());

            // Assert
            IDictionary<string, string> newModel = bindingContext.Model as IDictionary<string, string>;
            Assert.Equal(new[] { "horse", "bear" }, newModel.Keys.ToArray());
            Assert.Equal("Equidae", newModel["horse"]);
            Assert.Equal("Ursidae", newModel["bear"]);
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultIsNull_ReturnsNull()
        {
            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(null);

            // Assert
            Assert.Null(indexNames);
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultReturnsEmptyArray_ReturnsNull()
        {
            // Arrange
            ValueProviderResult vpResult = new ValueProviderResult(new string[0], "", null);

            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(vpResult);

            // Assert
            Assert.Null(indexNames);
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultReturnsNonEmptyArray_ReturnsArray()
        {
            // Arrange
            ValueProviderResult vpResult = new ValueProviderResult(new[] { "foo", "bar", "baz" }, "foo,bar,baz", null);

            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(vpResult);

            // Assert
            Assert.NotNull(indexNames);
            Assert.Equal(new[] { "foo", "bar", "baz" }, indexNames.ToArray());
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultReturnsNull_ReturnsNull()
        {
            // Arrange
            ValueProviderResult vpResult = new ValueProviderResult(null, null, null);

            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(vpResult);

            // Assert
            Assert.Null(indexNames);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ModelTypeNotGeneric_Fail()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int));

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(null, null, modelMetadata);

            // Assert
            Assert.Null(typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ModelTypeOpenGeneric_Fail()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IList<>));

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(null, null, modelMetadata);

            // Assert
            Assert.Null(typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ModelTypeWrongNumberOfGenericArguments_Fail()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>));

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(typeof(ICollection<>), null, modelMetadata);

            // Assert
            Assert.Null(typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ReadOnlyReference_ModelInstanceImmutable_Valid()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => new int[0], typeof(IList<int>));
            modelMetadata.IsReadOnly = true;

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(typeof(IList<>), typeof(List<>), modelMetadata);

            // Assert
            Assert.Null(typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ReadOnlyReference_ModelInstanceMutable_Valid()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => new List<int>(), typeof(IList<int>));
            modelMetadata.IsReadOnly = true;

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(typeof(IList<>), typeof(List<>), modelMetadata);

            // Assert
            Assert.Equal(new[] { typeof(int) }, typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ReadOnlyReference_ModelInstanceOfWrongType_Fail()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => new HashSet<int>(), typeof(ICollection<int>));
            modelMetadata.IsReadOnly = true;

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(typeof(IList<>), typeof(List<>), modelMetadata);

            // Assert
            // HashSet<> is not an IList<>, so we can't update
            Assert.Null(typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ReadOnlyReference_ModelIsNull_Fail()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IList<int>));
            modelMetadata.IsReadOnly = true;

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(typeof(ICollection<>), typeof(List<>), modelMetadata);

            // Assert
            Assert.Null(typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ReadWriteReference_NewInstanceAssignableToModelType_Success()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IList<int>));
            modelMetadata.IsReadOnly = false;

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(typeof(ICollection<>), typeof(List<>), modelMetadata);

            // Assert
            Assert.Equal(new[] { typeof(int) }, typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsForUpdatableGenericCollection_ReadWriteReference_NewInstanceNotAssignableToModelType_MutableInstance_Success()
        {
            // Arrange
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => new Collection<int>(), typeof(Collection<int>));
            modelMetadata.IsReadOnly = false;

            // Act
            Type[] typeArguments = CollectionModelBinderUtil.GetTypeArgumentsForUpdatableGenericCollection(typeof(ICollection<>), typeof(List<>), modelMetadata);

            // Assert
            Assert.Equal(new[] { typeof(int) }, typeArguments);
        }

        [Fact]
        public void GetZeroBasedIndexes()
        {
            // Act
            string[] indexes = CollectionModelBinderUtil.GetZeroBasedIndexes().Take(5).ToArray();

            // Assert
            Assert.Equal(new[] { "0", "1", "2", "3", "4" }, indexes);
        }

        private class ReadOnlyDictionary<TKey, TValue> : Dictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>
        {
            bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
            {
                get { return true; }
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ComplexModelDtoModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ComplexModelDtoModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_TypeDoesNotMatch_ReturnsNull()
        {
            // Arrange
            ComplexModelDtoModelBinderProvider provider = new ComplexModelDtoModelBinderProvider();
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(object));

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_TypeMatches_ReturnsBinder()
        {
            // Arrange
            ComplexModelDtoModelBinderProvider provider = new ComplexModelDtoModelBinderProvider();
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(ComplexModelDto));

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<ComplexModelDtoModelBinder>(binder);
        }

        private static ExtensibleModelBindingContext GetBindingContext(Type modelType)
        {
            return new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => null, modelType)
            };
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ComplexModelDtoModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ComplexModelDtoModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            MyModel model = new MyModel();
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(MyModel));
            ComplexModelDto dto = new ComplexModelDto(modelMetadata, modelMetadata.Properties);

            Mock<IExtensibleModelBinder> mockStringBinder = new Mock<IExtensibleModelBinder>();
            mockStringBinder
                .Setup(b => b.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Equal(typeof(string), mbc.ModelType);
                        Assert.Equal("theModel.StringProperty", mbc.ModelName);
                        mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.StringProperty");
                        mbc.Model = "someStringValue";
                        return true;
                    });

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(b => b.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Equal(typeof(int), mbc.ModelType);
                        Assert.Equal("theModel.IntProperty", mbc.ModelName);
                        mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.IntProperty");
                        mbc.Model = 42;
                        return true;
                    });

            Mock<IExtensibleModelBinder> mockDateTimeBinder = new Mock<IExtensibleModelBinder>();
            mockDateTimeBinder
                .Setup(b => b.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Equal(typeof(DateTime), mbc.ModelType);
                        Assert.Equal("theModel.DateTimeProperty", mbc.ModelName);
                        return false;
                    });

            ModelBinderProviderCollection binders = new ModelBinderProviderCollection();
            binders.RegisterBinderForType(typeof(string), mockStringBinder.Object, true /* suppressPrefixCheck */);
            binders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);
            binders.RegisterBinderForType(typeof(DateTime), mockDateTimeBinder.Object, true /* suppressPrefixCheck */);

            ExtensibleModelBindingContext parentBindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => dto, typeof(ComplexModelDto)),
                ModelName = "theModel",
                ModelBinderProviders = binders
            };

            ComplexModelDtoModelBinder binder = new ComplexModelDtoModelBinder();

            // Act
            bool retVal = binder.BindModel(controllerContext, parentBindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(dto, parentBindingContext.Model);

            ComplexModelDtoResult stringDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(string)).First()];
            Assert.Equal("someStringValue", stringDtoResult.Model);
            Assert.Equal("theModel.StringProperty", stringDtoResult.ValidationNode.ModelStateKey);

            ComplexModelDtoResult intDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(int)).First()];
            Assert.Equal(42, intDtoResult.Model);
            Assert.Equal("theModel.IntProperty", intDtoResult.ValidationNode.ModelStateKey);

            ComplexModelDtoResult dateTimeDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(DateTime)).First()];
            Assert.Null(dateTimeDtoResult);
        }

        private static ModelBindingContext GetBindingContext(Type modelType)
        {
            return new ModelBindingContext
            {
                ModelMetadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, modelType, "SomeProperty")
            };
        }

        private sealed class MyModel
        {
            public string StringProperty { get; set; }
            public int IntProperty { get; set; }
            public object ObjectProperty { get; set; } // no binding should happen since no registered binder
            public DateTime DateTimeProperty { get; set; } // registered binder returns false
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ComplexModelDtoResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ComplexModelDtoResultTest
    {
        [Fact]
        public void Constructor_ThrowsIfValidationNodeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ComplexModelDtoResult("some string", null); }, "validationNode");
        }

        [Fact]
        public void Constructor_SetsProperties()
        {
            // Arrange
            ModelValidationNode validationNode = GetValidationNode();

            // Act
            ComplexModelDtoResult result = new ComplexModelDtoResult("some string", validationNode);

            // Assert
            Assert.Equal("some string", result.Model);
            Assert.Equal(validationNode, result.ValidationNode);
        }

        private static ModelValidationNode GetValidationNode()
        {
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = provider.GetMetadataForType(null, typeof(object));
            return new ModelValidationNode(metadata, "someKey");
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ComplexModelDtoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ComplexModelDtoTest
    {
        [Fact]
        public void ConstructorThrowsIfModelMetadataIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ComplexModelDto(null, Enumerable.Empty<ModelMetadata>()); }, "modelMetadata");
        }

        [Fact]
        public void ConstructorThrowsIfPropertyMetadataIsNull()
        {
            // Arrange
            ModelMetadata modelMetadata = GetModelMetadata();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ComplexModelDto(modelMetadata, null); }, "propertyMetadata");
        }

        [Fact]
        public void ConstructorSetsProperties()
        {
            // Arrange
            ModelMetadata modelMetadata = GetModelMetadata();
            ModelMetadata[] propertyMetadata = new ModelMetadata[0];

            // Act
            ComplexModelDto dto = new ComplexModelDto(modelMetadata, propertyMetadata);

            // Assert
            Assert.Equal(modelMetadata, dto.ModelMetadata);
            Assert.Equal(propertyMetadata, dto.PropertyMetadata.ToArray());
            Assert.Empty(dto.Results);
        }

        private static ModelMetadata GetModelMetadata()
        {
            return new ModelMetadata(new EmptyModelMetadataProvider(), typeof(object), null, typeof(object), "PropertyName");
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/DictionaryModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class DictionaryModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<DictionaryModelBinder<int, string>>(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainPrefix_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
            };

            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/DictionaryModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class DictionaryModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<int, string>)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider
                {
                    { "someName[0]", new KeyValuePair<int, string>(42, "forty-two") },
                    { "someName[1]", new KeyValuePair<int, string>(84, "eighty-four") }
                }
            };

            Mock<IExtensibleModelBinder> mockKvpBinder = new Mock<IExtensibleModelBinder>();
            mockKvpBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(KeyValuePair<int, string>), mockKvpBinder.Object, false /* suppressPrefixCheck */);

            // Act
            bool retVal = new DictionaryModelBinder<int, string>().BindModel(controllerContext, bindingContext);

            // Assert
            Assert.True(retVal);

            var dictionary = Assert.IsAssignableFrom<IDictionary<int, string>>(bindingContext.Model);
            Assert.NotNull(dictionary);
            Assert.Equal(2, dictionary.Count);
            Assert.Equal("forty-two", dictionary[42]);
            Assert.Equal("eighty-four", dictionary[84]);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ExtensibleModelBinderAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ExtensibleModelBinderAdapterTest
    {
        [Fact]
        public void BindModel_PropertyFilterIsSet_Throws()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(SimpleModel)),
                PropertyFilter = (new BindAttribute { Include = "FirstName " }).IsPropertyAllowed
            };

            ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
            ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);

            // Act & assert

            Assert.Throws<InvalidOperationException>(
                delegate { shimBinder.BindModel(controllerContext, bindingContext); },
                @"The new model binding system cannot be used when a property whitelist or blacklist has been specified in [Bind] or via the call to UpdateModel() / TryUpdateModel(). Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead.");
        }

        [Fact]
        public void BindModel_SuccessfulBind_RunsValidationAndReturnsModel()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            bool validationCalled = false;

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelState = controllerContext.Controller.ViewData.ModelState,
                PropertyFilter = _ => true,
                ValueProvider = new SimpleValueProvider
                {
                    { "someName", "dummyValue" }
                }
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Same(bindingContext.ModelMetadata, mbc.ModelMetadata);
                        Assert.Equal("someName", mbc.ModelName);
                        Assert.Same(bindingContext.ValueProvider, mbc.ValueProvider);

                        mbc.Model = 42;
                        mbc.ValidationNode.Validating += delegate { validationCalled = true; };
                        return true;
                    });

            ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
            binderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, false /* suppressPrefixCheck */);
            ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);

            // Act
            object retVal = shimBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal(42, retVal);
            Assert.True(validationCalled);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void BindModel_SuccessfulBind_ComplexTypeFallback_RunsValidationAndReturnsModel()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();

            bool validationCalled = false;
            List<int> expectedModel = new List<int> { 1, 2, 3, 4, 5 };

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
                ModelName = "someName",
                ModelState = controllerContext.Controller.ViewData.ModelState,
                PropertyFilter = _ => true,
                ValueProvider = new SimpleValueProvider
                {
                    { "someOtherName", "dummyValue" }
                }
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Same(bindingContext.ModelMetadata, mbc.ModelMetadata);
                        Assert.Equal("", mbc.ModelName);
                        Assert.Same(bindingContext.ValueProvider, mbc.ValueProvider);

                        mbc.Model = expectedModel;
                        mbc.ValidationNode.Validating += delegate { validationCalled = true; };
                        return true;
                    });

            ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
            binderProviders.RegisterBinderForType(typeof(List<int>), mockIntBinder.Object, false /* suppressPrefixCheck */);
            ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);

            // Act
            object retVal = shimBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal(expectedModel, retVal);
            Assert.True(validationCalled);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void BindModel_UnsuccessfulBind_BinderFails_ReturnsNull()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            Mock<IExtensibleModelBinder> mockListBinder = new Mock<IExtensibleModelBinder>();
            mockListBinder.Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>())).Returns(false).Verifiable();

            ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection();
            binderProviders.RegisterBinderForType(typeof(List<int>), mockListBinder.Object, true /* suppressPrefixCheck */);
            ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = false,
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
                ModelState = controllerContext.Controller.ViewData.ModelState
            };

            // Act
            object retVal = shimBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Null(retVal);
            Assert.True(bindingContext.ModelState.IsValid);
            mockListBinder.Verify();
        }

        [Fact]
        public void BindModel_UnsuccessfulBind_SimpleTypeNoFallback_ReturnsNull()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            Mock<ModelBinderProvider> mockBinderProvider = new Mock<ModelBinderProvider>();
            mockBinderProvider.Setup(o => o.GetBinder(controllerContext, It.IsAny<ExtensibleModelBindingContext>())).Returns((IExtensibleModelBinder)null).Verifiable();
            ModelBinderProviderCollection binderProviders = new ModelBinderProviderCollection
            {
                mockBinderProvider.Object
            };
            ExtensibleModelBinderAdapter shimBinder = new ExtensibleModelBinderAdapter(binderProviders);

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelState = controllerContext.Controller.ViewData.ModelState
            };

            // Act
            object retVal = shimBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Null(retVal);
            Assert.True(bindingContext.ModelState.IsValid);
            mockBinderProvider.Verify();
            mockBinderProvider.Verify(o => o.GetBinder(controllerContext, It.IsAny<ExtensibleModelBindingContext>()), Times.AtMostOnce());
        }

        private static ControllerContext GetControllerContext()
        {
            return new ControllerContext
            {
                Controller = new SimpleController()
            };
        }

        private class SimpleController : Controller
        {
        }

        private class SimpleModel
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ExtensibleModelBindingContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ExtensibleModelBindingContextTest
    {
        [Fact]
        public void CopyConstructor()
        {
            // Arrange
            ExtensibleModelBindingContext originalBindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object)),
                ModelName = "theName",
                ModelState = new ModelStateDictionary(),
                ValueProvider = new SimpleValueProvider()
            };

            // Act
            ExtensibleModelBindingContext newBindingContext = new ExtensibleModelBindingContext(originalBindingContext);

            // Assert
            Assert.Null(newBindingContext.ModelMetadata);
            Assert.Equal("", newBindingContext.ModelName);
            Assert.Equal(originalBindingContext.ModelState, newBindingContext.ModelState);
            Assert.Equal(originalBindingContext.ValueProvider, newBindingContext.ValueProvider);
        }

        [Fact]
        public void ModelBinderProvidersProperty()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext();

            // Act & assert            
            MemberHelper.TestPropertyWithDefaultInstance(bindingContext, "ModelBinderProviders", new ModelBinderProviderCollection(), ModelBinderProviders.Providers);
        }

        [Fact]
        public void ModelProperty()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int))
            };

            // Act & assert            
            MemberHelper.TestPropertyValue(bindingContext, "Model", 42);
        }

        [Fact]
        public void ModelProperty_ThrowsIfModelMetadataDoesNotExist()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext();

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { bindingContext.Model = null; },
                "The ModelMetadata property must be set before accessing this property.");
        }

        [Fact]
        public void ModelNameProperty()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext();

            // Act & assert
            Assert.Reflection.StringProperty(bindingContext, (context) => context.ModelName, String.Empty);
        }

        [Fact]
        public void ModelStateProperty()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext();
            ModelStateDictionary modelState = new ModelStateDictionary();

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(bindingContext, "ModelState", modelState);
        }

        [Fact]
        public void ModelAndModelTypeAreFedFromModelMetadata()
        {
            // Act
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => 42, typeof(int))
            };

            // Assert
            Assert.Equal(42, bindingContext.Model);
            Assert.Equal(typeof(int), bindingContext.ModelType);
        }

        [Fact]
        public void ValidationNodeProperty()
        {
            // Act
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => 42, typeof(int))
            };

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(bindingContext, "ValidationNode", new ModelValidationNode(bindingContext.ModelMetadata, "someName"));
        }

        [Fact]
        public void ValidationNodeProperty_DefaultValues()
        {
            // Act
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => 42, typeof(int)),
                ModelName = "theInt"
            };

            // Act
            ModelValidationNode validationNode = bindingContext.ValidationNode;

            // Assert
            Assert.NotNull(validationNode);
            Assert.Equal(bindingContext.ModelMetadata, validationNode.ModelMetadata);
            Assert.Equal(bindingContext.ModelName, validationNode.ModelStateKey);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/GenericModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class GenericModelBinderProviderTest
    {
        [Fact]
        public void Constructor_WithFactory_ThrowsIfModelBinderFactoryIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new GenericModelBinderProvider(typeof(List<>), (Func<Type[], IExtensibleModelBinder>)null); }, "modelBinderFactory");
        }

        [Fact]
        public void Constructor_WithFactory_ThrowsIfModelTypeIsNotOpenGeneric()
        {
            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new GenericModelBinderProvider(typeof(List<int>), _ => null); },
                "The type 'System.Collections.Generic.List`1[System.Int32]' is not an open generic type." + Environment.NewLine
              + "Parameter name: modelType");
        }

        [Fact]
        public void Constructor_WithFactory_ThrowsIfModelTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new GenericModelBinderProvider(null, _ => null); }, "modelType");
        }

        [Fact]
        public void Constructor_WithInstance_ThrowsIfModelBinderIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new GenericModelBinderProvider(typeof(List<>), (IExtensibleModelBinder)null); }, "modelBinder");
        }

        [Fact]
        public void Constructor_WithInstance_ThrowsIfModelTypeIsNotOpenGeneric()
        {
            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new GenericModelBinderProvider(typeof(List<int>), new MutableObjectModelBinder()); },
                "The type 'System.Collections.Generic.List`1[System.Int32]' is not an open generic type." + Environment.NewLine
              + "Parameter name: modelType");
        }

        [Fact]
        public void Constructor_WithInstance_ThrowsIfModelTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new GenericModelBinderProvider(null, new MutableObjectModelBinder()); }, "modelType");
        }

        [Fact]
        public void Constructor_WithType_ThrowsIfModelBinderTypeIsNotModelBinder()
        {
            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new GenericModelBinderProvider(typeof(List<>), typeof(string)); },
                "The type 'System.String' does not implement the interface 'Microsoft.Web.Mvc.ModelBinding.IExtensibleModelBinder'." + Environment.NewLine
              + "Parameter name: modelBinderType");
        }

        [Fact]
        public void Constructor_WithType_ThrowsIfModelBinderTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new GenericModelBinderProvider(typeof(List<>), (Type)null); }, "modelBinderType");
        }

        [Fact]
        public void Constructor_WithType_ThrowsIfModelBinderTypeTypeArgumentMismatch()
        {
            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new GenericModelBinderProvider(typeof(List<>), typeof(DictionaryModelBinder<,>)); },
                "The open model type 'System.Collections.Generic.List`1[T]' has 1 generic type argument(s), but the open binder type 'Microsoft.Web.Mvc.ModelBinding.DictionaryModelBinder`2[TKey,TValue]' has 2 generic type argument(s). The binder type must not be an open generic type or must have the same number of generic arguments as the open model type." + Environment.NewLine
              + "Parameter name: modelBinderType");
        }

        [Fact]
        public void Constructor_WithType_ThrowsIfModelTypeIsNotOpenGeneric()
        {
            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new GenericModelBinderProvider(typeof(List<int>), typeof(MutableObjectModelBinder)); },
                "The type 'System.Collections.Generic.List`1[System.Int32]' is not an open generic type." + Environment.NewLine
              + "Parameter name: modelType");
        }

        [Fact]
        public void Constructor_WithType_ThrowsIfModelTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new GenericModelBinderProvider(null, typeof(MutableObjectModelBinder)); }, "modelType");
        }

        [Fact]
        public void GetBinder_TypeDoesNotMatch_ModelTypeIsInterface_ReturnsNull()
        {
            // Arrange
            GenericModelBinderProvider provider = new GenericModelBinderProvider(typeof(IEnumerable<>), typeof(CollectionModelBinder<>))
            {
                SuppressPrefixCheck = true
            };
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(object));

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_TypeDoesNotMatch_ModelTypeIsNotInterface_ReturnsNull()
        {
            // Arrange
            GenericModelBinderProvider provider = new GenericModelBinderProvider(typeof(List<>), typeof(CollectionModelBinder<>))
            {
                SuppressPrefixCheck = true
            };
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(object));

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_TypeMatches_PrefixNotFound_ReturnsNull()
        {
            // Arrange
            IExtensibleModelBinder binderInstance = new Mock<IExtensibleModelBinder>().Object;
            GenericModelBinderProvider provider = new GenericModelBinderProvider(typeof(List<>), binderInstance);

            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(List<int>));
            bindingContext.ValueProvider = new SimpleValueProvider();

            // Act
            IExtensibleModelBinder returnedBinder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(returnedBinder);
        }

        [Fact]
        public void GetBinder_TypeMatches_Success_Factory_ReturnsBinder()
        {
            // Arrange
            IExtensibleModelBinder binderInstance = new Mock<IExtensibleModelBinder>().Object;

            Func<Type[], IExtensibleModelBinder> binderFactory = typeArguments =>
            {
                Assert.Equal(new[] { typeof(int) }, typeArguments);
                return binderInstance;
            };

            GenericModelBinderProvider provider = new GenericModelBinderProvider(typeof(IList<>), binderFactory)
            {
                SuppressPrefixCheck = true
            };

            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(List<int>));

            // Act
            IExtensibleModelBinder returnedBinder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Same(binderInstance, returnedBinder);
        }

        [Fact]
        public void GetBinder_TypeMatches_Success_Instance_ReturnsBinder()
        {
            // Arrange
            IExtensibleModelBinder binderInstance = new Mock<IExtensibleModelBinder>().Object;

            GenericModelBinderProvider provider = new GenericModelBinderProvider(typeof(List<>), binderInstance)
            {
                SuppressPrefixCheck = true
            };

            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(List<int>));

            // Act
            IExtensibleModelBinder returnedBinder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Same(binderInstance, returnedBinder);
        }

        [Fact]
        public void GetBinder_TypeMatches_Success_TypeActivation_ReturnsBinder()
        {
            // Arrange
            GenericModelBinderProvider provider = new GenericModelBinderProvider(typeof(List<>), typeof(CollectionModelBinder<>))
            {
                SuppressPrefixCheck = true
            };

            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(List<int>));

            // Act
            IExtensibleModelBinder returnedBinder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<CollectionModelBinder<int>>(returnedBinder);
        }

        [Fact]
        public void GetBinderThrowsIfBindingContextIsNull()
        {
            // Arrange
            GenericModelBinderProvider provider = new GenericModelBinderProvider(typeof(IEnumerable<>), typeof(CollectionModelBinder<>));

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { provider.GetBinder(null, null); }, "bindingContext");
        }

        [Fact]
        public void GetBinderThrowsIfModelBinderHasNoParameterlessConstructor()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(List<int>));
            GenericModelBinderProvider provider =
                new GenericModelBinderProvider(typeof(List<>), typeof(NoParameterlessCtorBinder<>))
                {
                    SuppressPrefixCheck = true,
                };

            // Act & Assert, confirming type name and full stack are available in Exception
            MissingMethodException exception = Assert.Throws<MissingMethodException>(
                () => provider.GetBinder(null, bindingContext),
                "No parameterless constructor defined for this object. Object type 'Microsoft.Web.Mvc.ModelBinding.Test.GenericModelBinderProviderTest+NoParameterlessCtorBinder`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]'.");
            Assert.Contains("System.Activator.CreateInstance(", exception.ToString());
        }

        private static ExtensibleModelBindingContext GetBindingContext(Type modelType)
        {
            return new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => null, modelType)
            };
        }

        private class NoParameterlessCtorBinder<T> : IExtensibleModelBinder
        {
            public NoParameterlessCtorBinder(int parameter)
            {
            }

            public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/KeyValuePairModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class KeyValuePairModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo.key", 42 },
                    { "foo.value", "someValue" }
                }
            };

            KeyValuePairModelBinderProvider binderProvider = new KeyValuePairModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<KeyValuePairModelBinder<int, string>>(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo.key", 42 },
                    { "foo.value", "someValue" }
                }
            };

            KeyValuePairModelBinderProvider binderProvider = new KeyValuePairModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainKeyProperty_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo.value", "someValue" }
                }
            };

            KeyValuePairModelBinderProvider binderProvider = new KeyValuePairModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainValueProperty_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo.key", 42 }
                }
            };

            KeyValuePairModelBinderProvider binderProvider = new KeyValuePairModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/KeyValuePairModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class KeyValuePairModelBinderTest
    {
        [Fact]
        public void BindModel_MissingKey_ReturnsFalse()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            KeyValuePairModelBinder<int, string> binder = new KeyValuePairModelBinder<int, string>();

            // Act
            bool retVal = binder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Null(bindingContext.Model);
            Assert.Empty(bindingContext.ValidationNode.ChildNodes);
        }

        [Fact]
        public void BindModel_MissingValue_ReturnsTrue()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = 42;
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);

            KeyValuePairModelBinder<int, string> binder = new KeyValuePairModelBinder<int, string>();

            // Act
            bool retVal = binder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Null(bindingContext.Model);
            Assert.Equal(new[] { "someName.key" }, bindingContext.ValidationNode.ChildNodes.Select(n => n.ModelStateKey).ToArray());
        }

        [Fact]
        public void BindModel_SubBindingSucceeds()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "someName",
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = 42;
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);
            Mock<IExtensibleModelBinder> mockStringBinder = new Mock<IExtensibleModelBinder>();
            mockStringBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        mbc.Model = "forty-two";
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(string), mockStringBinder.Object, true /* suppressPrefixCheck */);

            KeyValuePairModelBinder<int, string> binder = new KeyValuePairModelBinder<int, string>();

            // Act
            bool retVal = binder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(new KeyValuePair<int, string>(42, "forty-two"), bindingContext.Model);
            Assert.Equal(new[] { "someName.key", "someName.value" }, bindingContext.ValidationNode.ChildNodes.Select(n => n.ModelStateKey).ToArray());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/KeyValuePairModelBinderUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class KeyValuePairModelBinderUtilTest
    {
        [Fact]
        public void TryBindStrongModel_BinderExists_BinderReturnsCorrectlyTypedObject_ReturnsTrue()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelState = new ModelStateDictionary(),
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Equal("someName.key", mbc.ModelName);
                        mbc.Model = 42;
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);

            // Act
            int model;
            bool retVal = KeyValuePairModelBinderUtil.TryBindStrongModel(controllerContext, bindingContext, "key", new EmptyModelMetadataProvider(), out model);

            // Assert
            Assert.True(retVal);
            Assert.Equal(42, model);
            Assert.Single(bindingContext.ValidationNode.ChildNodes);
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void TryBindStrongModel_BinderExists_BinderReturnsIncorrectlyTypedObject_ReturnsTrue()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelState = new ModelStateDictionary(),
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            Mock<IExtensibleModelBinder> mockIntBinder = new Mock<IExtensibleModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc)
                    {
                        Assert.Equal("someName.key", mbc.ModelName);
                        return true;
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, true /* suppressPrefixCheck */);

            // Act
            int model;
            bool retVal = KeyValuePairModelBinderUtil.TryBindStrongModel(controllerContext, bindingContext, "key", new EmptyModelMetadataProvider(), out model);

            // Assert
            Assert.True(retVal);
            Assert.Equal(default(int), model);
            Assert.Single(bindingContext.ValidationNode.ChildNodes);
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void TryBindStrongModel_NoBinder_ReturnsFalse()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelState = new ModelStateDictionary(),
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ValueProvider = new SimpleValueProvider()
            };

            // Act
            int model;
            bool retVal = KeyValuePairModelBinderUtil.TryBindStrongModel(controllerContext, bindingContext, "key", new EmptyModelMetadataProvider(), out model);

            // Assert
            Assert.False(retVal);
            Assert.Equal(default(int), model);
            Assert.Empty(bindingContext.ValidationNode.ChildNodes);
            Assert.Empty(bindingContext.ModelState);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ModelBinderConfigTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Web;
using System.Web.Mvc;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ModelBinderConfigTest
    {
        [Fact]
        public void GetUserResourceString_NullControllerContext_ReturnsNull()
        {
            // Act
            string customResourceString = ModelBinderConfig.GetUserResourceString(null /* controllerContext */, "someResourceName", "someResourceClassKey");

            // Assert
            Assert.Null(customResourceString);
        }

        [Fact]
        public void GetUserResourceString_NullHttpContext_ReturnsNull()
        {
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext).Returns((HttpContextBase)null);

            // Act
            string customResourceString = ModelBinderConfig.GetUserResourceString(mockControllerContext.Object, "someResourceName", "someResourceClassKey");

            // Assert
            Assert.Null(customResourceString);
        }

        [Fact]
        public void GetUserResourceString_NullResourceKey_ReturnsNull()
        {
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();

            // Act
            string customResourceString = ModelBinderConfig.GetUserResourceString(mockControllerContext.Object, "someResourceName", null /* resourceClassKey */);

            // Assert
            mockControllerContext.Verify(o => o.HttpContext, Times.Never());
            Assert.Null(customResourceString);
        }

        [Fact]
        public void GetUserResourceString_ValidResourceObject_ReturnsResourceString()
        {
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.GetGlobalResourceObject("someResourceClassKey", "someResourceName", CultureInfo.CurrentUICulture)).Returns("My custom resource string");

            // Act
            string customResourceString = ModelBinderConfig.GetUserResourceString(mockControllerContext.Object, "someResourceName", "someResourceClassKey");

            // Assert
            Assert.Equal("My custom resource string", customResourceString);
        }

        [Fact]
        public void Initialize_ReplacesOriginalCollection()
        {
            // Arrange
            ModelBinderDictionary oldBinders = new ModelBinderDictionary();
            oldBinders[typeof(int)] = new Mock<IModelBinder>().Object;
            ModelBinderProviderCollection newBinderProviders = new ModelBinderProviderCollection();

            // Act
            ModelBinderConfig.Initialize(oldBinders, newBinderProviders);

            // Assert
            Assert.Empty(oldBinders);

            var shimBinder = Assert.IsType<ExtensibleModelBinderAdapter>(oldBinders.DefaultBinder);
            Assert.Same(newBinderProviders, shimBinder.Providers);
        }

        [Fact]
        public void TypeConversionErrorMessageProvider_DefaultValue()
        {
            // Arrange
            ModelMetadata metadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(int), "SomePropertyName");

            // Act
            string errorString = ModelBinderConfig.TypeConversionErrorMessageProvider(null, metadata, "some incoming value");

            // Assert
            Assert.Equal("The value 'some incoming value' is not valid for SomePropertyName.", errorString);
        }

        [Fact]
        public void TypeConversionErrorMessageProvider_Property()
        {
            // Arrange
            ModelBinderConfigWrapper wrapper = new ModelBinderConfigWrapper();

            // Act & assert
            try
            {
                MemberHelper.TestPropertyWithDefaultInstance(wrapper, "TypeConversionErrorMessageProvider", (ModelBinderErrorMessageProvider)DummyErrorSelector);
            }
            finally
            {
                wrapper.Reset();
            }
        }

        [Fact]
        public void ValueRequiredErrorMessageProvider_DefaultValue()
        {
            // Arrange
            ModelMetadata metadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(int), "SomePropertyName");

            // Act
            string errorString = ModelBinderConfig.ValueRequiredErrorMessageProvider(null, metadata, "some incoming value");

            // Assert
            Assert.Equal("A value is required.", errorString);
        }

        [Fact]
        public void ValueRequiredErrorMessageProvider_Property()
        {
            // Arrange
            ModelBinderConfigWrapper wrapper = new ModelBinderConfigWrapper();

            // Act & assert
            try
            {
                MemberHelper.TestPropertyWithDefaultInstance(wrapper, "ValueRequiredErrorMessageProvider", (ModelBinderErrorMessageProvider)DummyErrorSelector);
            }
            finally
            {
                wrapper.Reset();
            }
        }

        private string DummyErrorSelector(ControllerContext controllerContext, ModelMetadata modelMetadata, object incomingValue)
        {
            throw new NotImplementedException();
        }

        private sealed class ModelBinderConfigWrapper
        {
            public ModelBinderErrorMessageProvider TypeConversionErrorMessageProvider
            {
                get { return ModelBinderConfig.TypeConversionErrorMessageProvider; }
                set { ModelBinderConfig.TypeConversionErrorMessageProvider = value; }
            }

            public ModelBinderErrorMessageProvider ValueRequiredErrorMessageProvider
            {
                get { return ModelBinderConfig.ValueRequiredErrorMessageProvider; }
                set { ModelBinderConfig.ValueRequiredErrorMessageProvider = value; }
            }

            public void Reset()
            {
                ModelBinderConfig.TypeConversionErrorMessageProvider = null;
                ModelBinderConfig.ValueRequiredErrorMessageProvider = null;
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ModelBinderProviderCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ModelBinderProviderCollectionTest
    {
        [Fact]
        public void ListWrappingConstructor()
        {
            // Arrange
            ModelBinderProvider[] providers = new[]
            {
                new Mock<ModelBinderProvider>().Object,
                new Mock<ModelBinderProvider>().Object
            };

            // Act
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection(providers);

            // Assert
            Assert.Equal(providers, collection.ToArray());
        }

        [Fact]
        public void DefaultConstructor()
        {
            // Act
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();

            // Assert
            Assert.Empty(collection);
        }

        [Fact]
        public void AddNullProviderThrows()
        {
            // Arrange
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection.Add(null); },
                "item");
        }

        [Fact]
        public void RegisterBinderForGenericType_Factory()
        {
            // Arrange
            ModelBinderProvider mockProvider = new Mock<ModelBinderProvider>().Object;
            IExtensibleModelBinder mockBinder = new Mock<IExtensibleModelBinder>().Object;

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection
            {
                mockProvider
            };

            // Act
            collection.RegisterBinderForGenericType(typeof(List<>), _ => mockBinder);

            // Assert
            var genericProvider = Assert.IsType<GenericModelBinderProvider>(collection[0]);
            Assert.Equal(typeof(List<>), genericProvider.ModelType);
            Assert.Equal(mockProvider, collection[1]);
        }

        [Fact]
        public void RegisterBinderForGenericType_Instance()
        {
            // Arrange
            ModelBinderProvider mockProvider = new Mock<ModelBinderProvider>().Object;
            IExtensibleModelBinder mockBinder = new Mock<IExtensibleModelBinder>().Object;

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection
            {
                mockProvider
            };

            // Act
            collection.RegisterBinderForGenericType(typeof(List<>), mockBinder);

            // Assert
            var genericProvider = Assert.IsType<GenericModelBinderProvider>(collection[0]);
            Assert.Equal(typeof(List<>), genericProvider.ModelType);
            Assert.Equal(mockProvider, collection[1]);
        }

        [Fact]
        public void RegisterBinderForGenericType_Type()
        {
            // Arrange
            ModelBinderProvider mockProvider = new Mock<ModelBinderProvider>().Object;
            IExtensibleModelBinder mockBinder = new Mock<IExtensibleModelBinder>().Object;

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection
            {
                mockProvider
            };

            // Act
            collection.RegisterBinderForGenericType(typeof(List<>), typeof(CollectionModelBinder<>));

            // Assert
            var genericProvider = Assert.IsType<GenericModelBinderProvider>(collection[0]);
            Assert.Equal(typeof(List<>), genericProvider.ModelType);
            Assert.Equal(mockProvider, collection[1]);
        }

        [Fact]
        public void RegisterBinderForType_Factory()
        {
            // Arrange
            ModelBinderProvider mockProvider = new Mock<ModelBinderProvider>().Object;
            IExtensibleModelBinder mockBinder = new Mock<IExtensibleModelBinder>().Object;

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection
            {
                mockProvider
            };

            // Act
            collection.RegisterBinderForType(typeof(int), () => mockBinder);

            // Assert
            var simpleProvider = Assert.IsType<SimpleModelBinderProvider>(collection[0]);
            Assert.Equal(typeof(int), simpleProvider.ModelType);
            Assert.Equal(mockProvider, collection[1]);
        }

        [Fact]
        public void RegisterBinderForType_Instance()
        {
            // Arrange
            ModelBinderProvider mockProvider = new Mock<ModelBinderProvider>().Object;
            IExtensibleModelBinder mockBinder = new Mock<IExtensibleModelBinder>().Object;

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection
            {
                mockProvider
            };

            // Act
            collection.RegisterBinderForType(typeof(int), mockBinder);

            // Assert
            var simpleProvider = Assert.IsType<SimpleModelBinderProvider>(collection[0]);
            Assert.Equal(typeof(int), simpleProvider.ModelType);
            Assert.Equal(mockProvider, collection[1]);
        }

        [Fact]
        public void RegisterBinderForType_Instance_InsertsNewProviderBehindFrontOfListProviders()
        {
            // Arrange
            ModelBinderProvider frontOfListProvider = new ProviderAtFront();
            IExtensibleModelBinder mockBinder = new Mock<IExtensibleModelBinder>().Object;

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection
            {
                frontOfListProvider
            };

            // Act
            collection.RegisterBinderForType(typeof(int), mockBinder);

            // Assert
            Assert.Equal(
                new[] { typeof(ProviderAtFront), typeof(SimpleModelBinderProvider) },
                collection.Select(o => o.GetType()).ToArray());
        }

        [Fact]
        public void SetItem()
        {
            // Arrange
            ModelBinderProvider provider0 = new Mock<ModelBinderProvider>().Object;
            ModelBinderProvider provider1 = new Mock<ModelBinderProvider>().Object;
            ModelBinderProvider provider2 = new Mock<ModelBinderProvider>().Object;

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();
            collection.Add(provider0);
            collection.Add(provider1);

            // Act
            collection[1] = provider2;

            // Assert
            Assert.Equal(new[] { provider0, provider2 }, collection.ToArray());
        }

        [Fact]
        public void SetNullProviderThrows()
        {
            // Arrange
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();
            collection.Add(new Mock<ModelBinderProvider>().Object);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection[0] = null; },
                "item");
        }

        [Fact]
        public void GetBinder_FromAttribute_BadAttribute_Throws()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_BadAttribute))
            };

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection();

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { providers.GetBinder(controllerContext, bindingContext); },
                @"The type 'System.Object' does not subclass Microsoft.Web.Mvc.ModelBinding.ModelBinderProvider or implement the interface Microsoft.Web.Mvc.ModelBinding.IExtensibleModelBinder.");
        }

        [Fact]
        public void GetBinder_FromAttribute_Binder_Generic_ReturnsBinder()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Binder_Generic<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo", "fooValue" }
                }
            };

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
            providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Binder_Generic<int>), new Mock<IExtensibleModelBinder>().Object, true /* suppressPrefix */);

            // Act
            IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);

            // Assert
            Assert.IsType<CustomGenericBinder<int>>(binder);
        }

        [Fact]
        public void GetBinder_FromAttribute_Binder_SuppressPrefixCheck_ReturnsBinder()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Binder_SuppressPrefix)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "bar", "barValue" }
                }
            };

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
            providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Binder_SuppressPrefix), new Mock<IExtensibleModelBinder>().Object, true /* suppressPrefix */);

            // Act
            IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);

            // Assert
            Assert.IsType<CustomBinder>(binder);
        }

        [Fact]
        public void GetBinder_FromAttribute_Binder_ValueNotPresent_ReturnsNull()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Binder)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "bar", "barValue" }
                }
            };

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
            providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Binder), new Mock<IExtensibleModelBinder>().Object, true /* suppressPrefix */);

            // Act
            IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_FromAttribute_Binder_ValuePresent_ReturnsBinder()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Binder)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo", "fooValue" }
                }
            };

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
            providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Binder), new Mock<IExtensibleModelBinder>().Object, true /* suppressPrefix */);

            // Act
            IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);

            // Assert
            Assert.IsType<CustomBinder>(binder);
        }

        [Fact]
        public void GetBinder_FromAttribute_Provider_ReturnsBinder()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithProviderAttribute_Provider))
            };

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection();
            providers.RegisterBinderForType(typeof(ModelWithProviderAttribute_Provider), new Mock<IExtensibleModelBinder>().Object, true /* suppressPrefix */);

            // Act
            IExtensibleModelBinder binder = providers.GetBinder(controllerContext, bindingContext);

            // Assert
            Assert.IsType<CustomBinder>(binder);
        }

        [Fact]
        public void GetBinderReturnsFirstBinderFromProviders()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object))
            };
            IExtensibleModelBinder expectedBinder = new Mock<IExtensibleModelBinder>().Object;

            Mock<ModelBinderProvider> mockProvider = new Mock<ModelBinderProvider>();
            mockProvider.Setup(p => p.GetBinder(controllerContext, bindingContext)).Returns(expectedBinder);

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection(new[]
            {
                new Mock<ModelBinderProvider>().Object,
                mockProvider.Object,
                new Mock<ModelBinderProvider>().Object
            });

            // Act
            IExtensibleModelBinder returned = collection.GetBinder(controllerContext, bindingContext);

            // Assert
            Assert.Equal(expectedBinder, returned);
        }

        [Fact]
        public void GetBinderReturnsNullIfNoProviderMatches()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object))
            };

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection(new[]
            {
                new Mock<ModelBinderProvider>().Object,
            });

            // Act
            IExtensibleModelBinder returned = collection.GetBinder(controllerContext, bindingContext);

            // Assert
            Assert.Null(returned);
        }

        [Fact]
        public void GetBinderThrowsIfBindingContextIsNull()
        {
            // Arrange
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { collection.GetBinder(new ControllerContext(), null); }, "bindingContext");
        }

        [Fact]
        public void GetBinderThrowsIfControllerContextIsNull()
        {
            // Arrange
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { collection.GetBinder(null, new ExtensibleModelBindingContext()); }, "controllerContext");
        }

        [Fact]
        public void GetBinderThrowsIfModelTypeHasBindAttribute()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ModelWithBindAttribute))
            };
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { collection.GetBinder(controllerContext, bindingContext); },
                @"The model of type 'Microsoft.Web.Mvc.ModelBinding.Test.ModelBinderProviderCollectionTest+ModelWithBindAttribute' has a [Bind] attribute. The new model binding system cannot be used with models that have type-level [Bind] attributes. Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead.");
        }

        [Fact]
        public void GetBinderThrowsIfBinderHasNoParameterlessConstructor()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(
                    null,
                    typeof(ModelWithProviderAttribute_ProviderHasNoParameterlessConstructor)),
            };

            // Act & Assert, confirming type name and full stack are available in Exception
            MissingMethodException exception = Assert.Throws<MissingMethodException>(
                () => collection.GetBinder(controllerContext, bindingContext),
                "No parameterless constructor defined for this object. Object type 'Microsoft.Web.Mvc.ModelBinding.Test.ModelBinderProviderCollectionTest+NoParameterlessCtorProvider'.");
            Assert.Contains("System.Activator.CreateInstance(", exception.ToString());
        }

        [Fact]
        public void GetBinderThrowsIfGenericProviderHasNoParameterlessConstructor()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ModelBinderProviderCollection collection = new ModelBinderProviderCollection();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(
                    null,
                    typeof(ModelWithProviderAttribute_ProviderHasNoParameterlessConstructor<int>)),
            };

            // Act & Assert, confirming type name and full stack are available in Exception
            MissingMethodException exception = Assert.Throws<MissingMethodException>(
                () => collection.GetBinder(controllerContext, bindingContext),
                "No parameterless constructor defined for this object. Object type 'Microsoft.Web.Mvc.ModelBinding.Test.ModelBinderProviderCollectionTest+NoParameterlessCtorBinder`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]'.");
            Assert.Contains("System.Activator.CreateInstance(", exception.ToString());
        }

        [Fact]
        public void GetRequiredBinderThrowsIfNoProviderMatches()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int))
            };

            ModelBinderProviderCollection collection = new ModelBinderProviderCollection(new[]
            {
                new Mock<ModelBinderProvider>().Object,
            });

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { collection.GetRequiredBinder(controllerContext, bindingContext); },
                @"A binder for type System.Int32 could not be located.");
        }

        [MetadataType(typeof(ModelWithBindAttribute_Buddy))]
        private class ModelWithBindAttribute
        {
            [Bind]
            private class ModelWithBindAttribute_Buddy
            {
            }
        }

        [ModelBinderProviderOptions(FrontOfList = true)]
        private class ProviderAtFront : ModelBinderProvider
        {
            public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        [ExtensibleModelBinder(typeof(object))]
        private class ModelWithProviderAttribute_BadAttribute
        {
        }

        [ExtensibleModelBinder(typeof(CustomBinder))]
        private class ModelWithProviderAttribute_Binder
        {
        }

        [ExtensibleModelBinder(typeof(CustomGenericBinder<>))]
        private class ModelWithProviderAttribute_Binder_Generic<T>
        {
        }

        [ExtensibleModelBinder(typeof(CustomBinder), SuppressPrefixCheck = true)]
        private class ModelWithProviderAttribute_Binder_SuppressPrefix
        {
        }

        [ExtensibleModelBinder(typeof(CustomProvider))]
        private class ModelWithProviderAttribute_Provider
        {
        }

        [ExtensibleModelBinder(typeof(NoParameterlessCtorProvider))]
        private class ModelWithProviderAttribute_ProviderHasNoParameterlessConstructor
        {
        }

        [ExtensibleModelBinder(typeof(NoParameterlessCtorBinder<>))]
        private class ModelWithProviderAttribute_ProviderHasNoParameterlessConstructor<T>
        {
        }

        private class CustomProvider : ModelBinderProvider
        {
            public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                return new CustomBinder();
            }
        }

        private class CustomBinder : IExtensibleModelBinder
        {
            public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        private class CustomGenericBinder<T> : IExtensibleModelBinder
        {
            public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        private class NoParameterlessCtorProvider : ModelBinderProvider
        {
            public NoParameterlessCtorProvider(int parameter)
            {
            }

            public override IExtensibleModelBinder GetBinder(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        private class NoParameterlessCtorBinder<T> : IExtensibleModelBinder
        {
            public NoParameterlessCtorBinder(int parameter)
            {
            }

            public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ModelBinderProvidersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ModelBinderProvidersTest
    {
        [Fact]
        public void CollectionDefaults()
        {
            // Arrange
            Type[] expectedTypes = new[]
            {
                typeof(TypeMatchModelBinderProvider),
                typeof(BinaryDataModelBinderProvider),
                typeof(KeyValuePairModelBinderProvider),
                typeof(ComplexModelDtoModelBinderProvider),
                typeof(ArrayModelBinderProvider),
                typeof(DictionaryModelBinderProvider),
                typeof(CollectionModelBinderProvider),
                typeof(TypeConverterModelBinderProvider),
                typeof(MutableObjectModelBinderProvider)
            };

            // Act
            Type[] actualTypes = ModelBinderProviders.Providers.Select(p => p.GetType()).ToArray();

            // Assert
            Assert.Equal(expectedTypes, actualTypes);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ModelBinderUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ModelBinderUtilTest
    {
        [Fact]
        public void CastOrDefault_CorrectType_ReturnsInput()
        {
            // Act
            int retVal = ModelBinderUtil.CastOrDefault<int>(42);

            // Assert
            Assert.Equal(42, retVal);
        }

        [Fact]
        public void CastOrDefault_IncorrectType_ReturnsDefaultTModel()
        {
            // Act
            DateTime retVal = ModelBinderUtil.CastOrDefault<DateTime>(42);

            // Assert
            Assert.Equal(default(DateTime), retVal);
        }

        [Fact]
        public void CreateIndexModelName_EmptyParentName()
        {
            // Act
            string fullChildName = ModelBinderUtil.CreateIndexModelName("", 42);

            // Assert
            Assert.Equal("[42]", fullChildName);
        }

        [Fact]
        public void CreateIndexModelName_IntIndex()
        {
            // Act
            string fullChildName = ModelBinderUtil.CreateIndexModelName("parentName", 42);

            // Assert
            Assert.Equal("parentName[42]", fullChildName);
        }

        [Fact]
        public void CreateIndexModelName_StringIndex()
        {
            // Act
            string fullChildName = ModelBinderUtil.CreateIndexModelName("parentName", "index");

            // Assert
            Assert.Equal("parentName[index]", fullChildName);
        }

        [Fact]
        public void CreatePropertyModelName()
        {
            // Act
            string fullChildName = ModelBinderUtil.CreatePropertyModelName("parentName", "childName");

            // Assert
            Assert.Equal("parentName.childName", fullChildName);
        }

        [Fact]
        public void CreatePropertyModelName_EmptyParentName()
        {
            // Act
            string fullChildName = ModelBinderUtil.CreatePropertyModelName("", "childName");

            // Assert
            Assert.Equal("childName", fullChildName);
        }

        [Fact]
        public void GetPossibleBinderInstance_Match_ReturnsBinder()
        {
            // Act
            IExtensibleModelBinder binder = ModelBinderUtil.GetPossibleBinderInstance(typeof(List<int>), typeof(List<>), typeof(SampleGenericBinder<>));

            // Assert
            Assert.IsType<SampleGenericBinder<int>>(binder);
        }

        [Fact]
        public void GetPossibleBinderInstance_NoMatch_ReturnsNull()
        {
            // Act
            IExtensibleModelBinder binder = ModelBinderUtil.GetPossibleBinderInstance(typeof(ArraySegment<int>), typeof(List<>), typeof(SampleGenericBinder<>));

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsEnumerable_ReturnsInputAsArray()
        {
            // Assert
            List<int> original = new List<int> { 1, 2, 3, 4 };

            // Act
            object[] retVal = ModelBinderUtil.RawValueToObjectArray(original);

            // Assert
            Assert.Equal(new object[] { 1, 2, 3, 4 }, retVal);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsObject_WrapsObjectInSingleElementArray()
        {
            // Act
            object[] retVal = ModelBinderUtil.RawValueToObjectArray(42);

            // Assert
            Assert.Equal(new object[] { 42 }, retVal);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsObjectArray_ReturnsInputInstance()
        {
            // Assert
            object[] original = new object[2];

            // Act
            object[] retVal = ModelBinderUtil.RawValueToObjectArray(original);

            // Assert
            Assert.Same(original, retVal);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsString_WrapsStringInSingleElementArray()
        {
            // Act
            object[] retVal = ModelBinderUtil.RawValueToObjectArray("hello");

            // Assert
            Assert.Equal(new object[] { "hello" }, retVal);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullDisabled_ModelIsEmptyString_LeavesModelAlone()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = false;

            // Act
            object model = "";
            ModelBinderUtil.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Equal("", model);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullEnabled_ModelIsEmptyString_ReplacesModelWithNull()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = true;

            // Act
            object model = "";
            ModelBinderUtil.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Null(model);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullEnabled_ModelIsWhitespaceString_ReplacesModelWithNull()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = true;

            // Act
            object model = "     "; // whitespace
            ModelBinderUtil.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Null(model);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullDisabled_ModelIsNotEmptyString_LeavesModelAlone()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = true;

            // Act
            object model = 42;
            ModelBinderUtil.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Equal(42, model);
        }

        [Fact]
        public void ValidateBindingContext_SuccessWithNonNullModel()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };
            bindingContext.ModelMetadata.Model = "hello!";

            // Act
            ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(string), false);

            // Assert
            // Nothing to do - if we got this far without throwing, the test succeeded
        }

        [Fact]
        public void ValidateBindingContext_SuccessWithNullModel()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };

            // Act
            ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(string), true);

            // Assert
            // Nothing to do - if we got this far without throwing, the test succeeded
        }

        [Fact]
        public void ValidateBindingContextThrowsIfBindingContextIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ModelBinderUtil.ValidateBindingContext(null, typeof(string), true); }, "bindingContext");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelInstanceIsWrongType()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };
            bindingContext.ModelMetadata.Model = 42;

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(string), true); },
                "The binding context has a Model of type 'System.Int32', but this binder can only operate on models of type 'System.String'." + Environment.NewLine
              + "Parameter name: bindingContext");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelIsNullButCannotBe()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(string), false); },
                "The binding context has a null Model, but this binder requires a non-null model of type 'System.String'." + Environment.NewLine
              + "Parameter name: bindingContext");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelMetadataIsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext();

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(string), true); },
                "The binding context cannot have a null ModelMetadata." + Environment.NewLine
              + "Parameter name: bindingContext");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelTypeIsWrong()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(object))
            };

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { ModelBinderUtil.ValidateBindingContext(bindingContext, typeof(string), true); },
                "The binding context has a ModelType of 'System.Object', but this binder can only operate on models of type 'System.String'." + Environment.NewLine
              + "Parameter name: bindingContext");
        }

        private static ModelMetadata GetMetadata(Type modelType)
        {
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            return provider.GetMetadataForType(null, modelType);
        }

        private class SampleGenericBinder<T> : IExtensibleModelBinder
        {
            public bool BindModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/ModelValidationNodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class ModelValidationNodeTest
    {
        [Fact]
        public void ConstructorSetsCollectionInstance()
        {
            // Arrange
            ModelMetadata metadata = GetModelMetadata();
            string modelStateKey = "someKey";
            ModelValidationNode[] childNodes = new[]
            {
                new ModelValidationNode(metadata, "someKey0"),
                new ModelValidationNode(metadata, "someKey1")
            };

            // Act
            ModelValidationNode node = new ModelValidationNode(metadata, modelStateKey, childNodes);

            // Assert
            Assert.Equal(childNodes, node.ChildNodes.ToArray());
        }

        [Fact]
        public void ConstructorThrowsIfModelMetadataIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ModelValidationNode(null, "someKey"); }, "modelMetadata");
        }

        [Fact]
        public void ConstructorThrowsIfModelStateKeyIsNull()
        {
            // Arrange
            ModelMetadata metadata = GetModelMetadata();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ModelValidationNode(metadata, null); }, "modelStateKey");
        }

        [Fact]
        public void PropertiesAreSet()
        {
            // Arrange
            ModelMetadata metadata = GetModelMetadata();
            string modelStateKey = "someKey";

            // Act
            ModelValidationNode node = new ModelValidationNode(metadata, modelStateKey);

            // Assert
            Assert.Equal(metadata, node.ModelMetadata);
            Assert.Equal(modelStateKey, node.ModelStateKey);
            Assert.NotNull(node.ChildNodes);
            Assert.Empty(node.ChildNodes);
        }

        [Fact]
        public void CombineWith()
        {
            // Arrange
            List<string> log = new List<string>();

            ModelValidationNode[] allChildNodes = new[]
            {
                new ModelValidationNode(GetModelMetadata(), "key1"),
                new ModelValidationNode(GetModelMetadata(), "key2"),
                new ModelValidationNode(GetModelMetadata(), "key3"),
            };

            ModelValidationNode parentNode1 = new ModelValidationNode(GetModelMetadata(), "parent1");
            parentNode1.ChildNodes.Add(allChildNodes[0]);
            parentNode1.Validating += delegate { log.Add("Validating parent1."); };
            parentNode1.Validated += delegate { log.Add("Validated parent1."); };

            ModelValidationNode parentNode2 = new ModelValidationNode(GetModelMetadata(), "parent2");
            parentNode2.ChildNodes.Add(allChildNodes[1]);
            parentNode2.ChildNodes.Add(allChildNodes[2]);
            parentNode2.Validating += delegate { log.Add("Validating parent2."); };
            parentNode2.Validated += delegate { log.Add("Validated parent2."); };

            // Act
            parentNode1.CombineWith(parentNode2);
            parentNode1.Validate(new ControllerContext { Controller = new EmptyController() });

            // Assert
            Assert.Equal(new[] { "Validating parent1.", "Validating parent2.", "Validated parent1.", "Validated parent2." }, log.ToArray());
            Assert.Equal(allChildNodes, parentNode1.ChildNodes.ToArray());
        }

        [Fact]
        public void CombineWith_OtherNodeIsSuppressed_DoesNothing()
        {
            // Arrange
            List<string> log = new List<string>();

            ModelValidationNode[] allChildNodes = new[]
            {
                new ModelValidationNode(GetModelMetadata(), "key1"),
                new ModelValidationNode(GetModelMetadata(), "key2"),
                new ModelValidationNode(GetModelMetadata(), "key3"),
            };

            ModelValidationNode[] expectedChildNodes = new[]
            {
                allChildNodes[0]
            };

            ModelValidationNode parentNode1 = new ModelValidationNode(GetModelMetadata(), "parent1");
            parentNode1.ChildNodes.Add(allChildNodes[0]);
            parentNode1.Validating += delegate { log.Add("Validating parent1."); };
            parentNode1.Validated += delegate { log.Add("Validated parent1."); };

            ModelValidationNode parentNode2 = new ModelValidationNode(GetModelMetadata(), "parent2");
            parentNode2.ChildNodes.Add(allChildNodes[1]);
            parentNode2.ChildNodes.Add(allChildNodes[2]);
            parentNode2.Validating += delegate { log.Add("Validating parent2."); };
            parentNode2.Validated += delegate { log.Add("Validated parent2."); };
            parentNode2.SuppressValidation = true;

            // Act
            parentNode1.CombineWith(parentNode2);
            parentNode1.Validate(new ControllerContext { Controller = new EmptyController() });

            // Assert
            Assert.Equal(new[] { "Validating parent1.", "Validated parent1." }, log.ToArray());
            Assert.Equal(expectedChildNodes, parentNode1.ChildNodes.ToArray());
        }

        [Fact]
        public void Validate_Ordering()
        {
            // Proper order of invocation:
            // 1. OnValidating()
            // 2. Child validators
            // 3. This validator
            // 4. OnValidated()

            // Arrange
            List<string> log = new List<string>();
            LoggingDataErrorInfoModel model = new LoggingDataErrorInfoModel(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);

            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");

            ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(() => model, model.GetType(), "ValidStringProperty");
            node.ChildNodes.Add(new ModelValidationNode(childMetadata, "theKey.ValidStringProperty"));

            node.Validating += delegate { log.Add("In OnValidating()"); };
            node.Validated += delegate { log.Add("In OnValidated()"); };

            // Act
            node.Validate(controllerContext);

            // Assert
            Assert.Equal(new[] { "In OnValidating()", "In IDataErrorInfo.get_Item('ValidStringProperty')", "In IDataErrorInfo.get_Error()", "In OnValidated()" }, log.ToArray());
        }

        [Fact]
        public void Validate_PassesNullContainerInstanceIfCannotBeConvertedToProperType()
        {
            // Arrange
            List<string> log1 = new List<string>();
            LoggingDataErrorInfoModel model1 = new LoggingDataErrorInfoModel(log1);
            ModelMetadata modelMetadata1 = GetModelMetadata(model1);

            List<string> log2 = new List<string>();
            LoggingDataErrorInfoModel model2 = new LoggingDataErrorInfoModel(log2);
            ModelMetadata modelMetadata2 = GetModelMetadata(model2);

            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ModelValidationNode node = new ModelValidationNode(modelMetadata1, "theKey");
            node.ChildNodes.Add(new ModelValidationNode(modelMetadata2, "theKey.SomeProperty"));

            // Act
            node.Validate(controllerContext);

            // Assert
            Assert.Equal(new[] { "In IDataErrorInfo.get_Error()" }, log1.ToArray());
            Assert.Equal(new[] { "In IDataErrorInfo.get_Error()" }, log2.ToArray());
        }

        [Fact]
        public void Validate_SkipsRemainingValidationIfModelStateIsInvalid()
        {
            // Because a property validator fails, the model validator shouldn't run

            // Arrange
            List<string> log = new List<string>();
            LoggingDataErrorInfoModel model = new LoggingDataErrorInfoModel(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);

            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");

            ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(() => model, model.GetType(), "InvalidStringProperty");
            node.ChildNodes.Add(new ModelValidationNode(childMetadata, "theKey.InvalidStringProperty"));

            node.Validating += delegate { log.Add("In OnValidating()"); };
            node.Validated += delegate { log.Add("In OnValidated()"); };

            // Act
            node.Validate(controllerContext);

            // Assert
            Assert.Equal(new[] { "In OnValidating()", "In IDataErrorInfo.get_Item('InvalidStringProperty')", "In OnValidated()" }, log.ToArray());
            Assert.Equal("Sample error message", controllerContext.Controller.ViewData.ModelState["theKey.InvalidStringProperty"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void Validate_SkipsValidationIfHandlerCancels()
        {
            // Arrange
            List<string> log = new List<string>();
            LoggingDataErrorInfoModel model = new LoggingDataErrorInfoModel(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);

            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");

            node.Validating += (sender, e) =>
            {
                log.Add("In OnValidating()");
                e.Cancel = true;
            };
            node.Validated += delegate { log.Add("In OnValidated()"); };

            // Act
            node.Validate(controllerContext);

            // Assert
            Assert.Equal(new[] { "In OnValidating()" }, log.ToArray());
        }

        [Fact]
        public void Validate_SkipsValidationIfSuppressed()
        {
            // Arrange
            List<string> log = new List<string>();
            LoggingDataErrorInfoModel model = new LoggingDataErrorInfoModel(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);

            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey")
            {
                SuppressValidation = true
            };

            node.Validating += (sender, e) => { log.Add("In OnValidating()"); };
            node.Validated += delegate { log.Add("In OnValidated()"); };

            // Act
            node.Validate(controllerContext);

            // Assert
            Assert.Empty(log);
        }

        [Fact]
        public void Validate_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            ModelValidationNode node = new ModelValidationNode(GetModelMetadata(), "someKey");

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { node.Validate(null); }, "controllerContext");
        }

        [Fact]
        [ReplaceCulture]
        public void Validate_ValidateAllProperties_AddsValidationErrors()
        {
            // Arrange
            ValidateAllPropertiesModel model = new ValidateAllPropertiesModel
            {
                RequiredString = null /* error */,
                RangedInt = 0 /* error */,
                ValidString = "dog"
            };

            ModelMetadata modelMetadata = GetModelMetadata(model);
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey")
            {
                ValidateAllProperties = true
            };

            controllerContext.Controller.ViewData.ModelState.AddModelError("theKey.RequiredString.Dummy", "existing Error Text");

            // Act
            node.Validate(controllerContext);

            // Assert
            Assert.Null(controllerContext.Controller.ViewData.ModelState["theKey.RequiredString"]);
            Assert.Equal("existing Error Text", controllerContext.Controller.ViewData.ModelState["theKey.RequiredString.Dummy"].Errors[0].ErrorMessage);
            Assert.Equal("The field RangedInt must be between 10 and 30.", controllerContext.Controller.ViewData.ModelState["theKey.RangedInt"].Errors[0].ErrorMessage);
            Assert.Null(controllerContext.Controller.ViewData.ModelState["theKey.ValidString"]);
            Assert.Null(controllerContext.Controller.ViewData.ModelState["theKey"]);
        }

        private static ModelMetadata GetModelMetadata()
        {
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            return provider.GetMetadataForType(null, typeof(object));
        }

        private static ModelMetadata GetModelMetadata(object o)
        {
            DataAnnotationsModelMetadataProvider provider = new DataAnnotationsModelMetadataProvider();
            return provider.GetMetadataForType(() => o, o.GetType());
        }

        private sealed class EmptyController : Controller
        {
        }

        private sealed class LoggingDataErrorInfoModel : IDataErrorInfo
        {
            private readonly IList<string> _log;

            public LoggingDataErrorInfoModel(IList<string> log)
            {
                _log = log;
            }

            string IDataErrorInfo.Error
            {
                get
                {
                    _log.Add("In IDataErrorInfo.get_Error()");
                    return null;
                }
            }

            string IDataErrorInfo.this[string columnName]
            {
                get
                {
                    _log.Add("In IDataErrorInfo.get_Item('" + columnName + "')");
                    return (columnName == "ValidStringProperty") ? null : "Sample error message";
                }
            }

            public string ValidStringProperty { get; set; }
            public string InvalidStringProperty { get; set; }
        }

        private class ValidateAllPropertiesModel
        {
            [Required]
            public string RequiredString { get; set; }

            [Range(10, 30)]
            public int RangedInt { get; set; }

            [RegularExpression("dog")]
            public string ValidString { get; set; }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/MutableObjectModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class MutableObjectModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_NoPrefixInValueProvider_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => 42, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
            };

            MutableObjectModelBinderProvider binderProvider = new MutableObjectModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_PrefixInValueProvider_ReturnsBinder()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => 42, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo.bar", "someValue" }
                }
            };

            MutableObjectModelBinderProvider binderProvider = new MutableObjectModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.NotNull(binder);
            Assert.IsType<MutableObjectModelBinder>(binder);
        }

        [Fact]
        public void GetBinder_TypeIsComplexModelDto_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ComplexModelDto)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider
                {
                    { "foo.bar", "someValue" }
                }
            };

            MutableObjectModelBinderProvider binderProvider = new MutableObjectModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = binderProvider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/MutableObjectModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class MutableObjectModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelBinderProviders = new ModelBinderProviderCollection(),
                ModelMetadata = GetMetadataForObject(new Person()),
                ModelName = "someName"
            };

            Mock<IExtensibleModelBinder> mockDtoBinder = new Mock<IExtensibleModelBinder>();
            mockDtoBinder
                .Setup(o => o.BindModel(controllerContext, It.IsAny<ExtensibleModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ExtensibleModelBindingContext mbc2)
                    {
                        return true; // just return the DTO unchanged
                    });
            bindingContext.ModelBinderProviders.RegisterBinderForType(typeof(ComplexModelDto), mockDtoBinder.Object, true /* suppressPrefixCheck */);

            Mock<TestableMutableObjectModelBinder> mockTestableBinder = new Mock<TestableMutableObjectModelBinder> { CallBase = true };
            mockTestableBinder.Setup(o => o.EnsureModelPublic(controllerContext, bindingContext)).Verifiable();
            mockTestableBinder.Setup(o => o.GetMetadataForPropertiesPublic(controllerContext, bindingContext)).Returns(new ModelMetadata[0]).Verifiable();
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;
            testableBinder.MetadataProvider = new DataAnnotationsModelMetadataProvider();

            // Act
            bool retValue = testableBinder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.True(retValue);
            Assert.IsType<Person>(bindingContext.Model);
            Assert.True(bindingContext.ValidationNode.ValidateAllProperties);
            mockTestableBinder.Verify();
        }

        [Fact]
        public void CanUpdateProperty_HasPublicSetter_ReturnsTrue()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadWriteString");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.True(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyArray_ReturnsFalse()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyArray");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.False(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyReferenceTypeNotBlacklisted_ReturnsTrue()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyObject");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.True(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyString_ReturnsFalse()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyString");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.False(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyValueType_ReturnsFalse()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyInt");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.False(canUpdate);
        }

        [Fact]
        public void CreateModel()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            object retModel = testableBinder.CreateModelPublic(null, bindingContext);

            // Assert
            Assert.IsType<Person>(retModel);
        }

        [Fact]
        public void CreateModelThrowsIfModelTypeHasNoParameterlessConstructor()
        {
            // Arrange
            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(NoParameterlessCtor)),
            };

            // Act & Assert, confirming type name and full stack are available in Exception
            MissingMethodException exception = Assert.Throws<MissingMethodException>(
                () => testableBinder.CreateModelPublic(null, bindingContext),
                "No parameterless constructor defined for this object. Object type 'Microsoft.Web.Mvc.ModelBinding.Test.MutableObjectModelBinderTest+NoParameterlessCtor'.");
            Assert.Contains("System.Activator.CreateInstance(", exception.ToString());
        }

        [Fact]
        public void EnsureModel_ModelIsNotNull_DoesNothing()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person())
            };

            Mock<TestableMutableObjectModelBinder> mockTestableBinder = new Mock<TestableMutableObjectModelBinder> { CallBase = true };
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;

            // Act
            object originalModel = bindingContext.Model;
            testableBinder.EnsureModelPublic(null, bindingContext);
            object newModel = bindingContext.Model;

            // Assert
            Assert.Same(originalModel, newModel);
            mockTestableBinder.Verify(o => o.CreateModelPublic(null, bindingContext), Times.Never());
        }

        [Fact]
        public void EnsureModel_ModelIsNull_CallsCreateModel()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            Mock<TestableMutableObjectModelBinder> mockTestableBinder = new Mock<TestableMutableObjectModelBinder> { CallBase = true };
            mockTestableBinder.Setup(o => o.CreateModelPublic(null, bindingContext)).Returns(new Person()).Verifiable();
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;

            // Act
            object originalModel = bindingContext.Model;
            testableBinder.EnsureModelPublic(null, bindingContext);
            object newModel = bindingContext.Model;

            // Assert
            Assert.Null(originalModel);
            Assert.IsType<Person>(newModel);
            mockTestableBinder.Verify();
        }

        [Fact]
        public void GetMetadataForProperties_WithBindAttribute()
        {
            // Arrange
            string[] expectedPropertyNames = new[] { "FirstName", "LastName" };

            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(PersonWithBindExclusion))
            };

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            IEnumerable<ModelMetadata> propertyMetadatas = testableBinder.GetMetadataForPropertiesPublic(null, bindingContext);
            string[] returnedPropertyNames = propertyMetadatas.Select(o => o.PropertyName).ToArray();

            // Assert
            Assert.Equal(expectedPropertyNames, returnedPropertyNames);
        }

        [Fact]
        public void GetMetadataForProperties_WithoutBindAttribute()
        {
            // Arrange
            string[] expectedPropertyNames = new[] { "DateOfBirth", "DateOfDeath", "ValueTypeRequired", "FirstName", "LastName", "PropertyWithDefaultValue" };

            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            IEnumerable<ModelMetadata> propertyMetadatas = testableBinder.GetMetadataForPropertiesPublic(null, bindingContext);
            string[] returnedPropertyNames = propertyMetadatas.Select(o => o.PropertyName).ToArray();

            // Assert
            Assert.Equal(expectedPropertyNames, returnedPropertyNames);
        }

        [Fact]
        public void GetRequiredPropertiesCollection_MixedAttributes()
        {
            // Arrange
            Type modelType = typeof(ModelWithMixedBindingBehaviors);

            // Act
            HashSet<string> requiredProperties;
            HashSet<string> skipProperties;
            MutableObjectModelBinder.GetRequiredPropertiesCollection(modelType, out requiredProperties, out skipProperties);

            // Assert
            Assert.Equal(new[] { "Required" }, requiredProperties.ToArray());
            Assert.Equal(new[] { "Never" }, skipProperties.ToArray());
        }

        [Fact]
        public void NullCheckFailedHandler_ModelStateAlreadyInvalid_DoesNothing()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            controllerContext.Controller.ViewData.ModelState.AddModelError("foo.bar", "Some existing error.");

            ModelMetadata modelMetadata = GetMetadataForType(typeof(Person));
            ModelValidationNode validationNode = new ModelValidationNode(modelMetadata, "foo");
            ModelValidatedEventArgs e = new ModelValidatedEventArgs(controllerContext, null /* parentNode */);

            // Act
            EventHandler<ModelValidatedEventArgs> handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(controllerContext, modelMetadata, null /* incomingValue */);
            handler(validationNode, e);

            // Assert
            Assert.False(controllerContext.Controller.ViewData.ModelState.ContainsKey("foo"));
        }

        [Fact]
        public void NullCheckFailedHandler_ModelStateValid_AddsErrorString()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };

            ModelMetadata modelMetadata = GetMetadataForType(typeof(Person));
            ModelValidationNode validationNode = new ModelValidationNode(modelMetadata, "foo");
            ModelValidatedEventArgs e = new ModelValidatedEventArgs(controllerContext, null /* parentNode */);

            // Act
            EventHandler<ModelValidatedEventArgs> handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(controllerContext, modelMetadata, null /* incomingValue */);
            handler(validationNode, e);

            // Assert
            Assert.True(controllerContext.Controller.ViewData.ModelState.ContainsKey("foo"));
            Assert.Equal("A value is required.", controllerContext.Controller.ViewData.ModelState["foo"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void NullCheckFailedHandler_ModelStateValid_CallbackReturnsNull_DoesNothing()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };

            ModelMetadata modelMetadata = GetMetadataForType(typeof(Person));
            ModelValidationNode validationNode = new ModelValidationNode(modelMetadata, "foo");
            ModelValidatedEventArgs e = new ModelValidatedEventArgs(controllerContext, null /* parentNode */);

            // Act
            ModelBinderErrorMessageProvider originalProvider = ModelBinderConfig.ValueRequiredErrorMessageProvider;
            try
            {
                ModelBinderConfig.ValueRequiredErrorMessageProvider = delegate { return null; };
                EventHandler<ModelValidatedEventArgs> handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(controllerContext, modelMetadata, null /* incomingValue */);
                handler(validationNode, e);
            }
            finally
            {
                ModelBinderConfig.ValueRequiredErrorMessageProvider = originalProvider;
            }

            // Assert
            Assert.True(controllerContext.Controller.ViewData.ModelState.IsValid);
        }

        [Fact]
        public void ProcessDto_BindRequiredFieldMissing_Throws()
        {
            // Arrange
            ModelWithBindRequired model = new ModelWithBindRequired
            {
                Name = "original value",
                Age = -20
            };

            ModelMetadata containerMetadata = GetMetadataForObject(model);

            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = containerMetadata,
                ModelName = "theModel"
            };
            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);

            ModelMetadata nameProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "Name");
            dto.Results[nameProperty] = new ComplexModelDtoResult("John Doe", new ModelValidationNode(nameProperty, ""));

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { testableBinder.ProcessDto(controllerContext, bindingContext, dto); },
                @"A value for 'theModel.Age' is required but was not present in the request.");

            Assert.Equal("original value", model.Name);
            Assert.Equal(-20, model.Age);
        }

        [Fact]
        public void ProcessDto_Success()
        {
            // Arrange
            DateTime dob = new DateTime(2001, 1, 1);
            Person model = new Person
            {
                DateOfBirth = dob
            };
            ModelMetadata containerMetadata = GetMetadataForObject(model);

            ControllerContext controllerContext = new ControllerContext();
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = containerMetadata
            };
            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);

            ModelMetadata firstNameProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "FirstName");
            dto.Results[firstNameProperty] = new ComplexModelDtoResult("John", new ModelValidationNode(firstNameProperty, ""));
            ModelMetadata lastNameProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "LastName");
            dto.Results[lastNameProperty] = new ComplexModelDtoResult("Doe", new ModelValidationNode(lastNameProperty, ""));
            ModelMetadata dobProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "DateOfBirth");
            dto.Results[dobProperty] = null;

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.ProcessDto(controllerContext, bindingContext, dto);

            // Assert
            Assert.Equal("John", model.FirstName);
            Assert.Equal("Doe", model.LastName);
            Assert.Equal(dob, model.DateOfBirth);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void SetProperty_PropertyHasDefaultValue_SetsDefaultValue()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person())
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "PropertyWithDefaultValue");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult);

            // Assert
            var person = Assert.IsType<Person>(bindingContext.Model);
            Assert.Equal(123.456m, person.PropertyWithDefaultValue);
            Assert.True(controllerContext.Controller.ViewData.ModelState.IsValid);
        }

        [Fact]
        public void SetProperty_PropertyIsReadOnly_DoesNothing()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "NonUpdateableProperty");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(null, bindingContext, propertyMetadata, dtoResult);

            // Assert
            // If didn't throw, success!
        }

        [Fact]
        public void SetProperty_PropertyIsSettable_CallsSetter()
        {
            // Arrange
            Person model = new Person();
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(model)
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "DateOfBirth");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(new DateTime(2001, 1, 1), validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult);

            // Assert
            validationNode.Validate(controllerContext);
            Assert.True(controllerContext.Controller.ViewData.ModelState.IsValid);
            Assert.Equal(new DateTime(2001, 1, 1), model.DateOfBirth);
        }

        [Fact]
        [ReplaceCulture]
        public void SetProperty_PropertyIsSettable_SetterThrows_RecordsError()
        {
            // Arrange
            Person model = new Person
            {
                DateOfBirth = new DateTime(1900, 1, 1)
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(model)
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "DateOfDeath");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(new DateTime(1800, 1, 1), validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(null, bindingContext, propertyMetadata, dtoResult);

            // Assert
            Assert.Equal("Date of death can't be before date of birth." + Environment.NewLine
                       + "Parameter name: value",
                         bindingContext.ModelState["foo"].Errors[0].Exception.Message);
        }

        [Fact]
        public void SetProperty_SettingNonNullableValueTypeToNull_RequiredValidatorNotPresent_RegistersValidationCallback()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person()),
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "DateOfBirth");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult);

            // Assert
            Assert.True(controllerContext.Controller.ViewData.ModelState.IsValid);
            validationNode.Validate(controllerContext, bindingContext.ValidationNode);
            Assert.False(controllerContext.Controller.ViewData.ModelState.IsValid);
        }

        [Fact]
        public void SetProperty_SettingNonNullableValueTypeToNull_RequiredValidatorPresent_AddsModelError()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person()),
                ModelName = "foo"
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "ValueTypeRequired");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo.ValueTypeRequired");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult);

            // Assert
            Assert.False(bindingContext.ModelState.IsValid);
            Assert.Equal("Sample message", bindingContext.ModelState["foo.ValueTypeRequired"].Errors[0].ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void SetProperty_SettingNullableTypeToNull_RequiredValidatorNotPresent_PropertySetterThrows_AddsRequiredMessageString()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new ModelWhosePropertySetterThrows()),
                ModelName = "foo"
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "NameNoAttribute");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo.NameNoAttribute");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult);

            // Assert
            Assert.False(bindingContext.ModelState.IsValid);
            ModelError error = Assert.Single(bindingContext.ModelState["foo.NameNoAttribute"].Errors);
            Assert.Equal("This is a different exception." + Environment.NewLine
                       + "Parameter name: value",
                         error.Exception.Message);
        }

        [Fact]
        public void SetProperty_SettingNullableTypeToNull_RequiredValidatorPresent_PropertySetterThrows_AddsRequiredMessageString()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext
            {
                Controller = new EmptyController()
            };
            ExtensibleModelBindingContext bindingContext = new ExtensibleModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new ModelWhosePropertySetterThrows()),
                ModelName = "foo"
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "Name");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo.Name");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult);

            // Assert
            Assert.False(bindingContext.ModelState.IsValid);
            ModelError error = Assert.Single(bindingContext.ModelState["foo.Name"].Errors);
            Assert.Equal("This message comes from the [Required] attribute.", error.ErrorMessage);
        }

        private static ModelMetadata GetMetadataForCanUpdateProperty(string propertyName)
        {
            DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            return metadataProvider.GetMetadataForProperty(null, typeof(MyModelTestingCanUpdateProperty), propertyName);
        }

        private static ModelMetadata GetMetadataForObject(object o)
        {
            DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            return metadataProvider.GetMetadataForType(() => o, o.GetType());
        }

        private static ModelMetadata GetMetadataForType(Type t)
        {
            DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            return metadataProvider.GetMetadataForType(null, t);
        }

        private class Person
        {
            private DateTime? _dateOfDeath;

            public DateTime DateOfBirth { get; set; }

            public DateTime? DateOfDeath
            {
                get { return _dateOfDeath; }
                set
                {
                    if (value < DateOfBirth)
                    {
                        throw new ArgumentOutOfRangeException("value", "Date of death can't be before date of birth.");
                    }
                    _dateOfDeath = value;
                }
            }

            [Required(ErrorMessage = "Sample message")]
            public int ValueTypeRequired { get; set; }

            public string FirstName { get; set; }
            public string LastName { get; set; }
            public string NonUpdateableProperty { get; private set; }

            [DefaultValue(typeof(decimal), "123.456")]
            public decimal PropertyWithDefaultValue { get; set; }
        }

        private class NoParameterlessCtor
        {
            public NoParameterlessCtor(int parameter)
            {
            }
        }

        private class PersonWithBindExclusion
        {
            [BindNever]
            public DateTime DateOfBirth { get; set; }

            [BindNever]
            public DateTime? DateOfDeath { get; set; }

            public string FirstName { get; set; }
            public string LastName { get; set; }
            public string NonUpdateableProperty { get; private set; }
        }

        private class ModelWithBindRequired
        {
            public string Name { get; set; }

            [BindRequired]
            public int Age { get; set; }
        }

        [BindRequired]
        private class ModelWithMixedBindingBehaviors
        {
            public string Required { get; set; }

            [BindNever]
            public string Never { get; set; }

            [BindingBehavior(BindingBehavior.Optional)]
            public string Optional { get; set; }
        }

        private sealed class MyModelTestingCanUpdateProperty
        {
            public int ReadOnlyInt { get; private set; }
            public string ReadOnlyString { get; private set; }
            public string[] ReadOnlyArray { get; private set; }
            public object ReadOnlyObject { get; private set; }
            public string ReadWriteString { get; set; }
        }

        private sealed class ModelWhosePropertySetterThrows
        {
            [Required(ErrorMessage = "This message comes from the [Required] attribute.")]
            public string Name
            {
                get { return null; }
                set { throw new ArgumentException("This is an exception.", "value"); }
            }

            public string NameNoAttribute
            {
                get { return null; }
                set { throw new ArgumentException("This is a different exception.", "value"); }
            }
        }

        public class TestableMutableObjectModelBinder : MutableObjectModelBinder
        {
            public virtual bool CanUpdatePropertyPublic(ModelMetadata propertyMetadata)
            {
                return base.CanUpdateProperty(propertyMetadata);
            }

            protected override bool CanUpdateProperty(ModelMetadata propertyMetadata)
            {
                return CanUpdatePropertyPublic(propertyMetadata);
            }

            public virtual object CreateModelPublic(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                return base.CreateModel(controllerContext, bindingContext);
            }

            protected override object CreateModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                return CreateModelPublic(controllerContext, bindingContext);
            }

            public virtual void EnsureModelPublic(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                base.EnsureModel(controllerContext, bindingContext);
            }

            protected override void EnsureModel(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                EnsureModelPublic(controllerContext, bindingContext);
            }

            public virtual IEnumerable<ModelMetadata> GetMetadataForPropertiesPublic(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                return base.GetMetadataForProperties(controllerContext, bindingContext);
            }

            protected override IEnumerable<ModelMetadata> GetMetadataForProperties(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext)
            {
                return GetMetadataForPropertiesPublic(controllerContext, bindingContext);
            }

            public virtual void SetPropertyPublic(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult)
            {
                base.SetProperty(controllerContext, bindingContext, propertyMetadata, dtoResult);
            }

            protected override void SetProperty(ControllerContext controllerContext, ExtensibleModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult)
            {
                SetPropertyPublic(controllerContext, bindingContext, propertyMetadata, dtoResult);
            }
        }

        private class EmptyController : Controller
        {
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/SimpleModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class SimpleModelBinderProviderTest
    {
        [Fact]
        public void ConstructorWithFactoryThrowsIfModelBinderFactoryIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new SimpleModelBinderProvider(typeof(object), (Func<IExtensibleModelBinder>)null); }, "modelBinderFactory");
        }

        [Fact]
        public void ConstructorWithFactoryThrowsIfModelTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new SimpleModelBinderProvider(null, () => null); }, "modelType");
        }

        [Fact]
        public void ConstructorWithInstanceThrowsIfModelBinderIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new SimpleModelBinderProvider(typeof(object), (IExtensibleModelBinder)null); }, "modelBinder");
        }

        [Fact]
        public void ConstructorWithInstanceThrowsIfModelTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new SimpleModelBinderProvider(null, new Mock<IExtensibleModelBinder>().Object); }, "modelType");
        }

        [Fact]
        public void GetBinder_TypeDoesNotMatch_ReturnsNull()
        {
            // Arrange
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), new Mock<IExtensibleModelBinder>().Object)
            {
                SuppressPrefixCheck = true
            };
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(object));

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_TypeMatches_PrefixNotFound_ReturnsNull()
        {
            // Arrange
            IExtensibleModelBinder binderInstance = new Mock<IExtensibleModelBinder>().Object;
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), binderInstance);

            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(string));
            bindingContext.ValueProvider = new SimpleValueProvider();

            // Act
            IExtensibleModelBinder returnedBinder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(returnedBinder);
        }

        [Fact]
        public void GetBinder_TypeMatches_PrefixSuppressed_ReturnsFactoryInstance()
        {
            // Arrange
            int numExecutions = 0;
            IExtensibleModelBinder theBinderInstance = new Mock<IExtensibleModelBinder>().Object;
            Func<IExtensibleModelBinder> factory = delegate
            {
                numExecutions++;
                return theBinderInstance;
            };

            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), factory)
            {
                SuppressPrefixCheck = true
            };
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(string));

            // Act
            IExtensibleModelBinder returnedBinder = provider.GetBinder(null, bindingContext);
            returnedBinder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Equal(2, numExecutions);
            Assert.Equal(theBinderInstance, returnedBinder);
        }

        [Fact]
        public void GetBinder_TypeMatches_PrefixSuppressed_ReturnsInstance()
        {
            // Arrange
            IExtensibleModelBinder theBinderInstance = new Mock<IExtensibleModelBinder>().Object;
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), theBinderInstance)
            {
                SuppressPrefixCheck = true
            };
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(string));

            // Act
            IExtensibleModelBinder returnedBinder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Equal(theBinderInstance, returnedBinder);
        }

        [Fact]
        public void GetBinderThrowsIfBindingContextIsNull()
        {
            // Arrange
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), new Mock<IExtensibleModelBinder>().Object);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { provider.GetBinder(null, null); }, "bindingContext");
        }

        [Fact]
        public void ModelTypeProperty()
        {
            // Arrange
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), new Mock<IExtensibleModelBinder>().Object);

            // Act & assert
            Assert.Equal(typeof(string), provider.ModelType);
        }

        private static ExtensibleModelBindingContext GetBindingContext(Type modelType)
        {
            return new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => null, modelType)
            };
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/TypeConverterModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class TypeConverterModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_NoTypeConverterExistsFromString_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(void)); // no TypeConverter exists Void -> String

            TypeConverterModelBinderProvider provider = new TypeConverterModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_NullValueProviderResult_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleValueProvider(); // clear the ValueProvider

            TypeConverterModelBinderProvider provider = new TypeConverterModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_TypeConverterExistsFromString_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(int)); // TypeConverter exists Int32 -> String

            TypeConverterModelBinderProvider provider = new TypeConverterModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<TypeConverterModelBinder>(binder);
        }

        private static ExtensibleModelBindingContext GetBindingContext(Type modelType)
        {
            return new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName",
                ValueProvider = new SimpleValueProvider
                {
                    { "theModelName", "someValue" }
                }
            };
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/TypeConverterModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using System.Globalization;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class TypeConverterModelBinderTest
    {
        [Fact]
        public void BindModel_Error_FormatExceptionsTurnedIntoStringsInModelState()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Equal("The value 'not an integer' is not valid for Int32.", bindingContext.ModelState["theModelName"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void BindModel_Error_FormatExceptionsTurnedIntoStringsInModelState_ErrorNotAddedIfCallbackReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            ModelBinderErrorMessageProvider originalProvider = ModelBinderConfig.TypeConversionErrorMessageProvider;
            bool retVal;
            try
            {
                ModelBinderConfig.TypeConversionErrorMessageProvider = delegate { return null; };
                retVal = binder.BindModel(null, bindingContext);
            }
            finally
            {
                ModelBinderConfig.TypeConversionErrorMessageProvider = originalProvider;
            }

            // Assert
            Assert.False(retVal);
            Assert.Null(bindingContext.Model);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void BindModel_Error_GeneralExceptionsSavedInModelState()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(Dummy));
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "foo" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Null(bindingContext.Model);
            Assert.Equal("The parameter conversion from type 'System.String' to type 'Microsoft.Web.Mvc.ModelBinding.Test.TypeConverterModelBinderTest+Dummy' failed. See the inner exception for more information.", bindingContext.ModelState["theModelName"].Errors[0].Exception.Message);
            Assert.Equal("From DummyTypeConverter: foo", bindingContext.ModelState["theModelName"].Errors[0].Exception.InnerException.Message);
        }

        [Fact]
        public void BindModel_NullValueProviderResult_ReturnsFalse()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(int));

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal, "BindModel should have returned null.");
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ConvertEmptyStringsToNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(string));
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Null(bindingContext.Model);
            Assert.True(bindingContext.ModelState.ContainsKey("theModelName"));
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ReturnsModel()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "42" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(42, bindingContext.Model);
            Assert.True(bindingContext.ModelState.ContainsKey("theModelName"));
        }

        private static ExtensibleModelBindingContext GetBindingContext(Type modelType)
        {
            return new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName",
                ValueProvider = new SimpleValueProvider() // empty
            };
        }

        [TypeConverter(typeof(DummyTypeConverter))]
        private struct Dummy
        {
        }

        private sealed class DummyTypeConverter : TypeConverter
        {
            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
            {
                return (sourceType == typeof(string)) || base.CanConvertFrom(context, sourceType);
            }

            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
            {
                throw new InvalidOperationException(String.Format("From DummyTypeConverter: {0}", value));
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/TypeMatchModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class TypeMatchModelBinderProviderTest
    {
        [Fact]
        public void ProviderIsMarkedFrontOfList()
        {
            // Arrange
            Type t = typeof(TypeMatchModelBinderProvider);

            // Act & assert
            Assert.True(t.GetCustomAttributes(typeof(ModelBinderProviderOptionsAttribute), true /* inherit */).Cast<ModelBinderProviderOptionsAttribute>().Single().FrontOfList);
        }

        [Fact]
        public void GetBinder_InvalidValueProviderResult_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeMatchModelBinderProvider provider = new TypeMatchModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ReturnsBinder()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", 42 }
            };

            TypeMatchModelBinderProvider provider = new TypeMatchModelBinderProvider();

            // Act
            IExtensibleModelBinder binder = provider.GetBinder(null, bindingContext);

            // Assert
            Assert.IsType<TypeMatchModelBinder>(binder);
        }

        private static ExtensibleModelBindingContext GetBindingContext()
        {
            return GetBindingContext(typeof(int));
        }

        private static ExtensibleModelBindingContext GetBindingContext(Type modelType)
        {
            return new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName"
            };
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/ModelBinding/Test/TypeMatchModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.ModelBinding.Test
{
    public class TypeMatchModelBinderTest
    {
        [Fact]
        public void BindModel_InvalidValueProviderResult_ReturnsFalse()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeMatchModelBinder binder = new TypeMatchModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ReturnsTrue()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", 42 }
            };

            TypeMatchModelBinder binder = new TypeMatchModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(42, bindingContext.Model);
            Assert.True(bindingContext.ModelState.ContainsKey("theModelName"));
        }

        [Fact]
        public void GetCompatibleValueProviderResult_ValueProviderResultRawValueIncorrect_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", "not an integer" }
            };

            // Act
            ValueProviderResult vpResult = TypeMatchModelBinder.GetCompatibleValueProviderResult(bindingContext);

            // Assert
            Assert.Null(vpResult); // Raw value is the wrong type
        }

        [Fact]
        public void GetCompatibleValueProviderResult_ValueProviderResultValid_ReturnsValueProviderResult()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleValueProvider
            {
                { "theModelName", 42 }
            };

            // Act
            ValueProviderResult vpResult = TypeMatchModelBinder.GetCompatibleValueProviderResult(bindingContext);

            // Assert
            Assert.NotNull(vpResult);
        }

        [Fact]
        public void GetCompatibleValueProviderResult_ValueProviderReturnsNull_ReturnsNull()
        {
            // Arrange
            ExtensibleModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleValueProvider();

            // Act
            ValueProviderResult vpResult = TypeMatchModelBinder.GetCompatibleValueProviderResult(bindingContext);

            // Assert
            Assert.Null(vpResult); // No key matched
        }

        private static ExtensibleModelBindingContext GetBindingContext()
        {
            return GetBindingContext(typeof(int));
        }

        private static ExtensibleModelBindingContext GetBindingContext(Type modelType)
        {
            return new ExtensibleModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName"
            };
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/AcceptAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class AcceptAttributeTest
    {
        [Fact]
        public void DefaultIsEmpty()
        {
            Assert.True(String.IsNullOrEmpty(new AcceptAttribute().MimeTypes));
        }

        [Fact]
        public void ClientRule()
        {
            // Arrange
            var attribute = new AcceptAttribute { MimeTypes = " text/html , application/javascript " };
            var provider = new Mock<ModelMetadataProvider>();
            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");

            // Act
            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();

            // Assert
            Assert.Equal("accept", clientRule.ValidationType);
            Assert.Equal("The PropertyName field only accepts files with one of the following content types: text/html, application/javascript.", clientRule.ErrorMessage);
            Assert.Single(clientRule.ValidationParameters);
            Assert.Equal("text/html,application/javascript", clientRule.ValidationParameters["mimetype"]);
        }

        [Fact]
        public void IsValidTests()
        {
            // Arrange
            var attribute = new AcceptAttribute { MimeTypes = " text/html , application/javascript " };

            // Act & Assert
            Assert.True(attribute.IsValid(null)); // Optional values are always valid
            Assert.True(attribute.IsValid("text/html"));
            Assert.True(attribute.IsValid("application/javascript"));
            Assert.False(attribute.IsValid("text/css"));
            Assert.False(attribute.IsValid("\0text/html")); // Illegal character
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/AjaxOnlyAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class AjaxOnlyAttributeTest
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHeaderNotPresent()
        {
            // Arrange
            AjaxOnlyAttribute attr = new AjaxOnlyAttribute();
            ControllerContext controllerContext = GetControllerContext(containsHeader: false);

            // Act
            bool isValid = attr.IsValidForRequest(controllerContext, null);

            // Assert
            Assert.False(isValid);
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHeaderIsPresent()
        {
            // Arrange
            AjaxOnlyAttribute attr = new AjaxOnlyAttribute();
            ControllerContext controllerContext = GetControllerContext(containsHeader: true);

            // Act
            bool isValid = attr.IsValidForRequest(controllerContext, null);

            // Assert
            Assert.True(isValid);
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            // Arrange
            AjaxOnlyAttribute attr = new AjaxOnlyAttribute();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.IsValidForRequest(null, null); }, "controllerContext");
        }

        private static ControllerContext GetControllerContext(bool containsHeader)
        {
            Mock<ControllerContext> mockContext = new Mock<ControllerContext>();

            NameValueCollection nvc = new NameValueCollection();
            if (containsHeader)
            {
                nvc["X-Requested-With"] = "XMLHttpRequest";
            }

            mockContext.Setup(o => o.HttpContext.Request.Headers).Returns(nvc);
            mockContext.Setup(o => o.HttpContext.Request["X-Requested-With"]).Returns("XMLHttpRequest"); // always assume the request contains this, e.g. as a form value

            return mockContext.Object;
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/AreaHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class AreaHelpersTest
    {
        [Fact]
        public void GetAreaNameFromAreaRouteCollectionRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("area_name", routes);
            Route route = context.MapRoute(null, "the_url");

            // Act
            string areaName = AreaHelpers.GetAreaName(route);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameFromIAreaAssociatedItem()
        {
            // Arrange
            CustomRouteWithArea route = new CustomRouteWithArea();

            // Act
            string areaName = AreaHelpers.GetAreaName(route);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameFromRouteData()
        {
            // Arrange
            RouteData routeData = new RouteData();
            routeData.DataTokens["area"] = "area_name";

            // Act
            string areaName = AreaHelpers.GetAreaName(routeData);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameFromRouteDataFallsBackToRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("area_name", routes);
            Route route = context.MapRoute(null, "the_url");
            RouteData routeData = new RouteData(route, new MvcRouteHandler());

            // Act
            string areaName = AreaHelpers.GetAreaName(routeData);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameReturnsNullIfRouteNotAreaAware()
        {
            // Arrange
            Route route = new Route("the_url", new MvcRouteHandler());

            // Act
            string areaName = AreaHelpers.GetAreaName(route);

            // Assert
            Assert.Null(areaName);
        }

        private class CustomRouteWithArea : RouteBase, IRouteWithArea
        {
            public string Area
            {
                get { return "area_name"; }
            }

            public override RouteData GetRouteData(HttpContextBase httpContext)
            {
                throw new NotImplementedException();
            }

            public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/AsyncManagerExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Threading;
using System.Web.Mvc.Async;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class AsyncManagerExtensionsTest
    {
        [Fact]
        public void RegisterTask_AsynchronousCompletion()
        {
            // Arrange
            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
            AsyncManager asyncManager = new AsyncManager(syncContext);
            bool endDelegateWasCalled = false;

            using (ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */))
            {
                Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
                {
                    Assert.Equal(1, asyncManager.OutstandingOperations.Count);
                    MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */);
                    ThreadPool.QueueUserWorkItem(_ =>
                    {
                        Assert.Equal(1, asyncManager.OutstandingOperations.Count);
                        callback(asyncResult);
                        waitHandle.Set();
                    });
                    return asyncResult;
                };
                Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; };

                // Act
                asyncManager.RegisterTask(beginDelegate, endDelegate);
                waitHandle.WaitOne();

                // Assert
                Assert.True(endDelegateWasCalled);
                Assert.True(syncContext.SendWasCalled);
                Assert.Equal(0, asyncManager.OutstandingOperations.Count);
            }
        }

        [Fact]
        public void RegisterTask_AsynchronousCompletion_SwallowsExceptionsThrownByEndDelegate()
        {
            // Arrange
            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
            AsyncManager asyncManager = new AsyncManager(syncContext);
            bool endDelegateWasCalled = false;

            using (ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */))
            {
                Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
                {
                    MockAsyncResult asyncResult = new MockAsyncResult(false /* completedSynchronously */);
                    ThreadPool.QueueUserWorkItem(_ =>
                    {
                        callback(asyncResult);
                        waitHandle.Set();
                    });
                    return asyncResult;
                };
                Action<IAsyncResult> endDelegate = delegate
                {
                    endDelegateWasCalled = true;
                    throw new Exception("This is a sample exception.");
                };

                // Act
                asyncManager.RegisterTask(beginDelegate, endDelegate);
                waitHandle.WaitOne();

                // Assert
                Assert.True(endDelegateWasCalled);
                Assert.Equal(0, asyncManager.OutstandingOperations.Count);
            }
        }

        [Fact]
        public void RegisterTask_ResetsOutstandingOperationCountIfBeginMethodThrows()
        {
            // Arrange
            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
            AsyncManager asyncManager = new AsyncManager(syncContext);

            Func<AsyncCallback, IAsyncResult> beginDelegate = cb => { throw new InvalidOperationException("BeginDelegate throws."); };
            Action<IAsyncResult> endDelegate = ar => { Assert.True(false, "This should never be called."); };

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { asyncManager.RegisterTask(beginDelegate, endDelegate); }, "BeginDelegate throws.");

            Assert.Equal(0, asyncManager.OutstandingOperations.Count);
        }

        [Fact]
        public void RegisterTask_SynchronousCompletion()
        {
            // Arrange
            SimpleSynchronizationContext syncContext = new SimpleSynchronizationContext();
            AsyncManager asyncManager = new AsyncManager(syncContext);
            bool endDelegateWasCalled = false;

            Func<AsyncCallback, IAsyncResult> beginDelegate = callback =>
            {
                Assert.Equal(1, asyncManager.OutstandingOperations.Count);
                MockAsyncResult asyncResult = new MockAsyncResult(true /* completedSynchronously */);
                callback(asyncResult);
                return asyncResult;
            };
            Action<IAsyncResult> endDelegate = delegate { endDelegateWasCalled = true; };

            // Act
            asyncManager.RegisterTask(beginDelegate, endDelegate);

            // Assert
            Assert.True(endDelegateWasCalled);
            Assert.False(syncContext.SendWasCalled);
            Assert.Equal(0, asyncManager.OutstandingOperations.Count);
        }

        [Fact]
        public void RegisterTask_ThrowsIfAsyncManagerIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { AsyncManagerExtensions.RegisterTask(null, _ => null, _ => { }); }, "asyncManager");
        }

        [Fact]
        public void RegisterTask_ThrowsIfBeginDelegateIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new AsyncManager().RegisterTask(null, _ => { }); }, "beginDelegate");
        }

        [Fact]
        public void RegisterTask_ThrowsIfEndDelegateIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new AsyncManager().RegisterTask(_ => null, null); }, "endDelegate");
        }

        private class SimpleSynchronizationContext : SynchronizationContext
        {
            public bool SendWasCalled;

            public override void Send(SendOrPostCallback d, object state)
            {
                SendWasCalled = true;
                d(state);
            }
        }

        private class MockAsyncResult : IAsyncResult
        {
            private readonly bool _completedSynchronously;

            public MockAsyncResult(bool completedSynchronously)
            {
                _completedSynchronously = completedSynchronously;
            }

            public object AsyncState
            {
                get { throw new NotImplementedException(); }
            }

            public WaitHandle AsyncWaitHandle
            {
                get { throw new NotImplementedException(); }
            }

            public bool CompletedSynchronously
            {
                get { return _completedSynchronously; }
            }

            public bool IsCompleted
            {
                get { throw new NotImplementedException(); }
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ButtonTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class ButtonTest
    {
        [Fact]
        public void ButtonWithNullNameThrowsArgumentNullException()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            Assert.ThrowsArgumentNull(() => html.Button(null, "text", HtmlButtonType.Button), "name");
        }

        [Fact]
        public void ButtonRendersBaseAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset, "onclickAttr");
            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" type=\"reset\">buttonText</button>", result.ToHtmlString());
        }

        [Fact]
        public void ButtonWithoutOnClickDoesNotRenderOnclickAttribute()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset);
            Assert.Equal("<button name=\"nameAttr\" type=\"reset\">buttonText</button>", result.ToHtmlString());
        }

        [Fact]
        public void ButtonAllowsInnerHtml()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString result = html.Button("nameAttr", "<img src=\"puppy.jpg\" />", HtmlButtonType.Submit, "onclickAttr");
            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" type=\"submit\"><img src=\"puppy.jpg\" /></button>", result.ToHtmlString());
        }

        [Fact]
        public void ButtonRendersExplicitAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset, "onclickAttr", new { title = "the-title" });
            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" title=\"the-title\" type=\"reset\">buttonText</button>", result.ToHtmlString());
        }

        [Fact]
        public void ButtonRendersExplicitAttributesWithUnderscores()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Reset, "onclickAttr", new { foo_bar = "baz" });
            Assert.Equal("<button foo-bar=\"baz\" name=\"nameAttr\" onclick=\"onclickAttr\" type=\"reset\">buttonText</button>", result.ToHtmlString());
        }

        [Fact]
        public void ButtonRendersExplicitDictionaryAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString result = html.Button("nameAttr", "buttonText", HtmlButtonType.Button, "onclickAttr", new RouteValueDictionary(new { title = "the-title" }));
            Assert.Equal("<button name=\"nameAttr\" onclick=\"onclickAttr\" title=\"the-title\" type=\"button\">buttonText</button>", result.ToHtmlString());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ContentTypeAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class ContentTypeAttributeTest
    {
        [Fact]
        public void ContentTypeSetInCtor()
        {
            var attr = new ContentTypeAttribute("text/html");
            Assert.Equal("text/html", attr.ContentType);
        }

        [Fact]
        public void ContentTypeCtorThrowsArgumentExceptionWhenContentTypeIsNull()
        {
            Assert.ThrowsArgumentNullOrEmpty(() => new ContentTypeAttribute(null), "contentType");
        }

        [Fact]
        public void ExecuteResultSetsContentType()
        {
            var mockHttpResponse = new Mock<HttpResponseBase>();
            var mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.Response).Returns(mockHttpResponse.Object);

            var mockController = new Mock<Controller>();
            var controllerContext = new ControllerContext(new RequestContext(mockHttpContext.Object, new RouteData()), mockController.Object);
            var result = new ContentResult { Content = "blah blah" };
            var filterContext = new ResultExecutingContext(controllerContext, result);

            var filter = new ContentTypeAttribute("text/xml");
            filter.OnResultExecuting(filterContext);

            mockHttpResponse.VerifySet(r => r.ContentType = "text/xml");
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ControllerExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class ControllerExtensionsTest
    {
        private const string AppPathModifier = MvcHelper.AppPathModifier;

        [Fact]
        public void RedirectToAction_DifferentController()
        {
            // Act
            RedirectToRouteResult result = new SampleController().RedirectToAction<DifferentController>(x => x.SomeOtherMethod(84));

            // Assert
            Assert.NotNull(result);
            Assert.Equal("", result.RouteName);
            Assert.Equal(3, result.RouteValues.Count);
            Assert.Equal("Different", result.RouteValues["controller"]);
            Assert.Equal("SomeOtherMethod", result.RouteValues["action"]);
            Assert.Equal(84, result.RouteValues["someOtherParameter"]);
        }

        [Fact]
        public void RedirectToAction_SameController()
        {
            // Act
            RedirectToRouteResult result = new SampleController().RedirectToAction(x => x.SomeMethod(42));

            // Assert
            Assert.NotNull(result);
            Assert.Equal("", result.RouteName);
            Assert.Equal(3, result.RouteValues.Count);
            Assert.Equal("Sample", result.RouteValues["controller"]);
            Assert.Equal("SomeMethod", result.RouteValues["action"]);
            Assert.Equal(42, result.RouteValues["someParameter"]);
        }

        [Fact]
        public void RedirectToAction_ThrowsIfControllerIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ((SampleController)null).RedirectToAction(x => x.SomeMethod(42)); }, "controller");
        }

        private class SampleController : Controller
        {
            public ActionResult SomeMethod(int someParameter)
            {
                throw new NotImplementedException();
            }
        }

        private class DifferentController : Controller
        {
            public ActionResult SomeOtherMethod(int someOtherParameter)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/CookieValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class CookieValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            HttpCookieCollection cookies = new HttpCookieCollection
            {
                new HttpCookie("foo", "fooValue"),
                new HttpCookie("bar.baz", "barBazValue"),
                new HttpCookie("", "emptyValue"),
                new HttpCookie(null, "nullValue")
            };

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.Cookies).Returns(cookies);

            CookieValueProviderFactory factory = new CookieValueProviderFactory();

            // Act
            IValueProvider provider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Null(provider.GetValue(""));
            Assert.True(provider.ContainsPrefix("bar"));
            Assert.Equal("fooValue", provider.GetValue("foo").AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, provider.GetValue("foo").Culture);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/CopyAsyncParametersAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class CopyAsyncParametersAttributeTest
    {
        [Fact]
        public void OnActionExecuting_CopiesParametersIfControllerIsAsync()
        {
            // Arrange
            CopyAsyncParametersAttribute attr = new CopyAsyncParametersAttribute();
            SampleAsyncController controller = new SampleAsyncController();

            ActionExecutingContext filterContext = new ActionExecutingContext
            {
                ActionParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase),
                Controller = controller
            };
            filterContext.ActionParameters["foo"] = "fooAction";
            filterContext.ActionParameters["bar"] = "barAction";
            controller.AsyncManager.Parameters["bar"] = "barAsync";
            controller.AsyncManager.Parameters["baz"] = "bazAsync";

            // Act
            attr.OnActionExecuting(filterContext);

            // Assert
            Assert.Equal("fooAction", controller.AsyncManager.Parameters["foo"]);
            Assert.Equal("barAction", controller.AsyncManager.Parameters["bar"]);
            Assert.Equal("bazAsync", controller.AsyncManager.Parameters["baz"]);
        }

        [Fact]
        public void OnActionExecuting_DoesNothingIfControllerNotAsync()
        {
            // Arrange
            CopyAsyncParametersAttribute attr = new CopyAsyncParametersAttribute();
            SampleSyncController controller = new SampleSyncController();

            ActionExecutingContext filterContext = new ActionExecutingContext
            {
                ActionParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase),
                Controller = controller
            };
            filterContext.ActionParameters["foo"] = "originalFoo";
            filterContext.ActionParameters["bar"] = "originalBar";

            // Act
            attr.OnActionExecuting(filterContext);

            // Assert
            // If we got this far without crashing, life is good :)
        }

        [Fact]
        public void OnActionExecuting_ThrowsIfFilterContextIsNull()
        {
            // Arrange
            CopyAsyncParametersAttribute attr = new CopyAsyncParametersAttribute();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnActionExecuting(null); }, "filterContext");
        }

        private class SampleSyncController : Controller
        {
        }

        private class SampleAsyncController : AsyncController
        {
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/CreditCardAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class CreditCardAttributeTest
    {
        [Fact]
        public void ClientRule()
        {
            // Arrange
            var attribute = new CreditCardAttribute();
            var provider = new Mock<ModelMetadataProvider>();
            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");

            // Act
            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();

            // Assert
            Assert.Equal("creditcard", clientRule.ValidationType);
            Assert.Equal("The PropertyName field is not a valid credit card number.", clientRule.ErrorMessage);
            Assert.Empty(clientRule.ValidationParameters);
        }

        [Fact]
        public void IsValidTests()
        {
            // Arrange
            var attribute = new CreditCardAttribute();

            // Act & Assert
            Assert.True(attribute.IsValid(null)); // Optional values are always valid
            Assert.True(attribute.IsValid("0000000000000000")); // Simplest valid value
            Assert.True(attribute.IsValid("1234567890123452")); // Good checksum
            Assert.True(attribute.IsValid("1234-5678-9012-3452")); // Good checksum, with dashes
            Assert.False(attribute.IsValid("0000000000000001")); // Bad checksum
            Assert.False(attribute.IsValid(0)); // Non-string
            Assert.False(attribute.IsValid("000%000000000001")); // Non-digit
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/CssExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class CssExtensionsTests
    {
        [Fact]
        public void CssWithoutFileThrowsArgumentNullException()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Assert
            Assert.ThrowsArgumentNullOrEmpty(() => html.Css(null), "file");
        }

        [Fact]
        public void CssWithRootedPathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("~/Correct/Path.css");

            // Assert
            Assert.Equal("<link href=\"/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithRelativePathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("../../Correct/Path.css");

            // Assert
            Assert.Equal("<link href=\"../../Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithRelativeCurrentPathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("/Correct/Path.css");

            // Assert
            Assert.Equal("<link href=\"/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithContentRelativePathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("Correct/Path.css");

            // Assert
            Assert.Equal("<link href=\"/Content/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithNullMediaTypeRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("Correct/Path.css", null);

            // Assert
            Assert.Equal("<link href=\"/Content/Correct/Path.css\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithEmptyMediaTypeRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("Correct/Path.css", String.Empty);

            // Assert
            Assert.Equal("<link href=\"/Content/Correct/Path.css\" media=\"\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithMediaTypeRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("Correct/Path.css", "Print");

            // Assert
            Assert.Equal("<link href=\"/Content/Correct/Path.css\" media=\"Print\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithUrlRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("http://ajax.Correct.com/Path.js");

            // Assert
            Assert.Equal("<link href=\"http://ajax.Correct.com/Path.js\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }

        [Fact]
        public void CssWithSecureUrlRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Css("https://ajax.Correct.com/Path.js");

            // Assert
            Assert.Equal("<link href=\"https://ajax.Correct.com/Path.js\" rel=\"stylesheet\" type=\"text/css\" />", result.ToHtmlString());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/DeserializeAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Runtime.Serialization;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class DeserializeAttributeTest
    {
        [Fact]
        public void BinderReturnsDeserializedValue()
        {
            // Arrange
            Mock<MvcSerializer> mockSerializer = new Mock<MvcSerializer>();
            mockSerializer.Setup(o => o.Deserialize("some-value")).Returns(42);
            DeserializeAttribute attr = new DeserializeAttribute() { Serializer = mockSerializer.Object };

            IModelBinder binder = attr.GetBinder();
            ModelBindingContext mbContext = new ModelBindingContext
            {
                ModelName = "someKey",
                ValueProvider = new SimpleValueProvider
                {
                    { "someKey", "some-value" }
                }
            };

            // Act
            object retVal = binder.BindModel(null, mbContext);

            // Assert
            Assert.Equal(42, retVal);
        }

        [Fact]
        public void BinderReturnsNullIfValueProviderDoesNotContainKey()
        {
            // Arrange
            DeserializeAttribute attr = new DeserializeAttribute();
            IModelBinder binder = attr.GetBinder();
            ModelBindingContext mbContext = new ModelBindingContext
            {
                ModelName = "someKey",
                ValueProvider = new SimpleValueProvider()
            };

            // Act
            object retVal = binder.BindModel(null, mbContext);

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void BinderThrowsIfBindingContextIsNull()
        {
            // Arrange
            DeserializeAttribute attr = new DeserializeAttribute();
            IModelBinder binder = attr.GetBinder();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { binder.BindModel(null, null); }, "bindingContext");
        }

        [Fact]
        public void BinderThrowsIfDataCorrupt()
        {
            // Arrange
            Mock<MvcSerializer> mockSerializer = new Mock<MvcSerializer>();
            mockSerializer.Setup(o => o.Deserialize(It.IsAny<string>())).Throws(new SerializationException());
            DeserializeAttribute attr = new DeserializeAttribute { Serializer = mockSerializer.Object };

            IModelBinder binder = attr.GetBinder();
            ModelBindingContext mbContext = new ModelBindingContext
            {
                ModelName = "someKey",
                ValueProvider = new SimpleValueProvider
                {
                    { "someKey", "This data is corrupted." }
                }
            };

            // Act & assert
            Exception exception = Assert.Throws<SerializationException>(
                delegate { binder.BindModel(null, mbContext); });
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/DynamicReflectionObjectTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class DynamicReflectionObjectTest
    {
        [Fact]
        public void NoPropertiesThrows()
        {
            // Arrange
            dynamic dro = DynamicReflectionObject.Wrap(new { });

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => dro.baz,
                "The property baz doesn't exist. There are no public properties on this object.");
        }

        [Fact]
        public void UnknownPropertyThrows()
        {
            // Arrange
            dynamic dro = DynamicReflectionObject.Wrap(new { foo = 3.4, biff = "Two", bar = 1 });

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => dro.baz,
                "The property baz doesn't exist. Supported properties are: bar, biff, foo.");
        }

        [Fact]
        public void CanAccessProperties()
        {
            // Arrange
            dynamic dro = DynamicReflectionObject.Wrap(new { foo = "Hello world!", bar = 42 });

            // Act & Assert
            Assert.Equal("Hello world!", dro.foo);
            Assert.Equal(42, dro.bar);
        }

        [Fact]
        public void CanAccessNestedAnonymousProperties()
        {
            // Arrange
            dynamic dro = DynamicReflectionObject.Wrap(new { foo = new { bar = "Hello world!" } });

            // Act & Assert
            Assert.Equal("Hello world!", dro.foo.bar);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/DynamicViewDataDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class DynamicViewDataDictionaryTest
    {
        // Property-style accessor

        [Fact]
        public void Property_UnknownItemReturnsEmptyString()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);

            // Act
            object result = dvdd.Foo;

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void Property_CanAccessViewDataValues()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["Foo"] = "Value for Foo";
            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);

            // Act
            object result = dvdd.Foo;

            // Assert
            Assert.Equal("Value for Foo", result);
        }

        [Fact]
        public void Property_CanAccessModelProperties()
        {
            ViewDataDictionary vdd = new ViewDataDictionary(new { Foo = "Value for Foo" });
            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);

            // Act
            object result = dvdd.Foo;

            // Assert
            Assert.Equal("Value for Foo", result);
        }

        // Index-style accessor

        [Fact]
        public void Indexer_GuardClauses()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => { var x = dvdd["foo", "bar"]; },
                "DynamicViewDataDictionary only supports single indexers.");

            Assert.Throws<ArgumentException>(
                () => { var x = dvdd[42]; },
                "DynamicViewDataDictionary only supports string-based indexers.");
        }

        [Fact]
        public void Indexer_UnknownItemReturnsEmptyString()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);

            // Act
            object result = dvdd["Foo"];

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void Indexer_CanAccessViewDataValues()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["Foo"] = "Value for Foo";
            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);

            // Act
            object result = dvdd["Foo"];

            // Assert
            Assert.Equal("Value for Foo", result);
        }

        [Fact]
        public void Indexer_CanAccessModelProperties()
        {
            ViewDataDictionary vdd = new ViewDataDictionary(new { Foo = "Value for Foo" });
            dynamic dvdd = DynamicViewDataDictionary.Wrap(vdd);

            // Act
            object result = dvdd["Foo"];

            // Assert
            Assert.Equal("Value for Foo", result);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/DynamicViewPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class DynamicViewPageTest
    {
        // DynamicViewPage

        [Fact]
        public void AnonymousObjectsAreWrapped()
        {
            // Arrange
            DynamicViewPage page = new DynamicViewPage();
            page.ViewData.Model = new { foo = "Hello world!" };

            // Act & Assert
            Assert.Equal("Microsoft.Web.Mvc.DynamicReflectionObject", page.Model.GetType().FullName);
        }

        [Fact]
        public void NonAnonymousObjectsAreNotWrapped()
        {
            // Arrange
            DynamicViewPage page = new DynamicViewPage();
            page.ViewData.Model = "Hello world!";

            // Act & Assert
            Assert.Equal(typeof(string), page.Model.GetType());
        }

        [Fact]
        public void ViewDataDictionaryIsWrapped()
        {
            // Arrange
            DynamicViewPage page = new DynamicViewPage();

            // Act & Assert
            Assert.Equal("Microsoft.Web.Mvc.DynamicViewDataDictionary", page.ViewData.GetType().FullName);
        }

        // DynamicViewPage<T>

        [Fact]
        public void Generic_ViewDataDictionaryIsWrapped()
        {
            // Arrange
            DynamicViewPage<object> page = new DynamicViewPage<object>();

            // Act & Assert
            Assert.Equal("Microsoft.Web.Mvc.DynamicViewDataDictionary", page.ViewData.GetType().FullName);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ElementalValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Globalization;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class ElementalValueProviderTest
    {
        [Fact]
        public void ContainsPrefix()
        {
            // Arrange
            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", 42, null);

            // Act & assert
            Assert.True(valueProvider.ContainsPrefix("foo"));
            Assert.False(valueProvider.ContainsPrefix("bar"));
        }

        [Fact]
        public void GetValue_NameDoesNotMatch_ReturnsNull()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            DateTime rawValue = new DateTime(2001, 1, 2);
            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", rawValue, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("bar");

            // Assert
            Assert.Null(vpResult);
        }

        [Fact]
        public void GetValue_NameMatches_ReturnsValueProviderResult()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            DateTime rawValue = new DateTime(2001, 1, 2);
            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", rawValue, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("FOO");

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(rawValue, vpResult.RawValue);
            Assert.Equal("02/01/2001 00:00:00", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/EmailAddressAttribueTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class EmailAddressAttribueTest
    {
        [Fact]
        public void ClientRule()
        {
            // Arrange
            var attribute = new EmailAddressAttribute();
            var provider = new Mock<ModelMetadataProvider>();
            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");

            // Act
            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();

            // Assert
            Assert.Equal("email", clientRule.ValidationType);
            Assert.Equal("The PropertyName field is not a valid e-mail address.", clientRule.ErrorMessage);
            Assert.Empty(clientRule.ValidationParameters);
        }

        [Fact]
        public void IsValidTests()
        {
            // Arrange
            var attribute = new EmailAddressAttribute();

            // Act & Assert
            Assert.True(attribute.IsValid(null)); // Optional values are always valid
            Assert.True(attribute.IsValid("joe@contoso.com"));
            Assert.True(attribute.IsValid("joe%fred@contoso.com"));
            Assert.False(attribute.IsValid("joe"));
            Assert.False(attribute.IsValid("joe@"));
            Assert.False(attribute.IsValid("joe@contoso"));
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ExpressionHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using ExpressionHelper = Microsoft.Web.Mvc.Internal.ExpressionHelper;

namespace Microsoft.Web.Mvc.Test
{
    public class ExpressionHelperTest
    {
        [Fact]
        public void BuildRouteValueDictionary_TargetsAsynchronousAsyncMethod_StripsSuffix()
        {
            // Arrange
            Expression<Action<TestAsyncController>> expr = (c => c.AsynchronousAsync());

            // Act
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);

            // Assert
            Assert.Equal("Asynchronous", rvd["action"]);
            Assert.Equal("TestAsync", rvd["controller"]);
            Assert.False(rvd.ContainsKey("area"));
        }

        [Fact]
        public void BuildRouteValueDictionary_TargetsAsynchronousCompletedMethod_Throws()
        {
            // Arrange
            Expression<Action<TestAsyncController>> expr = (c => c.AsynchronousCompleted());

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { ExpressionHelper.GetRouteValuesFromExpression(expr); },
                @"The method 'AsynchronousCompleted' is an asynchronous completion method and cannot be called directly.");
        }

        [Fact]
        public void BuildRouteValueDictionary_TargetsControllerWithAreaAttribute_AddsAreaName()
        {
            // Arrange
            Expression<Action<ControllerWithAreaController>> expr = c => c.Index();

            // Act
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);

            // Assert
            Assert.Equal("Index", rvd["action"]);
            Assert.Equal("ControllerWithArea", rvd["controller"]);
            Assert.Equal("the area name", rvd["area"]);
        }

        [Fact]
        public void BuildRouteValueDictionary_TargetsNonActionMethod_Throws()
        {
            // Arrange
            Expression<Action<TestController>> expr = (c => c.NotAnAction());

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { ExpressionHelper.GetRouteValuesFromExpression(expr); },
                @"The method 'NotAnAction' is marked [NonAction] and cannot be called directly.");
        }

        [Fact]
        public void BuildRouteValueDictionary_TargetsRenamedMethod_UsesNewName()
        {
            // Arrange
            Expression<Action<TestController>> expr = (c => c.Renamed());

            // Act
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);

            // Assert
            Assert.Equal("NewName", rvd["action"]);
            Assert.Equal("Test", rvd["controller"]);
            Assert.False(rvd.ContainsKey("area"));
        }

        [Fact]
        public void BuildRouteValueDictionary_TargetsSynchronousMethodOnAsyncController_ReturnsOriginalName()
        {
            // Arrange
            Expression<Action<TestAsyncController>> expr = (c => c.Synchronous());

            // Act
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(expr);

            // Assert
            Assert.Equal("Synchronous", rvd["action"]);
            Assert.Equal("TestAsync", rvd["controller"]);
            Assert.False(rvd.ContainsKey("area"));
        }

        [Fact]
        public void BuildRouteValueDictionaryWithNullExpressionThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(
                () => ExpressionHelper.GetRouteValuesFromExpression<TestController>(null),
                "action");
        }

        [Fact]
        public void BuildRouteValueDictionaryWithNonMethodExpressionThrowsInvalidOperationException()
        {
            // Arrange
            Expression<Action<TestController>> expression = c => new TestController();

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => ExpressionHelper.GetRouteValuesFromExpression(expression),
                "Expression must be a method call." + Environment.NewLine
              + "Parameter name: action");
        }

        [Fact]
        public void BuildRouteValueDictionaryWithoutControllerSuffixThrowsInvalidOperationException()
        {
            // Arrange
            Expression<Action<TestControllerNot>> index = (c => c.Index(123));

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => ExpressionHelper.GetRouteValuesFromExpression(index),
                "Controller name must end in 'Controller'." + Environment.NewLine
              + "Parameter name: action");
        }

        [Fact]
        public void BuildRouteValueDictionaryWithControllerBaseClassThrowsInvalidOperationException()
        {
            // Arrange
            Expression<Action<Controller>> index = (c => c.Dispose());

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => ExpressionHelper.GetRouteValuesFromExpression(index),
                "Cannot route to class named 'Controller'." + Environment.NewLine
              + "Parameter name: action");
        }

        [Fact]
        public void BuildRouteValueDictionaryAddsControllerNameToDictionary()
        {
            // Arrange
            Expression<Action<TestController>> index = (c => c.Index(123));

            // Act
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);

            // Assert
            Assert.Equal("Test", rvd["Controller"]);
        }

        [Fact]
        public void BuildRouteValueDictionaryFromExpressionReturnsCorrectDictionary()
        {
            // Arrange
            Expression<Action<TestController>> index = (c => c.Index(123));

            // Act
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);

            // Assert
            Assert.Equal("Test", rvd["Controller"]);
            Assert.Equal("Index", rvd["Action"]);
            Assert.Equal(123, rvd["page"]);
        }

        [Fact]
        public void BuildRouteValueDictionaryFromNonConstantExpressionReturnsCorrectDictionary()
        {
            // Arrange
            Expression<Action<TestController>> index = (c => c.About(Foo));

            // Act
            RouteValueDictionary rvd = ExpressionHelper.GetRouteValuesFromExpression(index);

            // Assert
            Assert.Equal("Test", rvd["Controller"]);
            Assert.Equal("About", rvd["Action"]);
            Assert.Equal("FooValue", rvd["s"]);
        }

        [Fact]
        public void GetInputNameFromPropertyExpressionReturnsPropertyName()
        {
            // Arrange
            Expression<Func<TestModel, int>> expression = m => m.IntProperty;

            // Act
            string name = ExpressionHelper.GetInputName(expression);

            // Assert
            Assert.Equal("IntProperty", name);
        }

        [Fact]
        public void GetInputNameFromPropertyWithMethodCallExpressionReturnsPropertyName()
        {
            // Arrange
            Expression<Func<TestModel, string>> expression = m => m.IntProperty.ToString();

            // Act
            string name = ExpressionHelper.GetInputName(expression);

            // Assert
            Assert.Equal("IntProperty", name);
        }

        [Fact]
        public void GetInputNameFromPropertyWithTwoMethodCallExpressionReturnsPropertyName()
        {
            // Arrange
            Expression<Func<TestModel, string>> expression = m => m.IntProperty.ToString().ToUpper();

            // Act
            string name = ExpressionHelper.GetInputName(expression);

            // Assert
            Assert.Equal("IntProperty", name);
        }

        [Fact]
        public void GetInputNameFromExpressionWithTwoPropertiesUsesWholeExpression()
        {
            // Arrange
            Expression<Func<TestModel, int>> expression = m => m.StringProperty.Length;

            // Act
            string name = ExpressionHelper.GetInputName(expression);

            // Assert
            Assert.Equal("StringProperty.Length", name);
        }

        public class TestController : Controller
        {
            public ActionResult Index(int page)
            {
                return null;
            }

            public string About(string s)
            {
                return "The value is " + s;
            }

            [ActionName("NewName")]
            public void Renamed()
            {
            }

            [NonAction]
            public void NotAnAction()
            {
            }
        }

        public class TestAsyncController : AsyncController
        {
            public void Synchronous()
            {
            }

            public void AsynchronousAsync()
            {
            }

            public void AsynchronousCompleted()
            {
            }
        }

        public string Foo
        {
            get { return "FooValue"; }
        }

        public class TestControllerNot : Controller
        {
            public ActionResult Index(int page)
            {
                return null;
            }
        }

        [ActionLinkArea("the area name")]
        public class ControllerWithAreaController : Controller
        {
            public ActionResult Index()
            {
                return null;
            }
        }

        public class TestModel
        {
            public int IntProperty { get; set; }
            public string StringProperty { get; set; }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/FileExtensionsAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class FileExtensionsAttributeTest
    {
        [Fact]
        public void DefaultExtensions()
        {
            Assert.Equal("png,jpg,jpeg,gif", new FileExtensionsAttribute().Extensions);
        }

        [Fact]
        public void ClientRule()
        {
            // Arrange
            var attribute = new FileExtensionsAttribute { Extensions = " FoO, .bar,baz " };
            var provider = new Mock<ModelMetadataProvider>();
            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");

            // Act
            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();

            // Assert
            Assert.Equal("extension", clientRule.ValidationType);
            Assert.Equal("The PropertyName field only accepts files with the following extensions: .foo, .bar, .baz", clientRule.ErrorMessage);
            Assert.Single(clientRule.ValidationParameters);
            Assert.Equal("foo,bar,baz", clientRule.ValidationParameters["extension"]);
        }

        [Fact]
        public void IsValidTests()
        {
            // Arrange
            var attribute = new FileExtensionsAttribute();

            // Act & Assert
            Assert.True(attribute.IsValid(null)); // Optional values are always valid
            Assert.True(attribute.IsValid("foo.png"));
            Assert.True(attribute.IsValid("foo.jpeg"));
            Assert.True(attribute.IsValid("foo.jpg"));
            Assert.True(attribute.IsValid("foo.gif"));
            Assert.True(attribute.IsValid(@"C:\Foo\baz.jpg"));
            Assert.False(attribute.IsValid("foo"));
            Assert.False(attribute.IsValid("foo.png.pif"));
            Assert.False(attribute.IsValid(@"C:\foo.png\bar"));
            Assert.False(attribute.IsValid("\0foo.png")); // Illegal character
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/FormExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.IO;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class FormExtensionsTest
    {
        internal const string AppPathModifier = "/$(SESSION)";

        [Fact]
        public void FormWithPostAction()
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            // Act
            IDisposable formDisposable = htmlHelper.BeginForm<FormController>(action => action.About());
            formDisposable.Dispose();

            // Assert
            Assert.Equal(@"<form action=""" + AppPathModifier + @"/Form/About"" method=""post""></form>", writer.ToString());
        }

        [Fact]
        public void FormWithPostActionAndObjectAttributes()
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            // Act
            IDisposable formDisposable = htmlHelper.BeginForm<FormController>(action => action.About(), FormMethod.Get, new { baz = "baz" });
            formDisposable.Dispose();

            // Assert
            Assert.Equal(@"<form action=""" + AppPathModifier + @"/Form/About"" baz=""baz"" method=""get""></form>", writer.ToString());
        }

        [Fact]
        public void FormWithPostActionAndObjectAttributesWithUnderscores()
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            // Act
            IDisposable formDisposable = htmlHelper.BeginForm<FormController>(action => action.About(), FormMethod.Get, new { foo_baz = "baz" });
            formDisposable.Dispose();

            // Assert
            Assert.Equal(@"<form action=""" + AppPathModifier + @"/Form/About"" foo-baz=""baz"" method=""get""></form>", writer.ToString());
        }

        public class FormController : Controller
        {
            public ActionResult About()
            {
                return RedirectToAction("foo");
            }
        }

        private static HtmlHelper GetFormHelper(out StringWriter writer)
        {
            Mock<HttpRequestBase> mockHttpRequest = new Mock<HttpRequestBase>();
            mockHttpRequest.Setup(r => r.Url).Returns(new Uri("http://www.contoso.com/some/path"));
            Mock<HttpResponseBase> mockHttpResponse = new Mock<HttpResponseBase>(MockBehavior.Strict);

            mockHttpResponse.Setup(r => r.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(r => AppPathModifier + r);
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.Request).Returns(mockHttpRequest.Object);
            mockHttpContext.Setup(c => c.Response).Returns(mockHttpResponse.Object);
            RouteCollection rt = new RouteCollection();
            rt.Add(new Route("{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            RouteData rd = new RouteData();
            rd.Values.Add("controller", "home");
            rd.Values.Add("action", "oldaction");

            Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
            mockViewContext.Setup(c => c.HttpContext).Returns(mockHttpContext.Object);
            mockViewContext.Setup(c => c.RouteData).Returns(rd);
            writer = new StringWriter();
            mockViewContext.Setup(c => c.Writer).Returns(writer);

            HtmlHelper helper = new HtmlHelper(
                mockViewContext.Object,
                new Mock<IViewDataContainer>().Object,
                rt);
            return helper;
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ImageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class ImageExtensionsTest
    {
        [Fact]
        public void ImageWithEmptyRelativeUrlThrowsArgumentNullException()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            Assert.ThrowsArgumentNullOrEmpty(() => html.Image(null), "imageRelativeUrl");
        }

        [Fact]
        public void ImageStaticWithEmptyRelativeUrlThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNullOrEmpty(() => ImageExtensions.Image((string)null, "alt", null), "imageUrl");
        }

        [Fact]
        public void ImageWithRelativeUrlRendersProperImageTag()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg");
            // NOTE: Although XHTML requires an alt tag, we don't construct one for you. Specify it yourself.
            Assert.Equal("<img src=\"/system/web/mvc.jpg\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithWithAttributesWithUnderscores()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", new { foo_bar = "baz" });
            Assert.Equal("<img foo-bar=\"baz\" src=\"/system/web/mvc.jpg\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithAltValueRendersImageWithAltTag()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", "this is an alt value");
            Assert.Equal("<img alt=\"this is an alt value\" src=\"/system/web/mvc.jpg\" title=\"this is an alt value\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithAltValueInObjectDictionaryRendersImageWithAltAndTitleTag()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", new { alt = "this is an alt value" });
            Assert.Equal("<img alt=\"this is an alt value\" src=\"/system/web/mvc.jpg\" title=\"this is an alt value\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithAltValueHtmlAttributeEncodesAltTag()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", @"<"">");
            Assert.Equal("<img alt=\"&lt;&quot;>\" src=\"/system/web/mvc.jpg\" title=\"&lt;&quot;>\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithAltValueInObjectDictionaryHtmlAttributeEncodesAltTag()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", new { alt = "this is an alt value" });
            Assert.Equal("<img alt=\"this is an alt value\" src=\"/system/web/mvc.jpg\" title=\"this is an alt value\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithAltSpecifiedAndInDictionaryRendersExplicit()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", "specified-alt", new { alt = "object-dictionary-alt" });
            Assert.Equal("<img alt=\"object-dictionary-alt\" src=\"/system/web/mvc.jpg\" title=\"object-dictionary-alt\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithAltAndAttributesWithUnderscores()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", "specified-alt", new { foo_bar = "baz" });
            Assert.Equal("<img alt=\"specified-alt\" foo-bar=\"baz\" src=\"/system/web/mvc.jpg\" title=\"specified-alt\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithSrcSpecifiedAndInDictionaryRendersExplicit()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", new { src = "explicit.jpg" });
            Assert.Equal("<img src=\"explicit.jpg\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithOtherAttributesRendersThoseAttributesCaseSensitively()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", new { width = 100, Height = 200 });
            Assert.Equal("<img Height=\"200\" src=\"/system/web/mvc.jpg\" width=\"100\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithUrlAndDictionaryRendersAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            var attributes = new RouteValueDictionary(new { width = 125 });
            MvcHtmlString imageResult = html.Image("/system/web/mvc.jpg", attributes);
            Assert.Equal("<img src=\"/system/web/mvc.jpg\" width=\"125\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithTildePathAndAppPathResolvesCorrectly()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary(), "/app");
            MvcHtmlString imageResult = html.Image("~/system/web/mvc.jpg");
            Assert.Equal("<img src=\"/app/system/web/mvc.jpg\" />", imageResult.ToHtmlString());
        }

        [Fact]
        public void ImageWithTildePathWithoutAppPathResolvesCorrectly()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary(), "/");
            MvcHtmlString imageResult = html.Image("~/system/web/mvc.jpg");
            Assert.Equal("<img src=\"/system/web/mvc.jpg\" />", imageResult.ToHtmlString());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/MailToExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class MailToExtensionsTest
    {
        [Fact]
        public void MailToWithoutEmailThrowsArgumentNullException()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            Assert.ThrowsArgumentNull(() => html.Mailto("link text", null), "emailAddress");
        }

        [Fact]
        public void MailToWithoutLinkTextThrowsArgumentNullException()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            Assert.ThrowsArgumentNull(() => html.Mailto(null, "somebody@example.com"), "linkText");
        }

        [Fact]
        public void MailToWithLinkTextAndEmailRendersProperElement()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "test@example.com");
            Assert.Equal("<a href=\"mailto:test@example.com\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithLinkTextEmailAndHtmlAttributesRendersAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "test@example.com", new { title = "this is a test" });
            Assert.Equal("<a href=\"mailto:test@example.com\" title=\"this is a test\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithLinkTextEmailAndHtmlAttributesDictionaryRendersAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "test@example.com", new RouteValueDictionary(new { title = "this is a test" }));
            Assert.Equal("<a href=\"mailto:test@example.com\" title=\"this is a test\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithSubjectAndHtmlAttributesRendersAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "test@example.com", "The subject", new { title = "this is a test" });
            Assert.Equal("<a href=\"mailto:test@example.com?subject=The subject\" title=\"this is a test\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithSubjectAndHtmlAttributesDictionaryRendersAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "test@example.com", "The subject", new RouteValueDictionary(new { title = "this is a test" }));
            Assert.Equal("<a href=\"mailto:test@example.com?subject=The subject\" title=\"this is a test\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToAttributeEncodesEmail()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "te\">st@example.com");
            Assert.Equal("<a href=\"mailto:te&quot;>st@example.com\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithMultipleRecipientsRendersWithCommas()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "te\">st@example.com,test2@example.com");
            Assert.Equal("<a href=\"mailto:te&quot;>st@example.com,test2@example.com\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithSubjectAppendsSubjectQuery()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "test@example.com", "This is the subject");
            Assert.Equal("<a href=\"mailto:test@example.com?subject=This is the subject\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithCopyOnlyAppendsCopyQuery()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            MvcHtmlString result = html.Mailto("This is a test", "test@example.com", null, null, "cctest@example.com", null, null);
            Assert.Equal("<a href=\"mailto:test@example.com?cc=cctest@example.com\">This is a test</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithMultipartBodyRendersProperMailtoEncoding()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            string body = "Line one" + Environment.NewLine
                        + "Line two" + Environment.NewLine
                        + "Line three";

            MvcHtmlString result = html.Mailto("email me", "test@example.com", null, body, null, null, null);
            Assert.Equal("<a href=\"mailto:test@example.com?body=Line one%0ALine two%0ALine three\">email me</a>", result.ToHtmlString());
        }

        [Fact]
        public void MailToWithAllValuesProvidedRendersCorrectTag()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            string body = "Line one" + Environment.NewLine
                        + "Line two" + Environment.NewLine
                        + "Line three";

            MvcHtmlString result = html.Mailto("email me", "test@example.com", "the subject", body, "cc@example.com", "bcc@example.com", new { title = "email test" });
            string expected = @"<a href=""mailto:test@example.com?subject=the subject&amp;cc=cc@example.com&amp;bcc=bcc@example.com&amp;body=Line one%0ALine two%0ALine three"" title=""email test"">email me</a>";
            Assert.Equal(expected, result.ToHtmlString());
        }

        [Fact]
        public void MailToWithAttributesWithUnderscores()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            string body = "Line one" + Environment.NewLine
                        + "Line two" + Environment.NewLine
                        + "Line three";

            MvcHtmlString result = html.Mailto("email me", "test@example.com", "the subject", body, "cc@example.com", "bcc@example.com", new { foo_bar = "baz" });
            string expected = @"<a foo-bar=""baz"" href=""mailto:test@example.com?subject=the subject&amp;cc=cc@example.com&amp;bcc=bcc@example.com&amp;body=Line one%0ALine two%0ALine three"">email me</a>";
            Assert.Equal(expected, result.ToHtmlString());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ModelCopierTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class ModelCopierTest
    {
        [Fact]
        public void CopyCollection_FromIsNull_DoesNothing()
        {
            // Arrange
            int[] from = null;
            List<int> to = new List<int> { 1, 2, 3 };

            // Act
            ModelCopier.CopyCollection(from, to);

            // Assert
            Assert.Equal(new[] { 1, 2, 3 }, to.ToArray());
        }

        [Fact]
        public void CopyCollection_ToIsImmutable_DoesNothing()
        {
            // Arrange
            List<int> from = new List<int> { 1, 2, 3 };
            ICollection<int> to = new ReadOnlyCollection<int>(new[] { 4, 5, 6 });

            // Act
            ModelCopier.CopyCollection(from, to);

            // Assert
            Assert.Equal(new[] { 1, 2, 3 }, from.ToArray());
            Assert.Equal(new[] { 4, 5, 6 }, to.ToArray());
        }

        [Fact]
        public void CopyCollection_ToIsMmutable_ClearsAndCopies()
        {
            // Arrange
            List<int> from = new List<int> { 1, 2, 3 };
            ICollection<int> to = new List<int> { 4, 5, 6 };

            // Act
            ModelCopier.CopyCollection(from, to);

            // Assert
            Assert.Equal(new[] { 1, 2, 3 }, from.ToArray());
            Assert.Equal(new[] { 1, 2, 3 }, to.ToArray());
        }

        [Fact]
        public void CopyCollection_ToIsNull_DoesNothing()
        {
            // Arrange
            List<int> from = new List<int> { 1, 2, 3 };
            List<int> to = null;

            // Act
            ModelCopier.CopyCollection(from, to);

            // Assert
            Assert.Equal(new[] { 1, 2, 3 }, from.ToArray());
        }

        [Fact]
        public void CopyModel_ExactTypeMatch_Copies()
        {
            // Arrange
            GenericModel<int> from = new GenericModel<int> { TheProperty = 21 };
            GenericModel<int> to = new GenericModel<int> { TheProperty = 42 };

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Equal(21, from.TheProperty);
            Assert.Equal(21, to.TheProperty);
        }

        [Fact]
        public void CopyModel_FromIsNull_DoesNothing()
        {
            // Arrange
            GenericModel<int> from = null;
            GenericModel<int> to = new GenericModel<int> { TheProperty = 42 };

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Equal(42, to.TheProperty);
        }

        [Fact]
        public void CopyModel_LiftedTypeMatch_ActualValueIsNotNull_Copies()
        {
            // Arrange
            GenericModel<int?> from = new GenericModel<int?> { TheProperty = 21 };
            GenericModel<int> to = new GenericModel<int> { TheProperty = 42 };

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Equal(21, from.TheProperty);
            Assert.Equal(21, to.TheProperty);
        }

        [Fact]
        public void CopyModel_LiftedTypeMatch_ActualValueIsNull_DoesNothing()
        {
            // Arrange
            GenericModel<int?> from = new GenericModel<int?> { TheProperty = null };
            GenericModel<int> to = new GenericModel<int> { TheProperty = 42 };

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Null(from.TheProperty);
            Assert.Equal(42, to.TheProperty);
        }

        [Fact]
        public void CopyModel_NoTypeMatch_DoesNothing()
        {
            // Arrange
            GenericModel<int> from = new GenericModel<int> { TheProperty = 21 };
            GenericModel<long> to = new GenericModel<long> { TheProperty = 42 };

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Equal(21, from.TheProperty);
            Assert.Equal(42, to.TheProperty);
        }

        [Fact]
        public void CopyModel_SubclassedTypeMatch_Copies()
        {
            // Arrange
            string originalModel = "Hello, world!";

            GenericModel<string> from = new GenericModel<string> { TheProperty = originalModel };
            GenericModel<object> to = new GenericModel<object> { TheProperty = 42 };

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Same(originalModel, from.TheProperty);
            Assert.Same(originalModel, to.TheProperty);
        }

        [Fact]
        public void CopyModel_ToDoesNotContainProperty_DoesNothing()
        {
            // Arrange
            GenericModel<int> from = new GenericModel<int> { TheProperty = 21 };
            OtherGenericModel<int> to = new OtherGenericModel<int> { SomeOtherProperty = 42 };

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Equal(21, from.TheProperty);
            Assert.Equal(42, to.SomeOtherProperty);
        }

        [Fact]
        public void CopyModel_ToIsNull_DoesNothing()
        {
            // Arrange
            GenericModel<int> from = new GenericModel<int> { TheProperty = 21 };
            GenericModel<int> to = null;

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Equal(21, from.TheProperty);
        }

        [Fact]
        public void CopyModel_ToIsReadOnly_DoesNothing()
        {
            // Arrange
            GenericModel<int> from = new GenericModel<int> { TheProperty = 21 };
            ReadOnlyGenericModel<int> to = new ReadOnlyGenericModel<int>(42);

            // Act
            ModelCopier.CopyModel(from, to);

            // Assert
            Assert.Equal(21, from.TheProperty);
            Assert.Equal(42, to.TheProperty);
        }

        private class GenericModel<T>
        {
            public T TheProperty { get; set; }
        }

        private class OtherGenericModel<T>
        {
            public T SomeOtherProperty { get; set; }
        }

        private class ReadOnlyGenericModel<T>
        {
            public ReadOnlyGenericModel(T propertyValue)
            {
                TheProperty = propertyValue;
            }

            public T TheProperty { get; private set; }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/MvcSerializerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Runtime.Serialization;
using System.Web.Security;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class MvcSerializerTest
    {
        [Fact]
        public void DeserializeThrowsIfSerializedValueIsCorrupt()
        {
            // Arrange
            IMachineKey machineKey = new MockMachineKey();

            // Act & assert
            Exception exception = Assert.Throws<SerializationException>(
                delegate { MvcSerializer.Deserialize("This is a corrupted value.", machineKey); },
                @"Deserialization failed. Verify that the data is being deserialized using the same SerializationMode with which it was serialized. Otherwise see the inner exception.");

            Assert.NotNull(exception.InnerException);
        }

        [Fact]
        public void DeserializeThrowsIfSerializedValueIsEmpty()
        {
            // Arrange
            MvcSerializer serializer = new MvcSerializer();

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { serializer.Deserialize(""); }, "serializedValue");
        }

        [Fact]
        public void DeserializeThrowsIfSerializedValueIsNull()
        {
            // Arrange
            MvcSerializer serializer = new MvcSerializer();

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { serializer.Deserialize(null); }, "serializedValue");
        }

        [Fact]
        public void SerializeAllowsNullValues()
        {
            // Arrange
            IMachineKey machineKey = new MockMachineKey();

            // Act
            string serializedValue = MvcSerializer.Serialize(null, machineKey);

            // Assert
            Assert.Equal(@"Microsoft.Web.Mvc.MvcSerializer.v1-dwdhbnlUeXBlLgNuaWyGCQF6M2h0dHA6Ly9zY2hlbWFzLm1pY3Jvc29mdC5jb20vMjAwMy8xMC9TZXJpYWxpemF0aW9uLwkBaSlodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZQE=", serializedValue);
        }

        [Fact]
        public void SerializeAndDeserializeRoundTripsValue()
        {
            // Arrange
            IMachineKey machineKey = new MockMachineKey();

            // Act
            string serializedValue = MvcSerializer.Serialize(42, machineKey);
            object deserializedValue = MvcSerializer.Deserialize(serializedValue, machineKey);

            // Assert
            Assert.Equal(42, deserializedValue);
        }

        private sealed class MockMachineKey : IMachineKey
        {
            public byte[] Unprotect(string protectedData, params string[] purposes)
            {
                string optionString = purposes[0].ToString();
                if (protectedData.StartsWith(optionString, StringComparison.Ordinal))
                {
                    protectedData = protectedData.Substring(optionString.Length + 1);
                }
                else
                {
                    throw new Exception("Corrupted data.");
                }
                return Convert.FromBase64String(protectedData);

            }

            public string Protect(byte[] userData, params string[] purposes)
            {
                return purposes[0].ToString() + "-" + Convert.ToBase64String(userData);
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/RadioExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class RadioExtensionsTest
    {
        [Fact]
        public void RadioButtonListNothingSelected()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", GetRadioButtonListData(false));

            // Assert
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListItemSelected()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", GetRadioButtonListData(true));

            // Assert
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input checked=""checked"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListItemSelectedWithValueFromViewData()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary(new { foolist = "bar" }));

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", GetRadioButtonListData(false));

            // Assert
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input checked=""checked"" id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListWithObjectAttributes()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", GetRadioButtonListData(true), new { attr1 = "value1" });

            // Assert
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" checked=""checked"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListWithObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", GetRadioButtonListData(true), new { foo_bar = "baz" });

            // Assert
            Assert.Equal(@"<input foo-bar=""baz"" id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input foo-bar=""baz"" id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input checked=""checked"" foo-bar=""baz"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListWithDictionaryAttributes()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", GetRadioButtonListData(true), new RouteValueDictionary(new { attr1 = "value1" }));

            // Assert
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" checked=""checked"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListNothingSelectedWithSelectListFromViewData()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(false));

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList");

            // Assert
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListItemSelectedWithSelectListFromViewData()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(true));

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList");

            // Assert
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input checked=""checked"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListWithObjectAttributesWithSelectListFromViewData()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(true));

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", new { attr1 = "value1" });

            // Assert
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" checked=""checked"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListWithObjectAttributesWithUnderscoresWithSelectListFromViewData()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(true));

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", new { foo_bar = "baz" });

            // Assert
            Assert.Equal(@"<input foo-bar=""baz"" id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input foo-bar=""baz"" id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input checked=""checked"" foo-bar=""baz"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListWithDictionaryAttributesWithSelectListFromViewData()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(true));

            // Act
            MvcHtmlString[] html = htmlHelper.RadioButtonList("FooList", new RouteValueDictionary(new { attr1 = "value1" }));

            // Assert
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""foo"" />", html[0].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" id=""FooList"" name=""FooList"" type=""radio"" value=""bar"" />", html[1].ToHtmlString());
            Assert.Equal(@"<input attr1=""value1"" checked=""checked"" id=""FooList"" name=""FooList"" type=""radio"" value=""baz"" />", html[2].ToHtmlString());
        }

        [Fact]
        public void RadioButtonListWithDictionaryAttributesWithWrongSelectListName()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(true));

            // Act / Assert
            Assert.Throws<InvalidOperationException>(() => 
                htmlHelper.RadioButtonList("WrongFooList", new RouteValueDictionary(new { attr1 = "value1" })));
        }

        [Fact]
        public void RadioButtonListWithDictionaryAttributesWithInvalidSelectListFromViewData()
        {
            // Arrange
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["FooList"] = "FOOBAR3";
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(viewData);

            // Act / Assert
            Assert.Throws<InvalidOperationException>(() => 
                htmlHelper.RadioButtonList("FooList", new RouteValueDictionary(new { attr1 = "value1" })));
        }

        [Fact]
        public void RadioButtonListWithDictionaryAttributesWithNullSelectListNameFromSelectList()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(true));
            SelectList selectList = GetRadioButtonListData(true);

            // Act / Assert
            Assert.Throws<ArgumentException>(() => 
                htmlHelper.RadioButtonList("", selectList, new RouteValueDictionary(new { attr1 = "value1" })));
        }

        [Fact]
        public void RadioButtonListWithDictionaryAttributesWithSelectListNameAndNullSelectList()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetRadioButtonListViewData(true));

            // Act / Assert
            Assert.Throws<ArgumentNullException>(() => 
                htmlHelper.RadioButtonList("FooBar", null, new RouteValueDictionary(new { attr1 = "value1" })));
        }

        private static SelectList GetRadioButtonListData(bool selectBaz)
        {
            List<RadioItem> list = new List<RadioItem>();
            list.Add(new RadioItem { Text = "text-foo", Value = "foo" });
            list.Add(new RadioItem { Text = "text-bar", Value = "bar" });
            list.Add(new RadioItem { Text = "text-baz", Value = "baz" });
            return new SelectList(list, "value", "TEXT", selectBaz ? "baz" : "something-else");
        }

        private static ViewDataDictionary GetRadioButtonListViewData(bool selectBaz)
        {
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["FooList"] = GetRadioButtonListData(selectBaz);
            return viewData;
        }

        private class RadioItem
        {
            public string Text { get; set; }

            public string Value { get; set; }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ReaderWriterCacheTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class ReaderWriterCacheTest
    {
        [Fact]
        public void PublicFetchOrCreateItemCreatesItemIfNotAlreadyInCache()
        {
            // Arrange
            ReaderWriterCacheHelper<int, string> helper = new ReaderWriterCacheHelper<int, string>();
            Dictionary<int, string> cache = helper.PublicCache;

            // Act
            string item = helper.PublicFetchOrCreateItem(42, () => "new");

            // Assert
            Assert.Equal("new", cache[42]);
            Assert.Equal("new", item);
        }

        [Fact]
        public void PublicFetchOrCreateItemReturnsExistingItemIfFound()
        {
            // Arrange
            ReaderWriterCacheHelper<int, string> helper = new ReaderWriterCacheHelper<int, string>();
            Dictionary<int, string> cache = helper.PublicCache;
            helper.PublicCache[42] = "original";

            // Act
            string item = helper.PublicFetchOrCreateItem(42, () => "new");

            // Assert
            Assert.Equal("original", cache[42]);
            Assert.Equal("original", item);
        }

        [Fact]
        public void PublicFetchOrCreateItemReturnsFirstItemIfTwoThreadsUpdateCacheSimultaneously()
        {
            // Arrange
            ReaderWriterCacheHelper<int, string> helper = new ReaderWriterCacheHelper<int, string>();
            Dictionary<int, string> cache = helper.PublicCache;
            Func<string> creator = delegate
            {
                // fake a second thread coming along when we weren't looking
                string firstItem = helper.PublicFetchOrCreateItem(42, () => "original");

                Assert.Equal("original", cache[42]);
                Assert.Equal("original", firstItem);
                return "new";
            };

            // Act
            string secondItem = helper.PublicFetchOrCreateItem(42, creator);

            // Assert
            Assert.Equal("original", cache[42]);
            Assert.Equal("original", secondItem);
        }

        private class ReaderWriterCacheHelper<TKey, TValue> : ReaderWriterCache<TKey, TValue>
        {
            public Dictionary<TKey, TValue> PublicCache
            {
                get { return Cache; }
            }

            public TValue PublicFetchOrCreateItem(TKey key, Func<TValue> creator)
            {
                return FetchOrCreateItem(key, creator);
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/RenderActionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.IO;
using System.Reflection;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class RenderActionTest
    {
        [Fact]
        public void RenderActionUsingExpressionWithParametersInViewContextRendersCorrectly()
        {
            // Arrange
            Func<RequestContext> requestContextAccessor;
            HtmlHelper html = GetHtmlHelper(out requestContextAccessor);
            html.ViewContext.RouteData.Values.Add("stuff", "42");

            // Act
            html.RenderAction<TestController>(c => c.Stuff());
            RequestContext requestContext = requestContextAccessor();

            // Assert
            Assert.NotNull(requestContext);
            Assert.Equal("Test", requestContext.RouteData.Values["controller"]);
            Assert.Equal("Stuff", requestContext.RouteData.Values["action"]);
            Assert.Equal("42", requestContext.RouteData.Values["stuff"]);
        }

        [Fact]
        public void RenderActionUsingExpressionRendersCorrectly()
        {
            // Arrange
            Func<RequestContext> requestContextAccessor;
            HtmlHelper html = GetHtmlHelper(out requestContextAccessor);

            // Act
            html.RenderAction<TestController>(c => c.About(76));
            RequestContext requestContext = requestContextAccessor();

            // Assert
            Assert.NotNull(requestContext);
            Assert.Equal("Test", requestContext.RouteData.Values["controller"]);
            Assert.Equal("About", requestContext.RouteData.Values["action"]);
            Assert.Equal(76, requestContext.RouteData.Values["page"]);
        }

        [Fact]
        public void RenderRouteWithNullRouteValueDictionaryThrowsException()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary(), "/");
            Assert.ThrowsArgumentNull(() => html.RenderRoute(null), "routeValues");
        }

        [Fact]
        public void RenderRouteWithActionAndControllerSpecifiedRendersCorrectAction()
        {
            // Arrange
            Func<RequestContext> requestContextAccessor;
            HtmlHelper html = GetHtmlHelper(out requestContextAccessor);

            // Act
            html.RenderRoute(new RouteValueDictionary(new { action = "Index", controller = "Test" }));
            RequestContext requestContext = requestContextAccessor();

            // Assert
            Assert.NotNull(requestContext);
            Assert.Equal("Test", requestContext.RouteData.Values["controller"]);
            Assert.Equal("Index", requestContext.RouteData.Values["action"]);
        }

        private static HtmlHelper GetHtmlHelper(out Func<RequestContext> requestContextAccessor)
        {
            RequestContext requestContext = null;

            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary(), "/");

            html.RouteCollection.MapRoute(null, "{*dummy}");
            Mock.Get(html.ViewContext.HttpContext)
                .Setup(o => o.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((_h, _w, _pf) =>
                {
                    MvcHandler mvcHandler = _h.GetType().GetProperty("InnerHandler", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(_h, null) as MvcHandler;
                    requestContext = mvcHandler.RequestContext;
                });

            requestContextAccessor = () => requestContext;
            return html;
        }

        public class TestController : Controller
        {
            public string Index()
            {
                return "It Worked!";
            }

            public string About(int page)
            {
                return "This is page #" + page;
            }

            public string Stuff()
            {
                string stuff = ControllerContext.RouteData.Values["stuff"] as string;
                return "Argument was " + stuff;
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ScriptExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class ScriptExtensionsTest
    {
        [Fact]
        public void ScriptWithoutReleaseFileThrowsArgumentNullException()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Assert
            Assert.ThrowsArgumentNullOrEmpty(() => html.Script(null, "file"), "releaseFile");
        }

        [Fact]
        public void ScriptWithoutDebugFileThrowsArgumentNullException()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Assert
            Assert.ThrowsArgumentNullOrEmpty(() => html.Script("File", null), "debugFile");
        }

        [Fact]
        public void ScriptWithRootedPathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Script("~/Correct/Path.js", "~/Correct/Debug/Path.js");

            // Assert
            Assert.Equal("<script src=\"/Correct/Path.js\" type=\"text/javascript\"></script>", result.ToHtmlString());
        }

        [Fact]
        public void ScriptWithRelativePathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Script("../../Correct/Path.js", "../../Correct/Debug/Path.js");

            // Assert
            Assert.Equal("<script src=\"../../Correct/Path.js\" type=\"text/javascript\"></script>", result.ToHtmlString());
        }

        [Fact]
        public void ScriptWithRelativeCurrentPathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Script("/Correct/Path.js", "/Correct/Debug/Path.js");

            // Assert
            Assert.Equal("<script src=\"/Correct/Path.js\" type=\"text/javascript\"></script>", result.ToHtmlString());
        }

        [Fact]
        public void ScriptWithScriptRelativePathRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Script("Correct/Path.js", "Correct/Debug/Path.js");

            // Assert
            Assert.Equal("<script src=\"/Scripts/Correct/Path.js\" type=\"text/javascript\"></script>", result.ToHtmlString());
        }

        [Fact]
        public void ScriptWithUrlRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Script("http://ajax.Correct.com/Path.js", "http://ajax.Debug.com/Path.js");

            // Assert
            Assert.Equal("<script src=\"http://ajax.Correct.com/Path.js\" type=\"text/javascript\"></script>", result.ToHtmlString());
        }

        [Fact]
        public void ScriptWithSecureUrlRendersProperElement()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());

            // Act
            MvcHtmlString result = html.Script("https://ajax.Correct.com/Path.js", "https://ajax.Debug.com/Path.js");

            // Assert
            Assert.Equal("<script src=\"https://ajax.Correct.com/Path.js\" type=\"text/javascript\"></script>", result.ToHtmlString());
        }

        [Fact]
        public void ScriptWithDebuggingOnUsesDebugUrl()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary());
            Mock.Get(html.ViewContext.HttpContext).Setup(v => v.IsDebuggingEnabled).Returns(true);

            // Act
            MvcHtmlString result = html.Script("Correct/Path.js", "Correct/Debug/Path.js");

            // Assert
            Assert.Equal("<script src=\"/Scripts/Correct/Debug/Path.js\" type=\"text/javascript\"></script>", result.ToHtmlString());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/SerializationExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class SerializationExtensionsTest
    {
        [Fact]
        public void SerializeFromProvidedValueOverridesViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary
            {
                { "someKey", 42 }
            };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            Mock<MvcSerializer> mockSerializer = new Mock<MvcSerializer>();
            mockSerializer.Setup(o => o.Serialize("Hello!")).Returns("some-value");

            // Act
            MvcHtmlString htmlString = helper.Serialize("someKey", "Hello!", mockSerializer.Object);

            // Assert
            Assert.Equal(@"<input name=""someKey"" type=""hidden"" value=""some-value"" />", htmlString.ToHtmlString());
        }

        [Fact]
        public void SerializeFromViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary
            {
                { "someKey", 42 }
            };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            Mock<MvcSerializer> mockSerializer = new Mock<MvcSerializer>();
            mockSerializer.Setup(o => o.Serialize(42)).Returns("some-other-value");

            // Act
            MvcHtmlString htmlString = helper.Serialize("someKey", mockSerializer.Object);

            // Assert
            Assert.Equal(@"<input name=""someKey"" type=""hidden"" value=""some-other-value"" />", htmlString.ToHtmlString());
        }

        [Fact]
        public void SerializeThrowsIfHtmlHelperIsNull()
        {
            Assert.ThrowsArgumentNull(
                delegate { SerializationExtensions.Serialize(null, "someName"); }, "htmlHelper");
        }

        [Fact]
        public void SerializeThrowsIfNameIsEmpty()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.Serialize(""); }, "name");
        }

        [Fact]
        public void SerializeThrowsIfNameIsNull()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.Serialize(null); }, "name");
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ServerVariablesValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class ServerVariablesValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            NameValueCollection serverVars = new NameValueCollection
            {
                { "foo", "fooValue" },
                { "bar.baz", "barBazValue" }
            };

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.ServerVariables).Returns(serverVars);

            ServerVariablesValueProviderFactory factory = new ServerVariablesValueProviderFactory();

            // Act
            IValueProvider provider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.True(provider.ContainsPrefix("bar"));
            Assert.Equal("fooValue", provider.GetValue("foo").AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, provider.GetValue("foo").Culture);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/SessionValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Web;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class SessionValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            Dictionary<string, object> backingStore = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)
            {
                { "foo", "fooValue" },
                { "bar.baz", "barBazValue" }
            };
            MockSessionState session = new MockSessionState(backingStore);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Session).Returns(session);

            SessionValueProviderFactory factory = new SessionValueProviderFactory();

            // Act
            IValueProvider provider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.True(provider.ContainsPrefix("bar"));
            Assert.Equal("fooValue", provider.GetValue("foo").AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, provider.GetValue("foo").Culture);
        }

        private sealed class MockSessionState : HttpSessionStateBase
        {
            private readonly IDictionary<string, object> _backingStore;

            public MockSessionState(IDictionary<string, object> backingStore)
            {
                _backingStore = backingStore;
            }

            public override object this[string name]
            {
                get { return _backingStore[name]; }
                set { _backingStore[name] = value; }
            }

            public override IEnumerator GetEnumerator()
            {
                return _backingStore.Keys.GetEnumerator();
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/SkipBindingAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class SkipBindingAttributeTest
    {
        [Fact]
        public void GetBinderReturnsModelBinderWhichReturnsNull()
        {
            // Arrange
            CustomModelBinderAttribute attr = new SkipBindingAttribute();
            IModelBinder binder = attr.GetBinder();

            // Act
            object result = binder.BindModel(null, null);

            // Assert
            Assert.Null(result);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/SubmitButtonExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class SubmitButtonExtensionsTest
    {
        [Fact]
        public void SubmitButtonRendersWithJustTypeAttribute()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton();
            Assert.Equal("<input type=\"submit\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithAttributesWithUnderscores()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton(null, "blah", new { foo_bar = "baz" });
            Assert.Equal("<input foo-bar=\"baz\" type=\"submit\" value=\"blah\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithNameRendersButtonWithNameAttribute()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton("button-name");
            Assert.Equal("<input id=\"button-name\" name=\"button-name\" type=\"submit\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithIdDifferentFromNameRendersButtonWithId()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton("button-name", "blah", new { id = "foo" });
            Assert.Equal("<input id=\"foo\" name=\"button-name\" type=\"submit\" value=\"blah\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithNameAndTextRendersAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton("button-name", "button-text");
            Assert.Equal("<input id=\"button-name\" name=\"button-name\" type=\"submit\" value=\"button-text\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithNameAndValueRendersBothAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton("button-name", "button-value", new { id = "button-id" });
            Assert.Equal("<input id=\"button-id\" name=\"button-name\" type=\"submit\" value=\"button-value\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithNameAndIdRendersBothAttributesCorrectly()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton("button-name", "button-value", new { id = "button-id" });
            Assert.Equal("<input id=\"button-id\" name=\"button-name\" type=\"submit\" value=\"button-value\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithTypeAttributeRendersCorrectType()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton("specified-name", "button-value", new { type = "not-submit" });
            Assert.Equal("<input id=\"specified-name\" name=\"specified-name\" type=\"not-submit\" value=\"button-value\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithNameAndValueSpecifiedAndPassedInAsAttributeChoosesSpecified()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitButton("specified-name", "button-value", new RouteValueDictionary(new { name = "name-attribute-value", value = "value-attribute" }));
            Assert.Equal("<input id=\"specified-name\" name=\"name-attribute-value\" type=\"submit\" value=\"value-attribute\" />", button.ToHtmlString());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/SubmitImageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace Microsoft.Web.Mvc.Test
{
    public class SubmitImageExtensionsTest
    {
        [Fact]
        public void SubmitImageWithEmptyImageSrcThrowsArgumentNullException()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            Assert.ThrowsArgumentNull(() => html.SubmitImage("name", null), "imageSrc");
        }

        [Fact]
        public void SubmitImageWithAttributesWithUnderscores()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitImage("specified-name", "/mvc.jpg", new { foo_bar = "baz" });
            Assert.Equal("<input foo-bar=\"baz\" id=\"specified-name\" name=\"specified-name\" src=\"/mvc.jpg\" type=\"image\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitImageWithTypeAttributeRendersExplicitTypeAttribute()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitImage("specified-name", "/mvc.jpg", new { type = "not-image" });
            Assert.Equal("<input id=\"specified-name\" name=\"specified-name\" src=\"/mvc.jpg\" type=\"not-image\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitImageWithNameAndImageUrlRendersNameAndSrcAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitImage("button-name", "/mvc.gif");
            Assert.Equal("<input id=\"button-name\" name=\"button-name\" src=\"/mvc.gif\" type=\"image\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitImageWithImageUrlStartingWithTildeRendersAppPath()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelperWithPath(new ViewDataDictionary(), "/app");
            MvcHtmlString button = html.SubmitImage("button-name", "~/mvc.gif");
            Assert.Equal("<input id=\"button-name\" name=\"button-name\" src=\"/app/mvc.gif\" type=\"image\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitImageWithNameAndIdRendersBothAttributesCorrectly()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitImage("button-name", "/mvc.png", new { id = "button-id" });
            Assert.Equal("<input id=\"button-id\" name=\"button-name\" src=\"/mvc.png\" type=\"image\" />", button.ToHtmlString());
        }

        [Fact]
        public void SubmitButtonWithNameAndValueSpecifiedAndPassedInAsAttributeChoosesExplicitAttributes()
        {
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MvcHtmlString button = html.SubmitImage("specified-name", "/specified-src.bmp", new RouteValueDictionary(new { name = "name-attribute", src = "src-attribute" }));
            Assert.Equal("<input id=\"specified-name\" name=\"name-attribute\" src=\"src-attribute\" type=\"image\" />", button.ToHtmlString());
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/TempDataValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class TempDataValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProvider_CorrectlyRetainsOrRemovesKeys()
        {
            // Arrange
            string[] expectedRetainedKeys = new[]
            {
                "retainMe"
            };

            TempDataDictionary tempData = new TempDataDictionary
            {
                { "retainMe", "retainMeValue" },
                { "removeMe", "removeMeValue" },
                { "previouslyRemoved", "previouslyRemovedValue" }
            };
            object dummy = tempData["previouslyRemoved"]; // mark value for removal

            ControllerContext controllerContext = GetControllerContext(tempData);

            TempDataValueProviderFactory factory = new TempDataValueProviderFactory();

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(controllerContext);
            ValueProviderResult nonExistentResult = valueProvider.GetValue("nonExistent");
            ValueProviderResult removeMeResult = valueProvider.GetValue("removeme");

            // Assert
            Assert.Null(nonExistentResult);
            Assert.Equal("removeMeValue", removeMeResult.AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, removeMeResult.Culture);

            // Verify that keys have been removed or retained correctly by the provider
            Mock<ITempDataProvider> mockTempDataProvider = new Mock<ITempDataProvider>();
            string[] retainedKeys = null;
            mockTempDataProvider
                .Setup(o => o.SaveTempData(controllerContext, It.IsAny<IDictionary<string, object>>()))
                .Callback(
                    delegate(ControllerContext cc, IDictionary<string, object> d) { retainedKeys = d.Keys.ToArray(); });

            tempData.Save(controllerContext, mockTempDataProvider.Object);
            Assert.Equal(expectedRetainedKeys, retainedKeys);
        }

        [Fact]
        public void GetValueProvider_EmptyTempData_ReturnsNull()
        {
            // Arrange
            TempDataDictionary tempData = new TempDataDictionary();
            ControllerContext controllerContext = GetControllerContext(tempData);

            TempDataValueProviderFactory factory = new TempDataValueProviderFactory();

            // Act
            IValueProvider provider = factory.GetValueProvider(controllerContext);

            // Assert
            Assert.Null(provider);
        }

        private static ControllerContext GetControllerContext(TempDataDictionary tempData)
        {
            return new ControllerContext
            {
                Controller = new EmptyController
                {
                    TempData = tempData
                }
            };
        }

        private sealed class EmptyController : Controller
        {
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/TypeHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class TypeHelpersTest
    {
        [Fact]
        public void GetTypeArgumentsIfMatch_ClosedTypeIsGenericAndMatches_ReturnsType()
        {
            // Act
            Type[] typeArguments = TypeHelpers.GetTypeArgumentsIfMatch(typeof(List<int>), typeof(List<>));

            // Assert
            Assert.Equal(new[] { typeof(int) }, typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsIfMatch_ClosedTypeIsGenericButDoesNotMatch_ReturnsNull()
        {
            // Act
            Type[] typeArguments = TypeHelpers.GetTypeArgumentsIfMatch(typeof(int?), typeof(List<>));

            // Assert
            Assert.Null(typeArguments);
        }

        [Fact]
        public void GetTypeArgumentsIfMatch_ClosedTypeIsNotGeneric_ReturnsNull()
        {
            // Act
            Type[] typeArguments = TypeHelpers.GetTypeArgumentsIfMatch(typeof(int), null);

            // Assert
            Assert.Null(typeArguments);
        }

        [Fact]
        public void IsCompatibleObjectReturnsTrueIfTypeIsNotNullableAndValueIsNull()
        {
            // Act
            bool retVal = TypeHelpers.IsCompatibleObject(typeof(int), null);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void IsCompatibleObjectReturnsFalseIfValueIsIncorrectType()
        {
            // Arrange
            object value = new[] { "Hello", "world" };

            // Act
            bool retVal = TypeHelpers.IsCompatibleObject(typeof(int), value);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void IsCompatibleObjectReturnsTrueIfTypeIsNullableAndValueIsNull()
        {
            // Act
            bool retVal = TypeHelpers.IsCompatibleObject(typeof(int?), null);

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void IsCompatibleObjectReturnsTrueIfValueIsOfCorrectType()
        {
            // Arrange
            object value = new[] { "Hello", "world" };

            // Act
            bool retVal = TypeHelpers.IsCompatibleObject(typeof(IEnumerable<string>), value);

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void TypeAllowsNullValueReturnsFalseForNonNullableGenericValueType()
        {
            Assert.False(TypeHelpers.TypeAllowsNullValue(typeof(KeyValuePair<int, string>)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsFalseForNonNullableGenericValueTypeDefinition()
        {
            Assert.False(TypeHelpers.TypeAllowsNullValue(typeof(KeyValuePair<,>)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsFalseForNonNullableValueType()
        {
            Assert.False(TypeHelpers.TypeAllowsNullValue(typeof(int)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsTrueForInterfaceType()
        {
            Assert.True(TypeHelpers.TypeAllowsNullValue(typeof(IDisposable)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsTrueForNullableType()
        {
            Assert.True(TypeHelpers.TypeAllowsNullValue(typeof(int?)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsTrueForReferenceType()
        {
            Assert.True(TypeHelpers.TypeAllowsNullValue(typeof(object)));
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/UrlAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.Mvc.Test
{
    public class UrlAttributeTest
    {
        [Fact]
        public void ClientRule()
        {
            // Arrange
            var attribute = new UrlAttribute();
            var provider = new Mock<ModelMetadataProvider>();
            var metadata = new ModelMetadata(provider.Object, null, null, typeof(string), "PropertyName");

            // Act
            ModelClientValidationRule clientRule = attribute.GetClientValidationRules(metadata, null).Single();

            // Assert
            Assert.Equal("url", clientRule.ValidationType);
            Assert.Equal("The PropertyName field is not a valid fully-qualified http, https, or ftp URL.", clientRule.ErrorMessage);
            Assert.Empty(clientRule.ValidationParameters);
        }

        [Fact]
        public void IsValidTests()
        {
            // Arrange
            var attribute = new UrlAttribute();

            // Act & Assert
            Assert.True(attribute.IsValid(null)); // Optional values are always valid
            Assert.True(attribute.IsValid("http://foo.bar"));
            Assert.True(attribute.IsValid("https://foo.bar"));
            Assert.True(attribute.IsValid("ftp://foo.bar"));
            Assert.False(attribute.IsValid("file:///foo.bar"));
            Assert.False(attribute.IsValid("http://user%password@foo.bar/"));
            Assert.False(attribute.IsValid("foo.png"));
            Assert.False(attribute.IsValid("\0foo.png")); // Illegal character
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/ValueProviderUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace Microsoft.Web.Mvc.Test
{
    public class ValueProviderUtilTest
    {
        [Fact]
        public void IsPrefixMatch_Misses()
        {
            // Arrange
            var tests = new[]
            {
                new { Prefix = "Prefix", TestString = (string)null, Reason = "Null test string shouldn't match anything." },
                new { Prefix = "Foo", TestString = "NotFoo", Reason = "Prefix 'foo' doesn't match 'notfoo'." },
                new { Prefix = "Foo", TestString = "FooBar", Reason = "Prefix 'foo' was not followed by a delimiter in the test string." }
            };

            // Act & assert
            foreach (var test in tests)
            {
                bool retVal = ValueProviderUtil.IsPrefixMatch(test.Prefix, test.TestString);
                Assert.False(retVal, test.Reason);
            }
        }

        [Fact]
        public void IsPrefixMatch_Hits()
        {
            // Arrange
            var tests = new[]
            {
                new { Prefix = "", TestString = "SomeTestString", Reason = "Empty prefix should match any non-null test string." },
                new { Prefix = "SomeString", TestString = "SomeString", Reason = "This was an exact match." },
                new { Prefix = "Foo", TestString = "foo.bar", Reason = "Prefix 'foo' matched." },
                new { Prefix = "Foo", TestString = "foo[bar]", Reason = "Prefix 'foo' matched." },
            };

            // Act & assert
            foreach (var test in tests)
            {
                bool retVal = ValueProviderUtil.IsPrefixMatch(test.Prefix, test.TestString);
                Assert.True(retVal, test.Reason);
            }
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/Test/VersionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace Microsoft.Web.Test
{
    public class VersionTest
    {
        [Fact]
        public void VerifyMVCVersionChangesAreIntentional()
        {
            Version mvcVersion = VersionTestHelper.GetVersionFromAssembly("System.Web.Mvc", typeof(Controller));
            Assert.Equal(new Version(5, 3, 0, 0), mvcVersion);
        }
    }
}


================================================
FILE: test/Microsoft.Web.Mvc.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/Microsoft.Web.WebPages.OAuth.Test/Microsoft.Web.WebPages.OAuth.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{694C6EDF-EA52-438F-B745-82B025ECC0E7}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.Web.WebPages.OAuth.Test</RootNamespace>
    <AssemblyName>Microsoft.Web.WebPages.OAuth.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="DotNetOpenAuth.AspNet, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.AspNet.4.0.3.12153\lib\net40-full\DotNetOpenAuth.AspNet.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.Core.4.0.3.12153\lib\net40-full\DotNetOpenAuth.Core.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OAuth, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OAuth.Core.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OAuth.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OAuth.Consumer, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OAuth.Consumer.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OAuth.Consumer.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OpenId, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OpenId.Core.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OpenId.dll</HintPath>
    </Reference>
    <Reference Include="DotNetOpenAuth.OpenId.RelyingParty, Version=4.0.0.0, Culture=neutral, PublicKeyToken=2780ccd10d57b246, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\DotNetOpenAuth.OpenId.RelyingParty.4.0.3.12153\lib\net40-full\DotNetOpenAuth.OpenId.RelyingParty.dll</HintPath>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Web" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="OAuthWebSecurityTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="PreAppStartCodeTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\Microsoft.Web.WebPages.OAuth\Microsoft.Web.WebPages.OAuth.csproj">
      <Project>{4CBFC7D3-1600-4CE5-BC6B-AC7BC2D6F853}</Project>
      <Name>Microsoft.Web.WebPages.OAuth</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: test/Microsoft.Web.WebPages.OAuth.Test/OAuthWebSecurityTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Specialized;
using System.Linq;
using System.Web;
using System.Web.Security;
using DotNetOpenAuth.AspNet;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.Web.WebPages.OAuth.Test
{
    public class OAuthWebSecurityTest : IDisposable
    {
        [Fact]
        public void RegisterClientThrowsOnNullValue()
        {
            Assert.ThrowsArgumentNull(() => OAuthWebSecurity.RegisterClient(null), "client");
        }

        [Fact]
        public void RegisterClientThrowsIfProviderNameIsEmpty()
        {
            // Arrange
            var client = new Mock<IAuthenticationClient>();
            client.Setup(c => c.ProviderName).Returns((string)null);

            // Act & Assert
            Assert.ThrowsArgument(() => OAuthWebSecurity.RegisterClient(client.Object), "client");

            client.Setup(c => c.ProviderName).Returns("");

            // Act & Assert
            Assert.ThrowsArgument(() => OAuthWebSecurity.RegisterClient(client.Object), "client");
        }

        [Fact]
        public void RegisterClientThrowsRegisterMoreThanOneClientWithTheSameName()
        {
            // Arrange
            var client1 = new Mock<IAuthenticationClient>();
            client1.Setup(c => c.ProviderName).Returns("provider");

            var client2 = new Mock<IAuthenticationClient>();
            client2.Setup(c => c.ProviderName).Returns("provider");

            OAuthWebSecurity.RegisterClient(client1.Object);

            // Act & Assert
            Assert.ThrowsArgument(() => OAuthWebSecurity.RegisterClient(client2.Object), null);
        }

        [Fact]
        public void RequestAuthenticationRedirectsToProviderWithNullReturnUrl()
        {
            var cookies = new HttpCookieCollection();

            // Arrange
            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Response.Cookies).Returns(cookies);
            context.Setup(c => c.Request.ServerVariables).Returns(new NameValueCollection());
            context.Setup(c => c.Request.Url).Returns(new Uri("http://live.com/login.aspx"));
            context.Setup(c => c.Request.RawUrl).Returns("/login.aspx");
            context.Setup(c => c.User.Identity.IsAuthenticated).Returns(false);

            var client = new Mock<IAuthenticationClient>();
            client.Setup(c => c.ProviderName).Returns("windowslive");
            client.Setup(c => c.RequestAuthentication(
                                    context.Object,
                                    It.Is<Uri>(u => u.AbsoluteUri.StartsWith("http://live.com/login.aspx?__provider__=windowslive", StringComparison.OrdinalIgnoreCase))))
                  .Verifiable();

            OAuthWebSecurity.RegisterClient(client.Object);

            // Act
            OAuthWebSecurity.RequestAuthenticationCore(context.Object, "windowslive", null);

            // Assert
            client.Verify();
        }

        [Fact]
        public void RequestAuthenticationRedirectsToProviderWithReturnUrl()
        {
            var cookies = new HttpCookieCollection();

            // Arrange
            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Request.ServerVariables).Returns(new NameValueCollection());
            context.Setup(c => c.Request.Url).Returns(new Uri("http://live.com/login.aspx"));
            context.Setup(c => c.Request.RawUrl).Returns("/login.aspx");
            context.Setup(c => c.Response.Cookies).Returns(cookies);
            context.Setup(c => c.User.Identity.IsAuthenticated).Returns(false);

            var client = new Mock<IAuthenticationClient>();
            client.Setup(c => c.ProviderName).Returns("yahoo");
            client.Setup(c => c.RequestAuthentication(
                                    context.Object,
                                    It.Is<Uri>(u => u.AbsoluteUri.StartsWith("http://yahoo.com/?__provider__=yahoo", StringComparison.OrdinalIgnoreCase))))
                  .Verifiable();

            OAuthWebSecurity.RegisterClient(client.Object);

            // Act
            OAuthWebSecurity.RequestAuthenticationCore(context.Object, "yahoo", "http://yahoo.com");

            // Assert
            client.Verify();
        }

        [Fact]
        public void VerifyAuthenticationFail()
        {
            // Arrange
            var queryStrings = new NameValueCollection();
            queryStrings.Add("__provider__", "twitter");

            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Request.QueryString).Returns(queryStrings);

            var client = new Mock<IAuthenticationClient>(MockBehavior.Strict);
            client.Setup(c => c.ProviderName).Returns("facebook");
            client.Setup(c => c.VerifyAuthentication(context.Object)).Returns(new AuthenticationResult(true, "facebook", "123",
                                                                                                "super", null));

            var anotherClient = new Mock<IAuthenticationClient>(MockBehavior.Strict);
            anotherClient.Setup(c => c.ProviderName).Returns("twitter");
            anotherClient.Setup(c => c.VerifyAuthentication(context.Object)).Returns(AuthenticationResult.Failed);

            OAuthWebSecurity.RegisterClient(client.Object);
            OAuthWebSecurity.RegisterClient(anotherClient.Object);

            // Act
            AuthenticationResult result = OAuthWebSecurity.VerifyAuthenticationCore(context.Object, "one.aspx");

            // Assert
            Assert.False(result.IsSuccessful);
            Assert.Equal("twitter", result.Provider);
        }

        [Fact]
        public void VerifyAuthenticationFailIfNoProviderInQueryString()
        {
            // Arrange
            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Request.QueryString).Returns(new NameValueCollection());

            var client = new Mock<IAuthenticationClient>(MockBehavior.Strict);
            client.Setup(c => c.ProviderName).Returns("facebook");

            var anotherClient = new Mock<IAuthenticationClient>(MockBehavior.Strict);
            anotherClient.Setup(c => c.ProviderName).Returns("twitter");

            OAuthWebSecurity.RegisterClient(client.Object);
            OAuthWebSecurity.RegisterClient(anotherClient.Object);

            // Act
            AuthenticationResult result = OAuthWebSecurity.VerifyAuthenticationCore(context.Object, "");

            // Assert
            Assert.False(result.IsSuccessful);
            Assert.Null(result.Provider);
        }

        [Fact]
        public void LoginSetAuthenticationTicketIfSuccessful()
        {
            var originalProvider = OAuthWebSecurity.OAuthDataProvider;
            try
            {
                // Arrange
                var cookies = new HttpCookieCollection();
                var context = new Mock<HttpContextBase>();
                context.Setup(c => c.Request.IsSecureConnection).Returns(true);
                context.Setup(c => c.Response.Cookies).Returns(cookies);

                var dataProvider = new Mock<IOpenAuthDataProvider>(MockBehavior.Strict);
                dataProvider.Setup(p => p.GetUserNameFromOpenAuth("twitter", "12345")).Returns("hola");
                OAuthWebSecurity.OAuthDataProvider = dataProvider.Object;

                OAuthWebSecurity.RegisterTwitterClient("sdfdsfsd", "dfdsfdsf");

                // Act
                bool successful = OAuthWebSecurity.LoginCore(context.Object, "twitter", "12345", createPersistentCookie: false);

                // Assert
                Assert.True(successful);

                Assert.Single(cookies);
                HttpCookie addedCookie = cookies[0];

                Assert.Equal(FormsAuthentication.FormsCookieName, addedCookie.Name);
                Assert.True(addedCookie.HttpOnly);
                Assert.Equal("/", addedCookie.Path);
                Assert.False(addedCookie.Secure);
                Assert.False(String.IsNullOrEmpty(addedCookie.Value));

                FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(addedCookie.Value);
                Assert.NotNull(ticket);
                Assert.Equal(2, ticket.Version);
                Assert.Equal("hola", ticket.Name);
                Assert.Equal("OAuth", ticket.UserData);
                Assert.False(ticket.IsPersistent);
            }
            finally
            {
                OAuthWebSecurity.OAuthDataProvider = originalProvider;
            }
        }

        [Fact]
        public void LoginFailIfUserIsNotFound()
        {
            var originalProvider = OAuthWebSecurity.OAuthDataProvider;
            try
            {
                // Arrange
                var context = new Mock<HttpContextBase>();
                OAuthWebSecurity.RegisterTwitterClient("consumerKey", "consumerSecrte");

                var dataProvider = new Mock<IOpenAuthDataProvider>();
                dataProvider.Setup(p => p.GetUserNameFromOpenAuth("twitter", "12345")).Returns((string)null);
                OAuthWebSecurity.OAuthDataProvider = dataProvider.Object;

                // Act
                bool successful = OAuthWebSecurity.LoginCore(context.Object, "twitter", "12345", createPersistentCookie: false);

                // Assert
                Assert.False(successful);
            }
            finally
            {
                OAuthWebSecurity.OAuthDataProvider = originalProvider;
            }
        }

        [Fact]
        public void GetOAuthClientReturnsTheCorrectClient()
        {
            // Arrange
            var client = new Mock<IAuthenticationClient>();
            client.Setup(c => c.ProviderName).Returns("facebook");
            OAuthWebSecurity.RegisterClient(client.Object);

            var anotherClient = new Mock<IAuthenticationClient>();
            anotherClient.Setup(c => c.ProviderName).Returns("hulu");
            OAuthWebSecurity.RegisterClient(anotherClient.Object);

            // Act
            var expectedClient = OAuthWebSecurity.GetOAuthClient("facebook");

            // Assert
            Assert.Same(expectedClient, client.Object);
        }

        [Fact]
        public void GetOAuthClientThrowsIfClientIsNotFound()
        {
            // Arrange
            var client = new Mock<IAuthenticationClient>();
            client.Setup(c => c.ProviderName).Returns("facebook");
            OAuthWebSecurity.RegisterClient(client.Object);

            var anotherClient = new Mock<IAuthenticationClient>();
            anotherClient.Setup(c => c.ProviderName).Returns("hulu");
            OAuthWebSecurity.RegisterClient(anotherClient.Object);

            // Act & Assert
            Assert.Throws<ArgumentException>(() => OAuthWebSecurity.GetOAuthClient("live"));
        }

        [Fact]
        public void TryGetOAuthClientSucceeds()
        {
            // Arrange
            var client = new Mock<IAuthenticationClient>();
            client.Setup(c => c.ProviderName).Returns("facebook");
            OAuthWebSecurity.RegisterClient(client.Object);

            var anotherClient = new Mock<IAuthenticationClient>();
            anotherClient.Setup(c => c.ProviderName).Returns("hulu");
            OAuthWebSecurity.RegisterClient(anotherClient.Object);

            // Act
            IAuthenticationClient expectedClient;
            bool result = OAuthWebSecurity.TryGetOAuthClient("facebook", out expectedClient);

            // Assert
            Assert.Same(expectedClient, client.Object);
            Assert.True(result);
        }

        [Fact]
        public void TryGetOAuthClientFail()
        {
            // Arrange
            var client = new Mock<IAuthenticationClient>();
            client.Setup(c => c.ProviderName).Returns("facebook");
            OAuthWebSecurity.RegisterClient(client.Object);

            var anotherClient = new Mock<IAuthenticationClient>();
            anotherClient.Setup(c => c.ProviderName).Returns("hulu");
            OAuthWebSecurity.RegisterClient(anotherClient.Object);

            // Act
            IAuthenticationClient expectedClient;
            bool result = OAuthWebSecurity.TryGetOAuthClient("live", out expectedClient);

            // Assert
            Assert.Null(expectedClient);
            Assert.False(result);
        }

        [Fact]
        public void TestRegisterFacebookClient()
        {
            // Arrange
            OAuthWebSecurity.RegisterFacebookClient("one", "two", displayName: "FB", extraData: null);

            // Act
            var data = OAuthWebSecurity.RegisteredClientData;

            // Assert
            Assert.True(data.IsReadOnly);
            Assert.Equal(1, data.Count);
            Assert.Equal("facebook", data.First().AuthenticationClient.ProviderName);
            Assert.Equal("FB", data.First().DisplayName);
            Assert.Null(data.First().ExtraData);
        }

        [Fact]
        public void TestRegisterMicrosoftClient()
        {
            // Arrange
            OAuthWebSecurity.RegisterMicrosoftClient("one", "two", displayName: "MS", extraData: null);

            // Act
            var data = OAuthWebSecurity.RegisteredClientData;

            // Assert
            Assert.True(data.IsReadOnly);
            Assert.Equal(1, data.Count);
            Assert.Equal("microsoft", data.First().AuthenticationClient.ProviderName);
            Assert.Equal("MS", data.First().DisplayName);
            Assert.Null(data.First().ExtraData);
        }

        [Fact]
        public void TestRegisterTwitterClient()
        {
            // Arrange
            OAuthWebSecurity.RegisterTwitterClient("x0", "y0", displayName: "Tweet", extraData: null);

            // Act
            var data = OAuthWebSecurity.RegisteredClientData;

            // Assert
            Assert.True(data.IsReadOnly);
            Assert.Equal(1, data.Count);
            Assert.Equal("twitter", data.First().AuthenticationClient.ProviderName);
            Assert.Equal("Tweet", data.First().DisplayName);
            Assert.Null(data.First().ExtraData);
        }

        [Fact]
        public void TestRegisterLinkedInClient()
        {
            // Arrange
            OAuthWebSecurity.RegisterLinkedInClient("x0", "y0", displayName: "LINKED", extraData: null);

            // Act
            var data = OAuthWebSecurity.RegisteredClientData;

            // Assert
            Assert.True(data.IsReadOnly);
            Assert.Equal(1, data.Count);
            Assert.Equal("linkedIn", data.First().AuthenticationClient.ProviderName);
            Assert.Equal("LINKED", data.First().DisplayName);
            Assert.Null(data.First().ExtraData);
        }

        [Fact]
        public void TestRegisterGoogleClient()
        {
            // Arrange
            OAuthWebSecurity.RegisterGoogleClient(displayName: "GOOG", extraData: null);

            // Act
            var data = OAuthWebSecurity.RegisteredClientData;

            // Assert
            Assert.True(data.IsReadOnly);
            Assert.Equal(1, data.Count);
            Assert.Equal("google", data.First().AuthenticationClient.ProviderName);
            Assert.Equal("GOOG", data.First().DisplayName);
            Assert.Null(data.First().ExtraData);
        }

        [Fact]
        public void TestRegisterYahooClient()
        {
            // Arrange
            OAuthWebSecurity.RegisterYahooClient(displayName: "YHOO", extraData: null);

            // Act
            var data = OAuthWebSecurity.RegisteredClientData;

            // Assert
            Assert.True(data.IsReadOnly);
            Assert.Equal(1, data.Count);
            Assert.Equal("yahoo", data.First().AuthenticationClient.ProviderName);
            Assert.Equal("YHOO", data.First().DisplayName);
            Assert.Null(data.First().ExtraData);
        }

        public void Dispose()
        {
            OAuthWebSecurity.ClearProviders();
        }
    }
}


================================================
FILE: test/Microsoft.Web.WebPages.OAuth.Test/PreAppStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace Microsoft.Web.WebPages.OAuth.Test
{
    public class PreAppStartCodeTest
    {
        [Fact]
        public void TestPreAppStartClass()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }
    }
}


================================================
FILE: test/Microsoft.Web.WebPages.OAuth.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="DotNetOpenAuth.AspNet" version="4.0.3.12153" targetFramework="net462" />
  <package id="DotNetOpenAuth.Core" version="4.0.3.12153" targetFramework="net462" />
  <package id="DotNetOpenAuth.OAuth.Consumer" version="4.0.3.12153" targetFramework="net462" />
  <package id="DotNetOpenAuth.OAuth.Core" version="4.0.3.12153" targetFramework="net462" />
  <package id="DotNetOpenAuth.OpenId.Core" version="4.0.3.12153" targetFramework="net462" />
  <package id="DotNetOpenAuth.OpenId.RelyingParty" version="4.0.3.12153" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/Settings.StyleCop
================================================
<StyleCopSettings Version="105">
  <GlobalSettings>
    <StringProperty Name="MergeSettingsFiles">Parent</StringProperty>
  </GlobalSettings>
  <Analyzers>
    <Analyzer AnalyzerId="Microsoft.Web.StyleCop.Rules">
      <Rules>
        <Rule Name="DoNotUseBuiltInTypeAliasInExpression">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.DocumentationRules">
      <AnalyzerSettings>
        <BooleanProperty Name="IncludeFields">False</BooleanProperty>
      </AnalyzerSettings>
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.LayoutRules">
      <Rules>
        <Rule Name="CurlyBracketsForMultiLineStatementsMustNotShareLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="StatementMustNotBeOnSingleLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ElementMustNotBeOnSingleLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="CurlyBracketsMustNotBeOmitted">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="CodeMustNotContainMultipleBlankLinesInARow">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ClosingCurlyBracketsMustNotBePrecededByBlankLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="OpeningCurlyBracketsMustNotBePrecededByBlankLine">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.MaintainabilityRules">
      <Rules>
        <Rule Name="AccessModifierMustBeDeclared">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileMayOnlyContainASingleClass">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FileMayOnlyContainASingleNamespace">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="RemoveDelegateParenthesisWhenPossible">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.NamingRules">
      <Rules>
        <Rule Name="ElementMustBeginWithUpperCaseLetter">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ConstFieldNamesMustBeginWithUpperCaseLetter">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FieldNamesMustNotUseHungarianNotation">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FieldNamesMustBeginWithLowerCaseLetter">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="AccessibleFieldsMustBeginWithUpperCaseLetter">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="FieldNamesMustNotContainUnderscore">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.OrderingRules">
      <Rules>
        <Rule Name="ElementsMustAppearInTheCorrectOrder">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.ReadabilityRules">
      <Rules>
        <Rule Name="DoNotPrefixCallsWithBaseUnlessLocalImplementationExists">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ClosingParenthesisMustBeOnLineOfLastParameter">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="UseStringEmptyForEmptyStrings">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="UseShorthandForNullableTypes">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
    <Analyzer AnalyzerId="StyleCop.CSharp.SpacingRules">
      <Rules>
        <Rule Name="CommasMustBeSpacedCorrectly">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="SemicolonsMustBeSpacedCorrectly">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="SymbolsMustBeSpacedCorrectly">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="PreprocessorKeywordsMustNotBePrecededBySpace">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ClosingParenthesisMustBeSpacedCorrectly">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="OpeningCurlyBracketsMustBeSpacedCorrectly">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
        <Rule Name="ClosingCurlyBracketsMustBeSpacedCorrectly">
          <RuleSettings>
            <BooleanProperty Name="Enabled">False</BooleanProperty>
          </RuleSettings>
        </Rule>
      </Rules>
      <AnalyzerSettings />
    </Analyzer>
  </Analyzers>
</StyleCopSettings>

================================================
FILE: test/System.Net.Http.Formatting.Test/ByteRangeStreamContentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class ByteRangeStreamContentTest
    {
        private MediaTypeHeaderValue _expectedMediatype = MediaTypeHeaderValue.Parse("text/test");

        public static TheoryDataSet<string, int, string> SingleRanges
        {
            get
            {
                // string ranges, int innerStreamLength, string expectedContentRange)
                return new TheoryDataSet<string, int, string>
                {
                    { "bytes=0-9", 10, "bytes 0-9/10" },
                    { "bytes=0-0", 10, "bytes 0-0/10" },
                    { "bytes=9-9", 10, "bytes 9-9/10" },
                    { "bytes=9-20", 10, "bytes 9-9/10" },
                    { "bytes=1-", 10, "bytes 1-9/10" },
                    { "bytes=8-", 10, "bytes 8-9/10" },
                    { "bytes=9-", 10, "bytes 9-9/10" },
                    { "bytes=-1", 10, "bytes 9-9/10" },
                    { "bytes=-2", 10, "bytes 8-9/10" },
                    { "bytes=-20", 10, "bytes 0-9/10" },
                    { "bytes=-9", 10, "bytes 1-9/10" },
                    { "bytes=-10", 10, "bytes 0-9/10" },
                };
            }
        }

        public static TheoryDataSet<string, int, int, string[]> MultiRanges
        {
            get
            {
                // string ranges, int innerStreamLength, int expectedBodyparts, string[] contentRanges)
                return new TheoryDataSet<string, int, int, string[]>
                {
                    { "bytes=0-9,0-0", 10, 2, new string[] { "bytes 0-9/10", "bytes 0-0/10" } },
                    { "bytes=0-0,0-9", 10, 2, new string[] { "bytes 0-0/10", "bytes 0-9/10" } },
                    { "bytes=0-0,9-20", 10, 2, new string[] { "bytes 0-0/10", "bytes 9-9/10" } },
                    { "bytes=0-0,9-9,9-20", 10, 3, new string[] { "bytes 0-0/10", "bytes 9-9/10", "bytes 9-9/10" } },
                    { "bytes=0-0,9-9,10-20", 10, 2, new string[] { "bytes 0-0/10", "bytes 9-9/10" } },
                };
            }
        }

        public static TheoryDataSet<string, int, string> NoOverlappingRanges
        {
            get
            {
                // string ranges, int innerStreamLength, string expectedContentRange)
                return new TheoryDataSet<string, int, string>
                {
                    { "bytes=100-", 10, "bytes */10" },
                    { "bytes=100-,200-,300-", 10, "bytes */10" },
                };
            }
        }

        [Fact]
        public void Ctor_ThrowsOnNullContent()
        {
            RangeHeaderValue range = new RangeHeaderValue();
            Assert.ThrowsArgumentNull(() => new ByteRangeStreamContent(
                content: null,
                range: range,
                mediaType: _expectedMediatype,
                bufferSize: 128),
                "content");
        }

        [Fact]
        public void Ctor_ThrowsIfCantSeekContent()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(false);
            RangeHeaderValue range = new RangeHeaderValue();

            // Act/Assert
            Assert.ThrowsArgument(() => new ByteRangeStreamContent(
                content: mockInnerStream.Object,
                range: range,
                mediaType: _expectedMediatype,
                bufferSize: 128),
                "content");
        }

        [Fact]
        public void Ctor_ThrowsOnNullRange()
        {
            Assert.ThrowsArgumentNull(() => new ByteRangeStreamContent(
                content: Stream.Null,
                range: null,
                mediaType: _expectedMediatype,
                bufferSize: 128),
                "range");
        }

        [Fact]
        public void Ctor_ThrowsOnNullMediaType()
        {
            RangeHeaderValue range = new RangeHeaderValue();
            Assert.ThrowsArgumentNull(() => new ByteRangeStreamContent(
                content: Stream.Null,
                range: range,
                mediaType: (MediaTypeHeaderValue)null,
                bufferSize: 128),
                "mediaType");
        }

        [Fact]
        public void Ctor_ThrowsOnNullMediaTypeString()
        {
            RangeHeaderValue range = new RangeHeaderValue();
            Assert.ThrowsArgument(() => new ByteRangeStreamContent(
                content: Stream.Null,
                range: range,
                mediaType: (String)null,
                bufferSize: 128),
                "mediaType",
                allowDerivedExceptions: true);
        }

        [Fact]
        public void Ctor_ThrowsOnInvalidBufferSize()
        {
            RangeHeaderValue range = new RangeHeaderValue();
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new ByteRangeStreamContent(
                content: Stream.Null,
                range: range,
                mediaType: _expectedMediatype,
                bufferSize: 0),
                "bufferSize", "1", "0");
        }

        [Fact]
        public void Ctor_ThrowsOnNonByteRangeUnit()
        {
            RangeHeaderValue range = RangeHeaderValue.Parse("pages=0-9");
            Assert.ThrowsArgument(() => new ByteRangeStreamContent(
                content: Stream.Null,
                range: range,
                mediaType: _expectedMediatype,
                bufferSize: 128),
                "range");
        }

        [Fact]
        public void Ctor_ThrowsOnNoByteRanges()
        {
            RangeHeaderValue range = new RangeHeaderValue() { Unit = "bytes" };
            Assert.ThrowsArgument(() => new ByteRangeStreamContent(
                content: Stream.Null,
                range: range,
                mediaType: _expectedMediatype,
                bufferSize: 128),
                "range");
        }

        [Theory]
        [InlineData("bytes=-1")]
        [InlineData("bytes=0-")]
        [InlineData("bytes=0-,10-20,9-9")]
        public void RangesOverZeroLengthStream(string ranges)
        {
            // Arrange
            RangeHeaderValue range = RangeHeaderValue.Parse(ranges);

            // Act
            try
            {
                new ByteRangeStreamContent(Stream.Null, range, _expectedMediatype);
            }
            catch (InvalidByteRangeException invalidByteRangeException)
            {
                ContentRangeHeaderValue expectedContentRange = new ContentRangeHeaderValue(length: 0);
                Assert.Equal(expectedContentRange, invalidByteRangeException.ContentRange);
            }
        }

        [Theory]
        [PropertyData("SingleRanges")]
        public void SingleRangeGeneratesNonMultipartContent(string ranges, int innerStreamLength, string contentRange)
        {
            // Arrange
            string data = new String('a', innerStreamLength);
            byte[] bytes = Encoding.UTF8.GetBytes(data);
            MemoryStream memStream = new MemoryStream(bytes);
            RangeHeaderValue range = RangeHeaderValue.Parse(ranges);

            // Act
            ByteRangeStreamContent rangeContent = new ByteRangeStreamContent(memStream, range, _expectedMediatype);

            // Assert
            Assert.Equal(_expectedMediatype, rangeContent.Headers.ContentType);
            ContentRangeHeaderValue expectedContentRange = ContentRangeHeaderValue.Parse(contentRange);
            Assert.Equal(expectedContentRange, rangeContent.Headers.ContentRange);
        }

        [Theory]
        [PropertyData("MultiRanges")]
        public async Task MultipleRangesGeneratesMultipartByteRangesContent(string ranges, int innerStreamLength, int expectedBodyparts, string[] contentRanges)
        {
            // Arrange
            string data = new String('a', innerStreamLength);
            byte[] bytes = Encoding.UTF8.GetBytes(data);
            MemoryStream memStream = new MemoryStream(bytes);
            RangeHeaderValue range = RangeHeaderValue.Parse(ranges);

            // Act
            ByteRangeStreamContent content = new ByteRangeStreamContent(memStream, range, _expectedMediatype);
            MemoryStream result = new MemoryStream();
            await content.CopyToAsync(result);
            MultipartMemoryStreamProvider multipart = await content.ReadAsMultipartAsync();

            // Assert
            Assert.Equal(expectedBodyparts, multipart.Contents.Count);
            for (int count = 0; count < multipart.Contents.Count; count++)
            {
                MediaTypeHeaderValue contentType = multipart.Contents[count].Headers.ContentType;
                Assert.Equal(_expectedMediatype, contentType);

                ContentRangeHeaderValue expectedContentRange = ContentRangeHeaderValue.Parse(contentRanges[count]);
                ContentRangeHeaderValue contentRange = multipart.Contents[count].Headers.ContentRange;
                Assert.Equal(expectedContentRange, contentRange);
            }
        }

        [Theory]
        [PropertyData("NoOverlappingRanges")]
        public void NoOverlappingRangesThrowException(string ranges, int innerStreamLength, string contentRange)
        {
            // Arrange
            string data = new String('a', innerStreamLength);
            byte[] bytes = Encoding.UTF8.GetBytes(data);
            MemoryStream memStream = new MemoryStream(bytes);
            RangeHeaderValue range = RangeHeaderValue.Parse(ranges);

            // Act
            try
            {
                new ByteRangeStreamContent(memStream, range, _expectedMediatype);
            }
            catch (InvalidByteRangeException invalidByteRangeException)
            {
                ContentRangeHeaderValue expectedContentRange = ContentRangeHeaderValue.Parse(contentRange);
                Assert.Equal(expectedContentRange, invalidByteRangeException.ContentRange);
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/CustomMultipartFormDataRemoteStreamProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Net.Http.Headers;
using Moq;

namespace System.Net.Http
{
    public class CustomMultipartFormDataRemoteStreamProvider : MultipartFormDataRemoteStreamProvider
    {
        public readonly string UrlBase = "http://some/path/to/";

        public readonly List<Stream> RemoteStreams = new List<Stream>();

        private readonly bool _isResultNull;

        public CustomMultipartFormDataRemoteStreamProvider()
        {
        }

        public CustomMultipartFormDataRemoteStreamProvider(bool isResultNull)
        {
            _isResultNull = isResultNull;
        }

        public override RemoteStreamInfo GetRemoteStream(HttpContent parent, HttpContentHeaders headers)
        {
            string fileName = headers.ContentDisposition.FileName;
            return _isResultNull
                ? null
                : new RemoteStreamInfo(CreateMockStream(), UrlBase + fileName, fileName);
        }

        private Stream CreateMockStream()
        {
            Stream stream = new Mock<Stream>().Object;
            RemoteStreams.Add(stream);
            return stream;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/HttpTestData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets.Types;
using System.Net.Http.Headers;
using System.Text;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.DataSets
{
    public class HttpTestData
    {
        public static TestData<HttpMethod> AllHttpMethods
        {
            get
            {
                return new RefTypeTestData<HttpMethod>(() =>
                    StandardHttpMethods.Concat(CustomHttpMethods).ToList());
            }
        }

        public static TestData<HttpMethod> StandardHttpMethods
        {
            get
            {
                return new RefTypeTestData<HttpMethod>(() => new List<HttpMethod>()
                {
                    HttpMethod.Head,
                    HttpMethod.Get,
                    HttpMethod.Post,
                    HttpMethod.Put,
                    HttpMethod.Delete,
                    HttpMethod.Options,
                    HttpMethod.Trace,
                });
            }
        }

        public static TestData<HttpMethod> CustomHttpMethods
        {
            get
            {
                return new RefTypeTestData<HttpMethod>(() => new List<HttpMethod>()
                {
                    new HttpMethod("Custom")
                });
            }
        }

        public static TestData<HttpStatusCode> AllHttpStatusCodes
        {
            get
            {
                return new ValueTypeTestData<HttpStatusCode>(new HttpStatusCode[]
                {
                    HttpStatusCode.Accepted,
                    HttpStatusCode.Ambiguous,
                    HttpStatusCode.BadGateway,
                    HttpStatusCode.BadRequest,
                    HttpStatusCode.Conflict,
                    HttpStatusCode.Continue,
                    HttpStatusCode.Created,
                    HttpStatusCode.ExpectationFailed,
                    HttpStatusCode.Forbidden,
                    HttpStatusCode.Found,
                    HttpStatusCode.GatewayTimeout,
                    HttpStatusCode.Gone,
                    HttpStatusCode.HttpVersionNotSupported,
                    HttpStatusCode.InternalServerError,
                    HttpStatusCode.LengthRequired,
                    HttpStatusCode.MethodNotAllowed,
                    HttpStatusCode.Moved,
                    HttpStatusCode.MovedPermanently,
                    HttpStatusCode.MultipleChoices,
                    HttpStatusCode.NoContent,
                    HttpStatusCode.NonAuthoritativeInformation,
                    HttpStatusCode.NotAcceptable,
                    HttpStatusCode.NotFound,
                    HttpStatusCode.NotImplemented,
                    HttpStatusCode.NotModified,
                    HttpStatusCode.OK,
                    HttpStatusCode.PartialContent,
                    HttpStatusCode.PaymentRequired,
                    HttpStatusCode.PreconditionFailed,
                    HttpStatusCode.ProxyAuthenticationRequired,
                    HttpStatusCode.Redirect,
                    HttpStatusCode.RedirectKeepVerb,
                    HttpStatusCode.RedirectMethod,
                    HttpStatusCode.RequestedRangeNotSatisfiable,
                    HttpStatusCode.RequestEntityTooLarge,
                    HttpStatusCode.RequestTimeout,
                    HttpStatusCode.RequestUriTooLong,
                    HttpStatusCode.ResetContent,
                    HttpStatusCode.SeeOther,
                    HttpStatusCode.ServiceUnavailable,
                    HttpStatusCode.SwitchingProtocols,
                    HttpStatusCode.TemporaryRedirect,
                    HttpStatusCode.Unauthorized,
                    HttpStatusCode.UnsupportedMediaType,
                    HttpStatusCode.Unused,
                    HttpStatusCode.UseProxy
                });
            }
        }

        public static TestData<HttpStatusCode> CustomHttpStatusCodes
        {
            get
            {
                return new ValueTypeTestData<HttpStatusCode>(new HttpStatusCode[]
                {
                    (HttpStatusCode)199,
                    (HttpStatusCode)299,
                    (HttpStatusCode)399,
                    (HttpStatusCode)499,
                    (HttpStatusCode)599,
                    (HttpStatusCode)699,
                    (HttpStatusCode)799,
                    (HttpStatusCode)899,
                    (HttpStatusCode)999,
                });
            }
        }

        public static ReadOnlyCollection<TestData> ConvertablePrimitiveValueTypes
        {
            get
            {
                return new ReadOnlyCollection<TestData>(new TestData[]
                {
                    TestData.CharTestData,
                    TestData.IntTestData,
                    TestData.UintTestData,
                    TestData.ShortTestData,
                    TestData.UshortTestData,
                    TestData.LongTestData,
                    TestData.UlongTestData,
                    TestData.ByteTestData,
                    TestData.SByteTestData,
                    TestData.BoolTestData,
                    TestData.DoubleTestData,
                    TestData.FloatTestData,
                    TestData.DecimalTestData,
                    TestData.TimeSpanTestData,
                    TestData.GuidTestData,
                    TestData.DateTimeTestData,
                    TestData.DateTimeOffsetTestData
                });
            }
        }

        public static ReadOnlyCollection<TestData> ConvertableEnumTypes
        {
            get
            {
                return new ReadOnlyCollection<TestData>(new TestData[]
                {
                    TestData.SimpleEnumTestData,
                    TestData.LongEnumTestData,
                    TestData.FlagsEnumTestData,
                    DataContractEnumTestData
                });
            }
        }

        public static ReadOnlyCollection<TestData> ConvertableValueTypes
        {
            get
            {
                return new ReadOnlyCollection<TestData>(
                    ConvertablePrimitiveValueTypes.Concat(ConvertableEnumTypes).ToList());
            }
        }

        public static TestData<MediaTypeHeaderValue> StandardBsonMediaTypes
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(() => new List<MediaTypeHeaderValue>()
                {
                    new MediaTypeHeaderValue("application/bson"),
                });
            }
        }

        public static TestData<MediaTypeHeaderValue> StandardJsonMediaTypes
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(() => new List<MediaTypeHeaderValue>()
                {
                    new MediaTypeHeaderValue("application/json"),
                    new MediaTypeHeaderValue("text/json")
                });
            }
        }

        public static TestData<MediaTypeHeaderValue> StandardXmlMediaTypes
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(() => new List<MediaTypeHeaderValue>()
                {
                    new MediaTypeHeaderValue("application/xml"),
                    new MediaTypeHeaderValue("text/xml")
                });
            }
        }

        public static TestData<MediaTypeHeaderValue> StandardODataMediaTypes
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(() => new List<MediaTypeHeaderValue>()
                {
                    new MediaTypeHeaderValue("application/atom+xml"),
                    new MediaTypeHeaderValue("application/json"),
                });
            }
        }

        public static TestData<MediaTypeHeaderValue> StandardFormUrlEncodedMediaTypes
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(() => new List<MediaTypeHeaderValue>()
                {
                    new MediaTypeHeaderValue("application/x-www-form-urlencoded")
                });
            }
        }

        public static TestData<string> StandardJsonMediaTypeStrings
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "application/json",
                    "text/json"
                });
            }
        }

        public static TestData<string> StandardXmlMediaTypeStrings
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "application/xml",
                    "text/xml"
                });
            }
        }

        public static TestData<string> LegalMediaTypeStrings
        {
            get
            {
                return new RefTypeTestData<string>(() =>
                    StandardXmlMediaTypeStrings.Concat(StandardJsonMediaTypeStrings).ToList());
            }
        }


        // Illegal media type strings.  These will cause the MediaTypeHeaderValue ctor to throw FormatException
        public static TestData<string> IllegalMediaTypeStrings
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "\0",
                    "9\r\n"
                });
            }
        }

        public static TestData<Encoding> StandardEncodings
        {
            get
            {
                return new RefTypeTestData<Encoding>(() => new List<Encoding>()
                {
                    new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true),
                    new UnicodeEncoding(bigEndian: false, byteOrderMark: true, throwOnInvalidBytes: true),
                });
            }
        }

        public static TheoryDataSet<string, string, bool> ReadAndWriteCorrectCharacterEncoding
        {
            get
            {
                return new TheoryDataSet<string, string, bool>
                {
                    { "This is a test 激光這兩個字是甚麼意思 string written using utf-8", "utf-8", true },
                    { "This is a test 激光這兩個字是甚麼意思 string written using utf-16", "utf-16", true },
                    { "This is a test 激光這兩個字是甚麼意思 string written using utf-32", "utf-32", false },
#if !NETCOREAPP // shift_jis and iso-2022-kr are not supported when running on .NET Core 2.1.
                    { "This is a test 激光這兩個字是甚麼意思 string written using shift_jis", "shift_jis", false },
#endif
                    { "This is a test æøå string written using iso-8859-1", "iso-8859-1", false },
#if !NETCOREAPP
                    { "This is a test 레이저 단어 뜻 string written using iso-2022-kr", "iso-2022-kr", false },
#endif
                };
            }
        }

        //// TODO: complete this list
        // Legal MediaTypeHeaderValues
        public static TestData<MediaTypeHeaderValue> LegalMediaTypeHeaderValues
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(
                    () => LegalMediaTypeStrings.Select(mediaType => new MediaTypeHeaderValue(mediaType)).ToList());
            }
        }

        public static TestData<MediaTypeWithQualityHeaderValue> StandardMediaTypesWithQuality
        {
            get
            {
                return new RefTypeTestData<MediaTypeWithQualityHeaderValue>(() => new List<MediaTypeWithQualityHeaderValue>()
                {
                    new MediaTypeWithQualityHeaderValue("application/json", .1) { CharSet="utf-8"},
                    new MediaTypeWithQualityHeaderValue("text/json", .2) { CharSet="utf-8"},
                    new MediaTypeWithQualityHeaderValue("application/xml", .3) { CharSet="utf-8"},
                    new MediaTypeWithQualityHeaderValue("text/xml", .4) { CharSet="utf-8"},
                    new MediaTypeWithQualityHeaderValue("application/atom+xml", .5) { CharSet="utf-8"},
                });
            }
        }

        public static TestData<HttpContent> StandardHttpContents
        {
            get
            {
                return new RefTypeTestData<HttpContent>(() => new List<HttpContent>()
                {
                    new ByteArrayContent(new byte[0]),
                    new FormUrlEncodedContent(new KeyValuePair<string, string>[0]),
                    new MultipartContent(),
                    new StringContent(""),
                    new StreamContent(new MemoryStream())
                });
            }
        }

        //// TODO: make this list compose from other data?
        // Collection of legal instances of all standard MediaTypeMapping types
        public static TestData<MediaTypeMapping> StandardMediaTypeMappings
        {
            get
            {
                return new RefTypeTestData<MediaTypeMapping>(() => QueryStringMappings.Cast<MediaTypeMapping>().ToList());
            }
        }

        public static TestData<QueryStringMapping> QueryStringMappings
        {
            get
            {
                return new RefTypeTestData<QueryStringMapping>(() => new List<QueryStringMapping>()
                {
                    new QueryStringMapping("format", "json", new MediaTypeHeaderValue("application/json"))
                });
            }
        }

        public static TestData<string> LegalUriPathExtensions
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "xml",
                    "json"
                });
            }
        }

        public static TestData<string> LegalQueryStringParameterNames
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "format",
                    "fmt"
                });
            }
        }

        public static TestData<string> LegalHttpHeaderNames
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "x-requested-with",
                    "some-random-name"
                });
            }
        }

        public static TestData<string> LegalHttpHeaderValues
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "1",
                    "XMLHttpRequest",
                    "\"quoted-string\""
                });
            }
        }

        public static TestData<string> LegalQueryStringParameterValues
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "xml",
                    "json"
                });
            }
        }

        public static TestData<string> LegalMediaRangeStrings
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "application/*",
                    "text/*"
                });
            }
        }

        public static TestData<MediaTypeHeaderValue> LegalMediaRangeValues
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(() =>
                    LegalMediaRangeStrings.Select(s => new MediaTypeHeaderValue(s)).ToList()
                    );
            }
        }

        public static TestData<MediaTypeWithQualityHeaderValue> MediaRangeValuesWithQuality
        {
            get
            {
                return new RefTypeTestData<MediaTypeWithQualityHeaderValue>(() => new List<MediaTypeWithQualityHeaderValue>()
                {
                    new MediaTypeWithQualityHeaderValue("application/*", .1),
                    new MediaTypeWithQualityHeaderValue("text/*", .2),
                });
            }
        }

        public static TestData<string> IllegalMediaRangeStrings
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "application/xml",
                    "text/xml"
                });
            }
        }

        public static TestData<MediaTypeHeaderValue> IllegalMediaRangeValues
        {
            get
            {
                return new RefTypeTestData<MediaTypeHeaderValue>(() =>
                    IllegalMediaRangeStrings.Select(s => new MediaTypeHeaderValue(s)).ToList()
                    );
            }
        }

        public static TestData<MediaTypeFormatter> StandardFormatters
        {
            get
            {
                return new RefTypeTestData<MediaTypeFormatter>(() => new List<MediaTypeFormatter>()
                {
                    new XmlMediaTypeFormatter(),
                    new JsonMediaTypeFormatter(),
                    new FormUrlEncodedMediaTypeFormatter()
                });
            }
        }

        public static TestData<Type> StandardFormatterTypes
        {
            get
            {
                return new RefTypeTestData<Type>(() => StandardFormatters.Select(m => m.GetType()));
            }
        }

        public static TestData<MediaTypeFormatter> DerivedFormatters
        {
            get
            {
                return new RefTypeTestData<MediaTypeFormatter>(() => new List<MediaTypeFormatter>()
                {
                    new DerivedXmlMediaTypeFormatter(),
                    new DerivedJsonMediaTypeFormatter(),
                    new DerivedFormUrlEncodedMediaTypeFormatter(),
                });
            }
        }

        public static TestData<IEnumerable<MediaTypeFormatter>> AllFormatterCollections
        {
            get
            {
                return new RefTypeTestData<IEnumerable<MediaTypeFormatter>>(() => new List<IEnumerable<MediaTypeFormatter>>()
                {
                    new MediaTypeFormatter[0],
                    StandardFormatters,
                    DerivedFormatters,
                });
            }
        }

        public static TestData<string> LegalHttpAddresses
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "http://somehost",
                    "https://somehost",
                });
            }
        }

        public static TestData<string> AddressesWithIllegalSchemes
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "net.tcp://somehost",
                    "file://somehost",
                    "net.pipe://somehost",
                    "mailto:somehost",
                    "ftp://somehost",
                    "news://somehost",
                    "ws://somehost",
                    "abc://somehost"
                });
            }
        }

        /// <summary>
        /// A read-only collection of representative values and reference type test data.
        /// Uses where exhaustive coverage is not required.  It includes null values.
        /// </summary>
        public static ReadOnlyCollection<TestData> RepresentativeValueAndRefTypeTestDataCollection
        {
            get
            {
                return new ReadOnlyCollection<TestData>(new TestData[]
                {
                     TestData.ByteTestData,
                     TestData.IntTestData,
                     TestData.BoolTestData,
                     TestData.SimpleEnumTestData,
                     TestData.StringTestData,
                     TestData.DateTimeTestData,
                     TestData.DateTimeOffsetTestData,
                     TestData.TimeSpanTestData,
                     WcfPocoTypeTestDataWithNull
                });
            }
        }

        public static TestData<HttpRequestMessage> NullContentHttpRequestMessages
        {
            get
            {
                return new RefTypeTestData<HttpRequestMessage>(() => new List<HttpRequestMessage>()
                {
                   new HttpRequestMessage() { Content = null },
                });
            }
        }

        public static TestData<string> LegalHttpParameterNames
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "文",
                    "A",
                    "a",
                    "b",
                    " a",
                    "arg1",
                    "arg2",
                    "1",
                    "@",
                    "!"
                });
            }
        }

        public static TestData<Type> LegalHttpParameterTypes
        {
            get
            {
                return new RefTypeTestData<Type>(() => new List<Type>()
                {
                    typeof(string),
                    typeof(byte[]),
                    typeof(byte[][]),
                    typeof(char),
                    typeof(DateTime),
                    typeof(decimal),
                    typeof(double),
                    typeof(Guid),
                    typeof(Int16),
                    typeof(Int32),
                    typeof(object),
                    typeof(sbyte),
                    typeof(Single),
                    typeof(TimeSpan),
                    typeof(UInt16),
                    typeof(UInt32),
                    typeof(UInt64),
                    typeof(Uri),
                    typeof(Enum),
                    typeof(Collection<object>),
                    typeof(IList<object>),
                    typeof(System.Runtime.Serialization.ISerializable),
                    typeof(System.Data.DataSet),
                    typeof(System.Xml.Serialization.IXmlSerializable),
                    typeof(Nullable),
                    typeof(Nullable<DateTime>),
                    typeof(Stream),
                    typeof(HttpRequestMessage),
                    typeof(HttpResponseMessage),
                    typeof(ObjectContent),
                    typeof(ObjectContent<object>),
                    typeof(HttpContent),
                    typeof(Delegate),
                    typeof(Action),
                    typeof(System.Threading.Tasks.Task<object>),
                    typeof(System.Threading.Tasks.Task),
                    typeof(List<dynamic>)
                });
            }
        }

        /// <summary>
        /// Common <see cref="TestData"/> for an <c>enum</c> decorated with a <see cref="DataContractAttribute"/>.
        /// </summary>
        public static ValueTypeTestData<DataContractEnum> DataContractEnumTestData
        {
            get
            {
                return new ValueTypeTestData<DataContractEnum>(
                    DataContractEnum.First,
                    DataContractEnum.Second);
            }
        }

        /// <summary>
        ///  Common <see cref="TestData"/> for the string form of a <see cref="Uri"/>.
        /// </summary>
        public static RefTypeTestData<string> UriTestDataStrings
        {
            get
            {
                return new RefTypeTestData<string>(() => new List<string>()
                {
                    "http://somehost",
                    "http://somehost:8080",
                    "http://somehost/",
                    "http://somehost:8080/",
                    "http://somehost/somepath",
                    "http://somehost/somepath/",
                    "http://somehost/somepath?somequery=somevalue"
                });
            }
        }

        /// <summary>
        ///  Common <see cref="TestData"/> for a <see cref="Uri"/>.
        /// </summary>
        public static RefTypeTestData<Uri> UriTestData
        {
            get
            {
                return new RefTypeTestData<Uri>(() => UriTestDataStrings.Select(s => new Uri(s)).ToList());
            }
        }

        /// <summary>
        ///  Common <see cref="TestData"/> for a POCO class type that includes null values
        ///  for both the base class and derived classes.
        /// </summary>
        public static RefTypeTestData<WcfPocoType> WcfPocoTypeTestDataWithNull
        {
            get
            {
                return new RefTypeTestData<WcfPocoType>(
                    WcfPocoType.GetTestDataWithNull,
                    WcfPocoType.GetDerivedTypeTestDataWithNull,
                    null);
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DataContractEnum.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.Serialization;

namespace System.Net.Http.Formatting.DataSets.Types
{
    [DataContract]
    public enum DataContractEnum
    {
        [EnumMember]
        First,

        [EnumMember]
        Second,

        Third
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DataContractType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml.Serialization;
using Microsoft.TestCommon.Types;

namespace System.Net.Http.Formatting.DataSets.Types
{
    [DataContract]
    [KnownType(typeof(DerivedDataContractType))]
    [XmlInclude(typeof(DerivedDataContractType))]
    public class DataContractType : INameAndIdContainer
    {
        private int id;
        private string name;

        public DataContractType()
        {
        }

        public DataContractType(int id, string name)
        {
            this.id = id;
            this.name = name;
        }

        [DataMember]
        public int Id
        {
            get
            {
                return this.id;
            }

            set
            {
                this.IdSet = true;
                this.id = value;
            }
        }

        [DataMember]
        public string Name
        {
            get
            {
                return this.name;
            }

            set
            {
                this.NameSet = true;
                this.name = value;
            }
        }

        [XmlIgnore]
        public bool IdSet { get; private set; }

        [XmlIgnore]
        public bool NameSet { get; private set; }

        public static IEnumerable<DataContractType> GetTestData()
        {
            return new DataContractType[] { new DataContractType(), new DataContractType(1, "SomeName") };
        }

        public static IEnumerable<DerivedDataContractType> GetDerivedTypeTestData()
        {
            return new DerivedDataContractType[] { 
                new DerivedDataContractType(), 
                new DerivedDataContractType(1, "SomeName", null), 
                new DerivedDataContractType(1, "SomeName", new WcfPocoType(2, "SomeOtherName"))};
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DerivedDataContractType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml.Serialization;

namespace System.Net.Http.Formatting.DataSets.Types
{
    [DataContract]
    [KnownType(typeof(DerivedWcfPocoType))]
    [KnownType(typeof(DerivedDataContractType))]
    [XmlInclude(typeof(DerivedWcfPocoType))]
    [XmlInclude(typeof(DerivedDataContractType))]
    public class DerivedDataContractType : DataContractType
    {
        private WcfPocoType reference;

        public DerivedDataContractType()
        {
        }

        public DerivedDataContractType(int id, string name, WcfPocoType reference)
            : base(id, name)
        {
            this.reference = reference;
        }

        [DataMember]
        public WcfPocoType Reference
        {
            get
            {
                return this.reference;
            }

            set
            {
                this.ReferenceSet = true;
                this.reference = value;
            }
        }

        [XmlIgnore]
        public bool ReferenceSet { get; private set; }

        public static new IEnumerable<DerivedDataContractType> GetTestData()
        {
            return new DerivedDataContractType[] { 
                new DerivedDataContractType(), 
                new DerivedDataContractType(1, "SomeName", new WcfPocoType(2, "SomeOtherName")) };
        }

        public static IEnumerable<DerivedDataContractType> GetKnownTypeTestData()
        {
            return new DerivedDataContractType[] { 
                new DerivedDataContractType(), 
                new DerivedDataContractType(1, "SomeName", null), 
                new DerivedDataContractType(1, "SomeName", new DerivedWcfPocoType(2, "SomeOtherName", null))};
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DerivedFormUrlEncodedMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Net.Http.Formatting.DataSets.Types
{
    public class DerivedFormUrlEncodedMediaTypeFormatter : FormUrlEncodedMediaTypeFormatter
    {
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DerivedJsonMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Net.Http.Formatting.DataSets.Types
{
    public class DerivedJsonMediaTypeFormatter : JsonMediaTypeFormatter
    {
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DerivedWcfPocoType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.Serialization;
using System.Xml.Serialization;

namespace System.Net.Http.Formatting.DataSets.Types
{
    public class DerivedWcfPocoType : WcfPocoType
    {
        private WcfPocoType reference;

        public DerivedWcfPocoType()
        {
        }

        public DerivedWcfPocoType(int id, string name, WcfPocoType reference)
            : base(id, name)
        {
            this.reference = reference;
        }

        public WcfPocoType Reference
        {
            get
            {
                return this.reference;
            }

            set
            {
                this.ReferenceSet = true;
                this.reference = value;
            }
        }

        [IgnoreDataMember]
        [XmlIgnore]
        public bool ReferenceSet { get; private set; }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DerivedXmlMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Net.Http.Formatting.DataSets.Types
{
    public class DerivedXmlMediaTypeFormatter : XmlMediaTypeFormatter
    {
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/DerivedXmlSerializableType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml.Serialization;

namespace System.Net.Http.Formatting.DataSets.Types
{
    [KnownType(typeof(DerivedWcfPocoType))]
    [XmlInclude(typeof(DerivedWcfPocoType))]
    public class DerivedXmlSerializableType : XmlSerializableType, INotJsonSerializable
    {
        private WcfPocoType reference;

        public DerivedXmlSerializableType()
        {
        }

        public DerivedXmlSerializableType(int id, string name, WcfPocoType reference)
            : base(id, name)
        {
            this.reference = reference;
        }

        [XmlElement]
        public WcfPocoType Reference
        {
            get
            {
                return this.reference;
            }

            set
            {
                this.ReferenceSet = true;
                this.reference = value;
            }
        }

        [XmlIgnore]
        public bool ReferenceSet { get; private set; }

        public static new IEnumerable<DerivedXmlSerializableType> GetTestData()
        {
            return new DerivedXmlSerializableType[] { 
                new DerivedXmlSerializableType(), 
                new DerivedXmlSerializableType(1, "SomeName", new WcfPocoType(2, "SomeOtherName")) };
        }

        public static IEnumerable<DerivedXmlSerializableType> GetKnownTypeTestData()
        {
            return new DerivedXmlSerializableType[] { 
                new DerivedXmlSerializableType(), 
                new DerivedXmlSerializableType(1, "SomeName", null), 
                new DerivedXmlSerializableType(1, "SomeName", new DerivedWcfPocoType(2, "SomeOtherName", null))};
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/INotJsonSerializable.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http.Formatting.DataSets.Types
{
    /// <summary>
    /// Tagging interface to indicate types which we know Json cannot serialize.
    /// </summary>
    public interface INotJsonSerializable
    {
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/WcfPocoType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Runtime.Serialization;
using System.Xml.Serialization;
using Microsoft.TestCommon.Types;

namespace System.Net.Http.Formatting.DataSets.Types
{
    [KnownType(typeof(DerivedWcfPocoType))]
    [XmlInclude(typeof(DerivedWcfPocoType))]
    public class WcfPocoType : INameAndIdContainer
    {
        private int id;
        private string name;

        public WcfPocoType()
        {
        }

        public WcfPocoType(int id, string name)
        {
            this.id = id;
            this.name = name;
        }

        public int Id
        {
            get
            {
                return this.id;
            }

            set
            {
                this.IdSet = true;
                this.id = value;
            }
        }

        public string Name
        {
            get
            {
                return this.name;
            }

            set
            {
                this.NameSet = true;
                this.name = value;
            }

        }

        [IgnoreDataMember]
        [XmlIgnore]
        public bool IdSet { get; private set; }

        [IgnoreDataMember]
        [XmlIgnore]
        public bool NameSet { get; private set; }

        public static IEnumerable<WcfPocoType> GetTestData()
        {
            return new WcfPocoType[] { new WcfPocoType(), new WcfPocoType(1, "SomeName") };
        }

        public static IEnumerable<WcfPocoType> GetTestDataWithNull()
        {
            return GetTestData().Concat(new WcfPocoType[] { null });
        }

        public static IEnumerable<DerivedWcfPocoType> GetDerivedTypeTestData()
        {
            return new DerivedWcfPocoType[] { 
                new DerivedWcfPocoType(), 
                new DerivedWcfPocoType(1, "SomeName", null), 
                new DerivedWcfPocoType(1, "SomeName", new WcfPocoType(2, "SomeOtherName"))};
        }

        public static IEnumerable<DerivedWcfPocoType> GetDerivedTypeTestDataWithNull()
        {
            return GetDerivedTypeTestData().Concat(new DerivedWcfPocoType[] { null });
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/DataSets/Types/XmlSerializableType.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml.Serialization;
using Microsoft.TestCommon.Types;

namespace System.Net.Http.Formatting.DataSets.Types
{
    [KnownType(typeof(DerivedXmlSerializableType))]
    [XmlInclude(typeof(DerivedXmlSerializableType))]
    public class XmlSerializableType : INameAndIdContainer
    {
        private int id;
        private string name;

        public XmlSerializableType()
        {
        }

        public XmlSerializableType(int id, string name)
        {
            this.id = id;
            this.name = name;
        }

        [XmlAttribute]
        public int Id
        {
            get
            {
                return this.id;
            }

            set
            {
                this.IdSet = true;
                this.id = value;
            }
        }

        [XmlElement]
        public string Name
        {
            get
            {
                return this.name;
            }

            set
            {
                this.NameSet = true;
                this.name = value;
            }

        }

        [XmlIgnore]
        public bool IdSet { get; private set; }

        [XmlIgnore]
        public bool NameSet { get; private set; }

        public override bool Equals(object obj)
        {
            if (Object.ReferenceEquals(this, obj))
            {
                return true;
            }

            XmlSerializableType other = obj as XmlSerializableType;
            if (Object.ReferenceEquals(other, null))
            {
                return false;
            }

            return String.Equals(this.Name, other.Name, StringComparison.Ordinal) && this.Id == other.Id;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }

        public static IEnumerable<XmlSerializableType> GetTestData()
        {
            return new XmlSerializableType[] { new XmlSerializableType(), new XmlSerializableType(1, "SomeName") };
        }

        public static IEnumerable<DerivedXmlSerializableType> GetDerivedTypeTestData()
        {
            return new DerivedXmlSerializableType[] { 
                new DerivedXmlSerializableType(), 
                new DerivedXmlSerializableType(1, "SomeName", null), 
                new DerivedXmlSerializableType(1, "SomeName", new WcfPocoType(2, "SomeOtherName"))};
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/BsonMediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class BsonMediaTypeFormatterTests : MediaTypeFormatterTestBase<BsonMediaTypeFormatter>
    {
        // Exclude IEnumerable<T> and IQueryable<T> to avoid attempts to round trip values that are known to cause
        // trouble in deserialization e.g. base IEnumerable<T>.  BSON reader won't know how to construct such types.
        private const TestDataVariations RoundTripVariations =
            (TestDataVariations.All | TestDataVariations.WithNull | TestDataVariations.AsClassMember) &
            ~(TestDataVariations.AsIEnumerable | TestDataVariations.AsIQueryable);

        /// <summary>
        /// Provide test data for round trip tests.  Avoid types BSON does not support.
        /// <remarks>
        /// BSON does not support some unsigned integers as well as having issues with <see cref="decimal"/>.
        /// <list type="bullet">
        /// <item><description>
        /// BSON writer attempts to write an unsigned int or long as a signed integer of the same size e.g. it writes
        /// an <see cref="uint"/> as an <see cref="int"/> and thus can only write values less than
        /// <c>Int32.MaxValue</c>.  BSON writer fortunately uses an <see cref="int"/> for <see cref="sbyte"/>,
        /// <see cref="byte"/>, <see cref="short"/>, and <see cref="ushort"/> values.
        /// </description></item>
        /// <item><description>
        /// BSON successfully writes all <see cref="decimal"/> values as <see cref="double"/>.  But BSON reader may not
        /// be able to be convert the <see cref="double"/> value back e.g. <c>Decimal.MaxValue</c> loses precision when
        /// written and is rounded up -- to an invalid <see cref="decimal"/> value.
        /// </description></item>
        /// <item><description>
        /// BSON (as well as JSON and default <c>ToString()</c> in the <see cref="DateTime"/> case) loses information
        /// when writing <see cref="DateTime"/> and <see cref="DateTimeOffset"/> values.  BSON writer uses a UTC
        /// datetime value in both cases -- losing <c>Kind</c> and <c>Offset</c> property values, respectively.
        /// (<see cref="DateTime"/> values are not currently included in
        /// <see cref="CommonUnitTestDataSets.ValueAndRefTypeTestDataCollection"/> but exclude
        /// <see cref="CommonUnitTestDataSets.DateTimes"/> to be safe.)
        /// </description></item>
        /// <item><description>
        /// BSON readers and writers appear to round trip <see cref="ISerializableType"/> values successfully.  However
        /// <see cref="ISerializableType"/> does not implement <see cref="IEquatable{T}"/> or
        /// <see cref="IComparable{T}"/> and thus <see cref="Assert.Equals()"/> fails.
        /// </description></item>
        /// </list>
        /// </remarks>
        /// </summary>
        public static IEnumerable<TestData> ValueAndRefTypeTestDataCollection
        {
            get
            {
                return CommonUnitTestDataSets.ValueAndRefTypeTestDataCollection.Except(
                    new TestData[] {
                        CommonUnitTestDataSets.Uints,
                        CommonUnitTestDataSets.Ulongs,
                        CommonUnitTestDataSets.DateTimeOffsets,
                        CommonUnitTestDataSets.DateTimes,
                        CommonUnitTestDataSets.Decimals,
                        CommonUnitTestDataSets.ISerializableTypes,
                    });
            }
        }


        public override IEnumerable<MediaTypeHeaderValue> ExpectedSupportedMediaTypes
        {
            get { return HttpTestData.StandardBsonMediaTypes; }
        }

        public override IEnumerable<Encoding> ExpectedSupportedEncodings
        {
            get { return HttpTestData.StandardEncodings; }
        }

        public override byte[] ExpectedSampleTypeByteRepresentation
        {
            get
            {
                return new byte[17]
                {
                    // Little-endian length
                    17, 0, 0, 0,
                    // Opcode indicating a 32bit integer
                    0x10,
                    // Field name as a C string
                    (byte)'N', (byte)'u', (byte)'m', (byte)'b', (byte)'e', (byte)'r', 0,
                    // Little-endian value
                    42, 0, 0, 0,
                    // BSON document terminator
                    0,
                };
            }
        }

        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();

            string mediaType = string.Format("application/bson; charset={0}", encoding);
            Encoding enc = CreateOrGetSupportedEncoding(formatter, encoding, isDefaultEncoding);

            // Test roundtrip in this case, not against expectations
            byte[] sourceData;
            using (MemoryStream stream = new MemoryStream())
            {
                formatter.WriteToStream(typeof(string), content, stream, enc);
                sourceData = stream.ToArray();
            }

            // Further Arrange, Act & Assert
            return ReadContentUsingCorrectCharacterEncodingHelperAsync(formatter, content, sourceData, mediaType);
        }

        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            GC.KeepAlive(isDefaultEncoding); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();

            string mediaType = string.Format("application/bson; charset={0}", encoding);
            Encoding enc = Encoding.GetEncoding(encoding);

            // Test sync and async approaches match, not against expectations
            // See ReadFromStreamAsync_UsesCorrectCharacterEncoding for roundtrip test
            byte[] expectedData;
            using (MemoryStream stream = new MemoryStream())
            {
                formatter.WriteToStream(typeof(string), content, stream, enc);
                expectedData = stream.ToArray();
            }

            // Further Arrange, Act & Assert
            return WriteContentUsingCorrectCharacterEncodingHelperAsync(formatter, content, expectedData, mediaType);
        }

        [Fact]
        void CopyConstructor()
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter()
            {
                MaxDepth = 42,
            };

            // Replace serializable settings and switch one property's value
            JsonSerializerSettings oldSettings = formatter.SerializerSettings;
            formatter.SerializerSettings = formatter.CreateDefaultSerializerSettings();
            formatter.SerializerSettings.CheckAdditionalContent = !formatter.SerializerSettings.CheckAdditionalContent;

            // Act
            TestBsonMediaTypeFormatter derivedFormatter = new TestBsonMediaTypeFormatter(formatter);

            // Assert
            Assert.Equal(formatter.MaxDepth, derivedFormatter.MaxDepth);
            Assert.NotSame(oldSettings, formatter.SerializerSettings);
            Assert.NotEqual(oldSettings.CheckAdditionalContent, formatter.SerializerSettings.CheckAdditionalContent);
            Assert.Same(formatter.SerializerSettings, derivedFormatter.SerializerSettings);
            Assert.Same(formatter.SerializerSettings.ContractResolver, derivedFormatter.SerializerSettings.ContractResolver);
        }

        [Fact]
        public void MaxDepth_RoundTrips()
        {
            // Arrange & Act & Assert
            Assert.Reflection.IntegerProperty(
                new BsonMediaTypeFormatter(),
                c => c.MaxDepth,
                expectedDefaultValue: 256,
                minLegalValue: 1,
                illegalLowerValue: 0,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 256);
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection")]
        public void CanReadType_ReturnsExpectedValues(Type variationType, object testData)
        {
            // Arrange
            GC.KeepAlive(testData); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();

            // Act & Assert
            Assert.True(formatter.CanReadType(variationType));
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection")]
        public void CanWriteType_ReturnsExpectedValues(Type variationType, object testData)
        {
            // Arrange
            GC.KeepAlive(testData); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();

            // Act & Assert
            Assert.True(formatter.CanWriteType(variationType));
        }

        [Fact]
        public async Task FormatterThrowsOnWriteWhenOverridenCreateFails()
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter
            {
                ThrowExceptionOnCreate = true,
            };

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<Exception>(action, "Throwing exception directly, since it needs to get caught by a catch all");

            Assert.False(formatter.WasCreateJsonReaderCalled);
            Assert.True(formatter.WasCreateJsonWriterCalled);
        }

        [Fact]
        public async Task FormatterThrowsOnWriteWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter
            {
                ReturnNullOncreate = true,
            };

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'CreateJsonWriter' method returned null. It must return a JSON writer instance.");

            Assert.False(formatter.WasCreateJsonReaderCalled);
            Assert.True(formatter.WasCreateJsonWriterCalled);
        }

        [Fact]
        public async Task FormatterThrowsOnWriteWithInvalidContent()
        {
            // Arrange (set up to serialize Int32.MaxValue + 1 as an UInt32; can't be done since serialization uses an Int32
            Type variationType = typeof(uint);
            uint testData = (uint)Int32.MaxValue + 1u;
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();
            HttpContent content = new StringContent(String.Empty);
            MemoryStream stream = new MemoryStream();
            string expectedMessage =
                "Value is too large to fit in a signed 32 bit integer. BSON does not support unsigned values. Path 'Value'.";

            // Act & Assert
            // Note error message is not quite correct: BSON supports byte, ushort, and smaller uint / ulong values.
            await Assert.ThrowsAsync<JsonWriterException>(
                () => formatter.WriteToStreamAsync(variationType, testData, stream, content, transportContext: null),
                expectedMessage);
        }

        [Fact]
        public async Task FormatterThrowsOnReadWhenOverridenCreateFails()
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter
            {
                ThrowExceptionOnCreate = true,
            };

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);
            await Assert.ThrowsAsync<Exception>(action, "Throwing exception directly, since it needs to get caught by a catch all");

            Assert.True(formatter.WasCreateJsonReaderCalled);
            Assert.False(formatter.WasCreateJsonWriterCalled);
        }

        [Fact]
        public async Task FormatterThrowsOnReadWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter
            {
                ReturnNullOncreate = true,
            };

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'CreateJsonReader' method returned null. It must return a JSON reader instance.");

            Assert.True(formatter.WasCreateJsonReaderCalled);
            Assert.False(formatter.WasCreateJsonWriterCalled);
        }

        [Fact]
        public async Task FormatterThrowsOnReadWithInvalidContent()
        {
            // Arrange (serialize Decimal.MaxValue; can't be read back since serialization uses rounded Double)
            Type variationType = typeof(decimal);
            decimal testData = Decimal.MaxValue;
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders contentHeaders = content.Headers;
            MemoryStream stream = new MemoryStream();

            await formatter.WriteToStreamAsync(variationType, testData, stream, content, transportContext: null);

            contentHeaders.ContentLength = stream.Length;
            stream.Flush();
            stream.Seek(0L, SeekOrigin.Begin);

            // Act & Assert
            await Assert.ThrowsAsync<JsonReaderException>(
                () => formatter.ReadFromStreamAsync(variationType, stream, content, null),
#if NETCOREAPP3_1_OR_GREATER
                "Could not convert to decimal: 7.922816251426434E+28. Path 'Value'."
#else
                "Could not convert to decimal: 7.92281625142643E+28. Path 'Value'."
#endif
                );
        }

        [Theory]
        [InlineData(typeof(IList<string>))]
        [InlineData(typeof(IDictionary<string, object>))]
        public async Task UseBsonFormatterWithNullCollections(Type type)
        {
            // Arrange
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            await Assert.Task.SucceedsAsync(formatter.WriteToStreamAsync(type, null, memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.Empty(serializedString);
        }

        [Theory]
        [TestDataSet(typeof(BsonMediaTypeFormatterTests), "ValueAndRefTypeTestDataCollection", RoundTripVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync(Type variationType, object testData)
        {
            // Arrange
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
            Assert.Equal(testData, readObj);
        }

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "BunchOfJsonObjectsTestDataCollection", RoundTripVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_PerhapsJObject(Type variationType, object testData)
        {
            // Arrange
            BsonMediaTypeFormatter formatter = new BsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            JObject readJObject = readObj as JObject;
            if (readJObject != null)
            {
                // Serialized a Dictionary<string, object> to handle simple runtime type; round trips as a JObject
                Assert.Single(readJObject);
                JToken readJToken = readJObject["Value"];
                Assert.NotNull(readJToken);
                Assert.Equal(testData, readJToken.ToObject(testData.GetType()));
            }
            else
            {
                Assert.Equal(testData, readObj);
            }
        }

        // Test alternate null value
        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection", TestDataVariations.AllSingleInstances)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull(Type variationType, object testData)
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object.
            Assert.Null(readObj);
        }

#if !NETCOREAPP2_1 // DBNull not serializable on .NET Core 2.1 except at top level (using BsonMediaTypeformatter special case).
        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection", TestDataVariations.AsDictionary)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull_Dictionary(Type variationType, object testData)
        {
            // Guard
            IDictionary<string, object> expectedDictionary = Assert.IsType<Dictionary<string, object>>(testData);

            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object. Reach into collections.
            Assert.Equal(testData.GetType(), readObj.GetType());

            IDictionary<string, object> readDictionary = (IDictionary<string, object>)readObj;
            Assert.Equal(expectedDictionary.Count, readDictionary.Count);

            foreach (string key in expectedDictionary.Keys)
            {
                Assert.True(readDictionary.ContainsKey(key));
                Assert.Null(readDictionary[key]);
            }
        }

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection",
            TestDataVariations.AsArray | TestDataVariations.AsList)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull_Enumerable(Type variationType, object testData)
        {
            // Guard
            Assert.True((testData as IEnumerable<object>) != null);

            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter();
            IEnumerable<object> expectedEnumerable = (IEnumerable<object>)testData;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object. Reach into collections.
            Assert.Equal(testData.GetType(), readObj.GetType());

            IEnumerable<object> readEnumerable = (IEnumerable<object>)readObj;
            Assert.Equal(expectedEnumerable.Count(), readEnumerable.Count());

            foreach (object readContent in readEnumerable)
            {
                Assert.Null(readContent);
            }
        }

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection", TestDataVariations.AsClassMember)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull_Holder(Type variationType, object testData)
        {
            // Guard
            Assert.IsType<TestDataHolder<object>>(testData);

            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object. Reach into objects.
            Assert.Equal(testData.GetType(), readObj.GetType());

            TestDataHolder<object> readDataHolder = (TestDataHolder<object>)readObj;
            Assert.Null(readDataHolder.V1);
        }
#endif

        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNullString()
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter();
            Type variationType = typeof(string);
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // Null on wire can be read as null of any nullable type
            Assert.Null(readObj);
        }

        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNull()
        {
            // Arrange
            TestBsonMediaTypeFormatter formatter = new TestBsonMediaTypeFormatter();
            Type variationType = typeof(DBNull);
            object testData = DBNull.Value;

            // Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // Only BSON case where DBNull.Value round-trips
            Assert.Equal(testData, readObj);
        }

        private class TestBsonMediaTypeFormatter : BsonMediaTypeFormatter
        {
            public TestBsonMediaTypeFormatter() : base()
            {
            }

            public TestBsonMediaTypeFormatter(TestBsonMediaTypeFormatter formatter) : base(formatter)
            {
            }

            public bool ReturnNullOncreate { get; set; }
            public bool ThrowExceptionOnCreate { get; set; }
            public bool WasCreateJsonReaderCalled { get; private set; }
            public bool WasCreateJsonWriterCalled { get; private set; }

            public override JsonReader CreateJsonReader(Type type, Stream readStream, Encoding effectiveEncoding)
            {
                WasCreateJsonReaderCalled = true;
                if (ReturnNullOncreate)
                {
                    return null;
                }

                if (ThrowExceptionOnCreate)
                {
                    throw new Exception("Throwing exception directly, since it needs to get caught by a catch all");
                }

                return base.CreateJsonReader(type, readStream, effectiveEncoding);
            }

            public override JsonWriter CreateJsonWriter(Type type, Stream writeStream, Encoding effectiveEncoding)
            {
                WasCreateJsonWriterCalled = true;
                if (ReturnNullOncreate)
                {
                    return null;
                }

                if (ThrowExceptionOnCreate)
                {
                    throw new Exception("Throwing exception directly, since it needs to get caught by a catch all");
                }

                return base.CreateJsonWriter(type, writeStream, effectiveEncoding);
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/BufferedMediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class BufferedMediaTypeFormatterTests : MediaTypeFormatterTestBase<MockBufferedMediaTypeFormatter>
    {
        private const string ExpectedSupportedMediaType = "text/test";
        private const string TestData = "Hello World Hello World Hello World Hello World Hello World Hello World";

        public override IEnumerable<MediaTypeHeaderValue> ExpectedSupportedMediaTypes
        {
            get { return new List<MediaTypeHeaderValue> { new MediaTypeHeaderValue(ExpectedSupportedMediaType) }; }
        }

        public override IEnumerable<Encoding> ExpectedSupportedEncodings
        {
            get { return HttpTestData.StandardEncodings; }
        }

        public override byte[] ExpectedSampleTypeByteRepresentation
        {
            get { return ExpectedSupportedEncodings.ElementAt(0).GetBytes("System.Net.Http.Formatting.MediaTypeFormatterTestBase`1+SampleType[System.Net.Http.Formatting.MockBufferedMediaTypeFormatter]"); }
        }

        [Fact]
        void CopyConstructor()
        {
            MockBufferedMediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter()
            {
                BufferSize = 512
            };

            MockBufferedMediaTypeFormatter derivedFormatter = new MockBufferedMediaTypeFormatter(formatter);

            Assert.Equal(formatter.BufferSize, derivedFormatter.BufferSize);
        }

        [Fact]
        public void BufferSize_RoundTrips()
        {
            Assert.Reflection.IntegerProperty(
                new MockBufferedMediaTypeFormatter(),
                c => c.BufferSize,
                expectedDefaultValue: 16 * 1024,
                minLegalValue: 0,
                illegalLowerValue: -1,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 1024);
        }

        [Fact]
        public void WriteToStreamAsync_WhenTypeParameterIsNull_ThrowsException()
        {
            BufferedMediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            Assert.ThrowsArgumentNull(
                () => formatter.WriteToStreamAsync(null, new object(), new MemoryStream(), null, null), "type");
        }

        [Fact]
        public void WriteToStreamAsync_WhenStreamParameterIsNull_ThrowsException()
        {
            BufferedMediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            Assert.ThrowsArgumentNull(
                () => formatter.WriteToStreamAsync(typeof(object), new object(), null, null, null), "writeStream");
        }

        [Fact]
        public void ReadFromStreamAsync_WhenTypeParamterIsNull_ThrowsException()
        {
            BufferedMediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => formatter.ReadFromStreamAsync(null, new MemoryStream(), null, null), "type");
        }

        [Fact]
        public void ReadFromStreamAsync_WhenStreamParamterIsNull_ThrowsException()
        {
            BufferedMediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => formatter.ReadFromStreamAsync(typeof(object), null, null, null), "readStream");
        }

        [Fact]
        public async Task BufferedWrite()
        {
            // Arrange. Specifically use the base class with async signatures.
            MediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            MemoryStream output = new MemoryStream();

            // Act. Call the async signature.
            await formatter.WriteToStreamAsync(TestData.GetType(), TestData, output, null, null);

            // Assert
            byte[] expectedBytes = ExpectedSupportedEncodings.ElementAt(0).GetBytes(TestData);
            byte[] actualBytes = output.ToArray();
            Assert.Equal(expectedBytes, actualBytes);
        }

        [Fact]
        public async Task BufferedRead()
        {
            // Arrange. Specifically use the base class with async signatures.
            MediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            byte[] expectedBytes = ExpectedSupportedEncodings.ElementAt(0).GetBytes(TestData);
            MemoryStream input = new MemoryStream(expectedBytes);

            // Act. Call the async signature.
            object result = await formatter.ReadFromStreamAsync(TestData.GetType(), input, null, null);

            // Assert
            Assert.Equal(TestData, result);
        }

        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            MediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            string mediaType = string.Format("{0}; charset={1}", ExpectedSupportedMediaType, encoding);

            // Act & assert
            return ReadFromStreamAsync_UsesCorrectCharacterEncodingHelper(formatter, content, content, mediaType, encoding, isDefaultEncoding);
        }

        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            MediaTypeFormatter formatter = new MockBufferedMediaTypeFormatter();
            string mediaType = string.Format("{0}; charset={1}", ExpectedSupportedMediaType, encoding);

            // Act & assert
            return WriteToStreamAsync_UsesCorrectCharacterEncodingHelper(formatter, content, content, mediaType, encoding, isDefaultEncoding);
        }

        [Fact]
        public override Task Overridden_ReadFromStreamAsyncWithCancellationToken_GetsCalled()
        {
            // ReadFromStreamAsync is not overridable on BufferedMediaTypeFormatter.
            // So, let this test be a NOOP
            return TaskHelpers.Completed();
        }

        [Fact]
        public override Task Overridden_ReadFromStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            // ReadFromStreamAsync is not overridable on BufferedMediaTypeFormatter.
            // So, let this test be a NOOP
            return TaskHelpers.Completed();
        }

        [Fact]
        public override Task Overridden_WriteToStreamAsyncWithCancellationToken_GetsCalled()
        {
            // WriteToStreamAsync is not overridable on BufferedMediaTypeFormatter.
            // So, let this test be a NOOP
            return TaskHelpers.Completed();
        }

        [Fact]
        public override Task Overridden_WriteToStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            // WriteToStreamAsync is not overridable on BufferedMediaTypeFormatter.
            // So, let this test be a NOOP
            return TaskHelpers.Completed();
        }
    }

    public class MockBufferedMediaTypeFormatter : BufferedMediaTypeFormatter
    {
        private const string SupportedMediaType = "text/test";

        public MockBufferedMediaTypeFormatter()
        {
            SupportedMediaTypes.Add(new MediaTypeHeaderValue(SupportedMediaType));

            // Set default supported character encodings
            SupportedEncodings.Add(new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: true));
            SupportedEncodings.Add(new UnicodeEncoding(bigEndian: false, byteOrderMark: true, throwOnInvalidBytes: true));
        }

        public MockBufferedMediaTypeFormatter(MockBufferedMediaTypeFormatter formatter)
            : base(formatter)
        {
        }

        public override bool CanReadType(Type type)
        {
            return true;
        }

        public override bool CanWriteType(Type type)
        {
            return true;
        }

        public override object ReadFromStream(Type type, Stream stream, HttpContent content, IFormatterLogger formatterLogger)
        {
            object result = null;
            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
            Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);
            using (StreamReader sReader = new StreamReader(stream, effectiveEncoding))
            {
                if (type == typeof(SampleType))
                {
                    return new SampleType { Number = 42 };
                }
                else
                {
                    result = sReader.ReadToEnd();
                }
            }
            return result;
        }

        public override void WriteToStream(Type type, object value, Stream stream, HttpContent content)
        {
            HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
            Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);
            using (StreamWriter sWriter = new StreamWriter(stream, effectiveEncoding))
            {
                if (value != null)
                {
                    sWriter.Write(value.ToString());
                }
                else
                {
                    sWriter.Write("null!");
                }
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/ContentNegotiationResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Formatting
{
    public class ContentNegotiationResultTest
    {
        private readonly MediaTypeFormatter _formatter = new Mock<MediaTypeFormatter>().Object;
        private readonly MediaTypeHeaderValue _mediaType = new MediaTypeHeaderValue("app/json");

        [Fact]
        public void Constructor_WhenFormatterParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => new ContentNegotiationResult(formatter: null, mediaType: null), "formatter");
        }

        [Fact]
        public void MediaTypeProperty()
        {
            Assert.Reflection.Property(new ContentNegotiationResult(_formatter, _mediaType),
                nr => nr.MediaType, _mediaType, allowNull: true, roundTripTestValue: new MediaTypeHeaderValue("foo/bar"));
        }

        [Fact]
        public void FormatterProperty()
        {
            Assert.Reflection.Property(new ContentNegotiationResult(_formatter, _mediaType),
                nr => nr.Formatter, _formatter, allowNull: false, roundTripTestValue: new JsonMediaTypeFormatter());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/DataContractJsonMediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Formatting.DataSets.Types;
using System.Net.Http.Headers;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class DataContractJsonMediaTypeFormatter : JsonMediaTypeFormatter
    {
        public DataContractJsonMediaTypeFormatter()
        {
            UseDataContractJsonSerializer = true;
        }
    }

    public class DataContractJsonMediaTypeFormatterTests : MediaTypeFormatterTestBase<DataContractJsonMediaTypeFormatter>
    {
        public static readonly TheoryDataSet<Type> AFewValidTypes = new()
        {
            typeof(bool),
            typeof(int),
            typeof(string),
        };

        public override IEnumerable<MediaTypeHeaderValue> ExpectedSupportedMediaTypes
        {
            get { return HttpTestData.StandardJsonMediaTypes; }
        }

        public override IEnumerable<Encoding> ExpectedSupportedEncodings
        {
            get { return HttpTestData.StandardEncodings; }
        }

        public override byte[] ExpectedSampleTypeByteRepresentation
        {
            get { return ExpectedSupportedEncodings.ElementAt(0).GetBytes("{\"Number\":42}"); }
        }

        [Fact]
        public void DefaultMediaType_ReturnsApplicationJson()
        {
            MediaTypeHeaderValue mediaType = DataContractJsonMediaTypeFormatter.DefaultMediaType;
            Assert.NotNull(mediaType);
            Assert.Equal("application/json", mediaType.MediaType);
        }

        [Fact]
        public void Indent_RoundTrips()
        {
            Assert.Reflection.BooleanProperty(
                new XmlMediaTypeFormatter(),
                c => c.Indent,
                expectedDefaultValue: false);
        }

        [Fact]
        public void MaxDepth_RoundTrips()
        {
            Assert.Reflection.IntegerProperty(
                new DataContractJsonMediaTypeFormatter(),
                c => c.MaxDepth,
                expectedDefaultValue: 256,
                minLegalValue: 1,
                illegalLowerValue: 0,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 256);
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection")]
        public void CanReadType_ReturnsExpectedValues(Type variationType, object testData)
        {
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            bool isSerializable = IsTypeSerializableWithJsonSerializer(variationType, testData);
            bool canSupport = formatter.CanReadTypeProxy(variationType);

            // If we don't agree, we assert only if the DCJ serializer says it cannot support something we think it should
            Assert.False(isSerializable != canSupport && isSerializable, String.Format("CanReadType returned wrong value for '{0}'.", variationType));

            // Ask a 2nd time to probe whether the cached result is treated the same
            canSupport = formatter.CanReadTypeProxy(variationType);
            Assert.False(isSerializable != canSupport && isSerializable, String.Format("2nd CanReadType returned wrong value for '{0}'.", variationType));
        }

        [Theory]
        [PropertyData(nameof(AFewValidTypes))]
        public void CanWriteType_ReturnsFalse_ForValidTypes(Type type)
        {
            XmlMediaTypeFormatter formatter = new();

            var canWrite = formatter.CanWriteType(type);

#if Testing_NetStandard1_3 // Different behavior in netstandard1.3 due to no DataContract validation.
            Assert.False(canWrite);
#else
            Assert.True(canWrite);
#endif
        }

        public class InvalidDataContract
        {
            // removing the default ctor makes this invalid
            public InvalidDataContract(string s)
            {
            }
        }

#if !Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Theory]
        [InlineData(typeof(IQueryable<string>))]
        [InlineData(typeof(IEnumerable<string>))]
        public async Task UseJsonFormatterWithNull(Type type)
        {
            JsonMediaTypeFormatter xmlFormatter = new DataContractJsonMediaTypeFormatter();
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(xmlFormatter.WriteToStreamAsync(type, null, memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("null"), "Using Json formatter to serialize null should emit 'null'.");
        }
#endif

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "ValueAndRefTypeTestDataCollectionExceptULong", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsTypeSerializableWithJsonSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

        [Theory]
        [TestDataSet(typeof(XmlMediaTypeFormatterTests), "BunchOfTypedObjectsTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_KnownTypes(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsTypeSerializableWithJsonSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter { AddDBNullKnownType = true, };

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

#if Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_UsingDataContractSerializer_Throws(Type variationType, object testData)
        {
            // Arrange. First, get some data using XmlSerializer.
            bool canSerialize = IsTypeSerializableWithJsonSerializer(variationType, testData, actuallyCheck: true) &&
                Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                var formatter = new JsonMediaTypeFormatter();
                using var stream = new MemoryStream();
                using var content = new StringContent(string.Empty);

                await formatter.WriteToStreamAsync(variationType, testData, stream, content, transportContext: null);
                await stream.FlushAsync();
                stream.Position = 0L;

                content.Headers.ContentLength = stream.Length;
                formatter.UseDataContractJsonSerializer = true;

                // Act & Assert
                await Assert.ThrowsAsync<PlatformNotSupportedException>(() =>
                    formatter.ReadFromStreamAsync(variationType, stream, content, formatterLogger: null),
                    "Unable to validate types on this platform when UseDataContractJsonSerializer is 'true'. " +
                    "Please reset UseDataContractJsonSerializer or move to a supported platform, one where the " +
                    ".NET Standard 2.0 assembly is usable.");
            }
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection", RoundTripDataVariations)]
        public async Task WriteToStreamAsync_UsingDataContractSerializer_Throws(Type variationType, object testData)
        {
            // Arrange
            var formatter = new JsonMediaTypeFormatter() { UseDataContractJsonSerializer = true};
            using var stream = new MemoryStream();
            using var content = new StringContent(string.Empty);

            // Act & Assert
            await Assert.ThrowsAsync<PlatformNotSupportedException>(() =>
                formatter.WriteToStreamAsync(variationType, testData, stream, content, transportContext: null),
                "Unable to validate types on this platform when UseDataContractJsonSerializer is 'true'. " +
                "Please reset UseDataContractJsonSerializer or move to a supported platform, one where the " +
                ".NET Standard 2.0 assembly is usable.");
        }

#else
#if !NETCOREAPP2_1 // DBNull not serializable on .NET Core 2.1.
        // Test alternate null value
        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNull()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            Type variationType = typeof(DBNull);
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value round-trips as either Object or DBNull because serialization includes its type
            Assert.Equal(testData, readObj);
        }

        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsEmptyString()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter { AddDBNullKnownType = true, };
            Type variationType = typeof(string);
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // Lower levels convert DBNull.Value to empty string on read
            Assert.Equal(String.Empty, readObj);
        }
#endif

        [Fact]
        public async Task UseDataContractJsonSerializer_Default()
        {
            DataContractJsonMediaTypeFormatter jsonFormatter = new DataContractJsonMediaTypeFormatter();
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(jsonFormatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.False(serializedString.Contains("\r\n"), "Using DCJS should emit data without indentation by default.");
        }
#endif

        [Fact]
        public void UseDataContractJsonSerializer_True_Indent_Throws()
        {
            DataContractJsonMediaTypeFormatter jsonFormatter = new DataContractJsonMediaTypeFormatter { Indent = true };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            Assert.Throws<NotSupportedException>(
                () => jsonFormatter.WriteToStreamAsync(typeof(SampleType),
                    new SampleType(),
                    memoryStream, content, transportContext: null));
        }

#if Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Fact]
        public override Task Overridden_ReadFromStreamAsyncWithCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task Overridden_ReadFromStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task Overridden_WriteToStreamAsyncWithCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task Overridden_WriteToStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task ReadFromStreamAsync_ReadsDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }

        // Attributes are in base class.
        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task ReadFromStreamAsync_WhenContentLengthIsNull_ReadsDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }

        // Attributes are in base class.
        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task WriteToStreamAsync_WhenObjectIsNull_WritesDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task WriteToStreamAsync_WritesDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }
#else
        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            DataContractJsonMediaTypeFormatter formatter = new DataContractJsonMediaTypeFormatter();
            string formattedContent = "\"" + content + "\"";
            string mediaType = string.Format("application/json; charset={0}", encoding);

            // Act & assert
            return ReadContentUsingCorrectCharacterEncodingHelperAsync(
                formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }

        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            DataContractJsonMediaTypeFormatter formatter = new DataContractJsonMediaTypeFormatter();
            string formattedContent = "\"" + content + "\"";
            string mediaType = string.Format("application/json; charset={0}", encoding);

            // Act & assert
            return WriteContentUsingCorrectCharacterEncodingHelperAsync(
                formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }
#endif

        public class TestJsonMediaTypeFormatter : DataContractJsonMediaTypeFormatter
        {
            public bool AddDBNullKnownType { get; set; }

            public bool CanReadTypeProxy(Type type)
            {
                return CanReadType(type);
            }

            public bool CanWriteTypeProxy(Type type)
            {
                return CanWriteType(type);
            }

            public override DataContractJsonSerializer CreateDataContractSerializer(Type type)
            {
                if (AddDBNullKnownType)
                {
                    return new DataContractJsonSerializer(type, new Type[] { typeof(DBNull), });
                }
                else
                {
                    return base.CreateDataContractSerializer(type);
                }
            }
        }

        private bool IsTypeSerializableWithJsonSerializer(Type type, object obj, bool actuallyCheck = false)
        {
#if Testing_NetStandard1_3 // Different behavior in netstandard1.3 due to no DataContract validation.
            if (!actuallyCheck)
            {
                return false;
            }
#endif

            try
            {
                new DataContractJsonSerializer(type);
                if (obj != null && obj.GetType() != type)
                {
                    new DataContractJsonSerializer(obj.GetType());
                }
            }
            catch
            {
                return false;
            }

            return !Assert.Http.IsKnownUnserializable(type, obj, (t) => typeof(INotJsonSerializable).IsAssignableFrom(t));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/DefaultContentNegotiatorTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting.Mocks;
using System.Net.Http.Headers;
using System.Text;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class DefaultContentNegotiatorTests
    {
        private readonly DefaultContentNegotiator _negotiator = new DefaultContentNegotiator();
        private readonly HttpRequestMessage _request = new HttpRequestMessage();

        public static TheoryDataSet<string, string[], string> MatchRequestMediaTypeData
        {
            get
            {
                // string requestMediaType, string[] supportedMediaTypes, string expectedMediaType
                return new TheoryDataSet<string, string[], string>
                {
                    { "text/plain", new string[0], null }, 
                    { "text/plain", new string[] { "text/xml", "application/xml" }, null }, 
                    { "application/xml", new string[] { "application/xml", "text/xml" }, "application/xml" }, 
                    { "APPLICATION/XML", new string[] { "text/xml", "application/xml" }, "application/xml" }, 
                    { "application/xml; charset=utf-8", new string[] { "text/xml", "application/xml" }, "application/xml" }, 
                    { "application/xml; charset=utf-8; parameter=value", new string[] { "text/xml", "application/xml" }, "application/xml" }, 
                };
            }
        }

        public static TheoryDataSet<string[], string[], string, double, int> MatchAcceptHeaderData
        {
            get
            {
                // string[] acceptHeader, string[] supportedMediaTypes, string expectedMediaType, double matchQuality, int range
                return new TheoryDataSet<string[], string[], string, double, int>
                {
                    { new string[] { "text/plain" }, new string[0], null, 0.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 

                    { new string[] { "text/plain" }, new string[] { "text/xml", "application/xml" }, null, 0.0, (int)MediaTypeFormatterMatchRanking.None }, 
                    { new string[] { "text/plain; q=0.5" }, new string[] { "text/xml", "application/xml" }, null, 0.0, (int)MediaTypeFormatterMatchRanking.None }, 

                    { new string[] { "application/xml" }, new string[] { "application/xml", "text/xml" }, "application/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 
                    { new string[] { "APPLICATION/XML; q=0.5" }, new string[] { "text/xml", "application/xml" }, "application/xml", 0.5, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 
                    { new string[] { "text/xml; q=0.5", "APPLICATION/XML; q=0.7" }, new string[] { "text/xml", "application/xml" }, "application/xml", 0.7, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 
                    { new string[] { "application/xml; q=0.0" }, new string[] { "application/xml", "text/xml" }, null, 0.0, (int)MediaTypeFormatterMatchRanking.None }, 
                    { new string[] { "APPLICATION/XML; q=0.0" }, new string[] { "text/xml", "application/xml" }, null, 0.0, (int)MediaTypeFormatterMatchRanking.None }, 
                    { new string[] { "text/xml; q=0.0", "APPLICATION/XML; q=0.0" }, new string[] { "text/xml", "application/xml" }, null, 0.0, (int)MediaTypeFormatterMatchRanking.None }, 

                    { new string[] { "text/*" }, new string[] { "text/xml", "application/xml" }, "text/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange }, 
                    { new string[] { "text/*", "application/xml" }, new string[] { "text/xml", "application/xml" }, "application/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 
                    { new string[] { "text/*", "application/xml; q=0.5" }, new string[] { "text/xml", "application/xml" }, "text/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange }, 
                    { new string[] { "text/*; q=0.5" }, new string[] { "text/xml", "application/xml" }, "text/xml", 0.5, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange }, 
                    { new string[] { "text/*; q=0.5", "application/xml" }, new string[] { "text/xml", "application/xml" }, "application/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 
                    { new string[] { "text/*; q=0.0", "application/xml; q=0.0" }, new string[] { "text/xml", "application/xml" }, null, 0.0, (int)MediaTypeFormatterMatchRanking.None }, 
                    { new string[] { "text/*; q=0.0", "application/xml" }, new string[] { "text/xml", "application/xml" }, "application/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 

                    { new string[] { "*/*; q=0.5" }, new string[] { "text/xml", "application/xml" }, "text/xml", 0.5, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange }, 
                    { new string[] { "*/*; q=0.0" }, new string[] { "text/xml", "application/xml" }, null, 0.0, (int)MediaTypeFormatterMatchRanking.None }, 
                    { new string[] { "*/*; q=0.5", "application/xml" }, new string[] { "text/xml", "application/xml" }, "application/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 
                    { new string[] { "*/*; q=1.0", "application/xml; q=0.5" }, new string[] { "text/xml", "application/xml" }, "text/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange }, 
                    { new string[] { "*/*", "application/xml" }, new string[] { "text/xml", "application/xml" }, "application/xml", 1.0, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral },

                    { new string[] { "text/*; q=0.5", "*/*; q=0.2", "application/xml; q=1.0" }, new string[] { "text/xml", "application/xml" }, "application/xml", 1.0,  (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 

                    { new string[] { "application/xml; q=0.5" }, new string[] { "text/xml", "application/xml" }, "application/xml", 0.5, (int)MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral }, 
                };
            }
        }

        public static TheoryDataSet<bool, string[], bool> ShouldMatchOnTypeData
        {
            get
            {
                // bool excludeMatchOnType, string[] acceptHeaders, bool expectedResult
                return new TheoryDataSet<bool, string[], bool>
                {
                    { false, new string[0], true }, 
                    { true, new string[0], true }, 

                    { false, new string[] { "application/xml" }, true }, 
                    { true, new string[] { "application/xml" }, false }, 
                    
                    { false, new string[] { "application/xml; q=1.0" }, true }, 
                    { true, new string[] { "application/xml; q=1.0" }, false }, 

                    { false, new string[] { "application/xml; q=0.0" }, true }, 
                    { true, new string[] { "application/xml; q=0.0" }, false }, 

                    { false, new string[] { "application/xml; q=0.0", "application/json" }, true }, 
                    { true, new string[] { "application/xml; q=0.0", "application/json" }, false }, 

                    { false, new string[] { "text/nomatch" }, true }, 
                    { true, new string[] { "text/nomatch" }, false }, 
                };
            }
        }

        public static TheoryDataSet<string[], string> MatchTypeData
        {
            get
            {
                // string[] supportedMediaTypes, string expectedMediaType
                return new TheoryDataSet<string[], string>
                {
                    { new string[0], "application/octet-stream" }, 

                    { new string[] { "text/xml", "application/xml" }, "text/xml" }, 
                    { new string[] { "application/xml", "text/xml" }, "application/xml" }, 
                };
            }
        }

        public static TheoryDataSet<string[], string, string[], string> SelectResponseCharacterEncodingData
        {
            get
            {
                // string[] acceptEncodings, string requestEncoding, string[] supportedEncodings, string expectedEncoding
                return new TheoryDataSet<string[], string, string[], string>
                {
                    { new string[] { "utf-8" }, null, new string[0], null },
                    { new string[0], "utf-8", new string[0], null },

                    { new string[0], null, new string[] { "utf-8", "utf-16"}, "utf-8" },
                    { new string[0], "utf-16", new string[] { "utf-8", "utf-16"}, "utf-16" },

                    { new string[] { "utf-8" }, null, new string[] { "utf-8", "utf-16"}, "utf-8" },
                    { new string[] { "utf-16" }, "utf-8", new string[] { "utf-8", "utf-16"}, "utf-16" },
                    { new string[] { "utf-16; q=0.5" }, "utf-8", new string[] { "utf-8", "utf-16"}, "utf-16" },

                    { new string[] { "utf-8; q=0.0" }, null, new string[] { "utf-8", "utf-16"}, "utf-8" },
                    { new string[] { "utf-8; q=0.0" }, "utf-16", new string[] { "utf-8", "utf-16"}, "utf-16" },
                    { new string[] { "utf-8; q=0.0", "utf-16; q=0.0" }, "utf-16", new string[] { "utf-8", "utf-16"}, "utf-16" },
                    { new string[] { "utf-8; q=0.0", "utf-16; q=0.0" }, null, new string[] { "utf-8", "utf-16"}, "utf-8" },
                    { new string[] { "*; q=0.0" }, null, new string[] { "utf-8", "utf-16"}, "utf-8" },
                    { new string[] { "*; q=0.0" }, "utf-16", new string[] { "utf-8", "utf-16"}, "utf-16" },
                };
            }
        }

        public static TheoryDataSet<ICollection<MediaTypeFormatterMatch>, MediaTypeFormatterMatch> SelectResponseMediaTypeData
        {
            get
            {
                // Only mapping and accept makes sense with q != 1.0
                MediaTypeFormatterMatch matchMapping10 = CreateMatch(1.0, MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping);
                MediaTypeFormatterMatch matchMapping05 = CreateMatch(0.5, MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping);

                MediaTypeFormatterMatch matchAccept10 = CreateMatch(1.0, MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral);
                MediaTypeFormatterMatch matchAccept05 = CreateMatch(0.5, MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderLiteral);

                MediaTypeFormatterMatch matchAcceptSubTypeRange10 = CreateMatch(1.0, MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange);
                MediaTypeFormatterMatch matchAcceptSubTypeRange05 = CreateMatch(0.5, MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderSubtypeMediaRange);

                MediaTypeFormatterMatch matchAcceptAllRange10 = CreateMatch(1.0, MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange);
                MediaTypeFormatterMatch matchAcceptAllRange05 = CreateMatch(0.5, MediaTypeFormatterMatchRanking.MatchOnRequestAcceptHeaderAllMediaRange);

                MediaTypeFormatterMatch matchRequest10 = CreateMatch(1.0, MediaTypeFormatterMatchRanking.MatchOnRequestMediaType);
                MediaTypeFormatterMatch matchType10 = CreateMatch(1.0, MediaTypeFormatterMatchRanking.MatchOnCanWriteType);

                // ICollection<MediaTypeFormatterMatch> candidateMatches, MediaTypeFormatterMatch winner
                return new TheoryDataSet<ICollection<MediaTypeFormatterMatch>, MediaTypeFormatterMatch>
                {
                    { new List<MediaTypeFormatterMatch>(), null },
                    { new List<MediaTypeFormatterMatch>() { matchType10 }, matchType10 },
                    { new List<MediaTypeFormatterMatch>() { matchType10, matchRequest10 }, matchRequest10 },
                    { new List<MediaTypeFormatterMatch>() { matchType10, matchRequest10, matchAcceptAllRange10 }, matchAcceptAllRange10 },
                    { new List<MediaTypeFormatterMatch>() { matchType10, matchRequest10, matchAcceptAllRange10, matchAcceptSubTypeRange10 }, matchAcceptSubTypeRange10 },
                    { new List<MediaTypeFormatterMatch>() { matchType10, matchRequest10, matchAcceptAllRange10, matchAcceptSubTypeRange10, matchAccept10 }, matchAccept10 },
                    { new List<MediaTypeFormatterMatch>() { matchType10, matchRequest10, matchAcceptAllRange10, matchAcceptSubTypeRange10, matchAccept10, matchMapping10 }, matchMapping10 },

                    { new List<MediaTypeFormatterMatch>() { matchAccept05, matchAccept10 }, matchAccept10 },
                    { new List<MediaTypeFormatterMatch>() { matchAccept10, matchAccept05 }, matchAccept10 },

                    { new List<MediaTypeFormatterMatch>() { matchAcceptSubTypeRange05, matchAcceptSubTypeRange10 }, matchAcceptSubTypeRange10 },
                    { new List<MediaTypeFormatterMatch>() { matchAcceptSubTypeRange10, matchAcceptSubTypeRange05 }, matchAcceptSubTypeRange10 },

                    { new List<MediaTypeFormatterMatch>() { matchAcceptAllRange05, matchAcceptAllRange10 }, matchAcceptAllRange10 },
                    { new List<MediaTypeFormatterMatch>() { matchAcceptAllRange10, matchAcceptAllRange05 }, matchAcceptAllRange10 },

                    { new List<MediaTypeFormatterMatch>() { matchMapping05, matchMapping10 }, matchMapping10 },
                    { new List<MediaTypeFormatterMatch>() { matchMapping10, matchMapping05 }, matchMapping10 },

                    { new List<MediaTypeFormatterMatch>() { matchMapping05, matchAccept05 }, matchMapping05 },
                    { new List<MediaTypeFormatterMatch>() { matchMapping10, matchAccept10 }, matchMapping10 },

                    { new List<MediaTypeFormatterMatch>() { matchMapping05, matchAcceptSubTypeRange05 }, matchMapping05 },
                    { new List<MediaTypeFormatterMatch>() { matchMapping10, matchAcceptSubTypeRange10 }, matchMapping10 },

                    { new List<MediaTypeFormatterMatch>() { matchMapping05, matchAcceptAllRange05 }, matchMapping05 },
                    { new List<MediaTypeFormatterMatch>() { matchMapping10, matchAcceptAllRange10 }, matchMapping10 },

                    { new List<MediaTypeFormatterMatch>() { matchMapping05, matchAccept10 }, matchAccept10 },
                    { new List<MediaTypeFormatterMatch>() { matchMapping05, matchAcceptSubTypeRange10 }, matchAcceptSubTypeRange10 },
                    { new List<MediaTypeFormatterMatch>() { matchMapping05, matchAcceptAllRange10 }, matchAcceptAllRange10 },
                };
            }
        }

        public static TheoryDataSet<MediaTypeFormatterMatch, MediaTypeFormatterMatch, bool> UpdateBestMatchData
        {
            get
            {
                MediaTypeFormatterMatch matchMapping10 = CreateMatch(1.0, MediaTypeFormatterMatchRanking.None);
                MediaTypeFormatterMatch matchMapping05 = CreateMatch(0.5, MediaTypeFormatterMatchRanking.None);

                // MediaTypeFormatterMatch current, MediaTypeFormatterMatch potentialReplacement, currentWins
                return new TheoryDataSet<MediaTypeFormatterMatch, MediaTypeFormatterMatch, bool>
                {
                    { null, matchMapping10, false },
                    { null, matchMapping05, false },

                    { matchMapping10, matchMapping10, true },
                    { matchMapping10, matchMapping05, true },

                    { matchMapping05, matchMapping10, false },
                    { matchMapping05, matchMapping05, true },
                };
            }
        }

        private static MediaTypeFormatterMatch CreateMatch(double? quality, MediaTypeFormatterMatchRanking ranking)
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/test");
            return new MediaTypeFormatterMatch(formatter, mediaType, quality, ranking);
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(DefaultContentNegotiator), TypeAssert.TypeProperties.IsPublicVisibleClass);
        }

        [Fact]
        public void Negotiate_WhenTypeParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() => _negotiator.Negotiate(null, _request, Enumerable.Empty<MediaTypeFormatter>()), "type");
        }

        [Fact]
        public void Negotiate_WhenRequestParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() => _negotiator.Negotiate(typeof(string), null, Enumerable.Empty<MediaTypeFormatter>()), "request");
        }

        [Fact]
        public void Negotiate_WhenFormattersParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() => _negotiator.Negotiate(typeof(string), _request, null), "formatters");
        }

        [Fact]
        public void Negotiate_ForEmptyFormatterCollection_ReturnsNull()
        {
            var result = _negotiator.Negotiate(typeof(string), _request, Enumerable.Empty<MediaTypeFormatter>());

            Assert.Null(result);
        }

        [Fact]
        public void Negotiate_MediaTypeMappingTakesPrecedenceOverAcceptHeader()
        {
            // Prepare the request message
            _request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            _request.Headers.Add("Browser", "IE");
            _request.Headers.Add("Cookie", "ABC");

            // Prepare the formatters
            List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>();
            formatters.Add(new JsonMediaTypeFormatter());
            formatters.Add(new XmlMediaTypeFormatter());
            PlainTextFormatter frmtr = new PlainTextFormatter();
            frmtr.SupportedMediaTypes.Clear();
            frmtr.MediaTypeMappings.Clear();
            frmtr.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/xml"));
            frmtr.MediaTypeMappings.Add(new MyMediaTypeMapping(new MediaTypeHeaderValue(("application/xml"))));
            formatters.Add(frmtr);

            // Act
            var result = _negotiator.Negotiate(typeof(string), _request, formatters);

            // Assert
            Assert.NotNull(result);
            Assert.Equal("application/xml", result.MediaType.MediaType);
            Assert.IsType<PlainTextFormatter>(result.Formatter);
        }

        [Fact]
        public void Negotiate_ForRequestReturnsFirstMatchingFormatter()
        {
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/myMediaType");

            MediaTypeFormatter formatter1 = new MockMediaTypeFormatter()
            {
                CanWriteTypeCallback = (Type t) => false
            };

            MediaTypeFormatter formatter2 = new MockMediaTypeFormatter()
            {
                CanWriteTypeCallback = (Type t) => true
            };

            formatter2.SupportedMediaTypes.Add(mediaType);

            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(
                new MediaTypeFormatter[] 
                {
                    formatter1,
                    formatter2
                });

            _request.Content = new StringContent("test", Encoding.Default, mediaType.MediaType);

            var result = _negotiator.Negotiate(typeof(string), _request, collection);
            Assert.Same(formatter2, result.Formatter);
            Assert.MediaType.AreEqual(mediaType, result.MediaType, "Expected the formatter's media type to be returned.");
        }

        [Fact]
        public void Negotiate_SelectsJsonAsDefaultFormatter()
        {
            // Arrange
            _request.Content = new StringContent("test");

            // Act
            var result = _negotiator.Negotiate(typeof(string), _request, new MediaTypeFormatterCollection());

            // Assert
            Assert.IsType<JsonMediaTypeFormatter>(result.Formatter);
            Assert.Equal(MediaTypeConstants.ApplicationJsonMediaType.MediaType, result.MediaType.MediaType);
        }

        [Fact]
        public void Negotiate_SelectsXmlFormatter_ForXhrRequestThatAcceptsXml()
        {
            // Arrange
            _request.Content = new StringContent("test");
            _request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            _request.Headers.Add("x-requested-with", "XMLHttpRequest");

            // Act
            var result = _negotiator.Negotiate(typeof(string), _request, new MediaTypeFormatterCollection());

            // Assert
            Assert.Equal("application/xml", result.MediaType.MediaType);
            Assert.IsType<XmlMediaTypeFormatter>(result.Formatter);
        }

        [Fact]
        public void Negotiate_SelectsJsonFormatter_ForXhrRequestThatDoesNotSpecifyAcceptHeaders()
        {
            // Arrange
            _request.Content = new StringContent("test");
            _request.Headers.Add("x-requested-with", "XMLHttpRequest");

            // Act
            var result = _negotiator.Negotiate(typeof(string), _request, new MediaTypeFormatterCollection());

            // Assert
            Assert.Equal("application/json", result.MediaType.MediaType);
            Assert.IsType<JsonMediaTypeFormatter>(result.Formatter);
        }

        [Fact]
        public void Negotiate_RespectsFormatterOrdering_ForXhrRequestThatDoesNotSpecifyAcceptHeaders()
        {
            // Arrange
            _request.Content = new StringContent("test");
            _request.Headers.Add("x-requested-with", "XMLHttpRequest");

            MediaTypeFormatterCollection formatters = new MediaTypeFormatterCollection(new MediaTypeFormatter[]
            {
                new XmlMediaTypeFormatter(),
                new JsonMediaTypeFormatter(),
                new FormUrlEncodedMediaTypeFormatter()
            });

            // Act
            var result = _negotiator.Negotiate(typeof(string), _request, formatters);

            // Assert
            Assert.Equal("application/json", result.MediaType.MediaType);
            Assert.IsType<JsonMediaTypeFormatter>(result.Formatter);
        }

        [Fact]
        public void Negotiate_SelectsJsonFormatter_ForXHRAndJsonValueResponse()
        {
            // Arrange
            _request.Content = new StringContent("test");
            _request.Headers.Add("x-requested-with", "XMLHttpRequest");

            // Act
            var result = _negotiator.Negotiate(typeof(JToken), _request, new MediaTypeFormatterCollection());

            Assert.Equal("application/json", result.MediaType.MediaType);
            Assert.IsType<JsonMediaTypeFormatter>(result.Formatter);
        }

        [Fact]
        public void Negotiate_SelectsJsonFormatter_ForXHRAndMatchAllAcceptHeader()
        {
            // Accept
            _request.Content = new StringContent("test");
            _request.Headers.Add("x-requested-with", "XMLHttpRequest");
            _request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("*/*"));

            // Act
            var result = _negotiator.Negotiate(typeof(string), _request, new MediaTypeFormatterCollection());

            // Assert
            Assert.Equal("application/json", result.MediaType.MediaType);
            Assert.IsType<JsonMediaTypeFormatter>(result.Formatter);
        }

        [Fact]
        public void Negotiate_UsesRequestedFormatterForXHRAndMatchAllPlusOtherAcceptHeader()
        {
            // Arrange
            _request.Content = new StringContent("test");
            _request.Headers.Add("x-requested-with", "XMLHttpRequest");
            _request.Headers.Accept.ParseAdd("text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"); // XHR header sent by Firefox 3b5

            // Act
            var result = _negotiator.Negotiate(typeof(string), _request, new MediaTypeFormatterCollection());

            // Assert
            Assert.Equal("application/xml", result.MediaType.MediaType);
            Assert.IsType<XmlMediaTypeFormatter>(result.Formatter);
        }

        [Theory]
        [InlineData(true)] 
        [InlineData(false)]
        public void Negotiate_ObservesExcludeMatchOnTypeOnly(bool excludeMatchOnTypeOnly)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator(excludeMatchOnTypeOnly);
            _request.Content = new StringContent("test");
            _request.Headers.Accept.ParseAdd("text/html");

            // Act
            var result = negotiator.Negotiate(typeof(string), _request, new MediaTypeFormatterCollection());

            // Assert
            if (excludeMatchOnTypeOnly)
            {
                Assert.Null(result);
            }
            else
            {
                Assert.NotNull(result);
                Assert.Equal("application/json", result.MediaType.MediaType);
            }
        }

        [Fact]
        public void ComputeFormatterMatches_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            Type type = typeof(object);
            HttpRequestMessage request = new HttpRequestMessage();
            List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>();

            Assert.ThrowsArgumentNull(() => negotiator.ComputeFormatterMatches(type: null, request: request, formatters: formatters), "type");
            Assert.ThrowsArgumentNull(() => negotiator.ComputeFormatterMatches(type: type, request: null, formatters: formatters), "request");
            Assert.ThrowsArgumentNull(() => negotiator.ComputeFormatterMatches(type: type, request: request, formatters: null), "formatters");
        }

        [Fact]
        public void MatchMediaTypeMapping_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            HttpRequestMessage request = new HttpRequestMessage();
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();

            Assert.ThrowsArgumentNull(() => negotiator.MatchMediaTypeMapping(request: null, formatter: formatter), "request");
            Assert.ThrowsArgumentNull(() => negotiator.MatchMediaTypeMapping(request: request, formatter: null), "formatter");
        }

        [Fact]
        public void MatchMediaTypeMapping_ReturnsMatch()
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            HttpRequestMessage request = new HttpRequestMessage();
            MediaTypeHeaderValue mappingMediatype = MediaTypeHeaderValue.Parse("application/other");
            MockMediaTypeMapping mockMediaTypeMapping = new MockMediaTypeMapping(mappingMediatype, 0.75);

            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            formatter.MediaTypeMappings.Add(mockMediaTypeMapping);

            // Act
            MediaTypeFormatterMatch match = negotiator.MatchMediaTypeMapping(request, formatter);

            // Assert
            Assert.True(mockMediaTypeMapping.WasInvoked);
            Assert.Same(request, mockMediaTypeMapping.Request);

            Assert.Same(formatter, match.Formatter);
            Assert.Equal(mockMediaTypeMapping.MediaType, match.MediaType);
            Assert.Equal(mockMediaTypeMapping.MatchQuality, match.Quality);
            Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnRequestWithMediaTypeMapping, match.Ranking);
        }

        [Fact]
        public void MatchAcceptHeader_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            List<MediaTypeWithQualityHeaderValue> sortedAcceptValues = new List<MediaTypeWithQualityHeaderValue>();

            Assert.ThrowsArgumentNull(() => negotiator.MatchAcceptHeader(sortedAcceptValues: null, formatter: formatter), "sortedAcceptValues");
            Assert.ThrowsArgumentNull(() => negotiator.MatchAcceptHeader(sortedAcceptValues: sortedAcceptValues, formatter: null), "formatter");
        }

        [Theory]
        [PropertyData("MatchAcceptHeaderData")]
        public void MatchAcceptHeader_ReturnsMatch(string[] acceptHeaders, string[] supportedMediaTypes, string expectedMediaType, double expectedQuality, int ranking)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            List<MediaTypeWithQualityHeaderValue> unsortedAcceptHeaders = acceptHeaders.Select(a => MediaTypeWithQualityHeaderValue.Parse(a)).ToList();
            IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptHeaders = negotiator.SortMediaTypeWithQualityHeaderValuesByQFactor(unsortedAcceptHeaders);

            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            foreach (string supportedMediaType in supportedMediaTypes)
            {
                formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(supportedMediaType));
            }

            // Act
            MediaTypeFormatterMatch match = negotiator.MatchAcceptHeader(sortedAcceptHeaders, formatter);

            // Assert
            if (expectedMediaType == null)
            {
                Assert.Null(match);
            }
            else
            {
                Assert.Same(formatter, match.Formatter);
                Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), match.MediaType);
                Assert.Equal(expectedQuality, match.Quality);
                Assert.Equal(ranking, (int)match.Ranking);
            }
        }

        [Fact]
        public void MatchRequestMediaType_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            HttpRequestMessage request = new HttpRequestMessage();
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();

            Assert.ThrowsArgumentNull(() => negotiator.MatchRequestMediaType(request: null, formatter: formatter), "request");
            Assert.ThrowsArgumentNull(() => negotiator.MatchRequestMediaType(request: request, formatter: null), "formatter");
        }

        [Theory]
        [PropertyData("MatchRequestMediaTypeData")]
        public void MatchRequestMediaType_ReturnsMatch(string requestMediaType, string[] supportedMediaTypes, string expectedMediaType)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent(String.Empty);
            request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(requestMediaType);

            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            foreach (string supportedMediaType in supportedMediaTypes)
            {
                formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(supportedMediaType));
            }

            // Act
            MediaTypeFormatterMatch match = negotiator.MatchRequestMediaType(request, formatter);

            // Assert
            if (expectedMediaType == null)
            {
                Assert.Null(match);
            }
            else
            {
                Assert.Same(formatter, match.Formatter);
                Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), match.MediaType);
                Assert.Equal(1.0, match.Quality);
                Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnRequestMediaType, match.Ranking);
            }
        }

        [Fact]
        public void ShouldMatchOnType_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            Assert.ThrowsArgumentNull(() => negotiator.ShouldMatchOnType(sortedAcceptValues: null), "sortedAcceptValues");
        }

        [Theory]
        [PropertyData("ShouldMatchOnTypeData")]
        public void ShouldMatchOnType_ReturnsExpectedResult(bool excludeMatchOnType, string[] acceptHeaders, bool expectedResult)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator(excludeMatchOnType);
            List<MediaTypeWithQualityHeaderValue> unsortedAcceptHeaders = acceptHeaders.Select(a => MediaTypeWithQualityHeaderValue.Parse(a)).ToList();
            IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptHeaders = negotiator.SortMediaTypeWithQualityHeaderValuesByQFactor(unsortedAcceptHeaders);

            // Act
            bool result = negotiator.ShouldMatchOnType(sortedAcceptHeaders);

            // Assert
            Assert.Equal(expectedResult, result);
        }

        [Fact]
        public void MatchType_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            Type type = typeof(object);
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();

            Assert.ThrowsArgumentNull(() => negotiator.MatchType(type: null, formatter: formatter), "type");
            Assert.ThrowsArgumentNull(() => negotiator.MatchType(type: type, formatter: null), "formatter");
        }

        [Theory]
        [PropertyData("MatchTypeData")]
        public void MatchType_ReturnsMatch(string[] supportedMediaTypes, string expectedMediaType)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            foreach (string supportedMediaType in supportedMediaTypes)
            {
                formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(supportedMediaType));
            }

            // Act
            MediaTypeFormatterMatch match = negotiator.MatchType(typeof(object), formatter);

            // Assert
            Assert.Same(formatter, match.Formatter);
            Assert.Equal(MediaTypeHeaderValue.Parse(expectedMediaType), match.MediaType);
            Assert.Equal(1.0, match.Quality);
            Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnCanWriteType, match.Ranking);
        }

        [Fact]
        public void SelectResponseMediaTypeFormatter_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            HttpRequestMessage request = new HttpRequestMessage();
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();

            Assert.ThrowsArgumentNull(() => negotiator.SelectResponseMediaTypeFormatter(matches: null), "matches");
        }

        [Theory]
        [PropertyData("SelectResponseMediaTypeData")]
        public void SelectResponseMediaTypeFormatter_SelectsMediaType(ICollection<MediaTypeFormatterMatch> matches, MediaTypeFormatterMatch expectedWinner)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            // Act
            MediaTypeFormatterMatch actualWinner = negotiator.SelectResponseMediaTypeFormatter(matches);

            // Assert
            Assert.Same(expectedWinner, actualWinner);
        }

        [Fact]
        public void SelectResponseCharacterEncoding_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            HttpRequestMessage request = new HttpRequestMessage();
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();

            Assert.ThrowsArgumentNull(() => negotiator.SelectResponseCharacterEncoding(request: null, formatter: formatter), "request");
            Assert.ThrowsArgumentNull(() => negotiator.SelectResponseCharacterEncoding(request: request, formatter: null), "formatter");
        }

        [Theory]
        [PropertyData("SelectResponseCharacterEncodingData")]
        public void SelectResponseCharacterEncoding_SelectsEncoding(string[] acceptCharsetHeaders, string requestEncoding, string[] supportedEncodings, string expectedEncoding)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            HttpRequestMessage request = new HttpRequestMessage();
            foreach (string acceptCharsetHeader in acceptCharsetHeaders)
            {
                request.Headers.AcceptCharset.Add(StringWithQualityHeaderValue.Parse(acceptCharsetHeader));
            }

            if (requestEncoding != null)
            {
                Encoding reqEncoding = Encoding.GetEncoding(requestEncoding);
                StringContent content = new StringContent("", reqEncoding, "text/plain");
                request.Content = content;
            }

            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };
            foreach (string supportedEncoding in supportedEncodings)
            {
                formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
            }

            // Act
            Encoding actualEncoding = negotiator.SelectResponseCharacterEncoding(request, formatter);

            // Assert
            if (expectedEncoding == null)
            {
                Assert.Null(actualEncoding);
            }
            else
            {
                Assert.Equal(Encoding.GetEncoding(expectedEncoding), actualEncoding);
            }
        }

        [Fact]
        public void SortMediaTypeWithQualityHeaderValuesByQFactor_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            Assert.ThrowsArgumentNull(() => negotiator.SortMediaTypeWithQualityHeaderValuesByQFactor((HttpHeaderValueCollection<MediaTypeWithQualityHeaderValue>)null), "headerValues");
        }

        [Theory]
        [TestDataSet(typeof(MediaTypeWithQualityHeaderValueComparerTests), "BeforeAfterSortedValues")]
        public void SortMediaTypeWithQualityHeaderValuesByQFactor_SortsCorrectly(IEnumerable<string> unsorted, IEnumerable<string> expectedSorted)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            List<MediaTypeWithQualityHeaderValue> unsortedValues =
                new List<MediaTypeWithQualityHeaderValue>(unsorted.Select(u => MediaTypeWithQualityHeaderValue.Parse(u)));

            List<MediaTypeWithQualityHeaderValue> expectedSortedValues =
                new List<MediaTypeWithQualityHeaderValue>(expectedSorted.Select(u => MediaTypeWithQualityHeaderValue.Parse(u)));

            // Act
            IEnumerable<MediaTypeWithQualityHeaderValue> actualSorted = negotiator.SortMediaTypeWithQualityHeaderValuesByQFactor(unsortedValues);

            // Assert
            Assert.True(expectedSortedValues.SequenceEqual(actualSorted));
        }

        [Fact]
        public void SortStringWithQualityHeaderValuesByQFactor_ThrowsOnNull()
        {
            MockContentNegotiator negotiator = new MockContentNegotiator();
            Assert.ThrowsArgumentNull(() => negotiator.SortStringWithQualityHeaderValuesByQFactor((HttpHeaderValueCollection<StringWithQualityHeaderValue>)null), "headerValues");
        }

        [Theory]
        [TestDataSet(typeof(StringWithQualityHeaderValueComparerTests), "BeforeAfterSortedValues")]
        public void SortStringWithQualityHeaderValuesByQFactor_SortsCorrectly(IEnumerable<string> unsorted, IEnumerable<string> expectedSorted)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            List<StringWithQualityHeaderValue> unsortedValues =
                new List<StringWithQualityHeaderValue>(unsorted.Select(u => StringWithQualityHeaderValue.Parse(u)));

            List<StringWithQualityHeaderValue> expectedSortedValues =
                new List<StringWithQualityHeaderValue>(expectedSorted.Select(u => StringWithQualityHeaderValue.Parse(u)));

            // Act
            IEnumerable<StringWithQualityHeaderValue> actualSorted = negotiator.SortStringWithQualityHeaderValuesByQFactor(unsortedValues);

            // Assert
            Assert.True(expectedSortedValues.SequenceEqual(actualSorted));
        }

        [Theory]
        [PropertyData("UpdateBestMatchData")]
        public void UpdateBestMatch_SelectsCorrectly(MediaTypeFormatterMatch current, MediaTypeFormatterMatch replacement, bool currentWins)
        {
            // Arrange
            MockContentNegotiator negotiator = new MockContentNegotiator();

            // Act
            MediaTypeFormatterMatch actualResult = negotiator.UpdateBestMatch(current, replacement);

            // Assert
            if (currentWins)
            {
                Assert.Same(current, actualResult);
            }
            else
            {
                Assert.Same(replacement, actualResult);
            }
        }

        private class PlainTextFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class MyMediaTypeMapping : MediaTypeMapping
        {
            public MyMediaTypeMapping(MediaTypeHeaderValue mediaType)
                : base(mediaType)
            {
            }

            public override double TryMatchMediaType(HttpRequestMessage request)
            {
                if (request.Headers.Contains("Cookie"))
                {
                    return 1.0;
                }
                else
                {
                    return 0;
                }
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/FormDataCollectionTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class FormDataCollectionTests
    {
        [Fact]
        public void CreateFromUri()
        {
            FormDataCollection form = new FormDataCollection(new Uri("http://foo.com/?x=1&y=2"));

            Assert.Equal("1", form.Get("x"));
            Assert.Equal("2", form.Get("y"));
        }

        [Fact]
        public void IndexerIsEquivalentToGet()
        {
            FormDataCollection form = new FormDataCollection(new Uri("http://foo.com/?x=1&y=2"));

            Assert.Equal("1", form.Get("x"));
            Assert.Equal(form["x"], form.Get("x"));
            Assert.Equal(form[null], form.Get(null));
        }

        [Fact]
        public void CreateFromEmptyUri()
        {
            FormDataCollection form = new FormDataCollection(new Uri("http://foo.com"));

            Assert.Empty(form);
        }

        [Fact]
        public void UriConstructorThrowsNull()
        {
            Assert.ThrowsArgumentNull(() => new FormDataCollection((Uri)null), "uri");
        }

        [Fact]
        public void CreateFromEmptyString()
        {
            FormDataCollection form = new FormDataCollection("");

            Assert.Empty(form);
        }

        [Fact]
        public void CreateFromNullString()
        {
            FormDataCollection form = new FormDataCollection((string)null);

            Assert.Empty(form);
        }

        [Fact]
        public void PairConstructorThrowsNull()
        {
            var arg = (IEnumerable<KeyValuePair<string, string>>)null;
            Assert.ThrowsArgumentNull(() => new FormDataCollection(arg), "pairs");
        }

        [Fact]
        public void CreateFromPairs()
        {
            Dictionary<string, string> pairs = new Dictionary<string, string>
            {
                { "x",  "1"},
                { "y" , "2"}
            };

            var form = new FormDataCollection(pairs);

            Assert.Equal("1", form.Get("x"));
            Assert.Equal("2", form.Get("y"));
        }

        [Fact]
        public void Enumeration()
        {
            FormDataCollection form = new FormDataCollection(new Uri("http://foo.com/?x=1&y=2"));

            // Enumeration should be ordered
            String s = "";
            foreach (KeyValuePair<string, string> kv in form)
            {
                s += string.Format("{0}={1};", kv.Key, kv.Value);
            }

            Assert.Equal("x=1;y=2;", s);
        }

        [Fact]
        public void GetValues()
        {
            FormDataCollection form = new FormDataCollection(new Uri("http://foo.com/?x=1&x=2&x=3"));

            Assert.Equal(new string[] { "1", "2", "3" }, form.GetValues("x"));
        }

        [Fact]
        public void CaseInSensitive()
        {
            FormDataCollection form = new FormDataCollection(new Uri("http://foo.com/?x=1&Y=2"));

            var nvc = form.ReadAsNameValueCollection();

            Assert.Equal(2, nvc.Count);
            Assert.Equal("1", nvc.Get("x"));
            Assert.Equal("2", nvc.Get("y"));
        }

        [Fact]
        public void ToNameValueCollection()
        {
            FormDataCollection form = new FormDataCollection(new Uri("http://foo.com/?x=1a&y=2&x=1b&=ValueOnly&KeyOnly"));

            var nvc = form.ReadAsNameValueCollection();

            // y=2
            // x=1a;x=1b
            // =ValueOnly
            // KeyOnly
            Assert.Equal(4, nvc.Count);
            Assert.Equal(new string[] { "1a", "1b" }, nvc.GetValues("x"));
            Assert.Equal("1a,1b", nvc.Get("x"));
            Assert.Equal("2", nvc.Get("y"));
            Assert.Equal("", nvc.Get("KeyOnly"));
            Assert.Equal("ValueOnly", nvc.Get(""));
        }

        const string SPACE = " "; // single literal space character

        [Theory]
        [InlineData("x=?", "?")] // normal
        [InlineData("x=%3f", "?")] // normal
        [InlineData("x=%3d", "=")] // normal
        [InlineData("x=abc", "abc")] // normal
        [InlineData("x", "")] // key only
        [InlineData("x=", "")] // rhs only
        [InlineData("x=%20", SPACE)] // escaped space
        [InlineData("x=" + SPACE, SPACE)] // literal space
        [InlineData("x=+", SPACE)]
        [InlineData("x=null", "null")] // null literal, not escaped
        [InlineData("x=undefined", "undefined")] // undefined literal, not escaped
        [InlineData("x=\"null\"", "\"null\"")] // quoted null, preserved as is
        public void Whitespace(string queryString, string expected)
        {
            FormDataCollection fd = new FormDataCollection(queryString);

            Assert.Single(fd);
            Assert.Equal(expected, fd.Get("x"));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/FormUrlEncodedFromContentTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http.Formatting.Parsers;
using System.Text;
using System.Web.Http;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class FormUrlEncodedJsonFromContentTests
    {
        public static TheoryDataSet<string, string> TestEncodedNameTestData
        {
            get
            {
                // string: encoded string: result
                return new TheoryDataSet<string, string>
                {
                    { "some+thing=10", @"{""some thing"":""10""}" },
                    { "%E5%B8%A6%E4%B8%89%E4%B8%AA%E8%A1%A8=bar", @"{""带三个表"":""bar""}" },
                    { "some+thing=10&%E5%B8%A6%E4%B8%89%E4%B8%AA%E8%A1%A8=bar", @"{""some thing"":""10"",""带三个表"":""bar""}"},
                    { "a[0\r\n][b]=1", "{\"a\":{\"0\\r\\n\":{\"b\":\"1\"}}}" },
                    { "a[0%0d\n][b]=1", "{\"a\":{\"0\\r\\n\":{\"b\":\"1\"}}}" },
                    { "a[0%0d%0a][b]=1", "{\"a\":{\"0\\r\\n\":{\"b\":\"1\"}}}" },
                    { "a[0\0]=1", "{\"a\":{\"0\\u0000\":\"1\"}}" },
                    { "a[0%00]=1", "{\"a\":{\"0\\u0000\":\"1\"}}" },
                    { "a[\00]=1", "{\"a\":{\"\\u00000\":\"1\"}}" },
                    { "a[%000]=1", "{\"a\":{\"\\u00000\":\"1\"}}" },
                };
            }
        }

        public static TheoryDataSet<string, string> TestObjectTestData
        {
            get
            {
                // string: encoded string: result
                return new TheoryDataSet<string, string>
                {
                    { "a[]=4&a[]=5&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=true&b[z][]=undefined&b[z][]=&c=1&f=",
                     @"{""a"":[""4"",""5""],""b"":{""x"":[""7""],""y"":""8"",""z"":[""9"",""true"",""undefined"",""""]},""c"":""1"",""f"":""""}" },

                    { "customer[Name]=Pete&customer[Address]=Redmond&customer[Age][0][]=23&customer[Age][0][]=24&customer[Age][1][]=25&" +
                      "customer[Age][1][]=26&customer[Phones][]=425+888+1111&customer[Phones][]=425+345+7777&customer[Phones][]=425+888+4564&" +
                      "customer[EnrolmentDate]=%22%5C%2FDate(1276562539537)%5C%2F%22&role=NewRole&changeDate=3&count=15",
                      @"{""customer"":{""Name"":""Pete"",""Address"":""Redmond"",""Age"":[[""23"",""24""],[""25"",""26""]]," +
                      @"""Phones"":[""425 888 1111"",""425 345 7777"",""425 888 4564""],""EnrolmentDate"":""\""\\/Date(1276562539537)\\/\""""},""role"":""NewRole"",""changeDate"":""3"",""count"":""15""}" },

                    { "customers[0][Name]=Pete2&customers[0][Address]=Redmond2&customers[0][Age][0][]=23&customers[0][Age][0][]=24&" +
                      "customers[0][Age][1][]=25&customers[0][Age][1][]=26&customers[0][Phones][]=425+888+1111&customers[0][Phones][]=425+345+7777&" +
                      "customers[0][Phones][]=425+888+4564&customers[0][EnrolmentDate]=%22%5C%2FDate(1276634840700)%5C%2F%22&customers[1][Name]=Pete3&" +
                      "customers[1][Address]=Redmond3&customers[1][Age][0][]=23&customers[1][Age][0][]=24&customers[1][Age][1][]=25&customers[1][Age][1][]=26&" +
                      "customers[1][Phones][]=425+888+1111&customers[1][Phones][]=425+345+7777&customers[1][Phones][]=425+888+4564&customers[1][EnrolmentDate]=%22%5C%2FDate(1276634840700)%5C%2F%22",
                      @"{""customers"":[{""Name"":""Pete2"",""Address"":""Redmond2"",""Age"":[[""23"",""24""],[""25"",""26""]]," +
                      @"""Phones"":[""425 888 1111"",""425 345 7777"",""425 888 4564""],""EnrolmentDate"":""\""\\/Date(1276634840700)\\/\""""}," +
                      @"{""Name"":""Pete3"",""Address"":""Redmond3"",""Age"":[[""23"",""24""],[""25"",""26""]],""Phones"":[""425 888 1111"",""425 345 7777"",""425 888 4564""],""EnrolmentDate"":""\""\\/Date(1276634840700)\\/\""""}]}" },

                    { "ab%5B%5D=hello", @"{""ab"":[""hello""]}" },

                    { "123=hello", @"{""123"":""hello""}" },

                    { "a%5B%5D=1&a", @"{""a"":[""1"",""""]}" },

                    { "a=1&a", @"{""a"":[""1"",""""]}" }
                };
            }
        }

        [Theory,
            InlineData("abc", "{\"abc\":\"\"}"),
            InlineData("%2eabc%2e", "{\".abc.\":\"\"}"),
            InlineData("", "{}"),
            InlineData("a=1", "{\"a\":\"1\"}")]
        public void SimpleStringsTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);

        }

        [Theory,
            InlineData("a=2", "{\"a\":\"2\"}"),
            InlineData("b=true", "{\"b\":\"true\"}"),
            InlineData("c=hello", "{\"c\":\"hello\"}"),
            InlineData("d=", "{\"d\":\"\"}"),
            InlineData("e=null", "{\"e\":\"null\"}")]
        public void SimpleObjectsTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);

        }

        [Fact]
        public void LegacyArraysTest()
        {
            ValidateFormUrlEncoded("a=1&a=hello&a=333", "{\"a\":[\"1\",\"hello\",\"333\"]}");

            // Only valid in shallow serialization
            ParseInvalidFormUrlEncoded("a[z]=2&a[z]=3");
        }

        [Theory,
            InlineData("a[]=1&a[]=hello&a[]=333", "{\"a\":[\"1\",\"hello\",\"333\"]}"),
            InlineData("a[b][]=1&a[b][]=hello&a[b][]=333", "{\"a\":{\"b\":[\"1\",\"hello\",\"333\"]}}"),
            InlineData("a[]=", "{\"a\":[\"\"]}"),
            InlineData("a%5B%5D=2", @"{""a"":[""2""]}"),
            InlineData("a[x][0]=1&a[x][]=2", @"{""a"":{""x"":[""1"",""2""]}}")]
        public void ArraysTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("a[0][]=1&a[0][]=hello&a[1][]=333", "{\"a\":[[\"1\",\"hello\"],[\"333\"]]}"),
            InlineData("a[b][0][]=1&a[b][1][]=hello&a[b][1][]=333", "{\"a\":{\"b\":[[\"1\"],[\"hello\",\"333\"]]}}"),
            InlineData("a[0][0][0][]=1", "{\"a\":[[[[\"1\"]]]]}")]
        public void MultidimensionalArraysTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("a[0][]=hello&a[2][]=333", "{\"a\":{\"0\":[\"hello\"],\"2\":[\"333\"]}}"),
            InlineData("a[0]=hello", "{\"a\":[\"hello\"]}"),
            InlineData("a[1][]=hello", "{\"a\":{\"1\":[\"hello\"]}}"),
            InlineData("a[1][0]=hello", "{\"a\":{\"1\":[\"hello\"]}}")]
        public void SparseArraysTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("b[]=2&b[1][c]=d", "{\"b\":[\"2\",{\"c\":\"d\"}]}")]
        public void ArraysWithMixedMembers(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("=3", "{\"\":\"3\"}"),
            InlineData("a=1&=3", "{\"a\":\"1\",\"\":\"3\"}"),
            InlineData("=3&b=2", "{\"\":\"3\",\"b\":\"2\"}")]
        public void EmptyKeyTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("a[b]=1&a=2"),
            InlineData("a[b]=1&a[b][]=2"),
            InlineData("a[x][]=1&a[x][0]=2"),
            InlineData("a=2&a[b]=1"),
            InlineData("[]=1"),
            InlineData("a[][]=0"),
            InlineData("a[][x]=0"),
            InlineData("a&a[b]=1")]
        public void InvalidObjectGraphsTest(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        [Theory,
            InlineData("a[b=2"),
            InlineData("a[[b]=2"),
            InlineData("a[b]]=2")]
        public void InvalidFormUrlEncodingTest(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS primitives.
        /// </summary>
        [Theory,
            InlineData("abc", @"{""abc"":""""}"),
            InlineData("123", @"{""123"":""""}"),
            InlineData("true", @"{""true"":""""}"),
            InlineData("", "{}"),
            InlineData("%2fabc%2f", @"{""/abc/"":""""}")]
        public void TestJValue(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Negative tests for parsing form-urlencoded data originated from JS primitives.
        /// </summary>
        [Theory,
            InlineData("a[b]=1&a=2"),
            InlineData("a=2&a[b]=1"),
            InlineData("[]=1")]
        public void TestJValueNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS objects.
        /// </summary>
        [Theory,
            InlineData("a=NaN", @"{""a"":""NaN""}"),
            InlineData("a=false", @"{""a"":""false""}"),
            InlineData("a=foo", @"{""a"":""foo""}"),
            InlineData("1=1", "{\"1\":\"1\"}")]
        public void TestObjects(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS arrays.
        /// </summary>
        [Theory,
            InlineData("a[]=2", @"{""a"":[""2""]}"),
            InlineData("a[]=", @"{""a"":[""""]}"),
            InlineData("a[0][0][]=1", @"{""a"":[[[""1""]]]}"),
            InlineData("z[]=9&z[]=true&z[]=undefined&z[]=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
            InlineData("z[]=9&z[]=true&z[]=undefined&z[]=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
            InlineData("z[0][]=9&z[0][]=true&z[1][]=undefined&z[1][]=null", @"{""z"":[[""9"",""true""],[""undefined"",""null""]]}"),
            InlineData("a[0][x]=2", @"{""a"":[{""x"":""2""}]}"),
            InlineData("a%5B%5D=2", @"{""a"":[""2""]}"),
            InlineData("a%5B%5D=", @"{""a"":[""""]}"),
            InlineData("z%5B%5D=9&z%5B%5D=true&z%5B%5D=undefined&z%5B%5D=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
            InlineData("z%5B%5D=9&z%5B%5D=true&z%5B%5D=undefined&z%5B%5D=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
            InlineData("z%5B0%5D%5B%5D=9&z%5B0%5D%5B%5D=true&z%5B1%5D%5B%5D=undefined&z%5B1%5D%5B%5D=null", @"{""z"":[[""9"",""true""],[""undefined"",""null""]]}")]
        public void TestArray(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS arrays, using the jQuery 1.3 format (no []'s).
        /// </summary>
        [Theory,
            InlineData("z=9&z=true&z=undefined&z=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
            InlineData("z=9&z=true&z=undefined&z=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
            InlineData("z=9&z=true&z=undefined&z=null&a=hello", @"{""z"":[""9"",""true"",""undefined"",""null""],""a"":""hello""}")]
        public void TestArrayCompat(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Negative tests for parsing form-urlencoded data originated from JS arrays.
        /// </summary>
        [Theory,
            InlineData("a[z]=2&a[z]=3")]
        public void TestArrayCompatNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for form-urlencoded data originated from sparse JS arrays.
        /// </summary>
        [Theory,
            InlineData("a[2]=hello", @"{""a"":{""2"":""hello""}}"),
            InlineData("a[x][0]=2", @"{""a"":{""x"":[""2""]}}"),
            InlineData("a[x][1]=2", @"{""a"":{""x"":{""1"":""2""}}}"),
            InlineData("a[x][0]=0&a[x][1]=1", @"{""a"":{""x"":[""0"",""1""]}}"),
            InlineData("a[0][0][0]=hello&a[1][0][0][0][]=hello", @"{""a"":[[[""hello""]],[[[[""hello""]]]]]}"),
            InlineData("a[0][0][0]=hello&a[1][0][0][0]=hello", @"{""a"":[[[""hello""]],[[[""hello""]]]]}"),
            InlineData("a[1][0][]=1", @"{""a"":{""1"":[[""1""]]}}"),
            InlineData("a[1][1][]=1", @"{""a"":{""1"":{""1"":[""1""]}}}"),
            InlineData("a[1][1][0]=1", @"{""a"":{""1"":{""1"":[""1""]}}}"),
            InlineData("a[0][]=2&a[0][]=3&a[2][]=1", "{\"a\":{\"0\":[\"2\",\"3\"],\"2\":[\"1\"]}}"),
            InlineData("a[x][]=1&a[x][1]=2", @"{""a"":{""x"":[""1"",""2""]}}"),
            InlineData("a[x][0]=1&a[x][]=2", @"{""a"":{""x"":[""1"",""2""]}}")]
        public void TestArraySparse(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Negative tests for parsing form-urlencoded arrays.
        /// </summary>
        [Theory,
            InlineData("a[x]=2&a[x][]=3"),
            InlineData("a[]=1&a[0][]=2"),
            InlineData("a[]=1&a[0][0][]=2"),
            InlineData("a[x][]=1&a[x][0]=2"),
            InlineData("a[][]=0"),
            InlineData("a[][x]=0")]
        public void TestArrayIndexNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for parsing complex object graphs form-urlencoded.
        /// </summary>
        [Theory]
        [PropertyData("TestObjectTestData")]
        public void TestObject(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data with encoded names.
        /// </summary>
        [Theory]
        [PropertyData("TestEncodedNameTestData")]
        public void TestEncodedName(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for malformed form-urlencoded data.
        /// </summary>
        [Theory,
            InlineData("a[b=2"),
            InlineData("a[[b]=2"),
            InlineData("a[b]]=2")]
        public void TestNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        private static void BuildParams(string prefix, JToken jsonValue, List<string> results)
        {
            if (jsonValue is JValue)
            {
                JValue jsonPrimitive = jsonValue as JValue;
                if (jsonPrimitive != null)
                {
                    if (jsonPrimitive.Type == JTokenType.String && String.IsNullOrEmpty(jsonPrimitive.Value.ToString()))
                    {
                        results.Add(prefix + "=" + String.Empty);
                    }
                    else
                    {
                        if (jsonPrimitive.Value is DateTime || jsonPrimitive.Value is DateTimeOffset)
                        {
                            string dateStr = jsonPrimitive.ToString();
                            if (!String.IsNullOrEmpty(dateStr) && dateStr.StartsWith("\""))
                            {
                                dateStr = dateStr.Substring(1, dateStr.Length - 2);
                            }
                            results.Add(prefix + "=" + WebUtility.UrlEncode(dateStr));
                        }
                        else
                        {
                            results.Add(prefix + "=" + WebUtility.UrlEncode(jsonPrimitive.Value.ToString()));
                        }
                    }
                }
                else
                {
                    results.Add(prefix + "=" + String.Empty);
                }
            }
            else if (jsonValue is JArray)
            {
                for (int i = 0; i < ((JArray)jsonValue).Count; i++)
                {
                    if (jsonValue[i] is JArray || jsonValue[i] is JObject)
                    {
                        BuildParams(prefix + "[" + i + "]", jsonValue[i], results);
                    }
                    else
                    {
                        BuildParams(prefix + "[]", jsonValue[i], results);
                    }
                }
            }
            else
            {
                //jsonValue is JObject
                foreach (KeyValuePair<string, JToken> item in (JObject)jsonValue)
                {
                    BuildParams(prefix + "[" + item.Key + "]", item.Value, results);
                }
            }
        }

        private static void ParseInvalidFormUrlEncoded(string encoded)
        {
            byte[] data = Encoding.UTF8.GetBytes(encoded);
            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                ICollection<KeyValuePair<string, string>> collection;
                FormUrlEncodedParser parser = FormUrlEncodedParserTests.CreateParser(data.Length + 1, out collection);
                Assert.NotNull(parser);

                int totalBytesConsumed;
                ParserState state = FormUrlEncodedParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.ThrowsArgument(() => { FormUrlEncodedJson.Parse(collection); }, null);
            }
        }

        private static void ValidateFormUrlEncoded(string encoded, string expectedResult)
        {
            byte[] data = Encoding.UTF8.GetBytes(encoded);
            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                ICollection<KeyValuePair<string, string>> collection;
                FormUrlEncodedParser parser = FormUrlEncodedParserTests.CreateParser(data.Length + 1, out collection);
                Assert.NotNull(parser);

                int totalBytesConsumed;
                ParserState state = FormUrlEncodedParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                JObject result = FormUrlEncodedJson.Parse(collection);
                Assert.NotNull(result);
                Assert.Equal(expectedResult, result.ToString(Newtonsoft.Json.Formatting.None));
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/FormUrlEncodedFromUriQueryTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class FormUrlEncodedJsonFromUriQueryTests
    {
        [Theory,
            InlineData("abc", "{\"abc\":\"\"}"),
            InlineData("%2eabc%2e", "{\".abc.\":\"\"}"),
            InlineData("", "{}"),
            InlineData("a=1", "{\"a\":\"1\"}")]
        public void SimpleStringsTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("a=2", "{\"a\":\"2\"}"),
            InlineData("b=true", "{\"b\":\"true\"}"),
            InlineData("c=hello", "{\"c\":\"hello\"}"),
            InlineData("d=", "{\"d\":\"\"}"),
            InlineData("e=null", "{\"e\":\"null\"}")]
        public void SimpleObjectsTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Fact]
        public void LegacyArraysTest()
        {
            ValidateFormUrlEncoded("a=1&a=hello&a=333", "{\"a\":[\"1\",\"hello\",\"333\"]}");

            // Only valid in shallow serialization
            ParseInvalidFormUrlEncoded("a[z]=2&a[z]=3");
        }

        [Theory,
            InlineData("a[]=1&a[]=hello&a[]=333", "{\"a\":[\"1\",\"hello\",\"333\"]}"),
            InlineData("a[b][]=1&a[b][]=hello&a[b][]=333", "{\"a\":{\"b\":[\"1\",\"hello\",\"333\"]}}"),
            InlineData("a[]=", "{\"a\":[\"\"]}"),
            InlineData("a%5B%5D=2", @"{""a"":[""2""]}"),
            InlineData("a[x][0]=1&a[x][]=2", @"{""a"":{""x"":[""1"",""2""]}}")]
        public void ArraysTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("a[0][]=1&a[0][]=hello&a[1][]=333", "{\"a\":[[\"1\",\"hello\"],[\"333\"]]}"),
            InlineData("a[b][0][]=1&a[b][1][]=hello&a[b][1][]=333", "{\"a\":{\"b\":[[\"1\"],[\"hello\",\"333\"]]}}"),
            InlineData("a[0][0][0][]=1", "{\"a\":[[[[\"1\"]]]]}")]
        public void MultidimensionalArraysTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("a[0][]=hello&a[2][]=333", "{\"a\":{\"0\":[\"hello\"],\"2\":[\"333\"]}}"),
            InlineData("a[0]=hello", "{\"a\":[\"hello\"]}"),
            InlineData("a[1][]=hello", "{\"a\":{\"1\":[\"hello\"]}}"),
            InlineData("a[1][0]=hello", "{\"a\":{\"1\":[\"hello\"]}}")]
        public void SparseArraysTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("b[]=2&b[1][c]=d", "{\"b\":[\"2\",{\"c\":\"d\"}]}")]
        public void ArraysWithMixedMembers(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("=3", "{\"\":\"3\"}"),
            InlineData("a=1&=3", "{\"a\":\"1\",\"\":\"3\"}"),
            InlineData("=3&b=2", "{\"\":\"3\",\"b\":\"2\"}")]
        public void EmptyKeyTest(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        [Theory,
            InlineData("a[b]=1&a=2"),
            InlineData("a[b]=1&a[b][]=2"),
            InlineData("a[x][]=1&a[x][0]=2"),
            InlineData("a=2&a[b]=1"),
            InlineData("[]=1"),
            InlineData("a[][]=0"),
            InlineData("a[][x]=0"),
            InlineData("a&a[b]=1")]
        public void InvalidObjectGraphsTest(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        [Theory,
            InlineData("a[b=2"),
            InlineData("a[[b]=2"),
            InlineData("a[b]]=2")]
        public void InvalidFormUrlEncodingTest(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS primitives.
        /// </summary>
        [Theory,
            InlineData("abc", @"{""abc"":""""}"),
            InlineData("123", @"{""123"":""""}"),
            InlineData("true", @"{""true"":""""}"),
            InlineData("", "{}"),
            InlineData("%2fabc%2f", @"{""/abc/"":""""}")]
        public void TestJValue(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Negative tests for parsing form-urlencoded data originated from JS primitives.
        /// </summary>
        [Theory,
            InlineData("a[b]=1&a=2"),
            InlineData("a=2&a[b]=1"),
            InlineData("[]=1")]
        public void TestJValueNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS objects.
        /// </summary>
        [Theory,
            InlineData("a=NaN", @"{""a"":""NaN""}"),
            InlineData("a=false", @"{""a"":""false""}"),
            InlineData("a=foo", @"{""a"":""foo""}"),
            InlineData("1=1", "{\"1\":\"1\"}")]
        public void TestObjects(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS arrays.
        /// </summary>
        [Theory,
            InlineData("a[]=2", @"{""a"":[""2""]}"),
            InlineData("a[]=", @"{""a"":[""""]}"),
            InlineData("a[0][0][]=1", @"{""a"":[[[""1""]]]}"),
            InlineData("z[]=9&z[]=true&z[]=undefined&z[]=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
            InlineData("z[]=9&z[]=true&z[]=undefined&z[]=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
            InlineData("z[0][]=9&z[0][]=true&z[1][]=undefined&z[1][]=null", @"{""z"":[[""9"",""true""],[""undefined"",""null""]]}"),
            InlineData("a[0][x]=2", @"{""a"":[{""x"":""2""}]}"),
            InlineData("a%5B%5D=2", @"{""a"":[""2""]}"),
            InlineData("a%5B%5D=", @"{""a"":[""""]}"),
            InlineData("z%5B%5D=9&z%5B%5D=true&z%5B%5D=undefined&z%5B%5D=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
            InlineData("z%5B%5D=9&z%5B%5D=true&z%5B%5D=undefined&z%5B%5D=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
            InlineData("z%5B0%5D%5B%5D=9&z%5B0%5D%5B%5D=true&z%5B1%5D%5B%5D=undefined&z%5B1%5D%5B%5D=null", @"{""z"":[[""9"",""true""],[""undefined"",""null""]]}")]
        public void TestArray(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data originated from JS arrays, using the jQuery 1.3 format (no []'s).
        /// </summary>
        [Theory,
            InlineData("z=9&z=true&z=undefined&z=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
            InlineData("z=9&z=true&z=undefined&z=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
            InlineData("z=9&z=true&z=undefined&z=null&a=hello", @"{""z"":[""9"",""true"",""undefined"",""null""],""a"":""hello""}")]
        public void TestArrayCompat(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Negative tests for parsing form-urlencoded data originated from JS arrays.
        /// </summary>
        [Theory,
            InlineData("a[z]=2&a[z]=3")]
        public void TestArrayCompatNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for form-urlencoded data originated from sparse JS arrays.
        /// </summary>
        [Theory,
            InlineData("a[2]=hello", @"{""a"":{""2"":""hello""}}"),
            InlineData("a[x][0]=2", @"{""a"":{""x"":[""2""]}}"),
            InlineData("a[x][1]=2", @"{""a"":{""x"":{""1"":""2""}}}"),
            InlineData("a[x][0]=0&a[x][1]=1", @"{""a"":{""x"":[""0"",""1""]}}"),
            InlineData("a[0][0][0]=hello&a[1][0][0][0][]=hello", @"{""a"":[[[""hello""]],[[[[""hello""]]]]]}"),
            InlineData("a[0][0][0]=hello&a[1][0][0][0]=hello", @"{""a"":[[[""hello""]],[[[""hello""]]]]}"),
            InlineData("a[1][0][]=1", @"{""a"":{""1"":[[""1""]]}}"),
            InlineData("a[1][1][]=1", @"{""a"":{""1"":{""1"":[""1""]}}}"),
            InlineData("a[1][1][0]=1", @"{""a"":{""1"":{""1"":[""1""]}}}"),
            InlineData("a[0][]=2&a[0][]=3&a[2][]=1", "{\"a\":{\"0\":[\"2\",\"3\"],\"2\":[\"1\"]}}"),
            InlineData("a[x][]=1&a[x][1]=2", @"{""a"":{""x"":[""1"",""2""]}}"),
            InlineData("a[x][0]=1&a[x][]=2", @"{""a"":{""x"":[""1"",""2""]}}")]
        public void TestArraySparse(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Negative tests for parsing form-urlencoded arrays.
        /// </summary>
        [Theory,
            InlineData("a[x]=2&a[x][]=3"),
            InlineData("a[]=1&a[0][]=2"),
            InlineData("a[]=1&a[0][0][]=2"),
            InlineData("a[x][]=1&a[x][0]=2"),
            InlineData("a[][]=0"),
            InlineData("a[][x]=0")]
        public void TestArrayIndexNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        /// <summary>
        /// Tests for parsing complex object graphs form-urlencoded.
        /// </summary>
        [Theory]
        [TestDataSet(typeof(FormUrlEncodedJsonFromContentTests), "TestObjectTestData")]
        public void TestObject(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for parsing form-urlencoded data with encoded names.
        /// </summary>
        [Theory]
        [TestDataSet(typeof(FormUrlEncodedJsonFromContentTests), "TestEncodedNameTestData")]
        public void TestEncodedName(string encoded, string expectedResult)
        {
            ValidateFormUrlEncoded(encoded, expectedResult);
        }

        /// <summary>
        /// Tests for malformed form-urlencoded data.
        /// </summary>
        [Theory,
            InlineData("a[b=2"),
            InlineData("a[[b]=2"),
            InlineData("a[b]]=2")]
        public void TestNegative(string encoded)
        {
            ParseInvalidFormUrlEncoded(encoded);
        }

        private static void BuildParams(string prefix, JToken jsonValue, List<string> results)
        {
            if (jsonValue is JValue)
            {
                JValue jsonPrimitive = jsonValue as JValue;
                if (jsonPrimitive != null)
                {
                    if (jsonPrimitive.Type == JTokenType.String && String.IsNullOrEmpty(jsonPrimitive.Value.ToString()))
                    {
                        results.Add(prefix + "=" + String.Empty);
                    }
                    else
                    {
                        if (jsonPrimitive.Value is DateTime || jsonPrimitive.Value is DateTimeOffset)
                        {
                            string dateStr = jsonPrimitive.ToString();
                            if (!String.IsNullOrEmpty(dateStr) && dateStr.StartsWith("\""))
                            {
                                dateStr = dateStr.Substring(1, dateStr.Length - 2);
                            }
                            results.Add(prefix + "=" + WebUtility.UrlEncode(dateStr));
                        }
                        else
                        {
                            results.Add(prefix + "=" + WebUtility.UrlEncode(jsonPrimitive.Value.ToString()));
                        }
                    }
                }
                else
                {
                    results.Add(prefix + "=" + String.Empty);
                }
            }
            else if (jsonValue is JArray)
            {
                for (int i = 0; i < ((JArray)jsonValue).Count; i++)
                {
                    if (jsonValue[i] is JArray || jsonValue[i] is JObject)
                    {
                        BuildParams(prefix + "[" + i + "]", jsonValue[i], results);
                    }
                    else
                    {
                        BuildParams(prefix + "[]", jsonValue[i], results);
                    }
                }
            }
            else
            {
                //jsonValue is JObject
                foreach (KeyValuePair<string, JToken> item in (JObject)jsonValue)
                {
                    BuildParams(prefix + "[" + item.Key + "]", item.Value, results);
                }
            }
        }

        private static Uri GetQueryUri(string query)
        {
            UriBuilder uriBuilder = new UriBuilder("http://some.host");
            uriBuilder.Query = query;
            return uriBuilder.Uri;
        }

        private static void ParseInvalidFormUrlEncoded(string encoded)
        {
            Uri address = GetQueryUri(encoded);
            JObject result;
            Assert.False(address.TryReadQueryAsJson(out result), "Expected parsing to return false");
            Assert.Null(result);
        }

        private static void ValidateFormUrlEncoded(string encoded, string expectedResult)
        {
            Uri address = GetQueryUri(encoded);
            JObject result;
            Assert.True(address.TryReadQueryAsJson(out result), "Expected parsing to return true");
            Assert.NotNull(result);
            Assert.Equal(expectedResult, result.ToString(Newtonsoft.Json.Formatting.None));
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/FormUrlEncodedJsonTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class FormUrlEncodedJsonTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(FormUrlEncodedJson), TypeAssert.TypeProperties.IsClass | TypeAssert.TypeProperties.IsStatic);
        }

        [Fact]
        public void ParseThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => FormUrlEncodedJson.Parse(null), null);
        }

        [Fact]
        public void ParseThrowsInvalidMaxDepth()
        {
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => FormUrlEncodedJson.Parse(CreateQuery(), -1), "maxDepth", "1", -1);
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => FormUrlEncodedJson.Parse(CreateQuery(), 0), "maxDepth", "1", 0);
        }

        [Fact]
        public void ParseThrowsMaxDepthExceeded()
        {
            // Depth of 'a[b]=1' is 3
            IEnumerable<KeyValuePair<string, string>> query = CreateQuery(new KeyValuePair<string, string>("a[b]", "1"));
            Assert.ThrowsArgument(() => { FormUrlEncodedJson.Parse(query, 2); }, null);

            // This should succeed
            Assert.NotNull(FormUrlEncodedJson.Parse(query, 3));
        }

        [Fact]
        public void TryParseThrowsOnNull()
        {
            JObject value;
            Assert.ThrowsArgumentNull(() => FormUrlEncodedJson.TryParse(null, out value), null);
        }

        [Fact]
        public void TryParseThrowsInvalidMaxDepth()
        {
            JObject value;
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => FormUrlEncodedJson.TryParse(CreateQuery(), -1, out value), "maxDepth", "1", -1);
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => FormUrlEncodedJson.TryParse(CreateQuery(), 0, out value), "maxDepth", "1", 0);
        }

        [Fact]
        public void TryParseReturnsFalseMaxDepthExceeded()
        {
            JObject value;

            // Depth of 'a[b]=1' is 3
            IEnumerable<KeyValuePair<string, string>> query = CreateQuery(new KeyValuePair<string, string>("a[b]", "1"));
            Assert.False(FormUrlEncodedJson.TryParse(query, 2, out value), "Parse should have failed due to too high depth.");

            // This should succeed
            Assert.True(FormUrlEncodedJson.TryParse(query, 3, out value), "Expected non-null JsonObject instance");
            Assert.NotNull(value);
        }

        private static IEnumerable<KeyValuePair<string, string>> CreateQuery(params KeyValuePair<string, string>[] namevaluepairs)
        {
            return new List<KeyValuePair<string, string>>(namevaluepairs);
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/FormUrlEncodedMediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class FormUrlEncodedMediaTypeFormatterTests
    {
        private const int MinBufferSize = 256;
        private const int DefaultBufferSize = 32 * 1024;
        private const int DefaultMaxDepth = 1024;

        [Fact]
        void CopyConstructor()
        {
            TestFormUrlEncodedMediaTypeFormatter formatter = new TestFormUrlEncodedMediaTypeFormatter()
            {
                MaxDepth = 42,
                ReadBufferSize = 512
            };

            TestFormUrlEncodedMediaTypeFormatter derivedFormatter = new TestFormUrlEncodedMediaTypeFormatter(formatter);

            Assert.Equal(formatter.MaxDepth, derivedFormatter.MaxDepth);
            Assert.Equal(formatter.ReadBufferSize, derivedFormatter.ReadBufferSize);
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(FormUrlEncodedMediaTypeFormatter), TypeAssert.TypeProperties.IsPublicVisibleClass);
        }

        [Fact]
        public void SupportedMediaTypes_HeaderValuesAreNotSharedBetweenInstances()
        {
            var formatter1 = new FormUrlEncodedMediaTypeFormatter();
            var formatter2 = new FormUrlEncodedMediaTypeFormatter();

            foreach (MediaTypeHeaderValue mediaType1 in formatter1.SupportedMediaTypes)
            {
                MediaTypeHeaderValue mediaType2 = formatter2.SupportedMediaTypes.Single(m => m.Equals(mediaType1));
                Assert.NotSame(mediaType1, mediaType2);
            }
        }

        [Fact]
        public void SupportEncodings_ValuesAreNotSharedBetweenInstances()
        {
            var formatter1 = new FormUrlEncodedMediaTypeFormatter();
            var formatter2 = new FormUrlEncodedMediaTypeFormatter();

            foreach (Encoding encoding1 in formatter1.SupportedEncodings)
            {
                Encoding encoding2 = formatter2.SupportedEncodings.Single(e => e.Equals(encoding1));
                Assert.NotSame(encoding1, encoding2);
            }
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "StandardFormUrlEncodedMediaTypes")]
        public void Constructor(MediaTypeHeaderValue mediaType)
        {
            FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter();
            Assert.True(formatter.SupportedMediaTypes.Contains(mediaType), String.Format("SupportedMediaTypes should have included {0}.", mediaType.ToString()));
        }

        [Fact]
        public void DefaultMediaTypeReturnsApplicationJson()
        {
            MediaTypeHeaderValue mediaType = FormUrlEncodedMediaTypeFormatter.DefaultMediaType;
            Assert.NotNull(mediaType);
            Assert.Equal("application/x-www-form-urlencoded", mediaType.MediaType);
        }

        [Fact]
        public void ReadBufferSize_RoundTrips()
        {
            Assert.Reflection.IntegerProperty(
                new FormUrlEncodedMediaTypeFormatter(),
                c => c.ReadBufferSize,
                expectedDefaultValue: 32 * 1024,
                minLegalValue: 256,
                illegalLowerValue: 255,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 1024);
        }

        [Fact]
        public void MaxDepthReturnsCorrectValue()
        {
            Assert.Reflection.IntegerProperty(
                 new FormUrlEncodedMediaTypeFormatter(),
                 f => f.MaxDepth,
                 expectedDefaultValue: 256,
                 minLegalValue: 1,
                 illegalLowerValue: 0,
                 maxLegalValue: null,
                 illegalUpperValue: null,
                 roundTripTestValue: 10);
        }

        [Fact]
        public async Task ReadDeeplyNestedObjectThrows()
        {
            FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter() { MaxDepth = 100 };

            StringContent content = new StringContent(GetDeeplyNestedObject(125));

            content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
            var contentStream = await content.ReadAsStreamAsync();
            await Assert.ThrowsAsync<ArgumentException>(
                () => formatter.ReadFromStreamAsync(typeof(JToken), contentStream, content, null));
        }

        [Fact]
        public async Task ReadDeeplyNestedObjectWithBigDepthQuotaWorks()
        {
            FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter() { MaxDepth = 150 };

            StringContent content = new StringContent(GetDeeplyNestedObject(125));

            content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

            var contentStream = await content.ReadAsStreamAsync();
            JToken result = (JToken)(await formatter.ReadFromStreamAsync(typeof(JToken), contentStream, content, null));
            Assert.NotNull(result);
        }

        static string GetDeeplyNestedObject(int depth)
        {
            StringBuilder sb = new StringBuilder("a");
            for (int i = 0; i < depth; i++)
            {
                sb.Append("[a]");
            }
            sb.Append("=1");
            return sb.ToString();
        }

        [Fact]
        public void CanReadTypeThrowsOnNull()
        {
            TestFormUrlEncodedMediaTypeFormatter formatter = new TestFormUrlEncodedMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.CanReadType(null); }, "type");
        }

        [Theory]
        [InlineData(typeof(FormDataCollection))]
        [InlineData(typeof(JToken))]
        public void CanReadTypeTrue(Type type)
        {
            TestFormUrlEncodedMediaTypeFormatter formatter = new TestFormUrlEncodedMediaTypeFormatter();

            Assert.True(formatter.CanReadType(type));
        }


        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection")]
        public void CanReadTypeReturnsFalse(Type variationType, object testData)
        {
            GC.KeepAlive(testData); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            TestFormUrlEncodedMediaTypeFormatter formatter = new TestFormUrlEncodedMediaTypeFormatter();

            Assert.False(formatter.CanReadType(variationType));

            // Ask a 2nd time to probe whether the cached result is treated the same
            Assert.False(formatter.CanReadType(variationType));
        }


        [Fact]
        public void CanWriteTypeThrowsOnNull()
        {
            TestFormUrlEncodedMediaTypeFormatter formatter = new TestFormUrlEncodedMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.CanWriteType(null); }, "type");
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection")]
        public void CanWriteTypeReturnsFalse(Type variationType, object testData)
        {
            GC.KeepAlive(testData); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            TestFormUrlEncodedMediaTypeFormatter formatter = new TestFormUrlEncodedMediaTypeFormatter();

            Assert.False(formatter.CanWriteType(variationType), "formatter should have returned false.");

            // Ask a 2nd time to probe whether the cached result is treated the same
            Assert.False(formatter.CanWriteType(variationType), "formatter should have returned false on 2nd try as well.");
        }

        [Fact]
        public void ReadFromStreamThrowsOnNull()
        {
            TestFormUrlEncodedMediaTypeFormatter formatter = new TestFormUrlEncodedMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.ReadFromStreamAsync(null, Stream.Null, null, null); }, "type");
            Assert.ThrowsArgumentNull(() => { formatter.ReadFromStreamAsync(typeof(object), null, null, null); }, "readStream");
        }

        [Fact]
        public void WriteToStreamAsyncThrowsNotImplemented()
        {
            FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter();
            Assert.Throws<NotSupportedException>(
                () => formatter.WriteToStreamAsync(typeof(object), new object(), Stream.Null, null, null),
                "The media type formatter of type 'FormUrlEncodedMediaTypeFormatter' does not support writing because it does not implement the WriteToStreamAsync method.");
        }

        public class TestFormUrlEncodedMediaTypeFormatter : FormUrlEncodedMediaTypeFormatter
        {
            public TestFormUrlEncodedMediaTypeFormatter()
            {
            }

            public TestFormUrlEncodedMediaTypeFormatter(TestFormUrlEncodedMediaTypeFormatter formatter)
                : base(formatter)
            {
            }

            public new bool CanReadType(Type type)
            {
                return base.CanReadType(type);
            }

            public new bool CanWriteType(Type type)
            {
                return base.CanWriteType(type);
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/JsonMediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Formatting.DataSets.Types;
using System.Net.Http.Headers;
using System.Runtime.Serialization.Json;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class JsonMediaTypeFormatterTests : MediaTypeFormatterTestBase<JsonMediaTypeFormatter>
    {
        // Test data which should round-trip without type information in the serialization.  Contains an exhaustive
        // selection of JSON native types.  (BSON also supports Int32, Int64, DateTime, Guid, ... natively.)
        private static readonly RefTypeTestData<object> BunchOfJsonObjectsTestData = new RefTypeTestData<object>(
            () => new List<object> { null, String.Empty, "This is a string", false, true, Double.MinValue,
                Double.MaxValue, });

        // Test data for DBNull.  Separate from BunchOfJsonObjectsTestData because DBNull will round-trip as null.
        private static readonly RefTypeTestData<object> DBNullAsObjectTestData = new RefTypeTestData<object>(
            () => new List<object> { DBNull.Value, });

        public static IEnumerable<TestData> BunchOfJsonObjectsTestDataCollection
        {
            get { return new TestData[] { BunchOfJsonObjectsTestData, }; }
        }

        public static IEnumerable<TestData> DBNullAsObjectTestDataCollection
        {
            get { return new TestData[] { DBNullAsObjectTestData, }; }
        }

        public static List<Type> JTokenTypes
        {
            get
            {
                return new List<Type>
                {
                    typeof(JToken),
                    typeof(JValue),
                    typeof(JArray),
                    typeof(JObject)
                };
            }
        }

        public static IEnumerable<TestData> ValueAndRefTypeTestDataCollectionExceptULong
        {
            get
            {
                // Include neither ISerializable data set nor unsigned longs
                return CommonUnitTestDataSets.ValueAndRefTypeTestDataCollection.Except(
                    new TestData[] { CommonUnitTestDataSets.Ulongs, CommonUnitTestDataSets.ISerializableTypes });
            }
        }

        public override IEnumerable<MediaTypeHeaderValue> ExpectedSupportedMediaTypes
        {
            get { return HttpTestData.StandardJsonMediaTypes; }
        }

        public override IEnumerable<Encoding> ExpectedSupportedEncodings
        {
            get { return HttpTestData.StandardEncodings; }
        }

        public override byte[] ExpectedSampleTypeByteRepresentation
        {
            get { return ExpectedSupportedEncodings.ElementAt(0).GetBytes("{\"Number\":42}"); }
        }

        [Fact]
        void CopyConstructor()
        {
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter()
            {
                Indent = true,
                MaxDepth = 42,
                UseDataContractJsonSerializer = true
            };

            TestJsonMediaTypeFormatter derivedFormatter = new TestJsonMediaTypeFormatter(formatter);

            Assert.Equal(formatter.MaxDepth, derivedFormatter.MaxDepth);
            Assert.Equal(formatter.UseDataContractJsonSerializer, derivedFormatter.UseDataContractJsonSerializer);
            Assert.Equal(formatter.Indent, derivedFormatter.Indent);
            Assert.Same(formatter.SerializerSettings, derivedFormatter.SerializerSettings);
            Assert.Same(formatter.SerializerSettings.ContractResolver, derivedFormatter.SerializerSettings.ContractResolver);
        }

        [Fact]
        public void DefaultMediaType_ReturnsApplicationJson()
        {
            MediaTypeHeaderValue mediaType = JsonMediaTypeFormatter.DefaultMediaType;
            Assert.NotNull(mediaType);
            Assert.Equal("application/json", mediaType.MediaType);
        }

        [Fact]
        public void Indent_RoundTrips()
        {
            Assert.Reflection.BooleanProperty(
                new XmlMediaTypeFormatter(),
                c => c.Indent,
                expectedDefaultValue: false);
        }

        [Fact]
        public void MaxDepth_RoundTrips()
        {
            Assert.Reflection.IntegerProperty(
                new JsonMediaTypeFormatter(),
                c => c.MaxDepth,
                expectedDefaultValue: 256,
                minLegalValue: 1,
                illegalLowerValue: 0,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 256);
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection")]
        public void CanReadType_ReturnsExpectedValues(Type variationType, object testData)
        {
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            bool isSerializable = IsTypeSerializableWithJsonSerializer(variationType, testData);
            bool canSupport = formatter.CanReadTypeProxy(variationType);

            // If we don't agree, we assert only if the DCJ serializer says it cannot support something we think it should
            Assert.False(isSerializable != canSupport && isSerializable, String.Format("CanReadType returned wrong value for '{0}'.", variationType));

            // Ask a 2nd time to probe whether the cached result is treated the same
            canSupport = formatter.CanReadTypeProxy(variationType);
            Assert.False(isSerializable != canSupport && isSerializable, String.Format("2nd CanReadType returned wrong value for '{0}'.", variationType));
        }

        [Fact]
        public async Task FormatterThrowsOnWriteWhenOverridenCreateFails()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'CreateJsonSerializer' method threw an exception when attempting to create a JSON serializer.");

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerJsonSerializer);
        }

        [Fact]
        public async Task FormatterThrowsOnWriteWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'CreateJsonSerializer' method returned null. It must return a JSON serializer instance.");

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerJsonSerializer);
        }

        [Fact]
        public async Task FormatterThrowsOnReadWhenOverridenCreateFails()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'CreateJsonSerializer' method threw an exception when attempting to create a JSON serializer.");

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerJsonSerializer);
        }

        [Fact]
        public async Task FormatterThrowsOnReadWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'CreateJsonSerializer' method returned null. It must return a JSON serializer instance.");

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerJsonSerializer);
        }

#if !Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Fact]
        public async Task DataContractFormatterThrowsOnWriteWhenOverridenCreateFails()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;
            formatter.UseDataContractJsonSerializer = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'DataContractJsonSerializer' serializer cannot serialize the type 'SampleType'.");

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerJsonSerializer);
        }

        [Fact]
        public async Task DataContractFormatterThrowsOnWriteWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;
            formatter.UseDataContractJsonSerializer = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'DataContractJsonSerializer' serializer cannot serialize the type 'SampleType'.");

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerJsonSerializer);
        }

        [Fact]
        public async Task DataContractFormatterThrowsOnReadWhenOverridenCreateFails()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;
            formatter.UseDataContractJsonSerializer = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);
            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'DataContractJsonSerializer' serializer cannot serialize the type 'SampleType'.");

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerJsonSerializer);
        }

        [Fact]
        public async Task DataContractFormatterThrowsOnReadWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;
            formatter.UseDataContractJsonSerializer = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);

            await Assert.ThrowsAsync<InvalidOperationException>(action, "The 'DataContractJsonSerializer' serializer cannot serialize the type 'SampleType'.");

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerJsonSerializer);
        }
#endif

        [Fact]
        public void CanReadType_ReturnsTrueOnJtoken()
        {
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            foreach (Type type in JTokenTypes)
            {
                Assert.True(formatter.CanReadTypeProxy(type), "formatter should have returned true.");
            }
        }

        [Fact]
        public void CanWriteType_ReturnsTrueOnJtoken()
        {
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            foreach (Type type in JTokenTypes)
            {
                Assert.True(formatter.CanWriteTypeProxy(type), "formatter should have returned false.");
            }
        }

        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsJToken()
        {
            string beforeMessage = "Hello World";
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            JToken before = beforeMessage;
            MemoryStream memStream = new MemoryStream();
            JsonTextWriter jsonWriter = new JsonTextWriter(new StreamWriter(memStream));
            before.WriteTo(jsonWriter);
            jsonWriter.Flush();
            memStream.Position = 0;

            JToken after = (await Assert.Task.SucceedsWithResultAsync<object>(formatter.ReadFromStreamAsync(typeof(JToken), memStream, null, null))) as JToken;
            Assert.NotNull(after);
            string afterMessage = after.ToObject<string>();

            Assert.Equal(beforeMessage, afterMessage);
        }

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "ValueAndRefTypeTestDataCollectionExceptULong", RoundTripDataVariations)]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "BunchOfJsonObjectsTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsTypeSerializableWithJsonSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

#if !NETCOREAPP2_1 // DBNull not serializable on .NET Core 2.1.
        // Test alternate null value; always serialized as "null"
        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection", TestDataVariations.AllSingleInstances)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull(Type variationType, object testData)
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object.
            Assert.Null(readObj);
        }

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection", TestDataVariations.AsDictionary)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull_Dictionary(Type variationType, object testData)
        {
            // Guard
            IDictionary<string, object> expectedDictionary = Assert.IsType<Dictionary<string, object>>(testData);

            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object. Reach into collections.
            Assert.Equal(testData.GetType(), readObj.GetType());

            IDictionary<string, object> readDictionary = (IDictionary<string, object>)readObj;
            Assert.Equal(expectedDictionary.Count, readDictionary.Count);

            foreach (string key in expectedDictionary.Keys)
            {
                Assert.True(readDictionary.ContainsKey(key));
                Assert.Null(readDictionary[key]);
            }
        }

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection",
            TestDataVariations.AsArray | TestDataVariations.AsList)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull_Enumerable(Type variationType, object testData)
        {
            // Guard
            Assert.True((testData as IEnumerable<object>) != null);

            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            IEnumerable<object> expectedEnumerable = (IEnumerable<object>)testData;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object. Reach into collections.
            Assert.Equal(testData.GetType(), readObj.GetType());

            IEnumerable<object> readEnumerable = (IEnumerable<object>)readObj;
            Assert.Equal(expectedEnumerable.Count(), readEnumerable.Count());

            foreach (object readContent in readEnumerable)
            {
                Assert.Null(readContent);
            }
        }

        [Theory]
        [TestDataSet(typeof(JsonMediaTypeFormatterTests), "DBNullAsObjectTestDataCollection", TestDataVariations.AsClassMember)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNull_Holder(Type variationType, object testData)
        {
            // Guard
            Assert.IsType<TestDataHolder<object>>(testData);

            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value can be read back as null object. Reach into objects.
            Assert.Equal(testData.GetType(), readObj.GetType());

            TestDataHolder<object> readDataHolder = (TestDataHolder<object>)readObj;
            Assert.Null(readDataHolder.V1);
        }

        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNullAsNullString()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            Type variationType = typeof(string);
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.value can be read as null of any nullable type
            Assert.Null(readObj);
        }

        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsync_DBNull()
        {
            // Arrange
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            Type variationType = typeof(DBNull);
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // Only JSON case where DBNull.Value round-trips
            Assert.Equal(testData, readObj);
        }
#endif

        [Fact]
        public async Task UseDataContractJsonSerializer_False()
        {
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter
            {
                UseDataContractJsonSerializer = false
            };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            //Assert.True(serializedString.Contains("DataContractSampleType"),
            //    "SampleType should be serialized with data contract name DataContractSampleType because UseDataContractJsonSerializer is set to true.");
            Assert.False(serializedString.Contains("\r\n"), "Using JsonSerializer should emit data without indentation by default.");
        }

        [Fact]
        public async Task UseDataContractJsonSerializer_False_Indent()
        {
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter
            {
                UseDataContractJsonSerializer = false,
                Indent = true
            };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("\r\n"), "Using JsonSerializer with Indent set to true should emit data with indentation.");
        }

        [Theory]
        [InlineData(typeof(IQueryable<string>))]
        [InlineData(typeof(IEnumerable<string>))]
        public async Task UseJsonFormatterWithNull(Type type)
        {
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter
            {
                UseDataContractJsonSerializer = false
            };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(formatter.WriteToStreamAsync(type, null, memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("null"), "Using Json formatter to serialize null should emit 'null'.");
        }

        [Fact]
        public async Task WriteToStreamAsync_RoundTripsJToken()
        {
            string beforeMessage = "Hello World";
            TestJsonMediaTypeFormatter formatter = new TestJsonMediaTypeFormatter();
            JToken before = new JValue(beforeMessage);
            MemoryStream memStream = new MemoryStream();

            await Assert.Task.SucceedsAsync(formatter.WriteToStreamAsync(typeof(JToken), before, memStream, null, null));
            memStream.Position = 0;
            JToken after = JToken.Load(new JsonTextReader(new StreamReader(memStream)));
            string afterMessage = after.ToObject<string>();

            Assert.Equal(beforeMessage, afterMessage);
        }

        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            string formattedContent = "\"" + content + "\"";
            string mediaType = string.Format("application/json; charset={0}", encoding);

            // Act & assert
            return ReadContentUsingCorrectCharacterEncodingHelperAsync(
                formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }

        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            string formattedContent = "\"" + content + "\"";
            string mediaType = string.Format("application/json; charset={0}", encoding);

            // Act & assert
            return WriteContentUsingCorrectCharacterEncodingHelperAsync(
                formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }

#if NET6_0_OR_GREATER
        // Cannot Mock a Stream and let JsonWriter write to it. Writer will use ReadOnlySpan in this case and such
        // parameters are not currently mockable. See moq/moq4#829, moq/moq4#979, and dotnet/runtime#45152.
        // Override here avoids the Mock<Stream> and should confirm this Stream is not closed. Also adds an
        // additional check of the written text.
        [Fact]
        public override async Task WriteToStreamAsync_WhenObjectIsNull_WritesDataButDoesNotCloseStream()
        {
            // Arrange
            JsonMediaTypeFormatter formatter = CreateFormatter();
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(Stream.Null);

            // Act
            await formatter.WriteToStreamAsync(typeof(SampleType), null, stream, content, null);

            // Assert (stream will throw if it has been closed)
            stream.Position = 0;
            using var reader = new StreamReader(stream);
            Assert.Equal("null", reader.ReadToEnd());
        }
#endif

        public class TestJsonMediaTypeFormatter : JsonMediaTypeFormatter
        {
            public TestJsonMediaTypeFormatter()
            {
            }

            public TestJsonMediaTypeFormatter(TestJsonMediaTypeFormatter formatter)
                : base(formatter)
            {
            }

            public bool ThrowAnExceptionOnCreate { get; set; }
            public bool ReturnNullOnCreate { get; set; }
            public JsonSerializer InnerJsonSerializer { get; private set; }
            public DataContractJsonSerializer InnerDataContractSerializer { get; private set; }

            public bool CanReadTypeProxy(Type type)
            {
                return CanReadType(type);
            }

            public bool CanWriteTypeProxy(Type type)
            {
                return CanWriteType(type);
            }

            public override JsonSerializer CreateJsonSerializer()
            {
                InnerJsonSerializer = base.CreateJsonSerializer();

                if (ReturnNullOnCreate)
                {
                    return null;
                }

                if (ThrowAnExceptionOnCreate)
                {
                    throw new Exception("Throwing exception directly, since it needs to get caught by a catch all");
                }

                return InnerJsonSerializer;
            }

            public override DataContractJsonSerializer CreateDataContractSerializer(Type type)
            {
                InnerDataContractSerializer = base.CreateDataContractSerializer(type);

                if (ReturnNullOnCreate)
                {
                    return null;
                }

                if (ThrowAnExceptionOnCreate)
                {
                    throw new Exception("Throwing exception directly, since it needs to get caught by a catch all");
                }

                return InnerDataContractSerializer;
            }
        }

        private bool IsTypeSerializableWithJsonSerializer(Type type, object obj)
        {
            try
            {
                new DataContractJsonSerializer(type);
                if (obj != null && obj.GetType() != type)
                {
                    new DataContractJsonSerializer(obj.GetType());
                }
            }
            catch
            {
                return false;
            }

            return !Assert.Http.IsKnownUnserializable(type, obj, (t) => typeof(INotJsonSerializable).IsAssignableFrom(t));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/JsonNetSerializationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

// Portions copyright (c) 2007 James Newton-King
//
// Permission is hereby granted, free of charge, to any person
// obtaining a copy of this software and associated documentation
// files (the "Software"), to deal in the Software without
// restriction, including without limitation the rights to use,
// copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following
// conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.

using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class JsonNetSerializationTest
    {
        public static TheoryDataSet<object, string> SerializedJson
        {
            get
            {
                return new TheoryDataSet<object, string>()
                {
                    // Primitives
                    { 'f', "\"f\"" },
                    { "abc", "\"abc\"" },
                    { "\"\\", @"""\""\\""" },
                    { 256, "256" },
                    { (ulong)long.MaxValue, long.MaxValue.ToString() },
                    { 45.78m, "45.78" },
                    { .00000457823432, "4.57823432E-06" },
                    { (byte)24, "24" },
                    { false, "false" },
                    { AttributeTargets.Assembly | AttributeTargets.Constructor, "33" },
                    { ConsoleColor.DarkCyan, "3" },
                    { new DateTimeOffset(1999, 5, 27, 4, 34, 45, TimeSpan.Zero), "\"1999-05-27T04:34:45+00:00\"" },
                    { new TimeSpan(5, 30, 0), "\"05:30:00\"" },
                    { new Uri("http://www.bing.com"), @"""http://www.bing.com""" },
                    { new Uri("http://www.bing.com/"), @"""http://www.bing.com/""" },
                    { new Uri("http://www.bing.com/foo"), @"""http://www.bing.com/foo""" },
                    { new Uri("http://www.bing.com/foo/"), @"""http://www.bing.com/foo/""" },
                    { new Guid("4ed1cd44-11d7-4b27-b623-0b8b553c8906"), "\"4ed1cd44-11d7-4b27-b623-0b8b553c8906\"" },

                    // Structs
                    { new Point() { x = 45, Y = -5}, "{\"x\":45,\"Y\":-5}" },

                    // Arrays
                    { new object[] {}, "[]" },
                    { new int[] { 1, 2, 3}, "[1,2,3]" },
                    { new string[] { "a", "b"}, "[\"a\",\"b\"]" },
                    { new Point[] { new Point() { x = 10, Y = 10}, new Point() { x = 20, Y = 20}}, "[{\"x\":10,\"Y\":10},{\"x\":20,\"Y\":20}]" },

                    // Collections
                    { new List<int> { 1, 2, 3}, "[1,2,3]" },
                    { new List<string> { "a", "b"}, "[\"a\",\"b\"]" },
                    { new List<Point> { new Point() { x = 10, Y = 10}, new Point() { x = 20, Y = 20}}, "[{\"x\":10,\"Y\":10},{\"x\":20,\"Y\":20}]" },
                    { new MyList<int> { 1, 2, 3}, "[1,2,3]" },
                    { new MyList<string> { "a", "b"}, "[\"a\",\"b\"]" },
                    { new MyList<Point> { new Point() { x = 10, Y = 10}, new Point() { x = 20, Y = 20}}, "[{\"x\":10,\"Y\":10},{\"x\":20,\"Y\":20}]" },

                    // Dictionaries

                    { new Dictionary<string, string> { { "k1", "v1" }, { "k2", "v2" } }, "{\"k1\":\"v1\",\"k2\":\"v2\"}" },
                    { new Dictionary<int, string> { { 1, "v1" }, { 2, "v2" } }, "{\"1\":\"v1\",\"2\":\"v2\"}" },

                    // Anonymous types
                    { new { Anon1 = 56, Anon2 = "foo"}, "{\"Anon1\":56,\"Anon2\":\"foo\"}" },

                    // Classes
                    { new DataContractType() { s = "foo", i = 49, NotAMember = "Error" }, "{\"s\":\"foo\",\"i\":49}" },
                    { new POCOType() { s = "foo", t = "Error"}, "{\"s\":\"foo\"}" },
#if !Testing_NetStandard1_3 // Only publics are serialized in netstandard1.3
                    { new SerializableType("protected") { publicField = "public", protectedInternalField = "protected internal", internalField = "internal", PublicProperty = "private", nonSerializedField = "Error" }, "{\"publicField\":\"public\",\"internalField\":\"internal\",\"protectedInternalField\":\"protected internal\",\"protectedField\":\"protected\",\"privateField\":\"private\"}" },
#else
                    { new SerializableType("protected") { publicField = "public", protectedInternalField = "protected internal", internalField = "internal", PublicProperty = "private", nonSerializedField = "Error" }, "{\"publicField\":\"public\",\"PublicProperty\":\"private\"}" },
#endif
                    { new { field1 = "x", field2 = (string)null, field3 = "y" }, "{\"field1\":\"x\",\"field2\":null,\"field3\":\"y\"}" },

                    // Generics
                    { new KeyValuePair<string, bool>("foo", false), "{\"Key\":\"foo\",\"Value\":false}" },

                    // ISerializable types
                    { new ISerializableType() { Property = "Value" }, "{\"SomeProperty\":\"Value\"}" },

                    // JSON Values
                    { new JValue(false), "false" },
                    { new JValue(54), "54" },
                    { new JValue("s"), "\"s\"" },
                    { new JArray() { new JValue(1), new JValue(2) }, "[1,2]" },
                    { new JObject() { { "k1", new JValue("v1") }, { "k2", new JValue("v2") } }, "{\"k1\":\"v1\",\"k2\":\"v2\"}" },
                    { new KeyValuePair<JToken, JToken>(new JValue("k"), new JArray() { new JValue("v1"), new JValue("v2") }), "{\"Key\":\"k\",\"Value\":[\"v1\",\"v2\"]}" },
                };
            }
        }

        public static TheoryDataSet<object, string, Type> TypedSerializedJson
        {
            get
            {
                return new TheoryDataSet<object, string, Type>()
                {
                    // Null
                    { null, "null", typeof(POCOType) },
                    { JValue.CreateNull(), "null", typeof(JToken) },

                    // Nullables
                    { new int?(), "null", typeof(int?) },
                    { new Point?(), "null", typeof(Point?) },
                    { new ConsoleColor?(), "null", typeof(ConsoleColor?) },
                    { new int?(45), "45", typeof(int?) },
                    { new Point?(new Point() { x = 45, Y = -5 }), "{\"x\":45,\"Y\":-5}", typeof(Point?) },
                    { new ConsoleColor?(ConsoleColor.DarkMagenta), "5", typeof(ConsoleColor?)},
                };
            }
        }

        [Theory]
        [PropertyData("SerializedJson")]
        public Task ObjectsSerializeToExpectedJson(object o, string expectedJson)
        {
            return ObjectsSerializeToExpectedJsonWithProvidedType(o, expectedJson, o.GetType());
        }

        [Theory]
        [PropertyData("SerializedJson")]
        public Task JsonDeserializesToExpectedObject(object expectedObject, string json)
        {
            return JsonDeserializesToExpectedObjectWithProvidedType(expectedObject, json, expectedObject.GetType());
        }

        [Theory]
        [PropertyData("TypedSerializedJson")]
        public async Task ObjectsSerializeToExpectedJsonWithProvidedType(object o, string expectedJson, Type type)
        {
            Assert.Equal(expectedJson, await SerializeAsync(o, type));
        }

        [Theory]
        [PropertyData("TypedSerializedJson")]
        public async Task JsonDeserializesToExpectedObjectWithProvidedType(object expectedObject, string json, Type type)
        {
            if (expectedObject == null)
            {
                Assert.Null(await DeserializeAsync(json, type));
            }
            else
            {
                object o = await DeserializeAsync(json, type);
                Assert.Equal(expectedObject, o, new ObjectComparer());
            }
        }

        [Fact]
        public async Task CallbacksGetCalled()
        {
            TypeWithCallbacks o = new TypeWithCallbacks();

            string json = await SerializeAsync(o, typeof(TypeWithCallbacks));
            Assert.Equal("12", o.callbackOrder);

            TypeWithCallbacks deserializedObject = (await DeserializeAsync(json, typeof(TypeWithCallbacks))) as TypeWithCallbacks;
            Assert.Equal("34", deserializedObject.callbackOrder);
        }

        [Fact]
        public async Task DerivedTypesArePreserved()
        {
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            formatter.SerializerSettings.TypeNameHandling = TypeNameHandling.Objects;
            string json = await SerializeAsync(new Derived(), typeof(Base), formatter);
            object deserializedObject = await DeserializeAsync(json, typeof(Base), formatter);
            Assert.IsType<Derived>(deserializedObject);
        }

        [Fact]
        public async Task ArbitraryTypesArentDeserializedByDefault()
        {
            string json = "{\"$type\":\"" + typeof(DangerousType).AssemblyQualifiedName + "\"}";
            object deserializedObject = await DeserializeAsync(json, typeof(object));
            Assert.IsNotType<DangerousType>(deserializedObject);
        }

        [Fact]
        public async Task ReferencesArePreserved()
        {
            Ref ref1 = new Ref();
            Ref ref2 = new Ref();
            ref1.Reference = ref2;
            ref2.Reference = ref1;

            string json = await SerializeAsync(ref1, typeof(Ref));
            Ref deserializedObject = (await DeserializeAsync(json, typeof(Ref))) as Ref;

            Assert.ReferenceEquals(deserializedObject, deserializedObject.Reference.Reference);
        }

        [Fact]
        public async Task MissingMemberGetsDeserializedToNull()
        {
            string json = "{}";

            POCOType deserializedObject = (await DeserializeAsync(json, typeof(POCOType))) as POCOType;

            Assert.Null(deserializedObject.s);
        }

        [Fact]
        public Task DeserializingDeepArraysThrows()
        {
            StringBuilder sb = new StringBuilder();
            int depth = 500;
            for (int i = 0; i < depth; i++)
            {
                sb.Append("[");
            }
            sb.Append("null");
            for (int i = 0; i < depth; i++)
            {
                sb.Append("]");
            }
            string json = sb.ToString();

            return Assert.ThrowsAsync<JsonReaderException>(() => DeserializeAsync(json, typeof(object)));
        }

        [Theory]
        // existing good surrogate pair
        [InlineData("ABC \\ud800\\udc00 DEF", "ABC \ud800\udc00 DEF")]
        // invalid surrogates (two high back-to-back)
        [InlineData("ABC \\ud800\\ud800 DEF", "ABC \ufffd\ufffd DEF")]
        // invalid high surrogate at end of string
        [InlineData("ABC \\ud800", "ABC \ufffd")]
        // high surrogate not followed by low surrogate
        [InlineData("ABC \\ud800 DEF", "ABC \ufffd DEF")]
        // low surrogate not preceded by high surrogate
        [InlineData("ABC \\udc00\\ud800 DEF", "ABC \ufffd\ufffd DEF")]
        // make sure unencoded invalid surrogate characters don't make it through
#if NETCOREAPP // Json.NET uses its regular invalid Unicode character on .NET Core 2.1; '?' elsewhere.
        [InlineData("\udc00\ud800\ud800", "\ufffd\ufffd\ufffd\ufffd\ufffd\ufffd")]
#else
        [InlineData("\udc00\ud800\ud800", "??????")]
#endif
        public async Task InvalidUnicodeStringsAreFixedUp(string input, string expectedString)
        {
            string json = "\"" + input + "\"";
            string deserializedString = (await DeserializeAsync(json, typeof(string))) as string;

            Assert.Equal(expectedString, deserializedString);

        }

        private static async Task<string> SerializeAsync(object o, Type type, MediaTypeFormatter formatter = null)
        {
            formatter = formatter ?? new JsonMediaTypeFormatter();
            MemoryStream ms = new MemoryStream();
            await formatter.WriteToStreamAsync(type, o, ms, null, null);
            ms.Flush();
            ms.Position = 0;
            return new StreamReader(ms).ReadToEnd();
        }

        internal static Task<object> DeserializeAsync(string json, Type type, MediaTypeFormatter formatter = null, IFormatterLogger formatterLogger = null)
        {
            formatter = formatter ?? new JsonMediaTypeFormatter();
            MemoryStream ms = new MemoryStream();
            byte[] bytes = Encoding.Default.GetBytes(json);
            ms.Write(bytes, 0, bytes.Length);
            ms.Flush();
            ms.Position = 0;

            return formatter.ReadFromStreamAsync(type, ms, content: null, formatterLogger: formatterLogger);
        }
    }

    public class ObjectComparer : IEqualityComparer<object>
    {
        bool IEqualityComparer<object>.Equals(object x, object y)
        {
            Type xType = x.GetType();

            if (xType == y.GetType())
            {
                if (typeof(JToken).IsAssignableFrom(xType) || xType == typeof(ArgumentNullException) || xType == typeof(KeyValuePair<JToken, JToken>))
                {
                    return x.ToString() == y.ToString();
                }
                if (xType == typeof(DataContractType))
                {
                    return Equals<DataContractType>(x, y);
                }
                if (xType == typeof(POCOType))
                {
                    return Equals<POCOType>(x, y);
                }

                if (xType == typeof(SerializableType))
                {
                    return Equals<SerializableType>(x, y);
                }

                if (xType == typeof(ISerializableType))
                {
                    return Equals<ISerializableType>(x, y);
                }

                if (xType == typeof(Point))
                {
                    return Equals<Point>(x, y);
                }

                if (typeof(IEnumerable).IsAssignableFrom(xType))
                {
                    IEnumerator xEnumerator = ((IEnumerable)x).GetEnumerator();
                    IEnumerator yEnumerator = ((IEnumerable)y).GetEnumerator();
                    while (xEnumerator.MoveNext())
                    {
                        // if x is longer than y
                        if (!yEnumerator.MoveNext())
                        {
                            return false;
                        }
                        else
                        {
                            if (!xEnumerator.Current.Equals(yEnumerator.Current))
                            {
                                return false;
                            }
                        }
                    }
                    // if y is longer than x
                    if (yEnumerator.MoveNext())
                    {
                        return false;
                    }
                    return true;
                }
            }

            return x.Equals(y);
        }

        int IEqualityComparer<object>.GetHashCode(object obj)
        {
            throw new NotImplementedException();
        }

        bool Equals<T>(object x, object y) where T : IEquatable<T>
        {
            IEquatable<T> yEquatable = (IEquatable<T>)y;
            return yEquatable.Equals((T)x);
        }
    }

    // Marked as [Serializable] to check that [DataContract] takes precedence over [Serializable]
    [DataContract]
    [Serializable]
    public class DataContractType : IEquatable<DataContractType>
    {
        [DataMember]
        public string s;

        [DataMember]
        internal int i;

        public string NotAMember;

        public bool Equals(DataContractType other)
        {
            return this.s == other.s && this.i == other.i;
        }
    }

    public class POCOType : IEquatable<POCOType>
    {
        public string s;
        internal string t;

        public bool Equals(POCOType other)
        {
            return this.s == other.s;
        }
    }

    public class MyList<T> : ICollection<T>
    {
        List<T> innerList = new List<T>();

        public IEnumerator<T> GetEnumerator()
        {
            return innerList.GetEnumerator();
        }

        public void Add(T item)
        {
            innerList.Add(item);
        }

        public void Clear()
        {
            innerList.Clear();
        }

        public bool Contains(T item)
        {
            return innerList.Contains(item);
        }

        public void CopyTo(T[] array, int arrayIndex)
        {
            innerList.CopyTo(array, arrayIndex);
        }

        public int Count
        {
            get { return innerList.Count; }
        }

        public bool IsReadOnly
        {
            get { return ((ICollection<T>)innerList).IsReadOnly; }
        }

        public bool Remove(T item)
        {
            return innerList.Remove(item);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return innerList.GetEnumerator();
        }

        IEnumerator<T> IEnumerable<T>.GetEnumerator()
        {
            return innerList.GetEnumerator();
        }
    }

    [Serializable]
    class SerializableType : IEquatable<SerializableType>
    {
        [JsonConstructor]
        public SerializableType(string protectedFieldValue)
        {
            this.protectedField = protectedFieldValue;
        }

        public string publicField;
        internal string internalField;
        protected internal string protectedInternalField;
        protected string protectedField;
        private string privateField;

        public string PublicProperty
        {
            get
            {
                return privateField;
            }
            set
            {
                this.privateField = value;
            }
        }

        [NonSerialized]
        public string nonSerializedField;

        public bool Equals(SerializableType other)
        {
#if !Testing_NetStandard1_3 // Only publics are serialized in netstandard1.3. privateField is serialized through PublicProperty
            return this.publicField == other.publicField &&
                this.internalField == other.internalField &&
                this.protectedInternalField == other.protectedInternalField &&
                this.protectedField == other.protectedField &&
                this.privateField == other.privateField;
#else
            // this.privateField is serialized through this.PublicProperty, thus the comparison here
            return this.publicField == other.publicField &&
                this.privateField == other.privateField;
#endif
        }
    }

    public struct Point : IEquatable<Point>
    {
        public int x;
        public int Y { get; set; }

        public bool Equals(Point other)
        {
            return this.x == other.x && this.Y == other.Y;
        }
    }

    [DataContract(IsReference = true)]
    public class Ref
    {
        [DataMember]
        public Ref Reference;
    }

    public class Base
    {
    }

    public class Derived : Base
    {
    }

    [DataContract]
    public class TypeWithCallbacks
    {
        public string callbackOrder = "";

        [OnSerializing]
        public void OnSerializing(StreamingContext c)
        {
            callbackOrder += "1";
        }

        [OnSerialized]
        public void OnSerialized(StreamingContext c)
        {
            callbackOrder += "2";
        }

        [OnDeserializing]
        public void OnDeserializing(StreamingContext c)
        {
            callbackOrder += "3";
        }

        [OnDeserialized]
        public void OnDeserialized(StreamingContext c)
        {
            callbackOrder += "4";
        }
    }

    public class DangerousType
    {
    }

    [Serializable]
    public class ISerializableType : ISerializable, IEquatable<ISerializableType>
    {
        public ISerializableType()
        {
        }

        protected ISerializableType(SerializationInfo info, StreamingContext context)
        {
            // The key here for GetValue/SetValue is intentionally different from the property name.
            // This tests that the serializer is using the result of GetObjectData, rather than the property
            // name.
            Property = (string)info.GetValue("SomeProperty", typeof(String));
        }

        public string Property
        {
            get;
            set;
        }

        public void GetObjectData(SerializationInfo info, StreamingContext context)
        {
            info.AddValue("SomeProperty", this.Property, typeof(String));
        }

        public bool Equals(ISerializableType other)
        {
            return String.Equals(Property, other.Property, StringComparison.Ordinal);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/JsonNetValidationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Formatting
{
    public class JsonNetValidationTest
    {
        public static TheoryDataSet<string, Type, int> Theories
        {
            get
            {
                return new TheoryDataSet<string, Type, int>()
                {
                    // Type coercion

                    {"null", typeof(int), 1},
                    {"45", typeof(string), 0},
                    {"random text", typeof(DateTimeOffset), 1},
                    {"[1,2,3]", typeof(string[]), 0},

                    {"\"foo\"", typeof(int), 1},
                    {"\"foo\"", typeof(DateTime), 1},

                    {"[\"a\",\"b\",\"45\",34]", typeof(int[]), 2},
                    {"[\"a\",\"b\",\"45\",34]", typeof(DateTime[]), 5},

                    // Required members

                    {"{}", typeof(DataContractWithRequiredMembers), 2},
                    {"[{},{},{}]", typeof(DataContractWithRequiredMembers[]), 6},

                    // Throwing setters

                    {"{\"Throws\":\"foo\"}", typeof(TypeWithThrowingSetter), 1},
                    {"[{\"Throws\":\"foo\"},{\"Throws\":\"foo\"}]", typeof(TypeWithThrowingSetter[]), 2},
                };
            }
        }

        [Theory]
        [PropertyData("Theories")]
        public async Task ModelErrorsPopulatedWithValidationErrors(string json, Type type, int expectedErrors)
        {
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            formatter.RequiredMemberSelector = new SimpleRequiredMemberSelector();
            Mock<IFormatterLogger> mockLogger = new Mock<IFormatterLogger>() { };

            await JsonNetSerializationTest.DeserializeAsync(json, type, formatter, mockLogger.Object);

            mockLogger.Verify(mock => mock.LogError(It.IsAny<string>(), It.IsAny<Exception>()), Times.Exactly(expectedErrors));
        }

        [Fact]
        public async Task HittingMaxDepthRaisesOnlyOneValidationError()
        {
            // Arrange
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            Mock<IFormatterLogger> mockLogger = new Mock<IFormatterLogger>();

            StringBuilder sb = new StringBuilder("{'A':null}");
            for (int i = 0; i < 5000; i++)
            {
                sb.Insert(0, "{'A':");
                sb.Append('}');
            }
            string json = sb.ToString();

            // Act
            await JsonNetSerializationTest.DeserializeAsync(json, typeof(Nest), formatter, mockLogger.Object);

            // Assert
            mockLogger.Verify(mock => mock.LogError(It.IsAny<string>(), It.IsAny<Exception>()), Times.Once());
        }
    }

    // this IRMS treats all member names that start with "Required" as required
    public class SimpleRequiredMemberSelector : IRequiredMemberSelector
    {
        public bool IsRequiredMember(MemberInfo member)
        {
            return member.Name.StartsWith("Required");
        }
    }

    public class DataContractWithRequiredMembers
    {
        public string Required1;
        public string Required2;
        public string Optional;
    }

    public class TypeWithThrowingSetter
    {
        public string Throws
        {
            get
            {
                return "foo";
            }
            set
            {
                throw new NotImplementedException();
            }
        }
    }

    public class Nest
    {
        public Nest A { get; set; }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeConstantsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class MediaTypeConstantsTests
    {
        private static void ValidateClones(MediaTypeHeaderValue clone1, MediaTypeHeaderValue clone2, string charset)
        {
            Assert.NotNull(clone1);
            Assert.NotNull(clone2);
            Assert.NotSame(clone1, clone2);
            Assert.Equal(clone1.MediaType, clone2.MediaType);
            Assert.Equal(charset, clone1.CharSet);
            Assert.Equal(charset, clone2.CharSet);
        }

        [Fact]
        public void ApplicationOctetStreamMediaType_ReturnsClone()
        {
            ValidateClones(MediaTypeConstants.ApplicationOctetStreamMediaType, MediaTypeConstants.ApplicationOctetStreamMediaType, null);
        }

        [Fact]
        public void ApplicationXmlMediaType_ReturnsClone()
        {
            ValidateClones(MediaTypeConstants.ApplicationXmlMediaType, MediaTypeConstants.ApplicationXmlMediaType, null);
        }

        [Fact]
        public void ApplicationJsonMediaType_ReturnsClone()
        {
            ValidateClones(MediaTypeConstants.ApplicationJsonMediaType, MediaTypeConstants.ApplicationJsonMediaType, null);
        }

        [Fact]
        public void TextXmlMediaType_ReturnsClone()
        {
            ValidateClones(MediaTypeConstants.TextXmlMediaType, MediaTypeConstants.TextXmlMediaType, null);
        }

        [Fact]
        public void TextJsonMediaType_ReturnsClone()
        {
            ValidateClones(MediaTypeConstants.TextJsonMediaType, MediaTypeConstants.TextJsonMediaType, null);
        }

        [Fact]
        public void ApplicationFormUrlEncodedMediaType_ReturnsClone()
        {
            ValidateClones(MediaTypeConstants.ApplicationFormUrlEncodedMediaType, MediaTypeConstants.ApplicationFormUrlEncodedMediaType, null);
        }


    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeFormatterCollectionTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Formatting.Mocks;
using System.Net.Http.Headers;
using System.Web.Http;
using System.Xml;
using System.Xml.Linq;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http.Formatting
{
    public class MediaTypeFormatterCollectionTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(MediaTypeFormatterCollection), TypeAssert.TypeProperties.IsPublicVisibleClass, typeof(Collection<MediaTypeFormatter>));
        }

        [Fact]
        public void Constructor()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();

            Assert.Equal(3, collection.Count);
            Assert.NotNull(collection.XmlFormatter);
            Assert.NotNull(collection.JsonFormatter);
            Assert.NotNull(collection.FormUrlEncodedFormatter);
        }

        [Fact]
        public void Constructor1_AcceptsEmptyList()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[0]);
            Assert.Empty(collection);
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "AllFormatterCollections")]
        public void Constructor1_SetsProperties(IEnumerable<MediaTypeFormatter> formatterCollection)
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatterCollection);
            if (collection.OfType<XmlMediaTypeFormatter>().Any())
            {
                Assert.NotNull(collection.XmlFormatter);
            }
            else
            {
                Assert.Null(collection.XmlFormatter);
            }

            if (collection.OfType<JsonMediaTypeFormatter>().Any())
            {
                Assert.NotNull(collection.JsonFormatter);
            }
            else
            {
                Assert.Null(collection.JsonFormatter);
            }
        }

        [Fact]
        public void Constructor1_SetsDerivedFormatters()
        {
            // force to array to get stable instances
            MediaTypeFormatter[] derivedFormatters = HttpTestData.DerivedFormatters.ToArray();
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(derivedFormatters);
            Assert.True(derivedFormatters.SequenceEqual(collection));
        }

        [Fact]
        public void Constructor1_ThrowsWithNullFormatters()
        {
            Assert.ThrowsArgumentNull(() => new MediaTypeFormatterCollection(null), "formatters");
        }

        [Fact]
        public void Constructor1_ThrowsWithNullFormatterInCollection()
        {
            Assert.ThrowsArgument(
                () => new MediaTypeFormatterCollection(new MediaTypeFormatter[] { null }), "formatters",
                Error.Format(Properties.Resources.CannotHaveNullInList,
                typeof(MediaTypeFormatter).Name));
        }

        [Fact]
        public void Constructor1_AcceptsDuplicateFormatterTypes()
        {
            MediaTypeFormatter[] formatters = new MediaTypeFormatter[]
            {
                new XmlMediaTypeFormatter(),
                new JsonMediaTypeFormatter(),
                new FormUrlEncodedMediaTypeFormatter(),

                new XmlMediaTypeFormatter(),
                new JsonMediaTypeFormatter(),
                new FormUrlEncodedMediaTypeFormatter(),
            };

            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);
            Assert.True(formatters.SequenceEqual(collection));
        }

        [Fact]
        public void MediaTypeFormatterCollection_Changing_FiresOnClear()
        {
            TestChanging((collection) => collection.Clear(), 1);
        }

        [Fact]
        public void MediaTypeFormatterCollection_Changing_FiresOnInsert()
        {
            TestChanging((collection) => collection.Insert(0, new XmlMediaTypeFormatter()), 1);
        }

        [Fact]
        public void MediaTypeFormatterCollection_Changing_FiresOnRemove()
        {
            TestChanging((collection) => collection.RemoveAt(0), 1);
        }

        [Fact]
        public void MediaTypeFormatterCollection_Changing_FiresOnSet()
        {
            TestChanging((collection) => collection[0] = new XmlMediaTypeFormatter(), 1);
        }

        private static void TestChanging(Action<MediaTypeFormatterCollection> mutation, int expectedCount)
        {
            // Arrange
            MediaTypeFormatter formatter1 = new XmlMediaTypeFormatter();
            MediaTypeFormatter formatter2 = new JsonMediaTypeFormatter();
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[] { formatter1, formatter2 });
            int changeCount = 0;
            collection.Changing += (source, args) => { changeCount++; };

            // Act
            mutation(collection);

            //Assert
            Assert.Equal(expectedCount, changeCount);
        }

        [Fact]
        public void XmlFormatter_SetByCtor()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[] { formatter });
            Assert.Same(formatter, collection.XmlFormatter);
        }

        [Fact]
        public void XmlFormatter_ClearedByCtor()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[0]);
            Assert.Null(collection.XmlFormatter);
        }

        [Fact]
        public void JsonFormatter_SetByCtor()
        {
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[] { formatter });
            Assert.Same(formatter, collection.JsonFormatter);
        }

        [Fact]
        public void JsonFormatter_ClearedByCtor()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[0]);
            Assert.Null(collection.JsonFormatter);
        }

        [Fact]
        public void FormUrlEncodedFormatter_SetByCtor()
        {
            FormUrlEncodedMediaTypeFormatter formatter = new FormUrlEncodedMediaTypeFormatter();
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[] { formatter });
            Assert.Same(formatter, collection.FormUrlEncodedFormatter);
        }

        [Fact]
        public void FormUrlEncodedFormatter_ClearedByCtor()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(new MediaTypeFormatter[0]);
            Assert.Null(collection.FormUrlEncodedFormatter);
        }

        [Fact]
        public void Remove_SetsXmlFormatter()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            int count = collection.Count;
            collection.Remove(collection.XmlFormatter);
            Assert.Null(collection.XmlFormatter);
            Assert.Equal(count - 1, collection.Count);
        }

        [Fact]
        public void Remove_SetsJsonFormatter()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            int count = collection.Count;
            collection.Remove(collection.JsonFormatter);
            Assert.Null(collection.JsonFormatter);
            Assert.Equal(count - 1, collection.Count);
        }

        [Fact]
        public void Insert_SetsXmlFormatter()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            int count = collection.Count;
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            collection.Insert(0, formatter);
            Assert.Same(formatter, collection.XmlFormatter);
            Assert.Equal(count + 1, collection.Count);
        }

        [Fact]
        public void Insert_SetsJsonFormatter()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            int count = collection.Count;
            JsonMediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            collection.Insert(0, formatter);
            Assert.Same(formatter, collection.JsonFormatter);
            Assert.Equal(count + 1, collection.Count);
        }

        [Fact]
        public void FindReader_ThrowsOnNullType()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/test");
            Assert.ThrowsArgumentNull(() => collection.FindReader(type: null, mediaType: mediaType), "type");
        }

        [Fact]
        public void FindReader_ThrowsOnNullMediaType()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            Assert.ThrowsArgumentNull(() => collection.FindReader(type: typeof(object), mediaType: null), "mediaType");
        }

        [Fact]
        public void FindReader_ReturnsNullOnNoMatch()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };

            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            collection.Clear();
            collection.Add(formatter);

            MediaTypeHeaderValue contentType = new MediaTypeHeaderValue("text/test");

            // Act
            MediaTypeFormatter actualFormatter = collection.FindReader(typeof(object), contentType);

            // Assert
            Assert.Null(actualFormatter);
        }

        [Theory]
        [TestDataSet(
            typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void FindReader_ReturnsFormatterOnMatch(Type variationType, object testData, string mediaType)
        {
            // Arrange
            GC.KeepAlive(testData); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };
            foreach (string legalMediaType in HttpTestData.LegalMediaTypeStrings)
            {
                formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue(legalMediaType));
            }

            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            collection.Clear();
            collection.Add(formatter);

            MediaTypeHeaderValue contentType = new MediaTypeHeaderValue(mediaType);

            // Act
            MediaTypeFormatter actualFormatter = collection.FindReader(variationType, contentType);

            // Assert
            Assert.Same(formatter, actualFormatter);
        }

        [Fact]
        public void FindWriter_ThrowsOnNullType()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/test");
            Assert.ThrowsArgumentNull(() => collection.FindWriter(type: null, mediaType: mediaType), "type");
        }

        [Fact]
        public void FindWriter_ThrowsOnNullMediaType()
        {
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            Assert.ThrowsArgumentNull(() => collection.FindWriter(type: typeof(object), mediaType: null), "mediaType");
        }

        [Fact]
        public void FindWriter_ReturnsNullOnNoMatch()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };

            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            collection.Clear();
            collection.Add(formatter);

            MediaTypeHeaderValue contentType = new MediaTypeHeaderValue("text/test");

            // Act
            MediaTypeFormatter actualFormatter = collection.FindWriter(typeof(object), contentType);

            // Assert
            Assert.Null(actualFormatter);
        }

        [Theory]
        [TestDataSet(
            typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void FindWriter_ReturnsFormatterOnMatch(Type variationType, object testData, string mediaType)
        {
            // Arrange
            GC.KeepAlive(testData); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter() { CallBase = true };
            foreach (string legalMediaType in HttpTestData.LegalMediaTypeStrings)
            {
                formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue(mediaType));
            }

            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection();
            collection.Clear();
            collection.Add(formatter);

            MediaTypeHeaderValue contentType = new MediaTypeHeaderValue(mediaType);

            // Act
            MediaTypeFormatter actualFormatter = collection.FindWriter(variationType, contentType);

            // Assert
            Assert.Same(formatter, actualFormatter);
        }

        [Theory]
        [InlineData(typeof(JObject))]
        [InlineData(typeof(XAttribute))]
        [InlineData(typeof(Type))]
        [InlineData(typeof(byte[]))]
        [InlineData(typeof(XmlElement))]
        [InlineData(typeof(FormDataCollection))]
        public void IsTypeExcludedFromValidation_ReturnsTrueForExcludedTypes(Type type)
        {
            Assert.True(MediaTypeFormatterCollection.IsTypeExcludedFromValidation(type));
        }

        [Fact]
        public void WritingFormatters_FiltersOutCanWriteAnyTypesFalse()
        {
            // Arrange
            MockMediaTypeFormatter writableFormatter = new MockMediaTypeFormatter();
            MockMediaTypeFormatter readOnlyFormatter = new MockMediaTypeFormatter() { CanWriteAnyTypesReturn = false };
            List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { writableFormatter, readOnlyFormatter };
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);

            // Act
            MediaTypeFormatter[] writableFormatters = collection.WritingFormatters;

            // Assert
            MediaTypeFormatter[] expectedFormatters = new MediaTypeFormatter[] { writableFormatter };
            Assert.Equal(expectedFormatters, writableFormatters);
        }

        [Fact]
        public void WritingFormatters_FiltersOutNull()
        {
            // Arrange
            MockMediaTypeFormatter writableFormatter = new MockMediaTypeFormatter();
            List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { writableFormatter };
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);
            collection.Add(null);

            // Act
            MediaTypeFormatter[] writableFormatters = collection.WritingFormatters;

            // Assert
            MediaTypeFormatter[] expectedFormatters = new MediaTypeFormatter[] { writableFormatter };
            Assert.Equal(expectedFormatters, writableFormatters);
        }

        [Fact]
        public void WritingFormatters_Caches()
        {
            // Arrange
            MockMediaTypeFormatter formatter1 = new MockMediaTypeFormatter();
            MockMediaTypeFormatter formatter2 = new MockMediaTypeFormatter();
            List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { formatter1, formatter2 };
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);

            // Act
            MediaTypeFormatter[] writableFormatters1 = collection.WritingFormatters;
            MediaTypeFormatter[] writableFormatters2 = collection.WritingFormatters;

            // Assert
            MediaTypeFormatter[] expectedFormatters = formatters.ToArray();
            Assert.Equal(expectedFormatters, writableFormatters1);
            Assert.Same(writableFormatters1, writableFormatters2);
        }

        [Fact]
        public void WritingFormatters_Insert_ResetsCache()
        {
            TestWritingFormattersCacheReset((collection) => collection.Insert(0, new MockMediaTypeFormatter()));
        }

        [Fact]
        public void WritingFormatters_RemoveAt_ResetsCache()
        {
            TestWritingFormattersCacheReset((collection) => collection.RemoveAt(0));
        }

        private static void TestWritingFormattersCacheReset(Action<MediaTypeFormatterCollection> mutation)
        {
            // Arrange
            MockMediaTypeFormatter formatter1 = new MockMediaTypeFormatter();
            MockMediaTypeFormatter formatter2 = new MockMediaTypeFormatter();
            List<MediaTypeFormatter> formatters = new List<MediaTypeFormatter>() { formatter1, formatter2 };
            MediaTypeFormatterCollection collection = new MediaTypeFormatterCollection(formatters);

            // Act
            mutation(collection);
            MediaTypeFormatter[] expectedFormatters = collection.ToArray();
            MediaTypeFormatter[] writableFormatters = collection.WritingFormatters;

            // Assert
            Assert.Equal(expectedFormatters, writableFormatters);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeFormatterExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting.Mocks;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class MediaTypeFormatterExtensionsTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(MediaTypeFormatterExtensions), TypeAssert.TypeProperties.IsPublicVisibleClass | TypeAssert.TypeProperties.IsStatic);
        }

        [Fact]
        public void AddQueryStringMappingThrowsWithNullThis()
        {
            MediaTypeFormatter formatter = null;
            Assert.ThrowsArgumentNull(() => formatter.AddQueryStringMapping("name", "value", new MediaTypeHeaderValue("application/xml")), "formatter");
        }

        [Fact]
        public void AddQueryStringMapping1ThrowsWithNullThis()
        {
            MediaTypeFormatter formatter = null;
            Assert.ThrowsArgumentNull(() => formatter.AddQueryStringMapping("name", "value", "application/xml"), "formatter");
        }

        [Fact]
        public void AddRequestHeaderMappingThrowsWithNullThis()
        {
            MediaTypeFormatter formatter = null;
            Assert.ThrowsArgumentNull(() => formatter.AddRequestHeaderMapping("name", "value", StringComparison.CurrentCulture, true, new MediaTypeHeaderValue("application/xml")), "formatter");
        }

        [Fact]
        public void AddRequestHeaderMappingAddsSuccessfully()
        {
            MediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Assert.Empty(formatter.MediaTypeMappings);
            formatter.AddRequestHeaderMapping("name", "value", StringComparison.CurrentCulture, true, new MediaTypeHeaderValue("application/xml"));
            IEnumerable<RequestHeaderMapping> mappings = formatter.MediaTypeMappings.OfType<RequestHeaderMapping>();
            RequestHeaderMapping mapping = Assert.Single(mappings);
            Assert.Equal("name", mapping.HeaderName);
            Assert.Equal("value", mapping.HeaderValue);
            Assert.Equal(StringComparison.CurrentCulture, mapping.HeaderValueComparison);
            Assert.True(mapping.IsValueSubstring);
            Assert.Equal(new MediaTypeHeaderValue("application/xml"), mapping.MediaType);
        }

        [Fact]
        public void AddRequestHeaderMapping1ThrowsWithNullThis()
        {
            MediaTypeFormatter formatter = null;
            Assert.ThrowsArgumentNull(() => formatter.AddRequestHeaderMapping("name", "value", StringComparison.CurrentCulture, true, "application/xml"), "formatter");
        }

        [Fact]
        public void AddRequestHeaderMapping1AddsSuccessfully()
        {
            MediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Assert.Empty(formatter.MediaTypeMappings);
            formatter.AddRequestHeaderMapping("name", "value", StringComparison.CurrentCulture, true, "application/xml");
            IEnumerable<RequestHeaderMapping> mappings = formatter.MediaTypeMappings.OfType<RequestHeaderMapping>();
            RequestHeaderMapping mapping = Assert.Single(mappings);
            Assert.Equal("name", mapping.HeaderName);
            Assert.Equal("value", mapping.HeaderValue);
            Assert.Equal(StringComparison.CurrentCulture, mapping.HeaderValueComparison);
            Assert.True(mapping.IsValueSubstring);
            Assert.Equal(new MediaTypeHeaderValue("application/xml"), mapping.MediaType);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeFormatterMatchTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting.Mocks;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class MediaTypeFormatterMatchTest
    {
        [Fact]
        public void Ctor_ThrowsOnNullFormatter()
        {
            Assert.ThrowsArgumentNull(() => new MediaTypeFormatterMatch(null, null, null, MediaTypeFormatterMatchRanking.None), "formatter");
        }

        [Fact]
        public void Ctor_ClonesMediaType()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            MediaTypeHeaderValue mediaType = MediaTypeHeaderValue.Parse("text/test");

            // Act
            MediaTypeFormatterMatch match = new MediaTypeFormatterMatch(formatter, mediaType, null, MediaTypeFormatterMatchRanking.MatchOnCanWriteType);

            // Assert
            Assert.Equal(mediaType, match.MediaType);
            Assert.NotSame(mediaType, match.MediaType);
        }

        [Fact]
        public void Ctor_InitializesDefaultValues()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();

            // Act
            MediaTypeFormatterMatch match = new MediaTypeFormatterMatch(formatter, null, null, MediaTypeFormatterMatchRanking.MatchOnCanWriteType);

            // Assert
            Assert.Same(formatter, match.Formatter);
            Assert.Equal(MediaTypeConstants.ApplicationOctetStreamMediaType, match.MediaType);
            Assert.Equal(FormattingUtilities.Match, match.Quality);
            Assert.Equal(MediaTypeFormatterMatchRanking.MatchOnCanWriteType, match.Ranking);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeFormatterTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Formatting
{
    /// <summary>
    /// A test class for common <see cref="MediaTypeFormatter"/> functionality across multiple implementations.
    /// </summary>
    /// <typeparam name="TFormatter">The type of formatter under test.</typeparam>
    public abstract class MediaTypeFormatterTestBase<TFormatter> where TFormatter : MediaTypeFormatter
    {
        protected MediaTypeFormatterTestBase()
        {
        }

        // Test data variations of interest in round-trip tests.
        public const TestDataVariations RoundTripDataVariations =
            TestDataVariations.All | TestDataVariations.WithNull | TestDataVariations.AsClassMember;

        public abstract IEnumerable<MediaTypeHeaderValue> ExpectedSupportedMediaTypes { get; }

        public abstract IEnumerable<Encoding> ExpectedSupportedEncodings { get; }

        /// <summary>
        /// Byte representation of an <see cref="SampleType"/> with value 42 using the default encoding
        /// for this media type formatter.
        /// </summary>
        public abstract byte[] ExpectedSampleTypeByteRepresentation { get; }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<TFormatter, MediaTypeFormatter>(TypeAssert.TypeProperties.IsPublicVisibleClass);
        }

        [Fact]
        public void SupportedMediaTypes_HeaderValuesAreNotSharedBetweenInstances()
        {
            var formatter1 = CreateFormatter();
            var formatter2 = CreateFormatter();

            foreach (MediaTypeHeaderValue mediaType1 in formatter1.SupportedMediaTypes)
            {
                MediaTypeHeaderValue mediaType2 = formatter2.SupportedMediaTypes.Single(m => m.Equals(mediaType1));
                Assert.NotSame(mediaType1, mediaType2);
            }
        }

        [Fact]
        public void SupportEncodings_ValuesAreNotSharedBetweenInstances()
        {
            var formatter1 = CreateFormatter();
            var formatter2 = CreateFormatter();

            foreach (Encoding mediaType1 in formatter1.SupportedEncodings)
            {
                Encoding mediaType2 = formatter2.SupportedEncodings.Single(m => m.Equals(mediaType1));
                Assert.NotSame(mediaType1, mediaType2);
            }
        }

        [Fact]
        public void SupportMediaTypes_DefaultSupportedMediaTypes()
        {
            TFormatter formatter = CreateFormatter();
            Assert.True(ExpectedSupportedMediaTypes.SequenceEqual(formatter.SupportedMediaTypes));
        }

        [Fact]
        public void SupportEncoding_DefaultSupportedEncodings()
        {
            TFormatter formatter = CreateFormatter();
            Assert.True(ExpectedSupportedEncodings.SequenceEqual(formatter.SupportedEncodings));
        }

        [Fact]
        public void ReadFromStreamAsync_ThrowsOnNull()
        {
            TFormatter formatter = CreateFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.ReadFromStreamAsync(null, Stream.Null, null, null); }, "type");
            Assert.ThrowsArgumentNull(() => { formatter.ReadFromStreamAsync(typeof(object), null, null, null); }, "readStream");
        }

        [Fact]
        public async Task ReadFromStreamAsync_WhenContentLengthIsZero_DoesNotReadStream()
        {
            // Arrange
            TFormatter formatter = CreateFormatter();
            Mock<Stream> mockStream = new Mock<Stream>();
            IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders contentHeaders = content.Headers;
            contentHeaders.ContentLength = 0;

            // Act
            await formatter.ReadFromStreamAsync(typeof(SampleType), mockStream.Object, content, mockFormatterLogger);

            // Assert
            mockStream.Verify(s => s.Read(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()), Times.Never());
            mockStream.Verify(s => s.ReadByte(), Times.Never());
            mockStream.Verify(s => s.BeginRead(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<AsyncCallback>(), It.IsAny<object>()), Times.Never());
        }

        [Fact]
        public async Task ReadFromStreamAsync_WhenContentLengthIsZero_DoesNotCloseStream()
        {
            // Arrange
            TFormatter formatter = CreateFormatter();
            Mock<Stream> mockStream = new Mock<Stream>();
            IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders contentHeaders = content.Headers;
            contentHeaders.ContentLength = 0;

            // Act
            await formatter.ReadFromStreamAsync(typeof(SampleType), mockStream.Object, content, mockFormatterLogger);

            // Assert
            mockStream.Verify(s => s.Close(), Times.Never());
        }

        [Theory]
        [InlineData(false)]
        [InlineData(0)]
        [InlineData("")]
        public async Task ReadFromStreamAsync_WhenContentLengthIsZero_ReturnsDefaultTypeValue<T>(T value)
        {
            // Arrange
            GC.KeepAlive(value); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            TFormatter formatter = CreateFormatter();
            HttpContent content = new StringContent("");

            // Act
            var contentStream = await content.ReadAsStreamAsync();
            var result = await formatter.ReadFromStreamAsync(typeof(T), contentStream, content, null);

            // Assert
            Assert.Equal(default(T), (T)result);
        }

        [Fact]
        public virtual async Task ReadFromStreamAsync_ReadsDataButDoesNotCloseStream()
        {
            // Arrange
            TFormatter formatter = CreateFormatter();
            MemoryStream memStream = new MemoryStream(ExpectedSampleTypeByteRepresentation);
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders contentHeaders = content.Headers;
            contentHeaders.ContentLength = memStream.Length;
            contentHeaders.ContentType = CreateSupportedMediaType();

            // Act
            var result = await formatter.ReadFromStreamAsync(typeof(SampleType), memStream, content, null);

            // Assert
            Assert.True(memStream.CanRead);

            var value = Assert.IsType<SampleType>(result);
            Assert.Equal(42, value.Number);
        }

        [Fact]
        public virtual async Task ReadFromStreamAsync_WhenContentLengthIsNull_ReadsDataButDoesNotCloseStream()
        {
            // Arrange
            TFormatter formatter = CreateFormatter();
            MemoryStream memStream = new MemoryStream(ExpectedSampleTypeByteRepresentation);
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders contentHeaders = content.Headers;
            contentHeaders.ContentLength = null;
            contentHeaders.ContentType = CreateSupportedMediaType();

            // Act
            var result = await formatter.ReadFromStreamAsync(typeof(SampleType), memStream, content, null);

            // Assert
            Assert.True(memStream.CanRead);

            var value = Assert.IsType<SampleType>(result);
            Assert.Equal(42, value.Number);
        }

        [Fact]
        public void WriteToStreamAsync_ThrowsOnNull()
        {
            TFormatter formatter = CreateFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.WriteToStreamAsync(null, new object(), Stream.Null, null, null); }, "type");
            Assert.ThrowsArgumentNull(() => { formatter.WriteToStreamAsync(typeof(object), new object(), null, null, null); }, "writeStream");
        }

        [Fact]
        public virtual async Task WriteToStreamAsync_WhenObjectIsNull_WritesDataButDoesNotCloseStream()
        {
            // Arrange
            TFormatter formatter = CreateFormatter();
            Mock<Stream> mockStream = new Mock<Stream>();
            mockStream.Setup(s => s.CanWrite).Returns(true);
            HttpContent content = new StringContent(String.Empty);

            // Act
            await formatter.WriteToStreamAsync(typeof(SampleType), null, mockStream.Object, content, null);

            // Assert
            mockStream.Verify(s => s.Close(), Times.Never());
            mockStream.Verify(s => s.BeginWrite(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<AsyncCallback>(), It.IsAny<object>()), Times.Never());
        }

        [Fact]
        public virtual async Task WriteToStreamAsync_WritesDataButDoesNotCloseStream()
        {
            // Arrange
            TFormatter formatter = CreateFormatter();
            SampleType sampleType = new SampleType { Number = 42 };
            MemoryStream memStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            content.Headers.ContentType = CreateSupportedMediaType();

            // Act
            await formatter.WriteToStreamAsync(typeof(SampleType), sampleType, memStream, content, null);

            // Assert
            Assert.True(memStream.CanRead);

            byte[] actualSampleTypeByteRepresentation = memStream.ToArray();
            Assert.NotEmpty(actualSampleTypeByteRepresentation);
        }

        [Fact]
        public virtual async Task Overridden_WriteToStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            // Arrange
            Stream stream = new MemoryStream();
            Mock<TFormatter> formatter = CreateMockFormatter();
            ObjectContent<int> content = new ObjectContent<int>(42, formatter.Object);

            formatter
                .Setup(f => f.WriteToStreamAsync(typeof(int), 42, stream, content, null /* transportContext */))
                .Returns(TaskHelpers.Completed())
                .Verifiable();

            // Act
            await content.CopyToAsync(stream);

            // Assert
            formatter.Verify();
        }

        [Fact]
        public virtual async Task Overridden_WriteToStreamAsyncWithCancellationToken_GetsCalled()
        {
            // Arrange
            Stream stream = new MemoryStream();
            Mock<TFormatter> formatter = CreateMockFormatter();
            ObjectContent<int> content = new ObjectContent<int>(42, formatter.Object);

            formatter
                .Setup(f => f.WriteToStreamAsync(typeof(int), 42, stream, content, null /* transportContext */, CancellationToken.None))
                .Returns(TaskHelpers.Completed())
                .Verifiable();

            // Act
            await content.CopyToAsync(stream);

            // Assert
            formatter.Verify();
        }

        [Fact]
        public virtual async Task Overridden_ReadFromStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            // Arrange
            Stream stream = new MemoryStream();
            Mock<TFormatter> formatter = CreateMockFormatter();
            formatter.Object.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/test"));
            StringContent content = new StringContent(" ", Encoding.Default, "application/test");
            CancellationTokenSource cts = new CancellationTokenSource();

            formatter
                .Setup(f => f.ReadFromStreamAsync(typeof(string), It.IsAny<Stream>(), content, null /*formatterLogger */))
                .Returns(Task.FromResult<object>(null))
                .Verifiable();

            // Act
            await content.ReadAsAsync<string>(new[] { formatter.Object }, cts.Token);

            // Assert
            formatter.Verify();
        }

        [Fact]
        public virtual async Task Overridden_ReadFromStreamAsyncWithCancellationToken_GetsCalled()
        {
            // Arrange
            Stream stream = new MemoryStream();
            Mock<TFormatter> formatter = CreateMockFormatter();
            formatter.Object.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse("application/test"));
            StringContent content = new StringContent(" ", Encoding.Default, "application/test");
            CancellationTokenSource cts = new CancellationTokenSource();

            formatter
                .Setup(f => f.ReadFromStreamAsync(typeof(string), It.IsAny<Stream>(), content, null /*formatterLogger */, cts.Token))
                .Returns(Task.FromResult<object>(null))
                .Verifiable();

            // Act
            await content.ReadAsAsync<string>(new[] { formatter.Object }, cts.Token);

            // Assert
            formatter.Verify();
        }

        // Remove this suppression once we pick up an xunit.analyzers package containing the xnuit/xunit#1466 fix.
#pragma warning disable xUnit1013 // Public method should be marked as test
        [Theory]
        [TestDataSet(typeof(HttpTestData), "ReadAndWriteCorrectCharacterEncoding")]
        public abstract Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding);

        [Theory]
        [TestDataSet(typeof(HttpTestData), "ReadAndWriteCorrectCharacterEncoding")]
        public abstract Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding);
#pragma warning restore xUnit1013 // Public method should be marked as test

        protected virtual TFormatter CreateFormatter()
        {
            ConstructorInfo constructor = typeof(TFormatter).GetConstructor(Type.EmptyTypes);
            return (TFormatter)constructor.Invoke(null);
        }

        protected virtual Mock<TFormatter> CreateMockFormatter()
        {
            return new Mock<TFormatter>() { CallBase = true };
        }

        protected virtual MediaTypeHeaderValue CreateSupportedMediaType()
        {
            return ExpectedSupportedMediaTypes.First();
        }

        public async Task<object> ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(MediaTypeFormatter formatter, Type variationType, object testData)
        {
            // Arrange
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders contentHeaders = content.Headers;
            object readObj = null;

            // Act & Assert
            await Assert.Stream.WriteAndReadAsync(
                async stream =>
                {
                    await Assert.Task.SucceedsAsync(formatter.WriteToStreamAsync(variationType, testData, stream, content, transportContext: null));
                    contentHeaders.ContentLength = stream.Length;
                },
                async stream => readObj = await Assert.Task.SucceedsWithResultAsync(formatter.ReadFromStreamAsync(variationType, stream, content, formatterLogger: null)));

            return readObj;
        }

        protected async Task ReadFromStreamAsync_UsesCorrectCharacterEncodingHelper(MediaTypeFormatter formatter, string content, string formattedContent, string mediaType, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            Encoding enc = null;
            if (isDefaultEncoding)
            {
                enc = formatter.SupportedEncodings.First((e) => e.WebName.Equals(encoding, StringComparison.OrdinalIgnoreCase));
            }
            else
            {
                enc = Encoding.GetEncoding(encoding);
                formatter.SupportedEncodings.Add(enc);
            }

            byte[] data = enc.GetBytes(formattedContent);
            MemoryStream memStream = new MemoryStream(data);

            StringContent dummyContent = new StringContent(string.Empty);
            HttpContentHeaders headers = dummyContent.Headers;
            headers.Clear();
            headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            headers.ContentLength = data.Length;

            IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;

            // Act
            string result = (await formatter.ReadFromStreamAsync(typeof(string), memStream, dummyContent, mockFormatterLogger)) as string;

            // Assert
            Assert.Equal(content, result);
        }

        protected async Task WriteToStreamAsync_UsesCorrectCharacterEncodingHelper(MediaTypeFormatter formatter, string content, string formattedContent, string mediaType, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            Encoding enc = null;
            if (isDefaultEncoding)
            {
                enc = formatter.SupportedEncodings.First((e) => e.WebName.Equals(encoding, StringComparison.OrdinalIgnoreCase));
            }
            else
            {
                enc = Encoding.GetEncoding(encoding);
                formatter.SupportedEncodings.Add(enc);
            }

            byte[] preamble = enc.GetPreamble();
            byte[] data = enc.GetBytes(formattedContent);
            byte[] expectedData = new byte[preamble.Length + data.Length];
            Buffer.BlockCopy(preamble, 0, expectedData, 0, preamble.Length);
            Buffer.BlockCopy(data, 0, expectedData, preamble.Length, data.Length);

            MemoryStream memStream = new MemoryStream();

            HttpContent httpContent = new StringContent(String.Empty);
            HttpContentHeaders contentHeaders = httpContent.Headers;
            contentHeaders.Clear();
            contentHeaders.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            contentHeaders.ContentLength = expectedData.Length;

            IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;

            // Act
            await formatter.WriteToStreamAsync(typeof(string), content, memStream, httpContent, null);

            // Assert
            byte[] actualData = memStream.ToArray();
            Assert.Equal(expectedData, actualData);
        }

        public static Encoding CreateOrGetSupportedEncoding(MediaTypeFormatter formatter, string encoding, bool isDefaultEncoding)
        {
            Encoding enc = null;
            if (isDefaultEncoding)
            {
                enc = formatter.SupportedEncodings.First((e) => e.WebName.Equals(encoding, StringComparison.OrdinalIgnoreCase));
            }
            else
            {
                enc = Encoding.GetEncoding(encoding);
                formatter.SupportedEncodings.Add(enc);
            }

            return enc;
        }

        protected static Task ReadContentUsingCorrectCharacterEncodingHelperAsync(MediaTypeFormatter formatter, string content, string formattedContent, string mediaType, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            Encoding enc = CreateOrGetSupportedEncoding(formatter, encoding, isDefaultEncoding);
            byte[] sourceData = enc.GetBytes(formattedContent);

            // Further Arrange, Act & Assert
            return ReadContentUsingCorrectCharacterEncodingHelperAsync(formatter, content, sourceData, mediaType);
        }

        protected static async Task ReadContentUsingCorrectCharacterEncodingHelperAsync(MediaTypeFormatter formatter, string content, byte[] sourceData, string mediaType)
        {
            // Arrange
            MemoryStream memStream = new MemoryStream(sourceData);

            StringContent dummyContent = new StringContent(string.Empty);
            HttpContentHeaders headers = dummyContent.Headers;
            headers.Clear();
            headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            headers.ContentLength = sourceData.Length;

            IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;

            // Act
            var result = (await formatter.ReadFromStreamAsync(typeof(string), memStream, dummyContent, mockFormatterLogger)) as string;

            // Assert
            Assert.Equal(content, result);
        }

        protected static Task WriteContentUsingCorrectCharacterEncodingHelperAsync(MediaTypeFormatter formatter, string content, string formattedContent, string mediaType, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            Encoding enc = CreateOrGetSupportedEncoding(formatter, encoding, isDefaultEncoding);

            byte[] preamble = enc.GetPreamble();
            byte[] data = enc.GetBytes(formattedContent);
            byte[] expectedData = new byte[preamble.Length + data.Length];
            Buffer.BlockCopy(preamble, 0, expectedData, 0, preamble.Length);
            Buffer.BlockCopy(data, 0, expectedData, preamble.Length, data.Length);

            // Further Arrange, Act & Assert
            return WriteContentUsingCorrectCharacterEncodingHelperAsync(formatter, content, expectedData, mediaType);
        }


        protected static async Task WriteContentUsingCorrectCharacterEncodingHelperAsync(MediaTypeFormatter formatter, string content, byte[] expectedData, string mediaType)
        {
            // Arrange
            MemoryStream memStream = new MemoryStream();

            StringContent dummyContent = new StringContent(string.Empty);
            HttpContentHeaders headers = dummyContent.Headers;
            headers.Clear();
            headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            headers.ContentLength = expectedData.Length;

            IFormatterLogger mockFormatterLogger = new Mock<IFormatterLogger>().Object;

            // Act
            await formatter.WriteToStreamAsync(typeof(string), content, memStream, dummyContent, null);

            // Assert
            byte[] actualData = memStream.ToArray();

            Assert.Equal(expectedData, actualData);
        }
    }

    [DataContract(Name = "DataContractSampleType")]
    public class SampleType
    {
        [DataMember]
        public int Number { get; set; }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Formatting.Mocks;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Formatting
{
    [Xunit.Collection("MediaTypeFormatterTests")] // Isolate MaxCollectionKeySize_RoundTrips.
    [Xunit.CollectionDefinition("MediaTypeFormatterTests", DisableParallelization = true)]
    public class MediaTypeFormatterTests
    {
        private const string TestMediaType = "text/test";
        private MediaTypeHeaderValue TestMediaTypeHeader = new MediaTypeHeaderValue(TestMediaType);

        public static TheoryDataSet<string, string[], string> SelectCharacterEncodingTestData
        {
            get
            {
                // string bodyEncoding, string[] supportedEncodings, string expectedEncoding
                return new TheoryDataSet<string, string[], string>
                {
                    { null, new string[] { "utf-8", "utf-16"}, "utf-8" },
                    { null, new string[] { "utf-16", "utf-8"}, "utf-16"},
                    { "utf-32", new string[] { "utf-8", "utf-16"}, "utf-8" },
                    { "utf-32", new string[] { "utf-8", "utf-16", "utf-32"}, "utf-32"}
                };
            }
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(MediaTypeFormatter), TypeAssert.TypeProperties.IsPublicVisibleClass | TypeAssert.TypeProperties.IsAbstract);
        }

        [Fact]
        public void Constructor()
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Collection<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes;
            Assert.NotNull(supportedMediaTypes);
            Assert.Empty(supportedMediaTypes);
            Collection<MediaTypeMapping> mappings = formatter.MediaTypeMappings;

            Assert.NotNull(mappings);
            Assert.Empty(mappings);
        }

        [Fact]
        void CopyConstructor()
        {
            TestMediaTypeFormatter formatter = new TestMediaTypeFormatter();
            TestMediaTypeFormatter derivedFormatter = new TestMediaTypeFormatter(formatter);

            Assert.Same(formatter.MediaTypeMappings, derivedFormatter.MediaTypeMappings);
            Assert.Same(formatter.MediaTypeMappingsInternal, derivedFormatter.MediaTypeMappingsInternal);
            Assert.Equal(formatter.RequiredMemberSelector, derivedFormatter.RequiredMemberSelector);

            Assert.Same(formatter.SupportedMediaTypes, derivedFormatter.SupportedMediaTypes);
            Assert.Same(formatter.SupportedMediaTypesInternal, derivedFormatter.SupportedMediaTypesInternal);

            Assert.Same(formatter.SupportedEncodings, derivedFormatter.SupportedEncodings);
            Assert.Same(formatter.SupportedEncodingsInternal, derivedFormatter.SupportedEncodingsInternal);
        }

        [Fact]
        public void MaxCollectionKeySize_RoundTrips()
        {
            var defaultMaxKeys = MediaTypeFormatter.MaxHttpCollectionKeys;
            try
            {
                Assert.Reflection.IntegerProperty<MediaTypeFormatter, int>(
                    null,
                    c => MediaTypeFormatter.MaxHttpCollectionKeys,
                    expectedDefaultValue: PlatformInfo.Platform == Platform.Net40 ? 1000 : Int32.MaxValue,
                    minLegalValue: 1,
                    illegalLowerValue: 0,
                    maxLegalValue: null,
                    illegalUpperValue: null,
                    roundTripTestValue: 125);
            }
            finally
            {
                MediaTypeFormatter.MaxHttpCollectionKeys = defaultMaxKeys;
            }
        }

        [Fact]
        public void SupportedMediaTypes_IsMutable()
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Collection<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes;
            MediaTypeHeaderValue[] mediaTypes = HttpTestData.LegalMediaTypeHeaderValues.ToArray();
            foreach (MediaTypeHeaderValue mediaType in mediaTypes)
            {
                supportedMediaTypes.Add(mediaType);
            }

            Assert.True(mediaTypes.SequenceEqual(formatter.SupportedMediaTypes));
        }

        [Fact]
        public void SupportedMediaTypes_AddThrowsWithNullMediaType()
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Collection<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes;

            Assert.ThrowsArgumentNull(() => supportedMediaTypes.Add(null), "item");
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "LegalMediaRangeValues")]
        public void SupportedMediaTypes_AddThrowsWithMediaRange(MediaTypeHeaderValue mediaType)
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Collection<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes;
            Assert.ThrowsArgument(() => supportedMediaTypes.Add(mediaType), "item", Error.Format(Properties.Resources.CannotUseMediaRangeForSupportedMediaType, typeof(MediaTypeHeaderValue).Name, mediaType.MediaType));
        }

        [Fact]
        public void SupportedMediaTypes_InsertThrowsWithNullMediaType()
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Collection<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes;

            Assert.ThrowsArgumentNull(() => supportedMediaTypes.Insert(0, null), "item");
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "LegalMediaRangeValues")]
        public void SupportedMediaTypes_InsertThrowsWithMediaRange(MediaTypeHeaderValue mediaType)
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Collection<MediaTypeHeaderValue> supportedMediaTypes = formatter.SupportedMediaTypes;

            Assert.ThrowsArgument(() => supportedMediaTypes.Insert(0, mediaType), "item", Error.Format(Properties.Resources.CannotUseMediaRangeForSupportedMediaType, typeof(MediaTypeHeaderValue).Name, mediaType.MediaType));
        }

        [Fact]
        public void MediaTypeMappings_IsMutable()
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Collection<MediaTypeMapping> mappings = formatter.MediaTypeMappings;
            MediaTypeMapping[] standardMappings = HttpTestData.StandardMediaTypeMappings.ToArray();
            foreach (MediaTypeMapping mapping in standardMappings)
            {
                mappings.Add(mapping);
            }

            Assert.True(standardMappings.SequenceEqual(formatter.MediaTypeMappings));
        }

        [Fact]
        public void SelectCharacterEncoding_ThrowsIfNoSupportedEncodings()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter { CallBase = true };
            HttpContent content = new StringContent("Hello World", Encoding.UTF8, "text/plain");

            // Act
            Assert.Throws<InvalidOperationException>(() => formatter.SelectCharacterEncoding(content.Headers));
        }

        [Theory]
        [PropertyData("SelectCharacterEncodingTestData")]
        public void SelectCharacterEncoding_ReturnsBestEncoding(string bodyEncoding, string[] supportedEncodings, string expectedEncoding)
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter { CallBase = true };

            foreach (string supportedEncoding in supportedEncodings)
            {
                formatter.SupportedEncodings.Add(Encoding.GetEncoding(supportedEncoding));
            }

            HttpContentHeaders contentHeaders = null;
            if (bodyEncoding != null)
            {
                Encoding bodyEnc = Encoding.GetEncoding(bodyEncoding);
                HttpContent content = new StringContent("Hello World", bodyEnc, "text/plain");
                contentHeaders = content.Headers;
            }

            // Act
            Encoding actualEncoding = formatter.SelectCharacterEncoding(contentHeaders);

            // Assert
            Encoding expectedEnc = expectedEncoding != null ? Encoding.GetEncoding(expectedEncoding) : null;
            Assert.Equal(expectedEnc, actualEncoding);
        }

        [Fact]
        public void ReadFromStreamAsync_ThrowsNotSupportedException()
        {
            var formatter = new Mock<MediaTypeFormatter> { CallBase = true }.Object;

            Assert.Throws<NotSupportedException>(() => formatter.ReadFromStreamAsync(null, null, null, null),
                "The media type formatter of type 'MediaTypeFormatterProxy' does not support reading because it does not implement the ReadFromStreamAsync method.");
        }

        [Fact]
        public void WriteToStreamAsync_ThrowsNotSupportedException()
        {
            var formatter = new Mock<MediaTypeFormatter> { CallBase = true }.Object;

            Assert.Throws<NotSupportedException>(() => formatter.WriteToStreamAsync(null, null, null, null, null),
                "The media type formatter of type 'MediaTypeFormatterProxy' does not support writing because it does not implement the WriteToStreamAsync method.");
        }

        [Theory]
        [InlineData(typeof(object))]
        [InlineData(typeof(string))]
        [InlineData(typeof(Nullable<int>))]
        public void GetDefaultValueForType_ReturnsNullForReferenceTypes(Type referenceType)
        {
            Assert.Null(MediaTypeFormatter.GetDefaultValueForType(referenceType));
        }

        [Theory]
        [InlineData(false)]
        [InlineData(0)]
        [InlineData('a')]
        public void GetDefaultValueForType_ReturnsValueForValueTypes<T>(T value)
        {
            Type valueType = value.GetType();
            T defaultValue = default(T);
            Assert.Equal(defaultValue, MediaTypeFormatter.GetDefaultValueForType(valueType));
        }

        [Fact]
        public void GetDefaultValueForType_ReturnsValueForStruct()
        {
            TestStruct s = new TestStruct();

            TestStruct result = (TestStruct)MediaTypeFormatter.GetDefaultValueForType(typeof(TestStruct));

            Assert.Equal(s, result);
        }

        [Fact]
        public void SetDefaultContentHeaders_ThrowsOnNullType()
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            HttpContentHeaders contentHeaders = FormattingUtilities.CreateEmptyContentHeaders();
            Assert.ThrowsArgumentNull(() => formatter.SetDefaultContentHeaders(null, contentHeaders, TestMediaTypeHeader), "type");
        }

        [Fact]
        public void SetDefaultContentHeaders_ThrowsOnNullHeaders()
        {
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Type type = typeof(object);
            Assert.ThrowsArgumentNull(() => formatter.SetDefaultContentHeaders(type, null, TestMediaTypeHeader), "headers");
        }

        [Fact]
        public void SetDefaultContentHeaders_UsesNonNullMediaTypeClone()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Type type = typeof(object);
            HttpContentHeaders contentHeaders = FormattingUtilities.CreateEmptyContentHeaders();

            // Act
            formatter.SetDefaultContentHeaders(type, contentHeaders, TestMediaTypeHeader);

            // Assert
            Assert.NotSame(TestMediaTypeHeader, contentHeaders.ContentType);
            Assert.Equal(TestMediaType, contentHeaders.ContentType.MediaType);
        }

        [Fact]
        public void SetDefaultContentHeaders_UsesDefaultSupportedMediaTypeClone()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            formatter.SupportedMediaTypes.Add(TestMediaTypeHeader);
            Type type = typeof(object);
            HttpContentHeaders contentHeaders = FormattingUtilities.CreateEmptyContentHeaders();

            // Act
            formatter.SetDefaultContentHeaders(type, contentHeaders, null);

            // Assert
            Assert.NotSame(TestMediaTypeHeader, contentHeaders.ContentType);
            Assert.Equal(TestMediaType, contentHeaders.ContentType.MediaType);
        }

        [Fact]
        public void SetDefaultContentHeaders_UsesDefaultSupportedEncoding()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            Encoding encoding = new UnicodeEncoding();
            formatter.SupportedEncodings.Add(encoding);
            Type type = typeof(object);
            HttpContentHeaders contentHeaders = FormattingUtilities.CreateEmptyContentHeaders();

            // Act
            formatter.SetDefaultContentHeaders(type, contentHeaders, TestMediaTypeHeader);

            // Assert
            Assert.Equal(TestMediaType, contentHeaders.ContentType.MediaType);
            Assert.Equal(encoding.WebName, contentHeaders.ContentType.CharSet);
        }

        [Fact]
        public void SetDefaultContentHeaders_UsesDefaultSupportedMediaTypeAndEncoding()
        {
            // Arrange
            MockMediaTypeFormatter formatter = new MockMediaTypeFormatter();
            formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue(TestMediaType));
            Encoding encoding = new UnicodeEncoding();
            formatter.SupportedEncodings.Add(encoding);
            Type type = typeof(object);
            HttpContentHeaders contentHeaders = FormattingUtilities.CreateEmptyContentHeaders();

            // Act
            formatter.SetDefaultContentHeaders(type, contentHeaders, null);

            // Assert
            Assert.Equal(TestMediaType, contentHeaders.ContentType.MediaType);
            Assert.Equal(encoding.WebName, contentHeaders.ContentType.CharSet);
        }

        [Fact]
        public async Task WriteToStreamAsyncWithCancellationToken_GetsCalled_DuringObjectContentWrite()
        {
            // Arrange
            object value = new object();
            Type type = typeof(object);
            MemoryStream stream = new MemoryStream();
            Mock<MediaTypeFormatter> formatter = new Mock<MediaTypeFormatter>{ CallBase = true };

            formatter.Setup(f => f.CanWriteType(type)).Returns(true);
            formatter
                .Setup(f => f.WriteToStreamAsync(type, value, stream, It.IsAny<ObjectContent>(), null, CancellationToken.None))
                .Returns(TaskHelpers.Completed())
                .Verifiable();

            ObjectContent content = new ObjectContent(type, value, formatter.Object);

            // Act
            await content.CopyToAsync(stream);

            // Assert
            formatter.Verify();
        }

        public struct TestStruct
        {
            private int I;
            public TestStruct(int i)
            {
                I = i + 1;
            }
        }

        private class TestMediaTypeFormatter : MediaTypeFormatter
        {
            public TestMediaTypeFormatter()
            {
            }

            public TestMediaTypeFormatter(TestMediaTypeFormatter formatter)
                : base(formatter)
            {
            }

            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeHeaderValueExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class MediaTypeHeaderValueExtensionsTests
    {
        public static TheoryDataSet<string, string, int> EqualValues
        {
            get
            {
                // These values are all equal
                return new TheoryDataSet<string, string, int>
                {
                    { "text/xml", "text/xml", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml", "TEXT/XML", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; charset=utf-8", "text/xml; charset=utf-8", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; parameter=value", "text/xml; parameter=value", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; charset=utf-8; parameter=value", "text/xml; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.None },

                    { "text/*", "text/*", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/*", "TEXT/*", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/*; charset=utf-8", "text/*; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/*; parameter=value", "text/*; parameter=value", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/*; charset=utf-8; parameter=value", "text/*; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },

                    { "*/*", "*/*", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "*/*; charset=utf-8", "*/*; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "*/*; parameter=value", "*/*; parameter=value", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "*/*; charset=utf-8; parameter=value", "*/*; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },
                };
            }
        }

        public static TheoryDataSet<string, string, int> NonEqualValues
        {
            get
            {
                return new TheoryDataSet<string, string, int>
                {
                    // These values are all subsets. If compared in reverse they are all non-subsets.
                    { "text/xml", "text/xml; charset=utf-8", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml", "TEXT/XML; charset=utf-8", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml", "text/xml; parameter=value", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; charset=utf-8", "text/xml; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.None },

                    { "text/*", "text/*; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/*", "TEXT/*; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/*", "text/*; parameter=value", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/*; charset=utf-8", "text/*; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },

                    { "text/xml", "text/*", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/xml", "text/*; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/xml", "TEXT/*; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/xml", "text/*; parameter=value", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },
                    { "text/xml; charset=utf-8", "text/*; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.SubtypeMediaRange },

                    { "*/*", "*/*; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "*/*", "*/*; parameter=value", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "*/*; charset=utf-8", "*/*; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },

                    { "text/*", "*/*", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "text/*", "*/*; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "text/*", "*/*; parameter=value", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "text/*; charset=utf-8", "*/*; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },

                    { "text/xml", "*/*", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "text/xml", "*/*; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "text/xml", "*/*; parameter=value", (int)MediaTypeHeaderValueRange.AllMediaRange },
                    { "text/xml; charset=utf-8", "*/*; parameter=value; charset=utf-8", (int)MediaTypeHeaderValueRange.AllMediaRange },
                };
            }
        }

        public static TheoryDataSet<string, string, int> NonOverlappingValues
        {
            get
            {
                return new TheoryDataSet<string, string, int>
                {
                    // These values are all value1 < value2 regardless of which value is first and second
                    // We do this asymmetric sorting algorithm to ensure that subsets are always <=0.
                    { "text/xml", "application/xml", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml", "APPLICATION/XML", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml", "application/xml; charset=utf-8", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; charset=utf-8", "application/xml; charset=utf-8", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; charset=utf-8", "application/xml; parameter=value", (int)MediaTypeHeaderValueRange.None },

                    { "text/xml", "text/plain", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml", "TEXT/PLAIN", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml", "text/plain; charset=utf-8", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; charset=utf-8", "text/plain; charset=utf-8", (int)MediaTypeHeaderValueRange.None },
                    { "text/xml; charset=utf-8", "text/plain; parameter=value", (int)MediaTypeHeaderValueRange.None },
                };
            }
        }

        [Theory]
        [PropertyData("EqualValues")]
        public void IsSubsetOf_ReturnsTrueForEqualValues(string mediaType1, string mediaType2, int range)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue1 = MediaTypeHeaderValue.Parse(mediaType1);
            MediaTypeHeaderValue mediaTypeHeaderValue2 = MediaTypeHeaderValue.Parse(mediaType2);

            MediaTypeHeaderValueRange actualRange;
            Assert.True(mediaTypeHeaderValue1.IsSubsetOf(mediaTypeHeaderValue2, out actualRange));
            Assert.Equal(range, (int)actualRange);

            Assert.True(mediaTypeHeaderValue2.IsSubsetOf(mediaTypeHeaderValue1, out actualRange));
        }

        [Theory]
        [PropertyData("NonEqualValues")]
        public void IsSubsetOf_ReturnsTrueForNonEqualValues(string mediaType1, string mediaType2, int range)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue1 = MediaTypeHeaderValue.Parse(mediaType1);
            MediaTypeHeaderValue mediaTypeHeaderValue2 = MediaTypeHeaderValue.Parse(mediaType2);

            MediaTypeHeaderValueRange actualRange;
            Assert.True(mediaTypeHeaderValue1.IsSubsetOf(mediaTypeHeaderValue2, out actualRange));
            Assert.Equal(range, (int)actualRange);

            Assert.False(mediaTypeHeaderValue2.IsSubsetOf(mediaTypeHeaderValue1));
        }

        [Theory]
        [PropertyData("NonOverlappingValues")]
        public void IsSubsetOf_ReturnsFalseForNonOverlappingValues(string mediaType1, string mediaType2, int range)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue1 = MediaTypeHeaderValue.Parse(mediaType1);
            MediaTypeHeaderValue mediaTypeHeaderValue2 = MediaTypeHeaderValue.Parse(mediaType2);

            MediaTypeHeaderValueRange actualRange;
            Assert.False(mediaTypeHeaderValue1.IsSubsetOf(mediaTypeHeaderValue2, out actualRange));
            Assert.Equal(range, (int)actualRange);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeMappingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class MediaTypeMappingTests
    {
        [Fact]
        public void Constructor_ThrowsOnNullMediaTypeHeaderValue()
        {
            Assert.ThrowsArgumentNull(() => new MockMediaTypeMapping((MediaTypeHeaderValue)null), "mediaType");
        }

        [Fact]
        public void Constructor_ThrowsOnNullMediaType()
        {
            Assert.ThrowsArgumentNull(() => new MockMediaTypeMapping((string)null), "mediaType");
            Assert.ThrowsArgumentNull(() => new MockMediaTypeMapping(String.Empty), "mediaType");
        }

        public class MockMediaTypeMapping : MediaTypeMapping
        {
            public MockMediaTypeMapping(MediaTypeHeaderValue mediaType)
                : base(mediaType)
            {
            }

            public MockMediaTypeMapping(string mediaType)
                : base(mediaType)
            {
            }

            public override double TryMatchMediaType(HttpRequestMessage request)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/MediaTypeWithQualityHeaderValueComparerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class MediaTypeWithQualityHeaderValueComparerTests
    {
        public static TheoryDataSet<string, string> EqualValues
        {
            get
            {
                return new TheoryDataSet<string, string>
                {
                    { "text/xml", "text/xml" },
                    { "text/xml", "text/xml; q=1" },
                    { "text/xml", "text/xml; q=1.0" },
                    { "text/xml", "text/xml; q=1.0000" },
                    { "text/xml", "TEXT/XML" },
                    { "text/plain", "text/xml" },
                    { "text/*", "text/*" },
                    { "text/*", "TEXT/*" },
                    { "*/*", "*/*" },
                    { "text/xml", "text/xml; charset=utf8" },
                    { "text/xml", "text/xml; parameter=value" },
                    { "text/xml; parameter=value", "text/xml; parameter=value" },
                    { "text/xml; parameter1=value1", "text/xml; parameter2=value2" },
                    { "text/xml; q=0.5", "text/xml; q=0.50" },
                    { "application/xml; q=0.5", "text/xml; q=0.5" },
                    { "application/xml; q=0.1", "text/xml; q=0.1" },
                    { "application/xml; parameter=value1; q=0.5", "text/xml; parameter=value2; q=0.5" },
                    { "text/xml", "text/xml;q=1" },
                    { "text/xml", "text/xml;q=1.0" },
                    { "text/xml", "text/xml; q=1.00000" },
                    { "text/xml; q=0.5", "text/xml; q=0.5" },
                    { "text/xml; q=1.0", "text/xml; q=1.0" },
                    { "*/*", "*/*;q=1" },
                    { "*/*", "*/*; q=1" },
                    { "*/*", "*/*;q=1.0" },
                    { "*/*", "*/*; q=1.0" },
                    { "*/*; q=0.5", "*/*; q=0.5" },
                    { "*/*; q=1.0", "*/*; q=1.0" },
                };
            }
        }

        public static TheoryDataSet<string, string> NonEqualValues
        {
            get
            {
                return new TheoryDataSet<string, string>
                {
                    { "text/plain; q=0.5", "text/plain" },
                    { "text/plain; q=0.5", "application/xml" },
                    { "text/plain; q=0.5", "text/plain; q=1.0" },
                    { "text/plain; q=0.5", "text/xml; q=1.0" },
                    { "text/*", "text/plain" },
                    { "application/*", "text/plain" },
                    { "*/*", "text/xml" },
                    { "*/*", "text/*" },
                    { "*/*;q=0.5", "*/*;q=0.6" },
                    { "*/*;q=0.5", "text/*;q=0.5" },
                    { "*/*;q=1", "text/plain" },
                    { "*/*; q=1", "text/plain" },
                    { "*/*;q=1.0", "text/plain" },
                    { "*/*; q=1.0", "text/plain" },
                    { "*/*; q=0.5", "text/plain; q=0.5" },
                    { "*/*; q=1.0", "text/plain; q=1.0" },
                    { "*/*; q=0.5", "text/*; q=0.6" },
                };
            }
        }

        public static TheoryDataSet<string[], string[]> BeforeAfterSortedValues
        {
            get
            {
                return new TheoryDataSet<string[], string[]>
                {
                    {
                        new string[]
                        {
                            "application/*",
                            "text/plain",
                            "text/plain;q=1.0",
                            "text/plain",
                            "text/plain;q=0",
                            "*/*;q=0.8",
                            "*/*;q=1",
                            "text/*;q=1",
                            "text/plain;q=0.8",
                            "text/*;q=0.8",
                            "text/*;q=0.6",
                            "text/*;q=1.0",
                            "*/*;q=0.4",
                            "text/plain;q=0.6",
                            "text/xml",
                        },
                        new string[]
                        {
                            "text/plain",
                            "text/plain;q=1.0",
                            "text/plain",
                            "text/xml",
                            "application/*",
                            "text/*;q=1",
                            "text/*;q=1.0",
                            "*/*;q=1",
                            "text/plain;q=0.8",
                            "text/*;q=0.8",
                            "*/*;q=0.8",
                            "text/plain;q=0.6",
                            "text/*;q=0.6",
                            "*/*;q=0.4",
                            "text/plain;q=0",
                        }
                    }
                };
            }
        }

        [Fact]
        public void StaticComparer_Returns_SameInstance()
        {
            MediaTypeWithQualityHeaderValueComparer comparer1 = MediaTypeWithQualityHeaderValueComparer.QualityComparer;
            MediaTypeWithQualityHeaderValueComparer comparer2 = MediaTypeWithQualityHeaderValueComparer.QualityComparer;

            Assert.NotNull(comparer1);
            Assert.Same(comparer1, comparer2);
        }

        [Theory]
        [PropertyData("EqualValues")]
        public void ComparerReturnsZeroForEqualValues(string mediaType1, string mediaType2)
        {
            // Arrange
            MediaTypeWithQualityHeaderValueComparer comparer = MediaTypeWithQualityHeaderValueComparer.QualityComparer;

            // Act
            MediaTypeWithQualityHeaderValue mediaTypeHeaderValue1 = MediaTypeWithQualityHeaderValue.Parse(mediaType1);
            MediaTypeWithQualityHeaderValue mediaTypeHeaderValue2 = MediaTypeWithQualityHeaderValue.Parse(mediaType2);

            // Assert
            Assert.Equal(0, comparer.Compare(mediaTypeHeaderValue1, mediaTypeHeaderValue2));
            Assert.Equal(0, comparer.Compare(mediaTypeHeaderValue2, mediaTypeHeaderValue1));
        }

        [Theory]
        [PropertyData("NonEqualValues")]
        public void ComparerReturnsNonZeroForNonEqualValues(string mediaType1, string mediaType2)
        {
            // Arrange
            MediaTypeWithQualityHeaderValueComparer comparer = MediaTypeWithQualityHeaderValueComparer.QualityComparer;

            // Act
            MediaTypeWithQualityHeaderValue mediaTypeHeaderValue1 = MediaTypeWithQualityHeaderValue.Parse(mediaType1);
            MediaTypeWithQualityHeaderValue mediaTypeHeaderValue2 = MediaTypeWithQualityHeaderValue.Parse(mediaType2);

            // Assert
            Assert.Equal(-1, comparer.Compare(mediaTypeHeaderValue1, mediaTypeHeaderValue2));
            Assert.Equal(1, comparer.Compare(mediaTypeHeaderValue2, mediaTypeHeaderValue1));
        }

        [Theory]
        [PropertyData("BeforeAfterSortedValues")]
        public void ComparerSortsListCorrectly(string[] unsorted, string[] expectedSorted)
        {
            // Arrange
            IEnumerable<MediaTypeWithQualityHeaderValue> unsortedValues =
                unsorted.Select(u => MediaTypeWithQualityHeaderValue.Parse(u));

            IEnumerable<MediaTypeWithQualityHeaderValue> expectedSortedValues =
                expectedSorted.Select(u => MediaTypeWithQualityHeaderValue.Parse(u));

            // Act
            IEnumerable<MediaTypeWithQualityHeaderValue> actualSorted = unsortedValues.OrderByDescending(m => m, MediaTypeWithQualityHeaderValueComparer.QualityComparer);

            // Assert
            Assert.True(expectedSortedValues.SequenceEqual(actualSorted));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/ParsedMediaTypeHeaderValueTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class ParsedMediaTypeHeadeValueTests
    {
        public static TheoryDataSet<string> FullMediaRanges
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "*/*",
                    "*/*; charset=utf-8",
                    "*/*; charset=utf-8; q=1.0",
                };
            }
        }

        public static TheoryDataSet<string> SubTypeMediaRanges
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "text/*",
                    "TEXT/*",
                    "application/*; charset=utf-8",
                    "APPLICATION/*; charset=utf-8",
                    "APPLICATION/*; charset=utf-8; q=1.0",
                };
            }
        }

        public static TheoryDataSet<string> InvalidMediaRanges
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "*/text",
                    "*/XML",
                };
            }
        }
        public static TheoryDataSet<string> NonMediaRanges
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "text/plain",
                    "TEXT/XML",
                    "application/xml; charset=utf-8",
                    "APPLICATION/xml; charset=utf-8",
                };
            }
        }

        public static TheoryDataSet<string> InvalidNonMediaRanges
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "",
                    " ",
                    "\n",
                    "\t",
                    "text",
                    "text/",
                    "text\\", 
                    "\\", "//", 
                    "text/[", 
                    "text/ ", 
                    " text/", 
                    " text/ ", 
                    "text\\ ", 
                    " text\\", 
                    " text\\ ", 
                    "text\\xml", 
                    "text//xml" 
                };
            }
        }

        [Theory]
        [PropertyData("InvalidNonMediaRanges")]
        public void MediaTypeHeaderValue_EnsuresValidMediaType(string invalidMediaType)
        {
            Assert.Throws<Exception>(() => new MediaTypeHeaderValue(invalidMediaType), exceptionMessage: null, allowDerivedExceptions: true);
        }

        [Fact]
        public void TypesEqual_SameType_True()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/json"));
            Assert.True(parsedMediaType1.TypesEqual(ref parsedMediaType2));
        }

        [Fact]
        public void TypesEqual_SameTypeDifferentCase_True()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("TEXT/xml"));
            Assert.True(parsedMediaType1.TypesEqual(ref parsedMediaType2));
        }

        [Fact]
        public void TypesEqual_DifferentType_False()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("application/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            Assert.False(parsedMediaType1.TypesEqual(ref parsedMediaType2));
        }

        [Fact]
        public void TypesEqual_DifferentTypeSameLength_False()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("texx/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            Assert.False(parsedMediaType1.TypesEqual(ref parsedMediaType2));
        }

        [Fact]
        public void SubTypesEqual_SameType_True()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("application/xml"));
            Assert.True(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
        }

        [Fact]
        public void SubTypesEqual_SameTypeDifferentCase_True()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/XML"));
            Assert.True(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
        }

        [Fact]
        public void SubTypesEqual_DifferentType_False()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/json"));
            Assert.False(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
        }

        [Fact]
        public void SubTypesEqual_DifferentTypeSameLength_False()
        {
            ParsedMediaTypeHeaderValue parsedMediaType1 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/xml"));
            ParsedMediaTypeHeaderValue parsedMediaType2 = new ParsedMediaTypeHeaderValue(MediaTypeHeaderValue.Parse("text/yml"));
            Assert.False(parsedMediaType1.SubTypesEqual(ref parsedMediaType2));
        }

        [Theory]
        [PropertyData("FullMediaRanges")]
        [PropertyData("SubTypeMediaRanges")]
        public void IsSubTypeMediaRange_ReturnsTrueForSubTypeMediaRanges(string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
            Assert.True(parsedMediaType.IsSubtypeMediaRange);
        }

        [Theory]
        [PropertyData("InvalidMediaRanges")]
        [PropertyData("NonMediaRanges")]
        public void IsSubTypeMediaRange_ReturnsFalseForNonSubTypeMediaRanges(string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
            Assert.False(parsedMediaType.IsSubtypeMediaRange);
        }

        [Theory]
        [PropertyData("FullMediaRanges")]
        public void IsAllMediaRange_ReturnsTrueForFullMediaTypeRanges(string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
            Assert.True(parsedMediaType.IsAllMediaRange);
        }

        [Theory]
        [PropertyData("SubTypeMediaRanges")]
        [PropertyData("InvalidMediaRanges")]
        [PropertyData("NonMediaRanges")]
        public void IsAllMediaRange_ReturnsFalseForNonFullMediaTypeRanges(string mediaType)
        {
            MediaTypeHeaderValue mediaTypeHeaderValue = MediaTypeHeaderValue.Parse(mediaType);
            ParsedMediaTypeHeaderValue parsedMediaType = new ParsedMediaTypeHeaderValue(mediaTypeHeaderValue);
            Assert.False(parsedMediaType.IsAllMediaRange);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/Parsers/FormUrlEncodedParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.Parsers
{
    public class FormUrlEncodedParserTests
    {
        private const int MinMessageSize = 1;
        private const int Iterations = 16;

        internal static Collection<KeyValuePair<string, string>> CreateCollection()
        {
            return new Collection<KeyValuePair<string, string>>();
        }

        internal static FormUrlEncodedParser CreateParser(int maxMessageSize, out ICollection<KeyValuePair<string, string>> nameValuePairs)
        {
            nameValuePairs = CreateCollection();
            return new FormUrlEncodedParser(nameValuePairs, maxMessageSize);
        }

        internal static byte[] CreateBuffer(params string[] nameValuePairs)
        {
            StringBuilder buffer = new StringBuilder();
            bool first = true;
            foreach (var h in nameValuePairs)
            {
                if (first)
                {
                    first = false;
                }
                else
                {
                    buffer.Append('&');
                }

                buffer.Append(h);
            }

            return Encoding.UTF8.GetBytes(buffer.ToString());
        }

        internal static ParserState ParseBufferInSteps(FormUrlEncodedParser parser, byte[] buffer, int readsize, out int totalBytesConsumed)
        {
            ParserState state = ParserState.Invalid;
            totalBytesConsumed = 0;
            while (totalBytesConsumed <= buffer.Length)
            {
                int size = Math.Min(buffer.Length - totalBytesConsumed, readsize);
                byte[] parseBuffer = new byte[size];
                Buffer.BlockCopy(buffer, totalBytesConsumed, parseBuffer, 0, size);

                int bytesConsumed = 0;
                state = parser.ParseBuffer(parseBuffer, parseBuffer.Length, ref bytesConsumed, totalBytesConsumed == buffer.Length - size);
                totalBytesConsumed += bytesConsumed;

                if (state != ParserState.NeedMoreData)
                {
                    return state;
                }
            }

            return state;
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<FormUrlEncodedParser>(TypeAssert.TypeProperties.IsClass);
        }

        [Fact]
        public void FormUrlEncodedParserThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => { new FormUrlEncodedParser(null, ParserData.MinHeaderSize); }, "nameValuePairs");
        }

        [Fact]
        public void FormUrlEncodedParserThrowsOnInvalidSize()
        {
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => { new FormUrlEncodedParser(CreateCollection(), MinMessageSize - 1); }, "maxMessageSize", MinMessageSize.ToString(), MinMessageSize - 1);

            FormUrlEncodedParser parser = new FormUrlEncodedParser(CreateCollection(), MinMessageSize);
            Assert.NotNull(parser);

            parser = new FormUrlEncodedParser(CreateCollection(), MinMessageSize + 1);
            Assert.NotNull(parser);
        }

        [Fact]
        public void ParseBufferThrowsOnNullBuffer()
        {
            ICollection<KeyValuePair<string, string>> collection;
            FormUrlEncodedParser parser = CreateParser(128, out collection);
            int bytesConsumed = 0;
            Assert.ThrowsArgumentNull(() => { parser.ParseBuffer(null, 0, ref bytesConsumed, false); }, "buffer");
        }

        [Fact]
        public void ParseBufferHandlesEmptyBuffer()
        {
            byte[] data = CreateBuffer();
            ICollection<KeyValuePair<string, string>> collection;
            FormUrlEncodedParser parser = CreateParser(MinMessageSize, out collection);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(data, data.Length, ref bytesConsumed, true);
            Assert.Equal(ParserState.Done, state);
            Assert.Equal(data.Length, bytesConsumed);
            Assert.Empty(collection);
        }

        [Theory]
        [InlineData("N", "N", "")]
        [InlineData("%26", "&", "")]
        [TestDataSet(typeof(UriQueryTestData), "UriQueryData")]
        public void ParseBufferCorrectly(string segment, string name, string value)
        {
            for (int index = 1; index < Iterations; index++)
            {
                List<string> segments = new List<string>();
                for (int cnt = 0; cnt < index; cnt++)
                {
                    segments.Add(segment);
                }

                byte[] data = CreateBuffer(segments.ToArray());
                for (var cnt = 1; cnt <= data.Length; cnt++)
                {
                    ICollection<KeyValuePair<string, string>> collection;
                    FormUrlEncodedParser parser = CreateParser(data.Length + 1, out collection);
                    Assert.NotNull(parser);

                    int totalBytesConsumed;
                    ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                    Assert.Equal(ParserState.Done, state);
                    Assert.Equal(data.Length, totalBytesConsumed);

                    Assert.Equal(index, collection.Count());
                    foreach (KeyValuePair<string, string> element in collection)
                    {
                        Assert.Equal(name, element.Key);
                        Assert.Equal(value, element.Value);
                    }
                }
            }
        }

        [Fact]
        public void HeaderParserDataTooBig()
        {
            byte[] data = CreateBuffer("N=V");
            ICollection<KeyValuePair<string, string>> collection;
            FormUrlEncodedParser parser = CreateParser(MinMessageSize, out collection);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(data, data.Length, ref bytesConsumed, true);
            Assert.Equal(ParserState.DataTooBig, state);
            Assert.Equal(MinMessageSize, bytesConsumed);
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/Parsers/HttpRequestHeaderParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Text;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.Parsers
{
    public class HttpRequestHeaderParserTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<HttpRequestHeaderParser>(TypeAssert.TypeProperties.IsClass);
        }

        [Fact]
        public void HttpRequestHeaderParserConstructorTest()
        {
            HttpUnsortedRequest result = new HttpUnsortedRequest();
            Assert.NotNull(result);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new HttpRequestHeaderParser(result, ParserData.MinRequestLineSize - 1, ParserData.MinHeaderSize),
                "maxRequestLineSize", ParserData.MinRequestLineSize.ToString(), ParserData.MinRequestLineSize - 1);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new HttpRequestHeaderParser(result, ParserData.MinRequestLineSize, ParserData.MinHeaderSize - 1),
                "maxHeaderSize", ParserData.MinHeaderSize.ToString(), ParserData.MinHeaderSize - 1);

            HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result, ParserData.MinRequestLineSize, ParserData.MinHeaderSize);
            Assert.NotNull(parser);

            Assert.ThrowsArgumentNull(() => { new HttpRequestHeaderParser(null); }, "httpRequest");
        }

        [Fact]
        public void RequestHeaderParserNullBuffer()
        {
            HttpUnsortedRequest result = new HttpUnsortedRequest();
            HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result, ParserData.MinRequestLineSize, ParserData.MinHeaderSize);
            Assert.NotNull(parser);
            int bytesConsumed = 0;
            Assert.ThrowsArgumentNull(() => { parser.ParseBuffer(null, 0, ref bytesConsumed); }, "buffer");
        }

        [Fact]
        public void RequestHeaderParserMinimumBuffer()
        {
            byte[] data = CreateBuffer("G", "/", "HTTP/1.1", null);
            HttpUnsortedRequest result = new HttpUnsortedRequest();
            HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result, ParserData.MinRequestLineSize, ParserData.MinHeaderSize);
            Assert.NotNull(parser);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(data, data.Length, ref bytesConsumed);
            Assert.Equal(ParserState.Done, state);
            Assert.Equal(data.Length, bytesConsumed);

            ValidateResult(result, "G", "/", new Version("1.1"), null);
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "AllHttpMethods")]
        public void RequestHeaderParserAcceptsStandardMethods(HttpMethod method)
        {
            byte[] data = CreateBuffer(method.ToString(), "/", "HTTP/1.1", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest result = new HttpUnsortedRequest();
                HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(result, method.ToString(), "/", new Version("1.1"), ParserData.ValidHeaders);
            }
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "CustomHttpMethods")]
        public void RequestHeaderParserAcceptsCustomMethods(HttpMethod method)
        {
            byte[] data = CreateBuffer(method.ToString(), "/", "HTTP/1.1", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest result = new HttpUnsortedRequest();
                HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(result, method.ToString(), "/", new Version("1.1"), ParserData.ValidHeaders);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidMethods")]
        public void RequestHeaderParserRejectsInvalidMethod(string invalidMethod)
        {
            byte[] data = CreateBuffer(invalidMethod, "/", "HTTP/1.1", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest result = new HttpUnsortedRequest();
                HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidRequestUris")]
        public void RequestHeaderParserRejectsInvalidUri(string invalidRequestUri)
        {
            byte[] data = CreateBuffer("GET", invalidRequestUri, "HTTP/1.1", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest result = new HttpUnsortedRequest();
                HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "Versions")]
        public void RequestHeaderParserAcceptsValidVersion(Version version)
        {
            byte[] data = CreateBuffer("GET", "/", String.Format("HTTP/{0}", version.ToString(2)), ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest result = new HttpUnsortedRequest();
                HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(result, "GET", "/", version, ParserData.ValidHeaders);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidVersions")]
        public void RequestHeaderParserRejectsInvalidVersion(string invalidVersion)
        {
            byte[] data = CreateBuffer("GET", "/", invalidVersion, ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest result = new HttpUnsortedRequest();
                HttpRequestHeaderParser parser = new HttpRequestHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        private static byte[] CreateBuffer(string method, string address, string version, Dictionary<string, string> headers)
        {
            const string SP = " ";
            const string CRLF = "\r\n";
            string lws = SP;

            StringBuilder request = new StringBuilder();
            request.AppendFormat("{0}{1}{2}{3}{4}{5}", method, lws, address, lws, version, CRLF);
            if (headers != null)
            {
                foreach (var h in headers)
                {
                    request.AppendFormat("{0}: {1}{2}", h.Key, h.Value, CRLF);
                }
            }

            request.Append(CRLF);
            return Encoding.UTF8.GetBytes(request.ToString());
        }

        private static ParserState ParseBufferInSteps(HttpRequestHeaderParser parser, byte[] buffer, int readsize, out int totalBytesConsumed)
        {
            ParserState state = ParserState.Invalid;
            totalBytesConsumed = 0;
            while (totalBytesConsumed <= buffer.Length)
            {
                int size = Math.Min(buffer.Length - totalBytesConsumed, readsize);
                byte[] parseBuffer = new byte[size];
                Buffer.BlockCopy(buffer, totalBytesConsumed, parseBuffer, 0, size);

                int bytesConsumed = 0;
                state = parser.ParseBuffer(parseBuffer, parseBuffer.Length, ref bytesConsumed);
                totalBytesConsumed += bytesConsumed;

                if (state != ParserState.NeedMoreData)
                {
                    return state;
                }
            }

            return state;
        }

        private static void ValidateResult(
            HttpUnsortedRequest requestLine,
            string method,
            string requestUri,
            Version version,
            Dictionary<string, string> headers)
        {
            Assert.Equal(new HttpMethod(method), requestLine.Method);
            Assert.Equal(requestUri, requestLine.RequestUri);
            Assert.Equal(version, requestLine.Version);

            if (headers != null)
            {
                Assert.Equal(headers.Count, requestLine.HttpHeaders.Count());
                foreach (var header in headers)
                {
                    Assert.True(requestLine.HttpHeaders.Contains(header.Key), "Parsed header did not contain expected key " + header.Key);
                    Assert.Equal(header.Value, requestLine.HttpHeaders.GetValues(header.Key).ElementAt(0));
                }
            }
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/Parsers/HttpRequestLineParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting.DataSets;
using System.Text;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.Parsers
{
    public class HttpRequestLineParserTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<HttpRequestLineParser>(TypeAssert.TypeProperties.IsClass);
        }

        [Fact]
        public void HttpRequestLineParserConstructorTest()
        {
            HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
            Assert.NotNull(requestLine);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new HttpRequestLineParser(requestLine, ParserData.MinRequestLineSize - 1),
                "maxRequestLineSize", ParserData.MinRequestLineSize.ToString(), ParserData.MinRequestLineSize - 1);

            HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, ParserData.MinRequestLineSize);
            Assert.NotNull(parser);

            Assert.ThrowsArgumentNull(() => { new HttpRequestLineParser(null, ParserData.MinRequestLineSize); }, "httpRequest");
        }


        [Fact]
        public void RequestLineParserNullBuffer()
        {
            HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
            HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, ParserData.MinRequestLineSize);
            Assert.NotNull(parser);
            int bytesConsumed = 0;
            Assert.ThrowsArgumentNull(() => { parser.ParseBuffer(null, 0, ref bytesConsumed); }, "buffer");
        }

        [Fact]
        public void RequestLineParserMinimumBuffer()
        {
            byte[] data = CreateBuffer("G", "/", "HTTP/1.1");
            HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
            HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, ParserData.MinRequestLineSize);
            Assert.NotNull(parser);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(data, data.Length, ref bytesConsumed);
            Assert.Equal(ParserState.Done, state);
            Assert.Equal(data.Length, bytesConsumed);

            ValidateResult(requestLine, "G", "/", new Version("1.1"));
        }

        [Fact]
        public void RequestLineParserRejectsLws()
        {
            byte[] data = CreateBuffer("GET", "/", "HTTP/1.1", true);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
                HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, data.Length);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "AllHttpMethods")]
        public void RequestLineParserAcceptsStandardMethods(HttpMethod method)
        {
            byte[] data = CreateBuffer(method.ToString(), "/", "HTTP/1.1");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
                HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, data.Length);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(requestLine, method.ToString(), "/", new Version("1.1"));
            }
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "CustomHttpMethods")]
        public void RequestLineParserAcceptsCustomMethods(HttpMethod method)
        {
            byte[] data = CreateBuffer(method.ToString(), "/", "HTTP/1.1");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
                HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, data.Length);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(requestLine, method.ToString(), "/", new Version("1.1"));
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidMethods")]
        public void RequestLineParserRejectsInvalidMethod(string invalidMethod)
        {
            byte[] data = CreateBuffer(invalidMethod, "/", "HTTP/1.1");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
                HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidRequestUris")]
        public void RequestLineParserRejectsInvalidUri(string invalidRequestUri)
        {
            byte[] data = CreateBuffer("GET", invalidRequestUri, "HTTP/1.1");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
                HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "Versions")]
        public void RequestLineParserAcceptsValidVersion(Version version)
        {
            byte[] data = CreateBuffer("GET", "/", String.Format("HTTP/{0}", version.ToString(2)));

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
                HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(requestLine, "GET", "/", version);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidVersions")]
        public void RequestLineParserRejectsInvalidVersion(string invalidVersion)
        {
            byte[] data = CreateBuffer("GET", "/", invalidVersion);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedRequest requestLine = new HttpUnsortedRequest();
                HttpRequestLineParser parser = new HttpRequestLineParser(requestLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        internal static byte[] CreateBuffer(string method, string address, string version)
        {
            return CreateBuffer(method, address, version, false);
        }

        private static byte[] CreateBuffer(string method, string address, string version, bool withLws)
        {
            const string SP = " ";
            const string HTAB = "\t";
            const string CRLF = "\r\n";

            string lws = SP;
            if (withLws)
            {
                lws = SP + SP + HTAB + SP;
            }

            string requestLine = String.Format("{0}{1}{2}{3}{4}{5}", method, lws, address, lws, version, CRLF);
            return Encoding.UTF8.GetBytes(requestLine);
        }

        private static ParserState ParseBufferInSteps(HttpRequestLineParser parser, byte[] buffer, int readsize, out int totalBytesConsumed)
        {
            ParserState state = ParserState.Invalid;
            totalBytesConsumed = 0;
            while (totalBytesConsumed <= buffer.Length)
            {
                int size = Math.Min(buffer.Length - totalBytesConsumed, readsize);
                byte[] parseBuffer = new byte[size];
                Buffer.BlockCopy(buffer, totalBytesConsumed, parseBuffer, 0, size);

                int bytesConsumed = 0;
                state = parser.ParseBuffer(parseBuffer, parseBuffer.Length, ref bytesConsumed);
                totalBytesConsumed += bytesConsumed;

                if (state != ParserState.NeedMoreData)
                {
                    return state;
                }
            }

            return state;
        }

        private static void ValidateResult(HttpUnsortedRequest requestLine, string method, string requestUri, Version version)
        {
            Assert.Equal(new HttpMethod(method), requestLine.Method);
            Assert.Equal(requestUri, requestLine.RequestUri);
            Assert.Equal(version, requestLine.Version);
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/Parsers/HttpResponseHeaderParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Text;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.Parsers
{
    public class HttpResponseHeaderParserTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<HttpResponseHeaderParser>(TypeAssert.TypeProperties.IsClass);
        }

        [Fact]
        public void HttpResponseHeaderParserConstructorTest()
        {
            HttpUnsortedResponse result = new HttpUnsortedResponse();
            Assert.NotNull(result);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new HttpResponseHeaderParser(result, ParserData.MinStatusLineSize - 1, ParserData.MinHeaderSize),
                "maxStatusLineSize", ParserData.MinStatusLineSize.ToString(), ParserData.MinStatusLineSize - 1);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new HttpResponseHeaderParser(result, ParserData.MinStatusLineSize, ParserData.MinHeaderSize - 1),
                "maxHeaderSize", ParserData.MinHeaderSize.ToString(), ParserData.MinHeaderSize - 1);

            HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result, ParserData.MinStatusLineSize, ParserData.MinHeaderSize);
            Assert.NotNull(parser);

            Assert.ThrowsArgumentNull(() => { new HttpResponseHeaderParser(null); }, "httpResponse");
        }


        [Fact]
        public void ResponseHeaderParserNullBuffer()
        {
            HttpUnsortedResponse result = new HttpUnsortedResponse();
            HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result, ParserData.MinStatusLineSize, ParserData.MinHeaderSize);
            Assert.NotNull(parser);
            int bytesConsumed = 0;
            Assert.ThrowsArgumentNull(() => { parser.ParseBuffer(null, 0, ref bytesConsumed); }, "buffer");
        }

        [Fact]
        public void ResponseHeaderParserMinimumBuffer()
        {
            byte[] data = CreateBuffer("HTTP/1.1", "200", "", null);
            HttpUnsortedResponse result = new HttpUnsortedResponse();
            HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result, ParserData.MinStatusLineSize, ParserData.MinHeaderSize);
            Assert.NotNull(parser);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(data, data.Length, ref bytesConsumed);
            Assert.Equal(ParserState.Done, state);
            Assert.Equal(data.Length, bytesConsumed);

            ValidateResult(result, new Version("1.1"), HttpStatusCode.OK, "", null);
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "AllHttpStatusCodes")]
        public void ResponseHeaderParserAcceptsStandardStatusCodes(HttpStatusCode status)
        {
            byte[] data = CreateBuffer("HTTP/1.1", ((int)status).ToString(), "Reason", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse result = new HttpUnsortedResponse();
                HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(result, new Version("1.1"), status, "Reason", ParserData.ValidHeaders);
            }
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "CustomHttpStatusCodes")]
        public void ResponseHeaderParserAcceptsCustomStatusCodes(HttpStatusCode status)
        {
            byte[] data = CreateBuffer("HTTP/1.1", ((int)status).ToString(), "Reason", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse result = new HttpUnsortedResponse();
                HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(result, new Version("1.1"), status, "Reason", ParserData.ValidHeaders);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidStatusCodes")]
        public void ResponseHeaderParserRejectsInvalidStatusCodes(string invalidStatus)
        {
            byte[] data = CreateBuffer("HTTP/1.1", invalidStatus, "Reason", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse result = new HttpUnsortedResponse();
                HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidReasonPhrases")]
        public void ResponseHeaderParserRejectsInvalidReasonPhrase(string invalidReason)
        {
            byte[] data = CreateBuffer("HTTP/1.1", "200", invalidReason, ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse result = new HttpUnsortedResponse();
                HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "Versions")]
        public void ResponseHeaderParserAcceptsValidVersion(Version version)
        {
            byte[] data = CreateBuffer(String.Format("HTTP/{0}", version.ToString(2)), "200", "Reason", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse result = new HttpUnsortedResponse();
                HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(result, version, HttpStatusCode.OK, "Reason", ParserData.ValidHeaders);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidVersions")]
        public void ResponseHeaderParserRejectsInvalidVersion(string invalid)
        {
            byte[] data = CreateBuffer(invalid, "200", "Reason", ParserData.ValidHeaders);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse result = new HttpUnsortedResponse();
                HttpResponseHeaderParser parser = new HttpResponseHeaderParser(result);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        private static byte[] CreateBuffer(string version, string statusCode, string reasonPhrase, Dictionary<string, string> headers)
        {
            const string SP = " ";
            const string CRLF = "\r\n";
            string lws = SP;

            StringBuilder response = new StringBuilder();
            response.AppendFormat("{0}{1}{2}{3}{4}{5}", version, lws, statusCode, lws, reasonPhrase, CRLF);
            if (headers != null)
            {
                foreach (var h in headers)
                {
                    response.AppendFormat("{0}: {1}{2}", h.Key, h.Value, CRLF);
                }
            }

            response.Append(CRLF);
            return Encoding.UTF8.GetBytes(response.ToString());
        }

        private static ParserState ParseBufferInSteps(HttpResponseHeaderParser parser, byte[] buffer, int readsize, out int totalBytesConsumed)
        {
            ParserState state = ParserState.Invalid;
            totalBytesConsumed = 0;
            while (totalBytesConsumed <= buffer.Length)
            {
                int size = Math.Min(buffer.Length - totalBytesConsumed, readsize);
                byte[] parseBuffer = new byte[size];
                Buffer.BlockCopy(buffer, totalBytesConsumed, parseBuffer, 0, size);

                int bytesConsumed = 0;
                state = parser.ParseBuffer(parseBuffer, parseBuffer.Length, ref bytesConsumed);
                totalBytesConsumed += bytesConsumed;

                if (state != ParserState.NeedMoreData)
                {
                    return state;
                }
            }

            return state;
        }

        private static void ValidateResult(
            HttpUnsortedResponse statusLine,
            Version version,
            HttpStatusCode statusCode,
            string reasonPhrase,
            Dictionary<string, string> headers)
        {
            Assert.Equal(version, statusLine.Version);
            Assert.Equal(statusCode, statusLine.StatusCode);
            Assert.Equal(reasonPhrase, statusLine.ReasonPhrase);

            if (headers != null)
            {
                Assert.Equal(headers.Count, statusLine.HttpHeaders.Count());
                foreach (var header in headers)
                {
                    Assert.True(statusLine.HttpHeaders.Contains(header.Key), "Parsed header did not contain expected key " + header.Key);
                    Assert.Equal(header.Value, statusLine.HttpHeaders.GetValues(header.Key).ElementAt(0));
                }
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/Parsers/HttpStatusLineParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting.DataSets;
using System.Text;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.Parsers
{
    public class HttpStatusLineParserTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<HttpStatusLineParser>(TypeAssert.TypeProperties.IsClass);
        }

        [Fact]
        public void HttpStatusLineParserConstructorTest()
        {
            HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
            Assert.NotNull(statusLine);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new HttpStatusLineParser(statusLine, ParserData.MinStatusLineSize - 1),
                "maxStatusLineSize", ParserData.MinStatusLineSize.ToString(), ParserData.MinStatusLineSize - 1);

            HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, ParserData.MinStatusLineSize);
            Assert.NotNull(parser);

            Assert.ThrowsArgumentNull(() => { new HttpStatusLineParser(null, ParserData.MinStatusLineSize); }, "httpResponse");
        }


        [Fact]
        public void StatusLineParserNullBuffer()
        {
            HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
            HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, ParserData.MinStatusLineSize);
            Assert.NotNull(parser);
            int bytesConsumed = 0;
            Assert.ThrowsArgumentNull(() => { parser.ParseBuffer(null, 0, ref bytesConsumed); }, "buffer");
        }

        [Fact]
        public void StatusLineParserMinimumBuffer()
        {
            byte[] data = CreateBuffer("HTTP/1.1", "200", "");
            HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
            HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, ParserData.MinStatusLineSize);
            Assert.NotNull(parser);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(data, data.Length, ref bytesConsumed);
            Assert.Equal(ParserState.Done, state);
            Assert.Equal(data.Length, bytesConsumed);

            ValidateResult(statusLine, new Version("1.1"), HttpStatusCode.OK, "");
        }

        [Fact]
        public void StatusLineParserRejectsLws()
        {
            byte[] data = CreateBuffer("HTTP/1.1", "200", "Reason", true);
            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
                HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, data.Length);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "AllHttpStatusCodes")]
        public void StatusLineParserAcceptsStandardStatusCodes(HttpStatusCode status)
        {
            byte[] data = CreateBuffer("HTTP/1.1", ((int)status).ToString(), "Reason");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
                HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, data.Length);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(statusLine, new Version("1.1"), status, "Reason");
            }
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "CustomHttpStatusCodes")]
        public void StatusLineParserAcceptsCustomStatusCodes(HttpStatusCode status)
        {
            byte[] data = CreateBuffer("HTTP/1.1", ((int)status).ToString(), "Reason");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
                HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, data.Length);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(statusLine, new Version("1.1"), status, "Reason");
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidStatusCodes")]
        public void StatusLineParserRejectsInvalidStatusCodes(string invalidStatus)
        {
            byte[] data = CreateBuffer("HTTP/1.1", invalidStatus, "Reason");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
                HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "ValidReasonPhrases")]
        public void StatusLineParserAcceptsValidReasonPhrase(string validReasonPhrase)
        {
            byte[] data = CreateBuffer("HTTP/1.1", "200", validReasonPhrase);

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
                HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);

                ValidateResult(statusLine, new Version("1.1"), HttpStatusCode.OK, validReasonPhrase);
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "Versions")]
        public void StatusLineParserAcceptsValidVersion(Version version)
        {
            byte[] data = CreateBuffer(String.Format("HTTP/{0}", version.ToString(2)), "200", "Reason");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
                HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(data.Length, totalBytesConsumed);

                ValidateResult(statusLine, version, HttpStatusCode.OK, "Reason");
            }
        }

        [Theory]
        [TestDataSet(typeof(ParserData), "InvalidVersions")]
        public void StatusLineParserRejectsInvalidVersion(string invalidVersion)
        {
            byte[] data = CreateBuffer(invalidVersion, "200", "Reason");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpUnsortedResponse statusLine = new HttpUnsortedResponse();
                HttpStatusLineParser parser = new HttpStatusLineParser(statusLine, 256);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
            }
        }

        internal static byte[] CreateBuffer(string version, string statusCode, string reasonPhrase)
        {
            return CreateBuffer(version, statusCode, reasonPhrase, false);
        }

        private static byte[] CreateBuffer(string version, string statusCode, string reasonPhrase, bool withLws)
        {
            const string SP = " ";
            const string HTAB = "\t";
            const string CRLF = "\r\n";

            string lws = SP;
            if (withLws)
            {
                lws = SP + SP + HTAB + SP;
            }

            string statusLine = String.Format("{0}{1}{2}{3}{4}{5}", version, lws, statusCode, lws, reasonPhrase, CRLF);
            return Encoding.UTF8.GetBytes(statusLine);
        }

        private static ParserState ParseBufferInSteps(HttpStatusLineParser parser, byte[] buffer, int readsize, out int totalBytesConsumed)
        {
            ParserState state = ParserState.Invalid;
            totalBytesConsumed = 0;
            while (totalBytesConsumed <= buffer.Length)
            {
                int size = Math.Min(buffer.Length - totalBytesConsumed, readsize);
                byte[] parseBuffer = new byte[size];
                Buffer.BlockCopy(buffer, totalBytesConsumed, parseBuffer, 0, size);

                int bytesConsumed = 0;
                state = parser.ParseBuffer(parseBuffer, parseBuffer.Length, ref bytesConsumed);
                totalBytesConsumed += bytesConsumed;

                if (state != ParserState.NeedMoreData)
                {
                    return state;
                }
            }

            return state;
        }

        private static void ValidateResult(HttpUnsortedResponse statusLine, Version version, HttpStatusCode statusCode, string reasonPhrase)
        {
            Assert.Equal(version, statusLine.Version);
            Assert.Equal(statusCode, statusLine.StatusCode);
            Assert.Equal(reasonPhrase, statusLine.ReasonPhrase);
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/Parsers/InternetMessageFormatHeaderParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Text;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.Parsers
{
    public class InternetMessageFormatHeaderParserTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<InternetMessageFormatHeaderParser>(TypeAssert.TypeProperties.IsClass);
        }

        [Fact]
        public void HeaderParserConstructorTest()
        {
            IEnumerable<HttpHeaders> headers = InternetMessageFormatHeaderParserTests.CreateHttpHeaders();
            foreach (var header in headers)
            {
                InternetMessageFormatHeaderParser parser = new InternetMessageFormatHeaderParser(header, ParserData.MinHeaderSize);
                Assert.NotNull(parser);
            }

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new InternetMessageFormatHeaderParser(headers.ElementAt(0), ParserData.MinHeaderSize - 1),
                "maxHeaderSize", ParserData.MinHeaderSize.ToString(), ParserData.MinHeaderSize - 1);

            Assert.ThrowsArgumentNull(() => { new InternetMessageFormatHeaderParser(null, ParserData.MinHeaderSize); }, "headers");
        }


        [Fact]
        public void HeaderParserNullBuffer()
        {
            HttpHeaders headers;
            InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(128, out headers);
            Assert.NotNull(parser);
            int bytesConsumed = 0;
            Assert.ThrowsArgumentNull(() => { parser.ParseBuffer(null, 0, ref bytesConsumed); }, "buffer");
        }

        [Fact]
        public void HeaderParserEmptyBuffer()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer();
            HttpHeaders headers;
            InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
            Assert.NotNull(parser);

            int bytesConsumed = 0;
            ParserState state = parser.ParseBuffer(data, data.Length, ref bytesConsumed);
            Assert.Equal(ParserState.Done, state);
            Assert.Equal(data.Length, bytesConsumed);

            Assert.Empty(headers);
        }

        [Fact]
        public void HeaderParserSingleNameValueHeader()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N:V");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Single(headers);
                IEnumerable<string> parsedValues = headers.GetValues("N");
                string parsedValue = Assert.Single(parsedValues);
                Assert.Equal("V", parsedValue);
            }
        }

        [Fact]
        public void HeaderParserSingleNameHeader()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N:");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Single(headers);
                IEnumerable<string> parsedValues = headers.GetValues("N");
                string parsedValue = Assert.Single(parsedValues);
                Assert.Equal("", parsedValue);
            }
        }

        [Fact]
        public void HeaderParserMultipleNameHeader()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N:V1", "N:V2");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Single(headers);
                IEnumerable<string> parsedValues = headers.GetValues("N");
                Assert.Equal(2, parsedValues.Count());
                Assert.Equal("V1", parsedValues.ElementAt(0));
                Assert.Equal("V2", parsedValues.ElementAt(1));
            }
        }

        [Fact]
        public void HeaderParserLwsHeader()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N1:V1", "N2: V2", "N3:\tV3");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(3, headers.Count());

                IEnumerable<string> parsedValues = headers.GetValues("N1");
                string parsedValue = Assert.Single(parsedValues);
                Assert.Equal("V1", parsedValue);

                parsedValues = headers.GetValues("N2");
                parsedValue = Assert.Single(parsedValues);
                Assert.Equal("V2", parsedValue);

                parsedValues = headers.GetValues("N3");
                parsedValue = Assert.Single(parsedValues);
                Assert.Equal("V3", parsedValue);
            }
        }

        [Fact]
        public void HeaderParserInvalidHeader()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N1 :V1");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Invalid, state);
                Assert.Equal(data.Length - 2, totalBytesConsumed);
            }
        }

        [Fact]
        public void HeaderParserSpecializedHeaders()
        {
            Dictionary<string, string> headerData = new Dictionary<string, string>
            {
                { @"JsonProperties0", @"{ ""SessionId"": ""{27729E1-B37B-4D29-AA0A-E367906C206E}"", ""MessageId"": ""{701332E1-B37B-4D29-AA0A-E367906C206E}"", ""TimeToLive"" : 90, ""CorrelationId"": ""{701332F3-B37B-4D29-AA0A-E367906C206E}"", ""SequenceNumber"" : 12345, ""DeliveryCount"" : 2, ""To"" : ""http://contoso.com/path1"", ""ReplyTo"" : ""http://fabrikam.com/path1"",  ""SentTimeUtc"" : ""Sun, 06 Nov 1994 08:49:37 GMT"", ""ScheduledEnqueueTimeUtc"" : ""Sun, 06 Nov 1994 08:49:37 GMT""}" },
                { @"JsonProperties1", @"{ ""SessionId"": ""{2813D4D2-46A9-4F4D-8904-E9BDE3712B70}"", ""MessageId"": ""{24AE31D6-63B8-46F3-9975-A3DAF1B6D3F4}"", ""TimeToLive"" : 80, ""CorrelationId"": ""{896DD5BD-1645-44D7-9E7C-D7F70958ECD6}"", ""SequenceNumber"" : 54321, ""DeliveryCount"" : 4, ""To"" : ""http://contoso.com/path2"", ""ReplyTo"" : ""http://fabrikam.com/path2"",  ""SentTimeUtc"" : ""Sun, 06 Nov 1994 10:49:37 GMT"", ""ScheduledEnqueueTimeUtc"" : ""Sun, 06 Nov 1994 10:49:37 GMT""}" },
                { @"P3P", @"CP=""ALL IND DSP COR ADM CONo CUR CUSo IVAo IVDo PSA PSD TAI TELo OUR SAMo CNT COM INT NAV ONL PHY PRE PUR UNI""" },
                { @"Cookie", @"omniID=1297715979621_9f45_1519_3f8a_f22f85346ac6; WT_FPC=id=65.55.227.138-2323234032.30136233:lv=1309374389020:ss=1309374389020; A=I&I=AxUFAAAAAACNCAAADYEZ7CFPss7Swnujy4PXZA!!&M=1&CS=126mAa0002ZB51a02gZB51a; MC1=GUID=568428660ad44d4ab8f46133f4b03738&HASH=6628&LV=20113&V=3; WT_NVR_RU=0=msdn:1=:2=; MUID=A44DE185EA1B4E8088CCF7B348C5D65F; MSID=Microsoft.CreationDate=03/04/2011 23:38:15&Microsoft.LastVisitDate=06/20/2011 04:15:08&Microsoft.VisitStartDate=06/20/2011 04:15:08&Microsoft.CookieId=f658f3f2-e6d6-42ab-b86b-96791b942b6f&Microsoft.TokenId=ffffffff-ffff-ffff-ffff-ffffffffffff&Microsoft.NumberOfVisits=106&Microsoft.CookieFirstVisit=1&Microsoft.IdentityToken=AA==&Microsoft.MicrosoftId=0441-6141-1523-9969; msresearch=%7B%22version%22%3A%224.6%22%2C%22state%22%3A%7B%22name%22%3A%22IDLE%22%2C%22url%22%3Aundefined%2C%22timestamp%22%3A1299281911415%7D%2C%22lastinvited%22%3A1299281911415%2C%22userid%22%3A%2212992819114151265672533023080%22%2C%22vendorid%22%3A1%2C%22surveys%22%3A%5Bundefined%5D%7D; CodeSnippetContainerLang=C#; msdn=L=1033; ADS=SN=175A21EF; s_cc=true; s_sq=%5B%5BB%5D%5D; TocHashCookie=ms310241(n)/aa187916(n)/aa187917(n)/dd273952(n)/dd295083(n)/ff472634(n)/ee667046(n)/ee667070(n)/gg259047(n)/gg618436(n)/; WT_NVR=0=/:1=query|library|en-us:2=en-us/vcsharp|en-us/library" },
                { @"Set-Cookie", @"A=I&I=AxUFAAAAAADsBgAA1sWZz4FGun/kOeyV4LGZVg!!&M=1; domain=.microsoft.com; expires=Sun, 30-Jun-2041 00:14:40 GMT; path=/" },
            };

            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer(headerData.Select((kv) => { return String.Format("{0}: {1}", kv.Key, kv.Value); }).ToArray());
            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(headerData.Count, headers.Count());
                for (int hCnt = 0; hCnt < headerData.Count; hCnt++)
                {
                    Assert.Equal(headerData.Keys.ElementAt(hCnt), headers.ElementAt(hCnt).Key);
                    Assert.Equal(headerData.Values.ElementAt(hCnt), headers.ElementAt(hCnt).Value.ElementAt(0));
                }
            }
        }

        [Fact]
        public void HeaderParserSplitHeader()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N:V1,", " V2,", "\tV3,", "      V4,", " \tV5");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Single(headers);
                IEnumerable<string> parsedValues = headers.GetValues("N");
                string parsedValue = Assert.Single(parsedValues);
                Assert.Equal("V1, V2, V3,      V4, \tV5", parsedValues.ElementAt(0));
            }
        }

        [Fact]
        public void HeaderParserDataTooBigSingle()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N:V");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(ParserData.MinHeaderSize, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.DataTooBig, state);
                Assert.Equal(ParserData.MinHeaderSize, totalBytesConsumed);
            }
        }

        [Fact]
        public void HeaderParserTestDataTooBigMulti()
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer("N1:V1", "N2:V2", "N3:V3");

            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(10, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.DataTooBig, state);
                Assert.Equal(10, totalBytesConsumed);
            }
        }

        [Fact]
        public void Rfc5322Sample1Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample1,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample2Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample2,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("sender"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample3Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample3,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("cc"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample4Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample4,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("cc"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample5Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample5,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample6Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample6,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("reply-to"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                    Assert.True(headers.Contains("in-reply-to"));
                    Assert.True(headers.Contains("references"));
                });
        }

        [Fact]
        public void Rfc5322Sample7Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample7,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                    Assert.True(headers.Contains("in-reply-to"));
                    Assert.True(headers.Contains("references"));
                });
        }

        [Fact]
        public void Rfc5322Sample8Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample8,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample9Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample9,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("resent-from"));
                    Assert.True(headers.Contains("resent-to"));
                    Assert.True(headers.Contains("resent-date"));
                    Assert.True(headers.Contains("resent-message-id"));
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample10Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample10,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("received"));
                    Assert.Equal(2, headers.GetValues("received").Count());
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("subject"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        [Fact]
        public void Rfc5322Sample11Test()
        {
            RunRfc5322SampleTest(Rfc5322Sample11,
                (headers) =>
                {
                    Assert.NotNull(headers);
                    Assert.True(headers.Contains("from"));
                    Assert.True(headers.Contains("to"));
                    Assert.True(headers.Contains("cc"));
                    Assert.True(headers.Contains("date"));
                    Assert.True(headers.Contains("message-id"));
                });
        }

        // Set of samples from RFC 5322 with times adjusted to GMT following HTTP style for date time format.
        static readonly string[] Rfc5322Sample1 = new string[] {
            @"From: John Doe <jdoe@machine.example>",
            @"To: Mary Smith <mary@example.net>",
            @"Subject: Saying Hello",
            @"Date: Fri, 21 Nov 1997 09:55:06 GMT",
            @"Message-ID: <1234@local.machine.example>",
        };

        static readonly string[] Rfc5322Sample2 = new string[] {
            @"From: John Doe <jdoe@machine.example>",
            @"Sender: Michael Jones <mjones@machine.example>",
            @"To: Mary Smith <mary@example.net>",
            @"Subject: Saying Hello",
            @"Date: Fri, 21 Nov 1997 09:55:06 GMT",
            @"Message-ID: <1234@local.machine.example>",
        };

        static readonly string[] Rfc5322Sample3 = new string[] {
            @"From: ""Joe Q. Public"" <john.q.public@example.com>",
            @"To: Mary Smith <mary@x.test>, jdoe@example.org, Who? <one@y.test>",
            @"Cc: <boss@nil.test>, ""Giant; \""Big\"" Box"" <sysservices@example.net>",
            @"Date: Tue, 01 Jul 2003 10:52:37 GMT",
            @"Message-ID: <5678.21-Nov-1997@example.com>",
        };

        static readonly string[] Rfc5322Sample4 = new string[] {
            @"From: Pete <pete@silly.example>",
            @"To: A Group:Ed Jones <c@a.test>,joe@where.test,John <jdoe@one.test>;",
            @"Cc: Undisclosed recipients:;",
            @"Date: Thu, 13 Feb 1969 23:32:54 GMT",
            @"Message-ID: <testabcd.1234@silly.example>",
        };

        static readonly string[] Rfc5322Sample5 = new string[] {
            @"From: John Doe <jdoe@machine.example>",
            @"To: Mary Smith <mary@example.net>",
            @"Subject: Saying Hello",
            @"Date: Fri, 21 Nov 1997 09:55:06 GMT",
            @"Message-ID: <1234@local.machine.example>",
        };

        static readonly string[] Rfc5322Sample6 = new string[] {
            @"From: Mary Smith <mary@example.net>",
            @"To: John Doe <jdoe@machine.example>",
            @"Reply-To: ""Mary Smith: Personal Account"" <smith@home.example>",
            @"Subject: Re: Saying Hello",
            @"Date: Fri, 21 Nov 1997 10:01:10 GMT",
            @"Message-ID: <3456@example.net>",
            @"In-Reply-To: <1234@local.machine.example>",
            @"References: <1234@local.machine.example>",
        };

        static readonly string[] Rfc5322Sample7 = new string[] {
            @"To: ""Mary Smith: Personal Account"" <smith@home.example>",
            @"From: John Doe <jdoe@machine.example>",
            @"Subject: Re: Saying Hello",
            @"Date: Fri, 21 Nov 1997 11:00:00 GMT",
            @"Message-ID: <abcd.1234@local.machine.test>",
            @"In-Reply-To: <3456@example.net>",
            @"References: <1234@local.machine.example> <3456@example.net>",
        };

        static readonly string[] Rfc5322Sample8 = new string[] {
            @"From: John Doe <jdoe@machine.example>",
            @"To: Mary Smith <mary@example.net>",
            @"Subject: Saying Hello",
            @"Date: Fri, 21 Nov 1997 09:55:06 GMT",
            @"Message-ID: <1234@local.machine.example>",
        };

        static readonly string[] Rfc5322Sample9 = new string[] {
            @"Resent-From: Mary Smith <mary@example.net>",
            @"Resent-To: Jane Brown <j-brown@other.example>",
            @"Resent-Date: Mon, 24 Nov 1997 14:22:01 GMT",
            @"Resent-Message-ID: <78910@example.net>",
            @"From: John Doe <jdoe@machine.example>",
            @"To: Mary Smith <mary@example.net>",
            @"Subject: Saying Hello",
            @"Date: Fri, 21 Nov 1997 09:55:06 GMT",
            @"Message-ID: <1234@local.machine.example>",
        };

        static readonly string[] Rfc5322Sample10 = new string[] {
            @"Received: from x.y.test",
            @"   by example.net",
            @"   via TCP",
            @"   with ESMTP",
            @"   id ABC12345",
            @"   for <mary@example.net>;  21 Nov 1997 10:05:43 GMT",
            @"Received: from node.example by x.y.test; 21 Nov 1997 10:01:22 GMT",
            @"From: John Doe <jdoe@node.example>",
            @"To: Mary Smith <mary@example.net>",
            @"Subject: Saying Hello",
            @"Date: Fri, 21 Nov 1997 09:55:06 GMT",
            @"Message-ID: <1234@local.node.example>",
        };

        static readonly string[] Rfc5322Sample11 = new string[] {
            @"From: Pete(A nice \) chap) <pete(his account)@silly.test(his host)>",
            @"To:A Group(Some people)",
            @"     :Chris Jones <c@(Chris's host.)public.example>,",
            @"         joe@example.org,",
            @"  John <jdoe@one.test> (my dear friend); (the end of the group)",
            @"Cc:(Empty list)(start)Hidden recipients  :(nobody(that I know))  ;",
            @"Date: Thu,",
            @"      13",
            @"        Feb",
            @"          1969",
            @"      23:32:00",
            @"               GMT",
            @"Message-ID:              <testabcd.1234@silly.test>",
        };

        private static IEnumerable<HttpHeaders> CreateHttpHeaders()
        {
            return new HttpHeaders[]
            {
                new HttpRequestMessage().Headers,
                new HttpResponseMessage().Headers,
                new StringContent(String.Empty).Headers,
            };
        }

        private static InternetMessageFormatHeaderParser CreateHeaderParser(int maximumHeaderLength, out HttpHeaders headers)
        {
            headers = new HttpRequestMessage().Headers;
            return new InternetMessageFormatHeaderParser(headers, maximumHeaderLength);
        }

        internal static byte[] CreateBuffer(params string[] headers)
        {
            const string CRLF = "\r\n";
            StringBuilder header = new StringBuilder();
            foreach (var h in headers)
            {
                header.Append(h + CRLF);
            }

            header.Append(CRLF);
            return Encoding.UTF8.GetBytes(header.ToString());
        }

        private static void RunRfc5322SampleTest(string[] testHeaders, Action<HttpHeaders> validation)
        {
            byte[] data = InternetMessageFormatHeaderParserTests.CreateBuffer(testHeaders);
            for (var cnt = 1; cnt <= data.Length; cnt++)
            {
                HttpHeaders headers;
                InternetMessageFormatHeaderParser parser = InternetMessageFormatHeaderParserTests.CreateHeaderParser(data.Length, out headers);
                Assert.NotNull(parser);

                int totalBytesConsumed = 0;
                ParserState state = InternetMessageFormatHeaderParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
                Assert.Equal(ParserState.Done, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                validation(headers);
            }
        }

        private static ParserState ParseBufferInSteps(InternetMessageFormatHeaderParser parser, byte[] buffer, int readsize, out int totalBytesConsumed)
        {
            ParserState state = ParserState.Invalid;
            totalBytesConsumed = 0;
            while (totalBytesConsumed <= buffer.Length)
            {
                int size = Math.Min(buffer.Length - totalBytesConsumed, readsize);
                byte[] parseBuffer = new byte[size];
                Buffer.BlockCopy(buffer, totalBytesConsumed, parseBuffer, 0, size);

                int bytesConsumed = 0;
                state = parser.ParseBuffer(parseBuffer, parseBuffer.Length, ref bytesConsumed);
                totalBytesConsumed += bytesConsumed;

                if (state != ParserState.NeedMoreData)
                {
                    return state;
                }
            }

            return state;
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/Parsers/MimeMultipartParserTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting.Parsers
{
    public class MimeMultipartParserTests
    {
        private const string SP = " ";
        private const string LF = "\n";
        private const string CR = "\r";
        private const string CRLF = "\r\n";
        private const string HTAB = "\t";
        private const string DashDash = "--";

        public static TheoryDataSet<string> Boundaries
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "1",
                    "a",
                    "'()+_--./:=?",
                    "--",
                    "----",
                    "9df4e21f-6e6f-4b08-8023-97283d2afeeb",
                    "-----------------------------7d159c1302d0y0",
                    "--------------------01234567890123456789",
                    "--------------------01234567890123456789--------------------",
                    "--A--B--C--D--E--F--",
                };
            }
        }

        public static TheoryDataSet<string> SingleShortBodies
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "",
                    "A",
                    "AA",
                };
            }
        }

        public static TheoryDataSet<string[]> MultipleShortBodies
        {
            get
            {
                return new TheoryDataSet<string[]>
                {
                    CreateMultipleShortBodies("", 26),
                    CreateMultipleShortBodies("{0}", 26),
                    CreateMultipleShortBodies("--{0}", 26),
                };
            }
        }

        public static TheoryDataSet<string> SingleLongBodies
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    CreateLongString("1234567890", "A", 128),
                    CreateLongString("1234567890", "--", 128),
                };
            }
        }

        public static TheoryDataSet<string[]> MultipleLongBodies
        {
            get
            {
                string[] result = new string[16];
                for (int count = 0; count < result.Length; count++)
                {
                    string bookend = Char.ConvertFromUtf32(0x41 + count);
                    result[count] = CreateLongString("1234567890", bookend, 16);
                }

                return new TheoryDataSet<string[]>
                {
                    result
                };
            }
        }

        public static TheoryDataSet<string> NearBoundaryBodies
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "AAA" + LF,
                    "AAA" + CR,
                    "AAA" + CRLF,
                    "AAA" + CRLF + CRLF,
                    "AAA" + CRLF + "-",
                    "AAA" + CRLF + "-" + CR,
                    "AAA" + CRLF + "=" + CRLF,
                    CR + "-" + "AAA",
                    CRLF + "-" + "AAA",
                    CRLF + "--" + "AAA" + CR + "AAA",
                    CRLF,
                    "AAA",
                    CRLF + CRLF,
                    CRLF + CRLF + CRLF,
                    "AAA" + "--" + "AAA",
                    CRLF + "AAA" + "--" + "AAA" + "--",
                    CRLF + "--" + "AAA" + CRLF,
                    CRLF + "--" + "AAA" + CRLF + CRLF,
                    CRLF + "--" + "AAA" + "--" + CRLF,
                    CRLF + "--" + "AAA" + "--" + CRLF + CRLF,
                    "--úN$(Os#»Í(Bt$(Dqf(CS'.‚æ0j",
                    "--123456",
                    "123--456",
                    "123456--"
                };
            }
        }

        public static TheoryDataSet<bool> TrueAndFalse
        {
            get
            {
                return new TheoryDataSet<bool>
                {
                    true,
                    false,
                };
            }
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public void MimeMultipartParserConstructorTest(string boundary)
        {
            MimeMultipartParser parser = new MimeMultipartParser(boundary, ParserData.MinMessageSize);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new MimeMultipartParser("-", ParserData.MinMessageSize - 1),
                "maxMessageSize", ParserData.MinMessageSize.ToString(), ParserData.MinMessageSize - 1);

            foreach (string empty in TestData.EmptyStrings)
            {
                Assert.ThrowsArgument(() => { new MimeMultipartParser(empty, ParserData.MinMessageSize); }, "boundary", allowDerivedExceptions: true);
            }

            Assert.ThrowsArgument(() => { new MimeMultipartParser("trailingspace ", ParserData.MinMessageSize); }, "boundary");

            Assert.ThrowsArgumentNull(() => { new MimeMultipartParser(null, ParserData.MinMessageSize); }, "boundary");
        }

        [Fact]
        public void MimeMultipartParser_ThrowsOnTooBigBoundary()
        {
            string maxLegalBoundary = new string('a', 246);
            MimeMultipartParser parser = new MimeMultipartParser(maxLegalBoundary, ParserData.MinMessageSize);

            string minIllegalBoundary = new string('a', 247);
            Assert.ThrowsArgumentLessThanOrEqualTo(() => new MimeMultipartParser(minIllegalBoundary, ParserData.MinMessageSize),
                "boundary", "246", "247");
        }

        [Fact]
        public void MultipartParserNullBuffer()
        {
            MimeMultipartParser parser = CreateMimeMultipartParser("-", 128);

            int bytesConsumed = 0;
            ArraySegment<byte> out1;
            ArraySegment<byte> out2;
            bool isFinal;
            Assert.ThrowsArgumentNull(() => { parser.ParseBuffer(null, 0, ref bytesConsumed, out out1, out out2, out isFinal); }, "buffer");
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public void MultipartParserEmptyBuffer(string boundary)
        {
            byte[] data = CreateBuffer(boundary);

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary);


                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(2, bodyParts.Count);
                Assert.Equal(0, bodyParts[0].Length);
                Assert.Equal(0, bodyParts[1].Length);
            }
        }

        [Theory]
        [TestDataSet(
            typeof(MimeMultipartParserTests), "Boundaries",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "SingleShortBodies")]
        public void MultipartParserSingleShortBodyPart(string boundary, bool withExtraWhitespace, bool withExtraCRLF, string singleShortBody)
        {
            byte[] data = CreateBuffer(boundary, withExtraWhitespace, withExtraCRLF, singleShortBody);

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(2, bodyParts.Count);
                Assert.Equal(0, bodyParts[0].Length);
                Assert.Equal(singleShortBody, bodyParts[1]);
            }
        }

        [Theory]
        [TestDataSet(
            typeof(MimeMultipartParserTests), "Boundaries",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "MultipleShortBodies")]
        public void MultipartParserMultipleShortBodyParts(string boundary, bool withExtraWhitespace, bool withExtraCRLF, string[] multipleShortBodies)
        {
            byte[] data = CreateBuffer(boundary, withExtraWhitespace, withExtraCRLF, multipleShortBodies);

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(multipleShortBodies.Length + 1, bodyParts.Count);
                Assert.Equal(0, bodyParts[0].Length);

                for (var check = 0; check < multipleShortBodies.Length; check++)
                {
                    Assert.Equal(multipleShortBodies[check], bodyParts[check + 1]);
                }
            }
        }


        [Theory]
        [TestDataSet(
            typeof(MimeMultipartParserTests), "Boundaries",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "SingleLongBodies")]
        public void MultipartParserSingleLongBodyPart(string boundary, bool withExtraWhitespace, bool withExtraCRLF, string singleLongBody)
        {
            byte[] data = CreateBuffer(boundary, withExtraWhitespace, withExtraCRLF, singleLongBody);

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(2, bodyParts.Count);
                Assert.Equal(0, bodyParts[0].Length);

                Assert.Equal(singleLongBody.Length, bodyParts[1].Length);
                Assert.Equal(singleLongBody, bodyParts[1]);
            }
        }

        [Theory]
        [TestDataSet(
            typeof(MimeMultipartParserTests), "Boundaries",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "MultipleLongBodies")]
        public void MultipartParserMultipleLongBodyParts(string boundary, bool withExtraWhitespace, bool withExtraCRLF, string[] multipleLongBodies)
        {
            byte[] data = CreateBuffer(boundary, withExtraWhitespace, withExtraCRLF, multipleLongBodies);

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(multipleLongBodies.Length + 1, bodyParts.Count);
                Assert.Equal(0, bodyParts[0].Length);

                for (var check = 0; check < multipleLongBodies.Length; check++)
                {
                    Assert.Equal(multipleLongBodies[check], bodyParts[check + 1]);
                }
            }
        }

        [Theory]
        [TestDataSet(
            typeof(MimeMultipartParserTests), "Boundaries",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "TrueAndFalse",
            typeof(MimeMultipartParserTests), "NearBoundaryBodies")]
        public void MultipartParserNearMatches(string boundary, bool withExtraWhitespace, bool withExtraCRLF, string nearBoundaryBody)
        {
            byte[] data = CreateBuffer(boundary, withExtraWhitespace, withExtraCRLF, nearBoundaryBody);

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(2, bodyParts.Count);
                Assert.Equal(0, bodyParts[0].Length);
                Assert.Equal(nearBoundaryBody, bodyParts[1]);
            }
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public void MultipartParserNesting(string boundary)
        {
            for (var nesting = 0; nesting < 16; nesting++)
            {
                string nested = CreateNestedBuffer(nesting);

                byte[] data = CreateBuffer(boundary, nested);

                for (var readSize = 1; readSize <= data.Length; readSize++)
                {
                    MimeMultipartParser parser = CreateMimeMultipartParser(boundary);

                    int totalBytesConsumed;
                    List<string> bodyParts;
                    MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                    Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                    Assert.Equal(data.Length, totalBytesConsumed);

                    Assert.Equal(2, bodyParts.Count);
                    Assert.Equal(0, bodyParts[0].Length);
                    Assert.Equal(nested.Length, bodyParts[1].Length);
                }
            }
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public void MimeMultipartParserTestDataTooBig(string boundary)
        {
            byte[] data = CreateBuffer(boundary);

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary, ParserData.MinMessageSize);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.DataTooBig, state);
                Assert.Equal(ParserData.MinMessageSize, totalBytesConsumed);
            }
        }

        [Fact]
        public void MaxMessageSizeIsExact()
        {
            string boundary = "--A";
            byte[] data = CreateBuffer(boundary, "cool");

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary, data.Length);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, 2, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(2, bodyParts.Count);
                Assert.Empty(bodyParts[0]);
            }
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public async Task MimeMultipartParserTestMultipartContent(string boundary)
        {
            MultipartContent content = new MultipartContent("mixed", boundary);
            content.Add(new StringContent("A"));
            content.Add(new StringContent("B"));
            content.Add(new StringContent("C"));

            MemoryStream memStream = new MemoryStream();
            await content.CopyToAsync(memStream);
            memStream.Position = 0;
            byte[] data = memStream.ToArray();

            for (var readSize = 1; readSize <= data.Length; readSize++)
            {
                MimeMultipartParser parser = CreateMimeMultipartParser(boundary);

                int totalBytesConsumed;
                List<string> bodyParts;
                MimeMultipartParser.State state = ParseBufferInSteps(parser, data, readSize, out bodyParts, out totalBytesConsumed);
                Assert.Equal(MimeMultipartParser.State.BodyPartCompleted, state);
                Assert.Equal(data.Length, totalBytesConsumed);

                Assert.Equal(4, bodyParts.Count);
                Assert.Empty(bodyParts[0]);

                Assert.EndsWith("A", bodyParts[1]);
                Assert.EndsWith("B", bodyParts[2]);
                Assert.EndsWith("C", bodyParts[3]);
            }
        }

        private static MimeMultipartParser CreateMimeMultipartParser(string boundary)
        {
            return new MimeMultipartParser(boundary, MimeMultipartBodyPartParser.DefaultMaxMessageSize);
        }

        private static MimeMultipartParser CreateMimeMultipartParser(string boundary, int minimumLength)
        {
            return new MimeMultipartParser(boundary, minimumLength);
        }

        internal static byte[] CreateBuffer(string boundary, params string[] bodyparts)
        {
            return CreateBuffer(boundary, false, false, bodyparts);
        }

        internal static string CreateNestedBuffer(int count)
        {
            StringBuilder buffer = new StringBuilder("content");

            for (var readSize = 0; readSize < count; readSize++)
            {
                byte[] nested = CreateBuffer("N" + readSize.ToString(), buffer.ToString());
                var message = Encoding.UTF8.GetString(nested);
                buffer.Length = 0;
                buffer.AppendLine(message);
            }

            return buffer.ToString();
        }

        private static byte[] CreateBuffer(string boundary, bool withExtraWhitespace, bool withTrailingCRLF, params string[] bodyparts)
        {
            string whitespace = String.Empty;
            if (withExtraWhitespace)
            {
                whitespace = SP + SP + HTAB + SP;
            }

            StringBuilder message = new StringBuilder();
            message.Append(DashDash + boundary + whitespace + CRLF);
            for (var i = 0; i < bodyparts.Length; i++)
            {
                message.Append(bodyparts[i]);
                if (i < bodyparts.Length - 1)
                {
                    message.Append(CRLF + DashDash + boundary + whitespace + CRLF);
                }
            }

            message.Append(CRLF + DashDash + boundary + DashDash + whitespace);
            if (withTrailingCRLF)
            {
                message.Append(CRLF);
            }

            return Encoding.UTF8.GetBytes(message.ToString());
        }

        private static MimeMultipartParser.State ParseBufferInSteps(MimeMultipartParser parser, byte[] buffer, int readsize, out List<string> bodyParts, out int totalBytesConsumed)
        {
            MimeMultipartParser.State state = MimeMultipartParser.State.Invalid;
            totalBytesConsumed = 0;
            bodyParts = new List<string>();
            bool isFinal = false;
            byte[] currentBodyPart = new byte[32 * 1024];
            int currentBodyLength = 0;

            while (true)
            {
                int size = Math.Min(buffer.Length - totalBytesConsumed, readsize);
                byte[] parseBuffer = new byte[size];
                Buffer.BlockCopy(buffer, totalBytesConsumed, parseBuffer, 0, size);

                int bytesConsumed = 0;
                ArraySegment<byte> out1;
                ArraySegment<byte> out2;
                state = parser.ParseBuffer(parseBuffer, parseBuffer.Length, ref bytesConsumed, out out1, out out2, out isFinal);
                totalBytesConsumed += bytesConsumed;

                Buffer.BlockCopy(out1.Array, out1.Offset, currentBodyPart, currentBodyLength, out1.Count);
                currentBodyLength += out1.Count;

                Buffer.BlockCopy(out2.Array, out2.Offset, currentBodyPart, currentBodyLength, out2.Count);
                currentBodyLength += out2.Count;

                if (state == MimeMultipartParser.State.BodyPartCompleted)
                {
                    var bPart = new byte[currentBodyLength];
                    Buffer.BlockCopy(currentBodyPart, 0, bPart, 0, currentBodyLength);
                    bodyParts.Add(Encoding.UTF8.GetString(bPart));
                    currentBodyLength = 0;
                    if (isFinal)
                    {
                        break;
                    }
                }
                else if (state != MimeMultipartParser.State.NeedMoreData)
                {
                    return state;
                }
            }

            Assert.True(isFinal, "The last segment is not a final segment.");
            return state;
        }

        private static string[] CreateMultipleShortBodies(string format, int iterations)
        {
            string[] result = new string[iterations];
            for (int count = 0; count < iterations; count++)
            {
                result[count] = string.Format(format, Char.ConvertFromUtf32(0x41 + count));
            }
            return result;
        }

        private static string CreateLongString(string msg, string bookend, int iterations)
        {
            StringBuilder longBody = new StringBuilder();
            if (!String.IsNullOrEmpty(bookend))
            {
                longBody.Append(bookend);
            }

            for (int i = 0; i < iterations; i++)
            {
                longBody.Append(msg);
            }

            if (!String.IsNullOrEmpty(bookend))
            {
                longBody.Append(bookend);
            }

            return longBody.ToString();
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/QueryStringMappingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Web.Http;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class QueryStringMappingTests
    {
        public static IEnumerable<string> UriStringsWithoutQuery
        {
            get
            {
                return HttpTestData.UriTestDataStrings.Where((s) => !s.Contains('?'));
            }
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(
                typeof(QueryStringMapping),
                TypeAssert.TypeProperties.IsPublicVisibleClass,
                typeof(MediaTypeMapping));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(HttpTestData), "LegalMediaTypeHeaderValues")]
        public void Constructor(string queryStringParameterName, string queryStringParameterValue, MediaTypeHeaderValue mediaType)
        {
            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            Assert.Equal(queryStringParameterName, mapping.QueryStringParameterName);
            Assert.Equal(queryStringParameterValue, mapping.QueryStringParameterValue);
            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "MediaType failed to set.");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeHeaderValues",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void ConstructorThrowsWithEmptyQueryParameterName(MediaTypeHeaderValue mediaType, string queryStringParameterName)
        {
            Assert.ThrowsArgumentNull(() => new QueryStringMapping(queryStringParameterName, "json", mediaType), "queryStringParameterName");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeHeaderValues",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void ConstructorThrowsWithEmptyQueryParameterValue(MediaTypeHeaderValue mediaType, string queryStringParameterValue)
        {
            Assert.ThrowsArgumentNull(() => new QueryStringMapping("query", queryStringParameterValue, mediaType), "queryStringParameterValue");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues")]
        public void ConstructorThrowsWithNullMediaTypeHeaderValue(string queryStringParameterName, string queryStringParameterValue)
        {
            Assert.ThrowsArgumentNull(() => new QueryStringMapping(queryStringParameterName, queryStringParameterValue, (MediaTypeHeaderValue)null), "mediaType");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void Constructor1(string queryStringParameterName, string queryStringParameterValue, string mediaType)
        {
            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            Assert.Equal(queryStringParameterName, mapping.QueryStringParameterName);
            Assert.Equal(queryStringParameterValue, mapping.QueryStringParameterValue);
            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "MediaType failed to set.");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void Constructor1ThrowsWithEmptyQueryParameterName(string mediaType, string queryStringParameterName)
        {
            Assert.ThrowsArgumentNull(() => new QueryStringMapping(queryStringParameterName, "json", mediaType), "queryStringParameterName");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void Constructor1ThrowsWithEmptyQueryParameterValue(string mediaType, string queryStringParameterValue)
        {
            Assert.ThrowsArgumentNull(() => new QueryStringMapping("query", queryStringParameterValue, mediaType), "queryStringParameterValue");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void Constructor1ThrowsWithEmptyMediaType(string queryStringParameterName, string queryStringParameterValue, string mediaType)
        {
            GC.KeepAlive(mediaType); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            Assert.ThrowsArgumentNull(() => new QueryStringMapping(queryStringParameterName, queryStringParameterValue, (MediaTypeHeaderValue)null), "mediaType");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(QueryStringMappingTests), "UriStringsWithoutQuery")]
        public void TryMatchMediaTypeReturnsMatchWithQueryStringParameterNameAndValueInUri(string queryStringParameterName, string queryStringParameterValue, string mediaType, string uriBase)
        {
            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            string uri = uriBase + "?" + queryStringParameterName + "=" + queryStringParameterValue;
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(QueryStringMappingTests), "UriStringsWithoutQuery")]
        public void TryMatchMediaTypeReturnsZeroWithQueryStringParameterNameNotInUri(string queryStringParameterName, string queryStringParameterValue, string mediaType, string uriBase)
        {
            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            string uri = uriBase + "?" + "not" + queryStringParameterName + "=" + queryStringParameterValue;
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(QueryStringMappingTests), "UriStringsWithoutQuery")]
        public void TryMatchMediaTypeReturnsZeroWithQueryStringParameterValueNotInUri(string queryStringParameterName, string queryStringParameterValue, string mediaType, string uriBase)
        {
            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            string uri = uriBase + "?" + queryStringParameterName + "=" + "not" + queryStringParameterValue;
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void TryMatchMediaTypeThrowsWithNullHttpRequestMessage(string queryStringParameterName, string queryStringParameterValue, string mediaType)
        {
            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            Assert.ThrowsArgumentNull(() => mapping.TryMatchMediaType(request: null), "request");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalQueryStringParameterNames",
            typeof(HttpTestData), "LegalQueryStringParameterValues",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void TryMatchMediaTypeThrowsWithNullUriInHttpRequestMessage(string queryStringParameterName, string queryStringParameterValue, string mediaType)
        {
            QueryStringMapping mapping = new QueryStringMapping(queryStringParameterName, queryStringParameterValue, mediaType);
            string errorMessage = Error.Format(Properties.Resources.NonNullUriRequiredForMediaTypeMapping, typeof(QueryStringMapping).Name);
            Assert.Throws<InvalidOperationException>(() => mapping.TryMatchMediaType(new HttpRequestMessage()), errorMessage);
        }

        [Theory]
        [InlineData("nAmE", "VaLuE", "name=value")]
        [InlineData("Format", "Xml", "format=xml")]
        public void TryMatchMediaTypeIsCaseInsensitive(string name, string value, string query)
        {
            QueryStringMapping mapping = new QueryStringMapping(name, value, "application/json");
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/?" + query);
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/RequestHeaderMappingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class RequestHeaderMappingTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(
                typeof(RequestHeaderMapping),
                TypeAssert.TypeProperties.IsPublicVisibleClass,
                typeof(MediaTypeMapping));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues",
            typeof(HttpTestData), "LegalMediaTypeHeaderValues")]
        public void Constructor(string headerName, string headerValue, MediaTypeHeaderValue mediaType)
        {
            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, StringComparison.CurrentCulture, true, mediaType);
            Assert.Equal(headerName, mapping.HeaderName);
            Assert.Equal(headerValue, mapping.HeaderValue);
            Assert.Equal(StringComparison.CurrentCulture, mapping.HeaderValueComparison);
            Assert.True(mapping.IsValueSubstring);
            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "MediaType failed to set.");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeHeaderValues",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void ConstructorThrowsWithEmptyHeaderName(MediaTypeHeaderValue mediaType, string headerName)
        {
            Assert.ThrowsArgumentNull(() => new RequestHeaderMapping(headerName, "value", StringComparison.CurrentCulture, false, mediaType), "headerName");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeHeaderValues",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void ConstructorThrowsWithEmptyHeaderValue(MediaTypeHeaderValue mediaType, string headerValue)
        {
            Assert.ThrowsArgumentNull(() => new RequestHeaderMapping("name", headerValue, StringComparison.CurrentCulture, false, mediaType), "headerValue");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues")]
        public void ConstructorThrowsWithNullMediaTypeHeaderValue(string headerName, string headerValue)
        {
            Assert.ThrowsArgumentNull(() => new RequestHeaderMapping(headerName, headerValue, StringComparison.CurrentCulture, false, (MediaTypeHeaderValue)null), "mediaType");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues",
            typeof(HttpTestData), "LegalMediaTypeHeaderValues")]
        public void ConstructorThrowsWithInvalidStringComparison(string headerName, string headerValue, MediaTypeHeaderValue mediaType)
        {
            int invalidValue = 999;
            Assert.ThrowsInvalidEnumArgument(() => new RequestHeaderMapping(headerName, headerValue, (StringComparison)invalidValue, false, mediaType),
                "valueComparison", invalidValue, typeof(StringComparison));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void Constructor1(string headerName, string headerValue, string mediaType)
        {
            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, StringComparison.CurrentCulture, true, mediaType);
            Assert.Equal(headerName, mapping.HeaderName);
            Assert.Equal(headerValue, mapping.HeaderValue);
            Assert.Equal(StringComparison.CurrentCulture, mapping.HeaderValueComparison);
            Assert.True(mapping.IsValueSubstring);
            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "MediaType failed to set.");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void Constructor1ThrowsWithEmptyHeaderName(string mediaType, string headerName)
        {
            Assert.ThrowsArgumentNull(() => new RequestHeaderMapping(headerName, "value", StringComparison.CurrentCulture, false, mediaType), "headerName");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void Constructor1ThrowsWithEmptyHeaderValue(string mediaType, string headerValue)
        {
            Assert.ThrowsArgumentNull(() => new RequestHeaderMapping("name", headerValue, StringComparison.CurrentCulture, false, mediaType), "headerValue");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void Constructor1ThrowsWithEmptyMediaType(string headerName, string headerValue, string mediaType)
        {
            Assert.ThrowsArgumentNull(() => new RequestHeaderMapping(headerName, headerValue, StringComparison.CurrentCulture, false, mediaType), "mediaType");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void Constructor1ThrowsWithInvalidStringComparison(string headerName, string headerValue, string mediaType)
        {
            int invalidValue = 999;
            Assert.ThrowsInvalidEnumArgument(
                () => new RequestHeaderMapping(headerName, headerValue, (StringComparison)invalidValue, false, mediaType),
                "valueComparison", invalidValue, typeof(StringComparison));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues",
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(CommonUnitTestDataSets), "Bools")]
        public void TryMatchMediaTypeReturnsTrueWithNameAndValueInRequest(string headerName, string headerValue, string mediaType, bool subset)
        {
            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, StringComparison.Ordinal, subset, mediaType);
            HttpRequestMessage request = new HttpRequestMessage();
            request.Headers.Add(headerName, headerValue);
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalHttpHeaderNames",
            typeof(HttpTestData), "LegalHttpHeaderValues",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void TryMatchMediaTypeReturnsTrueWithNameAndValueSubsetInRequest(string headerName, string headerValue, string mediaType)
        {
            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, StringComparison.Ordinal, true, mediaType);
            HttpRequestMessage request = new HttpRequestMessage();
            request.Headers.Add(headerName, "prefix" + headerValue);
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));

            request = new HttpRequestMessage();
            request.Headers.Add(headerName, headerValue + "postfix");
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));

            request = new HttpRequestMessage();
            request.Headers.Add(headerName, "prefix" + headerValue + "postfix");
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
           typeof(HttpTestData), "LegalHttpHeaderNames",
           typeof(HttpTestData), "LegalHttpHeaderValues",
           typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void TryMatchMediaTypeReturnsFalseWithNameNotInRequest(string headerName, string headerValue, string mediaType)
        {
            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, StringComparison.Ordinal, false, mediaType);
            HttpRequestMessage request = new HttpRequestMessage();
            request.Headers.Add("prefix" + headerName, headerValue);
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));

            request = new HttpRequestMessage();
            request.Headers.Add(headerName + "postfix", headerValue);
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));

            request = new HttpRequestMessage();
            request.Headers.Add("prefix" + headerName + "postfix", headerValue);
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
           typeof(HttpTestData), "LegalHttpHeaderNames",
           typeof(HttpTestData), "LegalHttpHeaderValues",
           typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void TryMatchMediaTypeReturnsFalseWithValueNotInRequest(string headerName, string headerValue, string mediaType)
        {
            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, StringComparison.Ordinal, false, mediaType);
            HttpRequestMessage request = new HttpRequestMessage();
            request.Headers.Add(headerName, "prefix" + headerValue);
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));

            request = new HttpRequestMessage();
            request.Headers.Add(headerName, headerValue + "postfix");
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));

            request = new HttpRequestMessage();
            request.Headers.Add(headerName, "prefix" + headerValue + "postfix");
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
           typeof(HttpTestData), "LegalHttpHeaderNames",
           typeof(HttpTestData), "LegalHttpHeaderValues",
           typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void TryMatchMediaTypeThrowsWithNullHttpRequestMessage(string headerName, string headerValue, string mediaType)
        {
            RequestHeaderMapping mapping = new RequestHeaderMapping(headerName, headerValue, StringComparison.CurrentCulture, true, mediaType);
            Assert.ThrowsArgumentNull(() => mapping.TryMatchMediaType(request: null), "request");
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/SerializerConsistencyTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.Serialization;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    // Tests for ensuring the serializers behave consistently in various cases.
    // This is important for conneg.
    public class SerializerConsistencyTests
    {
        [Fact]
        public Task PartialContract()
        {
            var c = new PartialDataContract {
                PropertyWithAttribute = "one",
#if !Testing_NetStandard1_3 // Xml formatter ignores DCS attributes but JSON one does not in netstandard1.3.
                PropertyWithoutAttribute = "false"
#endif
            };
            return SerializerConsistencyHepers.TestAsync(c);
        }

        [Fact]
        public Task ClassWithFields()
        {
            var c1 = new ClassWithFields { Property = "prop" };
            c1.SetField("field");
            return SerializerConsistencyHepers.TestAsync(c1);
        }

        [Fact]
        public Task PrivateProperty()
        {
            var source2 = new PrivateProperty { FirstName = "John", LastName = "Smith" };
            source2.SetItem("shoes");
            return SerializerConsistencyHepers.TestAsync(source2);
        }

        [Fact]
        public Task NormalClass()
        {
            var source = new NormalClass { FirstName = "John", LastName = "Smith", Item = "Socks" };
            return SerializerConsistencyHepers.TestAsync(source);
        }

        [Fact]
        public Task InheritedProperties()
        {
            // Will we pick up inherited properties from a base object?
            BaseClass source = new DerivedClass { Property = "base", DerivedProperty = "derived" };
            source.SetField("private");
            return SerializerConsistencyHepers.TestAsync(source, typeof(DerivedClass));
        }

        [Fact]
        public Task NullEmptyWhitespaceString()
        {
            NormalClass source = new NormalClass { FirstName = string.Empty, LastName = null, Item = "   " };

            return SerializerConsistencyHepers.TestAsync(source);
        }

#if !Testing_NetStandard1_3 // XmlSerializer is unable to write XML for a dictionary.
        [Fact]
        public Task Dictionary()
        {
            var dict = new Dictionary<string, int>();
            dict["one"] = 1;
            dict["two"] = 2;

            return SerializerConsistencyHepers.TestAsync(dict);
        }
#endif

        [Fact]
        public Task Array()
        {
            string[] array = new string[] { "First", "Second", "Last" };

            return SerializerConsistencyHepers.TestAsync(array);
        }

#if !Testing_NetStandard1_3 // XmlSerializer is unable to read XML for interfaces.
        [Fact]
        public async Task ArrayInterfaces()
        {
            string[] array = new string[] { "First", "Second", "Last" };

            await SerializerConsistencyHepers.TestAsync(array, typeof(IList<string>));
            await SerializerConsistencyHepers.TestAsync(array, typeof(ICollection<string>));
            await SerializerConsistencyHepers.TestAsync(array, typeof(IEnumerable<string>));
        }

        [Fact]
        public Task Linq()
        {
            var l = from i in Enumerable.Range(1, 10) where i > 5 select i * i;

            // Runtime type of a linq expression is some derived Linq type which we can't deserialize to.
            // So explicitly call out IEnumerable<T>
            return SerializerConsistencyHepers.TestAsync(l, typeof(IEnumerable<int>));
        }
#endif

        [Fact]
        public Task StaticProps()
        {
            ClassWithStaticProperties source = new ClassWithStaticProperties();

            return SerializerConsistencyHepers.TestAsync(source);
        }
    }

    // public class, public properties
    public class NormalClass
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public string Item { get; set; }
    }

    public class ClassWithStaticProperties
    {
        public string InstanceProp { get; set; }
        public static string StaticProp
        {
            get
            {
                Assert.True(false, "serializers should never call static properties");
                return string.Empty;
            }
            set
            {
                Assert.True(false, "serializers should never call static properties");
                throw new InvalidOperationException(); // assert already threw
            }
        }
    }

    [DataContract]
    public class PartialDataContract
    {
        [DataMember]
        public string PropertyWithAttribute { get; set; }

#if !Testing_NetStandard1_3 // Xml formatter ignores DCS attributes but JSON one does not in netstandard1.3.
        // no attribute here
        public string PropertyWithoutAttribute { get; set; }
#endif
    }

    public class PrivateProperty // with private field
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
        private string Item { get; set; }

        public void SetItem(string item)
        {
            this.Item = item;
        }
    }

    public class ClassWithFields
    {
        public string Property { get; set; }
        private string Field;

        public void SetField(string field)
        {
            this.Field = field;
        }
    }

    public class BaseClass
    {
        private string PrivateField;
        public string Property { get; set; }

        public void SetField(string field)
        {
            PrivateField = field;
        }
    }

    public class DerivedClass : BaseClass
    {
        public string DerivedProperty { get; set; }
    }

    // Helpers for performing consistency checks with the serializers.
    class SerializerConsistencyHepers
    {
        // Exercise the various serialization paths to verify that the default serializers behave consistently.
        public static Task TestAsync(object source)
        {
            Type tSource = source.GetType();
            return TestAsync(source, tSource);
        }

        // Allow explicitly passing in the type that gets passed to the serializer.
        // The expectation is that the type can be read and written with both serializers.
        public static Task TestAsync(object source, Type tSource)
        {
            return TestAsync(source, tSource, tSource);
        }

        // tSourceWrite - the type we use for the initial write.  This can be specific, and a 1-way serializable type (eg, a linq expression).
        // tSourceRead - the type that we read back as. This should be more general because we need to instantiate it.
        public static async Task TestAsync(object source, Type tSourceWrite, Type tSourceRead)
        {
            // Apply consistency chceks. This interleaves the results between the formatters.
            // It doesn't actually matter specifically what the formatter does, it just matters that they're consistent.
            // This will test various transitions between C#->JSON, JSON->C#, C#->XML, and XML->C#.
            // We can't compare C# objects, but we can compare the textual representation from XML and JSON.
            MediaTypeFormatter xmlFormatter = new MediaTypeFormatterCollection().XmlFormatter;
            MediaTypeFormatter jsonFor = new MediaTypeFormatterCollection().JsonFormatter;

            MemoryStream blobJson = await WriteAsync(source, tSourceWrite, jsonFor); // C# --> JSON
            MemoryStream blobXml = await WriteAsync(source, tSourceWrite, xmlFormatter); // C# --> XML

            object obj2 = await ReadAsync(blobJson, tSourceRead, jsonFor); // C# --> JSON --> C#
            object obj1 = await ReadAsync(blobXml, tSourceRead, xmlFormatter); // C# --> XML --> C#

            // We were able to round trip the source object through both formatters.
            // Now see if the resulting object is the same.

            // Check C# --> XML --> C#

            var blobXml2 = await WriteAsync(obj1, tSourceRead, xmlFormatter);  // C# --> XML --> C# --> XML
            var blobJson2 = await WriteAsync(obj1, tSourceRead, jsonFor); // C# --> XML --> C# --> JSON

            // Ensure that C#->XMl and  C#->XML->C#->XML give us the same result..
            Compare(blobXml, blobXml2);

            // Ensure that C#->Json and C#->XML->C#->Json give us the same result
            Compare(blobJson, blobJson2);

            // Check C# --> JSON --> C#

            var blobXml3 = await WriteAsync(obj2, tSourceRead, xmlFormatter);  // C# --> JSON --> C# --> XML
            var blobJson3 = await WriteAsync(obj2, tSourceRead, jsonFor); // C# --> JSON --> C# --> JSON

            // Ensure that C#->XML and C#->JSON->C#->XML are the same
            Compare(blobXml, blobXml3);

            // Ensure that C#->JSon and C#->JSON->C#->JSON are the same.
            Compare(blobJson, blobJson3);
        }

        // Compare if 2 streams have the same contents.
        private static void Compare(MemoryStream ms1, MemoryStream ms2)
        {
            string s1 = ToString(ms1);
            string s2 = ToString(ms2);

            Assert.Equal(s1, s2);
        }

        // Given a memory stream (which is representing a textual serialization format), get the string.
        private static string ToString(MemoryStream ms)
        {
            byte[] b = ms.GetBuffer();
            return System.Text.Encoding.UTF8.GetString(b, 0, (int)ms.Length);
        }

        private static async Task<object> ReadAsync(MemoryStream ms, Type tSource, MediaTypeFormatter formatter)
        {
            bool f = formatter.CanReadType(tSource);
            Assert.True(f);

            object o = await formatter.ReadFromStreamAsync(tSource, ms, content: null, formatterLogger: null);
            Assert.True(tSource.IsAssignableFrom(o.GetType()));

            return o;
        }

        private static async Task<MemoryStream> WriteAsync(object obj, Type tSource, MediaTypeFormatter formatter)
        {
            bool f = formatter.CanWriteType(tSource);
            Assert.True(f);

            MemoryStream ms = new MemoryStream();

            await formatter.WriteToStreamAsync(tSource, obj, ms, content: null, transportContext: null);

            ms.Position = 0;
            return ms;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/StringComparisonHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class StringComparisonHelperTest : EnumHelperTestBase<StringComparison>
    {
        public StringComparisonHelperTest()
            : base(StringComparisonHelper.IsDefined, StringComparisonHelper.Validate, (StringComparison)999)
        {
        }

#if Testing_NetStandard1_3 // InvariantCulture and InvariantCultureIgnoreCase case are not supported in netstandard1.3 project
        protected override bool ValueExistsForFramework(StringComparison value)
        {
            return !(value == StringComparison.InvariantCulture || value == StringComparison.InvariantCultureIgnoreCase);
        }
#endif
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/StringWithQualityHeaderValueComparerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class StringWithQualityHeaderValueComparerTests
    {
        public static TheoryDataSet<string, string> EqualValues
        {
            get
            {
                return new TheoryDataSet<string, string>
                {
                    { "value", "value" },
                    { "value", "VALUE" },
                    { "value", "value;q=1" },
                    { "value", "value; q=1" },
                    { "value", "value;q=1.0" },
                    { "value", "value; q=1.0" },
                    { "value", "value; q=1.00000" },
                    { "value; q=0.5", "value; q=0.5" },
                    { "value; q=1.0", "value; q=1.0" },
                    { "*", "*" },
                    { "*", "*;q=1" },
                    { "*", "*; q=1" },
                    { "*", "*;q=1.0" },
                    { "*", "*; q=1.0" },
                    { "*; q=0.5", "*; q=0.5" },
                    { "*; q=1.0", "*; q=1.0" },
                    { "value1", "value2" },
                    { "value1", "value2;q=1" },
                    { "value1", "value2; q=1" },
                    { "value1", "value2;q=1.0" },
                    { "value1", "value2; q=1.0" },
                };
            }
        }

        public static TheoryDataSet<string, string> NonEqualValues
        {
            get
            {
                return new TheoryDataSet<string, string>
                {
                    { "value; q=0.5", "value" },
                    { "value; q=0.5", "value; q=1.0" },
                    { "value1; q=0.5", "value2; q=1.0" },
                    { "*", "value1" },
                    { "*;q=1", "value1" },
                    { "*; q=1", "value1" },
                    { "*;q=1.0", "value1" },
                    { "*; q=1.0", "value1" },
                    { "*; q=0.5", "value1; q=0.5" },
                    { "*; q=1.0", "value1; q=1.0" },
                };
            }
        }

        public static TheoryDataSet<string[], string[]> BeforeAfterSortedValues
        {
            get
            {
                return new TheoryDataSet<string[], string[]>
                {
                    {
                        new string[]
                        {
                            "text",
                            "text;q=1.0",
                            "text",
                            "text;q=0",
                            "*;q=0.8",
                            "*;q=1",
                            "text;q=0.8",
                            "*;q=0.6",
                            "text;q=1.0",
                            "*;q=0.4",
                            "text;q=0.6",
                        }, 
                        new string[]
                        {
                            "text",
                            "text;q=1.0",
                            "text",
                            "text;q=1.0",
                            "*;q=1",
                            "text;q=0.8",
                            "*;q=0.8",
                            "text;q=0.6",
                            "*;q=0.6",
                            "*;q=0.4",
                            "text;q=0",
                        }
                    }
                };
            }
        }

        [Fact]
        public void StaticComparerReturnsSameInstance()
        {
            StringWithQualityHeaderValueComparer comparer1 = StringWithQualityHeaderValueComparer.QualityComparer;
            StringWithQualityHeaderValueComparer comparer2 = StringWithQualityHeaderValueComparer.QualityComparer;

            Assert.NotNull(comparer1);
            Assert.Same(comparer1, comparer2);
        }

        [Theory]
        [PropertyData("EqualValues")]
        public void ComparerReturnsZeroForEqualValues(string stringWithQuality1, string stringWithQuality2)
        {
            // Arrange
            StringWithQualityHeaderValueComparer comparer = StringWithQualityHeaderValueComparer.QualityComparer;

            // Act
            StringWithQualityHeaderValue stringWithQualityHeaderValue1 = StringWithQualityHeaderValue.Parse(stringWithQuality1);
            StringWithQualityHeaderValue stringWithQualityHeaderValue2 = StringWithQualityHeaderValue.Parse(stringWithQuality2);

            // Assert
            Assert.Equal(0, comparer.Compare(stringWithQualityHeaderValue1, stringWithQualityHeaderValue2));
            Assert.Equal(0, comparer.Compare(stringWithQualityHeaderValue2, stringWithQualityHeaderValue1));
        }

        [Theory]
        [PropertyData("NonEqualValues")]
        public void ComparerReturnsNonZeroForNonEqualValues(string stringWithQuality1, string stringWithQuality2)
        {
            // Arrange
            StringWithQualityHeaderValueComparer comparer = StringWithQualityHeaderValueComparer.QualityComparer;

            // Act
            StringWithQualityHeaderValue stringWithQualityHeaderValue1 = StringWithQualityHeaderValue.Parse(stringWithQuality1);
            StringWithQualityHeaderValue stringWithQualityHeaderValue2 = StringWithQualityHeaderValue.Parse(stringWithQuality2);

            // Assert
            Assert.Equal(-1, comparer.Compare(stringWithQualityHeaderValue1, stringWithQualityHeaderValue2));
            Assert.Equal(1, comparer.Compare(stringWithQualityHeaderValue2, stringWithQualityHeaderValue1));
        }

        [Theory]
        [PropertyData("BeforeAfterSortedValues")]
        public void ComparerSortsListCorrectly(string[] unsorted, string[] expectedSorted)
        {
            // Arrange
            IEnumerable<StringWithQualityHeaderValue> unsortedValues =
                unsorted.Select(u => StringWithQualityHeaderValue.Parse(u));

            IEnumerable<StringWithQualityHeaderValue> expectedSortedValues =
                expectedSorted.Select(u => StringWithQualityHeaderValue.Parse(u));

            // Act
            IEnumerable<StringWithQualityHeaderValue> actualSorted = unsortedValues.OrderByDescending(m => m, StringWithQualityHeaderValueComparer.QualityComparer);

            // Assert
            Assert.True(expectedSortedValues.SequenceEqual(actualSorted));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/XmlHttpRequestHeaderMappingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class XmlHttpRequestHeaderMappingTest
    {
        // HttpRequestMessage request, double expectedMatch
        public static TheoryDataSet<HttpRequestMessage, double> TryMatchMediaTypeData
        {
            get
            {
                return new TheoryDataSet<HttpRequestMessage, double>()
                {
                    { CreateXhrRequest(), 1.0 },
                    { CreateXhrRequest("*/*"), 1.0 },
                    { CreateXhrRequest("*/*; q=0.5"), 1.0 },

                    { CreateXhrRequest("text/*"), 0.0 },
                    { CreateXhrRequest("text/*; q=0.5"), 0.0 },
                    { CreateXhrRequest("application/xml"), 0.0 },
                    { CreateXhrRequest("application/xml; q=0.5"), 0.0 },
                    { CreateXhrRequest("text/test", "*/*; q=0.5"), 0.0 },
                };
            }
        }

        private static HttpRequestMessage CreateXhrRequest(params string[] acceptHeaders)
        {
            HttpRequestMessage request = new HttpRequestMessage();
            request.Headers.Add("X-Requested-With", "XmlHttpRequest");
            foreach (string accept in acceptHeaders)
            {
                request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse(accept));
            }
            return request;
        }

        [Fact]
        public void Constructor_Initializes()
        {
            XmlHttpRequestHeaderMapping mapping = new XmlHttpRequestHeaderMapping();
            Assert.Equal("x-requested-with", mapping.HeaderName);
            Assert.Equal("XMLHttpRequest", mapping.HeaderValue);
            Assert.Equal(StringComparison.OrdinalIgnoreCase, mapping.HeaderValueComparison);
            Assert.True(mapping.IsValueSubstring);
            Assert.Equal(MediaTypeConstants.ApplicationJsonMediaType, mapping.MediaType);
        }

        [Fact]
        public void TryMatchMediaType_ThrowsOnNull()
        {
            XmlHttpRequestHeaderMapping mapping = new XmlHttpRequestHeaderMapping();
            Assert.ThrowsArgumentNull(() => mapping.TryMatchMediaType(null), "request");
        }

        [Theory]
        [PropertyData("TryMatchMediaTypeData")]
        public void TryMatchMediaType_Matches(HttpRequestMessage request, double expectedMatch)
        {
            // Arrange
            XmlHttpRequestHeaderMapping mapping = new XmlHttpRequestHeaderMapping();

            // Act
            double actualMatch = mapping.TryMatchMediaType(request);

            // Assert
            Assert.Equal(expectedMatch, actualMatch);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/XmlMediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
using Microsoft.TestCommon;
using Moq;
using Newtonsoft.Json;

namespace System.Net.Http.Formatting
{
    public class XmlMediaTypeFormatterTests : MediaTypeFormatterTestBase<XmlMediaTypeFormatter>
    {
        // Test data which should round-trip using a media type that includes type information.  A representative
        // sample only; avoids types DataContractJsonSerializer fails to round trip (e.g. Guid, Uint16).  May require
        // known types or similar (de)serializer configuration.
        public static readonly RefTypeTestData<object> BunchOfTypedObjectsTestData = new RefTypeTestData<object>(
            () => new List<object>
            {
                null,
                String.Empty,
                "This is a string",
                false,
                true,
                Double.MinValue,
                Double.MaxValue,
                Int32.MinValue,
                Int32.MaxValue,
                Int64.MinValue,
                Int64.MaxValue,
#if !NETCOREAPP2_1 // DBNull not serializable on .NET Core 2.1.
                DBNull.Value,
#endif
            });

        public static readonly TheoryDataSet<Type> AFewValidTypes = new()
        {
            typeof(bool),
            typeof(int),
            typeof(string),
        };

        public static IEnumerable<TestData> BunchOfTypedObjectsTestDataCollection
        {
            get { return new TestData[] { BunchOfTypedObjectsTestData, }; }
        }

        public override IEnumerable<MediaTypeHeaderValue> ExpectedSupportedMediaTypes
        {
            get { return HttpTestData.StandardXmlMediaTypes; }
        }

        public override IEnumerable<Encoding> ExpectedSupportedEncodings
        {
            get { return HttpTestData.StandardEncodings; }
        }

        public override byte[] ExpectedSampleTypeByteRepresentation
        {
            get { return ExpectedSupportedEncodings.ElementAt(0).GetBytes("<DataContractSampleType xmlns:i=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns=\"http://schemas.datacontract.org/2004/07/System.Net.Http.Formatting\"><Number>42</Number></DataContractSampleType>"); }
        }

        [Fact]
        void CopyConstructor()
        {
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter()
            {
                Indent = true,
                MaxDepth = 42,
                UseXmlSerializer = true
            };

            TestXmlMediaTypeFormatter derivedFormatter = new TestXmlMediaTypeFormatter(formatter);

            Assert.Equal(formatter.Indent, derivedFormatter.Indent);
            Assert.Equal(formatter.MaxDepth, derivedFormatter.MaxDepth);
            Assert.Equal(formatter.UseXmlSerializer, derivedFormatter.UseXmlSerializer);
        }

        [Fact]
        public void DefaultMediaType_ReturnsApplicationXml()
        {
            MediaTypeHeaderValue mediaType = XmlMediaTypeFormatter.DefaultMediaType;
            Assert.NotNull(mediaType);
            Assert.Equal("application/xml", mediaType.MediaType);
        }

        [Fact]
        public void MaxDepthReturnsCorrectValue()
        {
            Assert.Reflection.IntegerProperty(
                new XmlMediaTypeFormatter(),
                f => f.MaxDepth,
                expectedDefaultValue: 256,
                minLegalValue: 1,
                illegalLowerValue: 0,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 10);
        }

#if !Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Fact]
        public async Task ReadDeeplyNestedObjectThrows()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter() { MaxDepth = 1 };

            MemoryStream stream = new MemoryStream();
            await formatter.WriteToStreamAsync(typeof(SampleType), new SampleType() { Number = 1 }, stream, null, null);
            stream.Position = 0;
            await Assert.ThrowsAsync<SerializationException>(() => formatter.ReadFromStreamAsync(typeof(SampleType), stream, null, null));
        }
#endif

        [Fact]
        public void Indent_RoundTrips()
        {
            Assert.Reflection.BooleanProperty(
                new XmlMediaTypeFormatter(),
                c => c.Indent,
                expectedDefaultValue: false);
        }

        [Fact]
        public void UseXmlSerializer_RoundTrips()
        {
            Assert.Reflection.BooleanProperty(
                new XmlMediaTypeFormatter(),
                c => c.UseXmlSerializer,
                expectedDefaultValue: false);
        }

#if !Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Theory]
        [InlineData(typeof(IEnumerable<string>))]
        [InlineData(typeof(IQueryable<string>))]
        public async Task UseXmlFormatterWithNull(Type type)
        {
            XmlMediaTypeFormatter xmlFormatter = new XmlMediaTypeFormatter { UseXmlSerializer = false };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(xmlFormatter.WriteToStreamAsync(type, null, memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("nil=\"true\""),
                "Null value should be serialized as nil.");
            Assert.True(serializedString.ToLower().Contains("arrayofstring"),
                "It should be serialized out as an array of string.");
        }

        [Fact]
        public async Task UseXmlSerializer_False()
        {
            XmlMediaTypeFormatter xmlFormatter = new XmlMediaTypeFormatter { UseXmlSerializer = false };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(xmlFormatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("DataContractSampleType"),
                "SampleType should be serialized with data contract name DataContractSampleType because we're using DCS.");
            Assert.False(serializedString.Contains("version=\"1.0\" encoding=\"utf-8\""),
                    "Using DCS should not emit the xml declaration by default.");
            Assert.False(serializedString.Contains("\r\n"), "Using DCS should emit data without indentation by default.");
        }

        [Fact]
        public async Task UseXmlSerializer_False_Indent()
        {
            XmlMediaTypeFormatter xmlFormatter = new XmlMediaTypeFormatter { UseXmlSerializer = false, Indent = true };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(xmlFormatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("\r\n"), "Using DCS with indent set to true should emit data with indentation.");
        }
#endif

        [Fact]
        public void SetSerializer_ThrowsWithNullType()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(string));
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(null, xmlSerializer); }, "type");
        }

        [Fact]
        public void SetSerializer_ThrowsWithNullSerializer()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(typeof(string), (XmlSerializer)null); }, "serializer");
        }

        [Fact]
        public void SetSerializer1_ThrowsWithNullSerializer()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer<string>((XmlSerializer)null); }, "serializer");
        }

        [Fact]
        public void SetSerializer2_ThrowsWithNullType()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            XmlObjectSerializer xmlObjectSerializer = new DataContractSerializer(typeof(string));
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(null, xmlObjectSerializer); }, "type");
        }

        [Fact]
        public void SetSerializer2_ThrowsWithNullSerializer()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(typeof(string), (XmlObjectSerializer)null); }, "serializer");
        }

        [Fact]
        public void SetSerializer3_ThrowsWithNullSerializer()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer<string>((XmlSerializer)null); }, "serializer");
        }

        [Fact]
        public void RemoveSerializer_ThrowsWithNullType()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.RemoveSerializer(null); }, "type");
        }

#if !Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Fact]
        public async Task FormatterThrowsOnWriteWhenOverridenCreateFails()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerXmlSerializer);
        }

        [Fact]
        public async Task FormatterThrowsOnWriteWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerXmlSerializer);
        }

        [Fact]
        public async Task FormatterThrowsOnReadWhenOverridenCreateFails()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);
            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerXmlSerializer);
        }

        [Fact]
        public async Task FormatterThrowsOnReadWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);

            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.NotNull(formatter.InnerDataContractSerializer);
            Assert.Null(formatter.InnerXmlSerializer);
        }
#endif

        [Fact]
        public async Task XmlSerializerFormatterThrowsOnWriteWhenOverridenCreateFails()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;
            formatter.UseXmlSerializer = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerXmlSerializer);
        }

        [Fact]
        public async Task XmlSerializerFormatterThrowsOnWriteWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;
            formatter.UseXmlSerializer = true;

            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);

            // Act & Assert
            Func<Task> action = () => formatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null);
            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerXmlSerializer);
        }

        [Fact]
        public async Task XmlSerializerFormatterThrowsOnReadWhenOverridenCreateFails()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ThrowAnExceptionOnCreate = true;
            formatter.UseXmlSerializer = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);
            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerXmlSerializer);
        }

        [Fact]
        public async Task XmlSerializerFormatterThrowsOnReadWhenOverridenCreateReturnsNull()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();

            formatter.ReturnNullOnCreate = true;
            formatter.UseXmlSerializer = true;

            byte[] array = Encoding.UTF8.GetBytes("foo");
            MemoryStream memoryStream = new MemoryStream(array);

            HttpContent content = new StringContent("foo");

            // Act & Assert
            Func<Task> action = () => formatter.ReadFromStreamAsync(typeof(SampleType), memoryStream, content, null);

            await Assert.ThrowsAsync<InvalidOperationException>(action);

            Assert.Null(formatter.InnerDataContractSerializer);
            Assert.NotNull(formatter.InnerXmlSerializer);
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingXmlSerializer(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsSerializableWithXmlSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
                formatter.SetSerializer(variationType, new XmlSerializer(variationType));

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

        [Theory]
        [TestDataSet(typeof(XmlMediaTypeFormatterTests), "BunchOfTypedObjectsTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingXmlSerializer_ExtraTypes(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsSerializableWithXmlSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
                formatter.SetSerializer(variationType, new XmlSerializer(variationType, new Type[] { typeof(DBNull), }));

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

        // Test alternate null value; this serializer attempts to cast DBNull to variationType so typeof(string) variation fails
        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingXmlSerializer_DBNull()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
            Type variationType = typeof(DBNull);
            formatter.SetSerializer(variationType, new XmlSerializer(variationType));
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
            Assert.Equal(testData, readObj);
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStream_AsyncRoundTripsWriteToStreamUsingDataContractSerializer(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsSerializableWithDataContractSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
                formatter.SetSerializer(variationType, new DataContractSerializer(variationType));

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

        [Theory]
        [TestDataSet(typeof(XmlMediaTypeFormatterTests), "BunchOfTypedObjectsTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStream_AsyncRoundTripsWriteToStreamUsingDataContractSerializer_KnownTypes(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsSerializableWithDataContractSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
                formatter.SetSerializer(variationType, new DataContractSerializer(variationType, new Type[] { typeof(DBNull), }));

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

#if Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_UsingDataContractSerializer_Throws(Type variationType, object testData)
        {
            // Arrange. First, get some data using XmlSerializer.
            bool canSerialize = IsSerializableWithXmlSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                var formatter = new XmlMediaTypeFormatter() { UseXmlSerializer = true };
                using var stream = new MemoryStream();
                using var content = new StringContent(string.Empty);

                await formatter.WriteToStreamAsync(variationType, testData, stream, content, transportContext: null);
                await stream.FlushAsync();
                stream.Position = 0L;

                content.Headers.ContentLength = stream.Length;
                formatter.RemoveSerializer(variationType);
                formatter.UseXmlSerializer = false;

                // Act & Assert
                await Assert.ThrowsAsync<PlatformNotSupportedException>(() =>
                    formatter.ReadFromStreamAsync(variationType, stream, content, formatterLogger: null),
                    "Unable to validate types on this platform when UseXmlSerializer is 'false'. Please set " +
                    "UseXmlSerializer or move to a supported platform, one where the .NET Standard 2.0 assembly " +
                    "is usable.");
            }
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection", RoundTripDataVariations)]
        public async Task WriteToStreamAsync_UsingDataContractSerializer_Throws(Type variationType, object testData)
        {
            // Arrange
            var formatter = new XmlMediaTypeFormatter();
            using var stream = new MemoryStream();
            using var content = new StringContent(string.Empty);

            // Act & Assert
            await Assert.ThrowsAsync<PlatformNotSupportedException>(() =>
                formatter.WriteToStreamAsync(variationType, testData, stream, content, transportContext: null),
                "Unable to validate types on this platform when UseXmlSerializer is 'false'. Please set " +
                "UseXmlSerializer or move to a supported platform, one where the .NET Standard 2.0 assembly " +
                "is usable.");
        }

#else
#if !NETCOREAPP2_1 // DBNull not serializable on .NET Core 2.1.
        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingDataContractSerializer_DBNull()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
            Type variationType = typeof(DBNull);
            formatter.SetSerializer(variationType, new DataContractSerializer(variationType));
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // DBNull.Value round-trips as either Object or DBNull because serialization includes its type
            Assert.Equal(testData, readObj);
        }

        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingDataContractSerializer_DBNullAsEmptyString()
        {
            // Arrange
            TestXmlMediaTypeFormatter formatter = new TestXmlMediaTypeFormatter();
            Type variationType = typeof(string);
            formatter.SetSerializer(variationType, new DataContractSerializer(variationType, new Type[] { typeof(DBNull), }));
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);

            // Lower levels convert DBNull.Value to empty string on read
            Assert.Equal(String.Empty, readObj);
        }
#endif

        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();

            string formattedContent = "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">" + content + "</string>";
            string mediaType = string.Format("application/xml; charset={0}", encoding);

            // Act & assert
            return ReadFromStreamAsync_UsesCorrectCharacterEncodingHelper(formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }
#endif

        [Fact]
        public async Task ReadFromStreamAsync_UsesGetDeserializerAndCreateXmlReader()
        {
            Type type = typeof(string);
            string xml = "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">x</string>";
            Stream stream = new MemoryStream(Encoding.UTF8.GetBytes(xml));
            var serializer = new Mock<XmlObjectSerializer>() { CallBase = true };
            var reader = new Mock<XmlReader>() { CallBase = true };
            var formatter = new Mock<XmlMediaTypeFormatter>() { CallBase = true };
            formatter.Setup(f => f.GetDeserializer(type, null)).Returns(serializer.Object);
            formatter.Setup(f => f.CreateXmlReader(stream, null)).Returns(reader.Object);

            await formatter.Object.ReadFromStreamAsync(type, stream, content: null, formatterLogger: null);

            serializer.Verify(s => s.ReadObject(reader.Object));
        }

        [Fact]
        public Task ReadFromStreamAsync_ThrowsException_WhenGetDeserializerReturnsNull()
        {
            Type type = typeof(string);
            string xml = "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">x</string>";
            var formatter = new Mock<XmlMediaTypeFormatter>() { CallBase = true };
            formatter.Setup(f => f.GetDeserializer(type, null)).Returns(null);

            return Assert.ThrowsAsync<InvalidOperationException>(
                () => formatter.Object.ReadFromStreamAsync(type, new MemoryStream(Encoding.UTF8.GetBytes(xml)), content: null, formatterLogger: null),
                "The object returned by GetDeserializer must not be a null value.");
        }

        [Fact]
        public Task ReadFromStreamAsync_ThrowsException_WhenGetDeserializerReturnsInvalidType()
        {
            Type type = typeof(string);
            string xml = "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">x</string>";
            var formatter = new Mock<XmlMediaTypeFormatter>() { CallBase = true };
            formatter.Setup(f => f.GetDeserializer(type, null)).Returns(new JsonSerializer());

            return Assert.ThrowsAsync<InvalidOperationException>(
                () => formatter.Object.ReadFromStreamAsync(type, new MemoryStream(Encoding.UTF8.GetBytes(xml)), content: null, formatterLogger: null),
                "The object of type 'JsonSerializer' returned by GetDeserializer must be an instance of either XmlObjectSerializer or XmlSerializer.");
        }

#if !Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            string formattedContent = "<string xmlns=\"http://schemas.microsoft.com/2003/10/Serialization/\">" + content +
                                      "</string>";
            string mediaType = string.Format("application/xml; charset={0}", encoding);

            // Act & assert
            return WriteToStreamAsync_UsesCorrectCharacterEncodingHelper(formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }
#endif

        [Fact]
        public async Task WriteToStreamAsync_UsesGetSerializerAndCreateXmlWriter()
        {
            Type type = typeof(string);
            object value = "x";
            Stream stream = new MemoryStream();
            var serializer = new Mock<XmlObjectSerializer>() { CallBase = true };
            var writer = new Mock<XmlWriter>() { CallBase = true };
            var formatter = new Mock<XmlMediaTypeFormatter>() { CallBase = true };
            formatter.Setup(f => f.GetSerializer(type, value, null)).Returns(serializer.Object);
            formatter.Setup(f => f.CreateXmlWriter(stream, null)).Returns(writer.Object);

            await formatter.Object.WriteToStreamAsync(type, value, stream, content: null, transportContext: null);

            serializer.Verify(s => s.WriteObject(writer.Object, value));
        }

        [Fact]
        public Task WriteToStreamAsync_ThrowsException_WhenGetSerializerReturnsNull()
        {
            Type type = typeof(string);
            object value = "x";
            var formatter = new Mock<XmlMediaTypeFormatter>() { CallBase = true };
            formatter.Setup(f => f.GetSerializer(type, value, null)).Returns(null);

            return Assert.ThrowsAsync<InvalidOperationException>(
                () => formatter.Object.WriteToStreamAsync(type, value, new MemoryStream(), content: null, transportContext: null),
                "The object returned by GetSerializer must not be a null value.");
        }

        [Fact]
        public Task WriteToStreamAsync_ThrowsException_WhenGetSerializerReturnsInvalidType()
        {
            Type type = typeof(string);
            object value = "x";
            var formatter = new Mock<XmlMediaTypeFormatter>() { CallBase = true };
            formatter.Setup(f => f.GetSerializer(type, value, null)).Returns(new JsonSerializer());

            return Assert.ThrowsAsync<InvalidOperationException>(
                () => formatter.Object.WriteToStreamAsync(type, value, new MemoryStream(), content: null, transportContext: null),
                "The object of type 'JsonSerializer' returned by GetSerializer must be an instance of either XmlObjectSerializer or XmlSerializer.");
        }

        [Fact]
        public void CreateXmlWriter_Uses_WriterSettings()
        {
            // Arrange
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            formatter.WriterSettings.ConformanceLevel = ConformanceLevel.Fragment;
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(stream);

            // Act
            XmlWriter writer = formatter.CreateXmlWriter(stream, content);

            // Assert
            Assert.Equal(writer.Settings.ConformanceLevel, formatter.WriterSettings.ConformanceLevel);
        }

        [Fact]
        public void Property_WriterSettings_DefaultValues()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();

            Assert.NotNull(formatter.WriterSettings);
            Assert.False(formatter.WriterSettings.Indent);
            Assert.False(formatter.WriterSettings.CloseOutput);
            Assert.True(formatter.WriterSettings.OmitXmlDeclaration);
            Assert.False(formatter.WriterSettings.CheckCharacters);
        }

#if !Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Fact]
        public async Task InvalidXmlCharacters_CanBeSerialized_Default()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(stream);

            await formatter.WriteToStreamAsync(typeof(string), "\x16", stream, content, null);
        }

        [Fact]
        public Task InvalidXmlCharacters_CannotBeSerialized_IfCheckCharactersIsTrue()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            formatter.WriterSettings.CheckCharacters = true;
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(stream);

            return Assert.ThrowsAsync<ArgumentException>(
                () => formatter.WriteToStreamAsync(typeof(string), "\x16", stream, content, null),
                "'\x16', hexadecimal value 0x16, is an invalid character.");
        }
#endif

        [Theory]
        [PropertyData(nameof(AFewValidTypes))]
        public void CanReadType_ReturnsFalse_ForValidTypes(Type type)
        {
            XmlMediaTypeFormatter formatter = new();

            var canRead = formatter.CanReadType(type);

#if Testing_NetStandard1_3 // Different behavior in netstandard1.3 due to no DataContract validation.
            Assert.False(canRead);
#else
            Assert.True(canRead);
#endif
        }

        [Theory]
        [PropertyData(nameof(AFewValidTypes))]
        public void CanWriteType_ReturnsFalse_ForValidTypes(Type type)
        {
            XmlMediaTypeFormatter formatter = new();

            var canWrite = formatter.CanWriteType(type);

#if Testing_NetStandard1_3 // Different behavior in netstandard1.3 due to no DataContract validation.
            Assert.False(canWrite);
#else
            Assert.True(canWrite);
#endif
        }

        [Fact]
        public void CanReadType_ReturnsFalse_ForInvalidDataContracts()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();

            Assert.False(formatter.CanReadType(typeof(InvalidDataContract)));
        }

        [Fact]
        public void CanWriteType_ReturnsFalse_ForInvalidDataContracts()
        {
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();

            Assert.False(formatter.CanWriteType(typeof(InvalidDataContract)));
        }

#if Testing_NetStandard1_3 // Cannot read or write w/ DCS in netstandard1.3.
        [Fact]
        public override Task Overridden_ReadFromStreamAsyncWithCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task Overridden_ReadFromStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task Overridden_WriteToStreamAsyncWithCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task Overridden_WriteToStreamAsyncWithoutCancellationToken_GetsCalled()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task ReadFromStreamAsync_ReadsDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }

        // Attributes are in base class.
        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task ReadFromStreamAsync_WhenContentLengthIsNull_ReadsDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }

        // Attributes are in base class.
        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task WriteToStreamAsync_WhenObjectIsNull_WritesDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }

        [Fact]
        public override Task WriteToStreamAsync_WritesDataButDoesNotCloseStream()
        {
            return Task.CompletedTask;
        }
#endif

        public class InvalidDataContract
        {
            // removing the default ctor makes this invalid
            public InvalidDataContract(string s)
            {
            }
        }

        public class TestXmlMediaTypeFormatter : XmlMediaTypeFormatter
        {
            public TestXmlMediaTypeFormatter()
            {
            }

            public TestXmlMediaTypeFormatter(TestXmlMediaTypeFormatter formatter)
                : base(formatter)
            {
            }

            public bool ThrowAnExceptionOnCreate { get; set; }
            public bool ReturnNullOnCreate { get; set; }
            public XmlSerializer InnerXmlSerializer { get; private set; }
            public DataContractSerializer InnerDataContractSerializer { get; private set; }

            public bool CanReadTypeCaller(Type type)
            {
                return CanReadType(type);
            }

            public bool CanWriteTypeCaller(Type type)
            {
                return CanWriteType(type);
            }

            public override XmlSerializer CreateXmlSerializer(Type type)
            {
                InnerXmlSerializer = base.CreateXmlSerializer(type);

                if (ReturnNullOnCreate)
                {
                    return null;
                }

                if (ThrowAnExceptionOnCreate)
                {
                    throw new Exception("Throwing exception directly, since it needs to get caught by a catch all");
                }

                return InnerXmlSerializer;
            }

            public override DataContractSerializer CreateDataContractSerializer(Type type)
            {
                InnerDataContractSerializer = base.CreateDataContractSerializer(type);

                if (ReturnNullOnCreate)
                {
                    return null;
                }

                if (ThrowAnExceptionOnCreate)
                {
                    throw new Exception("Throwing exception directly, since it needs to get caught by a catch all");
                }

                return InnerDataContractSerializer;
            }
        }

        private bool IsSerializableWithXmlSerializer(Type type, object obj)
        {
            if (Assert.Http.IsKnownUnserializable(type, obj))
            {
                return false;
            }

            try
            {
                new XmlSerializer(type);
                if (obj != null && obj.GetType() != type)
                {
                    new XmlSerializer(obj.GetType());
                }
            }
            catch
            {
                return false;
            }

            return true;
        }

        private bool IsSerializableWithDataContractSerializer(Type type, object obj)
        {
#if Testing_NetStandard1_3 // Different behavior in netstandard1.3 due to no DataContract validation.
            return false;
#else
            if (Assert.Http.IsKnownUnserializable(type, obj))
            {
                return false;
            }

            try
            {
                new DataContractSerializer(type);
                if (obj != null && obj.GetType() != type)
                {
                    new DataContractSerializer(obj.GetType());
                }
            }
            catch
            {
                return false;
            }

            return true;
#endif
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Formatting/XmlSerializerMediaTypeFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Serialization;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class XmlSerializerMediaTypeFormatter : XmlMediaTypeFormatter
    {
        public XmlSerializerMediaTypeFormatter()
        {
            UseXmlSerializer = true;
        }
    }

    public class XmlSerializerMediaTypeFormatterTests : MediaTypeFormatterTestBase<XmlSerializerMediaTypeFormatter>
    {
        public override IEnumerable<MediaTypeHeaderValue> ExpectedSupportedMediaTypes
        {
            get { return HttpTestData.StandardXmlMediaTypes; }
        }

        public override IEnumerable<Encoding> ExpectedSupportedEncodings
        {
            get { return HttpTestData.StandardEncodings; }
        }

        public override byte[] ExpectedSampleTypeByteRepresentation
        {
            get { return ExpectedSupportedEncodings.ElementAt(0).GetBytes("<SampleType xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\"><Number>42</Number></SampleType>"); }
        }

        [Fact]
        public void DefaultMediaType_ReturnsApplicationXml()
        {
            MediaTypeHeaderValue mediaType = XmlSerializerMediaTypeFormatter.DefaultMediaType;
            Assert.NotNull(mediaType);
            Assert.Equal("application/xml", mediaType.MediaType);
        }

        [Fact]
        public void Indent_RoundTrips()
        {
            Assert.Reflection.BooleanProperty(
                new XmlSerializerMediaTypeFormatter(),
                c => c.Indent,
                expectedDefaultValue: false);
        }

        [Fact]
        public async Task ReadDeeplyNestedObjectWorks()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter()
            {
                MaxDepth = 5001
            };

            StringContent content = new StringContent(GetDeeplyNestedObject(5000));

            content.Headers.ContentType = new MediaTypeHeaderValue("application/xml");

            Assert.IsType<Nest>(await formatter.ReadFromStreamAsync(typeof(Nest), await content.ReadAsStreamAsync(), content, null));
        }

        [Fact]
        public void UseXmlSerializer_RoundTrips()
        {
            Assert.Reflection.BooleanProperty(
                new XmlSerializerMediaTypeFormatter(),
                c => c.UseXmlSerializer,
                expectedDefaultValue: true);
        }

        [Theory]
        [InlineData(typeof(IQueryable<string>))]
        [InlineData(typeof(IEnumerable<string>))]
        public async Task UseXmlFormatterWithNull(Type type)
        {
            XmlMediaTypeFormatter xmlFormatter = new XmlSerializerMediaTypeFormatter();
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(xmlFormatter.WriteToStreamAsync(type, null, memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("nil=\"true\""),
                "Null value should be serialized as nil.");
            Assert.True(serializedString.ToLower().Contains("arrayofstring"),
                "It should be serialized out as an array of string.");
        }

        [Fact]
        public async Task UseXmlSerializer_True()
        {
            XmlSerializerMediaTypeFormatter xmlFormatter = new XmlSerializerMediaTypeFormatter();
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(xmlFormatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.False(serializedString.Contains("DataContractSampleType"),
                "SampleType should not be serialized with data contract name DataContractSampleType because UseXmlSerializer is set to true.");
            Assert.False(serializedString.Contains("version=\"1.0\" encoding=\"utf-8\""),
              "Using XmlSerializer should not emit the xml declaration by default.");
            Assert.False(serializedString.Contains("\r\n"), "Using default XmlSerializer should emit data without indentation.");
        }

        [Fact]
        public async Task UseXmlSerializer_True_Indent()
        {
            XmlSerializerMediaTypeFormatter xmlFormatter = new XmlSerializerMediaTypeFormatter { Indent = true };
            MemoryStream memoryStream = new MemoryStream();
            HttpContent content = new StringContent(String.Empty);
            await Assert.Task.SucceedsAsync(xmlFormatter.WriteToStreamAsync(typeof(SampleType), new SampleType(), memoryStream, content, transportContext: null));
            memoryStream.Position = 0;
            string serializedString = new StreamReader(memoryStream).ReadToEnd();
            Assert.True(serializedString.Contains("\r\n"), "Using default XmlSerializer with Indent set to true should emit data with indentation.");
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection")]
        public void CanReadType_ReturnsSameResultAsXmlSerializerConstructor(Type variationType, object testData)
        {
            TestXmlSerializerMediaTypeFormatter formatter = new TestXmlSerializerMediaTypeFormatter();

            bool isSerializable = IsSerializableWithXmlSerializer(variationType, testData);
            bool canSupport = formatter.CanReadTypeCaller(variationType);
            if (isSerializable != canSupport)
            {
                Assert.Equal(isSerializable, canSupport);
            }

            // Ask a 2nd time to probe whether the cached result is treated the same
            canSupport = formatter.CanReadTypeCaller(variationType);
            Assert.Equal(isSerializable, canSupport);

        }

        [Fact]
        public void SetSerializer_ThrowsWithNullType()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            XmlSerializer xmlSerializer = new XmlSerializer(typeof(string));
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(null, xmlSerializer); }, "type");
        }

        [Fact]
        public void SetSerializer_ThrowsWithNullSerializer()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(typeof(string), (XmlSerializer)null); }, "serializer");
        }

        [Fact]
        public void SetSerializer1_ThrowsWithNullSerializer()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer<string>((XmlSerializer)null); }, "serializer");
        }

        [Fact]
        public void SetSerializer2_ThrowsWithNullType()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            XmlObjectSerializer xmlObjectSerializer = new DataContractSerializer(typeof(string));
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(null, xmlObjectSerializer); }, "type");
        }

        [Fact]
        public void SetSerializer2_ThrowsWithNullSerializer()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer(typeof(string), (XmlObjectSerializer)null); }, "serializer");
        }

        [Fact]
        public void SetSerializer3_ThrowsWithNullSerializer()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.SetSerializer<string>((XmlSerializer)null); }, "serializer");
        }

        [Fact]
        public void RemoveSerializer_ThrowsWithNullType()
        {
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            Assert.ThrowsArgumentNull(() => { formatter.RemoveSerializer(null); }, "type");
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RepresentativeValueAndRefTypeTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingXmlSerializer(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsSerializableWithXmlSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestXmlSerializerMediaTypeFormatter formatter = new TestXmlSerializerMediaTypeFormatter();
                formatter.SetSerializer(variationType, new XmlSerializer(variationType));

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

        [Theory]
        [TestDataSet(typeof(XmlMediaTypeFormatterTests), "BunchOfTypedObjectsTestDataCollection", RoundTripDataVariations)]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingXmlSerializer_ExtraTypes(Type variationType, object testData)
        {
            // Guard
            bool canSerialize = IsSerializableWithXmlSerializer(variationType, testData) && Assert.Http.CanRoundTrip(variationType);
            if (canSerialize)
            {
                // Arrange
                TestXmlSerializerMediaTypeFormatter formatter = new TestXmlSerializerMediaTypeFormatter();
                formatter.SetSerializer(variationType, new XmlSerializer(variationType, new Type[] { typeof(DBNull), }));

                // Arrange & Act & Assert
                object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
                Assert.Equal(testData, readObj);
            }
        }

        // Test alternate null value; this serializer attempts to cast DBNull to variationType so typeof(string) variation fails
        [Fact]
        public async Task ReadFromStreamAsync_RoundTripsWriteToStreamAsyncUsingXmlSerializer_DBNull()
        {
            // Arrange
            TestXmlSerializerMediaTypeFormatter formatter = new TestXmlSerializerMediaTypeFormatter();
            Type variationType = typeof(DBNull);
            formatter.SetSerializer(variationType, new XmlSerializer(variationType));
            object testData = DBNull.Value;

            // Arrange & Act & Assert
            object readObj = await ReadFromStreamAsync_RoundTripsWriteToStreamAsync_Helper(formatter, variationType, testData);
            Assert.Equal(testData, readObj);
        }

        public override Task ReadFromStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            string formattedContent = "<string>" + content + "</string>";
            string mediaType = string.Format("application/xml; charset={0}", encoding);

            // Act & assert
            return ReadFromStreamAsync_UsesCorrectCharacterEncodingHelper(formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }

        public override Task WriteToStreamAsync_UsesCorrectCharacterEncoding(string content, string encoding, bool isDefaultEncoding)
        {
            // Arrange
            XmlSerializerMediaTypeFormatter formatter = new XmlSerializerMediaTypeFormatter();
            string formattedContent = "<string>" + content + "</string>";
            string mediaType = string.Format("application/xml; charset={0}", encoding);

            // Act & assert
            return WriteToStreamAsync_UsesCorrectCharacterEncodingHelper(formatter, content, formattedContent, mediaType, encoding, isDefaultEncoding);
        }

        static string GetDeeplyNestedObject(int depth)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < depth; i++)
            {
                sb.Insert(0, "<A>");
                sb.Append("</A>");
            }
            sb.Insert(0, "<Nest xmlns=\"http://example.com\">");
            sb.Append("</Nest>");
            sb.Insert(0, "<?xml version=\"1.0\"?>");

            return sb.ToString();
        }

        public class TestXmlSerializerMediaTypeFormatter : XmlSerializerMediaTypeFormatter
        {
            public bool CanReadTypeCaller(Type type)
            {
                return CanReadType(type);
            }

            public bool CanWriteTypeCaller(Type type)
            {
                return CanWriteType(type);
            }
        }

        [XmlRoot("Nest", Namespace = "http://example.com")]
        public class Nest
        {
            public Nest A { get; set; }
        }

        private bool IsSerializableWithXmlSerializer(Type type, object obj)
        {
            if (Assert.Http.IsKnownUnserializable(type, obj))
            {
                return false;
            }

            try
            {
                new XmlSerializer(type);
                if (obj != null && obj.GetType() != type)
                {
                    new XmlSerializer(obj.GetType());
                }
            }
            catch
            {
                return false;
            }

            return true;
        }

        private bool IsSerializableWithDataContractSerializer(Type type, object obj)
        {
            if (Assert.Http.IsKnownUnserializable(type, obj))
            {
                return false;
            }

            try
            {
                new DataContractSerializer(type);
                if (obj != null && obj.GetType() != type)
                {
                    new DataContractSerializer(obj.GetType());
                }
            }
            catch
            {
                return false;
            }

            return true;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/FormattingUtilitiesTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Net.Http.Headers;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http
{
    public class FormattingUtilitiesTests
    {
        public static TheoryDataSet<string, string> QuotedStrings
        {
            get
            {
                return new TheoryDataSet<string, string>()
                {
                    { @"""""", @"" },
                    { @"""string""", @"string" },
                    { @"string", @"string" },
                    { @"""str""ing""", @"str""ing" },
                };
            }
        }

        public static TheoryDataSet<string> NotQuotedStrings
        {
            get
            {
                return new TheoryDataSet<string>
                {       
                    @" """,
                    @" """"",
                    @"string",
                    @"str""ing",
                    @"s""trin""g",
                };
            }
        }

        public static TheoryDataSet<string> ValidHeaderTokens
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    Convert.ToChar(0x21).ToString(),
                    Convert.ToChar(0x7E).ToString(),
                    "acb",
                    "ABC",
                    "a&b",
                };
            }
        }

        public static TheoryDataSet<string> InvalidHeaderTokens
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    Convert.ToChar(0x20).ToString(),
                    Convert.ToChar(0x7F).ToString(),
                    null,
                    "<acb>",
                    "[ABC]",
                    "{a&b}",
                    "æææøøøååå",
                    "いくつかのテキスト",
                };
            }
        }

        public static TheoryDataSet<DateTimeOffset, string> ValidDateStringValues
        {
            get
            {
                return new TheoryDataSet<DateTimeOffset, string>
                {
                    { new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero), "Sun, 06 Nov 1994 08:49:37 GMT" },
                };
            }
        }

        public static TheoryDataSet<string, DateTimeOffset> ValidDateValues
        {
            get
            {
                return new TheoryDataSet<string, DateTimeOffset>
                {
                    // RFC1123 date/time value
                    { "Sun, 06 Nov 1994 08:49:37 GMT", new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "Sun, 06 Nov 1994 08:49:37", new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "6 Nov 1994 8:49:37 GMT", new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "6 Nov 1994 8:49:37",  new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "Sun, 06 Nov 94 08:49:37",  new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "6 Nov 94 8:49:37",  new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },

                    // RFC850 date/time value
                    { "Sunday, 06-Nov-94 08:49:37 GMT",  new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "Sunday, 6-Nov-94 8:49:37",  new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "Sun, 6-Nov-1994 8:49:37 GMT", new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },

                    // ANSI C's asctime() format
                    { "Sun Nov  06 08:49:37 1994",  new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },
                    { "Sun Nov  6 8:49:37 1994",  new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero) },

                    // RFC5322 date/time
                    { "Sat, 08 Nov 1997 09:55:06 -0600", new DateTimeOffset(1997, 11, 8, 9, 55, 6, new TimeSpan(-6, 0, 0)) },
                    { "8 Nov 1997 9:55:6", new DateTimeOffset(1997, 11, 8, 9, 55, 6, TimeSpan.Zero) },
                    { "Sat, 8 Nov 1997 9:55:6 +0200", new DateTimeOffset(1997, 11, 8, 9, 55, 6, new TimeSpan(2, 0, 0)) },
                };
            }
        }

        public static TheoryDataSet<string> InvalidDateValues
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "Sun, 06 Nov 1994 08:49:37 GMT invalid",
                    "Sun, 06 Nov 1994 08:49:37 GMT,",
                    ",Sun, 06 Nov 1994 08:49:37 GMT",
                    "Sun, 06 Nov 1994 08:49:37 æøå",
                    "Sun, 06 æøå 1994 08:49:37 GMT",
                    "Sun, 06 Nov 1994 08:49:37 いくつ",
                    "Sun, 06 いくつ 1994 08:49:37 Nov",
                    "æææøøøååå",
                    "いくつかのテキスト",
                };
            }
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(FormattingUtilities), TypeAssert.TypeProperties.IsClass | TypeAssert.TypeProperties.IsStatic);
        }

        [Fact]
        public void IsJsonValueTypeReturnsTrue()
        {
            Assert.True(FormattingUtilities.IsJTokenType(typeof(JToken)), "Should return true");
            Assert.True(FormattingUtilities.IsJTokenType(typeof(JValue)), "Should return true");
            Assert.True(FormattingUtilities.IsJTokenType(typeof(JObject)), "Should return true");
            Assert.True(FormattingUtilities.IsJTokenType(typeof(JArray)), "Should return true");
        }

        [Fact]
        public void CreateEmptyContentHeadersReturnsEmptyHeaders()
        {
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();
            Assert.NotNull(headers);
            Assert.Empty(headers);
        }

        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void UnquoteTokenReturnsSameRefOnEmpty(string empty)
        {
            string result = FormattingUtilities.UnquoteToken(empty);
            Assert.Same(empty, result);
        }

        [Theory]
        [PropertyData("NotQuotedStrings")]
        public void UnquoteTokenReturnsSameRefNonQuotedStrings(string test)
        {
            string result = FormattingUtilities.UnquoteToken(test);
            Assert.Equal(test, result);
        }

        [Theory]
        [PropertyData("QuotedStrings")]
        public void UnquoteTokenReturnsUnquotedStrings(string token, string expectedResult)
        {
            string result = FormattingUtilities.UnquoteToken(token);
            Assert.Equal(expectedResult, result);
        }

        [Theory]
        [PropertyData("ValidHeaderTokens")]
        public void ValidateHeaderToken_AcceptsValidTokens(string validToken)
        {
            bool result = FormattingUtilities.ValidateHeaderToken(validToken);
            Assert.True(result);
        }

        [Theory]
        [PropertyData("InvalidHeaderTokens")]
        public void ValidateHeaderToken_RejectsInvalidTokens(string invalidToken)
        {
            bool result = FormattingUtilities.ValidateHeaderToken(invalidToken);
            Assert.False(result);
        }

        [Theory]
        [PropertyData("ValidDateStringValues")]
        public void DateToString_GeneratesValidValue(DateTimeOffset input, string expectedValue)
        {
            string actualValue = FormattingUtilities.DateToString(input);
            Assert.Equal(expectedValue, actualValue);
        }

        [Theory]
        [PropertyData("ValidDateValues")]
        public void TryParseDate_AcceptsValidDates(string dateValue, DateTimeOffset expectedDate)
        {
            DateTimeOffset actualDate;
            Assert.True(FormattingUtilities.TryParseDate(dateValue, out actualDate));
            Assert.Equal(expectedDate, actualDate);
        }

        [Theory]
        [PropertyData("InvalidDateValues")]
        public void TryStringToDate_RejectsInvalidDates(string dateValue)
        {
            DateTimeOffset actualDate;
            Assert.False(FormattingUtilities.TryParseDate(dateValue, out actualDate));
        }

        [Theory]
        [InlineData("0", 0)]
        [InlineData("1", 1)]
        [InlineData("2147483647", Int32.MaxValue)]
        public void TryParseInt32_AcceptsValidNumbers(string intValue, int expectedInt)
        {
            int actualInt;
            Assert.True(FormattingUtilities.TryParseInt32(intValue, out actualInt));
            Assert.Equal(expectedInt, actualInt);
        }

        [Theory]
        [InlineData("-2147483649")]
        [InlineData("-2147483648")]
        [InlineData("2147483648")]
        [InlineData(" 0")]
        public void TryParseInt32_RejectsInvalidNumbers(string intValue)
        {
            int actualInt;
            Assert.False(FormattingUtilities.TryParseInt32(intValue, out actualInt));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Handlers/HttpProgressEventArgsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Net.Http.Handlers
{
    public class HttpProgressEventArgsTest
    {
        [Fact]
        public void Constructor_Initializes()
        {
            // Arrange
            int progressPercentage = 10;
            object userState = new object();
            long bytesTransferred = 10L * 1024 * 1024 * 1024;
            long? totalBytes = 10L * 1024 * 1024 * 1024;

            // Act
            HttpProgressEventArgs args = new HttpProgressEventArgs(progressPercentage, userState, bytesTransferred, totalBytes);

            // Assert
            Assert.Equal(progressPercentage, args.ProgressPercentage);
            Assert.Equal(userState, args.UserState);
            Assert.Equal(bytesTransferred, args.BytesTransferred);
            Assert.Equal(totalBytes, args.TotalBytes);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Handlers/ProgressContentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http.Handlers
{
    public class ProgressContentTest
    {
        private const string TestHeader = "TestHeader";
        private const string TestValue = "TestValue";

        [Fact]
        public void Constructor_CopyHeadersFromInnerContent()
        {
            // Arrange
            StringContent innerContent = new StringContent("HelloWorld!");
            innerContent.Headers.Add(TestHeader, TestValue);
            HttpRequestMessage request = new HttpRequestMessage();
            ProgressMessageHandler progressHandler = new ProgressMessageHandler();

            // Act
            ProgressContent progressContent = new ProgressContent(innerContent, progressHandler, request);

            // Assert
            ValidateContentHeader(progressContent);
            Assert.Equal(innerContent.Headers.ContentType, progressContent.Headers.ContentType);
            Assert.Equal(innerContent.Headers.ContentLength, progressContent.Headers.ContentLength);
        }

        [Fact]
        public async Task SerializeToStreamAsync_InsertsProgressStream()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("HelloWorld!");

            MockProgressEventHandler progressEventHandler = new MockProgressEventHandler();
            ProgressMessageHandler progressHandler = MockProgressEventHandler.CreateProgressMessageHandler(out progressEventHandler, sendProgress: true);
            ProgressContent progressContent = new ProgressContent(request.Content, progressHandler, request);
            MemoryStream memStream = new MemoryStream();

            // Act
            await progressContent.CopyToAsync(memStream);

            // Assert
            Assert.True(progressEventHandler.WasInvoked);
            Assert.Equal(request, progressEventHandler.Sender);
            Assert.Equal(request.Content.Headers.ContentLength, progressEventHandler.EventArgs.TotalBytes);
        }

        [Fact]
        public void Dispose_DisposesInnerContent()
        {
            // Arrange
            StringContent innerContent = new StringContent("HelloWorld!");
            HttpRequestMessage request = new HttpRequestMessage();
            ProgressMessageHandler progressHandler = new ProgressMessageHandler();
            ProgressContent progressContent = new ProgressContent(innerContent, progressHandler, request);

            // Act
            progressContent.Dispose();

            // Assert
            Assert.ThrowsObjectDisposed(() => innerContent.LoadIntoBufferAsync(), typeof(StringContent).FullName);
        }

        private static void ValidateContentHeader(HttpContent content)
        {
            IEnumerable<string> values;
            bool headerResult = content.Headers.TryGetValues(TestHeader, out values);
            Assert.True(headerResult);
            Assert.Equal(TestValue, values.First());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Handlers/ProgressMessageHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http.Handlers
{
    public class ProgressMessageHandlerTest
    {
        private const string TestHeader = "TestHeader";
        private const string TestValue = "TestValue";

        [Theory]
        [InlineData(false, false)]
        [InlineData(false, true)]
        [InlineData(true, false)]
        [InlineData(true, true)]
        public async Task SendAsync_DoesNotInsertSendProgressWithoutEntityOrHandlerPresent(bool insertRequestEntity, bool addSendProgressHandler)
        {
            // Arrange
            HttpMessageInvoker invoker = CreateMessageInvoker(includeResponseEntity: false, addReceiveProgressHandler: false, addSendProgressHandler: addSendProgressHandler);
            HttpRequestMessage request = new HttpRequestMessage();
            HttpContent content = null;
            if (insertRequestEntity)
            {
                content = new StringContent("Request Entity!");
                content.Headers.Add(TestHeader, TestValue);
                request.Content = content;
            }

            // Act
            await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            if (insertRequestEntity && addSendProgressHandler)
            {
                ValidateContentHeader(request.Content);
                Assert.NotSame(content, request.Content);
                Assert.IsType<ProgressContent>(request.Content);
            }
            else
            {
                if (insertRequestEntity)
                {
                    Assert.IsType<StringContent>(request.Content);
                }
                else
                {
                    Assert.Null(request.Content);
                }
            }
        }

        [Theory]
        [InlineData(false, false)]
        [InlineData(false, true)]
        [InlineData(true, false)]
        [InlineData(true, true)]
        public async Task SendAsync_InsertsReceiveProgressWhenResponseEntityPresent(bool insertResponseEntity, bool addReceiveProgressHandler)
        {
            // Arrange
            HttpMessageInvoker invoker = CreateMessageInvoker(includeResponseEntity: insertResponseEntity, addSendProgressHandler: false, addReceiveProgressHandler: addReceiveProgressHandler);
            HttpRequestMessage request = new HttpRequestMessage();

            // Act
            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            if (insertResponseEntity && addReceiveProgressHandler)
            {
                ValidateContentHeader(response.Content);
                Assert.NotNull(response.Content);
                Assert.IsType<StreamContent>(response.Content);
            }
            else
            {
                if (insertResponseEntity)
                {
                    Assert.IsType<StringContent>(response.Content);
                }
                else
                {
                    Assert.NotNull(response.Content);
                    Assert.Equal(0L, response.Content.Headers.ContentLength);
                }
            }
        }

        private static HttpMessageInvoker CreateMessageInvoker(bool includeResponseEntity, bool addSendProgressHandler, bool addReceiveProgressHandler)
        {
            ShortCircuitMessageHandler innerHandler = new ShortCircuitMessageHandler(includeResponseEntity);
            ProgressMessageHandler progress = new ProgressMessageHandler(innerHandler);
            if (addSendProgressHandler)
            {
                progress.HttpSendProgress += new MockProgressEventHandler().Handler;
            }

            if (addReceiveProgressHandler)
            {
                progress.HttpReceiveProgress += new MockProgressEventHandler().Handler;
            }

            return new HttpMessageInvoker(progress);
        }

        private static void ValidateContentHeader(HttpContent content)
        {
            IEnumerable<string> values;
            bool headerResult = content.Headers.TryGetValues(TestHeader, out values);
            Assert.True(headerResult);
            Assert.Equal(TestValue, values.First());
        }

        private class ShortCircuitMessageHandler : HttpMessageHandler
        {
            bool _includeResponseEntity;

            public ShortCircuitMessageHandler(bool includeResponseEntity)
            {
                _includeResponseEntity = includeResponseEntity;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                HttpResponseMessage response = request.CreateResponse();
                if (_includeResponseEntity)
                {
                    response.Content = new StringContent("Response Entity");
                    response.Content.Headers.Add(TestHeader, TestValue);
                }

                return Task.FromResult(response);
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Handlers/ProgressStreamTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Handlers
{
    public class ProgressStreamTest
    {
        [Fact]
        public async Task Read_ReportsBytesRead()
        {
            // Arrange
            HttpResponseMessage response = CreateResponse();
            Stream innerStream = await response.Content.ReadAsStreamAsync();
            long? expectedLength = response.Content.Headers.ContentLength;
            MockProgressEventHandler mockProgressEventHandler;
            ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false);
            ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response);

            // Act/Assert
            int totalBytesRead = 0;
            int bytesRead = 0;
            do
            {
                byte[] buffer = new byte[8];
                bytesRead = progressStream.Read(buffer, 0, buffer.Length);
                totalBytesRead += bytesRead;

                Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred);
                Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }
            while (bytesRead > 0);

            Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
            Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
        }

        [Fact]
        public async Task ReadByte_ReportsBytesRead()
        {
            // Arrange
            HttpResponseMessage response = CreateResponse();
            Stream innerStream = await response.Content.ReadAsStreamAsync();
            long? expectedLength = response.Content.Headers.ContentLength;
            MockProgressEventHandler mockProgressEventHandler;
            ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false);
            ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response);

            // Act/Assert
            int totalBytesRead = 0;
            while (progressStream.ReadByte() != -1)
            {
                totalBytesRead += 1;

                Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred);
                Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }

            Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
            Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
        }

#if !Testing_NetStandard1_3 // BeginX and EndX not supported on Streams in netstandard1.3
        [Fact]
        public async Task BeginEndRead_ReportsBytesRead()
        {
            // Arrange
            HttpResponseMessage response = CreateResponse();
            Stream innerStream = await response.Content.ReadAsStreamAsync();
            long? expectedLength = response.Content.Headers.ContentLength;
            MockProgressEventHandler mockProgressEventHandler;
            ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false);
            ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response);
            object userState = new object();

            // Act/Assert
            int totalBytesRead = 0;
            int bytesRead = 0;
            do
            {
                byte[] buffer = new byte[8];
                IAsyncResult result = progressStream.BeginRead(buffer, 0, buffer.Length, null, userState);
                bytesRead = progressStream.EndRead(result);
                totalBytesRead += bytesRead;

                Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState);
                Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred);
                Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }
            while (bytesRead > 0);

            Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
            Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
        }
#endif

        [Fact]
        public async Task ReadAsync_ReportsBytesRead()
        {
            // Arrange
            HttpResponseMessage response = CreateResponse();
            Stream innerStream = await response.Content.ReadAsStreamAsync();
            long? expectedLength = response.Content.Headers.ContentLength;
            MockProgressEventHandler mockProgressEventHandler;
            ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: false);
            ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, response: response);
            object userState = new object();

            // Act/Assert
            int totalBytesRead = 0;
            int bytesRead = 0;
            do
            {
                byte[] buffer = new byte[8];
                bytesRead = await progressStream.ReadAsync(buffer, 0, buffer.Length);
                totalBytesRead += bytesRead;

                Assert.Equal(totalBytesRead, mockProgressEventHandler.EventArgs.BytesTransferred);
                Assert.Equal((100L * totalBytesRead) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }
            while (bytesRead > 0);

            Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
            Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
        }

        [Fact]
        public void Write_ReportsBytesWritten()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            Stream innerStream = new MemoryStream();
            byte[] buffer = CreateBufferContent();
            long? expectedLength = request.Content.Headers.ContentLength;
            MockProgressEventHandler mockProgressEventHandler;
            ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true);
            ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request);

            // Act/Assert
            int totalBytesWritten = 0;
            int bytesWritten = 0;
            while (totalBytesWritten < expectedLength)
            {
                bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten);
                progressStream.Write(buffer, totalBytesWritten, bytesWritten);
                totalBytesWritten += bytesWritten;

                Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred);
                Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }

            Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
            Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
        }

        [Fact]
        public void WriteByte_ReportsBytesWritten()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            Stream innerStream = new MemoryStream();
            byte[] buffer = CreateBufferContent();
            long? expectedLength = request.Content.Headers.ContentLength;
            MockProgressEventHandler mockProgressEventHandler;
            ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true);
            ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request);

            // Act/Assert
            int totalBytesWritten = 0;
            while (totalBytesWritten < expectedLength)
            {
                progressStream.WriteByte(buffer[totalBytesWritten]);
                totalBytesWritten += 1;

                Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred);
                Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }

            Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
            Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
        }

#if !Testing_NetStandard1_3 // BeginX and EndX not supported on Streams in netstandard1.3
        [Fact]
        public void BeginEndWrite_ReportsBytesWritten()
        {
            // Arrange
            using (ManualResetEvent writeComplete = new ManualResetEvent(false))
            {
                HttpRequestMessage request = CreateRequest();
                Stream innerStream = new MemoryStream();
                byte[] buffer = CreateBufferContent();
                long? expectedLength = request.Content.Headers.ContentLength;
                MockProgressEventHandler mockProgressEventHandler;
                ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true);
                ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request);
                object userState = new object();

                // Act/Assert
                int totalBytesWritten = 0;
                int bytesWritten = 0;
                while (totalBytesWritten < expectedLength)
                {
                    bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten);
                    IAsyncResult result = progressStream.BeginWrite(buffer, totalBytesWritten, bytesWritten,
                        ia =>
                        {
                            progressStream.EndWrite(ia);
                            writeComplete.Set();
                        },
                        userState);

                    writeComplete.WaitOne();
                    writeComplete.Reset();
                    totalBytesWritten += bytesWritten;

                    Assert.Same(userState, mockProgressEventHandler.EventArgs.UserState);
                    Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred);
                    Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
                }

                Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
                Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }
        }
#endif

        [Fact]
        public async Task WriteAsync_ReportsBytesWritten()
        {
            // Arrange
            using (ManualResetEvent writeComplete = new ManualResetEvent(false))
            {
                HttpRequestMessage request = CreateRequest();
                Stream innerStream = new MemoryStream();
                byte[] buffer = CreateBufferContent();
                long? expectedLength = request.Content.Headers.ContentLength;
                MockProgressEventHandler mockProgressEventHandler;
                ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressEventHandler, sendProgress: true);
                ProgressStream progressStream = CreateProgressStream(innerStream: innerStream, progressMessageHandler: progressMessageHandler, request: request);
                object userState = new object();

                // Act/Assert
                int totalBytesWritten = 0;
                int bytesWritten = 0;
                while (totalBytesWritten < expectedLength)
                {
                    bytesWritten = Math.Min(8, (int)expectedLength - totalBytesWritten);
                    await progressStream.WriteAsync(buffer, totalBytesWritten, bytesWritten);

                    totalBytesWritten += bytesWritten;

                    Assert.Equal(totalBytesWritten, mockProgressEventHandler.EventArgs.BytesTransferred);
                    Assert.Equal((100L * totalBytesWritten) / expectedLength, mockProgressEventHandler.EventArgs.ProgressPercentage);
                }

                Assert.Equal(expectedLength, mockProgressEventHandler.EventArgs.TotalBytes);
                Assert.Equal(100, mockProgressEventHandler.EventArgs.ProgressPercentage);
            }
        }

        internal static ProgressStream CreateProgressStream(
            Stream innerStream = null,
            ProgressMessageHandler progressMessageHandler = null,
            HttpRequestMessage request = null,
            HttpResponseMessage response = null)
        {
            Stream iStream = innerStream ?? new Mock<Stream>().Object;
            ProgressMessageHandler pHandler = progressMessageHandler ?? new ProgressMessageHandler();
            HttpRequestMessage req = request ?? new HttpRequestMessage();
            HttpResponseMessage rsp = response ?? new HttpResponseMessage() { Content = new StreamContent(Stream.Null) };
            return new ProgressStream(iStream, pHandler, req, rsp);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage
            {
                Content = CreateStringContent()
            };
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage
            {
                Content = CreateStringContent()
            };
        }

        private static String CreateContent()
        {
            StringBuilder content = new StringBuilder();
            for (int count = 0; count < 100; count++)
            {
                content.Append("1234567890");
            }
            return content.ToString();
        }

        private static HttpContent CreateStringContent()
        {
            return new StringContent(CreateContent());
        }

        private static byte[] CreateBufferContent()
        {
            return Encoding.UTF8.GetBytes(CreateContent());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Handlers/ProgressWriteAsyncResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Formatting.Mocks;
using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Handlers
{
    public class ProgressWriteAsyncResultTest
    {
        static readonly byte[] sampleData = Encoding.UTF8.GetBytes("Hello World! Hello World! Hello World! Hello World! Hello World!");

        [Fact]
        public void Constructor_BeginWriteOnInnerStream()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            ProgressStream progressStream = ProgressStreamTest.CreateProgressStream();

            // Act
            IAsyncResult result = new ProgressWriteAsyncResult(
                mockInnerStream.Object, progressStream, sampleData, 2, 4, null, null);

            // Assert 
            mockInnerStream.Verify(s => s.BeginWrite(sampleData, 2, 4, It.IsAny<AsyncCallback>(), It.IsAny<object>()),
                Times.Once());
        }

        [Fact]
        public void Constructor_CompletesSynchronouslyIfInnerStreamCompletesSynchronously()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            object userState = new object();
            IAsyncResult mockIAsyncResult = MockCompletedAsyncResult.Create(true, userState);
            mockInnerStream.Setup(s => s.BeginWrite(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<AsyncCallback>(), It.IsAny<object>()))
                .Returns(mockIAsyncResult);
            ProgressStream progressStream = ProgressStreamTest.CreateProgressStream();

            // Act
            IAsyncResult result = new ProgressWriteAsyncResult(
                mockInnerStream.Object, progressStream, sampleData, 2, 4, null, userState);

            // Assert 
            Assert.True(result.IsCompleted);
            Assert.True(result.CompletedSynchronously);
            Assert.Same(userState, result.AsyncState);
        }

        [Fact]
        public void Constructor_CompletesWithExceptionIfInnerStreamThrows()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.BeginWrite(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<AsyncCallback>(), It.IsAny<object>()))
                .Throws<ApplicationException>();
            ProgressStream progressStream = ProgressStreamTest.CreateProgressStream();

            // Act
            IAsyncResult result = new ProgressWriteAsyncResult(
                mockInnerStream.Object, progressStream, sampleData, 2, 2, null, null);

            // Assert 
            Assert.True(result.IsCompleted);
            Assert.Throws<ApplicationException>(() => ProgressWriteAsyncResult.End(result));
        }

        [Theory]
        [InlineData(0, 10)]
        [InlineData(10, 1)]
        public void Constructor_ReportsBytesWritten(int offset, int count)
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            object userState = new object();
            IAsyncResult mockIAsyncResult = MockCompletedAsyncResult.Create(true, userState);
            mockInnerStream.Setup(s => s.BeginWrite(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<AsyncCallback>(), It.IsAny<object>()))
                .Returns(mockIAsyncResult);

            MockProgressEventHandler mockProgressHandler;
            ProgressMessageHandler progressMessageHandler = MockProgressEventHandler.CreateProgressMessageHandler(out mockProgressHandler, sendProgress: true);
            HttpRequestMessage request = new HttpRequestMessage();

            ProgressStream progressStream = ProgressStreamTest.CreateProgressStream(progressMessageHandler: progressMessageHandler, request: request);

            // Act
            IAsyncResult result = new ProgressWriteAsyncResult(
                mockInnerStream.Object, progressStream, sampleData, offset, count, null, userState);

            // Assert 
            Assert.True(mockProgressHandler.WasInvoked);
            Assert.Same(request, mockProgressHandler.Sender);
            Assert.Equal(count, mockProgressHandler.EventArgs.BytesTransferred);
            Assert.Same(userState, mockProgressHandler.EventArgs.UserState);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Headers/CookieHeaderValueTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using Microsoft.TestCommon;

namespace System.Net.Http.Headers
{
    public class CookieHeaderValueTest
    {
        public static TheoryDataSet<CookieHeaderValue, string> CookieHeaderDataSet
        {
            get
            {
                var dataset = new TheoryDataSet<CookieHeaderValue, string>();
                NameValueCollection nvc = new NameValueCollection();
                nvc.Add("n1", "v1");
                nvc.Add("n2", "v2");
                nvc.Add("n3", "v3");
                CookieHeaderValue header1 = new CookieHeaderValue("name1", nvc)
                {
                    Domain = "domain1",
                    Expires = new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero),
                    HttpOnly = true,
                    MaxAge = TimeSpan.FromDays(1),
                    Path = "path1",
                    Secure = true
                };
                dataset.Add(header1, "name1=n1=v1&n2=v2&n3=v3; expires=Sun, 06 Nov 1994 08:49:37 GMT; max-age=86400; domain=domain1; path=path1; secure; httponly");

                CookieHeaderValue header2 = new CookieHeaderValue("name2", "");
                dataset.Add(header2, "name2=");

                CookieHeaderValue header3 = new CookieHeaderValue("name2", "value2");
                dataset.Add(header3, "name2=value2");

                CookieHeaderValue header4 = new CookieHeaderValue("name4", "value4")
                {
                    MaxAge = TimeSpan.FromDays(1),
                };
                dataset.Add(header4, "name4=value4; max-age=86400");

                CookieHeaderValue header5 = new CookieHeaderValue("name5", "value5")
                {
                    Domain = "domain1",
                    Expires = new DateTimeOffset(1994, 11, 6, 8, 49, 37, TimeSpan.Zero),
                };
                dataset.Add(header5, "name5=value5; expires=Sun, 06 Nov 1994 08:49:37 GMT; domain=domain1");

                return dataset;
            }
        }

        public static TheoryDataSet<string> CookieHeaderDataSet_NoCookie
        {
            get
            {
                var dataSet = new TheoryDataSet<string>();
                foreach (var item in CookieHeaderDataSet)
                {
                    dataSet.Add((string)item[1]);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<string> InvalidCookieHeaderDataSet
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "expires=Sun, 06 Nov 1994 08:49:37 GMT; max-age=86400; domain=domain1",
                    "name=value; expires=Sun, 06 Nov 1994 08:49:37 ZZZ; max-age=86400; domain=domain1",
                    "name=value; expires=Sun, 06 Nov 1994 08:49:37 GMT; max-age=-86400; domain=domain1",
                };
            }
        }

        [Fact]
        public void CookieHeaderValue_Ctor1_InitializesCorrectly()
        {
            CookieHeaderValue header = new CookieHeaderValue("cookie", "value");
            CookieState cookie = Assert.Single(header.Cookies);
            Assert.Equal("cookie", cookie.Name);
            Assert.Equal("value", cookie.Values.AllKeys[0]);
        }

        [Fact]
        public void CookieHeaderValue_Ctor2_InitializesCorrectly()
        {
            NameValueCollection nvc = new NameValueCollection();
            nvc.Add("name", "value");
            CookieHeaderValue header = new CookieHeaderValue("cookie", nvc);
            CookieState cookie = Assert.Single(header.Cookies);
            Assert.Equal("cookie", cookie.Name);
            Assert.Equal("name", cookie.Values.AllKeys[0]);
            Assert.Equal("value", cookie.Values["name"]);
        }

        [Fact]
        public void CookieHeaderValue_Clone()
        {
            // Arrange
            NameValueCollection nvc = new NameValueCollection();
            nvc.Add("name", "value");
            CookieHeaderValue expectedValue = new CookieHeaderValue("cookie", nvc);
            expectedValue.Domain = "domain";
            expectedValue.Expires = DateTimeOffset.Now;
            expectedValue.MaxAge = TimeSpan.FromDays(10);
            expectedValue.Path = "path";
            expectedValue.HttpOnly = true;
            expectedValue.Secure = true;

            // Act
            CookieHeaderValue actualValue = expectedValue.Clone() as CookieHeaderValue;

            // Assert
            Assert.Equal(expectedValue.ToString(), actualValue.ToString());
        }

        [Theory]
        [PropertyData("CookieHeaderDataSet")]
        public void CookieHeaderValue_ToString(CookieHeaderValue input, string expectedValue)
        {
            Assert.Equal(expectedValue, input.ToString());
        }

        [Theory]
        [InlineData("")]
        [InlineData(null)]
        public void CookieHeaderValue_GetItem_ReturnsNullIfNameIsNullOrEmpty(string name)
        {
            CookieHeaderValue header = new CookieHeaderValue("cookie", "value");
            Assert.Null(header[name]);
        }

        [Fact]
        public void CookieHeaderValue_GetItem_ReturnsCookie()
        {
            CookieHeaderValue header = new CookieHeaderValue("cookie", "value");

            Assert.Single(header.Cookies);
            CookieState state = header["cookie"];
            Assert.Equal("value", state.Value);
        }

        [Fact]
        public void CookieHeaderValue_GetItem_CreatesEmptyCookieIfNotAlreadyPresent()
        {
            CookieHeaderValue header = new CookieHeaderValue("cookie", "value");

            CookieState state = header["newstate"];
            Assert.Equal(2, header.Cookies.Count);
            Assert.Equal(String.Empty, state.Value);
        }

        [Theory]
        [PropertyData("CookieHeaderDataSet_NoCookie")]
        public void CookieHeaderValue_TryParse_AcceptsValidValues(string expectedValue)
        {
            CookieHeaderValue header;
            bool result = CookieHeaderValue.TryParse(expectedValue, out header);

            Assert.True(result);
            Assert.Equal(expectedValue, header.ToString());
        }

        [Theory]
        [PropertyData("InvalidCookieHeaderDataSet")]
        public void CookieHeaderValue_TryParse_RejectsInvalidValues(string value)
        {
            CookieHeaderValue header;
            bool result = CookieHeaderValue.TryParse(value, out header);

            Assert.False(result);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Headers/CookieStateTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using Microsoft.TestCommon;

namespace System.Net.Http.Headers
{
    public class CookieStateTest
    {
        public static TheoryDataSet<string> InvalidCookieNames
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "<acb>",
                    "{acb}",
                    "[acb]",
                    "\"acb\"",
                    "a,b",
                    "a;b",
                    "a\\b",
                };
            }
        }

        public static TheoryDataSet<string, string> EncodedCookieStateStrings
        {
            get
            {
                TheoryDataSet<string, string> data = new TheoryDataSet<string, string>
                {
                    { "?", "%3F" },
                    { "=", "%3D" },
                    { "<acb>", "%3Cacb%3E" },
                    { "{acb}", "%7Bacb%7D" },
                    { "[acb]", "%5Bacb%5D" },
                    { "\"acb\"", "%22acb%22" },
                    { "a,b", "a%2Cb" },
                    { "a;b", "a%3Bb" },
                    { "a\\b", "a%5Cb" },
                    { "[]{}\\|!@#$%^&*()_-+=", "%5B%5D%7B%7D%5C%7C!%40%23%24%25%5E%26*()_-%2B%3D" },
                };

                return data;
            }
        }

        [Fact]
        public void CookieState_CtorThrowsOnNullName()
        {
            Assert.ThrowsArgumentNull(() => new CookieState(null, "value"), "name");
        }

        [Theory]
        [PropertyData("InvalidCookieNames")]
        public void CookieState_CtorThrowsOnInvalidName(string name)
        {
            Assert.ThrowsArgument(() => new CookieState(name, "value"), "name");
        }

        [Fact]
        public void CookieState_CtorThrowsOnNullNameValueCollection()
        {
            Assert.ThrowsArgumentNull(() => new CookieState("name", (NameValueCollection)null), "values");
        }

        [Theory]
        [InlineData("name", "")]
        [InlineData("name", "value")]
        [InlineData("name", "+=\\[]{}!@#$%^&*()_")]
        public void CookieState_Ctor1InitializesCorrectly(string name, string value)
        {
            CookieState cookie = new CookieState(name, value);
            Assert.Equal(name, cookie.Name);
            Assert.Equal(value, cookie.Values.AllKeys[0]);
            Assert.Equal(value, cookie.Value);
        }

        [Fact]
        public void CookieState_Ctor2InitializesCorrectly()
        {
            // Arrange
            NameValueCollection nvc = new NameValueCollection();
            nvc.Add("n1", "v1");

            // Act
            CookieState cookie = new CookieState("name", nvc);

            // Assert
            Assert.Equal("name", cookie.Name);
            Assert.Single(cookie.Values);
            Assert.Equal("n1", cookie.Values.AllKeys[0]);
            Assert.Equal("v1", cookie.Values["n1"]);
            Assert.Equal("n1", cookie.Value);
        }

        [Fact]
        public void CookieState_Value()
        {
            CookieState cookie = new CookieState("name");
            Assert.Equal(String.Empty, cookie.Value);

            cookie.Value = "value1";
            Assert.Equal("value1", cookie.Value);

            cookie.Values.AllKeys[0] = "value2";
            Assert.Equal("value2", cookie.Value);
        }

        [Fact]
        public void CookieState_ItemTreatsNullNameAsEmpty()
        {
            // Arrange
            CookieState state = new CookieState("name", "value");

            // Act
            state[null] = "v1";

            // Assert
            Assert.Equal("name=value&=v1", state.ToString());
        }

        [Theory]
        [PropertyData("EncodedCookieStateStrings")]
        public void CookieState_ItemEncodesName(string subname, string encodedSubname)
        {
            // Arrange
            CookieState state = new CookieState("name", "value");

            // Act
            state[subname] = "v1";

            // Assert
            string value = String.Format("name=value&{0}=v1", encodedSubname);
            Assert.Equal(value, state.ToString());
        }

        [Theory]
        [PropertyData("EncodedCookieStateStrings")]
        public void CookieState_ItemEncodesValue(string subvalue, string encodedSubvalue)
        {
            // Arrange
            CookieState state = new CookieState("name", "value");

            // Act
            state["n1"] = subvalue;

            // Assert
            string value = String.Format("name=value&n1={0}", encodedSubvalue);
            Assert.Equal(value, state.ToString());
        }

        [Fact]
        public void CookieState_Clone()
        {
            // Arrange
            NameValueCollection nvc = new NameValueCollection();
            nvc.Add("n1", "v1");
            CookieState expectedValue = new CookieState("name", nvc);

            // Act
            CookieState actualValue = expectedValue.Clone() as CookieState;

            // Assert
            Assert.Equal("name", actualValue.Name);
            Assert.Single(actualValue.Values);
            Assert.Equal("n1", actualValue.Values.AllKeys[0]);
            Assert.Equal("v1", actualValue.Values["n1"]);
        }

        [Theory]
        [PropertyData("EncodedCookieStateStrings")]
        public void CookieState_ToStringWithSingleValue(string subValue, string encodedSubvalue)
        {
            // Arrange
            CookieState cookie = new CookieState("name", subValue);

            // Act
            string actualValue = cookie.ToString();

            // Assert
            string expectedValue = String.Format("name={0}", encodedSubvalue);
            Assert.Equal(expectedValue, actualValue);
        }

        [Theory]
        [PropertyData("EncodedCookieStateStrings")]
        public void CookieState_ToStringWithNameValueCollection(string subValue, string encodedSubvalue)
        {
            // Arrange
            NameValueCollection nvc = new NameValueCollection();
            nvc.Add("n1", subValue);
            nvc.Add("n2", subValue);
            nvc.Add("n3", subValue);
            CookieState cookie = new CookieState("name", nvc);

            // Act
            string actualValue = cookie.ToString();

            // Assert
            string expectedValue = String.Format("name=n1={0}&n2={0}&n3={0}", encodedSubvalue);
            Assert.Equal(expectedValue, actualValue);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpClientExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;
using System.Net.Http.Formatting.Mocks;
using System.Net.Http.Headers;
using System.Net.Http.Mocks;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class HttpClientExtensionsTest
    {
        private const string InvalidUriMessage =
#if NET6_0_OR_GREATER
            "An invalid request URI was provided. Either the request URI must be an absolute URI or BaseAddress must be set.";
#else
            "An invalid request URI was provided. The request URI must either be an absolute URI or BaseAddress must be set.";
#endif
        private readonly MediaTypeFormatter _formatter = new MockMediaTypeFormatter { CallBase = true };
        private readonly HttpClient _client;
        private readonly MediaTypeHeaderValue _mediaTypeHeader = MediaTypeHeaderValue.Parse("foo/bar; charset=utf-16");

        public HttpClientExtensionsTest()
        {
            Mock<TestableHttpMessageHandler> handlerMock = new Mock<TestableHttpMessageHandler> { CallBase = true };
            handlerMock
                .Setup(h => h.SendAsyncPublic(It.IsAny<HttpRequestMessage>(), It.IsAny<CancellationToken>()))
                .Returns((HttpRequestMessage request, CancellationToken _) => Task.FromResult(new HttpResponseMessage() { RequestMessage = request }));

            _client = new HttpClient(handlerMock.Object);
        }

        [Fact]
        public void PostAsJsonAsync_String_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PostAsJsonAsync("http://www.example.com", new object()), "client");
        }

        [Fact]
        public void PostAsJsonAsync_String_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PostAsJsonAsync((string)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PostAsJsonAsync_String_UsesJsonMediaTypeFormatter()
        {
            var response = await _client.PostAsJsonAsync("http://example.com", new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<JsonMediaTypeFormatter>(content.Formatter);
        }

        [Fact]
        public void PostAsXmlAsync_String_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PostAsXmlAsync("http://www.example.com", new object()), "client");
        }

#if !Testing_NetStandard1_3 // Avoid "The configured formatter 'System.Net.Http.Formatting.XmlMediaTypeFormatter' cannot write an object of type 'Object'."
        [Fact]
        public void PostAsXmlAsync_String_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PostAsXmlAsync((string)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PostAsXmlAsync_String_UsesXmlMediaTypeFormatter()
        {
            var response = await _client.PostAsXmlAsync("http://example.com", new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<XmlMediaTypeFormatter>(content.Formatter);
        }
#endif

        [Fact]
        public void PostAsync_String_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PostAsync("http://www.example.com", new object(), new JsonMediaTypeFormatter(), "text/json"), "client");
        }

        [Fact]
        public void PostAsync_String_WhenRequestUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PostAsync((string)null, new object(), new JsonMediaTypeFormatter(), "text/json"),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PostAsync_String_WhenRequestUriIsSet_CreatesRequestWithAppropriateUri()
        {
            _client.BaseAddress = new Uri("http://example.com/");

            var response = await _client.PostAsync("myapi/", new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Equal("http://example.com/myapi/", request.RequestUri.ToString());
        }

        [Fact]
        public async Task PostAsync_String_WhenAuthoritativeMediaTypeIsSet_CreatesRequestWithAppropriateContentType()
        {
            var response = await _client.PostAsync("http://example.com/myapi/", new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
            Assert.Equal("utf-16", request.Content.Headers.ContentType.CharSet);
        }

        [Fact]
        public async Task PostAsync_String_WhenAuthoritativeMediaTypeStringIsSet_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PostAsync("http://example.com/myapi/", new object(), _formatter, mediaType, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PostAsync_String_WhenAuthoritativeMediaTypeStringIsSetWithoutCT_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PostAsync("http://example.com/myapi/", new object(), _formatter, mediaType);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PostAsync_String_WhenFormatterIsSet_CreatesRequestWithObjectContentAndCorrectFormatter()
        {
            var response = await _client.PostAsync("http://example.com/myapi/", new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            var content = Assert.IsType<ObjectContent<object>>(request.Content);
            Assert.Same(_formatter, content.Formatter);
        }

        [Fact]
        public async Task PostAsync_String_IssuesPostRequest()
        {
            var response = await _client.PostAsync("http://example.com/myapi/", new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Same(HttpMethod.Post, request.Method);
        }

        [Fact]
        public void PostAsync_String_WhenMediaTypeFormatterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() => _client.PostAsync("http://example.com", new object(), formatter: null), "formatter");
        }

        [Fact]
        public void PutAsJsonAsync_String_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PutAsJsonAsync("http://www.example.com", new object()), "client");
        }

        [Fact]
        public void PutAsJsonAsync_String_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PutAsJsonAsync((string)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PutAsJsonAsync_String_UsesJsonMediaTypeFormatter()
        {
            var response = await _client.PutAsJsonAsync("http://example.com", new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<JsonMediaTypeFormatter>(content.Formatter);
        }

        [Fact]
        public void PutAsXmlAsync_String_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PutAsXmlAsync("http://www.example.com", new object()), "client");
        }

#if !Testing_NetStandard1_3 // Avoid "The configured formatter 'System.Net.Http.Formatting.XmlMediaTypeFormatter' cannot write an object of type 'Object'."
        [Fact]
        public void PutAsXmlAsync_String_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PutAsXmlAsync((string)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PutAsXmlAsync_String_UsesXmlMediaTypeFormatter()
        {
            var response = await _client.PutAsXmlAsync("http://example.com", new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<XmlMediaTypeFormatter>(content.Formatter);
        }
#endif

        [Fact]
        public void PutAsync_String_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PutAsync("http://www.example.com", new object(), new JsonMediaTypeFormatter(), "text/json"), "client");
        }

        [Fact]
        public void PutAsync_String_WhenRequestUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PutAsync((string)null, new object(), new JsonMediaTypeFormatter(), "text/json"),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PutAsync_String_WhenRequestUriIsSet_CreatesRequestWithAppropriateUri()
        {
            _client.BaseAddress = new Uri("http://example.com/");

            var response = await _client.PutAsync("myapi/", new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Equal("http://example.com/myapi/", request.RequestUri.ToString());
        }

        [Fact]
        public async Task PutAsync_String_WhenAuthoritativeMediaTypeIsSet_CreatesRequestWithAppropriateContentType()
        {
            var response = await _client.PutAsync("http://example.com/myapi/", new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
            Assert.Equal("utf-16", request.Content.Headers.ContentType.CharSet);
        }

        [Fact]
        public async Task PutAsync_String_WhenFormatterIsSet_CreatesRequestWithObjectContentAndCorrectFormatter()
        {
            var response = await _client.PutAsync("http://example.com/myapi/", new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            var content = Assert.IsType<ObjectContent<object>>(request.Content);
            Assert.Same(_formatter, content.Formatter);
        }

        [Fact]
        public async Task PutAsync_String_WhenAuthoritativeMediaTypeStringIsSet_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PutAsync("http://example.com/myapi/", new object(), _formatter, mediaType, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PutAsync_String_WhenAuthoritativeMediaTypeStringIsSetWithoutCT_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PutAsync("http://example.com/myapi/", new object(), _formatter, mediaType);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PutAsync_String_IssuesPutRequest()
        {
            var response = await _client.PutAsync("http://example.com/myapi/", new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Same(HttpMethod.Put, request.Method);
        }

        [Fact]
        public void PutAsync_String_WhenMediaTypeFormatterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() => _client.PutAsync("http://example.com", new object(), formatter: null), "formatter");
        }

        [Fact]
        public void PostAsJsonAsync_Uri_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PostAsJsonAsync(new Uri("http://www.example.com"), new object()), "client");
        }

        [Fact]
        public void PostAsJsonAsync_Uri_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PostAsJsonAsync((Uri)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PostAsJsonAsync_Uri_UsesJsonMediaTypeFormatter()
        {
            var response = await _client.PostAsJsonAsync(new Uri("http://example.com"), new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<JsonMediaTypeFormatter>(content.Formatter);
        }

        [Fact]
        public void PostAsXmlAsync_Uri_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PostAsXmlAsync(new Uri("http://www.example.com"), new object()), "client");
        }

#if !Testing_NetStandard1_3 // Avoid "The configured formatter 'System.Net.Http.Formatting.XmlMediaTypeFormatter' cannot write an object of type 'Object'."
        [Fact]
        public void PostAsXmlAsync_Uri_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PostAsXmlAsync((Uri)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PostAsXmlAsync_Uri_UsesXmlMediaTypeFormatter()
        {
            var response = await _client.PostAsXmlAsync(new Uri("http://example.com"), new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<XmlMediaTypeFormatter>(content.Formatter);
        }
#endif

        [Fact]
        public void PostAsync_Uri_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PostAsync(new Uri("http://www.example.com"), new object(), new JsonMediaTypeFormatter(), "text/json"), "client");
        }

        [Fact]
        public void PostAsync_Uri_WhenRequestUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PostAsync((Uri)null, new object(), new JsonMediaTypeFormatter(), "text/json"),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PostAsync_Uri_WhenRequestUriIsSet_CreatesRequestWithAppropriateUri()
        {
            _client.BaseAddress = new Uri("http://example.com/");

            var response = await _client.PostAsync(new Uri("myapi/", UriKind.Relative), new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Equal("http://example.com/myapi/", request.RequestUri.ToString());
        }

        [Fact]
        public async Task PostAsync_Uri_WhenAuthoritativeMediaTypeIsSet_CreatesRequestWithAppropriateContentType()
        {
            var response = await _client.PostAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
            Assert.Equal("utf-16", request.Content.Headers.ContentType.CharSet);
        }

        [Fact]
        public async Task PostAsync_Uri_WhenFormatterIsSet_CreatesRequestWithObjectContentAndCorrectFormatter()
        {
            var response = await _client.PostAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            var content = Assert.IsType<ObjectContent<object>>(request.Content);
            Assert.Same(_formatter, content.Formatter);
        }

        [Fact]
        public async Task PostAsync_Uri_WhenAuthoritativeMediaTypeStringIsSet_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PostAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, mediaType, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PostAsync_Uri_WhenAuthoritativeMediaTypeStringIsSetWithoutCT_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PostAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, mediaType);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PostAsync_Uri_IssuesPostRequest()
        {
            var response = await _client.PostAsync(new Uri("http://example.com/myapi/"), new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Same(HttpMethod.Post, request.Method);
        }

        [Fact]
        public void PostAsync_Uri_WhenMediaTypeFormatterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() => _client.PostAsync(new Uri("http://example.com"), new object(), formatter: null), "formatter");
        }

        [Fact]
        public void PutAsJsonAsync_Uri_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PutAsJsonAsync(new Uri("http://www.example.com"), new object()), "client");
        }

        [Fact]
        public void PutAsJsonAsync_Uri_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PutAsJsonAsync((Uri)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PutAsJsonAsync_Uri_UsesJsonMediaTypeFormatter()
        {
            var response = await _client.PutAsJsonAsync(new Uri("http://example.com"), new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<JsonMediaTypeFormatter>(content.Formatter);
        }

        [Fact]
        public void PutAsXmlAsync_Uri_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PutAsXmlAsync(new Uri("http://www.example.com"), new object()), "client");
        }

#if !Testing_NetStandard1_3 // Avoid "The configured formatter 'System.Net.Http.Formatting.XmlMediaTypeFormatter' cannot write an object of type 'Object'."
        [Fact]
        public void PutAsXmlAsync_Uri_WhenUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PutAsXmlAsync((Uri)null, new object()),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PutAsXmlAsync_Uri_UsesXmlMediaTypeFormatter()
        {
            var response = await _client.PutAsXmlAsync(new Uri("http://example.com"), new object());

            var content = Assert.IsType<ObjectContent<object>>(response.RequestMessage.Content);
            Assert.IsType<XmlMediaTypeFormatter>(content.Formatter);
        }
#endif

        [Fact]
        public void PutAsync_Uri_WhenClientIsNull_ThrowsException()
        {
            HttpClient client = null;

            Assert.ThrowsArgumentNull(() => client.PutAsync(new Uri("http://www.example.com"), new object(), new JsonMediaTypeFormatter(), "text/json"), "client");
        }

        [Fact]
        public void PutAsync_Uri_WhenRequestUriIsNull_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => _client.PutAsync((Uri)null, new object(), new JsonMediaTypeFormatter(), "text/json"),
                InvalidUriMessage);
        }

        [Fact]
        public async Task PutAsync_Uri_WhenRequestUriIsSet_CreatesRequestWithAppropriateUri()
        {
            _client.BaseAddress = new Uri("http://example.com/");

            var response = await _client.PutAsync(new Uri("myapi/", UriKind.Relative), new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Equal("http://example.com/myapi/", request.RequestUri.ToString());
        }

        [Fact]
        public async Task PutAsync_Uri_WhenAuthoritativeMediaTypeIsSet_CreatesRequestWithAppropriateContentType()
        {
            var response = await _client.PutAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
            Assert.Equal("utf-16", request.Content.Headers.ContentType.CharSet);
        }

        [Fact]
        public async Task PutAsync_Uri_WhenFormatterIsSet_CreatesRequestWithObjectContentAndCorrectFormatter()
        {
            var response = await _client.PutAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, _mediaTypeHeader, CancellationToken.None);

            var request = response.RequestMessage;
            var content = Assert.IsType<ObjectContent<object>>(request.Content);
            Assert.Same(_formatter, content.Formatter);
        }

        [Fact]
        public async Task PutAsync_Uri_WhenAuthoritativeMediaTypeStringIsSet_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PutAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, mediaType, CancellationToken.None);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PutAsync_Uri_WhenAuthoritativeMediaTypeStringIsSetWithoutCT_CreatesRequestWithAppropriateContentType()
        {
            string mediaType = _mediaTypeHeader.MediaType;
            var response = await _client.PutAsync(new Uri("http://example.com/myapi/"), new object(), _formatter, mediaType);

            var request = response.RequestMessage;
            Assert.Equal("foo/bar", request.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task PutAsync_Uri_IssuesPutRequest()
        {
            var response = await _client.PutAsync(new Uri("http://example.com/myapi/"), new object(), _formatter);

            var request = response.RequestMessage;
            Assert.Same(HttpMethod.Put, request.Method);
        }

        [Fact]
        public void PutAsync_Uri_WhenMediaTypeFormatterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() => _client.PutAsync(new Uri("http://example.com"), new object(), formatter: null), "formatter");
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpClientFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http.Mocks;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpClientFactoryTest
    {
        public static TheoryDataSet<IEnumerable<DelegatingHandler>> InvalidPipelines
        {
            get
            {
                return new TheoryDataSet<IEnumerable<DelegatingHandler>>
                {
                    new List<DelegatingHandler>()
                    {
                        new MockDelegatingHandler(),
                        new MockDelegatingHandler(new HttpClientHandler())
                    },
                    new List<DelegatingHandler>()
                    {
                        new MockDelegatingHandler(new HttpClientHandler()),
                        new MockDelegatingHandler(),
                    },
                    new List<DelegatingHandler>()
                    {
                        null,
                        new MockDelegatingHandler(),
                    },
                    new List<DelegatingHandler>()
                    {
                        new MockDelegatingHandler(),
                        null,
                    },
                };
            }
        }

        [Fact]
        public void Create1_SetsInnerHandler()
        {
            // Arrange
            MockDelegatingHandler handler = new MockDelegatingHandler();

            // Act
            HttpClient client = HttpClientFactory.Create(handler);

            // Assert
            Assert.IsType<HttpClientHandler>(handler.InnerHandler);
        }

        [Fact]
        public void Create2_ThrowsOnNullInnerHandler()
        {
            Assert.ThrowsArgumentNull(() => HttpClientFactory.Create(null, new DelegatingHandler[0]), "innerHandler");
        }

        [Fact]
        public void Create2_SetsInnerHandler()
        {
            // Arrange
            MockDelegatingHandler handler = new MockDelegatingHandler();
            HttpClientHandler innerHandler = new HttpClientHandler();

            // Act
            HttpClient client = HttpClientFactory.Create(innerHandler, handler);

            // Assert
            Assert.IsType<HttpClientHandler>(handler.InnerHandler);
        }

        [Theory]
        [PropertyData("InvalidPipelines")]
        public void CreatePipeline_ThrowsOnInvalidPipeline(IEnumerable<DelegatingHandler> handlers)
        {
            Assert.ThrowsArgument(() => HttpClientFactory.CreatePipeline(new HttpClientHandler(), handlers), "handlers");
        }

        [Fact]
        public void CreatePipeline_ReturnsInnerHandler()
        {
            // Arrange
            HttpClientHandler innerHandler = new HttpClientHandler();

            // Act
            HttpMessageHandler handler = HttpClientFactory.CreatePipeline(innerHandler, null);

            // Assert
            Assert.Same(innerHandler, handler);
        }

        [Theory]
        [InlineData(1)]
        [InlineData(4)]
        [InlineData(16)]
        public void CreatePipeline_WiresUpHandlers(int maxHandlerCount)
        {
            // Arrange
            List<DelegatingHandler> handlers = new List<DelegatingHandler>();

            for (int handlerCount = 0; handlerCount < maxHandlerCount; handlerCount++)
            {
                handlers.Add(new MockDelegatingHandler());
            }

            HttpClientHandler innerHandler = new HttpClientHandler();

            // Act
            DelegatingHandler pipeline = HttpClientFactory.CreatePipeline(innerHandler, handlers) as DelegatingHandler;

            // Assert
            for (int index = 0; index < handlers.Count - 1; index++)
            {
                Assert.Same(handlers[index], pipeline);
                pipeline = pipeline.InnerHandler as DelegatingHandler;
            }
            Assert.Same(innerHandler, pipeline.InnerHandler);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpContentExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class HttpContentExtensionsTest
    {
        private static readonly IEnumerable<MediaTypeFormatter> _emptyFormatterList = Enumerable.Empty<MediaTypeFormatter>();
        private readonly Mock<MediaTypeFormatter> _formatterMock = new Mock<MediaTypeFormatter> { CallBase = true };
        private readonly MediaTypeHeaderValue _mediaType = new MediaTypeHeaderValue("foo/bar");
        private readonly MediaTypeFormatter[] _formatters;

        public HttpContentExtensionsTest()
        {
            _formatterMock.Object.SupportedMediaTypes.Add(_mediaType);
            _formatters = new[] { _formatterMock.Object };
        }

        [Fact]
        public void ReadAsAsync_WhenContentParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => HttpContentExtensions.ReadAsAsync(null, typeof(string), _emptyFormatterList), "content");
        }

        [Fact]
        public void ReadAsAsync_WhenTypeParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => HttpContentExtensions.ReadAsAsync(new StringContent(""), null, _emptyFormatterList), "type");
        }

        [Fact]
        public void ReadAsAsync_WhenFormattersParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => HttpContentExtensions.ReadAsAsync(new StringContent(""), typeof(string), null), "formatters");
        }

        [Fact]
        public void ReadAsAsyncOfT_WhenContentParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => HttpContentExtensions.ReadAsAsync<string>(null, _emptyFormatterList), "content");
        }

        [Fact]
        public void ReadAsAsyncOfT_WhenFormattersParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => HttpContentExtensions.ReadAsAsync<string>(new StringContent(""), null), "formatters");
        }

        [Fact]
        public async Task ReadAsAsyncOfT_WhenContentIsObjectContent_GoesThroughSerializationCycleToConvertTypes()
        {
            var content = new ObjectContent<int[]>(new int[] { 10, 20, 30, 40 }, new JsonMediaTypeFormatter());

            byte[] result = await content.ReadAsAsync<byte[]>();

            Assert.Equal(new byte[] { 10, 20, 30, 40 }, result);
        }

        [Fact]
        public void ReadAsAsyncOfT_WhenNoMatchingFormatterFound_Throws()
        {
            var content = new StringContent("{}");
            content.Headers.ContentType = _mediaType;
            content.Headers.ContentType.CharSet = "utf-16";
            var formatters = new MediaTypeFormatter[] { new JsonMediaTypeFormatter() };

            Assert.Throws<UnsupportedMediaTypeException>(() => content.ReadAsAsync<List<string>>(formatters),
                "No MediaTypeFormatter is available to read an object of type 'List`1' from content with media type 'foo/bar'.");
        }

        [Fact]
        public void ReadAsAsyncOfT_WhenTypeIsReferenceTypeAndNoMediaType_Throws()
        {
            var content = new StringContent("{}");
            content.Headers.ContentType = null;
            var formatters = new MediaTypeFormatter[] { new JsonMediaTypeFormatter() };

            Assert.Throws<UnsupportedMediaTypeException>(() => content.ReadAsAsync<List<string>>(formatters),
                "No MediaTypeFormatter is available to read an object of type 'List`1' from content with media type 'application/octet-stream'.");
        }

        [Fact]
        public void ReadAsAsyncOfT_WhenTypeIsValueTypeAndNoMediaType_Throws()
        {
            var content = new StringContent("123456");
            content.Headers.ContentType = null;
            var formatters = new MediaTypeFormatter[] { new JsonMediaTypeFormatter() };

            Assert.Throws<UnsupportedMediaTypeException>(() => content.ReadAsAsync<int>(formatters),
                "No MediaTypeFormatter is available to read an object of type 'Int32' from content with media type 'application/octet-stream'.");
        }

        [Fact]
        public async Task ReadAsAsyncOfT_ReadsFromContent_ThenInvokesFormattersReadFromStreamMethod()
        {
            Stream contentStream = null;
            string value = "42";
            var contentMock = new Mock<TestableHttpContent> { CallBase = true };
            contentMock.Setup(c => c.SerializeToStreamAsyncPublic(It.IsAny<Stream>(), It.IsAny<TransportContext>()))
                .Returns(TaskHelpers.Completed)
                .Callback((Stream s, TransportContext _) => contentStream = s)
                .Verifiable();
            HttpContent content = contentMock.Object;
            content.Headers.ContentType = _mediaType;
            _formatterMock
                .Setup(f => f.ReadFromStreamAsync(typeof(string), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns(Task.FromResult<object>(value));
            _formatterMock.Setup(f => f.CanReadType(typeof(string))).Returns(true);

            var resultValue = await content.ReadAsAsync<string>(_formatters);

            Assert.Same(value, resultValue);
            contentMock.Verify();
            _formatterMock.Verify(f => f.ReadFromStreamAsync(typeof(string), contentStream, content, null), Times.Once());
        }

        [Fact]
        public async Task ReadAsAsyncOfT_InvokesFormatterEvenIfContentLengthIsZero()
        {
            var content = new StringContent("");
            _formatterMock.Setup(f => f.CanReadType(typeof(string))).Returns(true);
            _formatterMock.Object.SupportedMediaTypes.Add(content.Headers.ContentType);
            _formatterMock
                .Setup(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns(Task.FromResult<object>(result: null));

            await content.ReadAsAsync<string>(_formatters);

            _formatterMock.Verify(f => f.ReadFromStreamAsync(typeof(string), It.IsAny<Stream>(), content, It.IsAny<IFormatterLogger>()), Times.Once());
        }

        [Fact]
        public async Task ReadAsAsync_WhenContentIsObjectContentAndValueIsCompatibleType_ReadsValueFromObjectContent()
        {
            _formatterMock.Setup(f => f.CanWriteType(typeof(TestClass))).Returns(true);
            var value = new TestClass();
            var content = new ObjectContent<TestClass>(value, _formatterMock.Object);

            Assert.Same(value, await content.ReadAsAsync<object>(_formatters));
            Assert.Same(value, await content.ReadAsAsync<TestClass>(_formatters));
            Assert.Same(value, await content.ReadAsAsync(typeof(object), _formatters));
            Assert.Same(value, await content.ReadAsAsync(typeof(TestClass), _formatters));

            _formatterMock.Verify(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), content, It.IsAny<IFormatterLogger>()), Times.Never());
        }

        [Fact]
        public async Task ReadAsAsync_WhenContentIsObjectContentAndValueIsNull_IfTypeIsNullable_SerializesAndDeserializesValue()
        {
            _formatterMock.Setup(f => f.CanWriteType(typeof(object))).Returns(true);
            _formatterMock.Setup(f => f.CanReadType(It.IsAny<Type>())).Returns(true);
            var content = new ObjectContent<object>(null, _formatterMock.Object);
            SetupUpRoundTripSerialization(type => null);

            Assert.Null(await content.ReadAsAsync<object>(_formatters));
            Assert.Null(await content.ReadAsAsync<TestClass>(_formatters));
            Assert.Null(await content.ReadAsAsync<Nullable<int>>(_formatters));
            Assert.Null(await content.ReadAsAsync(typeof(object), _formatters));
            Assert.Null(await content.ReadAsAsync(typeof(TestClass), _formatters));
            Assert.Null(await content.ReadAsAsync(typeof(Nullable<int>), _formatters));

            _formatterMock.Verify(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), content, It.IsAny<IFormatterLogger>()), Times.Exactly(6));
        }

        [Fact]
        public async Task ReadAsAsync_WhenContentIsObjectContentAndValueIsNull_IfTypeIsNotNullable_SerializesAndDeserializesValue()
        {
            _formatterMock.Setup(f => f.CanWriteType(typeof(object))).Returns(true);
            _formatterMock.Setup(f => f.CanReadType(typeof(Int32))).Returns(true);
            var content = new ObjectContent<object>(null, _formatterMock.Object, _mediaType);
            SetupUpRoundTripSerialization();

            Assert.IsType<Int32>(await content.ReadAsAsync<Int32>(_formatters));
            Assert.IsType<Int32>(await content.ReadAsAsync(typeof(Int32), _formatters));

            _formatterMock.Verify(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), content, It.IsAny<IFormatterLogger>()), Times.Exactly(2));
        }

        [Fact]
        public async Task ReadAsAsync_WhenContentIsObjectContentAndValueIsNotCompatibleType_SerializesAndDeserializesValue()
        {
            _formatterMock.Setup(f => f.CanWriteType(typeof(TestClass))).Returns(true);
            _formatterMock.Setup(f => f.CanReadType(typeof(string))).Returns(true);
            var value = new TestClass();
            var content = new ObjectContent<TestClass>(value, _formatterMock.Object, _mediaType);
            SetupUpRoundTripSerialization(type => new TestClass());

            await Assert.ThrowsAsync<InvalidCastException>(() => content.ReadAsAsync<string>(_formatters));

            Assert.IsNotType<string>(await content.ReadAsAsync(typeof(string), _formatters));

            _formatterMock.Verify(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), content, It.IsAny<IFormatterLogger>()), Times.Exactly(2));
        }

        [Fact]
        public async Task ReadAsAsync_WhenContentIsMultipartContentAndFormatterCanReadFromTheContent()
        {
            MultipartContent mimeContent = new MultipartContent();
            mimeContent.Add(new StringContent("multipartContent"));

            _formatterMock.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true);
            _formatterMock.Setup(f => f.CanReadType(It.IsAny<Type>())).Returns(true);
            _formatterMock.Setup(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns<Type, Stream, HttpContent, IFormatterLogger>(async (type, stream, content, logger) =>
                    {
                        MultipartMemoryStreamProvider provider = await content.ReadAsMultipartAsync();
                        HttpContent providerContent = Assert.Single(provider.Contents);
                        return await providerContent.ReadAsStringAsync();
                    });
            MediaTypeFormatter formatter = _formatterMock.Object;
            formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("multipart/mixed"));

            Assert.Equal("multipartContent", await mimeContent.ReadAsAsync<string>(new[] { formatter }));
        }

        [Fact]
        public async Task ReadAsAsync_type_cancellationToken_PassesCancellationTokenFurther()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            cts.Cancel();
            HttpContent content = new StringContent("42", Encoding.Default, "application/json");

            await Assert.ThrowsAsync<OperationCanceledException>(() => content.ReadAsAsync(typeof(int), cts.Token));
        }

        [Fact]
        public async Task ReadAsAsync_type_formatters_cancellationToken_PassesCancellationTokenFurther()
        {
            // Arrange
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(stream);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/test");
            CancellationToken token = new CancellationToken();
            Mock<MediaTypeFormatter> formatter = new Mock<MediaTypeFormatter>(MockBehavior.Strict);
            formatter.Object.SupportedMediaTypes.Add(content.Headers.ContentType);
            formatter.Setup(f => f.CanReadType(typeof(int))).Returns(true);
            formatter
                .Setup(f => f.ReadFromStreamAsync(typeof(int), It.IsAny<Stream>(), content, null, token))
                .Returns(Task.FromResult<object>(42))
                .Verifiable();

            // Act
            await content.ReadAsAsync(typeof(int), new[] { formatter.Object }, token);

            // Assert
            formatter.Verify();
        }

        [Fact]
        public async Task ReadAsAsync_type_formatters_formatterLogger_cancellationToken_PassesCancellationTokenFurther()
        {
            // Arrange
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(stream);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/test");
            CancellationToken token = new CancellationToken();
            IFormatterLogger formatterLogger = new Mock<IFormatterLogger>().Object;

            Mock<MediaTypeFormatter> formatter = new Mock<MediaTypeFormatter>(MockBehavior.Strict);
            formatter.Object.SupportedMediaTypes.Add(content.Headers.ContentType);
            formatter.Setup(f => f.CanReadType(typeof(int))).Returns(true);
            formatter
                .Setup(f => f.ReadFromStreamAsync(typeof(int), It.IsAny<Stream>(), content, formatterLogger, token))
                .Returns(Task.FromResult<object>(42))
                .Verifiable();

            // Act
            await content.ReadAsAsync(typeof(int), new[] { formatter.Object }, formatterLogger, token);

            // Assert
            formatter.Verify();
        }

        [Fact]
        public Task ReadAsAsyncOfT_cancellationToken_PassesCancellationTokenFurther()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            cts.Cancel();
            HttpContent content = new StringContent("42", Encoding.Default, "application/json");

            return Assert.ThrowsAsync<OperationCanceledException>(() => content.ReadAsAsync<int>(cts.Token));
        }

        [Fact]
        public async Task ReadAsAsyncOfT_formatters_cancellationToken_PassesCancellationTokenFurther()
        {
            // Arrange
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(stream);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/test");
            CancellationToken token = new CancellationToken();
            Mock<MediaTypeFormatter> formatter = new Mock<MediaTypeFormatter>(MockBehavior.Strict);
            formatter.Object.SupportedMediaTypes.Add(content.Headers.ContentType);
            formatter.Setup(f => f.CanReadType(typeof(int))).Returns(true);
            formatter
                .Setup(f => f.ReadFromStreamAsync(typeof(int), It.IsAny<Stream>(), content, null, token))
                .Returns(Task.FromResult<object>(42))
                .Verifiable();

            // Act
            await content.ReadAsAsync<int>(new[] { formatter.Object }, token);

            // Assert
            formatter.Verify();
        }

        [Fact]
        public async Task ReadAsAsyncOfT_formatters_formatterLogger_cancellationToken_PassesCancellationTokenFurther()
        {
            // Arrange
            Stream stream = new MemoryStream();
            HttpContent content = new StreamContent(stream);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/test");
            CancellationToken token = new CancellationToken();
            IFormatterLogger formatterLogger = new Mock<IFormatterLogger>().Object;

            Mock<MediaTypeFormatter> formatter = new Mock<MediaTypeFormatter>(MockBehavior.Strict);
            formatter.Object.SupportedMediaTypes.Add(content.Headers.ContentType);
            formatter.Setup(f => f.CanReadType(typeof(int))).Returns(true);
            formatter
                .Setup(f => f.ReadFromStreamAsync(typeof(int), It.IsAny<Stream>(), content, formatterLogger, token))
                .Returns(Task.FromResult<object>(42))
                .Verifiable();

            // Act
            await content.ReadAsAsync<int>(new[] { formatter.Object }, formatterLogger, token);

            // Assert
            formatter.Verify();
        }

        private void SetupUpRoundTripSerialization(Func<Type, object> factory = null)
        {
            factory = factory ?? Activator.CreateInstance;
            _formatterMock.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<TransportContext>()))
                .Returns(TaskHelpers.Completed());
            _formatterMock.Setup(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns<Type, Stream, HttpContent, IFormatterLogger>((type, stream, content, logger) => Task.FromResult<object>(factory(type)));
        }

        public class TestClass { }

        public abstract class TestableHttpContent : HttpContent
        {
            protected override Task<Stream> CreateContentReadStreamAsync()
            {
                return CreateContentReadStreamAsyncPublic();
            }

            public virtual Task<Stream> CreateContentReadStreamAsyncPublic()
            {
                return base.CreateContentReadStreamAsync();
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return SerializeToStreamAsyncPublic(stream, context);
            }

            public abstract Task SerializeToStreamAsyncPublic(Stream stream, TransportContext context);

            protected override bool TryComputeLength(out long length)
            {
                return TryComputeLengthPublic(out length);
            }

            public abstract bool TryComputeLengthPublic(out long length);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpContentFormDataExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpContentFormDataExtensionsTest
    {
        public static TheoryDataSet<string> FormDataContentTypes
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "application/x-www-form-urlencoded",
                    "APPLICATION/x-www-form-urlencoded",
                    "application/X-WWW-FORM-URLENCODED",
                    "application/x-www-form-urlencoded; charset=utf-8",
                    "application/x-www-form-urlencoded; parameter=value",
                };
            }
        }

        public static TheoryDataSet<string> NonFormDataContentTypes
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "application/xml",
                    "APPLICATION/json",
                    "text/xml",
                    "text/xml; charset=utf-8",
                    "text/xml; parameter=value",
                };
            }
        }

        public static TheoryDataSet<string> FormData
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "a=b",
                    "a+c=d+e",
                    "n1=v1&n2=v2",
                    "n1=v1a+v1b&n2=v2a+v2b",
                };
            }
        }

        public static TheoryDataSet<string> IrregularFormData
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "?data",
                    Char.ConvertFromUtf32(0x0D),
                    "Hello World",
                    "<string>Hello World</string>",
                    "{ \"Message\" : \"Hello World\"",
                };
            }
        }

        [Fact]
        public void IsFormData_ThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => HttpContentFormDataExtensions.IsFormData(null), "content");
        }

        [Fact]
        public void IsFormData_HandlesNullContentType()
        {
            HttpContent content = new StringContent(String.Empty);
            content.Headers.ContentType = null;
            Assert.False(content.IsFormData());
        }

        [Theory]
        [PropertyData("FormDataContentTypes")]
        public void IsFormData_AcceptsFormDataMediaTypes(string mediaType)
        {
            HttpContent content = new StringContent(String.Empty);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            Assert.True(content.IsFormData());
        }

        [Theory]
        [PropertyData("NonFormDataContentTypes")]
        public void IsFormData_RejectsNonFormDataMediaTypes(string mediaType)
        {
            HttpContent content = new StringContent(String.Empty);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            Assert.False(content.IsFormData());
        }

        [Fact]
        public void ReadAsFormDataAsync_ThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => HttpContentFormDataExtensions.ReadAsFormDataAsync(null), "content");
        }

        [Fact]
        public async Task ReadAsFromDataAsync_PassesCancellationToken()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            cts.Cancel();
            HttpContent content = new StringContent("");
            content.Headers.ContentType = MediaTypeConstants.ApplicationFormUrlEncodedMediaType;

            await Assert.ThrowsAsync<OperationCanceledException>(() => content.ReadAsFormDataAsync(cts.Token));
        }

        [Theory]
        [PropertyData("FormData")]
        public async Task ReadAsFormDataAsync_HandlesFormData(string formData)
        {
            // Arrange
            HttpContent content = new StringContent(formData);
            content.Headers.ContentType = MediaTypeConstants.ApplicationFormUrlEncodedMediaType;

            // Act
            NameValueCollection data = await content.ReadAsFormDataAsync();

            // Assert
            Assert.Equal(formData, data.ToString());
        }

        [Fact]
        public async Task ReadAsFormDataAsync_HandlesFormData_Encoded()
        {
            // Arrange
            string formData = "N=%c3%a6%c3%b8%c3%a5";
            HttpContent content = new StringContent(formData);
            content.Headers.ContentType = MediaTypeConstants.ApplicationFormUrlEncodedMediaType;

            // Act
            NameValueCollection data = await content.ReadAsFormDataAsync();

            // Assert
            Assert.Equal(formData, data.ToString(), ignoreCase: true);
        }

        [Theory]
        [PropertyData("IrregularFormData")]
        public async Task ReadAsFormDataAsync_HandlesIrregularFormData(string irregularFormData)
        {
            // Arrange
            HttpContent content = new StringContent(irregularFormData);
            content.Headers.ContentType = MediaTypeConstants.ApplicationFormUrlEncodedMediaType;

            // Act
            NameValueCollection data = await content.ReadAsFormDataAsync();

            // Assert
            Assert.Single(data);
            Assert.NotNull(data[irregularFormData]);
        }

        [Fact]
        public Task ReadAsFormDataAsync_HandlesNonFormData()
        {
            HttpContent content = new StringContent("{}", Encoding.UTF8, "test/unknown");
            return Assert.ThrowsAsync<UnsupportedMediaTypeException>(() => content.ReadAsFormDataAsync());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpContentMessageExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpContentMessageExtensionsTests
    {
        public static TheoryDataSet<IEnumerable<string>> ClientRoundTripData
        {
            get
            {
                return new TheoryDataSet<IEnumerable<string>>
                {
                    new string[]
                    {
                        @"GET / HTTP/1.1",
                        @"Accept: text/html, application/xhtml+xml, */*",
                        @"Accept-Language: en-US",
                        @"User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; WOW64; Trident/5.0)",
                        @"Accept-Encoding: gzip, deflate",
                        @"Proxy-Connection: Keep-Alive",
                        @"Host: msdn.microsoft.com",
                        @"Cookie: omniID=1297715979621_9f45_1519_3f8a_f22f85346ac6; WT_FPC=id=65.55.227.138-2323234032.30136233:lv=1309374389020:ss=1309374389020; A=I&I=AxUFAAAAAACNCAAADYEZ7CFPss7Swnujy4PXZA!!&M=1&CS=126mAa0002ZB51a02gZB51a; MC1=GUID=568428660ad44d4ab8f46133f4b03738&HASH=6628&LV=20113&V=3; WT_NVR_RU=0=msdn:1=:2=; MUID=A44DE185EA1B4E8088CCF7B348C5D65F; MSID=Microsoft.CreationDate=03/04/2011 23:38:15&Microsoft.LastVisitDate=06/20/2011 04:15:08&Microsoft.VisitStartDate=06/20/2011 04:15:08&Microsoft.CookieId=f658f3f2-e6d6-42ab-b86b-96791b942b6f&Microsoft.TokenId=ffffffff-ffff-ffff-ffff-ffffffffffff&Microsoft.NumberOfVisits=106&Microsoft.CookieFirstVisit=1&Microsoft.IdentityToken=AA==&Microsoft.MicrosoftId=0441-6141-1523-9969; msresearch=%7B%22version%22%3A%224.6%22%2C%22state%22%3A%7B%22name%22%3A%22IDLE%22%2C%22url%22%3Aundefined%2C%22timestamp%22%3A1299281911415%7D%2C%22lastinvited%22%3A1299281911415%2C%22userid%22%3A%2212992819114151265672533023080%22%2C%22vendorid%22%3A1%2C%22surveys%22%3A%5Bundefined%5D%7D; CodeSnippetContainerLang=C#; msdn=L=1033; ADS=SN=175A21EF; s_cc=true; s_sq=%5B%5BB%5D%5D; TocHashCookie=ms310241(n)/aa187916(n)/aa187917(n)/dd273952(n)/dd295083(n)/ff472634(n)/ee667046(n)/ee667070(n)/gg259047(n)/gg618436(n)/; WT_NVR=0=/:1=query|library|en-us:2=en-us/vcsharp|en-us/library",
                        @"Cookie: omniID=1297715979621_9f45_1519_3f8a_f22f85346ac6; WT_FPC=id=65.55.227.138-2323234032.30136233:lv=1309374389020:ss=1309374389020; A=I&I=AxUFAAAAAACNCAAADYEZ7CFPss7Swnujy4PXZA!!&M=1&CS=126mAa0002ZB51a02gZB51a; MC1=GUID=568428660ad44d4ab8f46133f4b03738&HASH=6628&LV=20113&V=3; WT_NVR_RU=0=msdn:1=:2=; MUID=A44DE185EA1B4E8088CCF7B348C5D65F; MSID=Microsoft.CreationDate=03/04/2011 23:38:15&Microsoft.LastVisitDate=06/20/2011 04:15:08&Microsoft.VisitStartDate=06/20/2011 04:15:08&Microsoft.CookieId=f658f3f2-e6d6-42ab-b86b-96791b942b6f&Microsoft.TokenId=ffffffff-ffff-ffff-ffff-ffffffffffff&Microsoft.NumberOfVisits=106&Microsoft.CookieFirstVisit=1&Microsoft.IdentityToken=AA==&Microsoft.MicrosoftId=0441-6141-1523-9969; msresearch=%7B%22version%22%3A%224.6%22%2C%22state%22%3A%7B%22name%22%3A%22IDLE%22%2C%22url%22%3Aundefined%2C%22timestamp%22%3A1299281911415%7D%2C%22lastinvited%22%3A1299281911415%2C%22userid%22%3A%2212992819114151265672533023080%22%2C%22vendorid%22%3A1%2C%22surveys%22%3A%5Bundefined%5D%7D; CodeSnippetContainerLang=C#; msdn=L=1033; ADS=SN=175A21EF; s_cc=true; s_sq=%5B%5BB%5D%5D; TocHashCookie=ms310241(n)/aa187916(n)/aa187917(n)/dd273952(n)/dd295083(n)/ff472634(n)/ee667046(n)/ee667070(n)/gg259047(n)/gg618436(n)/; WT_NVR=0=/:1=query|library|en-us:2=en-us/vcsharp|en-us/library",
                    },
                    new string[]
                    {
                        @"GET / HTTP/1.1",
                        @"Host: msdn.microsoft.com",
                        @"Proxy-Connection: keep-alive",
                        @"User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:5.0) Gecko/20100101 Firefox/5.0",
                        @"Accept: text/html, application/xhtml+xml, application/xml; q=0.9, */*; q=0.8",
                        @"Accept-Language: en-us, en; q=0.5",
                        @"Accept-Encoding: gzip, deflate",
                        @"Accept-Charset: ISO-8859-1, utf-8; q=0.7, *; q=0.7",
                    },
                    new string[]
                    {
                        @"GET / HTTP/1.1",
                        @"Host: msdn.microsoft.com",
                        @"Proxy-Connection: keep-alive",
                        @"User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/534.30 (KHTML, like Gecko) Chrome/12.0.742.100 Safari/534.30",
                        @"Accept: text/html, application/xhtml+xml, application/xml; q=0.9, */*; q=0.8",
                        @"Accept-Encoding: gzip, deflate, sdch",
                        @"Accept-Language: en-US, en; q=0.8",
                        @"Accept-Charset: ISO-8859-1, utf-8; q=0.7, *; q=0.3",
                    },
                    new string[]
                    {
                        @"GET / HTTP/1.1",
                        @"Host: msdn.microsoft.com",
                        @"User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.1; en-US) AppleWebKit/533.21.1 (KHTML, like Gecko) Version/5.0.5 Safari/533.21.1",
                        @"Accept: application/xml, application/xhtml+xml, text/html; q=0.9, text/plain; q=0.8, image/png, */*; q=0.5",
                        @"Accept-Language: en-US",
                        @"Accept-Encoding: gzip, deflate",
                        @"Connection: keep-alive",
                        @"Proxy-Connection: keep-alive",
                    },
                    new string[]
                    {
                        @"GET / HTTP/1.0",
                        @"User-Agent: Opera/9.80 (Windows NT 6.1; U; en) Presto/2.8.131 Version/11.11",
                        @"Host: msdn.microsoft.com",
                        @"Accept: text/html, application/xml; q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/x-xbitmap, */*; q=0.1",
                        @"Accept-Language: en-US, en; q=0.9",
                        @"Accept-Encoding: gzip, deflate",
                        @"Proxy-Connection: Keep-Alive",
                    },
                };
            }
        }

        public static TheoryDataSet<IEnumerable<string>> ServerRoundTripData
        {
            get
            {
                return new TheoryDataSet<IEnumerable<string>>
                {
                    new string[]
                    {
                        @"HTTP/1.1 200 OK",
                        @"Server: nginx",
                        @"Date: Mon, 26 Dec 2011 16:33:07 GMT",
                        @"Connection: keep-alive",
                        @"Set-Cookie: CG=US:WA:Bellevue; path=/",
                        @"Vary: Accept-Encoding, User-Agent",
                        @"Cache-Control: max-age=60, private",
                        @"Content-Length: 124",
                        @"Content-Type: text/html; charset=UTF-8",
                    },
                    new string[]
                    {
                        @"HTTP/1.1 302 Found",
                        @"Proxy-Connection: Keep-Alive",
                        @"Connection: Keep-Alive",
                        @"Via: 1.1 RED-PRXY-23",
                        @"Date: Thu, 30 Jun 2011 00:16:35 GMT",
                        @"Location: /en-us/",
                        @"Server: Microsoft-IIS/7.5",
                        @"Cache-Control: private",
                        @"P3P: CP=""ALL IND DSP COR ADM CONo CUR CUSo IVAo IVDo PSA PSD TAI TELo OUR SAMo CNT COM INT NAV ONL PHY PRE PUR UNI"", CP=""ALL IND DSP COR ADM CONo CUR CUSo IVAo IVDo PSA PSD TAI TELo OUR SAMo CNT COM INT NAV ONL PHY PRE PUR UNI""",
                        @"Set-Cookie: A=I&I=AxUFAAAAAAD7BwAA8Jx0njhGoW3MGASDmzeaGw!!&M=1; domain=.microsoft.com; expires=Sun, 30-Jun-2041 00:16:35 GMT; path=/",
                        @"Set-Cookie: ADS=SN=175A21EF; domain=.microsoft.com; path=/",
                        @"Set-Cookie: Sto.UserLocale=en-us; path=/",
                        @"Set-Cookie: A=I&I=AxUFAAAAAAD7BwAA8Jx0njhGoW3MGASDmzeaGw!!&M=1; domain=.microsoft.com; expires=Sun, 30-Jun-2041 00:16:35 GMT; path=/; path=/",
                        @"Set-Cookie: ADS=SN=175A21EF; domain=.microsoft.com; path=/; path=/",
                        @"X-AspNetMvc-Version: 3.0",
                        @"X-AspNet-Version: 4.0.30319",
                        @"X-Powered-By: ASP.NET",
                        @"X-Powered-By: ASP.NET",
                        @"Content-Length: 124",
                        @"Content-Type: text/html; charset=utf-8",
                    },
                    new string[]
                    {
                        @"HTTP/1.1 200 OK",
                        @"Proxy-Connection: Keep-Alive",
                        @"Connection: Keep-Alive",
                        @"Transfer-Encoding: chunked",
                        @"Via: 1.1 RED-PRXY-07",
                        @"Date: Mon, 26 Dec 2011 19:11:47 GMT",
                        @"Server: gws",
                        @"Cache-Control: max-age=0, private",
                        @"Set-Cookie: PREF=ID=e91cfd77b562e989:FF=0:TM=1324926707:LM=1324926707:S=4w8_eSySJPXCCjhT; expires=Wed, 25-Dec-2013 19:11:47 GMT; path=/; domain=.google.com",
                        @"Set-Cookie: NID=54=bSMpxl0q0MVlvG-eZYSBtQuYTF1clqrA-TSIZT8wZcbhrrsdkP9G5zPiXGSBmiNu656QR3xfTXKUPkP-HqY_nSnsjj1fb-ipoZ3DUcyXb9oS9_8tjz3NZ3A44GPCmRPx; expires=Tue, 26-Jun-2012 19:11:47 GMT; path=/; domain=.google.com; HttpOnly",
                        @"P3P: CP=""This is not a P3P policy! See http://www.google.com/support/accounts/bin/answer.py?hl=en&answer=151657 for more info.""",
                        @"X-XSS-Protection: 1; mode=block",
                        @"X-Frame-Options: SAMEORIGIN",
                        @"Expires: -1",
                        @"Content-Type: text/html; charset=ISO-8859-1",
                    }
                };
            }
        }

        public static TheoryDataSet<HttpContent> NotHttpMessageContent
        {
            get
            {
                return new TheoryDataSet<HttpContent>
                {
                    new ByteArrayContent(new byte[] { }),
                    new StringContent(String.Empty),
                    new StringContent(String.Empty, Encoding.UTF8, "application/http"),
                };
            }
        }

        private static HttpContent CreateContent(bool isRequest, bool hasEntity)
        {
            string message;
            if (isRequest)
            {
                message = hasEntity ? ParserData.HttpRequestWithEntity : ParserData.HttpRequest;
            }
            else
            {
                message = hasEntity ? ParserData.HttpResponseWithEntity : ParserData.HttpResponse;
            }

            StringContent content = new StringContent(message);
            content.Headers.ContentType = isRequest ? ParserData.HttpRequestMediaType : ParserData.HttpResponseMediaType;
            return content;
        }

        private static HttpContent CreateContent(bool isRequest, IEnumerable<string> header, string body)
        {
            StringBuilder message = new StringBuilder();
            foreach (string h in header)
            {
                message.Append(h);
                message.Append("\r\n");
            }

            message.Append("\r\n");
            if (body != null)
            {
                message.Append(body);
            }

            StringContent content = new StringContent(message.ToString());
            content.Headers.ContentType = isRequest ? ParserData.HttpRequestMediaType : ParserData.HttpResponseMediaType;
            return content;
        }

        private static async Task ValidateEntityAsync(HttpContent content)
        {
            Assert.NotNull(content);
            Assert.Equal(ParserData.TextContentType, content.Headers.ContentType.ToString());
            string entity = await content.ReadAsStringAsync();
            Assert.Equal(ParserData.HttpMessageEntity, entity);
        }

        private static async Task ValidateRequestMessageAsync(HttpRequestMessage request, bool hasEntity)
        {
            Assert.NotNull(request);
            Assert.Equal(Version.Parse("1.2"), request.Version);
            Assert.Equal(ParserData.HttpMethod, request.Method.ToString());
            Assert.Equal(ParserData.HttpRequestUri, request.RequestUri);
            Assert.Equal(ParserData.HttpHostName, request.Headers.Host);
            Assert.True(request.Headers.Contains("N1"), "request did not contain expected N1 header.");
            Assert.True(request.Headers.Contains("N2"), "request did not contain expected N2 header.");

            if (hasEntity)
            {
                await ValidateEntityAsync(request.Content);
            }
        }

        private static async Task ValidateResponseMessageAsync(HttpResponseMessage response, bool hasEntity)
        {
            Assert.NotNull(response);
            Assert.Equal(new Version("1.2"), response.Version);
            Assert.Equal(ParserData.HttpStatus, response.StatusCode);
            Assert.Equal(ParserData.HttpReasonPhrase, response.ReasonPhrase);
            Assert.True(response.Headers.Contains("N1"), "Response did not contain expected N1 header.");
            Assert.True(response.Headers.Contains("N2"), "Response did not contain expected N2 header.");

            if (hasEntity)
            {
                await ValidateEntityAsync(response.Content);
            }
        }

        [Fact]
        public void ReadAsHttpRequestMessageAsync_VerifyArguments()
        {
            Assert.ThrowsArgumentNull(() => HttpContentMessageExtensions.ReadAsHttpRequestMessageAsync(null), "content");
            Assert.ThrowsArgument(() => new ByteArrayContent(new byte[] { }).ReadAsHttpRequestMessageAsync(), "content");
            Assert.ThrowsArgument(() => new StringContent(String.Empty).ReadAsHttpRequestMessageAsync(), "content");
            Assert.ThrowsArgument(() => new StringContent(String.Empty, Encoding.UTF8, "application/http").ReadAsHttpRequestMessageAsync(), "content");

            Assert.ThrowsArgument(() =>
            {
                HttpContent content = new StringContent(String.Empty);
                content.Headers.ContentType = ParserData.HttpResponseMediaType;
                content.ReadAsHttpRequestMessageAsync();
            }, "content");

            Assert.ThrowsArgumentNull(() =>
            {
                HttpContent content = new StringContent(String.Empty);
                content.Headers.ContentType = ParserData.HttpRequestMediaType;
                content.ReadAsHttpRequestMessageAsync(null);
            }, "uriScheme");

            Assert.ThrowsArgument(() =>
            {
                HttpContent content = new StringContent(String.Empty);
                content.Headers.ContentType = ParserData.HttpRequestMediaType;
                content.ReadAsHttpRequestMessageAsync("i n v a l i d");
            }, "uriScheme");

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() =>
            {
                HttpContent content = new StringContent(String.Empty);
                content.Headers.ContentType = ParserData.HttpRequestMediaType;
                content.ReadAsHttpRequestMessageAsync(Uri.UriSchemeHttp, ParserData.MinBufferSize - 1);
            }, "bufferSize", ParserData.MinBufferSize.ToString(), ParserData.MinBufferSize - 1);
        }

        [Fact]
        public void ReadAsHttpResponseMessageAsync_VerifyArguments()
        {
            Assert.ThrowsArgumentNull(() => HttpContentMessageExtensions.ReadAsHttpResponseMessageAsync(null), "content");
            Assert.ThrowsArgument(() => new ByteArrayContent(new byte[] { }).ReadAsHttpResponseMessageAsync(), "content");
            Assert.ThrowsArgument(() => new StringContent(String.Empty).ReadAsHttpResponseMessageAsync(), "content");
            Assert.ThrowsArgument(() => new StringContent(String.Empty, Encoding.UTF8, "application/http").ReadAsHttpResponseMessageAsync(), "content");

            Assert.ThrowsArgument(() =>
            {
                HttpContent content = new StringContent(String.Empty);
                content.Headers.ContentType = ParserData.HttpRequestMediaType;
                content.ReadAsHttpResponseMessageAsync();
            }, "content");

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() =>
            {
                HttpContent content = new StringContent(String.Empty);
                content.Headers.ContentType = ParserData.HttpResponseMediaType;
                content.ReadAsHttpResponseMessageAsync(ParserData.MinBufferSize - 1);
            }, "bufferSize", ParserData.MinBufferSize.ToString(), ParserData.MinBufferSize - 1);
        }

        [Fact]
        public void IsHttpRequestMessageContentVerifyArguments()
        {
            Assert.ThrowsArgumentNull(() => HttpContentMessageExtensions.IsHttpRequestMessageContent(null), "content");
        }

        [Fact]
        public void IsHttpResponseMessageContentVerifyArguments()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                HttpContent content = null;
                HttpContentMessageExtensions.IsHttpResponseMessageContent(content);
            }, "content");
        }

        [Theory]
        [PropertyData("NotHttpMessageContent")]
        public void IsHttpRequestMessageContentRespondsFalse(HttpContent notHttpMessageContent)
        {
            Assert.False(notHttpMessageContent.IsHttpRequestMessageContent());
        }

        [Fact]
        public void IsHttpRequestMessageContentRespondsTrue()
        {
            HttpContent content = new StringContent(String.Empty);
            content.Headers.ContentType = ParserData.HttpRequestMediaType;
            Assert.True(content.IsHttpRequestMessageContent(), "Content should be HTTP request.");
        }

        [Theory]
        [PropertyData("NotHttpMessageContent")]
        public void IsHttpResponseMessageContent(HttpContent notHttpMessageContent)
        {
            Assert.False(notHttpMessageContent.IsHttpResponseMessageContent());

        }

        [Fact]
        public void IsHttpResponseMessageContentRespondsTrue()
        {
            HttpContent content = new StringContent(String.Empty);
            content.Headers.ContentType = ParserData.HttpResponseMediaType;
            Assert.True(content.IsHttpResponseMessageContent(), "Content should be HTTP response.");
        }

        [Fact]
        public async Task ReadAsHttpRequestMessageAsync_RequestWithoutEntity_ShouldReturnHttpRequestMessage()
        {
            HttpContent content = CreateContent(isRequest: true, hasEntity: false);
            HttpRequestMessage httpRequest = await content.ReadAsHttpRequestMessageAsync();
            await ValidateRequestMessageAsync(httpRequest, hasEntity: false);
        }

        [Fact]
        public async Task ReadAsHttpRequestMessageAsync_RequestWithEntity_ShouldReturnHttpRequestMessage()
        {
            HttpContent content = CreateContent(isRequest: true, hasEntity: true);
            HttpRequestMessage httpRequest = await content.ReadAsHttpRequestMessageAsync();
            await ValidateRequestMessageAsync(httpRequest, hasEntity: true);
        }

        [Fact]
        public async Task ReadAsHttpRequestMessageAsync_WithHttpsUriScheme_ReturnsUriWithHttps()
        {
            HttpContent content = CreateContent(isRequest: true, hasEntity: true);
            HttpRequestMessage httpRequest = await content.ReadAsHttpRequestMessageAsync(Uri.UriSchemeHttps);
            Assert.Equal(ParserData.HttpsRequestUri, httpRequest.RequestUri);
        }

        [Fact]
        public async Task ReadAsHttpResponseMessageAsync_ResponseWithoutEntity_ShouldReturnHttpResponseMessage()
        {
            HttpContent content = CreateContent(isRequest: false, hasEntity: false);
            HttpResponseMessage httpResponse = await content.ReadAsHttpResponseMessageAsync();
            await ValidateResponseMessageAsync(httpResponse, hasEntity: false);
        }

        [Fact]
        public async Task ReadAsHttpResponseMessageAsync_ResponseWithEntity_ShouldReturnHttpResponseMessage()
        {
            HttpContent content = CreateContent(isRequest: false, hasEntity: true);
            HttpResponseMessage httpResponse = await content.ReadAsHttpResponseMessageAsync();
            await ValidateResponseMessageAsync(httpResponse, hasEntity: true);
        }

        [Fact]
        public Task ReadAsHttpRequestMessageAsync_NoHostHeader_Throws()
        {
            string[] request = new[] {
                @"GET / HTTP/1.1",
            };

            HttpContent content = CreateContent(true, request, null);
            return Assert.ThrowsAsync<InvalidOperationException>(() => content.ReadAsHttpRequestMessageAsync());
        }

        [Fact]
        public Task ReadAsHttpRequestMessageAsync_TwoHostHeaders_Throws()
        {
            string[] request = new[] {
                @"GET / HTTP/1.1",
                @"Host: somehost.com",
                @"Host: otherhost.com",
            };

            HttpContent content = CreateContent(true, request, null);
            return Assert.ThrowsAsync<InvalidOperationException>(() => content.ReadAsHttpRequestMessageAsync());
        }

        [Fact]
        public async Task ReadAsHttpRequestMessageAsync_SortHeaders()
        {
            string[] request = new[] {
                @"GET / HTTP/1.1",
                @"Host: somehost.com",
                @"Content-Language: xx",
                @"Request-Header: zz",
            };

            HttpContent content = CreateContent(true, request, "sample body");
            HttpRequestMessage httpRequest = await content.ReadAsHttpRequestMessageAsync();
            Assert.Equal("xx", httpRequest.Content.Headers.ContentLanguage.ToString());

            IEnumerable<string> requestHeaderValues;
            Assert.True(httpRequest.Headers.TryGetValues("request-header", out requestHeaderValues));
            Assert.Equal("zz", requestHeaderValues.First());
        }

        [Fact]
        public async Task ReadAsHttpResponseMessageAsync_SortHeaders()
        {
            string[] response = new[] {
                @"HTTP/1.1 200 OK",
                @"Content-Language: xx",
                @"Response-Header: zz",
            };

            HttpContent content = CreateContent(false, response, "sample body");
            HttpResponseMessage httpResponse = await content.ReadAsHttpResponseMessageAsync();
            Assert.Equal("xx", httpResponse.Content.Headers.ContentLanguage.ToString());

            IEnumerable<string> ResponseHeaderValues;
            Assert.True(httpResponse.Headers.TryGetValues("Response-header", out ResponseHeaderValues));
            Assert.Equal("zz", ResponseHeaderValues.First());
        }

        [Fact]
        public Task ReadAsHttpResponseMessageAsync_Throws_TheHeaderSizeExceededTheDefaultLimit()
        {
            string[] response = new[] {
                @"HTTP/1.1 200 OK",
                String.Format("Set-Cookie: {0}={1}", new String('a', 16 * 1024), new String('b', 16 * 1024))
            };

            return Assert.ThrowsAsync<InvalidOperationException>(() =>
                {
                    HttpContent content = CreateContent(false, response, "sample body");
                    return content.ReadAsHttpResponseMessageAsync();
                });
        }

        [Fact]
        public Task ReadAsHttpRequestMessageAsync_Throws_TheHeaderSizeExceededTheDefaultLimit()
        {
            string[] request = new[] {
                @"GET / HTTP/1.1",
                @"Host: msdn.microsoft.com",
                String.Format("Cookie: {0}={1}", new String('a', 16 * 1024), new String('b', 16 * 1024))
            };

            return Assert.ThrowsAsync<InvalidOperationException>(() =>
            {
                HttpContent content = CreateContent(true, request, "sample body");
                return content.ReadAsHttpRequestMessageAsync();
            });
        }

        [Fact]
        public Task ReadAsHttpResponseMessageAsync_LargeHeaderSize()
        {
            string[] response = new[] {
                @"HTTP/1.1 200 OK",
                String.Format("Set-Cookie: {0}={1}", new String('a', 16 * 1024), new String('b', 16 * 1024))
            };

            HttpContent content = CreateContent(false, response, "sample body");
            return content.ReadAsHttpResponseMessageAsync(64 * 1024, 64 * 1024);
        }

        [Fact]
        public async Task ReadAsHttpRequestMessageAsync_LargeHeaderSize()
        {
            string cookieValue = string.Format("{0}={1}", new String('a', 16 * 1024), new String('b', 16 * 1024));
            string[] request = new[] {
                @"GET / HTTP/1.1",
                @"Host: msdn.microsoft.com",
                string.Format("Cookie: {0}", cookieValue),
            };

            HttpContent content = CreateContent(true, request, "sample body");
            var httpRequestMessage = await content.ReadAsHttpRequestMessageAsync(Uri.UriSchemeHttp, 64 * 1024, 64 * 1024);

            Assert.Equal(HttpMethod.Get, httpRequestMessage.Method);
            Assert.Equal("/", httpRequestMessage.RequestUri.PathAndQuery);
            Assert.Equal("msdn.microsoft.com", httpRequestMessage.Headers.Host);
            IEnumerable<string> actualCookieValue;
            Assert.True(httpRequestMessage.Headers.TryGetValues("Cookie", out actualCookieValue));
            Assert.Equal(cookieValue, Assert.Single(actualCookieValue));
        }

        [Fact]
        public async Task ReadAsHttpRequestMessageAsync_LargeHttpRequestLine()
        {
            string requestPath = string.Format("/myurl?{0}={1}", new string('a', 4 * 1024), new string('b', 4 * 1024));
            string cookieValue = string.Format("{0}={1}", new String('a', 4 * 1024), new String('b', 4 * 1024));
            string[] request = new[]
            {
                string.Format("GET {0} HTTP/1.1", requestPath),
                @"Host: msdn.microsoft.com",
                string.Format("Cookie: {0}", cookieValue),
            };

            HttpContent content = CreateContent(true, request, "sample body");
            var httpRequestMessage = await content.ReadAsHttpRequestMessageAsync(
                Uri.UriSchemeHttp,
                bufferSize: 64 * 1024,
                maxHeaderSize: 64 * 1024);

            Assert.Equal(HttpMethod.Get, httpRequestMessage.Method);
            Assert.Equal(requestPath, httpRequestMessage.RequestUri.PathAndQuery);
            Assert.Equal("msdn.microsoft.com", httpRequestMessage.Headers.Host);
            IEnumerable<string> actualCookieValue;
            Assert.True(httpRequestMessage.Headers.TryGetValues("Cookie", out actualCookieValue));
            Assert.Equal(cookieValue, Assert.Single(actualCookieValue));
        }

        [Theory]
        [InlineData("")]
        [InlineData("HTTP/1.1")]
        [InlineData("HTTP/1.1 200 OK")]
        [InlineData("HTTP/1.1 200 OK\r\n")]
        [InlineData("HTTP/1.1 200 OK\r\nServer:")]
        [InlineData("HTTP/1.1 200 OK\r\nServer: server")]
        [InlineData("HTTP/1.1 200 OK\r\nServer: server\r\n")]
        [InlineData("HTTP/1.1 200 OK\r\nServer: server\r\n\r")]
        public Task ReadAsHttpResponseMessageAsync_IncompleteResponse(string incompleteResponse)
        {
            StringContent content = new StringContent(incompleteResponse);
            content.Headers.ContentType = ParserData.HttpResponseMediaType;
            return Assert.ThrowsAsync<IOException>(() => content.ReadAsHttpResponseMessageAsync());
        }

        [Theory]
        [InlineData("")]
        [InlineData("GET")]
        [InlineData("GET / HTTP/1.0")]
        [InlineData("GET / HTTP/1.0\r\n")]
        [InlineData("GET / HTTP/1.0\r\nHost:")]
        [InlineData("GET / HTTP/1.0\r\nHost: localhost")]
        [InlineData("GET / HTTP/1.0\r\nHost: localhost\r\n")]
        [InlineData("GET / HTTP/1.0\r\nHost: localhost\r\n\r")]
        public Task ReadAsHttpRequestMessageAsync_IncompleteRequest(string incompleteRequest)
        {
            StringContent content = new StringContent(incompleteRequest);
            content.Headers.ContentType = ParserData.HttpRequestMediaType;
            return Assert.ThrowsAsync<IOException>(() => content.ReadAsHttpRequestMessageAsync());
        }

        [Theory]
        [PropertyData("ClientRoundTripData")]
        public async Task RoundtripClientRequest(IEnumerable<string> message)
        {
            HttpContent content = CreateContent(true, message, null);
            HttpRequestMessage httpRequest = await content.ReadAsHttpRequestMessageAsync();
            HttpMessageContent httpMessageContent = new HttpMessageContent(httpRequest);

            MemoryStream destination = new MemoryStream();
            await httpMessageContent.CopyToAsync(destination);
            destination.Seek(0, SeekOrigin.Begin);
            string destinationMessage = new StreamReader(destination).ReadToEnd();
            string sourceMessage = await content.ReadAsStringAsync();
            Assert.Equal(sourceMessage, destinationMessage);
        }

        [Theory]
        [PropertyData("ServerRoundTripData")]
        public async Task RoundtripServerResponse(IEnumerable<string> message)
        {
            HttpContent content = CreateContent(false, message, @"<html><head><title>Object moved</title></head><body><h2>Object moved to <a href=""/en-us/"">here</a>.</h2></body></html>");
            HttpResponseMessage httpResponse = await content.ReadAsHttpResponseMessageAsync();
            HttpMessageContent httpMessageContent = new HttpMessageContent(httpResponse);

            MemoryStream destination = new MemoryStream();
            await httpMessageContent.CopyToAsync(destination);
            destination.Seek(0, SeekOrigin.Begin);
            string destinationMessage = new StreamReader(destination).ReadToEnd();
            string sourceMessage = await content.ReadAsStringAsync();
            Assert.Equal(sourceMessage, destinationMessage);
        }

        [Fact]
        public Task ReadAsHttpRequestMessageAsync_cancellationToken_PassesCancellationToken()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            cts.Cancel();
            HttpContent content = CreateContent(isRequest: true, hasEntity: false);

            return Assert.ThrowsAsync<OperationCanceledException>(() => content.ReadAsHttpRequestMessageAsync(cts.Token));
        }

        [Fact]
        public Task ReadAsHttpRequestMessageAsync_uriScheme_cancellationToken_PassesCancellationToken()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            cts.Cancel();
            HttpContent content = CreateContent(isRequest: true, hasEntity: false);

            return Assert.ThrowsAsync<OperationCanceledException>(
                () => content.ReadAsHttpRequestMessageAsync("http", cts.Token));
        }

        [Fact]
        public Task ReadAsHttpRequestMessageAsync_uriScheme_bufferSize_cancellationToken_PassesCancellationToken()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            cts.Cancel();
            HttpContent content = CreateContent(isRequest: true, hasEntity: false);

            return Assert.ThrowsAsync<OperationCanceledException>(
                () => content.ReadAsHttpRequestMessageAsync("http", 1024, cts.Token));
        }

        [Fact]
        public Task ReadAsHttpRequestMessageAsync_uriScheme_bufferSize_maxHeaderSize_cancellationToken_PassesCancellationToken()
        {
            CancellationTokenSource cts = new CancellationTokenSource();
            cts.Cancel();
            HttpContent content = CreateContent(isRequest: true, hasEntity: false);

            return Assert.ThrowsAsync<OperationCanceledException>(
                () => content.ReadAsHttpRequestMessageAsync("http", 1024, 1024, cts.Token));
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpContentMultipartExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http.Formatting.Parsers;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class HttpContentMultipartExtensionsTests
    {
        private const string ValidBoundary = "-A-";
        private const string DefaultContentType = "text/plain";
        private const string DefaultContentDisposition = "form-data";
        private const string ExceptionStreamProviderMessage = "Bad Stream Provider!";
        private const string ExceptionSyncStreamMessage = "Bad Sync Stream!";
        private const string ExceptionAsyncStreamMessage = "Bad Async Stream!";

        public static TheoryDataSet<string, bool, string, bool> IsMimeMultipartContentTestData
        {
            get
            {
                return new TheoryDataSet<string, bool, string, bool>
                {
                    { "text/plain", false, "plain", false },
                    { "application/*", false, "related", false },
                    { "*/*", false, "related", false },
                    { "multipart/form-data", false, "form-data", false },
                    { "multipart/form-data; boundary=1234", true, "related", false },
                    { "multipart/form-data; boundary=1234; charset=utf-8", true, "form-data", true },
                    { "Multipart/Related; boundary=example-1; start=\"<950120.aaCC@XIson.com>\"; type=\"Application/X-FixedRecord\"; start-info=\"-o ps\"", true, "related", true },
                };
            }
        }

        public static TheoryDataSet<string, bool> IsMimeMultipartContentTestData_NoSubType
        {
            get
            {
                var dataSet = new TheoryDataSet<string, bool>();
                foreach (var item in IsMimeMultipartContentTestData)
                {
                    dataSet.Add((string)item[0], (bool)item[1]);
                }

                return dataSet;
            }
        }

        private static HttpContent CreateContent(string boundary, params string[] bodyEntity)
        {
            return CreateContentWithContentType(boundary, DefaultContentType, bodyEntity);
        }

        private static HttpContent CreateContentWithContentType(string boundary, string partContentType, params string[] bodyEntity)
        {
            List<string> entities = new List<string>();
            int cnt = 0;
            foreach (var body in bodyEntity)
            {
                byte[] header = InternetMessageFormatHeaderParserTests.CreateBuffer(
                    String.Format("N{0}: V{0}", cnt),
                    String.Format("Content-Type: {0}", partContentType),
                    String.Format("Content-Disposition: {0}; FileName=\"N{1}\"", DefaultContentDisposition, cnt));
                entities.Add(Encoding.UTF8.GetString(header) + body);
                cnt++;
            }

            byte[] message = MimeMultipartParserTests.CreateBuffer(boundary, entities.ToArray());
            HttpContent result = new ByteArrayContent(message);
            var contentType = new MediaTypeHeaderValue("multipart/form-data");
            contentType.Parameters.Add(new NameValueHeaderValue("boundary", String.Format("\"{0}\"", boundary)));
            result.Headers.ContentType = contentType;
            return result;
        }

        private static async Task ValidateContentsAsync(IEnumerable<HttpContent> contents)
        {
            int cnt = 0;
            foreach (var content in contents)
            {
                Assert.NotNull(content);
                Assert.NotNull(content.Headers);
                Assert.Equal(4, content.Headers.Count());

                IEnumerable<string> parsedValues = content.Headers.GetValues(String.Format("N{0}", cnt));
                string parsedValue = Assert.Single(parsedValues);
                Assert.Equal(String.Format("V{0}", cnt), parsedValue);

                Assert.Equal(DefaultContentType, content.Headers.ContentType.MediaType);

                Assert.Equal(DefaultContentDisposition, content.Headers.ContentDisposition.DispositionType);
                Assert.Equal(String.Format("\"N{0}\"", cnt), content.Headers.ContentDisposition.FileName);

                await AssertContentLengthHeaderValueAsync(content);

                cnt++;
            }
        }

        private static async Task AssertContentLengthHeaderValueAsync(HttpContent content)
        {
            long contentLength = (await content.ReadAsByteArrayAsync()).LongLength;
            long contentLengthHeaderValue = content.Headers.ContentLength.GetValueOrDefault();
            Assert.Equal(contentLength, contentLengthHeaderValue);
        }

        [Fact]
        public void IsMimeMultipartContent_ThrowsOnNullContent()
        {
            Assert.ThrowsArgumentNull(() => HttpContentMultipartExtensions.IsMimeMultipartContent(null), "content");
        }

        [Fact]
        public void IsMimeMultipartContent_ThrowsOnNullSubType()
        {
            StringContent content = new StringContent(String.Empty);
            Assert.ThrowsArgumentNull(() => HttpContentMultipartExtensions.IsMimeMultipartContent(content, null), "subtype");
        }

        [Theory]
        [PropertyData("IsMimeMultipartContentTestData")]
        public void IsMimeMultipartContent_ReturnsCorrectValue(string mediaType, bool isMultipart, string subtype, bool hasSubtype)
        {
            StringContent content = new StringContent(String.Empty);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);

            Assert.Equal(isMultipart, content.IsMimeMultipartContent());
            Assert.Equal(hasSubtype, content.IsMimeMultipartContent(subtype));
        }

        [Fact]
        public Task ReadAsMultipartAsync_ThrowsOnNullStreamProvider()
        {
            HttpContent content = CreateContent(ValidBoundary);
            return Assert.ThrowsArgumentNullAsync(() => content.ReadAsMultipartAsync((MultipartStreamProvider)null), "streamProvider");
        }

        [Fact]
        public Task ReadAsMultipartAsync_ThrowsOnInvalidBufferSize()
        {
            HttpContent content = CreateContent(ValidBoundary);
            return Assert.ThrowsArgumentGreaterThanOrEqualToAsync(
                () => content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider(), ParserData.MinBufferSize - 1),
                "bufferSize", ParserData.MinBufferSize.ToString(), ParserData.MinBufferSize - 1);
        }

        [Theory]
        [PropertyData("IsMimeMultipartContentTestData_NoSubType")]
        public async Task ReadAsMultipartAsync_DetectsNonMultipartContent(string mediaType, bool isMultipart)
        {
            StringContent content = new StringContent(String.Empty);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            if (!isMultipart)
            {
                await Assert.ThrowsArgumentAsync(() => content.ReadAsMultipartAsync(), "content");
            }
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public async Task ReadAsMultipartAsync_ParsesContent(string boundary)
        {
            HttpContent successContent;
            MultipartMemoryStreamProvider result;

            successContent = CreateContent(boundary, "A", "B", "C");
            result = await successContent.ReadAsMultipartAsync();
            Assert.Equal(3, result.Contents.Count);

            successContent = CreateContent(boundary, "A", "B", "C");
            result = await successContent.ReadAsMultipartAsync(new MultipartMemoryStreamProvider());
            Assert.Equal(3, result.Contents.Count);

            successContent = CreateContent(boundary, "A", "B", "C");
            result = await successContent.ReadAsMultipartAsync(new MultipartMemoryStreamProvider(), 1024);
            Assert.Equal(3, result.Contents.Count);
        }

        [Fact]
        public async Task ReadAsMultipartAsync_SkipsHeaderValidation()
        {
            // Arrange
            var content = CreateContentWithContentType("--boundary", "invalid", "SomeContent");

            // Act
            var result = await content.ReadAsMultipartAsync(CancellationToken.None);

            // Assert
            var bodyPart = Assert.Single(result.Contents);
            Assert.Null(bodyPart.Headers.ContentType);
            Assert.Equal("invalid", Assert.Single(bodyPart.Headers.GetValues("Content-Type")));
        }

        [Fact]
        public async Task ReadAsMultipartAsync_SetsStronglyTypedHeader_WhenHeaderIsValid()
        {
            // Arrange
            var content = CreateContentWithContentType("--boundary", "application/json", "SomeContent");

            // Act
            var result = await content.ReadAsMultipartAsync(CancellationToken.None);

            // Assert
            var bodyPart = Assert.Single(result.Contents);
            Assert.NotNull(bodyPart.Headers.ContentType);
            Assert.Equal("application/json", bodyPart.Headers.ContentType.MediaType);
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public async Task ReadAsMultipartAsync_ParsesEmptyContent(string boundary)
        {
            HttpContent content = CreateContent(boundary);
            MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync();
            Assert.Empty(result.Contents);
        }

        [Fact]
        public async Task ReadAsMultipartAsync_ThrowsOnBadStreamProvider()
        {
            HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
            IOException exception = await Assert.ThrowsAsync<IOException>(() => content.ReadAsMultipartAsync(new BadStreamProvider()));
            InvalidOperationException invalidOperationException = exception.InnerException as InvalidOperationException;
            Assert.NotNull(invalidOperationException);
            Assert.NotNull(invalidOperationException.InnerException);
            Assert.Equal(ExceptionStreamProviderMessage, invalidOperationException.InnerException.Message);
        }

        [Fact]
        public async Task ReadAsMultipartAsync_ThrowsOnNullProvider()
        {
            HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
            IOException exception = await Assert.ThrowsAsync<IOException>(() => content.ReadAsMultipartAsync(new NullProvider()));
            Assert.IsType<InvalidOperationException>(exception.InnerException);
        }

        [Fact]
        public async Task ReadAsMultipartAsync_ThrowsOnReadOnlyStream()
        {
            HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
            IOException exception = await Assert.ThrowsAsync<IOException>(() => content.ReadAsMultipartAsync(new ReadOnlyStreamProvider()));
            Assert.IsType<InvalidOperationException>(exception.InnerException);
        }

        [Fact]
        public Task ReadAsMultipartAsync_ThrowsOnPrematureEndOfStream()
        {
            HttpContent content = new StreamContent(Stream.Null);
            string mediaType = String.Format("multipart/form-data; boundary=\"{0}\"", ValidBoundary);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            return Assert.ThrowsAsync<IOException>(() => content.ReadAsMultipartAsync());
        }

        [Fact]
        public async Task ReadAsMultipartAsync_ThrowsOnReadError()
        {
            HttpContent content = new StreamContent(new ReadErrorStream());
            string mediaType = String.Format("multipart/form-data; boundary=\"{0}\"", ValidBoundary);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);
            IOException exception = await Assert.ThrowsAsync<IOException>(() => content.ReadAsMultipartAsync());
            Assert.NotNull(exception.InnerException);
            Assert.Equal(ExceptionAsyncStreamMessage, exception.InnerException.Message);
        }

        [Fact]
        public async Task ReadAsMultipartAsync_ThrowsOnWriteError()
        {
            HttpContent content = CreateContent(ValidBoundary, "A", "B", "C");
            IOException exception = await Assert.ThrowsAsync<IOException>(() => content.ReadAsMultipartAsync(new WriteErrorStreamProvider()));
            Assert.NotNull(exception.InnerException);
            Assert.Equal(ExceptionAsyncStreamMessage, exception.InnerException.Message);
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries", typeof(MimeMultipartParserTests), "SingleShortBodies")]
        public async Task ReadAsMultipartAsync_SingleShortBodyPart(string boundary, string singleShortBody)
        {
            HttpContent content = CreateContent(boundary, singleShortBody);

            MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync();
            HttpContent resultContent = Assert.Single(result.Contents);
            Assert.Equal(singleShortBody, await resultContent.ReadAsStringAsync());
            await ValidateContentsAsync(result.Contents);
        }

        [Fact]
        public async Task ReadAsMultipartAsync_WithHugeBody_AvoidStackOverflow()
        {
            // Arrange
            var fiftyMegs = 1024 * 1024 * 50;
            HttpContent content = CreateContent("---3123---", new string('x', fiftyMegs));

            // Act
            MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider(), 256);

            // Assert
            // this is for sanity. The actual test here is that the Act part did not cause a stack overflow
            Assert.Equal(fiftyMegs, (await result.Contents[0].ReadAsStringAsync()).Length);
            await ValidateContentsAsync(result.Contents);
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries", typeof(MimeMultipartParserTests), "MultipleShortBodies")]
        public async Task ReadAsMultipartAsync_MultipleShortBodyParts(string boundary, string[] multipleShortBodies)
        {
            HttpContent content = CreateContent(boundary, multipleShortBodies);
            MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync();
            Assert.Equal(multipleShortBodies.Length, result.Contents.Count);
            for (var check = 0; check < multipleShortBodies.Length; check++)
            {
                Assert.Equal(multipleShortBodies[check], await result.Contents[check].ReadAsStringAsync());
            }

            await ValidateContentsAsync(result.Contents);
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries", typeof(MimeMultipartParserTests), "SingleLongBodies")]
        public async Task ReadAsMultipartAsync_SingleLongBodyPart(string boundary, string singleLongBody)
        {
            HttpContent content = CreateContent(boundary, singleLongBody);

            MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync();
            HttpContent resultContent = Assert.Single(result.Contents);
            Assert.Equal(singleLongBody, await resultContent.ReadAsStringAsync());
            await ValidateContentsAsync(result.Contents);
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries", typeof(MimeMultipartParserTests), "MultipleLongBodies")]
        public async Task ReadAsMultipartAsync_MultipleLongBodyParts(string boundary, string[] multipleLongBodies)
        {
            HttpContent content = CreateContent(boundary, multipleLongBodies);
            MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync(new MultipartMemoryStreamProvider(), ParserData.MinBufferSize);
            Assert.Equal(multipleLongBodies.Length, result.Contents.Count);
            for (var check = 0; check < multipleLongBodies.Length; check++)
            {
                Assert.Equal(multipleLongBodies[check], await result.Contents[check].ReadAsStringAsync());
            }

            await ValidateContentsAsync(result.Contents);
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public async Task ReadAsMultipartAsync_UsingMultipartContent(string boundary)
        {
            MultipartContent content = new MultipartContent("mixed", boundary);
            content.Add(new StringContent("A"));
            content.Add(new StringContent("B"));
            content.Add(new StringContent("C"));

            MemoryStream memStream = new MemoryStream();
            await content.CopyToAsync(memStream);
            memStream.Position = 0;
            byte[] data = memStream.ToArray();
            var byteContent = new ByteArrayContent(data);
            byteContent.Headers.ContentType = content.Headers.ContentType;

            MultipartMemoryStreamProvider result = await byteContent.ReadAsMultipartAsync();
            Assert.Equal(3, result.Contents.Count);
            Assert.Equal("A", await result.Contents[0].ReadAsStringAsync());
            Assert.Equal("B", await result.Contents[1].ReadAsStringAsync());
            Assert.Equal("C", await result.Contents[2].ReadAsStringAsync());
        }

        [Theory]
        [TestDataSet(typeof(MimeMultipartParserTests), "Boundaries")]
        public async Task ReadAsMultipartAsync_NestedMultipartContent(string boundary)
        {
            const int nesting = 10;
            const string innerText = "Content";

            MultipartContent innerContent = new MultipartContent("mixed", boundary);
            innerContent.Add(new StringContent(innerText));
            for (var cnt = 0; cnt < nesting; cnt++)
            {
                string outerBoundary = String.Format("{0}_{1}", boundary, cnt);
                MultipartContent outerContent = new MultipartContent("mixed", outerBoundary);
                outerContent.Add(innerContent);
                innerContent = outerContent;
            }

            MemoryStream memStream = new MemoryStream();
            await innerContent.CopyToAsync(memStream);
            memStream.Position = 0;
            byte[] data = memStream.ToArray();
            HttpContent content = new ByteArrayContent(data);
            content.Headers.ContentType = innerContent.Headers.ContentType;

            for (var cnt = 0; cnt < nesting + 1; cnt++)
            {
                MultipartMemoryStreamProvider result = await content.ReadAsMultipartAsync();
                content = Assert.Single(result.Contents);
                Assert.NotNull(content);
            }

            string text = await content.ReadAsStringAsync();
            Assert.Equal(innerText, text);
        }

        [Fact]
        public async Task ReadAsMultipartAsyncOfT_PassesCancellationToken()
        {
            CancellationToken token = new CancellationToken();
            HttpContent content = CreateContent("boundary");
            Mock<MultipartStreamProvider> provider = new Mock<MultipartStreamProvider>();
            provider.Setup(p => p.ExecutePostProcessingAsync(token))
                .Returns(Task.FromResult(42))
                .Verifiable();

            await content.ReadAsMultipartAsync<MultipartStreamProvider>(provider.Object, token);

            provider.Verify();
        }

        public class ReadOnlyStream : MemoryStream
        {
            public override bool CanWrite
            {
                get
                {
                    return false;
                }
            }
        }

        public class ReadErrorStream : MemoryStream
        {
            public override int Read(byte[] buffer, int offset, int count)
            {
                throw new IOException(ExceptionSyncStreamMessage);
            }
            public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
            {
                throw new IOException(ExceptionAsyncStreamMessage);
            }

#if !Testing_NetStandard1_3 // BeginX and EndX not supported on Streams in netstandard1.3
            public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
            {
                throw new IOException(ExceptionAsyncStreamMessage);
            }
#endif
        }

        public class WriteErrorStream : MemoryStream
        {
            public override void Write(byte[] buffer, int offset, int count)
            {
                throw new IOException(ExceptionSyncStreamMessage);
            }

            public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
            {
                throw new IOException(ExceptionAsyncStreamMessage);
            }

#if !Testing_NetStandard1_3 // BeginX and EndX not supported on Streams in netstandard1.3
            public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
            {
                throw new IOException(ExceptionAsyncStreamMessage);
            }
#endif
        }

        public class BadStreamProvider : MultipartStreamProvider
        {
            public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
            {
                throw new Exception(ExceptionStreamProviderMessage);
            }
        }

        public class NullProvider : MultipartStreamProvider
        {
            public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
            {
                return null;
            }
        }

        public class ReadOnlyStreamProvider : MultipartStreamProvider
        {
            public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
            {
                return new ReadOnlyStream();
            }
        }

        public class WriteErrorStreamProvider : MultipartStreamProvider
        {
            public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
            {
                return new WriteErrorStream();
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpHeaderExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpHeaderExtensionsTest
    {
        [Fact]
        public void CopyTo_CopiesContentHeaders()
        {
            // Arrange
            HttpContentHeaders source = FormattingUtilities.CreateEmptyContentHeaders();
            source.ContentType = MediaTypeHeaderValue.Parse("application/json; charset=utf8; parameter=value");
            source.ContentLength = 1234;
            source.ContentLocation = new Uri("http://some.host");
            source.Add("test-name1", "test-value1");
            source.Add("test-name2", "test-value2");

            HttpContentHeaders destination = FormattingUtilities.CreateEmptyContentHeaders();

            // Act
            source.CopyTo(destination);

            // Assert
            Assert.Equal(source.ToString(), destination.ToString());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpMessageContentTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpMessageContentTests
    {
        private static readonly int iterations = 5;

        private static void AddMessageHeaders(HttpHeaders headers)
        {
            headers.Add("N1", new string[] { "V1a", "V1b", "V1c", "V1d", "V1e" });
            headers.Add("N2", "V2");
        }

        private static HttpRequestMessage CreateRequest(Uri requestUri, bool containsEntity)
        {
            HttpRequestMessage httpRequest = new HttpRequestMessage();
            httpRequest.Method = new HttpMethod(ParserData.HttpMethod);
            httpRequest.RequestUri = requestUri;
            httpRequest.Version = new Version("1.2");
            AddMessageHeaders(httpRequest.Headers);
            if (containsEntity)
            {
                httpRequest.Content = new StringContent(ParserData.HttpMessageEntity);
            }

            return httpRequest;
        }

        private static HttpResponseMessage CreateResponse(bool containsEntity)
        {
            HttpResponseMessage httpResponse = new HttpResponseMessage();
            httpResponse.StatusCode = ParserData.HttpStatus;
            httpResponse.ReasonPhrase = ParserData.HttpReasonPhrase;
            httpResponse.Version = new Version("1.2");
            AddMessageHeaders(httpResponse.Headers);
            httpResponse.Content =
                containsEntity ? new StringContent(ParserData.HttpMessageEntity) : new StreamContent(Stream.Null);

            return httpResponse;
        }

        private static async Task<string> ReadContentAsync(HttpContent content, bool unBuffered = false)
        {
            if (unBuffered)
            {
                var stream = new MemoryStream();
                await content.CopyToAsync(stream);
                stream.Position = 0L;

                // StreamReader will dispose of the Stream.
                using var reader = new StreamReader(stream);

                return await reader.ReadToEndAsync();
            }
            else
            {
                await content.LoadIntoBufferAsync();

                return await content.ReadAsStringAsync();
            }
        }

        private static async Task ValidateRequest(HttpContent content, bool containsEntity, bool unBuffered = false)
        {
            Assert.Equal(ParserData.HttpRequestMediaType, content.Headers.ContentType);
            long? length = content.Headers.ContentLength;
            Assert.NotNull(length);

            string message = await ReadContentAsync(content, unBuffered);
            if (containsEntity)
            {
                Assert.Equal(ParserData.HttpRequestWithEntity.Length, length);
                Assert.Equal(ParserData.HttpRequestWithEntity, message);
            }
            else
            {
                Assert.Equal(ParserData.HttpRequest.Length, length);
                Assert.Equal(ParserData.HttpRequest, message);
            }
        }

        private static async Task ValidateResponse(HttpContent content, bool containsEntity, bool unBuffered = false)
        {
            Assert.Equal(ParserData.HttpResponseMediaType, content.Headers.ContentType);

            long? length = content.Headers.ContentLength;
            Assert.NotNull(length);

            string message = await ReadContentAsync(content, unBuffered);
            if (containsEntity)
            {
                Assert.Equal(ParserData.HttpResponseWithEntity.Length, length);
                Assert.Equal(ParserData.HttpResponseWithEntity, message);
            }
            else
            {
                Assert.Equal(ParserData.HttpResponse.Length, length);
                Assert.Equal(ParserData.HttpResponse, message);
            }
        }

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<HttpMessageContent, HttpContent>(TypeAssert.TypeProperties.IsPublicVisibleClass | TypeAssert.TypeProperties.IsDisposable);
        }

        [Fact]
        public void RequestConstructor()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            HttpMessageContent instance = new HttpMessageContent(request);
            Assert.NotNull(instance);
            Assert.Same(request, instance.HttpRequestMessage);
            Assert.Null(instance.HttpResponseMessage);
        }

        [Fact]
        public void RequestConstructorThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => { new HttpMessageContent((HttpRequestMessage)null); }, "httpRequest");
        }

        [Fact]
        public void ResponseConstructor()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            HttpMessageContent instance = new HttpMessageContent(response);
            Assert.NotNull(instance);
            Assert.Same(response, instance.HttpResponseMessage);
            Assert.Null(instance.HttpRequestMessage);
        }

        [Fact]
        public void ResponseConstructorThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => { new HttpMessageContent((HttpResponseMessage)null); }, "httpResponse");
        }


        [Fact]
        public async Task SerializeRequest()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, false);
                HttpMessageContent instance = new HttpMessageContent(request);
                await ValidateRequest(instance, false);
            }
        }

        [Fact]
        public async Task SerializeRequestWithExistingHostHeader()
        {
            HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, false);
            string host = ParserData.HttpHostName;
            request.Headers.Host = host;
            HttpMessageContent instance = new HttpMessageContent(request);
            string message = await ReadContentAsync(instance);
            Assert.Equal(ParserData.HttpRequestWithHost, message);
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task SerializeRequestMultipleTimes(bool unBuffered)
        {
            HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, containsEntity: false);
            HttpMessageContent instance = new(request);
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                await ValidateRequest(instance, containsEntity: false, unBuffered);
            }
        }

        [Fact]
        public async Task SerializeResponse()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpResponseMessage response = CreateResponse(false);
                HttpMessageContent instance = new HttpMessageContent(response);
                await ValidateResponse(instance, false);
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task SerializeResponseMultipleTimes(bool unBuffered)
        {
            HttpResponseMessage response = CreateResponse(containsEntity: false);
            HttpMessageContent instance = new(response);
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                await ValidateResponse(instance, containsEntity: false, unBuffered);
            }
        }

        [Fact]
        public async Task SerializeRequestWithEntity()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, true);
                HttpMessageContent instance = new HttpMessageContent(request);
                await ValidateRequest(instance, true);
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task SerializeRequestWithEntityMultipleTimes(bool unBuffered)
        {
            HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, containsEntity: true);
            HttpMessageContent instance = new(request);
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                await ValidateRequest(instance, containsEntity: true, unBuffered);
            }
        }

        [Fact]
        public async Task SerializeResponseWithEntity()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpResponseMessage response = CreateResponse(true);
                HttpMessageContent instance = new HttpMessageContent(response);
                await ValidateResponse(instance, true);
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task SerializeResponseWithEntityMultipleTimes(bool unBuffered)
        {
            HttpResponseMessage response = CreateResponse(containsEntity: true);
            HttpMessageContent instance = new(response);
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                await ValidateResponse(instance, containsEntity: true, unBuffered);
            }
        }

        [Fact]
        public async Task SerializeRequestAsync()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, false);
                HttpMessageContent instance = new HttpMessageContent(request);
                await ValidateRequest(instance, false);
            }
        }

        [Fact]
        public async Task SerializeResponseAsync()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpResponseMessage response = CreateResponse(false);
                HttpMessageContent instance = new HttpMessageContent(response);
                await ValidateResponse(instance, false);
            }
        }

        [Fact]
        public async Task SerializeRequestWithPortAndQueryAsync()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUriWithPortAndQuery, false);
                HttpMessageContent instance = new HttpMessageContent(request);
                string message = await ReadContentAsync(instance);
                Assert.Equal(ParserData.HttpRequestWithPortAndQuery, message);
            }
        }

        [Fact]
        public async Task SerializeRequestWithEntityAsync()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, true);
                HttpMessageContent instance = new HttpMessageContent(request);
                await ValidateRequest(instance, true);
            }
        }

        [Fact]
        public async Task SerializeResponseWithEntityAsync()
        {
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                HttpResponseMessage response = CreateResponse(true);
                HttpMessageContent instance = new HttpMessageContent(response);
                await ValidateResponse(instance, true);
            }
        }

        [Fact]
        public void DisposeInnerHttpRequestMessage()
        {
            HttpRequestMessage request = CreateRequest(ParserData.HttpRequestUri, false);
            HttpMessageContent instance = new HttpMessageContent(request);
            instance.Dispose();
            Assert.ThrowsObjectDisposed(() => { request.Method = HttpMethod.Get; }, typeof(HttpRequestMessage).FullName);
        }

        [Fact]
        public void DisposeInnerHttpResponseMessage()
        {
            HttpResponseMessage response = CreateResponse(false);
            HttpMessageContent instance = new HttpMessageContent(response);
            instance.Dispose();
            Assert.ThrowsObjectDisposed(() => { response.StatusCode = HttpStatusCode.OK; }, typeof(HttpResponseMessage).FullName);
        }

        [Fact]
        public void Request_ContentLengthNull_IfReadOnlyStream()
        {
            var request = CreateRequest(ParserData.HttpRequestUri, containsEntity: false);
            request.Content = new StreamContent(new ReadOnlyStream());
            var instance = new HttpMessageContent(request);

            var length = instance.Headers.ContentLength;

            Assert.Null(length);
        }

        [Fact]
        public void Response_ContentLengthNull_IfReadOnlyStream()
        {
            var response = CreateResponse(containsEntity: false);
            response.Content = new StreamContent(new ReadOnlyStream());
            var instance = new HttpMessageContent(response);

            var length = instance.Headers.ContentLength;

            Assert.Null(length);
        }

        // Also confirms content can be serialized multiple times if either buffered or involves a seekable Stream.
        [Theory]
        [InlineData(false, true)]
        [InlineData(true, false)]
        public async Task Request_NoContentLength_IfNotRequested(bool readOnlyStream, bool unBuffered)
        {
            var request = CreateRequest(ParserData.HttpRequestUri, containsEntity: false);
            if (readOnlyStream)
            {
                request.Content = new StreamContent(new ReadOnlyStream());
            }
            var instance = new HttpMessageContent(request);

            for (int cnt = 0; cnt < iterations; cnt++)
            {
                var contentString = await ReadContentAsync(instance, unBuffered);

                Assert.Equal(ParserData.HttpRequest.Replace("Content-Length: 0\r\n", ""), contentString);
            }
        }

        // Also confirms content can be serialized multiple times if either buffered or involves a seekable Stream.
        [Theory]
        [InlineData(false, true)]
        [InlineData(true, false)]
        public async Task Response_NoContentLength_IfNotRequested(bool readOnlyStream, bool unBuffered)
        {
            var response = CreateResponse(containsEntity: false);
            if (readOnlyStream)
            {
                response.Content = new StreamContent(new ReadOnlyStream());
            }
            var instance = new HttpMessageContent(response);

            for (int cnt = 0; cnt < iterations; cnt++)
            {
                var contentString = await ReadContentAsync(instance, unBuffered);

                Assert.Equal(ParserData.HttpResponse.Replace("Content-Length: 0\r\n", ""), contentString);
            }
        }

        // Covers the false, false case of Request_NoContentLength_IfNotRequested(...).
        [Fact]
        public async Task Request_HasContentLength_IfBuffered_EvenIfNotRequested()
        {
            var request = CreateRequest(ParserData.HttpRequestUri, containsEntity: false);
            var instance = new HttpMessageContent(request);
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                var contentString = await ReadContentAsync(instance, unBuffered: false);

                Assert.Equal(ParserData.HttpRequest, contentString);
            }
        }

        // Covers the false, false case of Response_NoContentLength_IfNotRequested(...).
        [Fact]
        public async Task Response_HasContentLength_IfBuffered_EvenIfNotRequested()
        {
            var response = CreateResponse(containsEntity: false);
            var instance = new HttpMessageContent(response);
            for (int cnt = 0; cnt < iterations; cnt++)
            {
                var contentString = await ReadContentAsync(instance, unBuffered: false);

                Assert.Equal(ParserData.HttpResponse, contentString);
            }
        }

        // Covers the true, true case of Request_NoContentLength_IfNotRequested(...).
        [Fact]
        public async Task Request_CannotSerializeMultipleTimes_IfNotBufferedAndNotSeekable()
        {
            var request = CreateRequest(ParserData.HttpRequestUri, containsEntity: false);
            request.Content = new StreamContent(new ReadOnlyStream());
            var instance = new HttpMessageContent(request);

            // Act #1
            var contentString = await ReadContentAsync(instance, unBuffered: true);

            // Assert #1
            Assert.Equal(ParserData.HttpRequest.Replace("Content-Length: 0\r\n", ""), contentString);

            // Act #2
            await Assert.ThrowsAsync<InvalidOperationException>(
                () => ReadContentAsync(instance, unBuffered: true),
                "The 'HttpContent' of the 'HttpRequestMessage' has already been read.");
        }

        // Covers the true, true case of Response_NoContentLength_IfNotRequested(...).
        [Fact]
        public async Task Response_CannotSerializeMultipleTimes_IfNotBufferedAndNotSeekable()
        {
            var response = CreateResponse(containsEntity: false);
            response.Content = new StreamContent(new ReadOnlyStream());
            var instance = new HttpMessageContent(response);

            // Act #1
            var contentString = await ReadContentAsync(instance, unBuffered: true);

            // Assert #1
            Assert.Equal(ParserData.HttpResponse.Replace("Content-Length: 0\r\n", ""), contentString);

            // Act #2
            await Assert.ThrowsAsync<InvalidOperationException>(
                () => ReadContentAsync(instance, unBuffered: true),
                "The 'HttpContent' of the 'HttpResponseMessage' has already been read.");
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task Request_CannotSerialize_IfWriteOnlyStream(bool unBuffered)
        {
            var request = CreateRequest(ParserData.HttpRequestUri, containsEntity: false);
            request.Content = new StreamContent(new WriteOnlyStream());
            var instance = new HttpMessageContent(request);

            await Assert.ThrowsAsync<NotSupportedException>(
                () => ReadContentAsync(instance, unBuffered),
                "Stream does not support reading.");
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task Response_CannotSerialize_IfWriteOnlyStream(bool unBuffered)
        {
            var response = CreateResponse(containsEntity: false);
            response.Content = new StreamContent(new WriteOnlyStream());
            var instance = new HttpMessageContent(response);

            await Assert.ThrowsAsync<NotSupportedException>(
                () => ReadContentAsync(instance, unBuffered),
                "Stream does not support reading.");
        }

        // Unlike Stream.Null, this stream does not support seeking. Bit more like (say) a network stream or
        // the EmptyReadStream introduced in .NET 5. Note: EmptyReadStream should never be visible to our code
        // because HttpContentMessageExtensions and HttpRequestMessageExtensions overwrite
        // HttpResponseMessage.Content (or HttpRequestMessage.Content in one case) when creating an instance.
        private class ReadOnlyStream : Stream
        {
            public override bool CanRead => true;
            public override bool CanSeek => false;
            public override bool CanWrite => false;
            public override long Length => throw new NotImplementedException();
            public override long Position
            {
                get => throw new NotImplementedException();
                set => throw new NotImplementedException();
            }

            public override void Flush()
            {
                // Do nothing.
            }

            public override int Read(byte[] buffer, int offset, int count) => 0;

            public override long Seek(long offset, SeekOrigin origin) => throw new NotImplementedException();

            public override void SetLength(long value) => throw new NotImplementedException();

            public override void Write(byte[] buffer, int offset, int count) => throw new NotImplementedException();
        }

        // Unlike Stream.Null, this stream does not support seeking. Bit more like (say) a network stream.
        private class WriteOnlyStream : Stream
        {
            public override bool CanRead => false;
            public override bool CanSeek => false;
            public override bool CanWrite => true;
            public override long Length => throw new NotImplementedException();
            public override long Position
            {
                get => throw new NotImplementedException();
                set => throw new NotImplementedException();
            }

            public override void Flush()
            {
                // Do nothing.
            }

            public override int Read(byte[] buffer, int offset, int count) => throw new NotImplementedException();

            public override long Seek(long offset, SeekOrigin origin) => throw new NotImplementedException();

            public override void SetLength(long value) => throw new NotImplementedException();

            public override void Write(byte[] buffer, int offset, int count)
            {
                // Ignore all parameters and do nothing.
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpRequestHeadersExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpRequestHeadersExtensionsTest
    {
        public static TheoryDataSet<string[], string, string[]> CookieMatches
        {
            get
            {
                // IEnumerable<string> inputCookies, string matchName, IEnumerable<string> expectedOuput
                return new TheoryDataSet<string[], string, string[]>
                {
                    {
                        new string[] {},
                        "empty",
                        new string[] {}
                    },
                    {
                        new string[]
                        {
                            "RMID=2dab5fc9747d4f8edaf410ff",
                            "adxcs=-",
                            "adxcl=l*2ba62=4fc449bf:1",
                            "adxcs=si=0:1",
                        },
                        "nomatch",
                        new string[] {}
                    },
                    {
                        new string[]
                        {
                            "RMID=2dab5fc9747d4f8edaf410ff",
                            "adxcs=-",
                            "adxcl=l*2ba62=4fc449bf:1",
                            "ADXCS=si=0:1",
                        },
                        "adxcs",
                        new string[]
                        {
                            "adxcs=-",
                            "ADXCS=si=0%3A1"
                        }
                    },
                    {
                        new string[]
                        {
                            "MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!",
                            "MC0=1334766377159; MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!; MUID=20EC57A324256BF3039D54E520256B7D&TUID=1",
                        },
                        "A",
                        new string[]
                        {
                            "MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!",
                            "MC0=1334766377159; MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!; MUID=20EC57A324256BF3039D54E520256B7D&TUID=1",
                        }
                    },
                    {
                        new string[]
                        {
                            "MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!",
                            "MC0=1334766377159; MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!; MUID=20EC57A324256BF3039D54E520256B7D&TUID=1",
                        },
                        "MC0",
                        new string[]
                        {
                            "MC0=1334766377159; MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!; MUID=20EC57A324256BF3039D54E520256B7D&TUID=1",
                        }
                    },
                    {
                        new string[]
                        {
                            "MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!",
                            "MC0=1334766377159; MC1=GUID=e87574286c55d547b5a0b19fb27d57a4&HASH=2874&LV=20124&V=3&LU=1334766376863; MS0=7bbaad2a8316483c89bbd2ca4e96fcea; A=I&I=AxUFAAAAAACSCAAAHFNnP3xE7Uth5BCZZSiqZQ!!; MUID=20EC57A324256BF3039D54E520256B7D&TUID=1",
                        },
                        "MC",
                        new string[] { }
                    },
                };
            }
        }

        [Fact]
        public void GetCookies_ThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => HttpRequestHeadersExtensions.GetCookies(null), "headers");
        }

        [Fact]
        public void GetCookies_GetsCookiesReturnsEmptyCollection()
        {
            // Arrange
            HttpRequestHeaders headers = CreateHttpRequestHeaders();

            // Act
            IEnumerable<CookieHeaderValue> cookies = headers.GetCookies();

            // Assert
            Assert.Empty(cookies);
        }

        [Theory]
        [InlineData("name1=n1=v1&n2=v2&n3=v3; expires=Sun, 06 Nov 1994 08:49:37 GMT; max-age=86400; domain=domain1; path=path1; secure; httponly")]
        public void GetCookies_GetsCookies(string expectedCookie)
        {
            // Arrange
            HttpRequestHeaders headers = CreateHttpRequestHeaders();
            headers.TryAddWithoutValidation("Cookie", expectedCookie);

            // Act
            IEnumerable<CookieHeaderValue> cookies = headers.GetCookies();

            // Assert
            CookieHeaderValue cookie = Assert.Single(cookies);
            string actualCookie = cookie.ToString();
            Assert.Equal(expectedCookie, actualCookie);
        }

        [Fact]
        public void GetCookiesByName_ThrowsOnNullHeaders()
        {
            Assert.ThrowsArgumentNull(() => HttpRequestHeadersExtensions.GetCookies(null, "empty"), "headers");
        }

        [Fact]
        public void GetCookiesByName_ThrowsOnNullName()
        {
            HttpRequestHeaders headers = CreateHttpRequestHeaders();
            Assert.ThrowsArgumentNull(() => HttpRequestHeadersExtensions.GetCookies(headers, null), "name");
        }

        [Theory]
        [PropertyData("CookieMatches")]
        public void GetCookiesByName_GetsCookies(IEnumerable<string> cookies, string name, IEnumerable<string> expectedCookies)
        {
            // Arrange
            HttpRequestHeaders headers = CreateHttpRequestHeaders();
            foreach (string cookie in cookies)
            {
                headers.TryAddWithoutValidation("Cookie", cookie);
            }

            // Act
            IEnumerable<CookieHeaderValue> actualCookieHeaderValues = headers.GetCookies(name);

            // Assert
            IEnumerable<string> actualCookies = actualCookieHeaderValues.Select(c => c.ToString());
            Assert.True(actualCookies.SequenceEqual(expectedCookies));
        }

        private static HttpRequestHeaders CreateHttpRequestHeaders()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            return request.Headers;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpRequestMessageCommonExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpRequestMessageExtensionsTest
    {
        [Fact]
        public void IsCorrectType()
        {
            Assert.Type.HasProperties(typeof(HttpRequestMessageExtensions), TypeAssert.TypeProperties.IsStatic | TypeAssert.TypeProperties.IsPublicVisibleClass);
        }

        [Fact]
        public void CreateResponseThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => HttpRequestMessageExtensions.CreateResponse(null), "request");
        }

        [Fact]
        public void CreateResponseWithStatusThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => HttpRequestMessageExtensions.CreateResponse(null, HttpStatusCode.OK), "request");
        }

        [Fact]
        public void CreateResponse()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();

            // Act
            HttpResponseMessage response = request.CreateResponse();

            // Assert
            Assert.Same(request, response.RequestMessage);
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
        }

        [Fact]
        public void CreateResponseWithStatus()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();

            // Act
            HttpResponseMessage response = request.CreateResponse(HttpStatusCode.NotImplemented);

            // Assert
            Assert.Same(request, response.RequestMessage);
            Assert.Equal(HttpStatusCode.NotImplemented, response.StatusCode);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpResponseHeadersExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpResponseHeadersExtensionsTest
    {
        [Fact]
        public void AddCookies_ThrowsOnNull()
        {
            HttpResponseHeaders headers = CreateHttpResponseHeaders();
            List<CookieHeaderValue> cookies = new List<CookieHeaderValue>();

            Assert.ThrowsArgumentNull(() => HttpResponseHeadersExtensions.AddCookies(null, cookies), "headers");
            Assert.ThrowsArgumentNull(() => HttpResponseHeadersExtensions.AddCookies(headers, null), "cookies");
        }

        [Fact]
        public void AddCookies_ThrowsOnNullCookie()
        {
            HttpResponseHeaders headers = CreateHttpResponseHeaders();
            List<CookieHeaderValue> cookies = new List<CookieHeaderValue>();
            cookies.Add(null);

            Assert.ThrowsArgument(() => HttpResponseHeadersExtensions.AddCookies(headers, cookies), "cookies");
        }

        [Theory]
        [InlineData("name1=n1=v1&n2=v2&n3=v3; expires=Sun, 06 Nov 1994 08:49:37 GMT; max-age=86400; domain=domain1; path=path1; secure; httponly")]
        public void AddCookies_AddsCookies(string expectedCookie)
        {
            // Arrange
            HttpResponseHeaders headers = CreateHttpResponseHeaders();
            List<CookieHeaderValue> cookies = new List<CookieHeaderValue>();
            CookieHeaderValue cookie;
            bool parsedCorrectly = CookieHeaderValue.TryParse(expectedCookie, out cookie);
            cookies.Add(cookie);

            // Act
            headers.AddCookies(cookies);

            // Assert
            Assert.True(parsedCorrectly);
            IEnumerable<string> actualCookies;
            bool addedCorrectly = headers.TryGetValues("Set-Cookie", out actualCookies);
            Assert.True(addedCorrectly);
            string actualCookie = Assert.Single(actualCookies);
            Assert.Equal(expectedCookie, actualCookie);
        }

        private static HttpResponseHeaders CreateHttpResponseHeaders()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            return response.Headers;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpUnsortedRequestTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpUnsortedRequestTest
    {
        [Fact]
        public void Constructor_InitializesHeaders()
        {
            HttpUnsortedRequest request = new HttpUnsortedRequest();
            Assert.IsType<HttpUnsortedHeaders>(request.HttpHeaders);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/HttpUnsortedResponseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class HttpUnsortedResponseTest
    {
        [Fact]
        public void Constructor_InitializesHeaders()
        {
            HttpUnsortedResponse response = new HttpUnsortedResponse();
            Assert.IsType<HttpUnsortedHeaders>(response.HttpHeaders);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Internal/AsyncResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Internal;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class AsyncResultTest
    {
        private static readonly TimeSpan _timeout = TimeSpan.FromMilliseconds(10);

        [Fact]
        public void Constructor_Initializes()
        {
            // Arrange
            AsyncCallback callback = new AsyncCallback(_ => { });
            object state = new object();

            // Act
            MockAsyncResult mockAsyncResult = new MockAsyncResult(callback, state);

            // Assert
            Assert.True(mockAsyncResult.HasCallback);
            Assert.False(mockAsyncResult.IsCompleted);
            Assert.False(mockAsyncResult.CompletedSynchronously);
            Assert.Same(state, mockAsyncResult.AsyncState);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void Complete_SetsCompletedSynchronously(bool completedSynchronously)
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.Equal(completedSynchronously, mockAsyncResult.CompletedSynchronously);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void Complete_SetsIsCompleted(bool completedSynchronously)
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.True(mockAsyncResult.IsCompleted);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void Complete_CallsCallback(bool completedSynchronously)
        {
            // Arrange
            MockAsyncCallback mockCallback = new MockAsyncCallback(false);
            MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.True(mockCallback.WasInvoked);
            Assert.Same(mockAsyncResult, mockCallback.AsyncResult);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void Complete_ThrowsOnMultipleCompletes(bool completedSynchronously)
        {
            // Arrange
            MockAsyncResult mockAsyncResult = new MockAsyncResult(null, null);

            // Act
            mockAsyncResult.Complete(completedSynchronously);

            // Assert
            Assert.Throws<InvalidOperationException>(() => mockAsyncResult.Complete(completedSynchronously));
        }

        [Fact]
        public void Complete_ThrowsIfCallbackThrows()
        {
            // Arrange
            MockAsyncCallback mockCallback = new MockAsyncCallback(true);
            MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);

            // Act/Assert
            Assert.Throws<InvalidOperationException>(() => mockAsyncResult.Complete(false));
        }

        [Fact]
        public void End_ThrowsOnNullAsyncResult()
        {
            Assert.ThrowsArgumentNull(() => MockAsyncResult.End<MockAsyncResult>(null), "result");
        }

        [Fact]
        public void End_ThrowsOnInvalidAsyncResult()
        {
            Mock<IAsyncResult> mockIAsyncResult = new Mock<IAsyncResult>();
            Assert.ThrowsArgument(() => MockAsyncResult.End<MockAsyncResult>(mockIAsyncResult.Object), "result");
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void End_ThrowsIfCalledTwiceOnSameAsyncResult(bool completedSynchronously)
        {
            // Arrange
            MockAsyncCallback mockCallback = new MockAsyncCallback(false);
            MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);
            mockAsyncResult.Complete(completedSynchronously);

            // Act
            MockAsyncResult.End<MockAsyncResult>(mockAsyncResult);

            // Act
            Assert.Throws<InvalidOperationException>(() => MockAsyncResult.End<MockAsyncResult>(mockAsyncResult));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void End_ThrowsIfCompletedWithException(bool completedSynchronously)
        {
            // Arrange
            MockAsyncCallback mockCallback = new MockAsyncCallback(false);
            MockAsyncResult mockAsyncResult = new MockAsyncResult(mockCallback.Callback, null);
            ApplicationException applicationException = new ApplicationException("Complete failed!");
            mockAsyncResult.Complete(completedSynchronously, applicationException);

            // Act/Assert
            Assert.Throws<ApplicationException>(() => MockAsyncResult.End<MockAsyncResult>(mockAsyncResult));
        }

        internal class MockAsyncResult : AsyncResult
        {
            public MockAsyncResult(AsyncCallback callback, object state)
                : base(callback, state)
            {
            }

            public new void Complete(bool completedSynchronously)
            {
                base.Complete(completedSynchronously);
            }

            public new void Complete(bool completedSynchronously, Exception e)
            {
                base.Complete(completedSynchronously, e);
            }

            public static new TAsyncResult End<TAsyncResult>(IAsyncResult result) where TAsyncResult : AsyncResult
            {
                return AsyncResult.End<TAsyncResult>(result);
            }
        }

        public class MockAsyncCallback
        {
            private bool _throwInCallback;

            public MockAsyncCallback(bool throwInCallback)
            {
                _throwInCallback = throwInCallback;
            }

            public bool WasInvoked { get; private set; }

            public IAsyncResult AsyncResult { get; private set; }

            public Exception CallbackException { get; private set; }

            public void Callback(IAsyncResult result)
            {
                WasInvoked = true;
                AsyncResult = result;
                if (_throwInCallback)
                {
                    CallbackException = new Exception("Callback exception");
                    throw CallbackException;
                }
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Internal/ByteRangeStreamTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Internal
{
    public class ByteRangeStreamTest
    {
        // from, to, expectedText
        public static TheoryDataSet<long?, long?, string> CopyBoundsData
        {
            get
            {
                return new TheoryDataSet<long?, long?, string>
                {
                    { null, 23, "This is the whole text." },
                    { 0, null, "This is the whole text." },
                    { 0, 22, "This is the whole text." },
                    { 0, 3, "This" },
                    { 12, 16, "whole" },
                    { null, 5, "text." },
                    { 18, null, "text." },
                    { 18, 22, "text." },
                };
            }
        }

        // from, to, innerLength, effectiveLength
        public static TheoryDataSet<int, int, int, int> ReadBoundsData
        {
            get
            {
                return new TheoryDataSet<int, int, int, int>
                {
                    { 0, 9, 20, 10 },
                    { 8, 8, 10, 1 },
                    { 0, 19, 20, 20 },
                    { 0, 29, 40, 30 },
                    { 0, 29, 20, 20 },
                    { 19, 29, 20, 1 },
                };
            }
        }

        // from, to, innerLength, effectiveLength for reads limited by byte[] size.
        public static TheoryDataSet<int, int, int, int> ReadBoundsDataWithLimit
        {
            get
            {
                return new TheoryDataSet<int, int, int, int>
                {
                    { 0, 9, 20, 10 },
                    { 8, 8, 10, 1 },
                    { 0, 19, 20, 20 },
                    { 0, 29, 40, 25 },
                    { 0, 29, 20, 20 },
                    { 19, 29, 20, 1 },
                };
            }
        }

        [Fact]
        public void Ctor_ThrowsOnNullInnerStream()
        {
            var range = new RangeItemHeaderValue(0, 10);
            Assert.ThrowsArgumentNull(() => new ByteRangeStream(innerStream: null, range: range), "innerStream");
        }

        [Fact]
        public void Ctor_ThrowsOnNullRange()
        {
            Assert.ThrowsArgumentNull(() => new ByteRangeStream(innerStream: Stream.Null, range: null), "range");
        }

        [Fact]
        public void Ctor_ThrowsIfCantSeekInnerStream()
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(false);
            var range = new RangeItemHeaderValue(0, 10);

            // Act/Assert
            Assert.ThrowsArgument(() => new ByteRangeStream(mockInnerStream.Object, range), "innerStream");
        }

        [Fact]
        public void Ctor_ThrowsIfLowerRangeExceedsInnerStream()
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(5);
            var range = new RangeItemHeaderValue(10, 20);

            // Act/Assert
            Assert.ThrowsArgumentOutOfRange(() => new ByteRangeStream(mockInnerStream.Object, range), "range",
                "The 'From' value of the range must be less than or equal to 5.", false, 10);
        }

        [Fact]
        public void Ctor_SetsContentRange()
        {
            // Arrange
            var expectedContentRange = new ContentRangeHeaderValue(5, 9, 20);
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(20);
            var range = new RangeItemHeaderValue(5, 9);

            // Act
            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Assert
                Assert.Equal(expectedContentRange, rangeStream.ContentRange);
            }
        }

        [Theory]
        [InlineData(0)]
        [InlineData(-1)]
        public void Ctor_ThrowsIfInnerStreamLengthIsLessThanOne(int innerLength)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            var range = new RangeItemHeaderValue(null, 0);

            // Act/Assert
            Assert.ThrowsArgumentOutOfRange(
                () => new ByteRangeStream(mockInnerStream.Object, range),
                "innerStream",
                "The stream over which 'ByteRangeStream' provides a range view must have a length greater than or " +
                "equal to 1.",
                false,
                innerLength);
        }

        [Theory]
        [PropertyData("ReadBoundsData")]
        public void Ctor_SetsLength(int from, int to, int innerLength, int expectedLength)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            var range = new RangeItemHeaderValue(from, to);

            // Act
            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Assert
                Assert.Equal(expectedLength, rangeStream.Length);
            }
        }

        [Theory]
        [PropertyData("CopyBoundsData")]
        public async Task CopyTo_ReadsSpecifiedRange(long? from, long? to, string expectedText)
        {
            // Arrange
            var originalText = "This is the whole text.";
            var range = new RangeItemHeaderValue(from, to);

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            using (var targetStream = new MemoryStream())
            using (var reader = new StreamReader(targetStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                // Act
                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    rangeStream.CopyTo(targetStream);
                }

                // Assert
                targetStream.Position = 0L;
                var text = await reader.ReadToEndAsync();
                Assert.Equal(expectedText, text);
            }
        }

        [Theory]
        [PropertyData("CopyBoundsData")]
        public async Task CopyToAsync_ReadsSpecifiedRange(long? from, long? to, string expectedText)
        {
            // Arrange
            var originalText = "This is the whole text.";
            var range = new RangeItemHeaderValue(from, to);

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            using (var targetStream = new MemoryStream())
            using (var reader = new StreamReader(targetStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                // Act
                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    await rangeStream.CopyToAsync(targetStream);
                }

                // Assert
                targetStream.Position = 0L;
                var text = await reader.ReadToEndAsync();
                Assert.Equal(expectedText, text);
            }
        }

        [Fact]
        public void Position_ThrowsOnNegativeValue()
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(10L);
            var range = new RangeItemHeaderValue(0, 25L);

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act & Assert
                Assert.Throws<ArgumentOutOfRangeException>(() => rangeStream.Position = -1L);
            }
        }

        [Theory]
        [InlineData(null)]
        [InlineData(0L)]
        [InlineData(7L)]
        [InlineData(9L)]
        public void Position_ReturnsZeroInitially(long? from)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(10L);
            var range = new RangeItemHeaderValue(from, 25L);

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                var position = rangeStream.Position;

                // Assert
                Assert.Equal(0L, position);
            }
        }

        [Fact]
        public void Position_CanBeSetAfterLength()
        {
            // Arrange
            var expectedPosition = 300L;
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(10L);
            var range = new RangeItemHeaderValue(0L, 10L);

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                rangeStream.Position = expectedPosition;

                // Assert
                Assert.Equal(expectedPosition, rangeStream.Position);
            }
        }

        [Fact]
        public async Task Position_PositionsNextRead()
        {
            // Arrange
            var originalText = "890123456789";
            var range = new RangeItemHeaderValue(2L, null);

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    // Act
                    rangeStream.Position = 5L;

                    // Assert
                    var read = rangeStream.ReadByte();
                    Assert.Equal('5', (char)read);
                }
            }
        }

#if !Testing_NetStandard1_3 // BeginX and EndX are not supported on Streams in netstandard1.3
        [Theory]
        [PropertyData("ReadBoundsDataWithLimit")]
        public void BeginRead_ReadsEffectiveLengthBytes(int from, int to, int innerLength, int effectiveLength)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            var range = new RangeItemHeaderValue(from, to);
            var data = new byte[25];
            var offset = 5;
            var callback = new AsyncCallback(_ => { });
            var userState = new object();

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                var result = rangeStream.BeginRead(data, offset, data.Length, callback, userState);
                rangeStream.EndRead(result);

                // Assert
                mockInnerStream.Verify(
                    s => s.BeginRead(data, offset, effectiveLength, callback, userState),
                    Times.Once());
                Assert.Equal(effectiveLength, rangeStream.Position);
            }
        }
#endif

        [Fact]
        public async Task BeginRead_CanReadAfterLength()
        {
            // Arrange
            var originalText = "This is the whole text.";
            var range = new RangeItemHeaderValue(0L, null);
            var data = new byte[25];
            var callback = new AsyncCallback(_ => { });
            var userState = new object();

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    rangeStream.Position = 50L;

                    // Act
                    var result = rangeStream.BeginRead(data, 0, data.Length, callback, userState);
                    var read = rangeStream.EndRead(result);

                    // Assert
                    Assert.Equal(0, read);
                }
            }
        }

        [Theory]
        [PropertyData("ReadBoundsDataWithLimit")]
        public void Read_ReadsEffectiveLengthBytes(int from, int to, int innerLength, int effectiveLength)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            var range = new RangeItemHeaderValue(from, to);
            var data = new byte[25];
            var offset = 5;

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                rangeStream.Read(data, offset, data.Length);

                // Assert
                mockInnerStream.Verify(s => s.Read(data, offset, effectiveLength), Times.Once());
                Assert.Equal(effectiveLength, rangeStream.Position);
            }
        }

        [Fact]
        public async Task Read_CanReadAfterLength()
        {
            // Arrange
            var originalText = "This is the whole text.";
            var range = new RangeItemHeaderValue(0L, null);
            var data = new byte[25];

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    rangeStream.Position = 50L;

                    // Act
                    var read = rangeStream.Read(data, 0, data.Length);

                    // Assert
                    Assert.Equal(0, read);
                }
            }
        }

        [Theory]
        [PropertyData("ReadBoundsDataWithLimit")]
        public async Task ReadAsync_ReadsEffectiveLengthBytes(int from, int to, int innerLength, int effectiveLength)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            var range = new RangeItemHeaderValue(from, to);
            var data = new byte[25];
            var offset = 5;

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                await rangeStream.ReadAsync(data, offset, data.Length);

                // Assert
                mockInnerStream.Verify(
                    s => s.ReadAsync(data, offset, effectiveLength, CancellationToken.None),
                    Times.Once());
                Assert.Equal(effectiveLength, rangeStream.Position);
            }
        }

        [Fact]
        public async Task ReadAsync_CanReadAfterLength()
        {
            // Arrange
            var originalText = "This is the whole text.";
            var range = new RangeItemHeaderValue(0L, null);
            var data = new byte[25];

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    rangeStream.Position = 50L;

                    // Act
                    var read = await rangeStream.ReadAsync(data, 0, data.Length);

                    // Assert
                    Assert.Equal(0, read);
                }
            }
        }

        [Theory]
        [PropertyData("ReadBoundsData")]
        public void ReadByte_ReadsEffectiveLengthTimes(int from, int to, int innerLength, int effectiveLength)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(innerLength);
            var range = new RangeItemHeaderValue(from, to);
            var counter = 0;

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                while (rangeStream.ReadByte() != -1)
                {
                    counter++;
                }

                // Assert
                mockInnerStream.Verify(s => s.ReadByte(), Times.Exactly(effectiveLength));
                Assert.Equal(effectiveLength, counter);
                Assert.Equal(effectiveLength, rangeStream.Position);
            }
        }

        [Fact]
        public async Task ReadByte_CanReadAfterLength()
        {
            // Arrange
            var originalText = "This is the whole text.";
            var range = new RangeItemHeaderValue(0L, null);

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    rangeStream.Position = 50L;

                    // Act
                    var read = rangeStream.ReadByte();

                    // Assert
                    Assert.Equal(-1, read);
                }
            }
        }

        [Theory]
        [InlineData(-1, SeekOrigin.Begin)]
        [InlineData(-1, SeekOrigin.Current)]
        [InlineData(-11, SeekOrigin.End)]
        public void Seek_ThrowsIfBeforeOrigin(int offset, SeekOrigin origin)
        {
            // Arrange
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(10L);
            var range = new RangeItemHeaderValue(0, 25L);

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act & Assert
                Assert.Throws<IOException>(() => rangeStream.Seek(offset, origin));
            }
        }

        [Theory]
        [InlineData(25, SeekOrigin.Begin)]
        [InlineData(25, SeekOrigin.Current)]
        [InlineData(15, SeekOrigin.End)]
        public void Seek_CanMoveAfterLength(int offset, SeekOrigin origin)
        {
            // Arrange
            var expectedPosition = 25L;
            var mockInnerStream = new Mock<Stream>();
            mockInnerStream.Setup(s => s.CanSeek).Returns(true);
            mockInnerStream.Setup(s => s.Length).Returns(10L);
            var range = new RangeItemHeaderValue(0L, 10L);

            using (var rangeStream = new ByteRangeStream(mockInnerStream.Object, range))
            {
                // Act
                var newPosition = rangeStream.Seek(offset, origin);

                // Assert
                Assert.Equal(expectedPosition, newPosition);
                Assert.Equal(expectedPosition, rangeStream.Position);
            }
        }

        [Theory]
        [InlineData(5, SeekOrigin.Begin)]
        [InlineData(5, SeekOrigin.Current)]
        [InlineData(-5, SeekOrigin.End)]
        public async Task Seek_PositionsNextRead(int offset, SeekOrigin origin)
        {
            // Arrange
            var originalText = "890123456789";
            var range = new RangeItemHeaderValue(2L, null);

            using (var innerStream = new MemoryStream())
            using (var writer = new StreamWriter(innerStream))
            {
                await writer.WriteAsync(originalText);
                await writer.FlushAsync();

                using (var rangeStream = new ByteRangeStream(innerStream, range))
                {
                    // Act
                    rangeStream.Seek(offset, origin);

                    // Assert
                    var read = rangeStream.ReadByte();
                    Assert.Equal('5', (char)read);
                }
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Internal/ConcurrentDictionaryTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Collections.Concurrent
{
    public class ConcurrentDictionaryTests
    {
        [Fact]
        public void ContainsKey_ReturnsFalseWhenKeyIsNotPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();

            // Act & Assert
            Assert.False(dictionary.ContainsKey(3));
        }

        [Fact]
        public void ContainsKey_ReturnsTrueWhenKeyIsPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();

            // Act
            dictionary.TryAdd(1, 2);

            // Assert
            Assert.True(dictionary.ContainsKey(1));
        }

        [Fact]
        public void GetOrAdd_AddsNewValueWhenKeyIsNotPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();

            // Act
            int returnedValue = dictionary.GetOrAdd(1, (key) => { return ++key; });

            // Assert
            Assert.Equal(2, returnedValue);
        }

        [Fact]
        public void GetOrAdd_ReturnsExistingValueWhenKeyIsPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();
            dictionary.TryAdd(1, -1);

            // Act
            int returnedValue = dictionary.GetOrAdd(1, (key) => { return ++key; });

            // Assert
            Assert.Equal(-1, returnedValue);
        }

        [Fact]
        public void TryAdd_ReturnsTrueWhenKeyIsNotPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();

            // Act
            bool result = dictionary.TryAdd(1, 2);

            // Assert
            Assert.True(result);
            Assert.True(dictionary.ContainsKey(1));
        }

        [Fact]
        public void TryAdd_ReturnsFalseWhenKeyIsPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();
            dictionary.TryAdd(1, 2);

            // Act
            bool result = dictionary.TryAdd(1, 2);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void AddOrUpdate_AddsValueWhenKeyIsNotPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();

            // Act
            int result = dictionary.AddOrUpdate(1, 2, (key, current) => { return ++current; });

            // Assert
            Assert.Equal(2, result);
            Assert.Equal(2, dictionary.GetOrAdd(1, (key) => { return -1; }));
        }

        [Fact]
        public void AddOrUpdate_UpdatesValueWhenKeyIsPresent()
        {
            // Arrange
            ConcurrentDictionary<int, int> dictionary = new ConcurrentDictionary<int, int>();
            dictionary.TryAdd(1, 2);

            // Act
            int result = dictionary.AddOrUpdate(1, 2, (key, current) => { return ++current; });

            // Assert
            Assert.Equal(3, result);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Internal/DelegatingStreamTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Mocks;
using System.Threading;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Net.Http.Internal
{
    public class DelegatingStreamTest
    {
        [Fact]
        public void DelegatingStream_CtorThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => new MockDelegatingStream(null), "innerStream");
        }

        [Fact]
        public void DelegatingStream_CanRead()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            bool canRead = mockStream.CanRead;

            // Assert
            mockInnerStream.Verify(s => s.CanRead, Times.Once());
        }

        [Fact]
        public void DelegatingStream_CanSeek()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            bool canSeek = mockStream.CanSeek;

            // Assert
            mockInnerStream.Verify(s => s.CanSeek, Times.Once());
        }

        [Fact]
        public void DelegatingStream_CanWrite()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            bool canWrite = mockStream.CanWrite;

            // Assert
            mockInnerStream.Verify(s => s.CanWrite, Times.Once());
        }

        [Fact]
        public void DelegatingStream_Length()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            long length = mockStream.Length;

            // Assert
            mockInnerStream.Verify(s => s.Length, Times.Once());
        }

        [Fact]
        public void DelegatingStream_Position()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            long position = mockStream.Position;

            // Assert
            mockInnerStream.Verify(s => s.Position, Times.Once());
        }

        [Fact]
        public void DelegatingStream_ReadTimeout()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            int readTimeout = mockStream.ReadTimeout;

            // Assert
            mockInnerStream.Verify(s => s.ReadTimeout, Times.Once());
        }

        [Fact]
        public void DelegatingStream_CanTimeout()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            bool canTimeout = mockStream.CanTimeout;

            // Assert
            mockInnerStream.Verify(s => s.CanTimeout, Times.Once());
        }

        [Fact]
        public void DelegatingStream_WriteTimeout()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            int writeTimeout = mockStream.WriteTimeout;

            // Assert
            mockInnerStream.Verify(s => s.WriteTimeout, Times.Once());
        }

        [Fact]
        public void DelegatingStream_Dispose()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.Dispose();

            // Assert
            mockInnerStream.Protected().Verify("Dispose", Times.Once(), exactParameterMatch: true, args: true);
            mockInnerStream.Verify(s => s.Close(), Times.Once());
        }

        [Fact]
        public void DelegatingStream_Close()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.Close();

            // Assert
            mockInnerStream.Protected().Verify("Dispose", Times.Once(), exactParameterMatch: true, args: true);
            mockInnerStream.Verify(s => s.Close(), Times.Once());
        }

        [Fact]
        public void DelegatingStream_Seek()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            long offset = 1;
            SeekOrigin origin = SeekOrigin.End;

            // Act
            long seek = mockStream.Seek(offset, origin);

            // Assert
            mockInnerStream.Verify(s => s.Seek(offset, origin), Times.Once());
        }

        [Fact]
        public void DelegatingStream_Read()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;

            // Act
            mockStream.Read(buffer, offset, count);

            // Assert
            mockInnerStream.Verify(s => s.Read(buffer, offset, count), Times.Once());
        }

#if !Testing_NetStandard1_3 // BeginX and EndX not supported on Streams in netstandard1.3
        [Fact]
        public void DelegatingStream_BeginRead()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;
            AsyncCallback callback = new AsyncCallback((asyncResult) => { });
            object state = new object();

            // Act
            mockStream.BeginRead(buffer, offset, count, callback, state);

            // Assert
            mockInnerStream.Verify(s => s.BeginRead(buffer, offset, count, callback, state), Times.Once());
        }

        [Fact]
        public void DelegatingStream_EndRead()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            Mock<IAsyncResult> mockIAsyncResult = new Mock<IAsyncResult>();

            // Act
            int endRead = mockStream.EndRead(mockIAsyncResult.Object);

            // Assert
            mockInnerStream.Verify(s => s.EndRead(mockIAsyncResult.Object), Times.Once());
        }
#endif

        [Fact]
        public void DelegatingStream_ReadAsyc()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;

            // Act
            mockStream.ReadAsync(buffer, offset, count, CancellationToken.None);

            // Assert
            mockInnerStream.Verify(s => s.ReadAsync(buffer, offset, count, CancellationToken.None), Times.Once());
        }

        [Fact]
        public void DelegatingStream_ReadByte()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            int readByte = mockStream.ReadByte();

            // Assert
            mockInnerStream.Verify(s => s.ReadByte(), Times.Once());
        }

        [Fact]
        public void DelegatingStream_Flush()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.Flush();

            // Assert
            mockInnerStream.Verify(s => s.Flush(), Times.Once());
        }

        [Fact]
        public void DelegatingStream_SetLength()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.SetLength(10L);

            // Assert
            mockInnerStream.Verify(s => s.SetLength(10L), Times.Once());
        }

        [Fact]
        public void DelegatingStream_Write()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;

            // Act
            mockStream.Write(buffer, offset, count);

            // Assert
            mockInnerStream.Verify(s => s.Write(buffer, offset, count), Times.Once());
        }

#if !Testing_NetStandard1_3 // BeginX and EndX not supported on Streams in netstandard1.3
        [Fact]
        public void DelegatingStream_BeginWrite()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;
            AsyncCallback callback = new AsyncCallback((asyncResult) => { });
            object state = new object();

            // Act
            mockStream.BeginWrite(buffer, offset, count, callback, state);

            // Assert
            mockInnerStream.Verify(s => s.BeginWrite(buffer, offset, count, callback, state), Times.Once());
        }

        [Fact]
        public void DelegatingStream_EndWrite()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            Mock<IAsyncResult> mockIAsyncResult = new Mock<IAsyncResult>();

            // Act
            mockStream.EndWrite(mockIAsyncResult.Object);

            // Assert
            mockInnerStream.Verify(s => s.EndWrite(mockIAsyncResult.Object), Times.Once());
        }
#endif

        [Fact]
        public void DelegatingStream_WriteAsync()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte[] buffer = new byte[2];
            int offset = 1;
            int count = 1;

            // Act
            mockStream.WriteAsync(buffer, offset, count, CancellationToken.None);

            // Assert
            mockInnerStream.Verify(s => s.WriteAsync(buffer, offset, count, CancellationToken.None), Times.Once());
        }

        [Fact]
        public void DelegatingStream_WriteByte()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>();
            MockDelegatingStream mockStream = new MockDelegatingStream(mockInnerStream.Object);
            byte data = new byte();

            // Act
            mockStream.WriteByte(data);

            // Assert
            mockInnerStream.Verify(s => s.WriteByte(data), Times.Once());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Internal/HttpValueCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting;
using System.Net.Http.Formatting.Internal;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Net.Http.Internal
{
    public class HttpValueCollectionTest
    {
#if !NETCOREAPP // Unused on .NET Core.
        private static readonly int _maxCollectionKeys = 1000;
#endif

        private static HttpValueCollection CreateInstance()
        {
            return HttpValueCollection.Create();
        }

#if !NETCOREAPP // Unsupported on .NET Core.
        private static void RunInIsolation(Action action)
        {
            AppDomainUtils.RunInSeparateAppDomain(action);
        }
#endif

        public static TheoryDataSet<IEnumerable<KeyValuePair<string, string>>> KeyValuePairs
        {
            get
            {
                return new TheoryDataSet<IEnumerable<KeyValuePair<string, string>>>()
                {
                    new List<KeyValuePair<string, string>>
                    {
                        new KeyValuePair<string,string>(null, null),
                        new KeyValuePair<string,string>("n0", ""),
                        new KeyValuePair<string,string>("n1", "v1"),
                        new KeyValuePair<string,string>("n@2", "v@2"),
                        new KeyValuePair<string,string>("n 3", "v 3"),
                        new KeyValuePair<string,string>("n+4", "v+4"),
                        new KeyValuePair<string,string>("n;5", "v;5"),
                        new KeyValuePair<string,string>("n=5", "v=5"),
                    }
                };
            }
        }

        internal class TestPropertyHolder
        {
            public static TheoryDataSet<HttpValueCollection, string> ToStringTestData
            {
                get
                {
                    TheoryDataSet<HttpValueCollection, string> dataSet = new TheoryDataSet<HttpValueCollection, string>();

                    var hvc1 = CreateInstance();
                    hvc1.Add(null, null);
                    dataSet.Add(hvc1, "");

                    var hvc2 = CreateInstance();
                    hvc2.Add("name", null);
                    dataSet.Add(hvc2, "name");

                    var hvc3 = CreateInstance();
                    hvc3.Add("name", "");
                    dataSet.Add(hvc3, "name");

                    var hvc4 = CreateInstance();
                    hvc4.Add("na me", "");
                    dataSet.Add(hvc4, "na+me");

                    string encoded5 = "n%22%2C%3B%5Cn";

                    var hvc5 = CreateInstance();
                    hvc5.Add("n\",;\\n", "");
                    dataSet.Add(hvc5, encoded5);

                    var hvc6 = CreateInstance();
                    hvc6.Add("", "v1");
                    hvc6.Add("", "v2");
                    hvc6.Add("", "v3");
                    hvc6.Add("", "v4");
                    dataSet.Add(hvc6, "=v1&=v2&=v3&=v4");

                    var hvc7 = CreateInstance();
                    hvc7.Add("n1", "v1");
                    hvc7.Add("n2", "v2");
                    hvc7.Add("n3", "v3");
                    hvc7.Add("n4", "v4");
                    dataSet.Add(hvc7, "n1=v1&n2=v2&n3=v3&n4=v4");

                    string encoded8 = "n%2C1=v%2C1&n%3B2=v%3B2";

                    var hvc8 = CreateInstance();
                    hvc8.Add("n,1", "v,1");
                    hvc8.Add("n;2", "v;2");
                    dataSet.Add(hvc8, encoded8);

                    string encoded9 = "n1=%26&n2=%3B&n3=%26&n4=%2B&n5=%26&n6=%3D&n7=%26";

                    var hvc9 = CreateInstance();
                    hvc9.Add("n1", "&");
                    hvc9.Add("n2", ";");
                    hvc9.Add("n3", "&");
                    hvc9.Add("n4", "+");
                    hvc9.Add("n5", "&");
                    hvc9.Add("n6", "=");
                    hvc9.Add("n7", "&");
                    dataSet.Add(hvc9, encoded9);

                    var hvc10 = CreateInstance();
                    hvc10.Add("n1", "&");
                    hvc10.Add("n2", null);
                    hvc10.Add("n3", "null");
                    dataSet.Add(hvc10, "n1=%26&n2&n3=null");

                    return dataSet;
                }
            }
        }

        [Fact]
        public void Create_CreatesEmptyCollection()
        {
            var nvc = CreateInstance();

            Assert.IsType<HttpValueCollection>(nvc);
            Assert.Empty(nvc);
        }

#if !NETCOREAPP // Able to run on a separate AppDomain only on .NET Framework.
        // This set of tests requires running on a separate appdomain so we don't
        // touch the static property MediaTypeFormatter.MaxHttpCollectionKeys.
        [Fact]
        public void Create_CreateTooManyKeysThrows()
        {
            RunInIsolation(Create_CreateTooManyKeysThrowsPrivate);
        }

        private static void Create_CreateTooManyKeysThrowsPrivate()
        {
            // Arrange
            MediaTypeFormatter.MaxHttpCollectionKeys = _maxCollectionKeys;

            List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();

            for (int i = 0; i < _maxCollectionKeys + 1; i++)
            {
                list.Add(new KeyValuePair<string, string>(i.ToString(), i.ToString()));
            }

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => HttpValueCollection.Create(list), TooManyKeysError);
        }

        private static string TooManyKeysError
        {
            get
            {
                return "The number of keys in a NameValueCollection has exceeded the limit of '" + _maxCollectionKeys + "'. You can adjust it by modifying the MaxHttpCollectionKeys property on the 'System.Net.Http.Formatting.MediaTypeFormatter' class.";
            }
        }

        [Fact]
        public void Create_CreateDoesntThrowTooManyValues()
        {
            RunInIsolation(Create_CreateDoesntThrowTooManyValuesPrivate);
        }

        private static void Create_CreateDoesntThrowTooManyValuesPrivate()
        {
            // note this is static, but also the expected type in a real run.
            MediaTypeFormatter.MaxHttpCollectionKeys = _maxCollectionKeys;

            List<KeyValuePair<string, string>> list = new List<KeyValuePair<string, string>>();

            for (int i = 0; i < _maxCollectionKeys + 1; i++)
            {
                list.Add(new KeyValuePair<string, string>("key", i.ToString()));
            }

            Assert.DoesNotThrow(() => HttpValueCollection.Create(list));
        }

        [Fact]
        public void AddTooManyKeysThrows()
        {
            RunInIsolation(AddTooManyKeysThrowsPrivate);
        }

        private static void AddTooManyKeysThrowsPrivate()
        {
            // Note this is static, but also the expected type in a real run.
            MediaTypeFormatter.MaxHttpCollectionKeys = _maxCollectionKeys;

            HttpValueCollection collection = CreateInstance();
            for (int i = 0; i < _maxCollectionKeys; i++)
            {
                collection.Add(i.ToString(), i.ToString());
            }

            // Act && Assert
            Assert.Throws<InvalidOperationException>(
                () => collection.Add(_maxCollectionKeys.ToString(), _maxCollectionKeys.ToString()),
                TooManyKeysError);
        }

        [Fact]
        public void AddDoesntThrowTooManyValues()
        {
            RunInIsolation(AddDoesntThrowTooManyValuesPrivate);
        }

        private static void AddDoesntThrowTooManyValuesPrivate()
        {
            // Note this is static, but also the expected type in a real run.
            MediaTypeFormatter.MaxHttpCollectionKeys = _maxCollectionKeys;

            HttpValueCollection collection = CreateInstance();

            // Act && Assert
            Assert.DoesNotThrow(() =>
            {
                for (int i = 0; i < 1001; i++)
                {
                    collection.Add("key", i.ToString());
                }
            });
        }
#endif

        [Theory]
        [PropertyData("KeyValuePairs")]
        public void Create_InitializesCorrectly(IEnumerable<KeyValuePair<string, string>> input)
        {
            var nvc = HttpValueCollection.Create(input);

            int count = input.Count();
            Assert.IsType<HttpValueCollection>(nvc);
            Assert.Equal(count, nvc.Count);

            int index = 0;

            foreach (KeyValuePair<string, string> kvp in input)
            {
                string expectedKey = kvp.Key ?? String.Empty;
                string expectedValue = kvp.Value ?? String.Empty;

                string actualKey = nvc.AllKeys[index];
                string actualValue = nvc[index];
                index++;

                Assert.Equal(expectedKey, actualKey);
                Assert.Equal(expectedValue, actualValue);
            }
        }

        [Theory]
        [PropertyData("KeyValuePairs")]
        public void GetIsEquivalentToIndexerProperty(IEnumerable<KeyValuePair<string, string>> input)
        {
            var nvc = HttpValueCollection.Create(input);

            int count = input.Count();
            Assert.IsType<HttpValueCollection>(nvc);
            Assert.Equal(count, nvc.Count);

            foreach (KeyValuePair<string, string> kvp in input)
            {
                Assert.Equal(nvc[kvp.Key], nvc.Get(kvp.Key));
            }
        }

        [Theory]
        [PropertyData("ToStringTestData", PropertyType = typeof(TestPropertyHolder))]
        internal void ToString_GeneratesCorrectOutput(HttpValueCollection input, string expectedOutput)
        {
            string actualOutput = input.ToString();
            Assert.Equal(expectedOutput, actualOutput);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Internal/NonClosingDelegatingStreamTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Mocks;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Net.Http.Internal
{
    public class NonClosingDelegatingStreamTest
    {
        [Fact]
        public void NonClosingDelegatingStream_Dispose()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            MockNonClosingDelegatingStream mockStream = new MockNonClosingDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.Dispose();

            // Assert
            mockInnerStream.Protected().Verify("Dispose", Times.Never(), exactParameterMatch: true, args: true);
            mockInnerStream.Verify(s => s.Close(), Times.Never());
        }

        [Fact]
        public void NonClosingDelegatingStream_Close()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            MockNonClosingDelegatingStream mockStream = new MockNonClosingDelegatingStream(mockInnerStream.Object);

            // Act
            mockStream.Close();

            // Assert
            mockInnerStream.Protected().Verify("Dispose", Times.Never(), exactParameterMatch: true, args: true);
            mockInnerStream.Verify(s => s.Close(), Times.Never());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Internal/TranscodingStreamTests.cs
================================================
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.

// From https://github.com/dotnet/runtime/blob/88868b7a781f4e5b9037b8721f30440207a7aa42/src/libraries/System.Text.Encoding/tests/Encoding/TranscodingStreamTests.cs

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Pipelines;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

#nullable enable annotations

namespace System.Text.Tests
{
    public class TranscodingStreamTests
    {
        public static IEnumerable<object[]> ReadWriteTestBufferLengths
        {
            get
            {
                yield return new object[] { 1 };
                yield return new object[] { 4 * 1024 };
                yield return new object[] { 128 * 1024 };
                yield return new object[] { 2 * 1024 * 1024 };
            }
        }

#if Testing_NetStandard1_3 || Testing_NetStandard2_0 // .NET Framework implementation loses track of cancellation token.
        [Fact]
        public void AsyncMethods_ReturnCanceledTaskIfCancellationTokenTripped()
        {
            // Arrange

            CancellationTokenSource cts = new();
            CancellationToken expectedCancellationToken = cts.Token;
            cts.Cancel();

            var innerStreamMock = new Mock<Stream>(MockBehavior.Strict); // only CanRead/CanWrite should ever be invoked
            innerStreamMock.Setup(o => o.CanRead).Returns(true);
            innerStreamMock.Setup(o => o.CanWrite).Returns(true);

            Stream transcodingStream = new TranscodingStream(innerStreamMock.Object, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);

            // Act & assert

            RunTest(() => transcodingStream.ReadAsync(new byte[0], 0, 0, expectedCancellationToken));
            RunTest(() => transcodingStream.WriteAsync(new byte[0], 0, 0, expectedCancellationToken));
#if NETCOREAPP || NETSTANDARD2_1
            RunTest(() => transcodingStream.ReadAsync(Memory<byte>.Empty, expectedCancellationToken).AsTask());
            RunTest(() => transcodingStream.WriteAsync(ReadOnlyMemory<byte>.Empty, expectedCancellationToken).AsTask());
#endif

            void RunTest(Func<Task> callback)
            {
                Task task = callback();
                Assert.True(task.IsCanceled);
                Assert.Equal(expectedCancellationToken, Assert.Throws<TaskCanceledException>(() => task.GetAwaiter().GetResult()).CancellationToken);
            }
        }
#endif

        [Fact]
        public void CreateTranscodingStream_InvalidArgs()
        {
            Assert.ThrowsArgumentNull(() => new TranscodingStream(null, Encoding.UTF8, Encoding.UTF8), "innerStream");
            Assert.ThrowsArgumentNull(() => new TranscodingStream(Stream.Null, null, Encoding.UTF8), "innerEncoding");
            Assert.ThrowsArgumentNull(() => new TranscodingStream(Stream.Null, Encoding.UTF8, null), "thisEncoding");
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void CanRead_DelegatesToInnerStream(bool expectedCanRead)
        {
            // Arrange

            var innerStreamMock = new Mock<Stream>();
            innerStreamMock.Setup(o => o.CanRead).Returns(expectedCanRead);
            Stream transcodingStream = new TranscodingStream(innerStreamMock.Object, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);

            // Act

            bool actualCanReadBeforeDispose = transcodingStream.CanRead;
            transcodingStream.Dispose();
            bool actualCanReadAfterDispose = transcodingStream.CanRead;

            // Assert

            Assert.Equal(expectedCanRead, actualCanReadBeforeDispose);
            Assert.False(actualCanReadAfterDispose);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void CanWrite_DelegatesToInnerStream(bool expectedCanWrite)
        {
            // Arrange

            var innerStreamMock = new Mock<Stream>();
            innerStreamMock.Setup(o => o.CanWrite).Returns(expectedCanWrite);
            Stream transcodingStream = new TranscodingStream(innerStreamMock.Object, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);

            // Act

            bool actualCanWriteBeforeDispose = transcodingStream.CanWrite;
            transcodingStream.Dispose();
            bool actualCanWriteAfterDispose = transcodingStream.CanWrite;

            // Assert

            Assert.Equal(expectedCanWrite, actualCanWriteBeforeDispose);
            Assert.False(actualCanWriteAfterDispose);
        }

        [Fact]
        public void Dispose_MakesMostSubsequentOperationsThrow()
        {
            // Arrange

            MemoryStream innerStream = new();
            Stream transcodingStream = new TranscodingStream(innerStream, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);

            // Act

            transcodingStream.Dispose();

            // Assert
            // For Task/ValueTask-returning methods, we want the exception to be thrown synchronously.

            Assert.False(transcodingStream.CanRead);
            Assert.False(transcodingStream.CanSeek);
            Assert.False(transcodingStream.CanWrite);

#if true // Not overriding these and base Stream's BeginXYZ methods check CanXYZ first, throwing NotSupportedException.
            Assert.Throws<NotSupportedException>(() => transcodingStream.BeginRead(new byte[0], 0, 0, null, null));
            Assert.Throws<NotSupportedException>(() => transcodingStream.BeginWrite(new byte[0], 0, 0, null, null));
#else
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.BeginRead(new byte[0], 0, 0, null, null));
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.BeginWrite(new byte[0], 0, 0, null, null));
#endif
#if NETCOREAPP || NETSTANDARD2_1
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.Read(Span<byte>.Empty));
            Assert.Throws<ObjectDisposedException>(() => (object)transcodingStream.ReadAsync(Memory<byte>.Empty));
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.Write(ReadOnlySpan<byte>.Empty));
            Assert.Throws<ObjectDisposedException>(() => (object)transcodingStream.WriteAsync(ReadOnlyMemory<byte>.Empty));
#endif
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.Flush());
            Assert.Throws<ObjectDisposedException>(() => (object)transcodingStream.FlushAsync());
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.Read(new byte[0], 0, 0));
            Assert.Throws<ObjectDisposedException>(() => (object)transcodingStream.ReadAsync(new byte[0], 0, 0));
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.ReadByte());
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.Write(new byte[0], 0, 0));
            Assert.Throws<ObjectDisposedException>(() => (object)transcodingStream.WriteAsync(new byte[0], 0, 0));
            Assert.Throws<ObjectDisposedException>(() => transcodingStream.WriteByte((byte)'x'));
        }

        [Fact]
        public void Dispose_WithLeaveOpenFalse_DisposesInnerStream()
        {
            // Sync

            MemoryStream innerStream = new();
            Stream transcodingStream = new TranscodingStream(innerStream, Encoding.UTF8, Encoding.UTF8, leaveOpen: false);
            transcodingStream.Dispose();
            transcodingStream.Dispose(); // calling it a second time should no-op
            Assert.Throws<ObjectDisposedException>(() => innerStream.Read(Array.Empty<byte>(), 0, 0));

            // Async

#if NETCOREAPP3_1_OR_GREATER || NETSTANDARD2_1
            innerStream = new MemoryStream();
            transcodingStream = new TranscodingStream(innerStream, Encoding.UTF8, Encoding.UTF8, leaveOpen: false);
            transcodingStream.DisposeAsync().GetAwaiter().GetResult();
            transcodingStream.DisposeAsync().GetAwaiter().GetResult(); // calling it a second time should no-op
            Assert.Throws<ObjectDisposedException>(() => innerStream.Read(Span<byte>.Empty));
#endif
        }

        [Fact]
        public void Dispose_WithLeaveOpenTrue_DoesNotDisposeInnerStream()
        {
            // Sync

            MemoryStream innerStream = new();
            Stream transcodingStream = new TranscodingStream(innerStream, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);
            transcodingStream.Dispose();
            transcodingStream.Dispose(); // calling it a second time should no-op
            innerStream.Read(Array.Empty<byte>(), 0, 0); // shouldn't throw

            // Async

#if NETCOREAPP3_1_OR_GREATER || NETSTANDARD2_1
            innerStream = new MemoryStream();
            transcodingStream = new TranscodingStream(innerStream, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);
            transcodingStream.DisposeAsync().GetAwaiter().GetResult();
            transcodingStream.DisposeAsync().GetAwaiter().GetResult(); // calling it a second time should no-op
            innerStream.Read(Span<byte>.Empty); // shouldn't throw
#endif
        }

        // Moq heavily utilizes RefEmit, which does not work on most aot workloads
        [Fact]
        public void Flush_FlushesInnerStreamButNotDecodedState()
        {
            // Arrange

            CancellationToken expectedCancellationToken = new CancellationTokenSource().Token;
            Task expectedFlushAsyncTask = Task.FromResult("just some task");

            var innerStreamMock = new Mock<MemoryStream>() { CallBase = true };
            innerStreamMock.Setup(o => o.FlushAsync(expectedCancellationToken)).Returns(expectedFlushAsyncTask);
            Stream transcodingStream = new TranscodingStream(innerStreamMock.Object, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);

            transcodingStream.Write(new byte[] { 0x7A, 0xE0 }, 0, 2);
            innerStreamMock.Verify(o => o.Flush(), Times.Never);
            innerStreamMock.Verify(o => o.FlushAsync(It.IsAny<CancellationToken>()), Times.Never);

            // Act & assert - sync flush

            transcodingStream.Flush();
            innerStreamMock.Verify(o => o.Flush(), Times.Once);
            innerStreamMock.Verify(o => o.FlushAsync(It.IsAny<CancellationToken>()), Times.Never);

            // Act & assert - async flush
            // This also validates that we flowed the CancellationToken as expected

            Task actualFlushAsyncReturnedTask = transcodingStream.FlushAsync(expectedCancellationToken);
            Assert.Same(expectedFlushAsyncTask, actualFlushAsyncReturnedTask);
            innerStreamMock.Verify(o => o.Flush(), Times.Once);
            innerStreamMock.Verify(o => o.FlushAsync(expectedCancellationToken), Times.Once);

            Assert.Equal("z", Encoding.UTF8.GetString(innerStreamMock.Object.ToArray())); // [ E0 ] shouldn't have been flushed
        }

        [Fact]
        public void IdenticalInnerAndOuterEncodings_DoesNotActAsPassthrough()
        {
            // Test read
            // [ C0 ] is never a valid UTF-8 byte, should be replaced with U+FFFD

            MemoryStream innerStream = new(new byte[] { 0xC0 });
            Stream transcodingStream = new TranscodingStream(innerStream, Encoding.UTF8, Encoding.UTF8);

            Assert.Equal(0xEF, transcodingStream.ReadByte());
            Assert.Equal(0xBF, transcodingStream.ReadByte());
            Assert.Equal(0xBD, transcodingStream.ReadByte());
            Assert.Equal(-1 /* eof */, transcodingStream.ReadByte());

            // Test write

            innerStream = new MemoryStream();
            transcodingStream = new TranscodingStream(innerStream, Encoding.UTF8, Encoding.UTF8);
            transcodingStream.WriteByte(0xC0);
            Assert.Equal(new byte[] { 0xEF, 0xBF, 0xBD }, innerStream.ToArray());
        }

        [Theory]
        [PropertyData(nameof(ReadWriteTestBufferLengths))]
        public void Read_ByteArray(int bufferLength)
        {
            // Tests TranscodingStream.Read(byte[], int, int)

            byte[] buffer = new byte[bufferLength + 3];

            RunReadTest((transcodingStream, sink) =>
            {
                int numBytesRead = transcodingStream.Read(buffer, 1, bufferLength);
                Assert.True(numBytesRead >= 0);
                Assert.True(numBytesRead <= bufferLength);

                sink.Write(buffer, 1, numBytesRead);
                return numBytesRead;
            });
        }

        [Fact]
        public void Read_ByteArray_WithInvalidArgs_Throws()
        {
            Stream transcodingStream = new TranscodingStream(new MemoryStream(), Encoding.UTF8, Encoding.UTF8);

            Assert.ThrowsArgumentNull(() => transcodingStream.Read(null, 0, 0), "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Read(new byte[5], -1, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Read(new byte[5], 3, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Read(new byte[5], 5, 1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Read(new byte[5], 6, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Read(new byte[5], 6, 0));
        }

        [Fact]
        public void Read_ByteByByte()
        {
            // Tests TranscodingStream.ReadByte

            RunReadTest((transcodingStream, sink) =>
            {
                int value = transcodingStream.ReadByte();
                if (value < 0)
                {
                    return 0;
                }

                sink.WriteByte(checked((byte)value));
                return 1;
            });
        }

#if NETCOREAPP || NETSTANDARD2_1
        [Theory]
        [PropertyData(nameof(ReadWriteTestBufferLengths))]
        public void Read_Span(int bufferLength)
        {
            // Tests TranscodingStream.Read(Span<byte>)

            byte[] buffer = new byte[bufferLength];

            RunReadTest((transcodingStream, sink) =>
            {
                int numBytesRead = transcodingStream.Read(buffer.AsSpan());
                Assert.True(numBytesRead >= 0);
                Assert.True(numBytesRead <= bufferLength);

                sink.Write(buffer.AsSpan(0, numBytesRead));
                return numBytesRead;
            });
        }
#endif

        private void RunReadTest(Func<Stream, MemoryStream, int> callback)
        {
            MemoryStream sink = new();

            MemoryStream innerStream = new();
            Stream transcodingStream = new TranscodingStream(innerStream,
                innerEncoding: Encoding.UTF8,
                thisEncoding: CustomAsciiEncoding);

            // Test with a small string, then test with a large string

            RunOneTestIteration(128);
            RunOneTestIteration(10 * 1024 * 1024);

            Assert.Equal(-1, transcodingStream.ReadByte()); // should've reached EOF

            // Now put some invalid data into the inner stream, followed by EOF, and ensure we get U+FFFD back out.

            innerStream.SetLength(0); // reset
            innerStream.WriteByte(0xC0); // [ C0 ] is never valid in UTF-8
            innerStream.Position = 0;

            sink.SetLength(0); // reset
            int numBytesReadJustNow;
            do
            {
                numBytesReadJustNow = callback(transcodingStream, sink);
                Assert.True(numBytesReadJustNow >= 0);
            } while (numBytesReadJustNow > 0);

            Assert.Equal("[FFFD]", ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));
            Assert.Equal(-1, transcodingStream.ReadByte()); // should've reached EOF

            // Now put some incomplete data into the inner stream, followed by EOF, and ensure we get U+FFFD back out.

            innerStream.SetLength(0); // reset
            innerStream.WriteByte(0xC2); // [ C2 ] must be followed by [ 80..BF ] in UTF-8
            innerStream.Position = 0;

            sink.SetLength(0); // reset
            do
            {
                numBytesReadJustNow = callback(transcodingStream, sink);
                Assert.True(numBytesReadJustNow >= 0);
            } while (numBytesReadJustNow > 0);

            Assert.Equal("[FFFD]", ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));
            Assert.Equal(-1, transcodingStream.ReadByte()); // should've reached EOF

            void RunOneTestIteration(int stringLength)
            {
                sink.SetLength(0); // reset

                string expectedStringContents = GetVeryLongAsciiString(stringLength);
                innerStream.SetLength(0); // reset
                var bytes = Encoding.UTF8.GetBytes(expectedStringContents);
                innerStream.Write(bytes, 0, bytes.Length);
                innerStream.Position = 0;

                int numBytesReadJustNow;
                do
                {
                    numBytesReadJustNow = callback(transcodingStream, sink);
                    Assert.True(numBytesReadJustNow >= 0);
                } while (numBytesReadJustNow > 0);

                Assert.Equal(expectedStringContents, ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));
            }
        }

        [Fact]
        public Task ReadApm()
        {
            // Tests TranscodingStream.BeginRead / EndRead

            byte[] buffer = new byte[1024 * 1024];

            return RunReadTestAsync((transcodingStream, cancellationToken, sink) =>
            {
                TaskCompletionSource<int> tcs = new();
                object expectedState = new();

                try
                {
                    IAsyncResult asyncResult = transcodingStream.BeginRead(buffer, 1, buffer.Length - 2, (asyncResult) =>
                    {
                        try
                        {
                            int numBytesReadJustNow = transcodingStream.EndRead(asyncResult);
                            Assert.True(numBytesReadJustNow >= 0);
                            Assert.True(numBytesReadJustNow < buffer.Length - 3);
                            sink.Write(buffer, 1, numBytesReadJustNow);
                            tcs.SetResult(numBytesReadJustNow);
                        }
                        catch (Exception ex)
                        {
                            tcs.SetException(ex);
                        }
                    }, expectedState);
                    Assert.Same(expectedState, asyncResult.AsyncState);
                }
                catch (Exception ex)
                {
                    tcs.SetException(ex);
                }

                return new ValueTask<int>(tcs.Task);
            },
            suppressExpectedCancellationTokenAsserts: true); // APM pattern doesn't allow flowing CancellationToken
        }

        [Theory]
        [PropertyData(nameof(ReadWriteTestBufferLengths))]
        public Task ReadAsync_ByteArray(int bufferLength)
        {
            // Tests TranscodingStream.ReadAsync(byte[], int, int, CancellationToken)

            byte[] buffer = new byte[bufferLength + 3];

            return RunReadTestAsync(async (transcodingStream, cancellationToken, sink) =>
            {
                int numBytesRead = await transcodingStream.ReadAsync(buffer, 1, bufferLength, cancellationToken);
                Assert.True(numBytesRead >= 0);
                Assert.True(numBytesRead <= bufferLength);

                sink.Write(buffer, 1, numBytesRead);
                return numBytesRead;
            });
        }

#if NETCOREAPP || NETSTANDARD2_1
        [Theory]
        [PropertyData(nameof(ReadWriteTestBufferLengths))]
        public async Task ReadAsync_Memory(int bufferLength)
        {
            // Tests TranscodingStream.ReadAsync(Memory<byte>, CancellationToken)

            byte[] buffer = new byte[bufferLength];

            await RunReadTestAsync(async (transcodingStream, cancellationToken, sink) =>
            {
                int numBytesRead = await transcodingStream.ReadAsync(buffer.AsMemory(), cancellationToken);
                Assert.True(numBytesRead >= 0);
                Assert.True(numBytesRead <= bufferLength);

                sink.Write(buffer.AsSpan(0, numBytesRead));
                return numBytesRead;
            });
        }
#endif

        [Fact]
        public async Task ReadAsync_LoopsWhenPartialDataReceived()
        {
            // Validates that the TranscodingStream will loop instead of returning 0
            // if the inner stream read partial data and GetBytes cannot make forward progress.

            using AsyncComms comms = new();
            Stream transcodingStream = new TranscodingStream(comms.ReadStream, Encoding.UTF8, Encoding.UTF8);

            // First, ensure that writing [ C0 ] (always invalid UTF-8) to the stream
            // causes the reader to return immediately with fallback behavior.

            byte[] readBuffer = new byte[1024];
            comms.WriteBytes(new byte[] { 0xC0 });

            int numBytesRead = await transcodingStream.ReadAsync(readBuffer, 0, readBuffer.Length);
            Assert.Equal(new byte[] { 0xEF, 0xBF, 0xBD }, readBuffer.AsSpan(0, numBytesRead).ToArray()); // fallback substitution

            // Next, ensure that writing [ C2 ] (partial UTF-8, needs more data) to the stream
            // causes the reader to asynchronously loop, returning "not yet complete".

            readBuffer = new byte[1024];
            comms.WriteBytes(new byte[] { 0xC2 });

            var task = transcodingStream.ReadAsync(readBuffer, 0, readBuffer.Length);
            Assert.False(task.IsCompleted);
            comms.WriteBytes(new byte[] { 0x80 }); // [ C2 80 ] is valid UTF-8

            numBytesRead = await task; // should complete successfully
            Assert.Equal(new byte[] { 0xC2, 0x80 }, readBuffer.AsSpan(0, numBytesRead).ToArray());

            // Finally, ensure that writing [ C2 ] (partial UTF-8, needs more data) to the stream
            // followed by EOF causes the reader to perform substitution before returning EOF.

            readBuffer = new byte[1024];
            comms.WriteBytes(new byte[] { 0xC2 });

            task = transcodingStream.ReadAsync(readBuffer, 0, readBuffer.Length);
            Assert.False(task.IsCompleted);
            comms.WriteEof();

            numBytesRead = await task; // should complete successfully
            Assert.Equal(new byte[] { 0xEF, 0xBF, 0xBD }, readBuffer.AsSpan(0, numBytesRead).ToArray()); // fallback substitution

            // Next call really should return "EOF reached"

            readBuffer = new byte[1024];
            Assert.Equal(0, await transcodingStream.ReadAsync(readBuffer, 0, readBuffer.Length));
        }

        [Fact]
        public void ReadAsync_WithInvalidArgs_Throws()
        {
            Stream transcodingStream = new TranscodingStream(new MemoryStream(), Encoding.UTF8, Encoding.UTF8);

            Assert.ThrowsArgumentNull(() => { transcodingStream.ReadAsync(null, 0, 0); }, "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.ReadAsync(new byte[5], -1, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.ReadAsync(new byte[5], 3, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.ReadAsync(new byte[5], 5, 1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.ReadAsync(new byte[5], 6, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.ReadAsync(new byte[5], 6, 0));
        }

        [Fact]
        public void ReadApm_WithInvalidArgs_ThrowsAsync()
        {
            Stream transcodingStream = new TranscodingStream(new MemoryStream(), Encoding.UTF8, Encoding.UTF8);

#if true
            // Not overriding BeginRead and base Stream's method returns a Task as its IAsyncResult, delaying parameter checks.
            Assert.ThrowsArgumentNull(() => transcodingStream.EndRead(transcodingStream.BeginRead(null, 0, 0, null, null)), "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndRead(transcodingStream.BeginRead(new byte[5], -1, -1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndRead(transcodingStream.BeginRead(new byte[5], 3, -1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndRead(transcodingStream.BeginRead(new byte[5], 5, 1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndRead(transcodingStream.BeginRead(new byte[5], 6, -1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndRead(transcodingStream.BeginRead(new byte[5], 6, 0, null, null)));
#else
            Assert.ThrowsArgumentNull(() => transcodingStream.BeginRead(null, 0, 0, null, null), "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginRead(new byte[5], -1, -1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginRead(new byte[5], 3, -1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginRead(new byte[5], 5, 1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginRead(new byte[5], 6, -1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginRead(new byte[5], 6, 0, null, null));
#endif
        }

        private async Task RunReadTestAsync(Func<Stream, CancellationToken, MemoryStream, ValueTask<int>> callback, bool suppressExpectedCancellationTokenAsserts = false)
        {
            CancellationToken expectedCancellationToken = new CancellationTokenSource().Token;
            MemoryStream sink = new();
            MemoryStream innerStream = new();

            var delegatingInnerStreamMock = new Mock<Stream>(MockBehavior.Strict);
            delegatingInnerStreamMock.Setup(o => o.CanRead).Returns(true);

            // Needed for ReadByte calls.
            delegatingInnerStreamMock.Setup(o => o.Read(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()))
                .Returns<byte[], int, int>(innerStream.Read);

#if true // In current src/ projects, always pass byte array to inner Stream.
            if (suppressExpectedCancellationTokenAsserts)
            {
                delegatingInnerStreamMock.Setup(o => o.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()))
                    .Returns<byte[], int, int, CancellationToken>(innerStream.ReadAsync);
            }
            else
            {
                delegatingInnerStreamMock.Setup(o => o.ReadAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), expectedCancellationToken))
                    .Returns<byte[], int, int, CancellationToken>(innerStream.ReadAsync);
            }
#else
            if (suppressExpectedCancellationTokenAsserts)
            {
                delegatingInnerStreamMock.Setup(o => o.ReadAsync(It.IsAny<Memory<byte>>(), It.IsAny<CancellationToken>()))
                    .Returns<Memory<byte>, CancellationToken>(innerStream.ReadAsync);
            }
            else
            {
                delegatingInnerStreamMock.Setup(o => o.ReadAsync(It.IsAny<Memory<byte>>(), expectedCancellationToken))
                    .Returns<Memory<byte>, CancellationToken>(innerStream.ReadAsync);
            }
#endif

            Stream transcodingStream = new TranscodingStream(
                innerStream: delegatingInnerStreamMock.Object,
                innerEncoding: Encoding.UTF8,
                thisEncoding: CustomAsciiEncoding);

            // Test with a small string, then test with a large string

            await RunOneTestIteration(128);
            await RunOneTestIteration(10 * 1024 * 1024);

            Assert.Equal(-1, transcodingStream.ReadByte()); // should've reached EOF

            // Now put some invalid data into the inner stream, followed by EOF, and ensure we get U+FFFD back out.

            innerStream.SetLength(0); // reset
            innerStream.WriteByte(0xC0); // [ C0 ] is never valid in UTF-8
            innerStream.Position = 0;

            sink.SetLength(0); // reset
            int numBytesReadJustNow;
            do
            {
                numBytesReadJustNow = await callback(transcodingStream, expectedCancellationToken, sink);
                Assert.True(numBytesReadJustNow >= 0);
            } while (numBytesReadJustNow > 0);

            Assert.Equal("[FFFD]", ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));
            Assert.Equal(-1, transcodingStream.ReadByte()); // should've reached EOF

            // Now put some incomplete data into the inner stream, followed by EOF, and ensure we get U+FFFD back out.

            innerStream.SetLength(0); // reset
            innerStream.WriteByte(0xC2); // [ C2 ] must be followed by [ 80..BF ] in UTF-8
            innerStream.Position = 0;

            sink.SetLength(0); // reset
            do
            {
                numBytesReadJustNow = await callback(transcodingStream, expectedCancellationToken, sink);
                Assert.True(numBytesReadJustNow >= 0);
            } while (numBytesReadJustNow > 0);

            Assert.Equal("[FFFD]", ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));
            Assert.Equal(-1, transcodingStream.ReadByte()); // should've reached EOF

            async Task RunOneTestIteration(int stringLength)
            {
                sink.SetLength(0); // reset

                string expectedStringContents = GetVeryLongAsciiString(stringLength);
                innerStream.SetLength(0); // reset
                var bytes = Encoding.UTF8.GetBytes(expectedStringContents);
                innerStream.Write(bytes, 0, bytes.Length);
                innerStream.Position = 0;

                int numBytesReadJustNow;
                do
                {
                    numBytesReadJustNow = await callback(transcodingStream, expectedCancellationToken, sink);
                    Assert.True(numBytesReadJustNow >= 0);
                } while (numBytesReadJustNow > 0);

                Assert.Equal(expectedStringContents, ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));
            }
        }

        [Fact]
        public void ReadTimeout_WriteTimeout_NotSupported()
        {
            // Arrange - allow inner stream to support ReadTimeout + WriteTimeout

            var innerStreamMock = new Mock<Stream>();
            innerStreamMock.SetupProperty(o => o.ReadTimeout);
            innerStreamMock.SetupProperty(o => o.WriteTimeout);
            Stream transcodingStream = new TranscodingStream(Stream.Null, Encoding.UTF8, Encoding.UTF8, leaveOpen: true);

            // Act & assert - TranscodingStream shouldn't support ReadTimeout + WriteTimeout

            Assert.False(transcodingStream.CanTimeout);
            Assert.Throws<InvalidOperationException>(() => transcodingStream.ReadTimeout);
            Assert.Throws<InvalidOperationException>(() => transcodingStream.ReadTimeout = 42);
            Assert.Throws<InvalidOperationException>(() => transcodingStream.WriteTimeout);
            Assert.Throws<InvalidOperationException>(() => transcodingStream.WriteTimeout = 42);
        }

        [Fact]
        public void Seek_AlwaysThrows()
        {
            // MemoryStream is seekable, but we're not
            Stream transcodingStream = new TranscodingStream(new MemoryStream(), Encoding.UTF8, Encoding.UTF8);

            Assert.False(transcodingStream.CanSeek);
            Assert.Throws<NotSupportedException>(() => transcodingStream.Length);
            Assert.Throws<NotSupportedException>(() => transcodingStream.Position);
            Assert.Throws<NotSupportedException>(() => transcodingStream.Position = 0);
            Assert.Throws<NotSupportedException>(() => transcodingStream.Seek(0, SeekOrigin.Current));
            Assert.Throws<NotSupportedException>(() => transcodingStream.SetLength(0));
        }

        [Fact]
        public void Write()
        {
            MemoryStream innerStream = new();
            Stream transcodingStream = new TranscodingStream(
                innerStream,
                innerEncoding: ErrorCheckingUnicodeEncoding /* throws on error */,
                thisEncoding: Encoding.UTF8 /* performs substitution */,
                leaveOpen: true);

            // First, test Write(byte[], int, int)

            transcodingStream.Write(Encoding.UTF8.GetBytes("abcdefg"), 2, 3);
            Assert.Equal("cde", ErrorCheckingUnicodeEncoding.GetString(innerStream.ToArray()));

            // Then test WriteByte(byte)

            transcodingStream.WriteByte((byte)'z');
            Assert.Equal("cdez", ErrorCheckingUnicodeEncoding.GetString(innerStream.ToArray()));

            // We'll write U+00E0 (utf-8: [C3 A0]) byte-by-byte.
            // We shouldn't flush any intermediate bytes.

            transcodingStream.WriteByte((byte)0xC3);
            Assert.Equal("cdez", ErrorCheckingUnicodeEncoding.GetString(innerStream.ToArray()));

            transcodingStream.WriteByte((byte)0xA0);
            Assert.Equal("cdez\u00E0", ErrorCheckingUnicodeEncoding.GetString(innerStream.ToArray()));

            innerStream.SetLength(0); // reset inner stream

            // Then test Write(ROS<byte>), once with a short string and once with a long string

            string asciiString = GetVeryLongAsciiString(128);
            byte[] asciiBytesAsUtf8 = Encoding.UTF8.GetBytes(asciiString);
            transcodingStream.Write(asciiBytesAsUtf8, 0, asciiBytesAsUtf8.Length);
            Assert.Equal(asciiString, ErrorCheckingUnicodeEncoding.GetString(innerStream.ToArray()));

            innerStream.SetLength(0); // reset inner stream

            asciiString = GetVeryLongAsciiString(16 * 1024 * 1024);
            asciiBytesAsUtf8 = Encoding.UTF8.GetBytes(asciiString);
            transcodingStream.Write(asciiBytesAsUtf8, 0, asciiBytesAsUtf8.Length);
            Assert.Equal(asciiString, ErrorCheckingUnicodeEncoding.GetString(innerStream.ToArray()));

            innerStream.SetLength(0); // reset inner stream

            // Close the outer stream and ensure no leftover data was written to the inner stream

            transcodingStream.Close();
            Assert.Equal(0, innerStream.Position);
        }

        [Fact]
        public void Write_WithPartialData()
        {
            MemoryStream innerStream = new();
            Stream transcodingStream = new TranscodingStream(
                innerStream,
                innerEncoding: CustomAsciiEncoding /* performs custom substitution */,
                thisEncoding: Encoding.UTF8 /* performs U+FFFD substitution */,
                leaveOpen: true);

            // First, write some incomplete data

            transcodingStream.Write(new byte[] { 0x78, 0x79, 0x7A, 0xC3 }, 0, 4); // [C3] shouldn't be flushed yet
            Assert.Equal("xyz", ErrorCheckingAsciiEncoding.GetString(innerStream.ToArray()));

            // Flushing should have no effect

            transcodingStream.Flush();
            Assert.Equal("xyz", ErrorCheckingAsciiEncoding.GetString(innerStream.ToArray()));

            // Provide the second byte of the multi-byte sequence

            transcodingStream.WriteByte(0xA0); // [C3 A0] = U+00E0
            Assert.Equal("xyz[00E0]", ErrorCheckingAsciiEncoding.GetString(innerStream.ToArray()));

            // Provide an incomplete sequence, then close the stream.
            // Closing the stream should flush the underlying buffers and write the replacement char.

            transcodingStream.Write(new byte[] { 0xE0, 0xBF }, 0, 1); // first 2 bytes of incomplete 3-byte sequence
            Assert.Equal("xyz[00E0]", ErrorCheckingAsciiEncoding.GetString(innerStream.ToArray())); // wasn't flushed yet

            transcodingStream.Close();
            Assert.Equal("xyz[00E0][FFFD]", ErrorCheckingAsciiEncoding.GetString(innerStream.ToArray()));
        }

        [Fact]
        public void Write_WithInvalidArgs_Throws()
        {
            Stream transcodingStream = new TranscodingStream(new MemoryStream(), Encoding.UTF8, Encoding.UTF8);

            Assert.ThrowsArgumentNull(() => transcodingStream.Write(null, 0, 0), "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Write(new byte[5], -1, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Write(new byte[5], 3, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Write(new byte[5], 5, 1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Write(new byte[5], 6, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.Write(new byte[5], 6, 0));
        }

        // Moq heavily utilizes RefEmit, which does not work on most aot workloads
        [Fact]
        public async Task WriteAsync_WithFullData()
        {
            MemoryStream sink = new();
            CancellationToken expectedFlushAsyncCancellationToken = new CancellationTokenSource().Token;
            CancellationToken expectedWriteAsyncCancellationToken = new CancellationTokenSource().Token;

            var innerStreamMock = new Mock<Stream>(MockBehavior.Strict);
            innerStreamMock.Setup(o => o.CanWrite).Returns(true);
#if true // In current src/ projects, always pass byte array to inner Stream.
            innerStreamMock.Setup(o => o.WriteAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), expectedWriteAsyncCancellationToken))
                .Returns<byte[], int, int, CancellationToken>(sink.WriteAsync);
#else
            innerStreamMock.Setup(o => o.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), expectedWriteAsyncCancellationToken))
                .Returns<ReadOnlyMemory<byte>, CancellationToken>(sink.WriteAsync);
#endif
            innerStreamMock.Setup(o => o.FlushAsync(expectedFlushAsyncCancellationToken)).Returns(TaskHelpers.Completed());

            Stream transcodingStream = new TranscodingStream(
                innerStreamMock.Object,
                innerEncoding: ErrorCheckingUnicodeEncoding,
                thisEncoding: Encoding.UTF8 /* performs U+FFFD substitution */,
                leaveOpen: true);

            // First, test WriteAsync(byte[], int, int, CancellationToken)

            await transcodingStream.WriteAsync(Encoding.UTF8.GetBytes("abcdefg"), 2, 3, expectedWriteAsyncCancellationToken);
            Assert.Equal("cde", ErrorCheckingUnicodeEncoding.GetString(sink.ToArray()));

            // We'll write U+00E0 (utf-8: [C3 A0]) byte-by-byte.
            // We shouldn't flush any intermediate bytes.

            await transcodingStream.WriteAsync(new byte[] { 0xC3, 0xA0 }, 0, 1, expectedWriteAsyncCancellationToken);
            await transcodingStream.FlushAsync(expectedFlushAsyncCancellationToken);
            Assert.Equal("cde", ErrorCheckingUnicodeEncoding.GetString(sink.ToArray()));

            await transcodingStream.WriteAsync(new byte[] { 0xC3, 0xA0 }, 1, 1, expectedWriteAsyncCancellationToken);
            Assert.Equal("cde\u00E0", ErrorCheckingUnicodeEncoding.GetString(sink.ToArray()));

            sink.SetLength(0); // reset sink

            // Then test WriteAsync(ROM<byte>, CancellationToken), once with a short string and once with a long string

            string asciiString = GetVeryLongAsciiString(128);
            byte[] asciiBytesAsUtf8 = Encoding.UTF8.GetBytes(asciiString);
            await transcodingStream.WriteAsync(asciiBytesAsUtf8, 0, asciiBytesAsUtf8.Length, expectedWriteAsyncCancellationToken);
            Assert.Equal(asciiString, ErrorCheckingUnicodeEncoding.GetString(sink.ToArray()));

            sink.SetLength(0); // reset sink

            asciiString = GetVeryLongAsciiString(16 * 1024 * 1024);
            asciiBytesAsUtf8 = Encoding.UTF8.GetBytes(asciiString);
            await transcodingStream.WriteAsync(asciiBytesAsUtf8, 0, asciiBytesAsUtf8.Length, expectedWriteAsyncCancellationToken);
            Assert.Equal(asciiString, ErrorCheckingUnicodeEncoding.GetString(sink.ToArray()));

            sink.SetLength(0); // reset sink

            // Close the outer stream and ensure no leftover data was written to the inner stream

            transcodingStream.Dispose();
            Assert.Equal(0, sink.Position);
        }

        // Moq heavily utilizes RefEmit, which does not work on most aot workloads
        [Fact]
        public async Task WriteAsync_WithPartialData()
        {
            MemoryStream sink = new();
            CancellationToken expectedCancellationToken = new CancellationTokenSource().Token;

            var innerStreamMock = new Mock<Stream>(MockBehavior.Strict);
            innerStreamMock.Setup(o => o.CanWrite).Returns(true);
#if true // In current src/ projects, always pass byte array to inner Stream.
            innerStreamMock.Setup(o => o.WriteAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), expectedCancellationToken))
                .Returns<byte[], int, int, CancellationToken>(sink.WriteAsync);
#else
            innerStreamMock.Setup(o => o.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), expectedCancellationToken))
                .Returns<ReadOnlyMemory<byte>, CancellationToken>(sink.WriteAsync);
#endif

            Stream transcodingStream = new TranscodingStream(
                innerStreamMock.Object,
                innerEncoding: CustomAsciiEncoding /* performs custom substitution */,
                thisEncoding: Encoding.UTF8 /* performs U+FFFD substitution */,
                leaveOpen: true);

            // First, write some incomplete data

            await transcodingStream.WriteAsync(new byte[] { 0x78, 0x79, 0x7A, 0xC3 }, 0, 4, expectedCancellationToken); // [C3] shouldn't be flushed yet
            Assert.Equal("xyz", ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));

            // Provide the second byte of the multi-byte sequence

            await transcodingStream.WriteAsync(new byte[] { 0xA0 }, 0, 1, expectedCancellationToken); // [C3 A0] = U+00E0
            Assert.Equal("xyz[00E0]", ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));

            // Provide an incomplete sequence, then close the stream.
            // Closing the stream should flush the underlying buffers and write the replacement char.

            await transcodingStream.WriteAsync(new byte[] { 0xE0, 0xBF }, 0, 2, expectedCancellationToken); // first 2 bytes of incomplete 3-byte sequence
            Assert.Equal("xyz[00E0]", ErrorCheckingAsciiEncoding.GetString(sink.ToArray())); // wasn't flushed yet

            // The call to Dispose() will call innerStream.Write.

            innerStreamMock.Setup(o => o.Write(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()))
                .Callback<byte[], int, int>(sink.Write);
            transcodingStream.Dispose();
            Assert.Equal("xyz[00E0][FFFD]", ErrorCheckingAsciiEncoding.GetString(sink.ToArray()));
        }

        [Fact]
        public void WriteAsync_WithInvalidArgs_Throws()
        {
            Stream transcodingStream = new TranscodingStream(new MemoryStream(), Encoding.UTF8, Encoding.UTF8);

            Assert.ThrowsArgumentNull(() => { transcodingStream.WriteAsync(null, 0, 0); }, "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.WriteAsync(new byte[5], -1, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.WriteAsync(new byte[5], 3, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.WriteAsync(new byte[5], 5, 1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.WriteAsync(new byte[5], 6, -1));
            Assert.Throws<ArgumentOutOfRangeException>(() => (object)transcodingStream.WriteAsync(new byte[5], 6, 0));
        }

        // Moq heavily utilizes RefEmit, which does not work on most aot workloads
        [Fact]
        public void WriteApm()
        {
            // Arrange

            MemoryStream sink = new();
            object expectedState = new();

            var innerStreamMock = new Mock<Stream>(MockBehavior.Strict);
            innerStreamMock.Setup(o => o.CanWrite).Returns(true);
#if true // In current src/ projects, base Stream's BeginWrite method relies on Write and passes the byte array to the inner stream.
            innerStreamMock.Setup(o => o.Write(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()))
                .Callback<byte[], int, int>(sink.Write);
#else
            innerStreamMock.Setup(o => o.WriteAsync(It.IsAny<ReadOnlyMemory<byte>>(), CancellationToken.None))
                .Returns<ReadOnlyMemory<byte>, CancellationToken>(sink.WriteAsync);
#endif

            Stream transcodingStream = new TranscodingStream(innerStreamMock.Object, Encoding.UTF8, Encoding.UTF8);

            // Act

            IAsyncResult asyncResult = transcodingStream.BeginWrite(Encoding.UTF8.GetBytes("abcdefg"), 1, 3, null, expectedState);
            transcodingStream.EndWrite(asyncResult);

            // Assert

            Assert.Equal(expectedState, asyncResult.AsyncState);
            Assert.Equal("bcd", Encoding.UTF8.GetString(sink.ToArray()));
        }

        [Fact]
        public void WriteApm_WithInvalidArgs_Throws()
        {
            Stream transcodingStream = new TranscodingStream(new MemoryStream(), Encoding.UTF8, Encoding.UTF8);

#if true // Not overriding BeginRead and base Stream's method returns a Task as its IAsyncResult, delaying parameter checks.
            Assert.ThrowsArgumentNull(() => transcodingStream.EndWrite(transcodingStream.BeginWrite(null, 0, 0, null, null)), "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndWrite(transcodingStream.BeginWrite(new byte[5], -1, -1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndWrite(transcodingStream.BeginWrite(new byte[5], 3, -1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndWrite(transcodingStream.BeginWrite(new byte[5], 5, 1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndWrite(transcodingStream.BeginWrite(new byte[5], 6, -1, null, null)));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.EndWrite(transcodingStream.BeginWrite(new byte[5], 6, 0, null, null)));
#else
            Assert.ThrowsArgumentNull(() => transcodingStream.BeginWrite(null, 0, 0, null, null), "buffer");
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginWrite(new byte[5], -1, -1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginWrite(new byte[5], 3, -1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginWrite(new byte[5], 5, 1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginWrite(new byte[5], 6, -1, null, null));
            Assert.Throws<ArgumentOutOfRangeException>(() => transcodingStream.BeginWrite(new byte[5], 6, 0, null, null));
#endif
        }

        // returns "abc...xyzabc...xyzabc..."
        private static string GetVeryLongAsciiString(int length)
        {
#if NETCOREAPP || NETSTANDARD2_1
            return string.Create(length, (object)null, (buffer, _) =>
            {
                for (int i = 0; i < buffer.Length; i++)
                {
                    buffer[i] = (char)('a' + (i % 26));
                }
            });
#else
            // Somewhat minor that the string just repeats a single character.
            return new string('z', length);
#endif
        }

        // A custom ASCIIEncoding where both encoder + decoder fallbacks have been specified
        private static readonly Encoding CustomAsciiEncoding = Encoding.GetEncoding(
            "ascii", new CustomEncoderFallback(), new DecoderReplacementFallback("\uFFFD"));

        private static readonly Encoding ErrorCheckingAsciiEncoding
            = Encoding.GetEncoding("ascii", EncoderFallback.ExceptionFallback, DecoderFallback.ExceptionFallback);

        private static readonly UnicodeEncoding ErrorCheckingUnicodeEncoding
            = new(bigEndian: false, byteOrderMark: false, throwOnInvalidBytes: true);

        // A custom encoder fallback which substitutes unknown chars with "[xxxx]" (the code point as hex)
        private sealed class CustomEncoderFallback : EncoderFallback
        {
            public override int MaxCharCount => 8; // = "[10FFFF]".Length

            public override EncoderFallbackBuffer CreateFallbackBuffer()
            {
                return new CustomEncoderFallbackBuffer();
            }

            private sealed class CustomEncoderFallbackBuffer : EncoderFallbackBuffer
            {
                private string _remaining = string.Empty;
                private int _remainingIdx = 0;

                public override int Remaining => _remaining.Length - _remainingIdx;

                public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
                    => FallbackCommon((uint)char.ConvertToUtf32(charUnknownHigh, charUnknownLow));

                public override bool Fallback(char charUnknown, int index)
                    => FallbackCommon(charUnknown);

                private bool FallbackCommon(uint codePoint)
                {
                    Assert.True(codePoint <= 0x10FFFF);
                    _remaining = String.Format(CultureInfo.InvariantCulture, "[{0:X4}]", codePoint);
                    _remainingIdx = 0;
                    return true;
                }

                public override char GetNextChar()
                {
                    return (_remainingIdx < _remaining.Length)
                        ? _remaining[_remainingIdx++]
                        : '\0' /* end of string reached */;
                }

                public override bool MovePrevious()
                {
                    if (_remainingIdx == 0)
                    {
                        return false;
                    }

                    _remainingIdx--;
                    return true;
                }
            }
        }

        /// <summary>A custom encoding that's used to roundtrip from bytes to bytes through a string.</summary>
        private sealed class IdentityEncoding : Encoding
        {
            public override int GetByteCount(char[] chars, int index, int count) => count;

            public override int GetBytes(char[] chars, int charIndex, int charCount, byte[] bytes, int byteIndex)
            {
                Span<char> span = chars.AsSpan(charIndex, charCount);
                for (int i = 0; i < span.Length; i++)
                {
                    Debug.Assert(span[i] <= 0xFF);
                    bytes[byteIndex + i] = (byte)span[i];
                }
                return charCount;
            }

            public override int GetCharCount(byte[] bytes, int index, int count) => count;

            public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex)
            {
                Span<byte> span = bytes.AsSpan(byteIndex, byteCount);
                for (int i = 0; i < span.Length; i++)
                {
                    Debug.Assert(span[i] <= 0xFF);
                    chars[charIndex + i] = (char)span[i];
                }
                return byteCount;
            }

            public override int GetMaxByteCount(int charCount) => charCount;

            public override int GetMaxCharCount(int byteCount) => byteCount;

            public override byte[] GetPreamble() => Array.Empty<byte>();
        }

        // A helper type that allows synchronously writing to a stream while asynchronously
        // reading from it.
        private sealed class AsyncComms : IDisposable
        {
            private readonly BlockingCollection<byte[]> _blockingCollection;
            private readonly PipeWriter _writer;

            public AsyncComms()
            {
                _blockingCollection = new BlockingCollection<byte[]>();
                var pipe = new Pipe();
                ReadStream = pipe.Reader.AsStream();
                _writer = pipe.Writer;
                Task.Run(DrainWorker);
            }

            public Stream ReadStream { get; }

            public void Dispose()
            {
                _blockingCollection.Dispose();
            }

            public void WriteBytes(ReadOnlySpan<byte> bytes)
            {
                _blockingCollection.Add(bytes.ToArray());
            }

            public void WriteEof()
            {
                _blockingCollection.Add(null);
            }

            private async Task DrainWorker()
            {
                byte[] buffer;
                while ((buffer = _blockingCollection.Take()) is not null)
                {
                    await _writer.WriteAsync(buffer);
                }
                _writer.Complete();
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/InvalidByteRangeExceptionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class InvalidByteRangeExceptionTest
    {
        [Fact]
        public void Ctor_ThrowsOnNullRange()
        {
            Assert.ThrowsArgumentNull(() => new InvalidByteRangeException(contentRange: null), "contentRange");
        }

        [Fact]
        public void Ctor_SetsContentRange()
        {
            ContentRangeHeaderValue contentRange = new ContentRangeHeaderValue(0, 20, 100);
            InvalidByteRangeException invalidByteRangeException = new InvalidByteRangeException(contentRange);
            Assert.Same(contentRange, invalidByteRangeException.ContentRange);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MimeBodyPartTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class MimeBodyPartTest
    {
        public static TheoryDataSet<MultipartStreamProvider> BadMultipartStreamProviders
        {
            get
            {
                return new TheoryDataSet<MultipartStreamProvider>
                {
                    new HttpContentMultipartExtensionsTests.NullProvider(),
                    new HttpContentMultipartExtensionsTests.BadStreamProvider(),
                    new HttpContentMultipartExtensionsTests.ReadOnlyStreamProvider(),
                };
            }
        }

        [Theory]
        [TestDataSet(typeof(MimeBodyPartTest), "BadMultipartStreamProviders")]
        public async Task GetOutputStream_ThrowsOnInvalidStreamProvider(MultipartStreamProvider streamProvider)
        {
            // Arrange
            HttpContent parent = new StringContent("hello");
            MimeBodyPart bodypart = new MimeBodyPart(streamProvider, 1024, parent);
            bodypart.Segments.Add(new ArraySegment<byte>(new byte[] { 1 }));

            // Act and Assert
            await Assert.ThrowsAsync<InvalidOperationException>(() => bodypart.WriteSegment(bodypart.Segments[0], CancellationToken.None));
        }

        [Fact]
        public async Task Dispose_ClosesOutputStreamOnNonMemoryStream()
        {
            // Arrange
            HttpContent parent = new StringContent("hello");
            Mock<Stream> mockStream = new Mock<Stream>() { CallBase = true };
            mockStream.Setup(s => s.CanWrite).Returns(true);
            Mock<MultipartStreamProvider> mockStreamProvider = new Mock<MultipartStreamProvider>();
            mockStreamProvider.Setup(sp => sp.GetStream(It.IsAny<HttpContent>(), It.IsAny<HttpContentHeaders>())).Returns(mockStream.Object);
            MimeBodyPart bodypart = new MimeBodyPart(mockStreamProvider.Object, 1024, parent);
            bodypart.Segments.Add(new ArraySegment<byte>(new byte[] { 1 }));
            await bodypart.WriteSegment(bodypart.Segments[0], CancellationToken.None);
            bodypart.IsComplete = true;

            // Act
            bodypart.GetCompletedHttpContent();
            bodypart.Dispose();

            // Assert
            mockStream.Verify(s => s.Close(), Times.Once());
        }

        [Fact]
        public async Task Dispose_SetsPositionToZeroOnMemoryStream()
        {
            // Arrange
            HttpContent parent = new StringContent("hello");
            Mock<MemoryStream> mockStream = new Mock<MemoryStream> { CallBase = true };
            Mock<MultipartStreamProvider> mockStreamProvider = new Mock<MultipartStreamProvider>();
            mockStreamProvider.Setup(sp => sp.GetStream(It.IsAny<HttpContent>(), It.IsAny<HttpContentHeaders>())).Returns(mockStream.Object);
            MimeBodyPart bodypart = new MimeBodyPart(mockStreamProvider.Object, 1024, parent);
            bodypart.Segments.Add(new ArraySegment<byte>(new byte[] { 1 }));
            await bodypart.WriteSegment(bodypart.Segments[0], CancellationToken.None);
            bodypart.IsComplete = true;

            // Act
            bodypart.GetCompletedHttpContent();
            bodypart.Dispose();

            // Assert
            mockStream.VerifySet(s => s.Position = 0);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockAsyncCallback.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http.Formatting.Mocks
{
    public class MockAsyncCallback
    {
        public bool WasInvoked { get; private set; }

        public IAsyncResult AsyncResult { get; private set; }

        public void Handler(IAsyncResult result)
        {
            WasInvoked = true;
            AsyncResult = result;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockCompletedAsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Moq;

namespace System.Net.Http.Formatting.Mocks
{
    public class MockCompletedAsyncResult
    {
        private MockCompletedAsyncResult()
        {
        }

        public static IAsyncResult Create(bool completedSynchronously, object userState)
        {
            Mock<IAsyncResult> mockIAsyncResult = new Mock<IAsyncResult>();
            mockIAsyncResult.Setup(ar => ar.AsyncState).Returns(userState);
            mockIAsyncResult.Setup(ar => ar.IsCompleted).Returns(true);
            mockIAsyncResult.Setup(ar => ar.CompletedSynchronously).Returns(completedSynchronously);
            return mockIAsyncResult.Object;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockContentNegotiator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http.Headers;
using System.Text;

namespace System.Net.Http.Formatting.Mocks
{
    public class MockContentNegotiator : DefaultContentNegotiator
    {
        public MockContentNegotiator()
        {
        }

        public MockContentNegotiator(bool excludeMatchOnTypeOnly)
            : base(excludeMatchOnTypeOnly)
        {
        }

        public new Collection<MediaTypeFormatterMatch> ComputeFormatterMatches(Type type, HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
        {
            return base.ComputeFormatterMatches(type, request, formatters);
        }

        public new MediaTypeFormatterMatch SelectResponseMediaTypeFormatter(ICollection<MediaTypeFormatterMatch> matches)
        {
            return base.SelectResponseMediaTypeFormatter(matches);
        }

        public new Encoding SelectResponseCharacterEncoding(HttpRequestMessage request, MediaTypeFormatter formatter)
        {
            return base.SelectResponseCharacterEncoding(request, formatter);
        }

        public new MediaTypeFormatterMatch MatchMediaTypeMapping(HttpRequestMessage request, MediaTypeFormatter formatter)
        {
            return base.MatchMediaTypeMapping(request, formatter);
        }

        public new MediaTypeFormatterMatch MatchAcceptHeader(IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues, MediaTypeFormatter formatter)
        {
            return base.MatchAcceptHeader(sortedAcceptValues, formatter);
        }

        public new MediaTypeFormatterMatch MatchRequestMediaType(HttpRequestMessage request, MediaTypeFormatter formatter)
        {
            return base.MatchRequestMediaType(request, formatter);
        }

        public new bool ShouldMatchOnType(IEnumerable<MediaTypeWithQualityHeaderValue> sortedAcceptValues)
        {
            return base.ShouldMatchOnType(sortedAcceptValues);
        }

        public new MediaTypeFormatterMatch MatchType(Type type, MediaTypeFormatter formatter)
        {
            return base.MatchType(type, formatter);
        }

        public new IEnumerable<MediaTypeWithQualityHeaderValue> SortMediaTypeWithQualityHeaderValuesByQFactor(ICollection<MediaTypeWithQualityHeaderValue> headerValues)
        {
            return base.SortMediaTypeWithQualityHeaderValuesByQFactor(headerValues);
        }

        public new IEnumerable<StringWithQualityHeaderValue> SortStringWithQualityHeaderValuesByQFactor(ICollection<StringWithQualityHeaderValue> headerValues)
        {
            return base.SortStringWithQualityHeaderValuesByQFactor(headerValues);
        }

        public new MediaTypeFormatterMatch UpdateBestMatch(MediaTypeFormatterMatch current, MediaTypeFormatterMatch potentialReplacement)
        {
            return base.UpdateBestMatch(current, potentialReplacement);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockDelegatingHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Net.Http.Mocks
{
    internal class MockDelegatingHandler : DelegatingHandler
    {
        private bool _throwInSendAsync;

        public MockDelegatingHandler(bool throwInSendAsync = false)
        {
            _throwInSendAsync = throwInSendAsync;
        }

        public MockDelegatingHandler(HttpMessageHandler innerHandler, bool throwInSendAsync = false)
            : base(innerHandler)
        {
            _throwInSendAsync = throwInSendAsync;
        }

        public bool WasInvoked { get; private set; }

        public HttpRequestMessage Request { get; private set; }

        public CancellationToken CancellationToken { get; private set; }

        public Exception SendAsyncException { get; private set; }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            WasInvoked = true;
            Request = request;
            CancellationToken = cancellationToken;

            if (_throwInSendAsync)
            {
                SendAsyncException = new Exception("SendAsync exception");
                throw SendAsyncException;
            }
            return Task.FromResult(request.CreateResponse());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockDelegatingStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Internal;

namespace System.Net.Http.Mocks
{
    internal class MockDelegatingStream : DelegatingStream
    {
        public MockDelegatingStream(Stream innerStream)
            : base(innerStream)
        {
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockHttpContent.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using System.Threading.Tasks;

namespace System.Net.Http.Formatting.Mocks
{
    public delegate bool TryComputeLengthDelegate(out long length);

    public class MockHttpContent : HttpContent
    {
        public MockHttpContent()
        {
        }

        public MockHttpContent(HttpContent innerContent)
        {
            InnerContent = innerContent;
            Headers.ContentType = innerContent.Headers.ContentType;
        }

        public MockHttpContent(MediaTypeHeaderValue contentType)
        {
            if (contentType == null)
            {
                throw new ArgumentNullException("contentType");
            }
            Headers.ContentType = contentType;
        }

        public MockHttpContent(string contentType)
        {
            if (String.IsNullOrWhiteSpace(contentType))
            {
                throw new ArgumentNullException("contentType");
            }
            Headers.ContentType = new MediaTypeHeaderValue(contentType);
        }

        public HttpContent InnerContent { get; set; }

        public Action<bool> DisposeCallback { get; set; }
        public TryComputeLengthDelegate TryComputeLengthCallback { get; set; }
        public Action<Stream, TransportContext> SerializeToStreamCallback { get; set; }
        public Func<Stream, TransportContext, Task> SerializeToStreamAsyncCallback { get; set; }

        protected override void Dispose(bool disposing)
        {
            if (DisposeCallback != null)
            {
                DisposeCallback(disposing);
            }

            base.Dispose(disposing);
        }

        protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
        {
            if (SerializeToStreamAsyncCallback != null)
            {
                return SerializeToStreamAsyncCallback(stream, context);
            }
            else if (InnerContent != null)
            {
                return InnerContent.CopyToAsync(stream, context);
            }
            else
            {
                throw new InvalidOperationException("Construct with inner HttpContent or set SerializeToStreamCallback first.");
            }
        }

        protected override bool TryComputeLength(out long length)
        {
            if (TryComputeLengthCallback != null)
            {
                return TryComputeLengthCallback(out length);
            }

            if (InnerContent != null)
            {
                long? len = InnerContent.Headers.ContentLength;
                length = len.HasValue ? len.Value : 0L;
                return len.HasValue;
            }

            length = 0L;
            return false;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockMediaTypeFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using System.Text;

namespace System.Net.Http.Formatting.Mocks
{
    public class MockMediaTypeFormatter : MediaTypeFormatter
    {
        private bool _canWriteAnyTypes = true;
        public bool CallBase { get; set; }
        public Func<Type, bool> CanReadTypeCallback { get; set; }
        public Func<Type, bool> CanWriteTypeCallback { get; set; }

        internal override bool CanWriteAnyTypes
        {
            get { return _canWriteAnyTypes; }
        }

        public bool CanWriteAnyTypesReturn
        {
            get { return _canWriteAnyTypes; }
            set { _canWriteAnyTypes = value; }
        }

        public override bool CanReadType(Type type)
        {
            if (!CallBase && CanReadTypeCallback == null)
            {
                throw new InvalidOperationException("CallBase or CanReadTypeCallback must be set first.");
            }

            return CanReadTypeCallback != null ? CanReadTypeCallback(type) : true;
        }

        public override bool CanWriteType(Type type)
        {
            if (!CallBase && CanWriteTypeCallback == null)
            {
                throw new InvalidOperationException("CallBase or CanWriteTypeCallback must be set first.");
            }

            return CanWriteTypeCallback != null ? CanWriteTypeCallback(type) : true;
        }

        public new Encoding SelectCharacterEncoding(HttpContentHeaders contentHeaders)
        {
            return base.SelectCharacterEncoding(contentHeaders);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockMediaTypeMapping.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
namespace System.Net.Http.Formatting.Mocks
{
    public class MockMediaTypeMapping : MediaTypeMapping
    {
        public MockMediaTypeMapping(string mediaType, double matchQuality)
            : base(mediaType)
        {
            MatchQuality = matchQuality;
        }

        public MockMediaTypeMapping(MediaTypeHeaderValue mediaType, double matchQuality)
            : base(mediaType)
        {
            MatchQuality = matchQuality;
        }

        public double MatchQuality { get; private set; }

        public HttpRequestMessage Request { get; private set; }

        public bool WasInvoked { get; private set; }

        public override double TryMatchMediaType(HttpRequestMessage request)
        {
            WasInvoked = true;
            Request = request;
            return MatchQuality;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockNonClosingDelegatingStream.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Internal;

namespace System.Net.Http.Mocks
{
    internal class MockNonClosingDelegatingStream : NonClosingDelegatingStream
    {
        public MockNonClosingDelegatingStream(Stream innerStream)
            : base(innerStream)
        {
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/MockProgressEventHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Net.Http.Handlers
{
    public class MockProgressEventHandler
    {
        public bool WasInvoked { get; private set; }

        public object Sender { get; private set; }

        public HttpProgressEventArgs EventArgs { get; private set; }

        public void Handler(object sender, HttpProgressEventArgs eventArgs)
        {
            WasInvoked = true;
            Sender = sender;
            EventArgs = eventArgs;
        }

        public static ProgressMessageHandler CreateProgressMessageHandler(out MockProgressEventHandler progressEventHandler, bool sendProgress)
        {
            ProgressMessageHandler progressHandler = new ProgressMessageHandler();
            progressEventHandler = new MockProgressEventHandler();
            if (sendProgress)
            {
                progressHandler.HttpSendProgress += progressEventHandler.Handler;
            }
            else
            {
                progressHandler.HttpReceiveProgress += progressEventHandler.Handler;
            }
            return progressHandler;
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/Mocks/TestableHttpMessageHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;

namespace System.Net.Http.Mocks
{
    public class TestableHttpMessageHandler : HttpMessageHandler
    {
        public virtual Task<HttpResponseMessage> SendAsyncPublic(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            throw new NotImplementedException();
        }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            return SendAsyncPublic(request, cancellationToken);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartFileDataTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class MultipartFileDataTest
    {
        [Fact]
        public void Constructor_ThrowsOnNullHeaders()
        {
            Assert.ThrowsArgumentNull(() => new MultipartFileData(null, "file"), "headers");
        }

        [Fact]
        public void Constructor_ThrowsOnNullLocalFileName()
        {
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();
            Assert.ThrowsArgumentNull(() => new MultipartFileData(headers, null), "localFileName");
        }

        [Fact]
        public void Constructor_InitializesCorrectly()
        {
            // Arrange
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();
            string fileName = "filename";

            // Act
            MultipartFileData fileData = new MultipartFileData(headers, fileName);


            Assert.Same(headers, fileData.Headers);
            Assert.Same(fileName, fileData.LocalFileName);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartFileStreamProviderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Net.Http.Internal;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class MockMultipartFileStreamProvider : MultipartFileStreamProvider
    {
        public MockMultipartFileStreamProvider()
            : base(Path.GetTempPath())
        {
        }

        public MockMultipartFileStreamProvider(string rootPath)
            : base(rootPath)
        {
        }

        public MockMultipartFileStreamProvider(string rootPath, int bufferSize)
            : base(rootPath, bufferSize)
        {
        }
    }

    public class MultipartFileStreamProviderTests : MultipartStreamProviderTestBase<MockMultipartFileStreamProvider>
    {
        private const int MinBufferSize = 1;
        private const int ValidBufferSize = 0x111;
        private const string ValidPath = @"c:\some\path";

#if !NETCOREAPP // .NET Core does not enforce path validity in many APIs.
        public static TheoryDataSet<string> NotSupportedFilePaths
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "cc:\\a\\b",
                    "123:\\a\\b",
                    "c d:\\a\\b",
                };
            }
        }
#endif

        public static TheoryDataSet<string> InvalidFilePaths
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "",
                    " ",
                    "  ",
#if !NETCOREAPP // .NET Core does not enforce path validity in many APIs.
                    "\t\t \n ",
                    "c:\\a<b",
                    "c:\\a>b",
                    "c:\\a\"b",
                    "c:\\a\tb",
                    "c:\\a|b",
                    "c:\\a\bb",
#endif
                    "c:\\a\0b",
                    "c :\\a\0b",
                };
            }
        }

        [Fact]
        public void Constructor_ThrowsOnNullRootPath()
        {
            Assert.ThrowsArgumentNull(() => { new MultipartFileStreamProvider(null); }, "rootPath");
        }

#if !NETCOREAPP // .NET Core does not enforce path validity in many APIs.
        [Theory]
        [PropertyData("NotSupportedFilePaths")]
        public void Constructor_ThrowsOnNotSupportedRootPath(string notSupportedPath)
        {
            Assert.Throws<NotSupportedException>(() => new MultipartFileStreamProvider(notSupportedPath, ValidBufferSize));
        }
#endif

        [Theory]
        [PropertyData("InvalidFilePaths")]
        public void Constructor_ThrowsOnInvalidRootPath(string invalidPath)
        {
            Assert.ThrowsArgument(() => new MultipartFileStreamProvider(invalidPath, ValidBufferSize), null);
        }

        [Fact]
        public void Constructor_InvalidBufferSize()
        {
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => new MultipartFileStreamProvider(ValidPath, MinBufferSize - 1),
                "bufferSize", MinBufferSize.ToString(), MinBufferSize - 1);
        }

        [Fact]
        public void FileData_IsEmpty()
        {
            MultipartFileStreamProvider provider = new MultipartFileStreamProvider(ValidPath, ValidBufferSize);
            Assert.Empty(provider.FileData);
        }

        [Fact]
        public void GetStream()
        {
            Stream stream0 = null;
            Stream stream1 = null;

            try
            {
                string tempPath = Path.GetTempPath();
                MultipartFormDataContent content = new MultipartFormDataContent();
                content.Add(new StringContent("Content 1"), "NoFile");
                content.Add(new StringContent("Content 2"), "File", "Filename");

                MultipartFileStreamProvider provider = new MultipartFileStreamProvider(tempPath);
                stream0 = provider.GetStream(content, content.ElementAt(0).Headers);
                stream1 = provider.GetStream(content, content.ElementAt(1).Headers);

                Assert.IsType<FileStream>(stream0);
                Assert.IsType<FileStream>(stream1);

                Assert.Equal(2, provider.FileData.Count);
                string partialFileName = String.Format("{0}BodyPart_", tempPath);
                Assert.Contains(partialFileName, provider.FileData[0].LocalFileName);
                Assert.Contains(partialFileName, provider.FileData[1].LocalFileName);

                Assert.Same(content.ElementAt(0).Headers.ContentDisposition, provider.FileData[0].Headers.ContentDisposition);
                Assert.Same(content.ElementAt(1).Headers.ContentDisposition, provider.FileData[1].Headers.ContentDisposition);
            }
            finally
            {
                if (stream0 != null)
                {
                    stream0.Close();
                }

                if (stream1 != null)
                {
                    stream1.Close();
                }
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartFormDataRemoteStreamProviderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class MultipartFormDataRemoteStreamProviderTests :
        MultipartStreamProviderTestBase<CustomMultipartFormDataRemoteStreamProvider>
    {
        [Fact]
        public void FileData_IsEmpty()
        {
            CustomMultipartFormDataRemoteStreamProvider provider = new CustomMultipartFormDataRemoteStreamProvider();
            Assert.Empty(provider.FileData);
        }

        [Fact]
        public void FormData_IsEmpty()
        {
            CustomMultipartFormDataRemoteStreamProvider provider = new CustomMultipartFormDataRemoteStreamProvider();
            Assert.Empty(provider.FormData);
        }

        [Fact]
        public void GetStream_ThrowsOnNoContentDisposition()
        {
            // Arrange
            CustomMultipartFormDataRemoteStreamProvider provider = new CustomMultipartFormDataRemoteStreamProvider();
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => { provider.GetStream(content, headers); });
        }

        [Fact]
        public void GetStream()
        {
            // Arrange
            Stream stream0 = null;
            Stream stream1 = null;

            try
            {
                MultipartFormDataContent content = new MultipartFormDataContent();
                content.Add(new StringContent("Content 1"), "NoFile");
                content.Add(new StringContent("Content 2"), "File", "Filename");

                CustomMultipartFormDataRemoteStreamProvider provider =
                    new CustomMultipartFormDataRemoteStreamProvider();

                // Act
                stream0 = provider.GetStream(content, content.ElementAt(0).Headers);
                stream1 = provider.GetStream(content, content.ElementAt(1).Headers);

                // Assert
                Assert.IsType<MemoryStream>(stream0);
                Assert.Single(provider.RemoteStreams, stream1);

                MultipartRemoteFileData fileData = Assert.Single(provider.FileData);
                string expectedUrl = provider.UrlBase + "Filename";
                Assert.Equal(expectedUrl, fileData.Location);

                Assert.Same(content.ElementAt(1).Headers.ContentDisposition,
                    fileData.Headers.ContentDisposition);
            }
            finally
            {
                if (stream0 != null)
                {
                    stream0.Close();
                }

                if (stream1 != null)
                {
                    stream1.Close();
                }
            }
        }

        [Fact]
        [ReplaceCulture]
        public void GetStream_StreamResultNullThrowsException()
        {
            // Arrange
            MultipartFormDataContent content = new MultipartFormDataContent();
            content.Add(new StringContent("Content"), "File", "Filename");
            CustomMultipartFormDataRemoteStreamProvider provider =
                new CustomMultipartFormDataRemoteStreamProvider(isResultNull: true);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => provider.GetStream(content, content.ElementAt(0).Headers),
                "The 'GetRemoteStream' method in 'CustomMultipartFormDataRemoteStreamProvider' returned null. " +
                "It must return a RemoteStreamResult instance containing a writable stream and a valid URL."
                );
        }

        [Fact]
        public async Task PostProcessing_ProcessesFormData()
        {
            // Arrange
            int maxContents = 16;
            string contentFormat = "Content {0}";
            string formNameFormat = "FormName_{0}";
            string fileNameFormat = "FileName_{0}";

            MultipartFormDataContent multipartContent = new MultipartFormDataContent();

            // Create half contents for form data and the other half for file data.
            for (int index = 0; index < maxContents; index++)
            {
                string content = String.Format(contentFormat, index);
                string formName = String.Format(formNameFormat, index);
                if (index < maxContents/2)
                {
                    multipartContent.Add(new StringContent(content), formName);
                }
                else
                {
                    string fileName = String.Format(fileNameFormat, index);
                    multipartContent.Add(new StringContent(content), formName, fileName);
                }
            }

            CustomMultipartFormDataRemoteStreamProvider provider =
                new CustomMultipartFormDataRemoteStreamProvider();
            foreach (HttpContent content in multipartContent)
            {
                provider.Contents.Add(content);
                using (provider.GetStream(multipartContent, content.Headers))
                {
                }
            }

            // Act
            await provider.ExecutePostProcessingAsync();

            // Assert
            Assert.Equal(maxContents/2, provider.FormData.Count);

            // half contents for form data
            for (int index = 0; index < maxContents/2; index++)
            {
                string content = String.Format(contentFormat, index);
                string formName = String.Format(formNameFormat, index);
                Assert.Equal(content, provider.FormData[formName]);
            }

            // the other half for file data
            HttpContent[] contents = multipartContent.ToArray();
            for (int index = maxContents/2; index < maxContents; index++)
            {
                int fileDataIndex = index - (maxContents/2);
                string fileName = String.Format(fileNameFormat, index);
                string url = provider.UrlBase + fileName;
                Assert.Equal(url, provider.FileData[fileDataIndex].Location);
                Assert.Same(contents[index].Headers, provider.FileData[fileDataIndex].Headers);
            }
        }

        [Fact]
        public async Task ExecutePostProcessingAsyncWithoutCancellationToken_GetCalledBy_ReadAsMultipartAsync()
        {
            // Arrange
            MultipartFormDataContent multipartContent = new MultipartFormDataContent();
            Mock<CustomMultipartFormDataRemoteStreamProvider> mockProvider =
                new Mock<CustomMultipartFormDataRemoteStreamProvider>();
            mockProvider.CallBase = true;

            // Act
            await multipartContent.ReadAsMultipartAsync(mockProvider.Object);

            // Assert
            mockProvider.Verify(p => p.ExecutePostProcessingAsync(), Times.Once());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartFormDataStreamProviderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class MockMultipartFormDataStreamProvider : MultipartFormDataStreamProvider
    {
        public MockMultipartFormDataStreamProvider()
            : base(Path.GetTempPath())
        {
        }

        public MockMultipartFormDataStreamProvider(string rootPath)
            : base(rootPath)
        {
        }

        public MockMultipartFormDataStreamProvider(string rootPath, int bufferSize)
            : base(rootPath, bufferSize)
        {
        }
    }

    public class MultipartFormDataStreamProviderTests : MultipartStreamProviderTestBase<MockMultipartFormDataStreamProvider>
    {
        private const int ValidBufferSize = 0x111;
        private const string ValidPath = @"c:\some\path";

        [Fact]
        public void FormData_IsEmpty()
        {
            MultipartFormDataStreamProvider provider = new MultipartFormDataStreamProvider(ValidPath, ValidBufferSize);
            Assert.Empty(provider.FormData);
        }

        [Fact]
        public void GetStream_ThrowsOnNoContentDisposition()
        {
            MultipartFormDataStreamProvider provider = new MultipartFormDataStreamProvider(ValidPath);
            HttpContent content = new StringContent(String.Empty);
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();

            Assert.Throws<InvalidOperationException>(() => { provider.GetStream(content, headers); });
        }

        [Fact]
        public void GetStream()
        {
            Stream stream0 = null;
            Stream stream1 = null;

            try
            {
                string tempPath = Path.GetTempPath();
                MultipartFormDataContent content = new MultipartFormDataContent();
                content.Add(new StringContent("Content 1"), "NoFile");
                content.Add(new StringContent("Content 2"), "File", "Filename");

                MultipartFormDataStreamProvider provider = new MultipartFormDataStreamProvider(tempPath);
                stream0 = provider.GetStream(content, content.ElementAt(0).Headers);
                stream1 = provider.GetStream(content, content.ElementAt(1).Headers);

                Assert.IsType<MemoryStream>(stream0);
                Assert.IsType<FileStream>(stream1);

                MultipartFileData fileData = Assert.Single(provider.FileData);
                string partialFileName = String.Format("{0}BodyPart_", tempPath);
                Assert.Contains(partialFileName, fileData.LocalFileName);

                Assert.Same(content.ElementAt(1).Headers.ContentDisposition, fileData.Headers.ContentDisposition);
            }
            finally
            {
                if (stream0 != null)
                {
                    stream0.Close();
                }

                if (stream1 != null)
                {
                    stream1.Close();
                }
            }
        }

        [Fact]
        public async Task PostProcessing_ProcessesFormData()
        {
            // Arrange
            int maxContents = 16;
            string contentFormat = "Content {0}";
            string formNameFormat = "FormName_{0}";

            MultipartFormDataContent multipartContent = new MultipartFormDataContent();

            for (int index = 0; index < maxContents; index++)
            {
                string content = String.Format(contentFormat, index);
                string formName = String.Format(formNameFormat, index);
                multipartContent.Add(new StringContent(content), formName);
            }

            MultipartFormDataStreamProvider provider = new MultipartFormDataStreamProvider(ValidPath);
            foreach (HttpContent content in multipartContent)
            {
                provider.Contents.Add(content);
                provider.GetStream(multipartContent, content.Headers);
            }

            // Act
            await provider.ExecutePostProcessingAsync();

            // Assert
            Assert.Equal(maxContents, provider.FormData.Count);

            for (int index = 0; index < maxContents; index++)
            {
                string content = String.Format(contentFormat, index);
                string formName = String.Format(formNameFormat, index);
                Assert.Equal(content, provider.FormData[formName]);
            }
        }

        [Fact]
        public async Task PostProcessing_ProcessesFormData_WithCustomMultipartFormDataStreamProvider()
        {
            // Arrange
            string tempPath = Path.GetTempPath();
            int maxContents = 16;
            string contentFormat = "Content {0}";
            string formNameFormat = "FormName_{0}";
            string fileNameFormat = "FileName_{0}";

            MultipartFormDataContent multipartContent = new MultipartFormDataContent();

            // Create half contents for form data and the other half for file data.
            for (int index = 0; index < maxContents; index++)
            {
                string content = String.Format(contentFormat, index);
                string formName = String.Format(formNameFormat, index);
                if (index < maxContents/2)
                {
                    multipartContent.Add(new StringContent(content), formName);
                }
                else
                {
                    string fileName = String.Format(fileNameFormat, index);
                    multipartContent.Add(new StringContent(content), formName, fileName);
                }
            }

            CustomMultipartFormDataStreamProvider provider =
                new CustomMultipartFormDataStreamProvider(tempPath);
            foreach (HttpContent content in multipartContent)
            {
                provider.Contents.Add(content);
                using (provider.GetStream(multipartContent, content.Headers)) { }
            }

            // Act
            await provider.ExecutePostProcessingAsync();

            // Assert
            Assert.Equal(maxContents / 2, provider.FormData.Count);

            // half contents for form data
            for (int index = 0; index < maxContents / 2; index++)
            {
                string content = String.Format(contentFormat, index);
                string formName = String.Format(formNameFormat, index);
                Assert.Equal(content, provider.FormData[formName]);
            }

            // the other half for file data
            HttpContent[] contents = multipartContent.ToArray();
            for (int index = maxContents / 2; index < maxContents; index++)
            {
                int fileDataIndex = index - (maxContents / 2);
                string fileName = String.Format(fileNameFormat, index);
                Assert.Equal(fileName, provider.FileData[fileDataIndex].LocalFileName);
                Assert.Same(contents[index].Headers, provider.FileData[fileDataIndex].Headers);
            }
        }

        [Fact]
        public async Task ExecutePostProcessingAsyncWithoutCancellationToken_GetCalledBy_ReadAsMultipartAsync()
        {
            // Arrange
            MultipartFormDataContent multipartContent = new MultipartFormDataContent();
            Mock<MultipartFormDataStreamProvider> mockProvider = new Mock<MultipartFormDataStreamProvider>(ValidPath);
            mockProvider.CallBase = true;

            // Act
            var provider = await multipartContent.ReadAsMultipartAsync(mockProvider.Object);

            // Assert
            mockProvider.Verify(p => p.ExecutePostProcessingAsync(), Times.Once());
        }

        private class CustomMultipartFormDataStreamProvider : MultipartFormDataStreamProvider
        {
            public CustomMultipartFormDataStreamProvider(string rootPath)
                : base(rootPath)
            {
            }

            public CustomMultipartFormDataStreamProvider(string rootPath, int bufferSize)
                : base(rootPath, bufferSize)
            {
            }

            public override Stream GetStream(HttpContent parent, HttpContentHeaders headers)
            {
                Stream stream = null;
                ContentDispositionHeaderValue contentDisposition = headers.ContentDisposition;
                if (contentDisposition != null)
                {
                    if (!String.IsNullOrEmpty(contentDisposition.FileName))
                    {
                        FileData.Add(new MultipartFileData(headers, contentDisposition.FileName));
                        // Can be replaced with any stream the user want. e.g. Azure Blob Storage Stream.
                        stream = new MemoryStream();
                    }
                    else
                    {
                        stream = base.GetStream(parent, headers);
                    }
                }

                return stream;
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartMemoryStreamProviderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class MultipartMemoryStreamProviderTests : MultipartStreamProviderTestBase<MultipartMemoryStreamProvider>
    {
        [Fact]
        public void GetStream_ReturnsNewMemoryStream()
        {
            // Arrange
            MultipartMemoryStreamProvider instance = new MultipartMemoryStreamProvider();
            HttpContent parent = new StringContent(String.Empty);
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();

            // Act
            Stream stream1 = instance.GetStream(parent, headers);
            Stream stream2 = instance.GetStream(parent, headers);

            // Assert
            Assert.IsType<MemoryStream>(stream1);
            Assert.Equal(0, stream1.Length);
            Assert.Equal(0, stream1.Position);

            Assert.IsType<MemoryStream>(stream2);
            Assert.Equal(0, stream2.Length);
            Assert.Equal(0, stream2.Position);

            Assert.NotSame(stream1, stream2);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartRelatedStreamProviderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class MultipartRelatedStreamProviderTests : MultipartStreamProviderTestBase<MultipartRelatedStreamProvider>
    {
        private const string ContentID = "12345";
        private const string Boundary = "-A-";

        private const string DefaultRootContent = "Default root content";
        private const string ContentIDRootContent = "Content with matching Content-ID";
        private const string OtherContent = "Other Content";

        public static TheoryDataSet<string> MultipartRelatedWithStartParameter
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    { String.Format("multipart/related; boundary={0}; start=\"{1}\"", Boundary, ContentID) },
                    { String.Format("multipart/related; start={0}; boundary={1}", ContentID, Boundary) },
                };
            }
        }

        public static TheoryDataSet<string> MultipartWithMissingOrInvalidStartParameter
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    { String.Format("multipart/form-data; start=\"{0}\"; boundary={1}", ContentID, Boundary) },
                    { String.Format("multipart/form-data; start={0}; boundary={1}", ContentID, Boundary) },
                    { String.Format("multipart/form-data; boundary={0}", Boundary) },
                    { String.Format("multipart/related; boundary={0}", Boundary) },
                    { String.Format("multipart/mixed; start={0}; boundary={1}", ContentID, Boundary) },
                    { String.Format("multipart/mixed; boundary={1}", ContentID, Boundary) },
                };
            }
        }

        [Fact]
        public void RootContent_ReturnsNull()
        {
            MultipartRelatedStreamProvider provider = new MultipartRelatedStreamProvider();
            Assert.Null(provider.RootContent);
        }

        [Theory]
        [PropertyData("MultipartRelatedWithStartParameter")]
        public async Task RootContent_ReturnsNullIfContentIDIsNotMatched(string mediaType)
        {
            // Arrange
            MultipartContent content = new MultipartContent("related", Boundary);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);

            content.Add(new StringContent(DefaultRootContent));
            content.Add(new StringContent(OtherContent));

            HttpContent expectedRootContent = new StringContent(ContentIDRootContent);
            expectedRootContent.Headers.Add("Content-ID", "NoMatch");
            content.Add(expectedRootContent);

            MultipartRelatedStreamProvider provider = await content.ReadAsMultipartAsync(new MultipartRelatedStreamProvider());

            // Act
            HttpContent actualRootContent = provider.RootContent;

            // Assert
            Assert.Null(actualRootContent);
        }

        [Theory]
        [PropertyData("MultipartRelatedWithStartParameter")]
        public async Task RootContent_PicksContent_WithStartParameter(string mediaType)
        {
            var result = await RootContent_PicksContent_Setup(mediaType);
            Assert.Equal(ContentIDRootContent, result);
        }

        [Theory]
        [PropertyData("MultipartWithMissingOrInvalidStartParameter")]
        public async Task RootContent_PicksContent_WithoutStartParameter(string mediaType)
        {
            var result = await RootContent_PicksContent_Setup(mediaType);
            Assert.Equal(DefaultRootContent, result);
        }

        private async Task<string> RootContent_PicksContent_Setup(string mediaType)
        {
            // Arrange
            MultipartContent content = new MultipartContent("related", Boundary);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse(mediaType);

            content.Add(new StringContent(DefaultRootContent));
            content.Add(new StringContent(OtherContent));

            HttpContent contentIDContent = new StringContent(ContentIDRootContent);
            contentIDContent.Headers.Add("Content-ID", ContentID);
            content.Add(contentIDContent);

            MultipartRelatedStreamProvider provider = await content.ReadAsMultipartAsync(new MultipartRelatedStreamProvider());

            // Act
            HttpContent actualRootContent = provider.RootContent;
            return await actualRootContent.ReadAsStringAsync();
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartRemoteFileDataTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class MultipartRemoteFileDataTests
    {
        [Fact]
        public void Constructor_ThrowsOnNullHeaders()
        {
            // Arrange, Act & Assert
            Assert.ThrowsArgumentNull(
                () => new MultipartRemoteFileData(null, "http://some/path/to", "Name"),
                "headers");
        }

        [Fact]
        public void Constructor_ThrowsOnNullLocation()
        {
            // Arrange
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();
            
            // Act and Assert
            Assert.ThrowsArgumentNull(() => new MultipartRemoteFileData(headers, null, "Name"), "location");
        }

        [Fact]
        public void Constructor_ThrowsOnNullFileName()
        {
            // Arrange
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();

            // Act and Assert
            Assert.ThrowsArgumentNull(() => new MultipartRemoteFileData(headers, "http://some/path/to", null),
                "fileName");
        }

        [Fact]
        public void Constructor_InitializesCorrectly()
        {
            // Arrange
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();
            string remoteFileURL = "http://some/path/to";
            string fileName = "Name";

            // Act
            MultipartRemoteFileData fileData = new MultipartRemoteFileData(headers, remoteFileURL, fileName);

            // Assert
            Assert.Same(headers, fileData.Headers);
            Assert.Same(remoteFileURL, fileData.Location);
            Assert.Same(fileName, fileData.FileName);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/MultipartStreamProviderTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public abstract class MultipartStreamProviderTestBase<TProvider> where TProvider : MultipartStreamProvider, new()
    {
        protected MultipartStreamProviderTestBase()
        {
        }

        [Fact]
        public void Contents_IsEmpty()
        {
            // Arrange
            TProvider provider = new TProvider();

            // Act
            Collection<HttpContent> contents = provider.Contents;

            // Assert
            Assert.Empty(contents);
        }

        [Fact]
        public void PostProcessing_ReturnsCompleteTask()
        {
            // Arrange
            TProvider provider = new TProvider();

            // Act
            Task postProcessing = provider.ExecutePostProcessingAsync();

            // Assert
            Assert.Equal(TaskStatus.RanToCompletion, postProcessing.Status);
        }

        [Fact]
        public void GetStream_ThrowsOnNullParent()
        {
            TProvider provider = new TProvider();
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();

            Assert.ThrowsArgumentNull(() => provider.GetStream(null, headers), "parent");
        }

        [Fact]
        public void GetStream_ThrowsOnNullHeaders()
        {
            TProvider provider = new TProvider();
            StringContent content = new StringContent(String.Empty);

            Assert.ThrowsArgumentNull(() => provider.GetStream(content, null), "headers");
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/ObjectContentOfTTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class ObjectContentOfTTests
    {
        private MediaTypeHeaderValue _jsonHeaderValue = new MediaTypeHeaderValue("application/json");

        [Fact]
        public void Constructor_WhenFormatterParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => new ObjectContent<string>("", formatter: null), "formatter");
            Assert.ThrowsArgumentNull(() => new ObjectContent<string>("", formatter: null, mediaType: "foo/bar"), "formatter");
            Assert.ThrowsArgumentNull(() => new ObjectContent<string>("", formatter: null, mediaType: _jsonHeaderValue), "formatter");
        }

        [Fact]
        public void Constructor_SetsFormatterProperty()
        {
            var formatterMock = new Mock<MediaTypeFormatter>();
            formatterMock.Setup(f => f.CanWriteType(typeof(String))).Returns(true);
            var formatter = formatterMock.Object;

            var content = new ObjectContent<string>(null, formatter, mediaType: (MediaTypeHeaderValue)null);

            Assert.Same(formatter, content.Formatter);
        }

        [Fact]
        public void Constructor_CallsFormattersGetDefaultContentHeadersMethod()
        {
            var formatterMock = new Mock<MediaTypeFormatter>();
            formatterMock.Setup(f => f.CanWriteType(typeof(String))).Returns(true);

            var content = new ObjectContent(typeof(string), "", formatterMock.Object, _jsonHeaderValue);

            formatterMock.Verify(f => f.SetDefaultContentHeaders(typeof(string), content.Headers, _jsonHeaderValue),
                                 Times.Once());
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/ObjectContentTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class ObjectContentTests
    {
        private readonly object _value = new object();
        private readonly MediaTypeFormatter _formatter = new TestableMediaTypeFormatter();
        private readonly MediaTypeHeaderValue _jsonHeaderValue = new MediaTypeHeaderValue("application/json");

        [Fact]
        public void Constructor_WhenTypeArgumentIsNull_ThrowsEsxception()
        {
            Assert.ThrowsArgumentNull(() => new ObjectContent(null, _value, _formatter), "type");
            Assert.ThrowsArgumentNull(() => new ObjectContent(null, _value, _formatter, mediaType: "foo/bar"), "type");
            Assert.ThrowsArgumentNull(() => new ObjectContent(null, _value, _formatter, mediaType: _jsonHeaderValue), "type");
        }

        [Fact]
        public void Constructor_WhenFormatterArgumentIsNull_ThrowsEsxception()
        {
            Assert.ThrowsArgumentNull(() => new ObjectContent(typeof(Object), _value, formatter: null), "formatter");
            Assert.ThrowsArgumentNull(() => new ObjectContent(typeof(Object), _value, formatter: null, mediaType: "foo/bar"), "formatter");
            Assert.ThrowsArgumentNull(() => new ObjectContent(typeof(Object), _value, formatter: null, mediaType: _jsonHeaderValue), "formatter");
        }

        [Fact]
        public void Constructor_WhenValueIsNullAndTypeIsNotCompatible_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() =>
            {
                new ObjectContent(typeof(int), null, new JsonMediaTypeFormatter());
            }, "The 'ObjectContent' type cannot accept a null value for the value type 'Int32'.");
        }

        [Fact]
        public void Constructor_WhenValueIsNotNullButTypeDoesNotMatch_ThrowsException()
        {
            Assert.ThrowsArgument(() =>
            {
                new ObjectContent(typeof(IList<string>), new Dictionary<string, string>(), new JsonMediaTypeFormatter());
            }, "value", "An object of type 'Dictionary`2' cannot be used with a type parameter of 'IList`1'.");
        }

        [Fact]
        public void Constructor_WhenValueIsNotSupportedByFormatter_ThrowsException()
        {
            Mock<MediaTypeFormatter> formatterMock = new Mock<MediaTypeFormatter>();
            formatterMock.Setup(f => f.CanWriteType(typeof(List<string>))).Returns(false).Verifiable();

            Assert.Throws<InvalidOperationException>(() =>
            {
                new ObjectContent(typeof(List<string>), new List<string>(), formatterMock.Object);
            }, "The configured formatter 'Castle.Proxies.MediaTypeFormatterProxy' cannot write an object of type 'List`1'.");

            formatterMock.Verify();
        }

        [Fact]
        public void Constructor_SetsFormatterProperty()
        {
            var content = new ObjectContent(typeof(object), _value, _formatter, mediaType: (MediaTypeHeaderValue)null);

            Assert.Same(_formatter, content.Formatter);
        }

        [Fact]
        public void Constructor_CallsFormattersGetDefaultContentHeadersMethod()
        {
            var formatterMock = new Mock<MediaTypeFormatter>();
            formatterMock.Setup(f => f.CanWriteType(typeof(String))).Returns(true);

            var content = new ObjectContent(typeof(string), "", formatterMock.Object, _jsonHeaderValue);

            formatterMock.Verify(f => f.SetDefaultContentHeaders(typeof(string), content.Headers, _jsonHeaderValue),
                                 Times.Once());
        }

        [Theory]
        [PropertyData("ValidValueTypePairs")]
        public void Constructor_WhenValueAndTypeAreCompatible_SetsValue(Type type, object value)
        {
            var oc = new ObjectContent(type, value, new JsonMediaTypeFormatter());

            Assert.Same(value, oc.Value);
            Assert.Equal(type, oc.ObjectType);
        }

        [Fact]
        public void Constructor_WhenTypeIsNotSupportedByFormatter_ThrowsException()
        {
            Mock<MediaTypeFormatter> formatterMock = new Mock<MediaTypeFormatter>();
            formatterMock.Setup(f => f.CanWriteType(typeof(string))).Returns(true);
            formatterMock.Setup(f => f.CanWriteType(typeof(object))).Returns(false).Verifiable();

            Assert.Throws<InvalidOperationException>(() =>
            {
                var content = new ObjectContent(typeof(object), "", formatterMock.Object);
            }, "The configured formatter 'Castle.Proxies.MediaTypeFormatterProxy' cannot write an object of type 'Object'.");

            formatterMock.Verify();
        }

        public static TheoryDataSet<Type, object> ValidValueTypePairs
        {
            get
            {
                return new TheoryDataSet<Type, object>
                {
                    { typeof(Nullable<int>), null },
                    { typeof(string), null },
                    { typeof(int), 42 },
                    //{ typeof(int), (short)42 }, TODO should this work?
                    { typeof(object), "abc" },
                    { typeof(string), "abc" },
                    { typeof(IList<string>), new List<string>() },
                };
            }
        }

        [Fact]
        public void SerializeToStreamAsync_CallsUnderlyingFormatter()
        {
            var stream = Stream.Null;
            var context = new Mock<TransportContext>().Object;
            var formatterMock = new Mock<TestableMediaTypeFormatter> { CallBase = true };
            var oc = new TestableObjectContent(typeof(string), "abc", formatterMock.Object);
            var task = new Task(() => { });
            formatterMock.Setup(f => f.WriteToStreamAsync(typeof(string), "abc", stream, oc, context))
                .Returns(task).Verifiable();

            var result = oc.CallSerializeToStreamAsync(stream, context);

            Assert.Same(task, result);
            formatterMock.VerifyAll();
        }

        [Fact]
        public void TryComputeLength_ReturnsFalseAnd0()
        {
            var oc = new TestableObjectContent(typeof(string), null, _formatter);
            long length;

            var result = oc.CallTryComputeLength(out length);

            Assert.False(result);
            Assert.Equal(-1, length);
        }

        public class TestableObjectContent : ObjectContent
        {
            public TestableObjectContent(Type type, object value, MediaTypeFormatter formatter)
                : base(type, value, formatter)
            {
            }

            public bool CallTryComputeLength(out long length)
            {
                return TryComputeLength(out length);
            }

            public Task CallSerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return SerializeToStreamAsync(stream, context);
            }
        }

        public class TestableMediaTypeFormatter : MediaTypeFormatter
        {
            public TestableMediaTypeFormatter()
            {
                SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
            }

            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }

            public override Task WriteToStreamAsync(Type type, object value, Stream stream, HttpContent content, TransportContext transportContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/ParserData.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    internal static class ParserData
    {
        public const int MinHeaderSize = 2;

        public const int MinMessageSize = 10;

        public const int MinRequestLineSize = 14;

        public const int MinStatusLineSize = 15;

        public const int MinBufferSize = 256;

        public static TheoryDataSet<Version> Versions
        {
            get
            {
                return new TheoryDataSet<Version>
                {
                    Version.Parse("1.0"),
                    Version.Parse("1.1"),
                    Version.Parse("1.2"),
                    Version.Parse("2.0"),
                    Version.Parse("10.0"),
                    Version.Parse("1.15"),
                };
            }
        }

        public static TheoryDataSet<string> InvalidVersions
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "",
                    "http/1.1",
                    "HTTP/a.1",
                    "HTTP/1.a",
                    "HTTP 1.1",
                    "HTTP\t1.1",
                    "HTTP 1 1",
                    "\0",
                    "HTTP\01.1",
                    "HTTP/4294967295.4294967295",
                    "æææøøøååå",
                    "HTTP/æææøøøååå",
                    "いくつかのテキスト",
                    "HTTP/いくつかのテキスト",
                };
            }
        }

        public static TheoryDataSet<string> InvalidMethods
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "",
                    "G\tT",
                    "G E T",
                    "\0",
                    "G\0T",
                    "GET\n",
                    "æææøøøååå",
                    "いくつかのテキスト",
                };
            }
        }

        public static TheoryDataSet<string> ValidReasonPhrases
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "",
                    "Ok",
                    "public Server Error",
                    "r e a s o n",
                    "reason ",
                    " reason ",
                };
            }
        }

        public static TheoryDataSet<string> InvalidReasonPhrases
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "\0",
                    "\t",
                    "reason\n",
                    "æææøøøååå",
                    "いくつかのテキスト",
                };
            }
        }

        // This deliberately only checks for syntactic boundaries of the URI, not its content
        public static TheoryDataSet<string> InvalidRequestUris
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "",
                    "p a t h",
                    "path ",
                    " path ",
                    "æææø ø øååå",
                    "いくつか の テキスト"
                };
            }
        }

        public static TheoryDataSet<string> InvalidStatusCodes
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "0",
                    "99",
                    "1a1",
                    "abc",
                    "1001",
                    "2000",
                    Int32.MinValue.ToString(),
                    Int32.MaxValue.ToString(),
                    "æææøøøååå",
                    "いくつかのテキスト"
                };
            }
        }

        public static readonly Dictionary<string, string> ValidHeaders = new Dictionary<string, string>
        {
            { "N0", "V0"},
            { "N1", "V1"},
            { "N2", "V2"},
            { "N3", "V3"},
            { "N4", "V4"},
            { "N5", "V5"},
            { "N6", "V6"},
            { "N7", "V7"},
            { "N8", "V8"},
            { "N9", "V9"},
        };

        public static readonly string HttpMethod = "TEG";
        public static readonly HttpStatusCode HttpStatus = HttpStatusCode.Created;
        public static readonly string HttpReasonPhrase = "ReasonPhrase";
        public static readonly string HttpHostName = "example.com";
        public static readonly int HttpHostPort = 1234;
        public static readonly string HttpMessageEntity = "1234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890";

        public static readonly Uri HttpRequestUri = new Uri("http://" + HttpHostName + "/some/path");
        public static readonly Uri HttpRequestUriWithPortAndQuery = new Uri("http://" + HttpHostName + ":" + HttpHostPort + "/some/path?%C3%A6%C3%B8%C3%A5");
        public static readonly Uri HttpsRequestUri = new Uri("https://" + HttpHostName + "/some/path");

        public static readonly string TextContentType = "text/plain; charset=utf-8";

        public static readonly MediaTypeHeaderValue HttpRequestMediaType = MediaTypeHeaderValue.Parse("application/http; msgtype=request");
        public static readonly MediaTypeHeaderValue HttpResponseMediaType = MediaTypeHeaderValue.Parse("application/http; msgtype=response");

        public static readonly string HttpRequest =
            HttpMethod +
            " /some/path HTTP/1.2\r\nHost: " +
            HttpHostName +
            "\r\nN1: V1a, V1b, V1c, V1d, V1e\r\nN2: V2\r\n\r\n";

        public static readonly string HttpRequestWithHost =
            HttpMethod +
            " /some/path HTTP/1.2\r\n" +
            "N1: V1a, V1b, V1c, V1d, V1e\r\nN2: V2\r\nHost: " +
            HttpHostName + "\r\n\r\n";

        public static readonly string HttpRequestWithPortAndQuery =
            HttpMethod +
            " /some/path?%C3%A6%C3%B8%C3%A5 HTTP/1.2\r\nHost: " +
            HttpHostName + ":" + HttpHostPort.ToString() +
            "\r\nN1: V1a, V1b, V1c, V1d, V1e\r\nN2: V2\r\n\r\n";

        public static readonly string HttpResponse =
            "HTTP/1.2 " +
            ((int)HttpStatus).ToString() +
            " " +
            HttpReasonPhrase +
            "\r\nN1: V1a, V1b, V1c, V1d, V1e\r\nN2: V2\r\nContent-Length: 0\r\n\r\n";

        public static readonly string HttpRequestWithEntity =
            HttpMethod +
            " /some/path HTTP/1.2\r\nHost: " +
            HttpHostName +
            "\r\nN1: V1a, V1b, V1c, V1d, V1e\r\nN2: V2\r\nContent-Type: " +
            TextContentType +
            "\r\nContent-Length: 100" +
            "\r\n\r\n" +
            HttpMessageEntity;

        public static readonly string HttpResponseWithEntity =
            "HTTP/1.2 " +
            ((int)HttpStatus).ToString() +
            " " +
            HttpReasonPhrase +
            "\r\nN1: V1a, V1b, V1c, V1d, V1e\r\nN2: V2\r\nContent-Type: " +
            TextContentType +
            "\r\nContent-Length: 100" +
            "\r\n\r\n" +
            HttpMessageEntity;
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/PushStreamContentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Net.Http
{
    public class PushStreamContentTest
    {
        [Fact]
        public void Constructor_ThrowsOnNullAction()
        {
            Action<Stream, HttpContent, TransportContext> action = null;
            Assert.ThrowsArgumentNull(() => new PushStreamContent(action), "onStreamAvailable");
        }

        [Fact]
        public void Constructor_SetsDefaultMediaType()
        {
            Action<Stream, HttpContent, TransportContext> streamAction = new MockStreamAction().Action;
            PushStreamContent content = new PushStreamContent(streamAction);
            Assert.Equal(MediaTypeConstants.ApplicationOctetStreamMediaType, content.Headers.ContentType);
        }

        [Fact]
        public void Constructor_SetsMediaTypeFromString()
        {
            Action<Stream, HttpContent, TransportContext> streamAction = new MockStreamAction().Action;
            PushStreamContent content = new PushStreamContent(streamAction, "text/xml");
            Assert.Equal(MediaTypeConstants.TextXmlMediaType, content.Headers.ContentType);
        }

        [Fact]
        public void Constructor_SetsMediaType()
        {
            Action<Stream, HttpContent, TransportContext> streamAction = new MockStreamAction().Action;
            PushStreamContent content = new PushStreamContent(streamAction, MediaTypeConstants.TextXmlMediaType);
            Assert.Equal(MediaTypeConstants.TextXmlMediaType, content.Headers.ContentType);
        }

        [Fact]
        public async Task SerializeToStreamAsync_CallsAction()
        {
            // Arrange
            MemoryStream outputStream = new MemoryStream();
            MockStreamAction streamAction = new MockStreamAction(close: true);
            PushStreamContent content = new PushStreamContent((Action<Stream, HttpContent, TransportContext>)streamAction.Action);

            // Act
            await content.CopyToAsync(outputStream);

            // Assert
            Assert.True(streamAction.WasInvoked);
            Assert.Same(content, streamAction.Content);
            Assert.IsType<PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);

            // We don't close the underlying stream
            Assert.True(outputStream.CanRead);
        }

        [Fact]
        public async Task SerializeToStreamAsync_CompletesTaskOnActionException()
        {
            // Arrange
            MemoryStream outputStream = new MemoryStream();
            MockStreamAction streamAction = new MockStreamAction(throwException: true);
            PushStreamContent content = new PushStreamContent((Action<Stream, HttpContent, TransportContext>)streamAction.Action);

            // Act & Assert
            await Assert.ThrowsAsync<ApplicationException>(() => content.CopyToAsync(outputStream));
            Assert.True(streamAction.WasInvoked);
            Assert.IsType<PushStreamContent.CompleteTaskOnCloseStream>(streamAction.OutputStream);
            Assert.True(outputStream.CanRead);
        }

#if Testing_NetStandard1_3
        [Fact]
        public async Task CompleteTaskOnCloseStream_Dispose_CompletesTaskButDoNotDisposeInnerStream()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            TaskCompletionSource<bool> serializeToStreamTask = new TaskCompletionSource<bool>();
            MockCompleteTaskOnCloseStream mockStream = new MockCompleteTaskOnCloseStream(mockInnerStream.Object, serializeToStreamTask);

            // Act
            mockStream.Dispose();

            // Assert
            mockInnerStream.Protected().Verify("Dispose", Times.Never(), exactParameterMatch: true, args: true);
            Assert.Equal(TaskStatus.RanToCompletion, serializeToStreamTask.Task.Status);
            Assert.True(await serializeToStreamTask.Task);
        }
#else
        [Fact]
        public async Task CompleteTaskOnCloseStream_Dispose_CompletesTaskButDoNotCloseInnerStream()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            TaskCompletionSource<bool> serializeToStreamTask = new TaskCompletionSource<bool>();
            MockCompleteTaskOnCloseStream mockStream = new MockCompleteTaskOnCloseStream(mockInnerStream.Object, serializeToStreamTask);

            // Act
            mockStream.Dispose();

            // Assert
            mockInnerStream.Protected().Verify("Dispose", Times.Never(), exactParameterMatch: true, args: true);
            mockInnerStream.Verify(s => s.Close(), Times.Never());
            Assert.Equal(TaskStatus.RanToCompletion, serializeToStreamTask.Task.Status);
            Assert.True(await serializeToStreamTask.Task);
        }

        [Fact]
        public async Task NonClosingDelegatingStream_Close_CompletesTaskButDoNotCloseInnerStream()
        {
            // Arrange
            Mock<Stream> mockInnerStream = new Mock<Stream>() { CallBase = true };
            TaskCompletionSource<bool> serializeToStreamTask = new TaskCompletionSource<bool>();
            MockCompleteTaskOnCloseStream mockStream = new MockCompleteTaskOnCloseStream(mockInnerStream.Object, serializeToStreamTask);

            // Act
            mockStream.Close();

            // Assert
            mockInnerStream.Protected().Verify("Dispose", Times.Never(), exactParameterMatch: true, args: true);
            mockInnerStream.Verify(s => s.Close(), Times.Never());
            Assert.Equal(TaskStatus.RanToCompletion, serializeToStreamTask.Task.Status);
            Assert.True(await serializeToStreamTask.Task);
        }
#endif

        [Fact]
        public async Task PushStreamContentWithAsyncOnStreamAvailableHandler_ExceptionsInOnStreamAvailable_AreCaught()
        {
            // Arrange
            bool faulted = false;
            Exception exception = new ApplicationException();
            PushStreamContent content = new PushStreamContent(async (s, c, tc) =>
            {
                await Task.FromResult(42);
                throw exception;
            });
            MemoryStream stream = new MemoryStream();

            try
            {
                // Act
                await content.CopyToAsync(stream);
            }
            catch (ApplicationException e)
            {
                Assert.Same(exception, e);
                faulted = true;
            }

            // Assert
            Assert.True(faulted);
        }

        [Fact]
        public async Task PushStream_HttpContentIntegrationTest()
        {
            // Arrange
            var expected = "Hello, world!";

            using (var client = new MockHttpClient())
            {
                // We mock the client, so this doesn't actually hit the web. This client will just echo back
                // the body content we give it.
                using (var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost:30000/"))
                {
                    request.Content = new PushStreamContent((stream, content, context) =>
                    {
                        using (var writer = new StreamWriter(stream))
                        {
                            writer.Write(expected);
                        }
                    }, "text/plain");

                    // Act
                    using (var response = await client.SendAsync(request, CancellationToken.None))
                    {
                        // Assert
                        response.EnsureSuccessStatusCode();
                        var responseText = await response.Content.ReadAsStringAsync();
                        Assert.Equal(expected, responseText);
                    }
                }
            }
        }

        private class MockStreamAction
        {
            bool _close;
            bool _throwException;

            public MockStreamAction(bool close = false, bool throwException = false)
            {
                _close = close;
                _throwException = throwException;
            }

            public bool WasInvoked { get; private set; }

            public Stream OutputStream { get; private set; }

            public HttpContent Content { get; private set; }

            public TransportContext TransportContext { get; private set; }

            public void Action(Stream stream, HttpContent content, TransportContext context)
            {
                WasInvoked = true;
                OutputStream = stream;
                Content = content;
                TransportContext = context;

                if (_close)
                {
#if Testing_NetStandard1_3
                    stream.Dispose();
#else
                    stream.Close();
#endif
                }

                if (_throwException)
                {
                    throw new ApplicationException("Action threw exception!");
                }
            }
        }

        internal class MockCompleteTaskOnCloseStream : PushStreamContent.CompleteTaskOnCloseStream
        {
            public MockCompleteTaskOnCloseStream(Stream innerStream, TaskCompletionSource<bool> serializeToStreamTask)
                : base(innerStream, serializeToStreamTask)
            {
            }
        }

        private class MockHttpClient : HttpClient
        {
            public override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, Threading.CancellationToken cancellationToken)
            {
                var stream = new MemoryStream();
                await request.Content.CopyToAsync(stream);
                stream.Position = 0;

                return new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = new StreamContent(stream),
                };
            }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/RemoteStreamInfoTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http.Headers;
using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class RemoteStreamInfoTests
    {
        [Fact]
        public void Constructor_ThrowsOnNullStream()
        {
            // Arrange, Act & Assert
            Assert.ThrowsArgumentNull(
                () => new RemoteStreamInfo(null,  "http://some/path/to", "Name"),
                "remoteStream");
        }

        [Fact]
        public void Constructor_ThrowsOnNullLocation()
        {
            // Arrange
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => new RemoteStreamInfo(new MemoryStream(), null, "Name"), "location");
        }

        [Fact]
        public void Constructor_ThrowsOnNullFileName()
        {
            // Arrange
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => new RemoteStreamInfo(new MemoryStream(), "http://some/path/to", null),
                "fileName");
        }

        [Fact]
        public void Constructor_InitializesCorrectly()
        {
            // Arrange
            HttpContentHeaders headers = FormattingUtilities.CreateEmptyContentHeaders();
            string remoteFileURL = "http://some/path/to";
            string fileName = "Name";
            Stream stream = new MemoryStream();

            // Act
            RemoteStreamInfo fileData = new RemoteStreamInfo(stream, remoteFileURL, fileName);

            // Assert
            Assert.Same(stream, fileData.RemoteStream);
            Assert.Same(remoteFileURL, fileData.Location);
            Assert.Same(fileName, fileData.FileName);
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/System.Net.Http.Formatting.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{7AF77741-9158-4D5F-8782-8F21FADF025F}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Net.Http</RootNamespace>
    <AssemblyName>System.Net.Http.Formatting.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>

  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Buffers, Version=4.0.3.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.Buffers.4.5.1\lib\net461\System.Buffers.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>True</Private>
    </Reference>
    <Reference Include="System.Configuration" />
    <Reference Include="System.Data" />
    <Reference Include="System.IO.Pipelines, Version=4.0.2.4, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.IO.Pipelines.4.7.5\lib\net461\System.IO.Pipelines.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>True</Private>
    </Reference>
    <Reference Include="System.Memory, Version=4.0.1.2, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.Memory.4.5.5\lib\net461\System.Memory.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>True</Private>
    </Reference>
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.CompilerServices.Unsafe, Version=4.0.6.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.Runtime.CompilerServices.Unsafe.4.7.1\lib\net461\System.Runtime.CompilerServices.Unsafe.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>True</Private>
    </Reference>
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Threading.Tasks.Extensions, Version=4.2.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
      <HintPath>..\..\packages\System.Threading.Tasks.Extensions.4.5.4\lib\net461\System.Threading.Tasks.Extensions.dll</HintPath>
      <SpecificVersion>False</SpecificVersion>
      <Private>True</Private>
    </Reference>
    <Reference Include="System.XML" />
    <Reference Include="System.Xml.Linq" />

    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json.Bson, Version=1.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.Bson.1.0.2\lib\net45\Newtonsoft.Json.Bson.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>

    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
      <Visible>False</Visible>
    </CodeAnalysisDependentAssemblyPaths>

    <Compile Include="**\*.cs" Exclude="obj\**\*.cs" />

    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>

    <None Include="packages.config">
      <SubType>Designer</SubType>
    </None>

    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />

    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>

  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets"
      Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')"
        Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')"
        Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')"
        Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
</Project>


================================================
FILE: test/System.Net.Http.Formatting.Test/UriExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Net.Http.Formatting.DataSets;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Net.Http
{
    public class UriExtensionsTests
    {
        private static readonly Uri TestAddress = new Uri("http://www.example.com");
        private static readonly Type TestType = typeof(string);

        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(UriExtensions), TypeAssert.TypeProperties.IsPublicVisibleClass | TypeAssert.TypeProperties.IsStatic);
        }

        [Fact]
        public void ParseQueryStringThrowsWithNull()
        {
            Assert.ThrowsArgumentNull(() => ((Uri)null).ParseQueryString(), "address");
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "UriTestData")]
        public void ParseQueryStringSucceeds(Uri address)
        {
            var result = address.ParseQueryString();
            Assert.NotNull(result);

            bool addressContainsQuery = address.Query.Contains("?");
            if (!addressContainsQuery)
            {
                Assert.Empty(result);
            }
            else
            {
                Assert.True(result.Count > 0, "Uri with query string should return non-empty set.");
            }
        }

        [Fact]
        public void TryReadQueryAsJsonThrowsWithNull()
        {
            JObject value;
            Assert.ThrowsArgumentNull(() => ((Uri)null).TryReadQueryAsJson(out value), "address");
        }

        [Theory]
        [TestDataSet(typeof(HttpTestData), "UriTestData")]
        public void TryReadQueryAsJsonSucceeds(Uri address)
        {
            JObject value;
            Assert.True(address.TryReadQueryAsJson(out value), "Expected 'true' as result");
            Assert.NotNull(value);
            Assert.IsType<JObject>(value);
        }

        [Fact]
        public void TryReadQueryAsThrowsWithNull()
        {
            object value;
            Assert.ThrowsArgumentNull(() => ((Uri)null).TryReadQueryAs(TestType, out value), "address");
            Assert.ThrowsArgumentNull(() => TestAddress.TryReadQueryAs(null, out value), "type");
        }

        [Fact]
        public void TryReadQueryAsSucceeds()
        {
            object value;
            UriBuilder address = new UriBuilder("http://some.host");

            address.Query = "a=2";
            Assert.True(address.Uri.TryReadQueryAs(typeof(SimpleObject1), out value), "Expected 'true' reading valid data");
            SimpleObject1 so1 = (SimpleObject1)value;
            Assert.NotNull(so1);
            Assert.Equal(2, so1.a);

            address.Query = "b=true";
            Assert.True(address.Uri.TryReadQueryAs(typeof(SimpleObject2), out value), "Expected 'true' reading valid data");
            SimpleObject2 so2 = (SimpleObject2)value;
            Assert.NotNull(so2);
            Assert.True(so2.b, "Value should have been true");

            address.Query = "c=hello";
            Assert.True(address.Uri.TryReadQueryAs(typeof(SimpleObject3), out value), "Expected 'true' reading valid data");
            SimpleObject3 so3 = (SimpleObject3)value;
            Assert.NotNull(so3);
            Assert.Equal("hello", so3.c);

            address.Query = "c=";
            Assert.True(address.Uri.TryReadQueryAs(typeof(SimpleObject3), out value), "Expected 'true' reading valid data");
            so3 = (SimpleObject3)value;
            Assert.NotNull(so3);
            Assert.Equal("", so3.c);

            address.Query = "c=null";
            Assert.True(address.Uri.TryReadQueryAs(typeof(SimpleObject3), out value), "Expected 'true' reading valid data");
            so3 = (SimpleObject3)value;
            Assert.NotNull(so3);
            Assert.Equal("null", so3.c);
        }

        [Fact]
        public void TryReadQueryAsTThrowsWithNull()
        {
            object value;
            Assert.ThrowsArgumentNull(() => ((Uri)null).TryReadQueryAs<object>(out value), "address");
        }

        [Fact]
        public void TryReadQueryAsTSucceeds()
        {
            UriBuilder address = new UriBuilder("http://some.host");
            address.Query = "a=2";
            SimpleObject1 so1;
            Assert.True(address.Uri.TryReadQueryAs<SimpleObject1>(out so1), "Expected 'true' reading valid data");
            Assert.NotNull(so1);
            Assert.Equal(2, so1.a);

            address.Query = "b=true";
            SimpleObject2 so2;
            Assert.True(address.Uri.TryReadQueryAs<SimpleObject2>(out so2), "Expected 'true' reading valid data");
            Assert.NotNull(so2);
            Assert.True(so2.b, "Value should have been true");

            address.Query = "c=hello";
            SimpleObject3 so3;
            Assert.True(address.Uri.TryReadQueryAs<SimpleObject3>(out so3), "Expected 'true' reading valid data");
            Assert.NotNull(so3);
            Assert.Equal("hello", so3.c);

            address.Query = "c=";
            Assert.True(address.Uri.TryReadQueryAs<SimpleObject3>(out so3), "Expected 'true' reading valid data");
            Assert.NotNull(so3);
            Assert.Equal("", so3.c);

            address.Query = "c=null";
            Assert.True(address.Uri.TryReadQueryAs<SimpleObject3>(out so3), "Expected 'true' reading valid data");
            Assert.NotNull(so3);
            Assert.Equal("null", so3.c);
        }


        public class SimpleObject1
        {
            public int a { get; set; }
        }

        public class SimpleObject2
        {
            public bool b { get; set; }
        }

        public class SimpleObject3
        {
            public string c { get; set; }
        }
    }
}


================================================
FILE: test/System.Net.Http.Formatting.Test/UriQueryDataSet.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Net.Http
{
    public class UriQueryTestData
    {
        public static TheoryDataSet<string, string, string> UriQueryData
        {
            get
            {
                return new TheoryDataSet<string, string, string>
                {
                    { "=", "", "" },
                    { "N=", "N", "" },
                    { "=N", "", "N" },
                    { "N=V", "N", "V" },
                    { "%26=%26", "&", "&" },
                    { "%3D=%3D", "=", "=" },
                    { "N=A%2BC", "N", "A+C" },
                    { "N=100%25AA%21", "N", "100%AA!"},
                    { "N=%7E%21%40%23%24%25%5E%26%2A%28%29_%2B","N","~!@#$%^&*()_+"},
                    { "N=%601234567890-%3D", "N", "`1234567890-="},
                    { "N=%60%31%32%33%34%35%36%37%38%39%30%2D%3D","N", "`1234567890-="},
                    { "N=%E6%BF%80%E5%85%89%E9%80%99%E5%85%A9%E5%80%8B%E5%AD%97%E6%98%AF%E7%94%9A%E9%BA%BC%E6%84%8F%E6%80%9D", "N", "激光這兩個字是甚麼意思" },
                    { "N=%C3%A6%C3%B8%C3%A5","N","æøå"},
                    { "N=%C3%A6+%C3%B8+%C3%A5","N","æ ø å"},
                };
            }
        }
    }
}

================================================
FILE: test/System.Net.Http.Formatting.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="Newtonsoft.Json.Bson" version="1.0.2" targetFramework="net462" />
  <package id="System.Buffers" version="4.5.1" targetFramework="net462" />
  <package id="System.IO.Pipelines" version="4.7.5" targetFramework="net462" />
  <package id="System.Memory" version="4.5.5" targetFramework="net462" />
  <package id="System.Runtime.CompilerServices.Unsafe" version="4.7.1" targetFramework="net462" />
  <package id="System.Threading.Tasks.Extensions" version="4.5.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Net.Http.Formatting.ns1_3.Test/System.Net.Http.Formatting.ns1_3.Test.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <TargetFrameworks>net462;netcoreapp2.1;net8.0</TargetFrameworks>
    <RootNamespace>System.Net.Http</RootNamespace>
    <OutputPath>..\..\bin\$(Configuration)\Test\ns1_3\</OutputPath>
    <Configurations>$(Configurations);CodeAnalysis</Configurations>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
    <DefineConstants>$(DefineConstants);Testing_NetStandard1_3</DefineConstants>
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>

    <!-- Version 2.4.5 does not support netstandard2.1. -->
    <_VSRunnerVersion Condition=" '$(TargetFramework)' == 'netcoreapp2.1' ">2.4.3</_VSRunnerVersion>
    <_VSRunnerVersion Condition=" '$(TargetFramework)' != 'netcoreapp2.1' ">2.4.5</_VSRunnerVersion>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="System.IO.Pipelines" Version="4.7.5" />
    <PackageReference Include="System.Net.Http" Version="4.3.4"
        Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' " />

    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
    <PackageReference Include="Moq" Version="4.18.4" />
    <PackageReference Include="xunit" Version="2.4.2" />
    <PackageReference Include="xunit.analyzers" Version="1.1.0" />
    <PackageReference Include="xunit.runner.visualstudio" Version="$(_VSRunnerVersion)">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
    <PackageReference Include="XunitXml.TestLogger" Version="3.0.70" />

    <Compile Include="..\System.Net.Http.Formatting.Test\**\*.cs"
        Exclude="..\System.Net.Http.Formatting.Test\obj\**\*.cs;
                 ..\System.Net.Http.Formatting.Test\Formatting\BufferedMediaTypeFormatterTests.cs;
                 ..\System.Net.Http.Formatting.Test\Handlers\ProgressWriteAsyncResultTest.cs">
      <Link>%(RecursiveDir)\%(Filename).cs</Link>
    </Compile>

    <ProjectReference Include="..\..\src\System.Net.Http.Formatting.ns1_3\System.Net.Http.Formatting.ns1_3.csproj" />
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj" Properties="Testing_NetStandard1_3=true" />

    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
</Project>


================================================
FILE: test/System.Net.Http.Formatting.ns2_0.Test/System.Net.Http.Formatting.ns2_0.Test.csproj
================================================
<Project Sdk="Microsoft.NET.Sdk">
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <TargetFrameworks>net462;netcoreapp2.1;net8.0</TargetFrameworks>
    <RootNamespace>System.Net.Http</RootNamespace>
    <OutputPath>..\..\bin\$(Configuration)\Test\ns2_0\</OutputPath>
    <Configurations>$(Configurations);CodeAnalysis</Configurations>
    <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
    <DefineConstants>$(DefineConstants);Testing_NetStandard2_0</DefineConstants>
    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>

    <!-- Version 2.4.5 does not support netstandard2.1. -->
    <_VSRunnerVersion Condition=" '$(TargetFramework)' == 'netcoreapp2.1' ">2.4.3</_VSRunnerVersion>
    <_VSRunnerVersion Condition=" '$(TargetFramework)' != 'netcoreapp2.1' ">2.4.5</_VSRunnerVersion>
  </PropertyGroup>

  <ItemGroup>
    <PackageReference Include="System.IO.Pipelines" Version="4.7.5" />

    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
    <PackageReference Include="Moq" Version="4.18.4" />
    <PackageReference Include="xunit" Version="2.4.2" />
    <PackageReference Include="xunit.analyzers" Version="1.1.0" />
    <PackageReference Include="xunit.runner.visualstudio" Version="$(_VSRunnerVersion)">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
    <PackageReference Include="XunitXml.TestLogger" Version="3.0.70" />

    <Compile Include="..\System.Net.Http.Formatting.Test\**\*.cs"
        Exclude="..\System.Net.Http.Formatting.Test\obj\**\*.cs">
      <Link>%(RecursiveDir)\%(Filename).cs</Link>
    </Compile>

    <ProjectReference Include="..\..\src\System.Net.Http.Formatting.ns2_0\System.Net.Http.Formatting.ns2_0.csproj" />
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj" />

    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
</Project>


================================================
FILE: test/System.Web.Cors.Test/CorsEngineTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Cors.Test
{
    public class CorsEngineTest
    {
        [Fact]
        public void EvaluatePolicy_NullRequest_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.EvaluatePolicy(null, new CorsPolicy()),
                "requestContext");
        }

        [Fact]
        public void EvaluatePolicy_NullPolicy_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.EvaluatePolicy(new CorsRequestContext(), null),
                "policy");
        }

        [Fact]
        public void EvaluatePolicy_NoOrigin_ReturnsInvalidResult()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = null,
                HttpMethod = "GET"
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, new CorsPolicy());

            Assert.False(result.IsValid);
            Assert.Contains("The request does not contain the Origin header.", result.ErrorMessages);
        }

        [Fact]
        public void EvaluatePolicy_NoMatchingOrigin_ReturnsInvalidResult()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy();
            policy.Origins.Add("bar");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.False(result.IsValid);
            Assert.Contains("The origin 'foo' is not allowed.", result.ErrorMessages);
        }

        [Fact]
        public void EvaluatePolicy_EmptyOriginsPolicy_ReturnsInvalidResult()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy();

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.False(result.IsValid);
            Assert.Contains("The origin 'foo' is not allowed.", result.ErrorMessages);
        }

        [Fact]
        public void EvaluatePolicy_AllowAnyOrigin_DoesNotSupportCredentials_EmitsWildcardForOrigin()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                SupportsCredentials = false
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.Equal("*", result.AllowedOrigin);
        }

        [Fact]
        public void EvaluatePolicy_AllowAnyOrigin_SupportsCredentials_AddsSpecificOrigin()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                SupportsCredentials = true
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.Equal("foo", result.AllowedOrigin);
        }

        [Fact]
        public void EvaluatePolicy_DoesNotSupportCredentials_AllowCredentialsReturnsFalse()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                SupportsCredentials = false
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.False(result.SupportsCredentials);
        }

        [Fact]
        public void EvaluatePolicy_SupportsCredentials_AllowCredentialsReturnsTrue()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                SupportsCredentials = true
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(result.SupportsCredentials);
        }

        [Fact]
        public void EvaluatePolicy_NoExposedHeaders_NoAllowExposedHeaders()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.Empty(result.AllowedExposedHeaders);
        }

        [Fact]
        public void EvaluatePolicy_OneExposedHeaders_HeadersAllowed()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true
            };
            policy.ExposedHeaders.Add("foo");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.Equal(1, result.AllowedExposedHeaders.Count);
            Assert.Contains("foo", result.AllowedExposedHeaders);
        }

        [Fact]
        public void EvaluatePolicy_ManyExposedHeaders_HeadersAllowed()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true
            };
            policy.ExposedHeaders.Add("foo");
            policy.ExposedHeaders.Add("bar");
            policy.ExposedHeaders.Add("baz");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.Equal(3, result.AllowedExposedHeaders.Count());
            Assert.Contains("foo", result.AllowedExposedHeaders);
            Assert.Contains("bar", result.AllowedExposedHeaders);
            Assert.Contains("baz", result.AllowedExposedHeaders);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_MethodNotAllowed_ReturnsInvalidResult()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true
            };
            policy.Methods.Add("GET");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.False(result.IsValid);
            Assert.Contains("The method 'PUT' is not allowed.", result.ErrorMessages);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_MethodAllowed_ReturnsAllowMethods()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true
            };
            policy.Methods.Add("PUT");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.NotNull(result);
            Assert.Contains("PUT", result.AllowedMethods);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_OriginAllowed_ReturnsOrigin()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyMethod = true
            };
            policy.Origins.Add("foo");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Equal("foo", result.AllowedOrigin);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_SupportsCredentials_AllowCredentialsReturnsTrue()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo",
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyMethod = true,
                SupportsCredentials = true
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.True(result.SupportsCredentials);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_NoPreflightMaxAge_NoPreflightMaxAgeSet()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo",
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyMethod = true,
                PreflightMaxAge = null
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Null(result.PreflightMaxAge);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_PreflightMaxAge_PreflightMaxAgeSet()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo",
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyMethod = true,
                PreflightMaxAge = 10
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Equal(10, result.PreflightMaxAge);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_AnyMethod_ReturnsRequestMethod()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "GET",
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyMethod = true
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Equal(1, result.AllowedMethods.Count);
            Assert.Contains("GET", result.AllowedMethods);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_ListedMethod_ReturnsSubsetOfListedMethods()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo"
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true
            };
            policy.Methods.Add("PUT");
            policy.Methods.Add("DELETE");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Single(result.AllowedMethods);
            Assert.Contains("PUT", result.AllowedMethods);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_NoHeadersRequested_AllowedAllHeaders_ReturnsEmptyHeaders()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo",
            };
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyMethod = true,
                AllowAnyHeader = true
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Empty(result.AllowedHeaders);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_HeadersRequested_AllowAllHeaders_ReturnsRequestedHeaders()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo"
            };
            requestContext.AccessControlRequestHeaders.Add("foo");
            requestContext.AccessControlRequestHeaders.Add("bar");
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyHeader = true,
                AllowAnyMethod = true
            };

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Equal(2, result.AllowedHeaders.Count());
            Assert.Contains("foo", result.AllowedHeaders);
            Assert.Contains("bar", result.AllowedHeaders);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_HeadersRequested_AllowSomeHeaders_ReturnsSubsetOfListedHeaders()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo"
            };
            requestContext.AccessControlRequestHeaders.Add("Content-Type");
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyMethod = true
            };
            policy.Headers.Add("foo");
            policy.Headers.Add("bar");
            policy.Headers.Add("Content-Type");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.Equal(1, result.AllowedHeaders.Count);
            Assert.Contains("Content-Type", result.AllowedHeaders);
        }

        [Fact]
        public void EvaluatePolicy_PreflightRequest_HeadersRequested_NotAllHeaderMatches_ReturnsInvalidResult()
        {
            CorsEngine corsEngine = new CorsEngine();
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "PUT",
                Origin = "foo"
            };
            requestContext.AccessControlRequestHeaders.Add("match");
            requestContext.AccessControlRequestHeaders.Add("noMatch");
            CorsPolicy policy = new CorsPolicy
            {
                AllowAnyOrigin = true,
                AllowAnyMethod = true
            };
            policy.Headers.Add("match");
            policy.Headers.Add("foo");

            CorsResult result = corsEngine.EvaluatePolicy(requestContext, policy);

            Assert.True(requestContext.IsPreflight);
            Assert.False(result.IsValid);
            Assert.Contains("The collection of headers 'match,noMatch' is not allowed.", result.ErrorMessages);
        }

        [Fact]
        public void TryValidateMethod_NullPolicy_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateMethod(new CorsRequestContext(), null, new CorsResult()),
                "policy");
        }

        [Fact]
        public void TryValidateMethod_NullRequestContext_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateMethod(null, new CorsPolicy(), new CorsResult()),
                "requestContext");
        }

        [Fact]
        public void TryValidateMethod_NullResult_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateMethod(new CorsRequestContext(), new CorsPolicy(), null),
                "result");
        }

        [Fact]
        public void TryValidateMethod_DoesCaseSensitiveComparison()
        {
            CorsEngine corsEngine = new CorsEngine();

            CorsPolicy policy = new CorsPolicy();
            policy.Methods.Add("POST");
            CorsResult result = new CorsResult();

            bool isValid = corsEngine.TryValidateMethod(new CorsRequestContext { AccessControlRequestMethod = "post" }, policy, result);
            Assert.False(isValid);
            Assert.Equal(1, result.ErrorMessages.Count);
            Assert.Equal("The method 'post' is not allowed.", result.ErrorMessages[0]);
        }

        [Fact]
        public void TryValidateHeaders_NullPolicy_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateHeaders(new CorsRequestContext(), null, new CorsResult()),
                "policy");
        }

        [Fact]
        public void TryValidateHeaders_NullRequestContext_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateHeaders(null, new CorsPolicy(), new CorsResult()),
                "requestContext");
        }

        [Fact]
        public void TryValidateHeaders_NullResult_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateHeaders(new CorsRequestContext(), new CorsPolicy(), null),
                "result");
        }

        [Fact]
        public void TryValidateOrigin_NullPolicy_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateOrigin(new CorsRequestContext(), null, new CorsResult()),
                "policy");
        }

        [Fact]
        public void TryValidateOrigin_NullRequestContext_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateOrigin(null, new CorsPolicy(), new CorsResult()),
                "requestContext");
        }

        [Fact]
        public void TryValidateOrigin_NullResult_Throws()
        {
            CorsEngine corsEngine = new CorsEngine();

            Assert.ThrowsArgumentNull(() =>
                corsEngine.TryValidateOrigin(new CorsRequestContext(), new CorsPolicy(), null),
                "result");
        }

        [Fact]
        public void TryValidateOrigin_DoesCaseSensitiveComparison()
        {
            CorsEngine corsEngine = new CorsEngine();

            CorsPolicy policy = new CorsPolicy();
            policy.Origins.Add("http://Example.com");
            CorsResult result = new CorsResult();

            bool isValid = corsEngine.TryValidateOrigin(new CorsRequestContext { Origin = "http://example.com" }, policy, result);
            Assert.False(isValid);
            Assert.Equal(1, result.ErrorMessages.Count);
            Assert.Equal("The origin 'http://example.com' is not allowed.", result.ErrorMessages[0]);
        }
    }
}

================================================
FILE: test/System.Web.Cors.Test/CorsPolicyTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Cors.Test
{
    public class CorsPolicyTest
    {
        [Fact]
        public void Default_Constructor()
        {
            CorsPolicy corsPolicy = new CorsPolicy();

            Assert.False(corsPolicy.AllowAnyHeader);
            Assert.False(corsPolicy.AllowAnyMethod);
            Assert.False(corsPolicy.AllowAnyOrigin);
            Assert.False(corsPolicy.SupportsCredentials);
            Assert.Empty(corsPolicy.ExposedHeaders);
            Assert.Empty(corsPolicy.Headers);
            Assert.Empty(corsPolicy.Methods);
            Assert.Empty(corsPolicy.Origins);
            Assert.Null(corsPolicy.PreflightMaxAge);
        }

        [Fact]
        public void SettingNegativePreflightMaxAge_Throws()
        {
            CorsPolicy corsPolicy = new CorsPolicy();
            Assert.ThrowsArgumentOutOfRange(() =>
            {
                corsPolicy.PreflightMaxAge = -2;
            },
            "value",
            "PreflightMaxAge must be greater than or equal to 0.");
        }

        [Fact]
        public void ToString_ReturnsThePropertyValues()
        {
            CorsPolicy corsPolicy = new CorsPolicy
            {
                AllowAnyHeader = true,
                AllowAnyOrigin = true,
                PreflightMaxAge = 10,
                SupportsCredentials = true
            };
            corsPolicy.Headers.Add("foo");
            corsPolicy.Headers.Add("bar");
            corsPolicy.Origins.Add("http://example.com");
            corsPolicy.Origins.Add("http://example.org");
            corsPolicy.Methods.Add("GET");

            Assert.Equal(@"AllowAnyHeader: True, AllowAnyMethod: False, AllowAnyOrigin: True, PreflightMaxAge: 10, SupportsCredentials: True, Origins: {http://example.com,http://example.org}, Methods: {GET}, Headers: {foo,bar}, ExposedHeaders: {}", corsPolicy.ToString());
        }
    }
}

================================================
FILE: test/System.Web.Cors.Test/CorsRequestContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Cors.Test
{
    public class CorsRequestContextTest
    {
        [Fact]
        public void Default_Constructor()
        {
            CorsRequestContext requestContext = new CorsRequestContext();

            Assert.Null(requestContext.AccessControlRequestMethod);
            Assert.Null(requestContext.Host);
            Assert.Null(requestContext.HttpMethod);
            Assert.Null(requestContext.Origin);
            Assert.Null(requestContext.RequestUri);
            Assert.NotNull(requestContext.AccessControlRequestHeaders);
            Assert.False(requestContext.IsPreflight);
        }

        [Theory]
        [InlineData("OPTIONS", "POST", "foo")]
        [InlineData("options", "POST", "foo")]
        [InlineData("OPTIONS", "GET", "foo")]
        [InlineData("OPTIONS", "OPTIONS", "")]
        public void IsPreflight_ReturnsTrue(string httpMethod, string requestedMethod, string origin)
        {
            CorsRequestContext requestContext = new CorsRequestContext
            {
                HttpMethod = httpMethod,
                AccessControlRequestMethod = requestedMethod,
                Origin = origin
            };

            Assert.True(requestContext.IsPreflight);
        }

        [Theory]
        [InlineData("OPTIONS", "POST", null)]
        [InlineData("options", "POST", null)]
        [InlineData("OPTIONS", null, "foo")]
        [InlineData(null, "POST", "foo")]
        [InlineData("POST", "GET", "bar")]
        public void IsPreflight_ReturnsFalse(string httpMethod, string requestedMethod, string origin)
        {
            CorsRequestContext requestContext = new CorsRequestContext()
            {
                HttpMethod = httpMethod,
                AccessControlRequestMethod = requestedMethod,
                Origin = origin
            };

            Assert.False(requestContext.IsPreflight);
        }

        [Fact]
        public void ToString_ReturnsThePropertyValues()
        {
            CorsRequestContext requestContext = new CorsRequestContext
            {
                Host = "http://example.com",
                HttpMethod = "OPTIONS",
                AccessControlRequestMethod = "DELETE",
                Origin = "http://localhost",
                RequestUri = new Uri("http://example.com")
            };
            requestContext.AccessControlRequestHeaders.Add("foo");
            requestContext.AccessControlRequestHeaders.Add("bar");

            Assert.Equal(@"Origin: http://localhost, HttpMethod: OPTIONS, IsPreflight: True, Host: http://example.com, AccessControlRequestMethod: DELETE, RequestUri: http://example.com/, AccessControlRequestHeaders: {foo,bar}", requestContext.ToString());
        }
    }
}

================================================
FILE: test/System.Web.Cors.Test/CorsResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Web.Cors.Test
{
    public class CorsResultTest
    {
        [Fact]
        public void Default_Constructor()
        {
            CorsResult result = new CorsResult();

            Assert.Empty(result.AllowedHeaders);
            Assert.Empty(result.AllowedExposedHeaders);
            Assert.Empty(result.AllowedMethods);
            Assert.Empty(result.ErrorMessages);
            Assert.False(result.SupportsCredentials);
            Assert.Null(result.AllowedOrigin);
            Assert.Null(result.PreflightMaxAge);
            Assert.True(result.IsValid);
        }

        [Fact]
        public void SettingNegativePreflightMaxAge_Throws()
        {
            CorsResult result = new CorsResult();
            Assert.ThrowsArgumentOutOfRange(() =>
            {
                result.PreflightMaxAge = -2;
            },
            "value",
            "PreflightMaxAge must be greater than or equal to 0.");
        }

        [Fact]
        public void IsValid_ReturnsFalse_WhenThereIsError()
        {
            CorsResult result = new CorsResult();
            result.ErrorMessages.Add("error");

            Assert.False(result.IsValid);
        }

        [Fact]
        public void ToResponseHeaders_ReturnsNoHeaders_ByDefault()
        {
            CorsResult result = new CorsResult();

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Empty(headers);
        }

        [Fact]
        public void ToResponseHeaders_AllowOrigin_AllowOriginHeaderAdded()
        {
            CorsResult result = new CorsResult
            {
                AllowedOrigin = "http://example.com"
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Equal("http://example.com", headers["Access-Control-Allow-Origin"]);
        }

        [Fact]
        public void ToResponseHeaders_NoAllowOrigin_AllowOriginHeaderNotAdded()
        {
            CorsResult result = new CorsResult
            {
                AllowedOrigin = null
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Allow-Origin", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_AllowCredentials_AllowCredentialsHeaderAdded()
        {
            CorsResult result = new CorsResult
            {
                SupportsCredentials = true
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Equal("true", headers["Access-Control-Allow-Credentials"]);
        }

        [Fact]
        public void ToResponseHeaders_NoAllowCredentials_AllowCredentialsHeaderNotAdded()
        {
            CorsResult result = new CorsResult
            {
                SupportsCredentials = false
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Allow-Credentials", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_NoAllowMethods_AllowMethodsHeaderNotAdded()
        {
            CorsResult result = new CorsResult
            {
                // AllowMethods is empty by default
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Allow-Methods", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_OneAllowMethods_AllowMethodsHeaderAdded()
        {
            CorsResult result = new CorsResult();
            result.AllowedMethods.Add("PUT");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Equal("PUT", headers["Access-Control-Allow-Methods"]);
        }

        [Fact]
        public void ToResponseHeaders_SomeSimpleAllowMethods_AllowMethodsHeaderAddedForNonSimpleMethods()
        {
            CorsResult result = new CorsResult();
            result.AllowedMethods.Add("PUT");
            result.AllowedMethods.Add("get");
            result.AllowedMethods.Add("DELETE");
            result.AllowedMethods.Add("POST");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Contains("Access-Control-Allow-Methods", headers.Keys);
            string[] methods = headers["Access-Control-Allow-Methods"].Split(',');
            Assert.Equal(2, methods.Length);
            Assert.Contains("PUT", methods);
            Assert.Contains("DELETE", methods);
        }

        [Fact]
        public void ToResponseHeaders_SimpleAllowMethods_AllowMethodsHeaderNotAdded()
        {
            CorsResult result = new CorsResult();
            result.AllowedMethods.Add("GET");
            result.AllowedMethods.Add("HEAD");
            result.AllowedMethods.Add("POST");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Allow-Methods", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_NoAllowHeaders_AllowHeadersHeaderNotAdded()
        {
            CorsResult result = new CorsResult
            {
                // AllowHeaders is empty by default
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Allow-Headers", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_OneAllowHeaders_AllowHeadersHeaderAdded()
        {
            CorsResult result = new CorsResult();
            result.AllowedHeaders.Add("foo");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Equal("foo", headers["Access-Control-Allow-Headers"]);
        }

        [Fact]
        public void ToResponseHeaders_ManyAllowHeaders_AllowHeadersHeaderAdded()
        {
            CorsResult result = new CorsResult();
            result.AllowedHeaders.Add("foo");
            result.AllowedHeaders.Add("bar");
            result.AllowedHeaders.Add("baz");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Contains("Access-Control-Allow-Headers", headers.Keys);
            string[] headerValues = headers["Access-Control-Allow-Headers"].Split(',');
            Assert.Equal(3, headerValues.Length);
            Assert.Contains("foo", headerValues);
            Assert.Contains("bar", headerValues);
            Assert.Contains("baz", headerValues);
        }

        [Fact]
        public void ToResponseHeaders_SomeSimpleAllowHeaders_AllowHeadersHeaderAddedForNonSimpleHeaders()
        {
            CorsResult result = new CorsResult();
            result.AllowedHeaders.Add("Content-Language");
            result.AllowedHeaders.Add("foo");
            result.AllowedHeaders.Add("bar");
            result.AllowedHeaders.Add("Accept");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Contains("Access-Control-Allow-Headers", headers.Keys);
            string[] headerValues = headers["Access-Control-Allow-Headers"].Split(',');
            Assert.Equal(2, headerValues.Length);
            Assert.Contains("foo", headerValues);
            Assert.Contains("bar", headerValues);
        }

        [Fact]
        public void ToResponseHeaders_SimpleAllowHeaders_AllowHeadersHeaderNotAdded()
        {
            CorsResult result = new CorsResult();
            result.AllowedHeaders.Add("Accept");
            result.AllowedHeaders.Add("Accept-Language");
            result.AllowedHeaders.Add("Content-Language");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Allow-Headers", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_NoAllowExposedHeaders_ExposedHeadersHeaderNotAdded()
        {
            CorsResult result = new CorsResult
            {
                // AllowExposedHeaders is empty by default
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Expose-Headers", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_OneAllowExposedHeaders_ExposedHeadersHeaderAdded()
        {
            CorsResult result = new CorsResult();
            result.AllowedExposedHeaders.Add("foo");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Equal("foo", headers["Access-Control-Expose-Headers"]);
        }

        [Fact]
        public void ToResponseHeaders_ManyAllowExposedHeaders_ExposedHeadersHeaderAdded()
        {
            CorsResult result = new CorsResult();
            result.AllowedExposedHeaders.Add("foo");
            result.AllowedExposedHeaders.Add("bar");
            result.AllowedExposedHeaders.Add("baz");

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Contains("Access-Control-Expose-Headers", headers.Keys);
            string[] exposedHeaderValues = headers["Access-Control-Expose-Headers"].Split(',');
            Assert.Equal(3, exposedHeaderValues.Length);
            Assert.Contains("foo", exposedHeaderValues);
            Assert.Contains("bar", exposedHeaderValues);
            Assert.Contains("baz", exposedHeaderValues);
        }

        [Fact]
        public void ToResponseHeaders_NoPreflightMaxAge_MaxAgeHeaderNotAdded()
        {
            CorsResult result = new CorsResult
            {
                PreflightMaxAge = null
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.DoesNotContain("Access-Control-Max-Age", headers.Keys);
        }

        [Fact]
        public void ToResponseHeaders_PreflightMaxAge_MaxAgeHeaderAdded()
        {
            CorsResult result = new CorsResult
            {
                PreflightMaxAge = 30
            };

            IDictionary<string, string> headers = result.ToResponseHeaders();

            Assert.Equal("30", headers["Access-Control-Max-Age"]);
        }

        [Fact]
        public void ToString_ReturnsThePropertyValues()
        {
            CorsResult corsResult = new CorsResult
            {
                SupportsCredentials = true,
                PreflightMaxAge = 20,
                AllowedOrigin = "*"
            };
            corsResult.AllowedExposedHeaders.Add("foo");
            corsResult.AllowedHeaders.Add("bar");
            corsResult.AllowedHeaders.Add("baz");
            corsResult.AllowedMethods.Add("GET");
            corsResult.ErrorMessages.Add("error1");
            corsResult.ErrorMessages.Add("error2");

            Assert.Equal(@"IsValid: False, AllowCredentials: True, PreflightMaxAge: 20, AllowOrigin: *, AllowExposedHeaders: {foo}, AllowHeaders: {bar,baz}, AllowMethods: {GET}, ErrorMessages: {error1,error2}", corsResult.ToString());
        }
    }
}

================================================
FILE: test/System.Web.Cors.Test/System.Web.Cors.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Cors</RootNamespace>
    <AssemblyName>System.Web.Cors.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <ProjectGuid>{BF07E947-120D-4E93-93DA-A4BF121753EA}</ProjectGuid>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="CorsPolicyTest.cs" />
    <Compile Include="CorsEngineTest.cs" />
    <Compile Include="CorsRequestContextTest.cs" />
    <Compile Include="CorsResultTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.Cors\System.Web.Cors.csproj">
      <Project>{43c1b979-d593-4a32-bb3a-4316f1c66d66}</Project>
      <Name>System.Web.Cors</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Folder Include="Properties\" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Cors.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Helpers.Test/ChartTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Drawing;
using System.IO;
using System.Web.Hosting;
using System.Web.UI.DataVisualization.Charting;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Test
{
    public class ChartTest
    {
        private byte[] _writeData;

        public ChartTest()
        {
            _writeData = null;
        }

        [Fact]
        public void BuildChartAddsDefaultArea()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            AssertBuiltChartAction(chart, c =>
            {
                ChartArea chartArea = Assert.Single(c.ChartAreas);
                Assert.Equal("Default", chartArea.Name);
            });
        }

        [Fact]
        public void XAxisOverrides()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100)
                .SetXAxis("AxisX", 1, 100);
            AssertBuiltChartAction(chart, c =>
            {
                ChartArea chartArea = Assert.Single(c.ChartAreas);
                Assert.Equal("AxisX", chartArea.AxisX.Title);
                Assert.Equal(1, chartArea.AxisX.Minimum);
                Assert.Equal(100, chartArea.AxisX.Maximum);
            });
        }

        [Fact]
        public void YAxisOverrides()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100)
                .SetYAxis("AxisY", 1, 100);
            AssertBuiltChartAction(chart, c =>
            {
                ChartArea chartArea = Assert.Single(c.ChartAreas);
                Assert.Equal("AxisY", chartArea.AxisY.Title);
                Assert.Equal(1, chartArea.AxisY.Minimum);
                Assert.Equal(100, chartArea.AxisY.Maximum);
            });
        }

        [Fact]
        public void ConstructorLoadsTemplate()
        {
            var template = WriteTemplate(@"<Chart BorderWidth=""2""></Chart>");
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100, themePath: template);
            AssertBuiltChartAction(chart, c => { Assert.Equal(2, c.BorderWidth); });
        }

        [Fact]
        public void ConstructorLoadsTheme()
        {
            //Vanilla theme
            /*
             * <Chart Palette="SemiTransparent" BorderColor="#000" BorderWidth="2" BorderlineDashStyle="Solid">
                <ChartAreas>
                    <ChartArea _Template_="All" Name="Default">
                            <AxisX>
                                <MinorGrid Enabled="False" />
                                <MajorGrid Enabled="False" />
                            </AxisX>
                            <AxisY>
                                <MajorGrid Enabled="False" />
                                <MinorGrid Enabled="False" />
                            </AxisY>
                    </ChartArea>
                </ChartAreas>
                </Chart>
             */
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100, theme: ChartTheme.Vanilla);
            AssertBuiltChartAction(chart, c =>
            {
                Assert.Equal(ChartColorPalette.SemiTransparent, c.Palette);
                Assert.Equal(c.BorderColor, Color.FromArgb(0, Color.Black));
                ChartArea chartArea = Assert.Single(c.ChartAreas);
                Assert.False(chartArea.AxisX.MajorGrid.Enabled);
                Assert.False(chartArea.AxisY.MinorGrid.Enabled);
            });
        }

        [Fact]
        public void ConstructorLoadsThemeAndTemplate()
        {
            //Vanilla theme
            /*
             * <Chart Palette="SemiTransparent" BorderColor="#000" BorderWidth="2" BorderlineDashStyle="Solid">
                <ChartAreas>
                    <ChartArea _Template_="All" Name="Default">
                            <AxisX>
                                <MinorGrid Enabled="False" />
                                <MajorGrid Enabled="False" />
                            </AxisX>
                            <AxisY>
                                <MajorGrid Enabled="False" />
                                <MinorGrid Enabled="False" />
                            </AxisY>
                    </ChartArea>
                </ChartAreas>
                </Chart>
             */
            var template = WriteTemplate(@"<Chart BorderlineDashStyle=""DashDot""><Legends><Legend BackColor=""Red"" /></Legends></Chart>");
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100, theme: ChartTheme.Vanilla, themePath: template);
            AssertBuiltChartAction(chart, c =>
            {
                Assert.Equal(ChartColorPalette.SemiTransparent, c.Palette);
                Assert.Equal(c.BorderColor, Color.FromArgb(0, Color.Black));
                Assert.Equal(ChartDashStyle.DashDot, c.BorderlineDashStyle);
                Legend legend = Assert.Single(c.Legends);
                Assert.Equal(legend.BackColor, Color.Red);
                ChartArea chartArea = Assert.Single(c.ChartAreas);
                Assert.False(chartArea.AxisX.MajorGrid.Enabled);
                Assert.False(chartArea.AxisY.MinorGrid.Enabled);
            });
        }

        [Fact]
        public void ConstructorLoadsThemeAndTemplate_VPPRegistrationChanging()
        {
            // Arrange
            // Vanilla theme, as in ConstructorLoadsThemeAndTemplate()
            string template = WriteTemplate(@"<Chart BorderlineDashStyle=""DashDot""><Legends><Legend BackColor=""Red"" /></Legends></Chart>");
            HttpContextBase context = GetContext();
            string templatePath = VirtualPathUtility.Combine(context.Request.AppRelativeCurrentExecutionFilePath, template);

            MockVirtualPathProvider provider1 = new MockVirtualPathProvider();
            MockVirtualPathProvider provider2 = new MockVirtualPathProvider();
            VirtualPathProvider provider = provider1;

            // Act; use one provider in constructor and another in ExecuteChartAction()
            Chart chart = new Chart(context, () => provider, 100, 100, theme: ChartTheme.Vanilla, themePath: template);

            // The moral equivalent of HostingEnvironment.RegisterVirtualPathProvider(provider2)
            provider = provider2;

            // Assert
            AssertBuiltChartAction(chart, c =>
            {
                Assert.Equal(ChartColorPalette.SemiTransparent, c.Palette);
                Assert.Equal(c.BorderColor, Color.FromArgb(0, Color.Black));
                Assert.Equal(ChartDashStyle.DashDot, c.BorderlineDashStyle);
                Legend legend = Assert.Single(c.Legends);
                Assert.Equal(legend.BackColor, Color.Red);
                ChartArea chartArea = Assert.Single(c.ChartAreas);
                Assert.False(chartArea.AxisX.MajorGrid.Enabled);
                Assert.False(chartArea.AxisY.MinorGrid.Enabled);
            });

            Assert.Equal(1, provider1.FileExistsCalls);
            Assert.Equal(0, provider1.GetFileCalls);
            Assert.Equal(0, provider2.FileExistsCalls);
            Assert.Equal(1, provider2.GetFileCalls);
        }

        [Fact]
        public void ConstructorSetsWidthAndHeight()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 101, 102);
            Assert.Equal(101, chart.Width);
            Assert.Equal(102, chart.Height);
            AssertBuiltChartAction(chart, c =>
            {
                Assert.Equal(101, c.Width);
                Assert.Equal(102, c.Height);
            });
        }

        [Fact]
        public void ConstructorThrowsWhenHeightIsLessThanZero()
        {
            Assert.ThrowsArgumentOutOfRange(() => { new Chart(GetContext(), GetVirtualPathProvider(), 100, -1); }, "height", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void ConstructorThrowsWhenTemplateNotFound()
        {
            var templateFile = @"FileNotFound.xml";
            Assert.ThrowsArgument(() => { new Chart(GetContext(), GetVirtualPathProvider(), 100, 100, themePath: templateFile); },
                                                    "themePath",
                                                    String.Format("The theme file \"{0}\" could not be found.", VirtualPathUtility.Combine(GetContext().Request.AppRelativeCurrentExecutionFilePath, templateFile)));
        }

        [Fact]
        public void ConstructorThrowsWhenWidthIsLessThanZero()
        {
            Assert.ThrowsArgumentOutOfRange(() => { new Chart(GetContext(), GetVirtualPathProvider(), -1, 100); }, "width", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void DataBindCrossTable()
        {
            var data = new[]
            {
                new { GroupBy = "1", YValue = 1 },
                new { GroupBy = "1", YValue = 2 },
                new { GroupBy = "2", YValue = 1 }
            };
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100)
                .DataBindCrossTable(data, "GroupBy", xField: null, yFields: "YValue");
            // todo - anything else to verify here?
            AssertBuiltChartAction(chart, c =>
            {
                Assert.Equal(2, c.Series.Count);
                Assert.Equal(2, c.Series[0].Points.Count);
                Assert.Single(c.Series[1].Points);
            });
        }

        [Fact]
        public void DataBindCrossTableThrowsWhenDataSourceIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNull(() => { chart.DataBindCrossTable(null, "GroupBy", xField: null, yFields: "yFields"); }, "dataSource");
        }

        [Fact]
        public void DataBindCrossTableThrowsWhenDataSourceIsString()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgument(() => { chart.DataBindCrossTable("DataSource", "GroupBy", xField: null, yFields: "yFields"); }, "dataSource", "A series cannot be data-bound to a string object.");
        }

        [Fact]
        public void DataBindCrossTableThrowsWhenGroupByIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.DataBindCrossTable(new object[0], null, xField: null, yFields: "yFields"); }, "groupByField");
        }

        [Fact]
        public void DataBindCrossTableThrowsWhenGroupByIsEmpty()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.DataBindCrossTable(new object[0], "", xField: null, yFields: "yFields"); }, "groupByField");
        }

        [Fact]
        public void DataBindCrossTableThrowsWhenYFieldsIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.DataBindCrossTable(new object[0], "GroupBy", xField: null, yFields: null); }, "yFields");
        }

        [Fact]
        public void DataBindCrossTableThrowsWhenYFieldsIsEmpty()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.DataBindCrossTable(new object[0], "GroupBy", xField: null, yFields: ""); }, "yFields");
        }

        [Fact]
        public void DataBindTable()
        {
            var data = new[]
            {
                new { XValue = "1", YValue = 1 },
                new { XValue = "2", YValue = 2 },
                new { XValue = "3", YValue = 3 }
            };
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100)
                .DataBindTable(data, xField: "XValue");
            // todo - anything else to verify here?
            AssertBuiltChartAction(chart, c =>
            {
                var series = Assert.Single(c.Series);
                Assert.Equal(3, series.Points.Count);
            });
        }

        [Fact]
        public void DataBindTableWhenXFieldIsNull()
        {
            var data = new[]
            {
                new { YValue = 1 },
                new { YValue = 2 },
                new { YValue = 3 }
            };
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100)
                .DataBindTable(data, xField: null);
            // todo - anything else to verify here?
            AssertBuiltChartAction(chart, c =>
            {
                var series = Assert.Single(c.Series);
                Assert.Equal(3, series.Points.Count);
            });
        }

        [Fact]
        public void DataBindTableThrowsWhenDataSourceIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNull(() => { chart.DataBindTable(null); }, "dataSource");
        }

        [Fact]
        public void DataBindTableThrowsWhenDataSourceIsString()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgument(() => { chart.DataBindTable(""); }, "dataSource", "A series cannot be data-bound to a string object.");
        }

        [Fact]
        public void GetBytesReturnsNonEmptyArray()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.True(chart.GetBytes().Length > 0);
        }

        [Fact]
        public void GetBytesThrowsWhenFormatIsEmpty()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.GetBytes(format: String.Empty); }, "format");
        }

        [Fact]
        public void GetBytesThrowsWhenFormatIsInvalid()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgument(() => { chart.GetBytes(format: "foo"); }, "format", "\"foo\" is invalid image format. Valid values are image format names like: \"JPEG\", \"BMP\", \"GIF\", \"PNG\", etc.");
        }

        [Fact]
        public void GetBytesThrowsWhenFormatIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.GetBytes(format: null); }, "format");
        }

        [Fact]
        public void LegendDefaults()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100).AddLegend();
            AssertBuiltChartAction(chart, c =>
            {
                Legend legend = Assert.Single(c.Legends);
                // NOTE: Chart.Legends.Add will create default name
                Assert.Equal("Legend1", legend.Name);
                Assert.Equal(1, legend.BorderWidth);
            });
        }

        [Fact]
        public void LegendOverrides()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100).AddLegend("Legend1")
                .AddLegend("Legend2", "Legend2Name");
            AssertBuiltChartAction(chart, c =>
            {
                Assert.Equal(2, c.Legends.Count);
                Assert.Equal("Legend1", c.Legends[0].Name);
                Assert.Equal("Legend2", c.Legends[1].Title);
                Assert.Equal("Legend2Name", c.Legends[1].Name);
            });
        }

        [Fact]
        public void SaveAndWriteFromCache()
        {
            var context1 = GetContext();
            var chart = new Chart(context1, GetVirtualPathProvider(), 100, 100);

            string key = chart.SaveToCache();
            Assert.Equal(chart, WebCache.Get(key));

            var context2 = GetContext();
            Assert.Equal(chart, Chart.GetFromCache(context2, key));

            Chart.WriteFromCache(context2, key);

            Assert.Null(context1.Response.ContentType);
            Assert.Equal("image/jpeg", context2.Response.ContentType);
        }

        [Fact]
        public void SaveThrowsWhenFormatIsEmpty()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.Save(GetContext(), "chartPath", format: String.Empty); }, "format");
        }

        [Fact]
        public void SaveWorksWhenFormatIsJPG()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);

            string fileName = "chartPath";

            chart.Save(GetContext(), "chartPath", format: "jpg");
            byte[] a = File.ReadAllBytes(fileName);

            chart.Save(GetContext(), "chartPath", format: "jpeg");
            byte[] b = File.ReadAllBytes(fileName);

            Assert.Equal(a, b);
        }

        [Fact]
        public void SaveThrowsWhenFormatIsInvalid()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgument(() => { chart.Save(GetContext(), "chartPath", format: "foo"); }, "format", "\"foo\" is invalid image format. Valid values are image format names like: \"JPEG\", \"BMP\", \"GIF\", \"PNG\", etc.");
        }

        [Fact]
        public void SaveThrowsWhenFormatIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.Save(GetContext(), "chartPath", format: null); }, "format");
        }

        [Fact]
        public void SaveThrowsWhenPathIsEmpty()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.Save(GetContext(), path: String.Empty, format: "jpeg"); }, "path");
        }

        [Fact]
        public void SaveThrowsWhenPathIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.Save(GetContext(), path: null, format: "jpeg"); }, "path");
        }

        [Fact]
        public void SaveWritesToFile()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            chart.Save(GetContext(), "SaveWritesToFile.jpg", format: "image/jpeg");
            Assert.Equal("SaveWritesToFile.jpg", Path.GetFileName(chart.FileName));
            Assert.True(File.Exists(chart.FileName));
        }

        [Fact]
        public void SaveXmlThrowsWhenPathIsEmpty()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.SaveXml(GetContext(), String.Empty); }, "path");
        }

        [Fact]
        public void SaveXmlThrowsWhenPathIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.SaveXml(GetContext(), null); }, "path");
        }

        [Fact]
        public void SaveXmlWritesToFile()
        {
            var template = WriteTemplate(@"<Chart BorderWidth=""2""></Chart>");
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100, themePath: template);
            chart.SaveXml(GetContext(), "SaveXmlWritesToFile.xml");
            Assert.True(File.Exists("SaveXmlWritesToFile.xml"));
            string result = File.ReadAllText("SaveXmlWritesToFile.xml");
            Assert.Contains("BorderWidth=\"2\"", result);
        }

        [Fact]
        public void TemplateWithCommentsDoesNotThrow()
        {
            var template = WriteTemplate(@"<Chart BorderWidth=""2""><!-- This is a XML comment.  --> </Chart>");
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100, themePath: template);
            Assert.NotNull(chart.ToWebImage());
        }

        [Fact]
        public void TemplateWithIncorrectPropertiesThrows()
        {
            var template = WriteTemplate(@"<Chart borderWidth=""2""><fjkjkgjklfg /></Chart>");
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100, themePath: template);
            Assert.Throws<InvalidOperationException>(() => chart.ToWebImage(),
                                                              "Cannot deserialize property. Unknown property name 'borderWidth' in object \" System.Web.UI.DataVisualization.Charting.Chart");
        }

        [Fact]
        public void WriteWorksWithJPGFormat()
        {
            var response = new Mock<HttpResponseBase>();
            var stream = new MemoryStream();
            response.Setup(c => c.Output).Returns(new StreamWriter(stream));

            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Response).Returns(response.Object);

            var chart = new Chart(context.Object, GetVirtualPathProvider(), 100, 100);
            chart.Write("jpeg");

            byte[] a = stream.GetBuffer();

            stream.SetLength(0);
            chart.Write("jpg");
            byte[] b = stream.GetBuffer();

            Assert.Equal(a, b);
        }

        [Fact]
        public void WriteThrowsWithInvalidFormat()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgument(() => chart.Write("foo"),
                                                    "format", "\"foo\" is invalid image format. Valid values are image format names like: \"JPEG\", \"BMP\", \"GIF\", \"PNG\", etc.");
        }

        [Fact]
        public void SeriesOverrides()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100)
                .AddSeries(chartType: "Bar");
            AssertBuiltChartAction(chart, c =>
            {
                var series = Assert.Single(c.Series);
                Assert.Equal(SeriesChartType.Bar, series.ChartType);
            });
        }

        [Fact]
        public void SeriesThrowsWhenChartTypeIsEmpty()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.AddSeries(chartType: ""); }, "chartType");
        }

        [Fact]
        public void SeriesThrowsWhenChartTypeIsNull()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            Assert.ThrowsArgumentNullOrEmptyString(() => { chart.AddSeries(chartType: null); }, "chartType");
        }

        [Fact]
        public void TitleDefaults()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100).AddTitle();
            AssertBuiltChartAction(chart, c =>
            {
                var title = Assert.Single(c.Titles);
                // NOTE: Chart.Titles.Add will create default name
                Assert.Equal("Title1", title.Name);
                Assert.Equal(String.Empty, title.Text);
                Assert.Equal(1, title.BorderWidth);
            });
        }

        [Fact]
        public void TitleOverrides()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100).AddTitle(name: "Title1")
                .AddTitle("Title2Text", name: "Title2");
            AssertBuiltChartAction(chart, c =>
            {
                Assert.Equal(2, c.Titles.Count);
                Assert.Equal("Title1", c.Titles[0].Name);
                Assert.Equal("Title2", c.Titles[1].Name);
                Assert.Equal("Title2Text", c.Titles[1].Text);
            });
        }

        [Fact]
        public void ToWebImage()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            var image = chart.ToWebImage();
            Assert.NotNull(image);
            Assert.Equal("jpeg", image.ImageFormat);
        }

        [Fact]
        public void ToWebImageUsesFormat()
        {
            var chart = new Chart(GetContext(), GetVirtualPathProvider(), 100, 100);
            var image = chart.ToWebImage(format: "png");
            Assert.NotNull(image);
            Assert.Equal("png", image.ImageFormat);
        }

        [Fact]
        public void WriteFromCacheIsNoOpIfNotSavedInCache()
        {
            var context = GetContext();
            Assert.Null(Chart.WriteFromCache(context, Guid.NewGuid().ToString()));
            Assert.Null(context.Response.ContentType);
        }

        [Fact]
        public void WriteUpdatesResponse()
        {
            var context = GetContext();
            var chart = new Chart(context, GetVirtualPathProvider(), 100, 100);
            chart.Write();
            Assert.Equal("", context.Response.Charset);
            Assert.Equal("image/jpeg", context.Response.ContentType);
            Assert.True((_writeData != null) && (_writeData.Length > 0));
        }

        private static void AssertBuiltChartAction(Chart chart, Action<UI.DataVisualization.Charting.Chart> action)
        {
            bool actionCalled = false;
            chart.ExecuteChartAction(c =>
            {
                action(c);
                actionCalled = true;
            });
            Assert.True(actionCalled);
        }

        private HttpContextBase GetContext()
        {
            // Strip drive letter for VirtualPathUtility.Combine
            var testPath = Directory.GetCurrentDirectory().Substring(2) + "/Out";
            Mock<HttpRequestBase> request = new Mock<HttpRequestBase>();
            request.Setup(r => r.AppRelativeCurrentExecutionFilePath).Returns(testPath);
            request.Setup(r => r.MapPath(It.IsAny<string>())).Returns((string path) => path);

            Mock<HttpResponseBase> response = new Mock<HttpResponseBase>();
            response.SetupProperty(r => r.ContentType);
            response.SetupProperty(r => r.Charset);
            response.Setup(r => r.BinaryWrite(It.IsAny<byte[]>())).Callback((byte[] data) => _writeData = data);

            Mock<HttpServerUtilityBase> server = new Mock<HttpServerUtilityBase>();
            server.Setup(s => s.MapPath(It.IsAny<string>())).Returns((string s) => s);

            var items = new Hashtable();

            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Request).Returns(request.Object);
            context.Setup(c => c.Response).Returns(response.Object);
            context.Setup(c => c.Server).Returns(server.Object);
            context.Setup(c => c.Items).Returns(items);
            return context.Object;
        }

        private static string WriteTemplate(string xml)
        {
            var path = Guid.NewGuid() + ".xml";
            File.WriteAllText(path, xml);
            return path;
        }

        private static MockVirtualPathProvider GetVirtualPathProvider()
        {
            return new MockVirtualPathProvider();
        }

        class MockVirtualPathProvider : VirtualPathProvider
        {
            public int FileExistsCalls { get; private set; }

            public int GetFileCalls { get; private set; }

            class MockVirtualFile : VirtualFile
            {
                public MockVirtualFile(string virtualPath)
                    : base(virtualPath)
                {
                }

                public override Stream Open()
                {
                    return File.Open(this.VirtualPath, FileMode.Open);
                }
            }

            public override bool FileExists(string virtualPath)
            {
                ++FileExistsCalls;
                return File.Exists(virtualPath);
            }

            public override VirtualFile GetFile(string virtualPath)
            {
                ++GetFileCalls;
                return new MockVirtualFile(virtualPath);
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/ConversionUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Drawing;
using System.Globalization;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class ConversionUtilTest
    {
        [Fact]
        public void ConversionUtilReturnsStringTypes()
        {
            // Arrange
            string original = "Foo";

            // Act
            object result;
            bool success = ConversionUtil.TryFromString(typeof(String), original, out result);

            // Assert
            Assert.True(success);
            Assert.Equal(original, result);
        }

        [Fact]
        public void ConversionUtilConvertsStringsToColor()
        {
            // Arrange
            string original = "Blue";

            // Act
            object result;
            bool success = ConversionUtil.TryFromString(typeof(Color), original, out result);

            // Assert
            Assert.True(success);
            Assert.Equal(Color.Blue, result);
        }

        [Fact]
        public void ConversionUtilConvertsEnumValues()
        {
            // Arrange
            string original = "Weekday";

            // Act
            object result;
            bool success = ConversionUtil.TryFromString(typeof(TestEnum), original, out result);

            // Assert
            Assert.True(success);
            Assert.Equal(TestEnum.Weekday, result);
        }

        [Fact]
        public void ConversionUtilUsesTypeConverterToConvertArbitraryTypes()
        {
            // Arrange
            var date = new DateTime(2010, 01, 01);
            string original = date.ToString(CultureInfo.InvariantCulture);

            // Act
            object result;
            bool success = ConversionUtil.TryFromString(typeof(DateTime), original, out result);

            // Assert
            Assert.True(success);
            Assert.Equal(date, result);
        }

        private enum TestEnum
        {
            Weekend,
            Weekday
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/CryptoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Security.Cryptography;
using System.Text;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    /// <summary>
    /// This is a test class for CryptoTest and is intended
    /// to contain all CryptoTest Unit Tests
    /// </summary>
    public class CryptoTest
    {
        [Fact]
        public void SHA256HashTest_ReturnsValidData()
        {
            string data = "foo bar";
            string expected = "FBC1A9F858EA9E177916964BD88C3D37B91A1E84412765E29950777F265C4B75";
            string actual;
            actual = Crypto.SHA256(data);
            Assert.Equal(expected, actual);

            actual = Crypto.Hash(Encoding.UTF8.GetBytes(data));
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void GenerateSaltTest()
        {
            string salt = Crypto.GenerateSalt();
            salt = Crypto.GenerateSalt(64);
            Assert.Equal(24, Crypto.GenerateSalt().Length);
            Assert.Equal(12, Crypto.GenerateSalt(8).Length);
            Assert.Equal(88, Crypto.GenerateSalt(64).Length);
            Assert.Equal(44, Crypto.GenerateSalt(32).Length);
        }

        [Fact]
        public void HashPassword_PasswordGeneration()
        {
            // Act - call helper directly
            string generatedHash = Crypto.HashPassword("my-password");
            byte[] salt = new byte[16];
            Buffer.BlockCopy(Convert.FromBase64String(generatedHash), 1, salt, 0, 16); // extract salt from generated hash

            // Act - perform PBKDF2 directly
            string generatedHash2;
            using (var ms = new MemoryStream())
            {
                using (var bw = new BinaryWriter(ms))
                {
                    using (var deriveBytes = new Rfc2898DeriveBytes("my-password", salt, iterations: 1000))
                    {
                        bw.Write((byte)0x00); // version identifier
                        bw.Write(salt); // salt
                        bw.Write(deriveBytes.GetBytes(32)); // subkey
                    }

                    generatedHash2 = Convert.ToBase64String(ms.ToArray());
                }
            }

            // Assert
            Assert.Equal(generatedHash2, generatedHash);
        }

        [Fact]
        public void HashPassword_RoundTripping()
        {
            // Act & assert
            string password = "ImPepper";
            Assert.True(Crypto.VerifyHashedPassword(Crypto.HashPassword(password), password));
            Assert.False(Crypto.VerifyHashedPassword(Crypto.HashPassword(password), "ImSalt"));
            Assert.False(Crypto.VerifyHashedPassword(Crypto.HashPassword("Impepper"), password));
        }

        [Fact]
        public void VerifyHashedPassword_CorrectPassword_ReturnsTrue()
        {
            // Arrange
            string hashedPassword = "ALyuoraY/cIWD1hjo+K81/pf83qo6Q6T+UBYcXN9P3A9WHLvEY10f+lwW5qPG6h9xw=="; // this is for 'my-password'

            // Act
            bool retVal = Crypto.VerifyHashedPassword(hashedPassword, "my-password");

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void VerifyHashedPassword_IncorrectPassword_ReturnsFalse()
        {
            // Arrange
            string hashedPassword = "ALyuoraY/cIWD1hjo+K81/pf83qo6Q6T+UBYcXN9P3A9WHLvEY10f+lwW5qPG6h9xw=="; // this is for 'my-password'

            // Act
            bool retVal = Crypto.VerifyHashedPassword(hashedPassword, "some-other-password");

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void VerifyHashedPassword_InvalidPasswordHash_ReturnsFalse()
        {
            // Arrange
            string hashedPassword = "AAECAw=="; // this is an invalid password hash

            // Act
            bool retVal = Crypto.VerifyHashedPassword(hashedPassword, "hello-world");

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void MD5HashTest_ReturnsValidData()
        {
            string data = "foo bar";
            string expected = "327B6F07435811239BC47E1544353273";
            string actual;
            actual = Crypto.Hash(data, algorithm: "md5");
            Assert.Equal(expected, actual);

            actual = Crypto.Hash(Encoding.UTF8.GetBytes(data), algorithm: "MD5");
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void SHA1HashTest_ReturnsValidData()
        {
            string data = "foo bar";
            string expected = "3773DEA65156909838FA6C22825CAFE090FF8030";
            string actual;
            actual = Crypto.SHA1(data);
            Assert.Equal(expected, actual);

            actual = Crypto.Hash(Encoding.UTF8.GetBytes(data), algorithm: "sha1");
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void SHA1HashTest_WithNull_ThrowsException()
        {
            Assert.Throws<ArgumentNullException>(() => Crypto.SHA1((string)null));
            Assert.Throws<ArgumentNullException>(() => Crypto.Hash((byte[])null, algorithm: "SHa1"));
        }

        [Fact]
        public void SHA256HashTest_WithNull_ThrowsException()
        {
            Assert.Throws<ArgumentNullException>(() => Crypto.SHA256((string)null));
            Assert.Throws<ArgumentNullException>(() => Crypto.Hash((byte[])null, algorithm: "sHa256"));
        }

        [Fact]
        public void MD5HashTest_WithNull_ThrowsException()
        {
            Assert.Throws<ArgumentNullException>(() => Crypto.Hash((string)null, algorithm: "mD5"));
            Assert.Throws<ArgumentNullException>(() => Crypto.Hash((byte[])null, algorithm: "mD5"));
        }

        [Fact]
        public void HashWithUnknownAlg_ThrowsException()
        {
            Assert.Throws<InvalidOperationException>(() => Crypto.Hash("sdflksd", algorithm: "hao"), "The hash algorithm 'hao' is not supported, valid values are: sha256, sha1, md5");
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/DynamicDictionary.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Dynamic;
using System.Linq.Expressions;
using System.Reflection;

namespace System.Web.Helpers.Test
{
    /// <summary>
    /// Dynamic object implementation over a dictionary that doesn't implement anything but the interface.
    /// Used for testing our types that consume dynamic objects to make sure they don't make any assumptions on the implementation.
    /// </summary>
    public class DynamicDictionary : IDynamicMetaObjectProvider
    {
        private readonly Dictionary<string, object> _values = new Dictionary<string, object>();

        public object this[string name]
        {
            get
            {
                object result;
                _values.TryGetValue(name, out result);
                return result;
            }
            set { _values[name] = value; }
        }

        public DynamicMetaObject GetMetaObject(Expression parameter)
        {
            return new DynamicDictionaryMetaObject(parameter, this);
        }

        private class DynamicDictionaryMetaObject : DynamicMetaObject
        {
            private static readonly PropertyInfo ItemPropery = typeof(DynamicDictionary).GetProperty("Item");

            public DynamicDictionaryMetaObject(Expression expression, object value)
                : base(expression, BindingRestrictions.Empty, value)
            {
            }

            private IDictionary<string, object> WrappedDictionary
            {
                get { return ((DynamicDictionary)Value)._values; }
            }

            private Expression GetDynamicExpression()
            {
                return Expression.Convert(Expression, typeof(DynamicDictionary));
            }

            private Expression GetIndexExpression(string key)
            {
                return Expression.MakeIndex(
                    GetDynamicExpression(),
                    ItemPropery,
                    new[]
                    {
                        Expression.Constant(key)
                    }
                    );
            }

            private Expression GetSetValueExpression(string key, object value)
            {
                return Expression.Assign(
                    GetIndexExpression(key),
                    Expression.Convert(Expression.Constant(value),
                                       typeof(object))
                    );
            }

            public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
            {
                var binderDefault = binder.FallbackGetMember(this);

                var expression = Expression.Convert(GetIndexExpression(binder.Name),
                                                    typeof(object));

                var dynamicSuggestion = new DynamicMetaObject(expression, BindingRestrictions.GetTypeRestriction(Expression, LimitType)
                                                                              .Merge(binderDefault.Restrictions));

                return binder.FallbackGetMember(this, dynamicSuggestion);
            }

            public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
            {
                var binderDefault = binder.FallbackSetMember(this, value);

                Expression expression = GetSetValueExpression(binder.Name, value.Value);

                var dynamicSuggestion = new DynamicMetaObject(expression, BindingRestrictions.GetTypeRestriction(Expression, LimitType)
                                                                              .Merge(binderDefault.Restrictions));

                return binder.FallbackSetMember(this, value, dynamicSuggestion);
            }

            public override IEnumerable<string> GetDynamicMemberNames()
            {
                return WrappedDictionary.Keys;
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/DynamicHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Dynamic;
using Microsoft.Internal.Web.Utils;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class DynamicHelperTest
    {
        [Fact]
        public void TryGetMemberValueReturnsValueIfBinderIsNotCSharp()
        {
            // Arrange
            var mockMemberBinder = new MockMemberBinder("Foo");
            var dynamic = new DynamicWrapper(new { Foo = "Bar" });

            // Act
            object value;
            bool result = DynamicHelper.TryGetMemberValue(dynamic, mockMemberBinder, out value);

            // Assert
            Assert.Equal("Bar", value);
        }

        private class MockMemberBinder : GetMemberBinder
        {
            public MockMemberBinder(string name)
                : base(name, false)
            {
            }

            public override DynamicMetaObject FallbackGetMember(DynamicMetaObject target, DynamicMetaObject errorSuggestion)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/DynamicWrapper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Dynamic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;

namespace System.Web.Helpers.Test
{
    /// <summary>
    /// Dynamic object implementation over a regualar CLR object. Getmember accesses members through reflection.
    /// </summary>
    public class DynamicWrapper : IDynamicMetaObjectProvider
    {
        private object _object;

        public DynamicWrapper(object obj)
        {
            _object = obj;
        }

        public DynamicMetaObject GetMetaObject(Expression parameter)
        {
            return new DynamicWrapperMetaObject(parameter, this);
        }

        private class DynamicWrapperMetaObject : DynamicMetaObject
        {
            public DynamicWrapperMetaObject(Expression expression, object value)
                : base(expression, BindingRestrictions.Empty, value)
            {
            }

            private object WrappedObject
            {
                get { return ((DynamicWrapper)Value)._object; }
            }

            private Expression GetDynamicExpression()
            {
                return Expression.Convert(Expression, typeof(DynamicWrapper));
            }

            private Expression GetWrappedObjectExpression()
            {
                FieldInfo fieldInfo = typeof(DynamicWrapper).GetField("_object", BindingFlags.NonPublic | BindingFlags.Instance);
                Debug.Assert(fieldInfo != null);
                return Expression.Convert(
                    Expression.Field(GetDynamicExpression(), fieldInfo),
                    WrappedObject.GetType());
            }

            private Expression GetMemberAccessExpression(string memberName)
            {
                return Expression.Property(
                    GetWrappedObjectExpression(),
                    memberName);
            }

            public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
            {
                var binderDefault = binder.FallbackGetMember(this);

                var expression = Expression.Convert(GetMemberAccessExpression(binder.Name), typeof(object));

                var dynamicSuggestion = new DynamicMetaObject(expression, BindingRestrictions.GetTypeRestriction(Expression, LimitType)
                                                                              .Merge(binderDefault.Restrictions));

                return binder.FallbackGetMember(this, dynamicSuggestion);
            }

            public override IEnumerable<string> GetDynamicMemberNames()
            {
                return (from p in WrappedObject.GetType().GetProperties()
                        orderby p.Name
                        select p.Name).ToArray();
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/HelperResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.WebPages;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    /// <summary>
    /// This is a test class for Util is intended
    /// to contain all HelperResult Unit Tests
    /// </summary>
    public class HelperResultTest
    {
        [Fact]
        public void HelperResultConstructorNullTest()
        {
            Assert.ThrowsArgumentNull(() => { var helper = new HelperResult(null); }, "action");
        }

        [Fact]
        public void ToStringTest()
        {
            var text = "Hello";
            Action<TextWriter> action = tw => tw.Write(text);
            var helper = new HelperResult(action);
            Assert.Equal(text, helper.ToString());
        }

        [Fact]
        public void WriteToTest()
        {
            var text = "Hello";
            Action<TextWriter> action = tw => tw.Write(text);
            var helper = new HelperResult(action);
            var writer = new StringWriter();
            helper.WriteTo(writer);
            Assert.Equal(text, writer.ToString());
        }

        [Fact]
        public void ToHtmlStringDoesNotEncode()
        {
            // Arrange
            string text = "<strong>This is a test & it uses html.</strong>";
            Action<TextWriter> action = writer => writer.Write(text);
            HelperResult helperResult = new HelperResult(action);

            // Act
            string result = helperResult.ToHtmlString();

            // Assert
            Assert.Equal(result, text);
        }

        [Fact]
        public void ToHtmlStringReturnsSameResultAsWriteTo()
        {
            // Arrange
            string text = "<strong>This is a test & it uses html.</strong>";
            Action<TextWriter> action = writer => writer.Write(text);
            HelperResult helperResult = new HelperResult(action);
            StringWriter stringWriter = new StringWriter();

            // Act
            string htmlString = helperResult.ToHtmlString();
            helperResult.WriteTo(stringWriter);

            // Assert
            Assert.Equal(htmlString, stringWriter.ToString());
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/JsonTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Dynamic;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class JsonTest
    {
        [Fact]
        public void EncodeWithDynamicObject()
        {
            // Arrange
            dynamic obj = new DummyDynamicObject();
            obj.Name = "Hello";
            obj.Age = 1;
            obj.Grades = new[] { "A", "B", "C" };

            // Act
            string json = Json.Encode(obj);

            // Assert
            Assert.Equal("{\"Name\":\"Hello\",\"Age\":1,\"Grades\":[\"A\",\"B\",\"C\"]}", json);
        }

        [Fact]
        public void EncodeArray()
        {
            // Arrange
            object input = new string[] { "one", "2", "three", "4" };

            // Act
            string json = Json.Encode(input);

            // Assert
            Assert.Equal("[\"one\",\"2\",\"three\",\"4\"]", json);
        }

        [Fact]
        public void EncodeDynamicJsonArrayEncodesAsArray()
        {
            // Arrange
            dynamic array = Json.Decode("[1,2,3]");

            // Act
            string json = Json.Encode(array);

            // Assert
            Assert.Equal("[1,2,3]", json);
        }

        [Fact]
        public void EncodeObjectWithArrayProperty()
        {
            // Arrange
            dynamic personJson = Json.Decode("{name:'George', aliases: ['Peter', 'David']}");

            // Act
            string json = Json.Encode(personJson);

            // Assert
            Assert.Equal("{\"name\":\"George\",\"aliases\":[\"Peter\",\"David\"]}", json);
        }

        [Fact]
        public void DecodeDynamicObject()
        {
            // Act
            var obj = Json.Decode("{\"Name\":\"Hello\",\"Age\":1,\"Grades\":[\"A\",\"B\",\"C\"]}");

            // Assert
            Assert.Equal("Hello", obj.Name);
            Assert.Equal(1, obj.Age);
            Assert.Equal(3, obj.Grades.Length);
            Assert.Equal("A", obj.Grades[0]);
            Assert.Equal("B", obj.Grades[1]);
            Assert.Equal("C", obj.Grades[2]);
        }

        [Fact]
        public void DecodeDynamicObjectImplicitConversionToDictionary()
        {
            // Act
            IDictionary<string, object> values = Json.Decode("{\"Name\":\"Hello\",\"Age\":1}");

            // Assert
            Assert.Equal("Hello", values["Name"]);
            Assert.Equal(1, values["Age"]);
        }

        [Fact]
        public void DecodeArrayImplicitConversionToArrayAndObjectArray()
        {
            // Act
            Array array = Json.Decode("[1,2,3]");
            object[] objArray = Json.Decode("[1,2,3]");
            IEnumerable<dynamic> dynamicEnumerable = Json.Decode("[{a:1}]");

            // Assert
            Assert.NotNull(array);
            Assert.NotNull(objArray);
            Assert.NotNull(dynamicEnumerable);
        }

        [Fact]
        public void DecodeArrayImplicitConversionToArrayArrayValuesAreDynamic()
        {
            // Act            
            dynamic[] objArray = Json.Decode("[{\"A\":1}]");

            // Assert
            Assert.NotNull(objArray);
            Assert.Equal(1, objArray[0].A);
        }

        [Fact]
        public void DecodeDynamicObjectAccessPropertiesByIndexer()
        {
            // Arrange
            var obj = Json.Decode("{\"Name\":\"Hello\",\"Age\":1,\"Grades\":[\"A\",\"B\",\"C\"]}");

            // Assert
            Assert.Equal("Hello", obj["Name"]);
            Assert.Equal(1, obj["Age"]);
            Assert.Equal(3, obj["Grades"].Length);
            Assert.Equal("A", obj["Grades"][0]);
            Assert.Equal("B", obj["Grades"][1]);
            Assert.Equal("C", obj["Grades"][2]);
        }

        [Fact]
        public void DecodeDynamicObjectAccessPropertiesByNullIndexerReturnsNull()
        {
            // Arrange
            var obj = Json.Decode("{\"Name\":\"Hello\",\"Age\":1,\"Grades\":[\"A\",\"B\",\"C\"]}");

            // Assert
            Assert.Null(obj[null]);
        }

        [Fact]
        public void DecodeDateTime()
        {
            // Act
            DateTime dateTime = Json.Decode("\"\\/Date(940402800000)\\/\"");

            // Assert
            Assert.Equal(1999, dateTime.Year);
            Assert.Equal(10, dateTime.Month);
            Assert.Equal(20, dateTime.Day);
        }

        [Fact]
        public void DecodeNumber()
        {
            // Act
            int number = Json.Decode("1");

            // Assert
            Assert.Equal(1, number);
        }

        [Fact]
        public void DecodeString()
        {
            // Act
            string @string = Json.Decode("\"1\"");

            // Assert
            Assert.Equal("1", @string);
        }

        [Fact]
        public void DecodeArray()
        {
            // Act
            var values = Json.Decode("[11,12,13,14,15]");

            // Assert            
            Assert.Equal(5, values.Length);
            Assert.Equal(11, values[0]);
            Assert.Equal(12, values[1]);
            Assert.Equal(13, values[2]);
            Assert.Equal(14, values[3]);
            Assert.Equal(15, values[4]);
        }

        [Fact]
        public void DecodeObjectWithArrayProperty()
        {
            // Act
            var obj = Json.Decode("{\"A\":1,\"B\":[1,3,4]}");
            object[] bValues = obj.B;

            // Assert
            Assert.Equal(1, obj.A);
            Assert.Equal(1, bValues[0]);
            Assert.Equal(3, bValues[1]);
            Assert.Equal(4, bValues[2]);
        }

        [Fact]
        public void DecodeArrayWithObjectValues()
        {
            // Act
            var obj = Json.Decode("[{\"A\":1},{\"B\":3, \"C\": \"hello\"}]");

            // Assert
            Assert.Equal(2, obj.Length);
            Assert.Equal(1, obj[0].A);
            Assert.Equal(3, obj[1].B);
            Assert.Equal("hello", obj[1].C);
        }

        [Fact]
        public void DecodeArraySetValues()
        {
            // Arrange
            var values = Json.Decode("[1,2,3,4,5]");
            for (int i = 0; i < values.Length; i++)
            {
                values[i]++;
            }

            // Assert
            Assert.Equal(5, values.Length);
            Assert.Equal(2, values[0]);
            Assert.Equal(3, values[1]);
            Assert.Equal(4, values[2]);
            Assert.Equal(5, values[3]);
            Assert.Equal(6, values[4]);
        }

        [Fact]
        public void DecodeArrayPassToMethodThatTakesArray()
        {
            // Arrange
            var values = Json.Decode("[3,2,1]");

            // Act
            int index = Array.IndexOf(values, 2);

            // Assert
            Assert.Equal(1, index);
        }

        [Fact]
        public void DecodeArrayGetEnumerator()
        {
            // Arrange
            var values = Json.Decode("[1,2,3]");

            // Assert
            int val = 1;
            foreach (var value in values)
            {
                Assert.Equal(val, val);
                val++;
            }
        }

        [Fact]
        public void DecodeObjectPropertyAccessIsSameObjectInstance()
        {
            // Arrange
            var obj = Json.Decode("{\"Name\":{\"Version:\":4.0, \"Key\":\"Key\"}}");

            // Assert
            Assert.Same(obj.Name, obj.Name);
        }

        [Fact]
        public void DecodeArrayAccessingMembersThatDontExistReturnsNull()
        {
            // Act
            var obj = Json.Decode("[\"a\", \"b\"]");

            // Assert
            Assert.Null(obj.PropertyThatDoesNotExist);
        }

        [Fact]
        public void DecodeObjectSetProperties()
        {
            // Act
            var obj = Json.Decode("{\"A\":{\"B\":100}}");
            obj.A.B = 20;

            // Assert
            Assert.Equal(20, obj.A.B);
        }

        [Fact]
        public void DecodeObjectSettingObjectProperties()
        {
            // Act
            var obj = Json.Decode("{\"A\":1}");
            obj.A = new { B = 1, D = 2 };

            // Assert
            Assert.Equal(1, obj.A.B);
            Assert.Equal(2, obj.A.D);
        }

        [Fact]
        public void DecodeObjectWithArrayPropertyPassPropertyToMethodThatTakesArray()
        {
            // Arrange
            var obj = Json.Decode("{\"A\":[3,2,1]}");

            // Act
            Array.Sort(obj.A);

            // Assert
            Assert.Equal(1, obj.A[0]);
            Assert.Equal(2, obj.A[1]);
            Assert.Equal(3, obj.A[2]);
        }

        [Fact]
        public void DecodeObjectAccessingMembersThatDontExistReturnsNull()
        {
            // Act
            var obj = Json.Decode("{\"A\":1}");

            // Assert
            Assert.Null(obj.PropertyThatDoesntExist);
        }

        [Fact]
        public void DecodeObjectWithSpecificType()
        {
            // Act
            var person = Json.Decode<Person>("{\"Name\":\"David\", \"Age\":2}");

            // Assert
            Assert.Equal("David", person.Name);
            Assert.Equal(2, person.Age);
        }

        [Fact]
        public void DecodeObjectWithImplicitConversionToNonDynamicTypeThrows()
        {
            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => { Person person = Json.Decode("{\"Name\":\"David\", \"Age\":2, \"Address\":{\"Street\":\"Bellevue\"}}"); }, "Unable to convert to \"System.Web.Helpers.Test.JsonTest+Person\". Use Json.Decode<T> instead.");
        }

        private class DummyDynamicObject : DynamicObject
        {
            private IDictionary<string, object> _values = new Dictionary<string, object>();

            public override IEnumerable<string> GetDynamicMemberNames()
            {
                return _values.Keys;
            }

            public override bool TrySetMember(SetMemberBinder binder, object value)
            {
                _values[binder.Name] = value;
                return true;
            }

            public override bool TryGetMember(GetMemberBinder binder, out object result)
            {
                return _values.TryGetValue(binder.Name, out result);
            }
        }

        private class Person
        {
            public string Name { get; set; }
            public int Age { get; set; }
            public int GPA { get; set; }
            public Address Address { get; set; }
        }

        private class Address
        {
            public string Street { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/ObjectInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Dynamic;
using System.Linq;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class ObjectInfoTest
    {
        [Fact]
        public void PrintWithNegativeDepthThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => ObjectInfo.Print(null, depth: -1), "depth", "0");
        }

        [Fact]
        public void PrintWithInvalidEnumerationLength()
        {
            // Act & Assert
            Assert.ThrowsArgumentGreaterThan(() => ObjectInfo.Print(null, enumerationLength: -1), "enumerationLength", "0");
        }

        [Fact]
        public void PrintWithNull()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();

            // Act
            visitor.Print(null);

            // Assert
            string value = Assert.Single(visitor.Values);
            Assert.Equal("null", value);
        }

        [Fact]
        public void PrintWithEmptyString()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();

            // Act
            visitor.Print(String.Empty);

            // Assert
            string value = Assert.Single(visitor.Values);
            Assert.Equal(String.Empty, value);
        }

        [Fact]
        public void PrintWithInt()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();

            // Act
            visitor.Print(404);

            // Assert
            string value = Assert.Single(visitor.Values);
            Assert.Equal("404", value);
        }

        [Fact]
        public void PrintWithIDictionary()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            IDictionary dict = new OrderedDictionary();
            dict.Add("foo", "bar");
            dict.Add("abc", 500);

            // Act
            visitor.Print(dict);

            // Assert
            Assert.Equal("foo = bar", visitor.KeyValuePairs[0]);
            Assert.Equal("abc = 500", visitor.KeyValuePairs[1]);
        }

        [Fact]
        public void PrintWithIEnumerable()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            var values = Enumerable.Range(0, 10);

            // Act
            visitor.Print(values);

            // Assert
            foreach (var num in values)
            {
                Assert.Contains(num.ToString(), visitor.Values);
            }
        }

        [Fact]
        public void PrintWithGenericIListPrintsIndex()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            var values = Enumerable.Range(0, 10).ToList();

            // Act
            visitor.Print(values);

            // Assert
            for (int i = 0; i < values.Count; i++)
            {
                Assert.Contains(values[i].ToString(), visitor.Values);
                Assert.Contains(i, visitor.Indexes);
            }
        }

        [Fact]
        public void PrintWithArrayPrintsIndex()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            var values = Enumerable.Range(0, 10).ToArray();

            // Act
            visitor.Print(values);

            // Assert
            for (int i = 0; i < values.Length; i++)
            {
                Assert.Contains(values[i].ToString(), visitor.Values);
                Assert.Contains(i, visitor.Indexes);
            }
        }

        [Fact]
        public void PrintNameValueCollectionPrintsKeysAndValues()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            var values = new NameValueCollection();
            values["a"] = "1";
            values["b"] = null;

            // Act
            visitor.Print(values);

            // Assert
            Assert.Equal("a = 1", visitor.KeyValuePairs[0]);
            Assert.Equal("b = null", visitor.KeyValuePairs[1]);
        }

        [Fact]
        public void PrintDateTime()
        {
            using (new CultureReplacer("en-US"))
            {
                // Arrange
                MockObjectVisitor visitor = CreateObjectVisitor();
                var dt = new DateTime(2001, 11, 20, 10, 30, 1);

                // Act
                visitor.Print(dt);

                // Assert
                Assert.Equal("11/20/2001 10:30:01 AM", visitor.Values[0]);
            }
        }

        [Fact]
        public void PrintCustomObjectPrintsMembers()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            var person = new Person
            {
                Name = "David",
                Age = 23.3,
                Dob = new DateTime(1986, 11, 19),
                LongType = 1000000000,
                Type = 1
            };

            using (new CultureReplacer("en-US"))
            {
                // Act
                visitor.Print(person);

                // Assert
                Assert.Equal(9, visitor.Members.Count);
                Assert.Contains("double Age = 23.3", visitor.Members);
                Assert.Contains("string Name = David", visitor.Members);
                Assert.Contains("DateTime Dob = 11/19/1986 12:00:00 AM", visitor.Members);
                Assert.Contains("short Type = 1", visitor.Members);
                Assert.Contains("float Float = 0", visitor.Members);
                Assert.Contains("byte Byte = 0", visitor.Members);
                Assert.Contains("decimal Decimal = 0", visitor.Members);
                Assert.Contains("bool Bool = False", visitor.Members);
            }
        }

        [Fact]
        public void PrintShowsVisitedWhenCircularReferenceInObjectGraph()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            PersonNode node = new PersonNode
            {
                Person = new Person
                {
                    Name = "David",
                    Age = 23.3
                }
            };
            node.Next = node;

            // Act
            visitor.Print(node);

            // Assert
            Assert.Contains("string Name = David", visitor.Members);
            Assert.Contains(String.Format("double Age = {0}", 23.3), visitor.Members);
            Assert.Contains("PersonNode Next = Visited", visitor.Members);
        }

        [Fact]
        public void PrintShowsVisitedWhenCircularReferenceIsIEnumerable()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            List<object> values = new List<object>();
            values.Add(values);

            // Act
            visitor.Print(values);

            // Assert
            Assert.Equal("Visited", visitor.Values[0]);
            Assert.Equal("Visited " + values.GetHashCode(), visitor.Visited[0]);
        }

        [Fact]
        public void PrintShowsVisitedWhenCircularReferenceIsIDictionary()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            OrderedDictionary values = new OrderedDictionary();
            values[values] = values;

            // Act
            visitor.Print(values);

            // Assert
            Assert.Equal("Visited", visitor.Values[0]);
            Assert.Equal("Visited " + values.GetHashCode(), visitor.Visited[0]);
        }

        [Fact]
        public void PrintShowsVisitedWhenCircularReferenceIsNameValueCollection()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            NameValueCollection nameValues = new NameValueCollection();
            nameValues["id"] = "1";
            List<NameValueCollection> values = new List<NameValueCollection>();
            values.Add(nameValues);
            values.Add(nameValues);

            // Act
            visitor.Print(values);

            // Assert
            Assert.Contains("Visited", visitor.Values);
            Assert.Contains("Visited " + nameValues.GetHashCode(), visitor.Visited);
        }

        [Fact]
        public void PrintExcludesWriteOnlyProperties()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            ClassWithWriteOnlyProperty cls = new ClassWithWriteOnlyProperty();

            // Act
            visitor.Print(cls);

            // Assert
            Assert.Empty(visitor.Members);
        }

        [Fact]
        public void PrintWritesEnumeratedElementsUntilLimitIsReached()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            var enumeration = Enumerable.Range(0, 2000);

            // Act
            visitor.Print(enumeration);

            // Assert
            for (int i = 0; i <= 2000; i++)
            {
                if (i < 1000)
                {
                    Assert.Contains(i.ToString(), visitor.Values);
                }
                else
                {
                    Assert.DoesNotContain(i.ToString(), visitor.Values);
                }
            }
            Assert.Contains("Limit Exceeded", visitor.Values);
        }

        [Fact]
        public void PrintWithAnonymousType()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            var value = new { Name = "John", X = 1 };

            // Act
            visitor.Print(value);

            // Assert
            Assert.Contains("string Name = John", visitor.Members);
            Assert.Contains("int X = 1", visitor.Members);
        }

        [Fact]
        public void PrintClassWithPublicFields()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            ClassWithFields value = new ClassWithFields();
            value.Foo = "John";
            value.Bar = 1;

            // Actt
            visitor.Print(value);

            // Assert
            Assert.Contains("string Foo = John", visitor.Members);
            Assert.Contains("int Bar = 1", visitor.Members);
        }

        [Fact]
        public void PrintClassWithDynamicMembersPrintsMembersIfGetDynamicMemberNamesIsImplemented()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            dynamic d = new DynamicDictionary();
            d.Cycle = d;
            d.Name = "Foo";
            d.Value = null;

            // Act
            visitor.Print(d);

            // Assert
            Assert.Contains("DynamicDictionary Cycle = Visited", visitor.Members);
            Assert.Contains("string Name = Foo", visitor.Members);
            Assert.Contains("Value = null", visitor.Members);
        }

        [Fact]
        public void PrintClassWithDynamicMembersReturningNullPrintsNoMembers()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            dynamic d = new ClassWithDynamicAnNullMemberNames();
            d.Cycle = d;
            d.Name = "Foo";
            d.Value = null;

            // Act
            visitor.Print(d);

            // Assert
            Assert.False(visitor.Members.Any());
        }

        [Fact]
        public void PrintUsesToStringOfIConvertibleObjects()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            ConvertibleClass cls = new ConvertibleClass();

            // Act
            visitor.Print(cls);

            // Assert
            Assert.Equal("Test", visitor.Values[0]);
        }

        [Fact]
        public void PrintConvertsTypeToString()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();

            // Act
            visitor.Print(typeof(string));

            // Assert
            Assert.Equal("typeof(string)", visitor.Values[0]);
        }

        [Fact]
        [ReplaceCulture]
        public void PrintClassWithPropertyThatThrowsExceptionPrintsException()
        {
            // Arrange
            MockObjectVisitor visitor = CreateObjectVisitor();
            ClassWithPropertyThatThrowsException value = new ClassWithPropertyThatThrowsException();

            // Act
            visitor.Print(value);

            // Assert
            Assert.Equal("int MyProperty = Property accessor 'MyProperty' on object 'System.Web.Helpers.Test.ObjectInfoTest+ClassWithPropertyThatThrowsException' threw the following exception:'Property that shows an exception'", visitor.Members[0]);
        }

        [Fact]
        public void ConvertEscapeSequencesPrintsStringEscapeSequencesAsLiterals()
        {
            // Act
            string value = HtmlObjectPrinter.ConvertEscapseSequences("\\\'\"\0\a\b\f\n\r\t\v");

            // Assert
            Assert.Equal("\\\\'\\\"\\0\\a\\b\\f\\n\\r\\t\\v", value);
        }

        [Fact]
        public void ConvertEscapeSequencesDoesNotEscapeUnicodeSequences()
        {
            // Act
            string value = HtmlObjectPrinter.ConvertEscapseSequences("\u1023\x2045");

            // Assert
            Assert.Equal("\u1023\x2045", value);
        }

        [Fact]
        public void PrintCharPrintsQuotedString()
        {
            // Arrange
            HtmlObjectPrinter printer = new HtmlObjectPrinter(100, 100);
            HtmlElement element = new HtmlElement("span");
            printer.PushElement(element);

            // Act
            printer.VisitConvertedValue('x', "x");

            // Assert
            Assert.Equal(1, element.Children.Count);
            HtmlElement child = element.Children[0];
            Assert.Equal("'x'", child.InnerText);
            Assert.Equal("quote", child["class"]);
        }

        [Fact]
        public void PrintEscapeCharPrintsEscapedCharAsLiteral()
        {
            // Arrange
            HtmlObjectPrinter printer = new HtmlObjectPrinter(100, 100);
            HtmlElement element = new HtmlElement("span");
            printer.PushElement(element);

            // Act
            printer.VisitConvertedValue('\t', "\t");

            // Assert
            Assert.Equal(1, element.Children.Count);
            HtmlElement child = element.Children[0];
            Assert.Equal("'\\t'", child.InnerText);
            Assert.Equal("quote", child["class"]);
        }

        [Fact]
        public void GetTypeNameConvertsGenericTypesToCsharpSyntax()
        {
            // Act
            string value = ObjectVisitor.GetTypeName(typeof(Func<Func<Func<int, int, object>, Action<int>>>));

            // Assert
            Assert.Equal("Func<Func<Func<int, int, object>, Action<int>>>", value);
        }

        private class ConvertibleClass : IConvertible
        {
            public TypeCode GetTypeCode()
            {
                throw new NotImplementedException();
            }

            public bool ToBoolean(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public byte ToByte(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public char ToChar(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public DateTime ToDateTime(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public decimal ToDecimal(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public double ToDouble(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public short ToInt16(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public int ToInt32(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public long ToInt64(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public sbyte ToSByte(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public float ToSingle(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public string ToString(IFormatProvider provider)
            {
                return "Test";
            }

            public object ToType(Type conversionType, IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public ushort ToUInt16(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public uint ToUInt32(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }

            public ulong ToUInt64(IFormatProvider provider)
            {
                throw new NotImplementedException();
            }
        }

        private class ClassWithPropertyThatThrowsException
        {
            public int MyProperty
            {
                get { throw new InvalidOperationException("Property that shows an exception"); }
            }
        }

        private class ClassWithDynamicAnNullMemberNames : DynamicObject
        {
            public override IEnumerable<string> GetDynamicMemberNames()
            {
                return null;
            }

            public override bool TryGetMember(GetMemberBinder binder, out object result)
            {
                result = null;
                return true;
            }

            public override bool TrySetMember(SetMemberBinder binder, object value)
            {
                return true;
            }
        }

        private class Person
        {
            public string Name { get; set; }
            public double Age { get; set; }
            public DateTime Dob { get; set; }
            public short Type { get; set; }
            public long LongType { get; set; }
            public float Float { get; set; }
            public byte Byte { get; set; }
            public decimal Decimal { get; set; }
            public bool Bool { get; set; }
        }

        private class ClassWithFields
        {
            public string Foo;
            public int Bar = 13;
        }

        private class ClassWithWriteOnlyProperty
        {
            public int Value
            {
                set { }
            }
        }

        private class PersonNode
        {
            public Person Person { get; set; }
            public PersonNode Next { get; set; }
        }

        private MockObjectVisitor CreateObjectVisitor(int recursionLimit = 10, int enumerationLimit = 1000)
        {
            return new MockObjectVisitor(recursionLimit, enumerationLimit);
        }

        private class MockObjectVisitor : ObjectVisitor
        {
            public MockObjectVisitor(int recursionLimit, int enumerationLimit)
                : base(recursionLimit, enumerationLimit)
            {
                Values = new List<string>();
                KeyValuePairs = new List<string>();
                Members = new List<string>();
                Indexes = new List<int>();
                Visited = new List<string>();
            }

            public List<string> Values { get; set; }
            public List<string> KeyValuePairs { get; set; }
            public List<string> Members { get; set; }
            public List<int> Indexes { get; set; }
            public List<string> Visited { get; set; }

            public void Print(object value)
            {
                Visit(value, 0);
            }

            public override void VisitObjectVisitorException(ObjectVisitorException exception)
            {
                Values.Add(exception.InnerException.Message);
            }

            public override void VisitStringValue(string stringValue)
            {
                Values.Add(stringValue);
                base.VisitStringValue(stringValue);
            }

            public override void VisitVisitedObject(string id, object value)
            {
                Visited.Add(String.Format("Visited {0}", id));
                Values.Add("Visited");
                base.VisitVisitedObject(id, value);
            }

            public override void VisitIndexedEnumeratedValue(int index, object item, int depth)
            {
                Indexes.Add(index);
                base.VisitIndexedEnumeratedValue(index, item, depth);
            }

            public override void VisitEnumeratonLimitExceeded()
            {
                Values.Add("Limit Exceeded");
                base.VisitEnumeratonLimitExceeded();
            }

            public override void VisitMember(string name, Type type, object value, int depth)
            {
                base.VisitMember(name, type, value, depth);
                type = type ?? (value != null ? value.GetType() : null);
                if (type == null)
                {
                    Members.Add(String.Format("{0} = null", name));
                }
                else
                {
                    Members.Add(String.Format("{0} {1} = {2}", GetTypeName(type), name, Values.Last()));
                }
            }

            public override void VisitNull()
            {
                Values.Add("null");
                base.VisitNull();
            }

            public override void VisitKeyValue(object key, object value, int depth)
            {
                base.VisitKeyValue(key, value, depth);
                KeyValuePairs.Add(String.Format("{0} = {1}", Values[Values.Count - 2], Values[Values.Count - 1]));
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/PreComputedGridDataSourceTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Test
{
    public class PreComputedGridDataSourceTest
    {
        [Fact]
        public void PreSortedDataSourceReturnsRowCountItWasSpecified()
        {
            // Arrange
            int rows = 20;
            var dataSource = new PreComputedGridDataSource(new WebGrid(GetContext()), values: Enumerable.Range(0, 10).Cast<dynamic>(), totalRows: rows);

            // Act and Assert
            Assert.Equal(rows, dataSource.TotalRowCount);
        }

        [Fact]
        public void PreSortedDataSourceReturnsAllRows()
        {
            // Arrange
            var grid = new WebGrid(GetContext());
            var dataSource = new PreComputedGridDataSource(grid: grid, values: Enumerable.Range(0, 10).Cast<dynamic>(), totalRows: 10);

            // Act
            var rows = dataSource.GetRows(new SortInfo { SortColumn = String.Empty }, 0);

            // Assert
            Assert.Equal(10, rows.Count);
            Assert.Equal(0, rows.First().Value);
            Assert.Equal(9, rows.Last().Value);
        }

        private HttpContextBase GetContext()
        {
            return new Mock<HttpContextBase>().Object;
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/ServerInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Test
{
    public class InfoTest
    {
        [Fact]
        public void ConfigurationReturnsExpectedInfo()
        {
            var configInfo = ServerInfo.Configuration();

            // verification
            // checks only subset of values
            Assert.NotNull(configInfo);
            VerifyKey(configInfo, "Machine Name");
            VerifyKey(configInfo, "OS Version");
            VerifyKey(configInfo, "ASP.NET Version");
            VerifyKey(configInfo, "ASP.NET Web Pages Version");
        }

        [Fact]
        public void EnvironmentVariablesReturnsExpectedInfo()
        {
            var envVariables = ServerInfo.EnvironmentVariables();

            // verification
            // checks only subset of values
            Assert.NotNull(envVariables);
            VerifyKey(envVariables, "Path");
            VerifyKey(envVariables, "SystemDrive");
        }

        [Fact]
        public void ServerVariablesReturnsExpectedInfoWithNoContext()
        {
            var serverVariables = ServerInfo.ServerVariables();

            // verification
            // since there is no HttpContext this will be empty
            Assert.NotNull(serverVariables);
        }

        [Fact]
        public void ServerVariablesReturnsExpectedInfoWthContext()
        {
            var serverVariables = new NameValueCollection();
            serverVariables.Add("foo", "bar");

            var request = new Mock<HttpRequestBase>();
            request.Setup(c => c.ServerVariables).Returns(serverVariables);

            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Request).Returns(request.Object);

            // verification
            Assert.NotNull(serverVariables);

            IDictionary<string, string> returnedValues = ServerInfo.ServerVariables(context.Object);
            Assert.Equal(serverVariables.Count, returnedValues.Count);
            foreach (var item in returnedValues)
            {
                Assert.Equal(serverVariables[item.Key], item.Value);
            }
        }

#if false // Avoid an NRE when accessing HttpRuntime.BinDirectory without initializing the runtime.
        [Fact]
        public void HttpRuntimeInfoReturnsExpectedInfo()
        {
            var httpRuntimeInfo = ServerInfo.HttpRuntimeInfo();

            // verification
            // checks only subset of values
            Assert.NotNull(httpRuntimeInfo);
            VerifyKey(httpRuntimeInfo, "CLR Install Directory");
            VerifyKey(httpRuntimeInfo, "Asp Install Directory");
            VerifyKey(httpRuntimeInfo, "On UNC Share");
        }
#endif

        [Fact]
        public void ServerInfoDoesNotProduceLegacyCasForHomogenousAppDomain()
        {
            // Act and Assert
            Action action = () =>
            {
                IDictionary<string, string> configValue = ServerInfo.LegacyCAS(AppDomain.CurrentDomain);

                Assert.NotNull(configValue);
                Assert.Equal(0, configValue.Count);
            };

            AppDomainUtils.RunInSeparateAppDomain(GetAppDomainSetup(legacyCasEnabled: false), action);
        }

        [Fact]
        public void ServerInfoProducesLegacyCasForNonHomogenousAppDomain()
        {
            // Arrange
            Action action = () =>
            {
                // Act and Assert
                IDictionary<string, string> configValue = ServerInfo.LegacyCAS(AppDomain.CurrentDomain);

                // Assert
                Assert.True(configValue.ContainsKey("Legacy Code Access Security"));
                Assert.Equal("Legacy Code Access Security has been detected on your system. Microsoft WebPage features require the ASP.NET 4 Code Access Security model. For information about how to resolve this, contact your server administrator.", configValue["Legacy Code Access Security"]);
            };

            AppDomainUtils.RunInSeparateAppDomain(GetAppDomainSetup(legacyCasEnabled: true), action);
        }

        //[Fact]
        //public void SqlServerInfoReturnsExpectedInfo() {
        //    var sqlInfo = ServerInfo.SqlServerInfo();

        //    // verification
        //    // just verifies that we don't get any unexpected exceptions
        //    Assert.NotNull(sqlInfo);
        //}

#if false // Avoid NREs when accessing HttpRuntime.BinDirectory without initializing the runtime.
        [Fact]
        public void RenderResultContainsExpectedTags()
        {
            var htmlString = ServerInfo.GetHtml().ToString();

            // just verify that the final HTML produced contains some expected info
            Assert.True(htmlString.Contains("<table class=\"server-info\" dir=\"ltr\">"));
            Assert.True(htmlString.Contains("</style>"));
            Assert.True(htmlString.Contains("Server Configuration"));
        }

        [Fact]
        public void RenderGeneratesValidXhtml()
        {
            // Result does not validate against XHTML 1.1 and HTML5 because ServerInfo generates
            // <style> inside <body>. This is by design however since we only use ServerInfo
            // as debugging aid, not something to be permanently added to a web page.
            XhtmlAssert.Validate1_0(
                ServerInfo.GetHtml(),
                addRoot: true
                );
        }
#endif

        private void VerifyKey(IDictionary<string, string> info, string key)
        {
            Assert.True(info.ContainsKey(key));
            Assert.False(String.IsNullOrEmpty(info[key]));
        }

        private AppDomainSetup GetAppDomainSetup(bool legacyCasEnabled)
        {
            var setup = new AppDomainSetup();
            if (legacyCasEnabled)
            {
                setup.SetCompatibilitySwitches(new[] { "NetFx40_LegacySecurityPolicy" });
            }
            return setup;
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/System.Web.Helpers.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{D3313BDF-8071-4AC8-9D98-ABF7F9E88A57}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Helpers.Test</RootNamespace>
    <AssemblyName>System.Web.Helpers.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.DataVisualization" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.XML" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="ChartTest.cs" />
    <Compile Include="ConversionUtilTest.cs" />
    <Compile Include="CryptoTest.cs" />
    <Compile Include="DynamicDictionary.cs" />
    <Compile Include="DynamicHelperTest.cs" />
    <Compile Include="DynamicWrapper.cs" />
    <Compile Include="JsonTest.cs" />
    <Compile Include="ObjectInfoTest.cs" />
    <Compile Include="PreComputedGridDataSourceTest.cs" />
    <Compile Include="WebCacheTest.cs" />
    <Compile Include="HelperResultTest.cs" />
    <Compile Include="ServerInfoTest.cs" />
    <Compile Include="WebGridDataSourceTest.cs" />
    <Compile Include="WebGridTest.cs" />
    <Compile Include="WebImageTest.cs" />
    <Compile Include="WebMailTest.cs" />
    <Compile Include="XhtmlAssert.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9B7E3740-6161-4548-833C-4BBCA43B970E}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\LambdaFinal.jpg" />
    <EmbeddedResource Include="TestFiles\logo.bmp" />
    <EmbeddedResource Include="TestFiles\NETLogo.png" />
    <EmbeddedResource Include="TestFiles\Test.ico" />
    <EmbeddedResource Include="TestFiles\xhtml11-flat.dtd" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Helpers.Test/TestFiles/xhtml11-flat.dtd
================================================
<!-- ....................................................................... -->
<!-- XHTML 1.1 DTD  ........................................................ -->
<!-- file: xhtml11.dtd
-->

<!-- XHTML 1.1 DTD

     This is XHTML, a reformulation of HTML as a modular XML application.

     The Extensible HyperText Markup Language (XHTML)
     Copyright 1998-2000 World Wide Web Consortium
        (Massachusetts Institute of Technology, Institut National de
         Recherche en Informatique et en Automatique, Keio University).
         All Rights Reserved.

     Permission to use, copy, modify and distribute the XHTML DTD and its 
     accompanying documentation for any purpose and without fee is hereby 
     granted in perpetuity, provided that the above copyright notice and 
     this paragraph appear in all copies.  The copyright holders make no 
     representation about the suitability of the DTD for any purpose.

     It is provided "as is" without expressed or implied warranty.

        Author:     Murray M. Altheim <altheim@eng.sun.com>
        Revision:   $Id: xhtml11.dtd,v 1.20 2001/04/05 14:20:51 ahby Exp $

-->
<!-- This is the driver file for version 1.1 of the XHTML DTD.

     Please use this formal public identifier to identify it:

         "-//W3C//DTD XHTML 1.1//EN"
-->
<!ENTITY % XHTML.version  "-//W3C//DTD XHTML 1.1//EN" >

<!-- Use this URI to identify the default namespace:

         "http://www.w3.org/1999/xhtml"

     See the Qualified Names module for information
     on the use of namespace prefixes in the DTD.
-->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % XHTML.prefix "" >

<!-- Reserved for use with the XLink namespace:
-->
<!ENTITY % XLINK.xmlns "" >
<!ENTITY % XLINK.xmlns.attrib "" >

<!-- For example, if you are using XHTML 1.1 directly, use the FPI
     in the DOCTYPE declaration, with the xmlns attribute on the
     document element to identify the default namespace:

       <?xml version="1.0"?>
       <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "xhtml11.dtd">
       <html xmlns="http://www.w3.org/1999/xhtml"
             xml:lang="en">
       ...
       </html>

     Revisions:
     (none)
-->

<!-- reserved for future use with document profiles -->
<!ENTITY % XHTML.profile  "" >

<!-- Bidirectional Text features
     This feature-test entity is used to declare elements
     and attributes used for bidirectional text support.
-->
<!ENTITY % XHTML.bidi  "INCLUDE" >

<?doc type="doctype" role="title" { XHTML 1.1 } ?>

<!-- ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: -->

<!-- Pre-Framework Redeclaration placeholder  .................... -->
<!-- this serves as a location to insert markup declarations
     into the DTD prior to the framework declarations.
-->
<!ENTITY % xhtml-prefw-redecl.module "IGNORE" >
<![%xhtml-prefw-redecl.module;[
%xhtml-prefw-redecl.mod;
<!-- end of xhtml-prefw-redecl.module -->]]>

<!ENTITY % xhtml-events.module "INCLUDE" >

<!-- Inline Style Module  ........................................ -->
<!ENTITY % xhtml-inlstyle.module "INCLUDE" >
<![%xhtml-inlstyle.module;[
<!ENTITY % xhtml-inlstyle.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Inline Style 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-inlstyle-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Inline Style Module  ........................................... -->
<!-- file: xhtml-inlstyle-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-inlstyle-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML Inline Style 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-inlstyle-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Inline Style

     This module declares the 'style' attribute, used to support inline
     style markup. This module must be instantiated prior to the XHTML
     Common Attributes module in order to be included in %Core.attrib;.
-->

<!ENTITY % style.attrib
     "style        CDATA                    #IMPLIED"
>


<!ENTITY % Core.extra.attrib
     "%style.attrib;"
>

<!-- end of xhtml-inlstyle-1.mod -->
]]>

<!-- declare Document Model module instantiated in framework
-->
<!ENTITY % xhtml-model.mod
     PUBLIC "-//W3C//ENTITIES XHTML 1.1 Document Model 1.0//EN"
            "xhtml11-model-1.mod" >

<!-- Modular Framework Module (required) ......................... -->
<!ENTITY % xhtml-framework.module "INCLUDE" >
<![%xhtml-framework.module;[
<!ENTITY % xhtml-framework.mod
     PUBLIC "-//W3C//ENTITIES XHTML Modular Framework 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-framework-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Modular Framework Module  ...................................... -->
<!-- file: xhtml-framework-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-framework-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML Modular Framework 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-framework-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Modular Framework

     This required module instantiates the modules needed
     to support the XHTML modularization model, including:

        +  notations
        +  datatypes
        +  namespace-qualified names
        +  common attributes
        +  document model
        +  character entities

     The Intrinsic Events module is ignored by default but
     occurs in this module because it must be instantiated
     prior to Attributes but after Datatypes.
-->

<!ENTITY % xhtml-arch.module "IGNORE" >
<![%xhtml-arch.module;[
<!ENTITY % xhtml-arch.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Base Architecture 1.0//EN"
            "xhtml-arch-1.mod" >
%xhtml-arch.mod;]]>

<!ENTITY % xhtml-notations.module "INCLUDE" >
<![%xhtml-notations.module;[
<!ENTITY % xhtml-notations.mod
     PUBLIC "-//W3C//NOTATIONS XHTML Notations 1.0//EN"
            "xhtml-notations-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Notations Module  .............................................. -->
<!-- file: xhtml-notations-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-notations-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//NOTATIONS XHTML Notations 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-notations-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Notations

     defines the following notations, many of these imported from
     other specifications and standards. When an existing FPI is
     known, it is incorporated here.
-->

<!-- XML Notations ..................................... -->
<!-- SGML and XML Notations ............................ -->

<!-- W3C XML 1.0 Recommendation -->
<!NOTATION w3c-xml
     PUBLIC "ISO 8879//NOTATION Extensible Markup Language (XML) 1.0//EN" >

<!-- XML 1.0 CDATA -->
<!NOTATION cdata
     PUBLIC "-//W3C//NOTATION XML 1.0: CDATA//EN" >

<!-- SGML Formal Public Identifiers -->
<!NOTATION fpi
     PUBLIC "ISO 8879:1986//NOTATION Formal Public Identifier//EN" >

<!-- XHTML Notations ................................... -->

<!-- Length defined for cellpadding/cellspacing -->

<!-- nn for pixels or nn% for percentage length -->
<!NOTATION length
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Length//EN" >

<!-- space-separated list of link types -->
<!NOTATION linkTypes
    PUBLIC "-//W3C//NOTATION XHTML Datatype: LinkTypes//EN" >

<!-- single or comma-separated list of media descriptors -->
<!NOTATION mediaDesc
    PUBLIC "-//W3C//NOTATION XHTML Datatype: MediaDesc//EN" >

<!-- pixel, percentage, or relative -->
<!NOTATION multiLength
    PUBLIC "-//W3C//NOTATION XHTML Datatype: MultiLength//EN" >

<!-- one or more digits (NUMBER) -->
<!NOTATION number
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Number//EN" >

<!-- integer representing length in pixels -->
<!NOTATION pixels
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Pixels//EN" >

<!-- script expression -->
<!NOTATION script
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Script//EN" >

<!-- textual content -->
<!NOTATION text
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Text//EN" >

<!-- Imported Notations ................................ -->

<!-- a single character from [ISO10646] -->
<!NOTATION character
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Character//EN" >

<!-- a character encoding, as per [RFC2045] -->
<!NOTATION charset
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Charset//EN" >

<!-- a space separated list of character encodings, as per [RFC2045] -->
<!NOTATION charsets
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Charsets//EN" >

<!-- media type, as per [RFC2045] -->
<!NOTATION contentType
    PUBLIC "-//W3C//NOTATION XHTML Datatype: ContentType//EN" >

<!-- comma-separated list of media types, as per [RFC2045] -->
<!NOTATION contentTypes
    PUBLIC "-//W3C//NOTATION XHTML Datatype: ContentTypes//EN" >

<!-- date and time information. ISO date format -->
<!NOTATION datetime
    PUBLIC "-//W3C//NOTATION XHTML Datatype: Datetime//EN" >

<!-- a language code, as per [RFC3066] -->
<!NOTATION languageCode
    PUBLIC "-//W3C//NOTATION XHTML Datatype: LanguageCode//EN" >

<!-- a Uniform Resource Identifier, see [URI] -->
<!NOTATION uri
    PUBLIC "-//W3C//NOTATION XHTML Datatype: URI//EN" >

<!-- a space-separated list of Uniform Resource Identifiers, see [URI] -->
<!NOTATION uris
    PUBLIC "-//W3C//NOTATION XHTML Datatype: URIs//EN" >

<!-- end of xhtml-notations-1.mod -->
]]>

<!ENTITY % xhtml-datatypes.module "INCLUDE" >
<![%xhtml-datatypes.module;[
<!ENTITY % xhtml-datatypes.mod
     PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
            "xhtml-datatypes-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Datatypes Module  .............................................. -->
<!-- file: xhtml-datatypes-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-datatypes-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-datatypes-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Datatypes

     defines containers for the following datatypes, many of
     these imported from other specifications and standards.
-->

<!-- Length defined for cellpadding/cellspacing -->

<!-- nn for pixels or nn% for percentage length -->
<!ENTITY % Length.datatype "CDATA" >

<!-- space-separated list of link types -->
<!ENTITY % LinkTypes.datatype "NMTOKENS" >

<!-- single or comma-separated list of media descriptors -->
<!ENTITY % MediaDesc.datatype "CDATA" >

<!-- pixel, percentage, or relative -->
<!ENTITY % MultiLength.datatype "CDATA" >

<!-- one or more digits (NUMBER) -->
<!ENTITY % Number.datatype "CDATA" >

<!-- integer representing length in pixels -->
<!ENTITY % Pixels.datatype "CDATA" >

<!-- script expression -->
<!ENTITY % Script.datatype "CDATA" >

<!-- textual content -->
<!ENTITY % Text.datatype "CDATA" >

<!-- Imported Datatypes ................................ -->

<!-- a single character from [ISO10646] -->
<!ENTITY % Character.datatype "CDATA" >

<!-- a character encoding, as per [RFC2045] -->
<!ENTITY % Charset.datatype "CDATA" >

<!-- a space separated list of character encodings, as per [RFC2045] -->
<!ENTITY % Charsets.datatype "CDATA" >

<!-- media type, as per [RFC2045] -->
<!ENTITY % ContentType.datatype "CDATA" >

<!-- comma-separated list of media types, as per [RFC2045] -->
<!ENTITY % ContentTypes.datatype "CDATA" >

<!-- date and time information. ISO date format -->
<!ENTITY % Datetime.datatype "CDATA" >

<!-- formal public identifier, as per [ISO8879] -->
<!ENTITY % FPI.datatype "CDATA" >

<!-- a language code, as per [RFC3066] -->
<!ENTITY % LanguageCode.datatype "NMTOKEN" >

<!-- a Uniform Resource Identifier, see [URI] -->
<!ENTITY % URI.datatype "CDATA" >

<!-- a space-separated list of Uniform Resource Identifiers, see [URI] -->
<!ENTITY % URIs.datatype "CDATA" >

<!-- end of xhtml-datatypes-1.mod -->
]]>

<!-- placeholder for XLink support module -->
<!ENTITY % xhtml-xlink.mod "" >


<!ENTITY % xhtml-qname.module "INCLUDE" >
<![%xhtml-qname.module;[
<!ENTITY % xhtml-qname.mod
     PUBLIC "-//W3C//ENTITIES XHTML Qualified Names 1.0//EN"
            "xhtml-qname-1.mod" >
<!-- ....................................................................... -->
<!-- XHTML Qname Module  ................................................... -->
<!-- file: xhtml-qname-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-qname-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML Qualified Names 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-qname-1.mod"

     Revisions:
#2000-10-22: added qname declarations for ruby elements
     ....................................................................... -->

<!-- XHTML Qname (Qualified Name) Module

     This module is contained in two parts, labeled Section 'A' and 'B':

       Section A declares parameter entities to support namespace-
       qualified names, namespace declarations, and name prefixing
       for XHTML and extensions.

       Section B declares parameter entities used to provide
       namespace-qualified names for all XHTML element types:

         %applet.qname;   the xmlns-qualified name for <applet>
         %base.qname;     the xmlns-qualified name for <base>
         ...

     XHTML extensions would create a module similar to this one.
     Included in the XHTML distribution is a template module
     ('template-qname-1.mod') suitable for this purpose.
-->

<!-- Section A: XHTML XML Namespace Framework :::::::::::::::::::: -->

<!-- 1. Declare a %XHTML.prefixed; conditional section keyword, used
        to activate namespace prefixing. The default value should
        inherit '%NS.prefixed;' from the DTD driver, so that unless
        overridden, the default behaviour follows the overall DTD
        prefixing scheme.
-->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % XHTML.prefixed "%NS.prefixed;" >

<!-- 2. Declare a parameter entity (eg., %XHTML.xmlns;) containing
        the URI reference used to identify the XHTML namespace:
-->
<!ENTITY % XHTML.xmlns  "http://www.w3.org/1999/xhtml" >

<!-- 3. Declare parameter entities (eg., %XHTML.prefix;) containing
        the default namespace prefix string(s) to use when prefixing
        is enabled. This may be overridden in the DTD driver or the
        internal subset of an document instance. If no default prefix
        is desired, this may be declared as an empty string.

     NOTE: As specified in [XMLNAMES], the namespace prefix serves
     as a proxy for the URI reference, and is not in itself significant.
-->
<!ENTITY % XHTML.prefix  "" >

<!-- 4. Declare parameter entities (eg., %XHTML.pfx;) containing the
        colonized prefix(es) (eg., '%XHTML.prefix;:') used when
        prefixing is active, an empty string when it is not.
-->
<![%XHTML.prefixed;[
<!ENTITY % XHTML.pfx  "%XHTML.prefix;:" >
]]>
<!ENTITY % XHTML.pfx  "" >

<!-- declare qualified name extensions here ............ -->
<!ENTITY % xhtml-qname-extra.mod "" >


<!-- 5. The parameter entity %XHTML.xmlns.extra.attrib; may be
        redeclared to contain any non-XHTML namespace declaration
        attributes for namespaces embedded in XHTML. The default
        is an empty string.  XLink should be included here if used
        in the DTD.
-->
<!ENTITY % XHTML.xmlns.extra.attrib "" >

<!-- The remainder of Section A is only followed in XHTML, not extensions. -->

<!-- Declare a parameter entity %NS.decl.attrib; containing
     all XML Namespace declarations used in the DTD, plus the
     xmlns declaration for XHTML, its form dependent on whether
     prefixing is active.
-->
<![%XHTML.prefixed;[
<!ENTITY % NS.decl.attrib
     "xmlns:%XHTML.prefix;  %URI.datatype;   #FIXED '%XHTML.xmlns;'
      %XHTML.xmlns.extra.attrib;"
>
]]>
<!ENTITY % NS.decl.attrib
     "%XHTML.xmlns.extra.attrib;"
>

<!-- This is a placeholder for future XLink support.
-->
<!ENTITY % XLINK.xmlns.attrib "" >

<!-- Declare a parameter entity %NS.decl.attrib; containing all
     XML namespace declaration attributes used by XHTML, including
     a default xmlns attribute when prefixing is inactive.
-->
<![%XHTML.prefixed;[
<!ENTITY % XHTML.xmlns.attrib
     "%NS.decl.attrib;
      %XLINK.xmlns.attrib;"
>
]]>
<!ENTITY % XHTML.xmlns.attrib
     "xmlns        %URI.datatype;           #FIXED '%XHTML.xmlns;'
      %XLINK.xmlns.attrib;"
>

<!-- placeholder for qualified name redeclarations -->
<!ENTITY % xhtml-qname.redecl "" >


<!-- Section B: XHTML Qualified Names ::::::::::::::::::::::::::::: -->

<!-- 6. This section declares parameter entities used to provide
        namespace-qualified names for all XHTML element types.
-->

<!-- module:  xhtml-applet-1.mod -->
<!ENTITY % applet.qname  "%XHTML.pfx;applet" >

<!-- module:  xhtml-base-1.mod -->
<!ENTITY % base.qname    "%XHTML.pfx;base" >

<!-- module:  xhtml-bdo-1.mod -->
<!ENTITY % bdo.qname     "%XHTML.pfx;bdo" >

<!-- module:  xhtml-blkphras-1.mod -->
<!ENTITY % address.qname "%XHTML.pfx;address" >
<!ENTITY % blockquote.qname  "%XHTML.pfx;blockquote" >
<!ENTITY % pre.qname     "%XHTML.pfx;pre" >
<!ENTITY % h1.qname      "%XHTML.pfx;h1" >
<!ENTITY % h2.qname      "%XHTML.pfx;h2" >
<!ENTITY % h3.qname      "%XHTML.pfx;h3" >
<!ENTITY % h4.qname      "%XHTML.pfx;h4" >
<!ENTITY % h5.qname      "%XHTML.pfx;h5" >
<!ENTITY % h6.qname      "%XHTML.pfx;h6" >

<!-- module:  xhtml-blkpres-1.mod -->
<!ENTITY % hr.qname      "%XHTML.pfx;hr" >

<!-- module:  xhtml-blkstruct-1.mod -->
<!ENTITY % div.qname     "%XHTML.pfx;div" >
<!ENTITY % p.qname       "%XHTML.pfx;p" >

<!-- module:  xhtml-edit-1.mod -->
<!ENTITY % ins.qname     "%XHTML.pfx;ins" >
<!ENTITY % del.qname     "%XHTML.pfx;del" >

<!-- module:  xhtml-form-1.mod -->
<!ENTITY % form.qname    "%XHTML.pfx;form" >
<!ENTITY % label.qname   "%XHTML.pfx;label" >
<!ENTITY % input.qname   "%XHTML.pfx;input" >
<!ENTITY % select.qname  "%XHTML.pfx;select" >
<!ENTITY % optgroup.qname  "%XHTML.pfx;optgroup" >
<!ENTITY % option.qname  "%XHTML.pfx;option" >
<!ENTITY % textarea.qname  "%XHTML.pfx;textarea" >
<!ENTITY % fieldset.qname  "%XHTML.pfx;fieldset" >
<!ENTITY % legend.qname  "%XHTML.pfx;legend" >
<!ENTITY % button.qname  "%XHTML.pfx;button" >

<!-- module:  xhtml-hypertext-1.mod -->
<!ENTITY % a.qname       "%XHTML.pfx;a" >

<!-- module:  xhtml-image-1.mod -->
<!ENTITY % img.qname     "%XHTML.pfx;img" >

<!-- module:  xhtml-inlphras-1.mod -->
<!ENTITY % abbr.qname    "%XHTML.pfx;abbr" >
<!ENTITY % acronym.qname "%XHTML.pfx;acronym" >
<!ENTITY % cite.qname    "%XHTML.pfx;cite" >
<!ENTITY % code.qname    "%XHTML.pfx;code" >
<!ENTITY % dfn.qname     "%XHTML.pfx;dfn" >
<!ENTITY % em.qname      "%XHTML.pfx;em" >
<!ENTITY % kbd.qname     "%XHTML.pfx;kbd" >
<!ENTITY % q.qname       "%XHTML.pfx;q" >
<!ENTITY % samp.qname    "%XHTML.pfx;samp" >
<!ENTITY % strong.qname  "%XHTML.pfx;strong" >
<!ENTITY % var.qname     "%XHTML.pfx;var" >

<!-- module:  xhtml-inlpres-1.mod -->
<!ENTITY % b.qname       "%XHTML.pfx;b" >
<!ENTITY % big.qname     "%XHTML.pfx;big" >
<!ENTITY % i.qname       "%XHTML.pfx;i" >
<!ENTITY % small.qname   "%XHTML.pfx;small" >
<!ENTITY % sub.qname     "%XHTML.pfx;sub" >
<!ENTITY % sup.qname     "%XHTML.pfx;sup" >
<!ENTITY % tt.qname      "%XHTML.pfx;tt" >

<!-- module:  xhtml-inlstruct-1.mod -->
<!ENTITY % br.qname      "%XHTML.pfx;br" >
<!ENTITY % span.qname    "%XHTML.pfx;span" >

<!-- module:  xhtml-ismap-1.mod (also csismap, ssismap) -->
<!ENTITY % map.qname     "%XHTML.pfx;map" >
<!ENTITY % area.qname    "%XHTML.pfx;area" >

<!-- module:  xhtml-link-1.mod -->
<!ENTITY % link.qname    "%XHTML.pfx;link" >

<!-- module:  xhtml-list-1.mod -->
<!ENTITY % dl.qname      "%XHTML.pfx;dl" >
<!ENTITY % dt.qname      "%XHTML.pfx;dt" >
<!ENTITY % dd.qname      "%XHTML.pfx;dd" >
<!ENTITY % ol.qname      "%XHTML.pfx;ol" >
<!ENTITY % ul.qname      "%XHTML.pfx;ul" >
<!ENTITY % li.qname      "%XHTML.pfx;li" >

<!-- module:  xhtml-meta-1.mod -->
<!ENTITY % meta.qname    "%XHTML.pfx;meta" >

<!-- module:  xhtml-param-1.mod -->
<!ENTITY % param.qname   "%XHTML.pfx;param" >

<!-- module:  xhtml-object-1.mod -->
<!ENTITY % object.qname  "%XHTML.pfx;object" >

<!-- module:  xhtml-script-1.mod -->
<!ENTITY % script.qname  "%XHTML.pfx;script" >
<!ENTITY % noscript.qname  "%XHTML.pfx;noscript" >

<!-- module:  xhtml-struct-1.mod -->
<!ENTITY % html.qname    "%XHTML.pfx;html" >
<!ENTITY % head.qname    "%XHTML.pfx;head" >
<!ENTITY % title.qname   "%XHTML.pfx;title" >
<!ENTITY % body.qname    "%XHTML.pfx;body" >

<!-- module:  xhtml-style-1.mod -->
<!ENTITY % style.qname   "%XHTML.pfx;style" >

<!-- module:  xhtml-table-1.mod -->
<!ENTITY % table.qname   "%XHTML.pfx;table" >
<!ENTITY % caption.qname "%XHTML.pfx;caption" >
<!ENTITY % thead.qname   "%XHTML.pfx;thead" >
<!ENTITY % tfoot.qname   "%XHTML.pfx;tfoot" >
<!ENTITY % tbody.qname   "%XHTML.pfx;tbody" >
<!ENTITY % colgroup.qname  "%XHTML.pfx;colgroup" >
<!ENTITY % col.qname     "%XHTML.pfx;col" >
<!ENTITY % tr.qname      "%XHTML.pfx;tr" >
<!ENTITY % th.qname      "%XHTML.pfx;th" >
<!ENTITY % td.qname      "%XHTML.pfx;td" >

<!-- module:  xhtml-ruby-1.mod -->

<!ENTITY % ruby.qname    "%XHTML.pfx;ruby" >
<!ENTITY % rbc.qname     "%XHTML.pfx;rbc" >
<!ENTITY % rtc.qname     "%XHTML.pfx;rtc" >
<!ENTITY % rb.qname      "%XHTML.pfx;rb" >
<!ENTITY % rt.qname      "%XHTML.pfx;rt" >
<!ENTITY % rp.qname      "%XHTML.pfx;rp" >

<!-- Provisional XHTML 2.0 Qualified Names  ...................... -->

<!-- module:  xhtml-image-2.mod -->
<!ENTITY % alt.qname     "%XHTML.pfx;alt" >

<!-- end of xhtml-qname-1.mod -->
]]>

<!ENTITY % xhtml-events.module "IGNORE" >
<![%xhtml-events.module;[
<!ENTITY % xhtml-events.mod
     PUBLIC "-//W3C//ENTITIES XHTML Intrinsic Events 1.0//EN"
            "xhtml-events-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Intrinsic Events Module  ....................................... -->
<!-- file: xhtml-events-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-events-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML Intrinsic Events 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-events-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Intrinsic Event Attributes

     These are the event attributes defined in HTML 4.0,
     Section 18.2.3 "Intrinsic Events". This module must be
     instantiated prior to the Attributes Module but after
     the Datatype Module in the Modular Framework module.

    "Note: Authors of HTML documents are advised that changes
     are likely to occur in the realm of intrinsic events
     (e.g., how scripts are bound to events). Research in
     this realm is carried on by members of the W3C Document
     Object Model Working Group (see the W3C Web site at
     http://www.w3.org/ for more information)."
-->
<!-- NOTE: Because the ATTLIST declarations in this module occur
     before their respective ELEMENT declarations in other
     modules, there may be a dependency on this module that
     should be considered if any of the parameter entities used
     for element type names (eg., %a.qname;) are redeclared.
-->

<!ENTITY % Events.attrib
     "onclick      %Script.datatype;        #IMPLIED
      ondblclick   %Script.datatype;        #IMPLIED
      onmousedown  %Script.datatype;        #IMPLIED
      onmouseup    %Script.datatype;        #IMPLIED
      onmouseover  %Script.datatype;        #IMPLIED
      onmousemove  %Script.datatype;        #IMPLIED
      onmouseout   %Script.datatype;        #IMPLIED
      onkeypress   %Script.datatype;        #IMPLIED
      onkeydown    %Script.datatype;        #IMPLIED
      onkeyup      %Script.datatype;        #IMPLIED"
>

<!-- additional attributes on anchor element
-->
<!ATTLIST %a.qname;
     onfocus      %Script.datatype;         #IMPLIED
     onblur       %Script.datatype;         #IMPLIED
>

<!-- additional attributes on form element
-->
<!ATTLIST %form.qname;
      onsubmit     %Script.datatype;        #IMPLIED
      onreset      %Script.datatype;        #IMPLIED
>

<!-- additional attributes on label element
-->
<!ATTLIST %label.qname;
      onfocus      %Script.datatype;        #IMPLIED
      onblur       %Script.datatype;        #IMPLIED
>

<!-- additional attributes on input element
-->
<!ATTLIST %input.qname;
      onfocus      %Script.datatype;        #IMPLIED
      onblur       %Script.datatype;        #IMPLIED
      onselect     %Script.datatype;        #IMPLIED
      onchange     %Script.datatype;        #IMPLIED
>

<!-- additional attributes on select element
-->
<!ATTLIST %select.qname;
      onfocus      %Script.datatype;        #IMPLIED
      onblur       %Script.datatype;        #IMPLIED
      onchange     %Script.datatype;        #IMPLIED
>

<!-- additional attributes on textarea element
-->
<!ATTLIST %textarea.qname;
      onfocus      %Script.datatype;        #IMPLIED
      onblur       %Script.datatype;        #IMPLIED
      onselect     %Script.datatype;        #IMPLIED
      onchange     %Script.datatype;        #IMPLIED
>

<!-- additional attributes on button element
-->
<!ATTLIST %button.qname;
      onfocus      %Script.datatype;        #IMPLIED
      onblur       %Script.datatype;        #IMPLIED
>

<!-- additional attributes on body element
-->
<!ATTLIST %body.qname;
      onload       %Script.datatype;        #IMPLIED
      onunload     %Script.datatype;        #IMPLIED
>

<!-- additional attributes on area element
-->
<!ATTLIST %area.qname;
      onfocus      %Script.datatype;        #IMPLIED
      onblur       %Script.datatype;        #IMPLIED
>

<!-- end of xhtml-events-1.mod -->
]]>

<!ENTITY % xhtml-attribs.module "INCLUDE" >
<![%xhtml-attribs.module;[
<!ENTITY % xhtml-attribs.mod
     PUBLIC "-//W3C//ENTITIES XHTML Common Attributes 1.0//EN"
            "xhtml-attribs-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Common Attributes Module  ...................................... -->
<!-- file: xhtml-attribs-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-attribs-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML Common Attributes 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-attribs-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Common Attributes

     This module declares many of the common attributes for the XHTML DTD.
     %NS.decl.attrib; is declared in the XHTML Qname module.
-->

<!ENTITY % id.attrib
     "id           ID                       #IMPLIED"
>

<!ENTITY % class.attrib
     "class        NMTOKENS                 #IMPLIED"
>

<!ENTITY % title.attrib
     "title        %Text.datatype;          #IMPLIED"
>

<!ENTITY % Core.extra.attrib "" >

<!ENTITY % Core.attrib
     "%XHTML.xmlns.attrib;
      %id.attrib;
      %class.attrib;
      %title.attrib;
      %Core.extra.attrib;"
>

<!ENTITY % lang.attrib
     "xml:lang     %LanguageCode.datatype;  #IMPLIED"
>

<![%XHTML.bidi;[
<!ENTITY % dir.attrib
     "dir          ( ltr | rtl )            #IMPLIED"
>

<!ENTITY % I18n.attrib
     "%dir.attrib;
      %lang.attrib;"
>

]]>
<!ENTITY % I18n.attrib
     "%lang.attrib;"
>

<!ENTITY % Common.extra.attrib "" >

<!-- intrinsic event attributes declared previously
-->
<!ENTITY % Events.attrib "" >

<!ENTITY % Common.attrib
     "%Core.attrib;
      %I18n.attrib;
      %Events.attrib;
      %Common.extra.attrib;"
>

<!-- end of xhtml-attribs-1.mod -->
]]>

<!-- placeholder for content model redeclarations -->
<!ENTITY % xhtml-model.redecl "" >


<!ENTITY % xhtml-model.module "INCLUDE" >
<![%xhtml-model.module;[
<!-- instantiate the Document Model module declared in the DTD driver
-->
<!-- ....................................................................... -->
<!-- XHTML 1.1 Document Model Module  ...................................... -->
<!-- file: xhtml11-model-1.mod

     This is XHTML 1.1, a reformulation of HTML as a modular XML application.
     Copyright 1998-2000 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml11-model-1.mod,v 1.12 2000/11/18 18:20:25 ahby Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML 1.1 Document Model 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml11/DTD/xhtml11-model-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- XHTML 1.1 Document Model

     This module describes the groupings of elements that make up
     common content models for XHTML elements.

     XHTML has three basic content models:

         %Inline.mix;  character-level elements
         %Block.mix;   block-like elements, eg., paragraphs and lists
         %Flow.mix;    any block or inline elements

     Any parameter entities declared in this module may be used
     to create element content models, but the above three are
     considered 'global' (insofar as that term applies here).

     The reserved word '#PCDATA' (indicating a text string) is now
     included explicitly with each element declaration that is
     declared as mixed content, as XML requires that this token
     occur first in a content model specification.
-->
<!-- Extending the Model

     While in some cases this module may need to be rewritten to
     accommodate changes to the document model, minor extensions
     may be accomplished by redeclaring any of the three *.extra;
     parameter entities to contain extension element types as follows:

         %Misc.extra;    whose parent may be any block or
                         inline element.

         %Inline.extra;  whose parent may be any inline element.

         %Block.extra;   whose parent may be any block element.

     If used, these parameter entities must be an OR-separated
     list beginning with an OR separator ("|"), eg., "| a | b | c"

     All block and inline *.class parameter entities not part
     of the *struct.class classes begin with "| " to allow for
     exclusion from mixes.
-->

<!-- ..............  Optional Elements in head  .................. -->

<!ENTITY % HeadOpts.mix
     "( %script.qname; | %style.qname; | %meta.qname;
      | %link.qname; | %object.qname; )*"
>

<!-- .................  Miscellaneous Elements  .................. -->

<!-- ins and del are used to denote editing changes
-->
<!ENTITY % Edit.class "| %ins.qname; | %del.qname;" >

<!-- script and noscript are used to contain scripts
     and alternative content
-->
<!ENTITY % Script.class "| %script.qname; | %noscript.qname;" >

<!ENTITY % Misc.extra "" >

<!-- These elements are neither block nor inline, and can
     essentially be used anywhere in the document body.
-->
<!ENTITY % Misc.class
     "%Edit.class;
      %Script.class;
      %Misc.extra;"
>

<!-- ....................  Inline Elements  ...................... -->

<!ENTITY % InlStruct.class "%br.qname; | %span.qname;" >

<!ENTITY % InlPhras.class
     "| %em.qname; | %strong.qname; | %dfn.qname; | %code.qname;
      | %samp.qname; | %kbd.qname; | %var.qname; | %cite.qname;
      | %abbr.qname; | %acronym.qname; | %q.qname;" >

<!ENTITY % InlPres.class
     "| %tt.qname; | %i.qname; | %b.qname; | %big.qname;
      | %small.qname; | %sub.qname; | %sup.qname;" >

<!ENTITY % I18n.class "| %bdo.qname;" >

<!ENTITY % Anchor.class "| %a.qname;" >

<!ENTITY % InlSpecial.class
     "| %img.qname; | %map.qname;
      | %object.qname;" >

<!ENTITY % InlForm.class
     "| %input.qname; | %select.qname; | %textarea.qname;
      | %label.qname; | %button.qname;" >

<!ENTITY % Inline.extra "" >

<!ENTITY % Ruby.class "| %ruby.qname;" >

<!-- %Inline.class; includes all inline elements,
     used as a component in mixes
-->
<!ENTITY % Inline.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %I18n.class;
      %Anchor.class;
      %InlSpecial.class;
      %InlForm.class;
      %Ruby.class;
      %Inline.extra;"
>

<!-- %InlNoRuby.class; includes all inline elements
     except ruby, used as a component in mixes
-->
<!ENTITY % InlNoRuby.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %I18n.class;
      %Anchor.class;
      %InlSpecial.class;
      %InlForm.class;
      %Inline.extra;"
>

<!-- %NoRuby.content; includes all inlines except ruby
-->
<!ENTITY % NoRuby.content
     "( #PCDATA
      | %InlNoRuby.class;
      %Misc.class; )*"
>

<!-- %InlNoAnchor.class; includes all non-anchor inlines,
     used as a component in mixes
-->
<!ENTITY % InlNoAnchor.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %I18n.class;
      %InlSpecial.class;
      %InlForm.class;
      %Ruby.class;
      %Inline.extra;"
>

<!-- %InlNoAnchor.mix; includes all non-anchor inlines
-->
<!ENTITY % InlNoAnchor.mix
     "%InlNoAnchor.class;
      %Misc.class;"
>

<!-- %Inline.mix; includes all inline elements, including %Misc.class;
-->
<!ENTITY % Inline.mix
     "%Inline.class;
      %Misc.class;"
>

<!-- .....................  Block Elements  ...................... -->

<!-- In the HTML 4.0 DTD, heading and list elements were included
     in the %block; parameter entity. The %Heading.class; and
     %List.class; parameter entities must now be included explicitly
     on element declarations where desired.
-->

<!ENTITY % Heading.class
     "%h1.qname; | %h2.qname; | %h3.qname;
      | %h4.qname; | %h5.qname; | %h6.qname;" >

<!ENTITY % List.class "%ul.qname; | %ol.qname; | %dl.qname;" >

<!ENTITY % Table.class "| %table.qname;" >

<!ENTITY % Form.class  "| %form.qname;" >

<!ENTITY % Fieldset.class  "| %fieldset.qname;" >

<!ENTITY % BlkStruct.class "%p.qname; | %div.qname;" >

<!ENTITY % BlkPhras.class
     "| %pre.qname; | %blockquote.qname; | %address.qname;" >

<!ENTITY % BlkPres.class "| %hr.qname;" >

<!ENTITY % BlkSpecial.class
     "%Table.class;
      %Form.class;
      %Fieldset.class;"
>

<!ENTITY % Block.extra "" >

<!-- %Block.class; includes all block elements,
     used as an component in mixes
-->
<!ENTITY % Block.class
     "%BlkStruct.class;
      %BlkPhras.class;
      %BlkPres.class;
      %BlkSpecial.class;
      %Block.extra;"
>

<!-- %Block.mix; includes all block elements plus %Misc.class;
-->
<!ENTITY % Block.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      %Misc.class;"
>

<!-- ................  All Content Elements  .................. -->

<!-- %Flow.mix; includes all text content, block and inline
-->
<!ENTITY % Flow.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      | %Inline.class;
      %Misc.class;"
>

<!-- end of xhtml11-model-1.mod -->
]]>

<!ENTITY % xhtml-charent.module "INCLUDE" >
<![%xhtml-charent.module;[
<!ENTITY % xhtml-charent.mod
     PUBLIC "-//W3C//ENTITIES XHTML Character Entities 1.0//EN"
            "xhtml-charent-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Character Entities Module  ......................................... -->
<!-- file: xhtml-charent-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-charent-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ENTITIES XHTML Character Entities 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-charent-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Character Entities for XHTML

     This module declares the set of character entities for XHTML,
     including the Latin 1, Symbol and Special character collections.
-->

<!ENTITY % xhtml-lat1
    PUBLIC "-//W3C//ENTITIES Latin 1 for XHTML//EN"
           "xhtml-lat1.ent" >
<!-- Portions (C) International Organization for Standardization 1986
     Permission to copy in any form is granted for use with
     conforming SGML systems and applications as defined in
     ISO 8879, provided this notice is included in all copies.
-->
<!-- Character entity set. Typical invocation:
    <!ENTITY % HTMLlat1 PUBLIC
       "-//W3C//ENTITIES Latin 1 for XHTML//EN"
       "http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent">
    %HTMLlat1;
-->

<!ENTITY nbsp   "&#160;"> <!-- no-break space = non-breaking space,
                                  U+00A0 ISOnum -->
<!ENTITY iexcl  "&#161;"> <!-- inverted exclamation mark, U+00A1 ISOnum -->
<!ENTITY cent   "&#162;"> <!-- cent sign, U+00A2 ISOnum -->
<!ENTITY pound  "&#163;"> <!-- pound sign, U+00A3 ISOnum -->
<!ENTITY curren "&#164;"> <!-- currency sign, U+00A4 ISOnum -->
<!ENTITY yen    "&#165;"> <!-- yen sign = yuan sign, U+00A5 ISOnum -->
<!ENTITY brvbar "&#166;"> <!-- broken bar = broken vertical bar,
                                  U+00A6 ISOnum -->
<!ENTITY sect   "&#167;"> <!-- section sign, U+00A7 ISOnum -->
<!ENTITY uml    "&#168;"> <!-- diaeresis = spacing diaeresis,
                                  U+00A8 ISOdia -->
<!ENTITY copy   "&#169;"> <!-- copyright sign, U+00A9 ISOnum -->
<!ENTITY ordf   "&#170;"> <!-- feminine ordinal indicator, U+00AA ISOnum -->
<!ENTITY laquo  "&#171;"> <!-- left-pointing double angle quotation mark
                                  = left pointing guillemet, U+00AB ISOnum -->
<!ENTITY not    "&#172;"> <!-- not sign = discretionary hyphen,
                                  U+00AC ISOnum -->
<!ENTITY shy    "&#173;"> <!-- soft hyphen = discretionary hyphen,
                                  U+00AD ISOnum -->
<!ENTITY reg    "&#174;"> <!-- registered sign = registered trade mark sign,
                                  U+00AE ISOnum -->
<!ENTITY macr   "&#175;"> <!-- macron = spacing macron = overline
                                  = APL overbar, U+00AF ISOdia -->
<!ENTITY deg    "&#176;"> <!-- degree sign, U+00B0 ISOnum -->
<!ENTITY plusmn "&#177;"> <!-- plus-minus sign = plus-or-minus sign,
                                  U+00B1 ISOnum -->
<!ENTITY sup2   "&#178;"> <!-- superscript two = superscript digit two
                                  = squared, U+00B2 ISOnum -->
<!ENTITY sup3   "&#179;"> <!-- superscript three = superscript digit three
                                  = cubed, U+00B3 ISOnum -->
<!ENTITY acute  "&#180;"> <!-- acute accent = spacing acute,
                                  U+00B4 ISOdia -->
<!ENTITY micro  "&#181;"> <!-- micro sign, U+00B5 ISOnum -->
<!ENTITY para   "&#182;"> <!-- pilcrow sign = paragraph sign,
                                  U+00B6 ISOnum -->
<!ENTITY middot "&#183;"> <!-- middle dot = Georgian comma
                                  = Greek middle dot, U+00B7 ISOnum -->
<!ENTITY cedil  "&#184;"> <!-- cedilla = spacing cedilla, U+00B8 ISOdia -->
<!ENTITY sup1   "&#185;"> <!-- superscript one = superscript digit one,
                                  U+00B9 ISOnum -->
<!ENTITY ordm   "&#186;"> <!-- masculine ordinal indicator,
                                  U+00BA ISOnum -->
<!ENTITY raquo  "&#187;"> <!-- right-pointing double angle quotation mark
                                  = right pointing guillemet, U+00BB ISOnum -->
<!ENTITY frac14 "&#188;"> <!-- vulgar fraction one quarter
                                  = fraction one quarter, U+00BC ISOnum -->
<!ENTITY frac12 "&#189;"> <!-- vulgar fraction one half
                                  = fraction one half, U+00BD ISOnum -->
<!ENTITY frac34 "&#190;"> <!-- vulgar fraction three quarters
                                  = fraction three quarters, U+00BE ISOnum -->
<!ENTITY iquest "&#191;"> <!-- inverted question mark
                                  = turned question mark, U+00BF ISOnum -->
<!ENTITY Agrave "&#192;"> <!-- latin capital letter A with grave
                                  = latin capital letter A grave,
                                  U+00C0 ISOlat1 -->
<!ENTITY Aacute "&#193;"> <!-- latin capital letter A with acute,
                                  U+00C1 ISOlat1 -->
<!ENTITY Acirc  "&#194;"> <!-- latin capital letter A with circumflex,
                                  U+00C2 ISOlat1 -->
<!ENTITY Atilde "&#195;"> <!-- latin capital letter A with tilde,
                                  U+00C3 ISOlat1 -->
<!ENTITY Auml   "&#196;"> <!-- latin capital letter A with diaeresis,
                                  U+00C4 ISOlat1 -->
<!ENTITY Aring  "&#197;"> <!-- latin capital letter A with ring above
                                  = latin capital letter A ring,
                                  U+00C5 ISOlat1 -->
<!ENTITY AElig  "&#198;"> <!-- latin capital letter AE
                                  = latin capital ligature AE,
                                  U+00C6 ISOlat1 -->
<!ENTITY Ccedil "&#199;"> <!-- latin capital letter C with cedilla,
                                  U+00C7 ISOlat1 -->
<!ENTITY Egrave "&#200;"> <!-- latin capital letter E with grave,
                                  U+00C8 ISOlat1 -->
<!ENTITY Eacute "&#201;"> <!-- latin capital letter E with acute,
                                  U+00C9 ISOlat1 -->
<!ENTITY Ecirc  "&#202;"> <!-- latin capital letter E with circumflex,
                                  U+00CA ISOlat1 -->
<!ENTITY Euml   "&#203;"> <!-- latin capital letter E with diaeresis,
                                  U+00CB ISOlat1 -->
<!ENTITY Igrave "&#204;"> <!-- latin capital letter I with grave,
                                  U+00CC ISOlat1 -->
<!ENTITY Iacute "&#205;"> <!-- latin capital letter I with acute,
                                  U+00CD ISOlat1 -->
<!ENTITY Icirc  "&#206;"> <!-- latin capital letter I with circumflex,
                                  U+00CE ISOlat1 -->
<!ENTITY Iuml   "&#207;"> <!-- latin capital letter I with diaeresis,
                                  U+00CF ISOlat1 -->
<!ENTITY ETH    "&#208;"> <!-- latin capital letter ETH, U+00D0 ISOlat1 -->
<!ENTITY Ntilde "&#209;"> <!-- latin capital letter N with tilde,
                                  U+00D1 ISOlat1 -->
<!ENTITY Ograve "&#210;"> <!-- latin capital letter O with grave,
                                  U+00D2 ISOlat1 -->
<!ENTITY Oacute "&#211;"> <!-- latin capital letter O with acute,
                                  U+00D3 ISOlat1 -->
<!ENTITY Ocirc  "&#212;"> <!-- latin capital letter O with circumflex,
                                  U+00D4 ISOlat1 -->
<!ENTITY Otilde "&#213;"> <!-- latin capital letter O with tilde,
                                  U+00D5 ISOlat1 -->
<!ENTITY Ouml   "&#214;"> <!-- latin capital letter O with diaeresis,
                                  U+00D6 ISOlat1 -->
<!ENTITY times  "&#215;"> <!-- multiplication sign, U+00D7 ISOnum -->
<!ENTITY Oslash "&#216;"> <!-- latin capital letter O with stroke
                                  = latin capital letter O slash,
                                  U+00D8 ISOlat1 -->
<!ENTITY Ugrave "&#217;"> <!-- latin capital letter U with grave,
                                  U+00D9 ISOlat1 -->
<!ENTITY Uacute "&#218;"> <!-- latin capital letter U with acute,
                                  U+00DA ISOlat1 -->
<!ENTITY Ucirc  "&#219;"> <!-- latin capital letter U with circumflex,
                                  U+00DB ISOlat1 -->
<!ENTITY Uuml   "&#220;"> <!-- latin capital letter U with diaeresis,
                                  U+00DC ISOlat1 -->
<!ENTITY Yacute "&#221;"> <!-- latin capital letter Y with acute,
                                  U+00DD ISOlat1 -->
<!ENTITY THORN  "&#222;"> <!-- latin capital letter THORN,
                                  U+00DE ISOlat1 -->
<!ENTITY szlig  "&#223;"> <!-- latin small letter sharp s = ess-zed,
                                  U+00DF ISOlat1 -->
<!ENTITY agrave "&#224;"> <!-- latin small letter a with grave
                                  = latin small letter a grave,
                                  U+00E0 ISOlat1 -->
<!ENTITY aacute "&#225;"> <!-- latin small letter a with acute,
                                  U+00E1 ISOlat1 -->
<!ENTITY acirc  "&#226;"> <!-- latin small letter a with circumflex,
                                  U+00E2 ISOlat1 -->
<!ENTITY atilde "&#227;"> <!-- latin small letter a with tilde,
                                  U+00E3 ISOlat1 -->
<!ENTITY auml   "&#228;"> <!-- latin small letter a with diaeresis,
                                  U+00E4 ISOlat1 -->
<!ENTITY aring  "&#229;"> <!-- latin small letter a with ring above
                                  = latin small letter a ring,
                                  U+00E5 ISOlat1 -->
<!ENTITY aelig  "&#230;"> <!-- latin small letter ae
                                  = latin small ligature ae, U+00E6 ISOlat1 -->
<!ENTITY ccedil "&#231;"> <!-- latin small letter c with cedilla,
                                  U+00E7 ISOlat1 -->
<!ENTITY egrave "&#232;"> <!-- latin small letter e with grave,
                                  U+00E8 ISOlat1 -->
<!ENTITY eacute "&#233;"> <!-- latin small letter e with acute,
                                  U+00E9 ISOlat1 -->
<!ENTITY ecirc  "&#234;"> <!-- latin small letter e with circumflex,
                                  U+00EA ISOlat1 -->
<!ENTITY euml   "&#235;"> <!-- latin small letter e with diaeresis,
                                  U+00EB ISOlat1 -->
<!ENTITY igrave "&#236;"> <!-- latin small letter i with grave,
                                  U+00EC ISOlat1 -->
<!ENTITY iacute "&#237;"> <!-- latin small letter i with acute,
                                  U+00ED ISOlat1 -->
<!ENTITY icirc  "&#238;"> <!-- latin small letter i with circumflex,
                                  U+00EE ISOlat1 -->
<!ENTITY iuml   "&#239;"> <!-- latin small letter i with diaeresis,
                                  U+00EF ISOlat1 -->
<!ENTITY eth    "&#240;"> <!-- latin small letter eth, U+00F0 ISOlat1 -->
<!ENTITY ntilde "&#241;"> <!-- latin small letter n with tilde,
                                  U+00F1 ISOlat1 -->
<!ENTITY ograve "&#242;"> <!-- latin small letter o with grave,
                                  U+00F2 ISOlat1 -->
<!ENTITY oacute "&#243;"> <!-- latin small letter o with acute,
                                  U+00F3 ISOlat1 -->
<!ENTITY ocirc  "&#244;"> <!-- latin small letter o with circumflex,
                                  U+00F4 ISOlat1 -->
<!ENTITY otilde "&#245;"> <!-- latin small letter o with tilde,
                                  U+00F5 ISOlat1 -->
<!ENTITY ouml   "&#246;"> <!-- latin small letter o with diaeresis,
                                  U+00F6 ISOlat1 -->
<!ENTITY divide "&#247;"> <!-- division sign, U+00F7 ISOnum -->
<!ENTITY oslash "&#248;"> <!-- latin small letter o with stroke,
                                  = latin small letter o slash,
                                  U+00F8 ISOlat1 -->
<!ENTITY ugrave "&#249;"> <!-- latin small letter u with grave,
                                  U+00F9 ISOlat1 -->
<!ENTITY uacute "&#250;"> <!-- latin small letter u with acute,
                                  U+00FA ISOlat1 -->
<!ENTITY ucirc  "&#251;"> <!-- latin small letter u with circumflex,
                                  U+00FB ISOlat1 -->
<!ENTITY uuml   "&#252;"> <!-- latin small letter u with diaeresis,
                                  U+00FC ISOlat1 -->
<!ENTITY yacute "&#253;"> <!-- latin small letter y with acute,
                                  U+00FD ISOlat1 -->
<!ENTITY thorn  "&#254;"> <!-- latin small letter thorn with,
                                  U+00FE ISOlat1 -->
<!ENTITY yuml   "&#255;"> <!-- latin small letter y with diaeresis,
                                  U+00FF ISOlat1 -->


<!ENTITY % xhtml-symbol
    PUBLIC "-//W3C//ENTITIES Symbols for XHTML//EN"
           "xhtml-symbol.ent" >
<!-- Mathematical, Greek and Symbolic characters for HTML -->

<!-- Character entity set. Typical invocation:
     <!ENTITY % HTMLsymbol PUBLIC
        "-//W3C//ENTITIES Symbols for XHTML//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent">
     %HTMLsymbol;
-->

<!-- Portions (C) International Organization for Standardization 1986:
     Permission to copy in any form is granted for use with
     conforming SGML systems and applications as defined in
     ISO 8879, provided this notice is included in all copies.
-->

<!-- Relevant ISO entity set is given unless names are newly introduced.
     New names (i.e., not in ISO 8879 list) do not clash with any
     existing ISO 8879 entity names. ISO 10646 character numbers
     are given for each character, in hex. values are decimal
     conversions of the ISO 10646 values and refer to the document
     character set. Names are Unicode names. 
-->

<!-- Latin Extended-B -->
<!ENTITY fnof     "&#402;"> <!-- latin small f with hook = function
                                    = florin, U+0192 ISOtech -->

<!-- Greek -->
<!ENTITY Alpha    "&#913;"> <!-- greek capital letter alpha, U+0391 -->
<!ENTITY Beta     "&#914;"> <!-- greek capital letter beta, U+0392 -->
<!ENTITY Gamma    "&#915;"> <!-- greek capital letter gamma,
                                    U+0393 ISOgrk3 -->
<!ENTITY Delta    "&#916;"> <!-- greek capital letter delta,
                                    U+0394 ISOgrk3 -->
<!ENTITY Epsilon  "&#917;"> <!-- greek capital letter epsilon, U+0395 -->
<!ENTITY Zeta     "&#918;"> <!-- greek capital letter zeta, U+0396 -->
<!ENTITY Eta      "&#919;"> <!-- greek capital letter eta, U+0397 -->
<!ENTITY Theta    "&#920;"> <!-- greek capital letter theta,
                                    U+0398 ISOgrk3 -->
<!ENTITY Iota     "&#921;"> <!-- greek capital letter iota, U+0399 -->
<!ENTITY Kappa    "&#922;"> <!-- greek capital letter kappa, U+039A -->
<!ENTITY Lambda   "&#923;"> <!-- greek capital letter lambda,
                                    U+039B ISOgrk3 -->
<!ENTITY Mu       "&#924;"> <!-- greek capital letter mu, U+039C -->
<!ENTITY Nu       "&#925;"> <!-- greek capital letter nu, U+039D -->
<!ENTITY Xi       "&#926;"> <!-- greek capital letter xi, U+039E ISOgrk3 -->
<!ENTITY Omicron  "&#927;"> <!-- greek capital letter omicron, U+039F -->
<!ENTITY Pi       "&#928;"> <!-- greek capital letter pi, U+03A0 ISOgrk3 -->
<!ENTITY Rho      "&#929;"> <!-- greek capital letter rho, U+03A1 -->
<!-- there is no Sigmaf, and no U+03A2 character either -->
<!ENTITY Sigma    "&#931;"> <!-- greek capital letter sigma,
                                    U+03A3 ISOgrk3 -->
<!ENTITY Tau      "&#932;"> <!-- greek capital letter tau, U+03A4 -->
<!ENTITY Upsilon  "&#933;"> <!-- greek capital letter upsilon,
                                    U+03A5 ISOgrk3 -->
<!ENTITY Phi      "&#934;"> <!-- greek capital letter phi,
                                    U+03A6 ISOgrk3 -->
<!ENTITY Chi      "&#935;"> <!-- greek capital letter chi, U+03A7 -->
<!ENTITY Psi      "&#936;"> <!-- greek capital letter psi,
                                    U+03A8 ISOgrk3 -->
<!ENTITY Omega    "&#937;"> <!-- greek capital letter omega,
                                    U+03A9 ISOgrk3 -->

<!ENTITY alpha    "&#945;"> <!-- greek small letter alpha,
                                    U+03B1 ISOgrk3 -->
<!ENTITY beta     "&#946;"> <!-- greek small letter beta, U+03B2 ISOgrk3 -->
<!ENTITY gamma    "&#947;"> <!-- greek small letter gamma,
                                    U+03B3 ISOgrk3 -->
<!ENTITY delta    "&#948;"> <!-- greek small letter delta,
                                    U+03B4 ISOgrk3 -->
<!ENTITY epsilon  "&#949;"> <!-- greek small letter epsilon,
                                    U+03B5 ISOgrk3 -->
<!ENTITY zeta     "&#950;"> <!-- greek small letter zeta, U+03B6 ISOgrk3 -->
<!ENTITY eta      "&#951;"> <!-- greek small letter eta, U+03B7 ISOgrk3 -->
<!ENTITY theta    "&#952;"> <!-- greek small letter theta,
                                    U+03B8 ISOgrk3 -->
<!ENTITY iota     "&#953;"> <!-- greek small letter iota, U+03B9 ISOgrk3 -->
<!ENTITY kappa    "&#954;"> <!-- greek small letter kappa,
                                    U+03BA ISOgrk3 -->
<!ENTITY lambda   "&#955;"> <!-- greek small letter lambda,
                                    U+03BB ISOgrk3 -->
<!ENTITY mu       "&#956;"> <!-- greek small letter mu, U+03BC ISOgrk3 -->
<!ENTITY nu       "&#957;"> <!-- greek small letter nu, U+03BD ISOgrk3 -->
<!ENTITY xi       "&#958;"> <!-- greek small letter xi, U+03BE ISOgrk3 -->
<!ENTITY omicron  "&#959;"> <!-- greek small letter omicron, U+03BF NEW -->
<!ENTITY pi       "&#960;"> <!-- greek small letter pi, U+03C0 ISOgrk3 -->
<!ENTITY rho      "&#961;"> <!-- greek small letter rho, U+03C1 ISOgrk3 -->
<!ENTITY sigmaf   "&#962;"> <!-- greek small letter final sigma,
                                    U+03C2 ISOgrk3 -->
<!ENTITY sigma    "&#963;"> <!-- greek small letter sigma,
                                    U+03C3 ISOgrk3 -->
<!ENTITY tau      "&#964;"> <!-- greek small letter tau, U+03C4 ISOgrk3 -->
<!ENTITY upsilon  "&#965;"> <!-- greek small letter upsilon,
                                    U+03C5 ISOgrk3 -->
<!ENTITY phi      "&#966;"> <!-- greek small letter phi, U+03C6 ISOgrk3 -->
<!ENTITY chi      "&#967;"> <!-- greek small letter chi, U+03C7 ISOgrk3 -->
<!ENTITY psi      "&#968;"> <!-- greek small letter psi, U+03C8 ISOgrk3 -->
<!ENTITY omega    "&#969;"> <!-- greek small letter omega,
                                    U+03C9 ISOgrk3 -->
<!ENTITY thetasym "&#977;"> <!-- greek small letter theta symbol,
                                    U+03D1 NEW -->
<!ENTITY upsih    "&#978;"> <!-- greek upsilon with hook symbol,
                                    U+03D2 NEW -->
<!ENTITY piv      "&#982;"> <!-- greek pi symbol, U+03D6 ISOgrk3 -->

<!-- General Punctuation -->
<!ENTITY bull     "&#8226;"> <!-- bullet = black small circle,
                                     U+2022 ISOpub  -->
<!-- bullet is NOT the same as bullet operator, U+2219 -->
<!ENTITY hellip   "&#8230;"> <!-- horizontal ellipsis = three dot leader,
                                     U+2026 ISOpub  -->
<!ENTITY prime    "&#8242;"> <!-- prime = minutes = feet, U+2032 ISOtech -->
<!ENTITY Prime    "&#8243;"> <!-- double prime = seconds = inches,
                                     U+2033 ISOtech -->
<!ENTITY oline    "&#8254;"> <!-- overline = spacing overscore,
                                     U+203E NEW -->
<!ENTITY frasl    "&#8260;"> <!-- fraction slash, U+2044 NEW -->

<!-- Letterlike Symbols -->
<!ENTITY weierp   "&#8472;"> <!-- script capital P = power set
                                     = Weierstrass p, U+2118 ISOamso -->
<!ENTITY image    "&#8465;"> <!-- blackletter capital I = imaginary part,
                                     U+2111 ISOamso -->
<!ENTITY real     "&#8476;"> <!-- blackletter capital R = real part symbol,
                                     U+211C ISOamso -->
<!ENTITY trade    "&#8482;"> <!-- trade mark sign, U+2122 ISOnum -->
<!ENTITY alefsym  "&#8501;"> <!-- alef symbol = first transfinite cardinal,
                                     U+2135 NEW -->
<!-- alef symbol is NOT the same as hebrew letter alef,
     U+05D0 although the same glyph could be used to depict both characters -->

<!-- Arrows -->
<!ENTITY larr     "&#8592;"> <!-- leftwards arrow, U+2190 ISOnum -->
<!ENTITY uarr     "&#8593;"> <!-- upwards arrow, U+2191 ISOnum-->
<!ENTITY rarr     "&#8594;"> <!-- rightwards arrow, U+2192 ISOnum -->
<!ENTITY darr     "&#8595;"> <!-- downwards arrow, U+2193 ISOnum -->
<!ENTITY harr     "&#8596;"> <!-- left right arrow, U+2194 ISOamsa -->
<!ENTITY crarr    "&#8629;"> <!-- downwards arrow with corner leftwards
                                     = carriage return, U+21B5 NEW -->
<!ENTITY lArr     "&#8656;"> <!-- leftwards double arrow, U+21D0 ISOtech -->
<!-- Unicode does not say that lArr is the same as the 'is implied by' arrow
    but also does not have any other character for that function. So ? lArr can
    be used for 'is implied by' as ISOtech suggests -->
<!ENTITY uArr     "&#8657;"> <!-- upwards double arrow, U+21D1 ISOamsa -->
<!ENTITY rArr     "&#8658;"> <!-- rightwards double arrow,
                                     U+21D2 ISOtech -->
<!-- Unicode does not say this is the 'implies' character but does not have 
     another character with this function so ?
     rArr can be used for 'implies' as ISOtech suggests -->
<!ENTITY dArr     "&#8659;"> <!-- downwards double arrow, U+21D3 ISOamsa -->
<!ENTITY hArr     "&#8660;"> <!-- left right double arrow,
                                     U+21D4 ISOamsa -->

<!-- Mathematical Operators -->
<!ENTITY forall   "&#8704;"> <!-- for all, U+2200 ISOtech -->
<!ENTITY part     "&#8706;"> <!-- partial differential, U+2202 ISOtech  -->
<!ENTITY exist    "&#8707;"> <!-- there exists, U+2203 ISOtech -->
<!ENTITY empty    "&#8709;"> <!-- empty set = null set = diameter,
                                     U+2205 ISOamso -->
<!ENTITY nabla    "&#8711;"> <!-- nabla = backward difference,
                                     U+2207 ISOtech -->
<!ENTITY isin     "&#8712;"> <!-- element of, U+2208 ISOtech -->
<!ENTITY notin    "&#8713;"> <!-- not an element of, U+2209 ISOtech -->
<!ENTITY ni       "&#8715;"> <!-- contains as member, U+220B ISOtech -->
<!-- should there be a more memorable name than 'ni'? -->
<!ENTITY prod     "&#8719;"> <!-- n-ary product = product sign,
                                     U+220F ISOamsb -->
<!-- prod is NOT the same character as U+03A0 'greek capital letter pi' though
     the same glyph might be used for both -->
<!ENTITY sum      "&#8721;"> <!-- n-ary sumation, U+2211 ISOamsb -->
<!-- sum is NOT the same character as U+03A3 'greek capital letter sigma'
     though the same glyph might be used for both -->
<!ENTITY minus    "&#8722;"> <!-- minus sign, U+2212 ISOtech -->
<!ENTITY lowast   "&#8727;"> <!-- asterisk operator, U+2217 ISOtech -->
<!ENTITY radic    "&#8730;"> <!-- square root = radical sign,
                                     U+221A ISOtech -->
<!ENTITY prop     "&#8733;"> <!-- proportional to, U+221D ISOtech -->
<!ENTITY infin    "&#8734;"> <!-- infinity, U+221E ISOtech -->
<!ENTITY ang      "&#8736;"> <!-- angle, U+2220 ISOamso -->
<!ENTITY and      "&#8743;"> <!-- logical and = wedge, U+2227 ISOtech -->
<!ENTITY or       "&#8744;"> <!-- logical or = vee, U+2228 ISOtech -->
<!ENTITY cap      "&#8745;"> <!-- intersection = cap, U+2229 ISOtech -->
<!ENTITY cup      "&#8746;"> <!-- union = cup, U+222A ISOtech -->
<!ENTITY int      "&#8747;"> <!-- integral, U+222B ISOtech -->
<!ENTITY there4   "&#8756;"> <!-- therefore, U+2234 ISOtech -->
<!ENTITY sim      "&#8764;"> <!-- tilde operator = varies with = similar to,
                                     U+223C ISOtech -->
<!-- tilde operator is NOT the same character as the tilde, U+007E,
     although the same glyph might be used to represent both  -->
<!ENTITY cong     "&#8773;"> <!-- approximately equal to, U+2245 ISOtech -->
<!ENTITY asymp    "&#8776;"> <!-- almost equal to = asymptotic to,
                                     U+2248 ISOamsr -->
<!ENTITY ne       "&#8800;"> <!-- not equal to, U+2260 ISOtech -->
<!ENTITY equiv    "&#8801;"> <!-- identical to, U+2261 ISOtech -->
<!ENTITY le       "&#8804;"> <!-- less-than or equal to, U+2264 ISOtech -->
<!ENTITY ge       "&#8805;"> <!-- greater-than or equal to,
                                     U+2265 ISOtech -->
<!ENTITY sub      "&#8834;"> <!-- subset of, U+2282 ISOtech -->
<!ENTITY sup      "&#8835;"> <!-- superset of, U+2283 ISOtech -->
<!-- note that nsup, 'not a superset of, U+2283' is not covered by the Symbol 
     font encoding and is not included. Should it be, for symmetry?
     It is in ISOamsn  --> 
<!ENTITY nsub     "&#8836;"> <!-- not a subset of, U+2284 ISOamsn -->
<!ENTITY sube     "&#8838;"> <!-- subset of or equal to, U+2286 ISOtech -->
<!ENTITY supe     "&#8839;"> <!-- superset of or equal to,
                                     U+2287 ISOtech -->
<!ENTITY oplus    "&#8853;"> <!-- circled plus = direct sum,
                                     U+2295 ISOamsb -->
<!ENTITY otimes   "&#8855;"> <!-- circled times = vector product,
                                     U+2297 ISOamsb -->
<!ENTITY perp     "&#8869;"> <!-- up tack = orthogonal to = perpendicular,
                                     U+22A5 ISOtech -->
<!ENTITY sdot     "&#8901;"> <!-- dot operator, U+22C5 ISOamsb -->
<!-- dot operator is NOT the same character as U+00B7 middle dot -->

<!-- Miscellaneous Technical -->
<!ENTITY lceil    "&#8968;"> <!-- left ceiling = apl upstile,
                                     U+2308 ISOamsc  -->
<!ENTITY rceil    "&#8969;"> <!-- right ceiling, U+2309 ISOamsc  -->
<!ENTITY lfloor   "&#8970;"> <!-- left floor = apl downstile,
                                     U+230A ISOamsc  -->
<!ENTITY rfloor   "&#8971;"> <!-- right floor, U+230B ISOamsc  -->
<!ENTITY lang     "&#9001;"> <!-- left-pointing angle bracket = bra,
                                     U+2329 ISOtech -->
<!-- lang is NOT the same character as U+003C 'less than' 
     or U+2039 'single left-pointing angle quotation mark' -->
<!ENTITY rang     "&#9002;"> <!-- right-pointing angle bracket = ket,
                                     U+232A ISOtech -->
<!-- rang is NOT the same character as U+003E 'greater than' 
     or U+203A 'single right-pointing angle quotation mark' -->

<!-- Geometric Shapes -->
<!ENTITY loz      "&#9674;"> <!-- lozenge, U+25CA ISOpub -->

<!-- Miscellaneous Symbols -->
<!ENTITY spades   "&#9824;"> <!-- black spade suit, U+2660 ISOpub -->
<!-- black here seems to mean filled as opposed to hollow -->
<!ENTITY clubs    "&#9827;"> <!-- black club suit = shamrock,
                                     U+2663 ISOpub -->
<!ENTITY hearts   "&#9829;"> <!-- black heart suit = valentine,
                                     U+2665 ISOpub -->
<!ENTITY diams    "&#9830;"> <!-- black diamond suit, U+2666 ISOpub -->


<!ENTITY % xhtml-special
    PUBLIC "-//W3C//ENTITIES Special for XHTML//EN"
           "xhtml-special.ent" >
<!-- Special characters for HTML -->

<!-- Character entity set. Typical invocation:
     <!ENTITY % HTMLspecial PUBLIC
        "-//W3C//ENTITIES Special for XHTML//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent">
     %HTMLspecial;
-->

<!-- Portions (C) International Organization for Standardization 1986:
     Permission to copy in any form is granted for use with
     conforming SGML systems and applications as defined in
     ISO 8879, provided this notice is included in all copies.
-->

<!-- Relevant ISO entity set is given unless names are newly introduced.
     New names (i.e., not in ISO 8879 list) do not clash with any
     existing ISO 8879 entity names. ISO 10646 character numbers
     are given for each character, in hex. values are decimal
     conversions of the ISO 10646 values and refer to the document
     character set. Names are Unicode names. 
-->

<!-- C0 Controls and Basic Latin -->
<!ENTITY quot    "&#34;"> <!--  quotation mark = APL quote,
                                    U+0022 ISOnum -->
<!ENTITY amp     "&#38;#38;"> <!--  ampersand, U+0026 ISOnum -->
<!ENTITY lt      "&#38;#60;"> <!--  less-than sign, U+003C ISOnum -->
<!ENTITY gt      "&#62;"> <!--  greater-than sign, U+003E ISOnum -->
<!ENTITY apos	 "&#39;"> <!--  apostrophe mark, U+0027 ISOnum -->

<!-- Latin Extended-A -->
<!ENTITY OElig   "&#338;"> <!--  latin capital ligature OE,
                                    U+0152 ISOlat2 -->
<!ENTITY oelig   "&#339;"> <!--  latin small ligature oe, U+0153 ISOlat2 -->
<!-- ligature is a misnomer, this is a separate character in some languages -->
<!ENTITY Scaron  "&#352;"> <!--  latin capital letter S with caron,
                                    U+0160 ISOlat2 -->
<!ENTITY scaron  "&#353;"> <!--  latin small letter s with caron,
                                    U+0161 ISOlat2 -->
<!ENTITY Yuml    "&#376;"> <!--  latin capital letter Y with diaeresis,
                                    U+0178 ISOlat2 -->

<!-- Spacing Modifier Letters -->
<!ENTITY circ    "&#710;"> <!--  modifier letter circumflex accent,
                                    U+02C6 ISOpub -->
<!ENTITY tilde   "&#732;"> <!--  small tilde, U+02DC ISOdia -->

<!-- General Punctuation -->
<!ENTITY ensp    "&#8194;"> <!-- en space, U+2002 ISOpub -->
<!ENTITY emsp    "&#8195;"> <!-- em space, U+2003 ISOpub -->
<!ENTITY thinsp  "&#8201;"> <!-- thin space, U+2009 ISOpub -->
<!ENTITY zwnj    "&#8204;"> <!-- zero width non-joiner,
                                    U+200C NEW RFC 2070 -->
<!ENTITY zwj     "&#8205;"> <!-- zero width joiner, U+200D NEW RFC 2070 -->
<!ENTITY lrm     "&#8206;"> <!-- left-to-right mark, U+200E NEW RFC 2070 -->
<!ENTITY rlm     "&#8207;"> <!-- right-to-left mark, U+200F NEW RFC 2070 -->
<!ENTITY ndash   "&#8211;"> <!-- en dash, U+2013 ISOpub -->
<!ENTITY mdash   "&#8212;"> <!-- em dash, U+2014 ISOpub -->
<!ENTITY lsquo   "&#8216;"> <!-- left single quotation mark,
                                    U+2018 ISOnum -->
<!ENTITY rsquo   "&#8217;"> <!-- right single quotation mark,
                                    U+2019 ISOnum -->
<!ENTITY sbquo   "&#8218;"> <!-- single low-9 quotation mark, U+201A NEW -->
<!ENTITY ldquo   "&#8220;"> <!-- left double quotation mark,
                                    U+201C ISOnum -->
<!ENTITY rdquo   "&#8221;"> <!-- right double quotation mark,
                                    U+201D ISOnum -->
<!ENTITY bdquo   "&#8222;"> <!-- double low-9 quotation mark, U+201E NEW -->
<!ENTITY dagger  "&#8224;"> <!-- dagger, U+2020 ISOpub -->
<!ENTITY Dagger  "&#8225;"> <!-- double dagger, U+2021 ISOpub -->
<!ENTITY permil  "&#8240;"> <!-- per mille sign, U+2030 ISOtech -->
<!ENTITY lsaquo  "&#8249;"> <!-- single left-pointing angle quotation mark,
                                    U+2039 ISO proposed -->
<!-- lsaquo is proposed but not yet ISO standardized -->
<!ENTITY rsaquo  "&#8250;"> <!-- single right-pointing angle quotation mark,
                                    U+203A ISO proposed -->
<!-- rsaquo is proposed but not yet ISO standardized -->
<!ENTITY euro   "&#8364;"> <!--  euro sign, U+20AC NEW -->


<!-- end of xhtml-charent-1.mod -->
]]>

<!-- end of xhtml-framework-1.mod -->
]]>

<!-- Post-Framework Redeclaration placeholder  ................... -->
<!-- this serves as a location to insert markup declarations
     into the DTD following the framework declarations.
-->
<!ENTITY % xhtml-postfw-redecl.module "IGNORE" >
<![%xhtml-postfw-redecl.module;[
%xhtml-postfw-redecl.mod;
<!-- end of xhtml-postfw-redecl.module -->]]>

<!-- Text Module (Required)  ..................................... -->
<!ENTITY % xhtml-text.module "INCLUDE" >
<![%xhtml-text.module;[
<!ENTITY % xhtml-text.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Text 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-text-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Text Module  ................................................... -->
<!-- file: xhtml-text-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-text-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Text 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-text-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Textual Content

     The Text module includes declarations for all core
     text container elements and their attributes.
-->

<!ENTITY % xhtml-inlstruct.module "INCLUDE" >
<![%xhtml-inlstruct.module;[
<!ENTITY % xhtml-inlstruct.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Inline Structural 1.0//EN"
            "xhtml-inlstruct-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Inline Structural Module  ...................................... -->
<!-- file: xhtml-inlstruct-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-inlstruct-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Inline Structural 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-inlstruct-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Inline Structural

        br, span

     This module declares the elements and their attributes
     used to support inline-level structural markup.
-->

<!-- br: forced line break ............................. -->

<!ENTITY % br.element  "INCLUDE" >
<![%br.element;[

<!ENTITY % br.content  "EMPTY" >
<!ENTITY % br.qname  "br" >
<!ELEMENT %br.qname;  %br.content; >

<!-- end of br.element -->]]>

<!ENTITY % br.attlist  "INCLUDE" >
<![%br.attlist;[
<!ATTLIST %br.qname;
      %Core.attrib;
>
<!-- end of br.attlist -->]]>

<!-- span: generic inline container .................... -->

<!ENTITY % span.element  "INCLUDE" >
<![%span.element;[
<!ENTITY % span.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % span.qname  "span" >
<!ELEMENT %span.qname;  %span.content; >
<!-- end of span.element -->]]>

<!ENTITY % span.attlist  "INCLUDE" >
<![%span.attlist;[
<!ATTLIST %span.qname;
      %Common.attrib;
>
<!-- end of span.attlist -->]]>

<!-- end of xhtml-inlstruct-1.mod -->
]]>

<!ENTITY % xhtml-inlphras.module "INCLUDE" >
<![%xhtml-inlphras.module;[
<!ENTITY % xhtml-inlphras.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Inline Phrasal 1.0//EN"
            "xhtml-inlphras-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Inline Phrasal Module  ......................................... -->
<!-- file: xhtml-inlphras-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-inlphras-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Inline Phrasal 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-inlphras-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Inline Phrasal

        abbr, acronym, cite, code, dfn, em, kbd, q, samp, strong, var

     This module declares the elements and their attributes used to
     support inline-level phrasal markup.
-->

<!ENTITY % abbr.element  "INCLUDE" >
<![%abbr.element;[
<!ENTITY % abbr.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % abbr.qname  "abbr" >
<!ELEMENT %abbr.qname;  %abbr.content; >
<!-- end of abbr.element -->]]>

<!ENTITY % abbr.attlist  "INCLUDE" >
<![%abbr.attlist;[
<!ATTLIST %abbr.qname;
      %Common.attrib;
>
<!-- end of abbr.attlist -->]]>

<!ENTITY % acronym.element  "INCLUDE" >
<![%acronym.element;[
<!ENTITY % acronym.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % acronym.qname  "acronym" >
<!ELEMENT %acronym.qname;  %acronym.content; >
<!-- end of acronym.element -->]]>

<!ENTITY % acronym.attlist  "INCLUDE" >
<![%acronym.attlist;[
<!ATTLIST %acronym.qname;
      %Common.attrib;
>
<!-- end of acronym.attlist -->]]>

<!ENTITY % cite.element  "INCLUDE" >
<![%cite.element;[
<!ENTITY % cite.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % cite.qname  "cite" >
<!ELEMENT %cite.qname;  %cite.content; >
<!-- end of cite.element -->]]>

<!ENTITY % cite.attlist  "INCLUDE" >
<![%cite.attlist;[
<!ATTLIST %cite.qname;
      %Common.attrib;
>
<!-- end of cite.attlist -->]]>

<!ENTITY % code.element  "INCLUDE" >
<![%code.element;[
<!ENTITY % code.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % code.qname  "code" >
<!ELEMENT %code.qname;  %code.content; >
<!-- end of code.element -->]]>

<!ENTITY % code.attlist  "INCLUDE" >
<![%code.attlist;[
<!ATTLIST %code.qname;
      %Common.attrib;
>
<!-- end of code.attlist -->]]>

<!ENTITY % dfn.element  "INCLUDE" >
<![%dfn.element;[
<!ENTITY % dfn.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % dfn.qname  "dfn" >
<!ELEMENT %dfn.qname;  %dfn.content; >
<!-- end of dfn.element -->]]>

<!ENTITY % dfn.attlist  "INCLUDE" >
<![%dfn.attlist;[
<!ATTLIST %dfn.qname;
      %Common.attrib;
>
<!-- end of dfn.attlist -->]]>

<!ENTITY % em.element  "INCLUDE" >
<![%em.element;[
<!ENTITY % em.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % em.qname  "em" >
<!ELEMENT %em.qname;  %em.content; >
<!-- end of em.element -->]]>

<!ENTITY % em.attlist  "INCLUDE" >
<![%em.attlist;[
<!ATTLIST %em.qname;
      %Common.attrib;
>
<!-- end of em.attlist -->]]>

<!ENTITY % kbd.element  "INCLUDE" >
<![%kbd.element;[
<!ENTITY % kbd.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % kbd.qname  "kbd" >
<!ELEMENT %kbd.qname;  %kbd.content; >
<!-- end of kbd.element -->]]>

<!ENTITY % kbd.attlist  "INCLUDE" >
<![%kbd.attlist;[
<!ATTLIST %kbd.qname;
      %Common.attrib;
>
<!-- end of kbd.attlist -->]]>

<!ENTITY % q.element  "INCLUDE" >
<![%q.element;[
<!ENTITY % q.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % q.qname  "q" >
<!ELEMENT %q.qname;  %q.content; >
<!-- end of q.element -->]]>

<!ENTITY % q.attlist  "INCLUDE" >
<![%q.attlist;[
<!ATTLIST %q.qname;
      %Common.attrib;
      cite         %URI.datatype;           #IMPLIED
>
<!-- end of q.attlist -->]]>

<!ENTITY % samp.element  "INCLUDE" >
<![%samp.element;[
<!ENTITY % samp.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % samp.qname  "samp" >
<!ELEMENT %samp.qname;  %samp.content; >
<!-- end of samp.element -->]]>

<!ENTITY % samp.attlist  "INCLUDE" >
<![%samp.attlist;[
<!ATTLIST %samp.qname;
      %Common.attrib;
>
<!-- end of samp.attlist -->]]>

<!ENTITY % strong.element  "INCLUDE" >
<![%strong.element;[
<!ENTITY % strong.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % strong.qname  "strong" >
<!ELEMENT %strong.qname;  %strong.content; >
<!-- end of strong.element -->]]>

<!ENTITY % strong.attlist  "INCLUDE" >
<![%strong.attlist;[
<!ATTLIST %strong.qname;
      %Common.attrib;
>
<!-- end of strong.attlist -->]]>

<!ENTITY % var.element  "INCLUDE" >
<![%var.element;[
<!ENTITY % var.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % var.qname  "var" >
<!ELEMENT %var.qname;  %var.content; >
<!-- end of var.element -->]]>

<!ENTITY % var.attlist  "INCLUDE" >
<![%var.attlist;[
<!ATTLIST %var.qname;
      %Common.attrib;
>
<!-- end of var.attlist -->]]>

<!-- end of xhtml-inlphras-1.mod -->
]]>

<!ENTITY % xhtml-blkstruct.module "INCLUDE" >
<![%xhtml-blkstruct.module;[
<!ENTITY % xhtml-blkstruct.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Block Structural 1.0//EN"
            "xhtml-blkstruct-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Block Structural Module  ....................................... -->
<!-- file: xhtml-blkstruct-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-blkstruct-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Block Structural 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-blkstruct-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Block Structural

        div, p

     This module declares the elements and their attributes used to
     support block-level structural markup.
-->

<!ENTITY % div.element  "INCLUDE" >
<![%div.element;[
<!ENTITY % div.content
     "( #PCDATA | %Flow.mix; )*"
>
<!ENTITY % div.qname  "div" >
<!ELEMENT %div.qname;  %div.content; >
<!-- end of div.element -->]]>

<!ENTITY % div.attlist  "INCLUDE" >
<![%div.attlist;[
<!ATTLIST %div.qname;
      %Common.attrib;
>
<!-- end of div.attlist -->]]>

<!ENTITY % p.element  "INCLUDE" >
<![%p.element;[
<!ENTITY % p.content
     "( #PCDATA | %Inline.mix; )*" >
<!ENTITY % p.qname  "p" >
<!ELEMENT %p.qname;  %p.content; >
<!-- end of p.element -->]]>

<!ENTITY % p.attlist  "INCLUDE" >
<![%p.attlist;[
<!ATTLIST %p.qname;
      %Common.attrib;
>
<!-- end of p.attlist -->]]>

<!-- end of xhtml-blkstruct-1.mod -->
]]>

<!ENTITY % xhtml-blkphras.module "INCLUDE" >
<![%xhtml-blkphras.module;[
<!ENTITY % xhtml-blkphras.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Block Phrasal 1.0//EN"
            "xhtml-blkphras-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Block Phrasal Module  .......................................... -->
<!-- file: xhtml-blkphras-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-blkphras-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Block Phrasal 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-blkphras-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Block Phrasal

        address, blockquote, pre, h1, h2, h3, h4, h5, h6

     This module declares the elements and their attributes used to
     support block-level phrasal markup.
-->

<!ENTITY % address.element  "INCLUDE" >
<![%address.element;[
<!ENTITY % address.content
     "( #PCDATA | %Inline.mix; )*" >
<!ENTITY % address.qname  "address" >
<!ELEMENT %address.qname;  %address.content; >
<!-- end of address.element -->]]>

<!ENTITY % address.attlist  "INCLUDE" >
<![%address.attlist;[
<!ATTLIST %address.qname;
      %Common.attrib;
>
<!-- end of address.attlist -->]]>

<!ENTITY % blockquote.element  "INCLUDE" >
<![%blockquote.element;[
<!ENTITY % blockquote.content
     "( %Block.mix; )+"
>
<!ENTITY % blockquote.qname  "blockquote" >
<!ELEMENT %blockquote.qname;  %blockquote.content; >
<!-- end of blockquote.element -->]]>

<!ENTITY % blockquote.attlist  "INCLUDE" >
<![%blockquote.attlist;[
<!ATTLIST %blockquote.qname;
      %Common.attrib;
      cite         %URI.datatype;           #IMPLIED
>
<!-- end of blockquote.attlist -->]]>

<!ENTITY % pre.element  "INCLUDE" >
<![%pre.element;[
<!ENTITY % pre.content
     "( #PCDATA
      | %InlStruct.class;
      %InlPhras.class;
      | %tt.qname; | %i.qname; | %b.qname;
      %I18n.class;
      %Anchor.class;
      | %script.qname; | %map.qname;
      %Inline.extra; )*"
>
<!ENTITY % pre.qname  "pre" >
<!ELEMENT %pre.qname;  %pre.content; >
<!-- end of pre.element -->]]>

<!ENTITY % pre.attlist  "INCLUDE" >
<![%pre.attlist;[
<!ATTLIST %pre.qname;
      %Common.attrib;
      xml:space    ( preserve )             #FIXED 'preserve'
>
<!-- end of pre.attlist -->]]>

<!-- ...................  Heading Elements  ................... -->

<!ENTITY % Heading.content  "( #PCDATA | %Inline.mix; )*" >

<!ENTITY % h1.element  "INCLUDE" >
<![%h1.element;[
<!ENTITY % h1.qname  "h1" >
<!ELEMENT %h1.qname;  %Heading.content; >
<!-- end of h1.element -->]]>

<!ENTITY % h1.attlist  "INCLUDE" >
<![%h1.attlist;[
<!ATTLIST %h1.qname;
      %Common.attrib;
>
<!-- end of h1.attlist -->]]>

<!ENTITY % h2.element  "INCLUDE" >
<![%h2.element;[
<!ENTITY % h2.qname  "h2" >
<!ELEMENT %h2.qname;  %Heading.content; >
<!-- end of h2.element -->]]>

<!ENTITY % h2.attlist  "INCLUDE" >
<![%h2.attlist;[
<!ATTLIST %h2.qname;
      %Common.attrib;
>
<!-- end of h2.attlist -->]]>

<!ENTITY % h3.element  "INCLUDE" >
<![%h3.element;[
<!ENTITY % h3.qname  "h3" >
<!ELEMENT %h3.qname;  %Heading.content; >
<!-- end of h3.element -->]]>

<!ENTITY % h3.attlist  "INCLUDE" >
<![%h3.attlist;[
<!ATTLIST %h3.qname;
      %Common.attrib;
>
<!-- end of h3.attlist -->]]>

<!ENTITY % h4.element  "INCLUDE" >
<![%h4.element;[
<!ENTITY % h4.qname  "h4" >
<!ELEMENT %h4.qname;  %Heading.content; >
<!-- end of h4.element -->]]>

<!ENTITY % h4.attlist  "INCLUDE" >
<![%h4.attlist;[
<!ATTLIST %h4.qname;
      %Common.attrib;
>
<!-- end of h4.attlist -->]]>

<!ENTITY % h5.element  "INCLUDE" >
<![%h5.element;[
<!ENTITY % h5.qname  "h5" >
<!ELEMENT %h5.qname;  %Heading.content; >
<!-- end of h5.element -->]]>

<!ENTITY % h5.attlist  "INCLUDE" >
<![%h5.attlist;[
<!ATTLIST %h5.qname;
      %Common.attrib;
>
<!-- end of h5.attlist -->]]>

<!ENTITY % h6.element  "INCLUDE" >
<![%h6.element;[
<!ENTITY % h6.qname  "h6" >
<!ELEMENT %h6.qname;  %Heading.content; >
<!-- end of h6.element -->]]>

<!ENTITY % h6.attlist  "INCLUDE" >
<![%h6.attlist;[
<!ATTLIST %h6.qname;
      %Common.attrib;
>
<!-- end of h6.attlist -->]]>

<!-- end of xhtml-blkphras-1.mod -->
]]>

<!-- end of xhtml-text-1.mod -->
]]>

<!-- Hypertext Module (required) ................................. -->
<!ENTITY % xhtml-hypertext.module "INCLUDE" >
<![%xhtml-hypertext.module;[
<!ENTITY % xhtml-hypertext.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-hypertext-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Hypertext Module  .............................................. -->
<!-- file: xhtml-hypertext-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-hypertext-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-hypertext-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Hypertext

        a

     This module declares the anchor ('a') element type, which
     defines the source of a hypertext link. The destination
     (or link 'target') is identified via its 'id' attribute
     rather than the 'name' attribute as was used in HTML.
-->

<!-- ............  Anchor Element  ............ -->

<!ENTITY % a.element  "INCLUDE" >
<![%a.element;[
<!ENTITY % a.content
     "( #PCDATA | %InlNoAnchor.mix; )*"
>
<!ENTITY % a.qname  "a" >
<!ELEMENT %a.qname;  %a.content; >
<!-- end of a.element -->]]>

<!ENTITY % a.attlist  "INCLUDE" >
<![%a.attlist;[
<!ATTLIST %a.qname;
      %Common.attrib;
      href         %URI.datatype;           #IMPLIED
      charset      %Charset.datatype;       #IMPLIED
      type         %ContentType.datatype;   #IMPLIED
      hreflang     %LanguageCode.datatype;  #IMPLIED
      rel          %LinkTypes.datatype;     #IMPLIED
      rev          %LinkTypes.datatype;     #IMPLIED
      accesskey    %Character.datatype;     #IMPLIED
      tabindex     %Number.datatype;        #IMPLIED
>
<!-- end of a.attlist -->]]>

<!-- end of xhtml-hypertext-1.mod -->
]]>

<!-- Lists Module (required)  .................................... -->
<!ENTITY % xhtml-list.module "INCLUDE" >
<![%xhtml-list.module;[
<!ENTITY % xhtml-list.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-list-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Lists Module  .................................................. -->
<!-- file: xhtml-list-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-list-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-list-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Lists

        dl, dt, dd, ol, ul, li

     This module declares the list-oriented element types
     and their attributes.
-->

<!ENTITY % dl.qname  "dl" >
<!ENTITY % dt.qname  "dt" >
<!ENTITY % dd.qname  "dd" >
<!ENTITY % ol.qname  "ol" >
<!ENTITY % ul.qname  "ul" >
<!ENTITY % li.qname  "li" >

<!-- dl: Definition List ............................... -->

<!ENTITY % dl.element  "INCLUDE" >
<![%dl.element;[
<!ENTITY % dl.content  "( %dt.qname; | %dd.qname; )+" >
<!ELEMENT %dl.qname;  %dl.content; >
<!-- end of dl.element -->]]>

<!ENTITY % dl.attlist  "INCLUDE" >
<![%dl.attlist;[
<!ATTLIST %dl.qname;
      %Common.attrib;
>
<!-- end of dl.attlist -->]]>

<!-- dt: Definition Term ............................... -->

<!ENTITY % dt.element  "INCLUDE" >
<![%dt.element;[
<!ENTITY % dt.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ELEMENT %dt.qname;  %dt.content; >
<!-- end of dt.element -->]]>

<!ENTITY % dt.attlist  "INCLUDE" >
<![%dt.attlist;[
<!ATTLIST %dt.qname;
      %Common.attrib;
>
<!-- end of dt.attlist -->]]>

<!-- dd: Definition Description ........................ -->

<!ENTITY % dd.element  "INCLUDE" >
<![%dd.element;[
<!ENTITY % dd.content
     "( #PCDATA | %Flow.mix; )*"
>
<!ELEMENT %dd.qname;  %dd.content; >
<!-- end of dd.element -->]]>

<!ENTITY % dd.attlist  "INCLUDE" >
<![%dd.attlist;[
<!ATTLIST %dd.qname;
      %Common.attrib;
>
<!-- end of dd.attlist -->]]>

<!-- ol: Ordered List (numbered styles) ................ -->

<!ENTITY % ol.element  "INCLUDE" >
<![%ol.element;[
<!ENTITY % ol.content  "( %li.qname; )+" >
<!ELEMENT %ol.qname;  %ol.content; >
<!-- end of ol.element -->]]>

<!ENTITY % ol.attlist  "INCLUDE" >
<![%ol.attlist;[
<!ATTLIST %ol.qname;
      %Common.attrib;
>
<!-- end of ol.attlist -->]]>

<!-- ul: Unordered List (bullet styles) ................ -->

<!ENTITY % ul.element  "INCLUDE" >
<![%ul.element;[
<!ENTITY % ul.content  "( %li.qname; )+" >
<!ELEMENT %ul.qname;  %ul.content; >
<!-- end of ul.element -->]]>

<!ENTITY % ul.attlist  "INCLUDE" >
<![%ul.attlist;[
<!ATTLIST %ul.qname;
      %Common.attrib;
>
<!-- end of ul.attlist -->]]>

<!-- li: List Item ..................................... -->

<!ENTITY % li.element  "INCLUDE" >
<![%li.element;[
<!ENTITY % li.content
     "( #PCDATA | %Flow.mix; )*"
>
<!ELEMENT %li.qname;  %li.content; >
<!-- end of li.element -->]]>

<!ENTITY % li.attlist  "INCLUDE" >
<![%li.attlist;[
<!ATTLIST %li.qname;
      %Common.attrib;
>
<!-- end of li.attlist -->]]>

<!-- end of xhtml-list-1.mod -->
]]>

<!-- ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: -->

<!-- Edit Module  ................................................ -->
<!ENTITY % xhtml-edit.module "INCLUDE" >
<![%xhtml-edit.module;[
<!ENTITY % xhtml-edit.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Editing Elements 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-edit-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Editing Elements Module  ....................................... -->
<!-- file: xhtml-edit-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-edit-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Editing Markup 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-edit-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Editing Elements

        ins, del

     This module declares element types and attributes used to indicate
     inserted and deleted content while editing a document.
-->

<!-- ins: Inserted Text  ............................... -->

<!ENTITY % ins.element  "INCLUDE" >
<![%ins.element;[
<!ENTITY % ins.content
     "( #PCDATA | %Flow.mix; )*"
>
<!ENTITY % ins.qname  "ins" >
<!ELEMENT %ins.qname;  %ins.content; >
<!-- end of ins.element -->]]>

<!ENTITY % ins.attlist  "INCLUDE" >
<![%ins.attlist;[
<!ATTLIST %ins.qname;
      %Common.attrib;
      cite         %URI.datatype;           #IMPLIED
      datetime     %Datetime.datatype;      #IMPLIED
>
<!-- end of ins.attlist -->]]>

<!-- del: Deleted Text  ................................ -->

<!ENTITY % del.element  "INCLUDE" >
<![%del.element;[
<!ENTITY % del.content
     "( #PCDATA | %Flow.mix; )*"
>
<!ENTITY % del.qname  "del" >
<!ELEMENT %del.qname;  %del.content; >
<!-- end of del.element -->]]>

<!ENTITY % del.attlist  "INCLUDE" >
<![%del.attlist;[
<!ATTLIST %del.qname;
      %Common.attrib;
      cite         %URI.datatype;           #IMPLIED
      datetime     %Datetime.datatype;      #IMPLIED
>
<!-- end of del.attlist -->]]>

<!-- end of xhtml-edit-1.mod -->
]]>

<!-- BIDI Override Module  ....................................... -->
<!ENTITY % xhtml-bdo.module "%XHTML.bidi;" >
<![%xhtml-bdo.module;[
<!ENTITY % xhtml-bdo.mod
     PUBLIC "-//W3C//ELEMENTS XHTML BIDI Override Element 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-bdo-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML BDO Element Module ............................................. -->
<!-- file: xhtml-bdo-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-bdo-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML BDO Element 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-bdo-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Bidirectional Override (bdo) Element

     This modules declares the element 'bdo', used to override the
     Unicode bidirectional algorithm for selected fragments of text.

     DEPENDENCIES:
     Relies on the conditional section keyword %XHTML.bidi; declared
     as "INCLUDE". Bidirectional text support includes both the bdo
     element and the 'dir' attribute.
-->

<!ENTITY % bdo.element  "INCLUDE" >
<![%bdo.element;[
<!ENTITY % bdo.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % bdo.qname  "bdo" >
<!ELEMENT %bdo.qname;  %bdo.content; >
<!-- end of bdo.element -->]]>

<!ENTITY % bdo.attlist  "INCLUDE" >
<![%bdo.attlist;[
<!ATTLIST %bdo.qname;
      %Core.attrib;
      xml:lang     %LanguageCode.datatype;  #IMPLIED
      dir          ( ltr | rtl )            #REQUIRED
>
]]>

<!-- end of xhtml-bdo-1.mod -->
]]>

<!-- Ruby Module  ................................................ -->
<!ENTITY % Ruby.common.attlists "INCLUDE" >
<!ENTITY % Ruby.common.attrib "%Common.attrib;" >
<!ENTITY % xhtml-ruby.module "INCLUDE" >
<![%xhtml-ruby.module;[
<!ENTITY % xhtml-ruby.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Ruby 1.0//EN"
            "http://www.w3.org/TR/ruby/xhtml-ruby-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Ruby Module .................................................... -->
<!-- file: xhtml-ruby-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1999-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-ruby-1.mod,v 4.0 2001/04/03 23:14:33 altheim Exp $

     This module is based on the W3C Ruby Annotation Specification:

        http://www.w3.org/TR/ruby

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Ruby 1.0//EN"
       SYSTEM "http://www.w3.org/TR/ruby/xhtml-ruby-1.mod"

     ...................................................................... -->

<!-- Ruby Elements

        ruby, rbc, rtc, rb, rt, rp

     This module declares the elements and their attributes used to
     support ruby annotation markup.
-->

<!-- declare qualified element type names:
-->
<!ENTITY % ruby.qname  "ruby" >
<!ENTITY % rbc.qname  "rbc" >
<!ENTITY % rtc.qname  "rtc" >
<!ENTITY % rb.qname  "rb" >
<!ENTITY % rt.qname  "rt" >
<!ENTITY % rp.qname  "rp" >

<!-- rp fallback is included by default.
-->
<!ENTITY % Ruby.fallback "INCLUDE" >
<!ENTITY % Ruby.fallback.mandatory "IGNORE" >

<!-- Complex ruby is included by default; it may be 
     overridden by other modules to ignore it.
-->
<!ENTITY % Ruby.complex "INCLUDE" >

<!-- Fragments for the content model of the ruby element -->
<![%Ruby.fallback;[
<![%Ruby.fallback.mandatory;[
<!ENTITY % Ruby.content.simple 
     "( %rb.qname;, %rp.qname;, %rt.qname;, %rp.qname; )"
>
]]>
<!ENTITY % Ruby.content.simple 
     "( %rb.qname;, ( %rt.qname; | ( %rp.qname;, %rt.qname;, %rp.qname; ) ) )"
>
]]>
<!ENTITY % Ruby.content.simple "( %rb.qname;, %rt.qname; )" >

<![%Ruby.complex;[
<!ENTITY % Ruby.content.complex 
     "| ( %rbc.qname;, %rtc.qname;, %rtc.qname;? )"
>
]]>
<!ENTITY % Ruby.content.complex "" >

<!-- Content models of the rb and the rt elements are intended to
     allow other inline-level elements of its parent markup language,
     but it should not include ruby descendent elements. The following
     parameter entity %NoRuby.content; can be used to redefine
     those content models with minimum effort.  It's defined as
     '( #PCDATA )' by default.
-->
<!ENTITY % NoRuby.content "( #PCDATA )" >

<!-- one or more digits (NUMBER) -->
<!ENTITY % Number.datatype "CDATA" >

<!-- ruby element ...................................... -->

<!ENTITY % ruby.element  "INCLUDE" >
<![%ruby.element;[
<!ENTITY % ruby.content
     "( %Ruby.content.simple; %Ruby.content.complex; )"
>
<!ELEMENT %ruby.qname;  %ruby.content; >
<!-- end of ruby.element -->]]>

<![%Ruby.complex;[
<!-- rbc (ruby base component) element ................. -->

<!ENTITY % rbc.element  "INCLUDE" >
<![%rbc.element;[
<!ENTITY % rbc.content
     "(%rb.qname;)+"
>
<!ELEMENT %rbc.qname;  %rbc.content; >
<!-- end of rbc.element -->]]>

<!-- rtc (ruby text component) element ................. -->

<!ENTITY % rtc.element  "INCLUDE" >
<![%rtc.element;[
<!ENTITY % rtc.content
     "(%rt.qname;)+"
>
<!ELEMENT %rtc.qname;  %rtc.content; >
<!-- end of rtc.element -->]]>
]]>

<!-- rb (ruby base) element ............................ -->

<!ENTITY % rb.element  "INCLUDE" >
<![%rb.element;[
<!-- %rb.content; uses %NoRuby.content; as its content model,
     which is '( #PCDATA )' by default. It may be overridden
     by other modules to allow other inline-level elements
     of its parent markup language, but it should not include
     ruby descendent elements.
-->
<!ENTITY % rb.content "%NoRuby.content;" >
<!ELEMENT %rb.qname;  %rb.content; >
<!-- end of rb.element -->]]>

<!-- rt (ruby text) element ............................ -->

<!ENTITY % rt.element  "INCLUDE" >
<![%rt.element;[
<!-- %rt.content; uses %NoRuby.content; as its content model,
     which is '( #PCDATA )' by default. It may be overridden
     by other modules to allow other inline-level elements
     of its parent markup language, but it should not include
     ruby descendent elements.
-->
<!ENTITY % rt.content "%NoRuby.content;" >

<!ELEMENT %rt.qname;  %rt.content; >
<!-- end of rt.element -->]]>

<!-- rbspan attribute is used for complex ruby only ...... -->
<![%Ruby.complex;[
<!ENTITY % rt.attlist  "INCLUDE" >
<![%rt.attlist;[
<!ATTLIST %rt.qname;
      rbspan         %Number.datatype;      "1"
>
<!-- end of rt.attlist -->]]>
]]>

<!-- rp (ruby parenthesis) element ..................... -->

<![%Ruby.fallback;[
<!ENTITY % rp.element  "INCLUDE" >
<![%rp.element;[
<!ENTITY % rp.content
     "( #PCDATA )"
>
<!ELEMENT %rp.qname;  %rp.content; >
<!-- end of rp.element -->]]>
]]>

<!-- Ruby Common Attributes

     The following optional ATTLIST declarations provide an easy way
     to define common attributes for ruby elements.  These declarations
     are ignored by default.

     Ruby elements are intended to have common attributes of its
     parent markup language.  For example, if a markup language defines
     common attributes as a parameter entity %attrs;, you may add
     those attributes by just declaring the following parameter entities

         <!ENTITY % Ruby.common.attlists  "INCLUDE" >
         <!ENTITY % Ruby.common.attrib  "%attrs;" >

     before including the Ruby module.
-->

<!ENTITY % Ruby.common.attlists  "IGNORE" >
<![%Ruby.common.attlists;[
<!ENTITY % Ruby.common.attrib  "" >

<!-- common attributes for ruby ........................ -->

<!ENTITY % Ruby.common.attlist  "INCLUDE" >
<![%Ruby.common.attlist;[
<!ATTLIST %ruby.qname;
      %Ruby.common.attrib;
>
<!-- end of Ruby.common.attlist -->]]>

<![%Ruby.complex;[
<!-- common attributes for rbc ......................... -->

<!ENTITY % Rbc.common.attlist  "INCLUDE" >
<![%Rbc.common.attlist;[
<!ATTLIST %rbc.qname;
      %Ruby.common.attrib;
>
<!-- end of Rbc.common.attlist -->]]>

<!-- common attributes for rtc ......................... -->

<!ENTITY % Rtc.common.attlist  "INCLUDE" >
<![%Rtc.common.attlist;[
<!ATTLIST %rtc.qname;
      %Ruby.common.attrib;
>
<!-- end of Rtc.common.attlist -->]]>
]]>

<!-- common attributes for rb .......................... -->

<!ENTITY % Rb.common.attlist  "INCLUDE" >
<![%Rb.common.attlist;[
<!ATTLIST %rb.qname;
      %Ruby.common.attrib;
>
<!-- end of Rb.common.attlist -->]]>

<!-- common attributes for rt .......................... -->

<!ENTITY % Rt.common.attlist  "INCLUDE" >
<![%Rt.common.attlist;[
<!ATTLIST %rt.qname;
      %Ruby.common.attrib;
>
<!-- end of Rt.common.attlist -->]]>

<![%Ruby.fallback;[
<!-- common attributes for rp .......................... -->

<!ENTITY % Rp.common.attlist  "INCLUDE" >
<![%Rp.common.attlist;[
<!ATTLIST %rp.qname;
      %Ruby.common.attrib;
>
<!-- end of Rp.common.attlist -->]]>
]]>
]]>

<!-- end of xhtml-ruby-1.mod -->
]]>

<!-- Presentation Module  ........................................ -->
<!ENTITY % xhtml-pres.module "INCLUDE" >
<![%xhtml-pres.module;[
<!ENTITY % xhtml-pres.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Presentation 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-pres-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Presentation Module ............................................ -->
<!-- file: xhtml-pres-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-pres-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Presentation 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-pres-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Presentational Elements

     This module defines elements and their attributes for
     simple presentation-related markup.
-->

<!ENTITY % xhtml-inlpres.module "INCLUDE" >
<![%xhtml-inlpres.module;[
<!ENTITY % xhtml-inlpres.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Inline Presentation 1.0//EN"
            "xhtml-inlpres-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Inline Presentation Module  .................................... -->
<!-- file: xhtml-inlpres-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-inlpres-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Inline Presentation 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-inlpres-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Inline Presentational Elements

        b, big, i, small, sub, sup, tt

     This module declares the elements and their attributes used to
     support inline-level presentational markup.
-->

<!ENTITY % b.element  "INCLUDE" >
<![%b.element;[
<!ENTITY % b.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % b.qname  "b" >
<!ELEMENT %b.qname;  %b.content; >
<!-- end of b.element -->]]>

<!ENTITY % b.attlist  "INCLUDE" >
<![%b.attlist;[
<!ATTLIST %b.qname;
      %Common.attrib;
>
<!-- end of b.attlist -->]]>

<!ENTITY % big.element  "INCLUDE" >
<![%big.element;[
<!ENTITY % big.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % big.qname  "big" >
<!ELEMENT %big.qname;  %big.content; >
<!-- end of big.element -->]]>

<!ENTITY % big.attlist  "INCLUDE" >
<![%big.attlist;[
<!ATTLIST %big.qname;
      %Common.attrib;
>
<!-- end of big.attlist -->]]>

<!ENTITY % i.element  "INCLUDE" >
<![%i.element;[
<!ENTITY % i.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % i.qname  "i" >
<!ELEMENT %i.qname;  %i.content; >
<!-- end of i.element -->]]>

<!ENTITY % i.attlist  "INCLUDE" >
<![%i.attlist;[
<!ATTLIST %i.qname;
      %Common.attrib;
>
<!-- end of i.attlist -->]]>

<!ENTITY % small.element  "INCLUDE" >
<![%small.element;[
<!ENTITY % small.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % small.qname  "small" >
<!ELEMENT %small.qname;  %small.content; >
<!-- end of small.element -->]]>

<!ENTITY % small.attlist  "INCLUDE" >
<![%small.attlist;[
<!ATTLIST %small.qname;
      %Common.attrib;
>
<!-- end of small.attlist -->]]>

<!ENTITY % sub.element  "INCLUDE" >
<![%sub.element;[
<!ENTITY % sub.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % sub.qname  "sub" >
<!ELEMENT %sub.qname;  %sub.content; >
<!-- end of sub.element -->]]>

<!ENTITY % sub.attlist  "INCLUDE" >
<![%sub.attlist;[
<!ATTLIST %sub.qname;
      %Common.attrib;
>
<!-- end of sub.attlist -->]]>

<!ENTITY % sup.element  "INCLUDE" >
<![%sup.element;[
<!ENTITY % sup.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % sup.qname  "sup" >
<!ELEMENT %sup.qname;  %sup.content; >
<!-- end of sup.element -->]]>

<!ENTITY % sup.attlist  "INCLUDE" >
<![%sup.attlist;[
<!ATTLIST %sup.qname;
      %Common.attrib;
>
<!-- end of sup.attlist -->]]>

<!ENTITY % tt.element  "INCLUDE" >
<![%tt.element;[
<!ENTITY % tt.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ENTITY % tt.qname  "tt" >
<!ELEMENT %tt.qname;  %tt.content; >
<!-- end of tt.element -->]]>

<!ENTITY % tt.attlist  "INCLUDE" >
<![%tt.attlist;[
<!ATTLIST %tt.qname;
      %Common.attrib;
>
<!-- end of tt.attlist -->]]>

<!-- end of xhtml-inlpres-1.mod -->
]]>

<!ENTITY % xhtml-blkpres.module "INCLUDE" >
<![%xhtml-blkpres.module;[
<!ENTITY % xhtml-blkpres.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Block Presentation 1.0//EN"
            "xhtml-blkpres-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Block Presentation Module  ..................................... -->
<!-- file: xhtml-blkpres-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-blkpres-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Block Presentation 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-blkpres-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Block Presentational Elements

        hr

     This module declares the elements and their attributes used to
     support block-level presentational markup.
-->

<!ENTITY % hr.element  "INCLUDE" >
<![%hr.element;[
<!ENTITY % hr.content  "EMPTY" >
<!ENTITY % hr.qname  "hr" >
<!ELEMENT %hr.qname;  %hr.content; >
<!-- end of hr.element -->]]>

<!ENTITY % hr.attlist  "INCLUDE" >
<![%hr.attlist;[
<!ATTLIST %hr.qname;
      %Common.attrib;
>
<!-- end of hr.attlist -->]]>

<!-- end of xhtml-blkpres-1.mod -->
]]>

<!-- end of xhtml-pres-1.mod -->
]]>

<!-- Link Element Module  ........................................ -->
<!ENTITY % xhtml-link.module "INCLUDE" >
<![%xhtml-link.module;[
<!ENTITY % xhtml-link.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Link Element 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-link-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Link Element Module  ........................................... -->
<!-- file: xhtml-link-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-link-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Link Element 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-link-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Link element

        link

     This module declares the link element type and its attributes,
     which could (in principle) be used to define document-level links
     to external resources such as:

     a) for document specific toolbars/menus, e.g. start, contents,
        previous, next, index, end, help
     b) to link to a separate style sheet (rel="stylesheet")
     c) to make a link to a script (rel="script")
     d) by stylesheets to control how collections of html nodes are
        rendered into printed documents
     e) to make a link to a printable version of this document
        e.g. a postscript or pdf version (rel="alternate" media="print")
-->

<!-- link: Media-Independent Link ...................... -->

<!ENTITY % link.element  "INCLUDE" >
<![%link.element;[
<!ENTITY % link.content  "EMPTY" >
<!ENTITY % link.qname  "link" >
<!ELEMENT %link.qname;  %link.content; >
<!-- end of link.element -->]]>

<!ENTITY % link.attlist  "INCLUDE" >
<![%link.attlist;[
<!ATTLIST %link.qname;
      %Common.attrib;
      charset      %Charset.datatype;       #IMPLIED
      href         %URI.datatype;           #IMPLIED
      hreflang     %LanguageCode.datatype;  #IMPLIED
      type         %ContentType.datatype;   #IMPLIED
      rel          %LinkTypes.datatype;     #IMPLIED
      rev          %LinkTypes.datatype;     #IMPLIED
      media        %MediaDesc.datatype;     #IMPLIED
>
<!-- end of link.attlist -->]]>

<!-- end of xhtml-link-1.mod -->
]]>

<!-- Document Metainformation Module  ............................ -->
<!ENTITY % xhtml-meta.module "INCLUDE" >
<![%xhtml-meta.module;[
<!ENTITY % xhtml-meta.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Metainformation 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-meta-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Document Metainformation Module  ............................... -->
<!-- file: xhtml-meta-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-meta-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Metainformation 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-meta-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Meta Information

        meta

     This module declares the meta element type and its attributes,
     used to provide declarative document metainformation.
-->

<!-- meta: Generic Metainformation ..................... -->

<!ENTITY % meta.element  "INCLUDE" >
<![%meta.element;[
<!ENTITY % meta.content  "EMPTY" >
<!ENTITY % meta.qname  "meta" >
<!ELEMENT %meta.qname;  %meta.content; >
<!-- end of meta.element -->]]>

<!ENTITY % meta.attlist  "INCLUDE" >
<![%meta.attlist;[
<!ATTLIST %meta.qname;
      %XHTML.xmlns.attrib;
      %I18n.attrib;
      http-equiv   NMTOKEN                  #IMPLIED
      name         NMTOKEN                  #IMPLIED
      content      CDATA                    #REQUIRED
      scheme       CDATA                    #IMPLIED
>
<!-- end of meta.attlist -->]]>

<!-- end of xhtml-meta-1.mod -->
]]>

<!-- Base Element Module  ........................................ -->
<!ENTITY % xhtml-base.module "INCLUDE" >
<![%xhtml-base.module;[
<!ENTITY % xhtml-base.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Base Element 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-base-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Base Element Module  ........................................... -->
<!-- file: xhtml-base-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-base-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Base Element 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-base-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Base element

        base

     This module declares the base element type and its attributes,
     used to define a base URI against which relative URIs in the
     document will be resolved.

     Note that this module also redeclares the content model for
     the head element to include the base element.
-->

<!-- base: Document Base URI ........................... -->

<!ENTITY % base.element  "INCLUDE" >
<![%base.element;[
<!ENTITY % base.content  "EMPTY" >
<!ENTITY % base.qname  "base" >
<!ELEMENT %base.qname;  %base.content; >
<!-- end of base.element -->]]>

<!ENTITY % base.attlist  "INCLUDE" >
<![%base.attlist;[
<!ATTLIST %base.qname;
      %XHTML.xmlns.attrib;
      href         %URI.datatype;           #REQUIRED
>
<!-- end of base.attlist -->]]>

<!ENTITY % head.content
    "( %HeadOpts.mix;,
     ( ( %title.qname;, %HeadOpts.mix;, ( %base.qname;, %HeadOpts.mix; )? )
     | ( %base.qname;, %HeadOpts.mix;, ( %title.qname;, %HeadOpts.mix; ))))"
>

<!-- end of xhtml-base-1.mod -->
]]>

<!-- Scripting Module  ........................................... -->
<!ENTITY % xhtml-script.module "INCLUDE" >
<![%xhtml-script.module;[
<!ENTITY % xhtml-script.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Scripting 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-script-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Document Scripting Module  ..................................... -->
<!-- file: xhtml-script-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-script-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Scripting 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-script-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Scripting

        script, noscript

     This module declares element types and attributes used to provide
     support for executable scripts as well as an alternate content
     container where scripts are not supported.
-->

<!-- script: Scripting Statement ....................... -->

<!ENTITY % script.element  "INCLUDE" >
<![%script.element;[
<!ENTITY % script.content  "( #PCDATA )" >
<!ENTITY % script.qname  "script" >
<!ELEMENT %script.qname;  %script.content; >
<!-- end of script.element -->]]>

<!ENTITY % script.attlist  "INCLUDE" >
<![%script.attlist;[
<!ATTLIST %script.qname;
      %XHTML.xmlns.attrib;
      charset      %Charset.datatype;       #IMPLIED
      type         %ContentType.datatype;   #REQUIRED
      src          %URI.datatype;           #IMPLIED
      defer        ( defer )                #IMPLIED
      xml:space    ( preserve )             #FIXED 'preserve'
>
<!-- end of script.attlist -->]]>

<!-- noscript: No-Script Alternate Content ............. -->

<!ENTITY % noscript.element  "INCLUDE" >
<![%noscript.element;[
<!ENTITY % noscript.content
     "( %Block.mix; )+"
>
<!ENTITY % noscript.qname  "noscript" >
<!ELEMENT %noscript.qname;  %noscript.content; >
<!-- end of noscript.element -->]]>

<!ENTITY % noscript.attlist  "INCLUDE" >
<![%noscript.attlist;[
<!ATTLIST %noscript.qname;
      %Common.attrib;
>
<!-- end of noscript.attlist -->]]>

<!-- end of xhtml-script-1.mod -->
]]>

<!-- Style Sheets Module  ......................................... -->
<!ENTITY % xhtml-style.module "INCLUDE" >
<![%xhtml-style.module;[
<!ENTITY % xhtml-style.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Style Sheets 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-style-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Document Style Sheet Module  .................................... -->
<!-- file: xhtml-style-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-style-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//DTD XHTML Style Sheets 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-style-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Style Sheets

        style

     This module declares the style element type and its attributes,
     used to embed stylesheet information in the document head element.
-->

<!-- style: Style Sheet Information ..................... -->

<!ENTITY % style.element  "INCLUDE" >
<![%style.element;[
<!ENTITY % style.content  "( #PCDATA )" >
<!ENTITY % style.qname  "style" >
<!ELEMENT %style.qname;  %style.content; >
<!-- end of style.element -->]]>

<!ENTITY % style.attlist  "INCLUDE" >
<![%style.attlist;[
<!ATTLIST %style.qname;
      %XHTML.xmlns.attrib;
      %title.attrib;
      %I18n.attrib;
      type         %ContentType.datatype;   #REQUIRED
      media        %MediaDesc.datatype;     #IMPLIED
      xml:space    ( preserve )             #FIXED 'preserve'
>
<!-- end of style.attlist -->]]>

<!-- end of xhtml-style-1.mod -->
]]>

<!-- Image Module  ............................................... -->
<!ENTITY % xhtml-image.module "INCLUDE" >
<![%xhtml-image.module;[
<!ENTITY % xhtml-image.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Images 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-image-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Images Module  ................................................. -->
<!-- file: xhtml-image-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Rovision: $Id: xhtml-image-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Images 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-image-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Images

        img

     This module provides markup to support basic image embedding.
-->

<!-- To avoid problems with text-only UAs as well as to make
     image content understandable and navigable to users of
     non-visual UAs, you need to provide a description with
     the 'alt' attribute, and avoid server-side image maps.
-->

<!ENTITY % img.element  "INCLUDE" >
<![%img.element;[
<!ENTITY % img.content  "EMPTY" >
<!ENTITY % img.qname  "img" >
<!ELEMENT %img.qname;  %img.content; >
<!-- end of img.element -->]]>

<!ENTITY % img.attlist  "INCLUDE" >
<![%img.attlist;[
<!ATTLIST %img.qname;
      %Common.attrib;
      src          %URI.datatype;           #REQUIRED
      alt          %Text.datatype;          #REQUIRED
      longdesc     %URI.datatype;           #IMPLIED
      height       %Length.datatype;        #IMPLIED
      width        %Length.datatype;        #IMPLIED
>
<!-- end of img.attlist -->]]>

<!-- end of xhtml-image-1.mod -->
]]>

<!-- Client-side Image Map Module  ............................... -->
<!ENTITY % xhtml-csismap.module "INCLUDE" >
<![%xhtml-csismap.module;[
<!ENTITY % xhtml-csismap.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Client-side Image Maps 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-csismap-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Client-side Image Map Module  .................................. -->
<!-- file: xhtml-csismap-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-csismap-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Client-side Image Maps 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-csismap-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Client-side Image Maps

        area, map

     This module declares elements and attributes to support client-side
     image maps. This requires that the Image Module (or a module
     declaring the img element type) be included in the DTD.

     These can be placed in the same document or grouped in a
     separate document, although the latter isn't widely supported
-->

<!ENTITY % area.element  "INCLUDE" >
<![%area.element;[
<!ENTITY % area.content  "EMPTY" >
<!ENTITY % area.qname  "area" >
<!ELEMENT %area.qname;  %area.content; >
<!-- end of area.element -->]]>

<!ENTITY % Shape.datatype "( rect | circle | poly | default )">
<!ENTITY % Coords.datatype "CDATA" >

<!ENTITY % area.attlist  "INCLUDE" >
<![%area.attlist;[
<!ATTLIST %area.qname;
      %Common.attrib;
      href         %URI.datatype;           #IMPLIED
      shape        %Shape.datatype;         'rect'
      coords       %Coords.datatype;        #IMPLIED
      nohref       ( nohref )               #IMPLIED
      alt          %Text.datatype;          #REQUIRED
      tabindex     %Number.datatype;        #IMPLIED
      accesskey    %Character.datatype;     #IMPLIED
>
<!-- end of area.attlist -->]]>

<!-- modify anchor attribute definition list
     to allow for client-side image maps
-->
<!ATTLIST %a.qname;
      shape        %Shape.datatype;         'rect'
      coords       %Coords.datatype;        #IMPLIED
>

<!-- modify img attribute definition list
     to allow for client-side image maps
-->
<!ATTLIST %img.qname;
      usemap       IDREF                    #IMPLIED
>

<!-- modify form input attribute definition list
     to allow for client-side image maps
-->
<!ATTLIST %input.qname;
      usemap       IDREF                    #IMPLIED
>

<!-- modify object attribute definition list
     to allow for client-side image maps
-->
<!ATTLIST %object.qname;
      usemap       IDREF                    #IMPLIED
>

<!-- 'usemap' points to the 'id' attribute of a <map> element,
     which must be in the same document; support for external
     document maps was not widely supported in HTML and is
     eliminated in XHTML.

     It is considered an error for the element pointed to by
     a usemap IDREF to occur in anything but a <map> element.
-->

<!ENTITY % map.element  "INCLUDE" >
<![%map.element;[
<!ENTITY % map.content
     "(( %Block.mix; ) | %area.qname; )+"
>
<!ENTITY % map.qname  "map" >
<!ELEMENT %map.qname;  %map.content; >
<!-- end of map.element -->]]>

<!ENTITY % map.attlist  "INCLUDE" >
<![%map.attlist;[
<!ATTLIST %map.qname;
      %XHTML.xmlns.attrib;
      id           ID                       #REQUIRED
      %class.attrib;
      %title.attrib;
      %Core.extra.attrib;
      %I18n.attrib;
      %Events.attrib;
>
<!-- end of map.attlist -->]]>

<!-- end of xhtml-csismap-1.mod -->
]]>

<!-- Server-side Image Map Module  ............................... -->
<!ENTITY % xhtml-ssismap.module "INCLUDE" >
<![%xhtml-ssismap.module;[
<!ENTITY % xhtml-ssismap.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Server-side Image Maps 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-ssismap-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Server-side Image Map Module  .................................. -->
<!-- file: xhtml-ssismap-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-ssismap-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Server-side Image Maps 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-ssismap-1.mod"

     Revisions:
#2000-10-22: added declaration for 'ismap' on <input>
     ....................................................................... -->

<!-- Server-side Image Maps

     This adds the 'ismap' attribute to the img and input elements
     to support server-side processing of a user selection.
-->

<!ATTLIST %img.qname;
      ismap        ( ismap )                #IMPLIED
>

<!ATTLIST %input.qname;
      ismap        ( ismap )                #IMPLIED
>

<!-- end of xhtml-ssismap-1.mod -->
]]>

<!-- Param Element Module  ....................................... -->
<!ENTITY % xhtml-param.module "INCLUDE" >
<![%xhtml-param.module;[
<!ENTITY % xhtml-param.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Param Element 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-param-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Param Element Module  ..................................... -->
<!-- file: xhtml-param-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-param-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Param Element 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-param-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Parameters for Java Applets and Embedded Objects

        param

     This module provides declarations for the param element,
     used to provide named property values for the applet
     and object elements.
-->

<!-- param: Named Property Value ....................... -->

<!ENTITY % param.element  "INCLUDE" >
<![%param.element;[
<!ENTITY % param.content  "EMPTY" >
<!ENTITY % param.qname  "param" >
<!ELEMENT %param.qname;  %param.content; >
<!-- end of param.element -->]]>

<!ENTITY % param.attlist  "INCLUDE" >
<![%param.attlist;[
<!ATTLIST %param.qname;
      %XHTML.xmlns.attrib;
      %id.attrib;
      name         CDATA                    #REQUIRED
      value        CDATA                    #IMPLIED
      valuetype    ( data | ref | object )  'data'
      type         %ContentType.datatype;   #IMPLIED
>
<!-- end of param.attlist -->]]>

<!-- end of xhtml-param-1.mod -->
]]>

<!-- Embedded Object Module  ..................................... -->
<!ENTITY % xhtml-object.module "INCLUDE" >
<![%xhtml-object.module;[
<!ENTITY % xhtml-object.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Embedded Object 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-object-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Embedded Object Module  ........................................ -->
<!-- file: xhtml-object-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-object-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Embedded Object 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-object-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Embedded Objects

        object

     This module declares the object element type and its attributes, used
     to embed external objects as part of XHTML pages. In the document,
     place param elements prior to other content within the object element.

     Note that use of this module requires instantiation of the Param
     Element Module.
-->

<!-- object: Generic Embedded Object ................... -->

<!ENTITY % object.element  "INCLUDE" >
<![%object.element;[
<!ENTITY % object.content
     "( #PCDATA | %Flow.mix; | %param.qname; )*"
>
<!ENTITY % object.qname  "object" >
<!ELEMENT %object.qname;  %object.content; >
<!-- end of object.element -->]]>

<!ENTITY % object.attlist  "INCLUDE" >
<![%object.attlist;[
<!ATTLIST %object.qname;
      %Common.attrib;
      declare      ( declare )              #IMPLIED
      classid      %URI.datatype;           #IMPLIED
      codebase     %URI.datatype;           #IMPLIED
      data         %URI.datatype;           #IMPLIED
      type         %ContentType.datatype;   #IMPLIED
      codetype     %ContentType.datatype;   #IMPLIED
      archive      %URIs.datatype;          #IMPLIED
      standby      %Text.datatype;          #IMPLIED
      height       %Length.datatype;        #IMPLIED
      width        %Length.datatype;        #IMPLIED
      name         CDATA                    #IMPLIED
      tabindex     %Number.datatype;        #IMPLIED
>
<!-- end of object.attlist -->]]>

<!-- end of xhtml-object-1.mod -->
]]>

<!-- Tables Module ............................................... -->
<!ENTITY % xhtml-table.module "INCLUDE" >
<![%xhtml-table.module;[
<!ENTITY % xhtml-table.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Tables 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-table-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Table Module  .................................................. -->
<!-- file: xhtml-table-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-table-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Tables 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-table-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Tables

        table, caption, thead, tfoot, tbody, colgroup, col, tr, th, td

     This module declares element types and attributes used to provide
     table markup similar to HTML 4.0, including features that enable
     better accessibility for non-visual user agents.
-->

<!-- declare qualified element type names:
-->
<!ENTITY % table.qname  "table" >
<!ENTITY % caption.qname  "caption" >
<!ENTITY % thead.qname  "thead" >
<!ENTITY % tfoot.qname  "tfoot" >
<!ENTITY % tbody.qname  "tbody" >
<!ENTITY % colgroup.qname  "colgroup" >
<!ENTITY % col.qname  "col" >
<!ENTITY % tr.qname  "tr" >
<!ENTITY % th.qname  "th" >
<!ENTITY % td.qname  "td" >

<!-- The frame attribute specifies which parts of the frame around
     the table should be rendered. The values are not the same as
     CALS to avoid a name clash with the valign attribute.
-->
<!ENTITY % frame.attrib
     "frame        ( void
                   | above
                   | below
                   | hsides
                   | lhs
                   | rhs
                   | vsides
                   | box
                   | border )               #IMPLIED"
>

<!-- The rules attribute defines which rules to draw between cells:

     If rules is absent then assume:

       "none" if border is absent or border="0" otherwise "all"
-->
<!ENTITY % rules.attrib
     "rules        ( none
                   | groups
                   | rows
                   | cols
                   | all )                  #IMPLIED"
>

<!-- horizontal alignment attributes for cell contents
-->
<!ENTITY % CellHAlign.attrib
     "align        ( left
                   | center
                   | right
                   | justify
                   | char )                 #IMPLIED
      char         %Character.datatype;     #IMPLIED
      charoff      %Length.datatype;        #IMPLIED"
>

<!-- vertical alignment attribute for cell contents
-->
<!ENTITY % CellVAlign.attrib
     "valign       ( top
                   | middle
                   | bottom
                   | baseline )             #IMPLIED"
>

<!-- scope is simpler than axes attribute for common tables
-->
<!ENTITY % scope.attrib
     "scope        ( row
                   | col
                   | rowgroup
                   | colgroup )             #IMPLIED"
>

<!-- table: Table Element .............................. -->

<!ENTITY % table.element  "INCLUDE" >
<![%table.element;[
<!ENTITY % table.content
     "( %caption.qname;?, ( %col.qname;* | %colgroup.qname;* ),
      (( %thead.qname;?, %tfoot.qname;?, %tbody.qname;+ ) | ( %tr.qname;+ )))"
>
<!ELEMENT %table.qname;  %table.content; >
<!-- end of table.element -->]]>

<!ENTITY % table.attlist  "INCLUDE" >
<![%table.attlist;[
<!ATTLIST %table.qname;
      %Common.attrib;
      summary      %Text.datatype;          #IMPLIED
      width        %Length.datatype;        #IMPLIED
      border       %Pixels.datatype;        #IMPLIED
      %frame.attrib;
      %rules.attrib;
      cellspacing  %Length.datatype;        #IMPLIED
      cellpadding  %Length.datatype;        #IMPLIED
>
<!-- end of table.attlist -->]]>

<!-- caption: Table Caption ............................ -->

<!ENTITY % caption.element  "INCLUDE" >
<![%caption.element;[
<!ENTITY % caption.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ELEMENT %caption.qname;  %caption.content; >
<!-- end of caption.element -->]]>

<!ENTITY % caption.attlist  "INCLUDE" >
<![%caption.attlist;[
<!ATTLIST %caption.qname;
      %Common.attrib;
>
<!-- end of caption.attlist -->]]>

<!-- thead: Table Header ............................... -->

<!-- Use thead to duplicate headers when breaking table
     across page boundaries, or for static headers when
     tbody sections are rendered in scrolling panel.
-->

<!ENTITY % thead.element  "INCLUDE" >
<![%thead.element;[
<!ENTITY % thead.content  "( %tr.qname; )+" >
<!ELEMENT %thead.qname;  %thead.content; >
<!-- end of thead.element -->]]>

<!ENTITY % thead.attlist  "INCLUDE" >
<![%thead.attlist;[
<!ATTLIST %thead.qname;
      %Common.attrib;
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of thead.attlist -->]]>

<!-- tfoot: Table Footer ............................... -->

<!-- Use tfoot to duplicate footers when breaking table
     across page boundaries, or for static footers when
     tbody sections are rendered in scrolling panel.
-->

<!ENTITY % tfoot.element  "INCLUDE" >
<![%tfoot.element;[
<!ENTITY % tfoot.content  "( %tr.qname; )+" >
<!ELEMENT %tfoot.qname;  %tfoot.content; >
<!-- end of tfoot.element -->]]>

<!ENTITY % tfoot.attlist  "INCLUDE" >
<![%tfoot.attlist;[
<!ATTLIST %tfoot.qname;
      %Common.attrib;
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of tfoot.attlist -->]]>

<!-- tbody: Table Body ................................. -->

<!-- Use multiple tbody sections when rules are needed
     between groups of table rows.
-->

<!ENTITY % tbody.element  "INCLUDE" >
<![%tbody.element;[
<!ENTITY % tbody.content  "( %tr.qname; )+" >
<!ELEMENT %tbody.qname;  %tbody.content; >
<!-- end of tbody.element -->]]>

<!ENTITY % tbody.attlist  "INCLUDE" >
<![%tbody.attlist;[
<!ATTLIST %tbody.qname;
      %Common.attrib;
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of tbody.attlist -->]]>

<!-- colgroup: Table Column Group ...................... -->

<!-- colgroup groups a set of col elements. It allows you
     to group several semantically-related columns together.
-->

<!ENTITY % colgroup.element  "INCLUDE" >
<![%colgroup.element;[
<!ENTITY % colgroup.content  "( %col.qname; )*" >
<!ELEMENT %colgroup.qname;  %colgroup.content; >
<!-- end of colgroup.element -->]]>

<!ENTITY % colgroup.attlist  "INCLUDE" >
<![%colgroup.attlist;[
<!ATTLIST %colgroup.qname;
      %Common.attrib;
      span         %Number.datatype;        '1'
      width        %MultiLength.datatype;   #IMPLIED
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of colgroup.attlist -->]]>

<!-- col: Table Column ................................. -->

<!-- col elements define the alignment properties for
     cells in one or more columns.

     The width attribute specifies the width of the
     columns, e.g.

       width="64"        width in screen pixels
       width="0.5*"      relative width of 0.5

     The span attribute causes the attributes of one
     col element to apply to more than one column.
-->

<!ENTITY % col.element  "INCLUDE" >
<![%col.element;[
<!ENTITY % col.content  "EMPTY" >
<!ELEMENT %col.qname;  %col.content; >
<!-- end of col.element -->]]>

<!ENTITY % col.attlist  "INCLUDE" >
<![%col.attlist;[
<!ATTLIST %col.qname;
      %Common.attrib;
      span         %Number.datatype;        '1'
      width        %MultiLength.datatype;   #IMPLIED
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of col.attlist -->]]>

<!-- tr: Table Row ..................................... -->

<!ENTITY % tr.element  "INCLUDE" >
<![%tr.element;[
<!ENTITY % tr.content  "( %th.qname; | %td.qname; )+" >
<!ELEMENT %tr.qname;  %tr.content; >
<!-- end of tr.element -->]]>

<!ENTITY % tr.attlist  "INCLUDE" >
<![%tr.attlist;[
<!ATTLIST %tr.qname;
      %Common.attrib;
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of tr.attlist -->]]>

<!-- th: Table Header Cell ............................. -->

<!-- th is for header cells, td for data,
     but for cells acting as both use td
-->

<!ENTITY % th.element  "INCLUDE" >
<![%th.element;[
<!ENTITY % th.content
     "( #PCDATA | %Flow.mix; )*"
>
<!ELEMENT %th.qname;  %th.content; >
<!-- end of th.element -->]]>

<!ENTITY % th.attlist  "INCLUDE" >
<![%th.attlist;[
<!ATTLIST %th.qname;
      %Common.attrib;
      abbr         %Text.datatype;          #IMPLIED
      axis         CDATA                    #IMPLIED
      headers      IDREFS                   #IMPLIED
      %scope.attrib;
      rowspan      %Number.datatype;        '1'
      colspan      %Number.datatype;        '1'
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of th.attlist -->]]>

<!-- td: Table Data Cell ............................... -->

<!ENTITY % td.element  "INCLUDE" >
<![%td.element;[
<!ENTITY % td.content
     "( #PCDATA | %Flow.mix; )*"
>
<!ELEMENT %td.qname;  %td.content; >
<!-- end of td.element -->]]>

<!ENTITY % td.attlist  "INCLUDE" >
<![%td.attlist;[
<!ATTLIST %td.qname;
      %Common.attrib;
      abbr         %Text.datatype;          #IMPLIED
      axis         CDATA                    #IMPLIED
      headers      IDREFS                   #IMPLIED
      %scope.attrib;
      rowspan      %Number.datatype;        '1'
      colspan      %Number.datatype;        '1'
      %CellHAlign.attrib;
      %CellVAlign.attrib;
>
<!-- end of td.attlist -->]]>

<!-- end of xhtml-table-1.mod -->
]]>

<!-- Forms Module  ............................................... -->
<!ENTITY % xhtml-form.module "INCLUDE" >
<![%xhtml-form.module;[
<!ENTITY % xhtml-form.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Forms 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-form-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Forms Module  .................................................. -->
<!-- file: xhtml-form-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-form-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Forms 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-form-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Forms

        form, label, input, select, optgroup, option,
        textarea, fieldset, legend, button

     This module declares markup to provide support for online
     forms, based on the features found in HTML 4.0 forms.
-->

<!-- declare qualified element type names:
-->
<!ENTITY % form.qname  "form" >
<!ENTITY % label.qname  "label" >
<!ENTITY % input.qname  "input" >
<!ENTITY % select.qname  "select" >
<!ENTITY % optgroup.qname  "optgroup" >
<!ENTITY % option.qname  "option" >
<!ENTITY % textarea.qname  "textarea" >
<!ENTITY % fieldset.qname  "fieldset" >
<!ENTITY % legend.qname  "legend" >
<!ENTITY % button.qname  "button" >

<!-- %BlkNoForm.mix; includes all non-form block elements,
     plus %Misc.class;
-->
<!ENTITY % BlkNoForm.mix
     "%Heading.class;
      | %List.class;
      | %BlkStruct.class;
      %BlkPhras.class;
      %BlkPres.class;
      %Table.class;
      %Block.extra;
      %Misc.class;"
>

<!-- form: Form Element ................................ -->

<!ENTITY % form.element  "INCLUDE" >
<![%form.element;[
<!ENTITY % form.content
     "( %BlkNoForm.mix;
      | %fieldset.qname; )+"
>
<!ELEMENT %form.qname;  %form.content; >
<!-- end of form.element -->]]>

<!ENTITY % form.attlist  "INCLUDE" >
<![%form.attlist;[
<!ATTLIST %form.qname;
      %Common.attrib;
      action       %URI.datatype;           #REQUIRED
      method       ( get | post )           'get'
      enctype      %ContentType.datatype;   'application/x-www-form-urlencoded'
      accept-charset %Charsets.datatype;    #IMPLIED
      accept       %ContentTypes.datatype;  #IMPLIED
>
<!-- end of form.attlist -->]]>

<!-- label: Form Field Label Text ...................... -->

<!-- Each label must not contain more than ONE field
-->

<!ENTITY % label.element  "INCLUDE" >
<![%label.element;[
<!ENTITY % label.content
     "( #PCDATA
      | %input.qname; | %select.qname; | %textarea.qname; | %button.qname;
      | %InlStruct.class;
      %InlPhras.class;
      %I18n.class;
      %InlPres.class;
      %Anchor.class;
      %InlSpecial.class;
      %Inline.extra;
      %Misc.class; )*"
>
<!ELEMENT %label.qname;  %label.content; >
<!-- end of label.element -->]]>

<!ENTITY % label.attlist  "INCLUDE" >
<![%label.attlist;[
<!ATTLIST %label.qname;
      %Common.attrib;
      for          IDREF                    #IMPLIED
      accesskey    %Character.datatype;     #IMPLIED
>
<!-- end of label.attlist -->]]>

<!-- input: Form Control ............................... -->

<!ENTITY % input.element  "INCLUDE" >
<![%input.element;[
<!ENTITY % input.content  "EMPTY" >
<!ELEMENT %input.qname;  %input.content; >
<!-- end of input.element -->]]>

<!ENTITY % input.attlist  "INCLUDE" >
<![%input.attlist;[
<!ENTITY % InputType.class
     "( text | password | checkbox | radio | submit
      | reset | file | hidden | image | button )"
>
<!-- attribute 'name' required for all but submit & reset
-->
<!ATTLIST %input.qname;
      %Common.attrib;
      type         %InputType.class;        'text'
      name         CDATA                    #IMPLIED
      value        CDATA                    #IMPLIED
      checked      ( checked )              #IMPLIED
      disabled     ( disabled )             #IMPLIED
      readonly     ( readonly )             #IMPLIED
      size         %Number.datatype;        #IMPLIED
      maxlength    %Number.datatype;        #IMPLIED
      src          %URI.datatype;           #IMPLIED
      alt          %Text.datatype;          #IMPLIED
      tabindex     %Number.datatype;        #IMPLIED
      accesskey    %Character.datatype;     #IMPLIED
      accept       %ContentTypes.datatype;  #IMPLIED
>
<!-- end of input.attlist -->]]>

<!-- select: Option Selector ........................... -->

<!ENTITY % select.element  "INCLUDE" >
<![%select.element;[
<!ENTITY % select.content
     "( %optgroup.qname; | %option.qname; )+"
>
<!ELEMENT %select.qname;  %select.content; >
<!-- end of select.element -->]]>

<!ENTITY % select.attlist  "INCLUDE" >
<![%select.attlist;[
<!ATTLIST %select.qname;
      %Common.attrib;
      name         CDATA                    #IMPLIED
      size         %Number.datatype;        #IMPLIED
      multiple     ( multiple )             #IMPLIED
      disabled     ( disabled )             #IMPLIED
      tabindex     %Number.datatype;        #IMPLIED
>
<!-- end of select.attlist -->]]>

<!-- optgroup: Option Group ............................ -->

<!ENTITY % optgroup.element  "INCLUDE" >
<![%optgroup.element;[
<!ENTITY % optgroup.content  "( %option.qname; )+" >
<!ELEMENT %optgroup.qname;  %optgroup.content; >
<!-- end of optgroup.element -->]]>

<!ENTITY % optgroup.attlist  "INCLUDE" >
<![%optgroup.attlist;[
<!ATTLIST %optgroup.qname;
      %Common.attrib;
      disabled     ( disabled )             #IMPLIED
      label        %Text.datatype;          #REQUIRED
>
<!-- end of optgroup.attlist -->]]>

<!-- option: Selectable Choice ......................... -->

<!ENTITY % option.element  "INCLUDE" >
<![%option.element;[
<!ENTITY % option.content  "( #PCDATA )" >
<!ELEMENT %option.qname;  %option.content; >
<!-- end of option.element -->]]>

<!ENTITY % option.attlist  "INCLUDE" >
<![%option.attlist;[
<!ATTLIST %option.qname;
      %Common.attrib;
      selected     ( selected )             #IMPLIED
      disabled     ( disabled )             #IMPLIED
      label        %Text.datatype;          #IMPLIED
      value        CDATA                    #IMPLIED
>
<!-- end of option.attlist -->]]>

<!-- textarea: Multi-Line Text Field ................... -->

<!ENTITY % textarea.element  "INCLUDE" >
<![%textarea.element;[
<!ENTITY % textarea.content  "( #PCDATA )" >
<!ELEMENT %textarea.qname;  %textarea.content; >
<!-- end of textarea.element -->]]>

<!ENTITY % textarea.attlist  "INCLUDE" >
<![%textarea.attlist;[
<!ATTLIST %textarea.qname;
      %Common.attrib;
      name         CDATA                    #IMPLIED
      rows         %Number.datatype;        #REQUIRED
      cols         %Number.datatype;        #REQUIRED
      disabled     ( disabled )             #IMPLIED
      readonly     ( readonly )             #IMPLIED
      tabindex     %Number.datatype;        #IMPLIED
      accesskey    %Character.datatype;     #IMPLIED
>
<!-- end of textarea.attlist -->]]>

<!-- fieldset: Form Control Group ...................... -->

<!-- #PCDATA is to solve the mixed content problem,
     per specification only whitespace is allowed
-->

<!ENTITY % fieldset.element  "INCLUDE" >
<![%fieldset.element;[
<!ENTITY % fieldset.content
     "( #PCDATA | %legend.qname; | %Flow.mix; )*"
>
<!ELEMENT %fieldset.qname;  %fieldset.content; >
<!-- end of fieldset.element -->]]>

<!ENTITY % fieldset.attlist  "INCLUDE" >
<![%fieldset.attlist;[
<!ATTLIST %fieldset.qname;
      %Common.attrib;
>
<!-- end of fieldset.attlist -->]]>

<!-- legend: Fieldset Legend ........................... -->

<!ENTITY % legend.element  "INCLUDE" >
<![%legend.element;[
<!ENTITY % legend.content
     "( #PCDATA | %Inline.mix; )*"
>
<!ELEMENT %legend.qname;  %legend.content; >
<!-- end of legend.element -->]]>

<!ENTITY % legend.attlist  "INCLUDE" >
<![%legend.attlist;[
<!ATTLIST %legend.qname;
      %Common.attrib;
      accesskey    %Character.datatype;     #IMPLIED
>
<!-- end of legend.attlist -->]]>

<!-- button: Push Button ............................... -->

<!ENTITY % button.element  "INCLUDE" >
<![%button.element;[
<!ENTITY % button.content
     "( #PCDATA
      | %BlkNoForm.mix;
      | %InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %I18n.class;
      %InlSpecial.class;
      %Inline.extra; )*"
>
<!ELEMENT %button.qname;  %button.content; >
<!-- end of button.element -->]]>

<!ENTITY % button.attlist  "INCLUDE" >
<![%button.attlist;[
<!ATTLIST %button.qname;
      %Common.attrib;
      name         CDATA                    #IMPLIED
      value        CDATA                    #IMPLIED
      type         ( button | submit | reset ) 'submit'
      disabled     ( disabled )             #IMPLIED
      tabindex     %Number.datatype;        #IMPLIED
      accesskey    %Character.datatype;     #IMPLIED
>
<!-- end of button.attlist -->]]>

<!-- end of xhtml-form-1.mod -->
]]>

<!-- Legacy Markup ............................................... -->
<!ENTITY % xhtml-legacy.module "IGNORE" >
<![%xhtml-legacy.module;[
<!ENTITY % xhtml-legacy.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Legacy Markup 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-legacy-1.mod" >
%xhtml-legacy.mod;]]>

<!-- Document Structure Module (required)  ....................... -->
<!ENTITY % xhtml-struct.module "INCLUDE" >
<![%xhtml-struct.module;[
<!ENTITY % xhtml-struct.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-struct-1.mod" >
<!-- ...................................................................... -->
<!-- XHTML Structure Module  .............................................. -->
<!-- file: xhtml-struct-1.mod

     This is XHTML, a reformulation of HTML as a modular XML application.
     Copyright 1998-2001 W3C (MIT, INRIA, Keio), All Rights Reserved.
     Revision: $Id: xhtml-struct-1.mod,v 4.0 2001/04/02 22:42:49 altheim Exp $ SMI

     This DTD module is identified by the PUBLIC and SYSTEM identifiers:

       PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
       SYSTEM "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-struct-1.mod"

     Revisions:
     (none)
     ....................................................................... -->

<!-- Document Structure

        title, head, body, html

     The Structure Module defines the major structural elements and
     their attributes.

     Note that the content model of the head element type is redeclared
     when the Base Module is included in the DTD.

     The parameter entity containing the XML namespace URI value used
     for XHTML is '%XHTML.xmlns;', defined in the Qualified Names module.
-->

<!-- title: Document Title ............................. -->

<!-- The title element is not considered part of the flow of text.
     It should be displayed, for example as the page header or
     window title. Exactly one title is required per document.
-->

<!ENTITY % title.element  "INCLUDE" >
<![%title.element;[
<!ENTITY % title.content  "( #PCDATA )" >
<!ENTITY % title.qname  "title" >
<!ELEMENT %title.qname;  %title.content; >
<!-- end of title.element -->]]>

<!ENTITY % title.attlist  "INCLUDE" >
<![%title.attlist;[
<!ATTLIST %title.qname;
      %XHTML.xmlns.attrib;
      %I18n.attrib;
>
<!-- end of title.attlist -->]]>

<!-- head: Document Head ............................... -->

<!ENTITY % head.element  "INCLUDE" >
<![%head.element;[
<!ENTITY % head.content
    "( %HeadOpts.mix;, %title.qname;, %HeadOpts.mix; )"
>
<!ENTITY % head.qname  "head" >
<!ELEMENT %head.qname;  %head.content; >
<!-- end of head.element -->]]>

<!ENTITY % head.attlist  "INCLUDE" >
<![%head.attlist;[
<!-- reserved for future use with document profiles
-->
<!ENTITY % profile.attrib
     "profile      %URI.datatype;           '%XHTML.profile;'"
>

<!ATTLIST %head.qname;
      %XHTML.xmlns.attrib;
      %I18n.attrib;
      %profile.attrib;
>
<!-- end of head.attlist -->]]>

<!-- body: Document Body ............................... -->

<!ENTITY % body.element  "INCLUDE" >
<![%body.element;[
<!ENTITY % body.content
     "( %Block.mix; )+"
>
<!ENTITY % body.qname  "body" >
<!ELEMENT %body.qname;  %body.content; >
<!-- end of body.element -->]]>

<!ENTITY % body.attlist  "INCLUDE" >
<![%body.attlist;[
<!ATTLIST %body.qname;
      %Common.attrib;
>
<!-- end of body.attlist -->]]>

<!-- html: XHTML Document Element ...................... -->

<!ENTITY % html.element  "INCLUDE" >
<![%html.element;[
<!ENTITY % html.content  "( %head.qname;, %body.qname; )" >
<!ENTITY % html.qname  "html" >
<!ELEMENT %html.qname;  %html.content; >
<!-- end of html.element -->]]>

<!ENTITY % html.attlist  "INCLUDE" >
<![%html.attlist;[
<!-- version attribute value defined in driver
-->
<!ENTITY % XHTML.version.attrib
     "version      %FPI.datatype;           #FIXED '%XHTML.version;'"
>

<!-- see the Qualified Names module for information
     on how to extend XHTML using XML namespaces
-->
<!ATTLIST %html.qname;
      %XHTML.xmlns.attrib;
      %XHTML.version.attrib;
      %I18n.attrib;
>
<!-- end of html.attlist -->]]>

<!-- end of xhtml-struct-1.mod -->
]]>

<!-- end of XHTML 1.1 DTD  ................................................. -->
<!-- ....................................................................... -->


================================================
FILE: test/System.Web.Helpers.Test/WebCacheTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class WebCacheTest
    {
        [Fact]
        public void GetReturnsExpectedValueTest()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_GetTest";
            List<string> expected = new List<string>();
            WebCache.Set(key, expected);

            var actual = WebCache.Get(key);

            Assert.Equal(expected, actual);
            Assert.Equal(0, actual.Count);
        }

        [Fact]
        public void RemoveRemovesRightValueTest()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_RemoveTest";
            List<string> expected = new List<string>();
            WebCache.Set(key, expected);

            var actual = WebCache.Remove(key);

            Assert.Equal(expected, actual);
            Assert.Equal(0, actual.Count);
        }

        [Fact]
        public void RemoveRemovesValueFromCacheTest()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_RemoveTest2";
            List<string> expected = new List<string>();
            WebCache.Set(key, expected);

            var removed = WebCache.Remove(key);

            Assert.Null(WebCache.Get(key));
        }

        [Fact]
        public void SetWithAbsoluteExpirationDoesNotThrow()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "SetWithAbsoluteExpirationDoesNotThrow_SetTest";
            object expected = new object();
            int minutesToCache = 10;
            bool slidingExpiration = false;
            WebCache.Set(key, expected, minutesToCache, slidingExpiration);
            object actual = WebCache.Get(key);
            Assert.True(expected == actual);
        }

        [Fact]
        public void CanSetWithSlidingExpiration()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_CanSetWithSlidingExpiration_SetTest";
            object expected = new object();

            WebCache.Set(key, expected, slidingExpiration: true);
            object actual = WebCache.Get(key);
            Assert.True(expected == actual);
        }

        [Fact]
        public void SetWithSlidingExpirationForNegativeTime()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_SetWithSlidingExpirationForNegativeTime_SetTest";
            object expected = new object();
            Assert.ThrowsArgumentGreaterThan(() => WebCache.Set(key, expected, -1), "minutesToCache", "0");
        }

        [Fact]
        public void SetWithSlidingExpirationForZeroTime()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_SetWithSlidingExpirationForZeroTime_SetTest";
            object expected = new object();
            Assert.ThrowsArgumentGreaterThan(() => WebCache.Set(key, expected, 0), "minutesToCache", "0");
        }

        [Fact]
        public void SetWithSlidingExpirationForYear()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_SetWithSlidingExpirationForYear_SetTest";
            object expected = new object();

            WebCache.Set(key, expected, 365 * 24 * 60, true);
            object actual = WebCache.Get(key);
            Assert.True(expected == actual);
        }

        [Fact]
        public void SetWithSlidingExpirationForMoreThanYear()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_SetWithSlidingExpirationForMoreThanYear_SetTest";
            object expected = new object();
            Assert.ThrowsArgumentLessThanOrEqualTo(() => WebCache.Set(key, expected, (365 * 24 * 60) + 1, true), "minutesToCache", (365 * 24 * 60).ToString());
        }

        [Fact]
        public void SetWithAbsoluteExpirationForMoreThanYear()
        {
            string key = DateTime.UtcNow.Ticks.ToString() + "_SetWithAbsoluteExpirationForMoreThanYear_SetTest";
            object expected = new object();

            WebCache.Set(key, expected, 365 * 24 * 60, true);
            object actual = WebCache.Get(key);
            Assert.True(expected == actual);
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/WebGridDataSourceTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Test
{
    public class WebGridDataSourceTest
    {
        [Fact]
        public void WebGridDataSourceReturnsNumberOfItemsAsTotalRowCount()
        {
            // Arrange
            var rows = GetValues();
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: GetValues(), elementType: typeof(Person), canPage: false, canSort: false);

            // Act and Assert
            Assert.Equal(rows.Count(), dataSource.TotalRowCount);
        }

        [Fact]
        public void WebGridDataSourceReturnsUnsortedListIfSortColumnIsNull()
        {
            // Arrange
            var values = GetValues();
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: GetValues(), elementType: typeof(Person), canPage: false, canSort: true);

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = null }, 0);

            // Assert
            Assert.True(Enumerable.SequenceEqual<object>(values.ToList(), rows.Select(r => r.Value).ToList(), new PersonComparer()));
        }

        [Fact]
        public void WebGridDataSourceReturnsUnsortedListIfSortColumnIsEmpty()
        {
            // Arrange
            var values = GetValues();
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: GetValues(), elementType: typeof(Person), canPage: false, canSort: true);

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = String.Empty }, 0);

            // Assert
            Assert.True(Enumerable.SequenceEqual<object>(values.ToList(), rows.Select(r => r.Value).ToList(), new PersonComparer()));
        }

        [Fact]
        public void WebGridDataSourceReturnsUnsortedListIfSortCannotBeInferred()
        {
            // Arrange
            var values = GetValues();
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: GetValues(), elementType: typeof(Person), canPage: false, canSort: true);

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "Does-not-exist" }, 0);

            // Assert
            Assert.True(Enumerable.SequenceEqual<object>(values.ToList(), rows.Select(r => r.Value).ToList(), new PersonComparer()));
        }

        [Fact]
        public void WebGridDataSourceReturnsUnsortedListIfDefaultSortCannotBeInferred()
        {
            // Arrange
            var values = GetValues();
            var defaultSort = new SortInfo { SortColumn = "cannot-be-inferred" };
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: GetValues(), elementType: typeof(Person), canSort: true, canPage: false) { DefaultSort = defaultSort };

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "Does-not-exist" }, 0);

            // Assert
            Assert.True(Enumerable.SequenceEqual<object>(values.ToList(), rows.Select(r => r.Value).ToList(), new PersonComparer()));
        }

        [Fact]
        public void WebGridDataSourceUsesDefaultSortWhenCurrentSortCannotBeInferred()
        {
            // Arrange
            var values = GetValues();
            var defaultSort = new SortInfo { SortColumn = "FirstName" };
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: GetValues(), elementType: typeof(Person), canSort: true, canPage: false) { DefaultSort = defaultSort };

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "Does-not-exist" }, 0);

            // Assert
            Assert.True(Enumerable.SequenceEqual<object>(values.OrderBy(p => p.FirstName).ToList(), rows.Select(r => r.Value).ToList(), new PersonComparer()));
        }

        [Fact]
        public void WebGridDataSourceSortsUsingSpecifiedSort()
        {
            // Arrange
            var defaultSort = new SortInfo { SortColumn = "FirstName", SortDirection = SortDirection.Ascending };
            IEnumerable<dynamic> values = new[] { new Person { LastName = "Z" }, new Person { LastName = "X" }, new Person { LastName = "Y" } };
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(Person), canSort: true, canPage: false) { DefaultSort = defaultSort };

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "LastName" }, 0);

            // Assert
            Assert.Equal(rows.ElementAt(0).Value.LastName, "X");
            Assert.Equal(rows.ElementAt(1).Value.LastName, "Y");
            Assert.Equal(rows.ElementAt(2).Value.LastName, "Z");
        }

        [Fact]
        public void WebGridDataSourceSortsDynamicType()
        {
            // Arrange
            IEnumerable<dynamic> values = new[] { new TestDynamicType("col", "val1"), new TestDynamicType("col", "val2"), new TestDynamicType("col", "val3") };
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(TestDynamicType), canSort: true, canPage: false);

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "col", SortDirection = SortDirection.Descending }, 0);

            // Assert
            Assert.Equal(rows.ElementAt(0).Value.col, "val3");
            Assert.Equal(rows.ElementAt(1).Value.col, "val2");
            Assert.Equal(rows.ElementAt(2).Value.col, "val1");
        }

        [Fact]
        public void WebGridDataSourceWithNestedPropertySortsCorrectly()
        {
            // Arrange
            var element1 = new { Foo = new { Bar = "val2" } };
            var element2 = new { Foo = new { Bar = "val1" } };
            var element3 = new { Foo = new { Bar = "val3" } };
            IEnumerable<dynamic> values = new[] { element1, element2, element3 };

            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: element1.GetType(), canSort: true, canPage: false);

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "Foo.Bar", SortDirection = SortDirection.Descending }, 0);

            // Assert
            Assert.Equal(rows.ElementAt(0).Value.Foo.Bar, "val3");
            Assert.Equal(rows.ElementAt(1).Value.Foo.Bar, "val2");
            Assert.Equal(rows.ElementAt(2).Value.Foo.Bar, "val1");
        }

        [Fact]
        public void WebGridDataSourceSortsDictionaryBasedDynamicType()
        {
            // Arrange
            var value1 = new DynamicDictionary();
            value1["col"] = "val1";
            var value2 = new DynamicDictionary();
            value2["col"] = "val2";
            var value3 = new DynamicDictionary();
            value3["col"] = "val3";
            IEnumerable<dynamic> values = new[] { value1, value2, value3 };
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(TestDynamicType), canSort: true, canPage: false);

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "col", SortDirection = SortDirection.Descending }, 0);

            // Assert
            Assert.Equal(rows.ElementAt(0).Value.col, "val3");
            Assert.Equal(rows.ElementAt(1).Value.col, "val2");
            Assert.Equal(rows.ElementAt(2).Value.col, "val1");
        }

        [Fact]
        public void WebGridDataSourceReturnsOriginalDataSourceIfValuesCannotBeSorted()
        {
            // Arrange
            IEnumerable<dynamic> values = new object[] { new TestDynamicType("col", "val1"), new TestDynamicType("col", "val2"), new TestDynamicType("col", DBNull.Value) };
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(TestDynamicType), canSort: true, canPage: false);

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "col", SortDirection = SortDirection.Descending }, 0);

            // Assert
            Assert.Equal(rows.ElementAt(0).Value.col, "val1");
            Assert.Equal(rows.ElementAt(1).Value.col, "val2");
            Assert.Equal(rows.ElementAt(2).Value.col, DBNull.Value);
        }

        [Fact]
        public void WebGridDataSourceReturnsPagedResultsIfRowsPerPageIsSpecified()
        {
            // Arrange
            IEnumerable<dynamic> values = GetValues();
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(Person), canSort: false, canPage: true) { RowsPerPage = 2 };

            // Act 
            var rows = dataSource.GetRows(new SortInfo(), 0);

            // Assert
            Assert.Equal(2, rows.Count);
            Assert.Equal(rows.ElementAt(0).Value.LastName, "B2");
            Assert.Equal(rows.ElementAt(1).Value.LastName, "A2");
        }

        [Fact]
        public void WebGridDataSourceReturnsPagedSortedResultsIfRowsPerPageAndSortAreSpecified()
        {
            // Arrange
            IEnumerable<dynamic> values = GetValues();
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(Person), canSort: true, canPage: true) { RowsPerPage = 2 };

            // Act 
            var rows = dataSource.GetRows(new SortInfo { SortColumn = "LastName", SortDirection = SortDirection.Descending }, 0);

            // Assert
            Assert.Equal(2, rows.Count);
            Assert.Equal(rows.ElementAt(0).Value.LastName, "E2");
            Assert.Equal(rows.ElementAt(1).Value.LastName, "D2");
        }

        [Fact]
        public void WebGridDataSourceReturnsFewerThanRowsPerPageIfNumberOfItemsIsInsufficient()
        {
            // Arrange
            IEnumerable<dynamic> values = GetValues();
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(Person), canSort: true, canPage: true) { RowsPerPage = 3 };

            // Act 
            var rows = dataSource.GetRows(new SortInfo(), 1);

            // Assert
            Assert.Equal(2, rows.Count);
            Assert.Equal(rows.ElementAt(0).Value.LastName, "C2");
            Assert.Equal(rows.ElementAt(1).Value.LastName, "E2");
        }

        [Fact]
        public void WebGridDataSourceDoesNotThrowIfValuesAreNull()
        {
            // Arrange
            IEnumerable<dynamic> values = new object[] { String.Empty, null, DBNull.Value, null };
            var dataSource = new WebGridDataSource(new WebGrid(GetContext()), values: values, elementType: typeof(object), canSort: true, canPage: true) { RowsPerPage = 2 };

            // Act 
            var rows = dataSource.GetRows(new SortInfo(), 0);

            // Assert
            Assert.Equal(2, rows.Count);
            Assert.Equal(rows.ElementAt(0).Value, String.Empty);
            Assert.Null(rows.ElementAt(1).Value);
        }

        private IEnumerable<Person> GetValues()
        {
            return new[]
            {
                new Person { FirstName = "B1", LastName = "B2" },
                new Person { FirstName = "A1", LastName = "A2" },
                new Person { FirstName = "D1", LastName = "D2" },
                new Person { FirstName = "C1", LastName = "C2" },
                new Person { FirstName = "E1", LastName = "E2" },
            };
        }

        private class PersonComparer : IEqualityComparer<object>
        {
            public new bool Equals(object x, object y)
            {
                dynamic xDynamic = x;
                dynamic yDynamic = y;
                return (String.Equals(xDynamic.FirstName, yDynamic.FirstName, StringComparison.OrdinalIgnoreCase)
                        && String.Equals(xDynamic.LastName, yDynamic.LastName, StringComparison.OrdinalIgnoreCase));
            }

            public int GetHashCode(dynamic obj)
            {
                return 4; // Random dice roll
            }
        }

        private class TestDynamicType : DynamicObject
        {
            public Dictionary<string, object> _values = new Dictionary<string, object>();

            public TestDynamicType(string a, object b)
            {
                _values[a] = b;
            }

            public override bool TryGetMember(GetMemberBinder binder, out object result)
            {
                return _values.TryGetValue(binder.Name, out result);
            }
        }

        private class Person
        {
            public string FirstName { get; set; }

            public string LastName { get; set; }
        }

        private HttpContextBase GetContext()
        {
            return new Mock<HttpContextBase>().Object;
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/WebGridTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Web.TestUtil;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Test
{
    public class WebGridTest
    {
        [Fact]
        public void AjaxCheckedOnlyOnce()
        {
            var grid = new WebGrid(GetContext(), ajaxUpdateContainerId: "grid")
                .Bind(new[] { new { First = "First", Second = "Second" } });
            string html = grid.Table().ToString();
            Assert.Contains("<script", html);
            html = grid.Table().ToString();
            Assert.DoesNotContain("<script", html);
            html = grid.Pager().ToString();
            Assert.DoesNotContain("<script", html);
        }

        [Fact]
        public void AjaxCallbackIgnoredIfAjaxUpdateContainerIdIsNotSet()
        {
            var grid = new WebGrid(GetContext(), ajaxUpdateCallback: "myCallback")
                .Bind(new[] { new { First = "First", Second = "Second" } });
            string html = grid.Table().ToString();
            Assert.DoesNotContain("<script", html);
            Assert.DoesNotContain("myCallback", html);
        }

        [Fact]
        public void ColumnNameDefaultsExcludesIndexedProperties()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { "First", "Second" });
            Assert.Single(grid.ColumnNames);
            Assert.Contains("Length", grid.ColumnNames);
        }

        [Fact]
        public void ColumnNameDefaultsForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(new { First = "First", Second = "Second" }));
            Assert.Equal(2, grid.ColumnNames.Count());
            Assert.Contains("First", grid.ColumnNames);
            Assert.Contains("Second", grid.ColumnNames);
        }

        [Fact]
        public void ColumnNameDefaultsForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { First = "First", Second = "Second" } });
            Assert.Equal(2, grid.ColumnNames.Count());
            Assert.Contains("First", grid.ColumnNames);
            Assert.Contains("Second", grid.ColumnNames);
        }

        [Fact]
        public void ColumnNameDefaultsSupportsBindableTypes()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new
                {
                    DateTime = DateTime.MinValue,
                    DateTimeOffset = DateTimeOffset.MinValue,
                    Decimal = Decimal.MinValue,
                    Guid = Guid.Empty,
                    Int32 = 1,
                    NullableInt32 = (int?)1,
                    Object = new object(),
                    Projection = new { Foo = "Bar" },
                    TimeSpan = TimeSpan.MinValue
                }
            });
            Assert.Equal(7, grid.ColumnNames.Count());
            Assert.Contains("DateTime", grid.ColumnNames);
            Assert.Contains("DateTimeOffset", grid.ColumnNames);
            Assert.Contains("Decimal", grid.ColumnNames);
            Assert.Contains("Guid", grid.ColumnNames);
            Assert.Contains("Int32", grid.ColumnNames);
            Assert.Contains("NullableInt32", grid.ColumnNames);
            Assert.Contains("TimeSpan", grid.ColumnNames);
            Assert.DoesNotContain("Object", grid.ColumnNames);
            Assert.DoesNotContain("Projection", grid.ColumnNames);
        }

        [Fact]
        public void ColumnsIsNoOp()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { First = "First", Second = "Second" }
            });
            var columns = new[]
            {
                grid.Column("First"), grid.Column("Second")
            };
            Assert.Equal(columns, grid.Columns(columns));
        }

        [Fact]
        public void ColumnThrowsIfColumnNameIsEmptyAndNoFormat()
        {
            var grid = new WebGrid(GetContext()).Bind(new object[0]);
            Assert.ThrowsArgument(() => { grid.Column(columnName: String.Empty, format: null); }, "columnName", "The column name cannot be null or an empty string unless a custom format is specified.");
        }

        [Fact]
        public void ColumnThrowsIfColumnNameIsNullAndNoFormat()
        {
            var grid = new WebGrid(GetContext()).Bind(new object[0]);
            Assert.ThrowsArgument(() => { grid.Column(columnName: null, format: null); }, "columnName", "The column name cannot be null or an empty string unless a custom format is specified.");
        }

        [Fact]
        public void BindThrowsIfSourceIsNull()
        {
            Assert.ThrowsArgumentNull(() => { new WebGrid(GetContext()).Bind(null); }, "source");
        }

        [Fact]
        public void ConstructorThrowsIfRowsPerPageIsLessThanOne()
        {
            Assert.ThrowsArgumentOutOfRange(() => { new WebGrid(GetContext(), rowsPerPage: 0); }, "rowsPerPage", "Value must be greater than or equal to 1.", allowDerivedExceptions: true);
        }

        [Fact]
        public void GetHtmlDefaults()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var html = grid.GetHtml();
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tfoot><tr>" +
                "<td colspan=\"3\">1 <a href=\"?page=2\">2</a> <a href=\"?page=2\">&gt;</a> </td>" +
                "</tr></tfoot>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void WebGridProducesValidHtmlWhenSummaryIsSpecified()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var caption = "WebGrid With Caption";
            var html = grid.GetHtml(caption: caption);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table>" +
                "<caption>" + caption + "</caption>" +
                "<thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tfoot><tr>" +
                "<td colspan=\"3\">1 <a href=\"?page=2\">2</a> <a href=\"?page=2\">&gt;</a> </td>" +
                "</tr></tfoot>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void WebGridEncodesCaptionText()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var caption = "WebGrid <> With Caption";
            var html = grid.GetHtml(caption: caption);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table>" +
                "<caption>WebGrid &lt;&gt; With Caption</caption>" +
                "<thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tfoot><tr>" +
                "<td colspan=\"3\">1 <a href=\"?page=2\">2</a> <a href=\"?page=2\">&gt;</a> </td>" +
                "</tr></tfoot>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void GetHtmlWhenPageCountIsOne()
        {
            var grid = new WebGrid(GetContext())
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" }
                });
            var html = grid.GetHtml();
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P2&amp;sortdir=ASC\">P2</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tbody><tr><td>1</td><td>2</td><td>3</td></tr></tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void GetHtmlWhenPagingAndSortingAreDisabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, canPage: false, canSort: false)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            var html = grid.GetHtml();
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\">P1</th>" +
                "<th scope=\"col\">P2</th>" +
                "<th scope=\"col\">P3</th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>1</td><td>2</td><td>3</td></tr>" +
                "<tr><td>4</td><td>5</td><td>6</td></tr>" +
                "</tbody>" +
                "</table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void PageIndexCanBeReset()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            grid.PageIndex = 0;
            Assert.Equal(0, grid.PageIndex);
            // verify that selection link has updated page
            Assert.Equal("?page=1&row=1", grid.Rows.FirstOrDefault().GetSelectUrl());
        }

        [Fact]
        public void PageIndexCanBeResetToSameValue()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            grid.PageIndex = 0;
            Assert.Equal(0, grid.PageIndex);
        }

        [Fact]
        public void PageIndexDefaultsToZero()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(1, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenValueIsNegative()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.ThrowsArgumentOutOfRange(() => { grid.PageIndex = -1; }, "value", "Value must be between 0 and 1.");
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenValueIsEqualToPageCount()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.ThrowsArgumentOutOfRange(() => { grid.PageIndex = grid.PageCount; }, "value", "Value must be between 0 and 1.");
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenValueIsGreaterToPageCount()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.ThrowsArgumentOutOfRange(() => { grid.PageIndex = grid.PageCount + 1; }, "value", "Value must be between 0 and 1.");
        }

        [Fact]
        public void SetPageIndexThrowsExceptionWhenPagingIsDisabled()
        {
            var grid = new WebGrid(GetContext(), canPage: false)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Throws<NotSupportedException>(() => { grid.PageIndex = 1; }, "This operation is not supported when paging is disabled for the \"WebGrid\" object.");
        }

        [Fact]
        public void PageIndexResetsToLastPageWhenQueryStringValueGreaterThanPageCount()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(4, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexResetWhenQueryStringValueIsInvalid()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "NotAnInt";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(1, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexResetWhenQueryStringValueLessThanOne()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(1, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexUsesCustomQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["g_pg"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1, fieldNamePrefix: "g_", pageFieldName: "pg")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(4, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void PageIndexUsesQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(1, grid.Rows.Count);
            Assert.Equal(4, grid.Rows.First()["P1"]);
        }

        [Fact]
        public void GetPageCountWhenPagingIsTurnedOn()
        {
            var grid = new WebGrid(GetContext(), canPage: true, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(2, grid.PageCount);
        }

        [Fact]
        public void GetPageIndexWhenPagingIsTurnedOn()
        {
            var grid = new WebGrid(GetContext(), canPage: true, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                });
            grid.PageIndex = 1;
            Assert.Equal(1, grid.PageIndex);
            Assert.Equal(3, grid.PageCount);
            grid.PageIndex = 2;
            Assert.Equal(2, grid.PageIndex);
        }

        [Fact]
        public void GetPageCountWhenPagingIsTurnedOff()
        {
            var grid = new WebGrid(GetContext(), canPage: false, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            Assert.Equal(1, grid.PageCount);
        }

        [Fact]
        public void GetPageIndexWhenPagingIsTurnedOff()
        {
            var grid = new WebGrid(GetContext(), canPage: false, rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                    new { P1 = 4, P2 = '5', P3 = "6" },
                });
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(1, grid.PageCount);
        }

        [Fact]
        public void PageUrlResetsSelection()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            queryString["row"] = "0";
            queryString["sort"] = "P1";
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string url = grid.GetPageUrl(1);
            Assert.Equal("?page=2&sort=P1&sortdir=DESC", url);
        }

        [Fact]
        public void PageUrlResetsSelectionForAjax()
        {
            string expected40 = "$(&quot;#grid-container&quot;).swhgLoad(&quot;?page=2&amp;sort=P1&amp;sortdir=DESC&quot;,&quot;#grid-container&quot;);";
            string expected45 = "$(&quot;#grid-container&quot;).swhgLoad(&quot;?page=2\\u0026sort=P1\\u0026sortdir=DESC&quot;,&quot;#grid-container&quot;);";
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            queryString["row"] = "0";
            queryString["sort"] = "P1";
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1, ajaxUpdateContainerId: "grid-container")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.GetContainerUpdateScript(grid.GetPageUrl(1)).ToString();

            // Assert
            Assert.Equal(RuntimeEnvironment.IsVersion45Installed ? expected45 : expected40, html);
        }

        [Fact]
        public void PageUrlResetsSelectionForAjaxWithCallback()
        {
            string expected40 = "$(&quot;#grid&quot;).swhgLoad(&quot;?page=2&amp;sort=P1&amp;sortdir=DESC&quot;,&quot;#grid&quot;,myCallback);";
            string expected45 = "$(&quot;#grid&quot;).swhgLoad(&quot;?page=2\\u0026sort=P1\\u0026sortdir=DESC&quot;,&quot;#grid&quot;,myCallback);";
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "0";
            queryString["row"] = "0";
            queryString["sort"] = "P1";
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1, ajaxUpdateContainerId: "grid", ajaxUpdateCallback: "myCallback")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.GetContainerUpdateScript(grid.GetPageUrl(1)).ToString();

            // Assert
            Assert.Equal(RuntimeEnvironment.IsVersion45Installed ? expected45 : expected40, html);
        }

        [Fact]
        public void PageUrlThrowsIfIndexGreaterThanOrEqualToPageCount()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgumentOutOfRange(() => { grid.GetPageUrl(2); }, "pageIndex", "Value must be between 0 and 1.");
        }

        [Fact]
        public void PageUrlThrowsIfIndexLessThanZero()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgumentOutOfRange(() => { grid.GetPageUrl(-1); }, "pageIndex", "Value must be between 0 and 1.");
        }

        [Fact]
        public void PageUrlThrowsIfPagingIsDisabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, canPage: false).Bind(new[] { new { }, new { } });
            Assert.Throws<NotSupportedException>(() => { grid.GetPageUrl(2); }, "This operation is not supported when paging is disabled for the \"WebGrid\" object.");
        }

        [Fact]
        public void PagerRenderingDefaults()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { }, new { }, new { } });
            var html = grid.Pager();
            Assert.Equal(
                "1 " +
                "<a href=\"?page=2\">2</a> " +
                "<a href=\"?page=3\">3</a> " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=2\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnFirstShowingAll()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { }, new { }, new { } });
            var html = grid.Pager(WebGridPagerModes.All, numericLinksCount: 5);
            Assert.Equal(
                "1 " +
                "<a href=\"?page=2\">2</a> " +
                "<a href=\"?page=3\">3</a> " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=2\">&gt;</a> " +
                "<a href=\"?page=4\">&gt;&gt;</a>",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnNextToLastShowingAll()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.All, numericLinksCount: 4);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;&lt;</a> " +
                "<a href=\"?page=2\">&lt;</a> " +
                "<a href=\"?page=1\">1</a> " +
                "<a href=\"?page=2\">2</a> " +
                "3 " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=4\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnMiddleShowingAll()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.All, numericLinksCount: 3);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;&lt;</a> " +
                "<a href=\"?page=2\">&lt;</a> " +
                "<a href=\"?page=2\">2</a> " +
                "3 " +
                "<a href=\"?page=4\">4</a> " +
                "<a href=\"?page=4\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnSecondHidingFirstLast()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.NextPrevious | WebGridPagerModes.Numeric, numericLinksCount: 2);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;</a> " +
                "2 " +
                "<a href=\"?page=3\">3</a> " +
                "<a href=\"?page=3\">&gt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnLastHidingFirstLast()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "4";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.NextPrevious | WebGridPagerModes.Numeric, numericLinksCount: 1);
            Assert.Equal(
                "<a href=\"?page=3\">&lt;</a> " +
                "4 ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnMiddleHidingNextPrevious()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.FirstLast | WebGridPagerModes.Numeric, numericLinksCount: 0);
            Assert.Equal(
                "<a href=\"?page=1\">&lt;&lt;</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingOnMiddleWithLinksCountGreaterThanPageCount()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.Numeric, numericLinksCount: 6);
            Assert.Equal(
                "<a href=\"?page=1\">1</a> " +
                "<a href=\"?page=2\">2</a> " +
                "3 " +
                "<a href=\"?page=4\">4</a> ",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerRenderingHidingAll()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 2).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.Numeric, numericLinksCount: 0);
            Assert.Equal("", html.ToString());
        }

        [Fact]
        public void PagerRenderingTextOverrides()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1).Bind(new[]
            {
                new { }, new { }, new { }, new { }, new { }
            });
            var html = grid.Pager(WebGridPagerModes.FirstLast | WebGridPagerModes.NextPrevious,
                                  firstText: "first", previousText: "previous", nextText: "next", lastText: "last");
            Assert.Equal(
                "<a href=\"?page=1\">first</a> " +
                "<a href=\"?page=2\">previous</a> " +
                "<a href=\"?page=4\">next</a> " +
                "<a href=\"?page=5\">last</a>",
                html.ToString());
            XhtmlAssert.Validate1_1(html, wrapper: "div");
        }

        [Fact]
        public void PagerThrowsIfTextSetAndModeNotEnabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgument(() => { grid.Pager(firstText: "first"); }, "firstText", "To use this argument, pager mode \"FirstLast\" must be enabled.");
            Assert.ThrowsArgument(() => { grid.Pager(mode: WebGridPagerModes.Numeric, previousText: "previous"); }, "previousText", "To use this argument, pager mode \"NextPrevious\" must be enabled.");
            Assert.ThrowsArgument(() => { grid.Pager(mode: WebGridPagerModes.Numeric, nextText: "next"); }, "nextText", "To use this argument, pager mode \"NextPrevious\" must be enabled.");
            Assert.ThrowsArgument(() => { grid.Pager(lastText: "last"); }, "lastText", "To use this argument, pager mode \"FirstLast\" must be enabled.");
        }

        [Fact]
        public void PagerThrowsIfNumericLinkCountIsLessThanZero()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1).Bind(new[] { new { }, new { } });
            Assert.ThrowsArgumentOutOfRange(() => { grid.Pager(numericLinksCount: -1); }, "numericLinksCount", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void PagerThrowsIfPagingIsDisabled()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, canPage: false).Bind(new[] { new { }, new { } });
            Assert.Throws<NotSupportedException>(() => { grid.Pager(); }, "This operation is not supported when paging is disabled for the \"WebGrid\" object.");
        }

        [Fact]
        public void PagerWithAjax()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, ajaxUpdateContainerId: "grid")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.Pager().ToString();
            Assert.Contains("<script", html);
        }

        [Fact]
        public void PagerWithAjaxAndCallback()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 1, ajaxUpdateContainerId: "grid", ajaxUpdateCallback: "myCallback")
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            string html = grid.Pager().ToString();
            Assert.Contains("<script", html);
            Assert.Contains("data-swhgcallback=\"myCallback\"", html);
        }

        [Fact]
        public void PropertySettersDoNotThrowBeforePagingAndSorting()
        {
            // test with selection because SelectedIndex getter used to do range checking that caused paging and sorting
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "1";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 2).Bind(new[]
            {
                new { P1 = 1 }, new { P1 = 2 }, new { P1 = 3 }
            });

            // invoke other WebGrid properties to ensure they don't cause sorting and paging
            foreach (var prop in typeof(WebGrid).GetProperties())
            {
                // exceptions: these do cause sorting and paging
                if (prop.Name.Equals("Rows") || prop.Name.Equals("SelectedRow") || prop.Name.Equals("ElementType"))
                {
                    continue;
                }
                prop.GetValue(grid, null);
            }

            grid.PageIndex = 1;
            grid.SelectedIndex = 0;
            grid.SortColumn = "P1";
            grid.SortDirection = SortDirection.Descending;
        }

        [Fact]
        public void PropertySettersDoNotThrowAfterPagingAndSortingIfValuesHaveNotChanged()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 2).Bind(new[]
            {
                new { P1 = 1 }, new { P1 = 2 }, new { P1 = 3 }
            });
            // calling Rows will sort and page the data
            Assert.Equal(2, grid.Rows.Count());

            grid.PageIndex = 0;
            grid.SelectedIndex = -1;
            grid.SortColumn = String.Empty;
            grid.SortDirection = SortDirection.Ascending;
        }

        [Fact]
        public void PropertySettersThrowAfterPagingAndSorting()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 2).Bind(new[]
            {
                new { P1 = 1 }, new { P1 = 2 }, new { P1 = 3 }
            });
            // calling Rows will sort and page the data
            Assert.Equal(2, grid.Rows.Count());

            var message = "This property cannot be set after the \"WebGrid\" object has been sorted or paged. Make sure that this property is set prior to invoking the \"Rows\" property directly or indirectly through other methods such as \"GetHtml\", \"Pager\", \"Table\", etc.";
            Assert.Throws<InvalidOperationException>(() => { grid.PageIndex = 1; }, message);
            Assert.Throws<InvalidOperationException>(() => { grid.SelectedIndex = 0; }, message);
            Assert.Throws<InvalidOperationException>(() => { grid.SortColumn = "P1"; }, message);
            Assert.Throws<InvalidOperationException>(() => { grid.SortDirection = SortDirection.Descending; }, message);
        }

        [Fact]
        public void RowColumnsAreDynamicMembersForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(
                new { P1 = 1, P2 = '2', P3 = "3" }
                                                          ));
            dynamic row = grid.Rows.First();
            Assert.Equal(1, row.P1);
            Assert.Equal('2', row.P2);
            Assert.Equal("3", row.P3);
        }

        [Fact]
        public void RowColumnsAreDynamicMembersForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            dynamic row = grid.Rows.First();
            Assert.Equal(1, row.P1);
            Assert.Equal('2', row.P2);
            Assert.Equal("3", row.P3);
        }

        [Fact]
        public void RowExposesRowIndex()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { }, new { }, new { }
            });
            dynamic row = grid.Rows.First();
            Assert.Equal(0, row["ROW"]);
            row = grid.Rows.Skip(1).First();
            Assert.Equal(1, row.ROW);
            row = grid.Rows.Skip(2).First();
            Assert.Equal(2, row.ROW);
        }

        [Fact]
        public void RowExposesUnderlyingValue()
        {
            var sb = new StringBuilder("Foo");
            sb.Append("Bar");
            var grid = new WebGrid(GetContext()).Bind(new[] { sb });
            var row = grid.Rows.First();
            Assert.Equal(sb, row.Value);
            Assert.Equal("FooBar", row.ToString());
            Assert.Equal(grid, row.WebGrid);
        }

        [Fact]
        public void RowIndexerThrowsWhenColumnNameIsEmpty()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.ThrowsArgumentNullOrEmptyString(() => { var value = row[String.Empty]; }, "name");
        }

        [Fact]
        public void RowIndexerThrowsWhenColumnNameIsNull()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.ThrowsArgumentNullOrEmptyString(() => { var value = row[null]; }, "name");
        }

        [Fact] // todo - should throw ArgumentException?
        public void RowIndexerThrowsWhenColumnNotFound()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.Throws<InvalidOperationException>(() => { var value = row["NotAColumn"]; });
        }

        [Fact]
        public void RowIndexerThrowsWhenGreaterThanColumnCount()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            var row = grid.Rows.First();
            Assert.Throws<ArgumentOutOfRangeException>(() => { var value = row[4]; });
        }

        [Fact]
        public void RowIndexerThrowsWhenLessThanZero()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            Assert.Throws<ArgumentOutOfRangeException>(() => { var value = row[-1]; });
        }

        [Fact]
        public void RowIsEnumerableForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(
                new { P1 = 1, P2 = '2', P3 = "3" }
                                                          ));
            int i = 0;
            foreach (var col in (IEnumerable)grid.Rows.First())
            {
                i++;
            }
            Assert.Equal(3, i);
        }

        [Fact]
        public void RowIsEnumerableForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            int i = 0;
            foreach (var col in grid.Rows.First())
            {
                i++;
            }
            Assert.Equal(3, i);
        }

        [Fact]
        public void RowIsIndexableByColumnForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(
                new { P1 = 1, P2 = '2', P3 = "3" }
                                                          ));
            var row = grid.Rows.First();
            Assert.Equal(1, row["P1"]);
            Assert.Equal('2', row["P2"]);
            Assert.Equal("3", row["P3"]);
        }

        [Fact]
        public void RowIsIndexableByColumnForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            var row = grid.Rows.First();
            Assert.Equal(1, row["P1"]);
            Assert.Equal('2', row["P2"]);
            Assert.Equal("3", row["P3"]);
        }

        [Fact]
        public void RowIsIndexableByIndexForDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(Dynamics(
                new { P1 = 1, P2 = '2', P3 = "3" }
                                                          ));
            var row = grid.Rows.First();
            Assert.Equal(1, row[0]);
            Assert.Equal('2', row[1]);
            Assert.Equal("3", row[2]);
        }

        [Fact]
        public void RowIsIndexableByIndexForNonDynamics()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            var row = grid.Rows.First();
            Assert.Equal(1, row[0]);
            Assert.Equal('2', row[1]);
            Assert.Equal("3", row[2]);
        }

        [Fact]
        public void RowsNotPagedWhenPagingIsDisabled()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "2";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 1, canPage: false)
                .Bind(new[]
                {
                    new { P1 = 1, P2 = '2', P3 = "3" },
                    new { P1 = 4, P2 = '5', P3 = "6" }
                });
            // review: should we reset PageIndex or Sort when operation disabled?
            Assert.Equal(0, grid.PageIndex);
            Assert.Equal(2, grid.Rows.Count);
            Assert.Equal(1, grid.Rows.First()["P1"]);
            Assert.Equal(4, grid.Rows.Skip(1).First()["P1"]);
        }

        [Fact] // todo - should throw ArgumentException?
        public void RowTryGetMemberReturnsFalseWhenColumnNotFound()
        {
            var grid = new WebGrid(GetContext()).Bind(new[] { new { } });
            var row = grid.Rows.First();
            object value = null;
            Assert.False(row.TryGetMember("NotAColumn", out value));
        }

        [Fact]
        public void SelectedIndexCanBeReset()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "2";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.Equal(1, grid.SelectedIndex);
            grid.SelectedIndex = 0;
            Assert.Equal(0, grid.SelectedIndex);
        }

        [Fact]
        public void SelectedIndexCanBeResetToSameValue()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "2";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            grid.SelectedIndex = -1;
            Assert.Equal(-1, grid.SelectedIndex);
        }

        [Fact]
        public void SelectedIndexDefaultsToNegative()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.False(grid.HasSelection);
            Assert.Equal(-1, grid.SelectedIndex);
            Assert.Null(grid.SelectedRow);
        }

        [Fact]
        public void SelectedIndexResetWhenQueryStringValueGreaterThanRowsPerPage()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 2).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.False(grid.HasSelection);
            Assert.Equal(-1, grid.SelectedIndex);
            Assert.Null(grid.SelectedRow);
        }

        [Fact]
        public void SelectedIndexPersistsWhenPagingTurnedOff()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "3";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 2, canPage: false).Bind(new[]
            {
                new { }, new { }, new { }, new { }
            });
            grid.SelectedIndex = 3;
            Assert.Equal(3, grid.SelectedIndex);
        }

        [Fact]
        public void SelectedIndexResetWhenQueryStringValueIsInvalid()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "NotAnInt";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.False(grid.HasSelection);
            Assert.Equal(-1, grid.SelectedIndex);
            Assert.Null(grid.SelectedRow);
        }

        [Fact]
        public void SelectedIndexResetWhenQueryStringValueLessThanOne()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "0";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.False(grid.HasSelection);
            Assert.Equal(-1, grid.SelectedIndex);
            Assert.Null(grid.SelectedRow);
        }

        [Fact]
        public void SelectedIndexUsesCustomQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["g_sel"] = "2";
            var grid = new WebGrid(GetContext(queryString), fieldNamePrefix: "g_", selectionFieldName: "sel").Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.True(grid.HasSelection);
            Assert.Equal(1, grid.SelectedIndex);
            Assert.NotNull(grid.SelectedRow);
            Assert.Equal(4, grid.SelectedRow["P1"]);
        }

        [Fact]
        public void SelectedIndexUsesQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "2";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.True(grid.HasSelection);
            Assert.Equal(1, grid.SelectedIndex);
            Assert.NotNull(grid.SelectedRow);
            Assert.Equal(4, grid.SelectedRow["P1"]);
        }

        [Fact]
        public void SelectLink()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["page"] = "1";
            queryString["row"] = "1";
            queryString["sort"] = "P1";
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            string html = grid.Rows[1].GetSelectLink().ToString();
            Assert.Equal("<a href=\"?page=1&amp;row=2&amp;sort=P1&amp;sortdir=DESC\">Select</a>", html.ToString());
        }

        [Fact]
        public void SortCanBeReset()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "P1";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.Equal("P1", grid.SortColumn);
            grid.SortColumn = "P2";
            Assert.Equal("P2", grid.SortColumn);
            // verify that selection and page links have updated sort
            Assert.Equal("?sort=P2&row=1", grid.Rows.FirstOrDefault().GetSelectUrl());
            Assert.Equal("?sort=P2&page=1", grid.GetPageUrl(0));
        }

        [Fact]
        public void SortCanBeResetToNull()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "P1";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.Equal("P1", grid.SortColumn);
            grid.SortColumn = null;
            Assert.Equal(String.Empty, grid.SortColumn);
            // verify that selection and page links have updated sort
            Assert.Equal("?row=1", grid.Rows.FirstOrDefault().GetSelectUrl());
            Assert.Equal("?page=1", grid.GetPageUrl(0));
        }

        [Fact]
        public void SortCanBeResetToSameValue()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "P1";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            grid.SortColumn = String.Empty;
            Assert.Equal(String.Empty, grid.SortColumn);
        }

        [Fact]
        public void SortColumnDefaultsToEmpty()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            Assert.Equal(String.Empty, grid.SortColumn);
        }

        [Fact]
        public void SortColumnResetWhenQueryStringValueIsInvalid()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "P4";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            Assert.Equal("", grid.SortColumn);
        }

        [Fact]
        public void SortColumnUsesCustomQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["g_st"] = "P2";
            var grid = new WebGrid(GetContext(queryString), fieldNamePrefix: "g_", sortFieldName: "st").Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            Assert.Equal("P2", grid.SortColumn);
        }

        [Fact]
        public void SortColumnUsesQueryString()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "P2";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            Assert.Equal("P2", grid.SortColumn);
        }

        [Fact]
        public void SortDirectionCanBeReset()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sortdir"] = "DESC";
            var grid = new WebGrid(GetContext(queryString)).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });
            Assert.Equal(SortDirection.Descending, grid.SortDirection);
            grid.SortDirection = SortDirection.Ascending;
            Assert.Equal(SortDirection.Ascending, grid.SortDirection);
            // verify that selection and page links have updated sort
            Assert.Equal("?sortdir=ASC&row=1", grid.Rows.FirstOrDefault().GetSelectUrl());
            Assert.Equal("?sortdir=ASC&page=1", grid.GetPageUrl(0));
        }

        [Fact]
        public void SortDirectionDefaultsToAscending()
        {
            var grid = new WebGrid(GetContext()).Bind(new object[0]);
            Assert.Equal(SortDirection.Ascending, grid.SortDirection);
        }

        [Fact]
        public void SortDirectionResetWhenQueryStringValueIsInvalid()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sortdir"] = "NotASortDir";
            var grid = new WebGrid(GetContext(queryString)).Bind(new object[0]);
            Assert.Equal(SortDirection.Ascending, grid.SortDirection);
        }

        [Fact]
        public void SortDirectionUsesQueryStringOfAsc()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sortdir"] = "aSc";
            var grid = new WebGrid(GetContext(queryString)).Bind(new object[0]);
            Assert.Equal(SortDirection.Ascending, grid.SortDirection);
        }

        [Fact]
        public void SortDirectionUsesQueryStringOfAscending()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sortdir"] = "AScendING";
            var grid = new WebGrid(GetContext(queryString)).Bind(new object[0]);
            Assert.Equal(SortDirection.Ascending, grid.SortDirection);
        }

        [Fact]
        public void SortDirectionUsesQueryStringOfDesc()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sortdir"] = "DeSc";
            var grid = new WebGrid(GetContext(queryString)).Bind(new object[0]);
            Assert.Equal(SortDirection.Descending, grid.SortDirection);
        }

        [Fact]
        public void SortDirectionUsesQueryStringOfDescending()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["g_sd"] = "DeScendING";
            var grid = new WebGrid(GetContext(queryString), fieldNamePrefix: "g_", sortDirectionFieldName: "sd").Bind(new object[0]);
            Assert.Equal(SortDirection.Descending, grid.SortDirection);
        }

        [Fact]
        public void SortDisabledIfSortIsEmpty()
        {
            var grid = new WebGrid(GetContext(), defaultSort: String.Empty).Bind(Dynamics(
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
                                                                                     ));
            Assert.Equal("Joe", grid.Rows[0]["FirstName"]);
            Assert.Equal("Bob", grid.Rows[1]["FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["FirstName"]);
        }

        [Fact]
        public void SortDisabledIfSortIsNull()
        {
            var grid = new WebGrid(GetContext(), defaultSort: null).Bind(Dynamics(
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
                                                                             ));
            Assert.Equal("Joe", grid.Rows[0]["FirstName"]);
            Assert.Equal("Bob", grid.Rows[1]["FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["FirstName"]);
        }

        [Fact]
        public void SortForDynamics()
        {
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName").Bind(Dynamics(
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
                                                                                    ));
            Assert.Equal("Bob", grid.Rows[0]["FirstName"]);
            Assert.Equal("Joe", grid.Rows[1]["FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["FirstName"]);
        }

        [Fact]
        public void SortForDynamicsDescending()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "LastName";
            queryString["sortdir"] = "DESCENDING";
            var grid = new WebGrid(GetContext(queryString), defaultSort: "FirstName").Bind(Dynamics(
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
                                                                                               ));
            Assert.Equal("Smith", grid.Rows[0]["LastName"]);
            Assert.Equal("Jones", grid.Rows[1]["LastName"]);
            Assert.Equal("Johnson", grid.Rows[2]["LastName"]);
            Assert.Equal("Anderson", grid.Rows[3]["LastName"]);
        }

        [Fact]
        public void SortForNonDynamicNavigationColumn()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "Not.A.Column";
            var grid = new WebGrid(GetContext(queryString), defaultSort: "Person.FirstName").Bind(new[]
            {
                new { Person = new { FirstName = "Joe", LastName = "Smith" } },
                new { Person = new { FirstName = "Bob", LastName = "Johnson" } },
                new { Person = new { FirstName = "Sam", LastName = "Jones" } },
                new { Person = new { FirstName = "Tom", LastName = "Anderson" } }
            });
            Assert.Equal("Not.A.Column", grid.SortColumn); // navigation columns are validated during sort
            Assert.Equal("Bob", grid.Rows[0]["Person.FirstName"]);
            Assert.Equal("Joe", grid.Rows[1]["Person.FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["Person.FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["Person.FirstName"]);
        }

        [Fact]
        public void SortForNonDynamics()
        {
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName").Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
            });
            Assert.Equal("Bob", grid.Rows[0]["FirstName"]);
            Assert.Equal("Joe", grid.Rows[1]["FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["FirstName"]);
        }

        [Fact]
        public void SortForNonDynamicsDescending()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "LastName";
            queryString["sortdir"] = "DESCENDING";
            var grid = new WebGrid(GetContext(queryString), defaultSort: "FirstName").Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
            });
            Assert.Equal("Smith", grid.Rows[0]["LastName"]);
            Assert.Equal("Jones", grid.Rows[1]["LastName"]);
            Assert.Equal("Johnson", grid.Rows[2]["LastName"]);
            Assert.Equal("Anderson", grid.Rows[3]["LastName"]);
        }

        [Fact]
        public void SortForNonDynamicsEnumerable()
        {
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName").Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
            }.ToList());
            Assert.Equal("Bob", grid.Rows[0]["FirstName"]);
            Assert.Equal("Joe", grid.Rows[1]["FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["FirstName"]);
        }

        [Fact]
        public void SortForNonDynamicsEnumerableDescending()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "LastName";
            queryString["sortdir"] = "DESCENDING";
            var grid = new WebGrid(GetContext(queryString), defaultSort: "FirstName").Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
            }.ToList());
            Assert.Equal("Smith", grid.Rows[0]["LastName"]);
            Assert.Equal("Jones", grid.Rows[1]["LastName"]);
            Assert.Equal("Johnson", grid.Rows[2]["LastName"]);
            Assert.Equal("Anderson", grid.Rows[3]["LastName"]);
        }

        [Fact]
        public void SortForNonGenericEnumerable()
        {
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName").Bind(new NonGenericEnumerable(new[]
            {
                new Person { FirstName = "Joe", LastName = "Smith" },
                new Person { FirstName = "Bob", LastName = "Johnson" },
                new Person { FirstName = "Sam", LastName = "Jones" },
                new Person { FirstName = "Tom", LastName = "Anderson" }
            }));
            Assert.Equal("Bob", grid.Rows[0]["FirstName"]);
            Assert.Equal("Joe", grid.Rows[1]["FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["FirstName"]);
        }

        [Fact]
        public void SortForNonGenericEnumerableDescending()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["sort"] = "LastName";
            queryString["sortdir"] = "DESCENDING";
            var grid = new WebGrid(GetContext(queryString), defaultSort: "FirstName").Bind(new NonGenericEnumerable(new[]
            {
                new Person { FirstName = "Joe", LastName = "Smith" },
                new Person { FirstName = "Bob", LastName = "Johnson" },
                new Person { FirstName = "Sam", LastName = "Jones" },
                new Person { FirstName = "Tom", LastName = "Anderson" }
            }));
            Assert.Equal("Smith", grid.Rows[0]["LastName"]);
            Assert.Equal("Jones", grid.Rows[1]["LastName"]);
            Assert.Equal("Johnson", grid.Rows[2]["LastName"]);
            Assert.Equal("Anderson", grid.Rows[3]["LastName"]);
        }

        [Fact]
        public void SortUrlDefaults()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { FirstName = "Bob" }
            });
            string html = grid.GetSortUrl("FirstName");
            Assert.Equal("?sort=FirstName&sortdir=ASC", html.ToString());
        }

        [Fact]
        public void SortUrlThrowsIfColumnNameIsEmpty()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { }, new { }
            });
            Assert.ThrowsArgumentNullOrEmptyString(() => { grid.GetSortUrl(String.Empty); }, "column");
        }

        [Fact]
        public void SortUrlThrowsIfColumnNameIsNull()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { }, new { }
            });
            Assert.ThrowsArgumentNullOrEmptyString(() => { grid.GetSortUrl(null); }, "column");
        }

        [Fact]
        public void SortUrlThrowsIfSortingIsDisabled()
        {
            var grid = new WebGrid(GetContext(), canSort: false).Bind(new[]
            {
                new { P1 = 1 }, new { P1 = 2 }
            });
            Assert.Throws<NotSupportedException>(() => { grid.GetSortUrl("P1"); }, "This operation is not supported when sorting is disabled for the \"WebGrid\" object.");
        }

        [Fact]
        public void SortWhenSortIsDisabled()
        {
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName", canSort: false).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" },
                new { FirstName = "Sam", LastName = "Jones" },
                new { FirstName = "Tom", LastName = "Anderson" }
            });
            Assert.Equal("Joe", grid.Rows[0]["FirstName"]);
            Assert.Equal("Bob", grid.Rows[1]["FirstName"]);
            Assert.Equal("Sam", grid.Rows[2]["FirstName"]);
            Assert.Equal("Tom", grid.Rows[3]["FirstName"]);
        }

        [Fact]
        public void SortWithNullValues()
        {
            var data = new[]
            {
                new { FirstName = (object)"Joe", LastName = "Smith" },
                new { FirstName = (object)"Bob", LastName = "Johnson" },
                new { FirstName = (object)null, LastName = "Jones" }
            };
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName").Bind(data);

            Assert.Equal("Jones", grid.Rows[0]["LastName"]);
            Assert.Equal("Bob", grid.Rows[1]["FirstName"]);
            Assert.Equal("Joe", grid.Rows[2]["FirstName"]);

            grid = new WebGrid(GetContext(), defaultSort: "FirstName desc").Bind(data);

            Assert.Equal("Joe", grid.Rows[0]["FirstName"]);
            Assert.Equal("Bob", grid.Rows[1]["FirstName"]);
            Assert.Equal("Jones", grid.Rows[2]["LastName"]);
        }

        [Fact]
        public void SortWithMultipleNullValues()
        {
            var data = new[]
            {
                new { FirstName = (object)"Joe", LastName = "Smith" },
                new { FirstName = (object)"Bob", LastName = "Johnson" },
                new { FirstName = (object)null, LastName = "Hughes" },
                new { FirstName = (object)null, LastName = "Jones" }
            };
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName").Bind(data);

            Assert.Equal("Hughes", grid.Rows[0]["LastName"]);
            Assert.Equal("Jones", grid.Rows[1]["LastName"]);
            Assert.Equal("Bob", grid.Rows[2]["FirstName"]);
            Assert.Equal("Joe", grid.Rows[3]["FirstName"]);

            grid = new WebGrid(GetContext(), defaultSort: "FirstName desc").Bind(data);

            Assert.Equal("Joe", grid.Rows[0]["FirstName"]);
            Assert.Equal("Bob", grid.Rows[1]["FirstName"]);
            Assert.Equal("Hughes", grid.Rows[2]["LastName"]);
            Assert.Equal("Jones", grid.Rows[3]["LastName"]);
        }

        [Fact]
        public void SortWithMixedValuesDoesNotThrow()
        {
            var data = new[]
            {
                new { FirstName = (object)1, LastName = "Smith" },
                new { FirstName = (object)"Bob", LastName = "Johnson" },
                new { FirstName = (object)DBNull.Value, LastName = "Jones" }
            };
            var grid = new WebGrid(GetContext(), defaultSort: "FirstName").Bind(data);

            Assert.NotNull(grid.Rows);

            Assert.Equal("Smith", grid.Rows[0]["LastName"]);
            Assert.Equal("Johnson", grid.Rows[1]["LastName"]);
            Assert.Equal("Jones", grid.Rows[2]["LastName"]);
        }

        [Fact]
        public void SortWithUnsortableDoesNotThrow()
        {
            var object1 = new object();
            var object2 = new object();
            var data = new[]
            {
                new { Value = object1 },
                new { Value = object2 }
            };
            var grid = new WebGrid(GetContext(), defaultSort: "Value").Bind(data);

            Assert.NotNull(grid.Rows);

            Assert.Equal(object1, grid.Rows[0]["Value"]);
            Assert.Equal(object2, grid.Rows[1]["Value"]);
        }

        [Fact]
        public void TableRenderingWithColumnTemplates()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 3).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            var html = grid.Table(displayHeader: false,
                                  columns: new[]
                                  {
                                      grid.Column("P1", format: item => { return "<span>P1: " + item.P1 + "</span>"; }),
                                      grid.Column("P2", format: item => { return new HtmlString("<span>P2: " + item.P2 + "</span>"); }),
                                      grid.Column("P3", format: item => { return new HelperResult(tw => { tw.Write("<span>P3: " + item.P3 + "</span>"); }); })
                                  });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><tbody><tr>" +
                "<td>&lt;span&gt;P1: 1&lt;/span&gt;</td>" +
                "<td><span>P2: 2</span></td>" +
                "<td><span>P3: 3</span></td>" +
                "</tr></tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithDefaultCellValueOfCustom()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 3).Bind(new[]
            {
                new { P1 = String.Empty, P2 = (string)null },
            });
            var html = grid.Table(fillEmptyRows: true, emptyRowCellValue: "N/A", displayHeader: false);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><tbody>" +
                "<tr><td></td><td></td></tr>" +
                "<tr><td>N/A</td><td>N/A</td></tr>" +
                "<tr><td>N/A</td><td>N/A</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithDefaultCellValueOfEmpty()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 3).Bind(new[]
            {
                new { P1 = String.Empty, P2 = (string)null }
            });
            var html = grid.Table(fillEmptyRows: true, emptyRowCellValue: "", displayHeader: false);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><tbody>" +
                "<tr><td></td><td></td></tr>" +
                "<tr><td></td><td></td></tr>" +
                "<tr><td></td><td></td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithDefaultCellValueOfNbsp()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 3).Bind(new[]
            {
                new { P1 = String.Empty, P2 = (string)null }
            });
            var html = grid.Table(fillEmptyRows: true, displayHeader: false);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><tbody>" +
                "<tr><td></td><td></td></tr>" +
                "<tr><td>&nbsp;</td><td>&nbsp;</td></tr>" +
                "<tr><td>&nbsp;</td><td>&nbsp;</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithExclusions()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" }
            });
            var html = grid.Table(exclusions: new string[] { "P2" });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=P1&amp;sortdir=ASC\">P1</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=P3&amp;sortdir=ASC\">P3</a></th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>1</td><td>3</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithNoStylesAndFillEmptyRows()
        {
            var grid = new WebGrid(GetContext(), rowsPerPage: 3).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" }
            });
            var html = grid.Table(fillEmptyRows: true);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=FirstName&amp;sortdir=ASC\">FirstName</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=LastName&amp;sortdir=ASC\">LastName</a></th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>Joe</td><td>Smith</td></tr>" +
                "<tr><td>&nbsp;</td><td>&nbsp;</td></tr>" +
                "<tr><td>&nbsp;</td><td>&nbsp;</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithSortingDisabled()
        {
            var grid = new WebGrid(GetContext(), canSort: false).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" }
            });
            var html = grid.Table();
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\">FirstName</th>" +
                "<th scope=\"col\">LastName</th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>Joe</td><td>Smith</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithAttributes()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" }
            });
            var html = grid.Table(htmlAttributes: new { id = "my-table-id", summary = "Table summary" });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table id=\"my-table-id\" summary=\"Table summary\"><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=FirstName&amp;sortdir=ASC\">FirstName</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=LastName&amp;sortdir=ASC\">LastName</a></th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>Joe</td><td>Smith</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingEncodesAttributes()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" }
            });
            var html = grid.Table(htmlAttributes: new { summary = "\"<Table summary" });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table summary=\"&quot;&lt;Table summary\"><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=FirstName&amp;sortdir=ASC\">FirstName</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=LastName&amp;sortdir=ASC\">LastName</a></th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>Joe</td><td>Smith</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingIsNotAffectedWhenAttributesIsNull()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" }
            });
            var html = grid.Table(htmlAttributes: null);
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=FirstName&amp;sortdir=ASC\">FirstName</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=LastName&amp;sortdir=ASC\">LastName</a></th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>Joe</td><td>Smith</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingIsNotAffectedWhenAttributesIsEmpty()
        {
            var grid = new WebGrid(GetContext()).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" }
            });
            var html = grid.Table(htmlAttributes: new { });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>" +
                "<th scope=\"col\"><a href=\"?sort=FirstName&amp;sortdir=ASC\">FirstName</a></th>" +
                "<th scope=\"col\"><a href=\"?sort=LastName&amp;sortdir=ASC\">LastName</a></th>" +
                "</tr></thead>" +
                "<tbody>" +
                "<tr><td>Joe</td><td>Smith</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableRenderingWithStyles()
        {
            NameValueCollection queryString = new NameValueCollection();
            queryString["row"] = "1";
            var grid = new WebGrid(GetContext(queryString), rowsPerPage: 4).Bind(new[]
            {
                new { FirstName = "Joe", LastName = "Smith" },
                new { FirstName = "Bob", LastName = "Johnson" }
            });
            var html = grid.Table(tableStyle: "tbl", headerStyle: "hdr", footerStyle: "ftr",
                                  rowStyle: "row", alternatingRowStyle: "arow", selectedRowStyle: "sel", fillEmptyRows: true,
                                  footer: item => "footer text",
                                  columns: new[]
                                  {
                                      grid.Column("firstName", style: "c1", canSort: false),
                                      grid.Column("lastName", style: "c2", canSort: false)
                                  });
            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table class=\"tbl\"><thead><tr class=\"hdr\">" +
                "<th scope=\"col\">firstName</th><th scope=\"col\">lastName</th>" +
                "</tr></thead>" +
                "<tfoot>" +
                "<tr class=\"ftr\"><td colspan=\"2\">footer text</td></tr>" +
                "</tfoot>" +
                "<tbody>" +
                "<tr class=\"row sel\"><td class=\"c1\">Joe</td><td class=\"c2\">Smith</td></tr>" +
                "<tr class=\"arow\"><td class=\"c1\">Bob</td><td class=\"c2\">Johnson</td></tr>" +
                "<tr class=\"row\"><td class=\"c1\">&nbsp;</td><td class=\"c2\">&nbsp;</td></tr>" +
                "<tr class=\"arow\"><td class=\"c1\">&nbsp;</td><td class=\"c2\">&nbsp;</td></tr>" +
                "</tbody></table>", html.ToString());
            XhtmlAssert.Validate1_1(html);
        }

        [Fact]
        public void TableWithAjax()
        {
            var grid = new WebGrid(GetContext(), ajaxUpdateContainerId: "grid").Bind(new[]
            {
                new { First = "First", Second = "Second" }
            });
            string html = grid.Table().ToString();
            Assert.Contains("<script", html);
            Assert.Contains("swhgajax=\"true\"", html);
        }

        [Fact]
        public void TableWithAjaxAndCallback()
        {
            var grid = new WebGrid(GetContext(), ajaxUpdateContainerId: "grid", ajaxUpdateCallback: "myCallback").Bind(new[]
            {
                new { First = "First", Second = "Second" }
            });
            string html = grid.Table().ToString();
            Assert.Contains("<script", html);
            Assert.Contains("myCallback", html);
        }

        [Fact]
        public void WebGridEncodesAjaxDataStrings()
        {
            var grid = new WebGrid(GetContext(), ajaxUpdateContainerId: "'grid'", ajaxUpdateCallback: "'myCallback'").Bind(new[]
            {
                new { First = "First", Second = "Second" }
            });
            string html = grid.Table().ToString();
            Assert.Contains(@"&#39;grid&#39;", html);
            Assert.Contains(@"&#39;myCallback&#39;", html);
        }

        [Fact]
        public void WebGridThrowsIfOperationsArePerformedBeforeBinding()
        {
            // Arrange
            string errorMessage = "A data source must be bound before this operation can be performed.";
            var grid = new WebGrid(GetContext());

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => { var rows = grid.Rows; }, errorMessage);
            Assert.Throws<InvalidOperationException>(() => { int count = grid.TotalRowCount; }, errorMessage);
            Assert.Throws<InvalidOperationException>(() => grid.GetHtml().ToString(), errorMessage);
            Assert.Throws<InvalidOperationException>(() => grid.Pager().ToString(), errorMessage);
            Assert.Throws<InvalidOperationException>(() => grid.Table().ToString(), errorMessage);
            Assert.Throws<InvalidOperationException>(() =>
            {
                grid.SelectedIndex = 1;
                var row = grid.SelectedRow;
            }, errorMessage);
        }

        [Fact]
        public void WebGridThrowsIfBindingIsPerformedWhenAlreadyBound()
        {
            // Arrange
            var grid = new WebGrid(GetContext());
            var values = Enumerable.Range(0, 10).Cast<dynamic>();

            // Act
            grid.Bind(values);

            // Assert
            Assert.Throws<InvalidOperationException>(() => grid.Bind(values), "The WebGrid instance is already bound to a data source.");
        }

        [Fact]
        public void GetElementTypeReturnsDynamicTypeIfElementIsDynamic()
        {
            // Arrange
            IEnumerable<dynamic> elements = Dynamics(new[] { new Person { FirstName = "Foo", LastName = "Bar" } });

            // Act
            Type type = WebGrid.GetElementType(elements);

            // Assert
            Assert.Equal(typeof(IDynamicMetaObjectProvider), type);
        }

        [Fact]
        public void GetElementTypeReturnsEnumerableTypeIfFirstInstanceIsNotDynamic()
        {
            // Arrange
            IEnumerable<dynamic> elements = Iterator();

            // Act
            Type type = WebGrid.GetElementType(elements);

            // Assert
            Assert.Equal(typeof(Person), type);
        }

        [Fact]
        public void TableThrowsIfQueryStringDerivedSortColumnIsExcluded()
        {
            // Arrange
            NameValueCollection collection = new NameValueCollection();
            collection["sort"] = "Salary";
            var context = GetContext(collection);
            IList<Employee> employees = new List<Employee>();
            employees.Add(new Employee { Name = "A", Salary = 5, Manager = new Employee { Name = "-" } });
            employees.Add(new Employee { Name = "B", Salary = 20, Manager = employees[0] });
            employees.Add(new Employee { Name = "C", Salary = 15, Manager = employees[0] });
            employees.Add(new Employee { Name = "D", Salary = 5, Manager = employees[1] });

            var grid = new WebGrid(context, defaultSort: "Name").Bind(employees);

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => grid.GetHtml(exclusions: new[] { "Salary" }), "Column \"Salary\" does not exist.");
        }

        [Fact]
        public void TableThrowsIfQueryStringDerivedSortColumnDoesNotExistInColumnsArgument()
        {
            // Arrange
            NameValueCollection collection = new NameValueCollection();
            collection["sort"] = "Salary";
            var context = GetContext(collection);
            IList<Employee> employees = new List<Employee>();
            employees.Add(new Employee { Name = "A", Salary = 5, Manager = new Employee { Name = "-" } });
            employees.Add(new Employee { Name = "B", Salary = 20, Manager = employees[0] });
            employees.Add(new Employee { Name = "C", Salary = 15, Manager = employees[0] });
            employees.Add(new Employee { Name = "D", Salary = 5, Manager = employees[1] });

            var grid = new WebGrid(context, canSort: true, defaultSort: "Name").Bind(employees);

            // Act and Assert
            Assert.Throws<InvalidOperationException>(
                () => grid.Table(columns: new[] { new WebGridColumn { ColumnName = "Name" }, new WebGridColumn { ColumnName = "Manager.Name" } }),
                "Column \"Salary\" does not exist.");
        }

        [Fact]
        public void TableDoesNotThrowIfQueryStringDerivedSortColumnIsVisibleButNotSortable()
        {
            // Arrange
            NameValueCollection collection = new NameValueCollection();
            collection["sort"] = "Salary";
            collection["sortDir"] = "Desc";
            var context = GetContext(collection);
            IList<Employee> employees = new List<Employee>();
            employees.Add(new Employee { Name = "A", Salary = 5, Manager = new Employee { Name = "-" } });
            employees.Add(new Employee { Name = "B", Salary = 20, Manager = employees[0] });
            employees.Add(new Employee { Name = "C", Salary = 15, Manager = employees[0] });
            employees.Add(new Employee { Name = "D", Salary = 10, Manager = employees[1] });

            var grid = new WebGrid(context, canSort: true).Bind(employees);

            // Act
            var html = grid.Table(columns: new[] { new WebGridColumn { ColumnName = "Salary", CanSort = false } });

            // Assert
            Assert.NotNull(html);
            Assert.Equal(20, grid.Rows[0]["Salary"]);
            Assert.Equal(15, grid.Rows[1]["Salary"]);
            Assert.Equal(10, grid.Rows[2]["Salary"]);
            Assert.Equal(5, grid.Rows[3]["Salary"]);
        }

        [Fact]
        public void TableThrowsIfComplexPropertyIsUnsortable()
        {
            // Arrange
            NameValueCollection collection = new NameValueCollection();
            collection["sort"] = "Manager.Salary";
            var context = GetContext(collection);
            IList<Employee> employees = new List<Employee>();
            employees.Add(new Employee { Name = "A", Salary = 5, Manager = new Employee { Name = "-" } });
            employees.Add(new Employee { Name = "B", Salary = 20, Manager = employees[0] });
            employees.Add(new Employee { Name = "C", Salary = 15, Manager = employees[0] });
            employees.Add(new Employee { Name = "D", Salary = 5, Manager = employees[1] });
            var grid = new WebGrid(context).Bind(employees, columnNames: new[] { "Name", "Manager.Name" });

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => grid.GetHtml(),
                                                              "Column \"Manager.Salary\" does not exist.");
        }

        [Fact]
        public void TableDoesNotThrowIfUnsortableColumnIsExplicitlySpecifiedByUser()
        {
            // Arrange
            var context = GetContext();
            IList<Employee> employees = new List<Employee>();
            employees.Add(new Employee { Name = "A", Salary = 5, Manager = new Employee { Name = "-" } });
            employees.Add(new Employee { Name = "C", Salary = 15, Manager = employees[0] });
            employees.Add(new Employee { Name = "D", Salary = 10, Manager = employees[1] });

            // Act
            var grid = new WebGrid(context).Bind(employees, columnNames: new[] { "Name", "Manager.Name" });
            grid.SortColumn = "Salary";
            var html = grid.Table();

            // Assert
            Assert.Equal(5, grid.Rows[0]["Salary"]);
            Assert.Equal(10, grid.Rows[1]["Salary"]);
            Assert.Equal(15, grid.Rows[2]["Salary"]);

            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>"
                + "<th scope=\"col\"><a href=\"?sort=Name&amp;sortdir=ASC\">Name</a></th>"
                + "<th scope=\"col\"><a href=\"?sort=Manager.Name&amp;sortdir=ASC\">Manager.Name</a></th>"
                + "</tr></thead><tbody>"
                + "<tr><td>A</td><td>-</td></tr>"
                + "<tr><td>D</td><td>C</td></tr>"
                + "<tr><td>C</td><td>A</td></tr>"
                + "</tbody></table>", html.ToString());
        }

        [Fact]
        public void TableDoesNotThrowIfUnsortableColumnIsDefaultSortColumn()
        {
            // Arrange
            var context = GetContext();
            IList<Employee> employees = new List<Employee>();
            employees.Add(new Employee { Name = "A", Salary = 5, Manager = new Employee { Name = "-" } });
            employees.Add(new Employee { Name = "C", Salary = 15, Manager = employees[0] });
            employees.Add(new Employee { Name = "D", Salary = 10, Manager = employees[1] });

            // Act
            var grid = new WebGrid(context, defaultSort: "Salary").Bind(employees, columnNames: new[] { "Name", "Manager.Name" });
            var html = grid.Table();

            // Assert
            Assert.Equal(5, grid.Rows[0]["Salary"]);
            Assert.Equal(10, grid.Rows[1]["Salary"]);
            Assert.Equal(15, grid.Rows[2]["Salary"]);

            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>"
                + "<th scope=\"col\"><a href=\"?sort=Name&amp;sortdir=ASC\">Name</a></th>"
                + "<th scope=\"col\"><a href=\"?sort=Manager.Name&amp;sortdir=ASC\">Manager.Name</a></th>"
                + "</tr></thead><tbody>"
                + "<tr><td>A</td><td>-</td></tr>"
                + "<tr><td>D</td><td>C</td></tr>"
                + "<tr><td>C</td><td>A</td></tr>"
                + "</tbody></table>", html.ToString());
        }

        [Fact]
        public void CustomSorter()
        {
            // Arrange
            var context = GetContext();
            IList<Employee> employees = new List<Employee>();
            employees.Add(new Employee { Name = "A", Salary = 10, Manager = new Employee { Name = "C" } });
            employees.Add(new Employee { Name = "B", Salary = 20, Manager = null });
            employees.Add(new Employee { Name = "C", Salary = 30, Manager = new Employee { Name = "A" } });

            // Act
            var grid = new WebGrid(context, defaultSort: "Salary")
                .AddSorter("Manager.Name", (Employee x) => (x == null || x.Manager == null) ? null : x.Manager.Name);

            grid.Bind(employees);

            grid.SortColumn = "Manager.Name";
            grid.SortDirection = SortDirection.Ascending;

            var html = grid.Table(columns: grid.Columns(
                grid.Column("Name"),
                grid.Column("Manager.Name",
                header: "Manager",
                format: item => item.Manager == null ? "" : item.Manager.Name)));

            // Assert
            Assert.Equal(20, grid.Rows[0]["Salary"]);
            Assert.Equal(30, grid.Rows[1]["Salary"]);
            Assert.Equal(10, grid.Rows[2]["Salary"]);

            UnitTestHelper.AssertEqualsIgnoreWhitespace(
                "<table><thead><tr>"
                + "<th scope=\"col\"><a href=\"?sort=Name&amp;sortdir=ASC\">Name</a></th>"
                + "<th scope=\"col\"><a href=\"?sort=Manager.Name&amp;sortdir=DESC\">Manager</a></th>"
                + "</tr></thead><tbody>"
                + "<tr><td>B</td><td></td></tr>"
                + "<tr><td>C</td><td>A</td></tr>"
                + "<tr><td>A</td><td>C</td></tr>"
                + "</tbody></table>", html.ToString());
        }

        private static IEnumerable<Person> Iterator()
        {
            yield return new Person { FirstName = "Foo", LastName = "Bar" };
        }

        [Fact]
        public void GetElementTypeReturnsEnumerableTypeIfCollectionPassedImplementsEnumerable()
        {
            // Arrange
            IList<Person> listElements = new List<Person> { new Person { FirstName = "Foo", LastName = "Bar" } };
            HashSet<dynamic> setElements = new HashSet<dynamic> { new DynamicWrapper(new Person { FirstName = "Foo", LastName = "Bar" }) };

            // Act
            Type listType = WebGrid.GetElementType(listElements);
            Type setType = WebGrid.GetElementType(setElements);

            // Assert
            Assert.Equal(typeof(Person), listType);
            Assert.Equal(typeof(IDynamicMetaObjectProvider), setType);
        }

        [Fact]
        public void GetElementTypeReturnsEnumerableTypeIfCollectionImplementsEnumerable()
        {
            // Arrange
            IEnumerable<Person> elements = new NonGenericEnumerable(new[] { new Person { FirstName = "Foo", LastName = "Bar" } });

            // Act
            Type type = WebGrid.GetElementType(elements);

            // Assert
            Assert.Equal(typeof(Person), type);
        }

        [Fact]
        public void GetElementTypeReturnsEnumerableTypeIfCollectionIsIEnumerable()
        {
            // Arrange
            IEnumerable<Person> elements = new GenericEnumerable<Person>(new[] { new Person { FirstName = "Foo", LastName = "Bar" } });

            // Act
            Type type = WebGrid.GetElementType(elements);

            // Assert
            Assert.Equal(typeof(Person), type);
        }

        [Fact]
        public void GetElementTypeDoesNotThrowIfTypeIsNotGeneric()
        {
            // Arrange
            IEnumerable<dynamic> elements = new[] { new Person { FirstName = "Foo", LastName = "Bar" } };

            // Act
            Type type = WebGrid.GetElementType(elements);

            // Assert
            Assert.Equal(typeof(Person), type);
        }

        [Fact]
        public void WebGridWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            // Arrange
            const string expected = @"data-name=""value""";
            const string unexpected = @"data_name=""value""";
            var attributes = new { data_name = "value" };

            var grid = new WebGrid(GetContext(), ajaxUpdateContainerId: "grid")
                    .Bind(new[]
            {
                new { P1 = 1, P2 = '2', P3 = "3" },
                new { P1 = 4, P2 = '5', P3 = "6" }
            });

            // Act
            var htmlString = grid.GetHtml(htmlAttributes: attributes).ToHtmlString();

            // Assert
            Assert.DoesNotContain(unexpected, htmlString);
            Assert.Contains(expected, htmlString);
        }


        private static IEnumerable<dynamic> Dynamics(params object[] objects)
        {
            return (from o in objects
                    select new DynamicWrapper(o)).ToArray();
        }

        private static HttpContextBase GetContext(NameValueCollection queryString = null)
        {
            Mock<HttpRequestBase> requestMock = new Mock<HttpRequestBase>();
            requestMock.Setup(request => request.QueryString).Returns(queryString ?? new NameValueCollection());

            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(context => context.Request).Returns(requestMock.Object);
            contextMock.Setup(context => context.Items).Returns(new Hashtable());
            return contextMock.Object;
        }

        class Person
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
        }

        private class Employee
        {
            public string Name { get; set; }
            public int Salary { get; set; }
            public Employee Manager { get; set; }
        }

        class NonGenericEnumerable : IEnumerable<Person>
        {
            private IEnumerable<Person> _source;

            public NonGenericEnumerable(IEnumerable<Person> source)
            {
                _source = source;
            }

            public IEnumerator<Person> GetEnumerator()
            {
                return _source.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }

        class GenericEnumerable<T> : IEnumerable<T>
        {
            private IEnumerable<T> _source;

            public GenericEnumerable(IEnumerable<T> source)
            {
                _source = source;
            }

            public IEnumerator<T> GetEnumerator()
            {
                return _source.GetEnumerator();
            }

            IEnumerator IEnumerable.GetEnumerator()
            {
                return GetEnumerator();
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/WebImageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Test
{
    public class WebImageTest
    {
        private static readonly byte[] _JpgImageBytes = TestFile.Create("LambdaFinal.jpg").ReadAllBytes();
        private static readonly byte[] _BmpImageBytes = TestFile.Create("logo.bmp").ReadAllBytes();
        private static readonly byte[] _PngImageBytes = TestFile.Create("NETLogo.png").ReadAllBytes();
        private static readonly byte[] _IcoImageBytes = TestFile.Create("Test.ico").ReadAllBytes();

        [Fact]
        public void ConstructorThrowsWhenFilePathIsNull()
        {
            Assert.ThrowsArgument(() =>
                                                    new WebImage(GetContext(), s => new byte[] { }, filePath: null), "filePath", "Value cannot be null or an empty string.");
        }

        [Fact]
        public void ConstructorThrowsWhenFilePathIsEmpty()
        {
            Assert.ThrowsArgument(() =>
                                                    new WebImage(GetContext(), s => new byte[] { }, filePath: String.Empty), "filePath", "Value cannot be null or an empty string.");
        }

        [Fact]
        public void ConstructorThrowsWhenFilePathIsInvalid()
        {
            Assert.Throws<DirectoryNotFoundException>(() =>
                                                               new WebImage(GetContext(), s => { throw new DirectoryNotFoundException(); }, @"x:\this\does\not\exist.jpg"));
        }

        [Fact]
        public void ConstructorThrowsWhenFileContentIsInvalid()
        {
            byte[] imageContent = new byte[] { 32, 111, 209, 138, 76, 32 };
            Assert.ThrowsArgument(() => new WebImage(imageContent), "content",
                                                    "An image could not be constructed from the content provided.");
        }

        [Fact]
        public void FilePathReturnsCorrectPath()
        {
            // Arrange
            string imageName = @"x:\My-test-image.png";

            // Act
            WebImage image = new WebImage(GetContext(), s => _PngImageBytes, imageName);

            // Assert
            Assert.Equal(imageName, image.FileName);
        }

        [Fact]
        public void FilePathCanBeSet()
        {
            // Arrange
            string originalPath = @"x:\somePath.png";
            string newPath = @"x:\someOtherPath.jpg";

            // Act
            WebImage image = new WebImage(GetContext(), s => _PngImageBytes, originalPath);
            image.FileName = newPath;

            // Assert
            Assert.Equal(newPath, image.FileName);
        }

        [Fact]
        public void SimpleGetBytesClonesArray()
        {
            WebImage image = new WebImage(_PngImageBytes);

            byte[] returnedContent = image.GetBytes();

            Assert.False(ReferenceEquals(_PngImageBytes, returnedContent), "GetBytes should clone array.");
            Assert.Equal(_PngImageBytes, returnedContent);
        }

        [Fact]
        public void WebImagePreservesOriginalFormatFromFile()
        {
            WebImage image = new WebImage(_PngImageBytes);

            byte[] returnedContent = image.GetBytes();

            // If format was changed; content would be different
            Assert.Equal(_PngImageBytes, returnedContent);
        }

        [Fact]
        public void WebImagePreservesOriginalFormatFromStream()
        {
            WebImage image = null;
            byte[] originalContent = _PngImageBytes;
            using (MemoryStream stream = new MemoryStream(originalContent))
            {
                image = new WebImage(stream);
            } // dispose stream; WebImage should have no dependency on it

            byte[] returnedContent = image.GetBytes();

            // If format was changed; content would be different
            Assert.Equal(originalContent, returnedContent);
        }

        [Fact]
        public void WebImageCorrectlyReadsFromNoSeekStream()
        {
            WebImage image = null;

            byte[] originalContent = _PngImageBytes;
            using (MemoryStream stream = new MemoryStream(originalContent))
            {
                TestStream ts = new TestStream(stream);
                image = new WebImage(ts);
            } // dispose stream; WebImage should have no dependency on it

            byte[] returnedContent = image.GetBytes();

            // If chunks are not assembled correctly; content would be different and image would be corrupted.
            Assert.Equal(originalContent, returnedContent);
            Assert.Equal("png", image.ImageFormat);
        }

        [Fact]
        public void GetBytesWithNullReturnsClonesArray()
        {
            byte[] originalContent = _BmpImageBytes;
            WebImage image = new WebImage(originalContent);

            byte[] returnedContent = image.GetBytes();

            Assert.False(ReferenceEquals(originalContent, returnedContent), "GetBytes with string null should clone array.");
            Assert.Equal(originalContent, returnedContent);
        }

        [Fact]
        public void GetBytesWithSameFormatReturnsSameFormat()
        {
            byte[] originalContent = _JpgImageBytes;
            WebImage image = new WebImage(originalContent);

            byte[] returnedContent = image.GetBytes("jpeg");

            Assert.False(ReferenceEquals(originalContent, returnedContent), "GetBytes with string null should clone array.");
            Assert.Equal(originalContent, returnedContent);
        }

        [Fact]
        public void GetBytesWithDifferentFormatReturnsExpectedFormat()
        {
            byte[] originalContent = _BmpImageBytes;
            WebImage image = new WebImage(originalContent);

            // Request different format
            byte[] returnedContent = image.GetBytes("jpg");

            Assert.False(ReferenceEquals(originalContent, returnedContent), "GetBytes with string format should clone array.");
            using (MemoryStream stream = new MemoryStream(returnedContent))
            {
                using (Image tempImage = Image.FromStream(stream))
                {
                    Assert.Equal(ImageFormat.Jpeg, tempImage.RawFormat);
                }
            }
        }

        [Fact]
        public void GetBytesWithSameFormatReturnsSameFormatWhenCreatedFromFile()
        {
            byte[] originalContent = _BmpImageBytes;
            // Format is not set during construction.
            WebImage image = new WebImage(_BmpImageBytes);

            byte[] returnedContent = image.GetBytes("bmp");

            Assert.False(ReferenceEquals(originalContent, returnedContent), "GetBytes with string format should clone array.");
            Assert.Equal(originalContent, returnedContent);
        }

        [Fact]
        public void GetBytesWithNoFormatReturnsInitialFormatEvenAfterTransformations()
        {
            byte[] originalContent = _BmpImageBytes;
            // Format is not set during construction.
            WebImage image = new WebImage(_BmpImageBytes);
            image.Crop(top: 10, bottom: 10);

            byte[] returnedContent = image.GetBytes();

            Assert.NotEqual(originalContent, returnedContent);
            using (MemoryStream stream = new MemoryStream(returnedContent))
            {
                using (Image tempImage = Image.FromStream(stream))
                {
                    Assert.Equal(ImageFormat.Bmp, tempImage.RawFormat);
                }
            }
        }

        [Fact]
        public void GetBytesThrowsOnIncorrectFormat()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.ThrowsArgument(
                () => image.GetBytes("bmpx"),
                "format",
                "\"bmpx\" is invalid image format. Valid values are image format names like: \"JPEG\", \"BMP\", \"GIF\", \"PNG\", etc.");
        }

        [Fact]
        public void GetBytesWithDifferentFormatReturnsExpectedFormatWhenCreatedFromFile()
        {
            // Format is not set during construction.
            WebImage image = new WebImage(_PngImageBytes);

            // Request different format
            byte[] returnedContent = image.GetBytes("jpg");

            WebImage newImage = new WebImage(returnedContent);

            Assert.Equal("jpeg", newImage.ImageFormat);
        }

        [Fact]
        public void GetImageFromRequestReturnsNullForIncorrectMimeType()
        {
            // Arrange
            Mock<HttpPostedFileBase> postedFile = new Mock<HttpPostedFileBase>();
            postedFile.Setup(c => c.FileName).Returns("index.cshtml");
            postedFile.Setup(c => c.ContentType).Returns("image/jpg");

            Mock<HttpFileCollectionBase> files = new Mock<HttpFileCollectionBase>();
            files.Setup(c => c[0]).Returns(postedFile.Object);
            Mock<HttpRequestBase> request = new Mock<HttpRequestBase>();
            request.Setup(r => r.Files).Returns(files.Object);

            // Act and Assert
            Assert.Null(WebImage.GetImageFromRequest(request.Object));
        }

        public static IEnumerable<object[]> GetImageFromRequestDeterminesMimeTypeFromExtensionData
        {
            get
            {
                yield return new object[] { "index.jpeg", _JpgImageBytes, "jpeg" };
                yield return new object[] { "file1.jpg", _JpgImageBytes, "jpeg" };
                yield return new object[] { "file4.png", _PngImageBytes, "png" };
                yield return new object[] { "file5.ico", _IcoImageBytes, "icon" };
            }
        }

        [Theory]
        [PropertyData("GetImageFromRequestDeterminesMimeTypeFromExtensionData")]
        public void GetImageFromRequestDeterminesMimeTypeFromExtension(string fileName,
                                                                       byte[] content,
                                                                       string expectedExtension)
        {
            // Arrange
            Mock<HttpPostedFileBase> postedFile = new Mock<HttpPostedFileBase>();
            postedFile.Setup(c => c.FileName).Returns(fileName);
            postedFile.Setup(c => c.ContentType).Returns("application/octet-stream");
            postedFile.Setup(c => c.ContentLength).Returns(1);
            postedFile.Setup(c => c.InputStream).Returns(new MemoryStream(content));

            Mock<HttpFileCollectionBase> files = new Mock<HttpFileCollectionBase>();
            files.Setup(c => c.Count).Returns(1);
            files.Setup(c => c[0]).Returns(postedFile.Object);
            Mock<HttpRequestBase> request = new Mock<HttpRequestBase>();
            request.Setup(r => r.Files).Returns(files.Object);

            // Act
            WebImage image = WebImage.GetImageFromRequest(request.Object);

            // Assert
            Assert.NotNull(image);
            Assert.Equal(expectedExtension, image.ImageFormat);
        }

        [Fact]
        public void GetImageFromRequestIsCaseInsensitive()
        {
            // Arrange
            Mock<HttpPostedFileBase> postedFile = new Mock<HttpPostedFileBase>();
            postedFile.SetupGet(c => c.FileName).Returns("index.JPg");
            postedFile.SetupGet(c => c.ContentType).Returns("application/octet-stream");
            postedFile.SetupGet(c => c.ContentLength).Returns(1);
            postedFile.SetupGet(c => c.InputStream).Returns(new MemoryStream(_JpgImageBytes));

            Mock<HttpFileCollectionBase> files = new Mock<HttpFileCollectionBase>();
            files.Setup(c => c.Count).Returns(1);
            files.Setup(c => c[0]).Returns(postedFile.Object);
            Mock<HttpRequestBase> request = new Mock<HttpRequestBase>();
            request.Setup(r => r.Files).Returns(files.Object);

            // Act
            WebImage image = WebImage.GetImageFromRequest(request.Object);

            // Assert
            Assert.NotNull(image);
            Assert.Equal("jpeg", image.ImageFormat);
        }

        [Fact]
        public void ImagePropertiesAreCorrectForBmpImage()
        {
            WebImage image = new WebImage(_BmpImageBytes);

            Assert.Equal("bmp", image.ImageFormat);
            Assert.Equal(108, image.Width);
            Assert.Equal(44, image.Height);
        }

        [Fact]
        public void ImagePropertiesAreCorrectForPngImage()
        {
            WebImage image = new WebImage(_PngImageBytes);

            Assert.Equal("png", image.ImageFormat);
            Assert.Equal(160, image.Width);
            Assert.Equal(152, image.Height);
        }

        [Fact]
        public void ImagePropertiesAreCorrectForJpgImage()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.Equal("jpeg", image.ImageFormat);
            Assert.Equal(634, image.Width);
            Assert.Equal(489, image.Height);
        }

        [Fact]
        public void ResizePreservesRatio()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            image.Resize(200, 100, preserveAspectRatio: true, preventEnlarge: true);

            Assert.Equal(130, image.Width);
            Assert.Equal(100, image.Height);
        }

        [Fact]
        public void ResizePreservesResolution()
        {
            MemoryStream output = null;
            Action<string, byte[]> saveAction = (_, content) => { output = new MemoryStream(content); };

            WebImage image = new WebImage(_PngImageBytes);

            image.Resize(100, 50, preserveAspectRatio: true, preventEnlarge: true);

            image.Save(GetContext(), saveAction, @"x:\ResizePreservesResolution.jpg", "jpeg", forceWellKnownExtension: true);
            using (Image original = Image.FromStream(new MemoryStream(_PngImageBytes)))
            {
                using (Image modified = Image.FromStream(output))
                {
                    Assert.Equal(original.HorizontalResolution, modified.HorizontalResolution);
                    Assert.Equal(original.VerticalResolution, modified.VerticalResolution);
                }
            }
        }

        [Fact]
        public void ResizePreservesFormat()
        {
            // Arrange
            WebImage image = new WebImage(_PngImageBytes);
            MemoryStream output = null;
            Action<string, byte[]> saveAction = (_, content) => { output = new MemoryStream(content); };

            // Act
            image.Resize(200, 100, preserveAspectRatio: true, preventEnlarge: true);

            // Assert
            Assert.Equal("png", image.ImageFormat);
            image.Save(GetContext(), saveAction, @"x:\1.png", null, false);

            using (Image modified = Image.FromStream(output))
            {
                Assert.Equal(ImageFormat.Png, modified.RawFormat);
            }
        }

        [Fact]
        public void SaveUpdatesFileNameOfWebImageWhenForcingWellKnownExtension()
        {
            // Arrange
            var context = GetContext();

            // Act
            WebImage image = new WebImage(context, _ => _JpgImageBytes, @"c:\images\foo.jpg");

            image.Save(context, (_, __) => { }, @"x:\1.exe", "jpg", forceWellKnownExtension: true);

            // Assert
            Assert.Equal(@"x:\1.exe.jpeg", image.FileName);
        }

        [Fact]
        public void SaveUpdatesFileNameOfWebImageWhenFormatChanges()
        {
            // Arrange
            string imagePath = @"x:\images\foo.jpg";
            var context = GetContext();

            // Act
            WebImage image = new WebImage(context, _ => _JpgImageBytes, imagePath);

            image.Save(context, (_, __) => { }, imagePath, "png", forceWellKnownExtension: true);

            // Assert
            Assert.Equal(@"x:\images\foo.jpg.png", image.FileName);
        }

        [Fact]
        public void SaveKeepsNameIfFormatIsUnchanged()
        {
            // Arrange
            string imagePath = @"x:\images\foo.jpg";
            var context = GetContext();

            // Act
            WebImage image = new WebImage(context, _ => _JpgImageBytes, imagePath);

            image.Save(context, (_, __) => { }, imagePath, "jpg", forceWellKnownExtension: true);

            // Assert
            Assert.Equal(@"x:\images\foo.jpg", image.FileName);
        }

        [Fact]
        public void ResizeThrowsOnIncorrectWidthOrHeight()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentGreaterThan(
                () => image.Resize(-1, 100, preserveAspectRatio: true, preventEnlarge: true),
                "width",
                "0");

            Assert.ThrowsArgumentGreaterThan(
                () => image.Resize(100, -1, preserveAspectRatio: true, preventEnlarge: true),
                "height",
                "0");
        }

        [Fact]
        public void ResizeAndRotateDoesOperationsInRightOrder()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.Resize(200, 100, preserveAspectRatio: true, preventEnlarge: true).RotateLeft();

            Assert.Equal(100, image.Width);
            Assert.Equal(130, image.Height);
        }

        [Fact]
        public void ClonePreservesAllInformation()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.Resize(200, 100, preserveAspectRatio: true, preventEnlarge: true).RotateLeft();

            // this should preserve list of transformations
            WebImage cloned = image.Clone();

            Assert.Equal(100, cloned.Width);
            Assert.Equal(130, cloned.Height);
        }

        [Fact]
        public void ResizePreventsEnlarge()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            int height = image.Height;
            int width = image.Width;

            image.Resize(width * 2, height, preserveAspectRatio: true, preventEnlarge: true);
            Assert.Equal(width, image.Width);
            Assert.Equal(height, image.Height);
        }

        [Fact]
        public void CropCreatesCroppedImage()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.Crop(20, 20, 20, 20);

            Assert.Equal(594, image.Width);
            Assert.Equal(449, image.Height);
        }

        [Fact]
        public void CropThrowsOnIncorrectArguments()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.Crop(top: -1),
                "top",
                "0");

            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.Crop(left: -1),
                "left",
                "0");

            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.Crop(bottom: -1),
                "bottom",
                "0");

            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.Crop(right: -1),
                "right",
                "0");
        }

        [Fact]
        public void RotateLeftReturnsRotatedImage()
        {
            WebImage image = new WebImage(_PngImageBytes);
            image.RotateLeft();

            Assert.Equal(152, image.Width);
            Assert.Equal(160, image.Height);
        }

        [Fact]
        public void RotateRightReturnsRotatedImage()
        {
            WebImage image = new WebImage(_PngImageBytes);
            image.RotateRight();

            Assert.Equal(152, image.Width);
            Assert.Equal(160, image.Height);
        }

        [Fact]
        public void FlipVerticalReturnsFlippedImage()
        {
            WebImage image = new WebImage(_PngImageBytes);
            image.FlipVertical();

            Assert.Equal(160, image.Width);
            Assert.Equal(152, image.Height);
        }

        [Fact]
        public void FlipHorizontalReturnsFlippedImage()
        {
            WebImage image = new WebImage(_PngImageBytes);
            image.FlipHorizontal();

            Assert.Equal(160, image.Width);
            Assert.Equal(152, image.Height);
        }

        [Fact]
        public void MultipleCombinedOperationsExecuteInRightOrder()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.Resize(200, 100, preserveAspectRatio: true, preventEnlarge: true).RotateLeft();
            image.Crop(top: 10, right: 10).AddTextWatermark("plan9");

            Assert.Equal(90, image.Width);
            Assert.Equal(120, image.Height);
        }

        [Fact]
        public void AddTextWatermarkPreservesImageDimension()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.AddTextWatermark("Plan9", fontSize: 16, horizontalAlign: "Left", verticalAlign: "Bottom", opacity: 50);

            Assert.Equal(634, image.Width);
            Assert.Equal(489, image.Height);
        }

        [Fact]
        public void AddTextWatermarkParsesHexColorCorrectly()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.AddTextWatermark("Plan9", fontSize: 16, fontColor: "#FF0000", horizontalAlign: "Center", verticalAlign: "Middle");

            Assert.Equal(634, image.Width);
            Assert.Equal(489, image.Height);
        }

        [Fact]
        public void AddTextWatermarkParsesShortHexColorCorrectly()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.AddTextWatermark("Plan9", fontSize: 16, fontColor: "#F00", horizontalAlign: "Center", verticalAlign: "Middle");

            Assert.Equal(634, image.Width);
            Assert.Equal(489, image.Height);
        }

        [Fact]
        public void AddTextWatermarkDoesNotChangeImageIfPaddingIsTooBig()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            image.AddTextWatermark("Plan9", padding: 1000);

            Assert.Equal(634, image.Width);
            Assert.Equal(489, image.Height);
        }

        [Fact]
        public void AddTextWatermarkThrowsOnNegativeOpacity()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentOutOfRange(() => image.AddTextWatermark("Plan9", opacity: -1), "opacity", "Value must be between 0 and 100.");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnTooBigOpacity()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentOutOfRange(() => image.AddTextWatermark("Plan9", opacity: 155), "opacity", "Value must be between 0 and 100.");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnEmptyText()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.ThrowsArgumentNullOrEmptyString(
                () => image.AddTextWatermark(""),
                "text");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectColorName()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.Throws<ArgumentException>(
                () => image.AddTextWatermark("p9", fontColor: "super"),
                "The \"fontColor\" value is invalid. Valid values are names like \"White\", \"Black\", or \"DarkBlue\", or hexadecimal values in the form \"#RRGGBB\" or \"#RGB\".");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectHexColorValue()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.Throws<ArgumentException>(
                () => image.AddTextWatermark("p9", fontColor: "#XXX"),
                "The \"fontColor\" value is invalid. Valid values are names like \"White\", \"Black\", or \"DarkBlue\", or hexadecimal values in the form \"#RRGGBB\" or \"#RGB\".");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectHexColorLength()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.Throws<ArgumentException>(
                () => image.AddTextWatermark("p9", fontColor: "#F000"),
                "The \"fontColor\" value is invalid. Valid values are names like \"White\", \"Black\", or \"DarkBlue\", or hexadecimal values in the form \"#RRGGBB\" or \"#RGB\".");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectHorizontalAlignment()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.Throws<ArgumentException>(
                () => image.AddTextWatermark("p9", horizontalAlign: "Justify"),
                "The \"horizontalAlign\" value is invalid. Valid values are: \"Right\", \"Left\", and \"Center\".");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectVerticalAlignment()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.Throws<ArgumentException>(
                () => image.AddTextWatermark("p9", verticalAlign: "NotSet"),
                "The \"verticalAlign\" value is invalid. Valid values are: \"Top\", \"Bottom\", and \"Middle\".");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnNegativePadding()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.AddTextWatermark("p9", padding: -10),
                "padding",
                "0");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectFontSize()
        {
            WebImage image = new WebImage(_JpgImageBytes);
            Assert.ThrowsArgumentGreaterThan(
                () => image.AddTextWatermark("p9", fontSize: -10),
                "fontSize",
                "0");

            Assert.ThrowsArgumentGreaterThan(
                () => image.AddTextWatermark("p9", fontSize: 0),
                "fontSize",
                "0");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectFontStyle()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.Throws<ArgumentException>(
                () => image.AddTextWatermark("p9", fontStyle: "something"),
                "The \"fontStyle\" value is invalid. Valid values are: \"Regular\", \"Bold\", \"Italic\", \"Underline\", and \"Strikeout\".");
        }

        [Fact]
        public void AddTextWatermarkThrowsOnIncorrectFontFamily()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.Throws<ArgumentException>(
                () => image.AddTextWatermark("p9", fontFamily: "something"),
                "The \"fontFamily\" value is invalid. Valid values are font family names like: \"Arial\", \"Times New Roman\", etc. Make sure that the font family you are trying to use is installed on the server.");
        }

        [Fact]
        public void AddImageWatermarkPreservesImageDimension()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);
            image.AddImageWatermark(watermark, horizontalAlign: "LEFT", verticalAlign: "top", opacity: 50, padding: 10);

            Assert.Equal(634, image.Width);
            Assert.Equal(489, image.Height);
        }

        [Fact]
        public void CanAddTextAndImageWatermarks()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);
            image.AddImageWatermark(watermark, horizontalAlign: "LEFT", verticalAlign: "top", opacity: 30, padding: 10);
            image.AddTextWatermark("plan9");

            Assert.Equal(634, image.Width);
            Assert.Equal(489, image.Height);
        }

        [Fact]
        public void AddImageWatermarkDoesNotChangeWatermarkImage()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);
            image.AddImageWatermark(watermark, width: 54, height: 22, horizontalAlign: "LEFT", verticalAlign: "top", opacity: 50, padding: 10);

            Assert.Equal(108, watermark.Width);
            Assert.Equal(44, watermark.Height);
        }

        [Fact]
        public void AddImageWatermarkThrowsOnNullImage()
        {
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentNull(
                () => image.AddImageWatermark(watermarkImage: null),
                "watermarkImage");
        }

        [Fact]
        public void AddImageWatermarkThrowsWhenJustOneDimensionIsZero()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);

            string message = "Watermark width and height must both be positive or both be zero.";
            Assert.Throws<ArgumentException>(
                () => image.AddImageWatermark(watermark, width: 0, height: 22), message);

            Assert.Throws<ArgumentException>(
                () => image.AddImageWatermark(watermark, width: 100, height: 0), message);
        }

        [Fact]
        public void AddImageWatermarkThrowsWhenOpacityIsIncorrect()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentOutOfRange(() => image.AddImageWatermark(watermark, opacity: -1), "opacity", "Value must be between 0 and 100.");

            Assert.ThrowsArgumentOutOfRange(() => image.AddImageWatermark(watermark, opacity: 120), "opacity", "Value must be between 0 and 100.");
        }

        [Fact]
        public void AddImageWatermarkThrowsOnNegativeDimensions()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.AddImageWatermark(watermark, width: -1),
                "width",
                "0");

            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.AddImageWatermark(watermark, height: -1),
                "height",
                "0");
        }

        [Fact]
        public void AddImageWatermarkThrowsOnIncorrectHorizontalAlignment()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.Throws<ArgumentException>(
                () => image.AddImageWatermark(watermark, horizontalAlign: "horizontal"),
                "The \"horizontalAlign\" value is invalid. Valid values are: \"Right\", \"Left\", and \"Center\".");
        }

        [Fact]
        public void AddImageWatermarkThrowsOnIncorrectVerticalAlignment()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.Throws<ArgumentException>(
                () => image.AddImageWatermark(watermark, verticalAlign: "vertical"),
                "The \"verticalAlign\" value is invalid. Valid values are: \"Top\", \"Bottom\", and \"Middle\".");
        }

        [Fact]
        public void AddImageWatermarkThrowsOnNegativePadding()
        {
            WebImage watermark = new WebImage(_BmpImageBytes);
            WebImage image = new WebImage(_JpgImageBytes);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(
                () => image.AddImageWatermark(watermark, padding: -10),
                "padding",
                "0");
        }

        [Fact]
        public void AddImageWatermarkDoesNotChangeImageIfWatermarkIsTooBig()
        {
            WebImage watermark = new WebImage(_JpgImageBytes);
            WebImage image = new WebImage(_BmpImageBytes);
            byte[] originalBytes = image.GetBytes("jpg");

            // This will use original watermark image dimensions which is bigger than the target image.
            image.AddImageWatermark(watermark);
            byte[] watermarkedBytes = image.GetBytes("jpg");

            Assert.Equal(originalBytes, watermarkedBytes);
        }

        [Fact]
        public void AddImageWatermarkWithFileNameThrowsExceptionWhenWatermarkDirectoryDoesNotExist()
        {
            var context = GetContext();
            WebImage image = new WebImage(_BmpImageBytes);

            Assert.Throws<DirectoryNotFoundException>(
                () => image.AddImageWatermark(context, s => { throw new DirectoryNotFoundException(); }, @"x:\path\does\not\exist", width: 0, height: 0, horizontalAlign: "Right", verticalAlign: "Bottom", opacity: 100, padding: 5));
        }

        [Fact]
        public void AddImageWatermarkWithFileNameThrowsExceptionWhenWatermarkFileDoesNotExist()
        {
            var context = GetContext();
            WebImage image = new WebImage(_BmpImageBytes);
            Assert.Throws<FileNotFoundException>(
                () => image.AddImageWatermark(context, s => { throw new FileNotFoundException(); }, @"x:\there-is-no-file.jpg", width: 0, height: 0, horizontalAlign: "Right", verticalAlign: "Bottom", opacity: 100, padding: 5));
        }

        [Fact]
        public void AddImageWatermarkWithFileNameThrowsExceptionWhenWatermarkFilePathIsNull()
        {
            var context = GetContext();

            WebImage image = new WebImage(_BmpImageBytes);
            Assert.ThrowsArgument(
                () => image.AddImageWatermark(context, s => _JpgImageBytes, watermarkImageFilePath: null, width: 0, height: 0, horizontalAlign: "Right", verticalAlign: "Bottom", opacity: 100, padding: 5),
                "filePath",
                "Value cannot be null or an empty string.");
        }

        [Fact]
        public void AddImageWatermarkWithFileNameThrowsExceptionWhenWatermarkFilePathIsEmpty()
        {
            var context = GetContext();
            WebImage image = new WebImage(_BmpImageBytes);
            Assert.ThrowsArgument(
                () => image.AddImageWatermark(context, s => _JpgImageBytes, watermarkImageFilePath: null, width: 0, height: 0, horizontalAlign: "Right", verticalAlign: "Bottom", opacity: 100, padding: 5),
                "filePath",
                "Value cannot be null or an empty string.");
        }

        [Fact]
        public void CanAddImageWatermarkWithFileName()
        {
            // Arrange
            var context = GetContext();
            WebImage image = new WebImage(_BmpImageBytes);
            WebImage watermark = new WebImage(_JpgImageBytes);

            // Act
            var watermarkedWithImageArgument = image.AddImageWatermark(watermark).GetBytes();
            var watermarkedWithFilePathArgument = image.AddImageWatermark(context, (name) => _JpgImageBytes, @"x:\jpegimage.jpg", width: 0, height: 0, horizontalAlign: "Right", verticalAlign: "Bottom", opacity: 100, padding: 5).GetBytes();

            Assert.Equal(watermarkedWithImageArgument, watermarkedWithFilePathArgument);
        }

        [Fact]
        public void SaveOverwritesExistingFile()
        {
            Action<string, byte[]> saveAction = (path, content) => { };

            WebImage image = new WebImage(_BmpImageBytes);
            string newFileName = @"x:\newImage.bmp";

            image.Save(GetContext(), saveAction, newFileName, imageFormat: null, forceWellKnownExtension: true);

            image.RotateLeft();
            // just verify this does not throw
            image.Save(GetContext(), saveAction, newFileName, imageFormat: null, forceWellKnownExtension: true);
        }

        [Fact]
        public void SaveThrowsWhenPathIsNull()
        {
            Action<string, byte[]> saveAction = (path, content) => { };

            // this constructor will not set path
            byte[] originalContent = _BmpImageBytes;
            WebImage image = new WebImage(originalContent);

            Assert.ThrowsArgumentNullOrEmptyString(
                () => image.Save(GetContext(), saveAction, filePath: null, imageFormat: null, forceWellKnownExtension: true),
                "filePath");
        }

        [Fact]
        public void SaveThrowsWhenPathIsEmpty()
        {
            Action<string, byte[]> saveAction = (path, content) => { };
            WebImage image = new WebImage(_BmpImageBytes);

            Assert.ThrowsArgumentNullOrEmptyString(
                () => image.Save(GetContext(), saveAction, filePath: String.Empty, imageFormat: null, forceWellKnownExtension: true),
                "filePath");
        }

        [Fact]
        public void SaveUsesOriginalFormatWhenNoFormatIsSpecified()
        {
            // Arrange
            // Use rooted path so we by pass using HttpContext
            var specifiedOutputFile = @"C:\some-dir\foo.jpg";
            string actualOutputFile = null;
            Action<string, byte[]> saveAction = (fileName, content) => { actualOutputFile = fileName; };

            // Act
            WebImage image = new WebImage(_PngImageBytes);
            image.Save(GetContext(), saveAction, filePath: specifiedOutputFile, imageFormat: null, forceWellKnownExtension: true);

            // Assert
            Assert.Equal(".png", Path.GetExtension(actualOutputFile));
        }

        [Fact]
        public void SaveUsesOriginalFormatForStreamsWhenNoFormatIsSpecified()
        {
            // Arrange
            // Use rooted path so we by pass using HttpContext
            var specifiedOutputFile = @"x:\some-dir\foo.jpg";
            string actualOutputFile = null;
            Action<string, byte[]> saveAction = (fileName, content) => { actualOutputFile = fileName; };

            // Act
            WebImage image = new WebImage(_PngImageBytes);
            image.Save(GetContext(), saveAction, filePath: specifiedOutputFile, imageFormat: null, forceWellKnownExtension: true);

            // Assert
            Assert.Equal(".png", Path.GetExtension(actualOutputFile));
        }

        [Fact]
        public void SaveSetsExtensionBasedOnFormatWhenForceExtensionIsSet()
        {
            // Arrange
            // Use rooted path so we by pass using HttpContext
            var specifiedOutputFile = @"x:\some-dir\foo.exe";
            string actualOutputFile = null;
            Action<string, byte[]> saveAction = (fileName, content) => { actualOutputFile = fileName; };

            // Act
            WebImage image = new WebImage(_BmpImageBytes);
            image.Save(GetContext(), saveAction, filePath: specifiedOutputFile, imageFormat: "jpg", forceWellKnownExtension: true);

            // Assert
            Assert.Equal(".jpeg", Path.GetExtension(actualOutputFile));
            Assert.Equal(specifiedOutputFile + ".jpeg", actualOutputFile);
        }

        [Fact]
        public void SaveAppendsExtensionBasedOnFormatWhenForceExtensionIsSet()
        {
            // Arrange
            // Use rooted path so we by pass using HttpContext
            var specifiedOutputFile = @"x:\some-dir\foo";
            string actualOutputFile = null;
            Action<string, byte[]> saveAction = (fileName, content) => { actualOutputFile = fileName; };

            // Act
            WebImage image = new WebImage(_BmpImageBytes);
            image.Save(GetContext(), saveAction, filePath: specifiedOutputFile, imageFormat: "jpg", forceWellKnownExtension: true);

            // Assert
            Assert.Equal(".jpeg", Path.GetExtension(actualOutputFile));
        }

        [Fact]
        public void SaveDoesNotModifyExtensionWhenExtensionIsCorrect()
        {
            // Arrange
            // Use rooted path so we by pass using HttpContext
            var specifiedOutputFile = @"x:\some-dir\foo.jpg";
            string actualOutputFile = null;
            Action<string, byte[]> saveAction = (fileName, content) => { actualOutputFile = fileName; };

            // Act
            WebImage image = new WebImage(_BmpImageBytes);
            image.Save(GetContext(), saveAction, filePath: specifiedOutputFile, imageFormat: "jpg", forceWellKnownExtension: true);

            // Assert
            Assert.Equal(specifiedOutputFile, actualOutputFile);
        }

        [Fact]
        public void SaveDoesNotModifyExtensionWhenForceCorrectExtensionRenameIsCleared()
        {
            // Arrange
            // Use rooted path so we by pass using HttpContext
            var specifiedOutputFile = @"x:\some-dir\foo.exe";
            string actualOutputFile = null;
            Action<string, byte[]> saveAction = (fileName, content) => { actualOutputFile = fileName; };

            // Act
            WebImage image = new WebImage(_BmpImageBytes);
            image.Save(GetContext(), saveAction, filePath: specifiedOutputFile, imageFormat: "jpg", forceWellKnownExtension: false);

            // Assert
            Assert.Equal(specifiedOutputFile, actualOutputFile);
        }

        [Fact]
        public void ImageFormatIsSavedCorrectly()
        {
            WebImage image = new WebImage(_BmpImageBytes);
            Assert.Equal("bmp", image.ImageFormat);
        }

        [Fact]
        public void SaveUsesInitialFormatWhenNoFormatIsSpecified()
        {
            // Arrange
            string savePath = @"x:\some-dir\image.png";
            MemoryStream stream = null;
            Action<string, byte[]> saveAction = (path, content) => { stream = new MemoryStream(content); };
            var image = new WebImage(_PngImageBytes);

            // Act 
            image.FlipVertical().FlipHorizontal();

            // Assert
            image.Save(GetContext(), saveAction, savePath, imageFormat: null, forceWellKnownExtension: true);

            using (Image savedImage = Image.FromStream(stream))
            {
                Assert.Equal(savedImage.RawFormat, ImageFormat.Png);
            }
        }

        [Fact]
        public void ImageFormatIsParsedCorrectly()
        {
            WebImage image = new WebImage(_BmpImageBytes);
            Assert.Equal("bmp", image.ImageFormat);
        }

        private static HttpContextBase GetContext()
        {
            var httpContext = new Mock<HttpContextBase>();
            var httpRequest = new Mock<HttpRequestBase>();
            httpRequest.Setup(c => c.MapPath(It.IsAny<string>())).Returns((string path) => path);
            httpContext.Setup(c => c.Request).Returns(httpRequest.Object);

            return httpContext.Object;
        }

        // Test stream that pretends it can't seek. 
        private class TestStream : Stream
        {
            private MemoryStream _memoryStream;

            public TestStream(MemoryStream memoryStream)
            {
                _memoryStream = memoryStream;
            }

            public override bool CanRead
            {
                get { return _memoryStream.CanRead; }
            }

            public override bool CanSeek
            {
                get { return false; }
            }

            public override bool CanWrite
            {
                get { return _memoryStream.CanWrite; }
            }

            public override void Flush()
            {
                _memoryStream.Flush();
            }

            public override long Length
            {
                get { throw new NotSupportedException(); }
            }

            public override long Position
            {
                get { return _memoryStream.Position; }
                set { _memoryStream.Position = value; }
            }

            public override int Read(byte[] buffer, int offset, int count)
            {
                return _memoryStream.Read(buffer, offset, count);
            }

            public override long Seek(long offset, SeekOrigin origin)
            {
                throw new NotSupportedException();
            }

            public override void SetLength(long value)
            {
                _memoryStream.SetLength(value);
            }

            public override void Write(byte[] buffer, int offset, int count)
            {
                _memoryStream.Write(buffer, offset, count);
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/WebMailTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Net.Mail;
using System.Text;
using System.Web.WebPages.Scope;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class WebMailTest : IDisposable
    {
        const string FromAddress = "abc@123.com";
        const string Server = "myserver.com";
        const int Port = 100;
        const string UserName = "My UserName";
        const string Password = "My Password";

        [Fact]
        public void WebMailSmtpServerTests()
        {
            // All tests prior to setting smtp server go here
            // Verify Send throws if no SmtpServer is set
            Assert.Throws<InvalidOperationException>(
                () => WebMail.Send(to: "test@test.com", subject: "test", body: "test body"),
                "\"SmtpServer\" was not specified."
                );

            // Verify SmtpServer uses scope storage.
            // Arrange
            var value = "value";

            // Act
            WebMail.SmtpServer = value;

            // Assert
            Assert.Equal(WebMail.SmtpServer, value);
            Assert.Equal(ScopeStorage.CurrentScope[WebMail.SmtpServerKey], value);
        }

        [Fact]
        public void WebMailSendThrowsIfPriorityIsInvalid()
        {
            Assert.ThrowsArgument(
                () => WebMail.Send(to: "test@test.com", subject: "test", body: "test body", priority: "foo"),
                "priority",
                "The \"priority\" value is invalid. Valid values are \"Low\", \"Normal\" and \"High\"."
                );
        }

        [Fact]
        public void WebMailUsesScopeStorageForSmtpPort()
        {
            // Arrange
            var value = 4;

            // Act
            WebMail.SmtpPort = value;

            // Assert
            Assert.Equal(WebMail.SmtpPort, value);
            Assert.Equal(ScopeStorage.CurrentScope[WebMail.SmtpPortKey], value);
        }

        [Fact]
        public void WebMailUsesScopeStorageForEnableSsl()
        {
            // Arrange
            var value = true;

            // Act
            WebMail.EnableSsl = value;

            // Assert
            Assert.Equal(WebMail.EnableSsl, value);
            Assert.Equal(ScopeStorage.CurrentScope[WebMail.EnableSslKey], value);
        }

        [Fact]
        public void WebMailUsesScopeStorageForDefaultCredentials()
        {
            // Arrange
            var value = true;

            // Act
            WebMail.SmtpUseDefaultCredentials = value;

            // Assert
            Assert.Equal(WebMail.SmtpUseDefaultCredentials, value);
            Assert.Equal(ScopeStorage.CurrentScope[WebMail.SmtpUseDefaultCredentialsKey], value);
        }

        [Fact]
        public void WebMailUsesScopeStorageForUserName()
        {
            // Arrange
            var value = "value";

            // Act
            WebMail.UserName = value;

            // Assert
            Assert.Equal(WebMail.UserName, value);
            Assert.Equal(ScopeStorage.CurrentScope[WebMail.UserNameKey], value);
        }

        [Fact]
        public void WebMailUsesScopeStorageForPassword()
        {
            // Arrange
            var value = "value";

            // Act
            WebMail.Password = value;

            // Assert
            Assert.Equal(WebMail.Password, value);
            Assert.Equal(ScopeStorage.CurrentScope[WebMail.PasswordKey], value);
        }

        [Fact]
        public void WebMailUsesScopeStorageForFrom()
        {
            // Arrange
            var value = "value";

            // Act
            WebMail.From = value;

            // Assert
            Assert.Equal(WebMail.From, value);
            Assert.Equal(ScopeStorage.CurrentScope[WebMail.FromKey], value);
        }

        [Fact]
        public void WebMailThrowsWhenSmtpServerValueIsNullOrEmpty()
        {
            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => WebMail.SmtpServer = null, "SmtpServer");
            Assert.ThrowsArgumentNullOrEmptyString(() => WebMail.SmtpServer = String.Empty, "SmtpServer");
        }

        [Fact]
        public void ParseHeaderParsesStringInKeyValueFormat()
        {
            // Arrange
            string header = "foo: bar";

            // Act
            string key, value;

            // Assert
            Assert.True(WebMail.TryParseHeader(header, out key, out value));
            Assert.Equal("foo", key);
            Assert.Equal("bar", value);
        }

        [Fact]
        public void ParseHeaderReturnsFalseIfHeaderIsNotInCorrectFormat()
        {
            // Arrange
            string header = "foo bar";

            // Act
            string key, value;

            // Assert
            Assert.False(WebMail.TryParseHeader(header, out key, out value));
            Assert.Null(key);
            Assert.Null(value);
        }

        [Fact]
        public void SetPropertiesOnMessageTest_SetsAllInfoCorrectlyOnMailMessageTest()
        {
            // Arrange
            MailMessage message = new MailMessage();
            string to = "abc123@xyz.com";
            string subject = "subject1";
            string body = "body1";
            string from = FromAddress;
            string cc = "cc@xyz.com";
            string attachmentName = "NETLogo.png";
            string bcc = "foo@bar.com";
            string replyTo = "x@y.com,z@pqr.com";
            string contentEncoding = "utf-8";
            string headerEncoding = "utf-16";
            var priority = MailPriority.Low;

            // Act
            string fileToAttach = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());

            try
            {
                TestFile.Create(attachmentName).Save(fileToAttach);
                bool isBodyHtml = true;
                var additionalHeaders = new[] { "header1:value1" };
                WebMail.SetPropertiesOnMessage(message, to, subject, body, from, cc, bcc, replyTo, contentEncoding, headerEncoding, priority, new[] { fileToAttach }, isBodyHtml, additionalHeaders);

                // Assert
                Assert.Equal(body, message.Body);
                Assert.Equal(subject, message.Subject);
                Assert.Equal(to, message.To[0].Address);
                Assert.Equal(cc, message.CC[0].Address);
                Assert.Equal(from, message.From.Address);
                Assert.Equal(bcc, message.Bcc[0].Address);
                Assert.Equal("x@y.com", message.ReplyToList[0].Address);
                Assert.Equal("z@pqr.com", message.ReplyToList[1].Address);
                Assert.Equal(MailPriority.Low, message.Priority);
                Assert.Equal(Encoding.UTF8, message.BodyEncoding);
                Assert.Equal(Encoding.Unicode, message.HeadersEncoding);

                Assert.Contains("header1", message.Headers.AllKeys);
                Assert.Single(message.Attachments);
            }
            finally
            {
                try
                {
                    File.Delete(fileToAttach);
                }
                catch (IOException)
                {
                } // Try our best to clean up after ourselves
            }
        }

        [Fact]
        public void MailSendWithNullInCollection_ThrowsArgumentException()
        {
            Assert.Throws<ArgumentException>(
                () => WebMail.Send("foo@bar.com", "sub", "body", filesToAttach: new string[] { "c:\\foo.txt", null }),
                "A string in the collection is null or empty.\r\nParameter name: filesToAttach"
            );

            Assert.Throws<ArgumentException>(
                () => WebMail.Send("foo@bar.com", "sub", "body", additionalHeaders: new string[] { "foo:bar", null }),
                "A string in the collection is null or empty.\r\nParameter name: additionalHeaders"
            );
        }

        [Fact]
        public void AssignHeaderValuesIgnoresMalformedHeaders()
        {
            // Arrange
            var message = new MailMessage();
            var headers = new[] { "foo1:bar1", "foo2", "foo3|bar3", "foo4 bar4" };

            // Act
            WebMail.AssignHeaderValues(message, headers);

            // Assert
            Assert.Single(message.Headers);
            Assert.Equal("foo1", message.Headers.AllKeys[0]);
            Assert.Equal("bar1", message.Headers[0]);
        }

        [Fact]
        public void PropertiesDuplicatedAcrossHeaderAndArgumentDoesNotThrow()
        {
            // Arrange
            var message = new MailMessage();
            var headers = new[] { "to:to@test.com" };

            // Act
            WebMail.SetPropertiesOnMessage(message, "to@test.com", null, null, "from@test.com", null, null, null, null, null, MailPriority.Normal, null, false, headers);

            // Assert
            Assert.Equal(2, message.To.Count);
            Assert.Equal("to@test.com", message.To.First().Address);
            Assert.Equal("to@test.com", message.To.Last().Address);
        }

        [Fact]
        public void AssignHeaderValuesSetsPropertiesForKnownHeaderValues()
        {
            // Arrange
            var message = new MailMessage();
            var headers = new[]
            {
                "cc:cc@test.com", "bcc:bcc@test.com,bcc2@test.com", "from:from@test.com", "priority:high", "reply-to:replyto1@test.com,replyto2@test.com",
                "sender: sender@test.com", "to:to@test.com"
            };

            // Act
            WebMail.AssignHeaderValues(message, headers);

            // Assert
            Assert.Equal("cc@test.com", message.CC.Single().Address);
            Assert.Equal("bcc@test.com", message.Bcc.First().Address);
            Assert.Equal("bcc2@test.com", message.Bcc.Last().Address);
            Assert.Equal("from@test.com", message.From.Address);
            Assert.Equal(MailPriority.High, message.Priority);
            Assert.Equal("replyto1@test.com", message.ReplyToList.First().Address);
            Assert.Equal("replyto2@test.com", message.ReplyToList.Last().Address);
            Assert.Equal("sender@test.com", message.Sender.Address);
            Assert.Equal("to@test.com", message.To.Single().Address);

            // Assert we transparently set header values
            Assert.Equal(headers.Count(), message.Headers.Count);
        }

        [Fact]
        public void AssignHeaderDoesNotThrowIfPriorityValueIsInvalid()
        {
            // Arrange
            var message = new MailMessage();
            var headers = new[] { "priority:invalid-value" };

            // Act
            WebMail.AssignHeaderValues(message, headers);

            // Assert
            Assert.Equal(MailPriority.Normal, message.Priority);

            // Assert we transparently set header values
            Assert.Single(message.Headers);
            Assert.Equal("Priority", message.Headers.Keys[0]);
            Assert.Equal("invalid-value", message.Headers["Priority"]);
        }

        [Fact]
        public void AssignHeaderDoesNotThrowIfMailAddressIsInvalid()
        {
            // Arrange
            var message = new MailMessage();
            var headers = new[] { "to:not-#-email@@" };

            // Act
            WebMail.AssignHeaderValues(message, headers);

            // Assert
            Assert.Empty(message.To);

            // Assert we transparently set header values
            Assert.Single(message.Headers);
            Assert.Equal("To", message.Headers.Keys[0]);
            Assert.Equal("not-#-email@@", message.Headers["To"]);
        }

        [Fact]
        public void AssignHeaderDoesNotThrowIfKnownHeaderValuesAreEmptyOrMalformed()
        {
            // Arrange
            var message = new MailMessage();
            var headers = new[] { "to:", ":reply-to", "priority:false" };

            // Act
            WebMail.AssignHeaderValues(message, headers);

            // Assert
            Assert.Empty(message.To);

            // Assert we transparently set header values
            Assert.Single(message.Headers);
            Assert.Equal("Priority", message.Headers.Keys[0]);
            Assert.Equal("false", message.Headers["Priority"]);
        }

        [Fact]
        public void ArgumentsToSendTakePriorityOverHeader()
        {
            // Arrange
            var message = new MailMessage();
            var headers = new[] { "from:header-from@test.com", "cc:header-cc@test.com", "priority:low" };

            // Act
            WebMail.SetPropertiesOnMessage(message, null, null, null, "direct-from@test.com", "direct-cc@test.com", null, null, null, null, MailPriority.High, null, false, headers);

            // Assert
            Assert.Equal("direct-from@test.com", message.From.Address);
            Assert.Equal("header-cc@test.com", message.CC.First().Address);
            Assert.Equal("direct-cc@test.com", message.CC.Last().Address);
            Assert.Equal(MailPriority.High, message.Priority);
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. WebMail.SmtpServer) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/XhtmlAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net;
using System.Reflection;
using System.Text.RegularExpressions;
using System.Web.WebPages;
using System.Xml;
using System.Xml.Resolvers;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    // see: http://msdn.microsoft.com/en-us/library/hdf992b8(v=VS.100).aspx
    // see: http://blogs.msdn.com/xmlteam/archive/2008/08/14/introducing-the-xmlpreloadedresolver.aspx
    public class XhtmlAssert
    {
        const string Xhtml10Wrapper = "<html xmlns=\"http://www.w3.org/1999/xhtml\"><head></head><body>{0}</body></html>";
        const string DOCTYPE_XHTML1_1 = "<!DOCTYPE {0} PUBLIC \"-//W3C//DTD XHTML 1.1//EN\" \"xhtml11-flat.dtd\">\r\n";

        public static void Validate1_0(object result, bool addRoot = false)
        {
            string html = null;
            if (addRoot)
            {
                html = String.Format(Xhtml10Wrapper, GetHtml(result));
            }
            else
            {
                html = GetHtml(result);
            }

            Validate1_0(html);
        }

        public static void Validate1_1(object result, string wrapper = null)
        {
            string root;
            string html = GetHtml(result);
            if (String.IsNullOrEmpty(wrapper))
            {
                root = GetRoot(html);
            }
            else
            {
                root = wrapper;
                html = String.Format("<{0}>{1}</{0}>", wrapper, html);
            }
            Validate1_1(root, html);
        }

        private static string GetHtml(object result)
        {
            Assert.True((result is IHtmlString) || (result is HelperResult), "Helpers should return IHTMLString or HelperResult");
            return result.ToString();
        }

        private static string GetRoot(string html)
        {
            Regex regex = new Regex(@"<(\w+)[\s>]");
            Match match = regex.Match(html);
            Assert.True(match.Success, "Could not determine root element");
            Assert.True(match.Groups.Count > 1, "Could not determine root element");
            return match.Groups[1].Value;
        }

        private static void Validate1_0(string html)
        {
            XmlReaderSettings settings = new XmlReaderSettings();
            settings.DtdProcessing = DtdProcessing.Parse;
            settings.XmlResolver = new XmlPreloadedResolver(XmlKnownDtds.Xhtml10);

            Validate(settings, html);
        }

        private static void Validate1_1(string root, string html)
        {
            var settings = new XmlReaderSettings { DtdProcessing = DtdProcessing.Parse, ValidationType = ValidationType.DTD, XmlResolver = new AssemblyResourceXmlResolver() };

            string docType = String.Format(DOCTYPE_XHTML1_1, root);
            Validate(settings, docType + html);
        }

        private static void Validate(XmlReaderSettings settings, string html)
        {
            using (StringReader sr = new StringReader(html))
            {
                using (XmlReader reader = XmlReader.Create(sr, settings))
                {
                    while (reader.Read())
                    {
                        // XHTML element and attribute names must be lowercase, since XML is case sensitive.
                        // The W3C validator detects this, but we must manually check since the XmlReader does not.
                        // See: http://www.w3.org/TR/xhtml1/#h-4.2
                        if (reader.NodeType == XmlNodeType.Element)
                        {
                            string element = reader.Name;
                            Assert.True(element == element.ToLowerInvariant());
                            if (reader.HasAttributes)
                            {
                                for (int i = 0; i < reader.AttributeCount; i++)
                                {
                                    reader.MoveToAttribute(i);
                                    string attribute = reader.Name;
                                    Assert.True(attribute == attribute.ToLowerInvariant());
                                }
                                // move back to element node
                                reader.MoveToElement();
                            }
                        }
                    }
                }
            }
        }

        private class AssemblyResourceXmlResolver : XmlResolver
        {
            public override ICredentials Credentials
            {
                set { throw new NotSupportedException(); }
            }

            public override object GetEntity(Uri absoluteUri, string role, Type ofObjectToReturn)
            {
                Assembly assembly = typeof(XhtmlAssert).Assembly;
                return assembly.GetManifestResourceStream("System.Web.Helpers.Test.TestFiles.xhtml11-flat.dtd");
            }
        }
    }
}


================================================
FILE: test/System.Web.Helpers.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.Cors.Test/AttributeBasedPolicyProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Net.Http;
using System.Web.Cors;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Cors
{
    public class AttributeBasedPolicyProviderFactoryTest
    {
        [Fact]
        public void GetCorsPolicyProvider_NullRequest_Throws()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            Assert.ThrowsArgumentNull(() =>
                providerFactory.GetCorsPolicyProvider(null),
                "request");
        }

        [Theory]
        [InlineData("DELETE", "", typeof(EnableCorsAttribute))]
        [InlineData("Post", "", typeof(DisableCorsAttribute))]
        [InlineData("get", "", typeof(EnableCorsAttribute))]
        [InlineData("GET", "/3", typeof(DisableCorsAttribute))]
        public void GetCorsPolicyProvider_Preflight_ReturnsExpectedPolicyProvider(string httpMethod, string path, Type expectedProviderType)
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample" + path);
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, httpMethod);
            HttpConfiguration config = new HttpConfiguration();
            request.SetConfiguration(config);
            IHttpRoute route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            request.SetRouteData(route.GetRouteData("/", request));

            ICorsPolicyProvider provider = providerFactory.GetCorsPolicyProvider(request);

            Assert.True(request.GetCorsRequestContext().IsPreflight);
            Assert.IsType(expectedProviderType, provider);
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_ReturnsCompleteControllerContext()
        {
           // Arrange
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "POST");
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerContext controllerContext = null;
            var actionSelector = new Mock<IHttpActionSelector>();
            actionSelector.Setup(s => s.SelectAction(It.IsAny<HttpControllerContext>()))
                          .Callback<HttpControllerContext>(context => controllerContext = context);
            config.Services.Replace(typeof(IHttpActionSelector), actionSelector.Object);
            request.SetConfiguration(config);
            IHttpRoute route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            request.SetRouteData(route.GetRouteData("/", request));

            ICorsPolicyProvider provider = providerFactory.GetCorsPolicyProvider(request);

            // Assert
            Assert.NotNull(controllerContext);
            Assert.Equal(config, controllerContext.Configuration);
            Assert.NotNull(controllerContext.Request);
            Assert.NotNull(controllerContext.RequestContext);
            Assert.NotNull(controllerContext.Controller);
            Assert.NotNull(controllerContext.ControllerDescriptor);
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_DisposesControllerAfterActionSelection()
        {
            // Arrange
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "POST");
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerContext controllerContext = null;
            var actionSelector = new Mock<IHttpActionSelector>();
            actionSelector.Setup(s => s.SelectAction(It.IsAny<HttpControllerContext>()))
                          .Callback<HttpControllerContext>(context =>
                          {
                              Assert.False(((SampleController)context.Controller).Disposed);
                              controllerContext = context;
                          });
            config.Services.Replace(typeof(IHttpActionSelector), actionSelector.Object);
            request.SetConfiguration(config);
            IHttpRoute route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            request.SetRouteData(route.GetRouteData("/", request));

            ICorsPolicyProvider provider = providerFactory.GetCorsPolicyProvider(request);

            // Assert
            Assert.True(((SampleController)controllerContext.Controller).Disposed);
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_NoHttpConfiguration_Throws()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();

            // No HttpConfiguration set on the request.
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "GET");
            HttpConfiguration config = new HttpConfiguration();
            IHttpRoute route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            request.SetRouteData(route.GetRouteData("/", request));

            Assert.Throws<InvalidOperationException>(() =>
                providerFactory.GetCorsPolicyProvider(request),
                "The request does not have an associated configuration object.");
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_NoRouteData_ReturnsNull()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();

            // No RouteData set on the request.
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "GET");
            HttpConfiguration config = new HttpConfiguration();
            request.SetConfiguration(config);

            var provider = providerFactory.GetCorsPolicyProvider(request);

            Assert.Null(provider);
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_ReturnsDefaultPolicyProvider_WhenActionSelectionFails()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            ICorsPolicyProvider mockProvider = new Mock<ICorsPolicyProvider>().Object;
            providerFactory.DefaultPolicyProvider = mockProvider;
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "RandomMethod");
            HttpConfiguration config = new HttpConfiguration();
            request.SetConfiguration(config);
            IHttpRoute route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            request.SetRouteData(route.GetRouteData("/", request));

            ICorsPolicyProvider provider = providerFactory.GetCorsPolicyProvider(request);

            Assert.True(request.GetCorsRequestContext().IsPreflight);
            Assert.Same(mockProvider, provider);
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_Throws_WhenNoDefaultPolicyProviderAndActionSelectionFails()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "RandomMethod");
            HttpConfiguration config = new HttpConfiguration();
            request.SetConfiguration(config);
            IHttpRoute route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            request.SetRouteData(route.GetRouteData("/", request));

            Assert.True(request.GetCorsRequestContext().IsPreflight);
            Assert.Throws<HttpResponseException>(() =>
                providerFactory.GetCorsPolicyProvider(request));
        }

        [Fact]
        public void GetCorsPolicyProvider_ReturnsDefaultPolicyProvider()
        {
            ICorsPolicyProvider mockProvider = new Mock<ICorsPolicyProvider>().Object;
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            providerFactory.DefaultPolicyProvider = mockProvider;
            HttpRequestMessage request = new HttpRequestMessage();
            Func<string> action = new DefaultController().Get;
            request.SetActionDescriptor(new ReflectedHttpActionDescriptor
            {
                MethodInfo = action.Method
            });
            request.Headers.Add("Origin", "http://example.com");

            ICorsPolicyProvider policyProvider = providerFactory.GetCorsPolicyProvider(request);

            Assert.Same(mockProvider, policyProvider);
        }

        [Fact]
        public void GetCorsPolicyProvider_ReturnsPolicyProvider_OnController()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage();
            Func<string> action = new SampleController().Get;
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor
            {
                ControllerName = "Sample",
                ControllerType = typeof(SampleController)
            };
            request.SetActionDescriptor(new ReflectedHttpActionDescriptor
            {
                MethodInfo = action.Method,
                ControllerDescriptor = controllerDescriptor
            });
            request.Headers.Add("Origin", "http://example.com");

            ICorsPolicyProvider policyProvider = providerFactory.GetCorsPolicyProvider(request);

            Assert.NotNull(policyProvider);
            Assert.IsType<EnableCorsAttribute>(policyProvider);
        }

        [Fact]
        public void GetCorsPolicyProvider_ReturnsPolicyProvider_OnAction()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage();
            Func<string> action = new SampleController().Post;
            request.SetActionDescriptor(new ReflectedHttpActionDescriptor
            {
                MethodInfo = action.Method
            });
            request.Headers.Add("Origin", "http://example.com");

            ICorsPolicyProvider policyProvider = providerFactory.GetCorsPolicyProvider(request);

            Assert.NotNull(policyProvider);
            Assert.IsType<DisableCorsAttribute>(policyProvider);
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_ReturnsPolicyProviderUsingPerControllerConfiguration()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/percontrollerconfig");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "httpmethod");
            HttpConfiguration config = new HttpConfiguration();
            request.SetConfiguration(config);
            config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });

            ICorsPolicyProvider provider = providerFactory.GetCorsPolicyProvider(request);

            Assert.True(request.GetCorsRequestContext().IsPreflight);
            EnableCorsAttribute enableCorsAttribute = Assert.IsType<EnableCorsAttribute>(provider);
            string origin = Assert.Single(enableCorsAttribute.Origins);
            Assert.Equal("http://example.com", origin);
        }

        [Fact]
        public void GetCorsPolicyProvider_Preflight_DoesNotUseRouteDataOnTheRequest()
        {
            AttributeBasedPolicyProviderFactory providerFactory = new AttributeBasedPolicyProviderFactory();
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.Headers.Add("Origin", "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "Put");
            HttpConfiguration config = new HttpConfiguration();
            request.SetConfiguration(config);
            var route = config.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            request.SetRouteData(new HttpRouteData(route, new HttpRouteValueDictionary(new { action = "Options", controller = "sample", id = 2 })));

            ICorsPolicyProvider provider = providerFactory.GetCorsPolicyProvider(request);

            Assert.True(request.GetCorsRequestContext().IsPreflight);
            EnableCorsAttribute enableCorsAttribute = Assert.IsType<EnableCorsAttribute>(provider);
            Assert.Equal(2, enableCorsAttribute.Origins.Count());
            Assert.Equal("http://example.com", enableCorsAttribute.Origins[0]);
            Assert.Equal("http://localhost", enableCorsAttribute.Origins[1]);
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/Controllers/DefaultController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Cors
{
    public class DefaultController : ApiController
    {
        public string Get()
        {
            return "value";
        }

        [EnableCors("http://restrictedExample.com", "*", "*")]
        public string Post()
        {
            return "value created";
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/Controllers/ExternalActionSelectorAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;

namespace System.Web.Http.Cors.Test.Controllers
{
    public class ExternalActionSelectorAttribute : Attribute, IControllerConfiguration
    {
        public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
        {
            controllerSettings.Services.Replace(typeof(IHttpActionSelector), new ExternalActionSelector());
        }

        private class ExternalActionSelector : IHttpActionSelector
        {
            public HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
            {
                HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor
                {
                    ControllerName = "Sample",
                    ControllerType = typeof(SampleController)
                };
                Action action = new SampleController().Head;
                return new ReflectedHttpActionDescriptor(controllerDescriptor, action.Method);
            }

            public ILookup<string, HttpActionDescriptor> GetActionMapping(HttpControllerDescriptor controllerDescriptor)
            {
                List<HttpActionDescriptor> descriptors = new List<HttpActionDescriptor>();
                return descriptors.ToLookup(d => d.ActionName);
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/Controllers/PerControllerConfigController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Cors.Test.Controllers
{
    [ExternalActionSelector]
    public class PerControllerConfigController : ApiController
    {
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/Controllers/SampleController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Cors
{
    [EnableCors("*", "*", "*")]
    public class SampleController : ApiController
    {
        public bool Disposed { get; private set; }

        public string Get()
        {
            return "value";
        }

        [DisableCors]
        public string Get(int id)
        {
            return "value" + id;
        }

        [DisableCors]
        public string Post()
        {
            return "value";
        }

        public void Delete()
        {
        }

        [EnableCors("http://example.com", "*", "*")]
        public void Head()
        {
        }

        [EnableCors("http://example.com, http://localhost", "*", "*")]
        public void Put()
        {
        }

        protected override void Dispose(bool disposing)
        {
            Disposed = true;
            base.Dispose(disposing);
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/Controllers/ThrowingController.cs
================================================
namespace System.Web.Http.Cors
{
    [EnableCors("*", "*", "*")]
    public class ThrowingController : ApiController
    {
        public string Get()
        {
            throw new Exception();
        }
    }
}


================================================
FILE: test/System.Web.Http.Cors.Test/CorsHttpConfigurationExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Cors;
using System.Web.Http.Cors.Tracing;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Cors.Test
{
    public class CorsHttpConfigurationExtensionsTest
    {
        [Fact]
        public void EnableCors_NullConfig_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                CorsHttpConfigurationExtensions.EnableCors(null);
            },
            "httpConfiguration");
        }

        [Fact]
        public void EnableCors_AddsCorsMessageHandler_DuringInitializerExecution()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.MessageHandlers.Clear();
            config.EnableCors();

            Assert.Empty(config.MessageHandlers);

            config.Initializer(config);

            var handler = Assert.Single(config.MessageHandlers);
            Assert.IsType<CorsMessageHandler>(handler);
        }

        [Fact]
        public void EnableCors_IsIdempotent()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.MessageHandlers.Clear();
            config.EnableCors();
            config.EnableCors();
            config.EnableCors();

            Assert.Empty(config.MessageHandlers);

            config.Initializer(config);

            var handler = Assert.Single(config.MessageHandlers);
            Assert.IsType<CorsMessageHandler>(handler);
        }

        [Fact]
        public void EnableCors_Initializer_IsIdempotent()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.MessageHandlers.Clear();
            config.EnableCors();

            Assert.Empty(config.MessageHandlers);

            config.Initializer(config);
            config.Initializer(config);
            config.Initializer(config);

            var handler = Assert.Single(config.MessageHandlers);
            Assert.IsType<CorsMessageHandler>(handler);
        }

        [Fact]
        public void EnableCors_AddsCorsPolicyProvider()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.MessageHandlers.Clear();
            EnableCorsAttribute policyProvider = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*");
            config.EnableCors(policyProvider);
            config.Initializer(config);

            ICorsPolicyProviderFactory providerFactory = config.GetCorsPolicyProviderFactory();
            AttributeBasedPolicyProviderFactory attributeProviderFactory = Assert.IsType<AttributeBasedPolicyProviderFactory>(providerFactory);
            Assert.Same(policyProvider, attributeProviderFactory.DefaultPolicyProvider);
        }

        [Fact]
        public void EnableCors_AddsTracers_WhenTracingIsEnabled()
        {
            HttpConfiguration config = new HttpConfiguration();
            ITraceWriter traceMock = new Mock<ITraceWriter>().Object;
            config.Services.Replace(typeof(ITraceWriter), traceMock);
            config.MessageHandlers.Clear();
            EnableCorsAttribute policyProvider = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*");
            config.EnableCors(policyProvider);
            config.Initializer(config);

            ICorsPolicyProviderFactory providerFactory = config.GetCorsPolicyProviderFactory();
            Assert.IsType<CorsPolicyProviderFactoryTracer>(providerFactory);
        }

        [Fact]
        public void GetCorsPolicyProviderFactory_NullHttpConfiguration_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                CorsHttpConfigurationExtensions.GetCorsPolicyProviderFactory(null);
            },
            "httpConfiguration");
        }

        [Fact]
        public void GetCorsPolicyProviderFactory_ReturnsDefaultCorsPolicyProviderFactory()
        {
            HttpConfiguration config = new HttpConfiguration();
            ICorsPolicyProviderFactory providerFactory = config.GetCorsPolicyProviderFactory();

            Assert.NotNull(providerFactory);
            Assert.IsType<AttributeBasedPolicyProviderFactory>(providerFactory);
        }

        [Fact]
        public void GetCorsPolicyProviderFactory_ReturnsTheCustomCorsPolicyProviderFactory()
        {
            ICorsPolicyProviderFactory mockFactory = new Mock<ICorsPolicyProviderFactory>().Object;
            HttpConfiguration config = new HttpConfiguration();
            config.SetCorsPolicyProviderFactory(mockFactory);
            ICorsPolicyProviderFactory providerFactory = config.GetCorsPolicyProviderFactory();

            Assert.Same(mockFactory, providerFactory);
        }

        [Fact]
        public void GetCorsEngine_NullHttpConfiguration_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                CorsHttpConfigurationExtensions.GetCorsEngine(null);
            },
            "httpConfiguration");
        }

        [Fact]
        public void GetCorsEngine_ReturnsDefaultCorsEngine()
        {
            HttpConfiguration config = new HttpConfiguration();
            ICorsEngine corsEngine = config.GetCorsEngine();
            Assert.IsType<CorsEngine>(corsEngine);
        }

        [Fact]
        public void GetCorsEngine_ReturnsTheCustomCorsEngine()
        {
            ICorsEngine mockEngine = new Mock<ICorsEngine>().Object;
            HttpConfiguration config = new HttpConfiguration();
            config.SetCorsEngine(mockEngine);
            ICorsEngine corsEngine = config.GetCorsEngine();
            Assert.Same(mockEngine, corsEngine);
        }

        [Fact]
        public void SetCorsEngine_NullHttpConfiguration_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                CorsHttpConfigurationExtensions.SetCorsEngine(null, new CorsEngine());
            },
            "httpConfiguration");
        }

        [Fact]
        public void SetCorsEngine_NullCorsEngine_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                CorsHttpConfigurationExtensions.SetCorsEngine(new HttpConfiguration(), null);
            },
            "corsEngine");
        }

        [Fact]
        public void SetCorsPolicyProviderFactory_NullHttpConfiguration_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                CorsHttpConfigurationExtensions.SetCorsPolicyProviderFactory(null, new AttributeBasedPolicyProviderFactory());
            },
            "httpConfiguration");
        }

        [Fact]
        public void SetCorsPolicyProviderFactory_NullCorsEngine_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                CorsHttpConfigurationExtensions.SetCorsPolicyProviderFactory(new HttpConfiguration(), null);
            },
            "corsPolicyProviderFactory");
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/CorsHttpRequestMessageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Cors;
using Microsoft.TestCommon;

namespace System.Web.Http.Cors.Test
{
    public class CorsHttpRequestMessageExtensionsTest
    {
        [Fact]
        public void GetCorsRequestContext_NullRequestParam_Throws()
        {
            Assert.ThrowsArgumentNull(
                () => CorsHttpRequestMessageExtensions.GetCorsRequestContext(null),
                "request");
        }

        [Fact]
        public void GetCorsRequestContext_NotOrigin_ReturnsNull()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            CorsRequestContext result = request.GetCorsRequestContext();
            Assert.Null(result);
        }

        [Fact]
        public void GetCorsRequestContext_CachesTheContext()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "http://example.com/test");
            request.Headers.Add("Origin", "foo");
            request.Headers.Add("Host", "example.com");
            request.Headers.Add("Access-Control-Request-Method", "bar");

            CorsRequestContext result = request.GetCorsRequestContext();
            CorsRequestContext result2 = request.GetCorsRequestContext();

            Assert.Same(result, result2);
        }

        [Fact]
        public void GetCorsRequestContext_ReturnsHost()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "http://example.com/test");
            request.Headers.Add("Origin", "foo");
            request.Headers.Add("Host", "example.com");

            CorsRequestContext result = request.GetCorsRequestContext();

            Assert.Equal("example.com", result.Host);
        }

        [Fact]
        public void GetCorsRequestContext_ReturnsHttpMethod()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://example.com/test");
            request.Headers.Add("Origin", "foo");

            CorsRequestContext result = request.GetCorsRequestContext();

            Assert.Equal("OPTIONS", result.HttpMethod);
        }

        [Fact]
        public void GetCorsRequestContext_ReturnsOrigin()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "http://example.com/test");
            request.Headers.Add("Origin", "foo");

            CorsRequestContext result = request.GetCorsRequestContext();

            Assert.Equal("foo", result.Origin);
        }

        [Fact]
        public void GetCorsRequestContext_ReturnsRequestMethod()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "http://example.com/test");
            request.Headers.Add("Origin", "foo");
            request.Headers.Add("Access-Control-Request-Method", "bar");

            CorsRequestContext result = request.GetCorsRequestContext();

            Assert.Equal("bar", result.AccessControlRequestMethod);
        }

        [Fact]
        public void GetCorsRequestContext_RetunsEmptyRequestHeaders()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "http://example.com/test");
            request.Headers.Add("Origin", "foo");

            CorsRequestContext result = request.GetCorsRequestContext();

            Assert.Empty(result.AccessControlRequestHeaders);
        }

        [Fact]
        public void GetCorsRequestContext_RetunsRequestHeaders()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "http://example.com/test");
            request.Headers.Add("Origin", "foo");
            request.Headers.Add("Access-Control-Request-Headers", "foo, bar");

            CorsRequestContext result = request.GetCorsRequestContext();

            Assert.Equal(2, result.AccessControlRequestHeaders.Count);
            Assert.Contains("foo", result.AccessControlRequestHeaders);
            Assert.Contains("bar", result.AccessControlRequestHeaders);
        }

        [Fact]
        public void GetCorsRequestContext_RetunsRequestHeadersFromMultipleAccessControlRequestHeaders()
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put, "http://example.com/test");
            request.Headers.Add("Origin", "foo");
            request.Headers.Add("Access-Control-Request-Headers", "foo, bar");
            request.Headers.Add("Access-Control-Request-Headers", "extra,baz");

            CorsRequestContext result = request.GetCorsRequestContext();

            Assert.Equal(4, result.AccessControlRequestHeaders.Count);
            Assert.Contains("foo", result.AccessControlRequestHeaders);
            Assert.Contains("bar", result.AccessControlRequestHeaders);
            Assert.Contains("extra", result.AccessControlRequestHeaders);
            Assert.Contains("baz", result.AccessControlRequestHeaders);
        }

        [Fact]
        public void GetCorsRequestContext_ReturnsHttpRequestInThePropertiesCollection()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://example.com/test");
            request.Headers.Add("Origin", "foo");

            // Act 
            CorsRequestContext result = request.GetCorsRequestContext();

            // Assert
            object actualRequest;
            result.Properties.TryGetValue(typeof(HttpRequestMessage).FullName, out actualRequest);
            Assert.Equal(request, actualRequest);
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/CorsHttpResponseMessageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Web.Http.Cors;
using Microsoft.TestCommon;

namespace System.Web.Cors.Test.WebAPI
{
    public class CorsHttpResponseMessageExtensionsTest
    {
        [Fact]
        public void WriteCorsHeaders_NullResponse_Throws()
        {
            Assert.ThrowsArgumentNull(() =>
                System.Web.Http.Cors.CorsHttpResponseMessageExtensions.WriteCorsHeaders(null, new CorsResult()),
                "response");
        }

        [Fact]
        public void WriteCorsHeaders_NullCorsResult_Throws()
        {
            HttpResponseMessage response = new HttpResponseMessage();

            Assert.ThrowsArgumentNull(() =>
                response.WriteCorsHeaders(null),
                "corsResult");
        }

        [Fact]
        public void WriteCorsHeaders_EmptyCorsResult_EmptyHeaders()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            response.WriteCorsHeaders(new CorsResult());
            Assert.Empty(response.Headers);
        }

        [Fact]
        public void WriteCorsHeaders_WritesAllowMethods()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            CorsResult corsResult = new CorsResult();
            corsResult.AllowedMethods.Add("DELETE");
            corsResult.AllowedMethods.Add("PUT");

            response.WriteCorsHeaders(corsResult);
            HttpResponseHeaders headers = response.Headers;

            Assert.Single(headers);
            string[] allowMethods = headers.GetValues("Access-Control-Allow-Methods").FirstOrDefault().Split(',');
            Assert.Contains("DELETE", allowMethods);
            Assert.Contains("PUT", allowMethods);
        }

        [Fact]
        public void WriteCorsHeaders_WritesAllowExposedHeaders()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            CorsResult corsResult = new CorsResult();
            corsResult.AllowedExposedHeaders.Add("baz");

            response.WriteCorsHeaders(corsResult);
            HttpResponseHeaders headers = response.Headers;

            Assert.Single(headers);
            string[] exposedHeaders = headers.GetValues("Access-Control-Expose-Headers").FirstOrDefault().Split(',');
            Assert.Contains("baz", exposedHeaders);
        }

        [Fact]
        public void WriteCorsHeaders_WritesAllowHeaders()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            CorsResult corsResult = new CorsResult();
            corsResult.AllowedHeaders.Add("foo");
            corsResult.AllowedHeaders.Add("bar");

            response.WriteCorsHeaders(corsResult);
            HttpResponseHeaders headers = response.Headers;

            Assert.Single(headers);
            string[] allowHeaders = headers.GetValues("Access-Control-Allow-Headers").FirstOrDefault().Split(',');
            Assert.Contains("foo", allowHeaders);
            Assert.Contains("bar", allowHeaders);
        }

        [Fact]
        public void WriteCorsHeaders_WritesAllowCredentials()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            CorsResult corsResult = new CorsResult
            {
                SupportsCredentials = true
            };

            response.WriteCorsHeaders(corsResult);
            HttpResponseHeaders headers = response.Headers;

            Assert.Single(headers);
            Assert.Equal("true", headers.GetValues("Access-Control-Allow-Credentials").FirstOrDefault());
        }

        [Fact]
        public void WriteCorsHeaders_WritesAllowOrigin()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            CorsResult corsResult = new CorsResult
            {
                AllowedOrigin = "*"
            };

            response.WriteCorsHeaders(corsResult);
            HttpResponseHeaders headers = response.Headers;

            Assert.Single(headers);
            Assert.Equal("*", headers.GetValues("Access-Control-Allow-Origin").FirstOrDefault());
        }

        [Fact]
        public void WriteCorsHeaders_WritesPreflightMaxAge()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            CorsResult corsResult = new CorsResult
            {
                PreflightMaxAge = 10
            };

            response.WriteCorsHeaders(corsResult);
            HttpResponseHeaders headers = response.Headers;

            Assert.Single(headers);
            Assert.Equal("10", headers.GetValues("Access-Control-Max-Age").FirstOrDefault());
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/CorsMessageHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using Microsoft.TestCommon;

namespace System.Web.Http.Cors
{
    public class CorsMessageHandlerTest
    {
        [Fact]
        public void Constructor_NullConfig_Throws()
        {
            Assert.ThrowsArgumentNull(() => new CorsMessageHandler(null), "httpConfiguration");
        }

        [Fact]
        public async Task SendAsync_DoesNotAddHeaders_WhenOriginIsMissing()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            HttpServer server = new HttpServer(config);
            CorsMessageHandler corsHandler = new CorsMessageHandler(config);
            corsHandler.InnerHandler = server;
            HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/sample");

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Empty(response.Headers);
        }

        [Theory]
        [InlineData("GET", "*")]
        [InlineData("DELETE", "*")]
        [InlineData("HEAD", "http://example.com")]
        public async Task SendAsync_ReturnsAllowAOrigin(string httpMethod, string expectedOrigin)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            HttpServer server = new HttpServer(config);
            CorsMessageHandler corsHandler = new CorsMessageHandler(config);
            corsHandler.InnerHandler = server;
            HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler);
            HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/sample");
            request.Headers.Add(CorsConstants.Origin, "http://example.com");

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);
            string origin = response.Headers.GetValues("Access-Control-Allow-Origin").FirstOrDefault();

            Assert.Equal(expectedOrigin, origin);
        }

        [Theory]
        [InlineData("DELETE", "*", "foo,bar")]
        [InlineData("PUT", "http://localhost", "content-type,custom")]
        public async Task SendAsync_Preflight_ReturnsAllowMethodsAndAllowHeaders(string requestedMethod, string expectedOrigin, string requestedHeaders)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            HttpServer server = new HttpServer(config);
            CorsMessageHandler corsHandler = new CorsMessageHandler(config);
            corsHandler.InnerHandler = server;
            HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.SetConfiguration(config);
            request.Headers.Add(CorsConstants.Origin, "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, requestedMethod);
            request.Headers.Add(CorsConstants.AccessControlRequestHeaders, requestedHeaders);

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);
            string origin = response.Headers.GetValues(CorsConstants.AccessControlAllowOrigin).FirstOrDefault();
            string allowMethod = response.Headers.GetValues(CorsConstants.AccessControlAllowMethods).FirstOrDefault();
            string[] allowHeaders = response.Headers.GetValues(CorsConstants.AccessControlAllowHeaders).FirstOrDefault().Split(',');
            string[] requestedHeaderArray = requestedHeaders.Split(',');

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(expectedOrigin, origin);
            Assert.Equal(requestedMethod, allowMethod);
            foreach (string requestedHeader in requestedHeaderArray)
            {
                Assert.Contains(requestedHeader, allowHeaders);
            }
        }

        [Fact]
        public async Task SendAsync_Preflight_ReturnsOriginalResponse_WhenNoCorsPolicyProviderIsFound()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            config.MessageHandlers.Add(new CorsMessageHandler(config));
            HttpServer server = new HttpServer(config);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/default");
            request.Headers.Add(CorsConstants.Origin, "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "GET");

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode);
        }

        [Fact]
        public async Task SendAsync_Preflight_ReturnsBadRequest_WhenOriginIsNotAllowed()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            config.MessageHandlers.Add(new CorsMessageHandler(config));
            HttpServer server = new HttpServer(config);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/default");
            request.Headers.Add(CorsConstants.Origin, "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "POST");

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Equal("{\"Message\":\"The origin 'http://localhost' is not allowed.\"}", await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task SendAsync_Preflight_ReturnsSoftNotFound_WhenNoRouteMatches()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "foo");
            config.MessageHandlers.Add(new CorsMessageHandler(config));
            HttpServer server = new HttpServer(config);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/nomatch");
            request.Headers.Add(CorsConstants.Origin, "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "POST");

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            bool noRouteMatched = Assert.IsType<bool>(request.Properties[HttpPropertyKeys.NoRouteMatched]);
            Assert.True(noRouteMatched);
            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
            Assert.Equal("{\"Message\":\"No HTTP resource was found that matches the request URI 'http://localhost/nomatch'.\"}", await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task SendAsync_Preflight_ReturnsSoftNotFound_WhenControllerSelectionFails()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            config.MessageHandlers.Add(new CorsMessageHandler(config));
            HttpServer server = new HttpServer(config);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/nomatch");
            request.Headers.Add(CorsConstants.Origin, "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "POST");

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
        }

        [Fact]
        public async Task SendAsync_HandlesExceptions_ThrownDuringPreflight()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            HttpServer server = new HttpServer(config);
            CorsMessageHandler corsHandler = new CorsMessageHandler(config);
            corsHandler.InnerHandler = server;
            HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.SetConfiguration(config);
            request.Headers.Add(CorsConstants.Origin, "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "RandomMethod");

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode);
        }

        [Fact]
        public async Task SendAsync_Preflight_RethrowsExceptions_WhenRethrowFlagIsTrue()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            HttpServer server = new HttpServer(config);
            CorsMessageHandler corsHandler = new CorsMessageHandler(config, true);
            corsHandler.InnerHandler = server;
            HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Options, "http://localhost/sample");
            request.SetConfiguration(config);
            request.Headers.Add(CorsConstants.Origin, "http://localhost");
            request.Headers.Add(CorsConstants.AccessControlRequestMethod, "RandomMethod");

            await Assert.ThrowsAsync<HttpResponseException>(() => invoker.SendAsync(request, CancellationToken.None));
        }

        [Fact]
        public async Task SendAsync_RethrowsExceptions_WhenRethrowFlagIsTrue()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "{controller}");
            config.Services.Replace(typeof(IExceptionHandler), new PassthroughExceptionHandler());
            HttpServer server = new HttpServer(config);
            CorsMessageHandler corsHandler = new CorsMessageHandler(config, true);
            corsHandler.InnerHandler = server;
            HttpMessageInvoker invoker = new HttpMessageInvoker(corsHandler);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/throwing");
            request.SetConfiguration(config);
            request.Headers.Add(CorsConstants.Origin, "http://localhost");

            await Assert.ThrowsAsync<Exception>(() => invoker.SendAsync(request, CancellationToken.None));
        }

        [Fact]
        public Task HandleCorsRequestAsync_NullConfig_Throws()
        {
            CorsMessageHandler corsHandler = new CorsMessageHandler(new HttpConfiguration());
            return Assert.ThrowsArgumentNullAsync(
                () => corsHandler.HandleCorsRequestAsync(null, new CorsRequestContext(), CancellationToken.None),
                "request");
        }

        [Fact]
        public Task HandleCorsRequestAsync_NullContext_Throws()
        {
            CorsMessageHandler corsHandler = new CorsMessageHandler(new HttpConfiguration());
            return Assert.ThrowsArgumentNullAsync(
                () => corsHandler.HandleCorsRequestAsync(new HttpRequestMessage(), null, CancellationToken.None),
                "corsRequestContext");
        }

        [Fact]
        public async Task HandleCorsPreflightRequestAsync_ReturnsBadRequestWhenAccessControlRequestMethodIsInvalid()
        {
            CorsMessageHandler corsHandler = new CorsMessageHandler(new HttpConfiguration());
            HttpResponseMessage response = await corsHandler.HandleCorsPreflightRequestAsync(new HttpRequestMessage(),
                new CorsRequestContext
                {
                    AccessControlRequestMethod = "Get-http://localhost"
                },
                CancellationToken.None);

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Equal("The \"Access-Control-Request-Method\" header value 'Get-http://localhost' is invalid.", (await response.Content.ReadAsAsync<HttpError>()).Message);
        }

        [Theory]
        [InlineData("")]
        [InlineData(null)]
        public async Task HandleCorsPreflightRequestAsync_ReturnsBadRequestWhenAccessControlRequestMethodIsNullOrEmpty(string accessControlRequestMethod)
        {
            CorsMessageHandler corsHandler = new CorsMessageHandler(new HttpConfiguration());
            HttpResponseMessage response = await corsHandler.HandleCorsPreflightRequestAsync(new HttpRequestMessage(),
                new CorsRequestContext
                {
                    AccessControlRequestMethod = accessControlRequestMethod
                },
                CancellationToken.None);

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Equal("The \"Access-Control-Request-Method\" header value cannot be null or empty.", (await response.Content.ReadAsAsync<HttpError>()).Message);
        }

        [Fact]
        public Task HandleCorsPreflightRequestAsync_NullContext_Throws()
        {
            CorsMessageHandler corsHandler = new CorsMessageHandler(new HttpConfiguration());
            return Assert.ThrowsArgumentNullAsync(
                () => corsHandler.HandleCorsPreflightRequestAsync(new HttpRequestMessage(), null, CancellationToken.None),
                "corsRequestContext");
        }

        private class PassthroughExceptionHandler : IExceptionHandler
        {
            public Task HandleAsync(ExceptionHandlerContext context, CancellationToken cancellationToken)
            {
                throw context.Exception;
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/DisableCorsAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;
using Microsoft.TestCommon;

namespace System.Web.Http.Cors.Test
{
    public class DisableCorsAttributeTest
    {
        [Fact]
        public async Task GetCorsPolicyAsync_ReturnsNull()
        {
            DisableCorsAttribute disableCors = new DisableCorsAttribute();
            CorsPolicy corsPolicy = await disableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Null(corsPolicy);
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/EnableCorsAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;
using Microsoft.TestCommon;

namespace System.Web.Http.Cors.Test
{
    public class EnableCorsAttributeTest
    {
        [Fact]
        public void Default_Constructor()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*");

            Assert.False(enableCors.SupportsCredentials);
            Assert.Empty(enableCors.ExposedHeaders);
            Assert.Empty(enableCors.Headers);
            Assert.Empty(enableCors.Methods);
            Assert.Empty(enableCors.Origins);
            Assert.Equal(-1, enableCors.PreflightMaxAge);
        }

        [Theory]
        [InlineData(null)]
        [InlineData("")]
        public void SettingNullOrEmptyOrigins_Throws(string origins)
        {
            Assert.ThrowsArgument(() =>
            {
                new EnableCorsAttribute(origins: origins, headers: "*", methods: "*");
            },
            "origins",
            "Value cannot be null or an empty string.");
        }

        [Fact]
        public async Task GetCorsPolicyAsync_DefaultPolicyValues()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*");

            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.True(corsPolicy.AllowAnyHeader);
            Assert.True(corsPolicy.AllowAnyMethod);
            Assert.True(corsPolicy.AllowAnyOrigin);
            Assert.False(corsPolicy.SupportsCredentials);
            Assert.Empty(corsPolicy.ExposedHeaders);
            Assert.Empty(corsPolicy.Headers);
            Assert.Empty(corsPolicy.Methods);
            Assert.Empty(corsPolicy.Origins);
            Assert.Null(corsPolicy.PreflightMaxAge);
        }

        [Fact]
        public async Task GetCorsPolicyAsync_RetunsExpectedSupportsCredentials()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*")
            {
                SupportsCredentials = true
            };

            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.True(corsPolicy.SupportsCredentials);
        }

        [Fact]
        public async Task GetCorsPolicyAsync_RetunsExpectedPreflightMaxAge()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*")
            {
                PreflightMaxAge = 20
            };

            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(20, corsPolicy.PreflightMaxAge);
        }

        [Theory]
        [InlineData("foo", new[] { "foo" })]
        [InlineData("foo ", new[] { "foo" })]
        [InlineData("foo,", new[] { "foo" })]
        [InlineData("foo,bar", new[] { "foo", "bar" })]
        [InlineData("foo, bar", new[] { "foo", "bar" })]
        [InlineData("foo,bar,", new[] { "foo", "bar" })]
        public async Task GetCorsPolicyAsync_RetunsExpectedExposeHeaders(string exposedHeaders, string[] expectedResults)
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*", exposedHeaders: exposedHeaders);

            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(new List<string>(expectedResults), corsPolicy.ExposedHeaders);
        }

        [Theory]
        [InlineData("Accept", new[] { "Accept" })]
        [InlineData("Accept ", new[] { "Accept" })]
        [InlineData("Accept,", new[] { "Accept" })]
        [InlineData("Accept,Content-Type", new[] { "Accept", "Content-Type" })]
        [InlineData("Accept, Content-Type", new[] { "Accept", "Content-Type" })]
        [InlineData("Accept,Content-Type,", new[] { "Accept", "Content-Type" })]
        public async Task GetCorsPolicyAsync_RetunsExpectedHeaders(string headers, string[] expectedResults)
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: headers, methods: "*");

            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(new List<string>(expectedResults), corsPolicy.Headers);
        }

        [Theory]
        [InlineData("Get", new[] { "Get" })]
        [InlineData("Get ", new[] { "Get" })]
        [InlineData("Get,", new[] { "Get" })]
        [InlineData("Get,Delete", new[] { "Get", "Delete" })]
        [InlineData("Get, Delete", new[] { "Get", "Delete" })]
        [InlineData("Get,Delete,", new[] { "Get", "Delete" })]
        public async Task GetCorsPolicyAsync_RetunsExpectedMethods(string methods, string[] expectedResults)
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: methods);

            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(new List<string>(expectedResults), corsPolicy.Methods);
        }

        [Theory]
        [InlineData("http://example.com", new[] { "http://example.com" })]
        [InlineData("http://example.com ", new[] { "http://example.com" })]
        [InlineData("http://example.com,", new[] { "http://example.com" })]
        [InlineData("http://example.com,http://localhost:8080", new[] { "http://example.com", "http://localhost:8080" })]
        [InlineData("http://example.com, http://localhost:8080", new[] { "http://example.com", "http://localhost:8080" })]
        [InlineData("http://example.com,http://localhost:8080,", new[] { "http://example.com", "http://localhost:8080" })]
        public async Task GetCorsPolicyAsync_RetunsExpectedOrigins(string origins, string[] expectedResults)
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: origins, headers: "*", methods: "*");

            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(new List<string>(expectedResults), corsPolicy.Origins);
        }

        [Theory]
        [InlineData("foo", "The specified policy origin 'foo' is invalid. It must be correctly formed with the scheme, the host, and optionally, the port.")]
        [InlineData("://example.com", "The specified policy origin '://example.com' is invalid. It must be correctly formed with the scheme, the host, and optionally, the port.")]
        [InlineData("http://example.com/", "The specified policy origin 'http://example.com/' is invalid. It cannot end with a forward slash.")]
        [InlineData("http://example.com#fragment", "The specified policy origin 'http://example.com#fragment' is invalid. It must not contain a path, query, or fragment.")]
        [InlineData("http://example.com/path", "The specified policy origin 'http://example.com/path' is invalid. It must not contain a path, query, or fragment.")]
        [InlineData("http://example.com?query=foo", "The specified policy origin 'http://example.com?query=foo' is invalid. It must not contain a path, query, or fragment.")]
        public Task GetCorsPolicyAsync_InvalidOrigin_Throws(string origin, string expectedErrorMessage)
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: origin, headers: "*", methods: "*");

            return Assert.ThrowsAsync<InvalidOperationException>(
                () => enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None),
                expectedErrorMessage);
        }

        [Theory]
        [InlineData("", "The specified policy origin cannot be null or empty.")]
        [InlineData(null, "The specified policy origin cannot be null or empty.")]
        public Task GetCorsPolicyAsync_NullEmptyOrigin_Throws(string origin, string expectedErrorMessage)
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "http://localhost", headers: "*", methods: "*");
            enableCors.Origins.Add(origin);

            return Assert.ThrowsAsync<InvalidOperationException>(
                () => enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None),
                expectedErrorMessage);
        }

        [Fact]
        public async Task AllowAnyHeader_IsFalse_WhenHeadersPropertyIsSet()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "foo", methods: "*");
            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.False(corsPolicy.AllowAnyHeader);
        }

        [Fact]
        public async Task AllowAnyOrigin_IsFalse_WhenOriginsPropertyIsSet()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "http://example.com", headers: "*", methods: "*");
            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.False(corsPolicy.AllowAnyOrigin);
        }

        [Fact]
        public async Task AllowAnyMethod_IsFalse_WhenMethodsPropertyIsSet()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "GET");
            CorsPolicy corsPolicy = await enableCors.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.False(corsPolicy.AllowAnyMethod);
        }

        [Fact]
        public void SettingNegativePreflightMaxAge_Throws()
        {
            EnableCorsAttribute enableCors = new EnableCorsAttribute(origins: "*", headers: "*", methods: "*");
            Assert.ThrowsArgumentOutOfRange(() =>
            {
                enableCors.PreflightMaxAge = -2;
            },
            "value",
            "PreflightMaxAge must be greater than or equal to 0.");
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/HttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;

namespace System.Web.Http.Cors
{
    internal static class HttpRequestMessageExtensions
    {
        public static void SetActionDescriptor(this HttpRequestMessage request, HttpActionDescriptor actionDescriptor)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            request.Properties[HttpPropertyKeys.HttpActionDescriptorKey] = actionDescriptor;
        }
    }
}


================================================
FILE: test/System.Web.Http.Cors.Test/System.Web.Http.Cors.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{1E89A3E9-0A7F-418F-B4BE-6E38A6315373}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.Cors</RootNamespace>
    <AssemblyName>System.Web.Http.Cors.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.XML" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Cors\System.Web.Cors.csproj">
      <Project>{43c1b979-d593-4a32-bb3a-4316f1c66d66}</Project>
      <Name>System.Web.Cors</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.Cors\System.Web.Http.Cors.csproj">
      <Project>{25def6f6-7f99-4eb7-91ed-5181a346afe1}</Project>
      <Name>System.Web.Http.Cors</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Folder Include="Properties\" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AttributeBasedPolicyProviderFactoryTest.cs" />
    <Compile Include="Controllers\ExternalActionSelectorAttribute.cs" />
    <Compile Include="Controllers\PerControllerConfigController.cs" />
    <Compile Include="Controllers\SampleController.cs" />
    <Compile Include="Controllers\DefaultController.cs" />
    <Compile Include="Controllers\ThrowingController.cs" />
    <Compile Include="CorsMessageHandlerTest.cs" />
    <Compile Include="DisableCorsAttributeTest.cs" />
    <Compile Include="EnableCorsAttributeTest.cs" />
    <Compile Include="CorsHttpConfigurationExtensionsTest.cs" />
    <Compile Include="CorsHttpRequestMessageExtensionsTest.cs" />
    <Compile Include="CorsHttpResponseMessageExtensionsTest.cs" />
    <Compile Include="HttpRequestMessageExtensions.cs" />
    <Compile Include="Tracing\CorsEngineTracerTest.cs" />
    <Compile Include="Tracing\CorsPolicyProviderFactoryTracerTest.cs" />
    <Compile Include="Tracing\CorsPolicyProviderTracerTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Http.Cors.Test/Tracing/CorsEngineTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Cors;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Cors.Tracing
{
    public class CorsEngineTracerTest
    {
        [Fact]
        public void EvaluatePolicy_CallsInner()
        {
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            Mock<ICorsEngine> corsEngineMock = new Mock<ICorsEngine>();
            bool innerIsCalled = false;
            corsEngineMock.Setup(engine => engine.EvaluatePolicy(It.IsAny<CorsRequestContext>(), It.IsAny<CorsPolicy>())).Returns(() =>
            {
                innerIsCalled = true;
                return new CorsResult();
            });
            CorsEngineTracer tracer = new CorsEngineTracer(corsEngineMock.Object, traceWriterMock.Object);

            tracer.EvaluatePolicy(new CorsRequestContext(), new CorsPolicy());

            Assert.True(innerIsCalled);
        }

        [Fact]
        public void EvaluatePolicy_EmitTraces()
        {
            TraceRecord beginTrace = null;
            TraceRecord endTrace = null;
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            traceWriterMock
                .Setup(t => t.Trace(It.IsAny<HttpRequestMessage>(), It.IsAny<string>(), It.IsAny<TraceLevel>(), It.IsAny<Action<TraceRecord>>()))
                .Callback<HttpRequestMessage, string, TraceLevel, Action<TraceRecord>>((request, category, level, traceAction) =>
                {
                    TraceRecord traceRecord = new TraceRecord(request, category, level);
                    traceAction(traceRecord);
                    if (traceRecord.Kind == TraceKind.Begin)
                    {
                        beginTrace = traceRecord;
                    }
                    else if (traceRecord.Kind == TraceKind.End)
                    {
                        endTrace = traceRecord;
                    }
                });
            Mock<ICorsEngine> corsEngineMock = new Mock<ICorsEngine>();
            corsEngineMock
                .Setup(engine => engine.EvaluatePolicy(It.IsAny<CorsRequestContext>(), It.IsAny<CorsPolicy>()))
                .Returns(new CorsResult());
            CorsEngineTracer tracer = new CorsEngineTracer(corsEngineMock.Object, traceWriterMock.Object);

            tracer.EvaluatePolicy(new CorsRequestContext(), new CorsPolicy());

            Assert.NotNull(beginTrace);
            Assert.Equal(TraceCategories.CorsCategory, beginTrace.Category);
            Assert.Equal(TraceLevel.Info, beginTrace.Level);
            Assert.Equal("EvaluatePolicy", beginTrace.Operation);

            Assert.NotNull(endTrace);
            Assert.Equal(TraceCategories.CorsCategory, endTrace.Category);
            Assert.Equal(TraceLevel.Info, endTrace.Level);
            Assert.Equal("EvaluatePolicy", endTrace.Operation);
            Assert.Equal(
                @"CorsResult returned: 'IsValid: True, AllowCredentials: False, PreflightMaxAge: null, AllowOrigin: , AllowExposedHeaders: {}, AllowHeaders: {}, AllowMethods: {}, ErrorMessages: {}'",
                endTrace.Message);
        }

        [Fact]
        public void EvaluatePolicy_Trace_ContainsHttpRequest()
        {
            // Arrange
            HttpRequestMessage httpRequest = new HttpRequestMessage(HttpMethod.Options, "http://example.com/test");
            httpRequest.Headers.Add("Origin", "foo");
            CorsRequestContext corsRequestContext = httpRequest.GetCorsRequestContext();

            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            traceWriterMock
                .Setup(t => t.Trace(httpRequest, It.IsAny<string>(), It.IsAny<TraceLevel>(), It.IsAny<Action<TraceRecord>>()))
                .Verifiable();

            Mock<ICorsEngine> corsEngineMock = new Mock<ICorsEngine>();
            corsEngineMock
                .Setup(engine => engine.EvaluatePolicy(corsRequestContext, It.IsAny<CorsPolicy>()))
                .Returns(new CorsResult());

            CorsEngineTracer tracer = new CorsEngineTracer(corsEngineMock.Object, traceWriterMock.Object);

            // Act
            tracer.EvaluatePolicy(corsRequestContext, new CorsPolicy());

            // Assert 
            traceWriterMock.Verify();
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/Tracing/CorsPolicyProviderFactoryTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Cors;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Cors.Tracing
{
    public class CorsPolicyProviderFactoryTracerTest
    {
        [Fact]
        public void GetCorsPolicyProvider_CallsInner()
        {
            bool innerIsCalled = false;
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            Mock<ICorsPolicyProviderFactory> policyProviderFactoryMock = new Mock<ICorsPolicyProviderFactory>();
            policyProviderFactoryMock
                .Setup(f => f.GetCorsPolicyProvider(It.IsAny<HttpRequestMessage>()))
                .Returns(() =>
                {
                    innerIsCalled = true;
                    return new Mock<ICorsPolicyProvider>().Object;
                });
            CorsPolicyProviderFactoryTracer tracer = new CorsPolicyProviderFactoryTracer(policyProviderFactoryMock.Object, traceWriterMock.Object);

            tracer.GetCorsPolicyProvider(new HttpRequestMessage());

            Assert.True(innerIsCalled);
        }

        [Fact]
        public void GetCorsPolicyProvider_ReturnsCorsPolicyProviderTracer()
        {
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            ICorsPolicyProvider expectedPolicyProvider = new Mock<ICorsPolicyProvider>().Object;
            Mock<ICorsPolicyProviderFactory> policyProviderFactoryMock = new Mock<ICorsPolicyProviderFactory>();
            policyProviderFactoryMock
                .Setup(f => f.GetCorsPolicyProvider(It.IsAny<HttpRequestMessage>()))
                .Returns(expectedPolicyProvider);
            CorsPolicyProviderFactoryTracer tracer = new CorsPolicyProviderFactoryTracer(policyProviderFactoryMock.Object, traceWriterMock.Object);

            ICorsPolicyProvider policyProvider = tracer.GetCorsPolicyProvider(new HttpRequestMessage());

            Assert.IsType<CorsPolicyProviderTracer>(policyProvider);
        }

        [Fact]
        public void GetCorsPolicyProvider_ReturnsNullWhenInnerReturnsNull()
        {
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            ICorsPolicyProvider expectedPolicyProvider = new Mock<ICorsPolicyProvider>().Object;
            Mock<ICorsPolicyProviderFactory> policyProviderFactoryMock = new Mock<ICorsPolicyProviderFactory>();
            policyProviderFactoryMock
                .Setup(f => f.GetCorsPolicyProvider(It.IsAny<HttpRequestMessage>()))
                .Returns((ICorsPolicyProvider)null);
            CorsPolicyProviderFactoryTracer tracer = new CorsPolicyProviderFactoryTracer(policyProviderFactoryMock.Object, traceWriterMock.Object);

            ICorsPolicyProvider policyProvider = tracer.GetCorsPolicyProvider(new HttpRequestMessage());

            Assert.Null(policyProvider);
        }

        [Fact]
        public void GetCorsPolicyProvider_EmitTraces()
        {
            TraceRecord beginTrace = null;
            TraceRecord endTrace = null;
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            traceWriterMock
                .Setup(t => t.Trace(It.IsAny<HttpRequestMessage>(), It.IsAny<string>(), It.IsAny<TraceLevel>(), It.IsAny<Action<TraceRecord>>()))
                .Callback<HttpRequestMessage, string, TraceLevel, Action<TraceRecord>>((request, category, level, traceAction) =>
                {
                    TraceRecord traceRecord = new TraceRecord(request, category, level);
                    traceAction(traceRecord);
                    if (traceRecord.Kind == TraceKind.Begin)
                    {
                        beginTrace = traceRecord;
                    }
                    else if (traceRecord.Kind == TraceKind.End)
                    {
                        endTrace = traceRecord;
                    }
                });
            Mock<ICorsPolicyProviderFactory> policyProviderFactoryMock = new Mock<ICorsPolicyProviderFactory>();
            policyProviderFactoryMock
                .Setup(f => f.GetCorsPolicyProvider(It.IsAny<HttpRequestMessage>()))
                .Returns(new EnableCorsAttribute(origins: "*", headers: "*", methods: "*"));
            CorsPolicyProviderFactoryTracer tracer = new CorsPolicyProviderFactoryTracer(policyProviderFactoryMock.Object, traceWriterMock.Object);
            HttpRequestMessage requestMessage = new HttpRequestMessage();
            requestMessage.Method = HttpMethod.Get;
            requestMessage.Headers.Add(CorsConstants.Origin, "http://example.com");

            tracer.GetCorsPolicyProvider(requestMessage);

            Assert.NotNull(beginTrace);
            Assert.Equal(TraceCategories.CorsCategory, beginTrace.Category);
            Assert.Equal(TraceLevel.Info, beginTrace.Level);
            Assert.Equal("GetCorsPolicyProvider", beginTrace.Operation);
            Assert.Equal(
                @"CorsRequestContext: 'Origin: http://example.com, HttpMethod: GET, IsPreflight: False, Host: , AccessControlRequestMethod: null, RequestUri: , AccessControlRequestHeaders: {}'",
                beginTrace.Message);

            Assert.NotNull(endTrace);
            Assert.Equal(TraceCategories.CorsCategory, endTrace.Category);
            Assert.Equal(TraceLevel.Info, endTrace.Level);
            Assert.Equal("GetCorsPolicyProvider", endTrace.Operation);
            Assert.Equal(
                @"CorsPolicyProvider selected: 'System.Web.Http.Cors.EnableCorsAttribute'",
                endTrace.Message);
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/Tracing/CorsPolicyProviderTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Cors;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Cors.Tracing
{
    public class CorsPolicyProviderTracerTest
    {
        [Fact]
        public async Task GetCorsPolicyAsync_CallsInner()
        {
            bool innerIsCalled = false;
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            Mock<ICorsPolicyProvider> policyProviderMock = new Mock<ICorsPolicyProvider>();
            policyProviderMock
                .Setup(f => f.GetCorsPolicyAsync(It.IsAny<HttpRequestMessage>(), CancellationToken.None))
                .Returns(() =>
                {
                    innerIsCalled = true;
                    return Task.FromResult(new CorsPolicy());
                });
            CorsPolicyProviderTracer tracer = new CorsPolicyProviderTracer(policyProviderMock.Object, traceWriterMock.Object);

            await tracer.GetCorsPolicyAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.True(innerIsCalled);
        }

        [Fact]
        public async Task GetCorsPolicyAsync_EmitTraces()
        {
            TraceRecord beginTrace = null;
            TraceRecord endTrace = null;
            Mock<ITraceWriter> traceWriterMock = new Mock<ITraceWriter>();
            traceWriterMock
                .Setup(t => t.Trace(It.IsAny<HttpRequestMessage>(), It.IsAny<string>(), It.IsAny<TraceLevel>(), It.IsAny<Action<TraceRecord>>()))
                .Callback<HttpRequestMessage, string, TraceLevel, Action<TraceRecord>>((request, category, level, traceAction) =>
                {
                    TraceRecord traceRecord = new TraceRecord(request, category, level);
                    traceAction(traceRecord);
                    if (traceRecord.Kind == TraceKind.Begin)
                    {
                        beginTrace = traceRecord;
                    }
                    else if (traceRecord.Kind == TraceKind.End)
                    {
                        endTrace = traceRecord;
                    }
                });
            CorsPolicyProviderTracer tracer = new CorsPolicyProviderTracer(new EnableCorsAttribute(origins: "*", headers: "*", methods: "*"), traceWriterMock.Object);
            HttpRequestMessage requestMessage = new HttpRequestMessage();
            requestMessage.Method = HttpMethod.Get;
            requestMessage.Headers.Add(CorsConstants.Origin, "http://example.com");

            await tracer.GetCorsPolicyAsync(requestMessage, CancellationToken.None);

            Assert.NotNull(beginTrace);
            Assert.Equal(TraceCategories.CorsCategory, beginTrace.Category);
            Assert.Equal(TraceLevel.Info, beginTrace.Level);
            Assert.Equal("GetCorsPolicyAsync", beginTrace.Operation);
            Assert.Equal(
                @"CorsRequestContext: 'Origin: http://example.com, HttpMethod: GET, IsPreflight: False, Host: , AccessControlRequestMethod: null, RequestUri: , AccessControlRequestHeaders: {}'",
                beginTrace.Message);

            Assert.NotNull(endTrace);
            Assert.Equal(TraceCategories.CorsCategory, endTrace.Category);
            Assert.Equal(TraceLevel.Info, endTrace.Level);
            Assert.Equal("GetCorsPolicyAsync", endTrace.Operation);
            Assert.Equal(
                @"CorsPolicy selected: 'AllowAnyHeader: True, AllowAnyMethod: True, AllowAnyOrigin: True, PreflightMaxAge: null, SupportsCredentials: False, Origins: {}, Methods: {}, Headers: {}, ExposedHeaders: {}'",
                endTrace.Message);
        }
    }
}

================================================
FILE: test/System.Web.Http.Cors.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/ApiExplorerSettingsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using Microsoft.TestCommon;

namespace System.Web.Http.ApiExplorer
{
    public class ApiExplorerSettingsTest
    {
        public static IEnumerable<object[]> HiddenController_DoesNotShowUpOnDescription_PropertyData
        {
            get
            {
                object controllerType = typeof(HiddenController);
                object expectedApiDescriptions = new List<object>();
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("HiddenController_DoesNotShowUpOnDescription_PropertyData")]
        public void HiddenController_DoesNotShowUpOnDescription(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        public static IEnumerable<object[]> HiddenAction_DoesNotShowUpOnDescription_PropertyData
        {
            get
            {
                object controllerType = typeof(HiddenActionController);
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "HiddenAction/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("HiddenAction_DoesNotShowUpOnDescription_PropertyData")]
        public void HiddenAction_DoesNotShowUpOnDescription(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/AttributeRoutesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http;
using System.Security.Cryptography;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.ApiExplorer
{
    public class AttributeRoutesTest
    {
        public static IEnumerable<object[]> VerifyDescription_OnAttributeRoutes_PropertyData
        {
            get
            {
                object controllerType;
                object expectedApiDescriptions;

                controllerType = typeof(MixedController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Post, RelativePath = "attribute/mixed", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(AttributedController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "controller/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "controller/{name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "controller/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "controller/{id}?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "optional/{opt1}/{opt2}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "optionalwconstraint/{opt}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "default/{default1}/{default2}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "wildcard/{wildcard}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "multiverb", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "multiverb", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "multi1", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "multi2", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(PrefixedController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "prefix", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "prefix", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "prefix/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(DefaultRouteController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "prefix2/defaultroute/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "prefix2", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "prefix2/defaultrouteoverride/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(RpcController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/default2/getallcustomers1", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/default2/getallcustomers2", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/resource/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(PartlyResourcePartlyRpcController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "partial/doop1", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "partial/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(OptionalController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "apioptional", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "apioptional/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(OverloadController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "apioverload/{name}?age={age}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "apioverload/{id}?score={score}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(BaseClassController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "baseclass?id={id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(BaseClassPrefixController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "baseclassprefix", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "baseclassprefix/base/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(SubClassRouteController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "subclassroute", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "subclassroute?id={id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "subclassroute?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("VerifyDescription_OnAttributeRoutes_PropertyData")]
        public void VerifyDescription_OnAttributeRoutes(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            config.EnsureInitialized();
            
            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        public static IEnumerable<object[]> VerifyDescription_OnMixedRoutes_PropertyData
        {
            get
            {
                object controllerType;
                object expectedApiDescriptions;

                controllerType = typeof(MixedController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/Mixed?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "attribute/mixed", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "api/Mixed/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(PrefixedController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "prefix", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "prefix", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "prefix/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "api/prefixed", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 0},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(SubClassController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "subclass?id={id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "subclass?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(SubClassNoRouteController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/subclassnoroute/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "api/subclassnoroute?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(SubClassNoPrefixController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/subclassnoprefix", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/subclassnoprefix/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "api/subclassnoprefix?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(SubClassPrefixController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/subclassprefix", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "api/subclassprefix/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "subclassprefix?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("VerifyDescription_OnMixedRoutes_PropertyData")]
        public void VerifyDescription_OnMixedRoutes(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            config.Routes.MapHttpRoute("Default", "api/{controller}/{id}", new { id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            config.EnsureInitialized();

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        [Fact]
        public void NoDescription_OnAttributeRoutedAction_UsingStandardControllerRoute()
        {
            HttpConfiguration config = new HttpConfiguration();
            var route = config.Routes.MapHttpRoute("Default", "api/someController", new { controller = "DefaultRoute" });
            config.MapHttpAttributeRoutes();

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(DefaultRouteController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            config.EnsureInitialized();

            IApiExplorer explorer = config.Services.GetApiExplorer();
            Assert.True(explorer.ApiDescriptions.All(d => d.Route != route));
        }

        [Fact]
        public void NoDescription_OnAttributeRoutedAction_UsingStandardRoute()
        {
            HttpConfiguration config = new HttpConfiguration();
            var route = config.Routes.MapHttpRoute("Default", "api/someAction/{id}", new { controller = "Attributed", action = "Get" });
            config.MapHttpAttributeRoutes();

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(AttributedController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            config.EnsureInitialized();

            IApiExplorer explorer = config.Services.GetApiExplorer();
            Assert.True(explorer.ApiDescriptions.All(d => d.Route != route));
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/AmbiguousActionController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ApiExplorer
{
    public class AmbiguousActionController : ApiController
    {
        // The actions GetItem and Get and potentially be ambiguous under
        // route "api/{controller}" because they're both GET api/AmbiguousAction

        public void GetItem()
        {
        }

        public void Get()
        {
        }

        public bool Post(int id)
        {
            return true;
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/AttributeRouteControllers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ApiExplorer
{
    public class MixedController : ApiController
    {
        public string Get(string name, int series)
        {
            return null;
        }

        [Route("attribute/mixed")]
        public string Post([FromBody]string values)
        {
            return values;
        }

        [HttpDelete]
        public void RemoveItem(int id)
        {
        }
    }

    public class AttributedController : ApiController
    {
        [Route("controller/{id:int}")]
        public string Get(int id)
        {
            return "Get" + id;
        }

        [Route("controller/{name}")]
        public string GetByName(string name)
        {
            return "GetByName" + name;
        }

        [Route("controller/{id}")]
        public string Put(string id)
        {
            return "Put" + id;
        }

        [Route("controller/{id}")]
        public string Put(string id, string name)
        {
            return "Put" + id + name;
        }

        [HttpGet]
        [Route("optional/{opt1?}/{opt2?}")]
        public string Optional(int opt1, string opt2)
        {
            return "Optional" + opt1 + opt2;
        }

        [HttpGet]
        [Route("optionalwconstraint/{opt:int?}")]
        public string OptionalWithConstraint(string opt)
        {
            return "OptionalWithConstraint" + opt;
        }

        [HttpGet]
        [Route("default/{default1=D1}/{default2=D2}")]
        public string Default(string default1, string default2)
        {
            return "Default" + default1 + default2;
        }

        [HttpGet]
        [Route("wildcard/{*wildcard}")]
        public string Wildcard(string wildcard)
        {
            return "Wildcard" + wildcard;
        }

        [HttpGet]
        [HttpPut]
        [Route("multiverb")]
        public string MultiVerbs()
        {
            return Request.Method.ToString();
        }

        [HttpDelete] // Pick a unique verb
        [Route("multi1")]
        [Route("multi2")]
        public string MultiRoute()
        {
            return "multi";
        }
    }

    [RoutePrefix("prefix")]
    public class PrefixedController : ApiController
    {
        // Should not be reachable be our routes since there's no route attribute.
        public void Post()
        {
        }

        [Route("")]
        public string Get()
        {
            return "PrefixedGet";
        }

        [Route] // same behavior as Route("")
        public string Put()
        {
            return "PrefixedPut";
        }

        [HttpGet]
        [Route("{id}")]
        public string GetById(int id)
        {
            return "PrefixedGetById" + id;
        }
    }

    [RoutePrefix("prefix2")]
    [Route("defaultroute/{id:int}")]
    public class DefaultRouteController : ApiController
    {
        // This gets default route
        public string Get(int id)
        {
            return "get" + id;
        }

        [Route]
        public string Post()
        {
            return "post";
        }

        [Route("defaultrouteoverride/{id}")]
        public string Put(int id)
        {
            return "put" + id;
        }
    }

    [Route("api/default2/{action}")]
    public class RpcController : ApiController
    {
        public string GetAllCustomers1()
        {
            return "GetAllCustomers1";
        }

        public string GetAllCustomers2()
        {
            return "GetAllCustomers2";
        }

        // Have a REST api on a RPC controller. Has unique URL
        [Route("api/resource/{id}")]
        public string GetById(string id)
        {
            return id;
        }
    }

    [Route("partial/{action}")]
    public class PartlyResourcePartlyRpcController : ApiController
    {
        // Normal RPC methods
        [HttpGet]
        public string DoOp1()
        {
            return "op1";
        }

        // Some non-RPC methods.  Has overlapping URL
        [Route("partial/{id:int}")]
        public string GetById(int id)
        {
            return id.ToString();
        }
    }

    [RoutePrefix("apioptional")]
    [Route("{id?}")]
    public class OptionalController : ApiController
    {
        public string GetAllCustomers()
        {
            return "GetAllCustomers";
        }

        public string GetCustomer(int id)
        {
            return "GetCustomer:" + id;
        }
    }

    [RoutePrefix("apioverload")]
    public class OverloadController : ApiController
    {
        [Route("{name}")]
        public string GetAge(string name, int age)
        {
            return "GetAge:" + name + age;
        }

        [Route("{id}")]
        public string GetScore(string id, int score)
        {
            return "GetScore:" + id + score;
        }
    }

    [Route("baseclass", Name = "Base")]
    public class BaseClassController : ApiController
    {
        public string Get(int id)
        {
            return "Get:" + id;
        }
    }

    [Route("subclass", Name = "Sub")]
    public class SubClassController : BaseClassController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    public class SubClassNoRouteController : BaseClassController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    [RoutePrefix("baseclassprefix")]
    public class BaseClassPrefixController : ApiController
    {
        [Route]
        public string GetAll()
        {
            return "Get";
        }

        [Route("base/{id}", Name = "GetById")]
        public string GetById(int id)
        {
            return "Get:" + id;
        }
    }

    public class SubClassNoPrefixController : BaseClassPrefixController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    [RoutePrefix("subclassprefix")]
    public class SubClassPrefixController : BaseClassPrefixController
    {
        [Route]
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    [Route("subclassroute")]
    public class SubClassRouteController : BaseClassPrefixController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/DocumentationController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Web.Http.ApiExplorer
{
    [ApiDocumentation("Documentation controller")]
    public class DocumentationController : ApiController
    {
        [ApiDocumentation("Get action")]
        [ApiResponseDocumentation("Get response")]
        public string Get()
        {
            return string.Empty;
        }

        [ApiDocumentation("Post action")]
        [ApiParameterDocumentation("value", "value parameter")]
        public void Post(string value)
        {
        }

        [ApiDocumentation("Put action")]
        [ApiParameterDocumentation("id", "id parameter")]
        [ApiParameterDocumentation("value", "value parameter")]
        public void Put(int id, string value)
        {
        }

        [ApiDocumentation("Delete action")]
        [ApiParameterDocumentation("id", "id parameter")]
        public void Delete(int id)
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/HiddenActionController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Description;
namespace System.Web.Http.ApiExplorer
{
    public class HiddenActionController : ApiController
    {
        public string GetVisibleAction(int id)
        {
            return "visible action";
        }

        [HttpPost]
        [ApiExplorerSettings(IgnoreApi = true)]
        public void AddData()
        {
        }

        [ApiExplorerSettings(IgnoreApi = true)]
        public int Get()
        {
            return 0;
        }

        [NonAction]
        public string GetHiddenAction()
        {
            return "Hidden action";
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/HiddenController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Description;
namespace System.Web.Http.ApiExplorer
{
    [ApiExplorerSettings(IgnoreApi = true)]
    public class HiddenController : ApiController
    {
        public string Get(int id)
        {
            return "visible action";
        }

        [HttpPost]
        public void AddData()
        {
        }

        public int Get()
        {
            return 0;
        }

        [NonAction]
        public string GetHiddenAction()
        {
            return "Hidden action";
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/ItemController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ApiExplorer
{
    public class ItemController : ApiController
    {
        public Item GetItem(string name, int series)
        {
            return new Item()
            {
                Name = name,
                Series = series
            };
        }

        [HttpPost]
        [HttpPut]
        public Item PostItem(Item item)
        {
            return item;
        }

        [HttpDelete]
        public void RemoveItem(int id)
        {
        }

        public class Item
        {
            public int Series { get; set; }
            public string Name { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/OverloadsController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.ApiExplorer
{
    public class OverloadsController : ApiController
    {
        public Person Get(int id) { return null; }
        public List<Person> Get() { return null; }
        public List<Person> Get(string name) { return null; }
        public Person GetPersonByNameAndId(string name, int id) { return null; }
        public Person GetPersonByNameAndAge(string name, int age) { return null; }
        public Person GetPersonByNameAgeAndSsn(string name, int age, int ssn) { return null; }
        public Person GetPersonByNameIdAndSsn(string name, int id, int ssn) { return null; }
        public Person GetPersonByNameAndSsn(string name, int ssn) { return null; }
        public Person Post(Person Person) { return null; }
        public Person ActionDefaultedToPost(string name, int age) { return null; }
        public void Delete(int id, string name = "Default Name") { }
        public void Delete(int id, string name, int age) { }

        public class Person
        {
            public string Name { get; set; }
            public int ID { get; set; }
            public int SSN { get; set; }
            public int Age { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/ParameterSourceController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.ModelBinding;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.ApiExplorer
{
    public class ParameterSourceController : ApiController
    {
        public void GetCompleTypeFromUri([FromUri]ComplexType value, string name)
        {
        }

        public void PostSimpleTypeFromBody([FromBody] string name)
        {
        }

        public void GetCustomFromUriAttribute([MyFromUriAttribute] ComplexType value, ComplexType bodyValue)
        {
        }

        public void GetFromHeaderAttribute([FromHeaderAttribute] string value)
        {
        }

        public class ComplexType
        {
            public int Id { get; set; }
            public string Name { get; set; }
        }

        private class MyFromUriAttribute : ModelBinderAttribute, IUriValueProviderFactory
        {
            public override IEnumerable<ValueProviderFactory> GetValueProviderFactories(HttpConfiguration configuration)
            {
                var factories = from f in base.GetValueProviderFactories(configuration) where f is IUriValueProviderFactory select f;
                return factories;
            }
        }

        private class FromHeaderAttribute : ModelBinderAttribute
        {
            public override IEnumerable<ValueProviderFactory> GetValueProviderFactories(HttpConfiguration configuration)
            {
                var factories = new ValueProviderFactory[] { new HeaderValueProvider() };
                return factories;
            }
        }

        private class HeaderValueProvider : ValueProviderFactory
        {
            public override IValueProvider GetValueProvider(Controllers.HttpActionContext actionContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Controllers/ResponseTypeController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Web.Http.Description;

namespace System.Web.Http.ApiExplorer
{
    public class ResponseTypeController : ApiController
    {
        [ResponseType(typeof(User))]
        public IHttpActionResult Get()
        {
            return Content<User>(HttpStatusCode.OK, new User { FirstName = "foo", LastName = "bar" });
        }

        [ResponseType(typeof(User))]
        public HttpResponseMessage Post(User user)
        {
            return Request.CreateResponse<User>(user);
        }

        public string Delete(int id)
        {
            return "User deleted";
        }

        [ResponseType(typeof(void))]
        public IHttpActionResult Head()
        {
            return StatusCode(HttpStatusCode.OK);
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/DocumentationProviders/AttributeDocumentationProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Description;

namespace System.Web.Http.ApiExplorer
{
    public class AttributeDocumentationProvider : IDocumentationProvider
    {
        public string GetDocumentation(HttpActionDescriptor actionDescriptor)
        {
            var apiDocumentation = actionDescriptor.GetCustomAttributes<ApiDocumentationAttribute>().FirstOrDefault();
            if (apiDocumentation != null)
            {
                return apiDocumentation.Description;
            }

            return String.Empty;
        }

        public string GetDocumentation(HttpParameterDescriptor parameterDescriptor)
        {
            var parameterDocumentation = parameterDescriptor.ActionDescriptor.GetCustomAttributes<ApiParameterDocumentationAttribute>().FirstOrDefault(param => param.ParameterName == parameterDescriptor.ParameterName);
            if (parameterDocumentation != null)
            {
                return parameterDocumentation.Description;
            }

            return String.Empty;
        }

        public string GetDocumentation(HttpControllerDescriptor controllerDescriptor)
        {
            var apiDocumentation = controllerDescriptor.GetCustomAttributes<ApiDocumentationAttribute>().FirstOrDefault();
            if (apiDocumentation != null)
            {
                return apiDocumentation.Description;
            }

            return String.Empty;
        }
        
        public string GetResponseDocumentation(HttpActionDescriptor actionDescriptor)
        {
            var apiDocumentation = actionDescriptor.GetCustomAttributes<ApiResponseDocumentationAttribute>().FirstOrDefault();
            if (apiDocumentation != null)
            {
                return apiDocumentation.Description;
            }

            return String.Empty;
        }
    }

    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = false)]
    public sealed class ApiDocumentationAttribute : Attribute
    {
        public ApiDocumentationAttribute(string description)
        {
            Description = description;
        }

        public string Description { get; private set; }
    }

    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
    public sealed class ApiResponseDocumentationAttribute : Attribute
    {
        public ApiResponseDocumentationAttribute(string description)
        {
            Description = description;
        }

        public string Description { get; private set; }
    }

    [AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
    public sealed class ApiParameterDocumentationAttribute : Attribute
    {
        public ApiParameterDocumentationAttribute(string parameterName, string description)
        {
            ParameterName = parameterName;
            Description = description;
        }

        public string ParameterName { get; private set; }

        public string Description { get; private set; }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/DocumentationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using Microsoft.TestCommon;

namespace System.Web.Http.ApiExplorer
{
    public class DocumentationTest
    {
        [Fact]
        public void VerifyDefaultDocumentationMessage()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            foreach (ApiDescription description in explorer.ApiDescriptions)
            {
                Assert.Null(description.Documentation);
                foreach (ApiParameterDescription param in description.ParameterDescriptions)
                {
                    Assert.Null(param.Documentation);
                }
            }
        }

        [Fact]
        public void VerifyCustomDocumentationProviderMessage()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(DocumentationController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            AttributeDocumentationProvider documentationProvider = new AttributeDocumentationProvider();
            config.Services.Replace(typeof(IDocumentationProvider), documentationProvider);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            foreach (ApiDescription description in explorer.ApiDescriptions)
            {
                Assert.Equal(
                    "Documentation controller",
                    documentationProvider.GetDocumentation(description.ActionDescriptor.ControllerDescriptor));
                Assert.Equal(
                    String.Format("{0} action", description.ActionDescriptor.ActionName),
                    description.Documentation);
                foreach (ApiParameterDescription param in description.ParameterDescriptions)
                {
                    Assert.Equal(
                        String.Format("{0} parameter", param.Name),
                        param.Documentation);
                }
                if (description.ResponseDescription.DeclaredType != null)
                {
                    Assert.Equal(
                        String.Format("{0} response", description.ActionDescriptor.ActionName),
                        description.ResponseDescription.Documentation);
                }
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/Formatters/ItemFormatter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;

namespace System.Web.Http.ApiExplorer
{
    public class ItemFormatter : BufferedMediaTypeFormatter
    {
        public override bool CanReadType(Type type)
        {
            return typeof(System.Web.Http.ApiExplorer.ItemController.Item).IsAssignableFrom(type);
        }

        public override bool CanWriteType(Type type)
        {
            return typeof(System.Web.Http.ApiExplorer.ItemController.Item).IsAssignableFrom(type);
        }

        public override object ReadFromStream(Type type, IO.Stream stream, Net.Http.HttpContent content, IFormatterLogger formatterLogger)
        {
            return base.ReadFromStream(type, stream, content, formatterLogger);
        }

        public override void WriteToStream(Type type, object value, IO.Stream stream, Net.Http.HttpContent content)
        {
            base.WriteToStream(type, value, stream, content);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/FormattersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ApiExplorer
{
    public class FormattersTest
    {
        [Fact]
        public void CustomRequestBodyFormatters_ShowUpOnDescription()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostItem");
            Assert.True(description.SupportedRequestBodyFormatters.Any(formatter => formatter == customFormatter), "Did not find the custom formatter on the SupportedRequestBodyFormatters.");
        }

        [Fact]
        public void CustomResponseFormatters_ShowUpOnDescription()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostItem");
            Assert.True(description.SupportedResponseFormatters.Any(formatter => formatter == customFormatter), "Did not find the custom formatter on the SupportedResponseFormatters.");
        }

        [Fact]
        public void SupportedRequestBodyFormatters_ReturnsFormattersWithoutTracers_WithNoTracing()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);
            config.Initializer.Invoke(config);
            int expectedFormatterCount = config.Formatters.Count - 1;
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            // Act 
            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostItem");
            Collection<MediaTypeFormatter> formatters = description.SupportedRequestBodyFormatters;

            // Assert
            Assert.False(formatters.Any(f => f is IFormatterTracer), "Tracers are present");
            Assert.Equal(expectedFormatterCount, formatters.Count);
        }

        [Fact]
        public void SupportedResponseFormatters_ReturnsFormattersWithoutTracers_WithNoTracing()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);
            config.Initializer.Invoke(config);
            int expectedFormatterCount = config.Formatters.Count - 2;
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            // Act 
            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostItem");
            Collection<MediaTypeFormatter> formatters = description.SupportedResponseFormatters;

            // Assert
            Assert.False(formatters.Any(f => f is IFormatterTracer), "Tracers are present");
            Assert.Equal(expectedFormatterCount, formatters.Count);
        }

        [Fact]
        public void SupportedRequestBodyFormatters_ReturnsFormattersWithoutTracers_WithTracing()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);
            ITraceWriter testTraceWriter = new Mock<ITraceWriter>().Object;
            config.Services.Replace(typeof(ITraceWriter), testTraceWriter);
            config.Initializer.Invoke(config);
            int expectedFormatterCount = config.Formatters.Count - 1;
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            // Act 
            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostItem");
            Collection<MediaTypeFormatter> formatters = description.SupportedRequestBodyFormatters;

            // Assert
            Assert.False(formatters.Any(f => f is IFormatterTracer), "Tracers are present");
            Assert.Equal(expectedFormatterCount, formatters.Count);
        }

        [Fact]
        public void SupportedResponseFormatters_ReturnsFormattersWithoutTracers_WithTracing()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            ItemFormatter customFormatter = new ItemFormatter();
            config.Formatters.Add(customFormatter);
            ITraceWriter testTraceWriter = new Mock<ITraceWriter>().Object;
            config.Services.Replace(typeof(ITraceWriter), testTraceWriter);
            config.Initializer.Invoke(config);
            int expectedFormatterCount = config.Formatters.Count - 2;
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ItemController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            // Act 
            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostItem");
            Collection<MediaTypeFormatter> formatters = description.SupportedResponseFormatters;

            // Assert
            Assert.False(formatters.Any(f => f is IFormatterTracer), "Tracers are present");
            Assert.Equal(expectedFormatterCount, formatters.Count);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/ParameterSourceTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Linq;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using Microsoft.TestCommon;

namespace System.Web.Http.ApiExplorer
{
    public class ParameterSourceTest
    {
        [Fact]
        public void FromUriParameterSource_ShowUpCorrectlyOnDescription()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{action}/{id}", new { id = RouteParameter.Optional });
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ParameterSourceController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetCompleTypeFromUri");
            Assert.NotNull(description);
            Assert.True(description.ParameterDescriptions.All(param => param.Source == ApiParameterSource.FromUri), "All parameters should come from URI.");

            description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetCustomFromUriAttribute");
            Assert.NotNull(description);
            Assert.True(description.ParameterDescriptions.Any(param => param.Source == ApiParameterSource.FromUri && param.Name == "value"), "The 'value' parameter should come from URI.");
            Assert.True(description.ParameterDescriptions.Any(param => param.Source == ApiParameterSource.FromBody && param.Name == "bodyValue"), "The 'bodyValue' parameter should come from body.");
        }

        [Fact]
        public void FromBodyParameterSource_ShowUpCorrectlyOnDescription()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{action}/{id}", new { id = RouteParameter.Optional });
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ParameterSourceController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "PostSimpleTypeFromBody");
            Assert.NotNull(description);
            Assert.True(description.ParameterDescriptions.All(param => param.Source == ApiParameterSource.FromBody), "The parameter should come from Body.");
        }

        [Fact]
        public void UnknownParameterSource_ShowUpCorrectlyOnDescription()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{action}/{id}", new { id = RouteParameter.Optional });
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ParameterSourceController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetFromHeaderAttribute");
            Assert.NotNull(description);
            Assert.True(description.ParameterDescriptions.All(param => param.Source == ApiParameterSource.Unknown), "The parameter source should be Unknown.");
        }

        [Fact]
        public void EnumParameters_ShowUpCorrectlyOnDescription()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}");
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(EnumParameterOverloadsController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithEnumParameter");
            Assert.NotNull(description);
            ApiParameterDescription parameterDescription = Assert.Single(description.ParameterDescriptions);
            Assert.Equal(ApiParameterSource.FromUri, parameterDescription.Source);
            Assert.Equal("EnumParameterOverloads?scope={scope}", description.RelativePath);

            description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithTwoEnumParameters");
            Assert.NotNull(description);
            Assert.Equal(2, description.ParameterDescriptions.Count);
            Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[0].Source);
            Assert.Equal(ApiParameterSource.FromUri, description.ParameterDescriptions[1].Source);
            Assert.Equal("EnumParameterOverloads?level={level}&kind={kind}", description.RelativePath);

            description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == "GetWithNullableEnumParameter");
            Assert.NotNull(description);
            parameterDescription = Assert.Single(description.ParameterDescriptions);
            Assert.Equal(ApiParameterSource.FromUri, parameterDescription.Source);
            Assert.Equal("EnumParameterOverloads?level={level}", description.RelativePath);
        }

        [Theory]
        [InlineData("api/values/{id}", "", "Get")]
        [InlineData("api/values", "?value={value}", "GetFromUri")]
        [InlineData("api/values", "?X={X}&Y={Y}", "GetPoint")]
        [InlineData("api/values", "?origin.X={origin.X}&origin.Y={origin.Y}&end.X={end.X}&end.Y={end.Y}", "GetDistance")]
        [InlineData("api/values", "?Latitude={Latitude}&Longitude={Longitude}", "GetLocation")]
        [InlineData("api/values", "?value={value}", "GetConvertible")]
        [InlineData("api/values", "", "GetNoDescribable")]
        [InlineData("api/values", "?X={X}", "GetParticle")]
        public void RelativePath_IsCorrectForTypesFromUri(string routeTemplate, string expectedQueryString, string methodName)
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", routeTemplate, new { controller = "ApiExplorerActionsWithParameters", action = methodName });
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, typeof(ApiExplorerActionsWithParametersController));
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            IApiExplorer explorer = config.Services.GetApiExplorer();

            // Act
            ApiDescription description = explorer.ApiDescriptions.FirstOrDefault(desc => desc.ActionDescriptor.ActionName == methodName);

            // Assert
            Assert.NotNull(description);
            Assert.Equal(routeTemplate + expectedQueryString, description.RelativePath);
        }

        public class ApiExplorerActionsWithParametersController : ApiController
        {
            public void Get(int id) { }
            public void GetFromUri([FromUri]string value) { }
            public void GetPoint([FromUri] Point complexParameterObject) { }
            public void GetDistance([FromUri] Point origin, [FromUri] Point end) { }
            public void GetLocation(Location location) { }
            public void GetConvertible([FromUri] ConvertibleFromString value) { }
            public void GetNoDescribable([FromUri] NonDescribable nonDescribable) { }
            public void GetParticle([FromUri] Particle particle) { }
        }

        public class Point
        {
            public int X { get; set; }
            public int Y { get; set; }
        }

        [FromUri]
        public class Location
        {
            public int Latitude { get; set; }
            public int Longitude { get; set; }
            public static Location Greenwich { get; set; }
        }

        [TypeConverter(typeof(ConvertibleFromStringConverter))]
        public class ConvertibleFromString
        {
            public class ConvertibleFromStringConverter : TypeConverter
            {
                public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
                {
                    return sourceType == typeof(string);
                }
            }
            public int Id { get; set; }
            public string Value { get; set; }
        }

        // We only support complex types whose all of their individual
        // properties can be converted from string.
        public class NonDescribable
        {
            public Point Point { get; set; }
        }

        // Get only, Set only, and private properties are ignored.
        public class Particle
        {
            public int X { get; set; }
            public int Y { get; private set; }
            public int Z
            {
                get
                {
                    return 0;
                }
            }
            private int _mass;
            public int Mass
            {
                set
                {
                    _mass = value;
                }
            }
            private string Color { get; set; }
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/ResponseTypeAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using Microsoft.TestCommon;

namespace System.Web.Http.ApiExplorer
{
    public class ResponseTypeAttributeTest
    {
        [Theory]
        [InlineData("Get", typeof(IHttpActionResult), typeof(User), 2)]
        [InlineData("Post", typeof(HttpResponseMessage), typeof(User), 2)]
        [InlineData("Delete", typeof(string), null, 2)]
        [InlineData("Head", typeof(IHttpActionResult), typeof(void), 0)]
        public void DeclaredResponseType_AppearsOnApiDescription(string actionName, Type declaredType, Type responseType, int responseFormattersCount)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            Type controllerToTest = typeof(ResponseTypeController);
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerToTest);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            Collection<ApiDescription> apis = config.Services.GetApiExplorer().ApiDescriptions;
            ApiDescription expectedApi = apis.FirstOrDefault(api => api.ActionDescriptor.ActionName == actionName &&
                api.ResponseDescription.DeclaredType == declaredType &&
                api.ResponseDescription.ResponseType == responseType);

            Assert.NotNull(expectedApi);
            Assert.Equal(responseFormattersCount, expectedApi.SupportedResponseFormatters.Count);
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/RouteConstraintsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.ApiExplorer
{
    public class RouteConstraintsTest
    {
        public static IEnumerable<object[]> HttpMethodConstraints_LimitsTheDescriptions_PropertyData
        {
            get
            {
                object controllerType = typeof(ItemController);
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Item?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(OverloadsController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/{id}?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}&age={age}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/{id}?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2}
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("HttpMethodConstraints_LimitsTheDescriptions_PropertyData")]
        public void HttpMethodConstraints_LimitsTheDescriptions(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional }, new { routeConstraint = new HttpMethodConstraint(HttpMethod.Get, HttpMethod.Put) });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        public static IEnumerable<object[]> RegexConstraint_LimitsTheController_PropertyData
        {
            get
            {
                object[] controllerTypes = new Type[] { typeof(OverloadsController), typeof(ItemController) };
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Item?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Item/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1}
                };
                yield return new[] { controllerTypes, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("RegexConstraint_LimitsTheController_PropertyData")]
        public void RegexConstraint_LimitsTheController(Type[] controllerTypes, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional }, new { controller = "It.*" }); // controllers that start with "It"

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerTypes);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        public static IEnumerable<object[]> RegexConstraint_LimitsTheAction_PropertyData
        {
            get
            {
                object[] controllerTypes = new Type[] { typeof(OverloadsController), typeof(ItemController) };
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Item/GetItem?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAndId/{id}?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAndAge?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAgeAndSsn?name={name}&age={age}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameIdAndSsn/{id}?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAndSsn?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2}
                };
                yield return new[] { controllerTypes, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("RegexConstraint_LimitsTheAction_PropertyData")]
        public void RegexConstraint_LimitsTheAction(Type[] controllerTypes, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{action}/{id}", new { id = RouteParameter.Optional }, new { action = "Get.+" }); // actions that start with "Get" and at least one extra character

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerTypes);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ApiExplorer/RoutesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.ApiExplorer
{
    public class RoutesTest
    {
        [Fact]
        public void VerifyDescription_OnEmptyRoute()
        {
            HttpConfiguration config = new HttpConfiguration();
            IApiExplorer explorer = config.Services.GetApiExplorer();

            Assert.NotNull(explorer);
            Assert.Empty(explorer.ApiDescriptions);
        }

        [Fact]
        public void VerifyDescription_OnInvalidRoute()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Invalid", "badRouteWithNoControler");
            IApiExplorer explorer = config.Services.GetApiExplorer();

            Assert.NotNull(explorer);
            Assert.Empty(explorer.ApiDescriptions);
        }

        public static IEnumerable<object[]> VerifyDescription_OnDefaultRoute_PropertyData
        {
            get
            {
                object controllerType = typeof(ItemController);
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Item?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Item/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(OverloadsController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/{id}?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}&age={age}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/{id}?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "Overloads", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "Overloads?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Overloads/{id}?name={name}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Overloads/{id}?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 3}
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("VerifyDescription_OnDefaultRoute_PropertyData")]
        public void VerifyDescription_OnDefaultRoute(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        public static IEnumerable<object[]> VerifyDescription_OnRouteWithControllerOnDefaults_PropertyData
        {
            get
            {
                object controllerType = typeof(ItemController);
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "myitem?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "myitem", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "myitem", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "myitem/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("VerifyDescription_OnRouteWithControllerOnDefaults_PropertyData")]
        public void VerifyDescription_OnRouteWithControllerOnDefaults(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "myitem/{id}", new { controller = "Item", id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        public static IEnumerable<object[]> VerifyDescription_OnRouteWithActionVariable_PropertyData
        {
            get
            {
                object controllerType = typeof(ItemController);
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Item/GetItem?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "Item/PostItem", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Put, RelativePath = "Item/PostItem", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Item/RemoveItem/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };

                controllerType = typeof(OverloadsController);
                expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/Get/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/Get", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 0},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/Get?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAndId/{id}?name={name}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAndAge?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAgeAndSsn?name={name}&age={age}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameIdAndSsn/{id}?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                    new { HttpMethod = HttpMethod.Get, RelativePath = "Overloads/GetPersonByNameAndSsn?name={name}&ssn={ssn}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "Overloads/Post", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                    new { HttpMethod = HttpMethod.Post, RelativePath = "Overloads/ActionDefaultedToPost?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Overloads/Delete/{id}?name={name}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 2},
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Overloads/Delete/{id}?name={name}&age={age}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 3}
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("VerifyDescription_OnRouteWithActionVariable_PropertyData")]
        public void VerifyDescription_OnRouteWithActionVariable(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{action}/{id}", new { id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        public static IEnumerable<object[]> VerifyDescription_On_RouteWithActionOnDefaults_PropertyData
        {
            get
            {
                object controllerType = typeof(ItemController);
                object expectedApiDescriptions = new List<object>
                {
                    new { HttpMethod = HttpMethod.Delete, RelativePath = "Item/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1}
                };
                yield return new[] { controllerType, expectedApiDescriptions };
            }
        }

        [Theory]
        [PropertyData("VerifyDescription_On_RouteWithActionOnDefaults_PropertyData")]
        public void VerifyDescription_On_RouteWithActionOnDefaults(Type controllerType, List<object> expectedResults)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { action = "RemoveItem", id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            ApiExplorerHelper.VerifyApiDescriptions(explorer.ApiDescriptions, expectedResults);
        }

        [Fact]
        public void InvalidActionNameOnRoute_DoesNotThrow()
        {
            Type controllerType = typeof(OverloadsController);
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { action = "ActionThatDoesNotExist", id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            Assert.Empty(explorer.ApiDescriptions);
        }

        [Fact]
        public void InvalidControllerNameOnRoute_DoesNotThrow()
        {
            Type controllerType = typeof(OverloadsController);
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "mycontroller/{id}", new { controller = "ControllerThatDoesNotExist", id = RouteParameter.Optional });

            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            Assert.Empty(explorer.ApiDescriptions);
        }

        [Fact]
        public void VerifyOnlyOneSetOfDescriptionIsGenerated_OnTwoMatchingRoutes()
        {
            Type controllerType = typeof(ItemController);
            HttpConfiguration config = new HttpConfiguration();
            IHttpRoute matchingRoute = config.Routes.MapHttpRoute("Item", "Item/{id}", new { id = RouteParameter.Optional, controller = "Item" });
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            Collection<ApiDescription> descriptions = explorer.ApiDescriptions;

            foreach (ApiDescription description in descriptions)
            {
                Assert.Same(matchingRoute, description.Route);
            }
            List<object> expectedResults = new List<object>
            {
                new { HttpMethod = HttpMethod.Get, RelativePath = "Item?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 2},
                new { HttpMethod = HttpMethod.Post, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                new { HttpMethod = HttpMethod.Put, RelativePath = "Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 1},
                new { HttpMethod = HttpMethod.Delete, RelativePath = "Item/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 1}
            };
            ApiExplorerHelper.VerifyApiDescriptions(descriptions, expectedResults);
        }

        [Fact]
        public void VerifyDescriptionIsNotGeneratedForAmbiguousAction_OnDefaultRoutes()
        {
            Type controllerType = typeof(AmbiguousActionController);
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            Collection<ApiDescription> descriptions = explorer.ApiDescriptions;

            List<object> expectedResults = new List<object>
            {
                new { HttpMethod = HttpMethod.Post, RelativePath = "AmbiguousAction/{id}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 1}
            };
            ApiExplorerHelper.VerifyApiDescriptions(descriptions, expectedResults);
        }

        [Fact]
        public void VerifyDescriptionIsGenerated_WhenRouteParameterIsNotInAction()
        {
            Type controllerType = typeof(ItemController);
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Custom", "{majorVersion}/{minorVersion}/custom", new { controller = "Item" });
            config.Routes.MapHttpRoute("Default", "{version}/{controller}/{id}", new { id = RouteParameter.Optional });
            DefaultHttpControllerSelector controllerSelector = ApiExplorerHelper.GetStrictControllerSelector(config, controllerType);
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            IApiExplorer explorer = config.Services.GetApiExplorer();
            Collection<ApiDescription> descriptions = explorer.ApiDescriptions;

            List<object> expectedResults = new List<object>
            {
                new { HttpMethod = HttpMethod.Get, RelativePath = "{majorVersion}/{minorVersion}/custom?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 4},
                new { HttpMethod = HttpMethod.Post, RelativePath = "{majorVersion}/{minorVersion}/custom", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 3},
                new { HttpMethod = HttpMethod.Put, RelativePath = "{majorVersion}/{minorVersion}/custom", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 3},
                new { HttpMethod = HttpMethod.Delete, RelativePath = "{majorVersion}/{minorVersion}/custom?id={id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 3},
                new { HttpMethod = HttpMethod.Get, RelativePath = "{version}/Item?name={name}&series={series}", HasRequestFormatters = false, HasResponseFormatters = true, NumberOfParameters = 3},
                new { HttpMethod = HttpMethod.Post, RelativePath = "{version}/Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 2},
                new { HttpMethod = HttpMethod.Put, RelativePath = "{version}/Item", HasRequestFormatters = true, HasResponseFormatters = true, NumberOfParameters = 2},
                new { HttpMethod = HttpMethod.Delete, RelativePath = "{version}/Item/{id}", HasRequestFormatters = false, HasResponseFormatters = false, NumberOfParameters = 2}
            };
            ApiExplorerHelper.VerifyApiDescriptions(descriptions, expectedResults);
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ContentNegotiation/AcceptHeaderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.ContentNegotiation
{
    public class AcceptHeaderTests : ContentNegotiationTestBase
    {
        [Theory]
        [InlineData("application/json")]
        [InlineData("application/xml")]
        public async Task Response_Contains_ContentType(string contentType)
        {
            // Arrange
            MediaTypeWithQualityHeaderValue requestContentType = new MediaTypeWithQualityHeaderValue(contentType);
            MediaTypeHeaderValue responseContentType = null;

            // Act
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, BaseAddress);
            request.Headers.Accept.Add(requestContentType);
            HttpResponseMessage response = await Client.SendAsync(request);
            response.EnsureSuccessStatusCode();
            responseContentType = response.Content.Headers.ContentType;

            // Assert
            Assert.Equal(requestContentType.MediaType, responseContentType.MediaType);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ContentNegotiation/ConnegController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ContentNegotiation
{
    public class ConnegController : ApiController
    {
        public ConnegItem GetItem(string name = "Fido", int age = 3)
        {
            return new ConnegItem()
            {
                Name = name,
                Age = age
            };
        }

        public ConnegItem PostItem(ConnegItem item)
        {
            return item;
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ContentNegotiation/ConnegItem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ContentNegotiation
{
    public class ConnegItem
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ContentNegotiation/ContentNegotiationTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ContentNegotiation
{
    public abstract class ContentNegotiationTestBase : HttpServerTestBase
    {
        protected ContentNegotiationTestBase()
            : base("http://localhost/Conneg")
        {
        }

        protected override void ApplyConfiguration(HttpConfiguration configuration)
        {
            configuration.Routes.MapHttpRoute("Default", "{controller}", new { controller = "Conneg" });
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ContentNegotiation/CustomFormatterTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Http.SelfHost;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ContentNegotiation
{
    public class CustomFormatterTests
    {
        private HttpServer server = null;
        private string baseAddress = null;
        private HttpClient httpClient = null;
        private HttpConfiguration config = null;

        public CustomFormatterTests()
        {
            SetupHost();
        }

        [Fact]
        public async Task CustomFormatter_Overrides_SetResponseHeaders_During_Conneg()
        {
            Order reqOrdr = new Order() { OrderId = "100", OrderValue = 100.00 };
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new ObjectContent<Order>(reqOrdr, new XmlMediaTypeFormatter())
            };
            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoOrder");
            request.Method = HttpMethod.Post;
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("text/plainwithversioninfo"));

            HttpResponseMessage response = await httpClient.SendAsync(request);

            response.EnsureSuccessStatusCode();

            IEnumerable<string> versionHdr = null;
            Assert.True(response.Content.Headers.TryGetValues("Version", out versionHdr));
            Assert.Equal("1.3.5.0", versionHdr.First());
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("text/plainwithversioninfo", response.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public async Task CustomFormatter_Post_Returns_Request_String_Content()
        {
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new ObjectContent<string>("Hello World!", new PlainTextFormatter())
            };
            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoString");
            request.Method = HttpMethod.Post;

            HttpResponseMessage response = await httpClient.SendAsync(request);

            response.EnsureSuccessStatusCode();
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("text/plain", response.Content.Headers.ContentType.MediaType);
            Assert.Equal("Hello World!", await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task CustomFormatter_Post_Returns_Request_Integer_Content()
        {
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new ObjectContent<int>(100, new PlainTextFormatter())
            };

            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoInt");
            request.Method = HttpMethod.Post;

            HttpResponseMessage response = await httpClient.SendAsync(request);

            response.EnsureSuccessStatusCode();
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("text/plain", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(100, Convert.ToInt32(await response.Content.ReadAsStringAsync()));
        }

        [Fact]
        public async Task CustomFormatter_Post_Returns_Request_ComplexType_Content()
        {
            Order reqOrdr = new Order() { OrderId = "100", OrderValue = 100.00 };
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new ObjectContent<Order>(reqOrdr, new PlainTextFormatter())
            };
            request.RequestUri = new Uri(baseAddress + "/CustomFormatterTests/EchoOrder");
            request.Method = HttpMethod.Post;

            HttpResponseMessage response = await httpClient.SendAsync(request);

            response.EnsureSuccessStatusCode();
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("text/plain", response.Content.Headers.ContentType.MediaType);
        }

        private void SetupHost()
        {
            baseAddress = "http://localhost/";
            config = new HttpSelfHostConfiguration(baseAddress);
            config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "CustomFormatterTests", action = "EchoOrder" });
            config.MessageHandlers.Add(new ConvertToStreamMessageHandler());
            config.Formatters.Add(new PlainTextFormatterWithVersionInfo());
            config.Formatters.Add(new PlainTextFormatter());

            server = new HttpServer(config);
            httpClient = new HttpClient(server);
        }
    }

    public class PlainTextFormatterWithVersionInfo : MediaTypeFormatter
    {
        public PlainTextFormatterWithVersionInfo()
        {
            this.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/plainwithversioninfo"));
        }

        public override bool CanReadType(Type type)
        {
            return true;
        }

        public override bool CanWriteType(Type type)
        {
            return true;
        }

        public override void SetDefaultContentHeaders(Type objectType, HttpContentHeaders contentHeaders, MediaTypeHeaderValue mediaType)
        {
            base.SetDefaultContentHeaders(objectType, contentHeaders, mediaType);
            contentHeaders.TryAddWithoutValidation("Version", "1.3.5.0");
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            string stringContent = null;

            using (var reader = new StreamReader(readStream))
            {
                stringContent = reader.ReadToEnd();
            }

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.SetResult(stringContent);

            return tcs.Task;
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
        {
            var output = value.ToString();
            var writer = new StreamWriter(writeStream);
            writer.Write(output);
            writer.Flush();

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.SetResult(null);

            return tcs.Task;
        }
    }

    public class PlainTextFormatter : MediaTypeFormatter
    {
        public PlainTextFormatter()
        {
            this.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/plain"));
        }

        public override bool CanReadType(Type type)
        {
            return true;
        }

        public override bool CanWriteType(Type type)
        {
            return true;
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            object result = null;

            using (var reader = new StreamReader(readStream))
            {
                result = reader.ReadToEnd();
            }

            if (type == typeof(Int32))
            {
                result = Int32.Parse((string)result);
            }
            else if (type == typeof(Order))
            {
                result = new Order((string)result);
            }

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.SetResult(result);
            return tcs.Task;
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
        {
            var output = value == null ? String.Empty : value.ToString();
            var writer = new StreamWriter(writeStream);
            writer.Write(output);
            writer.Flush();

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.SetResult(null);
            return tcs.Task;
        }
    }

    public class CustomFormatterTestsController : ApiController
    {
        [HttpPost]
        public string EchoString([FromBody] string input)
        {
            return input;
        }

        [HttpPost]
        public int EchoInt([FromBody] int input)
        {
            return input;
        }

        [HttpPost]
        public Order EchoOrder(Order order)
        {
            return order;
        }
    }

    public class Order : IEquatable<Order>, ICloneable
    {
        public string OrderId { get; set; }
        public double OrderValue { get; set; }

        public Order() { }

        public Order(string value)
        {
            string[] pieces = value.Split(new[] { '\n' }, 2);

            OrderId = pieces[0];
            OrderValue = Double.Parse(pieces[1]);
        }

        public bool Equals(Order other)
        {
            return (this.OrderId.Equals(other.OrderId) && this.OrderValue.Equals(other.OrderValue));
        }

        public object Clone()
        {
            return this.MemberwiseClone();
        }

        public override string ToString()
        {
            return String.Format("{0}\n{1}", OrderId, OrderValue);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ContentNegotiation/DefaultContentNegotiatorTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ContentNegotiation
{
    public class DefaultContentNegotiatorTests : ContentNegotiationTestBase
    {
        [Fact]
        public async Task Custom_ContentNegotiator_Used_In_Response()
        {
            // Arrange
            Configuration.Formatters.Clear();
            MediaTypeWithQualityHeaderValue requestContentType = new MediaTypeWithQualityHeaderValue("application/xml");
            MediaTypeHeaderValue responseContentType = null;

            Mock<IContentNegotiator> selector = new Mock<IContentNegotiator>();
            selector.Setup(s => s.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(), It.IsAny<IEnumerable<MediaTypeFormatter>>()))
                .Returns(new ContentNegotiationResult(new XmlMediaTypeFormatter(), null));

            Configuration.Services.Replace(typeof(IContentNegotiator), selector.Object);

            // Act
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, BaseAddress);
            request.Headers.Accept.Add(requestContentType);
            HttpResponseMessage response = await Client.SendAsync(request);
            response.EnsureSuccessStatusCode();
            responseContentType = response.Content.Headers.ContentType;

            // Assert
            selector.Verify(s => s.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(), It.IsAny<IEnumerable<MediaTypeFormatter>>()), Times.AtLeastOnce());
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ContentNegotiation/HttpResponseReturnTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Http.SelfHost;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ContentNegotiation
{
    public class HttpResponseReturnTests
    {
        private HttpServer server = null;
        private string baseAddress = null;
        private HttpClient httpClient = null;

        public HttpResponseReturnTests()
        {
            this.SetupHost();
        }

        [Theory]
        [InlineData("ReturnHttpResponseMessage")]
        [InlineData("ReturnHttpResponseMessageAsObject")]
        [InlineData("ReturnString")]
        public async Task ActionReturnsHttpResponseMessage(string action)
        {
            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">Hello</string>";

            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(baseAddress + String.Format("HttpResponseReturn/{0}", action));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Get;

            HttpResponseMessage response = await httpClient.SendAsync(request);

            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        [Theory]
        [InlineData("ReturnHttpResponseMessageAsXml")]
        public async Task ActionReturnsHttpResponseMessageWithExplicitMediaType(string action)
        {
            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">Hello</string>";

            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(baseAddress + String.Format("HttpResponseReturn/{0}", action));
            request.Method = HttpMethod.Get;

            HttpResponseMessage response = await httpClient.SendAsync(request);

            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        [Theory]
        [InlineData("ReturnMultipleSetCookieHeaders")]
        public async Task ReturnMultipleSetCookieHeadersShouldWork(string action)
        {
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(baseAddress + String.Format("HttpResponseReturn/{0}", action));
            request.Method = HttpMethod.Get;
            HttpResponseMessage response = await httpClient.SendAsync(request);
            response.EnsureSuccessStatusCode();
            IEnumerable<string> list;
            Assert.True(response.Headers.TryGetValues("Set-Cookie", out list));
            Assert.Equal(new[] { "cookie1", "cookie2" }, list);
        }

        private void SetupHost()
        {
            baseAddress = "http://localhost/";

            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);
            config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "HttpResponseReturn" });
            config.MessageHandlers.Add(new ConvertToStreamMessageHandler());

            server = new HttpServer(config);
            httpClient = new HttpClient(server);
        }
    }

    public class HttpResponseReturnController : ApiController
    {
        [HttpGet]
        public HttpResponseMessage ReturnHttpResponseMessage()
        {
            return Request.CreateResponse(HttpStatusCode.OK, "Hello");
        }

        [HttpGet]
        public object ReturnHttpResponseMessageAsObject()
        {
            return ReturnHttpResponseMessage();
        }

        [HttpGet]
        public HttpResponseMessage ReturnHttpResponseMessageAsXml()
        {
            HttpResponseMessage response = new HttpResponseMessage()
            {
                Content = new ObjectContent<string>("Hello", new XmlMediaTypeFormatter())
            };
            return response;
        }

        [HttpGet]
        public string ReturnString()
        {
            return "Hello";
        }

        [HttpGet]
        public HttpResponseMessage ReturnMultipleSetCookieHeaders()
        {
            HttpResponseMessage resp = new HttpResponseMessage(HttpStatusCode.OK);
            resp.Headers.Add("Set-Cookie", "cookie1");
            resp.Headers.Add("Set-Cookie", "cookie2");
            return resp;
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/ActionAttributesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    [CLSCompliant(false)]
    public class ActionAttributesTest
    {
        [Theory]
        [InlineData("GET", "ActionAttributeTest/RetriveUsers", "RetriveUsers")]
        [InlineData("POST", "ActionAttributeTest/AddUsers/1", "AddUsers")]
        [InlineData("PUT", "ActionAttributeTest/UpdateUsers", "UpdateUsers")]
        [InlineData("DELETE", "ActionAttributeTest/DeleteUsers", "DeleteUsers")]
        [InlineData("PATCH", "ActionAttributeTest/Users?key=2", "Users")]
        [InlineData("HEAD", "ActionAttributeTest/Users?key=3", "Users")]
        public void SelectAction_OnRouteWithActionParameter(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{action}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ActionAttributeTestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("POST", "ActionAttributeTest/RetriveUsers")]
        [InlineData("DELETE", "ActionAttributeTest/RetriveUsers")]
        [InlineData("WHATEVER", "ActionAttributeTest/RetriveUsers")]
        [InlineData("GET", "ActionAttributeTest/UpdateUsers")]
        [InlineData("WHATEVER", "ActionAttributeTest/UpdateUsers")]
        [InlineData("POST", "ActionAttributeTest/DeleteUsers")]
        [InlineData("DELETEME", "ActionAttributeTest/DeleteUsers")]
        public void SelectAction_ThrowsMethodNotSupported_OnRouteWithActionParameter(string httpMethod, string requestUrl)
        {
            string routeUrl = "{controller}/{action}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };
            HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            Type controllerType = typeof(ActionAttributeTestController);
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType);

            var exception = Assert.Throws<HttpResponseException>(() =>
                {
                    HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext);
                });

            Assert.Equal(HttpStatusCode.MethodNotAllowed, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            Assert.Equal("The requested resource does not support http method '" + httpMethod + "'.", ((HttpError)content.Value).Message);
        }

        [Theory]
        [InlineData("POST", "ActionAttributeTest/NonAction")]
        [InlineData("ACTION", "ActionAttributeTest/NonActionWitHttpMethod")]
        [InlineData("GET", "ActionAttributeTest/AddUsers")] // id is required on this action, so url is invalid. 404
        [InlineData("PUT", "ActionAttributeTest/AddUsers")] // id is required on this action, so url is invalid. 404
        [InlineData("WHATEVER", "ActionAttributeTest/AddUsers")] // id is required on this action, so url is invalid. 404
        [InlineData("GET", "ActionAttributeTest/Users")] // key param is required, bad url. 404
        [InlineData("POST", "ActionAttributeTest/Users")] // key param is required, bad url. 404
        [InlineData("PATCHING", "ActionAttributeTest/Users")] // key param is required, bad url. 404
        [InlineData("NonAction", "ActionAttributeTest/NonAction")] // NonAction, 404
        [InlineData("GET", "ActionAttributeTest/NonAction")] // NonAction, 404
        public void SelectAction_ThrowsNotFound_OnRouteWithActionParameter(string httpMethod, string requestUrl)
        {
            string routeUrl = "{controller}/{action}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };
            HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            controllerContext.Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            Type controllerType = typeof(ActionAttributeTestController);
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType);

            var exception = Assert.Throws<HttpResponseException>(() =>
                {
                    HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext);
                });

            Assert.Equal(HttpStatusCode.NotFound, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);

            // Error message might be ApiControllerActionSelector_ActionNameNotFound or ApiControllerActionSelector_ActionNotFound
            string actualMessage = (string)((HttpError)content.Value)["MessageDetail"];
            Assert.StartsWith("No action was found on the controller 'ActionAttributeTestController' that matches", actualMessage);
        }

        [Theory]
        [InlineData("GET", "ActionAttributeTest/", "RetriveUsers")]
        [InlineData("GET", "ActionAttributeTest/3", "RetriveUsers")]
        [InlineData("GET", "ActionAttributeTest/4?ssn=12345", "RetriveUsers")]
        [InlineData("POST", "ActionAttributeTest/1", "AddUsers")]
        [InlineData("PUT", "ActionAttributeTest", "UpdateUsers")]
        [InlineData("PUT", "ActionAttributeTest/4", "UpdateUsers")]
        [InlineData("PUT", "ActionAttributeTest/4?extra=thing", "UpdateUsers")]
        [InlineData("DELETE", "ActionAttributeTest", "DeleteUsers")]
        [InlineData("PATCH", "ActionAttributeTest", "PatchUsers")]
        [InlineData("HEAD", "ActionAttributeTest/", "Head")]
        [InlineData("PATCH", "ActionAttributeTest?key=2", "Users")]
        [InlineData("HEAD", "ActionAttributeTest?key=2", "Users")]
        [InlineData("OPTIONS", "ActionAttributeTest", "Options")]
        [InlineData("PATCH", "ActionAttributeTest/2", "Update")]
        [InlineData("HEAD", "ActionAttributeTest/2", "Ping")]
        [InlineData("OPTIONS", "ActionAttributeTest/2", "Help")]
        public void SelectAction_OnDefaultRoute(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ActionAttributeTestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("CONNECT", "ActionAttributeTest")]
        [InlineData("TRACE", "ActionAttributeTest")]
        [InlineData("NonAction", "ActionAttributeTest/")]
        [InlineData("DENY", "ActionAttributeTest")]
        [InlineData("APP", "ActionAttributeTest")]
        public void SelectAction_ThrowsMethodNotSupported_OnDefaultRoute(string httpMethod, string requestUrl)
        {
            string routeUrl = "{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };
            HttpControllerContext controllerContext = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            Type controllerType = typeof(ActionAttributeTestController);
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType);

            var exception = Assert.Throws<HttpResponseException>(() =>
                {
                    HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(controllerContext);
                });

            Assert.Equal(HttpStatusCode.MethodNotAllowed, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            Assert.Equal("The requested resource does not support http method '" + httpMethod + "'.", ((HttpError)content.Value).Message);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/ActionReachabilityTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class ActionReachabilityTest
    {
        [Theory]
        [InlineData("GET", "Users", HttpStatusCode.OK, "GetUser")]
        [InlineData("UPDATE", "Users", HttpStatusCode.OK, "PutUser")]
        [InlineData("DELETE", "Users", HttpStatusCode.OK, "Remove")]
        [InlineData("OPTIONS", "Users", HttpStatusCode.OK, "Assist")]
        [InlineData("PUT", "Users", HttpStatusCode.OK, "PutUserWithEmptyName")]
        [InlineData("GET", "ParameterTest", HttpStatusCode.OK, "Get(-1)")]
        [InlineData("GET", "ParameterTest?id=2", HttpStatusCode.OK, "Get(2)")]
        [InlineData("POST", "ParameterTest", HttpStatusCode.OK, "POST(null)")]
        [InlineData("POST", "ParameterTest?id=myId", HttpStatusCode.OK, "POST(myId)")]
        [InlineData("Put", "ParameterTest?id=1&value=myvalue", HttpStatusCode.OK, "Put(1, myvalue)")]
        [InlineData("DELETE", "ParameterTest?id=1", HttpStatusCode.NoContent, "")]
        [InlineData("POST", "Users", HttpStatusCode.InternalServerError, "")] // InternalServerError because of ambiguous match, there're multiple POST actions given that every action is POST by default
        [InlineData("POST", "Users/Approve", HttpStatusCode.NotFound, "")] // NotFound because it doesn't match the route
        [InlineData("DELETE", "Users/Remove", HttpStatusCode.NotFound, "")] // NotFound because it doesn't match the route
        [InlineData("POST", "Users/DefaultActionWithEmptyActionName", HttpStatusCode.NotFound, "")] // NotFound because it doesn't match the route
        [InlineData("DELETE", "ParameterTest", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because url is valid, but not for Delete.
        [InlineData("Put", "ParameterTest", HttpStatusCode.MethodNotAllowed, "")] // Put requires 'id' and 'value' as parameters, but url is still valid for other verbs (GET, Delete,Post).
        [InlineData("Put", "ParameterTest?id=1", HttpStatusCode.MethodNotAllowed, "")] // Put requires 'id' and 'value' as parameters, but url is still valid for other verbs (GET,Post).
        public async Task ActionReachability_UsingResourceOrientedRoute(string httpMethod, string requestUrl, HttpStatusCode expectedStatusCode, string expectedActionName)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("REST", "{controller}");
            HttpServer server = new HttpServer(config);
            HttpClient client = new HttpClient(server);
            HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/" + requestUrl);

            HttpResponseMessage response = await client.SendAsync(request);

            Assert.Equal(expectedStatusCode, response.StatusCode);
            if (response.StatusCode == HttpStatusCode.OK)
            {
                Assert.Equal(expectedActionName, await response.Content.ReadAsAsync<string>());
            }
        }

        [Theory]
        [InlineData("GET", "Users/GetUser", HttpStatusCode.OK, "GetUser")]
        [InlineData("POST", "Users/Approve", HttpStatusCode.OK, "Approve")]
        [InlineData("UPDATE", "Users/PutUser", HttpStatusCode.OK, "PutUser")]
        [InlineData("POST", "Users/UpdateUser", HttpStatusCode.OK, "PostUser")]
        [InlineData("PATCH", "Users/ReplaceUser", HttpStatusCode.OK, "DeleteUser")]
        [InlineData("DELETE", "Users/Remove", HttpStatusCode.OK, "Remove")]
        [InlineData("POST", "Users/Reject", HttpStatusCode.OK, "Deny")]
        [InlineData("OPTIONS", "Users/Help", HttpStatusCode.OK, "Assist")]
        [InlineData("GET", "ParameterTest/Get", HttpStatusCode.OK, "Get(-1)")]
        [InlineData("GET", "ParameterTest/Get?id=2", HttpStatusCode.OK, "Get(2)")]
        [InlineData("POST", "ParameterTest/post", HttpStatusCode.OK, "POST(null)")]
        [InlineData("POST", "ParameterTest/post?id=myId", HttpStatusCode.OK, "POST(myId)")]
        [InlineData("Put", "ParameterTest/put?id=1&value=myvalue", HttpStatusCode.OK, "Put(1, myvalue)")]
        [InlineData("DELETE", "ParameterTest/Delete?id=1", HttpStatusCode.NoContent, "")]
        [InlineData("POST", "Users/GetUser", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because the convention implies it's a GET
        [InlineData("GET", "Users", HttpStatusCode.NotFound, "")] // NotFound because it doesn't match the route
        [InlineData("PUT", "Users", HttpStatusCode.NotFound, "")] // NotFound because it doesn't match the route
        [InlineData("PUT", "Users/PutUserWithEmptyName", HttpStatusCode.NotFound, "")] // NotFound because the action has an empty name and it's not reachable through {action}
        [InlineData("POST", "Users/PostUser", HttpStatusCode.NotFound, "")] // NotFound because the action name is renamed to UpdateUser
        [InlineData("GET", "Users/Approve", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because only POST is allowed by default for action that has no HttpMethd declared or implied
        [InlineData("POST", "Users/Remove", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because the action has the attribute HttpDelete
        [InlineData("POST", "Users/DefaultActionWithEmptyActionName", HttpStatusCode.NotFound, "")] // NotFound because the action has an empty name and it's not reachable through {action}
        [InlineData("DELETE", "ParameterTest/Delete", HttpStatusCode.NotFound, "")] // NotFound because Delete requires 'id' as parameter
        [InlineData("Put", "ParameterTest/put", HttpStatusCode.NotFound, "")] // NotFound because Put requires 'id' and 'value' as parameters
        [InlineData("Put", "ParameterTest/put?id=1", HttpStatusCode.NotFound, "")] // NotFound because Put requires 'id' and 'value' as parameters
        public async Task ActionReachability_UsingRpcStyleRoute(string httpMethod, string requestUrl, HttpStatusCode expectedStatusCode, string expectedActionName)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("RPC", "{controller}/{action}");
            HttpServer server = new HttpServer(config);
            HttpClient client = new HttpClient(server);
            HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/" + requestUrl);

            HttpResponseMessage response = await client.SendAsync(request);

            Assert.Equal(expectedStatusCode, response.StatusCode);
            if (response.StatusCode == HttpStatusCode.OK)
            {
                Assert.Equal(expectedActionName, await response.Content.ReadAsAsync<string>());
            }
        }

        [Theory]
        [InlineData("GET", "Users/GetUser", HttpStatusCode.OK, "GetUser")]
        [InlineData("POST", "Users/Approve", HttpStatusCode.OK, "Approve")]
        [InlineData("UPDATE", "Users/PutUser", HttpStatusCode.OK, "PutUser")]
        [InlineData("POST", "Users/UpdateUser", HttpStatusCode.OK, "PostUser")]
        [InlineData("PATCH", "Users/ReplaceUser", HttpStatusCode.OK, "DeleteUser")]
        [InlineData("DELETE", "Users/Remove", HttpStatusCode.OK, "Remove")]
        [InlineData("POST", "Users/Reject", HttpStatusCode.OK, "Deny")]
        [InlineData("OPTIONS", "Users/Help", HttpStatusCode.OK, "Assist")]
        [InlineData("POST", "Users", HttpStatusCode.OK, "DefaultActionWithEmptyActionName")]
        [InlineData("PUT", "Users", HttpStatusCode.OK, "PutUserWithEmptyName")]
        [InlineData("GET", "Users", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because GetUser doesn't have the ActionName="" so it's not reachable
        [InlineData("UPDATE", "Users", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because GetUser doesn't have the ActionName="" so it's not reachable
        [InlineData("DELETE", "Users", HttpStatusCode.MethodNotAllowed, "Remove")] // MethodNotAllowed because GetUser doesn't have the ActionName="" so it's not reachable
        [InlineData("OPTIONS", "Users", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because GetUser doesn't have the ActionName="" so it's not reachable
        [InlineData("PUT", "Users/PutUserWithEmptyName", HttpStatusCode.NotFound, "")] // NotFound because the action has an empty name and it's not reachable through {action}
        [InlineData("POST", "Users/GetUser", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because the convention implies it's a GET
        [InlineData("POST", "Users/PostUser", HttpStatusCode.NotFound, "")] // NotFound because the action name is renamed to UpdateUser
        [InlineData("GET", "Users/Approve", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because only POST is allowed by default for action that has no HttpMethd declared or implied
        [InlineData("POST", "Users/Remove", HttpStatusCode.MethodNotAllowed, "")] // MethodNotAllowed because the action has the attribute HttpDelete
        [InlineData("POST", "Users/DefaultActionWithEmptyActionName", HttpStatusCode.NotFound, "")] // NotFound because the ActionName="" and no HttpMethd is declared or implied
        public async Task ActionReachability_UsingResourceAndRpcStyleRoutes(string httpMethod, string requestUrl, HttpStatusCode expectedStatusCode, string expectedActionName)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Hybrid", "{controller}/{action}", new { action = "" });
            HttpServer server = new HttpServer(config);
            HttpClient client = new HttpClient(server);
            HttpRequestMessage request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/" + requestUrl);

            HttpResponseMessage response = await client.SendAsync(request);

            Assert.Equal(expectedStatusCode, response.StatusCode);
            if (response.StatusCode == HttpStatusCode.OK)
            {
                Assert.Equal(expectedActionName, await response.Content.ReadAsAsync<string>());
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/ApiControllerActionSelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    [CLSCompliant(false)]
    public class ApiControllerActionSelectorTest
    {
        [Theory]
        [InlineData("GET", "Test", "GetUsers")]
        [InlineData("GET", "Test/2", "GetUser")]
        [InlineData("GET", "Test/3?name=mario", "GetUserByNameAndId")]
        [InlineData("GET", "Test/3?name=mario&ssn=123456", "GetUserByNameIdAndSsn")]
        [InlineData("GET", "Test?name=mario&ssn=123456", "GetUserByNameAndSsn")]
        [InlineData("GET", "Test?name=mario&ssn=123456&age=3", "GetUserByNameAgeAndSsn")]
        [InlineData("GET", "Test/5?random=9", "GetUser")]
        [InlineData("Post", "Test", "PostUser")]
        [InlineData("Post", "Test?name=mario&age=10", "PostUserByNameAndAge")]

        // Note: Normally the following would not match DeleteUserByIdAndOptName because it has 'id' and 'age' as parameters while the DeleteUserByIdAndOptName action has 'id' and 'name'.
        // However, because the default value is provided on action parameter 'name', having the 'id' in the request was enough to match the action.
        [InlineData("Delete", "Test/6?age=10", "DeleteUserByIdAndOptName")]
        [InlineData("Delete", "Test", "DeleteUserByOptName")]
        [InlineData("Delete", "Test?name=user", "DeleteUserByOptName")]
        [InlineData("Delete", "Test/6?email=user@test.com", "DeleteUserById_Email_OptName_OptPhone")]
        [InlineData("Delete", "Test/6?email=user@test.com&name=user", "DeleteUserById_Email_OptName_OptPhone")]
        [InlineData("Delete", "Test/6?email=user@test.com&name=user&phone=123456789", "DeleteUserById_Email_OptName_OptPhone")]
        [InlineData("Delete", "Test/6?email=user@test.com&height=1.8", "DeleteUserById_Email_Height_OptName_OptPhone")]
        [InlineData("Delete", "Test/6?email=user@test.com&height=1.8&name=user", "DeleteUserById_Email_Height_OptName_OptPhone")]
        [InlineData("Delete", "Test/6?email=user@test.com&height=1.8&name=user&phone=12345678", "DeleteUserById_Email_Height_OptName_OptPhone")]
        [InlineData("Head", "Test/6", "Head_Id_OptSize_OptIndex")]
        [InlineData("Head", "Test/6?size=2", "Head_Id_OptSize_OptIndex")]
        [InlineData("Head", "Test/6?index=2", "Head_Id_OptSize_OptIndex")]
        [InlineData("Head", "Test/6?index=2&size=10", "Head_Id_OptSize_OptIndex")]
        [InlineData("Head", "Test/6?index=2&otherParameter=10", "Head_Id_OptSize_OptIndex")]
        [InlineData("Head", "Test/6?otherQueryParameter=1234", "Head_Id_OptSize_OptIndex")]
        [InlineData("Head", "Test", "Head")]
        [InlineData("Head", "Test?otherParam=2", "Head")]
        [InlineData("Head", "Test?index=2&size=10", "Head")]
        public void Route_Parameters_Default(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "Test", "GetUsers")]
        [InlineData("GET", "Test/2", "GetUsersByName")]
        [InlineData("GET", "Test/luigi?ssn=123456", "GetUserByNameAndSsn")]
        [InlineData("GET", "Test/luigi?ssn=123456&id=2&ssn=12345", "GetUserByNameIdAndSsn")]
        [InlineData("GET", "Test?age=10&ssn=123456", "GetUsers")]
        [InlineData("GET", "Test?id=3&ssn=123456&name=luigi", "GetUserByNameIdAndSsn")]
        [InlineData("POST", "Test/luigi?age=20", "PostUserByNameAndAge")]
        public void Route_Parameters_Non_Id(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{name}";
            object routeDefault = new { name = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "Test/3?NAME=mario", "GetUserByNameAndId")]
        [InlineData("GET", "Test/3?name=mario&SSN=123456", "GetUserByNameIdAndSsn")]
        [InlineData("GET", "Test?nAmE=mario&ssn=123456&AgE=3", "GetUserByNameAgeAndSsn")]
        [InlineData("Delete", "Test/6?AGe=10", "DeleteUserByIdAndOptName")]
        public void Route_Parameters_Casing(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{ID}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "Test/GetUsers", "GetUsers")]
        [InlineData("GET", "Test/GetUser/7", "GetUser")]
        [InlineData("GET", "Test/GetUser?id=3", "GetUser")]
        [InlineData("GET", "Test/GetUser/4?id=3", "GetUser")]
        [InlineData("GET", "Test/GetUserByNameAgeAndSsn?name=user&age=90&ssn=123456789", "GetUserByNameAgeAndSsn")]
        [InlineData("GET", "Test/GetUserByNameAndSsn?name=user&ssn=123456789", "GetUserByNameAndSsn")]
        [InlineData("POST", "Test/PostUserByNameAndAddress?name=user", "PostUserByNameAndAddress")]
        public void Route_Action(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{action}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "Test/getusers", "GetUsers")]
        [InlineData("GET", "Test/getuseR/1", "GetUser")]
        [InlineData("GET", "Test/Getuser?iD=3", "GetUser")]
        [InlineData("GET", "Test/GetUser/4?Id=3", "GetUser")]
        [InlineData("GET", "Test/GetUserByNameAgeandSsn?name=user&age=90&ssn=123456789", "GetUserByNameAgeAndSsn")]
        [InlineData("GET", "Test/getUserByNameAndSsn?name=user&ssn=123456789", "GetUserByNameAndSsn")]
        [InlineData("POST", "Test/PostUserByNameAndAddress?name=user", "PostUserByNameAndAddress")]
        public void Route_Action_Name_Casing(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{action}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "Test", "GetUsers")]
        [InlineData("GET", "Test/?name=peach", "GetUsersByName")]
        [InlineData("GET", "Test?name=peach", "GetUsersByName")]
        [InlineData("GET", "Test?name=peach&ssn=123456", "GetUserByNameAndSsn")]
        [InlineData("GET", "Test?name=peach&ssn=123456&age=3", "GetUserByNameAgeAndSsn")]
        public void Route_No_Action(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}";

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "ParameterAttribute/2", "GetUser")]
        [InlineData("GET", "ParameterAttribute?id=2", "GetUser")]
        [InlineData("GET", "ParameterAttribute?myId=2", "GetUserByMyId")]
        [InlineData("POST", "ParameterAttribute/3?name=user", "PostUserNameFromUri")]
        [InlineData("POST", "ParameterAttribute/3", "PostUserNameFromBody")]
        [InlineData("DELETE", "ParameterAttribute/3?name=user", "DeleteUserWithNullableIdAndName")]
        [InlineData("DELETE", "ParameterAttribute?address=userStreet", "DeleteUser")]
        public void ModelBindingParameterAttribute_AreAppliedWhenSelectingActions(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "ParameterAttribute", typeof(ParameterAttributeController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "notActionParameterValue1/Test", "GetUsers")]
        [InlineData("GET", "notActionParameterValue2/Test/2", "GetUser")]
        [InlineData("GET", "notActionParameterValue1/Test?randomQueryVariable=val1", "GetUsers")]
        [InlineData("GET", "notActionParameterValue2/Test/2?randomQueryVariable=val2", "GetUser")]
        public void ActionsThatHaveSubsetOfRouteParameters_AreConsideredForSelection(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{notActionParameter}/{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Fact]
        public void RequestToAmbiguousAction_OnDefaultRoute()
        {
            string routeUrl = "{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };
            string httpMethod = "Post";
            string requestUrl = "Test?name=mario";

            // This would result in ambiguous match because complex parameter is not considered for matching.
            // Therefore, PostUserByNameAndAddress(string name, Address address) would conflicts with PostUserByName(string name)
            Assert.Throws<InvalidOperationException>(() =>
                {
                    HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
                    context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
                    HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);
                });
        }

        [Fact]
        public void RequestToActionWithNotSupportedHttpMethod_OnRouteWithAction()
        {
            string routeUrl = "{controller}/{action}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };
            string requestUrl = "Test/GetUsers";
            string httpMethod = "POST";

            var exception = Assert.Throws<HttpResponseException>(() =>
            {
                HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
                context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
                HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);
            });

            Assert.Equal(HttpStatusCode.MethodNotAllowed, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            AssertAllowedHeaders(exception.Response, HttpMethod.Get);
            Assert.Equal("The requested resource does not support http method 'POST'.", ((HttpError)content.Value).Message);
        }

        [Fact]
        public void RequestToActionWith_HttpMethodDefinedByAttributeAndActionName()
        {
            string routeUrl = "{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };
            string requestUrl = "Test";
            string httpMethod = "PATCH";

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal("PutUser", descriptor.ActionName);

            // When you have the HttpMethod attribute, the convention should not be applied.
            httpMethod = "PUT";
            var exception = Assert.Throws<HttpResponseException>(() =>
            {
                context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
                context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
                ApiControllerHelper.SelectAction(context);
            });

            Assert.Equal(HttpStatusCode.MethodNotAllowed, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            Assert.Equal("The requested resource does not support http method 'PUT'.", ((HttpError)content.Value).Message);
            AssertAllowedHeaders(exception.Response, HttpMethod.Get, new HttpMethod("PATCH"), HttpMethod.Post, HttpMethod.Delete, HttpMethod.Head);
        }

        // Verify response has all the methods in its Allow header. values are unsorted.
        private void AssertAllowedHeaders(HttpResponseMessage response, params HttpMethod[] allowedMethods)
        {
            foreach (var method in allowedMethods)
            {
                Assert.Contains(method.ToString(), response.Content.Headers.Allow);
            }
            Assert.Equal(allowedMethods.Length, response.Content.Headers.Allow.Count);
        }

        [Theory]
        [InlineData("GET", "Test", "GetUsers")]
        [InlineData("GET", "Test/2", "GetUser")]
        [InlineData("GET", "Test/3?name=mario", "GetUserByNameAndId")]
        [InlineData("GET", "Test/3?name=mario&ssn=123456", "GetUserByNameIdAndSsn")]
        [InlineData("GET", "Test?name=mario&ssn=123456", "GetUserByNameAndSsn")]
        [InlineData("GET", "Test?name=mario&ssn=123456&age=3", "GetUserByNameAgeAndSsn")]
        [InlineData("GET", "Test/5?random=9", "GetUser")]
        public void SelectionBasedOnParameter_IsNotAffectedBy_AddingGlobalValueProvider(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}/{id}";
            object routeDefault = new { id = RouteParameter.Optional };

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl, routeDefault);
            context.Configuration.Services.Add(typeof(ValueProviderFactory), new HeaderValueProviderFactory());
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "test", typeof(TestController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }

        [Theory]
        [InlineData("GET", "Test", "Get")]
        [InlineData("GET", "Test?scope=global", "GetWithEnumParameter")]
        [InlineData("GET", "Test?level=off&kind=trace", "GetWithTwoEnumParameters")]
        [InlineData("GET", "Test?level=", "GetWithNullableEnumParameter")]
        public void SelectAction_ReturnsActionDescriptor_ForEnumParameterOverloads(string httpMethod, string requestUrl, string expectedActionName)
        {
            string routeUrl = "{controller}";

            HttpControllerContext context = ApiControllerHelper.CreateControllerContext(httpMethod, requestUrl, routeUrl);
            context.ControllerDescriptor = new HttpControllerDescriptor(context.Configuration, "EnumParameterOverloadsController", typeof(EnumParameterOverloadsController));
            HttpActionDescriptor descriptor = ApiControllerHelper.SelectAction(context);

            Assert.Equal(expectedActionName, descriptor.ActionName);
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/ActionAttributeTestController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    public class ActionAttributeTestController : ApiController
    {
        [HttpGet]
        public void RetriveUsers() { }

        [HttpPost]
        public void AddUsers(int id) { }

        [HttpPut]
        public void UpdateUsers(User user) { }

        [HttpDelete]
        [ActionName("DeleteUsers")]
        public void RemoveUsers(string name = null) { }

        [HttpOptions]
        public void Help(int id) { }

        [HttpHead]
        public void Ping(int id) { }

        [HttpPatch]
        public void Update(int id) { }

        [AcceptVerbs("PATCH", "HEAD")]
        [CLSCompliant(false)]
        public void Users(double key) { }

        [NonAction]
        public void NonAction() { }

        [NonAction]
        [AcceptVerbs("ACTION")]
        public void NonActionWitHttpMethod() { }

        public void Options() { }

        public void Head() { }

        public void PatchUsers() { }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/EnumParameterOverloadsController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Filters;
using System.Web.Http.Tracing;

namespace System.Web.Http
{
    public class EnumParameterOverloadsController : ApiController
    {
        public IEnumerable<string> Get()
        {
            return new string[] { "get" };
        }

        public FilterScope GetWithEnumParameter(FilterScope scope)
        {
            return scope;
        }

        public string GetWithTwoEnumParameters([FromUri]TraceLevel level, TraceKind kind)
        {
            return level.ToString() + kind.ToString();
        }

        public string GetWithNullableEnumParameter(TraceLevel? level)
        {
            return level.ToString();
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/HeaderValueProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using System.Web.Http.ValueProviders;
namespace System.Web.Http
{
    public class HeaderValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(HttpActionContext actionContext)
        {
            return new HeaderValueProvider();
        }
    }

    public class HeaderValueProvider : IValueProvider
    {
        public bool ContainsPrefix(string prefix)
        {
            return false;
        }

        public ValueProviderResult GetValue(string key)
        {
            return null;
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/ParameterAttributeController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http
{
    public class ParameterAttributeController : ApiController
    {
        public User GetUserByMyId(int myId) { return null; }
        public User GetUser([FromUri(Name = "id")] int myId) { return null; }
        public List<User> PostUserNameFromUri(int id, [FromUri]string name) { return null; }
        public List<User> PostUserNameFromBody(int id, [FromBody] string name) { return null; }
        public void DeleteUserWithNullableIdAndName(int? id, string name) { }
        public void DeleteUser(string address) { }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/ParameterTestController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    public class ParameterTestController : ApiController
    {
        public void Delete(int id)
        {
        }

        public string Get(int id = -1)
        {
            return String.Format("Get({0})", id);
        }

        public string POST(string id = null)
        {
            return String.Format("POST({0})", id ?? "null");
        }

        public string Put(int id, string value)
        {
            return String.Format("Put({0}, {1})", id, value);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/RegularConfigController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Description;

namespace System.Web.Http
{
    public class RegularConfigController : ApiController
    {
        public int GetFormattersCount_ControllerConfig()
        {
            return Configuration.Formatters.Count;
        }

        public int GetParameterRulesCount_ControllerConfig()
        {
            return Configuration.ParameterBindingRules.Count;
        }

        public int GetServicesCount_ControllerConfig()
        {
            return Configuration.Services.GetService(typeof(IDocumentationProvider)) == null ? 0 : 1;
        }

        public int GetFormattersCount_RequestConfig()
        {
            return Request.GetConfiguration().Formatters.Count;
        }

        public int GetParameterRulesCount_RequestConfig()
        {
            return Request.GetConfiguration().ParameterBindingRules.Count;
        }

        public int GetServicesCount_RequestConfig()
        {
            return Request.GetConfiguration().Services.GetService(typeof(IDocumentationProvider)) == null ? 0 : 1;
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/SpecialConfigController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.ApiExplorer;
using System.Web.Http.Controllers;
using System.Web.Http.Description;

namespace System.Web.Http
{
    [ControllerConfigAttribute]
    public class SpecialConfigController : ApiController
    {
        public int GetFormattersCount_ControllerConfig()
        {
            return Configuration.Formatters.Count;
        }

        public int GetParameterRulesCount_ControllerConfig()
        {
            return Configuration.ParameterBindingRules.Count;
        }

        public int GetServicesCount_ControllerConfig()
        {
            return Configuration.Services.GetService(typeof(IDocumentationProvider)) == null ? 0 : 1;
        }

        public int GetFormattersCount_RequestConfig()
        {
            return Request.GetConfiguration().Formatters.Count;
        }

        public int GetParameterRulesCount_RequestConfig()
        {
            return Request.GetConfiguration().ParameterBindingRules.Count;
        }

        public int GetServicesCount_RequestConfig()
        {
            return Request.GetConfiguration().Services.GetService(typeof(IDocumentationProvider)) == null ? 0 : 1;
        }

        private class ControllerConfigAttribute : Attribute, IControllerConfiguration
        {
            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
            {
                controllerSettings.Formatters.Clear();
                controllerSettings.Formatters.Add(new XmlMediaTypeFormatter());

                controllerSettings.ParameterBindingRules.Clear();

                controllerSettings.Services.Replace(typeof(IDocumentationProvider), new AttributeDocumentationProvider());
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/TestController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http
{
    public class TestController : ApiController
    {
        public User GetUser(int id) { return null; }
        public List<User> GetUsers() { return null; }

        public List<User> GetUsersByName(string name) { return null; }

        [AcceptVerbs("PATCH")]
        public void PutUser(User user) { }

        public User GetUserByNameAndId(string name, int id) { return null; }
        public User GetUserByNameAndAge(string name, int age) { return null; }
        public User GetUserByNameAgeAndSsn(string name, int age, int ssn) { return null; }
        public User GetUserByNameIdAndSsn(string name, int id, int ssn) { return null; }
        public User GetUserByNameAndSsn(string name, int ssn) { return null; }
        public User PostUser(User user) { return null; }
        public User PostUserByNameAndAge(string name, int age) { return null; }
        public User PostUserByName(string name) { return null; }
        public User PostUserByNameAndAddress(string name, UserAddress address) { return null; }
        public User DeleteUserByOptName(string name = null) { return null; }
        public User DeleteUserByIdAndOptName(int id, string name = "DefaultName") { return null; }
        public User DeleteUserByIdNameAndAge(int id, string name, int age) { return null; }
        public User DeleteUserById_Email_OptName_OptPhone(int id, string email, string name = null, int phone = 0) { return null; }
        public User DeleteUserById_Email_Height_OptName_OptPhone(int id, string email, double height, string name = "DefaultName", int? phone = null) { return null; }
        public void Head_Id_OptSize_OptIndex(int id, int size = 10, int index = 0) { }
        public void Head() { }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/User.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Web.Http
{
    public class User
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/UserAddress.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Web.Http
{
    public class UserAddress
    {
        public string Street;
        public int ZipCode;
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/UsersController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    public class UsersController : ApiController
    {
        // Undecorated action, following convention
        public string GetUser() { return "GetUser"; }

        // Undecorated action, not following conventions
        public string Approve() { return "Approve"; }

        // Action decorated with Verb only, following conventions
        [AcceptVerbs("UPDATE")]
        public string PutUser() { return "PutUser"; }

        // Action decorated with Name = "" only, following conventions, not reachable by {action}
        [ActionName("")]
        public string PutUserWithEmptyName() { return "PutUserWithEmptyName"; }

        // Action decorated with Name = "" only, not following conventions, it's a POST by default and not reachable by {action}
        [ActionName("")]
        public string DefaultActionWithEmptyActionName() { return "DefaultActionWithEmptyActionName"; }

        // Action decorated with Name only, following conventions
        [ActionName("UpdateUser")]
        public string PostUser() { return "PostUser"; }

        // Action decorated with both, following conventions
        [AcceptVerbs("PATCH")]
        [ActionName("ReplaceUser")]
        public string DeleteUser() { return "DeleteUser"; }

        // Action decorated with Verb only, not following conventions
        [HttpDelete]
        public string Remove() { return "Remove"; }

        // Action decorated with Name only, not following conventions
        [ActionName("Reject")]
        public string Deny() { return "Deny"; }

        // Action decorated with both, not following conventions
        [AcceptVerbs("OPTIONS")]
        [ActionName("Help")]
        public string Assist() { return "Assist"; }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Apis/ValuesController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http
{
    /// <summary>
    /// This controller is a clone from the standard WebApi project template
    /// </summary>
    public class ValuesController : ApiController
    {
        // GET api/values
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        // GET api/values/5
        public string Get(int id)
        {
            return "value";
        }

        // POST api/values
        public void Post(string value = null)
        {
        }

        // PUT api/values/5
        public void Put(int id, string value)
        {
        }

        // DELETE api/values/5
        public void Delete(int id)
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/ControllerConfigurationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class ControllerConfigurationTest
    {
        [Theory]
        [InlineData("SpecialConfig/GetFormattersCount_ControllerConfig", 1)]
        [InlineData("RegularConfig/GetFormattersCount_ControllerConfig", 4)]
        [InlineData("SpecialConfig/GetParameterRulesCount_ControllerConfig", 0)]
        [InlineData("RegularConfig/GetParameterRulesCount_ControllerConfig", 3)]
        [InlineData("SpecialConfig/GetServicesCount_ControllerConfig", 1)]
        [InlineData("RegularConfig/GetServicesCount_ControllerConfig", 0)]
        [InlineData("SpecialConfig/GetFormattersCount_RequestConfig", 1)]
        [InlineData("RegularConfig/GetFormattersCount_RequestConfig", 4)]
        [InlineData("SpecialConfig/GetParameterRulesCount_RequestConfig", 0)]
        [InlineData("RegularConfig/GetParameterRulesCount_RequestConfig", 3)]
        [InlineData("SpecialConfig/GetServicesCount_RequestConfig", 1)]
        [InlineData("RegularConfig/GetServicesCount_RequestConfig", 0)]
        public async Task ControllerConfigurationSettings_ArePropagatedTo_ControllerAndRequest(string requestUrl, int count)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{action}");
            HttpServer server = new HttpServer(config);
            HttpClient client = new HttpClient(server);
            HttpResponseMessage response = await client.GetAsync("http://localhost/" + requestUrl);

            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(count, await response.Content.ReadAsAsync<int>());
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Controllers/Helpers/ApiControllerHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;

namespace System.Web.Http
{
    public class ApiControllerHelper
    {
        public static HttpActionDescriptor SelectAction(HttpControllerContext controllerContext)
        {
            ApiControllerActionSelector selector = new ApiControllerActionSelector();
            HttpActionDescriptor descriptor = selector.SelectAction(controllerContext);
            return descriptor;
        }

        public static HttpControllerContext CreateControllerContext(string httpMethod, string requestUrl, string routeUrl, object routeDefault = null)
        {
            string baseAddress = "http://localhost/";
            HttpConfiguration config = new HttpConfiguration();
            HttpRoute route = routeDefault != null ? new HttpRoute(routeUrl, new HttpRouteValueDictionary(routeDefault)) : new HttpRoute(routeUrl);
            config.Routes.Add("test", route);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethodHelper.GetHttpMethod(httpMethod), baseAddress + requestUrl);

            IHttpRouteData routeData = config.Routes.GetRouteData(request);
            if (routeData == null)
            {
                throw new InvalidOperationException("Could not dispatch to controller based on the route.");
            }

            RemoveOptionalRoutingParameters(routeData.Values);

            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(config, routeData, request);
            return controllerContext;
        }

        private static void RemoveOptionalRoutingParameters(IDictionary<string, object> routeValueDictionary)
        {
            // Get all keys for which the corresponding value is 'Optional'.
            // ToArray() necessary so that we don't manipulate the dictionary while enumerating.
            string[] matchingKeys = (from entry in routeValueDictionary
                                     where entry.Value == RouteParameter.Optional
                                     select entry.Key).ToArray();

            foreach (string key in matchingKeys)
            {
                routeValueDictionary.Remove(key);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Dispatcher/CustomHttpControllerTypeResolverTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Dispatcher
{
    public class CustomControllerTypeResolverTest : HttpServerTestBase
    {
        internal static readonly string ExpectedContent = "Hello World!";

        public CustomControllerTypeResolverTest()
            : base("http://localhost/")
        {
        }

        protected override void ApplyConfiguration(HttpConfiguration configuration)
        {
            // Add default route
            configuration.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );

            // Set our own assembly resolver where we add the assemblies we need
            CustomControllerTypeResolver customHttpControllerTypeResolver = new CustomControllerTypeResolver();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), customHttpControllerTypeResolver);
        }

        [Fact]
        public async Task CustomControllerTypeResolver_ReplacesControllerTypeAndNameConvention()
        {
            // Arrange
            string address = BaseAddress + "api/custominternal";

            // Act
            HttpResponseMessage response = await Client.GetAsync(address);
            string content = await response.Content.ReadAsStringAsync();

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(ExpectedContent, content);
        }
    }

    internal class CustomControllerTypeResolver : IHttpControllerTypeResolver
    {
        public ICollection<Type> GetControllerTypes(IAssembliesResolver assembliesResolver)
        {
            return new List<Type> { typeof(CustomInternalController) };
        }
    }

    /// <summary>
    /// Test controller which is declared internal so wouldn't not get picked up by
    /// <see cref="DefaultHttpControllerTypeResolver"/>.
    /// </summary>
    internal class CustomInternalController : ApiController
    {
        public HttpResponseMessage Get()
        {
            HttpResponseMessage response = Request.CreateResponse();
            response.Content = new StringContent(CustomControllerTypeResolverTest.ExpectedContent);
            return response;
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ExceptionHandling/DuplicateControllers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http;

namespace System.Web.Http
{
    public class DuplicateController : ApiController
    {
        public string GetAction()
        {
            return "dup";
        }
    }
}

namespace System.Web.Http2
{
    public class DuplicateController : ApiController
    {
        public string GetAction()
        {
            return "dup2";
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ExceptionHandling/ExceptionController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;

namespace System.Web.Http
{
    public class ExceptionController : ApiController
    {
        public static string ResponseExceptionHeaderKey = "responseExceptionStatusCode";

        public HttpResponseMessage Unavailable()
        {
            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable));
        }

        public Task<HttpResponseMessage> AsyncUnavailable()
        {
            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable));
        }

        public Task<HttpResponseMessage> AsyncUnavailableDelegate()
        {
            return Task.Factory.StartNew<HttpResponseMessage>(() => { throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.ServiceUnavailable)); });
        }

        public HttpResponseMessage ArgumentNull()
        {
            throw new ArgumentNullException("foo");
        }

        public Task<HttpResponseMessage> AsyncArgumentNull()
        {
            return Task.Factory.StartNew<HttpResponseMessage>(() => { throw new ArgumentNullException("foo"); });
        }

        [HttpGet]
        public string GetException()
        {
            return "foo";
        }

        [HttpGet]
        public string GetString()
        {
            return "bar";
        }

        public T GenericAction<T>() where T : User
        {
            return null;
        }

        [AuthenticationFilterAuthenticateThrows]
        public void AuthenticationFilterAuthenticate() { }

        [AuthenticationFilterAuthenticateResultThrows]
        public void AuthenticationFilterAuthenticateResult() { }

        [AuthenticationFilterChallengeThrows]
        public void AuthenticationFilterChallenge() { }

        [AuthenticationFilterChallengeResultThrows]
        public void AuthenticationFilterChallengeResult() { }

        [AuthorizationFilterThrows]
        public void AuthorizationFilter() { }

        [ActionFilterThrows]
        public void ActionFilter() { }

        [ExceptionFilterThrows]
        public void ExceptionFilter() { throw new ArgumentException("exception"); }

        private class AuthenticationFilterAttribute : Attribute, IAuthenticationFilter
        {
            public virtual Task AuthenticateAsync(HttpAuthenticationContext context,
                CancellationToken cancellationToken)
            {
                return Task.FromResult<object>(null);
            }

            public virtual Task ChallengeAsync(HttpAuthenticationChallengeContext context,
                CancellationToken cancellationToken)
            {
                return Task.FromResult<object>(null);
            }

            public bool AllowMultiple
            {
                get { return false; }
            }
        }

        private class AuthenticationErrorResult : IHttpActionResult
        {
            private readonly HttpActionContext _context;

            public AuthenticationErrorResult(HttpActionContext context)
            {
                Contract.Assert(context != null);
                _context = context;
            }

            public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
            {
                TryThrowHttpResponseException(_context);
                throw new ArgumentException("authentication");
            }
        }

        private class AuthenticationFilterAuthenticateThrows : AuthenticationFilterAttribute
        {
            public override Task AuthenticateAsync(HttpAuthenticationContext context,
                CancellationToken cancellationToken)
            {
                TryThrowHttpResponseException(context.ActionContext);
                throw new ArgumentException("authentication");
            }
        }

        private class AuthenticationFilterAuthenticateResultThrows : AuthenticationFilterAttribute
        {
            public override Task AuthenticateAsync(HttpAuthenticationContext context,
                CancellationToken cancellationToken)
            {
                context.ErrorResult = new AuthenticationErrorResult(context.ActionContext);
                return Task.FromResult<object>(null);
            }
        }

        private class AuthenticationFilterChallengeThrows : AuthenticationFilterAttribute
        {
            public override Task ChallengeAsync(HttpAuthenticationChallengeContext context,
                CancellationToken cancellationToken)
            {
                TryThrowHttpResponseException(context.ActionContext);
                throw new ArgumentException("authentication");
            }
        }

        private class AuthenticationFilterChallengeResultThrows : AuthenticationFilterAttribute
        {
            public override Task ChallengeAsync(HttpAuthenticationChallengeContext context,
                CancellationToken cancellationToken)
            {
                context.Result = new AuthenticationErrorResult(context.ActionContext);
                return Task.FromResult<object>(null);
            }
        }

        private class AuthorizationFilterThrows : AuthorizeAttribute
        {
            public override void OnAuthorization(HttpActionContext actionContext)
            {
                TryThrowHttpResponseException(actionContext);
                throw new ArgumentException("authorization");
            }
        }

        private class ActionFilterThrows : ActionFilterAttribute
        {
            public override void OnActionExecuting(HttpActionContext actionContext)
            {
                TryThrowHttpResponseException(actionContext);
                throw new ArgumentException("action");
            }
        }

        private class ExceptionFilterThrows : ExceptionFilterAttribute
        {
            public override void OnException(HttpActionExecutedContext actionExecutedContext)
            {
                TryThrowHttpResponseException(actionExecutedContext.ActionContext);
                throw actionExecutedContext.Exception;
            }
        }

        private static void TryThrowHttpResponseException(HttpActionContext actionContext)
        {
            IEnumerable<string> values;
            if (actionContext.ControllerContext.Request.Headers.TryGetValues(ResponseExceptionHeaderKey, out values))
            {
                string statusString = values.First() as string;
                if (!String.IsNullOrEmpty(statusString))
                {
                    HttpStatusCode status = (HttpStatusCode)Enum.Parse(typeof(HttpStatusCode), statusString);
                    throw new HttpResponseException(actionContext.Request.CreateResponse(status, "HttpResponseExceptionMessage"));
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ExceptionHandling/ExceptionHandlingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http.Properties;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Web.Http
{
    public class ExceptionHandlingTest
    {
        [Theory]
        [InlineData("Unavailable")]
        [InlineData("AsyncUnavailable")]
        [InlineData("AsyncUnavailableDelegate")]
        public async Task ThrowingHttpResponseException_FromAction_GetsReturnedToClient(string actionName)
        {
            string controllerName = "Exception";
            string requestUrl = String.Format("{0}/{1}/{2}", ScenarioHelper.BaseAddress, controllerName, actionName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                (response) =>
                {
                    Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode);
                    return Task.FromResult(0);
                }
            );
        }

        [Theory]
        [InlineData("ArgumentNull")]
        [InlineData("AsyncArgumentNull")]
        public async Task ThrowingArgumentNullException_FromAction_GetsReturnedToClient(string actionName)
        {
            string controllerName = "Exception";
            string requestUrl = String.Format("{0}/{1}/{2}", ScenarioHelper.BaseAddress, controllerName, actionName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    HttpError exception = await response.Content.ReadAsAsync<HttpError>();
                    Assert.Equal(typeof(ArgumentNullException).FullName, exception["ExceptionType"].ToString());
                }
            );
        }

        [Theory]
        [InlineData("ArgumentNull")]
        [InlineData("AsyncArgumentNull")]
        public async Task ThrowingArgumentNullException_FromAction_GetsReturnedToClientParsedAsJson(string actionName)
        {
            string controllerName = "Exception";
            string requestUrl = String.Format("{0}/{1}/{2}", ScenarioHelper.BaseAddress, controllerName, actionName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    dynamic json = JToken.Parse(await response.Content.ReadAsStringAsync());
                    string result = json.ExceptionType;
                    Assert.Equal(typeof(ArgumentNullException).FullName, result);
                }
            );
        }

        [Theory]
        [InlineData("AuthenticationFilterAuthenticate")]
        [InlineData("AuthenticationFilterAuthenticateResult")]
        [InlineData("AuthenticationFilterChallenge")]
        [InlineData("AuthenticationFilterChallengeResult")]
        [InlineData("AuthorizationFilter")]
        [InlineData("ActionFilter")]
        [InlineData("ExceptionFilter")]
        public async Task ThrowingArgumentException_FromFilter_GetsReturnedToClient(string actionName)
        {
            string controllerName = "Exception";
            string requestUrl = String.Format("{0}/{1}/{2}", ScenarioHelper.BaseAddress, controllerName, actionName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    HttpError exception = await response.Content.ReadAsAsync<HttpError>();
                    Assert.Equal(typeof(ArgumentException).FullName, exception["ExceptionType"].ToString());
                }
            );
        }

        [Theory]
        [InlineData("AuthenticationFilterAuthenticate", HttpStatusCode.Ambiguous)]
        [InlineData("AuthenticationFilterAuthenticateResult", HttpStatusCode.BadGateway)]
        [InlineData("AuthenticationFilterChallenge", HttpStatusCode.BadRequest)]
        [InlineData("AuthenticationFilterChallengeResult", HttpStatusCode.Conflict)]
        [InlineData("AuthorizationFilter", HttpStatusCode.Forbidden)]
        [InlineData("ActionFilter", HttpStatusCode.NotAcceptable)]
        [InlineData("ExceptionFilter", HttpStatusCode.NotImplemented)]
        public async Task ThrowingHttpResponseException_FromFilter_GetsReturnedToClient(string actionName, HttpStatusCode responseExceptionStatusCode)
        {
            string controllerName = "Exception";
            string requestUrl = String.Format("{0}/{1}/{2}", ScenarioHelper.BaseAddress, controllerName, actionName);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, requestUrl);
            request.Headers.Add(ExceptionController.ResponseExceptionHeaderKey, responseExceptionStatusCode.ToString());

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                request,
                async (response) =>
                {
                    Assert.Equal(responseExceptionStatusCode, response.StatusCode);
                    Assert.Equal("HttpResponseExceptionMessage", await response.Content.ReadAsAsync<string>());
                }
            );
        }

        // TODO: add tests that throws from custom model binders

        [Fact]
        public async Task Service_ReturnsNotFound_WhenControllerNameDoesNotExist()
        {
            string controllerName = "randomControllerThatCannotBeFound";
            string requestUrl = String.Format("{0}/{1}", ScenarioHelper.BaseAddress, controllerName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                    var result = await response.Content.ReadAsAsync<HttpError>();
                    Assert.Equal(
                        String.Format(SRResources.DefaultControllerFactory_ControllerNameNotFound, controllerName),
                        result["MessageDetail"]);
                }
            );
        }

        [Fact]
        public async Task Service_ReturnsNotFound_WhenActionNameDoesNotExist()
        {
            string controllerName = "Exception";
            string actionName = "actionNotFound";
            string requestUrl = String.Format("{0}/{1}/{2}", ScenarioHelper.BaseAddress, controllerName, actionName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                    var result = await response.Content.ReadAsAsync<HttpError>();
                    Assert.Equal(
                        String.Format(SRResources.ApiControllerActionSelector_ActionNameNotFound, controllerName, actionName),
                        result["MessageDetail"]);
                }
            );
        }

        [Fact]
        public async Task Service_ReturnsMethodNotAllowed_WhenActionsDoesNotSupportTheRequestHttpMethod()
        {
            string controllerName = "Exception";
            string actionName = "GetString";
            HttpMethod requestMethod = HttpMethod.Post;
            string requestUrl = String.Format("{0}/{1}/{2}", ScenarioHelper.BaseAddress, controllerName, actionName);
            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                new HttpRequestMessage(requestMethod, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.MethodNotAllowed, response.StatusCode);
                    var result = await response.Content.ReadAsAsync<HttpError>();
                    Assert.Equal(
                        String.Format(SRResources.ApiControllerActionSelector_HttpMethodNotSupported, requestMethod.Method),
                        result.Message);
                }
            );
        }

        [Fact]
        public async Task Service_ReturnsInternalServerError_WhenMultipleActionsAreFound()
        {
            string controllerName = "Exception";
            string requestUrl = String.Format("{0}/{1}", ScenarioHelper.BaseAddress, controllerName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    var result = await response.Content.ReadAsAsync<HttpError>();
                    Assert.Contains(
                        String.Format(SRResources.ApiControllerActionSelector_AmbiguousMatch, String.Empty),
                        result["ExceptionMessage"] as string);
                }
            );
        }

        [Fact]
        public async Task Service_ReturnsInternalServerError_WhenMultipleControllersAreFound()
        {
            string controllerName = "Duplicate";
            string requestUrl = String.Format("{0}/{1}", ScenarioHelper.BaseAddress, controllerName);

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "",
                new HttpRequestMessage(HttpMethod.Post, requestUrl),
                async (response) =>
                {
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    var result = await response.Content.ReadAsAsync<HttpError>();
                    Assert.Contains(
                        String.Format(SRResources.DefaultControllerFactory_ControllerNameAmbiguous_WithRouteTemplate, controllerName, "{controller}", String.Empty, Environment.NewLine),
                        result["ExceptionMessage"] as string);
                }
            );
        }

        [Fact]
        public async Task GenericMethod_Throws_InvalidOperationException()
        {
            HttpConfiguration config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
            config.Routes.MapHttpRoute("Default", "Exception/{action}", new { controller = "Exception" });
            HttpServer server = new HttpServer(config);
            HttpClient client = new HttpClient(server);

            // Ensure that the behavior is repeatable and other action is still callable after the error
            for (int i = 0; i < 10; i++)
            {
                // Make sure other action can be called
                HttpResponseMessage response = await client.GetAsync("http://localhost/Exception/GetString");
                Assert.True(response.IsSuccessStatusCode,
                    String.Format("Successful status code was expected but got '{0}' instead. Error: {1}", response.StatusCode, await response.Content.ReadAsStringAsync()));

                // Make a request to generic method and verify the exception
                response = await client.PostAsync("http://localhost/Exception/GenericAction", null);
                Type controllerType = typeof(ExceptionController);
                HttpError exception = await response.Content.ReadAsAsync<HttpError>();
                Assert.Equal(typeof(InvalidOperationException).FullName, exception["ExceptionType"]);
                Assert.Equal(
                    String.Format(
                        SRResources.ReflectedHttpActionDescriptor_CannotCallOpenGenericMethods,
                        controllerType.GetMethod("GenericAction"),
                        controllerType.FullName),
                    exception["ExceptionMessage"]);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ExceptionHandling/HttpResponseExceptionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using Microsoft.TestCommon;

namespace System.Web.Http.ExceptionHandling
{
    public class HttpResponseExceptionTest
    {
        [Theory]
        [InlineData("DoNotThrow")]
        [InlineData("ActionMethod")]
        // TODO : 332683 - HttpResponseExceptions in message handlers
        //[InlineData("RequestMessageHandler")]
        //[InlineData("ResponseMessageHandler")]
        [InlineData("RequestAuthorization")]
        [InlineData("AuthenticationAuthenticate")]
        [InlineData("AuthenticationChallenge")]
        [InlineData("BeforeActionExecuted")]
        [InlineData("AfterActionExecuted")]
        [InlineData("ContentNegotiatorNegotiate")]
        [InlineData("ActionMethodAndExceptionFilter")]
        [InlineData("MediaTypeFormatterReadFromStreamAsync")]
        public async Task HttpResponseExceptionWithExplicitStatusCode(string throwAt)
        {
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(ScenarioHelper.BaseAddress + "/ExceptionTests/ReturnString");
            request.Method = HttpMethod.Post;
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            request.Content = new StringContent("\"" + throwAt + "\"", Encoding.UTF8, "application/json");

            await ScenarioHelper.RunTestAsync(
                "ExceptionTests",
                "/{action}",
                request,
                async response =>
                {
                    Assert.NotNull(response.Content);
                    Assert.NotNull(response.Content.Headers.ContentType);
                    Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);

                    if (throwAt == "DoNotThrow")
                    {
                        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                        Assert.Equal("Hello World!",
                            await response.Content.ReadAsAsync<string>(new List<MediaTypeFormatter>() { new JsonMediaTypeFormatter() }));
                    }
                    else
                    {
                        Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                        Assert.Equal(String.Format("Error at {0}", throwAt),
                            await response.Content.ReadAsAsync<string>(new List<MediaTypeFormatter>() { new JsonMediaTypeFormatter() }));
                    }
                },
                config =>
                {
                    config.Services.Replace(typeof(IContentNegotiator), new CustomContentNegotiator(throwAt));

                    config.MessageHandlers.Add(new CustomMessageHandler(throwAt));
                    config.Filters.Add(new CustomActionFilterAttribute(throwAt));
                    config.Filters.Add(new CustomAuthorizationFilterAttribute(throwAt));
                    config.Filters.Add(new CustomAuthenticationFilter(throwAt));
                    config.Filters.Add(new CustomExceptionFilterAttribute(throwAt));
                    config.Formatters.Clear();
                    config.Formatters.Add(new CustomJsonMediaTypeFormatter(throwAt));
                }
            );
        }
    }

    public class CustomMessageHandler : DelegatingHandler
    {
        private string _throwAt;

        public CustomMessageHandler(string throwAt)
        {
            _throwAt = throwAt;
        }

        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "RequestMessageHandler");

            HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
            ExceptionTestsUtility.CheckForThrow(_throwAt, "ResponseMessageHandler");

            return response;
        }
    }

    public class ExceptionTestsController : ApiController
    {
        [HttpPost]
        public string ReturnString([FromBody] string throwAt)
        {
            string message = "Hello World!";

            // check if the test wants to throw from here
            ExceptionTestsUtility.CheckForThrow(throwAt, "ActionMethod");

            // NOTE: this indicates that we want to throw from here & after this gets intercepted
            // by the ExceptionFilter, we want to throw from there too
            ExceptionTestsUtility.CheckForThrow(throwAt, "ActionMethodAndExceptionFilter");

            return message;
        }
    }

    public class CustomAuthenticationFilter : IAuthenticationFilter
    {
        private string _throwAt;

        public CustomAuthenticationFilter(string throwAt)
        {
            _throwAt = throwAt;
        }

        public Task AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "AuthenticationAuthenticate");
            return Task.FromResult<object>(null);
        }

        public Task ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "AuthenticationChallenge");
            return Task.FromResult<object>(null);
        }

        public bool AllowMultiple
        {
            get { return false; }
        }
    }

    public class CustomAuthorizationFilterAttribute : AuthorizationFilterAttribute
    {
        private string _throwAt;

        public CustomAuthorizationFilterAttribute(string throwAt)
        {
            _throwAt = throwAt;
        }

        public override void OnAuthorization(HttpActionContext context)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "RequestAuthorization");
        }
    }

    public class CustomActionFilterAttribute : ActionFilterAttribute
    {
        private string _throwAt;

        public CustomActionFilterAttribute(string throwAt)
        {
            _throwAt = throwAt;
        }

        public override void OnActionExecuting(HttpActionContext context)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "BeforeActionExecuted");
        }

        public override void OnActionExecuted(HttpActionExecutedContext context)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "AfterActionExecuted");
        }
    }

    public class CustomExceptionFilterAttribute : ExceptionFilterAttribute
    {
        private string _throwAt;

        public CustomExceptionFilterAttribute(string throwAt)
        {
            _throwAt = throwAt;
        }

        public override void OnException(HttpActionExecutedContext context)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "ActionMethodAndExceptionFilter");
        }
    }

    public class CustomContentNegotiator : System.Net.Http.Formatting.DefaultContentNegotiator
    {
        private string _throwAt;

        public CustomContentNegotiator(string throwAt)
        {
            _throwAt = throwAt;
        }

        public override ContentNegotiationResult Negotiate(Type type, HttpRequestMessage request, IEnumerable<MediaTypeFormatter> formatters)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "ContentNegotiatorNegotiate");

            return base.Negotiate(type, request, formatters);
        }
    }

    public class CustomJsonMediaTypeFormatter : JsonMediaTypeFormatter
    {
        private string _throwAt;

        public CustomJsonMediaTypeFormatter(string throwAt)
        {
            _throwAt = throwAt;
        }

        public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "MediaTypeFormatterReadFromStreamAsync");

            return base.ReadFromStreamAsync(type, readStream, content, formatterLogger);
        }

        public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content, TransportContext transportContext)
        {
            ExceptionTestsUtility.CheckForThrow(_throwAt, "MediaTypeFormatterWriteToStreamAsync");

            return base.WriteToStreamAsync(type, value, writeStream, content, transportContext);
        }
    }

    public static class ExceptionTestsUtility
    {
        public static void CheckForThrow(string throwAt, string stage)
        {
            if (throwAt == stage)
            {
                HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NotFound)
                {
                    Content = new ObjectContent<string>(String.Format("Error at {0}", stage), new JsonMediaTypeFormatter())
                };

                throw new HttpResponseException(response);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ExceptionHandling/IncludeErrorDetailTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http.Hosting;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Web.Http
{
    public class IncludeErrorDetailTest
    {
        public static TheoryDataSet ThrowingOnActionIncludesErrorDetailData
        {
            get
            {
                return new TheoryDataSet<bool, IncludeErrorDetailPolicy, bool?, bool>()
                {
                    // isLocal, includeErrorDetail, customErrors, expectErrorDetail
                    { true, IncludeErrorDetailPolicy.LocalOnly, true, true },
                    { false, IncludeErrorDetailPolicy.LocalOnly, true, false },
                    { true, IncludeErrorDetailPolicy.LocalOnly, false, true },
                    { false, IncludeErrorDetailPolicy.LocalOnly, false, false },
                    { true, IncludeErrorDetailPolicy.LocalOnly, null, true },
                    { false, IncludeErrorDetailPolicy.LocalOnly, null, false },

                    { true, IncludeErrorDetailPolicy.Always, true, true },
                    { false, IncludeErrorDetailPolicy.Always, true, true },
                    { true, IncludeErrorDetailPolicy.Always, false, true },
                    { false, IncludeErrorDetailPolicy.Always, false, true },
                    { true, IncludeErrorDetailPolicy.Always, null, true },
                    { false, IncludeErrorDetailPolicy.Always, null, true },

                    { true, IncludeErrorDetailPolicy.Never, true, false },
                    { false, IncludeErrorDetailPolicy.Never, true, false },
                    { true, IncludeErrorDetailPolicy.Never, false, false },
                    { false, IncludeErrorDetailPolicy.Never, false, false },
                    { true, IncludeErrorDetailPolicy.Never, null, false },
                    { false, IncludeErrorDetailPolicy.Never, null, false },

                    { true, IncludeErrorDetailPolicy.Default, true, false },
                    { false, IncludeErrorDetailPolicy.Default, true, false },
                    { true, IncludeErrorDetailPolicy.Default, false, true },
                    { false, IncludeErrorDetailPolicy.Default, false, true },
                    { true, IncludeErrorDetailPolicy.Default, null, true },
                    { false, IncludeErrorDetailPolicy.Default, null, false }
                };
            }
        }

        [Theory]
        [PropertyData("ThrowingOnActionIncludesErrorDetailData")]
        public async Task ThrowingOnActionIncludesErrorDetail(bool isLocal, IncludeErrorDetailPolicy includeErrorDetail, bool? customErrors, bool expectErrorDetail)
        {
            string controllerName = "Exception";
            string requestUrl = String.Format("{0}/{1}/{2}", "http://www.foo.com", controllerName, "ArgumentNull");
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post, requestUrl);
            request.Properties[HttpPropertyKeys.IsLocalKey] = new Lazy<bool>(() => isLocal);
            if (customErrors != null)
            {
                request.Properties[HttpPropertyKeys.IncludeErrorDetailKey] = new Lazy<bool>(() => !(bool)customErrors);
            }

            await ScenarioHelper.RunTestAsync(
                controllerName,
                "/{action}",
                request,
                async (response) =>
                {
                    if (expectErrorDetail)
                    {
                        await AssertResponseIncludesErrorDetailAsync(response);
                    }
                    else
                    {
                        await AssertResponseDoesNotIncludeErrorDetailAsync(response);
                    }
                },
                (config) =>
                {
                    config.IncludeErrorDetailPolicy = includeErrorDetail;
                }
            );
        }

        private async Task AssertResponseIncludesErrorDetailAsync(HttpResponseMessage response)
        {
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
            dynamic json = JToken.Parse(await response.Content.ReadAsStringAsync());
            string result = json.ExceptionType;
            Assert.Equal(typeof(ArgumentNullException).FullName, result);
        }

        private async Task AssertResponseDoesNotIncludeErrorDetailAsync(HttpResponseMessage response)
        {
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
            JObject json = JToken.Parse(await response.Content.ReadAsStringAsync()) as JObject;
            Assert.Single(json);
            string errorMessage = ((JValue)json["Message"]).ToString();
            Assert.Equal("An error has occurred.", errorMessage);
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/BodyBindingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http.Properties;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// End to end functional tests for model binding via request body
    /// </summary>
    public class BodyBindingTests : ModelBindingTests
    {
        [Fact]
        [ReplaceCulture]
        public async Task Body_Bad_Input_Receives_Validation_Error()
        {
            // Arrange
            string formUrlEncodedString = "Id=101&Name=testFirstNameTooLong";
            StringContent stringContent = new StringContent(formUrlEncodedString, Encoding.UTF8, "application/x-www-form-urlencoded");

            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + "ModelBinding/PostComplexWithValidation"),
                Method = HttpMethod.Post,
                Content = stringContent,
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Equal("Failed to bind customer.RequiredValue. The errors are:\nErrorMessage: The RequiredValue property is required.\nFailed to bind customer.Name. The errors are:\nErrorMessage: The field Name must be a string with a maximum length of 6.\n",
                await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task Body_Good_Input_Succeed()
        {
            // Arrange
            string formUrlEncodedString = "Id=111&Name=John&RequiredValue=9";
            StringContent stringContent = new StringContent(formUrlEncodedString, Encoding.UTF8, "application/x-www-form-urlencoded");

            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + "ModelBinding/PostComplexWithValidation"),
                Method = HttpMethod.Post,
                Content = stringContent,
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.Equal("111", await response.Content.ReadAsStringAsync());
        }

        [Theory]
        [InlineData("PostWithOptionalBodyParameter")]
        [InlineData("PostWithOptionalBodyParameterAndUriParameter?id=3")]
        public async Task Body_OptionalParameter_Throws(string actionName)
        {
            // Arrange
            StringContent stringContent = new StringContent(@"""string value""", Encoding.UTF8, "application/json");
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + "ModelBinding/" + actionName),
                Method = HttpMethod.Post,
                Content = stringContent,
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);
            HttpError error = await response.Content.ReadAsAsync<HttpError>();

            // Assert
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
            Assert.Equal(String.Format(SRResources.OptionalBodyParameterNotSupported, "value", typeof(FormatterParameterBinding).Name), error["ExceptionMessage"]);
        }

        [Theory]
        [InlineData("application/json")]
        [InlineData(null)]
        public async Task Body_Binds_EmptyContentWithOrWithoutContentTypeHeader(string mediaType)
        {
            // Arrange
            StringContent stringContent = new StringContent(String.Empty);
            stringContent.Headers.ContentType = mediaType != null ? new MediaTypeHeaderValue(mediaType) : null;

            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + "ModelBinding/PostComplexTypeFromBody"),
                Method = HttpMethod.Post,
                Content = stringContent,
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            ModelBindOrder actualItem = await response.Content.ReadAsAsync<ModelBindOrder>();
            Assert.Null(actualItem);
        }

        [Theory]
        [InlineData("PostComplexType", "application/json")]
        [InlineData("PostComplexType", "application/xml")]
        [InlineData("PostComplexTypeFromBody", "application/json")]
        [InlineData("PostComplexTypeFromBody", "application/xml")]
        public async Task Body_Binds_ComplexType_Type_Key_Value_Read(string action, string mediaType)
        {
            // Arrange
            ModelBindOrder expectedItem = new ModelBindOrder()
            {
                ItemName = "Bike",
                Quantity = 1,
                Customer = new ModelBindCustomer { Name = "Fred" }
            };
            var formatter = new MediaTypeFormatterCollection().FindWriter(typeof(ModelBindOrder), new MediaTypeHeaderValue(mediaType));
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new ObjectContent<ModelBindOrder>(expectedItem, formatter),
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}", action)),
                Method = HttpMethod.Post,
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            ModelBindOrder actualItem = await response.Content.ReadAsAsync<ModelBindOrder>();
            Assert.Equal(expectedItem, actualItem, new ModelBindOrderEqualityComparer());
        }

        [Theory]
        [InlineData("PostComplexType", "application/json")]
        [InlineData("PostComplexType", "application/xml")]
        [InlineData("PostComplexTypeFromBody", "application/json")]
        [InlineData("PostComplexTypeFromBody", "application/xml")]
        public async Task Body_Binds_ComplexType_Type_Whole_Body_Read(string action, string mediaType)
        {
            // Arrange
            ModelBindOrder expectedItem = new ModelBindOrder()
            {
                ItemName = "Bike",
                Quantity = 1,
                Customer = new ModelBindCustomer { Name = "Fred" }
            };
            var formatter = new MediaTypeFormatterCollection().FindWriter(typeof(ModelBindOrder), new MediaTypeHeaderValue(mediaType));
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new ObjectContent<ModelBindOrder>(expectedItem, formatter),
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}", action)),
                Method = HttpMethod.Post,
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            ModelBindOrder actualItem = await response.Content.ReadAsAsync<ModelBindOrder>();
            Assert.Equal(expectedItem, actualItem, new ModelBindOrderEqualityComparer());
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/CustomBindingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// End to end functional tests for model binding via custom providers
    /// </summary>
    public class CustomBindingTests : ModelBindingTests
    {
        [Fact]
        public async Task Custom_ValueProvider_Binds_Simple_Types_Get()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}", "GetIntCustom")),
                Method = HttpMethod.Get
            };

            request.Headers.Add("value", "5");

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            string responseString = await response.Content.ReadAsStringAsync();
            Assert.Equal("5", responseString);
        }

    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/DefaultActionValueBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

namespace System.Web.Http.ModelBinding
{
    public class DefaultActionValueBinderTest
    {
        [Fact]
        public async Task BindValuesAsync_Uses_DefaultValues()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("Get") });
            CancellationToken cancellationToken = new CancellationToken();
            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["id"] = 0;
            expectedResult["firstName"] = "DefaultFirstName";
            expectedResult["lastName"] = "DefaultLastName";
            Assert.Equal(expectedResult, context.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_WithObjectContentInRequest_Works()
        {
            // Arrange
            ActionValueItem cust = new ActionValueItem() { FirstName = "FirstName", LastName = "LastName", Id = 1 };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });
            context.ControllerContext.Request = new HttpRequestMessage
            {
                Content = new ObjectContent<ActionValueItem>(cust, new JsonMediaTypeFormatter())
            };
            CancellationToken cancellationToken = new CancellationToken();
            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            var result = context.ActionArguments;
            Assert.Single(result);
            var item = Assert.IsType<ActionValueItem>(result["item"]);
            Assert.Equal(cust.FirstName, item.FirstName);
            Assert.Equal(cust.LastName, item.LastName);
            Assert.Equal(cust.Id, item.Id);
        }

        #region Query Strings

        [Fact]
        public async Task BindValuesAsync_ConvertEmptyString()
        {
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?A1=&A2=&A3=&A4=")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetTestEmptyString") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, CancellationToken.None);

            // Assert
            ConvertEmptyStringContainer arg = (ConvertEmptyStringContainer)actionContext.ActionArguments["x"];

            Assert.NotNull(arg);
            Assert.Equal(String.Empty, arg.A1);
            Assert.Null(arg.A2);
            Assert.Null(arg.A3);
            Assert.Null(arg.A4);
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_Simple_Types()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?id=5&firstName=queryFirstName&lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("Get") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["id"] = 5;
            expectedResult["firstName"] = "queryFirstName";
            expectedResult["lastName"] = "queryLastName";
            Assert.Equal(expectedResult, actionContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_Simple_Types_With_FromUriAttribute()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?id=5&firstName=queryFirstName&lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetFromUri") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["id"] = 5;
            expectedResult["firstName"] = "queryFirstName";
            expectedResult["lastName"] = "queryLastName";
            Assert.Equal(expectedResult, actionContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_Complex_Types()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?id=5&firstName=queryFirstName&lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetItem") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Assert.True(actionContext.ModelState.IsValid);
            KeyValuePair<string, object> actionArgument = Assert.Single(actionContext.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsType<ActionValueItem>(actionArgument.Value);
            Assert.Equal(5, deserializedActionValueItem.Id);
            Assert.Equal("queryFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("queryLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_Post_Complex_Types()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?id=5&firstName=queryFirstName&lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexTypeUri") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Assert.True(actionContext.ModelState.IsValid);
            KeyValuePair<string, object> actionArgument = Assert.Single(actionContext.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsType<ActionValueItem>(actionArgument.Value);
            Assert.Equal(5, deserializedActionValueItem.Id);
            Assert.Equal("queryFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("queryLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_Post_Enumerable_Complex_Types()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?items[0].id=5&items[0].firstName=queryFirstName&items[0].lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostEnumerableUri") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Assert.True(actionContext.ModelState.IsValid);
            KeyValuePair<string, object> keyValuePair = Assert.Single(actionContext.ActionArguments);
            IEnumerable<ActionValueItem> items = Assert.IsAssignableFrom<IEnumerable<ActionValueItem>>(keyValuePair.Value);
            ActionValueItem deserializedActionValueItem = items.First();
            Assert.Equal(5, deserializedActionValueItem.Id);
            Assert.Equal("queryFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("queryLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_Post_Enumerable_Complex_Types_No_Index()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?id=5&firstName=queryFirstName&items.lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostEnumerableUri") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Assert.True(actionContext.ModelState.IsValid);
            KeyValuePair<string, object> keyValuePair = Assert.Single(actionContext.ActionArguments);
            IEnumerable<ActionValueItem> items = Assert.IsAssignableFrom<IEnumerable<ActionValueItem>>(keyValuePair.Value);
            Assert.Empty(items);     // expect unsuccessful bind but proves we don't loop infinitely
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_ComplexType_Using_Prefixes()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?item.id=5&item.firstName=queryFirstName&item.lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetItem") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(actionContext.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsType<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(5, deserializedActionValueItem.Id);
            Assert.Equal("queryFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("queryLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_ComplexType_Using_FromUriAttribute()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?item.id=5&item.firstName=queryFirstName&item.lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetItemFromUri") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(actionContext.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsType<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(5, deserializedActionValueItem.Id);
            Assert.Equal("queryFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("queryLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_Using_Custom_ValueProviderAttribute()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetFromCustom") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["id"] = 99;
            expectedResult["firstName"] = "99";
            expectedResult["lastName"] = "99";
            Assert.Equal(expectedResult, actionContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_Using_Prefix_To_Rename()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?custid=5&first=renamedFirstName&last=renamedLastName")
                    // notice the query string names match the prefixes in GetFromNamed() and not the actual parameter names
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetFromNamed") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["id"] = 5;
            expectedResult["firstName"] = "renamedFirstName";
            expectedResult["lastName"] = "renamedLastName";
            Assert.Equal(expectedResult, actionContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_Query_String_Values_To_Complex_Types_With_Validation_Error()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost?id=100&firstName=queryFirstName&lastName=queryLastName")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetItem") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Assert.False(actionContext.ModelState.IsValid);
        }

        #endregion Query Strings

        #region RouteData

        [Fact]
        public async Task BindValuesAsync_RouteData_Values_To_Simple_Types()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("id", 6);
            route.Values.Add("firstName", "routeFirstName");
            route.Values.Add("lastName", "routeLastName");

            HttpActionContext controllerContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(route, new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("Get") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(controllerContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["id"] = 6;
            expectedResult["firstName"] = "routeFirstName";
            expectedResult["lastName"] = "routeLastName";
            Assert.Equal(expectedResult, controllerContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_RouteData_Values_To_Simple_Types_Using_FromUriAttribute()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("id", 6);
            route.Values.Add("firstName", "routeFirstName");
            route.Values.Add("lastName", "routeLastName");

            HttpActionContext controllerContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(route, new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("Get") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(controllerContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["id"] = 6;
            expectedResult["firstName"] = "routeFirstName";
            expectedResult["lastName"] = "routeLastName";
            Assert.Equal(expectedResult, controllerContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_RouteData_Values_To_Complex_Types()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("id", 6);
            route.Values.Add("firstName", "routeFirstName");
            route.Values.Add("lastName", "routeLastName");

            HttpActionContext controllerContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(route, new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetItem") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(controllerContext, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(controllerContext.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsType<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(6, deserializedActionValueItem.Id);
            Assert.Equal("routeFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("routeLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_RouteData_Values_To_Complex_Types_Using_FromUriAttribute()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("id", 6);
            route.Values.Add("firstName", "routeFirstName");
            route.Values.Add("lastName", "routeLastName");

            HttpActionContext controllerContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(route, new HttpRequestMessage()
                {
                    Method = HttpMethod.Get,
                    RequestUri = new Uri("http://localhost")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetItemFromUri") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(controllerContext, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(controllerContext.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsType<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(6, deserializedActionValueItem.Id);
            Assert.Equal("routeFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("routeLastName", deserializedActionValueItem.LastName);
        }

        #endregion RouteData

        #region ControllerContext
        [Fact]
        public async Task BindValuesAsync_ControllerContext_CancellationToken()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = HttpMethod.Get
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetFromCancellationToken") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(actionContext.ActionArguments);
            Assert.Equal(cancellationToken, keyValuePair.Value);
        }
        #endregion ControllerContext

        #region Body

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_Json()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            string jsonString = "{\"Id\":\"7\",\"FirstName\":\"testFirstName\",\"LastName\":\"testLastName\"}";
            StringContent stringContent = new StringContent(jsonString, Encoding.UTF8, "application/json");

            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsAssignableFrom<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(7, deserializedActionValueItem.Id);
            Assert.Equal("testFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("testLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_Json_With_Validation_Error()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            string jsonString = "{\"Id\":\"100\",\"FirstName\":\"testFirstName\",\"LastName\":\"testLastName\"}";
            StringContent stringContent = new StringContent(jsonString, Encoding.UTF8, "application/json");

            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            Assert.False(context.ModelState.IsValid);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_FormUrlEncoded()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            string formUrlEncodedString = "Id=7&FirstName=testFirstName&LastName=testLastName";
            StringContent stringContent = new StringContent(formUrlEncodedString, Encoding.UTF8, "application/x-www-form-urlencoded");

            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsAssignableFrom<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(7, deserializedActionValueItem.Id);
            Assert.Equal("testFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("testLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_FormUrlEncoded_With_Validation_Error()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            string formUrlEncodedString = "Id=101&FirstName=testFirstName&LastName=testLastName";
            StringContent stringContent = new StringContent(formUrlEncodedString, Encoding.UTF8, "application/x-www-form-urlencoded");

            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            Assert.False(context.ModelState.IsValid);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_Xml()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/xml");
            ActionValueItem item = new ActionValueItem() { Id = 7, FirstName = "testFirstName", LastName = "testLastName" };
            ObjectContent<ActionValueItem> tempContent = new ObjectContent<ActionValueItem>(item, new XmlMediaTypeFormatter());
            StringContent stringContent = new StringContent(await tempContent.ReadAsStringAsync());
            stringContent.Headers.ContentType = mediaType;
            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsAssignableFrom<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(item.Id, deserializedActionValueItem.Id);
            Assert.Equal(item.FirstName, deserializedActionValueItem.FirstName);
            Assert.Equal(item.LastName, deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_Xml_Structural()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/xml");

            // Test sending from a non .NET type (raw xml).
            // The default XML serializer requires that the xml root name matches the C# class name.
            string xmlSource =
                @"<ActionValueItem xmlns='http://schemas.datacontract.org/2004/07/System.Web.Http.ModelBinding' xmlns:i='http://www.w3.org/2001/XMLSchema-instance'>
                      <FirstName>testFirstName</FirstName>
                      <Id>7</Id>
                      <LastName>testLastName</LastName>
                  </ActionValueItem>".Replace('\'', '"');

            StringContent stringContent = new StringContent(xmlSource);
            stringContent.Headers.ContentType = mediaType;
            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsAssignableFrom<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(7, deserializedActionValueItem.Id);
            Assert.Equal("testFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("testLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_Xml_With_Validation_Error()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/xml");
            ActionValueItem item = new ActionValueItem() { Id = 101, FirstName = "testFirstName", LastName = "testLastName" };
            var tempContent = new ObjectContent<ActionValueItem>(item, new XmlMediaTypeFormatter());
            StringContent stringContent = new StringContent(await tempContent.ReadAsStringAsync());
            stringContent.Headers.ContentType = mediaType;
            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            Assert.False(context.ModelState.IsValid);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_NullContent()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage() { Content = null };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, CancellationToken.None);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            object deserializedActionValueItem = keyValuePair.Value;
            Assert.Null(deserializedActionValueItem);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_And_Uri_To_Simple()
        {
            // Arrange
            string jsonString = "{\"Id\":\"7\",\"FirstName\":\"testFirstName\",\"LastName\":\"testLastName\"}";
            StringContent stringContent = new StringContent(jsonString, Encoding.UTF8, "application/json");

            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri("http://localhost/ActionValueController/PostFromBody?id=123"),
                Content = stringContent
            };

            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostFromBodyAndUri") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, CancellationToken.None);

            // Assert
            Assert.Equal(2, context.ActionArguments.Count);
            Assert.Equal(123, context.ActionArguments["id"]);

            ActionValueItem deserializedActionValueItem = Assert.IsAssignableFrom<ActionValueItem>(context.ActionArguments["item"]);
            Assert.Equal(7, deserializedActionValueItem.Id);
            Assert.Equal("testFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("testLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_Using_FromBodyAttribute()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            string jsonString = "{\"Id\":\"7\",\"FirstName\":\"testFirstName\",\"LastName\":\"testLastName\"}";
            StringContent stringContent = new StringContent(jsonString, Encoding.UTF8, "application/json");

            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };

            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostFromBody") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsAssignableFrom<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(7, deserializedActionValueItem.Id);
            Assert.Equal("testFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("testLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_Complex_Type_Using_Formatter_To_Deserialize()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            string jsonString = "{\"Id\":\"7\",\"FirstName\":\"testFirstName\",\"LastName\":\"testLastName\"}";
            StringContent stringContent = new StringContent(jsonString, Encoding.UTF8, "application/json");

            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostComplexType") });
            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            ActionValueItem deserializedActionValueItem = Assert.IsAssignableFrom<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(7, deserializedActionValueItem.Id);
            Assert.Equal("testFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("testLastName", deserializedActionValueItem.LastName);
        }


        [Fact]
        public async Task BindValuesAsync_Body_To_IEnumerable_Complex_Type_Json()
        {
            // ModelBinding will bind T to IEnumerable<T>, but JSON.Net won't. So enclose JSON in [].
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            string jsonString = "[{\"Id\":\"7\",\"FirstName\":\"testFirstName\",\"LastName\":\"testLastName\"}]";
            StringContent stringContent = new StringContent(jsonString, Encoding.UTF8, "application/json");

            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostEnumerable") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            IEnumerable<ActionValueItem> items = Assert.IsAssignableFrom<IEnumerable<ActionValueItem>>(keyValuePair.Value);
            ActionValueItem deserializedActionValueItem = items.First();
            Assert.Equal(7, deserializedActionValueItem.Id);
            Assert.Equal("testFirstName", deserializedActionValueItem.FirstName);
            Assert.Equal("testLastName", deserializedActionValueItem.LastName);
        }

        [Fact]
        public async Task BindValuesAsync_Body_To_JToken()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("application/json");
            ActionValueItem item = new ActionValueItem() { Id = 7, FirstName = "testFirstName", LastName = "testLastName" };
            string json = "{\"a\":123,\"b\":[false,null,12.34]}";
            JToken jt = JToken.Parse(json);
            var tempContent = new ObjectContent<JToken>(jt, new JsonMediaTypeFormatter());
            StringContent stringContent = new StringContent(await tempContent.ReadAsStringAsync());
            stringContent.Headers.ContentType = mediaType;
            HttpRequestMessage request = new HttpRequestMessage() { Content = stringContent };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostJsonValue") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, cancellationToken);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            JToken deserializedJsonValue = Assert.IsAssignableFrom<JToken>(keyValuePair.Value);
            string deserializedJsonAsString = deserializedJsonValue.ToString(Formatting.None);
            Assert.Equal(json, deserializedJsonAsString);
        }

        #endregion Body

        [Fact]
        public async Task BindValuesAsync_FromUriAttribute_DecoratedOn_Type()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = new HttpMethod("Patch"),
                    RequestUri = new Uri("http://localhost?x=123&y=456&data.description=mypoint")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("Patch") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["point"] = new Point { X = 123, Y = 456, Data = new Data { Description = "mypoint" } };
            Assert.Equal(expectedResult, actionContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_ModelBinderAttribute_WithEmptyName()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();
            HttpActionContext actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(new HttpRequestMessage()
                {
                    Method = new HttpMethod("Options"),
                    RequestUri = new Uri("http://localhost?x=123&y=456&data.description=mypoint")
                }),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("Options") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, cancellationToken);

            // Assert
            Dictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["data"] = new Point { X = 123, Y = 456, Data = new Data { Description = "mypoint" } };
            Assert.Equal(expectedResult, actionContext.ActionArguments, new DictionaryEqualityComparer());
        }

        [Fact]
        public async Task BindValuesAsync_Config_BindParameter()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.BindParameter(typeof(Data), new CustomModelBinder());

            HttpRequestMessage request = new HttpRequestMessage()
                {
                    RequestUri = new Uri("http://localhost")
                };

            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(config, request);
            HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext,
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("GetData") });

            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(actionContext, CancellationToken.None);

            // Assert
            Data argData = (Data)actionContext.ActionArguments["data"];
            Assert.NotNull(argData);
            Assert.Equal("testing", argData.Description);
        }

        [Fact]
        public async Task BindValuesAsync_Config_BindParameter_ShouldNotBeAppliedToUnrelatedTypes()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.BindParameter(typeof(Data), new CustomModelBinder());

            ActionValueItem item = new ActionValueItem() { Id = 7, FirstName = "testFirstName", LastName = "testLastName" };
            HttpRequestMessage request = new HttpRequestMessage()
            {
                Content = new ObjectContent(typeof(ActionValueItem), item, config.Formatters.JsonFormatter)
            };
            HttpActionContext context = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(config, request),
                new ReflectedHttpActionDescriptor() { MethodInfo = typeof(ActionValueController).GetMethod("PostItem") });
            DefaultActionValueBinder provider = new DefaultActionValueBinder();

            // Act
            await provider.BindValuesAsync(context, CancellationToken.None);

            // Assert
            KeyValuePair<string, object> keyValuePair = Assert.Single(context.ActionArguments);
            ActionValueItem result = Assert.IsAssignableFrom<ActionValueItem>(keyValuePair.Value);
            Assert.Equal(7, result.Id);
            Assert.Equal("testFirstName", result.FirstName);
            Assert.Equal("testLastName", result.LastName);
        }
    }

    [FromUri]
    public class Point
    {
        public int X { get; set; }
        public int Y { get; set; }
        public Data Data { get; set; }

        public override bool Equals(object obj)
        {
            Point other = obj as Point;
            if (other != null)
            {
                return other.X == X && other.Y == Y && other.Data.Description == other.Data.Description;
            }
            return false;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }

    // Test model binder to bind typeof(Data)
    public class CustomModelBinder : IModelBinder
    {
        public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
        {
            Assert.Equal(typeof(Data), bindingContext.ModelType);
            bindingContext.Model = new Data { Description = "testing" };
            return true;
        }
    }

    public class Data
    {
        public string Description { get; set; }
    }

    public class ActionValueController : ApiController
    {
        public void GetData(Data data)
        {
        }

        public void PostItem(ActionValueItem item)
        {
        }

        // Demonstrates the use of ModelBinderAttribute with empty name
        public void Options([FromUri(Name = "")]Point data) { }

        // Demonstrates complex parameter that has FromUri declared on the type
        public void Patch(Point point) { }

        // Demonstrates parameter that can come from route, query string, or defaults
        public ActionValueItem Get(int id = 0, string firstName = "DefaultFirstName", string lastName = "DefaultLastName")
        {
            return new ActionValueItem() { Id = id, FirstName = firstName, LastName = lastName };
        }

        // Demonstrates an explicit override to obtain parameters from URL
        public ActionValueItem GetFromUri([FromUri] int id = 0,
                                   [FromUri] string firstName = "DefaultFirstName",
                                   [FromUri] string lastName = "DefaultLastName")
        {
            return new ActionValueItem() { Id = id, FirstName = firstName, LastName = lastName };
        }


        // Complex objects default to body. But we can bind from URI with an attribute.
        public ActionValueItem GetItem([FromUri] ActionValueItem item)
        {
            return item;
        }

        // Demonstrates ModelBinding a Item object explicitly from Uri
        public ActionValueItem GetItemFromUri([FromUri] ActionValueItem item)
        {
            return item;
        }

        // Demonstrates use of renaming parameters via name
        public ActionValueItem GetFromNamed([FromUri(Name = "custID")] int id,
                                     [FromUri(Name = "first")] string firstName,
                                     [FromUri(Name = "last")] string lastName)
        {
            return new ActionValueItem() { Id = id, FirstName = firstName, LastName = lastName };
        }


        public void GetTestEmptyString([FromUri] ConvertEmptyStringContainer x)
        {
        }

        // Demonstrates use of custom ValueProvider via attribute
        public ActionValueItem GetFromCustom([ValueProvider(typeof(ActionValueControllerValueProviderFactory), Name = "id")] int id,
                                      [ValueProvider(typeof(ActionValueControllerValueProviderFactory), Name = "customFirstName")] string firstName,
                                      [ValueProvider(typeof(ActionValueControllerValueProviderFactory), Name = "customLastName")] string lastName)
        {
            return new ActionValueItem() { Id = id, FirstName = firstName, LastName = lastName };
        }

        // Demonstrates ModelBinding to the CancellationToken of the current request
        public string GetFromCancellationToken(CancellationToken cancellationToken)
        {
            return cancellationToken.ToString();
        }

        // Demonstrates ModelBinding to the ModelState of the current request
        public string GetFromModelState(ModelState modelState)
        {
            return modelState.ToString();
        }

        // Demonstrates binding to complex type from body
        public ActionValueItem PostComplexType(ActionValueItem item)
        {
            return item;
        }

        // Demonstrates binding to complex type from uri
        public ActionValueItem PostComplexTypeUri([FromUri] ActionValueItem item)
        {
            return item;
        }

        // Demonstrates binding to IEnumerable of complex type from body or Uri
        public ActionValueItem PostEnumerable(IEnumerable<ActionValueItem> items)
        {
            return items.FirstOrDefault();
        }

        // Demonstrates binding to IEnumerable of complex type from body or Uri
        public ActionValueItem PostEnumerableUri([FromUri] IEnumerable<ActionValueItem> items)
        {
            return items.FirstOrDefault();
        }

        // Demonstrates binding to JsonValue from body
        public JToken PostJsonValue(JToken jsonValue)
        {
            return jsonValue;
        }

        // Demonstrate what we expect to be the common default scenario. No attributes are required.
        // A complex object comes from the body, and simple objects come from the URI.
        public ActionValueItem PostFromBodyAndUri(int id, ActionValueItem item)
        {
            return item;
        }

        // Demonstrates binding to complex type explicitly marked as coming from body
        public ActionValueItem PostFromBody([FromBody] ActionValueItem item)
        {
            return item;
        }

        // Demonstrates how body can be shredded to name/value pairs to bind to simple types
        public ActionValueItem PostToSimpleTypes(int id, string firstName, string lastName)
        {
            return new ActionValueItem() { Id = id, FirstName = firstName, LastName = lastName };
        }

        // Demonstrates binding to ObjectContent<T> from request body
        public Task<ActionValueItem> PostObjectContentOfItemAsync(ObjectContent<ActionValueItem> item)
        {
            return item.ReadAsAsync<ActionValueItem>();
        }

        public class ActionValueControllerValueProviderFactory : ValueProviderFactory
        {
            public override IValueProvider GetValueProvider(HttpActionContext actionContext)
            {
                return new ActionValueControllerValueProvider();
            }
        }

        public class ActionValueControllerValueProvider : IValueProvider
        {
            public bool ContainsPrefix(string prefix)
            {
                return true;
            }

            public ValueProviderResult GetValue(string key)
            {
                return new ValueProviderResult("99", "99", CultureInfo.CurrentCulture);
            }
        }
    }

    static class DefaultActionValueBinderExtensions
    {
        public static Task BindValuesAsync(this DefaultActionValueBinder binder, HttpActionContext actionContext, CancellationToken cancellationToken)
        {
            HttpActionBinding binding = binder.GetBinding(actionContext.ActionDescriptor);
            return binding.ExecuteBindingAsync(actionContext, cancellationToken);
        }
    }

    public class ActionValueItem
    {
        [Range(0, 99)]
        public int Id { get; set; }
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }

    // Test variants of converting empty string to null.
    // Pass each property the empty string.
    public class ConvertEmptyStringContainer
    {
        [DisplayFormat(ConvertEmptyStringToNull = false)]
        public string A1 { get; set; } // ""

        [DisplayFormat(ConvertEmptyStringToNull = true)]
        public string A2 { get; set; } // Null

        [DisplayFormat]
        public string A3 { get; set; } // Null

        public string A4 { get; set; } // Null
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/HttpContentBindingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.ServiceModel;
using System.Threading.Tasks;
using System.Web.Http.SelfHost;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// Tests actions that directly use HttpRequestMessage parameters
    /// </summary>
    public class HttpContentBindingTests
    {
        public HttpContentBindingTests()
        {
            SetupHost();
        }

        [Theory]
        [InlineData("application/xml")]
        [InlineData("text/xml")]
        [InlineData("application/json")]
        [InlineData("text/json")]
        public async Task Action_Directly_Reads_HttpRequestMessage(string mediaType)
        {
            Order order = new Order() { OrderId = "99", OrderValue = 100.0 };
            var formatter = new MediaTypeFormatterCollection().FindWriter(typeof(Order), new MediaTypeHeaderValue(mediaType));
            HttpRequestMessage request = new HttpRequestMessage()
            {
                Content = new ObjectContent<Order>(order, formatter, mediaType),
                RequestUri = new Uri(baseAddress + "/HttpContentBinding/HandleMessage"),
                Method = HttpMethod.Post
            };

            HttpResponseMessage response = await httpClient.SendAsync(request);

            Order receivedOrder = await response.Content.ReadAsAsync<Order>();
            Assert.Equal(order.OrderId, receivedOrder.OrderId);
            Assert.Equal(order.OrderValue, receivedOrder.OrderValue);
        }

        private HttpServer server = null;
        private string baseAddress = null;
        private HttpClient httpClient = null;

        private void SetupHost()
        {
            baseAddress = "http://localhost/";

            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);
            config.HostNameComparisonMode = HostNameComparisonMode.Exact;
            config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "HttpContentBinding", action = "HandleMessage" });
            config.MessageHandlers.Add(new ConvertToStreamMessageHandler());

            server = new HttpServer(config);
            httpClient = new HttpClient(server);
        }
    }

    public class Order
    {
        public string OrderId { get; set; }
        public double OrderValue { get; set; }
    }

    public class HttpContentBindingController : ApiController
    {
        [HttpPost]
        public async Task<HttpResponseMessage> HandleMessage()
        {
            Order order = await Request.Content.ReadAsAsync<Order>();
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new ObjectContent<Order>(order, new JsonMediaTypeFormatter())
            };
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/ModelBindingController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Runtime.Serialization;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    public class ModelBindingController : ApiController
    {
        public string GetString(string value)
        {
            return value;
        }

        public string GetStringFromRoute(string controller = null, string action = null)
        {
            return controller + ":" + action;
        }

        public int GetInt(int value)
        {
            return value;
        }

        public int? GetOptionalNullableInt(int? value = null)
        {
            return value;
        }

        public int GetIntWithDefault(int value = -1)
        {
            return value;
        }

        public string GetStringWithDefault(string value = null)
        {
            return value;
        }

        public int GetIntFromUri([FromUri] int value)
        {
            return value;
        }

        public int GetIntPrefixed([FromUri(Name = "somePrefix")] int value)
        {
            return value;
        }

        public int GetIntCustom([ValueProvider(typeof(RequestHeadersValueProviderFactory))] int value)
        {
            return value;
        }

        public Task<int> GetIntAsync(int value, CancellationToken token)
        {
            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
            tcs.TrySetResult(value);
            return tcs.Task;
        }

        public bool GetBool(bool value)
        {
            return value;
        }

        public ModelBindOrder GetComplexType(ModelBindOrder item)
        {
            return item;
        }

        public ModelBindOrder GetComplexTypeFromUri([FromUri] ModelBindOrder item)
        {
            return item;
        }

        public string PostString(string value)
        {
            return value;
        }

        public int PostInt(int value)
        {
            return value;
        }

        public HttpResponseMessage PostComplexWithValidation(CustomerNameMax6 customer)
        {
            string errors = String.Empty;
            foreach (var kv in this.ModelState)
            {
                int errorCount = kv.Value.Errors.Count;

                if (errorCount > 0)
                {
                    errors += String.Format("Failed to bind {0}. The errors are:\n", kv.Key);
                    for (int i = 0; i < errorCount; i++)
                    {
                        ModelError error = kv.Value.Errors[i];
                        errors += "ErrorMessage: " + error.ErrorMessage + "\n";

                        if (error.Exception != null)
                        {
                            errors += "Exception" + error.Exception + "\n";
                        }
                    }
                }
            }

            if (errors != String.Empty)
            {
                // Has validation failure
                // TODO, 334736, support HttpResponseException which takes ModelState
                // throw new HttpResponseException(this.ModelState);
                HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.BadRequest);
                response.Content = new StringContent(errors);
                throw new HttpResponseException(response);
            }
            else
            {
                // happy path
                return Request.CreateResponse<int>(HttpStatusCode.OK, customer.Id);
            }
        }

        public int PostIntFromUri([FromUri] int value)
        {
            return value;
        }

        public int PostIntFromBody([FromBody] int value)
        {
            return value;
        }

        public int PostIntUriPrefixed([FromUri(Name = "somePrefix")] int value)
        {
            return value;
        }

        public bool PostBool(bool value)
        {
            return value;
        }

        public int PostIntArray([FromUri] int[] value)
        {
            return value.Sum();
        }

        public ModelBindOrder PostComplexType(ModelBindOrder item)
        {
            return item;
        }

        public ModelBindOrder PostComplexTypeFromUri([FromUri] ModelBindOrder item)
        {
            return item;
        }

        public ComplexTypeWithNestedCollection PostComplexTypeFromUriWithNestedCollection([FromUri] ComplexTypeWithNestedCollection value)
        {
            return value;
        }

        public ModelBindOrder PostComplexTypeFromBody([FromBody] ModelBindOrder item)
        {
            return item;
        }

        // check if HttpRequestMessage prevents binding other parameters
        public int PostComplexTypeHttpRequestMessage(HttpRequestMessage request, ModelBindOrder order)
        {
            return Int32.Parse(order.ItemName) + order.Quantity;
        }

        public string PostWithOptionalBodyParameter([FromBody] string value = "default")
        {
            return value;
        }

        public string PostWithOptionalBodyParameterAndUriParameter([FromUri]int id, [FromBody] string value = "default")
        {
            return value;
        }
    }

    [DataContract]
    public class CustomerNameMax6
    {
        [Required]
        [StringLength(6)]
        [DataMember]
        public string Name { get; set; }

        [DataMember]
        public int Id { get; set; }

        [Required]
        [DataMember(IsRequired = true)]
        public int RequiredValue { get; set; }
    }

    public class ModelBindCustomer
    {
        public string Name { get; set; }
    }

    public class ModelBindOrder
    {
        public string ItemName { get; set; }
        public int Quantity { get; set; }
        public ModelBindCustomer Customer { get; set; }
    }

    public class ComplexTypeWithNestedCollection
    {
        public IEnumerable<int> Numbers { get; set; }
    }

    public class ModelBindOrderEqualityComparer : IEqualityComparer<ModelBindOrder>
    {
        public bool Equals(ModelBindOrder x, ModelBindOrder y)
        {
            Assert.True(x != null, "Expected ModelBindOrder cannot be null.");
            Assert.True(y != null, "Actual ModelBindOrder was null.");
            Assert.Equal(x.ItemName, y.ItemName);
            Assert.Equal(x.Quantity, y.Quantity);

            if (x.Customer != null)
            {
                Assert.True(y.Customer != null, "Actual Customer was null but expected was " + x.Customer.Name);
            }
            else if (x.Customer == null)
            {
                Assert.True(y.Customer == null, "Actual Customer was not null but should have been.");
            }
            else
            {
                Assert.True(String.Equals(x.Customer.Name, y.Customer.Name, StringComparison.Ordinal), String.Format("Expected Customer.Name '{0}' but actual was '{1}'", x.Customer.Name, y.Customer.Name));
            }

            return true;
        }

        public int GetHashCode(ModelBindOrder obj)
        {
            return obj.GetHashCode();
        }
    }

    public class RequestHeadersValueProviderFactory : ValueProviderFactory
    {
        public override IValueProvider GetValueProvider(HttpActionContext actionContext)
        {
            return new RequestHeaderValueProvider(actionContext);
        }
    }

    public class RequestHeaderValueProvider : IValueProvider
    {
        HttpActionContext _actionContext;
        public RequestHeaderValueProvider(HttpActionContext actionContext)
        {
            _actionContext = actionContext;
        }

        public bool ContainsPrefix(string prefix)
        {
            return _actionContext.ControllerContext.Request.Headers.Contains(prefix);
        }

        public ValueProviderResult GetValue(string key)
        {
            string result = _actionContext.ControllerContext.Request.Headers.GetValues(key).FirstOrDefault();
            return result == null
                ? null
                : new ValueProviderResult(result, result, CultureInfo.CurrentCulture);
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/ModelBindingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// End to end functional tests for model binding
    /// </summary>
    public abstract class ModelBindingTests : HttpServerTestBase
    {
        protected ModelBindingTests()
            : base("http://localhost/")
        {
        }

        protected override void ApplyConfiguration(HttpConfiguration configuration)
        {
            configuration.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "ModelBinding" });
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/QueryStringBindingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// End to end functional tests for model binding via query strings
    /// </summary>
    public class QueryStringBindingTests : ModelBindingTests
    {
        [Theory]
        [InlineData("GetString", "?value=test", "\"test\"")]
        [InlineData("GetInt", "?value=99", "99")]
        [InlineData("GetBool", "?value=false", "false")]
        [InlineData("GetBool", "?value=true", "true")]
        [InlineData("GetIntWithDefault", "?value=99", "99")]    // action has default, but we provide value
        [InlineData("GetIntWithDefault", "", "-1")]             // action has default, we provide no value
        [InlineData("GetStringWithDefault", "", "null")]        // action has null default, we provide no value
        [InlineData("GetIntFromUri", "?value=99", "99")]        // [FromUri]
        [InlineData("GetIntPrefixed", "?somePrefix=99", "99")]  // [FromUri(Prefix=somePrefix)]
        [InlineData("GetIntAsync", "?value=5", "5")]
        [InlineData("GetOptionalNullableInt", "", "null")]
        [InlineData("GetOptionalNullableInt", "?value=6", "6")]
        public async Task Query_String_Binds_Simple_Types_Get(string action, string queryString, string expectedResponse)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}{1}", action, queryString)),
                Method = HttpMethod.Get
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            string responseString = await response.Content.ReadAsStringAsync();
            Assert.Equal(expectedResponse, responseString);
        }

        [Theory]
        [InlineData("PostString", "?value=test", "\"test\"")]
        [InlineData("PostInt", "?value=99", "99")]
        [InlineData("PostBool", "?value=false", "false")]
        [InlineData("PostBool", "?value=true", "true")]
        [InlineData("PostIntFromUri", "?value=99", "99")]           // [FromUri]
        [InlineData("PostIntUriPrefixed", "?somePrefix=99", "99")]  // [FromUri(Prefix=somePrefix)]
        [InlineData("PostIntArray", "?value={[1,2,3]}", "0")]       // TODO: DevDiv2 333257 -- make this array real when fix JsonValue array model binding
        public async Task Query_String_Binds_Simple_Types_Post(string action, string queryString, string expectedResponse)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}{1}", action, queryString)),
                Method = HttpMethod.Post
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            string responseString = await response.Content.ReadAsStringAsync();
            Assert.Equal(expectedResponse, responseString);
        }

        [Theory]
        [InlineData("GetComplexTypeFromUri", "itemName=Tires&quantity=2&customer.Name=Sue", "Tires", 2, "Sue")]
        public async Task Query_String_ComplexType_Type_Get(string action, string queryString, string itemName, int quantity, string customerName)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}?{1}", action, queryString)),
                Method = HttpMethod.Get
            };

            ModelBindOrder expectedItem = new ModelBindOrder()
            {
                ItemName = itemName,
                Quantity = quantity,
                Customer = new ModelBindCustomer { Name = customerName }
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            ModelBindOrder actualItem = await response.Content.ReadAsAsync<ModelBindOrder>();
            Assert.Equal(expectedItem, actualItem, new ModelBindOrderEqualityComparer());
        }

        [Theory]
        [InlineData("PostComplexTypeFromUri", "itemName=Tires&quantity=2&customer.Name=Bob", "Tires", 2, "Bob")]
        public async Task Query_String_ComplexType_Type_Post(string action, string queryString, string itemName, int quantity, string customerName)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}?{1}", action, queryString)),
                Method = HttpMethod.Post
            };
            ModelBindOrder expectedItem = new ModelBindOrder()
            {
                ItemName = itemName,
                Quantity = quantity,
                Customer = new ModelBindCustomer { Name = customerName }
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            ModelBindOrder actualItem = await response.Content.ReadAsAsync<ModelBindOrder>();
            Assert.Equal(expectedItem, actualItem, new ModelBindOrderEqualityComparer());
        }

        [Theory]
        [InlineData("PostComplexTypeFromUriWithNestedCollection", "value.Numbers[0]=1&value.Numbers[1]=2", new[] { 1, 2 })]
        public async Task Query_String_ComplexType_Type_Post_NestedCollection(string action, string queryString, int[] expectedValues)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + String.Format("ModelBinding/{0}?{1}", action, queryString)),
                Method = HttpMethod.Post
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            ComplexTypeWithNestedCollection actualResult = await response.Content.ReadAsAsync<ComplexTypeWithNestedCollection>();
            int[] actualValues = actualResult.Numbers.ToArray();
            Assert.Equal(expectedValues.Length, actualValues.Length);
            for (int i = 0; i < expectedValues.Length; i++)
            {
                Assert.Equal(expectedValues[i], actualValues[i]);
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/ModelBinding/RouteBindingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// End to end functional tests for model binding via routes
    /// </summary>
    public class RouteBindingTests : ModelBindingTests
    {
        [Fact]
        public async Task Route_Binds_Simple_Types_Get()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage()
            {
                RequestUri = new Uri(BaseAddress + "ModelBinding/GetStringFromRoute"),
                Method = HttpMethod.Get
            };

            // Act
            HttpResponseMessage response = await Client.SendAsync(request);

            // Assert
            string responseString = await response.Content.ReadAsStringAsync();
            Assert.Equal("\"ModelBinding:GetStringFromRoute\"", responseString);
        }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

[assembly: CLSCompliant(false)]

================================================
FILE: test/System.Web.Http.Integration.Test/System.Web.Http.Integration.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{3267DFC6-B34D-4011-BC0F-D3B56AF6F608}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http</RootNamespace>
    <AssemblyName>System.Web.Http.Integration.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.IdentityModel" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.ServiceModel" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="ApiExplorer\Controllers\AmbiguousActionController.cs" />
    <Compile Include="ApiExplorer\Controllers\AttributeRouteControllers.cs" />
    <Compile Include="ApiExplorer\Controllers\ResponseTypeController.cs" />
    <Compile Include="ApiExplorer\Controllers\DocumentationController.cs" />
    <Compile Include="ApiExplorer\Controllers\ParameterSourceController.cs" />
    <Compile Include="ApiExplorer\AttributeRoutesTest.cs" />
    <Compile Include="ApiExplorer\ResponseTypeAttributeTest.cs" />
    <Compile Include="ApiExplorer\DocumentationProviders\AttributeDocumentationProvider.cs" />
    <Compile Include="ApiExplorer\FormattersTest.cs" />
    <Compile Include="ApiExplorer\Formatters\ItemFormatter.cs" />
    <Compile Include="ApiExplorer\ParameterSourceTest.cs" />
    <Compile Include="ApiExplorer\DocumentationTest.cs" />
    <Compile Include="ApiExplorer\RouteConstraintsTest.cs" />
    <Compile Include="ApiExplorer\RoutesTest.cs" />
    <Compile Include="Controllers\Apis\EnumParameterOverloadsController.cs" />
    <Compile Include="Controllers\Apis\HeaderValueProviderFactory.cs" />
    <Compile Include="Controllers\Apis\ParameterTestController.cs" />
    <Compile Include="Controllers\Apis\SpecialConfigController.cs" />
    <Compile Include="Controllers\Apis\RegularConfigController.cs" />
    <Compile Include="Controllers\Apis\ParameterAttributeController.cs" />
    <Compile Include="Controllers\Apis\UsersController.cs" />
    <Compile Include="Controllers\ActionReachabilityTest.cs" />
    <Compile Include="Controllers\Apis\ValuesController.cs" />
    <Compile Include="Controllers\ControllerConfigurationTest.cs" />
    <Compile Include="Dispatcher\CustomHttpControllerTypeResolverTest.cs" />
    <Compile Include="Tracing\ITestTraceWriter.cs" />
    <Compile Include="Tracing\MemoryTraceWriter.cs" />
    <Compile Include="Tracing\NeverTracesTraceWriter.cs" />
    <Compile Include="Tracing\TracingTest.cs" />
    <Compile Include="Util\ApiExplorerHelper.cs" />
    <Compile Include="ApiExplorer\ApiExplorerSettingsTest.cs" />
    <Compile Include="ApiExplorer\Controllers\HiddenController.cs" />
    <Compile Include="ApiExplorer\Controllers\ItemController.cs" />
    <Compile Include="ApiExplorer\Controllers\HiddenActionController.cs" />
    <Compile Include="ApiExplorer\Controllers\OverloadsController.cs" />
    <Compile Include="ContentNegotiation\ContentNegotiationTestBase.cs" />
    <Compile Include="ContentNegotiation\CustomFormatterTests.cs" />
    <Compile Include="ContentNegotiation\DefaultContentNegotiatorTests.cs" />
    <Compile Include="ContentNegotiation\HttpResponseReturnTests.cs" />
    <Compile Include="ContentNegotiation\ConnegController.cs" />
    <Compile Include="ContentNegotiation\ConnegItem.cs" />
    <Compile Include="ContentNegotiation\AcceptHeaderTests.cs" />
    <Compile Include="Controllers\ActionAttributesTest.cs" />
    <Compile Include="Controllers\ApiControllerActionSelectorTest.cs" />
    <Compile Include="Controllers\Apis\ActionAttributeTestController.cs" />
    <Compile Include="Controllers\Apis\TestController.cs" />
    <Compile Include="Controllers\Apis\User.cs" />
    <Compile Include="Controllers\Apis\UserAddress.cs" />
    <Compile Include="Controllers\Helpers\ApiControllerHelper.cs" />
    <Compile Include="ExceptionHandling\DuplicateControllers.cs" />
    <Compile Include="ExceptionHandling\ExceptionController.cs" />
    <Compile Include="ExceptionHandling\ExceptionHandlingTest.cs" />
    <Compile Include="ExceptionHandling\HttpResponseExceptionTest.cs" />
    <Compile Include="ExceptionHandling\IncludeErrorDetailTest.cs" />
    <Compile Include="ModelBinding\BodyBindingTests.cs" />
    <Compile Include="ModelBinding\CustomBindingTests.cs" />
    <Compile Include="ModelBinding\DefaultActionValueBinderTest.cs" />
    <Compile Include="ModelBinding\ModelBindingController.cs" />
    <Compile Include="ModelBinding\ModelBindingTests.cs" />
    <Compile Include="ModelBinding\HttpContentBindingTests.cs" />
    <Compile Include="ModelBinding\QueryStringBindingTests.cs" />
    <Compile Include="ModelBinding\RouteBindingTests.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Util\ContextUtil.cs" />
    <Compile Include="Util\ConvertToStreamMessageHandler.cs" />
    <Compile Include="Util\HttpServerTestBase.cs" />
    <Compile Include="Util\ScenarioHelper.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.SelfHost\System.Web.Http.SelfHost.csproj">
      <Project>{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}</Project>
      <Name>System.Web.Http.SelfHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</Project>
      <Name>System.Web.Http</Name>
      <Private>True</Private>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Http.Integration.Test/Tracing/ITestTraceWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.Tracing
{
    public interface ITestTraceWriter : ITraceWriter
    {
        // Asks the trace writer to initialize for another test iteration
        void Start();

        // Tells the trace writer to stop tracing
        void Finish();

        // Returns true if the tracer writer received any trace requests
        bool DidReceiveTraceRequests { get; }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Tracing/MemoryTraceWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// This <see cref="ITraceWriter"/> unconditionally responds that
    /// all categories and levels are enabled.  
    /// All attempts to trace call back the caller for trace information
    /// and the information is kept in memory for later use.
    /// <para>
    /// Its use forces all trace statements in all tracers to
    /// evaluate their information and update their TraceRecord.
    /// </para>
    /// </summary>
    public class MemoryTraceWriter : ITestTraceWriter
    {
        private List<TraceRecord> _records = new List<TraceRecord>();

        public void Trace(HttpRequestMessage request, string category, TraceLevel level, Action<TraceRecord> traceAction)
        {
            TraceRecord record = new TraceRecord(request, category, level);
            traceAction(record);
            _records.Add(record);
        }

        public void Start()
        {
            _records.Clear();
        }

        public bool DidReceiveTraceRequests { get { return _records.Count != 0; } }

        public void Finish()
        {
        }

        public IList<TraceRecord> Records { get { return _records; } }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/Tracing/NeverTracesTraceWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// This <see cref="ITraceWriter"/> unconditionally responds that
    /// all categories and levels are disabled.  
    /// All attempts to trace do not call back to the user for trace information.
    /// </summary>
    /// <para>
    /// Its use forces all tracers to be installed and to execute,
    /// but all their trace statements are not called back for
    /// their trace information.
    /// </para>
    public class NeverTracesTraceWriter : ITestTraceWriter
    {
        public void Trace(HttpRequestMessage request, string category, TraceLevel level, Action<TraceRecord> traceAction)
        {
            DidReceiveTraceRequests = true;
        }

        public void Start()
        {
            DidReceiveTraceRequests = false;
        }

        public bool DidReceiveTraceRequests { get; set; }

        public void Finish()
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Tracing/TracingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Threading.Tasks;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// End to end functional tests for tracing.
    /// Verifies ValuesController from standard WebApi project template
    /// behaves the same whether tracing is on or off.  Also verifies
    /// silent and verbose trace writers do not affect the responses.
    ///
    /// </summary>
    public class TracingTest
    {
        private readonly string _baseAddress = "http://localhost";

        public TracingTest()
        {
        }

        // The test trace writers used when testing that the controller
        // is unaffected by presence or behavior of trace writers
        public static TheoryDataSet<ITestTraceWriter> TestTraceWriters
        {
            get
            {
                return new TheoryDataSet<ITestTraceWriter>
                {
                    // Null means tracing is disabled
                    null,

                    // This trace writer enables tracing, and the tracer
                    // never calls back any tracing client to ask for more info.
                    new NeverTracesTraceWriter(),

                    // This trace writer enables tracing, and the tracer
                    // always calls back all tracing clients to ask for more info.
                    new MemoryTraceWriter(),
                };
            }
        }

        // These are all the Begin/End traces we expect in a successful ValuesController.Get(id).
        // Tests assert all these are traced (both a Begin and End) and that no others are traced.
        // We verify only the stable parts of the trace record, not the optional messages etc.
        public static List<ExpectedTraceRecord> ExpectedTraceRecords = new List<ExpectedTraceRecord>() {
            new ExpectedTraceRecord("System.Web.Http.Request",      string.Empty,                     string.Empty),
            new ExpectedTraceRecord("System.Web.Http.MessageHandlers",  "DelegatingHandlerProxy",     "SendAsync"),
            new ExpectedTraceRecord("System.Web.Http.Controllers",  "DefaultHttpControllerSelector",  "SelectController"),
            new ExpectedTraceRecord("System.Web.Http.Controllers",  "HttpControllerDescriptor",       "CreateController"),
            new ExpectedTraceRecord("System.Web.Http.Controllers",  "DefaultHttpControllerActivator", "Create"),
            new ExpectedTraceRecord("System.Web.Http.Controllers",  "DefaultHttpControllerTypeResolver", "GetControllerTypes"),
            new ExpectedTraceRecord("System.Web.Http.Controllers",  "ValuesController",               "ExecuteAsync"),
            new ExpectedTraceRecord("System.Web.Http.Action",       "ApiControllerActionSelector",    "SelectAction"),
            new ExpectedTraceRecord("System.Web.Http.Action",       "ApiControllerActionInvoker",     "InvokeActionAsync"),
            new ExpectedTraceRecord("System.Web.Http.Action",       "ReflectedHttpActionDescriptor",  "ExecuteAsync"),
            new ExpectedTraceRecord("System.Web.Http.ModelBinding", "HttpActionBinding",              "ExecuteBindingAsync"),
            new ExpectedTraceRecord("System.Web.Http.ModelBinding", "ModelBinderParameterBinding",    "ExecuteBindingAsync"),
            new ExpectedTraceRecord("System.Net.Http.Formatting",   "DefaultContentNegotiator",       "Negotiate"),
            new ExpectedTraceRecord("System.Net.Http.Formatting",   "JsonMediaTypeFormatter",         "GetPerRequestFormatterInstance"),
            new ExpectedTraceRecord("System.Net.Http.Formatting",   "JsonMediaTypeFormatter",         "WriteToStreamAsync"),
        };

        // These are all the Begin/End traces we expect in a successful ValuesController.Get(id).
        public static List<ExpectedTraceRecord> ExpectedTraceRecordOrder = new List<ExpectedTraceRecord>() {
            new ExpectedTraceRecord(TraceKind.Begin,     "System.Web.Http.Request",      string.Empty,                     string.Empty),
            new ExpectedTraceRecord(TraceKind.Begin,     "System.Web.Http.MessageHandlers",  "DelegatingHandlerProxy",  "SendAsync"),
            new ExpectedTraceRecord(TraceKind.Begin,     "System.Web.Http.Controllers",  "DefaultHttpControllerSelector",  "SelectController"),
            new ExpectedTraceRecord(TraceKind.Begin,     "System.Web.Http.Controllers",  "DefaultHttpControllerTypeResolver", "GetControllerTypes"),
            new ExpectedTraceRecord(TraceKind.End,       "System.Web.Http.Controllers",  "DefaultHttpControllerTypeResolver", "GetControllerTypes"),
            new ExpectedTraceRecord(TraceKind.End,       "System.Web.Http.Controllers",  "DefaultHttpControllerSelector",  "SelectController"),
            new ExpectedTraceRecord(TraceKind.Begin,     "System.Web.Http.Controllers",  "HttpControllerDescriptor",       "CreateController"),
            new ExpectedTraceRecord(TraceKind.Begin,     "System.Web.Http.Controllers",  "DefaultHttpControllerActivator", "Create"),
            new ExpectedTraceRecord(TraceKind.End,       "System.Web.Http.Controllers",  "DefaultHttpControllerActivator", "Create"),
            new ExpectedTraceRecord(TraceKind.End,       "System.Web.Http.Controllers",  "HttpControllerDescriptor",       "CreateController"),
            new ExpectedTraceRecord(TraceKind.Begin,     "System.Web.Http.Controllers",  "ValuesController",               "ExecuteAsync"),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Web.Http.Action",       "ApiControllerActionSelector",    "SelectAction"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.Action",       "ApiControllerActionSelector",    "SelectAction"),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Web.Http.ModelBinding", "HttpActionBinding",              "ExecuteBindingAsync"),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Web.Http.ModelBinding", "ModelBinderParameterBinding",    "ExecuteBindingAsync"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.ModelBinding", "ModelBinderParameterBinding",    "ExecuteBindingAsync"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.ModelBinding", "HttpActionBinding",              "ExecuteBindingAsync"),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Web.Http.Action",       "ApiControllerActionInvoker",     "InvokeActionAsync"),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Web.Http.Action",       "ReflectedHttpActionDescriptor",  "ExecuteAsync"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.Action",       "ReflectedHttpActionDescriptor",  "ExecuteAsync"),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Net.Http.Formatting",   "DefaultContentNegotiator",       "Negotiate"),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Net.Http.Formatting",   "JsonMediaTypeFormatter",         "GetPerRequestFormatterInstance"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Net.Http.Formatting",   "JsonMediaTypeFormatter",         "GetPerRequestFormatterInstance"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Net.Http.Formatting",   "DefaultContentNegotiator",       "Negotiate"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.Action",       "ApiControllerActionInvoker",     "InvokeActionAsync"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.Controllers",  "ValuesController",               "ExecuteAsync"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.MessageHandlers",  "DelegatingHandlerProxy",  "SendAsync"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Web.Http.Request",      string.Empty,                     string.Empty),
            new ExpectedTraceRecord(TraceKind.Begin,    "System.Net.Http.Formatting",   "JsonMediaTypeFormatter",         "WriteToStreamAsync"),
            new ExpectedTraceRecord(TraceKind.End,      "System.Net.Http.Formatting",   "JsonMediaTypeFormatter",         "WriteToStreamAsync"),
        };

        [Theory]
        [PropertyData("TestTraceWriters")]
        public async Task ValuesController_Behavior_Unchanged_By_Tracing(ITestTraceWriter traceWriter)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });

            // The null trace writer case is tested as well to verify the
            // ValuesController works as expected without tracing.
            if (traceWriter != null)
            {
                config.Services.Replace(typeof(ITraceWriter), traceWriter);
                traceWriter.Start();
            }

            ValuesController valuesController = new ValuesController();

            using (HttpServer server = new HttpServer(config))
            {
                using (HttpClient client = new HttpClient(server))
                {
                    if (traceWriter != null)
                    {
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Get()
                    string uri = _baseAddress + "/api/Values";
                    HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
                    HttpResponseMessage response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    string[] expectedGetResponse = valuesController.Get().ToArray();
                    string[] actualGetResponse = await response.Content.ReadAsAsync<string[]>();
                    Assert.Equal(expectedGetResponse, actualGetResponse);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Get(id) using query string
                    uri = _baseAddress + "/api/Values?id=5";
                    request = new HttpRequestMessage(HttpMethod.Get, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    string expectedGetQueryStringResponse = valuesController.Get(5);
                    string actualGetQueryStringResponse = await response.Content.ReadAsAsync<string>();
                    Assert.Equal(expectedGetQueryStringResponse, actualGetQueryStringResponse);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Get(id) using route
                    uri = _baseAddress + "/api/Values/5";
                    request = new HttpRequestMessage(HttpMethod.Get, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    string expectedGetRouteResponse = valuesController.Get(5);
                    string actualGetRouteResponse = await response.Content.ReadAsAsync<string>();
                    Assert.Equal(expectedGetQueryStringResponse, actualGetRouteResponse);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Get(id) using query string that causes model binding error
                    uri = _baseAddress + "/api/Values?id=x";
                    request = new HttpRequestMessage(HttpMethod.Get, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Post(value) with no parameters
                    uri = _baseAddress + "/api/Values";
                    request = new HttpRequestMessage(HttpMethod.Post, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Post(value) using query string
                    uri = _baseAddress + "/api/Values?value=hello";
                    request = new HttpRequestMessage(HttpMethod.Post, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Put(id, value) using query strings
                    uri = _baseAddress + "/api/Values?id=5&value=hello";
                    request = new HttpRequestMessage(HttpMethod.Put, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Put(id, value) using route + query string
                    uri = _baseAddress + "/api/Values/5?value=hello";
                    request = new HttpRequestMessage(HttpMethod.Put, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Delete(id) using query string
                    uri = _baseAddress + "/api/Values?id=5";
                    request = new HttpRequestMessage(HttpMethod.Delete, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                        traceWriter.Start();
                    }

                    // Calls ValuesController.Delete(id) using route
                    uri = _baseAddress + "/api/Values/5";
                    request = new HttpRequestMessage(HttpMethod.Delete, uri);
                    response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
                    if (traceWriter != null)
                    {
                        traceWriter.Finish();
                        Assert.True(traceWriter.DidReceiveTraceRequests);
                    }
                }
            }
        }

        [Fact]
        public async Task ValuesController_Get_Id_Writes_Expected_Traces()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
            Mock<DelegatingHandler> customMessageHandler = new Mock<DelegatingHandler>() { CallBase = true };
            config.MessageHandlers.Add(customMessageHandler.Object);
            MemoryTraceWriter traceWriter = new MemoryTraceWriter();
            config.Services.Replace(typeof(ITraceWriter), traceWriter);

            using (HttpServer server = new HttpServer(config))
            {
                using (HttpClient client = new HttpClient(server))
                {
                    traceWriter.Start();

                    // Calls ValueController.Get(id) using query string
                    string uri = _baseAddress + "/api/Values?id=5";
                    HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
                    HttpResponseMessage response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    traceWriter.Finish();

                    IList<string> missingTraces = MissingTraces(ExpectedTraceRecords, traceWriter.Records);
                    Assert.True(missingTraces.Count == 0,
                                string.Format("These expected traces were missing:{0}    {1}",
                                                Environment.NewLine, string.Join(Environment.NewLine + "    ", missingTraces)));

                    IList<string> unexpectedTraces = UnexpectedTraces(ExpectedTraceRecords, traceWriter.Records);
                    Assert.True(unexpectedTraces.Count == 0,
                                string.Format("These traces were not expected:{0}    {1}",
                                                Environment.NewLine, string.Join(Environment.NewLine + "    ", unexpectedTraces)));
                }
            }
        }

        [Fact]
        public async Task ValuesController_Get_Id_Writes_Expected_Traces_InTheCorrectOrder()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{id}", new { id = RouteParameter.Optional });
            Mock<DelegatingHandler> customMessageHandler = new Mock<DelegatingHandler>() { CallBase = true };
            config.MessageHandlers.Add(customMessageHandler.Object);
            MemoryTraceWriter traceWriter = new MemoryTraceWriter();
            config.Services.Replace(typeof(ITraceWriter), traceWriter);

            using (HttpServer server = new HttpServer(config))
            {
                using (HttpClient client = new HttpClient(server))
                {
                    traceWriter.Start();

                    // Calls ValueController.Get(id) using query string
                    string uri = _baseAddress + "/api/Values?id=5";
                    HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
                    HttpResponseMessage response = await client.SendAsync(request);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    traceWriter.Finish();

                    Assert.True(ConfirmTracingOrder(ExpectedTraceRecordOrder, traceWriter.Records));
                }
            }
        }
        // Returns a list of strings describing all of the expected trace records that were not
        // actually traced.
        // If you experience test failures from this list, it means someone stopped tracing or
        // changed the content of what was traced.
        // Update the ExpectedTraceRecords property to reflect what is expected.
        private static IList<string> MissingTraces(IList<ExpectedTraceRecord> expectedRecords, IList<TraceRecord> actualRecords)
        {
            List<string> missing = new List<string>();

            foreach (ExpectedTraceRecord expectedRecord in expectedRecords)
            {
                TraceRecord beginTrace = actualRecords.SingleOrDefault(r =>
                    String.Equals(r.Category, expectedRecord.Category, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.Operator, expectedRecord.OperatorName, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.Operation, expectedRecord.OperationName, StringComparison.OrdinalIgnoreCase) &&
                    r.Kind == TraceKind.Begin
                    );

                if (beginTrace == null)
                {
                    missing.Add(string.Format("Begin category={0}, operator={1}, operation={2}",
                                    expectedRecord.Category, expectedRecord.OperatorName, expectedRecord.OperationName));
                }

                TraceRecord endTrace = actualRecords.SingleOrDefault(r =>
                    String.Equals(r.Category, expectedRecord.Category, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.Operator, expectedRecord.OperatorName, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.Operation, expectedRecord.OperationName, StringComparison.OrdinalIgnoreCase) &&
                    r.Kind == TraceKind.End
                    );

                if (endTrace == null)
                {
                    missing.Add(string.Format("End category={0}, operator={1}, operation={2}",
                                    expectedRecord.Category, expectedRecord.OperatorName, expectedRecord.OperationName));
                }
            }

            return missing;
        }

        // Returns a list of strings of trace records we did not expect.
        // If you experience failures from this list, it means someone added new traces
        // or changed the contents of the traces.
        // Update the ExpectedTraceRecords property to reflect what is expected.
        private static IList<string> UnexpectedTraces(IList<ExpectedTraceRecord> expectedRecords, IList<TraceRecord> actualRecords)
        {
            List<string> unexpected = new List<string>();

            foreach (TraceRecord actualRecord in actualRecords)
            {
                // Ignore record of a ReflectionTypeLoadException to allow test to succeed in Visual Studio. The record is an
                // artifact specific to testing in VS. (Attempting to load all types from xunit.runner.visualstudio.testadapter.dll
                // fails with recent xUnit.net packages. The assembly references Microsoft.VisualStudio.TestPlatform.ObjectModel.dll
                // which is not available with xUnit.net 2.0.x.)
                //
                // Similarly, ignore records for the same exception to allow test to succeed when using the xUnit MSBuild runner.
                // In that case, missing types may come from System.Web and Microsoft.Build.Utilities.v4.0 as well as xunit.runner.msbuild.net452.
                if (actualRecord.Operation == null &&
                    actualRecord.Exception is ReflectionTypeLoadException &&
                    actualRecord.Message != null &&
                    (actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'xunit.runner.visualstudio.testadapter, ",
                         StringComparison.Ordinal) ||
                     actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'xunit.runner.msbuild.",
                         StringComparison.Ordinal) ||
                     actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'System.Web, ",
                         StringComparison.Ordinal) ||
                     actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'Microsoft.Build.Utilities.",
                         StringComparison.Ordinal)))
                {
                    continue;
                }

                ExpectedTraceRecord expectedTrace = expectedRecords.FirstOrDefault(r =>
                    String.Equals(r.Category, actualRecord.Category, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.OperatorName, actualRecord.Operator, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.OperationName, actualRecord.Operation, StringComparison.OrdinalIgnoreCase));

                if (expectedTrace == null)
                {
                    unexpected.Add(string.Format("kind={0} category={1}, operator={2}, operation={3}, message={4}",
                        actualRecord.Kind, actualRecord.Category, actualRecord.Operator, actualRecord.Operation, actualRecord.Message));
                }
            }

            return unexpected;
        }

        // Returns true if the tracing records are in the correct order, else returns false.
        private static bool ConfirmTracingOrder(IList<ExpectedTraceRecord> expectedRecords, IList<TraceRecord> actualRecords)
        {
            int traceBeginPos = 0;
            foreach (ExpectedTraceRecord expectedRecord in expectedRecords)
            {
                TraceRecord beginTrace = actualRecords.SingleOrDefault(r =>
                    String.Equals(r.Category, expectedRecord.Category, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.Operator, expectedRecord.OperatorName, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(r.Operation, expectedRecord.OperationName, StringComparison.OrdinalIgnoreCase) &&
                    object.Equals(r.Kind, expectedRecord.TraceKind)
                    );

                // Ignore record of a ReflectionTypeLoadException to allow test to succeed in Visual Studio. The record is an
                // artifact specific to testing in VS. (Attempting to load all types from xunit.runner.visualstudio.testadapter.dll
                // fails with recent xUnit.net packages. The assembly references Microsoft.VisualStudio.TestPlatform.ObjectModel.dll
                // which is not available with xUnit.net 2.0.x.)
                //
                // Similarly, ignore records for the same exception to allow test to succeed when using the xUnit MSBuild runner.
                // In that case, missing types may come from System.Web and Microsoft.Build.Utilities.v4.0 as well as xunit.runner.msbuild.net452.
                var actualRecord = actualRecords.ElementAtOrDefault(traceBeginPos);
                while (actualRecord != null &&
                    actualRecord.Operation == null &&
                    actualRecord.Exception is ReflectionTypeLoadException &&
                    actualRecord.Message != null &&
                    (actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'xunit.runner.visualstudio.testadapter, ",
                         StringComparison.Ordinal) ||
                     actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'xunit.runner.msbuild.",
                         StringComparison.Ordinal) ||
                     actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'System.Web, ",
                         StringComparison.Ordinal) ||
                     actualRecord.Message.StartsWith(
                         "Exception thrown while getting types from 'Microsoft.Build.Utilities.",
                         StringComparison.Ordinal)))
                {
                    traceBeginPos++;
                    actualRecord = actualRecords.ElementAtOrDefault(traceBeginPos);
                }

                if (!object.ReferenceEquals(beginTrace, actualRecord))
                {
                    return false;
                }

                traceBeginPos++;
            }
            return true;
        }
    }

    public class ExpectedTraceRecord
    {
        public ExpectedTraceRecord(string category, string operatorName, string operationName)
        {
            Category = category;
            OperatorName = operatorName;
            OperationName = operationName;
        }

        public ExpectedTraceRecord(TraceKind kind, string category, string operatorName, string operationName)
        {
            TraceKind = kind;
            Category = category;
            OperatorName = operatorName;
            OperationName = operationName;
        }

        public string Category { get; private set; }
        public TraceKind TraceKind { get; private set; }
        public string OperatorName { get; private set; }
        public string OperationName { get; private set; }
    }
}

================================================
FILE: test/System.Web.Http.Integration.Test/Util/ApiExplorerHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ApiExplorer
{
    public static class ApiExplorerHelper
    {
        public static void VerifyApiDescriptions(Collection<ApiDescription> apiDescriptions, List<object> expectedResults)
        {
            Assert.Equal(expectedResults.Count, apiDescriptions.Count);
            ApiDescription[] sortedDescriptions = apiDescriptions.OrderBy(description => description.ID).ToArray();
            object[] sortedExpectedResults = expectedResults.OrderBy(r =>
            {
                dynamic expectedResult = r;
                HttpMethod expectedHttpMethod = expectedResult.HttpMethod;
                string expectedRelativePath = expectedResult.RelativePath;
                return expectedHttpMethod + expectedRelativePath;
            }).ToArray();

            for (int i = 0; i < sortedDescriptions.Length; i++)
            {
                dynamic expectedResult = sortedExpectedResults[i];
                ApiDescription matchingDescription = sortedDescriptions[i];
                Assert.Equal(expectedResult.HttpMethod, matchingDescription.HttpMethod);
                Assert.Equal(expectedResult.RelativePath, matchingDescription.RelativePath, ignoreCase: true);
                Assert.Equal(expectedResult.HasRequestFormatters, matchingDescription.SupportedRequestBodyFormatters.Count > 0);
                Assert.Equal(expectedResult.HasResponseFormatters, matchingDescription.SupportedResponseFormatters.Count > 0);
                Assert.Equal(expectedResult.NumberOfParameters, matchingDescription.ParameterDescriptions.Count);
            }
        }

        public static DefaultHttpControllerSelector GetStrictControllerSelector(HttpConfiguration config, params Type[] controllerTypes)
        {
            Dictionary<string, HttpControllerDescriptor> controllerMapping = new Dictionary<string, HttpControllerDescriptor>();
            foreach (Type controllerType in controllerTypes)
            {
                string controllerName = controllerType.Name.Substring(0, controllerType.Name.Length - DefaultHttpControllerSelector.ControllerSuffix.Length);
                var controllerDescriptor = new HttpControllerDescriptor(config, controllerName, controllerType);
                controllerMapping.Add(controllerDescriptor.ControllerName, controllerDescriptor);
            }

            Mock<DefaultHttpControllerSelector> factory = new Mock<DefaultHttpControllerSelector>(config);
            factory.Setup(f => f.GetControllerMapping()).Returns(controllerMapping);
            return factory.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Util/ContextUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using Moq;

// TODO: move this class to TestCommon after it has been refactored
namespace System.Web.Http
{
    public static class ContextUtil
    {
        public static HttpControllerContext CreateControllerContext()
        {
            return CreateControllerContext(null, null, null);
        }

        public static HttpControllerContext CreateControllerContext(HttpConfiguration configuration)
        {
            return CreateControllerContext(configuration, null, null);
        }

        public static HttpControllerContext CreateControllerContext(HttpRequestMessage request)
        {
            return CreateControllerContext(null, null, request);
        }

        public static HttpControllerContext CreateControllerContext(HttpConfiguration configuration, IHttpRouteData routeData)
        {
            return CreateControllerContext(configuration, routeData, null);
        }

        public static HttpControllerContext CreateControllerContext(IHttpRouteData routeData, HttpRequestMessage request)
        {
            return CreateControllerContext(null, routeData, request);
        }

        public static HttpControllerContext CreateControllerContext(HttpConfiguration configuration, HttpRequestMessage request)
        {
            return CreateControllerContext(configuration, null, request);
        }

        public static HttpControllerContext CreateControllerContext(HttpConfiguration configuration, IHttpRouteData routeData, HttpRequestMessage request)
        {
            HttpConfiguration config = configuration ?? new HttpConfiguration();
            IHttpRouteData route = routeData ?? new HttpRouteData(new HttpRoute());
            HttpRequestMessage req = request ?? new HttpRequestMessage();
            req.SetConfiguration(config);
            req.SetRouteData(route);
            return new HttpControllerContext(config, route, req) { ControllerDescriptor = new HttpControllerDescriptor(config) };
        }

        public static HttpActionContext CreateActionContext(HttpControllerContext controllerContext = null, HttpActionDescriptor actionDescriptor = null)
        {
            HttpControllerContext context = controllerContext ?? ContextUtil.CreateControllerContext();
            HttpActionDescriptor descriptor = actionDescriptor ?? new Mock<HttpActionDescriptor>() { CallBase = true }.Object;

            if (descriptor.Configuration == null)
            {
                descriptor.Configuration = controllerContext.Configuration;
            }

            if (context.ControllerDescriptor == null)
            {
                context.ControllerDescriptor = new HttpControllerDescriptor(descriptor.Configuration);
            }

            if (descriptor.ControllerDescriptor == null)
            {
                descriptor.ControllerDescriptor = context.ControllerDescriptor;
            }

            return new HttpActionContext(context, descriptor);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Util/ConvertToStreamMessageHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Util
{
    internal class ConvertToStreamMessageHandler : DelegatingHandler
    {
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            HttpContent requestContent = await ToStreamContent(request.Content);
            request.Content = requestContent;
            HttpResponseMessage response = await base.SendAsync(request, cancellationToken);
            HttpContent responseContent = await ToStreamContent(response.Content);
            response.Content = responseContent;
            return response;
        }

        private static Task<HttpContent> ToStreamContent(HttpContent content)
        {
            ObjectContent objectContent = content as ObjectContent;
            if (objectContent != null)
            {
                return ToStreamContent(objectContent);
            }
            else
            {
                return Task.FromResult(content);
            }
        }

        private static async Task<HttpContent> ToStreamContent(ObjectContent content)
        {
            Stream stream = await content.ReadAsStreamAsync();
            StreamContent streamContent = new StreamContent(stream);
            foreach (var header in content.Headers)
            {
                streamContent.Headers.TryAddWithoutValidation(header.Key, header.Value);
            }

            return streamContent;
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Util/HttpServerTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Util;

namespace System.Web.Http
{
    public abstract class HttpServerTestBase
    {
        protected HttpServerTestBase(string baseAddress)
        {
            SetupHost(baseAddress);
        }

        protected HttpServer Server { get; private set; }

        protected HttpConfiguration Configuration { get; private set; }

        protected string BaseAddress { get; private set; }

        protected HttpClient Client { get; private set; }

        protected abstract void ApplyConfiguration(HttpConfiguration configuration);

        private void SetupHost(string baseAddress)
        {
            BaseAddress = baseAddress;

            Configuration = new HttpConfiguration();
            Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
            Configuration.MessageHandlers.Add(new ConvertToStreamMessageHandler());
            ApplyConfiguration(Configuration);

            Server = new HttpServer(Configuration);
            Client = new HttpClient(Server);
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/Util/ScenarioHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http
{
    public static class ScenarioHelper
    {
        public static string BaseAddress = "http://localhost";
        public static async Task RunTestAsync(
            string controllerName,
            string routeSuffix,
            HttpRequestMessage request,
            Func<HttpResponseMessage, Task> assert,
            Action<HttpConfiguration> configurer = null)
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };

            config.Routes.MapHttpRoute("Default", "{controller}" + routeSuffix, new { controller = controllerName });
            if (configurer != null)
            {
                configurer(config);
            }
            HttpServer server = new HttpServer(config);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);
            HttpResponseMessage response = null;
            try
            {
                // Act
                response = await invoker.SendAsync(request, CancellationToken.None);

                // Assert
                await assert(response);
            }
            finally
            {
                request.Dispose();
                if (response != null)
                {
                    response.Dispose();
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Integration.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.Owin.Test/ExceptionHandling/DefaultExceptionHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Results;
using Microsoft.TestCommon;

namespace System.Web.Http.Owin.ExceptionHandling
{
    public class DefaultExceptionHandlerTests
    {
        [Fact]
        public void HandleAsync_IfContextIsNull_Throws()
        {
            // Arrange
            IExceptionHandler product = CreateProductUnderTest();
            ExceptionHandlerContext context = null;
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.HandleAsync(context, cancellationToken), "context");
        }

        [Fact]
        public void HandleAsync_IfRequestIsNull_Throws()
        {
            // Arrange
            IExceptionHandler product = CreateProductUnderTest();
            ExceptionHandlerContext context = new ExceptionHandlerContext(new ExceptionContext(CreateException(), ExceptionCatchBlocks.HttpServer));

            Assert.Null(context.ExceptionContext.Request); // Guard
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgument(() => product.HandleAsync(context, cancellationToken), "context",
                "ExceptionContext.Request must not be null.");
        }

        [Fact]
        public async Task HandleAsync_HandlesExceptionViaCreateErrorResponse()
        {
            IExceptionHandler product = CreateProductUnderTest();

            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                expectedRequest.SetRequestContext(new HttpRequestContext { IncludeErrorDetail = true });
                ExceptionHandlerContext context = CreateValidContext(expectedRequest);
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                IHttpActionResult result = context.Result;
                ResponseMessageResult typedResult = Assert.IsType<ResponseMessageResult>(result);
                using (HttpResponseMessage response = typedResult.Response)
                {
                    Assert.NotNull(response);

                    using (HttpResponseMessage expectedResponse = expectedRequest.CreateErrorResponse(
                        HttpStatusCode.InternalServerError, context.ExceptionContext.Exception))
                    {
                        AssertErrorResponse(expectedResponse, response);
                    }

                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        private static void AssertErrorResponse(HttpResponseMessage expected, HttpResponseMessage actual)
        {
            Assert.NotNull(expected); // Guard
            ObjectContent<HttpError> expectedContent = Assert.IsType<ObjectContent<HttpError>>(expected.Content); // Guard
            Assert.NotNull(expectedContent.Formatter); // Guard

            Assert.NotNull(actual);
            Assert.Equal(expected.StatusCode, actual.StatusCode);
            ObjectContent<HttpError> actualContent = Assert.IsType<ObjectContent<HttpError>>(actual.Content);
            Assert.NotNull(actualContent.Formatter);
            Assert.Same(expectedContent.Formatter.GetType(), actualContent.Formatter.GetType());
            Assert.Equal(expectedContent.Value, actualContent.Value);
            Assert.Same(expected.RequestMessage, actual.RequestMessage);
        }

        private static ExceptionHandlerContext CreateContext(ExceptionContext exceptionContext)
        {
            return new ExceptionHandlerContext(exceptionContext);
        }

        private static Exception CreateException()
        {
            return new NotSupportedException();
        }

        private static DefaultExceptionHandler CreateProductUnderTest()
        {
            return new DefaultExceptionHandler();
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static ExceptionHandlerContext CreateValidContext(HttpRequestMessage request)
        {
            return CreateContext(new ExceptionContext(CreateException(),
                                                      ExceptionCatchBlocks.HttpServer,
                                                      request));
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/ExceptionHandling/EmptyExceptionLoggerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using Microsoft.TestCommon;

namespace System.Web.Http.Owin.ExceptionHandling
{
    public class EmptyExceptionLoggerTests
    {
        [Fact]
        public void LogAsync_ReturnsCompletedTask()
        {
            // Arrange
            IExceptionLogger product = CreateProductUnderTest();
            ExceptionLoggerContext context = CreateContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act
            Task task = product.LogAsync(context, cancellationToken);

            // Assert
            Assert.NotNull(task);
            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
        }

        private static ExceptionLoggerContext CreateContext()
        {
            return new ExceptionLoggerContext(new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer));
        }

        private static EmptyExceptionLogger CreateProductUnderTest()
        {
            return new EmptyExceptionLogger();
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/HostAuthenticationAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class HostAuthenticationAttributeTest
    {
        [Fact]
        public void AttributeUsageValidOn_IsClassOrMethod()
        {
            // Act
            AttributeUsageAttribute usage = (AttributeUsageAttribute)Attribute.GetCustomAttribute(
                typeof(HostAuthenticationAttribute), typeof(AttributeUsageAttribute));

            // Assert
            Assert.NotNull(usage);
            Assert.Equal(AttributeTargets.Class | AttributeTargets.Method, usage.ValidOn);
        }

        [Fact]
        public void AttributeUsageAllowMultiple_IsTrue()
        {
            // Act
            AttributeUsageAttribute usage = (AttributeUsageAttribute)Attribute.GetCustomAttribute(
                typeof(HostAuthenticationAttribute), typeof(AttributeUsageAttribute));

            // Assert
            Assert.NotNull(usage);
            Assert.True(usage.AllowMultiple);
        }

        [Fact]
        public void Constructor_ThrowsWhenInnerFilterIsNull()
        {
            // Arrange
            IAuthenticationFilter innerFilter = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { var ignore = CreateProductUnderTest(innerFilter); }, "innerFilter");
        }

        [Fact]
        public void InnerFilter_ReturnsSpecifiedInstance()
        {
            // Arrange
            IAuthenticationFilter expectedInnerFilter = CreateDummyFilter();
            HostAuthenticationAttribute product = CreateProductUnderTest(expectedInnerFilter);

            // Act
            IAuthenticationFilter innerFilter = product.InnerFilter;

            // Assert
            Assert.Same(expectedInnerFilter, innerFilter);
        }

        [Fact]
        public void AllowMultiple_ReturnsTrue()
        {
            // Arrange
            IAuthenticationFilter innerFilter = CreateDummyFilter();
            IAuthenticationFilter product = CreateProductUnderTest(innerFilter);

            // Act
            bool allowMultiple = product.AllowMultiple;

            // Assert
            Assert.True(allowMultiple);
        }

        [Fact]
        public void AuthenticateAsync_DelegatesToInnerFilter()
        {
            // Arrange
            Task expectedTask = CreateTask();
            HttpAuthenticationContext context = CreateAuthenticationContext();
            CancellationToken cancellationToken = CreateCancellationToken();
            Mock<IAuthenticationFilter> spyMock = new Mock<IAuthenticationFilter>(MockBehavior.Strict);
            spyMock.Setup(f => f.AuthenticateAsync(context, cancellationToken)).Returns(expectedTask);
            IAuthenticationFilter spy = spyMock.Object;
            IAuthenticationFilter product = CreateProductUnderTest(spy);

            // Act
            Task task = product.AuthenticateAsync(context, cancellationToken);

            // Assert
            Assert.Same(expectedTask, task);
        }

        [Fact]
        public void ChallengeAsync_DelegatesToInnerFilter()
        {
            // Arrange
            Task expectedTask = CreateTask();
            HttpAuthenticationChallengeContext context = CreateChallengeContext();
            CancellationToken cancellationToken = CreateCancellationToken();
            Mock<IAuthenticationFilter> spyMock = new Mock<IAuthenticationFilter>(MockBehavior.Strict);
            spyMock.Setup(f => f.ChallengeAsync(context, cancellationToken)).Returns(expectedTask);
            IAuthenticationFilter spy = spyMock.Object;
            IAuthenticationFilter product = CreateProductUnderTest(spy);

            // Act
            Task task = product.ChallengeAsync(context, cancellationToken);

            // Assert
            Assert.Same(expectedTask, task);
        }

        [Fact]
        public void ConstructorWithString_ThrowsWhenAuthenticationTypeIsNull()
        {
            // Arrange
            string authenticationType = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { var ignore = CreateProductUnderTest(authenticationType); },
                "authenticationType");
        }

        [Fact]
        public void InnerFilter_IsHostAuthenticationFilter_WhenUsingConstructorWithString()
        {
            // Arrange
            string expectedAuthenticationType = "Ignore";
            HostAuthenticationAttribute product = CreateProductUnderTest(expectedAuthenticationType);

            // Act
            IAuthenticationFilter innerFilter = product.InnerFilter;

            // Assert
            HostAuthenticationFilter typedInnerFilter = Assert.IsType<HostAuthenticationFilter>(innerFilter);
            Assert.Same(expectedAuthenticationType, typedInnerFilter.AuthenticationType);
        }

        [Fact]
        public void AuthenticationType_IsSpecifiedInstance_WhenUsingConstructorWithString()
        {
            // Arrange
            string expectedAuthenticationType = "Ignore";
            HostAuthenticationAttribute product = CreateProductUnderTest(expectedAuthenticationType);

            // Act
            string authenticationType = product.AuthenticationType;

            // Assert
            Assert.Same(expectedAuthenticationType, authenticationType);
        }

        private static HttpAuthenticationContext CreateAuthenticationContext()
        {
            return new HttpAuthenticationContext(new HttpActionContext(), CreateDummyPrincipal());
        }

        private static CancellationToken CreateCancellationToken()
        {
            return new CancellationToken(true);
        }

        private static HttpAuthenticationChallengeContext CreateChallengeContext()
        {
            return new HttpAuthenticationChallengeContext(new HttpActionContext(), CreateDummyActionResult());
        }

        private static IHttpActionResult CreateDummyActionResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static IAuthenticationFilter CreateDummyFilter()
        {
            return new Mock<IAuthenticationFilter>(MockBehavior.Strict).Object;
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static HostAuthenticationAttribute CreateProductUnderTest(string authenticationType)
        {
            return new HostAuthenticationAttribute(authenticationType);
        }

        private static HostAuthenticationAttribute CreateProductUnderTest(IAuthenticationFilter innerFilter)
        {
            return new HostAuthenticationAttribute(innerFilter);
        }

        private static Task CreateTask()
        {
            return Task.FromResult<object>(null);
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/HostAuthenticationFilterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Claims;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using Microsoft.Owin;
using Microsoft.Owin.Security;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class HostAuthenticationFilterTest
    {
        private const string ChallengeKey = "security.Challenge";

        [Fact]
        public void Constructor_Throws_WhenAuthenticationTypeIsNull()
        {
            // Arrange
            string authenticationType = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { var ignore = CreateProductUnderTest(authenticationType); },
                "authenticationType");
        }

        [Fact]
        public void AuthenticationType_ReturnsSpecifiedInstance()
        {
            // Arrange
            string expectedAuthenticationType = "AuthenticationType";
            HostAuthenticationFilter filter = CreateProductUnderTest(expectedAuthenticationType);

            // Act
            string authenticationType = filter.AuthenticationType;

            // Assert
            Assert.Same(expectedAuthenticationType, authenticationType);
        }

        [Fact]
        public void AllowMultiple_ReturnsTrue()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();

            // Act
            bool allowMultiple = filter.AllowMultiple;

            // Assert
            Assert.True(allowMultiple);
        }

        [Fact]
        public async Task AuthenticateAsync_SetsClaimsPrincipal_WhenOwinAuthenticateReturnsIdentity()
        {
            // Arrange
            string authenticationType = "AuthenticationType";
            IAuthenticationFilter filter = CreateProductUnderTest(authenticationType);
            IIdentity expectedIdentity = CreateDummyIdentity();
            IAuthenticationManager authenticationManager = CreateAuthenticationManager((a) =>
                {
                    AuthenticateResult result;

                    if (a == authenticationType)
                    {
                        result = new AuthenticateResult(expectedIdentity, new AuthenticationProperties(), new AuthenticationDescription());
                    }
                    else
                    {
                        result = null;
                    }

                    return Task.FromResult(result);
                });
            IOwinContext owinContext = CreateOwinContext(authenticationManager);
            HttpAuthenticationContext context;

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                context = CreateAuthenticationContext(request);

                // Act
                await filter.AuthenticateAsync(context, CancellationToken.None);
            }

            // Assert
            Assert.Null(context.ErrorResult);
            IPrincipal principal = context.Principal;
            ClaimsPrincipal claimsPrincipal = Assert.IsType<ClaimsPrincipal>(principal);
            IIdentity identity = claimsPrincipal.Identity;
            Assert.Same(expectedIdentity, identity);
        }

        [Fact]
        public async Task AuthenticateAsync_SetsNoPrincipalOrError_WhenOwinAuthenticateReturnsNullResult()
        {
            // Arrange
            string authenticationType = "AuthenticationType";
            IAuthenticationFilter filter = CreateProductUnderTest(authenticationType);
            IIdentity expectedIdentity = CreateDummyIdentity();
            IAuthenticationManager authenticationManager = CreateAuthenticationManager(
                (ignore1) => Task.FromResult<AuthenticateResult>(null));
            IOwinContext owinContext = CreateOwinContext(authenticationManager);
            IPrincipal expectedPrincipal = CreateDummyPrincipal();

            HttpAuthenticationContext context;

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                context = CreateAuthenticationContext(request, expectedPrincipal);

                // Act
                await filter.AuthenticateAsync(context, CancellationToken.None);
            }

            // Assert
            Assert.Null(context.ErrorResult);
            Assert.Same(expectedPrincipal, context.Principal);
        }

        [Fact]
        public async Task AuthenticateAsync_SetsNoPrincipalOrError_WhenOwinAuthenticateReturnsNullIdentity()
        {
            // Arrange
            string authenticationType = "AuthenticationType";
            IAuthenticationFilter filter = CreateProductUnderTest(authenticationType);
            IIdentity expectedIdentity = CreateDummyIdentity();
            IAuthenticationManager authenticationManager = CreateAuthenticationManager(
                (ignore1) => Task.FromResult(new AuthenticateResult(null, new AuthenticationProperties(), new AuthenticationDescription())));
            IOwinContext owinContext = CreateOwinContext(authenticationManager);
            IPrincipal expectedPrincipal = CreateDummyPrincipal();

            HttpAuthenticationContext context;

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                context = CreateAuthenticationContext(request, expectedPrincipal);

                // Act
                await filter.AuthenticateAsync(context, CancellationToken.None);
            }

            // Assert
            Assert.Null(context.ErrorResult);
            Assert.Same(expectedPrincipal, context.Principal);
        }

        [Fact]
        public Task AuthenticateAsync_Throws_WhenContextIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();

            // Act & Assert
            return Assert.ThrowsArgumentNullAsync(
                () => filter.AuthenticateAsync(null, CancellationToken.None),
                "context");
        }

        [Fact]
        public Task AuthenticateAsync_Throws_WhenRequestIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();
            HttpAuthenticationContext context = CreateAuthenticationContext();
            Assert.Null(context.Request);

            // Act & Assert
            return Assert.ThrowsAsync<InvalidOperationException>(
                () => filter.AuthenticateAsync(context, CancellationToken.None),
                "HttpAuthenticationContext.Request must not be null.");
        }

        [Fact]
        public async Task AuthenticateAsync_Throws_WhenOwinContextIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpAuthenticationContext context = CreateAuthenticationContext(request);

                // Act & Assert
                await Assert.ThrowsAsync<InvalidOperationException>(
                    () => filter.AuthenticateAsync(context, CancellationToken.None),
                    "No OWIN authentication manager is associated with the request.");
            }
        }

        [Fact]
        public async Task AuthenticateAsync_Throws_WhenAuthenticationManagerIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();
            IOwinContext owinContext = CreateOwinContext(null);

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                HttpAuthenticationContext context = CreateAuthenticationContext(request);

                // Act & Assert
                await Assert.ThrowsAsync<InvalidOperationException>(
                    () => filter.AuthenticateAsync(context, CancellationToken.None),
                    "No OWIN authentication manager is associated with the request.");
            }
        }

        [Fact]
        public async Task AuthenticateAsync_ReturnsCanceledTask_WhenCancellationIsRequested()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();
            IOwinContext owinContext = CreateOwinContext();

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                HttpAuthenticationContext context = CreateAuthenticationContext(request);
                CancellationToken cancellationToken = new CancellationToken(true);

                // Act & Assert
                await Assert.ThrowsAsync<OperationCanceledException>(() => filter.AuthenticateAsync(context, cancellationToken));
            }
        }

        [Fact]
        public async Task ChallengeAsync_AddsAuthenticationType_WhenOwinChallengeAlreadyExists()
        {
            // Arrange
            string expectedAuthenticationType = "AuthenticationType";
            IAuthenticationFilter filter = CreateProductUnderTest(expectedAuthenticationType);
            IHttpActionResult result = CreateDummyActionResult();
            string originalAuthenticationType = "FirstChallenge";
            AuthenticationProperties originalExtra = CreateExtra();
            AuthenticationResponseChallenge originalChallenge = new AuthenticationResponseChallenge(
                new string[] { originalAuthenticationType }, originalExtra);
            IAuthenticationManager authenticationManager = CreateAuthenticationManager(originalChallenge);
            IOwinContext owinContext = CreateOwinContext(authenticationManager);

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                HttpAuthenticationChallengeContext context = CreateChallengeContext(request, result);

                // Act
                await filter.ChallengeAsync(context, CancellationToken.None);
            }

            // Assert
            AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge;
            Assert.NotNull(challenge);
            string[] authenticationTypes = challenge.AuthenticationTypes;
            Assert.NotNull(authenticationTypes);
            Assert.Equal(2, authenticationTypes.Length);
            Assert.Same(originalAuthenticationType, authenticationTypes[0]);
            Assert.Same(expectedAuthenticationType, authenticationTypes[1]);
            AuthenticationProperties extra = challenge.Properties;
            Assert.Same(originalExtra, extra);
        }

        [Fact]
        public async Task ChallengeAsync_CreatesAuthenticationTypes_WhenOwinChallengeWithNullTypesAlreadyExists()
        {
            // Arrange
            string expectedAuthenticationType = "AuthenticationType";
            IAuthenticationFilter filter = CreateProductUnderTest(expectedAuthenticationType);
            IHttpActionResult result = CreateDummyActionResult();
            AuthenticationProperties originalExtra = CreateExtra();
            AuthenticationResponseChallenge originalChallenge = new AuthenticationResponseChallenge(null,
                originalExtra);
            IAuthenticationManager authenticationManager = CreateAuthenticationManager(originalChallenge);
            IOwinContext owinContext = CreateOwinContext(authenticationManager);

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                HttpAuthenticationChallengeContext context = CreateChallengeContext(request, result);

                // Act
                await filter.ChallengeAsync(context, CancellationToken.None);
            }

            // Assert
            AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge;
            Assert.NotNull(challenge);
            string[] authenticationTypes = challenge.AuthenticationTypes;
            Assert.NotNull(authenticationTypes);
            string authenticationType = Assert.Single(authenticationTypes);
            Assert.Same(expectedAuthenticationType, authenticationType);
            AuthenticationProperties extra = challenge.Properties;
            Assert.Same(originalExtra, extra);
        }

        [Fact]
        public async Task ChallengeAsync_CreatesOwinChallengeWithAuthenticationType_WhenNoChallengeExists()
        {
            // Arrange
            string expectedAuthenticationType = "AuthenticationType";
            IAuthenticationFilter filter = CreateProductUnderTest(expectedAuthenticationType);
            IHttpActionResult result = CreateDummyActionResult();
            IAuthenticationManager authenticationManager = CreateAuthenticationManager(
                (AuthenticationResponseChallenge)null);
            IOwinContext owinContext = CreateOwinContext(authenticationManager);

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                HttpAuthenticationChallengeContext context = CreateChallengeContext(request, result);

                // Act
                await filter.ChallengeAsync(context, CancellationToken.None);
            }

            // Assert
            AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge;
            Assert.NotNull(challenge);
            string[] authenticationTypes = challenge.AuthenticationTypes;
            Assert.NotNull(authenticationTypes);
            string authenticationType = Assert.Single(authenticationTypes);
            Assert.Same(expectedAuthenticationType, authenticationType);
            AuthenticationProperties extra = challenge.Properties;
            Assert.NotNull(extra);
        }

        [Fact]
        public Task ChallengeAsync_Throws_WhenContextIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();

            // Act & Assert
            return Assert.ThrowsArgumentNullAsync(() => filter.ChallengeAsync(null, CancellationToken.None), "context");
        }

        [Fact]
        public Task ChallengeAsync_Throws_WhenRequestIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();
            IHttpActionResult result = CreateDummyActionResult();
            HttpAuthenticationChallengeContext context = new HttpAuthenticationChallengeContext(
                new HttpActionContext(), result);
            Assert.Null(context.Request);

            // Act & Assert
            return Assert.ThrowsAsync<InvalidOperationException>(
                () => filter.ChallengeAsync(context, CancellationToken.None),
                "HttpAuthenticationChallengeContext.Request must not be null.");
        }

        [Fact]
        public async Task ChallengeAsync_Throws_WhenOwinContextIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();
            IHttpActionResult result = CreateDummyActionResult();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpAuthenticationChallengeContext context = CreateChallengeContext(request, result);

                // Act & Assert
                await Assert.ThrowsAsync<InvalidOperationException>(
                    () => filter.ChallengeAsync(context, CancellationToken.None),
                    "No OWIN authentication manager is associated with the request.");
            }
        }

        [Fact]
        public async Task ChallengeAsync_Throws_WhenAuthenticationManagerIsNull()
        {
            // Arrange
            IAuthenticationFilter filter = CreateProductUnderTest();
            IHttpActionResult result = CreateDummyActionResult();
            IOwinContext owinContext = CreateOwinContext(null);

            using (HttpRequestMessage request = CreateRequest(owinContext))
            {
                HttpAuthenticationChallengeContext context = CreateChallengeContext(request, result);

                // Act & Assert
                await Assert.ThrowsAsync<InvalidOperationException>(
                    () => filter.ChallengeAsync(context, CancellationToken.None),
                    "No OWIN authentication manager is associated with the request.");
            }
        }

        private static HttpActionContext CreateActionContext(HttpRequestMessage request)
        {
            HttpControllerContext controllerContext = new HttpControllerContext();
            controllerContext.Request = request;
            HttpActionDescriptor descriptor = CreateDummyActionDescriptor();
            return new HttpActionContext(controllerContext, descriptor);
        }

        private static HttpAuthenticationContext CreateAuthenticationContext()
        {
            HttpActionContext actionContext = new HttpActionContext();
            IPrincipal principal = CreateDummyPrincipal();
            return new HttpAuthenticationContext(actionContext, principal);
        }

        private static HttpAuthenticationContext CreateAuthenticationContext(HttpRequestMessage request)
        {
            IPrincipal principal = CreateDummyPrincipal();
            return CreateAuthenticationContext(request, principal);
        }

        private static HttpAuthenticationContext CreateAuthenticationContext(HttpRequestMessage request,
            IPrincipal principal)
        {
            HttpActionContext actionContext = CreateActionContext(request);
            return new HttpAuthenticationContext(actionContext, principal);
        }

        private static IAuthenticationManager CreateAuthenticationManager(
            Func<string, Task<AuthenticateResult>> authenticate)
        {
            Mock<IAuthenticationManager> mock = new Mock<IAuthenticationManager>(
                MockBehavior.Strict);
            string authenticationType = null;
            mock.Setup(m => m.AuthenticateAsync(It.IsAny<string>()))
                .Callback<string>((a) => { authenticationType = a; })
                .Returns(() => authenticate.Invoke(authenticationType));
            return mock.Object;
        }

        private static IAuthenticationManager CreateAuthenticationManager(AuthenticationResponseChallenge challenge)
        {
            Mock<IAuthenticationManager> mock = new Mock<IAuthenticationManager>(MockBehavior.Strict);
            mock.SetupProperty(m => m.AuthenticationResponseChallenge);
            IAuthenticationManager authenticationManager = mock.Object;
            authenticationManager.AuthenticationResponseChallenge = challenge;
            return authenticationManager;
        }

        private static HttpAuthenticationChallengeContext CreateChallengeContext(HttpRequestMessage request,
            IHttpActionResult result)
        {
            HttpActionContext actionContext = CreateActionContext(request);
            return new HttpAuthenticationChallengeContext(actionContext, result);
        }

        private static HttpActionDescriptor CreateDummyActionDescriptor()
        {
            return new Mock<HttpActionDescriptor>(MockBehavior.Strict).Object;
        }

        private static IHttpActionResult CreateDummyActionResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static ClaimsIdentity CreateDummyIdentity()
        {
            return new Mock<ClaimsIdentity>(MockBehavior.Strict).Object;
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static AuthenticationProperties CreateExtra()
        {
            return new AuthenticationProperties();
        }

        private static IOwinContext CreateOwinContext()
        {
            return new OwinContext();
        }

        private static IOwinContext CreateOwinContext(IAuthenticationManager authenticationManager)
        {
            Mock<IOwinContext> mockContext = new Mock<IOwinContext>(MockBehavior.Strict);
            mockContext.SetupGet(c => c.Authentication).Returns(authenticationManager);
            return mockContext.Object;
        }

        private static HostAuthenticationFilter CreateProductUnderTest()
        {
            return CreateProductUnderTest("IgnoreAuthenticationType");
        }

        private static HostAuthenticationFilter CreateProductUnderTest(string authenticationType)
        {
            return new HostAuthenticationFilter(authenticationType);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpRequestMessage CreateRequest(IOwinContext owinContext)
        {
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetOwinContext(owinContext);
            return request;
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/HttpMessageHandlerAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.Owin.ExceptionHandling;
using System.Web.Http.Results;
using System.Web.Http.Routing;
using Microsoft.Owin;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class HttpMessageHandlerAdapterTest
    {
        [Fact]
        public void ConstructorWithOptions_IfOptionsIsNull_Throws()
        {
            // Arrange
            HttpMessageHandlerOptions options = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(options), "options");
        }

        [Fact]
        public void ConstructorWithOptions_IfMessageHandlerIsNull_Throws()
        {
            // Arrange
            HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler: null);

            // Act & Assert.
            Assert.ThrowsArgument(() => CreateProductUnderTest(options), "options",
                "HttpMessageHandlerOptions.MessageHandler must not be null.");
        }

        [Fact]
        public void ConstructorWithOptions_IfBufferPolicySelectorIsNull_Throws()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler);
                options.BufferPolicySelector = null;

                // Act & Assert.
                Assert.ThrowsArgument(() => CreateProductUnderTest(options), "options",
                    "HttpMessageHandlerOptions.BufferPolicySelector must not be null.");
            }
        }

        [Fact]
        public void ConstructorWithOptions_IfExceptionLoggerIsNull_Throws()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler);
                options.ExceptionLogger = null;

                // Act & Assert.
                Assert.ThrowsArgument(() => CreateProductUnderTest(options), "options",
                    "HttpMessageHandlerOptions.ExceptionLogger must not be null.");
            }
        }

        [Fact]
        public void ConstructorWithOptions_IfExceptionHandlerIsNull_Throws()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler);
                options.ExceptionHandler = null;

                // Act & Assert.
                Assert.ThrowsArgument(() => CreateProductUnderTest(options), "options",
                    "HttpMessageHandlerOptions.ExceptionHandler must not be null.");
            }
        }

        [Fact]
        public void ConstructorWithList_IfMessageHandlerIsNull_Throws()
        {
            // Arrange
            HttpMessageHandler messageHandler = null;
            IHostBufferPolicySelector bufferPolicySelector = CreateDummyBufferPolicy();

            // Act & Assert.
#pragma warning disable 0618
            Assert.ThrowsArgumentNull(() => new HttpMessageHandlerAdapter(null, messageHandler, bufferPolicySelector),
                "messageHandler");
#pragma warning restore 0618
        }

        [Fact]
        public void ConstructorWithList_IfBufferPolicySelectorIsNull_Throws()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IHostBufferPolicySelector bufferPolicySelector = null;

                // Act & Assert.
#pragma warning disable 0618
                Assert.ThrowsArgumentNull(() => new HttpMessageHandlerAdapter(null, messageHandler,
                    bufferPolicySelector), "bufferPolicySelector");
#pragma warning restore 0618
            }
        }

        [Fact]
        public void MessageHandler_IfUsingOptionsConstructor_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpMessageHandler expectedMessageHandler = CreateDummyMessageHandler())
            {
                HttpMessageHandlerOptions options = CreateDummyOptions(expectedMessageHandler);
                HttpMessageHandlerAdapter product = CreateProductUnderTest(options);

                // Act
                HttpMessageHandler messageHandler = product.MessageHandler;

                // Assert
                Assert.Same(expectedMessageHandler, messageHandler);
            }
        }

        [Fact]
        public void MessageHandler_IfUsingListConstructor_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpMessageHandler expectedMessageHandler = CreateDummyMessageHandler())
            {
                IHostBufferPolicySelector bufferPolicySelector = CreateDummyBufferPolicy();
#pragma warning disable 0618
                HttpMessageHandlerAdapter product = new HttpMessageHandlerAdapter(null, expectedMessageHandler,
                    bufferPolicySelector);
#pragma warning restore 0618

                // Act
                HttpMessageHandler messageHandler = product.MessageHandler;

                // Assert
                Assert.Same(expectedMessageHandler, messageHandler);
            }
        }

        [Fact]
        public void BufferPolicySelector_IfUsingOptionsConstructor_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IHostBufferPolicySelector expectedBufferPolicySelector = CreateDummyBufferPolicy();
                HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler);
                options.BufferPolicySelector = expectedBufferPolicySelector;
                HttpMessageHandlerAdapter product = CreateProductUnderTest(options);

                // Act
                IHostBufferPolicySelector bufferPolicySelector = product.BufferPolicySelector;

                // Assert
                Assert.Same(expectedBufferPolicySelector, bufferPolicySelector);
            }
        }

        [Fact]
        public void BufferPolicySelector_IfUsingListConstructor_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IHostBufferPolicySelector expectedBufferPolicySelector = CreateDummyBufferPolicy();
#pragma warning disable 0618
                HttpMessageHandlerAdapter product = new HttpMessageHandlerAdapter(null, messageHandler,
                    expectedBufferPolicySelector);
#pragma warning restore 0618

                // Act
                IHostBufferPolicySelector bufferPolicySelector = product.BufferPolicySelector;

                // Assert
                Assert.Same(expectedBufferPolicySelector, bufferPolicySelector);
            }
        }

        [Fact]
        public void ExceptionLogger_IfUsingOptionsConstructor_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
                HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler);
                options.ExceptionLogger = expectedExceptionLogger;
                HttpMessageHandlerAdapter product = CreateProductUnderTest(options);

                // Act
                IExceptionLogger exceptionLogger = product.ExceptionLogger;

                // Assert
                Assert.Same(expectedExceptionLogger, exceptionLogger);
            }
        }

        [Fact]
        public void ExceptionLogger_IfUsingListConstructor_ReturnsEmptyExceptionLogger()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IHostBufferPolicySelector bufferPolicySelector = CreateDummyBufferPolicy();
#pragma warning disable 0618
                HttpMessageHandlerAdapter product = new HttpMessageHandlerAdapter(null, messageHandler,
                    bufferPolicySelector);
#pragma warning restore 0618

                // Act
                IExceptionLogger exceptionLogger = product.ExceptionLogger;

                // Assert
                Assert.IsType<EmptyExceptionLogger>(exceptionLogger);
            }
        }

        [Fact]
        public void ExceptionHandler_IfUsingOptionsConstructor_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();
                HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler);
                options.ExceptionHandler = expectedExceptionHandler;
                HttpMessageHandlerAdapter product = CreateProductUnderTest(options);

                // Act
                IExceptionHandler exceptionHandler = product.ExceptionHandler;

                // Assert
                Assert.Same(expectedExceptionHandler, exceptionHandler);
            }
        }

        [Fact]
        public void ExceptionHandler_IfUsingListConstructor_ReturnsDefaultExceptionHandler()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IHostBufferPolicySelector bufferPolicySelector = CreateDummyBufferPolicy();
#pragma warning disable 0618
                HttpMessageHandlerAdapter product = new HttpMessageHandlerAdapter(null, messageHandler,
                    bufferPolicySelector);
#pragma warning restore 0618

                // Act
                IExceptionHandler exceptionHandler = product.ExceptionHandler;

                // Assert
                Assert.IsType<DefaultExceptionHandler>(exceptionHandler);
            }
        }

        [Fact]
        public void AppDisposing_IfUsingOptionsConstructor_ReturnsSpecifiedValue()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                CancellationToken expectedAppDisposing = tokenSource.Token;
                HttpMessageHandlerOptions options = CreateDummyOptions(messageHandler);
                options.AppDisposing = expectedAppDisposing;
                HttpMessageHandlerAdapter product = CreateProductUnderTest(options);

                // Act
                CancellationToken appDisposing = product.AppDisposing;

                // Assert
                Assert.Equal(expectedAppDisposing, appDisposing);
            }
        }

        [Fact]
        public void AppDisposing_IfUsingListConstructor_ReturnsDefaultExceptionHandler()
        {
            // Arrange
            using (HttpMessageHandler messageHandler = CreateDummyMessageHandler())
            {
                IHostBufferPolicySelector bufferPolicySelector = CreateDummyBufferPolicy();
#pragma warning disable 0618
                HttpMessageHandlerAdapter product = new HttpMessageHandlerAdapter(null, messageHandler,
                    bufferPolicySelector);
#pragma warning restore 0618

                // Act
                CancellationToken appDisposing = product.AppDisposing;

                // Assert
                Assert.Equal(CancellationToken.None, appDisposing);
            }
        }

        [Fact]
        public void TriggeringHostOnAppDisposing_DisposesMessageHandler()
        {
            // Arrange
            using (SpyDisposeHttpMessageHandler spy = new SpyDisposeHttpMessageHandler())
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                HttpMessageHandlerOptions options = CreateDummyOptions(spy);
                options.AppDisposing = tokenSource.Token;
                HttpMessageHandlerAdapter product = CreateProductUnderTest(options);

                // Act
                tokenSource.Cancel(throwOnFirstException: true);
                CancellationToken appDisposing = product.AppDisposing;

                // Assert
                Assert.True(spy.Disposed);
            }
        }

        [Fact]
        public async Task Invoke_ThrowsOnNullRequest()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);
            var mockContext = new Mock<IOwinContext>();
            mockContext.Setup(context => context.Response).Returns(new OwinResponse());

            await Assert.ThrowsAsync<InvalidOperationException>(
                () => adapter.Invoke(mockContext.Object),
                "The OWIN context's Request property must not be null.");
        }

        [Fact]
        public async Task Invoke_ThrowsOnNullResponse()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);
            var mockContext = new Mock<IOwinContext>();
            mockContext.Setup(context => context.Request).Returns(new OwinRequest());

            await Assert.ThrowsAsync<InvalidOperationException>(
                () => adapter.Invoke(mockContext.Object),
                "The OWIN context's Response property must not be null.");
        }

        [Fact]
        public async Task Invoke_BuildsAppropriateRequestMessage()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var request = handler.Request;
            Assert.Equal(HttpMethod.Get, request.Method);
            Assert.Equal("http://localhost/vroot/api/customers", request.RequestUri.AbsoluteUri);
        }

        [Fact]
        public async Task Invoke_BuildsUriWithQueryStringIfPresent()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            environment["owin.RequestQueryString"] = "id=45";
            var adapter = CreateProductUnderTest(new HttpMessageHandlerOptions
            {
                MessageHandler = handler,
                BufferPolicySelector = bufferPolicySelector,
                ExceptionLogger = new EmptyExceptionLogger(),
                ExceptionHandler = new DefaultExceptionHandler()
            });

            await adapter.Invoke(new OwinContext(environment));

            var request = handler.Request;
            Assert.Equal(HttpMethod.Get, request.Method);
            Assert.Equal("http://localhost/vroot/api/customers?id=45", request.RequestUri.AbsoluteUri);
        }

        [Fact]
        public async Task Invoke_BuildsUriWithHostAndPort()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost:12345", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var request = handler.Request;
            Assert.Equal(HttpMethod.Get, request.Method);
            Assert.Equal("http://localhost:12345/vroot/api/customers", request.RequestUri.AbsoluteUri);
        }

        [Theory]
        [InlineData("a b")]
        // reserved characters
        [InlineData("!*'();:@&=$,[]")]
        // common unreserved characters
        [InlineData(@"-_.~+""<>^`{|}")]
        // random unicode characters
        [InlineData("激光這")]
        [InlineData("?#")]
        public async Task Invoke_CreatesUri_ThatGeneratesCorrectlyDecodedStrings(string decodedId)
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers/" + decodedId);
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);
            var route = new HttpRoute("api/customers/{id}");

            await adapter.Invoke(new OwinContext(environment));
            IHttpRouteData routeData = route.GetRouteData("/vroot", handler.Request);

            Assert.NotNull(routeData);
            Assert.Equal(decodedId, routeData.Values["id"]);
        }

        [Theory]
        [InlineData("%24", "$")]
        [InlineData("%28%29", "()")]
        [InlineData("%5B%5D", "[]")]
        [InlineData("%7B%7D", "{}")]
        public async Task Invoke_CreatesUri_ContainingCorrectlyDecodedStrings(string encoded, string decoded)
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers/" + encoded);
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);
            var route = new HttpRoute("api/customers/{id}");

            await adapter.Invoke(new OwinContext(environment));
            IHttpRouteData routeData = route.GetRouteData("/vroot", handler.Request);

            Assert.NotNull(routeData);
            Assert.Equal(decoded, routeData.Values["id"]);
        }

        [Fact]
        public async Task Invoke_AddsRequestHeadersToRequestMessage()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var requestHeaders = environment["owin.RequestHeaders"] as IDictionary<string, string[]>;
            requestHeaders["Accept"] = new string[] { "application/json", "application/xml" };
            requestHeaders["Content-Length"] = new string[] { "45" };
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var request = handler.Request;
            Assert.Equal(2, request.Headers.Count());
            Assert.Equal(new string[] { "application/json", "application/xml" }, request.Headers.Accept.Select(mediaType => mediaType.ToString()).ToArray());
            Assert.Equal("localhost", request.Headers.Host);
            Assert.Single(request.Content.Headers);
            Assert.Equal(45, request.Content.Headers.ContentLength);
        }

        [Fact]
        public async Task Invoke_SetsRequestBodyOnRequestMessage()
        {
            string body = null;
            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = async (r, i) =>
            {
                body = await r.Content.ReadAsStringAsync();
                return new HttpResponseMessage();
            };
            var handler = CreateLambdaMessageHandler(sendAsync);
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var expectedBody = "This is the request body.";
            environment["owin.RequestBody"] = new MemoryStream(Encoding.UTF8.GetBytes(expectedBody));
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            Assert.Equal(expectedBody, body);
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task Invoke_RespectsInputBufferingSetting(bool bufferInput)
        {
            var expectedBody = "This is the request body.";
            var requestBodyMock = new Mock<MemoryStream>(Encoding.UTF8.GetBytes(expectedBody));
            requestBodyMock.CallBase = true;
            requestBodyMock.Setup(s => s.CanSeek).Returns(false);
            MemoryStream requestBody = requestBodyMock.Object;

            string body = null;
            bool originalStreamDisposed = false;
            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = async (r, i) =>
            {
                body = await r.Content.ReadAsStringAsync();
                originalStreamDisposed = !requestBody.CanRead;
                return new HttpResponseMessage();
            };
            var handler = CreateLambdaMessageHandler(sendAsync);
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: bufferInput, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            environment["owin.RequestBody"] = requestBody;
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            // Assert that Web API gets the right body
            Assert.Equal(expectedBody, body);
            // The original stream should have been fully read and then disposed only when buffering.
            Assert.Equal(bufferInput, originalStreamDisposed);

            if (bufferInput)
            {
                // Assert that the OWIN environment still has a request body that can be read
                var owinRequestBody = environment["owin.RequestBody"] as Stream;
                byte[] bodyBytes = new byte[25];
                int charsRead = owinRequestBody.Read(bodyBytes, 0, 25);
                Assert.Equal(expectedBody, Encoding.UTF8.GetString(bodyBytes));
            }
        }

        [Fact]
        public async Task Invoke_IfBufferPolicyDisablesInputBuffering_DisablesRequestBuffering()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: false);

            using (HttpResponseMessage response = CreateResponse())
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicySelector)))
            {
                bool bufferingDisabled = false;
                Action disableBuffering = () => bufferingDisabled = true;
                IOwinRequest owinRequest = CreateFakeOwinRequest(disableBuffering);
                IOwinResponse owinResponse = CreateFakeOwinResponse();
                IOwinContext expectedContext = CreateStubOwinContext(owinRequest, owinResponse);

                // Act
                await product.Invoke(expectedContext);

                // Assert
                Assert.True(bufferingDisabled);
            }
        }

        [Fact]
        public async Task Invoke_IfBufferPolicyEnablesInputBuffering_DoesNotDisableRequestBuffering()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: true,
                bufferOutput: false);

            using (HttpResponseMessage response = CreateResponse())
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicySelector)))
            {
                bool bufferingDisabled = false;
                Action disableBuffering = () => bufferingDisabled = true;
                IOwinRequest owinRequest = CreateFakeOwinRequest(disableBuffering);
                IOwinResponse owinResponse = CreateFakeOwinResponse();
                IOwinContext expectedContext = CreateStubOwinContext(owinRequest, owinResponse);

                // Act
                await product.Invoke(expectedContext);

                // Assert
                Assert.False(bufferingDisabled);
            }
        }

        [Fact]
        public async Task Invoke_SetsOwinEnvironment()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var request = handler.Request;
            Assert.Same(environment, request.GetOwinEnvironment());
        }

        [Fact]
        public async Task Invoke_SetsOwinRequestContext()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: true);

            using (HttpResponseMessage response = CreateResponse())
            {
                HttpRequestMessage request = null;
                Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = (r, c) =>
                {
                    request = r;
                    return Task.FromResult(response);
                };

                using (HttpMessageHandler messageHandler = CreateLambdaMessageHandler(sendAsync))
                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                    bufferPolicySelector)))
                {
                    IOwinRequest owinRequest = CreateFakeOwinRequest();
                    IOwinResponse owinResponse = CreateFakeOwinResponse();
                    IOwinContext expectedContext = CreateStubOwinContext(owinRequest, owinResponse);

                    // Act
                    await product.Invoke(expectedContext);

                    // Assert
                    HttpRequestContext requestContext = request.GetRequestContext();
                    OwinHttpRequestContext typedContext = Assert.IsType<OwinHttpRequestContext>(requestContext);
                    Assert.Same(expectedContext, typedContext.Context);
                    Assert.Same(request, typedContext.Request);
                }
            }
        }

        [Theory]
        [InlineData(null, false)]
        [InlineData(false, false)]
        [InlineData(true, true)]
        public async Task Invoke_SetsRequestIsLocalProperty(bool? isLocal, bool expectedRequestLocal)
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            if (isLocal.HasValue)
            {
                environment["server.IsLocal"] = isLocal.Value;
            }
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var request = handler.Request;
            Assert.Equal(expectedRequestLocal, request.IsLocal());
        }

        [Fact]
        public async Task Invoke_SetsClientCertificate()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var clientCert = new Mock<X509Certificate2>().Object;
            environment["ssl.ClientCertificate"] = clientCert;
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var request = handler.Request;
            Assert.Equal(clientCert, request.GetClientCertificate());
        }

        [Fact]
        public async Task Invoke_CallsMessageHandler_WithEnvironmentCancellationToken()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var cancellationToken = new CancellationToken();
            environment["owin.CallCancelled"] = cancellationToken;
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            Assert.Equal(cancellationToken, handler.CancellationToken);
        }

        [Fact]
        public async Task Invoke_CallsMessageHandler_WithEnvironmentUser()
        {
            var handler = CreateOKHandlerStub();
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var user = new Mock<IPrincipal>().Object;
            environment["server.User"] = user;
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            Assert.Equal(user, handler.User);
        }

        [Fact]
        public async Task Invoke_Throws_IfMessageHandlerReturnsNull()
        {
            HttpResponseMessage response = null;
            var handler = new HandlerStub() { Response = response };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await Assert.ThrowsAsync<InvalidOperationException>(
                () => adapter.Invoke(new OwinContext(environment)),
                "The message handler did not return a response message.");
        }

        [Fact]
        public async Task Invoke_DoesNotCallNext_IfMessageHandlerDoesNotReturn404()
        {
            var mockNext = new Mock<OwinMiddleware>(MockBehavior.Strict, null);
            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
            var handler = new HandlerStub() { Response = response, AddNoRouteMatchedKey = true };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(mockNext.Object, options);

            // Does not throw.
            await adapter.Invoke(new OwinContext(environment));
        }

        [Fact]
        public async Task Invoke_DoesNotCallNext_IfMessageHandlerDoesNotAddNoRouteMatchedProperty()
        {
            var mockNext = new Mock<OwinMiddleware>(MockBehavior.Strict, null);
            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NotFound);
            var handler = new HandlerStub() { Response = response, AddNoRouteMatchedKey = false };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(mockNext.Object, options);

            // Does not throw.
            await adapter.Invoke(new OwinContext(environment));
        }

        [Fact]
        public async Task Invoke_CallsNext_IfMessageHandlerReturns404WithNoRouteMatched()
        {
            var nextMock = new Mock<OwinMiddleware>(null);
            nextMock.Setup(middleware => middleware.Invoke(It.IsAny<OwinContext>())).Returns(TaskHelpers.Completed()).Verifiable();
            HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.NotFound);
            var handler = new HandlerStub() { Response = response, AddNoRouteMatchedKey = true };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(nextMock.Object, options);

            await adapter.Invoke(new OwinContext(environment));

            nextMock.Verify();
        }

        [Fact]
        public async Task Invoke_SetsResponseStatusCodeAndReasonPhrase()
        {
            var expectedReasonPhrase = "OH NO!";
            var response = new HttpResponseMessage(HttpStatusCode.ServiceUnavailable) { ReasonPhrase = expectedReasonPhrase };
            var handler = new HandlerStub() { Response = response };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            Assert.Equal(503, environment["owin.ResponseStatusCode"]);
            Assert.Equal(expectedReasonPhrase, environment["owin.ResponseReasonPhrase"]);
        }

        [Fact]
        public async Task Invoke_SetsResponseHeaders()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK);
            response.Headers.Location = new Uri("http://www.location.com/");
            response.Content = new StringContent(@"{""x"":""y""}", Encoding.UTF8, "application/json");
            var handler = new HandlerStub() { Response = response };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var responseHeaders = environment["owin.ResponseHeaders"] as IDictionary<string, string[]>;
            Assert.Equal(3, responseHeaders.Count);
            Assert.Equal("http://www.location.com/", Assert.Single(responseHeaders["Location"]));
            Assert.Equal("9", Assert.Single(responseHeaders["Content-Length"]));
            Assert.Equal("application/json; charset=utf-8", Assert.Single(responseHeaders["Content-Type"]));
        }

        [Fact]
        public async Task Invoke_SetsResponseBody()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK);
            var expectedBody = @"{""x"":""y""}";
            response.Content = new StringContent(expectedBody, Encoding.UTF8, "application/json");
            var handler = new HandlerStub() { Response = response };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var responseStream = new MemoryStream();
            environment["owin.ResponseBody"] = responseStream;
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            responseStream.Seek(0, SeekOrigin.Begin);
            byte[] bodyBytes = new byte[9];
            int charsRead = responseStream.Read(bodyBytes, 0, 9);
            // Assert that we can read 9 characters and no more characters after that
            Assert.Equal(9, charsRead);
            Assert.Equal(-1, responseStream.ReadByte());
            Assert.Equal(expectedBody, Encoding.UTF8.GetString(bodyBytes));
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task Invoke_RespectsOutputBufferingSetting(bool bufferOutput)
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK);
            response.Content = new ObjectContent<string>("blue", new JsonMediaTypeFormatter());
            var handler = new HandlerStub() { Response = response };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: bufferOutput);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var responseHeaders = environment["owin.ResponseHeaders"] as IDictionary<string, string[]>;
            if (bufferOutput)
            {
                Assert.True(responseHeaders.ContainsKey("Content-Length"));
            }
            else
            {
                Assert.False(responseHeaders.ContainsKey("Content-Length"));
            }
        }

        [Fact]
        public async Task Invoke_IfBufferPolicyDisablesOutputBuffering_DisablesResponseBuffering()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: false);

            using (HttpResponseMessage response = CreateResponse())
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicySelector)))
            {
                IOwinRequest owinRequest = CreateFakeOwinRequest();
                bool bufferingDisabled = false;
                Action disableBuffering = () => bufferingDisabled = true;
                IOwinResponse owinResponse = CreateFakeOwinResponse(disableBuffering);
                IOwinContext expectedContext = CreateStubOwinContext(owinRequest, owinResponse);

                // Act
                await product.Invoke(expectedContext);

                // Assert
                Assert.True(bufferingDisabled);
            }
        }

        [Fact]
        public async Task Invoke_IfBufferPolicyEnablesOutputBuffering_DoesNotDisableResponseBuffering()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: true);

            using (HttpResponseMessage response = CreateResponse())
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicySelector)))
            {
                IOwinRequest owinRequest = CreateFakeOwinRequest();
                bool bufferingDisabled = false;
                Action disableBuffering = () => bufferingDisabled = true;
                IOwinResponse owinResponse = CreateFakeOwinResponse(disableBuffering);
                IOwinContext expectedContext = CreateStubOwinContext(owinRequest, owinResponse);

                // Act
                await product.Invoke(expectedContext);

                // Assert
                Assert.False(bufferingDisabled);
            }
        }

        [Fact]
        public async Task Invoke_AddsZeroContentLengthHeader_WhenThereIsNoContent()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK);
            var handler = new HandlerStub() { Response = response };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var responseHeaders = environment["owin.ResponseHeaders"] as IDictionary<string, string[]>;
            Assert.Equal("0", responseHeaders["Content-Length"][0]);
        }

        [Fact]
        public async Task Invoke_IfTransferEncodingChunkedAndContentLengthAreBothSet_IgnoresContentLength()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK);
            response.Content = new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes("Hello world")));
            response.Headers.TransferEncodingChunked = true;
            var handler = new HandlerStub() { Response = response };
            var bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            var environment = CreateOwinEnvironment("GET", "http", "localhost", "/vroot", "/api/customers");
            var options = CreateValidOptions(handler, bufferPolicySelector);
            var adapter = CreateProductUnderTest(options);

            await adapter.Invoke(new OwinContext(environment));

            var responseHeaders = environment["owin.ResponseHeaders"] as IDictionary<string, string[]>;
            Assert.False(responseHeaders.ContainsKey("Content-Length"));
        }

        [Fact]
        public async Task Invoke_IfTransferEncodingIsJustChunked_DoesNotCopyHeader()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicy = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);

            using (HttpResponseMessage response = CreateResponse())
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicy)))
            {
                response.Headers.TransferEncodingChunked = true;

                IOwinRequest owinRequest = CreateFakeOwinRequest();
                IOwinResponse owinResponse = CreateFakeOwinResponseWithHeaders();
                IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                // Act
                await product.Invoke(context);

                // Assert
                Assert.DoesNotContain("Transfer-Encoding", owinResponse.Headers.Keys);
            }
        }

        [Fact]
        public async Task Invoke_IfTransferEncodingIsIdentity_DoesCopyHeader()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicy = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);

            using (HttpResponseMessage response = CreateResponse())
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicy)))
            {
                response.Headers.TransferEncoding.Add(new TransferCodingHeaderValue("identity"));

                IOwinRequest owinRequest = CreateFakeOwinRequest();
                IOwinResponse owinResponse = CreateFakeOwinResponseWithHeaders();
                IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                // Act
                await product.Invoke(context);

                // Assert
                Assert.Contains("Transfer-Encoding", owinResponse.Headers.Keys);
                Assert.Equal("identity", owinResponse.Headers["Transfer-Encoding"]);
            }
        }

        [Fact]
        public async Task Invoke_IfTransferEncodingIsIdentityChunked_DoesCopyHeader()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicy = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);

            using (HttpResponseMessage response = CreateResponse())
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicy)))
            {
                response.Headers.TransferEncoding.Add(new TransferCodingHeaderValue("identity"));
                response.Headers.TransferEncodingChunked = true;
                Assert.Equal("identity, chunked", response.Headers.TransferEncoding.ToString()); // Guard

                IOwinRequest owinRequest = CreateFakeOwinRequest();
                IOwinResponse owinResponse = CreateFakeOwinResponseWithHeaders();
                IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                // Act
                await product.Invoke(context);

                // Assert
                Assert.Contains("Transfer-Encoding", owinResponse.Headers.Keys);
                Assert.Equal("identity,chunked", owinResponse.Headers["Transfer-Encoding"]);
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingFaults_DisposesOriginalResponse()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: true);

            using (HttpContent content = CreateFaultingContent())
            using (SpyDisposeHttpResponseMessage spy = new SpyDisposeHttpResponseMessage(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(spy))
            {
                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (MemoryStream output = new MemoryStream())
                {
                    IOwinRequest owinRequest = CreateFakeOwinRequest();
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);
                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    Assert.True(spy.Disposed);
                }
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingFaults_CallsExceptionServices()
        {
            // Arrange
            Exception expectedException = CreateException();

            using (HttpContent content = CreateFaultingContent(expectedException))
            using (HttpResponseMessage expectedResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedResponse))
            {
                Mock<IExceptionLogger> exceptionLoggerMock = CreateStubExceptionLoggerMock();
                IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

                Mock<IExceptionHandler> exceptionHandlerMock = CreateStubExceptionHandlerMock();
                IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionLogger = exceptionLogger;
                options.ExceptionHandler = exceptionHandler;

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act & Assert
                    await Assert.ThrowsAsync<Exception>(() => product.Invoke(context));

                    Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                        c != null
                        && c.Exception == expectedException
                        && c.CatchBlock == OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferContent
                        && c.Request != null
                        && c.Response == expectedResponse;

                    exceptionLoggerMock.Verify(l => l.LogAsync(
                        It.Is<ExceptionLoggerContext>(c => exceptionContextMatches(c.ExceptionContext)),
                        expectedCancellationToken), Times.Once());
                    exceptionHandlerMock.Verify(h => h.HandleAsync(
                        It.Is<ExceptionHandlerContext>((c) => exceptionContextMatches(c.ExceptionContext)),
                        expectedCancellationToken), Times.Once());
                }
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingCancels_DoesNotCallExceptionServices()
        {
            // Arrange
            Exception expectedException = new OperationCanceledException();

            using (HttpContent content = CreateFaultingContent(expectedException))
            using (HttpResponseMessage expectedResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedResponse))
            {
                Mock<IExceptionLogger> exceptionLoggerMock = new Mock<IExceptionLogger>(MockBehavior.Strict);
                IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

                Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionLogger = exceptionLogger;
                options.ExceptionHandler = exceptionHandler;

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act & Assert
                    await Assert.ThrowsAsync<OperationCanceledException>(() => product.Invoke(context));
                }
            }
        }

        [Fact]
        public async Task Invoke_IfExceptionHandlerSetsNullResult_PropogatesFaultedTaskException()
        {
            // Arrange
            Exception expectedException = CreateExceptionWithCallStack();
            string expectedStackTrace = expectedException.StackTrace;

            using (HttpContent content = CreateFaultingContent(expectedException))
            using (HttpResponseMessage response = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            {
                IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
                IExceptionHandler exceptionHandler = CreateExceptionHandler(result: null);

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionLogger = exceptionLogger;
                options.ExceptionHandler = exceptionHandler;

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                {
                    IOwinRequest owinRequest = CreateFakeOwinRequest();
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act & Assert
                    var exception = await Assert.ThrowsAsync<Exception>(() => product.Invoke(context));
                    Assert.Same(expectedException, exception);
                    Assert.NotNull(exception.StackTrace);
                    Assert.StartsWith(expectedStackTrace, exception.StackTrace);
                }
            }
        }

        [Fact]
        public async Task Invoke_IfExceptionHandlerHandlesException_SendsResponse()
        {
            // Arrange
            Exception expectedException = CreateException();
            string expectedErrorContents = "Sorry";
            HttpStatusCode expectedErrorStatusCode = HttpStatusCode.BadRequest;

            using (HttpContent content = CreateFaultingContent())
            using (HttpResponseMessage response = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (StringContent errorContent = new StringContent(expectedErrorContents))
            using (HttpResponseMessage errorResponse = CreateResponse(errorContent))
            {
                errorResponse.StatusCode = expectedErrorStatusCode;
                errorResponse.Content = errorContent;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionLogger = CreateStubExceptionLogger();
                options.ExceptionHandler = CreateExceptionHandler(new ResponseMessageResult(errorResponse));

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (MemoryStream output = new MemoryStream())
                {
                    IOwinRequest owinRequest = CreateFakeOwinRequest();

                    int statusCode = 0;
                    Mock<IOwinResponse> mock = new Mock<IOwinResponse>();
                    mock.Setup(r => r.Headers).Returns(new Mock<IHeaderDictionary>().Object);
                    mock.SetupGet(r => r.Body).Returns(output);
                    mock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((v) => statusCode = v);
                    IOwinResponse owinResponse = mock.Object;

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    Assert.Equal((int)expectedErrorStatusCode, statusCode);
                    using (HttpRequestMessage request = CreateRequest(includeErrorDetail: true))
                    {
                        Assert.Equal(expectedErrorContents, Encoding.UTF8.GetString(output.ToArray()));
                    }
                }
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingFaultsAndUsingListConstructor_SendsErrorResponse()
        {
            // Arrange
            Exception expectedException = CreateException();
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: true);

            using (HttpContent content = CreateFaultingContent(expectedException))
            using (HttpResponseMessage response = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicySelector)))
            using (MemoryStream output = new MemoryStream())
            {
                IOwinRequest owinRequest = CreateFakeOwinRequest();

                int statusCode = 0;
                Mock<IOwinResponse> mock = new Mock<IOwinResponse>();
                mock.Setup(r => r.Headers).Returns(new Mock<IHeaderDictionary>().Object);
                mock.SetupGet(r => r.Body).Returns(output);
                mock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((v) => statusCode = v);
                IOwinResponse owinResponse = mock.Object;

                IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                // Act
                await product.Invoke(context);

                // Assert
                Assert.Equal(500, statusCode);
                using (HttpRequestMessage request = CreateRequest(includeErrorDetail: true))
                using (HttpResponseMessage expectedResponse = request.CreateErrorResponse(
                    HttpStatusCode.InternalServerError, expectedException))
                {
                    string expectedContents = await expectedResponse.Content.ReadAsStringAsync();
                    Assert.Equal(expectedContents, Encoding.UTF8.GetString(output.ToArray()));
                }
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingErrorFaults_DisposesErrorResponse()
        {
            // Arrange
            Exception expectedOriginalException = CreateException();
            Exception expectedErrorException = CreateException();

            using (HttpContent content = CreateFaultingContent(expectedOriginalException))
            using (HttpResponseMessage expectedOriginalResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedOriginalResponse))
            using (HttpContent errorContent = CreateFaultingContent(expectedErrorException))
            using (SpyDisposeHttpResponseMessage spy = new SpyDisposeHttpResponseMessage(errorContent))
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionHandler = CreateExceptionHandler(new ResponseMessageResult(spy));

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    Assert.True(spy.Disposed);
                }
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingErrorFaults_CallsExceptionLogger()
        {
            // Arrange
            Exception expectedOriginalException = CreateException();
            Exception expectedErrorException = CreateException();

            using (HttpContent content = CreateFaultingContent(expectedOriginalException))
            using (HttpResponseMessage expectedOriginalResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedOriginalResponse))
            using (HttpContent errorContent = CreateFaultingContent(expectedErrorException))
            using (HttpResponseMessage expectedErrorResponse = CreateResponse(errorContent))
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                Mock<IExceptionLogger> mock = CreateStubExceptionLoggerMock();
                IExceptionLogger exceptionLogger = mock.Object;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionLogger = exceptionLogger;
                options.ExceptionHandler = CreateExceptionHandler(new ResponseMessageResult(expectedErrorResponse));

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    mock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                        c.ExceptionContext != null
                        && c.ExceptionContext.Exception == expectedOriginalException
                        && c.ExceptionContext.CatchBlock ==
                            OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferContent
                        && c.ExceptionContext.Request != null
                        && c.ExceptionContext.Response == expectedOriginalResponse),
                        expectedCancellationToken), Times.Once());
                    mock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                        c.ExceptionContext != null
                        && c.ExceptionContext.Exception == expectedErrorException
                        && c.ExceptionContext.CatchBlock ==
                            OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferError
                        && c.ExceptionContext.Request != null
                        && c.ExceptionContext.Response == expectedErrorResponse),
                        expectedCancellationToken), Times.Once());
                }
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingErrorCancels_DoesNotCallExceptionLogger()
        {
            // Arrange
            Exception expectedOriginalException = CreateException();
            Exception expectedErrorException = new OperationCanceledException();

            using (HttpContent content = CreateFaultingContent(expectedOriginalException))
            using (HttpResponseMessage expectedOriginalResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedOriginalResponse))
            using (HttpContent errorContent = CreateFaultingContent(expectedErrorException))
            using (HttpResponseMessage expectedErrorResponse = CreateResponse(errorContent))
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                Mock<IExceptionLogger> mock = CreateStubExceptionLoggerMock();
                IExceptionLogger exceptionLogger = mock.Object;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionLogger = exceptionLogger;
                options.ExceptionHandler = CreateExceptionHandler(new ResponseMessageResult(expectedErrorResponse));

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act & Assert
                    await Assert.ThrowsAsync<OperationCanceledException>(() => product.Invoke(context));

                    mock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                        c.ExceptionContext != null
                        && c.ExceptionContext.Exception == expectedOriginalException
                        && c.ExceptionContext.CatchBlock ==
                            OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferContent
                        && c.ExceptionContext.Request != null
                        && c.ExceptionContext.Response == expectedOriginalResponse),
                        expectedCancellationToken), Times.Once());

                    // This shouldn't be called for 'HttpMessageHandlerAdapterBufferError' because that's what's being
                    // cancelled.
                    mock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                        c.ExceptionContext != null
                        && c.ExceptionContext.Exception == expectedErrorException
                        && c.ExceptionContext.CatchBlock ==
                            OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferError
                        && c.ExceptionContext.Request != null
                        && c.ExceptionContext.Response == expectedErrorResponse),
                        expectedCancellationToken), Times.Never());
                }
            }
        }

        [Fact]
        public async Task Invoke_IfBufferingErrorFaults_SendsEmptyErrorResponse()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: true);

            using (HttpContent content = CreateFaultingContent())
            using (HttpResponseMessage response = CreateResponse(content))
            using (HttpContent errorContent = CreateFaultingContent())
            using (HttpResponseMessage errorResponse = CreateResponse(errorContent))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            {
                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: true);
                options.ExceptionHandler = CreateExceptionHandler(new ResponseMessageResult(errorResponse));

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (MemoryStream output = new MemoryStream())
                {
                    IOwinRequest owinRequest = CreateFakeOwinRequest();

                    int statusCode = 0;
                    Mock<IOwinResponse> mock = new Mock<IOwinResponse>();
                    mock.Setup(r => r.Headers).Returns(new Mock<IHeaderDictionary>().Object);
                    mock.SetupGet(r => r.Body).Returns(output);
                    mock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((v) => statusCode = v);
                    IOwinResponse owinResponse = mock.Object;

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse, isLocal: true);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    Assert.Equal(500, statusCode);
                    Assert.Equal(new byte[0], output.ToArray());
                }
            }
        }

        [Fact]
        public async Task Invoke_IfStreamingFaults_ReturnsCanceledTask()
        {
            // Arrange
            IHostBufferPolicySelector bufferPolicySelector = CreateBufferPolicySelector(bufferInput: false,
                bufferOutput: false);

            using (HttpContent content = CreateFaultingContent())
            using (HttpResponseMessage response = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            using (HttpMessageHandlerAdapter product = CreateProductUnderTest(CreateValidOptions(messageHandler,
                bufferPolicySelector)))
            {
                IOwinRequest owinRequest = CreateFakeOwinRequest();
                IOwinResponse owinResponse = CreateFakeOwinResponse();

                IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                // Act & Assert
                await Assert.ThrowsAsync<TaskCanceledException>(() => product.Invoke(context));
            }
        }

        [Fact]
        public async Task Invoke_IfStreamingFaults_CallsExceptionLogger()
        {
            // Arrange
            Exception expectedException = CreateException();

            using (HttpContent content = CreateFaultingContent(expectedException))
            using (HttpResponseMessage expectedResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedResponse))
            {
                Mock<IExceptionLogger> mock = CreateStubExceptionLoggerMock();
                IExceptionLogger exceptionLogger = mock.Object;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
                options.ExceptionLogger = exceptionLogger;

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);

                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                    // Act & Assert
                    await Assert.ThrowsAsync<TaskCanceledException>(() => product.Invoke(context));

                    mock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>((c) =>
                        c != null
                        && c.ExceptionContext != null
                        && c.ExceptionContext.Exception == expectedException
                        && c.ExceptionContext.CatchBlock ==
                            OwinExceptionCatchBlocks.HttpMessageHandlerAdapterStreamContent
                        && c.ExceptionContext.Request != null
                        && c.ExceptionContext.Response == expectedResponse),
                        expectedCancellationToken), Times.Once());
                }
            }
        }

        [Fact]
        public async Task Invoke_IfStreamingCancels_DoesNotCallExceptionLogger()
        {
            // Arrange
            Exception expectedException = new OperationCanceledException();

            using (HttpContent content = CreateFaultingContent(expectedException))
            using (HttpResponseMessage expectedResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedResponse))
            {
                Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
                IExceptionLogger exceptionLogger = mock.Object;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.BufferPolicySelector = CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
                options.ExceptionLogger = exceptionLogger;

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);

                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                    // Act
                    await Assert.ThrowsAsync<OperationCanceledException>(() => product.Invoke(context));
                }
            }
        }

        [Fact]
        public async Task Invoke_IfTryComputeLengthThrows_CallsExceptionLogger()
        {
            // Arrange
            Exception expectedException = CreateException();

            using (HttpContent content = CreateThrowingContent(expectedException))
            using (HttpResponseMessage expectedResponse = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(expectedResponse))
            {
                Mock<IExceptionLogger> mock = CreateStubExceptionLoggerMock();
                IExceptionLogger exceptionLogger = mock.Object;

                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);
                options.ExceptionLogger = exceptionLogger;

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
                {
                    CancellationToken expectedCancellationToken = tokenSource.Token;
                    IOwinRequest owinRequest = CreateFakeOwinRequest(expectedCancellationToken);

                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    mock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>((c) =>
                        c != null
                        && c.ExceptionContext != null
                        && c.ExceptionContext.Exception == expectedException
                        && c.ExceptionContext.CatchBlock ==
                            OwinExceptionCatchBlocks.HttpMessageHandlerAdapterComputeContentLength
                        && c.ExceptionContext.Request != null
                        && c.ExceptionContext.Response == expectedResponse),
                        expectedCancellationToken), Times.Once());
                }
            }
        }

        [Fact]
        public async Task Invoke_IfTryComputeLengthThrows_SendsEmptyErrorResponse()
        {
            // Arrange
            Exception expectedException = CreateException();

            using (HttpContent content = CreateThrowingContent(expectedException))
            using (HttpResponseMessage response = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            {
                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                {
                    IOwinRequest owinRequest = CreateFakeOwinRequest();

                    Mock<IOwinResponse> owinResponseMock = new Mock<IOwinResponse>(MockBehavior.Strict);
                    int statusCode = 0;
                    owinResponseMock.SetupGet(r => r.Environment).Returns((IDictionary<string, object>)null);
                    owinResponseMock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>(s => statusCode = s);
                    int? contentLength = null;
                    Mock<IHeaderDictionary> headersMock = new Mock<IHeaderDictionary>(MockBehavior.Strict);
                    headersMock
                        .As<IDictionary<string, string[]>>()
                        .SetupSet(h => h["Content-Length"] = It.IsAny<string[]>())
                        .Callback<string, string[]>((i, v) => contentLength = int.Parse(v[0]));
                    IHeaderDictionary headers = headersMock.Object;
                    owinResponseMock.SetupGet(r => r.Headers).Returns(headers);
                    IOwinResponse owinResponse = owinResponseMock.Object;

                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    Assert.Equal(500, statusCode);
                    Assert.Equal(0, contentLength);
                }
            }
        }

        [Fact]
        public async Task Invoke_IfTryComputeLengthThrows_DoesNotEvaluateOutputBufferPolicy()
        {
            // Arrange
            using (HttpContent content = CreateThrowingContent(CreateException()))
            using (HttpResponseMessage response = CreateResponse(content))
            using (HttpMessageHandler messageHandler = CreateStubMessageHandler(response))
            {
                HttpMessageHandlerOptions options = CreateValidOptions(messageHandler);

                Mock<IHostBufferPolicySelector> bufferPolicyMock =
                    new Mock<IHostBufferPolicySelector>(MockBehavior.Strict);
                bufferPolicyMock
                    .Setup(p => p.UseBufferedInputStream(It.IsAny<object>()))
                    .Returns(false);
                bool calledUseBufferedOutputStream = false;
                bufferPolicyMock
                    .Setup(p => p.UseBufferedOutputStream(It.IsAny<HttpResponseMessage>()))
                    .Callback(() => calledUseBufferedOutputStream = true)
                    .Returns(false);
                options.BufferPolicySelector = bufferPolicyMock.Object;

                using (HttpMessageHandlerAdapter product = CreateProductUnderTest(options))
                {
                    IOwinRequest owinRequest = CreateFakeOwinRequest();
                    IOwinResponse owinResponse = CreateFakeOwinResponse(Stream.Null);
                    IOwinContext context = CreateStubOwinContext(owinRequest, owinResponse);

                    // Act
                    await product.Invoke(context);

                    // Assert
                    Assert.False(calledUseBufferedOutputStream);
                }
            }
        }

        private static IHostBufferPolicySelector CreateBufferPolicySelector(bool bufferInput, bool bufferOutput)
        {
            var mock = new Mock<IHostBufferPolicySelector>();
            mock.Setup(bps => bps.UseBufferedInputStream(It.IsAny<object>())).Returns(bufferInput);
            mock.Setup(bps => bps.UseBufferedOutputStream(It.IsAny<HttpResponseMessage>())).Returns(bufferOutput);
            return mock.Object;
        }

        private static CancellationTokenSource CreateCancellationTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static IHostBufferPolicySelector CreateDummyBufferPolicy()
        {
            return new Mock<IHostBufferPolicySelector>(MockBehavior.Strict).Object;
        }

        private static IExceptionHandler CreateDummyExceptionHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyExceptionLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static HttpMessageHandler CreateDummyMessageHandler()
        {
            Mock<HttpMessageHandler> mock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
            mock.As<IDisposable>().Setup(c => c.Dispose());
            return mock.Object;
        }

        private static HttpMessageHandlerOptions CreateDummyOptions(HttpMessageHandler messageHandler)
        {
            return new HttpMessageHandlerOptions
            {
                MessageHandler = messageHandler,
                BufferPolicySelector = CreateDummyBufferPolicy(),
                ExceptionLogger = CreateDummyExceptionLogger(),
                ExceptionHandler = CreateDummyExceptionHandler()
            };
        }

        private static Exception CreateException()
        {
            return new Exception();
        }

        private static IExceptionHandler CreateExceptionHandler(IHttpActionResult result)
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Callback<ExceptionHandlerContext, CancellationToken>((c, i) => c.Result = result)
                .Returns(Task.FromResult(0));
            return mock.Object;
        }

        private static Exception CreateExceptionWithCallStack()
        {
            try
            {
                throw CreateException();
            }
            catch (Exception exception)
            {
                return exception;
            }
        }

        private static IHeaderDictionary CreateFakeHeaders()
        {
            return new HeaderDictionary(new Dictionary<string, string[]>());
        }

        private static IOwinRequest CreateFakeOwinRequest()
        {
            return CreateFakeOwinRequest(CancellationToken.None);
        }

        private static IOwinRequest CreateFakeOwinRequest(CancellationToken cancellationToken)
        {
            return CreateFakeOwinRequestMock(cancellationToken).Object;
        }

        private static IOwinRequest CreateFakeOwinRequest(Action disableBuffering)
        {
            Mock<IDictionary<string, object>> environmentMock = new Mock<IDictionary<string, object>>(MockBehavior.Strict);
            object disableBufferingValue = disableBuffering;
            environmentMock.Setup(d => d.TryGetValue("server.DisableRequestBuffering", out disableBufferingValue)).Returns(true);
            IDictionary<string, object> environment = environmentMock.Object;

            Mock<IOwinRequest> mock = CreateFakeOwinRequestMock(CancellationToken.None);
            mock.SetupGet(r => r.Environment).Returns(environment);
            return mock.Object;
        }

        private static Mock<IOwinRequest> CreateFakeOwinRequestMock(CancellationToken cancellationToken)
        {
            Mock<IHeaderDictionary> headersMock = new Mock<IHeaderDictionary>(MockBehavior.Strict);
            headersMock.Setup(h => h.GetEnumerator()).Returns(
                new Mock<IEnumerator<KeyValuePair<string, string[]>>>().Object);

            Mock<IOwinRequest> mock = new Mock<IOwinRequest>(MockBehavior.Strict);
            mock.SetupGet(r => r.Method).Returns("GET");
            mock.SetupGet(r => r.Uri).Returns(new Uri("http://ignore"));
            mock.SetupGet(r => r.Body).Returns(Stream.Null);
            mock.SetupGet(r => r.Headers).Returns(headersMock.Object);
            mock.SetupGet(r => r.User).Returns((IPrincipal)null);
            mock.SetupGet(r => r.CallCancelled).Returns(cancellationToken);
            mock.SetupGet(r => r.Environment).Returns((IDictionary<string, object>)null);
            return mock;
        }

        private static IOwinResponse CreateFakeOwinResponse()
        {
            return CreateFakeOwinResponseMock().Object;
        }

        private static IOwinResponse CreateFakeOwinResponse(Stream body)
        {
            Mock<IOwinResponse> mock = CreateFakeOwinResponseMock();
            mock.SetupGet(r => r.Body).Returns(body);
            return mock.Object;
        }

        private static IOwinResponse CreateFakeOwinResponse(Action disableBuffering)
        {
            Mock<IDictionary<string, object>> environmentMock = new Mock<IDictionary<string, object>>(MockBehavior.Strict);
            object disableBufferingValue = disableBuffering;
            environmentMock.Setup(d => d.TryGetValue("server.DisableResponseBuffering", out disableBufferingValue)).Returns(true);
            IDictionary<string, object> environment = environmentMock.Object;

            Mock<IOwinResponse> mock = CreateFakeOwinResponseMock();
            mock.SetupGet(r => r.Environment).Returns(environment);
            return mock.Object;
        }

        private static Mock<IOwinResponse> CreateFakeOwinResponseMock()
        {
            Mock<IOwinResponse> mock = new Mock<IOwinResponse>();
            mock.Setup(r => r.Headers).Returns(new Mock<IHeaderDictionary>().Object);
            return mock;
        }

        private static IOwinResponse CreateFakeOwinResponseWithHeaders()
        {
            Mock<IOwinResponse> mock = new Mock<IOwinResponse>();
            IHeaderDictionary headers = CreateFakeHeaders();
            mock.Setup(r => r.Headers).Returns(headers);
            return mock.Object;
        }

        private static Task CreateFaultedTask(Exception exception)
        {
            TaskCompletionSource<object> source = new TaskCompletionSource<object>();
            source.SetException(exception);
            return source.Task;
        }

        private static FaultingHttpContent CreateFaultingContent()
        {
            return CreateFaultingContent(CreateException());
        }

        private static FaultingHttpContent CreateFaultingContent(Exception exception)
        {
            return new FaultingHttpContent(exception);
        }

        private static MediaTypeFormatter CreateFaultingFormatter(Exception exception)
        {
            Mock<MediaTypeFormatter> mock = new Mock<MediaTypeFormatter>();
            mock.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true);
            mock.Setup(f => f.GetPerRequestFormatterInstance(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                It.IsAny<MediaTypeHeaderValue>())).Returns(mock.Object);
            mock
                .Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<object>(), It.IsAny<Stream>(),
                    It.IsAny<HttpContent>(), It.IsAny<TransportContext>()))
                .Returns(CreateFaultedTask(exception));
            return mock.Object;
        }

        private static HttpMessageHandler CreateLambdaMessageHandler(
            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync)
        {
            return new LambdaHttpMessageHandler(sendAsync);
        }

        private static HandlerStub CreateOKHandlerStub()
        {
            var response = new HttpResponseMessage(HttpStatusCode.OK);
            return new HandlerStub() { Response = response };
        }

        private static Dictionary<string, object> CreateOwinEnvironment(string method, string scheme, string hostHeaderValue, string pathBase, string path)
        {
            var environment = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
            environment["owin.RequestMethod"] = method;
            environment["owin.RequestScheme"] = scheme;
            environment["owin.RequestHeaders"] = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase) { { "Host", new string[] { hostHeaderValue } } };
            environment["owin.RequestPathBase"] = pathBase;
            environment["owin.RequestPath"] = path;
            environment["owin.RequestQueryString"] = "";
            environment["owin.RequestBody"] = new MemoryStream();
            environment["owin.CallCancelled"] = new CancellationToken();
            environment["owin.ResponseHeaders"] = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
            environment["owin.ResponseBody"] = new MemoryStream();
            return environment;
        }

        private static HttpMessageHandlerAdapter CreateProductUnderTest(HttpMessageHandlerOptions options)
        {
            return CreateProductUnderTest(next: null, options: options);
        }

        private static HttpMessageHandlerAdapter CreateProductUnderTest(OwinMiddleware next, HttpMessageHandlerOptions options)
        {
            return new HttpMessageHandlerAdapter(next, options);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpRequestMessage CreateRequest(bool includeErrorDetail)
        {
            HttpRequestMessage request = CreateRequest();
            request.SetRequestContext(new HttpRequestContext
            {
                IncludeErrorDetail = includeErrorDetail
            });
            return request;
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static HttpResponseMessage CreateResponse(HttpContent content)
        {
            return new HttpResponseMessage
            {
                Content = content
            };
        }

        private static Mock<IExceptionHandler> CreateStubExceptionHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static IExceptionLogger CreateStubExceptionLogger()
        {
            return CreateStubExceptionLoggerMock().Object;
        }

        private static Mock<IExceptionLogger> CreateStubExceptionLoggerMock()
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static HttpMessageHandler CreateStubMessageHandler(HttpResponseMessage response)
        {
            return new LambdaHttpMessageHandler((r, c) => Task.FromResult(response));
        }

        private static IOwinContext CreateStubOwinContext(IOwinRequest request, IOwinResponse response)
        {
            Mock<IOwinContext> mock = new Mock<IOwinContext>(MockBehavior.Strict);
            mock.Setup(c => c.Request).Returns(request);
            mock.Setup(c => c.Response).Returns(response);
            return mock.Object;
        }

        private static IOwinContext CreateStubOwinContext(IOwinRequest request, IOwinResponse response, bool isLocal)
        {
            Mock<IOwinContext> mock = new Mock<IOwinContext>(MockBehavior.Strict);
            mock.Setup(c => c.Request).Returns(request);
            mock.Setup(c => c.Response).Returns(response);
            mock.Setup(c => c.Get<bool>("server.IsLocal")).Returns(isLocal);
            return mock.Object;
        }

        private static ThrowingHttpContent CreateThrowingContent(Exception exception)
        {
            return new ThrowingHttpContent(exception);
        }

        private static HttpMessageHandlerOptions CreateValidOptions(HttpMessageHandler messageHandler)
        {
            IHostBufferPolicySelector bufferPolicy =
                CreateBufferPolicySelector(bufferInput: false, bufferOutput: false);
            return CreateValidOptions(messageHandler, bufferPolicy);
        }

        private static HttpMessageHandlerOptions CreateValidOptions(HttpMessageHandler messageHandler,
            IHostBufferPolicySelector bufferPolicySelector)
        {
            return new HttpMessageHandlerOptions
            {
                MessageHandler = messageHandler,
                BufferPolicySelector = bufferPolicySelector,
                ExceptionLogger = new EmptyExceptionLogger(),
                ExceptionHandler = new DefaultExceptionHandler()
            };
        }

        public class HandlerStub : HttpMessageHandler
        {
            public HttpRequestMessage Request { get; private set; }
            public CancellationToken CancellationToken { get; private set; }
            public HttpResponseMessage Response { get; set; }
            public IPrincipal User { get; set; }
            public bool AddNoRouteMatchedKey { get; set; }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                Request = request;
                CancellationToken = cancellationToken;
                User = Thread.CurrentPrincipal;

                if (AddNoRouteMatchedKey)
                {
                    request.Properties[HttpPropertyKeys.NoRouteMatched] = true;
                }

                return Task.FromResult<HttpResponseMessage>(Response);
            }
        }

        private class LambdaHttpMessageHandler : HttpMessageHandler
        {
            private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _sendAsync;

            public LambdaHttpMessageHandler(
                Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync)
            {
                _sendAsync = sendAsync;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                return _sendAsync.Invoke(request, cancellationToken);
            }
        }

        private class FaultingHttpContent : HttpContent
        {
            private readonly Exception _exception;

            public FaultingHttpContent(Exception exception)
            {
                _exception = exception;
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return CreateFaultedTask(_exception);
            }

            protected override bool TryComputeLength(out long length)
            {
                length = 0;
                return false;
            }
        }

        private class SpyDisposeFaultingHttpContent : HttpContent
        {
            private readonly Exception _exception;

            public SpyDisposeFaultingHttpContent(Exception exception)
            {
                _exception = exception;
            }

            public bool Disposed { get; private set; }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return CreateFaultedTask(_exception);
            }

            protected override bool TryComputeLength(out long length)
            {
                length = 0;
                return false;
            }

            protected override void Dispose(bool disposing)
            {
                Disposed = true;
                base.Dispose(disposing);
            }
        }

        private class SpyDisposeHttpMessageHandler : HttpMessageHandler
        {
            public bool Disposed { get; private set; }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }

            protected override void Dispose(bool disposing)
            {
                Disposed = true;
            }
        }

        private class SpyDisposeHttpResponseMessage : HttpResponseMessage
        {
            public SpyDisposeHttpResponseMessage(HttpContent content)
            {
                Content = content;
            }

            public bool Disposed { get; private set; }

            protected override void Dispose(bool disposing)
            {
                Disposed = true;
                base.Dispose(disposing);
            }
        }

        private class SpyDisposeStream : Stream
        {
            public bool Disposed { get; private set; }

            public override bool CanRead
            {
                get { return false; }
            }

            public override bool CanSeek
            {
                get { return false; }
            }

            public override bool CanWrite
            {
                get { return true; }
            }

            public override void Flush()
            {
            }

            public override long Length
            {
                get { return 0; }
            }

            public override long Position
            {
                get
                {
                    return 0;
                }
                set
                {
                }
            }

            public override int Read(byte[] buffer, int offset, int count)
            {
                return 0;
            }

            public override long Seek(long offset, SeekOrigin origin)
            {
                throw new NotSupportedException();
            }

            public override void SetLength(long value)
            {
            }

            public override void Write(byte[] buffer, int offset, int count)
            {
            }

            protected override void Dispose(bool disposing)
            {
                Disposed = true;
                base.Dispose(disposing);
            }
        }

        private class ThrowingHttpContent : HttpContent
        {
            private readonly Exception _exception;

            public ThrowingHttpContent(Exception exception)
            {
                _exception = exception;
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                throw _exception;
            }

            protected override bool TryComputeLength(out long length)
            {
                throw _exception;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/HttpMessageHandlerExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Owin
{
    internal static class HttpMessageHandlerExtensions
    {
        public static Task<HttpResponseMessage> SendAsync(this HttpMessageHandler handler, HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            HttpMessageInvoker invoker = new HttpMessageInvoker(handler, disposeHandler: false);
            return invoker.SendAsync(request, cancellationToken);
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/HttpMessageHandlerOptionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class HttpMessageHandlerOptionsTests
    {
        [Fact]
        public void MessageHandlerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpMessageHandlerOptions product = CreateProductUnderTest();

            using (HttpMessageHandler expectedMessageHandler = CreateDummyMessageHandler())
            {
                product.MessageHandler = expectedMessageHandler;

                // Act
                HttpMessageHandler messageHandler = product.MessageHandler;

                // Assert
                Assert.Same(expectedMessageHandler, messageHandler);
            }
        }

        [Fact]
        public void BufferPolicySelectorGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpMessageHandlerOptions product = CreateProductUnderTest();
            IHostBufferPolicySelector expectedBufferPolicySelector = CreateDummyBufferPolicy();
            product.BufferPolicySelector = expectedBufferPolicySelector;

            // Act
            IHostBufferPolicySelector bufferPolicy = product.BufferPolicySelector;

            // Assert
            Assert.Same(expectedBufferPolicySelector, bufferPolicy);
        }

        [Fact]
        public void ExceptionLoggerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpMessageHandlerOptions product = CreateProductUnderTest();
            IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
            product.ExceptionLogger = expectedExceptionLogger;

            // Act
            IExceptionLogger exceptionLogger = product.ExceptionLogger;

            // Assert
            Assert.Same(expectedExceptionLogger, exceptionLogger);
        }

        [Fact]
        public void ExceptionHandlerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpMessageHandlerOptions product = CreateProductUnderTest();
            IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();
            product.ExceptionHandler = expectedExceptionHandler;

            // Act
            IExceptionHandler exceptionHandler = product.ExceptionHandler;

            // Assert
            Assert.Same(expectedExceptionHandler, exceptionHandler);
        }

        [Fact]
        public void AppDisposingGet_ReturnsSpecifiedValue()
        {
            // Arrange
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                HttpMessageHandlerOptions product = CreateProductUnderTest();
                CancellationToken expectedAppDisposing = tokenSource.Token;
                product.AppDisposing = expectedAppDisposing;

                // Act
                CancellationToken appDisposing = product.AppDisposing;

                // Assert
                Assert.Equal(expectedAppDisposing, appDisposing);
            }
        }

        private static CancellationTokenSource CreateCancellationTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static IHostBufferPolicySelector CreateDummyBufferPolicy()
        {
            return new Mock<IHostBufferPolicySelector>(MockBehavior.Strict).Object;
        }

        private static IExceptionHandler CreateDummyExceptionHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyExceptionLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static HttpMessageHandler CreateDummyMessageHandler()
        {
            Mock<HttpMessageHandler> mock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
            mock.As<IDisposable>().Setup(c => c.Dispose());
            return mock.Object;
        }

        private static HttpMessageHandlerOptions CreateProductUnderTest()
        {
            return new HttpMessageHandlerOptions();
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/IgnoreRouteTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.Owin.ExceptionHandling;
using System.Web.Http.Routing;
using Microsoft.Owin;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class IgnoreRouteIntegrationTests
    {
        [Fact]
        public void Invoke_IfRouteIsIgnored_CallsNextMiddleware()
        {
            // Arrange
            int expectedStatusCode = 123;
            string pathToIgnoreRoute = "ignore";
            OwinMiddleware next = CreateStubMiddleware(expectedStatusCode);

            using (HttpServer server = new HttpServer())
            {
                server.Configuration.Routes.IgnoreRoute("IgnoreRouteName", pathToIgnoreRoute);
                server.Configuration.MapHttpAttributeRoutes(); // See IgnoreController

                OwinMiddleware product = CreateProductUnderTest(next, server);

                IOwinRequest request = CreateStubRequest(new Uri("http://somehost/" + pathToIgnoreRoute));

                Mock<IOwinResponse> mock = CreateStubResponseMock();
                int statusCode = 0;
                mock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((s) => statusCode = s);
                IOwinResponse response = mock.Object;

                IOwinContext context = CreateStubContext(request, response);

                // Act
                Task task = product.Invoke(context);

                // Assert
                Assert.NotNull(task);
                task.WaitUntilCompleted();
                task.ThrowIfFaulted();

                Assert.Equal(expectedStatusCode, statusCode);
            }
        }

        [Fact]
        public void Invoke_IfRouteIsIgnored_WithConstraints_CallsNextMiddleware()
        {
            // Arrange
            int expectedStatusCode = 0;
            string pathToIgnoreRoute = "constraint/10";

            using (HttpServer server = new HttpServer())
            {
                server.Configuration.Routes.IgnoreRoute("Constraints", "constraint/{id}", constraints: new { constraint = new CustomConstraint() });
                server.Configuration.MapHttpAttributeRoutes(); // See IgnoreController

                OwinMiddleware product = CreateProductUnderTest(null, server);

                IOwinRequest request = CreateStubRequest(new Uri("http://somehost/" + pathToIgnoreRoute));

                Mock<IOwinResponse> mock = CreateStubResponseMock();
                int statusCode = 0;
                mock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((s) => statusCode = s);
                IOwinResponse response = mock.Object;

                IOwinContext context = CreateStubContext(request, response);

                // Act
                Task task = product.Invoke(context);

                // Assert
                Assert.NotNull(task);
                task.WaitUntilCompleted();
                task.ThrowIfFaulted();

                Assert.Equal(expectedStatusCode, statusCode);
            }
        }

        private static IOwinContext CreateStubContext(IOwinRequest request, IOwinResponse response)
        {
            Mock<IOwinContext> mock = new Mock<IOwinContext>(MockBehavior.Strict);
            mock.SetupGet(c => c.Request).Returns(request);
            mock.SetupGet(c => c.Response).Returns(response);
            mock.Setup(c => c.Get<bool>("server.IsLocal")).Returns(true);
            return mock.Object;
        }

        private static OwinMiddleware CreateStubMiddleware(int statusCode)
        {
            Mock<OwinMiddleware> mock = new Mock<OwinMiddleware>(MockBehavior.Strict, null);
            mock
                .Setup(m => m.Invoke(It.IsAny<IOwinContext>()))
                .Callback<IOwinContext>((c) => c.Response.StatusCode = statusCode)
                .Returns(Task.FromResult(0));
            return mock.Object;
        }

        private static IOwinRequest CreateStubRequest(Uri uri)
        {
            Mock<IOwinRequest> mock = new Mock<IOwinRequest>(MockBehavior.Strict);
            mock.SetupGet(r => r.CallCancelled).Returns(CancellationToken.None);
            mock.SetupGet(r => r.Environment).Returns((IDictionary<string, object>)null);
            mock.SetupGet(r => r.Body).Returns(Stream.Null);
            mock.SetupGet(r => r.Method).Returns("GET");
            mock.SetupGet(r => r.Uri).Returns(uri);
            mock.SetupGet(r => r.PathBase).Returns(new PathString(String.Empty));
            mock.SetupGet(r => r.Headers).Returns(CreateFakeHeaders());
            mock.SetupGet(r => r.User).Returns((IPrincipal)null);
            return mock.Object;
        }

        private static Mock<IOwinResponse> CreateStubResponseMock()
        {
            Mock<IOwinResponse> mock = new Mock<IOwinResponse>(MockBehavior.Strict);
            mock.SetupSet(r => r.ReasonPhrase = It.IsAny<string>());
            mock.SetupGet(r => r.Environment).Returns((IDictionary<string, object>)null);
            mock.SetupGet(r => r.Headers).Returns(CreateFakeHeaders());
            mock.SetupGet(r => r.Body).Returns(Stream.Null);
            return mock;
        }

        private static IHeaderDictionary CreateFakeHeaders()
        {
            return new HeaderDictionary(new Dictionary<string, string[]>());
        }

        private static HttpMessageHandlerAdapter CreateProductUnderTest(OwinMiddleware next, HttpMessageHandler messageHandler)
        {
            return new HttpMessageHandlerAdapter(next: next, options: new HttpMessageHandlerOptions
            {
                MessageHandler = messageHandler,
                BufferPolicySelector = new Mock<IHostBufferPolicySelector>().Object,
                ExceptionLogger = new EmptyExceptionLogger(),
                ExceptionHandler = new Mock<IExceptionHandler>().Object
            });
        }

        public class IgnoreController : ApiController
        {
            [Route("ignore")]
            [Route("constraint/10")]
            public IHttpActionResult Get()
            {
                return Ok();
            }
        }

        public class CustomConstraint : IHttpRouteConstraint
        {
            public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName,
                IDictionary<string, object> values, HttpRouteDirection routeDirection)
            {
                long id;
                if (values.ContainsKey("id")
                    && Int64.TryParse(values["id"].ToString(), out id)
                    && (id == 10))
                {
                    return true;
                }

                return false;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/NonOwnedStreamTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http.Owin
{
    public class NonOwnedStreamTests
    {
        [Fact]
        public void Constructor_IfInnerStreamIsNull_Throws()
        {
            // Arrange
            Stream innerStream = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(innerStream), "innerStream");
        }

        [Fact]
        public void Read_DelegatesToInnerStream()
        {
            // Arrange
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            int expectedBytesRead = 123;
            mock.Setup(s => s.Read(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>()))
                .Returns(expectedBytesRead);
            mock.Setup(s => s.Close());
            mock.As<IDisposable>().Setup(s => s.Dispose());

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                byte[] expectedBuffer = new byte[0];
                int expectedOffset = 456;
                int expectedCount = 789;

                // Act
                int bytesRead = product.Read(expectedBuffer, expectedOffset, expectedCount);

                // Assert
                Assert.Equal(expectedBytesRead, bytesRead);
                mock.Verify(s => s.Read(expectedBuffer, expectedOffset, expectedCount), Times.Once());
            }
        }

        [Fact]
        public void Read_IfDisposed_Throws()
        {
            // Arrange
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            mock.Setup(s => s.Close());
            mock.As<IDisposable>().Setup(s => s.Dispose());

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                byte[] buffer = new byte[0];
                int offset = 0;
                int count = 0;

                product.Dispose();

                // Act & Assert
                Assert.Throws<ObjectDisposedException>(() => product.Read(buffer, offset, count));
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void CanRead_DelegatesToInnerStream(bool expectedCanRead)
        {
            // Arrange
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            mock.SetupGet(s => s.CanRead)
                .Returns(expectedCanRead);
            mock.Setup(s => s.Close());
            mock.As<IDisposable>().Setup(s => s.Dispose());

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                // Act
                bool canRead = product.CanRead;

                // Assert
                Assert.Equal(expectedCanRead, canRead);
            }
        }

        [Fact]
        public void CanRead_IfDisposed_ReturnsFalse()
        {
            // Arrange
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            mock.Setup(s => s.Close());
            mock.As<IDisposable>().Setup(s => s.Dispose());

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                product.Dispose();

                // Act
                bool canRead = product.CanRead;

                // Assert
                Assert.False(canRead);
            }
        }

        [Fact]
        public void Dispose_DoesNotDisposeInnerStream()
        {
            // Arrange
            bool innerStreamDisposed = false;
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            mock.Setup(s => s.Close()).Callback(() => innerStreamDisposed = true);
            mock.As<IDisposable>().Setup(s => s.Dispose());
            mock.Protected().Setup("Dispose", exactParameterMatch: true, args: true).Callback(() => innerStreamDisposed = true);

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                product.Dispose();

                // Act & Assert
                Assert.False(innerStreamDisposed);
            }
        }

        [Fact]
        public void Dispose_IfCalledTwice_DoesNotThrow()
        {
            // Arrange
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            mock.Setup(s => s.Close());
            mock.As<IDisposable>().Setup(s => s.Dispose());

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                product.Dispose();

                // Act & Assert
                Assert.DoesNotThrow(() => product.Dispose());
            }
        }

        [Fact]
        public void Close_DoesNotDisposeInnerStream()
        {
            // Arrange
            bool innerStreamDisposed = false;
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            mock.Setup(s => s.Close()).Callback(() => innerStreamDisposed = true);
            mock.As<IDisposable>().Setup(s => s.Dispose());
            mock.Protected().Setup("Dispose", exactParameterMatch: true, args: true).Callback(() => innerStreamDisposed = true);

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                product.Close();

                // Act & Assert
                Assert.False(innerStreamDisposed);
            }
        }

        [Fact]
        public void Close_DisposesThisObject()
        {
            // Arrange
            Mock<Stream> mock = new Mock<Stream>(MockBehavior.Strict);
            mock.Setup(s => s.Close());
            mock.As<IDisposable>().Setup(s => s.Dispose());

            using (Stream innerStream = mock.Object)
            using (Stream product = CreateProductUnderTest(innerStream))
            {
                product.Close();

                byte[] buffer = new byte[0];
                int offset = 0;
                int count = 0;

                // Act & Assert
                Assert.Throws<ObjectDisposedException>(() => product.Read(buffer, offset, count));
            }
        }

        private static NonOwnedStream CreateProductUnderTest(Stream innerStream)
        {
            return new NonOwnedStream(innerStream);
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinBufferPolicySelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using Microsoft.TestCommon;

namespace System.Web.Http.Owin
{
    public class OwinBufferPolicySelectorTest
    {
        [Fact]
        public void UseBufferedInputStream_ReturnsFalse()
        {
            Assert.False(new OwinBufferPolicySelector().UseBufferedInputStream(null));
        }

        [Fact]
        public void UseBufferedOutputStream_ReturnsTrue_ForObjectContent()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            response.Content = new ObjectContent<string>("blue", new JsonMediaTypeFormatter());

            Assert.True(new OwinBufferPolicySelector().UseBufferedOutputStream(response));
        }

        [Fact]
        public void UseBufferedOutputStream_ReturnsFalse_ForSpecifiedContentLength()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            response.Content = new ObjectContent<string>("blue", new JsonMediaTypeFormatter());
            response.Content.Headers.ContentLength = 5;

            Assert.False(new OwinBufferPolicySelector().UseBufferedOutputStream(response));
        }

        [Fact]
        public void UseBufferedOutputStream_ReturnsFalse_ForChunkedTransferEncoding()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            response.Headers.TransferEncodingChunked = true;
            response.Content = new ObjectContent<string>("blue", new JsonMediaTypeFormatter());

            Assert.False(new OwinBufferPolicySelector().UseBufferedOutputStream(response));
        }

        [Fact]
        public void UseBufferedOutputStream_ReturnsFalse_ForStreamContent()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            response.Content = new StreamContent(new MemoryStream());

            Assert.False(new OwinBufferPolicySelector().UseBufferedOutputStream(response));
        }

        [Fact]
        public void UseBufferedOutputStream_ReturnsFalse_ForPushStreamContent()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            response.Content = new PushStreamContent((s, c, tc) => { return; });

            Assert.False(new OwinBufferPolicySelector().UseBufferedOutputStream(response));
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinExceptionCatchBlocksTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using Microsoft.TestCommon;

namespace System.Web.Http.Owin
{
    public class OwinExceptionCatchBlocksTests
    {
        [Fact]
        public void HttpMessageHandlerAdapterBufferContent_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferContent;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpMessageHandlerAdapter.BufferContent", isTopLevel: true,
                    callsHandler: true);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpMessageHandlerAdapterBufferContent_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferContent;

            // Act
            ExceptionContextCatchBlock second = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferContent;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpMessageHandlerAdapterBufferError_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferError;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpMessageHandlerAdapter.BufferError", isTopLevel: true,
                    callsHandler: false);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpMessageHandlerAdapterBufferError_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferError;

            // Act
            ExceptionContextCatchBlock second = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterBufferError;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpMessageHandlerAdapterComputeContentLength_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock =
                OwinExceptionCatchBlocks.HttpMessageHandlerAdapterComputeContentLength;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpMessageHandlerAdapter.ComputeContentLength", isTopLevel: true,
                    callsHandler: false);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpMessageHandlerAdapterComputeContentLength_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterComputeContentLength;

            // Act
            ExceptionContextCatchBlock second = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterComputeContentLength;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpMessageHandlerAdapterStreamContent_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterStreamContent;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpMessageHandlerAdapter.StreamContent", isTopLevel: true,
                    callsHandler: false);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpMessageHandlerAdapterStreamContent_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterStreamContent;

            // Act
            ExceptionContextCatchBlock second = OwinExceptionCatchBlocks.HttpMessageHandlerAdapterStreamContent;

            // Assert
            Assert.Same(first, second);
        }

        private static void AssertEqual(ExceptionContextCatchBlock expected, ExceptionContextCatchBlock actual)
        {
            if (expected == null)
            {
                Assert.Null(actual);
                return;
            }

            Assert.NotNull(actual);
            Assert.Equal(expected.Name, actual.Name);
            Assert.Equal(expected.IsTopLevel, actual.IsTopLevel);
            Assert.Equal(expected.CallsHandler, actual.CallsHandler);
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinHostIntegrationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Owin.Hosting;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;
using Owin;

namespace System.Web.Http.Owin
{
    [Xunit.Collection("PortReserver Collection")] // Avoid conflicts between different PortReserver consumers.
    public class OwinHostIntegrationTest
    {
        [Fact]
        public async Task SimpleGet_Works()
        {
            using (var port = new PortReserver())
            using (WebApp.Start<OwinHostIntegrationTest>(url: CreateBaseUrl(port)))
            {
                HttpClient client = new HttpClient();

                var response = await client.GetAsync(CreateUrl(port, "HelloWorld"));

                Assert.True(response.IsSuccessStatusCode);
                Assert.Equal("\"Hello from OWIN\"", await response.Content.ReadAsStringAsync());
                Assert.Null(response.Headers.TransferEncodingChunked);
            }
        }

        [Fact]
        public async Task SimplePost_Works()
        {
            using (var port = new PortReserver())
            using (WebApp.Start<OwinHostIntegrationTest>(url: CreateBaseUrl(port)))
            {
                HttpClient client = new HttpClient();
                var content = new StringContent("\"Echo this\"", Encoding.UTF8, "application/json");

                var response = await client.PostAsync(CreateUrl(port, "Echo"), content);

                Assert.True(response.IsSuccessStatusCode);
                Assert.Equal("\"Echo this\"", await response.Content.ReadAsStringAsync());
                Assert.Null(response.Headers.TransferEncodingChunked);
            }
        }

        [Fact]
        public async Task GetThatThrowsDuringSerializations_RespondsWith500()
        {
            using (var port = new PortReserver())
            using (WebApp.Start<OwinHostIntegrationTest>(url: CreateBaseUrl(port)))
            {
                HttpClient client = new HttpClient();

                var response = await client.GetAsync(CreateUrl(port, "Error"));

                Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                JObject json = Assert.IsType<JObject>(JToken.Parse(await response.Content.ReadAsStringAsync()));
                JToken exceptionMessage;
                Assert.True(json.TryGetValue("ExceptionMessage", out exceptionMessage));
                Assert.Null(response.Headers.TransferEncodingChunked);
            }
        }

        private static string CreateBaseUrl(PortReserver port)
        {
            return port.BaseUri + "vroot";
        }

        private static string CreateUrl(PortReserver port, string localPath)
        {
            return CreateBaseUrl(port) + "/" + localPath;
        }

#pragma warning disable xUnit1013 // Public method should be marked as test
        public void Configuration(IAppBuilder appBuilder)
#pragma warning restore xUnit1013 // Public method should be marked as test
        {
            var config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}");
            appBuilder.UseWebApi(config);
        }
    }

    public class HelloWorldController : ApiController
    {
        public string Get()
        {
            return "Hello from OWIN";
        }
    }

    public class EchoController : ApiController
    {
        public string Post([FromBody] string s)
        {
            return s;
        }
    }

    public class ErrorController : ApiController
    {
        public ExceptionThrower Get()
        {
            return new ExceptionThrower();
        }

        public class ExceptionThrower
        {
            public string Throws
            {
                get
                {
                    throw new InvalidOperationException();
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinHttpConfigurationExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Hosting;
using System.Web.Http.Owin;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class OwinHttpConfigurationExtensionsTest
    {
        [Fact]
        public void SuppressDefaultHostAuthentication_InsertsPassiveAuthenticationMessageHandler()
        {
            // Arrange
            DelegatingHandler existingHandler = new Mock<DelegatingHandler>(MockBehavior.Strict).Object;

            using (HttpConfiguration configuration = new HttpConfiguration())
            {
                configuration.MessageHandlers.Add(existingHandler);

                // Act
                configuration.SuppressDefaultHostAuthentication();

                // Assert
                Assert.Equal(2, configuration.MessageHandlers.Count);
                DelegatingHandler firstHandler = configuration.MessageHandlers[0];
                Assert.IsType<PassiveAuthenticationMessageHandler>(firstHandler);
            }
        }

        [Fact]
        public void SuppressDefaultHostAuthentication_Throws_WhenConfigurationIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                OwinHttpConfigurationExtensions.SuppressDefaultHostAuthentication(null);
            }, "configuration");
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinHttpRequestContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.Owin;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class OwinHttpRequestContextTests
    {
        [Fact]
        public void ContextGet_ReturnsProvidedInstance()
        {
            // Arrange
            IOwinContext expectedOwinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                OwinHttpRequestContext context = CreateProductUnderTest(expectedOwinContext, request);

                // Act
                IOwinContext owinContext = context.Context;

                // Assert
                Assert.Same(expectedOwinContext, owinContext);
            }
        }

        [Fact]
        public void RequestGet_ReturnsProvidedInstance()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                OwinHttpRequestContext context = CreateProductUnderTest(owinContext, expectedRequest);

                // Act
                HttpRequestMessage request = context.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsContextClientCertificate()
        {
            // Arrange
            X509Certificate2 expectedCertificate = CreateCertificate();
            Mock<IOwinContext> owinContextMock = CreateOwinContextMock();
            owinContextMock
                .Setup(c => c.Get<X509Certificate2>(OwinConstants.ClientCertifiateKey))
                .Returns(expectedCertificate);
            IOwinContext owinContext = owinContextMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsNull_ByDefault()
        {
            // Arrange
            IOwinContext owinContext = new OwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ClientCertificateSet_UpdatesClientCertificate()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                X509Certificate2 expectedCertificate = CreateCertificate();

                // Act
                context.ClientCertificate = expectedCertificate;

                // Assert
                X509Certificate2 certificate = context.ClientCertificate;
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void ClientCertificateSet_UpdatesClientCertificate_WhenNull()
        {
            // Arrange
            Mock<IOwinContext> owinContextMock = CreateOwinContextMock();
            owinContextMock
                .Setup(c => c.Get<X509Certificate2>(OwinConstants.ClientCertifiateKey))
                .Returns(CreateCertificate());
            IOwinContext owinContext = owinContextMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                context.ClientCertificate = null;

                // Assert
                X509Certificate2 certificate = context.ClientCertificate;
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsFirstObservedContextClientCertificate()
        {
            // Arrange
            X509Certificate2 expectedCertificate = CreateCertificate();
            X509Certificate2 currentCertificate = expectedCertificate;
            Mock<IOwinContext> owinContextMock = CreateOwinContextMock();
            owinContextMock
                .Setup(c => c.Get<X509Certificate2>(OwinConstants.ClientCertifiateKey))
                .Returns(() => currentCertificate);
            IOwinContext owinContext = owinContextMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                X509Certificate2 ignore = context.ClientCertificate;
                currentCertificate = CreateCertificate();

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void IncludeErrorDetailGet_ReturnsFalse_ByDefault()
        {
            // Arrange
            IOwinContext owinContext = new OwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.False(includeErrorDetail);
            }
        }

        [Fact]
        public void IncludeErrorDetailGet_ReturnsTrue_WhenUnconfiguredAndIsLocal()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                context.IsLocal = true;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.True(includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true, IncludeErrorDetailPolicy.Always, true)]
        [InlineData(true, IncludeErrorDetailPolicy.Always, false)]
        [InlineData(false, IncludeErrorDetailPolicy.Never, true)]
        [InlineData(false, IncludeErrorDetailPolicy.Never, false)]
        [InlineData(true, IncludeErrorDetailPolicy.LocalOnly, true)]
        [InlineData(false, IncludeErrorDetailPolicy.LocalOnly, false)]
        [InlineData(true, IncludeErrorDetailPolicy.Default, true)]
        [InlineData(false, IncludeErrorDetailPolicy.Default, false)]
        public void IncludeErrorDetailGet_ForPolicy(bool expected, IncludeErrorDetailPolicy policy, bool isLocal)
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                context.Configuration = configuration;
                context.IsLocal = isLocal;
                configuration.IncludeErrorDetailPolicy = policy;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expected, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailSet_UpdatesIncludeErrorDetail(bool expectedIncludeErrorDetail)
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                context.IncludeErrorDetail = expectedIncludeErrorDetail;

                // Assert
                bool includeErrorDetail = context.IncludeErrorDetail;
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true, IncludeErrorDetailPolicy.Never)]
        [InlineData(false, IncludeErrorDetailPolicy.Always)]
        public void IncludeErrorDetailSet_OverridesPolicy(bool expected, IncludeErrorDetailPolicy policy)
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                context.Configuration = configuration;
                configuration.IncludeErrorDetailPolicy = policy;

                // Act
                context.IncludeErrorDetail = expected;

                // Assert
                bool includeErrorDetail = context.IncludeErrorDetail;
                Assert.Equal(expected, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsFirstObservedValue(bool expectedIncludeErrorDetail)
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                context.IsLocal = expectedIncludeErrorDetail;
                bool ignore = context.IncludeErrorDetail;
                context.IsLocal = !expectedIncludeErrorDetail;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Fact]
        public void IsLocalGet_ReturnsFalse_ByDefault()
        {
            // Arrange
            IOwinContext owinContext = new OwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.False(isLocal);
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public void IsLocal_ReturnsContextIsLocalValue(bool expectedIsLocal)
        {
            // Arrange
            Mock<IOwinContext> owinContextMock = CreateOwinContextMock();
            owinContextMock.Setup(c => c.Get<bool>(OwinConstants.IsLocalKey)).Returns(expectedIsLocal);
            IOwinContext owinContext = owinContextMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalSet_UpdatesIsLocal(bool expectedIsLocal)
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                context.IsLocal = expectedIsLocal;

                // Assert
                bool isLocal = context.IsLocal;
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalGet_ReturnsFirstObservedValue(bool expectedIsLocal)
        {
            // Arrange
            Mock<IOwinContext> owinContextMock = CreateOwinContextMock();
            bool currentOwinContextIsLocal = expectedIsLocal;
            owinContextMock.Setup(c => c.Get<bool>(OwinConstants.IsLocalKey)).Returns(() => currentOwinContextIsLocal);
            IOwinContext owinContext = owinContextMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                bool ignore = context.IsLocal;
                currentOwinContextIsLocal = !expectedIsLocal;

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Fact]
        public void PrincipalGet_ReturnsContextRequestUser()
        {
            // Arrange
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            Mock<IOwinRequest> owinRequestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
            owinRequestMock.Setup(r => r.User).Returns(expectedPrincipal);
            IOwinContext owinContext = CreateStubOwinContext(owinRequestMock.Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                IPrincipal principal = context.Principal;

                // Assert
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalSet_UpdatesContextRequestUser()
        {
            // Arrange
            Mock<IOwinRequest> owinRequestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
            IPrincipal principal = null;
            owinRequestMock.SetupSet((r) => r.User = It.IsAny<IPrincipal>()).Callback<IPrincipal>(
                value => { principal = value; });
            IOwinContext owinContext = CreateStubOwinContext(owinRequestMock.Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                IPrincipal expectedPrincipal = CreateDummyPrincipal();

                // Act
                context.Principal = expectedPrincipal;

                // Assert
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalSet_UpdatesThreadCurrentPrincipal()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext(new Mock<IOwinRequest>().Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                IPrincipal expectedPrincipal = CreateDummyPrincipal();

                // Act
                context.Principal = expectedPrincipal;

                // Assert
                IPrincipal principal = Thread.CurrentPrincipal;
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        public void UrlGet_ReturnsUrlHelperForRequest()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, expectedRequest);

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.NotNull(url);
                Assert.Same(expectedRequest, url.Request);
            }
        }

        [Fact]
        public void UrlGet_ReturnsSameInstance()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                UrlHelper firstUrl = context.Url;

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.Same(firstUrl, url);
            }
        }

        [Fact]
        public void UrlSet_UpdatesUrl()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                UrlHelper expectedUrl = CreateDummyUrlHelper();

                // Act
                context.Url = expectedUrl;

                // Assert
                UrlHelper url = context.Url;
                Assert.Same(expectedUrl, url);
            }
        }

        [Fact]
        public void UrlSet_UpdatesUrl_WhenNull()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                context.Url = null;

                // Assert
                UrlHelper url = context.Url;
                Assert.Null(url);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsSlash_ByDefault()
        {
            // Arrange
            IOwinContext owinContext = new OwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal("/", virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsContextRequestPathBase()
        {
            // Arrange
            string expectedVirtualPathRoot = "/foo";
            Mock<IOwinRequest> owinRequestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
            owinRequestMock.Setup(r => r.PathBase).Returns(new PathString(expectedVirtualPathRoot));
            IOwinContext owinContext = CreateStubOwinContext(owinRequestMock.Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        // Regression test for #203.
        [Fact]
        public void VirtualPathRootGet_ReturnsUnescapedContextRequestPathBase()
        {
            // Arrange
            var expectedVirtualPathRoot = "/a b";
            var owinRequestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
            owinRequestMock
                .Setup(r => r.PathBase)
                .Returns(new PathString(expectedVirtualPathRoot));

            var owinContext = CreateStubOwinContext(owinRequestMock.Object);
            using (var request = CreateRequest())
            {
                var context = CreateProductUnderTest(owinContext, request);

                // Act
                var virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Theory]
        [InlineData(null)]
        [InlineData("")]
        public void VirtualPathRootGet_ReturnsSlash_WhenContextRequestPathBaseIsValue(string contextRequestPathBase)
        {
            // Arrange
            Mock<IOwinRequest> owinRequestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
            owinRequestMock.Setup(r => r.PathBase).Returns(new PathString(contextRequestPathBase));
            IOwinContext owinContext = CreateStubOwinContext(owinRequestMock.Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal("/", virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesVirtualPathRoot()
        {
            // Arrange
            IOwinContext owinContext = CreateStubOwinContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                string expectedVirtualPathRoot = "foo";

                // Act
                context.VirtualPathRoot = expectedVirtualPathRoot;

                // Assert
                string virtualPathRoot = context.VirtualPathRoot;
                Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesVirtualPathRoot_WhenNull()
        {
            // Arrange
            Mock<IOwinRequest> owinRequestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
            owinRequestMock.Setup(r => r.PathBase).Returns(new PathString("/other"));
            IOwinContext owinContext = CreateStubOwinContext(owinRequestMock.Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);

                // Act
                context.VirtualPathRoot = null;

                // Assert
                string virtualPathRoot = context.VirtualPathRoot;
                Assert.Null(virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsFirstObservedContextRequestPathBase()
        {
            // Arrange
            string expectedVirtualPathRoot = "/expected";
            string currentVirtualPathRoot = expectedVirtualPathRoot;
            Mock<IOwinRequest> owinRequestMock = new Mock<IOwinRequest>(MockBehavior.Strict);
            owinRequestMock.Setup(r => r.PathBase).Returns(() => new PathString(currentVirtualPathRoot));
            IOwinContext owinContext = CreateStubOwinContext(owinRequestMock.Object);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(owinContext, request);
                string ignore = context.VirtualPathRoot;
                currentVirtualPathRoot = "/other";

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        private static X509Certificate2 CreateCertificate()
        {
            return new X509Certificate2();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static IOwinRequest CreateDummyOwinRequest()
        {
            return new Mock<IOwinRequest>(MockBehavior.Strict).Object;
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static UrlHelper CreateDummyUrlHelper()
        {
            return new Mock<UrlHelper>(MockBehavior.Strict).Object;
        }

        private static Mock<IOwinContext> CreateOwinContextMock()
        {
            Mock<IOwinContext> mock = new Mock<IOwinContext>(MockBehavior.Strict);
            mock.Setup(c => c.Request).Returns(CreateDummyOwinRequest());
            return mock;
        }

        private static OwinHttpRequestContext CreateProductUnderTest(IOwinContext context, HttpRequestMessage request)
        {
            return new OwinHttpRequestContext(context, request);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static IOwinContext CreateStubOwinContext()
        {
            return CreateOwinContextMock().Object;
        }

        private static IOwinContext CreateStubOwinContext(IOwinRequest request)
        {
            Mock<IOwinContext> mock = new Mock<IOwinContext>(MockBehavior.Strict);
            mock.Setup(c => c.Request).Returns(request);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinHttpRequestMessageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using Microsoft.Owin;
using Microsoft.TestCommon;

namespace System.Web.Http.Owin
{
    public class OwinHttpRequestMessageExtensionsTest
    {
        [Fact]
        public void GetOwinContext_Throws_WhenRequestIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(() => { OwinHttpRequestMessageExtensions.GetOwinContext(null); }, "request");
        }

        [Fact]
        public void GetOwinContext_ReturnsNull_WhenNotSet()
        {
            // Act & Assert
            Assert.Null(new HttpRequestMessage().GetOwinContext());
        }

        [Fact]
        public void GetOwinContext_ReturnsSetContextInstance()
        {
            // Arrange
            var request = new HttpRequestMessage();
            var context = new OwinContext();
            request.SetOwinContext(context);

            // Act & Asert
            Assert.Same(context, request.GetOwinContext());
        }

        [Fact]
        public void SetOwinContext_Throws_WhenRequestIsNull()
        {
            // Arrange
            var context = new OwinContext();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { OwinHttpRequestMessageExtensions.SetOwinContext(null, context); },
                "request");
        }

        [Fact]
        public void GetOwinContext_ReturnsOwinContextAndRemovesEnvironmentProperty_AfterSetEnvironmentProperty()
        {
            // Arrange
            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                var environment = new Dictionary<string, object>();
                request.Properties.Add("MS_OwinEnvironment", environment);

                // Act
                var context = request.GetOwinContext();

                // Assert
                Assert.NotNull(context);
                Assert.Same(environment, context.Environment);
                Assert.False(request.Properties.ContainsKey("MS_OwinEnvironment"));
            }
        }

        [Fact]
        public void SetOwinContext_RemovesOwinEnvironmentProperty_WhenPresent()
        {
            // Arrange
            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                var environment = new Dictionary<string, object>();
                request.Properties.Add("MS_OwinEnvironment", environment);
                var context = new OwinContext();

                // Act
                request.SetOwinContext(context);

                // Assert
                Assert.False(request.Properties.ContainsKey("MS_OwinEnvironment"));
            }
        }

        [Fact]
        public void SetOwinContext_Throws_WhenContextIsNull()
        {
            // Arrange
            var request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { OwinHttpRequestMessageExtensions.SetOwinContext(request, null); },
                "context");
        }

        [Fact]
        public void GetOwinEnvironment_Throws_WhenRequestIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(() => { OwinHttpRequestMessageExtensions.GetOwinEnvironment(null); }, "request");
        }

        [Fact]
        public void GetOwinEnvironment_ReturnsNull_WhenNotSet()
        {
            // Act & Assert
            Assert.Null(new HttpRequestMessage().GetOwinEnvironment());
        }

        [Fact]
        public void GetOwinEnvironment_ReturnsSetEnvironmentInstance()
        {
            // Arrange
            var request = new HttpRequestMessage();
            var environment = new Dictionary<string, object>();
            request.SetOwinEnvironment(environment);

            // Act & Assert
            Assert.Same(environment, request.GetOwinEnvironment());
        }

        [Fact]
        public void GetOwinEnvironment_ReturnsSetContextEnvironmentInstance()
        {
            // Arrange
            var request = new HttpRequestMessage();
            var environment = new Dictionary<string, object>();
            var context = new OwinContext(environment);
            request.SetOwinContext(context);

            // Act & Assert
            Assert.Same(environment, request.GetOwinEnvironment());
        }

        [Fact]
        public void GetOwinContext_ReturnsOwinContext_AfterSetContextEnvironment()
        {
            // Arrange
            var request = new HttpRequestMessage();
            var environment = new Dictionary<string, object>();
            request.SetOwinEnvironment(environment);

            // Act
            IOwinContext context = request.GetOwinContext();

            // Assert
            Assert.IsType<OwinContext>(context);
            Assert.Same(environment, context.Environment);
        }

        [Fact]
        public void SetOwinEnvironment_Throws_WhenRequestIsNull()
        {
            // Arrange
            var environment = new Dictionary<string, object>();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => { OwinHttpRequestMessageExtensions.SetOwinEnvironment(null, environment); }, "request");
        }

        [Fact]
        public void SetOwinEnvironment_Throws_WhenEnvironmentIsNull()
        {
            // Arrange
            var request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { OwinHttpRequestMessageExtensions.SetOwinEnvironment(request, null); },
                "environment");
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinRequestExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.Owin;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class OwinRequestExtensionsTests
    {
        [Fact]
        public void DisableBuffering_IfActionIsAvailable_CallsAction()
        {
            // Arrange
            bool bufferingDisabled = false;
            Action disableBufferingAction = () => bufferingDisabled = true;
            IDictionary<string, object> environment = CreateStubEnvironment(disableBufferingAction);
            IOwinRequest request = CreateStubRequest(environment);

            // Act
            OwinRequestExtensions.DisableBuffering(request);

            // Assert
            Assert.True(bufferingDisabled);
        }

        [Fact]
        public void DisableBuffering_IfRequestIsNull_Throws()
        {
            // Arrange
            IOwinRequest request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => OwinRequestExtensions.DisableBuffering(request), "request");
        }

        [Fact]
        public void DisableBuffering_IfEnvironmentIsNull_DoesNotThrow()
        {
            // Arrange
            IDictionary<string, object> environment = null;
            IOwinRequest request = CreateStubRequest(environment);

            // Act & Assert
            Assert.DoesNotThrow(() => request.DisableBuffering());
        }

        [Fact]
        public void DisableBuffering_IfServerDisableResponseBufferingIsAbsent_DoesNotThrow()
        {
            // Arrange
            Mock<IDictionary<string, object>> environmentMock = new Mock<IDictionary<string, object>>(MockBehavior.Strict);
            IDictionary<string, object> environment = CreateStubEnvironment(null, hasDisableBufferingAction: false);
            IOwinRequest request = CreateStubRequest(environment);

            // Act & Assert
            Assert.DoesNotThrow(() => request.DisableBuffering());
        }

        [Fact]
        public void DisableBuffering_IfServerDisableResponseBufferingIsNotAction_DoesNotThrow()
        {
            // Arrange
            object nonAction = new object();
            IDictionary<string, object> environment = CreateStubEnvironment(nonAction);
            IOwinRequest request = CreateStubRequest(environment);

            // Act & Assert
            Assert.DoesNotThrow(() => request.DisableBuffering());
        }

        [Fact]
        public void GetContentLength_IfHeadersIsNull_ReturnsNull()
        {
            // Arrange
            IOwinRequest request = CreateStubRequest(headers: null);
            Assert.Null(request.Headers); // Guard

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfHeadersDoesNotContainContentLengthHeader_ReturnsNull()
        {
            // Arrange
            IHeaderDictionary headers = CreateStubHeaders();
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfContentLengthHeaderValuesIsNull_ReturnsNull()
        {
            // Arrange
            IHeaderDictionary headers = CreateStubHeaders("Content-Length", null);
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfContentLengthHeaderValuesIsEmpty_ReturnsNull()
        {
            // Arrange
            IHeaderDictionary headers = CreateStubHeaders("Content-Length", new string[0]);
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfContentLengthHeaderValuesIsMultiple_ReturnsNull()
        {
            // Arrange
            IHeaderDictionary headers = CreateStubHeaders("Content-Length", new string[] { "123", "456" });
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfContentLengthHeaderIsSingleNullValue_ReturnsNull()
        {
            // Arrange
            IHeaderDictionary headers = CreateStubHeaders("Content-Length", new string[] { null });
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfContentLengthHeaderIsSingleNonIntegerValue_ReturnsNull()
        {
            // Arrange
            IHeaderDictionary headers = CreateStubHeaders("Content-Length", new string[] { "abc" });
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfContentLengthHeaderIsNegative_ReturnsNull()
        {
            // Arrange
            IHeaderDictionary headers = CreateStubHeaders("Content-Length", new string[] { "-1" });
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = OwinRequestExtensions.GetContentLength(request);

            // Assert
            Assert.False(length.HasValue);
        }

        [Fact]
        public void GetContentLength_IfValid_ReturnsValue()
        {
            int expected = 123;
            IHeaderDictionary headers = CreateStubHeaders("Content-Length", new string[] { expected.ToString() });
            IOwinRequest request = CreateStubRequest(headers);

            // Act
            int? length = request.GetContentLength();

            // Assert
            Assert.True(length.HasValue);
            Assert.Equal(expected, length.Value);
        }

        private static IDictionary<string, object> CreateStubEnvironment(object disableBufferingAction)
        {
            return CreateStubEnvironment(disableBufferingAction, hasDisableBufferingAction: true);
        }

        private static IDictionary<string, object> CreateStubEnvironment(object disableBufferingAction, bool hasDisableBufferingAction)
        {
            Mock<IDictionary<string, object>> mock = new Mock<IDictionary<string, object>>(MockBehavior.Strict);
            mock.Setup(d => d.TryGetValue("server.DisableRequestBuffering", out disableBufferingAction)).Returns(hasDisableBufferingAction);
            return mock.Object;
        }

        private static IHeaderDictionary CreateStubHeaders(string key, string[] value)
        {
            Mock<IHeaderDictionary> mock = new Mock<IHeaderDictionary>(MockBehavior.Strict);
            mock.Setup(h => h.TryGetValue(key, out value)).Returns(true);
            return mock.Object;
        }

        private static IHeaderDictionary CreateStubHeaders()
        {
            Mock<IHeaderDictionary> mock = new Mock<IHeaderDictionary>(MockBehavior.Strict);
            string[] value = null;
            mock.Setup(h => h.TryGetValue(It.IsAny<string>(), out value)).Returns(false);
            return mock.Object;
        }

        private static IOwinRequest CreateStubRequest(IHeaderDictionary headers)
        {
            Mock<IOwinRequest> mock = new Mock<IOwinRequest>(MockBehavior.Strict);
            mock.SetupGet(r => r.Headers).Returns(headers);
            return mock.Object;
        }

        private static IOwinRequest CreateStubRequest(IDictionary<string, object> environment)
        {
            Mock<IOwinRequest> mock = new Mock<IOwinRequest>(MockBehavior.Strict);
            mock.SetupGet(r => r.Environment).Returns(environment);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/OwinResponseExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.Owin;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class OwinResponseExtensionsTests
    {
        [Fact]
        public void DisableBuffering_IfActionIsAvailable_CallsAction()
        {
            // Arrange
            bool bufferingDisabled = false;
            Action disableBufferingAction = () => bufferingDisabled = true;
            IDictionary<string, object> environment = CreateStubEnvironment(disableBufferingAction);
            IOwinResponse response = CreateStubResponse(environment);

            // Act
            OwinResponseExtensions.DisableBuffering(response);

            // Assert
            Assert.True(bufferingDisabled);
        }

        [Fact]
        public void DisableBuffering_IfResponseIsNull_Throws()
        {
            // Arrange
            IOwinResponse response = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => OwinResponseExtensions.DisableBuffering(response), "response");
        }

        [Fact]
        public void DisableBuffering_IfEnvironmentIsNull_DoesNotThrow()
        {
            // Arrange
            IDictionary<string, object> environment = null;
            IOwinResponse response = CreateStubResponse(environment);

            // Act & Assert
            Assert.DoesNotThrow(() => response.DisableBuffering());
        }

        [Fact]
        public void DisableBuffering_IfServerDisableResponseBufferingIsAbsent_DoesNotThrow()
        {
            // Arrange
            Mock<IDictionary<string, object>> environmentMock = new Mock<IDictionary<string,object>>(MockBehavior.Strict);
            IDictionary<string, object> environment = CreateStubEnvironment(null, hasDisableBufferingAction: false);
            IOwinResponse response = CreateStubResponse(environment);

            // Act & Assert
            Assert.DoesNotThrow(() => response.DisableBuffering());
        }

        [Fact]
        public void DisableBuffering_IfServerDisableResponseBufferingIsNotAction_DoesNotThrow()
        {
            // Arrange
            object nonAction = new object();
            IDictionary<string, object> environment = CreateStubEnvironment(nonAction);
            IOwinResponse response = CreateStubResponse(environment);

            // Act & Assert
            Assert.DoesNotThrow(() => response.DisableBuffering());
        }

        private static IDictionary<string, object> CreateStubEnvironment(object disableBufferingAction)
        {
            return CreateStubEnvironment(disableBufferingAction, hasDisableBufferingAction: true);
        }

        private static IDictionary<string, object> CreateStubEnvironment(object disableBufferingAction, bool hasDisableBufferingAction)
        {
            Mock<IDictionary<string, object>> mock = new Mock<IDictionary<string, object>>(MockBehavior.Strict);
            mock.Setup(d => d.TryGetValue("server.DisableResponseBuffering", out disableBufferingAction)).Returns(hasDisableBufferingAction);
            return mock.Object;
        }

        private static IOwinResponse CreateStubResponse(IDictionary<string, object> environment)
        {
            Mock<IOwinResponse> mock = new Mock<IOwinResponse>(MockBehavior.Strict);
            mock.SetupGet(r => r.Environment).Returns(environment);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/PassiveAuthenticationMessageHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.Owin;
using Microsoft.Owin.Security;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Owin
{
    public class PassiveAuthenticationMessageHandlerTest
    {
        [Fact]
        public async Task SendAsync_DelegatesToInnerHandler()
        {
            // Arrange
            HttpRequestMessage request = null;
            CancellationToken cancellationToken = default(CancellationToken);
            IOwinContext context = CreateOwinContext();

            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            {
                HttpMessageHandler innerHandler = new LambdaHttpMessageHandler((r, c) =>
                {
                    request = r;
                    cancellationToken = c;
                    return Task.FromResult(expectedResponse);
                });
                HttpMessageHandler handler = CreateProductUnderTest(innerHandler);
                CancellationToken expectedCancellationToken = new CancellationToken(true);

                using (HttpRequestMessage expectedRequest = CreateRequestWithOwinContextAndRequestContext(context))
                {
                    // Act
                    HttpResponseMessage response = await handler.SendAsync(expectedRequest, expectedCancellationToken);

                    // Assert
                    Assert.Same(expectedRequest, request);
                    Assert.Equal(expectedCancellationToken, cancellationToken);
                    Assert.Same(expectedResponse, response);
                }
            }
        }

        [Fact]
        public async Task SendAsync_Throws_WhenRequestContextIsNull()
        {
            // Arrange
            HttpMessageHandler innerHandler = CreateDummyHandler();
            HttpMessageHandler handler = CreateProductUnderTest(innerHandler);

            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                // Act & Assert
                await Assert.ThrowsArgumentAsync(
                    () => handler.SendAsync(request, CancellationToken.None),
                    "request",
                    "The request must have a request context.");
            }
        }

        [Fact]
        public async Task SendAsync_Throws_WhenOwinContextIsNull()
        {
            // Arrange
            HttpMessageHandler innerHandler = CreateStubHandler();
            HttpMessageHandler handler = CreateProductUnderTest(innerHandler);

            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                request.SetRequestContext(new HttpRequestContext());

                // Act & Assert
                InvalidOperationException exception = await Assert.ThrowsAsync<InvalidOperationException>(
                    () => handler.SendAsync(request, CancellationToken.None));
                Assert.Equal("No OWIN authentication manager is associated with the request.", exception.Message);
            }
        }

        [Fact]
        public async Task SendAsync_Throws_WhenAuthenticationManagerIsNull()
        {
            // Arrange
            HttpMessageHandler innerHandler = CreateStubHandler();
            HttpMessageHandler handler = CreateProductUnderTest(innerHandler);
            IOwinContext context = CreateOwinContext(null);

            using (HttpRequestMessage request = CreateRequestWithOwinContextAndRequestContext(context))
            {
                // Act & Assert
                InvalidOperationException exception = await Assert.ThrowsAsync<InvalidOperationException>(
                    () => handler.SendAsync(request, CancellationToken.None));
                Assert.Equal("No OWIN authentication manager is associated with the request.", exception.Message);
            }
        }

        [Fact]
        public async Task SendAsync_SetsRequestContextPrincipalToAnonymous_BeforeCallingInnerHandler()
        {
            // Arrange
            var requestContextMock = new Mock<HttpRequestContext>(MockBehavior.Strict);
            var sequence = new MockSequence();
            var initialPrincipal = new GenericPrincipal(new GenericIdentity("generic user"), new[] { "generic role" });
            IPrincipal requestContextPrincipal = null;
            requestContextMock
                .InSequence(sequence)
                .SetupGet(c => c.Principal)
                .Returns(initialPrincipal);
            requestContextMock
                .InSequence(sequence)
                .SetupSet(c => c.Principal = It.IsAny<IPrincipal>())
                .Callback<IPrincipal>(value => requestContextPrincipal = value);

            // SendAsync also restores the old principal.
            requestContextMock
                .InSequence(sequence)
                .SetupGet(c => c.Principal)
                .Returns(requestContextPrincipal);
            requestContextMock
                .InSequence(sequence)
                .SetupSet(c => c.Principal = initialPrincipal);

            IPrincipal principalBeforeInnerHandler = null;
            HttpMessageHandler inner = new LambdaHttpMessageHandler((ignore1, ignore2) =>
            {
                principalBeforeInnerHandler = requestContextPrincipal;
                return Task.FromResult<HttpResponseMessage>(null);
            });
            HttpMessageHandler handler = CreateProductUnderTest(inner);
            var context = CreateOwinContext();

            using (var request = new HttpRequestMessage())
            {
                request.SetOwinContext(context);
                request.SetRequestContext(requestContextMock.Object);

                // Act
                await handler.SendAsync(request, CancellationToken.None);
            }

            // Assert
            Assert.Equal(requestContextPrincipal, principalBeforeInnerHandler);
            Assert.NotNull(principalBeforeInnerHandler);
            var identity = principalBeforeInnerHandler.Identity;
            Assert.NotNull(identity);
            Assert.False(identity.IsAuthenticated);
            Assert.Null(identity.Name);
            Assert.Null(identity.AuthenticationType);
        }

        [Fact]
        public async Task SendAsync_SuppressesAuthenticationChallenges_WhenNoChallengeIsSet()
        {
            // Arrange
            HttpMessageHandler inner = CreateStubHandler();
            HttpMessageHandler handler = CreateProductUnderTest(inner);
            IOwinContext context = CreateOwinContext();

            using (HttpRequestMessage request = CreateRequestWithOwinContextAndRequestContext(context))
            {
                // Act
                HttpResponseMessage ignore = await handler.SendAsync(request, CancellationToken.None);
            }

            // Assert
            IAuthenticationManager authenticationManager = context.Authentication;
            AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge;
            Assert.NotNull(challenge);
            string[] authenticationTypes = challenge.AuthenticationTypes;
            Assert.NotNull(authenticationTypes);
            string authenticationType = Assert.Single(authenticationTypes);
            Assert.Null(authenticationType);
        }

        [Fact]
        public async Task SendAsync_SuppressesAuthenticationChallenges_WhenExistingAuthenticationTypesIsNull()
        {
            // Arrange
            HttpMessageHandler inner = CreateStubHandler();
            HttpMessageHandler handler = CreateProductUnderTest(inner);
            IOwinContext context = CreateOwinContext();
            IAuthenticationManager authenticationManager = context.Authentication;
            IDictionary<string, string> expectedExtra = new Dictionary<string, string>();
            AuthenticationProperties extraWrapper = new AuthenticationProperties(expectedExtra);
            context.Authentication.AuthenticationResponseChallenge = new AuthenticationResponseChallenge(null,
                extraWrapper);

            using (HttpRequestMessage request = CreateRequestWithOwinContextAndRequestContext(context))
            {
                // Act
                HttpResponseMessage ignore = await handler.SendAsync(request, CancellationToken.None);
            }

            // Assert
            AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge;
            Assert.NotNull(challenge);
            string[] authenticationTypes = challenge.AuthenticationTypes;
            Assert.NotNull(authenticationTypes);
            string authenticationType = Assert.Single(authenticationTypes);
            Assert.Null(authenticationType);
            AuthenticationProperties actualExtraWrapper = challenge.Properties;
            Assert.NotNull(actualExtraWrapper);
            Assert.Same(expectedExtra, actualExtraWrapper.Dictionary);
        }

        [Fact]
        public async Task SendAsync_SuppressesAuthenticationChallenges_WhenExistingAuthenticationTypesIsEmpty()
        {
            // Arrange
            HttpMessageHandler inner = CreateStubHandler();
            HttpMessageHandler handler = CreateProductUnderTest(inner);
            IOwinContext context = CreateOwinContext();
            IAuthenticationManager authenticationManager = context.Authentication;
            AuthenticationProperties extraWrapper = new AuthenticationProperties();
            IDictionary<string, string> expectedExtra = extraWrapper.Dictionary;
            authenticationManager.AuthenticationResponseChallenge = new AuthenticationResponseChallenge(new string[0],
                extraWrapper);

            using (HttpRequestMessage request = CreateRequestWithOwinContextAndRequestContext(context))
            {
                // Act
                HttpResponseMessage ignore = await handler.SendAsync(request, CancellationToken.None);
            }

            // Assert
            AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge;
            Assert.NotNull(challenge);
            string[] authenticationTypes = challenge.AuthenticationTypes;
            Assert.NotNull(authenticationTypes);
            string authenticationType = Assert.Single(authenticationTypes);
            Assert.Null(authenticationType);
            AuthenticationProperties actualExtraWrapper = challenge.Properties;
            Assert.NotNull(actualExtraWrapper);
            Assert.Same(expectedExtra, actualExtraWrapper.Dictionary);
        }

        [Fact]
        public async Task SendAsync_LeavesAuthenticationChallenges_WhenExistingAuthenticationTypesIsNonEmpty()
        {
            // Arrange
            HttpMessageHandler inner = CreateStubHandler();
            HttpMessageHandler handler = CreateProductUnderTest(inner);
            IOwinContext context = CreateOwinContext();
            IAuthenticationManager authenticationManager = context.Authentication;
            AuthenticationProperties extraWrapper = new AuthenticationProperties();
            string[] expectedAuthenticationTypes = new string[] { "Existing" };
            IDictionary<string, string> expectedExtra = extraWrapper.Dictionary;
            authenticationManager.AuthenticationResponseChallenge = new AuthenticationResponseChallenge(
                expectedAuthenticationTypes, extraWrapper);

            using (HttpRequestMessage request = CreateRequestWithOwinContextAndRequestContext(context))
            {
                // Act
                HttpResponseMessage ignore = await handler.SendAsync(request, CancellationToken.None);
            }

            // Assert
            AuthenticationResponseChallenge challenge = authenticationManager.AuthenticationResponseChallenge;
            Assert.NotNull(challenge);
            Assert.Same(expectedAuthenticationTypes, challenge.AuthenticationTypes);
            AuthenticationProperties actualExtraWrapper = challenge.Properties;
            Assert.NotNull(actualExtraWrapper);
            Assert.Same(expectedExtra, actualExtraWrapper.Dictionary);
        }

        private static HttpMessageHandler CreateDummyHandler()
        {
            return new DummyHttpMessageHandler();
        }

        private static IOwinContext CreateOwinContext()
        {
            return new OwinContext();
        }

        private static IOwinContext CreateOwinContext(IAuthenticationManager authenticationManager)
        {
            Mock<IOwinContext> mock = new Mock<IOwinContext>(MockBehavior.Strict);
            mock.SetupGet(m => m.Authentication).Returns(authenticationManager);
            return mock.Object;
        }

        private static PassiveAuthenticationMessageHandler CreateProductUnderTest(HttpMessageHandler innerHandler)
        {
            PassiveAuthenticationMessageHandler handler = new PassiveAuthenticationMessageHandler();
            handler.InnerHandler = innerHandler;
            return handler;
        }

        private static HttpRequestMessage CreateRequestWithOwinContextAndRequestContext(IOwinContext context)
        {
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetOwinContext(context);
            request.SetRequestContext(new HttpRequestContext());
            return request;
        }

        private static HttpMessageHandler CreateStubHandler()
        {
            return new LambdaHttpMessageHandler((ignore1, ignore2) =>
            {
                return Task.FromResult<HttpResponseMessage>(null);
            });
        }

        private class DummyHttpMessageHandler : HttpMessageHandler
        {
            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }
        }

        private class LambdaHttpMessageHandler : HttpMessageHandler
        {
            private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _sendAsync;

            public LambdaHttpMessageHandler(Func<HttpRequestMessage, CancellationToken,
                Task<HttpResponseMessage>> sendAsync)
            {
                if (sendAsync == null)
                {
                    throw new ArgumentNullException("sendAsync");
                }

                _sendAsync = sendAsync;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                return _sendAsync.Invoke(request, cancellationToken);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/System.Web.Http.Owin.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{C19267DD-3984-430C-AE18-4034F85DE4E5}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.Owin</RootNamespace>
    <AssemblyName>System.Web.Http.Owin.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.Owin">
      <HintPath>..\..\packages\Microsoft.Owin.4.2.2\lib\net45\Microsoft.Owin.dll</HintPath>
    </Reference>
    <Reference Include="Microsoft.Owin.Host.HttpListener, Version=4.2.2.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\Microsoft.Owin.Host.HttpListener.4.2.2\lib\net45\Microsoft.Owin.Host.HttpListener.dll</HintPath>
    </Reference>
    <Reference Include="Microsoft.Owin.Hosting, Version=4.2.2.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <SpecificVersion>False</SpecificVersion>
      <HintPath>..\..\packages\Microsoft.Owin.Hosting.4.2.2\lib\net45\Microsoft.Owin.Hosting.dll</HintPath>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Owin">
      <HintPath>..\..\packages\Owin.1.0\lib\net40\Owin.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="ExceptionHandling\DefaultExceptionHandlerTests.cs" />
    <Compile Include="ExceptionHandling\EmptyExceptionLoggerTests.cs" />
    <Compile Include="HttpMessageHandlerOptionsTests.cs" />
    <Compile Include="NonOwnedStreamTests.cs" />
    <Compile Include="OwinExceptionCatchBlocksTests.cs" />
    <Compile Include="OwinHttpRequestContextTests.cs" />
    <Compile Include="HostAuthenticationAttributeTest.cs" />
    <Compile Include="HostAuthenticationFilterTest.cs" />
    <Compile Include="OwinHttpConfigurationExtensionsTest.cs" />
    <Compile Include="HttpMessageHandlerExtensions.cs" />
    <Compile Include="OwinHttpRequestMessageExtensionsTest.cs" />
    <Compile Include="OwinRequestExtensionsTests.cs" />
    <Compile Include="OwinResponseExtensionsTests.cs" />
    <Compile Include="PassiveAuthenticationMessageHandlerTest.cs" />
    <Compile Include="WebApiAppBuilderExtensionsTest.cs" />
    <Compile Include="OwinBufferPolicySelectorTest.cs" />
    <Compile Include="HttpMessageHandlerAdapterTest.cs" />
    <Compile Include="OwinHostIntegrationTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.Owin\System.Web.Http.Owin.csproj">
      <Project>{66dd7cd7-c68f-4d0e-9f3d-3b58c49d1467}</Project>
      <Name>System.Web.Http.Owin</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{fccc4cb7-baf7-4a57-9f89-e5766fe536c0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Http.Owin.Test/WebApiAppBuilderExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using Microsoft.TestCommon;
using Moq;
using Owin;

namespace System.Web.Http.Owin
{
    public class WebApiAppBuilderExtensionsTest
    {
        [Fact]
        public void UseWebApiWithConfiguration_IfBuilderIsNull_Throws()
        {
            // Arrange
            IAppBuilder builder = null;

            using (HttpConfiguration configuration = CreateConfiguration())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() => WebApiAppBuilderExtensions.UseWebApi(builder, configuration),
                    "builder");
            }
        }

        [Fact]
        public void UseWebApiWithConfiguration_IfConfigurationIsNull_Throws()
        {
            // Arrange
            IAppBuilder builder = CreateDummyAppBuilder();
            HttpConfiguration configuration = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => WebApiAppBuilderExtensions.UseWebApi(builder, configuration),
                "configuration");
        }

        [Fact]
        public void UseWebApiWithServer_IfBuilderIsNull_Throws()
        {
            // Arrange
            IAppBuilder builder = null;

            using (HttpServer httpServer = CreateServer())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() => WebApiAppBuilderExtensions.UseWebApi(builder, httpServer), "builder");
            }
        }

        [Fact]
        public void UseWebApiWithServer_IfServerIsNull_Throws()
        {
            // Arrange
            IAppBuilder builder = CreateDummyAppBuilder();
            HttpServer httpServer = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => WebApiAppBuilderExtensions.UseWebApi(builder, httpServer), "httpServer");
        }

        [Fact]
        public void UseWebApi_UsesAdapter()
        {
            var config = new HttpConfiguration();
            var appBuilder = new Mock<IAppBuilder>();
            appBuilder
                .Setup(ab => ab.Use(
                    typeof(HttpMessageHandlerAdapter),
                    It.Is<HttpMessageHandlerOptions>((o) => ((HttpServer)o.MessageHandler).Configuration == config)))
                .Returns(appBuilder.Object)
                .Verifiable();

            IAppBuilder returnedAppBuilder = appBuilder.Object.UseWebApi(config);

            Assert.Equal(appBuilder.Object, returnedAppBuilder);
            appBuilder.Verify();
        }

        [Fact]
        public async Task UseWebApi_UsesAdapterAndConfigServices()
        {
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                var config = new HttpConfiguration();
                var bufferPolicySelector = new Mock<IHostBufferPolicySelector>().Object;
                Mock<IExceptionLogger> loggerMock = new Mock<IExceptionLogger>();
                Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>();
                config.Services.Replace(typeof(IHostBufferPolicySelector), bufferPolicySelector);
                config.Services.Replace(typeof(IExceptionLogger), loggerMock.Object);
                config.Services.Replace(typeof(IExceptionHandler), handlerMock.Object);
                IExceptionLogger exceptionLogger = null;
                IExceptionHandler exceptionHandler = null;
                var appBuilder = new Mock<IAppBuilder>();
                CancellationToken expectedAppDisposing = tokenSource.Token;
                IDictionary<string, object> properties = new Dictionary<string, object>
                {
                    { "host.OnAppDisposing", expectedAppDisposing }
                };
                appBuilder.SetupGet(b => b.Properties).Returns(properties);
                appBuilder
                    .Setup(ab => ab.Use(
                        typeof(HttpMessageHandlerAdapter),
                        It.Is<HttpMessageHandlerOptions>((o) => ((HttpServer)o.MessageHandler).Configuration == config
                            && o.BufferPolicySelector == bufferPolicySelector
                            && o.AppDisposing == expectedAppDisposing)))
                    .Callback<object, object[]>((i, args) =>
                    {
                        HttpMessageHandlerOptions options = (HttpMessageHandlerOptions)args[0];
                        exceptionLogger = options.ExceptionLogger;
                        exceptionHandler = options.ExceptionHandler;
                    })
                    .Returns(appBuilder.Object)
                    .Verifiable();

                IAppBuilder returnedAppBuilder = appBuilder.Object.UseWebApi(config);

                Assert.Equal(appBuilder.Object, returnedAppBuilder);
                appBuilder.Verify();
                await AssertDelegatesToAsync(loggerMock, exceptionLogger);
                await AssertDelegatesToAsync(handlerMock, exceptionHandler);
            }
        }

        [Fact]
        public void UseWebApiWithHttpServer_UsesAdapter()
        {
            // Arrange
            HttpServer httpServer = new Mock<HttpServer>().Object;
            Mock<IAppBuilder> appBuilderMock = new Mock<IAppBuilder>();
            appBuilderMock
                .Setup(ab => ab.Use(
                    typeof(HttpMessageHandlerAdapter),
                    It.Is<HttpMessageHandlerOptions>((o) => o.MessageHandler == httpServer)))
                .Returns(appBuilderMock.Object)
                .Verifiable();

            // Act
            IAppBuilder returnedAppBuilder = appBuilderMock.Object.UseWebApi(httpServer);

            // Assert
            Assert.Equal(appBuilderMock.Object, returnedAppBuilder);
            appBuilderMock.Verify();
        }

        [Fact]
        public async Task UseWebApiWithHttpServer_UsesAdapterAndConfigServices()
        {
            // Arrange
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                HttpConfiguration config = new HttpConfiguration();
                IHostBufferPolicySelector bufferPolicySelector = new Mock<IHostBufferPolicySelector>().Object;
                Mock<IExceptionLogger> loggerMock = new Mock<IExceptionLogger>();
                Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>();
                config.Services.Replace(typeof(IHostBufferPolicySelector), bufferPolicySelector);
                config.Services.Replace(typeof(IExceptionLogger), loggerMock.Object);
                config.Services.Replace(typeof(IExceptionHandler), handlerMock.Object);
                HttpServer httpServer = new Mock<HttpServer>(config).Object;
                IExceptionLogger exceptionLogger = null;
                IExceptionHandler exceptionHandler = null;
                Mock<IAppBuilder> appBuilderMock = new Mock<IAppBuilder>();
                CancellationToken expectedAppDisposing = tokenSource.Token;
                IDictionary<string, object> properties = new Dictionary<string, object>
                {
                    { "host.OnAppDisposing", expectedAppDisposing }
                };
                appBuilderMock.SetupGet(b => b.Properties).Returns(properties);
                appBuilderMock
                    .Setup(ab => ab.Use(
                        typeof(HttpMessageHandlerAdapter),
                        It.Is<HttpMessageHandlerOptions>((o) => o.MessageHandler == httpServer
                            && o.BufferPolicySelector == bufferPolicySelector
                            && o.AppDisposing == expectedAppDisposing)))
                    .Callback<object, object[]>((i, args) =>
                    {
                        HttpMessageHandlerOptions options = (HttpMessageHandlerOptions)args[0];
                        exceptionLogger = options.ExceptionLogger;
                        exceptionHandler = options.ExceptionHandler;
                    })
                    .Returns(appBuilderMock.Object)
                    .Verifiable();

                // Act
                IAppBuilder returnedAppBuilder = appBuilderMock.Object.UseWebApi(httpServer);

                // Assert
                Assert.Equal(appBuilderMock.Object, returnedAppBuilder);
                appBuilderMock.Verify();
                await AssertDelegatesToAsync(loggerMock, exceptionLogger);
                await AssertDelegatesToAsync(handlerMock, exceptionHandler);
            }
        }

        [Fact]
        public void GetOnAppDisposingProperty_IfPropertiesIsPresent_ReturnsSpecifiedValue()
        {
            // Arrange
            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                CancellationToken expectedOnAppDisposing = tokenSource.Token;
                IDictionary<string, object> properties = CreateStubOnAppDisposingDictionary(expectedOnAppDisposing);
                IAppBuilder builder = CreateStubAppBuilder(properties);

                // Act
                CancellationToken onAppDisposing = builder.GetOnAppDisposingProperty();

                // Assert
                Assert.Equal(expectedOnAppDisposing, onAppDisposing);
            }
        }

        [Fact]
        public void GetOnAppDisposingProperty_IfPropertiesIsNull_ReturnsCancellationTokenNone()
        {
            // Arrange
            IDictionary<string, object> properties = null;
            IAppBuilder builder = CreateStubAppBuilder(properties);

            // Act
            CancellationToken onAppDisposing = WebApiAppBuilderExtensions.GetOnAppDisposingProperty(builder);

            // Assert
            Assert.Equal(CancellationToken.None, onAppDisposing);
        }

        [Fact]
        public void GetOnAppDisposingProperty_IfPropertyIsAbsent_ReturnsCancellationTokenNone()
        {
            // Arrange
            IDictionary<string, object> properties = CreateStubOnAppDisposingDictionary(onAppDisposing: null, hasOnAppDisposing: false);
            IAppBuilder builder = CreateStubAppBuilder(properties);

            // Act
            CancellationToken onAppDisposing = WebApiAppBuilderExtensions.GetOnAppDisposingProperty(builder);

            // Assert
            Assert.Equal(CancellationToken.None, onAppDisposing);
        }

        [Fact]
        public void GetOnAppDisposingProperty_IfPropertyIsNonCancellationToken_ReturnsCancellationTokenNone()
        {
            // Arrange
            object nonCancellationToken = new object();
            IDictionary<string, object> properties = CreateStubOnAppDisposingDictionary(nonCancellationToken);
            IAppBuilder builder = CreateStubAppBuilder(properties);

            // Act
            CancellationToken onAppDisposing = WebApiAppBuilderExtensions.GetOnAppDisposingProperty(builder);

            // Assert
            Assert.Equal(CancellationToken.None, onAppDisposing);
        }

        private static async Task AssertDelegatesToAsync(Mock<IExceptionHandler> expected, IExceptionHandler actual)
        {
            Assert.NotNull(actual);

            ExceptionHandlerContext context = new ExceptionHandlerContext(new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer));
            CancellationToken cancellationToken = CancellationToken.None;

            expected
                .Setup((l) => l.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(CreateCanceledTask());

            await Assert.ThrowsAsync<TaskCanceledException>(() => actual.HandleAsync(context, cancellationToken));

            expected.Verify((l) => l.HandleAsync(context, cancellationToken), Times.Once());
        }

        private static async Task AssertDelegatesToAsync(Mock<IExceptionLogger> expected, IExceptionLogger actual)
        {
            Assert.NotNull(actual);

            ExceptionLoggerContext context = new ExceptionLoggerContext(new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer));
            CancellationToken cancellationToken = CancellationToken.None;

            expected
                .Setup((l) => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(CreateCanceledTask());

            await Assert.ThrowsAsync<TaskCanceledException>(() => actual.LogAsync(context, cancellationToken));

            expected.Verify((l) => l.LogAsync(context, cancellationToken), Times.Once());
        }

        private static Task CreateCanceledTask()
        {
            TaskCompletionSource<object> source = new TaskCompletionSource<object>();
            source.SetCanceled();
            return source.Task;
        }

        private static CancellationTokenSource CreateCancellationTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static IAppBuilder CreateDummyAppBuilder()
        {
            return new Mock<IAppBuilder>(MockBehavior.Strict).Object;
        }

        private static HttpServer CreateServer()
        {
            return new HttpServer();
        }

        private static IAppBuilder CreateStubAppBuilder(IDictionary<string, object> properties)
        {
            Mock<IAppBuilder> mock = new Mock<IAppBuilder>(MockBehavior.Strict);
            mock.SetupGet(b => b.Properties).Returns(properties);
            return mock.Object;
        }

        private static IDictionary<string, object> CreateStubOnAppDisposingDictionary(object onAppDisposing)
        {
            return CreateStubOnAppDisposingDictionary(onAppDisposing, hasOnAppDisposing: true);
        }

        private static IDictionary<string, object> CreateStubOnAppDisposingDictionary(object onAppDisposing, bool hasOnAppDisposing)
        {
            Mock<IDictionary<string, object>> mock = new Mock<IDictionary<string, object>>();
            mock.Setup(d => d.TryGetValue("host.OnAppDisposing", out onAppDisposing)).Returns(hasOnAppDisposing);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Owin.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Microsoft.Owin" version="4.2.2" targetFramework="net462" />
  <package id="Microsoft.Owin.Host.HttpListener" version="4.2.2" targetFramework="net462" />
  <package id="Microsoft.Owin.Hosting" version="4.2.2" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="Owin" version="1.0" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.SelfHost.Test/Authentication/BasicOverHttpTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.ServiceModel;
using System.Threading.Tasks;
using System.Web.Http.SelfHost;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    [Xunit.Collection("PortReserver Collection")] // Avoid conflicts between different PortReserver consumers.
    public class BasicOverHttpTest
    {
        [Fact]
        public Task AuthenticateWithUsernameTokenSucceed()
        {
            return RunBasicAuthTest("Sample", "", new NetworkCredential("username", "password"),
                (response) => Assert.Equal(HttpStatusCode.OK, response.StatusCode)
                );
        }

        [Fact]
        public Task AuthenticateWithWrongPasswordFail()
        {
            return RunBasicAuthTest("Sample", "", new NetworkCredential("username", "wrong password"),
                (response) => Assert.Equal(HttpStatusCode.Forbidden, response.StatusCode)
                );
        }

        [Fact]
        public Task AuthenticateWithNoCredentialFail()
        {
            return RunBasicAuthTest("Sample", "", null,
                (response) => Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode)
                );
        }

        private static async Task RunBasicAuthTest(string controllerName, string routeSuffix, NetworkCredential credential, Action<HttpResponseMessage> assert)
        {
            using (var port = new PortReserver())
            {
                // Arrange
                HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(port.BaseUri);
                config.HostNameComparisonMode = HostNameComparisonMode.Exact;
                config.Routes.MapHttpRoute("Default", "{controller}" + routeSuffix, new { controller = controllerName });
                config.UserNamePasswordValidator = new CustomUsernamePasswordValidator();
                config.MessageHandlers.Add(new CustomMessageHandler());
                HttpSelfHostServer server = new HttpSelfHostServer(config);

                await server.OpenAsync();

                // Create a GET request with correct username and password
                HttpClientHandler handler = new HttpClientHandler();
                handler.Credentials = credential;
                HttpClient client = new HttpClient(handler);

                HttpResponseMessage response = null;
                try
                {
                    // Act
                    response = await client.GetAsync(port.BaseUri);

                    // Assert
                    assert(response);
                }
                finally
                {
                    if (response != null)
                    {
                        response.Dispose();
                    }
                    client.Dispose();
                }

                await server.CloseAsync();
            }
        }

    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/Authentication/CustomMessageHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Principal;
using System.ServiceModel;
using System.ServiceModel.Security;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http
{
    public class CustomMessageHandler : DelegatingHandler
    {
        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            IPrincipal originalPrincipal = Thread.CurrentPrincipal;

            // here you can see the requestor's identity via the request message
            // convert the Generic Identity to some IPrincipal object, and set it in the request's property
            // later the authorization filter will use the role information to authorize request.
            SecurityMessageProperty property = request.GetSecurityMessageProperty();
            if (property != null)
            {
                ServiceSecurityContext context = property.ServiceSecurityContext;

                if (context.PrimaryIdentity.Name == "username")
                {
                    Thread.CurrentPrincipal = new GenericPrincipal(context.PrimaryIdentity, new string[] { "Administrators" });
                }
            }

            try
            {
                return await base.SendAsync(request, cancellationToken);
            }
            finally
            {
                Thread.CurrentPrincipal = originalPrincipal;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/Authentication/CustomUsernamePasswordValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IdentityModel.Selectors;

namespace System.Web.Http
{
    public class CustomUsernamePasswordValidator : UserNamePasswordValidator
    {
        public override void Validate(string userName, string password)
        {
            if (userName == "username" && password == "password")
            {
                return;
            }
            else
            {
                throw new InvalidOperationException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/Authentication/RequireAdminAttribute.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;

namespace System.Web.Http
{
    public class RequireAdminAttribute : AuthorizationFilterAttribute
    {
        public override void OnAuthorization(HttpActionContext context)
        {
            // do authorization based on the principle.
            IPrincipal principal = Thread.CurrentPrincipal;
            if (principal == null || !principal.IsInRole("Administrators"))
            {
                context.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized);
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.SelfHost.Test/Authentication/SampleController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http
{
    /// <summary>
    /// Sample ApiControler
    /// </summary>
    public class SampleController : ApiController
    {
        [RequireAdmin]
        public string Get()
        {
            return "hello";
        }
    }
}

================================================
FILE: test/System.Web.Http.SelfHost.Test/Channels/HttpBindingSecurityModeHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.SelfHost.Channels;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class HttpBindingSecurityModeHelperTest : EnumHelperTestBase<HttpBindingSecurityMode>
    {
        public HttpBindingSecurityModeHelperTest()
            : base(HttpBindingSecurityModeHelper.IsDefined, HttpBindingSecurityModeHelper.Validate, (HttpBindingSecurityMode)999)
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/DeeplyNestedTypeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.ServiceModel;
using System.Text;
using System.Threading.Tasks;
using System.Xml.Linq;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Web.Http.SelfHost
{
    public class DeepNestedTypeTests
    {
        private HttpSelfHostServer server = null;
        private string baseAddress = null;
        private HttpClient httpClient = null;

        public DeepNestedTypeTests()
        {
            this.SetupHost();
        }

        private void SetupHost()
        {
            baseAddress = String.Format("http://localhost/");

            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);
            config.HostNameComparisonMode = HostNameComparisonMode.Exact;
            config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "DeepNestedType" });

            server = new HttpSelfHostServer(config);

            httpClient = new HttpClient(server);
        }

        [Fact]
        public async Task PostDeeplyNestedTypeInXmlThrows()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "DeepNestedType/PostNest"));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;
            request.Content = new StringContent(GetNestedObjectInXml(8000), UTF8Encoding.UTF8, "application/xml");

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
        }

        [Fact]
        public async Task PostNotTooDeeplyNestedTypeInXmlWorks()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "DeepNestedType/PostNest"));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;
            request.Content = new StringContent(GetNestedObjectInXml(20), UTF8Encoding.UTF8, "application/xml");

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">success from PostNest</string>";
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task PostDeeplyNestedTypeInFormUrlEncodedThrows()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "DeepNestedType/PostJToken"));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;
            request.Content = new StringContent(GetNestedObjectInFormUrl(5000), UTF8Encoding.UTF8, "application/x-www-form-urlencoded");

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
        }

        [Fact]
        public async Task PostNotTooDeeplyNestedTypeInFormUrlEncodedWorks()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "DeepNestedType/PostJToken"));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;
            request.Content = new StringContent(GetNestedObjectInFormUrl(20), UTF8Encoding.UTF8, "application/x-www-form-urlencoded");

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">success from PostJToken</string>";
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task PostNestedListInFormUrlEncodedWorks()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "DeepNestedType/PostNestedList"));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;
            request.Content = new StringContent(GetBigListInFormUrl(70000), Encoding.UTF8, "application/x-www-form-urlencoded");

            // Act
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">success from PostNestedList</string>";
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task PostBigArrayWorks()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "DeepNestedType/PostXElement"));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;

            request.Content = new StringContent(GetBigArray(5000), Encoding.UTF8, "application/xml");

            // Act
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">success from PostXElement</string>";
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        /*
        <?xml version="1.0"?>
        <ArrayOfString xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
        <string />
        <string />
        <string />
        </ArrayOfString>
        */
            private string GetBigArray(int arraySize)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 0; i < arraySize; i++)
                {
                    sb.Append("<string/>");
                }

                sb.Insert(0, "<ArrayOfString>");
                sb.Append("</ArrayOfString>");
                sb.Insert(0, "<?xml version=\"1.0\"?>");

                return sb.ToString();
            }

        private string GetNestedObjectInXml(int depth)
        {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < depth; i++)
            {
                sb.Insert(0, "<A>");
                sb.Append("</A>");
            }

            sb.Insert(0, "<Nest xmlns=\"http://schemas.datacontract.org/2004/07/System.Web.Http.SelfHost\">");
            sb.Append("</Nest>");
            sb.Insert(0, "<?xml version=\"1.0\"?>");

            return sb.ToString();
        }

        private string GetNestedObjectInFormUrl(int depth)
        {
            StringBuilder sb = new StringBuilder("a");
            for (int i = 0; i < depth; i++)
            {
                sb.Append("[a]");
            }
            sb.Append("=1");
            return sb.ToString();
        }

        private string GetBigListInFormUrl(int depth)
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("a");
            for (int i = 0; i < depth; i++)
            {
                sb.Append("[N]");
            }
            sb.Append("[D]=1");
            return sb.ToString();
        }
    }

    public class DeepNestedTypeController : ApiController
    {
        public string PostNest(Nest a)
        {
            if (!ModelState.IsValid)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError));
            }
            return "success from PostNest";
        }

        public string PostJToken(JToken token)
        {
            if (!ModelState.IsValid)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError));
            }
            return "success from PostJToken";
        }

        public string PostNestedList(MyList a)
        {
            if (!ModelState.IsValid)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError));
            }
            return "success from PostNestedList";
        }

        public string PostXElement(XElement input)
        {
            if (!ModelState.IsValid)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError));
            }

            return "success from PostXElement";
        }
    }

    public class Nest
    {
        public Nest A { get; set; }
    }

    public class MyList
    {
        public int D { get; set; }
        public MyList N { get; set; }
    }

}


================================================
FILE: test/System.Web.Http.SelfHost.Test/HttpSelfHostConfigurationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IdentityModel.Selectors;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Description;
using System.Threading.Tasks;
using System.Web.Http.SelfHost.Channels;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.SelfHost
{
    public class HttpSelfHostConfigurationTest
    {
        public static TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType> BasicClientCredentialTestData
        {
            get
            {
                return new TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType>()
                {
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Basic},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Basic},
                };
            }
        }

        public static TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType> CertificateClientCredentialTestData
        {
            get
            {
                return new TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType>()
                {
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Certificate},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Certificate},
                };
            }
        }

        public static TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType> NonCertificateClientCredentialTestData
        {
            get
            {
                return new TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType>()
                {
                    {"http://localhost", HttpBindingSecurityMode.None, HttpClientCredentialType.None},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.None},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Basic},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Basic},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Digest},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Digest},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Ntlm},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Ntlm},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Windows},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Windows},
                };
            }
        }

        public static TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType> NonBasicClientCredentialTestData
        {
            get
            {
                return new TheoryDataSet<string, HttpBindingSecurityMode, HttpClientCredentialType>()
                {
                    {"http://localhost", HttpBindingSecurityMode.None, HttpClientCredentialType.None},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.None},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Certificate},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Certificate},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Digest},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Digest},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Ntlm},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Ntlm},
                    {"http://localhost", HttpBindingSecurityMode.TransportCredentialOnly, HttpClientCredentialType.Windows},
                    {"https://localhost", HttpBindingSecurityMode.Transport, HttpClientCredentialType.Windows},
                };
            }
        }

        [Fact]
        public void HttpSelfHostConfiguration_NullBaseAddressString_Throws()
        {
            Assert.ThrowsArgumentNull(() => new HttpSelfHostConfiguration((string)null), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_RelativeBaseAddressString_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration("relative"), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_QueryBaseAddressString_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration("http://localhost?somequery"), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_FragmentBaseAddressString_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration("http://localhost#somefragment"), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_InvalidSchemeBaseAddressString_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration("ftp://localhost"), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_NullBaseAddress_Throws()
        {
            Assert.ThrowsArgumentNull(() => new HttpSelfHostConfiguration((Uri)null), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_RelativeBaseAddress_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration(new Uri("relative", UriKind.Relative)), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_QueryBaseAddress_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration(new Uri("http://localhost?somequery")), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_FragmentBaseAddress_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration(new Uri("http://localhost#somefragment")), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_InvalidSchemeBaseAddress_Throws()
        {
            Assert.ThrowsArgument(() => new HttpSelfHostConfiguration(new Uri("ftp://localhost")), "baseAddress");
        }

        [Fact]
        public void HttpSelfHostConfiguration_BaseAddress_IsSet()
        {
            // Arrange
            Uri baseAddress = new Uri("http://localhost");

            // Act
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);

            // Assert
            Assert.Same(baseAddress, config.BaseAddress);
        }

        [Fact]
        public void HttpSelfHostConfiguration_MaxConcurrentRequests_RoundTrips()
        {
            Assert.Reflection.IntegerProperty(
                new HttpSelfHostConfiguration("http://localhost"),
                c => c.MaxConcurrentRequests,
                expectedDefaultValue: GetDefaultMaxConcurrentRequests(),
                minLegalValue: 1,
                illegalLowerValue: 0,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 10);
        }

        [Fact]
        public void HttpSelfHostConfiguration_MaxBufferSize_RoundTrips()
        {
            Assert.Reflection.IntegerProperty(
                new HttpSelfHostConfiguration("http://localhost"),
                c => c.MaxBufferSize,
                expectedDefaultValue: 64 * 1024,
                minLegalValue: 1,
                illegalLowerValue: 0,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 10);
        }

        [Theory]
        [InlineData(1, 1)]
        [InlineData(1024, 1024)]
        [InlineData(Int32.MaxValue - 1, Int32.MaxValue - 1)]
        [InlineData(Int32.MaxValue, Int32.MaxValue)]
        [InlineData(Int64.MaxValue - 1, Int32.MaxValue)]
        [InlineData(Int64.MaxValue, Int32.MaxValue)]
        public void HttpSelfHostConfiguration_MaxBufferSize_TracksMaxReceivedMessageSizeWhenNotSet(long maxReceivedMessageSize, int expectedMaxBufferSize)
        {
            // Arrange
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost");
            config.MaxReceivedMessageSize = maxReceivedMessageSize;

            // Act & Assert
            Assert.Equal(expectedMaxBufferSize, config.MaxBufferSize);
        }

        [Theory]
        [InlineData(2, 1)]
        [InlineData(1025, 1024)]
        [InlineData(Int64.MaxValue, Int32.MaxValue)]
        public void HttpSelfHostConfiguration_MaxBufferSize_DoesNotTrackMaxReceivedMessageSizeWhenSet(long maxReceivedMessageSize, int maxBufferSize)
        {
            // Arrange
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost");
            config.MaxBufferSize = maxBufferSize;
            config.MaxReceivedMessageSize = maxReceivedMessageSize;

            // Act & Assert
            Assert.Equal(maxBufferSize, config.MaxBufferSize);
            Assert.Equal(maxReceivedMessageSize, config.MaxReceivedMessageSize);
        }

        [Theory]
        [InlineData(1)]
        [InlineData(1024)]
        [InlineData(Int64.MaxValue)]
        public void HttpSelfHostConfiguration_MaxBufferSize_DoesNotTrackMaxReceivedMessageIfNotBuffered(long maxReceivedMessageSize)
        {
            // Arrange
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost");
            config.TransferMode = TransferMode.Streamed;
            config.MaxReceivedMessageSize = maxReceivedMessageSize;

            // Act & Assert
            Assert.Equal(maxReceivedMessageSize, config.MaxReceivedMessageSize);
            Assert.Equal(64 * 1024, config.MaxBufferSize);
        }

        [Fact]
        public void HttpSelfHostConfiguration_MaxReceivedMessageSize_RoundTrips()
        {
            Assert.Reflection.IntegerProperty(
                new HttpSelfHostConfiguration("http://localhost"),
                c => c.MaxReceivedMessageSize,
                expectedDefaultValue: 64 * 1024,
                minLegalValue: 1,
                illegalLowerValue: 0,
                maxLegalValue: null,
                illegalUpperValue: null,
                roundTripTestValue: 10);
        }

        [Fact]
        public Task HttpSelfHostConfiguration_ClientCredentialType_RoundTrips()
        {
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost");

            Assert.Reflection.EnumPropertyWithoutIllegalValueCheck<HttpSelfHostConfiguration, HttpClientCredentialType>(
                   config,
                   c => c.ClientCredentialType,
                   expectedDefaultValue: HttpClientCredentialType.None,
                   roundTripTestValue: HttpClientCredentialType.Windows);

            // now let us check the illegal value differently
            config.ClientCredentialType = (HttpClientCredentialType)999;
            return Assert.ThrowsArgumentOutOfRangeAsync(() => new HttpSelfHostServer(config).OpenAsync(), "value", null, 999);
        }

        [Fact]
        public void HttpSelfHostConfiguration_UserNamePasswordValidator_RoundTrips()
        {
            // Arrange
            UserNamePasswordValidator userNamePasswordValidator = new Mock<UserNamePasswordValidator>().Object;

            Assert.Reflection.Property(
                new HttpSelfHostConfiguration("http://localhost"),
                c => c.UserNamePasswordValidator,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: userNamePasswordValidator);
        }

        [Fact]
        public void HttpSelfHostConfiguration_X509CertificateValidator_RoundTrips()
        {
            // Arrange
            X509CertificateValidator x509CertificateValidator = new Mock<X509CertificateValidator>().Object;

            Assert.Reflection.Property(
                new HttpSelfHostConfiguration("http://localhost"),
                c => c.X509CertificateValidator,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: x509CertificateValidator);
        }

        [Fact]
        public void HttpSelfHostConfiguration_TransferMode_RoundTrips()
        {
            Assert.Reflection.EnumProperty(
                new HttpSelfHostConfiguration("http://localhost"),
                c => c.TransferMode,
                expectedDefaultValue: TransferMode.Buffered,
                illegalValue: (TransferMode)999,
                roundTripTestValue: TransferMode.Streamed);
        }

        [Fact]
        public void HttpSelfHostConfiguration_HostNameComparisonMode_RoundTrips()
        {
            Assert.Reflection.EnumProperty(
                new HttpSelfHostConfiguration("http://localhost"),
                c => c.HostNameComparisonMode,
                expectedDefaultValue: HostNameComparisonMode.StrongWildcard,
                illegalValue: (HostNameComparisonMode)999,
                roundTripTestValue: HostNameComparisonMode.Exact);
        }

        [Fact]
        public void HttpSelfHostConfiguration_NegativeTimeouts_ThrowArgumentOutOfRange()
        {
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost");
            TimeSpan negativeTimeout = new TimeSpan(-1, 0, 0);

            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => config.ReceiveTimeout = negativeTimeout, "value", "00:00:00", "-01:00:00");
            Assert.ThrowsArgumentGreaterThanOrEqualTo(() => config.SendTimeout = negativeTimeout, "value", "00:00:00", "-01:00:00");
        }

        [Fact]
        public void HttpSelfHostConfiguration_Settings_PropagateToBinding()
        {
            // Arrange
            HttpBinding binding = new HttpBinding();
            binding.ConfigureTransportBindingElement = ConfigureTransportBindingElement;
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost")
            {
                MaxBufferSize = 10,
                MaxReceivedMessageSize = 11,
                ReceiveTimeout = new TimeSpan(1, 0, 0),
                SendTimeout = new TimeSpan(1, 0, 0),
                TransferMode = TransferMode.StreamedResponse,
                HostNameComparisonMode = HostNameComparisonMode.WeakWildcard
            };

            // Act
            config.ConfigureBinding(binding);

            // Assert
            Assert.Equal(10, binding.MaxBufferSize);
            Assert.Equal(11, binding.MaxReceivedMessageSize);
            Assert.Equal(new TimeSpan(1, 0, 0), binding.ReceiveTimeout);
            Assert.Equal(new TimeSpan(1, 0, 0), binding.SendTimeout);
            Assert.Equal(TransferMode.StreamedResponse, binding.TransferMode);
            Assert.Equal(HostNameComparisonMode.WeakWildcard, binding.HostNameComparisonMode);
            Assert.Equal(Net.AuthenticationSchemes.Ntlm, binding.CreateBindingElements().Find<HttpTransportBindingElement>().AuthenticationScheme);
        }

        void ConfigureTransportBindingElement(HttpTransportBindingElement element)
        {
            element.AuthenticationScheme = Net.AuthenticationSchemes.Ntlm;
        }

        [Theory]
        [PropertyData("BasicClientCredentialTestData")]
        [PropertyData("NonBasicClientCredentialTestData")]
        public void HttpSelfHostConfiguration_ClientCredentialType_PropagatesToHttpBinding(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType)
        {
            // Arrange
            HttpBinding binding = new HttpBinding();
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address)
            {
                ClientCredentialType = clientCredentialType
            };

            // Act
            BindingParameterCollection parameters = config.ConfigureBinding(binding);

            Assert.Equal(clientCredentialType, binding.Security.Transport.ClientCredentialType);
            Assert.Equal(mode, binding.Security.Mode);
        }


        [Theory]
        [PropertyData("NonBasicClientCredentialTestData")]
        public void HttpSelfHostConfiguration_WrongClientCredentialType_WithUsernamePasswordValidator_Throws(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType)
        {
            // Arrange
            GC.KeepAlive(mode); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            HttpBinding binding = new HttpBinding();
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address)
            {
                UserNamePasswordValidator = new CustomUsernamePasswordValidator()
            };

            config.ClientCredentialType = clientCredentialType;

            Assert.Throws<InvalidOperationException>(() =>
                {
                    // Act
                    BindingParameterCollection parameters = config.ConfigureBinding(binding);
                });
        }

        [Theory]
        [PropertyData("BasicClientCredentialTestData")]
        public void HttpSelfHostConfiguration_CorrectClientCredentialType_WithUsernamePasswordValidator_Works(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType)
        {
            // Arrange
            GC.KeepAlive(mode); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            HttpBinding binding = new HttpBinding();
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address)
            {
                UserNamePasswordValidator = new CustomUsernamePasswordValidator()
            };

            config.ClientCredentialType = clientCredentialType;

            // Act
            BindingParameterCollection parameters = config.ConfigureBinding(binding);
        }

        [Theory]
        [PropertyData("NonCertificateClientCredentialTestData")]
        public void HttpSelfHostConfiguration_WrongClientCredentialType_WithX509CertificateValidator_Throws(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType)
        {
            // Arrange
            GC.KeepAlive(mode); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            HttpBinding binding = new HttpBinding();
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address)
            {
                X509CertificateValidator = new Mock<X509CertificateValidator>().Object
            };

            config.ClientCredentialType = clientCredentialType;

            Assert.Throws<InvalidOperationException>(() =>
            {
                // Act
                BindingParameterCollection parameters = config.ConfigureBinding(binding);
            });
        }

        [Theory]
        [PropertyData("CertificateClientCredentialTestData")]
        public void HttpSelfHostConfiguration_CorrectClientCredentialType_WithX509CertificateValidator_Works(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType)
        {
            // Arrange
            GC.KeepAlive(mode); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            HttpBinding binding = new HttpBinding();
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address)
            {
                X509CertificateValidator = new Mock<X509CertificateValidator>().Object
            };

            config.ClientCredentialType = clientCredentialType;

            // Act
            BindingParameterCollection parameters = config.ConfigureBinding(binding);
        }


        [Theory]
        [InlineData("http://localhost", HttpBindingSecurityMode.TransportCredentialOnly)]
        [InlineData("https://localhost", HttpBindingSecurityMode.Transport)]
        public void HttpSelfHostConfiguration_UserNamePasswordValidator_PropagatesToBinding(string address, HttpBindingSecurityMode mode)
        {
            // Arrange
            HttpBinding binding = new HttpBinding();
            UserNamePasswordValidator validator = new Mock<UserNamePasswordValidator>().Object;
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address)
            {
                UserNamePasswordValidator = validator
            };

            // Act
            BindingParameterCollection parameters = config.ConfigureBinding(binding);

            // Assert
            Assert.NotNull(parameters);
            ServiceCredentials serviceCredentials = parameters.Find<ServiceCredentials>();
            Assert.NotNull(serviceCredentials);
            Assert.Equal(HttpClientCredentialType.Basic, binding.Security.Transport.ClientCredentialType);
            Assert.Equal(mode, binding.Security.Mode);
        }

        private static int GetDefaultMaxConcurrentRequests()
        {
            try
            {
                return Math.Max(Environment.ProcessorCount * 100, 100);
            }
            catch
            {
                return 100;
            }
        }

        public class CustomUsernamePasswordValidator : UserNamePasswordValidator
        {
            public override void Validate(string userName, string password)
            {
                if (userName == "username" && password == "password")
                {
                    return;
                }
                else
                {
                    throw new InvalidOperationException();
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/HttpSelfHostResponseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.ServiceModel;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.SelfHost
{
    [Xunit.Collection("PortReserver Collection")] // Avoid conflicts between different PortReserver consumers.
    public class HttpSelfHostResponseTest
    {
        [Fact]
        public async Task Get_Returns_500_And_No_Content_For_Null_HttpResponseMessage_From_MessageHandler()
        {
            using (var selfHostTester = new SelfHostTester())
            {
                // Arrange
                selfHostTester.MessageHandler.ReturnNull = true;
                HttpRequestMessage request = new HttpRequestMessage();
                request.RequestUri = new Uri(Path.Combine(selfHostTester.BaseAddress, "NullResponse/GetNormalResponse"));
                request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                request.Method = HttpMethod.Get;

                // Action
                HttpResponseMessage response = await selfHostTester.HttpClient.SendAsync(request);

                // Assert
                Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                Assert.Equal(0, response.Content.Headers.ContentLength);
            }
        }

        [Fact]
        public async Task Post_Returns_500_And_No_Content_For_Null_HttpResponseMessage_From_MessageHandler()
        {
            using (var selfHostTester = new SelfHostTester())
            {
                // Arrange
                selfHostTester.MessageHandler.ReturnNull = true;
                HttpRequestMessage request = new HttpRequestMessage();
                request.RequestUri = new Uri(Path.Combine(selfHostTester.BaseAddress, "NullResponse/PostNormalResponse"));
                request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                request.Method = HttpMethod.Post;
                request.Content = new ObjectContent<NullResponseCustomer>(new NullResponseCustomer() { Name = "Sue", Age = 39 }, new JsonMediaTypeFormatter());

                // Action
                HttpResponseMessage response = await selfHostTester.HttpClient.SendAsync(request);

                // Assert
                Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                Assert.Equal(0, response.Content.Headers.ContentLength);
            }
        }

        [Fact]
        public async Task Get_Returns_500_And_Error_Content_For_Null_HttpResponseMessage_From_Action()
        {
            using (var selfHostTester = new SelfHostTester())
            {
                // Arrange
                selfHostTester.MessageHandler.ReturnNull = false;
                HttpRequestMessage request = new HttpRequestMessage();
                request.RequestUri = new Uri(Path.Combine(selfHostTester.BaseAddress, "NullResponse/GetNullResponseFromAction"));
                request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                request.Method = HttpMethod.Get;

                // Action
                HttpResponseMessage response = await selfHostTester.HttpClient.SendAsync(request);

                // Assert
                Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                Assert.Contains("\"Message\":\"An error has occurred.\"", await response.Content.ReadAsStringAsync());
            }
        }

        [Fact]
        public async Task Post_Returns_500_And_Error_Content_For_Null_HttpResponseMessage_From_Action()
        {
            using (var selfHostTester = new SelfHostTester())
            {
                // Arrange
                selfHostTester.MessageHandler.ReturnNull = false;
                HttpRequestMessage request = new HttpRequestMessage();
                request.RequestUri = new Uri(Path.Combine(selfHostTester.BaseAddress, "NullResponse/PostNullResponseFromAction"));
                request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                request.Method = HttpMethod.Post;
                request.Content = new ObjectContent<NullResponseCustomer>(new NullResponseCustomer() { Name = "Sue", Age = 39 }, new JsonMediaTypeFormatter());

                // Action
                HttpResponseMessage response = await selfHostTester.HttpClient.SendAsync(request);

                // Assert
                Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                Assert.Contains("\"Message\":\"An error has occurred.\"", await response.Content.ReadAsStringAsync());
            }
        }

        [Fact]
        public async Task Get_Returns_500_And_Error_Content_For_Null_Task_From_Action()
        {
            using (var selfHostTester = new SelfHostTester())
            {
                // Arrange
                selfHostTester.MessageHandler.ReturnNull = false;
                HttpRequestMessage request = new HttpRequestMessage();
                request.RequestUri = new Uri(Path.Combine(selfHostTester.BaseAddress, "NullResponse/GetNullTaskFromAction"));
                request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                request.Method = HttpMethod.Get;

                // Action
                HttpResponseMessage response = await selfHostTester.HttpClient.SendAsync(request);

                // Assert
                Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                Assert.Contains("\"Message\":\"An error has occurred.\"", await response.Content.ReadAsStringAsync());
            }
        }

        [Fact]
        public async Task Post_Returns_500_And_Error_Content_For_Null_Task_From_Action()
        {
            using (var selfHostTester = new SelfHostTester())
            {
                // Arrange
                selfHostTester.MessageHandler.ReturnNull = false;
                HttpRequestMessage request = new HttpRequestMessage();
                request.RequestUri = new Uri(Path.Combine(selfHostTester.BaseAddress, "NullResponse/PostNullTaskFromAction"));
                request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
                request.Method = HttpMethod.Post;
                request.Content = new ObjectContent<NullResponseCustomer>(new NullResponseCustomer() { Name = "Sue", Age = 39 }, new JsonMediaTypeFormatter());

                // Action
                HttpResponseMessage response = await selfHostTester.HttpClient.SendAsync(request);

                // Assert
                Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                Assert.Contains("\"Message\":\"An error has occurred.\"", await response.Content.ReadAsStringAsync());
            }
        }

        private class SelfHostTester : IDisposable
        {
            private HttpSelfHostServer _server;
            private PortReserver _testPort = new PortReserver();

            public string BaseAddress { get; private set; }
            public HttpClient HttpClient { get; private set; }
            public NullResponseMessageHandler MessageHandler { get; private set; }

            public SelfHostTester()
            {
                HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(_testPort.BaseUri);
                BaseAddress = _testPort.BaseUri;

                config.HostNameComparisonMode = HostNameComparisonMode.Exact;
                config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "NullResponse" });

                MessageHandler = new NullResponseMessageHandler();
                config.MessageHandlers.Add(MessageHandler);

                _server = new HttpSelfHostServer(config);
                _server.OpenAsync().Wait();

                HttpClient = new HttpClient();
            }

            public void Dispose()
            {
                _testPort.Dispose();
                HttpClient.Dispose();
                _server.CloseAsync().Wait();
            }
        }
    }

    public class NullResponseController : ApiController
    {
        [HttpGet]
        public NullResponseCustomer GetNormalResponse()
        {
            return new NullResponseCustomer() { Name = "Fred", Age = 39 };
        }

        [HttpPost]
        public NullResponseCustomer PostNormalResponse(NullResponseCustomer customer)
        {
            return customer;
        }

        [HttpGet]
        public HttpResponseMessage GetNullResponseFromAction()
        {
            return null;
        }

        [HttpPost]
        public HttpResponseMessage PostNullResponseFromAction(NullResponseCustomer customer)
        {
            return null;
        }

        [HttpGet]
        public Task<HttpResponseMessage> GetNullTaskFromAction()
        {
            return null;
        }

        [HttpPost]
        public Task<HttpResponseMessage> PostNullTaskFromAction(NullResponseCustomer customer)
        {
            return null;
        }
    }

    public class NullResponseCustomer
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }

    public class NullResponseMessageHandler : DelegatingHandler
    {
        public bool ReturnNull { get; set; }

        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, Threading.CancellationToken cancellationToken)
        {
            Task<HttpResponseMessage> t = base.SendAsync(request, cancellationToken);

            if (!ReturnNull)
            {
                return t;
            }

            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
            tcs.SetResult(null);
            return tcs.Task;
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/HttpSelfHostServerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.ServiceModel;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.SelfHost
{
    [Xunit.Collection("PortReserver Collection")] // Avoid conflicts between different PortReserver consumers.
    public class HttpSelfHostServerTest : IDisposable
    {
        private HttpSelfHostServer server = null;

        public void Dispose()
        {
            if (server != null)
            {
                server.CloseAsync().Wait();
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/EchoString", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/EchoString", TransferMode.Streamed)]
        public async Task SendAsync_Direct_Returns_OK_For_Successful_ObjectContent_Write(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode);
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);
                string responseString = await response.Content.ReadAsStringAsync();

                // Assert
                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal("\"echoString\"", responseString);
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/EchoString", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/EchoString", TransferMode.Streamed)]
        public async Task SendAsync_ServiceModel_Returns_OK_For_Successful_ObjectContent_Write(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange
                server = await CreateServerAsync(port, transferMode);
                bool shouldChunk = transferMode == TransferMode.Streamed;

                // Act
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);
                string responseString = await response.Content.ReadAsStringAsync();
                IEnumerable<string> headerValues = null;
                bool isChunked = response.Headers.TryGetValues("Transfer-Encoding", out headerValues) && headerValues != null &&
                                 headerValues.Any((v) => String.Equals(v, "chunked", StringComparison.OrdinalIgnoreCase));

                // Assert
                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal("\"echoString\"", responseString);
                Assert.Equal(shouldChunk, isChunked);
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/EchoStream", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/EchoStream", TransferMode.Streamed)]
        public async Task SendAsync_Direct_Returns_OK_For_Successful_Stream_Write(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode);
                HttpResponseMessage response = await new HttpClient(server).GetAsync(BaseUri(port, transferMode) + uri);
                string responseString = await response.Content.ReadAsStringAsync();
                IEnumerable<string> headerValues = null;
                bool isChunked = response.Headers.TryGetValues("Transfer-Encoding", out headerValues) && headerValues != null &&
                                 headerValues.Any((v) => String.Equals(v, "chunked", StringComparison.OrdinalIgnoreCase));

                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal("echoStream", responseString);
                Assert.False(isChunked);    // stream never chunk, buffered or streamed
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/EchoStream", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/EchoStream", TransferMode.Streamed)]
        public async Task SendAsync_ServiceModel_Returns_OK_For_Successful_Stream_Write(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode);
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);
                string responseString = await response.Content.ReadAsStringAsync();

                // Assert
                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal("echoStream", responseString);
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/ThrowBeforeTask", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowBeforeTask", TransferMode.Streamed)]
        [InlineData("/SelfHostServerTest/ThrowBeforeWrite", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowBeforeWrite", TransferMode.Streamed)]
        [InlineData("/SelfHostServerTest/ThrowAfterWrite", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowAfterWrite", TransferMode.Streamed)]
        public async Task SendAsync_Direct_Throws_When_ObjectContent_CopyToAsync_Throws(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act & Assert
                server = await CreateServerAsync(port, transferMode);
                await Assert.ThrowsAsync<InvalidOperationException>(
                    () => new HttpClient(server).GetAsync(BaseUri(port, transferMode) + uri));
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/ThrowBeforeTask", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowBeforeTask", TransferMode.Streamed)]
        [InlineData("/SelfHostServerTest/ThrowBeforeWrite", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowBeforeWrite", TransferMode.Streamed)]
        [InlineData("/SelfHostServerTest/ThrowAfterWrite", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowAfterWrite", TransferMode.Streamed)]
        public async Task SendAsync_ServiceModel_Closes_Connection_When_ObjectContent_CopyToAsync_Throws(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange
                server = await CreateServerAsync(port, transferMode);
                Task<HttpResponseMessage> task = new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);

                // Act & Assert
                await Assert.ThrowsAsync<HttpRequestException>(() => task);
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/ThrowBeforeWriteStream", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowBeforeWriteStream", TransferMode.Streamed)]
        [InlineData("/SelfHostServerTest/ThrowAfterWriteStream", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowAfterWriteStream", TransferMode.Streamed)]
        public async Task SendAsync_Direct_Throws_When_StreamContent_Throws(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act & Assert
                server = await CreateServerAsync(port, transferMode);
                await Assert.ThrowsAsync<InvalidOperationException>(
                    () => new HttpClient(server).GetAsync(BaseUri(port, transferMode) + uri));
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/ThrowBeforeWriteStream", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowBeforeWriteStream", TransferMode.Streamed)]
        [InlineData("/SelfHostServerTest/ThrowAfterWriteStream", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/ThrowAfterWriteStream", TransferMode.Streamed)]
        public async Task SendAsync_ServiceModel_Throws_When_StreamContent_Throws(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange
                server = await CreateServerAsync(port, transferMode);
                Task task = new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);

                // Act & Assert
                await Assert.ThrowsAsync<HttpRequestException>(() => task);
            }
        }

        [Fact]
        public async Task SendAsync_ServiceModel_AddsSelfHostHttpRequestContext()
        {
            // Arrange
            using (PortReserver port = new PortReserver())
            {
                string baseUri = port.BaseUri;

                HttpRequestContext context = null;
                Uri via = null;

                Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = (r, c) =>
                {
                    if (r != null)
                    {
                        context = r.GetRequestContext();
                    }

                    SelfHostHttpRequestContext typedContext = context as SelfHostHttpRequestContext;

                    if (typedContext != null)
                    {
                        via = typedContext.RequestContext.RequestMessage.Properties.Via;
                    }

                    return Task.FromResult(new HttpResponseMessage());
                };

                using (HttpSelfHostConfiguration expectedConfiguration = new HttpSelfHostConfiguration(baseUri))
                {
                    expectedConfiguration.HostNameComparisonMode = HostNameComparisonMode.Exact;

                    using (HttpMessageHandler dispatcher = new LambdaHttpMessageHandler(sendAsync))
                    using (HttpSelfHostServer server = new HttpSelfHostServer(expectedConfiguration, dispatcher))
                    using (HttpClient client = new HttpClient())
                    using (HttpRequestMessage expectedRequest = new HttpRequestMessage(HttpMethod.Get, baseUri))
                    {
                        await server.OpenAsync();

                        // Act
                        using (HttpResponseMessage ignore = await client.SendAsync(expectedRequest))
                        {
                            // Assert
                            SelfHostHttpRequestContext typedContext = (SelfHostHttpRequestContext)context;
                            Assert.Equal(expectedRequest.RequestUri, via);
                            Assert.Same(expectedConfiguration, context.Configuration);
                            Assert.Equal(expectedRequest.RequestUri, typedContext.Request.RequestUri);

                            await server.CloseAsync();
                        }
                    }
                }
            }
        }

        [Theory]
        [InlineData("/SelfHostServerTest/EchoString", TransferMode.Buffered)]
        [InlineData("/SelfHostServerTest/EchoString", TransferMode.Streamed)]
        public async Task Get_Returns_Hard404_If_IgnoreRoute(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode, ignoreRoute: true);
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);

                // Assert
                Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                Assert.False(response.RequestMessage.Properties.ContainsKey(HttpPropertyKeys.NoRouteMatched));
            }
        }

        [Theory]
        [InlineData("/a/b/c/d/e", TransferMode.Buffered)]
        [InlineData("/EchoString?f=12", TransferMode.Streamed)]
        public async Task Get_Returns_Hard404_If_IgnoreRouteDoesNotMatch(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode, ignoreRoute: true);
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);

                // Assert
                Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                Assert.False(response.RequestMessage.Properties.ContainsKey(HttpPropertyKeys.NoRouteMatched));
            }
        }

        [Theory]
        [InlineData("/constraint/values/10", TransferMode.Buffered)]
        [InlineData("/constraint/values/15", TransferMode.Buffered)]
        [InlineData("/constraint/values/20", TransferMode.Buffered)]
        public async Task Get_Returns_Hard404_If_IgnoreRoute_WithConstraints_ConstraintsMatched(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode, ignoreRoute: true);
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);

                // Assert
                Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                Assert.False(response.RequestMessage.Properties.ContainsKey(HttpPropertyKeys.NoRouteMatched));
            }
        }

        [Theory]
        [InlineData("/constraint/values/40", TransferMode.Buffered)]
        [InlineData("/constraint/values/50", TransferMode.Buffered)]
        [InlineData("/constraint/values/65", TransferMode.Buffered)]
        public async Task Get_Returns_Value_If_IgnoreRoute_WithConstraints_ConstraintsNotMatched(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode, ignoreRoute: true);
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);
                string responseString = await response.Content.ReadAsStringAsync();

                // Assert
                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal(String.Concat("/constraint/values/", responseString), uri);
            }
        }

        [Theory]
        [InlineData("/other/SelfHostServerTest/EchoString", TransferMode.Buffered)]
        [InlineData("/other/SelfHostServerTest/EchoString", TransferMode.Streamed)]
        public async Task Get_Returns_Success_If_OtherRouteMatched(string uri, TransferMode transferMode)
        {
            using (var port = new PortReserver())
            {
                // Arrange & Act
                server = await CreateServerAsync(port, transferMode, ignoreRoute: true);
                HttpResponseMessage response = await new HttpClient().GetAsync(BaseUri(port, transferMode) + uri);
                string responseString = await response.Content.ReadAsStringAsync();

                // Assert
                Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                Assert.Equal("\"echoString\"", responseString);
            }
        }

        internal class ThrowsBeforeTaskObjectContent : ObjectContent
        {
            public ThrowsBeforeTaskObjectContent()
                : base(typeof(string), "testContent", new JsonMediaTypeFormatter())
            {
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                throw new InvalidOperationException("ThrowBeforeTask");
            }
        }

        internal class ThrowBeforeWriteObjectContent : ObjectContent
        {
            public ThrowBeforeWriteObjectContent()
                : base(typeof(string), "testContent", new JsonMediaTypeFormatter())
            {
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return Task.Factory.StartNew(() =>
                        {
                            throw new InvalidOperationException("ThrowBeforeWrite");
                        });

            }
        }

        internal class ThrowAfterWriteObjectContent : ObjectContent
        {
            public ThrowAfterWriteObjectContent()
                : base(typeof(string), "testContent", new JsonMediaTypeFormatter())
            {
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return Task.Factory.StartNew(() =>
                                                 {
                                                     byte[] buffer =
                                                         Encoding.UTF8.GetBytes("ThrowAfterWrite");
                                                     stream.Write(buffer, 0, buffer.Length);
                                                     throw new InvalidOperationException("ThrowAfterWrite");
                                                 });
            }
        }

        internal class ThrowBeforeWriteStream : StreamContent
        {
            public ThrowBeforeWriteStream()
                : base(new MemoryStream(Encoding.UTF8.GetBytes("ThrowBeforeWriteStream")))
            {
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                throw new InvalidOperationException("ThrowBeforeWriteStream");
            }
        }

        internal class ThrowAfterWriteStream : StreamContent
        {
            public ThrowAfterWriteStream()
                : base(new MemoryStream(Encoding.UTF8.GetBytes("ThrowAfterWriteStream")))
            {
            }

            protected override async Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                await base.SerializeToStreamAsync(stream, context);
                throw new InvalidOperationException("ThrowAfterWriteStream");
            }
        }

        private static async Task<HttpSelfHostServer> CreateServerAsync(PortReserver port, TransferMode transferMode, bool ignoreRoute = false)
        {
            HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(BaseUri(port, transferMode));
            config.HostNameComparisonMode = HostNameComparisonMode.Exact;
            if (ignoreRoute)
            {
                config.Routes.IgnoreRoute("Ignore", "{controller}/{action}");
                config.Routes.IgnoreRoute("IgnoreWithConstraints", "constraint/values/{id}", constraints: new { constraint = new CustomConstraint() });
            }
            config.Routes.MapHttpRoute("Default", "{controller}/{action}");
            config.Routes.MapHttpRoute("Other", "other/{controller}/{action}");
            config.TransferMode = transferMode;
            config.MapHttpAttributeRoutes();

            HttpSelfHostServer server = new HttpSelfHostServer(config);
            await server.OpenAsync();
            return server;
        }

        public class CustomConstraint : IHttpRouteConstraint
        {
            public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName,
                IDictionary<string, object> values, HttpRouteDirection routeDirection)
            {
                long id;
                if (values.ContainsKey("id")
                    && Int64.TryParse(values["id"].ToString(), out id)
                    && (id == 10 || id == 15 || id == 20))
                {
                    return true;
                }

                return false;
            }
        }

        private static string BaseUri(PortReserver port, TransferMode transferMode)
        {
            return transferMode == TransferMode.Streamed
                ? port.BaseUri + "stream"
                : port.BaseUri;
        }

        private class LambdaHttpMessageHandler : HttpMessageHandler
        {
            private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _sendAsync;

            public LambdaHttpMessageHandler(
                Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync)
            {
                _sendAsync = sendAsync;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                return _sendAsync.Invoke(request, cancellationToken);
            }
        }
    }

    public class SelfHostServerTestController : ApiController
    {
        [HttpGet]
        public string EchoString()
        {
            return "echoString";
        }

        [HttpGet]
        public HttpResponseMessage EchoStream()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
                       {
                           Content = new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes("echoStream")))
                       };
        }

        [HttpGet]
        public HttpResponseMessage ThrowBeforeTask()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
                {
                    RequestMessage = Request,
                    Content = new HttpSelfHostServerTest.ThrowsBeforeTaskObjectContent()
                };
        }

        [HttpGet]
        public HttpResponseMessage ThrowBeforeWrite()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                RequestMessage = Request,
                Content = new HttpSelfHostServerTest.ThrowBeforeWriteObjectContent()
            };
        }

        [HttpGet]
        public HttpResponseMessage ThrowAfterWrite()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                RequestMessage = Request,
                Content = new HttpSelfHostServerTest.ThrowAfterWriteObjectContent()
            };
        }

        [HttpGet]
        public HttpResponseMessage ThrowBeforeWriteStream()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                RequestMessage = Request,
                Content = new HttpSelfHostServerTest.ThrowBeforeWriteStream()
            };
        }

        [HttpGet]
        public HttpResponseMessage ThrowAfterWriteStream()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                RequestMessage = Request,
                Content = new HttpSelfHostServerTest.ThrowAfterWriteStream()
            };
        }
    }

    [RoutePrefix("constraint")]
    public class IgnoreRouteWithConstraintsTestController : ApiController
    {
        [Route("values/{id:int}")]
        public int Get(int id)
        {
            return id;
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/MaxHttpCollectionKeyTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Web.Http.SelfHost
{
    public class MaxHttpCollectionKeyTests
    {
        private HttpServer server = null;
        private string baseAddress = null;
        private HttpClient httpClient = null;

        public MaxHttpCollectionKeyTests()
        {
            this.SetupHost();
        }

        private void SetupHost()
        {
            baseAddress = String.Format("http://localhost/");

            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "MaxHttpCollectionKeyType" });

            server = new HttpServer(config);

            httpClient = new HttpClient(server);
        }

        [Theory]
        [InlineData("PostCustomer")]
        [InlineData("PostFormData")]
        public async Task PostManyKeysInFormUrlEncodedThrows(string actionName)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "MaxHttpCollectionKeyType/" + actionName));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;
            request.Content = new StringContent(GenerateHttpCollectionKeyInput(100), UTF8Encoding.UTF8, "application/x-www-form-urlencoded");
            MediaTypeFormatter.MaxHttpCollectionKeys = 99;

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            string expectedResponseValue = @"The number of keys in a NameValueCollection has exceeded the limit of '99'. You can adjust it by modifying the MaxHttpCollectionKeys property on the 'System.Net.Http.Formatting.MediaTypeFormatter' class.";
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        [Theory]
        [InlineData("PostCustomer")]
        [InlineData("PostFormData")]
        public async Task PostNotTooManyKeysInFormUrlEncodedWorks(string actionName)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "MaxHttpCollectionKeyType/" + actionName));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));
            request.Method = HttpMethod.Post;
            request.Content = new StringContent(GenerateHttpCollectionKeyInput(100), UTF8Encoding.UTF8, "application/x-www-form-urlencoded");
            MediaTypeFormatter.MaxHttpCollectionKeys = 1000;

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            string expectedResponseValue = @"<string xmlns=""http://schemas.microsoft.com/2003/10/Serialization/"">success from " + actionName + "</string>";
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Equal(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        [Theory]
        [InlineData("PostCustomerFromUri")]
        [InlineData("GetWithQueryable")]
        public async Task PostManyKeysInUriThrows(string actionName)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "MaxHttpCollectionKeyType/" + actionName + "/?" + GenerateHttpCollectionKeyInput(100)));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));

            if (actionName.StartsWith("Post"))
            {
                request.Method = HttpMethod.Post;
                request.Content = new StringContent("", UTF8Encoding.UTF8, "application/x-www-form-urlencoded");
            }
            else
            {
                request.Method = HttpMethod.Get;
            }

            MediaTypeFormatter.MaxHttpCollectionKeys = 99;

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
        }

        [Theory]
        [InlineData("PostCustomerFromUri")]
        [InlineData("GetWithQueryable")]
        public async Task PostNotTooManyKeysInUriWorks(string actionName)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(Path.Combine(baseAddress, "MaxHttpCollectionKeyType/" + actionName + "/?" + GenerateHttpCollectionKeyInput(100)));
            request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/xml"));

            if (actionName.StartsWith("Post"))
            {
                request.Method = HttpMethod.Post;
                request.Content = new StringContent("", UTF8Encoding.UTF8, "application/x-www-form-urlencoded");
            }
            else
            {
                request.Method = HttpMethod.Get;
            }

            MediaTypeFormatter.MaxHttpCollectionKeys = 1000;

            // Action
            HttpResponseMessage response = await httpClient.SendAsync(request);

            // Assert
            string expectedResponseValue = @"success from " + actionName;
            Assert.NotNull(response.Content);
            Assert.NotNull(response.Content.Headers.ContentType);
            Assert.Equal("application/xml", response.Content.Headers.ContentType.MediaType);
            Assert.Contains(expectedResponseValue, await response.Content.ReadAsStringAsync());
        }

        private static string GenerateHttpCollectionKeyInput(int num)
        {
            StringBuilder sb = new StringBuilder("a=0");

            for (int i = 0; i < num; i++)
            {
                sb.Append("&");
                sb.Append(i.ToString());
                sb.Append("=0");
            }

            return sb.ToString();
        }
    }

    public class MaxHttpCollectionKeyTypeController : ApiController
    {
        // Post strongly typed Customer
        public string PostCustomer(Customer a)
        {
            if (!ModelState.IsValid)
            {
                HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.BadRequest);
                ModelBinding.ModelState value = null;
                ModelState.TryGetValue("a", out value);
                response.Content = new StringContent(value.Errors[0].Exception.Message);
                throw new HttpResponseException(response);
            }

            return "success from PostCustomer";
        }

        // Post form data
        public string PostFormData(FormDataCollection a)
        {
            if (!ModelState.IsValid)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
            }

            try
            {
                NameValueCollection collection = a.ReadAsNameValueCollection();
            }
            catch (InvalidOperationException ex)
            {
                HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.BadRequest);
                response.Content = new StringContent(ex.Message);
                throw new HttpResponseException(response);
            }

            return "success from PostFormData";
        }

        public string PostCustomerFromUri([FromUri]Customer a)
        {
            if (!ModelState.IsValid)
            {
                HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.BadRequest);
                ModelBinding.ModelState value = null;
                ModelState.TryGetValue("a", out value);
                response.Content = new StringContent(value.Errors[0].ErrorMessage);
                throw new HttpResponseException(response);
            }

            return "success from PostCustomerFromUri";
        }

        public IQueryable<string> GetWithQueryable()
        {
            return new List<string>() { "success from GetWithQueryable" }.AsQueryable();
        }

        public string PostJToken(JToken token)
        {
            if (!ModelState.IsValid)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest));
            }

            return "success from PostJToken";
        }
    }

    public class Customer
    {
        public string Name { get; set; }
        public int Age { get; set; }

        public override string ToString()
        {
            return "ModelBindingItem(" + Name + "," + Age + ")";
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/SelfHostHttpRequestContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics.Contracts;
using System.IdentityModel.Claims;
using System.IdentityModel.Policy;
using System.Net;
using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.ServiceModel;
using System.ServiceModel.Channels;
using System.ServiceModel.Security;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.SelfHost
{
    public class SelfHostHttpRequestContextTests
    {
        [Fact]
        public void RequestContextGet_ReturnsProvidedInstance()
        {
            // Arrange
            using (RequestContext expectedServiceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                SelfHostHttpRequestContext context = CreateProductUnderTest(expectedServiceModelContext, configuration,
                    request);

                // Act
                RequestContext serviceModelContext = context.RequestContext;

                // Assert
                Assert.Same(expectedServiceModelContext, serviceModelContext);
            }
        }

        [Fact]
        public void RequestGet_ReturnsProvidedInstance()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                SelfHostHttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration,
                    expectedRequest);

                // Act
                HttpRequestMessage request = context.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsNull_ByDefault()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsContextClientCertificate()
        {
            // Arrange
            X509Certificate2 expectedCertificate = CreateCertificate();

            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                request.Properties[HttpSelfHostServer.SecurityKey] = CreateSecurityProperty(expectedCertificate);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                // WCF clones the certificate instance, so NotNull is the best we can check without creating a real
                // certificate.
                Assert.NotNull(certificate);
            }
        }

        [Fact]
        public void ClientCertificateSet_UpdatesClientCertificate()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                X509Certificate2 expectedCertificate = CreateCertificate();

                // Act
                context.ClientCertificate = expectedCertificate;

                // Assert
                X509Certificate2 certificate = context.ClientCertificate;
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void ClientCertificateSet_UpdatesClientCertificate_WhenNull()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                request.Properties[HttpSelfHostServer.SecurityKey] = CreateSecurityProperty(CreateCertificate());

                // Act
                context.ClientCertificate = null;

                // Assert
                X509Certificate2 certificate = context.ClientCertificate;
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ConfigurationGet_ReturnsProvidedInstance()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, expectedConfiguration,
                    request);

                // Act
                HttpConfiguration configuration = context.Configuration;

                // Assert
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void ConfigurationSet_UpdatesConfiguration()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration initialConfiguration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, initialConfiguration,
                    request);

                // Act
                context.Configuration = expectedConfiguration;

                // Assert
                HttpConfiguration configuration = context.Configuration;
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void IncludeErrorDetailGet_ReturnsFalse_ByDefault()
        {
            // Arrange
            using (Message message = CreateMessage())
            using (RequestContext serviceModelContext = CreateStubServiceModelContext(message))
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                context.Configuration = null;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.False(includeErrorDetail);
            }
        }

        [Fact]
        public void IncludeErrorDetailGet_ReturnsTrue_WhenUnconfiguredAndIsLocal()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                context.Configuration = null;
                context.IsLocal = true;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.True(includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true, IncludeErrorDetailPolicy.Always, true)]
        [InlineData(true, IncludeErrorDetailPolicy.Always, false)]
        [InlineData(false, IncludeErrorDetailPolicy.Never, true)]
        [InlineData(false, IncludeErrorDetailPolicy.Never, false)]
        [InlineData(true, IncludeErrorDetailPolicy.LocalOnly, true)]
        [InlineData(false, IncludeErrorDetailPolicy.LocalOnly, false)]
        [InlineData(true, IncludeErrorDetailPolicy.Default, true)]
        [InlineData(false, IncludeErrorDetailPolicy.Default, false)]
        public void IncludeErrorDetailGet_ForPolicy(bool expected, IncludeErrorDetailPolicy policy, bool isLocal)
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                context.IsLocal = isLocal;
                configuration.IncludeErrorDetailPolicy = policy;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expected, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailSet_UpdatesIncludeErrorDetail(bool expectedIncludeErrorDetail)
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                context.IncludeErrorDetail = expectedIncludeErrorDetail;

                // Assert
                bool includeErrorDetail = context.IncludeErrorDetail;
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true, IncludeErrorDetailPolicy.Never)]
        [InlineData(false, IncludeErrorDetailPolicy.Always)]
        public void IncludeErrorDetailSet_OverridesPolicy(bool expected, IncludeErrorDetailPolicy policy)
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                configuration.IncludeErrorDetailPolicy = policy;

                // Act
                context.IncludeErrorDetail = expected;

                // Assert
                bool includeErrorDetail = context.IncludeErrorDetail;
                Assert.Equal(expected, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsFirstObservedValue(bool expectedIncludeErrorDetail)
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                context.IsLocal = expectedIncludeErrorDetail;
                bool ignore = context.IncludeErrorDetail;
                context.IsLocal = !expectedIncludeErrorDetail;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Fact]
        public void IsLocalGet_ReturnsFalse_ByDefault()
        {
            // Arrange
            using (Message message = CreateMessage())
            using (RequestContext serviceModelContext = CreateStubServiceModelContext(message))
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.False(isLocal);
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public void IsLocal_ReturnsContextIsLocalValue(bool expectedIsLocal)
        {
            // Arrange
            using (Message message = CreateMessage(expectedIsLocal))
            using (RequestContext serviceModelContext = CreateStubServiceModelContext(message))
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalSet_UpdatesIsLocal(bool expectedIsLocal)
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                context.IsLocal = expectedIsLocal;

                // Assert
                bool isLocal = context.IsLocal;
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public void IsLocalGet_ReturnsFirstObservedValue(bool expectedIsLocal)
        {
            // Arrange
            using (Message message = CreateMessage(expectedIsLocal))
            using (RequestContext serviceModelContext = CreateStubServiceModelContext(message))
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                bool ignore = context.IsLocal;
                SetIsLocal(message, !expectedIsLocal);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalGet_ReturnsThreadCurrentPrincipal()
        {
            // Arrange
            IPrincipal expectedPrincipal = CreateDummyPrincipal();

            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                Thread.CurrentPrincipal = expectedPrincipal;

                // Act
                IPrincipal principal = context.Principal;

                // Assert
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalSet_UpdatesThreadCurrentPrincipal()
        {
            // Arrange
            IPrincipal expectedPrincipal = CreateDummyPrincipal();

            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                context.Principal = expectedPrincipal;

                // Assert
                IPrincipal principal = Thread.CurrentPrincipal;
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        public void UrlGet_ReturnsUrlHelperForRequest()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, expectedRequest);

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.NotNull(url);
                Assert.Same(expectedRequest, url.Request);
            }
        }

        [Fact]
        public void UrlGet_ReturnsSameInstance()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                UrlHelper firstUrl = context.Url;

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.Same(firstUrl, url);
            }
        }

        [Fact]
        public void UrlSet_UpdatesUrl()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                UrlHelper expectedUrl = CreateDummyUrlHelper();

                // Act
                context.Url = expectedUrl;

                // Assert
                UrlHelper url = context.Url;
                Assert.Same(expectedUrl, url);
            }
        }

        [Fact]
        public void UrlSet_UpdatesUrl_WhenNull()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                context.Url = null;

                // Assert
                UrlHelper url = context.Url;
                Assert.Null(url);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsSlash_ByDefault()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal("/", virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsSlash_WhenConfigurationIsNull()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                context.Configuration = null;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal("/", virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsConfigurationVirtualPathRoot()
        {
            // Arrange
            string expectedVirtualPathRoot = "/foo";

            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration(expectedVirtualPathRoot))
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Theory]
        [InlineData("a b")]
        [InlineData("/a b")]
        [InlineData("/a%20b")]
        public void VirtualPathRootGet_ReturnsUnescapedConfigurationVirtualPathRoot(string configurationVirtualPathRoot)
        {
            // Arrange
            var expectedVirtualPathRoot = "/a b";
            using (var serviceModelContext = CreateStubServiceModelContext())
            using (var configuration = CreateConfiguration(configurationVirtualPathRoot))
            using (var request = CreateRequest())
            {
                var context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                var virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesVirtualPathRoot()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                string expectedVirtualPathRoot = "foo";

                // Act
                context.VirtualPathRoot = expectedVirtualPathRoot;

                // Assert
                string virtualPathRoot = context.VirtualPathRoot;
                Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesVirtualPathRoot_WhenNull()
        {
            // Arrange
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);

                // Act
                context.VirtualPathRoot = null;

                // Assert
                string virtualPathRoot = context.VirtualPathRoot;
                Assert.Null(virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsFirstObservedConfigurationVirtualPathRoot()
        {
            // Arrange
            string expectedVirtualPathRoot = "/expected";
            using (RequestContext serviceModelContext = CreateStubServiceModelContext())
            using (HttpConfiguration configuration = CreateConfiguration(expectedVirtualPathRoot))
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration otherConfiguration = CreateConfiguration("/other"))
            {
                HttpRequestContext context = CreateProductUnderTest(serviceModelContext, configuration, request);
                string ignore = context.VirtualPathRoot;
                context.Configuration = otherConfiguration;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        private static X509Certificate2 CreateCertificate()
        {
            return new X509Certificate2();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static HttpConfiguration CreateConfiguration(string virtualPathRoot)
        {
            return new HttpConfiguration(new HttpRouteCollection(virtualPathRoot));
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static UrlHelper CreateDummyUrlHelper()
        {
            return new Mock<UrlHelper>(MockBehavior.Strict).Object;
        }

        private static Message CreateMessage()
        {
            return Message.CreateMessage(MessageVersion.None, null);
        }

        private static Message CreateMessage(bool isLocal)
        {
            Message message = CreateMessage();
            SetIsLocal(message, isLocal);
            return message;
        }

        private static SelfHostHttpRequestContext CreateProductUnderTest(RequestContext requestContext,
            HttpConfiguration configuration, HttpRequestMessage request)
        {
            return new SelfHostHttpRequestContext(requestContext, configuration, request);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static SecurityMessageProperty CreateSecurityProperty(X509Certificate2 certificate)
        {
            AuthorizationContext authorizationContext = new X509AuthorizationContext(certificate);
            ServiceSecurityContext securityContext = new ServiceSecurityContext(authorizationContext);
            SecurityMessageProperty securityProperty = new SecurityMessageProperty();
            securityProperty.ServiceSecurityContext = securityContext;
            return securityProperty;
        }

        private static Mock<RequestContext> CreateServiceModelContextMock()
        {
            Mock<RequestContext> mock = new Mock<RequestContext>(MockBehavior.Strict);
            mock.As<IDisposable>().Setup(c => c.Dispose());
            return mock;
        }

        private static RequestContext CreateStubServiceModelContext()
        {
            return CreateServiceModelContextMock().Object;
        }

        private static RequestContext CreateStubServiceModelContext(Message requestMessage)
        {
            Mock<RequestContext> mock = CreateServiceModelContextMock();
            mock.Setup(c => c.RequestMessage).Returns(requestMessage);
            return mock.Object;
        }

        private static void SetIsLocal(Message message, bool value)
        {
            IPAddress address = value ? IPAddress.Loopback : IPAddress.None;
            message.Properties[RemoteEndpointMessageProperty.Name] = new RemoteEndpointMessageProperty(
                address.ToString(), 0);
        }

        private class X509AuthorizationContext : AuthorizationContext
        {
            private readonly ReadOnlyCollection<ClaimSet> _claimSets;

            public X509AuthorizationContext(X509Certificate2 certificate)
            {
                Contract.Assert(certificate != null);
                _claimSets = new ReadOnlyCollection<ClaimSet>(new List<ClaimSet>(new ClaimSet[] {
                    new X509CertificateClaimSet(certificate) }));
            }

            public override ReadOnlyCollection<ClaimSet> ClaimSets
            {
                get { return _claimSets; }
            }

            public override DateTime ExpirationTime
            {
                get { throw new NotImplementedException(); }
            }

            public override string Id
            {
                get { throw new NotImplementedException(); }
            }

            public override IDictionary<string, object> Properties
            {
                get { throw new NotImplementedException(); }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/ServiceModel/HostNameComparisonModeHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;
using System.Web.Http.SelfHost.ServiceModel;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class HostNameComparisonModeHelperTest : EnumHelperTestBase<HostNameComparisonMode>
    {
        public HostNameComparisonModeHelperTest()
            : base(HostNameComparisonModeHelper.IsDefined, HostNameComparisonModeHelper.Validate, (HostNameComparisonMode)999)
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/ServiceModel/TransferModeHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ServiceModel;
using System.Web.Http.SelfHost.ServiceModel;
using Microsoft.TestCommon;

namespace System.Net.Http.Formatting
{
    public class TransferModeHelperTest : EnumHelperTestBase<TransferMode>
    {
        public TransferModeHelperTest()
            : base(TransferModeHelper.IsDefined, TransferModeHelper.Validate, (TransferMode)999)
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.SelfHost.Test/System.Web.Http.SelfHost.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{7F29EE87-6A63-43C6-B7FF-74DD06815830}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.SelfHost</RootNamespace>
    <AssemblyName>System.Web.Http.SelfHost.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.IdentityModel" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.ServiceModel" />
    <Reference Include="System.Web" />
    <Reference Include="System.XML" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\HttpMethodHelperTest.cs">
      <Link>Common\HttpMethodHelperTest.cs</Link>
    </Compile>
    <Compile Include="Authentication\BasicOverHttpTest.cs" />
    <Compile Include="Authentication\CustomMessageHandler.cs" />
    <Compile Include="Authentication\CustomUsernamePasswordValidator.cs" />
    <Compile Include="Authentication\RequireAdminAttribute.cs" />
    <Compile Include="Authentication\SampleController.cs" />
    <Compile Include="Channels\HttpBindingSecurityModeHelperTest.cs" />
    <Compile Include="DeeplyNestedTypeTests.cs" />
    <Compile Include="HttpSelfHostConfigurationTest.cs" />
    <Compile Include="HttpSelfHostServerTest.cs" />
    <Compile Include="MaxHttpCollectionKeyTests.cs" />
    <Compile Include="HttpSelfHostResponseTest.cs" />
    <Compile Include="SelfHostHttpRequestContextTests.cs" />
    <Compile Include="ServiceModel\TransferModeHelperTest.cs" />
    <Compile Include="ServiceModel\HostNameComparisonModeHelperTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.SelfHost\System.Web.Http.SelfHost.csproj">
      <Project>{66492E69-CE4C-4FB1-9B1F-88DEE09D06F1}</Project>
      <Name>System.Web.Http.SelfHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3D3FFD8A-624D-4E9B-954B-E1C105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Http.SelfHost.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.SignalR.Test/HubControllerBaseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Hubs;
using Microsoft.AspNet.SignalR.Infrastructure;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HubControllerBaseTest
    {
        [Fact]
        public void Clients_ThrowsInvalidOperationForNullHubContext()
        {
            Assert.Throws<InvalidOperationException>(
                () => new HubContextController(null).Clients,
                "No hub context could be found for the HubController of type 'HubContextController'.");
        }

        [Fact]
        public void Clients_ReturnsHubContextsClients()
        {
            Mock<IHubContext> mockContext = new Mock<IHubContext>();
            IHubConnectionContext clients = new HubConnectionContext();
            mockContext.Setup(mock => mock.Clients).Returns(clients);
            var controller = new HubContextController(mockContext.Object);

            Assert.Same(clients, controller.Clients);
        }

        [Fact]
        public void Groups_ThrowsInvalidOperationForNullHubContext()
        {
            Assert.Throws<InvalidOperationException>(
                () => new HubContextController(null).Groups,
                "No hub context could be found for the HubController of type 'HubContextController'.");
        }

        [Fact]
        public void Groups_ReturnsHubContextsClients()
        {
            Mock<IHubContext> mockContext = new Mock<IHubContext>();
            IGroupManager groups = new Mock<IGroupManager>().Object;
            mockContext.Setup(mock => mock.Groups).Returns(groups);
            var controller = new HubContextController(mockContext.Object);

            Assert.Same(groups, controller.Groups);
        }

        [Fact]
        public void ConnectionManager_ReturnsGlobalConnectionManager_IfConfigurationIsNull()
        {
            HubContextController controller = new HubContextController();

            Assert.Same(GlobalHost.ConnectionManager, controller.GetConnectionManager());
        }

        [Fact]
        public void ConnectionManager_ReturnsGlobalConnectionManager_IfCannotResolveIConnectionManager()
        {
            HubContextController controller = new HubContextController();
            controller.Configuration = new HttpConfiguration();
            Mock<System.Web.Http.Dependencies.IDependencyResolver> mockDependencyResolver = new Mock<Dependencies.IDependencyResolver>();
            mockDependencyResolver.Setup(mock => mock.GetService(typeof(IConnectionManager))).Returns(null);
            controller.Configuration.DependencyResolver = mockDependencyResolver.Object;

            Assert.Same(GlobalHost.ConnectionManager, controller.GetConnectionManager());
        }

        [Fact]
        public void ConnectionManager_ReturnsConnectionManagerFromDependencyResolver_IfFound()
        {
            HubContextController controller = new HubContextController();
            controller.Configuration = new HttpConfiguration();
            IConnectionManager connectionManager = new Mock<IConnectionManager>().Object;
            Mock<System.Web.Http.Dependencies.IDependencyResolver> mockDependencyResolver = new Mock<Dependencies.IDependencyResolver>();
            mockDependencyResolver.Setup(mock => mock.GetService(typeof(IConnectionManager))).Returns(connectionManager);
            controller.Configuration.DependencyResolver = mockDependencyResolver.Object;

            Assert.Same(connectionManager, controller.GetConnectionManager());
        }

        public class HubContextController : HubControllerBase
        {
            IHubContext _hubContext;

            public HubContextController(IHubContext hubContext = null)
            {
                _hubContext = hubContext;
            }

            protected override IHubContext HubContext
            {
                get
                {
                    return _hubContext;
                }
            }

            public IConnectionManager GetConnectionManager()
            {
                return ConnectionManager;
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.SignalR.Test/HubControllerOfTHubTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http;
using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Infrastructure;
using Microsoft.TestCommon;
using Moq;

public class HubControllerOfTTest
{
    [Fact]
    public void HubContext_ReturnsContextResolvedFromConnectionManager()
    {
        DefaultContextController controller = new DefaultContextController();
        controller.Configuration = new HttpConfiguration();
        Mock<IConnectionManager> mockConnectionManager = new Mock<IConnectionManager>();
        IHubContext context = new Mock<IHubContext>().Object;
        mockConnectionManager.Setup(mock => mock.GetHubContext<MyHub>()).Returns(context);
        Mock<System.Web.Http.Dependencies.IDependencyResolver> mockDependencyResolver = new Mock<System.Web.Http.Dependencies.IDependencyResolver>();
        mockDependencyResolver.Setup(mock => mock.GetService(typeof(IConnectionManager))).Returns(mockConnectionManager.Object);
        controller.Configuration.DependencyResolver = mockDependencyResolver.Object;

        Assert.Same(context, controller.GetHubContext());
    }

    public class DefaultContextController : HubController<MyHub>
    {
        public IHubContext GetHubContext()
        {
            return HubContext;
        }

        public IConnectionManager GetConnectionManager()
        {
            return ConnectionManager;
        }
    }

    public class MyHub : Hub
    {
    }
}

================================================
FILE: test/System.Web.Http.SignalR.Test/HubControllerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.AspNet.SignalR;
using Microsoft.AspNet.SignalR.Infrastructure;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HubControllerTest
    {
        [Fact]
        public void Constructor_ThrowsArgumentNullForNullHubName()
        {
            Assert.ThrowsArgumentNull(() => new NullHubNameController(), "hubName");
        }

        [Fact]
        public void HubContext_ReturnsContextResolvedFromConnectionManager()
        {
            DefaultContextController controller = new DefaultContextController("hub");
            controller.Configuration = new HttpConfiguration();
            Mock<IConnectionManager> mockConnectionManager = new Mock<IConnectionManager>();
            IHubContext context = new Mock<IHubContext>().Object;
            mockConnectionManager.Setup(mock => mock.GetHubContext("hub")).Returns(context);
            Mock<System.Web.Http.Dependencies.IDependencyResolver> mockDependencyResolver = new Mock<Dependencies.IDependencyResolver>();
            mockDependencyResolver.Setup(mock => mock.GetService(typeof(IConnectionManager))).Returns(mockConnectionManager.Object);
            controller.Configuration.DependencyResolver = mockDependencyResolver.Object;

            Assert.Same(context, controller.GetHubContext());
        }

        public class NullHubNameController : HubController
        {
            public NullHubNameController() : base(null)
            {
            }
        }

        public class DefaultContextController : HubController
        {
            public DefaultContextController(string hubName) : base(hubName)
            {
            }

            public IHubContext GetHubContext()
            {
                return HubContext;
            }

            public IConnectionManager GetConnectionManager()
            {
                return ConnectionManager;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.SignalR.Test/System.Web.Http.SignalR.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{E22245AF-D5E1-46F6-B443-C886983EC50C}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>System.Web.Http</RootNamespace>
    <AssemblyName>System.Web.Http.SignalR.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.AspNet.SignalR.Core">
      <HintPath>..\..\packages\Microsoft.AspNet.SignalR.Core.1.0.0\lib\net40\Microsoft.AspNet.SignalR.Core.dll</HintPath>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.SignalR\System.Web.Http.SignalR.csproj">
      <Project>{8a607ac9-e7dd-4b74-a0b1-47fc95b9838b}</Project>
      <Name>System.Web.Http.SignalR</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{fccc4cb7-baf7-4a57-9f89-e5766fe536c0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="HubControllerBaseTest.cs" />
    <Compile Include="HubControllerOfTHubTest.cs" />
    <Compile Include="HubControllerTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Http.SignalR.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Microsoft.AspNet.SignalR.Core" version="1.0.0" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.Test/AuthorizeAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Principal;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class AuthorizeAttributeTest
    {
        private readonly Mock<HttpActionDescriptor> _actionDescriptorMock = new Mock<HttpActionDescriptor>() { CallBase = true };
        private readonly Collection<AllowAnonymousAttribute> _allowAnonymousAttributeCollection = new Collection<AllowAnonymousAttribute>(new AllowAnonymousAttribute[] { new AllowAnonymousAttribute() });
        private readonly MockableAuthorizeAttribute _attribute;
        private readonly Mock<MockableAuthorizeAttribute> _attributeMock = new Mock<MockableAuthorizeAttribute>() { CallBase = true };
        private readonly Mock<HttpControllerDescriptor> _controllerDescriptorMock = new Mock<HttpControllerDescriptor>() { CallBase = true };
        private readonly HttpControllerContext _controllerContext;
        private readonly HttpActionContext _actionContext;
        private readonly Mock<IPrincipal> _principalMock = new Mock<IPrincipal>();
        private readonly HttpRequestMessage _request = new HttpRequestMessage();

        public AuthorizeAttributeTest()
        {
            _attribute = _attributeMock.Object;
            _controllerContext = new Mock<HttpControllerContext>() { CallBase = true }.Object;
            _controllerDescriptorMock.Setup(cd => cd.GetCustomAttributes<AllowAnonymousAttribute>()).Returns(new Collection<AllowAnonymousAttribute>(Enumerable.Empty<AllowAnonymousAttribute>().ToList()));
            _actionDescriptorMock.Setup(ad => ad.GetCustomAttributes<AllowAnonymousAttribute>()).Returns(new Collection<AllowAnonymousAttribute>(Enumerable.Empty<AllowAnonymousAttribute>().ToList()));
            _controllerContext.ControllerDescriptor = _controllerDescriptorMock.Object;
            _controllerContext.Request = _request;
            _actionContext = ContextUtil.CreateActionContext(_controllerContext, _actionDescriptorMock.Object);
            _controllerContext.RequestContext.Principal = _principalMock.Object;
        }

        [Fact]
        public void Roles_Property()
        {
            AuthorizeAttribute attribute = new AuthorizeAttribute();

            Assert.Reflection.StringProperty(attribute, a => a.Roles, expectedDefaultValue: String.Empty);
        }

        [Fact]
        public void Users_Property()
        {
            AuthorizeAttribute attribute = new AuthorizeAttribute();

            Assert.Reflection.StringProperty(attribute, a => a.Users, expectedDefaultValue: String.Empty);
        }

        [Fact]
        public void AllowMultiple_ReturnsTrue()
        {
            Assert.True(_attribute.AllowMultiple);
        }

        [Fact]
        public void TypeId_ReturnsUniqueInstances()
        {
            var attribute1 = new AuthorizeAttribute();
            var attribute2 = new AuthorizeAttribute();

            Assert.NotSame(attribute1.TypeId, attribute2.TypeId);
        }

        [Fact]
        public void OnAuthorization_IfContextParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                _attribute.OnAuthorization(actionContext: null);
            }, "actionContext");
        }

        [Fact]
        public void OnAuthorization_IfUserIsAuthenticated_DoesNotShortCircuitRequest()
        {
            _principalMock.Setup(p => p.Identity.IsAuthenticated).Returns(true);

            _attribute.OnAuthorization(_actionContext);

            Assert.Null(_actionContext.Response);
        }

        [Fact]
        public void OnAuthorization_IfRequestContextDoesNotContainPrincipal_DoesShortCircuitRequest()
        {
            _actionContext.ControllerContext.RequestContext.Principal = null;

            _attribute.OnAuthorization(_actionContext);

            AssertUnauthorizedRequestSet(_actionContext);
        }

        [Fact]
        public void OnAuthorization_IfPrincipalDoesNotContainIdentity_DoesShortCircuitRequest()
        {
            _principalMock.Setup(p => p.Identity).Returns((IIdentity)null);

            _attribute.OnAuthorization(_actionContext);

            AssertUnauthorizedRequestSet(_actionContext);
        }

        [Fact]
        public void OnAuthorization_IfUserIsNotAuthenticated_DoesShortCircuitRequest()
        {
            _principalMock.Setup(p => p.Identity.IsAuthenticated).Returns(false).Verifiable();

            _attribute.OnAuthorization(_actionContext);

            AssertUnauthorizedRequestSet(_actionContext);
            _principalMock.Verify();
        }

        [Fact]
        public void OnAuthorization_IfUserIsNotInUsersCollection_DoesShortCircuitRequest()
        {
            _attribute.Users = "John";
            _principalMock.Setup(p => p.Identity.IsAuthenticated).Returns(true).Verifiable();
            _principalMock.Setup(p => p.Identity.Name).Returns("Mary").Verifiable();

            _attribute.OnAuthorization(_actionContext);

            AssertUnauthorizedRequestSet(_actionContext);
            _principalMock.Verify();
        }

        [Fact]
        public void OnAuthorization_IfUserIsInUsersCollection_DoesNotShortCircuitRequest()
        {
            _attribute.Users = " John , Mary ";
            _principalMock.Setup(p => p.Identity.IsAuthenticated).Returns(true).Verifiable();
            _principalMock.Setup(p => p.Identity.Name).Returns("Mary").Verifiable();

            _attribute.OnAuthorization(_actionContext);

            Assert.Null(_actionContext.Response);
            _principalMock.Verify();
        }

        [Fact]
        public void OnAuthorization_IfUserIsNotInRolesCollection_DoesShortCircuitRequest()
        {
            _attribute.Users = " John , Mary ";
            _attribute.Roles = "Administrators,PowerUsers";
            _principalMock.Setup(p => p.Identity.IsAuthenticated).Returns(true).Verifiable();
            _principalMock.Setup(p => p.Identity.Name).Returns("Mary").Verifiable();
            _principalMock.Setup(p => p.IsInRole("Administrators")).Returns(false).Verifiable();
            _principalMock.Setup(p => p.IsInRole("PowerUsers")).Returns(false).Verifiable();

            _attribute.OnAuthorization(_actionContext);

            AssertUnauthorizedRequestSet(_actionContext);
            _principalMock.Verify();
        }

        [Fact]
        public void OnAuthorization_IfUserIsInRolesCollection_DoesNotShortCircuitRequest()
        {
            _attribute.Users = " John , Mary ";
            _attribute.Roles = "Administrators,PowerUsers";
            _principalMock.Setup(p => p.Identity.IsAuthenticated).Returns(true).Verifiable();
            _principalMock.Setup(p => p.Identity.Name).Returns("Mary").Verifiable();
            _principalMock.Setup(p => p.IsInRole("Administrators")).Returns(false).Verifiable();
            _principalMock.Setup(p => p.IsInRole("PowerUsers")).Returns(true).Verifiable();

            _attribute.OnAuthorization(_actionContext);

            Assert.Null(_actionContext.Response);
            _principalMock.Verify();
        }

        [Fact]
        public void OnAuthorization_IfActionDescriptorIsMarkedWithAllowAnonymousAttribute_DoesNotShortCircuitResponse()
        {
            _actionDescriptorMock.Setup(ad => ad.GetCustomAttributes<AllowAnonymousAttribute>()).Returns(_allowAnonymousAttributeCollection);
            Mock<MockableAuthorizeAttribute> authorizeAttributeMock = new Mock<MockableAuthorizeAttribute>() { CallBase = true };
            AuthorizeAttribute attribute = authorizeAttributeMock.Object;

            attribute.OnAuthorization(_actionContext);

            Assert.Null(_actionContext.Response);
        }

        [Fact]
        public void OnAuthorization_IfControllerDescriptorIsMarkedWithAllowAnonymousAttribute_DoesNotShortCircuitResponse()
        {
            _controllerDescriptorMock.Setup(ad => ad.GetCustomAttributes<AllowAnonymousAttribute>()).Returns(_allowAnonymousAttributeCollection);
            Mock<MockableAuthorizeAttribute> authorizeAttributeMock = new Mock<MockableAuthorizeAttribute>() { CallBase = true };
            AuthorizeAttribute attribute = authorizeAttributeMock.Object;

            attribute.OnAuthorization(_actionContext);

            Assert.Null(_actionContext.Response);
        }

        [Fact]
        public void OnAuthorization_IfRequestNotAuthorized_CallsHandleUnauthorizedRequest()
        {
            Mock<MockableAuthorizeAttribute> authorizeAttributeMock = new Mock<MockableAuthorizeAttribute>() { CallBase = true };
            _principalMock.Setup(p => p.Identity.IsAuthenticated).Returns(false);
            authorizeAttributeMock.Setup(a => a.HandleUnauthorizedRequestPublic(_actionContext)).Verifiable();
            AuthorizeAttribute attribute = authorizeAttributeMock.Object;

            attribute.OnAuthorization(_actionContext);

            authorizeAttributeMock.Verify();
        }

        [Fact]
        public void HandleUnauthorizedRequest_IfContextParameterIsNull_ThrowsArgumentNullException()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                _attribute.HandleUnauthorizedRequestPublic(context: null);
            }, "actionContext");
        }

        [Fact]
        public void HandleUnauthorizedRequest_SetsResponseWithUnauthorizedStatusCode()
        {
            _attribute.HandleUnauthorizedRequestPublic(_actionContext);

            Assert.NotNull(_actionContext.Response);
            Assert.Equal(HttpStatusCode.Unauthorized, _actionContext.Response.StatusCode);
            Assert.Same(_request, _actionContext.Response.RequestMessage);
        }

        [Theory]
        [PropertyData("SplitStringTestData")]
        public void SplitString_SplitsOnCommaAndTrimsWhitespaceAndIgnoresEmptyStrings(string input, params string[] expectedResult)
        {
            string[] result = AuthorizeAttribute.SplitString(input);

            Assert.Equal(expectedResult, result);
        }

        public static IEnumerable<object[]> SplitStringTestData
        {
            get
            {
                return new ParamsTheoryDataSet<string, string>() {
                    { null },
                    { String.Empty },
                    { "   " },
                    { "  A  ", "A" },
                    { "  A, B  ", "A", "B" },
                    { "  , A, ,B, ", "A", "B" },
                    { "   A   B   ", "A   B" },
                };
            }
        }

        [CLSCompliant(false)]
        public class ParamsTheoryDataSet<TParam1, TParam2> : TheoryDataSet
        {
            public void Add(TParam1 p1, params TParam2[] p2)
            {
                AddItem(p1, p2);
            }
        }

        private static void AssertUnauthorizedRequestSet(HttpActionContext actionContext)
        {
            Assert.NotNull(actionContext.Response);
            Assert.Equal(HttpStatusCode.Unauthorized, actionContext.Response.StatusCode);
            Assert.Same(actionContext.ControllerContext.Request, actionContext.Response.RequestMessage);
        }

        public class MockableAuthorizeAttribute : AuthorizeAttribute
        {
            protected override void HandleUnauthorizedRequest(HttpActionContext context)
            {
                HandleUnauthorizedRequestPublic(context);
            }

            public virtual void HandleUnauthorizedRequestPublic(HttpActionContext context)
            {
                base.HandleUnauthorizedRequest(context);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Batch/BatchHttpRequestContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Batch
{
    public class BatchHttpRequestContextTests
    {
        [Fact]
        public void Constructor_Throws_WhenBatchContextIsNull()
        {
            // Arrange
            HttpRequestContext batchContext = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(batchContext), "batchContext");
        }

        [Fact]
        public void BatchContext_ReturnsProvidedInstance()
        {
            // Arrange
            HttpRequestContext expectedBatchContext = CreateDummyContext();
            BatchHttpRequestContext context = CreateProductUnderTest(expectedBatchContext);

            // Act
            HttpRequestContext batchContext = context.BatchContext;

            // Assert
            Assert.Same(expectedBatchContext, batchContext);
        }

        [Fact]
        public void ClientCertificateGet_ReturnsBatchContextClientCertificate()
        {
            // Arrange
            X509Certificate2 expectedCertificate = CreateCertificate();
            HttpRequestContext batchContext = CreateContext();
            batchContext.ClientCertificate = expectedCertificate;
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            X509Certificate2 certificate = context.ClientCertificate;

            // Assert
            Assert.Same(expectedCertificate, certificate);
        }

        [Fact]
        public void ClientCertificateSet_UpdatesBatchContextClientCertificate()
        {
            // Arrange
            X509Certificate2 expectedCertificate = CreateCertificate();
            HttpRequestContext batchContext = CreateContext();
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            context.ClientCertificate = expectedCertificate;

            // Assert
            X509Certificate2 certificate = batchContext.ClientCertificate;
            Assert.Same(expectedCertificate, certificate);
        }

        [Fact]
        public void ConfigurationGet_DoesNotReturnBatchContextConfiguration()
        {
            // Arrange
            using (HttpConfiguration unexpectedConfiguration = CreateConfiguration())
            {
                HttpRequestContext batchContext = CreateContext();
                batchContext.Configuration = unexpectedConfiguration;
                HttpRequestContext context = CreateProductUnderTest(batchContext);

                // Act
                HttpConfiguration configuration = context.Configuration;

                // Assert
                Assert.NotSame(unexpectedConfiguration, configuration);
            }
        }

        [Fact]
        public void ConfigurationSet_UpdatesConfiguration()
        {
            // Arrange
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                HttpRequestContext batchContext = CreateContext();
                HttpRequestContext context = CreateProductUnderTest(batchContext);

                // Act
                context.Configuration = expectedConfiguration;

                // Assert
                HttpConfiguration configuration = context.Configuration;
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsBatchContextIncludeErrorDetail(bool expectedIncludeErrorDetail)
        {
            // Arrange
            HttpRequestContext batchContext = CreateContext();
            batchContext.IncludeErrorDetail = expectedIncludeErrorDetail;
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            bool includeErrorDetail = context.IncludeErrorDetail;

            // Assert
            Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailSet_UpdatesBatchContextIncludeErrorDetail(bool expectedIncludeErrorDetail)
        {
            // Arrange
            HttpRequestContext batchContext = CreateContext();
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            context.IncludeErrorDetail = expectedIncludeErrorDetail;

            // Assert
            bool includeErrorDetail = batchContext.IncludeErrorDetail;
            Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalGet_ReturnsBatchContextIsLocal(bool expectedIsLocal)
        {
            // Arrange
            HttpRequestContext batchContext = CreateContext();
            batchContext.IsLocal = expectedIsLocal;
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            bool isLocal = context.IsLocal;

            // Assert
            Assert.Equal(expectedIsLocal, isLocal);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalSet_UpdatesBatchContextIsLocal(bool expectedIsLocal)
        {
            // Arrange
            HttpRequestContext batchContext = CreateContext();
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            context.IsLocal = expectedIsLocal;

            // Assert
            bool isLocal = batchContext.IsLocal;
            Assert.Equal(expectedIsLocal, isLocal);
        }

        [Fact]
        public void PrincipalGet_ReturnsBatchContextPrincipal()
        {
            // Arrange
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            HttpRequestContext batchContext = CreateContext();
            batchContext.Principal = expectedPrincipal;
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            IPrincipal principal = context.Principal;

            // Assert
            Assert.Same(expectedPrincipal, principal);
        }

        [Fact]
        public void PrincipalSet_UpdatesBatchContextPrincipal()
        {
            // Arrange
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            HttpRequestContext batchContext = CreateContext();
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            context.Principal = expectedPrincipal;

            // Assert
            IPrincipal principal = batchContext.Principal;
            Assert.Same(expectedPrincipal, principal);
        }

        [Fact]
        public void RouteDataGet_DoesNotReturnBatchContextRouteData()
        {
            // Arrange
            IHttpRouteData unexpectedRouteData = CreateDummyRouteData();
            HttpRequestContext batchContext = CreateContext();
            batchContext.RouteData = unexpectedRouteData;
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            IHttpRouteData routeData = context.RouteData;

            // Assert
            Assert.NotSame(unexpectedRouteData, routeData);
        }

        [Fact]
        public void RouteDataSet_UpdatesRouteData()
        {
            // Arrange
            IHttpRouteData expectedRouteData = CreateDummyRouteData();
            HttpRequestContext batchContext = CreateContext();
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            context.RouteData = expectedRouteData;

            // Assert
            IHttpRouteData routeData = context.RouteData;
            Assert.Same(expectedRouteData, routeData);
        }

        [Fact]
        public void UrlGet_DoesNotReturnBatchContextUrl()
        {
            // Arrange
            UrlHelper unexpectedUrl = CreateDummyUrlHelper();
            HttpRequestContext batchContext = CreateContext();
            batchContext.Url = unexpectedUrl;
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            UrlHelper url = context.Url;

            // Assert
            Assert.NotSame(unexpectedUrl, url);
        }

        [Fact]
        public void UrlSet_UpdatesUrl()
        {
            // Arrange
            UrlHelper expectedUrl = CreateDummyUrlHelper();
            HttpRequestContext batchContext = CreateContext();
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            context.Url = expectedUrl;

            // Assert
            UrlHelper url = context.Url;
            Assert.Same(expectedUrl, url);
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsBatchContextVirtualPathRoot()
        {
            // Arrange
            string expectedVirtualPathRoot = "foo";
            HttpRequestContext batchContext = CreateContext();
            batchContext.VirtualPathRoot = expectedVirtualPathRoot;
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            string virtualPathRoot = context.VirtualPathRoot;

            // Assert
            Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesBatchContextVirtualPathRoot()
        {
            // Arrange
            string expectedVirtualPathRoot = "foo";
            HttpRequestContext batchContext = CreateContext();
            HttpRequestContext context = CreateProductUnderTest(batchContext);

            // Act
            context.VirtualPathRoot = expectedVirtualPathRoot;

            // Assert
            string virtualPathRoot = batchContext.VirtualPathRoot;
            Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
        }

        private static X509Certificate2 CreateCertificate()
        {
            return new X509Certificate2();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static HttpRequestContext CreateContext()
        {
            return new HttpRequestContext();
        }

        private static HttpRequestContext CreateDummyContext()
        {
            return new Mock<HttpRequestContext>(MockBehavior.Strict).Object;
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static IHttpRouteData CreateDummyRouteData()
        {
            return new Mock<IHttpRouteData>(MockBehavior.Strict).Object;
        }

        private static UrlHelper CreateDummyUrlHelper()
        {
            return new Mock<UrlHelper>(MockBehavior.Strict).Object;
        }

        private static BatchHttpRequestContext CreateProductUnderTest(HttpRequestContext batchContext)
        {
            return new BatchHttpRequestContext(batchContext);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Batch/BatchHttpRequestMessageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http.Batch
{
    public class BatchHttpRequestMessageExtensionsTest
    {
        [Theory]
        [InlineData("MS_HttpRouteData")]
        [InlineData("MS_DisposableRequestResources")]
        [InlineData("MS_SynchronizationContext")]
        [InlineData("MS_HttpConfiguration")]
        [InlineData("MS_HttpBatchContext")]
        [InlineData("MS_RoutingContext")]
        public void CopyBatchRequestProperties_IgnoresSpecialProperties(string specialPropertyName)
        {
            // Arrange
            string notSpecialPropertyName = "SomeProperty";
            HttpRequestMessage baseRequest = new HttpRequestMessage();
            HttpRequestMessage childRequest = new HttpRequestMessage();

            baseRequest.Properties.Add(notSpecialPropertyName, 42);
            baseRequest.Properties.Add(specialPropertyName, 42);

            // Act
            childRequest.CopyBatchRequestProperties(baseRequest);

            // Assert
            Assert.Contains(notSpecialPropertyName, childRequest.Properties.Keys);
            Assert.DoesNotContain(specialPropertyName, childRequest.Properties.Keys);
        }

        [Fact]
        public void CopyBatchRequestProperties_AddsBatchHttpRequestContext()
        {
            using (HttpRequestMessage subRequest = new HttpRequestMessage())
            using (HttpRequestMessage batchRequest = new HttpRequestMessage())
            {
                HttpRequestContext expectedOriginalContext = new HttpRequestContext();
                subRequest.SetRequestContext(expectedOriginalContext);

                // Act
                BatchHttpRequestMessageExtensions.CopyBatchRequestProperties(subRequest, batchRequest);

                // Assert
                HttpRequestContext context = subRequest.GetRequestContext();
                BatchHttpRequestContext typedContext = Assert.IsType<BatchHttpRequestContext>(context);
                Assert.Same(expectedOriginalContext, typedContext.BatchContext);
            }
        }

        [Fact]
        public void CopyBatchRequestProperties_SetsRequestContextWithUrlHelperForSubRequest()
        {
            // Arrange
            using (HttpRequestMessage subRequest = new HttpRequestMessage())
            using (HttpRequestMessage batchRequest = new HttpRequestMessage())
            {
                subRequest.SetRequestContext(new HttpRequestContext());

                // Act
                BatchHttpRequestMessageExtensions.CopyBatchRequestProperties(subRequest, batchRequest);

                // Assert
                HttpRequestContext context = subRequest.GetRequestContext();
                Assert.NotNull(context);
                Assert.NotNull(context.Url);
                Assert.Same(subRequest, context.Url.Request);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Batch/BatchLearningTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.Batch
{
    public class BatchLearningTests
    {
        [Fact]
        public async Task BatchRequest_SubRequestPropertiesDoNotContainRoutingContext_CopyProperties()
        {
            // Arrange
            const string baseAddress = "http://localhost/api/";
            HttpConfiguration config = new HttpConfiguration();
            HttpServer server = new HttpServer(config);
            config.Routes.MapHttpBatchRoute(
                routeName: "Batch",
                routeTemplate: "api/$batch",
                batchHandler: new CustomHttpBatchHandler(server));
            config.Routes.MapHttpRoute(
                "Default",
                "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional });

            // Act
            using (HttpClient client = new HttpClient(server))
            using (HttpRequestMessage batchRequest = new HttpRequestMessage(HttpMethod.Post, baseAddress + "$batch"))
            {
                batchRequest.Content = new MultipartContent("mixed")
                {
                    new HttpMessageContent(
                        new HttpRequestMessage(HttpMethod.Post, baseAddress + "values")
                        {
                            Content = new ObjectContent<string>("newValue", new JsonMediaTypeFormatter())
                        }),
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, baseAddress + "values/newValue"))
                };

                using (HttpResponseMessage batchResponse = await client.SendAsync(batchRequest, CancellationToken.None))
                {
                    MultipartStreamProvider streamProvider = await batchResponse.Content.ReadAsMultipartAsync();
                    foreach (HttpContent content in streamProvider.Contents)
                    {
                        HttpResponseMessage response = await content.ReadAsHttpResponseMessageAsync();
                        string result = await response.Content.ReadAsStringAsync();

                        // Assert
                        Assert.Equal("\"newValue\"", result);
                    }
                }
            }
        }

        public class ValuesController : ApiController
        {
            public string Get(string id)
            {
                return id;
            }

            public string Post([FromBody] string value)
            {
                return value;
            }
        }

        public class CustomHttpBatchHandler : DefaultHttpBatchHandler
        {
            public CustomHttpBatchHandler(HttpServer httpServer)
                : base(httpServer)
            {
            }

            public override async Task<IList<HttpRequestMessage>> ParseBatchRequestsAsync(
                HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                IList<HttpRequestMessage> subRequests = await base.ParseBatchRequestsAsync(request, cancellationToken);

                // Assert
                Assert.NotNull(subRequests);
                foreach (HttpRequestMessage subRequest in subRequests)
                {
                    Assert.NotNull(subRequest);
                    Assert.Equal(2, subRequest.Properties.Count);
                    Assert.True(subRequest.Properties.ContainsKey(HttpPropertyKeys.RequestContextKey));
                    Assert.True(subRequest.Properties.ContainsKey(HttpPropertyKeys.IsBatchRequest));
                    Assert.False(subRequest.Properties.ContainsKey(HttpRoute.RoutingContextKey));
                }

                return subRequests;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Batch/DefaultHttpBatchHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Batch;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class DefaultHttpBatchHandlerTest
    {
        [Fact]
        public void Parameter_Constructor()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());

            Assert.Equal(BatchExecutionOrder.Sequential, batchHandler.ExecutionOrder);
            Assert.NotNull(batchHandler.Invoker);
            Assert.Contains("multipart/mixed", batchHandler.SupportedContentTypes);
        }

        [Fact]
        public void Constructor_Throws_IfHttpServerIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new DefaultHttpBatchHandler(null),
                "httpServer");
        }

        [Fact]
        public Task CreateResponseMessageAsync_Throws_IfResponsesAreNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            return Assert.ThrowsArgumentNullAsync(
                () => batchHandler.CreateResponseMessageAsync(null, new HttpRequestMessage(), CancellationToken.None),
                "responses");
        }

        [Fact]
        public Task CreateResponseMessageAsync_Throws_IfRequestIsNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            return Assert.ThrowsArgumentNullAsync(
                () => batchHandler.CreateResponseMessageAsync(new HttpResponseMessage[0], null, CancellationToken.None),
                "request");
        }

        [Fact]
        public async Task CreateResponseMessageAsync_ReturnsMultipartContent()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            HttpResponseMessage[] responses = new HttpResponseMessage[]
            {
                new HttpResponseMessage(HttpStatusCode.OK),
                new HttpResponseMessage(HttpStatusCode.BadRequest)
            };

            HttpResponseMessage response = await batchHandler.CreateResponseMessageAsync(responses, new HttpRequestMessage(), CancellationToken.None);

            MultipartContent content = Assert.IsType<MultipartContent>(response.Content);
            List<HttpResponseMessage> nestedResponses = new List<HttpResponseMessage>();
            foreach (var part in content)
            {
                nestedResponses.Add(await part.ReadAsHttpResponseMessageAsync());
            }

            Assert.Equal(2, nestedResponses.Count);
            Assert.Equal(HttpStatusCode.OK, nestedResponses[0].StatusCode);
            Assert.Equal(HttpStatusCode.BadRequest, nestedResponses[1].StatusCode);
        }

        [Fact]
        public Task ProcessBatchAsync_Throws_IfRequestIsNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            return Assert.ThrowsArgumentNullAsync(
                () => batchHandler.ProcessBatchAsync(null, CancellationToken.None),
                "request");
        }

        [Fact]
        public async Task ProcessBatchAsync_CallsRegisterForDispose()
        {
            List<IDisposable> expectedResourcesForDisposal = new List<IDisposable>();
            MockHttpServer server = new MockHttpServer(request =>
            {
                var tmpContent = new StringContent(String.Empty);
                request.RegisterForDispose(tmpContent);
                expectedResourcesForDisposal.Add(tmpContent);
                return new HttpResponseMessage { Content = new StringContent(request.RequestUri.AbsoluteUri) };
            });
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);
            HttpRequestMessage batchRequest = new HttpRequestMessage
            {
                Content = new MultipartContent("mixed")
                {
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://example.org/"))
                }
            };

            var response = await batchHandler.ProcessBatchAsync(batchRequest, CancellationToken.None);
            var resourcesForDisposal = batchRequest.GetResourcesForDisposal();

            foreach (var expectedResource in expectedResourcesForDisposal)
            {
                Assert.Contains(expectedResource, resourcesForDisposal);
            }
        }

        [Fact]
        public void ExecutionOrder_ThrowsWhenTheValueIsInvalid()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());

            Assert.ThrowsInvalidEnumArgument(
                () => batchHandler.ExecutionOrder = (BatchExecutionOrder)20,
                "value",
                20,
                typeof(BatchExecutionOrder));
        }

        [Fact]
        public Task ExecuteRequestMessagesAsync_Throws_IfRequestsAreNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            return Assert.ThrowsArgumentNullAsync(
                () => batchHandler.ExecuteRequestMessagesAsync(null, CancellationToken.None),
                "requests");
        }

        [Fact]
        public async Task ExecuteRequestMessagesAsync_CallsInvokerForEachRequest()
        {
            MockHttpServer server = new MockHttpServer(request =>
            {
                return new HttpResponseMessage { Content = new StringContent(request.RequestUri.AbsoluteUri) };
            });
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);
            HttpRequestMessage[] requests = new HttpRequestMessage[]
            {
                new HttpRequestMessage(HttpMethod.Get, "http://example.com/"),
                new HttpRequestMessage(HttpMethod.Post, "http://example.org/")
            };

            var responses = await batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None);

            Assert.Equal(2, responses.Count);
            Assert.Equal("http://example.com/", await responses[0].Content.ReadAsStringAsync());
            Assert.Equal("http://example.org/", await responses[1].Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task ExecuteRequestMessagesAsync_DisposesResponseInCaseOfException()
        {
            List<DisposableResponseMessage> responses = new List<DisposableResponseMessage>();
            MockHttpServer server = new MockHttpServer(request =>
            {
                if (request.Method == HttpMethod.Put)
                {
                    throw new InvalidOperationException();
                }
                var response = new DisposableResponseMessage();
                responses.Add(response);
                return response;
            });
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server);
            HttpRequestMessage[] requests = new HttpRequestMessage[]
            {
                new HttpRequestMessage(HttpMethod.Get, "http://example.com/"),
                new HttpRequestMessage(HttpMethod.Post, "http://example.com/"),
                new HttpRequestMessage(HttpMethod.Put, "http://example.com/")
            };

            await Assert.ThrowsAsync<InvalidOperationException>(
                () => batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None));

            Assert.Equal(2, responses.Count);
            foreach (var response in responses)
            {
                Assert.True(response.IsDisposed);
            }
        }

        [Fact]
        public async Task ExecuteRequestMessagesAsync_NonSequentialExecution()
        {
            List<HttpRequestMessage> completedRequests = new List<HttpRequestMessage>();

            MockHttpServer server = new MockHttpServer(async request =>
            {
                if (request.Method == HttpMethod.Get)
                {
                    await Task.Delay(2000);
                }
                completedRequests.Add(request);
                return new HttpResponseMessage();
            });
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server)
            {
                ExecutionOrder = BatchExecutionOrder.NonSequential
            };
            HttpRequestMessage[] requests = new HttpRequestMessage[]
            {
                new HttpRequestMessage(HttpMethod.Get, "http://example.com/"),
                new HttpRequestMessage(HttpMethod.Post, "http://example.com/")
            };

            await batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None);

            Assert.Equal(2, completedRequests.Count);
            Assert.Equal(HttpMethod.Post, completedRequests[0].Method);
            Assert.Equal(HttpMethod.Get, completedRequests[1].Method);
        }

        [Fact]
        public async Task ExecuteRequestMessagesAsync_SequentialExecutionCallInvokerForEachRequest()
        {
            List<HttpRequestMessage> completedRequests = new List<HttpRequestMessage>();

            MockHttpServer server = new MockHttpServer(async request =>
            {
                if (request.Method == HttpMethod.Get)
                {
                    await Task.Delay(2000);
                }
                completedRequests.Add(request);
                return new HttpResponseMessage();
            });
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server)
            {
                ExecutionOrder = BatchExecutionOrder.Sequential
            };
            HttpRequestMessage[] requests = new HttpRequestMessage[]
            {
                new HttpRequestMessage(HttpMethod.Get, "http://example.com/"),
                new HttpRequestMessage(HttpMethod.Post, "http://example.com/")
            };

            await batchHandler.ExecuteRequestMessagesAsync(requests, CancellationToken.None);

            Assert.Equal(2, completedRequests.Count);
            Assert.Equal(HttpMethod.Get, completedRequests[0].Method);
            Assert.Equal(HttpMethod.Post, completedRequests[1].Method);
        }

        [Fact]
        public Task ParseBatchRequestsAsync_Throws_IfRequestIsNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            return Assert.ThrowsArgumentNullAsync(
                () => batchHandler.ParseBatchRequestsAsync(null, CancellationToken.None),
                "request");
        }

        [Fact]
        public async Task ParseBatchRequestsAsync_Returns_RequestsFromMultipartContent()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new MultipartContent("mixed")
                {
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://example.com/values"))
                }
            };

            IList<HttpRequestMessage> requests = await batchHandler.ParseBatchRequestsAsync(request, CancellationToken.None);

            Assert.Equal(2, requests.Count);
            Assert.Equal(HttpMethod.Get, requests[0].Method);
            Assert.Equal("http://example.com/", requests[0].RequestUri.AbsoluteUri);
            Assert.Equal(HttpMethod.Post, requests[1].Method);
            Assert.Equal("http://example.com/values", requests[1].RequestUri.AbsoluteUri);
        }

        [Fact]
        public async Task ParseBatchRequestsAsync_Returns_RequestsFromMultipartContent_WithUriSchemeSet_FromRequest()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new MultipartContent("mixed")
                {
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "https://example.com/values"))
                },
                RequestUri = new Uri("https://example.com/")
            };

            IList<HttpRequestMessage> requests = await batchHandler.ParseBatchRequestsAsync(request, CancellationToken.None);

            Assert.Equal(2, requests.Count);
            Assert.Equal(HttpMethod.Get, requests[0].Method);
            Assert.Equal("https://example.com/", requests[0].RequestUri.AbsoluteUri);
            Assert.Equal(HttpMethod.Post, requests[1].Method);
            Assert.Equal("https://example.com/values", requests[1].RequestUri.AbsoluteUri);
        }

        [Fact]
        public async Task ParseBatchRequestsAsync_CopiesPropertiesFromRequest_WithoutExcludedProperties()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            HttpRequestMessage request = new HttpRequestMessage
            {
                Content = new MultipartContent("mixed")
                {
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Get, "http://example.com/")),
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://example.com/values"))
                }
            };
            request.Properties.Add("foo", "bar");
            request.SetRouteData(new HttpRouteData(new HttpRoute()));
            request.RegisterForDispose(new StringContent(String.Empty));

            IList<HttpRequestMessage> requests = await batchHandler.ParseBatchRequestsAsync(request, CancellationToken.None);

            Assert.Equal(2, requests.Count);
            Assert.Equal(HttpMethod.Get, requests[0].Method);
            Assert.Equal("bar", requests[0].Properties["foo"]);
            Assert.Null(requests[0].GetRouteData());
            Assert.Same(requests[0], requests[0].GetUrlHelper().Request);
            Assert.Empty(requests[0].GetResourcesForDisposal());
            Assert.Equal("http://example.com/", requests[0].RequestUri.AbsoluteUri);

            Assert.Equal(HttpMethod.Post, requests[1].Method);
            Assert.Equal("http://example.com/values", requests[1].RequestUri.AbsoluteUri);
            Assert.Equal("bar", requests[1].Properties["foo"]);
            Assert.Null(requests[1].GetRouteData());
            Assert.Same(requests[1], requests[1].GetUrlHelper().Request);
            Assert.Empty(requests[1].GetResourcesForDisposal());
        }

        [Fact]
        public void ValidateRequest_Throws_IfRequestIsNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            Assert.ThrowsArgumentNull(
                () => batchHandler.ValidateRequest(null),
                "request");
        }

        [Fact]
        public async Task ValidateRequest_Throws_IfRequestContentIsNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            HttpRequestMessage request = new HttpRequestMessage();

            HttpResponseException errorResponse = Assert.Throws<HttpResponseException>(
                () => batchHandler.ValidateRequest(request));
            Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
            Assert.Equal("The 'Content' property on the batch request cannot be null.",
                (await errorResponse.Response.Content.ReadAsAsync<HttpError>()).Message);
        }

        [Fact]
        public async Task ValidateRequest_Throws_IfRequestContentTypeIsNull()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent(String.Empty);
            request.Content.Headers.ContentType = null;

            HttpResponseException errorResponse = Assert.Throws<HttpResponseException>(
                () => batchHandler.ValidateRequest(request));
            Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
            Assert.Equal("The batch request must have a \"Content-Type\" header.",
                (await errorResponse.Response.Content.ReadAsAsync<HttpError>()).Message);
        }

        [Fact]
        public async Task ValidateRequest_Throws_IfRequestMediaTypeIsWrong()
        {
            DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(new HttpServer());
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent(String.Empty);
            request.Content.Headers.ContentType = new MediaTypeHeaderValue("text/json");

            HttpResponseException errorResponse = Assert.Throws<HttpResponseException>(
                () => batchHandler.ValidateRequest(request));
            Assert.Equal(HttpStatusCode.BadRequest, errorResponse.Response.StatusCode);
            Assert.Equal("The batch request of media type 'text/json' is not supported.",
                (await errorResponse.Response.Content.ReadAsAsync<HttpError>()).Message);
        }

        private class MockHttpServer : HttpServer
        {
            private Func<HttpRequestMessage, Task<HttpResponseMessage>> _action;

            public MockHttpServer(Func<HttpRequestMessage, HttpResponseMessage> action)
            {
                _action = request =>
                {
                    return Task.FromResult(action(request));
                };
            }

            public MockHttpServer(Func<HttpRequestMessage, Task<HttpResponseMessage>> action)
            {
                _action = action;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return _action(request);
            }
        }

        private class DisposableResponseMessage : HttpResponseMessage
        {
            public bool IsDisposed { get; set; }

            protected override void Dispose(bool disposing)
            {
                IsDisposed = true;
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/Batch/HttpBatchHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Batch;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Results;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpBatchHandlerTest
    {
        [Fact]
        public void Constructor_Throws_WhenServerIsNull()
        {
            // Arrange
            HttpServer httpServer = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(httpServer), "httpServer");
        }

        [Fact]
        public void ExceptionLoggerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler exceptionHandler = CreateDummyExceptionHandler();

            using (HttpServer server = CreateServer())
            using (HttpBatchHandler handler = CreateProductUnderTest(server, expectedExceptionLogger,
                exceptionHandler))
            {
                // Act
                IExceptionLogger exceptionLogger = handler.ExceptionLogger;

                // Assert
                Assert.Same(expectedExceptionLogger, exceptionLogger);
            }
        }

        [Fact]
        public void ExceptionHandlerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            IExceptionLogger exceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();

            using (HttpServer server = CreateServer())
            using (HttpBatchHandler handler = CreateProductUnderTest(server, exceptionLogger,
                expectedExceptionHandler))
            {
                // Act
                IExceptionHandler exceptionHandler = handler.ExceptionHandler;

                // Assert
                Assert.Same(expectedExceptionHandler, exceptionHandler);
            }
        }

        [Fact]
        public void ExceptionLoggerGet_IfUnset_ReturnsExceptionLoggerFromConfiguration()
        {
            // Arrange
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
                configuration.Services.Add(typeof(IExceptionLogger), expectedExceptionLogger);

                using (HttpServer server = new HttpServer(configuration))
                using (HttpBatchHandler product = CreateProductUnderTest(server))
                {
                    // Act
                    IExceptionLogger exceptionLogger = product.ExceptionLogger;

                    // Assert
                    CompositeExceptionLogger compositeLogger = Assert.IsType<CompositeExceptionLogger>(exceptionLogger);
                    IEnumerable<IExceptionLogger> loggers = compositeLogger.Loggers;
                    Assert.NotNull(loggers);
                    IExceptionLogger logger = Assert.Single(loggers);
                    Assert.Same(expectedExceptionLogger, logger);
                }
            }
        }

        [Fact]
        public void ExceptionHandlerGet_IfUnset_ReturnsExceptionHandlerFromConfiguration()
        {
            // Arrange
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();
                configuration.Services.Replace(typeof(IExceptionHandler), expectedExceptionHandler);

                using (HttpServer server = new HttpServer(configuration))
                using (HttpBatchHandler product = CreateProductUnderTest(server))
                {
                    // Act
                    IExceptionHandler exceptionHandler = product.ExceptionHandler;

                    // Assert
                    LastChanceExceptionHandler lastChanceHandler = Assert.IsType<LastChanceExceptionHandler>(exceptionHandler);
                    Assert.Same(expectedExceptionHandler, lastChanceHandler.InnerHandler);
                }
            }
        }

        [Fact]
        public Task SendAsync_Throws_WhenRequestIsNull()
        {
            // Arrange
            MockHttpBatchHandler mockHandler = new MockHttpBatchHandler(new HttpServer());

            // Act & Assert
            return Assert.ThrowsArgumentNullAsync(() => mockHandler.SendAsync(null), "request");
        }

        [Fact]
        public async Task SendAsync_CallsProcessBatchAsync()
        {
            Mock<HttpBatchHandler> handler = new Mock<HttpBatchHandler>(new HttpServer());
            handler.Setup(h => h.ProcessBatchAsync(It.IsAny<HttpRequestMessage>(), CancellationToken.None))
                .Returns(Task.FromResult(new HttpResponseMessage(HttpStatusCode.Redirect)
                {
                    Content = new StringContent("ProcessBatchAsync called.")
                }));
            HttpMessageInvoker invoker = new HttpMessageInvoker(handler.Object);

            var response = await invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
            Assert.Equal("ProcessBatchAsync called.", await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task SendAsync_ReturnsHttpResponseException()
        {
            Mock<HttpBatchHandler> handler = new Mock<HttpBatchHandler>(new HttpServer());
            handler.Setup(h => h.ProcessBatchAsync(It.IsAny<HttpRequestMessage>(), CancellationToken.None))
                .Returns(() =>
                {
                    throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)
                    {
                        Content = new StringContent("HttpResponseException Error.")
                    });
                });
            HttpMessageInvoker invoker = new HttpMessageInvoker(handler.Object);

            var response = await invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
            Assert.Equal("HttpResponseException Error.", await response.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task SendAsync_IfProcessBatchAsyncTaskIsFaulted_CallsExceptionServices()
        {
            // Arrange
            Exception expectedException = CreateException();

            Mock<IExceptionLogger> exceptionLoggerMock = CreateStubExceptionLoggerMock();
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = CreateStubExceptionHandlerMock();
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpServer server = CreateServer(configuration))
            using (HttpBatchHandler product = new LambdaHttpBatchHandler(server, exceptionLogger, exceptionHandler,
                (i1, i2) => CreateFaultedTask<HttpResponseMessage>(expectedException)))
            {
                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                await Assert.ThrowsAsync<Exception>(() => product.SendAsync(expectedRequest, cancellationToken));

                // Assert
                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == ExceptionCatchBlocks.HttpBatchHandler
                    && c.Request == expectedRequest;

                exceptionLoggerMock.Verify(l => l.LogAsync(
                    It.Is<ExceptionLoggerContext>(c => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());

                exceptionHandlerMock.Verify(h => h.HandleAsync(
                    It.Is<ExceptionHandlerContext>((c) => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task SendAsync_IfProcessBatchAsyncTaskIsCanceled_DoesNotCallExceptionServices()
        {
            // Arrange
            Exception expectedException = new OperationCanceledException();

            Mock<IExceptionLogger> exceptionLoggerMock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpServer server = CreateServer(configuration))
            using (HttpBatchHandler product = new LambdaHttpBatchHandler(server, exceptionLogger, exceptionHandler,
                (i1, i2) => CreateFaultedTask<HttpResponseMessage>(expectedException)))
            {
                CancellationToken cancellationToken = CreateCancellationToken();

                // Act & Assert
                await Assert.ThrowsAsync<OperationCanceledException>(() => product.SendAsync(expectedRequest, cancellationToken));
            }
        }

        [Fact]
        public async Task SendAsync_IfExceptionHandlerSetsNullResult_PropogatesFaultedTaskException()
        {
            // Arrange
            Exception expectedException = CreateExceptionWithCallStack();
            string expectedStackTrace = expectedException.StackTrace;

            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();

            Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            exceptionHandlerMock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Callback<ExceptionHandlerContext, CancellationToken>((c, i) => c.Result = null)
                .Returns(Task.FromResult(0));
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpServer server = CreateServer(configuration))
            using (HttpBatchHandler product = new LambdaHttpBatchHandler(server, exceptionLogger, exceptionHandler,
                (i1, i2) => CreateFaultedTask<HttpResponseMessage>(expectedException)))
            {
                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                var exception = await Assert.ThrowsAsync<Exception>(() => product.SendAsync(request, cancellationToken));

                // Assert
                Assert.Same(expectedException, exception);
                Assert.NotNull(exception.StackTrace);
                Assert.StartsWith(expectedStackTrace, exception.StackTrace);
            }
        }

        [Fact]
        public async Task SendAsync_IfExceptionHandlerHandlesException_ReturnsResponse()
        {
            // Arrange
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();

            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                exceptionHandlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Callback<ExceptionHandlerContext, CancellationToken>((c, i) =>
                        c.Result = new ResponseMessageResult(expectedResponse))
                    .Returns(Task.FromResult(0));
                IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

                using (HttpRequestMessage request = CreateRequest())
                using (HttpConfiguration configuration = new HttpConfiguration())
                using (HttpServer server = CreateServer(configuration))
                using (HttpBatchHandler product = new LambdaHttpBatchHandler(server, exceptionLogger, exceptionHandler,
                    (i1, i2) => CreateFaultedTask<HttpResponseMessage>(CreateException())))
                {
                    CancellationToken cancellationToken = CreateCancellationToken();

                    // Act
                    HttpResponseMessage response = await product.SendAsync(request, cancellationToken);

                    // Assert
                    Assert.Same(expectedResponse, response);
                }
            }
        }

        [Fact]
        public async Task SendAsync_WithDefaultExceptionHandler_IfProcessBatchAsyncTaskIsFaulted_ReturnsInternalServerError()
        {
            Mock<HttpBatchHandler> handler = new Mock<HttpBatchHandler>(new HttpServer());
            handler.Setup(h => h.ProcessBatchAsync(It.IsAny<HttpRequestMessage>(), CancellationToken.None))
                .Returns(() =>
                {
                    throw new InvalidOperationException();
                });
            HttpMessageInvoker invoker = new HttpMessageInvoker(handler.Object);

            var response = await invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None);

            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
        }

        private static CancellationToken CreateCancellationToken()
        {
            CancellationTokenSource source = new CancellationTokenSource();
            return source.Token;
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static IExceptionHandler CreateDummyExceptionHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyExceptionLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static Exception CreateException()
        {
            return new Exception();
        }

        private static Exception CreateExceptionWithCallStack()
        {
            try
            {
                throw CreateException();
            }
            catch (Exception exception)
            {
                return exception;
            }
        }

        private static Task<TResult> CreateFaultedTask<TResult>(Exception exception)
        {
            TaskCompletionSource<TResult> source = new TaskCompletionSource<TResult>();
            source.SetException(exception);
            return source.Task;
        }

        private static HttpBatchHandler CreateProductUnderTest(HttpServer httpServer)
        {
            return new MockHttpBatchHandler(httpServer);
        }

        private static HttpBatchHandler CreateProductUnderTest(HttpServer httpServer, IExceptionLogger exceptionLogger,
                IExceptionHandler exceptionHanlder)
        {
            return new MockHttpBatchHandler(httpServer, exceptionLogger, exceptionHanlder);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static HttpServer CreateServer()
        {
            return new HttpServer();
        }

        private static HttpServer CreateServer(HttpConfiguration configuration)
        {
            return new HttpServer(configuration);
        }

        private static Mock<IExceptionHandler> CreateStubExceptionHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static IExceptionLogger CreateStubExceptionLogger()
        {
            return CreateStubExceptionLoggerMock().Object;
        }

        private static Mock<IExceptionLogger> CreateStubExceptionLoggerMock()
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private class LambdaHttpBatchHandler : HttpBatchHandler
        {
            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _processBatchAsync;

            public LambdaHttpBatchHandler(HttpServer httpServer, IExceptionLogger exceptionLogger,
                IExceptionHandler exceptionHandler,
                Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> processBatchAsync)
                : base(httpServer)
            {
                Contract.Assert(processBatchAsync != null);
                _processBatchAsync = processBatchAsync;
                ExceptionLogger = exceptionLogger;
                ExceptionHandler = exceptionHandler;
            }

            public override Task<HttpResponseMessage> ProcessBatchAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return _processBatchAsync.Invoke(request, cancellationToken);
            }
        }

        private class MockHttpBatchHandler : HttpBatchHandler
        {
            public MockHttpBatchHandler(HttpServer server)
                : base(server)
            {
            }

            public MockHttpBatchHandler(HttpServer httpServer, IExceptionLogger exceptionLogger,
                IExceptionHandler exceptionHanlder)
                : base(httpServer)
            {
                ExceptionLogger = exceptionLogger;
                ExceptionHandler = exceptionHanlder;
            }

            public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request)
            {
                return SendAsync(request, CancellationToken.None);
            }

            public override Task<HttpResponseMessage> ProcessBatchAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return Task.FromResult(new HttpResponseMessage());
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/Common/TraceWriterExceptionMapperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;

namespace System.Web.Http.Common
{
    public class TraceWriterExceptionMapperTest
    {
        public static TheoryDataSet<Exception, TraceLevel?> GetMappedTraceLevelTestData
        {
            get
            {
                return new TheoryDataSet<Exception, TraceLevel?>
                {
                    { new Exception(), null},
                    { new HttpResponseException(new HttpResponseMessage(HttpStatusCode.OK)), TraceLevel.Info },
                    { new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Accepted)), TraceLevel.Info },
                    { new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest)), TraceLevel.Warn },
                    { new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Conflict)), TraceLevel.Warn },
                    { new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)), null },
                };
            }
        }

        [Theory]
        [PropertyData("GetMappedTraceLevelTestData")]
        public void GetMappedTraceLevel_ReturnsExpectedTraceLevel(Exception exception, TraceLevel? expectedTraceLevel)
        {
            Assert.Equal(expectedTraceLevel, TraceWriterExceptionMapper.GetMappedTraceLevel(exception));
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ActionFilterResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class ActionFilterResultTests
    {
        [Fact]
        public async Task InvokeActionWithActionFilters_ChainsFiltersInOrderFollowedByInnerActionContinuation()
        {
            // Arrange
            HttpActionContext actionContextInstance = ContextUtil.CreateActionContext();
            List<string> log = new List<string>();
            Mock<IActionFilter> globalFilterMock = CreateActionFilterMock((ctx, ct, continuation) =>
            {
                log.Add("globalFilter");
                return continuation();
            });
            Mock<IActionFilter> actionFilterMock = CreateActionFilterMock((ctx, ct, continuation) =>
            {
                log.Add("actionFilter");
                return continuation();
            });
            Func<Task<HttpResponseMessage>> innerAction = () => Task<HttpResponseMessage>.Factory.StartNew(() =>
            {
                log.Add("innerAction");
                return null;
            });
            var filters = new IActionFilter[] {
                globalFilterMock.Object,
                actionFilterMock.Object,
            };

            // Act
            var result = ActionFilterResult.InvokeActionWithActionFilters(actionContextInstance,
                CancellationToken.None, filters, innerAction);

            // Assert
            Assert.NotNull(result);
            await result();

            Assert.Equal(new[] { "globalFilter", "actionFilter", "innerAction" }, log.ToArray());
            globalFilterMock.Verify();
            actionFilterMock.Verify();
        }

        private Mock<IActionFilter> CreateActionFilterMock(Func<HttpActionContext, CancellationToken,
            Func<Task<HttpResponseMessage>>, Task<HttpResponseMessage>> implementation)
        {
            Mock<IActionFilter> filterMock = new Mock<IActionFilter>();
            filterMock.Setup(f => f.ExecuteActionFilterAsync(It.IsAny<HttpActionContext>(),
                                                             CancellationToken.None,
                                                             It.IsAny<Func<Task<HttpResponseMessage>>>()))
                      .Returns(implementation)
                      .Verifiable();
            return filterMock;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ApiControllerActionInvokerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class ApiControllerActionInvokerTest
    {
        private readonly HttpActionContext _actionContext;
        private readonly Mock<HttpActionDescriptor> _actionDescriptorMock = new Mock<HttpActionDescriptor>();
        private readonly ApiControllerActionInvoker _actionInvoker = new ApiControllerActionInvoker();
        private readonly HttpControllerContext _controllerContext;
        private readonly HttpRequestMessage _request = new HttpRequestMessage();
        private readonly Mock<IActionResultConverter> _converterMock = new Mock<IActionResultConverter>();

        public ApiControllerActionInvokerTest()
        {
            _controllerContext = new HttpControllerContext()
            {
                Request = _request
            };
            _actionContext = new HttpActionContext(_controllerContext, _actionDescriptorMock.Object);
            _actionDescriptorMock.Setup(ad => ad.ResultConverter).Returns(_converterMock.Object);
        }

        [Fact]
        public void InvokeActionAsync_Throws_IfContextIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => _actionInvoker.InvokeActionAsync(null, CancellationToken.None),
                "actionContext");
        }

        [Fact]
        public async Task InvokeActionAsync_InvokesActionDescriptorExecuteAsync()
        {
            var cts = new CancellationTokenSource();
            _actionDescriptorMock.Setup(
                ad => ad.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult((object)null));

            await _actionInvoker.InvokeActionAsync(_actionContext, cts.Token);

            _actionDescriptorMock.Verify(ad => ad.ExecuteAsync(_actionContext.ControllerContext, _actionContext.ActionArguments, cts.Token), Times.Once());
        }

        [Fact]
        public async Task InvokeActionAsync_PassesExecutionResultToConfiguredConverter()
        {
            var value = new object();
            _actionDescriptorMock.Setup(ad => ad.ExecuteAsync(_actionContext.ControllerContext, _actionContext.ActionArguments, CancellationToken.None))
                .Returns(Task.FromResult(value));

            await _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            _converterMock.Verify(c => c.Convert(_actionContext.ControllerContext, value), Times.Once());
        }

        [Fact]
        public async Task InvokeActionAsync_ReturnsResponseFromConverter()
        {
            var expectedResponse = new HttpResponseMessage();
            _actionDescriptorMock.Setup(ad => ad.ExecuteAsync(_actionContext.ControllerContext, _actionContext.ActionArguments, CancellationToken.None))
                .Returns(Task.FromResult(new object()));
            _converterMock.Setup(c => c.Convert(_actionContext.ControllerContext, It.IsAny<object>()))
                .Returns(expectedResponse);

            var response = await _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            Assert.Same(expectedResponse, response);
        }

        [Fact]
        public async Task InvokeActionAsync_WhenExecuteThrowsHttpResponseException_ReturnsResponse()
        {
            HttpResponseMessage response = new HttpResponseMessage();
            _actionDescriptorMock.Setup(ad => ad.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<IDictionary<string, object>>(), CancellationToken.None))
                .Throws(new HttpResponseException(response));

            var result = await _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            Assert.Same(response, result);
            Assert.Same(_request, result.RequestMessage);
        }

        [Fact]
        public async Task InvokeActionAsync_WhenExecuteThrows_ReturnsFaultedTask()
        {
            Exception expectedException = new Exception();
            _actionDescriptorMock.Setup(ad => ad.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<IDictionary<string, object>>(), CancellationToken.None))
                .Throws(expectedException);

            // Act & Assert
            var exception = await Assert.ThrowsAsync<Exception>(() => _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None));
            Assert.Same(expectedException, exception);
        }

        [Fact]
        public async Task InvokeActionAsync_ForActionResult_ReturnsResultResponse()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();

            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            {
                IHttpActionResult result = CreateStubResult(expectedResponse);
                _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
                _actionDescriptorMock.Setup(d => d.ExecuteAsync(_actionContext.ControllerContext,
                    _actionContext.ActionArguments, cancellationToken)).Returns(Task.FromResult((object)result));

                // Act
                HttpResponseMessage response = await _actionInvoker.InvokeActionAsync(_actionContext, cancellationToken);

                // Assert
                Assert.Same(expectedResponse, response);
            }
        }

        [Fact]
        public async Task InvokeActionAsync_ForActionResult_AddsRequestMessage_WhenMissing()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            {
                _controllerContext.Request = expectedRequest;

                using (HttpResponseMessage responseToReturn = new HttpResponseMessage())
                {
                    IHttpActionResult result = CreateStubResult(responseToReturn);
                    _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
                    _actionDescriptorMock.Setup(d => d.ExecuteAsync(It.IsAny<HttpControllerContext>(),
                        It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>())).Returns(
                        Task.FromResult((object)result));

                    // Act
                    HttpResponseMessage response = await _actionInvoker.InvokeActionAsync(_actionContext, cancellationToken);

                    // Assert
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task InvokeActionAsync_ForActionResult_LeavesRequestMessage_WhenPresent()
        {
            // Arrange
            CancellationToken cancellationToken = new CancellationToken();

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            {
                using (HttpRequestMessage otherRequest = new HttpRequestMessage())
                {
                    _controllerContext.Request = otherRequest;

                    using (HttpResponseMessage responseToReturn = CreateResponse(expectedRequest))
                    {
                        IHttpActionResult result = CreateStubResult(responseToReturn);
                        _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
                        _actionDescriptorMock.Setup(d => d.ExecuteAsync(It.IsAny<HttpControllerContext>(),
                            It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>())).Returns(
                            Task.FromResult((object)result));

                        // Act
                        HttpResponseMessage response = await _actionInvoker.InvokeActionAsync(_actionContext, cancellationToken);

                        // Assert
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public async Task InvokeActionAsync_ForActionResult_HandlesHttpResponseException()
        {
            // Arrange
            _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
            HttpResponseException expectedException = new HttpResponseException(HttpStatusCode.Ambiguous);
            _actionDescriptorMock.Setup(d => d.ExecuteAsync(It.IsAny<HttpControllerContext>(),
                It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>())).Throws(expectedException);

            // Act
            HttpResponseMessage response = await _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            // Assert
            Assert.Equal(HttpStatusCode.Ambiguous, response.StatusCode);
        }

        [Fact]
        public Task InvokeActionAsync_ForActionResult_Throws_WhenResultIsNull()
        {
            // Arrange
            _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
            _actionDescriptorMock.Setup(d => d.ExecuteAsync(It.IsAny<HttpControllerContext>(),
                It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>())).Returns(
                Task.FromResult<object>(null));

            // Act
            Task<HttpResponseMessage> task = _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            // Assert
            return Assert.ThrowsAsync<InvalidOperationException>(() => task,
                "A null value was returned where an instance of IHttpActionResult was expected.");
        }

        [Fact]
        public Task InvokeActionAsync_ForActionResult_Throws_WhenResponseIsNull()
        {
            // Arrange
            _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
            IHttpActionResult emptyResult = CreateStubResult(null);
            _actionDescriptorMock.Setup(d => d.ExecuteAsync(It.IsAny<HttpControllerContext>(),
                It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>())).Returns(
                Task.FromResult((object)emptyResult));

            // Act
            Task<HttpResponseMessage> task = _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            // Assert
            return Assert.ThrowsAsync<InvalidOperationException>(() => task,
                "A null value was returned where an instance of HttpResponseMessage was expected.");
        }

        [Fact]
        public Task InvokeActionAsync_ForActionResult_Throws_WhenResultIsNotActionResult()
        {
            // Arrange
            _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(IHttpActionResult));
            _actionDescriptorMock.Setup(d => d.ExecuteAsync(It.IsAny<HttpControllerContext>(),
                It.IsAny<IDictionary<string, object>>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult(
                new object()));

            // Act
            Task<HttpResponseMessage> task = _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            // Assert
            return Assert.ThrowsAsync<InvalidOperationException>(() => task,
                "An object of type 'System.Object' was returned where an instance of IHttpActionResult was expected.");
        }

        [Fact]
        public async Task InvokeActionAsync_DeclaredObject_ReturnsWidget()
        {
            using (var expectedResponse = new HttpResponseMessage())
            {
                var result = new Widget() { Name = "CoolWidget" };

                _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(object));
                _actionDescriptorMock.Setup(d => d.ExecuteAsync(
                    It.IsAny<HttpControllerContext>(),
                    It.IsAny<IDictionary<string, object>>(),
                    It.IsAny<CancellationToken>())).Returns(Task.FromResult((object)result));

                _converterMock.Setup(c => c.Convert(It.IsAny<HttpControllerContext>(), result)).Returns(expectedResponse);

                // Act
                HttpResponseMessage response = await _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

                // Assert
                Assert.Same(expectedResponse, response);
            }
        }

        [Fact]
        public async Task InvokeActionAsync_WrongReturnType_Throws()
        {
            using (var expectedResponse = new HttpResponseMessage())
            {
                var result = new Mock<IHttpActionResult>().Object;

                _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(Widget));
                _actionDescriptorMock.SetupGet(d => d.ResultConverter).Returns(new ValueResultConverter<Widget>());
                _actionDescriptorMock.Setup(d => d.ExecuteAsync(
                    It.IsAny<HttpControllerContext>(),
                    It.IsAny<IDictionary<string, object>>(),
                    It.IsAny<CancellationToken>())).Returns(Task.FromResult((object)result));

                // Act & Assert
                await Assert.ThrowsAsync<InvalidCastException>(() => _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None));
            }
        }

        [Fact]
        public async Task InvokeActionAsync_DeclaredObject_ReturnsActionResult()
        {
            // Arrange
            using (var expectedResponse = new HttpResponseMessage())
            {
                var mockActionResult = new Mock<IHttpActionResult>();
                mockActionResult
                    .Setup(m => m.ExecuteAsync(It.IsAny<CancellationToken>()))
                    .Returns(Task.FromResult(expectedResponse));

                _actionDescriptorMock.Setup(d => d.ReturnType).Returns(typeof(object));
                _actionDescriptorMock.Setup(d => d.ExecuteAsync(
                    It.IsAny<HttpControllerContext>(),
                    It.IsAny<IDictionary<string, object>>(),
                    It.IsAny<CancellationToken>())).Returns(Task.FromResult((object)mockActionResult.Object));

                // Act
                HttpResponseMessage response = await _actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

                // Assert
                Assert.Same(expectedResponse, response);
            }
        }

        private static HttpResponseMessage CreateResponse(HttpRequestMessage request)
        {
            return new HttpResponseMessage
            {
                RequestMessage = request
            };
        }

        private static IHttpActionResult CreateStubResult(HttpResponseMessage response)
        {
            Mock<IHttpActionResult> mock = new Mock<IHttpActionResult>();
            mock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response));
            return mock.Object;
        }

        private class Widget
        {
            public string Name
            {
                get;
                set;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ApiControllerActionSelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class ApiControllerActionSelectorTest
    {
        [Fact]
        public void SelectAction_With_DifferentExecutionContexts()
        {
            ApiControllerActionSelector actionSelector = new ApiControllerActionSelector();
            HttpControllerContext GetContext = ContextUtil.CreateControllerContext();
            HttpControllerDescriptor usersControllerDescriptor = new HttpControllerDescriptor(GetContext.Configuration, "Users", typeof(UsersController));
            usersControllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionSelector), actionSelector);
            GetContext.ControllerDescriptor = usersControllerDescriptor;
            GetContext.Request = new HttpRequestMessage
                {
                    Method = HttpMethod.Get
                };
            HttpControllerContext PostContext = ContextUtil.CreateControllerContext();
            usersControllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionSelector), actionSelector);
            PostContext.ControllerDescriptor = usersControllerDescriptor;
            PostContext.Request = new HttpRequestMessage
            {
                Method = HttpMethod.Post
            };

            HttpActionDescriptor getActionDescriptor = actionSelector.SelectAction(GetContext);
            HttpActionDescriptor postActionDescriptor = actionSelector.SelectAction(PostContext);

            Assert.Equal("Get", getActionDescriptor.ActionName);
            Assert.Equal("Post", postActionDescriptor.ActionName);
        }

        [Fact]
        public void SelectAction_RespectsDirectRoutes()
        {
            var actionSelector = new ApiControllerActionSelector();
            HttpControllerContext context = ContextUtil.CreateControllerContext();
            context.Request = new HttpRequestMessage { Method = HttpMethod.Get };
            var controllerDescriptor = new HttpControllerDescriptor(context.Configuration, "Users", typeof(UsersController));
            context.ControllerDescriptor = controllerDescriptor;
            ReflectedHttpActionDescriptor directRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["Get"].First();
            context.RouteData.Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { directRouteAction });

            HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(context);

            Assert.Same(directRouteAction, actionDescriptor);
        }

        [Fact]
        public void SelectAction_WithDirectRoutes_RespectsRouteOrder()
        {
            // Arrange
            var actionSelector = new ApiControllerActionSelector();
            HttpControllerContext context = ContextUtil.CreateControllerContext();
            context.Request = new HttpRequestMessage { Method = HttpMethod.Get };
            var controllerDescriptor = new HttpControllerDescriptor(context.Configuration, "MultipleGet", typeof(MultipleGetController));
            context.ControllerDescriptor = controllerDescriptor;
            ReflectedHttpActionDescriptor firstDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetA"].Single();
            HttpRouteData[] subRouteData = new HttpRouteData[2];
            subRouteData[0] = new HttpRouteData(new HttpRoute());
            subRouteData[1] = new HttpRouteData(new HttpRoute());
            context.RouteData.Values.Add(RouteCollectionRoute.SubRouteDataKey, subRouteData);
            subRouteData[0].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { firstDirectRouteAction });
            subRouteData[0].Route.DataTokens.Add("order", 1);
            ReflectedHttpActionDescriptor secondDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetB"].Single();
            subRouteData[1].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { secondDirectRouteAction });
            subRouteData[1].Route.DataTokens.Add("order", 2);

            // Act
            HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(context);

            // Assert
            Assert.Same(firstDirectRouteAction, actionDescriptor);
        }

        [Fact]
        public void SelectAction_WithDirectRoutes_RespectsPrecedence()
        {
            // Arrange
            var actionSelector = new ApiControllerActionSelector();
            HttpControllerContext context = ContextUtil.CreateControllerContext();
            context.Request = new HttpRequestMessage { Method = HttpMethod.Get };
            var controllerDescriptor = new HttpControllerDescriptor(context.Configuration, "MultipleGet", typeof(MultipleGetController));
            context.ControllerDescriptor = controllerDescriptor;
            ReflectedHttpActionDescriptor firstDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetA"].Single();
            HttpRouteData[] subRouteData = new HttpRouteData[2];
            subRouteData[0] = new HttpRouteData(new HttpRoute());
            subRouteData[1] = new HttpRouteData(new HttpRoute());
            context.RouteData.Values.Add(RouteCollectionRoute.SubRouteDataKey, subRouteData);
            subRouteData[0].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { firstDirectRouteAction });
            subRouteData[0].Route.DataTokens.Add("precedence", 2M);
            ReflectedHttpActionDescriptor secondDirectRouteAction = (ReflectedHttpActionDescriptor)actionSelector.GetActionMapping(controllerDescriptor)["GetB"].Single();
            subRouteData[1].Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { secondDirectRouteAction });
            subRouteData[1].Route.DataTokens.Add("precedence", 1M);

            // Act
            HttpActionDescriptor actionDescriptor = actionSelector.SelectAction(context);

            // Assert
            Assert.Same(secondDirectRouteAction, actionDescriptor);
        }

        [Fact]
        public void SelectAction_Throws_IfContextIsNull()
        {
            ApiControllerActionSelector actionSelector = new ApiControllerActionSelector();

            Assert.ThrowsArgumentNull(
                () => actionSelector.SelectAction(null),
                "controllerContext");
        }

        [Fact]
        public void GetActionMapping_IgnoresNonAction()
        {
            var actionSelector = new ApiControllerActionSelector();
            HttpControllerContext context = ContextUtil.CreateControllerContext();
            context.Request = new HttpRequestMessage { Method = HttpMethod.Get };
            var controllerDescriptor = new HttpControllerDescriptor(context.Configuration, "NonAction", typeof(NonActionController));
            context.ControllerDescriptor = controllerDescriptor;

            var mapping = actionSelector.GetActionMapping(controllerDescriptor);

            Assert.False(mapping.Contains("GetA"));
            Assert.True(mapping.Contains("GetB"));            
        }

        public class NonActionController : ApiController
        {
            [NonAction]
            public HttpResponseMessage GetA() { return null; }

            public HttpResponseMessage GetB() { return null; }
        }

        public class MultipleGetController : ApiController
        {
            public HttpResponseMessage GetA() { return null; }

            public HttpResponseMessage GetB() { return null; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ApiControllerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Filters;
using System.Web.Http.Hosting;
using System.Web.Http.Metadata;
using System.Web.Http.ModelBinding;
using System.Web.Http.Routing;
using System.Web.Http.Services;
using System.Web.Http.Validation;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class ApiControllerTest
    {
        private readonly HttpActionContext _actionContextInstance = ContextUtil.CreateActionContext();
        private readonly HttpConfiguration _configurationInstance = new HttpConfiguration();
        private readonly HttpActionDescriptor _actionDescriptorInstance = new Mock<HttpActionDescriptor>() { CallBase = true }.Object;

        [Fact]
        public async Task Setting_CustomActionInvoker()
        {
            // Arrange
            ApiController api = new UsersController();
            string responseText = "Hello World";
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController));
            controllerContext.ControllerDescriptor = controllerDescriptor;

            Mock<IHttpActionInvoker> mockInvoker = new Mock<IHttpActionInvoker>();
            mockInvoker
                .Setup(invoker => invoker.InvokeActionAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>()))
                .Returns(() =>
                {
                    TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
                    tcs.TrySetResult(new HttpResponseMessage() { Content = new StringContent(responseText) });
                    return tcs.Task;
                });
            controllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionInvoker), mockInvoker.Object);

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(
                controllerContext,
                CancellationToken.None);

            // Assert
            Assert.Equal(responseText, await message.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task Setting_CustomActionSelector()
        {
            // Arrange
            var api = new UsersController();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api);

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController));
            controllerContext.ControllerDescriptor = controllerDescriptor;

            Mock<IHttpActionSelector> mockSelector = new Mock<IHttpActionSelector>();
            mockSelector
                .Setup(invoker => invoker.SelectAction(It.IsAny<HttpControllerContext>()))
                .Returns(() =>
                {
                    Func<HttpResponseMessage> testDelegate = api.Delete;
                    return new ReflectedHttpActionDescriptor
                    {
                        Configuration = controllerContext.Configuration,
                        ControllerDescriptor = controllerDescriptor,
                        MethodInfo = testDelegate.Method
                    };
                });
            controllerDescriptor.Configuration.Services.Replace(typeof(IHttpActionSelector), mockSelector.Object);

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(
                controllerContext,
                CancellationToken.None);

            // Assert
            Assert.Equal("User Deleted", await message.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task Default_Get()
        {
            // Arrange
            ApiController api = new UsersController();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, request: new HttpRequestMessage() { Method = HttpMethod.Get });
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(
                controllerContext,
                CancellationToken.None);

            // Assert
            Assert.Equal("Default User", await message.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task Default_Post()
        {
            // Arrange
            ApiController api = new UsersController();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, request: new HttpRequestMessage() { Method = HttpMethod.Post });
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(
                controllerContext,
                CancellationToken.None);

            // Assert
            Assert.Equal("User Posted", await message.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task Default_Put()
        {
            // Arrange
            ApiController api = new UsersController();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, request: new HttpRequestMessage() { Method = HttpMethod.Put });
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(
                controllerContext,
                CancellationToken.None);

            // Assert
            Assert.Equal("User Updated", await message.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task Default_Delete()
        {
            // Arrange
            ApiController api = new UsersController();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, request: new HttpRequestMessage() { Method = HttpMethod.Delete });
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(
                controllerContext,
                CancellationToken.None);

            // Assert
            Assert.Equal("User Deleted", await message.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task Route_ActionName()
        {
            // Arrange
            ApiController api = new UsersRpcController();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("action", "Admin");
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, routeData: route, request: new HttpRequestMessage() { Method = HttpMethod.Post });
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersRpcController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(controllerContext, CancellationToken.None);
            User user = await message.Content.ReadAsAsync<User>();

            // Assert
            Assert.Equal("Yao", user.FirstName);
            Assert.Equal("Huang", user.LastName);
        }

        [Fact]
        public async Task Route_Get_Action_With_Route_Parameters()
        {
            // Arrange
            ApiController api = new UsersRpcController();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("action", "EchoUser");
            route.Values.Add("firstName", "RouteFirstName");
            route.Values.Add("lastName", "RouteLastName");
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, routeData: route, request: new HttpRequestMessage() { Method = HttpMethod.Post });
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersRpcController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(controllerContext, CancellationToken.None);
            User user = await message.Content.ReadAsAsync<User>();

            // Assert
            Assert.Equal("RouteFirstName", user.FirstName);
            Assert.Equal("RouteLastName", user.LastName);
        }

        [Fact]
        public async Task Route_Get_Action_With_Query_Parameters()
        {
            // Arrange
            ApiController api = new UsersRpcController();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("action", "EchoUser");

            Uri requestUri = new Uri("http://localhost/?firstName=QueryFirstName&lastName=QueryLastName");
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, routeData: route, request: new HttpRequestMessage()
                {
                    Method = HttpMethod.Post,
                    RequestUri = requestUri
                });
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersRpcController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(controllerContext, CancellationToken.None);
            User user = await message.Content.ReadAsAsync<User>();

            // Assert
            Assert.Equal("QueryFirstName", user.FirstName);
            Assert.Equal("QueryLastName", user.LastName);
        }

        [Fact]
        public async Task Route_Post_Action_With_Content_Parameter()
        {
            // Arrange
            ApiController api = new UsersRpcController();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            route.Values.Add("action", "EchoUserObject");
            User postedUser = new User()
            {
                FirstName = "SampleFirstName",
                LastName = "SampleLastName"
            };

            HttpRequestMessage request = new HttpRequestMessage() { Method = HttpMethod.Post };

            // Create a serialized request because this test directly calls the controller
            // which would have normally been working with a serialized request content.
            string serializedUserAsString = null;
            using (HttpRequestMessage tempRequest = new HttpRequestMessage() { Content = new ObjectContent<User>(postedUser, new XmlMediaTypeFormatter()) })
            {
                serializedUserAsString = await tempRequest.Content.ReadAsStringAsync();
            }

            StringContent stringContent = new StringContent(serializedUserAsString);
            stringContent.Headers.ContentType = new MediaTypeHeaderValue("application/xml");
            request.Content = stringContent;

            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, routeData: route, request: request);
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(UsersRpcController));

            // Act
            HttpResponseMessage message = await api.ExecuteAsync(
                controllerContext,
                CancellationToken.None);
            User user = await message.Content.ReadAsAsync<User>();

            // Assert
            Assert.Equal(postedUser.FirstName, user.FirstName);
            Assert.Equal(postedUser.LastName, user.LastName);
        }

        [Fact]
        public async Task Invalid_Action_In_Route()
        {
            // Arrange
            ApiController api = new UsersController();
            HttpRouteData route = new HttpRouteData(new HttpRoute());
            string actionName = "invalidOp";
            route.Values.Add("action", actionName);
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(instance: api, routeData: route, request: new HttpRequestMessage() { Method = HttpMethod.Get });
            Type controllerType = typeof(UsersController);
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, controllerType.Name, controllerType);
            controllerContext.Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            // Act & Assert
            var exception = await Assert.ThrowsAsync<HttpResponseException>(
                () => api.ExecuteAsync(controllerContext, CancellationToken.None));

            Assert.Equal(HttpStatusCode.NotFound, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            Assert.Equal("No action was found on the controller 'UsersController' that matches the name 'invalidOp'.",
                ((HttpError)content.Value)["MessageDetail"]);
        }

        [Fact]
        public async Task ExecuteAsync_InvokesAuthenticationFilters_ThenInvokesAuthorizationFilters_ThenInvokesModelBinding_ThenInvokesActionFilters_ThenInvokesAction()
        {
            List<string> log = new List<string>();
            Mock<ApiController> controllerMock = new Mock<ApiController>() { CallBase = true };
            var controllerContextMock = new Mock<HttpControllerContext>();

            Mock<IActionValueBinder> binderMock = new Mock<IActionValueBinder>();
            Mock<HttpActionBinding> actionBindingMock = new Mock<HttpActionBinding>();
            actionBindingMock.Setup(b => b.ExecuteBindingAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>())).Returns(() => Task.Factory.StartNew(() => { log.Add("model binding"); }));
            binderMock.Setup(b => b.GetBinding(It.IsAny<HttpActionDescriptor>())).Returns(actionBindingMock.Object);
            HttpConfiguration configuration = new HttpConfiguration();

            HttpControllerContext controllerContext = controllerContextMock.Object;
            controllerContext.Configuration = configuration;
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(configuration, "test", typeof(object));
            var actionFilterMock = CreateActionFilterMock((ac, ct, cont) =>
            {
                log.Add("action filters");
                return cont();
            });
            var authorizationFilterMock = CreateAuthorizationFilterMock((ac, ct, cont) =>
            {
                log.Add("authZ filters");
                return cont();
            });
            Mock<IAuthenticationFilter> authenticationFilterMock = new Mock<IAuthenticationFilter>();
            authenticationFilterMock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(),
                It.IsAny<CancellationToken>())).Callback(() =>
                    {
                        log.Add("authN filters authenticate");
                    }).Returns(() => Task.FromResult<object>(null));
            IHttpActionResult innerResult = null;
            Mock<IHttpActionResult> challengeResultMock = new Mock<IHttpActionResult>();
            challengeResultMock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(async () =>
            {
                HttpResponseMessage response = await innerResult.ExecuteAsync(CancellationToken.None);
                log.Add("authN filters challenge");
                return response;
            });
            authenticationFilterMock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
                It.IsAny<CancellationToken>()))
                .Callback<HttpAuthenticationChallengeContext, CancellationToken>((c, t) =>
                {
                    innerResult = c.Result;
                    c.Result = challengeResultMock.Object;
                })
                .Returns(() => Task.FromResult<object>(null));

            var selectorMock = new Mock<IHttpActionSelector>();

            Mock<HttpActionDescriptor> actionDescriptorMock = new Mock<HttpActionDescriptor>();
            actionDescriptorMock.Setup(ad => ad.ActionBinding).Returns(actionBindingMock.Object);
            actionDescriptorMock.Setup(ad => ad.GetFilterPipeline())
                .Returns(new Collection<FilterInfo>(new List<FilterInfo>() { new FilterInfo(actionFilterMock.Object, FilterScope.Action), new FilterInfo(authorizationFilterMock.Object, FilterScope.Action), new FilterInfo(authenticationFilterMock.Object, FilterScope.Action) }));

            selectorMock.Setup(s => s.SelectAction(controllerContext)).Returns(actionDescriptorMock.Object);

            ApiController controller = controllerMock.Object;
            var invokerMock = new Mock<IHttpActionInvoker>();
            invokerMock.Setup(i => i.InvokeActionAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>()))
                       .Returns(() => Task.Factory.StartNew(() =>
                       {
                           log.Add("action");
                           return new HttpResponseMessage();
                       }));
            controllerContext.Configuration.Services.Replace(typeof(IHttpActionInvoker), invokerMock.Object);
            controllerContext.Configuration.Services.Replace(typeof(IHttpActionSelector), selectorMock.Object);
            controllerContext.Configuration.Services.Replace(typeof(IActionValueBinder), binderMock.Object);

            await controller.ExecuteAsync(controllerContext, CancellationToken.None);

            Assert.Equal(new string[] { "authN filters authenticate", "authZ filters", "model binding", "action filters", "action", "authN filters challenge" }, log.ToArray());
        }

        [Fact]
        public void GetFilters_QueriesFilterProvidersFromServices()
        {
            // Arrange
            Mock<DefaultServices> servicesMock = new Mock<DefaultServices> { CallBase = true };
            Mock<IFilterProvider> filterProviderMock = new Mock<IFilterProvider>();
            servicesMock.Setup(r => r.GetServices(typeof(IFilterProvider))).Returns(new object[] { filterProviderMock.Object }).Verifiable();
            _configurationInstance.Services = servicesMock.Object;

            HttpActionDescriptor actionDescriptorMock = new Mock<HttpActionDescriptor>() { CallBase = true }.Object;
            actionDescriptorMock.Configuration = _configurationInstance;

            // Act
            actionDescriptorMock.GetFilterPipeline();

            // Assert
            servicesMock.Verify();
        }

        [Fact]
        public void GetFilters_UsesFilterProvidersToGetFilters()
        {
            // Arrange
            Mock<DefaultServices> servicesMock = new Mock<DefaultServices> { CallBase = true };
            Mock<IFilterProvider> filterProviderMock = new Mock<IFilterProvider>();
            servicesMock.Setup(r => r.GetServices(typeof(IFilterProvider))).Returns(new[] { filterProviderMock.Object });
            _configurationInstance.Services = servicesMock.Object;

            HttpActionDescriptor actionDescriptorMock = new Mock<HttpActionDescriptor>() { CallBase = true }.Object;
            actionDescriptorMock.Configuration = _configurationInstance;

            // Act
            actionDescriptorMock.GetFilterPipeline().ToList();

            // Assert
            filterProviderMock.Verify(fp => fp.GetFilters(_configurationInstance, actionDescriptorMock));
        }

        [Fact]
        public void RequestPropertyGetterSetterWorks()
        {
            Assert.Reflection.Property(new Mock<ApiController>().Object,
                c => c.Request, expectedDefaultValue: null, allowNull: false,
                roundTripTestValue: new HttpRequestMessage());
        }

        [Fact]
        public void ConfigurationPropertyGetterSetterWorks()
        {
            Assert.Reflection.Property(new Mock<ApiController>().Object,
                c => c.Configuration, expectedDefaultValue: null, allowNull: false,
                roundTripTestValue: new HttpConfiguration());
        }

        [Fact]
        public void ModelStatePropertyGetterWorks()
        {
            // Arrange
            ApiController controller = new Mock<ApiController>().Object;

            // Act
            ModelStateDictionary expected = new ModelStateDictionary();
            expected.Add("a", new ModelState() { Value = new ValueProviders.ValueProviderResult("result", "attempted", CultureInfo.InvariantCulture) });

            controller.ModelState.Add("a", new ModelState() { Value = new ValueProviders.ValueProviderResult("result", "attempted", CultureInfo.InvariantCulture) });

            // Assert
            Assert.Equal(expected.Count, controller.ModelState.Count);
        }

        // TODO: Move these tests to ActionDescriptorTest
        [Fact]
        public void GetFilters_OrdersFilters()
        {
            // Arrange
            HttpActionDescriptor actionDescriptorMock = new Mock<HttpActionDescriptor>() { CallBase = true }.Object;
            actionDescriptorMock.Configuration = _configurationInstance;

            var globalFilter = new FilterInfo(new TestMultiFilter(), FilterScope.Global);
            var actionFilter = new FilterInfo(new TestMultiFilter(), FilterScope.Action);
            var controllerFilter = new FilterInfo(new TestMultiFilter(), FilterScope.Controller);
            Mock<DefaultServices> servicesMock = BuildFilterProvidingServicesMock(_configurationInstance, actionDescriptorMock, globalFilter, actionFilter, controllerFilter);
            _configurationInstance.Services = servicesMock.Object;

            // Act
            var result = actionDescriptorMock.GetFilterPipeline().ToArray();

            // Assert
            Assert.Equal(new[] { globalFilter, controllerFilter, actionFilter }, result);
        }

        [Fact]
        public void GetFilters_RemovesDuplicateUniqueFiltersKeepingMostSpecificScope()
        {
            // Arrange
            HttpActionDescriptor actionDescriptorMock = new Mock<HttpActionDescriptor>() { CallBase = true }.Object;
            actionDescriptorMock.Configuration = _configurationInstance;

            var multiActionFilter = new FilterInfo(new TestMultiFilter(), FilterScope.Action);
            var multiGlobalFilter = new FilterInfo(new TestMultiFilter(), FilterScope.Global);
            var uniqueControllerFilter = new FilterInfo(new TestUniqueFilter(), FilterScope.Controller);
            var uniqueActionFilter = new FilterInfo(new TestUniqueFilter(), FilterScope.Action);
            Mock<DefaultServices> servicesMock = BuildFilterProvidingServicesMock(
                _configurationInstance, actionDescriptorMock,
                multiActionFilter, multiGlobalFilter, uniqueControllerFilter, uniqueActionFilter);
            _configurationInstance.Services = servicesMock.Object;

            // Act
            var result = actionDescriptorMock.GetFilterPipeline().ToArray();

            // Assert
            Assert.Equal(new[] { multiGlobalFilter, multiActionFilter, uniqueActionFilter }, result);
        }

        [Fact]
        public Task ExecuteAsync_RunsExceptionFilter_WhenActionThrowsException()
        {
            // Arrange
            Exception expectedException = new NotImplementedException();
            ApiController controller = new ExceptionController(expectedException);

            // Act & Assert
            return TestExceptionFilterAsync(controller, expectedException, configure: null);
        }

        [Fact]
        public Task ExecuteAsync_RunsExceptionFilter_WhenActionFilterThrowsException()
        {
            // Arrange
            Exception expectedException = new NotImplementedException();
            ApiController controller = new ExceptionlessController();
            Mock<IActionFilter> filterMock = new Mock<IActionFilter>();
            filterMock.Setup(f => f.ExecuteActionFilterAsync(It.IsAny<HttpActionContext>(),
                It.IsAny<CancellationToken>(), It.IsAny<Func<Task<HttpResponseMessage>>>())).Callback(() =>
            {
                throw expectedException;
            });
            IActionFilter filter = filterMock.Object;

            // Act & Assert
            return TestExceptionFilterAsync(controller, expectedException, (configuration) =>
                { configuration.Filters.Add(filter); });
        }

        [Fact]
        public Task ExecuteAsync_RunsExceptionFilter_WhenAuthorizationFilterThrowsException()
        {
            // Arrange
            Exception expectedException = new NotImplementedException();
            ApiController controller = new ExceptionlessController();
            Mock<IAuthorizationFilter> filterMock = new Mock<IAuthorizationFilter>();
            filterMock.Setup(f => f.ExecuteAuthorizationFilterAsync(It.IsAny<HttpActionContext>(),
                It.IsAny<CancellationToken>(), It.IsAny<Func<Task<HttpResponseMessage>>>())).Callback(() =>
            {
                throw expectedException;
            });
            IAuthorizationFilter filter = filterMock.Object;

            // Act & Assert
            return TestExceptionFilterAsync(controller, expectedException, (configuration) =>
                { configuration.Filters.Add(filter); });
        }

        [Fact]
        public Task ExecuteAsync_RunsExceptionFilter_WhenAuthenticationFilterAuthenticateThrowsException()
        {
            // Arrange
            Exception expectedException = new NotImplementedException();
            ApiController controller = new ExceptionlessController();
            Mock<IAuthenticationFilter> filterMock = new Mock<IAuthenticationFilter>();
            filterMock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(),
                It.IsAny<CancellationToken>())).Callback(() =>
                {
                    throw expectedException;
                });
            IAuthenticationFilter filter = filterMock.Object;

            // Act & Assert
            return TestExceptionFilterAsync(controller, expectedException, (configuration) =>
                { configuration.Filters.Add(filter); });
        }

        [Fact]
        public Task ExecuteAsync_RunsExceptionFilter_WhenAuthenticationFilterChallengeThrowsException()
        {
            // Arrange
            Exception expectedException = new NotImplementedException();
            ApiController controller = new ExceptionlessController();
            Mock<IAuthenticationFilter> filterMock = new Mock<IAuthenticationFilter>();
            filterMock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(),
                It.IsAny<CancellationToken>())).Returns(() => Task.FromResult<object>(null));
            filterMock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
                It.IsAny<CancellationToken>())).Callback(() =>
                {
                    throw expectedException;
                });
            IAuthenticationFilter filter = filterMock.Object;

            // Act & Assert
            return TestExceptionFilterAsync(controller, expectedException, (configuration) =>
                { configuration.Filters.Add(filter); });
        }

        private static async Task TestExceptionFilterAsync(ApiController controller, Exception expectedException,
            Action<HttpConfiguration> configure)
        {
            // Arrange
            Exception actualException = null;
            IHttpRouteData routeData = new HttpRouteData(new HttpRoute());

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpConfiguration configuration = new HttpConfiguration())
            using (HttpResponseMessage response = new HttpResponseMessage())
            {
                HttpControllerContext context = new HttpControllerContext(configuration, routeData, request);
                HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(configuration,
                    "Ignored", controller.GetType());
                context.Controller = controller;
                context.ControllerDescriptor = controllerDescriptor;

                if (configure != null)
                {
                    configure.Invoke(configuration);
                }

                Mock<IExceptionFilter> spy = new Mock<IExceptionFilter>();
                spy.Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(),
                    It.IsAny<CancellationToken>())).Returns<HttpActionExecutedContext, CancellationToken>(
                    (c, i) =>
                    {
                        actualException = c.Exception;
                        c.Response = response;
                        return Task.FromResult<object>(null);
                    });

                configuration.Filters.Add(spy.Object);

                // Act
                HttpResponseMessage ignore = await controller.ExecuteAsync(context, CancellationToken.None);
            }

            // Assert
            Assert.Same(expectedException, actualException);
        }

        [Fact]
        public async Task ExecuteAsync_IfActionThrows_CallsExceptionServicesFromConfiguration()
        {
            List<string> log = new List<string>();
            Exception expectedException = new Exception();
            ExceptionController controller = new ExceptionController(expectedException);

            Mock<IExceptionLogger> exceptionLoggerMock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            exceptionLoggerMock
                .Setup(h => h.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns<ExceptionLoggerContext, CancellationToken>((c, i) =>
                {
                    log.Add("logger");
                    return Task.FromResult(0);
                });
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            exceptionHandlerMock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                {
                    log.Add("handler");
                    return Task.FromResult(0);
                });
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(
                controllerContext.Configuration, "Get", typeof(ExceptionController));
            controllerContext.ControllerDescriptor = controllerDescriptor;
            controllerContext.Controller = controller;
            controllerContext.Configuration.Services.Add(typeof(IExceptionLogger), exceptionLogger);
            controllerContext.Configuration.Services.Replace(typeof(IExceptionHandler), exceptionHandler);
            controllerContext.Configuration.Filters.Add(CreateStubExceptionFilter());

            // Act & Assert
            var exception = await Assert.ThrowsAsync<Exception>(() => controller.ExecuteAsync(controllerContext, CancellationToken.None));

            Assert.Same(expectedException, exception);
            Assert.Equal(new string[] { "logger", "handler" }, log.ToArray());
        }

        [Fact]
        public async Task ApiControllerCannotBeReused()
        {
            // Arrange
            var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
            var singletonController = new Mock<ApiController> { CallBase = true }.Object;
            var mockDescriptor = new Mock<HttpControllerDescriptor>(config, "MyMock", typeof(ApiController)) { CallBase = true };
            mockDescriptor.Setup(d => d.CreateController(It.IsAny<HttpRequestMessage>())).Returns(singletonController);
            var mockSelector = new Mock<DefaultHttpControllerSelector>(config) { CallBase = true };
            mockSelector.Setup(s => s.SelectController(It.IsAny<HttpRequestMessage>())).Returns(mockDescriptor.Object);
            config.Routes.MapHttpRoute("default", "", new { controller = "MyMock" });
            config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
            var server = new HttpServer(config);
            var invoker = new HttpMessageInvoker(server);

            // Act
            HttpResponseMessage response1 = await invoker.SendAsync(new HttpRequestMessage(HttpMethod.Get, "http://localhost/"), CancellationToken.None);
            HttpResponseMessage response2 = await invoker.SendAsync(new HttpRequestMessage(HttpMethod.Get, "http://localhost/"), CancellationToken.None);

            // Assert
            Assert.NotEqual(HttpStatusCode.InternalServerError, response1.StatusCode);
            Assert.Equal(HttpStatusCode.InternalServerError, response2.StatusCode);
            Assert.Contains("Cannot reuse an 'ApiController' instance. 'ApiController' has to be constructed per incoming message.", await response2.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task ApiControllerPutsSelfInRequestResourcesToBeDisposed()
        {
            // Arrange
            var config = new HttpConfiguration();
            config.Routes.MapHttpRoute("default", "", new { controller = "SpyDispose" });
            var server = new HttpServer(config);
            var invoker = new HttpMessageInvoker(server);
            var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/");
            await invoker.SendAsync(request, CancellationToken.None);

            // Act
            request.DisposeRequestResources();

            // Assert
            Assert.True(SpyDisposeController.DisposeWasCalled);
        }

        [Fact]
        public void ControllerContextDefault_IsNonNull()
        {
            // Arrange
            ApiController controller = CreateFakeController();

            // Act
            HttpControllerContext context = controller.ControllerContext;

            // Assert
            Assert.NotNull(context);
        }

        [Fact]
        public void RequestGet_ReturnsControllerContextRequest()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                controller.ControllerContext = new HttpControllerContext
                {
                    Request = expectedRequest
                };

                // Act
                HttpRequestMessage request = controller.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void RequestSet_Throws_WhenNull()
        {
            // Arrange
            ApiController controller = CreateFakeController();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { controller.Request = null; }, "value");
        }

        [Fact]
        public void RequestSet_UpdatesControllerContextRequest()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpControllerContext controllerContext = CreateControllerContext();
                controller.ControllerContext = controllerContext;

                // Act
                controller.Request = expectedRequest;

                // Assert
                Assert.Same(expectedRequest, controllerContext.Request);
            }
        }

        [Fact]
        public void RequestSet_UpdatesRequestRequestContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext expectedRequestContext = CreateRequestContext();
                controller.RequestContext = expectedRequestContext;

                // Act
                controller.Request = request;

                // Assert
                Assert.Same(expectedRequestContext, request.GetRequestContext());
            }
        }

        [Fact]
        public void RequestSet_Throws_WhenRequestHasConflictingRequestContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext otherRequestContext = CreateRequestContext();
                request.SetRequestContext(otherRequestContext);
                Assert.NotSame(controller.RequestContext, otherRequestContext); // Guard

                // Act & Assert
                Assert.Throws<InvalidOperationException>(() => { controller.Request = request; },
                    "The request context property on the request must be null or match ApiController.RequestContext.");
            }
        }

        [Fact]
        public void RequestSet_UpdatesRequestRequestContext_WhenRequestHasNoContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext expectedRequestContext = CreateRequestContext();
                controller.RequestContext = expectedRequestContext;
                Assert.Null(request.GetRequestContext()); // Guard

                // Act
                controller.Request = request;

                // Assert
                Assert.Same(expectedRequestContext, request.GetRequestContext());
            }
        }

        [Fact]
        public void RequestSet_WithConfigurationPropertyAndDefaultRequestContext_UpdatesConfiguration()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = new HttpConfiguration())
            {
                ApiController controller = CreateFakeController();
                request.SetConfiguration(expectedConfiguration);
                controller.Request = request;

                // Act
                HttpConfiguration configuration = controller.Configuration;

                // Assert
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void RequestContextSet_LeavesRequestRequestContextUnchanged_WhenRequestHasControllerRequestContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext expectedRequestContext = controller.RequestContext;
                request.SetRequestContext(expectedRequestContext);

                // Act
                controller.Request = request;

                // Assert
                HttpRequestContext requestContext = request.GetRequestContext();
                Assert.Same(expectedRequestContext, requestContext);
            }
        }

        [Fact]
        public void RequestSet_UpdatesRequestBackedContextRequest()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                RequestBackedHttpRequestContext context = Assert.IsType<RequestBackedHttpRequestContext>(controller.RequestContext); // Guard

                // Act
                controller.Request = expectedRequest;

                // Assert
                Assert.Same(expectedRequest, context.Request);
            }
        }

        [Fact]
        public void RequestContextGet_ReturnsControllerContextRequestContext()
        {
            // Arrange
            HttpControllerContext controllerContext = CreateControllerContext();
            HttpRequestContext expectedRequestContext = CreateRequestContext();
            controllerContext.RequestContext = expectedRequestContext;
            ApiController controller = CreateFakeController();
            controller.ControllerContext = controllerContext;

            // Act
            HttpRequestContext requestContext = controller.RequestContext;

            // Assert
            Assert.Same(expectedRequestContext, requestContext);
        }

        [Fact]
        public void RequestContextSet_Throws_WhenNull()
        {
            // Arrange
            ApiController controller = CreateFakeController();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { controller.RequestContext = null; }, "value");
        }

        [Fact]
        public void RequestContextSet_UpdatesControllerContextRequestContext()
        {
            // Arrange
            ApiController controller = CreateFakeController();
            HttpControllerContext controllerContext = CreateControllerContext();
            controller.ControllerContext = controllerContext;
            HttpRequestContext expectedRequestContext = CreateRequestContext();

            // Act
            controller.RequestContext = expectedRequestContext;

            // Assert
            Assert.Same(expectedRequestContext, controllerContext.RequestContext);
        }

        [Fact]
        public void RequestContextSet_UpdatesRequestRequestContext_WhenRequestIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext expectedRequestContext = CreateRequestContext();
                controller.Request = request;

                // Act
                controller.RequestContext = expectedRequestContext;

                // Assert
                HttpRequestContext requestContext = request.GetRequestContext();
                Assert.Same(expectedRequestContext, requestContext);
            }
        }

        [Fact]
        public void RequestContextSet_Throws_WhenRequestIsPresentWithConflictingRequestContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext otherRequestContext = CreateRequestContext();
                controller.Request = request;
                request.SetRequestContext(otherRequestContext);
                HttpRequestContext requestContext = CreateRequestContext();

                // Act & Assert
                Assert.Throws<InvalidOperationException>(() => { controller.RequestContext = requestContext; },
                    "The request context property on the request must be null or match ApiController.RequestContext.");
            }
        }

        [Fact]
        public void RequestContextSet_UpdatesRequestRequestContext_WhenRequestIsPresentWithNoContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext expectedRequestContext = CreateRequestContext();
                controller.Request = request;
                request.Properties.Remove(HttpPropertyKeys.RequestContextKey);

                // Act
                controller.RequestContext = expectedRequestContext;

                // Assert
                HttpRequestContext requestContext = request.GetRequestContext();
                Assert.Same(expectedRequestContext, requestContext);
            }
        }

        [Fact]
        public void RequestContextSet_UpdatesRequestRequestContext_WhenRequestIsPresentWithExistingContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext expectedRequestContext = CreateRequestContext();
                controller.Request = request;
                request.SetRequestContext(controller.RequestContext);

                // Act
                controller.RequestContext = expectedRequestContext;

                // Assert
                HttpRequestContext requestContext = request.GetRequestContext();
                Assert.Same(expectedRequestContext, requestContext);
            }
        }

        [Fact]
        public void RequestContextSet_LeavesRequestRequestContextUnchanged_WhenRequestIsPresentWithNewContext()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ApiController controller = CreateFakeController();
                HttpRequestContext expectedRequestContext = CreateRequestContext();
                controller.Request = request;
                request.SetRequestContext(expectedRequestContext);

                // Act
                controller.RequestContext = expectedRequestContext;

                // Assert
                HttpRequestContext requestContext = request.GetRequestContext();
                Assert.Same(expectedRequestContext, requestContext);
            }
        }

        [Fact]
        public void RequestContextDefault_IsRequestBacked()
        {
            // Arrange
            ApiController controller = CreateFakeController();

            // Act
            HttpRequestContext context = controller.RequestContext;

            // Assert
            Assert.IsType<RequestBackedHttpRequestContext>(context);
        }

        [Fact]
        public void UserGet_ReturnsContextPrincipal()
        {
            // Arrange
            ApiController controller = CreateFakeController();
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            controller.RequestContext = new HttpRequestContext
            {
                Principal = expectedPrincipal
            };

            // Act
            IPrincipal principal = controller.User;

            // Assert
            Assert.Same(expectedPrincipal, principal);
        }

        [Fact]
        public void UserSet_UpdatesContextPrincipal()
        {
            // Arrange
            ApiController controller = CreateFakeController();
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            HttpRequestContext context = new HttpRequestContext();
            controller.RequestContext = context;

            // Act
            controller.User = expectedPrincipal;

            // Assert
            Assert.Same(expectedPrincipal, context.Principal);
        }

        [Fact]
        public void Validate_ThrowsInvalidOperationException_IfConfigurationIsNull()
        {
            // Arrange
            TestController controller = new TestController();
            TestEntity entity = new TestEntity();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => controller.Validate(entity),
                "ApiController.Configuration must not be null.");
        }

        [Fact]
        public void Validate_DoesNothing_IfValidatorIsNull()
        {
            // Arrange
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Services.Replace(typeof(IBodyModelValidator), null);
            TestEntity entity = new TestEntity { ID = 9999999 };

            TestController controller = new TestController { Configuration = configuration };

            // Act
            controller.Validate(entity);

            // Assert
            Assert.True(controller.ModelState.IsValid);
        }

        [Fact]
        [ReplaceCulture]
        public void Validate_CallsValidateOnConfiguredValidator_UsingConfiguredMetadataProvider()
        {
            // Arrange
            Mock<IBodyModelValidator> validator = new Mock<IBodyModelValidator>();
            Mock<ModelMetadataProvider> metadataProvider = new Mock<ModelMetadataProvider>();

            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Services.Replace(typeof(IBodyModelValidator), validator.Object);
            configuration.Services.Replace(typeof(ModelMetadataProvider), metadataProvider.Object);

            TestController controller = new TestController { Configuration = configuration };
            TestEntity entity = new TestEntity { ID = 42 };

            // Act
            controller.Validate(entity);

            // Assert
            validator.Verify(
                v => v.Validate(entity, typeof(TestEntity), metadataProvider.Object, controller.ActionContext, String.Empty),
                Times.Once());
            Assert.True(controller.ModelState.IsValid);
        }

        [Fact]
        [ReplaceCulture]
        public void Validate_SetsModelStateErrors_ForInvalidModels()
        {
            // Arrange
            HttpConfiguration configuration = new HttpConfiguration();
            TestController controller = new TestController { Configuration = configuration };
            TestEntity entity = new TestEntity { ID = -1 };

            // Act
            controller.Validate(entity);

            // Assert
            Assert.False(controller.ModelState.IsValid);
            Assert.Equal("The field ID must be between 0 and 100.", controller.ModelState["ID"].Errors[0].ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void Validate_SetsModelStateErrorsUnderRightPrefix_ForInvalidModels()
        {
            // Arrange
            HttpConfiguration configuration = new HttpConfiguration();
            TestController controller = new TestController { Configuration = configuration };
            TestEntity entity = new TestEntity { ID = -1 };

            // Act
            controller.Validate(entity, keyPrefix: "prefix");

            // Assert
            Assert.False(controller.ModelState.IsValid);
            Assert.Equal("The field ID must be between 0 and 100.",
                controller.ModelState["prefix.ID"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void Validate_DoesNotThrow_ForValidModels()
        {
            // Arrange
            HttpConfiguration configuration = new HttpConfiguration();
            TestController controller = new TestController { Configuration = configuration };
            TestEntity entity = new TestEntity { ID = 42 };

            // Act && Assert
            Assert.DoesNotThrow(() => controller.Validate(entity));
        }

        private class TestController : ApiController
        {
        }

        private class TestEntity
        {
            [Range(0, 100)]
            public int ID { get; set; }
        }

        private Mock<IAuthorizationFilter> CreateAuthorizationFilterMock(Func<HttpActionContext, CancellationToken, Func<Task<HttpResponseMessage>>, Task<HttpResponseMessage>> implementation)
        {
            Mock<IAuthorizationFilter> filterMock = new Mock<IAuthorizationFilter>();
            filterMock.Setup(f => f.ExecuteAuthorizationFilterAsync(It.IsAny<HttpActionContext>(),
                                                                    CancellationToken.None,
                                                                    It.IsAny<Func<Task<HttpResponseMessage>>>()))
                      .Returns(implementation)
                      .Verifiable();
            return filterMock;
        }

        private Mock<IActionFilter> CreateActionFilterMock(Func<HttpActionContext, CancellationToken, Func<Task<HttpResponseMessage>>, Task<HttpResponseMessage>> implementation)
        {
            Mock<IActionFilter> filterMock = new Mock<IActionFilter>();
            filterMock.Setup(f => f.ExecuteActionFilterAsync(It.IsAny<HttpActionContext>(),
                                                             CancellationToken.None,
                                                             It.IsAny<Func<Task<HttpResponseMessage>>>()))
                      .Returns(implementation)
                      .Verifiable();
            return filterMock;
        }

        private static HttpControllerContext CreateControllerContext()
        {
            return new HttpControllerContext();
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static ApiController CreateFakeController()
        {
            return new ExceptionlessController();
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpRequestContext CreateRequestContext()
        {
            return new HttpRequestContext();
        }

        private static IExceptionFilter CreateStubExceptionFilter()
        {
            Mock<IExceptionFilter> mock = new Mock<IExceptionFilter>(MockBehavior.Strict);
            mock
                .Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(),
                    It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock.Object;
        }

        private static Mock<DefaultServices> BuildFilterProvidingServicesMock(HttpConfiguration configuration, HttpActionDescriptor action, params FilterInfo[] filters)
        {
            var servicesMock = new Mock<DefaultServices> { CallBase = true };
            var filterProviderMock = new Mock<IFilterProvider>();
            servicesMock.Setup(r => r.GetServices(typeof(IFilterProvider))).Returns(new[] { filterProviderMock.Object });
            filterProviderMock.Setup(fp => fp.GetFilters(configuration, action)).Returns(filters);
            return servicesMock;
        }

        public class ExceptionController : ApiController
        {
            private readonly Exception _exception;

            public ExceptionController(Exception exception)
            {
                _exception = exception;
            }

            public void Get()
            {
                throw _exception;
            }
        }

        public class ExceptionlessController : ApiController
        {
            public void Get()
            {
            }
        }

        public class SpyDisposeController : ApiController
        {
            public static bool DisposeWasCalled = false;

            public SpyDisposeController()
            {
            }

            public void Get() { }

            protected override void Dispose(bool disposing)
            {
                DisposeWasCalled = true;
                base.Dispose(disposing);
            }
        }

        /// <summary>
        /// Simple IFilter implementation with AllowMultiple = true
        /// </summary>
        public class TestMultiFilter : IFilter
        {
            public bool AllowMultiple
            {
                get { return true; }
            }
        }

        /// <summary>
        /// Simple IFilter implementation with AllowMultiple = false
        /// </summary>
        public class TestUniqueFilter : IFilter
        {
            public bool AllowMultiple
            {
                get { return false; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ApiControllerTestabilityTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class ApiControllerTestabilityTest
    {
        [Fact]
        public void Post_With_EmptyRequest_And_MockUrlHelper()
        {
            // Arrange
            CustomersController controller = new CustomersController();
            controller.Configuration = new HttpConfiguration();
            controller.Request = new HttpRequestMessage();

            Mock<UrlHelper> url = new Mock<UrlHelper>();
            url.Setup(u => u.Link("default", new { id = 42 })).Returns("http://location_header/").Verifiable();
            controller.Url = url.Object;

            // Act
            var result = controller.Post(new Customer { ID = 42 });

            // Assert
            Customer customer;
            Assert.Equal("http://location_header/", result.Headers.Location.AbsoluteUri);
            Assert.True(result.TryGetContentValue<Customer>(out customer));
            Assert.Equal(42, customer.ID);
        }

        [Fact]
        public void Post_With_EmptyConfiguration_ThrowsNoRoute()
        {
            // Arrange
            CustomersController controller = new CustomersController();
            controller.Configuration = new HttpConfiguration();
            controller.Request = new HttpRequestMessage();

            // Act
            Assert.ThrowsArgument(
                () => controller.Post(new Customer { ID = 42 }),
                "name",
                "A route named 'default' could not be found in the route collection.");
        }

        [Fact]
        public void Post_With_InitializeConfigurationAndRequestAndRouteData()
        {
            // Arrange
            CustomersController controller = new CustomersController();
            controller.Configuration = new HttpConfiguration();
            controller.Configuration.Routes.MapHttpRoute("default", "{controller}/{id}", new { id = RouteParameter.Optional });
            controller.RequestContext.RouteData = new HttpRouteData(new HttpRoute(), new HttpRouteValueDictionary { { "controller", "Customers" } });
            controller.Request = new HttpRequestMessage { RequestUri = new Uri("http://locahost/Customers") };

            // Act
            var result = controller.Post(new Customer { ID = 42 });

            // Assert
            Customer customer;
            Assert.Equal("http://locahost/Customers/42", result.Headers.Location.AbsoluteUri);
            Assert.True(result.TryGetContentValue<Customer>(out customer));
            Assert.Equal(42, customer.ID);
        }

        private class CustomersController : ApiController
        {
            public HttpResponseMessage Post(Customer c)
            {
                var response = Request.CreateResponse(HttpStatusCode.Created, c);
                response.Headers.Location = new Uri(Url.Link("default", new { id = c.ID }));
                return response;
            }
        }

        private class Customer
        {
            public int ID { get; set; }

            public string Name { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/Apis/User.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Web.Http
{
    public class User
    {
        public string FirstName { get; set; }
        public string LastName { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/Apis/UsersController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;

namespace System.Web.Http
{
    public class UsersController : ApiController
    {
        public HttpResponseMessage Get()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent("Default User")
            };
        }

        public HttpResponseMessage Post()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent("User Posted")
            };
        }

        public HttpResponseMessage Put()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent("User Updated")
            };
        }

        public HttpResponseMessage Delete()
        {
            return new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent("User Deleted")
            };
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/Apis/UsersRpcController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading.Tasks;

namespace System.Web.Http
{
    public class UsersRpcController : ApiController
    {
        public User EchoUser(string firstName, string lastName)
        {
            return new User()
            {
                FirstName = firstName,
                LastName = lastName,
            };
        }

        public Task<User> EchoUserAsync(string firstName, string lastName)
        {
            return Task.FromResult(new User()
            {
                FirstName = firstName,
                LastName = lastName,
            });
        }

        [Authorize]
        [HttpGet]
        public User AddAdmin(string firstName, string lastName)
        {
            return new User()
            {
                FirstName = firstName,
                LastName = lastName,
            };
        }

        public User RetriveUser(int id)
        {
            return new User()
            {
                LastName = "UserLN" + id,
                FirstName = "UserFN" + id
            };
        }

        public User EchoUserObject(User user)
        {
            return user;
        }

        public User Admin()
        {
            return new User
            {
                FirstName = "Yao",
                LastName = "Huang"
            };
        }

        public void DeleteAllUsers()
        {
        }

        public Task DeleteAllUsersAsync()
        {
            return TaskHelpers.Completed();
        }

        public void AddUser([FromBody] User user)
        {
        }

        public Task WrappedTaskReturningMethod()
        {
            return Task.FromResult(TaskHelpers.Completed());
        }

        public object TaskAsObjectReturningMethod()
        {
            return TaskHelpers.Completed();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/AuthenticationFilterResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class AuthenticationFilterResultTests
    {
        [Fact]
        public async Task ExecuteAsync_DelegatesToInnerResult_WhenFiltersIsEmpty()
        {
            // Arrange
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                HttpActionContext context = CreateContext();
                ApiController controller = CreateController();
                IAuthenticationFilter[] filters = new IAuthenticationFilter[0];
                int calls = 0;
                CancellationToken cancellationToken;
                IHttpActionResult innerResult = CreateActionResult((t) =>
                {
                    calls++;
                    cancellationToken = t;
                    return Task.FromResult(expectedResponse);
                });
                IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
                CancellationToken expectedCancellationToken = CreateCancellationToken();

                // Act
                HttpResponseMessage response = await product.ExecuteAsync(expectedCancellationToken);

                // Assert
                Assert.Equal(1, calls);
                Assert.Equal(expectedCancellationToken, cancellationToken);
                Assert.Same(expectedResponse, response);
            }
        }

        [Fact]
        public async Task ExecuteAsync_CallsRequestContextPrincipalGet()
        {
            // Arrange
            HttpActionContext context = CreateContext();
            ApiController controller = CreateController();
            IAuthenticationFilter filter = CreateStubFilter();
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
            int calls = 0;
            Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>();
            requestContextMock.Setup(c => c.Principal).Callback(() =>
                {
                    calls++;
                });
            controller.RequestContext = requestContextMock.Object;
            IHttpActionResult innerResult = CreateStubActionResult();

            IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);

            // Act
            HttpResponseMessage response = await product.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Equal(1, calls);
        }

        [Fact]
        public async Task ExecuteAsync_CallsFilterAuthenticateAsync()
        {
            // Arrange
            HttpActionContext expectedActionContext = CreateContext();
            ApiController controller = CreateController();
            int calls = 0;
            HttpAuthenticationContext authenticationContext = null;
            CancellationToken cancellationToken = default(CancellationToken);
            IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
            {
                calls++;
                authenticationContext = c;
                cancellationToken = t;
            });
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>(MockBehavior.Strict);
            requestContextMock.Setup(c => c.Principal).Returns(expectedPrincipal);
            controller.RequestContext = requestContextMock.Object;
            IHttpActionResult innerResult = CreateStubActionResult();
            CancellationToken expectedCancellationToken = CreateCancellationToken();

            IHttpActionResult product = CreateProductUnderTest(expectedActionContext, controller, filters,
                innerResult);

            // Act
            await product.ExecuteAsync(expectedCancellationToken);

            // Assert
            Assert.Equal(1, calls);
            Assert.NotNull(authenticationContext);
            HttpActionContext actionContext = authenticationContext.ActionContext;
            Assert.Same(expectedActionContext, actionContext);
            IPrincipal principal = authenticationContext.Principal;
            Assert.Same(expectedPrincipal, principal);
            Assert.Equal(expectedCancellationToken, cancellationToken);
        }

        [Fact]
        public async Task ExecuteAsync_DelegatesToErrorResult_WhenFilterReturnsFailure()
        {
            // Arrange
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                HttpActionContext context = CreateContext();
                ApiController controller = CreateController();
                int calls = 0;
                CancellationToken cancellationToken;
                IHttpActionResult errorResult = CreateActionResult((t) =>
                {
                    calls++;
                    cancellationToken = t;
                    return Task.FromResult(expectedResponse);
                });
                IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
                {
                    c.ErrorResult = errorResult;
                });
                IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
                IHttpActionResult innerResult = CreateDummyActionResult();
                IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
                CancellationToken expectedCancellationToken = CreateCancellationToken();

                // Act
                HttpResponseMessage response = await product.ExecuteAsync(expectedCancellationToken);

                // Assert
                Assert.Equal(1, calls);
                Assert.Equal(expectedCancellationToken, cancellationToken);
                Assert.Same(expectedResponse, response);
            }
        }

        [Fact]
        public async Task ExecuteAsync_DoesNotCallSecondFilterAuthenticateOrInnerResult_WhenFirstFilterReturnsFailure()
        {
            // Arrange
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                HttpActionContext context = CreateContext();
                ApiController controller = CreateController();
                IHttpActionResult errorResult = CreateActionResult((t) => Task.FromResult(expectedResponse));
                IAuthenticationFilter firstFilter = CreateAuthenticationFilter((c, t) =>
                {
                    c.ErrorResult = errorResult;
                });
                int calls = 0;
                IAuthenticationFilter secondFilter = CreateAuthenticationFilter((c, t) =>
                    {
                        calls++;
                    });
                IAuthenticationFilter[] filters = new IAuthenticationFilter[] { firstFilter, secondFilter };
                IHttpActionResult innerResult = CreateDummyActionResult();
                IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);
                CancellationToken expectedCancellationToken = CreateCancellationToken();

                // Act
                await product.ExecuteAsync(expectedCancellationToken);

                // Assert
                Assert.Equal(0, calls);
            }
        }

        [Fact]
        public async Task ExecuteAsync_UpdatesRequestContextPrincipal_WhenFilterReturnsSuccess()
        {
            // Arrange
            HttpActionContext context = CreateContext();
            ApiController controller = CreateController();
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
            {
                c.Principal = expectedPrincipal;
            });
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
            IPrincipal principal = null;
            IHttpActionResult innerResult = CreateActionResult((c) =>
            {
                principal = controller.User;
                return Task.FromResult<HttpResponseMessage>(null);
            });

            IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);

            // Act
            await product.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Same(expectedPrincipal, principal);
        }

        [Fact]
        public async Task ExecuteAsync_PassesPrincipalFromFirstFilterSuccessToSecondFilter()
        {
            // Arrange
            HttpActionContext context = CreateContext();
            ApiController controller = CreateController();
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            IAuthenticationFilter firstFilter = CreateAuthenticationFilter((c, t) =>
            {
                c.Principal = expectedPrincipal;
            });
            IPrincipal principal = null;
            IAuthenticationFilter secondFilter = CreateAuthenticationFilter((c, t) =>
            {
                if (c != null)
                {
                    principal = c.Principal;
                }
            });
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { firstFilter, secondFilter };
            IHttpActionResult innerResult = CreateStubActionResult();

            IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);

            // Act
            await product.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Same(expectedPrincipal, principal);
        }

        [Fact]
        public async Task ExecuteAsync_OnlySetsPrincipalOnce_WhenMultipleFiltersReturnSuccess()
        {
            // Arrange
            HttpActionContext context = CreateContext();
            ApiController controller = CreateController();
            IPrincipal principal = CreateDummyPrincipal();
            IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) =>
            {
                c.Principal = principal;
            });
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter, filter };
            int calls = 0;
            Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>();
            requestContextMock
                .SetupSet(c => c.Principal = It.IsAny<IPrincipal>())
                .Callback<IPrincipal>((i) => { calls++; });
            controller.RequestContext = requestContextMock.Object;
            IHttpActionResult innerResult = CreateStubActionResult();

            IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);

            // Act
            await product.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Equal(1, calls);
        }

        [Fact]
        public async Task ExecuteAsync_DoesNotSetPrincipal_WhenNoFilterReturnsSuccess()
        {
            // Arrange
            HttpActionContext context = CreateContext();
            ApiController controller = CreateController();
            IPrincipal principal = CreateDummyPrincipal();
            IAuthenticationFilter filter = CreateAuthenticationFilter((c, t) => Task.FromResult<object>(null));
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter, filter };
            int calls = 0;
            Mock<HttpRequestContext> requestContextMock = new Mock<HttpRequestContext>();
            requestContextMock
                .SetupSet(c => c.Principal = It.IsAny<IPrincipal>())
                .Callback<IPrincipal>((i) => { calls++; });
            controller.RequestContext = requestContextMock.Object;
            IHttpActionResult innerResult = CreateStubActionResult();

            IHttpActionResult product = CreateProductUnderTest(context, controller, filters, innerResult);

            // Act
            await product.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Equal(0, calls);
        }

        [Fact]
        public async Task ExecuteAsync_CallsFilterChallengeAsync_WithInnerResult_WhenNoFilterReturnsFailure()
        {
            // Arrange
            HttpActionContext expectedContext = CreateContext();
            ApiController controller = CreateController();
            int calls = 0;
            HttpActionContext context = null;
            IHttpActionResult innerResult = null;
            CancellationToken cancellationToken = default(CancellationToken);
            IAuthenticationFilter filter = CreateAuthenticationFilterChallenge((c, t) =>
            {
                calls++;
                context = c.ActionContext;
                innerResult = c.Result;
                cancellationToken = t;
            });
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
            IHttpActionResult expectedInnerResult = CreateStubActionResult();
            CancellationToken expectedCancellationToken = CreateCancellationToken();

            IHttpActionResult product = CreateProductUnderTest(expectedContext, controller, filters,
                expectedInnerResult);

            // Act
            await product.ExecuteAsync(expectedCancellationToken);

            // Assert
            Assert.Equal(1, calls);
            Assert.Same(expectedContext, context);
            Assert.Same(expectedInnerResult, innerResult);
            Assert.Equal(expectedCancellationToken, cancellationToken);
        }

        [Fact]
        public async Task ExecuteAsync_CallsFilterChallengeAsync_WithErrorResult_WhenFilterReturnsFailure()
        {
            // Arrange
            HttpActionContext expectedContext = CreateContext();
            ApiController controller = CreateController();
            IHttpActionResult expectedErrorResult = CreateDummyActionResult();
            int calls = 0;
            HttpActionContext context = null;
            IHttpActionResult innerResult = null;
            CancellationToken cancellationToken = default(CancellationToken);
            IAuthenticationFilter filter = CreateAuthenticationFilter(
                (c, t) =>
                {
                    c.ErrorResult = expectedErrorResult;
                },
                (c, t) =>
                {
                    calls++;
                    context = c.ActionContext;
                    innerResult = c.Result;
                    cancellationToken = t;

                    c.Result = CreateStubActionResult();
                });
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
            IHttpActionResult originalInnerResult = CreateDummyActionResult();
            CancellationToken expectedCancellationToken = CreateCancellationToken();

            IHttpActionResult product = CreateProductUnderTest(expectedContext, controller, filters,
                originalInnerResult);

            // Act
            await product.ExecuteAsync(expectedCancellationToken);

            // Assert
            Assert.Equal(1, calls);
            Assert.Same(expectedContext, context);
            Assert.Same(expectedErrorResult, innerResult);
            Assert.Equal(expectedCancellationToken, cancellationToken);
        }

        [Fact]
        public async Task ExecuteAsync_CallsSecondFilterChallengeAsync_WithFirstChallengeResult()
        {
            // Arrange
            HttpActionContext expectedContext = CreateContext();
            ApiController controller = CreateController();
            IHttpActionResult expectedInnerResult = CreateDummyActionResult();
            int calls = 0;
            HttpActionContext context = null;
            IHttpActionResult result = null;
            CancellationToken cancellationToken = default(CancellationToken);
            IAuthenticationFilter firstFilter = CreateAuthenticationFilterChallenge((c, t) =>
            {
                c.Result = expectedInnerResult;
            });
            IAuthenticationFilter secondFilter = CreateAuthenticationFilterChallenge((c, t) =>
            {
                calls++;
                context = c.ActionContext;
                result = c.Result;
                cancellationToken = t;

                c.Result = CreateStubActionResult();
            });
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { firstFilter, secondFilter };
            IHttpActionResult originalInnerResult = CreateDummyActionResult();
            CancellationToken expectedCancellationToken = CreateCancellationToken();

            IHttpActionResult product = CreateProductUnderTest(expectedContext, controller, filters,
                originalInnerResult);

            // Act
            await product.ExecuteAsync(expectedCancellationToken);

            // Assert
            Assert.Equal(1, calls);
            Assert.Same(expectedContext, context);
            Assert.Same(expectedInnerResult, result);
            Assert.Equal(expectedCancellationToken, cancellationToken);
        }

        private static IHttpActionResult CreateActionResult(
            Func<CancellationToken, Task<HttpResponseMessage>> executeAsync)
        {
            Mock<IHttpActionResult> mock = new Mock<IHttpActionResult>(MockBehavior.Strict);
            CancellationToken cancellationToken;
            mock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>()))
                .Callback<CancellationToken>((t) => { cancellationToken = t; })
                .Returns(() => executeAsync.Invoke(cancellationToken));
            return mock.Object;
        }

        private static IAuthenticationFilter CreateAuthenticationFilter(
            Action<HttpAuthenticationContext, CancellationToken> authenticate)
        {
            Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>();
            mock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(), It.IsAny<CancellationToken>()))
                .Callback<HttpAuthenticationContext, CancellationToken>((c, t) =>
                {
                    authenticate.Invoke(c, t);
                })
                .Returns(() => Task.FromResult<object>(null));
            mock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
                It.IsAny<CancellationToken>()))
                .Returns(() => Task.FromResult<object>(null));
            return mock.Object;
        }

        private static IAuthenticationFilter CreateAuthenticationFilter(
            Action<HttpAuthenticationContext, CancellationToken> authenticate,
            Action<HttpAuthenticationChallengeContext, CancellationToken> challenge)
        {
            Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>();
            mock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(), It.IsAny<CancellationToken>()))
                .Callback<HttpAuthenticationContext, CancellationToken>((c, t) =>
                    {
                        authenticate.Invoke(c, t);
                    })
                .Returns(() => Task.FromResult<object>(null));
            mock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
                It.IsAny<CancellationToken>()))
                .Callback<HttpAuthenticationChallengeContext, CancellationToken>((c, t) =>
                    {
                        challenge.Invoke(c, t);
                    })
                .Returns(() => Task.FromResult<object>(null));
            return mock.Object;
        }

        private static IAuthenticationFilter CreateAuthenticationFilterChallenge(
            Action<HttpAuthenticationChallengeContext, CancellationToken> challenge)
        {
            Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>();
            mock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(), It.IsAny<CancellationToken>()))
                .Returns(() => Task.FromResult<object>(null));
            mock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
                It.IsAny<CancellationToken>()))
                .Callback<HttpAuthenticationChallengeContext, CancellationToken>((c, t) =>
                {
                    challenge.Invoke(c, t);
                })
                .Returns(() => Task.FromResult<object>(null));
            return mock.Object;
        }

        private static CancellationToken CreateCancellationToken()
        {
            return new CancellationToken(canceled: true);
        }

        private static HttpActionContext CreateContext()
        {
            return new HttpActionContext();
        }

        private static ApiController CreateController()
        {
            return new Mock<ApiController>().Object;
        }

        private static IHttpActionResult CreateDummyActionResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static AuthenticationFilterResult CreateProductUnderTest(HttpActionContext context,
            ApiController controller, IAuthenticationFilter[] filters, IHttpActionResult innerResult)
        {
            return new AuthenticationFilterResult(context, controller, filters, innerResult);
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static IHttpActionResult CreateStubActionResult()
        {
            Mock<IHttpActionResult> mock = new Mock<IHttpActionResult>(MockBehavior.Strict);
            HttpResponseMessage response = null;
            mock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(() => Task.FromResult(response));
            return mock.Object;
        }

        private static IAuthenticationFilter CreateStubFilter()
        {
            Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>(MockBehavior.Strict);
            mock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(), It.IsAny<CancellationToken>()))
                .Returns(() => Task.FromResult<object>(null));
            mock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
                It.IsAny<CancellationToken>()))
                .Returns(() => Task.FromResult<object>(null));
            return mock.Object;
        }

        private static HttpRequestContext CreateStubRequestContext()
        {
            Mock<HttpRequestContext> mock = new Mock<HttpRequestContext>(MockBehavior.Strict);
            mock.Setup(c => c.Principal).Returns((IPrincipal)null);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/AuthorizationFilterResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class AuthorizationFilterResultTests
    {
        [Fact]
        public async Task ExecuteAsync_ChainsFiltersInOrderFollowedByInnerActionContinuation()
        {
            // Arrange
            HttpActionContext actionContextInstance = ContextUtil.CreateActionContext();
            List<string> log = new List<string>();
            Mock<IAuthorizationFilter> globalFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) =>
            {
                log.Add("globalFilter");
                return continuation();
            });
            Mock<IAuthorizationFilter> actionFilterMock = CreateAuthorizationFilterMock((ctx, ct, continuation) =>
            {
                log.Add("actionFilter");
                return continuation();
            });
            Mock<IHttpActionResult> innerResultMock = new Mock<IHttpActionResult>();
            innerResultMock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(() =>
            {
                log.Add("innerAction");
                return Task.FromResult<HttpResponseMessage>(null);
            });
            IHttpActionResult innerResult = innerResultMock.Object;
            var filters = new IAuthorizationFilter[] {
                globalFilterMock.Object,
                actionFilterMock.Object,
            };
            IHttpActionResult authorizationFilter = new AuthorizationFilterResult(actionContextInstance, filters,
                innerResult);

            // Act
            await authorizationFilter.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Equal(new[] { "globalFilter", "actionFilter", "innerAction" }, log.ToArray());
            globalFilterMock.Verify();
            actionFilterMock.Verify();
        }

        private Mock<IAuthorizationFilter> CreateAuthorizationFilterMock(Func<HttpActionContext, CancellationToken,
            Func<Task<HttpResponseMessage>>, Task<HttpResponseMessage>> implementation)
        {
            Mock<IAuthorizationFilter> filterMock = new Mock<IAuthorizationFilter>();
            filterMock.Setup(f => f.ExecuteAuthorizationFilterAsync(It.IsAny<HttpActionContext>(),
                                                                    CancellationToken.None,
                                                                    It.IsAny<Func<Task<HttpResponseMessage>>>()))
                      .Returns(implementation)
                      .Verifiable();
            return filterMock;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ExceptionFilterResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Filters;
using System.Web.Http.Results;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class ExceptionFilterResultTests
    {
        [Fact]
        public async Task ExecuteAsync_IfInnerResultTaskIsSuccessful_ReturnsSuccessTask()
        {
            // Arrange
            List<string> log = new List<string>();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            var exceptionFilter = CreateExceptionFilter((ec, ct) =>
            {
                log.Add("exceptionFilter");
                return Task.Factory.StartNew(() => { });
            });
            var filters = new IExceptionFilter[] { exceptionFilter };
            IExceptionLogger exceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler exceptionHandler = CreateDummyExceptionHandler();
            var expectedResponse = new HttpResponseMessage();
            var actionResult = CreateStubActionResult(Task.FromResult(expectedResponse));

            IHttpActionResult product = CreateProductUnderTest(actionContext, filters, exceptionLogger,
                exceptionHandler, actionResult);

            // Act
            var response = await product.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Same(expectedResponse, response);
            Assert.Equal(new string[] { }, log.ToArray());
        }

        [Fact]
        public async Task ExecuteAsync_IfInnerResultTaskIsCanceled_ReturnsCanceledTask()
        {
            // Arrange
            List<string> log = new List<string>();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();

            // ExceptionFilters still have a chance to see the cancellation exception
            var exceptionFilter = CreateExceptionFilter((ec, ct) =>
            {
                log.Add("exceptionFilter");
                return Task.Factory.StartNew(() => { });
            });

            var filters = new IExceptionFilter[] { exceptionFilter };
            IExceptionLogger exceptionLogger = new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
            IExceptionHandler exceptionHandler = new Mock<IExceptionHandler>(MockBehavior.Strict).Object;

            var actionResult = CreateStubActionResult(TaskHelpers.Canceled<HttpResponseMessage>());

            IHttpActionResult product = CreateProductUnderTest(actionContext, filters, exceptionLogger,
                exceptionHandler, actionResult);

            // Act & Assert
            await Assert.ThrowsAsync<TaskCanceledException>(() => product.ExecuteAsync(CancellationToken.None));

            Assert.Equal(new string[] { "exceptionFilter" }, log.ToArray());
        }

        [Fact]
        public async Task ExecuteAsync_IfInnerResultTaskIsFaulted_ExecutesFiltersAndReturnsFaultedTaskIfNotHandled()
        {
            // Arrange
            List<string> log = new List<string>();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            Exception exceptionSeenByFilter = null;
            var exceptionFilter = CreateExceptionFilter((ec, ct) =>
            {
                exceptionSeenByFilter = ec.Exception;
                log.Add("exceptionFilter");
                return Task.Factory.StartNew(() => { });
            });
            var filters = new IExceptionFilter[] { exceptionFilter };
            IExceptionLogger exceptionLogger = CreateExceptionLogger((c, i) =>
            {
                log.Add("exceptionLogger");
                return Task.FromResult(0);
            });
            IExceptionHandler exceptionHandler = CreateStubExceptionHandler();
            var expectedException = new Exception();
            var actionResult = CreateStubActionResult(TaskHelpers.FromError<HttpResponseMessage>(expectedException));

            IHttpActionResult product = CreateProductUnderTest(actionContext, filters, exceptionLogger,
                exceptionHandler, actionResult);

            // Act & Assert
            var exception = await Assert.ThrowsAsync<Exception>(() => product.ExecuteAsync(CancellationToken.None));

            Assert.Same(expectedException, exception);
            Assert.Same(expectedException, exceptionSeenByFilter);
            Assert.Equal(new string[] { "exceptionLogger", "exceptionFilter" }, log.ToArray());
        }

        [Fact]
        public async Task ExecuteAsync_IfInnerResultTaskIsFaulted_CallsExceptionLogger()
        {
            // Arrange
            Exception expectedException = CreateException();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpActionContext expectedActionContext = CreateActionContext(request);
                IExceptionFilter[] filters = new IExceptionFilter[0];

                Mock<IExceptionLogger> exceptionLoggerMock = CreateStubExceptionLoggerMock();
                IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

                IExceptionHandler exceptionHandler = CreateStubExceptionHandler();
                IHttpActionResult innerResult = CreateStubActionResult(
                    CreateFaultedTask<HttpResponseMessage>(expectedException));

                IHttpActionResult product = CreateProductUnderTest(expectedActionContext, filters, exceptionLogger,
                    exceptionHandler, innerResult);

                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                await Assert.ThrowsAsync<InvalidOperationException>(() => product.ExecuteAsync(cancellationToken));

                // Assert
                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == ExceptionCatchBlocks.IExceptionFilter
                    && c.ActionContext == expectedActionContext;

                exceptionLoggerMock.Verify(l => l.LogAsync(
                    It.Is<ExceptionLoggerContext>(c => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task ExecuteAsync_IfInnerResultTaskIsFaulted_ExecutesFiltersAndReturnsResultIfHandled()
        {
            // Arrange
            List<string> log = new List<string>();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            var exception = new Exception();
            HttpResponseMessage globalFilterResponse = new HttpResponseMessage();
            HttpResponseMessage actionFilterResponse = new HttpResponseMessage();
            HttpResponseMessage resultSeenByGlobalFilter = null;
            var globalFilter = CreateExceptionFilter((ec, ct) =>
            {
                log.Add("globalFilter");
                resultSeenByGlobalFilter = ec.Response;
                ec.Response = globalFilterResponse;
                return Task.Factory.StartNew(() => { });
            });
            var actionFilter = CreateExceptionFilter((ec, ct) =>
            {
                log.Add("actionFilter");
                ec.Response = actionFilterResponse;
                return Task.Factory.StartNew(() => { });
            });
            var filters = new IExceptionFilter[] { globalFilter, actionFilter };
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            IExceptionHandler exceptionHandler = CreateDummyExceptionHandler();
            var actionResult = CreateStubActionResult(TaskHelpers.FromError<HttpResponseMessage>(exception));

            IHttpActionResult product = CreateProductUnderTest(actionContext, filters, exceptionLogger,
                exceptionHandler, actionResult);

            // Act
            var response = await product.ExecuteAsync(CancellationToken.None);

            // Assert
            Assert.Same(globalFilterResponse, response);
            Assert.Same(actionFilterResponse, resultSeenByGlobalFilter);
            Assert.Equal(new string[] { "actionFilter", "globalFilter" }, log.ToArray());
        }

        [Fact]
        public async Task ExecuteAsync_IfInnerResultTaskIsFaulted_AndNoFilterHandles_RunsHandlerAndReturnsResultIfHandled()
        {
            // Arrange
            List<string> log = new List<string>();
            Exception expectedException = CreateException();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                HttpActionContext expectedActionContext = CreateActionContext(request);

                IExceptionFilter filter = CreateExceptionFilter((c, i) =>
                {
                    log.Add("filter");
                    return Task.FromResult(0);
                });

                IExceptionFilter[] filters = new IExceptionFilter[] { filter };

                IExceptionLogger exceptionLogger = CreateStubExceptionLogger();

                Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>();
                exceptionHandlerMock
                    .Setup(l => l.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Callback<ExceptionHandlerContext, CancellationToken>((c, i) =>
                    {
                        log.Add("handler");
                        c.Result = new ResponseMessageResult(expectedResponse);
                    })
                    .Returns(Task.FromResult(0));
                IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

                IHttpActionResult innerResult = CreateStubActionResult(
                    CreateFaultedTask<HttpResponseMessage>(expectedException));

                IHttpActionResult product = CreateProductUnderTest(expectedActionContext, filters, exceptionLogger,
                    exceptionHandler, innerResult);

                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                HttpResponseMessage response = await product.ExecuteAsync(cancellationToken);

                // Assert
                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == ExceptionCatchBlocks.IExceptionFilter
                    && c.ActionContext == expectedActionContext;

                exceptionHandlerMock.Verify(h => h.HandleAsync(
                    It.Is<ExceptionHandlerContext>((c) => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());
                Assert.Same(expectedResponse, response);
                Assert.Equal(new string[] { "filter", "handler" }, log.ToArray());
            }
        }

        [Fact]
        public async Task ExecuteAsync_IfFilterChangesException_ThrowsUpdatedException()
        {
            // Arrange
            Exception expectedException = new NotImplementedException();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpActionContext context = CreateActionContext(request);

                Mock<IExceptionFilter> filterMock = new Mock<IExceptionFilter>();
                filterMock
                    .Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(),
                        It.IsAny<CancellationToken>()))
                    .Callback<HttpActionExecutedContext, CancellationToken>((c, t) =>
                    {
                        c.Exception = expectedException;
                    })
                    .Returns(() => Task.FromResult<object>(null));
                IExceptionFilter filter = filterMock.Object;
                IExceptionFilter[] filters = new IExceptionFilter[] { filter };

                IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
                IExceptionHandler exceptionHandler = CreateStubExceptionHandler();

                IHttpActionResult innerResult = CreateStubActionResult(
                    CreateFaultedTask<HttpResponseMessage>(CreateException()));

                IHttpActionResult product = CreateProductUnderTest(context, filters, exceptionLogger, exceptionHandler,
                    innerResult);

                // Act & Assert
                var exception = await Assert.ThrowsAsync<NotImplementedException>(
                    () => product.ExecuteAsync(CancellationToken.None));
                Assert.Same(expectedException, exception);
            }
        }

        [Fact]
        public async Task ExecuteAsync_IfFaultedTaskExceptionIsUnhandled_PreservesExceptionStackTrace()
        {
            // Arrange
            Exception originalException = CreateExceptionWithStackTrace();
            string expectedStackTrace = originalException.StackTrace;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpActionContext context = CreateActionContext(request);
                IExceptionFilter[] filters = new IExceptionFilter[0];

                IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
                IExceptionHandler exceptionHandler = CreateStubExceptionHandler();

                IHttpActionResult innerResult = CreateStubActionResult(
                    CreateFaultedTask<HttpResponseMessage>(originalException));

                IHttpActionResult product = CreateProductUnderTest(context, filters, exceptionLogger, exceptionHandler,
                    innerResult);

                // Act & Assert
                var exception = await Assert.ThrowsAsync<InvalidOperationException>(
                    () => product.ExecuteAsync(CancellationToken.None));

                Assert.NotNull(expectedStackTrace);
                Assert.NotNull(exception);
                Assert.NotNull(exception.StackTrace);
                Assert.StartsWith(expectedStackTrace, exception.StackTrace);
            }
        }

        private static HttpActionContext CreateActionContext()
        {
            return new HttpActionContext();
        }

        private static HttpActionContext CreateActionContext(HttpRequestMessage request)
        {
            HttpActionContext actionContext = CreateActionContext();
            actionContext.ControllerContext = new HttpControllerContext()
            {
                Request = request
            };
            return actionContext;
        }

        private static CancellationToken CreateCancellationToken()
        {
            CancellationTokenSource source = new CancellationTokenSource();
            return source.Token;
        }

        private static IExceptionHandler CreateDummyExceptionHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyExceptionLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private IExceptionFilter CreateExceptionFilter(
            Func<HttpActionExecutedContext, CancellationToken, Task> executeExceptionFilterAsync)
        {
            Mock<IExceptionFilter> mock = new Mock<IExceptionFilter>();
            mock
                .Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(),
                    It.IsAny<CancellationToken>()))
                .Returns(executeExceptionFilterAsync);
            return mock.Object;
        }

        private static IExceptionLogger CreateExceptionLogger(
            Func<ExceptionLoggerContext, CancellationToken, Task> logAsync)
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>();
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(logAsync);
            return mock.Object;
        }

        private static Exception CreateException()
        {
            return new InvalidOperationException();
        }

        private static Exception CreateExceptionWithStackTrace()
        {
            Exception exception;

            try
            {
                throw CreateException();
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            return exception;
        }

        private static Task<TResult> CreateFaultedTask<TResult>(Exception exception)
        {
            TaskCompletionSource<TResult> source = new TaskCompletionSource<TResult>();
            source.SetException(exception);
            return source.Task;
        }

        private static ExceptionFilterResult CreateProductUnderTest(HttpActionContext context, IExceptionFilter[] filters,
            IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler, IHttpActionResult innerResult)
        {
            return new ExceptionFilterResult(context, filters, exceptionLogger, exceptionHandler, innerResult);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static IHttpActionResult CreateStubActionResult(Task<HttpResponseMessage> task)
        {
            Mock<IHttpActionResult> actionResultMock = new Mock<IHttpActionResult>(MockBehavior.Strict);
            actionResultMock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(() =>
            {
                return task;
            });
            return actionResultMock.Object;
        }

        private static IExceptionHandler CreateStubExceptionHandler()
        {
            return CreateStubExceptionHandlerMock().Object;
        }

        private static Mock<IExceptionHandler> CreateStubExceptionHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>();
            mock
                .Setup(l => l.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult<HttpResponseMessage>(null));
            return mock;
        }

        private static IExceptionLogger CreateStubExceptionLogger()
        {
            return CreateStubExceptionLoggerMock().Object;
        }

        private static Mock<IExceptionLogger> CreateStubExceptionLoggerMock()
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>();
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/FilterGroupingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class FilterGroupingTests
    {
        [Fact]
        public void ActionFilters_ReturnsEmptyArray_WhenFiltersIsEmpty()
        {
            // Arrange
            IEnumerable<FilterInfo> filters = CreateEmptyFilters();
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IActionFilter[] actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Empty(actionFilters);
        }

        [Fact]
        public void ActionFilters_ReturnsActionFilters()
        {
            // Arrange
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IActionFilter[] actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(3, actionFilters.Length);
            Assert.Same(expectedGlobalFilter, actionFilters[0]);
            Assert.Same(expectedControllerFilter, actionFilters[1]);
            Assert.Same(expectedActionFilter, actionFilters[2]);
        }

        [Fact]
        public void ActionFilters_ReturnsAllActionFilters_WhenOverrideScopeIsGlobal()
        {
            // Arrange
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(IActionFilter)), FilterScope.Global);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IActionFilter[] actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(3, actionFilters.Length);
            Assert.Same(expectedGlobalFilter, actionFilters[0]);
            Assert.Same(expectedControllerFilter, actionFilters[1]);
            Assert.Same(expectedActionFilter, actionFilters[2]);
        }

        [Fact]
        public void ActionFilters_ReturnsControllerAndBelowActionFilters_WhenOverrideScopeIsController()
        {
            // Arrange
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(IActionFilter)), FilterScope.Controller);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IActionFilter[] actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(2, actionFilters.Length);
            Assert.Same(expectedControllerFilter, actionFilters[0]);
            Assert.Same(expectedActionFilter, actionFilters[1]);
        }

        [Fact]
        public void ActionFilters_ReturnsActionScopeActionFilters_WhenOverrideScopeIsAction()
        {
            // Arrange
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(IActionFilter)), FilterScope.Action);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IActionFilter[] actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            IActionFilter singleFilter = Assert.Single(actionFilters);
            Assert.Same(expectedActionFilter, singleFilter);
        }

        [Fact]
        public void ActionFilters_ReturnsAllActionFilters_WhenOtherFilterIsOverriddenAtActionLevel()
        {
            // Arrange
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(object)), FilterScope.Action);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IActionFilter[] actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(3, actionFilters.Length);
            Assert.Same(expectedGlobalFilter, actionFilters[0]);
            Assert.Same(expectedControllerFilter, actionFilters[1]);
            Assert.Same(expectedActionFilter, actionFilters[2]);
        }

        [Fact]
        public void AuthorizationFilters_ReturnsActionScopeAuthorizationFilters_WhenOverrideScopeIsAction()
        {
            // Arrange
            IAuthorizationFilter expectedGlobalFilter = CreateDummyAuthorizationFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IAuthorizationFilter expectedControllerFilter = CreateDummyAuthorizationFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IAuthorizationFilter expectedActionFilter = CreateDummyAuthorizationFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(IAuthorizationFilter)),
                FilterScope.Action);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IAuthorizationFilter[] authorizationFilters = product.AuthorizationFilters;

            // Assert
            Assert.NotNull(authorizationFilters);
            IAuthorizationFilter authorizationFilter = Assert.Single(authorizationFilters);
            Assert.Same(expectedActionFilter, authorizationFilter);
        }

        [Fact]
        public void AuthenticationFilters_ReturnsActionScopeAuthenticationFilters_WhenOverrideScopeIsAction()
        {
            // Arrange
            IAuthenticationFilter expectedGlobalFilter = CreateDummyAuthenticationFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IAuthenticationFilter expectedControllerFilter = CreateDummyAuthenticationFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IAuthenticationFilter expectedActionFilter = CreateDummyAuthenticationFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(IAuthenticationFilter)),
                FilterScope.Action);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IAuthenticationFilter[] authenticationFilters = product.AuthenticationFilters;

            // Assert
            Assert.NotNull(authenticationFilters);
            IAuthenticationFilter authenticationFilter = Assert.Single(authenticationFilters);
            Assert.Same(expectedActionFilter, authenticationFilter);
        }

        [Fact]
        public void ExceptionFilters_ReturnsActionScopeExceptionFilters_WhenOverrideScopeIsAction()
        {
            // Arrange
            IExceptionFilter expectedGlobalFilter = CreateDummyExceptionFilter();
            FilterInfo globalFilter = new FilterInfo(expectedGlobalFilter, FilterScope.Global);
            IExceptionFilter expectedControllerFilter = CreateDummyExceptionFilter();
            FilterInfo controllerFilter = new FilterInfo(expectedControllerFilter, FilterScope.Controller);
            IExceptionFilter expectedActionFilter = CreateDummyExceptionFilter();
            FilterInfo actionFilter = new FilterInfo(expectedActionFilter, FilterScope.Action);
            FilterInfo overrideFilter = new FilterInfo(CreateOverride(typeof(IExceptionFilter)), FilterScope.Action);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { globalFilter, controllerFilter, actionFilter, overrideFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IExceptionFilter[] exceptionFilters = product.ExceptionFilters;

            // Assert
            Assert.NotNull(exceptionFilters);
            IExceptionFilter exceptionFilter = Assert.Single(exceptionFilters);
            Assert.Same(expectedActionFilter, exceptionFilter);
        }

        [Fact]
        public void FilterImplementingMultipleType_WhereOneTypeIsOverridden_AppearsOnlyInTheOtherList()
        {
            // Arrange
            IFilter expectedInstance = new ActionAndExceptionFilter();
            FilterInfo actionAndExceptionFilter = new FilterInfo(expectedInstance, FilterScope.Global);
            FilterInfo overrideExceptionFilter = new FilterInfo(CreateOverride(typeof(IExceptionFilter)),
                FilterScope.Action);
            IEnumerable<FilterInfo> filters = new FilterInfo[] { actionAndExceptionFilter, overrideExceptionFilter };
            FilterGrouping product = CreateProductUnderTest(filters);

            // Act
            IActionFilter[] actionFilters = product.ActionFilters;
            IExceptionFilter[] exceptionFilters = product.ExceptionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            IActionFilter actionFilter = Assert.Single(actionFilters);
            Assert.Same(expectedInstance, actionFilter);
            Assert.NotNull(exceptionFilters);
            Assert.Empty(exceptionFilters);
        }

        private static IActionFilter CreateDummyActionFilter()
        {
            return new Mock<IActionFilter>(MockBehavior.Strict).Object;
        }

        private static IAuthenticationFilter CreateDummyAuthenticationFilter()
        {
            return new Mock<IAuthenticationFilter>(MockBehavior.Strict).Object;
        }

        private static IAuthorizationFilter CreateDummyAuthorizationFilter()
        {
            return new Mock<IAuthorizationFilter>(MockBehavior.Strict).Object;
        }

        private static IExceptionFilter CreateDummyExceptionFilter()
        {
            return new Mock<IExceptionFilter>(MockBehavior.Strict).Object;
        }

        private static IEnumerable<FilterInfo> CreateEmptyFilters()
        {
            return new FilterInfo[0];
        }

        private static IOverrideFilter CreateOverride(Type filtersToOverride)
        {
            Mock<IOverrideFilter> mock = new Mock<IOverrideFilter>();
            mock.Setup(f => f.FiltersToOverride).Returns(filtersToOverride);
            return mock.Object;
        }

        private static FilterGrouping CreateProductUnderTest(IEnumerable<FilterInfo> filters)
        {
            return new FilterGrouping(filters);
        }

        private class ActionAndExceptionFilter : IActionFilter, IExceptionFilter
        {
            public bool AllowMultiple
            {
                get { throw new NotImplementedException(); }
            }

            public Task<HttpResponseMessage> ExecuteActionFilterAsync(HttpActionContext actionContext,
                CancellationToken cancellationToken, Func<Task<HttpResponseMessage>> continuation)
            {
                throw new NotImplementedException();
            }

            public Task ExecuteExceptionFilterAsync(HttpActionExecutedContext actionExecutedContext,
                CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/HttpActionContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpActionContextTest
    {
        [Fact]
        public void Default_Constructor()
        {
            HttpActionContext actionContext = new HttpActionContext();

            Assert.Null(actionContext.ControllerContext);
            Assert.Null(actionContext.ActionDescriptor);
            Assert.Null(actionContext.Response);
            Assert.Null(actionContext.Request);
            Assert.NotNull(actionContext.ActionArguments);
            Assert.NotNull(actionContext.ModelState);
        }

        [Fact]
        public void Parameter_Constructor()
        {
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
            HttpActionDescriptor actionDescriptor = new Mock<HttpActionDescriptor>().Object;
            HttpActionContext actionContext = new HttpActionContext(controllerContext, actionDescriptor);

            Assert.Same(controllerContext, actionContext.ControllerContext);
            Assert.Same(actionDescriptor, actionContext.ActionDescriptor);
            Assert.Same(controllerContext.Request, actionContext.Request);
            Assert.Null(actionContext.Response);
            Assert.NotNull(actionContext.ActionArguments);
            Assert.NotNull(actionContext.ModelState);
        }

        [Fact]
        public void Constructor_Throws_IfControllerContextIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpActionContext(null, new Mock<HttpActionDescriptor>().Object),
                "controllerContext");
        }

        [Fact]
        public void Constructor_Throws_IfActionDescriptorIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpActionContext(ContextUtil.CreateControllerContext(), null),
                "actionDescriptor");
        }

        [Fact]
        public void ControllerContext_Property()
        {
            Assert.Reflection.Property<HttpActionContext, HttpControllerContext>(
                instance: new HttpActionContext(),
                propertyGetter: ac => ac.ControllerContext,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: ContextUtil.CreateControllerContext());
        }

        [Fact]
        public void ActionDescriptor_Property()
        {
            Assert.Reflection.Property<HttpActionContext, HttpActionDescriptor>(
                instance: new HttpActionContext(),
                propertyGetter: ac => ac.ActionDescriptor,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: new Mock<HttpActionDescriptor>().Object);
        }

        [Fact]
        public void RequestContextGet_ReturnsControllerContextRequestContext()
        {
            // Arrange
            HttpRequestContext expectedRequestContext = new HttpRequestContext();

            HttpActionContext product = new HttpActionContext();
            product.ControllerContext = new HttpControllerContext
            {
                RequestContext = expectedRequestContext
            };

            // Act
            HttpRequestContext requestContext = product.RequestContext;

            // Assert
            Assert.Same(expectedRequestContext, requestContext);
        }

        [Fact]
        public void RequestContextGet_IfControllerContextIsNull_ReturnsNull()
        {
            // Arrange
            HttpRequestContext expectedRequestContext = new HttpRequestContext();

            HttpActionContext product = new HttpActionContext();
            Assert.Null(product.ControllerContext); // Guard

            // Act
            HttpRequestContext requestContext = product.RequestContext;

            // Assert
            Assert.Null(requestContext);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/HttpActionDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http.Controllers
{
    public class HttpActionDescriptorTest
    {
        [Theory]
        [InlineData(null, typeof(VoidResultConverter))]
        [InlineData(typeof(HttpResponseMessage), typeof(ResponseMessageResultConverter))]
        [InlineData(typeof(object), typeof(ValueResultConverter<object>))]
        [InlineData(typeof(string), typeof(ValueResultConverter<string>))]
        public void GetResultConverter_GetAppropriateConverterInstance(Type actionReturnType, Type expectedConverterType)
        {
            var result = HttpActionDescriptor.GetResultConverter(actionReturnType);

            Assert.IsType(expectedConverterType, result);
        }

        [Fact]
        public void GetResultConverter_WhenReturnTypeIsActionResult_ReturnsNull()
        {
            // Act
            IActionResultConverter converter = HttpActionDescriptor.GetResultConverter(typeof(IHttpActionResult));

            // Assert
            Assert.Null(converter);
        }

        [Fact]
        public void GetResultConverter_WhenTypeIsAnGenericParameterType_Throws()
        {
            var genericType = typeof(HttpActionDescriptorTest).GetMethod("SampleGenericMethod").ReturnType;

            Assert.Throws<InvalidOperationException>(() => HttpActionDescriptor.GetResultConverter(genericType),
                "No action result converter could be constructed for a generic parameter type 'TResult'.");
        }

        public TResult SampleGenericMethod<TResult>()
        {
            return default(TResult);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/HttpConfigurationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Web.Http.Controllers;
using System.Web.Http.Services;
using System.Web.Http.Tracing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpConfigurationTest
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties<HttpConfiguration>(TypeAssert.TypeProperties.IsPublicVisibleClass | TypeAssert.TypeProperties.IsDisposable);
        }

        [Fact]
        public void Default_Constructor()
        {
            HttpConfiguration configuration = new HttpConfiguration();

            Assert.Empty(configuration.Filters);
            Assert.NotEmpty(configuration.Formatters);
            Assert.Empty(configuration.MessageHandlers);
            Assert.Empty(configuration.Properties);
            Assert.Empty(configuration.Routes);
            Assert.NotNull(configuration.DependencyResolver);
            Assert.NotNull(configuration.Services);
            Assert.Equal("/", configuration.VirtualPathRoot);
        }

        [Fact]
        public void Parameter_Constructor()
        {
            string path = "/some/path";
            HttpRouteCollection routes = new HttpRouteCollection(path);
            HttpConfiguration configuration = new HttpConfiguration(routes);

            Assert.Same(routes, configuration.Routes);
            Assert.Equal(path, configuration.VirtualPathRoot);
        }

        [Fact]
        public void Dispose_Idempotent()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Dispose();
            configuration.Dispose();
        }

        [Fact]
        public void DependencyResolver_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();

            // Act & assert
            Assert.ThrowsArgumentNull(() => config.DependencyResolver = null, "value");
        }

        [Fact]
        public void Initializer_Default_Set_By_Ctor()
        {
            // Arrange
            var config = new HttpConfiguration();

            // Assert
            Assert.NotNull(config.Initializer);
        }

        [Fact]
        public void Initializer_Throws_With_Null()
        {
            // Arrange
            var config = new HttpConfiguration();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => config.Initializer = null, "value");
        }

        [Fact]
        public void Initializer_Initializes_TraceManager_By_Default()
        {
            // Arrange
            var config = new HttpConfiguration();
            Mock<ITraceManager> mock = new Mock<ITraceManager>() { CallBase = true };
            mock.Setup(m => m.Initialize(config)).Verifiable();
            config.Services.Replace(typeof(ITraceManager), mock.Object);

            // Act
            config.Initializer(config);

            // Assert
            mock.Verify();
        }

        [Fact]
        public void EnsureInitialized_CallsInitializerOnce()
        {
            // Arrange
            int count = 0;
            var config = new HttpConfiguration();
            config.Initializer = _ => { count++; };

            // Act
            config.EnsureInitialized();
            Assert.Equal(1, count);

            config.EnsureInitialized();
            Assert.Equal(1, count);

        }

        [Fact]
        public void Initializer_Sets_Formatter_RequiredMemberSelector_By_Default()
        {
            // Arrange
            var config = new HttpConfiguration();
            Mock<MediaTypeFormatter> mockFormatter = new Mock<MediaTypeFormatter>() { CallBase = true };
            mockFormatter.Object.RequiredMemberSelector = null;

            config.Formatters.Clear();
            config.Formatters.Add(mockFormatter.Object);

            // Act
            config.Initializer(config);

            // Assert
            Assert.NotNull(mockFormatter.Object.RequiredMemberSelector);
        }

        [Fact]
        public void Initialize_Default_Initializer_Can_Be_Removed()
        {
            // Arrange
            var config = new HttpConfiguration();
            config.Initializer = (c) => { };
            bool initializeCalled = false;
            Mock<ITraceManager> mock = new Mock<ITraceManager>() { CallBase = true };
            mock.Setup(m => m.Initialize(config)).Callback(() => initializeCalled = true);
            config.Services.Replace(typeof(ITraceManager), mock.Object);

            // Act
            config.Initializer(config);

            // Assert
            Assert.False(initializeCalled);
        }

        [Fact]
        public void Initialize_Initializer_Can_Be_Reused()
        {
            // Arrange
            HttpConfiguration config1 = new HttpConfiguration();
            HttpConfiguration configPassedToAction = null;
            config1.Initializer = (c) => configPassedToAction = c;

            HttpConfiguration config2 = new HttpConfiguration();
            config2.Initializer = config1.Initializer;

            // Act
            config2.Initializer(config2);

            // Assert
            Assert.Same(config2, configPassedToAction);
        }

        [Fact]
        public void Initialize_Can_Be_Chained()
        {
            // Arrange
            HttpConfiguration config1 = new HttpConfiguration();
            HttpConfiguration configPassedToAction1 = null;
            config1.Initializer = (c) => configPassedToAction1 = c;

            HttpConfiguration config2 = new HttpConfiguration();
            HttpConfiguration configPassedToAction2 = null;
            config2.Initializer = (c) => { config1.Initializer(config1); configPassedToAction2 = c; };

            // Act
            config2.Initializer(config2);

            // Assert
            Assert.Same(config1, configPassedToAction1);
            Assert.Same(config2, configPassedToAction2);
        }

        [Fact]
        public void ApplyControllerSettings_Does_Not_Clone_When_Settings_Are_Not_Initialized()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerSettings settings = new HttpControllerSettings(config);

            // Act
            HttpConfiguration clonedConfig = HttpConfiguration.ApplyControllerSettings(settings, config);

            // Assert
            Assert.Same(config, clonedConfig);
        }

        [Fact]
        public void ApplyControllerSettings_Clones_Configuration_When_Settings_Are_Initialized()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerSettings settings = new HttpControllerSettings(config);
            settings.Formatters.Clear();    // accessing this property will force a clone

            // Act
            HttpConfiguration clonedConfig = HttpConfiguration.ApplyControllerSettings(settings, config);

            // Assert
            Assert.NotNull(clonedConfig);
            Assert.NotSame(config, clonedConfig);
        }

        [Fact]
        public void ApplyControllerSettings_Executes_Original_Initializer_On_Clone()
        {
            // Arrange
            HttpConfiguration configPassedToAction = null;
            HttpConfiguration config = new HttpConfiguration();
            config.Initializer = (c) => configPassedToAction = c;
            HttpControllerSettings settings = new HttpControllerSettings(config);
            settings.Formatters.Clear();    // accessing this property will force a clone

            // Act
            HttpConfiguration clonedConfig = HttpConfiguration.ApplyControllerSettings(settings, config);

            // Assert
            Assert.Same(clonedConfig, configPassedToAction);
        }

        [Fact]
        public void ApplyControllerSettings_Clone_Inherits_Tracing_On_PerController_Services()
        {
            // Arrange
            bool calledTrace = false;
            HttpConfiguration config = new HttpConfiguration();
            Mock<ITraceWriter> mockTracer = new Mock<ITraceWriter>() { CallBase = true };
            mockTracer.Setup(m => m.Trace(It.IsAny<HttpRequestMessage>(),
                                          It.IsAny<string>(),
                                          It.IsAny<TraceLevel>(),
                                          It.IsAny<Action<TraceRecord>>())).Callback(() => { calledTrace = true; });

            config.Services.Replace(typeof(ITraceWriter), mockTracer.Object);
            config.Initializer(config);    // installs tracer on original config

            HttpControllerSettings settings = new HttpControllerSettings(config);
            Mock<IContentNegotiator> mockNegotiator = new Mock<IContentNegotiator>() { CallBase = true };
            settings.Services.Replace(typeof(IContentNegotiator), mockNegotiator.Object);

            // Act
            HttpConfiguration clonedConfig = HttpConfiguration.ApplyControllerSettings(settings, config);
            clonedConfig.Services.GetContentNegotiator().Negotiate(typeof(string), new HttpRequestMessage(), Enumerable.Empty<MediaTypeFormatter>());

            // Assert
            Assert.True(calledTrace);
        }

        [Fact]
        public void ApplyControllerSettings_Clone_Inherits_Tracing_On_PerController_Formatters()
        {
            // Arrange
            bool calledTrace = false;
            HttpConfiguration config = new HttpConfiguration();
            Mock<ITraceWriter> mockTracer = new Mock<ITraceWriter>() { CallBase = true };
            mockTracer.Setup(m => m.Trace(It.IsAny<HttpRequestMessage>(),
                                          It.IsAny<string>(),
                                          It.IsAny<TraceLevel>(),
                                          It.IsAny<Action<TraceRecord>>())).Callback(() => { calledTrace = true; });

            config.Services.Replace(typeof(ITraceWriter), mockTracer.Object);
            config.Initializer(config);    // installs tracer on original config

            HttpControllerSettings settings = new HttpControllerSettings(config);
            Mock<MediaTypeFormatter> mockFormatter = new Mock<MediaTypeFormatter>() { CallBase = true };
            settings.Formatters.Clear();
            settings.Formatters.Add(mockFormatter.Object);

            // Act
            HttpConfiguration clonedConfig = HttpConfiguration.ApplyControllerSettings(settings, config);
            clonedConfig.Formatters[0].GetPerRequestFormatterInstance(typeof(string), new HttpRequestMessage(), new MediaTypeHeaderValue("application/mine"));

            // Assert
            Assert.True(calledTrace);
        }

        [Fact]
        public void ApplyControllerSettings_Clone_Can_Enable_Tracing_When_Original_Disabled_It()
        {
            // Arrange
            bool calledTrace = false;
            HttpConfiguration config = new HttpConfiguration();
            Mock<ITraceWriter> mockTracer = new Mock<ITraceWriter>() { CallBase = true };
            mockTracer.Setup(m => m.Trace(It.IsAny<HttpRequestMessage>(),
                                          It.IsAny<string>(),
                                          It.IsAny<TraceLevel>(),
                                          It.IsAny<Action<TraceRecord>>())).Callback(() => { calledTrace = true; });

            config.Initializer(config);    // ensures TraceManager is called, but it will be a NOP

            HttpControllerSettings settings = new HttpControllerSettings(config);
            settings.Services.Replace(typeof(ITraceWriter), mockTracer.Object);

            // Act
            HttpConfiguration clonedConfig = HttpConfiguration.ApplyControllerSettings(settings, config);
            clonedConfig.Services.GetContentNegotiator().Negotiate(typeof(string), new HttpRequestMessage(), Enumerable.Empty<MediaTypeFormatter>());

            // Assert
            Assert.True(calledTrace);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/HttpControllerContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpControllerContextTest
    {
        [Fact]
        public void Default_Constructor()
        {
            HttpControllerContext controllerContext = new HttpControllerContext();

            Assert.Null(controllerContext.Configuration);
            Assert.Null(controllerContext.Controller);
            Assert.Null(controllerContext.ControllerDescriptor);
            Assert.Null(controllerContext.Request);
            Assert.Null(controllerContext.RouteData);
        }

        [Fact]
        public void Parameter_Constructor()
        {
            HttpConfiguration config = new HttpConfiguration();
            IHttpRouteData routeData = new Mock<IHttpRouteData>().Object;
            HttpRequestMessage request = new HttpRequestMessage();
            HttpControllerContext controllerContext = new HttpControllerContext(config, routeData, request);

            Assert.Same(config, controllerContext.Configuration);
            Assert.Same(request, controllerContext.Request);
            Assert.Same(routeData, controllerContext.RouteData);
            Assert.Null(controllerContext.Controller);
            Assert.Null(controllerContext.ControllerDescriptor);
        }

        [Fact]
        public void Constructor_Throws_IfConfigurationIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpControllerContext(null, new Mock<IHttpRouteData>().Object, new HttpRequestMessage()),
                "configuration");
        }

        [Fact]
        public void Constructor_Throws_IfRouteDataIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpControllerContext(new HttpConfiguration(), null, new HttpRequestMessage()),
                "routeData");
        }

        [Fact]
        public void Constructor_Throws_IfRequestIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpControllerContext(new HttpConfiguration(), new Mock<IHttpRouteData>().Object, null),
                "request");
        }

        [Fact]
        public void Configuration_Property()
        {
            Assert.Reflection.Property<HttpControllerContext, HttpConfiguration>(
                instance: new HttpControllerContext(),
                propertyGetter: cc => cc.Configuration,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: new HttpConfiguration());
        }

        [Fact]
        public void Controller_Property()
        {
            Assert.Reflection.Property<HttpControllerContext, IHttpController>(
                instance: new HttpControllerContext(),
                propertyGetter: cc => cc.Controller,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: new Mock<IHttpController>().Object);
        }

        [Fact]
        public void ControllerDescriptor_Property()
        {
            Assert.Reflection.Property<HttpControllerContext, HttpControllerDescriptor>(
                instance: new HttpControllerContext(),
                propertyGetter: cc => cc.ControllerDescriptor,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: new HttpControllerDescriptor());
        }

        [Fact]
        public void RouteData_Property()
        {
            Assert.Reflection.Property<HttpControllerContext, IHttpRouteData>(
                instance: new HttpControllerContext(),
                propertyGetter: cc => cc.RouteData,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: new Mock<IHttpRouteData>().Object);
        }

    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/HttpControllerDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpControllerDescriptorTest
    {
        [Fact]
        public void Default_Constructor()
        {
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor();

            Assert.Null(controllerDescriptor.ControllerName);
            Assert.Null(controllerDescriptor.Configuration);
            Assert.Null(controllerDescriptor.ControllerType);
            Assert.NotNull(controllerDescriptor.Properties);
        }

        [Fact]
        public void Parameter_Constructor()
        {
            HttpConfiguration config = new HttpConfiguration();
            string controllerName = "UsersController";
            Type controllerType = typeof(UsersController);

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(config, controllerName, controllerType);
            Assert.NotNull(controllerDescriptor.ControllerName);
            Assert.NotNull(controllerDescriptor.Configuration);
            Assert.NotNull(controllerDescriptor.ControllerType);
            Assert.NotNull(controllerDescriptor.Properties);
            Assert.Equal(config, controllerDescriptor.Configuration);
            Assert.Equal(controllerName, controllerDescriptor.ControllerName);
            Assert.Equal(controllerType, controllerDescriptor.ControllerType);
        }

        [Fact]
        public void Constructor_Throws_IfConfigurationIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpControllerDescriptor(null, "UsersController", typeof(UsersController)),
                "configuration");
        }

        [Fact]
        public void Constructor_Throws_IfControllerNameIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpControllerDescriptor(new HttpConfiguration(), null, typeof(UsersController)),
                "controllerName");
        }

        [Fact]
        public void Constructor_Throws_IfControllerTypeIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpControllerDescriptor(new HttpConfiguration(), "UsersController", null),
                "controllerType");
        }

        [Fact]
        public void Configuration_Property()
        {
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor();

            Assert.Reflection.Property<HttpControllerDescriptor, HttpConfiguration>(
                instance: controllerDescriptor,
                propertyGetter: cd => cd.Configuration,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: config);
        }

        [Fact]
        public void ControllerName_Property()
        {
            string controllerName = "UsersController";
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor();

            Assert.Reflection.Property<HttpControllerDescriptor, string>(
                instance: controllerDescriptor,
                propertyGetter: cd => cd.ControllerName,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: controllerName);
        }

        [Fact]
        public void ControllerType_Property()
        {
            Type controllerType = typeof(UsersController);
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor();

            Assert.Reflection.Property<HttpControllerDescriptor, Type>(
                instance: controllerDescriptor,
                propertyGetter: cd => cd.ControllerType,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: controllerType);
        }

        [Fact]
        public void GetFilters_InvokesGetCustomAttributesMethod()
        {
            var descriptorMock = new Mock<HttpControllerDescriptor> { CallBase = true };
            var filters = new Collection<IFilter>(new List<IFilter>());
            descriptorMock.Setup(d => d.GetCustomAttributes<IFilter>()).Returns(filters).Verifiable();

            var result = descriptorMock.Object.GetFilters();

            Assert.Same(filters, result);
            descriptorMock.Verify();
        }

        [Fact]
        public void Initialize_In_InheritenceHierarchy()
        {
            // Verifies that initialization is run in order with , and that they all mutate on the same descriptor object
            HttpConfiguration config = new HttpConfiguration();

            // Act.
            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(MyDerived2Controller));

            // Assert
            Assert.Same(MyDerived1Controller.SelectorBase, desc.Configuration.Services.GetActionSelector());
            Assert.Same(MyDerived1Controller.ActionValueBinderDerived1, desc.Configuration.Services.GetActionValueBinder());
            Assert.Same(config.Formatters, desc.Configuration.Formatters); // didn't override, stays the same
            Assert.Same(config.ParameterBindingRules, desc.Configuration.ParameterBindingRules); // didn't override, stays the same
        }

        [Fact]
        public void Initialize_In_InheritenceHierarchy_Branching()
        {
            // Verifies that initialization is run in order with, and that they all mutate on the same descriptor object
            HttpConfiguration config = new HttpConfiguration();

            // Act.
            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(MyDerived3Controller));

            // Assert
            Assert.Same(MyDerived1Controller.SelectorBase, desc.Configuration.Services.GetActionSelector());
            Assert.Same(MyDerived3Controller.ActionValueBinderDerived3, desc.Configuration.Services.GetActionValueBinder());
            Assert.Same(config.Formatters, desc.Configuration.Formatters); // didn't override, stays the same
            Assert.Same(config.ParameterBindingRules, desc.Configuration.ParameterBindingRules); // didn't override, stays the same
        }

        [Fact]
        public void Initialize_GetsTheActualControllerDescriptor_In_InheritenceHierarchy()
        {
            HttpConfiguration config = new HttpConfiguration();

            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(VerifyControllerDescriptorDerivedController));
            Assert.Equal(typeof(VerifyControllerDescriptorDerivedController), VerifyControllerDescriptorAttribute.ControllerType);

            desc = new HttpControllerDescriptor(config, "MyController", typeof(VerifyControllerDescriptorBaseController));
            Assert.Equal(typeof(VerifyControllerDescriptorBaseController), VerifyControllerDescriptorAttribute.ControllerType);
        }

        [Fact]
        public void EmptySetting_DoesNotChangeTheConfigurationInstance()
        {
            HttpConfiguration config = new HttpConfiguration();

            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(NoopControllerConfigController));
            Assert.Same(config, desc.Configuration); // didn't change anything, the config instance stays the same
        }

        [Fact]
        public void GetCustomAttributes_GetsInheritedAttributes()
        {
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(MyDerived1Controller));

            var attributes = desc.GetCustomAttributes<MyConfigBaseAttribute>();

            Assert.Single(attributes);
        }

        [Fact]
        public void GetCustomAttributesInheritTrue_GetsInheritedAttributes()
        {
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(MyDerived1Controller));

            var attributes = desc.GetCustomAttributes<MyConfigBaseAttribute>(inherit: true);

            Assert.Single(attributes);
        }

        [Fact]
        public void GetCustomAttributesInheritFalse_DoesNotGetInheritedAttributes()
        {
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(MyDerived1Controller));

            var attributes = desc.GetCustomAttributes<MyConfigBaseAttribute>(inherit: false);

            Assert.Empty(attributes);
        }

        [Fact]
        public void GetCustomAttributesInheritFalse_GetsDeclaredAttributes()
        {
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(MyDerived1Controller));

            var attributes = desc.GetCustomAttributes<MyConfigDerived1Attribute>(inherit: false);

            Assert.Single(attributes);
        }

        class NoopControllerConfigAttribute : Attribute, IControllerConfiguration
        {
            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
            {
            }
        }

        [NoopControllerConfig]
        class NoopControllerConfigController : ApiController
        {
        }

        class VerifyControllerDescriptorAttribute : Attribute, IControllerConfiguration
        {
            public static Type ControllerType;
            public void Initialize(HttpControllerSettings settings, HttpControllerDescriptor controllerDescriptor)
            {
                ControllerType = controllerDescriptor.ControllerType;
            }
        }

        [VerifyControllerDescriptor]
        class VerifyControllerDescriptorBaseController : ApiController
        {
        }

        class VerifyControllerDescriptorDerivedController : VerifyControllerDescriptorBaseController
        {
        }

        class MyConfigBaseAttribute : Attribute, IControllerConfiguration
        {
            public void Initialize(HttpControllerSettings settings, HttpControllerDescriptor controllerDescriptor)
            {
                settings.Services.Replace(typeof(IActionValueBinder), MyBaseController.ActionValueBinderBase);
                settings.Services.Replace(typeof(IHttpActionSelector), MyBaseController.SelectorBase);
            }
        }

        [MyConfigBase]
        class MyBaseController : ApiController
        {
            public static IHttpActionSelector SelectorBase = new Mock<IHttpActionSelector>().Object;
            public static IActionValueBinder ActionValueBinderBase = new Mock<IActionValueBinder>().Object;
        }

        class MyConfigDerived1Attribute : Attribute, IControllerConfiguration
        {
            public void Initialize(HttpControllerSettings settings, HttpControllerDescriptor controllerDescriptor)
            {
                // Base runs first, so we should be able to see changes from the base.
                Assert.Same(MyBaseController.ActionValueBinderBase, settings.Services.GetActionValueBinder());

                // Also overwrite them
                settings.Services.Replace(typeof(IActionValueBinder), MyDerived1Controller.ActionValueBinderDerived1);
            }
        }

        class MyConfigDerived3Attribute : Attribute, IControllerConfiguration
        {
            public void Initialize(HttpControllerSettings settings, HttpControllerDescriptor controllerDescriptor)
            {
                // MyConfigDerived1 runs first, so we should be able to see changes from the MyConfigDerived1.
                Assert.Same(MyDerived1Controller.ActionValueBinderDerived1, settings.Services.GetActionValueBinder());

                // Also overwrite them
                settings.Services.Replace(typeof(IActionValueBinder), MyDerived3Controller.ActionValueBinderDerived3);
            }
        }

        [MyConfigDerived1]
        class MyDerived1Controller : MyBaseController
        {
            public static IActionValueBinder ActionValueBinderDerived1 = new Mock<IActionValueBinder>().Object;
        }

        class MyDerived2Controller : MyDerived1Controller
        {
        }

        [MyConfigDerived3]
        class MyDerived3Controller : MyDerived1Controller
        {
            public static IActionValueBinder ActionValueBinderDerived3 = new Mock<IActionValueBinder>().Object;
        }


        [Fact]
        public void Initialize_Append_A_Formatter()
        {
            // Verifies that controller inherit the formatter list from the global config, and can mutate it.
            HttpConfiguration config = new HttpConfiguration();

            MediaTypeFormatter globalFormatter = new Mock<MediaTypeFormatter>().Object;
            config.Formatters.Clear();
            config.Formatters.Add(globalFormatter);

            // Act.
            HttpControllerDescriptor desc = new HttpControllerDescriptor(config, "MyController", typeof(MyControllerWithCustomFormatter));

            // Assert
            Assert.Equal(2, desc.Configuration.Formatters.Count);
            Assert.Same(globalFormatter, desc.Configuration.Formatters[0]);
            Assert.Same(MyControllerWithCustomFormatter.CustomFormatter, desc.Configuration.Formatters[1]);
        }


        class MyControllerWithCustomFormatterConfigAttribute : Attribute, IControllerConfiguration
        {
            public void Initialize(HttpControllerSettings settings, HttpControllerDescriptor controllerDescriptor)
            {
                // Appends to existing list. Formatter list has copy-on-write semantics.
                Assert.Single(settings.Formatters); // the one we already set
                settings.Formatters.Add(MyControllerWithCustomFormatter.CustomFormatter);
            }
        }

        [MyControllerWithCustomFormatterConfig]
        class MyControllerWithCustomFormatter : ApiController
        {
            public static MediaTypeFormatter CustomFormatter = new Mock<MediaTypeFormatter>().Object;

        }

    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/HttpParameterBindingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpParameterBindingTest
    {
        [Fact]
        public void GetValueMissing()
        {
            CustomBinding binding = new CustomBinding("p1");

            HttpActionContext ctx = new HttpActionContext();

            var result = binding.GetValue(ctx);

            Assert.Null(result);
        }

        [Fact]
        public void GetValue_Returns_Set()
        {
            CustomBinding binding = new CustomBinding("p1");

            HttpActionContext ctx = new HttpActionContext();

            // Act
            object result = "abc";
            binding.SetValue(ctx, result);
            var result2 = binding.GetValue(ctx);

            // Assert
            Assert.Same(result, result2);
        }

        [Fact]
        public void Can_Set_Null()
        {
            // It's legal to set a parameter to null. Test against spurious null checks.
            CustomBinding binding = new CustomBinding("p1");

            HttpActionContext ctx = new HttpActionContext();

            // Act            
            binding.SetValue(ctx, null);

            var resultFinal = binding.GetValue(ctx);

            // Assert
            Assert.Null(resultFinal);
        }

        [Fact]
        public void Call_Set_Multiple_Times()
        {
            // Make sure a binding can set the argument multiple times and that we get the latest. 
            // This is interesting with composite bindings that chain to an inner binding. 
            CustomBinding binding = new CustomBinding("p1");

            HttpActionContext ctx = new HttpActionContext();

            // Act
            object result1 = "abc";
            binding.SetValue(ctx, result1);

            object result2 = 123;
            binding.SetValue(ctx, result2);

            var resultFinal = binding.GetValue(ctx);

            // Assert
            Assert.Same(result2, resultFinal);
        }

        [Fact]
        public void Set_Modifies_Dictionary()
        {
            string name = "p1";
            CustomBinding binding = new CustomBinding(name);

            HttpActionContext ctx = new HttpActionContext();

            // Act
            object result = "abc";
            binding.SetValue(ctx, result);
            var result2 = ctx.ActionArguments[name];

            // Assert
            Assert.Same(result, result2);
        }

        [Fact]
        public void Reuse_Binding_With_Different_Contexts()
        { 
            // The same binding can be used across multiple action contexts.

            string name = "p1";
            CustomBinding binding = new CustomBinding(name);

            HttpActionContext ctx1 = new HttpActionContext();
            HttpActionContext ctx2 = new HttpActionContext();

            // Act
            object result1 = "abc";
            binding.SetValue(ctx1, result1);

            object result2 = 123;            
            binding.SetValue(ctx2, result2);

            // Assert
            Assert.Same(result1, binding.GetValue(ctx1));
            Assert.Same(result2, binding.GetValue(ctx2));
        }

        // Helper for testing. 
        // Easily construct, mock out the the right things, and expose protected members to the tests. 
        public class CustomBinding : HttpParameterBinding
        {
            public CustomBinding(string paramName) : base(Build(paramName))
            {
            }

            static HttpParameterDescriptor Build(string paramName)
            {
                Mock<HttpParameterDescriptor> mock = new Mock<HttpParameterDescriptor>();
                mock.Setup(x => x.ParameterName).Returns(paramName);
                return mock.Object;
            }

            public override Threading.Tasks.Task ExecuteBindingAsync(Metadata.ModelMetadataProvider metadataProvider, HttpActionContext actionContext, Threading.CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }

            // Expose protected
            public new object GetValue(HttpActionContext actionContext)
            {
                return base.GetValue(actionContext);
            }

            public new void SetValue(HttpActionContext actionContext, object value)
            {
                base.SetValue(actionContext, value);
            }
        }
    }


}


================================================
FILE: test/System.Web.Http.Test/Controllers/HttpParameterDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpParameterDescriptorTest
    {
        [Fact]
        public void Default_Constructor()
        {
            HttpParameterDescriptor parameterDescriptor = new Mock<HttpParameterDescriptor>().Object;

            Assert.Null(parameterDescriptor.ParameterName);
            Assert.Null(parameterDescriptor.ParameterType);
            Assert.Null(parameterDescriptor.Configuration);
            Assert.Null(parameterDescriptor.Prefix);
            Assert.Null(parameterDescriptor.ParameterBinderAttribute);
            Assert.Null(parameterDescriptor.ActionDescriptor);
            Assert.Null(parameterDescriptor.DefaultValue);
            Assert.NotNull(parameterDescriptor.Properties);
            Assert.False(parameterDescriptor.IsOptional);
        }

        [Fact]
        public void Configuration_Property()
        {
            HttpConfiguration config = new HttpConfiguration();
            HttpParameterDescriptor parameterDescriptor = new Mock<HttpParameterDescriptor> { CallBase = true }.Object;

            Assert.Reflection.Property<HttpParameterDescriptor, HttpConfiguration>(
                 instance: parameterDescriptor,
                 propertyGetter: pd => pd.Configuration,
                 expectedDefaultValue: null,
                 allowNull: false,
                 roundTripTestValue: config);
        }

        [Fact]
        public void ActionDescriptor_Property()
        {
            HttpParameterDescriptor parameterDescriptor = new Mock<HttpParameterDescriptor> { CallBase = true }.Object;
            HttpActionDescriptor actionDescriptor = new Mock<HttpActionDescriptor>().Object;

            Assert.Reflection.Property<HttpParameterDescriptor, HttpActionDescriptor>(
                 instance: parameterDescriptor,
                 propertyGetter: pd => pd.ActionDescriptor,
                 expectedDefaultValue: null,
                 allowNull: false,
                 roundTripTestValue: actionDescriptor);
        }

        [Fact]
        public void GetCustomAttributes_Returns_EmptyAttributes()
        {
            HttpParameterDescriptor parameterDescriptor = new Mock<HttpParameterDescriptor> { CallBase = true }.Object;
            IEnumerable<object> attributes = parameterDescriptor.GetCustomAttributes<object>();

            Assert.Empty(attributes);
        }

        [Fact]
        public void GetCustomAttributes_AttributeType_Returns_EmptyAttributes()
        {
            HttpParameterDescriptor parameterDescriptor = new Mock<HttpParameterDescriptor> { CallBase = true }.Object;
            IEnumerable<FromBodyAttribute> attributes = parameterDescriptor.GetCustomAttributes<FromBodyAttribute>();

            Assert.Empty(attributes);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ParameterBindingExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting;
using System.Web.Http.ModelBinding;
using System.Web.Http.Validation;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class ParameterBindingExtensionsTest
    {
        [Fact]
        public void BindAsError()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            string message = "error message";
            HttpParameterBinding binding = param.BindAsError(message);

            Assert.NotNull(binding);
            Assert.False(binding.IsValid);
            Assert.Equal(message, binding.ErrorMessage);
        }

        [Fact]
        public void BindWithModelBinding_Default()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            ModelBinderParameterBinding binding = (ModelBinderParameterBinding) param.BindWithModelBinding();

            Assert.NotNull(binding);
        }

        [Fact]
        public void BindWithModelBinding_Attribute()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            ModelBinderAttribute attribute = new ModelBinderAttribute(typeof(CustomModelBinder));
            ModelBinderParameterBinding binding = (ModelBinderParameterBinding) param.BindWithAttribute(attribute);

            Assert.NotNull(binding);
            Assert.IsType<CustomModelBinder>(binding.Binder);
        }

        [Fact]
        public void BindWithModelBinding_IModelBinder()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            var binder = new CustomModelBinder();
            ModelBinderParameterBinding binding = (ModelBinderParameterBinding) param.BindWithModelBinding(binder);

            Assert.NotNull(binding);
            Assert.Equal(binder, binding.Binder);
        }

        [Fact]
        public void BindWithModelBinding_ValueProviderFactory_Array()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            ModelBinderParameterBinding binding = (ModelBinderParameterBinding) param.BindWithModelBinding(new CustomValueProviderFactory1(), new CustomValueProviderFactory2());

            Assert.NotNull(binding);

            ValueProviderFactory[] vpfs = binding.ValueProviderFactories.ToArray();
            Assert.Equal(2, vpfs.Length);            
            Assert.IsType<CustomValueProviderFactory1>(vpfs[0]);
            Assert.IsType<CustomValueProviderFactory2>(vpfs[1]);
        }

        [Fact]
        public void BindWithModelBinding_ValueProviderFactory_IEnumerable()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            var binder = new CustomModelBinder();
            ModelBinderParameterBinding binding = (ModelBinderParameterBinding) param.BindWithModelBinding(binder, new List<ValueProviderFactory>() { new CustomValueProviderFactory1(), new CustomValueProviderFactory2() });

            Assert.NotNull(binding);
            Assert.Equal(binder, binding.Binder);

            ValueProviderFactory[] vpfs = binding.ValueProviderFactories.ToArray();
            Assert.Equal(2, vpfs.Length);
            Assert.IsType<CustomValueProviderFactory1>(vpfs[0]);
            Assert.IsType<CustomValueProviderFactory2>(vpfs[1]);
        }

        [Fact]
        public void BindWithModelBinding_ValueProviderFactory_Binder_and_IEnumerable()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            ModelBinderParameterBinding binding = (ModelBinderParameterBinding) param.BindWithModelBinding(new List<ValueProviderFactory>() { new CustomValueProviderFactory1(), new CustomValueProviderFactory2() });

            Assert.NotNull(binding);

            ValueProviderFactory[] vpfs = binding.ValueProviderFactories.ToArray();
            Assert.Equal(2, vpfs.Length);
            Assert.IsType<CustomValueProviderFactory1>(vpfs[0]);
            Assert.IsType<CustomValueProviderFactory2>(vpfs[1]);
        }

        [Fact]
        public void BindWithFormatter()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            FormatterParameterBinding binding = (FormatterParameterBinding) param.BindWithFormatter();

            Assert.NotNull(binding);
        }

        [Fact]
        public void BindWithFormatter_Formatter_Array()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            MediaTypeFormatter formatter1 = new XmlMediaTypeFormatter();
            MediaTypeFormatter formatter2 = new JsonMediaTypeFormatter();

            FormatterParameterBinding binding = (FormatterParameterBinding) param.BindWithFormatter(formatter1, formatter2);
            
            Assert.NotNull(binding);
            MediaTypeFormatter[] formatters = binding.Formatters.ToArray();
            Assert.Equal(2, formatters.Length);
            Assert.Equal(formatter1, formatters[0]);
            Assert.Equal(formatter2, formatters[1]);
        }

        [Fact]
        public void BindWithFormatter_Formatter_IEnumerable()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            MediaTypeFormatter formatter1 = new XmlMediaTypeFormatter();
            MediaTypeFormatter formatter2 = new JsonMediaTypeFormatter();

            FormatterParameterBinding binding = (FormatterParameterBinding) param.BindWithFormatter(new List<MediaTypeFormatter> { formatter1, formatter2 });

            Assert.NotNull(binding);
            MediaTypeFormatter[] formatters = binding.Formatters.ToArray();
            Assert.Equal(2, formatters.Length);
            Assert.Equal(formatter1, formatters[0]);
            Assert.Equal(formatter2, formatters[1]);
        }

        [Fact]
        public void BindWithFormatter_Formatters_and_Validator()
        {
            HttpParameterDescriptor param = CreateParameterDescriptor();

            IBodyModelValidator bodyModelValidator = new Mock<IBodyModelValidator>().Object;
            MediaTypeFormatter formatter1 = new XmlMediaTypeFormatter();
            MediaTypeFormatter formatter2 = new JsonMediaTypeFormatter();

            FormatterParameterBinding binding = (FormatterParameterBinding) param.BindWithFormatter(new List<MediaTypeFormatter> { formatter1, formatter2 }, bodyModelValidator);

            Assert.NotNull(binding);
            Assert.Equal(bodyModelValidator, binding.BodyModelValidator);
            MediaTypeFormatter[] formatters = binding.Formatters.ToArray();
            Assert.Equal(2, formatters.Length);
            Assert.Equal(formatter1, formatters[0]);
            Assert.Equal(formatter2, formatters[1]);
        }

        // Create a parameter that's sufficiently complete that we can run a basic Bind() operation on it. 
        private static HttpParameterDescriptor CreateParameterDescriptor()
        {
            // Need config because bind looks up in config.
            HttpConfiguration config = new HttpConfiguration();
            HttpParameterDescriptor param = CreateParameterDescriptor(typeof(object), "thing");
            param.Configuration = config;
            param.ActionDescriptor = new Mock<HttpActionDescriptor>().Object;
            param.ActionDescriptor.ControllerDescriptor = new HttpControllerDescriptor(config);

            return param;
        }

        private static HttpParameterDescriptor CreateParameterDescriptor(Type type, string name)
        {
            Mock<HttpParameterDescriptor> mock = new Mock<HttpParameterDescriptor>();
            mock.Setup(p => p.ParameterType).Returns(type);
            mock.Setup(p => p.ParameterName).Returns(name);
            return mock.Object;
        }

        public class CustomModelBinder : IModelBinder
        {
            public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        public class CustomValueProviderFactory1 : ValueProviderFactory
        {
            public override IValueProvider GetValueProvider(HttpActionContext actionContext)
            {
                throw new NotImplementedException();
            }
        }
        public class CustomValueProviderFactory2 : ValueProviderFactory
        {
            public override IValueProvider GetValueProvider(HttpActionContext actionContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ReflectedHttpActionDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class ReflectedHttpActionDescriptorTest
    {
        private readonly UsersRpcController _controller = new UsersRpcController();
        private readonly HttpControllerContext _context;
        private readonly Dictionary<string, object> _arguments = new Dictionary<string, object>();

        public ReflectedHttpActionDescriptorTest()
        {
            _context = ContextUtil.CreateControllerContext(instance: _controller);
            _context.Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
        }

        [Fact]
        public void Default_Constructor()
        {
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor();

            Assert.Null(actionDescriptor.ActionName);
            Assert.Null(actionDescriptor.Configuration);
            Assert.Null(actionDescriptor.ControllerDescriptor);
            Assert.Null(actionDescriptor.MethodInfo);
            Assert.Null(actionDescriptor.ReturnType);
            Assert.NotNull(actionDescriptor.Properties);
        }

        [Fact]
        public void Parameter_Constructor()
        {
            Func<string, string, User> echoUserMethod = _controller.EchoUser;
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(config, "", typeof(UsersRpcController));
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, echoUserMethod.Method);

            Assert.Equal("EchoUser", actionDescriptor.ActionName);
            Assert.Equal(config, actionDescriptor.Configuration);
            Assert.Equal(typeof(UsersRpcController), actionDescriptor.ControllerDescriptor.ControllerType);
            Assert.Equal(echoUserMethod.Method, actionDescriptor.MethodInfo);
            Assert.Equal(typeof(User), actionDescriptor.ReturnType);
            Assert.NotNull(actionDescriptor.Properties);
        }

        [Fact]
        public void Constructor_Throws_IfMethodInfoIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), null),
                "methodInfo");
        }

        [Fact]
        public void MethodInfo_Property()
        {
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor();
            Action action = new Action(() => { });

            Assert.Reflection.Property<ReflectedHttpActionDescriptor, MethodInfo>(
                 instance: actionDescriptor,
                 propertyGetter: ad => ad.MethodInfo,
                 expectedDefaultValue: null,
                 allowNull: false,
                 roundTripTestValue: action.Method);
        }

        [Fact]
        public void ControllerDescriptor_Property()
        {
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor();
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor();

            Assert.Reflection.Property<ReflectedHttpActionDescriptor, HttpControllerDescriptor>(
                 instance: actionDescriptor,
                 propertyGetter: ad => ad.ControllerDescriptor,
                 expectedDefaultValue: null,
                 allowNull: false,
                 roundTripTestValue: controllerDescriptor);
        }

        [Fact]
        public void Configuration_Property()
        {
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor();
            HttpConfiguration config = new HttpConfiguration();

            Assert.Reflection.Property<ReflectedHttpActionDescriptor, HttpConfiguration>(
                 instance: actionDescriptor,
                 propertyGetter: ad => ad.Configuration,
                 expectedDefaultValue: null,
                 allowNull: false,
                 roundTripTestValue: config);
        }

        [Fact]
        public void GetFilter_Returns_AttributedFilter()
        {
            Func<string, string, User> echoUserMethod = _controller.AddAdmin;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };
            _arguments["firstName"] = "test";
            _arguments["lastName"] = "unit";

            IEnumerable<IFilter> filters = actionDescriptor.GetFilters();

            Assert.NotNull(filters);
            IFilter filter = Assert.Single(filters);
            Assert.IsType<AuthorizeAttribute>(filter);
        }

        [Fact]
        public void GetFilterPipeline_Returns_ConfigurationFilters()
        {
            IActionFilter actionFilter = new Mock<IActionFilter>().Object;
            IExceptionFilter exceptionFilter = new Mock<IExceptionFilter>().Object;
            IAuthorizationFilter authorizationFilter = new AuthorizeAttribute();
            Action deleteAllUsersMethod = _controller.DeleteAllUsers;

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "UsersRpcController", typeof(UsersRpcController));
            controllerDescriptor.Configuration.Filters.Add(actionFilter);
            controllerDescriptor.Configuration.Filters.Add(exceptionFilter);
            controllerDescriptor.Configuration.Filters.Add(authorizationFilter);
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(controllerDescriptor, deleteAllUsersMethod.Method);

            Collection<FilterInfo> filters = actionDescriptor.GetFilterPipeline();

            Assert.Same(actionFilter, filters[0].Instance);
            Assert.Same(exceptionFilter, filters[1].Instance);
            Assert.Same(authorizationFilter, filters[2].Instance);
        }

        [Fact]
        public void GetCustomAttributes_Returns_ActionAttributes()
        {
            Func<string, string, User> echoUserMethod = _controller.AddAdmin;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };

            IEnumerable<IFilter> filters = actionDescriptor.GetCustomAttributes<IFilter>();
            IEnumerable<HttpGetAttribute> httpGet = actionDescriptor.GetCustomAttributes<HttpGetAttribute>();

            Assert.NotNull(filters);
            IFilter filter = Assert.Single(filters);
            Assert.IsType<AuthorizeAttribute>(filter);
            Assert.NotNull(httpGet);
            Assert.Single(httpGet);
        }

        [Fact]
        public void GetParameters_Returns_ActionParameters()
        {
            Func<string, string, User> echoUserMethod = _controller.EchoUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };

            Collection<HttpParameterDescriptor> parameterDescriptors = actionDescriptor.GetParameters();

            Assert.Equal(2, parameterDescriptors.Count);
            Assert.Contains(parameterDescriptors, p => p.ParameterName == "firstName");
            Assert.Contains(parameterDescriptors, p => p.ParameterName == "lastName");
        }

        [Fact]
        public Task ExecuteAsync_DoesNotCallActionWhenCancelled()
        {
            var cts = new CancellationTokenSource();
            cts.Cancel();
            Action action = () => { throw new NotImplementedException(); };
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = action.Method };

            return Assert.ThrowsAsync<TaskCanceledException>(() => actionDescriptor.ExecuteAsync(_context, _arguments, cts.Token));
        }


        [Fact]
        public async Task ExecuteAsync_Returns_TaskOfNull_ForVoidAction()
        {
            Action deleteAllUsersMethod = _controller.DeleteAllUsers;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = deleteAllUsersMethod.Method };

            object returnValue = await actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None);

            Assert.Null(returnValue);
        }

        [Fact]
        public async Task ExecuteAsync_Returns_Results_ForNonVoidAction()
        {
            Func<string, string, User> echoUserMethod = _controller.EchoUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };
            _arguments["firstName"] = "test";
            _arguments["lastName"] = "unit";

            object result = await actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None);

            var returnValue = Assert.IsType<User>(result);
            Assert.Equal("test", returnValue.FirstName);
            Assert.Equal("unit", returnValue.LastName);
        }

        [Fact]
        public async Task ExecuteAsync_Returns_TaskOfNull_ForTaskAction()
        {
            Func<Task> deleteAllUsersMethod = _controller.DeleteAllUsersAsync;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = deleteAllUsersMethod.Method };

            object returnValue = await actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None);

            Assert.Null(returnValue);
        }

        [Fact]
        public async Task ExecuteAsync_Returns_Results_ForTaskOfTAction()
        {
            Func<string, string, Task<User>> echoUserMethod = _controller.EchoUserAsync;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };
            _arguments["firstName"] = "test";
            _arguments["lastName"] = "unit";

            object result = await actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None);

            var returnValue = Assert.IsType<User>(result);
            Assert.Equal("test", returnValue.FirstName);
            Assert.Equal("unit", returnValue.LastName);
        }

        [Fact]
        public void ExecuteAsync_Throws_IfContextIsNull()
        {
            Func<string, string, User> echoUserMethod = _controller.EchoUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };

            Assert.ThrowsArgumentNull(
                () => actionDescriptor.ExecuteAsync(null, _arguments, CancellationToken.None),
                "controllerContext");
        }

        [Fact]
        public async Task ExecuteAsync_Throws_IfArgumentsIsNull()
        {
            Func<string, string, User> echoUserMethod = _controller.EchoUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };

            await Assert.ThrowsAsync<ArgumentNullException>(
                () => actionDescriptor.ExecuteAsync(_context, null, CancellationToken.None),
                "arguments",
                partialMatch: true);
        }

        [Fact]
        public async Task ExecuteAsync_Throws_IfValueTypeArgumentsIsNull()
        {
            Func<int, User> retrieveUserMethod = _controller.RetriveUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = retrieveUserMethod.Method };
            _arguments["id"] = null;

            var exception = await Assert.ThrowsAsync<HttpResponseException>(
                 () => actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None));

            Assert.Equal(HttpStatusCode.BadRequest, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            Assert.Equal("The parameters dictionary contains a null entry for parameter 'id' of non-nullable type 'System.Int32' " +
                "for method 'System.Web.Http.User RetriveUser(Int32)' in 'System.Web.Http.UsersRpcController'. An optional parameter " +
                "must be a reference type, a nullable type, or be declared as an optional parameter.",
                ((HttpError)content.Value)["MessageDetail"]);
        }

        [Fact]
        public async Task ExecuteAsync_Throws_IfArgumentNameIsWrong()
        {
            Func<int, User> retrieveUserMethod = _controller.RetriveUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = retrieveUserMethod.Method };
            _arguments["otherId"] = 6;

            var exception = await Assert.ThrowsAsync<HttpResponseException>(
                () => actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None));

            Assert.Equal(HttpStatusCode.BadRequest, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            Assert.Equal("The parameters dictionary does not contain an entry for parameter 'id' of type 'System.Int32' " +
                "for method 'System.Web.Http.User RetriveUser(Int32)' in 'System.Web.Http.UsersRpcController'. " +
                "The dictionary must contain an entry for each parameter, including parameters that have null values.",
                ((HttpError)content.Value)["MessageDetail"]);
        }

        [Fact]
        public async Task ExecuteAsync_Throws_IfArgumentTypeIsWrong()
        {
            Func<int, User> retrieveUserMethod = _controller.RetriveUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = retrieveUserMethod.Method };
            _arguments["id"] = new DateTime();

            var exception = await Assert.ThrowsAsync<HttpResponseException>(
                 () => actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None));

            Assert.Equal(HttpStatusCode.BadRequest, exception.Response.StatusCode);
            var content = Assert.IsType<ObjectContent<HttpError>>(exception.Response.Content);
            Assert.Equal("The parameters dictionary contains an invalid entry for parameter 'id' for method " +
                "'System.Web.Http.User RetriveUser(Int32)' in 'System.Web.Http.UsersRpcController'. " +
                "The dictionary contains a value of type 'System.DateTime', but the parameter requires a value " +
                "of type 'System.Int32'.",
                ((HttpError)content.Value)["MessageDetail"]);
        }

        [Fact]
        public async Task ExecuteAsync_IfTaskReturningMethod_ReturnsWrappedTaskInstance_Throws()
        {
            Func<Task> method = _controller.WrappedTaskReturningMethod;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = method.Method };

            await Assert.ThrowsAsync<InvalidOperationException>(
                 () => actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None),
                 "The method 'WrappedTaskReturningMethod' on type 'UsersRpcController' returned an instance of 'System.Threading.Tasks.Task`1[[System.Threading.Tasks.Task, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]'. Make sure to call Unwrap on the returned value to avoid unobserved faulted Task.");
        }

        [Fact]
        public async Task ExecuteAsync_IfObjectReturningMethod_ReturnsTaskInstance_Throws()
        {
            Func<object> method = _controller.TaskAsObjectReturningMethod;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = method.Method };

            await Assert.ThrowsAsync<InvalidOperationException>(
                 () => actionDescriptor.ExecuteAsync(_context, _arguments, CancellationToken.None),
                 "The method 'TaskAsObjectReturningMethod' on type 'UsersRpcController' returned a Task instance even though it is not an asynchronous method.");
        }

        [Theory]
        [InlineData(typeof(void), null)]
        [InlineData(typeof(string), typeof(string))]
        [InlineData(typeof(Task), null)]
        [InlineData(typeof(Task<string>), typeof(string))]
        public void GetReturnType_ReturnsUnwrappedActionType(Type methodReturnType, Type expectedReturnType)
        {
            Mock<MethodInfo> methodMock = new Mock<MethodInfo>();
            methodMock.Setup(m => m.ReturnType).Returns(methodReturnType);

            Assert.Equal(expectedReturnType, ReflectedHttpActionDescriptor.GetReturnType(methodMock.Object));
        }

        [Fact]
        public void GetHashCode_ReturnsTheSameHashCode_ForDifferentInstancesWithTheSameMethodInfo()
        {
            Func<string, string, User> echoUserMethod = _controller.EchoUser;
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(config, "", typeof(UsersRpcController));
            ReflectedHttpActionDescriptor actionDescriptor1 = new ReflectedHttpActionDescriptor(controllerDescriptor, echoUserMethod.Method);
            ReflectedHttpActionDescriptor actionDescriptor2 = new ReflectedHttpActionDescriptor(controllerDescriptor, echoUserMethod.Method);

            Assert.Equal(actionDescriptor1.GetHashCode(), actionDescriptor2.GetHashCode());
        }

        [Fact]
        public void Equals_ReturnsTrue_ForDifferentInstancesWithTheSameMethodInfo()
        {
            Func<string, string, User> echoUserMethod = _controller.EchoUser;
            HttpConfiguration config = new HttpConfiguration();
            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(config, "", typeof(UsersRpcController));
            ReflectedHttpActionDescriptor actionDescriptor1 = new ReflectedHttpActionDescriptor(controllerDescriptor, echoUserMethod.Method);
            ReflectedHttpActionDescriptor actionDescriptor2 = new ReflectedHttpActionDescriptor(controllerDescriptor, echoUserMethod.Method);

            Assert.Equal(actionDescriptor1, actionDescriptor2);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ReflectedHttpParameterDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class ReflectedHttpParameterDescriptorTest
    {
        [Fact]
        public void Parameter_Constructor()
        {
            UsersRpcController controller = new UsersRpcController();
            Func<string, string, User> echoUserMethod = controller.EchoUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = echoUserMethod.Method };
            ParameterInfo parameterInfo = echoUserMethod.Method.GetParameters()[0];
            ReflectedHttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);

            Assert.Equal(actionDescriptor, parameterDescriptor.ActionDescriptor);
            Assert.Null(parameterDescriptor.DefaultValue);
            Assert.Equal(parameterInfo, parameterDescriptor.ParameterInfo);
            Assert.Equal(parameterInfo.Name, parameterDescriptor.ParameterName);
            Assert.Equal(typeof(string), parameterDescriptor.ParameterType);
            Assert.Null(parameterDescriptor.Prefix);
            Assert.Null(parameterDescriptor.ParameterBinderAttribute);
            Assert.False(parameterDescriptor.IsOptional);
        }

        [Fact]
        public void Constructor_Throws_IfParameterInfoIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new ReflectedHttpParameterDescriptor(new Mock<HttpActionDescriptor>().Object, null),
                "parameterInfo");
        }

        [Fact]
        public void Constructor_Throws_IfActionDescriptorIsNull()
        {
            Assert.ThrowsArgumentNull(
                () => new ReflectedHttpParameterDescriptor(null, new Mock<ParameterInfo>().Object),
                "actionDescriptor");
        }

        [Fact]
        public void ParameterInfo_Property()
        {
            ParameterInfo referenceParameter = new Mock<ParameterInfo>().Object;
            Assert.Reflection.Property(new ReflectedHttpParameterDescriptor(), d => d.ParameterInfo, expectedDefaultValue: null, allowNull: false, roundTripTestValue: referenceParameter);
        }

        [Fact]
        public void ParameterBinderAttribute_NotNull_WhenParameterAttributeIsFound()
        {
            UsersRpcController controller = new UsersRpcController();
            Action<User> addUserMethod = controller.AddUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = addUserMethod.Method };
            ParameterInfo parameterInfo = addUserMethod.Method.GetParameters()[0];
            ReflectedHttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
            Assert.NotNull(parameterDescriptor.ParameterBinderAttribute);
        }

        private static void MethodWithOptionalParam(int id = 7) { }

        [Fact]
        public void IsOptional_Returns_True_ForOptionalParameter()
        {
            UsersRpcController controller = new UsersRpcController();
            MethodInfo methodWithOptionalParam = GetType().GetMethod("MethodWithOptionalParam", BindingFlags.Static | BindingFlags.NonPublic);
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = methodWithOptionalParam };
            ParameterInfo parameterInfo = methodWithOptionalParam.GetParameters()[0];
            ReflectedHttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
            Assert.True(parameterDescriptor.IsOptional);
        }

        [Fact]
        public void GetCustomAttributes_Returns_ParameterAttributes()
        {
            UsersRpcController controller = new UsersRpcController();
            Action<User> addUserMethod = controller.AddUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = addUserMethod.Method };
            ParameterInfo parameterInfo = addUserMethod.Method.GetParameters()[0];
            ReflectedHttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
            object[] attributes = parameterDescriptor.GetCustomAttributes<object>().ToArray();

            object attribute = Assert.Single(attributes);
            Assert.IsType<FromBodyAttribute>(attribute);
        }

        [Fact]
        public void GetCustomAttributes_AttributeType_Returns_ParameterAttributes()
        {
            UsersRpcController controller = new UsersRpcController();
            Action<User> addUserMethod = controller.AddUser;
            ReflectedHttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = addUserMethod.Method };
            ParameterInfo parameterInfo = addUserMethod.Method.GetParameters()[0];
            ReflectedHttpParameterDescriptor parameterDescriptor = new ReflectedHttpParameterDescriptor(actionDescriptor, parameterInfo);
            IEnumerable<FromBodyAttribute> attributes = parameterDescriptor.GetCustomAttributes<FromBodyAttribute>();

            Assert.Single(attributes);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/RequestBackedHttpRequestContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Threading;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class RequestBackedHttpRequestContextTests
    {
        [Fact]
        public void ConstructorWithRequest_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => new RequestBackedHttpRequestContext(request), "request");
        }

        [Fact]
        public void RequestGet_ReturnsInstanceProvidedInConstructorWithRequest()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                RequestBackedHttpRequestContext context = CreateProductUnderTest(expectedRequest);

                // Act
                HttpRequestMessage request = context.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void RequestSet_UpdatesRequest()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                RequestBackedHttpRequestContext context = CreateProductUnderTest();

                // Act
                context.Request = expectedRequest;

                // Assert
                Assert.Same(expectedRequest, context.Request);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsNull_AsDefault()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            X509Certificate2 certificate = context.ClientCertificate;

            // Assert
            Assert.Null(certificate);
        }

        [Fact]
        public void ClientCertificateSet_UpdatesClientCertificate()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();
            X509Certificate2 expectedCertificate = CreateCertificate();

            // Act
            context.ClientCertificate = expectedCertificate;

            // Assert
            X509Certificate2 certificate = context.ClientCertificate;
            Assert.Same(expectedCertificate, certificate);
        }

        [Fact]
        public void ClientCertificateGet_ReturnsClientCertificateFromProperty_WhenRequestIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                X509Certificate2 expectedCertificate = CreateCertificate();
                request.Properties[HttpPropertyKeys.ClientCertificateKey] = expectedCertificate;

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_IgnoresRequest_AfterClientCertificateSet()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                X509Certificate2 expectedCertificate = CreateCertificate();
                context.ClientCertificate = expectedCertificate;
                request.Properties[HttpPropertyKeys.ClientCertificateKey] = CreateCertificate();

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_IgnoresRequest_AfterClientCertificateSetNull()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                context.ClientCertificate = null;
                request.Properties[HttpPropertyKeys.ClientCertificateKey] = CreateCertificate();

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ConfigurationGet_ReturnsNull_AsDefault()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            HttpConfiguration configuration = context.Configuration;

            // Assert
            Assert.Null(configuration);
        }

        [Fact]
        public void ConfigurationSet_UpdatesConfiguration()
        {
            // Arrange
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest();

                // Act
                context.Configuration = expectedConfiguration;

                // Assert
                HttpConfiguration configuration = context.Configuration;
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void ConfigurationGet_ReturnsConfigurationFromProperty_WhenRequestIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                request.Properties[HttpPropertyKeys.HttpConfigurationKey] = expectedConfiguration;

                // Act
                HttpConfiguration configuration = context.Configuration;

                // Assert
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void ConfigurationGet_IgnoresRequest_AfterConfigurationSet()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            using (HttpConfiguration otherConfiguration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                context.Configuration = expectedConfiguration;
                request.SetConfiguration(otherConfiguration);

                // Act
                HttpConfiguration configuration = context.Configuration;

                // Assert
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void ConfigurationGet_IgnoresRequest_AfterConfigurationSetNull()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration otherConfiguration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                context.Configuration = null;
                request.SetConfiguration(otherConfiguration);

                // Act
                HttpConfiguration configuration = context.Configuration;

                // Assert
                Assert.Null(configuration);
            }
        }

        [Fact]
        public void IncludeErrorDetailGet_ReturnsFalse_AsDefault()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            bool includeErrorDetail = context.IncludeErrorDetail;

            // Assert
            Assert.False(includeErrorDetail);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailSet_UpdatesIncludeErrorDetail(bool expectedIncludeErrorDetail)
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            context.IncludeErrorDetail = expectedIncludeErrorDetail;

            // Assert
            bool includeErrorDetail = context.IncludeErrorDetail;
            Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsIncludeErrorDetailFromProperty_WhenRequestIsPresent(bool expected)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                request.Properties[HttpPropertyKeys.IncludeErrorDetailKey] = new Lazy<bool>(() => expected);

                // Act
                bool actual = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_IgnoresRequest_AfterIncludeErrorDetailSet(bool expectedIncludeErrorDetail)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                context.IncludeErrorDetail = expectedIncludeErrorDetail;
                request.Properties[HttpPropertyKeys.IncludeErrorDetailKey] =
                    new Lazy<bool>(() => !expectedIncludeErrorDetail);

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Fact]
        public void IsLocalGet_ReturnsFalse_AsDefault()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            bool isLocal = context.IsLocal;

            // Assert
            Assert.False(isLocal);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalSet_UpdatesIsLocal(bool expectedIsLocal)
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            context.IsLocal = expectedIsLocal;

            // Assert
            bool isLocal = context.IsLocal;
            Assert.Equal(expectedIsLocal, isLocal);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalGet_ReturnsIsLocalFromProperty_WhenRequestIsPresent(bool expected)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                request.Properties[HttpPropertyKeys.IsLocalKey] = new Lazy<bool>(() => expected);

                // Act
                bool actual = context.IsLocal;

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalGet_IgnoresRequest_AfterIsLocalSet(bool expectedIsLocal)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                context.IsLocal = expectedIsLocal;
                request.Properties[HttpPropertyKeys.IsLocalKey] =
                    new Lazy<bool>(() => !expectedIsLocal);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalGet_ReturnsThreadCurrentPrincipalFromConstructor()
        {
            // Arrange
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            Thread.CurrentPrincipal = expectedPrincipal;

            // Act
            HttpRequestContext context = CreateProductUnderTest();

            // Assert
            Thread.CurrentPrincipal = CreateDummyPrincipal();
            Assert.Same(expectedPrincipal, context.Principal);
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalGet_ReturnsThreadCurrentPrincipalFromConstructorWithRequest()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                IPrincipal expectedPrincipal = CreateDummyPrincipal();
                Thread.CurrentPrincipal = expectedPrincipal;

                // Act
                HttpRequestContext context = CreateProductUnderTest(request);

                // Assert
                Thread.CurrentPrincipal = CreateDummyPrincipal();
                Assert.Same(expectedPrincipal, context.Principal);
            }
        }

        [Fact]
        public void PrincipalSet_UpdatesPrincipal()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();
            IPrincipal expectedPrincipal = CreateDummyPrincipal();

            // Act
            context.Principal = expectedPrincipal;

            // Assert
            Assert.Same(expectedPrincipal, context.Principal);
        }

        [Fact]
        public void RouteDataGet_ReturnsNull_AsDefault()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            IHttpRouteData routeData = context.RouteData;

            // Assert
            Assert.Null(routeData);
        }

        [Fact]
        public void RouteDataSet_UpdatesRouteData()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();
            IHttpRouteData expectedRouteData = CreateDummyRouteData();

            // Act
            context.RouteData = expectedRouteData;

            // Assert
            IHttpRouteData routeData = context.RouteData;
            Assert.Same(expectedRouteData, routeData);
        }

        [Fact]
        public void RouteDataGet_ReturnsRouteDataFromProperty_WhenRequestIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                IHttpRouteData expectedRouteData = CreateDummyRouteData();
                request.Properties[HttpPropertyKeys.HttpRouteDataKey] = expectedRouteData;

                // Act
                IHttpRouteData routeData = context.RouteData;

                // Assert
                Assert.Same(expectedRouteData, routeData);
            }
        }

        [Fact]
        public void RouteDataGet_IgnoresRequest_AfterRouteDataSet()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                IHttpRouteData expectedRouteData = CreateDummyRouteData();
                context.RouteData = expectedRouteData;
                request.Properties[HttpPropertyKeys.HttpRouteDataKey] = CreateDummyRouteData();

                // Act
                IHttpRouteData routeData = context.RouteData;

                // Assert
                Assert.Same(expectedRouteData, routeData);
            }
        }

        [Fact]
        public void RouteDataGet_IgnoresRequest_AfterRouteDataSetNull()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                context.RouteData = null;
                request.Properties[HttpPropertyKeys.HttpRouteDataKey] = CreateDummyRouteData();

                // Act
                IHttpRouteData routeData = context.RouteData;

                // Assert
                Assert.Null(routeData);
            }
        }

        [Fact]
        public void UrlGet_ReturnsNull_AsDefault()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            UrlHelper url = context.Url;

            // Assert
            Assert.Null(url);
        }

        [Fact]
        public void UrlSet_UpdatesUrl()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();
            UrlHelper expectedUrl = CreateUrlHelper();

            // Act
            context.Url = expectedUrl;

            // Assert
            UrlHelper url = context.Url;
            Assert.Same(expectedUrl, url);
        }

        [Fact]
        public void UrlGet_ReturnsNewInstanceForRequest_WhenRequestIsPresent()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(expectedRequest);

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.NotNull(url);
                Assert.Same(expectedRequest, url.Request);
            }
        }

        [Fact]
        public void UrlGet_IgnoresRequest_AfterUrlSet()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                UrlHelper expectedUrl = CreateUrlHelper();
                context.Url = expectedUrl;

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.Same(expectedUrl, url);
            }
        }

        [Fact]
        public void UrlGet_IgnoresRequest_AfterUrlSetNull()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(request);
                context.Url = null;

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.Null(url);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsNull_AsDefault()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();

            // Act
            string virtualPathRoot = context.VirtualPathRoot;

            // Assert
            Assert.Null(virtualPathRoot);
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesVirtualPathRoot()
        {
            // Arrange
            HttpRequestContext context = CreateProductUnderTest();
            string expectedVirtualPathRoot = "/";

            // Act
            context.VirtualPathRoot = expectedVirtualPathRoot;

            // Assert
            string virtualPathRoot = context.VirtualPathRoot;
            Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsConfigurationVirtualPathRoot_WhenConfigurationIsPresent()
        {
            // Arrange
            string expectedVirtualPathRoot = "/";

            using (HttpConfiguration configuration = new HttpConfiguration(new HttpRouteCollection(
                expectedVirtualPathRoot)))
            {
                HttpRequestContext context = CreateProductUnderTest();
                context.Configuration = configuration;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Theory]
        [InlineData("a b")]
        [InlineData("/a b")]
        [InlineData("/a%20b")]
        public void VirtualPathRootGet_ReturnsUnescapedConfigurationVirtualPathRoot(string configurationVirtualPathRoot)
        {
            // Arrange
            var expectedVirtualPathRoot = "/a b";
            using (var routeCollection = new HttpRouteCollection(configurationVirtualPathRoot))
            using (var configuration = new HttpConfiguration(routeCollection))
            {
                var context = CreateProductUnderTest();
                context.Configuration = configuration;

                // Act
                var virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_IgnoresConfiguration_AfterVirtualPathRootSet()
        {
            // Arrange
            using (HttpConfiguration configuration = new HttpConfiguration(new HttpRouteCollection("other")))
            {
                HttpRequestContext context = CreateProductUnderTest();
                context.Configuration = configuration;
                string expectedVirtualPathRoot = "/";
                context.VirtualPathRoot = expectedVirtualPathRoot;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_IgnoresConfiguration_AfterVirtualPathRootSetNull()
        {
            // Arrange
            using (HttpConfiguration configuration = new HttpConfiguration(new HttpRouteCollection("other")))
            {
                HttpRequestContext context = CreateProductUnderTest();
                context.Configuration = configuration;
                context.VirtualPathRoot = null;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Null(virtualPathRoot);
            }
        }

        private static X509Certificate2 CreateCertificate()
        {
            return new X509Certificate2();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static IHttpRouteData CreateDummyRouteData()
        {
            return new Mock<IHttpRouteData>(MockBehavior.Strict).Object;
        }

        private static RequestBackedHttpRequestContext CreateProductUnderTest()
        {
            return new RequestBackedHttpRequestContext();
        }

        private static RequestBackedHttpRequestContext CreateProductUnderTest(HttpRequestMessage request)
        {
            return new RequestBackedHttpRequestContext(request);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static UrlHelper CreateUrlHelper()
        {
            return new UrlHelper();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ResponseMessageResultConverterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http.Controllers
{
    public class ResponseMessageResultConverterTest
    {
        private readonly ResponseMessageResultConverter _converter = new ResponseMessageResultConverter();
        private readonly HttpControllerContext _context = new HttpControllerContext();
        private readonly HttpRequestMessage _request = new HttpRequestMessage();

        public ResponseMessageResultConverterTest()
        {
            _context.Request = _request;
            _context.Configuration = new HttpConfiguration();
        }

        [Fact]
        public void Convert_WhenValueIsResponseMessage_ReturnsResponseMessageWithRequestAssigned()
        {
            HttpResponseMessage response = new HttpResponseMessage();

            var result = _converter.Convert(_context, response);

            Assert.Same(response, result);
            Assert.Same(_request, result.RequestMessage);
        }

        [Fact]
        public void Convert_WhenContextIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => _converter.Convert(controllerContext: null, actionResult: new HttpResponseMessage()), "controllerContext");
        }

        [Fact]
        public void Convert_WhenValueIsNull_Throws()
        {
            Assert.Throws<InvalidOperationException>(() => _converter.Convert(_context, null),
                "A null value was returned where an instance of HttpResponseMessage was expected.");
        }

        [Fact]
        public void Convert_WhenValueIsIncompatibleType_Throws()
        {
            Assert.Throws<InvalidCastException>(() => _converter.Convert(_context, "42"),
                "Unable to cast object of type 'System.String' to type 'System.Net.Http.HttpResponseMessage'.");
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/ValueResultConverterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using Microsoft.TestCommon;

namespace System.Web.Http.Controllers
{
    public class ValueResultConverterTest
    {
        private readonly ValueResultConverter<object> _objectValueConverter = new ValueResultConverter<object>();
        private readonly ValueResultConverter<Animal> _animalValueConverter = new ValueResultConverter<Animal>();
        private readonly HttpControllerContext _context = new HttpControllerContext();
        private readonly HttpRequestMessage _request = new HttpRequestMessage();

        public ValueResultConverterTest()
        {
            _context.Request = _request;
            _context.Configuration = new HttpConfiguration();
        }

        [Fact]
        public void Convert_WhenContextIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => _objectValueConverter.Convert(controllerContext: null, actionResult: new object()), "controllerContext");
        }

        [Fact]
        public void Convert_WhenValueTypeIsNotCompatible_Throws()
        {
            Assert.Throws<InvalidCastException>(() => _animalValueConverter.Convert(_context, new object()),
                "Unable to cast object of type 'System.Object' to type 'Animal'.");
        }

        [Fact]
        public void Convert_WhenValueIsResponseMessage_ReturnsResponseMessageWithRequestAssigned()
        {
            HttpResponseMessage response = new HttpResponseMessage();

            var result = _objectValueConverter.Convert(_context, response);

            Assert.Same(response, result);
            Assert.Same(_request, result.RequestMessage);
        }

        [Fact]
        public void Convert_WhenValueIsAnyType_CreatesContentNegotiatedResponse()
        {
            Dog dog = new Dog();
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            _context.Configuration.Formatters.Clear();
            _context.Configuration.Formatters.Add(formatter);

            var result = _animalValueConverter.Convert(_context, dog);

            Assert.Equal(HttpStatusCode.OK, result.StatusCode);
            var content = Assert.IsType<ObjectContent<Animal>>(result.Content);
            Assert.Same(dog, content.Value);
            Assert.Same(formatter, content.Formatter);
            Assert.Same(_request, result.RequestMessage);
        }

        public class Animal { }
        public class Dog : Animal { }
    }
}


================================================
FILE: test/System.Web.Http.Test/Controllers/VoidResultConverterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http.Controllers
{
    public class VoidResultConverterTest
    {
        private readonly VoidResultConverter _converter = new VoidResultConverter();
        private readonly HttpControllerContext _context = new HttpControllerContext();
        private readonly HttpRequestMessage _request = new HttpRequestMessage();

        public VoidResultConverterTest()
        {
            _context.Request = _request;
            _context.Configuration = new HttpConfiguration();
        }

        [Fact]
        public void Convert_WhenContextIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => _converter.Convert(controllerContext: null, actionResult: null), "controllerContext");
        }

        [Fact]
        public void Convert_ReturnsResponseMessageWithRequestAssignedAndNoContentToReflectVoid()
        {
            var result = _converter.Convert(_context, null);

            Assert.Equal(HttpStatusCode.NoContent, result.StatusCode);
            Assert.NotNull(result.Content);
            Assert.Equal(0L, result.Content.Headers.ContentLength);
            Assert.Same(_request, result.RequestMessage);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Description/ApiExplorerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Description
{
    public class ApiExplorerTest
    {
        [Fact]
        public void Descriptions_RecognizesDirectRoutes()
        {
            var config = new HttpConfiguration();
            var routeTemplate = "api/values";
            var controllerDescriptor = new HttpControllerDescriptor(config, "ApiExplorerValues", typeof(ApiExplorerValuesController));
            var action = new ReflectedHttpActionDescriptor(controllerDescriptor, typeof(ApiExplorerValuesController).GetMethod("Get"));
            var actions = new ReflectedHttpActionDescriptor[] { action };
            config.Routes.Add("Route", CreateDirectRoute(routeTemplate, actions));

            var descriptions = new ApiExplorer(config).ApiDescriptions;

            ApiDescription description = Assert.Single(descriptions);
            Assert.Equal(HttpMethod.Get, description.HttpMethod);
            Assert.Equal(routeTemplate, description.RelativePath);
            Assert.Equal(action, description.ActionDescriptor);
        }

        [Fact]
        public void Descriptions_RecognizesIgnoreApiForDirectRoutes_Action()
        {
            var config = new HttpConfiguration();
            var routeTemplate = "api/values";
            var controllerDescriptor = new HttpControllerDescriptor(config, "ApiExplorerValues", typeof(ApiExplorerValuesController));
            var actions = new ReflectedHttpActionDescriptor[] 
            {
                new ReflectedHttpActionDescriptor(controllerDescriptor, typeof(ApiExplorerValuesController).GetMethod("Get")),
                new ReflectedHttpActionDescriptor(controllerDescriptor, typeof(ApiExplorerValuesController).GetMethod("Post")),
            };
            config.Routes.Add("Route", CreateDirectRoute(routeTemplate, actions));

            var descriptions = new ApiExplorer(config).ApiDescriptions;

            ApiDescription description = Assert.Single(descriptions);
            Assert.Equal(HttpMethod.Get, description.HttpMethod);
            Assert.Equal(routeTemplate, description.RelativePath);
        }

        [Fact]
        public void Descriptions_RecognizesIgnoreApiForDirectRoutes_Controller()
        {
            var config = new HttpConfiguration();
            var routeTemplate = "api/values";
            var controllerDescriptor = new HttpControllerDescriptor(config, "IgnoreApiValues", typeof(IgnoreApiValuesController));
            var actions = new ReflectedHttpActionDescriptor[] 
            {
                new ReflectedHttpActionDescriptor(controllerDescriptor, typeof(IgnoreApiValuesController).GetMethod("Get")),
                new ReflectedHttpActionDescriptor(controllerDescriptor, typeof(IgnoreApiValuesController).GetMethod("Post")),
            };
            config.Routes.Add("Route", CreateDirectRoute(routeTemplate, actions));

            var descriptions = new ApiExplorer(config).ApiDescriptions;

            Assert.Empty(descriptions);
        }

        public class ApiExplorerValuesController : ApiController
        {
            public void Get() { }

            [ApiExplorerSettings(IgnoreApi = true)]
            public void Post() { }
        }

        [ApiExplorerSettings(IgnoreApi = true)]
        public class IgnoreApiValuesController : ApiController
        {
            public void Get() { }
            public void Post() { }
        }

        [Fact]
        public void Descriptions_RecognizesCompositeRoutes()
        {
            var config = new HttpConfiguration();
            var routeTemplate = "api/values";
            var controllerDescriptor = new HttpControllerDescriptor(config, "AttributeApiExplorerValues", typeof(AttributeApiExplorerValuesController));
            var action = new ReflectedHttpActionDescriptor(controllerDescriptor, typeof(AttributeApiExplorerValuesController).GetMethod("Action"));
            var actions = new ReflectedHttpActionDescriptor[] { action };

            var routeCollection = new List<IHttpRoute>();
            routeCollection.Add(CreateDirectRoute(routeTemplate, actions));

            RouteCollectionRoute route = new RouteCollectionRoute();
            route.EnsureInitialized(() => routeCollection);

            config.Routes.Add("Route", route);

            var descriptions = new ApiExplorer(config).ApiDescriptions;

            ApiDescription description = Assert.Single(descriptions);
            Assert.Equal(HttpMethod.Get, description.HttpMethod);
            Assert.Equal(routeTemplate, description.RelativePath);
            Assert.Equal(action, description.ActionDescriptor);
        }

        [Fact]
        public void TryExpandUriParameters_EnsureNoKeyConflicts()
        {
            // This test ensures that keys adding to parameterValuesForRoute are case-insensitive
            // and would not cause any exeception if it already has the key. So set up two
            // ApiParameterDescription instances, one with "id" and another with "Id". Act the
            // method and assert that no exception occurs and the output is correct.
            // Arrange
            string expectedExpandedRouteTemplate = "?id={id}";
            string expandedRouteTemplate;
            Mock<HttpParameterDescriptor> parameterDescriptorMock = new Mock<HttpParameterDescriptor>();
            parameterDescriptorMock.SetupGet(p => p.ParameterType).Returns(typeof(ClassWithId));
            List<ApiParameterDescription> descriptions = new List<ApiParameterDescription>()
            {
                new ApiParameterDescription()
                {
                    Source = ApiParameterSource.FromUri,
                    Name = "id"
                },
                new ApiParameterDescription()
                {
                    Source = ApiParameterSource.FromUri,
                    ParameterDescriptor = parameterDescriptorMock.Object
                },
            };

            // Act
            bool isExpanded = ApiExplorer.TryExpandUriParameters(new HttpRoute(),
                                                     new HttpParsedRoute(new List<PathSegment>()),
                                                     descriptions,
                                                     out expandedRouteTemplate);

            // Assert
            Assert.True(isExpanded);
            Assert.Equal(expectedExpandedRouteTemplate, expandedRouteTemplate);
        }


        [Theory]
        // Simple type
        [InlineData("?id={id}", typeof(int), "id")]
        // Simple Array and Collection
        [InlineData("?id[0]={id[0]}&id[1]={id[1]}", typeof(int[]), "id")]
        [InlineData("?id[0]={id[0]}&id[1]={id[1]}", typeof(string[]), "id")]
        [InlineData("?id[0]={id[0]}&id[1]={id[1]}", typeof(IList<string>), "id")]
        [InlineData("?id[0]={id[0]}&id[1]={id[1]}", typeof(List<string>), "id")]
        [InlineData("?id[0]={id[0]}&id[1]={id[1]}", typeof(IEnumerable<string>), "id")]
        [InlineData("?id[0]={id[0]}&id[1]={id[1]}", typeof(ICollection<int>), "id")]
        // Complex Array and Collection
        [InlineData("?users[0].Name={users[0].Name}&users[0].Age={users[0].Age}" +
                        "&users[1].Name={users[1].Name}&users[1].Age={users[1].Age}",
                    typeof(IEnumerable<User>),
                    "users")]
        [InlineData("?users[0].Name={users[0].Name}&users[0].Age={users[0].Age}" +
                        "&users[1].Name={users[1].Name}&users[1].Age={users[1].Age}",
                    typeof(User[]),
                    "users")]
        // MutableObject
        [InlineData("?Foo={Foo}&Bar={Bar}", typeof(MutableObject), "mutable")]
        // KeyValuePair
        [InlineData("?key={key}&value={value}", typeof(KeyValuePair<string, string>), "pair")]
        // Dictionary
        [InlineData("?dict[0].key={dict[0].key}&dict[0].value={dict[0].value}&dict[1].key={dict[1].key}" +
                        "&dict[1].value={dict[1].value}",
                    typeof(Dictionary<string, string>),
                    "dict")]
        // MutableObject extending IList<> does not generate query string samples like ?id[0]={id[0]}&id[1]={id[1]}.
        // Note that the "Item" query string in the following is not valid,
        // which is a bug but will happen in rare cases.
        [InlineData("?Foo={Foo}&Bar={Bar}&Capacity={Capacity}&Item={Item}",
                    typeof(GenericMutableObject<string>),
                    "genericMutable")]
        public void TryExpandUriParameters_FromUri_Succeeds(string expectedPath,
                                                                      Type parameterType,
                                                                      string parameterName)
        {
            // Arrange
            string finalPath;
            List<ApiParameterDescription> descriptions = new List<ApiParameterDescription>()
            {
                CreateApiParameterDescription(parameterType, parameterName),
            };

            // Act
            bool isExpanded = ApiExplorer.TryExpandUriParameters(new HttpRoute(),
                                                     new HttpParsedRoute(new List<PathSegment>()),
                                                     descriptions,
                                                     out finalPath);

            // Assert
            Assert.True(isExpanded);
            Assert.Equal(expectedPath, finalPath);
        }

        [Fact]
        public void TryExpandUriParameters_CompositeParametersFromUri_Succeeds()
        {
            // Arrange
            string finalPath;
            const string expectedPath = 
                "?id[0]={id[0]}&id[1]={id[1]}&property[0]={property[0]}&property[1]={property[1]}&name={name}";
            List<ApiParameterDescription> descriptions = new List<ApiParameterDescription>()
            {
                CreateApiParameterDescription(typeof(int[]), "id"),
                CreateApiParameterDescription(typeof(ICollection<string>), "property"),
                CreateApiParameterDescription(typeof(string), "name"),
            };

            // Act
            bool isExpanded = ApiExplorer.TryExpandUriParameters(new HttpRoute(),
                                                     new HttpParsedRoute(new List<PathSegment>()),
                                                     descriptions,
                                                     out finalPath);

            // Assert
            Assert.True(isExpanded);
            Assert.Equal(expectedPath, finalPath);
        }

        [Fact]
        public void Descriptions_RecognizesMixedCaseParameters()
        {
            // Ensure that two "Id"s, one from "api/values/{id}" and another "Id" from ClassWithId,
            // would not cause any exception and only one of them is added.
            var config = new HttpConfiguration();
            var routeTemplate = "api/values/{id}";
            var controllerDescriptor = new HttpControllerDescriptor(config, "ApiExplorerValues", typeof(DuplicatedIdController));
            var action = new ReflectedHttpActionDescriptor(controllerDescriptor, typeof(DuplicatedIdController).GetMethod("Get"));
            var actions = new ReflectedHttpActionDescriptor[] { action };
            config.Routes.Add("Route", CreateDirectRoute(routeTemplate, actions));

            var descriptions = new ApiExplorer(config).ApiDescriptions;

            ApiDescription description = Assert.Single(descriptions);
            Assert.Equal(HttpMethod.Get, description.HttpMethod);
            Assert.Equal(routeTemplate, description.RelativePath, StringComparer.OrdinalIgnoreCase);
            Assert.Equal(action, description.ActionDescriptor);
        }

        private class ClassWithId
        {
            public int Id { get; set; }
        }

        private class DuplicatedIdController : ApiController
        {
            public void Get([FromUri] ClassWithId objectWithId) { }
        }

        public class AttributeApiExplorerValuesController : ApiController
        {
            [Route("")]
            [HttpGet]
            public void Action() { }
        }

        private static IHttpRoute CreateDirectRoute(string template,
            IReadOnlyCollection<ReflectedHttpActionDescriptor> actions)
        {
            DirectRouteBuilder builder = new DirectRouteBuilder(actions, targetIsAction: true);
            builder.Template = template;
            return builder.Build().Route;
        }

        private ApiParameterDescription CreateApiParameterDescription(Type type, string name)
        {
            Mock<HttpParameterDescriptor> parameterDescriptorMock = new Mock<HttpParameterDescriptor>();
            parameterDescriptorMock.SetupGet(p => p.ParameterName).Returns(name);
            parameterDescriptorMock.SetupGet(p => p.ParameterType).Returns(type);
            return new ApiParameterDescription()
            {
                Source = ApiParameterSource.FromUri,
                ParameterDescriptor = parameterDescriptorMock.Object,
                Name = name
            };
        }

        private class MutableObject
        {
            public string Foo { get; set; }
            public string Bar { get; set; }
        }

        private class GenericMutableObject<T> : List<T>
        {
            public string Foo { get; set; }
            public string Bar { get; set; }
        }

        private class User
        {
            public string Name { get; set; }
            public int Age { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Description/ApiParameterDescriptionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Description
{
    public class ApiParameterDescriptionTest
    {
        [Fact]
        public void GetBindableProperties_WorksOnlyFor_PublicInstanceProperties_WithPublicGettersAndSetters()
        {
            // Arrange
            ApiParameterDescription parameter = new ApiParameterDescription();
            Mock<HttpParameterDescriptor> parameterDescriptorMock = new Mock<HttpParameterDescriptor>();
            parameterDescriptorMock.SetupGet(p => p.ParameterType).Returns(typeof(ClassWithAllKindsOfProperties));
            parameter.ParameterDescriptor = parameterDescriptorMock.Object;

            // Act
            IEnumerable<PropertyInfo> bindableProperties = parameter.GetBindableProperties();

            // Assert
            PropertyInfo bindableProperty = Assert.Single(bindableProperties);
            Assert.Equal("ValidProperty", bindableProperty.Name);
        }
    }

    internal class ClassWithAllKindsOfProperties
    {
        public int ValidProperty { get; set; }
        public static string InvalidProperty { get; set; }
        public int PropertyWithPrivateSetter { get; private set; }
        public int PropertyWithPrivateGetter { private get; set; }
        internal int InternalProperty { get; set; }
        protected int ProtectedProperty { get; private set; }
        private int PrivateProperty { get; set; }
        public int PropertyWithoutSetter { get { return 0; } }
        public int PropertyWithoutGetter { set { return; } }
    }
}


================================================
FILE: test/System.Web.Http.Test/Dispatcher/DefaultAssembliesResolverTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Http.Services;
using Microsoft.TestCommon;

namespace System.Web.Http.Dispatcher
{
    public class DefaultAssembliesResolverTest
    {
        [Fact]
        public void GetAssemblies_ContainsCurrentAssembly()
        {
            IAssembliesResolver ar = new DefaultAssembliesResolver();
            Assembly currentAssembly = typeof(DefaultAssembliesResolverTest).Assembly;

            Assert.True(ar.GetAssemblies().Contains(currentAssembly));
        }

        [Fact]
        public void Class_IsDefaultIAssembliesResolver()
        {
            var serviceResolver = new DefaultServices(new HttpConfiguration());

            Assert.IsType<DefaultAssembliesResolver>(serviceResolver.GetService(typeof(IAssembliesResolver)));
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Dispatcher/DefaultHttpControllerActivatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.Hosting;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Dispatcher
{
    public class DefaultHttpControllerActivatorTest
    {
        // Create tests

        [Fact]
        public void Create_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage();
            request.SetConfiguration(config);
            var descriptor = new HttpControllerDescriptor(config, "Simple", typeof(SimpleController));
            var activator = new DefaultHttpControllerActivator();

            // Act & assert
            Assert.ThrowsArgumentNull(() => activator.Create(request: null, controllerDescriptor: descriptor, controllerType: typeof(SimpleController)), "request");
            Assert.ThrowsArgumentNull(() => activator.Create(request, controllerDescriptor: null, controllerType: typeof(SimpleController)), "controllerDescriptor");
            Assert.ThrowsArgumentNull(() => activator.Create(request, descriptor, controllerType: null), "controllerType");
            Assert.Throws<InvalidOperationException>(
                () => activator.Create(request, descriptor, typeof(AbstractController)),
                "An error occurred when trying to create a controller of type 'AbstractController'. Make sure that the controller has a parameterless public constructor.");
            Assert.Throws<InvalidOperationException>(
                () => activator.Create(request, descriptor, typeof(ControllerWithCtorParams)),
                "An error occurred when trying to create a controller of type 'ControllerWithCtorParams'. Make sure that the controller has a parameterless public constructor.");
        }

        [Fact]
        public void Create_MakesInstanceOfController()
        {
            // Arrange
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage();
            request.SetConfiguration(config);
            var descriptor = new HttpControllerDescriptor(config, "Simple", typeof(SimpleController));
            var activator = new DefaultHttpControllerActivator();

            // Act
            IHttpController result = activator.Create(request, descriptor, typeof(SimpleController));

            // Assert
            Assert.NotNull(result);
            Assert.IsType<SimpleController>(result);
        }

        [Fact]
        public void Create_UsesControllerFromRequestLevelDependencyScope()
        {
            // Arrange
            var controller = new ControllerWithCtorParams(42);
            var mockScope = new Mock<IDependencyScope>();
            mockScope.Setup(r => r.GetService(typeof(ControllerWithCtorParams))).Returns(controller).Verifiable();
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage();
            request.SetConfiguration(config);
            request.Properties[HttpPropertyKeys.DependencyScope] = mockScope.Object;
            var descriptor = new HttpControllerDescriptor(config, "Name", typeof(ControllerWithCtorParams));
            var activator = new DefaultHttpControllerActivator();

            // Act
            IHttpController result = activator.Create(request, descriptor, typeof(ControllerWithCtorParams));

            // Assert
            Assert.Same(controller, result);
            mockScope.Verify();
        }

        [Fact]
        public void Create_DoesnotCacheControllerFromRequestLevelDependencyScope()
        {
            // Arrange
            int count = 0;
            var controller = new ControllerWithCtorParams(42);
            var mockScope = new Mock<IDependencyScope>();
            mockScope.Setup(r => r.GetService(typeof(ControllerWithCtorParams))).Returns(() =>
            {
                count++;
                return new ControllerWithCtorParams(42);
            }).Verifiable();
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage();
            request.SetConfiguration(config);
            request.Properties[HttpPropertyKeys.DependencyScope] = mockScope.Object;
            var descriptor = new HttpControllerDescriptor(config, "Name", typeof(ControllerWithCtorParams));
            var activator = new DefaultHttpControllerActivator();

            // Act
            IHttpController result1 = activator.Create(request, descriptor, typeof(ControllerWithCtorParams));
            IHttpController result2 = activator.Create(request, descriptor, typeof(ControllerWithCtorParams));

            // Assert
            Assert.NotEqual(result1, result2);
            mockScope.Verify();
            Assert.Equal(2, count);
        }

        [Fact]
        public void Create_MixupInstanceCreationAndDependencyScope()
        {
            // Arrange
            var controller = new ControllerWithCtorParams(42);
            var mockScope = new Mock<IDependencyScope>();
            mockScope.Setup(r => r.GetService(typeof(ControllerWithCtorParams))).Returns(controller).Verifiable();
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage();
            request.SetConfiguration(config);
            request.Properties[HttpPropertyKeys.DependencyScope] = mockScope.Object;
            var descriptorControllerWithCtorParamsResult = new HttpControllerDescriptor(config, "Name", typeof(ControllerWithCtorParams));
            var descriptorSimpleController = new HttpControllerDescriptor(config, "Simple", typeof(SimpleController));
            var activator = new DefaultHttpControllerActivator();

            // Act
            IHttpController simpleController = activator.Create(request, descriptorSimpleController, typeof(SimpleController));
            IHttpController controllerWithCtorParamsResult = activator.Create(request, descriptorControllerWithCtorParamsResult, typeof(ControllerWithCtorParams));

            // Assert
            Assert.NotNull(simpleController);
            Assert.IsType<SimpleController>(simpleController);
            Assert.Same(controller, controllerWithCtorParamsResult);
            mockScope.Verify();
        }

        [Fact]
        public void Create_ThrowsForNullDependencyScope()
        {
            // Arrange
            var config = new HttpConfiguration();
            var mockResolver = new Mock<IDependencyResolver>();
            mockResolver.Setup(resolver => resolver.BeginScope()).Returns((IDependencyScope)null).Verifiable();
            config.DependencyResolver = mockResolver.Object;
            var request = new HttpRequestMessage();
            request.SetConfiguration(config);
            var descriptorSimpleController = new HttpControllerDescriptor(config, "Simple", typeof(SimpleController));
            var activator = new DefaultHttpControllerActivator();

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(
                () => activator.Create(request, descriptorSimpleController, typeof(SimpleController)));

            Assert.Equal(
                "An error occurred when trying to create a controller of type 'SimpleController'. Make sure that the controller has a parameterless public constructor.",
                exception.Message);
            Assert.NotNull(exception.InnerException);
            Assert.Matches(
                "A dependency resolver of type 'IDependencyResolverProxy' returned an invalid value of null from its " +
                "BeginScope method. If the container does not have a concept of scope, consider returning a scope " +
                "that resolves in the root of the container instead.",
                exception.InnerException.Message);

            mockResolver.Verify();
        }

        // Helper classes

        abstract class AbstractController : ApiController { }

        class SimpleController : ApiController { }

        class ControllerWithCtorParams : ApiController
        {
            public ControllerWithCtorParams(int unused) { }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Dispatcher/DefaultHttpControllerSelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Dispatcher
{
    public class DefaultHttpControllerSelectorTest
    {
        [Fact]
        public void Constructor_Throws_NullConfiguration()
        {
            Assert.ThrowsArgumentNull(
                () => new DefaultHttpControllerSelector(configuration: null),
                "configuration");
        }

        [Theory]
        [InlineData("controller", "abc")]
        [InlineData("Controller", "123")]
        [InlineData("ControLler", "123")]
        [InlineData("CONTROLLER", "ABC")]
        public void GetControllerName_PicksControllerNameFromRouteData(string controllerKeyName, string controllerName)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            IHttpRouteData routeData = GetRouteData();
            routeData.Values[controllerKeyName] = controllerName;
            request.SetRouteData(routeData);
            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(new HttpConfiguration());

            // Act
            string selectedControllerName = selector.GetControllerName(request);

            // Assert
            Assert.Equal(controllerName, selectedControllerName);
        }

        [Fact]
        public void GetControllerName_PicksNull_NoRouteData()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(new HttpConfiguration());

            // Act
            string selectedControllerName = selector.GetControllerName(request);

            // Assert
            Assert.Null(selectedControllerName);
        }

        [Fact]
        public void GetControllerName_PicksNull_EmptyRouteData()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetRouteData(GetRouteData());
            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(new HttpConfiguration());

            // Act
            string selectedControllerName = selector.GetControllerName(request);

            // Assert
            Assert.Null(selectedControllerName);
        }

        [Fact]
        public void DefaultHttpControllerSelector_Uses_IAssemblyResolverAndIHttpControllerTypeResolver()
        {
            // Arrange
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IAssembliesResolver> assemblyResolver = new Mock<IAssembliesResolver>();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IAssembliesResolver), assemblyResolver.Object);
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);

            controllerTypeResolver.Setup(c => c.GetControllerTypes(assemblyResolver.Object)).Returns(new Collection<Type> { GetMockControllerType("Sample") }).Verifiable();
            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            HttpRequestMessage request = new HttpRequestMessage();
            IHttpRouteData routeData = GetRouteData();
            routeData.Values["controller"] = "Sample";
            request.SetRouteData(routeData);

            // Act
            selector.SelectController(request);

            // Assert
            controllerTypeResolver.Verify();
        }

        [Theory]
        [InlineData("Sample")]
        [InlineData("SAmple")]
        [InlineData("SAMPLE")]
        public void SelectController_IsCaseInsensitive(string controllerTypeName)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);

            Type controllerType = GetMockControllerType("Sample");
            controllerTypeResolver
                .Setup(c => c.GetControllerTypes(It.IsAny<IAssembliesResolver>()))
                .Returns(new Collection<Type> { controllerType });

            HttpRequestMessage request = new HttpRequestMessage();
            IHttpRouteData routeData = GetRouteData();
            routeData.Values["controller"] = controllerTypeName;
            request.SetRouteData(routeData);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            HttpControllerDescriptor descriptor = selector.SelectController(request);

            // Assert
            Assert.IsType<HttpControllerDescriptor>(descriptor);
            Assert.Equal(controllerType, descriptor.ControllerType);
        }

        [Fact]
        public void SelectController_DoesNotCreateNewInstances_ForSameController()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);

            Type controllerType = GetMockControllerType("Sample");
            controllerTypeResolver
                .Setup(c => c.GetControllerTypes(It.IsAny<IAssembliesResolver>()))
                .Returns(new Collection<Type> { controllerType });

            HttpRequestMessage request = new HttpRequestMessage();
            IHttpRouteData routeData = GetRouteData();
            routeData.Values["controller"] = "Sample";
            request.SetRouteData(routeData);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            HttpControllerDescriptor descriptor1 = selector.SelectController(request);
            HttpControllerDescriptor descriptor2 = selector.SelectController(request);

            // Assert
            Assert.ReferenceEquals(descriptor1, descriptor2);
        }

        [Fact]
        public void SelectController_DoesNotCreateNewInstances_ForSameController_DiferentCasedControllerName()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);

            Type controllerType = GetMockControllerType("Sample");
            controllerTypeResolver
                .Setup(c => c.GetControllerTypes(It.IsAny<IAssembliesResolver>()))
                .Returns(new Collection<Type> { controllerType });

            HttpRequestMessage request1 = new HttpRequestMessage();
            IHttpRouteData routeData1 = GetRouteData();
            routeData1.Values["controller"] = "Sample";
            request1.SetRouteData(routeData1);

            HttpRequestMessage request2 = new HttpRequestMessage();
            IHttpRouteData routeData2 = GetRouteData();
            routeData2.Values["controller"] = "SaMPle";
            request2.SetRouteData(routeData2);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            HttpControllerDescriptor descriptor1 = selector.SelectController(request1);
            HttpControllerDescriptor descriptor2 = selector.SelectController(request2);

            // Assert
            Assert.ReferenceEquals(descriptor1, descriptor2);
        }

        [Fact]
        public void SelectController_Throws_NullRequest()
        {
            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(new HttpConfiguration());

            Assert.ThrowsArgumentNull(
                () => selector.SelectController(request: null),
                "request");
        }

        [Fact]
        public void SelectController_Throws_NotFound_NoControllerInRouteData()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetRouteData(GetRouteData());

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            var ex = Assert.Throws<HttpResponseException>(
                () => selector.SelectController(request));

            // Assert
            Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
        }

        [Fact]
        public void SelectController_RespectsDirectRoutes()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            HttpRequestMessage request = new HttpRequestMessage();
            var controllerDescriptor = new HttpControllerDescriptor();
            var action1Descriptor = new ReflectedHttpActionDescriptor() { ControllerDescriptor = controllerDescriptor };
            var action2Descriptor = new ReflectedHttpActionDescriptor() { ControllerDescriptor = controllerDescriptor };
            IHttpRouteData routeData = GetRouteData();
            routeData.Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { action1Descriptor, action2Descriptor });
            request.SetRouteData(routeData);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            var selectedController = selector.SelectController(request);

            // Assert
            Assert.Same(controllerDescriptor, selectedController);
        }

        [Fact]
        public void SelectController_ThrowsOnDirectRoutesWithDifferentControllers()
        {
            var action1Descriptor = new ReflectedHttpActionDescriptor()
            {
                ControllerDescriptor = new HttpControllerDescriptor()
                {
                    ControllerType = GetMockControllerType("Controller1"),
                }
            };

            var action2Descriptor = new ReflectedHttpActionDescriptor()
            {
                ControllerDescriptor = new HttpControllerDescriptor()
                {
                    ControllerType = GetMockControllerType("Controller2"),
                }
            };

            IHttpRouteData routeData = GetRouteData();
            routeData.Route.DataTokens.Add("actions", new ReflectedHttpActionDescriptor[] { action1Descriptor, action2Descriptor });

            HttpConfiguration configuration = new HttpConfiguration();
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetRouteData(routeData);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            string expectedMessage =
                "Multiple controller types were found that match the URL. This can happen if attribute routes on multiple " +
                "controllers match the requested URL." + Environment.NewLine +
                Environment.NewLine +
                "The request has found the following matching controller types: " + Environment.NewLine +
                "FullController1Controller" + Environment.NewLine +
                "FullController2Controller";

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => selector.SelectController(request), expectedMessage);
        }

        [Fact]
        public void SelectController_Throws_NotFound_NoRouteData()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            HttpRequestMessage request = new HttpRequestMessage();

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            var ex = Assert.Throws<HttpResponseException>(
                () => selector.SelectController(request));

            // Assert
            Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
        }

        // We ignore attribute routes when RouteData.Route is null
        // See: https://aspnetwebstack.codeplex.com/workitem/1996
        [Fact]
        public void SelectController_WhenRouteData_RouteIsNull_FindsController()
        {
            // Arrange
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);

            Type controllerType = GetMockControllerType("Sample");
            controllerTypeResolver
                .Setup(c => c.GetControllerTypes(It.IsAny<IAssembliesResolver>()))
                .Returns(new Collection<Type> { controllerType });

            HttpRequestMessage request = new HttpRequestMessage();

            var routeValues = new Dictionary<string, object>(StringComparer.Ordinal)
            {
                { "controller", "Sample" }
            };

            var routeData = new Mock<IHttpRouteData>();
            routeData.SetupGet(rd => rd.Values).Returns(routeValues);
            routeData.SetupGet(rd => rd.Route).Returns((IHttpRoute)null);
            request.SetRouteData(routeData.Object);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            var controller = selector.SelectController(request);

            // Assert
            Assert.Equal(controllerType, controller.ControllerType);
        }

        // We ignore attribute routes when RouteData.Route is null
        // See: https://aspnetwebstack.codeplex.com/workitem/1996
        [Fact]
        public void SelectController_WhenRouteData_RouteIsNull_DoesNotFindController()
        {
            // Arrange
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);

            controllerTypeResolver
                .Setup(c => c.GetControllerTypes(It.IsAny<IAssembliesResolver>()))
                .Returns(new Collection<Type> {}); // No controllers here

            HttpRequestMessage request = new HttpRequestMessage();

            var routeValues = new Dictionary<string, object>(StringComparer.Ordinal)
            {
                { "controller", "Sample" }
            };

            var routeData = new Mock<IHttpRouteData>();
            routeData.SetupGet(rd => rd.Values).Returns(routeValues);
            routeData.SetupGet(rd => rd.Route).Returns((IHttpRoute)null);
            request.SetRouteData(routeData.Object);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            var ex = Assert.Throws<HttpResponseException>(
                () => selector.SelectController(request));

            // Assert
            Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
        }

        [Fact]
        public async Task SelectController_Throws_NotFound_NoMatchingControllerType()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);
            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            controllerTypeResolver
                .Setup(c => c.GetControllerTypes(It.IsAny<IAssembliesResolver>()))
                .Returns(new Collection<Type>());

            HttpRequestMessage request = new HttpRequestMessage();
            IHttpRouteData routeData1 = GetRouteData();
            routeData1.Values["controller"] = "Sample";
            request.SetRouteData(routeData1);
            request.SetConfiguration(configuration);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            var ex = Assert.Throws<HttpResponseException>(
                () => selector.SelectController(request));

            // Assert
            Assert.Equal(HttpStatusCode.NotFound, ex.Response.StatusCode);
            var result = await ex.Response.Content.ReadAsAsync<HttpError>();
            string response = result["MessageDetail"] as string;
            Assert.Equal("No type was found that matches the controller named 'Sample'.", response);
        }

        [Fact]
        public void SelectController_Throws_DuplicateController()
        {
            HttpConfiguration configuration = new HttpConfiguration();
            Mock<IHttpControllerTypeResolver> controllerTypeResolver = new Mock<IHttpControllerTypeResolver>();
            configuration.Services.Replace(typeof(IHttpControllerTypeResolver), controllerTypeResolver.Object);
            configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

            controllerTypeResolver
                .Setup(c => c.GetControllerTypes(It.IsAny<IAssembliesResolver>()))
                .Returns(new Collection<Type> { GetMockControllerType("Sample"), GetMockControllerType("SampLe"), GetMockControllerType("SAmpLE") });

            HttpRequestMessage request = new HttpRequestMessage();
            IHttpRouteData routeData1 = GetRouteData();
            routeData1.Values["controller"] = "Sample";
            request.SetRouteData(routeData1);
            request.SetConfiguration(configuration);

            DefaultHttpControllerSelector selector = new DefaultHttpControllerSelector(configuration);

            // Act
            var ex = Assert.Throws<InvalidOperationException>(
                () => selector.SelectController(request));

            // Assert
            string message = ex.Message;
            Assert.Contains(
                "Multiple types were found that match the controller named 'Sample'. This can happen if the route that services this request ('') found multiple controllers defined with the same name but differing namespaces, which is not supported.\r\n\r\nThe request for 'Sample' has found the following matching controllers:",
                message);

            var duplicateControllers = message.Split(':')[1].Split('\n').Select(str => str.Trim());
            Assert.Contains("FullSampleController", duplicateControllers);
            Assert.Contains("FullSampLeController", duplicateControllers);
            Assert.Contains("FullSAmpLEController", duplicateControllers);
        }

        private static IHttpRouteData GetRouteData()
        {
            HttpRoute route = new HttpRoute();
            HttpRouteData routeData = new HttpRouteData(route);

            return routeData;
        }

        private static Type GetMockControllerType(string controllerName)
        {
            Mock<Type> mockType = new Mock<Type>();

            mockType.Setup(t => t.Name).Returns(controllerName + "Controller");
            mockType.Setup(t => t.FullName).Returns("Full" + controllerName + "Controller");
            return mockType.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Dispatcher/DefaultHttpControllerTypeResolverTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Dispatcher
{
    public class DefaultHttpControllerTypeResolverTest
    {
        public static TheoryDataSet<Type> ValidControllerTypes
        {
            get
            {
                return new TheoryDataSet<Type>
                {
                    typeof(validcontroller),
                    typeof(ValidController),
                    typeof(VALIDController),
                    typeof(VALIDCONTROLLER),
                    typeof(ValidSealedController),
                    typeof(ValidPartialController),
                    typeof(ValidInheritedController),
                    typeof(ControllerWrapper.ValidNestedController),
                    typeof(ControllerWrapper.ValidInheritedNestedController),
                    typeof(ControllerWrapper.ControllerNestedWrapper.ValidNestedNestedController),
                    typeof(InheritedControllerHidingWrapper.ValidNestedController)
                };
            }
        }

        public static TheoryDataSet<Type> InvalidControllerTypesWithValidNames
        {
            get
            {
                return new TheoryDataSet<Type>
                {
                    typeof(InvalidAbstractController),
                    typeof(ControllerWrapper.InvalidAbstractNestedController),
                    ControllerWrapper.TypeOfInvalidProtectedNestedController(), // NOTE: Unable to get through typeof(ControllerWrapper.InvalidProtectedNestedController),
                    ControllerWrapper.TypeOfInvalidPrivateNestedController(), // NOTE: Unable to get through typeof(ControllerWrapper.InvalidPrivateNestedController),
                    typeof(ControllerWrapper.InvalidInternalNestedController)
                };
            }
        }

        public static TheoryDataSet<Type> InvalidControllerTypesWithInvalidNames
        {
            get
            {
                return new TheoryDataSet<Type>
                {
                    typeof(Ctrl),
                    typeof(Controller),
                    typeof(ControllerPrefix),
                    typeof(InvalidControllerStruct),
                    typeof(InvalidControllerWithInconsistentName),
                    typeof(InvalidControllerWithNoBaseType)
                };
            }
        }

        [Fact]
        public void DefaultHttpControllerTypeResolver_GuardClauses()
        {
            Assert.ThrowsArgumentNull(() => new DefaultHttpControllerTypeResolver(null), "predicate");
        }

        [Theory]
        [PropertyData("ValidControllerTypes")]
        public void IsControllerType_AcceptsValidControllerTypes(Type validControllerType)
        {
            Assert.True(DefaultHttpControllerTypeResolver.IsControllerType(validControllerType));
        }

        [Theory]
        [PropertyData("InvalidControllerTypesWithValidNames"), PropertyData("InvalidControllerTypesWithInvalidNames")]
        public void IsControllerType_RejectsInvalidControllerTypes(Type invalidControllerType)
        {
            Assert.False(DefaultHttpControllerTypeResolver.IsControllerType(invalidControllerType));
        }

        [Theory]
        [PropertyData("ValidControllerTypes")]
        public void HasValidControllerName_AcceptsValidControllerNames(Type validControllerType)
        {
            Assert.True(DefaultHttpControllerTypeResolver.HasValidControllerName(validControllerType));
        }

        [Theory]
        [PropertyData("InvalidControllerTypesWithInvalidNames")]
        public void HasValidControllerName_RejectsInvalidControllerNames(Type invalidControllerType)
        {
            Assert.False(DefaultHttpControllerTypeResolver.HasValidControllerName(invalidControllerType));
        }

        [Fact]
        public void GetControllerTypes_ThrowsOnNull()
        {
            DefaultHttpControllerTypeResolver resolver = new DefaultHttpControllerTypeResolver();
            Assert.ThrowsArgumentNull(() => resolver.GetControllerTypes(null), "assembliesResolver");
        }

        [Fact]
        public void GetControllerTypes_FindsTypes()
        {
            // Arrange
            DefaultHttpControllerTypeResolver resolver = new DefaultHttpControllerTypeResolver();
            Mock<IAssembliesResolver> mockAssemblyResolver = new Mock<IAssembliesResolver>();

            mockAssemblyResolver.Setup(a => a.GetAssemblies()).Returns(new List<Assembly> 
            {
                null,
                new MockExportedTypesAssembly(ThrowException.ReflectionTypeLoadException,
                    typeof(ControllerWrapper.ValidNestedController),
                    typeof(ControllerWrapper.ValidInheritedNestedController),
                    typeof(ControllerWrapper.ControllerNestedWrapper.ValidNestedNestedController),
                    typeof(InheritedControllerHidingWrapper.ValidNestedController)),
                new MockExportedTypesAssembly(ThrowException.Exception,
                    typeof(ControllerWrapper.InvalidAbstractNestedController),
                    ControllerWrapper.TypeOfInvalidProtectedNestedController(), // NOTE: Unable to get through typeof(ControllerWrapper.InvalidProtectedNestedController),
                    ControllerWrapper.TypeOfInvalidPrivateNestedController(), // NOTE: Unable to get through typeof(ControllerWrapper.InvalidPrivateNestedController),
                    typeof(ControllerWrapper.InvalidInternalNestedController)),
                new MockExportedTypesAssembly(ThrowException.None,
                    typeof(ValidSealedController),
                    typeof(ValidPartialController),
                    typeof(ValidInheritedController),
                    typeof(ValidController),
                    typeof(VALIDController),
                    typeof(VALIDCONTROLLER),
                    typeof(InvalidAbstractController),
                    typeof(InvalidControllerStruct),
                    typeof(InvalidControllerWithInconsistentName),
                    typeof(InvalidControllerWithNoBaseType))
            });

            // Act
            ICollection<Type> actualControllerTypes = resolver.GetControllerTypes(mockAssemblyResolver.Object);

            // Assert
            Assert.Equal(10, actualControllerTypes.Count);
            Assert.True(actualControllerTypes.Contains(typeof(ControllerWrapper.ValidNestedController)));
            Assert.True(actualControllerTypes.Contains(typeof(ControllerWrapper.ValidInheritedNestedController)));
            Assert.True(actualControllerTypes.Contains(typeof(ControllerWrapper.ControllerNestedWrapper.ValidNestedNestedController)));
            Assert.True(actualControllerTypes.Contains(typeof(ValidSealedController)));
            Assert.True(actualControllerTypes.Contains(typeof(ValidPartialController)));
            Assert.True(actualControllerTypes.Contains(typeof(ValidInheritedController)));
            Assert.True(actualControllerTypes.Contains(typeof(ValidController)));
            Assert.True(actualControllerTypes.Contains(typeof(VALIDController)));
            Assert.True(actualControllerTypes.Contains(typeof(VALIDCONTROLLER)));
            Assert.True(actualControllerTypes.Contains(typeof(InheritedControllerHidingWrapper.ValidNestedController)));
        }

        private static string GetDefaultControllerRouteName(Type controllerType)
        {
            return controllerType.Name.Substring(0, controllerType.Name.Length - "Controller".Length);
        }
    }

    public enum ThrowException
    {
        None = 0,
        Exception,
        ReflectionTypeLoadException,
    }

    public class MockExportedTypesAssembly : Assembly
    {
        private ThrowException _throwException;
        private Type[] _exportedTypes;

        public MockExportedTypesAssembly(ThrowException throwException, params Type[] exportedTypes)
        {
            _throwException = throwException;
            _exportedTypes = exportedTypes;
        }

        public override bool IsDynamic
        {
            get { return false; }
        }

        public override Type[] GetTypes()
        {
            switch (_throwException)
            {
                case ThrowException.Exception:
                    throw new Exception("GetTypes exception");

                case ThrowException.ReflectionTypeLoadException:
                    throw new ReflectionTypeLoadException(_exportedTypes, null, "GetTypes exception");
            }

            return _exportedTypes;
        }
    }

    public class ControllerWrapper
    {
        public static Type TypeOfInvalidPrivateNestedController()
        {
            return typeof(InvalidPrivateNestedController);
        }

        public static Type TypeOfInvalidProtectedNestedController()
        {
            return typeof(InvalidProtectedNestedController);
        }

        public class ValidNestedController : ApiController
        {
        }

        public abstract class InvalidAbstractNestedController : ApiController
        {
        }

        public class ValidInheritedNestedController : InvalidAbstractNestedController
        {
        }

        protected class InvalidProtectedNestedController : ApiController
        {
        }

        private class InvalidPrivateNestedController : ApiController
        {
        }

        internal class InvalidInternalNestedController : ApiController
        {
        }

        public class ControllerNestedWrapper
        {
            public class ValidNestedNestedController : ApiController
            {
            }
        }
    }

    public abstract class InvalidAbstractController : ApiController
    {
    }

    public struct InvalidControllerStruct
    {
    }

    public class ControllerPrefix
    {
    }

    public class InvalidControllerWithInconsistentName : ApiController
    {
    }

    public class InvalidControllerWithNoBaseType
    {
    }

    public sealed class ValidSealedController : ApiController
    {
    }

    public partial class ValidPartialController : ApiController
    {
    }

    public partial class ValidPartialController
    {
    }

    public class ValidInheritedController : InvalidAbstractController
    {
    }

    public class Controller : ApiController
    {
    }

    public class Ctrl : ApiController
    {
    }

    public class validcontroller : ApiController
    {
    }

    public class ValidController : ApiController
    {
    }

    public class VALIDController : ApiController
    {
    }

    public class VALIDCONTROLLER : ApiController
    {
    }

    public class InheritedControllerHidingWrapper : ControllerWrapper
    {
        public new class ValidNestedController : ControllerWrapper.ValidNestedController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Dispatcher/HttpControllerDispatcherTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Net;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Results;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Dispatcher
{
    public class HttpControllerDispatcherTest
    {
        [Fact]
        public void Constructor_GuardClauses()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpControllerDispatcher(configuration: null),
                "configuration");
        }

        [Fact]
        public void ExceptionLoggerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler exceptionHandler = CreateDummyExceptionHandler();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpControllerDispatcher product = CreateProductUnderTest(configuration, expectedExceptionLogger,
                exceptionHandler))
            {
                // Act
                IExceptionLogger exceptionLogger = product.ExceptionLogger;

                // Assert
                Assert.Same(expectedExceptionLogger, exceptionLogger);
            }
        }

        [Fact]
        public void ExceptionHandlerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            IExceptionLogger exceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpControllerDispatcher product = CreateProductUnderTest(configuration, exceptionLogger,
                expectedExceptionHandler))
            {
                // Act
                IExceptionHandler exceptionHandler = product.ExceptionHandler;

                // Assert
                Assert.Same(expectedExceptionHandler, exceptionHandler);
            }
        }

        [Fact]
        public void ExceptionLoggerGet_IfUnset_ReturnsExceptionLoggerFromConfiguration()
        {
            // Arrange
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
                configuration.Services.Add(typeof(IExceptionLogger), expectedExceptionLogger);

                using (HttpControllerDispatcher product = CreateProductUnderTest(configuration))
                {
                    // Act
                    IExceptionLogger exceptionLogger = product.ExceptionLogger;

                    // Assert
                    CompositeExceptionLogger compositeLogger = Assert.IsType<CompositeExceptionLogger>(exceptionLogger);
                    IEnumerable<IExceptionLogger> loggers = compositeLogger.Loggers;
                    Assert.NotNull(loggers);
                    IExceptionLogger logger = Assert.Single(loggers);
                    Assert.Same(expectedExceptionLogger, logger);
                }
            }
        }

        [Fact]
        public void ExceptionHandlerGet_IfUnset_UsesExceptionHandlerFromConfiguration()
        {
            // Arrange
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();
                configuration.Services.Replace(typeof(IExceptionHandler), expectedExceptionHandler);

                using (HttpControllerDispatcher product = CreateProductUnderTest(configuration))
                {
                    // Act
                    IExceptionHandler exceptionHandler = product.ExceptionHandler;

                    // Assert
                    LastChanceExceptionHandler lastChanceHandler = Assert.IsType<LastChanceExceptionHandler>(exceptionHandler);
                    Assert.Same(expectedExceptionHandler, lastChanceHandler.InnerHandler);
                }
            }
        }

        [Fact]
        public async Task SendAsync_CallsControllerSelectorToGetControllerDescriptor()
        {
            var mockSelector = new Mock<IHttpControllerSelector>();
            var config = new HttpConfiguration();
            config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
            var request = CreateRequest(config, "http://localhost/api/foo");
            var dispatcher = new HttpControllerDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            await invoker.SendAsync(request, CancellationToken.None);

            mockSelector.Verify(s => s.SelectController(request), Times.Once());
        }

        [Fact]
        public async Task SendAsync_CallsControllerDescriptorToCreateController()
        {
            var mockSelector = new Mock<IHttpControllerSelector>();
            var mockDescriptor = new Mock<HttpControllerDescriptor>();
            var config = new HttpConfiguration();
            config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
            var request = CreateRequest(config, "http://localhost/api/foo");
            mockSelector.Setup(s => s.SelectController(request))
                        .Returns(mockDescriptor.Object);
            mockDescriptor.Setup(d => d.CreateController(request))
                          .Returns(new PrivateController())
                          .Verifiable();
            var dispatcher = new HttpControllerDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            await invoker.SendAsync(request, CancellationToken.None);

            mockDescriptor.Verify();
        }

        [Fact]
        public async Task SendAsync_CallsControllerExecuteAsyncWithPopulatedControllerContext()
        {
            HttpControllerContext calledContext = null;
            var mockSelector = new Mock<IHttpControllerSelector>();
            var mockDescriptor = new Mock<HttpControllerDescriptor>();
            var mockController = new Mock<IHttpController>();
            var config = new HttpConfiguration();
            config.Services.Replace(typeof(IHttpControllerSelector), mockSelector.Object);
            var request = CreateRequest(config, "http://localhost/api/foo");
            mockSelector.Setup(s => s.SelectController(request))
                        .Returns(mockDescriptor.Object);
            mockDescriptor.Setup(d => d.CreateController(request))
                          .Returns(mockController.Object);
            mockDescriptor.Object.Initialize(config);
            mockController.Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None))
                          .Callback((HttpControllerContext ctxt, CancellationToken token) => { calledContext = ctxt; });
            var dispatcher = new HttpControllerDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            await invoker.SendAsync(request, CancellationToken.None);

            Assert.NotNull(calledContext);
            Assert.Same(mockController.Object, calledContext.Controller);
            Assert.Same(mockDescriptor.Object, calledContext.ControllerDescriptor);
            Assert.Same(config, calledContext.Configuration);
            Assert.Same(request, calledContext.Request);
            Assert.Same(request.GetRouteData(), calledContext.RouteData);
        }

        [Fact]
        public async Task SendAsync_Returns404WhenControllerSelectorReturnsNullControllerDescriptor()
        {
            var config = new HttpConfiguration();
            var request = CreateRequest(config, "http://localhost/api/foo");
            var dispatcher = new HttpControllerDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
        }

        // In this case the controller selector throws, so we don't get a controller context in the
        // exception handlers.
        [Fact]
        public async Task SendAsync_IfSendAsyncThrows_InControllerSelector_CallsExceptionServices()
        {
            // Arrange
            Exception expectedException = CreateException();

            Mock<IExceptionLogger> exceptionLoggerMock = CreateStubExceptionLoggerMock();
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = CreateStubExceptionHandlerMock();
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage expectedRequest = CreateRequestWithRouteData())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpMessageHandler product = CreateProductUnderTest(configuration, exceptionLogger,
                exceptionHandler))
            {
                configuration.Services.Replace(typeof(IHttpControllerSelector),
                    CreateThrowingControllerSelector(expectedException));

                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                await Assert.ThrowsAsync<Exception>(() => product.SendAsync(expectedRequest, cancellationToken));

                // Assert
                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == ExceptionCatchBlocks.HttpControllerDispatcher
                    && c.Request == expectedRequest
                    && c.ControllerContext == null;

                exceptionLoggerMock.Verify(l => l.LogAsync(
                    It.Is<ExceptionLoggerContext>(c => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());

                exceptionHandlerMock.Verify(h => h.HandleAsync(
                    It.Is<ExceptionHandlerContext>((c) => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());
            }
        }

        // In this case the controller itself throws, so we get a controller context in the
        // exception handlers.
        [Fact]
        public async Task SendAsync_IfSendAsyncThrows_Controller_CallsExceptionServices()
        {
            // Arrange
            Exception expectedException = CreateException();

            Mock<IExceptionLogger> exceptionLoggerMock = CreateStubExceptionLoggerMock();
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = CreateStubExceptionHandlerMock();
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            var controller = new ThrowingController(expectedException);

            var controllerActivator = new Mock<IHttpControllerActivator>();
            controllerActivator
                .Setup(
                    activator => activator.Create(
                        It.IsAny<HttpRequestMessage>(),
                        It.IsAny<HttpControllerDescriptor>(),
                        It.IsAny<Type>()))
                .Returns(controller);

            using (HttpRequestMessage expectedRequest = CreateRequestWithRouteData())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpMessageHandler product = CreateProductUnderTest(configuration, exceptionLogger,
                exceptionHandler))
            {
                var controllerSelector = new Mock<IHttpControllerSelector>(MockBehavior.Strict);
                controllerSelector
                    .Setup(selector => selector.SelectController(It.IsAny<HttpRequestMessage>()))
                    .Returns(new HttpControllerDescriptor(configuration, "Throwing", controller.GetType()));

                configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelector.Object);
                configuration.Services.Replace(typeof(IHttpControllerActivator), controllerActivator.Object);

                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                await Assert.ThrowsAsync<Exception>(() => product.SendAsync(expectedRequest, cancellationToken));

                // Assert
                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == ExceptionCatchBlocks.HttpControllerDispatcher
                    && c.Request == expectedRequest
                    && c.ControllerContext != null
                    && c.ControllerContext == controller.ControllerContext
                    && c.ControllerContext.Controller == controller;

                exceptionLoggerMock.Verify(l => l.LogAsync(
                    It.Is<ExceptionLoggerContext>(c => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());

                exceptionHandlerMock.Verify(h => h.HandleAsync(
                    It.Is<ExceptionHandlerContext>((c) => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());
            }
        }


        [Fact]
        public async Task SendAsync_IfSendAsyncCancels_InControllerSelector_DoesNotCallExceptionServices()
        {
            // Arrange
            Exception expectedException = new OperationCanceledException();

            Mock<IExceptionLogger> exceptionLoggerMock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage expectedRequest = CreateRequestWithRouteData())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpMessageHandler product = CreateProductUnderTest(configuration, exceptionLogger,
                exceptionHandler))
            {
                configuration.Services.Replace(typeof(IHttpControllerSelector),
                    CreateThrowingControllerSelector(expectedException));

                CancellationToken cancellationToken = CreateCancellationToken();

                // Act & Assert
                await Assert.ThrowsAsync<OperationCanceledException>(() => product.SendAsync(expectedRequest, cancellationToken));
            }
        }

        [Fact]
        public async Task SendAsync_IfExceptionHandlerSetsNullResult_PropogatesFaultedTaskException()
        {
            // Arrange
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo();
            string expectedStackTrace = exceptionInfo.SourceException.StackTrace;

            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();

            Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            exceptionHandlerMock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Callback<ExceptionHandlerContext, CancellationToken>((c, i) => c.Result = null)
                .Returns(Task.FromResult(0));
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage request = CreateRequestWithRouteData())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpMessageHandler product = CreateProductUnderTest(configuration, exceptionLogger,
                exceptionHandler))
            {
                configuration.Services.Replace(typeof(IHttpControllerSelector),
                    CreateThrowingControllerSelector(exceptionInfo));

                CancellationToken cancellationToken = CreateCancellationToken();

                // Act & Assert
                var exception = await Assert.ThrowsAsync<Exception>(() => product.SendAsync(request, cancellationToken));

                Assert.Same(exceptionInfo.SourceException, exception);
                Assert.NotNull(exception.StackTrace);
                Assert.StartsWith(expectedStackTrace, exception.StackTrace);
            }
        }

        [Fact]
        public async Task SendAsync_IfExceptionHandlerHandlesException_ReturnsResponse()
        {
            // Arrange
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();

            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                exceptionHandlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Callback<ExceptionHandlerContext, CancellationToken>((c, i) =>
                        c.Result = new ResponseMessageResult(expectedResponse))
                    .Returns(Task.FromResult(0));
                IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

                using (HttpRequestMessage request = CreateRequestWithRouteData())
                using (HttpConfiguration configuration = new HttpConfiguration())
                using (HttpMessageHandler product = CreateProductUnderTest(configuration, exceptionLogger,
                    exceptionHandler))
                {
                    configuration.Services.Replace(typeof(IHttpControllerSelector),
                        CreateThrowingControllerSelector(CreateException()));

                    CancellationToken cancellationToken = CreateCancellationToken();

                    // Act
                    HttpResponseMessage response = await product.SendAsync(request, cancellationToken);

                    // Assert
                    Assert.Same(expectedResponse, response);
                }
            }
        }

        [Fact]
        public async Task SendAsync_IfExceptionHandlerIsDefault_Returns500WithHttpErrorWhenControllerThrows()
        {
            var config = new HttpConfiguration() { IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always };
            var request = CreateRequest(config, "http://localhost/api/HttpControllerDispatcherThrowing");
            var dispatcher = new HttpControllerDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            HttpResponseMessage response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
            var objectContent = Assert.IsType<ObjectContent<HttpError>>(response.Content);
            var error = Assert.IsType<HttpError>(objectContent.Value);
            Assert.Equal("Hello from the throwing controller", error["ExceptionMessage"]);
        }

        [Fact]
        public async Task SendAsync_CreatesControllerContext_WithRequestContextFromRequest()
        {
            // Arrange
            using (HttpConfiguration configuration = new HttpConfiguration())
            using (HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(configuration))
            using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                Mock<IHttpController> controllerMock = new Mock<IHttpController>();
                HttpRequestContext requestContext = null;
                controllerMock
                    .Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None))
                    .Callback<HttpControllerContext, CancellationToken>((c, t) =>
                    {
                        requestContext = c.RequestContext;
                    });
                Mock<HttpControllerDescriptor> controllerDescriptorMock = new Mock<HttpControllerDescriptor>();
                controllerDescriptorMock.Setup(d => d.CreateController(request)).Returns(controllerMock.Object);
                HttpControllerDescriptor controllerDescriptor = controllerDescriptorMock.Object;
                controllerDescriptor.Configuration = configuration;
                Mock<IHttpControllerSelector> controllerSelectorMock = new Mock<IHttpControllerSelector>();
                controllerSelectorMock.Setup(s => s.SelectController(request)).Returns(controllerDescriptor);
                configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelectorMock.Object);

                HttpRequestContext expectedRequestContext = new HttpRequestContext
                {
                    Configuration = configuration
                };
                request.SetRequestContext(expectedRequestContext);

                request.SetRouteData(new Mock<IHttpRouteData>(MockBehavior.Strict).Object);

                // Act
                HttpResponseMessage ignore = await invoker.SendAsync(request, CancellationToken.None);

                // Assert
                Assert.Same(expectedRequestContext, requestContext);
            }
        }

        [Fact]
        public async Task SendAsync_CreatesControllerContextWithRequestBackedRequestContext_WhenRequestRequestContextIsNull()
        {
            // Arrange
            using (HttpConfiguration configuration = new HttpConfiguration())
            using (HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(configuration))
            using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                Mock<IHttpController> controllerMock = new Mock<IHttpController>();
                HttpRequestContext requestContext = null;
                controllerMock
                    .Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None))
                    .Callback<HttpControllerContext, CancellationToken>((c, t) =>
                    {
                        requestContext = c.RequestContext;
                    });
                Mock<HttpControllerDescriptor> controllerDescriptorMock = new Mock<HttpControllerDescriptor>();
                controllerDescriptorMock.Setup(d => d.CreateController(request)).Returns(controllerMock.Object);
                HttpControllerDescriptor controllerDescriptor = controllerDescriptorMock.Object;
                controllerDescriptor.Configuration = configuration;
                Mock<IHttpControllerSelector> controllerSelectorMock = new Mock<IHttpControllerSelector>();
                controllerSelectorMock.Setup(s => s.SelectController(request)).Returns(controllerDescriptor);
                configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelectorMock.Object);

                request.SetRouteData(new Mock<IHttpRouteData>(MockBehavior.Strict).Object);

                // Act
                HttpResponseMessage ignore = await invoker.SendAsync(request, CancellationToken.None);

                // Assert
                RequestBackedHttpRequestContext typedRequestContext = Assert.IsType<RequestBackedHttpRequestContext>(requestContext);
                Assert.Same(request, typedRequestContext.Request);
                Assert.Same(configuration, typedRequestContext.Configuration);
            }
        }

        [Fact]
        public async Task SendAsync_SetsRequestBackedRequestContextOnRequest_WhenRequestRequestContextIsNull()
        {
            // Arrange
            using (HttpConfiguration configuration = new HttpConfiguration())
            using (HttpControllerDispatcher dispatcher = new HttpControllerDispatcher(configuration))
            using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                Mock<IHttpController> controllerMock = new Mock<IHttpController>();
                HttpRequestContext requestContext = null;
                controllerMock
                    .Setup(c => c.ExecuteAsync(It.IsAny<HttpControllerContext>(), CancellationToken.None))
                    .Callback<HttpControllerContext, CancellationToken>((c, t) =>
                    {
                        requestContext = request.GetRequestContext();
                    });
                Mock<HttpControllerDescriptor> controllerDescriptorMock = new Mock<HttpControllerDescriptor>();
                controllerDescriptorMock.Setup(d => d.CreateController(request)).Returns(controllerMock.Object);
                HttpControllerDescriptor controllerDescriptor = controllerDescriptorMock.Object;
                controllerDescriptor.Configuration = configuration;
                Mock<IHttpControllerSelector> controllerSelectorMock = new Mock<IHttpControllerSelector>();
                controllerSelectorMock.Setup(s => s.SelectController(request)).Returns(controllerDescriptor);
                configuration.Services.Replace(typeof(IHttpControllerSelector), controllerSelectorMock.Object);

                request.SetRouteData(new Mock<IHttpRouteData>(MockBehavior.Strict).Object);

                // Act
                HttpResponseMessage ignore = await invoker.SendAsync(request, CancellationToken.None);

                // Assert
                RequestBackedHttpRequestContext typedRequestContext = Assert.IsType<RequestBackedHttpRequestContext>(requestContext);
                Assert.Same(request, typedRequestContext.Request);
                Assert.Same(configuration, typedRequestContext.Configuration);
            }
        }

        private static CancellationToken CreateCancellationToken()
        {
            CancellationTokenSource source = new CancellationTokenSource();
            return source.Token;
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static IExceptionHandler CreateDummyExceptionHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyExceptionLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static Exception CreateException()
        {
            return new Exception();
        }

        private static ExceptionDispatchInfo CreateExceptionInfo()
        {
            try
            {
                throw CreateException();
            }
            catch (Exception exception)
            {
                return ExceptionDispatchInfo.Capture(exception);
            }
        }

        private static HttpControllerDispatcher CreateProductUnderTest(HttpConfiguration configuration)
        {
            return new HttpControllerDispatcher(configuration);
        }

        private static HttpControllerDispatcher CreateProductUnderTest(HttpConfiguration configuration,
            IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler)
        {
            return new HttpControllerDispatcher(configuration)
            {
                ExceptionLogger = exceptionLogger,
                ExceptionHandler = exceptionHandler
            };
        }

        private static HttpRequestMessage CreateRequestWithRouteData()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetRouteData(new Mock<IHttpRouteData>(MockBehavior.Strict).Object);
            return request;
        }

        private static HttpRequestMessage CreateRequest(HttpConfiguration config, string requestUri)
        {
            IHttpRoute route = config.Routes.MapHttpRoute("default", "api/{controller}/{id}", new { id = RouteParameter.Optional });
            var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
            request.SetRouteData(route.GetRouteData("/", request));
            request.SetConfiguration(config);
            return request;
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static Mock<IExceptionHandler> CreateStubExceptionHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static IExceptionLogger CreateStubExceptionLogger()
        {
            return CreateStubExceptionLoggerMock().Object;
        }

        private static Mock<IExceptionLogger> CreateStubExceptionLoggerMock()
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static IHttpControllerSelector CreateThrowingControllerSelector(Exception exception)
        {
            Mock<IHttpControllerSelector> mock = new Mock<IHttpControllerSelector>(MockBehavior.Strict);
            mock
                .Setup(s => s.SelectController(It.IsAny<HttpRequestMessage>()))
                .Throws(exception);
            return mock.Object;
        }

        private static IHttpControllerSelector CreateThrowingControllerSelector(ExceptionDispatchInfo exceptionInfo)
        {
            return new ThrowingControllerSelector(exceptionInfo);
        }

        private class PrivateController : ApiController
        {
            public void Get() { }

            public override Task<HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
            {
                // Empty. Skip all the logic of execcuting a controller.
                HttpResponseMessage response = new HttpResponseMessage();
                return Task.FromResult(response);
            }
        }

        private class ThrowingControllerSelector : IHttpControllerSelector
        {
            private readonly ExceptionDispatchInfo _exceptionInfo;

            public ThrowingControllerSelector(ExceptionDispatchInfo exceptionInfo)
            {
                Contract.Assert(exceptionInfo != null);
                _exceptionInfo = exceptionInfo;
            }

            public HttpControllerDescriptor SelectController(HttpRequestMessage request)
            {
                _exceptionInfo.Throw();
                return null; // We'll never get here, but the compiler doesn't know that.
            }

            public IDictionary<string, HttpControllerDescriptor> GetControllerMapping()
            {
                _exceptionInfo.Throw();
                return null; // We'll never get here, but the compiler doesn't know that.
            }
        }
    }

    public class ThrowingController : ApiController
    {
        private readonly Exception _exception;

        public ThrowingController(Exception exception)
        {
            _exception = exception;
        }

        public override Task<HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
        {
            ControllerContext = controllerContext;
            throw _exception;
        }
    }

    // This is used in SendAsync_IfExceptionHandlerIsDefault_Returns500WithHttpErrorWhenControllerThrows
    // Don't touch!
    public class HttpControllerDispatcherThrowingController : ApiController
    {
        public void Get()
        {
            throw new Exception("Hello from the throwing controller");
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Dispatcher/HttpErrorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Net.Http.Formatting;
using System.Threading.Tasks;
using System.Web.Http.ModelBinding;
using Microsoft.TestCommon;
using Newtonsoft.Json.Linq;

namespace System.Web.Http.Dispatcher
{
    public class HttpErrorTest
    {
        public static TheoryDataSet<HttpError, Func<string>, string, string> ErrorKeyValue
        {
            get
            {
                HttpError httpError = new HttpError();
                return new TheoryDataSet<HttpError, Func<string>, string, string>
                {
                    { httpError, () => httpError.Message, "Message", "Message_Value" },
                    { httpError, () => httpError.MessageDetail, "MessageDetail", "MessageDetail_Value" },
                    { httpError, () => httpError.ExceptionMessage, "ExceptionMessage", "ExceptionMessage_Value" },
                    { httpError, () => httpError.ExceptionType, "ExceptionType", "ExceptionType_Value" },
                    { httpError, () => httpError.StackTrace, "StackTrace", "StackTrace_Value" },
                };
            }
        }

        public static TheoryDataSet<HttpError> HttpErrors
        {
            get
            {
                return new TheoryDataSet<HttpError>()
                {
                    new HttpError(),
                    new HttpError("error"),
                    new HttpError(new NotImplementedException(), true),
                    new HttpError(new ModelStateDictionary() { { "key", new ModelState() { Errors = { new ModelError("error") } } } }, true),
                    new HttpError("error", "errordetail"),
                };
            }
        }

        [Fact]
        public void Constructor_GuardClauses()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpError(message: null),
                "message");
            Assert.ThrowsArgumentNull(
                () => new HttpError(exception: null, includeErrorDetail: false),
                "exception");
            Assert.ThrowsArgumentNull(
                () => new HttpError(modelState: null, includeErrorDetail: false),
                "modelState");
        }

        [Fact]
        public void StringConstructor_AddsCorrectDictionaryItems()
        {
            HttpError error = new HttpError("something bad happened");

            Assert.Contains(new KeyValuePair<string, object>("Message", "something bad happened"), error);
        }

        [Fact]
        public void ExceptionConstructorWithDetail_AddsCorrectDictionaryItems()
        {
            HttpError error = new HttpError(new ArgumentException("error", new Exception()), true);

            Assert.Contains(new KeyValuePair<string, object>("Message", "An error has occurred."), error);
            Assert.Contains(new KeyValuePair<string, object>("ExceptionMessage", "error"), error);
            Assert.Contains(new KeyValuePair<string, object>("ExceptionType", "System.ArgumentException"), error);
            Assert.True(error.ContainsKey("StackTrace"));
            Assert.True(error.ContainsKey("InnerException"));
            Assert.IsType<HttpError>(error["InnerException"]);
        }

        [Fact]
        public void ModelStateConstructorWithDetail_AddsCorrectDictionaryItems()
        {
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddModelError("[0].Name", "error1");
            modelState.AddModelError("[0].Name", "error2");
            modelState.AddModelError("[0].Address", "error");
            modelState.AddModelError("[2].Name", new Exception("OH NO"));

            HttpError error = new HttpError(modelState, true);
            HttpError modelStateError = error["ModelState"] as HttpError;

            Assert.Contains(new KeyValuePair<string, object>("Message", "The request is invalid."), error);
            Assert.Contains("error1", modelStateError["[0].Name"] as IEnumerable<string>);
            Assert.Contains("error2", modelStateError["[0].Name"] as IEnumerable<string>);
            Assert.Contains("error", modelStateError["[0].Address"] as IEnumerable<string>);
            Assert.True(modelStateError.ContainsKey("[2].Name"));
            Assert.Contains("OH NO", modelStateError["[2].Name"] as IEnumerable<string>);
        }

        [Fact]
        public void ExceptionConstructorWithoutDetail_AddsCorrectDictionaryItems()
        {
            HttpError error = new HttpError(new ArgumentException("error", new Exception()), false);

            Assert.Contains(new KeyValuePair<string, object>("Message", "An error has occurred."), error);
            Assert.False(error.ContainsKey("ExceptionMessage"));
            Assert.False(error.ContainsKey("ExceptionType"));
            Assert.False(error.ContainsKey("StackTrace"));
            Assert.False(error.ContainsKey("InnerException"));
        }

        [Fact]
        public void ModelStateConstructorWithoutDetail_AddsCorrectDictionaryItems()
        {
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddModelError("[0].Name", "error1");
            modelState.AddModelError("[0].Name", "error2");
            modelState.AddModelError("[0].Address", "error");
            modelState.AddModelError("[2].Name", new Exception("OH NO"));

            HttpError error = new HttpError(modelState, false);
            HttpError modelStateError = error["ModelState"] as HttpError;

            Assert.Contains(new KeyValuePair<string, object>("Message", "The request is invalid."), error);
            Assert.Contains("error1", modelStateError["[0].Name"] as IEnumerable<string>);
            Assert.Contains("error2", modelStateError["[0].Name"] as IEnumerable<string>);
            Assert.Contains("error", modelStateError["[0].Address"] as IEnumerable<string>);
            Assert.True(modelStateError.ContainsKey("[2].Name"));
            Assert.DoesNotContain("OH NO", modelStateError["[2].Name"] as IEnumerable<string>);
        }

        [Fact]
        public async Task HttpError_Roundtrips_WithJsonFormatter()
        {
            HttpError error = new HttpError("error") { { "ErrorCode", 42 }, { "Data", new[] { "a", "b", "c" } } };
            MediaTypeFormatter formatter = new JsonMediaTypeFormatter();
            MemoryStream stream = new MemoryStream();

            await formatter.WriteToStreamAsync(typeof(HttpError), error, stream, content: null, transportContext: null);
            stream.Position = 0;
            HttpError roundtrippedError = (await formatter.ReadFromStreamAsync(typeof(HttpError), stream, content: null, formatterLogger: null)) as HttpError;

            Assert.NotNull(roundtrippedError);
            Assert.Equal("error", roundtrippedError.Message);
            Assert.Equal(42L, roundtrippedError["ErrorCode"]);
            JArray data = roundtrippedError["Data"] as JArray;
            Assert.Equal(3, data.Count);
            Assert.Contains("a", data);
            Assert.Contains("b", data);
            Assert.Contains("c", data);
        }

        [Fact]
        public async Task HttpError_Roundtrips_WithXmlFormatter()
        {
            HttpError error = new HttpError("error") { { "ErrorCode", 42 }, { "Data", new[] { "a", "b", "c" } } };
            MediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            MemoryStream stream = new MemoryStream();

            await formatter.WriteToStreamAsync(typeof(HttpError), error, stream, content: null, transportContext: null);
            stream.Position = 0;
            HttpError roundtrippedError = (await formatter.ReadFromStreamAsync(typeof(HttpError), stream, content: null, formatterLogger: null)) as HttpError;

            Assert.NotNull(roundtrippedError);
            Assert.Equal("error", roundtrippedError.Message);
            Assert.Equal("42", roundtrippedError["ErrorCode"]);
            Assert.Equal("a b c", roundtrippedError["Data"]);
        }

        [Fact]
        public async Task HttpErrorWithWhitespace_Roundtrips_WithXmlFormatter()
        {
            string message = "  foo\n bar  \n ";
            HttpError error = new HttpError(message);
            MediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            MemoryStream stream = new MemoryStream();

            await formatter.WriteToStreamAsync(typeof(HttpError), error, stream, content: null, transportContext: null);
            stream.Position = 0;
            HttpError roundtrippedError = (await formatter.ReadFromStreamAsync(typeof(HttpError), stream, content: null, formatterLogger: null)) as HttpError;

            Assert.NotNull(roundtrippedError);
            Assert.Equal(message, roundtrippedError.Message);
        }

        [Fact]
        public async Task HttpError_Roundtrips_WithXmlSerializer()
        {
            HttpError error = new HttpError("error") { { "ErrorCode", 42 }, { "Data", new[] { "a", "b", "c" } } };
            MediaTypeFormatter formatter = new XmlMediaTypeFormatter() { UseXmlSerializer = true };
            MemoryStream stream = new MemoryStream();

            await formatter.WriteToStreamAsync(typeof(HttpError), error, stream, content: null, transportContext: null);
            stream.Position = 0;
            HttpError roundtrippedError = (await formatter.ReadFromStreamAsync(typeof(HttpError), stream, content: null, formatterLogger: null)) as HttpError;

            Assert.NotNull(roundtrippedError);
            Assert.Equal("error", roundtrippedError.Message);
            Assert.Equal("42", roundtrippedError["ErrorCode"]);
            Assert.Equal("a b c", roundtrippedError["Data"]);
        }

        [Fact]
        public async Task HttpErrorForInnerException_Serializes_WithXmlSerializer()
        {
            HttpError error = new HttpError(new ArgumentException("error", new Exception("innerError")), includeErrorDetail: true);
            MediaTypeFormatter formatter = new XmlMediaTypeFormatter() { UseXmlSerializer = true };
            MemoryStream stream = new MemoryStream();

            await formatter.WriteToStreamAsync(typeof(HttpError), error, stream, content: null, transportContext: null);
            stream.Position = 0;
            string serializedError = new StreamReader(stream).ReadToEnd();

            Assert.NotNull(serializedError);
            Assert.Equal(
                "<Error><Message>An error has occurred.</Message><ExceptionMessage>error</ExceptionMessage><ExceptionType>System.ArgumentException</ExceptionType><StackTrace /><InnerException><Message>An error has occurred.</Message><ExceptionMessage>innerError</ExceptionMessage><ExceptionType>System.Exception</ExceptionType><StackTrace /></InnerException></Error>",
                serializedError);
        }

        [Fact]
        public void HttpError_Message_RoundTrips()
        {
            string message = "HelloWorld";
            Assert.Reflection.Property(
                new HttpError(message),
                e => e.Message,
                expectedDefaultValue: message,
                allowNull: true,
                roundTripTestValue: "HelloAgain");
        }

        [Fact]
        public void HttpError_MessageDetail_RoundTrips()
        {
            string messageDetail = "HelloWorld";
            Assert.Reflection.Property(
                new HttpError("message", messageDetail),
                e => e.MessageDetail,
                expectedDefaultValue: messageDetail,
                allowNull: true,
                roundTripTestValue: "HelloAgain");
        }

        [Fact]
        public void HttpError_ExceptionMessage_RoundTrips()
        {
            string exceptionMessage = "ExceptionMessage";
            Exception exception = new Exception(exceptionMessage);
            Assert.Reflection.Property(
                new HttpError(exception, includeErrorDetail: true),
                e => e.ExceptionMessage,
                expectedDefaultValue: exceptionMessage,
                allowNull: true,
                roundTripTestValue: "HelloAgain");
        }

        [Fact]
        public void HttpError_ExceptionType_RoundTrips()
        {
            ApplicationException exception = new ApplicationException("HelloWorld");
            Assert.Reflection.Property(
                new HttpError(exception, includeErrorDetail: true),
                e => e.ExceptionType,
                expectedDefaultValue: exception.GetType().FullName,
                allowNull: true,
                roundTripTestValue: "HelloAgain");
        }

        [Fact]
        public void HttpError_StackTrace_RoundTrips()
        {
            Exception exception;
            try
            {
                throw new Exception("HelloWorld");
            }
            catch (Exception e)
            {
                exception = e;
            }

            Assert.Reflection.Property(
                new HttpError(exception, includeErrorDetail: true),
                e => e.StackTrace,
                expectedDefaultValue: exception.StackTrace,
                allowNull: true,
                roundTripTestValue: "HelloAgain");
        }

        [Fact]
        public void GetPropertyValue_GetsValue_IfTypeMatches()
        {
            HttpError error = new HttpError();
            error["key"] = "x";

            Assert.Equal("x", error.GetPropertyValue<string>("key"));
            Assert.Equal("x", error.GetPropertyValue<object>("key"));
        }

        [Fact]
        public void GetPropertyValue_GetsDefault_IfTypeDoesNotMatch()
        {
            HttpError error = new HttpError();
            error["key"] = "x";

            Assert.Null(error.GetPropertyValue<Uri>("key"));
            Assert.Equal(0, error.GetPropertyValue<int>("key"));
        }

        [Fact]
        public void GetPropertyValue_GetsDefault_IfPropertyMissing()
        {
            HttpError error = new HttpError();

            Assert.Null(error.GetPropertyValue<string>("key"));
            Assert.Equal(0, error.GetPropertyValue<int>("key"));
        }

        [Theory]
        [PropertyData("ErrorKeyValue")]
        public void HttpErrorStringProperties_UseCorrectHttpErrorKey(HttpError httpError, Func<string> productUnderTest, string key, string actualValue)
        {
            // Arrange
            httpError[key] = actualValue;

            // Act
            string expectedValue = productUnderTest.Invoke();

            // Assert
            Assert.Equal(expectedValue, actualValue);
        }

        [Fact]
        public void HttpErrorProperty_InnerException_UsesCorrectHttpErrorKey()
        {
            // Arrange
            HttpError error = new HttpError(new ArgumentException("error", new Exception()), true);

            // Act
            HttpError innerException = error.InnerException;

            // Assert
            Assert.Same(error["InnerException"], innerException);
        }

        [Fact]
        public void HttpErrorProperty_ModelState_UsesCorrectHttpErrorKey()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddModelError("[0].Name", "error1");
            HttpError error = new HttpError(modelState, true);

            // Act
            HttpError actualModelStateError = error.ModelState;

            // Assert
            Assert.Same(error["ModelState"], actualModelStateError);
        }

        [Theory]
        [PropertyData("HttpErrors")]
        public void HttpErrors_UseCaseInsensitiveComparer(HttpError httpError)
        {
            var lowercaseKey = "abcd";
            var uppercaseKey = "ABCD";

            httpError[lowercaseKey] = "error";

            Assert.True(httpError.ContainsKey(lowercaseKey));
            Assert.True(httpError.ContainsKey(uppercaseKey));
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Dispatcher/HttpRoutingDispatcherTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http.Dispatcher
{
    public class HttpRoutingDispatcherTest
    {
        [Fact]
        public void Constructor_GuardClauses()
        {
            Assert.ThrowsArgumentNull(
                () => new HttpRoutingDispatcher(configuration: null),
                "configuration");
            Assert.ThrowsArgumentNull(
                () => new HttpRoutingDispatcher(configuration: null, defaultHandler: new Mock<HttpMessageHandler>().Object),
                "configuration");
            Assert.ThrowsArgumentNull(
                () => new HttpRoutingDispatcher(new HttpConfiguration(), defaultHandler: null),
                "defaultHandler");
        }

        [Fact]
        public async Task SendAsync_PopulatesRouteDataWhenNotPresentInRequest()
        {
            var config = new HttpConfiguration();
            var request = CreateRequest(config, "http://localhost/api/controllerName/42");
            var dispatcher = new HttpRoutingDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            await invoker.SendAsync(request, CancellationToken.None);

            var routeData = request.GetRouteData();
            Assert.NotNull(routeData);
            Assert.Same(config.Routes.Single(), routeData.Route);
            Assert.Equal("controllerName", routeData.Values["controller"]);
            Assert.Equal("42", routeData.Values["id"]);
        }

        [Fact]
        public async Task SendAsync_RemovesRouteParameterOptionalValuesThatAreNotPresent()
        {
            var config = new HttpConfiguration();
            var request = CreateRequest(config, "http://localhost/api/controllerName");
            var dispatcher = new HttpRoutingDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            await invoker.SendAsync(request, CancellationToken.None);

            Assert.False(request.GetRouteData().Values.ContainsKey("id"));
        }

        [Fact]
        public async Task SendAsync_Returns404WhenNoMatchingRoute()
        {
            var config = new HttpConfiguration();
            var request = CreateRequest(config, "http://localhost/noMatch");
            var dispatcher = new HttpRoutingDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            var response = await invoker.SendAsync(request, CancellationToken.None);

            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
            Assert.True((bool)request.Properties[HttpPropertyKeys.NoRouteMatched]);
        }

        [Fact]
        public void SendAsync_CallsDefaultHandlerWhenRouteHandlerIsNull()
        {
            var mockHandler = new Mock<HttpMessageHandler>();
            var config = new HttpConfiguration();
            var request = CreateRequest(config, "http://localhost/api/controllerName", routeHandler: null);
            var dispatcher = new HttpRoutingDispatcher(config, defaultHandler: mockHandler.Object);
            var invoker = new HttpMessageInvoker(dispatcher);

            invoker.SendAsync(request, CancellationToken.None);

            mockHandler.Protected().Verify("SendAsync", Times.Once(), request, CancellationToken.None);
        }

        [Fact]
        public void SendAsync_CallsRouterHandlerWhenRouteHandlerIsNotNull()
        {
            var mockHandler = new Mock<HttpMessageHandler>();
            var config = new HttpConfiguration();
            var request = CreateRequest(config, "http://localhost/api/controllerName", routeHandler: mockHandler.Object);
            var dispatcher = new HttpRoutingDispatcher(config);
            var invoker = new HttpMessageInvoker(dispatcher);

            invoker.SendAsync(request, CancellationToken.None);

            mockHandler.Protected().Verify("SendAsync", Times.Once(), request, CancellationToken.None);
        }

        [Fact]
        public async Task SendAsync_UsesRouteDataFromRequestContext()
        {
            // Arrange
            Mock<HttpMessageHandler> doNotUseDefaultHandlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
            doNotUseDefaultHandlerMock.As<IDisposable>().Setup(c => c.Dispose());

            using (HttpConfiguration configuration = new HttpConfiguration())
            using (HttpMessageHandler doNoUseDefaultHandler = doNotUseDefaultHandlerMock.Object)
            using (HttpRoutingDispatcher dispatcher = new HttpRoutingDispatcher(configuration, doNoUseDefaultHandler))
            using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            {
                SpyHttpMessageHandler routeHandler = new SpyHttpMessageHandler(expectedResponse);

                Mock<IHttpRoute> routeMock = new Mock<IHttpRoute>(MockBehavior.Strict);
                routeMock.Setup(r => r.Handler).Returns(routeHandler);

                Mock<IHttpRouteData> routeDataMock = new Mock<IHttpRouteData>(MockBehavior.Strict);
                routeDataMock.Setup(d => d.Route).Returns(routeMock.Object);
                routeDataMock.Setup(d => d.Values).Returns(new Dictionary<string, object>());

                HttpRequestContext context = new HttpRequestContext();
                context.RouteData = routeDataMock.Object;
                expectedRequest.SetRequestContext(context);

                // Act
                HttpResponseMessage response = await invoker.SendAsync(expectedRequest, CancellationToken.None);

                // Assert
                Assert.Same(expectedResponse, response);
                Assert.Same(expectedRequest, routeHandler.Request);
            }
        }

        [Fact]
        public async Task SendAsync_IgnoreRoute_UsesRouteDataWithStopRoutingHandlerFromRequestContext()
        {
            // Arrange
            Mock<HttpMessageHandler> doNotUseDefaultHandlerMock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
            doNotUseDefaultHandlerMock.As<IDisposable>().Setup(c => c.Dispose());

            using (HttpConfiguration configuration = new HttpConfiguration())
            using (HttpMessageHandler doNoUseDefaultHandler = doNotUseDefaultHandlerMock.Object)
            using (HttpRoutingDispatcher dispatcher = new HttpRoutingDispatcher(configuration, doNoUseDefaultHandler))
            using (HttpMessageInvoker invoker = new HttpMessageInvoker(dispatcher))
            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            {
                HttpMessageHandler routeHandler = new StopRoutingHandler();

                Mock<IHttpRoute> routeMock = new Mock<IHttpRoute>(MockBehavior.Strict);
                routeMock.Setup(r => r.Handler).Returns(routeHandler);

                Mock<IHttpRouteData> routeDataMock = new Mock<IHttpRouteData>(MockBehavior.Strict);
                routeDataMock.Setup(d => d.Route).Returns(routeMock.Object);
                routeDataMock.Setup(d => d.Values).Returns(new Dictionary<string, object>());

                HttpRequestContext context = new HttpRequestContext();
                context.RouteData = routeDataMock.Object;
                expectedRequest.SetRequestContext(context);

                // Act
                HttpResponseMessage response = await invoker.SendAsync(expectedRequest, CancellationToken.None);

                // Assert
                Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                Assert.True(response.RequestMessage.Properties.ContainsKey(HttpPropertyKeys.NoRouteMatched));
            }
        }

        private static HttpRequestMessage CreateRequest(HttpConfiguration config, string requestUri)
        {
            return CreateRequest(config, requestUri, routeHandler: new EmptyResponseHandler());
        }

        private static HttpRequestMessage CreateRequest(HttpConfiguration config, string requestUri, HttpMessageHandler routeHandler)
        {
            var route = config.Routes.CreateRoute("api/{controller}/{id}",
                                                  defaults: new Dictionary<string, object> { { "id", RouteParameter.Optional } },
                                                  constraints: null,
                                                  dataTokens: null,
                                                  handler: routeHandler);
            config.Routes.Add("default", route);

            var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
            request.SetConfiguration(config);
            return request;
        }

        private class EmptyResponseHandler : HttpMessageHandler
        {
            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return Task.FromResult(request.CreateResponse(HttpStatusCode.OK));
            }
        }

        private class SpyHttpMessageHandler : HttpMessageHandler
        {
            private readonly HttpResponseMessage _response;

            public HttpRequestMessage Request { get; private set; }
            public CancellationToken CancellationToken { get; private set; }

            public SpyHttpMessageHandler(HttpResponseMessage response)
            {
                _response = response;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                Request = request;
                CancellationToken = cancellationToken;
                return Task.FromResult(_response);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/CompositeExceptionLoggerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ExceptionHandling
{
    public class CompositeExceptionLoggerTests
    {
        [Fact]
        public void Constructor_IfLoggersIsNull_Throws()
        {
            // Arrange
            IEnumerable<IExceptionLogger> loggers = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(loggers), "loggers");
        }

        [Fact]
        public void Loggers_ContainsSpecifiedInstances()
        {
            // Arrange
            IExceptionLogger expectedLogger = CreateDummyLogger();
            List<IExceptionLogger> expectedLoggers = new List<IExceptionLogger> { expectedLogger };
            CompositeExceptionLogger product = CreateProductUnderTest(expectedLoggers);

            // Act
            IEnumerable<IExceptionLogger> loggers = product.Loggers;

            // Assert
            Assert.NotNull(loggers);
            IExceptionLogger logger = Assert.Single(loggers);
            Assert.Same(expectedLogger, logger);

        }

        [Fact]
        public void Constructor_CapturesLoggersContents()
        {
            // Arrange
            IExceptionLogger expectedLogger = CreateDummyLogger();
            List<IExceptionLogger> expectedLoggers = new List<IExceptionLogger> { expectedLogger };

            // Act
            CompositeExceptionLogger product = CreateProductUnderTest(expectedLoggers);

            // Assert
            expectedLoggers.Clear();
            IEnumerable<IExceptionLogger> loggers = product.Loggers;
            Assert.NotNull(loggers);
            IExceptionLogger logger = Assert.Single(loggers);
            Assert.Same(expectedLogger, logger);
        }

        [Fact]
        public void ConstructorWithParams_SetsLoggers()
        {
            // Arrange
            IExceptionLogger expectedLogger1 = CreateDummyLogger();
            IExceptionLogger expectedLogger2 = CreateDummyLogger();

            // Act
            CompositeExceptionLogger product = new CompositeExceptionLogger(expectedLogger1, expectedLogger2);

            // Assert
            IEnumerable<IExceptionLogger> loggers = product.Loggers;
            Assert.NotNull(loggers);
            Assert.Equal(2, loggers.Count());
            Assert.Same(expectedLogger1, loggers.ElementAt(0));
            Assert.Same(expectedLogger2, loggers.ElementAt(1));
        }

        [Fact]
        public async Task LogAsync_DelegatesToLoggers()
        {
            // Arrange
            Mock<IExceptionLogger> exceptionLogger1Mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            Mock<IExceptionLogger> exceptionLogger2Mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            exceptionLogger1Mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            exceptionLogger2Mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            IEnumerable<IExceptionLogger> loggers = new IExceptionLogger[]
            {
                exceptionLogger1Mock.Object,
                exceptionLogger2Mock.Object
            };
            IExceptionLogger product = CreateProductUnderTest(loggers);

            ExceptionLoggerContext expectedContext = CreateMinimalValidContext();
            CancellationToken expectedCancellationToken = CreateCancellationToken();

            // Act
            await product.LogAsync(expectedContext, expectedCancellationToken);

            // Assert
            exceptionLogger1Mock.Verify(l => l.LogAsync(expectedContext, expectedCancellationToken), Times.Once());
            exceptionLogger2Mock.Verify(l => l.LogAsync(expectedContext, expectedCancellationToken), Times.Once());
        }

        [Fact]
        public void LogAsync_IfLoggerIsNull_Throws()
        {
            // Arrange
            IEnumerable<IExceptionLogger> loggers = new IExceptionLogger[] { null };
            IExceptionLogger product = CreateProductUnderTest(loggers);

            ExceptionLoggerContext context = CreateMinimalValidContext();
            CancellationToken cancellationToken = CreateCancellationToken();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => product.LogAsync(context, cancellationToken),
                "The IExceptionLogger instance must not be null.");

        }

        private static CancellationToken CreateCancellationToken()
        {
            CancellationTokenSource source = new CancellationTokenSource();
            return source.Token;
        }

        private static ExceptionLoggerContext CreateMinimalValidContext()
        {
            return new ExceptionLoggerContext(new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer));
        }

        private static IExceptionLogger CreateDummyLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static CompositeExceptionLogger CreateProductUnderTest(IEnumerable<IExceptionLogger> loggers)
        {
            return new CompositeExceptionLogger(loggers);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/DefaultExceptionHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Results;
using Microsoft.TestCommon;

namespace System.Web.Http.ExceptionHandling
{
    public class DefaultExceptionHandlerTests
    {
        [Fact]
        public void HandleAsync_IfContextIsNull_Throws()
        {
            // Arrange
            IExceptionHandler product = CreateProductUnderTest();
            ExceptionHandlerContext context = null;
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.HandleAsync(context, cancellationToken), "context");
        }

        [Fact]
        public void HandleAsync_IfRequestIsNull_Throws()
        {
            // Arrange
            IExceptionHandler product = CreateProductUnderTest();
            ExceptionHandlerContext context = new ExceptionHandlerContext(new ExceptionContext(CreateException(), ExceptionCatchBlocks.HttpServer));
            Assert.Null(context.ExceptionContext.Request); // Guard
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgument(() => product.HandleAsync(context, cancellationToken), "context",
                "ExceptionContext.Request must not be null.");
        }

        [Fact]
        public async Task HandleAsync_HandlesExceptionViaCreateErrorResponse()
        {
            IExceptionHandler product = CreateProductUnderTest();

            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                expectedRequest.SetRequestContext(new HttpRequestContext { IncludeErrorDetail = true });
                ExceptionHandlerContext context = CreateValidContext(expectedRequest);
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                IHttpActionResult result = context.Result;
                ResponseMessageResult typedResult = Assert.IsType<ResponseMessageResult>(result);
                using (HttpResponseMessage response = typedResult.Response)
                {
                    Assert.NotNull(response);

                    using (HttpResponseMessage expectedResponse = expectedRequest.CreateErrorResponse(
                        HttpStatusCode.InternalServerError, context.ExceptionContext.Exception))
                    {
                        AssertErrorResponse(expectedResponse, response);
                    }

                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task HandleAsync_IfCatchBlockIsIExceptionFilter_LeavesExceptionUnhandled()
        {
            IExceptionHandler product = CreateProductUnderTest();

            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionHandlerContext context = CreateValidContext(request, ExceptionCatchBlocks.IExceptionFilter);
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                Assert.Null(context.Result);
            }
        }

        private static void AssertErrorResponse(HttpResponseMessage expected, HttpResponseMessage actual)
        {
            Assert.NotNull(expected); // Guard
            ObjectContent<HttpError> expectedContent = Assert.IsType<ObjectContent<HttpError>>(expected.Content); // Guard
            Assert.NotNull(expectedContent.Formatter); // Guard

            Assert.NotNull(actual);
            Assert.Equal(expected.StatusCode, actual.StatusCode);
            ObjectContent<HttpError> actualContent = Assert.IsType<ObjectContent<HttpError>>(actual.Content);
            Assert.NotNull(actualContent.Formatter);
            Assert.Same(expectedContent.Formatter.GetType(), actualContent.Formatter.GetType());
            Assert.Equal(expectedContent.Value, actualContent.Value);
            Assert.Same(expected.RequestMessage, actual.RequestMessage);
        }

        private static ExceptionHandlerContext CreateContext(ExceptionContext exceptionContext)
        {
            return new ExceptionHandlerContext(exceptionContext);
        }

        private static Exception CreateException()
        {
            return new NotSupportedException();
        }

        private static DefaultExceptionHandler CreateProductUnderTest()
        {
            return new DefaultExceptionHandler();
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static ExceptionHandlerContext CreateValidContext(HttpRequestMessage request)
        {
            return CreateContext(new ExceptionContext(CreateException(), ExceptionCatchBlocks.HttpServer, request));
        }

        private static ExceptionHandlerContext CreateValidContext(HttpRequestMessage request,
            ExceptionContextCatchBlock catchBlock)
        {
            return CreateContext(new ExceptionContext(CreateException(), catchBlock, request));
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/EmptyExceptionHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.ExceptionHandling
{
    public class EmptyExceptionHandlerTests
    {
        [Fact]
        public void HandleAsync_ReturnsCompletedTask()
        {
            // Arrange
            IExceptionHandler product = CreateProductUnderTest();

            ExceptionHandlerContext context = CreateContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act
            Task task = product.HandleAsync(context, cancellationToken);

            // Assert
            Assert.NotNull(task);
            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
        }

        private static ExceptionHandlerContext CreateContext()
        {
            return new ExceptionHandlerContext(new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer));
        }

        private static EmptyExceptionHandler CreateProductUnderTest()
        {
            return new EmptyExceptionHandler();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionCatchBlocksTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionCatchBlocksTests
    {
        [Fact]
        public void HttpBatchHandler_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = ExceptionCatchBlocks.HttpBatchHandler;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpBatchHandler", isTopLevel: false, callsHandler: true);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpBatchHandler_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = ExceptionCatchBlocks.HttpBatchHandler;

            // Act
            ExceptionContextCatchBlock second = ExceptionCatchBlocks.HttpBatchHandler;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpControllerDispatcher_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = ExceptionCatchBlocks.HttpControllerDispatcher;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpControllerDispatcher", isTopLevel: false, callsHandler: true);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpControllerDispatcher_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = ExceptionCatchBlocks.HttpControllerDispatcher;

            // Act
            ExceptionContextCatchBlock second = ExceptionCatchBlocks.HttpControllerDispatcher;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpServer_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = ExceptionCatchBlocks.HttpServer;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpServer", isTopLevel: true, callsHandler: true);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpServer_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = ExceptionCatchBlocks.HttpServer;

            // Act
            ExceptionContextCatchBlock second = ExceptionCatchBlocks.HttpServer;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void IExceptionFilter_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = ExceptionCatchBlocks.IExceptionFilter;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("IExceptionFilter", isTopLevel: false, callsHandler: true);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void IExceptionFilter_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = ExceptionCatchBlocks.IExceptionFilter;

            // Act
            ExceptionContextCatchBlock second = ExceptionCatchBlocks.IExceptionFilter;

            // Assert
            Assert.Same(first, second);
        }

        private static void AssertEqual(ExceptionContextCatchBlock expected, ExceptionContextCatchBlock actual)
        {
            if (expected == null)
            {
                Assert.Null(actual);
                return;
            }

            Assert.NotNull(actual);
            Assert.Equal(expected.Name, actual.Name);
            Assert.Equal(expected.IsTopLevel, actual.IsTopLevel);
            Assert.Equal(expected.CallsHandler, actual.CallsHandler);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionContextCatchBlockTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using Microsoft.TestCommon;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionContextCatchBlockTests
    {
        [Fact]
        public void Constructor_IfNameIsNull_Throws()
        {
            // Arrange
            string name = null;
            bool isTopLevel = false;
            bool callsHandler = false;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(name, isTopLevel, callsHandler), "name");
        }

        [Fact]
        public void Name_IsSpecifiedInstance()
        {
            // Arrange
            string expectedName = "TheName";
            bool isTopLevel = true;
            bool callsHandler = false;
            ExceptionContextCatchBlock product = CreateProductUnderTest(expectedName, isTopLevel, callsHandler);

            // Act
            string name = product.Name;

            // Assert
            Assert.Same(expectedName, name);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsTopLevel_IsSpecifiedValue(bool expectedIsTopLevel)
        {
            // Arrange
            string name = "IgnoreName";
            bool callsHandler = false;
            ExceptionContextCatchBlock product = CreateProductUnderTest(name, expectedIsTopLevel, callsHandler);

            // Act
            bool isTopLevel = product.IsTopLevel;

            // Assert
            Assert.Equal(expectedIsTopLevel, isTopLevel);
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public void CallsHandler_IsSpecifiedValue(bool expectedCallsHandler)
        {
            // Arrange
            string name = "IgnoreName";
            bool isTopLevel = true;
            ExceptionContextCatchBlock product = CreateProductUnderTest(name, isTopLevel, expectedCallsHandler);

            // Act
            bool callsHandler = product.CallsHandler;

            // Assert
            Assert.Equal(expectedCallsHandler, callsHandler);
        }

        [Fact]
        public void ToString_ReturnsName()
        {
            // Arrange
            string expectedName = "TheName";
            bool isTopLevel = false;
            bool callsHandler= false;
            object product = CreateProductUnderTest(expectedName, isTopLevel, callsHandler);

            // Act
            string value = product.ToString();

            // Assert
            Assert.Same(expectedName, value);
        }

        [Fact]
        public void DebuggerDisplayAttribute_IsSpecifiedValue()
        {
            // Act
            DebuggerDisplayAttribute attribute = (DebuggerDisplayAttribute)Attribute.GetCustomAttribute(
                typeof(ExceptionContextCatchBlock), typeof(DebuggerDisplayAttribute));

            // Assert
            Assert.NotNull(attribute);
            string value = attribute.Value;
            Assert.Equal("Name: {Name}, IsTopLevel: {IsTopLevel}", value);
        }

        private static ExceptionContextCatchBlock CreateProductUnderTest(string name, bool isTopLevel, bool callsHandler)
        {
            return new ExceptionContextCatchBlock(name, isTopLevel, callsHandler);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionContextTests
    {
        [Fact]
        public void ConstructorWithoutArguments_SetsPropertiesToSpecifiedValues()
        {
            // Act
            ExceptionContext product = CreateProductUnderTest();

            // Assert
            Assert.NotNull(product.Exception);
            Assert.NotNull(product.CatchBlock);

            Assert.Null(product.ActionContext);
            Assert.Null(product.ControllerContext);
            Assert.Null(product.RequestContext);
            Assert.Null(product.Request);
            Assert.Null(product.Response);
        }

        [Fact]
        public void ConstructorWithActionContext_SetsPropertiesToSpecifiedValues()
        {
            // Arrange
            Exception expectedException = CreateException();
            HttpRequestContext expectedRequestContext = CreateRequestContext();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpControllerContext expectedControllerContext = CreateControllerContext(expectedRequestContext,
                    expectedRequest);
                HttpActionContext expectedActionContext = CreateActionContext(expectedControllerContext);
                ExceptionContextCatchBlock expectedCatchBlock = CreateCatchBlock();

                // Act
                ExceptionContext product = CreateProductUnderTest(expectedException, expectedCatchBlock,
                    expectedActionContext);

                // Assert
                Assert.Same(expectedException, product.Exception);
                Assert.Same(expectedCatchBlock, product.CatchBlock);
                Assert.Same(expectedActionContext, product.ActionContext);
                Assert.Same(expectedControllerContext, product.ControllerContext);
                Assert.Same(expectedRequestContext, product.RequestContext);
                Assert.Same(expectedRequest, product.Request);
                Assert.Null(product.Response);
            }
        }

        [Fact]
        public void ConstructorWithActionContext_IfExceptionIsNull_Throws()
        {
            // Arrange
            Exception exception = null;
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpRequestContext requestContext = CreateRequestContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpControllerContext controllerContext = CreateControllerContext(requestContext, request);
                HttpActionContext actionContext = CreateActionContext(controllerContext);

                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, actionContext),
                    "exception");
            }
        }

        [Fact]
        public void ConstructorWithActionContext_IfCatchBlockIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = null;
            HttpRequestContext requestContext = CreateRequestContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpControllerContext controllerContext = CreateControllerContext(requestContext, request);
                HttpActionContext actionContext = CreateActionContext(controllerContext);

                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, actionContext),
                    "catchBlock");
            }
        }

        [Fact]
        public void ConstructorWithActionContext_IfActionContextIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpActionContext actionContext = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, actionContext),
                "actionContext");
        }

        [Fact]
        public void ConstructorWithActionContext_IfControllerContextIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpActionContext actionContext = new HttpActionContext();
            Assert.Null(actionContext.ControllerContext); // Guard

            // Act & Assert
            Assert.ThrowsArgument(() => CreateProductUnderTest(exception, catchBlock, actionContext), "actionContext",
                "HttpActionContext.ControllerContext must not be null.");
        }

        [Fact]
        public void ConstructorWithActionContext_IfRequestIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpRequestContext requestContext = CreateRequestContext();
            HttpControllerContext controllerContext = new HttpControllerContext
            {
                RequestContext = requestContext
            };
            Assert.Null(controllerContext.Request); // Guard
            HttpActionContext actionContext = CreateActionContext(controllerContext);

            // Act & Assert
            Assert.ThrowsArgument(() => CreateProductUnderTest(exception, catchBlock, actionContext), "actionContext",
                "HttpControllerContext.Request must not be null");
        }

        [Fact]
        public void ConstructorWithRequest_SetsPropertiesToSpecifiedValues()
        {
            // Arrange
            Exception expectedException = CreateException();
            ExceptionContextCatchBlock expectedCatchBlock = CreateCatchBlock();
            HttpRequestContext expectedRequestContext = CreateRequestContext();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                expectedRequest.SetRequestContext(expectedRequestContext);

                // Act
                ExceptionContext product = CreateProductUnderTest(expectedException, expectedCatchBlock,
                    expectedRequest);

                // Assert
                Assert.Same(expectedException, product.Exception);
                Assert.Same(expectedCatchBlock, product.CatchBlock);
                Assert.Same(expectedRequest, product.Request);
                Assert.Same(expectedRequestContext, product.RequestContext);
                Assert.Null(product.ControllerContext);
                Assert.Null(product.ActionContext);
                Assert.Null(product.Response);
            }
        }

        [Fact]
        public void ConstructorWithRequest_IfExceptionIsNull_Throws()
        {
            // Arrange
            Exception exception = null;
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpRequestContext requestContext = CreateRequestContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                request.SetRequestContext(requestContext);

                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, request), "exception");
            }
        }

        [Fact]
        public void ConstructorWithRequest_IfCatchBlockIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = null;
            HttpRequestContext requestContext = CreateRequestContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                request.SetRequestContext(requestContext);

                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, request), "catchBlock");
            }
        }

        [Fact]
        public void ConstructorWithRequest_IfRequestIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, request), "request");
        }

        [Fact]
        public void ConstructorWithRequest_IfRequestContextIsNull_IgnoresRequestContext()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();

            using (HttpRequestMessage request = CreateRequest())
            {
                Assert.Null(request.GetRequestContext()); // Guard

                // Act
                ExceptionContext product = CreateProductUnderTest(exception, catchBlock, request);

                // Assert
                Assert.Null(product.RequestContext);
            }
        }

        [Fact]
        public void ConstructorWithRequestAndResponse_SetsPropertiesToSpecifiedValues()
        {
            // Arrange
            Exception expectedException = CreateException();
            ExceptionContextCatchBlock expectedCatchBlock = CreateCatchBlock();
            HttpRequestContext expectedRequestContext = CreateRequestContext();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                expectedRequest.SetRequestContext(expectedRequestContext);

                // Act
                ExceptionContext product = CreateProductUnderTest(expectedException, expectedCatchBlock,
                    expectedRequest, expectedResponse);

                // Assert
                Assert.Same(expectedException, product.Exception);
                Assert.Same(expectedCatchBlock, product.CatchBlock);
                Assert.Same(expectedRequest, product.Request);
                Assert.Same(expectedRequestContext, product.RequestContext);
                Assert.Same(expectedResponse, product.Response);
                Assert.Null(product.ControllerContext);
                Assert.Null(product.ActionContext);
            }
        }

        [Fact]
        public void ConstructorWithRequestAndResponse_IfExceptionIsNull_Throws()
        {
            // Arrange
            Exception exception = null;
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpRequestContext requestContext = CreateRequestContext();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpResponseMessage response = CreateResponse())
            {
                request.SetRequestContext(requestContext);

                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, request, response),
                    "exception");
            }
        }

        [Fact]
        public void ConstructorWithRequestAndResponse_IfCatchBlockIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = null;
            HttpRequestContext requestContext = CreateRequestContext();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpResponseMessage response = CreateResponse())
            {
                request.SetRequestContext(requestContext);

                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, request, response),
                    "catchBlock");
            }
        }

        [Fact]
        public void ConstructorWithRequestAndResponse_IfRequestIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();
            HttpRequestMessage request = null;

            using (HttpResponseMessage response = CreateResponse())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, request, response),
                    "request");
            }
        }

        [Fact]
        public void ConstructorWithRequestAndResponse_IfRequestContextIsNull_IgnoresRequestContext()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpResponseMessage response = CreateResponse())
            {
                Assert.Null(request.GetRequestContext()); // Guard

                // Act
                ExceptionContext product = CreateProductUnderTest(exception, catchBlock, request, response);

                // Assert
                Assert.Null(product.RequestContext);
            }
        }

        [Fact]
        public void ConstructorWithRequestAndResponse_IfResponseIsNull_Throws()
        {
            // Arrange
            Exception exception = CreateException();
            ExceptionContextCatchBlock catchBlock = CreateCatchBlock();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpResponseMessage response = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() => CreateProductUnderTest(exception, catchBlock, request, response),
                    "response");
            }
        }

        private static HttpActionContext CreateActionContext()
        {
            return new HttpActionContext();
        }

        private static HttpActionContext CreateActionContext(HttpControllerContext controllerContext)
        {
            return new HttpActionContext
            {
                ControllerContext = controllerContext
            };
        }

        private static ExceptionContextCatchBlock CreateCatchBlock()
        {
            return new ExceptionContextCatchBlock("IgnoreCaughtAt", isTopLevel: false, callsHandler: false);
        }

        private static HttpControllerContext CreateControllerContext()
        {
            return new HttpControllerContext();
        }

        private static HttpControllerContext CreateControllerContext(HttpRequestContext requestContext,
            HttpRequestMessage request)
        {
            return new HttpControllerContext
            {
                RequestContext = requestContext,
                Request = request
            };
        }

        private static Exception CreateException()
        {
            return new DivideByZeroException();
        }

        private static ExceptionContext CreateProductUnderTest()
        {
            return new ExceptionContext(CreateException(), CreateCatchBlock());
        }

        private static ExceptionContext CreateProductUnderTest(Exception exception,
            ExceptionContextCatchBlock catchBlock, HttpActionContext actionContext)
        {
            return new ExceptionContext(exception, catchBlock, actionContext);
        }

        private static ExceptionContext CreateProductUnderTest(Exception exception,
            ExceptionContextCatchBlock catchBlock, HttpRequestMessage request)
        {
            return new ExceptionContext(exception, catchBlock, request);
        }

        private static ExceptionContext CreateProductUnderTest(Exception exception,
            ExceptionContextCatchBlock catchBlock, HttpRequestMessage request, HttpResponseMessage response)
        {
            return new ExceptionContext(exception, catchBlock, request, response);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpRequestContext CreateRequestContext()
        {
            return new HttpRequestContext();
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionHandlerContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionHandlerContextTests
    {
        [Fact]
        public void Constructor_IfExceptionContextIsNull_Throws()
        {
            // Arrange
            ExceptionContext context = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(context), "exceptionContext");
        }

        [Fact]
        public void ExceptionContextGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionContext expectedContext = CreateMinimalContext();
            ExceptionHandlerContext product = CreateProductUnderTest(expectedContext);

            // Act
            ExceptionContext context = product.ExceptionContext;

            // Assert
            Assert.Same(expectedContext, context);
        }

        [Fact]
        public void ResultSet_UpdatesValue()
        {
            // Arrange
            ExceptionHandlerContext product = CreateProductUnderTest(CreateMinimalContext());
            IHttpActionResult expectedResult = CreateDummyResult();

            // Act
            product.Result = expectedResult;

            // Assert
            IHttpActionResult result = product.Result;
            Assert.Same(expectedResult, result);
        }

        [Fact]
        public void ExceptionGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            Exception expectedException = new InvalidOperationException();
            ExceptionContext context = new ExceptionContext(expectedException, ExceptionCatchBlocks.HttpServer);
            ExceptionHandlerContext product = CreateProductUnderTest(context);

            // Act
            Exception exception = product.Exception;

            // Assert
            Assert.Same(expectedException, exception);
        }

        [Fact]
        public void CatchBlockGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionContextCatchBlock expectedCatchBlock = new ExceptionContextCatchBlock("IgnoreName", false, false);
            ExceptionContext context = new ExceptionContext(new Exception(), expectedCatchBlock);
            ExceptionHandlerContext product = CreateProductUnderTest(context);

            // Act
            ExceptionContextCatchBlock catchBlock = product.CatchBlock;

            // Assert
            Assert.Same(expectedCatchBlock, catchBlock);
        }

        [Fact]
        public void RequestGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            {
                ExceptionContext context = CreateMinimalContext(expectedRequest);
                ExceptionHandlerContext product = CreateProductUnderTest(context);

                // Act
                HttpRequestMessage request = product.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void RequestContextGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpRequestContext expectedRequestContext = new HttpRequestContext();
            ExceptionContext context = CreateMinimalContext(expectedRequestContext);
            ExceptionHandlerContext product = CreateProductUnderTest(context);

            // Act
            HttpRequestContext requestContext = product.RequestContext;

            // Assert
            Assert.Same(expectedRequestContext, requestContext);
        }

        private static ExceptionContext CreateMinimalContext(HttpRequestContext context = null)
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer)
            {
                RequestContext = context,
            };
        }

        private static ExceptionContext CreateMinimalContext(HttpRequestMessage request)
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer, request);
        }

        private static IHttpActionResult CreateDummyResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static ExceptionHandlerContext CreateProductUnderTest(ExceptionContext exceptionContext)
        {
            return new ExceptionHandlerContext(exceptionContext);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionHandlerExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionHandlerExtensionsTests
    {
        [Fact]
        public async Task HandleAsync_CallsInterfaceHandleAsync()
        {
            // Arrange
            Mock<IExceptionHandler> mock = CreateStubHandlerMock();
            IExceptionHandler handler = mock.Object;

            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                ExceptionContext expectedContext = CreateMinimalValidContext();
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                await ExceptionHandlerExtensions.HandleAsync(handler, expectedContext,
                    expectedCancellationToken);

                // Assert
                mock.Verify(h => h.HandleAsync(It.Is<ExceptionHandlerContext>(
                    c => c.ExceptionContext == expectedContext), expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task HandleAsync_IfResultIsNotSet_ReturnsCompletedTaskWithNullResponse()
        {
            // Arrange
            IExceptionHandler handler = CreateStubHandler();
            ExceptionContext context = CreateMinimalValidContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act
            HttpResponseMessage response = await ExceptionHandlerExtensions.HandleAsync(handler, context, cancellationToken);

            // Assert
            Assert.Null(response);
        }

        [Fact]
        public async Task HandleAsync_IfResultIsSet_CallsResultExecuteAsync()
        {
            // Arrange
            using (HttpResponseMessage response = CreateResponse())
            {
                Mock<IHttpActionResult> mock = new Mock<IHttpActionResult>(MockBehavior.Strict);
                mock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(response));
                IHttpActionResult result = mock.Object;
                IExceptionHandler handler = CreateResultHandler(result);

                using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
                {
                    ExceptionContext context = CreateMinimalValidContext();
                    CancellationToken expectedCancellationToken = tokenSource.Token;

                    // Act
                    await ExceptionHandlerExtensions.HandleAsync(handler, context,
                        expectedCancellationToken);

                    // Assert
                    mock.Verify(h => h.ExecuteAsync(expectedCancellationToken), Times.Once());
                }
            }
        }

        [Fact]
        public async Task HandleAsync_IfResultIsSet_ReturnsCompletedTaskWithResultResponse()
        {
            // Arrange
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                Mock<IHttpActionResult> mock = new Mock<IHttpActionResult>(MockBehavior.Strict);
                mock.Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>())).Returns(Task.FromResult(expectedResponse));
                IHttpActionResult result = mock.Object;
                IExceptionHandler handler = CreateResultHandler(result);

                ExceptionContext context = CreateMinimalValidContext();
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                HttpResponseMessage response = await handler.HandleAsync(context, cancellationToken);

                // Assert
                Assert.Same(expectedResponse, response);
            }
        }

        [Fact]
        public void HandleAsync_IfHandlerIsNull_Throws()
        {
            // Arrange
            IExceptionHandler handler = null;
            ExceptionContext context = CreateMinimalValidContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
                ExceptionHandlerExtensions.HandleAsync(handler, context, cancellationToken), "handler");
        }

        [Fact]
        public void HandleAsync_IfContextIsNull_Throws()
        {
            // Arrange
            IExceptionHandler handler = CreateDummyHandler();
            ExceptionContext context = null;
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
                ExceptionHandlerExtensions.HandleAsync(handler, context, cancellationToken), "context");
        }

        [Fact]
        public async Task HandleAsync_IfResultIsSetButReturnsNull_ReturnsFaultedTask()
        {
            // Arrange
            Mock<IHttpActionResult> mock = new Mock<IHttpActionResult>(MockBehavior.Strict);
            mock
                .Setup(r => r.ExecuteAsync(It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult<HttpResponseMessage>(null));
            IHttpActionResult result = mock.Object;
            IExceptionHandler handler = CreateResultHandler(result);
            ExceptionContext context = CreateMinimalValidContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            var exception = await Assert.ThrowsAsync<InvalidOperationException>(
                () => ExceptionHandlerExtensions.HandleAsync(handler, context, cancellationToken));
            Assert.Equal("IHttpActionResult.ExecuteAsync must not return null.", exception.Message);
        }

        private static CancellationTokenSource CreateCancellationTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static ExceptionContext CreateMinimalValidContext()
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer);
        }

        private static IExceptionHandler CreateDummyHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static IExceptionHandler CreateResultHandler(IHttpActionResult result)
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                {
                    c.Result = result;
                    return Task.FromResult(0);
                });
            return mock.Object;
        }

        private static IExceptionHandler CreateStubHandler()
        {
            return CreateStubHandlerMock().Object;
        }

        private static Mock<IExceptionHandler> CreateStubHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionHandlerTests
    {
        [Fact]
        public void HandleAsync_IfContextIsNull_Throws()
        {
            // Arrange
            Mock<ExceptionHandler> mock = new Mock<ExceptionHandler> { CallBase = true };
            IExceptionHandler product = mock.Object;

            ExceptionHandlerContext context = null;
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.HandleAsync(context, cancellationToken), "context");
        }

        [Fact]
        public void HandleAsync_IfShouldHandleReturnsTrue_DelegatesToHandleAsyncCore()
        {
            // Arrange
            Mock<ExceptionHandler> mock = new Mock<ExceptionHandler> { CallBase = true };
            Task expectedTask = CreateCompletedTask();
            mock.Setup(h => h.ShouldHandle(It.IsAny<ExceptionHandlerContext>())).Returns(true);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(expectedTask);

            IExceptionHandler product = mock.Object;

            ExceptionHandlerContext expectedContext = CreateMinimalValidHandlerContext();

            using (CancellationTokenSource tokenSource = CreateTokenSource())
            {
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                Task task = product.HandleAsync(expectedContext, expectedCancellationToken);

                // Assert
                Assert.Same(expectedTask, task);
                mock.Verify(h => h.ShouldHandle(expectedContext), Times.Once());
                mock.Verify(h => h.HandleAsync(expectedContext, expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public void HandleAsync_IfShouldHandleReturnsFalse_ReturnsCompletedTask()
        {
            // Arrange
            Mock<ExceptionHandler> mock = new Mock<ExceptionHandler> { CallBase = true };
            mock.Setup(h => h.ShouldHandle(It.IsAny<ExceptionHandlerContext>())).Returns(false);

            IExceptionHandler product = mock.Object;

            ExceptionHandlerContext expectedContext = CreateMinimalValidHandlerContext();
            CancellationToken expectedCancellationToken = CancellationToken.None;

            // Act
            Task task = product.HandleAsync(expectedContext, expectedCancellationToken);

            // Assert
            Assert.NotNull(task);
            Assert.True(task.IsCompleted);
            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
            mock.Verify(h => h.ShouldHandle(expectedContext), Times.Once());
            mock.Verify(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()),
                Times.Never());
        }

        [Fact]
        public async Task HandleAsyncCore_DelegatesToHandleCore_AndReturnsCompletedTask()
        {
            // Arrange
            Mock<ExceptionHandler> mock = new Mock<ExceptionHandler>();
            mock.CallBase = true;
            ExceptionHandler product = mock.Object;

            ExceptionHandlerContext expectedContext = CreateMinimalValidHandlerContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act
            await product.HandleAsync(expectedContext, cancellationToken);

            // Assert
            mock.Verify(h => h.Handle(expectedContext), Times.Once());
        }

        [Fact]
        public void HandleCore_DoesNotThrow()
        {
            // Arrange
            Mock<ExceptionHandler> mock = new Mock<ExceptionHandler>();
            mock.CallBase = true;
            ExceptionHandler product = mock.Object;

            ExceptionHandlerContext context = CreateMinimalValidHandlerContext();

            // Act & Assert
            Assert.DoesNotThrow(() => product.Handle(context));
        }

        [Fact]
        public void ShouldHandle_IfContextIsNull_Throws()
        {
            // Arrange
            Mock<ExceptionHandler> mock = new Mock<ExceptionHandler>();
            mock.CallBase = true;
            ExceptionHandler product = mock.Object;

            ExceptionHandlerContext context = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.ShouldHandle(context), "context");
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void ShouldHandle_ReturnsIsTopLevelCatchBlock(bool isTopLevelCatchBlock)
        {
            // Arrange
            Mock<ExceptionHandler> mock = new Mock<ExceptionHandler>();
            mock.CallBase = true;
            ExceptionHandler product = mock.Object;

            ExceptionHandlerContext context = CreateContext(new ExceptionContext(new Exception(),
                new ExceptionContextCatchBlock("IgnoreCaughtAt", isTopLevelCatchBlock, callsHandler: false)));

            // Act
            bool shouldHandle = product.ShouldHandle(context);

            // Assert
            Assert.Equal(isTopLevelCatchBlock, shouldHandle);
        }

        private static Task CreateCompletedTask()
        {
            TaskCompletionSource<object> source = new TaskCompletionSource<object>();
            return source.Task;
        }

        private static ExceptionHandlerContext CreateContext(ExceptionContext exceptionContext)
        {
            return new ExceptionHandlerContext(exceptionContext);
        }

        private static ExceptionContext CreateMinimalValidExceptionContext()
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer);
        }

        private static CancellationTokenSource CreateTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static ExceptionHandlerContext CreateMinimalValidHandlerContext()
        {
            return new ExceptionHandlerContext(CreateMinimalValidExceptionContext());
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionLoggerContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionLoggerContextTests
    {
        [Fact]
        public void Constructor_IfExceptionContextIsNull_Throws()
        {
            // Arrange
            ExceptionContext context = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(context), "exceptionContext");
        }

        [Fact]
        public void ExceptionContextGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionContext expectedContext = CreateMinimalValidContext();
            ExceptionLoggerContext product = CreateProductUnderTest(expectedContext);

            // Act
            ExceptionContext context = product.ExceptionContext;

            // Assert
            Assert.Same(expectedContext, context);
        }

        [Fact]
        public void ExceptionGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            Exception expectedException = new InvalidOperationException();
            ExceptionContext context = new ExceptionContext(expectedException, ExceptionCatchBlocks.HttpServer);
            ExceptionLoggerContext product = CreateProductUnderTest(context);

            // Act
            Exception exception = product.Exception;

            // Assert
            Assert.Same(expectedException, exception);
        }

        [Fact]
        public void CatchBlockGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionContextCatchBlock expectedCatchBlock = new ExceptionContextCatchBlock("IgnoreName", false, false);
            ExceptionContext context = new ExceptionContext(new Exception(), expectedCatchBlock);
            ExceptionLoggerContext product = CreateProductUnderTest(context);

            // Act
            ExceptionContextCatchBlock catchBlock = product.CatchBlock;

            // Assert
            Assert.Same(expectedCatchBlock, catchBlock);
        }

        [Fact]
        public void RequestGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            {
                ExceptionContext context = new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer, expectedRequest);

                ExceptionLoggerContext product = CreateProductUnderTest(context);

                // Act
                HttpRequestMessage request = product.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void RequestContextGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpRequestContext expectedRequestContext = new HttpRequestContext();
            ExceptionContext context = CreateMinimalValidContext(expectedRequestContext);
            ExceptionLoggerContext product = CreateProductUnderTest(context);

            // Act
            HttpRequestContext requestContext = product.RequestContext;

            // Assert
            Assert.Same(expectedRequestContext, requestContext);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void CallsHandlerGet_ReturnsCatchBlockCallsHandler(bool expectedCallsHandler)
        {
            // Arrange
            ExceptionContext context = new ExceptionContext(new Exception(),
                new ExceptionContextCatchBlock("IgnoreName", isTopLevel: false,
                    callsHandler: expectedCallsHandler));

            ExceptionLoggerContext product = CreateProductUnderTest(context);

            // Act
            bool callsHandler = product.CallsHandler;

            // Assert
            Assert.Equal(expectedCallsHandler, callsHandler);
        }

        private static ExceptionContext CreateMinimalValidContext(HttpRequestContext context = null)
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer)
            {
                RequestContext = context,
            };
        }

        private static ExceptionLoggerContext CreateProductUnderTest(ExceptionContext exceptionContext)
        {
            return new ExceptionLoggerContext(exceptionContext);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionLoggerExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionLoggerExtensionsTests
    {
        [Fact]
        public async Task LogAsync_DelegatesToInterfaceLogAsync()
        {
            // Arrange
            Task expectedTask = CreateCompletedTask();
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(h => h.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(expectedTask);

            IExceptionLogger logger = mock.Object;

            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                ExceptionContext expectedContext = CreateMinimalValidContext();
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                Task task = ExceptionLoggerExtensions.LogAsync(logger, expectedContext, expectedCancellationToken);

                // Assert
                Assert.Same(expectedTask, task);
                await task;

                mock.Verify(h => h.LogAsync(It.Is<ExceptionLoggerContext>(c => c.ExceptionContext == expectedContext),
                    expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public void LogAsync_IfLoggerIsNull_Throws()
        {
            // Arrange
            IExceptionLogger logger = null;
            ExceptionContext context = CreateMinimalValidContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
                ExceptionLoggerExtensions.LogAsync(logger, context, cancellationToken), "logger");
        }

        [Fact]
        public void LogAsync_IfContextIsNull_Throws()
        {
            // Arrange
            IExceptionLogger logger = CreateDummyLogger();
            ExceptionContext context = null;
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
                ExceptionLoggerExtensions.LogAsync(logger, context, cancellationToken), "context");
        }

        private static CancellationTokenSource CreateCancellationTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static Task CreateCompletedTask()
        {
            TaskCompletionSource<object> source = new TaskCompletionSource<object>();
            source.SetResult(null);
            return source.Task;
        }

        private static ExceptionContext CreateMinimalValidContext()
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer);
        }

        private static IExceptionLogger CreateDummyLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionLoggerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionLoggerTests
    {
        [Fact]
        public void LogAsync_IfContextIsNull_Throws()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger> { CallBase = true };

            IExceptionLogger product = mock.Object;

            ExceptionLoggerContext context = null;
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.LogAsync(context, cancellationToken), "context");
        }

        [Fact]
        public void LogAsync_IfShouldLogReturnsTrue_DelegatesToLogAsyncCore()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger> { CallBase = true };
            Task expectedTask = CreateCompletedTask();
            mock.Setup(h => h.ShouldLog(It.IsAny<ExceptionLoggerContext>())).Returns(true);
            mock
                .Setup(h => h.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(expectedTask);

            IExceptionLogger product = mock.Object;

            ExceptionLoggerContext expectedContext = CreateMinimalValidLoggerContext();

            using (CancellationTokenSource tokenSource = CreateTokenSource())
            {
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                Task task = product.LogAsync(expectedContext, expectedCancellationToken);

                // Assert
                Assert.Same(expectedTask, task);
                mock.Verify(h => h.ShouldLog(expectedContext), Times.Once());
                mock.Verify(h => h.LogAsync(expectedContext, expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public void LogAsync_IfShouldLogReturnsFalse_ReturnsCompletedTask()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger> { CallBase = true };
            mock.Setup(h => h.ShouldLog(It.IsAny<ExceptionLoggerContext>())).Returns(false);

            IExceptionLogger product = mock.Object;

            ExceptionLoggerContext expectedContext = CreateMinimalValidLoggerContext();
            CancellationToken expectedCancellationToken = CancellationToken.None;

            // Act
            Task task = product.LogAsync(expectedContext, expectedCancellationToken);

            // Assert
            Assert.NotNull(task);
            Assert.True(task.IsCompleted);
            Assert.Equal(TaskStatus.RanToCompletion, task.Status);
            mock.Verify(h => h.ShouldLog(expectedContext), Times.Once());
            mock.Verify(h => h.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()),
                Times.Never());
        }

        [Fact]
        public async Task LogAsyncCore_DelegatesToLogCore_AndReturnsCompletedTask()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            ExceptionLoggerContext expectedContext = CreateMinimalValidLoggerContext();
            CancellationToken cancellationToken = CancellationToken.None;

            // Act
            await product.LogAsync(expectedContext, cancellationToken);

            // Assert
            mock.Verify(h => h.Log(expectedContext), Times.Once());
        }

        [Fact]
        public void LogCore_DoesNotThrow()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            ExceptionLoggerContext context = CreateMinimalValidLoggerContext();

            // Act & Assert
            Assert.DoesNotThrow(() => product.Log(context));
        }

        [Fact]
        public void ShouldLog_IfContextIsNull_Throws()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            ExceptionLoggerContext context = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.ShouldLog(context), "context");
        }

        [Fact]
        public void ShouldLog_IfExceptionDataIsNull_ReturnsTrue()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            Exception exception = CreateException(data: null);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.True(shouldLog);
        }

        [Fact]
        public void LoggedByKey_IsSpecifiedValue()
        {
            // Act & Assert
            Assert.Equal("MS_LoggedBy", ExceptionLogger.LoggedByKey);
        }

        [Fact]
        public void ShouldLog_IfExceptionDataIsReadOnly_ReturnsTrue()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            Mock<IDictionary> dataMock = new Mock<IDictionary>(MockBehavior.Strict);
            dataMock.Setup(d => d.IsReadOnly).Returns(true);
            IDictionary data = dataMock.Object;
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.True(shouldLog);
        }

        [Fact]
        public void ShouldLog_IfExceptionDataIsEmpty_AddsLoggedByKeyWithLoggerValueAndReturnsTrue()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            IDictionary data = new Dictionary();
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.True(shouldLog);
            Assert.True(data.Contains(ExceptionLogger.LoggedByKey));
            object loggedBy = data[ExceptionLogger.LoggedByKey];
            ICollection<object> loggedByCollection = Assert.IsAssignableFrom<ICollection<object>>(loggedBy);
            Assert.Contains(product, loggedByCollection);
        }

        [Fact]
        public void ShouldLog_IfExceptionDataHasEmptyLoggedBy_AddsLoggerAndReturnsTrue()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            ICollection<object> loggedBy = new List<object>();
            IDictionary data = new Dictionary();
            data.Add(ExceptionLogger.LoggedByKey, loggedBy);
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.True(shouldLog);
            Assert.True(data.Contains(ExceptionLogger.LoggedByKey));
            object updatedLoggedBy = data[ExceptionLogger.LoggedByKey];
            Assert.Same(loggedBy, updatedLoggedBy);
            Assert.Contains(product, loggedBy);
        }

        [Fact]
        public void ShouldLog_IfExceptionDataContainsLoggedByLogger_ReturnsFalse()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            IDictionary data = new Dictionary();
            ICollection<object> loggedBy = new List<object>() { product };
            data.Add(ExceptionLogger.LoggedByKey, loggedBy);
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.False(shouldLog);
            Assert.True(data.Contains(ExceptionLogger.LoggedByKey));
            object updatedLoggedBy = data[ExceptionLogger.LoggedByKey];
            Assert.Same(loggedBy, updatedLoggedBy);
            Assert.Equal(1, loggedBy.Count);
        }

        [Fact]
        public void ShouldLog_IfExceptionDataContainsLoggedByOfIncompatibleType_ReturnsTrue()
        {
            // Arrange
            Mock<ExceptionLogger> mock = new Mock<ExceptionLogger>();
            mock.CallBase = true;
            ExceptionLogger product = mock.Object;

            IDictionary data = new Dictionary();
            data.Add(ExceptionLogger.LoggedByKey, null);
            Exception exception = CreateException(data);
            ExceptionLoggerContext context = CreateMinimalValidLoggerContext(exception);

            // Act
            bool shouldLog = product.ShouldLog(context);

            // Assert
            Assert.True(shouldLog);
            Assert.True(data.Contains(ExceptionLogger.LoggedByKey));
            object updatedLoggedBy = data[ExceptionLogger.LoggedByKey];
            Assert.Null(updatedLoggedBy);
        }

        private static Task CreateCompletedTask()
        {
            TaskCompletionSource<object> source = new TaskCompletionSource<object>();
            return source.Task;
        }

        private static ExceptionLoggerContext CreateContext(ExceptionContext exceptionContext)
        {
            return new ExceptionLoggerContext(exceptionContext);
        }

        private static Exception CreateException(IDictionary data)
        {
            Mock<Exception> mock = new Mock<Exception>();
            mock.Setup(e => e.Data).Returns(data);
            return mock.Object;
        }

        private static ExceptionContext CreateMinimalValidExceptionContext()
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer);
        }

        private static CancellationTokenSource CreateTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static ExceptionLoggerContext CreateMinimalValidLoggerContext()
        {
            return CreateMinimalValidLoggerContext(new Exception());
        }

        private static ExceptionLoggerContext CreateMinimalValidLoggerContext(Exception exception)
        {
            return CreateContext(new ExceptionContext(exception, ExceptionCatchBlocks.HttpServer));
        }

        private class Dictionary : DictionaryBase
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/ExceptionServicesTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http.ExceptionHandling
{
    public class ExceptionServicesTests
    {
        [Fact]
        public void GetLoggerWithServices_ReturnsCompositeExceptionLoggerWithServicesLoggers()
        {
            // Arrange
            IExceptionLogger expectedLogger = CreateDummyLogger();

            using (ServicesContainer services = CreateServices(expectedLogger))
            {
                // Act
                IExceptionLogger logger = ExceptionServices.GetLogger(services);

                // Assert
                IEnumerable<IExceptionLogger> loggers = Assert.IsType<CompositeExceptionLogger>(logger).Loggers;
                IExceptionLogger actualLogger = Assert.Single(loggers);
                Assert.Same(expectedLogger, actualLogger);
            }
        }

        [Fact]
        public void GetLoggerWithServices_ReturnsSameInstance()
        {
            // Arrange
            IExceptionLogger innerLogger = CreateDummyLogger();

            using (ServicesContainer services = CreateServices(innerLogger))
            {
                IExceptionLogger firstLogger = ExceptionServices.GetLogger(services);

                // Act
                IExceptionLogger secondLogger = ExceptionServices.GetLogger(services);

                // Assert
                Assert.Same(firstLogger, secondLogger);
            }
        }

        [Fact]
        public void GetLoggerWithServices_IfServicesIsNull_Throws()
        {
            // Arrange
            ServicesContainer services = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => ExceptionServices.GetLogger(services), "services");
        }

        [Fact]
        public void GetLoggerWithConfiguration_ReturnsCompositeExceptionLoggerWithServicesLoggers()
        {
            // Arrange
            IExceptionLogger expectedLogger = CreateDummyLogger();

            using (HttpConfiguration configuration = CreateConfiguration(expectedLogger))
            {
                // Act
                IExceptionLogger logger = ExceptionServices.GetLogger(configuration);

                // Assert
                IEnumerable<IExceptionLogger> loggers = Assert.IsType<CompositeExceptionLogger>(logger).Loggers;
                IExceptionLogger actualLogger = Assert.Single(loggers);
                Assert.Same(expectedLogger, actualLogger);
            }
        }

        [Fact]
        public void GetLoggerWithConfiguration_IfConfigurationIsNull_Throws()
        {
            // Arrange
            HttpConfiguration configuration = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => ExceptionServices.GetLogger(configuration), "configuration");
        }

        [Fact]
        public void GetHandlerWithServices_ReturnsLastChanceHandlerWithServicesInnerHandler()
        {
            // Arrange
            IExceptionHandler expectedHandler = CreateDummyHandler();

            using (ServicesContainer services = CreateServices(expectedHandler))
            {
                // Act
                IExceptionHandler handler = ExceptionServices.GetHandler(services);

                // Assert
                IExceptionHandler innerHandler = Assert.IsType<LastChanceExceptionHandler>(handler).InnerHandler;
                Assert.Same(expectedHandler, innerHandler);
            }
        }

        [Fact]
        public void GetHandlerWithServices_ReturnsSameInstance()
        {
            // Arrange
            IExceptionHandler innerHandler = CreateDummyHandler();

            using (ServicesContainer services = CreateServices(innerHandler))
            {
                IExceptionHandler firstHandler = ExceptionServices.GetHandler(services);

                // Act
                IExceptionHandler secondHandler = ExceptionServices.GetHandler(services);

                // Assert
                Assert.Same(firstHandler, secondHandler);
            }
        }

        [Fact]
        public void GetHandlerWithServices_IfHandlerIsAbsent_ReturnsLastChanceHandlerWithEmptyInnerHandler()
        {
            // Arrange
            IExceptionHandler servicesHandler = null;

            using (ServicesContainer services = CreateServices(servicesHandler))
            {
                // Act
                IExceptionHandler handler = ExceptionServices.GetHandler(services);

                // Assert
                IExceptionHandler innerHandler = Assert.IsType<LastChanceExceptionHandler>(handler).InnerHandler;
                Assert.IsType<EmptyExceptionHandler>(innerHandler);
            }
        }

        [Fact]
        public void GetHandlerWithServices_IfServicesIsNull_Throws()
        {
            // Arrange
            ServicesContainer services = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => ExceptionServices.GetHandler(services), "services");
        }

        [Fact]
        public void GetHandlerWithConfiguration_ReturnsLastChanceHandlerWithServicesInnerHandler()
        {
            // Arrange
            IExceptionHandler expectedHandler = CreateDummyHandler();

            using (HttpConfiguration configuration = CreateConfiguration(expectedHandler))
            {
                // Act
                IExceptionHandler handler = ExceptionServices.GetHandler(configuration);

                // Assert
                IExceptionHandler innerHandler = Assert.IsType<LastChanceExceptionHandler>(handler).InnerHandler;
                Assert.Same(expectedHandler, innerHandler);
            }
        }

        [Fact]
        public void GetHandlerWithConfiguration_IfConfigurationIsNull_Throws()
        {
            // Arrange
            HttpConfiguration configuration = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => ExceptionServices.GetHandler(configuration), "configuration");
        }

        private static HttpConfiguration CreateConfiguration(IExceptionHandler handler)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Services.Replace(typeof(IExceptionHandler), handler);
            return configuration;
        }

        private static HttpConfiguration CreateConfiguration(params IExceptionLogger[] loggers)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Services.ReplaceRange(typeof(IExceptionLogger), loggers);
            return configuration;
        }

        private static IExceptionHandler CreateDummyHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static ServicesContainer CreateServices(IExceptionHandler handler)
        {
            Mock<ServicesContainer> mock = new Mock<ServicesContainer>(MockBehavior.Strict);
            mock.Setup(s => s.GetService(typeof(IExceptionHandler))).Returns(handler);
            LastChanceExceptionHandler cached = null;
            mock.Setup(s => s.GetService(typeof(LastChanceExceptionHandler))).Returns(() => cached);
            mock.Protected()
                .Setup("ReplaceSingle", typeof(LastChanceExceptionHandler), ItExpr.IsAny<object>())
                .Callback<Type, object>((i, o) => cached = (LastChanceExceptionHandler)o);
            mock.Setup(s => s.IsSingleService(typeof(LastChanceExceptionHandler))).Returns(true);
            mock.Protected().Setup("ResetCache", typeof(LastChanceExceptionHandler));
            mock.Setup(s => s.Dispose());
            return mock.Object;
        }

        private static ServicesContainer CreateServices(params IExceptionLogger[] loggers)
        {
            Mock<ServicesContainer> mock = new Mock<ServicesContainer>(MockBehavior.Strict);
            mock.Setup(s => s.GetServices(typeof(IExceptionLogger))).Returns(loggers);
            CompositeExceptionLogger cached = null;
            mock.Setup(s => s.GetService(typeof(CompositeExceptionLogger))).Returns(() => cached);
            mock.Protected()
                .Setup("ReplaceSingle", typeof(CompositeExceptionLogger), ItExpr.IsAny<object>())
                .Callback<Type, object>((i, o) => cached = (CompositeExceptionLogger)o);
            mock.Setup(s => s.IsSingleService(typeof(CompositeExceptionLogger))).Returns(true);
            mock.Protected().Setup("ResetCache", typeof(CompositeExceptionLogger));
            mock.Setup(s => s.Dispose());
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ExceptionHandling/LastChanceExceptionHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Results;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ExceptionHandling
{
    public class LastChanceExceptionHandlerTests
    {
        [Fact]
        public void Constructor_IfInnerHandlerIsNull_Throws()
        {
            // Arrange
            IExceptionHandler innerHandler = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => CreateProductUnderTest(innerHandler), "innerHandler");
        }

        [Fact]
        public void InnerHandler_ReturnsSpecifiedInstance()
        {
            // Arrange
            IExceptionHandler expectedInnerHandler = CreateDummyHandler();
            LastChanceExceptionHandler product = CreateProductUnderTest(expectedInnerHandler);

            // Act
            IExceptionHandler innerHandler = product.InnerHandler;

            // Assert
            Assert.Same(expectedInnerHandler, innerHandler);
        }

        [Fact]
        public async Task HandleAsync_DelegatesToInnerHandler()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            Task expectedTask = CreateCompletedTask();
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(expectedTask);
            IExceptionHandler innerHander = mock.Object;

            IExceptionHandler product = CreateProductUnderTest(innerHander);

            ExceptionHandlerContext expectedContext = CreateContext();

            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                Task task = product.HandleAsync(expectedContext, expectedCancellationToken);

                // Assert
                Assert.Same(expectedTask, task);
                await task;
                mock.Verify(h => h.HandleAsync(expectedContext, expectedCancellationToken), Times.Once());
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public async Task HandleAsync_IfIsTopLevelCatchBlockAndCanCreateExceptionResult_InitializesResult(bool includeDetail)
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            IHttpActionResult result = null;
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                {
                    result = c != null ? c.Result : null;
                    return Task.FromResult(0);
                });
            IExceptionHandler innerHander = mock.Object;

            IExceptionHandler product = CreateProductUnderTest(innerHander);

            Exception expectedException = CreateDummyException();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);
                configuration.Formatters.Clear();
                MediaTypeFormatter expectedFormatter = CreateDummyFormatter();
                configuration.Formatters.Add(expectedFormatter);

                ExceptionHandlerContext context = new ExceptionHandlerContext(new ExceptionContext(
                    exception: expectedException,
                    catchBlock: CreateTopLevelCatchBlock(),
                    request: expectedRequest)
                {
                    RequestContext = new HttpRequestContext
                                    {
                                        Configuration = configuration,
                                        IncludeErrorDetail = includeDetail
                                    },
                });

                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                ExceptionResult exceptionResult = Assert.IsType<ExceptionResult>(result);
                Assert.Same(expectedException, exceptionResult.Exception);
                Assert.Equal(includeDetail, exceptionResult.IncludeErrorDetail);
                Assert.Same(expectedContentNegotiator, exceptionResult.ContentNegotiator);
                Assert.Same(expectedRequest, exceptionResult.Request);
                Assert.NotNull(exceptionResult.Formatters);
                MediaTypeFormatter formatter = Assert.Single(exceptionResult.Formatters);
                Assert.Same(expectedFormatter, formatter);
            }
        }

        [Fact]
        public async Task HandleAsync_IfNotIsTopLevelCatchBlock_LeavesResultNull()
        {
            // Arrange
            Exception exception = CreateDummyException();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionContext context = new ExceptionContext(
                    exception,
                    CreateNonTopLevelCatchBlock(),
                    request)
                    {
                        RequestContext = new HttpRequestContext
                                        {
                                            Configuration = configuration
                                        },
                    };

                // More Arrange; then Act & Assert
                await TestHandleAsyncLeavesResultNull(context);
            }
        }

        [Fact]
        public Task HandleAsync_IfContextIsNull_LeavesResultNull()
        {
            // Arrange
            ExceptionHandlerContext context = null;

            // More Arrange; then Act & Assert
            return TestHandleAsyncLeavesResultNull(context);
        }

        [Fact]
        public async Task HandleAsync_IfRequestIsNull_LeavesResultNull()
        {
            // Arrange
            Exception exception = CreateDummyException();

            using (HttpConfiguration configuration = CreateConfiguration())
            {
                ExceptionContext context = new ExceptionContext(
                    exception,
                    CreateTopLevelCatchBlock())
                {
                    RequestContext = new HttpRequestContext
                    {
                        Configuration = configuration
                    },
                    Request = null
                };

                // More Arrange; then Act & Assert
                await TestHandleAsyncLeavesResultNull(context);
            }
        }

        [Fact]
        public async Task HandleAsync_IfRequestContextIsNull_LeavesResultNull()
        {
            // Arrange
            Exception exception = CreateDummyException();

            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionContext context = new ExceptionContext(
                    exception,
                    CreateTopLevelCatchBlock())
                {
                    RequestContext = null,
                    Request = request
                };

                // More Arrange; then Act & Assert
                await TestHandleAsyncLeavesResultNull(context);
            }
        }

        [Fact]
        public async Task HandleAsync_IfConfigurationIsNull_LeavesResultNull()
        {
            // Arrange
            Exception exception = CreateDummyException();

            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionContext context = new ExceptionContext(
                    exception,
                    CreateTopLevelCatchBlock())
                {
                    RequestContext = new HttpRequestContext
                    {
                        Configuration = null
                    },
                    Request = request
                };

                // More Arrange; then Act & Assert
                await TestHandleAsyncLeavesResultNull(context);
            }
        }

        [Fact]
        public async Task HandleAsync_IfContentNegotiatorIsNull_LeavesResultNull()
        {
            // Arrange
            Exception exception = CreateDummyException();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpRequestMessage request = CreateRequest())
            {
                configuration.Services.Clear(typeof(IContentNegotiator));

                ExceptionContext context = new ExceptionContext(
                    exception,
                    CreateTopLevelCatchBlock())
                {
                    RequestContext = new HttpRequestContext
                    {
                        Configuration = configuration
                    },
                    Request = request
                };

                // More Arrange; then Act & Assert
                await TestHandleAsyncLeavesResultNull(context);
            }
        }

        private static Task TestHandleAsyncLeavesResultNull(ExceptionContext context)
        {
            return TestHandleAsyncLeavesResultNull(new ExceptionHandlerContext(context));
        }

        private static async Task TestHandleAsyncLeavesResultNull(ExceptionHandlerContext context)
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            IHttpActionResult result = null;
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                {
                    result = c != null ? c.Result : null;
                    return Task.FromResult(0);
                });
            IExceptionHandler innerHander = mock.Object;

            IExceptionHandler product = CreateProductUnderTest(innerHander);

            CancellationToken cancellationToken = CancellationToken.None;

            // Act
            await product.HandleAsync(context, cancellationToken);

            // Assert
            Assert.Null(result);
        }

        private static CancellationTokenSource CreateCancellationTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static Task CreateCompletedTask()
        {
            TaskCompletionSource<object> source = new TaskCompletionSource<object>();
            source.SetResult(null);
            return source.Task;
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static ExceptionHandlerContext CreateContext()
        {
            return new ExceptionHandlerContext(CreateMinimalValidExceptionContext());
        }

        private static ExceptionContext CreateMinimalValidExceptionContext()
        {
            return new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer);
        }

        private static ExceptionHandlerContext CreateContext(ExceptionContext exceptionContext)
        {
            return new ExceptionHandlerContext(exceptionContext);
        }

        private static IContentNegotiator CreateDummyContentNegotiator()
        {
            return new Mock<IContentNegotiator>(MockBehavior.Strict).Object;
        }

        private static Exception CreateDummyException()
        {
            return new Mock<Exception>(MockBehavior.Strict).Object;
        }

        private static MediaTypeFormatter CreateDummyFormatter()
        {
            return new Mock<MediaTypeFormatter>(MockBehavior.Strict).Object;
        }

        private static IExceptionHandler CreateDummyHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static ExceptionContextCatchBlock CreateNonTopLevelCatchBlock()
        {
            return new ExceptionContextCatchBlock("IgnoreCaughtAt", isTopLevel: false, callsHandler: false);
        }

        private static LastChanceExceptionHandler CreateProductUnderTest(IExceptionHandler innerHandler)
        {
            return new LastChanceExceptionHandler(innerHandler);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static ExceptionContextCatchBlock CreateTopLevelCatchBlock()
        {
            return new ExceptionContextCatchBlock("IgnoreCaughtAt", isTopLevel: true, callsHandler: false);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/ActionDescriptorFilterProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class ActionDescriptorFilterProviderTest
    {
        private readonly ActionDescriptorFilterProvider _provider = new ActionDescriptorFilterProvider();
        private static readonly HttpConfiguration _configuration = new HttpConfiguration();

        [Fact]
        public void GetFilters_IfConfigurationParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                _provider.GetFilters(configuration: null, actionDescriptor: new Mock<HttpActionDescriptor>().Object);
            }, "configuration");
        }

        [Fact]
        public void GetFilters_IfActionDescriptorParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                _provider.GetFilters(_configuration, actionDescriptor: null);
            }, "actionDescriptor");
        }

        [Fact]
        public void GetFilters_GetsFilterObjectsFromActionDescriptorAndItsControllerDescriptor()
        {
            // Arrange
            Mock<HttpActionDescriptor> adMock = new Mock<HttpActionDescriptor>();
            IFilter filter1 = new Mock<IFilter>().Object;
            IFilter filter2 = new Mock<IFilter>().Object;
            IFilter filter3 = new Mock<IFilter>().Object;
            adMock.Setup(ad => ad.GetFilters()).Returns(new Collection<IFilter>(new[] { filter1, filter2 })).Verifiable();

            Mock<HttpControllerDescriptor> cdMock = new Mock<HttpControllerDescriptor>();
            cdMock.Setup(cd => cd.GetFilters()).Returns(new Collection<IFilter>(new[] { filter3 })).Verifiable();

            HttpActionDescriptor actionDescriptor = adMock.Object;
            actionDescriptor.ControllerDescriptor = cdMock.Object;

            // Act
            var result = _provider.GetFilters(_configuration, actionDescriptor).ToList();

            // Assert
            adMock.Verify();
            cdMock.Verify();
            Assert.Equal(3, result.Count);
            Assert.Equal(new FilterInfo(filter3, FilterScope.Controller), result[0], new TestFilterInfoComparer());
            Assert.Equal(new FilterInfo(filter1, FilterScope.Action), result[1], new TestFilterInfoComparer());
            Assert.Equal(new FilterInfo(filter2, FilterScope.Action), result[2], new TestFilterInfoComparer());
        }

        public class TestFilterInfoComparer : IEqualityComparer<FilterInfo>
        {
            public bool Equals(FilterInfo x, FilterInfo y)
            {
                return (x == null && y == null) || (Object.ReferenceEquals(x.Instance, y.Instance) && x.Scope == y.Scope);
            }

            public int GetHashCode(FilterInfo obj)
            {
                return obj.GetHashCode();
            }
        }

    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/ActionFilterAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class ActionFilterAttributeTest
    {
        [Fact]
        public void AllowsMultiple_DefaultReturnsTrue()
        {
            ActionFilterAttribute actionFilter = new TestableActionFilter();

            Assert.True(actionFilter.AllowMultiple);
        }

        [Fact]
        public void ExecuteActionFilterAsync_IfContextParameterIsNull_ThrowsException()
        {
            var filter = new TestableActionFilter() as IActionFilter;
            Assert.ThrowsArgumentNull(() =>
            {
                filter.ExecuteActionFilterAsync(actionContext: null, cancellationToken: CancellationToken.None, continuation: () => null);
            }, "actionContext");
        }

        [Fact]
        public void ExecuteActionFilterAsync_IfContinuationParameterIsNull_ThrowsException()
        {
            var filter = new TestableActionFilter() as IActionFilter;
            Assert.ThrowsArgumentNull(() =>
            {
                filter.ExecuteActionFilterAsync(actionContext: ContextUtil.CreateActionContext(), cancellationToken: CancellationToken.None, continuation: null);
            }, "continuation");
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_InvokesOnActionExecutingBeforeContinuation()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>() { CallBase = true };
            bool onActionExecutingInvoked = false;
            filterMock.Setup(f => f.OnActionExecuting(It.IsAny<HttpActionContext>())).Callback(() =>
            {
                onActionExecutingInvoked = true;
            });
            bool? flagWhenContinuationInvoked = null;
            Func<Task<HttpResponseMessage>> continuation = () =>
            {
                flagWhenContinuationInvoked = onActionExecutingInvoked;
                return Task.FromResult(new HttpResponseMessage());
            };
            var filter = (IActionFilter)filterMock.Object;

            // Act
            await filter.ExecuteActionFilterAsync(context, CancellationToken.None, continuation);
            // Assert
            Assert.True(flagWhenContinuationInvoked.Value);
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_OnActionExecutingMethodGetsPassedControllerContext()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>() { CallBase = true };
            var filter = (IActionFilter)filterMock.Object;

            // Act
            await filter.ExecuteActionFilterAsync(context, CancellationToken.None, () =>
            {
                return Task.FromResult(new HttpResponseMessage());
            });

            // Assert
            filterMock.Verify(f => f.OnActionExecuting(context));
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutingThrowsException_ReturnsFaultedTask()
        {
            // Arrange
            Exception expectedException = new Exception("{51C81EE9-F8D2-4F63-A1F8-B56052E0F2A4}");
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            filterMock.Setup(f => f.OnActionExecuting(It.IsAny<HttpActionContext>())).Throws(expectedException);
            var filter = (IActionFilter)filterMock.Object;
            bool continuationCalled = false;

            // Act
            var exception = await Assert.ThrowsAsync<Exception>(
                () => filter.ExecuteActionFilterAsync(context, CancellationToken.None, () =>
                {
                    continuationCalled = true;
                    return null;
                }));

            // Assert
            Assert.Same(expectedException, exception);
            Assert.False(continuationCalled);
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutingSetsResult_ShortCircuits()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            HttpResponseMessage response = new HttpResponseMessage();
            filterMock.Setup(f => f.OnActionExecuting(It.IsAny<HttpActionContext>())).Callback<HttpActionContext>(c =>
            {
                c.Response = response;
            });
            bool continuationCalled = false;
            var filter = (IActionFilter)filterMock.Object;

            // Act
            var result = await filter.ExecuteActionFilterAsync(context, CancellationToken.None, () =>
            {
                continuationCalled = true;
                return null;
            });

            // Assert
            Assert.False(continuationCalled);
            Assert.Same(response, result);
        }

        [Fact]
        public Task ExecuteActionFilterAsync_IfContinuationTaskWasCanceled_ReturnsCanceledTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;

            // Act & Assert
            return Assert.ThrowsAsync<TaskCanceledException>(
                () =>filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => TaskHelpers.Canceled<HttpResponseMessage>()));
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfContinuationSucceeded_InvokesOnActionExecutedAsSuccess()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            HttpResponseMessage response = new HttpResponseMessage();

            // Act
            await filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => Task.FromResult(response));

            // Assert
            filterMock.Verify(f => f.OnActionExecuted(It.Is<HttpActionExecutedContext>(ec =>
                    Object.ReferenceEquals(ec.Response, response)
                    && ec.Exception == null
                    && Object.ReferenceEquals(ec.ActionContext, context)
            )));
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfContinuationFaulted_InvokesOnActionExecutedAsError()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();

            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            Exception exception = new Exception("{ABCC912C-B6D1-4C27-9059-732ABC644A0C}");
            Func<Task<HttpResponseMessage>> continuation = () => TaskHelpers.FromError<HttpResponseMessage>(exception);

            // Act & Assert
            await Assert.ThrowsAsync<Exception>(
                () => filter.ExecuteActionFilterAsync(context, CancellationToken.None, continuation));

            // Assert
            filterMock.Verify(f => f.OnActionExecuted(It.Is<HttpActionExecutedContext>(ec =>
                    Object.ReferenceEquals(ec.Exception, exception)
                    && ec.Response == null
                    && Object.ReferenceEquals(ec.ActionContext, context)
            )));

            filterMock.Verify(f => f.OnActionExecutedAsync(It.Is<HttpActionExecutedContext>(ec =>
                    Object.ReferenceEquals(ec.Exception, exception)
                    && ec.Response == null
                    && Object.ReferenceEquals(ec.ActionContext, context)),
                    It.IsAny<CancellationToken>()
            ));
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_CancellationTokenFlowsThrough()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();

            using (var cts = new CancellationTokenSource())
            {
                CancellationToken token = cts.Token;

                Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
                {
                    CallBase = true,
                };

                var filter = (IActionFilter)filterMock.Object;
                Func<Task<HttpResponseMessage>> continuation = () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());

                // Act
                await filter.ExecuteActionFilterAsync(context, token, continuation);

                // Assert
                filterMock.Verify(f => f.OnActionExecutingAsync(It.IsAny<HttpActionContext>(),
                                               It.Is<CancellationToken>(t => t == token)));

                filterMock.Verify(f => f.OnActionExecutedAsync(It.IsAny<HttpActionExecutedContext>(),
                                                               It.Is<CancellationToken>(t => t == token)));
            }
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_DoesNotInvokeOnActionExecutedWhenOverriden()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            Func<Task<HttpResponseMessage>> continuation = () => Task.FromResult(new HttpResponseMessage());

            filterMock.Setup(f => f.OnActionExecutedAsync(It.IsAny<HttpActionExecutedContext>(), It.IsAny<CancellationToken>())).Returns(TaskHelpers.Completed());
            filterMock.Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Callback(
                () =>
                {
                    throw new InvalidOperationException();
                });

            var filter = (IActionFilter)filterMock.Object;

            // Act
            await filter.ExecuteActionFilterAsync(context, CancellationToken.None, continuation);

            // Assert
            filterMock.Verify(f => f.OnActionExecutedAsync(It.IsAny<HttpActionExecutedContext>(),
                                                           It.IsAny<CancellationToken>()));
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_DoesNotInvokeOnActionExecutingWhenOverriden()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            Func<Task<HttpResponseMessage>> continuation = () => Task.FromResult(new HttpResponseMessage());

            filterMock.Setup(f => f.OnActionExecutingAsync(It.IsAny<HttpActionContext>(), CancellationToken.None)).Returns(TaskHelpers.Completed());
            filterMock.Setup(f => f.OnActionExecuting(It.IsAny<HttpActionContext>())).Callback(
                () =>
                {
                    throw new InvalidOperationException();
                });

            var filter = (IActionFilter)filterMock.Object;

            // Act
            await filter.ExecuteActionFilterAsync(context, CancellationToken.None, continuation);

            // Assert
            filterMock.Verify(f => f.OnActionExecutedAsync(It.IsAny<HttpActionExecutedContext>(), CancellationToken.None));
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutedDoesNotHandleExceptionFromContinuation_ReturnsFaultedTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            Exception exception = new Exception("{1EC330A2-33D0-4892-9335-2D833849D54E}");
            filterMock.Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Callback<HttpActionExecutedContext>(ec =>
            {
                ec.Response = null;
            });

            // Act
            Exception result = await Assert.ThrowsAsync<Exception>(
                () => filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromError<HttpResponseMessage>(exception))
            );

            // Assert
            Assert.Same(exception, result);
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutedDoesHandleExceptionFromContinuation_ReturnsSuccessfulTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            HttpResponseMessage newResponse = new HttpResponseMessage();
            filterMock.Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Callback<HttpActionExecutedContext>(ec =>
            {
                ec.Response = newResponse;
            });

            // Act
            HttpResponseMessage result = await filter.ExecuteActionFilterAsync(
                                                        context,
                                                        CancellationToken.None,
                                                        () => TaskHelpers.FromError<HttpResponseMessage>(new Exception("{ED525C8E-7165-4207-B3F6-4AB095739017}")));

            // Assert
            Assert.Same(newResponse, result);
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutedThrowsException_ReturnsFaultedTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            Exception exception = new Exception("{AC32AD02-36A7-45E5-8955-76A4E3B461C6}");
            filterMock.Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Callback<HttpActionExecutedContext>(ec =>
            {
                throw exception;
            });

            // Act
            Exception actual = await Assert.ThrowsAsync<Exception>(
                () => filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => Task.FromResult(new HttpResponseMessage()))
            );


            // Assert
            Assert.Same(exception, actual);
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutedSetsResult_ReturnsNewResult()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            HttpResponseMessage newResponse = new HttpResponseMessage();
            filterMock.Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Callback<HttpActionExecutedContext>(ec =>
            {
                ec.Response = newResponse;
            });

            // Act
            HttpResponseMessage result = await filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => Task.FromResult(new HttpResponseMessage()));

            // Assert
            Assert.Same(newResponse, result);
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutedDoesNotChangeResult_ReturnsSameResult()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            HttpResponseMessage response = new HttpResponseMessage();
            filterMock.Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Callback<HttpActionExecutedContext>(ec =>
            {
                ec.Response = ec.Response;
            });

            // Act
            HttpResponseMessage result = await filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => Task.FromResult(response));

            // Assert
            Assert.Same(response, result);
        }

        [Fact]
        public Task ExecuteActionFilterAsync_IfOnActionExecutedRemovesSuccessfulResult_ReturnsFaultedTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<ActionFilterAttribute> filterMock = new Mock<ActionFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IActionFilter)filterMock.Object;
            HttpResponseMessage response = new HttpResponseMessage();
            filterMock.Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Callback<HttpActionExecutedContext>(ec =>
            {
                ec.Response = null;
            });

            // Act and Assert
            return Assert.ThrowsAsync<InvalidOperationException>(
                () => filter.ExecuteActionFilterAsync(context, CancellationToken.None, () => Task.FromResult(response)),
                "After calling ActionFilterAttributeProxy.OnActionExecuted, the HttpActionExecutedContext properties Result and Exception were both null. At least one of these values must be non-null. To provide a new response, please set the Result object; to indicate an error, please throw an exception."
            );
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfOnActionExecutedReplacesException_ThrowsNewException()
        {
            // Arrange
            Exception expectedReplacementException = CreateException();

            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                Mock<ActionFilterAttribute> mock = new Mock<ActionFilterAttribute>();
                mock.CallBase = true;
                mock
                    .Setup(f => f.OnActionExecuted(It.IsAny<HttpActionExecutedContext>()))
                    .Callback<HttpActionExecutedContext>((c) => c.Exception = expectedReplacementException);
                IActionFilter product = mock.Object;

                HttpActionContext context = ContextUtil.CreateActionContext();
                Func<Task<HttpResponseMessage>> continuation = () =>
                    CreateFaultedTask<HttpResponseMessage>(CreateException());

                // Act
                Exception exception = await Assert.ThrowsAsync<InvalidOperationException>(
                    () => product.ExecuteActionFilterAsync(context, CancellationToken.None, continuation)
                );

                // Assert
                Assert.Same(expectedReplacementException, exception);
            }
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_IfFaultedTaskExceptionIsUnhandled_PreservesExceptionStackTrace()
        {
            // Arrange
            Exception originalException = CreateExceptionWithStackTrace();
            string expectedStackTrace = originalException.StackTrace;

            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                IActionFilter product = new TestableActionFilter();
                HttpActionContext context = ContextUtil.CreateActionContext();
                Func<Task<HttpResponseMessage>> continuation = () => CreateFaultedTask<HttpResponseMessage>(
                    originalException);

                // Act
                Exception exception = await Assert.ThrowsAsync<InvalidOperationException>(
                    () => product.ExecuteActionFilterAsync(context, CancellationToken.None, continuation)
                );

                // Assert
                Assert.NotNull(expectedStackTrace);
                Assert.StartsWith(expectedStackTrace, exception.StackTrace);
            }
        }

        private static Exception CreateException()
        {
            return new InvalidOperationException();
        }

        private static Exception CreateExceptionWithStackTrace()
        {
            Exception exception;

            try
            {
                throw CreateException();
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            return exception;
        }

        private static Task<T> CreateFaultedTask<T>(Exception exception)
        {
            return TaskHelpers.FromError<T>(exception);
        }

        public class TestableActionFilter : ActionFilterAttribute
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/AuthorizationFilterAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class AuthorizationFilterAttributeTest
    {
        [Fact]
        public void AllowsMultiple_DefaultReturnsTrue()
        {
            AuthorizationFilterAttribute actionFilter = new TestableAuthorizationFilter();

            Assert.True(actionFilter.AllowMultiple);
        }

        [Fact]
        public void ExecuteAuthorizationFilterAsync_IfContextParameterIsNull_ThrowsException()
        {
            var filter = new TestableAuthorizationFilter() as IAuthorizationFilter;
            Assert.ThrowsArgumentNull(() =>
            {
                filter.ExecuteAuthorizationFilterAsync(actionContext: null, cancellationToken: CancellationToken.None, continuation: () => null);
            }, "actionContext");
        }

        [Fact]
        public void ExecuteAuthorizationFilterAsync_IfContinuationParameterIsNull_ThrowsException()
        {
            var filter = new TestableAuthorizationFilter() as IAuthorizationFilter;
            Assert.ThrowsArgumentNull(() =>
            {
                filter.ExecuteAuthorizationFilterAsync(actionContext: ContextUtil.CreateActionContext(), cancellationToken: CancellationToken.None, continuation: null);
            }, "continuation");
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_InvokesOnActionExecutingBeforeContinuation()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<AuthorizationFilterAttribute> filterMock = new Mock<AuthorizationFilterAttribute>() { CallBase = true };
            bool onActionExecutingInvoked = false;
            filterMock.Setup(f => f.OnAuthorization(It.IsAny<HttpActionContext>())).Callback(() =>
            {
                onActionExecutingInvoked = true;
            });
            bool? flagWhenContinuationInvoked = null;
            Func<Task<HttpResponseMessage>> continuation = () =>
            {
                flagWhenContinuationInvoked = onActionExecutingInvoked;
                return Task.FromResult(new HttpResponseMessage());
            };
            var filter = (IAuthorizationFilter)filterMock.Object;

            // Act
            await filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, continuation);

            // Assert
            Assert.True(flagWhenContinuationInvoked.Value);
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_IfOnActionExecutingSetsResult_ShortCircuits()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<AuthorizationFilterAttribute> filterMock = new Mock<AuthorizationFilterAttribute>
            {
                CallBase = true,
            };

            HttpResponseMessage response = new HttpResponseMessage();
            filterMock.Setup(f => f.OnAuthorization(It.IsAny<HttpActionContext>())).Callback<HttpActionContext>(c =>
            {
                c.Response = response;
            });

            bool continuationCalled = false;
            var filter = (IAuthorizationFilter)filterMock.Object;

            // Act
            var result = await filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () =>
            {
                continuationCalled = true;
                return null;
            });

            // Assert
            Assert.False(continuationCalled);
            Assert.Same(response, result);
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_IfOnActionExecutingThrowsException_ReturnsFaultedTask()
        {
            // Arrange
            Exception expectedException = new Exception();
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<AuthorizationFilterAttribute> filterMock = new Mock<AuthorizationFilterAttribute>()
            {
                CallBase = true,
            };

            filterMock.Setup(f => f.OnAuthorization(It.IsAny<HttpActionContext>())).Throws(expectedException);
            var filter = (IAuthorizationFilter)filterMock.Object;
            bool continuationCalled = false;

            // Act & Assert
            Exception exception = await Assert.ThrowsAsync<Exception>(
                () => filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () =>
                {
                    continuationCalled = true;
                    return null;
                }));

            // Assert
            Assert.Same(expectedException, exception);
            Assert.False(continuationCalled);
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_OnActionExecutingMethodGetsPassedControllerContext()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<AuthorizationFilterAttribute> filterMock = new Mock<AuthorizationFilterAttribute>() { CallBase = true };
            var filter = (IAuthorizationFilter)filterMock.Object;

            // Act
            await filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () =>
            {
                return Task.FromResult(new HttpResponseMessage());
            });

            // Assert
            filterMock.Verify(f => f.OnAuthorization(context));
        }

        [Fact]
        public Task ExecuteAuthorizationFilterAsync_IfContinuationTaskWasCanceled_ReturnsCanceledTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<AuthorizationFilterAttribute> filterMock = new Mock<AuthorizationFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IAuthorizationFilter)filterMock.Object;

            // Act & Assert
            return Assert.ThrowsAsync<TaskCanceledException>(
                () => filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () => TaskHelpers.Canceled<HttpResponseMessage>()));
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_IfContinuationSucceeded_ReturnsSuccessTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<AuthorizationFilterAttribute> filterMock = new Mock<AuthorizationFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IAuthorizationFilter)filterMock.Object;
            HttpResponseMessage expectedResponse = new HttpResponseMessage();

            // Act
            var response = await filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () => Task.FromResult(expectedResponse));

            // Assert
            Assert.Same(expectedResponse, response);
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_IfContinuationFaulted_ReturnsFaultedTask()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            Mock<AuthorizationFilterAttribute> filterMock = new Mock<AuthorizationFilterAttribute>()
            {
                CallBase = true,
            };

            var filter = (IAuthorizationFilter)filterMock.Object;
            Exception expectedException = new Exception();

            // Act
            var exception = await Assert.ThrowsAsync<Exception>(
                () => filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromError<HttpResponseMessage>(expectedException)));

            // Assert
            Assert.Same(expectedException, exception);
        }
    }

    public class TestableAuthorizationFilter : AuthorizationFilterAttribute
    {
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/ConfigurationFilterProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class ConfigurationFilterProviderTest
    {
        private readonly ConfigurationFilterProvider provider = new ConfigurationFilterProvider();

        [Fact]
        public void GetFilters_IfContextParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                provider.GetFilters(configuration: null, actionDescriptor: null);
            }, "configuration");
        }

        [Fact]
        public void GetFilters_ReturnsFiltersFromConfiguration()
        {
            var config = new HttpConfiguration();
            IFilter filter1 = new Mock<IFilter>().Object;
            config.Filters.Add(filter1);

            var result = provider.GetFilters(config, actionDescriptor: null);

            Assert.True(result.All(f => f.Scope == FilterScope.Global));
            Assert.Same(filter1, result.ToArray()[0].Instance);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/ExceptionFilterAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class ExceptionFilterAttributeTest
    {
        private readonly HttpActionExecutedContext _context = new HttpActionExecutedContext(ContextUtil.CreateActionContext(), new Exception());

        [Fact]
        public void AllowsMultiple_DefaultReturnsTrue()
        {
            ExceptionFilterAttribute actionFilter = new TestableExceptionFilter();

            Assert.True(actionFilter.AllowMultiple);
        }

        [Fact]
        public void ExecuteExceptionFilterAsync_IfContextParameterIsNull_ThrowsException()
        {
            IExceptionFilter filter = new Mock<ExceptionFilterAttribute>() { CallBase = true }.Object;

            Assert.ThrowsArgumentNull(() =>
            {
                filter.ExecuteExceptionFilterAsync(actionExecutedContext: null, cancellationToken: CancellationToken.None);
            }, "actionExecutedContext");
        }

        [Fact]
        public async Task ExecuteExceptionFilterAsync_IfOnExceptionThrowsException_RethrowsTheSameException()
        {
            // Arrange
            var mockFilter = new Mock<ExceptionFilterAttribute>() { CallBase = true };

            Exception exception = new Exception();
            mockFilter.Setup(f => f.OnException(_context)).Throws(exception);
            IExceptionFilter filter = mockFilter.Object;

            // Act & Assert
            var thrownException = await Assert.ThrowsAsync<Exception>(() =>
                filter.ExecuteExceptionFilterAsync(_context, CancellationToken.None));
            Assert.Same(exception, thrownException);
        }

        [Fact]
        public async Task ExecuteExceptionFilterAsync_InvokesOnExceptionMethod()
        {
            // Arrange
            var mockFilter = new Mock<ExceptionFilterAttribute>()
            {
                CallBase = true,
            };

            IExceptionFilter filter = mockFilter.Object;

            // Act
            await filter.ExecuteExceptionFilterAsync(_context, CancellationToken.None);

            // Assert
            mockFilter.Verify(f => f.OnException(_context));
        }

        [Fact]
        public void ExecuteExceptionFilterAsync_ReturnsCompletedTask()
        {
            // Arrange
            var mockFilter = new Mock<ExceptionFilterAttribute>() { CallBase = true };
            IExceptionFilter filter = mockFilter.Object;

            // Act
            var result = filter.ExecuteExceptionFilterAsync(_context, CancellationToken.None);

            // Assert
            Assert.True(result.Status == TaskStatus.RanToCompletion);
        }

        public sealed class TestableExceptionFilter : ExceptionFilterAttribute
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/FilterAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http.Filters
{
    [CLSCompliant(false)]
    public class FilterAttributeTest
    {
        [Theory]
        [InlineData(typeof(UniqueFilterAttribute), false)]
        [InlineData(typeof(MultiFilterAttribute), true)]
        [InlineData(typeof(DefaultFilterAttribute), true)]
        public void AllowMultiple(Type filterType, bool expectedAllowsMultiple)
        {
            var attribute = (FilterAttribute)Activator.CreateInstance(filterType);

            Assert.Equal(expectedAllowsMultiple, attribute.AllowMultiple);
        }

        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
        public sealed class UniqueFilterAttribute : FilterAttribute
        {
        }

        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
        public sealed class MultiFilterAttribute : FilterAttribute
        {
        }

        public sealed class DefaultFilterAttribute : FilterAttribute
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/FilterInfoComparerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class FilterInfoComparerTest
    {
        public static TheoryDataSet<FilterInfo, FilterInfo, int> CompareTestData
        {
            get
            {
                IFilter f = new Mock<IFilter>().Object;
                return new TheoryDataSet<FilterInfo, FilterInfo, int>()
                {
                    { null, null, 0 },
                    { new FilterInfo(f, FilterScope.Action), null, 1 },
                    { null, new FilterInfo(f, FilterScope.Action), -1 },
                    { new FilterInfo(f, FilterScope.Action), new FilterInfo(f, FilterScope.Action), 0 },
                    { new FilterInfo(f, FilterScope.Controller), new FilterInfo(f, FilterScope.Action), -1 },
                    { new FilterInfo(f, FilterScope.Action), new FilterInfo(f, FilterScope.Controller), 1 },
                };
            }
        }

        [Theory]
        [PropertyData("CompareTestData")]
        public void Compare(FilterInfo x, FilterInfo y, int expectedSign)
        {
            int result = FilterInfoComparer.Instance.Compare(x, y);

            Assert.Equal(expectedSign, Math.Sign(result));
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/FilterInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class FilterInfoTest
    {
        [Fact]
        public void Constructor()
        {
            var filterInstance = new Mock<IFilter>().Object;

            FilterInfo filter = new FilterInfo(filterInstance, FilterScope.Controller);

            Assert.Equal(FilterScope.Controller, filter.Scope);
            Assert.Same(filterInstance, filter.Instance);
        }

        [Fact]
        public void Constructor_IfInstanceParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                new FilterInfo(instance: null, scope: FilterScope.Controller);
            }, "instance");
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/HttpActionExecutedContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http.Filters
{
    public class HttpActionExecutedContextTest
    {
        [Fact]
        public void Default_Constructor()
        {
            HttpActionExecutedContext actionExecutedContext = new HttpActionExecutedContext();

            Assert.Null(actionExecutedContext.ActionContext);
            Assert.Null(actionExecutedContext.Exception);
            Assert.Null(actionExecutedContext.Request);
            Assert.Null(actionExecutedContext.Response);
        }

        [Fact]
        public void Parameter_Constructor()
        {
            HttpActionContext context = ContextUtil.CreateActionContext();
            Exception exception = new Exception();

            var actionContext = new HttpActionExecutedContext(context, exception);

            Assert.Same(context, actionContext.ActionContext);
            Assert.Same(exception, actionContext.Exception);
            Assert.Same(context.ControllerContext.Request, actionContext.Request);
            Assert.Null(actionContext.Response);
        }

        [Fact]
        public void Constructor_AllowsNullExceptionParameter()
        {
            HttpActionContext context = ContextUtil.CreateActionContext();

            var actionContext = new HttpActionExecutedContext(context, exception: null);

            Assert.Null(actionContext.Exception);
        }

        [Fact]
        public void Constructor_IfContextParameterIsNull_ThrowsException()
        {
            Assert.ThrowsArgumentNull(() =>
            {
                new HttpActionExecutedContext(actionContext: null, exception: null);
            }, "actionContext");
        }

        [Fact]
        public void ActionContext_Property()
        {
            Assert.Reflection.Property<HttpActionExecutedContext, HttpActionContext>(
                instance: new HttpActionExecutedContext(),
                propertyGetter: aec => aec.ActionContext,
                expectedDefaultValue: null,
                allowNull: false,
                roundTripTestValue: ContextUtil.CreateActionContext());
        }

        [Fact]
        public void Exception_Property()
        {
            Assert.Reflection.Property<HttpActionExecutedContext, Exception>(
                instance: new HttpActionExecutedContext(),
                propertyGetter: aec => aec.Exception,
                expectedDefaultValue: null,
                allowNull: true,
                roundTripTestValue: new ArgumentException());
        }

        [Fact]
        public void Result_Property()
        {
            Assert.Reflection.Property<HttpActionExecutedContext, HttpResponseMessage>(
            instance: new HttpActionExecutedContext(actionContext: ContextUtil.CreateActionContext(), exception: null),
                propertyGetter: aec => aec.Response,
                expectedDefaultValue: null,
                allowNull: true,
                roundTripTestValue: new HttpResponseMessage());
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/HttpAuthenticationChallengeContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class HttpAuthenticationChallengeContextTests
    {
        [Fact]
        public void Constructor_Throws_WhenActionContextIsNull()
        {
            // Arrange
            HttpActionContext actionContext = null;
            IHttpActionResult result = CreateDummyResult();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(actionContext, result); }, "actionContext");
        }

        [Fact]
        public void Constructor_Throws_WhenResultIsNull()
        {
            // Arrange
            HttpActionContext actionContext = CreateActionContext();
            IHttpActionResult result = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(actionContext, result); }, "result");
        }

        [Fact]
        public void ActionContext_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpActionContext expectedActionContext = CreateActionContext();
            IHttpActionResult result = CreateDummyResult();
            HttpAuthenticationChallengeContext product = CreateProductUnderTest(expectedActionContext, result);

            // Act
            HttpActionContext actionContext = product.ActionContext;

            // Assert
            Assert.Same(expectedActionContext, actionContext);
        }

        [Fact]
        public void Result_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpActionContext actionContext = CreateActionContext();
            IHttpActionResult expectedResult = CreateDummyResult();
            HttpAuthenticationChallengeContext product = CreateProductUnderTest(actionContext, expectedResult);

            // Act
            IHttpActionResult result = product.Result;

            // Assert
            Assert.Same(expectedResult, result);
        }

        [Fact]
        public void Request_ReturnsActionContextRequest()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpActionContext actionContext = CreateActionContext(expectedRequest);
                IHttpActionResult result = CreateDummyResult();
                HttpAuthenticationChallengeContext product = CreateProductUnderTest(actionContext, result);

                // Act
                HttpRequestMessage request = product.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void ResultSetter_Throws_WhenNull()
        {
            // Arrange
            HttpActionContext actionContext = CreateActionContext();
            IHttpActionResult result = CreateDummyResult();
            HttpAuthenticationChallengeContext product = CreateProductUnderTest(actionContext, result);

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { product.Result = null; }, "value");
        }

        private static HttpActionContext CreateActionContext()
        {
            return new HttpActionContext();
        }

        private static HttpActionContext CreateActionContext(HttpRequestMessage request)
        {
            HttpControllerContext controllerContext = new HttpControllerContext();
            controllerContext.Request = request;
            HttpActionContext actionContext = new HttpActionContext();
            actionContext.ControllerContext = controllerContext;
            return actionContext;
        }

        private static IHttpActionResult CreateDummyResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static HttpAuthenticationChallengeContext CreateProductUnderTest(HttpActionContext actionContext,
            IHttpActionResult result)
        {
            return new HttpAuthenticationChallengeContext(actionContext, result);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/HttpAuthenticationContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Principal;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Controllers
{
    public class HttpAuthenticationContextTests
    {
        [Fact]
        public void Constructor_Throws_WhenActionContextIsNull()
        {
            // Arrange
            HttpActionContext actionContext = null;
            IPrincipal principal = CreateDummyPrincipal();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(actionContext, principal); }, "actionContext");
        }

        [Fact]
        public void ActionContext_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpActionContext expectedActionContext = CreateActionContext();
            IPrincipal principal = CreateDummyPrincipal();
            HttpAuthenticationContext product = CreateProductUnderTest(expectedActionContext, principal);

            // Act
            HttpActionContext actionContext = product.ActionContext;

            // Assert
            Assert.Same(expectedActionContext, actionContext);
        }

        [Fact]
        public void Principal_ReturnsSpecifiedInstance()
        {
            // Arrange
            HttpActionContext actionContext = CreateActionContext();
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            HttpAuthenticationContext product = CreateProductUnderTest(actionContext, expectedPrincipal);

            // Act
            IPrincipal principal = product.Principal;

            // Assert
            Assert.Same(expectedPrincipal, principal);
        }

        [Fact]
        public void Request_ReturnsActionContextRequest()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpActionContext actionContext = CreateActionContext(expectedRequest);
                IPrincipal principal = CreateDummyPrincipal();
                HttpAuthenticationContext product = CreateProductUnderTest(actionContext, principal);

                // Act
                HttpRequestMessage request = product.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        private static HttpActionContext CreateActionContext()
        {
            return new HttpActionContext();
        }

        private static HttpActionContext CreateActionContext(HttpRequestMessage request)
        {
            HttpControllerContext controllerContext = new HttpControllerContext();
            controllerContext.Request = request;
            HttpActionContext actionContext = new HttpActionContext();
            actionContext.ControllerContext = controllerContext;
            return actionContext;
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static HttpAuthenticationContext CreateProductUnderTest(HttpActionContext actionContext,
            IPrincipal principal)
        {
            return new HttpAuthenticationContext(actionContext, principal);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Filters/HttpFilterCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Filters
{
    public class HttpFilterCollectionTest
    {
        private readonly IFilter _filter = new Mock<IFilter>().Object;
        private readonly HttpFilterCollection _collection = new HttpFilterCollection();

        [Fact]
        public void Add_WhenFilterParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => _collection.Add(filter: null), "filter");
        }

        [Fact]
        public void Add_AddsFilterWithGlobalScope()
        {
            _collection.Add(_filter);

            Assert.Same(_filter, _collection.First().Instance);
            Assert.Equal(FilterScope.Global, _collection.First().Scope);
        }

        [Fact]
        public void Add_AllowsAddingSameInstanceMultipleTimes()
        {
            _collection.Add(_filter);
            _collection.Add(_filter);

            Assert.Equal(2, _collection.Count);
        }

        [Fact]
        public void AddRange_AddsAllFilters()
        {
            IFilter[] filters = { _filter, _filter };

            _collection.AddRange(filters);

            Assert.Equal(filters.Length, _collection.Count);
            Assert.True(filters.All(_collection.Contains));
        }

        [Fact]
        public void AddRange_AddsAllFiltersWithGlobalScope()
        {
            IFilter[] filters = { _filter, _filter };

            _collection.AddRange(filters);

            Assert.True(_collection.All(f => FilterScope.Global == f.Scope));
        }

        [Fact]
        public void AddRange_ValidatesNotNull()
        {
            IFilter[] filters = { _filter, null };

            Assert.Throws<ArgumentException>(
                () => _collection.AddRange(filters),
                "The parameter 'filters' cannot contain a null element." + Environment.NewLine +
                "Parameter name: filters");

            Assert.Equal(0, _collection.Count);
        }

        [Fact]
        public void Clear_EmptiesCollection()
        {
            _collection.Add(_filter);

            _collection.Clear();

            Assert.Equal(0, _collection.Count);
        }

        [Fact]
        public void Contains_WhenFilterNotInCollection_ReturnsFalse()
        {
            Assert.False(_collection.Contains(_filter));
        }

        [Fact]
        public void Contains_WhenFilterInCollection_ReturnsTrue()
        {
            _collection.Add(_filter);

            Assert.True(_collection.Contains(_filter));
        }

        [Fact]
        public void Count_WhenCollectionIsEmpty_ReturnsZero()
        {
            Assert.Equal(0, _collection.Count);
        }

        [Fact]
        public void Count_WhenItemAddedToCollection_ReturnsOne()
        {
            _collection.Add(_filter);

            Assert.Equal(1, _collection.Count);
        }

        [Fact]
        public void Remove_WhenCollectionDoesNotHaveFilter_DoesNothing()
        {
            _collection.Remove(_filter);

            Assert.Equal(0, _collection.Count);
        }

        [Fact]
        public void Remove_WhenCollectionHasFilter_RemovesIt()
        {
            _collection.Add(_filter);
            _collection.Add(_filter);

            _collection.Remove(_filter);

            Assert.Equal(0, _collection.Count);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Hosting/HttpMessageHandlerExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http.Hosting
{
    internal static class HttpMessageHandlerExtensions
    {
        public static Task<HttpResponseMessage> SendAsync(this HttpMessageHandler handler, HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            HttpMessageInvoker invoker = new HttpMessageInvoker(handler, false);
            return invoker.SendAsync(request, cancellationToken);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Hosting/HttpRouteTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.Hosting
{
    public class HttpRouteTest
    {
        [Fact]
        public void Ctor_PreservesWhitespaceInRouteTemplate()
        {
            string whitespace = "   ";

            HttpRoute httpRoute = new HttpRoute(whitespace);

            Assert.Equal(whitespace, httpRoute.RouteTemplate);
        }

        [Theory]
        [InlineData("{controller}/{id}", "/SelfHostServer", "http://localhost/SelfHostServer/Customer/999")]
        [InlineData("{controller}/{id}", "", "http://localhost/Customer/999")]
        [InlineData("{controller}", "", "http://localhost/")]
        [InlineData("{controller}", "/SelfHostServer", "http://localhost/SelfHostServer")]
        [InlineData("{controller}", "", "http://localhost")]
        [InlineData("{controller}/{id}", "", "http://localhost/")]
        [InlineData("{controller}/{id}", "/SelfHostServer", "http://localhost/SelfHostServer")]
        [InlineData("{controller}/{id}", "", "http://localhost")]
        [InlineData("api", "", "http://localhost/api")]
        [InlineData("api", "", "http://LOCALHOST/API")]
        [InlineData("{controller}/{id}", "/SelfHostServer/Customer/999", "http://localhost/SelfHostServer/Customer/999")]
        [InlineData("{controller}/{id}", "/SelfHostServer/Customer/999", "http://localhost/SelfHostServer/Customer/999/")]
        [InlineData("{controller}/{id}", "/SelfHostServer/Customer/999/", "http://localhost/SelfHostServer/Customer/999/")]
        [InlineData("{controller}", "/SelfHostServer", "http://localhost/SelfHostServer/")]
        [InlineData("{controller}", "/SelfHostServer/", "http://localhost/SelfHostServer/")]
        public void GetRouteDataShouldMatch(string uriTemplate, string virtualPathRoot, string requestUri)
        {
            HttpRoute route = new HttpRoute(uriTemplate);
            route.Defaults.Add("controller", "Customer");
            route.Defaults.Add("id", "999");
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(requestUri);

            IHttpRouteData data = route.GetRouteData(virtualPathRoot, request);

            // Assert
            Assert.NotNull(data);
            IDictionary<string, object> expectedResult = new Dictionary<string, object>();
            expectedResult["controller"] = "Customer";
            expectedResult["id"] = "999";
            Assert.Equal(expectedResult, data.Values, new DictionaryEqualityComparer());
        }

        [Theory]
        [InlineData("{controller}/{id}", "/SelfHostServer/Customer/999/Invalid", "http://localhost/SelfHostServer/Customer/999")]
        [InlineData("{controller}", "/SelfHostServer/", "http://localhost/SelfHostServer")]
        public void GetRouteDataDoesNotMatch(string uriTemplate, string virtualPathRoot, string requestUri)
        {
            HttpRoute route = new HttpRoute(uriTemplate);
            route.Defaults.Add("controller", "Customer");
            route.Defaults.Add("id", "999");
            HttpRequestMessage request = new HttpRequestMessage();
            request.RequestUri = new Uri(requestUri);

            IHttpRouteData data = route.GetRouteData(virtualPathRoot, request);

            // Assert
            Assert.Null(data);
        }

        [Theory]
        [InlineData("controller")]
        [InlineData("cOnTrOlLeR")]
        [InlineData("CONTROLLER")]
        public void GetVirtualPath_GetsValuesInCaseInsensitiveWay(string controllerKey)
        {
            var route = new HttpRoute("{controller}");
            var request = new HttpRequestMessage();
            request.SetRouteData(
                new HttpRouteData(route, new HttpRouteValueDictionary() {
                    { "controller", "Employees" }
                }));
            var values = new HttpRouteValueDictionary()
            {
                { "httproute", true },
                { controllerKey, "Customers" }
            };

            IHttpVirtualPathData virtualPath = route.GetVirtualPath(request, values);

            Assert.NotNull(virtualPath);
            Assert.Equal("Customers", virtualPath.VirtualPath);
        }

        [Fact]
        public void GetVirtualPath_GeneratesPathWithoutRouteData()
        {
            var route = new HttpRoute("{controller}");
            var request = new HttpRequestMessage();
            var values = new HttpRouteValueDictionary()
            {
                { "httproute", true },
                { "controller", "Customers" }
            };

            IHttpVirtualPathData virtualPath = route.GetVirtualPath(request, values);

            Assert.NotNull(virtualPath);
            Assert.Equal("Customers", virtualPath.VirtualPath);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Hosting/SuppressHostPrincipalMessageHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Hosting
{
    public class SuppressHostPrincipalMessageHandlerTest
    {
        [Fact]
        public async Task SendAsync_DelegatesToInnerHandler()
        {
            // Arrange
            HttpRequestMessage request = null;
            var cancellationToken = default(CancellationToken);
            HttpMessageHandler innerHandler = new LambdaHttpMessageHandler((r, c) =>
            {
                request = r;
                cancellationToken = c;
                return Task.FromResult<HttpResponseMessage>(null);
            });
            HttpMessageHandler handler = CreateProductUnderTest(innerHandler);
            var expectedCancellationToken = new CancellationToken(true);

            using (var expectedRequest = CreateRequestWithContext())
            {
                // Act
                var result = await handler.SendAsync(expectedRequest, expectedCancellationToken);

                // Assert
                Assert.Same(expectedRequest, request);
                Assert.Equal(expectedCancellationToken, cancellationToken);
                Assert.Null(result);
            }
        }

        [Fact]
        public async Task SendAsync_Throws_WhenRequestContextIsNull()
        {
            // Arrange
            HttpMessageHandler innerHandler = CreateDummyHandler();
            HttpMessageHandler handler = CreateProductUnderTest(innerHandler);

            using (HttpRequestMessage request = new HttpRequestMessage())
            {
                // Act & Assert
                await Assert.ThrowsArgumentAsync(
                    () => handler.SendAsync(request, CancellationToken.None),
                    "request",
                    "The request must have a request context.");
            }
        }

        [Fact]
        public async Task SendAsync_SetsCurrentPrincipalToAnonymous_BeforeCallingInnerHandler()
        {
            // Arrange
            var requestContextMock = new Mock<HttpRequestContext>(MockBehavior.Strict);
            var sequence = new MockSequence();
            var initialPrincipal = new GenericPrincipal(new GenericIdentity("generic user"), new[] { "generic role" });
            IPrincipal requestContextPrincipal = null;
            requestContextMock
                .InSequence(sequence)
                .SetupGet(c => c.Principal)
                .Returns(initialPrincipal);
            requestContextMock
                .InSequence(sequence)
                .SetupSet(c => c.Principal = It.IsAny<IPrincipal>())
                .Callback<IPrincipal>(value => requestContextPrincipal = value);

            // SendAsync also restores the old principal.
            requestContextMock
                .InSequence(sequence)
                .SetupGet(c => c.Principal)
                .Returns(requestContextPrincipal);
            requestContextMock
                .InSequence(sequence)
                .SetupSet(c => c.Principal = initialPrincipal);

            IPrincipal principalBeforeInnerHandler = null;
            HttpMessageHandler inner = new LambdaHttpMessageHandler((ignore1, ignore2) =>
            {
                principalBeforeInnerHandler = requestContextPrincipal;
                return Task.FromResult<HttpResponseMessage>(null);
            });
            HttpMessageHandler handler = CreateProductUnderTest(inner);

            using (var request = new HttpRequestMessage())
            {
                request.SetRequestContext(requestContextMock.Object);

                // Act
                await handler.SendAsync(request, CancellationToken.None);
            }

            // Assert
            Assert.Equal(requestContextPrincipal, principalBeforeInnerHandler);
            Assert.NotNull(principalBeforeInnerHandler);
            var identity = principalBeforeInnerHandler.Identity;
            Assert.NotNull(identity);
            Assert.False(identity.IsAuthenticated);
            Assert.Null(identity.Name);
            Assert.Null(identity.AuthenticationType);
        }

        private static HttpMessageHandler CreateDummyHandler()
        {
            return new DummyHttpMessageHandler();
        }

        private static SuppressHostPrincipalMessageHandler CreateProductUnderTest(HttpMessageHandler innerHandler)
        {
            SuppressHostPrincipalMessageHandler handler = new SuppressHostPrincipalMessageHandler();
            handler.InnerHandler = innerHandler;
            return handler;
        }

        private static HttpRequestMessage CreateRequestWithContext()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetRequestContext(new HttpRequestContext());
            return request;
        }

        private class DummyHttpMessageHandler : HttpMessageHandler
        {
            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }
        }

        private class LambdaHttpMessageHandler : HttpMessageHandler
        {
            private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _sendAsync;

            public LambdaHttpMessageHandler(Func<HttpRequestMessage, CancellationToken,
                Task<HttpResponseMessage>> sendAsync)
            {
                if (sendAsync == null)
                {
                    throw new ArgumentNullException("sendAsync");
                }

                _sendAsync = sendAsync;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
                CancellationToken cancellationToken)
            {
                return _sendAsync.Invoke(request, cancellationToken);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpConfigurationExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Hosting;
using System.Web.Http.ModelBinding;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class HttpConfigurationExtensionsTest
    {
        [Fact]
        public void BindParameter_GuardClauses()
        {
            HttpConfiguration config = new HttpConfiguration();
            Type type = typeof(TestParameter);
            IModelBinder binder = new Mock<IModelBinder>().Object;

            Assert.ThrowsArgumentNull(() => HttpConfigurationExtensions.BindParameter(null, type, binder), "configuration");
            Assert.ThrowsArgumentNull(() => HttpConfigurationExtensions.BindParameter(config, null, binder), "type");
            Assert.ThrowsArgumentNull(() => HttpConfigurationExtensions.BindParameter(config, type, null), "binder");
        }

        [Fact]
        public void BindParameter_InsertsModelBinderProviderInPositionZero()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            Type type = typeof(TestParameter);
            IModelBinder binder = new Mock<IModelBinder>().Object;

            // Act
            config.BindParameter(type, binder);

            // Assert
            SimpleModelBinderProvider provider = config.Services.GetServices(typeof(ModelBinderProvider)).OfType<SimpleModelBinderProvider>().First();
            Assert.Equal(type, provider.ModelType);
        }

        [Fact]
        public void MapHttpAttributeRoutes_DoesNotAddRoutesWithoutAttribute()
        {
            // Arrange
            var config = new HttpConfiguration();
            var routePrefixes = new Collection<IRoutePrefix>() { new RoutePrefixAttribute("prefix") };
            var routeProviders = new Collection<RouteAttribute>() { };
            SetUpConfiguration(config, routePrefixes, routeProviders);

            // Act
            config.MapHttpAttributeRoutes();

            // Assert
            var routes = config.GetAttributeRoutes();
            Assert.Empty(routes);
        }

        [Fact]
        public void MapHttpAttributeRoutes_DoesNotRegisterRoute_ForActionsWithPrefixButNoRouteTemplate()
        {
            // Arrange
            var config = new HttpConfiguration();
            var routePrefixes = new Collection<IRoutePrefix>() { new RoutePrefixAttribute("prefix") };
            var routeProviders = new Collection<RouteAttribute>() { };
            SetUpConfiguration(config, routePrefixes, routeProviders);

            // Act
            config.MapHttpAttributeRoutes();

            // Assert
            var routes = config.GetAttributeRoutes();
            Assert.Empty(routes);
        }

        [Theory]
        [InlineData(null, "", "")]
        [InlineData(null, "   ", "   ")]
        [InlineData(null, "controller/{id}", "controller/{id}")]
        [InlineData("", "", "")]
        [InlineData("", "   ", "   ")]
        [InlineData("", "controller/{id}", "controller/{id}")]
        [InlineData("   ", "", "   ")]
        [InlineData("   ", "   ", "   /   ")]
        [InlineData("   ", "controller/{id}", "   /controller/{id}")]
        [InlineData("prefix/{prefixId}", "", "prefix/{prefixId}")]
        [InlineData("prefix/{prefixId}", "   ", "prefix/{prefixId}/   ")]
        [InlineData("prefix/{prefixId}", "controller/{id}", "prefix/{prefixId}/controller/{id}")]
        [InlineData(null, "~/controller/{id}", "controller/{id}")]
        [InlineData("prefix/{prefixId}", "~/", "")]
        [InlineData("prefix/{prefixId}", "~/controller/{id}", "controller/{id}")]
        public void MapHttpAttributeRoutes_AddsRouteFromAttribute(string prefix, string template, string expectedTemplate)
        {
            // Arrange
            var config = new HttpConfiguration();
            var routePrefixes = new Collection<IRoutePrefix>();
            if (prefix != null)
            {
                routePrefixes.Add(new RoutePrefixAttribute(prefix));
            }

            var routeProviders = new Collection<RouteAttribute>() { new RouteAttribute(template) };

            SetUpConfiguration(config, routePrefixes, routeProviders);

            // Act
            config.MapHttpAttributeRoutes();

            // Assert
            var routes = config.GetAttributeRoutes();
            IHttpRoute route = Assert.Single(routes);
            Assert.Equal(expectedTemplate, route.RouteTemplate);
        }

        [Fact]
        public void MapHttpAttributeRoutes_ThrowsForRoutePrefixThatEndsWithSeparator()
        {
            // Arrange
            var config = new HttpConfiguration();
            var routePrefixes = new Collection<IRoutePrefix>() { new RoutePrefixAttribute("prefix/") };
            var routeProviders = new Collection<RouteAttribute>() { new RouteAttribute("") };
            SetUpConfiguration(config, routePrefixes, routeProviders);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => { config.MapHttpAttributeRoutes(); config.EnsureInitialized(); },
                "The route prefix 'prefix/' on the controller named 'Controller' cannot end with a '/' character.");
        }

        [Fact]
        public void MapHttpAttributeRoutes_ThrowsForRouteTemplateThatStartsWithSeparator()
        {
            // Arrange
            var config = new HttpConfiguration();
            var routePrefixes = new Collection<IRoutePrefix>() { };
            var routeProviders = new Collection<RouteAttribute>() { new RouteAttribute("/get") };
            SetUpConfiguration(config, routePrefixes, routeProviders);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => { config.MapHttpAttributeRoutes(); config.EnsureInitialized(); },
                "The route template '/get' on the action named 'Action' cannot start with a '/' character.");
        }

        [Fact]
        public void MapHttpAttributeRoutes_AddsMultipleRoutesFromAttributes()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            var routePrefixes = new Collection<IRoutePrefix>();
            var routeProviders = new Collection<RouteAttribute>() { new RouteAttribute("controller/get1"), new RouteAttribute("controller/get2") };
            SetUpConfiguration(config, routePrefixes, routeProviders);

            // Act
            config.MapHttpAttributeRoutes();

            // Assert
            var routes = config.GetAttributeRoutes();
            Assert.Equal(2, routes.Count);
            Assert.Single(routes, route => route.RouteTemplate == "controller/get1");
            Assert.Single(routes, route => route.RouteTemplate == "controller/get2");
        }

        [Fact]
        public void MapHttpAttributeRoutes_IsDeferred()
        {
            bool called = false;
            HttpConfiguration config = new HttpConfiguration();

            config.Initializer = _ => called = true;
            config.Services.Clear(typeof(IHttpControllerSelector));
            config.Services.Clear(typeof(IHttpActionSelector));
            config.Services.Clear(typeof(IActionValueBinder));

            // Call Map, ensure that it's not touching any services yet since all work is deferred.
            // This is important since these services aren't ready to be used until after config is finalized.
            // Else we may end up caching objects prematurely.
            config.MapHttpAttributeRoutes();

            Assert.False(called);
        }

        [Fact]
        public void MapHttpAttributeRoutes_AddsLinkGenerationRoutes()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            var routePrefixes = new Collection<IRoutePrefix>() { };
            var routeProviders = new Collection<RouteAttribute>()
                {
                    new RouteAttribute("get1") { Name = "one" },
                    new RouteAttribute("get2") { Name = "two" },
                    new RouteAttribute("get3") { Name = "three" }
                };
            SetUpConfiguration(config, routePrefixes, routeProviders);

            // Act
            config.MapHttpAttributeRoutes();
            config.Initializer(config);

            // Assert
            HttpRouteCollection routes = config.Routes;
            Assert.Equal(4, routes.Count); // 1 attr route, plus 3 generation routes
            Assert.IsType<RouteCollectionRoute>(routes.ElementAt(0));
            for (int i = 1; i < 4; i++)
            {
                Assert.IsType<LinkGenerationRoute>(routes.ElementAt(i));
            }

            Assert.IsType<LinkGenerationRoute>(routes["one"]);
            Assert.IsType<LinkGenerationRoute>(routes["two"]);
            Assert.IsType<LinkGenerationRoute>(routes["three"]);
        }

        [Fact]
        public void MapHttpAttributeRoutes_RespectsPerControllerActionSelectors()
        {
            // Arrange
            var globalConfiguration = new HttpConfiguration();
            var controllerDescriptor = new HttpControllerDescriptor(globalConfiguration, "PerControllerActionSelector", typeof(PerControllerActionSelectorController));

            // Set up the global action selector and controller selector
            var controllerSelector = CreateControllerSelector(new[] { controllerDescriptor });
            globalConfiguration.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);

            var globalAction = CreateActionDescriptor(controllerDescriptor, "Global", new Collection<RouteAttribute>() { new RouteAttribute("Global") });
            var globalActionSelector = CreateActionSelector(
                new Dictionary<HttpControllerDescriptor, IEnumerable<HttpActionDescriptor>>()
                    {
                        { controllerDescriptor, new HttpActionDescriptor[] { globalAction } }
                    });
            globalConfiguration.Services.Replace(typeof(IHttpActionSelector), globalActionSelector);

            // Configure the per controller action selector to return the action with route "PerController"
            var perControllerAction = CreateActionDescriptor(
                controllerDescriptor,
                "PerController",
                new Collection<RouteAttribute>() { new RouteAttribute("PerController") });
            ActionSelectorConfigurationAttribute.PerControllerActionSelectorMock
                .Setup(a => a.GetActionMapping(controllerDescriptor))
                .Returns(new HttpActionDescriptor[] { perControllerAction }.ToLookup(ad => ad.ActionName));

            // Act
            globalConfiguration.MapHttpAttributeRoutes();

            // Assert
            var routes = globalConfiguration.GetAttributeRoutes();
            Assert.Equal("PerController", Assert.Single(routes).RouteTemplate);
        }

        [Fact]
        public void SuppressHostPrincipal_InsertsSuppressHostPrincipalMessageHandler()
        {
            // Arrange
            DelegatingHandler existingHandler = new Mock<DelegatingHandler>(MockBehavior.Strict).Object;

            using (HttpConfiguration configuration = new HttpConfiguration())
            {
                configuration.MessageHandlers.Add(existingHandler);

                // Act
                configuration.SuppressHostPrincipal();

                // Assert
                Assert.Equal(2, configuration.MessageHandlers.Count);
                DelegatingHandler firstHandler = configuration.MessageHandlers[0];
                Assert.IsType<SuppressHostPrincipalMessageHandler>(firstHandler);
            }
        }

        [Fact]
        public void SuppressHostPrincipal_Throws_WhenConfigurationIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(() => { HttpConfigurationExtensions.SuppressHostPrincipal(null); },
                "configuration");
        }

        private static void SetUpConfiguration(HttpConfiguration config, Collection<IRoutePrefix> routePrefixes, IEnumerable<RouteAttribute> routeAttributes)
        {
            HttpControllerDescriptor controllerDescriptor = CreateControllerDescriptor(config, "Controller", routePrefixes);
            HttpActionDescriptor actionDescriptor = CreateActionDescriptor(controllerDescriptor, "Action", routeAttributes);

            var controllerSelector = CreateControllerSelector(new[] { controllerDescriptor });
            config.Services.Replace(typeof(IHttpControllerSelector), controllerSelector);
            var actionSelector = CreateActionSelector(
                new Dictionary<HttpControllerDescriptor, IEnumerable<HttpActionDescriptor>>()
                {
                    { controllerDescriptor, new HttpActionDescriptor[] { actionDescriptor } }
                });
            config.Services.Replace(typeof(IHttpActionSelector), actionSelector);
        }

        private static HttpControllerDescriptor CreateControllerDescriptor(HttpConfiguration configuration, string controllerName,
            Collection<IRoutePrefix> routePrefixes)
        {
            Mock<HttpControllerDescriptor> controllerDescriptor = new Mock<HttpControllerDescriptor>();
            controllerDescriptor.Object.Configuration = configuration;
            controllerDescriptor.Object.ControllerName = controllerName;
            controllerDescriptor.Setup(cd => cd.GetCustomAttributes<IRoutePrefix>(false)).Returns(routePrefixes);
            controllerDescriptor.Setup(cd => cd.GetCustomAttributes<IHttpRouteInfoProvider>(false)).Returns(new Collection<IHttpRouteInfoProvider>());
            controllerDescriptor.Setup(cd => cd.GetCustomAttributes<IDirectRouteFactory>(false)).Returns(new Collection<IDirectRouteFactory>());
            return controllerDescriptor.Object;
        }

        private static HttpActionDescriptor CreateActionDescriptor(
            HttpControllerDescriptor controllerDescriptor,
            string actionName, IEnumerable<RouteAttribute>
            routeAttributes)
        {
            Collection<IDirectRouteFactory> newProviders = new Collection<IDirectRouteFactory>(new List<IDirectRouteFactory>(routeAttributes));
            Collection<IHttpRouteInfoProvider> oldProviders = new Collection<IHttpRouteInfoProvider>(new List<IHttpRouteInfoProvider>(routeAttributes));
            Mock<ReflectedHttpActionDescriptor> actionDescriptor = new Mock<ReflectedHttpActionDescriptor>();
            actionDescriptor.Setup(ad => ad.ActionName).Returns(actionName);
            actionDescriptor.Setup(ad => ad.GetCustomAttributes<IDirectRouteFactory>(false)).Returns(newProviders);
            actionDescriptor.Setup(ad => ad.GetCustomAttributes<IHttpRouteInfoProvider>(false)).Returns(oldProviders);
            actionDescriptor.Setup(ad => ad.SupportedHttpMethods).Returns(new Collection<HttpMethod>());
            actionDescriptor.CallBase = true;

            actionDescriptor.Object.ControllerDescriptor = controllerDescriptor;

            return actionDescriptor.Object;
        }

        private static IHttpControllerSelector CreateControllerSelector(IEnumerable<HttpControllerDescriptor> controllerDescriptors)
        {
            Mock<IHttpControllerSelector> controllerSelector = new Mock<IHttpControllerSelector>();
            controllerSelector.Setup(c => c.GetControllerMapping()).Returns(controllerDescriptors.ToDictionary(cd => cd.ControllerName));
            return controllerSelector.Object;
        }

        private static IHttpActionSelector CreateActionSelector(Dictionary<HttpControllerDescriptor, IEnumerable<HttpActionDescriptor>> actionMap)
        {
            Mock<IHttpActionSelector> actionSelector = new Mock<IHttpActionSelector>();
            foreach (var mapEntry in actionMap)
            {
                actionSelector.Setup(a => a.GetActionMapping(mapEntry.Key)).Returns(mapEntry.Value.ToLookup(ad => ad.ActionName));
            }
            return actionSelector.Object;
        }

        public class TestParameter
        {
        }

        [ActionSelectorConfiguration]
        public class PerControllerActionSelectorController : ApiController { }

        public class ActionSelectorConfigurationAttribute : Attribute, IControllerConfiguration
        {
            public static Mock<IHttpActionSelector> PerControllerActionSelectorMock = new Mock<IHttpActionSelector>();

            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
            {
                controllerSettings.Services.Replace(typeof(IHttpActionSelector), PerControllerActionSelectorMock.Object);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpErrorKeysTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class HttpErrorKeysTest
    {
        public static TheoryDataSet<Func<string>, string> ErrorKeys
        {
            get
            {
                return new TheoryDataSet<Func<string>, string>
                {
                    { () => HttpErrorKeys.MessageKey, "Message" },
                    { () => HttpErrorKeys.MessageDetailKey, "MessageDetail" },
                    { () => HttpErrorKeys.ModelStateKey, "ModelState" },
                    { () => HttpErrorKeys.ExceptionMessageKey, "ExceptionMessage" },
                    { () => HttpErrorKeys.ExceptionTypeKey, "ExceptionType" },
                    { () => HttpErrorKeys.StackTraceKey, "StackTrace" },
                    { () => HttpErrorKeys.InnerExceptionKey, "InnerException" },
                    { () => HttpErrorKeys.MessageLanguageKey, "MessageLanguage" },
                    { () => HttpErrorKeys.ErrorCodeKey, "ErrorCode" }
                };
            }
        }

        [Theory]
        [PropertyData("ErrorKeys")]
        public void HttpErrorKeyProperties_Returns_CorrectKeys(Func<string> productUnderTest, string expectedResult)
        {
            // Act
            string actualResult = productUnderTest.Invoke();

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpMessageHandlerExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace System.Web.Http
{
    public static class HttpMessageHandlerExtensions
    {
        public static Task<HttpResponseMessage> SendAsync(this HttpMessageHandler handler, HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            using (HttpMessageInvoker invoker = new HttpMessageInvoker(handler, disposeHandler: false))
            {
                return invoker.SendAsync(request, cancellationToken);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpRequestMessageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net.Http.Formatting;
using System.Net.Http.Formatting.Mocks;
using System.Net.Http.Headers;
using System.Security.Cryptography.X509Certificates;
using System.Threading;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class HttpRequestMessageExtensionsTest
    {
        [Fact]
        public void GetRequestContext_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => request.GetRequestContext(), "request");
        }

        [Fact]
        public void GetRequestContext_ReturnsProperty()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext expectedContext = CreateContext();
                request.Properties[HttpPropertyKeys.RequestContextKey] = expectedContext;

                // Act
                HttpRequestContext context = request.GetRequestContext();

                // Assert
                Assert.Same(expectedContext, context);
            }
        }

        [Fact]
        public void SetRequestContext_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;
            HttpRequestContext context = CreateContext();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { request.SetRequestContext(context); }, "request");
        }

        [Fact]
        public void SetRequestContext_Throws_WhenContextIsNull()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() => { request.SetRequestContext(context); }, "context");
            }
        }

        [Fact]
        public void SetRequestContext_AddsProperty()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext expectedContext = CreateContext();

                // Act
                request.SetRequestContext(expectedContext);

                // Assert
                Assert.Same(expectedContext, request.Properties[HttpPropertyKeys.RequestContextKey]);
            }
        }

        [Fact]
        public void GetConfigurationThrowsOnNull()
        {
            HttpRequestMessage request = null;
            Assert.ThrowsArgumentNull(() => request.GetConfiguration(), "request");
        }

        [Fact]
        public void GetConfiguration_ReturnsConfigurationFromContext_WhenOnlyContextIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                request.SetRequestContext(new HttpRequestContext
                {
                    Configuration = expectedConfiguration
                });

                // Act
                HttpConfiguration configuration = request.GetConfiguration();

                // Assert
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void GetConfiguration_ReturnsConfigurationFromProperty_WhenOnlyPropertyIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                request.Properties[HttpPropertyKeys.HttpConfigurationKey] = expectedConfiguration;

                // Act
                HttpConfiguration configuration = request.GetConfiguration();

                // Assert
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void GetConfiguration_ReturnsConfigurationFromContext_WhenBothContextAndPropertyArePresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            using (HttpConfiguration otherConfiguration = CreateConfiguration())
            {
                request.Properties[HttpPropertyKeys.HttpConfigurationKey] = otherConfiguration;
                request.SetRequestContext(new HttpRequestContext
                {
                    Configuration = expectedConfiguration
                });

                // Act
                HttpConfiguration configuration = request.GetConfiguration();

                // Assert
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void SetConfiguration_ThrowsArgumentNull_Request()
        {
            HttpRequestMessage request = null;

            Assert.ThrowsArgumentNull(
                () => request.SetConfiguration(CreateConfiguration()),
                "request");
        }

        [Fact]
        public void SetConfiguration_ThrowsArgumentNull_Configuration()
        {
            HttpRequestMessage request = CreateRequest();

            Assert.ThrowsArgumentNull(
                () => request.SetConfiguration(null),
                "configuration");
        }

        [Fact]
        public void SetConfiguration_AddsProperty()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                // Act
                request.SetConfiguration(expectedConfiguration);

                // Assert
                Assert.Same(expectedConfiguration, request.Properties[HttpPropertyKeys.HttpConfigurationKey]);
            }
        }

        [Fact]
        public void SetConfiguration_UpdatesContextAndAddsProperty_WhenContextIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                HttpRequestContext context = CreateContext();
                request.SetRequestContext(context);

                // Act
                request.SetConfiguration(expectedConfiguration);

                // Assert
                Assert.Same(expectedConfiguration, context.Configuration);
                Assert.Same(expectedConfiguration, request.Properties[HttpPropertyKeys.HttpConfigurationKey]);
            }
        }

        [Fact]
        public void GetSynchronizationContextThrowsOnNull()
        {
            HttpRequestMessage request = null;
            Assert.ThrowsArgumentNull(() => request.GetSynchronizationContext(), "request");
        }

        [Fact]
        public void GetSynchronizationContext()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            Mock<SynchronizationContext> syncContextMock = new Mock<SynchronizationContext>();
            SynchronizationContext beforeSyncContext = syncContextMock.Object;
            request.Properties.Add(HttpPropertyKeys.SynchronizationContextKey, beforeSyncContext);

            // Act
            SynchronizationContext afterSyncContext = request.GetSynchronizationContext();

            // Assert
            Assert.Same(beforeSyncContext, afterSyncContext);
        }

        [Fact]
        public void GetRouteData_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act
            Assert.ThrowsArgumentNull(() => request.GetRouteData(), "request");
        }

        [Fact]
        public void GetRouteData_ReturnsRouteDataFromContext_WhenOnlyContextIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                IHttpRouteData expectedRouteData = CreateDummyRouteData();
                request.SetRequestContext(new HttpRequestContext
                {
                    RouteData = expectedRouteData
                });

                // Act
                IHttpRouteData routeData = request.GetRouteData();

                // Assert
                Assert.Same(expectedRouteData, routeData);
            }
        }

        [Fact]
        public void GetRouteData_ReturnsRouteDataFromProperty_WhenOnlyPropertyIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                IHttpRouteData expectedRouteData = CreateDummyRouteData();
                request.Properties[HttpPropertyKeys.HttpRouteDataKey] = expectedRouteData;

                // Act
                IHttpRouteData routeData = request.GetRouteData();

                // Assert
                Assert.Same(expectedRouteData, routeData);
            }
        }

        [Fact]
        public void GetRouteData_ReturnsRouteDataFromContext_WhenBothContextAndPropertyArePresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                IHttpRouteData expectedRouteData = CreateDummyRouteData();
                request.SetRequestContext(new HttpRequestContext
                {
                    RouteData = expectedRouteData
                });
                IHttpRouteData otherRouteData = CreateDummyRouteData();
                request.Properties[HttpPropertyKeys.HttpRouteDataKey] = otherRouteData;

                // Act
                IHttpRouteData routeData = request.GetRouteData();

                // Assert
                Assert.Same(expectedRouteData, routeData);
            }
        }

        [Fact]
        public void SetRouteData_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;
            IHttpRouteData routeData = CreateDummyRouteData();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => request.SetRouteData(routeData), "request");
        }

        [Fact]
        public void SetRouteData_Throws_WhenRouteDataIsNull()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                IHttpRouteData routeData = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() => request.SetRouteData(routeData), "routeData");
            }
        }

        [Fact]
        public void SetRouteData_AddsProperty()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                IHttpRouteData expectedRouteData = CreateDummyRouteData();

                // Act
                request.SetRouteData(expectedRouteData);

                // Assert
                Assert.Same(expectedRouteData, request.Properties[HttpPropertyKeys.HttpRouteDataKey]);
            }
        }

        [Fact]
        public void SetRouteData_UpdatesContextAndAddsProperty_WhenContextIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateContext();
                request.SetRequestContext(context);
                IHttpRouteData expectedRouteData = CreateDummyRouteData();

                // Act
                request.SetRouteData(expectedRouteData);

                // Assert
                Assert.Same(expectedRouteData, context.RouteData);
                Assert.Same(expectedRouteData, request.Properties[HttpPropertyKeys.HttpRouteDataKey]);
            }
        }

        [Fact]
        public void GetUrlHelper_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => request.GetUrlHelper(), "request");
        }

        [Fact]
        public void GetUrlHelper_ReturnsUrlFromContext_WhenContextIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                UrlHelper expectedUrl = new Mock<UrlHelper>().Object;
                request.SetRequestContext(new HttpRequestContext
                {
                    Url = expectedUrl
                });

                // Act
                UrlHelper url = request.GetUrlHelper();

                // Assert
                Assert.Same(expectedUrl, url);
            }
        }

        [Fact]
        public void GetUrlHelper_ReturnsNewUrlHelperForRequest_WhenContextIsAbsent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                // Act
                UrlHelper urlHelper = request.GetUrlHelper();

                // Assert
                Assert.NotNull(urlHelper);
                Assert.Same(request, urlHelper.Request);
            }
        }

        [Fact]
        public void GetClientCertificate_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => request.GetClientCertificate(), "request");
        }

        [Fact]
        public void GetClientCertificate_ReturnsClientCertificateFromContext_WhenOnlyContextIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                X509Certificate2 expectedCertificate = CreateCertificate();
                request.SetRequestContext(new HttpRequestContext
                {
                    ClientCertificate = expectedCertificate
                });

                // Act
                X509Certificate2 certificate = request.GetClientCertificate();

                // Assert
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void GetClientCertificate_ReturnsClientCertificateFromProperty_WhenOnlyPropertyIsPresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                X509Certificate2 expectedCertificate = CreateCertificate();
                request.Properties[HttpPropertyKeys.ClientCertificateKey] = expectedCertificate;

                // Act
                X509Certificate2 certificate = request.GetClientCertificate();

                // Assert
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void GetClientCertificate_ReturnsClientCertificateFromContext_WhenBothContextAndPropertyArePresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                X509Certificate2 expectedCertificate = CreateCertificate();
                request.SetRequestContext(new HttpRequestContext
                {
                    ClientCertificate = expectedCertificate
                });
                X509Certificate2 otherCertificate = CreateCertificate();
                request.Properties[HttpPropertyKeys.ClientCertificateKey] = otherCertificate;

                // Act
                X509Certificate2 certificate = request.GetClientCertificate();

                // Assert
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void CreateResponse_OnNullRequest_ThrowsException()
        {
            HttpRequestMessage request = null;
            Assert.ThrowsArgumentNull(() =>
            {
                request.CreateResponse(CreateValue());
            }, "request");

            Assert.ThrowsArgumentNull(() =>
            {
                request.CreateResponse(HttpStatusCode.OK, CreateValue());
            }, "request");

            Assert.ThrowsArgumentNull(() =>
            {
                request.CreateResponse(HttpStatusCode.OK, CreateValue(), configuration: null);
            }, "request");
        }

        [Fact]
        public void CreateResponse_OnNullConfiguration_ThrowsException()
        {
            HttpRequestMessage request = CreateRequest();
            request.Properties[HttpPropertyKeys.HttpConfigurationKey] = null;

            Assert.Throws<InvalidOperationException>(() =>
            {
                request.CreateResponse(CreateValue());
            }, "The request does not have an associated configuration object or the provided configuration was null.");

            Assert.Throws<InvalidOperationException>(() =>
            {
                request.CreateResponse(HttpStatusCode.OK, CreateValue(), configuration: null);
            }, "The request does not have an associated configuration object or the provided configuration was null.");
        }

        [Fact]
        public void CreateResponse_DoingConneg_OnlyContent_RetrievesContentNegotiatorFromServiceResolver()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            HttpConfiguration config = CreateAndAddConfiguration(request);
            Mock<DefaultServices> servicesMock = new Mock<DefaultServices> { CallBase = true };
            servicesMock.Setup(s => s.GetService(typeof(IContentNegotiator)))
                        .Returns(new Mock<IContentNegotiator>().Object)
                        .Verifiable();
            config.Services = servicesMock.Object;

            // Act
            request.CreateResponse(CreateValue());

            // Assert
            servicesMock.Verify();
        }

        [Fact]
        public void CreateResponse_DoingConneg_RetrievesContentNegotiatorFromServiceResolver()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            HttpConfiguration config = CreateAndAddConfiguration(request);
            Mock<DefaultServices> servicesMock = new Mock<DefaultServices> { CallBase = true };
            servicesMock.Setup(s => s.GetService(typeof(IContentNegotiator)))
                        .Returns(new Mock<IContentNegotiator>().Object)
                        .Verifiable();
            config.Services = servicesMock.Object;

            // Act
            request.CreateResponse(HttpStatusCode.OK, CreateValue(), config);

            // Assert
            servicesMock.Verify();
        }

        [Fact]
        public void CreateResponse_DoingConneg_WhenNoContentNegotiatorInstanceRegistered_Throws()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            HttpConfiguration config = CreateAndAddConfiguration(request);
            config.Services.Clear(typeof(IContentNegotiator));

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => request.CreateResponse(CreateValue()),
                "The provided configuration does not have an instance of the 'System.Net.Http.Formatting.IContentNegotiator' service registered.");

            Assert.Throws<InvalidOperationException>(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), config),
                "The provided configuration does not have an instance of the 'System.Net.Http.Formatting.IContentNegotiator' service registered.");
        }

        [Fact]
        public void CreateResponse_DoingConneg_WhenContentNegotiatorReturnsNullResult_Throws()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            HttpConfiguration config = CreateAndAddConfiguration(request);
            Mock<IContentNegotiator> negotiatorMock = new Mock<IContentNegotiator>();
            negotiatorMock.Setup(r => r.Negotiate(typeof(string), request, config.Formatters)).Returns(value: null);
            config.Services.Replace(typeof(IContentNegotiator), negotiatorMock.Object);

            // Act
            var response = request.CreateResponse<string>(HttpStatusCode.OK, "", config);

            // Assert
            Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
            Assert.Same(request, response.RequestMessage);
        }

        [Fact]
        public void CreateResponse_DoingConneg_PerformsContentNegotiationAndCreatesContentUsingResults()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            HttpConfiguration config = CreateAndAddConfiguration(request);
            XmlMediaTypeFormatter formatter = new XmlMediaTypeFormatter();
            Mock<IContentNegotiator> negotiatorMock = new Mock<IContentNegotiator>();
            negotiatorMock.Setup(r => r.Negotiate(typeof(string), request, config.Formatters))
                        .Returns(new ContentNegotiationResult(formatter, null));
            config.Services.Replace(typeof(IContentNegotiator), negotiatorMock.Object);

            // Act
            var response = request.CreateResponse<string>(HttpStatusCode.NoContent, "42", config);

            // Assert
            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
            Assert.Same(request, response.RequestMessage);
            var objectContent = Assert.IsType<ObjectContent<string>>(response.Content);
            Assert.Equal("42", objectContent.Value);
            Assert.Same(formatter, objectContent.Formatter);
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_WhenRequestIsNull_Throws()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act
            Assert.ThrowsArgumentNull(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), "foo/bar"), "request");
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_WhenMediaTypeHeaderIsNull_Throws()
        {
            HttpRequestMessage request = CreateRequest();

            Assert.ThrowsArgumentNull(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), (MediaTypeHeaderValue)null), "mediaType");
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_WhenMediaTypeStringIsNull_Throws()
        {
            HttpRequestMessage request = CreateRequest();

            Assert.ThrowsArgument(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), (string)null), "mediaType");
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_WhenMediaTypeStringIsEmpty_Throws()
        {
            HttpRequestMessage request = CreateRequest();

            Assert.ThrowsArgumentNull(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), (MediaTypeHeaderValue)null), "mediaType");
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_WhenMediaTypeStringIsInvalidFormat_Throws()
        {
            HttpRequestMessage request = CreateRequest();

            Assert.Throws<FormatException>(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), "foo/bar; param=value"), "The format of value 'foo/bar; param=value' is invalid.");
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_WhenRequestDoesNotHaveConfiguration_Throws()
        {
            HttpRequestMessage request = CreateRequest();

            // Arrange
            request.Properties[HttpPropertyKeys.HttpConfigurationKey] = null;

            // Act
            Assert.Throws<InvalidOperationException>(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), mediaType: "foo/bar"),
                "The request does not have an associated configuration object or the provided configuration was null.");
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_WhenMediaTypeDoesNotMatch_Throws()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            request.SetConfiguration(new HttpConfiguration());

            // Act
            Assert.Throws<InvalidOperationException>(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), mediaType: "foo/bar"),
                "Could not find a formatter matching the media type 'foo/bar' that can write an instance of 'Object'.");
        }

        [Fact]
        public void CreateResponse_MatchingMediaType_FindsMatchingFormatterAndCreatesResponse()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            var config = new HttpConfiguration();
            request.SetConfiguration(config);
            config.Formatters.Clear();
            Mock<MediaTypeFormatter> formatterMock = new Mock<MediaTypeFormatter> { CallBase = true };
            var formatter = formatterMock.Object;
            formatterMock.Setup(f => f.CanWriteType(typeof(object))).Returns(true).Verifiable();
            formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("foo/bar"));
            config.Formatters.Add(formatter);
            object expectedValue = CreateValue();

            // Act
            var response = request.CreateResponse(HttpStatusCode.Gone, expectedValue, mediaType: "foo/bar");

            // Assert
            Assert.Equal(HttpStatusCode.Gone, response.StatusCode);
            var content = Assert.IsType<ObjectContent<object>>(response.Content);
            Assert.Same(expectedValue, content.Value);
            Assert.Same(formatter, content.Formatter);
            Assert.Equal("foo/bar", content.Headers.ContentType.MediaType);
            formatterMock.Verify();
        }

        [Fact]
        public void CreateResponse_AcceptingFormatter_WhenRequestIsNull_Throws()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act
            Assert.ThrowsArgumentNull(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), new MockMediaTypeFormatter()), "request");
        }

        [Fact]
        public void CreateResponse_AcceptingFormatter_WhenFormatterIsNull_Throws()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();

            // Act
            Assert.ThrowsArgumentNull(() => request.CreateResponse(HttpStatusCode.OK, CreateValue(), formatter: null), "formatter");
        }

        [Fact]
        public void CreateResponse_AcceptingFormatter_CreatesResponseWithDefaultMediaType()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            var formatter = new MockMediaTypeFormatter { CallBase = true };
            formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("foo/bar"));
            object expectedValue = CreateValue();

            // Act
            var response = request.CreateResponse(HttpStatusCode.MultipleChoices, expectedValue, formatter, mediaType: (string)null);

            // Assert
            Assert.Equal(HttpStatusCode.MultipleChoices, response.StatusCode);
            var content = Assert.IsType<ObjectContent<object>>(response.Content);
            Assert.Same(expectedValue, content.Value);
            Assert.Same(formatter, content.Formatter);
            Assert.Equal("foo/bar", content.Headers.ContentType.MediaType);
        }

        [Fact]
        public void CreateResponse_AcceptingFormatter_WithOverridenMediaTypeString_CreatesResponse()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            var formatter = new MockMediaTypeFormatter { CallBase = true };
            formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("foo/bar"));

            // Act
            var response = request.CreateResponse(HttpStatusCode.MultipleChoices, CreateValue(), formatter, mediaType: "bin/baz");

            // Assert
            Assert.Equal("bin/baz", response.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public void CreateResponse_AcceptingFormatter_WithOverridenMediaTypeHeader_CreatesResponse()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            var formatter = new MockMediaTypeFormatter { CallBase = true };
            formatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("foo/bar"));

            // Act
            var response = request.CreateResponse(HttpStatusCode.MultipleChoices, CreateValue(), formatter, mediaType: new MediaTypeHeaderValue("bin/baz"));

            // Assert
            Assert.Equal("bin/baz", response.Content.Headers.ContentType.MediaType);
        }

        [Fact]
        public void RegisterForDispose_WhenRequestParameterIsNull_Throws()
        {
            HttpRequestMessage request = null;
            Assert.ThrowsArgumentNull(() => request.RegisterForDispose(resource: null), "request");
        }

        [Fact]
        public void RegisterForDispose_WhenResourceParamterIsNull_DoesNothing()
        {
            HttpRequestMessage request = CreateRequest();
            request.RegisterForDispose(resource: null);

            Assert.False(request.Properties.ContainsKey(HttpPropertyKeys.DisposableRequestResourcesKey));
        }

        [Fact]
        public void RegisterForDispose_WhenResourceListDoesNotExist_CreatesListAndAddsResource()
        {
            HttpRequestMessage request = CreateRequest();
            request.Properties.Remove(HttpPropertyKeys.DisposableRequestResourcesKey);
            IDisposable disposable = CreateStubDisposable();

            request.RegisterForDispose(disposable);

            var list = Assert.IsType<List<IDisposable>>(request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey]);
            IDisposable item = Assert.Single(list);
            Assert.Same(disposable, item);
        }

        [Fact]
        public void RegisterForDispose_WhenResourceListExists_AddsResource()
        {
            HttpRequestMessage request = CreateRequest();
            var list = new List<IDisposable>();
            request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey] = list;
            IDisposable disposable = CreateStubDisposable();

            request.RegisterForDispose(disposable);

            Assert.Same(list, request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey]);
            IDisposable item = Assert.Single(list);
            Assert.Same(disposable, item);
        }

        [Fact]
        public void DisposeRequestResources_WhenRequestParameterIsNull_Throws()
        {
            HttpRequestMessage request = null;
            Assert.ThrowsArgumentNull(() => request.DisposeRequestResources(), "request");
        }

        [Fact]
        public void DisposeRequestResources_WhenResourceListDoesNotExists_DoesNothing()
        {
            HttpRequestMessage request = CreateRequest();
            request.Properties.Remove(HttpPropertyKeys.DisposableRequestResourcesKey);

            request.DisposeRequestResources();

            Assert.False(request.Properties.ContainsKey(HttpPropertyKeys.DisposableRequestResourcesKey));
        }

        [Fact]
        public void DisposeRequestResources_WhenResourceListExists_DisposesResourceAndClearsReferences()
        {
            HttpRequestMessage request = CreateRequest();
            Mock<IDisposable> disposableMock = new Mock<IDisposable>();
            IDisposable disposable = disposableMock.Object;
            var list = new List<IDisposable> { disposable };
            request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey] = list;

            request.DisposeRequestResources();

            disposableMock.Verify(d => d.Dispose());
            Assert.Empty(list);
        }

        [Fact]
        public void DisposeRequestResources_WhenResourcesDisposeMethodThrowsException_IgnoresExceptionsAndContinuesDisposingOtherResources()
        {
            HttpRequestMessage request = CreateRequest();
            Mock<IDisposable> throwingDisposableMock = new Mock<IDisposable>();
            throwingDisposableMock.Setup(d => d.Dispose()).Throws(new Exception());
            Mock<IDisposable> disposableMock = new Mock<IDisposable>();
            IDisposable disposable = disposableMock.Object;
            var list = new List<IDisposable> { throwingDisposableMock.Object, disposable };
            request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey] = list;

            request.DisposeRequestResources();

            throwingDisposableMock.Verify(d => d.Dispose());
            disposableMock.Verify(d => d.Dispose());
            Assert.Empty(list);
        }

        [Fact]
        public void CreateErrorResponseRangeNotSatisfiable_ThrowsOnNullException()
        {
            HttpRequestMessage request = CreateRequest();
            Assert.ThrowsArgumentNull(() => request.CreateErrorResponse(invalidByteRangeException: null), "invalidByteRangeException");
        }

        [Fact]
        public void CreateErrorResponseRangeNotSatisfiable_SetsCorrectStatusCodeAndContentRangeHeader()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            ContentRangeHeaderValue expectedContentRange = new ContentRangeHeaderValue(length: 128);
            InvalidByteRangeException invalidByteRangeException = new InvalidByteRangeException(expectedContentRange);

            // Act
            HttpResponseMessage response = request.CreateErrorResponse(invalidByteRangeException);

            // Assert
            Assert.Equal(HttpStatusCode.RequestedRangeNotSatisfiable, response.StatusCode);
            Assert.Same(expectedContentRange, response.Content.Headers.ContentRange);
        }

        [Fact]
        public void IsLocal_When_Request_From_Local_Address()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy<bool>(() => true));

            // Act
            bool isLocal = request.IsLocal();

            // Assert
            Assert.True(isLocal);
        }

        [Fact]
        public void IsLocal_When_Request_Not_From_Local_Address()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy<bool>(() => false));

            // Act
            bool isLocal = request.IsLocal();

            // Assert
            Assert.False(isLocal);
        }

        [Fact]
        public void IsLocal_With_Property_Value_Null_Returns_False()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            request.Properties.Add(HttpPropertyKeys.IsLocalKey, null);

            // Act
            bool isLocal = request.IsLocal();

            // Assert
            Assert.False(isLocal);
        }

        [Fact]
        public void IsLocal_With_Property_Value_String_Returns_False()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            request.Properties.Add(HttpPropertyKeys.IsLocalKey, "Test String");

            // Act
            bool isLocal = request.IsLocal();

            // Assert
            Assert.False(isLocal);
        }

        [Fact]
        public void IsLocal_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => request.IsLocal(), "request");
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocal_ReturnsValueFromContext_WhenOnlyContextIsPresent(bool expectedIsLocal)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                request.SetRequestContext(new HttpRequestContext
                {
                    IsLocal = expectedIsLocal
                });

                // Act
                bool isLocal = request.IsLocal();

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocal_ReturnsValueFromProperty_WhenOnlyPropertyIsPresent(bool expectedIsLocal)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                request.Properties[HttpPropertyKeys.IsLocalKey] = new Lazy<bool>(() => expectedIsLocal);

                // Act
                bool isLocal = request.IsLocal();

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocal_ReturnsValueFromContext_WhenBothContextAndPropertyArePresent(bool expectedIsLocal)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                request.SetRequestContext(new HttpRequestContext
                {
                    IsLocal = expectedIsLocal
                });
                request.Properties[HttpPropertyKeys.IsLocalKey] = new Lazy<bool>(() => !expectedIsLocal);

                // Act
                bool isLocal = request.IsLocal();

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Fact]
        public void IsLocal_ReturnsFalse_WhenNeitherContextNorPropertyArePresent()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                // Act
                bool isLocal = request.IsLocal();

                // Assert
                Assert.False(isLocal);
            }
        }

        [Fact]
        public void ShouldIncludeErrorDetail_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => request.ShouldIncludeErrorDetail(), "request");
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void ShouldIncludeErrorDetail_ReturnsValueFromContext_WhenOnlyContextIsPresent(bool expected)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                request.SetRequestContext(new HttpRequestContext
                {
                    IncludeErrorDetail = expected
                });

                // Act
                bool actual = request.ShouldIncludeErrorDetail();

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void ShouldIncludeErrorDetail_ReturnsValueFromProperty_WhenOnlyPropertyIsPresent(bool expected)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                request.Properties[HttpPropertyKeys.IncludeErrorDetailKey] = new Lazy<bool>(() => expected);

                // Act
                bool actual = request.ShouldIncludeErrorDetail();

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void ShouldIncludeErrorDetail_ReturnsValueFromContext_WhenBothArePresent(bool expected)
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                request.SetRequestContext(new HttpRequestContext
                {
                    IncludeErrorDetail = expected
                });
                request.Properties[HttpPropertyKeys.IncludeErrorDetailKey] = new Lazy<bool>(() => !expected);

                // Act
                bool actual = request.ShouldIncludeErrorDetail();

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        [Theory]
        [InlineData(IncludeErrorDetailPolicy.Default, null, null, false)]
        [InlineData(IncludeErrorDetailPolicy.Default, null, true, true)]
        [InlineData(IncludeErrorDetailPolicy.Default, null, false, false)]
        [InlineData(IncludeErrorDetailPolicy.Default, true, null, false)]
        [InlineData(IncludeErrorDetailPolicy.Default, true, true, true)]
        [InlineData(IncludeErrorDetailPolicy.Default, true, false, false)]
        [InlineData(IncludeErrorDetailPolicy.Default, false, null, false)]
        [InlineData(IncludeErrorDetailPolicy.Default, false, true, true)]
        [InlineData(IncludeErrorDetailPolicy.Default, false, false, false)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, null, null, false)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, null, true, false)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, null, false, false)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, true, null, true)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, true, true, true)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, true, false, true)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, false, null, false)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, false, true, false)]
        [InlineData(IncludeErrorDetailPolicy.LocalOnly, false, false, false)]
        [InlineData(IncludeErrorDetailPolicy.Always, null, null, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, null, true, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, null, false, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, true, null, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, true, true, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, true, false, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, false, null, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, false, true, true)]
        [InlineData(IncludeErrorDetailPolicy.Always, false, false, true)]
        [InlineData(IncludeErrorDetailPolicy.Never, null, null, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, null, true, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, null, false, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, true, null, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, true, true, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, true, false, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, false, null, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, false, true, false)]
        [InlineData(IncludeErrorDetailPolicy.Never, false, false, false)]
        [InlineData(null, false, false, false)]
        public void ShouldIncludeErrorDetail_WhenContextIsAbsent(IncludeErrorDetailPolicy errorDetail, bool isLocal, bool includeErrorDetail, bool expectedResult)
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            HttpConfiguration config = CreateAndAddConfiguration(request);
            config.IncludeErrorDetailPolicy = errorDetail;
            request.Properties.Add(HttpPropertyKeys.IsLocalKey, new Lazy<bool>(() => isLocal));
            request.Properties.Add(HttpPropertyKeys.IncludeErrorDetailKey, new Lazy<bool>(() => includeErrorDetail));

            // Act
            bool includeError = request.ShouldIncludeErrorDetail();

            // Assert
            Assert.Equal(includeError, expectedResult);
        }

        [Fact]
        public void ShouldIncludeErrorDetail_Returns_False_WhenConfigIsNull_includeErrorDetail_Null()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();

            // Act
            bool includeError = request.ShouldIncludeErrorDetail();

            // Assert
            Assert.False(includeError);
        }

        [Fact]
        public void ShouldIncludeErrorDetail_Returns_Value_WhenConfigIsNull_includeErrorDetail_HasValue()
        {
            // Arrange
            HttpRequestMessage request = CreateRequest();
            request.Properties.Add(HttpPropertyKeys.IncludeErrorDetailKey, new Lazy<bool>(() => true));

            // Act
            bool includeError = request.ShouldIncludeErrorDetail();

            // Assert
            Assert.True(includeError);
        }

        [Fact]
        public void GetCorrelationId_ReturnsTraceCorrelationManagerId_IfSet()
        {
            Guid traceId = Guid.NewGuid();
            using (var scope = new TraceIdScope(traceId))
            {
                Assert.Equal(traceId, CreateRequest().GetCorrelationId());
            }
        }

        [Fact]
        public void GetCorrelationId_ReturnsNewGuid_IfTraceCorrelationManagerIdNotSet()
        {
            Guid traceId = Guid.Empty;
            using (var scope = new TraceIdScope(traceId))
            {
                Assert.NotEqual(traceId, CreateRequest().GetCorrelationId());
            }
        }

        [Fact]
        public void GetQueryNameValuePairs_ParsesQueryString()
        {
            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=cool");

            // Act
            var actual = request.GetQueryNameValuePairs();

            // Assert
            Assert.IsType<KeyValuePair<string, string>[]>(actual); // We call ToArray to ensure that we're not caching an iterator block.

            Assert.Single(actual, kvp => kvp.Key == "x" && kvp.Value == "7");
            Assert.Single(actual, kvp => kvp.Key == "y" && kvp.Value == "cool");
        }

        [Fact]
        public void GetQueryNameValuePairs_StoresResult()
        {
            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=cool");

            // Act
            var returned = request.GetQueryNameValuePairs();

            // Assert
            IEnumerable<KeyValuePair<string, string>> cached;
            Assert.True(request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out cached));

            Assert.Same(returned, cached);
            Assert.Same(returned, request.GetQueryNameValuePairs());
        }

        [Fact]
        public void GetQueryNameValuePairs_ReplacesResultWhenUriChanges()
        {
            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=cool");
            request.GetQueryNameValuePairs();

            // Act
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=verycool");
            var returned = request.GetQueryNameValuePairs();

            // Assert
            IEnumerable<KeyValuePair<string, string>> cached;
            string queryString;

            Assert.True(request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out cached));
            Assert.True(request.Properties.TryGetValue<string>(HttpPropertyKeys.CachedRequestQueryKey, out queryString));

            Assert.Same(returned, cached);
            Assert.Same(returned, request.GetQueryNameValuePairs());
            Assert.Same(request.RequestUri.Query, queryString);
        }

        [InlineData("http://localhost/api/Person/10?", "http://localhost/api/Person/10?x=7&y=verycool")]
        [InlineData("http://localhost/api/Person/10", "http://localhost/api/Person/10?x=7&y=verycool")]
        [Theory]
        public void GetQueryNameValuePairs_ReplacesResultWhenUriChangesFromEmpty(string firstUri, string secondUri)
        {
            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri(firstUri);
            request.GetQueryNameValuePairs();

            // Act
            request.RequestUri = new Uri(secondUri);
            var returned = request.GetQueryNameValuePairs();

            // Assert
            IEnumerable<KeyValuePair<string, string>> cached;
            string queryString;

            Assert.True(request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out cached));
            Assert.True(request.Properties.TryGetValue<string>(HttpPropertyKeys.CachedRequestQueryKey, out queryString));

            Assert.Same(returned, cached);
            Assert.Same(returned, request.GetQueryNameValuePairs());
            Assert.Same(request.RequestUri.Query, queryString);
        }

        [InlineData("http://localhost/api/Person/10?x=7&y=verycool", "http://localhost/api/Person/10?")]
        [InlineData("http://localhost/api/Person/10?x=7&y=verycool", "http://localhost/api/Person/10")]
        [Theory]
        public void GetQueryNameValuePairs_ReplacesResultWhenUriChangesToEmpty(string firstUri, string secondUri)
        {
            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri(firstUri);
            IEnumerable<KeyValuePair<string, string>> original = request.GetQueryNameValuePairs();

            // Act
            request.RequestUri = new Uri(secondUri);
            var returned = request.GetQueryNameValuePairs();

            // Assert
            IEnumerable<KeyValuePair<string, string>> cached;
            string queryString;

            // Cache is not cleared when the query is empty, but it is when the query is ?.
            Assert.True(request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out cached));
            Assert.True(request.Properties.TryGetValue<string>(HttpPropertyKeys.CachedRequestQueryKey, out queryString));

            if (request.RequestUri.Query == "?")
            {
                Assert.Same(returned, cached);
                Assert.Same(request.RequestUri.Query, queryString);
                Assert.Equal(returned, Enumerable.Empty<KeyValuePair<string, string>>());
            }
            else
            {
                Assert.Same(original, cached);
                Assert.NotSame(returned, cached);
                Assert.NotSame(request.RequestUri.Query, queryString);
                Assert.Same(returned, Enumerable.Empty<KeyValuePair<string, string>>());
            }

            Assert.Same(returned, request.GetQueryNameValuePairs());
        }

        [Fact]
        public void GetQueryNameValuePairs_ReplacesResultWhenUriChanges_AndUserRemovedCache()
        {
            // This test verifies that users following the existing workaround for the issue
            // https://aspnetwebstack.codeplex.com/workitem/2200 are not broken.

            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=cool");
            request.GetQueryNameValuePairs();
            request.Properties.Remove(HttpPropertyKeys.RequestQueryNameValuePairsKey);

            Assert.False(request.Properties.ContainsKey(HttpPropertyKeys.RequestQueryNameValuePairsKey));

            // Act
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=verycool");
            var returned = request.GetQueryNameValuePairs();

            // Assert
            IEnumerable<KeyValuePair<string, string>> cached;
            string queryString;

            Assert.True(request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out cached));
            Assert.True(request.Properties.TryGetValue<string>(HttpPropertyKeys.CachedRequestQueryKey, out queryString));

            Assert.Same(returned, cached);
            Assert.Same(returned, request.GetQueryNameValuePairs());
            Assert.Same(request.RequestUri.Query, queryString);
        }

        [Fact]
        public void GetQueryNameValuePairs_ReplacesResultWhenUriChangesToEmpty_AndUserRemovedCache()
        {
            // This test verifies that users following the existing workaround for the issue
            // https://aspnetwebstack.codeplex.com/workitem/2200 are not broken.

            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=cool");
            request.GetQueryNameValuePairs();
            request.Properties.Remove(HttpPropertyKeys.RequestQueryNameValuePairsKey);

            Assert.False(request.Properties.ContainsKey(HttpPropertyKeys.RequestQueryNameValuePairsKey));

            // Act
            request.RequestUri = new Uri("http://localhost/api/Person/10");
            var returned = request.GetQueryNameValuePairs();

            // Assert
            IEnumerable<KeyValuePair<string, string>> cached;
            string queryString;

            Assert.False(request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out cached));
            Assert.True(request.Properties.TryGetValue<string>(HttpPropertyKeys.CachedRequestQueryKey, out queryString)); // this will not get cleared.

            Assert.Same(returned, Enumerable.Empty<KeyValuePair<string, string>>());
            Assert.Same(returned, request.GetQueryNameValuePairs());
            Assert.NotSame(request.RequestUri.Query, queryString);
        }

        [Fact]
        public void GetQueryNameValuePairs_ReplacesResultWhenUriChangesFromEmpty_AndUserRemovedCache()
        {
            // This test verifies that users following the existing workaround for the issue
            // https://aspnetwebstack.codeplex.com/workitem/2200 are not broken.

            // Arrange
            var request = CreateRequest();
            request.RequestUri = new Uri("http://localhost/api/Person/10");
            request.GetQueryNameValuePairs();
            request.Properties.Remove(HttpPropertyKeys.RequestQueryNameValuePairsKey);

            Assert.False(request.Properties.ContainsKey(HttpPropertyKeys.RequestQueryNameValuePairsKey));

            // Act
            request.RequestUri = new Uri("http://localhost/api/Person/10?x=7&y=verycool");
            var returned = request.GetQueryNameValuePairs();

            // Assert
            IEnumerable<KeyValuePair<string, string>> cached;
            string queryString;

            Assert.True(request.Properties.TryGetValue<IEnumerable<KeyValuePair<string, string>>>(HttpPropertyKeys.RequestQueryNameValuePairsKey, out cached));
            Assert.True(request.Properties.TryGetValue<string>(HttpPropertyKeys.CachedRequestQueryKey, out queryString));

            Assert.Same(returned, cached);
            Assert.Same(returned, request.GetQueryNameValuePairs());
            Assert.Same(request.RequestUri.Query, queryString);
        }

        private class TraceIdScope : IDisposable
        {
            Guid _oldValue;

            public TraceIdScope(Guid traceId)
            {
                _oldValue = Trace.CorrelationManager.ActivityId;
                Trace.CorrelationManager.ActivityId = traceId;
            }

            public void Dispose()
            {
                Trace.CorrelationManager.ActivityId = _oldValue;
            }
        }

        private static HttpConfiguration CreateAndAddConfiguration(HttpRequestMessage request)
        {
            HttpConfiguration configuration = CreateConfiguration();
            request.SetConfiguration(configuration);
            return configuration;
        }

        private static X509Certificate2 CreateCertificate()
        {
            return new X509Certificate2();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static HttpRequestContext CreateContext()
        {
            return new HttpRequestContext();
        }

        private static IHttpRouteData CreateDummyRouteData()
        {
            return new Mock<IHttpRouteData>(MockBehavior.Strict).Object;
        }

        private static IDisposable CreateStubDisposable()
        {
            return new Mock<IDisposable>().Object;
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static object CreateValue()
        {
            return new object();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpResponseExceptionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class HttpResponseExceptionTest
    {
        [Fact]
        public void Constructor_WhenResponseParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => new HttpResponseException(response: null), "response");
        }

        [Fact]
        [ReplaceCulture]
        public void Constructor_SetsResponseProperty()
        {
            // Arrange and Act
            var response = new HttpResponseMessage();
            var exception = new HttpResponseException(response);

            // Assert
            Assert.Same(response, exception.Response);
            Assert.Equal("Processing of the HTTP request resulted in an exception. Please see the HTTP response returned by the 'Response' property of this exception for details.", exception.Message);
        }

        [Fact]
        [ReplaceCulture]
        public void Constructor_SetsResponsePropertyWithGivenStatusCode()
        {
            // Arrange and Act
            var exception = new HttpResponseException(HttpStatusCode.BadGateway);

            // Assert
            Assert.Equal(HttpStatusCode.BadGateway, exception.Response.StatusCode);
            Assert.Equal("Processing of the HTTP request resulted in an exception. Please see the HTTP response returned by the 'Response' property of this exception for details.", exception.Message);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpResponseMessageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http.Formatting;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http
{
    public class HttpResponseMessageExtensionsTest
    {
        private readonly HttpResponseMessage _response = new HttpResponseMessage();
        private readonly Mock<MediaTypeFormatter> _formatterMock = new Mock<MediaTypeFormatter>();

        public HttpResponseMessageExtensionsTest()
        {
            _formatterMock.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true);
        }

        [Fact]
        public void TryGetContentValue_WhenResponseParameterIsNull_Throws()
        {
            object value;
            Assert.ThrowsArgumentNull(() => HttpResponseMessageExtensions.TryGetContentValue<object>(null, out value), "response");
        }

        [Theory]
        [InlineData(default(bool))]
        [InlineData(default(int))]
        [InlineData(default(object))]
        public void TryGetContentValue_WhenResponseHasNoContent_ReturnsFalse<T>(T expectedResult)
        {
            T value;

            Assert.False(_response.TryGetContentValue<T>(out value));

            Assert.Equal(expectedResult, value);
        }


        [Theory]
        [InlineData(default(bool))]
        [InlineData(default(int))]
        [InlineData(default(object))]
        public void TryGetContentValue_WhenResponseHasNonObjectContent_ReturnsFalse<T>(T expectedResult)
        {
            _response.Content = new StringContent("43");
            T value;

            Assert.False(_response.TryGetContentValue<T>(out value));

            Assert.Equal(expectedResult, value);
        }

        [Theory]
        [InlineData(default(bool))]
        [InlineData(default(int))]
        [InlineData(default(object))]
        public void TryGetContentValue_WhenResponseHasObjectContentWithNullValue_ReturnsFalse<T>(T expectedResult)
        {
            _response.Content = new ObjectContent(typeof(object), null, _formatterMock.Object);
            T value;

            Assert.False(_response.TryGetContentValue<T>(out value));

            Assert.Equal(expectedResult, value);
        }

        [Theory]
        [InlineData(default(bool))]
        [InlineData(default(int))]
        public void TryGetContentValue_WhenResponseHasObjectContentWithIncompatibleValue_ReturnsFalse<T>(T expectedResult)
        {
            _response.Content = new ObjectContent<string>("42", _formatterMock.Object);
            T value;

            Assert.False(_response.TryGetContentValue<T>(out value));

            Assert.Equal(expectedResult, value);
        }

        [Fact]
        public void TryGetContentValue_WhenResponseHasObjectContentWithCompatibleValue_ReturnsTrue()
        {
            List<string> value = new List<string>();
            _response.Content = new ObjectContent<List<string>>(value, _formatterMock.Object);
            IList<string> result;

            Assert.True(_response.TryGetContentValue(out result));

            Assert.Same(value, result);
        }

        [Fact]
        public void TryGetContentValue_WhenResponseHasObjectContentValueTypeValue_RetrievingAsObjectReturnsTrue()
        {
            _response.Content = new ObjectContent<int>(32, _formatterMock.Object);
            object result;

            Assert.True(_response.TryGetContentValue(out result));

            Assert.Equal(32, result);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpRouteCollectionExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Web.Http.Batch;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpRouteCollectionExtensionsTest
    {
        [Fact]
        public void IsCorrectType()
        {
            Assert.Type.HasProperties(typeof(HttpRouteCollectionExtensions), TypeAssert.TypeProperties.IsStatic | TypeAssert.TypeProperties.IsPublicVisibleClass);
        }

        [Fact]
        public void MapHttpRoute1ThrowsOnNullRouteCollection()
        {
            Assert.ThrowsArgumentNull(() => HttpRouteCollectionExtensions.MapHttpRoute(null, "", "", null), "routes");
        }

        [Fact]
        public void MapHttpRoute1CreatesRoute()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();
            object defaults = new { d1 = "D1" };

            // Act
            IHttpRoute route = routes.MapHttpRoute("name", "template", defaults);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.RouteTemplate);
            Assert.Equal(1, route.Defaults.Count);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Same(route, routes["name"]);
        }

        [Fact]
        public void MapHttpRoute1WithDefaultsAsDictionaryCreatesRoute()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();
            object defaults = new Dictionary<string, object> { { "d1", "D1" } };

            // Act
            IHttpRoute route = routes.MapHttpRoute("name", "template", defaults);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.RouteTemplate);
            Assert.Equal(1, route.Defaults.Count);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Same(route, routes["name"]);
        }

        [Fact]
        public void MapHttpRoute2ThrowsOnNullRouteCollection()
        {
            Assert.ThrowsArgumentNull(() => HttpRouteCollectionExtensions.MapHttpRoute(null, "", "", null, null), "routes");
        }

        [Fact]
        public void MapHttpRoute2CreatesRoute()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();
            object defaults = new { d1 = "D1" };
            object constraints = new { c1 = "C1" };

            // Act
            IHttpRoute route = routes.MapHttpRoute("name", "template", defaults, constraints);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.RouteTemplate);
            Assert.Equal(1, route.Defaults.Count);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Equal(1, route.Defaults.Count);
            Assert.Equal("C1", route.Constraints["c1"]);
            Assert.Same(route, routes["name"]);
        }

        [Fact]
        public void MapHttpRoute2WithDefaultsAndConstraintsAsDictionaryCreatesRoute()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();
            object defaults = new Dictionary<string, object> { { "d1", "D1" } };
            object constraints = new Dictionary<string, object> { { "c1", "C1" } };

            // Act
            IHttpRoute route = routes.MapHttpRoute("name", "template", defaults, constraints);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.RouteTemplate);
            Assert.Equal(1, route.Defaults.Count);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Equal(1, route.Defaults.Count);
            Assert.Equal("C1", route.Constraints["c1"]);
            Assert.Same(route, routes["name"]);
        }

        [Fact]
        public void MapHttpBatchRoute_CreatesRoutesUsingCustomBatchHandler()
        {
            HttpRouteCollection routes = new HttpRouteCollection();
            HttpBatchHandler mockBatchHandler = new Mock<HttpBatchHandler>(new HttpServer()).Object;
            IHttpRoute route = routes.MapHttpBatchRoute("batch", "api/batch", mockBatchHandler);

            Assert.NotNull(route);
            Assert.Equal("api/batch", route.RouteTemplate);
            Assert.Same(route, routes["batch"]);
            Assert.Same(mockBatchHandler, route.Handler);
        }

        [Fact]
        public void IgnoreRouteWithNullRouteCollectionThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { HttpRouteCollectionExtensions.IgnoreRoute(null, "bar", "foo"); },
                "routes");
        }

        [Fact]
        public void IgnoreRouteWithNullRouteNameThrows()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { routes.IgnoreRoute(null, "foo"); },
                "routeName");
        }

        [Fact]
        public void IgnoreRouteWithNullUrlThrows()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { routes.IgnoreRoute("foo", null); },
                "routeTemplate");
        }

        [Fact]
        public void IgnoreRouteWithoutConstraints()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();

            // Act
            routes.IgnoreRoute("SomeRouteName", "SomeRouteTemplate");

            // Assert
            HttpRoute route = Assert.Single(routes.Cast<HttpRoute>());
            Assert.NotNull(route);
            Assert.Equal("SomeRouteTemplate", route.RouteTemplate);
            Assert.IsType<StopRoutingHandler>(route.Handler);
            Assert.Empty(route.Defaults);
            Assert.Empty(route.Constraints);
        }

        [Fact]
        public void IgnoreRouteWithConstraints()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();
            var constraints = new { Foo = "DefaultFoo" };

            // Act
            routes.IgnoreRoute("SomeRouteName", "SomeRouteTemplate", constraints);

            // Assert
            HttpRoute route = Assert.Single(routes.Cast<HttpRoute>());
            Assert.NotNull(route);
            Assert.Equal("SomeRouteTemplate", route.RouteTemplate);
            Assert.IsType<StopRoutingHandler>(route.Handler);
            Assert.Empty(route.Defaults);
            Assert.Single(route.Constraints);
            Assert.Equal("DefaultFoo", route.Constraints["Foo"]);
        }

        [Fact]
        public void IgnoreRouteInternalNeverMatchesUrlGeneration()
        {
            // Arrange
            HttpRouteCollection routes = new HttpRouteCollection();
            IHttpRoute route = routes.IgnoreRoute("Foo", "SomeRouteTemplate");

            // Act
            IHttpVirtualPathData vpd = route.GetVirtualPath(new HttpRequestMessage(HttpMethod.Get, "SomeRouteTemplate"), null);

            // Assert
            Assert.Null(vpd);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpRouteCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http
{
    public class HttpRouteCollectionTest
    {
        [Fact]
        public void HttpRouteCollection_Dispose_UniquifiesHandlers()
        {
            // Arrange
            var collection = new HttpRouteCollection();

            var handler1 = new Mock<HttpMessageHandler>();
            handler1.As<IDisposable>().Setup(c => c.Dispose()).Verifiable();

            var handler2 = new Mock<HttpMessageHandler>();
            handler2.As<IDisposable>().Setup(c => c.Dispose()).Verifiable();

            var route1 = new Mock<IHttpRoute>();
            route1.SetupGet(r => r.Handler).Returns(handler1.Object);

            var route2 = new Mock<IHttpRoute>();
            route2.SetupGet(r => r.Handler).Returns(handler1.Object);

            var route3 = new Mock<IHttpRoute>();
            route3.SetupGet(r => r.Handler).Returns(handler2.Object);

            collection.Add("route1", route1.Object);
            collection.Add("route2", route2.Object);
            collection.Add("route3", route3.Object);

            // Act
            collection.Dispose();

            // Assert
            handler1.As<IDisposable>().Verify(c => c.Dispose(), Times.Once());
            handler2.As<IDisposable>().Verify(c => c.Dispose(), Times.Once());
        }

        [Fact]
        public void CreateRoute_ValidatesConstraintType_IHttpRouteConstraint()
        {
            // Arrange
            var routes = new MockHttpRouteCollection();

            var constraint = new CustomConstraint();
            var constraints = new HttpRouteValueDictionary();
            constraints.Add("custom", constraint);

            // Act
            var route = routes.CreateRoute("{controller}/{id}", null, constraints);

            // Assert
            Assert.NotNull(route.Constraints["custom"]);
            Assert.Equal(1, routes.TimesValidateConstraintCalled);
        }

        [Fact]
        public void CreateRoute_ValidatesConstraintType_StringRegex()
        {
            // Arrange
            var routes = new MockHttpRouteCollection();

            var constraint = "product|products";
            var constraints = new HttpRouteValueDictionary();
            constraints.Add("custom", constraint);

            // Act
            var route = routes.CreateRoute("{controller}/{id}", null, constraints);

            // Assert
            Assert.NotNull(route.Constraints["custom"]);
            Assert.Equal(1, routes.TimesValidateConstraintCalled);
        }

        [Fact]
        public void CreateRoute_ValidatesConstraintType_InvalidType()
        {
            // Arrange
            var routes = new HttpRouteCollection();

            var constraint = new Uri("http://localhost/");
            var constraints = new HttpRouteValueDictionary();
            constraints.Add("custom", constraint);

            string expectedMessage =
                "The constraint entry 'custom' on the route with route template '{controller}/{id}' " +
                "must have a string value or be of a type which implements 'System.Web.Http.Routing.IHttpRouteConstraint'.";

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => routes.CreateRoute("{controller}/{id}", null, constraints), expectedMessage);
        }

        private class CustomConstraint : IHttpRouteConstraint
        {
            public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
            {
                throw new NotImplementedException();
            }
        }

        private class MockHttpRouteCollection : HttpRouteCollection
        {
            public int TimesValidateConstraintCalled
            {
                get;
                private set;
            }

            protected override void ValidateConstraint(string routeTemplate, string name, object constraint)
            {
                TimesValidateConstraintCalled++;
                base.ValidateConstraint(routeTemplate, name, constraint);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/HttpServerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Results;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http
{
    public class HttpServerTest
    {
        [Fact]
        public void IsCorrectType()
        {
            Assert.Type.HasProperties<HttpServer, DelegatingHandler>(TypeAssert.TypeProperties.IsPublicVisibleClass | TypeAssert.TypeProperties.IsDisposable);
        }

        [Fact]
        public void DefaultConstructor()
        {
            Assert.DoesNotThrow(() => new HttpServer());
        }

        [Fact]
        public void ConstructorConfigThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => new HttpServer((HttpConfiguration)null), "configuration");
        }

        [Fact]
        public void ConstructorConfigSetsUpProperties()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();

            // Act
            HttpServer server = new HttpServer(config);

            // Assert
            Assert.Same(config, server.Configuration);
        }

        [Fact]
        public void ConstructorDispatcherThrowsOnNull()
        {
            Assert.ThrowsArgumentNull(() => new HttpServer((HttpMessageHandler)null), "dispatcher");
        }

        [Fact]
        public void ConstructorDispatcherSetsUpProperties()
        {
            // Arrange
            Mock<HttpMessageHandler> mockHandler = new Mock<HttpMessageHandler>();

            // Act
            HttpServer server = new HttpServer(mockHandler.Object);

            // Assert
            Assert.Same(mockHandler.Object, server.Dispatcher);
        }

        [Fact]
        public void ConstructorThrowsOnNull()
        {
            Mock<HttpMessageHandler> mockHandler = new Mock<HttpMessageHandler>();
            Assert.ThrowsArgumentNull(() => new HttpServer((HttpConfiguration)null, mockHandler.Object), "configuration");
            Assert.ThrowsArgumentNull(() => new HttpServer(new HttpConfiguration(), null), "dispatcher");
        }

        [Fact]
        public void ConstructorSetsUpProperties()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            Mock<HttpControllerDispatcher> controllerDispatcherMock = new Mock<HttpControllerDispatcher>(config);

            // Act
            HttpServer server = new HttpServer(config, controllerDispatcherMock.Object);

            // Assert
            Assert.Same(config, server.Configuration);
            Assert.Same(controllerDispatcherMock.Object, server.Dispatcher);
        }

        [Fact]
        public void ExceptionLoggerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler exceptionHandler = CreateDummyExceptionHandler();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpMessageHandler dispatcher = CreateDummyMessageHandler())
            using (HttpServer product = CreateProductUnderTest(configuration, dispatcher, expectedExceptionLogger,
                exceptionHandler))
            {
                // Act
                IExceptionLogger exceptionLogger = product.ExceptionLogger;

                // Assert
                Assert.Same(expectedExceptionLogger, exceptionLogger);
            }
        }

        [Fact]
        public void ExceptionHandlerGet_ReturnsSpecifiedInstance()
        {
            // Arrange
            IExceptionLogger exceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();

            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpMessageHandler dispatcher = CreateDummyMessageHandler())
            using (HttpServer product = CreateProductUnderTest(configuration, dispatcher, exceptionLogger,
                expectedExceptionHandler))
            {
                // Act
                IExceptionHandler exceptionHandler = product.ExceptionHandler;

                // Assert
                Assert.Same(expectedExceptionHandler, exceptionHandler);
            }
        }

        [Fact]
        public void ExceptionLoggerGet_IfUnset_ReturnsExceptionLoggerFromConfiguration()
        {
            // Arrange
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                IExceptionLogger expectedExceptionLogger = CreateDummyExceptionLogger();
                configuration.Services.Add(typeof(IExceptionLogger), expectedExceptionLogger);

                using (HttpMessageHandler dispatcher = CreateDummyMessageHandler())
                using (HttpServer product = new HttpServer(configuration, dispatcher))
                {
                    // Act
                    IExceptionLogger exceptionLogger = product.ExceptionLogger;

                    // Assert
                    CompositeExceptionLogger compositeLogger = Assert.IsType<CompositeExceptionLogger>(exceptionLogger);
                    IEnumerable<IExceptionLogger> loggers = compositeLogger.Loggers;
                    Assert.NotNull(loggers);
                    IExceptionLogger logger = Assert.Single(loggers);
                    Assert.Same(expectedExceptionLogger, logger);
                }
            }
        }

        [Fact]
        public void ExceptionHandlerGet_IfUnset_UsesExceptionHandlerFromConfiguration()
        {
            // Arrange
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                IExceptionHandler expectedExceptionHandler = CreateDummyExceptionHandler();
                configuration.Services.Replace(typeof(IExceptionHandler), expectedExceptionHandler);

                using (HttpMessageHandler dispatcher = CreateDummyMessageHandler())
                using (HttpServer product = new HttpServer(configuration, dispatcher))
                {
                    // Act
                    IExceptionHandler exceptionHandler = product.ExceptionHandler;

                    // Assert
                    LastChanceExceptionHandler lastChanceHandler = Assert.IsType<LastChanceExceptionHandler>(exceptionHandler);
                    Assert.Same(expectedExceptionHandler, lastChanceHandler.InnerHandler);
                }
            }
        }

        [Fact]
        public async Task DisposedReturnsServiceUnavailable()
        {
            // Arrange
            Mock<HttpMessageHandler> mockHandler = new Mock<HttpMessageHandler>();
            HttpServer server = new HttpServer(mockHandler.Object);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);
            server.Dispose();
            HttpRequestMessage request = new HttpRequestMessage();

            // Act
            var response = await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            mockHandler.Protected().Verify<Task<HttpResponseMessage>>("SendAsync", Times.Never(), request, CancellationToken.None);
            Assert.Equal(HttpStatusCode.ServiceUnavailable, response.StatusCode);
        }

        [Fact]
        public async Task RequestGetsConfigurationAsParameter()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();

            HttpConfiguration config = new HttpConfiguration();
            Mock<HttpControllerDispatcher> dispatcherMock = new Mock<HttpControllerDispatcher>(config);
            dispatcherMock.Protected().Setup<Task<HttpResponseMessage>>("SendAsync", request, CancellationToken.None)
                .Returns(Task.FromResult<HttpResponseMessage>(request.CreateResponse()));

            HttpServer server = new HttpServer(config, dispatcherMock.Object);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);

            // Act
            await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            dispatcherMock.Protected().Verify<Task<HttpResponseMessage>>("SendAsync", Times.Once(), request, CancellationToken.None);
            Assert.Same(config, request.GetConfiguration());
        }

        [Fact]
        public async Task RequestGetsSyncContextAsParameter()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();

            HttpConfiguration config = new HttpConfiguration();
            Mock<HttpControllerDispatcher> dispatcherMock = new Mock<HttpControllerDispatcher>(config);
            dispatcherMock.Protected().Setup<Task<HttpResponseMessage>>("SendAsync", request, CancellationToken.None)
                .Returns(Task.FromResult<HttpResponseMessage>(request.CreateResponse()));

            HttpServer server = new HttpServer(config, dispatcherMock.Object);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);

            SynchronizationContext syncContext = new SynchronizationContext();
            SynchronizationContext.SetSynchronizationContext(syncContext);

            // Act
            await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            dispatcherMock.Protected().Verify<Task<HttpResponseMessage>>("SendAsync", Times.Once(), request, CancellationToken.None);
            Assert.Same(syncContext, request.GetSynchronizationContext());
        }

        [Fact, RestoreThreadPrincipal]
        public async Task SendAsync_SetsGenericPrincipalWhenThreadPrincipalIsNullAndCleansUpAfterward()
        {
            // Arrange
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage();
            var dispatcherMock = new Mock<HttpControllerDispatcher>(config);
            var server = new HttpServer(config, dispatcherMock.Object);
            var invoker = new HttpMessageInvoker(server);
            IPrincipal callbackPrincipal = null;
            Thread.CurrentPrincipal = null;
            dispatcherMock.Protected()
                          .Setup<Task<HttpResponseMessage>>("SendAsync", request, CancellationToken.None)
                          .Callback(() => callbackPrincipal = Thread.CurrentPrincipal)
                          .Returns(Task.FromResult<HttpResponseMessage>(request.CreateResponse()));

            // Act
            await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            Assert.NotNull(callbackPrincipal);
            Assert.False(callbackPrincipal.Identity.IsAuthenticated);
            Assert.Empty(callbackPrincipal.Identity.Name);
            Assert.Null(Thread.CurrentPrincipal);
        }

        [Fact, RestoreThreadPrincipal]
        public async Task SendAsync_DoesNotChangeExistingThreadPrincipal()
        {
            // Arrange
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage();
            var dispatcherMock = new Mock<HttpControllerDispatcher>(config);
            var server = new HttpServer(config, dispatcherMock.Object);
            var invoker = new HttpMessageInvoker(server);
            var principal = new GenericPrincipal(new GenericIdentity("joe"), new string[0]);
            Thread.CurrentPrincipal = principal;
            IPrincipal callbackPrincipal = null;
            dispatcherMock.Protected()
                          .Setup<Task<HttpResponseMessage>>("SendAsync", request, CancellationToken.None)
                          .Callback(() => callbackPrincipal = Thread.CurrentPrincipal)
                          .Returns(Task.FromResult<HttpResponseMessage>(request.CreateResponse()));

            // Act
            await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            Assert.Same(principal, callbackPrincipal);
            Assert.Same(principal, Thread.CurrentPrincipal);
        }

        [Fact]
        public async Task SendAsync_Handles_ExceptionsThrownInMessageHandlers()
        {
            // Arrange
            var config = new HttpConfiguration();
            config.MessageHandlers.Add(new ThrowingMessageHandler(new InvalidOperationException()));
            HttpServer server = new HttpServer(config);
            var invoker = new HttpMessageInvoker(server);

            // Act
            var response = await invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None);

            // Assert
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
        }

        [Fact]
        public async Task SendAsync_Handles_HttpResponseExceptionsThrownInMessageHandlers()
        {
            // Arrange
            HttpResponseException exception = new HttpResponseException(new HttpResponseMessage(HttpStatusCode.HttpVersionNotSupported));
            exception.Response.ReasonPhrase = "whatever";
            var config = new HttpConfiguration();
            config.MessageHandlers.Add(new ThrowingMessageHandler(exception));
            HttpServer server = new HttpServer(config);
            var invoker = new HttpMessageInvoker(server);

            // Act
            var response = await invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None);

            // Assert
            Assert.Equal(exception.Response.StatusCode, response.StatusCode);
            Assert.Equal(exception.Response.ReasonPhrase, response.ReasonPhrase);
        }

        [Fact]
        public async Task SendAsync_Handles_ExceptionsThrownInCustomRoutes()
        {
            // Arrange
            var config = new HttpConfiguration();
            config.Routes.Add("throwing route", new ThrowingRoute(new InvalidOperationException()));
            HttpServer server = new HttpServer(config);
            var invoker = new HttpMessageInvoker(server);

            // Act
            var response = await invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None);

            // Assert
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
        }

        [Fact]
        public async Task SendAsync_Handles_HttpResponseExceptionsThrownInCustomRoutes()
        {
            // Arrange
            HttpResponseException exception = new HttpResponseException(new HttpResponseMessage(HttpStatusCode.HttpVersionNotSupported));
            exception.Response.ReasonPhrase = "whatever";
            var config = new HttpConfiguration();
            config.Routes.Add("throwing route", new ThrowingRoute(exception));
            HttpServer server = new HttpServer(config);
            var invoker = new HttpMessageInvoker(server);

            // Act
            var response = await invoker.SendAsync(new HttpRequestMessage(), CancellationToken.None);

            // Assert
            Assert.Equal(exception.Response.StatusCode, response.StatusCode);
            Assert.Equal(exception.Response.ReasonPhrase, response.ReasonPhrase);
        }

        [Fact]
        public async Task SendAsync_IfDispatcherTaskIsFaulted_CallsExceptionServices()
        {
            // Arrange
            Exception expectedException = CreateException();

            HttpMessageHandler dispatcher = CreateFaultingMessageHandler(expectedException);

            Mock<IExceptionLogger> exceptionLoggerMock = CreateStubExceptionLoggerMock();
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = CreateStubExceptionHandlerMock();
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpServer product = CreateProductUnderTest(configuration, dispatcher, exceptionLogger,
                exceptionHandler))
            {
                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                await Assert.ThrowsAsync<Exception>(() => product.SendAsync(expectedRequest, cancellationToken));

                // Assert
                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == ExceptionCatchBlocks.HttpServer
                    && c.Request == expectedRequest;

                exceptionLoggerMock.Verify(l => l.LogAsync(
                    It.Is<ExceptionLoggerContext>(c => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());

                exceptionHandlerMock.Verify(h => h.HandleAsync(
                    It.Is<ExceptionHandlerContext>((c) => exceptionContextMatches(c.ExceptionContext)),
                    cancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task SendAsync_IfRequestCancelled_DoesNotCallExceptionServices()
        {
            // Arrange
            Exception expectedException = new OperationCanceledException();

            HttpMessageHandler dispatcher = CreateFaultingMessageHandler(expectedException);

            Mock<IExceptionLogger> exceptionLoggerMock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            IExceptionLogger exceptionLogger = exceptionLoggerMock.Object;

            Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpServer product = CreateProductUnderTest(configuration, dispatcher, exceptionLogger,
                exceptionHandler))
            {
                CancellationToken cancellationToken = CreateCancellationToken();

                // Act
                await Assert.ThrowsAsync<OperationCanceledException>(() => product.SendAsync(expectedRequest, cancellationToken));

                // The mock handler and logger will throw if they are called, so this test verifies that
                // they aren't called by construction.
            }
        }

        [Fact]
        public async Task SendAsync_IfExceptionHandlerSetsNullResult_PropogatesFaultedTaskException()
        {
            // Arrange
            Exception expectedException = CreateExceptionWithCallStack();
            string expectedStackTrace = expectedException.StackTrace;

            HttpMessageHandler dispatcher = CreateFaultingMessageHandler(expectedException);

            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();

            Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            exceptionHandlerMock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Callback<ExceptionHandlerContext, CancellationToken>((c, i) => c.Result = null)
                .Returns(Task.FromResult(0));
            IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            using (HttpServer product = CreateProductUnderTest(configuration, dispatcher, exceptionLogger,
                exceptionHandler))
            {
                CancellationToken cancellationToken = CreateCancellationToken();

                // Act & Assert
                var exception = await Assert.ThrowsAsync<Exception>(() => product.SendAsync(request, cancellationToken));

                Assert.Same(expectedException, exception);
                Assert.NotNull(exception.StackTrace);
                Assert.StartsWith(expectedStackTrace, exception.StackTrace);
            }
        }

        [Fact]
        public async Task SendAsync_IfExceptionHandlerHandlesException_ReturnsResponse()
        {
            // Arrange
            HttpMessageHandler dispatcher = CreateFaultingMessageHandler(CreateException());

            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();

            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                Mock<IExceptionHandler> exceptionHandlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                exceptionHandlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Callback<ExceptionHandlerContext, CancellationToken>((c, i) =>
                        c.Result = new ResponseMessageResult(expectedResponse))
                    .Returns(Task.FromResult(0));
                IExceptionHandler exceptionHandler = exceptionHandlerMock.Object;

                using (HttpRequestMessage request = CreateRequest())
                using (HttpConfiguration configuration = new HttpConfiguration())
                using (HttpServer product = CreateProductUnderTest(configuration, dispatcher, exceptionLogger,
                    exceptionHandler))
                {
                    CancellationToken cancellationToken = CreateCancellationToken();

                    // Act
                    HttpResponseMessage response = await product.SendAsync(request, cancellationToken);

                    // Assert
                    Assert.Same(expectedResponse, response);
                }
            }
        }

        [Fact]
        public async Task HttpServerAddsDefaultRequestContext()
        {
            // Arrange
            HttpServer server = new HttpServer();
            var handler = new ThrowIfNoContext();

            server.Configuration.MessageHandlers.Add(handler);
            server.Configuration.MapHttpAttributeRoutes();
            server.Configuration.EnsureInitialized();

            var invoker = new HttpMessageInvoker(server);

            var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Customers");

            // Act
            var response = await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            response.EnsureSuccessStatusCode();
            Assert.True(handler.ContextFound);
        }

        [Fact]
        public async Task HttpServerDoesNotReplaceOriginalRequestContext()
        {
            // Arrange
            HttpServer server = new HttpServer();
            var handler = new ThrowIfNoContext();

            server.Configuration.MessageHandlers.Add(handler);
            server.Configuration.MapHttpAttributeRoutes();
            server.Configuration.EnsureInitialized();

            HttpMessageInvoker invoker = new HttpMessageInvoker(server);

            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/Customers");

            HttpRequestContext context = new HttpRequestContext();

            request.SetRequestContext(context);

            // Act
            var response = await invoker.SendAsync(request, CancellationToken.None);

            // Assert
            response.EnsureSuccessStatusCode();
            Assert.True(handler.ContextFound);
            Assert.Equal(context, response.RequestMessage.GetRequestContext());
        }

        private static CancellationToken CreateCancellationToken()
        {
            CancellationTokenSource source = new CancellationTokenSource();
            return source.Token;
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static IExceptionHandler CreateDummyExceptionHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyExceptionLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static HttpMessageHandler CreateDummyMessageHandler()
        {
            Mock<HttpMessageHandler> mock = new Mock<HttpMessageHandler>(MockBehavior.Strict);
            mock.As<IDisposable>().Setup(c => c.Dispose());
            return mock.Object;
        }

        private static Exception CreateException()
        {
            return new Exception();
        }

        private static Exception CreateExceptionWithCallStack()
        {
            try
            {
                throw CreateException();
            }
            catch (Exception exception)
            {
                return exception;
            }
        }

        private static Task<TResult> CreateFaultedTask<TResult>(Exception exception)
        {
            TaskCompletionSource<TResult> source = new TaskCompletionSource<TResult>();
            source.SetException(exception);
            return source.Task;
        }

        private static HttpMessageHandler CreateFaultingMessageHandler(Exception exception)
        {
            Mock<HttpMessageHandler> mock = new Mock<HttpMessageHandler>();
            mock
                .Protected()
                .Setup<Task<HttpResponseMessage>>("SendAsync", ItExpr.IsAny<HttpRequestMessage>(),
                    ItExpr.IsAny<CancellationToken>())
                .Returns(CreateFaultedTask<HttpResponseMessage>(exception));
            return mock.Object;
        }

        private static HttpServer CreateProductUnderTest(HttpConfiguration configuration,
            HttpMessageHandler dispatcher, IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler)
        {
            return new HttpServer(configuration, dispatcher)
            {
                ExceptionLogger = exceptionLogger,
                ExceptionHandler = exceptionHandler
            };
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static Mock<IExceptionHandler> CreateStubExceptionHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static IExceptionLogger CreateStubExceptionLogger()
        {
            return CreateStubExceptionLoggerMock().Object;
        }

        private static Mock<IExceptionLogger> CreateStubExceptionLoggerMock()
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private class ThrowIfNoContext : DelegatingHandler
        {
            public bool ContextFound { get; set; }

            protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                HttpRequestContext incomingContext = request.GetRequestContext();

                if (incomingContext == null)
                {
                    throw new InvalidOperationException("context missing");
                }

                ContextFound = true;

                HttpResponseMessage result = await base.SendAsync(request, cancellationToken);

                HttpRequestContext outgoingContext = result.RequestMessage.GetRequestContext();

                if (outgoingContext != incomingContext)
                {
                    throw new InvalidOperationException("context mismatch");
                }

                return result;
            }
        }

        public class RequestHasContextController : ApiController
        {
            [Route("Customers")]
            public IHttpActionResult Get()
            {
                if (RequestContext == null)
                {
                    return InternalServerError();
                }

                if (Request.GetRequestContext() == null)
                {
                    return BadRequest();
                }

                return Ok();
            }
        }

        private class ThrowingMessageHandler : DelegatingHandler
        {
            private Exception _exception;

            public ThrowingMessageHandler(Exception exception)
            {
                _exception = exception;
            }

            protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                // dummy await so that the task doesn't get completed synchronously.
                await Task.FromResult(42);
                throw _exception;
            }
        }

        private class ThrowingRoute : HttpRoute
        {
            private Exception _exception;

            public ThrowingRoute(Exception exception)
            {
                _exception = exception;
            }

            public override IHttpRouteData GetRouteData(string virtualPathRoot, HttpRequestMessage request)
            {
                throw _exception;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Internal/CollectionModelBinderUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;

namespace System.Web.Http.Internal
{
    public class CollectionModelBinderUtilTest
    {
        [Fact]
        public void CreateOrReplaceCollection_OriginalModelImmutable_CreatesNewInstance()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => new ReadOnlyCollection<int>(new int[0]), typeof(ICollection<int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, new[] { 10, 20, 30 }, () => new List<int>());

            // Assert
            int[] newModel = (bindingContext.Model as ICollection<int>).ToArray();
            Assert.Equal(new[] { 10, 20, 30 }, newModel);
        }

        [Fact]
        public void CreateOrReplaceCollection_OriginalModelMutable_UpdatesOriginalInstance()
        {
            // Arrange
            List<int> originalInstance = new List<int> { 10, 20, 30 };
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => originalInstance, typeof(ICollection<int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, new[] { 40, 50, 60 }, () => new List<int>());

            // Assert
            Assert.Same(originalInstance, bindingContext.Model);
            Assert.Equal(new[] { 40, 50, 60 }, originalInstance.ToArray());
        }

        [Fact]
        public void CreateOrReplaceCollection_OriginalModelNotCollection_CreatesNewInstance()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ICollection<int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceCollection(bindingContext, new[] { 10, 20, 30 }, () => new List<int>());

            // Assert
            int[] newModel = (bindingContext.Model as ICollection<int>).ToArray();
            Assert.Equal(new[] { 10, 20, 30 }, newModel);
        }

        [Fact]
        public void CreateOrReplaceDictionary_DisallowsDuplicateKeys()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(Dictionary<string, int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new[]
                {
                    new KeyValuePair<string, int>("forty-two", 40),
                    new KeyValuePair<string, int>("forty-two", 2),
                    new KeyValuePair<string, int>("forty-two", 42)
                },
                () => new Dictionary<string, int>());

            // Assert
            IDictionary<string, int> newModel = bindingContext.Model as IDictionary<string, int>;
            Assert.Equal(new[] { "forty-two" }, newModel.Keys.ToArray());
            Assert.Equal(42, newModel["forty-two"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_DisallowsNullKeys()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(Dictionary<string, int>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new[]
                {
                    new KeyValuePair<string, int>("forty-two", 42),
                    new KeyValuePair<string, int>(null, 84)
                },
                () => new Dictionary<string, int>());

            // Assert
            IDictionary<string, int> newModel = bindingContext.Model as IDictionary<string, int>;
            Assert.Equal(new[] { "forty-two" }, newModel.Keys.ToArray());
            Assert.Equal(42, newModel["forty-two"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_OriginalModelImmutable_CreatesNewInstance()
        {
            // Arrange
            ReadOnlyDictionary<string, string> originalModel = new ReadOnlyDictionary<string, string>();

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => originalModel, typeof(IDictionary<string, string>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new Dictionary<string, string>
                {
                    { "Hello", "World" }
                },
                () => new Dictionary<string, string>());

            // Assert
            IDictionary<string, string> newModel = bindingContext.Model as IDictionary<string, string>;
            Assert.NotSame(originalModel, newModel);
            Assert.Equal(new[] { "Hello" }, newModel.Keys.ToArray());
            Assert.Equal("World", newModel["Hello"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_OriginalModelMutable_UpdatesOriginalInstance()
        {
            // Arrange
            Dictionary<string, string> originalInstance = new Dictionary<string, string>
            {
                { "dog", "Canidae" },
                { "cat", "Felidae" }
            };
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => originalInstance, typeof(IDictionary<string, string>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new Dictionary<string, string>
                {
                    { "horse", "Equidae" },
                    { "bear", "Ursidae" }
                },
                () => new Dictionary<string, string>());

            // Assert
            Assert.Same(originalInstance, bindingContext.Model);
            Assert.Equal(new[] { "horse", "bear" }, originalInstance.Keys.ToArray());
            Assert.Equal("Equidae", originalInstance["horse"]);
            Assert.Equal("Ursidae", originalInstance["bear"]);
        }

        [Fact]
        public void CreateOrReplaceDictionary_OriginalModelNotDictionary_CreatesNewInstance()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<string, string>))
            };

            // Act
            CollectionModelBinderUtil.CreateOrReplaceDictionary(
                bindingContext,
                new Dictionary<string, string>
                {
                    { "horse", "Equidae" },
                    { "bear", "Ursidae" }
                },
                () => new Dictionary<string, string>());

            // Assert
            IDictionary<string, string> newModel = bindingContext.Model as IDictionary<string, string>;
            Assert.Equal(new[] { "horse", "bear" }, newModel.Keys.ToArray());
            Assert.Equal("Equidae", newModel["horse"]);
            Assert.Equal("Ursidae", newModel["bear"]);
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultIsNull_ReturnsNull()
        {
            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(null);

            // Assert
            Assert.Null(indexNames);
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultReturnsEmptyArray_ReturnsNull()
        {
            // Arrange
            ValueProviderResult vpResult = new ValueProviderResult(new string[0], "", null);

            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(vpResult);

            // Assert
            Assert.Null(indexNames);
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultReturnsNonEmptyArray_ReturnsArray()
        {
            // Arrange
            ValueProviderResult vpResult = new ValueProviderResult(new[] { "foo", "bar", "baz" }, "foo,bar,baz", null);

            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(vpResult);

            // Assert
            Assert.NotNull(indexNames);
            Assert.Equal(new[] { "foo", "bar", "baz" }, indexNames.ToArray());
        }

        [Fact]
        public void GetIndexNamesFromValueProviderResult_ValueProviderResultReturnsNull_ReturnsNull()
        {
            // Arrange
            ValueProviderResult vpResult = new ValueProviderResult(null, null, null);

            // Act
            IEnumerable<string> indexNames = CollectionModelBinderUtil.GetIndexNamesFromValueProviderResult(vpResult);

            // Assert
            Assert.Null(indexNames);
        }

        [Fact]
        public void GetZeroBasedIndexes()
        {
            // Act
            string[] indexes = CollectionModelBinderUtil.GetZeroBasedIndexes().Take(5).ToArray();

            // Assert
            Assert.Equal(new[] { "0", "1", "2", "3", "4" }, indexes);
        }

        private class ReadOnlyDictionary<TKey, TValue> : Dictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>
        {
            bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly
            {
                get { return true; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Internal/TypeActivatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Reflection;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http.Internal
{
    public class TypeActivatorTest
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(typeof(TypeActivator), TypeAssert.TypeProperties.IsClass | TypeAssert.TypeProperties.IsStatic);
        }

        public static TheoryDataSet<Type, Type> ValidTypeParameters
        {
            get
            {
                return new TheoryDataSet<Type, Type>
                {
                    { typeof(List<int>), typeof(IList<int>)},
                    { typeof(Dictionary<int, int>), typeof(IDictionary<int, int>)},
                    { typeof(HttpRequestMessage), typeof(HttpRequestMessage)},
                    { typeof(HttpConfiguration), typeof(HttpConfiguration)},
                    { typeof(ReflectedHttpActionDescriptor), typeof(HttpActionDescriptor) },
                    { typeof(ApiControllerActionSelector), typeof(IHttpActionSelector)},
                    { typeof(ApiControllerActionInvoker), typeof(IHttpActionInvoker)},
                    { typeof(List<HttpStatusCode>), typeof(IEnumerable<HttpStatusCode>)},
                };
            }
        }

        public static TheoryDataSet<Type> ValidInstanceTypeParameters
        {
            get
            {
                return new TheoryDataSet<Type>
                {
                    { typeof(List<int>) },
                    { typeof(Dictionary<int, int>) },
                    { typeof(HttpRequestMessage) },
                    { typeof(HttpConfiguration) },
                    { typeof(ReflectedHttpActionDescriptor) },
                    { typeof(ApiControllerActionSelector) },
                    { typeof(ApiControllerActionInvoker) },
                    { typeof(List<HttpStatusCode>) },
                };
            }
        }

        [Theory]
        [PropertyData("ValidInstanceTypeParameters")]
        public void CreateType(Type instanceType)
        {
            // Arrange
            Func<object> instanceDelegate = TypeActivator.Create(instanceType);

            // Act
            object instance = instanceDelegate();

            // Assert
            Assert.IsType(instanceType, instance);
        }

        [Theory]
        [InlineData(typeof(int))]
        [InlineData(typeof(Guid))]
        [InlineData(typeof(HttpStatusCode))]
        [InlineData(typeof(string))]
        [InlineData(typeof(Uri))]
        [InlineData(typeof(IDictionary<object, object>))]
        [InlineData(typeof(List<>))]
        public void CreateTypeInvalidThrowsInvalidArgument(Type type)
        {
            // Value types, interfaces, and open generics cause ArgumentException
            Assert.ThrowsArgument(() => TypeActivator.Create(type), paramName: null);
        }

        [Theory]
        [InlineData(typeof(HttpContent))]
        [InlineData(typeof(HttpActionDescriptor))]
        public void CreateTypeInvalidThrowsInvalidOperation(Type type)
        {
            // Abstract types cause InvalidOperationException
            Assert.Throws<InvalidOperationException>(() => TypeActivator.Create(type));
        }

        [Theory]
        [PropertyData("ValidInstanceTypeParameters")]
        public void CreateOfT(Type instanceType)
        {
            // Arrange
            Type activatorType = typeof(TypeActivator);
            MethodInfo createMethodInfo = activatorType.GetMethod("Create", Type.EmptyTypes);
            MethodInfo genericCreateMethodInfo = createMethodInfo.MakeGenericMethod(instanceType);
            Func<object> instanceDelegate = (Func<object>)genericCreateMethodInfo.Invoke(null, null);

            // Act
            object instance = instanceDelegate();

            // Assert
            Assert.IsType(instanceType, instance);
        }

        [Fact]
        public void CreateOfTInvalid()
        {
            // string doesn't have a default ctor
            Assert.ThrowsArgument(() => TypeActivator.Create<string>(), paramName: null);

            // Uri doesn't have a default ctor
            Assert.ThrowsArgument(() => TypeActivator.Create<Uri>(), paramName: null);

            // HttpContent is abstract
            Assert.Throws<InvalidOperationException>(() => TypeActivator.Create<HttpContent>());

            // HttpActionDescriptor is abstract
            Assert.Throws<InvalidOperationException>(() => TypeActivator.Create<HttpActionDescriptor>());
        }

        [Theory]
        [PropertyData("ValidTypeParameters")]
        public void CreateOfTBase(Type instanceType, Type baseType)
        {
            // Arrange
            Type activatorType = typeof(TypeActivator);
            MethodInfo createMethodInfo = null;
            foreach (MethodInfo methodInfo in activatorType.GetMethods())
            {
                ParameterInfo[] parameterInfo = methodInfo.GetParameters();
                if (methodInfo.Name == "Create" && methodInfo.ContainsGenericParameters && parameterInfo.Length == 1 && parameterInfo[0].ParameterType == typeof(Type))
                {
                    createMethodInfo = methodInfo;
                    break;
                }
            }

            MethodInfo genericCreateMethodInfo = createMethodInfo.MakeGenericMethod(baseType);
            Func<object> instanceDelegate = (Func<object>)genericCreateMethodInfo.Invoke(null, new object[] { instanceType });

            // Act
            object instance = instanceDelegate();

            // Assert
            Assert.IsType(instanceType, instance);
        }

        [Fact]
        public void CreateOfTBaseInvalid()
        {
            // int not being a ref type
            Assert.ThrowsArgument(() => TypeActivator.Create<object>(typeof(int)), paramName: null);

            // GUID is not a ref type
            Assert.ThrowsArgument(() => TypeActivator.Create<object>(typeof(Guid)), paramName: null);

            // HttpStatusCode is not a ref type
            Assert.ThrowsArgument(() => TypeActivator.Create<object>(typeof(HttpStatusCode)), paramName: null);

            // string does not have a default ctor
            Assert.ThrowsArgument(() => TypeActivator.Create<string>(typeof(string)), paramName: null);

            // ObjectContent does not have a default ctor
            Assert.ThrowsArgument(() => TypeActivator.Create<HttpContent>(typeof(ObjectContent)), paramName: null);

            // Base type and instance type flipped
            Assert.ThrowsArgument(() => TypeActivator.Create<ReflectedHttpActionDescriptor>(typeof(HttpActionDescriptor)), paramName: null);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Metadata/ModelMetadataTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Metadata
{
    public class ModelMetadataTest
    {
        // Guard clauses

        [Fact]
        public void NullProviderThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new ModelMetadata(null /* provider */, null /* containerType */, null /* model */, typeof(object), null /* propertyName */),
                "provider");
        }

        [Fact]
        public void NullTypeThrows()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new ModelMetadata(provider.Object, null /* containerType */, null /* model */, null /* modelType */, null /* propertyName */),
                "modelType");
        }

        // Constructor

        [Fact]
        public void DefaultValues()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act
            ModelMetadata metadata = new ModelMetadata(provider.Object, typeof(Exception), () => "model", typeof(string), "propertyName");

            // Assert
            Assert.Equal(typeof(Exception), metadata.ContainerType);
            Assert.True(metadata.ConvertEmptyStringToNull);
            Assert.Null(metadata.Description);
            Assert.Equal("model", metadata.Model);
            Assert.Equal(typeof(string), metadata.ModelType);
            Assert.Equal("propertyName", metadata.PropertyName);
            Assert.False(metadata.IsReadOnly);
        }

        // IsComplexType

        struct IsComplexTypeModel
        {
        }

        [Fact]
        public void IsComplexTypeTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Object), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(IsComplexTypeModel), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Nullable<IsComplexTypeModel>), null).IsComplexType);
        }

        // IsNullableValueType

        [Fact]
        public void IsNullableValueTypeTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsNullableValueType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsNullableValueType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsNullableValueType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsNullableValueType);
        }

        // Properties

        [Fact]
        public void PropertiesCallsProvider()
        {
            // Arrange
            Type modelType = typeof(string);
            List<ModelMetadata> propertyMetadata = new List<ModelMetadata>();
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, modelType, null);
            provider.Setup(p => p.GetMetadataForProperties(null, modelType))
                .Returns(propertyMetadata)
                .Verifiable();

            // Act
            IEnumerable<ModelMetadata> result = metadata.Properties;

            // Assert
            Assert.Equal(propertyMetadata, result.ToList());
            provider.Verify();
        }

        [Fact]
        public void PropertiesListGetsResetWhenModelGetsReset()
        { // Dev10 Bug #923263
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();
            var metadata = new ModelMetadata(provider, null, () => new Class1(), typeof(Class1), null);

            // Act
            ModelMetadata[] originalProps = metadata.Properties.ToArray();
            metadata.Model = new Class2();
            ModelMetadata[] newProps = metadata.Properties.ToArray();

            // Assert
            ModelMetadata originalProp = Assert.Single(originalProps);
            Assert.Equal(typeof(string), originalProp.ModelType);
            Assert.Equal("Prop1", originalProp.PropertyName);
            ModelMetadata newProp = Assert.Single(newProps);
            Assert.Equal(typeof(int), newProp.ModelType);
            Assert.Equal("Prop2", newProp.PropertyName);
        }

        class Class1
        {
            public string Prop1 { get; set; }
        }

        class Class2
        {
            public int Prop2 { get; set; }
        }

        // GetDisplayName()

        [Fact]
        public void ReturnsPropertyNameWhenSetAndDisplayNameIsNull()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), "PropertyName");

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("PropertyName", result);
        }

        [Fact]
        public void ReturnsTypeNameWhenPropertyNameAndDisplayNameAreNull()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("Object", result);
        }

        // Helpers

        private class DummyContactModel
        {
            public int IntField = 0;
            public string FirstName { get; set; }
            public string LastName { get; set; }
            public Nullable<int> NullableIntValue { get; set; }
            public int[] Array { get; set; }

            public string this[int index]
            {
                get { return "Indexed into " + index; }
            }
        }

        private class DummyModelContainer
        {
            public DummyContactModel Model { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Metadata/Providers/AssociatedMetadataProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Http.Metadata.Providers
{
    public class AssociatedMetadataProviderTest
    {
        // GetMetadataForProperties

        [Fact]
        public void GetMetadataForPropertiesNullContainerTypeThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.GetMetadataForProperties(new Object(), containerType: null),
                "containerType");
        }

        [Fact]
        public void GetMetadataForPropertiesCreatesMetadataForAllPropertiesOnModelWithPropertyValues()
        {
            // Arrange
            PropertyModel model = new PropertyModel { LocalAttributes = 42, MetadataAttributes = "hello", MixedAttributes = 21.12 };
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act
            provider.GetMetadataForProperties(model, typeof(PropertyModel)).ToList(); // Call ToList() to force the lazy evaluation to evaluate

            // Assert
            CreateMetadataPrototypeParams local = Assert.Single(
                provider.CreateMetadataPrototypeLog,
                m => m.ContainerType == typeof(PropertyModel) && m.PropertyName == "LocalAttributes");
            Assert.Equal(typeof(int), local.ModelType);
            Assert.Contains(local.Attributes, a => a is RequiredAttribute);

            CreateMetadataPrototypeParams metadata = Assert.Single(
                provider.CreateMetadataPrototypeLog,
                m => m.ContainerType == typeof(PropertyModel) && m.PropertyName == "MetadataAttributes");
            Assert.Equal(typeof(string), metadata.ModelType);
            Assert.Contains(metadata.Attributes, a => a is RangeAttribute);

            CreateMetadataPrototypeParams mixed = Assert.Single(
                provider.CreateMetadataPrototypeLog,
                m => m.ContainerType == typeof(PropertyModel) && m.PropertyName == "MixedAttributes");
            Assert.Equal(typeof(double), mixed.ModelType);
            Assert.Contains(mixed.Attributes, a => a is RequiredAttribute);
            Assert.Contains(mixed.Attributes, a => a is RangeAttribute);
        }

        [Fact]
        public void GetMetadataForPropertyWithNullContainerReturnsMetadataWithNullValuesForProperties()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act
            provider.GetMetadataForProperties(null, typeof(PropertyModel)).ToList(); // Call ToList() to force the lazy evaluation to evaluate

            // Assert
            Assert.True(provider.CreateMetadataFromPrototypeLog.Any());
            foreach (var parms in provider.CreateMetadataFromPrototypeLog)
            {
                Assert.Null(parms.Model);
            }
        }

        // GetMetadataForProperty

        [Fact]
        public void GetMetadataForPropertyNullContainerTypeThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.GetMetadataForProperty(modelAccessor: null, containerType: null, propertyName: "propertyName"),
                "containerType");
        }

        [Fact]
        public void GetMetadataForPropertyNullOrEmptyPropertyNameThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgument(
                () => provider.GetMetadataForProperty(modelAccessor: null, containerType: typeof(object), propertyName: null),
                "propertyName",
                "The argument 'propertyName' is null or empty.");
            Assert.ThrowsArgument(
                () => provider.GetMetadataForProperty(modelAccessor: null, containerType: typeof(object), propertyName: String.Empty),
                "propertyName",
                "The argument 'propertyName' is null or empty.");
        }

        [Fact]
        public void GetMetadataForPropertyInvalidPropertyNameThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgument(
                () => provider.GetMetadataForProperty(modelAccessor: null, containerType: typeof(object), propertyName: "BadPropertyName"),
                "propertyName",
                "The property System.Object.BadPropertyName could not be found.");
        }

        [Fact]
        public void GetMetadataForPropertyWithLocalAttributes()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, typeof(PropertyModel), null, typeof(int), "LocalAttributes");
            provider.CreateMetadataFromPrototypeReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(PropertyModel), "LocalAttributes");

            // Assert
            Assert.Same(metadata, result);
            CreateMetadataPrototypeParams metadataPrototypeParams = Assert.Single(
                provider.CreateMetadataPrototypeLog,
                parameters => parameters.PropertyName == "LocalAttributes");
            Assert.Contains(metadataPrototypeParams.Attributes, a => a is RequiredAttribute);
        }

        [Fact]
        public void GetMetadataForPropertyWithMetadataAttributes()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, typeof(PropertyModel), null, typeof(string), "MetadataAttributes");
            provider.CreateMetadataFromPrototypeReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(PropertyModel), "MetadataAttributes");

            // Assert
            Assert.Same(metadata, result);
            CreateMetadataPrototypeParams parms = Assert.Single(
                provider.CreateMetadataPrototypeLog,
                parameters => parameters.PropertyName == "MetadataAttributes");
            Assert.Contains(parms.Attributes, a => a is RangeAttribute);
        }

        [Fact]
        public void GetMetadataForPropertyWithMixedAttributes()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, typeof(PropertyModel), null, typeof(double), "MixedAttributes");
            provider.CreateMetadataFromPrototypeReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(PropertyModel), "MixedAttributes");

            // Assert
            Assert.Same(metadata, result);
            CreateMetadataPrototypeParams parms = Assert.Single(
                provider.CreateMetadataPrototypeLog,
                p => p.PropertyName == "MixedAttributes");
            Assert.Contains(parms.Attributes, a => a is RequiredAttribute);
            Assert.Contains(parms.Attributes, a => a is RangeAttribute);
        }

        // GetMetadataForType

        [Fact]
        public void GetMetadataForTypeNullModelTypeThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.GetMetadataForType(() => new Object(), modelType: null),
                "modelType");
        }

        [Fact]
        public void GetMetadataForTypeIncludesAttributesOnType()
        {
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, null, typeof(TypeModel), null);
            provider.CreateMetadataFromPrototypeReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForType(null, typeof(TypeModel));

            // Assert
            Assert.Same(metadata, result);
            CreateMetadataPrototypeParams parms = Assert.Single(
                provider.CreateMetadataPrototypeLog,
                p => p.ModelType == typeof(TypeModel));
            Assert.Contains(parms.Attributes, a => a is ReadOnlyAttribute);
        }

        // Helpers

        [MetadataType(typeof(Metadata))]
        private class PropertyModel
        {
            [Required]
            public int LocalAttributes { get; set; }

            public string MetadataAttributes { get; set; }

            [Required]
            public double MixedAttributes { get; set; }

            private class Metadata
            {
                [Range(10, 100)]
                public object MetadataAttributes { get; set; }

                [Range(10, 100)]
                public object MixedAttributes { get; set; }
            }
        }

        private class ModelWithReadOnlyProperty
        {
            public int ReadOnlyProperty { get; private set; }
        }

        [ReadOnly(true)]
        private class TypeModel
        {
        }

        class TestableAssociatedMetadataProvider : AssociatedMetadataProvider<ModelMetadata>
        {
            public List<CreateMetadataPrototypeParams> CreateMetadataPrototypeLog = new List<CreateMetadataPrototypeParams>();
            public List<CreateMetadataFromPrototypeParams> CreateMetadataFromPrototypeLog = new List<CreateMetadataFromPrototypeParams>();
            public ModelMetadata CreateMetadataPrototypeReturnValue = null;
            public ModelMetadata CreateMetadataFromPrototypeReturnValue = null;

            protected override ModelMetadata CreateMetadataPrototype(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName)
            {
                CreateMetadataPrototypeLog.Add(new CreateMetadataPrototypeParams
                {
                    Attributes = attributes,
                    ContainerType = containerType,
                    ModelType = modelType,
                    PropertyName = propertyName
                });

                return CreateMetadataPrototypeReturnValue;
            }

            protected override ModelMetadata CreateMetadataFromPrototype(ModelMetadata prototype, Func<object> modelAccessor)
            {
                CreateMetadataFromPrototypeLog.Add(new CreateMetadataFromPrototypeParams
                {
                    Prototype = prototype,
                    Model = modelAccessor == null ? null : modelAccessor()
                });

                return CreateMetadataFromPrototypeReturnValue;
            }
        }

        class CreateMetadataPrototypeParams
        {
            public IEnumerable<Attribute> Attributes { get; set; }
            public Type ContainerType { get; set; }
            public Type ModelType { get; set; }
            public string PropertyName { get; set; }
        }

        class CreateMetadataFromPrototypeParams
        {
            public ModelMetadata Prototype { get; set; }
            public object Model { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Metadata/Providers/DataAnnotationsModelMetadataProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Http.Metadata.Providers
{
    public class DataAnnotationsModelMetadataProviderTest
    {
        [Fact]
        public void GetMetadataForPropertiesSetTypesAndPropertyNames()
        {
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();

            // Act
            IEnumerable<ModelMetadata> result = provider.GetMetadataForProperties("foo", typeof(string));

            // Assert
            Assert.Contains(result, m => m.ModelType == typeof(int)
                                        && m.PropertyName == "Length"
                                        && (int)m.Model == 3);
        }

        [Fact]
        public void GetMetadataForPropertySetsTypeAndPropertyName()
        {
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(string), "Length");

            // Assert
            Assert.Equal(typeof(int), result.ModelType);
            Assert.Equal("Length", result.PropertyName);
        }

        [Fact]
        public void GetMetadataForTypeSetsTypeWithNullPropertyName()
        {
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();

            // Act
            ModelMetadata result = provider.GetMetadataForType(null, typeof(string));

            // Assert
            Assert.Equal(typeof(string), result.ModelType);
            Assert.Null(result.PropertyName);
        }

        [Theory]
        [InlineData("NoAttributes", false)]
        [InlineData("ReadOnlyAttribute", true)]
        [InlineData("EditableAttribute", true)]
        [InlineData("BothAttributes", false)]
        public void ReadOnlyTests(string propertyName, bool expected)
        {
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();

            // Act
            var actual = provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), propertyName).IsReadOnly;

            // Assert
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("NoAttribute", "NoAttribute")]
        [InlineData("NothingSet", "NothingSet")]
        [InlineData("EmptyDisplayName", "")]
        [InlineData("DescriptionSet", "DescriptionSet")]
        [InlineData("NameSet", "Name text1")]
        [InlineData("DisplayNameSet", "Just DisplayName")]
        [InlineData("BothSet", "Name text2")]
        [InlineData("FallbackToDisplayName", "Fallback")]
        [InlineData("FallbackToProperty", "FallbackToProperty")]
        [InlineData("FallbackToPropertyFromDisplayName", "FallbackToPropertyFromDisplayName")]
        [InlineData("DisplayNameDefault", "")] // The default for DisplayName is the empty string, we don't have special handling for it, and nither does MVC.
        public void DataAnnotationsNameTests(string propertyName, string expected)
        {
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();

            // Act
            var actual = provider.GetMetadataForProperty(null, typeof(DisplayModel), propertyName).GetDisplayName();

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void DisplayAttribute_WithLocalizedName()
        {
            // Guard
            var expected = Resources.String1;
            Assert.NotEqual("String1", expected);

            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();

            // Act
            var actual = provider.GetMetadataForProperty(null, typeof(DisplayModel), "Localized").GetDisplayName();
            
            // Assert
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData("NoAttribute", null)]
        [InlineData("NothingSet", null)]
        [InlineData("NameSet", null)]
        [InlineData("DescriptionSet", "Description text1")]
        [InlineData("BothSet", "Description text2")]
        public void DataAnnotationsDescriptionTests(string propertyName, string expected)
        {
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();

            // Act
            var actual = provider.GetMetadataForProperty(null, typeof(DisplayModel), propertyName).Description;

            // Assert
            Assert.Equal(expected, actual);
        }

        // [Display] & [DisplayName] tests
        private class DisplayModel
        {
            public int NoAttribute { get; set; }

            // Description + Name combination.

            [Display]
            public int NothingSet { get; set; }

            [Display(Name = "")]
            public int EmptyDisplayName { get; set; }

            [Display(Description = "Description text1")]
            public int DescriptionSet { get; set; }

            [Display(Name = "Name text1")]
            public int NameSet { get; set; }

            [DisplayName("Just DisplayName")]
            public int DisplayNameSet { get; set; }

            [Display(Description = "Description text2", Name = "Name text2")]
            [DisplayName("This won't be used")]
            public int BothSet { get; set; }

            [Display(Name = "String1", ResourceType = typeof(Resources))]
            public int Localized { get; set; }

            [Display]
            [DisplayName("Fallback")]
            public int FallbackToDisplayName { get; set; }

            [Display]
            public int FallbackToProperty { get; set; }

            [DisplayName(null)]
            public int FallbackToPropertyFromDisplayName { get; set; }

            [DisplayName]
            public int DisplayNameDefault { get; set; }
        }

        // [ReadOnly] & [Editable] tests
        private class ReadOnlyModel
        {
            public int NoAttributes { get; set; }

            [ReadOnly(true)]
            public int ReadOnlyAttribute { get; set; }

            [Editable(false)]
            public int EditableAttribute { get; set; }

            [ReadOnly(true)]
            [Editable(true)]
            public int BothAttributes { get; set; }

            // Editable trumps ReadOnly
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/ArrayModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class ArrayModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.IsType<ArrayModelBinder<int>>(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ICollection<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/ArrayModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding.Binders
{
    public class ArrayModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object));

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "someName[0]", "42" },
                    { "someName[1]", "84" }
                }
            };
            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                    return true;
                });

            // Act
            bool retVal = new ArrayModelBinder<int>().BindModel(context, bindingContext);

            // Assert
            Assert.True(retVal);

            int[] array = bindingContext.Model as int[];
            Assert.Equal(new[] { 42, 84 }, array);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainPrefix_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider()
            };

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);
            bool bound = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(bound);
        }

        [Fact]
        public void GetBinder_ModelMetadataReturnsReadOnly_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo[0]", "42" },
                }
            };
            bindingContext.ModelMetadata.IsReadOnly = true;

            ArrayModelBinderProvider binderProvider = new ArrayModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);
            bool bound = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(bound);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/CollectionModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    public class CollectionModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IEnumerable<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.IsType<CollectionModelBinder<int>>(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsNullable_ReturnsNull()
        {
            // Arrange
            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, typeof(int?));

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsGeneric_ReturnsNull()
        {
            // Arrange
            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, typeof(Tuple<int>));

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainPrefix_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IEnumerable<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider()
            };

            CollectionModelBinderProvider binderProvider = new CollectionModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);
            bool bound = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(bound);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/CollectionModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Util;
using System.Web.Http.Validation;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class CollectionModelBinderTest
    {
        [Fact]
        public void BindComplexCollectionFromIndexes_FiniteIndexes()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "someName[foo]", "42" },
                    { "someName[baz]", "200" }
                }
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object));

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                    return true;
                });

            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindComplexCollectionFromIndexes(context, bindingContext, new[] { "foo", "bar", "baz" });

            // Assert
            Assert.Equal(new[] { 42, 0, 200 }, boundCollection.ToArray());
            Assert.Equal(new[] { "someName[foo]", "someName[baz]" }, bindingContext.ValidationNode.ChildNodes.Select(o => o.ModelStateKey).ToArray());
        }

        [Fact]
        public void BindComplexCollectionFromIndexes_InfiniteIndexes()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "someName[0]", "42" },
                    { "someName[1]", "100" },
                    { "someName[3]", "400" }
                }
            };

            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object));

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                    return true;
                });

            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindComplexCollectionFromIndexes(context, bindingContext, null /* indexNames */);

            // Assert
            Assert.Equal(new[] { 42, 100 }, boundCollection.ToArray());
            Assert.Equal(new[] { "someName[0]", "someName[1]" }, bindingContext.ValidationNode.ChildNodes.Select(o => o.ModelStateKey).ToArray());
        }

        [Fact]
        public void BindModel_ComplexCollection()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "someName.index", new[] { "foo", "bar", "baz" } },
                    { "someName[foo]", "42" },
                    { "someName[bar]", "100" },
                    { "someName[baz]", "200" }
                }
            };

            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object));

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                    return true;
                });

            CollectionModelBinder<int> modelBinder = new CollectionModelBinder<int>();

            // Act
            bool retVal = modelBinder.BindModel(context, bindingContext);

            // Assert
            Assert.Equal(new[] { 42, 100, 200 }, ((List<int>)bindingContext.Model).ToArray());
        }

        [Fact]
        public void BindModel_SimpleCollection()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "someName", new[] { "42", "100", "200" } }
                }
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object));

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                    return true;
                });

            CollectionModelBinder<int> modelBinder = new CollectionModelBinder<int>();

            // Act
            bool retVal = modelBinder.BindModel(context, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(new[] { 42, 100, 200 }, ((List<int>)bindingContext.Model).ToArray());
        }

        [Fact]
        public void BindSimpleCollection_RawValueIsEmptyCollection_ReturnsEmptyList()
        {
            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindSimpleCollection(null, null, new object[0], null);

            // Assert
            Assert.NotNull(boundCollection);
            Assert.Empty(boundCollection);
        }

        [Fact]
        public void BindSimpleCollection_RawValueIsNull_ReturnsNull()
        {
            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindSimpleCollection(null, null, null, null);

            // Assert
            Assert.Null(boundCollection);
        }

        [Fact]
        public void BindSimpleCollection_SubBindingSucceeds()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider()
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object));

            ModelValidationNode childValidationNode = null;
            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    Assert.Equal("someName", mbc.ModelName);
                    childValidationNode = mbc.ValidationNode;
                    mbc.Model = 42;
                    return true;
                });

            // Act
            List<int> boundCollection = CollectionModelBinder<int>.BindSimpleCollection(context, bindingContext, new int[1], culture);

            // Assert
            Assert.Equal(new[] { 42 }, boundCollection.ToArray());
            Assert.Equal(new[] { childValidationNode }, bindingContext.ValidationNode.ChildNodes.ToArray());
        }

        [Fact]
        public void BindingUnboundedCollection_WhenNoValuesArePresent_ProducesSingleEntryCollection()
        {
            // Arrange
            string propertyName = "Addresses";
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(
                                                            modelAccessor: null,
                                                            containerType: typeof(UserWithAddress),
                                                            propertyName: propertyName);
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = modelMetadata,
                ModelName = propertyName,
                ValueProvider = new SimpleHttpValueProvider { { propertyName, "some value" } }
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            CollectionModelBinder<UserWithAddress> binder = new CollectionModelBinder<UserWithAddress>();

            // Act
            bool result = binder.BindModel(context, bindingContext);

            // Assert
            Assert.True(result);
            List<UserWithAddress> boundModel = Assert.IsType<List<UserWithAddress>>(bindingContext.Model);
            UserWithAddress listModel = Assert.Single(boundModel);
            Assert.Null(listModel.Addresses);
        }

        [Fact]
        public void BindingNestedUnboundedCollection_WhenNoValuesArePresent_ProducesEmptyCollection()
        {
            // Arrange
            string propertyName = "Addresses";
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(
                                                            modelAccessor: null,
                                                            containerType: typeof(UserWithAddress),
                                                            propertyName: propertyName);
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = modelMetadata,
                ModelName = propertyName,
                ValueProvider = new SimpleHttpValueProvider { { "Addresses.AddressLines", "some value" } }
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            CollectionModelBinder<UserWithAddress> binder = new CollectionModelBinder<UserWithAddress>();

            // Act
            bool result = binder.BindModel(context, bindingContext);

            // Assert
            Assert.True(result);
            List<UserWithAddress> boundModel = Assert.IsType<List<UserWithAddress>>(bindingContext.Model);
            Assert.Empty(boundModel);
        }

        [Fact]
        public void BindingListsWithIndex_ProducesSingleLengthCollection_WithNullValues()
        {
            // Arrange
            string propertyName = "Addresses";
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(
                                                            modelAccessor: null,
                                                            containerType: typeof(UserWithAddress),
                                                            propertyName: propertyName);
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = modelMetadata,
                ModelName = propertyName,
                ValueProvider = new SimpleHttpValueProvider { { "Addresses.index", "10000" } }
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            CollectionModelBinder<UserWithAddress> binder = new CollectionModelBinder<UserWithAddress>();

            // Act
            bool result = binder.BindModel(context, bindingContext);

            // Assert
            Assert.True(result);
            List<UserWithAddress> boundModel = Assert.IsType<List<UserWithAddress>>(bindingContext.Model);
            UserWithAddress listModel = Assert.Single(boundModel);
            Assert.Null(listModel);
        }

        [Fact]
        public void BindingUnboundedCollection_WithRecursiveRelation_ProducesSingleLengthCollection()
        {
            // Arrange
            string propertyName = "People";
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(
                                                            modelAccessor: null,
                                                            containerType: typeof(PeopleModel),
                                                            propertyName: propertyName);
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = modelMetadata,
                ModelName = propertyName,
                ValueProvider = new SimpleHttpValueProvider { { propertyName, "test value" } }
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            CollectionModelBinder<Person> binder =
                new CollectionModelBinder<Person>();

            // Act
            bool result = binder.BindModel(context, bindingContext);

            // Assert
            Assert.True(result);
            List<Person> boundModel = Assert.IsType<List<Person>>(bindingContext.Model);
            Person type = Assert.Single(boundModel);
            Assert.Null(type.Name);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/ComplexModelDtoModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class ComplexModelDtoModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_TypeDoesNotMatch_ReturnsNull()
        {
            // Arrange
            ComplexModelDtoModelBinderProvider provider = new ComplexModelDtoModelBinderProvider();
            ModelBindingContext bindingContext = GetBindingContext(typeof(object));

            // Act
            IModelBinder binder = provider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        private static ModelBindingContext GetBindingContext(Type modelType)
        {
            return new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => null, modelType)
            };
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/ComplexModelDtoModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Validation;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding.Binders
{
    public class ComplexModelDtoModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            MyModel model = new MyModel();
            ModelMetadata modelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(MyModel));
            ComplexModelDto dto = new ComplexModelDto(modelMetadata, modelMetadata.Properties);
            Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            Mock<IModelBinder> mockDateTimeBinder = new Mock<IModelBinder>();
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.ReplaceRange(typeof(ModelBinderProvider),
                new ModelBinderProvider[] {
                    new SimpleModelBinderProvider(typeof(string), mockStringBinder.Object) { SuppressPrefixCheck = true },
                    new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object) { SuppressPrefixCheck = true },
                    new SimpleModelBinderProvider(typeof(DateTime), mockDateTimeBinder.Object) { SuppressPrefixCheck = true }
                });

            mockStringBinder
                .Setup(b => b.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    Assert.Equal(typeof(string), mbc.ModelType);
                    Assert.Equal("theModel.StringProperty", mbc.ModelName);
                    mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.StringProperty");
                    mbc.Model = "someStringValue";
                    return true;
                });
            mockIntBinder
                .Setup(b => b.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    Assert.Equal(typeof(int), mbc.ModelType);
                    Assert.Equal("theModel.IntProperty", mbc.ModelName);
                    mbc.ValidationNode = new ModelValidationNode(mbc.ModelMetadata, "theModel.IntProperty");
                    mbc.Model = 42;
                    return true;
                });
            mockDateTimeBinder
                .Setup(b => b.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext ec, ModelBindingContext mbc) =>
                {
                    Assert.Equal(typeof(DateTime), mbc.ModelType);
                    Assert.Equal("theModel.DateTimeProperty", mbc.ModelName);
                    return false;
                });
            ModelBindingContext parentBindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => dto, typeof(ComplexModelDto)),
                ModelName = "theModel",
            };
            ComplexModelDtoModelBinder binder = new ComplexModelDtoModelBinder();

            // Act
            bool retVal = binder.BindModel(context, parentBindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(dto, parentBindingContext.Model);

            ComplexModelDtoResult stringDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(string)).First()];
            Assert.Equal("someStringValue", stringDtoResult.Model);
            Assert.Equal("theModel.StringProperty", stringDtoResult.ValidationNode.ModelStateKey);

            ComplexModelDtoResult intDtoResult = dto.Results[dto.PropertyMetadata.Where(m => m.ModelType == typeof(int)).First()];
            Assert.Equal(42, intDtoResult.Model);
            Assert.Equal("theModel.IntProperty", intDtoResult.ValidationNode.ModelStateKey);

            // Bind failed, so DateTime won't even be in the DTO dictionary
            bool containsMissingKey = dto.Results.ContainsKey(dto.PropertyMetadata.Where(m => m.ModelType == typeof(DateTime)).First());
            Assert.False(containsMissingKey);
        }

        private sealed class MyModel
        {
            public string StringProperty { get; set; }
            public int IntProperty { get; set; }
            public object ObjectProperty { get; set; } // no binding should happen since no registered binder
            public DateTime DateTimeProperty { get; set; } // registered binder returns false
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/ComplexModelDtoResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Validation;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class ComplexModelDtoResultTest
    {
        [Fact]
        public void Constructor_ThrowsIfValidationNodeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new ComplexModelDtoResult("some string", null),
                "validationNode");
        }

        [Fact]
        public void Constructor_SetsProperties()
        {
            // Arrange
            ModelValidationNode validationNode = GetValidationNode();

            // Act
            ComplexModelDtoResult result = new ComplexModelDtoResult("some string", validationNode);

            // Assert
            Assert.Equal("some string", result.Model);
            Assert.Equal(validationNode, result.ValidationNode);
        }

        private static ModelValidationNode GetValidationNode()
        {
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = provider.GetMetadataForType(null, typeof(object));
            return new ModelValidationNode(metadata, "someKey");
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/ComplexModelDtoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class ComplexModelDtoTest
    {
        [Fact]
        public void ConstructorThrowsIfModelMetadataIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new ComplexModelDto(null, Enumerable.Empty<ModelMetadata>()),
                "modelMetadata");
        }

        [Fact]
        public void ConstructorThrowsIfPropertyMetadataIsNull()
        {
            // Arrange
            ModelMetadata modelMetadata = GetModelMetadata();

            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new ComplexModelDto(modelMetadata, null),
                "propertyMetadata");
        }

        [Fact]
        public void ConstructorSetsProperties()
        {
            // Arrange
            ModelMetadata modelMetadata = GetModelMetadata();
            ModelMetadata[] propertyMetadata = new ModelMetadata[0];

            // Act
            ComplexModelDto dto = new ComplexModelDto(modelMetadata, propertyMetadata);

            // Assert
            Assert.Equal(modelMetadata, dto.ModelMetadata);
            Assert.Equal(propertyMetadata, dto.PropertyMetadata.ToArray());
            Assert.Empty(dto.Results);
        }

        private static ModelMetadata GetModelMetadata()
        {
            return new ModelMetadata(new EmptyModelMetadataProvider(), typeof(object), null, typeof(object), "PropertyName");
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/DictionaryModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class DictionaryModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.IsType<DictionaryModelBinder<int, string>>(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo[0]", "42" },
                }
            };

            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsNullable_ReturnsNull()
        {
            // Arrange
            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, typeof(int?));

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsGeneric_ReturnsNull()
        {
            // Arrange
            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, typeof(Tuple<int>));

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_ValueProviderDoesNotContainPrefix_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider()
            };

            DictionaryModelBinderProvider binderProvider = new DictionaryModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);
            bool bound = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(bound);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/DictionaryModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding.Binders
{
    public class DictionaryModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            Mock<IModelBinder> mockKvpBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(IDictionary<int, string>)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "someName[0]", new KeyValuePair<int, string>(42, "forty-two") },
                    { "someName[1]", new KeyValuePair<int, string>(84, "eighty-four") }
                }
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), (new SimpleModelBinderProvider(typeof(KeyValuePair<int, string>), mockKvpBinder.Object)));

            mockKvpBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext cc, ModelBindingContext mbc) =>
                {
                    mbc.Model = mbc.ValueProvider.GetValue(mbc.ModelName).ConvertTo(mbc.ModelType);
                    return true;
                });

            // Act
            bool retVal = new DictionaryModelBinder<int, string>().BindModel(context, bindingContext);

            // Assert
            Assert.True(retVal);

            var dictionary = Assert.IsAssignableFrom<IDictionary<int, string>>(bindingContext.Model);
            Assert.NotNull(dictionary);
            Assert.Equal(2, dictionary.Count);
            Assert.Equal("forty-two", dictionary[42]);
            Assert.Equal("eighty-four", dictionary[84]);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/KeyValuePairModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class KeyValuePairModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_CorrectModelTypeAndValueProviderEntries_ReturnsBinder()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo.key", 42 },
                    { "foo.value", "someValue" }
                }
            };

            KeyValuePairModelBinderProvider binderProvider = new KeyValuePairModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.IsType<KeyValuePairModelBinder<int, string>>(binder);
        }

        [Fact]
        public void GetBinder_ModelTypeIsIncorrect_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo.key", 42 },
                    { "foo.value", "someValue" }
                }
            };

            KeyValuePairModelBinderProvider binderProvider = new KeyValuePairModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/KeyValuePairModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding.Binders
{
    public class KeyValuePairModelBinderTest
    {
        [Fact]
        public void BindModel_MissingKey_ReturnsFalse()
        {
            // Arrange
            KeyValuePairModelBinder<int, string> binder = new KeyValuePairModelBinder<int, string>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider()
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(KeyValuePair<int, string>), binder));

            // Act
            bool retVal = binder.BindModel(context, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Null(bindingContext.Model);
            Assert.Empty(bindingContext.ValidationNode.ChildNodes);
        }

        [Fact]
        public void BindModel_MissingValue_ReturnsTrue()
        {
            // Arrange
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider()
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object) { SuppressPrefixCheck = true });

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext cc, ModelBindingContext mbc) =>
                {
                    mbc.Model = 42;
                    return true;
                });
            KeyValuePairModelBinder<int, string> binder = new KeyValuePairModelBinder<int, string>();

            // Act
            bool retVal = binder.BindModel(context, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Null(bindingContext.Model);
            Assert.Equal(new[] { "someName.key" }, bindingContext.ValidationNode.ChildNodes.Select(n => n.ModelStateKey).ToArray());
        }

        [Fact]
        public void BindModel_SubBindingSucceeds()
        {
            // Arrange
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(KeyValuePair<int, string>)),
                ModelName = "someName",
                ValueProvider = new SimpleHttpValueProvider()
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.ReplaceRange(typeof(ModelBinderProvider),
                new ModelBinderProvider[] {
                    new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object) { SuppressPrefixCheck = true },
                    new SimpleModelBinderProvider(typeof(string), mockStringBinder.Object) { SuppressPrefixCheck = true }
                });

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext cc, ModelBindingContext mbc) =>
                {
                    mbc.Model = 42;
                    return true;
                });
            mockStringBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext cc, ModelBindingContext mbc) =>
                {
                    mbc.Model = "forty-two";
                    return true;
                });
            KeyValuePairModelBinder<int, string> binder = new KeyValuePairModelBinder<int, string>();

            // Act
            bool retVal = binder.BindModel(context, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(new KeyValuePair<int, string>(42, "forty-two"), bindingContext.Model);
            Assert.Equal(new[] { "someName.key", "someName.value" }, bindingContext.ValidationNode.ChildNodes.Select(n => n.ModelStateKey).ToArray());
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/KeyValuePairModelBinderUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding.Binders
{
    public class KeyValuePairModelBinderUtilTest
    {
        [Fact]
        public void TryBindStrongModel_BinderExists_BinderReturnsCorrectlyTypedObject_ReturnsTrue()
        {
            // Arrange
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelState = new ModelStateDictionary(),
                ValueProvider = new SimpleHttpValueProvider()
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object) { SuppressPrefixCheck = true });

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext cc, ModelBindingContext mbc) =>
                {
                    Assert.Equal("someName.key", mbc.ModelName);
                    mbc.Model = 42;
                    return true;
                });

            // Act
            int model;
            bool retVal = context.TryBindStrongModel(bindingContext, "key", new EmptyModelMetadataProvider(), out model);

            // Assert
            Assert.True(retVal);
            Assert.Equal(42, model);
            Assert.Single(bindingContext.ValidationNode.ChildNodes);
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void TryBindStrongModel_BinderExists_BinderReturnsIncorrectlyTypedObject_ReturnsTrue()
        {
            // Arrange
            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelState = new ModelStateDictionary(),
                ValueProvider = new SimpleHttpValueProvider()
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(int), mockIntBinder.Object) { SuppressPrefixCheck = true });

            mockIntBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext cc, ModelBindingContext mbc) =>
                {
                    Assert.Equal("someName.key", mbc.ModelName);
                    return true;
                });

            // Act
            int model;
            bool retVal = context.TryBindStrongModel(bindingContext, "key", new EmptyModelMetadataProvider(), out model);

            // Assert
            Assert.True(retVal);
            Assert.Equal(default(int), model);
            Assert.Single(bindingContext.ValidationNode.ChildNodes);
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void TryBindStrongModel_NoBinder_ReturnsFalse()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                ModelState = new ModelStateDictionary(),
                ValueProvider = new SimpleHttpValueProvider()
            };

            // Act
            int model;
            bool retVal = context.TryBindStrongModel(bindingContext, "key", new EmptyModelMetadataProvider(), out model);

            // Assert
            Assert.False(retVal);
            Assert.Equal(default(int), model);
            Assert.Empty(bindingContext.ValidationNode.ChildNodes);
            Assert.Empty(bindingContext.ModelState);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/MutableObjectModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class MutableObjectModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_NoPrefixInValueProvider_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => 42, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider()
            };

            MutableObjectModelBinderProvider binderProvider = new MutableObjectModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_PrefixInValueProvider_ComplexType_ReturnsBinder()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => new MutableTestType(), typeof(MutableTestType)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo.bar", "someValue" }
                }
            };

            MutableObjectModelBinderProvider binderProvider = new MutableObjectModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.NotNull(binder);
            Assert.IsType<MutableObjectModelBinder>(binder);
        }

        [Fact]
        public void GetBinder_PrefixInValueProvider_SimpleType_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => 42, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo.bar", "someValue" }
                }
            };

            MutableObjectModelBinderProvider binderProvider = new MutableObjectModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_TypeIsComplexModelDto_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(ComplexModelDto)),
                ModelName = "foo",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "foo.bar", "someValue" }
                }
            };

            MutableObjectModelBinderProvider binderProvider = new MutableObjectModelBinderProvider();

            // Act
            IModelBinder binder = binderProvider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        class MutableTestType
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/MutableObjectModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Validation;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding.Binders
{
    public class MutableObjectModelBinderTest
    {
        [Fact]
        public void BindModel()
        {
            // Arrange
            Mock<IValueProvider> mockValueProvider = new Mock<IValueProvider>();
            mockValueProvider.Setup(o => o.ContainsPrefix(It.IsAny<string>())).Returns(true);

            Mock<IModelBinder> mockDtoBinder = new Mock<IModelBinder>();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person()),
                ModelName = "someName",
                ValueProvider = mockValueProvider.Object
            };
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ControllerContext.Configuration.Services.Replace(typeof(ModelBinderProvider), new SimpleModelBinderProvider(typeof(ComplexModelDto), mockDtoBinder.Object) { SuppressPrefixCheck = true });

            mockDtoBinder
                .Setup(o => o.BindModel(context, It.IsAny<ModelBindingContext>()))
                .Returns((HttpActionContext cc, ModelBindingContext mbc2) =>
                {
                    return true; // just return the DTO unchanged
                });

            Mock<TestableMutableObjectModelBinder> mockTestableBinder = new Mock<TestableMutableObjectModelBinder> { CallBase = true };
            mockTestableBinder.Setup(o => o.EnsureModelPublic(context, bindingContext)).Verifiable();
            mockTestableBinder.Setup(o => o.GetMetadataForPropertiesPublic(context, bindingContext)).Returns(new ModelMetadata[0]).Verifiable();
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;
            testableBinder.MetadataProvider = new DataAnnotationsModelMetadataProvider();

            // Act
            bool retValue = testableBinder.BindModel(context, bindingContext);

            // Assert
            Assert.True(retValue);
            Assert.IsType<Person>(bindingContext.Model);
            Assert.True(bindingContext.ValidationNode.ValidateAllProperties);
            mockTestableBinder.Verify();
        }

        [Fact]
        public void CanUpdateProperty_HasPublicSetter_ReturnsTrue()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadWriteString");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.True(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyArray_ReturnsFalse()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyArray");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.False(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyReferenceTypeNotBlacklisted_ReturnsTrue()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyObject");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.True(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyString_ReturnsFalse()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyString");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.False(canUpdate);
        }

        [Fact]
        public void CanUpdateProperty_ReadOnlyValueType_ReturnsFalse()
        {
            // Arrange
            ModelMetadata propertyMetadata = GetMetadataForCanUpdateProperty("ReadOnlyInt");

            // Act
            bool canUpdate = MutableObjectModelBinder.CanUpdatePropertyInternal(propertyMetadata);

            // Assert
            Assert.False(canUpdate);
        }

        [Fact]
        public void CreateModel()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            object retModel = testableBinder.CreateModelPublic(null, bindingContext);

            // Assert
            Assert.IsType<Person>(retModel);
        }

        [Fact]
        public void EnsureModel_ModelIsNotNull_DoesNothing()
        {
            // Arrange
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person())
            };

            Mock<TestableMutableObjectModelBinder> mockTestableBinder = new Mock<TestableMutableObjectModelBinder> { CallBase = true };
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;

            // Act
            object originalModel = bindingContext.Model;
            testableBinder.EnsureModelPublic(null, bindingContext);
            object newModel = bindingContext.Model;

            // Assert
            Assert.Same(originalModel, newModel);
            mockTestableBinder.Verify(o => o.CreateModelPublic(actionContext, bindingContext), Times.Never());
        }

        [Fact]
        public void EnsureModel_ModelIsNull_CallsCreateModel()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            Mock<TestableMutableObjectModelBinder> mockTestableBinder = new Mock<TestableMutableObjectModelBinder> { CallBase = true };
            mockTestableBinder.Setup(o => o.CreateModelPublic(null, bindingContext)).Returns(new Person()).Verifiable();
            TestableMutableObjectModelBinder testableBinder = mockTestableBinder.Object;

            // Act
            object originalModel = bindingContext.Model;
            testableBinder.EnsureModelPublic(null, bindingContext);
            object newModel = bindingContext.Model;

            // Assert
            Assert.Null(originalModel);
            Assert.IsType<Person>(newModel);
            mockTestableBinder.Verify();
        }

        [Fact]
        public void GetMetadataForProperties_WithBindAttribute()
        {
            // Arrange
            string[] expectedPropertyNames = new[] { "FirstName", "LastName" };

            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(PersonWithBindExclusion))
            };

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            IEnumerable<ModelMetadata> propertyMetadatas = testableBinder.GetMetadataForPropertiesPublic(actionContext, bindingContext);
            string[] returnedPropertyNames = propertyMetadatas.Select(o => o.PropertyName).ToArray();

            // Assert
            Assert.Equal(expectedPropertyNames, returnedPropertyNames);
        }

        [Fact]
        public void GetMetadataForProperties_WithoutBindAttribute()
        {
            // Arrange
            string[] expectedPropertyNames = new[] { "DateOfBirth", "DateOfDeath", "ValueTypeRequired", "FirstName", "LastName", "PropertyWithDefaultValue" };

            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            IEnumerable<ModelMetadata> propertyMetadatas = testableBinder.GetMetadataForPropertiesPublic(actionContext, bindingContext);
            string[] returnedPropertyNames = propertyMetadatas.Select(o => o.PropertyName).ToArray();

            // Assert
            Assert.Equal(expectedPropertyNames, returnedPropertyNames);
        }

        [Fact]
        public void GetRequiredPropertiesCollection_MixedAttributes()
        {
            // Arrange
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new ModelWithMixedBindingBehaviors())
            };

            // Act
            HashSet<string> requiredProperties;
            Dictionary<string, ModelValidator> requiredValidators;
            HashSet<string> skipProperties;
            MutableObjectModelBinder.GetRequiredPropertiesCollection(actionContext, bindingContext, out requiredProperties, out requiredValidators, out skipProperties);

            // Assert
            Assert.Equal(new[] { "Required" }, requiredProperties.ToArray());
            Assert.Equal(new[] { "Never" }, skipProperties.ToArray());
        }

        [Fact]
        public void NullCheckFailedHandler_ModelStateAlreadyInvalid_DoesNothing()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            context.ModelState.AddModelError("foo.bar", "Some existing error.");

            ModelMetadata modelMetadata = GetMetadataForType(typeof(Person));
            ModelValidationNode validationNode = new ModelValidationNode(modelMetadata, "foo");
            ModelValidatedEventArgs e = new ModelValidatedEventArgs(context, null /* parentNode */);

            // Act
            EventHandler<ModelValidatedEventArgs> handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(modelMetadata, null /* incomingValue */);
            handler(validationNode, e);

            // Assert
            Assert.False(context.ModelState.ContainsKey("foo"));
        }

        [Fact]
        public void NullCheckFailedHandler_ModelStateValid_AddsErrorString()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelMetadata modelMetadata = GetMetadataForType(typeof(Person));
            ModelValidationNode validationNode = new ModelValidationNode(modelMetadata, "foo");
            ModelValidatedEventArgs e = new ModelValidatedEventArgs(context, null /* parentNode */);

            // Act
            EventHandler<ModelValidatedEventArgs> handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(modelMetadata, null /* incomingValue */);
            handler(validationNode, e);

            // Assert
            Assert.True(context.ModelState.ContainsKey("foo"));
            Assert.Equal("A value is required.", context.ModelState["foo"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void NullCheckFailedHandler_ModelStateValid_CallbackReturnsNull_DoesNothing()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelMetadata modelMetadata = GetMetadataForType(typeof(Person));
            ModelValidationNode validationNode = new ModelValidationNode(modelMetadata, "foo");
            ModelValidatedEventArgs e = new ModelValidatedEventArgs(context, null /* parentNode */);

            // Act
            ModelBinderErrorMessageProvider originalProvider = ModelBinderConfig.ValueRequiredErrorMessageProvider;
            try
            {
                ModelBinderConfig.ValueRequiredErrorMessageProvider = (ec, mm, value) => null;
                EventHandler<ModelValidatedEventArgs> handler = MutableObjectModelBinder.CreateNullCheckFailedHandler(modelMetadata, null /* incomingValue */);
                handler(validationNode, e);
            }
            finally
            {
                ModelBinderConfig.ValueRequiredErrorMessageProvider = originalProvider;
            }

            // Assert
            Assert.True(context.ModelState.IsValid);
        }

        [Fact]
        [ReplaceCulture]
        public void ProcessDto_BindRequiredFieldMissing_RaisesModelError()
        {
            // Arrange
            ModelWithBindRequired model = new ModelWithBindRequired
            {
                Name = "original value",
                Age = -20
            };

            ModelMetadata containerMetadata = GetMetadataForObject(model);

            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = containerMetadata,
                ModelName = "theModel"
            };
            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);

            ModelMetadata nameProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "Name");
            dto.Results[nameProperty] = new ComplexModelDtoResult("John Doe", new ModelValidationNode(nameProperty, ""));

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.ProcessDto(context, bindingContext, dto);

            // Assert
            ModelStateDictionary modelStateDictionary = bindingContext.ModelState;
            Assert.False(modelStateDictionary.IsValid);
            Assert.Single(modelStateDictionary);

            // Check Age error.
            ModelState modelState;
            Assert.True(modelStateDictionary.TryGetValue("theModel.Age", out modelState));

            ModelError modelError = Assert.Single(modelState.Errors);
            Assert.Null(modelError.Exception);
            Assert.NotNull(modelError.ErrorMessage);
            Assert.Equal("The Age property is required.", modelError.ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void ProcessDto_BindRequiredFieldNull_RaisesModelError()
        {
            // Arrange
            ModelWithBindRequired model = new ModelWithBindRequired
            {
                Name = "original value",
                Age = -20
            };

            ModelMetadata containerMetadata = GetMetadataForObject(model);
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = containerMetadata,
                ModelName = "theModel",
                ModelState = context.ModelState,
            };

            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);
            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            ModelMetadata propertyMetadata = dto.PropertyMetadata.Single(o => o.PropertyName == "Name");
            dto.Results[propertyMetadata] =
                new ComplexModelDtoResult("John Doe", new ModelValidationNode(propertyMetadata, "theModel.Name"));

            // Attempt to set non-Nullable property to null.  HttpBindRequiredAttribute should not be relevant in this
            // case because the binding exists.
            propertyMetadata = dto.PropertyMetadata.Single(o => o.PropertyName == "Age");
            dto.Results[propertyMetadata] =
                new ComplexModelDtoResult(null, new ModelValidationNode(propertyMetadata, "theModel.Age"));

            // Act; must also Validate because null-check error handler is late-bound
            testableBinder.ProcessDto(context, bindingContext, dto);
            bindingContext.ValidationNode.Validate(context);

            // Assert
            ModelStateDictionary modelStateDictionary = bindingContext.ModelState;
            Assert.False(modelStateDictionary.IsValid);
            Assert.Single(modelStateDictionary);

            // Check Age error.
            ModelState modelState;
            Assert.True(modelStateDictionary.TryGetValue("theModel.Age", out modelState));

            ModelError modelError = Assert.Single(modelState.Errors);
            Assert.Null(modelError.Exception);
            Assert.NotNull(modelError.ErrorMessage);
            Assert.Equal("A value is required.", modelError.ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void ProcessDto_RequiredFieldMissing_RaisesModelError()
        {
            // Arrange
            ModelWithRequired model = new ModelWithRequired();
            ModelMetadata containerMetadata = GetMetadataForObject(model);
            HttpActionContext context = ContextUtil.CreateActionContext();

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = containerMetadata,
                ModelName = "theModel"
            };

            // Set no properties though Age (a non-Nullable struct) and City (a class) properties are required.
            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);
            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.ProcessDto(context, bindingContext, dto);

            // Assert
            ModelStateDictionary modelStateDictionary = bindingContext.ModelState;
            Assert.False(modelStateDictionary.IsValid);
            Assert.Equal(2, modelStateDictionary.Count);

            // Check Age error.
            ModelState modelState;
            Assert.True(modelStateDictionary.TryGetValue("theModel.Age", out modelState));

            ModelError modelError = Assert.Single(modelState.Errors);
            Assert.Null(modelError.Exception);
            Assert.NotNull(modelError.ErrorMessage);
            Assert.Equal("The Age field is required.", modelError.ErrorMessage);

            // Check City error.
            Assert.True(modelStateDictionary.TryGetValue("theModel.City", out modelState));

            modelError = Assert.Single(modelState.Errors);
            Assert.Null(modelError.Exception);
            Assert.NotNull(modelError.ErrorMessage);
            Assert.Equal("The City field is required.", modelError.ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void ProcessDto_RequiredFieldNull_RaisesModelError()
        {
            // Arrange
            ModelWithRequired model = new ModelWithRequired();
            ModelMetadata containerMetadata = GetMetadataForObject(model);
            HttpActionContext context = ContextUtil.CreateActionContext();

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = containerMetadata,
                ModelName = "theModel"
            };

            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);
            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Make Age valid and City invalid.
            ModelMetadata propertyMetadata = dto.PropertyMetadata.Single(p => p.PropertyName == "Age");
            dto.Results[propertyMetadata] =
                new ComplexModelDtoResult(23, new ModelValidationNode(propertyMetadata, "theModel.Age"));
            propertyMetadata = dto.PropertyMetadata.Single(p => p.PropertyName == "City");
            dto.Results[propertyMetadata] =
                new ComplexModelDtoResult(null, new ModelValidationNode(propertyMetadata, "theModel.City"));

            // Act
            testableBinder.ProcessDto(context, bindingContext, dto);

            // Assert
            ModelStateDictionary modelStateDictionary = bindingContext.ModelState;
            Assert.False(modelStateDictionary.IsValid);
            Assert.Single(modelStateDictionary);

            // Check City error.
            ModelState modelState;
            Assert.True(modelStateDictionary.TryGetValue("theModel.City", out modelState));

            ModelError modelError = Assert.Single(modelState.Errors);
            Assert.Null(modelError.Exception);
            Assert.NotNull(modelError.ErrorMessage);
            Assert.Equal("The City field is required.", modelError.ErrorMessage);
        }

        [Fact]
        public void ProcessDto_RequiredFieldMissing_RaisesModelErrorWithMessage()
        {
            // Arrange
            Person model = new Person();
            ModelMetadata containerMetadata = GetMetadataForObject(model);
            HttpActionContext context = ContextUtil.CreateActionContext();

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = containerMetadata,
                ModelName = "theModel"
            };

            // Set no properties though ValueTypeRequired (a non-Nullable struct) property is required.
            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);
            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.ProcessDto(context, bindingContext, dto);

            // Assert
            ModelStateDictionary modelStateDictionary = bindingContext.ModelState;
            Assert.False(modelStateDictionary.IsValid);
            Assert.Single(modelStateDictionary);

            // Check ValueTypeRequired error.
            ModelState modelState;
            Assert.True(modelStateDictionary.TryGetValue("theModel.ValueTypeRequired", out modelState));

            ModelError modelError = Assert.Single(modelState.Errors);
            Assert.Null(modelError.Exception);
            Assert.NotNull(modelError.ErrorMessage);
            Assert.Equal("Sample message", modelError.ErrorMessage);
        }

        [Fact]
        public void ProcessDto_RequiredFieldNull_RaisesModelErrorWithMessage()
        {
            // Arrange
            Person model = new Person();
            ModelMetadata containerMetadata = GetMetadataForObject(model);
            HttpActionContext context = ContextUtil.CreateActionContext();

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = containerMetadata,
                ModelName = "theModel"
            };

            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);
            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Make ValueTypeRequired invalid.
            ModelMetadata propertyMetadata = dto.PropertyMetadata.Single(p => p.PropertyName == "ValueTypeRequired");
            dto.Results[propertyMetadata] =
                new ComplexModelDtoResult(null, new ModelValidationNode(propertyMetadata, "theModel.ValueTypeRequired"));

            // Act
            testableBinder.ProcessDto(context, bindingContext, dto);

            // Assert
            ModelStateDictionary modelStateDictionary = bindingContext.ModelState;
            Assert.False(modelStateDictionary.IsValid);
            Assert.Single(modelStateDictionary);

            // Check ValueTypeRequired error.
            ModelState modelState;
            Assert.True(modelStateDictionary.TryGetValue("theModel.ValueTypeRequired", out modelState));

            ModelError modelError = Assert.Single(modelState.Errors);
            Assert.Null(modelError.Exception);
            Assert.NotNull(modelError.ErrorMessage);
            Assert.Equal("Sample message", modelError.ErrorMessage);
        }

        [Fact]
        public void ProcessDto_Success()
        {
            // Arrange
            DateTime dob = new DateTime(2001, 1, 1);
            PersonWithBindExclusion model = new PersonWithBindExclusion
            {
                DateOfBirth = dob
            };
            ModelMetadata containerMetadata = GetMetadataForObject(model);

            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = containerMetadata
            };
            ComplexModelDto dto = new ComplexModelDto(containerMetadata, containerMetadata.Properties);

            ModelMetadata firstNameProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "FirstName");
            dto.Results[firstNameProperty] = new ComplexModelDtoResult("John", new ModelValidationNode(firstNameProperty, ""));
            ModelMetadata lastNameProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "LastName");
            dto.Results[lastNameProperty] = new ComplexModelDtoResult("Doe", new ModelValidationNode(lastNameProperty, ""));
            ModelMetadata dobProperty = dto.PropertyMetadata.Single(o => o.PropertyName == "DateOfBirth");
            dto.Results[dobProperty] = null;

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.ProcessDto(context, bindingContext, dto);

            // Assert
            Assert.Equal("John", model.FirstName);
            Assert.Equal("Doe", model.LastName);
            Assert.Equal(dob, model.DateOfBirth);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void SetProperty_PropertyHasDefaultValue_SetsDefaultValue()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person())
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "PropertyWithDefaultValue");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);
            ModelValidator requiredValidator = context.GetValidators(propertyMetadata).Where(v => v.IsRequired).FirstOrDefault();

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(context, bindingContext, propertyMetadata, dtoResult, requiredValidator);

            // Assert
            var person = Assert.IsType<Person>(bindingContext.Model);
            Assert.Equal(123.456m, person.PropertyWithDefaultValue);
            Assert.True(context.ModelState.IsValid);
        }

        [Fact]
        public void SetProperty_PropertyIsReadOnly_DoesNothing()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForType(typeof(Person))
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "NonUpdateableProperty");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(null, bindingContext, propertyMetadata, dtoResult, requiredValidator: null);

            // Assert
            // If didn't throw, success!
        }

        [Fact]
        public void SetProperty_PropertyIsSettable_CallsSetter()
        {
            // Arrange
            Person model = new Person();
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(model)
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "DateOfBirth");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(new DateTime(2001, 1, 1), validationNode);
            ModelValidator requiredValidator = context.GetValidators(propertyMetadata).Where(v => v.IsRequired).FirstOrDefault();

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(context, bindingContext, propertyMetadata, dtoResult, requiredValidator);

            // Assert
            validationNode.Validate(context);
            Assert.True(context.ModelState.IsValid);
            Assert.Equal(new DateTime(2001, 1, 1), model.DateOfBirth);
        }

        [Fact]
        [ReplaceCulture]
        public void SetProperty_PropertyIsSettable_SetterThrows_RecordsError()
        {
            // Arrange
            Person model = new Person
            {
                DateOfBirth = new DateTime(1900, 1, 1)
            };
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(model)
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "DateOfDeath");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(new DateTime(1800, 1, 1), validationNode);

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(null, bindingContext, propertyMetadata, dtoResult, requiredValidator: null);

            // Assert
            Assert.Equal("Date of death can't be before date of birth." + Environment.NewLine
                       + "Parameter name: value",
                         bindingContext.ModelState["foo"].Errors[0].Exception.Message);
        }

        [Fact]
        public void SetProperty_SettingNonNullableValueTypeToNull_RequiredValidatorNotPresent_RegistersValidationCallback()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person()),
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "DateOfBirth");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);
            ModelValidator requiredValidator = context.GetValidators(propertyMetadata).Where(v => v.IsRequired).FirstOrDefault();

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(context, bindingContext, propertyMetadata, dtoResult, requiredValidator);

            // Assert
            Assert.True(context.ModelState.IsValid);
            validationNode.Validate(context, bindingContext.ValidationNode);
            Assert.False(context.ModelState.IsValid);
        }

        [Fact]
        public void SetProperty_SettingNonNullableValueTypeToNull_RequiredValidatorPresent_AddsModelError()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new Person()),
                ModelName = "foo"
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "ValueTypeRequired");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo.ValueTypeRequired");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);
            ModelValidator requiredValidator = context.GetValidators(propertyMetadata).Where(v => v.IsRequired).FirstOrDefault();

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(context, bindingContext, propertyMetadata, dtoResult, requiredValidator);

            // Assert
            Assert.False(bindingContext.ModelState.IsValid);
            Assert.Equal("Sample message", bindingContext.ModelState["foo.ValueTypeRequired"].Errors[0].ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void SetProperty_SettingNullableTypeToNull_RequiredValidatorNotPresent_PropertySetterThrows_AddsRequiredMessageString()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new ModelWhosePropertySetterThrows()),
                ModelName = "foo"
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "NameNoAttribute");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo.NameNoAttribute");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);
            ModelValidator requiredValidator = context.GetValidators(propertyMetadata).Where(v => v.IsRequired).FirstOrDefault();

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(context, bindingContext, propertyMetadata, dtoResult, requiredValidator);

            // Assert
            Assert.False(bindingContext.ModelState.IsValid);
            ModelError modelError = Assert.Single(bindingContext.ModelState["foo.NameNoAttribute"].Errors);
            Assert.Equal(
                "This is a different exception." + Environment.NewLine + "Parameter name: value",
                modelError.Exception.Message);
        }

        [Fact]
        public void SetProperty_SettingNullableTypeToNull_RequiredValidatorPresent_PropertySetterThrows_AddsRequiredMessageString()
        {
            // Arrange
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadataForObject(new ModelWhosePropertySetterThrows()),
                ModelName = "foo"
            };

            ModelMetadata propertyMetadata = bindingContext.ModelMetadata.Properties.Single(o => o.PropertyName == "Name");
            ModelValidationNode validationNode = new ModelValidationNode(propertyMetadata, "foo.Name");
            ComplexModelDtoResult dtoResult = new ComplexModelDtoResult(null /* model */, validationNode);
            ModelValidator requiredValidator = context.GetValidators(propertyMetadata).Where(v => v.IsRequired).FirstOrDefault();

            TestableMutableObjectModelBinder testableBinder = new TestableMutableObjectModelBinder();

            // Act
            testableBinder.SetPropertyPublic(context, bindingContext, propertyMetadata, dtoResult, requiredValidator);

            // Assert
            Assert.False(bindingContext.ModelState.IsValid);
            ModelError modelError = Assert.Single(bindingContext.ModelState["foo.Name"].Errors);
            Assert.Equal("This message comes from the [Required] attribute.", modelError.ErrorMessage);
        }

        private static ModelMetadata GetMetadataForCanUpdateProperty(string propertyName)
        {
            DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            return metadataProvider.GetMetadataForProperty(null, typeof(MyModelTestingCanUpdateProperty), propertyName);
        }

        private static ModelMetadata GetMetadataForObject(object o)
        {
            DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            return metadataProvider.GetMetadataForType(() => o, o.GetType());
        }

        private static ModelMetadata GetMetadataForType(Type t)
        {
            DataAnnotationsModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            return metadataProvider.GetMetadataForType(null, t);
        }

        private class Person
        {
            private DateTime? _dateOfDeath;

            public DateTime DateOfBirth { get; set; }

            public DateTime? DateOfDeath
            {
                get { return _dateOfDeath; }
                set
                {
                    if (value < DateOfBirth)
                    {
                        throw new ArgumentOutOfRangeException("value", "Date of death can't be before date of birth.");
                    }
                    _dateOfDeath = value;
                }
            }

            [Required(ErrorMessage = "Sample message")]
            public int ValueTypeRequired { get; set; }

            public string FirstName { get; set; }
            public string LastName { get; set; }
            public string NonUpdateableProperty { get; private set; }

            [DefaultValue(typeof(decimal), "123.456")]
            public decimal PropertyWithDefaultValue { get; set; }
        }

        private class PersonWithBindExclusion
        {
            [HttpBindNever]
            public DateTime DateOfBirth { get; set; }

            [HttpBindNever]
            public DateTime? DateOfDeath { get; set; }

            public string FirstName { get; set; }
            public string LastName { get; set; }
            public string NonUpdateableProperty { get; private set; }
        }

        private class ModelWithRequired
        {
            public string Name { get; set; }

            [Required]
            public int Age { get; set; }

            [Required]
            public string City { get; set; }
        }

        private class ModelWithBindRequired
        {
            public string Name { get; set; }

            [HttpBindRequired]
            public int Age { get; set; }
        }

        [HttpBindRequired]
        private class ModelWithMixedBindingBehaviors
        {
            public string Required { get; set; }

            [HttpBindNever]
            public string Never { get; set; }

            [HttpBindingBehavior(HttpBindingBehavior.Optional)]
            public string Optional { get; set; }
        }

        private sealed class MyModelTestingCanUpdateProperty
        {
            public int ReadOnlyInt { get; private set; }
            public string ReadOnlyString { get; private set; }
            public string[] ReadOnlyArray { get; private set; }
            public object ReadOnlyObject { get; private set; }
            public string ReadWriteString { get; set; }
        }

        private sealed class ModelWhosePropertySetterThrows
        {
            [Required(ErrorMessage = "This message comes from the [Required] attribute.")]
            public string Name
            {
                get { return null; }
                set { throw new ArgumentException("This is an exception.", "value"); }
            }

            public string NameNoAttribute
            {
                get { return null; }
                set { throw new ArgumentException("This is a different exception.", "value"); }
            }
        }

        public class TestableMutableObjectModelBinder : MutableObjectModelBinder
        {
            public virtual bool CanUpdatePropertyPublic(ModelMetadata propertyMetadata)
            {
                return base.CanUpdateProperty(propertyMetadata);
            }

            protected override bool CanUpdateProperty(ModelMetadata propertyMetadata)
            {
                return CanUpdatePropertyPublic(propertyMetadata);
            }

            public virtual object CreateModelPublic(HttpActionContext context, ModelBindingContext bindingContext)
            {
                return base.CreateModel(context, bindingContext);
            }

            protected override object CreateModel(HttpActionContext context, ModelBindingContext bindingContext)
            {
                return CreateModelPublic(context, bindingContext);
            }

            public virtual void EnsureModelPublic(HttpActionContext context, ModelBindingContext bindingContext)
            {
                base.EnsureModel(context, bindingContext);
            }

            protected override void EnsureModel(HttpActionContext context, ModelBindingContext bindingContext)
            {
                EnsureModelPublic(context, bindingContext);
            }

            public virtual IEnumerable<ModelMetadata> GetMetadataForPropertiesPublic(HttpActionContext context, ModelBindingContext bindingContext)
            {
                return base.GetMetadataForProperties(context, bindingContext);
            }

            protected override IEnumerable<ModelMetadata> GetMetadataForProperties(HttpActionContext context, ModelBindingContext bindingContext)
            {
                return GetMetadataForPropertiesPublic(context, bindingContext);
            }

            public virtual void SetPropertyPublic(HttpActionContext context, ModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult, ModelValidator requiredValidator)
            {
                base.SetProperty(context, bindingContext, propertyMetadata, dtoResult, requiredValidator);
            }

            protected override void SetProperty(HttpActionContext actionContext, ModelBindingContext bindingContext, ModelMetadata propertyMetadata, ComplexModelDtoResult dtoResult, ModelValidator requiredValidator)
            {
                SetPropertyPublic(actionContext, bindingContext, propertyMetadata, dtoResult, requiredValidator);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/SimpleModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding.Binders
{
    public class SimpleModelBinderProviderTest
    {
        [Fact]
        public void ConstructorWithFactoryThrowsIfModelBinderFactoryIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new SimpleModelBinderProvider(typeof(object), (Func<IModelBinder>)null),
                "modelBinderFactory");
        }

        [Fact]
        public void ConstructorWithFactoryThrowsIfModelTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new SimpleModelBinderProvider(null, () => null),
                "modelType");
        }

        [Fact]
        public void ConstructorWithInstanceThrowsIfModelBinderIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new SimpleModelBinderProvider(typeof(object), (IModelBinder)null),
                "modelBinder");
        }

        [Fact]
        public void ConstructorWithInstanceThrowsIfModelTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new SimpleModelBinderProvider(null, new Mock<IModelBinder>().Object),
                "modelType");
        }

        [Fact]
        public void GetBinder_TypeDoesNotMatch_ReturnsNull()
        {
            // Arrange
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), new Mock<IModelBinder>().Object)
            {
                SuppressPrefixCheck = true
            };
            ModelBindingContext bindingContext = GetBindingContext(typeof(object));

            // Act
            IModelBinder binder = provider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_TypeMatches_PrefixNotFound_ReturnsNull()
        {
            // Arrange
            IModelBinder binderInstance = new Mock<IModelBinder>().Object;
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), binderInstance);

            ModelBindingContext bindingContext = GetBindingContext(typeof(string));
            bindingContext.ValueProvider = new SimpleHttpValueProvider();

            // Act
            IModelBinder returnedBinder = provider.GetBinder(null, bindingContext.ModelType);
            bool bound = returnedBinder.BindModel(null, bindingContext);

            // Assert
            Assert.False(bound);
        }

        [Fact]
        public void GetBinder_TypeMatches_PrefixSuppressed_ReturnsFactoryInstance()
        {
            // Arrange
            int numExecutions = 0;
            IModelBinder theBinderInstance = new Mock<IModelBinder>().Object;
            Func<IModelBinder> factory = delegate
            {
                numExecutions++;
                return theBinderInstance;
            };

            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), factory)
            {
                SuppressPrefixCheck = true
            };
            ModelBindingContext bindingContext = GetBindingContext(typeof(string));

            // Act
            IModelBinder returnedBinder = provider.GetBinder(null, bindingContext.ModelType);
            returnedBinder.BindModel(null, bindingContext);

            returnedBinder = provider.GetBinder(null, bindingContext.ModelType);
            returnedBinder.BindModel(null, bindingContext);

            // Assert
            Assert.Equal(2, numExecutions);
        }

        [Fact]
        public void GetBinder_TypeMatches_PrefixSuppressed_ReturnsInstance()
        {
            // Arrange
            IModelBinder theBinderInstance = new Mock<IModelBinder>().Object;
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), theBinderInstance)
            {
                SuppressPrefixCheck = true
            };
            ModelBindingContext bindingContext = GetBindingContext(typeof(string));

            // Act
            IModelBinder returnedBinder = provider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.NotNull(returnedBinder);
        }

        [Fact]
        public void GetBinderThrowsIfBindingContextIsNull()
        {
            // Arrange
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), new Mock<IModelBinder>().Object);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { provider.GetBinder(null, null); }, "modelType");
        }

        [Fact]
        public void ModelTypeProperty()
        {
            // Arrange
            SimpleModelBinderProvider provider = new SimpleModelBinderProvider(typeof(string), new Mock<IModelBinder>().Object);

            // Act & assert
            Assert.Equal(typeof(string), provider.ModelType);
        }

        private static ModelBindingContext GetBindingContext(Type modelType)
        {
            return new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => null, modelType)
            };
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/TypeConverterModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class TypeConverterModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_NoTypeConverterExistsFromString_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(void)); // no TypeConverter exists Void -> String

            TypeConverterModelBinderProvider provider = new TypeConverterModelBinderProvider();

            // Act
            IModelBinder binder = provider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void GetBinder_NullValueProviderResult_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleHttpValueProvider(); // clear the ValueProvider

            TypeConverterModelBinderProvider provider = new TypeConverterModelBinderProvider();

            // Act
            IModelBinder binder = provider.GetBinder(null, bindingContext.ModelType);
            bool bound = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(bound);
        }

        [Fact]
        public void GetBinder_TypeConverterExistsFromString_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(int)); // TypeConverter exists Int32 -> String

            TypeConverterModelBinderProvider provider = new TypeConverterModelBinderProvider();

            // Act
            IModelBinder binder = provider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.IsType<TypeConverterModelBinder>(binder);
        }

        private static ModelBindingContext GetBindingContext(Type modelType)
        {
            return new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName",
                ValueProvider = new SimpleHttpValueProvider
                {
                    { "theModelName", "someValue" }
                }
            };
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/TypeConverterModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Globalization;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class TypeConverterModelBinderTest
    {
        [Fact]
        public void BindModel_Error_FormatExceptionsTurnedIntoStringsInModelState()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Equal("The value 'not an integer' is not valid for Int32.", bindingContext.ModelState["theModelName"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void BindModel_Error_FormatExceptionsTurnedIntoStringsInModelState_ErrorNotAddedIfCallbackReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            ModelBinderErrorMessageProvider originalProvider = ModelBinderConfig.TypeConversionErrorMessageProvider;
            bool retVal;
            try
            {
                ModelBinderConfig.TypeConversionErrorMessageProvider = delegate { return null; };
                retVal = binder.BindModel(null, bindingContext);
            }
            finally
            {
                ModelBinderConfig.TypeConversionErrorMessageProvider = originalProvider;
            }

            // Assert
            Assert.False(retVal);
            Assert.Null(bindingContext.Model);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void BindModel_Error_GeneralExceptionsSavedInModelState()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(Dummy));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "foo" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Null(bindingContext.Model);
            Assert.Equal("The parameter conversion from type 'System.String' to type 'System.Web.Http.ModelBinding.Binders.TypeConverterModelBinderTest+Dummy' failed. See the inner exception for more information.", bindingContext.ModelState["theModelName"].Errors[0].Exception.Message);
            Assert.Equal("From DummyTypeConverter: foo", bindingContext.ModelState["theModelName"].Errors[0].Exception.InnerException.Message);
        }

        [Fact]
        public void BindModel_NullValueProviderResult_ReturnsFalse()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(int));

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal, "BindModel should have returned null.");
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ConvertEmptyStringsToNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(string));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Null(bindingContext.Model);
            Assert.True(bindingContext.ModelState.ContainsKey("theModelName"));
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ReturnsModel()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext(typeof(int));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "42" }
            };

            TypeConverterModelBinder binder = new TypeConverterModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(42, bindingContext.Model);
            Assert.True(bindingContext.ModelState.ContainsKey("theModelName"));
        }

        private static ModelBindingContext GetBindingContext(Type modelType)
        {
            return new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName",
                ValueProvider = new SimpleHttpValueProvider() // empty
            };
        }

        [TypeConverter(typeof(DummyTypeConverter))]
        private struct Dummy
        {
        }

        private sealed class DummyTypeConverter : TypeConverter
        {
            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
            {
                return (sourceType == typeof(string)) || base.CanConvertFrom(context, sourceType);
            }

            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
            {
                throw new InvalidOperationException(String.Format("From DummyTypeConverter: {0}", value));
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/TypeMatchModelBinderProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class TypeMatchModelBinderProviderTest
    {
        [Fact]
        public void GetBinder_InvalidValueProviderResult_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeMatchModelBinderProvider provider = new TypeMatchModelBinderProvider();

            // Act
            IModelBinder binder = provider.GetBinder(null, bindingContext.ModelType);
            bool bound = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(bound);
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ReturnsBinder()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", 42 }
            };

            TypeMatchModelBinderProvider provider = new TypeMatchModelBinderProvider();

            // Act
            IModelBinder binder = provider.GetBinder(null, bindingContext.ModelType);

            // Assert
            Assert.IsType<TypeMatchModelBinder>(binder);
        }

        private static ModelBindingContext GetBindingContext()
        {
            return GetBindingContext(typeof(int));
        }

        private static ModelBindingContext GetBindingContext(Type modelType)
        {
            return new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName"
            };
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/Binders/TypeMatchModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding.Binders
{
    public class TypeMatchModelBinderTest
    {
        [Fact]
        public void BindModel_InvalidValueProviderResult_ReturnsFalse()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "not an integer" }
            };

            TypeMatchModelBinder binder = new TypeMatchModelBinder();

            // Act
            bool retVal = binder.BindModel(null, bindingContext);

            // Assert
            Assert.False(retVal);
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void BindModel_ValidValueProviderResult_ReturnsTrue()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", 42 }
            };

            TypeMatchModelBinder binder = new TypeMatchModelBinder();
            HttpActionContext actionContext = new HttpActionContext
            {
                ControllerContext = new HttpControllerContext { Configuration = new HttpConfiguration() }
            };

            // Act
            bool retVal = binder.BindModel(actionContext, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Equal(42, bindingContext.Model);
            Assert.True(bindingContext.ModelState.ContainsKey("theModelName"));
        }

        [Fact]
        public void GetCompatibleValueProviderResult_ValueProviderResultRawValueIncorrect_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", "not an integer" }
            };

            // Act
            ValueProviderResult vpResult = TypeMatchModelBinder.GetCompatibleValueProviderResult(bindingContext);

            // Assert
            Assert.Null(vpResult); // Raw value is the wrong type
        }

        [Fact]
        public void GetCompatibleValueProviderResult_ValueProviderResultValid_ReturnsValueProviderResult()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", 42 }
            };

            // Act
            ValueProviderResult vpResult = TypeMatchModelBinder.GetCompatibleValueProviderResult(bindingContext);

            // Assert
            Assert.NotNull(vpResult);
        }

        [Fact]
        public void GetCompatibleValueProviderResult_ValueProviderReturnsNull_ReturnsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = GetBindingContext();
            bindingContext.ValueProvider = new SimpleHttpValueProvider();

            // Act
            ValueProviderResult vpResult = TypeMatchModelBinder.GetCompatibleValueProviderResult(bindingContext);

            // Assert
            Assert.Null(vpResult); // No key matched
        }

        [Fact]
        public void BindModel_ThrowsArgument_IfControllerContextIsNullOnActionContext()
        {
            // Arrange
            TypeMatchModelBinder binder = new TypeMatchModelBinder();
            HttpActionContext actionContext = new HttpActionContext();
            Customer model = new Customer { Age = 99999 };
            ModelBindingContext bindingContext = GetBindingContext(typeof(Customer));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", model }
            };

            // Act
            Assert.ThrowsArgument(() => binder.BindModel(actionContext, bindingContext),
                "actionContext", "HttpActionContext.ControllerContext must not be null.");
        }

        [Fact]
        public void BindModel_ThrowsArgument_IfConfigurationIsNullOnControllerContext()
        {
            // Arrange
            TypeMatchModelBinder binder = new TypeMatchModelBinder();
            HttpActionContext actionContext = new HttpActionContext { ControllerContext = new HttpControllerContext() };
            Customer model = new Customer { Age = 99999 };
            ModelBindingContext bindingContext = GetBindingContext(typeof(Customer));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", model }
            };

            // Act
            Assert.ThrowsArgument(() => binder.BindModel(actionContext, bindingContext),
                "actionContext", "HttpControllerContext.Configuration must not be null.");
        }

        [Fact]
        public void BindModel_Performs_Validation()
        {
            // Arrange
            TypeMatchModelBinder binder = new TypeMatchModelBinder();
            HttpActionContext actionContext = new HttpActionContext
            {
                ControllerContext = new HttpControllerContext { Configuration = new HttpConfiguration() }
            };

            Customer model = new Customer { Age = 99999 };
            ModelBindingContext bindingContext = GetBindingContext(typeof(Customer));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", model }
            };
            bindingContext.ModelState = actionContext.ModelState;

            // Act
            bool retVal = binder.BindModel(actionContext, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Same(model, bindingContext.Model);
            Assert.True(actionContext.ModelState.ContainsKey("theModelName"));
            Assert.False(actionContext.ModelState.IsValid);
            Assert.Equal("The field Age must be between 0 and 100.", actionContext.ModelState["theModelName.Age"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void BindModel_Performs_ValidationOnArrays()
        {
            // Arrange
            TypeMatchModelBinder binder = new TypeMatchModelBinder();
            HttpActionContext actionContext = new HttpActionContext
            {
                ControllerContext = new HttpControllerContext { Configuration = new HttpConfiguration() }
            };

            Customer[] model = new[] { new Customer { Age = 99999 } };
            ModelBindingContext bindingContext = GetBindingContext(typeof(Customer[]));
            bindingContext.ValueProvider = new SimpleHttpValueProvider
            {
                { "theModelName", model }
            };
            bindingContext.ModelState = actionContext.ModelState;

            // Act
            bool retVal = binder.BindModel(actionContext, bindingContext);

            // Assert
            Assert.True(retVal);
            Assert.Same(model, bindingContext.Model);
            Assert.True(actionContext.ModelState.ContainsKey("theModelName"));
            Assert.False(actionContext.ModelState.IsValid);
            Assert.Equal("The field Age must be between 0 and 100.", actionContext.ModelState["theModelName[0].Age"].Errors[0].ErrorMessage);
        }

        private static ModelBindingContext GetBindingContext()
        {
            return GetBindingContext(typeof(int));
        }

        private static ModelBindingContext GetBindingContext(Type modelType)
        {
            return new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, modelType),
                ModelName = "theModelName",
            };
        }

        private class Customer
        {
            [Range(0, 100)]
            public int Age { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/CompositeModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class CompositeModelBinderTest
    {
        //// REVIEW: remove or activate when PropertyFilter is activated
        ////[Fact]
        ////public void BindModel_PropertyFilterIsSet_Throws()
        ////{
        ////    // Arrange
        ////    HttpExecutionContext executionContext = GetHttpExecutionContext();

        ////    ModelBindingContext bindingContext = new ModelBindingContext
        ////    {
        ////        FallbackToEmptyPrefix = true,
        ////        ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(SimpleModel)),
        ////        //PropertyFilter = (new BindAttribute { Include = "FirstName " }).IsPropertyAllowed
        ////    };

        ////    List<ModelBinderProvider> binderProviders = new List<ModelBinderProvider>();
        ////    CompositeModelBinder shimBinder = new CompositeModelBinder(binderProviders);

        ////    // Act & assert
        ////    Assert.Throws<InvalidOperationException>(
        ////        delegate { shimBinder.BindModel(executionContext, bindingContext); },
        ////        @"The new model binding system cannot be used when a property allow list or disallow list has been specified in [Bind] or via the call to UpdateModel() / TryUpdateModel(). Use the [BindRequired] and [BindNever] attributes on the model type or its properties instead.");
        ////}

        [Fact]
        public void BindModel_SuccessfulBind_RunsValidationAndReturnsModel()
        {
            // Arrange
            HttpActionContext actionContext = ContextUtil.CreateActionContext(GetHttpControllerContext());
            bool validationCalled = false;

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                ModelName = "someName",
                //ModelState = executionContext.Controller.ViewData.ModelState,
                //PropertyFilter = _ => true,
                ValueProvider = new SimpleValueProvider
                {
                    { "someName", "dummyValue" }
                }
            };

            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(actionContext, It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(HttpActionContext cc, ModelBindingContext mbc)
                    {
                        Assert.Same(bindingContext.ModelMetadata, mbc.ModelMetadata);
                        Assert.Equal("someName", mbc.ModelName);
                        Assert.Same(bindingContext.ValueProvider, mbc.ValueProvider);

                        mbc.Model = 42;
                        mbc.ValidationNode.Validating += delegate { validationCalled = true; };
                        return true;
                    });

            //binderProviders.RegisterBinderForType(typeof(int), mockIntBinder.Object, false /* suppressPrefixCheck */);
            IModelBinder shimBinder = new CompositeModelBinder(mockIntBinder.Object);

            // Act
            bool isBound = shimBinder.BindModel(actionContext, bindingContext);

            // Assert
            Assert.True(isBound);
            Assert.Equal(42, bindingContext.Model);
            Assert.True(validationCalled);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void BindModel_SuccessfulBind_ComplexTypeFallback_RunsValidationAndReturnsModel()
        {
            // Arrange
            HttpActionContext actionContext = ContextUtil.CreateActionContext(GetHttpControllerContext());

            bool validationCalled = false;
            List<int> expectedModel = new List<int> { 1, 2, 3, 4, 5 };

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
                ModelName = "someName",
                //ModelState = executionContext.Controller.ViewData.ModelState,
                //PropertyFilter = _ => true,
                ValueProvider = new SimpleValueProvider
                {
                    { "someOtherName", "dummyValue" }
                }
            };

            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            mockIntBinder
                .Setup(o => o.BindModel(actionContext, It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(HttpActionContext cc, ModelBindingContext mbc)
                    {
                        if (!String.IsNullOrEmpty(mbc.ModelName))
                        {
                            return false;
                        }

                        Assert.Same(bindingContext.ModelMetadata, mbc.ModelMetadata);
                        Assert.Equal("", mbc.ModelName);
                        Assert.Same(bindingContext.ValueProvider, mbc.ValueProvider);

                        mbc.Model = expectedModel;
                        mbc.ValidationNode.Validating += delegate { validationCalled = true; };
                        return true;
                    });

            //binderProviders.RegisterBinderForType(typeof(List<int>), mockIntBinder.Object, false /* suppressPrefixCheck */);
            IModelBinder shimBinder = new CompositeModelBinder(mockIntBinder.Object);

            // Act
            bool isBound = shimBinder.BindModel(actionContext, bindingContext);

            // Assert
            Assert.True(isBound);
            Assert.Equal(expectedModel, bindingContext.Model);
            Assert.True(validationCalled);
            Assert.True(bindingContext.ModelState.IsValid);
        }

        [Fact]
        public void BindModel_UnsuccessfulBind_BinderFails_ReturnsNull()
        {
            // Arrange
            HttpActionContext actionContext = ContextUtil.CreateActionContext(GetHttpControllerContext());
            Mock<IModelBinder> mockListBinder = new Mock<IModelBinder>();
            mockListBinder.Setup(o => o.BindModel(actionContext, It.IsAny<ModelBindingContext>())).Returns(false).Verifiable();

            IModelBinder shimBinder = (IModelBinder)mockListBinder.Object;

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = false,
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(List<int>)),
                //ModelState = executionContext.Controller.ViewData.ModelState
            };

            // Act
            bool isBound = shimBinder.BindModel(actionContext, bindingContext);

            // Assert
            Assert.False(isBound);
            Assert.Null(bindingContext.Model);
            Assert.True(bindingContext.ModelState.IsValid);
            mockListBinder.Verify();
        }

        [Fact]
        public void BindModel_UnsuccessfulBind_SimpleTypeNoFallback_ReturnsNull()
        {
            // Arrange
            HttpActionContext actionContext = ContextUtil.CreateActionContext(GetHttpControllerContext());
            Mock<ModelBinderProvider> mockBinderProvider = new Mock<ModelBinderProvider>();
            mockBinderProvider.Setup(o => o.GetBinder(It.IsAny<HttpConfiguration>(), It.IsAny<Type>())).Returns((IModelBinder)null).Verifiable();
            List<ModelBinderProvider> binderProviders = new List<ModelBinderProvider>()
            {
                mockBinderProvider.Object
            };
            CompositeModelBinderProvider shimBinderProvider = new CompositeModelBinderProvider(binderProviders);
            CompositeModelBinder shimBinder = new CompositeModelBinder(shimBinderProvider.GetBinder(null, null));

            ModelBindingContext bindingContext = new ModelBindingContext
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int)),
                //ModelState = executionContext.Controller.ViewData.ModelState
            };

            // Act
            bool isBound = shimBinder.BindModel(actionContext, bindingContext);

            // Assert
            Assert.False(isBound);
            Assert.Null(bindingContext.Model);
            Assert.True(bindingContext.ModelState.IsValid);
            mockBinderProvider.Verify();
            mockBinderProvider.Verify(o => o.GetBinder(It.IsAny<HttpConfiguration>(), It.IsAny<Type>()), Times.AtMostOnce());
        }

        private static HttpControllerContext GetHttpControllerContext()
        {
            return ContextUtil.CreateControllerContext();
        }

        private class SimpleController : ApiController
        {
        }

        private class SimpleModel
        {
            public string FirstName { get; set; }
            public string LastName { get; set; }
        }

        private class SimpleValueProvider : Dictionary<string, object>, IValueProvider
        {
            private readonly CultureInfo _culture;

            public SimpleValueProvider()
                : this(null)
            {
            }

            public SimpleValueProvider(CultureInfo culture)
                : base(StringComparer.OrdinalIgnoreCase)
            {
                _culture = culture ?? CultureInfo.InvariantCulture;
            }

            // copied from ValueProviderUtil
            public bool ContainsPrefix(string prefix)
            {
                foreach (string key in Keys)
                {
                    if (key != null)
                    {
                        if (prefix.Length == 0)
                        {
                            return true; // shortcut - non-null key matches empty prefix
                        }

                        if (key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                        {
                            if (key.Length == prefix.Length)
                            {
                                return true; // exact match
                            }
                            else
                            {
                                switch (key[prefix.Length])
                                {
                                    case '.': // known separator characters
                                    case '[':
                                        return true;
                                }
                            }
                        }
                    }
                }

                return false; // nothing found
            }

            public ValueProviderResult GetValue(string key)
            {
                object rawValue;
                if (TryGetValue(key, out rawValue))
                {
                    return new ValueProviderResult(rawValue, Convert.ToString(rawValue, _culture), _culture);
                }
                else
                {
                    // value not found
                    return null;
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/DefaultActionValueBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Net.Http;
using System.Reflection;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    // These tests primarily focus on getting the right binding contract. They don't actually execute the contract.
    public class DefaultActionValueBinderTest
    {
        [Fact]
        public void BindValuesAsync_Throws_Null_ActionDescriptor()
        {
            // Arrange
            HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor { MethodInfo = (MethodInfo)MethodInfo.GetCurrentMethod() };

            // Act and Assert
            Assert.ThrowsArgumentNull(
                () => new DefaultActionValueBinder().GetBinding(null),
                "actionDescriptor");
        }

        private void Action_Int(int id) { }

        [Fact]
        public void Check_Int_Is_ModelBound()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Int"));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        [Fact]
        public void Check_Config_Override_Use_Formatters()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.ParameterBindingRules.Add(param => param.BindWithFormatter()); // overrides

            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Int", config));

            Assert.Single(binding.ParameterBindings);
            AssertIsBody(binding, 0);
        }

        private void Action_Int_FromUri([FromUri] int id) { }

        [Fact]
        public void Check_Explicit_Int_Is_ModelBound()
        {
            // Even though int is implicitly model bound, still ok to specify it explicitly
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Int_FromUri"));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        // All types in this signature are model bound
        private void Action_SimpleTypes(char ch, Byte b, Int16 i16, UInt16 u16, Int32 i32, UInt32 u32, Int64 i64, UInt64 u64, string s, DateTime d, Decimal dec, Guid g, DateTimeOffset dateTimeOffset, TimeSpan timespan) { }

        [Fact]
        public void Check_SimpleTypes_Are_ModelBound()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_SimpleTypes"));

            for (int i = 0; i < binding.ParameterBindings.Length; i++)
            {
                AssertIsModelBound(binding, 0);
            }
        }

        private void Action_ComplexTypeWithStringConverter(ComplexTypeWithStringConverter x) { }

        [Fact]
        public void Check_String_TypeConverter_Is_ModelBound()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_ComplexTypeWithStringConverter"));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        private void Action_ComplexTypeWithStringConverter_Body_Override([FromBody] ComplexTypeWithStringConverter x) { }

        [Fact]
        public void Check_String_TypeConverter_With_Body_Override()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_ComplexTypeWithStringConverter_Body_Override"));

            Assert.Single(binding.ParameterBindings);
            AssertIsBody(binding, 0);
        }

        private void Action_NullableInt(Nullable<int> id) { }

        [Fact]
        public void Check_NullableInt_Is_ModelBound()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_NullableInt"));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        private void Action_Nullable_ValueType(Nullable<ComplexValueType> id) { }

        [Fact]
        public void Check_Nullable_ValueType_Is_FromBody()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Nullable_ValueType"));

            Assert.Single(binding.ParameterBindings);
            AssertIsBody(binding, 0);
        }


        private void Action_IntArray(int[] arrayFrombody) { }

        [Fact]
        public void Check_IntArray_Is_FromBody()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_IntArray"));

            Assert.Single(binding.ParameterBindings);
            AssertIsBody(binding, 0);
        }


        private void Action_SimpleType_Body([FromBody] int i) { }

        [Fact]
        public void Check_SimpleType_Body()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_SimpleType_Body"));

            Assert.Single(binding.ParameterBindings);
            AssertIsBody(binding, 0);
        }

        private void Action_Empty() { }

        [Fact]
        public void Check_Empty_Action()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Empty"));

            Assert.NotNull(binding.ParameterBindings);
            Assert.Empty(binding.ParameterBindings);
        }

        private void Action_String_String(string s1, string s2) { }

        [Fact]
        public void Check_String_String_IsModelBound()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_String_String"));

            Assert.Equal(2, binding.ParameterBindings.Length);
            AssertIsModelBound(binding, 0);
            AssertIsModelBound(binding, 1);
        }

        private void Action_Complex_Type(ComplexType complex) { }

        [Fact]
        public void Check_Complex_Type_FromBody()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Complex_Type"));

            Assert.Single(binding.ParameterBindings);
            AssertIsBody(binding, 0);
        }

        [Fact]
        public void Check_Config_Override_Use_ModelBinding()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.ParameterBindingRules.Add(param => param.BindWithModelBinding());
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Complex_Type", config));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }


        private void Action_Complex_ValueType(ComplexValueType complex) { }

        [Fact]
        public void Check_Complex_ValueType_FromBody()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Complex_ValueType"));

            Assert.Single(binding.ParameterBindings);
            AssertIsBody(binding, 0);
        }

        private void Action_Default_Custom_Model_Binder([ModelBinder] ComplexType complex) { }

        [Fact]
        public void Check_Customer_Binder()
        {
            // Mere presence of a ModelBinder attribute means the type is model bound.

            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Default_Custom_Model_Binder"));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        private void Action_Complex_Type_Uri([FromUri] ComplexType complex) { }

        [Fact]
        public void Check_Complex_Type_FromUri()
        {
            // [FromUri] is just a specific instance of ModelBinder attribute
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Complex_Type_Uri"));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        private void Action_Two_Complex_Types(ComplexType complexBody1, ComplexType complexBody2) { }

        [Fact]
        public void Check_Two_Complex_Types_FromBody()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            // It's illegal to have multiple parameters from the body.
            // But we should still be able to get a binding for it. We just can't execute it.
            var binding = binder.GetBinding(GetAction("Action_Two_Complex_Types"));

            Assert.Equal(2, binding.ParameterBindings.Length);
            AssertIsError(binding, 0);
            AssertIsError(binding, 1);
        }

        private void Action_Complex_Type_UriAndBody([FromUri] ComplexType complexUri, ComplexType complexBody) { }

        [Fact]
        public void Check_Complex_Type_FromBody_And_FromUri()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Complex_Type_UriAndBody"));

            Assert.Equal(2, binding.ParameterBindings.Length);
            AssertIsModelBound(binding, 0);
            AssertIsBody(binding, 1);
        }

        private void Action_CancellationToken(CancellationToken ct) { }

        [Fact]
        public void Check_Cancellation_Token()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_CancellationToken"));

            Assert.Single(binding.ParameterBindings);
            AssertIsCancellationToken(binding, 0);
        }

        private void Action_CustomModelBinder_On_Parameter_WithProvider([ModelBinder(typeof(CustomModelBinderProvider))] ComplexType complex) { }

        [Fact]
        public void Check_CustomModelBinder_On_Parameter()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Services.ReplaceRange(typeof(ValueProviderFactory), new ValueProviderFactory[] {
                new CustomValueProviderFactory(),
            });

            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_CustomModelBinder_On_Parameter_WithProvider", config));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);

            ModelBinderParameterBinding p = (ModelBinderParameterBinding)binding.ParameterBindings[0];
            Assert.IsType<CustomModelBinder>(p.Binder);

            // Since the ModelBinderAttribute didn't specify the valueproviders, we should pull those from config.
            ValueProviderFactory valueProviderFactory = Assert.Single(p.ValueProviderFactories);
            Assert.IsType<CustomValueProviderFactory>(valueProviderFactory);
        }

        // Model binder attribute is on the type's declaration.
        private void Action_ComplexParameter_With_ModelBinder(ComplexTypeWithModelBinder complex) { }

        [Fact]
        public void Check_Parameter_With_ModelBinder_Attribute_On_Type()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_ComplexParameter_With_ModelBinder"));

            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        private void Action_Conflicting_Attributes([FromBody][FromUri] int i) { }

        [Fact]
        public void Error_Conflicting_Attributes()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Conflicting_Attributes"));

            // Have 2 attributes that conflict with each other. Still get the contract, but it has an error in it.
            Assert.Single(binding.ParameterBindings);
            AssertIsError(binding, 0);
        }

        [FromBody]
        class Widget
        {
        }
        private void Action_Closest_Attribute_Wins([FromUri] Widget i) { }

        [Fact]
        public void Check_Closest_Attribute_Wins()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Closest_Attribute_Wins"));

            // Have 2 attributes that conflict with each other. Still get the contract, but it has an error in it.
            Assert.Single(binding.ParameterBindings);
            AssertIsModelBound(binding, 0);
        }

        private void Action_HttpContent_Parameter(HttpContent c) { }

        [Fact]
        public void Check_HttpContent()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_HttpContent_Parameter"));

            Assert.Single(binding.ParameterBindings);
            AssertIsError(binding, 0);
        }

        private void Action_Derived_HttpContent_Parameter(StreamContent c) { }

        [Fact]
        public void Check_Derived_HttpContent()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Derived_HttpContent_Parameter"));

            Assert.Single(binding.ParameterBindings);
            AssertIsError(binding, 0);
        }

        private void Action_Request_Parameter(HttpRequestMessage request) { }

        [Fact]
        public void Check_Request_Parameter()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_Request_Parameter"));

            Assert.Single(binding.ParameterBindings);
            AssertIsCustomBinder<HttpRequestParameterBinding>(binding, 0);
        }


        private void Action_CustomBindingAttribute([CustomBindingAttribute] int x) { }

        [Fact]
        public void Check_CustomBindingAttribute()
        {
            DefaultActionValueBinder binder = new DefaultActionValueBinder();

            var binding = binder.GetBinding(GetAction("Action_CustomBindingAttribute"));

            HttpParameterBinding parameterBinding = Assert.Single(binding.ParameterBindings);
            Assert.Same(CustomBindingAttribute.MockBinding, parameterBinding);
        }

        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Parameter, Inherited = true, AllowMultiple = false)]
        private class CustomBindingAttribute : ParameterBindingAttribute
        {
            public static HttpParameterBinding MockBinding = new CustomBinding();

            public override HttpParameterBinding GetBinding(HttpParameterDescriptor parameter)
            {
                return MockBinding;
            }

            private class CustomBinding : HttpParameterBinding
            {
                public CustomBinding()
                    : base(new Mock<HttpParameterDescriptor>().Object)
                {
                }
                public override Threading.Tasks.Task ExecuteBindingAsync(Metadata.ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
                {
                    throw new NotImplementedException();
                }
            }
        }



        // Assert that the binding contract says the given parameter comes from the body
        private void AssertIsBody(HttpActionBinding binding, int paramIdx)
        {
            HttpParameterBinding p = binding.ParameterBindings[paramIdx];
            Assert.NotNull(p);
            Assert.True(p.IsValid);
            Assert.True(p.WillReadBody);
        }

        // Assert that the binding contract says the given parameter is not from the body (will be handled by model binding)
        private void AssertIsModelBound(HttpActionBinding binding, int paramIdx)
        {
            HttpParameterBinding p = binding.ParameterBindings[paramIdx];
            Assert.NotNull(p);
            Assert.IsType<ModelBinderParameterBinding>(p);
            Assert.True(p.IsValid);
            Assert.False(p.WillReadBody);
        }

        // Assert that the binding contract says the given parameter will be bound to the cancellation token.
        private void AssertIsCancellationToken(HttpActionBinding binding, int paramIdx)
        {
            AssertIsCustomBinder<CancellationTokenParameterBinding>(binding, paramIdx);
        }

        private void AssertIsError(HttpActionBinding binding, int paramIdx)
        {
            HttpParameterBinding p = binding.ParameterBindings[paramIdx];
            Assert.NotNull(p);
            Assert.False(p.IsValid);
            Assert.False(p.WillReadBody);
        }

        private void AssertIsCustomBinder<T>(HttpActionBinding binding, int paramIdx)
        {
            HttpParameterBinding p = binding.ParameterBindings[paramIdx];
            Assert.NotNull(p);
            Assert.IsType<T>(p);
            Assert.True(p.IsValid);
            Assert.False(p.WillReadBody);
        }


        // Helper to get an ActionDescriptor for a method name.
        private HttpActionDescriptor GetAction(string name)
        {
            return GetAction(name, new HttpConfiguration());
        }

        private HttpActionDescriptor GetAction(string name, HttpConfiguration config)
        {
            MethodInfo method = this.GetType().GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
            Assert.NotNull(method);
            return new ReflectedHttpActionDescriptor { MethodInfo = method, Configuration = config, ControllerDescriptor = GetControllerDescriptor(config) };
        }

        // Get a controller descriptor that's sufficiently initialized to use with parameter binding
        private HttpControllerDescriptor GetControllerDescriptor(HttpConfiguration config)
        {
            return new HttpControllerDescriptor(config);
        }

        // Complex type to use with tests
        class ComplexType
        {
        }

        struct ComplexValueType
        {
        }

        // Complex type to use with tests
        [ModelBinder]
        class ComplexTypeWithModelBinder
        {
        }

        // Add Type converter for string, which causes the type to be viewed as a Simple type.
        [TypeConverter(typeof(MyTypeConverter))]
        public class ComplexTypeWithStringConverter
        {
            public string Data { get; set; }
            public ComplexTypeWithStringConverter(string data)
            {
                Data = data;
            }
        }

        // A string type converter
        public class MyTypeConverter : TypeConverter
        {
            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
            {
                if (sourceType == typeof(string))
                {
                    return true;
                }
                return base.CanConvertFrom(context, sourceType);
            }

            public override object ConvertFrom(ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
            {
                if (value is string)
                {
                    return new ComplexTypeWithStringConverter((string)value);
                }

                return base.ConvertFrom(context, culture, value);
            }
        }

        class CustomModelBinderProvider : ModelBinderProvider
        {
            public override IModelBinder GetBinder(HttpConfiguration config, Type modelType)
            {
                return new CustomModelBinder();
            }
        }

        class CustomModelBinder : IModelBinder
        {
            public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        class CustomValueProviderFactory : ValueProviderFactory
        {
            public override IValueProvider GetValueProvider(HttpActionContext actionContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/FormDataCollectionExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Validation;
using System.Web.Http.Validation.Providers;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class FormDataCollectionExtensionsTest
    {
        [Theory]
        [InlineData("", null)]
        [InlineData("", "")] // empty
        [InlineData("x", "x")] // normal key
        [InlineData("", "[]")] // trim []
        [InlineData("x", "x[]")] // trim []
        [InlineData("x[234]", "x[234]")] // array index
        [InlineData("x.y", "x[y]")] // field lookup
        [InlineData("x.y.z", "x[y][z]")] // nested field lookup
        [InlineData("x.y[234].x", "x[y][234][x]")] // compound
        public void TestNormalize(string expectedMvc, string jqueryString)
        {
            Assert.Equal(expectedMvc, FormDataCollectionExtensions.NormalizeJQueryToMvc(jqueryString));
        }

        [Fact]
        public void TestGetJQueryNameValuePairs()
        {
            // Arrange
            var formData = new FormDataCollection("x.y=30&x[y]=70&x[z][20]=cool");

            // Act
            var actual = FormDataCollectionExtensions.GetJQueryNameValuePairs(formData).ToArray();

            // Assert
            var arraySetter = Assert.Single(actual, kvp => kvp.Key == "x.z[20]");
            Assert.Equal("cool", arraySetter.Value);

            Assert.Single(actual, kvp => kvp.Key == "x.y" && kvp.Value == "30");
            Assert.Single(actual, kvp => kvp.Key == "x.y" && kvp.Value == "70");
        }

        [Fact]
        public async Task ReadIntArray()
        {
            // No key name means the top level object is an array
            int[] result = await ParseJQueryAsync<int[]>("=30&=40&=50");

            Assert.Equal(new int[] { 30,40,50 } , result);
        }

        [Fact]
        public async Task ReadIntArrayWithBrackets()
        {
            // brackets for explicit array
            int[] result = await ParseJQueryAsync<int[]>("[]=30&[]=40&[]=50");

            Assert.Equal(new int[] { 30, 40, 50 }, result);
        }

        [Fact]
        public async Task ReadIntArrayFromSingleElement()
        {
            // No key name means the top level object is an array
            int[] result = await ParseJQueryAsync<int[]>("=30");

            Assert.Equal(new int[] { 30 }, result);
        }

        [Fact]
        public async Task ReadClassWithIntArray()
        {
            // specifying key name 'x=30' means that we have a field named x.
            // multiple x keys mean that field is an array.
            var result = await ParseJQueryAsync<ClassWithArrayField>("x=30&x=40&x=50");

            Assert.Equal(new int[] { 30, 40, 50 }, result.x);
        }

        public class ComplexType
        {
            public string Str { get; set; }
            public int I { get; set; }
            public Point P { get; set; }
        }
        public class Point
        {
            public int X { get; set; }
            public int Y { get; set; }
        }

        [Fact]
        public async Task ReadClassWithFields()
        {
            // Basic container class with multiple fields
            var result = await ParseJQueryAsync<Point>("X=3&Y=4");
            Assert.Equal(3, result.X);
            Assert.Equal(4, result.Y);
        }

        [Fact]
        public void ReadClassWithFieldsFromUri()
        {
            var uri = new Uri("http://foo.com/?X=3&Y=4&Z=5");
            FormDataCollection fd = new FormDataCollection(uri);
            var result = fd.ReadAs<Point>();

            Assert.Equal(3, result.X);
            Assert.Equal(4, result.Y);
        }

        [Fact]
        public async Task ReadClassWithFieldsAndPartialBind()
        {
            // Basic container class with multiple fields
            // Extra Z=5 field, ignored since we're reading point.
            var result = await ParseJQueryAsync<Point>("X=3&Y=4&Z=5");
            Assert.Equal(3, result.X);
            Assert.Equal(4, result.Y);
        }

        public class Nest
        {
            public Nest A { get; set; }
        }

        [Fact]
        public Task ReadDeeplyNestedFormUrlThrows()
        {
            StringBuilder sb = new StringBuilder("A");
            for (int i = 0; i < 10000; i++)
            {
                sb.Append("[A]");
            }
            sb.Append("=1");

            return Assert.ThrowsAsync<InsufficientExecutionStackException>(() => ParseJQueryAsync<Nest>(sb.ToString()));
        }

        [Fact]
        public Task ReadDeeplyNestedMvcThrows()
        {
            StringBuilder sb = new StringBuilder("A");
            for (int i = 0; i < 10000; i++)
            {
                sb.Append(".A");
            }
            sb.Append("=1");

            return Assert.ThrowsAsync<InsufficientExecutionStackException>(() => ParseJQueryAsync<Nest>(sb.ToString()));
        }

        public class ClassWithPointArray
        {
            public Point[] Data { get; set; }
        }

        [Fact]
        public async Task ReadArrayOfClasses()
        {
            // Array of classes.
            string s = "Data[0][X]=10&Data[0][Y]=20&Data[1][X]=30&Data[1][Y]=40";
            var result = await ParseJQueryAsync<ClassWithPointArray>(s);

            Assert.NotNull(result.Data);
            Assert.Equal(2, result.Data.Length);
            Assert.Equal(10, result.Data[0].X);
            Assert.Equal(20, result.Data[0].Y);
            Assert.Equal(30, result.Data[1].X);
            Assert.Equal(40, result.Data[1].Y);
        }

        [Fact]
        public async Task ReadComplexNestedType()
        {
            var result = await ParseJQueryAsync<ComplexType>("Str=Hello+world&I=123&P[X]=3&P[Y]=4");
            Assert.Equal("Hello world", result.Str);
            Assert.Equal(123, result.I);
            Assert.NotNull(result.P); // failed to find P
            Assert.Equal(3, result.P.X);
            Assert.Equal(4, result.P.Y);
        }

        class ComplexType2
        {
            public class Epsilon
            {
                public int[] f { get; set; }
            }

            public class Beta
            {
                public int c { get; set; }
                public int d { get; set; }
            }

            public int[] a { get; set; }
            public Beta[] b { get; set; }
            public Epsilon e { get; set; }
        }

        [Fact]
        public async Task ReadComplexNestedType2()
        {
            // Jquery encoding from this JSON: "{a:[1,2],b:[{c:3,d:4},{c:5,d:6}],e:{f:[7,8,9]}}";
            string s = "a[]=1&a[]=2&b[0][c]=3&b[0][d]=4&b[1][c]=5&b[1][d]=6&e[f][]=7&e[f][]=8&e[f][]=9";
            var result = await ParseJQueryAsync<ComplexType2>(s);

            Assert.NotNull(result);
            Assert.Equal(new int[] { 1, 2 }, result.a);
            Assert.Equal(2, result.b.Length);
            Assert.Equal(3, result.b[0].c);
            Assert.Equal(4, result.b[0].d);
            Assert.Equal(5, result.b[1].c);
            Assert.Equal(6, result.b[1].d);
            Assert.Equal(new int[] { 7, 8, 9 }, result.e.f);
        }

        [Fact]
        public async Task ReadJaggedArray()
        {
            string s = "[0][]=9&[0][]=10&[1][]=11&[1][]=12&[2][]=13&[2][]=14";
            var result = await ParseJQueryAsync<int[][]>(s);

            Assert.Equal(9, result[0][0]);
            Assert.Equal(10, result[0][1]);
            Assert.Equal(11, result[1][0]);
            Assert.Equal(12, result[1][1]);
            Assert.Equal(13, result[2][0]);
            Assert.Equal(14, result[2][1]);
        }

        [Fact]
        public async Task ReadMultipleParameters()
        {
            // Basic container class with multiple fields
            HttpContent content = FormContent("X=3&Y=4");
            FormDataCollection fd = await content.ReadAsAsync<FormDataCollection>();

            Assert.Equal(3, fd.ReadAs<int>("X", requiredMemberSelector: null, formatterLogger: null));
            Assert.Equal("3", fd.ReadAs<string>("X", requiredMemberSelector: null, formatterLogger: null));
            Assert.Equal(4, fd.ReadAs<int>("Y", requiredMemberSelector: null, formatterLogger: null));
        }

        [Fact]
        public async Task ReadInvalidInt_ReturnsDefaultValue()
        {
            int result = await ParseJQueryAsync<int>("xyz");
            Assert.Equal(0, result);
        }

        [Fact]
        public async Task ReadForThrowingSetterTypeRecordsCorrectModelError()
        {
            HttpContent content = FormContent("Throws=text");
            FormDataCollection formData = await content.ReadAsAsync<FormDataCollection>();
            Mock<IFormatterLogger> mockLogger = new Mock<IFormatterLogger>();

            formData.ReadAs<ThrowingSetterType>(String.Empty, requiredMemberSelector: null, formatterLogger: mockLogger.Object);

            mockLogger.Verify(mock => mock.LogError("Throws", ThrowingSetterType.Exception));
        }

        [Fact]
        public async Task ReadAs_NullActionContextThrows()
        {
            // Arrange
            HttpContent content = FormContent("=30");
            FormDataCollection formData = await content.ReadAsAsync<FormDataCollection>();

            // Act/Assert
            Assert.Throws<ArgumentNullException>(() => formData.ReadAs<int>((HttpActionContext)null));
        }

        [Fact]
        public async Task ReadAs_WithHttpActionContext()
        {
            // Arrange
            int expected = 30;
            HttpContent content = FormContent("=30");
            FormDataCollection formData = await content.ReadAsAsync<FormDataCollection>();

            using (HttpConfiguration configuration = new HttpConfiguration())
            {
                HttpActionContext actionContext = CreateActionContext(configuration);

                // Act
                int actual = formData.ReadAs<int>(actionContext);

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        [Fact]
        public async Task ReadAs_WithModelNameAndHttpActionContext()
        {
            // Arrange
            int expected = 30;
            HttpContent content = FormContent("a=30");
            FormDataCollection formData = await content.ReadAsAsync<FormDataCollection>();

            using (HttpConfiguration configuration = new HttpConfiguration())
            {
                HttpActionContext actionContext = CreateActionContext(configuration);

                // Act
                int actual = (int)formData.ReadAs(typeof(int), "a", actionContext);

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        // This test verifies the user scenario behind codeplex-999 - ReadAs should take HttpActionContext
        // as a parameter to make use of ModelBinders in the configuration.
        [Fact]
        public async Task Read_As_WithHttpActionContextAndCustomModelBinder()
        {
            // Arrange
            int expected = 15;
            HttpContent content = FormContent("a=30");
            FormDataCollection formData = await content.ReadAsAsync<FormDataCollection>();

            using (HttpConfiguration configuration = new HttpConfiguration())
            {
                configuration.Services.Insert(typeof(ModelBinderProvider), 0, new CustomIntModelBinderProvider());

                HttpActionContext actionContext = CreateActionContext(configuration);

                // Act
                int actual = (int)formData.ReadAs(typeof(int), "a", actionContext);

                // Assert
                Assert.Equal(expected, actual);
            }
        }

        // This test is to make sure that the ServicesConfigurationWrapper has not
        // altered HttpConfiguration.Services in any way
        [Fact]
        public async Task Read_As_NoServicesChangeInConfig()
        {
            // Arrange
            HttpContent content = FormContent("a=30");
            FormDataCollection formData = await content.ReadAsAsync<FormDataCollection>();

            using (HttpConfiguration configuration = new HttpConfiguration())
            {
                // Act
                HttpControllerSettings settings = new HttpControllerSettings(configuration);
                HttpConfiguration clonedConfiguration =
                    HttpConfiguration.ApplyControllerSettings(settings, configuration);
                int actual = (int)formData.ReadAs(typeof(int), "a", requiredMemberSelector: null,
                    formatterLogger: (new Mock<IFormatterLogger>()).Object, config: configuration);

                // Assert
                Assert.Equal(30, actual);
                Assert.Same(clonedConfiguration.Services, configuration.Services);
            }
        }

        [Fact]
        public void ServicesContainerWrapper_GetServices_Returns_RequiredModelValidatorProvider()
        {
            // Arrange
            var requiredMemberModelValidatorProvider =
                new RequiredMemberModelValidatorProvider(requiredMemberSelector: null);
            FormDataCollectionExtensions.ServicesContainerWrapper wrapper =
                new FormDataCollectionExtensions.ServicesContainerWrapper(
                    new HttpConfiguration(), requiredMemberModelValidatorProvider);

            // Act
            IEnumerable<object> services = wrapper.GetServices(typeof(ModelValidatorProvider));

            // Assert
            Assert.Same(requiredMemberModelValidatorProvider, services.ElementAt(0));
        }

        [Fact]
        public void ServicesContainerWrapper_GetService_Returns_ModelValidatorCache()
        {
            // Arrange
            FormDataCollectionExtensions.ServicesContainerWrapper wrapper =
                new FormDataCollectionExtensions.ServicesContainerWrapper(
                    new HttpConfiguration(), new RequiredMemberModelValidatorProvider(requiredMemberSelector: null));

            // Act
            object serviceInstance1 = wrapper.GetService(typeof(IModelValidatorCache));
            object serviceInstance2 = wrapper.GetService(typeof(IModelValidatorCache));

            // Assert
            Assert.IsType<ModelValidatorCache>(serviceInstance1);
            Assert.NotSame(serviceInstance1, serviceInstance2);
        }

        [Fact]
        public void ServicesContainerWrapper_GetService_Returns_ModelValidatorProvider()
        {
            // Arrange
            var requiredMemberModelValidatorProvider =
                new RequiredMemberModelValidatorProvider(requiredMemberSelector: null);
            FormDataCollectionExtensions.ServicesContainerWrapper wrapper =
                new FormDataCollectionExtensions.ServicesContainerWrapper(
                    new HttpConfiguration(), requiredMemberModelValidatorProvider);

            // Act
            object service = wrapper.GetService(typeof(ModelValidatorProvider));

            // Assert
            Assert.Equal(requiredMemberModelValidatorProvider, service);
        }

        private static HttpActionContext CreateActionContext(HttpConfiguration configuration)
        {
            HttpControllerContext controllerContext = new HttpControllerContext()
            {
                Configuration = configuration,
                ControllerDescriptor = new HttpControllerDescriptor(configuration),
            };

            return new HttpActionContext { ControllerContext = controllerContext };
        }

        private static HttpContent FormContent(string s)
        {
            HttpContent content = new StringContent(s);
            content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");

            return content;
        }

        private async Task<T> ParseJQueryAsync<T>(string jquery)
        {
            HttpContent content = FormContent(jquery);
            FormDataCollection fd = await content.ReadAsAsync<FormDataCollection>();
            T result = fd.ReadAs<T>();
            return result;
        }

        private class CustomIntModelBinder : IModelBinder
        {
            public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
            {
                ValueProviderResult valueResult = bindingContext.ValueProvider.GetValue(bindingContext.ModelName);
                int result = (int)valueResult.ConvertTo(typeof(int));

                bindingContext.Model = result / 2;
                return true;
            }
        }

        private class CustomIntModelBinderProvider : ModelBinderProvider
        {
            public override IModelBinder GetBinder(HttpConfiguration configuration, Type modelType)
            {
                if (modelType == typeof(int))
                {
                    return new CustomIntModelBinder();
                }
                else
                {
                    return null;
                }
            }
        }

        private class ThrowingSetterType
        {
            public static Exception Exception = new Exception("This setter throws");
            public string Throws { get { return null; } set { throw Exception; } }
        }

        private class ClassWithArrayField
        {
            public int[] x { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/FormatterParameterBindingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Validation;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class FormatterParameterBindingTest
    {
        [Fact]
        public void ReadContentAsync_Throws_ForNoContentType()
        {
            var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost");
            request.Content = new StringContent("The quick, brown fox tripped and fell.");
            request.Content.Headers.ContentType = null;
            var formatters = new MediaTypeFormatterCollection();
            var descriptor = new Mock<HttpParameterDescriptor>();
            descriptor.Setup(desc => desc.IsOptional).Returns(false);
            var binding = new FormatterParameterBinding(descriptor.Object, formatters, null);

            HttpResponseException exception = Assert.Throws<HttpResponseException>(
                () => binding.ReadContentAsync(request, typeof(string), formatters, null));

            Assert.Equal(HttpStatusCode.UnsupportedMediaType, exception.Response.StatusCode);
            HttpError error;
            exception.Response.TryGetContentValue(out error);
            Assert.Equal(
                "The request contains an entity body but no Content-Type header. The inferred media type 'application/octet-stream' is not supported for this resource.",
                error.Message);
        }

        [Fact]
        public void ReadContentAsync_Throws_ForUnsupportedMediaType()
        {
            var request = new HttpRequestMessage(HttpMethod.Post, "http://localhost");
            request.Content = new StringContent("The quick, brown fox tripped and fell.");
            var formatters = new MediaTypeFormatterCollection();
            var descriptor = new Mock<HttpParameterDescriptor>();
            descriptor.Setup(desc => desc.IsOptional).Returns(false);
            var binding = new FormatterParameterBinding(descriptor.Object, formatters, null);

            HttpResponseException exception = Assert.Throws<HttpResponseException>(
                () => binding.ReadContentAsync(request, typeof(string), formatters, null));

            Assert.Equal(HttpStatusCode.UnsupportedMediaType, exception.Response.StatusCode);
            HttpError error;
            exception.Response.TryGetContentValue(out error);
            Assert.Equal(
                "The request entity's media type 'text/plain' is not supported for this resource.",
                error.Message);
        }

        [Fact]
        public async Task ExecuteBindingAsync_PassesCancellationTokenTo_ReadContentAsync()
        {
            // Arrange
            var parameter = new Mock<HttpParameterDescriptor>();
            parameter.Setup(p => p.IsOptional).Returns(false);
            parameter.Setup(p => p.ParameterName).Returns("ParameterName");
            var formatters = Enumerable.Empty<MediaTypeFormatter>();
            IBodyModelValidator validator = null;
            ModelMetadataProvider metadataProvider = new Mock<ModelMetadataProvider>().Object;
            HttpRequestMessage request = new HttpRequestMessage();
            HttpActionContext actionContext = new HttpActionContext { ControllerContext = new HttpControllerContext { Request = request } };
            CancellationTokenSource cts = new CancellationTokenSource();

            Mock<FormatterParameterBinding> binding = new Mock<FormatterParameterBinding>(parameter.Object, formatters, validator);
            binding.CallBase = true;
            binding.Setup(b => b.ReadContentAsync(request, null, formatters, It.IsAny<IFormatterLogger>()))
                .Returns(Task.FromResult<object>(42))
                .Verifiable();

            // Act
            await binding.Object.ExecuteBindingAsync(metadataProvider, actionContext, cts.Token);

            // Assert
            binding.Verify();
        }

        [Fact]
        public async Task ReadContentAsync_PassesCancellationToken_Further()
        {
            // Arrange
            var parameter = new Mock<HttpParameterDescriptor>();
            parameter.Setup(p => p.IsOptional).Returns(false);
            IBodyModelValidator validator = null;
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("app/test");
            IFormatterLogger logger = null;
            CancellationTokenSource cts = new CancellationTokenSource();

            Mock<MediaTypeFormatter> formatter = new Mock<MediaTypeFormatter>();
            formatter.Setup(f => f.CanReadType(typeof(int))).Returns(true);
            formatter.Object.SupportedMediaTypes.Add(request.Content.Headers.ContentType);
            formatter.Setup(f => f.ReadFromStreamAsync(typeof(int), It.IsAny<Stream>(), request.Content, logger, cts.Token))
                .Returns(Task.FromResult<object>(42))
                .Verifiable();

            var formatters = new[] { formatter.Object };
            FormatterParameterBinding binding = new FormatterParameterBinding(parameter.Object, formatters, validator);

            // Act
            await binding.ReadContentAsync(request, typeof(int), formatters, logger, cts.Token);

            // Assert
            formatter.Verify();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/HttpBindingBehaviorAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    public class HttpHttpBindingBehaviorAttributeTest
    {
        [Fact]
        public void Behavior_Property()
        {
            // Arrange
            HttpBindingBehavior expectedBehavior = (HttpBindingBehavior)(-20);

            // Act
            HttpBindingBehaviorAttribute attr = new HttpBindingBehaviorAttribute(expectedBehavior);

            // Assert
            Assert.Equal(expectedBehavior, attr.Behavior);
        }

        [Fact]
        public void TypeId_ReturnsSameValue()
        {
            // Arrange
            HttpBindNeverAttribute neverAttr = new HttpBindNeverAttribute();
            HttpBindRequiredAttribute requiredAttr = new HttpBindRequiredAttribute();

            // Act & assert
            Assert.Same(neverAttr.TypeId, requiredAttr.TypeId);
        }

        [Fact]
        public void BindNever_SetsBehavior()
        {
            // Act
            HttpBindingBehaviorAttribute attr = new HttpBindNeverAttribute();

            // Assert
            Assert.Equal(HttpBindingBehavior.Never, attr.Behavior);
        }

        [Fact]
        public void BindRequired_SetsBehavior()
        {
            // Act
            HttpBindingBehaviorAttribute attr = new HttpBindRequiredAttribute();

            // Assert
            Assert.Equal(HttpBindingBehavior.Required, attr.Behavior);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/HttpParameterBindingExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class HttpParameterBindingExtensionsTest
    {
        [Fact]
        public void WillReadUri_Throws_With_Null_ParameterBinding()
        {
            // Arrange
            HttpParameterBinding binding = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => binding.WillReadUri(), "parameterBinding");
        }

        [Fact]
        public void WillReadUri_Returns_True_For_IValueProviderParameterBinding_Containing_Only_Standard_Uri_ValueProviders()
        {
            // Arrange
            Mock<HttpParameterDescriptor> descriptorMock = new Mock<HttpParameterDescriptor>();
            HttpParameterBinding bindingMock = new HttpValueProviderParameterBindingTestDouble(
                                                    descriptorMock.Object,
                                                    new List<ValueProviderFactory>() 
                                                    {
                                                        new QueryStringValueProviderFactory(), 
                                                        new RouteDataValueProviderFactory()
                                                    });

            // Act
            bool result = bindingMock.WillReadUri();

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void WillReadUri_Returns_False_For_IValueProviderParameterBinding_Containing_Non_Uri_ValueProviders()
        {
            // Arrange
            Mock<HttpParameterDescriptor> descriptorMock = new Mock<HttpParameterDescriptor>();
            Mock<ValueProviderFactory> valueProviderMock = new Mock<ValueProviderFactory>();
            HttpParameterBinding bindingMock = new HttpValueProviderParameterBindingTestDouble(
                                                    descriptorMock.Object,
                                                    new List<ValueProviderFactory>() 
                                                    {
                                                        new QueryStringValueProviderFactory(), 
                                                        new RouteDataValueProviderFactory(),
                                                        valueProviderMock.Object,
                                                    });

            // Act
            bool result = bindingMock.WillReadUri();

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void WillReadUri_Returns_False_For_IValueProviderParameterBinding_Containing_No_ValueProviders()
        {
            // Arrange
            Mock<HttpParameterDescriptor> descriptorMock = new Mock<HttpParameterDescriptor>();
            HttpParameterBinding bindingMock = new HttpValueProviderParameterBindingTestDouble(
                                                    descriptorMock.Object,
                                                    new List<ValueProviderFactory>());

            // Act
            bool result = bindingMock.WillReadUri();

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void WillReadUri_Returns_False_For_HttpParameterBinding_Not_Implementing_IValueProviderParameterBinding()
        {
            // Arrange
            Mock<HttpParameterDescriptor> descriptorMock = new Mock<HttpParameterDescriptor>();
            Mock<HttpParameterBinding> bindingMock = new Mock<HttpParameterBinding>(descriptorMock.Object);

            // Act
            bool result = bindingMock.Object.WillReadUri();

            // Assert
            Assert.False(result);
        }

        class HttpValueProviderParameterBindingTestDouble : HttpParameterBinding, IValueProviderParameterBinding
        {
            public IEnumerable<ValueProviderFactory> Factories { get; set; }

            public HttpValueProviderParameterBindingTestDouble(HttpParameterDescriptor descriptor, IEnumerable<ValueProviderFactory> factories) : base(descriptor)
            {
                Factories = factories;
            }

            public override Task ExecuteBindingAsync(Metadata.ModelMetadataProvider metadataProvider, HttpActionContext actionContext, Threading.CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }

            public IEnumerable<ValueProviderFactory> ValueProviderFactories
            {
                get { return Factories; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/ModelBinderAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class ModelBinderAttributeTest
    {
        [Fact]
        public void Empty_BinderType()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ModelBinderProvider), new CustomModelBinderProvider());

            ModelBinderAttribute attr = new ModelBinderAttribute();

            ModelBinderProvider provider = attr.GetModelBinderProvider(config);
            Assert.IsType<CustomModelBinderProvider>(provider);
        }

        [Fact]
        public void Illegal_BinderType()
        {
            // Given an illegal type.
            // Constructor shouldn't throw. But trying to instantiate the model binder provider will throw.
            HttpConfiguration config = new HttpConfiguration();
            ModelBinderAttribute attr = new ModelBinderAttribute(typeof(object));

            Assert.Equal(typeof(object), attr.BinderType); // can still lookup illegal type
            Assert.Throws<InvalidOperationException>(
                () => attr.GetModelBinderProvider(config)
            );
        }

        [Fact]
        public void BinderType_Provided()
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelBinderAttribute attr = new ModelBinderAttribute(typeof(CustomModelBinderProvider));

            ModelBinderProvider provider = attr.GetModelBinderProvider(config);
            Assert.IsType<CustomModelBinderProvider>(provider);
        }

        [Fact]
        public void BinderType_From_DependencyResolver()
        {
            // To test dependency resolver, the registered type and actual type should be different.
            HttpConfiguration config = new HttpConfiguration();
            var mockDependencyResolver = new Mock<IDependencyResolver>();
            mockDependencyResolver.Setup(r => r.GetService(typeof(CustomModelBinderProvider)))
                               .Returns(new SecondCustomModelBinderProvider());
            config.DependencyResolver = mockDependencyResolver.Object;

            ModelBinderAttribute attr = new ModelBinderAttribute(typeof(CustomModelBinderProvider));

            ModelBinderProvider provider = attr.GetModelBinderProvider(config);
            Assert.IsType<SecondCustomModelBinderProvider>(provider);
        }

        [Fact]
        public void BinderType_From_DependencyResolver_ReleasedWhenConfigIsDisposed()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            var mockDependencyResolver = new Mock<IDependencyResolver>();
            SecondCustomModelBinderProvider provider = new SecondCustomModelBinderProvider();
            mockDependencyResolver.Setup(r => r.GetService(typeof(CustomModelBinderProvider))).Returns(provider);
            config.DependencyResolver = mockDependencyResolver.Object;

            ModelBinderAttribute attr = new ModelBinderAttribute(typeof(CustomModelBinderProvider));
            attr.GetModelBinderProvider(config);

            // Act
            config.Dispose();

            // Assert
            mockDependencyResolver.Verify(dr => dr.Dispose(), Times.Once());
        }

        [Fact]
        public void Set_ModelBinder_And_ValueProviders()
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelBinderAttribute attr = new ValueProviderAttribute(typeof(CustomValueProviderFactory)) { BinderType = typeof(CustomModelBinderProvider) };
            IEnumerable<ValueProviderFactory> vpfs = attr.GetValueProviderFactories(config);

            Assert.IsType<CustomModelBinderProvider>(attr.GetModelBinderProvider(config));
            object valueProviderFactory = Assert.Single(vpfs);
            Assert.IsType<CustomValueProviderFactory>(valueProviderFactory);
        }

        [Fact]
        public void Get_ModelBinder_From_Empty_Attribute()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ModelBinderProvider), new CustomModelBinderProvider());

            // binder = null, so pulls default from config. But attribute still has value by specifying the value providers.
            ModelBinderAttribute attr = new ValueProviderAttribute(typeof(CustomValueProviderFactory));

            // Act
            IModelBinder binder = attr.GetModelBinder(config, null);

            // Assert
            Assert.Null(attr.BinderType); // using the default
            Assert.NotNull(binder);
            Assert.IsType<CustomModelBinder>(binder);
        }

        [Fact]
        public void Get_ModelBinder_From_Binder()
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelBinderAttribute attr = new ModelBinderAttribute { BinderType = typeof(CustomModelBinder) };

            // Act
            IModelBinder binder = attr.GetModelBinder(config, null);

            // Assert
            Assert.NotNull(binder);
            Assert.IsType<CustomModelBinder>(binder);
        }

        [Fact]
        public void Get_ModelBinder_From_BinderProvider()
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelBinderAttribute attr = new ModelBinderAttribute { BinderType = typeof(CustomModelBinderProvider) };

            // Act
            IModelBinder binder = attr.GetModelBinder(config, null);

            // Assert
            Assert.NotNull(binder);
            Assert.IsType<CustomModelBinder>(binder);
        }

        private class CustomModelBinderProvider : ModelBinderProvider
        {
            public override IModelBinder GetBinder(HttpConfiguration config, Type modelType)
            {
                return new CustomModelBinder();
            }
        }

        private class CustomModelBinder : IModelBinder
        {
            public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
            {
                return true;
            }
        }

        private class SecondCustomModelBinderProvider : ModelBinderProvider
        {
            public override IModelBinder GetBinder(HttpConfiguration config, Type modelType)
            {
                throw new NotImplementedException();
            }
        }

        private class CustomValueProviderFactory : ValueProviderFactory
        {
            public override IValueProvider GetValueProvider(HttpActionContext actionContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/ModelBinderConfigTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class ModelBinderConfigTest
    {
        [Fact]
        public void GetUserResourceString_NullControllerContext_ReturnsNull()
        {
            // Act
            string customResourceString = ModelBinderConfig.GetUserResourceString(null /* controllerContext */, "someResourceName", "someResourceClassKey");

            // Assert
            Assert.Null(customResourceString);
        }

        [Fact]
        public void TypeConversionErrorMessageProvider_DefaultValue()
        {
            // Arrange
            ModelMetadata metadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(int), "SomePropertyName");

            // Act
            string errorString = ModelBinderConfig.TypeConversionErrorMessageProvider(null, metadata, "some incoming value");

            // Assert
            Assert.Equal("The value 'some incoming value' is not valid for SomePropertyName.", errorString);
        }

        [Fact]
        public void TypeConversionErrorMessageProvider_Property()
        {
            // Arrange
            ModelBinderConfigWrapper wrapper = new ModelBinderConfigWrapper();

            // Act & assert
            try
            {
                MemberHelper.TestPropertyWithDefaultInstance(wrapper, "TypeConversionErrorMessageProvider", (ModelBinderErrorMessageProvider)DummyErrorSelector);
            }
            finally
            {
                wrapper.Reset();
            }
        }

        [Fact]
        public void ValueRequiredErrorMessageProvider_DefaultValue()
        {
            // Arrange
            ModelMetadata metadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(int), "SomePropertyName");

            // Act
            string errorString = ModelBinderConfig.ValueRequiredErrorMessageProvider(null, metadata, "some incoming value");

            // Assert
            Assert.Equal("A value is required.", errorString);
        }

        [Fact]
        public void ValueRequiredErrorMessageProvider_Property()
        {
            // Arrange
            ModelBinderConfigWrapper wrapper = new ModelBinderConfigWrapper();

            // Act & assert
            try
            {
                MemberHelper.TestPropertyWithDefaultInstance(wrapper, "ValueRequiredErrorMessageProvider", (ModelBinderErrorMessageProvider)DummyErrorSelector);
            }
            finally
            {
                wrapper.Reset();
            }
        }

        private string DummyErrorSelector(HttpActionContext actionContext, ModelMetadata modelMetadata, object incomingValue)
        {
            throw new NotImplementedException();
        }

        private sealed class ModelBinderConfigWrapper
        {
            public ModelBinderErrorMessageProvider TypeConversionErrorMessageProvider
            {
                get { return ModelBinderConfig.TypeConversionErrorMessageProvider; }
                set { ModelBinderConfig.TypeConversionErrorMessageProvider = value; }
            }

            public ModelBinderErrorMessageProvider ValueRequiredErrorMessageProvider
            {
                get { return ModelBinderConfig.ValueRequiredErrorMessageProvider; }
                set { ModelBinderConfig.ValueRequiredErrorMessageProvider = value; }
            }

            public void Reset()
            {
                ModelBinderConfig.TypeConversionErrorMessageProvider = null;
                ModelBinderConfig.ValueRequiredErrorMessageProvider = null;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/ModelBindingContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Metadata.Providers;
using System.Web.Http.Util;
using System.Web.Http.Validation;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    public class ModelBindingContextTest
    {
        [Fact]
        public void CopyConstructor()
        {
            // Arrange
            ModelBindingContext originalBindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object)),
                ModelName = "theName",
                ModelState = new ModelStateDictionary(),
                ValueProvider = new SimpleHttpValueProvider()
            };

            // Act
            ModelBindingContext newBindingContext = new ModelBindingContext(originalBindingContext);

            // Assert
            Assert.Null(newBindingContext.ModelMetadata);
            Assert.Equal("", newBindingContext.ModelName);
            Assert.Equal(originalBindingContext.ModelState, newBindingContext.ModelState);
            Assert.Equal(originalBindingContext.ValueProvider, newBindingContext.ValueProvider);
        }

        [Fact]
        public void ModelProperty()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(int))
            };

            // Act & assert
            MemberHelper.TestPropertyValue(bindingContext, "Model", 42);
        }

        [Fact]
        public void ModelProperty_ThrowsIfModelMetadataDoesNotExist()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                () => bindingContext.Model = null,
                "The ModelMetadata property must be set before accessing this property.");
        }

        [Fact]
        public void ModelNameProperty()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();

            // Act & assert
            Assert.Reflection.StringProperty(bindingContext, bc => bc.ModelName, String.Empty);
        }

        [Fact]
        public void ModelStateProperty()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();
            ModelStateDictionary modelState = new ModelStateDictionary();

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(bindingContext, "ModelState", modelState);
        }

        [Fact]
        public void ModelAndModelTypeAreFedFromModelMetadata()
        {
            // Act
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => 42, typeof(int))
            };

            // Assert
            Assert.Equal(42, bindingContext.Model);
            Assert.Equal(typeof(int), bindingContext.ModelType);
        }

        [Fact]
        public void ValidationNodeProperty()
        {
            // Act
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => 42, typeof(int))
            };

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(bindingContext, "ValidationNode", new ModelValidationNode(bindingContext.ModelMetadata, "someName"));
        }

        [Fact]
        public void ValidationNodeProperty_DefaultValues()
        {
            // Act
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => 42, typeof(int)),
                ModelName = "theInt"
            };

            // Act
            ModelValidationNode validationNode = bindingContext.ValidationNode;

            // Assert
            Assert.NotNull(validationNode);
            Assert.Equal(bindingContext.ModelMetadata, validationNode.ModelMetadata);
            Assert.Equal(bindingContext.ModelName, validationNode.ModelStateKey);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/ModelBindingEndToEndTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Newtonsoft.Json;

namespace System.Web.Http.ModelBinding
{
    /// <summary>
    /// End-to-end tests for model binding.
    /// </summary>
    public class ModelBindingEndToEndTests
    {
        [Fact]
        public async Task BindModel_BindsValuesFromUrl()
        {
            // Arrange
            string value = "some-value";
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get,
                            "http://localhost/ModelBinding/Url?somekey=" + value);

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            Assert.Equal(value, await ReadAsJson<string>(response));
        }

        [Fact]
        public async Task BindModel_BindsSimpleTypesFromBody()
        {
            // Arrange
            Dictionary<string, string> bodyParameters = new Dictionary<string, string>
            {
                { "Name", "PersonName" },
                { "Sibling.Name", "SiblingName" },
            };
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post,
                            "http://localhost/ModelBinding/SimpleType")
            {
                Content = new FormUrlEncodedContent(bodyParameters)
            };

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            Person result = await ReadAsJson<Person>(response);
            Assert.Equal("PersonName", result.Name);
            Assert.Equal("SiblingName", result.Sibling.Name);
        }

        [Fact]
        public async Task BindModel_WithCollection()
        {
            // Arrange
            Dictionary<string, string> bodyParameters = new Dictionary<string, string>
            {
                { "AddressLines[0].Line", "Street Address 0" },
                { "AddressLines[1].Line", "Street Address 1" },
                { "ZipCode", "98052" },
            };
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put,
                            "http://localhost/ModelBinding/CollectionType")
            {
                Content = new FormUrlEncodedContent(bodyParameters)
            };

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            Address address = await ReadAsJson<Address>(response);
            Assert.Equal(2, address.AddressLines.Count);
            Assert.Equal("Street Address 0", address.AddressLines[0].Line);
            Assert.Equal("Street Address 1", address.AddressLines[1].Line);
            Assert.Equal("98052", address.ZipCode);
        }

        [Fact]
        public async Task BindModel_WithCollection_SpecifyingIndex()
        {
            // Arrange
            IEnumerable<KeyValuePair<string, string>> bodyParameters = new[]
            {
                new KeyValuePair<string, string>("AddressLines.index", "3"),
                new KeyValuePair<string, string>("AddressLines.index", "10000"),
                new KeyValuePair<string, string>("AddressLines[3].Line", "Street Address 0"),
                new KeyValuePair<string, string>("AddressLines[10000].Line", "Street Address 1"),
            };
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Put,
                            "http://localhost/ModelBinding/CollectionType")
            {
                Content = new FormUrlEncodedContent(bodyParameters)
            };

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            Address address = await ReadAsJson<Address>(response);
            Assert.Equal(2, address.AddressLines.Count);
            Assert.Equal("Street Address 0", address.AddressLines[0].Line);
            Assert.Equal("Street Address 1", address.AddressLines[1].Line);
        }

        [Fact]
        public async Task BindModel_WithNestedCollection()
        {
            // Arrange
            Dictionary<string, string> bodyParameters = new Dictionary<string, string>
            {
                { "Addresses[0].AddressLines[0].Line", "Street Address 00" },
                { "Addresses[0].AddressLines[1].Line", "Street Address 01" },
                { "Addresses[0].ZipCode", "98052" },
                { "Addresses[1].AddressLines[0].Line", "Street Address 10" },
                { "Addresses[1].AddressLines[3].Line", "Street Address 13" },
            };
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post,
                            "http://localhost/ModelBinding/NestedCollection")
            {
                Content = new FormUrlEncodedContent(bodyParameters)
            };

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            UserWithAddress result = await ReadAsJson<UserWithAddress>(response);
            Assert.Equal(2, result.Addresses.Count);
            Address address = result.Addresses[0];
            Assert.Equal(2, address.AddressLines.Count);
            Assert.Equal("Street Address 00", address.AddressLines[0].Line);
            Assert.Equal("Street Address 01", address.AddressLines[1].Line);
            Assert.Equal("98052", address.ZipCode);

            address = result.Addresses[1];
            StreetAddress streetAddress= streetAddress = Assert.Single(address.AddressLines);
            Assert.Equal("Street Address 10", streetAddress.Line);
            Assert.Null(address.ZipCode);
        }

        [Fact]
        public async Task BindModel_WithIncorrectlyFormattedNestedCollectionValue()
        {
            // Arrange
            Dictionary<string, string> bodyParameters = new Dictionary<string, string>
            {
                { "Addresses", "Street Address 00" },
            };
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post,
                            "http://localhost/ModelBinding/NestedCollection")
            {
                Content = new FormUrlEncodedContent(bodyParameters)
            };

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            UserWithAddress result = await ReadAsJson<UserWithAddress>(response);
            Address address = Assert.Single(result.Addresses);
            Assert.Null(address.AddressLines);
            Assert.Null(address.ZipCode);
        }

        [Fact]
        public async Task BindModel_WithNestedCollectionContainingARecursiveRelation()
        {
            // Arrange
            Dictionary<string, string> bodyParameters = new Dictionary<string, string>
            {
                { "People[0].Name", "Person 0" },
                { "People[0].Sibling.Name", "Person 0 Sibling" },
                { "People[1].Sibling.Name", "Person 1 Sibling" },
                { "People[2].Sibling", "Person 2 Sibling" },
                { "People[1000].Name", "Person 1000 Sibling" },
            };
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post,
                            "http://localhost/ModelBinding/NestedCollectionOfRecursiveTypes")
            {
                Content = new FormUrlEncodedContent(bodyParameters)
            };

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            PeopleModel result = await ReadAsJson<PeopleModel>(response);
            Assert.Equal(3, result.People.Count);
            Person person = result.People[0];

            Assert.Equal("Person 0", person.Name);
            Assert.Equal("Person 0 Sibling", person.Sibling.Name);
            Assert.Null(person.Sibling.Sibling);

            person = result.People[1];
            Assert.Equal("Person 1 Sibling", person.Sibling.Name);
            Assert.Null(person.Sibling.Sibling);

            person = result.People[2];
            Assert.Null(person.Name);
            Assert.NotNull(person.Sibling);
            Assert.Null(person.Sibling.Name);
        }

        [Fact]
        public async Task BindModel_WithNestedCollectionContainingRecursiveRelation_WithMalformedValue()
        {
            // Arrange
            Dictionary<string, string> bodyParameters = new Dictionary<string, string>
            {
                { "People", "Person 0" },
            };
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Post,
                            "http://localhost/ModelBinding/NestedCollectionOfRecursiveTypes")
            {
                Content = new FormUrlEncodedContent(bodyParameters)
            };

            // Act
            HttpResponseMessage response = await SubmitRequestAsync(request);

            // Assert
            PeopleModel result = await ReadAsJson<PeopleModel>(response);
            Person person = Assert.Single(result.People);
            Assert.Null(person.Name);
            Assert.Null(person.Sibling);
        }

        private static async Task<HttpResponseMessage> SubmitRequestAsync(HttpRequestMessage request)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.MapHttpAttributeRoutes();
            HttpServer server = new HttpServer(config);
            using (HttpMessageInvoker client = new HttpMessageInvoker(server))
            {
                HttpResponseMessage response = await client.SendAsync(request, CancellationToken.None);
                response.EnsureSuccessStatusCode();

                return response;
            }
        }

        private static async Task<TVal> ReadAsJson<TVal>(HttpResponseMessage response)
        {
            Assert.Equal(MediaTypeHeaderValue.Parse("application/json; charset=utf-8"),
                         response.Content.Headers.ContentType);
            string content = await response.Content.ReadAsStringAsync();
            return JsonConvert.DeserializeObject<TVal>(content);
        }
    }

    [RoutePrefix("ModelBinding")]
    public class ModelBindingController : ApiController
    {
        [HttpGet]
        [Route("Url")]
        public string UrlBinding([FromUri] string someKey)
        {
            return someKey;
        }

        [HttpPost]
        [Route("SimpleType")]
        public Person SimpleType([FromBody] Person model)
        {
            return model;
        }

        [HttpPut]
        [Route("CollectionType")]
        public Address CollectionType([FromBody] Address address)
        {
            return address;
        }

        [HttpPost]
        [Route("NestedCollection")]
        public UserWithAddress NestedCollectionType([FromBody] UserWithAddress user)
        {
            return user;
        }

        [HttpPost]
        [Route("NestedCollectionOfRecursiveTypes")]
        public PeopleModel NestedCollectionType([FromBody] PeopleModel model)
        {
            return model;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/ModelBindingUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.ModelBinding
{
    public class ModelBindingUtilTest
    {
        [Fact]
        public void CastOrDefault_CorrectType_ReturnsInput()
        {
            // Act
            int retVal = ModelBindingHelper.CastOrDefault<int>(42);

            // Assert
            Assert.Equal(42, retVal);
        }

        [Fact]
        public void CastOrDefault_IncorrectType_ReturnsDefaultTModel()
        {
            // Act
            DateTime retVal = ModelBindingHelper.CastOrDefault<DateTime>(42);

            // Assert
            Assert.Equal(default(DateTime), retVal);
        }

        [Fact]
        public void CreateIndexModelName_EmptyParentName()
        {
            // Act
            string fullChildName = ModelBindingHelper.CreateIndexModelName("", 42);

            // Assert
            Assert.Equal("[42]", fullChildName);
        }

        [Fact]
        public void CreateIndexModelName_IntIndex()
        {
            // Act
            string fullChildName = ModelBindingHelper.CreateIndexModelName("parentName", 42);

            // Assert
            Assert.Equal("parentName[42]", fullChildName);
        }

        [Fact]
        public void CreateIndexModelName_StringIndex()
        {
            // Act
            string fullChildName = ModelBindingHelper.CreateIndexModelName("parentName", "index");

            // Assert
            Assert.Equal("parentName[index]", fullChildName);
        }

        [Fact]
        public void CreatePropertyModelName()
        {
            // Act
            string fullChildName = ModelBindingHelper.CreatePropertyModelName("parentName", "childName");

            // Assert
            Assert.Equal("parentName.childName", fullChildName);
        }

        [Fact]
        public void CreatePropertyModelName_EmptyParentName()
        {
            // Act
            string fullChildName = ModelBindingHelper.CreatePropertyModelName("", "childName");

            // Assert
            Assert.Equal("childName", fullChildName);
        }

        [Fact]
        public void GetPossibleBinderInstance_Match_ReturnsBinder()
        {
            // Act
            IModelBinder binder = ModelBindingHelper.GetPossibleBinderInstance(typeof(List<int>), typeof(List<>), typeof(SampleGenericBinder<>));

            // Assert
            Assert.IsType<SampleGenericBinder<int>>(binder);
        }

        [Fact]
        public void GetPossibleBinderInstance_NoMatch_ReturnsNull()
        {
            // Act
            IModelBinder binder = ModelBindingHelper.GetPossibleBinderInstance(typeof(ArraySegment<int>), typeof(List<>), typeof(SampleGenericBinder<>));

            // Assert
            Assert.Null(binder);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsEnumerable_ReturnsInputAsArray()
        {
            // Assert
            List<int> original = new List<int> { 1, 2, 3, 4 };

            // Act
            object[] retVal = ModelBindingHelper.RawValueToObjectArray(original);

            // Assert
            Assert.Equal(new object[] { 1, 2, 3, 4 }, retVal);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsObject_WrapsObjectInSingleElementArray()
        {
            // Act
            object[] retVal = ModelBindingHelper.RawValueToObjectArray(42);

            // Assert
            Assert.Equal(new object[] { 42 }, retVal);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsObjectArray_ReturnsInputInstance()
        {
            // Assert
            object[] original = new object[2];

            // Act
            object[] retVal = ModelBindingHelper.RawValueToObjectArray(original);

            // Assert
            Assert.Same(original, retVal);
        }

        [Fact]
        public void RawValueToObjectArray_RawValueIsString_WrapsStringInSingleElementArray()
        {
            // Act
            object[] retVal = ModelBindingHelper.RawValueToObjectArray("hello");

            // Assert
            Assert.Equal(new object[] { "hello" }, retVal);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullDisabled_ModelIsEmptyString_LeavesModelAlone()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = false;

            // Act
            object model = "";
            ModelBindingHelper.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Equal("", model);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullEnabled_ModelIsEmptyString_ReplacesModelWithNull()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = true;

            // Act
            object model = "";
            ModelBindingHelper.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Null(model);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullEnabled_ModelIsWhitespaceString_ReplacesModelWithNull()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = true;

            // Act
            object model = "     "; // whitespace
            ModelBindingHelper.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Null(model);
        }

        [Fact]
        public void ReplaceEmptyStringWithNull_ConvertEmptyStringToNullDisabled_ModelIsNotEmptyString_LeavesModelAlone()
        {
            // Arrange
            ModelMetadata modelMetadata = GetMetadata(typeof(string));
            modelMetadata.ConvertEmptyStringToNull = true;

            // Act
            object model = 42;
            ModelBindingHelper.ReplaceEmptyStringWithNull(modelMetadata, ref model);

            // Assert
            Assert.Equal(42, model);
        }

        [Fact]
        public void ValidateBindingContext_SuccessWithNonNullModel()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };
            bindingContext.ModelMetadata.Model = "hello!";

            // Act
            ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(string), false);

            // Assert
            // Nothing to do - if we got this far without throwing, the test succeeded
        }

        [Fact]
        public void ValidateBindingContext_SuccessWithNullModel()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };

            // Act
            ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(string), true);

            // Assert
            // Nothing to do - if we got this far without throwing, the test succeeded
        }

        [Fact]
        public void ValidateBindingContextThrowsIfBindingContextIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => ModelBindingHelper.ValidateBindingContext(null, typeof(string), true),
                "bindingContext");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelInstanceIsWrongType()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };
            bindingContext.ModelMetadata.Model = 42;

            // Act & assert
            Assert.ThrowsArgument(
                () => ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(string), allowNullModel: true),
                "bindingContext",
                "The binding context has a Model of type 'System.Int32', but this binder can only operate on models of type 'System.String'.");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelIsNullButCannotBe()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(string))
            };

            // Act & assert
            Assert.ThrowsArgument(
                () => ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(string), false),
                "bindingContext",
                "The binding context has a null Model, but this binder requires a non-null model of type 'System.String'.");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelMetadataIsNull()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();

            // Act & assert
            Assert.ThrowsArgument(
                () => ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(string), true),
                "bindingContext",
                "The binding context cannot have a null ModelMetadata.");
        }

        [Fact]
        public void ValidateBindingContextThrowsIfModelTypeIsWrong()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = GetMetadata(typeof(object))
            };

            // Act & assert
            Assert.ThrowsArgument(
                () => ModelBindingHelper.ValidateBindingContext(bindingContext, typeof(string), true),
                "bindingContext",
                "The binding context has a ModelType of 'System.Object', but this binder can only operate on models of type 'System.String'.");
        }

        private static ModelMetadata GetMetadata(Type modelType)
        {
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            return provider.GetMetadataForType(null, modelType);
        }

        private class SampleGenericBinder<T> : IModelBinder
        {
            public bool BindModel(HttpActionContext actionContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/ParameterBindingProvidersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ModelBinding
{
    public class ParameterBindingProvidersTest
    {
        [Fact]
        public void AsCollection()
        {
            ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();

            // Knowing that it's a collection means we have known behavior around 
            // the collection methods (like insert, add, clear, etc).
            Assert.True(pb is Collection<Func<HttpParameterDescriptor, HttpParameterBinding>>);
        }

        [Fact]
        public void Lookup_empty_collection_returns_null()
        {
            // The collection is empty,  so lookup will fail.
            ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
            HttpParameterDescriptor parameter = CreateParameterDescriptor(typeof(object), "none");

            // Act
            HttpParameterBinding binding = pb.LookupBinding(parameter);

            // Assert. 
            Assert.Null(binding);
        }

        [Fact]
        public void Lookup_is_ordered()
        {
            ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
            HttpParameterBinding mockBinding1 = new EmptyParameterBinding();
            HttpParameterBinding mockBinding2 = new EmptyParameterBinding();
            HttpParameterBinding mockBinding3 = new EmptyParameterBinding();

            pb.Add(param => param.ParameterName == "first" ? mockBinding1 : null);
            pb.Add(param => param.ParameterName == "first" ? mockBinding2 : null);
            pb.Add(param => param.ParameterType == typeof(int) ? mockBinding3 : null);

            // Act
            HttpParameterBinding b1 = pb.LookupBinding(CreateParameterDescriptor(null, "first"));
            HttpParameterBinding b2 = pb.LookupBinding(CreateParameterDescriptor(typeof(string), "none"));
            HttpParameterBinding b3 = pb.LookupBinding(CreateParameterDescriptor(typeof(int), "first"));
            HttpParameterBinding b4 = pb.LookupBinding(CreateParameterDescriptor(typeof(int), "last"));


            // Assert
            Assert.Equal(mockBinding1, b1);
            Assert.Null(b2);
            Assert.Equal(mockBinding1, b3);
            Assert.Equal(mockBinding3, b4);
        }

        [Fact]
        public void Add_with_type_match()
        {
            ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
            HttpParameterBinding mockBinding = new EmptyParameterBinding();

            pb.Add(typeof(string), param => mockBinding);

            // Act
            HttpParameterBinding b1 = pb.LookupBinding(CreateParameterDescriptor(typeof(string), "first"));
            HttpParameterBinding b2 = pb.LookupBinding(CreateParameterDescriptor(typeof(int), "first"));

            // Assert
            Assert.Equal(mockBinding, b1);
            Assert.Null(b2); // doesn't match type, misses.
        }

        [Fact]
        public void type_match_user_function_not_invoked_if_type_doesnt_match()
        {
            ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
            HttpParameterBinding mockBinding = new EmptyParameterBinding();

            pb.Add(typeof(string), param => { throw new InvalidOperationException("shouldn't be called"); });
            pb.Insert(0, typeof(string), param => { throw new InvalidOperationException("shouldn't be called"); });

            // Act
            HttpParameterBinding b2 = pb.LookupBinding(CreateParameterDescriptor(typeof(int), "first"));

            // Assert - made it through the action without throwing.
        }

        [Fact]
        public void Insert_with_type_match()
        {
            ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
            HttpParameterBinding mockBinding1 = new EmptyParameterBinding();
            HttpParameterBinding mockBinding2 = new EmptyParameterBinding();
            HttpParameterBinding mockBinding3 = new EmptyParameterBinding();

            // Act, test insertion            
            pb.Add(typeof(string), param => mockBinding2);
            pb.Add(typeof(int), param => mockBinding2);
            pb.Insert(0, typeof(string), param => mockBinding1);
            pb.Insert(2, typeof(int), param => mockBinding3); // goes in middle

            // Assert via lookups
            Assert.Equal(mockBinding1, pb.LookupBinding(CreateParameterDescriptor(typeof(string), "first")));
            Assert.Equal(mockBinding3, pb.LookupBinding(CreateParameterDescriptor(typeof(int), "first")));            
        }

        // For unit testing purposes, just create a unique binding objet. 
        // We'll just compare object reference identity to determine if binds give the expected binding back.
        // ParameterDescriptor is ignored.
        private class EmptyParameterBinding : HttpParameterBinding
        {
            public EmptyParameterBinding()
                : base(CreateParameterDescriptor(typeof(object), "dummy"))
            { 
            }

            public override Threading.Tasks.Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, Threading.CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }
        }
        
        private static HttpParameterDescriptor CreateParameterDescriptor(Type type, string name)
        {
            Mock<HttpParameterDescriptor> mock = new Mock<HttpParameterDescriptor>();
            mock.Setup(p => p.ParameterType).Returns(type);
            mock.Setup(p => p.ParameterName).Returns(name);
            return mock.Object;
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/ModelBinding/SharedModels/Address.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.ModelBinding
{
    public class Address
    {
        public List<StreetAddress> AddressLines { get; set; }

        public string ZipCode { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/SharedModels/PeopleModel.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.ModelBinding
{
    public class PeopleModel
    {
        public List<Person> People { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/SharedModels/Person.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ModelBinding
{
    public class Person
    {
        public Person Sibling { get; set; }

        public string Name { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/SharedModels/StreetAddress.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Http.ModelBinding
{
    public class StreetAddress
    {
        public string Line { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Test/ModelBinding/SharedModels/User.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.ModelBinding
{
    public class UserWithAddress
    {
        public List<Address> Addresses { get; set; }
    }
}


================================================
FILE: test/System.Web.Http.Test/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

[assembly: CLSCompliant(false)]


================================================
FILE: test/System.Web.Http.Test/Resources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.18033
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Http {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Http.Resources", typeof(Resources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Localized Value.
        /// </summary>
        public static string String1 {
            get {
                return ResourceManager.GetString("String1", resourceCulture);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Resources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="String1" xml:space="preserve">
    <value>Localized Value</value>
  </data>
</root>

================================================
FILE: test/System.Web.Http.Test/Results/BadRequestErrorMessageResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class BadRequestErrorMessageResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenMessageIsNull()
        {
            // Arrange
            string message = null;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(message, contentNegotiator, request, formatters);
                }, "message");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenContentNegotiatorIsNull()
        {
            // Arrange
            string message = CreateMessage();
            IContentNegotiator contentNegotiator = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(message, contentNegotiator, request, formatters);
                }, "contentNegotiator");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            string message = CreateMessage();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();
            HttpRequestMessage request = null;
            IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(message, contentNegotiator, request, formatters);
            }, "request");
        }

        [Fact]
        public void Constructor_Throws_WhenFormattersIsNull()
        {
            // Arrange
            string message = CreateMessage();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(message, contentNegotiator, request, formatters);
                }, "formatters");
            }
        }

        [Fact]
        public void Message_ReturnsInstanceProvided()
        {
            // Arrange
            string expectedMessage = CreateMessage();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                BadRequestErrorMessageResult result = CreateProductUnderTest(expectedMessage, contentNegotiator,
                    request, formatters);

                // Act
                string message = result.Message;

                // Assert
                Assert.Same(expectedMessage, message);
            }
        }

        [Fact]
        public void ContentNegotiator_ReturnsInstanceProvided()
        {
            // Arrange
            string message = CreateMessage();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, expectedContentNegotiator,
                    request, formatters);

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ReturnsInstanceProvided()
        {
            // Arrange
            string message = CreateMessage();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, contentNegotiator,
                    expectedRequest, formatters);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Formatters_ReturnsInstanceProvided()
        {
            // Arrange
            string message = CreateMessage();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, contentNegotiator, request,
                    expectedFormatters);

                // Act
                IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                // Assert
                Assert.Same(expectedFormatters, formatters);
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationSucceeds()
        {
            // Arrange
            string expectedMessage = CreateMessage();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(expectedMessage, contentNegotiator, expectedRequest,
                    expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                    HttpError error = (HttpError)typedContent.Value;
                    Assert.NotNull(error);
                    Assert.Same(expectedMessage, error.Message);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationFails()
        {
            // Arrange
            string message = CreateMessage();
            ContentNegotiationResult negotiationResult = null;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(message, contentNegotiator, expectedRequest,
                    expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(message, controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse_WhenContentNegotationSucceeds()
        {
            // Arrange
            string expectedMessage = CreateMessage();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedInputFormatter = CreateFormatter();
            MediaTypeFormatter expectedOutputFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedOutputFormatter,
                expectedMediaType);

            Expression<Func<IEnumerable<MediaTypeFormatter>, bool>> formattersMatch = (f) =>
                f != null && f.AsArray().Length == 1 && f.AsArray()[0] == expectedInputFormatter;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, It.Is(formattersMatch))).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                using (HttpConfiguration configuration = CreateConfiguration(expectedInputFormatter,
                    contentNegotiator))
                {
                    configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
                    controller.Configuration = configuration;
                    controller.Request = expectedRequest;

                    IHttpActionResult result = CreateProductUnderTest(expectedMessage, controller);

                    // Act
                    Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                    // Assert
                    Assert.NotNull(task);

                    using (HttpResponseMessage response = await task)
                    {
                        Assert.NotNull(response);
                        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                        HttpContent content = response.Content;
                        ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                        HttpError error = (HttpError)typedContent.Value;
                        Assert.NotNull(error);
                        Assert.Same(expectedMessage, error.Message);
                        Assert.NotNull(typedContent.Headers);
                        Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                    IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
                    configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.Same(expectedContentNegotiator, contentNegotiator);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string message = CreateMessage();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = CreateController();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                MediaTypeFormatter expectedFormatter = CreateFormatter();

                using (HttpConfiguration lateConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string message = CreateMessage();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), expectedContentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                IContentNegotiator ignore = result.ContentNegotiator;

                configuration.Services.Replace(typeof(IContentNegotiator), CreateDummyContentNegotiator());

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;
                    HttpRequestMessage ignore = result.Request;

                    using (HttpRequestMessage otherRequest = CreateRequest())
                    {
                        controller.Request = otherRequest;

                        // Act
                        HttpRequestMessage request = result.Request;

                        // Assert
                        Assert.Same(expectedRequest, request);
                    }
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                IEnumerable<MediaTypeFormatter> ignore = result.Formatters;

                using (HttpConfiguration lateConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenConfigurationIsNull()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = CreateController();
            HttpControllerContext context = new HttpControllerContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.ControllerContext = context;

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "HttpControllerContext.Configuration must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenServiceIsNull()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), null))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Request = request;
                controller.Configuration = configuration;

                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "The provided configuration does not have an instance of the " +
                    "'System.Net.Http.Formatting.IContentNegotiator' service registered.");
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            string message = CreateMessage();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                BadRequestErrorMessageResult result = CreateProductUnderTest(message, controller);

                // Act & Assert
                InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
            }
        }

        [Fact]
        public void ApiControllerBadRequest_WithString_CreatesCorrectResult()
        {
            // Arrange
            string expectedMessage = CreateMessage();
            ApiController controller = CreateController();

            // Act
            BadRequestErrorMessageResult result = controller.BadRequest(expectedMessage);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedMessage, result.Message);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static HttpConfiguration CreateConfiguration(MediaTypeFormatter formatter,
            IContentNegotiator contentNegotiator)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Formatters.Clear();
            configuration.Formatters.Add(formatter);
            configuration.Services.Replace(typeof(IContentNegotiator), contentNegotiator);
            return configuration;
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static IContentNegotiator CreateDummyContentNegotiator()
        {
            return new Mock<IContentNegotiator>(MockBehavior.Strict).Object;
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubMediaTypeFormatter();
        }

        private static IEnumerable<MediaTypeFormatter> CreateFormatters()
        {
            return new MediaTypeFormatter[0];
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static string CreateMessage()
        {
            return "IgnoreMessage";
        }

        private static BadRequestErrorMessageResult CreateProductUnderTest(string message,
            IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
        {
            return new BadRequestErrorMessageResult(message, contentNegotiator, request, formatters);
        }

        private static BadRequestErrorMessageResult CreateProductUnderTest(string message, ApiController controller)
        {
            return new BadRequestErrorMessageResult(message, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class StubMediaTypeFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/BadRequestResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class BadRequestResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(request); }, "request");
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                BadRequestResult result = CreateProductUnderTest(expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = CreateProductUnderTest(controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ApiController controller = CreateController();
            BadRequestResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ApiController controller = CreateController();
            BadRequestResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            BadRequestResult result = CreateProductUnderTest(controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerBadRequest_CreatesCorrectResult()
        {
            // Arrange
            ApiController controller = CreateController();

            // Act
            BadRequestResult result = controller.BadRequest();

            // Assert
            Assert.NotNull(result);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static BadRequestResult CreateProductUnderTest(HttpRequestMessage request)
        {
            return new BadRequestResult(request);
        }

        private static BadRequestResult CreateProductUnderTest(ApiController controller)
        {
            return new BadRequestResult(controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/ConflictResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class ConflictResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(request); }, "request");
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                ConflictResult result = CreateProductUnderTest(expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = CreateProductUnderTest(controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Conflict, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ApiController controller = CreateController();
            ConflictResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ApiController controller = CreateController();
            ConflictResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            ConflictResult result = CreateProductUnderTest(controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerConflict_CreatesCorrectResult()
        {
            // Arrange
            ApiController controller = CreateController();

            // Act
            ConflictResult result = controller.Conflict();

            // Assert
            Assert.NotNull(result);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static ConflictResult CreateProductUnderTest(HttpRequestMessage request)
        {
            return new ConflictResult(request);
        }

        private static ConflictResult CreateProductUnderTest(ApiController controller)
        {
            return new ConflictResult(controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/CreatedAtRouteNegotiatedContentResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class CreatedAtRouteNegotiatedContentResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRouteNameIsNull()
        {
            // Arrange
            string routeName = null;
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();
            UrlHelper urlFactory = CreateDummyUrlFactory();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(routeName, routeValues, content, urlFactory, contentNegotiator, request,
                        formatters);
                }, "routeName");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenUrlFactoryIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();
            UrlHelper urlFactory = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(routeName, routeValues, content, urlFactory, contentNegotiator, request,
                        formatters);
                }, "urlFactory");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenContentNegotiatorIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(routeName, routeValues, content, urlFactory, contentNegotiator, request,
                        formatters);
                }, "contentNegotiator");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();
            HttpRequestMessage request = null;
            IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(routeName, routeValues, content, urlFactory, contentNegotiator, request,
                    formatters);
            }, "request");
        }

        [Fact]
        public void Constructor_Throws_WhenFormattersIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(routeName, routeValues, content, urlFactory, contentNegotiator, request,
                        formatters);
                }, "formatters");
            }
        }

        [Fact]
        public void RouteName_Returns_InstanceProvided()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(expectedRouteName,
                    routeValues, content, urlFactory, contentNegotiator, request, formatters);

                // Act
                string routeName = result.RouteName;

                // Assert
                Assert.Same(expectedRouteName, routeName);
            }
        }

        [Fact]
        public void RouteValues_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName,
                    expectedRouteValues, content, urlFactory, contentNegotiator, request, formatters);

                // Act
                IDictionary<string, object> routeValues = result.RouteValues;

                // Assert
                Assert.Same(expectedRouteValues, routeValues);
            }
        }

        [Fact]
        public void Content_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object expectedContent = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    expectedContent, urlFactory, contentNegotiator, request, formatters);

                // Act
                object content = result.Content;

                // Assert
                Assert.Same(expectedContent, content);
            }
        }

        [Fact]
        public void UrlFactory_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper expectedUrlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, expectedUrlFactory, contentNegotiator, request, formatters);

                // Act
                UrlHelper urlFactory = result.UrlFactory;

                // Assert
                Assert.Same(expectedUrlFactory, urlFactory);
            }
        }

        [Fact]
        public void ContentNegotiator_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, urlFactory, expectedContentNegotiator, request, formatters);

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, urlFactory, contentNegotiator, expectedRequest, formatters);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Formatters_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, urlFactory, contentNegotiator, request, expectedFormatters);

                // Act
                IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                // Assert
                Assert.Same(expectedFormatters, formatters);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationSucceeds()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            object expectedContent = CreateContent();
            Mock<UrlHelper> spyUrlFactory = new Mock<UrlHelper>(MockBehavior.Strict);
            string expectedLocation = CreateLocation().AbsoluteUri;
            spyUrlFactory.Setup(f => f.Link(expectedRouteName, expectedRouteValues)).Returns(expectedLocation);
            UrlHelper urlFactory = spyUrlFactory.Object;
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spyContentNegotiator = new Mock<IContentNegotiator>();
                spyContentNegotiator.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters))
                    .Returns(negotiationResult);
                IContentNegotiator contentNegotiator = spyContentNegotiator.Object;

                IHttpActionResult result = CreateProductUnderTest(expectedRouteName, expectedRouteValues,
                    expectedContent, urlFactory, contentNegotiator, expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Created, response.StatusCode);
                    Assert.Same(expectedLocation, response.Headers.Location.OriginalString);
                    HttpContent content = response.Content;
                    ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                    Assert.Same(expectedContent, typedContent.Value);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationFails()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            ContentNegotiationResult negotiationResult = null;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(routeName, routeValues, content, urlFactory,
                    contentNegotiator, expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
                    Assert.Null(response.Headers.Location);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_Throws_WhenUrlHelperLinkReturnsNull_AfterContentNegotiationSucceeds()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            object expectedContent = CreateContent();
            Mock<UrlHelper> stubUrlFactory = new Mock<UrlHelper>(MockBehavior.Strict);
            stubUrlFactory.Setup(f => f.Link(expectedRouteName, expectedRouteValues)).Returns((string)null);
            UrlHelper urlFactory = stubUrlFactory.Object;
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spyContentNegotiator = new Mock<IContentNegotiator>();
                spyContentNegotiator.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters))
                    .Returns(negotiationResult);
                IContentNegotiator contentNegotiator = spyContentNegotiator.Object;

                IHttpActionResult result = CreateProductUnderTest(expectedRouteName, expectedRouteValues,
                    expectedContent, urlFactory, contentNegotiator, expectedRequest, expectedFormatters);

                // Act & Assert
                InvalidOperationException exception = await Assert.ThrowsAsync<InvalidOperationException>(
                    () => result.ExecuteAsync(CancellationToken.None));
                Assert.Equal("UrlHelper.Link must not return null.", exception.Message);
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(routeName, routeValues, content, controller);
            }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse_WhenContentNegotationSucceeds()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            object expectedContent = CreateContent();
            Mock<UrlHelper> spyUrlFactory = new Mock<UrlHelper>(MockBehavior.Strict);
            string expectedLocation = CreateLocation().AbsoluteUri;
            spyUrlFactory.Setup(f => f.Link(expectedRouteName, expectedRouteValues)).Returns(expectedLocation);
            UrlHelper urlFactory = spyUrlFactory.Object;
            ApiController controller = CreateController();
            MediaTypeFormatter expectedInputFormatter = CreateFormatter();
            MediaTypeFormatter expectedOutputFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedOutputFormatter,
                expectedMediaType);

            Expression<Func<IEnumerable<MediaTypeFormatter>, bool>> formattersMatch = (f) =>
                f != null && f.AsArray().Length == 1 && f.AsArray()[0] == expectedInputFormatter;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, It.Is(formattersMatch))).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                using (HttpConfiguration configuration = CreateConfiguration(expectedInputFormatter,
                    contentNegotiator))
                {
                    controller.Configuration = configuration;
                    controller.Request = expectedRequest;
                    controller.Url = urlFactory;

                    IHttpActionResult result = CreateProductUnderTest(expectedRouteName, expectedRouteValues,
                        expectedContent, controller);

                    // Act
                    Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                    // Assert
                    Assert.NotNull(task);

                    using (HttpResponseMessage response = await task)
                    {
                        Assert.NotNull(response);
                        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
                        Assert.Same(expectedLocation, response.Headers.Location.OriginalString);
                        HttpContent content = response.Content;
                        ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                        Assert.Same(expectedContent, typedContent.Value);
                        Assert.Same(expectedOutputFormatter, typedContent.Formatter);
                        Assert.NotNull(typedContent.Headers);
                        Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public void UrlFactory_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;
                controller.Url = CreateDummyUrlFactory();

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName,
                    routeValues, content, controller);

                UrlHelper expectedUrlFactory = CreateDummyUrlFactory();
                controller.Url = expectedUrlFactory;

                // Act
                UrlHelper urlFactory = result.UrlFactory;

                // Assert
                Assert.Same(expectedUrlFactory, urlFactory);
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName,
                        routeValues, content, controller);

                    IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
                    configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.Same(expectedContentNegotiator, contentNegotiator);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                MediaTypeFormatter expectedFormatter = CreateFormatter();

                using (HttpConfiguration lateConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void UrlFactory_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;
                UrlHelper expectedUrlFactory = CreateDummyUrlFactory();
                controller.Url = expectedUrlFactory;

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                UrlHelper ignore = result.UrlFactory;

                controller.Url = CreateDummyUrlFactory();

                // Act
                UrlHelper urlFactory = result.UrlFactory;

                // Assert
                Assert.Same(expectedUrlFactory, urlFactory);
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), expectedContentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                IContentNegotiator ignore = result.ContentNegotiator;

                configuration.Services.Replace(typeof(IContentNegotiator), CreateDummyContentNegotiator());

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;
                    HttpRequestMessage ignore = result.Request;

                    using (HttpRequestMessage otherRequest = CreateRequest())
                    {
                        controller.Request = otherRequest;

                        // Act
                        HttpRequestMessage request = result.Request;

                        // Assert
                        Assert.Same(expectedRequest, request);
                    }
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                IEnumerable<MediaTypeFormatter> ignore = result.Formatters;

                using (HttpConfiguration lateConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenConfigurationIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();
            HttpControllerContext context = new HttpControllerContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.ControllerContext = context;
                controller.Request = request;

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "HttpControllerContext.Configuration must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenServiceIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), null))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "The provided configuration does not have an instance of the " +
                    "'System.Net.Http.Formatting.IContentNegotiator' service registered.");
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                Assert.Null(controller.Request);

                CreatedAtRouteNegotiatedContentResult<object> result = CreateProductUnderTest(routeName, routeValues,
                    content, controller);

                // Act & Assert
                InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                    { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
            }
        }

        [Fact]
        public void ApiControllerCreatedAtRoute_WithStringAndDictionary_CreatesCorrectResult()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            object expectedContent = CreateContent();
            ApiController controller = CreateController();

            // Act
            CreatedAtRouteNegotiatedContentResult<object> result = controller.CreatedAtRoute(expectedRouteName,
                expectedRouteValues, expectedContent);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedRouteName, result.RouteName);
            Assert.Same(expectedRouteValues, result.RouteValues);
            Assert.Same(expectedContent, result.Content);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerCreatedAtRoute_WithStringAndObject_CreatesCorrectResult()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            object routeValues = new { id = 1 };
            object expectedContent = CreateContent();
            ApiController controller = CreateController();

            // Act
            CreatedAtRouteNegotiatedContentResult<object> result = controller.CreatedAtRoute(expectedRouteName,
                routeValues, expectedContent);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedRouteName, result.RouteName);
            Assert.IsType<HttpRouteValueDictionary>(result.RouteValues);
            Assert.True(result.RouteValues.ContainsKey("id"));
            Assert.Equal(1, result.RouteValues["id"]);
            Assert.Same(expectedContent, result.Content);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static HttpConfiguration CreateConfiguration(MediaTypeFormatter formatter,
            IContentNegotiator contentNegotiator)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Formatters.Clear();
            configuration.Formatters.Add(formatter);
            configuration.Services.Replace(typeof(IContentNegotiator), contentNegotiator);
            return configuration;
        }

        private static object CreateContent()
        {
            return new object();
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static IContentNegotiator CreateDummyContentNegotiator()
        {
            return new Mock<IContentNegotiator>(MockBehavior.Strict).Object;
        }

        private static UrlHelper CreateDummyUrlFactory()
        {
            return new Mock<UrlHelper>(MockBehavior.Strict).Object;
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubMediaTypeFormatter();
        }

        private static IEnumerable<MediaTypeFormatter> CreateFormatters()
        {
            return new MediaTypeFormatter[0];
        }

        private static Uri CreateLocation()
        {
            return new Uri("aa://b");
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static CreatedAtRouteNegotiatedContentResult<object> CreateProductUnderTest(string routeName,
            IDictionary<string, object> routeValues, object content, UrlHelper urlFactory,
            IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
        {
            return new CreatedAtRouteNegotiatedContentResult<object>(routeName, routeValues, content, urlFactory,
                contentNegotiator, request, formatters);
        }

        private static CreatedAtRouteNegotiatedContentResult<object> CreateProductUnderTest(string routeName,
            IDictionary<string, object> routeValues, object content, ApiController controller)
        {
            return new CreatedAtRouteNegotiatedContentResult<object>(routeName, routeValues, content, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static string CreateRouteName()
        {
            return "IgnoreRouteName";
        }

        private static IDictionary<string, object> CreateRouteValues()
        {
            return new Dictionary<string, object>();
        }

        private class StubMediaTypeFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/CreatedNegotiatedContentResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class CreatedNegotiatedContentResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenLocationIsNull()
        {
            // Arrange
            Uri location = null;
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(location, content, contentNegotiator, request, formatters);
                }, "location");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenContentNegotiatorIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(location, content, contentNegotiator, request, formatters);
                }, "contentNegotiator");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();
            HttpRequestMessage request = null;
            IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(location, content, contentNegotiator, request, formatters);
            }, "request");
        }

        [Fact]
        public void Constructor_Throws_WhenFormattersIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(location, content, contentNegotiator, request, formatters);
                }, "formatters");
            }
        }

        [Fact]
        public void Location_Returns_InstanceProvided()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(expectedLocation, content,
                    contentNegotiator, request, formatters);

                // Act
                Uri location = result.Location;

                // Assert
                Assert.Same(expectedLocation, location);
            }
        }

        [Fact]
        public void Content_Returns_InstanceProvided()
        {
            // Arrange
            Uri location = CreateLocation();
            object expectedContent = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, expectedContent,
                    contentNegotiator, request, formatters);

                // Act
                object content = result.Content;

                // Assert
                Assert.Same(expectedContent, content);
            }
        }

        [Fact]
        public void ContentNegotiator_Returns_InstanceProvided()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content,
                    expectedContentNegotiator, request, formatters);

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content,
                    contentNegotiator, expectedRequest, formatters);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Formatters_Returns_InstanceProvided()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content,
                    contentNegotiator, request, expectedFormatters);

                // Act
                IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                // Assert
                Assert.Same(expectedFormatters, formatters);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationSucceeds()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(expectedLocation, expectedContent, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Created, response.StatusCode);
                    Assert.Same(expectedLocation, response.Headers.Location);
                    HttpContent content = response.Content;
                    ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                    Assert.Same(expectedContent, typedContent.Value);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationFails()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ContentNegotiationResult negotiationResult = null;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(location, content, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
                    Assert.Null(response.Headers.Location);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(location, content, controller);
            }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse_WhenContentNegotationSucceeds()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();
            object expectedContent = CreateContent();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedInputFormatter = CreateFormatter();
            MediaTypeFormatter expectedOutputFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedOutputFormatter,
                expectedMediaType);

            Expression<Func<IEnumerable<MediaTypeFormatter>, bool>> formattersMatch = (f) =>
                f != null && f.AsArray().Length == 1 && f.AsArray()[0] == expectedInputFormatter;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, It.Is(formattersMatch))).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                using (HttpConfiguration configuration = CreateConfiguration(expectedInputFormatter,
                    contentNegotiator))
                {
                    controller.Configuration = configuration;
                    controller.Request = expectedRequest;

                    IHttpActionResult result = CreateProductUnderTest(expectedLocation, expectedContent, controller);

                    // Act
                    Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                    // Assert
                    Assert.NotNull(task);

                    using (HttpResponseMessage response = await task)
                    {
                        Assert.NotNull(response);
                        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
                        Assert.Same(expectedLocation, response.Headers.Location);
                        HttpContent content = response.Content;
                        ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                        Assert.Same(expectedContent, typedContent.Value);
                        Assert.Same(expectedOutputFormatter, typedContent.Formatter);
                        Assert.NotNull(typedContent.Headers);
                        Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content,
                        controller);

                    IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
                    configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.Same(expectedContentNegotiator, contentNegotiator);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = CreateController();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                MediaTypeFormatter expectedFormatter = CreateFormatter();

                using (HttpConfiguration lateConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), expectedContentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                IContentNegotiator ignore = result.ContentNegotiator;

                configuration.Services.Replace(typeof(IContentNegotiator), CreateDummyContentNegotiator());

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;
                    HttpRequestMessage ignore = result.Request;

                    using (HttpRequestMessage otherRequest = CreateRequest())
                    {
                        controller.Request = otherRequest;

                        // Act
                        HttpRequestMessage request = result.Request;

                        // Assert
                        Assert.Same(expectedRequest, request);
                    }
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                IEnumerable<MediaTypeFormatter> ignore = result.Formatters;

                using (HttpConfiguration lateConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenConfigurationIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = CreateController();
            HttpControllerContext context = new HttpControllerContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.ControllerContext = context;

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "HttpControllerContext.Configuration must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenServiceIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), null))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;

                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "The provided configuration does not have an instance of the " +
                    "'System.Net.Http.Formatting.IContentNegotiator' service registered.");
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            object content = CreateContent();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                CreatedNegotiatedContentResult<object> result = CreateProductUnderTest(location, content, controller);

                // Act & Assert
                InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                    { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
            }
        }

        [Fact]
        public void ApiControllerCreated_WithUriAndContent_CreatesCorrectResult()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();
            object expectedContent = CreateContent();
            ApiController controller = CreateController();

            // Act
            CreatedNegotiatedContentResult<object> result = controller.Created(expectedLocation, expectedContent);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedLocation, result.Location);
            Assert.Same(expectedContent, result.Content);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerCreated_WithStringAndContent_Throws_WhenLocationIsNull()
        {
            // Arrange
            string location = null;
            object content = CreateContent();
            ApiController controller = CreateController();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { controller.Created(location, content); }, "location");
        }

        [Theory]
        [InlineData("/example/yes")] // Absolute path
        [InlineData("relative/relative")] // Relative path
        [InlineData("http://example.com")] // Absolute URL with host
        public void ApiControllerCreated_WithStringAndContent_CreatesCorrectResult(string location)
        {
            // Arrange
            object expectedContent = CreateContent();
            ApiController controller = CreateController();

            // Act
            CreatedNegotiatedContentResult<object> result = controller.Created(location, expectedContent);

            // Assert
            Assert.NotNull(result);
            Assert.Same(location, result.Location.OriginalString);
            Assert.Same(expectedContent, result.Content);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static HttpConfiguration CreateConfiguration(MediaTypeFormatter formatter,
            IContentNegotiator contentNegotiator)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Formatters.Clear();
            configuration.Formatters.Add(formatter);
            configuration.Services.Replace(typeof(IContentNegotiator), contentNegotiator);
            return configuration;
        }

        private static object CreateContent()
        {
            return new object();
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static IContentNegotiator CreateDummyContentNegotiator()
        {
            return new Mock<IContentNegotiator>(MockBehavior.Strict).Object;
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubMediaTypeFormatter();
        }

        private static IEnumerable<MediaTypeFormatter> CreateFormatters()
        {
            return new MediaTypeFormatter[0];
        }

        private static Uri CreateLocation()
        {
            return new Uri("aa://b");
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static CreatedNegotiatedContentResult<object> CreateProductUnderTest(Uri location, object content,
            IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
        {
            return new CreatedNegotiatedContentResult<object>(location, content, contentNegotiator, request,
                formatters);
        }

        private static CreatedNegotiatedContentResult<object> CreateProductUnderTest(Uri location, object content,
            ApiController controller)
        {
            return new CreatedNegotiatedContentResult<object>(location, content, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class StubMediaTypeFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/ExceptionResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class ExceptionResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenExceptionIsNull()
        {
            // Arrange
            Exception exception = null;
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator, request, formatters);
                }, "exception");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenContentNegotiatorIsNull()
        {
            // Arrange
            Exception exception = CreateException();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator, request, formatters);
                }, "contentNegotiator");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            Exception exception = CreateException();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();
            HttpRequestMessage request = null;
            IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator, request, formatters);
            }, "request");
        }

        [Fact]
        public void Constructor_Throws_WhenFormattersIsNull()
        {
            // Arrange
            Exception exception = CreateException();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator, request, formatters);
                }, "formatters");
            }
        }

        [Fact]
        public void Exception_ReturnsInstanceProvided()
        {
            // Arrange
            Exception expectedException = CreateException();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                ExceptionResult result = CreateProductUnderTest(expectedException, includeErrorDetail,
                    contentNegotiator, request, formatters);

                // Act
                Exception exception = result.Exception;

                // Assert
                Assert.Same(expectedException, exception);
            }
        }

        [Fact]
        public void IncludeErrorDetail_ReturnsValueProvided()
        {
            // Arrange
            Exception exception = CreateException();
            bool expectedIncludeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                ExceptionResult result = CreateProductUnderTest(exception, expectedIncludeErrorDetail,
                    contentNegotiator, request, formatters);

                // Act
                bool includeErrorDetail = result.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Fact]
        public void ContentNegotiator_ReturnsInstanceProvided()
        {
            // Arrange
            Exception exception = CreateException();
            bool includeErrorDetail = true;
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                ExceptionResult result = CreateProductUnderTest(exception, includeErrorDetail,
                    expectedContentNegotiator, request, formatters);

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ReturnsInstanceProvided()
        {
            // Arrange
            Exception exception = CreateException();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                ExceptionResult result = CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator,
                    expectedRequest, formatters);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Formatters_ReturnsInstanceProvided()
        {
            // Arrange
            Exception exception = CreateException();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                ExceptionResult result = CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator,
                    request, expectedFormatters);

                // Act
                IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                // Assert
                Assert.Same(expectedFormatters, formatters);
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationSucceedsAndIncludeErrorDetailIsTrue()
        {
            // Arrange
            Exception expectedException = CreateExceptionWithStackTrace();
            bool includeErrorDetail = true;
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(expectedException, includeErrorDetail,
                    contentNegotiator, expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                    HttpError error = (HttpError)typedContent.Value;
                    Assert.NotNull(error);
                    Assert.Equal(expectedException.Message, error.ExceptionMessage);
                    Assert.Equal(expectedException.GetType().FullName, error.ExceptionType);
                    Assert.Equal(expectedException.StackTrace, error.StackTrace);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationSucceedsAndIncludeErrorDetailIsFalse()
        {
            // Arrange
            Exception exception = CreateExceptionWithStackTrace();
            bool includeErrorDetail = false;
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                    HttpError error = (HttpError)typedContent.Value;
                    Assert.NotNull(error);
                    Assert.Null(error.ExceptionMessage);
                    Assert.Null(error.ExceptionType);
                    Assert.Null(error.StackTrace);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationFails()
        {
            // Arrange
            Exception exception = CreateException();
            bool includeErrorDetail = true;
            ContentNegotiationResult negotiationResult = null;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(ModelStateDictionary), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(exception, includeErrorDetail, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(exception, controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse_WhenContentNegotationSucceeds()
        {
            // Arrange
            Exception expectedException = CreateExceptionWithStackTrace();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedInputFormatter = CreateFormatter();
            MediaTypeFormatter expectedOutputFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedOutputFormatter,
                expectedMediaType);

            Expression<Func<IEnumerable<MediaTypeFormatter>, bool>> formattersMatch = (f) =>
                f != null && f.AsArray().Length == 1 && f.AsArray()[0] == expectedInputFormatter;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, It.Is(formattersMatch))).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                using (HttpConfiguration configuration = CreateConfiguration(expectedInputFormatter,
                    contentNegotiator))
                {
                    controller.RequestContext = new HttpRequestContext
                    {
                        Configuration = configuration,
                        IncludeErrorDetail = true
                    };
                    controller.Request = expectedRequest;

                    IHttpActionResult result = CreateProductUnderTest(expectedException, controller);

                    // Act
                    Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                    // Assert
                    Assert.NotNull(task);

                    using (HttpResponseMessage response = await task)
                    {
                        Assert.NotNull(response);
                        Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                        HttpContent content = response.Content;
                        ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                        HttpError error = (HttpError)typedContent.Value;
                        Assert.NotNull(error);
                        Assert.Equal(expectedException.Message, error.ExceptionMessage);
                        Assert.Equal(expectedException.GetType().FullName, error.ExceptionType);
                        Assert.Equal(expectedException.StackTrace, error.StackTrace);
                        Assert.Same(expectedOutputFormatter, typedContent.Formatter);
                        Assert.NotNull(typedContent.Headers);
                        Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public void IncludeErrorDetail_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    ExceptionResult result = CreateProductUnderTest(exception, controller);

                    configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Never;

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.False(result.IncludeErrorDetail);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    ExceptionResult result = CreateProductUnderTest(exception, controller);

                    IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
                    configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.Same(expectedContentNegotiator, contentNegotiator);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Exception exception = CreateException();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                ExceptionResult result = CreateProductUnderTest(exception, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                ExceptionResult result = CreateProductUnderTest(exception, controller);

                MediaTypeFormatter expectedFormatter = CreateFormatter();

                using (HttpConfiguration lateConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void IncludeErrorDetail_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext requestContext = new HttpRequestContext
                {
                    Configuration = configuration,
                    IncludeErrorDetail = true
                };
                controller.RequestContext = requestContext;
                controller.Request = request;

                ExceptionResult result = CreateProductUnderTest(exception, controller);

                bool ignore = result.IncludeErrorDetail;

                requestContext.IncludeErrorDetail = false;

                // Act
                bool includeErrorDetail = result.IncludeErrorDetail;

                // Assert
                Assert.True(includeErrorDetail);
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Exception exception = CreateException();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), expectedContentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                ExceptionResult result = CreateProductUnderTest(exception, controller);

                IContentNegotiator ignore = result.ContentNegotiator;

                configuration.Services.Replace(typeof(IContentNegotiator), CreateDummyContentNegotiator());

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                ExceptionResult result = CreateProductUnderTest(exception, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;
                    HttpRequestMessage ignore = result.Request;

                    using (HttpRequestMessage otherRequest = CreateRequest())
                    {
                        controller.Request = otherRequest;

                        // Act
                        HttpRequestMessage request = result.Request;

                        // Assert
                        Assert.Same(expectedRequest, request);
                    }
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                ExceptionResult result = CreateProductUnderTest(exception, controller);

                IEnumerable<MediaTypeFormatter> ignore = result.Formatters;

                using (HttpConfiguration lateConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void IncludeErrorDetail_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                ExceptionResult result = CreateProductUnderTest(exception, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(() => { bool ignore = result.IncludeErrorDetail; },
                    "ApiController.Request must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenConfigurationIsNull()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();
            HttpControllerContext context = new HttpControllerContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.ControllerContext = context;

                ExceptionResult result = CreateProductUnderTest(exception, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "HttpControllerContext.Configuration must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenServiceIsNull()
        {
            // Arrange
            Exception exception = CreateException();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), null))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Request = request;
                controller.Configuration = configuration;

                ExceptionResult result = CreateProductUnderTest(exception, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "The provided configuration does not have an instance of the " +
                    "'System.Net.Http.Formatting.IContentNegotiator' service registered.");
            }
        }

        [Fact]
        public void ApiControllerInternalServerError_WithException_CreatesCorrectResult()
        {
            // Arrange
            Exception expectedException = CreateException();
            ApiController controller = CreateController();

            // Act
            ExceptionResult result = controller.InternalServerError(expectedException);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedException, result.Exception);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static HttpConfiguration CreateConfiguration(MediaTypeFormatter formatter,
            IContentNegotiator contentNegotiator)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Formatters.Clear();
            configuration.Formatters.Add(formatter);
            configuration.Services.Replace(typeof(IContentNegotiator), contentNegotiator);
            return configuration;
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static IContentNegotiator CreateDummyContentNegotiator()
        {
            return new Mock<IContentNegotiator>(MockBehavior.Strict).Object;
        }

        private static Exception CreateException()
        {
            return new Exception();
        }

        private static Exception CreateExceptionWithStackTrace()
        {
            try
            {
                throw CreateException();
            }
            catch (Exception ex)
            {
                return ex;
            }
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubMediaTypeFormatter();
        }

        private static IEnumerable<MediaTypeFormatter> CreateFormatters()
        {
            return new MediaTypeFormatter[0];
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static ExceptionResult CreateProductUnderTest(Exception exception, bool includeErrorDetail,
            IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
        {
            return new ExceptionResult(exception, includeErrorDetail, contentNegotiator, request, formatters);
        }

        private static ExceptionResult CreateProductUnderTest(Exception exception, ApiController controller)
        {
            return new ExceptionResult(exception, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class StubMediaTypeFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/FormattedContentResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class FormattedContentResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenFormatterIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = null;
            MediaTypeHeaderValue mediaType = CreateMediaType();

            using (HttpRequestMessage request = CreateRequest())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    new FormattedContentResult<object>(statusCode, content, formatter, mediaType, request);
                }, "formatter");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                new FormattedContentResult<object>(statusCode, content, formatter, mediaType, request);
            }, "request");
        }

        [Fact]
        public void StatusCode_Returns_ValueProvided()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();

            using (HttpRequestMessage request = CreateRequest())
            {
                FormattedContentResult<object> result = new FormattedContentResult<object>(expectedStatusCode, content,
                    formatter, mediaType, request);

                // Act
                HttpStatusCode statusCode = result.StatusCode;

                // Assert
                Assert.Equal(expectedStatusCode, statusCode);
            }
        }

        [Fact]
        public void Content_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();

            using (HttpRequestMessage request = CreateRequest())
            {
                FormattedContentResult<object> result = new FormattedContentResult<object>(statusCode, expectedContent,
                    formatter, mediaType, request);

                // Act
                object content = result.Content;

                // Assert
                Assert.Same(expectedContent, content);
            }
        }

        [Fact]
        public void Formatter_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();

            using (HttpRequestMessage request = CreateRequest())
            {
                FormattedContentResult<object> result = new FormattedContentResult<object>(statusCode, content,
                    expectedFormatter, mediaType, request);

                // Act
                MediaTypeFormatter formatter = result.Formatter;

                // Assert
                Assert.Same(expectedFormatter, formatter);
            }
        }

        [Fact]
        public void MediaType_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();

            using (HttpRequestMessage request = CreateRequest())
            {
                FormattedContentResult<object> result = new FormattedContentResult<object>(statusCode, content,
                    formatter, expectedMediaType, request);

                // Act
                MediaTypeHeaderValue mediaType = result.MediaType;

                // Assert
                Assert.Same(expectedMediaType, mediaType);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                FormattedContentResult<object> result = new FormattedContentResult<object>(statusCode, content,
                    formatter, mediaType, expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = new FormattedContentResult<object>(expectedStatusCode, expectedContent,
                    expectedFormatter, expectedMediaType, expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(expectedStatusCode, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                    Assert.Same(expectedContent, typedContent.Value);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                new FormattedContentResult<object>(statusCode, content, formatter, mediaType, controller);
            }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = new FormattedContentResult<object>(expectedStatusCode, expectedContent,
                    expectedFormatter, expectedMediaType, controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(expectedStatusCode, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                    Assert.Same(expectedContent, typedContent.Value);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Equal(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();
            FormattedContentResult<object> result = new FormattedContentResult<object>(statusCode, content, formatter,
                mediaType, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();
            FormattedContentResult<object> result = new FormattedContentResult<object>(statusCode, content, formatter,
                mediaType, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            FormattedContentResult<object> result = new FormattedContentResult<object>(statusCode, content, formatter,
                mediaType, controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerContent_WithFormatter_CreatesCorrectFormattedContentResult()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ApiController controller = CreateController();

            // Act
            FormattedContentResult<object> result = controller.Content(expectedStatusCode, expectedContent,
                expectedFormatter, expectedMediaType);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(expectedStatusCode, result.StatusCode);
            Assert.Same(expectedContent, result.Content);
            Assert.Same(expectedFormatter, result.Formatter);
            Assert.Same(expectedMediaType, result.MediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerContent_WithFormatterAndStringMediaType_CreatesCorrectFormattedContentResult()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            string expectedMediaType = CreateMediaType().MediaType;
            ApiController controller = CreateController();

            // Act
            FormattedContentResult<object> result = controller.Content(expectedStatusCode, expectedContent,
                expectedFormatter, expectedMediaType);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(expectedStatusCode, result.StatusCode);
            Assert.Same(expectedContent, result.Content);
            Assert.Same(expectedFormatter, result.Formatter);
            MediaTypeHeaderValue mediaType = result.MediaType;
            Assert.NotNull(mediaType);
            Assert.Equal(expectedMediaType, mediaType.MediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerContent_WithFormatterButNotMediaType_CreatesCorrectFormattedContentResult()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            ApiController controller = CreateController();

            // Act
            FormattedContentResult<object> result = controller.Content(expectedStatusCode, expectedContent,
                expectedFormatter);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(expectedStatusCode, result.StatusCode);
            Assert.Same(expectedContent, result.Content);
            Assert.Same(expectedFormatter, result.Formatter);
            Assert.Null(result.MediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static object CreateContent()
        {
            return new object();
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubFormatter();
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpStatusCode CreateStatusCode()
        {
            return HttpStatusCode.Continue;
        }

        private class StubFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/InternalServerErrorResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class InternalServerErrorResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(request); }, "request");
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                InternalServerErrorResult result = CreateProductUnderTest(expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = CreateProductUnderTest(controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ApiController controller = CreateController();
            InternalServerErrorResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ApiController controller = CreateController();
            InternalServerErrorResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            InternalServerErrorResult result = CreateProductUnderTest(controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerInternalServerError_CreatesCorrectResult()
        {
            // Arrange
            ApiController controller = CreateController();

            // Act
            InternalServerErrorResult result = controller.InternalServerError();

            // Assert
            Assert.NotNull(result);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static InternalServerErrorResult CreateProductUnderTest(HttpRequestMessage request)
        {
            return new InternalServerErrorResult(request);
        }

        private static InternalServerErrorResult CreateProductUnderTest(ApiController controller)
        {
            return new InternalServerErrorResult(controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/InvalidModelStateResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class InvalidModelStateResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenModelStateIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = null;
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator, request, formatters);
                }, "modelState");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenContentNegotiatorIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator, request, formatters);
                }, "contentNegotiator");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();
            HttpRequestMessage request = null;
            IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator, request, formatters);
            }, "request");
        }

        [Fact]
        public void Constructor_Throws_WhenFormattersIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator, request, formatters);
                }, "formatters");
            }
        }

        [Fact]
        public void ModelState_ReturnsInstanceProvided()
        {
            // Arrange
            ModelStateDictionary expectedModelState = CreateModelState();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                InvalidModelStateResult result = CreateProductUnderTest(expectedModelState, includeErrorDetail,
                    contentNegotiator, request, formatters);

                // Act
                ModelStateDictionary modelState = result.ModelState;

                // Assert
                Assert.Same(expectedModelState, modelState);
            }
        }

        [Fact]
        public void IncludeErrorDetail_ReturnsValueProvided()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            bool expectedIncludeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                InvalidModelStateResult result = CreateProductUnderTest(modelState, expectedIncludeErrorDetail,
                    contentNegotiator, request, formatters);

                // Act
                bool includeErrorDetail = result.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Fact]
        public void ContentNegotiator_ReturnsInstanceProvided()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            bool includeErrorDetail = true;
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                InvalidModelStateResult result = CreateProductUnderTest(modelState, includeErrorDetail,
                    expectedContentNegotiator, request, formatters);

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ReturnsInstanceProvided()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                InvalidModelStateResult result = CreateProductUnderTest(modelState, includeErrorDetail,
                    contentNegotiator, expectedRequest, formatters);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Formatters_ReturnsInstanceProvided()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            bool includeErrorDetail = true;
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                InvalidModelStateResult result = CreateProductUnderTest(modelState, includeErrorDetail,
                    contentNegotiator, request, expectedFormatters);

                // Act
                IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                // Assert
                Assert.Same(expectedFormatters, formatters);
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationSucceedsAndIncludeErrorDetailIsTrue()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            string expectedModelStateKey = "ModelStateKey";
            string expectedModelStateExceptionMessage = "ModelStateExceptionMessage";
            modelState.AddModelError(expectedModelStateKey, new InvalidOperationException(
                expectedModelStateExceptionMessage));
            bool includeErrorDetail = true;
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                    HttpError error = (HttpError)typedContent.Value;
                    Assert.NotNull(error);
                    HttpError modelStateError = error.ModelState;
                    Assert.NotNull(modelStateError);
                    Assert.True(modelState.ContainsKey(expectedModelStateKey));
                    object modelStateValue = modelStateError[expectedModelStateKey];
                    string[] typedModelStateValues = Assert.IsType<string[]>(modelStateValue);
                    string typedModelStateValue = Assert.Single(typedModelStateValues);
                    Assert.Same(expectedModelStateExceptionMessage, typedModelStateValue);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationSucceedsAndIncludeErrorDetailIsFalse()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            string expectedModelStateKey = "ModelStateKey";
            string expectedModelStateErrorMessage = "ModelStateErrorMessage";
            ModelState originalModelStateItem = new ModelState();
            originalModelStateItem.Errors.Add(new ModelError(new InvalidOperationException(),
                expectedModelStateErrorMessage));
            modelState.Add(expectedModelStateKey, originalModelStateItem);
            bool includeErrorDetail = false;
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter,
                expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                    HttpError error = (HttpError)typedContent.Value;
                    Assert.NotNull(error);
                    HttpError modelStateError = error.ModelState;
                    Assert.NotNull(modelStateError);
                    Assert.True(modelState.ContainsKey(expectedModelStateKey));
                    object modelStateValue = modelStateError[expectedModelStateKey];
                    string[] typedModelStateValues = Assert.IsType<string[]>(modelStateValue);
                    string typedModelStateValue = Assert.Single(typedModelStateValues);
                    Assert.Same(expectedModelStateErrorMessage, typedModelStateValue);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_ReturnsCorrectResponse_WhenContentNegotiationFails()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelStateWithError();
            bool includeErrorDetail = true;
            ContentNegotiationResult negotiationResult = null;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(ModelStateDictionary), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(modelState, includeErrorDetail, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(modelState, controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse_WhenContentNegotationSucceeds()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            string expectedModelStateKey = "ModelStateKey";
            string expectedModelStateExceptionMessage = "ModelStateExceptionMessage";
            modelState.AddModelError(expectedModelStateKey, new InvalidOperationException(
                expectedModelStateExceptionMessage));
            ApiController controller = CreateController();
            MediaTypeFormatter expectedInputFormatter = CreateFormatter();
            MediaTypeFormatter expectedOutputFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedOutputFormatter,
                expectedMediaType);

            Expression<Func<IEnumerable<MediaTypeFormatter>, bool>> formattersMatch = (f) =>
                f != null && f.AsArray().Length == 1 && f.AsArray()[0] == expectedInputFormatter;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(HttpError), expectedRequest, It.Is(formattersMatch))).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                using (HttpConfiguration configuration = CreateConfiguration(expectedInputFormatter,
                    contentNegotiator))
                {
                    controller.RequestContext = new HttpRequestContext
                    {
                        Configuration = configuration,
                        IncludeErrorDetail = true
                    };
                    controller.Request = expectedRequest;

                    IHttpActionResult result = CreateProductUnderTest(modelState, controller);

                    // Act
                    Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                    // Assert
                    Assert.NotNull(task);

                    using (HttpResponseMessage response = await task)
                    {
                        Assert.NotNull(response);
                        Assert.Equal(HttpStatusCode.BadRequest, response.StatusCode);
                        HttpContent content = response.Content;
                        ObjectContent<HttpError> typedContent = Assert.IsType<ObjectContent<HttpError>>(content);
                        HttpError error = (HttpError)typedContent.Value;
                        Assert.NotNull(error);
                        HttpError modelStateError = error.ModelState;
                        Assert.NotNull(modelStateError);
                        Assert.True(modelState.ContainsKey(expectedModelStateKey));
                        object modelStateValue = modelStateError[expectedModelStateKey];
                        string[] typedModelStateValues = Assert.IsType<string[]>(modelStateValue);
                        string typedModelStateValue = Assert.Single(typedModelStateValues);
                        Assert.Same(expectedModelStateExceptionMessage, typedModelStateValue);
                        Assert.Same(expectedOutputFormatter, typedContent.Formatter);
                        Assert.NotNull(typedContent.Headers);
                        Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public void IncludeErrorDetail_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                    configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Never;

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.False(result.IncludeErrorDetail);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                    IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
                    configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.Same(expectedContentNegotiator, contentNegotiator);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                MediaTypeFormatter expectedFormatter = CreateFormatter();

                using (HttpConfiguration lateConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void IncludeErrorDetail_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext requestContext = new HttpRequestContext
                {
                    Configuration = configuration,
                    IncludeErrorDetail = true
                };
                controller.RequestContext = requestContext;
                controller.Request = request;

                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                bool ignore = result.IncludeErrorDetail;

                requestContext.IncludeErrorDetail = false;

                // Act
                bool includeErrorDetail = result.IncludeErrorDetail;

                // Assert
                Assert.True(includeErrorDetail);
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            IContentNegotiator expectedContentNegotiator = CreateDummyContentNegotiator();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), expectedContentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                IContentNegotiator ignore = result.ContentNegotiator;

                configuration.Services.Replace(typeof(IContentNegotiator), CreateDummyContentNegotiator());

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;

                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;
                    HttpRequestMessage ignore = result.Request;

                    using (HttpRequestMessage otherRequest = CreateRequest())
                    {
                        controller.Request = otherRequest;

                        // Act
                        HttpRequestMessage request = result.Request;

                        // Assert
                        Assert.Same(expectedRequest, request);
                    }
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            IContentNegotiator contentNegotiator = CreateDummyContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                IEnumerable<MediaTypeFormatter> ignore = result.Formatters;

                using (HttpConfiguration lateConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void IncludeErrorDetail_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            {
                controller.Configuration = configuration;
                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                // Act & Assert
                InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                    { bool ignore = result.IncludeErrorDetail; }, "ApiController.Request must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenConfigurationIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();
            HttpControllerContext context = new HttpControllerContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.ControllerContext = context;

                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "HttpControllerContext.Configuration must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenServiceIsNull()
        {
            // Arrange
            ModelStateDictionary modelState = CreateModelState();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), null))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Request = request;
                controller.Configuration = configuration;

                InvalidModelStateResult result = CreateProductUnderTest(modelState, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "The provided configuration does not have an instance of the " +
                    "'System.Net.Http.Formatting.IContentNegotiator' service registered.");
            }
        }

        [Fact]
        public void ApiControllerBadRequest_WithModelStateDictionary_CreatesCorrectResult()
        {
            // Arrange
            ModelStateDictionary expectedModelState = CreateModelState();
            ApiController controller = CreateController();

            // Act
            InvalidModelStateResult result = controller.BadRequest(expectedModelState);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedModelState, result.ModelState);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(),
                CreateDummyContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static HttpConfiguration CreateConfiguration(MediaTypeFormatter formatter,
            IContentNegotiator contentNegotiator)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Formatters.Clear();
            configuration.Formatters.Add(formatter);
            configuration.Services.Replace(typeof(IContentNegotiator), contentNegotiator);
            return configuration;
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static IContentNegotiator CreateDummyContentNegotiator()
        {
            return new Mock<IContentNegotiator>(MockBehavior.Strict).Object;
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubMediaTypeFormatter();
        }

        private static IEnumerable<MediaTypeFormatter> CreateFormatters()
        {
            return new MediaTypeFormatter[0];
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static ModelStateDictionary CreateModelState()
        {
            return new ModelStateDictionary();
        }

        private static ModelStateDictionary CreateModelStateWithError()
        {
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddModelError(String.Empty, String.Empty);
            return modelState;
        }

        private static InvalidModelStateResult CreateProductUnderTest(ModelStateDictionary modelState,
            bool includeErrorDetail, IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
        {
            return new InvalidModelStateResult(modelState, includeErrorDetail, contentNegotiator,
                request, formatters);
        }

        private static InvalidModelStateResult CreateProductUnderTest(ModelStateDictionary modelState,
            ApiController controller)
        {
            return new InvalidModelStateResult(modelState, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class StubMediaTypeFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/JsonResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;
using Newtonsoft.Json;

namespace System.Web.Http.Results
{
    public class JsonResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenSerializerSettingsIsNull()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = null;
            Encoding encoding = CreateDummyEncoding();

            using (HttpRequestMessage request = CreateRequest())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(content, serializerSettings, encoding, request);
                }, "serializerSettings");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenEncodingIsNull()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(content, serializerSettings, encoding, request);
                }, "encoding");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(content, serializerSettings, encoding, request);
            }, "request");
        }

        [Fact]
        public void Content_Returns_InstanceProvided()
        {
            // Arrange
            object expectedContent = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();

            using (HttpRequestMessage request = CreateRequest())
            {
                JsonResult<object> result = CreateProductUnderTest(expectedContent, serializerSettings, encoding,
                    request);

                // Act
                object content = result.Content;

                // Assert
                Assert.Same(expectedContent, content);
            }
        }

        [Fact]
        public void SerializerSettings_Returns_InstanceProvided()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings expectedSerializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();

            using (HttpRequestMessage request = CreateRequest())
            {
                JsonResult<object> result = CreateProductUnderTest(content, expectedSerializerSettings, encoding,
                    request);

                // Act
                JsonSerializerSettings serializerSettings = result.SerializerSettings;

                // Assert
                Assert.Same(expectedSerializerSettings, serializerSettings);
            }
        }

        [Fact]
        public void Encoding_Returns_InstanceProvided()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding expectedEncoding = CreateDummyEncoding();

            using (HttpRequestMessage request = CreateRequest())
            {
                JsonResult<object> result = CreateProductUnderTest(content, serializerSettings, expectedEncoding,
                    request);

                // Act
                Encoding encoding = result.Encoding;

                // Assert
                Assert.Same(expectedEncoding, encoding);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                JsonResult<object> result = CreateProductUnderTest(content, serializerSettings, encoding,
                    expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            string[] content = new string[] { "Content" };
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateEncoding();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(content, serializerSettings, encoding,
                    expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    Assert.NotNull(response.Content);
                    Assert.NotNull(response.Content.Headers.ContentType);
                    Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
                    Assert.Equal(encoding.WebName, response.Content.Headers.ContentType.CharSet);
                    Assert.IsType<ByteArrayContent>(response.Content);
                    StringBuilder expectedBuilder = new StringBuilder();
                    using (TextWriter textWriter = new StringWriter(expectedBuilder, CultureInfo.InvariantCulture))
                    {
                        JsonSerializer serializer = JsonSerializer.Create(serializerSettings);

                        using (JsonWriter jsonWriter = new JsonTextWriter(textWriter))
                        {
                            serializer.Serialize(jsonWriter, content);
                            jsonWriter.Flush();
                        }
                    }
                    byte[] expectedContents = encoding.GetBytes(expectedBuilder.ToString());
                    byte[] contents = await response.Content.ReadAsByteArrayAsync();
                    Assert.Equal(expectedContents, contents);
                    Assert.True(response.Content.Headers.ContentLength.HasValue);
                    Assert.Equal((long)expectedContents.Length, response.Content.Headers.ContentLength.Value);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(content, serializerSettings, encoding, controller);
            }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            string[] content = new string[] { "Content" };
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateEncoding();
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = CreateProductUnderTest(content, serializerSettings, encoding, controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    Assert.NotNull(response.Content);
                    Assert.NotNull(response.Content.Headers.ContentType);
                    Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
                    Assert.Equal(encoding.WebName, response.Content.Headers.ContentType.CharSet);
                    Assert.IsType<ByteArrayContent>(response.Content);
                    StringBuilder expectedBuilder = new StringBuilder();
                    using (TextWriter textWriter = new StringWriter(expectedBuilder, CultureInfo.InvariantCulture))
                    {
                        JsonSerializer serializer = JsonSerializer.Create(serializerSettings);

                        using (JsonWriter jsonWriter = new JsonTextWriter(textWriter))
                        {
                            serializer.Serialize(jsonWriter, content);
                            jsonWriter.Flush();
                        }
                    }
                    byte[] expectedContents = encoding.GetBytes(expectedBuilder.ToString());
                    byte[] contents = await response.Content.ReadAsByteArrayAsync();
                    Assert.Equal(expectedContents, contents);
                    Assert.True(response.Content.Headers.ContentLength.HasValue);
                    Assert.Equal((long)expectedContents.Length, response.Content.Headers.ContentLength.Value);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();
            ApiController controller = CreateController();
            JsonResult<object> result = CreateProductUnderTest(content, serializerSettings, encoding, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();
            ApiController controller = CreateController();
            JsonResult<object> result = CreateProductUnderTest(content, serializerSettings, encoding, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            object content = CreateContent();
            JsonSerializerSettings serializerSettings = CreateSerializerSettings();
            Encoding encoding = CreateDummyEncoding();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            JsonResult<object> result = CreateProductUnderTest(content, serializerSettings, encoding, controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerJson_WithObjectJsonSerializerSettingsAndEncoding_CreatesCorrectResult()
        {
            // Arrange
            object expectedContent = CreateContent();
            JsonSerializerSettings expectedSerializerSettings = CreateSerializerSettings();
            Encoding expectedEncoding = CreateDummyEncoding();
            ApiController controller = CreateController();

            // Act
            JsonResult<object> result = controller.Json(expectedContent, expectedSerializerSettings, expectedEncoding);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedContent, result.Content);
            Assert.Same(expectedSerializerSettings, result.SerializerSettings);
            Assert.Same(expectedEncoding, result.Encoding);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerJson_WithObjectAndJsonSerializerSettings_CreatesCorrectResult()
        {
            // Arrange
            object expectedContent = CreateContent();
            JsonSerializerSettings expectedSerializerSettings = CreateSerializerSettings();
            ApiController controller = CreateController();

            // Act
            JsonResult<object> result = controller.Json(expectedContent, expectedSerializerSettings);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedContent, result.Content);
            Assert.Same(expectedSerializerSettings, result.SerializerSettings);
            Encoding expectedEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false,
                throwOnInvalidBytes: true);
            Assert.Equal(expectedEncoding, result.Encoding);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerJson_WithObject_CreatesCorrectResult()
        {
            // Arrange
            object expectedContent = CreateContent();
            ApiController controller = CreateController();

            // Act
            JsonResult<object> result = controller.Json(expectedContent);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedContent, result.Content);
            Assert.NotNull(result.SerializerSettings);
            Encoding expectedEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false,
                throwOnInvalidBytes: true);
            Assert.Equal(expectedEncoding, result.Encoding);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static object CreateContent()
        {
            return new object();
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static Encoding CreateDummyEncoding()
        {
            return new Mock<Encoding>(MockBehavior.Strict).Object;
        }

        private static Encoding CreateEncoding()
        {
            return new ASCIIEncoding();
        }

        private static JsonResult<T> CreateProductUnderTest<T>(T content, JsonSerializerSettings serializerSettings,
            Encoding encoding, HttpRequestMessage request)
        {
            return new JsonResult<T>(content, serializerSettings, encoding, request);
        }

        private static JsonResult<T> CreateProductUnderTest<T>(T content, JsonSerializerSettings serializerSettings,
            Encoding encoding, ApiController controller)
        {
            return new JsonResult<T>(content, serializerSettings, encoding, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static JsonSerializerSettings CreateSerializerSettings()
        {
            return new JsonSerializerSettings();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/NegotiatedContentResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class NegotiatedContentResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenContentNegotiatorIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    new NegotiatedContentResult<object>(statusCode, content, contentNegotiator, request, formatters);
                }, "contentNegotiator");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();
            HttpRequestMessage request = null;
            IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                new NegotiatedContentResult<object>(statusCode, content, contentNegotiator, request, formatters);
            }, "request");
        }

        [Fact]
        public void Constructor_Throws_WhenFormattersIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    new NegotiatedContentResult<object>(statusCode, content, contentNegotiator, request, formatters);
                }, "formatters");
            }
        }

        [Fact]
        public void StatusCode_Returns_ValueProvided()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(expectedStatusCode,
                    content, contentNegotiator, request, formatters);

                // Act
                HttpStatusCode statusCode = result.StatusCode;

                // Assert
                Assert.Equal(expectedStatusCode, statusCode);
            }
        }

        [Fact]
        public void Content_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode,
                    expectedContent, contentNegotiator, request, formatters);

                // Act
                object content = result.Content;

                // Assert
                Assert.Same(expectedContent, content);
            }
        }

        [Fact]
        public void ContentNegotiator_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator expectedContentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    expectedContentNegotiator, request, formatters);

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    contentNegotiator, expectedRequest, formatters);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Formatters_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    contentNegotiator, request, expectedFormatters);

                // Act
                IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                // Assert
                Assert.Same(expectedFormatters, formatters);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationSucceeds()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter, expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = new NegotiatedContentResult<object>(expectedStatusCode, expectedContent,
                    contentNegotiator, expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(expectedStatusCode, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                    Assert.Same(expectedContent, typedContent.Value);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationFails()
        {
            // Arrange
            HttpStatusCode statusCode = HttpStatusCode.Conflict;
            object content = CreateContent();
            ContentNegotiationResult negotiationResult = null;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = new NegotiatedContentResult<object>(statusCode, content, contentNegotiator,
                    expectedRequest, expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                new NegotiatedContentResult<object>(statusCode, content, controller);
            }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse_WhenContentNegotationSucceeds()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedInputFormatter = CreateFormatter();
            MediaTypeFormatter expectedOutputFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedOutputFormatter,
                expectedMediaType);

            Expression<Func<IEnumerable<MediaTypeFormatter>, bool>> formattersMatch = (f) =>
                f != null && f.AsArray().Length == 1 && f.AsArray()[0] == expectedInputFormatter;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, It.Is(formattersMatch))).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                using (HttpConfiguration configuration = CreateConfiguration(expectedInputFormatter,
                    contentNegotiator))
                {
                    controller.Configuration = configuration;
                    controller.Request = expectedRequest;

                    IHttpActionResult result = new NegotiatedContentResult<object>(expectedStatusCode, expectedContent,
                        controller);

                    // Act
                    Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                    // Assert
                    Assert.NotNull(task);

                    using (HttpResponseMessage response = await task)
                    {
                        Assert.NotNull(response);
                        Assert.Equal(expectedStatusCode, response.StatusCode);
                        HttpContent content = response.Content;
                        ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                        Assert.Same(expectedContent, typedContent.Value);
                        Assert.Same(expectedOutputFormatter, typedContent.Formatter);
                        Assert.NotNull(typedContent.Headers);
                        Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesLazily()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                        controller);

                    IContentNegotiator expectedContentNegotiator = CreateContentNegotiator();
                    configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.Same(expectedContentNegotiator, contentNegotiator);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;
                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesLazily()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = CreateController();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                MediaTypeFormatter expectedFormatter = CreateFormatter();

                using (HttpConfiguration lateConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesOnce()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            IContentNegotiator expectedContentNegotiator = CreateContentNegotiator();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), expectedContentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                IContentNegotiator ignore = result.ContentNegotiator;

                configuration.Services.Replace(typeof(IContentNegotiator), CreateContentNegotiator());

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;
                    HttpRequestMessage ignore = result.Request;

                    using (HttpRequestMessage otherRequest = CreateRequest())
                    {
                        controller.Request = otherRequest;

                        // Act
                        HttpRequestMessage request = result.Request;

                        // Assert
                        Assert.Same(expectedRequest, request);
                    }
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesOnce()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                IEnumerable<MediaTypeFormatter> ignore = result.Formatters;

                using (HttpConfiguration lateConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenConfigurationIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = CreateController();
            HttpControllerContext context = new HttpControllerContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.ControllerContext = context;

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "HttpControllerContext.Configuration must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenServiceIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), null))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;

                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "The provided configuration does not have an instance of the " +
                    "'System.Net.Http.Formatting.IContentNegotiator' service registered.");
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            object content = CreateContent();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;
                NegotiatedContentResult<object> result = new NegotiatedContentResult<object>(statusCode, content,
                    controller);

                // Act & Assert
                InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                    { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
            }
        }

        [Fact]
        public void ApiControllerContent_WithContent_CreatesCorrectNegotiatedContentResult()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            object expectedContent = CreateContent();
            ApiController controller = CreateController();

            // Act
            NegotiatedContentResult<object> result = controller.Content(expectedStatusCode, expectedContent);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(expectedStatusCode, result.StatusCode);
            Assert.Same(expectedContent, result.Content);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static HttpConfiguration CreateConfiguration(MediaTypeFormatter formatter,
            IContentNegotiator contentNegotiator)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Formatters.Clear();
            configuration.Formatters.Add(formatter);
            configuration.Services.Replace(typeof(IContentNegotiator), contentNegotiator);
            return configuration;
        }

        private static object CreateContent()
        {
            return new object();
        }

        private static IContentNegotiator CreateContentNegotiator()
        {
            return new DummyContentNegotiator();
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubMediaTypeFormatter();
        }

        private static IEnumerable<MediaTypeFormatter> CreateFormatters()
        {
            return new MediaTypeFormatter[0];
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpStatusCode CreateStatusCode()
        {
            return HttpStatusCode.Continue;
        }

        private class DummyContentNegotiator : IContentNegotiator
        {
            public ContentNegotiationResult Negotiate(Type type, HttpRequestMessage request,
                IEnumerable<MediaTypeFormatter> formatters)
            {
                throw new NotImplementedException();
            }
        }

        private class StubMediaTypeFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/NotFoundResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class NotFoundResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(request); }, "request");
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                NotFoundResult result = CreateProductUnderTest(expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = CreateProductUnderTest(controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ApiController controller = CreateController();
            NotFoundResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ApiController controller = CreateController();
            NotFoundResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            NotFoundResult result = CreateProductUnderTest(controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerNotFound_CreatesCorrectResult()
        {
            // Arrange
            ApiController controller = CreateController();

            // Act
            NotFoundResult result = controller.NotFound();

            // Assert
            Assert.NotNull(result);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static NotFoundResult CreateProductUnderTest(HttpRequestMessage request)
        {
            return new NotFoundResult(request);
        }

        private static NotFoundResult CreateProductUnderTest(ApiController controller)
        {
            return new NotFoundResult(controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/OkNegotiatedContentResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class OkNegotiatedContentResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenContentNegotiatorIsNull()
        {
            // Arrange
            object content = CreateContent();
            IContentNegotiator contentNegotiator = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(content, contentNegotiator, request, formatters);
                }, "contentNegotiator");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();
            HttpRequestMessage request = null;
            IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(content, contentNegotiator, request, formatters);
            }, "request");
        }

        [Fact]
        public void Constructor_Throws_WhenFormattersIsNull()
        {
            // Arrange
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = null;

                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(content, contentNegotiator, request, formatters);
                }, "formatters");
            }
        }

        [Fact]
        public void Content_Returns_InstanceProvided()
        {
            // Arrange
            object expectedContent = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(expectedContent, contentNegotiator,
                    request, formatters);

                // Act
                object content = result.Content;

                // Assert
                Assert.Same(expectedContent, content);
            }
        }

        [Fact]
        public void ContentNegotiator_Returns_InstanceProvided()
        {
            // Arrange
            object content = CreateContent();
            IContentNegotiator expectedContentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, expectedContentNegotiator,
                    request, formatters);

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> formatters = CreateFormatters();

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, contentNegotiator,
                    expectedRequest, formatters);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Formatters_Returns_InstanceProvided()
        {
            // Arrange
            object content = CreateContent();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpRequestMessage request = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, contentNegotiator, request,
                    expectedFormatters);

                // Act
                IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                // Assert
                Assert.Same(expectedFormatters, formatters);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationSucceeds()
        {
            // Arrange
            object expectedContent = CreateContent();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedFormatter, expectedMediaType);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(expectedContent, contentNegotiator, expectedRequest,
                    expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    HttpContent content = response.Content;
                    ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                    Assert.Same(expectedContent, typedContent.Value);
                    Assert.Same(expectedFormatter, typedContent.Formatter);
                    Assert.NotNull(typedContent.Headers);
                    Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse_WhenContentNegotiationFails()
        {
            // Arrange
            object content = CreateContent();
            ContentNegotiationResult negotiationResult = null;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IEnumerable<MediaTypeFormatter> expectedFormatters = CreateFormatters();

                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, expectedFormatters)).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                IHttpActionResult result = CreateProductUnderTest(content, contentNegotiator, expectedRequest,
                    expectedFormatters);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.NotAcceptable, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(content, controller);
            }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse_WhenContentNegotationSucceeds()
        {
            // Arrange
            object expectedContent = CreateContent();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedInputFormatter = CreateFormatter();
            MediaTypeFormatter expectedOutputFormatter = CreateFormatter();
            MediaTypeHeaderValue expectedMediaType = CreateMediaType();
            ContentNegotiationResult negotiationResult = new ContentNegotiationResult(expectedOutputFormatter,
                expectedMediaType);

            Expression<Func<IEnumerable<MediaTypeFormatter>, bool>> formattersMatch = (f) =>
                f != null && f.AsArray().Length == 1 && f.AsArray()[0] == expectedInputFormatter;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                Mock<IContentNegotiator> spy = new Mock<IContentNegotiator>();
                spy.Setup(n => n.Negotiate(typeof(object), expectedRequest, It.Is(formattersMatch))).Returns(
                    negotiationResult);
                IContentNegotiator contentNegotiator = spy.Object;

                using (HttpConfiguration configuration = CreateConfiguration(expectedInputFormatter,
                    contentNegotiator))
                {
                    controller.Configuration = configuration;
                    controller.Request = expectedRequest;

                    IHttpActionResult result = CreateProductUnderTest(expectedContent, controller);

                    // Act
                    Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                    // Assert
                    Assert.NotNull(task);

                    using (HttpResponseMessage response = await task)
                    {
                        Assert.NotNull(response);
                        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                        HttpContent content = response.Content;
                        ObjectContent<object> typedContent = Assert.IsType<ObjectContent<object>>(content);
                        Assert.Same(expectedContent, typedContent.Value);
                        Assert.Same(expectedOutputFormatter, typedContent.Formatter);
                        Assert.NotNull(typedContent.Headers);
                        Assert.Equal(expectedMediaType, typedContent.Headers.ContentType);
                        Assert.Same(expectedRequest, response.RequestMessage);
                    }
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesLazily()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;

                using (HttpRequestMessage request = CreateRequest())
                {
                    controller.Request = request;

                    OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                    IContentNegotiator expectedContentNegotiator = CreateContentNegotiator();
                    configuration.Services.Replace(typeof(IContentNegotiator), expectedContentNegotiator);

                    // Act
                    IContentNegotiator contentNegotiator = result.ContentNegotiator;

                    // Assert
                    Assert.Same(expectedContentNegotiator, contentNegotiator);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            object content = CreateContent();
            MediaTypeFormatter formatter = CreateFormatter();
            MediaTypeHeaderValue mediaType = CreateMediaType();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;
                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesLazily()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = CreateController();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                MediaTypeFormatter expectedFormatter = CreateFormatter();

                using (HttpConfiguration lateConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_EvaluatesOnce()
        {
            // Arrange
            object content = CreateContent();
            IContentNegotiator expectedContentNegotiator = CreateContentNegotiator();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), expectedContentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = request;

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                IContentNegotiator ignore = result.ContentNegotiator;

                configuration.Services.Replace(typeof(IContentNegotiator), CreateContentNegotiator());

                // Act
                IContentNegotiator contentNegotiator = result.ContentNegotiator;

                // Assert
                Assert.Same(expectedContentNegotiator, contentNegotiator);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                using (HttpRequestMessage expectedRequest = CreateRequest())
                {
                    controller.Request = expectedRequest;
                    HttpRequestMessage ignore = result.Request;

                    using (HttpRequestMessage otherRequest = CreateRequest())
                    {
                        controller.Request = otherRequest;

                        // Act
                        HttpRequestMessage request = result.Request;

                        // Assert
                        Assert.Same(expectedRequest, request);
                    }
                }
            }
        }

        [Fact]
        public void Formatters_ForApiController_EvaluatesOnce()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = CreateController();
            MediaTypeFormatter expectedFormatter = CreateFormatter();
            IContentNegotiator contentNegotiator = CreateContentNegotiator();

            using (HttpConfiguration earlyConfiguration = CreateConfiguration(expectedFormatter, contentNegotiator))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = earlyConfiguration;
                controller.Request = request;

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                IEnumerable<MediaTypeFormatter> ignore = result.Formatters;

                using (HttpConfiguration lateConfiguration = CreateConfiguration(CreateFormatter(), contentNegotiator))
                {
                    controller.Configuration = lateConfiguration;

                    // Act
                    IEnumerable<MediaTypeFormatter> formatters = result.Formatters;

                    // Assert
                    Assert.NotNull(formatters);
                    MediaTypeFormatter formatter = Assert.Single(formatters);
                    Assert.Same(expectedFormatter, formatter);
                }
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenConfigurationIsNull()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = CreateController();
            HttpControllerContext context = new HttpControllerContext();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.ControllerContext = context;

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "HttpControllerContext.Configuration must not be null.");
            }
        }

        [Fact]
        public void ContentNegotiator_ForApiController_Throws_WhenServiceIsNull()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = CreateController();

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), null))
            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Configuration = configuration;

                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => { IContentNegotiator ignore = result.ContentNegotiator; },
                    "The provided configuration does not have an instance of the " +
                    "'System.Net.Http.Formatting.IContentNegotiator' service registered.");
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            object content = CreateContent();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            {
                controller.Configuration = configuration;
                OkNegotiatedContentResult<object> result = CreateProductUnderTest(content, controller);

                // Act & Assert
                InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                    { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
            }
        }

        [Fact]
        public void ApiControllerOk_WithContent_CreatesCorrectResult()
        {
            // Arrange
            object expectedContent = CreateContent();
            ApiController controller = CreateController();

            // Act
            OkNegotiatedContentResult<object> result = controller.Ok(expectedContent);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedContent, result.Content);

            using (HttpConfiguration configuration = CreateConfiguration(CreateFormatter(), CreateContentNegotiator()))
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Configuration = configuration;
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static HttpConfiguration CreateConfiguration(MediaTypeFormatter formatter,
            IContentNegotiator contentNegotiator)
        {
            HttpConfiguration configuration = new HttpConfiguration();
            configuration.Formatters.Clear();
            configuration.Formatters.Add(formatter);
            configuration.Services.Replace(typeof(IContentNegotiator), contentNegotiator);
            return configuration;
        }

        private static object CreateContent()
        {
            return new object();
        }

        private static IContentNegotiator CreateContentNegotiator()
        {
            return new DummyContentNegotiator();
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static MediaTypeFormatter CreateFormatter()
        {
            return new StubMediaTypeFormatter();
        }

        private static IEnumerable<MediaTypeFormatter> CreateFormatters()
        {
            return new MediaTypeFormatter[0];
        }

        private static MediaTypeHeaderValue CreateMediaType()
        {
            return new MediaTypeHeaderValue("text/plain");
        }

        private static OkNegotiatedContentResult<object> CreateProductUnderTest(object content,
            IContentNegotiator contentNegotiator, HttpRequestMessage request,
            IEnumerable<MediaTypeFormatter> formatters)
        {
            return new OkNegotiatedContentResult<object>(content, contentNegotiator, request, formatters);
        }

        private static OkNegotiatedContentResult<object> CreateProductUnderTest(object content,
            ApiController controller)
        {
            return new OkNegotiatedContentResult<object>(content, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class DummyContentNegotiator : IContentNegotiator
        {
            public ContentNegotiationResult Negotiate(Type type, HttpRequestMessage request,
                IEnumerable<MediaTypeFormatter> formatters)
            {
                throw new NotImplementedException();
            }
        }

        private class StubMediaTypeFormatter : MediaTypeFormatter
        {
            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/OkResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class OkResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(request); }, "request");
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                OkResult result = CreateProductUnderTest(expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = CreateProductUnderTest(controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.OK, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            ApiController controller = CreateController();
            OkResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            ApiController controller = CreateController();
            OkResult result = CreateProductUnderTest(controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            OkResult result = CreateProductUnderTest(controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerOk_CreatesCorrectResult()
        {
            // Arrange
            ApiController controller = CreateController();

            // Act
            OkResult result = controller.Ok();

            // Assert
            Assert.NotNull(result);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static OkResult CreateProductUnderTest(HttpRequestMessage request)
        {
            return new OkResult(request);
        }

        private static OkResult CreateProductUnderTest(ApiController controller)
        {
            return new OkResult(controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/RedirectResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class RedirectResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenLocationIsNull()
        {
            // Arrange
            Uri location = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(location, request); }, "location");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(location, request); }, "request");
        }

        [Fact]
        public void Location_Returns_InstanceProvided()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();

            using (HttpRequestMessage request = CreateRequest())
            {
                RedirectResult result = CreateProductUnderTest(expectedLocation, request);

                // Act
                Uri location = result.Location;

                // Assert
                Assert.Same(expectedLocation, location);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            Uri location = CreateLocation();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                RedirectResult result = CreateProductUnderTest(location, expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedLocation, expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
                    Assert.Same(expectedLocation, response.Headers.Location);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(location, controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                IHttpActionResult result = CreateProductUnderTest(expectedLocation, controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
                    Assert.Same(expectedLocation, response.Headers.Location);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            Uri location = CreateLocation();
            ApiController controller = CreateController();
            RedirectResult result = CreateProductUnderTest(location, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            Uri location = CreateLocation();
            ApiController controller = CreateController();
            RedirectResult result = CreateProductUnderTest(location, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            Uri location = CreateLocation();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            RedirectResult result = CreateProductUnderTest(location, controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerRedirect_WithUri_CreatesCorrectResult()
        {
            // Arrange
            Uri expectedLocation = CreateLocation();
            ApiController controller = CreateController();

            // Act
            RedirectResult result = controller.Redirect(expectedLocation);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedLocation, result.Location);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerRedirect_WithString_Throws_WhenLocationIsNull()
        {
            // Arrange
            string location = null;
            ApiController controller = CreateController();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { controller.Redirect(location); }, "location");
        }

        [Fact]
        public void ApiControllerRedirect_WithString_CreatesCorrectResult()
        {
            // Arrange
            string expectedLocation = CreateLocation().OriginalString;
            ApiController controller = CreateController();

            // Act
            RedirectResult result = controller.Redirect(expectedLocation);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedLocation, result.Location.OriginalString);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static Uri CreateLocation()
        {
            return new Uri("aa://b");
        }

        private static RedirectResult CreateProductUnderTest(Uri location, HttpRequestMessage request)
        {
            return new RedirectResult(location, request);
        }

        private static RedirectResult CreateProductUnderTest(Uri location, ApiController controller)
        {
            return new RedirectResult(location, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/RedirectToRouteResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Results
{
    public class RedirectToRouteResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRouteNameIsNull()
        {
            // Arrange
            string routeName = null;
            IDictionary<string, object> routeValues = CreateRouteValues();
            UrlHelper urlFactory = CreateDummyUrlFactory();

            using (HttpRequestMessage request = CreateRequest())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(routeName, routeValues, urlFactory, request);
                }, "routeName");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenUrlFactoryIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            UrlHelper urlFactory = null;

            using (HttpRequestMessage request = CreateRequest())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() =>
                {
                    CreateProductUnderTest(routeName, routeValues, urlFactory, request);
                }, "urlFactory");
            }
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            UrlHelper urlFactory = CreateDummyUrlFactory();
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(routeName, routeValues, urlFactory, request);
            }, "request");
        }

        [Fact]
        public void RouteName_Returns_InstanceProvided()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            UrlHelper urlFactory = CreateDummyUrlFactory();

            using (HttpRequestMessage request = CreateRequest())
            {
                RedirectToRouteResult result = CreateProductUnderTest(expectedRouteName, routeValues, urlFactory,
                    request);

                // Act
                string routeName = result.RouteName;

                // Assert
                Assert.Same(expectedRouteName, routeName);
            }
        }

        [Fact]
        public void RouteValues_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            UrlHelper urlFactory = CreateDummyUrlFactory();

            using (HttpRequestMessage request = CreateRequest())
            {
                RedirectToRouteResult result = CreateProductUnderTest(routeName, expectedRouteValues, urlFactory,
                    request);

                // Act
                IDictionary<string, object> routeValues = result.RouteValues;

                // Assert
                Assert.Same(expectedRouteValues, routeValues);
            }
        }

        [Fact]
        public void UrlFactory_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            UrlHelper expectedUrlFactory = CreateDummyUrlFactory();

            using (HttpRequestMessage request = CreateRequest())
            {
                RedirectToRouteResult result = CreateProductUnderTest(routeName, routeValues, expectedUrlFactory,
                    request);

                // Act
                UrlHelper urlFactory = result.UrlFactory;

                // Assert
                Assert.Same(expectedUrlFactory, urlFactory);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            UrlHelper urlFactory = CreateDummyUrlFactory();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                RedirectToRouteResult result = CreateProductUnderTest(routeName, routeValues, urlFactory,
                    expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            Mock<UrlHelper> spyUrlFactory = new Mock<UrlHelper>(MockBehavior.Strict);
            string expectedLocation = CreateLocation().AbsoluteUri;
            spyUrlFactory.Setup(f => f.Link(expectedRouteName, expectedRouteValues)).Returns(expectedLocation);
            UrlHelper urlFactory = spyUrlFactory.Object;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedRouteName, expectedRouteValues, urlFactory,
                    expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
                    Assert.Same(expectedLocation, response.Headers.Location.OriginalString);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task ExecuteAsync_Throws_WhenUrlHelperLinkReturnsNull()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            Mock<UrlHelper> stubUrlFactory = new Mock<UrlHelper>(MockBehavior.Strict);
            stubUrlFactory.Setup(f => f.Link(expectedRouteName, expectedRouteValues)).Returns((string)null);
            UrlHelper urlFactory = stubUrlFactory.Object;

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(expectedRouteName, expectedRouteValues, urlFactory,
                    expectedRequest);

                // Act & Assert
                InvalidOperationException exception = await Assert.ThrowsAsync<InvalidOperationException>(
                    () => result.ExecuteAsync(CancellationToken.None));
                Assert.Equal("UrlHelper.Link must not return null.", exception.Message);
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() =>
            {
                CreateProductUnderTest(routeName, routeValues, controller);
            }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            Mock<UrlHelper> spyUrlFactory = new Mock<UrlHelper>(MockBehavior.Strict);
            string expectedLocation = CreateLocation().AbsoluteUri;
            spyUrlFactory.Setup(f => f.Link(expectedRouteName, expectedRouteValues)).Returns(expectedLocation);
            UrlHelper urlFactory = spyUrlFactory.Object;
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                controller.Url = urlFactory;

                IHttpActionResult result = CreateProductUnderTest(expectedRouteName, expectedRouteValues, controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
                    Assert.Same(expectedLocation, response.Headers.Location.OriginalString);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void UrlFactory_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            ApiController controller = CreateController();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Request = request;
                controller.Url = CreateDummyUrlFactory();

                RedirectToRouteResult result = CreateProductUnderTest(routeName, routeValues, controller);

                UrlHelper expectedUrlFactory = CreateDummyUrlFactory();
                controller.Url = expectedUrlFactory;

                // Act
                UrlHelper urlFactory = result.UrlFactory;

                // Assert
                Assert.Same(expectedUrlFactory, urlFactory);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            ApiController controller = CreateController();
            RedirectToRouteResult result = CreateProductUnderTest(routeName, routeValues, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void UrlFactory_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            ApiController controller = CreateController();

            using (HttpRequestMessage request = CreateRequest())
            {
                controller.Request = request;
                UrlHelper expectedUrlFactory = CreateDummyUrlFactory();
                controller.Url = expectedUrlFactory;

                RedirectToRouteResult result = CreateProductUnderTest(routeName, routeValues, controller);

                UrlHelper ignore = result.UrlFactory;

                controller.Url = CreateDummyUrlFactory();

                // Act
                UrlHelper urlFactory = result.UrlFactory;

                // Assert
                Assert.Same(expectedUrlFactory, urlFactory);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            ApiController controller = CreateController();

            RedirectToRouteResult result = CreateProductUnderTest(routeName, routeValues, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            string routeName = CreateRouteName();
            IDictionary<string, object> routeValues = CreateRouteValues();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);

            RedirectToRouteResult result = CreateProductUnderTest(routeName, routeValues, controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerRedirectToRoute_WithStringAndDictionary_CreatesCorrectResult()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            IDictionary<string, object> expectedRouteValues = CreateRouteValues();
            ApiController controller = CreateController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(expectedRouteName, expectedRouteValues);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedRouteName, result.RouteName);
            Assert.Same(expectedRouteValues, result.RouteValues);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerRedirectToRoute_WithStringAndObject_CreatesCorrectResult()
        {
            // Arrange
            string expectedRouteName = CreateRouteName();
            object routeValues = new { id = 1 };
            ApiController controller = CreateController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(expectedRouteName, routeValues);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedRouteName, result.RouteName);
            Assert.IsType<HttpRouteValueDictionary>(result.RouteValues);
            Assert.True(result.RouteValues.ContainsKey("id"));
            Assert.Equal(1, result.RouteValues["id"]);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static UrlHelper CreateDummyUrlFactory()
        {
            return new Mock<UrlHelper>(MockBehavior.Strict).Object;
        }

        private static Uri CreateLocation()
        {
            return new Uri("aa://b");
        }

        private static RedirectToRouteResult CreateProductUnderTest(string routeName,
            IDictionary<string, object> routeValues, UrlHelper urlFactory, HttpRequestMessage request)
        {
            return new RedirectToRouteResult(routeName, routeValues, urlFactory, request);
        }

        private static RedirectToRouteResult CreateProductUnderTest(string routeName,
            IDictionary<string, object> routeValues, ApiController controller)
        {
            return new RedirectToRouteResult(routeName, routeValues, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static string CreateRouteName()
        {
            return "IgnoreRouteName";
        }

        private static IDictionary<string, object> CreateRouteValues()
        {
            return new Dictionary<string, object>();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/ResponseMessageResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class ResponseMessageResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenResponseIsNull()
        {
            // Arrange, Act & Assert
            Assert.ThrowsArgumentNull(() => { new ResponseMessageResult(null); }, "response");
        }

        [Fact]
        public void Response_Returns_InstanceProvided()
        {
            // Arrange
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                ResponseMessageResult result = new ResponseMessageResult(expectedResponse);

                // Act
                HttpResponseMessage response = result.Response;

                // Assert
                Assert.Same(expectedResponse, response);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_InstanceProvided()
        {
            // Arrange
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                IHttpActionResult result = new ResponseMessageResult(expectedResponse);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.Same(expectedResponse, response);
                }
            }
        }

        [Fact]
        public void ApiControllerResponseMessage_CreatesCorrectResponseMessageResult()
        {
            // Arrange
            using (HttpResponseMessage expectedResponse = CreateResponse())
            {
                ApiController controller = CreateController();

                // Act
                ResponseMessageResult result = controller.ResponseMessage(expectedResponse);

                // Assert
                Assert.NotNull(result);
                Assert.Same(expectedResponse, result.Response);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/StatusCodeResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class StatusCodeResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { new StatusCodeResult(statusCode, request); }, "request");
        }

        [Fact]
        public void StatusCode_Returns_ValueProvided()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();

            using (HttpRequestMessage request = CreateRequest())
            {
                StatusCodeResult result = new StatusCodeResult(expectedStatusCode, request);

                // Act
                HttpStatusCode statusCode = result.StatusCode;

                // Assert
                Assert.Equal(expectedStatusCode, statusCode);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                StatusCodeResult result = new StatusCodeResult(statusCode, expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = new StatusCodeResult(expectedStatusCode, expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(expectedStatusCode, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { new StatusCodeResult(statusCode, controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = new StatusCodeResult(expectedStatusCode, controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(expectedStatusCode, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            ApiController controller = CreateController();
            StatusCodeResult result = new StatusCodeResult(statusCode, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            ApiController controller = CreateController();
            StatusCodeResult result = new StatusCodeResult(statusCode, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            HttpStatusCode statusCode = CreateStatusCode();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            StatusCodeResult result = new StatusCodeResult(statusCode, controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerStatusCode_CreatesCorrectStatusCodeResult()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = CreateStatusCode();
            ApiController controller = CreateController();

            // Act
            StatusCodeResult result = controller.StatusCode(expectedStatusCode);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(expectedStatusCode, result.StatusCode);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpStatusCode CreateStatusCode()
        {
            return HttpStatusCode.Continue;
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Results/UnauthorizedResultTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Results
{
    public class UnauthorizedResultTests
    {
        [Fact]
        public void Constructor_Throws_WhenChallengesIsNull()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> challenges = null;
            HttpRequestMessage request = CreateRequest();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(challenges, request); }, "challenges");
        }

        [Fact]
        public void Constructor_Throws_WhenRequestIsNull()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> challenges = CreateChallenges();
            HttpRequestMessage request = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(challenges, request); }, "request");
        }

        [Fact]
        public void Challenges_Returns_InstanceProvided()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> expectedChallenges = CreateChallenges();

            using (HttpRequestMessage request = CreateRequest())
            {
                UnauthorizedResult result = CreateProductUnderTest(expectedChallenges, request);

                // Act
                IEnumerable<AuthenticationHeaderValue> challenges = result.Challenges;

                // Assert
                Assert.Same(expectedChallenges, challenges);
            }
        }

        [Fact]
        public void Request_Returns_InstanceProvided()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> challenges = CreateChallenges();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                UnauthorizedResult result = CreateProductUnderTest(challenges, expectedRequest);

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public async Task ExecuteAsync_Returns_CorrectResponse()
        {
            // Arrange
            AuthenticationHeaderValue expectedChallenge1 = CreateChallenge();
            AuthenticationHeaderValue expectedChallenge2 = CreateChallenge();
            IEnumerable<AuthenticationHeaderValue> challenges = new[] { expectedChallenge1, expectedChallenge2 };

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                IHttpActionResult result = CreateProductUnderTest(challenges, expectedRequest);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
                    Assert.Equal(2, response.Headers.WwwAuthenticate.Count);
                    Assert.Same(expectedChallenge1, response.Headers.WwwAuthenticate.ElementAt(0));
                    Assert.Same(expectedChallenge2, response.Headers.WwwAuthenticate.ElementAt(1));
                    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Constructor_ForApiController_Throws_WhenControllerIsNull()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> challenges = CreateChallenges();
            ApiController controller = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => { CreateProductUnderTest(challenges, controller); }, "controller");
        }

        [Fact]
        public async Task ExecuteAsync_ForApiController_ReturnsCorrectResponse()
        {
            // Arrange
            AuthenticationHeaderValue expectedChallenge1 = CreateChallenge();
            AuthenticationHeaderValue expectedChallenge2 = CreateChallenge();
            IEnumerable<AuthenticationHeaderValue> challenges = new[] { expectedChallenge1, expectedChallenge2 };
            ApiController controller = CreateController();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                IHttpActionResult result = CreateProductUnderTest(challenges, controller);

                // Act
                Task<HttpResponseMessage> task = result.ExecuteAsync(CancellationToken.None);

                // Assert
                Assert.NotNull(task);

                using (HttpResponseMessage response = await task)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
                    Assert.Equal(2, response.Headers.WwwAuthenticate.Count);
                    Assert.Same(expectedChallenge1, response.Headers.WwwAuthenticate.ElementAt(0));
                    Assert.Same(expectedChallenge2, response.Headers.WwwAuthenticate.ElementAt(1));
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesLazily()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> challenges = CreateChallenges();
            ApiController controller = CreateController();
            UnauthorizedResult result = CreateProductUnderTest(challenges, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;

                // Act
                HttpRequestMessage request = result.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void Request_ForApiController_EvaluatesOnce()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> challenges = CreateChallenges();
            ApiController controller = CreateController();
            UnauthorizedResult result = CreateProductUnderTest(challenges, controller);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                HttpRequestMessage ignore = result.Request;

                using (HttpRequestMessage otherRequest = CreateRequest())
                {
                    controller.Request = otherRequest;

                    // Act
                    HttpRequestMessage request = result.Request;

                    // Assert
                    Assert.Same(expectedRequest, request);
                }
            }
        }

        [Fact]
        public void Request_ForApiController_Throws_WhenControllerRequestIsNull()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> challenges = CreateChallenges();
            ApiController controller = CreateController();
            Assert.Null(controller.Request);
            UnauthorizedResult result = CreateProductUnderTest(challenges, controller);

            // Act & Assert
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(() =>
                { HttpRequestMessage ignore = result.Request; }, "ApiController.Request must not be null.");
        }

        [Fact]
        public void ApiControllerUnauthorized_WithIEnumerable_CreatesCorrectResult()
        {
            // Arrange
            IEnumerable<AuthenticationHeaderValue> expectedChallenges = CreateChallenges();
            ApiController controller = CreateController();

            // Act
            UnauthorizedResult result = controller.Unauthorized(expectedChallenges);

            // Assert
            Assert.NotNull(result);
            Assert.Same(expectedChallenges, result.Challenges);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        [Fact]
        public void ApiControllerUnauthorized_WithParams_CreatesCorrectResult()
        {
            // Arrange
            AuthenticationHeaderValue challenge1 = CreateChallenge();
            AuthenticationHeaderValue challenge2 = CreateChallenge();
            ApiController controller = CreateController();

            // Act
            UnauthorizedResult result = controller.Unauthorized(challenge1, challenge2);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(2, result.Challenges.Count());
            Assert.Same(challenge1, result.Challenges.ElementAt(0));
            Assert.Same(challenge2, result.Challenges.ElementAt(1));

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                controller.Request = expectedRequest;
                Assert.Same(expectedRequest, result.Request);
            }
        }

        private static IEnumerable<AuthenticationHeaderValue> CreateChallenges()
        {
            return new AuthenticationHeaderValue[0];
        }

        private static AuthenticationHeaderValue CreateChallenge()
        {
            return new AuthenticationHeaderValue("IgnoreScheme");
        }

        private static ApiController CreateController()
        {
            return new FakeController();
        }

        private static UnauthorizedResult CreateProductUnderTest(IEnumerable<AuthenticationHeaderValue> challenges,
            HttpRequestMessage request)
        {
            return new UnauthorizedResult(challenges, request);
        }

        private static UnauthorizedResult CreateProductUnderTest(IEnumerable<AuthenticationHeaderValue> challenges,
            ApiController controller)
        {
            return new UnauthorizedResult(challenges, controller);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private class FakeController : ApiController
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/AttributeRoutingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http.Routing
{
    public class AttributeRoutingTest
    {
        [Theory]
        [InlineData("GET", "controller/42", "Get42")]
        // Tests inline route constraints
        [InlineData("GET", "controller/Ethan", "GetByNameEthan")]
        // Tests the HTTP method constraint
        [InlineData("PUT", "controller/42", "Put42")]
        // Tests route consolidation (or lack thereof)
        [InlineData("PUT", "controller/42?name=foo", "Put42foo")]
        // Tests optional parameters
        [InlineData("GET", "optional/1/2", "Optional12")]
        [InlineData("GET", "optional/1", "Optional1opt")]
        [InlineData("GET", "optional", "Optional8opt")]
        [InlineData("GET", "optionalwconstraint", "OptionalWithConstraintx")]
        [InlineData("GET", "optionalwnullable/12", "Optional12")]
        [InlineData("GET", "optionalwnullable", "Optional")]
        [InlineData("GET", "apibadcontrollerx/int/12", "GetInt12")]
        [InlineData("GET", "apibadcontrollerx/nullableint/12", "GetNullable12")]
        [InlineData("GET", "apibadcontrollerx/string/12", "GetString12")]
        // Tests default values
        [InlineData("GET", "default/1/2", "Default12")]
        [InlineData("GET", "default/1", "Default1D2")]
        [InlineData("GET", "default", "DefaultD1D2")]
        // Test wildcard parameters
        [InlineData("GET", "wildcard/a/b/c", "Wildcarda/b/c")]
        // Test prefixes
        [InlineData("GET", "prefix", "PrefixedGet")]
        [InlineData("GET", "prefix/123", "PrefixedGetById123")]
        [InlineData("PUT", "prefix", "PrefixedPut")]
        // Test multiple controllerRouteFactories to same action
        [InlineData("DELETE", "multi1", "multi")]
        [InlineData("DELETE", "multi2", "multi")]
        // Test multiple verbs on the same route
        [InlineData("GET", "multiverb", "GET")]
        [InlineData("PUT", "multiverb", "PUT")]
        // Test with default route
        [InlineData("GET", "prefix2/defaultroute/12", "get12")]
        [InlineData("PUT", "prefix2/defaultrouteoverride/12", "put12")]
        [InlineData("POST", "prefix2", "post")]
        // {action} values
        [InlineData("GET", "api/default2/GetAllCustomers1", "GetAllCustomers1")]
        [InlineData("GET", "api/resource/12", "12")]
        [InlineData("GET", "apiactionstress/ActionY/ActionX?useX=5", "XActionY5")]
        [InlineData("GET", "apiactionstress/ActionY/ActionX?useY=7", "YActionX7")]
        // Mixing {action} with REST
        [InlineData("GET", "partial/DoOp1", "op1")]
        [InlineData("GET", "partial/154", "154")]
        // Optional on controller [Route]
        [InlineData("GET", "apioptional", "GetAllCustomers")]
        [InlineData("GET", "apioptional/57", "GetCustomer:57")]
        // Overload resolution
        [InlineData("GET", "apioverload/Fred?age=12", "GetAge:Fred12")]
        [InlineData("GET", "apioverload/Fred?score=12", "GetScore:Fred12")]
        // Controller route attribute inheritance
        [InlineData("GET", "subclass?id=8", "Get:8")]
        [InlineData("POST", "subclass?name=foo", "Post:foo")]
        [InlineData("GET", "api/subclassnoroute?id=8", "Get:8")]
        [InlineData("POST", "api/subclassnoroute?name=foo", "Post:foo")]
        [InlineData("GET", "baseclass?id=9", "Get:9")]
        [InlineData("GET", "baseclassprefix", "Get")]
        [InlineData("GET", "baseclassprefix/base/8", "Get:8")]
        [InlineData("GET", "api/subclassnoprefix", "Get")]
        [InlineData("GET", "api/subclassnoprefix?id=9", "Get:9")]
        [InlineData("POST", "api/subclassnoprefix?name=foo", "Post:foo")]
        [InlineData("POST", "subclassprefix?name=foo", "Post:foo")]
        [InlineData("GET", "api/subclassprefix", "Get")]
        [InlineData("GET", "api/subclassprefix?id=3", "Get:3")]
        [InlineData("GET", "subclassroute", "Get")]
        [InlineData("GET", "subclassroute?id=9", "Get:9")]
        [InlineData("POST", "subclassroute?name=foo", "Post:foo")]
        // Route order
        [InlineData("GET", "routeorder/11", "GetById:11")]
        [InlineData("GET", "routeorder/name", "GetByName:name")]
        [InlineData("GET", "routeorder/literal", "GetLiteral")]
        [InlineData("GET", "routeorderoverload", "Get")]
        [InlineData("GET", "routeorderoverload?name=name&id=1", "GetByNameAndId:name1")]
        [InlineData("GET", "routeorderoverload?name=name", "GetByName:name")]
        // Route precedence
        [InlineData("GET", "routeprecedence/11", "GetById:11")]
        [InlineData("GET", "routeprecedence/name", "GetByName:name")]
        [InlineData("GET", "routeprecedence/literal", "GetLiteral")]
        [InlineData("GET", "routeprecedence/name?id=20", "GetByNameAndId:name20")]
        [InlineData("GET", "constraint", "pass")]
        public async Task AttributeRouting_RoutesToAction(string httpMethod, string uri, string responseBody)
        {
            var request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/" + uri);

            var response = await SubmitRequestAsync(request);

            Assert.True(response.IsSuccessStatusCode);
            Assert.Equal(responseBody, GetContentValue<string>(response));
        }

        [Theory]
        // default controllerRouteFactories
        [InlineData("GET", "prefix2/defaultroute/name", HttpStatusCode.NotFound)] // miss route constraint
        [InlineData("PUT", "prefix2/defaultroute/12", HttpStatusCode.MethodNotAllowed)] // override, different url
        [InlineData("POST", "prefix", HttpStatusCode.MethodNotAllowed)]
        // wrong verb, 405
        [InlineData("MISSING", "controller/42", HttpStatusCode.MethodNotAllowed)]
        [InlineData("MISSING", "default/1/2", HttpStatusCode.MethodNotAllowed)]
        [InlineData("MISSING", "controller/Ethan", HttpStatusCode.MethodNotAllowed)]
        // accessing attribute routed method via standard route
        [InlineData("GET", "api/Attributed?id=42", HttpStatusCode.NotFound)]
        [InlineData("GET", "api/DefaultRoute?id=42", HttpStatusCode.NotFound)]
        [InlineData("GET", "api/Default2/GetById", HttpStatusCode.NotFound)]
        [InlineData("GET", "api/Default2/MethodNotFound", HttpStatusCode.NotFound)]
        // Ambiguous match
        [InlineData("GET", "apioverload/Fred?score=12&age=23", HttpStatusCode.InternalServerError)]
        [InlineData("GET", "apiactionstress/ActionY/ActionX?useY=7&useX=8", HttpStatusCode.InternalServerError)]
        // Unreachable inherited controllerRouteFactories
        [InlineData("GET", "api/subclassroute", HttpStatusCode.NotFound)]
        [InlineData("GET", "api/subclassroute?id=9", HttpStatusCode.NotFound)]
        [InlineData("POST", "api/subclassroute?name=foo", HttpStatusCode.NotFound)]
        [InlineData("GET", "api/baseclass?id=2", HttpStatusCode.NotFound)]
        [InlineData("GET", "api/baseclassprefix", HttpStatusCode.NotFound)]
        [InlineData("GET", "api/baseclassprefix?id=2", HttpStatusCode.NotFound)]
        // Default value is required, 500 would be a better error, but important thing is we fail
        [InlineData("GET", "apibadcontrollerx/int", HttpStatusCode.NotFound)]
        [InlineData("GET", "apibadcontrollerx/nullableint", HttpStatusCode.NotFound)]
        [InlineData("GET", "apibadcontrollerx/string", HttpStatusCode.NotFound)]
        public async Task AttributeRouting_Failures(string httpMethod, string uri, HttpStatusCode failureCode)
        {
            var request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/" + uri);

            var response = await SubmitRequestAsync(request);

            Assert.False(response.IsSuccessStatusCode);
            Assert.Equal(failureCode, response.StatusCode);
        }

        [Fact]
        public async Task AttributeRouting_MultipleControllerMatches()
        {
            var request = new HttpRequestMessage(new HttpMethod("GET"), "http://localhost/ambiguousmatch");

            var response = await SubmitRequestAsync(request);

            Assert.False(response.IsSuccessStatusCode);
            Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
        }

        [Fact]
        public void RoutePrefixAttribute_IsSingleInstance()
        {
            var attr = typeof(RoutePrefixAttribute);
            var attrs = attr.GetCustomAttributes(typeof(AttributeUsageAttribute), false);
            var usage = (AttributeUsageAttribute)attrs[0];

            Assert.Equal(AttributeTargets.Class, usage.ValidOn);
            Assert.False(usage.AllowMultiple); // only 1 per class
            Assert.True(usage.Inherited); // RoutePrefix is not inherited.
        }

        [Theory]
        [InlineData("GET", "NS1Home/Introduction", "Home.Index()")]
        [InlineData("GET", "NS2Account/PeopleList", "Account.Index()")]
        [InlineData("GET", "CustomizedDefaultPrefix/Unknown", "Default.Index()")]
        public async Task AttributeRouting_RoutesToAction_WithCustomizedRoutePrefix(string httpMethod, string uri, string responseBody)
        {
            var request = new HttpRequestMessage(new HttpMethod(httpMethod), "http://localhost/" + uri);

            var response = await SubmitRequestAsync(request);

            Assert.True(response.IsSuccessStatusCode);
            Assert.Equal(responseBody, GetContentValue<string>(response));
        }

        [Fact]
        public async Task AttributeRouting_DirectRouteProvider_ControllerRoute()
        {
            var controllerRoutes = new Dictionary<Type, IEnumerable<IDirectRouteFactory>>()
            {
                { typeof(DirectRouteProviderController), new[] { new RouteAttribute("CoolRouteBro") } }
            };

            var routeProvider = new DirectRouteProvider(controllerRoutes, null);


            var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/CoolRouteBro");

            var response = await SubmitRequestAsync(request, routeProvider);

            Assert.True(response.IsSuccessStatusCode);
            Assert.Equal("DirectRouteProviderController.Get239303030()", GetContentValue<string>(response));
        }

        [Fact]
        public async Task AttributeRouting_DirectRouteProvider_ControllerRoute_TraditionalRouteDoesntMatch()
        {
            var controllerRoutes = new Dictionary<Type, IEnumerable<IDirectRouteFactory>>()
            {
                { typeof(DirectRouteProviderController), new[] { new RouteAttribute("CoolRouteBro") } }
            };

            var routeProvider = new DirectRouteProvider(controllerRoutes, null);


            var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/DirectRouteProvider");

            var response = await SubmitRequestAsync(request, routeProvider);

            Assert.False(response.IsSuccessStatusCode);
            Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
        }

        [Fact]
        public async Task AttributeRouting_DirectRouteProvider_ActionRoute()
        {
            var actionRoutes = new Dictionary<string, IEnumerable<IDirectRouteFactory>>()
            {
                { "Get239303030", new[] { new RouteAttribute("CoolRouteBro") } }
            };

            var routeProvider = new DirectRouteProvider(null, actionRoutes);


            var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/CoolRouteBro");

            var response = await SubmitRequestAsync(request, routeProvider);

            Assert.True(response.IsSuccessStatusCode);
            Assert.Equal("DirectRouteProviderController.Get239303030()", GetContentValue<string>(response));
        }

        private static async Task<HttpResponseMessage> SubmitRequestAsync(HttpRequestMessage request, IDirectRouteProvider routeProvider = null)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("DefaultApi", "api/{controller}");
            if (routeProvider == null)
            {
                config.MapHttpAttributeRoutes();
            }
            else
            {
                config.MapHttpAttributeRoutes(routeProvider);
            }

            HttpResponseMessage response;
            HttpServer server = new HttpServer(config);
            using (HttpMessageInvoker client = new HttpMessageInvoker(server))
            {
                response = await client.SendAsync(request, CancellationToken.None);
            }

            return response;
        }

        private static T GetContentValue<T>(HttpResponseMessage response)
        {
            T value;
            response.TryGetContentValue<T>(out value);
            return value;
        }

        private class DirectRouteProvider : DefaultDirectRouteProvider
        {
            private readonly IDictionary<Type, IEnumerable<IDirectRouteFactory>> _controllerRouteFactories;
            private readonly IDictionary<string, IEnumerable<IDirectRouteFactory>> _actionRouteFactories;

            public DirectRouteProvider(
                IDictionary<Type, IEnumerable<IDirectRouteFactory>> controllerRouteFactories,
                IDictionary<string, IEnumerable<IDirectRouteFactory>> actionRouteFactories)
            {
                _controllerRouteFactories = controllerRouteFactories ?? new Dictionary<Type, IEnumerable<IDirectRouteFactory>>();
                _actionRouteFactories = actionRouteFactories ?? new Dictionary<string, IEnumerable<IDirectRouteFactory>>();
            }

            protected override IReadOnlyList<IDirectRouteFactory> GetControllerRouteFactories(HttpControllerDescriptor controllerDescriptor)
            {
                IEnumerable<IDirectRouteFactory> factories;
                _controllerRouteFactories.TryGetValue(controllerDescriptor.ControllerType, out factories);
                return factories == null ? null : factories.ToList();
            }

            protected override IReadOnlyList<IDirectRouteFactory> GetActionRouteFactories(HttpActionDescriptor actionDescriptor)
            {
                IEnumerable<IDirectRouteFactory> factories;
                _actionRouteFactories.TryGetValue(actionDescriptor.ActionName, out factories);
                return factories == null ? null : factories.ToList();
            }
        }
    }

    public class DirectRouteProviderController : ApiController
    {
        public string Get239303030()
        {
            return "DirectRouteProviderController.Get239303030()";
        }
    }

    public class AttributedController : ApiController
    {
        [Route("controller/{id:int}")]
        public string Get(int id)
        {
            return "Get" + id;
        }

        [Route("controller/{name}")]
        public string GetByName(string name)
        {
            return "GetByName" + name;
        }

        [Route("controller/{id}")]
        public string Put(string id)
        {
            return "Put" + id;
        }

        [Route("controller/{id}")]
        public string Put(string id, string name)
        {
            return "Put" + id + name;
        }

        // Optional route parameters still require a default value in the signature.
        [HttpGet]
        [Route("optional/{opt1?}/{opt2?}")]
        public string Optional(int opt1 = 8, string opt2 = "opt")
        {
            return "Optional" + opt1 + opt2;
        }

        [HttpGet]
        [Route("optionalwnullable/{opt1?}")]
        public string Optional(int? opt1 = null)
        {
            return "Optional" + opt1;
        }

        [HttpGet]
        [Route("optionalwconstraint/{opt:int?}")]
        public string OptionalWithConstraint(string opt = "x")
        {
            return "OptionalWithConstraint" + opt;
        }

        [HttpGet]
        [Route("default/{default1=D1}/{default2=D2}")]
        public string Default(string default1, string default2)
        {
            return "Default" + default1 + default2;
        }

        [HttpGet]
        [Route("wildcard/{*wildcard}")]
        public string Wildcard(string wildcard)
        {
            return "Wildcard" + wildcard;
        }

        [HttpGet]
        [HttpPut]
        [Route("multiverb")]
        public string MultiVerbs()
        {
            return Request.Method.ToString();
        }

        [HttpDelete] // Pick a unique verb
        [Route("multi1")]
        [Route("multi2")]
        public string MultiRoute()
        {
            return "multi";
        }

    }

    // Routes have optional parameters, but signature says it's required.
    // Try with value-type, reference type, and nullable.
    public class OptionalParameterController : ApiController
    {
        // Optional in route, required in signature.
        [Route("apibadcontrollerx/int/{id?}")]
        public string Get(int id)
        {
            return "GetInt" + id;
        }

        [Route("apibadcontrollerx/nullableint/{id?}")]
        public string GetNullable(int? id)
        {
            return "GetNullable" + id;
        }

        [Route("apibadcontrollerx/string/{id?}")]
        public string GetString(string id)
        {
            return "GetString" + id;
        }
    }

    [RoutePrefix("prefix")]
    public class PrefixedController : ApiController
    {
        // Should not be reachable be our routes since there's no route attribute.
        public void Post()
        {
        }

        [Route("")]
        public string Get()
        {
            return "PrefixedGet";
        }

        [Route] // same behavior as Route("")
        public string Put()
        {
            return "PrefixedPut";
        }

        [HttpGet]
        [Route("{id}")]
        public string GetById(int id)
        {
            return "PrefixedGetById" + id;
        }
    }

    [RoutePrefix("prefix2")]
    [Route("defaultroute/{id:int}")]
    public class DefaultRouteController : ApiController
    {
        // This gets default route
        public string Get(int id)
        {
            return "get" + id;
        }

        [Route]
        public string Post()
        {
            return "post";
        }

        [Route("defaultrouteoverride/{id}")]
        public string Put(int id)
        {
            return "put" + id;
        }
    }

    [Route("api/default2/{action}")]
    public class RpcController : ApiController
    {
        public string GetAllCustomers1()
        {
            return "GetAllCustomers1";
        }

        public string GetAllCustomers2()
        {
            return "GetAllCustomers2";
        }

        // Have a REST api on a RPC controller. Has unique URL
        [Route("api/resource/{id}")]
        public string GetById(string id)
        {
            return id;
        }
    }

    [RoutePrefix("apioptional")]
    [Route("{id?}")]
    public class OptionalController : ApiController
    {
        public string GetAllCustomers()
        {
            return "GetAllCustomers";
        }

        public string GetCustomer(int id)
        {
            return "GetCustomer:" + id;
        }
    }

    [Route("partial/{action}")]
    public class PartlyResourcePartlyRpcController : ApiController
    {
        // Normal RPC methods
        [HttpGet]
        public string DoOp1()
        {
            return "op1";
        }

        // Some non-RPC methods.  Has overlapping URL
        [Route("partial/{id:int}")]
        public string GetById(int id)
        {
            return id.ToString();
        }
    }

    [RoutePrefix("apioverload")]
    public class OverloadController : ApiController
    {
        [Route("{name}")]
        public string GetAge(string name, int age)
        {
            return "GetAge:" + name + age;
        }

        [Route("{id}")]
        public string GetScore(string id, int score)
        {
            return "GetScore:" + id + score;
        }
    }

    [RoutePrefix("apitokens")]
    public class TokensController : ApiController
    {
        [Route("{id:int}")]
        public string GetById(int id)
        {
            return "id" + id;
        }

        [Route("{name}")]
        public string GetByName(string name)
        {
            return "name" + name;
        }

        [Route("{id:int}")]
        public string GetDetails(int id, string name)
        {
            return "id" + id + "name" + name;
        }
    }

    // Stress test for action selection. This stresses that the union route really keeps the various
    // sub routes separate and properly elevates the correct one.
    // Uses query string parameters to disambiguate.
    [RoutePrefix("apiactionstress")]
    [Route("{x}/{action}")]
    [Route("{action}/{y}")]
    public class ActionStressController : ApiController
    {
        [HttpGet]
        public string ActionX(string x, int useX)
        {
            return "X" + x + useX;
        }

        [HttpGet]
        public string ActionY(string y, int useY)
        {
            return "Y" + y + useY;
        }
    }

    [Route("baseclass", Name = "Base")]
    public class BaseClassController : ApiController
    {
        public string Get(int id)
        {
            return "Get:" + id;
        }
    }

    [Route("subclass", Name = "Sub")]
    public class SubClassController : BaseClassController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    public class SubClassNoRouteController : BaseClassController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    [RoutePrefix("baseclassprefix")]
    public class BaseClassPrefixController : ApiController
    {
        [Route]
        public string GetAll()
        {
            return "Get";
        }

        [Route("base/{id}", Name = "GetById")]
        public string GetById(int id)
        {
            return "Get:" + id;
        }
    }

    public class SubClassNoPrefixController : BaseClassPrefixController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    [RoutePrefix("subclassprefix")]
    public class SubClassPrefixController : BaseClassPrefixController
    {
        [Route]
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    [Route("subclassroute")]
    public class SubClassRouteController : BaseClassPrefixController
    {
        public string Post(string name)
        {
            return "Post:" + name;
        }
    }

    public class RouteOrderController : ApiController
    {
        [Route("routeorder/{id:int}", Order = 1)]
        public string GetById(int id)
        {
            return "GetById:" + id;
        }

        [Route("routeorder/{name}", Order = 2)]
        public string GetByName(string name)
        {
            return "GetByName:" + name;
        }

        [Route("routeorder/literal", Order = 0)]
        public string GetLiteral()
        {
            return "GetLiteral";
        }
    }

    public class RouteOrderOverloadController : ApiController
    {
        [Route("routeorderoverload", Order = 1)]
        public string GetByNameAndId(string name, int id)
        {
            return "GetByNameAndId:" + name + id;
        }

        [Route("routeorderoverload", Order = 2)]
        public string GetByName(string name)
        {
            return "GetByName:" + name;
        }

        [Route("routeorderoverload", Order = 3)]
        public string Get()
        {
            return "Get";
        }
    }

    public class RoutePrecedenceController : ApiController
    {
        [Route("routeprecedence/{id:int}")]
        public string GetById(int id)
        {
            return "GetById:" + id;
        }

        [Route("routeprecedence/{name}")]
        public string GetByName(string name)
        {
            return "GetByName:" + name;
        }

        [Route("routeprecedence/{name}")]
        public string GetByNameAndId(string name, int id)
        {
            return "GetByNameAndId:" + name + id;
        }

        [Route("routeprecedence/literal")]
        public string GetLiteral()
        {
            return "GetLiteral";
        }
    }

    [RoutePrefix("constraint")]
    public class ConstraintController : ApiController
    {
        [ConstrainedRoute(Order = 1, ConstraintMatches = true)]
        public string GetHigherOrderWithMatchingContsraint()
        {
            return "pass";
        }

        [ConstrainedRoute(Order = 0, ConstraintMatches = false)]
        public string GetLowerOrderWithNonMatchingConstraint()
        {
            return "fail";
        }

        private class ConstrainedRouteAttribute : RouteFactoryAttribute
        {
            public ConstrainedRouteAttribute()
                : base(null)
            {
            }

            public bool ConstraintMatches { get; set; }

            public override IDictionary<string, object> Constraints
            {
                get
                {
                    return new HttpRouteValueDictionary()
                    {
                        { String.Empty, new Constraint(ConstraintMatches) }
                    };
                }
            }

            private class Constraint : IHttpRouteConstraint
            {
                private readonly bool _matches;

                public Constraint(bool matches)
                {
                    _matches = matches;
                }

                public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName,
                    IDictionary<string, object> values, HttpRouteDirection routeDirection)
                {
                    return _matches;
                }
            }
        }
    }

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
    public class CustomizedRoutePrefixAttribute : Attribute, IRoutePrefix
    {
        public CustomizedRoutePrefixAttribute(Type controller)
        {
            if (controller == null)
            {
                throw Error.ArgumentNull("prefix");
            }

            if (controller.Equals(typeof(HomeWithCustomizedRoutePrefixController)))
            {
                Prefix = "NS1Home";
            }
            else if (controller.Equals(typeof(AccountWithCustomizedRoutePrefixController)))
            {
                Prefix = "NS2Account";
            }
            else
            {
                Prefix = "CustomizedDefaultPrefix";
            }
        }

        public string Prefix { get; private set; }
    }

    [CustomizedRoutePrefix(typeof(HomeWithCustomizedRoutePrefixController))]
    public class HomeWithCustomizedRoutePrefixController : ApiController
    {
        [Route("Introduction")]
        public string Get()
        {
            return "Home.Index()";
        }
    }

    [CustomizedRoutePrefix(typeof(AccountWithCustomizedRoutePrefixController))]
    public class AccountWithCustomizedRoutePrefixController : ApiController
    {
        [Route("PeopleList")]
        public string Get()
        {
            return "Account.Index()";
        }
    }

    [CustomizedRoutePrefix(typeof(OtherWithCustomizedRoutePrefixController))]
    public class OtherWithCustomizedRoutePrefixController : ApiController
    {
        [Route("Unknown")]
        public String Get()
        {
            return "Default.Index()";
    }
    }

    [Route("ambiguousmatch")]
    public class AmbiguousMatch1Controller : ApiController
    {
        public string Get()
        {
            return "Get()";
        }
    }

    [Route("ambiguousmatch")]
    public class AmbiguousMatch2Controller : ApiController
    {
        public string Get()
        {
            return "Get()";
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/DefaultDirectRouteProviderTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Internal;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Routing
{
    public class DefaultDirectRouteProviderTests
    {
        [Fact]
        public void GetActionDirectRoutes_IfDirectRouteProviderReturnsNull_Throws()
        {
            // Arrange
            var factories = new[] { CreateStubRouteFactory(null) };
            var action = CreateStubActionDescriptor("IgnoreAction");
            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => provider.GetActionDirectRoutes(action, factories, constraintResolver),
                "IDirectRouteFactory.CreateRoute must not return null.");
        }

        [Fact]
        public void GetControllerDirectRoutes_IfDirectRouteProviderReturnsNull_Throws()
        {
            // Arrange
            var factories = new[] { CreateStubRouteFactory(null) };
            var action = CreateStubActionDescriptor("IgnoreAction");
            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => provider.GetControllerDirectRoutes(action.ControllerDescriptor, new[] { action }, factories, constraintResolver),
                "IDirectRouteFactory.CreateRoute must not return null.");
        }

        [Fact]
        public void GetActionDirectRoutes_IfDirectRouteProviderReturnsRouteWithoutActionDescriptors_Throws()
        {
            // Arrange
            IHttpRoute route = new Mock<IHttpRoute>().Object;
            RouteEntry entry = new RouteEntry(name: null, route: route);
            var factories = new[] { CreateStubRouteFactory(entry) };

            var action = CreateStubActionDescriptor("IgnoreAction");
            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            string expectedMessage = "The route does not have any associated action descriptors. Routing requires " +
                "that each direct route map to a non-empty set of actions.";
            Assert.Throws<InvalidOperationException>(
                () => provider.GetActionDirectRoutes(action, factories, constraintResolver),
                expectedMessage);
        }

        [Fact]
        public void GetControllerDirectRoutes_IfDirectRouteProviderReturnsRouteWithoutActionDescriptors_Throws()
        {
            // Arrange
            IHttpRoute route = new Mock<IHttpRoute>().Object;
            RouteEntry entry = new RouteEntry(name: null, route: route);
            var factories = new[] { CreateStubRouteFactory(entry) };

            var action = CreateStubActionDescriptor("IgnoreAction");
            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            string expectedMessage = "The route does not have any associated action descriptors. Routing requires " +
                "that each direct route map to a non-empty set of actions.";
            Assert.Throws<InvalidOperationException>(
                () => provider.GetControllerDirectRoutes(action.ControllerDescriptor, new[] { action }, factories, constraintResolver),
                expectedMessage);
        }

        [Fact]
        public void GetActionDirectRoutes_IfDirectRouteProviderReturnsRouteWithEmptyActionDescriptors_Throws()
        {
            // Arrange
            HttpRouteValueDictionary dataTokens = new HttpRouteValueDictionary
            {
                { RouteDataTokenKeys.Actions, new HttpActionDescriptor[0] }
            };
            HttpRoute route = new HttpRoute(null, null, null, dataTokens);
            RouteEntry entry = new RouteEntry(name: null, route: route);
            var factories = new[] { CreateStubRouteFactory(entry) };

            var action = CreateStubActionDescriptor("IgnoreAction");
            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            string expectedMessage = "The route does not have any associated action descriptors. Routing requires " +
                "that each direct route map to a non-empty set of actions.";
            Assert.Throws<InvalidOperationException>(
                () => provider.GetActionDirectRoutes(action, factories, constraintResolver),
                expectedMessage);
        }

        [Fact]
        public void GetControllerDirectRoute_IfDirectRouteProviderReturnsRouteWithEmptyActionDescriptors_Throws()
        {
            // Arrange
            HttpRouteValueDictionary dataTokens = new HttpRouteValueDictionary
            {
                { RouteDataTokenKeys.Actions, new HttpActionDescriptor[0] }
            };
            HttpRoute route = new HttpRoute(null, null, null, dataTokens);
            RouteEntry entry = new RouteEntry(name: null, route: route);
            var factories = new[] { CreateStubRouteFactory(entry) };

            var action = CreateStubActionDescriptor("IgnoreAction");
            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            string expectedMessage = "The route does not have any associated action descriptors. Routing requires " +
                "that each direct route map to a non-empty set of actions.";
            Assert.Throws<InvalidOperationException>(
                () => provider.GetControllerDirectRoutes(action.ControllerDescriptor, new[] { action }, factories, constraintResolver),
                expectedMessage);
        }

        [Fact]
        public void GetActionDirectRoutes_IfDirectRouteProviderReturnsRouteWithHandler_Throws()
        {
            // Arrange
            var action = CreateStubActionDescriptor("IgnoreAction");

            HttpRouteValueDictionary dataTokens = new HttpRouteValueDictionary
            {
                { RouteDataTokenKeys.Actions, new HttpActionDescriptor[] { action } }
            };
            HttpMessageHandler handler = new Mock<HttpMessageHandler>(MockBehavior.Strict).Object;
            HttpRoute route = new HttpRoute(null, null, null, dataTokens, handler);
            RouteEntry entry = new RouteEntry(name: null, route: route);
            var factories = new[] { CreateStubRouteFactory(entry) };

            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            string expectedMessage = "Direct routing does not support per-route message handlers.";
            Assert.Throws<InvalidOperationException>(
                () => provider.GetActionDirectRoutes(action, factories, constraintResolver), 
                expectedMessage);
        }

        [Fact]
        public void GetControllerDirectRoutes_IfDirectRouteProviderReturnsRouteWithHandler_Throws()
        {
            // Arrange
            var action = CreateStubActionDescriptor("IgnoreAction");

            HttpRouteValueDictionary dataTokens = new HttpRouteValueDictionary
            {
                { RouteDataTokenKeys.Actions, new HttpActionDescriptor[] { action } }
            };
            HttpMessageHandler handler = new Mock<HttpMessageHandler>(MockBehavior.Strict).Object;
            HttpRoute route = new HttpRoute(null, null, null, dataTokens, handler);
            RouteEntry entry = new RouteEntry(name: null, route: route);
            var factories = new[] { CreateStubRouteFactory(entry) };

            var constraintResolver = new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            string expectedMessage = "Direct routing does not support per-route message handlers.";
            Assert.Throws<InvalidOperationException>(
                () => provider.GetControllerDirectRoutes(action.ControllerDescriptor, new[] { action }, factories, constraintResolver),
                expectedMessage);
        }

        [Fact]
        public void GetRoutePrefix_WithMultiRoutePrefix_ThrowsInvalidOperationException()
        {
            // Arrange
            var httpControllerDescriptor = new MultiRoutePrefixControllerDescripter();
            var typeMock = new Mock<Type>();
            typeMock.SetupGet(t => t.FullName).Returns("Namespace.TypeFullName");
            httpControllerDescriptor.ControllerType = typeMock.Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => provider.GetRoutePrefix(httpControllerDescriptor),
                "Only one route prefix attribute is supported. Remove extra attributes from the controller of type 'Namespace.TypeFullName'.");
        }

        [Fact]
        public void GetRoutePrefix_WithNullPrefix_ThrowsInvalidOperationException()
        {
            // Arrange
            var httpControllerDescriptor = new NullRoutePrefixControllerDescripter();
            var typeMock = new Mock<Type>();
            typeMock.SetupGet(t => t.FullName).Returns("Namespace.TypeFullName");
            httpControllerDescriptor.ControllerType = typeMock.Object;

            var provider = new AccessibleDirectRouteProvider();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => provider.GetRoutePrefix(httpControllerDescriptor),
                "The property 'prefix' from route prefix attribute on controller of type 'Namespace.TypeFullName' cannot be null.");
        }

        private static HttpActionDescriptor CreateStubActionDescriptor(string actionName)
        {
            Mock<HttpActionDescriptor> mock = new Mock<HttpActionDescriptor>(MockBehavior.Strict, new Mock<HttpControllerDescriptor>().Object);
            mock.SetupGet(d => d.ActionName).Returns(actionName);
            return mock.Object;
        }

        private static IDirectRouteFactory CreateStubRouteFactory(RouteEntry entry)
        {
            Mock<IDirectRouteFactory> mock = new Mock<IDirectRouteFactory>(MockBehavior.Strict);
            mock.Setup(p => p.CreateRoute(It.IsAny<DirectRouteFactoryContext>())).Returns(entry);
            return mock.Object;
        }

        private class MultiRoutePrefixControllerDescripter : HttpControllerDescriptor
        {
            public override Collection<T> GetCustomAttributes<T>(bool inherit)
            {
                object[] attributes = new object[] { new ExtendedRoutePrefixAttribute(), new RoutePrefixAttribute("Prefix") };
                return new Collection<T>(TypeHelper.OfType<T>(attributes));
            }
        }

        private class NullRoutePrefixControllerDescripter : HttpControllerDescriptor
        {
            public override Collection<T> GetCustomAttributes<T>(bool inherit)
            {
                object[] attributes = new object[] { new ExtendedRoutePrefixAttribute() };
                return new Collection<T>(TypeHelper.OfType<T>(attributes));
            }
        }

        private class ExtendedRoutePrefixAttribute : RoutePrefixAttribute
        {
        }

        private class AccessibleDirectRouteProvider : DefaultDirectRouteProvider
        {
            public new IReadOnlyCollection<IDirectRouteFactory> GetActionRouteFactories(HttpActionDescriptor actionDescriptor)
            {
                return base.GetActionRouteFactories(actionDescriptor);
            }

            public new IReadOnlyList<RouteEntry> GetControllerDirectRoutes(
                HttpControllerDescriptor controllerDescriptor,
                IReadOnlyList<HttpActionDescriptor> actionDescriptors,
                IReadOnlyList<IDirectRouteFactory> factories,
                IInlineConstraintResolver constraintResolver)
            {
                return base.GetControllerDirectRoutes(controllerDescriptor, actionDescriptors, factories, constraintResolver);
            }

            public new IReadOnlyList<RouteEntry> GetActionDirectRoutes(
                HttpActionDescriptor actionDescriptor,
                IReadOnlyList<IDirectRouteFactory> factories,
                IInlineConstraintResolver constraintResolver)
            {
                return base.GetActionDirectRoutes(actionDescriptor, factories, constraintResolver);
            }

            public new IReadOnlyCollection<IDirectRouteFactory> GetControllerRouteFactories(HttpControllerDescriptor controllerDescriptor)
            {
                return base.GetControllerRouteFactories(controllerDescriptor);
            }

            public new string GetRoutePrefix(HttpControllerDescriptor controllerDescriptor)
            {
                return base.GetRoutePrefix(controllerDescriptor);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/DirectRouteProviderContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Routing
{
    public class DirectRouteProviderContextTests
    {
        [Fact]
        public void CreateBuilderWithoutResolverAndBuild_SetsActionsDataToken()
        {
            var actions = new HttpActionDescriptor[] { new ReflectedHttpActionDescriptor() };

            var route = BuildWithoutResolver("route", actions);

            var actualActions = route.DataTokens[RouteDataTokenKeys.Actions];
            Assert.Equal(actions, actualActions);
        }

        [Fact]
        public void CreateBuilderWithoutResolverAndBuild_AddsDefaultValuesAsOptional()
        {
            var actions = new ReflectedHttpActionDescriptor[] { new ReflectedHttpActionDescriptor() };
            var route = BuildWithoutResolver("movies/{id}", actions);
            route.Defaults.Add("id", RouteParameter.Optional);

            var routeData = route.GetRouteData("", new HttpRequestMessage(HttpMethod.Get, "http://localhost/movies"));

            Assert.Equal(RouteParameter.Optional, routeData.Values["id"]);
        }

        [Fact]
        public void CreateBuilderWithResolverAndBuild_Throws_WhenConstraintResolverReturnsNull()
        {
            Mock<IInlineConstraintResolver> constraintResolver = new Mock<IInlineConstraintResolver>();
            constraintResolver.Setup(r => r.ResolveConstraint("constraint")).Returns<IHttpRouteConstraint>(null);

            var ex = Assert.Throws<InvalidOperationException>(
                () => BuildWithResolver(@"hello/{param:constraint}", constraintResolver: constraintResolver.Object));
            Assert.Matches(
                "The inline constraint resolver of type 'IInlineConstraintResolverProxy' was unable to resolve the following inline constraint: 'constraint'.",
                ex.Message);
        }

        [Fact]
        public void CreateBuilderWithResolverAndBuild_ResolvesConstraintUsingConstraintResolver()
        {
            IHttpRouteConstraint routeConstraint = new Mock<IHttpRouteConstraint>().Object;
            Mock<IInlineConstraintResolver> constraintResolver = new Mock<IInlineConstraintResolver>();
            constraintResolver.Setup(r => r.ResolveConstraint("constraint")).Returns(routeConstraint);

            var route = BuildWithResolver(@"hello/{param:constraint}", constraintResolver: constraintResolver.Object);

            Assert.Equal("hello/{param}", route.RouteTemplate);
            Assert.Equal(routeConstraint, route.Constraints["param"]);
        }

        private static IHttpRoute BuildWithoutResolver(string template,
            IReadOnlyCollection<HttpActionDescriptor> actions)
        {
            DirectRouteFactoryContext context = new DirectRouteFactoryContext(null, actions,
                new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object, targetIsAction: true);
            IDirectRouteBuilder builder = context.CreateBuilder(template, constraintResolver: null);
            return builder.Build().Route;
        }

        private static IHttpRoute BuildWithResolver(string template, IInlineConstraintResolver constraintResolver)
        {
            HttpActionDescriptor[] actions = new HttpActionDescriptor[] { new ReflectedHttpActionDescriptor() };
            DirectRouteFactoryContext context = new DirectRouteFactoryContext(null, actions, constraintResolver, targetIsAction: true);

            // Act
            IDirectRouteBuilder builder = context.CreateBuilder(template);
            IHttpRoute route = builder.Build().Route;

            // Assertions for default, unspecified behavior:
            Assert.NotNull(route);
            Assert.Equal(actions, route.DataTokens["actions"]);

            return route;
        }

    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/HttpRouteTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http.Routing
{
    public class HttpRouteTest
    {
        [Theory]
        [InlineData("123 456")]
        [InlineData("123 {456")]
        [InlineData("123 [45]6")]
        [InlineData("123 (4)56")]
        [InlineData("abc+56")]
        [InlineData("abc.56")]
        [InlineData("abc*56")]
        [InlineData(@"hello12.1[)]*^$=!@23}")]
        public void GetRouteData_HandlesUrlEncoding(string id)
        {
            HttpRoute route = new HttpRoute("{controller}/{id}");
            Uri uri = new Uri("http://localhost/test/" + id + "/");
            IHttpRouteData routeData = route.GetRouteData("", new HttpRequestMessage(HttpMethod.Get, uri));
            Assert.Equal("test", routeData.Values["controller"]);
            Assert.Equal(id, routeData.Values["id"]);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/HttpRouteValueDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Http.Routing
{
    public class HttpRouteValueDictionaryTest
    {
        private static readonly Dictionary<string, object> data0 = null;
        private static readonly Dictionary<string, object> data1 = new Dictionary<string, object>();
        private static readonly Dictionary<string, object> data2 = new Dictionary<string, object> 
            {
                { "key1", "value1" },
                { "key2", 2 },
                { "key3", TimeSpan.FromDays(1) },
            };

        public static TheoryDataSet<Dictionary<string, object>, Dictionary<string, object>> DictionaryConstructorData
        {
            get
            {
                // Input, expected output
                return new TheoryDataSet<Dictionary<string, object>, Dictionary<string, object>>
                {
                    { null, data1 },
                    { data0, data1 },
                    { data1, data1 },
                    { data2, data2 },
                };
            }
        }

        public static TheoryDataSet<object, Dictionary<string, object>> ObjectConstructorData
        {
            get
            {
                // Input, expected output
                return new TheoryDataSet<object, Dictionary<string, object>>
                {
                    { null, data1 },
                    { data0, data1 },
                    { data1, data1 },
                    { new { }, data1},
                    { data2, data2 },
                    { new { key1 = "value1", key2 = 2, key3 = TimeSpan.FromDays(1) }, data2},
                };
            }
        }

        [Theory]
        [PropertyData("DictionaryConstructorData")]
        public void Constructor_AcceptsDictionaryValues(Dictionary<string, object> input, Dictionary<string, object> expectedOutput)
        {
            HttpRouteValueDictionary routeValues = new HttpRouteValueDictionary(input);
            Assert.True(expectedOutput.SequenceEqual(routeValues));
        }

        [Theory]
        [PropertyData("ObjectConstructorData")]
        public void Constructor_AcceptsObjectValues(object input, Dictionary<string, object> expectedOutput)
        {
            HttpRouteValueDictionary routeValues = new HttpRouteValueDictionary(input);
            Assert.True(expectedOutput.SequenceEqual(routeValues));
        }

        [Fact]
        public void Constructor_IsCaseInsensitive()
        {
            // Arrange
            HttpRouteValueDictionary routeValues = new HttpRouteValueDictionary();

            // Act
            routeValues.Add("KEY", null);

            // Assert
            Assert.True(routeValues.ContainsKey("key"));
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/LinkGenerationRouteTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Routing
{
    public class LinkGenerationRouteTests
    {
        [Fact]
        public void GenerateRoute_DoesNotClaimData()
        {
            LinkGenerationRoute route = new LinkGenerationRoute(new InnerRoute());

            IHttpRouteData data = route.GetRouteData(string.Empty, new HttpRequestMessage());

            Assert.Null(data);
        }

        [Fact]
        public void GenerateRoute_ForwardsInnerProperties()
        {
            IHttpRoute innerRoute = new InnerRoute();
            LinkGenerationRoute route = new LinkGenerationRoute(innerRoute);

            Assert.NotNull(route.Defaults);
            Assert.Equal(innerRoute.Defaults, route.Defaults);

            Assert.NotNull(route.Constraints);
            Assert.Equal(innerRoute.Constraints, route.Constraints);

            Assert.NotNull(route.DataTokens);
            Assert.Equal(innerRoute.DataTokens, route.DataTokens);

            Assert.NotNull(innerRoute.Handler);
            Assert.Null(route.Handler);

            Assert.NotNull(route.RouteTemplate);
            Assert.Equal(innerRoute.RouteTemplate, route.RouteTemplate);
        }

        [Fact]
        public void GenerateRoute_GetVirtualPathIsForwarded()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            IDictionary<string, object> values = new Dictionary<string, object>();

            IHttpVirtualPathData data = new Mock<IHttpVirtualPathData>().Object;

            Mock<IHttpRoute> inner = new Mock<IHttpRoute>();
            inner.Setup(r => r.GetVirtualPath(request, values)).Returns(data);

            LinkGenerationRoute route = new LinkGenerationRoute(inner.Object);

            IHttpVirtualPathData result = route.GetVirtualPath(request, values);

            Assert.Equal(data, result);
        }

        // Route where everything is not implemented. Tests that the generated route is not forwarding calls. 
        private class InnerRoute : IHttpRoute
        {
            private readonly IHttpRouteData _routeData = new Mock<IHttpRouteData>().Object;
            private readonly IHttpVirtualPathData _virtualPathData = new Mock<IHttpVirtualPathData>().Object;

            public InnerRoute()
            {
                Defaults = new Dictionary<string, object>();
                Defaults.Add("default", "value");

                Constraints = new Dictionary<string, object>();
                Constraints.Add("constraint", "value");

                DataTokens = new Dictionary<string, object>();
                DataTokens.Add("token", "value");

                Handler = new Mock<HttpMessageHandler>().Object;
            }

            public string RouteTemplate
            {
                get { return "InnerRoute"; }
            }

            public IDictionary<string, object> Defaults { get; private set; }

            public IDictionary<string, object> Constraints { get; private set; }

            public IDictionary<string, object> DataTokens { get; private set; }

            public HttpMessageHandler Handler { get; private set; }

            public IHttpRouteData GetRouteData(string virtualPathRoot, HttpRequestMessage request)
            {
                return _routeData;
            }

            public IHttpVirtualPathData GetVirtualPath(HttpRequestMessage request, Collections.Generic.IDictionary<string, object> values)
            {
                return _virtualPathData;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/MediaTypeFormatterExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Formatting
{
    public class MediaTypeFormatterExtensionsTests
    {
        [Fact]
        public void AddUriPathExtensionMapping_MediaTypeHeaderValue_ThrowsWithNullThis()
        {
            MediaTypeFormatter formatter = null;
            Assert.ThrowsArgumentNull(() => formatter.AddUriPathExtensionMapping("xml", new MediaTypeHeaderValue("application/xml")), "formatter");
        }

        [Fact]
        public void AddUriPathExtensionMapping_MediaTypeHeaderValue_UpdatesMediaTypeMappingsCollection()
        {
            MediaTypeFormatter mockFormatter = new Mock<MediaTypeFormatter> { CallBase = true }.Object;

            mockFormatter.AddUriPathExtensionMapping("ext", new MediaTypeHeaderValue("application/test"));

            MediaTypeMapping mediaTypeMapping = Assert.Single(mockFormatter.MediaTypeMappings);
            UriPathExtensionMapping uriPathExtensionMapping = Assert.IsType<UriPathExtensionMapping>(mediaTypeMapping);
            Assert.Equal("ext", uriPathExtensionMapping.UriPathExtension);
            Assert.Equal("application/test", uriPathExtensionMapping.MediaType.MediaType);
        }

        [Fact]
        public void AddUriPathExtensionMapping_MediaType_ThrowsWithNullThis()
        {
            MediaTypeFormatter formatter = null;
            Assert.ThrowsArgumentNull(() => formatter.AddUriPathExtensionMapping("xml", "application/xml"), "formatter");
        }

        [Fact]
        public void AddUriPathExtensionMapping_MediaType_UpdatesMediaTypeMappingsCollection()
        {
            MediaTypeFormatter mockFormatter = new Mock<MediaTypeFormatter> { CallBase = true }.Object;

            mockFormatter.AddUriPathExtensionMapping("ext", "application/test");

            MediaTypeMapping mediaTypeMapping = Assert.Single(mockFormatter.MediaTypeMappings);
            UriPathExtensionMapping uriPathExtensionMapping = Assert.IsType<UriPathExtensionMapping>(mediaTypeMapping);
            Assert.Equal("ext", uriPathExtensionMapping.UriPathExtension);
            Assert.Equal("application/test", uriPathExtensionMapping.MediaType.MediaType);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/RouteAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class RouteAttributeTest
    {
        [Fact]
        public void DefaultCtor_IsEmptyString()
        {
            RouteAttribute attribute = new RouteAttribute();

            Assert.Equal(String.Empty, attribute.Template);
        }
        
        [Fact]
        public void Ctor_NotNull()
        {
            Assert.ThrowsArgumentNull(() => new RouteAttribute(null), "template");
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/UriPathExtensionMappingTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting.DataSets;
using System.Net.Http.Headers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Net.Http.Formatting
{
    public class UriPathExtensionMappingTests
    {
        [Fact]
        public void TypeIsCorrect()
        {
            Assert.Type.HasProperties(
                typeof(UriPathExtensionMapping),
                TypeAssert.TypeProperties.IsPublicVisibleClass,
                typeof(MediaTypeMapping));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void ConstructorMediaType_Initialises_MediaTypeAndUriPathExtension(string uriPathExtension, string mediaType)
        {
            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
            Assert.Equal(uriPathExtension, mapping.UriPathExtension);
            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "Failed to set MediaType.");
        }

        [Theory]
        [TestDataSet(
            typeof(CommonUnitTestDataSets), "EmptyStrings",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void ConstructorMediaType_ThrowsWithEmptyUriPathExtension(string uriPathExtension, string mediaType)
        {
            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, mediaType), "uriPathExtension");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions",
            typeof(CommonUnitTestDataSets), "EmptyStrings")]
        public void ConstructorMediaType_ThrowsWithEmptyMediaType(string uriPathExtension, string mediaType)
        {
            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, mediaType), "mediaType");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions",
            typeof(HttpTestData), "LegalMediaTypeHeaderValues")]
        public void ConstructorMediaTypeHeaderValue_Initialises_MediaTypeAndUriPathExtension(string uriPathExtension, MediaTypeHeaderValue mediaType)
        {
            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
            Assert.Equal(uriPathExtension, mapping.UriPathExtension);
            Assert.MediaType.AreEqual(mediaType, mapping.MediaType, "Failed to set MediaType.");
        }

        [Theory]
        [TestDataSet(
            typeof(CommonUnitTestDataSets), "EmptyStrings",
            typeof(HttpTestData), "LegalMediaTypeHeaderValues")]
        public void ConstructorMediaTypeHeaderValue_ThrowsWithEmptyUriPathExtension(string uriPathExtension, MediaTypeHeaderValue mediaType)
        {
            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, mediaType), "uriPathExtension");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions")]
        public void ConstructorMediaTypeHeaderValue_ThrowsWithEmptyMediaType(string uriPathExtension)
        {
            Assert.ThrowsArgumentNull(() => new UriPathExtensionMapping(uriPathExtension, (MediaTypeHeaderValue)null), "mediaType");
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions",
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(HttpTestData), "UriTestDataStrings")]
        public void TryMatchMediaType_Returns_MatchWithExtensionInRouteData(string uriPathExtension, string mediaType, string baseUriString)
        {
            GC.KeepAlive(baseUriString); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
            HttpRequestMessage request = GetRequestWithExtInRouteData(uriPathExtension);
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions",
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(HttpTestData), "UriTestDataStrings")]
        public void TryMatchMediaType_Returns_MatchWithExtensionInRouteData_DifferCase(string uriPathExtension, string mediaType, string baseUriString)
        {
            GC.KeepAlive(baseUriString); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension.ToUpperInvariant(), mediaType);
            HttpRequestMessage request = GetRequestWithExtInRouteData(uriPathExtension.ToLowerInvariant());
            Assert.Equal(1.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions",
            typeof(HttpTestData), "LegalMediaTypeStrings",
            typeof(HttpTestData), "UriTestDataStrings")]
        public void TryMatchMediaType_Returns_ZeroWithExtensionNotInRouteData(string uriPathExtension, string mediaType, string baseUriString)
        {
            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
            Uri uri = new Uri(baseUriString);
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, uri);
            Assert.Equal(0.0, mapping.TryMatchMediaType(request));
        }

        [Theory]
        [TestDataSet(
            typeof(HttpTestData), "LegalUriPathExtensions",
            typeof(HttpTestData), "LegalMediaTypeStrings")]
        public void TryMatchMediaType_Throws_WithNullHttpRequestMessage(string uriPathExtension, string mediaType)
        {
            UriPathExtensionMapping mapping = new UriPathExtensionMapping(uriPathExtension, mediaType);
            Assert.ThrowsArgumentNull(() => mapping.TryMatchMediaType(request: null), "request");
        }

        private static HttpRequestMessage GetRequestWithExtInRouteData(string extensionValue)
        {
            IHttpRoute route = new Mock<IHttpRoute>().Object;
            IHttpRouteData routeData = new HttpRouteData(route);
            routeData.Values[UriPathExtensionMapping.UriPathExtensionKey] = extensionValue;

            HttpRequestMessage request = new HttpRequestMessage();
            request.SetRouteData(routeData);

            return request;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Routing/UrlHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using Microsoft.TestCommon;

namespace System.Web.Http.Routing
{
    public class UrlHelperTest
    {
        public static TheoryDataSet<string, int?, string> UrlGeneratorTestData
        {
            get
            {
                return new TheoryDataSet<string, int?, string>()
                {
                    { null, 456, "/somerootpath/people/456"}, // Just override ID, so ID is replaced
                    { "people", 456, "/somerootpath/people/456"}, // Just override ID, so ID is replaced
                    { null, null, "/somerootpath/people/123"}, // Override nothing, so everything the same
                    { "people", null, "/somerootpath/people/123"}, // Override nothing, so everything the same
                    { "customers", 456, "/somerootpath/customers/456"}, // Override everything, so everything changed
                    { "customers", null, null}, // Override controller, which clears out the ID, so it doesn't match (i.e. null)
                };
            }
        }

        public static TheoryDataSet<string> RequestUrlTestData
        {
            get
            {
                return new TheoryDataSet<string>
                {
                    "http://localhost",
                    "http://localhost/123",
                    "http://localhost/123?q=odata&$filter=123#123"
                };
            }
        }

        [Fact]
        public void EmptyCtor_MeantForUnitTesting_DoesntThrow()
        {
            Assert.DoesNotThrow(() => new UrlHelper());
        }

        [Fact]
        public void UrlHelper_CtorThrows_WithNullContext()
        {
            Assert.ThrowsArgumentNull(
                () => new UrlHelper(null),
                "request");
        }

        [Theory]
        [PropertyData("UrlGeneratorTestData")]
        public void UrlHelper_UsesCurrentRouteDataToPopulateValues_WithObjectValues(string controller, int? id, string expectedUrl)
        {
            var url = GetUrlHelperForApi();
            object routeValues = GetRouteValuesAsObject(controller, id);

            string generatedUrl = url.Route("route1", routeValues);

            Assert.Equal(expectedUrl, generatedUrl);
        }

        [Theory]
        [PropertyData("UrlGeneratorTestData")]
        public void UrlHelper_UsesCurrentRouteDataToPopulateValues_WithDictionaryValues(string controller, int? id, string expectedUrl)
        {
            var url = GetUrlHelperForApi();
            Dictionary<string, object> routeValues = GetRouteValuesAsDictionary(controller, id);

            string generatedUrl = url.Route("route1", routeValues);

            Assert.Equal(expectedUrl, generatedUrl);
        }

        [Fact]
        public void UrlHelper_Throws_WhenWrongNameUsed_WithObjectValues()
        {
            var url = GetUrlHelperForApi();
            Assert.ThrowsArgument(
                () => url.Route("route-doesn't-exist", null),
                "name",
                "A route named 'route-doesn't-exist' could not be found in the route collection.");
        }

        [Fact]
        public void UrlHelper_Throws_WhenWrongNameUsed_WithDictionaryValues()
        {
            var url = GetUrlHelperForApi();
            Assert.ThrowsArgument(
                () => url.Route("route-doesn't-exist", (IDictionary<string, object>)null),
                "name",
                "A route named 'route-doesn't-exist' could not be found in the route collection.");
        }

        [Theory]
        [TestDataSet(
            typeof(UrlHelperTest), "UrlGeneratorTestData",
            typeof(UrlHelperTest), "RequestUrlTestData")]
        public void UrlHelper_LinkGeneration_GeneratesRightLinksWithDictionary(string controller, int? id, string expectedUrl, string requestUrl)
        {
            var urlHelper = GetUrlHelperForApi();
            urlHelper.Request.RequestUri = new Uri(requestUrl);
            Dictionary<string, object> routeValues = GetRouteValuesAsDictionary(controller, id);
            string baseUrl = new Uri(requestUrl).GetLeftPart(UriPartial.Authority);

            string generatedlink = urlHelper.Link("route1", routeValues);

            Assert.Equal(expectedUrl != null ? baseUrl + expectedUrl : null, generatedlink);
        }

        [Theory]
        [TestDataSet(
            typeof(UrlHelperTest), "UrlGeneratorTestData",
            typeof(UrlHelperTest), "RequestUrlTestData")]
        public void UrlHelper_LinkGeneration_GeneratesRightLinksWithObject(string controller, int? id, string expectedUrl, string requestUrl)
        {
            var urlHelper = GetUrlHelperForApi();
            urlHelper.Request.Method = HttpMethod.Get;
            urlHelper.Request.RequestUri = new Uri(requestUrl);
            object routeValues = GetRouteValuesAsObject(controller, id);
            string baseUrl = new Uri(requestUrl).GetLeftPart(UriPartial.Authority);

            string generatedlink = urlHelper.Link("route1", routeValues);

            Assert.Equal(expectedUrl != null ? baseUrl + expectedUrl : null, generatedlink);
        }

        [Fact]
        public void UrlHelper_Content_NoOpsAbsoluteUrl()
        {
            // Arrange
            var request = new HttpRequestMessage();
            request.RequestUri = new Uri("http://contoso.com/api/Products");
            var urlHelper = new UrlHelper(request);

            // Act
            string link = urlHelper.Content("http://microsoft.com/webapi");

            // Assert
            Assert.Equal("http://microsoft.com/webapi", link);
        }

        [Fact]
        public void UrlHelper_Content_CombinesAbsolutePath()
        {
            // Arrange
            var request = new HttpRequestMessage();
            request.RequestUri = new Uri("http://contoso.com/api/Products");
            var urlHelper = new UrlHelper(request);

            // Act
            string link = urlHelper.Content("/store");

            // Assert
            Assert.Equal("http://contoso.com/store", link);
        }

        [Fact]
        public void UrlHelper_Content_CombinesVirtualPath()
        {
            // Arrange
            var request = new HttpRequestMessage();
            request.SetRequestContext(new HttpRequestContext
            {
                VirtualPathRoot = "/AppPath"
            });
            request.RequestUri = new Uri("http://contoso.com/AppPath/api/Products");
            var urlHelper = new UrlHelper(request);

            // Act
            string link = urlHelper.Content("~/store");

            // Assert
            Assert.Equal("http://contoso.com/AppPath/store", link);
        }

        [Fact]
        public void UrlHelper_Content_UsesVirtualPathFromConfiguration()
        {
            // Arrange
            var request = new HttpRequestMessage();
            request.SetConfiguration(new HttpConfiguration(new HttpRouteCollection("/AppPath")));
            request.RequestUri = new Uri("http://contoso.com/AppPath/api/Products");
            var urlHelper = new UrlHelper(request);

            // Act
            string link = urlHelper.Content("~/store");

            // Assert
            Assert.Equal("http://contoso.com/AppPath/store", link);
        }

        [Fact]
        public void UrlHelper_Content_DefaultsVirtualPathToSlash()
        {
            // Arrange
            var request = new HttpRequestMessage();
            request.SetRequestContext(new HttpRequestContext());
            request.RequestUri = new Uri("http://contoso.com/api/Products");
            var urlHelper = new UrlHelper(request);

            // Act
            string link = urlHelper.Content("~/store");

            // Assert
            Assert.Equal("http://contoso.com/store", link);
        }

        private static UrlHelper GetUrlHelperForApi()
        {
            HttpRequestMessage request = new HttpRequestMessage();

            // Set up routes
            var routes = new HttpRouteCollection("/somerootpath");
            IHttpRoute route = routes.MapHttpRoute("route1", "{controller}/{id}");
            request.Properties[HttpPropertyKeys.HttpConfigurationKey] = new HttpConfiguration(routes);
            request.Properties[HttpPropertyKeys.HttpRouteDataKey] = new HttpRouteData(route, new HttpRouteValueDictionary(new { controller = "people", id = "123" }));

            return new UrlHelper(request);
        }

        private static object GetRouteValuesAsObject(string controller, int? id)
        {
            object routeValues = null;
            if (controller == null)
            {
                if (id == null)
                {
                    routeValues = null;
                }
                else
                {
                    routeValues = new { id };
                }
            }
            else
            {
                if (id == null)
                {
                    routeValues = new { controller };
                }
                else
                {
                    routeValues = new { controller, id };
                }
            }

            return routeValues;
        }

        private static Dictionary<string, object> GetRouteValuesAsDictionary(string controller, int? id)
        {
            Dictionary<string, object> routeValues = new Dictionary<string, object>();
            if (controller == null)
            {
                if (id == null)
                {
                    routeValues = null;
                }
                else
                {
                    routeValues.Add("id", id);
                }
            }
            else
            {
                if (id == null)
                {
                    routeValues.Add("controller", controller);
                }
                else
                {
                    routeValues.Add("controller", controller);
                    routeValues.Add("id", id);
                }
            }

            return routeValues;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Services/ControllerServicesTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Services
{
    public class ControllerServicesTests
    {
        [Fact]
        public void Get_Falls_Through_To_Global()
        {
            HttpConfiguration config = new HttpConfiguration();
            ControllerServices cs = new ControllerServices(config.Services);

            // Act
            IActionValueBinder localVal = (IActionValueBinder) cs.GetService(typeof(IActionValueBinder));
            IActionValueBinder globalVal = (IActionValueBinder) config.Services.GetService(typeof(IActionValueBinder));
            
            // Assert
            // Local controller didn't override, should get same value as global case.
            Assert.Same(localVal, globalVal);
        }

        [Fact]
        public void Controller_Overrides_Global()
        {
            HttpConfiguration config = new HttpConfiguration();
            ControllerServices cs = new ControllerServices(config.Services);
                        
            IActionValueBinder newLocalService = new Mock<IActionValueBinder>().Object;
            cs.Replace(typeof(IActionValueBinder), newLocalService);

            // Act            
            IActionValueBinder localVal = (IActionValueBinder)cs.GetService(typeof(IActionValueBinder));
            IActionValueBinder globalVal = (IActionValueBinder)config.Services.GetService(typeof(IActionValueBinder));

            // Assert
            // Local controller didn't override, should get same value as global case.
            Assert.Same(localVal, newLocalService);
            Assert.NotSame(localVal, globalVal);
        }

        [Fact]
        public void Controller_Overrides_DependencyInjection()
        {
            // Setting on Controller config overrides the DI container. 
            HttpConfiguration config = new HttpConfiguration();

            IActionValueBinder newDIService = new Mock<IActionValueBinder>().Object;
            var mockDependencyResolver = new Mock<IDependencyResolver>();
            mockDependencyResolver.Setup(dr => dr.GetService(typeof(IActionValueBinder))).Returns(newDIService);
            config.DependencyResolver = mockDependencyResolver.Object;
            
            ControllerServices cs = new ControllerServices(config.Services);

            IActionValueBinder newLocalService = new Mock<IActionValueBinder>().Object;
            cs.Replace(typeof(IActionValueBinder), newLocalService);

            // Act            
            IActionValueBinder localVal = (IActionValueBinder)cs.GetService(typeof(IActionValueBinder));
            IActionValueBinder globalVal = (IActionValueBinder)config.Services.GetService(typeof(IActionValueBinder));

            // Assert
            // Local controller didn't override, should get same value as global case.            
            Assert.Same(newDIService, globalVal); // asking the config will give back the DI service
            Assert.Same(newLocalService, localVal); // but asking locally will get back the local service.
        }

        [Fact]
        public void Controller_Appends_Inherited_List()
        {
            // Controller Services has "copy on write" semantics for inherited list. 
            // It can get the inherited list and mutate it. 

            HttpConfiguration config = new HttpConfiguration();
            ServicesContainer global = config.Services;

            ControllerServices cs = new ControllerServices(config.Services);

            ValueProviderFactory vpf = new Mock<ValueProviderFactory>().Object;

            // Act
            cs.Add(typeof(ValueProviderFactory), vpf); // appends to end

            // Assert
            IEnumerable<object> original = global.GetServices(typeof(ValueProviderFactory));
            object[] modified = cs.GetServices(typeof(ValueProviderFactory)).ToArray();

            Assert.True(original.Count() > 1);
            object[] expected = original.Concat(new object[] { vpf }).ToArray();
            Assert.Equal(expected, modified);
        }

        [Fact]
        public void Controller_Clear_Single_Item()
        {
            HttpConfiguration config = new HttpConfiguration();
            ServicesContainer global = config.Services;

            ControllerServices cs = new ControllerServices(config.Services);
            IActionValueBinder newLocalService = new Mock<IActionValueBinder>().Object;
            cs.Replace(typeof(IActionValueBinder), newLocalService);

            // Act
            cs.Clear(typeof(IActionValueBinder));

            // Assert
            IActionValueBinder localVal = (IActionValueBinder)cs.GetService(typeof(IActionValueBinder));
            IActionValueBinder globalVal = (IActionValueBinder)config.Services.GetService(typeof(IActionValueBinder));

            Assert.Same(globalVal, localVal);
        }

        [Fact]
        public void Controller_Set_Null()
        {
            HttpConfiguration config = new HttpConfiguration();
            ServicesContainer global = config.Services;

            ControllerServices cs = new ControllerServices(config.Services);

            // Act
            // Setting to null is not the same as clear. Clear() means fall through to global config. 
            cs.Replace(typeof(IActionValueBinder), null);

            // Assert
            IActionValueBinder localVal = (IActionValueBinder)cs.GetService(typeof(IActionValueBinder));
            
            Assert.Null(localVal);
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/Services/DecoratorTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Services
{
    public class DecoratorTests
    {
        [Fact]
        public void GetInner_Returns_Inner_Object_From_ObjectWrapper()
        {
            // Arrange
            DummyAggregatedClass dummyInnerObject = new DummyAggregatedClass();
            DummyObjectWrapper dummyObjectWrapper = new DummyObjectWrapper(dummyInnerObject);
            IBaseInterface dummyBase = dummyObjectWrapper as IBaseInterface;

            // Act
            DummyAggregatedClass innerObject = Decorator.GetInner(dummyBase) as DummyAggregatedClass;

            // Assert
            Assert.Same(dummyInnerObject, innerObject);
        }

        [Fact]
        public void GetInner_Returns_InnerMost_Object_From_ObjectWrapper()
        {
            // Arrange
            DummyAggregatedClass dummyInnerObject = new DummyAggregatedClass();
            DummyObjectWrapper dummyObjectWrapper = new DummyObjectWrapper(dummyInnerObject);
            DummyDoubleLayerWrapper dummyDoubleLayerWrapper = new DummyDoubleLayerWrapper(dummyObjectWrapper);
            IBaseInterface dummyBase = dummyDoubleLayerWrapper as IBaseInterface;

            // Act
            DummyAggregatedClass innerObject = Decorator.GetInner(dummyBase) as DummyAggregatedClass;

            // Assert
            Assert.Same(dummyInnerObject, innerObject);
        }

        [Fact]
        public void GetInner_Call_On_InnerObject_Returns_InnerObject()
        {
            // Arrange
            DummyAggregatedClass dummyInnerObject = new DummyAggregatedClass();
            IBaseInterface dummyBase = dummyInnerObject as IBaseInterface;

            // Act
            DummyAggregatedClass innerObject = Decorator.GetInner(dummyBase) as DummyAggregatedClass;

            // Assert
            Assert.Same(dummyInnerObject, innerObject);
        }

        [Fact]
        public void GetInner_Call_On_Wrapper_Which_Does_Not_Contain_InnerObject_Returns_Wrapper()
        {
            // Arrange
            DummyWrapper dummyWrapper = new DummyWrapper();
            IBaseInterface dummyBase = dummyWrapper as IBaseInterface;

            // Act
            DummyWrapper innerObject = Decorator.GetInner(dummyBase) as DummyWrapper;

            // Assert
            Assert.Same(dummyWrapper, innerObject);
        }

        [Fact]
        public void GetInner_Returns_Itself_From_AnyClass_Which_Does_Not_Implement_Base_Interface()
        {
            // Arrange
            Mock<object> dummyClass = new Mock<object>();

            // Act
            object innerObject = Decorator.GetInner(dummyClass.Object);

            // Assert
            Assert.Same(dummyClass.Object, innerObject);
        }

        [Fact]
        public void GetInner_Returns_Null_When_Null_Is_Passed()
        {
            // Arrange
            object nullValue = null;

            // Act
            object innerObject = Decorator.GetInner(nullValue);

            // Assert
            Assert.Null(innerObject);
        }

        [Fact]
        public void GetInner_Returns_Inner_Object_From_ObjectWrapper_Which_Wraps_Itself()
        {
            // Arrange
            DummyAggregatedClass dummyInnerObject = new DummyAggregatedClass();
            DummyBaseWrapper dummyBaseWrapper = new DummyBaseWrapper(dummyInnerObject);
            IBaseInterface dummyBase = dummyBaseWrapper as IBaseInterface;

            // Act
            DummyBaseWrapper innerObject = Decorator.GetInner(dummyBase) as DummyBaseWrapper;

            // Assert
            Assert.Same(dummyBaseWrapper, innerObject);
        }

        private interface IBaseInterface { }

        private class DummyAggregatedClass : IBaseInterface { }

        private class DummyWrapper : IBaseInterface { }

        private class DummyObjectWrapper : IBaseInterface, IDecorator<DummyAggregatedClass>
        {
            private readonly DummyAggregatedClass _inner;

            public DummyObjectWrapper(DummyAggregatedClass innerObject)
            {
                _inner = innerObject;
            }

            public DummyAggregatedClass Inner
            {
                get { return _inner; }
            }
        }

        private class DummyDoubleLayerWrapper : IBaseInterface, IDecorator<DummyObjectWrapper>
        {
            private readonly DummyObjectWrapper _inner;

            public DummyDoubleLayerWrapper(DummyObjectWrapper innerObject)
            {
                _inner = innerObject;
            }

            public DummyObjectWrapper Inner
            {
                get { return _inner; }
            }
        }

        private class DummyBaseWrapper : IBaseInterface, IDecorator<IBaseInterface>
        {
            private readonly IBaseInterface _inner;

            public DummyBaseWrapper(IBaseInterface innerObject)
            {
                _inner = innerObject;
            }

            public IBaseInterface Inner
            {
                get { return this; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Services/DefaultServicesTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.Dependencies;
using System.Web.Http.Description;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Filters;
using System.Web.Http.Hosting;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Tracing;
using System.Web.Http.Validation;
using System.Web.Http.Validation.Providers;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Services
{
    public class DefaultServicesTests
    {
        // Constructor tests

        [Fact]
        public void Constructor_GuardClauses()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(() => new DefaultServices(configuration: null), "configuration");
        }

        [Fact]
        public void Constructor_DefaultServicesInContainer()
        {
            // Arrange
            var config = new HttpConfiguration();

            // Act
            var defaultServices = new DefaultServices(config);

            // Assert
            Assert.Null(defaultServices.GetService(typeof(IDocumentationProvider)));
            Assert.Null(defaultServices.GetService(typeof(ITraceWriter)));

            Assert.IsType<DefaultActionValueBinder>(defaultServices.GetService(typeof(IActionValueBinder)));
            Assert.IsType<ApiExplorer>(defaultServices.GetService(typeof(IApiExplorer)));
            Assert.IsType<DefaultAssembliesResolver>(defaultServices.GetService(typeof(IAssembliesResolver)));
            Assert.IsType<DefaultBodyModelValidator>(defaultServices.GetService(typeof(IBodyModelValidator)));
            Assert.IsType<DefaultContentNegotiator>(defaultServices.GetService(typeof(IContentNegotiator)));
            Assert.IsType<ApiControllerActionInvoker>(defaultServices.GetService(typeof(IHttpActionInvoker)));
            Assert.IsType<ApiControllerActionSelector>(defaultServices.GetService(typeof(IHttpActionSelector)));
            Assert.IsType<DefaultHttpControllerActivator>(defaultServices.GetService(typeof(IHttpControllerActivator)));
            Assert.IsType<DefaultHttpControllerSelector>(defaultServices.GetService(typeof(IHttpControllerSelector)));
            Assert.IsType<DefaultHttpControllerTypeResolver>(defaultServices.GetService(typeof(IHttpControllerTypeResolver)));
            Assert.IsType<TraceManager>(defaultServices.GetService(typeof(ITraceManager)));
            Assert.IsType<DataAnnotationsModelMetadataProvider>(defaultServices.GetService(typeof(ModelMetadataProvider)));
            Assert.IsType<ModelValidatorCache>(defaultServices.GetService(typeof(IModelValidatorCache)));
            Assert.IsType<DefaultExceptionHandler>(defaultServices.GetService(typeof(IExceptionHandler)));

            object[] filterProviders = defaultServices.GetServices(typeof(IFilterProvider)).ToArray();
            Assert.Equal(2, filterProviders.Length);
            Assert.IsType<ConfigurationFilterProvider>(filterProviders[0]);
            Assert.IsType<ActionDescriptorFilterProvider>(filterProviders[1]);

            object[] modelBinderProviders = defaultServices.GetServices(typeof(ModelBinderProvider)).ToArray();
            Assert.Equal(8, modelBinderProviders.Length);
            Assert.IsType<TypeConverterModelBinderProvider>(modelBinderProviders[0]);
            Assert.IsType<TypeMatchModelBinderProvider>(modelBinderProviders[1]);
            Assert.IsType<KeyValuePairModelBinderProvider>(modelBinderProviders[2]);
            Assert.IsType<ComplexModelDtoModelBinderProvider>(modelBinderProviders[3]);
            Assert.IsType<ArrayModelBinderProvider>(modelBinderProviders[4]);
            Assert.IsType<DictionaryModelBinderProvider>(modelBinderProviders[5]);
            Assert.IsType<CollectionModelBinderProvider>(modelBinderProviders[6]);
            Assert.IsType<MutableObjectModelBinderProvider>(modelBinderProviders[7]);

            object[] validatorProviders = defaultServices.GetServices(typeof(ModelValidatorProvider)).ToArray();
            Assert.Equal(2, validatorProviders.Length);
            Assert.IsType<DataAnnotationsModelValidatorProvider>(validatorProviders[0]);
            Assert.IsType<DataMemberModelValidatorProvider>(validatorProviders[1]);

            object[] valueProviderFactories = defaultServices.GetServices(typeof(ValueProviderFactory)).ToArray();
            Assert.Equal(2, valueProviderFactories.Length);
            Assert.IsType<QueryStringValueProviderFactory>(valueProviderFactories[0]);
            Assert.IsType<RouteDataValueProviderFactory>(valueProviderFactories[1]);

            object[] exceptionLoggers = defaultServices.GetServices(typeof(IExceptionLogger)).ToArray();
            Assert.Empty(exceptionLoggers);
        }

        // Add tests

        [Fact]
        public void Add_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.Add(serviceType: null, service: new object()), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.Add(typeof(object), service: null), "service");
            Assert.ThrowsArgument(
                () => defaultServices.Add(typeof(object), new object()),
                "serviceType",
                "The service type Object is not supported.");
            Assert.ThrowsArgument(
                () => defaultServices.Add(typeof(IHttpActionInvoker), new object()),
                "service",
                "The type Object must derive from IHttpActionInvoker.");
        }

        [Fact]
        public void Add_AddsServiceToEndOfServicesList()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider = new Mock<IFilterProvider>().Object;
            IEnumerable<object> servicesBefore = defaultServices.GetServices(typeof(IFilterProvider));

            // Act
            defaultServices.Add(typeof(IFilterProvider), filterProvider);

            // Assert
            IEnumerable<object> servicesAfter = defaultServices.GetServices(typeof(IFilterProvider));
            Assert.Equal(servicesBefore.Concat(new[] { filterProvider }), servicesAfter);
        }

        // AddRange tests

        [Fact]
        public void AddRange_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.AddRange(serviceType: null, services: new[] { new object() }), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.AddRange(typeof(object), services: null), "services");
            Assert.ThrowsArgument(
                () => defaultServices.AddRange(typeof(object), new[] { new object() }),
                "serviceType",
                "The service type Object is not supported.");
            Assert.ThrowsArgument(() => defaultServices.AddRange(typeof(ValueProviderFactory), new[] { new object() }),
                "services",
                "The type Object must derive from ValueProviderFactory.");
        }

        [Fact]
        public void AddRange_AddsServicesToEndOfServicesList()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider = new Mock<IFilterProvider>().Object;
            IEnumerable<object> servicesBefore = defaultServices.GetServices(typeof(IFilterProvider));

            // Act
            defaultServices.AddRange(typeof(IFilterProvider), new[] { filterProvider });

            // Assert
            IEnumerable<object> servicesAfter = defaultServices.GetServices(typeof(IFilterProvider));
            Assert.Equal(servicesBefore.Concat(new[] { filterProvider }), servicesAfter);
        }

        [Fact]
        public void AddRange_SkipsNullObjects()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            IEnumerable<object> servicesBefore = defaultServices.GetServices(typeof(IFilterProvider));

            // Act
            defaultServices.AddRange(typeof(IFilterProvider), new object[] { null });

            // Assert
            IEnumerable<object> servicesAfter = defaultServices.GetServices(typeof(IFilterProvider));
            Assert.Equal(servicesBefore, servicesAfter);
        }

        // Clear tests

        [Fact]
        public void Clear_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.Clear(serviceType: null), "serviceType");
            Assert.ThrowsArgument(
                () => defaultServices.Clear(typeof(object)),
                "serviceType",
                "The service type Object is not supported.");
        }

        [Fact]
        public void Clear_RemovesAllServices()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            Assert.NotEmpty(defaultServices.GetServices(typeof(IFilterProvider)));

            // Act
            defaultServices.Clear(typeof(IFilterProvider));

            // Assert
            Assert.Empty(defaultServices.GetServices(typeof(IFilterProvider)));
        }

        // FindIndex tests

        [Fact]
        public void FindIndex_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.FindIndex(serviceType: null, match: _ => true), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.FindIndex(typeof(object), match: null), "match");
            Assert.ThrowsArgument(
                () => defaultServices.FindIndex(typeof(object), _ => true),
                "serviceType",
                "The service type Object is not supported.");
        }

        [Fact]
        public void FindIndex_SuccessfulFind()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act
            int index = defaultServices.FindIndex(typeof(IFilterProvider), _ => true);

            // Assert
            Assert.Equal(0, index);
        }

        [Fact]
        public void FindIndex_FailedFind()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act
            int index = defaultServices.FindIndex(typeof(IFilterProvider), _ => false);

            // Assert
            Assert.Equal(-1, index);
        }

        [Fact]
        public void FindIndex_EmptyServiceListAlwaysReturnsFailure()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            defaultServices.Clear(typeof(IFilterProvider));

            // Act
            int index = defaultServices.FindIndex(typeof(IFilterProvider), _ => true);

            // Assert
            Assert.Equal(-1, index);
        }

        // GetService tests

        [Fact]
        public void GetService_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.GetService(serviceType: null), "serviceType");
            Assert.ThrowsArgument(
                () => defaultServices.GetService(typeof(object)),
                "serviceType",
                "The service type Object is not supported.");
        }

        [Fact]
        public void GetService_ReturnsNullWhenServiceListEmpty()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            defaultServices.Clear(typeof(IActionValueBinder));

            // Act
            object service = defaultServices.GetService(typeof(IActionValueBinder));

            // Assert
            Assert.Null(service);
        }

        [Fact]
        public void GetService_PrefersServiceInDependencyInjectionContainer()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider = new Mock<IActionValueBinder>().Object;
            var mockDependencyResolver = new Mock<IDependencyResolver>();
            mockDependencyResolver.Setup(dr => dr.GetService(typeof(IActionValueBinder))).Returns(filterProvider);
            config.DependencyResolver = mockDependencyResolver.Object;

            // Act
            object service = defaultServices.GetService(typeof(IActionValueBinder));

            // Assert
            Assert.Same(filterProvider, service);
        }

        [Fact]
        public void GetService_CachesResultFromDependencyInjectionContainer()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var mockDependencyResolver = new Mock<IDependencyResolver>();
            config.DependencyResolver = mockDependencyResolver.Object;

            // Act
            defaultServices.GetService(typeof(IActionValueBinder));
            defaultServices.GetService(typeof(IActionValueBinder));

            // Assert
            mockDependencyResolver.Verify(dr => dr.GetService(typeof(IActionValueBinder)), Times.Once());
        }

        // GetServicesTests

        [Fact]
        public void GetServices_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.GetServices(serviceType: null), "serviceType");
            Assert.ThrowsArgument(
                () => defaultServices.GetServices(typeof(object)),
                "serviceType",
                "The service type Object is not supported.");
        }

        [Fact]
        public void GetServices_ReturnsEmptyEnumerationWhenServiceListEmpty()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            defaultServices.Clear(typeof(IFilterProvider));

            // Act
            IEnumerable<object> services = defaultServices.GetServices(typeof(IFilterProvider));

            // Assert
            Assert.Empty(services);
        }

        [Fact]
        public void GetServices_PrependsServiceInDependencyInjectionContainer()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            IEnumerable<object> servicesBefore = defaultServices.GetServices(typeof(IFilterProvider));
            var filterProvider = new Mock<IFilterProvider>().Object;
            var mockDependencyResolver = new Mock<IDependencyResolver>();
            mockDependencyResolver.Setup(dr => dr.GetServices(typeof(IFilterProvider))).Returns(new[] { filterProvider });
            config.DependencyResolver = mockDependencyResolver.Object;

            // Act
            IEnumerable<object> servicesAfter = defaultServices.GetServices(typeof(IFilterProvider));

            // Assert
            Assert.Equal(new[] { filterProvider }.Concat(servicesBefore), servicesAfter);
        }

        [Fact]
        public void GetServices_CachesResultFromDependencyInjectionContainer()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var mockDependencyResolver = new Mock<IDependencyResolver>();
            config.DependencyResolver = mockDependencyResolver.Object;

            // Act
            defaultServices.GetServices(typeof(IFilterProvider));
            defaultServices.GetServices(typeof(IFilterProvider));

            // Assert
            mockDependencyResolver.Verify(dr => dr.GetServices(typeof(IFilterProvider)), Times.Once());
        }

        // Insert tests

        [Fact]
        public void Insert_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.Insert(serviceType: null, index: 0, service: new object()), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.Insert(typeof(object), 0, service: null), "service");
            Assert.ThrowsArgument(
                () => defaultServices.Insert(typeof(object), 0, new object()),
                "serviceType",
                "The service type Object is not supported.");
            Assert.ThrowsArgument(
                () => defaultServices.Insert(typeof(IHttpActionInvoker), 0, new object()),
                "service",
                "The type Object must derive from IHttpActionInvoker.");
            Assert.ThrowsArgumentOutOfRange(
                () => defaultServices.Insert(typeof(ValueProviderFactory), -1, new Mock<ValueProviderFactory>().Object),
                "index",
                "Index must be within the bounds of the List.");
        }

        [Fact]
        public void Insert_AddsElementAtTheRequestedLocation()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            var newFilterProvider = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.Insert(typeof(IFilterProvider), 1, newFilterProvider);

            // Assert
            Assert.Equal(new[] { filterProvider1, newFilterProvider, filterProvider2 }, defaultServices.GetServices(typeof(IFilterProvider)));
        }

        // InsertRange tests

        [Fact]
        public void InsertRange_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.InsertRange(serviceType: null, index: 0, services: new[] { new object() }), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.InsertRange(typeof(object), 0, services: null), "services");
            Assert.ThrowsArgument(
                () => defaultServices.InsertRange(typeof(object), 0, new[] { new object() }),
                "serviceType",
                "The service type Object is not supported.");
            Assert.ThrowsArgument(
                () => defaultServices.InsertRange(typeof(IHttpActionInvoker), 0, new[] { new object() }),
                "services",
                "The type Object must derive from IHttpActionInvoker.");
            Assert.ThrowsArgumentOutOfRange(
                () => defaultServices.InsertRange(typeof(ValueProviderFactory), -1, new[] { new Mock<ValueProviderFactory>().Object }),
                "index",
                "Index was out of range. Must be non-negative and less than the size of the collection.");
        }

        [Fact]
        public void InsertRange_AddsElementAtTheRequestedLocation()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            var newFilterProvider1 = new Mock<IFilterProvider>().Object;
            var newFilterProvider2 = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.InsertRange(typeof(IFilterProvider), 1, new[] { newFilterProvider1, newFilterProvider2 });

            // Assert
            Assert.Equal(new[] { filterProvider1, newFilterProvider1, newFilterProvider2, filterProvider2 }, defaultServices.GetServices(typeof(IFilterProvider)));
        }

        // Remove tests

        [Fact]
        public void Remove_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.Remove(serviceType: null, service: new object()), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.Remove(typeof(object), service: null), "service");
            Assert.ThrowsArgument(
                () => defaultServices.Remove(typeof(object), new object()),
                "serviceType",
                "The service type Object is not supported.");
        }

        [Fact]
        public void Remove_ObjectFound()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.Remove(typeof(IFilterProvider), filterProvider1);

            // Assert
            Assert.Equal(new[] { filterProvider2 }, defaultServices.GetServices(typeof(IFilterProvider)));
        }

        [Fact]
        public void Remove_ObjectNotFound()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            var notPresentFilterProvider = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.Remove(typeof(IFilterProvider), notPresentFilterProvider);

            // Assert
            Assert.Equal(new[] { filterProvider1, filterProvider2 }, defaultServices.GetServices(typeof(IFilterProvider)));
        }

        // RemoveAll tests

        [Fact]
        public void RemoveAll_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.RemoveAll(serviceType: null, match: _ => true), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.RemoveAll(typeof(object), match: null), "match");
            Assert.ThrowsArgument(
                () => defaultServices.RemoveAll(typeof(object), _ => true),
                "serviceType",
                "The service type Object is not supported.");
        }

        [Fact]
        public void RemoveAll_SuccessfulMatch()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.RemoveAll(typeof(IFilterProvider), _ => true);

            // Assert
            Assert.Empty(defaultServices.GetServices(typeof(IFilterProvider)));
        }

        [Fact]
        public void RemoveAll_PartialMatch()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.RemoveAll(typeof(IFilterProvider), obj => obj == filterProvider2);

            // Assert
            Assert.Equal(new[] { filterProvider1 }, defaultServices.GetServices(typeof(IFilterProvider)));
        }

        // RemoveAt tests

        [Fact]
        public void RemoveAt_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.RemoveAt(serviceType: null, index: 0), "serviceType");
            Assert.ThrowsArgument(
                () => defaultServices.RemoveAt(typeof(object), 0),
                "serviceType",
                "The service type Object is not supported.");
            Assert.ThrowsArgumentOutOfRange(
                () => defaultServices.RemoveAt(typeof(IFilterProvider), -1),
                "index",
                "Index was out of range. Must be non-negative and less than the size of the collection.");
        }

        [Fact]
        public void RemoteAt_RemovesService()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.RemoveAt(typeof(IFilterProvider), 1);

            // Assert
            Assert.Equal(new[] { filterProvider1 }, defaultServices.GetServices(typeof(IFilterProvider)));
        }

        // Replace tests
        [Fact]
        public void Replace_SetsNull()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            defaultServices.Replace(typeof(IActionValueBinder), service: null);
        }

        [Fact]
        public void Replace_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.Replace(serviceType: null, service: new object()), "serviceType");
            Assert.ThrowsArgument(
                () => defaultServices.Replace(typeof(object), new object()),
                "serviceType",
                "The service type Object is not supported.");
            Assert.ThrowsArgument(
                () => defaultServices.Replace(typeof(IHttpActionInvoker), new object()),
                "service",
                "The type Object must derive from IHttpActionInvoker.");
        }

        [Fact]
        public void Replace_ReplacesAllValuesWithTheGivenService()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;
            var newFilterProvider = new Mock<IFilterProvider>().Object;
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Act
            defaultServices.Replace(typeof(IFilterProvider), newFilterProvider);

            // Assert
            Assert.Equal(new[] { newFilterProvider }, defaultServices.GetServices(typeof(IFilterProvider)));
        }

        // ReplaceRange tests

        [Fact]
        public void ReplaceRange_GuardClauses()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);

            // Act & assert
            Assert.ThrowsArgumentNull(() => defaultServices.ReplaceRange(serviceType: null, services: new[] { new object() }), "serviceType");
            Assert.ThrowsArgumentNull(() => defaultServices.ReplaceRange(typeof(object), services: null), "services");
            Assert.ThrowsArgument(
                () => defaultServices.ReplaceRange(typeof(object), new[] { new object() }),
                "serviceType",
                "The service type Object is not supported.");
            Assert.ThrowsArgument(
                () => defaultServices.ReplaceRange(typeof(ValueProviderFactory), new[] { new object() }),
                "services",
                "The type Object must derive from ValueProviderFactory.");
        }

        [Fact]
        public void ReplaceRange_ReplacesAllValuesWithTheGivenServices()
        {
            // Arrange
            var config = new HttpConfiguration();
            var defaultServices = new DefaultServices(config);
            var filterProvider1 = new Mock<IFilterProvider>().Object;
            var filterProvider2 = new Mock<IFilterProvider>().Object;

            // Act
            defaultServices.ReplaceRange(typeof(IFilterProvider), new[] { filterProvider1, filterProvider2 });

            // Assert
            Assert.Equal(new[] { filterProvider1, filterProvider2 }, defaultServices.GetServices(typeof(IFilterProvider)));
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Services/ServicesExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Services
{
    public class ServicesExtensionsTests
    {
        [Fact]
        public void GetValueProviderFactories_Throws_WhenServicesIsNull()
        {
            // Arrange
            ServicesContainer services = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => ServicesExtensions.GetValueProviderFactories(services), "services");
        }

        [Fact]
        public void GetExceptionHandler_DelegatesToGetService()
        {
            // Arrange
            IExceptionHandler expectedExceptionHandler = new Mock<IExceptionHandler>(MockBehavior.Strict).Object;

            Mock<ServicesContainer> mock = new Mock<ServicesContainer>(MockBehavior.Strict);
            mock.Setup(s => s.GetService(typeof(IExceptionHandler))).Returns(expectedExceptionHandler);
            ServicesContainer services = mock.Object;

            // Act
            IExceptionHandler exceptionHandler = ServicesExtensions.GetExceptionHandler(services);

            // Assert
            mock.Verify(s => s.GetService(typeof(IExceptionHandler)), Times.Once());
            Assert.Same(expectedExceptionHandler, exceptionHandler);
        }

        [Fact]
        public void GetExceptionLoggers_DelegatesToGetServices()
        {
            // Arrange
            IExceptionLogger expectedExceptionLogger = new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
            IEnumerable<IExceptionLogger> expectedExceptionLoggers =
                new IExceptionLogger[] { expectedExceptionLogger };

            Mock<ServicesContainer> mock = new Mock<ServicesContainer>(MockBehavior.Strict);
            mock.Setup(s => s.GetServices(typeof(IExceptionLogger))).Returns(expectedExceptionLoggers);
            ServicesContainer services = mock.Object;

            // Act
            IEnumerable<IExceptionLogger> exceptionLoggers = ServicesExtensions.GetExceptionLoggers(services);

            // Assert
            mock.Verify(s => s.GetServices(typeof(IExceptionLogger)), Times.Once());
            Assert.NotNull(exceptionLoggers);
            IExceptionLogger exceptionLogger = Assert.Single(exceptionLoggers);
            Assert.Same(expectedExceptionLogger, exceptionLogger);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/System.Web.Http.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{7F2C796F-43B2-4F8F-ABFF-A154EC8AAFA1}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http</RootNamespace>
    <AssemblyName>System.Web.Http.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <DefineConstants>$(DefineConstants);ASPNETWEBAPI</DefineConstants>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Caching" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Web" />
    <Reference Include="System.XML" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\CollectionExtensionsTest.cs">
      <Link>Common\CollectionExtensionsTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\DictionaryExtensionsTest.cs">
      <Link>Common\DictionaryExtensionsTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\ErrorTest.cs">
      <Link>Common\ErrorTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\ListWrapperCollectionTests.cs">
      <Link>Common\ListWrapperCollectionTests.cs</Link>
    </Compile>
    <Compile Include="..\Common\PrefixContainerTest.cs">
      <Link>Common\PrefixContainerTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteFactoryAttributeTests.cs">
      <Link>Routing\RouteFactoryAttributeTests.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RoutePrecedenceTests.cs">
      <Link>Routing\RoutePrecedenceTests.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpersExtensionsTest.cs">
      <Link>Common\TaskHelpersExtensionsTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\TaskHelpersTest.cs">
      <Link>Common\TaskHelpersTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\TypeExtensionsTest.cs">
      <Link>Common\TypeExtensionsTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\UriQueryUtilityTest.cs">
      <Link>Common\UriQueryUtilityTest.cs</Link>
    </Compile>
    <Compile Include="AuthorizeAttributeTest.cs" />
    <Compile Include="Batch\BatchHttpRequestMessageExtensionsTest.cs" />
    <Compile Include="Batch\BatchHttpRequestContextTests.cs" />
    <Compile Include="Batch\BatchLearningTests.cs" />
    <Compile Include="Batch\HttpBatchHandlerTest.cs" />
    <Compile Include="Batch\DefaultHttpBatchHandlerTest.cs" />
    <Compile Include="Common\TraceWriterExceptionMapperTest.cs" />
    <Compile Include="Controllers\ActionFilterResultTests.cs" />
    <Compile Include="Controllers\ApiControllerTestabilityTest.cs" />
    <Compile Include="Controllers\Apis\User.cs" />
    <Compile Include="Controllers\Apis\UsersRpcController.cs" />
    <Compile Include="Controllers\AuthorizationFilterResultTests.cs" />
    <Compile Include="Controllers\AuthenticationFilterResultTests.cs" />
    <Compile Include="Controllers\ExceptionFilterResultTests.cs" />
    <Compile Include="Controllers\RequestBackedHttpRequestContextTests.cs" />
    <Compile Include="Controllers\FilterGroupingTests.cs" />
    <Compile Include="Controllers\HttpParameterBindingTest.cs" />
    <Compile Include="Controllers\ParameterBindingExtensionsTest.cs" />
    <Compile Include="Controllers\ResponseMessageResultConverterTest.cs" />
    <Compile Include="Controllers\ValueResultConverterTest.cs" />
    <Compile Include="Controllers\HttpActionDescriptorTest.cs" />
    <Compile Include="Controllers\HttpControllerContextTest.cs" />
    <Compile Include="Controllers\HttpConfigurationTest.cs" />
    <Compile Include="Controllers\VoidResultConverterTest.cs" />
    <Compile Include="Description\ApiExplorerTest.cs" />
    <Compile Include="Description\ApiParameterDescriptionTest.cs" />
    <Compile Include="ExceptionHandling\CompositeExceptionLoggerTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionContextCatchBlockTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionLoggerExtensionsTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionLoggerContextTests.cs" />
    <Compile Include="ExceptionHandling\DefaultExceptionHandlerTests.cs" />
    <Compile Include="ExceptionHandling\EmptyExceptionHandlerTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionCatchBlocksTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionContextTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionHandlerContextTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionHandlerExtensionsTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionHandlerTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionLoggerTests.cs" />
    <Compile Include="ExceptionHandling\ExceptionServicesTests.cs" />
    <Compile Include="ExceptionHandling\LastChanceExceptionHandlerTests.cs" />
    <Compile Include="Filters\HttpAuthenticationChallengeContextTests.cs" />
    <Compile Include="Filters\HttpAuthenticationContextTests.cs" />
    <Compile Include="Hosting\HttpMessageHandlerExtensions.cs" />
    <Compile Include="Hosting\SuppressHostPrincipalMessageHandlerTest.cs" />
    <Compile Include="HttpMessageHandlerExtensions.cs" />
    <Compile Include="HttpRouteCollectionTest.cs" />
    <Compile Include="ModelBinding\ModelBindingEndToEndTests.cs" />
    <Compile Include="ModelBinding\SharedModels\PeopleModel.cs" />
    <Compile Include="ModelBinding\SharedModels\User.cs" />
    <Compile Include="ModelBinding\SharedModels\Address.cs" />
    <Compile Include="ModelBinding\SharedModels\StreetAddress.cs" />
    <Compile Include="ModelBinding\SharedModels\Person.cs" />
    <Compile Include="Resources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="Results\BadRequestResultTests.cs" />
    <Compile Include="Results\RedirectToRouteResultTests.cs" />
    <Compile Include="Results\CreatedAtRouteNegotiatedContentResultTests.cs" />
    <Compile Include="Results\BadRequestErrorMessageResultTests.cs" />
    <Compile Include="Results\JsonResultTests.cs" />
    <Compile Include="Results\ConflictResultTests.cs" />
    <Compile Include="Results\UnauthorizedResultTests.cs" />
    <Compile Include="Results\ExceptionResultTests.cs" />
    <Compile Include="Results\OkResultTests.cs" />
    <Compile Include="Results\InternalServerErrorResultTests.cs" />
    <Compile Include="Results\NotFoundResultTests.cs" />
    <Compile Include="Results\CreatedNegotiatedContentResultTests.cs" />
    <Compile Include="Results\OkNegotiatedContentResultTests.cs" />
    <Compile Include="Results\InvalidModelStateResultTests.cs" />
    <Compile Include="Results\NegotiatedContentResultTests.cs" />
    <Compile Include="Results\FormattedContentResultTests.cs" />
    <Compile Include="Results\RedirectResultTests.cs" />
    <Compile Include="Results\StatusCodeResultTests.cs" />
    <Compile Include="HttpConfigurationExtensionsTest.cs" />
    <Compile Include="Dispatcher\DefaultHttpControllerTypeResolverTest.cs" />
    <Compile Include="Dispatcher\DefaultHttpControllerSelectorTest.cs" />
    <Compile Include="Dispatcher\DefaultHttpControllerActivatorTest.cs" />
    <Compile Include="Dispatcher\HttpControllerDispatcherTest.cs" />
    <Compile Include="Dispatcher\HttpErrorTest.cs" />
    <Compile Include="Dispatcher\HttpRoutingDispatcherTest.cs" />
    <Compile Include="Filters\HttpFilterCollectionTest.cs" />
    <Compile Include="HttpErrorKeysTest.cs" />
    <Compile Include="HttpResponseMessageExtensionsTest.cs" />
    <Compile Include="HttpResponseExceptionTest.cs" />
    <Compile Include="HttpServerTest.cs" />
    <Compile Include="HttpRequestMessageExtensionsTest.cs" />
    <Compile Include="HttpRouteCollectionExtensionsTest.cs" />
    <Compile Include="Results\ResponseMessageResultTests.cs" />
    <Compile Include="Metadata\Providers\AssociatedMetadataProviderTest.cs" />
    <Compile Include="ModelBinding\FormatterParameterBindingTest.cs" />
    <Compile Include="ModelBinding\HttpParameterBindingExtensionsTest.cs" />
    <Compile Include="ModelBinding\ParameterBindingProvidersTest.cs" />
    <Compile Include="Dispatcher\DefaultAssembliesResolverTest.cs" />
    <Compile Include="Controllers\ApiControllerActionInvokerTest.cs" />
    <Compile Include="Controllers\ApiControllerActionSelectorTest.cs" />
    <Compile Include="Controllers\HttpParameterDescriptorTest.cs" />
    <Compile Include="Controllers\ReflectedHttpParameterDescriptorTest.cs" />
    <Compile Include="Controllers\HttpControllerDescriptorTest.cs" />
    <Compile Include="Controllers\ReflectedHttpActionDescriptorTest.cs" />
    <Compile Include="Controllers\HttpActionContextTest.cs" />
    <Compile Include="Hosting\HttpRouteTest.cs" />
    <Compile Include="Internal\TypeActivatorTest.cs" />
    <Compile Include="Metadata\ModelMetadataTest.cs" />
    <Compile Include="Metadata\Providers\DataAnnotationsModelMetadataProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\FormDataCollectionExtensionsTest.cs" />
    <Compile Include="ModelBinding\ModelBinderAttributeTest.cs" />
    <Compile Include="Routing\AttributeRoutingTest.cs" />
    <Compile Include="..\Common\Routing\RouteConstraintsTests.cs">
      <Link>Routing\RouteConstraintsTests.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DefaultInlineConstraintResolverTest.cs">
      <Link>Routing\DefaultInlineConstraintResolverTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\InlineRouteTemplateParserTests.cs">
      <Link>Routing\InlineRouteTemplateParserTests.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DirectRouteBuilderTests.cs">
      <Link>Routing\DirectRouteBuilderTests.cs</Link>
    </Compile>
    <Compile Include="Routing\DefaultDirectRouteProviderTests.cs" />
    <Compile Include="Routing\LinkGenerationRouteTests.cs" />
    <Compile Include="Routing\DirectRouteProviderContextTests.cs" />
    <Compile Include="Routing\HttpRouteValueDictionaryTest.cs" />
    <Compile Include="Routing\HttpRouteTest.cs" />
    <Compile Include="Routing\MediaTypeFormatterExtensionsTests.cs" />
    <Compile Include="Routing\RouteAttributeTests.cs" />
    <Compile Include="..\Common\Routing\SubRouteCollectionTest.cs">
      <Link>Routing\SubRouteCollectionTest.cs</Link>
    </Compile>
    <Compile Include="Routing\UriPathExtensionMappingTests.cs" />
    <Compile Include="Routing\UrlHelperTest.cs" />
    <Compile Include="Services\ControllerServicesTests.cs" />
    <Compile Include="Services\DecoratorTests.cs" />
    <Compile Include="Services\DefaultServicesTests.cs" />
    <Compile Include="Services\ServicesExtensionsTests.cs" />
    <Compile Include="Tracing\TraceRecordTest.cs" />
    <Compile Include="Tracing\TraceLevelHelperTest.cs" />
    <Compile Include="Tracing\FormattingUtilitiesTest.cs" />
    <Compile Include="Tracing\HttpRequestMessageExtensionsTest.cs" />
    <Compile Include="Tracing\ITraceWriterExtensionsTest.cs" />
    <Compile Include="Tracing\TestTraceWriter.cs" />
    <Compile Include="Tracing\TraceManagerTest.cs" />
    <Compile Include="Tracing\TracerCorrectnessTest.cs" />
    <Compile Include="Tracing\TraceRecordComparer.cs" />
    <Compile Include="Tracing\Tracers\BufferedMediaTypeFormatterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\DefaultHttpControllerTypeResolverTracerTest.cs" />
    <Compile Include="Tracing\Tracers\OverrideFilterTracerTests.cs" />
    <Compile Include="Tracing\Tracers\AuthenticationFilterTracerTests.cs" />
    <Compile Include="Tracing\Tracers\ReadWriteMediaTypeFormatterTracerTestBase.cs" />
    <Compile Include="Tracing\Tracers\FormUrlEncodedMediaTypeFormatterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpActionBindingTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpActionDescriptorTracerTest.cs" />
    <Compile Include="Tracing\Tracers\ActionFilterAttributeTracerTest.cs" />
    <Compile Include="Tracing\Tracers\ActionFilterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpActionInvokerTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpActionSelectorTracerTest.cs" />
    <Compile Include="Tracing\Tracers\ActionValueBinderTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerDescriptorTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerTracerTest.cs" />
    <Compile Include="Tracing\Tracers\AuthorizationFilterAttributeTracerTest.cs" />
    <Compile Include="Tracing\Tracers\AuthorizationFilterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\ContentNegotiatorTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerActivatorTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpControllerSelectorTracerTest.cs" />
    <Compile Include="Tracing\Tracers\ExceptionFilterAttributeTracerTest.cs" />
    <Compile Include="Tracing\Tracers\ExceptionFilterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\FilterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\FormatterParameterBindingTracerTest.cs" />
    <Compile Include="Tracing\Tracers\HttpParameterBindingTracerTest.cs" />
    <Compile Include="Tracing\Tracers\JsonMediaTypeFormatterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\MediaTypeFormatterTracerTest.cs" />
    <Compile Include="Tracing\Tracers\MediaTypeFormatterTracerTestBase.cs" />
    <Compile Include="Tracing\Tracers\MessageHandlerTracerTest.cs" />
    <Compile Include="Tracing\Tracers\RequestMessageHandlerTracerTest.cs" />
    <Compile Include="Tracing\Tracers\XmlMediaTypeFormatterTracerTest.cs" />
    <Compile Include="Tracing\TraceKindHelperTest.cs" />
    <Compile Include="Util\ContextUtil.cs" />
    <Compile Include="Filters\HttpActionExecutedContextTest.cs" />
    <Compile Include="Filters\ActionFilterAttributeTest.cs" />
    <Compile Include="Filters\ActionDescriptorFilterProviderTest.cs" />
    <Compile Include="Filters\AuthorizationFilterAttributeTest.cs" />
    <Compile Include="Filters\ExceptionFilterAttributeTest.cs" />
    <Compile Include="Filters\FilterAttributeTest.cs" />
    <Compile Include="Filters\FilterInfoComparerTest.cs" />
    <Compile Include="Filters\FilterInfoTest.cs" />
    <Compile Include="Filters\ConfigurationFilterProviderTest.cs" />
    <Compile Include="ModelBinding\CompositeModelBinderTest.cs" />
    <Compile Include="ModelBinding\DefaultActionValueBinderTest.cs" />
    <Compile Include="Controllers\ApiControllerTest.cs" />
    <Compile Include="Controllers\Apis\UsersController.cs" />
    <Compile Include="ModelBinding\HttpBindingBehaviorAttributeTest.cs" />
    <Compile Include="Internal\CollectionModelBinderUtilTest.cs" />
    <Compile Include="ModelBinding\Binders\ArrayModelBinderProviderTest.cs" />
    <Compile Include="ModelBinding\Binders\ArrayModelBinderTest.cs" />
    <Compile Include="ModelBinding\Binders\CollectionModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\CollectionModelBinderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\ComplexModelDtoModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\ComplexModelDtoModelBinderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\ComplexModelDtoResultTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\ComplexModelDtoTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\DictionaryModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\DictionaryModelBinderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\KeyValuePairModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\KeyValuePairModelBinderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\KeyValuePairModelBinderUtilTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\MutableObjectModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\MutableObjectModelBinderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\SimpleModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\TypeConverterModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\TypeConverterModelBinderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\TypeMatchModelBinderProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\Binders\TypeMatchModelBinderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="ModelBinding\ModelBinderConfigTest.cs" />
    <Compile Include="ModelBinding\ModelBindingUtilTest.cs" />
    <Compile Include="ModelBinding\ModelBindingContextTest.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Util\SimpleHttpValueProvider.cs" />
    <Compile Include="Validation\DefaultBodyModelValidatorTest.cs" />
    <Compile Include="Validation\ModelStateFormatterLoggerTest.cs" />
    <Compile Include="Validation\ModelValidationNodeTest.cs" />
    <Compile Include="Validation\ModelValidationRequiredMemberSelectorTest.cs" />
    <Compile Include="Validation\ModelValidationResultTest.cs" />
    <Compile Include="Validation\ModelValidatorTest.cs" />
    <Compile Include="Validation\Providers\AssociatedValidatorProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Validation\Providers\DataAnnotationsModelValidatorProviderTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Validation\Providers\DataMemberModelValidatorProviderTest.cs" />
    <Compile Include="Validation\Providers\InvalidModelValidatorProviderTest.cs" />
    <Compile Include="Validation\ReferenceEqualityComparerTest.cs" />
    <Compile Include="Validation\Validators\DataAnnotationsModelValidatorTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Validation\Validators\ErrorModelValidatorTest.cs" />
    <Compile Include="ValueProviders\Providers\ElementalValueProviderTest.cs" />
    <Compile Include="ValueProviders\Providers\RouteDataValueProviderFactoryTest.cs" />
    <Compile Include="ValueProviders\Providers\NameValuePairsValueProviderTest.cs" />
    <Compile Include="ValueProviders\Providers\QueryStringValueProviderFactoryTest.cs" />
    <Compile Include="ValueProviders\Providers\QueryStringValueProviderTest.cs" />
    <Compile Include="ValueProviders\Providers\RouteDataValueProviderTest.cs" />
    <Compile Include="ValueProviders\ValueProviderResultTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Net.Http.Formatting.Test\System.Net.Http.Formatting.Test.csproj">
      <Project>{7AF77741-9158-4D5F-8782-8F21FADF025F}</Project>
      <Name>System.Net.Http.Formatting.Test</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Resources.resx">
      <Generator>PublicResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Http.Test/Tracing/FormattingUtilitiesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Linq;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using System.Web.Http.ModelBinding.Binders;
using System.Web.Http.Routing;
using System.Web.Http.ValueProviders;
using System.Web.Http.ValueProviders.Providers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing
{
    public class FormattingUtilitiesTest
    {
        [Theory]
        [TestDataSet(typeof(CommonUnitTestDataSets), "RefTypeTestDataCollection")]
        public void ValueToString_Formats(Type variationType, object testData)
        {
            // Arrange
            GC.KeepAlive(variationType); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters.
            string expected = Convert.ToString(testData, CultureInfo.CurrentCulture);

            // Act
            string actual = FormattingUtilities.ValueToString(testData, CultureInfo.CurrentCulture);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ValueToString_Formats_Null_Value()
        {
            // Arrange & Act
            string actual = FormattingUtilities.ValueToString(null, CultureInfo.CurrentCulture);

            // Assert
            Assert.Equal("null", actual);
        }

        [Fact]
        public void ActionArgumentsToString_Formats()
        {
            // Arrange
            Dictionary<string, object> arguments = new Dictionary<string, object>()
                                                       {
                                                           {"p1", 1},
                                                           {"p2", true}
                                                       };

            string expected = String.Format("p1={0}, p2={1}",
                                    FormattingUtilities.ValueToString(arguments["p1"], CultureInfo.CurrentCulture),
                                    FormattingUtilities.ValueToString(arguments["p2"], CultureInfo.CurrentCulture));

            // Act
            string actual = FormattingUtilities.ActionArgumentsToString(arguments);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ActionDescriptorToString_Formats()
        {
            // Arrange
            Mock<HttpParameterDescriptor> paramDescriptor1 = new Mock<HttpParameterDescriptor>() { CallBase = true };
            paramDescriptor1.Setup(p => p.ParameterName).Returns("p1");
            paramDescriptor1.Setup(p => p.ParameterType).Returns(typeof(int));
            Mock<HttpParameterDescriptor> paramDescriptor2 = new Mock<HttpParameterDescriptor>() { CallBase = true };
            paramDescriptor2.Setup(p => p.ParameterName).Returns("p2");
            paramDescriptor2.Setup(p => p.ParameterType).Returns(typeof(bool));

            Collection<HttpParameterDescriptor> parameterCollection = new Collection<HttpParameterDescriptor>(
                new HttpParameterDescriptor[] { paramDescriptor1.Object, paramDescriptor2.Object });
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(parameterCollection);
            mockActionDescriptor.Setup(a => a.ActionName).Returns("SampleAction");

            string expected = String.Format("SampleAction({0} p1, {1} p2)", typeof(int).Name, typeof(bool).Name);

            // Act
            string actual = FormattingUtilities.ActionDescriptorToString(mockActionDescriptor.Object);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ActionInvokeToString_Formats()
        {
            // Arrange
            Dictionary<string, object> arguments = new Dictionary<string, object>()
                                                       {
                                                           {"p1", 1},
                                                           {"p2", true}
                                                       };

            string expected = String.Format("SampleAction(p1={0}, p2={1})",
                                    FormattingUtilities.ValueToString(arguments["p1"], CultureInfo.CurrentCulture),
                                    FormattingUtilities.ValueToString(arguments["p2"], CultureInfo.CurrentCulture));

            // Act
            string actual = FormattingUtilities.ActionInvokeToString("SampleAction", arguments);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ActionInvokeToString_With_ActionContext_Formats()
        {
            // Arrange
            Mock<HttpParameterDescriptor> paramDescriptor1 = new Mock<HttpParameterDescriptor>() { CallBase = true };
            paramDescriptor1.Setup(p => p.ParameterName).Returns("p1");
            paramDescriptor1.Setup(p => p.ParameterType).Returns(typeof(int));
            Mock<HttpParameterDescriptor> paramDescriptor2 = new Mock<HttpParameterDescriptor>() { CallBase = true };
            paramDescriptor2.Setup(p => p.ParameterName).Returns("p2");
            paramDescriptor2.Setup(p => p.ParameterType).Returns(typeof(bool));

            Collection<HttpParameterDescriptor> parameterCollection = new Collection<HttpParameterDescriptor>(
                new HttpParameterDescriptor[] { paramDescriptor1.Object, paramDescriptor2.Object });
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(parameterCollection);
            mockActionDescriptor.Setup(a => a.ActionName).Returns("SampleAction");

            HttpActionContext actionContext =
                ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            actionContext.ActionArguments["p1"] = 1;
            actionContext.ActionArguments["p2"] = true;

            string expected = String.Format("SampleAction(p1={0}, p2={1})",
                                    FormattingUtilities.ValueToString(actionContext.ActionArguments["p1"], CultureInfo.CurrentCulture),
                                    FormattingUtilities.ValueToString(actionContext.ActionArguments["p2"], CultureInfo.CurrentCulture));

            // Act
            string actual = FormattingUtilities.ActionInvokeToString(actionContext);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void FormattersToString_Formats()
        {
            // Arrange
            MediaTypeFormatterCollection formatters = new MediaTypeFormatterCollection();
            string expected = String.Join(", ", formatters.Select<MediaTypeFormatter, string>((f) => f.GetType().Name));

            // Act
            string actual = FormattingUtilities.FormattersToString(formatters);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ModelBinderToString_Formats()
        {
            // Arrange
            ModelBinderProvider provider = new SimpleModelBinderProvider(typeof(int), () => null);
            string expected = typeof(SimpleModelBinderProvider).Name;

            // Act
            string actual = FormattingUtilities.ModelBinderToString(provider);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ModelBinderToString_With_CompositeModelBinder_Formats()
        {
            // Arrange
            ModelBinderProvider innerProvider1 = new SimpleModelBinderProvider(typeof(int), () => null);
            ModelBinderProvider innerProvider2 = new ArrayModelBinderProvider();
            CompositeModelBinderProvider compositeProvider = new CompositeModelBinderProvider(new ModelBinderProvider[] { innerProvider1, innerProvider2 });
            string expected = String.Format(
                                "{0}({1}, {2})",
                                typeof(CompositeModelBinderProvider).Name,
                                typeof(SimpleModelBinderProvider).Name,
                                typeof(ArrayModelBinderProvider).Name);

            // Act
            string actual = FormattingUtilities.ModelBinderToString(compositeProvider);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ValueProviderToString_Formats()
        {
            // Arrange
            IValueProvider provider = new ElementalValueProvider("unused", 1, CultureInfo.CurrentCulture);
            string expected = typeof(ElementalValueProvider).Name;

            // Act
            string actual = FormattingUtilities.ValueProviderToString(provider);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ValueProviderToString_With_CompositeProvider_Formats()
        {
            // Arrange
            List<IValueProvider> providers = new List<IValueProvider>()
                                                 {
                                                    new ElementalValueProvider("unused", 1, CultureInfo.CurrentCulture),
                                                    new NameValuePairsValueProvider(() => null, CultureInfo.CurrentCulture)
                                                 };

            CompositeValueProvider compositeProvider = new CompositeValueProvider(providers);
            string expected = String.Format(
                                "{0}({1}, {2})",
                                typeof(CompositeValueProvider).Name,
                                typeof(ElementalValueProvider).Name,
                                typeof(NameValuePairsValueProvider).Name);

            // Act
            string actual = FormattingUtilities.ValueProviderToString(compositeProvider);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void RouteToString_Formats()
        {
            // Arrange
            Dictionary<string, object> routeDictionary = new Dictionary<string, object>()
                                                             {
                                                                 {"r1", "c1"},
                                                                 {"r2", "c2"}
                                                             };
            Mock<IHttpRouteData> mockRouteData = new Mock<IHttpRouteData>() { CallBase = true };
            mockRouteData.Setup(r => r.Values).Returns(routeDictionary);
            string expected = "r1:c1,r2:c2";

            // Act
            string actual = FormattingUtilities.RouteToString(mockRouteData.Object);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ModelStateToString_Formats_With_Valid_ModelState()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            string expected = String.Empty;

            // Act
            string actual = FormattingUtilities.ModelStateToString(modelState);

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ModelStateToString_Formats_With_InValid_ModelState()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddModelError("p1", "is bad");

            string expected = "p1: is bad";

            // Act
            string actual = FormattingUtilities.ModelStateToString(modelState);

            // Assert
            Assert.Equal(expected, actual);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/HttpRequestMessageExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http.Tracing
{
    public class HttpRequestMessageExtensionsTest
    {
        [Fact]
        public void GetCorrelationId_Returns_Valid_Guid()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();

            // Act
            Guid guid1 = request.GetCorrelationId();
            Guid guid2 = request.GetCorrelationId();

            // Assert
            Assert.Equal(guid1, guid2);
            Assert.NotEqual(guid1, Guid.Empty);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/ITraceWriterExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http.ModelBinding;
using Microsoft.TestCommon;

namespace System.Web.Http.Tracing
{
    public class ITraceWriterExtensionsTest
    {
        [Fact]
        public void Debug_With_Message_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Debug) { Kind = TraceKind.Trace, Message = "The formatted message" },
            };

            // Act
            traceWriter.Debug(request, "testCategory", "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Debug_With_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Debug) { Kind = TraceKind.Trace, Exception = exception },
            };

            // Act
            traceWriter.Debug(request, "testCategory", exception);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Debug_With_Message_And_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Debug) { Kind = TraceKind.Trace, Message = "The formatted message", Exception = exception },
            };

            // Act
            traceWriter.Debug(request, "testCategory", exception, "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Info_With_Message_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info) { Kind = TraceKind.Trace, Message = "The formatted message" },
            };

            // Act
            traceWriter.Info(request, "testCategory", "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Info_With_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info) { Kind = TraceKind.Trace, Exception = exception },
            };

            // Act
            traceWriter.Info(request, "testCategory", exception);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Info_With_Message_And_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info) { Kind = TraceKind.Trace, Message = "The formatted message", Exception = exception },
            };

            // Act
            traceWriter.Info(request, "testCategory", exception, "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Warn_With_Message_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Warn) { Kind = TraceKind.Trace, Message = "The formatted message" },
            };

            // Act
            traceWriter.Warn(request, "testCategory", "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Warn_With_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Warn) { Kind = TraceKind.Trace, Exception = exception },
            };

            // Act
            traceWriter.Warn(request, "testCategory", exception);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Warn_With_Message_And_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Warn) { Kind = TraceKind.Trace, Message = "The formatted message", Exception = exception },
            };

            // Act
            traceWriter.Warn(request, "testCategory", exception, "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Error_With_Message_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error) { Kind = TraceKind.Trace, Message = "The formatted message" },
            };

            // Act
            traceWriter.Error(request, "testCategory", "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Error_With_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error) { Kind = TraceKind.Trace, Exception = exception },
            };

            // Act
            traceWriter.Error(request, "testCategory", exception);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Error_With_Message_And_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error) { Kind = TraceKind.Trace, Message = "The formatted message", Exception = exception },
            };

            // Act
            traceWriter.Error(request, "testCategory", exception, "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Fatal_With_Message_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Fatal) { Kind = TraceKind.Trace, Message = "The formatted message" },
            };

            // Act
            traceWriter.Fatal(request, "testCategory", "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Fatal_With_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Fatal) { Kind = TraceKind.Trace, Exception = exception },
            };

            // Act
            traceWriter.Fatal(request, "testCategory", exception);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Fatal_With_Message_And_Exception_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Fatal) { Kind = TraceKind.Trace, Message = "The formatted message", Exception = exception },
            };

            // Act
            traceWriter.Fatal(request, "testCategory", exception, "The {0} message", "formatted");

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void TraceBeginEnd_Throws_With_Null_This()
        {
            // Arrange
            TestTraceWriter traceWriter = null;
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => traceWriter.TraceBeginEnd(request,
                                             "",
                                             TraceLevel.Off,
                                             "",
                                             "",
                                             beginTrace: null,
                                             execute: () => { },
                                             endTrace: null,
                                             errorTrace: null),
                                       "traceWriter");
        }

        [Fact]
        public void TraceBeginEnd_Throws_With_Null_Execute_Action()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => traceWriter.TraceBeginEnd(request,
                                             "",
                                             TraceLevel.Off,
                                             "",
                                             "",
                                             beginTrace: null,
                                             execute: null,
                                             endTrace: null,
                                             errorTrace: null),
                                       "execute");
        }

        [Fact]
        public void TraceBeginEnd_Accepts_Null_Trace_Actions()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            traceWriter.TraceBeginEnd(request,
                     "",
                     TraceLevel.Off,
                     "",
                     "",
                     beginTrace: null,
                     execute: () => { },
                     endTrace: null,
                     errorTrace: null);
        }

        [Fact]
        public void TraceBeginEnd_Invokes_BeginTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Fatal,
                                 "",
                                 "",
                                 beginTrace: (tr) => { invoked = true; },
                                 execute: () => { },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
        }

        [Fact]
        public void TraceBeginEnd_Does_Not_Invoke_BeginTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { invoked = true; },
                                 execute: () => { },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public void TraceBeginEnd_Invokes_Execute()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Fatal,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { invoked = true; },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
        }

        [Fact]
        public void TraceBeginEnd_Invokes_EndTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { },
                                 endTrace: (tr) => { invoked = true; },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
        }

        [Fact]
        public void TraceBeginEnd_Does_Not_Invoke_EndTrace_When_Error_Occurs()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            Exception exception = new InvalidOperationException();
            bool invoked = false;

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(
                    () => traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { throw exception; },
                                 endTrace: (tr) => { invoked = true; },
                                 errorTrace: (tr) => { }));
            Assert.False(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public void TraceBeginEnd_Does_Not_Invoke_EndTrace_When_Tracing_Only_High_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { },
                                 endTrace: (tr) => { invoked = true; },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public void TraceBeginEnd_Invokes_ErrorTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            Exception exception = new InvalidOperationException();
            bool invoked = false;

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(
                    () => traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { throw exception; },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.True(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public void TraceBeginEnd_Does_Not_Invoke_ErrorTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Fatal;
            HttpRequestMessage request = new HttpRequestMessage();
            Exception exception = new InvalidOperationException();
            bool invoked = false;

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(
                    () => traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { throw exception; },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.False(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public void TraceBeginEnd_Invokes_ErrorTrace_When_Tracing_Only_Errors()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            Exception exception = new InvalidOperationException();
            bool invoked = false;

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(
                    () => traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { throw exception; },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.True(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public void TraceBeginEnd_Does_Not_Invoke_ErrorTrace_Unless_Error_Occurs()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            traceWriter.TraceBeginEnd(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => { },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { invoked = true; });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public void TraceBeginEnd_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info) { Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage" },
                new TraceRecord(request, "testCategory", TraceLevel.Info) { Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Message = "endMessage" },
            };

            // Act
            traceWriter.TraceBeginEnd(request,
                                 "testCategory",
                                 TraceLevel.Info,
                                 "tester",
                                 "testOp",
                                 beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                 execute: () => { },
                                 endTrace: (tr) => { tr.Message = "endMessage"; },
                                 errorTrace: (tr) => { tr.Message = "won't happen"; });

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void TraceBeginEnd_Traces_And_Throws_When_Execute_Throws()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException("test exception");
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info) { Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage" },
                new TraceRecord(request, "testCategory", TraceLevel.Error) { Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Exception = exception, Message = "errorMessage" },
            };

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(
                                () => traceWriter.TraceBeginEnd(request,
                                    "testCategory",
                                    TraceLevel.Info,
                                    "tester",
                                    "testOp",
                                    beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                    execute: () => { throw exception; },
                                    endTrace: (tr) => { tr.Message = "won't happen"; },
                                    errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
        }

        [Fact]
        public void TraceBeginEnd_Traces_And_Throws_HttpResponseException()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseException exception = new HttpResponseException(Net.HttpStatusCode.NotFound);
            List<TraceRecord> expectedTraces = new List<TraceRecord>
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Warn)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Exception = exception,
                    Message = "errorMessage", Status = Net.HttpStatusCode.NotFound
                },
            };

            // Act & Assert
            Exception thrown = Assert.Throws<HttpResponseException>(
                                () => traceWriter.TraceBeginEnd(request,
                                    "testCategory",
                                    TraceLevel.Error,
                                    "tester",
                                    "testOp",
                                    beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                    execute: () => { throw exception; },
                                    endTrace: (tr) => { tr.Message = "won't Happen"; },
                                    errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(thrown, exception);
        }

        [Fact]
        public void TraceBeginEnd_Traces_And_Throws_AggregateException()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            AggregateException aggregateException = CreateAggregateException(request);
            List<TraceRecord> expectedTraces = new List<TraceRecord>
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Warn)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Exception = aggregateException,
                    // In the aggregateException, only the httpResponseException with the highest status code
                    // will be reflected in the trace record's message. In this test case, it should be NotFound.
                    Message = "UserMessage='The request is invalid.', ModelStateError=[key=[error], username=[invalid]]",
                    Status = Net.HttpStatusCode.NotFound
                },
            };

            // Act & Assert
            Exception thrown = Assert.Throws<AggregateException>(
                                () => traceWriter.TraceBeginEnd(request,
                                    "testCategory",
                                    TraceLevel.Error,
                                    "tester",
                                    "testOp",
                                    beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                    execute: () => { throw aggregateException; },
                                    endTrace: (tr) => { tr.Message = "won't Happen"; },
                                    errorTrace: null));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(thrown, expectedTraces[1].Exception);
        }

        [Fact]
        public void TraceBeginEnd_Does_Not_Trace_HttpResponseException_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new HttpResponseException(Net.HttpStatusCode.NotFound);

            // Act & Assert
            Exception thrown = Assert.Throws<HttpResponseException>(
                                () => traceWriter.TraceBeginEnd(request,
                                "",
                                TraceLevel.Info,
                                "",
                                "",
                                beginTrace: (tr) => { invoked = true; },
                                execute: () => { throw exception; },
                                endTrace: (tr) => { },
                                errorTrace: (tr) => { }));
            Assert.False(invoked);
            Assert.Empty(traceWriter.Traces);
            Assert.Same(thrown, exception);
        }

        [Fact]
        public void TraceBeginEndAsync_Throws_With_Null_This()
        {
            // Arrange
            TestTraceWriter traceWriter = null;
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => traceWriter.TraceBeginEndAsync(request,
                                             "",
                                             TraceLevel.Off,
                                             "",
                                             "",
                                             beginTrace: null,
                                             execute: () => TaskHelpers.Completed(),
                                             endTrace: null,
                                             errorTrace: null),
                                       "traceWriter");
        }

        [Fact]
        public void TraceBeginEndAsync_Throws_With_Null_Execute_Action()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => traceWriter.TraceBeginEndAsync(request,
                                             "",
                                             TraceLevel.Off,
                                             "",
                                             "",
                                             beginTrace: null,
                                             execute: null,
                                             endTrace: null,
                                             errorTrace: null),
                                       "execute");
        }

        [Fact]
        public Task TraceBeginEndAsync_Accepts_Null_Trace_Actions()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            return traceWriter.TraceBeginEndAsync(request,
                     "",
                     TraceLevel.Off,
                     "",
                     "",
                     beginTrace: null,
                     execute: () => TaskHelpers.Completed(),
                     endTrace: null,
                     errorTrace: null);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Invokes_BeginTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Fatal,
                                 "",
                                 "",
                                 beginTrace: (tr) => { invoked = true; },
                                 execute: () => TaskHelpers.Completed(),
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Does_Not_Invoke_BeginTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { invoked = true; },
                                 execute: () => TaskHelpers.Completed(),
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Traces_And_Throws_HttpResponseException()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseException exception = new HttpResponseException(Net.HttpStatusCode.InternalServerError);
            List<TraceRecord> expectedTraces = new List<TraceRecord>
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Exception = exception,
                    Message = "errorMessage", Status = Net.HttpStatusCode.InternalServerError
                },
            };

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<HttpResponseException>(
                                () => traceWriter.TraceBeginEndAsync(request,
                                    "testCategory",
                                    TraceLevel.Info,
                                    "tester",
                                    "testOp",
                                    beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                    execute: () => { throw exception; },
                                    endTrace: (tr) => { tr.Message = "won't Happen"; },
                                    errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(thrown, exception);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Does_Not_Trace_HttpResponseException_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new HttpResponseException(Net.HttpStatusCode.NotFound);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<HttpResponseException>(
                                () => traceWriter.TraceBeginEndAsync(request,
                                "",
                                TraceLevel.Info,
                                "",
                                "",
                                beginTrace: (tr) => { invoked = true; },
                                execute: () => TaskHelpers.FromError(exception),
                                endTrace: (tr) => { },
                                errorTrace: (tr) => { }));
            Assert.False(invoked);
            Assert.Empty(traceWriter.Traces);
            Assert.Same(thrown, exception);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Invokes_Execute()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Fatal,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () =>
                                 {
                                     invoked = true;
                                     return TaskHelpers.Completed();
                                 },
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Invokes_EndTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => TaskHelpers.Completed(),
                                 endTrace: (tr) => { invoked = true; },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Does_Not_Invoke_End_Trace_When_Error_Occurs()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                        () => traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr) => { invoked = true; },
                                 errorTrace: (tr) => { }));
            Assert.False(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Does_Not_Invoke_EndTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => TaskHelpers.Completed(),
                                 endTrace: (tr) => { invoked = true; },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Invokes_ErrorTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                        () => traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.True(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Does_Not_Invoke_ErrorTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Fatal;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                        () => traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.False(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Invokes_ErrorTrace_When_Tracing_Only_Errors()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                        () => traceWriter.TraceBeginEndAsync(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.True(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Does_Not_Invoke_ErrorTrace_Unless_Error_Occurs()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
            tcs.TrySetResult(null);

            // Act
            await traceWriter.TraceBeginEndAsync(
                            request,
                            "",
                            TraceLevel.Off,
                            "",
                            "",
                            beginTrace: (tr) => { },
                            execute: () => tcs.Task,
                            endTrace: (tr) => { },
                            errorTrace: (tr) => { invoked = true; });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsync_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Message = "endMessage"
                },
            };

            // Act
            await traceWriter.TraceBeginEndAsync(request,
                                 "testCategory",
                                 TraceLevel.Info,
                                 "tester",
                                 "testOp",
                                 beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                 execute: () => TaskHelpers.Completed(),
                                 endTrace: (tr) => { tr.Message = "endMessage"; },
                                 errorTrace: (tr) => { tr.Message = "won't happen"; });

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task TraceBeginEndAsync_Traces_When_Inner_Cancels()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Warn)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Message = "errorMessage"
                },
            };

            // Act & Assert
            await Assert.ThrowsAsync<TaskCanceledException>(
                () => traceWriter.TraceBeginEndAsync(request,
                     "testCategory",
                     TraceLevel.Info,
                     "tester",
                     "testOp",
                     beginTrace: (tr) => { tr.Message = "beginMessage"; },
                     execute: () => TaskHelpers.Canceled(),
                     endTrace: (tr) => { tr.Message = "won't happen"; },
                     errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public async Task TraceBeginEndAsync_Traces_And_Throws_AggregateException(bool isExThrownAtExecution)
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            AggregateException aggregateException = CreateAggregateException(request);
            List<TraceRecord> expectedTraces = new List<TraceRecord>
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Warn)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Exception = aggregateException,
                    // In the aggregateException, only the httpResponseException with the highest status code
                    // will be reflected in the trace record's message. In this test case, it should be NotFound.
                    Message = "UserMessage='The request is invalid.', ModelStateError=[key=[error], username=[invalid]]",
                    Status = Net.HttpStatusCode.NotFound
                },
            };

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<AggregateException>(
                                () => traceWriter.TraceBeginEndAsync(request,
                                    "testCategory",
                                    TraceLevel.Error,
                                    "tester",
                                    "testOp",
                                    beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                    execute: () =>
                                    {
                                        if (isExThrownAtExecution)
                                        {
                                            throw aggregateException;
                                        }
                                        Task task = new Task(() => { throw aggregateException; });
                                        task.Start();
                                        return task;
                                    },
                                    endTrace: (tr) => { tr.Message = "won't Happen"; },
                                    errorTrace: null));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(thrown, expectedTraces[1].Exception);
        }

        [Fact]
        public async Task TraceBeginAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp",
                    Message = "errorMessage", Exception = exception
                },
            };

            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
            tcs.TrySetException(exception);

            // Act & Assert
            InvalidOperationException thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                        () => traceWriter.TraceBeginEndAsync(request,
                                     "testCategory",
                                     TraceLevel.Info,
                                     "tester",
                                     "testOp",
                                     beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                     execute: () => tcs.Task,
                                     endTrace: (tr) => { tr.Message = "won't happen"; },
                                     errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
        }

        [Fact]
        public void TraceBeginEndAsyncGeneric_Throws_With_Null_This()
        {
            // Arrange
            TestTraceWriter traceWriter = null;
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => traceWriter.TraceBeginEndAsync<int>(request,
                                             "",
                                             TraceLevel.Off,
                                             "",
                                             "",
                                             beginTrace: null,
                                             execute: () => Task.FromResult<int>(1),
                                             endTrace: null,
                                             errorTrace: null),
                                       "traceWriter");
        }

        [Fact]
        public void TraceBeginEndAsyncGeneric_Throws_With_Null_Execute_Action()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            Assert.ThrowsArgumentNull(() => traceWriter.TraceBeginEndAsync<int>(request,
                                             "",
                                             TraceLevel.Off,
                                             "",
                                             "",
                                             beginTrace: null,
                                             execute: null,
                                             endTrace: null,
                                             errorTrace: null),
                                       "execute");
        }

        [Fact]
        public Task TraceBeginEndAsyncGeneric_Accepts_Null_Trace_Actions()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();

            // Act & Assert
            return traceWriter.TraceBeginEndAsync<int>(request,
                     "",
                     TraceLevel.Off,
                     "",
                     "",
                     beginTrace: null,
                     execute: () => Task.FromResult<int>(1),
                     endTrace: null,
                     errorTrace: null);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Invokes_BeginTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Fatal,
                                 "",
                                 "",
                                 beginTrace: (tr) => { invoked = true; },
                                 execute: () => Task.FromResult<int>(1),
                                 endTrace: (tr, value) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Traces_And_Throws_HttpResponseException()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseException exception = new HttpResponseException(Net.HttpStatusCode.NotFound);
            List<TraceRecord> expectedTraces = new List<TraceRecord>
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Warn)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Exception = exception,
                    Message = "errorMessage", Status = Net.HttpStatusCode.NotFound
                },
            };

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<HttpResponseException>(
                                () => traceWriter.TraceBeginEndAsync<int>(request,
                                    "testCategory",
                                    TraceLevel.Error,
                                    "tester",
                                    "testOp",
                                    beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                    execute: () => { throw exception; },
                                    endTrace: (tr, result) => { tr.Message = "won't Happen"; },
                                    errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(thrown, exception);
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public async Task TraceBeginEndAsyncGeneric_Traces_And_Throws_AggregateException(bool isExThrownAtExecution)
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            AggregateException aggregateException = CreateAggregateException(request);
            List<TraceRecord> expectedTraces = new List<TraceRecord>
            {
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Warn)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Exception = aggregateException,
                    // In the aggregateException, only the httpResponseException with the highest status code
                    // will be reflected in the trace record's message. In this test case, it should be NotFound.
                    Message = "UserMessage='The request is invalid.', ModelStateError=[key=[error], username=[invalid]]",
                    Status = Net.HttpStatusCode.NotFound
                },
            };

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<AggregateException>(
                                () => traceWriter.TraceBeginEndAsync<int>(request,
                                    "testCategory",
                                    TraceLevel.Error,
                                    "tester",
                                    "testOp",
                                    beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                    execute: () =>
                                    {
                                        if (isExThrownAtExecution)
                                        {
                                            throw aggregateException;
                                        }
                                        Task<int> task = new Task<int>(() => { throw aggregateException; });
                                        task.Start();
                                        return task;
                                    },
                                    endTrace: (tr, result) => { tr.Message = "won't Happen"; },
                                    errorTrace: null));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(thrown, expectedTraces[1].Exception);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Does_Not_Trace_HttpResponseException_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act & Assert
            await Assert.ThrowsAsync<HttpResponseException>(
                () => traceWriter.TraceBeginEndAsync(request,
                "",
                TraceLevel.Info,
                "",
                "",
                beginTrace: (tr) => { invoked = true; },
                execute: () => TaskHelpers.FromError(new HttpResponseException(Net.HttpStatusCode.NotFound)),
                endTrace: (tr) => { },
                errorTrace: (tr) => { }));
            Assert.False(invoked);
            Assert.Empty(traceWriter.Traces);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Does_Not_Invoke_BeginTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { invoked = true; },
                                 execute: () => Task.FromResult<int>(1),
                                 endTrace: (tr, value) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Invokes_Execute()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            int result = await traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Fatal,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () =>
                                 {
                                     invoked = true;
                                     return Task.FromResult<int>(1);
                                 },
                                 endTrace: (tr, value) => { },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
            Assert.Equal(1, result);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Invokes_EndTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            int invokedValue = 0;

            // Act
            await traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => Task.FromResult<int>(1),
                                 endTrace: (tr, value) => { invoked = true; invokedValue = value; },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.True(invoked);
            Assert.Equal(1, invokedValue);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Does_Not_Invoke_EndTrace_When_Error_Occurs()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>(0);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                () => traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr, value) => { invoked = true; },
                                 errorTrace: (tr) => { }));
            Assert.False(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Does_Not_Invoke_EndTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;

            // Act
            await traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => Task.FromResult<int>(1),
                                 endTrace: (tr, value) => { invoked = true; },
                                 errorTrace: (tr) => { });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Invokes_ErrorTrace()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>(0);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                () => traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Off,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr, value) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.True(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Does_Not_Invoke_ErrorTrace_When_Tracing_Only_Higher_Level()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Fatal;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>(0);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                () => traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr, value) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.False(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Invokes_ErrorTrace_When_Tracing_Only_Errors()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            traceWriter.TraceSelector = (rqst, category, level) => level >= TraceLevel.Error;
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            Exception exception = new InvalidOperationException();
            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>(0);
            tcs.TrySetException(exception);

            // Act & Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                () => traceWriter.TraceBeginEndAsync<int>(request,
                                 "",
                                 TraceLevel.Info,
                                 "",
                                 "",
                                 beginTrace: (tr) => { },
                                 execute: () => tcs.Task,
                                 endTrace: (tr, value) => { },
                                 errorTrace: (tr) => { invoked = true; }));
            Assert.True(invoked);
            Assert.Same(exception, thrown);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Does_Not_Invoke_ErrorTrace_Unless_Error_Occurs()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            bool invoked = false;
            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
            tcs.TrySetResult(1);

            // Act
            await traceWriter.TraceBeginEndAsync<int>(
                            request,
                            "",
                            TraceLevel.Off,
                            "",
                            "",
                            beginTrace: (tr) => { },
                            execute: () => tcs.Task,
                            endTrace: (tr, value) => { },
                            errorTrace: (tr) => { invoked = true; });

            // Assert
            Assert.False(invoked);
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Traces()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Message = "endMessage1"
                },
            };

            // Act
            await traceWriter.TraceBeginEndAsync<int>(request,
                                 "testCategory",
                                 TraceLevel.Info,
                                 "tester",
                                 "testOp",
                                 beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                 execute: () => Task.FromResult<int>(1),
                                 endTrace: (tr, value) => { tr.Message = "endMessage" + value; },
                                 errorTrace: (tr) => { tr.Message = "won't happen"; });

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task TraceBeginEndAsyncGeneric_Traces_When_Inner_Cancels()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Warn)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp", Message = "errorMessage"
                },
            };

            // Act & Assert
            await Assert.ThrowsAsync<TaskCanceledException>(
                () => traceWriter.TraceBeginEndAsync<int>(request,
                     "testCategory",
                     TraceLevel.Info,
                     "tester",
                     "testOp",
                     beginTrace: (tr) => { tr.Message = "beginMessage"; },
                     execute: () => TaskHelpers.Canceled<int>(),
                     endTrace: (tr, value) => { tr.Message = "won't happen"; },
                     errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task TraceBeginAsyncGeneric_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            InvalidOperationException exception = new InvalidOperationException();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, "testCategory", TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operator = "tester", Operation = "testOp", Message = "beginMessage"
                },
                new TraceRecord(request, "testCategory", TraceLevel.Error)
                {
                    Kind = TraceKind.End, Operator = "tester", Operation = "testOp",
                    Message = "errorMessage", Exception = exception
                },
            };

            TaskCompletionSource<int> tcs = new TaskCompletionSource<int>(1);
            tcs.TrySetException(exception);

            // Act & Assert
            InvalidOperationException thrown = await Assert.ThrowsAsync<InvalidOperationException>(
                        () => traceWriter.TraceBeginEndAsync<int>(request,
                                     "testCategory",
                                     TraceLevel.Info,
                                     "tester",
                                     "testOp",
                                     beginTrace: (tr) => { tr.Message = "beginMessage"; },
                                     execute: () => tcs.Task,
                                     endTrace: (tr, value) => { tr.Message = "won't happen"; },
                                     errorTrace: (tr) => { tr.Message = "errorMessage"; }));
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
        }

        private static AggregateException CreateAggregateException(HttpRequestMessage request)
        {
            using (new CultureReplacer())
            {
                HttpError httpError = new HttpError(new ModelStateDictionary()
                {
                    { "key", new ModelState() { Errors = { new ModelError("error") } } },
                    { "username", new ModelState() { Errors = { new ModelError("invalid") } } },
                }, true);
                HttpResponseException hre = new HttpResponseException(
                    request.CreateErrorResponse(Net.HttpStatusCode.BadRequest,
                                                new HttpError("Error Message from HRE.")));
                Exception nestedHre = new Exception("Level 1",
                    new Exception("Level 2",
                        new HttpResponseException(request.CreateErrorResponse(Net.HttpStatusCode.NotFound, httpError))));
                List<Exception> exceptions = new List<Exception>();
                exceptions.Add(hre);
                exceptions.Add(nestedHre);
                return new AggregateException(exceptions);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/TestTraceWriter.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Test spy used internally to capture <see cref="TraceRecord"/>s.
    /// </summary>
    internal class TestTraceWriter : ITraceWriter
    {
        private List<TraceRecord> _traceRecords = new List<TraceRecord>();

        public Func<HttpRequestMessage, string, TraceLevel, bool> TraceSelector { get; set; }

        public IList<TraceRecord> Traces { get { return _traceRecords;  } }

        public void Trace(HttpRequestMessage request, string category, TraceLevel level, Action<TraceRecord> traceAction)
        {
            if (TraceSelector == null || TraceSelector(request, category, level))
            {
                TraceRecord traceRecord = new TraceRecord(request, category, level);
                traceAction(traceRecord);
                lock (_traceRecords)
                {
                    _traceRecords.Add(traceRecord);
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/TraceKindHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http.Tracing
{
    public class TraceKindHelperTest : EnumHelperTestBase<TraceKind>
    {
        public TraceKindHelperTest()
            : base(TraceKindHelper.IsDefined, TraceKindHelper.Validate, (TraceKind)999)
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/TraceLevelHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http.Tracing
{
    public class TraceLevelHelperTest : EnumHelperTestBase<TraceLevel>
    {
        public TraceLevelHelperTest()
            : base(TraceLevelHelper.IsDefined, TraceLevelHelper.Validate, (TraceLevel)999)
        {
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/TraceManagerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Services;
using System.Web.Http.Tracing.Tracers;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http.Tracing
{
    public class TraceManagerTest
    {
        public static TheoryDataSet<List<DelegatingHandler>> MultipleMessageHandlers
        {
            get
            {
                TestTraceWriter traceWriter = new TestTraceWriter();
                DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
                DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
                RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
                DelegatingHandler messageHandlerDummy = new Mock<DelegatingHandler>().Object;
                DelegatingHandler msgHandlerTracerDummy = new MessageHandlerTracer(messageHandlerDummy, traceWriter);
                return new TheoryDataSet<List<DelegatingHandler>>
                {
                    { new List<DelegatingHandler>() },
                    { new List<DelegatingHandler>() { messageHandler } },
                    { new List<DelegatingHandler>() { messageHandler, messageHandler } },
                    { new List<DelegatingHandler>() { messageHandler, messageHandler, messageHandler } },
                    { new List<DelegatingHandler>() { msgHandlerTracer } },
                    { new List<DelegatingHandler>() { msgHandlerTracer, msgHandlerTracer } },
                    { new List<DelegatingHandler>() { msgHandlerTracer, msgHandlerTracer, msgHandlerTracer } },
                    { new List<DelegatingHandler>() { requestMsgtracer } },
                    { new List<DelegatingHandler>() { requestMsgtracer, requestMsgtracer } },
                    { new List<DelegatingHandler>() { requestMsgtracer, requestMsgtracer, requestMsgtracer } },
                    { new List<DelegatingHandler>() { messageHandler, msgHandlerTracer } },
                    { new List<DelegatingHandler>() { msgHandlerTracer, messageHandler } },
                    { new List<DelegatingHandler>() { requestMsgtracer, messageHandler, msgHandlerTracer } },
                    { new List<DelegatingHandler>() { messageHandler, requestMsgtracer, msgHandlerTracer } },
                    { new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer } },
                    { new List<DelegatingHandler>() { requestMsgtracer, msgHandlerTracer, messageHandler } },
                    { new List<DelegatingHandler>() { msgHandlerTracer, requestMsgtracer, messageHandler } },
                    { new List<DelegatingHandler>() { msgHandlerTracer, messageHandler, requestMsgtracer } },
                    { new List<DelegatingHandler>() { messageHandler, msgHandlerTracerDummy, requestMsgtracer } }
                };
            }
        }

        [Fact]
        public void TraceManager_Is_In_Default_ServiceResolver()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();

            // Act
            ITraceManager traceManager = config.Services.GetService(typeof(ITraceManager)) as ITraceManager;

            // Assert
            Assert.IsType<TraceManager>(traceManager);
        }

        [Theory]
        [InlineData(typeof(IHttpControllerSelector))]
        [InlineData(typeof(IHttpControllerActivator))]
        [InlineData(typeof(IHttpActionSelector))]
        [InlineData(typeof(IHttpActionInvoker))]
        [InlineData(typeof(IActionValueBinder))]
        [InlineData(typeof(IContentNegotiator))]
        [InlineData(typeof(IHttpControllerTypeResolver))]
        public void Initialize_Does_Not_Alter_Configuration_When_No_TraceWriter_Present(Type serviceType)
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            object defaultService = config.Services.GetService(serviceType);

            // Act
            new TraceManager().Initialize(config);

            // Assert
            Assert.Same(defaultService.GetType(), config.Services.GetService(serviceType).GetType());
        }

        [Theory]
        [InlineData(typeof(IHttpControllerSelector))]
        [InlineData(typeof(IHttpControllerActivator))]
        [InlineData(typeof(IHttpActionSelector))]
        [InlineData(typeof(IHttpActionInvoker))]
        [InlineData(typeof(IActionValueBinder))]
        [InlineData(typeof(IContentNegotiator))]
        [InlineData(typeof(IHttpControllerTypeResolver))]
        public void Initialize_Alters_Configuration_When_TraceWriter_Present(Type serviceType)
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            Mock<ITraceWriter> traceWriter = new Mock<ITraceWriter>() { CallBase = true };
            config.Services.Replace(typeof(ITraceWriter), traceWriter.Object);
            object defaultService = config.Services.GetService(serviceType);

            // Act
            new TraceManager().Initialize(config);

            // Assert
            Assert.NotSame(defaultService.GetType(), config.Services.GetService(serviceType).GetType());
        }

        [Fact]
        public void Initialize_Does_Not_Alter_MessageHandlers_When_No_TraceWriter_Present()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            Mock<DelegatingHandler> mockHandler = new Mock<DelegatingHandler>() { CallBase = true };
            config.MessageHandlers.Add(mockHandler.Object);

            // Act
            new TraceManager().Initialize(config);

            // Assert
            Assert.Equal(config.MessageHandlers[config.MessageHandlers.Count - 1].GetType(), mockHandler.Object.GetType());
        }

        [Fact]
        public void Initialize_Alters_MessageHandlers_WhenTraceWriter_Present()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            Mock<ITraceWriter> traceWriter = new Mock<ITraceWriter>() { CallBase = true };
            config.Services.Replace(typeof(ITraceWriter), traceWriter.Object);
            Mock<DelegatingHandler> mockHandler = new Mock<DelegatingHandler>() { CallBase = true };
            config.MessageHandlers.Add(mockHandler.Object);

            // Act
            new TraceManager().Initialize(config);

            // Assert
            Assert.IsAssignableFrom<RequestMessageHandlerTracer>(config.MessageHandlers[0]);
            Assert.IsAssignableFrom<MessageHandlerTracer>(config.MessageHandlers[config.MessageHandlers.Count - 2]);
            Assert.Equal(3, config.MessageHandlers.Count);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void Initialize_Does_Not_Alter_MediaTypeFormatters_When_No_TraceWriter_Present()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();

            // Act
            new TraceManager().Initialize(config);

            // Assert
            foreach (var formatter in config.Formatters)
            {
                Assert.False(typeof(IFormatterTracer).IsAssignableFrom(formatter.GetType()));
            }
        }

        [Fact]
        public void Initialize_Alters_MediaTypeFormatters_WhenTraceWriter_Present()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            Mock<ITraceWriter> traceWriter = new Mock<ITraceWriter>() { CallBase = true };
            config.Services.Replace(typeof(ITraceWriter), traceWriter.Object);

            // Act
            new TraceManager().Initialize(config);

            // Assert
            foreach (var formatter in config.Formatters)
            {
                Assert.IsAssignableFrom<IFormatterTracer>(formatter);
            }
        }

        [Fact]
        public void Multiple_Initialize_DoesNotAlter_Num_Of_MessageHandlers_With_No_TraceWriter()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            int expectedHandlerCount = config.MessageHandlers.Count;

            // Act
            traceManager.Initialize(config);

            // Assert
            int actualHandlerCount = config.MessageHandlers.Count;
            Assert.Equal(expectedHandlerCount, actualHandlerCount);
        }

        [Theory]
        [PropertyData("MultipleMessageHandlers")]
        public void Multiple_Initialize_DoesNotAlter_MessageHandlerCollection(List<DelegatingHandler> handlerList)
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;

            // Act
            traceManager.Initialize(config);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void HttpServer_Initialize_After_Trace_Manager_Initialize_DoesNotAlter_MessageHandlerCollection()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            config.MessageHandlers.Add(messageHandler);
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;
            HttpRequestMessage request = new HttpRequestMessage();
            Mock<HttpControllerDispatcher> dispatcherMock = new Mock<HttpControllerDispatcher>(config);
            dispatcherMock.Protected().Setup<Task<HttpResponseMessage>>("SendAsync", request, CancellationToken.None)
                .Returns(Task.FromResult<HttpResponseMessage>(request.CreateResponse()));

            HttpServer server = new HttpServer(config, dispatcherMock.Object);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);

            // Act
            Task<HttpResponseMessage> response = invoker.SendAsync(request, CancellationToken.None);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void TraceManager_Initialize_After_HttpServer_Initialize_DoesNotAlter_MessageHandlerCollection()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            config.MessageHandlers.Add(messageHandler);
            TraceManager traceManager = new TraceManager();
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;
            HttpRequestMessage request = new HttpRequestMessage();
            Mock<HttpControllerDispatcher> dispatcherMock = new Mock<HttpControllerDispatcher>(config);
            dispatcherMock.Protected().Setup<Task<HttpResponseMessage>>("SendAsync", request, CancellationToken.None)
                .Returns(Task.FromResult<HttpResponseMessage>(request.CreateResponse()));

            HttpServer server = new HttpServer(config, dispatcherMock.Object);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);

            // Act
            Task<HttpResponseMessage> response = invoker.SendAsync(request, CancellationToken.None);
            traceManager.Initialize(config);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void HttpServer_CallsCustomMessageHandlers_InTheCorrectOrder()
        {
            // Arrange
            List<int> order = new List<int>();
            order.Add(1);
            order.Add(2);
            order.Add(3);
            order.Add(4);
            List<int>.Enumerator e = order.GetEnumerator();
            OrderAwareMessageHandler messageHandler1 = new OrderAwareMessageHandler(e, 1);
            OrderAwareMessageHandler messageHandler2 = new OrderAwareMessageHandler(e, 2);
            OrderAwareMessageHandler messageHandler3 = new OrderAwareMessageHandler(e, 3);
            OrderAwareMessageHandler messageHandler4 = new OrderAwareMessageHandler(e, 4);
            HttpRequestMessage request = new HttpRequestMessage();
            TraceManager traceManager = new TraceManager();
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            config.MessageHandlers.Add(messageHandler1);
            config.MessageHandlers.Add(messageHandler2);
            config.MessageHandlers.Add(messageHandler3);
            config.MessageHandlers.Add(messageHandler4);
            Mock<HttpControllerDispatcher> dispatcherMock = new Mock<HttpControllerDispatcher>(config);
            dispatcherMock.Protected().Setup<Task<HttpResponseMessage>>("SendAsync", request, CancellationToken.None)
                .Returns(Task.FromResult<HttpResponseMessage>(request.CreateResponse()));
            HttpServer server = new HttpServer(config, dispatcherMock.Object);
            HttpMessageInvoker invoker = new HttpMessageInvoker(server);

            // Act
            Task<HttpResponseMessage> response = invoker.SendAsync(request, CancellationToken.None);

            // Assert
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        public class OrderAwareMessageHandler : DelegatingHandler
        {
            private static IEnumerator<int> _order;
            private int _expectedOrder;

            public OrderAwareMessageHandler(IEnumerator<int> order, int expectedOrder)
            {
                _order = order;
                _expectedOrder = expectedOrder;
            }
            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                _order.MoveNext();
                Assert.True(_order.Current == _expectedOrder);
                return base.SendAsync(request, cancellationToken);
            }
        }

        [Fact]
        public void Initialize_Repairs_Handler_Collection_If_MsgHandler_Deleted()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            TestTraceWriter traceWriter = new TestTraceWriter();
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
            RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
            List<DelegatingHandler> handlerList = new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer };
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            int expectedHandlerCount = config.MessageHandlers.Count;

            // Act
            config.MessageHandlers.RemoveAt(expectedHandlerCount - 1);
            traceManager.Initialize(config);

            // Assert
            int actualHandlerCount = config.MessageHandlers.Count;
            Assert.Equal(expectedHandlerCount - 2, actualHandlerCount);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void Initialize_Repairs_Handler_Collection_If_Tracer_Deleted()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            TestTraceWriter traceWriter = new TestTraceWriter();
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
            RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
            List<DelegatingHandler> handlerList = new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer };
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            int handlerCount = config.MessageHandlers.Count;
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;

            // Act
            config.MessageHandlers.RemoveAt(handlerCount - 2);
            traceManager.Initialize(config);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void Initialize_Repairs_Handler_Collection_If_RequestTracer_Deleted()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            TestTraceWriter traceWriter = new TestTraceWriter();
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
            RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
            List<DelegatingHandler> handlerList = new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer };
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;

            // Act
            config.MessageHandlers.RemoveAt(2);
            traceManager.Initialize(config);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void Initialize_Repairs_Handler_Collection_If_MsgHandler_Inserted()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            TestTraceWriter traceWriter = new TestTraceWriter();
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
            RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
            List<DelegatingHandler> handlerList = new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer };
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            int expectedHandlerCount = config.MessageHandlers.Count;

            // Act
            config.MessageHandlers.Insert(1, messageHandler);
            traceManager.Initialize(config);

            // Assert
            int actualHandlerCount = config.MessageHandlers.Count;
            Assert.Equal(expectedHandlerCount + 2, actualHandlerCount);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void Initialize_Repairs_Handler_Collection_If_Tracer_Inserted()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            TestTraceWriter traceWriter = new TestTraceWriter();
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
            RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
            List<DelegatingHandler> handlerList = new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer };
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;

            // Act
            config.MessageHandlers.Insert(0, msgHandlerTracer);
            traceManager.Initialize(config);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        [Fact]
        public void Initialize_Repairs_Handler_Collection_If_RequestTracer_Inserted()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            TestTraceWriter traceWriter = new TestTraceWriter();
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
            RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
            List<DelegatingHandler> handlerList = new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer };
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;

            // Act
            config.MessageHandlers.Insert(0, requestMsgtracer);
            traceManager.Initialize(config);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }

        private static bool IsMessageHandlerCollectionValid(Collection<DelegatingHandler> messageHandlers)
        {
            int handlerCount = messageHandlers.Count;

            // if the handler count is zero, exit early.
            if (handlerCount == 0)
            {
                return false;
            }

            // if RequestMessageHandlerTracer is absent, exit early.
            if (!(messageHandlers[0] is RequestMessageHandlerTracer))
            {
                return false;
            }

            // Message handler list must be an odd number (2*N+1) for N message handlers.
            if (handlerCount % 2 != 1)
            {
                return false;
            }

            // Check if all odd positions have tracers and even positions have their corresponding handlers.
            for (int i = 2; i < handlerCount; i += 2)
            {
                DelegatingHandler tracer = messageHandlers[i - 1];
                DelegatingHandler messageHandler = messageHandlers[i];
                if (!(tracer is MessageHandlerTracer))
                {
                    return false;
                }

                DelegatingHandler innerHandler = Decorator.GetInner(tracer);
                if (innerHandler != messageHandler)
                {
                    return false;
                }
            }

            return true;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/TraceRecordComparer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// Comparer class to allow xUnit asserts for <see cref="TraceRecord"/>.
    /// </summary>
    internal class TraceRecordComparer : IEqualityComparer<TraceRecord>
    {
        public bool IgnoreExceptionReference { get; set; }

        public bool Equals(TraceRecord x, TraceRecord y)
        {
            if (!String.Equals(x.Category, y.Category) ||
                   x.Level != y.Level ||
                   x.Kind != y.Kind ||
                   !Object.ReferenceEquals(x.Request, y.Request))
            {
                return false;
            }

            // The following must match only if they are present on 'x' -- the expected value
            if (x.Exception != null)
            {
                if (IgnoreExceptionReference)
                {
                    if (y.Exception == null || !String.Equals(x.Exception.Message, y.Exception.Message))
                    {
                        return false;
                    }
                }
                else
                {
                    if (!Object.ReferenceEquals(x.Exception, y.Exception))
                    {
                        return false;
                    }
                }
            }

            if (!String.IsNullOrEmpty(x.Message) && !String.Equals(x.Message, y.Message))
            {
                return false;
            }

            if (!String.IsNullOrEmpty(x.Operation) && !String.Equals(x.Operation, y.Operation))
            {
                return false;
            }

            if (!String.IsNullOrEmpty(x.Operator) && !String.Equals(x.Operator, y.Operator))
            {
                return false;
            }

            return true;
        }

        public int GetHashCode(TraceRecord obj)
        {
            return obj.GetHashCode();
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/TraceRecordTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http.Tracing
{
    public class TraceRecordTest
    {
        [Fact]
        public void TraceRecord_TraceKind_RoundTrips()
        {
            Assert.Reflection.EnumProperty(
                new TraceRecord(request: null, category: null, level: TraceLevel.Info),
                r => r.Kind,
                expectedDefaultValue: TraceKind.Trace,
                illegalValue: (TraceKind)999,
                roundTripTestValue: TraceKind.End);
        }

        [Fact]
        public void TraceRecord_TraceLevel_RoundTrips()
        {
            Assert.Reflection.EnumProperty(
                new TraceRecord(request: null, category: null, level: TraceLevel.Info),
                r => r.Level,
                expectedDefaultValue: TraceLevel.Info,
                illegalValue: (TraceLevel)999,
                roundTripTestValue: TraceLevel.Fatal);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/TracerCorrectnessTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Reflection;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Filters;
using System.Web.Http.ModelBinding;
using System.Web.Http.Tracing.Tracers;
using Microsoft.TestCommon;

namespace System.Web.Http.Tracing
{
    /// <summary>
    /// This test class verifies that all tracers are correctly written.
    /// </summary>
    public class TracerCorrectnessTest
    {
        // Theory data for Tracers.  Tuple is:
        // [0] a framework type known to have a tracer
        // [1] the type of the tracer for that framework type
        // [2] member exclusion list,
        //     A string array containing member names the tracer handles in some way hidden from analysis.
        //     They will not be reported as issues.
        // !!! Exercise care in adding to the exclusion list !!!
        //     It means you have dealt with the issue, not that you're hiding from it.
        public static TheoryDataSet<Type, Type, string[]> AllKnownTracers
        {
            get
            {
                return new TheoryDataSet<Type, Type, string[]>
                {
                    { typeof(ActionFilterAttribute), typeof(ActionFilterAttributeTracer), new string[0] },
                    { typeof(IActionValueBinder), typeof(ActionValueBinderTracer), new string[0] },
                    { typeof(IActionFilter), typeof(ActionFilterTracer), new string[0] },
                    { typeof(AuthorizationFilterAttribute), typeof(AuthorizationFilterAttributeTracer), new string[0] },
                    { typeof(IAuthorizationFilter), typeof(AuthorizationFilterTracer), new string[0] },
                    { typeof(IAuthenticationFilter), typeof(AuthenticationFilterTracer), new string[0] },
                    { typeof(IOverrideFilter), typeof(OverrideFilterTracer), new string[0] },
                    { typeof(BufferedMediaTypeFormatter), typeof(BufferedMediaTypeFormatterTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_BufferSize", "set_BufferSize",
                            "get_SupportedMediaTypes",
                            "get_SupportedEncodings",
                            "get_MediaTypeMappings",
                            "get_RequiredMemberSelector", "set_RequiredMemberSelector",
                            // Cannot override, inner handles correctly
                            "ReadFromStreamAsync", "WriteToStreamAsync", "SelectCharacterEncoding"
                        }
                    },
                    { typeof(IContentNegotiator), typeof(ContentNegotiatorTracer), new string[0] },
                    { typeof(ExceptionFilterAttribute), typeof(ExceptionFilterAttributeTracer), new string[0] },
                    { typeof(IExceptionFilter), typeof(ExceptionFilterTracer), new string[0] },
                    { typeof(IFilter), typeof(FilterTracer), new string[0] },
                    { typeof(FormatterParameterBinding), typeof(FormatterParameterBindingTracer), new string[]
                        {
                            // Handled in base ctor
                            "get_Formatters", "set_Formatters",
                            "get_BodyModelValidator", "set_BodyModelValidator",
                            "get_Descriptor",
                            // Cannot override but handled by overriding ErrorMessage
                            "get_IsValid",
                            "GetValue", "SetValue"
                        }
                    },
                    { typeof(FormUrlEncodedMediaTypeFormatter), typeof(FormUrlEncodedMediaTypeFormatterTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_MaxDepth", "set_MaxDepth",
                            "get_ReadBufferSize", "set_ReadBufferSize",
                            "get_SupportedMediaTypes",
                            "get_SupportedEncodings",
                            "get_MediaTypeMappings",
                            "get_RequiredMemberSelector", "set_RequiredMemberSelector",
                            // Cannot override, base handles correctly via SupportedEncodings
                            "SelectCharacterEncoding",
                        }
                    },
                    { typeof(HttpActionBinding), typeof(HttpActionBindingTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_ActionDescriptor", "set_ActionDescriptor",
                            "get_ParameterBindings", "set_ParameterBindings"
                        }
                    },
                    { typeof(HttpActionDescriptor), typeof(HttpActionDescriptorTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_Configuration", "set_Configuration",
                            "get_ControllerDescriptor", "set_ControllerDescriptor"
                        }
                    },

                    { typeof(IHttpActionInvoker), typeof(HttpActionInvokerTracer), new string[0] },
                    { typeof(IHttpActionSelector), typeof(HttpActionSelectorTracer), new string[0] },
                    { typeof(IHttpControllerActivator), typeof(HttpControllerActivatorTracer), new string[0] },
                    { typeof(HttpControllerDescriptor), typeof(HttpControllerDescriptorTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_Configuration", "set_Configuration",
                            "get_ControllerType", "set_ControllerType",
                            "get_ControllerName", "set_ControllerName"
                        }
                    },
                    { typeof(IHttpControllerSelector), typeof(HttpControllerSelectorTracer), new string[0] },
                    { typeof(IHttpController), typeof(HttpControllerTracer), new string[0] },
                    { typeof(HttpParameterBinding), typeof(HttpParameterBindingTracer), new string[]
                        {
                            // Handled in base ctor
                            "get_Descriptor",
                            // Cannot override but handled by overriding ErrorMessage
                            "get_IsValid",
                            "GetValue", "SetValue",
                        }
                    },
                    { typeof(JsonMediaTypeFormatter), typeof(JsonMediaTypeFormatterTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_MaxDepth", "set_MaxDepth",
                            "get_SupportedMediaTypes",
                            "get_SupportedEncodings",
                            "get_MediaTypeMappings",
                            "get_RequiredMemberSelector", "set_RequiredMemberSelector",
                            "get_Indent", "set_Indent",
                            "get_UseDataContractJsonSerializer", "set_UseDataContractJsonSerializer",
                            "get_SerializerSettings", "set_SerializerSettings",
                            // Cannot override, base handles correctly
                            "SelectCharacterEncoding",
                            // Cannot override behavior, but copying SerializerSettings in ctor captures inner's result
                            "CreateDefaultSerializerSettings"
                        }
                    },
                    { typeof(MediaTypeFormatter), typeof(MediaTypeFormatterTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_SupportedMediaTypes", "get_SupportedEncodings",
                            "get_MediaTypeMappings",
                            "get_RequiredMemberSelector", "set_RequiredMemberSelector",
                            // Cannot override, base handles correctly
                            "SelectCharacterEncoding"
                        }
                    },
                    { typeof(DelegatingHandler), typeof(MessageHandlerTracer),  new string[]
                        {
                            // Value set by framework before we trace
                            "get_InnerHandler", "set_InnerHandler",
                            // Not meant to be delegated to inner, just to base
                            "Dispose"
                        }
                    },
                    { typeof(DelegatingHandler), typeof(RequestMessageHandlerTracer),new string[]
                        {
                            // Value set by framework before we trace
                            "get_InnerHandler", "set_InnerHandler",
                            // Not meant to be delegated to inner, just to base
                            "Dispose"
                        }
                    },
                    { typeof(XmlMediaTypeFormatter), typeof(XmlMediaTypeFormatterTracer), new string[]
                        {
                            // Values copied in ctor
                            "get_SupportedMediaTypes",
                            "get_SupportedEncodings",
                            "get_MediaTypeMappings",
                            "get_RequiredMemberSelector", "set_RequiredMemberSelector",
                            "get_UseXmlSerializer", "set_UseXmlSerializer",
                            "get_Indent", "set_Indent",
                            "get_WriterSettings",
                            "get_MaxDepth", "set_MaxDepth",
                            "InvokeCreateXmlReader", "InvokeCreateXmlWriter",
                            "InvokeGetDeserializer", "InvokeGetSerializer",
                            // Cannot override, base handles correctly
                            "SelectCharacterEncoding",
                            // Assume these are called before starting app.
                            // Tracer does not need to see them,
                            // and inner will uses its copies in read or write
                            "SetSerializer", "RemoveSerializer",
                        }
                    },
                    { typeof(DefaultHttpControllerTypeResolver), typeof(DefaultHttpControllerTypeResolverTracer), new string[0] },
                };
            }
        }

        // Following filters work best if there are no duplicate tracer types in AllKnownTracers. Currently the case.
        public static TheoryDataSet<Type, Type> AllKnownTracers_NoExclusions
        {
            get
            {
                var dataSet = new TheoryDataSet<Type, Type>();
                foreach (var item in AllKnownTracers)
                {
                    dataSet.Add((Type)item[0], (Type)item[1]);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<Type, string[]> AllKnownTracers_NoInnerType
        {
            get
            {
                var dataSet = new TheoryDataSet<Type, string[]>();
                foreach (var item in AllKnownTracers)
                {
                    dataSet.Add((Type)item[1], (string[])item[2]);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<Type> AllKnownTracers_JustTracerType
        {
            get
            {
                var dataSet = new TheoryDataSet<Type>();
                foreach (var item in AllKnownTracers)
                {
                    dataSet.Add((Type)item[1]);
                }

                return dataSet;
            }
        }

        [Fact]
        public void All_Tracers_Are_Tested()
        {
            // Arrange & Act
            Type[] allTracerTypes = typeof(ITraceWriter).Assembly.GetTypes().Where(t => !t.IsAbstract && t.Name.EndsWith("Tracer")).ToArray();
            Type[] allKnownTracerTypes = AllKnownTracers.Select<object[], Type>(tds => (Type)tds[1]).ToArray();
            Type[] untestedTypes = allTracerTypes.Where(tAll => !allKnownTracerTypes.Any(tKnown => tKnown == tAll)).ToArray();
            untestedTypes = untestedTypes.OrderBy<Type, string>(t => t.Name).ToArray();

            // Assert
            Assert.True(untestedTypes.Length == 0,
                        String.Format("These tracer types must be added to {0}.AllKnownTracers:{1}        {2}",
                        this.GetType().Name,
                        Environment.NewLine,
                        string.Join(Environment.NewLine + "        ", untestedTypes.Select<Type, string>(t => t.Name))));
        }

        [Theory]
        [PropertyData("AllKnownTracers_NoExclusions")]
        public void All_Tracers_Are_Internal_And_Disposable_When_Inner_Is_Disposable(Type innerType, Type tracerType)
        {
            // Arrange
            TypeAssert.TypeProperties typeProperties = TypeAssert.TypeProperties.IsClass;

            // If the inner is IDisposable, the tracer must be too.
            // The IHttpController case is special -- it must be disposable to invoke the inner.Dispose
            // only if the implementation type is IDisposable.
            if (typeof(IDisposable).IsAssignableFrom(innerType) || innerType == typeof(IHttpController))
            {
                typeProperties |= TypeAssert.TypeProperties.IsDisposable;
            }

            // Act & Assert
            Assert.Type.HasProperties(tracerType, typeProperties);
        }

        [Theory]
        [PropertyData("AllKnownTracers_JustTracerType")]
        public void All_Tracers_Use_Correct_Namespace(Type tracerType)
        {
            // Arrange & Act & Assert
            Assert.Equal("System.Web.Http.Tracing.Tracers", tracerType.Namespace);
        }

        [Theory]
        [PropertyData("AllKnownTracers_NoInnerType")]
        public void All_Excluded_Members_Are_Declared(Type tracerType, string[] exclusions)
        {
            // Arrange & Act
            string[] declaredMembers = tracerType.GetMembers(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Select<MemberInfo, string>(m => m.Name).ToArray();
            string[] unDeclaredExcludedMembers = exclusions.Where(e => !declaredMembers.Contains(e.Substring(e.LastIndexOf('.') + 1))).ToArray();

            // Assert
            Assert.True(unDeclaredExcludedMembers.Length == 0,
                        String.Format("The tracer '{0}' does not declare these members listed for exclusion: {1}",
                                        tracerType.Name,
                                        string.Join(",", unDeclaredExcludedMembers)));
        }

        [Theory]
        [PropertyData("AllKnownTracers")]
        public void All_Tracers_Handle_All_Inner_Members(Type innerType, Type tracerType, string[] excludedMembers)
        {
            // Arrange & Act
            IList<string> issues = DetermineIssues(innerType, tracerType, excludedMembers);

            // Assert
            Assert.True(issues.Count == 0,
                        String.Format("'{0}' does not handle these members from '{1}':{2}        {3}",
                        tracerType.Name,
                        innerType.Name,
                        Environment.NewLine,
                        string.Join(Environment.NewLine + "        ", issues)));
        }

        private static IList<string> DetermineIssues(Type innerType, Type tracerType, string[] excludedMembers)
        {
            List<string> issues = new List<string>();

            MemberInfo[] typeMembers = innerType.GetMembers(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
            foreach (MemberInfo memberInfo in typeMembers)
            {
                if (memberInfo is ConstructorInfo)
                {
                    continue;
                }

                MethodInfo methodInfo = memberInfo as MethodInfo;
                if (methodInfo != null)
                {
                    AddIssues(tracerType, issues, methodInfo, excludedMembers);
                }
            }

            return issues;
        }

        private static void AddIssues(Type tracerType, IList<string> issues, MethodInfo methodInfo, string[] excludedMembers)
        {
            if (methodInfo == null ||
                !(methodInfo.IsPublic || methodInfo.IsFamily) ||
                methodInfo.DeclaringType == typeof(Object))
            {
                return;
            }

            // Allow exclusion list to be short name or long name, because some members are up the inheritance chain
            string visibleMemberName = String.Format("{0}.{1}", methodInfo.DeclaringType.Name, GetSignature(methodInfo));
            if (!DoesTracerDeclare(tracerType, methodInfo) && !excludedMembers.Contains(visibleMemberName) && !excludedMembers.Contains(methodInfo.Name))
            {
                bool isOverrideable = IsOverrideable(methodInfo);
                bool isSetter = methodInfo.IsSpecialName && methodInfo.Name.StartsWith("set_");
                bool isGetter = methodInfo.IsSpecialName && methodInfo.Name.StartsWith("get_");
                issues.Add(String.Format("{0} [{1}]",
                            visibleMemberName,
                            isOverrideable
                                ? "Override this virtual in the tracer"
                                : isGetter
                                    ? "Capture this value from inner in the tracer's ctor, and add to it to the exclude list"
                                    : isSetter
                                        ? "Ensure this non-virtual setter cannot be called after the tracer has captured it, and add it to the exclude list"
                                        : "Make this member virtual and override it, or add it to the exclude list"));
            }
        }

        private static bool IsOverrideable(MethodInfo methodInfo)
        {
            return !methodInfo.IsFinal && (methodInfo.IsVirtual || methodInfo.IsAbstract);
        }

        private static bool DoMethodsMatch(MethodInfo originalMethodInfo, MethodInfo candidateMethodInfo)
        {
            if (!GetSignature(candidateMethodInfo).Equals(GetSignature(originalMethodInfo)))
            {
                return false;
            }

            return true;
        }

        private static string GetSignature(MethodInfo methodInfo)
        {
            return
                String.Format("{0}({1})", methodInfo.Name.Substring(methodInfo.Name.LastIndexOf(".") + 1),
                    String.Join(",", methodInfo.GetParameters().Select(p => p.ParameterType.Name)));
        }

        private static bool DoesTracerDeclare(Type tracerType, MethodInfo methodInfo)
        {
            if (methodInfo == null)
            {
                return true;
            }

            MethodInfo matchingMethod = tracerType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance).FirstOrDefault(m => DoMethodsMatch(methodInfo, m));
            return matchingMethod != null && matchingMethod.DeclaringType != methodInfo.DeclaringType;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/ActionFilterAttributeTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class ActionFilterAttributeTracerTest
    {
        [Fact]
        public void Equals_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<ActionFilterAttribute> mockAttribute = new Mock<ActionFilterAttribute>();
            mockAttribute.Setup(a => a.Equals(randomObject)).Returns(true).Verifiable();
            ActionFilterAttributeTracer tracer = new ActionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.Equals(randomObject);

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void GetHashCode_Calls_Inner()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockAttribute = new Mock<ActionFilterAttribute>();
            mockAttribute.Setup(a => a.GetHashCode()).Returns(1).Verifiable();
            ActionFilterAttributeTracer tracer = new ActionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            int valueReturned = tracer.GetHashCode();

            // Assert
            Assert.Equal(1, valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void IsDefaultAttribute_Calls_Inner()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockAttribute = new Mock<ActionFilterAttribute>();
            mockAttribute.Setup(a => a.IsDefaultAttribute()).Returns(true).Verifiable();
            ActionFilterAttributeTracer tracer = new ActionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.IsDefaultAttribute();

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void Match_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<ActionFilterAttribute> mockAttribute = new Mock<ActionFilterAttribute>();
            mockAttribute.Setup(a => a.Match(randomObject)).Returns(true).Verifiable();
            ActionFilterAttributeTracer tracer = new ActionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.Match(randomObject);

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void TypeId_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<ActionFilterAttribute> mockAttribute = new Mock<ActionFilterAttribute>();
            mockAttribute.Setup(a => a.TypeId).Returns(randomObject).Verifiable();
            ActionFilterAttributeTracer tracer = new ActionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            object valueReturned = tracer.TypeId;

            // Assert
            Assert.Same(randomObject, valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void AllowMultiple_Calls_Inner()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockAttribute = new Mock<ActionFilterAttribute>();
            mockAttribute.Setup(a => a.AllowMultiple).Returns(true).Verifiable();
            ActionFilterAttributeTracer tracer = new ActionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.AllowMultiple;

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_Traces_Executing_And_Executed()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockAttr = new Mock<ActionFilterAttribute>() { CallBase = true };
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            TestTraceWriter traceWriter = new TestTraceWriter();
            IActionFilter tracer = new ActionFilterAttributeTracer(mockAttr.Object, traceWriter) as IActionFilter;
            Func<Task<HttpResponseMessage>> continuation =
                () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnActionExecutingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "OnActionExecutingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnActionExecutedAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "OnActionExecutedAsync" }
            };

            // Act
            await tracer.ExecuteActionFilterAsync(actionContext, CancellationToken.None, continuation);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_Faults_And_Traces_When_OnExecuting_Faults()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockAttr = new Mock<ActionFilterAttribute>() { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockAttr.Setup(a => a.OnActionExecuting(It.IsAny<HttpActionContext>())).Throws(exception);
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            TestTraceWriter traceWriter = new TestTraceWriter();
            IActionFilter tracer = new ActionFilterAttributeTracer(mockAttr.Object, traceWriter) as IActionFilter;
            Func<Task<HttpResponseMessage>> continuation =
                () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnActionExecutingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End,  Operation = "OnActionExecutingAsync" }
            };

            // Act
            Task<HttpResponseMessage> task = tracer.ExecuteActionFilterAsync(actionContext, CancellationToken.None, continuation);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteActionFilterAsync_Faults_And_Traces_When_OnExecuted_Faults()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockAttr = new Mock<ActionFilterAttribute>() { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockAttr.Setup(a => a.OnActionExecuted(It.IsAny<HttpActionExecutedContext>())).Throws(exception);
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            TestTraceWriter traceWriter = new TestTraceWriter();
            IActionFilter tracer = new ActionFilterAttributeTracer(mockAttr.Object, traceWriter) as IActionFilter;

            Func<Task<HttpResponseMessage>> continuation =
                () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnActionExecutingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "OnActionExecutingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnActionExecutedAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End,  Operation = "OnActionExecutedAsync" }
            };

            // Act
            Task<HttpResponseMessage> task = tracer.ExecuteActionFilterAsync(actionContext, CancellationToken.None, continuation);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[3].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_ActionFilterAttributeTracer_Returns_ActionFilterAttribute()
        {
            // Arrange
            ActionFilterAttribute expectedInner = new Mock<ActionFilterAttribute>().Object;
            ActionFilterAttributeTracer productUnderTest = new ActionFilterAttributeTracer(expectedInner, new TestTraceWriter());

            // Act
            ActionFilterAttribute actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_ActionFilterAttributeTracer_Returns_ActionFilterAttribute()
        {
            // Arrange
            ActionFilterAttribute expectedInner = new Mock<ActionFilterAttribute>().Object;
            ActionFilterAttributeTracer productUnderTest = new ActionFilterAttributeTracer(expectedInner, new TestTraceWriter());

            // Act
            ActionFilterAttribute actualInner = Decorator.GetInner(productUnderTest as ActionFilterAttribute);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/ActionFilterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class ActionFilterTracerTest
    {
        [Fact]
        public async Task ExecuteActionAsync_Traces_ExecuteActionFilterAsync()
        {
            // Arrange
            HttpResponseMessage response = new HttpResponseMessage();
            Mock<IActionFilter> mockFilter = new Mock<IActionFilter>() { CallBase = true };
            mockFilter.Setup(
                f =>
                f.ExecuteActionFilterAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>(),
                                           It.IsAny<Func<Task<HttpResponseMessage>>>())).Returns(
                                               Task.FromResult<HttpResponseMessage>(response));
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            TestTraceWriter traceWriter = new TestTraceWriter();
            ActionFilterTracer tracer = new ActionFilterTracer(mockFilter.Object, traceWriter);
            Func<Task<HttpResponseMessage>> continuation =
                () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteActionFilterAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "ExecuteActionFilterAsync" },
            };

            // Act
            var filter = (IActionFilter)tracer;
            await filter.ExecuteActionFilterAsync(actionContext, CancellationToken.None, continuation);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteActionAsync_Faults_And_Traces_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            Mock<IActionFilter> mockFilter = new Mock<IActionFilter>() { CallBase = true };
            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>(null);
            tcs.TrySetException(exception);
            mockFilter.Setup(f => f.ExecuteActionFilterAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>(),
                                It.IsAny<Func<Task<HttpResponseMessage>>>())).Returns(tcs.Task);
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            TestTraceWriter traceWriter = new TestTraceWriter();
            ActionFilterTracer tracer = new ActionFilterTracer(mockFilter.Object, traceWriter);
            Func<Task<HttpResponseMessage>> continuation =
                () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteActionFilterAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End,  Operation = "ExecuteActionFilterAsync" },
            };

            // Act
            Task<HttpResponseMessage> task = ((IActionFilter)tracer).ExecuteActionFilterAsync(actionContext, CancellationToken.None, continuation);


            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_ActionFilterTracer_Returns_IActionFilter()
        {
            // Arrange
            IActionFilter expectedInner = new Mock<IActionFilter>().Object;
            ActionFilterTracer productUnderTest = new ActionFilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IActionFilter actualInner = productUnderTest.Inner as IActionFilter;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_Property_On_ActionFilterTracer_Returns_IActionFilter()
        {
            // Arrange
            IActionFilter expectedInner = new Mock<IActionFilter>().Object;
            ActionFilterTracer productUnderTest = new ActionFilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IActionFilter actualInner = Decorator.GetInner(productUnderTest as IActionFilter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/ActionValueBinderTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Controllers;
using System.Web.Http.ModelBinding;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class ActionValueBinderTracerTest
    {
        [Fact]
        public void GetBinding_Returns_HttpActionBindingTracer()
        {
            // Arrange
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));

            Mock<HttpParameterDescriptor> mockParameterDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            Mock<HttpParameterBinding> mockParameterBinding = new Mock<HttpParameterBinding>(mockParameterDescriptor.Object) { CallBase = true };
            HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object });

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));

            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
            controllerContext.ControllerDescriptor = controllerDescriptor;

            Mock<IActionValueBinder> mockBinder = new Mock<IActionValueBinder>() { CallBase = true };
            mockBinder.Setup(b => b.GetBinding(It.IsAny<HttpActionDescriptor>())).Returns(actionBinding);
            ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, new TestTraceWriter());

            // Act
            HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object);

            // Assert
            Assert.IsType<HttpActionBindingTracer>(actualBinding);
            Assert.Same(mockActionDescriptor.Object, actualBinding.ActionDescriptor);
        }

        [Fact]
        public void GetBinding_Invokes_Inner_And_Returns_ActionBinder_With_Tracing_HttpParameterBinding()
        {
            // Arrange
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));

            Mock<HttpParameterDescriptor> mockParameterDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            Mock<HttpParameterBinding> mockParameterBinding = new Mock<HttpParameterBinding>(mockParameterDescriptor.Object) { CallBase = true };
            HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object });

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));

            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
            controllerContext.ControllerDescriptor = controllerDescriptor;

            Mock<IActionValueBinder> mockBinder = new Mock<IActionValueBinder>() { CallBase = true };
            mockBinder.Setup(b => b.GetBinding(It.IsAny<HttpActionDescriptor>())).Returns(actionBinding);
            ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, new TestTraceWriter());

            // Act
            HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object);

            // Assert
            Assert.IsAssignableFrom<HttpParameterBindingTracer>(actualBinding.ParameterBindings[0]);
        }

        [Fact]
        public void GetBinding_Invokes_Inner_And_Returns_ActionBinder_With_Tracing_FormatterParameterBinding()
        {
            // Arrange
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));

            Mock<HttpParameterDescriptor> mockParameterDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            Mock<FormatterParameterBinding> mockParameterBinding = new Mock<FormatterParameterBinding>(mockParameterDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true };
            HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object });

            HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));

            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
            controllerContext.ControllerDescriptor = controllerDescriptor;

            Mock<IActionValueBinder> mockBinder = new Mock<IActionValueBinder>() { CallBase = true };
            mockBinder.Setup(b => b.GetBinding(It.IsAny<HttpActionDescriptor>())).Returns(actionBinding);
            ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, new TestTraceWriter());

            // Act
            HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object);

            // Assert
            Assert.IsAssignableFrom<FormatterParameterBindingTracer>(actualBinding.ParameterBindings[0]);
        }

        [Fact]
        public void GetBinding_DoesNotWrapHttpActionBindingTracer()
        {
            // Arrange
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            Mock<HttpParameterDescriptor> mockParameterDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            Mock<FormatterParameterBinding> mockParameterBinding = new Mock<FormatterParameterBinding>(mockParameterDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true };
            HttpActionBinding actionBinding = new HttpActionBinding(mockActionDescriptor.Object, new HttpParameterBinding[] { mockParameterBinding.Object });

            ITraceWriter traceWriter = new TestTraceWriter();
            HttpActionBindingTracer actionBindingTracer = new HttpActionBindingTracer(actionBinding, traceWriter);
            Mock<IActionValueBinder> mockBinder = new Mock<IActionValueBinder>() { CallBase = true };
            mockBinder.Setup(b => b.GetBinding(It.IsAny<HttpActionDescriptor>())).Returns(actionBindingTracer);
            ActionValueBinderTracer tracer = new ActionValueBinderTracer(mockBinder.Object, traceWriter);

            // Act
            HttpActionBinding actualBinding = ((IActionValueBinder)tracer).GetBinding(mockActionDescriptor.Object);

            // Assert
            Assert.Same(actionBindingTracer, actualBinding);
        }

        [Fact]
        public void Inner_Property_On_ActionValueBinderTracer_Returns_IActionValueBinder()
        {
            // Arrange
            IActionValueBinder expectedInner = new Mock<IActionValueBinder>().Object;
            ActionValueBinderTracer productUnderTest = new ActionValueBinderTracer(expectedInner, new TestTraceWriter());

            // Act
            IActionValueBinder actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_Property_On_ActionValueBinderTracer_Returns_IActionValueBinder()
        {
            // Arrange
            IActionValueBinder expectedInner = new Mock<IActionValueBinder>().Object;
            ActionValueBinderTracer productUnderTest = new ActionValueBinderTracer(expectedInner, new TestTraceWriter());

            // Act
            IActionValueBinder actualInner = Decorator.GetInner(productUnderTest as IActionValueBinder);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/AuthenticationFilterTracerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Principal;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class AuthenticationFilterTracerTests
    {
        [Fact]
        public void Inner_ReturnsSpecifiedInstance()
        {
            // Arrange
            IAuthenticationFilter expectedInner = CreateDummyFilter();
            ITraceWriter tracer = CreateDummyTracer();
            AuthenticationFilterTracer product = CreateProductUnderTest(expectedInner, tracer);

            // Act
            IAuthenticationFilter inner = product.Inner;

            // Assert
            Assert.Same(expectedInner, inner);
        }

        [Fact]
        public async Task AuthenticateAsync_DelegatesToInnerFilter()
        {
            // Arrange
            HttpAuthenticationContext expectedAuthenticationContext = CreateAuthenticationContext();
            CancellationToken expectedCancellationToken = CreateCancellationToken();
            Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>();
            int calls = 0;
            mock.Setup(f => f.AuthenticateAsync(expectedAuthenticationContext, expectedCancellationToken)).Callback(
                () => { calls++; }).Returns(() => Task.FromResult<object>(null));
            IAuthenticationFilter filter = mock.Object;
            ITraceWriter tracer = CreateStubTracer();
            IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);

            // Act
            await product.AuthenticateAsync(expectedAuthenticationContext, expectedCancellationToken);

            // Assert
            Assert.Equal(1, calls);
        }

        [Theory]
        [ReplaceCulture]
        [InlineData(true, "The authentication filter successfully set a principal "
                        + "to a known identity. Identity.Name='User'. "
                        + "Identity.AuthenticationType='Basic'.")]
        [InlineData(false, "The authentication filter set a principal to an unknown identity.")]
        public async Task AuthenticateAsync_Traces(bool withIdentity, string expectedMessage)
        {
            // Arrange
            CancellationToken cancellationToken = CreateCancellationToken();
            Mock<IAuthenticationFilter> filterMock = new Mock<IAuthenticationFilter>();
            filterMock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(),
                                                      It.IsAny<CancellationToken>()))
                .Callback((HttpAuthenticationContext context,
                           CancellationToken token) => context.Principal = CreateDummyPrincipal(withIdentity))
                .Returns(Task.FromResult<object>(null));
            IAuthenticationFilter filter = filterMock.Object;
            TraceRecord record = null;
            ITraceWriter tracer = CreateTracer((r) => { record = r; });
            IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpAuthenticationContext authenticationContext = CreateAuthenticationContext(expectedRequest,
                                                                                              isPrincipalSet: false);

                // Act
                await product.AuthenticateAsync(authenticationContext, cancellationToken);

                // Assert
                Assert.NotNull(record);
                Assert.Same(expectedRequest, record.Request);
                Assert.Same(TraceCategories.FiltersCategory, record.Category);
                Assert.Equal(TraceLevel.Info, record.Level);
                Assert.Equal(TraceKind.End, record.Kind);
                Assert.Equal(filter.GetType().Name, record.Operator);
                Assert.Equal("AuthenticateAsync", record.Operation);
                Assert.Null(record.Exception);
                Assert.Equal(expectedMessage, record.Message);
            }
        }

        [Fact]
        [ReplaceCulture]
        public async Task AuthenticateAsync_Traces_ErrorResult()
        {
            // Arrange
            IHttpActionResult result = new AuthenticationFailureResult();
            CancellationToken cancellationToken = CreateCancellationToken();
            Mock<IAuthenticationFilter> filterMock = new Mock<IAuthenticationFilter>();
            filterMock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(),
                                                      It.IsAny<CancellationToken>()))
                .Callback((HttpAuthenticationContext context,
                           CancellationToken token) => context.ErrorResult = result)
                .Returns(Task.FromResult<object>(null));
            TraceRecord record = null;
            ITraceWriter tracer = CreateTracer((r) => { record = r; });
            IAuthenticationFilter product = CreateProductUnderTest(filterMock.Object, tracer);
            const string expectedMessage = "The authentication filter encountered an error. ErrorResult="
                + "'System.Web.Http.Tracing.Tracers.AuthenticationFilterTracerTests+AuthenticationFailureResult'.";

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpAuthenticationContext authenticationContext = CreateAuthenticationContext(expectedRequest);

                // Act
                await product.AuthenticateAsync(authenticationContext, cancellationToken);

                // Assert
                Assert.NotNull(record);
                Assert.Same(expectedRequest, record.Request);
                Assert.Same(TraceCategories.FiltersCategory, record.Category);
                Assert.Equal(TraceLevel.Info, record.Level);
                Assert.Equal(TraceKind.End, record.Kind);
                Assert.Equal(filterMock.Object.GetType().Name, record.Operator);
                Assert.Equal("AuthenticateAsync", record.Operation);
                Assert.Null(record.Exception);
                Assert.Equal(expectedMessage, record.Message);
            }
        }

        [Fact]
        [ReplaceCulture]
        public async Task AuthenticateAsync_Traces_DidNothing()
        {
            // Arrange
            CancellationToken cancellationToken = CreateCancellationToken();
            IAuthenticationFilter filter = CreateStubFilter();
            TraceRecord record = null;
            ITraceWriter tracer = CreateTracer((r) => { record = r; });
            IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
            const string expectedMessage = "The authentication filter did not encounter an error or set a principal.";

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpAuthenticationContext authenticationContext = CreateAuthenticationContext(expectedRequest);

                // Act
                await product.AuthenticateAsync(authenticationContext, cancellationToken);

                // Assert
                Assert.NotNull(record);
                Assert.Same(expectedRequest, record.Request);
                Assert.Same(TraceCategories.FiltersCategory, record.Category);
                Assert.Equal(TraceLevel.Info, record.Level);
                Assert.Equal(TraceKind.End, record.Kind);
                Assert.Equal(filter.GetType().Name, record.Operator);
                Assert.Equal("AuthenticateAsync", record.Operation);
                Assert.Null(record.Exception);
                Assert.Equal(expectedMessage, record.Message);
            }
        }

        [Fact]
        public async Task AuthenticateAsync_Traces_WhenContextIsNull()
        {
            // Arrange
            CancellationToken cancellationToken = CreateCancellationToken();
            IAuthenticationFilter filter = CreateStubFilter();
            TraceRecord record = null;
            ITraceWriter tracer = CreateTracer((r) => { record = r; });
            IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
            HttpAuthenticationContext authenticationContext = null;

            // Act
            await product.AuthenticateAsync(authenticationContext, cancellationToken);

            // Assert
            Assert.NotNull(record);
            Assert.Null(record.Request);
        }

        [Fact]
        public async Task ChallengeAsync_DelegatesToInnerFilter()
        {
            // Arrange
            HttpAuthenticationChallengeContext expectedChallengeContext = CreateChallengeContext();
            CancellationToken expectedCancellationToken = CreateCancellationToken();
            IHttpActionResult expectedInnerResult = CreateDummyActionResult();
            IHttpActionResult expectedResult = CreateDummyActionResult();
            Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>();
            int calls = 0;
            mock.Setup(f => f.ChallengeAsync(expectedChallengeContext, expectedCancellationToken))
                .Callback(() => { calls++; })
                .Returns(() => Task.FromResult(expectedResult));
            IAuthenticationFilter filter = mock.Object;
            ITraceWriter tracer = CreateStubTracer();
            IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);

            // Act
            await product.ChallengeAsync(expectedChallengeContext, expectedCancellationToken);

            // Assert
            Assert.Equal(1, calls);
        }

        [Fact]
        public async Task ChallengeAsync_Traces()
        {
            // Arrange
            CancellationToken cancellationToken = CreateCancellationToken();
            IAuthenticationFilter filter = CreateStubFilter();
            TraceRecord record = null;
            ITraceWriter tracer = CreateTracer((r) => { record = r; });
            IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
            IHttpActionResult innerResult = CreateDummyActionResult();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpAuthenticationChallengeContext context = CreateChallengeContext(expectedRequest, innerResult);

                // Act
                await product.ChallengeAsync(context, cancellationToken);

                // Assert
                Assert.NotNull(record);
                Assert.Same(expectedRequest, record.Request);
                Assert.Same(TraceCategories.FiltersCategory, record.Category);
                Assert.Equal(TraceLevel.Info, record.Level);
                Assert.Equal(TraceKind.End, record.Kind);
                Assert.Equal(filter.GetType().Name, record.Operator);
                Assert.Equal("ChallengeAsync", record.Operation);
                Assert.Null(record.Exception);
                Assert.Null(record.Message);
            }
        }

        [Fact]
        public async Task ChallengeAsync_Traces_WhenContextIsNull()
        {
            // Arrange
            CancellationToken cancellationToken = CreateCancellationToken();
            IAuthenticationFilter filter = CreateStubFilter();
            TraceRecord record = null;
            ITraceWriter tracer = CreateTracer((r) => { record = r; });
            IAuthenticationFilter product = CreateProductUnderTest(filter, tracer);
            HttpAuthenticationChallengeContext context = null;

            // Act
            await product.ChallengeAsync(context, cancellationToken);

            // Assert
            Assert.NotNull(record);
            Assert.Null(record.Request);
        }

        private static HttpActionContext CreateActionContext()
        {
            return new HttpActionContext();
        }

        private static HttpActionContext CreateActionContext(HttpRequestMessage request)
        {
            HttpControllerContext controllerContext = new HttpControllerContext();
            controllerContext.Request = request;
            HttpActionContext actionContext = new HttpActionContext();
            actionContext.ControllerContext = controllerContext;
            return actionContext;
        }

        private static HttpAuthenticationContext CreateAuthenticationContext()
        {
            HttpActionContext actionContext = CreateActionContext();
            IPrincipal principal = CreateDummyPrincipal();
            return new HttpAuthenticationContext(actionContext, principal);
        }

        private static HttpAuthenticationContext CreateAuthenticationContext(HttpRequestMessage request,
                                                                             bool isPrincipalSet = true)
        {
            HttpActionContext actionContext = CreateActionContext(request);
            IPrincipal principal = (isPrincipalSet) ? CreateDummyPrincipal() : null;
            return new HttpAuthenticationContext(actionContext, principal);
        }

        private static CancellationToken CreateCancellationToken()
        {
            return new CancellationToken(canceled: true);
        }

        private static HttpAuthenticationChallengeContext CreateChallengeContext()
        {
            HttpActionContext actionContext = CreateActionContext();
            IHttpActionResult result = CreateDummyResult();
            return new HttpAuthenticationChallengeContext(actionContext, result);
        }

        private static HttpAuthenticationChallengeContext CreateChallengeContext(HttpRequestMessage request,
            IHttpActionResult result)
        {
            HttpActionContext actionContext = CreateActionContext(request);
            return new HttpAuthenticationChallengeContext(actionContext, result);
        }

        private IHttpActionResult CreateDummyActionResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static IAuthenticationFilter CreateDummyFilter()
        {
            return new Mock<IAuthenticationFilter>(MockBehavior.Strict).Object;
        }

        private static IPrincipal CreateDummyPrincipal(bool withIdentity = true)
        {
            var principalMock = new Mock<IPrincipal>(MockBehavior.Strict);
            if (withIdentity)
            {
                principalMock.Setup(p => p.Identity.Name).Returns("User");
                principalMock.Setup(p => p.Identity.AuthenticationType).Returns("Basic");
            }
            else
            {
                principalMock.Setup(p => p.Identity).Returns((IIdentity)null);
            }
            return principalMock.Object;
        }

        private static IHttpActionResult CreateDummyResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static ITraceWriter CreateDummyTracer()
        {
            return new Mock<ITraceWriter>(MockBehavior.Strict).Object;
        }

        private static AuthenticationFilterTracer CreateProductUnderTest(IAuthenticationFilter innerFilter,
            ITraceWriter traceWriter)
        {
            return new AuthenticationFilterTracer(innerFilter, traceWriter);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static IAuthenticationFilter CreateStubFilter()
        {
            Mock<IAuthenticationFilter> mock = new Mock<IAuthenticationFilter>();
            mock.Setup(f => f.AuthenticateAsync(It.IsAny<HttpAuthenticationContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult<object>(null));
            mock.Setup(f => f.ChallengeAsync(It.IsAny<HttpAuthenticationChallengeContext>(),
                It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult<object>(null));
            return mock.Object;
        }

        private static ITraceWriter CreateStubTracer()
        {
            return new Mock<ITraceWriter>().Object;
        }

        private static ITraceWriter CreateTracer(Action<TraceRecord> trace)
        {
            Mock<ITraceWriter> mock = new Mock<ITraceWriter>(MockBehavior.Strict);
            TraceRecord record = null;
            mock.Setup(t => t.Trace(It.IsAny<HttpRequestMessage>(), It.IsAny<string>(), It.IsAny<TraceLevel>(),
                It.IsAny<Action<TraceRecord>>()))
                .Callback<HttpRequestMessage, string, TraceLevel, Action<TraceRecord>>((r, c, l, a) =>
                    {
                        record = new TraceRecord(r, c, l);
                        a.Invoke(record);
                        trace.Invoke(record);
                    });
            return mock.Object;
        }

        private class AuthenticationFailureResult : IHttpActionResult
        {
            public Task<HttpResponseMessage> ExecuteAsync(CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/AuthorizationFilterAttributeTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class AuthorizationFilterAttributeTracerTest
    {
        [Fact]
        public void Equals_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<AuthorizationFilterAttribute> mockAttribute = new Mock<AuthorizationFilterAttribute>();
            mockAttribute.Setup(a => a.Equals(randomObject)).Returns(true).Verifiable();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.Equals(randomObject);

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void GetHashCode_Calls_Inner()
        {
            // Arrange
            Mock<AuthorizationFilterAttribute> mockAttribute = new Mock<AuthorizationFilterAttribute>();
            mockAttribute.Setup(a => a.GetHashCode()).Returns(1).Verifiable();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            int valueReturned = tracer.GetHashCode();

            // Assert
            Assert.Equal(1, valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void IsDefaultAttribute_Calls_Inner()
        {
            // Arrange
            Mock<AuthorizationFilterAttribute> mockAttribute = new Mock<AuthorizationFilterAttribute>();
            mockAttribute.Setup(a => a.IsDefaultAttribute()).Returns(true).Verifiable();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.IsDefaultAttribute();

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void Match_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<AuthorizationFilterAttribute> mockAttribute = new Mock<AuthorizationFilterAttribute>();
            mockAttribute.Setup(a => a.Match(randomObject)).Returns(true).Verifiable();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.Match(randomObject);

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void TypeId_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<AuthorizationFilterAttribute> mockAttribute = new Mock<AuthorizationFilterAttribute>();
            mockAttribute.Setup(a => a.TypeId).Returns(randomObject).Verifiable();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            object valueReturned = tracer.TypeId;

            // Assert
            Assert.Same(randomObject, valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void AllowMultiple_Calls_Inner()
        {
            // Arrange
            Mock<AuthorizationFilterAttribute> mockAttribute = new Mock<AuthorizationFilterAttribute>();
            mockAttribute.Setup(a => a.AllowMultiple).Returns(true).Verifiable();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.AllowMultiple;

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_Traces()
        {
            // Arrange
            Mock<AuthorizationFilterAttribute> mockAttr = new Mock<AuthorizationFilterAttribute>() { CallBase = true };
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            Func<Task<HttpResponseMessage>> continuation = () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TestTraceWriter traceWriter = new TestTraceWriter();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttr.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnAuthorizationAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "OnAuthorizationAsync" },
            };

            // Act
            var filter = (IAuthorizationFilter)tracer;
            await filter.ExecuteAuthorizationFilterAsync(actionContext, CancellationToken.None, continuation);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_Throws_And_Traces_When_Inner_OnException_Throws()
        {
            // Arrange
            Mock<AuthorizationFilterAttribute> mockAttr = new Mock<AuthorizationFilterAttribute>() { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockAttr.Setup(a => a.OnAuthorization(It.IsAny<HttpActionContext>())).Throws(exception);
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            Func<Task<HttpResponseMessage>> continuation = () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TestTraceWriter traceWriter = new TestTraceWriter();
            AuthorizationFilterAttributeTracer tracer = new AuthorizationFilterAttributeTracer(mockAttr.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnAuthorizationAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End,  Operation = "OnAuthorizationAsync" }
            };

            // Act
            Exception thrown =
                await Assert.ThrowsAsync<InvalidOperationException>(
                    () => ((IAuthorizationFilter)tracer).ExecuteAuthorizationFilterAsync(actionContext, CancellationToken.None, continuation));

            // Assert
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_AuthorizationFilterAttributeTracer_Returns_AuthorizationFilterAttribute()
        {
            // Arrange
            AuthorizationFilterAttribute expectedInner = new Mock<AuthorizationFilterAttribute>().Object;
            AuthorizationFilterAttributeTracer productUnderTest = new AuthorizationFilterAttributeTracer(expectedInner, new TestTraceWriter());

            // Act
            AuthorizationFilterAttribute actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_AuthorizationFilterAttributeTracer_Returns_AuthorizationFilterAttribute()
        {
            // Arrange
            AuthorizationFilterAttribute expectedInner = new Mock<AuthorizationFilterAttribute>().Object;
            AuthorizationFilterAttributeTracer productUnderTest = new AuthorizationFilterAttributeTracer(expectedInner, new TestTraceWriter());

            // Act
            AuthorizationFilterAttribute actualInner = Decorator.GetInner(productUnderTest as AuthorizationFilterAttribute);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/AuthorizationFilterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class AuthorizationFilterTracerTest
    {
        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_Traces()
        {
            // Arrange
            HttpResponseMessage response = new HttpResponseMessage();
            Mock<IAuthorizationFilter> mockFilter = new Mock<IAuthorizationFilter>() { CallBase = true };
            mockFilter.Setup(f => f.ExecuteAuthorizationFilterAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>(), It.IsAny<Func<Task<HttpResponseMessage>>>())).Returns(Task.FromResult(response));
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            Func<Task<HttpResponseMessage>> continuation = () => Task.FromResult<HttpResponseMessage>(new HttpResponseMessage());
            TestTraceWriter traceWriter = new TestTraceWriter();
            AuthorizationFilterTracer tracer = new AuthorizationFilterTracer(mockFilter.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteAuthorizationFilterAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "ExecuteAuthorizationFilterAsync" },
            };

            // Act
            var filter = (IAuthorizationFilter)tracer;
            await filter.ExecuteAuthorizationFilterAsync(actionContext, CancellationToken.None, continuation);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteAuthorizationFilterAsync_Faults_And_Traces_When_Inner_Faults()
        {
            // Arrange
            Mock<IAuthorizationFilter> mockAttr = new Mock<IAuthorizationFilter>() { CallBase = true };
            HttpResponseMessage response = new HttpResponseMessage();
            InvalidOperationException exception = new InvalidOperationException("test");
            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>(response);
            tcs.TrySetException(exception);
            mockAttr.Setup(a => a.ExecuteAuthorizationFilterAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>(), It.IsAny<Func<Task<HttpResponseMessage>>>())).Returns(tcs.Task);
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionContext actionContext = ContextUtil.CreateActionContext(actionDescriptor: mockActionDescriptor.Object);
            Func<Task<HttpResponseMessage>> continuation = () => Task.FromResult<HttpResponseMessage>(response);
            TestTraceWriter traceWriter = new TestTraceWriter();
            AuthorizationFilterTracer tracer = new AuthorizationFilterTracer(mockAttr.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteAuthorizationFilterAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End,  Operation = "ExecuteAuthorizationFilterAsync" }
            };

            // Act & Assert
            Task task = ((IAuthorizationFilter)tracer).ExecuteAuthorizationFilterAsync(actionContext, CancellationToken.None, continuation);
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);

            // Assert
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_AuthorizationFilterTracer_Returns_IAuthorizationFilter()
        {
            // Arrange
            IAuthorizationFilter expectedInner = new Mock<IAuthorizationFilter>().Object;
            AuthorizationFilterTracer productUnderTest = new AuthorizationFilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IAuthorizationFilter actualInner = productUnderTest.Inner as IAuthorizationFilter;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_AuthorizationFilterTracer_Returns_IAuthorizationFilter()
        {
            // Arrange
            IAuthorizationFilter expectedInner = new Mock<IAuthorizationFilter>().Object;
            AuthorizationFilterTracer productUnderTest = new AuthorizationFilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IAuthorizationFilter actualInner = Decorator.GetInner(productUnderTest as IAuthorizationFilter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/BufferedMediaTypeFormatterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class BufferedMediaTypeFormatterTracerTest : MediaTypeFormatterTracerTestBase<BufferedMediaTypeFormatter>
    {
        public override MediaTypeFormatter CreateTracer(BufferedMediaTypeFormatter formatter, HttpRequestMessage request, ITraceWriter traceWriter)
        {
            return new BufferedMediaTypeFormatterTracer(formatter, traceWriter, request);
        }

        [Fact]
        public void BufferSize_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
            BufferedMediaTypeFormatter innerFormatter = mockFormatter.Object;
            innerFormatter.BufferSize = innerFormatter.BufferSize + 1;
            BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.BufferSize, tracer.BufferSize);
        }

        [Fact]
        public void ReadFromStream_Traces()
        {
            // Arrange
            Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
            mockFormatter.Setup(f => f.ReadFromStream(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns("sampleValue");
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ReadFromStream" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ReadFromStream" }
            };

            // Act
            string valueReturned = tracer.ReadFromStream(typeof(string), new MemoryStream(), request.Content, null) as string;

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Equal("sampleValue", valueReturned);
        }

        [Fact]
        public void ReadFromStreamWithCancellationToken_Traces()
        {
            // Arrange
            Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
            mockFormatter.Setup(f => f.ReadFromStream(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns("sampleValue");
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ReadFromStream" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ReadFromStream" }
            };

            // Act
            string valueReturned = tracer.ReadFromStream(typeof(string), new MemoryStream(), request.Content, null, CancellationToken.None) as string;

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Equal("sampleValue", valueReturned);
        }

        [Fact]
        public void ReadFromStream_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
            mockFormatter.Setup(
                f => f.ReadFromStream(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>())).Throws(exception);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ReadFromStream" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ReadFromStream" }
            };

            // Act
            Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.ReadFromStream(typeof(string), new MemoryStream(), request.Content, null));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void WriteToStream_Traces()
        {
            // Arrange
            Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
            mockFormatter.Setup(
                f => f.WriteToStream(It.IsAny<Type>(), It.IsAny<Object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>()));
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "WriteToStream" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "WriteToStream" }
            };

            // Act
            tracer.WriteToStream(typeof(string), "sampleValue", new MemoryStream(), request.Content);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void WriteToStreamWithCancellationToken_Traces()
        {
            // Arrange
            Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
            mockFormatter.Setup(
                f => f.WriteToStream(It.IsAny<Type>(), It.IsAny<Object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>()));
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "WriteToStream" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "WriteToStream" }
            };

            // Act
            tracer.WriteToStream(typeof(string), "sampleValue", new MemoryStream(), request.Content, CancellationToken.None);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void WriteToStream_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            Mock<BufferedMediaTypeFormatter> mockFormatter = new Mock<BufferedMediaTypeFormatter>() { CallBase = true };
            mockFormatter.Setup(f => f.WriteToStream(It.IsAny<Type>(), It.IsAny<Object>(), It.IsAny<Stream>(),
                                                     It.IsAny<HttpContent>()))
                         .Throws(exception);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            BufferedMediaTypeFormatterTracer tracer = new BufferedMediaTypeFormatterTracer(mockFormatter.Object, traceWriter, request);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "WriteToStream" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "WriteToStream" }
            };

            // Act
            Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.WriteToStream(typeof(string), "sampleValue", new MemoryStream(), request.Content));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_BufferedMediaTypeFormatterTracer_Returns_BufferedMediaTypeFormatter()
        {
            // Arrange
            BufferedMediaTypeFormatter expectedInner = new Mock<BufferedMediaTypeFormatter>().Object;
            BufferedMediaTypeFormatterTracer productUnderTest = new BufferedMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            BufferedMediaTypeFormatter actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_BufferedMediaTypeFormatterTracer_Returns_BufferedMediaTypeFormatter()
        {
            // Arrange
            BufferedMediaTypeFormatter expectedInner = new Mock<BufferedMediaTypeFormatter>().Object;
            BufferedMediaTypeFormatterTracer productUnderTest = new BufferedMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            BufferedMediaTypeFormatter actualInner = Decorator.GetInner(productUnderTest as BufferedMediaTypeFormatter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/ContentNegotiatorTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class ContentNegotiatorTracerTest
    {
        private readonly HttpRequestMessage _request = new HttpRequestMessage();
        private readonly Mock<IContentNegotiator> _mockNegotiator = new Mock<IContentNegotiator>();
        private readonly ContentNegotiatorTracer _tracer;
        private readonly TestTraceWriter _traceWriter = new TestTraceWriter();

        public ContentNegotiatorTracerTest()
        {
            _tracer = new ContentNegotiatorTracer(_mockNegotiator.Object, _traceWriter);
        }

        [Fact]
        public void Negotiate_Calls_Inner_Negotiate()
        {
            // Act
            ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]);

            // Assert
            _mockNegotiator.Verify(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>()), Times.Once());
        }

        [Fact]
        public void Negotiate_Returns_Inner_MediaType()
        {
            // Arrange
            MediaTypeHeaderValue expectedMediaType = new MediaTypeHeaderValue("application/xml");
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Returns(
                                new ContentNegotiationResult(new JsonMediaTypeFormatter(), expectedMediaType));

            // Act
            var result = ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]);

            // Assert
            Assert.Same(expectedMediaType, result.MediaType);
        }

        [Fact]
        public void Negotiate_Returns_Wrapped_Inner_XmlFormatter()
        {
            // Arrange
            MediaTypeFormatter expectedFormatter = new XmlMediaTypeFormatter();
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Returns(
                                new ContentNegotiationResult(expectedFormatter, null));

            // Act
            var result = ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]);

            // Assert
            Assert.IsType<XmlMediaTypeFormatterTracer>(result.Formatter);
        }

        [Fact]
        public void Negotiate_Returns_Wrapped_Inner_JsonFormatter()
        {
            // Arrange
            MediaTypeFormatter expectedFormatter = new JsonMediaTypeFormatter();
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Returns(
                                new ContentNegotiationResult(expectedFormatter, null));

            // Act
            var result = ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]);

            // Assert
            Assert.IsType<JsonMediaTypeFormatterTracer>(result.Formatter);
        }

        [Fact]
        public void Negotiate_Returns_Wrapped_Inner_FormUrlEncodedFormatter()
        {
            // Arrange
            MediaTypeFormatter expectedFormatter = new FormUrlEncodedMediaTypeFormatter();
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Returns(
                                new ContentNegotiationResult(expectedFormatter, null));

            // Act
            var result = ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]);

            // Assert
            Assert.IsType<FormUrlEncodedMediaTypeFormatterTracer>(result.Formatter);
        }

        [Fact]
        public void Negotiate_Returns_Null_Inner_Formatter()
        {
            // Arrange
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Returns(
                                value: null);

            // Act
            var result = ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]);

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public void Negotiate_Traces_BeginEnd()
        {
            // Arrange
            MediaTypeFormatter expectedFormatter = new XmlMediaTypeFormatter();
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Returns(
                                new ContentNegotiationResult(expectedFormatter, null));
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End }
            };

            // Act
            ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, _traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Negotiate_Throws_When_Inner_Throws()
        {
            // Arrange
            MediaTypeFormatter expectedFormatter = new XmlMediaTypeFormatter();
            InvalidOperationException expectedException = new InvalidOperationException("test");
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Throws(expectedException);

            // Act & Assert
            InvalidOperationException actualException = Assert.Throws<InvalidOperationException>(() => ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]));

            // Assert
            Assert.Same(expectedException, actualException);
        }

        [Fact]
        public void Negotiate_Traces_BeginEnd_When_Inner_Throws()
        {
            // Arrange
            MediaTypeFormatter expectedFormatter = new XmlMediaTypeFormatter();
            InvalidOperationException expectedException = new InvalidOperationException("test");
            _mockNegotiator.Setup(
                n =>
                n.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(),
                            It.IsAny<IEnumerable<MediaTypeFormatter>>())).Throws(expectedException);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_request, TraceCategories.FormattingCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => ((IContentNegotiator)_tracer).Negotiate(typeof(int), _request, new MediaTypeFormatter[0]));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, _traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(expectedException, _traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_ContentNegotiatiorTracer_Returns_IContentNegotiator()
        {
            // Arrange
            IContentNegotiator expectedInner = new Mock<IContentNegotiator>().Object;
            ContentNegotiatorTracer productUnderTest = new ContentNegotiatorTracer(expectedInner, new TestTraceWriter());

            // Act
            IContentNegotiator actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_ContentNegotiatiorTracer_Returns_IContentNegotiator()
        {
            // Arrange
            IContentNegotiator expectedInner = new Mock<IContentNegotiator>().Object;
            ContentNegotiatorTracer productUnderTest = new ContentNegotiatorTracer(expectedInner, new TestTraceWriter());

            // Act
            IContentNegotiator actualInner = Decorator.GetInner(productUnderTest as IContentNegotiator);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/DefaultHttpControllerTypeResolverTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Web.Http.Dispatcher;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class DefaultHttpControllerTypeResolverTracerTest
    {
        private static readonly string ExceptionMessage = "Remember my name";
        private readonly List<Type> ExpectedTypes;
        private readonly List<TraceRecord> ExpectedTraces;

        private readonly Mock<MockableAssembly>[] Assemblies;
        private readonly Mock<IAssembliesResolver> AssembliesResolver;
        private readonly Mock<DefaultHttpControllerTypeResolver> HttpControllerTypeResolver;

        public DefaultHttpControllerTypeResolverTracerTest()
        {
            ExpectedTypes = new List<Type>
            {
                typeof(ValidController), typeof(UsersRpcController), typeof(UsersController),
            };

            Type[] fine1Types = new Type[]
            {
                typeof(DefaultHttpControllerTypeResolverTracerTest),
                null,
                typeof(ValidController),
            };
            Type[] poorTypes = new Type[]
            {
                typeof(string),
                null,
                typeof(Action),
                null,
                typeof(UsersRpcController),
            };
            Type[] fine2Types = new Type[]
            {
                typeof(DefaultHttpControllerTypeResolver),
                null,
                typeof(DefaultHttpControllerTypeResolverTracer),
                null,
                typeof(UsersController)
            };

            Exception worseException = new Exception(ExceptionMessage);
            Exception poorException = new ReflectionTypeLoadException(poorTypes, new Exception[] { worseException });
            ExpectedTraces = new List<TraceRecord>
            {
                new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Debug)
                {
                    Kind = TraceKind.Begin,
                    Operator = "DefaultHttpControllerTypeResolverProxy", // Moq type name
                    Operation = "GetControllerTypes",
                },
                new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Warn)
                {
                    Kind = TraceKind.Trace,
                    Exception = poorException,
                    Message = "Exception thrown while getting types from 'PoorAssembly'.",
                },
                new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Warn)
                {
                    Kind = TraceKind.Trace,
                    Exception = worseException,
                    Message = "Exception thrown while getting types from 'WorseAssembly'.",
                },
                new TraceRecord(null, TraceCategories.ControllersCategory, TraceLevel.Debug)
                {
                    Kind = TraceKind.End,
                    Operator = "DefaultHttpControllerTypeResolverProxy",
                    Operation = "GetControllerTypes",
                },
            };

            Mock<MockableAssembly> fine1Assembly = new Mock<MockableAssembly>(MockBehavior.Strict);
            fine1Assembly.Setup(assembly => assembly.GetTypes()).Returns(fine1Types);
            fine1Assembly.SetupGet(assembly => assembly.IsDynamic).Returns(false);

            Exception[] exceptions = new Exception[] { new Exception(ExceptionMessage), };
            Mock<MockableAssembly> poorAssembly = new Mock<MockableAssembly>(MockBehavior.Strict);
            poorAssembly.Setup(assembly => assembly.GetTypes()).Throws(poorException);
            poorAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(false);
            poorAssembly.SetupGet(assembly => assembly.FullName).Returns("PoorAssembly");

            Mock<MockableAssembly> worseAssembly = new Mock<MockableAssembly>(MockBehavior.Strict);
            worseAssembly.Setup(assembly => assembly.GetTypes()).Throws(worseException);
            worseAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(false);
            worseAssembly.SetupGet(assembly => assembly.FullName).Returns("WorseAssembly");

            Mock<MockableAssembly> fine2Assembly = new Mock<MockableAssembly>(MockBehavior.Strict);
            fine2Assembly.Setup(assembly => assembly.GetTypes()).Returns(fine2Types);
            fine2Assembly.SetupGet(assembly => assembly.IsDynamic).Returns(false);

            Mock<MockableAssembly> dynamicAssembly = new Mock<MockableAssembly>(MockBehavior.Strict);
            dynamicAssembly.SetupGet(assembly => assembly.IsDynamic).Returns(true);

            Assemblies = new Mock<MockableAssembly>[]
            {
                fine1Assembly,
                poorAssembly,
                worseAssembly,
                fine2Assembly,
                dynamicAssembly,
            };

            AssembliesResolver = new Mock<IAssembliesResolver>(MockBehavior.Strict);
            AssembliesResolver.Setup(resolver => resolver.GetAssemblies()).Returns(
                Assemblies.Select(assembly => (Assembly)assembly.Object).AsCollection());

            HttpControllerTypeResolver =
                new Mock<DefaultHttpControllerTypeResolver>() { CallBase = true, };
        }

        [Fact]
        public void GetControllerTypes_CallsMocks()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            DefaultHttpControllerTypeResolverTracer tracer =
                new DefaultHttpControllerTypeResolverTracer(HttpControllerTypeResolver.Object, traceWriter);

            // Act
            tracer.GetControllerTypes(AssembliesResolver.Object);

            // Assert (particularly important tracer delegates to original DefaultHttpControllerTypeResolver)
            HttpControllerTypeResolver.Verify(
                controller => controller.GetControllerTypes(AssembliesResolver.Object), Times.Once());

            // Predicate is not called on null entries or internal types in the Type arrays (see TypeIsVisible)
            HttpControllerTypeResolver.VerifyGet(controller => controller.IsControllerTypePredicate, Times.Exactly(7));

            AssembliesResolver.Verify(resolver => resolver.GetAssemblies(), Times.Once());
            foreach (Mock<MockableAssembly> mock in Assemblies)
            {
                mock.VerifyGet(assembly => assembly.IsDynamic, Times.Once());
                mock.Verify(assembly => assembly.GetTypes(), mock.Object.IsDynamic ? Times.Never() : Times.Once());
            }
        }

        [Fact]
        public void GetControllerTypes_ReturnsExpectedTypes()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            DefaultHttpControllerTypeResolverTracer tracer =
                new DefaultHttpControllerTypeResolverTracer(HttpControllerTypeResolver.Object, traceWriter);

            // Act
            ICollection<Type> types = tracer.GetControllerTypes(AssembliesResolver.Object);

            // Assert
            Assert.NotNull(types);
            Assert.NotEmpty(types);
            Assert.Equal(ExpectedTypes, types);
        }

        [Fact]
        public void GetControllerTypes_TracesAsExpected()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            DefaultHttpControllerTypeResolverTracer tracer =
                new DefaultHttpControllerTypeResolverTracer(HttpControllerTypeResolver.Object, traceWriter);

            // Act
            ICollection<Type> types = tracer.GetControllerTypes(AssembliesResolver.Object);

            // Assert
            Assert.NotNull(traceWriter.Traces);
            Assert.Equal(ExpectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void InnerProperty_ReturnsOriginal()
        {
            // Arrange
            DefaultHttpControllerTypeResolver expectedResolver = HttpControllerTypeResolver.Object;
            TestTraceWriter traceWriter = new TestTraceWriter();
            DefaultHttpControllerTypeResolverTracer tracer =
                new DefaultHttpControllerTypeResolverTracer(HttpControllerTypeResolver.Object, traceWriter);

            // Act
            DefaultHttpControllerTypeResolver resolver = tracer.Inner;

            // Assert
            Assert.NotNull(resolver);
            Assert.Same(expectedResolver, resolver);
        }

        [Fact]
        public void Decorator_GetInner_ReturnsOriginal()
        {
            // Arrange
            DefaultHttpControllerTypeResolver expectedResolver = HttpControllerTypeResolver.Object;
            TestTraceWriter traceWriter = new TestTraceWriter();
            DefaultHttpControllerTypeResolverTracer tracer =
                new DefaultHttpControllerTypeResolverTracer(HttpControllerTypeResolver.Object, traceWriter);

            // Act
            DefaultHttpControllerTypeResolver resolver = Decorator.GetInner(tracer as DefaultHttpControllerTypeResolver);

            // Assert
            Assert.NotNull(resolver);
            Assert.Same(expectedResolver, resolver);
        }

        [Fact]
        public void IsControllerTypePredicateProperty_SameAsInInner()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            DefaultHttpControllerTypeResolverTracer tracer =
                new DefaultHttpControllerTypeResolverTracer(HttpControllerTypeResolver.Object, traceWriter);

            // Act
            Predicate<Type> innerPredicate = HttpControllerTypeResolver.Object.IsControllerTypePredicate;
            Predicate<Type> tracerPredicate = tracer.IsControllerTypePredicate;

            // Assert
            Assert.NotNull(tracerPredicate);
            Assert.Same(innerPredicate, tracerPredicate);
        }

        [Fact]
        public void IsControllerTypePredicateProperty_RoundTrips()
        {
            // Arrange
            Predicate<Type> expectedPredicate = type => type != null;
            DefaultHttpControllerTypeResolver resolver = new DefaultHttpControllerTypeResolver(expectedPredicate);

            TestTraceWriter traceWriter = new TestTraceWriter();
            DefaultHttpControllerTypeResolverTracer tracer =
                new DefaultHttpControllerTypeResolverTracer(resolver, traceWriter);

            // Act
            Predicate<Type> predicate = tracer.IsControllerTypePredicate;

            // Assert
            Assert.NotNull(predicate);
            Assert.Same(expectedPredicate, predicate);
        }

        // Workaround Moq / Castle requirement that ISerializable object must have the ISerializable constructor.
        // Assembly implements ISerializable but lacks the constructor.
        public abstract class MockableAssembly : Assembly
        {
            public MockableAssembly()
            {
            }

            public MockableAssembly(SerializationInfo info, StreamingContext context)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/ExceptionFilterAttributeTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class ExceptionFilterAttributeTracerTest
    {
        [Fact]
        public void Equals_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<ExceptionFilterAttribute> mockAttribute = new Mock<ExceptionFilterAttribute>();
            mockAttribute.Setup(a => a.Equals(randomObject)).Returns(true).Verifiable();
            ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.Equals(randomObject);

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void GetHashCode_Calls_Inner()
        {
            // Arrange
            Mock<ExceptionFilterAttribute> mockAttribute = new Mock<ExceptionFilterAttribute>();
            mockAttribute.Setup(a => a.GetHashCode()).Returns(1).Verifiable();
            ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            int valueReturned = tracer.GetHashCode();

            // Assert
            Assert.Equal(1, valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void IsDefaultAttribute_Calls_Inner()
        {
            // Arrange
            Mock<ExceptionFilterAttribute> mockAttribute = new Mock<ExceptionFilterAttribute>();
            mockAttribute.Setup(a => a.IsDefaultAttribute()).Returns(true).Verifiable();
            ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.IsDefaultAttribute();

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void Match_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<ExceptionFilterAttribute> mockAttribute = new Mock<ExceptionFilterAttribute>();
            mockAttribute.Setup(a => a.Match(randomObject)).Returns(true).Verifiable();
            ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.Match(randomObject);

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void TypeId_Calls_Inner()
        {
            // Arrange
            object randomObject = new Object();
            Mock<ExceptionFilterAttribute> mockAttribute = new Mock<ExceptionFilterAttribute>();
            mockAttribute.Setup(a => a.TypeId).Returns(randomObject).Verifiable();
            ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            object valueReturned = tracer.TypeId;

            // Assert
            Assert.Same(randomObject, valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public void AllowMultiple_Calls_Inner()
        {
            // Arrange
            Mock<ExceptionFilterAttribute> mockAttribute = new Mock<ExceptionFilterAttribute>();
            mockAttribute.Setup(a => a.AllowMultiple).Returns(true).Verifiable();
            ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttribute.Object, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.AllowMultiple;

            // Assert
            Assert.True(valueReturned);
            mockAttribute.Verify();
        }

        [Fact]
        public async Task ExecuteExceptionFilterAsync_Traces()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseMessage response = new HttpResponseMessage();
            Mock<ExceptionFilterAttribute> mockAttr = new Mock<ExceptionFilterAttribute>() { CallBase = true };
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
            TestTraceWriter traceWriter = new TestTraceWriter();
            ExceptionFilterAttributeTracer tracer = new ExceptionFilterAttributeTracer(mockAttr.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnExceptionAsync" },
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "OnExceptionAsync" },
            };

            // Act
            var filter = (IExceptionFilter)tracer;
            await filter.ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteExceptionFilterAsync_Throws_And_Traces_When_Inner_OnException_Throws()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseMessage response = new HttpResponseMessage();
            Mock<ExceptionFilterAttribute> mockAttr = new Mock<ExceptionFilterAttribute>() { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockAttr.Setup(a => a.OnException(It.IsAny<HttpActionExecutedContext>())).Callback(() => { throw exception; });
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));
            HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
            TestTraceWriter traceWriter = new TestTraceWriter();
            IExceptionFilter tracer = new ExceptionFilterAttributeTracer(mockAttr.Object, traceWriter) as IExceptionFilter;
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "OnExceptionAsync" },
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End,  Operation = "OnExceptionAsync" }
            };

            // Act
            // We separate the task creation and the wait, to verify we don't throw at task creation
            // and that the exception flows inside the task (even if an Aggregate Exception was thrown).
            var task = tracer.ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);

            // Assert
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_ExceptionFilterAttributeTracer_Returns_ExceptionFilterAttribute()
        {
            // Arrange
            ExceptionFilterAttribute expectedInner = new Mock<ExceptionFilterAttribute>().Object;
            ExceptionFilterAttributeTracer productUnderTest = new ExceptionFilterAttributeTracer(expectedInner, new TestTraceWriter());

            // Act
            ExceptionFilterAttribute actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_ExceptionFilterAttributeTracer_Returns_ExceptionFilterAttribute()
        {
            // Arrange
            ExceptionFilterAttribute expectedInner = new Mock<ExceptionFilterAttribute>().Object;
            ExceptionFilterAttributeTracer productUnderTest = new ExceptionFilterAttributeTracer(expectedInner, new TestTraceWriter());

            // Act
            ExceptionFilterAttribute actualInner = Decorator.GetInner(productUnderTest as ExceptionFilterAttribute);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/ExceptionFilterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class ExceptionFilterTracerTest
    {
        [Fact]
        public async Task ExecuteExceptionFilterAsync_Traces()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseMessage response = new HttpResponseMessage();
            Mock<IExceptionFilter> mockFilter = new Mock<IExceptionFilter>() { CallBase = true };
            mockFilter.Setup(f => f.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(), It.IsAny<CancellationToken>()))
                .Returns(TaskHelpers.Completed());
            HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
            TestTraceWriter traceWriter = new TestTraceWriter();
            ExceptionFilterTracer tracer = new ExceptionFilterTracer(mockFilter.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteExceptionFilterAsync" },
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.End,  Operation = "ExecuteExceptionFilterAsync" },
            };

            // Act
            var filter = (IExceptionFilter)tracer;
            await filter.ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteExceptionFilterAsync_Faults_And_Traces_When_Inner_Faults()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseMessage response = new HttpResponseMessage();
            Mock<IExceptionFilter> mockFilter = new Mock<IExceptionFilter>() { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>(null);
            tcs.TrySetException(exception);
            mockFilter.Setup(a => a.ExecuteExceptionFilterAsync(It.IsAny<HttpActionExecutedContext>(), It.IsAny<CancellationToken>())).Returns(tcs.Task);
            HttpActionExecutedContext actionExecutedContext = ContextUtil.GetActionExecutedContext(request, response);
            TestTraceWriter traceWriter = new TestTraceWriter();
            ExceptionFilterTracer tracer = new ExceptionFilterTracer(mockFilter.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteExceptionFilterAsync" },
                new TraceRecord(request, TraceCategories.FiltersCategory, TraceLevel.Error) { Kind = TraceKind.End,  Operation = "ExecuteExceptionFilterAsync" }
            };

            // Act
            Task task = ((IExceptionFilter)tracer).ExecuteExceptionFilterAsync(actionExecutedContext, CancellationToken.None);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_ExceptionFilterTracer_Returns_IExceptionFilter()
        {
            // Arrange
            IExceptionFilter expectedInner = new Mock<IExceptionFilter>().Object;
            ExceptionFilterTracer productUnderTest = new ExceptionFilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IExceptionFilter actualInner = productUnderTest.Inner as IExceptionFilter;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_ExceptionFilterTracer_Returns_IExceptionFilter()
        {
            // Arrange
            IExceptionFilter expectedInner = new Mock<IExceptionFilter>().Object;
            ExceptionFilterTracer productUnderTest = new ExceptionFilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IExceptionFilter actualInner = Decorator.GetInner(productUnderTest.Inner as IExceptionFilter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/FilterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class FilterTracerTest
    {
        [Fact]
        public void CreateFilterTracers_IFilter_With_IFilter_Returns_Single_Wrapped_IFilter()
        {
            // Arrange
            Mock<IFilter> mockFilter = new Mock<IFilter>();

            // Act
            IEnumerable<IFilter> wrappedFilters = FilterTracer.CreateFilterTracers(mockFilter.Object, new TestTraceWriter());

            // Assert
            IFilter wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<FilterTracer>(wrappedFilter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_IActionFilter_Returns_Single_Wrapped_IActionFilter()
        {
            // Arrange
            Mock<IActionFilter> mockFilter = new Mock<IActionFilter>();

            // Act
            IEnumerable<IFilter> wrappedFilters = FilterTracer.CreateFilterTracers(mockFilter.Object, new TestTraceWriter());

            // Assert
            IFilter wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ActionFilterTracer>(wrappedFilter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_IExceptionFilter_Returns_Single_Wrapped_IExceptionFilter()
        {
            // Arrange
            Mock<IExceptionFilter> mockFilter = new Mock<IExceptionFilter>();

            // Act
            IEnumerable<IFilter> wrappedFilters = FilterTracer.CreateFilterTracers(mockFilter.Object, new TestTraceWriter());

            // Assert
            IFilter wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ExceptionFilterTracer>(wrappedFilter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_IAuthenticationFilter_Returns_Single_Wrapped_IAuthenticationFilter()
        {
            // Arrange
            IAuthenticationFilter expectedInner = new Mock<IAuthenticationFilter>().Object;
            ITraceWriter expectedTraceWriter = new TestTraceWriter();

            // Act
            IEnumerable<IFilter> tracers = FilterTracer.CreateFilterTracers(expectedInner, expectedTraceWriter);

            // Assert
            Assert.NotNull(tracers);
            IFilter untypedFilter = Assert.Single(tracers);
            AuthenticationFilterTracer tracer = Assert.IsType<AuthenticationFilterTracer>(untypedFilter);
            Assert.Same(expectedInner, tracer.InnerFilter);
            Assert.Same(expectedTraceWriter, tracer.TraceWriter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_IAuthorizationFilter_Returns_Single_Wrapped_IAuthorizationFilter()
        {
            // Arrange
            Mock<IAuthorizationFilter> mockFilter = new Mock<IAuthorizationFilter>();

            // Act
            IEnumerable<IFilter> wrappedFilters = FilterTracer.CreateFilterTracers(mockFilter.Object, new TestTraceWriter());

            // Assert
            IFilter wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<AuthorizationFilterTracer>(wrappedFilter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_IOverrideFilter_Returns_Single_Wrapped_IOverrideFilter()
        {
            // Arrange
            IOverrideFilter expectedInner = new Mock<IOverrideFilter>().Object;
            ITraceWriter expectedTraceWriter = new TestTraceWriter();

            // Act
            IEnumerable<IFilter> tracers = FilterTracer.CreateFilterTracers(expectedInner, expectedTraceWriter);

            // Assert
            Assert.NotNull(tracers);
            IFilter untypedFilter = Assert.Single(tracers);
            OverrideFilterTracer tracer = Assert.IsType<OverrideFilterTracer>(untypedFilter);
            Assert.Same(expectedInner, tracer.InnerFilter);
            Assert.Same(expectedTraceWriter, tracer.TraceWriter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_ActionFilterAttribute_Returns_Single_Wrapped_Filter()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockFilter = new Mock<ActionFilterAttribute>();

            // Act
            IEnumerable<IFilter> wrappedFilters = FilterTracer.CreateFilterTracers(mockFilter.Object, new TestTraceWriter());

            // Assert
            IFilter wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ActionFilterAttributeTracer>(wrappedFilter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_ExceptionFilterAttribute_Returns_Single_Wrapped_Filter()
        {
            // Arrange
            Mock<ExceptionFilterAttribute> mockFilter = new Mock<ExceptionFilterAttribute>();

            // Act
            IEnumerable<IFilter> wrappedFilters = FilterTracer.CreateFilterTracers(mockFilter.Object, new TestTraceWriter());

            // Assert
            IFilter wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ExceptionFilterAttributeTracer>(wrappedFilter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_AuthorizationFilterAttribute_Returns_Single_Wrapped_Filter()
        {
            // Arrange
            Mock<AuthorizationFilterAttribute> mockFilter = new Mock<AuthorizationFilterAttribute>();

            // Act
            IEnumerable<IFilter> wrappedFilters = FilterTracer.CreateFilterTracers(mockFilter.Object, new TestTraceWriter());

            // Assert
            IFilter wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<AuthorizationFilterAttributeTracer>(wrappedFilter);
        }

        [Fact]
        public void CreateFilterTracers_IFilter_With_All_Filter_Interfaces_Returns_Wrapped_Filters_For_Each_Filter()
        {
            // Arrange
            IFilter filter = new TestFilterAllBehaviors();

            // Act
            IFilter[] wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter()).ToArray();

            // Assert
            Assert.Equal(5, wrappedFilters.Length);
            Assert.Single(wrappedFilters.OfType<ActionFilterTracer>());
            Assert.Single(wrappedFilters.OfType<AuthorizationFilterTracer>());
            Assert.Single(wrappedFilters.OfType<AuthenticationFilterTracer>());
            Assert.Single(wrappedFilters.OfType<ExceptionFilterTracer>());
            Assert.Single(wrappedFilters.OfType<OverrideFilterTracer>());
        }

        [Fact]
        public void CreateFilterTracers_With_IFilter_Returns_Single_Wrapped_IFilter()
        {
            // Arrange
            Mock<IFilter> mockFilter = new Mock<IFilter>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Action);

            // Act
            IEnumerable<FilterInfo> wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter());

            // Assert
            FilterInfo wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<FilterTracer>(wrappedFilter.Instance);
        }

        [Fact]
        public void CreateFilterTracers_With_IActionFilter_Returns_Single_Wrapped_IActionFilter()
        {
            // Arrange
            Mock<IActionFilter> mockFilter = new Mock<IActionFilter>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Action);

            // Act
            IEnumerable<FilterInfo> wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter());

            // Assert
            FilterInfo wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ActionFilterTracer>(wrappedFilter.Instance);
        }

        [Fact]
        public void CreateFilterTracers_With_IExceptionFilter_Returns_Single_Wrapped_IExceptionFilter()
        {
            // Arrange
            Mock<IExceptionFilter> mockFilter = new Mock<IExceptionFilter>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Action);

            // Act
            IEnumerable<FilterInfo> wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter());

            // Assert
            FilterInfo wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ExceptionFilterTracer>(wrappedFilter.Instance);
        }

        [Fact]
        public void CreateFilterTracers_With_IAuthenticationFilter_Returns_Single_Wrapped_IAuthenticationFilter()
        {
            // Arrange
            IAuthenticationFilter expectedInner = new Mock<IAuthenticationFilter>().Object;
            FilterInfo inputFilterInfo = new FilterInfo(expectedInner, FilterScope.Action);
            ITraceWriter expectedTraceWriter = new TestTraceWriter();

            // Act
            IEnumerable<FilterInfo> filters = FilterTracer.CreateFilterTracers(inputFilterInfo, expectedTraceWriter);

            // Assert
            Assert.NotNull(filters);
            FilterInfo filterInfo = Assert.Single(filters);
            Assert.NotNull(filterInfo);
            IFilter untypedFilter = filterInfo.Instance;
            AuthenticationFilterTracer tracer = Assert.IsType<AuthenticationFilterTracer>(untypedFilter);
            Assert.Same(expectedInner, tracer.InnerFilter);
            Assert.Same(expectedTraceWriter, tracer.TraceWriter);
        }

        [Fact]
        public void CreateFilterTracers_With_IAuthorizationFilter_Returns_Single_Wrapped_IAuthorizationFilter()
        {
            // Arrange
            Mock<IAuthorizationFilter> mockFilter = new Mock<IAuthorizationFilter>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Action);

            // Act
            IEnumerable<FilterInfo> wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter());

            // Assert
            FilterInfo wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<AuthorizationFilterTracer>(wrappedFilter.Instance);
        }

        [Fact]
        public void CreateFilterTracers_With_IOverrideFilter_Returns_Single_Wrapped_IOverrideFilter()
        {
            // Arrange
            IOverrideFilter expectedInner = new Mock<IOverrideFilter>().Object;
            FilterInfo inputFilterInfo = new FilterInfo(expectedInner, FilterScope.Action);
            ITraceWriter expectedTraceWriter = new TestTraceWriter();

            // Act
            IEnumerable<FilterInfo> filters = FilterTracer.CreateFilterTracers(inputFilterInfo, expectedTraceWriter);

            // Assert
            Assert.NotNull(filters);
            FilterInfo filterInfo = Assert.Single(filters);
            Assert.NotNull(filterInfo);
            IFilter untypedFilter = filterInfo.Instance;
            OverrideFilterTracer tracer = Assert.IsType<OverrideFilterTracer>(untypedFilter);
            Assert.Same(expectedInner, tracer.InnerFilter);
            Assert.Same(expectedTraceWriter, tracer.TraceWriter);
        }

        [Fact]
        public void CreateFilterTracers_With_ActionFilterAttribute_Returns_Single_Wrapped_Filter()
        {
            // Arrange
            Mock<ActionFilterAttribute> mockFilter = new Mock<ActionFilterAttribute>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Action);

            // Act
            IEnumerable<FilterInfo> wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter());

            // Assert
            FilterInfo wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ActionFilterAttributeTracer>(wrappedFilter.Instance);
        }

        [Fact]
        public void CreateFilterTracers_With_ExceptionFilterAttribute_Returns_Single_Wrapped_Filter()
        {
            // Arrange
            Mock<ExceptionFilterAttribute> mockFilter = new Mock<ExceptionFilterAttribute>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Action);

            // Act
            IEnumerable<FilterInfo> wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter());

            // Assert
            FilterInfo wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<ExceptionFilterAttributeTracer>(wrappedFilter.Instance);
        }

        [Fact]
        public void CreateFilterTracers_With_AuthorizationFilterAttribute_Returns_Single_Wrapped_Filter()
        {
            // Arrange
            Mock<AuthorizationFilterAttribute> mockFilter = new Mock<AuthorizationFilterAttribute>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Action);

            // Act
            IEnumerable<FilterInfo> wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter());

            // Assert
            FilterInfo wrappedFilter = Assert.Single(wrappedFilters);
            Assert.IsType<AuthorizationFilterAttributeTracer>(wrappedFilter.Instance);
        }

        [Fact]
        public void CreateFilterTracers_With_All_Filter_Interfaces_Returns_Wrapped_Filters_For_Each_Filter()
        {
            // Arrange
            FilterInfo filter = new FilterInfo(new TestFilterAllBehaviors(), FilterScope.Action);

            // Act
            FilterInfo[] wrappedFilters = FilterTracer.CreateFilterTracers(filter, new TestTraceWriter()).ToArray();

            // Assert
            Assert.Equal(5, wrappedFilters.Length);
            Assert.Single(wrappedFilters, f => f.Instance.GetType() == typeof(ActionFilterTracer));
            Assert.Single(wrappedFilters, f => f.Instance.GetType() == typeof(AuthorizationFilterTracer));
            Assert.Single(wrappedFilters, f => f.Instance.GetType() == typeof(AuthenticationFilterTracer));
            Assert.Single(wrappedFilters, f => f.Instance.GetType() == typeof(ExceptionFilterTracer));
            Assert.Single(wrappedFilters, f => f.Instance.GetType() == typeof(OverrideFilterTracer));
        }

        [Fact]
        public void Inner_Property_On_FilterTracer_Returns_IFilter()
        {
            // Arrange
            IFilter expectedInner = new Mock<IFilter>().Object;
            FilterTracer productUnderTest = new FilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IFilter actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_Property_On_FilterTracer_Returns_IFilter()
        {
            // Arrange
            IFilter expectedInner = new Mock<IFilter>().Object;
            FilterTracer productUnderTest = new FilterTracer(expectedInner, new TestTraceWriter());

            // Act
            IFilter actualInner = Decorator.GetInner(productUnderTest as IFilter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        // Test filter class that exposes all filter behaviors will cause separate filters for each
        class TestFilterAllBehaviors : IActionFilter, IExceptionFilter, IAuthorizationFilter, IAuthenticationFilter,
            IOverrideFilter
        {
            Task<Net.Http.HttpResponseMessage> IActionFilter.ExecuteActionFilterAsync(Controllers.HttpActionContext actionContext, Threading.CancellationToken cancellationToken, Func<Threading.Tasks.Task<Net.Http.HttpResponseMessage>> continuation)
            {
                throw new NotImplementedException();
            }

            bool IFilter.AllowMultiple
            {
                get { throw new NotImplementedException(); }
            }

            Task IExceptionFilter.ExecuteExceptionFilterAsync(HttpActionExecutedContext actionExecutedContext, CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }

            Task<HttpResponseMessage> IAuthorizationFilter.ExecuteAuthorizationFilterAsync(HttpActionContext actionContext, CancellationToken cancellationToken, Func<Task<Net.Http.HttpResponseMessage>> continuation)
            {
                throw new NotImplementedException();
            }

            Task IAuthenticationFilter.AuthenticateAsync(HttpAuthenticationContext context, CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }

            Task IAuthenticationFilter.ChallengeAsync(HttpAuthenticationChallengeContext context, CancellationToken cancellationToken)
            {
                throw new NotImplementedException();
            }

            public Type FiltersToOverride
            {
                get { throw new NotImplementedException(); }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/FormUrlEncodedMediaTypeFormatterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Services;
using Microsoft.TestCommon;

namespace System.Web.Http.Tracing.Tracers
{
    public class FormUrlEncodedMediaTypeFormatterTracerTest : ReadWriteMediaTypeFormatterTracerTestBase<FormUrlEncodedMediaTypeFormatter>
    {
        public override MediaTypeFormatter CreateTracer(FormUrlEncodedMediaTypeFormatter formatter, HttpRequestMessage request, ITraceWriter traceWriter)
        {
            return new FormUrlEncodedMediaTypeFormatterTracer(formatter, traceWriter, request);
        }

        [Fact]
        public void MaxDepth_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            FormUrlEncodedMediaTypeFormatter innerFormatter = new FormUrlEncodedMediaTypeFormatter();
            innerFormatter.MaxDepth = innerFormatter.MaxDepth + 1;
            FormUrlEncodedMediaTypeFormatterTracer tracer = new FormUrlEncodedMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.MaxDepth, tracer.MaxDepth);
        }

        [Fact]
        public void ReadBufferSize_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            FormUrlEncodedMediaTypeFormatter innerFormatter = new FormUrlEncodedMediaTypeFormatter();
            innerFormatter.ReadBufferSize = innerFormatter.ReadBufferSize + 1;
            FormUrlEncodedMediaTypeFormatterTracer tracer = new FormUrlEncodedMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.ReadBufferSize, tracer.ReadBufferSize);
        }

        [Fact]
        public void Inner_Property_On_FormUrlEncodedMediaTypeFormatterTracer_Returns_FormUrlEncodedMediaTypeFormatter()
        {
            // Arrange
            FormUrlEncodedMediaTypeFormatter expectedInner = new FormUrlEncodedMediaTypeFormatter();
            FormUrlEncodedMediaTypeFormatterTracer productUnderTest = new FormUrlEncodedMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            FormUrlEncodedMediaTypeFormatter actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_FormUrlEncodedMediaTypeFormatterTracer_Returns_FormUrlEncodedMediaTypeFormatter()
        {
            // Arrange
            FormUrlEncodedMediaTypeFormatter expectedInner = new FormUrlEncodedMediaTypeFormatter();
            FormUrlEncodedMediaTypeFormatterTracer productUnderTest = new FormUrlEncodedMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            FormUrlEncodedMediaTypeFormatter actualInner = Decorator.GetInner(productUnderTest as FormUrlEncodedMediaTypeFormatter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/FormatterParameterBindingTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding;
using System.Web.Http.Services;
using System.Web.Http.Validation;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class FormatterParameterBindingTracerTest
    {
        [Fact]
        public void ErrorMessage_Calls_Inner()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null);
            mockBinding.Setup(b => b.ErrorMessage).Returns("errorMessage").Verifiable();
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.Equal("errorMessage", tracer.ErrorMessage);
            mockBinding.Verify();
        }

        [Fact]
        public void WillReadBody_Calls_Inner()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null);
            mockBinding.Setup(b => b.WillReadBody).Returns(true).Verifiable();
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.True(tracer.WillReadBody);
            mockBinding.Verify();
        }

        [Fact]
        public void Descriptor_Uses_Inners()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true };
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.Same(mockBinding.Object.Descriptor, tracer.Descriptor);
        }

        [Fact]
        public void Formatters_Uses_Inners()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true };
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.Equal(mockBinding.Object.Formatters, tracer.Formatters);
        }

        [Fact]
        public void BodyModelValidator_Uses_Inners()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<IBodyModelValidator> mockValidator = new Mock<IBodyModelValidator>();
            Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), mockValidator.Object) { CallBase = true };
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.Equal(mockBinding.Object.BodyModelValidator, tracer.BodyModelValidator);
        }

        /// <summary>
        /// This test verifies that our <see cref="FormatterParameterBindingTracer"/>
        /// intercepts the async bind request and redirects it to use tracing formatters
        /// correlated to the request.
        /// </summary>
        [Fact]
        public async Task ExecuteBindingAsync_Traces_And_Invokes_Inner_ReadAsync()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            FormatterParameterBinding binding = new FormatterParameterBinding(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null);
            TestTraceWriter traceWriter = new TestTraceWriter();
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(binding, traceWriter);
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            actionContext.Request.Content = new StringContent("true");
            actionContext.Request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
            ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
            };

            // Act
            await tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Equal("true", actionContext.ActionArguments["paramName"]);
        }

        [Fact]
        public void ExecuteBindingAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockBinding.Setup(
                b =>
                b.ExecuteBindingAsync(It.IsAny<ModelMetadataProvider>(), It.IsAny<HttpActionContext>(),
                                      It.IsAny<CancellationToken>())).Throws(exception);

            TestTraceWriter traceWriter = new TestTraceWriter();
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, traceWriter);
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
            };

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None));

            // Assert
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteBindingAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange

            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<FormatterParameterBinding> mockBinding = new Mock<FormatterParameterBinding>(mockParamDescriptor.Object, new MediaTypeFormatterCollection(), null) { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.TrySetException(exception);

            mockBinding.Setup(
                b =>
                b.ExecuteBindingAsync(It.IsAny<ModelMetadataProvider>(), It.IsAny<HttpActionContext>(),
                                      It.IsAny<CancellationToken>())).Returns(tcs.Task);

            TestTraceWriter traceWriter = new TestTraceWriter();
            FormatterParameterBindingTracer tracer = new FormatterParameterBindingTracer(mockBinding.Object, traceWriter);
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
            };

            // Act & Assert
            Task task = tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_FormatterParameterBindingTracer_Returns_FormatterParameterBinding()
        {
            // Arrange
            HttpParameterDescriptor httpParameterDescriptor = new Mock<HttpParameterDescriptor>().Object;
            MediaTypeFormatterCollection mediaTypeFormatterCollection = new MediaTypeFormatterCollection();
            FormatterParameterBinding expectedInner = new FormatterParameterBinding(httpParameterDescriptor, mediaTypeFormatterCollection, null);
            FormatterParameterBindingTracer productUnderTest = new FormatterParameterBindingTracer(expectedInner, new TestTraceWriter());

            // Act
            FormatterParameterBinding actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_FormatterParameterBindingTracer_Returns_FormatterParameterBinding()
        {
            // Arrange
            HttpParameterDescriptor httpParameterDescriptor = new Mock<HttpParameterDescriptor>().Object;
            MediaTypeFormatterCollection mediaTypeFormatterCollection = new MediaTypeFormatterCollection();
            FormatterParameterBinding expectedInner = new FormatterParameterBinding(httpParameterDescriptor, mediaTypeFormatterCollection, null);
            FormatterParameterBindingTracer productUnderTest = new FormatterParameterBindingTracer(expectedInner, new TestTraceWriter());

            // Act
            FormatterParameterBinding actualInner = Decorator.GetInner(productUnderTest as FormatterParameterBinding);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpActionBindingTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpActionBindingTracerTest
    {
        private Mock<HttpActionDescriptor> _mockActionDescriptor;
        private Mock<HttpParameterDescriptor> _mockParameterDescriptor;
        private Mock<HttpParameterBinding> _mockParameterBinding;
        private HttpActionBinding _actionBinding;
        private HttpActionContext _actionContext;
        private HttpControllerContext _controllerContext;
        private HttpControllerDescriptor _controllerDescriptor;

        public HttpActionBindingTracerTest()
        {
            _mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            _mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            _mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));

            _mockParameterDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            _mockParameterBinding = new Mock<HttpParameterBinding>(_mockParameterDescriptor.Object) { CallBase = true };
            _actionBinding = new HttpActionBinding(_mockActionDescriptor.Object, new HttpParameterBinding[] { _mockParameterBinding.Object });

            _controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));

            _controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
            _controllerContext.ControllerDescriptor = _controllerDescriptor;

            _actionContext = ContextUtil.CreateActionContext(_controllerContext, actionDescriptor: _mockActionDescriptor.Object);

        }

        [Fact]
        public void ActionDescriptor_Uses_Inners()
        {
            // Arrange
            HttpActionBinding binding = new Mock<HttpActionBinding>() { CallBase = true }.Object;
            binding.ActionDescriptor = _mockActionDescriptor.Object;
            HttpActionBindingTracer tracer = new HttpActionBindingTracer(binding, new TestTraceWriter());

            // Assert
            Assert.Same(binding.ActionDescriptor, tracer.ActionDescriptor);
        }

        [Fact]
        public void ParameterBindings_Uses_Inners()
        {
            // Arrange
            HttpActionBinding binding = new Mock<HttpActionBinding>() { CallBase = true }.Object;
            HttpParameterBinding[] parameterBindings = new HttpParameterBinding[0];
            binding.ParameterBindings = parameterBindings;
            HttpActionBindingTracer tracer = new HttpActionBindingTracer(binding, new TestTraceWriter());

            // Assert
            Assert.Same(parameterBindings, tracer.ParameterBindings);
        }

        [Fact]
        public async Task BindValuesAsync_Invokes_Inner_And_Traces()
        {
            // Arrange
            bool wasInvoked = false;
            Mock<HttpActionBinding> mockBinder = new Mock<HttpActionBinding>() { CallBase = true };
            mockBinder.Setup(b => b.ExecuteBindingAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>()))
                .Callback(() => wasInvoked = true).Returns(TaskHelpers.Completed());

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionBindingTracer tracer = new HttpActionBindingTracer(mockBinder.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.End }
            };

            // Act
            await tracer.ExecuteBindingAsync(_actionContext, CancellationToken.None);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.True(wasInvoked);
        }

        [Fact]
        public async Task ExecuteBindingAsync_Faults_And_Traces_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException();
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.TrySetException(exception);
            Mock<HttpActionBinding> mockBinder = new Mock<HttpActionBinding>() { CallBase = true };
            mockBinder.Setup(b => b.ExecuteBindingAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>()))
                .Returns(tcs.Task);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionBindingTracer tracer = new HttpActionBindingTracer(mockBinder.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            // Act
            Task task = tracer.ExecuteBindingAsync(_actionContext, CancellationToken.None);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_HttpActionBindingTracer_Returns_HttpActionBinding()
        {
            // Arrange
            HttpActionBinding expectedInner = new HttpActionBinding();
            HttpActionBindingTracer productUnderTest = new HttpActionBindingTracer(expectedInner, new TestTraceWriter());

            // Act
            HttpActionBinding actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpActionBindingTracer_Returns_HttpActionBinding()
        {
            // Arrange
            HttpActionBinding expectedInner = new HttpActionBinding();
            HttpActionBindingTracer productUnderTest = new HttpActionBindingTracer(expectedInner, new TestTraceWriter());

            // Act
            HttpActionBinding actualInner = Decorator.GetInner(productUnderTest as HttpActionBinding);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpActionDescriptorTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpActionDescriptorTracerTest
    {
        [Fact]
        public void ActionName_Calls_Inner()
        {
            // Arrange
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.ActionName).Returns("actionName").Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same("actionName", tracer.ActionName);
            mockDescriptor.Verify();
        }

        [Fact]
        public void SupportedHttpMethods_Calls_Inner()
        {
            // Arrange
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Collection<HttpMethod> methods = new Collection<HttpMethod>() { HttpMethod.Delete };
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.SupportedHttpMethods).Returns(methods).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Equal(methods, tracer.SupportedHttpMethods);
            mockDescriptor.Verify();
        }

        [Fact]
        public void ActionBinding_Calls_Inner()
        {
            // Arrange
            HttpActionBinding binding = new Mock<HttpActionBinding>().Object;
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.ActionBinding).Returns(binding).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same(binding, tracer.ActionBinding);
            mockDescriptor.Verify();
        }

        [Fact]
        public void ReturnType_Calls_Inner()
        {
            // Arrange
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.ReturnType).Returns(typeof(string)).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Equal(typeof(string), tracer.ReturnType);
            mockDescriptor.Verify();
        }

        [Fact]
        public void ResultConverter_Calls_Inner()
        {
            // Arrange
            IActionResultConverter resultConverter = new Mock<IActionResultConverter>().Object;
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.ResultConverter).Returns(resultConverter).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same(resultConverter, tracer.ResultConverter);
            mockDescriptor.Verify();
        }

        [Fact]
        public void Properties_Calls_Inner()
        {
            // Arrange
            ConcurrentDictionary<object, object> properties = new ConcurrentDictionary<object, object>();
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.Properties).Returns(properties).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same(properties, tracer.Properties);
            mockDescriptor.Verify();
        }

        [Fact]
        public void GetCustomAttributes_Calls_Inner()
        {
            // Arrange
            Collection<Attribute> customAttributes = new Collection<Attribute>();
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.GetCustomAttributes<Attribute>()).Returns(customAttributes).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same(customAttributes, tracer.GetCustomAttributes<Attribute>());
            mockDescriptor.Verify();
        }

        [Fact]
        public void GetParameters_Calls_Inner()
        {
            // Arrange
            Collection<HttpParameterDescriptor> parameters = new Collection<HttpParameterDescriptor>();
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.GetParameters()).Returns(parameters).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same(parameters, tracer.GetParameters());
            mockDescriptor.Verify();
        }

        [Fact]
        public void GetFilters_Calls_Inner()
        {
            // Arrange
            Collection<IFilter> filters = new Collection<IFilter>();
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.GetFilters()).Returns(filters).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act
            tracer.GetFilters();

            // Assert
            mockDescriptor.Verify();
        }

        [Fact]
        public void GetFilterPipeline_Calls_Inner()
        {
            // Arrange
            Collection<FilterInfo> filters = new Collection<FilterInfo>();
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            mockDescriptor.Setup(d => d.GetFilterPipeline()).Returns(filters).Verifiable();
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act
            tracer.GetFilterPipeline();

            // Assert
            mockDescriptor.Verify();
        }
        [Fact]
        public void Configuration_Uses_Inners()
        {
            // Assert
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same(actionDescriptor.Configuration, tracer.Configuration);
        }

        [Fact]
        public void ControllerDescriptor_Uses_Inners()
        {
            // Assert
            HttpControllerDescriptor controllerDescriptor = new Mock<HttpControllerDescriptor>().Object;
            controllerDescriptor.Configuration = new HttpConfiguration();
            Mock<HttpActionDescriptor> mockDescriptor = new Mock<HttpActionDescriptor>(controllerDescriptor);
            HttpActionDescriptor actionDescriptor = mockDescriptor.Object;
            HttpControllerContext controllerContext = new Mock<HttpControllerContext>().Object;
            controllerContext.Configuration = controllerDescriptor.Configuration;
            controllerContext.ControllerDescriptor = controllerDescriptor;
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, actionDescriptor, new TestTraceWriter());

            // Act and Assert
            Assert.Same(actionDescriptor.ControllerDescriptor, tracer.ControllerDescriptor);
        }

        // This test verifies only one kind of filter is wrapped, proving
        // the static FilterTracer.CreateFilterTracer was called from GetFilterPipeline.
        // Deeper testing of FilterTracer.CreateFilterTracer is in FilterTracerTest.
        [Fact]
        public void GetFilterPipeline_Returns_Wrapped_Filters()
        {
            // Arrange
            Mock<IFilter> mockFilter = new Mock<IFilter>();
            FilterInfo filter = new FilterInfo(mockFilter.Object, FilterScope.Global);
            Collection<FilterInfo> filterCollection = new Collection<FilterInfo>(new FilterInfo[] { filter });
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetFilterPipeline()).Returns(filterCollection);
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, new TestTraceWriter());

            // Act
            Collection<FilterInfo> wrappedFilterCollection = tracer.GetFilterPipeline();

            // Assert
            Assert.IsType<FilterTracer>(wrappedFilterCollection[0].Instance);
        }

        // This test verifies only one kind of filter is wrapped, proving
        // the static FilterTracer.CreateFilterTracer was called from GetFilterPipeline.
        // Deeper testing of FilterTracer.CreateFilterTracer is in FilterTracerTest.
        [Fact]
        public void GetFilters_Returns_Wrapped_IFilters()
        {
            // Arrange
            Mock<IFilter> mockFilter = new Mock<IFilter>();
            Collection<IFilter> filters = new Collection<IFilter>(new IFilter[] { mockFilter.Object });
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.GetFilters()).Returns(filters);
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, new TestTraceWriter());

            // Act
            IFilter[] wrappedFilters = tracer.GetFilters().ToArray();

            // Assert
            Assert.IsType<FilterTracer>(wrappedFilters[0]);
        }

        [Fact]
        public void ExecuteAsync_Invokes_Inner_ExecuteAsync()
        {
            // Arrange
            var cts = new CancellationTokenSource();
            var mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            var controllerContext = ContextUtil.CreateControllerContext();
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
            var arguments = new Dictionary<string, object>();
            var tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, new TestTraceWriter());

            // Act
            tracer.ExecuteAsync(controllerContext, arguments, cts.Token);

            // Assert
            mockActionDescriptor.Verify(a => a.ExecuteAsync(controllerContext, arguments, cts.Token), Times.Once());
        }

        [Fact]
        public async Task ExecuteAsync_Traces()
        {
            // Arrange
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            mockActionDescriptor.Setup(a => a.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<IDictionary<string, object>>(), CancellationToken.None))
                .Returns(Task.FromResult<object>(null));
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
            IDictionary<string, object> arguments = new Dictionary<string, object>();
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteAsync" },
                new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.End }
            };

            // Act
            await tracer.ExecuteAsync(controllerContext, arguments, CancellationToken.None);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void ExecuteAsync_Throws_What_Inner_Throws_And_Traces()
        {
            // Arrange
            Mock<HttpActionDescriptor> mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockActionDescriptor.Setup(
                a => a.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<IDictionary<string, object>>(), CancellationToken.None)).Throws(exception);
            mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
            controllerContext.ControllerDescriptor = new HttpControllerDescriptor(controllerContext.Configuration, "test", typeof(ApiController));
            IDictionary<string, object> arguments = new Dictionary<string, object>();
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionDescriptorTracer tracer = new HttpActionDescriptorTracer(controllerContext, mockActionDescriptor.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(controllerContext.Request, TraceCategories.ActionCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => tracer.ExecuteAsync(controllerContext, arguments, CancellationToken.None));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_HttpActionDescriptorTracer_Returns_HttpActionDescriptor()
        {
            // Arrange
            HttpActionDescriptor expectedInner = new Mock<HttpActionDescriptor>().Object;
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
            HttpActionDescriptorTracer productUnderTest = new HttpActionDescriptorTracer(controllerContext, expectedInner, new TestTraceWriter());

            // Act
            HttpActionDescriptor actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpActionDescriptorTracer_Returns_HttpActionDescriptor()
        {
            // Arrange
            HttpActionDescriptor expectedInner = new Mock<HttpActionDescriptor>().Object;
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext();
            HttpActionDescriptorTracer productUnderTest = new HttpActionDescriptorTracer(controllerContext, expectedInner, new TestTraceWriter());

            // Act
            HttpActionDescriptor actualInner = Decorator.GetInner(productUnderTest as HttpActionDescriptor);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpActionInvokerTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpActionInvokerTracerTest
    {
        private HttpActionContext _actionContext;
        private ApiController _apiController;

        public HttpActionInvokerTracerTest()
        {
            UsersController controller = new UsersController();
            _apiController = controller;

            Func<HttpResponseMessage> actionMethod = controller.Get;
            _actionContext = ContextUtil.CreateActionContext(
                ContextUtil.CreateControllerContext(instance: _apiController),
                new ReflectedHttpActionDescriptor { MethodInfo = actionMethod.Method });
            HttpRequestMessage request = new HttpRequestMessage();
            _actionContext.ControllerContext.Request = request;
        }

        [Fact]
        public void InvokeActionAsync_Invokes_Inner_InvokeActionAsync()
        {
            // Arrange
            var cts = new CancellationTokenSource();
            var mockInnerInvoker = new Mock<IHttpActionInvoker>();
            IHttpActionInvoker invoker = new HttpActionInvokerTracer(mockInnerInvoker.Object, new Mock<ITraceWriter>().Object);

            // Act
            invoker.InvokeActionAsync(_actionContext, cts.Token);

            // Assert
            mockInnerInvoker.Verify(i => i.InvokeActionAsync(_actionContext, cts.Token), Times.Once());
        }

        [Fact]
        public async Task InvokeActionAsync_Traces_Begin_And_End_Info()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(new ApiControllerActionInvoker(), traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.End }
            };

            // Act
            var actionInvoker = (IHttpActionInvoker)tracer;
            await actionInvoker.InvokeActionAsync(_actionContext, CancellationToken.None);

            // Assert
            Assert.Equal(2, traceWriter.Traces.Count);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task InvokeActionAsync_Returns_Cancelled_Inner_Task()
        {
            // Arrange
            CancellationTokenSource cancellationSource = new CancellationTokenSource();
            cancellationSource.Cancel();

            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(new ApiControllerActionInvoker(), new TestTraceWriter());

            // Act
            var response = ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, cancellationSource.Token);

            // Assert
            await Assert.ThrowsAsync<TaskCanceledException>(() => response);
        }

        [Fact]
        public async Task InvokeActionAsync_Traces_Cancelled_Inner_Task()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(new ApiControllerActionInvoker(), traceWriter);
            CancellationTokenSource cancellationSource = new CancellationTokenSource();
            cancellationSource.Cancel();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Warn) { Kind = TraceKind.End }
            };

            // Act
            var response = ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, cancellationSource.Token);

            // Assert
            await Assert.ThrowsAsync<TaskCanceledException>(() => response);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task InvokeActionAsync_Returns_Faulted_Inner_Task()
        {
            // Arrange
            Mock<ApiControllerActionInvoker> mockActionInvoker = new Mock<ApiControllerActionInvoker>() { CallBase = true };
            InvalidOperationException expectedException = new InvalidOperationException("test message");
            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>(null);
            tcs.TrySetException(expectedException);
            mockActionInvoker.Setup(
                a => a.InvokeActionAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>())).Returns(tcs.Task);
            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(mockActionInvoker.Object, new TestTraceWriter());

            // Act & Assert
            var exception = await Assert.ThrowsAsync<InvalidOperationException>(
                () => ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, CancellationToken.None));

            Assert.Equal(expectedException.Message, exception.Message);
        }

        [Fact]
        public async Task InvokeActionAsync_Traces_Faulted_Inner_Task()
        {
            // Arrange
            Mock<ApiControllerActionInvoker> mockActionInvoker = new Mock<ApiControllerActionInvoker>() { CallBase = true };
            InvalidOperationException expectedException = new InvalidOperationException("test message");
            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>(null);
            tcs.TrySetException(expectedException);
            mockActionInvoker.Setup(
                a => a.InvokeActionAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>())).Returns(tcs.Task);
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(mockActionInvoker.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            // Act
            var response = ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, CancellationToken.None);

            // Assert
            await Assert.ThrowsAsync<InvalidOperationException>(() => response);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Equal(expectedException, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void InvokeActionAsync_Throws_When_ActionContext_Is_Null()
        {
            // Arrange
            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(new ApiControllerActionInvoker(), new TestTraceWriter());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => ((IHttpActionInvoker)tracer).InvokeActionAsync(null, CancellationToken.None),
                "actionContext");
        }

        [Fact]
        public void InvokeActionAsync_Throws_Exception_Thrown_From_Inner()
        {
            // Arrange
            InvalidOperationException expectedException = new InvalidOperationException("test message");
            Mock<ApiControllerActionInvoker> mockActionInvoker = new Mock<ApiControllerActionInvoker>() { CallBase = true };
            mockActionInvoker.Setup(
                a => a.InvokeActionAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>())).Throws(expectedException);
            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(mockActionInvoker.Object, new TestTraceWriter());

            // Act & Assert
            InvalidOperationException thrownException = Assert.Throws<InvalidOperationException>(
                () => ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, CancellationToken.None)
            );

            // Assert
            Assert.Equal(expectedException, thrownException);
        }

        [Fact]
        public void InvokeActionAsync_Traces_Exception_Thrown_From_Inner()
        {
            // Arrange
            InvalidOperationException expectedException = new InvalidOperationException("test message");
            Mock<ApiControllerActionInvoker> mockActionInvoker = new Mock<ApiControllerActionInvoker>() { CallBase = true };
            mockActionInvoker.Setup(
                a => a.InvokeActionAsync(It.IsAny<HttpActionContext>(), It.IsAny<CancellationToken>())).Throws(expectedException);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpActionInvokerTracer tracer = new HttpActionInvokerTracer(mockActionInvoker.Object, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => ((IHttpActionInvoker)tracer).InvokeActionAsync(_actionContext, CancellationToken.None)
            );

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Equal(expectedException, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_HttpActionInvokerTracer_Returns_IHttpActionInvoker()
        {
            // Arrange
            IHttpActionInvoker expectedInner = new Mock<IHttpActionInvoker>().Object;
            HttpActionInvokerTracer productUnderTest = new HttpActionInvokerTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpActionInvoker actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpActionInvokerTracer_Returns_IHttpActionInvoker()
        {
            // Arrange
            IHttpActionInvoker expectedInner = new Mock<IHttpActionInvoker>().Object;
            HttpActionInvokerTracer productUnderTest = new HttpActionInvokerTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpActionInvoker actualInner = Decorator.GetInner(productUnderTest as IHttpActionInvoker);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpActionSelectorTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpActionSelectorTracerTest
    {
        private Mock<HttpActionDescriptor> _mockActionDescriptor;
        private HttpActionContext _actionContext;
        private HttpControllerContext _controllerContext;
        private HttpControllerDescriptor _controllerDescriptor;

        public HttpActionSelectorTracerTest()
        {
            _mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            _mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            _mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));

            _controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));

            _controllerContext = ContextUtil.CreateControllerContext(request: new HttpRequestMessage());
            _controllerContext.ControllerDescriptor = _controllerDescriptor;

            _actionContext = ContextUtil.CreateActionContext(_controllerContext, actionDescriptor: _mockActionDescriptor.Object);
        }

        [Fact]
        public void SelectAction_Traces_And_Returns_ActionDescriptor_Tracer()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            Mock<IHttpActionSelector> mockSelector = new Mock<IHttpActionSelector>();
            mockSelector.Setup(s => s.SelectAction(_controllerContext)).Returns(_mockActionDescriptor.Object);
            HttpActionSelectorTracer tracer = new HttpActionSelectorTracer(mockSelector.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.End }
            };

            // Act
            HttpActionDescriptor selectedActionDescriptor = ((IHttpActionSelector)tracer).SelectAction(_controllerContext);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.IsAssignableFrom<HttpActionDescriptorTracer>(selectedActionDescriptor);
        }

        [Fact]
        public void SelectAction_DoesNotWrapHttpActionDescriptorTracer()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            Mock<IHttpActionSelector> mockSelector = new Mock<IHttpActionSelector>();

            HttpActionDescriptorTracer actionDescriptorTracer = new HttpActionDescriptorTracer(_controllerContext, _mockActionDescriptor.Object, traceWriter);
            mockSelector.Setup(s => s.SelectAction(_controllerContext)).Returns(actionDescriptorTracer);
            HttpActionSelectorTracer tracer = new HttpActionSelectorTracer(mockSelector.Object, traceWriter);

            // Act
            HttpActionDescriptor selectedActionDescriptor = ((IHttpActionSelector)tracer).SelectAction(_controllerContext);

            // Assert
            Assert.Same(actionDescriptorTracer, selectedActionDescriptor);
        }

        [Fact]
        public void SelectAction_Traces_And_Throws_Exception_Thrown_From_Inner()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            Mock<IHttpActionSelector> mockSelector = new Mock<IHttpActionSelector>();
            InvalidOperationException exception = new InvalidOperationException();
            mockSelector.Setup(s => s.SelectAction(_controllerContext)).Throws(exception);
            HttpActionSelectorTracer tracer = new HttpActionSelectorTracer(mockSelector.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(_actionContext.Request, TraceCategories.ActionCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            // Act
            Exception thrown = Assert.Throws<InvalidOperationException>(() => ((IHttpActionSelector)tracer).SelectAction(_controllerContext));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_HttpActionSelectorTracer_Returns_IHttpActionSelector()
        {
            // Arrange
            IHttpActionSelector expectedInner = new Mock<IHttpActionSelector>().Object;
            HttpActionSelectorTracer productUnderTest = new HttpActionSelectorTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpActionSelector actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpActionSelectorTracer_Returns_IHttpActionSelector()
        {
            // Arrange
            IHttpActionSelector expectedInner = new Mock<IHttpActionSelector>().Object;
            HttpActionSelectorTracer productUnderTest = new HttpActionSelectorTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpActionSelector actualInner = Decorator.GetInner(productUnderTest as IHttpActionSelector);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpControllerActivatorTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpControllerActivatorTracerTest
    {
        [Fact]
        public void Create_Invokes_Inner_And_Traces()
        {
            // Arrange
            Mock<ApiController> mockController = new Mock<ApiController>();
            Mock<IHttpControllerActivator> mockActivator = new Mock<IHttpControllerActivator>() { CallBase = true };
            mockActivator.Setup(b => b.Create(It.IsAny<HttpRequestMessage>(), It.IsAny<HttpControllerDescriptor>(), It.IsAny<Type>())).Returns(mockController.Object);
            HttpRequestMessage request = new HttpRequestMessage();
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerActivatorTracer tracer = new HttpControllerActivatorTracer(mockActivator.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "Create" },
                new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "Create" }
            };

            // Act
            IHttpController createdController = ((IHttpControllerActivator)tracer).Create(request, controllerDescriptor: null, controllerType: mockController.Object.GetType());

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.IsAssignableFrom<HttpControllerTracer>(createdController);
        }

        [Fact]
        public void Create_Throws_And_Traces_When_Inner_Throws()
        {
            // Arrange
            Mock<ApiController> mockController = new Mock<ApiController>();
            Mock<IHttpControllerActivator> mockActivator = new Mock<IHttpControllerActivator>() { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockActivator.Setup(b => b.Create(It.IsAny<HttpRequestMessage>(), It.IsAny<HttpControllerDescriptor>(), It.IsAny<Type>())).Throws(exception);
            HttpRequestMessage request = new HttpRequestMessage();
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerActivatorTracer tracer = new HttpControllerActivatorTracer(mockActivator.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "Create" },
                new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "Create" }
            };

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(() => ((IHttpControllerActivator)tracer).Create(request, controllerDescriptor: null, controllerType: mockController.Object.GetType()));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_HttpControllerActivatorTracer_Returns_IHttpControllerActivator()
        {
            // Arrange
            IHttpControllerActivator expectedInner = new Mock<IHttpControllerActivator>().Object;
            HttpControllerActivatorTracer productUnderTest = new HttpControllerActivatorTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpControllerActivator actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpControllerActivatorTracer_Returns_IHttpControllerActivator()
        {
            // Arrange
            IHttpControllerActivator expectedInner = new Mock<IHttpControllerActivator>().Object;
            HttpControllerActivatorTracer productUnderTest = new HttpControllerActivatorTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpControllerActivator actualInner = Decorator.GetInner(productUnderTest as IHttpControllerActivator);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpControllerDescriptorTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpControllerDescriptorTracerTest
    {
        private static readonly HttpControllerContext _controllerContext = ContextUtil.CreateControllerContext(instance: _controller);
        private static readonly HttpRequestMessage _request = _controllerContext.Request;
        private static readonly IHttpController _controller = new Mock<IHttpController>().Object;
        private static readonly InvalidOperationException _exception = new InvalidOperationException("test");

        [Fact]
        public void Properties_Calls_Inner()
        {
            // Arrange
            ConcurrentDictionary<object, object> properties = new ConcurrentDictionary<object, object>();
            Mock<HttpControllerDescriptor> mockControllerDescriptor = new Mock<HttpControllerDescriptor>();
            mockControllerDescriptor.Setup(d => d.Properties).Returns(properties).Verifiable();
            HttpControllerDescriptorTracer tracer = GetHttpControllerDescriptorTracer(mockControllerDescriptor.Object, new TestTraceWriter());

            // Act and Assert
            Assert.Same(properties, tracer.Properties);
            mockControllerDescriptor.Verify();
        }

        [Fact]
        public void CreateController_Invokes_Inner_And_Traces()
        {
            // Arrange
            Mock<HttpControllerDescriptor> mockControllerDescriptor = CreateMockControllerDescriptor();
            mockControllerDescriptor.Setup(b => b.CreateController(It.IsAny<HttpRequestMessage>())).Returns(_controller);
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerDescriptorTracer tracer = GetHttpControllerDescriptorTracer(mockControllerDescriptor.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "CreateController" },
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "CreateController" }
            };

            // Act
            IHttpController controller = tracer.CreateController(_request);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.IsAssignableFrom<HttpControllerTracer>(controller);
        }

        [Fact]
        public void CreateController_Throws_And_Traces_When_Inner_Throws()
        {
            // Arrange
            Mock<HttpControllerDescriptor> mockControllerDescriptor = CreateMockControllerDescriptor();
            mockControllerDescriptor.Setup(b => b.CreateController(It.IsAny<HttpRequestMessage>())).Throws(_exception);
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerDescriptorTracer tracer = GetHttpControllerDescriptorTracer(mockControllerDescriptor.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "CreateController" },
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "CreateController" }
            };

            // Act
            Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.CreateController(_request));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(_exception, thrown);
            Assert.Same(_exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_HttpControllerDescriptorTracer_Returns_HttpControllerDescriptor()
        {
            // Arrange
            HttpControllerDescriptor expectedInner = BuildHttpControllerDescriptor(_controller);

            HttpControllerDescriptorTracer productUnderTest = new HttpControllerDescriptorTracer(expectedInner, new TestTraceWriter());

            // Act
            HttpControllerDescriptor actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpControllerDescriptorTracer_Returns_HttpControllerDescriptor()
        {
            // Arrange
            HttpControllerDescriptor expectedInner = BuildHttpControllerDescriptor(_controller);

            HttpControllerDescriptorTracer productUnderTest = new HttpControllerDescriptorTracer(expectedInner, new TestTraceWriter());

            // Act
            HttpControllerDescriptor actualInner = Decorator.GetInner(productUnderTest as HttpControllerDescriptor);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_DoesNotCauseControllerInitializationToHappenAgainAndAgain()
        {
            // Arrange
            int raisedCount = 0;
            RaiseWhenInitializedAttribute.Initialized += delegate { ++raisedCount; };

            var descriptor = new HttpControllerDescriptor(new HttpConfiguration(), "my", typeof(MyController));
            Assert.Equal(1, raisedCount);

            // Act
            new HttpControllerDescriptorTracer(descriptor, new TestTraceWriter());
            new HttpControllerDescriptorTracer(descriptor, new TestTraceWriter());
            new HttpControllerDescriptorTracer(descriptor, new TestTraceWriter());

            // Assert
            Assert.Equal(1, raisedCount);
        }

        private static HttpControllerDescriptor BuildHttpControllerDescriptor(IHttpController controller, string controllerName = "AnyController", HttpConfiguration httpConfiguration = null)
        {
            HttpControllerDescriptor expectedInner = new Mock<HttpControllerDescriptor>().Object;
            expectedInner.ControllerName = controllerName;
            expectedInner.ControllerType = controller.GetType();
            expectedInner.Configuration = httpConfiguration ?? new HttpConfiguration();
            return expectedInner;
        }

        private static HttpControllerDescriptorTracer GetHttpControllerDescriptorTracer(HttpControllerDescriptor controllerDescriptor, ITraceWriter traceWriter)
        {
            if (controllerDescriptor.Configuration == null)
            {
                controllerDescriptor.Configuration = new HttpConfiguration();
            }

            if (controllerDescriptor.ControllerName == null)
            {
                controllerDescriptor.ControllerName = "AnyController";
            }

            if (controllerDescriptor.ControllerType == null)
            {
                controllerDescriptor.ControllerType = _controller.GetType();
            }

            return new HttpControllerDescriptorTracer(
                innerDescriptor: controllerDescriptor,
                traceWriter: traceWriter);
        }

        private static Mock<HttpControllerDescriptor> CreateMockControllerDescriptor()
        {
            Mock<HttpControllerDescriptor> mockControllerDescriptor = new Mock<HttpControllerDescriptor>(_controllerContext.Configuration, "AnyController", _controller.GetType());
            return mockControllerDescriptor;
        }

        private class RaiseWhenInitializedAttribute : Attribute, IControllerConfiguration
        {
            public static event EventHandler Initialized;
            public void Initialize(HttpControllerSettings controllerSettings, HttpControllerDescriptor controllerDescriptor)
            {
                Initialized(this, EventArgs.Empty);
            }
        }

        [RaiseWhenInitialized]
        private class MyController : ApiController
        {
            public string Foo()
            {
                return "bar";
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpControllerSelectorTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Dispatcher;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpControllerSelectorTracerTest
    {
        private static readonly IHttpController _controller = new Mock<IHttpController>().Object;
        private static readonly HttpControllerContext _controllerContext = ContextUtil.CreateControllerContext(instance: _controller);
        private static readonly HttpRequestMessage _request = _controllerContext.Request;

        [Fact]
        public void SelectController_Invokes_Inner_And_Traces()
        {
            // Arrange
            Mock<HttpControllerDescriptor> mockControllerDescriptor = new Mock<HttpControllerDescriptor>(_controllerContext.Configuration, "AnyController", _controller.GetType());
            Mock<IHttpControllerSelector> mockSelector = new Mock<IHttpControllerSelector>();
            mockSelector.Setup(b => b.SelectController(It.IsAny<HttpRequestMessage>())).Returns(mockControllerDescriptor.Object);
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerSelectorTracer tracer = new HttpControllerSelectorTracer(mockSelector.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SelectController" },
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "SelectController" }
            };

            // Act
            HttpControllerDescriptor controllerDescriptor = ((IHttpControllerSelector)tracer).SelectController(_request);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.IsAssignableFrom<HttpControllerDescriptorTracer>(controllerDescriptor);
        }

        [Fact]
        public void SelectController_Throws_And_Traces_When_Inner_Throws()
        {
            // Arrange
            Mock<IHttpControllerSelector> mockSelector = new Mock<IHttpControllerSelector>();
            InvalidOperationException exception = new InvalidOperationException("test");
            mockSelector.Setup(b => b.SelectController(It.IsAny<HttpRequestMessage>())).Throws(exception);
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerSelectorTracer tracer = new HttpControllerSelectorTracer(mockSelector.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SelectController" },
                new TraceRecord(_request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "SelectController" }
            };

            // Act
            Exception thrown = Assert.Throws<InvalidOperationException>(() => ((IHttpControllerSelector)tracer).SelectController(_request));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public void Inner_Property_On_HttpControllerSelectorTracer_Returns_IHttpControllerSelector()
        {
            // Arrange
            IHttpControllerSelector expectedInner = new Mock<IHttpControllerSelector>().Object;
            HttpControllerSelectorTracer productUnderTest = new HttpControllerSelectorTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpControllerSelector actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpControllerSelectorTracer_Returns_IHttpControllerSelector()
        {
            // Arrange
            IHttpControllerSelector expectedInner = new Mock<IHttpControllerSelector>().Object;
            HttpControllerSelectorTracer productUnderTest = new HttpControllerSelectorTracer(expectedInner, new TestTraceWriter());

            // Act
            IHttpControllerSelector actualInner = Decorator.GetInner(productUnderTest as IHttpControllerSelector);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpControllerTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Hosting;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpControllerTracerTest
    {
        private Mock<HttpActionDescriptor> _mockActionDescriptor;
        private HttpControllerDescriptor _controllerDescriptor;

        public HttpControllerTracerTest()
        {
            _mockActionDescriptor = new Mock<HttpActionDescriptor>() { CallBase = true };
            _mockActionDescriptor.Setup(a => a.ActionName).Returns("test");
            _mockActionDescriptor.Setup(a => a.GetParameters()).Returns(new Collection<HttpParameterDescriptor>(new HttpParameterDescriptor[0]));

            _controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "controller", typeof(ApiController));
        }

        [Fact]
        public void Dispose_TracesAndInvokesInnerDisposeWhenControllerIsDisposable()
        {
            // Arrange
            var mockController = new Mock<IHttpController>();
            var mockDisposable = mockController.As<IDisposable>();
            var request = new HttpRequestMessage();
            var traceWriter = new TestTraceWriter();
            var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
            var expectedTraces = new[]
            {
                new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "Dispose" },
                new TraceRecord(request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "Dispose" }
            };

            // Act
            ((IDisposable)tracer).Dispose();

            // Assert
            Assert.Equal(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            mockDisposable.Verify(d => d.Dispose(), Times.Once());
        }

        [Fact]
        public void Dispose_DoesNotTraceWhenControllerIsNotDisposable()
        {
            // Arrange
            var mockController = new Mock<IHttpController>();
            var request = new HttpRequestMessage();
            var traceWriter = new TestTraceWriter();
            var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);

            // Act
            ((IDisposable)tracer).Dispose();

            // Assert
            Assert.Empty(traceWriter.Traces);
        }

        [Fact]
        public async Task ExecuteAsync_RemovesInnerControllerFromReleaseListAndAddsItselfInstead()
        {
            // Arrange
            var request = new HttpRequestMessage();
            var context = ContextUtil.CreateControllerContext(request: request);
            var mockController = new Mock<IHttpController>();
            var mockDisposable = mockController.As<IDisposable>();
            mockController.Setup(c => c.ExecuteAsync(context, CancellationToken.None))
                          .Callback<HttpControllerContext, CancellationToken>((cc, ct) => cc.Request.RegisterForDispose(mockDisposable.Object))
                          .Returns(() => Task.FromResult(new HttpResponseMessage()))
                          .Verifiable();
            context.ControllerDescriptor = _controllerDescriptor;
            context.Controller = mockController.Object;
            var traceWriter = new TestTraceWriter();
            var tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);

            // Act
            var controller = (IHttpController)tracer;
            await controller.ExecuteAsync(context, CancellationToken.None);

            // Assert
            IEnumerable<IDisposable> disposables = (IEnumerable<IDisposable>)request.Properties[HttpPropertyKeys.DisposableRequestResourcesKey];
            Assert.Contains(tracer, disposables);
            Assert.DoesNotContain(mockDisposable.Object, disposables);
        }

        [Fact]
        public async Task ExecuteAsync_Invokes_Inner_And_Traces()
        {
            // Arrange
            HttpResponseMessage response = new HttpResponseMessage();
            Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
            mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(Task.FromResult<HttpResponseMessage>(response));

            HttpRequestMessage request = new HttpRequestMessage();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
            controllerContext.ControllerDescriptor = _controllerDescriptor;
            controllerContext.Controller = mockController.Object;

            HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.End }
            };

            // Act
            var task = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None);
            HttpResponseMessage actualResponse = await task;

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(response, actualResponse);
        }

        [Fact]
        public async Task ExecuteAsync_Faults_And_Traces_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException();
            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
            tcs.TrySetException(exception);
            Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
            mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(tcs.Task);

            HttpRequestMessage request = new HttpRequestMessage();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
            controllerContext.ControllerDescriptor = _controllerDescriptor;
            controllerContext.Controller = mockController.Object;

            HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            // Act
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public async Task ExecuteAsync_IsCancelled_And_Traces_When_Inner_IsCancelled()
        {
            // Arrange
            Mock<ApiController> mockController = new Mock<ApiController>() { CallBase = true };
            mockController.Setup(b => b.ExecuteAsync(It.IsAny<HttpControllerContext>(), It.IsAny<CancellationToken>())).Returns(TaskHelpers.Canceled<HttpResponseMessage>());

            HttpRequestMessage request = new HttpRequestMessage();
            HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
            controllerContext.ControllerDescriptor = _controllerDescriptor;
            controllerContext.Controller = mockController.Object;

            HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Warn) { Kind = TraceKind.End }
            };

            // Act
            Task task = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None);
            Exception thrown = await Assert.ThrowsAsync<TaskCanceledException>(() => task);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_HttpControllerTracer_Returns_IHttpController()
        {
            // Arrange
            IHttpController expectedInner = new Mock<IHttpController>().Object;
            HttpControllerTracer productUnderTest = new HttpControllerTracer(new HttpRequestMessage(), expectedInner, new TestTraceWriter());

            // Act
            IHttpController actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpControllerTracer_Returns_IHttpController()
        {
            // Arrange
            IHttpController expectedInner = new Mock<IHttpController>().Object;
            HttpControllerTracer productUnderTest = new HttpControllerTracer(new HttpRequestMessage(), expectedInner, new TestTraceWriter());

            // Act
            IHttpController actualInner = Decorator.GetInner(productUnderTest as IHttpController);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/HttpParameterBindingTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding;
using System.Web.Http.Services;
using System.Web.Http.ValueProviders;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class HttpParameterBindingTracerTest
    {
        [Fact]
        public void ErrorMessage_Calls_Inner()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object);
            mockBinding.Setup(b => b.ErrorMessage).Returns("errorMessage").Verifiable();
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.Equal("errorMessage", tracer.ErrorMessage);
            mockBinding.Verify();
        }

        [Fact]
        public void WillReadBody_Calls_Inner()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object);
            mockBinding.Setup(b => b.WillReadBody).Returns(true).Verifiable();
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.True(tracer.WillReadBody);
            mockBinding.Verify();
        }

        [Fact]
        public void Descriptor_Uses_Inners()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object) { CallBase = true };
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act & Assert
            Assert.Same(mockBinding.Object.Descriptor, tracer.Descriptor);
        }

        [Fact]
        public void ValueProviderFactories_Calls_Inner()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<IModelBinder> mockModelBinder = new Mock<IModelBinder>() { CallBase = true };
            Mock<ValueProviderFactory> mockValueProviderFactory = new Mock<ValueProviderFactory>() { CallBase = true };

            List<ValueProviderFactory> expectedFactories = new List<ValueProviderFactory>
            {
                mockValueProviderFactory.Object
            };

            ModelBinderParameterBinding binding = new ModelBinderParameterBinding(mockParamDescriptor.Object, mockModelBinder.Object, expectedFactories);
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(binding, new TestTraceWriter());

            // Act
            List<ValueProviderFactory> actualFactories = tracer.ValueProviderFactories.ToList();

            // Assert
            Assert.Equal(expectedFactories, actualFactories);
        }

        [Fact]
        public void ValueProviderFactories_Returns_Empty_Enumerable_When_Not_IValueProviderParameterBinding()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object);
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, new TestTraceWriter());

            // Act
            ValueProviderFactory[] actualFactories = tracer.ValueProviderFactories.ToArray();

            // Assert
            Assert.Empty(actualFactories);
        }

        [Fact]
        public async Task ExecuteBindingAsync_Traces_And_Invokes_Inner()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object) { CallBase = true };
            bool innerInvoked = false;
            mockBinding.Setup(
                b =>
                b.ExecuteBindingAsync(It.IsAny<ModelMetadataProvider>(), It.IsAny<HttpActionContext>(),
                                      It.IsAny<CancellationToken>())).Returns(TaskHelpers.Completed()).Callback(() => innerInvoked = true);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, traceWriter);
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
            };

            // Act
            await tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.True(innerInvoked);
        }

        [Fact]
        public void ExecuteBindingAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object) { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            mockBinding.Setup(
                b =>
                b.ExecuteBindingAsync(It.IsAny<ModelMetadataProvider>(), It.IsAny<HttpActionContext>(),
                                      It.IsAny<CancellationToken>())).Throws(exception);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, traceWriter);
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
            };

            // Act & Assert
            Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None));

            // Assert
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public async Task ExecuteBindingAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange

            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            Mock<HttpParameterBinding> mockBinding = new Mock<HttpParameterBinding>(mockParamDescriptor.Object) { CallBase = true };
            InvalidOperationException exception = new InvalidOperationException("test");
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.TrySetException(exception);

            mockBinding.Setup(
                b =>
                b.ExecuteBindingAsync(It.IsAny<ModelMetadataProvider>(), It.IsAny<HttpActionContext>(),
                                      It.IsAny<CancellationToken>())).Returns(tcs.Task);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpParameterBindingTracer tracer = new HttpParameterBindingTracer(mockBinding.Object, traceWriter);
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            ModelMetadataProvider metadataProvider = new EmptyModelMetadataProvider();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ExecuteBindingAsync" },
                new TraceRecord(actionContext.Request, TraceCategories.ModelBindingCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "ExecuteBindingAsync" }
            };

            // Act & Assert
            Task task = tracer.ExecuteBindingAsync(metadataProvider, actionContext, CancellationToken.None);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void Inner_Property_On_HttpParameterBindingTracer_Returns_HttpParameterBinding()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            HttpParameterBinding expectedInner = new Mock<HttpParameterBinding>(mockParamDescriptor.Object).Object;
            HttpParameterBindingTracer productUnderTest = new HttpParameterBindingTracer(expectedInner, new TestTraceWriter());

            // Act
            HttpParameterBinding actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_HttpParameterBindingTracer_Returns_HttpParameterBinding()
        {
            // Arrange
            Mock<HttpParameterDescriptor> mockParamDescriptor = new Mock<HttpParameterDescriptor>() { CallBase = true };
            mockParamDescriptor.Setup(d => d.ParameterName).Returns("paramName");
            mockParamDescriptor.Setup(d => d.ParameterType).Returns(typeof(string));
            HttpParameterBinding expectedInner = new Mock<HttpParameterBinding>(mockParamDescriptor.Object).Object;
            HttpParameterBindingTracer productUnderTest = new HttpParameterBindingTracer(expectedInner, new TestTraceWriter());

            // Act
            HttpParameterBinding actualInner = Decorator.GetInner(productUnderTest as HttpParameterBinding);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/JsonMediaTypeFormatterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;
using Newtonsoft.Json;

namespace System.Web.Http.Tracing.Tracers
{
    public class JsonMediaTypeFormatterTracerTest : ReadWriteMediaTypeFormatterTracerTestBase<JsonMediaTypeFormatter>
    {
        public override MediaTypeFormatter CreateTracer(JsonMediaTypeFormatter formatter, HttpRequestMessage request, ITraceWriter traceWriter)
        {
            return new JsonMediaTypeFormatterTracer(formatter, traceWriter, request);
        }

        [Fact]
        public void UseDataContractJsonSerializer_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            JsonMediaTypeFormatter innerFormatter = new JsonMediaTypeFormatter();
            innerFormatter.UseDataContractJsonSerializer = !innerFormatter.UseDataContractJsonSerializer;
            JsonMediaTypeFormatterTracer tracer = new JsonMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.UseDataContractJsonSerializer, tracer.UseDataContractJsonSerializer);
        }

        [Fact]
        public void MaxDepth_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            JsonMediaTypeFormatter innerFormatter = new JsonMediaTypeFormatter();
            innerFormatter.MaxDepth = innerFormatter.MaxDepth + 1;
            JsonMediaTypeFormatterTracer tracer = new JsonMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.MaxDepth, tracer.MaxDepth);
        }

        [Fact]
        public void Indent_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            JsonMediaTypeFormatter innerFormatter = new JsonMediaTypeFormatter();
            innerFormatter.Indent = !innerFormatter.Indent;
            JsonMediaTypeFormatterTracer tracer = new JsonMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.Indent, tracer.Indent);
        }

        [Fact]
        public void SerializerSettings_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            JsonSerializerSettings serializerSettings = new JsonSerializerSettings();
            JsonMediaTypeFormatter innerFormatter = new JsonMediaTypeFormatter() { SerializerSettings = serializerSettings };
            JsonMediaTypeFormatterTracer tracer = new JsonMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Same(innerFormatter.SerializerSettings, tracer.SerializerSettings);
        }

        [Fact]
        public void Inner_Property_On_JsonMediaTypeFormatterTracerTest_Returns_JsonMediaTypeFormatter()
        {
            // Arrange
            JsonMediaTypeFormatter expectedInner = new JsonMediaTypeFormatter();
            JsonMediaTypeFormatterTracer productUnderTest = new JsonMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            JsonMediaTypeFormatter actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_JsonMediaTypeFormatterTracerTest_Returns_JsonMediaTypeFormatter()
        {
            // Arrange
            JsonMediaTypeFormatter expectedInner = new JsonMediaTypeFormatter();
            JsonMediaTypeFormatterTracer productUnderTest = new JsonMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            JsonMediaTypeFormatter actualInner = Decorator.GetInner(productUnderTest as JsonMediaTypeFormatter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        public static IEnumerable<object[]> RequestBodies
        {
            get
            {
                HttpRequestMessage request = new HttpRequestMessage();
                return new[]
                {
                    new object[]
                    {
                        new List<TraceRecord>
                        {
                            new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                            {
                                Kind = TraceKind.Begin,
                                Operation = "ReadFromStreamAsync",
                                Message = "Type='SampleType', content-type='application/json'",
                                Operator = "JsonMediaTypeFormatter"
                            },
                            new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                            {
                                Kind = TraceKind.End,
                                Operation = "ReadFromStreamAsync",
                                Message = "Value read='System.Net.Http.Formatting.SampleType'",
                                Operator = "JsonMediaTypeFormatter"
                            },
                        },
                        request,
                        "{\"Number\":42}"
                    },
                    new object[]
                    {
                        new List<TraceRecord>
                        {
                            new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                            {
                                Kind = TraceKind.Begin,
                                Operation = "ReadFromStreamAsync",
                                Message = "Type='SampleType', content-type='application/json'",
                                Operator = "JsonMediaTypeFormatter"
                            },
                            new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
                            {
                                Kind = TraceKind.Trace,
                                Operation = "ReadFromStreamAsync",
                                Operator = "JsonMediaTypeFormatter",
                                Exception = new JsonReaderException(
                                    "Unterminated string. Expected delimiter: \". Path '', line 1, position 12.")
                            },
                            new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                            {
                                Kind = TraceKind.End,
                                Operation = "ReadFromStreamAsync",
                                Message = "Value read='null'",
                                Operator = "JsonMediaTypeFormatter"
                            },
                        },
                        request,
                        "{\"Number:42}"
                    }
                };
            }
        }

        [Theory]
        [ReplaceCulture]
        [PropertyData("RequestBodies")]
        public async Task ReadFromStreamAsync_LogErrorFromJsonRequestBody(IList<TraceRecord> expectedTraces,
                                                                    HttpRequestMessage request,
                                                                    string requestBody)
        {
            // Arrange
            var formatter = new JsonMediaTypeFormatter();
            formatter.UseDataContractJsonSerializer = false;
            HttpContent content = new StringContent(requestBody);
            content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
            var loggerMock = new Mock<IFormatterLogger>();
            loggerMock.Setup(l => l.LogError(It.IsAny<string>(), It.IsAny<Exception>()));
            TestTraceWriter traceWriter = new TestTraceWriter();
            var tracer = new MediaTypeFormatterTracer(formatter, traceWriter, request);

            // Act
            await tracer.ReadFromStreamAsync(typeof(SampleType),
                                       await content.ReadAsStreamAsync(),
                                       content, loggerMock.Object
                                      );

            // Assert
            // Error must always be marked as handled at ReadFromStream in BaseJsonMediaTypeFormatters,
            // so it would not propagate to here.
            // Note that regarding the exception's comparison in the record we only compare its message,
            // because we cannot get the exact exception and message would be enough for logging.
            Assert.Equal<TraceRecord>(expectedTraces,
                                      traceWriter.Traces,
                                      new TraceRecordComparer() { IgnoreExceptionReference = true });
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/MediaTypeFormatterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics.Contracts;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class MediaTypeFormatterTracerTest
    {
        public static TheoryDataSet<MediaTypeFormatter> AllKnownFormatters
        {
            get
            {
                return new TheoryDataSet<MediaTypeFormatter>
                {
                    new XmlMediaTypeFormatter(), 
                    new JsonMediaTypeFormatter(),
                    new FormUrlEncodedMediaTypeFormatter(),
                    new Mock<BufferedMediaTypeFormatter>().Object
                };
            }
        }

        [Theory]
        [PropertyData("AllKnownFormatters")]
        public void CreateTracer_Returns_Tracing_Formatter(MediaTypeFormatter formatter)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();

            // Act
            MediaTypeFormatter tracingFormatter = MediaTypeFormatterTracer.CreateTracer(formatter, new TestTraceWriter(), request);

            // Assert
            IFormatterTracer tracer = Assert.IsAssignableFrom<IFormatterTracer>(tracingFormatter);
            Assert.Same(formatter, tracer.InnerFormatter);
        }

        [Theory]
        [PropertyData("AllKnownFormatters")]
        public void Inner_Property_On_All_MediaTypeFormatterTracers_Returns_Object_Of_Type_MediaTypeFormatter(MediaTypeFormatter formatter)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            MediaTypeFormatter formatterTracer = MediaTypeFormatterTracer.CreateTracer(formatter, new TestTraceWriter(), request);

            // Act
            MediaTypeFormatter innerFormatter = (formatterTracer as IDecorator<MediaTypeFormatter>).Inner;

            // Assert
            Assert.Same(formatter, innerFormatter);
        }

        [Theory]
        [PropertyData("AllKnownFormatters")]
        public void Decorator_GetInner_On_All_MediaTypeFormatterTracers_Returns_Object_Of_Type_MediaTypeFormatter(MediaTypeFormatter formatter)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            MediaTypeFormatter formatterTracer = MediaTypeFormatterTracer.CreateTracer(formatter, new TestTraceWriter(), request);

            // Act
            MediaTypeFormatter innerFormatter = Decorator.GetInner(formatterTracer);

            // Assert
            Assert.Same(formatter, innerFormatter);
        }

        [Fact]
        public async Task ReadFromStream_Traces()
        {
            // Arrange
            string contentType = "text/plain";
            object value = new object();
            CustomMediaTypeFormatter formatter = new CustomMediaTypeFormatter(value);
            formatter.SupportedMediaTypes.Add(MediaTypeHeaderValue.Parse(contentType));

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("42", Encoding.Default, contentType);
            MediaTypeFormatterTracer tracer = new MediaTypeFormatterTracer(formatter, traceWriter, request);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "ReadFromStreamAsync" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "ReadFromStreamAsync" }
            };

            // Act
            object valueReturned = await request.Content.ReadAsAsync<object>(new[] { tracer });

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Equal(value, valueReturned);
        }

        [Fact]
        public async Task WriteToStream_Traces()
        {
            // Arrange
            object value = new object();
            CustomMediaTypeFormatter formatter = new CustomMediaTypeFormatter(value);
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            MediaTypeFormatterTracer tracer = new MediaTypeFormatterTracer(formatter, traceWriter, request);
            request.Content = new ObjectContent<object>(value, tracer);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "WriteToStreamAsync" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "WriteToStreamAsync" }
            };

            // Act
            await request.Content.CopyToAsync(new MemoryStream());

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        [ReplaceCulture]
        public void FormatterLoggerTracer_LogErrorException()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            string operatorName = this.GetType().Name;
            string operationName = "FormatterLoggerTracer_LogErrorException";
            var loggerMock = new Mock<IFormatterLogger>();
            loggerMock.Setup(o => o.LogError(It.IsAny<string>(), It.IsAny<Exception>()));
            IFormatterLogger tracer = new FormatterLoggerTraceWrapper(loggerMock.Object, traceWriter, request, operatorName, operationName);
            Exception exception = new Exception("message");
            string errorPath = "errorPath";
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error) 
                {
                    Kind = TraceKind.Trace, Operation = operationName, Exception = exception, Operator = operatorName
                },
            };

            // Act
            tracer.LogError(errorPath, exception);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        [ReplaceCulture]
        public void FormatterLoggerTracer_LogErrorMessage()
        {
            // Arrange
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            string operatorName = this.GetType().Name;
            string operationName = "FormatterLoggerTracer_LogErrorMessage";
            var loggerMock = new Mock<IFormatterLogger>();
            loggerMock.Setup(o => o.LogError(It.IsAny<string>(), It.IsAny<string>()));
            IFormatterLogger tracer = new FormatterLoggerTraceWrapper(loggerMock.Object, traceWriter, request, operatorName, operationName);
            string errorMessage = "errorMessage";
            string errorPath = "errorPath";
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
                {
                    Kind = TraceKind.Trace, Operation = operationName, Message = errorMessage, Operator = operatorName 
                },
            };

            // Act
            tracer.LogError(errorPath, errorMessage);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        private class CustomMediaTypeFormatter : MediaTypeFormatter
        {
            private object _result;

            public CustomMediaTypeFormatter(object result)
            {
                Contract.Assert(result != null);
                _result = result;
            }

            public override bool CanReadType(Type type)
            {
                return true;
            }

            public override bool CanWriteType(Type type)
            {
                return true;
            }

            public override Task<object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content,
                IFormatterLogger formatterLogger, CancellationToken cancellationToken)
            {
                return Task.FromResult(_result);
            }

            public override Task WriteToStreamAsync(Type type, object value, Stream writeStream, HttpContent content,
                TransportContext transportContext, CancellationToken cancellationToken)
            {
                return Task.FromResult(_result);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/MediaTypeFormatterTracerTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    // Abstract base test class for MediaTypeFormatter tracers.
    // This tests core functionality common to all MediaTypeFormatters.
    // It does not test read/write paths because BufferedMediaTypeFormatter
    // has sealed those methods, and they cannot be overridden by mocks.
    // Refer to ReadWriteMediaTypeFormatterTracerTestBase for read/write tests.
    public abstract class MediaTypeFormatterTracerTestBase<TFormatter> 
        where TFormatter: MediaTypeFormatter
    {
        public abstract MediaTypeFormatter CreateTracer(TFormatter formatter, HttpRequestMessage request, ITraceWriter traceWriter);

        [Fact]
        public void CanReadType_Calls_Inner()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };

            mockFormatter.Setup(f => f.CanReadType(randomType)).Returns(true).Verifiable();
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.CanReadType(randomType);

            // Assert
            Assert.True(valueReturned);
            mockFormatter.Verify();
        }

        [Fact]
        public void CanWriteType_Calls_Inner()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            mockFormatter.Setup(f => f.CanWriteType(randomType)).Returns(true).Verifiable();
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act
            bool valueReturned = tracer.CanWriteType(randomType);

            // Assert
            Assert.True(valueReturned);
            mockFormatter.Verify();
        }

        [Fact]
        public void GetPerRequestFormatterInstance_Calls_Inner_And_Wraps_Tracer_Around_It()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("plain/text");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter formatterObject = mockFormatter.Object;

            mockFormatter.Setup(f => f.GetPerRequestFormatterInstance(randomType, request, mediaType)).Returns(formatterObject).Verifiable();
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act
            MediaTypeFormatter valueReturned = tracer.GetPerRequestFormatterInstance(randomType, request, mediaType);

            // Assert
            IFormatterTracer tracerReturned = Assert.IsAssignableFrom<IFormatterTracer>(valueReturned);
            Assert.Same(formatterObject, tracerReturned.InnerFormatter);
            mockFormatter.Verify();
        }

        [Fact]
        public void SetDefaultContentHeaders_Calls_Inner()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            HttpContentHeaders contentHeaders = new StringContent("").Headers;
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("plain/text");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter formatterObject = mockFormatter.Object;

            mockFormatter.Setup(f => f.SetDefaultContentHeaders(randomType, contentHeaders, mediaType)).Verifiable();
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act
            tracer.SetDefaultContentHeaders(randomType, contentHeaders, mediaType);

            // Assert
            mockFormatter.Verify();
        }

        [Fact]
        public void SupportedMediaTypes_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/fake");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            innerFormatter.SupportedMediaTypes.Clear();
            innerFormatter.SupportedMediaTypes.Add(mediaType);
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act & Assert
            Assert.Same(innerFormatter.SupportedMediaTypes, tracer.SupportedMediaTypes);
        }

        [Fact]
        public void MediaTypeMappings_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/fake");
            Mock<MediaTypeMapping> mockMapping = new Mock<MediaTypeMapping>(mediaType);
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            innerFormatter.MediaTypeMappings.Clear();
            innerFormatter.MediaTypeMappings.Add(mockMapping.Object);
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act & Assert
            Assert.Same(innerFormatter.MediaTypeMappings, tracer.MediaTypeMappings);
        }

        [Fact]
        public void SupportedEncodings_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Mock<Encoding> mockEncoding = new Mock<Encoding>();
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            innerFormatter.SupportedEncodings.Clear();
            innerFormatter.SupportedEncodings.Add(mockEncoding.Object);
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act & Assert
            Assert.Same(innerFormatter.SupportedEncodings, tracer.SupportedEncodings);
        }

        [Fact]
        public void RequiredMemberSelector_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Mock<IRequiredMemberSelector> mockSelector = new Mock<IRequiredMemberSelector>();
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            innerFormatter.RequiredMemberSelector = mockSelector.Object;
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());

            // Act & Assert
            Assert.Same(innerFormatter.RequiredMemberSelector, tracer.RequiredMemberSelector);
        }

        [Fact]
        public void GetPerRequestFormatterInstance_SupportedMediaTypes_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/fake");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());
            tracer.SupportedMediaTypes.Add(mediaType);

            // Act
            MediaTypeFormatter valueReturned = innerFormatter.GetPerRequestFormatterInstance(randomType, request, mediaType);

            // Assert
            Assert.Same(tracer.SupportedMediaTypes, valueReturned.SupportedMediaTypes);
            Assert.Same(tracer.SupportedMediaTypes, innerFormatter.SupportedMediaTypes);
        }

        [Fact]
        public void GetPerRequestFormatterInstance_MediaTypeMappings_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/fake");
            Mock<MediaTypeMapping> mockMapping = new Mock<MediaTypeMapping>(mediaType);
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());
            tracer.MediaTypeMappings.Add(mockMapping.Object);

            // Act
            MediaTypeFormatter valueReturned = innerFormatter.GetPerRequestFormatterInstance(randomType, request, mediaType);

            // Assert
            Assert.Same(tracer.MediaTypeMappings, valueReturned.MediaTypeMappings);
            Assert.Same(tracer.MediaTypeMappings, innerFormatter.MediaTypeMappings);
        }

        [Fact]
        public void GetPerRequestFormatterInstance_SupportedEncodings_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/fake");
            Mock<Encoding> mockEncoding = new Mock<Encoding>();
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());
            tracer.SupportedEncodings.Add(mockEncoding.Object);

            // Act
            MediaTypeFormatter valueReturned = innerFormatter.GetPerRequestFormatterInstance(randomType, request, mediaType);

            // Assert
            Assert.Same(tracer.SupportedEncodings, valueReturned.SupportedEncodings);
            Assert.Same(tracer.SupportedEncodings, innerFormatter.SupportedEncodings);
        }

        [Fact]
        public void GetPerRequestFormatterInstance_RequiredMemberSelector_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            Type randomType = typeof(string);
            MediaTypeHeaderValue mediaType = new MediaTypeHeaderValue("text/fake");
            Mock<IRequiredMemberSelector> mockSelector = new Mock<IRequiredMemberSelector>();
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            MediaTypeFormatter innerFormatter = mockFormatter.Object;
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, new TestTraceWriter());
            tracer.RequiredMemberSelector = mockSelector.Object;

            // Act
            MediaTypeFormatter valueReturned = innerFormatter.GetPerRequestFormatterInstance(randomType, request, mediaType);

            // Assert
            Assert.Same(tracer.RequiredMemberSelector, valueReturned.RequiredMemberSelector);
            Assert.Same(tracer.RequiredMemberSelector, innerFormatter.RequiredMemberSelector);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/MessageHandlerTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class MessageHandlerTracerTest
    {
        [Fact]
        public async Task SendAsync_Traces_And_Invokes_Inner()
        {
            // Arrange
            HttpResponseMessage response = new HttpResponseMessage();
            MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) =>
                                                 Task.FromResult<HttpResponseMessage>(response));

            TestTraceWriter traceWriter = new TestTraceWriter();
            MessageHandlerTracer tracer = new MessageHandlerTracer(mockHandler, traceWriter);
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) =>
                                     Task.FromResult<HttpResponseMessage>(response));
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SendAsync" },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "SendAsync" }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Task<HttpResponseMessage> task = method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task<HttpResponseMessage>;
            HttpResponseMessage actualResponse = await task;

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(response, actualResponse);
        }

        [Fact]
        public void SendAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) => { throw exception; });

            TestTraceWriter traceWriter = new TestTraceWriter();
            MessageHandlerTracer tracer = new MessageHandlerTracer(mockHandler, traceWriter);

            // DelegatingHandlers require an InnerHandler to run.  We create a mock one to simulate what
            // would happen when a DelegatingHandler executing after the tracer throws.
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { throw exception; });
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SendAsync" },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "SendAsync" }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Exception thrown =
                Assert.Throws<TargetInvocationException>(
                    () => method.Invoke(tracer, new object[] { request, CancellationToken.None }));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown.InnerException);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public async Task SendAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
            tcs.TrySetException(exception);
            MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) => { return tcs.Task; });

            TestTraceWriter traceWriter = new TestTraceWriter();
            MessageHandlerTracer tracer = new MessageHandlerTracer(mockHandler, traceWriter);

            // DelegatingHandlers require an InnerHandler to run.  We create a mock one to simulate what
            // would happen when a DelegatingHandler executing after the tracer returns a Task that throws.
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { return tcs.Task; });
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SendAsync" },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "SendAsync" }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Task<HttpResponseMessage> task =
                method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task<HttpResponseMessage>;

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }


        // DelegatingHandler cannot be mocked with Moq
        private class MockDelegatingHandler : DelegatingHandler
        {
            private Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _callback;

            public MockDelegatingHandler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> callback)
                : base()
            {
                _callback = callback;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return _callback(request, cancellationToken);
            }
        }

        // HttpMessageHandler cannot be mocked with Moq
        private class MockHttpMessageHandler : HttpMessageHandler
        {
            private Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _callback;

            public MockHttpMessageHandler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> callback)
                : base()
            {
                _callback = callback;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return _callback(request, cancellationToken);
            }
        }

        [Fact]
        public void Inner_Property_On_MessageHandlerTracer_Returns_DelegatingHandler()
        {
            // Arrange
            DelegatingHandler expectedInner = new Mock<DelegatingHandler>().Object;
            MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter());

            // Act
            DelegatingHandler actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_MessageHandlerTracer_Returns_DelegatingHandler()
        {
            // Arrange
            DelegatingHandler expectedInner = new Mock<DelegatingHandler>().Object;
            MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter());

            // Act
            DelegatingHandler actualInner = Decorator.GetInner(productUnderTest as DelegatingHandler);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/OverrideFilterTracerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.ObjectModel;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    public class OverrideFilterTracerTests
    {
        [Fact]
        public void InnerFilter_IsSpecifiedInstance()
        {
            // Arrange
            IOverrideFilter expectedInnerFilter = CreateDummyInnerFilter();
            ITraceWriter traceWriter = CreateDummyTraceWriter();
            FilterTracer product = CreateProductUnderTest(expectedInnerFilter, traceWriter);

            // Act
            IFilter innerFilter = product.InnerFilter;

            // Assert
            Assert.Same(expectedInnerFilter, innerFilter);
        }

        [Fact]
        public void Filter_IsSpecifiedInstance()
        {
            // Arrange
            IOverrideFilter expectedInnerFilter = CreateDummyInnerFilter();
            ITraceWriter traceWriter = CreateDummyTraceWriter();
            IDecorator<IOverrideFilter> product = CreateProductUnderTest(expectedInnerFilter, traceWriter);

            // Act
            IOverrideFilter innerFilter = product.Inner;

            // Assert
            Assert.Same(expectedInnerFilter, innerFilter);
        }

        [Fact]
        public void TraceWriter_IsSpecifiedInstance()
        {
            // Arrange
            IOverrideFilter innerFilter = CreateDummyInnerFilter();
            ITraceWriter expectedTraceWriter = CreateDummyTraceWriter();
            FilterTracer product = CreateProductUnderTest(innerFilter, expectedTraceWriter);

            // Act
            ITraceWriter traceWriter = product.TraceWriter;

            // Assert
            Assert.Same(expectedTraceWriter, traceWriter);
        }

        [Fact]
        public void FiltersToOverride_IsInnerFilterSpecifiedInstance()
        {
            // Arrange
            Type expectedFiltersToOverride = typeof(IActionFilter);
            IOverrideFilter innerFilter = CreateStubInnerFilter(expectedFiltersToOverride);
            ITraceWriter traceWriter = CreateDummyTraceWriter();
            IOverrideFilter product = CreateProductUnderTest(innerFilter, traceWriter);

            // Act
            Type filtersToOverride = product.FiltersToOverride;

            // Assert
            Assert.Same(expectedFiltersToOverride, filtersToOverride);
        }

        private static IOverrideFilter CreateDummyInnerFilter()
        {
            return new Mock<IOverrideFilter>(MockBehavior.Strict).Object;
        }

        private static ITraceWriter CreateDummyTraceWriter()
        {
            return new Mock<ITraceWriter>(MockBehavior.Strict).Object;
        }

        private static OverrideFilterTracer CreateProductUnderTest(IOverrideFilter innerFilter,
            ITraceWriter traceWriter)
        {
            return new OverrideFilterTracer(innerFilter, traceWriter);
        }

        private static IOverrideFilter CreateStubInnerFilter(Type filtersToOverride)
        {
            Mock<IOverrideFilter> mock = new Mock<IOverrideFilter>();
            mock.Setup(f => f.FiltersToOverride).Returns(filtersToOverride);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/ReadWriteMediaTypeFormatterTracerTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Tracing.Tracers
{
    // This abstract base for MediaTypeFormatterTracers extends the core tests
    // by adding read/write tests.  BufferedMediaTypeFormatter sealed its async
    // read and write methods and they cannot be overridden by mocks.  This
    // abstract base is used for all MediaTypeFormatters whose read/write methods
    // can be overridden.
    public abstract class ReadWriteMediaTypeFormatterTracerTestBase<TFormatter> : MediaTypeFormatterTracerTestBase<TFormatter>
        where TFormatter : MediaTypeFormatter
    {
        [Fact]
        public async Task ReadFromStreamAsync_Traces()
        {
            // Arrange
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            mockFormatter.Setup(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns(Task.FromResult<object>("sampleValue"));
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);

            TraceRecord[] expectedTraces = new TraceRecord[]
                {
                    new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                        { Kind = TraceKind.Begin, Operation = "ReadFromStreamAsync" },
                    new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                        { Kind = TraceKind.End, Operation = "ReadFromStreamAsync" }
                };

            // Act
            Task<object> task = tracer.ReadFromStreamAsync(typeof(string), new MemoryStream(), request.Content, null);
            string result = (await task) as string;

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Equal("sampleValue", result);
        }

        [Fact]
        public void ReadFromStreamAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            mockFormatter.Setup(
                f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>())).Throws(exception);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                    { Kind = TraceKind.Begin, Operation = "ReadFromStreamAsync" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
                    { Kind = TraceKind.End, Operation = "ReadFromStreamAsync" }
            };

            // Act
            Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.ReadFromStreamAsync(typeof(string), new MemoryStream(), request.Content, null));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public async Task ReadFromStreamAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.TrySetException(exception);

            mockFormatter.Setup(f => f.ReadFromStreamAsync(It.IsAny<Type>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<IFormatterLogger>()))
                .Returns(tcs.Task);
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                    { Kind = TraceKind.Begin, Operation = "ReadFromStreamAsync" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
                    { Kind = TraceKind.End, Operation = "ReadFromStreamAsync" }
            };

            // Act
            Task<object> task = tracer.ReadFromStreamAsync(typeof(string), new MemoryStream(), request.Content, null);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public async Task WriteToStreamAsync_Traces()
        {
            // Arrange
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            mockFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<Object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<TransportContext>()))
                .Returns(TaskHelpers.Completed());
            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                    { Kind = TraceKind.Begin, Operation = "WriteToStreamAsync" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                    { Kind = TraceKind.End, Operation = "WriteToStreamAsync" }
            };

            // Act
            await tracer.WriteToStreamAsync(typeof(string), "sampleValue", new MemoryStream(), request.Content, transportContext: null);

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
        }

        [Fact]
        public void WriteToStreamAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            mockFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<Object>(), It.IsAny<Stream>(),
                                                         It.IsAny<HttpContent>(), It.IsAny<TransportContext>()))
                .Throws(exception);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                    { Kind = TraceKind.Begin, Operation = "WriteToStreamAsync" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
                    { Kind = TraceKind.End, Operation = "WriteToStreamAsync" }
            };

            // Act
            Exception thrown = Assert.Throws<InvalidOperationException>(() => tracer.WriteToStreamAsync(typeof(string), "sampleValue", new MemoryStream(), request.Content, transportContext: null));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public async Task WriteToStreamAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            Mock<TFormatter> mockFormatter = new Mock<TFormatter>() { CallBase = true };
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.TrySetException(exception);

            mockFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<Object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<TransportContext>()))
                .Returns(tcs.Task);

            TestTraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            request.Content = new StringContent("");
            MediaTypeFormatter tracer = CreateTracer(mockFormatter.Object, request, traceWriter);
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Info)
                    { Kind = TraceKind.Begin, Operation = "WriteToStreamAsync" },
                new TraceRecord(request, TraceCategories.FormattingCategory, TraceLevel.Error)
                    { Kind = TraceKind.End, Operation = "WriteToStreamAsync" }
            };

            // Act
            Task task = tracer.WriteToStreamAsync(typeof(string), "sampleValue", new MemoryStream(), request.Content, transportContext: null);

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/RequestMessageHandlerTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;

namespace System.Web.Http.Tracing.Tracers
{
    public class RequestMessageHandlerTracerTest
    {
        [Fact]
        public async Task SendAsync_Traces_And_Invokes_Inner()
        {
            // Arrange
            HttpResponseMessage response = new HttpResponseMessage();
            TestTraceWriter traceWriter = new TestTraceWriter();
            RequestMessageHandlerTracer tracer = new RequestMessageHandlerTracer(traceWriter);
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) =>
                                     Task.FromResult<HttpResponseMessage>(response));
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Info) { Kind = TraceKind.End }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Task<HttpResponseMessage> task = method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task<HttpResponseMessage>;
            HttpResponseMessage actualResponse = await task;

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(response, actualResponse);
        }

        [Fact]
        public void SendAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            TestTraceWriter traceWriter = new TestTraceWriter();
            RequestMessageHandlerTracer tracer = new RequestMessageHandlerTracer(traceWriter);

            // DelegatingHandlers require an InnerHandler to run.  We create a mock one to simulate what
            // would happen when a DelegatingHandler executing after the tracer throws.
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { throw exception; });
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Exception thrown =
                Assert.Throws<TargetInvocationException>(
                    () => method.Invoke(tracer, new object[] { request, CancellationToken.None }));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown.InnerException);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }

        [Fact]
        public async Task SendAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            TaskCompletionSource<HttpResponseMessage> tcs = new TaskCompletionSource<HttpResponseMessage>();
            tcs.TrySetException(exception);
            TestTraceWriter traceWriter = new TestTraceWriter();
            RequestMessageHandlerTracer tracer = new RequestMessageHandlerTracer(traceWriter);

            // DelegatingHandlers require an InnerHandler to run.  We create a mock one to simulate what
            // would happen when a DelegatingHandler executing after the tracer returns a Task that throws.
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { return tcs.Task; });
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Info) { Kind = TraceKind.Begin },
                new TraceRecord(request, TraceCategories.RequestCategory, TraceLevel.Error) { Kind = TraceKind.End }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Task<HttpResponseMessage> task =
                method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task<HttpResponseMessage>;

            // Assert
            Exception thrown = await Assert.ThrowsAsync<InvalidOperationException>(() => task);
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }


        // DelegatingHandler cannot be mocked with Moq
        private class MockDelegatingHandler : DelegatingHandler
        {
            private Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _callback;

            public MockDelegatingHandler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> callback)
                : base()
            {
                _callback = callback;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return _callback(request, cancellationToken);
            }
        }

        // HttpMessageHandler cannot be mocked with Moq
        private class MockHttpMessageHandler : HttpMessageHandler
        {
            private Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _callback;

            public MockHttpMessageHandler(Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> callback)
                : base()
            {
                _callback = callback;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return _callback(request, cancellationToken);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Tracing/Tracers/XmlMediaTypeFormatterTracerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.Services;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http.Tracing.Tracers
{
    public class XmlMediaTypeFormatterTracerTest : ReadWriteMediaTypeFormatterTracerTestBase<XmlMediaTypeFormatter>
    {
        public override MediaTypeFormatter CreateTracer(XmlMediaTypeFormatter formatter, HttpRequestMessage request, ITraceWriter traceWriter)
        {
            return new XmlMediaTypeFormatterTracer(formatter, traceWriter, request);
        }

        [Fact]
        public void UseXmlSerializer_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            XmlMediaTypeFormatter innerFormatter = new XmlMediaTypeFormatter();
            innerFormatter.UseXmlSerializer = !innerFormatter.UseXmlSerializer;
            XmlMediaTypeFormatterTracer tracer = new XmlMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.UseXmlSerializer, tracer.UseXmlSerializer);
        }

        [Fact]
        public void MaxDepth_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            XmlMediaTypeFormatter innerFormatter = new XmlMediaTypeFormatter();
            innerFormatter.MaxDepth = innerFormatter.MaxDepth + 1;
            XmlMediaTypeFormatterTracer tracer = new XmlMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.MaxDepth, tracer.MaxDepth);
        }

        [Fact]
        public void Indent_Uses_Inners()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            XmlMediaTypeFormatter innerFormatter = new XmlMediaTypeFormatter();
            innerFormatter.Indent = !innerFormatter.Indent;
            XmlMediaTypeFormatterTracer tracer = new XmlMediaTypeFormatterTracer(innerFormatter, new TestTraceWriter(), request);

            // Act & Assert
            Assert.Equal(innerFormatter.Indent, tracer.Indent);
        }

        [Fact]
        public void Inner_Property_On_XmlMediaTypeFormatterTracer_Returns_XmlMediaTypeFormatter()
        {
            // Arrange
            XmlMediaTypeFormatter expectedInner = new XmlMediaTypeFormatter();
            XmlMediaTypeFormatterTracer productUnderTest = new XmlMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            XmlMediaTypeFormatter actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void Decorator_GetInner_On_XmlMediaTypeFormatterTracer_Returns_XmlMediaTypeFormatter()
        {
            // Arrange
            XmlMediaTypeFormatter expectedInner = new XmlMediaTypeFormatter();
            XmlMediaTypeFormatterTracer productUnderTest = new XmlMediaTypeFormatterTracer(expectedInner, new TestTraceWriter(), new HttpRequestMessage());

            // Act
            XmlMediaTypeFormatter actualInner = Decorator.GetInner(productUnderTest as XmlMediaTypeFormatter);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }

        [Fact]
        public void CreateXmlReader_Calls_CreateXmlReaderOnInner()
        {
            // Arrange
            Stream stream = new Mock<Stream>().Object;
            HttpContent content = new StringContent("");
            Mock<XmlMediaTypeFormatter> formatter = new Mock<XmlMediaTypeFormatter>();
            XmlMediaTypeFormatterTracer tracer = CreateTracer(formatter.Object);

            // Act
            tracer.InvokeCreateXmlReader(stream, content);

            // Assert
            formatter.Protected().Verify("CreateXmlReader", Times.Once(), stream, content);
        }

        [Fact]
        public void CreateXmlWriter_Calls_CreateXmlWriterOnInner()
        {
            // Arrange
            Stream stream = new Mock<Stream>().Object;
            HttpContent content = new StringContent("");
            Mock<XmlMediaTypeFormatter> formatter = new Mock<XmlMediaTypeFormatter>();
            XmlMediaTypeFormatterTracer tracer = CreateTracer(formatter.Object);

            // Act
            tracer.InvokeCreateXmlWriter(stream, content);

            // Assert
            formatter.Protected().Verify("CreateXmlWriter", Times.Once(), stream, content);
        }

        [Fact]
        public void GetDeserializer_Calls_GetDeserializerOnInner()
        {
            // Arrange
            Type type = new Mock<Type>().Object;
            HttpContent content = new StringContent("");
            Mock<XmlMediaTypeFormatter> formatter = new Mock<XmlMediaTypeFormatter>();
            XmlMediaTypeFormatterTracer tracer = CreateTracer(formatter.Object);

            // Act
            tracer.InvokeGetDeserializer(type, content);

            // Assert
            formatter.Protected().Verify("GetDeserializer", Times.Once(), type, content);
        }

        [Fact]
        public void GetSerializer_Calls_GetSerializerOnInner()
        {
            // Arrange
            Type type = new Mock<Type>().Object;
            object value = new object();
            HttpContent content = new StringContent("");
            Mock<XmlMediaTypeFormatter> formatter = new Mock<XmlMediaTypeFormatter>();
            XmlMediaTypeFormatterTracer tracer = CreateTracer(formatter.Object);

            // Act
            tracer.InvokeGetSerializer(type, value, content);

            // Assert
            formatter.Protected().Verify("GetSerializer", Times.Once(), type, value, content);
        }

        private static XmlMediaTypeFormatterTracer CreateTracer(XmlMediaTypeFormatter inner)
        {
            ITraceWriter traceWriter = new TestTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage();
            return new XmlMediaTypeFormatterTracer(inner, traceWriter, request);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Util/ContextUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Filters;
using System.Web.Http.Routing;
using Moq;

namespace System.Web.Http
{
    internal static class ContextUtil
    {
        public static HttpControllerContext CreateControllerContext(HttpConfiguration configuration = null, IHttpController instance = null, IHttpRouteData routeData = null, HttpRequestMessage request = null)
        {
            HttpConfiguration config = configuration ?? new HttpConfiguration();
            IHttpRouteData route = routeData ?? new HttpRouteData(new HttpRoute());
            HttpRequestMessage req = request ?? new HttpRequestMessage();
            req.SetConfiguration(config);
            req.SetRouteData(route);

            HttpControllerContext context = new HttpControllerContext(config, route, req);
            if (instance != null)
            {
                context.Controller = instance;
            }
            context.ControllerDescriptor = CreateControllerDescriptor(config);

            return context;
        }

        public static HttpActionContext CreateActionContext(HttpControllerContext controllerContext = null, HttpActionDescriptor actionDescriptor = null)
        {
            HttpControllerContext context = controllerContext ?? ContextUtil.CreateControllerContext();
            HttpActionDescriptor descriptor = actionDescriptor ?? CreateActionDescriptor();
            descriptor.ControllerDescriptor = context.ControllerDescriptor;
            return new HttpActionContext(context, descriptor);
        }

        public static HttpActionContext GetHttpActionContext(HttpRequestMessage request)
        {
            HttpActionContext actionContext = CreateActionContext();
            actionContext.ControllerContext.Request = request;
            return actionContext;
        }

        public static HttpActionExecutedContext GetActionExecutedContext(HttpRequestMessage request, HttpResponseMessage response)
        {
            HttpActionContext actionContext = CreateActionContext();
            actionContext.ControllerContext.Request = request;
            HttpActionExecutedContext actionExecutedContext = new HttpActionExecutedContext(actionContext, null) { Response = response };
            return actionExecutedContext;
        }

        public static HttpControllerDescriptor CreateControllerDescriptor(HttpConfiguration config = null)
        {
            if (config == null)
            {
                config = new HttpConfiguration();
            }
            return new HttpControllerDescriptor() { Configuration = config, ControllerName = "FooController" };
        }

        public static HttpActionDescriptor CreateActionDescriptor()
        {
            var mock = new Mock<HttpActionDescriptor>() { CallBase = true };
            mock.SetupGet(d => d.ActionName).Returns("Bar");
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Util/SimpleHttpValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Web.Http.ValueProviders;

namespace System.Web.Http.Util
{
    public sealed class SimpleHttpValueProvider : Dictionary<string, object>, IValueProvider
    {
        private readonly CultureInfo _culture;

        public SimpleHttpValueProvider()
            : this(null)
        {
        }

        public SimpleHttpValueProvider(CultureInfo culture)
            : base(StringComparer.OrdinalIgnoreCase)
        {
            _culture = culture ?? CultureInfo.InvariantCulture;
        }

        // copied from ValueProviderUtil
        public bool ContainsPrefix(string prefix)
        {
            foreach (string key in Keys)
            {
                if (key != null)
                {
                    if (prefix.Length == 0)
                    {
                        return true; // shortcut - non-null key matches empty prefix
                    }

                    if (key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                    {
                        if (key.Length == prefix.Length)
                        {
                            return true; // exact match
                        }
                        else
                        {
                            switch (key[prefix.Length])
                            {
                                case '.': // known separator characters
                                case '[':
                                    return true;
                            }
                        }
                    }
                }
            }

            return false; // nothing found
        }

        public ValueProviderResult GetValue(string key)
        {
            object rawValue;
            if (TryGetValue(key, out rawValue))
            {
                return new ValueProviderResult(rawValue, Convert.ToString(rawValue, _culture), _culture);
            }
            else
            {
                // value not found
                return null;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/DefaultBodyModelValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.ModelBinding;
using System.Xml.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Validation
{
    public class DefaultBodyModelValidatorTest
    {
        private static Person LonelyPerson;

        static DefaultBodyModelValidatorTest()
        {
            LonelyPerson = new Person() { Name = "Reallllllllly Long Name" };
            LonelyPerson.Friend = LonelyPerson;
        }

        public static IEnumerable<object[]> ValidationErrors
        {
            get
            {
                return new TheoryDataSet<object, Type, Dictionary<string, string>>()
                {
                    // Primitives
                    { null, typeof(Person), new Dictionary<string, string>() },
                    { 14, typeof(int), new Dictionary<string, string>() },
                    { "foo", typeof(string), new Dictionary<string, string>() },

                    // Object Traversal : make sure we can traverse the object graph without throwing
                    { new ValueType() { Reference = "ref", Value = 256}, typeof(ValueType), new Dictionary<string, string>()},
                    { new ReferenceType() { Reference = "ref", Value = 256}, typeof(ReferenceType), new Dictionary<string, string>()},

                    // Classes
                    { new Person() { Name = "Rick", Profession = "Astronaut" }, typeof(Person), new Dictionary<string, string>() },
                    { new Person(), typeof(Person), new Dictionary<string, string>()
                        {
                            { "Name", "The Name field is required." },
                            { "Profession", "The Profession field is required." }
                        }
                    },

                    { new Person() { Name = "Rick", Friend = new Person() }, typeof(Person), new Dictionary<string, string>()
                        {
                            { "Profession", "The Profession field is required." },
                            { "Friend.Name", "The Name field is required." },
                            { "Friend.Profession", "The Profession field is required." }
                        }
                    },

                    // Collections
                    { new Person[] { new Person(), new Person() }, typeof(Person[]), new Dictionary<string, string>()
                        {
                            { "[0].Name", "The Name field is required." },
                            { "[0].Profession", "The Profession field is required." },
                            { "[1].Name", "The Name field is required." },
                            { "[1].Profession", "The Profession field is required." }
                        }
                    },

                    { new List<Person> { new Person(), new Person() }, typeof(Person[]), new Dictionary<string, string>()
                        {
                            { "[0].Name", "The Name field is required." },
                            { "[0].Profession", "The Profession field is required." },
                            { "[1].Name", "The Name field is required." },
                            { "[1].Profession", "The Profession field is required." }
                        }
                    },

                    { new Dictionary<string, Person> { { "Joe", new Person() } , { "Mark", new Person() } }, typeof(Dictionary<string, Person>), new Dictionary<string, string>()
                        {
                            { "[0].Value.Name", "The Name field is required." },
                            { "[0].Value.Profession", "The Profession field is required." },
                            { "[1].Value.Name", "The Name field is required." },
                            { "[1].Value.Profession", "The Profession field is required." }
                        }
                    },

                    // IValidatableObject's
                    { new ValidatableModel(), typeof(ValidatableModel), new Dictionary<string, string>()
                        {
                            { "", "Error1" },
                            { "Property1", "Error2" },
                            { "Property2", "Error3" },
                            { "Property3", "Error3" }
                        }
                    },
                    { new[] { new ValidatableModel() }, typeof(ValidatableModel[]), new Dictionary<string, string>()
                        {
                            { "[0]", "Error1" },
                            { "[0].Property1", "Error2" },
                            { "[0].Property2", "Error3" },
                            { "[0].Property3", "Error3" }
                        }
                    },

                    // Testing we don't blow up on cycles
                    { LonelyPerson, typeof(Person), new Dictionary<string, string>()
                        {
                            { "Name", "The field Name must be a string with a maximum length of 10." },
                            { "Profession", "The Profession field is required." }
                        }
                    },

                    // Testing that we don't bubble up exceptions when property getters throw
                    { new Uri("/api/values", UriKind.Relative), typeof(Uri), new Dictionary<string, string>() },

                    // Testing that excluded types don't result in any errors
                    { typeof(string), typeof(Type), new Dictionary<string, string>() },
                    { new byte[] { (byte)'a', (byte)'b' }, typeof(byte[]), new Dictionary<string, string>() },
                    { XElement.Parse("<xml>abc</xml>"), typeof(XElement), new Dictionary<string, string>() }
                };
            }
        }

        [Theory]
        [ReplaceCulture]
        [PropertyData("ValidationErrors")]
        public void ExpectedValidationErrorsRaised(object model, Type type, Dictionary<string, string> expectedErrors)
        {
            // Arrange
            ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();

            // Act
            Assert.DoesNotThrow(() =>
                new DefaultBodyModelValidator().Validate(model, type, metadataProvider, actionContext, string.Empty)
            );

            // Assert
            Dictionary<string, string> actualErrors = new Dictionary<string, string>();
            foreach (KeyValuePair<string, ModelState> keyStatePair in actionContext.ModelState)
            {
                foreach (ModelError error in keyStatePair.Value.Errors)
                {
                    actualErrors.Add(keyStatePair.Key, error.ErrorMessage);
                }
            }

            Assert.Equal(expectedErrors.Count, actualErrors.Count);
            foreach (KeyValuePair<string, string> keyErrorPair in expectedErrors)
            {
                Assert.Contains(keyErrorPair.Key, actualErrors.Keys);
                Assert.Equal(keyErrorPair.Value, actualErrors[keyErrorPair.Key]);
            }
        }

        [Fact]
        public void MultipleValidationErrorsOnSameMemberReported()
        {
            // Arrange
            ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            object model = new Address() { Street = "Microsoft Way" };

            // Act
            Assert.DoesNotThrow(() =>
                new DefaultBodyModelValidator().Validate(model, typeof(Address), metadataProvider, actionContext, string.Empty)
            );

            // Assert
            Assert.Contains("Street", actionContext.ModelState.Keys);
            ModelState streetState = actionContext.ModelState["Street"];
            Assert.Equal(2, streetState.Errors.Count);
        }

        [Fact]
        public void ExcludedTypes_AreNotValidated()
        {
            // Arrange
            ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            Mock<DefaultBodyModelValidator> mockValidator = new Mock<DefaultBodyModelValidator>();
            mockValidator.CallBase = true;
            mockValidator.Setup(validator => validator.ShouldValidateType(typeof(Person))).Returns(false);

            // Act
            mockValidator.Object.Validate(new Person(), typeof(Person), metadataProvider, actionContext, string.Empty);

            // Assert
            Assert.True(actionContext.ModelState.IsValid);
        }

        [Fact]
        public void ExcludedPropertyTypes_AreShallowValidated()
        {
            // Arrange
            ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            Mock<DefaultBodyModelValidator> mockValidator = new Mock<DefaultBodyModelValidator>();
            mockValidator.CallBase = true;
            mockValidator.Setup(validator => validator.ShouldValidateType(typeof(Person))).Returns(false);

            // Act
            mockValidator.Object.Validate(new Pet(), typeof(Pet), metadataProvider, actionContext, string.Empty);

            // Assert
            Assert.False(actionContext.ModelState.IsValid);
            ModelState modelState = actionContext.ModelState["Owner"];
            Assert.Single(modelState.Errors);
        }

        [Fact]
        public void Validate_DoesNotUseOverridden_GetHashCodeOrEquals()
        {
            // Arrange
            ModelMetadataProvider metadataProvider = new DataAnnotationsModelMetadataProvider();
            HttpActionContext actionContext = ContextUtil.CreateActionContext();
            DefaultBodyModelValidator validator = new DefaultBodyModelValidator();
            object instance = new[] { new TypeThatOverridesEquals { Funny = "hehe" }, new TypeThatOverridesEquals { Funny = "hehe" } };

            // Act & Assert
            Assert.DoesNotThrow(
                () => validator.Validate(instance, typeof(TypeThatOverridesEquals[]), metadataProvider, actionContext, String.Empty));
        }

        public class Person
        {
            [Required]
            [StringLength(10)]
            public string Name { get; set; }

            [Required]
            public string Profession { get; set; }

            public Person Friend { get; set; }
        }

        public class Address
        {
            [StringLength(5)]
            [RegularExpression("hehehe")]
            public string Street { get; set; }
        }

        public struct ValueType
        {
            public int Value;
            public string Reference;
        }

        public class ReferenceType
        {
            public static string StaticProperty { get { return "static"; } }
            public int Value;
            public string Reference;
        }

        public class Pet
        {
            [Required]
            public Person Owner { get; set; }
        }

        public class ValidatableModel : IValidatableObject
        {
            public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
            {
                yield return new ValidationResult("Error1", new string[] { });
                yield return new ValidationResult("Error2", new[] { "Property1" });
                yield return new ValidationResult("Error3", new[] { "Property2", "Property3" });
            }
        }

        public class TypeThatOverridesEquals
        {
            [StringLength(2)]
            public string Funny { get; set; }

            public override bool Equals(object obj)
            {
                throw new InvalidOperationException();
            }

            public override int GetHashCode()
            {
                throw new InvalidOperationException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/ModelStateFormatterLoggerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Formatting;
using System.Web.Http.ModelBinding;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation
{
    public class ModelStateFormatterLoggerTest
    {
        [Fact]
        public void LogErrorAddsErrorToModelState()
        {
            ModelStateDictionary modelState = new ModelStateDictionary();
            string prefix = "prefix";
            IFormatterLogger formatterLogger = new ModelStateFormatterLogger(modelState, prefix);

            formatterLogger.LogError("property", "error");

            Assert.True(modelState.ContainsKey("prefix.property"));
            ModelError error = Assert.Single(modelState["prefix.property"].Errors);
            Assert.Equal("error", error.ErrorMessage);
        }

        [Fact]
        public void LogErrorAddsExceptionToModelState()
        {
            ModelStateDictionary modelState = new ModelStateDictionary();
            string prefix = "prefix";
            IFormatterLogger formatterLogger = new ModelStateFormatterLogger(modelState, prefix);

            Exception e = new Exception("error");

            formatterLogger.LogError("property", e);

            Assert.True(modelState.ContainsKey("prefix.property"));
            ModelError error = Assert.Single(modelState["prefix.property"].Errors);
            Assert.Equal(e, error.Exception);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/ModelValidationNodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Http.Controllers;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation
{
    public class ModelValidationNodeTest
    {
        [Fact]
        public void ConstructorSetsCollectionInstance()
        {
            // Arrange
            ModelMetadata metadata = GetModelMetadata();
            string modelStateKey = "someKey";
            ModelValidationNode[] childNodes = new[]
            {
                new ModelValidationNode(metadata, "someKey0"),
                new ModelValidationNode(metadata, "someKey1")
            };

            // Act
            ModelValidationNode node = new ModelValidationNode(metadata, modelStateKey, childNodes);

            // Assert
            Assert.Equal(childNodes, node.ChildNodes.ToArray());
        }

        [Fact]
        public void ConstructorThrowsIfModelMetadataIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new ModelValidationNode(null, "someKey"),
                "modelMetadata");
        }

        [Fact]
        public void ConstructorThrowsIfModelStateKeyIsNull()
        {
            // Arrange
            ModelMetadata metadata = GetModelMetadata();

            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new ModelValidationNode(metadata, null),
                "modelStateKey");
        }

        [Fact]
        public void PropertiesAreSet()
        {
            // Arrange
            ModelMetadata metadata = GetModelMetadata();
            string modelStateKey = "someKey";

            // Act
            ModelValidationNode node = new ModelValidationNode(metadata, modelStateKey);

            // Assert
            Assert.Equal(metadata, node.ModelMetadata);
            Assert.Equal(modelStateKey, node.ModelStateKey);
            Assert.NotNull(node.ChildNodes);
            Assert.Empty(node.ChildNodes);
        }

        [Fact]
        public void CombineWith()
        {
            // Arrange
            List<string> log = new List<string>();

            ModelValidationNode[] allChildNodes = new[]
            {
                new ModelValidationNode(GetModelMetadata(), "key1"),
                new ModelValidationNode(GetModelMetadata(), "key2"),
                new ModelValidationNode(GetModelMetadata(), "key3"),
            };

            ModelValidationNode parentNode1 = new ModelValidationNode(GetModelMetadata(), "parent1");
            parentNode1.ChildNodes.Add(allChildNodes[0]);
            parentNode1.Validating += (sender, e) => log.Add("Validating parent1.");
            parentNode1.Validated += (sender, e) => log.Add("Validated parent1.");

            ModelValidationNode parentNode2 = new ModelValidationNode(GetModelMetadata(), "parent2");
            parentNode2.ChildNodes.Add(allChildNodes[1]);
            parentNode2.ChildNodes.Add(allChildNodes[2]);
            parentNode2.Validating += (sender, e) => log.Add("Validating parent2.");
            parentNode2.Validated += (sender, e) => log.Add("Validated parent2.");

            // Act
            parentNode1.CombineWith(parentNode2);
            parentNode1.Validate(ContextUtil.CreateActionContext());

            // Assert
            Assert.Equal(new[] { "Validating parent1.", "Validating parent2.", "Validated parent1.", "Validated parent2." }, log.ToArray());
            Assert.Equal(allChildNodes, parentNode1.ChildNodes.ToArray());
        }

        [Fact]
        public void CombineWith_OtherNodeIsSuppressed_DoesNothing()
        {
            // Arrange
            List<string> log = new List<string>();

            ModelValidationNode[] allChildNodes = new[]
            {
                new ModelValidationNode(GetModelMetadata(), "key1"),
                new ModelValidationNode(GetModelMetadata(), "key2"),
                new ModelValidationNode(GetModelMetadata(), "key3"),
            };

            ModelValidationNode[] expectedChildNodes = new[]
            {
                allChildNodes[0]
            };

            ModelValidationNode parentNode1 = new ModelValidationNode(GetModelMetadata(), "parent1");
            parentNode1.ChildNodes.Add(allChildNodes[0]);
            parentNode1.Validating += (sender, e) => log.Add("Validating parent1.");
            parentNode1.Validated += (sender, e) => log.Add("Validated parent1.");

            ModelValidationNode parentNode2 = new ModelValidationNode(GetModelMetadata(), "parent2");
            parentNode2.ChildNodes.Add(allChildNodes[1]);
            parentNode2.ChildNodes.Add(allChildNodes[2]);
            parentNode2.Validating += (sender, e) => log.Add("Validating parent2.");
            parentNode2.Validated += (sender, e) => log.Add("Validated parent2.");
            parentNode2.SuppressValidation = true;

            // Act
            parentNode1.CombineWith(parentNode2);
            parentNode1.Validate(ContextUtil.CreateActionContext());

            // Assert
            Assert.Equal(new[] { "Validating parent1.", "Validated parent1." }, log.ToArray());
            Assert.Equal(expectedChildNodes, parentNode1.ChildNodes.ToArray());
        }

        [Fact]
        public void Validate_Ordering()
        {
            // Proper order of invocation:
            // 1. OnValidating()
            // 2. Child validators
            // 3. This validator
            // 4. OnValidated()

            // Arrange
            List<string> log = new List<string>();
            LoggingValidatableObject model = new LoggingValidatableObject(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);
            ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(() => model, model.GetType(), "ValidStringProperty");
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");
            node.Validating += (sender, e) => log.Add("In OnValidating()");
            node.Validated += (sender, e) => log.Add("In OnValidated()");
            node.ChildNodes.Add(new ModelValidationNode(childMetadata, "theKey.ValidStringProperty"));

            // Act
            node.Validate(ContextUtil.CreateActionContext());

            // Assert
            Assert.Equal(new[] { "In OnValidating()", "In LoggingValidatonAttribute.IsValid()", "In IValidatableObject.Validate()", "In OnValidated()" }, log.ToArray());
        }

        [Fact]
        public void Validate_SkipsRemainingValidationIfModelStateIsInvalid()
        {
            // Because a property validator fails, the model validator shouldn't run

            // Arrange
            List<string> log = new List<string>();
            LoggingValidatableObject model = new LoggingValidatableObject(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);
            ModelMetadata childMetadata = new EmptyModelMetadataProvider().GetMetadataForProperty(() => model, model.GetType(), "InvalidStringProperty");
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");
            node.ChildNodes.Add(new ModelValidationNode(childMetadata, "theKey.InvalidStringProperty"));
            node.Validating += (sender, e) => log.Add("In OnValidating()");
            node.Validated += (sender, e) => log.Add("In OnValidated()");
            HttpActionContext context = ContextUtil.CreateActionContext();

            // Act
            node.Validate(context);

            // Assert
            Assert.Equal(new[] { "In OnValidating()", "In IValidatableObject.Validate()", "In OnValidated()" }, log.ToArray());
            Assert.Equal("Sample error message", context.ModelState["theKey.InvalidStringProperty"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void Validate_SkipsValidationIfHandlerCancels()
        {
            // Arrange
            List<string> log = new List<string>();
            LoggingValidatableObject model = new LoggingValidatableObject(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey");
            node.Validating += (sender, e) =>
            {
                log.Add("In OnValidating()");
                e.Cancel = true;
            };
            node.Validated += (sender, e) => log.Add("In OnValidated()");

            // Act
            node.Validate(ContextUtil.CreateActionContext());

            // Assert
            Assert.Equal(new[] { "In OnValidating()" }, log.ToArray());
        }

        [Fact]
        public void Validate_SkipsValidationIfSuppressed()
        {
            // Arrange
            List<string> log = new List<string>();
            LoggingValidatableObject model = new LoggingValidatableObject(log);
            ModelMetadata modelMetadata = GetModelMetadata(model);
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey")
            {
                SuppressValidation = true
            };

            node.Validating += (sender, e) => log.Add("In OnValidating()");
            node.Validated += (sender, e) => log.Add("In OnValidated()");

            // Act
            node.Validate(ContextUtil.CreateActionContext());

            // Assert
            Assert.Empty(log);
        }

        [Fact]
        public void Validate_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            ModelValidationNode node = new ModelValidationNode(GetModelMetadata(), "someKey");

            // Act & assert
            Assert.ThrowsArgumentNull(
                () => node.Validate(null),
                "actionContext");
        }

        [Fact]
        [ReplaceCulture]
        public void Validate_ValidateAllProperties_AddsValidationErrors()
        {
            // Arrange
            ValidateAllPropertiesModel model = new ValidateAllPropertiesModel
            {
                RequiredString = null /* error */,
                RangedInt = 0 /* error */,
                ValidString = "dog"
            };

            ModelMetadata modelMetadata = GetModelMetadata(model);
            HttpActionContext context = ContextUtil.CreateActionContext();
            ModelValidationNode node = new ModelValidationNode(modelMetadata, "theKey")
            {
                ValidateAllProperties = true
            };
            context.ModelState.AddModelError("theKey.RequiredString.Dummy", "existing Error Text");

            // Act
            node.Validate(context);

            // Assert
            Assert.Null(context.ModelState["theKey.RequiredString"]);
            Assert.Equal("existing Error Text", context.ModelState["theKey.RequiredString.Dummy"].Errors[0].ErrorMessage);
            Assert.Equal("The field RangedInt must be between 10 and 30.", context.ModelState["theKey.RangedInt"].Errors[0].ErrorMessage);
            Assert.Null(context.ModelState["theKey.ValidString"]);
            Assert.Null(context.ModelState["theKey"]);
        }

        private static ModelMetadata GetModelMetadata()
        {
            return new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object));
        }

        private static ModelMetadata GetModelMetadata(object o)
        {
            return new DataAnnotationsModelMetadataProvider().GetMetadataForType(() => o, o.GetType());
        }

        private sealed class LoggingValidatableObject : IValidatableObject
        {
            private readonly IList<string> _log;

            public LoggingValidatableObject(IList<string> log)
            {
                _log = log;
            }

            [LoggingValidation]
            public string ValidStringProperty { get; set; }
            public string InvalidStringProperty { get; set; }

            public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
            {
                _log.Add("In IValidatableObject.Validate()");
                yield return new ValidationResult("Sample error message", new[] { "InvalidStringProperty" });
            }

            private sealed class LoggingValidationAttribute : ValidationAttribute
            {
                protected override ValidationResult IsValid(object value, ValidationContext validationContext)
                {
                    LoggingValidatableObject lvo = (LoggingValidatableObject)value;
                    lvo._log.Add("In LoggingValidatonAttribute.IsValid()");
                    return ValidationResult.Success;
                }
            }
        }

        private class ValidateAllPropertiesModel
        {
            [Required]
            public string RequiredString { get; set; }

            [Range(10, 30)]
            public int RangedInt { get; set; }

            [RegularExpression("dog")]
            public string ValidString { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/ModelValidationRequiredMemberSelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Net.Http.Formatting;
using System.Reflection;
using System.Runtime.Serialization;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation
{
    public class ModelValidationRequiredMemberSelectorTest
    {
        [Theory]
        [InlineData("CustomerID", true)]
        [InlineData("ID", true)]
        [InlineData("ItemID", true)]
        [InlineData("UselessInfo", false)]
        public void IsRequiredMember_RecognizesRequiredMembers(string propertyName, bool isRequired)
        {
            HttpConfiguration config = new HttpConfiguration();
            IRequiredMemberSelector selector = new ModelValidationRequiredMemberSelector(config.Services.GetModelMetadataProvider(), config.Services.GetModelValidatorProviders());

            Assert.Equal(isRequired, selector.IsRequiredMember(typeof(PurchaseOrder).GetProperty(propertyName)));
        }

        [Theory]
        [InlineData("StringProperty")]
        [InlineData("NullableProperty")]
        [InlineData("CollectionProperty")]
        public void IsRequiredMember_ReturnsFalse_ForNullableProperties(string propertyName)
        {
            HttpConfiguration config = new HttpConfiguration();
            IRequiredMemberSelector selector = new ModelValidationRequiredMemberSelector(config.Services.GetModelMetadataProvider(), config.Services.GetModelValidatorProviders());

            Assert.False(selector.IsRequiredMember(typeof(NullableProperties).GetProperty(propertyName)));
        }


        [Theory]
        [InlineData("ProtectedGet")]
        [InlineData("NoGet")]
        [InlineData("Internal")]
        public void IsRequiredMember_ReturnsFalse_ForInvalidProperties(string propertyName)
        {
            HttpConfiguration config = new HttpConfiguration();
            IRequiredMemberSelector selector = new ModelValidationRequiredMemberSelector(config.Services.GetModelMetadataProvider(), config.Services.GetModelValidatorProviders());
            PropertyInfo propertyInfo = typeof(BadProperties).GetProperty(propertyName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

            Assert.False(selector.IsRequiredMember(propertyInfo));
        }

        [DataContract]
        public class PurchaseOrder
        {
            [DataMember(IsRequired = true)]
            public int ID { get; set; }

            [Required]
            public int CustomerID { get; set; }

            [Required]
            [DataMember(IsRequired = true)]
            public int ItemID { get; set; }

            public int UselessInfo { get; set; }
        }

        public class NullableProperties
        {
            [Required]
            public string StringProperty { get; set; }

            [Required]
            public Nullable<int> NullableProperty { get; set; }

            [Required]
            public List<int> CollectionProperty { get; set; }
        }

        public class BadProperties
        {
            public int ProtectedGet
            {
                protected get;
                set;
            }

            public int NoGet
            {
                set { }
            }

            internal int Internal
            {
                get;
                set;
            }
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/Validation/ModelValidationResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation
{
    public class ModelValidationResultTest
    {
        [Fact]
        public void MemberNameProperty()
        {
            // Arrange
            ModelValidationResult result = new ModelValidationResult();

            // Act & assert
            MemberHelper.TestStringProperty(result, "MemberName", String.Empty);
        }

        [Fact]
        public void MessageProperty()
        {
            // Arrange
            ModelValidationResult result = new ModelValidationResult();

            // Act & assert
            MemberHelper.TestStringProperty(result, "Message", String.Empty);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/ModelValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation
{
    public class ModelValidatorTest
    {
        private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
        private static IEnumerable<ModelValidatorProvider> _noValidatorProviders = Enumerable.Empty<ModelValidatorProvider>();

        [Fact]
        public void ConstructorGuards()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(object));

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new TestableModelValidator(validatorProviders: null),
                "validatorProviders");
        }

        [Fact]
        public void ValuesSet()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");

            // Act
            TestableModelValidator validator = new TestableModelValidator(_noValidatorProviders);

            // Assert
            Assert.Same(_noValidatorProviders, validator.ValidatorProviders);
        }

        [Fact]
        public void IsRequiredFalseByDefault()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");

            // Act
            TestableModelValidator validator = new TestableModelValidator(_noValidatorProviders);

            // Assert
            Assert.False(validator.IsRequired);
        }

        [Fact]
        public void GetModelValidator_DoesNotReadPropertyValues()
        {
            // Arrange
            IEnumerable<ModelValidatorProvider> validatorProviders = new[] { new ObservableModelValidatorProvider() };
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(ObservableModel));

            // Act
            ModelValidator validator = ModelValidator.GetModelValidator(validatorProviders);
            ModelValidationResult[] results = validator.Validate(metadata, model).ToArray();

            // Assert
            Assert.False(model.PropertyWasRead());
        }

        private class ObservableModelValidatorProvider : ModelValidatorProvider
        {
            public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders)
            {
                return new ModelValidator[] { new ObservableModelValidator(validatorProviders) };
            }

            private class ObservableModelValidator : ModelValidator
            {
                public ObservableModelValidator(IEnumerable<ModelValidatorProvider> validatorProviders)
                    : base(validatorProviders)
                {
                }

                public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
                {
                    return Enumerable.Empty<ModelValidationResult>();
                }
            }
        }

        private class ObservableModel
        {
            private bool _propertyWasRead;

            public int TheProperty
            {
                get
                {
                    _propertyWasRead = true;
                    return 42;
                }
            }

            public bool PropertyWasRead()
            {
                return _propertyWasRead;
            }
        }

        private class TestableModelValidator : ModelValidator
        {
            public TestableModelValidator(IEnumerable<ModelValidatorProvider> validatorProviders)
                : base(validatorProviders)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/Providers/AssociatedValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Validation.Providers
{
    public class AssociatedValidatorProviderTest
    {
        private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
        private static IEnumerable<ModelValidatorProvider> _noValidatorProviders = Enumerable.Empty<ModelValidatorProvider>();

        [Fact]
        public void GetValidatorsGuardClauses()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(object));
            Mock<AssociatedValidatorProvider> provider = new Mock<AssociatedValidatorProvider> { CallBase = true };

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.Object.GetValidators(metadata: null, validatorProviders: _noValidatorProviders),
                "metadata");
            Assert.ThrowsArgumentNull(
                () => provider.Object.GetValidators(metadata, validatorProviders: null),
                "validatorProviders");
        }

        [Fact]
        public void GetValidatorsForPropertyWithLocalAttributes()
        {
            // Arrange
            IEnumerable<Attribute> callbackAttributes = null;
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(null, typeof(PropertyModel), "LocalAttributes");
            Mock<TestableAssociatedValidatorProvider> provider = new Mock<TestableAssociatedValidatorProvider> { CallBase = true };
            provider.Setup(p => p.AbstractGetValidators(metadata, _noValidatorProviders, It.IsAny<IEnumerable<Attribute>>()))
                    .Callback<ModelMetadata, IEnumerable<ModelValidatorProvider>, IEnumerable<Attribute>>((m, c, attributes) => callbackAttributes = attributes)
                    .Returns(() => null)
                    .Verifiable();

            // Act
            provider.Object.GetValidators(metadata, _noValidatorProviders);

            // Assert
            provider.Verify();
            Assert.Contains(callbackAttributes, a => a is RequiredAttribute);
        }

        [Fact]
        public void GetValidatorsForPropertyWithMetadataAttributes()
        {
            // Arrange
            IEnumerable<Attribute> callbackAttributes = null;
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(null, typeof(PropertyModel), "MetadataAttributes");
            Mock<TestableAssociatedValidatorProvider> provider = new Mock<TestableAssociatedValidatorProvider> { CallBase = true };
            provider.Setup(p => p.AbstractGetValidators(metadata, _noValidatorProviders, It.IsAny<IEnumerable<Attribute>>()))
                    .Callback<ModelMetadata, IEnumerable<ModelValidatorProvider>, IEnumerable<Attribute>>((m, c, attributes) => callbackAttributes = attributes)
                    .Returns(() => null)
                    .Verifiable();

            // Act
            provider.Object.GetValidators(metadata, _noValidatorProviders);

            // Assert
            provider.Verify();
            Assert.Contains(callbackAttributes, a => a is RangeAttribute);
        }

        [Fact]
        public void GetValidatorsForPropertyWithMixedAttributes()
        {
            // Arrange
            IEnumerable<Attribute> callbackAttributes = null;
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(null, typeof(PropertyModel), "MixedAttributes");
            Mock<TestableAssociatedValidatorProvider> provider = new Mock<TestableAssociatedValidatorProvider> { CallBase = true };
            provider.Setup(p => p.AbstractGetValidators(metadata, _noValidatorProviders, It.IsAny<IEnumerable<Attribute>>()))
                    .Callback<ModelMetadata, IEnumerable<ModelValidatorProvider>, IEnumerable<Attribute>>((m, c, attributes) => callbackAttributes = attributes)
                    .Returns(() => null)
                    .Verifiable();

            // Act
            provider.Object.GetValidators(metadata, _noValidatorProviders);

            // Assert
            provider.Verify();
            Assert.Contains(callbackAttributes, a => a is RangeAttribute);
            Assert.Contains(callbackAttributes, a => a is RequiredAttribute);
        }

        [MetadataType(typeof(Metadata))]
        private class PropertyModel
        {
            [Required]
            public int LocalAttributes { get; set; }

            public string MetadataAttributes { get; set; }

            [Required]
            public double MixedAttributes { get; set; }

            private class Metadata
            {
                [Range(10, 100)]
                public object MetadataAttributes { get; set; }

                [Range(10, 100)]
                public object MixedAttributes { get; set; }
            }
        }

        public abstract class TestableAssociatedValidatorProvider : AssociatedValidatorProvider
        {
            protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders, IEnumerable<Attribute> attributes)
            {
                return AbstractGetValidators(metadata, validatorProviders, attributes);
            }

            public abstract IEnumerable<ModelValidator> AbstractGetValidators(ModelMetadata metadata, IEnumerable<ModelValidatorProvider> validatorProviders, IEnumerable<Attribute> attributes);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/Providers/DataAnnotationsModelValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.Http.Validation.Validators;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.Validation.Providers
{
    public class DataAnnotationsModelValidatorProviderTest
    {
        private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
        private static IEnumerable<ModelValidatorProvider> _noValidatorProviders = Enumerable.Empty<ModelValidatorProvider>();

        // Validation attribute adapter registration

        private class MyValidationAttribute : ValidationAttribute
        {
            public override bool IsValid(object value)
            {
                throw new NotImplementedException();
            }
        }

        private class MyValidationAttributeAdapter : DataAnnotationsModelValidator
        {
            public MyValidationAttributeAdapter(IEnumerable<ModelValidatorProvider> validatorProviders, ValidationAttribute attribute)
                : base(validatorProviders, attribute)
            {
            }
        }

        private class MyValidationAttributeAdapterBadCtor : ModelValidator
        {
            public MyValidationAttributeAdapterBadCtor(IEnumerable<ModelValidatorProvider> validatorProviders)
                : base(validatorProviders)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
            {
                throw new NotImplementedException();
            }
        }

        private class MyDefaultValidationAttributeAdapter : DataAnnotationsModelValidator
        {
            public MyDefaultValidationAttributeAdapter(IEnumerable<ModelValidatorProvider> validatorProviders, ValidationAttribute attribute)
                : base(validatorProviders, attribute)
            {
            }
        }

        [MyValidation]
        private class MyValidatedClass
        {
        }

        [Fact]
        public void RegisterAdapter()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            provider.AttributeFactories = new Dictionary<Type, DataAnnotationsModelValidationFactory>();

            // Act
            provider.RegisterAdapter(typeof(MyValidationAttribute), typeof(MyValidationAttributeAdapter));

            // Assert
            var type = provider.AttributeFactories.Keys.Single();
            Assert.Equal(typeof(MyValidationAttribute), type);

            var factory = provider.AttributeFactories.Values.Single();
            var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(object));
            var attribute = new MyValidationAttribute();
            var validator = factory(_noValidatorProviders, attribute);
            Assert.IsType<MyValidationAttributeAdapter>(validator);
        }

        [Fact]
        public void RegisterAdapterGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();

            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterAdapter(null, typeof(MyValidationAttributeAdapter)),
                "attributeType");

            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterAdapter(typeof(MyValidationAttribute), null),
                "adapterType");

            // Validation attribute must derive from ValidationAttribute
            Assert.ThrowsArgument(
                () => provider.RegisterAdapter(typeof(object), typeof(MyValidationAttributeAdapter)),
                "attributeType",
                "The type Object must derive from ValidationAttribute");

            // Adapter must derive from ModelValidator
            Assert.ThrowsArgument(
                () => provider.RegisterAdapter(typeof(MyValidationAttribute), typeof(object)),
                "adapterType",
                "The type Object must derive from ModelValidator");

            // Adapter must have the expected constructor
            Assert.ThrowsArgument(
                () => provider.RegisterAdapter(typeof(MyValidationAttribute), typeof(MyValidationAttributeAdapterBadCtor)),
                "adapterType",
                "The type MyValidationAttributeAdapterBadCtor must have a public constructor which accepts three parameters of types ModelMetadata, IEnumerable<ModelValidatorProvider>, and MyValidationAttribute");
        }

        [Fact]
        public void RegisterAdapterFactory()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            provider.AttributeFactories = new Dictionary<Type, DataAnnotationsModelValidationFactory>();
            DataAnnotationsModelValidationFactory factory = delegate { return null; };

            // Act
            provider.RegisterAdapterFactory(typeof(MyValidationAttribute), factory);

            // Assert
            var type = provider.AttributeFactories.Keys.Single();
            Assert.Equal(typeof(MyValidationAttribute), type);
            Assert.Same(factory, provider.AttributeFactories.Values.Single());
        }

        [Fact]
        public void RegisterAdapterFactoryGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();
            DataAnnotationsModelValidationFactory factory = (validatorProviders, attribute) => null;

            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterAdapterFactory(null, factory),
                "attributeType");

            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterAdapterFactory(typeof(MyValidationAttribute), null),
                "factory");

            // Validation attribute must derive from ValidationAttribute
            Assert.ThrowsArgument(
                () => provider.RegisterAdapterFactory(typeof(object), factory),
                "attributeType",
                "The type Object must derive from ValidationAttribute");
        }

        [Fact]
        public void RegisterDefaultAdapter()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatedClass));
            provider.RegisterDefaultAdapter(typeof(MyDefaultValidationAttributeAdapter));

            // Act
            var result = provider.GetValidators(metadata, _noValidatorProviders).Single();

            // Assert
            Assert.IsType<MyDefaultValidationAttributeAdapter>(result);
        }

        [Fact]
        public void RegisterDefaultAdapterGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();

            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterDefaultAdapter(null),
                "adapterType");

            // Adapter must derive from ModelValidator
            Assert.ThrowsArgument(
                () => provider.RegisterDefaultAdapter(typeof(object)),
                "adapterType",
                "The type Object must derive from ModelValidator");

            // Adapter must have the expected constructor
            Assert.ThrowsArgument(
                () => provider.RegisterDefaultAdapter(typeof(MyValidationAttributeAdapterBadCtor)),
                "adapterType",
                "The type MyValidationAttributeAdapterBadCtor must have a public constructor which accepts three parameters of types ModelMetadata, IEnumerable<ModelValidatorProvider>, and ValidationAttribute");
        }

        [Fact]
        public void RegisterDefaultAdapterFactory()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatedClass));
            ModelValidator validator = new Mock<ModelValidator>(_noValidatorProviders).Object;
            DataAnnotationsModelValidationFactory factory = delegate { return validator; };
            provider.RegisterDefaultAdapterFactory(factory);

            // Act
            var result = provider.GetValidators(metadata, _noValidatorProviders).Single();

            // Assert
            Assert.Same(validator, result);
        }

        [Fact]
        public void RegisterDefaultAdapterFactoryGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();

            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterDefaultAdapterFactory(null),
                "factory");
        }

        // IValidatableObject adapter registration

        private class MyValidatableAdapter : ModelValidator
        {
            public MyValidatableAdapter(IEnumerable<ModelValidatorProvider> validatorProviders)
                : base(validatorProviders)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
            {
                throw new NotImplementedException();
            }
        }

        private class MyValidatableAdapterBadCtor : ModelValidator
        {
            public MyValidatableAdapterBadCtor(IEnumerable<ModelValidatorProvider> validatorProviders, int unused)
                : base(validatorProviders)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(ModelMetadata metadata, object container)
            {
                throw new NotImplementedException();
            }
        }

        private class MyValidatableClass : IValidatableObject
        {
            public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
            {
                throw new NotImplementedException();
            }
        }

        [Fact]
        public void RegisterValidatableObjectAdapter()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            provider.ValidatableFactories = new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();
            IValidatableObject validatable = new Mock<IValidatableObject>().Object;

            // Act
            provider.RegisterValidatableObjectAdapter(validatable.GetType(), typeof(MyValidatableAdapter));

            // Assert
            var type = provider.ValidatableFactories.Keys.Single();
            Assert.Equal(validatable.GetType(), type);

            var factory = provider.ValidatableFactories.Values.Single();
            var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(object));
            var validator = factory(_noValidatorProviders);
            Assert.IsType<MyValidatableAdapter>(validator);
        }

        [Fact]
        public void RegisterValidatableObjectAdapterGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();

            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterValidatableObjectAdapter(null, typeof(MyValidatableAdapter)),
                "modelType");

            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), null),
                "adapterType");

            // Validation attribute must derive from ValidationAttribute
            Assert.ThrowsArgument(
                () => provider.RegisterValidatableObjectAdapter(typeof(object), typeof(MyValidatableAdapter)),
                "modelType",
                "The type Object must derive from IValidatableObject.");

            // Adapter must derive from ModelValidator
            Assert.ThrowsArgument(
                () => provider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), typeof(object)),
                "adapterType",
                "The type Object must derive from ModelValidator");

            // Adapter must have the expected constructor
            Assert.ThrowsArgument(
                () => provider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), typeof(MyValidatableAdapterBadCtor)),
                "adapterType",
                "The type MyValidatableAdapterBadCtor must have a public constructor which accepts two parameters of types ModelMetadata and IEnumerable<ModelValidatorProvider>");
        }

        [Fact]
        public void RegisterValidatableObjectAdapterFactory()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            provider.ValidatableFactories = new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();
            DataAnnotationsValidatableObjectAdapterFactory factory = delegate { return null; };

            // Act
            provider.RegisterValidatableObjectAdapterFactory(typeof(MyValidatableClass), factory);

            // Assert
            var type = provider.ValidatableFactories.Keys.Single();
            Assert.Equal(typeof(MyValidatableClass), type);
            Assert.Same(factory, provider.ValidatableFactories.Values.Single());
        }

        [Fact]
        public void RegisterValidatableObjectAdapterFactoryGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();
            DataAnnotationsValidatableObjectAdapterFactory factory = (context) => null;

            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterValidatableObjectAdapterFactory(null, factory),
                "modelType");

            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterValidatableObjectAdapterFactory(typeof(MyValidatableClass), null),
                "factory");

            // Validation attribute must derive from ValidationAttribute
            Assert.ThrowsArgument(
                () => provider.RegisterValidatableObjectAdapterFactory(typeof(object), factory),
                "modelType",
                "The type Object must derive from IValidatableObject");
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapter()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatableClass));
            provider.RegisterDefaultValidatableObjectAdapter(typeof(MyValidatableAdapter));

            // Act
            var result = provider.GetValidators(metadata, _noValidatorProviders).Single();

            // Assert
            Assert.IsType<MyValidatableAdapter>(result);
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapterGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();

            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterDefaultValidatableObjectAdapter(null),
                "adapterType");

            // Adapter must derive from ModelValidator
            Assert.ThrowsArgument(
                () => provider.RegisterDefaultValidatableObjectAdapter(typeof(object)),
                "adapterType",
                "The type Object must derive from ModelValidator");

            // Adapter must have the expected constructor
            Assert.ThrowsArgument(
                () => provider.RegisterDefaultValidatableObjectAdapter(typeof(MyValidatableAdapterBadCtor)),
                "adapterType",
                "The type MyValidatableAdapterBadCtor must have a public constructor which accepts two parameters of types ModelMetadata and IEnumerable<ModelValidatorProvider>");
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapterFactory()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(MyValidatableClass));
            ModelValidator validator = new Mock<ModelValidator>(_noValidatorProviders).Object;
            DataAnnotationsValidatableObjectAdapterFactory factory = delegate { return validator; };
            provider.RegisterDefaultValidatableObjectAdapterFactory(factory);

            // Act
            var result = provider.GetValidators(metadata, _noValidatorProviders).Single();

            // Assert
            Assert.Same(validator, result);
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapterFactoryGuardClauses()
        {
            var provider = new DataAnnotationsModelValidatorProvider();

            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => provider.RegisterDefaultValidatableObjectAdapterFactory(null),
                "factory");
        }

        // Default adapter factory for unknown attribute type

        [Fact]
        public void UnknownValidationAttributeGetsDefaultAdapter()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForType(() => null, typeof(DummyClassWithDummyValidationAttribute));

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, _noValidatorProviders);

            // Assert
            var validator = validators.Single();
            Assert.IsType<DataAnnotationsModelValidator>(validator);
        }

        private class DummyValidationAttribute : ValidationAttribute
        {
        }

        [DummyValidation]
        private class DummyClassWithDummyValidationAttribute
        {
        }

        // Default IValidatableObject adapter factory

        [Fact]
        public void IValidatableObjectGetsAValidator()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var mockValidatable = new Mock<IValidatableObject>();
            var metadata = _metadataProvider.GetMetadataForType(() => null, mockValidatable.Object.GetType());

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, _noValidatorProviders);

            // Assert
            Assert.Single(validators);
        }

        // Integration with metadata system

        [Fact]
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var model = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");

            // Act
            ModelValidator[] validators = provider.GetValidators(metadata, _noValidatorProviders).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(metadata, model)).ToArray();

            // Assert
            Assert.Empty(validators);
            Assert.False(model.PropertyWasRead());
        }

        private class ObservableModel
        {
            private bool _propertyWasRead;

            public string TheProperty
            {
                get
                {
                    _propertyWasRead = true;
                    return "Hello";
                }
            }

            public bool PropertyWasRead()
            {
                return _propertyWasRead;
            }
        }

        private class BaseModel
        {
            public virtual string MyProperty { get; set; }
        }

        private class DerivedModel : BaseModel
        {
            [StringLength(10)]
            public override string MyProperty
            {
                get { return base.MyProperty; }
                set { base.MyProperty = value; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/Providers/DataMemberModelValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation.Providers
{
    public class DataMemberModelValidatorProviderTest
    {
        private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();

        [Fact]
        public void ClassWithoutAttributes_NoValidator()
        {
            // Arrange
            var provider = new DataMemberModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForProperty(() => null, typeof(ClassWithoutAttributes), "TheProperty");

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, new[] { provider });

            // Assert
            Assert.Empty(validators);
        }

        class ClassWithoutAttributes
        {
            public int TheProperty { get; set; }
        }

        [Fact]
        public void ClassWithDataMemberIsRequiredTrue_Validator()
        {
            // Arrange
            var provider = new DataMemberModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForProperty(() => null, typeof(ClassWithDataMemberIsRequiredTrue), "TheProperty");

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, new[] { provider });

            // Assert
            ModelValidator validator = Assert.Single(validators);
            Assert.True(validator.IsRequired);
        }

        [DataContract]
        class ClassWithDataMemberIsRequiredTrue
        {
            [DataMember(IsRequired = true)]
            public int TheProperty { get; set; }
        }

        [Fact]
        public void ClassWithDataMemberIsRequiredFalse_NoValidator()
        {
            // Arrange
            var provider = new DataMemberModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForProperty(() => null, typeof(ClassWithDataMemberIsRequiredFalse), "TheProperty");

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, new[] { provider });

            // Assert
            Assert.Empty(validators);
        }

        [DataContract]
        class ClassWithDataMemberIsRequiredFalse
        {
            [DataMember(IsRequired = false)]
            public int TheProperty { get; set; }
        }

        [Fact]
        public void ClassWithDataMemberIsRequiredTrueWithoutDataContract_NoValidator()
        {
            // Arrange
            var provider = new DataMemberModelValidatorProvider();
            var metadata = _metadataProvider.GetMetadataForProperty(() => null, typeof(ClassWithDataMemberIsRequiredTrueWithoutDataContract), "TheProperty");

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, new[] { provider });

            // Assert
            Assert.Empty(validators);
        }

        class ClassWithDataMemberIsRequiredTrueWithoutDataContract
        {
            [DataMember(IsRequired = true)]
            public int TheProperty { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/Providers/InvalidModelValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Runtime.Serialization;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation.Providers
{
    public class InvalidModelValidatorProviderTest
    {
        private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
        private static IEnumerable<ModelValidatorProvider> _noValidatorProviders = Enumerable.Empty<ModelValidatorProvider>();

        [Fact]
        public void GetValidatorsReturnsNothingForValidModel()
        {
            InvalidModelValidatorProvider validatorProvider = new InvalidModelValidatorProvider();

            IEnumerable<ModelValidator> validators = validatorProvider.GetValidators(_metadataProvider.GetMetadataForType(null, typeof(ValidModel)), _noValidatorProviders);

            Assert.Empty(validators);
        }

        [Fact]
        public void GetValidatorsReturnsInvalidModelValidatorsForInvalidModelType()
        {
            InvalidModelValidatorProvider validatorProvider = new InvalidModelValidatorProvider();

            IEnumerable<ModelValidator> validators = validatorProvider.GetValidators(_metadataProvider.GetMetadataForType(null, typeof(InvalidModel)), _noValidatorProviders);

            Assert.Equal(2, validators.Count());
            Assert.Throws<InvalidOperationException>(() => validators.ElementAt(0).Validate(null, null),
                "Non-public property 'Internal' on type 'System.Web.Http.Validation.Providers.InvalidModelValidatorProviderTest+InvalidModel' is attributed with one or more validation attributes. Validation attributes on non-public properties are not supported. Consider using a public property for validation instead.");
            Assert.Throws<InvalidOperationException>(() => validators.ElementAt(1).Validate(null, null),
                "Field 'Field' on type 'System.Web.Http.Validation.Providers.InvalidModelValidatorProviderTest+InvalidModel' is attributed with one or more validation attributes. Validation attributes on fields are not supported. Consider using a public property for validation instead.");
        }

        [Fact]
        public void GetValidatorsReturnsInvalidModelValidatorsForInvalidModelProperty()
        {
            InvalidModelValidatorProvider validatorProvider = new InvalidModelValidatorProvider();

            IEnumerable<ModelValidator> validators = validatorProvider.GetValidators(_metadataProvider.GetMetadataForProperty(null, typeof(InvalidModel), "Value"), _noValidatorProviders);

            ModelValidator validator = Assert.Single(validators);
            Assert.Throws<InvalidOperationException>(() => validator.Validate(null, null),
                "Property 'Value' on type 'System.Web.Http.Validation.Providers.InvalidModelValidatorProviderTest+InvalidModel' is invalid. Value-typed properties marked as [Required] must also be marked with [DataMember(IsRequired=true)] to be recognized as required. Consider attributing the declaring type with [DataContract] and the property with [DataMember(IsRequired=true)].");
        }

        [DataContract]
        public class ValidModel
        {
            [Required]
            [DataMember]
            [StringLength(10)]
            public string Ref { get; set; }

            [DataMember]
            internal string Internal { get; set; }

            [Required]
            [DataMember(IsRequired=true)]
            public int Value { get; set; }

            public string Field;
        }

        public class InvalidModel
        {
            [Required]
            public string Ref { get; set; }

            [StringLength(10)]
            [RegularExpression("pattern")]
            internal string Internal { get; set; }

            [Required]
            public int Value { get; set; }

            [StringLength(10)]
            public string Field;
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/Validation/ReferenceEqualityComparerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Http.Validation
{
    public class ReferenceEqualityComparerTest
    {
        [Fact]
        public void Equals_ReturnsTrue_ForSameObject()
        {
            object o = new object();
            Assert.True(ReferenceEqualityComparer.Instance.Equals(o, o));
        }

        [Fact]
        public void Equals_ReturnsFalse_ForDifferentObject()
        {
            Object o1 = new Object();
            Object o2 = new Object();

            Assert.False(ReferenceEqualityComparer.Instance.Equals(o1, o2));
        }

        [Fact]
        public void Equals_DoesntCall_OverriddenEqualsOnTheType()
        {
            TypeThatOverridesEquals t1 = new TypeThatOverridesEquals();
            TypeThatOverridesEquals t2 = new TypeThatOverridesEquals();

            Assert.DoesNotThrow(() => ReferenceEqualityComparer.Instance.Equals(t1, t2));
        }

        [Fact]
        public void Equals_ReturnsFalse_ValueType()
        {
            Assert.False(ReferenceEqualityComparer.Instance.Equals(42, 42));
        }

        [Fact]
        public void Equals_NullEqualsNull()
        {
            var comparer = ReferenceEqualityComparer.Instance;
            Assert.True(comparer.Equals(null, null));
        }

        [Fact]
        public void GetHashCode_ReturnsSameValueForSameObject()
        {
            object o = new object();
            var comparer = ReferenceEqualityComparer.Instance;
            Assert.Equal(comparer.GetHashCode(o), comparer.GetHashCode(o));
        }

        [Fact]
        public void GetHashCode_DoesNotThrowForNull()
        {
            var comparer = ReferenceEqualityComparer.Instance;
            Assert.DoesNotThrow(() => comparer.GetHashCode(null));
        }

        private class TypeThatOverridesEquals
        {
            public override bool Equals(object obj)
            {
                throw new InvalidOperationException();
            }

            public override int GetHashCode()
            {
                throw new InvalidOperationException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/Validators/DataAnnotationsModelValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Http.Metadata;
using System.Web.Http.Metadata.Providers;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http.Validation.Validators
{
    public class DataAnnotationsModelValidatorTest
    {
        private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
        private static IEnumerable<ModelValidatorProvider> _noValidatorProviders = Enumerable.Empty<ModelValidatorProvider>();

        [Fact]
        public void ConstructorGuards()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(object));
            var attribute = new RequiredAttribute();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new DataAnnotationsModelValidator(null, attribute),
                "validatorProviders");
            Assert.ThrowsArgumentNull(
                () => new DataAnnotationsModelValidator(_noValidatorProviders, null),
                "attribute");
        }

        [Fact]
        public void ValuesSet()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");
            var attribute = new RequiredAttribute();

            // Act
            var validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute);

            // Assert
            Assert.Same(attribute, validator.Attribute);
        }

        public static TheoryDataSet<NameValueCollection> FalseAppSettingsData
        {
            get
            {
                return new TheoryDataSet<NameValueCollection>
                {
                    new NameValueCollection(),
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "false" },
                    },
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "False" },
                    },
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "false" },
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "true" },
                    },
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "garbage" },
                    },
                };
            }
        }

        [Theory]
        [PropertyData("FalseAppSettingsData")]
        public void GetUseLegacyValidationMemberName_ReturnsFalse(NameValueCollection appSettings)
        {
            // Arrange & Act
            var result = DataAnnotationsModelValidator.GetUseLegacyValidationMemberName(appSettings);

            // Assert
            Assert.False(result);
        }

        public static TheoryDataSet<NameValueCollection> TrueAppSettingsData
        {
            get
            {
                return new TheoryDataSet<NameValueCollection>
                {
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "true" },
                    },
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "True" },
                    },
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "true" },
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "false" },
                    },
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "true" },
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "false" },
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "garbage" },
                    },
                    new NameValueCollection
                    {
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "True" },
                        { DataAnnotationsModelValidator.UseLegacyValidationMemberNameKey, "garbage" },
                    },
                };
            }
        }

        [Theory]
        [PropertyData("TrueAppSettingsData")]
        public void GetUseLegacyValidationMemberName_ReturnsTrue(NameValueCollection appSettings)
        {
            // Arrange & Act
            var result = DataAnnotationsModelValidator.GetUseLegacyValidationMemberName(appSettings);

            // Assert
            Assert.True(result);
        }

        public static TheoryDataSet<ModelMetadata, string> ValidateSetsMemberNamePropertyDataSet
        {
            get
            {
                return new TheoryDataSet<ModelMetadata, string>
                {
                    {
                        _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length"),
                        "Length"
                    },
                    {
                        _metadataProvider.GetMetadataForProperty(() => string.Empty, typeof(AnnotatedModel), "Name"),
                        "Name"
                    },
                    {
                        _metadataProvider.GetMetadataForType(() => new object(), typeof(SampleModel)),
                        "SampleModel"
                    },
                };
            }
        }

        [Theory]
        [PropertyData("ValidateSetsMemberNamePropertyDataSet")]
        public void ValidateSetsMemberNamePropertyOfValidationContextForProperties(ModelMetadata metadata, string expectedMemberName)
        {
            // Arrange
            var attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Callback((object o, ValidationContext context) =>
                     {
                         Assert.Equal(expectedMemberName, context.MemberName);
                     })
                     .Returns(ValidationResult.Success)
                     .Verifiable();
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(metadata, container: null);

            // Assert
            Assert.Empty(results);
            attribute.VerifyAll();
        }

        [Fact]
        public void ValidateSetsMemberNameProperty_UsingDisplayName()
        {
            AppDomainUtils.RunInSeparateAppDomain(ValidateSetsMemberNameProperty_UsingDisplayName_Inner);
        }

        private static void ValidateSetsMemberNameProperty_UsingDisplayName_Inner()
        {
            // Arrange
            DataAnnotationsModelValidator.UseLegacyValidationMemberName = true;
            var expectedMemberName = "Annotated Name";
            var attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute
                .Protected()
                .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                .Callback((object o, ValidationContext context) =>
                {
                    Assert.Equal(expectedMemberName, context.MemberName);
                })
                .Returns(ValidationResult.Success)
                .Verifiable();
            var validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);
            var metadata = _metadataProvider.GetMetadataForProperty(() => string.Empty, typeof(AnnotatedModel), "Name");

            // Act
            var results = validator.Validate(metadata, container: null);

            // Assert
            Assert.Empty(results);
            attribute.VerifyAll();
        }

        // Confirm explicit false setting does not change Validate(...)'s behavior from its default.
        [Fact]
        public void ValidateSetsMemberNameProperty_NotUsingDisplayName()
        {
            AppDomainUtils.RunInSeparateAppDomain(ValidateSetsMemberNameProperty_NotUsingDisplayName_Inner);
        }

        private static void ValidateSetsMemberNameProperty_NotUsingDisplayName_Inner()
        {
            // Arrange
            DataAnnotationsModelValidator.UseLegacyValidationMemberName = false;
            var expectedMemberName = "Name";
            var attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute
                .Protected()
                .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                .Callback((object o, ValidationContext context) =>
                {
                    Assert.Equal(expectedMemberName, context.MemberName);
                })
                .Returns(ValidationResult.Success)
                .Verifiable();
            var validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);
            var metadata = _metadataProvider.GetMetadataForProperty(() => string.Empty, typeof(AnnotatedModel), "Name");

            // Act
            var results = validator.Validate(metadata, container: null);

            // Assert
            Assert.Empty(results);
            attribute.VerifyAll();
        }

        public static TheoryDataSet<ModelMetadata, string> ValidateSetsDisplayNamePropertyDataSet
        {
            get
            {
                return new TheoryDataSet<ModelMetadata, string>
                {
                    {
                        _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length"),
                        "Length"
                    },
                    {
                        _metadataProvider.GetMetadataForProperty(() => string.Empty, typeof(AnnotatedModel), "Name"),
                        "Annotated Name"
                    },
                    {
                        _metadataProvider.GetMetadataForType(() => new object(), typeof(SampleModel)),
                        "SampleModel"
                    },
                };
            }
        }

        [Theory]
        [PropertyData("ValidateSetsDisplayNamePropertyDataSet")]
        public void ValidateSetsDisplayNamePropertyOfValidationContextAsExpected(
            ModelMetadata metadata,
            string expectedDisplayName)
        {
            // Arrange
            var attribute = new Mock<ValidationAttribute>
            {
                CallBase = true,
            };
            attribute
                .Protected()
                .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                .Callback(
                    (object o, ValidationContext context) => Assert.Equal(expectedDisplayName, context.DisplayName))
                .Returns(ValidationResult.Success)
                .Verifiable();
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(
                _noValidatorProviders,
                attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(metadata, container: null);

            // Assert
            Assert.Empty(results);
            attribute.VerifyAll();
        }

        [Fact]
        public void ValidateWithIsValidTrue()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Setup(a => a.IsValid(metadata.Model)).Returns(true);
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> result = validator.Validate(metadata, null);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void ValidateWithIsValidFalse()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Setup(a => a.IsValid(metadata.Model)).Returns(false);
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> result = validator.Validate(metadata, null);

            // Assert
            var validationResult = result.Single();
            Assert.Equal("", validationResult.MemberName);
            Assert.Equal(attribute.Object.FormatErrorMessage("Length"), validationResult.Message);
        }

        [Fact]
        public void ValidatateWithValidationResultSuccess()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Returns(ValidationResult.Success);
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> result = validator.Validate(metadata, null);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void ValidateReturnsSingleValidationResultIfMemberNameSequenceIsEmpty()
        {
            // Arrange
            const string errorMessage = "Some error message";
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Returns(new ValidationResult(errorMessage, memberNames: null));
            var validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(metadata, container: null);

            // Assert
            ModelValidationResult validationResult = Assert.Single(results);
            Assert.Equal(errorMessage, validationResult.Message);
            Assert.Empty(validationResult.MemberName);
        }

        [Fact]
        public void ValidateReturnsSingleValidationResultIfOneMemberNameIsSpecified()
        {
            // Arrange
            const string errorMessage = "A different error message";
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(() => new object(), typeof(object));
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Returns(new ValidationResult(errorMessage, new[] { "FirstName" }));
            var validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(metadata, container: null);

            // Assert
            ModelValidationResult validationResult = Assert.Single(results);
            Assert.Equal(errorMessage, validationResult.Message);
            Assert.Equal("FirstName", validationResult.MemberName);
        }

        [Fact]
        public void ValidateReturnsMemberNameIfItIsDifferentFromDisplayName()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(() => new SampleModel(), typeof(SampleModel));
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Returns(new ValidationResult("Name error", new[] { "Name" }));
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(_noValidatorProviders, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(metadata, container: null);

            // Assert
            ModelValidationResult validationResult = Assert.Single(results);
            Assert.Equal("Name", validationResult.MemberName);
        }

        [Fact]
        public void IsRequiredTests()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => 15, typeof(string), "Length");

            // Act & Assert
            Assert.False(new DataAnnotationsModelValidator(_noValidatorProviders, new RangeAttribute(10, 20)).IsRequired);
            Assert.True(new DataAnnotationsModelValidator(_noValidatorProviders, new RequiredAttribute()).IsRequired);
            Assert.True(new DataAnnotationsModelValidator(_noValidatorProviders, new DerivedRequiredAttribute()).IsRequired);
        }

        class DerivedRequiredAttribute : RequiredAttribute
        {
        }

        class SampleModel
        {
            public string Name { get; set; }
        }

        private class AnnotatedModel
        {
            [Display(Name = "Annotated Name")]
            public string Name { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/Validation/Validators/ErrorModelValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Metadata.Providers;
using Microsoft.TestCommon;

namespace System.Web.Http.Validation.Validators
{
    public class ErrorModelValidatorTest
    {
        private static DataAnnotationsModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
        private static IEnumerable<ModelValidatorProvider> _noValidatorProviders = Enumerable.Empty<ModelValidatorProvider>();

        [Fact]
        public void ConstructorGuards()
        {
            Assert.ThrowsArgumentNull(
                () => new ErrorModelValidator(validatorProviders: null, errorMessage: "error"),
                "validatorProviders");
            Assert.ThrowsArgumentNull(
                () => new ErrorModelValidator(validatorProviders: _noValidatorProviders, errorMessage: null),
                "errorMessage");
        }

        [Fact]
        public void ValidateThrowsException()
        {
            ErrorModelValidator validator = new ErrorModelValidator(_noValidatorProviders, "error");

            Assert.Throws<InvalidOperationException>(() => validator.Validate(null, null), "error");
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ValueProviders/Providers/ElementalValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using Microsoft.TestCommon;

namespace System.Web.Http.ValueProviders.Providers
{
    public class ElementalValueProviderTest
    {
        [Theory]
        [InlineData("MyProperty", "MyProperty")]
        [InlineData("MyProperty.SubProperty", "MyProperty")]
        [InlineData("MyProperty[0]", "MyProperty")]
        public void ContainsPrefix_ReturnsTrue_IfElementNameStartsWithPrefix(string elementName, string prefix)
        {
            // Arrange
            CultureInfo culture = new CultureInfo("en-US");
            ElementalValueProvider elementalValueProvider = new ElementalValueProvider(elementName,
                                                                                       new object(),
                                                                                       culture);

            // Act
            bool containsPrefix = elementalValueProvider.ContainsPrefix(prefix);

            // Assert
            Assert.True(containsPrefix);
        }

        [Theory]
        [InlineData("MyProperty", "MyProperty1")]
        [InlineData("MyPropertyTest", "MyProperty")]
        [InlineData("Random", "MyProperty")]
        public void ContainsPrefix_ReturnsFalse_IfElementCannotSpecifyValuesForPrefix(string elementName, string prefix)
        {
            // Arrange
            CultureInfo culture = new CultureInfo("en-US");
            ElementalValueProvider elementalValueProvider = new ElementalValueProvider(elementName,
                                                                                       new object(),
                                                                                       culture);

            // Act
            bool containsPrefix = elementalValueProvider.ContainsPrefix(prefix);

            // Assert
            Assert.False(containsPrefix);
        }

        [Fact]
        public void GetValue_NameDoesNotMatch_ReturnsNull()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            DateTime rawValue = new DateTime(2001, 1, 2);
            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", rawValue, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("bar");

            // Assert
            Assert.Null(vpResult);
        }

        [Theory]
        [InlineData("foo")]
        [InlineData("FOO")]
        [InlineData("FoO")]
        public void GetValue_NameMatches_ReturnsValueProviderResult(string name)
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            DateTime rawValue = new DateTime(2001, 1, 2);
            ElementalValueProvider valueProvider = new ElementalValueProvider("foo", rawValue, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue(name);

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(rawValue, vpResult.RawValue);
            Assert.Equal("02/01/2001 00:00:00", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ValueProviders/Providers/NameValuePairsValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Http.ValueProviders.Providers
{
    public class NameValuePairsValueProviderTest
    {
        private static readonly IEnumerable<KeyValuePair<string, string>> _backingStore = new KeyValuePair<string, string>[]
        {
            new KeyValuePair<string, string>("foo", "fooValue1"),
            new KeyValuePair<string, string>("foo", "fooValue2"),
            new KeyValuePair<string, string>("bar.baz", "someOtherValue"),
            new KeyValuePair<string, string>("null_value", null),
            new KeyValuePair<string, string>("prefix.null_value", null)
        };

        [Fact]
        public void Constructor_GuardClauses()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new NameValuePairsValueProvider(values: (IEnumerable<KeyValuePair<string, string>>)null, culture: CultureInfo.InvariantCulture),
                "values");

            Assert.ThrowsArgumentNull(
                () => new NameValuePairsValueProvider(valuesFactory: null, culture: CultureInfo.InvariantCulture),
                "valuesFactory");
        }

        [Fact]
        public void ContainsPrefix_GuardClauses()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act & assert
            Assert.ThrowsArgumentNull(
                () => valueProvider.ContainsPrefix(null),
                "prefix");
        }

        [Fact]
        public void ContainsPrefix_WithEmptyCollection_ReturnsFalseForEmptyPrefix()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(Enumerable.Empty<KeyValuePair<string, string>>(), null);

            // Act
            bool result = valueProvider.ContainsPrefix("");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ContainsPrefix_WithNonEmptyCollection_ReturnsTrueForEmptyPrefix()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act
            bool result = valueProvider.ContainsPrefix("");

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void ContainsPrefix_WithNonEmptyCollection_ReturnsTrueForKnownPrefixes()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act & Assert
            Assert.True(valueProvider.ContainsPrefix("foo"));
            Assert.True(valueProvider.ContainsPrefix("bar"));
            Assert.True(valueProvider.ContainsPrefix("bar.baz"));
        }

        [Fact]
        public void ContainsPrefix_WithNonEmptyCollection_ReturnsFalseForUnknownPrefix()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act
            bool result = valueProvider.ContainsPrefix("biff");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void GetKeysFromPrefix_GuardClauses()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act & assert
            Assert.ThrowsArgumentNull(
                () => valueProvider.GetKeysFromPrefix(null),
                "prefix");
        }

        [Fact]
        public void GetKeysFromPrefix_EmptyPrefix_ReturnsAllPrefixes()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act
            IDictionary<string, string> result = valueProvider.GetKeysFromPrefix("");

            // Assert
            Assert.Equal<KeyValuePair<string, string>>(
                result.OrderBy(kvp => kvp.Key),
                new Dictionary<string, string> { { "bar", "bar" }, { "foo", "foo" }, { "null_value", "null_value" }, { "prefix", "prefix" } });
        }

        [Fact]
        public void GetKeysFromPrefix_UnknownPrefix_ReturnsEmptyDictionary()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act
            IDictionary<string, string> result = valueProvider.GetKeysFromPrefix("abc");

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void GetKeysFromPrefix_KnownPrefix_ReturnsMatchingItems()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act
            IDictionary<string, string> result = valueProvider.GetKeysFromPrefix("bar");

            // Assert
            KeyValuePair<string, string> kvp = Assert.Single(result);
            Assert.Equal("baz", kvp.Key);
            Assert.Equal("bar.baz", kvp.Value);
        }

        [Fact]
        public void GetValue_GuardClauses()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act & assert
            Assert.ThrowsArgumentNull(
                () => valueProvider.GetValue(null),
                "key");
        }

        [Fact]
        public void GetValue_SingleValue()
        {
            // Arrange
            var culture = CultureInfo.GetCultureInfo("fr-FR");
            var valueProvider = new NameValuePairsValueProvider(_backingStore, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("bar.baz");

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal("someOtherValue", vpResult.RawValue);
            Assert.Equal("someOtherValue", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }

        [Fact]
        public void GetValue_MultiValue()
        {
            // Arrange
            var culture = CultureInfo.GetCultureInfo("fr-FR");
            var valueProvider = new NameValuePairsValueProvider(_backingStore, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("foo");

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(new List<string>() { "fooValue1", "fooValue2" }, (List<string>)vpResult.RawValue);
            Assert.Equal("fooValue1,fooValue2", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }

        [Theory]
        [InlineData("null_value")]
        [InlineData("prefix.null_value")]
        public void GetValue_NullValue(string key)
        {
            // Arrange
            var culture = CultureInfo.GetCultureInfo("fr-FR");
            var valueProvider = new NameValuePairsValueProvider(_backingStore, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue(key);

            // Assert
            Assert.NotNull(vpResult);
            Assert.Null(vpResult.RawValue);
            Assert.Null(vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }

        [Fact]
        public void GetValue_NullMultipleValue()
        {
            // Arrange
            var backingStore = new KeyValuePair<string, string>[]
            {
                new KeyValuePair<string, string>("key", null),
                new KeyValuePair<string, string>("key", null),
                new KeyValuePair<string, string>("key", "value")
            };
            var culture = CultureInfo.GetCultureInfo("fr-FR");
            var valueProvider = new NameValuePairsValueProvider(backingStore, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("key");

            // Assert
            Assert.Equal(new[] { null, null, "value" }, vpResult.RawValue as IEnumerable<string>);
            Assert.Equal(",,value", vpResult.AttemptedValue);
        }

        [Fact]
        public void GetValue_ReturnsNullIfKeyNotFound()
        {
            // Arrange
            var valueProvider = new NameValuePairsValueProvider(_backingStore, null);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("bar");

            // Assert
            Assert.Null(vpResult);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ValueProviders/Providers/QueryStringValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Net.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;

namespace System.Web.Http.ValueProviders.Providers
{
    public class QueryStringValueProviderFactoryTest
    {
        private readonly QueryStringValueProviderFactory _factory = new QueryStringValueProviderFactory();

        [Fact]
        public void GetValueProvider_WhenActionContextParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => _factory.GetValueProvider(actionContext: null), "actionContext");
        }

        [Fact]
        public void GetValueProvider_ReturnsQueryStringValueProviderInstaceWithInvariantCulture()
        {
            var controllerContext = new HttpControllerContext() { Request = new HttpRequestMessage() };
            var context = new HttpActionContext() { ControllerContext = controllerContext };

            IValueProvider result = _factory.GetValueProvider(context);

            var valueProvider = Assert.IsType<QueryStringValueProvider>(result);
            Assert.Equal(CultureInfo.InvariantCulture, valueProvider.Culture);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ValueProviders/Providers/QueryStringValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Net.Http;
using Microsoft.TestCommon;

namespace System.Web.Http.ValueProviders.Providers
{
    public class QueryStringValueProviderTest
    {
        private NameValueCollection ParseQueryString(Uri uri)
        {
            HttpRequestMessage request = new HttpRequestMessage { RequestUri = uri };
            NameValueCollection nameValuePairs = new NameValueCollection();
            foreach (KeyValuePair<string, string> keyValuePair in request.GetQueryNameValuePairs())
            {
                nameValuePairs.Add(keyValuePair.Key, keyValuePair.Value);
            }
            return nameValuePairs;
        }

        [Fact]
        public void ParseQueryString_Null()
        {
            // Act
            NameValueCollection result = ParseQueryString(null);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void ParseQueryString_SingleNamelessValue()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            string key = Assert.Single(result) as string;
            Assert.Equal("key", key);
            Assert.Equal("", result[key]);
        }

        [Fact]
        public void ParseQueryString_SingleNamedValue()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key1=value1");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            string key = Assert.Single(result) as string;
            Assert.Equal("key1", key);
            Assert.Equal("value1", result[key]);
        }

        [Fact]
        public void ParseQueryString_TwoNamedValues()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key1=value1&key2=value2");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("value1", result["key1"]);
            Assert.Equal("value2", result["key2"]);
        }

        [Fact]
        public void ParseQueryString_MixedNamedAndUnnamedValues()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key1=value1&key2");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("value1", result["key1"]);
            Assert.Equal("", result["key2"]);
            Assert.Null(result[""]);
        }

        [Fact]
        public void ParseQueryString_MultipleValuesForSingleName()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key1=value1&key1=value2");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            Assert.Equal("value1,value2", result["key1"]);
            Assert.Equal(new[] { "value1", "value2" }, result.GetValues("key1"));
        }

        [Fact]
        public void ParseQueryString_LeadingAmpersand()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?&key1=value1");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("value1", result["key1"]);
            Assert.Equal("", result[""]);
        }

        [Fact]
        public void ParseQueryString_IntermediateDoubleAmpersand()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key1=value1&&key2=value2");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            Assert.Equal(3, result.Count);
            Assert.Equal("value1", result["key1"]);
            Assert.Equal("value2", result["key2"]);
            Assert.Equal("", result[""]);
        }

        [Fact]
        public void ParseQueryString_TrailingAmpersand()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key1=value1&");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("value1", result["key1"]);
            Assert.Equal("", result[""]);
        }

        [Fact]
        public void ParseQueryString_EncodedUrlValues()
        {
            // Arrange
            Uri uri = new Uri("http://localhost/?key%31=value%31");

            // Act
            NameValueCollection result = ParseQueryString(uri);

            // Assert
            Assert.Single(result);
            Assert.Equal("value1", result["key1"]);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ValueProviders/Providers/RouteDataValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Net.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.ValueProviders.Providers
{
    public class RouteDataValueProviderFactoryTest
    {
        private readonly RouteDataValueProviderFactory _factory = new RouteDataValueProviderFactory();

        [Fact]
        public void GetValueProvider_WhenActionContextParameterIsNull_Throws()
        {
            Assert.ThrowsArgumentNull(() => _factory.GetValueProvider(actionContext: null), "actionContext");
        }

        [Fact]
        public void GetValueProvider_ReturnsQueryStringValueProviderInstaceWithInvariantCulture()
        {
            var routeData = new Mock<IHttpRouteData>();
            routeData.Setup(r => r.Values).Returns(() => new Dictionary<string, object>());
            var controllerContext = new HttpControllerContext() { Request = new HttpRequestMessage(), RouteData = routeData.Object };
            var context = new HttpActionContext() { ControllerContext = controllerContext };

            IValueProvider result = _factory.GetValueProvider(context);

            var valueProvider = Assert.IsType<RouteDataValueProvider>(result);
            Assert.Equal(CultureInfo.InvariantCulture, valueProvider.Culture);
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ValueProviders/Providers/RouteDataValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Http.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.ValueProviders.Providers
{
    public class RouteDataValueProviderTest
    {
        [Fact]
        public void GetRouteValues_Returns_RouteValues()
        {
            // Arrange
            HttpRouteData routeData = new HttpRouteData(new HttpRoute());
            routeData.Values.Add("key1", "value1");
            routeData.Values.Add("key2", "value2");

            // Act
            IEnumerable<KeyValuePair<string, string>> result = RouteDataValueProvider.GetRouteValues(routeData);

            // Assert
            Assert.Equal(result, new Dictionary<string, string> { { "key1", "value1" }, { "key2", "value2" } });
        }

        [Fact]
        public void GetRouteValues_IfRouteDataHasNullValue_ReturnsKeyValuePairWithNullValue()
        {
            // Arrange
            HttpRouteData routeData = new HttpRouteData(new HttpRoute());
            routeData.Values.Add("key", null);

            // Act
            IEnumerable<KeyValuePair<string, string>> result = RouteDataValueProvider.GetRouteValues(routeData);

            // Assert
            Assert.Equal(result, new[] { new KeyValuePair<string, string>("key", null) });
        }
    }
}


================================================
FILE: test/System.Web.Http.Test/ValueProviders/ValueProviderResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using Microsoft.TestCommon;

namespace System.Web.Http.ValueProviders
{
    public class ValueProviderResultTest
    {
        [Fact]
        public void ConvertTo_ReturnsNullForReferenceTypes_WhenValueIsNull()
        {
            var valueProviderResult = new ValueProviderResult(null, null, CultureInfo.InvariantCulture);

            var convertedValue = valueProviderResult.ConvertTo(typeof(string));

            Assert.Null(convertedValue);
        }

        [Fact]
        public void ConvertTo_ReturnsDefaultForValueTypes_WhenValueIsNull()
        {
            var valueProviderResult = new ValueProviderResult(null, null, CultureInfo.InvariantCulture);

            var convertedValue = valueProviderResult.ConvertTo(typeof(int));

            Assert.Equal(0, convertedValue);
        }

        [Fact]
        public void ConvertTo_PopulatesArray_WhenSingleNeedsToBeConvertedToArray()
        {
            // Arrange
            var valueProviderResult = new ValueProviderResult(DayOfWeek.Friday, "It's Friday!", CultureInfo.InvariantCulture);

            // Act
            var convertedValue = (DayOfWeek[])valueProviderResult.ConvertTo(typeof(DayOfWeek[]));

            // Assert
            Assert.Single(convertedValue, DayOfWeek.Friday);
        }

        [Fact]
        public void ConvertTo_PopulatesArray_WhenSourceArrayNeedsToBeConvertedToArray()
        {
            // Arrange
            string[] values = new[] { "3", "2", "1" };
            var valueProviderResult = new ValueProviderResult(values, values.ToString(), CultureInfo.InvariantCulture);

            // Act
            var convertedValue = valueProviderResult.ConvertTo(typeof(int[]));

            // Assert
            Assert.Equal(new[] { 3, 2, 1 }, convertedValue);
        }

        [Fact]
        public void ConvertTo_PopulatesArray_WhenListNeedsToBeConvertedToArray()
        {
            // Arrange
            List<string> values = new List<string> { "-1", "0", "1" };
            var valueProviderResult = new ValueProviderResult(values, values.ToString(), CultureInfo.InvariantCulture);

            // Act
            var convertedValue = valueProviderResult.ConvertTo(typeof(int[]));

            // Assert
            Assert.IsType<int[]>(convertedValue);
            Assert.Equal(new[] { -1, 0, 1 }, convertedValue);
        }

        public static TheoryDataSet<IList, object> SingleValueBoundToArrayData
        {
            get
            {
                return new TheoryDataSet<IList, object>
                {
                    { new List<string> { "Foo", "Bar" }, "Foo" },
                    { new string[] { "baz", "qux" }, "baz" },
                    { new List<int> { -17, 34 }, -17 },
                    { new string[] { "30", "15" }, 30 }
                };
            }
        }

        [Theory]
        [PropertyData("SingleValueBoundToArrayData")]
        public void ConvertTo_ReturnsFirstValue_WhenSequenceNeedsToConvertedToSingleValue(IList value, object expected)
        {
            // Arrange
            var valueProviderResult = new ValueProviderResult(value, value.ToString(), CultureInfo.InvariantCulture);

            // Act
            var convertedValue = valueProviderResult.ConvertTo(expected.GetType());

            // Assert
            Assert.Equal(expected, convertedValue);
        }
    }
}

================================================
FILE: test/System.Web.Http.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.Tracing.Test/HttpConfigurationTracingExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.Tracing;
using Microsoft.TestCommon;

namespace System.Web.Http.Test
{
    public class HttpConfigurationTracingExtensionsTest
    {
        [Fact]
        public void EnableSystemDiagnosticsTracing_Adds_TraceWriter()
        {
            HttpConfiguration config = new HttpConfiguration();
            SystemDiagnosticsTraceWriter returnedTraceWriter = config.EnableSystemDiagnosticsTracing();
            ITraceWriter setTraceWriter = config.Services.GetService(typeof(ITraceWriter)) as ITraceWriter;

            Assert.ReferenceEquals(returnedTraceWriter, setTraceWriter);
        }

        [Fact]
        public void EnableSystemDiagnosticsTracing_ThrowsIfNull()
        {
            Assert.ThrowsArgumentNull(() => HttpConfigurationTracingExtensions.EnableSystemDiagnosticsTracing(null), "configuration");
        }
    }
}


================================================
FILE: test/System.Web.Http.Tracing.Test/System.Web.Http.Tracing.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{F87FD911-4A97-4057-8EAE-1CB96B9A1937}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.Tracing.Test</RootNamespace>
    <AssemblyName>System.Web.Http.Tracing.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="HttpConfigurationTracingExtensionsTest.cs" />
    <Compile Include="SystemDiagnosticsTraceWriterTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.Tracing\System.Web.Http.Tracing.csproj">
      <Project>{6E81EF98-8F5C-4EED-8B37-456991CA56FD}</Project>
      <Name>System.Web.Http.Tracing</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{fccc4cb7-baf7-4a57-9f89-e5766fe536c0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: test/System.Web.Http.Tracing.Test/SystemDiagnosticsTraceWriterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Web.Http.ModelBinding;
using Microsoft.TestCommon;

namespace System.Web.Http.Tracing.Diagnostics.Test
{
    public class SystemDiagnosticsTraceWriterTest
    {
        // Duplicates of constants in HttpError
        private const string MessageKey = "Message";
        private const string MessageDetailKey = "MessageDetail";
        private const string ModelStateKey = "ModelState";
        private const string ExceptionMessageKey = "ExceptionMessage";
        private const string ExceptionTypeKey = "ExceptionType";
        private const string StackTraceKey = "StackTrace";
        private const string InnerExceptionKey = "InnerException";

        [Fact]
        public void Ctor_Initializes_Properties()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();

            // Act & Assert
            Assert.False(writer.IsVerbose);
            Assert.Equal(TraceLevel.Info, writer.MinimumLevel);
            Assert.Null(writer.TraceSource);
        }

        [Fact]
        public void TraceSource_Accepts_Custom_TraceSource()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();
            TraceSource traceSource = new TraceSource("CustomTraceSource");

            // Act
            writer.TraceSource = traceSource;

            // Assert
            Assert.Equal(traceSource, writer.TraceSource);
        }

        [Fact]
        public void TraceSource_Accepts_Null_TraceSource()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();

            // Act
            writer.TraceSource = null;

            // Assert
            Assert.Null(writer.TraceSource);
        }

        [Theory]
        [InlineData(TraceLevel.Debug)]
        [InlineData(TraceLevel.Info)]
        [InlineData(TraceLevel.Warn)]
        [InlineData(TraceLevel.Error)]
        [InlineData(TraceLevel.Fatal)]
        public void MinimumLevel_Setter_Accepts_All_Legal_Levels(TraceLevel level)
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();

            // Act
            writer.MinimumLevel = level;

            // Assert
            Assert.Equal(level, writer.MinimumLevel);
        }

        [Theory]
        [InlineData(TraceLevel.Off - 1)]
        [InlineData(TraceLevel.Fatal + 1)]
        public void MinimumLevel_Setter_Throws_With_Bad_Level(TraceLevel level)
        {
            // Arrange & Act & Assert
            ArgumentOutOfRangeException exception = Assert.Throws<ArgumentOutOfRangeException>(() => { new SystemDiagnosticsTraceWriter().MinimumLevel = level; });
            Assert.Equal("value", exception.ParamName);
            Assert.Contains("The TraceLevel property must be a value between TraceLevel.Off and TraceLevel.Fatal, inclusive.", exception.Message);
            Assert.Equal(level, exception.ActualValue);
        }

        [Fact]
        public void Trace_Throws_With_Null_Category()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();

            // Act & Assert
            ArgumentNullException exception = Assert.Throws<ArgumentNullException>(
                                                () => writer.Trace(new HttpRequestMessage(),
                                                                    null,
                                                                    TraceLevel.Info,
                                                                    (tr) => { }));
            Assert.Equal("category", exception.ParamName);
        }

        [Fact]
        public void Trace_Throws_With_Null_TraceAction()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();

            // Act & Assert
            ArgumentNullException exception = Assert.Throws<ArgumentNullException>(
                                                () => writer.Trace(new HttpRequestMessage(),
                                                                    "MyCategory",
                                                                    TraceLevel.Info,
                                                                    traceAction: null));
            Assert.Equal("traceAction", exception.ParamName);
        }

        [Theory]
        [InlineData(TraceLevel.Off - 1)]
        [InlineData(TraceLevel.Fatal + 1)]
        public void Trace_Throws_With_Illegal_Level(TraceLevel level)
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();

            // Act & Assert
            ArgumentOutOfRangeException exception = Assert.Throws<ArgumentOutOfRangeException>(
                                                () => writer.Trace(new HttpRequestMessage(),
                                                                    "MyCategory",
                                                                    level,
                                                                    (tr) => { }));
            Assert.Equal("level", exception.ParamName);
            Assert.Contains("The TraceLevel property must be a value between TraceLevel.Off and TraceLevel.Fatal, inclusive.", exception.Message);
            Assert.Equal(level, exception.ActualValue);
        }

        [Fact]
        public void Trace_Writes_To_Custom_TraceSource()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            // Act
            writer.Info(request, "TestCategory", "TestMessage");

            // Assert
            Assert.Equal("Message='TestMessage'", ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages[0]);
        }

        [Theory]
        [InlineData(TraceLevel.Debug, TraceEventType.Verbose)]
        [InlineData(TraceLevel.Info, TraceEventType.Information)]
        [InlineData(TraceLevel.Warn, TraceEventType.Warning)]
        [InlineData(TraceLevel.Error, TraceEventType.Error)]
        [InlineData(TraceLevel.Fatal, TraceEventType.Critical)]
        public void Trace_Writes_Correct_EventType_To_TraceListeners(TraceLevel level, TraceEventType diagnosticLevel)
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();
            writer.MinimumLevel = level;

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            // Act
            writer.Trace(request, "TestCategory", level, (tr) => { tr.Message = "TestMessage"; });

            // Assert
            Assert.Equal(diagnosticLevel, ((TestTraceListener)writer.TraceSource.Listeners[0]).TraceEventType);
        }

        [Theory]
        [InlineData(TraceLevel.Debug)]
        [InlineData(TraceLevel.Info)]
        [InlineData(TraceLevel.Warn)]
        [InlineData(TraceLevel.Error)]
        [InlineData(TraceLevel.Fatal)]
        public void Trace_Verbose_Writes_Correct_Message_To_TraceListeners_With_All_Fields_Set(TraceLevel level)
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();
            writer.MinimumLevel = level;
            writer.IsVerbose = true;

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception = new InvalidOperationException("TestException");

            // Act
            writer.Trace(request, "TestCategory", level, (tr) =>
            {
                tr.Message = "TestMessage";
                tr.Operation = "TestOperation";
                tr.Operator = "TestOperator";
                tr.Status = HttpStatusCode.Accepted;
                tr.Exception = exception;
            });

            // Assert
            string expected = String.Format("Level={0}, Kind=Trace, Category='TestCategory', Id={1}, Message='TestMessage', Operation=TestOperator.TestOperation, Status=202 (Accepted), Exception={2}",
                                                level.ToString(),
                                                request.GetCorrelationId().ToString(),
                                                exception.ToString());

            string actual = ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages[0].Trim();
            string timePrefix = "] ";
            actual = actual.Substring(actual.IndexOf(timePrefix) + timePrefix.Length);
            Assert.Equal(expected, actual);
        }

        [Theory]
        [InlineData(TraceLevel.Debug)]
        [InlineData(TraceLevel.Info)]
        [InlineData(TraceLevel.Warn)]
        [InlineData(TraceLevel.Error)]
        [InlineData(TraceLevel.Fatal)]
        public void Trace_Brief_Writes_Correct_Message_To_TraceListeners_With_All_Fields_Set(TraceLevel level)
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();
            writer.MinimumLevel = level;

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception = new InvalidOperationException("TestException");

            // Act
            writer.Trace(request, "TestCategory", level, (tr) =>
            {
                tr.Message = "TestMessage";
                tr.Operation = "TestOperation";
                tr.Operator = "TestOperator";
                tr.Status = HttpStatusCode.Accepted;
                tr.Exception = exception;
            });

            // Assert
            string expected = "Message='TestMessage', Operation=TestOperator.TestOperation, Status=202 (Accepted), Exception=System.InvalidOperationException: TestException";
            string actual = ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages[0].Trim();
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void Trace_Verbose_Writes_Correct_Message_To_TraceListeners_With_Only_Required_Fields_Set()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();
            writer.IsVerbose = true;

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception = new InvalidOperationException("TestException");

            // Act
            writer.Info(request, "TestCategory", String.Empty);

            // Assert
            string expected = String.Format("Level=Info, Kind=Trace, Category='TestCategory', Id={0}",
                                            request.GetCorrelationId().ToString());

            string actual = ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages[0].Trim();
            string timePrefix = "] ";
            actual = actual.Substring(actual.IndexOf(timePrefix) + timePrefix.Length);
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void Trace_Brief_Writes_Correct_Message_To_TraceListeners_With_Only_Required_Fields_Set()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception = new InvalidOperationException("TestException");

            // Act
            writer.Info(request, "TestCategory", "TestMessage");

            // Assert
            string expected = "Message='TestMessage'";
            string actual = ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages[0].Trim();
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void Trace_Brief_Trace_Does_Not_Trace_When_No_Data()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception = new InvalidOperationException("TestException");

            // Act
            writer.Trace(request, "TestCategory", TraceLevel.Info, (tr) => { });

            // Assert
            Assert.Equal(0, ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages.Count);
        }

        [Fact]
        public void Trace_Brief_Trace_Does_Not_Trace_BeginKind()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception = new InvalidOperationException("TestException");

            // Act
            writer.Trace(request, "TestCategory", TraceLevel.Info, (tr) => { tr.Kind = TraceKind.Begin; tr.Message = "TestMessage"; });

            // Assert
            Assert.Equal(0, ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages.Count);
        }

        [Theory]
        [InlineData(TraceLevel.Debug)]
        [InlineData(TraceLevel.Info)]
        [InlineData(TraceLevel.Warn)]
        [InlineData(TraceLevel.Error)]
        [InlineData(TraceLevel.Fatal)]
        public void Trace_Does_Not_Trace_Below_Minimum_Level(TraceLevel level)
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();
            writer.MinimumLevel = level;

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception = new InvalidOperationException("TestException");

            // Act
            writer.Trace(request, "TestCategory", level - 1, (tr) => { });

            // Assert
            Assert.Equal(0, ((TestTraceListener)writer.TraceSource.Listeners[0]).Messages.Count);
        }

        [Fact]
        public void Trace_Traces_Warning_EventType_When_Translates_HttpResponseException_Error()
        {
            // Arrange
            SystemDiagnosticsTraceWriter writer = CreateTraceWriter();
            writer.IsVerbose = true;

            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.BadRequest, "bad request");
            HttpResponseException responseException = new HttpResponseException(response);

            // Act
            writer.Error(request, "TestCategory", responseException);

            // Assert
            Assert.Equal(TraceEventType.Warning, ((TestTraceListener)writer.TraceSource.Listeners[0]).TraceEventType);
        }

        [Fact]
        void Format_Throws_With_Null_TraceRecord()
        {
            // Arrange & Act & Assert
            ArgumentNullException exception =
                Assert.Throws<ArgumentNullException>(
                () => { new SystemDiagnosticsTraceWriter().Format(null); });

            Assert.Equal("traceRecord", exception.ParamName);
        }

        [Theory]
        [InlineData(TraceLevel.Debug)]
        [InlineData(TraceLevel.Info)]
        [InlineData(TraceLevel.Warn)]
        [InlineData(TraceLevel.Error)]
        [InlineData(TraceLevel.Fatal)]
        public void Format_Verbose_Builds_Trace_With_All_TraceRecord_Properties(TraceLevel level)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            InvalidOperationException exception;
            try
            {
                // Want the full stack trace in the payload
                throw new InvalidOperationException("TestException");
            }
            catch (InvalidOperationException ex)
            {
                exception = ex;
            }

            TraceRecord traceRecord = new TraceRecord(request, "TestCategory", level)
            {
                Message = "TestMessage",
                Operation = "TestOperation",
                Operator = "TestOperator",
                Status = HttpStatusCode.Accepted,
                Exception = exception
            };

            // Act
            string formattedTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.Format(traceRecord);

            // Assert
            AssertContainsExactly(formattedTrace,
                                new Dictionary<string, string>
                                    {
                                        { "Level", level.ToString() },
                                        { "Kind", TraceKind.Trace.ToString() },
                                        { "Category", "'TestCategory'"},
                                        { "Id", request.GetCorrelationId().ToString() },
                                        { "Message", "'TestMessage'" },
                                        { "Operation", "TestOperator.TestOperation" },
                                        { "Status", "202 (Accepted)" },
                                        { "Exception", exception.ToString() },
                                    });

        }

        [Fact]
        public void Format_Builds_Trace_With_Null_Fields()
        {
            // Arrange
            TraceRecord traceRecord = new TraceRecord(request: null, category: null, level: TraceLevel.Info)
            {
                Message = null,
                Operation = null,
                Operator = null,
            };

            // Act
            string formattedTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.Format(traceRecord);

            // Assert
            AssertContainsExactly(formattedTrace,
                                new Dictionary<string, string>
                                    {
                                        { "Level", TraceLevel.Info.ToString() },
                                        { "Kind", TraceKind.Trace.ToString() },
                                        { "Id", new Guid().ToString() }
                                    });

        }

        [Fact]
        public void Format_Delegates_To_FormatRequestEnvelope_Begin()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Info)
            {
                Kind = TraceKind.Begin,
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.Format(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Request received, Method=GET, Url=http://localhost/, Id={0}", traceRecord.RequestId.ToString());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        public void Format_Verbose_Delegates_To_FormatRequestEnvelope_End()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Info)
            {
                Kind = TraceKind.End,
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.Format(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Sending response, Method=GET, Url=http://localhost/, Id={0}", traceRecord.RequestId.ToString());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        void FormatRequestEnvelope_Throws_With_Null_TraceRecord()
        {
            // Arrange & Act & Assert
            ArgumentNullException exception =
                Assert.Throws<ArgumentNullException>(
                () => { new SystemDiagnosticsTraceWriter().FormatRequestEnvelope(null); });

            Assert.Equal("traceRecord", exception.ParamName);
        }

        [Fact]
        public void FormatRequestEnvelope_Verbose_Builds_Correct_Begin_Trace_With_Only_Required_Fields()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Info)
            {
                Kind = TraceKind.Begin,
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.FormatRequestEnvelope(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Request received, Method=GET, Url=http://localhost/, Id={0}", traceRecord.RequestId.ToString());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        public void FormatRequestEnvelope_Verbose_Builds_Correct_Begin_Trace_With_All_Fields()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            Exception exception = null;
            try
            {
                throw new InvalidOperationException("ExceptionMessage");
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Info)
            {
                Kind = TraceKind.Begin,
                Message = "EnvelopeMessage",
                Exception = exception
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.FormatRequestEnvelope(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Request received, Method=GET, Url=http://localhost/, Id={0}, Message='EnvelopeMessage', Exception={1}",
                                                traceRecord.RequestId.ToString(),
                                                exception.ToString().Trim());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        public void FormatRequestEnvelope_Verbose_Builds_Correct_Begin_Trace_With_Null_Fields()
        {
            // Arrange
            TraceRecord traceRecord = new TraceRecord(request: null, category: null, level: TraceLevel.Info)
            {
                Kind = TraceKind.Begin,
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.FormatRequestEnvelope(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Request received, Id={0}", traceRecord.RequestId.ToString());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        public void FormatRequestEnvelope_Verbose_Builds_Correct_End_Trace_With_Only_Required_Fields()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Info)
            {
                Kind = TraceKind.End,
                Status = HttpStatusCode.Accepted
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.FormatRequestEnvelope(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Sending response, Status=202 (Accepted), Method=GET, Url=http://localhost/, Id={0}", traceRecord.RequestId.ToString());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        public void FormatRequestEnvelope_Verbose_Builds_Correct_End_Trace_With_All_Fields()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            Exception exception = null;
            try
            {
                throw new InvalidOperationException("ExceptionMessage");
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Info)
            {
                Kind = TraceKind.End,
                Status = HttpStatusCode.Accepted,
                Message = "EnvelopeMessage",
                Exception = exception
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.FormatRequestEnvelope(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Sending response, Status=202 (Accepted), Method=GET, Url=http://localhost/, Id={0}, Message={1}, Exception={2}",
                                                    traceRecord.RequestId.ToString(),
                                                    "'EnvelopeMessage'",
                                                    exception.ToString().Trim());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        public void FormatRequestEnvelope_Verbose_Builds_Correct_End_Trace_With_Null_Fields()
        {
            // Arrange
            TraceRecord traceRecord = new TraceRecord(request: null, category: null, level: TraceLevel.Info)
            {
                Kind = TraceKind.End,
            };

            // Act
            string actualTrace = new SystemDiagnosticsTraceWriter() { IsVerbose = true }.FormatRequestEnvelope(traceRecord);

            // Assert
            string timePrefix = "] ";
            actualTrace = actualTrace.Substring(actualTrace.IndexOf(timePrefix) + timePrefix.Length);
            string expectedTrace = String.Format("Sending response, Id={0}", traceRecord.RequestId.ToString());
            Assert.Equal(expectedTrace, actualTrace);
        }

        [Fact]
        void TranslateHttpResponseException_Throws_With_Null_TraceRecord()
        {
            // Arrange & Act & Assert
            ArgumentNullException exception =
                Assert.Throws<ArgumentNullException>(
                    () => { new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(null); });

            Assert.Equal("traceRecord", exception.ParamName);
        }

        [Fact]
        public void TranslateHttpResponseException_Copies_Status_From_Response()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "MyCategory", TraceLevel.Error)
            {
                Exception = new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest))
            };

            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(HttpStatusCode.BadRequest, traceRecord.Status);
        }

        [Fact]
        public void TranslateHttpResponseException_Maps_Client_Error_To_Warning()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "MyCategory", TraceLevel.Error)
            {
                Exception = new HttpResponseException(new HttpResponseMessage(HttpStatusCode.BadRequest))
            };


            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Warn, traceRecord.Level);
        }

        [Fact]
        public void TranslateHttpResponseException_Maps_Non_Errors_To_Info()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "MyCategory", TraceLevel.Error)
            {
                Exception = new HttpResponseException(new HttpResponseMessage(HttpStatusCode.Moved))
            };


            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Info, traceRecord.Level);
        }

        [Fact]
        public void TranslateHttpResponseException_Does_Not_Alter_Server_Errors()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            TraceRecord traceRecord = new TraceRecord(request, "MyCategory", TraceLevel.Error)
            {
                Exception = new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError))
            };


            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Error, traceRecord.Level);
        }

        [Fact]
        public void TranslateHttpResponseException_Unpacks_Empty_HttpError()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            HttpError httpError = new HttpError();
            HttpResponseMessage errorResponse = request.CreateResponse(HttpStatusCode.BadRequest);
            errorResponse.Content = new ObjectContent<HttpError>(httpError, new JsonMediaTypeFormatter());

            TraceRecord traceRecord = new TraceRecord(request, "MyCategory", TraceLevel.Error)
            {
                Exception = new HttpResponseException(errorResponse)
            };


            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(0, ParseTrace(traceRecord.Message).Count);
        }

        [Fact]
        public void TranslateHttpResponseException_Unpacks_HttpError_With_All_Fields_Set()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            Exception exception = null;
            try
            {
                throw new InvalidOperationException("ExpectedExceptionMessage");
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            HttpError httpError = new HttpError(exception, includeErrorDetail: true);
            httpError.Message = "ExpectedUserMessage";
            httpError[MessageDetailKey] = "ExpectedDetailMessage";

            HttpResponseMessage errorResponse = request.CreateResponse(HttpStatusCode.BadRequest);
            errorResponse.Content = new ObjectContent<HttpError>(httpError, new JsonMediaTypeFormatter());

            TraceRecord traceRecord = new TraceRecord(request, "MyCategory", TraceLevel.Error)
            {
                Exception = new HttpResponseException(errorResponse)
            };


            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Warn, traceRecord.Level);

            AssertContainsExactly(traceRecord.Message, new Dictionary<string, string>()
            {
                { "UserMessage", "'ExpectedUserMessage'" },
                { "MessageDetail", "'ExpectedDetailMessage'" },
                { "ExceptionType", "'System.InvalidOperationException'" },
                { "ExceptionMessage", "'ExpectedExceptionMessage'" },
                { "StackTrace", exception.StackTrace.Trim() }
            });
        }

        [Fact]
        public void TranslateHttpResponseException_Unpacks_HttpError_With_Inner_Exceptions()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            Exception exception1 = null;
            Exception exception2 = null;
            Exception exception3 = null;

            try
            {
                throw new NotSupportedException("ExpectedExceptionMessage3");
            }
            catch (Exception ex)
            {
                exception3 = ex;
            }

            try
            {
                throw new NotImplementedException("ExpectedExceptionMessage2", exception3);
            }
            catch (Exception ex)
            {
                exception2 = ex;
            }

            try
            {
                throw new InvalidOperationException("ExpectedExceptionMessage1", exception2);
            }
            catch (Exception ex)
            {
                exception1 = ex;
            }

            HttpError httpError = new HttpError(exception1, includeErrorDetail: true);
            httpError.Message = "ExpectedUserMessage";
            httpError[MessageDetailKey] = "ExpectedDetailMessage";

            HttpResponseMessage errorResponse = request.CreateResponse(HttpStatusCode.BadRequest);
            errorResponse.Content = new ObjectContent<HttpError>(httpError, new JsonMediaTypeFormatter());

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Error)
            {
                Exception = new HttpResponseException(errorResponse)
            };


            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Warn, traceRecord.Level);

            AssertContainsExactly(traceRecord.Message, new Dictionary<string, string>()
            {
                { "UserMessage", "'ExpectedUserMessage'" },
                { "MessageDetail", "'ExpectedDetailMessage'" },

                { "ExceptionType", "'System.InvalidOperationException'" },
                { "ExceptionMessage", "'ExpectedExceptionMessage1'" },
                { "StackTrace", exception1.StackTrace.Trim() },

                { "ExceptionType[1]", "'System.NotImplementedException'" },
                { "ExceptionMessage[1]", "'ExpectedExceptionMessage2'" },
                { "StackTrace[1]", exception2.StackTrace.Trim() },

                { "ExceptionType[2]", "'System.NotSupportedException'" },
                { "ExceptionMessage[2]", "'ExpectedExceptionMessage3'" },
                { "StackTrace[2]", exception3.StackTrace.Trim() }

            });
        }

        [Fact]
        public void TranslateHttpResponseException_HiddenInAggregateException_UnpackTheMostSevere()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            var ex500 = new HttpResponseException(HttpStatusCode.InternalServerError);
            var ex503 = new HttpResponseException(HttpStatusCode.ServiceUnavailable);
            var ex401 = new HttpResponseException(HttpStatusCode.Unauthorized);
            var ex503IsWithinMe = new Exception("I have 503 inside me", ex503);

            var aggregate = new AggregateException(ex500, ex503IsWithinMe, ex401);

            HttpError httpError = new HttpError(aggregate, includeErrorDetail: true);
            HttpResponseMessage errorResponse = request.CreateResponse(HttpStatusCode.ServiceUnavailable);
            errorResponse.Content = new ObjectContent<HttpError>(httpError, new JsonMediaTypeFormatter());

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Error)
            {
                Exception = new HttpResponseException(errorResponse)
            };

            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Error, traceRecord.Level);
            Assert.Equal(HttpStatusCode.ServiceUnavailable, traceRecord.Status);
        }

        [Fact]
        public void TranslateHttpResponseException_Unpacks_ModelState_Errors()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            ModelStateDictionary modelStateDictionary = new ModelStateDictionary();
            ModelState modelState1 = new ModelState();
            modelState1.Errors.Add("modelState1.Error1");
            modelState1.Errors.Add("modelState1.Error2");
            modelStateDictionary["key1"] = modelState1;

            ModelState modelState2 = new ModelState();
            modelState2.Errors.Add("modelState2.Error1");
            modelState2.Errors.Add("modelState2.Error2");
            modelStateDictionary["key2"] = modelState2;

            HttpError httpError = new HttpError(modelStateDictionary, includeErrorDetail: true);
            HttpResponseMessage errorResponse = request.CreateResponse(HttpStatusCode.BadRequest);
            errorResponse.Content = new ObjectContent<HttpError>(httpError, new JsonMediaTypeFormatter());

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Error)
            {
                Exception = new HttpResponseException(errorResponse)
            };

            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Warn, traceRecord.Level);

            string message = ExtractModelStateErrorString(traceRecord.Message);

            AssertContainsExactly(message, new Dictionary<string, string>()
            {
                { "key1", "[modelState1.Error1, modelState1.Error2]" },
                { "key2", "[modelState2.Error1, modelState2.Error2]" },
            });
        }

        [Fact]
        public void TranslateHttpResponseException_Unpacks_HttpError_With_No_Fields_Set()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri("http://localhost"),
                Method = HttpMethod.Get
            };

            Exception exception = null;
            try
            {
                throw new InvalidOperationException("ExpectedExceptionMessage");
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            HttpError httpError = new HttpError();
            HttpResponseMessage errorResponse = request.CreateResponse(HttpStatusCode.BadRequest);
            errorResponse.Content = new ObjectContent<HttpError>(httpError, new JsonMediaTypeFormatter());

            TraceRecord traceRecord = new TraceRecord(request, "System.Web.Http.Request", TraceLevel.Error)
            {
                Exception = new HttpResponseException(errorResponse)
            };

            // Act
            new SystemDiagnosticsTraceWriter().TranslateHttpResponseException(traceRecord);

            // Assert
            Assert.Equal(TraceLevel.Warn, traceRecord.Level);
            Assert.Equal(string.Empty, traceRecord.Message);
        }

        private static void AssertContainsExactly(string trace, IDictionary<string, string> expected)
        {
            IDictionary<string, string> actual = ParseTrace(trace);
            Assert.Equal(expected.Count, actual.Count);
            foreach (string key in expected.Keys)
            {
                Assert.True(actual.ContainsKey(key), String.Format("Missing {0} field", key));
                Assert.Equal(expected[key], actual[key]);
            }
        }

        private static IDictionary<string, string> ParseTrace(string trace)
        {
            Dictionary<string, string> traces = new Dictionary<string, string>();
            string[] splits = trace.Split('=');
            for (int i = 0; i < splits.Length - 1; i++)
            {
                // Line is either "key" or "value key" -- get the key part
                string[] nextSplit = splits[i].Split(' ');
                if (nextSplit.Length < 1)
                {
                    continue;
                }
                string key = nextSplit[nextSplit.Length - 1].Trim();

                string value;

                // Last item containing name takes entire remaining text
                if (i == splits.Length - 2)
                {
                    value = splits[i + 1].Trim();
                }
                else
                {
                    // Next line is "value, nextKey" -- get the value part
                    int lastCommaPos = splits[i + 1].LastIndexOf(", ");
                    if (lastCommaPos < 0)
                    {
                        continue;
                    }

                    value = splits[i + 1].Substring(0, lastCommaPos).Trim();
                }

                traces[key] = value;
            }

            return traces;
        }

        private static string ExtractModelStateErrorString(string message)
        {
            string modelStatePrefix = "ModelStateError=[";
            int modelStatePrefixPos = message.IndexOf(modelStatePrefix);
            Assert.True(modelStatePrefixPos >= 0);
            int lastBracketPos = message.LastIndexOf("]");
            Assert.True(lastBracketPos > modelStatePrefixPos);

            int startPos = modelStatePrefixPos + modelStatePrefix.Length;

            return message.Substring(startPos, lastBracketPos - startPos);
        }

        // Helper to create a new SystemDiagnosticsTraceWriter configured
        // to use a custom TraceSource to write its traces to a TestTraceListener.
        private static SystemDiagnosticsTraceWriter CreateTraceWriter()
        {
            TestTraceListener testTraceListener = new TestTraceListener();
            TraceSource testTraceSource = new TraceSource("TestTraceSource", SourceLevels.All);
            testTraceSource.Listeners.Clear();
            testTraceSource.Listeners.Add(testTraceListener);

            SystemDiagnosticsTraceWriter writer = new SystemDiagnosticsTraceWriter();
            writer.TraceSource = testTraceSource;
            return writer;
        }

        // Test spy used to capture test traces
        class TestTraceListener : TraceListener
        {
            private List<string> _messages = new List<string>();

            public IList<string> Messages { get { return _messages; } }

            public string SourceName { get; set; }

            public int? Id { get; set; }

            public TraceEventType TraceEventType { get; set; }

            public override void Write(string message)
            {
                _messages.Add(message);
            }

            public override void WriteLine(string message)
            {
                Write(message + Environment.NewLine);
            }

            public override void TraceEvent(TraceEventCache eventCache, string source, TraceEventType eventType, int id, string message)
            {
                _messages.Add(message);
                SourceName = source;
                Id = id;
                TraceEventType = eventType;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.Tracing.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Http.WebHost.Test/BatchingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Batch;
using System.Web.Http.WebHost.Routing;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.WebHost
{
    public class BatchingTest
    {
        // Regression test for Codeplex-2103
        //
        // When batching is used in web host, we need to wrap the HttpRequestMessages in an HttpContextBase
        // adapter and pass system to system.web. In 2103 there were bugs in this wrapper, and we weren't 
        // following the contract with respect to %-encoding.
        [Fact]
        public async Task WebHost_Batching_WithSpecialCharactersInUrl()
        {
            // Arrange
            var handler = new SuccessMessageHandler();

            var routeCollection = new HostedHttpRouteCollection(new RouteCollection(), "/");
            routeCollection.Add("default", routeCollection.CreateRoute(
                "values/  space",
                defaults: null,
                constraints: null,
                dataTokens: null,
                handler: handler));

            var configuration = new HttpConfiguration(routeCollection);

            var server = new HttpServer(configuration);

            var batchHandler = new DefaultHttpBatchHandler(server);
            var request = new HttpRequestMessage
            {
                Content = new MultipartContent("mixed")
                {
                    new HttpMessageContent(new HttpRequestMessage(HttpMethod.Post, "http://contoso.com/values/  space"))
                }
            };

            // Arrange
            var response = await batchHandler.ProcessBatchAsync(request, CancellationToken.None);

            // Assert
            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
            Assert.True(handler.IsCalled);
        }

        private class SuccessMessageHandler : HttpMessageHandler
        {
            public bool IsCalled { get; private set; }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                IsCalled = true;
                return Task.FromResult(request.CreateResponse(HttpStatusCode.OK));
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/GlobalConfigurationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Dispatcher;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.WebHost;
using System.Web.Http.WebHost.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class GlobalConfigurationTest
    {
        [Fact]
        public void ConfigurationRouteCollection_IsHostedHttpRouteCollection()
        {
            // Arrange
            HttpConfiguration configuration = GlobalConfiguration.Configuration;
            Assert.NotNull(configuration); // Guard

            // Act
            HttpRouteCollection routes = configuration.Routes;

            // Assert
            Assert.IsType<HostedHttpRouteCollection>(routes);
            // Note that there is currently no easy way to test that it references RouteTable.Routes.
        }

        [Theory]
        [InlineData(typeof(IAssembliesResolver), typeof(WebHostAssembliesResolver))]
        [InlineData(typeof(IHttpControllerTypeResolver), typeof(WebHostHttpControllerTypeResolver))]
        [InlineData(typeof(IHostBufferPolicySelector), typeof(WebHostBufferPolicySelector))]
        [InlineData(typeof(IExceptionHandler), typeof(WebHostExceptionHandler))]
        public void ConfigurationService_IsWebHost(Type serviceInterfaceType, Type expectedImplementationType)
        {
            // Arrange
            HttpConfiguration configuration = GlobalConfiguration.Configuration;
            Assert.NotNull(configuration); // Guard
            Assert.NotNull(configuration.Services); // Guard

            // Act
            object service = configuration.Services.GetService(serviceInterfaceType);

            // Assert
            Assert.IsType(expectedImplementationType, service);
        }

        [Fact]
        public void ExceptionHandler_WrapsDefaultExceptionHandler()
        {
            // Arrange
            HttpConfiguration configuration = GlobalConfiguration.Configuration;
            Assert.NotNull(configuration); // Guard
            Assert.NotNull(configuration.Services); // Guard

            Type defaultExceptionHandlerType;

            using (HttpConfiguration standardConfiguration = new HttpConfiguration())
            {
                defaultExceptionHandlerType = standardConfiguration.Services.GetExceptionHandler().GetType();
            }

            // Act
            object service = configuration.Services.GetService(typeof(IExceptionHandler));

            // Assert
            WebHostExceptionHandler typedHandler = Assert.IsType<WebHostExceptionHandler>(service); // Guard
            Assert.IsType(defaultExceptionHandlerType, typedHandler.InnerHandler);
        }

        [Fact]
        public void DefaultHandler_IsHttpRoutingDispatcher()
        {
            // Act
            HttpMessageHandler handler = GlobalConfiguration.DefaultHandler;

            // Assert
            Assert.IsType<HttpRoutingDispatcher>(handler);
            // Note that there is currently no easy way to test it references GlobalConfiguration.Configuration.
        }

        [Fact]
        public void DefaultServer_ReferencesConfiguration()
        {
            // Act
            HttpServer server = GlobalConfiguration.DefaultServer;

            // Assert
            Assert.NotNull(server);
            Assert.Same(GlobalConfiguration.Configuration, server.Configuration);
        }

        [Fact]
        public void DefaultServer_ReferencesDefaultHandler()
        {
            // Act
            HttpServer server = GlobalConfiguration.DefaultServer;

            // Assert
            Assert.NotNull(server);
            Assert.Same(GlobalConfiguration.DefaultHandler, server.Dispatcher);
        }

        [Fact]
        public void Configure_Throws_WhenConfigurationCallbackIsNull()
        {
            // Arrange
            using (new GlobalConfigurationContext())
            {
                // Act & Assert
                Assert.ThrowsArgumentNull(() => { GlobalConfiguration.Configure(null); }, "configurationCallback");
            }
        }

        [Fact]
        public void Configure_CallsCallbackOnceWithGlobalConfiguration()
        {
            // Arrange
            using (new GlobalConfigurationContext())
            {
                int calls = 0;
                HttpConfiguration configuration = null;
                Action<HttpConfiguration> callback = (c) =>
                {
                    calls++;
                    configuration = c;
                };

                // Act
                GlobalConfiguration.Configure(callback);

                // Assert
                Assert.Equal(1, calls);
                Assert.Same(GlobalConfiguration.Configuration, configuration);
            }
        }

        [Fact]
        public void Configure_CallsConfigurationEnsureInitialized()
        {
            // Arrange
            using (new GlobalConfigurationContext())
            {
                bool initialized = false;
                GlobalConfiguration.Configuration.Initializer = (c) =>
                {
                    initialized = true;
                };
                Action<HttpConfiguration> callback = (ignore) => { };

                // Act
                GlobalConfiguration.Configure(callback);

                // Assert
                Assert.True(initialized);
            }
        }

        private sealed class GlobalConfigurationContext : IDisposable
        {
            bool disposed;

            public void Dispose()
            {
                if (!disposed)
                {
                    GlobalConfiguration.Reset();
                    disposed = true;
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/HttpControllerHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.Contracts;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Hosting;
using System.Web.Http.Results;
using System.Web.Http.WebHost.Routing;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;
using Newtonsoft.Json.Linq;

namespace System.Web.Http.WebHost
{
    public class HttpControllerHandlerTest
    {
        public static TheoryDataSet<HttpMethod> AllHttpMethods
        {
            get
            {
                return new TheoryDataSet<HttpMethod>
                {
                    HttpMethod.Get,
                    HttpMethod.Post,
                    HttpMethod.Put,
                    HttpMethod.Delete,
                    HttpMethod.Head,
                    HttpMethod.Options,
                    HttpMethod.Trace
                };
            }
        }

        public static TheoryDataSet<HttpMethod> HttpMethodsWithContent
        {
            get
            {
                return new TheoryDataSet<HttpMethod>
                {
                    HttpMethod.Post,
                    HttpMethod.Put,
                    HttpMethod.Delete,
                };
            }
        }

        [Theory]
        [PropertyData("AllHttpMethods")]
        public void ConvertRequest_Creates_HttpRequestMessage_For_All_HttpMethods(HttpMethod httpMethod)
        {
            // Arrange
            HttpContextBase contextBase = CreateStubContextBase(httpMethod.Method, new MemoryStream());

            // Act
            HttpRequestMessage request = HttpControllerHandler.ConvertRequest(contextBase);

            // Assert
            Assert.Equal(httpMethod, request.Method);
        }

        [Fact]
        public void ConvertRequest_DoesNotAddContentLength()
        {
            // Arrange
            HttpContextBase contextBase = CreateStubContextBase("Get", new MemoryStream());

            // Act
            HttpRequestMessage request = HttpControllerHandler.ConvertRequest(contextBase);

            // Assert
            var headers = request.Content.Headers;
            Assert.NotNull(headers);
            Assert.Null(headers.ContentLength);

            IEnumerable<string> unused;
            Assert.False(headers.TryGetValues("Content-Length", out unused));
        }

        [Fact]
        public void ConvertRequest_Copies_Headers_And_Content_Headers()
        {
            // Arrange
            HttpContextBase contextBase = CreateStubContextBase("Get", new MemoryStream());
            HttpRequestBase requestBase = contextBase.Request;
            NameValueCollection nameValues = requestBase.Headers;
            nameValues["myHeader"] = "myValue";
            nameValues["Content-Type"] = "application/mine";

            // Act
            HttpRequestMessage request = HttpControllerHandler.ConvertRequest(contextBase);
            string[] headerValues = request.Headers.GetValues("myHeader").ToArray();

            // Assert
            Assert.Equal("myValue", headerValues[0]);
            Assert.Equal("application/mine", request.Content.Headers.ContentType.MediaType);
        }

        [Theory]
        [PropertyData("HttpMethodsWithContent")]
        public void ConvertRequest_Creates_Request_With_Content_For_Content_Methods(HttpMethod httpMethod)
        {
            // Arrange
            HttpContextBase contextBase = CreateStubContextBase(httpMethod.Method, new MemoryStream());

            // Act
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(contextBase);

            // Assert
            Assert.NotNull(actualRequest.Content);
        }

        [Fact]
        public async Task ConvertRequest_Uses_HostBufferPolicySelector_To_Select_Buffered_Stream()
        {
            // Arrange
            HttpContextBase contextMock = CreateStubContextBase("Post", new MemoryStream(new byte[] { 5 }));
            MemoryStream memoryStream = new MemoryStream();

            // Act
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(contextMock);
            await actualRequest.Content.CopyToAsync(memoryStream);
            byte[] actualBuffer = memoryStream.GetBuffer();

            // Assert
            Assert.Equal(5, actualBuffer[0]);
        }

        [Fact]
        public void ConvertRequest_AddsOwinEnvironment_WhenPresentInHttpContext()
        {
            // Arrange
            using (MemoryStream ignoreStream = new MemoryStream())
            {
                HttpRequestBase stubRequest = CreateStubRequestBase("IgnoreMethod", ignoreStream);
                IDictionary<string, object> expectedEnvironment = new Dictionary<string, object>();
                IDictionary items = new Hashtable
                {
                    { HttpControllerHandler.OwinEnvironmentHttpContextKey, expectedEnvironment }
                };
                HttpContextBase context = CreateStubContextBase(stubRequest, items);

                // Act
                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    IDictionary<string, object> environment = actualRequest.GetOwinEnvironment();

                    // Assert
                    Assert.Same(expectedEnvironment, environment);
                }
            }
        }

        [Fact]
        public void ConvertRequest_DoesNotAddOwinEnvironment_WhenNotPresentInHttpContext()
        {
            // Arrange
            using (MemoryStream ignoreStream = new MemoryStream())
            {
                HttpRequestBase stubRequest = CreateStubRequestBase("IgnoreMethod", ignoreStream);
                IDictionary items = new Hashtable();
                HttpContextBase context = CreateStubContextBase(stubRequest, items);

                // Act
                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    // Assert
                    object ignore;
                    bool found = actualRequest.Properties.TryGetValue(HttpControllerHandler.OwinEnvironmentKey,
                        out ignore);
                    Assert.False(found);
                }
            }
        }

        [Fact]
        public void ConvertRequest_DoesNotAddOwinEnvironment_WhenItemsIsNull()
        {
            // Arrange
            using (MemoryStream ignoreStream = new MemoryStream())
            {
                HttpRequestBase stubRequest = CreateStubRequestBase("IgnoreMethod", ignoreStream);
                IDictionary items = null;
                HttpContextBase context = CreateStubContextBase(stubRequest, items);

                // Act
                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    // Assert
                    object ignore;
                    bool found = actualRequest.Properties.TryGetValue(HttpControllerHandler.OwinEnvironmentKey,
                        out ignore);
                    Assert.False(found);
                }
            }
        }

        [Fact]
        public async Task ConvertRequest_DoesLazyGetInputStream()
        {
            bool inputStreamCalled = false;
            HttpRequestBase stubRequest = CreateFakeRequestBase(() =>
            {
                inputStreamCalled = true;
                return new MemoryStream();
            }, buffered: true);
            HttpContextBase context = CreateStubContextBase(request: stubRequest, items: null);

            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context);

            Assert.False(inputStreamCalled);
            var contentStream = await actualRequest.Content.ReadAsStreamAsync();
            Assert.True(inputStreamCalled);
        }

        [Fact]
        public async Task ConvertRequest_UsesRequestInputStream_InClassicMode()
        {
            // Arrange
            string input = "Hello world";
            var stream = new MemoryStream(Encoding.UTF8.GetBytes(input));
            HttpRequestBase fakeRequest = CreateFakeRequestBase(() => stream, buffered: true);
            HttpContextBase context = CreateStubContextBase(request: fakeRequest, items: null);
            Mock<HttpRequestBase> mockRequest = Mock.Get<HttpRequestBase>(fakeRequest);

            // Act
            fakeRequest.InputStream.Position = 10;
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context);
            string result = await actualRequest.Content.ReadAsStringAsync();

            // Assert
            // Verify that the InputStream was reset when reading the content.
            Assert.Equal(input, result);
            mockRequest.Verify(r => r.InputStream, Times.AtLeastOnce());
            mockRequest.Verify(r => r.GetBufferedInputStream(), Times.Never());
        }

        [Fact]
        public async Task ConvertRequest_UsesBufferedInputStream_IfReadEntityBodyModeIsNone()
        {
            // Arrange
            HttpRequestBase stubRequest = CreateFakeRequestBase(() => new MemoryStream(), buffered: true);
            HttpContextBase context = CreateStubContextBase(request: stubRequest, items: null);
            Mock<HttpRequestBase> mockRequest = Mock.Get<HttpRequestBase>(stubRequest);

            // Act
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context);
            await actualRequest.Content.ReadAsStreamAsync();

            // Assert
            mockRequest.Verify(r => r.InputStream, Times.Never());
            mockRequest.Verify(r => r.GetBufferedInputStream(), Times.AtLeastOnce());
        }

        [Fact]
        public Task ConvertRequest_WithBufferedPolicy_ThrowsIfRequestHasBeenPartiallyRead()
        {
            // Arrange
            var stream = new MemoryStream(new byte[16]);
            HttpRequestBase fakeRequest = CreateFakeRequestBase(() => stream, buffered: true);
            HttpContextBase context = CreateStubContextBase(request: fakeRequest, items: null);

            // Act
            fakeRequest.GetBufferedInputStream().Position = 4;
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context);

            // Assert
            return Assert.ThrowsAsync<InvalidOperationException>(() => actualRequest.Content.ReadAsStringAsync());
        }

        [Fact]
        public async Task ConvertRequest_WithBufferedPolicy_ReturnsInputStreamIfBufferedStreamWasFullyRead()
        {
            // Arrange
            string inputStreamMessage = "This is from input stream";
            var bufferedStream = new MemoryStream(new byte[16]);
            var inputStream = new MemoryStream(Encoding.UTF8.GetBytes(inputStreamMessage));
            HttpRequestBase fakeRequest = CreateFakeRequestBase(() => bufferedStream, buffered: true);
            HttpContextBase context = CreateStubContextBase(request: fakeRequest, items: null);
            Mock<HttpRequestBase> mockRequest = Mock.Get<HttpRequestBase>(fakeRequest);
            mockRequest.SetupGet(f => f.InputStream)
                       .Returns(inputStream)
                       .Verifiable();

            // Act
            bufferedStream.Seek(0, SeekOrigin.End);
            new StreamReader(fakeRequest.GetBufferedInputStream()).ReadToEnd();
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context);
            string result = await actualRequest.Content.ReadAsStringAsync();

            // Assert
            Assert.Equal(inputStreamMessage, result);
        }

        [Fact]
        public async Task ConvertRequest_DoesLazyGetBufferlessInputStream_IfRequestStreamHasNotBeenRead()
        {
            // Arrange
            bool inputStreamCalled = false;
            var hostBufferPolicy = new Mock<IHostBufferPolicySelector>();
            hostBufferPolicy.Setup(c => c.UseBufferedInputStream(It.IsAny<object>()))
                                          .Returns(false);
            hostBufferPolicy.Setup(c => c.UseBufferedOutputStream(It.IsAny<HttpResponseMessage>()))
                                          .Returns(true);

            HttpRequestBase stubRequest = CreateFakeRequestBase(() =>
                {
                    inputStreamCalled = true;
                    return new MemoryStream();
                }, buffered: false);
            HttpContextBase context = HttpControllerHandlerTest.CreateStubContextBase(request: stubRequest, items: null);

            // Act
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context, hostBufferPolicy.Object);

            // Assert
            Assert.False(inputStreamCalled);
            Stream contentStream = await actualRequest.Content.ReadAsStreamAsync();
            Assert.True(inputStreamCalled);
        }

        [Fact]
        public Task ConvertRequest_WithBufferlessPolicy_ThrowsIfRequestStreamHasBeenReadInClassicMode()
        {
            // Arrange
            var hostBufferPolicy = new Mock<IHostBufferPolicySelector>();
            hostBufferPolicy.Setup(c => c.UseBufferedInputStream(It.IsAny<object>()))
                                          .Returns(false);
            hostBufferPolicy.Setup(c => c.UseBufferedOutputStream(It.IsAny<HttpResponseMessage>()))
                                          .Returns(true);

            var stream = new MemoryStream(8);
            HttpRequestBase stubRequest = CreateFakeRequestBase(() => stream, buffered: false);
            HttpContextBase context = HttpControllerHandlerTest.CreateStubContextBase(request: stubRequest, items: null);

            // Act
            context.Request.InputStream.Position = 2;
            HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context, hostBufferPolicy.Object);

            // Assert
            return Assert.ThrowsAsync<InvalidOperationException>(() => actualRequest.Content.ReadAsStreamAsync(),
                 "Unable to read the entity body in Bufferless mode. The request stream has already been buffered.");
        }

        [Fact]
        public Task ConvertRequest_WithBufferlessPolicy_ThrowsIfRequestStreamHasBeenReadInBufferedMode()
        {
            // Arrange
            var hostBufferPolicy = new Mock<IHostBufferPolicySelector>();
            hostBufferPolicy.Setup(c => c.UseBufferedInputStream(It.IsAny<object>()))
                                          .Returns(false);
            hostBufferPolicy.Setup(c => c.UseBufferedOutputStream(It.IsAny<HttpResponseMessage>()))
                                          .Returns(true);

            var stream = new MemoryStream(8);
            HttpRequestBase stubRequest = CreateFakeRequestBase(() => stream, buffered: false);
            HttpContextBase context = HttpControllerHandlerTest.CreateStubContextBase(request: stubRequest, items: null);

            // Act
            context.Request.GetBufferedInputStream();
            HttpRequestMessage message = HttpControllerHandler.ConvertRequest(context, hostBufferPolicy.Object);

            // Assert
            return Assert.ThrowsAsync<InvalidOperationException>(() => message.Content.ReadAsStringAsync(),
                 "Unable to read the entity body. The request stream has already been read in 'Buffered' mode.");
        }

        [Fact]
        public Task ConvertRequest_WithBufferlessPolicy_ThrowsIfRequestStreamHasBeenRead()
        {
            // Arrange
            var hostBufferPolicy = new Mock<IHostBufferPolicySelector>();
            hostBufferPolicy.Setup(c => c.UseBufferedInputStream(It.IsAny<object>()))
                                          .Returns(false);
            hostBufferPolicy.Setup(c => c.UseBufferedOutputStream(It.IsAny<HttpResponseMessage>()))
                                          .Returns(true);

            var stream = new MemoryStream(new byte[16]);
            HttpRequestBase stubRequest = CreateFakeRequestBase(() => stream, buffered: false);
            HttpContextBase context = HttpControllerHandlerTest.CreateStubContextBase(request: stubRequest, items: null);

            // Act
            context.Request.GetBufferlessInputStream().Position = 4;
            HttpRequestMessage message = HttpControllerHandler.ConvertRequest(context, hostBufferPolicy.Object);

            // Assert
            return Assert.ThrowsAsync<InvalidOperationException>(() => message.Content.ReadAsStringAsync(),
                 "Unable to read the entity body. A portion of the request stream has already been read.");
        }

        [Fact]
        public void ConvertRequest_AddsWebHostHttpRequestContext()
        {
            // Arrange
            Mock<HttpRequestBase> requestBaseMock = new Mock<HttpRequestBase>(MockBehavior.Strict);
            requestBaseMock.Setup(r => r.HttpMethod).Returns("IGNORED");
            requestBaseMock.Setup(r => r.Url).Returns(new Uri("http://ignore"));
            requestBaseMock.Setup(r => r.Headers).Returns(new NameValueCollection());
            requestBaseMock.Setup(r => r.ReadEntityBodyMode).Returns(ReadEntityBodyMode.None);
            HttpRequestBase requestBase = requestBaseMock.Object;
            Mock<HttpContextBase> contextBaseMock = new Mock<HttpContextBase>(MockBehavior.Strict);
            contextBaseMock.Setup(c => c.Request).Returns(requestBase);
            contextBaseMock.Setup(c => c.Items).Returns((IDictionary)null);
            HttpContextBase contextBase = contextBaseMock.Object;

            // Act
            using (HttpRequestMessage expectedRequest = HttpControllerHandler.ConvertRequest(contextBase))
            {
                // Assert
                HttpRequestContext context = expectedRequest.GetRequestContext();
                WebHostHttpRequestContext typedContext = Assert.IsType<WebHostHttpRequestContext>(context);
                Assert.Same(contextBase, typedContext.Context);
                Assert.Same(requestBase, typedContext.WebRequest);
                Assert.Same(expectedRequest, typedContext.Request);
            }
        }

        [Fact]
        public async Task CopyResponseAsync_IfResponseHasNoCacheControlDefined_SetsNoCacheCacheabilityOnAspNetResponse()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseMessage response = new HttpResponseMessage();

            // Act
            await CopyResponseAsync(contextMock.Object, request, response);

            // Assert
            contextMock.Verify(c => c.Response.Cache.SetCacheability(HttpCacheability.NoCache));
        }

        [Fact]
        public async Task CopyResponseAsync_IfResponseHasCacheControlDefined_DoesNotSetCacheCacheabilityOnAspNetResponse()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseMessage response = new HttpResponseMessage();
            response.Headers.CacheControl = new CacheControlHeaderValue { Public = true };

            // Act
            await CopyResponseAsync(contextMock.Object, request, response);

            // Assert
            contextMock.Verify(c => c.Response.Cache.SetCacheability(HttpCacheability.NoCache), Times.Never());
        }

        [Fact]
        public async Task ProcessRequestAsync_DisposesRequestAndResponse()
        {
            // Arrange
            Mock<HttpResponseBase> responseMock = new Mock<HttpResponseBase>() { DefaultValue = DefaultValue.Mock };
            responseMock.SetupGet(r => r.OutputStream).Returns(Stream.Null);
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            contextMock.SetupGet(hcb => hcb.Response).Returns(responseMock.Object);
            IDictionary items = new Dictionary<object, object>();
            contextMock.SetupGet((hcb) => hcb.Items).Returns(items);
            HttpContextBase context = contextMock.Object;

            HttpRequestMessage request = new HttpRequestMessage();
            context.SetHttpRequestMessage(request);
            SpyDisposable spy = new SpyDisposable();
            request.RegisterForDispose(spy);
            HttpResponseMessage response = new HttpResponseMessage();

            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = (r, c) =>
                Task.FromResult(response);

            using (HttpMessageHandler handler = new LambdaHttpMessageHandler(sendAsync))
            {
                HttpControllerHandler product = new HttpControllerHandler(
                    new Mock<RouteData>(MockBehavior.Strict).Object, handler);

                // Act
                await product.ProcessRequestAsyncCore(context);

                // Assert
                Assert.True(spy.Disposed);
                Assert.ThrowsObjectDisposed(() => request.Method = HttpMethod.Get, typeof(HttpRequestMessage).FullName);
                Assert.ThrowsObjectDisposed(() => response.StatusCode = HttpStatusCode.OK, typeof(HttpResponseMessage).FullName);
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_DisposesRequestAndResponseWithContent()
        {
            // Arrange
            Mock<HttpResponseBase> responseMock = new Mock<HttpResponseBase>() { DefaultValue = DefaultValue.Mock };
            responseMock.SetupGet(r => r.OutputStream).Returns(Stream.Null);
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            contextMock.SetupGet(hcb => hcb.Response).Returns(responseMock.Object);
            IDictionary items = new Dictionary<object, object>();
            contextMock.SetupGet((hcb) => hcb.Items).Returns(items);
            HttpContextBase context = contextMock.Object;

            HttpRequestMessage request = new HttpRequestMessage() { Content = new StringContent("request") };
            context.SetHttpRequestMessage(request);
            SpyDisposable spy = new SpyDisposable();
            request.RegisterForDispose(spy);
            HttpResponseMessage response = new HttpResponseMessage() { Content = new StringContent("response") };

            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = (r, c) =>
                Task.FromResult(response);

            using (HttpMessageHandler handler = new LambdaHttpMessageHandler(sendAsync))
            {
                HttpControllerHandler product = new HttpControllerHandler(
                    new Mock<RouteData>(MockBehavior.Strict).Object, handler);

                // Act
                await product.ProcessRequestAsyncCore(context);

                // Assert
                Assert.True(spy.Disposed);
                Assert.ThrowsObjectDisposed(() => request.Method = HttpMethod.Get, typeof(HttpRequestMessage).FullName);
                Assert.ThrowsObjectDisposed(() => response.StatusCode = HttpStatusCode.OK, typeof(HttpResponseMessage).FullName);
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_IfHandlerFaults_DisposesRequest()
        {
            // Arrange
            Mock<HttpResponseBase> responseMock = new Mock<HttpResponseBase>();
            responseMock.SetupGet(r => r.OutputStream).Returns(Stream.Null);
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            contextMock.SetupGet(hcb => hcb.Response).Returns(responseMock.Object);
            IDictionary items = new Dictionary<object, object>();
            contextMock.SetupGet((hcb) => hcb.Items).Returns(items);
            HttpContextBase context = contextMock.Object;

            HttpRequestMessage request = new HttpRequestMessage();
            context.SetHttpRequestMessage(request);
            SpyDisposable spy = new SpyDisposable();
            request.RegisterForDispose(spy);

            Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync = (r, c) =>
                CreateFaultedTask<HttpResponseMessage>(CreateException());

            using (HttpMessageHandler handler = new LambdaHttpMessageHandler(sendAsync))
            {
                HttpControllerHandler product = new HttpControllerHandler(
                    new Mock<RouteData>(MockBehavior.Strict).Object, handler);

                // Act & Assert
                await Assert.ThrowsAsync<EncoderFallbackException>(() => product.ProcessRequestAsyncCore(context));

                Assert.True(spy.Disposed);
                Assert.ThrowsObjectDisposed(() => request.Method = HttpMethod.Get, typeof(HttpRequestMessage).FullName);
            }
        }

        [Fact]
        public void SuppressFormsAuthenticationRedirect_DoesntRequireSuppressRedirect()
        {
            // Arrange
            Mock<HttpResponseBase> responseMock = new Mock<HttpResponseBase>();
            responseMock.SetupGet(r => r.StatusCode).Returns(200);
            responseMock.SetupSet(r => r.SuppressFormsAuthenticationRedirect = It.IsAny<bool>()).Verifiable();
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            IDictionary contextItems = new Hashtable();
            contextMock.SetupGet(hcb => hcb.Response).Returns(responseMock.Object);
            contextMock.SetupGet(hcb => hcb.Items).Returns(contextItems);

            // Act
            HttpControllerHandler.EnsureSuppressFormsAuthenticationRedirect(contextMock.Object);

            // Assert
            responseMock.VerifySet(r => r.SuppressFormsAuthenticationRedirect = It.IsAny<bool>(), Times.Never);
        }

        [Fact]
        public void SuppressFormsAuthenticationRedirect_RequireSuppressRedirect()
        {
            // Arrange
            bool suppressFormsAuthenticationRedirect = false;
            Mock<HttpResponseBase> responseMock = new Mock<HttpResponseBase>();
            responseMock.SetupGet(r => r.StatusCode).Returns(401);
            responseMock.SetupSet<bool>(r => r.SuppressFormsAuthenticationRedirect = It.IsAny<bool>())
                .Callback(value => suppressFormsAuthenticationRedirect = value)
                .Verifiable();
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            IDictionary contextItems = new Hashtable();
            contextMock.SetupGet(hcb => hcb.Response).Returns(responseMock.Object);
            contextMock.SetupGet(hcb => hcb.Items).Returns(contextItems);

            // Act
            HttpControllerHandler.EnsureSuppressFormsAuthenticationRedirect(contextMock.Object);

            // Assert
            responseMock.VerifySet(r => r.SuppressFormsAuthenticationRedirect = It.IsAny<bool>(), Times.Once);
            Assert.True(suppressFormsAuthenticationRedirect);
        }

        [Fact]
        public async Task CopyResponseAsync_Creates_Correct_HttpResponseBase()
        {
            // Arrange
            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", new JsonMediaTypeFormatter());

            // Act
            await CopyResponseAsync(contextMock.Object, request, response);

            // Assert preparation -- deserialize the response
            memoryStream.Seek(0L, SeekOrigin.Begin);
            string responseString = null;
            using (var streamReader = new StreamReader(memoryStream))
            {
                responseString = streamReader.ReadToEnd();
            }

            // Assert
            Assert.Equal((int)HttpStatusCode.OK, responseBase.StatusCode);
            Assert.StartsWith(JsonMediaTypeFormatter.DefaultMediaType.MediaType, responseBase.Headers["Content-Type"]);
            Assert.Equal("\"hello\"", responseString);
        }

        [Fact]
        public async Task CopyResponseAsync_IfTransferEncodingChunkedAndContentLengthAreBothSet_IgnoresContentLength()
        {
            // Arrange
            HttpResponseBase responseBase = CreateMockHttpResponseBaseForResponse(Stream.Null).Object;
            HttpContextBase contextBase = CreateStubContextBase(responseBase);

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request })
            {
                response.Headers.TransferEncodingChunked = true;
                response.Content = new StringContent("SomeContent");
                Assert.NotNull(response.Content.Headers.ContentLength); // Guard; added by System.Net.Http.

                // Act
                await CopyResponseAsync(contextBase, request, response);

                // Assert
                Assert.DoesNotContain("Content-Length", responseBase.Headers.OfType<string>());
            }
        }

        [Fact]
        public async Task CopyResponseAsync_IfTransferEncodingIsJustChunked_DoesNotCopyHeaderToHost()
        {
            // Arrange
            HttpResponseBase responseBase = CreateMockHttpResponseBaseForResponse(Stream.Null).Object;
            HttpContextBase contextBase = CreateStubContextBase(responseBase);

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request })
            {
                response.Headers.TransferEncodingChunked = true;

                // Act
                await CopyResponseAsync(contextBase, request, response);

                // Assert
                Assert.DoesNotContain("Transfer-Encoding", responseBase.Headers.OfType<string>());
            }
        }

        [Fact]
        public async Task CopyResponseAsync_IfTransferEncodingIsIdentity_CopiesHeaderToHost()
        {
            // Arrange
            HttpResponseBase responseBase = CreateMockHttpResponseBaseForResponse(Stream.Null).Object;
            HttpContextBase contextBase = CreateStubContextBase(responseBase);

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request })
            {
                response.Headers.TransferEncoding.Add(new TransferCodingHeaderValue("identity"));

                // Act
                await CopyResponseAsync(contextBase, request, response);

                // Assert
                Assert.Contains("Transfer-Encoding", responseBase.Headers.OfType<string>());
                Assert.Equal(new string[] { "identity" }, responseBase.Headers.GetValues("Transfer-Encoding"));
            }
        }

        [Fact]
        public async Task CopyResponseAsync_IfTransferEncodingIsIdentityChunked_CopiesHeaderToHost()
        {
            // Arrange
            HttpResponseBase responseBase = CreateMockHttpResponseBaseForResponse(Stream.Null).Object;
            HttpContextBase contextBase = CreateStubContextBase(responseBase);

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request })
            {
                response.Headers.TransferEncoding.Add(new TransferCodingHeaderValue("identity"));
                response.Headers.TransferEncodingChunked = true;
                Assert.Equal("identity, chunked", response.Headers.TransferEncoding.ToString()); // Guard

                // Act
                await CopyResponseAsync(contextBase, request, response);

                // Assert
                Assert.Contains("Transfer-Encoding", responseBase.Headers.OfType<string>());
                Assert.Equal(new string[] { "identity", "chunked" },
                    responseBase.Headers.GetValues("Transfer-Encoding"));
            }
        }

        [Fact]
        public async Task CopyResponseAsync_IfTransferEncodingIsChunked_DisablesResponseBuffering()
        {
            // Arrange
            HttpResponseBase responseBase = CreateMockHttpResponseBaseForResponse(Stream.Null).Object;
            HttpContextBase contextBase = CreateStubContextBase(responseBase);

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request })
            {
                response.Headers.TransferEncodingChunked = true;
                response.Content = new ObjectContent(typeof(string), String.Empty, new JsonMediaTypeFormatter());

                // Act
                await CopyResponseAsync(contextBase, request, response);

                // Assert
                Assert.False(responseBase.BufferOutput);
            }
        }

        [Fact]
        public async Task CopyResponseAsync_IfHandlerIsDefault_Returns_Error_Response_When_Formatter_Write_Task_Faults()
        {
            // Arrange
            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            try
            {
                // to capture stack trace inside this method
                throw new NotSupportedException("Expected error");
            }
            catch (Exception ex)
            {
                tcs.SetException(ex);
            }

            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                          It.IsAny<object>(),
                                                          It.IsAny<Stream>(),
                                                          It.IsAny<HttpContent>(),
                                                          It.IsAny<TransportContext>())).Returns(tcs.Task);

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(GlobalConfiguration.Configuration);

            // Act
            await HttpControllerHandler.CopyResponseAsync(contextMock.Object, request, response, exceptionLogger,
                exceptionHandler, CancellationToken.None);

            // Assert preparation -- deserialize the HttpError response
            HttpError httpError = null;
            memoryStream.Seek(0L, SeekOrigin.Begin);
            using (StreamContent content = new StreamContent(memoryStream))
            {
                content.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;
                httpError = await content.ReadAsAsync<HttpError>();
            }

            // Assert
            Assert.Equal((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
            Assert.StartsWith(JsonMediaTypeFormatter.DefaultMediaType.MediaType, responseBase.Headers["Content-Type"]);
            Assert.Equal("An error has occurred.", httpError["Message"]);
            Assert.Equal("The 'ObjectContent`1' type failed to serialize the response body for content type 'application/json; charset=utf-8'.", httpError["ExceptionMessage"]);
            Assert.Equal(typeof(InvalidOperationException).FullName, httpError["ExceptionType"]);
            Assert.True(httpError.ContainsKey("StackTrace"));

            HttpError innerError = (httpError["InnerException"] as JObject).ToObject<HttpError>();
            Assert.NotNull(innerError);
            Assert.Equal(typeof(NotSupportedException).FullName, innerError["ExceptionType"].ToString());
            Assert.Equal("Expected error", innerError["ExceptionMessage"]);
            Assert.Contains(MethodInfo.GetCurrentMethod().Name, innerError["StackTrace"].ToString());
        }

        [Fact]
        public async Task CopyResponseAsync_IfHandlerIsDefault_Returns_Error_Response_When_Formatter_Write_Throws_Immediately()
        {
            // Arrange
            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                          It.IsAny<object>(),
                                                          It.IsAny<Stream>(),
                                                          It.IsAny<HttpContent>(),
                                                          It.IsAny<TransportContext>())).Throws(new NotSupportedException("Expected error"));

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(GlobalConfiguration.Configuration);

            // Act
            await HttpControllerHandler.CopyResponseAsync(contextMock.Object, request, response, exceptionLogger, exceptionHandler, CancellationToken.None);

            // Assert preparation -- deserialize the HttpError response
            HttpError httpError = null;
            memoryStream.Seek(0L, SeekOrigin.Begin);
            using (StreamContent content = new StreamContent(memoryStream))
            {
                content.Headers.ContentType = JsonMediaTypeFormatter.DefaultMediaType;
                httpError = await content.ReadAsAsync<HttpError>();
            }

            // Assert
            Assert.Equal((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
            Assert.StartsWith(JsonMediaTypeFormatter.DefaultMediaType.MediaType, responseBase.Headers["Content-Type"]);
            Assert.Equal("An error has occurred.", httpError["Message"]);
            Assert.Equal("The 'ObjectContent`1' type failed to serialize the response body for content type 'application/json; charset=utf-8'.", httpError["ExceptionMessage"]);
            Assert.Equal(typeof(InvalidOperationException).FullName, httpError["ExceptionType"]);
            Assert.True(httpError.ContainsKey("StackTrace"));

            HttpError innerError = (httpError["InnerException"] as JObject).ToObject<HttpError>();
            Assert.NotNull(innerError);
            Assert.Equal(typeof(NotSupportedException).FullName, innerError["ExceptionType"].ToString());
            Assert.Equal("Expected error", innerError["ExceptionMessage"]);
            Assert.Contains("System.Net.Http.HttpContent.CopyToAsync", innerError["StackTrace"].ToString());
        }

        [Fact]
        public async Task CopyResponseAsync_Returns_User_Response_When_Formatter_Write_Throws_HttpResponseException_With_No_Content()
        {
            // Arrange
            HttpResponseMessage errorResponse = new HttpResponseMessage(HttpStatusCode.MethodNotAllowed);
            errorResponse.Headers.Add("myHeader", "myValue");

            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                          It.IsAny<object>(),
                                                          It.IsAny<Stream>(),
                                                          It.IsAny<HttpContent>(),
                                                          It.IsAny<TransportContext>())).Throws(new HttpResponseException(errorResponse));

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);

            // Act
            await CopyResponseAsync(contextMock.Object, request, response);
            memoryStream.Seek(0L, SeekOrigin.Begin);

            // Assert
            Assert.Equal((int)errorResponse.StatusCode, responseBase.StatusCode);
            Assert.Equal(0, memoryStream.Length);
            Assert.Equal("myValue", responseBase.Headers["myHeader"]);
            Assert.Null(responseBase.Headers["Content-Type"]);
        }

        [Fact]
        public async Task CopyResponseAsync_Returns_User_Response_When_Formatter_Write_Throws_HttpResponseException_With_Content()
        {
            // Arrange
            HttpResponseMessage errorResponse = new HttpResponseMessage(HttpStatusCode.MethodNotAllowed);
            errorResponse.Headers.Add("myHeader", "myValue");
            errorResponse.Content = new StringContent("user message", Encoding.UTF8, "application/fake");

            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                          It.IsAny<object>(),
                                                          It.IsAny<Stream>(),
                                                          It.IsAny<HttpContent>(),
                                                          It.IsAny<TransportContext>())).Throws(new HttpResponseException(errorResponse));

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);

            // Act
            await CopyResponseAsync(contextMock.Object, request, response);

            // Assert preparation -- deserialize the response

            memoryStream.Seek(0L, SeekOrigin.Begin);
            string responseContent = null;
            using (var streamReader = new StreamReader(memoryStream))
            {
                responseContent = streamReader.ReadToEnd();
            }

            // Assert
            Assert.Equal((int)errorResponse.StatusCode, responseBase.StatusCode);
            Assert.StartsWith("application/fake", responseBase.Headers["Content-Type"]);
            Assert.Equal("user message", responseContent);
            Assert.Equal("myValue", responseBase.Headers["myHeader"]);
        }

        [Fact]
        public async Task CopyResponseAsync_Returns_InternalServerError_And_No_Content_When_Formatter_Write_Task_Faults_During_Error_Response()
        {
            // Arrange
            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.SetException(new NotSupportedException("Expected error"));

            // This formatter throws on any write attempt
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                            It.IsAny<object>(),
                                                            It.IsAny<Stream>(),
                                                            It.IsAny<HttpContent>(),
                                                            It.IsAny<TransportContext>())).Returns(tcs.Task);

            // Create a local config to hook to the request to condition
            // the formatter selection for the error response
            HttpConfiguration config = new HttpConfiguration();
            config.Formatters.Clear();
            config.Formatters.Add(formatterMock.Object);

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            request.SetConfiguration(config);
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(GlobalConfiguration.Configuration);

            // Act
            await HttpControllerHandler.CopyResponseAsync(contextMock.Object, request, response, exceptionLogger,
                exceptionHandler, CancellationToken.None);

            // Assert
            Assert.Equal((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
            Assert.Equal(0, memoryStream.Length);
            Assert.Null(responseBase.Headers["Content-Type"]);
        }

        [Fact]
        public async Task CopyResponseAsync_Returns_InternalServerError_And_No_Content_When_Formatter_Write_Throws_Immediately_During_Error_Response()
        {
            // Arrange
            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };

            // This formatter throws on any write attempt
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                            It.IsAny<object>(),
                                                            It.IsAny<Stream>(),
                                                            It.IsAny<HttpContent>(),
                                                            It.IsAny<TransportContext>())).Throws(new NotSupportedException("Expected error"));

            // Create a local config to hook to the request to condition
            // the formatter selection for the error response
            HttpConfiguration config = new HttpConfiguration();
            config.Formatters.Clear();
            config.Formatters.Add(formatterMock.Object);

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            request.SetConfiguration(config);
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(GlobalConfiguration.Configuration);

            // Act
            await HttpControllerHandler.CopyResponseAsync(contextMock.Object, request, response, exceptionLogger,
                exceptionHandler, CancellationToken.None);

            // Assert
            Assert.Equal((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
            Assert.Equal(0, memoryStream.Length);
            Assert.Null(responseBase.Headers["Content-Type"]);
        }

        [Fact]
        public async Task CopyResponseAsync_Returns_InternalServerError_And_No_Content_When_Content_Negotiation_Cannot_Find_Formatter_For_Error_Response()
        {
            // Create a content negotiator that works attempting a normal response but fails when creating the error response.
            Mock<IContentNegotiator> negotiatorMock = new Mock<IContentNegotiator>() { CallBase = true };
            negotiatorMock.Setup(m => m.Negotiate(It.IsAny<Type>(), It.IsAny<HttpRequestMessage>(), It.IsAny<IEnumerable<MediaTypeFormatter>>()))
                .Returns((Type t, HttpRequestMessage r, IEnumerable<MediaTypeFormatter> f) =>
                    {
                        ContentNegotiationResult result = t == typeof(HttpError)
                            ? null
                            : new ContentNegotiationResult(f.First(), JsonMediaTypeFormatter.DefaultMediaType);
                        return result;
                    });

            // Arrange
            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };

            // This formatter throws on any write attempt
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                            It.IsAny<object>(),
                                                            It.IsAny<Stream>(),
                                                            It.IsAny<HttpContent>(),
                                                            It.IsAny<TransportContext>())).Throws(new NotSupportedException("Expected error"));

            // Create a local config to hook to the request to condition
            // the formatter selection for the error response
            HttpConfiguration config = new HttpConfiguration();
            config.Formatters.Clear();
            config.Formatters.Add(formatterMock.Object);
            config.Services.Replace(typeof(IContentNegotiator), negotiatorMock.Object);

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            request.SetConfiguration(config);
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(GlobalConfiguration.Configuration);

            // Act
            await HttpControllerHandler.CopyResponseAsync(contextMock.Object, request, response, exceptionLogger,
                exceptionHandler, CancellationToken.None);

            // Assert
            Assert.Equal((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
            Assert.Equal(0, memoryStream.Length);
            Assert.Null(responseBase.Headers["Content-Type"]);
        }

        [Fact]
        public async Task CopyResponseAsync_Returns_InternalServerError_And_No_Content_When_No_Content_Negotiator_For_Error_Response()
        {
            // Arrange
            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };

            // This formatter throws on any write attempt
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                            It.IsAny<object>(),
                                                            It.IsAny<Stream>(),
                                                            It.IsAny<HttpContent>(),
                                                            It.IsAny<TransportContext>())).Throws(new NotSupportedException("Expected error"));

            // Create a local config to hook to the request to condition
            // the formatter selection for the error response
            HttpConfiguration config = new HttpConfiguration();
            config.Formatters.Clear();
            config.Formatters.Add(formatterMock.Object);
            config.Services.Replace(typeof(IContentNegotiator), null /*negotiatorMock.Object*/);

            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            request.SetConfiguration(config);
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            IExceptionHandler exceptionHandler = ExceptionServices.GetHandler(GlobalConfiguration.Configuration);

            // Act
            await HttpControllerHandler.CopyResponseAsync(contextMock.Object, request, response, exceptionLogger,
                exceptionHandler, CancellationToken.None);

            // Assert
            Assert.Equal((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
            Assert.Equal(0, memoryStream.Length);
            Assert.Null(responseBase.Headers["Content-Type"]);
        }

        [Fact]
        public async Task CopyResponseAsync_Returns_InternalServerError_And_No_Content_For_Null_HttpResponseMessage()
        {
            // Arrange
            MemoryStream memoryStream = new MemoryStream();
            Mock<HttpContextBase> contextMock = CreateMockHttpContextBaseForResponse(memoryStream);
            HttpResponseBase responseBase = contextMock.Object.Response;
            HttpRequestMessage request = new HttpRequestMessage();

            // Act
            await CopyResponseAsync(contextMock.Object, request: new HttpRequestMessage(), response: null);

            // Assert
            Assert.Equal((int)HttpStatusCode.InternalServerError, responseBase.StatusCode);
            Assert.Equal(0, memoryStream.Length);
            Assert.Null(responseBase.Headers["Content-Type"]);
        }

        [Fact]
        public async Task WriteStreamedResponseContentAsync_Aborts_When_Formatter_Write_Throws_Immediately()
        {
            // Arrange
            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                          It.IsAny<object>(),
                                                          It.IsAny<Stream>(),
                                                          It.IsAny<HttpContent>(),
                                                          It.IsAny<TransportContext>())).Throws(new NotSupportedException("Expected error"));

            MemoryStream memoryStream = new MemoryStream();

            Mock<HttpRequestBase> requestBaseMock = new Mock<HttpRequestBase>();
            requestBaseMock.Setup(m => m.Abort()).Verifiable();
            HttpRequestBase requestBase = requestBaseMock.Object;
            HttpResponseBase responseBase = CreateMockHttpResponseBaseForResponse(memoryStream).Object;
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            contextMock.SetupGet(m => m.Response).Returns(responseBase);
            HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);

            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);

            // Act
            await WriteStreamedResponseContentAsync(contextBase, request, response);

            // Assert
            requestBaseMock.Verify();
        }

        [Fact]
        public async Task WriteStreamedResponseContentAsync_Aborts_When_Formatter_Write_Faults()
        {
            // Arrange
            TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
            tcs.TrySetException(new NotSupportedException("Expected error"));

            Mock<JsonMediaTypeFormatter> formatterMock = new Mock<JsonMediaTypeFormatter>() { CallBase = true };
            formatterMock.Setup(m => m.WriteToStreamAsync(It.IsAny<Type>(),
                                                          It.IsAny<object>(),
                                                          It.IsAny<Stream>(),
                                                          It.IsAny<HttpContent>(),
                                                          It.IsAny<TransportContext>())).Returns(tcs.Task);

            MemoryStream memoryStream = new MemoryStream();

            Mock<HttpRequestBase> requestBaseMock = new Mock<HttpRequestBase>();
            requestBaseMock.Setup(m => m.Abort()).Verifiable();
            HttpRequestBase requestBase = requestBaseMock.Object;
            HttpResponseBase responseBase = CreateMockHttpResponseBaseForResponse(memoryStream).Object;
            HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);

            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            HttpResponseMessage response = new HttpResponseMessage() { RequestMessage = request };
            response.Content = new ObjectContent<string>("hello", formatterMock.Object);

            // Act
            await WriteStreamedResponseContentAsync(contextBase, request, response);

            // Assert
            requestBaseMock.Verify();
        }

        [Fact]
        public async Task WriteStreamedResponseContentAsync_IfCopyToAsyncThrows_CallsExceptionLogger()
        {
            // Arrange
            Exception expectedException = CreateException();

            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            IExceptionLogger logger = mock.Object;

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            using (CancellationTokenSource tokenSource = new CancellationTokenSource())
            {
                expectedResponse.Content = CreateFaultingContent(expectedException);

                HttpRequestBase requestBase = CreateStubRequestBase();
                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                await HttpControllerHandler.WriteStreamedResponseContentAsync(contextBase, expectedRequest,
                    expectedResponse, logger, expectedCancellationToken);

                // Assert
                mock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerStreamContent
                    && c.ExceptionContext.Request == expectedRequest
                    && c.ExceptionContext.Response == expectedResponse
                    ), expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task WriteStreamedResponseContentAsync_IfCopyToAsyncCancells_DoesNotCallExceptionLogger()
        {
            // Arrange
            Exception expectedException = new OperationCanceledException();

            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            IExceptionLogger logger = mock.Object;

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            using (CancellationTokenSource tokenSource = new CancellationTokenSource())
            {
                expectedResponse.Content = CreateFaultingContent(expectedException);

                HttpRequestBase requestBase = CreateStubRequestBase();
                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act & Assert
                await Assert.ThrowsAsync<OperationCanceledException>(
                    () => HttpControllerHandler.WriteStreamedResponseContentAsync(
                        contextBase,
                        expectedRequest,
                        expectedResponse,
                        logger,
                        expectedCancellationToken));
            }
        }

        [Fact]
        public async Task WriteBufferedResponseContentAsync_IfCopyToAsyncThrows_CallsExceptionServices()
        {
            // Arrange
            Exception expectedException = CreateException();

            Mock<IExceptionLogger> loggerMock = CreateStubExceptionLoggerMock();
            IExceptionLogger logger = loggerMock.Object;
            Mock<IExceptionHandler> handlerMock = CreateStubExceptionHandlerMock();
            IExceptionHandler handler = handlerMock.Object;

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            using (CancellationTokenSource tokenSource = new CancellationTokenSource())
            {
                expectedResponse.Content = CreateFaultingContent(expectedException);

                HttpRequestBase requestBase = CreateStubRequestBase();
                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act & Assert
                await Assert.ThrowsAsync<EncoderFallbackException>(
                    () => HttpControllerHandler.WriteBufferedResponseContentAsync(
                        contextBase,
                        expectedRequest,
                        expectedResponse,
                        logger,
                        handler,
                        expectedCancellationToken));

                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent
                    && c.Request == expectedRequest
                    && c.Response == expectedResponse;

                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    exceptionContextMatches(c.ExceptionContext)), expectedCancellationToken), Times.Once());
                handlerMock.Verify(l => l.HandleAsync(It.Is<ExceptionHandlerContext>(c =>
                    exceptionContextMatches(c.ExceptionContext)), expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task WriteBufferedResponseContentAsync_IfCopyToAsyncCancels_DoesNotCallExceptionServices()
        {
            // Arrange
            Exception expectedException = new OperationCanceledException();

            Mock<IExceptionLogger> loggerMock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            IExceptionLogger logger = loggerMock.Object;
            Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            IExceptionHandler handler = handlerMock.Object;

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            using (CancellationTokenSource tokenSource = new CancellationTokenSource())
            {
                expectedResponse.Content = CreateFaultingContent(expectedException);

                HttpRequestBase requestBase = CreateStubRequestBase();
                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act & Assert
                await Assert.ThrowsAsync<OperationCanceledException>(
                    () => HttpControllerHandler.WriteBufferedResponseContentAsync(
                        contextBase,
                        expectedRequest,
                        expectedResponse,
                        logger,
                        handler,
                        expectedCancellationToken));
            }
        }

        [Fact]
        public async Task WriteBufferedResponseContentAsync_IfCopyToAsyncThrowsAndHandlerHandles_ReturnsCompletedTask()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = HttpStatusCode.ExpectationFailed;

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage())
            {
                IExceptionLogger logger = CreateStubExceptionLogger();
                Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                handlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                    {
                        c.Result = new StatusCodeResult(expectedStatusCode, request);
                        return Task.FromResult(0);
                    });
                IExceptionHandler handler = handlerMock.Object;

                response.Content = CreateFaultingContent(CreateException());

                int statusCode = 0;
                HttpRequestBase requestBase = CreateStubRequestBase();
                Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>();
                responseBaseMock.Setup(r => r.OutputStream).Returns(Stream.Null);
                responseBaseMock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((c) => statusCode = c);
                HttpResponseBase responseBase = responseBaseMock.Object;
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = CancellationToken.None;

                // Act
                await HttpControllerHandler.WriteBufferedResponseContentAsync(contextBase, request,
                    response, logger, handler, expectedCancellationToken);

                // Assert
                Assert.Equal((int)expectedStatusCode, statusCode);
            }
        }

        [Fact]
        public async Task WriteBufferedResponseContentAsync_IfCopyToAsyncThrowsAndHandlerDoesNotHandle_PropagatesFault()
        {
            // Arrange
            Exception expectedException = CreateExceptionWithCallStack();
            string expectedStackTrace = expectedException.StackTrace;

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage())
            {
                IExceptionLogger logger = CreateStubExceptionLogger();
                IExceptionHandler handler = CreateStubExceptionHandler();

                response.Content = CreateFaultingContent(expectedException);

                HttpRequestBase requestBase = CreateStubRequestBase();
                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = CancellationToken.None;

                // Act & Assert
                var exception = await Assert.ThrowsAsync<EncoderFallbackException>(
                    () => HttpControllerHandler.WriteBufferedResponseContentAsync(
                        contextBase,
                        request,
                        response,
                        logger,
                        handler,
                        expectedCancellationToken));

                Assert.Same(expectedException, exception);
                Assert.NotNull(exception.StackTrace);
                Assert.StartsWith(expectedStackTrace, exception.StackTrace);
            }
        }

        [Fact]
        public async Task WriteBufferedResponseContentAsync_IfCopyToAsyncOnErrorResponseThrows_CallsExceptionLogger()
        {
            // Arrange
            Exception expectedOriginalException = CreateException();
            Exception expectedErrorException = CreateException();

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedOriginalResponse = new HttpResponseMessage())
            using (HttpResponseMessage expectedErrorResponse = new HttpResponseMessage())
            using (CancellationTokenSource tokenSource = new CancellationTokenSource())
            {
                expectedOriginalResponse.Content = CreateFaultingContent(expectedOriginalException);
                expectedErrorResponse.Content = CreateFaultingContent(expectedErrorException);

                Mock<IExceptionLogger> loggerMock = CreateStubExceptionLoggerMock();
                IExceptionLogger logger = loggerMock.Object;
                Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                handlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                    {
                        c.Result = new ResponseMessageResult(expectedErrorResponse);
                        return Task.FromResult(0);
                    });
                IExceptionHandler handler = handlerMock.Object;

                HttpRequestBase requestBase = CreateStubRequestBase();
                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                await HttpControllerHandler.WriteBufferedResponseContentAsync(contextBase, expectedRequest,
                    expectedOriginalResponse, logger, handler, expectedCancellationToken);

                // Assert
                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedOriginalException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent
                    && c.ExceptionContext.Request == expectedRequest
                    && c.ExceptionContext.Response == expectedOriginalResponse),
                    expectedCancellationToken), Times.Once());
                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedErrorException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerBufferError
                    && c.ExceptionContext.Request == expectedRequest
                    && c.ExceptionContext.Response == expectedErrorResponse),
                    expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task WriteBufferedResponseContentAsync_IfCopyToAsyncOnErrorResponseCancels_DoesNotCallCallsExceptionLogger()
        {
            // Arrange
            Exception expectedOriginalException = CreateException();
            Exception expectedErrorException = new OperationCanceledException();

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedOriginalResponse = new HttpResponseMessage())
            using (HttpResponseMessage expectedErrorResponse = new HttpResponseMessage())
            using (CancellationTokenSource tokenSource = new CancellationTokenSource())
            {
                expectedOriginalResponse.Content = CreateFaultingContent(expectedOriginalException);
                expectedErrorResponse.Content = CreateFaultingContent(expectedErrorException);

                Mock<IExceptionLogger> loggerMock = CreateStubExceptionLoggerMock();
                IExceptionLogger logger = loggerMock.Object;
                Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                handlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                    {
                        c.Result = new ResponseMessageResult(expectedErrorResponse);
                        return Task.FromResult(0);
                    });
                IExceptionHandler handler = handlerMock.Object;

                HttpRequestBase requestBase = CreateStubRequestBase();
                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(requestBase, responseBase);
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act & Assert
                await Assert.ThrowsAsync<OperationCanceledException>(
                    () => HttpControllerHandler.WriteBufferedResponseContentAsync(
                        contextBase,
                        expectedRequest,
                        expectedOriginalResponse,
                        logger,
                        handler,
                        expectedCancellationToken));

                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedOriginalException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent
                    && c.ExceptionContext.Request == expectedRequest
                    && c.ExceptionContext.Response == expectedOriginalResponse),
                    expectedCancellationToken), Times.Once());
                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedErrorException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerBufferError
                    && c.ExceptionContext.Request == expectedRequest
                    && c.ExceptionContext.Response == expectedErrorResponse),
                    expectedCancellationToken), Times.Never());
            }
        }

        [Fact]
        public async Task PrepareHeadersAsync_IfTryComputeLengthThrows_CallsExceptionLogger()
        {
            // Arrange
            HttpResponseBase responseBase = CreateStubResponseBase();
            Exception expectedException = CreateException();

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            using (HttpResponseMessage expectedResponse = new HttpResponseMessage())
            using (CancellationTokenSource tokenSource = new CancellationTokenSource())
            {
                expectedResponse.Content = CreateThrowingContent(expectedException);

                Mock<IExceptionLogger> loggerMock = CreateStubExceptionLoggerMock();
                IExceptionLogger logger = loggerMock.Object;

                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                await HttpControllerHandler.PrepareHeadersAsync(responseBase, expectedRequest, expectedResponse,
                    logger, expectedCancellationToken);

                // Assert
                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerComputeContentLength
                    && c.ExceptionContext.Request == expectedRequest
                    && c.ExceptionContext.Response == expectedResponse),
                    expectedCancellationToken), Times.Once());
            }
        }

        [Fact]
        public async Task PrepareHeadersAsync_IfTryComputeLengthThrows_SetsEmptyErrorResponseAndReturnsFalse()
        {
            // Arrange
            Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>(MockBehavior.Strict);
            responseBaseMock.Setup(r => r.Clear());
            responseBaseMock.Setup(r => r.ClearHeaders());
            int statusCode = 0;
            responseBaseMock.SetupSet((r) => r.StatusCode = It.IsAny<int>()).Callback<int>((s) => statusCode = s);
            bool suppressContent = false;
            responseBaseMock.SetupSet((r) => r.SuppressContent = It.IsAny<bool>()).Callback<bool>((s) => suppressContent = s);
            HttpResponseBase responseBase = responseBaseMock.Object;

            using (HttpRequestMessage request = new HttpRequestMessage())
            using (HttpResponseMessage response = new HttpResponseMessage())
            {
                response.Content = CreateThrowingContent(CreateException());
                IExceptionLogger logger = CreateStubExceptionLogger();
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                bool result = await HttpControllerHandler.PrepareHeadersAsync(responseBase, request, response, logger,
                    cancellationToken);

                // Assert
                responseBaseMock.Verify(r => r.Clear(), Times.Once());
                responseBaseMock.Verify(r => r.ClearHeaders(), Times.Once());
                Assert.Equal(500, statusCode);
                Assert.True(suppressContent);
                Assert.False(result);
            }
        }

        [Fact]
        public async Task GetBufferedStream_ReadAsString_GetsSeekableInputStream()
        {
            // Arrange
            using (MemoryStream nonSeekable = new MemoryStream())
            using (MemoryStream seekable = new MemoryStream())
            {
                var request = CreateStubRequestBaseMock("IgnoreMethod", nonSeekable, seekable);
                var context = CreateStubContextBase(request.Object);

                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    // Guard
                    request.Verify(r => r.GetBufferedInputStream(), Times.Never());
                    request.Verify(r => r.InputStream, Times.Never());

                    // Act
                    var content = await actualRequest.Content.ReadAsStringAsync();

                    // Assert
                    request.Verify(r => r.GetBufferedInputStream(), Times.Once());
                    request.Verify(r => r.InputStream, Times.Once());
                }
            }
        }

        [Fact]
        public async Task GetBufferedStream_ReadAsStream_DoesNotGetSeekableInputStream()
        {
            // Arrange
            using (MemoryStream nonSeekable = new MemoryStream())
            using (MemoryStream seekable = new MemoryStream())
            {
                var request = CreateStubRequestBaseMock("IgnoreMethod", nonSeekable, seekable);
                var context = CreateStubContextBase(request.Object);

                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    // Guard
                    request.Verify(r => r.GetBufferedInputStream(), Times.Never());
                    request.Verify(r => r.InputStream, Times.Never());

                    // Act
                    var stream = await actualRequest.Content.ReadAsStreamAsync();

                    // Assert
                    request.Verify(r => r.GetBufferedInputStream(), Times.Once());
                    request.Verify(r => r.InputStream, Times.Never());
                }
            }
        }

        [Fact]
        public async Task GetBufferedStream_ReadAsStream_ThenSeek_GetsSeekableInputStream()
        {
            // Arrange
            string content = "Hello, World!";
            using (MemoryStream nonSeekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            using (MemoryStream seekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            {
                var request = CreateStubRequestBaseMock("IgnoreMethod", nonSeekable, seekable);
                var context = CreateStubContextBase(request.Object);

                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    var stream = await actualRequest.Content.ReadAsStreamAsync();

                    // Guard
                    request.Verify(r => r.GetBufferedInputStream(), Times.Once());
                    request.Verify(r => r.InputStream, Times.Never());

                    // Act
                    stream.Seek(1L, SeekOrigin.Begin);

                    // Assert
                    request.Verify(r => r.GetBufferedInputStream(), Times.Once());
                    request.Verify(r => r.InputStream, Times.Once());
                }
            }
        }

        [Fact]
        public async Task GetBufferedStream_EndToEnd_ReadContentTwice()
        {
            // Arrange
            string content = "Hello, World!";
            using (MemoryStream nonSeekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            using (MemoryStream seekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            {
                var request = CreateStubRequestBaseMock("IgnoreMethod", nonSeekable, seekable);
                var context = CreateStubContextBase(request.Object);

                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    // Act
                    var actual1 = await actualRequest.Content.ReadAsStringAsync();
                    var actual2 = await actualRequest.Content.ReadAsStringAsync();

                    // Assert
                    Assert.Equal(content, actual1);
                    Assert.Equal(content, actual2);
                }
            }
        }

        [Fact]
        public async Task GetBufferedStream_EndToEnd_ReadContentThenSeekThenRead()
        {
            // Arrange
            string content = "Hello, World!";
            using (MemoryStream nonSeekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            using (MemoryStream seekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            {
                var request = CreateStubRequestBaseMock("IgnoreMethod", nonSeekable, seekable);
                var context = CreateStubContextBase(request.Object);

                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    // Act
                    var actual1 = await actualRequest.Content.ReadAsStringAsync();

                    var stream = await actualRequest.Content.ReadAsStreamAsync();
                    stream.Seek(0, SeekOrigin.Begin);

                    string actual2;
                    using (var reader = new StreamReader(stream))
                    {
                        actual2 = await reader.ReadToEndAsync();
                    }

                    // Assert
                    Assert.Equal(content, actual1);
                    Assert.Equal(content, actual2);
                }
            }
        }

        [Fact]
        public async Task GetBufferedStream_EndToEnd_SeekThenRead()
        {
            // Arrange
            string content = "Hello, World!";
            using (MemoryStream nonSeekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            using (MemoryStream seekable = new MemoryStream(Encoding.UTF8.GetBytes(content)))
            {
                var request = CreateStubRequestBaseMock("IgnoreMethod", nonSeekable, seekable);
                var context = CreateStubContextBase(request.Object);

                using (HttpRequestMessage actualRequest = HttpControllerHandler.ConvertRequest(context))
                {
                    // Act
                    var stream = await actualRequest.Content.ReadAsStreamAsync();
                    stream.Seek(1L, SeekOrigin.Begin);
                    stream.Seek(0L, SeekOrigin.Begin);

                    var actual = await actualRequest.Content.ReadAsStringAsync();

                    // Assert
                    Assert.Equal(content, actual);
                }
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_Cancels_AbortsRequest()
        {
            // Arrange
            var request = CreateStubRequestBaseMock("Ignore", new MemoryStream(), new MemoryStream());
            request.Setup(r => r.Abort()).Verifiable();

            var context = CreateStubContextBase(request.Object);

            var messageHandler = new LambdaHttpMessageHandler((r, ct) => { throw new OperationCanceledException(); });

            var handler = new HttpControllerHandler(new RouteData(), messageHandler);

            // Act
            await handler.ProcessRequestAsyncCore(context);

            // Assert
            request.Verify(r => r.Abort(), Times.Once());
        }

        private static Task CopyResponseAsync(HttpContextBase contextBase, HttpRequestMessage request, HttpResponseMessage response)
        {
            IExceptionLogger exceptionLogger = CreateDummyExceptionLogger();
            IExceptionHandler exceptionHandler = CreateDummyExceptionHandler();
            CancellationToken cancellationToken = CancellationToken.None;

            return HttpControllerHandler.CopyResponseAsync(contextBase, request, response, exceptionLogger,
                exceptionHandler, cancellationToken);
        }

        private static IExceptionHandler CreateDummyExceptionHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyExceptionLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static Exception CreateException()
        {
            return new EncoderFallbackException();
        }

        private static Exception CreateExceptionWithCallStack()
        {
            try
            {
                throw CreateException();
            }
            catch (Exception exception)
            {
                return exception;
            }
        }

        private static Task<T> CreateFaultedTask<T>(Exception exception)
        {
            TaskCompletionSource<T> source = new TaskCompletionSource<T>();
            source.SetException(exception);
            return source.Task;
        }

        private static HttpContent CreateFaultingContent(Exception exception)
        {
            return new FaultingHttpContent(exception);
        }

        private static HttpContextBase CreateStubContextBase(string httpMethod, Stream bufferedStream)
        {
            HttpRequestBase request = CreateStubRequestBase(httpMethod, bufferedStream);
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            contextMock.SetupGet(m => m.Request).Returns(request);
            return contextMock.Object;
        }

        internal static HttpContextBase CreateStubContextBase(HttpRequestBase request)
        {
            return CreateStubContextBase(request, new Hashtable());
        }

        internal static HttpContextBase CreateStubContextBase(HttpRequestBase request, IDictionary items)
        {
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            contextMock.SetupGet(m => m.Request).Returns(request);
            contextMock.SetupGet(m => m.Items).Returns(items);
            return contextMock.Object;
        }

        private static HttpContextBase CreateStubContextBase(HttpRequestBase request, HttpResponseBase response)
        {
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.SetupGet(m => m.Request).Returns(request);
            contextMock.SetupGet(m => m.Response).Returns(response);
            return contextMock.Object;
        }

        private static HttpContextBase CreateStubContextBase(HttpResponseBase response)
        {
            Mock<HttpContextBase> mock = new Mock<HttpContextBase>(MockBehavior.Strict);
            mock.SetupGet(m => m.Response).Returns(response);
            return mock.Object;
        }

        private static IExceptionHandler CreateStubExceptionHandler()
        {
            return CreateStubExceptionHandlerMock().Object;
        }

        private static Mock<IExceptionHandler> CreateStubExceptionHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static IExceptionLogger CreateStubExceptionLogger()
        {
            return CreateStubExceptionLoggerMock().Object;
        }

        private static Mock<IExceptionLogger> CreateStubExceptionLoggerMock()
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static HttpRequestBase CreateStubRequestBase()
        {
            return new Mock<HttpRequestBase>().Object;
        }

        private static HttpRequestBase CreateStubRequestBase(string httpMethod, Stream bufferedStream)
        {
            return CreateStubRequestBaseMock(httpMethod, bufferedStream, bufferedStream).Object;
        }

        private static Mock<HttpRequestBase> CreateStubRequestBaseMock(string httpMethod, Stream nonSeekableStream, Stream seekableStream)
        {
            Mock<HttpRequestBase> requestBaseMock = new Mock<HttpRequestBase>() { CallBase = true };
            requestBaseMock.SetupGet(m => m.HttpMethod).Returns(httpMethod);
            requestBaseMock.SetupGet(m => m.Url).Returns(new Uri("Http://localhost"));
            requestBaseMock.SetupGet(m => m.Headers).Returns(new NameValueCollection());
            requestBaseMock.SetupGet(m => m.ReadEntityBodyMode).Returns(ReadEntityBodyMode.None);

            requestBaseMock.Setup(m => m.GetBufferedInputStream()).Returns(nonSeekableStream).Verifiable();
            requestBaseMock.SetupGet(m => m.InputStream).Returns(seekableStream).Verifiable();

            requestBaseMock.Setup(m => m.GetBufferlessInputStream()).Throws<InvalidOperationException>();

            return requestBaseMock;
        }

        internal static HttpRequestBase CreateFakeRequestBase(Func<Stream> getStream, bool buffered)
        {
            var readEntityBodyMode = ReadEntityBodyMode.None;
            Mock<HttpRequestBase> requestBaseMock = new Mock<HttpRequestBase>() { CallBase = true };
            requestBaseMock.SetupGet(m => m.HttpMethod).Returns("GET");
            requestBaseMock.SetupGet(m => m.Url).Returns(new Uri("Http://localhost"));
            requestBaseMock.SetupGet(m => m.Headers).Returns(new NameValueCollection());
            requestBaseMock.Setup(r => r.ReadEntityBodyMode).Returns(() => readEntityBodyMode);

            requestBaseMock.Setup(m => m.GetBufferedInputStream()).Returns(() =>
            {
                if (readEntityBodyMode == ReadEntityBodyMode.None || readEntityBodyMode == ReadEntityBodyMode.Buffered)
                {
                    readEntityBodyMode = ReadEntityBodyMode.Buffered;
                    return getStream();
                }
                throw new InvalidOperationException();
            });

            requestBaseMock.SetupGet(m => m.InputStream).Returns(() =>
            {
                if (readEntityBodyMode == ReadEntityBodyMode.None || readEntityBodyMode == ReadEntityBodyMode.Classic)
                {
                    readEntityBodyMode = ReadEntityBodyMode.Classic;
                    return getStream();
                }
                else if (readEntityBodyMode == ReadEntityBodyMode.Buffered)
                {
                    Stream stream = getStream();
                    if (stream.Position == stream.Length)
                    {
                        return stream;
                    }
                }
                throw new InvalidOperationException();
            });

            requestBaseMock.Setup(m => m.GetBufferlessInputStream()).Returns(() =>
            {
                if (readEntityBodyMode == ReadEntityBodyMode.None || readEntityBodyMode == ReadEntityBodyMode.Bufferless)
                {
                    readEntityBodyMode = ReadEntityBodyMode.Bufferless;
                    return getStream();
                }
                throw new InvalidOperationException();
            });
            return requestBaseMock.Object;
        }

        private static HttpResponseBase CreateStubResponseBase()
        {
            return new Mock<HttpResponseBase>().Object;
        }

        private static HttpResponseBase CreateStubResponseBase(Stream outputStream)
        {
            Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>();
            responseBaseMock.Setup(r => r.OutputStream).Returns(outputStream);
            return responseBaseMock.Object;
        }

        private static Mock<HttpResponseBase> CreateMockHttpResponseBaseForResponse(Stream outputStream)
        {
            NameValueCollection testHeaders = new NameValueCollection();

            Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>() { DefaultValue = DefaultValue.Mock };
            responseBaseMock.Setup(m => m.OutputStream).Returns(outputStream);
            responseBaseMock.Setup(m => m.Headers).Returns(testHeaders);
            responseBaseMock.Setup(m => m.AppendHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((s, v) => testHeaders.Add(s, v));
            responseBaseMock.Setup(m => m.ClearHeaders()).Callback(() => testHeaders.Clear());
            responseBaseMock.Setup(m => m.Clear()).Callback(() => testHeaders.Clear());
            responseBaseMock.SetupProperty(m => m.StatusCode);
            responseBaseMock.SetupProperty(m => m.BufferOutput);

            return responseBaseMock;
        }

        private static Mock<HttpContextBase> CreateMockHttpContextBaseForResponse(Stream outputStream)
        {
            NameValueCollection testHeaders = new NameValueCollection();

            Mock<HttpResponseBase> responseBaseMock = CreateMockHttpResponseBaseForResponse(outputStream);
            HttpResponseBase responseBase = responseBaseMock.Object;
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>() { DefaultValue = DefaultValue.Mock };
            contextMock.SetupGet(m => m.Response).Returns(responseBase);

            return contextMock;
        }

        private static HttpContent CreateThrowingContent(Exception exception)
        {
            return new ThrowingHttpContent(exception);
        }

        private static Task WriteStreamedResponseContentAsync(HttpContextBase contextBase, HttpRequestMessage request,
            HttpResponseMessage response)
        {
            IExceptionLogger exceptionLogger = CreateStubExceptionLogger();
            CancellationToken cancellationToken = CancellationToken.None;

            return HttpControllerHandler.WriteStreamedResponseContentAsync(contextBase, request, response,
                exceptionLogger, cancellationToken);
        }

        private class FaultingHttpContent : HttpContent
        {
            private readonly Exception _exception;

            public FaultingHttpContent(Exception exception)
            {
                Contract.Assert(exception != null);
                _exception = exception;
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return CreateFaultedTask<object>(_exception);
            }

            protected override bool TryComputeLength(out long length)
            {
                length = 0;
                return false;
            }
        }

        private class LambdaHttpMessageHandler : HttpMessageHandler
        {
            private readonly Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> _sendAsync;

            public LambdaHttpMessageHandler(
                Func<HttpRequestMessage, CancellationToken, Task<HttpResponseMessage>> sendAsync)
            {
                Contract.Assert(sendAsync != null);
                _sendAsync = sendAsync;
            }

            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return _sendAsync.Invoke(request, cancellationToken);
            }
        }

        private sealed class SpyDisposable : IDisposable
        {
            public bool Disposed { get; private set; }

            public void Dispose()
            {
                Disposed = true;
            }
        }

        private class ThrowingHttpContent : HttpContent
        {
            private readonly Exception _exception;

            public ThrowingHttpContent(Exception exception)
            {
                Contract.Assert(exception != null);
                _exception = exception;

            }
            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                throw _exception;
            }

            protected override bool TryComputeLength(out long length)
            {
                throw _exception;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/HttpRequestMessageExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Web.Http.Hosting;

namespace System.Web.Http
{
    internal static class HttpRequestMessageExtensions
    {
        public static void SetIsLocal(this HttpRequestMessage request, Lazy<bool> isLocal)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            request.Properties[HttpPropertyKeys.IsLocalKey] = isLocal;
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

[assembly: CLSCompliant(false)]


================================================
FILE: test/System.Web.Http.WebHost.Test/RouteCollectionExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http
{
    public class RouteCollectionExtensionsTest
    {
        [Fact]
        public void IsCorrectType()
        {
            Assert.Type.HasProperties(typeof(RouteCollectionExtensions), TypeAssert.TypeProperties.IsStatic | TypeAssert.TypeProperties.IsPublicVisibleClass);
        }

        [Fact]
        public void MapHttpRoute1ThrowsOnNullRouteCollection()
        {
            Assert.ThrowsArgumentNull(() => RouteCollectionExtensions.MapHttpRoute(null, "", "", null), "routes");
        }

        [Fact]
        public void MapHttpRoute1CreatesRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            object defaults = new { d1 = "D1" };

            // Act
            Route route = routes.MapHttpRoute("name", "template", defaults);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.Url);
            Assert.Single(route.Defaults);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Same(route, routes["name"]);
        }

        [Fact]
        public void MapHttpRoute1WithDefaultsAsDictionaryCreatesRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            object defaults = new Dictionary<string, object> { { "d1", "D1" } };

            // Act
            Route route = routes.MapHttpRoute("name", "template", defaults);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.Url);
            Assert.Single(route.Defaults);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Same(route, routes["name"]);
        }

        [Fact]
        public void MapHttpRoute2ThrowsOnNullRouteCollection()
        {
            Assert.ThrowsArgumentNull(() => RouteCollectionExtensions.MapHttpRoute(null, "", "", null, null), "routes");
        }

        [Fact]
        public void MapHttpRoute2CreatesRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            object defaults = new { d1 = "D1" };
            object constraints = new { c1 = "C1" };

            // Act
            Route route = routes.MapHttpRoute("name", "template", defaults, constraints);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.Url);
            Assert.Single(route.Defaults);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Single(route.Constraints);
            Assert.Equal("C1", route.Constraints["c1"]);
            Assert.Same(route, routes["name"]);
        }

        [Fact]
        public void MapHttpRoute2WithDefaultsAndConstraintsAsDictionaryCreatesRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            object defaults = new Dictionary<string, object> { { "d1", "D1" } };
            object constraints = new Dictionary<string, object> { { "c1", "C1" } };

            // Act
            Route route = routes.MapHttpRoute("name", "template", defaults, constraints);

            // Assert
            Assert.NotNull(route);
            Assert.Equal("template", route.Url);
            Assert.Single(route.Defaults);
            Assert.Equal("D1", route.Defaults["d1"]);
            Assert.Single(route.Constraints);
            Assert.Equal("C1", route.Constraints["c1"]);
            Assert.Same(route, routes["name"]);
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Routing/HostedHttpRouteCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Dispatcher;
using System.Web.Http.Hosting;
using System.Web.Http.Routing;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Http.WebHost.Routing
{
    public class HostedHttpRouteCollectionTest
    {
        RouteCollection _aspNetRoutes;
        HostedHttpRouteCollection _webApiRoutes;

        public HostedHttpRouteCollectionTest()
        {
            _aspNetRoutes = new RouteCollection();
            _webApiRoutes = new HostedHttpRouteCollection(_aspNetRoutes);
        }

        [Fact]
        public void Constructor_GuardClauses()
        {
            Assert.ThrowsArgumentNull(() => new HostedHttpRouteCollection(routeCollection: null), "routeCollection");
        }

        [Fact]
        public void Add_WithHostedHttpRoute_RegistersInnerRouteWithAspNetRouteCollection()
        {
            var route = new HostedHttpRoute("uri", null, null, null, null);

            _webApiRoutes.Add("name", route);

            var httpWebRoute = Assert.IsType<HttpWebRoute>(_aspNetRoutes["name"]);
            Assert.Same(route.OriginalRoute, httpWebRoute);
            Assert.Same(route, httpWebRoute.HttpRoute);
        }

        [Fact]
        public void Add_WithNonHostedHttpRoute_WrapsCustomRouteWithHttpWebRoute()
        {
            var route = new Mock<IHttpRoute>().Object;

            _webApiRoutes.Add("name", route);

            var httpWebRoute = Assert.IsType<HttpWebRoute>(_aspNetRoutes["name"]);
            Assert.Same(route, httpWebRoute.HttpRoute);
        }

        [Fact]
        public void Clear_RemovesAllValuesFromAspNetRouteCollection()
        {
            _aspNetRoutes.Add(new Mock<RouteBase>().Object);

            _webApiRoutes.Clear();

            Assert.Empty(_aspNetRoutes);
        }

        [Fact]
        public void Contains_OnlyMatchesRegisteredHttpRouteInstances()
        {
            var route = new Mock<IHttpRoute>().Object;
            _webApiRoutes.Add("bar", route);

            Assert.True(_webApiRoutes.Contains(route));
            Assert.False(_webApiRoutes.Contains(new Mock<IHttpRoute>().Object));
        }

        [Fact]
        public void ContainsKey_MatchesAllRoutesInAspNetRouteCollection()
        {
            _aspNetRoutes.Add("foo", new Mock<RouteBase>().Object);
            _webApiRoutes.Add("bar", new Mock<IHttpRoute>().Object);

            Assert.True(_webApiRoutes.ContainsKey("foo"));
            Assert.True(_webApiRoutes.ContainsKey("bar"));
        }

        [Fact]
        public void Count_ReturnsCountOfAllRoutesInAspNetRouteCollection()
        {
            _aspNetRoutes.Add("foo", new Mock<RouteBase>().Object);
            _webApiRoutes.Add("bar", new Mock<IHttpRoute>().Object);

            Assert.Equal(2, _webApiRoutes.Count);
        }

        [Fact]
        public void CreateRoute_CreatesHostedHttpRoute()
        {
            var defaults = new HttpRouteValueDictionary { { "Foo", "Bar" } };
            var constraints = new HttpRouteValueDictionary { { "Bar", "Baz" } };
            var dataTokens = new HttpRouteValueDictionary { { "Baz", "Biff" } };
            var handler = new Mock<HttpMessageHandler>().Object;

            IHttpRoute result = _webApiRoutes.CreateRoute("uri", defaults, constraints, dataTokens, handler);

            Assert.IsType<HostedHttpRoute>(result);
            Assert.Equal("Bar", result.Defaults["Foo"]);
            Assert.Equal("Baz", result.Constraints["Bar"]);
            Assert.Equal("Biff", result.DataTokens["Baz"]);
            Assert.Same(handler, result.Handler);
        }

        [Fact]
        public void Enumerating_OnlyIncludesHttpRoutes()
        {
            var aspNetRoute = new Mock<RouteBase>().Object;
            _aspNetRoutes.Add("foo", aspNetRoute);
            var httpRoute = new Mock<IHttpRoute>().Object;
            _webApiRoutes.Add("bar", httpRoute);

            List<object> objects = new List<object>(_webApiRoutes);

            Assert.Contains(httpRoute, objects);
            Assert.DoesNotContain(aspNetRoute, objects);
        }

        [Fact]
        public void GetRouteData_GuardClauses()
        {
            Assert.ThrowsArgumentNull(() => _webApiRoutes.GetRouteData(request: null), "request");
        }

        [Fact]
        public void GetRouteData_WithHttpContext_UnmatchedRoute_ReturnsNull()
        {
            var request = new HttpRequestMessage();
            request.SetHttpContext(CreateHttpContext("~/api2"));
            IHttpRoute route = _webApiRoutes.CreateRoute("api", null, null);
            _webApiRoutes.Add("default", route);

            IHttpRouteData result = _webApiRoutes.GetRouteData(request);

            Assert.Null(result);
        }

        [Fact]
        public void GetRouteData_WithHttpContext_MatchedRoute_ReturnsRouteData()
        {
            var request = new HttpRequestMessage();
            request.SetHttpContext(CreateHttpContext("~/api"));
            IHttpRoute route = _webApiRoutes.CreateRoute("api", null, null);
            _webApiRoutes.Add("default", route);

            IHttpRouteData result = _webApiRoutes.GetRouteData(request);

            Assert.Same(route, result.Route);
        }

        [Fact]
        public void SendAsync_CallsDefaultHandlerWhenCustomASPNETRoute()
        {
            // Arrange
            var mockHandler = new Mock<HttpMessageHandler>();
            var config = new HttpConfiguration();
            var request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/controllerName");
            request.SetConfiguration(config);
            HttpDomainRoute domainRoute = new HttpDomainRoute("test", new { controller = "Values", action = "GetTenant" });
            request.SetRouteData(new HostedHttpRouteData(domainRoute.GetRouteData(null)));
            var dispatcher = new HttpRoutingDispatcher(config, defaultHandler: mockHandler.Object);
            var invoker = new HttpMessageInvoker(dispatcher);

            // Act
            invoker.SendAsync(request, CancellationToken.None);

            // Assert
            mockHandler.Protected().Verify("SendAsync", Times.Once(), request, CancellationToken.None);
        }

        [Fact]
        public void GetVirtualPath_GuardClauses()
        {
            Assert.ThrowsArgumentNull(() => _webApiRoutes.GetVirtualPath(request: null, name: null, values: null), "request");
        }

        [Fact]
        public void GetVirtualPath_ReturnsVirtualPathData()
        {
            var request = new HttpRequestMessage();
            request.SetHttpContext(CreateHttpContext("~/api", "APP PATH MODIFIER RETURN VALUE"));
            var config = new HttpConfiguration(_webApiRoutes);
            IHttpRoute route = _webApiRoutes.CreateRoute("api", null, null);
            _webApiRoutes.Add("default", route);
            request.SetRouteData(_webApiRoutes.GetRouteData(request));
            request.SetConfiguration(config);

            IHttpVirtualPathData result = _webApiRoutes.GetVirtualPath(request, null, new HttpRouteValueDictionary { { "httproute", true } });

            Assert.NotNull(result);
            Assert.Same(route, result.Route);
            Assert.Equal("APP PATH MODIFIER RETURN VALUE", result.VirtualPath);
        }

        [Fact]
        public void Indexer_ForHttpRoute_ReturnsRoute()
        {
            var route = new Mock<IHttpRoute>().Object;
            _webApiRoutes.Add("foo", route);

            var result = _webApiRoutes["foo"];

            Assert.NotNull(result);
            Assert.Same(route, result);
        }

        [Fact]
        public void Indexer_ForAspNetRoute_Throws()
        {
            _aspNetRoutes.Add("foo", new Mock<RouteBase>().Object);

            Assert.Throws<KeyNotFoundException>(() => _webApiRoutes["foo"], "The given key was not present in the dictionary.");
        }

        [Fact]
        public void Indexer_ForUnknownRoute_Throws()
        {
            Assert.Throws<KeyNotFoundException>(() => _webApiRoutes["foo"], "The given key was not present in the dictionary.");
        }

        [Fact]
        public void UnsupportedFunctions()
        {
            Assert.Throws<NotSupportedException>(() => _webApiRoutes.CopyTo((IHttpRoute[])null, 0), "This operation is only supported by directly calling it on 'RouteCollection'.");

            Assert.Throws<NotSupportedException>(() => _webApiRoutes.CopyTo((KeyValuePair<string, IHttpRoute>[])null, 0), "This operation is not supported by 'HostedHttpRouteCollection'.");
            Assert.Throws<NotSupportedException>(() => _webApiRoutes.Insert(0, null, null), "This operation is not supported by 'HostedHttpRouteCollection'.");
            Assert.Throws<NotSupportedException>(() => _webApiRoutes.Remove(null), "This operation is not supported by 'HostedHttpRouteCollection'.");
        }

        [Fact]
        public void ConvertHttpRouteDataToRouteDataRunsCustomHttpRoute()
        {
            // Arrange
            DomainHttpRoute route = new DomainHttpRoute("myDomain", "api/{controller}/{action}", new { controller = "Values", action = "GetTenant" });
            HostedHttpRouteCollection collection = new HostedHttpRouteCollection(new RouteCollection());
            collection.Add("domainRoute", route);
            HttpRequestMessage request = CreateHttpRequestMessageWithContext();
            IHttpRouteData httpRouteData = collection.GetRouteData(request);

            // Act
            RouteData routeData = httpRouteData.ToRouteData();

            // Assert
            Assert.NotNull(routeData.Values);
            Assert.Equal(3, routeData.Values.Count);
            Assert.Equal("controllerName", routeData.Values["controller"]);
            Assert.Equal("actionName", routeData.Values["action"]);
            Assert.Equal("myDomain", routeData.Values["domain"]);
        }

        [Fact]
        public void CustomHttpRouteGetVitualPathRunsCustomHttpRoute()
        {
            // Arrange
            DomainHttpRoute route = new DomainHttpRoute("myDomain", "api/{controller}/{action}", new { controller = "SomeValue", action = "SomeAction" });
            HostedHttpRouteCollection collection = new HostedHttpRouteCollection(new RouteCollection());
            collection.Add("domainRoute", route);
            HttpRequestMessage request = CreateHttpRequestMessageWithContext();
            HttpRouteValueDictionary routeValues = new HttpRouteValueDictionary()
                {
                    {"controller", "controllerName"},
                    {"action", "actionName"},
                    {"httproute", true}
                };

            request.SetRouteData(new HttpRouteData(route, routeValues));

            // Act
            IHttpVirtualPathData httpvPathData = collection.GetVirtualPath(request, "domainRoute", routeValues);

            // Assert
            Assert.NotNull(httpvPathData);
            Assert.Equal("/api/controllerName/actionNameFromDomain", httpvPathData.VirtualPath);
        }

        [Fact]
        public void IgnoreRoute_GetVirtualPathReturnsNull()
        {
            // Arrange
            DomainHttpRoute route = new DomainHttpRoute("myDomain", "api/{controller}/{action}", new { controller = "SomeValue", action = "SomeAction" });
            HostedHttpRouteCollection collection = new HostedHttpRouteCollection(new RouteCollection());
            collection.IgnoreRoute("domainRoute", route.RouteTemplate);
            HttpRequestMessage request = CreateHttpRequestMessageWithContext();
            HttpRouteValueDictionary routeValues = new HttpRouteValueDictionary()
                {
                    {"controller", "controllerName"},
                    {"action", "actionName"},
                    {"httproute", true}
                };

            request.SetRouteData(new HttpRouteData(route, routeValues));

            // Act
            IHttpVirtualPathData httpvPathData = collection.GetVirtualPath(request, "domainRoute", routeValues);

            // Assert
            // Altough it contains the ignore route, GetVirtualPath from the ignored route will always return null.
            Assert.Equal(1, collection.Count);
            Assert.Null(httpvPathData);
        }

        [Theory]
        [InlineData("people/")]
        [InlineData("people/1")]
        [InlineData("people/literal")]
        [InlineData("people/name?id=20")]
        public async Task IgnoreRoute_GetSoft404IfRouteIgnored(string requestPath)
        {
            var request = CreateHttpRequestMessageWithContext(requestPath);

            var response = await SubmitRequestAsync(request);

            Assert.Equal(Net.HttpStatusCode.NotFound, response.StatusCode);
            Assert.True(response.RequestMessage.Properties.ContainsKey(HttpPropertyKeys.NoRouteMatched));
        }

        [Fact]
        public void CreateRoute_ValidatesConstraintType_IHttpRouteConstraint()
        {
            // Arrange
            var routes = new MockHostedHttpRouteCollection(new RouteCollection());

            var constraint = new CustomHttpConstraint();
            var constraints = new HttpRouteValueDictionary();
            constraints.Add("custom", constraint);

            // Act
            var route = routes.CreateRoute("{controller}/{id}", null, constraints);

            // Assert
            Assert.NotNull(route.Constraints["custom"]);

            Assert.Equal(1, routes.TimesValidateConstraintCalled);
        }

        [Fact]
        public void CreateRoute_ValidatesConstraintType_IRouteConstraint()
        {
            // Arrange
            var routes = new MockHostedHttpRouteCollection(new RouteCollection());

            var constraint = new CustomConstraint();
            var constraints = new HttpRouteValueDictionary();
            constraints.Add("custom", constraint);

            // Act
            var route = routes.CreateRoute("{controller}/{id}", null, constraints);

            // Assert
            Assert.NotNull(route.Constraints["custom"]);
            Assert.Equal(1, routes.TimesValidateConstraintCalled);
        }

        [Fact]
        public void CreateRoute_ValidatesConstraintType_StringRegex()
        {
            // Arrange
            var routes = new MockHostedHttpRouteCollection(new RouteCollection());

            var constraint = "product|products";
            var constraints = new HttpRouteValueDictionary();
            constraints.Add("custom", constraint);

            // Act
            var route = routes.CreateRoute("{controller}/{id}", null, constraints);

            // Assert
            Assert.NotNull(route.Constraints["custom"]);
            Assert.Equal(1, routes.TimesValidateConstraintCalled);
        }

        [Fact]
        public void CreateRoute_ValidatesConstraintType_InvalidType()
        {
            // Arrange
            var routes = new HostedHttpRouteCollection(new RouteCollection());

            var constraint = new Uri("http://localhost/");
            var constraints = new HttpRouteValueDictionary();
            constraints.Add("custom", constraint);

            string expectedMessage =
                "The constraint entry 'custom' on the route with route template '{controller}/{id}' " +
                "must have a string value or be of a type which implements 'System.Web.Http.Routing.IHttpRouteConstraint' or 'System.Web.Routing.IRouteConstraint'.";

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => routes.CreateRoute("{controller}/{id}", null, constraints), expectedMessage);
        }

        [Theory]
        [InlineData("values/10")]
        [InlineData("values/15")]
        [InlineData("values/20")]
        public async Task IgnoreRoute_WithConstraints_GetSoft404IfRouteIgnored(string requestPath)
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/constraint/" + requestPath);
            request.SetConfiguration(new HttpConfiguration());
            request.SetHttpContext(CreateHttpContext("~/constraint"));

            var response = await SubmitRequestAsync(request);

            Assert.Equal(Net.HttpStatusCode.NotFound, response.StatusCode);
            Assert.True(response.RequestMessage.Properties.ContainsKey(HttpPropertyKeys.NoRouteMatched));
        }

        [Theory]
        [InlineData("values/1")]
        [InlineData("values/25")]
        [InlineData("values/40")]
        public async Task IgnoreRoute_WithConstraints_GetValueIfNotIgnored(string requestPath)
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/constraint/" + requestPath);
            request.SetConfiguration(new HttpConfiguration());
            request.SetHttpContext(CreateHttpContext("~/constraint"));

            var response = await SubmitRequestAsync(request);

            Assert.Equal(Net.HttpStatusCode.OK, response.StatusCode);
            Assert.Equal(String.Concat("values/", await response.Content.ReadAsStringAsync()), requestPath);
        }

        public class CustomIgnoreRouteConstraint : IHttpRouteConstraint
        {
            public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName,
                IDictionary<string, object> values, HttpRouteDirection routeDirection)
            {
                long id;
                if (values.ContainsKey("id")
                    && Int64.TryParse(values["id"].ToString(), out id)
                    && (id == 10 || id == 15 || id == 20))
                {
                    return true;
                }

                return false;
            }
        }

        private static async Task<HttpResponseMessage> SubmitRequestAsync(HttpRequestMessage request)
        {
            HttpConfiguration config = new HttpConfiguration(new HostedHttpRouteCollection(new RouteCollection()));
            config.Routes.IgnoreRoute("Bar", "api/{*pathInfo}");
            config.Routes.IgnoreRoute("Constraints", "constraint/values/{id}", constraints: new { constraint = new CustomIgnoreRouteConstraint() });
            config.Routes.MapHttpRoute("DefaultApi", "api/{controller}/{action}");
            config.MapHttpAttributeRoutes();

            HttpResponseMessage response;
            HttpServer server = new HttpServer(config);
            using (HttpMessageInvoker client = new HttpMessageInvoker(server))
            {
                response = await client.SendAsync(request, CancellationToken.None);
            }

            return response;
        }

        [RoutePrefix("constraint")]
        public class IgnoreRouteWithConstraintsTestController : ApiController
        {
            [Route("values/{id:int}")]
            public int Get(int id)
            {
               return id;
            }
        }

        private static T GetContentValue<T>(HttpResponseMessage response)
        {
            T value;
            response.TryGetContentValue<T>(out value);
            return value;
        }

        private static HttpRequestMessage CreateHttpRequestMessageWithContext(string requestPath = "controllerName/actionName")
        {
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, "http://localhost/api/" + requestPath);
            request.SetConfiguration(new HttpConfiguration());
            request.SetHttpContext(CreateHttpContext("~/api"));

            return request;
        }

        private static HttpContextBase CreateHttpContext(string relativeUrl, string appPathModifierReturnValue = "")
        {
            var mockContext = new Mock<HttpContextBase>();

            mockContext.SetupGet(c => c.Request.ApplicationPath).Returns(String.Empty);
            mockContext.SetupGet(c => c.Request.AppRelativeCurrentExecutionFilePath).Returns(relativeUrl);
            mockContext.SetupGet(c => c.Request.PathInfo).Returns("");
            mockContext.SetupGet(c => c.Items).Returns(new Dictionary<string, object>());
            mockContext.SetupGet(c => c.Request.HttpMethod).Returns("GET");
            mockContext.SetupGet(c => c.Request.InputStream).Returns(new MemoryStream());
            mockContext.SetupGet(c => c.Request.Headers).Returns(new NameValueCollection());
            mockContext.SetupGet(c => c.Request.ApplicationPath).Returns("/");

            if (appPathModifierReturnValue == string.Empty)
            {
                mockContext.Setup(c => c.Response.ApplyAppPathModifier(It.IsAny<string>()))
                               .Returns((string s) => { return s; });
            }
            else
            {
                mockContext.Setup(c => c.Response.ApplyAppPathModifier(It.IsAny<string>()))
                             .Returns(appPathModifierReturnValue);
            }

            return mockContext.Object;
        }

        public class HttpDomainRoute : Route
        {
            public HttpDomainRoute(string routeTemplate, object defaults, object constraints = null)
                : base(routeTemplate, new RouteValueDictionary(defaults), new RouteValueDictionary(constraints), new RouteValueDictionary(), HttpControllerRouteHandler.Instance)
            {
            }

            public override RouteData GetRouteData(HttpContextBase context)
            {
                RouteData data = new RouteData(this, RouteHandler);
                data.Values.Add("domain", "customer");
                return data;
            }

            public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
            {
                return base.GetVirtualPath(requestContext, values);
            }
        }

        public class DomainHttpRoute : HttpRoute
        {
            public DomainHttpRoute(string domain, string routeTemplate, object defaults, object constraints = null)
                : base(routeTemplate, new HttpRouteValueDictionary(defaults), new HttpRouteValueDictionary(constraints))
            {
                Domain = domain;
            }

            public string Domain { get; set; }

            public override IHttpRouteData GetRouteData(string virtualPathRoot, System.Net.Http.HttpRequestMessage request)
            {
                // Route data
                IHttpRouteData data = base.GetRouteData(virtualPathRoot, request);
                data.Values.Add("domain", Domain);
                return data;
            }

            public override IHttpVirtualPathData GetVirtualPath(System.Net.Http.HttpRequestMessage request, IDictionary<string, object> values)
            {
                // customize the action token
                values["action"] = "actionNameFromDomain";

                return base.GetVirtualPath(request, values);
            }
        }

        private class CustomHttpConstraint : IHttpRouteConstraint
        {
            public bool Match(HttpRequestMessage request, IHttpRoute route, string parameterName, IDictionary<string, object> values, HttpRouteDirection routeDirection)
            {
                throw new NotImplementedException();
            }
        }

        private class CustomConstraint : IRouteConstraint
        {
            public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
            {
                throw new NotImplementedException();
            }
        }

        private class MockHostedHttpRouteCollection : HostedHttpRouteCollection
        {
            public MockHostedHttpRouteCollection(RouteCollection routes)
                : base(routes)
            {
            }

            public int TimesValidateConstraintCalled
            {
                get;
                private set;
            }

            protected override void ValidateConstraint(string routeTemplate, string name, object constraint)
            {
                TimesValidateConstraintCalled++;
                base.ValidateConstraint(routeTemplate, name, constraint);
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Routing/HostedUrlHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net.Http;
using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;
using UrlHelper = System.Web.Http.Routing.UrlHelper;

namespace System.Web.Http.WebHost.Routing
{
    public class HostedUrlHelperTest
    {
        [Theory]
        [InlineData(WhichRoute.ApiRoute1)]
        [InlineData(WhichRoute.ApiRoute2)]
        [InlineData(WhichRoute.WebRoute1)]
        public void UrlHelper_GeneratesApiUrl_ForMatchingData(WhichRoute whichRoute)
        {
            // Mixed mode app with Web API generating URLs to other APIs
            var url = GetUrlHelperForMixedApp(whichRoute);

            string generatedUrl = url.Route("apiroute2", new { controller = "something", action = "someaction", id = 789 });

            Assert.Equal("$APP$/SOMEAPP/api/something/someaction", generatedUrl);
        }

        [Theory]
        [InlineData(WhichRoute.ApiRoute1)]
        [InlineData(WhichRoute.ApiRoute2)]
        [InlineData(WhichRoute.WebRoute1)]
        public void UrlHelper_GeneratesNonApiUrl_ForMatchingData(WhichRoute whichRoute)
        {
            // Mixed mode app with Web API generating URLs to other non-API routes
            var url = GetUrlHelperForMixedApp(whichRoute);

            string generatedUrl = url.Route("webroute1", new { controller = "something", action = "someaction", id = 789 });

            Assert.Equal("$APP$/SOMEAPP/something/someaction/789", generatedUrl);
        }

        [Theory]
        [InlineData(WhichRoute.ApiRoute1)]
        [InlineData(WhichRoute.ApiRoute2)]
        [InlineData(WhichRoute.WebRoute1)]
        public void UrlHelper_GeneratesNullUrl_ForDataNotMatching(WhichRoute whichRoute)
        {
            // Mixed mode app with Web API generating URLs to other non-API routes
            var url = GetUrlHelperForMixedApp(whichRoute);

            string generatedUrl = url.Route("webroute1", new { foo = "bar" });

            Assert.Null(generatedUrl);
        }

        [Theory]
        [InlineData(WhichRoute.ApiRoute1)]
        [InlineData(WhichRoute.ApiRoute2)]
        [InlineData(WhichRoute.WebRoute1)]
        public void UrlHelper_SkipsApiRoutesAndMatchesMvcUrl_ForMatchingData(WhichRoute whichRoute)
        {
            // Mixed mode app with MVC generating URLs to other MVC URLs
            RouteCollection routes;
            RequestContext requestContext;
            var url = GetUrlHelperForMixedApp(whichRoute, out routes, out requestContext);

            // Note: This is generating a URL the "hard" way because it's simulating what a regular MVC
            // app would do when generating a URL. If we went through the Web API functionality it wouldn't
            // be testing what would really happen in a mixed app.
            VirtualPathData virtualPathData = routes.GetVirtualPath(requestContext, new RouteValueDictionary(new { controller = "something", action = "someaction", id = 789 }));

            Assert.NotNull(virtualPathData);

            string generatedUrl = virtualPathData.VirtualPath;

            Assert.Equal("$APP$/SOMEAPP/something/someaction/789", generatedUrl);
        }

        [Theory]
        [InlineData(WhichRoute.ApiRoute1)]
        [InlineData(WhichRoute.ApiRoute2)]
        [InlineData(WhichRoute.WebRoute1)]
        public void UrlHelper_MvcAppGeneratesApiRoute_WithSpecialHttpRouteKey(WhichRoute whichRoute)
        {
            // Mixed mode app with MVC generating URLs to Web APIs
            RouteCollection routes;
            RequestContext requestContext;
            var url = GetUrlHelperForMixedApp(whichRoute, out routes, out requestContext);

            // Note: This is generating a URL the "hard" way because it's simulating what a regular MVC
            // app would do when generating a URL. If we went through the Web API functionality it wouldn't
            // be testing what would really happen in a mixed app.
            VirtualPathData virtualPathData = routes.GetVirtualPath(requestContext, new RouteValueDictionary(new { controller = "something", action = "someotheraction", id = 789, httproute = true }));

            Assert.NotNull(virtualPathData);

            string generatedUrl = virtualPathData.VirtualPath;

            Assert.Equal("$APP$/SOMEAPP/api/something/someotheraction", generatedUrl);
        }

        [Theory]
        [InlineData("httproute")]
        [InlineData("httpRoute")]
        [InlineData("HTTPROUTE")]
        [InlineData("hTtProuTE")]
        public void UrlHelper_DoesntAddDuplicateHttpRoute_ForHttpRouteInDifferentCasing(string httpRoute)
        {
            // Mixed mode app with MVC generating URLs to Web APIs
            RouteCollection routes;
            RequestContext requestContext;
            var url = GetUrlHelperForMixedApp(WhichRoute.ApiRoute1, out routes, out requestContext);

            string generatedUrl = url.Route("apiroute1", new Dictionary<string, object> { { "controller", "something" }, { "id", 789 }, { httpRoute, true } });

            Assert.Equal("$APP$/SOMEAPP/api/something/789", generatedUrl);
        }

        private static UrlHelper GetUrlHelperForMixedApp(WhichRoute whichRoute)
        {
            RouteCollection routes;
            RequestContext requestContext;
            return GetUrlHelperForMixedApp(whichRoute, out routes, out requestContext);
        }

        private static UrlHelper GetUrlHelperForMixedApp(WhichRoute whichRoute, out RouteCollection routes, out RequestContext requestContext)
        {
            routes = new RouteCollection();

            HttpRequestMessage request = new HttpRequestMessage();
            var mockHttpContext = new Mock<HttpContextBase>();
            var mockHttpRequest = new Mock<HttpRequestBase>();
            mockHttpRequest.SetupGet<string>(x => x.ApplicationPath).Returns("/SOMEAPP/");
            var mockHttpResponse = new Mock<HttpResponseBase>();
            mockHttpResponse.Setup<string>(x => x.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(x => "$APP$" + x);
            mockHttpContext.SetupGet<HttpRequestBase>(x => x.Request).Returns(mockHttpRequest.Object);
            mockHttpContext.SetupGet<HttpResponseBase>(x => x.Response).Returns(mockHttpResponse.Object);
            request.Properties["MS_HttpContext"] = mockHttpContext.Object;

            // Set up routes
            var hostedRoutes = new HostedHttpRouteCollection(routes);
            Route apiRoute1 = routes.MapHttpRoute("apiroute1", "api/{controller}/{id}", new { action = "someaction" });
            Route apiRoute2 = routes.MapHttpRoute("apiroute2", "api/{controller}/{action}", new { id = 789 });
            Route webRoute1 = routes.MapRoute("webroute1", "{controller}/{action}/{id}");
            request.SetConfiguration(new HttpConfiguration(hostedRoutes));

            RouteData routeData = new RouteData();
            routeData.Values.Add("controller", "people");
            routeData.Values.Add("id", "123");

            // Specify which route we came in on (e.g. what request matching the incoming URL) because
            // it can affect the generated URL due to the ambient route data.
            switch (whichRoute)
            {
                case WhichRoute.ApiRoute1:
                    routeData.Route = apiRoute1;
                    break;
                case WhichRoute.ApiRoute2:
                    routeData.Route = apiRoute2;
                    break;
                case WhichRoute.WebRoute1:
                    routeData.Route = webRoute1;
                    break;
                default:
                    throw new ArgumentException("Invalid route specified.", "whichRoute");
            }
            request.SetRouteData(new HostedHttpRouteData(routeData));

            requestContext = new RequestContext(mockHttpContext.Object, routeData);

            return request.GetUrlHelper();
        }

        public enum WhichRoute
        {
            ApiRoute1,
            ApiRoute2,
            WebRoute1,
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Routing/HttpContextBaseExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Net.Http;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.WebHost.Routing
{
    public class HttpContextBaseExtensionsTest
    {
        [Fact]
        public void GetOrCreateHttpRequestMessageFromHttpContextCopiesHeaders()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            Dictionary<string, object> items = new Dictionary<string, object>();
            contextMock.Setup(o => o.Items).Returns(items);
            var requestMock = new Mock<HttpRequestBase>();
            requestMock.Setup(r => r.HttpMethod).Returns("GET");
            requestMock.Setup(r => r.InputStream).Returns(new MemoryStream());
            NameValueCollection col = new NameValueCollection();
            col.Add("customHeader", "customHeaderValue");
            requestMock.Setup(r => r.Headers).Returns(col);
            contextMock.Setup(o => o.Request).Returns(requestMock.Object);

            // Act
            contextMock.Object.GetOrCreateHttpRequestMessage();

            // Assert
            HttpRequestMessage request = contextMock.Object.GetHttpRequestMessage();
            Assert.NotNull(request);
            Assert.Equal(HttpMethod.Get, request.Method);
            IEnumerable<string> headerValues;
            Assert.True(request.Headers.TryGetValues("customHeader", out headerValues));
            string headerValue = Assert.Single(headerValues);
            Assert.Equal("customHeaderValue", headerValue);
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Routing/HttpRequestMessageWrapperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Net.Http;
using System.Web.Http.Hosting;
using Microsoft.TestCommon;

namespace System.Web.Http.WebHost.Routing
{
    public class HttpRequestMessageWrapperTest
    {
        public static TheoryDataSet<string, string, string> AppRelativeCurrentExecutionFilePathData
        {
            get
            {
                // string virtualPathRoot, string requestUri, string expectedPath
                return new TheoryDataSet<string, string, string>
                {
                    { "/", "http://localhost/path", "~/path" },
                    { "/", "http://localhost/path.ext", "~/path.ext" },
                    { "/", "http://localhost/path.ext?query=value", "~/path.ext" },

                    { "/", "http://localhost/path/", "~/path" },
                    { "/", "http://localhost/path.ext/", "~/path.ext" },
                    { "/", "http://localhost/path.ext/?query=value", "~/path.ext" },

                    { "/path1", "http://localhost/path1/path2", "~/path2" },
                    { "/path1", "http://localhost/path1/path2.ext", "~/path2.ext" },
                    { "/path1", "http://localhost/path1/path2.ext?query=value", "~/path2.ext" },

                    { "/path1", "http://localhost/path1/path2/", "~/path2" },
                    { "/path1", "http://localhost/path1/path2.ext/", "~/path2.ext" },
                    { "/path1", "http://localhost/path1/path2.ext/?query=value", "~/path2.ext" },

                    { "/path1", "http://localhost/path1/path2/path3", "~/path2/path3" },
                    { "/path1", "http://localhost/path1/path2/path3.ext", "~/path2/path3.ext" },
                    { "/path1", "http://localhost/path1/path2/path3.ext?query=value", "~/path2/path3.ext" },

                    { "/path1", "http://localhost/path1/path2/path3/", "~/path2/path3" },
                    { "/path1", "http://localhost/path1/path2/path3.ext/", "~/path2/path3.ext" },
                    { "/path1", "http://localhost/path1/path2/path3.ext/?query=value", "~/path2/path3.ext" },

                    { "/path1", "http://localhost/PATH1/path2/path3/", "~/path2/path3" },
                    { "/path1", "http://localhost/PATH1/PATH2/path3.ext/", "~/PATH2/path3.ext" },
                    { "/path1", "http://localhost/PATH1/PATH2/PATH3.ext/?query=value", "~/PATH2/PATH3.ext" },

                    // urls should be unencoded - /path1/path2 /path3.ext instead of /path1/path2%20/path3.ext
                    { "/path1", "http://localhost/PATH1/path2 /path3/", "~/path2 /path3" },
                    { "/path1", "http://localhost/PATH1/PATH2 /path3.ext/", "~/PATH2 /path3.ext" },
                    { "/path1", "http://localhost/PATH1/PATH2 /PATH3.ext/?query=value", "~/PATH2 /PATH3.ext" },
                };
            }
        }

        public static TheoryDataSet<string, string, string> FilePathData
        {
            get
            {
                // string virtualPathRoot, string requestUri, string expectedPath
                return new TheoryDataSet<string, string, string>
                {
                    { "/", "http://localhost/path", "/path" },
                    { "/", "http://localhost/path.ext", "/path.ext" },
                    { "/", "http://localhost/path.ext?query=value", "/path.ext" },

                    { "/", "http://localhost/path/", "/path" },
                    { "/", "http://localhost/path.ext/", "/path.ext" },
                    { "/", "http://localhost/path.ext/?query=value", "/path.ext" },

                    { "/path1", "http://localhost/path1/path2", "/path1/path2" },
                    { "/path1", "http://localhost/path1/path2.ext", "/path1/path2.ext" },
                    { "/path1", "http://localhost/path1/path2.ext?query=value", "/path1/path2.ext" },

                    { "/path1", "http://localhost/path1/path2/", "/path1/path2" },
                    { "/path1", "http://localhost/path1/path2.ext/", "/path1/path2.ext" },
                    { "/path1", "http://localhost/path1/path2.ext/?query=value", "/path1/path2.ext" },

                    { "/path1", "http://localhost/path1/path2/path3", "/path1/path2/path3" },
                    { "/path1", "http://localhost/path1/path2/path3.ext", "/path1/path2/path3.ext" },
                    { "/path1", "http://localhost/path1/path2/path3.ext?query=value", "/path1/path2/path3.ext" },

                    { "/path1", "http://localhost/path1/path2/path3/", "/path1/path2/path3" },
                    { "/path1", "http://localhost/path1/path2/path3.ext/", "/path1/path2/path3.ext" },
                    { "/path1", "http://localhost/path1/path2/path3.ext/?query=value", "/path1/path2/path3.ext" },

                    // urls should be unescaped - /path1/path2 /path3.ext instead of /path1/path2%20/path3.ext
                    { "/path1", "http://localhost/path1/path2 /path3/", "/path1/path2 /path3" },
                    { "/path1", "http://localhost/path1/path2 /path3.ext/", "/path1/path2 /path3.ext" },
                    { "/path1", "http://localhost/path1/path2 /path3.ext/?query=value", "/path1/path2 /path3.ext" },
                };
            }
        }

        [Fact]
        public void Constructor_GuardClauses()
        {
            HttpRequestMessage request = new HttpRequestMessage();
            Assert.ThrowsArgumentNull(() => new HttpRequestMessageWrapper(virtualPathRoot: null, httpRequest: request), "virtualPathRoot");
            Assert.ThrowsArgumentNull(() => new HttpRequestMessageWrapper(String.Empty, httpRequest: null), "httpRequest");
        }

        [Theory]
        [InlineData("")]
        [InlineData("/")]
        [InlineData("/path")]
        [InlineData("/path1/path2")]
        public void ApplicationPath_DelegatesToHttpRequestMessage(string applicationPath)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper(applicationPath, request);

            // Act
            string actualApplicationPath = wrapper.ApplicationPath;

            // Assert
            Assert.Equal(applicationPath, actualApplicationPath);
        }

        [Theory]
        [PropertyData("AppRelativeCurrentExecutionFilePathData")]
        public void AppRelativeCurrentExecutionFilePath_DelegatesToHttpRequestMessage(string virtualPathRoot, string requestUri, string expectedPath)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri(requestUri),
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper(virtualPathRoot, request);

            // Act
            string actualPath = wrapper.AppRelativeCurrentExecutionFilePath;

            // Assert
            Assert.Equal(expectedPath, actualPath);
        }

        [Theory]
        [PropertyData("FilePathData")]
        public void CurrentExecutionFilePath_DelegatesToHttpRequestMessage(string virtualPathRoot, string requestUri, string expectedPath)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri(requestUri),
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper(virtualPathRoot, request);

            // Act
            string actualPath = wrapper.CurrentExecutionFilePath;

            // Assert
            Assert.Equal(expectedPath, actualPath);
        }

        [Theory]
        [PropertyData("FilePathData")]
        public void FilePath_DelegatesToHttpRequestMessage(string virtualPathRoot, string requestUri, string expectedPath)
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = new Uri(requestUri),
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper(virtualPathRoot, request);

            // Act
            string actualPath = wrapper.FilePath;

            // Assert
            Assert.Equal(expectedPath, actualPath);
        }

        [Fact]
        public void HttpMethod_DelegatesToHttpRequestMessage()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                Method = new HttpMethod("DELETE")
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            string actualMethod = wrapper.HttpMethod;

            // Assert
            Assert.Equal("DELETE", actualMethod);
        }

        [Fact]
        public void RequestType_DelegatesToHttpRequestMessage()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage
            {
                Method = new HttpMethod("DELETE")
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            string actualRequestType = wrapper.RequestType;

            // Assert
            Assert.Equal("DELETE", actualRequestType);
        }

        [Fact]
        public void Path_DelegatesToHttpRequestMessage()
        {
            // Arrange
            Uri requestUri = new Uri("http://localhost/some/path?query=value");
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = requestUri
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            string actualPath = wrapper.Path;

            // Assert
            Assert.Equal("/some/path", actualPath);
        }

        [Fact]
        public void Path_DelegatesToHttpRequestMessage_DoesNotEncode()
        {
            // Arrange
            Uri requestUri = new Uri("http://localhost/some /path?query=value");
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = requestUri
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            string actualPath = wrapper.Path;

            // Assert
            Assert.Equal("/some /path", actualPath);
        }

        [Theory]
        [InlineData("http://www.example.com")]
        [InlineData("http://www.example.com?query")]
        [InlineData("http://www.example.com?query=value")]
        public void QueryString_DelegatesToHttpRequestMessage(string requestUri)
        {
            // Arrange
            Uri reqUri = new Uri(requestUri);
            NameValueCollection expectedQueryString = reqUri.ParseQueryString();
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = reqUri
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            NameValueCollection actualQuery = wrapper.QueryString;

            // Assert
            Assert.Equal(expectedQueryString.ToString(), actualQuery.ToString());
        }

        [Fact]
        public void RawUrl_DelegatesToHttpRequestMessage()
        {
            // Arrange
            Uri requestUri = new Uri("http://localhost/some/path?query=value");
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = requestUri
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            string actualRawUrl = wrapper.RawUrl;

            // Assert
            Assert.Equal("/some/path?query=value", actualRawUrl);
        }

        [Fact]
        public void RawUrl_DelegatesToHttpRequestMessage_DoesNotEncode()
        {
            // Arrange
            Uri requestUri = new Uri("http://localhost/some /path?query=value");
            HttpRequestMessage request = new HttpRequestMessage
            {
                RequestUri = requestUri
            };
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            string actualRawUrl = wrapper.RawUrl;

            // Assert
            Assert.Equal("/some /path?query=value", actualRawUrl);
        }

        [Fact]
        public void IsLocal_Call_To_HttpRequestMessageExtension_Method()
        {
            // Arrange
            HttpRequestMessage request = new HttpRequestMessage();
            request.SetIsLocal(new Lazy<bool>(() => true));
            HttpRequestMessageWrapper wrapper = new HttpRequestMessageWrapper("/", request);

            // Act
            bool isLocal = wrapper.IsLocal;

            // Assert
            Assert.True(isLocal);
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Routing/HttpRouteExceptionHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Results;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.WebHost.Routing
{
    public class HttpRouteExceptionHandlerTests
    {
        [Fact]
        public void ExceptionInfo_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionDispatchInfo expectedExceptionInfo = CreateExceptionInfo();
            IExceptionLogger logger = CreateDummyLogger();
            IExceptionHandler handler = CreateDummyHandler();
            HttpRouteExceptionHandler product = CreateProductUnderTest(expectedExceptionInfo, logger, handler);

            // Act
            ExceptionDispatchInfo exceptionInfo = product.ExceptionInfo;

            // Assert
            Assert.Same(exceptionInfo, expectedExceptionInfo);
        }

        [Fact]
        public void ExceptionLogger_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo();
            IExceptionLogger expectedLogger = CreateDummyLogger();
            IExceptionHandler handler = CreateDummyHandler();
            HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, expectedLogger, handler);

            // Act
            IExceptionLogger logger = product.ExceptionLogger;

            // Assert
            Assert.Same(expectedLogger, logger);
        }

        [Fact]
        public void ExceptionHandler_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo();
            IExceptionLogger logger = CreateDummyLogger();
            IExceptionHandler expectedHandler = CreateDummyHandler();
            HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, expectedHandler);

            // Act
            IExceptionHandler handler = product.ExceptionHandler;

            // Assert
            Assert.Same(expectedHandler, handler);
        }

        [Fact]
        public void ExceptionInfo_IfUsingExceptionInfoConstructor_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionDispatchInfo expectedExceptionInfo = CreateExceptionInfo();
            HttpRouteExceptionHandler product = CreateProductUnderTest(expectedExceptionInfo);

            // Act
            ExceptionDispatchInfo exceptionInfo = product.ExceptionInfo;

            // Assert
            Assert.Same(exceptionInfo, expectedExceptionInfo);
        }

        [Fact]
        public void ExceptionLogger_IfUsingExceptionInfoConstructor_ReturnsExceptionServicesInstance()
        {
            // Arrange
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo();
            HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo);

            // Act
            IExceptionLogger logger = product.ExceptionLogger;

            // Assert
            IExceptionLogger expectedLogger = ExceptionServices.GetLogger(GlobalConfiguration.Configuration);
            Assert.Same(expectedLogger, logger);
        }

        [Fact]
        public void ExceptionHandler_IfUsingExceptionInfoConstructor_ReturnsExceptionServicesInstance()
        {
            // Arrange
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo();
            HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo);

            // Act
            IExceptionHandler handler = product.ExceptionHandler;

            // Assert
            IExceptionHandler expectedHandler = ExceptionServices.GetHandler(GlobalConfiguration.Configuration);
            Assert.Same(expectedHandler, handler);
        }

        [Fact]
        public async Task ProcessRequestAsync_IfExceptionIsHttpResponseException_UsesExceptionResponse()
        {
            // Arrange
            HttpStatusCode expectedStatusCode = HttpStatusCode.Forbidden;

            using (HttpResponseMessage response = CreateResponse(expectedStatusCode))
            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(new HttpResponseException(response));
                IExceptionLogger logger = CreateDummyLogger();
                IExceptionHandler handler = CreateDummyHandler();

                HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

                int statusCode = 0;
                Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>();
                responseBaseMock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((s) => statusCode = s);
                responseBaseMock.SetupGet(r => r.Cache).Returns(() => new Mock<HttpCachePolicyBase>().Object);
                HttpResponseBase responseBase = responseBaseMock.Object;
                HttpContextBase contextBase = CreateStubContextBase(responseBase);
                contextBase.SetHttpRequestMessage(request);

                // Act
                await product.ProcessRequestAsync(contextBase);

                // Assert
                Assert.Equal((int)expectedStatusCode, statusCode);
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_IfExceptionIsNotHttpResponseException_CallsExceptionServices()
        {
            // Arrange
            Exception expectedException = CreateException();
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(expectedException);

            Mock<IExceptionLogger> loggerMock = CreateStubExceptionLoggerMock();
            IExceptionLogger logger = loggerMock.Object;
            Mock<IExceptionHandler> handlerMock = CreateStubExceptionHandlerMock();
            IExceptionHandler handler = handlerMock.Object;

            HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

            HttpResponseBase responseBase = CreateStubResponseBase();
            HttpContextBase contextBase = CreateStubContextBase(responseBase);

            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            {
                contextBase.SetHttpRequestMessage(expectedRequest);

                // Act & Assert
                await Assert.ThrowsAsync<Exception>(() => product.ProcessRequestAsync(contextBase));

                Func<ExceptionContext, bool> exceptionContextMatches = (c) =>
                    c != null
                    && c.Exception == expectedException
                    && c.CatchBlock == WebHostExceptionCatchBlocks.HttpWebRoute
                    && c.Request == expectedRequest;

                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    exceptionContextMatches(c.ExceptionContext)), CancellationToken.None), Times.Once());
                handlerMock.Verify(l => l.HandleAsync(It.Is<ExceptionHandlerContext>(c =>
                    exceptionContextMatches(c.ExceptionContext)), CancellationToken.None), Times.Once());
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_IfHandlerHandles_UsesHandlerResult()
        {
            // Arrange
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo();

            IExceptionLogger logger = CreateStubExceptionLogger();

            HttpStatusCode expectedStatusCode = HttpStatusCode.Ambiguous;
            Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            handlerMock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                {
                    c.Result = new StatusCodeResult(expectedStatusCode, new HttpRequestMessage());
                    return Task.FromResult(0);
                });
            IExceptionHandler handler = handlerMock.Object;

            HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

            int statusCode = 0;
            Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>();
            responseBaseMock.SetupSet(r => r.StatusCode = It.IsAny<int>()).Callback<int>((c) => statusCode = c);
            responseBaseMock.SetupGet(r => r.Cache).Returns(() => new Mock<HttpCachePolicyBase>().Object);
            HttpResponseBase responseBase = responseBaseMock.Object;
            HttpContextBase contextBase = CreateStubContextBase(responseBase);
            using (HttpRequestMessage request = CreateRequest())
            {
                contextBase.SetHttpRequestMessage(request);

                // Act
                await product.ProcessRequestAsync(contextBase);

                // Assert
                Assert.Equal((int)expectedStatusCode, statusCode);
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_IfHandlerDoesNotHandle_ReturnsTaskPropagatingException()
        {
            // Arrange
            Exception expectedException = CreateExceptionWithCallStack();
            string expectedStackTrace = expectedException.StackTrace;
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(expectedException);

            IExceptionLogger logger = CreateStubExceptionLogger();
            IExceptionHandler handler = CreateStubExceptionHandler();

            HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

            HttpResponseBase responseBase = CreateStubResponseBase();
            HttpContextBase contextBase = CreateStubContextBase(responseBase);

            using (HttpRequestMessage request = CreateRequest())
            {
                contextBase.SetHttpRequestMessage(request);

                // Act & Assert
                var exception = await Assert.ThrowsAsync<Exception>(() => product.ProcessRequestAsync(contextBase));

                Assert.Same(expectedException, exception);
                Assert.NotNull(exception.StackTrace);
                Assert.StartsWith(expectedStackTrace, exception.StackTrace);
            }

        }

        [Fact]
        public async Task ProcessRequestAsync_IfCopyToAsyncOnErrorResponseThrows_CallsExceptionLogger()
        {
            // Arrange
            Exception expectedOriginalException = CreateException();
            ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(expectedOriginalException);

            Mock<IExceptionLogger> loggerMock = CreateStubExceptionLoggerMock();
            IExceptionLogger logger = loggerMock.Object;

            Exception expectedErrorException = CreateException();

            using (HttpResponseMessage expectedErrorResponse = new HttpResponseMessage())
            using (HttpRequestMessage expectedRequest = new HttpRequestMessage())
            {
                expectedErrorResponse.Content = CreateFaultingContent(expectedErrorException);

                Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                handlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Returns<ExceptionHandlerContext, CancellationToken>((c, i) =>
                    {
                        c.Result = new ResponseMessageResult(expectedErrorResponse);
                        return Task.FromResult(0);
                    });
                IExceptionHandler handler = handlerMock.Object;

                HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

                HttpResponseBase responseBase = CreateStubResponseBase(Stream.Null);
                HttpContextBase contextBase = CreateStubContextBase(responseBase);
                contextBase.SetHttpRequestMessage(expectedRequest);

                // Act
                await product.ProcessRequestAsync(contextBase);

                // Assert
                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedOriginalException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpWebRoute
                    && c.ExceptionContext.Request == expectedRequest),
                    CancellationToken.None), Times.Once());
                loggerMock.Verify(l => l.LogAsync(It.Is<ExceptionLoggerContext>(c =>
                    c.ExceptionContext != null
                    && c.ExceptionContext.Exception == expectedErrorException
                    && c.ExceptionContext.CatchBlock == WebHostExceptionCatchBlocks.HttpControllerHandlerBufferError
                    && c.ExceptionContext.Request == expectedRequest
                    && c.ExceptionContext.Response == expectedErrorResponse),
                    CancellationToken.None), Times.Once());
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_IfExceptionIsHttpResponseException_DisposesRequestAndResponse()
        {
            // Arrange
            using (HttpResponseMessage response = CreateResponse())
            using (HttpRequestMessage request = CreateRequest())
            using (SpyDisposable spy = new SpyDisposable())
            {
                request.RegisterForDispose(spy);

                ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(new HttpResponseException(response));
                IExceptionLogger logger = CreateDummyLogger();
                IExceptionHandler handler = CreateDummyHandler();

                HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

                Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>();
                responseBaseMock.SetupGet(r => r.Cache).Returns(() => new Mock<HttpCachePolicyBase>().Object);
                HttpResponseBase responseBase = responseBaseMock.Object;
                HttpContextBase contextBase = CreateStubContextBase(responseBase);
                contextBase.SetHttpRequestMessage(request);

                // Act
                await product.ProcessRequestAsync(contextBase);

                // Assert
                Assert.True(spy.Disposed);
                Assert.ThrowsObjectDisposed(() => request.Method = HttpMethod.Get,
                    typeof(HttpRequestMessage).FullName);
                Assert.ThrowsObjectDisposed(() => response.StatusCode = HttpStatusCode.OK,
                    typeof(HttpResponseMessage).FullName);
            }
        }

        [Fact]
        public async Task ProcessRequestAsync_IfExceptionIsNotHttpResponseException_DisposesRequest()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            using (SpyDisposable spy = new SpyDisposable())
            {
                request.RegisterForDispose(spy);

                ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(CreateException());
                Mock<IExceptionLogger> loggerMock = new Mock<IExceptionLogger>(MockBehavior.Strict);
                loggerMock
                    .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                    .Returns(Task.FromResult(0));
                Mock<IExceptionHandler> handlerMock = new Mock<IExceptionHandler>(MockBehavior.Strict);
                handlerMock
                    .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                    .Returns(Task.FromResult(0));

                HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, loggerMock.Object, handlerMock.Object);

                Mock<HttpResponseBase> responseBaseMock = new Mock<HttpResponseBase>();
                responseBaseMock.SetupGet(r => r.Cache).Returns(() => new Mock<HttpCachePolicyBase>().Object);
                HttpResponseBase responseBase = responseBaseMock.Object;
                HttpContextBase contextBase = CreateStubContextBase(responseBase);
                contextBase.SetHttpRequestMessage(request);

                // Act & Assert
                await Assert.ThrowsAsync<Exception>(() => product.ProcessRequestAsync(contextBase));

                Assert.True(spy.Disposed);
                Assert.ThrowsObjectDisposed(() => request.Method = HttpMethod.Get,
                    typeof(HttpRequestMessage).FullName);
            }
        }

        // This scenario emulates what would happen if a route throws OperationCanceledException.
        [Fact]
        public async Task ProcessRequestAsync_RouteCanceled_CancelsRequest()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(new OperationCanceledException());
                IExceptionLogger logger = CreateDummyLogger();
                IExceptionHandler handler = CreateDummyHandler();

                HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

                Mock<HttpRequestBase> requestBase = new Mock<HttpRequestBase>(MockBehavior.Strict);
                requestBase.Setup(r => r.Abort()).Verifiable();

                Mock<HttpResponseBase> responseBase = new Mock<HttpResponseBase>(MockBehavior.Strict);

                HttpContextBase contextBase = CreateStubContextBase(requestBase.Object, responseBase.Object);
                contextBase.SetHttpRequestMessage(request);

                // Act
                await product.ProcessRequestAsync(contextBase);

                // Assert
                requestBase.Verify(r => r.Abort(), Times.Once());
            }
        }

        // This scenario emulates what would happen if the request is canceled while trying to handle an http response exception
        // thrown by routing.
        [Fact]
        public async Task ProcessRequestAsync_WritingResponseCanceled_CancelsRequest()
        {
            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionDispatchInfo exceptionInfo = CreateExceptionInfo(new HttpResponseException(HttpStatusCode.OK));
                IExceptionLogger logger = CreateDummyLogger();
                IExceptionHandler handler = CreateDummyHandler();

                HttpRouteExceptionHandler product = CreateProductUnderTest(exceptionInfo, logger, handler);

                Mock<HttpRequestBase> requestBase = new Mock<HttpRequestBase>(MockBehavior.Strict);
                requestBase.Setup(r => r.Abort()).Verifiable();

                Mock<HttpResponseBase> responseBase = new Mock<HttpResponseBase>(MockBehavior.Strict);
                responseBase.SetupSet(r => r.StatusCode = It.IsAny<int>()).Throws(new OperationCanceledException());

                HttpContextBase contextBase = CreateStubContextBase(requestBase.Object, responseBase.Object);
                contextBase.SetHttpRequestMessage(request);

                // Act
                await product.ProcessRequestAsync(contextBase);

                // Assert
                requestBase.Verify(r => r.Abort(), Times.Once());
            }
        }

        private static IExceptionHandler CreateDummyHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IExceptionLogger CreateDummyLogger()
        {
            return new Mock<IExceptionLogger>(MockBehavior.Strict).Object;
        }

        private static Exception CreateException()
        {
            return new Exception();
        }

        private static Exception CreateExceptionWithCallStack()
        {
            try
            {
                throw CreateException();
            }
            catch (Exception exception)
            {
                return exception;
            }
        }

        private static ExceptionDispatchInfo CreateExceptionInfo()
        {
            return CreateExceptionInfo(CreateException());
        }

        private static ExceptionDispatchInfo CreateExceptionInfo(Exception exception)
        {
            return ExceptionDispatchInfo.Capture(exception);
        }

        private static HttpContent CreateFaultingContent(Exception exception)
        {
            return new FaultingHttpContent(exception);
        }

        private static HttpRouteExceptionHandler CreateProductUnderTest(ExceptionDispatchInfo exceptionInfo)
        {
            return new HttpRouteExceptionHandler(exceptionInfo);
        }

        private static HttpRouteExceptionHandler CreateProductUnderTest(ExceptionDispatchInfo exceptionInfo,
            IExceptionLogger exceptionLogger, IExceptionHandler exceptionHandler)
        {
            return new HttpRouteExceptionHandler(exceptionInfo, exceptionLogger, exceptionHandler);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static HttpResponseMessage CreateResponse(HttpStatusCode statusCode)
        {
            return new HttpResponseMessage(statusCode);
        }

        private static HttpContextBase CreateStubContextBase(HttpResponseBase response)
        {
            return CreateStubContextBase(request: null, response: response);
        }

        private static HttpContextBase CreateStubContextBase(HttpRequestBase request, HttpResponseBase response)
        {
            Mock<HttpContextBase> mock = new Mock<HttpContextBase>();
            mock.SetupGet(m => m.Request).Returns(request);
            mock.SetupGet(m => m.Response).Returns(response);

            IDictionary items = new Dictionary<object, object>();
            mock.SetupGet(m => m.Items).Returns(items);

            return mock.Object;
        }

        private static IExceptionHandler CreateStubExceptionHandler()
        {
            return CreateStubExceptionHandlerMock().Object;
        }

        private static Mock<IExceptionHandler> CreateStubExceptionHandlerMock()
        {
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>(MockBehavior.Strict);
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static IExceptionLogger CreateStubExceptionLogger()
        {
            return CreateStubExceptionLoggerMock().Object;
        }

        private static Mock<IExceptionLogger> CreateStubExceptionLoggerMock()
        {
            Mock<IExceptionLogger> mock = new Mock<IExceptionLogger>(MockBehavior.Strict);
            mock
                .Setup(l => l.LogAsync(It.IsAny<ExceptionLoggerContext>(), It.IsAny<CancellationToken>()))
                .Returns(Task.FromResult(0));
            return mock;
        }

        private static HttpResponseBase CreateStubResponseBase()
        {
            return new Mock<HttpResponseBase>().Object;
        }

        private static HttpResponseBase CreateStubResponseBase(Stream outputStream)
        {
            Mock<HttpResponseBase> mock = new Mock<HttpResponseBase>();
            mock.Setup(r => r.OutputStream).Returns(outputStream);
            return mock.Object;
        }

        private class FaultingHttpContent : HttpContent
        {
            private readonly Exception _exception;

            public FaultingHttpContent(Exception exception)
            {
                Contract.Assert(exception != null);
                _exception = exception;
            }

            protected override Task SerializeToStreamAsync(Stream stream, TransportContext context)
            {
                return CreateFaultedTask(_exception);
            }

            protected override bool TryComputeLength(out long length)
            {
                length = 0;
                return false;
            }

            private static Task CreateFaultedTask(Exception exception)
            {
                TaskCompletionSource<object> source = new TaskCompletionSource<object>();
                source.SetException(exception);
                return source.Task;
            }
        }

        private sealed class SpyDisposable : IDisposable
        {
            public bool Disposed { get; private set; }

            public void Dispose()
            {
                Disposed = true;
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Routing/HttpRouteExceptionRouteHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Runtime.ExceptionServices;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Http.WebHost.Routing
{
    public class HttpRouteExceptionRouteHandlerTests
    {
        [Fact]
        public void ExceptionInfo_ReturnsSpecifiedInstance()
        {
            // Arrange
            ExceptionDispatchInfo expectedExceptionInfo = CreateExceptionInfo();
            HttpRouteExceptionRouteHandler product = CreateProductUnderTest(expectedExceptionInfo);

            // Act
            ExceptionDispatchInfo exceptionInfo = product.ExceptionInfo;

            // Assert
            Assert.Same(exceptionInfo, expectedExceptionInfo);
        }

        [Fact]
        public void GetHttpHandler_ReturnsExceptionHandlerWithExceptionInfo()
        {
            // Arrange
            ExceptionDispatchInfo expectedExceptionInfo = CreateExceptionInfo();
            IRouteHandler product = CreateProductUnderTest(expectedExceptionInfo);
            RequestContext requestContext = null;

            // Act
            IHttpHandler handler = product.GetHttpHandler(requestContext);

            // Assert
            HttpRouteExceptionHandler typedHandler = Assert.IsType<HttpRouteExceptionHandler>(handler);
            Assert.Same(expectedExceptionInfo, typedHandler.ExceptionInfo);
        }

        private static ExceptionDispatchInfo CreateExceptionInfo()
        {
            return ExceptionDispatchInfo.Capture(new Exception());
        }

        private static HttpRouteExceptionRouteHandler CreateProductUnderTest(ExceptionDispatchInfo exceptionInfo)
        {
            return new HttpRouteExceptionRouteHandler(exceptionInfo);
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/Routing/HttpWebRouteTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Net.Http;
using System.Runtime.ExceptionServices;
using System.Web.Http.Routing;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.WebHost.Routing
{
    public class HttpWebRouteTests
    {
        [Fact]
        public void GetRouteData_IfHttpRouteGetRouteDataThrows_RoutesToExceptionHandler()
        {
            // Arrange
            Exception expectedException = CreateException();
            IHttpRoute route = CreateThrowingRoute(expectedException);

            HttpWebRoute product = CreateProductUnderTest(route);

            HttpRequestBase requestBase = CreateStubRequestBase("GET");
            HttpContextBase contextBase = CreateStubContextBase(requestBase);

            using (HttpRequestMessage request = CreateRequest())
            {
                contextBase.SetHttpRequestMessage(request);

                // Act
                RouteData routeData = product.GetRouteData(contextBase);

                // Assert
                Assert.NotNull(routeData);
                Assert.Same(product, routeData.Route);
                HttpRouteExceptionRouteHandler typedHandler = Assert.IsType<HttpRouteExceptionRouteHandler>(routeData.RouteHandler);
                ExceptionDispatchInfo exceptionInfo = typedHandler.ExceptionInfo;
                Assert.NotNull(exceptionInfo); // Guard
                Assert.Same(expectedException, exceptionInfo.SourceException);
            }
        }

        private static Exception CreateException()
        {
            return new NotFiniteNumberException();
        }

        private static HttpWebRoute CreateProductUnderTest(IHttpRoute httpRoute)
        {
            return new HttpWebRoute(null, null, null, null, null, httpRoute);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpContextBase CreateStubContextBase(HttpRequestBase request)
        {
            Mock<HttpContextBase> mock = new Mock<HttpContextBase>();
            mock.SetupGet(m => m.Request).Returns(request);
            IDictionary items = new Dictionary<object, object>();
            mock.SetupGet(m => m.Items).Returns(items);
            return mock.Object;
        }

        private static HttpRequestBase CreateStubRequestBase(string httpMethod)
        {
            return new Mock<HttpRequestBase>().Object;
        }

        private static IHttpRoute CreateThrowingRoute(Exception exception)
        {
            Mock<IHttpRoute> mock = new Mock<IHttpRoute>(MockBehavior.Strict);
            mock
                .Setup(m => m.GetRouteData(It.IsAny<string>(), It.IsAny<HttpRequestMessage>()))
                .Throws(exception);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/SeekableBufferedRequestStreamTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.WebHost
{
    public class SeekableBufferedRequestStreamTest
    {
        private const string Content = "Hello, World!";

        /// <summary>
        /// Chosen to require multiple reads.
        /// </summary>
        private const int BufferSize = 3;

        [Fact]
        public void ReadToEnd_WithRead_SwapsStreams()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            // Act
            byte[] buffer = new byte[BufferSize];
            while (stream.Read(buffer, 0, buffer.Length) > 0)
            {
                // Guard
                Assert.Same(nonSeekable, stream.InnerStream);
            }

            // Assert
            Assert.Same(seekable, stream.InnerStream);
        }

        [Fact]
        public void ReadToEnd_WithBeginRead_SwapsStreams()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            // Act
            byte[] buffer = new byte[BufferSize];
            while (stream.EndRead(stream.BeginRead(buffer, 0, buffer.Length, null, null)) > 0)
            {
                // Guard
                Assert.Same(nonSeekable, stream.InnerStream);
            }

            // Assert
            Assert.Same(seekable, stream.InnerStream);
        }

        [Fact]
        public async Task ReadToEnd_WithReadAsync_SwapsStreams()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            // Act
            byte[] buffer = new byte[BufferSize];
            while (await stream.ReadAsync(buffer, 0, buffer.Length) > 0)
            {
                // Guard
                Assert.Same(nonSeekable, stream.InnerStream);
            }

            // Assert
            Assert.Same(seekable, stream.InnerStream);
        }

        [Fact]
        public void ReadToEnd_WithReadByte_SwapsStreams()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            // Act
            while (stream.ReadByte() > 0)
            {
                // Guard
                Assert.Same(nonSeekable, stream.InnerStream);
            }

            // Assert
            Assert.Same(seekable, stream.InnerStream);
        }

        [Fact]
        public void SwapStream_PreservesPosition()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            stream.ReadByte();

            // Guard
            Assert.Same(nonSeekable, stream.InnerStream);
            Assert.Equal(1L, stream.Position);

            stream.Seek(2L, SeekOrigin.Begin);

            // Assert
            Assert.Equal(2L, stream.Position);
            Assert.Same(seekable, stream.InnerStream);
        }

        [Fact]
        public void Seek_SwapsStreams()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            // Guard
            Assert.Same(nonSeekable, stream.InnerStream);

            // Act
            stream.Seek(1L, SeekOrigin.Begin);

            // Assert
            Assert.Same(seekable, stream.InnerStream);
        }

        [Fact]
        public void Seek_NoOpBegin()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            for (int i = 0; i < 3; i++)
            {
                stream.ReadByte();
            }

            // Act
            stream.Seek(3L, SeekOrigin.Begin);

            // Assert
            Assert.Same(nonSeekable, stream.InnerStream);
        }

        [Fact]
        public void Seek_NoOpCurent()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            for (int i = 0; i < 3; i++)
            {
                stream.ReadByte();
            }

            // Act
            stream.Seek(0L, SeekOrigin.Current);

            // Assert
            Assert.Same(nonSeekable, stream.InnerStream);
        }

        [Fact]
        public void Seek_NoOpEnd()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            for (int i = 0; i < 3; i++)
            {
                stream.ReadByte();
            }

            // Act
            stream.Seek(stream.Position - stream.Length, SeekOrigin.End);

            // Assert
            Assert.Same(nonSeekable, stream.InnerStream);
        }

        [Fact]
        public void Dispose_DoesNotDisposeInnerStreams()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            // Act
            stream.Dispose();

            // Assert
            Assert.False(stream.CanRead);
            Assert.True(nonSeekable.CanRead);
            Assert.True(seekable.CanRead);
        }

        [Fact]
        public void Seek_ThrowsOnInvalidSeekOrigin()
        {
            // Arrange
            var nonSeekable = CreateNonSeekableStream(Content);
            var seekable = CreateSeekableStream(Content);
            var stream = CreateStream(nonSeekable, seekable);

            var origin = (SeekOrigin)5;

            var message = 
                "The value of argument 'origin' (" + (int)origin + ") is invalid for Enum type " +
                "'SeekOrigin'." + Environment.NewLine +
                "Parameter name: origin";

            // Act & Assert
            Assert.Throws<InvalidEnumArgumentException>(() => stream.Seek(0L, origin), message);
        }

        private Stream CreateSeekableStream(string content)
        {
            return new MemoryStream(Encoding.UTF8.GetBytes(content));
        }

        private Stream CreateNonSeekableStream(string content)
        {
            return new NonSeekableStream(Encoding.UTF8.GetBytes(content));
        }

        private AccessibleStreamWrapper CreateStream(Stream stream1, Stream stream2)
        {
            // Guards
            Assert.False(stream1.CanSeek);
            Assert.True(stream2.CanSeek);

            var request = new Mock<HttpRequestBase>();
            request.Setup(r => r.GetBufferedInputStream()).Returns(stream1);
            request.SetupGet(r => r.InputStream).Returns(stream2);

            return new AccessibleStreamWrapper(request.Object);
        }

        private class AccessibleStreamWrapper : SeekableBufferedRequestStream
        {
            public AccessibleStreamWrapper(HttpRequestBase request)
                : base(request)
            {
            }

            public new Stream InnerStream
            {
                get
                {
                    return base.InnerStream;
                }
            }
        }

        private class NonSeekableStream : MemoryStream
        {
            public NonSeekableStream()
            {
            }

            public NonSeekableStream(byte[] bytes)
                : base(bytes)
            {
            }

            public override bool CanSeek
            {
                get
                {
                    return false;
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/SuppressFormsAuthRedirectHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Http.WebHost
{
    public class SuppressFormsAuthRedirectHelperTest
    {
        [Theory]
        [InlineData("false", false)]
        [InlineData("true", true)]
        [InlineData("", true)]
        [InlineData("foo", true)]
        public void GetDisabled_ParsesAppSettings(string setting, bool expected)
        {
            Assert.Equal(expected, SuppressFormsAuthRedirectHelper.GetEnabled(new NameValueCollection() { { SuppressFormsAuthRedirectHelper.AppSettingsSuppressFormsAuthenticationRedirectKey, setting } }));
        }

        [Fact]
        public void PreApplicationStartCode_IsValid()
        {
#pragma warning disable 0618 // System.Web.Http.WebHost.PreApplicationStartCode is obsolete
            Type preApplicationStartType = typeof(PreApplicationStartCode);
#pragma warning restore
            PreAppStartTestHelper.TestPreAppStartClass(preApplicationStartType);
            object[] attrs = preApplicationStartType.GetCustomAttributes(typeof(ObsoleteAttribute), true);
            Assert.Single(attrs);
        }
    }
}

================================================
FILE: test/System.Web.Http.WebHost.Test/System.Web.Http.WebHost.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{EA62944F-BD25-4730-9405-9BE8FF5BEACD}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Http.WebHost</RootNamespace>
    <AssemblyName>System.Web.Http.WebHost.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Web" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="BatchingTest.cs" />
    <Compile Include="Routing\HttpRouteExceptionHandlerTests.cs" />
    <Compile Include="Routing\HttpRouteExceptionRouteHandlerTests.cs" />
    <Compile Include="Routing\HttpWebRouteTests.cs" />
    <Compile Include="SeekableBufferedRequestStreamTest.cs" />
    <Compile Include="WebHostExceptionCatchBlocksTests.cs" />
    <Compile Include="WebHostExceptionHandlerTests.cs" />
    <Compile Include="WebHostHttpRequestContextTests.cs" />
    <Compile Include="GlobalConfigurationTest.cs" />
    <Compile Include="HttpRequestMessageExtensions.cs" />
    <Compile Include="Routing\HttpContextBaseExtensionsTest.cs" />
    <Compile Include="Routing\HttpRequestMessageWrapperTest.cs" />
    <Compile Include="Routing\HostedHttpRouteCollectionTest.cs" />
    <Compile Include="WebHostBufferPolicySelectorTest.cs" />
    <Compile Include="HttpControllerHandlerTest.cs" />
    <Compile Include="RouteCollectionExtensionsTest.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Routing\HostedUrlHelperTest.cs" />
    <Compile Include="SuppressFormsAuthRedirectHelperTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668E9021-CE84-49D9-98FB-DF125A9FCDB0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.Owin\System.Web.Http.Owin.csproj">
      <Project>{66dd7cd7-c68f-4d0e-9f3d-3b58c49d1467}</Project>
      <Name>System.Web.Http.Owin</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.WebHost\System.Web.Http.WebHost.csproj">
      <Project>{A0187BC2-8325-4BB2-8697-7F955CF4173E}</Project>
      <Name>System.Web.Http.WebHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3D3FFD8A-624D-4E9B-954B-E1C105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Http.WebHost.Test/WebHostBufferPolicySelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.WebHost
{
    public class WebHostBufferPolicySelectorTest
    {
        private const string testString = "testString";

        public static TheoryDataSet<HttpContent, bool> OutputBufferingTestData
        {
            get
            {
                Mock<Stream> mockStream = new Mock<Stream>() { CallBase = true };
                return new TheoryDataSet<HttpContent, bool>()
                {
                    // Known length HttpContents other than OC should not buffer
                    { new StringContent(testString), false },
                    { new ByteArrayContent(Encoding.UTF8.GetBytes(testString)), false },
                    { new StreamContent(new MemoryStream(Encoding.UTF8.GetBytes(testString))), false },

                    // StreamContent (unknown length) should not buffer
                    { new StreamContent(mockStream.Object), false },

                    // PushStreamContent (unknown length) should not buffer
                    { new PushStreamContent((stream, headers, context) => {}), false },

                    // ObjectContent (unknown length) should buffer
                    { new ObjectContent<string>(testString, new XmlMediaTypeFormatter()), true }
                };
            }
        }

        public static TheoryDataSet<HttpContent> OutputBufferingTestData_NoExpectedResult
        {
            get
            {
                var dataSet = new TheoryDataSet<HttpContent>();
                foreach (var item in OutputBufferingTestData)
                {
                    dataSet.Add((HttpContent)item[0]);
                }

                return dataSet;
            }
        }

        [Fact]
        void UseBufferedInputStream_Returns_True()
        {
            // Arrange
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>() { CallBase = true };

            // Act & Assert
            Assert.True(new WebHostBufferPolicySelector().UseBufferedInputStream(mockContext.Object));
        }

        [Fact]
        void UseBufferedInputStream_ThrowsOnNull()
        {
            WebHostBufferPolicySelector selector = new WebHostBufferPolicySelector();
            Assert.ThrowsArgumentNull(() => selector.UseBufferedInputStream(null), "hostContext");
        }

        [Fact]
        void UseBufferedInputStream_Can_Be_Overridden()
        {
            // Arrange
            Mock<WebHostBufferPolicySelector> mockSelector = new Mock<WebHostBufferPolicySelector>();
            mockSelector.Setup((w) => w.UseBufferedInputStream(It.IsAny<HttpContextBase>())).Returns(false);
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>() { CallBase = true };

            // Act & Assert
            Assert.False(mockSelector.Object.UseBufferedInputStream(mockContext.Object));
        }

        [Fact]
        public void UseBufferedOutputStream_ThrowsOnNull()
        {
            WebHostBufferPolicySelector selector = new WebHostBufferPolicySelector();
            Assert.ThrowsArgumentNull(() => selector.UseBufferedOutputStream(null), "response");
        }

        [Theory]
        [PropertyData("OutputBufferingTestData")]
        public void UseBufferedOutputStream_ReturnsCorrectValue(HttpContent content, bool expectedResult)
        {
            // Arrange
            WebHostBufferPolicySelector selector = new WebHostBufferPolicySelector();
            HttpResponseMessage response = new HttpResponseMessage();
            response.Content = content;

            // Act
            bool actualResult = selector.UseBufferedOutputStream(response);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }

        [Theory]
        [PropertyData("OutputBufferingTestData_NoExpectedResult")]
        public void UseBufferedOutputStream_CausesContentLengthHeaderToBeSet(HttpContent content)
        {
            // Arrange & Act
            WebHostBufferPolicySelector selector = new WebHostBufferPolicySelector();
            HttpResponseMessage response = new HttpResponseMessage();
            response.Content = content;

            selector.UseBufferedOutputStream(response);

            IEnumerable<string> contentLengthEnumerable;
            bool isContentLengthInHeaders = content.Headers.TryGetValues("Content-Length", out contentLengthEnumerable);
            string[] contentLengthStrings = isContentLengthInHeaders ? contentLengthEnumerable.ToArray() : new string[0];
            long? contentLength = content.Headers.ContentLength;

            // Assert
            if (contentLength.HasValue && contentLength.Value >= 0)
            {
                // Setting the header is HttpContentHeader's responsibility, but we assert
                // it has happened here because it is UseBufferedOutputStream's responsibility
                // to cause that to happen. HttpControllerHandler relies on this.
                Assert.True(isContentLengthInHeaders);
                Assert.Equal(contentLength.Value, long.Parse(contentLengthStrings[0]));
            }
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/WebHostExceptionCatchBlocksTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http.ExceptionHandling;
using Microsoft.TestCommon;

namespace System.Web.Http.WebHost
{
    public class WebHostExceptionCatchBlocksTests
    {
        [Fact]
        public void HttpControllerHandlerBufferContent_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpControllerHandler.BufferContent", isTopLevel: true,
                    callsHandler: true);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpControllerHandlerBufferContent_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent;

            // Act
            ExceptionContextCatchBlock second = WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpControllerHandlerBufferError_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = WebHostExceptionCatchBlocks.HttpControllerHandlerBufferError;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpControllerHandler.BufferError", isTopLevel: true,
                    callsHandler: false);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpControllerHandlerBufferError_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = WebHostExceptionCatchBlocks.HttpControllerHandlerBufferError;

            // Act
            ExceptionContextCatchBlock second = WebHostExceptionCatchBlocks.HttpControllerHandlerBufferError;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpControllerHandlerComputeContentLength_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = WebHostExceptionCatchBlocks.HttpControllerHandlerComputeContentLength;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpControllerHandler.ComputeContentLength", isTopLevel: true,
                    callsHandler: false);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpControllerHandlerComputeContentLength_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = WebHostExceptionCatchBlocks.HttpControllerHandlerComputeContentLength;

            // Act
            ExceptionContextCatchBlock second = WebHostExceptionCatchBlocks.HttpControllerHandlerComputeContentLength;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpControllerHandlerStreamContent_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = WebHostExceptionCatchBlocks.HttpControllerHandlerStreamContent;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpControllerHandler.StreamContent", isTopLevel: true,
                    callsHandler: false);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpControllerHandlerStreamContent_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = WebHostExceptionCatchBlocks.HttpControllerHandlerStreamContent;

            // Act
            ExceptionContextCatchBlock second = WebHostExceptionCatchBlocks.HttpControllerHandlerStreamContent;

            // Assert
            Assert.Same(first, second);
        }

        [Fact]
        public void HttpWebRoute_IsSpecifiedValue()
        {
            // Act
            ExceptionContextCatchBlock catchBlock = WebHostExceptionCatchBlocks.HttpWebRoute;

            // Assert
            ExceptionContextCatchBlock expected =
                new ExceptionContextCatchBlock("HttpWebRoute", isTopLevel: true, callsHandler: true);
            AssertEqual(expected, catchBlock);
        }

        [Fact]
        public void HttpWebRoute_IsSameInstance()
        {
            // Arrange
            ExceptionContextCatchBlock first = WebHostExceptionCatchBlocks.HttpWebRoute;

            // Act
            ExceptionContextCatchBlock second = WebHostExceptionCatchBlocks.HttpWebRoute;

            // Assert
            Assert.Same(first, second);
        }

        private static void AssertEqual(ExceptionContextCatchBlock expected, ExceptionContextCatchBlock actual)
        {
            if (expected == null)
            {
                Assert.Null(actual);
                return;
            }

            Assert.NotNull(actual);
            Assert.Equal(expected.Name, actual.Name);
            Assert.Equal(expected.IsTopLevel, actual.IsTopLevel);
            Assert.Equal(expected.CallsHandler, actual.CallsHandler);
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/WebHostExceptionHandlerTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Http.Controllers;
using System.Web.Http.ExceptionHandling;
using System.Web.Http.Results;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.WebHost
{
    public class WebHostExceptionHandlerTests
    {
        [Fact]
        public void InnerHandler_IsSpecifiedInstance()
        {
            // Arrange
            IExceptionHandler expectedHandler = CreateDummyHandler();
            WebHostExceptionHandler product = CreateProductUnderTest(expectedHandler);

            // Act
            IExceptionHandler handler = product.InnerHandler;

            // Assert
            Assert.Same(expectedHandler, handler);
        }

        [Fact]
        public void HandleAsync_DelegatesToInnerHandler()
        {
            // Arrange
            Task expectedTask = CreateTask();
            Mock<IExceptionHandler> mock = new Mock<IExceptionHandler>();
            mock
                .Setup(h => h.HandleAsync(It.IsAny<ExceptionHandlerContext>(), It.IsAny<CancellationToken>()))
                .Returns(expectedTask);
            IExceptionHandler innerHandler = mock.Object;

            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            ExceptionHandlerContext expectedContext = CreateContext();

            using (CancellationTokenSource tokenSource = CreateCancellationTokenSource())
            {
                CancellationToken expectedCancellationToken = tokenSource.Token;

                // Act
                Task task = product.HandleAsync(expectedContext, expectedCancellationToken);

                // Assert
                mock.Verify(h => h.HandleAsync(expectedContext, expectedCancellationToken), Times.Once());
                Assert.Same(expectedTask, task);
            }
        }

        [Fact]
        public void HandleAsync_IfContextIsNull_Throws()
        {
            // Arrange
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            ExceptionHandlerContext context = null;
            CancellationToken cancellationToken = CancellationToken.None;

            // Act & Assert
            Assert.ThrowsArgumentNull(() => product.HandleAsync(context, cancellationToken), "context");
        }

        [Fact]
        public async Task HandleAsync_IfCatchBlockIsWebHostBufferedContent_HandlesWithCustomException()
        {
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpResponseMessage originalResponse = CreateResponse())
            {
                originalResponse.Content = new StringContent("Error");
                originalResponse.Content.Headers.ContentType = new MediaTypeHeaderValue("text/plain");
                expectedRequest.SetRequestContext(new HttpRequestContext { IncludeErrorDetail = true });
                ExceptionHandlerContext context = CreateValidContext(expectedRequest,
                    WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
                context.ExceptionContext.Response = originalResponse;
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                IHttpActionResult result = context.Result;
                ResponseMessageResult typedResult = Assert.IsType<ResponseMessageResult>(result);

                using (HttpResponseMessage response = typedResult.Response)
                using (HttpResponseMessage expectedResponse = expectedRequest.CreateErrorResponse(
                    HttpStatusCode.InternalServerError, new InvalidOperationException("The 'StringContent' type " +
                        "failed to serialize the response body for content type 'text/plain'.",
                        context.ExceptionContext.Exception)))
                {
                    AssertErrorResponse(expectedResponse, response);
                }
            }
        }

        [Fact]
        public async Task HandleAsync_IfCatchBlockIsWebHostBufferedContent_WithoutContentType_HandlesWithCustomException()
        {
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpResponseMessage originalResponse = CreateResponse())
            {
                originalResponse.Content = new StringContent("Error");
                originalResponse.Content.Headers.ContentType = null;
                expectedRequest.SetRequestContext(new HttpRequestContext { IncludeErrorDetail = true });
                ExceptionHandlerContext context = CreateValidContext(expectedRequest,
                    WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
                context.ExceptionContext.Response = originalResponse;
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                IHttpActionResult result = context.Result;
                ResponseMessageResult typedResult = Assert.IsType<ResponseMessageResult>(result);

                using (HttpResponseMessage response = typedResult.Response)
                using (HttpResponseMessage expectedResponse = expectedRequest.CreateErrorResponse(
                    HttpStatusCode.InternalServerError, new InvalidOperationException(
                        "The 'StringContent' type failed to serialize the response body.",
                        context.ExceptionContext.Exception)))
                {
                    AssertErrorResponse(expectedResponse, response);
                }
            }
        }

        [Fact]
        public async Task HandleAsync_IfCatchBlockIsWebHostBufferedContent_WithFailedNegotiation_HandlesWithCustomException()
        {
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpResponseMessage originalResponse = CreateResponse())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                configuration.Formatters.Clear();

                originalResponse.Content = new StringContent("Error");
                expectedRequest.SetRequestContext(new HttpRequestContext
                {
                    IncludeErrorDetail = true,
                    Configuration = configuration
                });
                ExceptionHandlerContext context = CreateValidContext(expectedRequest,
                    WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
                context.ExceptionContext.Response = originalResponse;
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                IHttpActionResult result = context.Result;
                ResponseMessageResult typedResult = Assert.IsType<ResponseMessageResult>(result);
                using (HttpResponseMessage response = typedResult.Response)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    Assert.Null(response.Content);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public async Task HandleAsync_IfCatchBlockIsWebHostBufferedContent_WithCreateException_HandlesWithCustomException()
        {
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            // Arrange
            using (HttpRequestMessage expectedRequest = CreateRequest())
            using (HttpResponseMessage originalResponse = CreateResponse())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                configuration.Services.Clear(typeof(IContentNegotiator));

                originalResponse.Content = new StringContent("Error");
                expectedRequest.SetRequestContext(new HttpRequestContext
                {
                    IncludeErrorDetail = true,
                    Configuration = configuration
                });
                ExceptionHandlerContext context = CreateValidContext(expectedRequest,
                    WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
                context.ExceptionContext.Response = originalResponse;
                CancellationToken cancellationToken = CancellationToken.None;

                // Act
                await product.HandleAsync(context, cancellationToken);

                // Assert
                IHttpActionResult result = context.Result;
                ResponseMessageResult typedResult = Assert.IsType<ResponseMessageResult>(result);
                using (HttpResponseMessage response = typedResult.Response)
                {
                    Assert.NotNull(response);
                    Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
                    Assert.NotNull(response.Content);
                    Assert.Equal(0L, response.Content.Headers.ContentLength);
                    Assert.Same(expectedRequest, response.RequestMessage);
                }
            }
        }

        [Fact]
        public void HandleAsync_IfCatchBlockIsWebHostBufferedContent_AndRequestIsNull_Throws()
        {
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            // Arrange
            using (HttpResponseMessage response = CreateResponse())
            {
                ExceptionHandlerContext context = CreateContext(
                    CreateMinimalValidExceptionContext(WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent));

                Assert.Null(context.ExceptionContext.Request); // Guard
                CancellationToken cancellationToken = CancellationToken.None;

                // Act & Assert
                Assert.ThrowsArgument(() => product.HandleAsync(context, cancellationToken), "context",
                    "ExceptionContext.Request must not be null.");
            }
        }

        [Fact]
        public void HandleAsync_IfCatchBlockIsWebHostBufferedContent_AndResponseIsNull_Throws()
        {
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            // Arrange
            using (HttpRequestMessage request = CreateRequest())
            {
                ExceptionHandlerContext context = CreateValidContext(request,
                    WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
                Assert.Null(context.ExceptionContext.Response); // Guard
                CancellationToken cancellationToken = CancellationToken.None;

                // Act & Assert
                Assert.ThrowsArgument(() => product.HandleAsync(context, cancellationToken), "context",
                    "ExceptionContext.Response must not be null.");
            }
        }

        [Fact]
        public void HandleAsync_IfCatchBlockIsWebHostBufferedContent_AndResponseContentIsNull_Throws()
        {
            // Arrange
            IExceptionHandler innerHandler = CreateDummyHandler();
            IExceptionHandler product = CreateProductUnderTest(innerHandler);

            using (HttpRequestMessage request = CreateRequest())
            using (HttpResponseMessage response = CreateResponse())
            {
                ExceptionHandlerContext context = CreateValidContext(request,
                    WebHostExceptionCatchBlocks.HttpControllerHandlerBufferContent);
                context.ExceptionContext.Response = response;
                Assert.Null(context.ExceptionContext.Request.Content); // Guard
                CancellationToken cancellationToken = CancellationToken.None;

                // Act & Assert
                Assert.ThrowsArgument(() => product.HandleAsync(context, cancellationToken), "context",
                    "HttpResponseMessage.Content must not be null.");
            }
        }

        private static void AssertErrorResponse(HttpResponseMessage expected, HttpResponseMessage actual)
        {
            Assert.NotNull(expected); // Guard
            ObjectContent<HttpError> expectedContent = Assert.IsType<ObjectContent<HttpError>>(expected.Content); // Guard
            Assert.NotNull(expectedContent.Formatter); // Guard

            Assert.NotNull(actual);
            Assert.Equal(expected.StatusCode, actual.StatusCode);
            ObjectContent<HttpError> actualContent = Assert.IsType<ObjectContent<HttpError>>(actual.Content);
            Assert.NotNull(actualContent.Formatter);
            Assert.Same(expectedContent.Formatter.GetType(), actualContent.Formatter.GetType());
            Assert.Equal(Flatten(expectedContent.Value), Flatten(actualContent.Value));
            Assert.Same(expected.RequestMessage, actual.RequestMessage);
        }

        private static object Flatten(object obj)
        {
            IDictionary<string, object> dictionary = obj as IDictionary<string, object>;

            if (dictionary == null)
            {
                return obj;
            }

            IDictionary<string, object> flattened = new Dictionary<string, object>();
            AddValues(dictionary, null, flattened);
            return flattened;
        }

        private static void AddValues(IDictionary<string, object> source, string prefix,
            IDictionary<string, object> destination)
        {
            foreach (string key in source.Keys)
            {
                object value = source[key];
                IDictionary<string, object> dictionaryValue = value as IDictionary<string, object>;

                string prefixedKey = prefix != null ? prefix + "." + key : key;

                if (dictionaryValue != null)
                {
                    destination.Add(prefixedKey, "<Flattened>");
                    AddValues(dictionaryValue, prefixedKey, destination);
                }
                else
                {
                    destination.Add(prefixedKey, value);
                }
            }
        }

        private static CancellationTokenSource CreateCancellationTokenSource()
        {
            return new CancellationTokenSource();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static ExceptionHandlerContext CreateContext()
        {
            return CreateContext(new ExceptionContext(new Exception(), ExceptionCatchBlocks.HttpServer));
        }

        private static ExceptionHandlerContext CreateContext(ExceptionContext exceptionContext)
        {
            return new ExceptionHandlerContext(exceptionContext);
        }

        private static IExceptionHandler CreateDummyHandler()
        {
            return new Mock<IExceptionHandler>(MockBehavior.Strict).Object;
        }

        private static IHttpActionResult CreateDummyResult()
        {
            return new Mock<IHttpActionResult>(MockBehavior.Strict).Object;
        }

        private static WebHostExceptionHandler CreateProductUnderTest(IExceptionHandler innerHandler)
        {
            return new WebHostExceptionHandler(innerHandler);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpResponseMessage CreateResponse()
        {
            return new HttpResponseMessage();
        }

        private static Task CreateTask()
        {
            TaskCompletionSource<object> source = new TaskCompletionSource<object>();
            return source.Task;
        }

        private static ExceptionHandlerContext CreateValidContext(HttpRequestMessage request,
            ExceptionContextCatchBlock catchBlock)
        {
            return CreateContext(CreateMinimalValidExceptionContext(catchBlock, request));
        }

        private static ExceptionContext CreateMinimalValidExceptionContext(ExceptionContextCatchBlock catchBlock, HttpRequestMessage request = null)
        {
            return new ExceptionContext(new InvalidOperationException(), catchBlock)
                        {
                            Request = request,
                        };
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/WebHostHttpRequestContextTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http;
using System.Security.Cryptography.X509Certificates;
using System.Security.Principal;
using System.Threading;
using System.Web.Http.Controllers;
using System.Web.Http.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Http.WebHost
{
    public class WebHostHttpRequestContextTests
    {
        private const string Base64Certificate = "MIFRMIFHAgEAMAIGADAJMQcwBQYAEwFhMB4XDTEzMDkxMDE5NTQ0OVoXDTM5MTIzMT" +
            "IzNTk1OVowCTEHMAUGABMBYTCBBzACBgADgQAwAgYAA4EA";

        [Fact]
        public void ContextGet_ReturnsProvidedInstance()
        {
            // Arrange
            HttpContextBase expectedWebContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                WebHostHttpRequestContext context = CreateProductUnderTest(expectedWebContext, webRequest, request);

                // Act
                HttpContextBase webContext = context.Context;

                // Assert
                Assert.Same(expectedWebContext, webContext);
            }
        }

        [Fact]
        public void WebRequestGet_ReturnsProvidedInstance()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase expectedWebRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                WebHostHttpRequestContext context = CreateProductUnderTest(webContext, expectedWebRequest, request);

                // Act
                HttpRequestBase webRequest = context.WebRequest;

                // Assert
                Assert.Same(expectedWebRequest, webRequest);
            }
        }

        [Fact]
        public void RequestGet_ReturnsProvidedInstance()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                WebHostHttpRequestContext context = CreateProductUnderTest(webContext, webRequest, expectedRequest);

                // Act
                HttpRequestMessage request = context.Request;

                // Assert
                Assert.Same(expectedRequest, request);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsNull_WhenRequestBaseClientCertificateIsNull()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            Mock<HttpRequestBase> webRequestMock = new Mock<HttpRequestBase>(MockBehavior.Strict);
            webRequestMock.Setup(r => r.ClientCertificate).Returns((HttpClientCertificate)null);
            HttpRequestBase webRequest = webRequestMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsNull_WhenRequestBaseClientCertificateCertificateIsNull()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpClientCertificate clientCertificate = CreateHttpClientCertificate(null);
            HttpRequestBase webRequest = CreateStubWebRequest(clientCertificate);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsNull_WhenRequestBaseClientCertificateCertificateIsEmpty()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpClientCertificate clientCertificate = CreateHttpClientCertificate(new byte[0]);
            HttpRequestBase webRequest = CreateStubWebRequest(clientCertificate);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ClientCertificateGet_ReturnsRequestBaseClientCertificate()
        {
            // Arrange
            byte[] expectedCertificateBytes = Convert.FromBase64String(Base64Certificate);
            HttpContextBase webContext = CreateDummyWebContext();
            HttpClientCertificate clientCertificate = CreateHttpClientCertificate(expectedCertificateBytes);
            HttpRequestBase webRequest = CreateStubWebRequest(clientCertificate);

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                X509Certificate2 certificate = context.ClientCertificate;

                // Assert
                Assert.NotNull(certificate);
                Assert.Equal(expectedCertificateBytes, certificate.RawData);
            }
        }

        [Fact]
        public void ClientCertificateSet_UpdatesClientCertificate()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                X509Certificate2 expectedCertificate = CreateCertificate();

                // Act
                context.ClientCertificate = expectedCertificate;

                // Assert
                X509Certificate2 certificate = context.ClientCertificate;
                Assert.Same(expectedCertificate, certificate);
            }
        }

        [Fact]
        public void ClientCertificateSet_UpdatesClientCertificate_WhenNull()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                context.ClientCertificate = null;

                // Assert
                X509Certificate2 certificate = context.ClientCertificate;
                Assert.Null(certificate);
            }
        }

        [Fact]
        public void ConfigurationGet_ReturnsGlobalConfiguration_ByDefault()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                HttpConfiguration configuration = context.Configuration;

                // Assert
                Assert.Same(GlobalConfiguration.Configuration, configuration);
            }
        }

        [Fact]
        public void ConfigurationSet_UpdatesConfiguration()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration expectedConfiguration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                context.Configuration = expectedConfiguration;

                // Assert
                HttpConfiguration configuration = context.Configuration;
                Assert.Same(expectedConfiguration, configuration);
            }
        }

        [Fact]
        public void ConfigurationSet_UpdatesConfiguration_WhenNull()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                context.Configuration = null;

                // Assert
                HttpConfiguration configuration = context.Configuration;
                Assert.Null(configuration);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsNoCustomErrorEnabled_WhenUnconfigured(bool expectedIncludeErrorDetail)
        {
            // Arrange
            Mock<HttpContextBase> webContextMock = new Mock<HttpContextBase>(MockBehavior.Strict);
            webContextMock.Setup(r => r.IsCustomErrorEnabled).Returns(!expectedIncludeErrorDetail);
            HttpContextBase webContext = webContextMock.Object;
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = null;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsNoCustomErrorEnabled_ForDefaultPolicy(bool expectedIncludeErrorDetail)
        {
            // Arrange
            Mock<HttpContextBase> webContextMock = new Mock<HttpContextBase>(MockBehavior.Strict);
            webContextMock.Setup(r => r.IsCustomErrorEnabled).Returns(!expectedIncludeErrorDetail);
            HttpContextBase webContext = webContextMock.Object;
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;
                configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Default;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsIsLocal_ForLocalOnlyPolicy(bool expectedIncludeErrorDetail)
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;
                configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.LocalOnly;
                context.IsLocal = expectedIncludeErrorDetail;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Fact]
        public void IncludeErrorDetailGet_ReturnsTrue_ForAlwaysPolicy()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;
                configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.True(includeErrorDetail);
            }
        }

        [Fact]
        public void IncludeErrorDetailGet_ReturnsFalse_ForNeverPolicy()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;
                configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Never;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.False(includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailSet_UpdatesIncludeErrorDetail(bool expectedIncludeErrorDetail)
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                context.IncludeErrorDetail = expectedIncludeErrorDetail;

                // Assert
                bool includeErrorDetail = context.IncludeErrorDetail;
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true, IncludeErrorDetailPolicy.Never)]
        [InlineData(false, IncludeErrorDetailPolicy.Always)]
        public void IncludeErrorDetailSet_OverridesPolicy(bool expected, IncludeErrorDetailPolicy policy)
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;
                configuration.IncludeErrorDetailPolicy = policy;

                // Act
                context.IncludeErrorDetail = expected;

                // Assert
                bool includeErrorDetail = context.IncludeErrorDetail;
                Assert.Equal(expected, includeErrorDetail);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IncludeErrorDetailGet_ReturnsFirstObservedValue(bool expectedIncludeErrorDetail)
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;
                configuration.IncludeErrorDetailPolicy = expectedIncludeErrorDetail
                    ? IncludeErrorDetailPolicy.Always : IncludeErrorDetailPolicy.Never;
                bool ignore = context.IncludeErrorDetail;
                configuration.IncludeErrorDetailPolicy = expectedIncludeErrorDetail
                    ? IncludeErrorDetailPolicy.Never : IncludeErrorDetailPolicy.Always;

                // Act
                bool includeErrorDetail = context.IncludeErrorDetail;

                // Assert
                Assert.Equal(expectedIncludeErrorDetail, includeErrorDetail);
            }
        }

        [Fact]
        public void IsLocalGet_ReturnsFalse_ByDefault()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = new Mock<HttpRequestBase>().Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.False(isLocal);
            }
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public void IsLocal_ReturnsWebRequestIsLocalValue(bool expectedIsLocal)
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            Mock<HttpRequestBase> webRequestMock = new Mock<HttpRequestBase>(MockBehavior.Strict);
            webRequestMock.Setup(r => r.IsLocal).Returns(expectedIsLocal);
            HttpRequestBase webRequest = webRequestMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalSet_UpdatesIsLocal(bool expectedIsLocal)
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                context.IsLocal = expectedIsLocal;

                // Assert
                bool isLocal = context.IsLocal;
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsLocalGet_ReturnsFirstObservedValue(bool expectedIsLocal)
        {
            // Arrange
            bool currentWebRequestIsLocal = expectedIsLocal;
            HttpContextBase webContext = CreateDummyWebContext();
            Mock<HttpRequestBase> webRequestMock = new Mock<HttpRequestBase>(MockBehavior.Strict);
            webRequestMock.Setup(r => r.IsLocal).Returns(() => currentWebRequestIsLocal);
            HttpRequestBase webRequest = webRequestMock.Object;

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                bool ignore = context.IsLocal;
                currentWebRequestIsLocal = !expectedIsLocal;

                // Act
                bool isLocal = context.IsLocal;

                // Assert
                Assert.Equal(expectedIsLocal, isLocal);
            }
        }

        [Fact]
        public void PrincipalGet_ReturnsWebContextUser()
        {
            // Arrange
            IPrincipal expectedPrincipal = CreateDummyPrincipal();
            Mock<HttpContextBase> webContextMock = new Mock<HttpContextBase>(MockBehavior.Strict);
            webContextMock.Setup(r => r.User).Returns(expectedPrincipal);
            HttpContextBase webContext = webContextMock.Object;
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                IPrincipal principal = context.Principal;

                // Assert
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalSet_UpdatesWebContextUser()
        {
            // Arrange
            Mock<HttpContextBase> webContextMock = new Mock<HttpContextBase>(MockBehavior.Strict);
            IPrincipal principal = null;
            webContextMock.SetupSet(r => r.User = It.IsAny<IPrincipal>()).Callback<IPrincipal>(
                value => { principal = value; });
            HttpContextBase webContext = webContextMock.Object;
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                IPrincipal expectedPrincipal = CreateDummyPrincipal();

                // Act
                context.Principal = expectedPrincipal;

                // Assert
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        [RestoreThreadPrincipal]
        public void PrincipalSet_UpdatesThreadCurrentPrincipal()
        {
            // Arrange
            HttpContextBase webContext = new Mock<HttpContextBase>().Object;
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                IPrincipal expectedPrincipal = CreateDummyPrincipal();

                // Act
                context.Principal = expectedPrincipal;

                // Assert
                IPrincipal principal = Thread.CurrentPrincipal;
                Assert.Same(expectedPrincipal, principal);
            }
        }

        [Fact]
        public void UrlGet_ReturnsUrlHelperForRequest()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage expectedRequest = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, expectedRequest);

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.NotNull(url);
                Assert.Same(expectedRequest, url.Request);
            }
        }

        [Fact]
        public void UrlGet_ReturnsSameInstance()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                UrlHelper firstUrl = context.Url;

                // Act
                UrlHelper url = context.Url;

                // Assert
                Assert.Same(firstUrl, url);
            }
        }

        [Fact]
        public void UrlSet_UpdatesUrl()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                UrlHelper expectedUrl = CreateDummyUrlHelper();

                // Act
                context.Url = expectedUrl;

                // Assert
                UrlHelper url = context.Url;
                Assert.Same(expectedUrl, url);
            }
        }

        [Fact]
        public void UrlSet_UpdatesUrl_WhenNull()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                context.Url = null;

                // Assert
                UrlHelper url = context.Url;
                Assert.Null(url);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsNull_ByDefault()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Null(virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsNull_WhenConfigurationIsNull()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = null;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Null(virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsConfigurationVirtualPathRoot()
        {
            // Arrange
            string expectedVirtualPathRoot = "/foo";
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration(expectedVirtualPathRoot))
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Theory]
        [InlineData("a b")]
        [InlineData("/a b")]
        [InlineData("/a%20b")]
        public void VirtualPathRootGet_ReturnsUnescapedConfigurationVirtualPathRoot(string configurationVirtualPathRoot)
        {
            // Arrange
            var expectedVirtualPathRoot = "/a b";
            var webContext = CreateDummyWebContext();
            var webRequest = CreateDummyWebRequest();

            using (var request = CreateRequest())
            using (var configuration = CreateConfiguration(configurationVirtualPathRoot))
            {
                var context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;

                // Act
                var virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesVirtualPathRoot()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                string expectedVirtualPathRoot = "foo";

                // Act
                context.VirtualPathRoot = expectedVirtualPathRoot;

                // Assert
                string virtualPathRoot = context.VirtualPathRoot;
                Assert.Same(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootSet_UpdatesVirtualPathRoot_WhenNull()
        {
            // Arrange
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration("/other"))
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;

                // Act
                context.VirtualPathRoot = null;

                // Assert
                string virtualPathRoot = context.VirtualPathRoot;
                Assert.Null(virtualPathRoot);
            }
        }

        [Fact]
        public void VirtualPathRootGet_ReturnsFirstObservedConfigurationVirtualPathRoot()
        {
            // Arrange
            string expectedVirtualPathRoot = "/foo";
            HttpContextBase webContext = CreateDummyWebContext();
            HttpRequestBase webRequest = CreateDummyWebRequest();

            using (HttpRequestMessage request = CreateRequest())
            using (HttpConfiguration configuration = CreateConfiguration(expectedVirtualPathRoot))
            using (HttpConfiguration otherConfiguration = CreateConfiguration("/other"))
            {
                HttpRequestContext context = CreateProductUnderTest(webContext, webRequest, request);
                context.Configuration = configuration;
                string ignore = context.VirtualPathRoot;
                context.Configuration = otherConfiguration;

                // Act
                string virtualPathRoot = context.VirtualPathRoot;

                // Assert
                Assert.Equal(expectedVirtualPathRoot, virtualPathRoot);
            }
        }

        private static X509Certificate2 CreateCertificate()
        {
            return new X509Certificate2();
        }

        private static HttpConfiguration CreateConfiguration()
        {
            return new HttpConfiguration();
        }

        private static HttpConfiguration CreateConfiguration(string virtualPathRoot)
        {
            return new HttpConfiguration(new HttpRouteCollection(virtualPathRoot));
        }

        private static HttpContextBase CreateDummyWebContext()
        {
            return new Mock<HttpContextBase>(MockBehavior.Strict).Object;
        }

        private static HttpRequestBase CreateDummyWebRequest()
        {
            return new Mock<HttpRequestBase>(MockBehavior.Strict).Object;
        }

        private static IPrincipal CreateDummyPrincipal()
        {
            return new Mock<IPrincipal>(MockBehavior.Strict).Object;
        }

        private static UrlHelper CreateDummyUrlHelper()
        {
            return new Mock<UrlHelper>(MockBehavior.Strict).Object;
        }

        private static HttpClientCertificate CreateHttpClientCertificate(byte[] bytes)
        {
            Mock<HttpWorkerRequest> workerRequestMock = new Mock<HttpWorkerRequest>();
            workerRequestMock.Setup(wr => wr.GetRawUrl()).Returns("/");
            workerRequestMock.Setup(wr => wr.GetServerVariable("CERT_FLAGS")).Returns("1");
            workerRequestMock.Setup(wr => wr.GetClientCertificate()).Returns(bytes);
            HttpContext context = new HttpContext(workerRequestMock.Object);
            return context.Request.ClientCertificate;
        }

        private static WebHostHttpRequestContext CreateProductUnderTest(HttpContextBase contextBase,
            HttpRequestBase requestBase, HttpRequestMessage request)
        {
            return new WebHostHttpRequestContext(contextBase, requestBase, request);
        }

        private static HttpRequestMessage CreateRequest()
        {
            return new HttpRequestMessage();
        }

        private static HttpRequestBase CreateStubWebRequest(HttpClientCertificate clientCertificate)
        {
            Mock<HttpRequestBase> mock = new Mock<HttpRequestBase>(MockBehavior.Strict);
            mock.Setup(r => r.ClientCertificate).Returns(clientCertificate);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Http.WebHost.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Mvc.Test/Ajax/Test/AjaxExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Threading;
using System.Web.Mvc.Html;
using System.Web.Routing;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Ajax.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class AjaxExtensionsTest : IDisposable
    {
        // Guards

        [Fact]
        public void ActionLinkWithNullOrEmptyLinkTextThrows()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { MvcHtmlString actionLink = ajaxHelper.ActionLink(String.Empty, String.Empty, null, null, null, null); },
                "linkText");
        }

        [Fact]
        public void RouteLinkWithNullOrEmptyLinkTextThrows()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { MvcHtmlString actionLink = ajaxHelper.RouteLink(String.Empty, String.Empty, null, null, null); },
                "linkText");
        }

        // Form context setup and cleanup

        [Fact]
        public void BeginFormSetsAndRestoresToDefault()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper();

            ajaxHelper.ViewContext.FormContext = null;
            FormContext defaultFormContext = ajaxHelper.ViewContext.FormContext;

            // Act & assert - push
            MvcForm theForm = ajaxHelper.BeginForm(new AjaxOptions());
            Assert.NotNull(ajaxHelper.ViewContext.FormContext);
            Assert.NotEqual(defaultFormContext, ajaxHelper.ViewContext.FormContext);

            // Act & assert - pop
            theForm.Dispose();
            Assert.Equal(defaultFormContext, ajaxHelper.ViewContext.FormContext);
        }

        [Fact]
        public void DisposeWritesClosingFormTag()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper();
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", ajaxOptions);
            form.Dispose();

            // Assert
            Assert.EndsWith("</form>", writer.ToString());
        }

        // GlobalizationScript

        [Fact]
        public void GlobalizationScriptWithNullCultureInfoThrows()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { ajaxHelper.GlobalizationScript(null); },
                "cultureInfo");
        }

        [Fact]
        public void GlobalizationScriptUsesCurrentCultureAsDefault()
        {
            CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;

            try
            {
                // Arrange
                AjaxHelper ajaxHelper = GetAjaxHelper();
                AjaxHelper.GlobalizationScriptPath = null;
                Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-GB");

                // Act
                MvcHtmlString globalizationScript = ajaxHelper.GlobalizationScript();

                // Assert
                Assert.Equal(@"<script src=""~/Scripts/Globalization/en-GB.js"" type=""text/javascript""></script>", globalizationScript.ToHtmlString());
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = currentCulture;
            }
        }

        [Fact]
        public void GlobalizationScriptWithCultureInfo()
        {
            CultureInfo currentCulture = Thread.CurrentThread.CurrentCulture;

            try
            {
                // Arrange
                AjaxHelper ajaxHelper = GetAjaxHelper();
                AjaxHelper.GlobalizationScriptPath = null;
                Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("en-GB");

                // Act
                MvcHtmlString globalizationScript = ajaxHelper.GlobalizationScript(CultureInfo.GetCultureInfo("en-CA"));

                // Assert
                Assert.Equal(@"<script src=""~/Scripts/Globalization/en-CA.js"" type=""text/javascript""></script>", globalizationScript.ToHtmlString());
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = currentCulture;
            }
        }

        [Fact]
        public void GlobalizationScriptEncodesSource()
        {
            // Arrange
            Mock<CultureInfo> xssCulture = new Mock<CultureInfo>("en-US");
            xssCulture.Setup(culture => culture.Name).Returns("evil.example.com/<script>alert('XSS!')</script>");
            string globalizationPath = "~/Scripts&Globalization";
            string expectedScriptTag = @"<script src=""~/Scripts&amp;Globalization/evil.example.com%2f%3cscript%3ealert(%27XSS!%27)%3c%2fscript%3e.js"" type=""text/javascript""></script>";

            // Act
            MvcHtmlString globalizationScript = AjaxExtensions.GlobalizationScriptHelper(globalizationPath, xssCulture.Object);

            // Assert
            Assert.Equal(expectedScriptTag, globalizationScript.ToHtmlString());
        }

        [Fact]
        public void GlobalizationScriptWithNullCultureName()
        {
            // Arrange
            Mock<CultureInfo> xssCulture = new Mock<CultureInfo>("en-US");
            xssCulture.Setup(culture => culture.Name).Returns((string)null);

            AjaxHelper ajaxHelper = GetAjaxHelper();
            AjaxHelper.GlobalizationScriptPath = null;

            // Act
            MvcHtmlString globalizationScript = ajaxHelper.GlobalizationScript(xssCulture.Object);

            // Assert
            Assert.Equal(@"<script src=""~/Scripts/Globalization/.js"" type=""text/javascript""></script>", globalizationScript.ToHtmlString());
        }

        // ActionLink (traditional JavaScript)

        [Fact]
        public void ActionLinkWithNullActionName()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", null, new AjaxOptions());

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullActionName_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", null, new AjaxOptions());

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullActionNameAndNullOptions()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", null, null);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullActionNameAndNullOptions_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", null, null);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLink()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", new AjaxOptions());

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/home/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLink_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", new AjaxOptions());

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/home/Action"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkAnonymousValues()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object values = new { controller = "Controller" };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkAnonymousValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object values = new { controller = "Controller" };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkAnonymousValuesAndAttributes()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object htmlAttributes = new { foo = "bar", baz = "quux", foo_bar = "baz_quux" };
            object values = new { controller = "Controller" };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkAnonymousValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object htmlAttributes = new { foo = "bar", baz = "quux", foo_bar = "baz_quux" };
            object values = new { controller = "Controller" };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkTypedValues()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };

            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkTypedValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };

            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkTypedValuesAndAttributes()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "baz", "quux" },
                { "foo_bar", "baz_quux" }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkTypedValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "baz", "quux" },
                { "foo_bar", "baz_quux" }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkController()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller", new AjaxOptions());

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkController_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller", new AjaxOptions());

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerAnonymousValues()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object values = new { id = 5 };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerAnonymousValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object values = new { id = 5 };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerAnonymousValuesAndAttributes()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object htmlAttributes = new { foo = "bar", baz = "quux", foo_bar = "baz_quux" };
            object values = new { id = 5 };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerAnonymousValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object htmlAttributes = new { foo = "bar", baz = "quux", foo_bar = "baz_quux" };
            object values = new { id = 5 };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerTypedValues()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerTypedValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerTypedValuesAndAttributes()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "baz", "quux" },
                { "foo_bar", "baz_quux" }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkControllerTypedValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "baz", "quux" },
                { "foo_bar", "baz_quux" }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.ActionLink("Some Text", "Action", "Controller", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithOptions()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller", new AjaxOptions { UpdateTargetId = "some-id" });

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithOptions_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "some-id" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller", options);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullHostName()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller",
                                                             null, null, null, null, new AjaxOptions { UpdateTargetId = "some-id" }, null);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullHostName_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller",
                                                             null, null, null, null, new AjaxOptions { UpdateTargetId = "some-id" }, null);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithProtocol()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller", "https", null, null, null, new AjaxOptions { UpdateTargetId = "some-id" }, null);

            // Assert
            Assert.Equal(@"<a href=""https://foo.bar.baz" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithProtocol_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString actionLink = ajaxHelper.ActionLink("linkText", "Action", "Controller", "https", null, null, null, new AjaxOptions { UpdateTargetId = "some-id" }, null);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" href=""https://foo.bar.baz" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">linkText</a>", actionLink.ToHtmlString());
        }

        // RouteLink

        [Fact]
        public void RouteLinkWithNullOptions()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString routeLink = ajaxHelper.RouteLink("Some Text", new RouteValueDictionary(), null);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">Some Text</a>", routeLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithNullOptions_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString routeLink = ajaxHelper.RouteLink("Some Text", new RouteValueDictionary(), null);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"">Some Text</a>", routeLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkAnonymousValues()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString routeLink = helper.RouteLink("Some Text", values, options);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", routeLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkAnonymousValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString routeLink = helper.RouteLink("Some Text", values, options);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", routeLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkAnonymousValuesAndAttributes()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object htmlAttributes = new
            {
                foo = "bar",
                baz = "quux",
                foo_bar = "baz_quux"
            };
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.RouteLink("Some Text", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkAnonymousValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object htmlAttributes = new
            {
                foo = "bar",
                baz = "quux",
                foo_bar = "baz_quux"
            };
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.RouteLink("Some Text", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkTypedValues()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };

            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.RouteLink("Some Text", values, options);

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkTypedValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };

            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.RouteLink("Some Text", values, options);

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkTypedValuesAndAttributes()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "baz", "quux" },
                { "foo_bar", "baz_quux" }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.RouteLink("Some Text", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkTypedValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper helper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "baz", "quux" },
                { "foo_bar", "baz_quux" }
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = helper.RouteLink("Some Text", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRoute()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("linkText", "namedroute", new AjaxOptions());

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRoute_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("linkText", "namedroute", new AjaxOptions());

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteAnonymousAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object htmlAttributes = new
            {
                foo = "bar",
                baz = "quux",
                foo_bar = "baz_quux"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteAnonymousAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object htmlAttributes = new
            {
                foo = "bar",
                baz = "quux",
                foo_bar = "baz_quux"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteTypedAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteTypedAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteWithAnonymousValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("linkText", "namedroute", values, new AjaxOptions());

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteWithAnonymousValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("linkText", "namedroute", values, new AjaxOptions());

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteAnonymousValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };

            object htmlAttributes = new
            {
                foo = "bar",
                baz = "quux",
                foo_bar = "baz_quux"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteAnonymousValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            object values = new
            {
                action = "Action",
                controller = "Controller"
            };

            object htmlAttributes = new
            {
                foo = "bar",
                baz = "quux",
                foo_bar = "baz_quux"
            };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo-bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteWithTypedValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("linkText", "namedroute", values, new AjaxOptions());

            // Assert
            Assert.Equal(@"<a href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteWithTypedValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("linkText", "namedroute", values, new AjaxOptions());

            // Assert
            Assert.Equal(@"<a data-ajax=""true"" href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"">linkText</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteTypedValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };

            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteTypedValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" },
                { "action", "Action" }
            };

            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", values, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/Controller/Action"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteNullValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", null, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkNamedRouteNullValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", null, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo_bar=""baz_quux"" href=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithHostName()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", null, "baz.bar.foo", null, null, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" foo=""bar"" foo_bar=""baz_quux"" href=""http://baz.bar.foo" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" onclick=""Sys.Mvc.AsyncHyperlink.handleClick(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;update-div&#39; });"">Some Text</a>", actionLink.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithHostName_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "foo", "bar" }, { "baz", "quux" }, { "foo_bar", "baz_quux" } };
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "update-div" };

            // Act
            MvcHtmlString actionLink = ajaxHelper.RouteLink("Some Text", "namedroute", null, "baz.bar.foo", null, null, options, htmlAttributes);

            // Assert
            Assert.Equal(@"<a baz=""quux"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#update-div"" foo=""bar"" foo_bar=""baz_quux"" href=""http://baz.bar.foo" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"">Some Text</a>", actionLink.ToHtmlString());
        }

        // BeginForm

        [Fact]
        public void BeginFormOnlyWithNullOptions()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm(null);

            // Assert
            Assert.Equal(@"<form action=""/rawUrl"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormOnlyWithNullOptions_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm(null);

            // Assert
            Assert.Equal(@"<form action=""/rawUrl"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormWithNullActionName()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm(null, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormWithNullActionName_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm(null, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/home/oldaction"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormWithNullOptions()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", null);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormWithNullOptions_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", null);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginForm()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm(ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""/rawUrl"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginForm_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm(ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""/rawUrl"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormAction()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/home/Action"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormAction_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/home/Action"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormAnonymousValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            object values = new { controller = "Controller" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormAnonymousValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            object values = new { controller = "Controller" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormAnonymousValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            object values = new { controller = "Controller" };
            object htmlAttributes = new { method = "get", foo_bar = "baz_quux" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" foo-bar=""baz_quux"" method=""get"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormAnonymousValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            object values = new { controller = "Controller" };
            object htmlAttributes = new { method = "get", foo_bar = "baz_quux" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" foo-bar=""baz_quux"" method=""get"">", writer.ToString());
        }

        [Fact]
        public void BeginFormTypedValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormTypedValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormTypedValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "method", "get" },
                { "foo_bar", "baz_quux" }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" foo_bar=""baz_quux"" method=""get"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormTypedValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "controller", "Controller" }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "method", "get" },
                { "foo_bar", "baz_quux" }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" foo_bar=""baz_quux"" method=""get"">", writer.ToString());
        }

        [Fact]
        public void BeginFormController()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormController_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerAnonymousValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            object values = new { id = 5 };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerAnonymousValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            object values = new { id = 5 };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerAnonymousValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            object values = new { id = 5 };
            object htmlAttributes = new { method = "get", foo_bar = "baz_quux" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" foo-bar=""baz_quux"" method=""get"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerAnonymousValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            object values = new { id = 5 };
            object htmlAttributes = new { method = "get", foo_bar = "baz_quux" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" data-ajax=""true"" foo-bar=""baz_quux"" method=""get"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerTypedValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerTypedValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerTypedValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "method", "get" },
                { "foo_bar", "baz_quux" }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" foo_bar=""baz_quux"" method=""get"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormControllerTypedValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary
            {
                { "id", 5 }
            };
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "method", "get" },
                { "foo_bar", "baz_quux" }
            };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action/5"" data-ajax=""true"" foo_bar=""baz_quux"" method=""get"">", writer.ToString());
        }

        [Fact]
        public void BeginFormWithTargetId()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">", writer.ToString());
        }

        [Fact]
        public void BeginFormWithTargetId_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginForm("Action", "Controller", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/Controller/Action"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" method=""post"">", writer.ToString());
        }

        // BeginRouteForm

        [Fact]
        public void BeginRouteForm()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteForm_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormAnonymousValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            AjaxHelper poes = GetAjaxHelper(unobtrusiveJavaScript: false);
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", null, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormAnonymousValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            AjaxHelper poes = GetAjaxHelper(unobtrusiveJavaScript: true);
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", null, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormAnonymousValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            object htmlAttributes = new { method = "get", foo_bar = "baz_quux" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", null, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" foo-bar=""baz_quux"" method=""get"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormAnonymousValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            object htmlAttributes = new { method = "get", foo_bar = "baz_quux" };
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", null, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" foo-bar=""baz_quux"" method=""get"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormCanUseNamedRouteWithoutSpecifyingDefaults()
        {
            // DevDiv 217072: Non-mvc specific helpers should not give default values for controller and action

            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            ajaxHelper.RouteCollection.MapRoute("MyRouteName", "any/url", new { controller = "Charlie" });
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("MyRouteName", new AjaxOptions());

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/any/url"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormCanUseNamedRouteWithoutSpecifyingDefaults_Unobtrusive()
        {
            // DevDiv 217072: Non-mvc specific helpers should not give default values for controller and action

            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            ajaxHelper.RouteCollection.MapRoute("MyRouteName", "any/url", new { controller = "Charlie" });
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("MyRouteName", new AjaxOptions());

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/any/url"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormTypedValues()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" method=""post"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace });"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormTypedValues_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            AjaxOptions ajaxOptions = new AjaxOptions();
            RouteValueDictionary values = new RouteValueDictionary();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", values, ajaxOptions);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" data-ajax=""true"" method=""post"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormTypedValuesAndAttributes()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: false);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "method", "get" }, { "foo_bar", "baz_quux" } };
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            RouteValueDictionary values = new RouteValueDictionary();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" foo_bar=""baz_quux"" method=""get"" onclick=""Sys.Mvc.AsyncForm.handleClick(this, new Sys.UI.DomEvent(event));"" onsubmit=""Sys.Mvc.AsyncForm.handleSubmit(this, new Sys.UI.DomEvent(event), { insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: &#39;some-id&#39; });"">", writer.ToString());
        }

        [Fact]
        public void BeginRouteFormTypedValuesAndAttributes_Unobtrusive()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper(unobtrusiveJavaScript: true);
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object> { { "method", "get" }, { "foo_bar", "baz_quux" } };
            AjaxOptions ajaxOptions = new AjaxOptions { UpdateTargetId = "some-id" };
            RouteValueDictionary values = new RouteValueDictionary();
            StringWriter writer = new StringWriter();
            ajaxHelper.ViewContext.Writer = writer;

            // Act
            IDisposable form = ajaxHelper.BeginRouteForm("namedroute", values, ajaxOptions, htmlAttributes);

            // Assert
            Assert.Equal(@"<form action=""" + MvcHelper.AppPathModifier + @"/app/named/home/oldaction"" data-ajax=""true"" data-ajax-mode=""replace"" data-ajax-update=""#some-id"" foo_bar=""baz_quux"" method=""get"">", writer.ToString());
        }

        // Helpers

        private static AjaxHelper GetAjaxHelper(bool unobtrusiveJavaScript = false)
        {
            var mockRequest = new Mock<HttpRequestBase>();
            mockRequest.Setup(o => o.Url).Returns(new Uri("http://foo.bar.baz"));
            mockRequest.Setup(o => o.RawUrl).Returns("/rawUrl");
            mockRequest.Setup(o => o.PathInfo).Returns(String.Empty);
            mockRequest.Setup(o => o.ApplicationPath).Returns("/app/");

            var mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(o => o.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(r => MvcHelper.AppPathModifier + r);

            var mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request).Returns(mockRequest.Object);
            mockHttpContext.Setup(o => o.Session).Returns((HttpSessionStateBase)null);
            mockHttpContext.Setup(o => o.Items).Returns(new Hashtable());
            mockHttpContext.Setup(o => o.Response).Returns(mockResponse.Object);

            var routes = new RouteCollection();
            routes.MapRoute("default", "{controller}/{action}/{id}", new { id = "defaultid" });
            routes.MapRoute("namedroute", "named/{controller}/{action}/{id}", new { id = "defaultid" });

            var routeData = new RouteData();
            routeData.Values.Add("controller", "home");
            routeData.Values.Add("action", "oldaction");

            var viewContext = new ViewContext()
            {
                HttpContext = mockHttpContext.Object,
                RouteData = routeData,
                UnobtrusiveJavaScriptEnabled = unobtrusiveJavaScript,
                Writer = TextWriter.Null
            };

            return new AjaxHelper(viewContext, new Mock<IViewDataContainer>().Object, routes);
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ViewContext.UnobtrusiveJavaScriptEnabled) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Ajax/Test/AjaxOptionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Ajax.Test
{
    public class AjaxOptionsTest
    {
        [Fact]
        public void InsertionModeProperty()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act & Assert
            MemberHelper.TestEnumProperty(options, "InsertionMode", InsertionMode.Replace, false);
        }

        [Fact]
        public void InsertionModePropertyExceptionText()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act & Assert
            Assert.ThrowsArgumentOutOfRange(
                delegate { options.InsertionMode = (InsertionMode)4; },
                "value",
                @"Specified argument was out of the range of valid values.");
        }

        [Fact]
        public void InsertionModeStringTests()
        {
            // Act & Assert
            Assert.Equal("Sys.Mvc.InsertionMode.replace", new AjaxOptions { InsertionMode = InsertionMode.Replace }.InsertionModeString);
            Assert.Equal("Sys.Mvc.InsertionMode.insertAfter", new AjaxOptions { InsertionMode = InsertionMode.InsertAfter }.InsertionModeString);
            Assert.Equal("Sys.Mvc.InsertionMode.insertBefore", new AjaxOptions { InsertionMode = InsertionMode.InsertBefore }.InsertionModeString);
        }

        [Theory]
        [InlineData(InsertionMode.Replace, "replace")]
        [InlineData(InsertionMode.InsertAfter, "after")]
        [InlineData(InsertionMode.InsertBefore, "before")]
        [InlineData(InsertionMode.ReplaceWith, "replace-with")]
        public void InsertionModeUnobtrusiveTests(InsertionMode mode, string expected)
        {
            // Arrange
            AjaxOptions options = new AjaxOptions { InsertionMode = mode };

            // Act
            string result = options.InsertionModeUnobtrusive;

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void HttpMethodProperty()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act & Assert
            MemberHelper.TestStringProperty(options, "HttpMethod", String.Empty);
        }

        [Fact]
        public void OnBeginProperty()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act & Assert
            MemberHelper.TestStringProperty(options, "OnBegin", String.Empty);
        }

        [Fact]
        public void OnFailureProperty()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act & Assert
            MemberHelper.TestStringProperty(options, "OnFailure", String.Empty);
        }

        [Fact]
        public void OnSuccessProperty()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act & Assert
            MemberHelper.TestStringProperty(options, "OnSuccess", String.Empty);
        }

        [Fact]
        public void ToJavascriptStringWithEmptyOptions()
        {
            string s = (new AjaxOptions()).ToJavascriptString();
            Assert.Equal("{ insertionMode: Sys.Mvc.InsertionMode.replace }", s);
        }

        [Fact]
        public void ToJavascriptString()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions
            {
                InsertionMode = InsertionMode.InsertBefore,
                Confirm = "confirm",
                HttpMethod = "POST",
                LoadingElementId = "loadingElement",
                UpdateTargetId = "someId",
                Url = "http://someurl.com",
                OnBegin = "some_begin_function",
                OnComplete = "some_complete_function",
                OnFailure = "some_failure_function",
                OnSuccess = "some_success_function",
            };

            // Act
            string s = options.ToJavascriptString();

            // Assert
            Assert.Equal("{ insertionMode: Sys.Mvc.InsertionMode.insertBefore, " +
                         "confirm: 'confirm', " +
                         "httpMethod: 'POST', " +
                         "loadingElementId: 'loadingElement', " +
                         "updateTargetId: 'someId', " +
                         "url: 'http://someurl.com', " +
                         "onBegin: Function.createDelegate(this, some_begin_function), " +
                         "onComplete: Function.createDelegate(this, some_complete_function), " +
                         "onFailure: Function.createDelegate(this, some_failure_function), " +
                         "onSuccess: Function.createDelegate(this, some_success_function) }", s);
        }

        [Fact]
        public void ToJavascriptStringEscapesQuotesCorrectly()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions
            {
                InsertionMode = InsertionMode.InsertBefore,
                Confirm = @"""confirm""",
                HttpMethod = "POST",
                LoadingElementId = "loading'Element'",
                UpdateTargetId = "someId",
                Url = "http://someurl.com",
                OnBegin = "some_begin_function",
                OnComplete = "some_complete_function",
                OnFailure = "some_failure_function",
                OnSuccess = "some_success_function",
            };

            // Act
            string s = options.ToJavascriptString();

            // Assert
            Assert.Equal("{ insertionMode: Sys.Mvc.InsertionMode.insertBefore, " +
                         @"confirm: '""confirm""', " +
                         "httpMethod: 'POST', " +
                         @"loadingElementId: 'loading\'Element\'', " +
                         "updateTargetId: 'someId', " +
                         "url: 'http://someurl.com', " +
                         "onBegin: Function.createDelegate(this, some_begin_function), " +
                         "onComplete: Function.createDelegate(this, some_complete_function), " +
                         "onFailure: Function.createDelegate(this, some_failure_function), " +
                         "onSuccess: Function.createDelegate(this, some_success_function) }", s);
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public void ToJavascriptStringIgnoresAllowCache(bool allowCache)
        {
            // Arrange
            AjaxOptions options = new AjaxOptions
            {
                InsertionMode = InsertionMode.InsertAfter,
                UpdateTargetId = "someId",
                Url = "http://someurl.com",
                OnComplete = "some_complete_function",
                AllowCache = allowCache
            };

            // Act
            string s = options.ToJavascriptString();

            // Assert
            Assert.Equal("{ insertionMode: Sys.Mvc.InsertionMode.insertAfter, " +
                         "updateTargetId: 'someId', " +
                         "url: 'http://someurl.com', " +
                         "onComplete: Function.createDelegate(this, some_complete_function) }", s);
        }

        [Fact]
        public void ToJavascriptStringWithOnlyUpdateTargetId()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "someId" };

            // Act
            string s = options.ToJavascriptString();

            // Assert
            Assert.Equal("{ insertionMode: Sys.Mvc.InsertionMode.replace, updateTargetId: 'someId' }", s);
        }

        [Fact]
        public void ToJavascriptStringWithUpdateTargetIdAndExplicitInsertionMode()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions { InsertionMode = InsertionMode.InsertAfter, UpdateTargetId = "someId" };

            // Act
            string s = options.ToJavascriptString();

            // Assert
            Assert.Equal("{ insertionMode: Sys.Mvc.InsertionMode.insertAfter, updateTargetId: 'someId' }", s);
        }

        [Fact]
        public void ToUnobtrusiveHtmlAttributesWithEmptyOptions()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act
            IDictionary<string, object> attributes = options.ToUnobtrusiveHtmlAttributes();

            // Assert
            Assert.Single(attributes);
            Assert.Equal("true", attributes["data-ajax"]);
        }

        [Fact]
        public void ToUnobtrusiveHtmlAttributes()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions
            {
                InsertionMode = InsertionMode.InsertBefore,
                Confirm = "confirm",
                HttpMethod = "POST",
                LoadingElementId = "loadingElement",
                LoadingElementDuration = 450,
                UpdateTargetId = "someId",
                Url = "http://someurl.com",
                OnBegin = "some_begin_function",
                OnComplete = "some_complete_function",
                OnFailure = "some_failure_function",
                OnSuccess = "some_success_function",
            };

            // Act
            var attributes = options.ToUnobtrusiveHtmlAttributes();

            // Assert
            Assert.Equal(12, attributes.Count);
            Assert.Equal("true", attributes["data-ajax"]);
            Assert.Equal("confirm", attributes["data-ajax-confirm"]);
            Assert.Equal("POST", attributes["data-ajax-method"]);
            Assert.Equal("#loadingElement", attributes["data-ajax-loading"]);
            Assert.Equal(450, attributes["data-ajax-loading-duration"]);
            Assert.Equal("http://someurl.com", attributes["data-ajax-url"]);
            Assert.Equal("#someId", attributes["data-ajax-update"]);
            Assert.Equal("before", attributes["data-ajax-mode"]);
            Assert.Equal("some_begin_function", attributes["data-ajax-begin"]);
            Assert.Equal("some_complete_function", attributes["data-ajax-complete"]);
            Assert.Equal("some_failure_function", attributes["data-ajax-failure"]);
            Assert.Equal("some_success_function", attributes["data-ajax-success"]);
        }

        [Fact]
        public void ToUnobtrusiveHtmlAttributesWithAllowCache()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions
            {
                UpdateTargetId = "someId",
                HttpMethod = "GET",
                AllowCache = true,
                Url = "http://someurl.com",
                OnComplete = "some_complete_function"
            };

            // Act
            var attributes = options.ToUnobtrusiveHtmlAttributes();

            // Assert
            Assert.Equal(7, attributes.Count);
            Assert.Equal("true", attributes["data-ajax"]);
            Assert.Equal("GET", attributes["data-ajax-method"]);
            Assert.Equal("http://someurl.com", attributes["data-ajax-url"]);
            Assert.Equal("#someId", attributes["data-ajax-update"]);
            Assert.Equal("true", attributes["data-ajax-cache"]);
            Assert.Equal("replace", attributes["data-ajax-mode"]);
            Assert.Equal("some_complete_function", attributes["data-ajax-complete"]);
        }

        [Fact]
        public void ToUnobtrusiveHtmlAttributesWithOnlyUpdateTargetId()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions { UpdateTargetId = "someId" };

            // Act
            var attributes = options.ToUnobtrusiveHtmlAttributes();

            // Assert
            Assert.Equal(3, attributes.Count);
            Assert.Equal("true", attributes["data-ajax"]);
            Assert.Equal("#someId", attributes["data-ajax-update"]);
            Assert.Equal("replace", attributes["data-ajax-mode"]); // Only added when UpdateTargetId is set
        }


        [Theory]
        [InlineData("foo.bar", "#foo\\.bar")]
        [InlineData("baz:bar", "#baz\\:bar")]
        [InlineData("qux[zot]", "#qux\\[zot\\]")]
        [InlineData("foo[:zot].", "#foo\\[\\:zot\\]\\.")]
        public void ToUnobtrusiveHtmlAttributesEscapesClientSideIdentifiers(string id, string expected)
        {
            // Arrange
            AjaxOptions options = new AjaxOptions { UpdateTargetId = id, LoadingElementId = id };

            // Act
            var attributes = options.ToUnobtrusiveHtmlAttributes();

            // Assert
            Assert.Equal(expected, attributes["data-ajax-update"]);
            Assert.Equal(expected, attributes["data-ajax-loading"]);
        }

        [Theory]
        [InlineData(InsertionMode.InsertAfter, "after")]
        [InlineData(InsertionMode.ReplaceWith, "replace-with")]
        public void ToUnobtrusiveHtmlAttributesWithUpdateTargetIdAndExplicitInsertionMode(InsertionMode mode, string expectedMode)
        {
            // Arrange
            AjaxOptions options = new AjaxOptions
            {
                InsertionMode = mode,
                UpdateTargetId = "someId"
            };

            // Act
            var attributes = options.ToUnobtrusiveHtmlAttributes();

            // Assert
            Assert.Equal(3, attributes.Count);
            Assert.Equal("true", attributes["data-ajax"]);
            Assert.Equal("#someId", attributes["data-ajax-update"]);
            Assert.Equal(expectedMode, attributes["data-ajax-mode"]);
        }

        [Fact]
        public void UpdateTargetIdProperty()
        {
            // Arrange
            AjaxOptions options = new AjaxOptions();

            // Act & Assert
            MemberHelper.TestStringProperty(options, "UpdateTargetId", String.Empty);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/AsyncActionDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class AsyncActionDescriptorTest
    {
        [Fact]
        public void SynchronousExecuteThrows()
        {
            // Arrange
            AsyncActionDescriptor actionDescriptor = new TestableAsyncActionDescriptor();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => actionDescriptor.Execute(new Mock<ControllerContext>().Object, parameters: null),
                "The asynchronous action method 'testAction' cannot be executed synchronously."
                );
        }

        private class TestableAsyncActionDescriptor : AsyncActionDescriptor
        {
            public override string ActionName
            {
                get { return "testAction"; }
            }

            public override ControllerDescriptor ControllerDescriptor
            {
                get { throw new NotImplementedException(); }
            }

            public override IAsyncResult BeginExecute(ControllerContext controllerContext, IDictionary<string, object> parameters, AsyncCallback callback, object state)
            {
                throw new NotImplementedException();
            }

            public override object EndExecute(IAsyncResult asyncResult)
            {
                throw new NotImplementedException();
            }

            public override ParameterDescriptor[] GetParameters()
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/AsyncActionMethodSelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class AsyncActionMethodSelectorTest
    {
        [Fact]
        public void AliasedMethodsProperty()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);

            // Act
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Assert
            Assert.Equal(3, selector.AliasedMethods.Length);

            List<MethodInfo> sortedAliasedMethods = selector.AliasedMethods.OrderBy(methodInfo => methodInfo.Name).ToList();
            Assert.Equal("Bar", sortedAliasedMethods[0].Name);
            Assert.Equal("FooRenamed", sortedAliasedMethods[1].Name);
            Assert.Equal("Renamed", sortedAliasedMethods[2].Name);
        }

        [Fact]
        public void ControllerTypeProperty()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act & Assert
            Assert.Same(controllerType, selector.ControllerType);
        }

        [Fact]
        public void FindAction_DoesNotMatchAsyncMethod()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "EventPatternAsync");

            // Assert
            Assert.Null(creator);
        }

        [Fact]
        public void FindAction_DoesNotMatchCompletedMethod()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "EventPatternCompleted");

            // Assert
            Assert.Null(creator);
        }

        [Fact]
        public void FindAction_ReturnsMatchingMethodIfOneMethodMatches()
        {
            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "OneMatch");
            ActionDescriptor actionDescriptor = creator("someName", new Mock<ControllerDescriptor>().Object);

            // Assert
            var castActionDescriptor = Assert.IsType<ReflectedActionDescriptor>(actionDescriptor);
            Assert.Equal("OneMatch", castActionDescriptor.MethodInfo.Name);
            Assert.Equal(typeof(string), castActionDescriptor.MethodInfo.GetParameters()[0].ParameterType);
        }

        [Fact]
        public void FindAction_ReturnsMethodWithActionSelectionAttributeIfMultipleMethodsMatchRequest()
        {
            // DevDiv Bugs 212062: If multiple action methods match a request, we should match only the methods with an
            // [ActionMethod] attribute since we assume those methods are more specific.

            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "ShouldMatchMethodWithSelectionAttribute");
            ActionDescriptor actionDescriptor = creator("someName", new Mock<ControllerDescriptor>().Object);

            // Assert
            var castActionDescriptor = Assert.IsType<ReflectedActionDescriptor>(actionDescriptor);
            Assert.Equal("MethodHasSelectionAttribute1", castActionDescriptor.MethodInfo.Name);
        }

        [Fact]
        public void FindAction_ReturnsNullIfNoMethodMatches()
        {
            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "ZeroMatch");

            // Assert
            Assert.Null(creator);
        }

        [Fact]
        public void FindAction_ThrowsIfMultipleMethodsMatch()
        {
            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act & veriy
            Assert.Throws<AmbiguousMatchException>(
                delegate { selector.FindAction(new ControllerContext(), "TwoMatch"); },
                "The current request for action 'TwoMatch' on controller type 'SelectionAttributeController' is ambiguous between the following action methods:" + Environment.NewLine
              + "Void TwoMatch2() on type System.Web.Mvc.Async.Test.AsyncActionMethodSelectorTest+SelectionAttributeController" + Environment.NewLine
              + "Void TwoMatch() on type System.Web.Mvc.Async.Test.AsyncActionMethodSelectorTest+SelectionAttributeController");
        }

        [Fact]
        public void FindActionMethod_Asynchronous()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "EventPattern");
            ActionDescriptor actionDescriptor = creator("someName", new Mock<ControllerDescriptor>().Object);

            // Assert
            var castActionDescriptor = Assert.IsType<ReflectedAsyncActionDescriptor>(actionDescriptor);
            Assert.Equal("EventPatternAsync", castActionDescriptor.AsyncMethodInfo.Name);
            Assert.Equal("EventPatternCompleted", castActionDescriptor.CompletedMethodInfo.Name);
        }

        [Fact]
        public void FindActionMethod_Task()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "TaskPattern");
            ActionDescriptor actionDescriptor = creator("someName", new Mock<ControllerDescriptor>().Object);

            // Assert
            var castActionDescriptor = Assert.IsType<TaskAsyncActionDescriptor>(actionDescriptor);
            Assert.Equal("TaskPattern", castActionDescriptor.TaskMethodInfo.Name);
            Assert.Equal(typeof(Task), castActionDescriptor.TaskMethodInfo.ReturnType);
        }

        [Fact]
        public void FindActionMethod_GenericTask()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act
            ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "GenericTaskPattern");
            ActionDescriptor actionDescriptor = creator("someName", new Mock<ControllerDescriptor>().Object);

            // Assert
            var castActionDescriptor = Assert.IsType<TaskAsyncActionDescriptor>(actionDescriptor);
            Assert.Equal("GenericTaskPattern", castActionDescriptor.TaskMethodInfo.Name);
            Assert.Equal(typeof(Task<string>), castActionDescriptor.TaskMethodInfo.ReturnType);
        }

        [Fact]
        public void FindActionMethod_Asynchronous_ThrowsIfCompletionMethodNotFound()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "EventPatternWithoutCompletionMethod"); },
                @"Could not locate a method named 'EventPatternWithoutCompletionMethodCompleted' on controller type System.Web.Mvc.Async.Test.AsyncActionMethodSelectorTest+MethodLocatorController.");
        }

        [Fact]
        public void FindActionMethod_Asynchronous_ThrowsIfMultipleCompletedMethodsMatched()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act & assert
            Assert.Throws<AmbiguousMatchException>(
                delegate { ActionDescriptorCreator creator = selector.FindAction(new ControllerContext(), "EventPatternAmbiguous"); },
                "Lookup for method 'EventPatternAmbiguousCompleted' on controller type 'MethodLocatorController' failed because of an ambiguity between the following methods:" + Environment.NewLine
              + "Void EventPatternAmbiguousCompleted(Int32) on type System.Web.Mvc.Async.Test.AsyncActionMethodSelectorTest+MethodLocatorController" + Environment.NewLine
              + "Void EventPatternAmbiguousCompleted(System.String) on type System.Web.Mvc.Async.Test.AsyncActionMethodSelectorTest+MethodLocatorController");
        }

        [Fact]
        public void FindAction_NullContext_Throws()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Act & Assert
            Assert.Throws<ArgumentNullException>(() => selector.FindAction(null, "Action"));
        }

        [Fact]
        public void NonAliasedMethodsProperty()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);

            // Act
            AsyncActionMethodSelector selector = new AsyncActionMethodSelector(controllerType);

            // Assert
            Assert.Equal(6, selector.NonAliasedMethods.Count);

            List<MethodInfo> sortedMethods = selector.NonAliasedMethods["foo"].OrderBy(method => method.GetParameters().Length).ToList();
            Assert.Equal("Foo", sortedMethods[0].Name);
            Assert.Empty(sortedMethods[0].GetParameters());
            Assert.Equal("Foo", sortedMethods[1].Name);
            Assert.Equal(typeof(string), sortedMethods[1].GetParameters()[0].ParameterType);

            MethodInfo methodInfo = Assert.Single(selector.NonAliasedMethods["EventPattern"]);
            Assert.Equal("EventPatternAsync", methodInfo.Name);
            methodInfo = Assert.Single(selector.NonAliasedMethods["EventPatternAmbiguous"]);
            Assert.Equal("EventPatternAmbiguousAsync", methodInfo.Name);
            methodInfo = Assert.Single(selector.NonAliasedMethods["EventPatternWithoutCompletionMethod"]);
            Assert.Equal("EventPatternWithoutCompletionMethodAsync", methodInfo.Name);

            methodInfo = Assert.Single(selector.NonAliasedMethods["TaskPattern"]);
            Assert.Equal("TaskPattern", methodInfo.Name);
            methodInfo = Assert.Single(selector.NonAliasedMethods["GenericTaskPattern"]);
            Assert.Equal("GenericTaskPattern", methodInfo.Name);
        }

        private class MethodLocatorController : Controller
        {
            public void Foo()
            {
            }

            public void Foo(string s)
            {
            }

            [ActionName("Foo")]
            public void FooRenamed()
            {
            }

            [ActionName("Bar")]
            public void Bar()
            {
            }

            [ActionName("PrivateVoid")]
            private void PrivateVoid()
            {
            }

            protected void ProtectedVoidAction()
            {
            }

            public static void StaticMethod()
            {
            }

            public void EventPatternAsync()
            {
            }

            public void EventPatternCompleted()
            {
            }

            public void EventPatternWithoutCompletionMethodAsync()
            {
            }

            public void EventPatternAmbiguousAsync()
            {
            }

            public void EventPatternAmbiguousCompleted(int i)
            {
            }

            public void EventPatternAmbiguousCompleted(string s)
            {
            }

            public Task TaskPattern()
            {
                return Task.Factory.StartNew(() => "foo");
            }

            public Task<string> GenericTaskPattern()
            {
                return Task.Factory.StartNew(() => "foo");
            }

            [ActionName("RenamedCompleted")]
            public void Renamed()
            {
            }

            // ensure that methods inheriting from Controller or a base class are not matched
            [ActionName("Blah")]
            protected override void ExecuteCore()
            {
                throw new NotImplementedException();
            }

            public string StringProperty { get; set; }

#pragma warning disable 0067
            public event EventHandler<EventArgs> SomeEvent;
#pragma warning restore 0067
        }

        private class SelectionAttributeController : Controller
        {
            [Match(false)]
            public void OneMatch()
            {
            }

            public void OneMatch(string s)
            {
            }

            public void TwoMatch()
            {
            }

            [ActionName("TwoMatch")]
            public void TwoMatch2()
            {
            }

            [Match(true), ActionName("ShouldMatchMethodWithSelectionAttribute")]
            public void MethodHasSelectionAttribute1()
            {
            }

            [ActionName("ShouldMatchMethodWithSelectionAttribute")]
            public void MethodDoesNotHaveSelectionAttribute1()
            {
            }

            private class MatchAttribute : ActionMethodSelectorAttribute
            {
                private bool _match;

                public MatchAttribute(bool match)
                {
                    _match = match;
                }

                public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
                {
                    return _match;
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/AsyncControllerActionInvokerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Threading;
using System.Web.Mvc.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class AsyncControllerActionInvokerTest
    {
        [Fact]
        public void InvokeAction_ActionNotFound()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ActionNotFound", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void InvokeAction_ActionThrowsException_Handled()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ActionThrowsExceptionAndIsHandled", null, null);
            Assert.Null(((TestController)controllerContext.Controller).Log); // Result filter shouldn't have executed yet

            bool retVal = invoker.EndInvokeAction(asyncResult);
            Assert.True(retVal);
            Assert.Equal("From exception filter", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_ActionThrowsException_NotHandled()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            Assert.Throws<Exception>(
                delegate { invoker.BeginInvokeAction(controllerContext, "ActionThrowsExceptionAndIsNotHandled", null, null); },
                @"Some exception text.");
        }

        [Fact]
        public void InvokeAction_ActionThrowsException_ThreadAbort()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            Assert.Throws<ThreadAbortException>(
                delegate { invoker.BeginInvokeAction(controllerContext, "ActionCallsThreadAbort", null, null); });
        }

        [Fact]
        public void InvokeAction_AuthenticationFilterShortCircuits()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthenticationFilterShortCircuits", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.True(retVal);
            Assert.Equal("From authentication filter", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_AuthenticationFilterChallenges()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthenticationFilterChallenges", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.True(retVal);
            Assert.Equal("From authentication filter challenge", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_AuthenticationFilterShortCircuitsAndChallenges()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthenticationFilterShortCircuitsAndChallenges", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.True(retVal);
            Assert.Equal("From authentication filter challenge", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_AuthorizationFilterShortCircuits()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthorizationFilterShortCircuits", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.True(retVal);
            Assert.Equal("From authorization filter", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_AuthorizationFilterShortCircuitsAndChallenges()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "AuthorizationFilterShortCircuitsAndChallenges", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.True(retVal);
            Assert.Equal("From authentication filter challenge", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_NormalAction()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.True(retVal);
            Assert.Equal("From action", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_OverrideFindAction()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvokerWithCustomFindAction();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, actionName: "Non-ExistantAction", callback: null, state: null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            // Assert
            Assert.True(retVal);
            Assert.Equal("From action", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_RequestValidationFails()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext(passesRequestValidation: false);
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            Assert.Throws<HttpRequestValidationException>(
                delegate { invoker.BeginInvokeAction(controllerContext, "NormalAction", null, null); });
        }

        [Fact]
        public void InvokeAction_ResultThrowsException_Handled()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultThrowsExceptionAndIsHandled", null, null);
            bool retVal = invoker.EndInvokeAction(asyncResult);

            Assert.True(retVal);
            Assert.Equal("From exception filter", ((TestController)controllerContext.Controller).Log);
        }

        [Fact]
        public void InvokeAction_ResultThrowsException_NotHandled()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultThrowsExceptionAndIsNotHandled", null, null);
            Assert.Throws<Exception>(
                delegate { invoker.EndInvokeAction(asyncResult); },
                @"Some exception text.");
        }

        [Fact]
        public void InvokeAction_ResultThrowsException_ThreadAbort()
        {
            // Arrange
            ControllerContext controllerContext = GetControllerContext();
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            IAsyncResult asyncResult = invoker.BeginInvokeAction(controllerContext, "ResultCallsThreadAbort", null, null);
            Assert.Throws<ThreadAbortException>(
                delegate { invoker.EndInvokeAction(asyncResult); });
        }

        [Fact]
        public void InvokeAction_ThrowsIfActionNameIsEmpty()
        {
            // Arrange
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { invoker.BeginInvokeAction(new ControllerContext(), "", null, null); }, "actionName");
        }

        [Fact]
        public void InvokeAction_ThrowsIfActionNameIsNull()
        {
            // Arrange
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { invoker.BeginInvokeAction(new ControllerContext(), null, null, null); }, "actionName");
        }

        [Fact]
        public void InvokeAction_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { invoker.BeginInvokeAction(null, "someAction", null, null); }, "controllerContext");
        }

        [Fact]
        public void InvokeActionMethod_AsynchronousDescriptor()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                ActionResult expectedResult = new ViewResult();

                Mock<AsyncActionDescriptor> mockActionDescriptor = new Mock<AsyncActionDescriptor>();
                mockActionDescriptor.Setup(d => d.BeginExecute(controllerContext, parameters, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult);
                mockActionDescriptor.Setup(d => d.EndExecute(innerAsyncResult)).Returns(expectedResult);

                AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

                // Act
                IAsyncResult asyncResult = invoker.BeginInvokeActionMethod(controllerContext, mockActionDescriptor.Object, parameters, null, null);
                ActionResult returnedResult = invoker.EndInvokeActionMethod(asyncResult);

                // Assert
                Assert.Equal(expectedResult, returnedResult);
            }
        }

        [Fact]
        public void InvokeActionMethod_SynchronousDescriptor()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            ActionResult expectedResult = new ViewResult();

            Mock<ActionDescriptor> mockActionDescriptor = new Mock<ActionDescriptor>();
            mockActionDescriptor.Setup(d => d.Execute(controllerContext, parameters)).Returns(expectedResult);

            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();

            // Act
            IAsyncResult asyncResult = invoker.BeginInvokeActionMethod(controllerContext, mockActionDescriptor.Object, parameters, null, null);
            ActionResult returnedResult = invoker.EndInvokeActionMethod(asyncResult);

            // Assert
            Assert.Equal(expectedResult, returnedResult);
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_BeginExecuteThrowsOnActionExecutingException_Handled()
        {
            // Arrange
            ActionResult expectedResult = new ViewResult();
            Exception expectedException = new Exception("Some exception text.");
            bool onActionExecutingWasCalled = false;
            bool onActionExecutedWasCalled = false;
            ActionFilterImpl actionFilter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = filterContext => { onActionExecutingWasCalled = true; },
                OnActionExecutedImpl = filterContext =>
                {
                    onActionExecutedWasCalled = true;
                    Assert.Same(expectedException, filterContext.Exception);
                    filterContext.ExceptionHandled = true;
                    filterContext.Result = expectedResult;
                }
            };
            Func<IAsyncResult> beginExecute = delegate
            {
                throw expectedException;
            };

            // Act
            ActionResult result = BeginInvokeActionMethodWithFiltersBeginTester(beginExecute, actionFilter);

            // Assert
            Assert.True(onActionExecutingWasCalled);
            Assert.True(onActionExecutedWasCalled);
            Assert.Equal(expectedResult, result);
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_BeginExecuteThrowsOnActionExecutingException_HandledByEarlier()
        {
            // Arrange
            ActionResult expectedResult = new ViewResult();
            List<string> actionLog = new List<string>();
            Exception exception = new Exception("Some exception text.");
            Func<IAsyncResult> beginExecute = delegate
            {
                actionLog.Add("BeginExecute");
                throw exception;
            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting1"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    actionLog.Add("OnActionExecuted1");
                    Assert.Same(exception, filterContext.Exception);
                    filterContext.ExceptionHandled = true;
                    filterContext.Result = expectedResult;
                }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting2"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted2"); }
            };

            // Act
            ActionResult result = BeginInvokeActionMethodWithFiltersBeginTester(beginExecute, filter1, filter2);

            // Assert
            Assert.Equal(new[] { "OnActionExecuting1", "OnActionExecuting2", "BeginExecute", "OnActionExecuted2", "OnActionExecuted1" }, actionLog.ToArray());
            Assert.Equal(expectedResult, result);
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_BeginExecuteThrowsOnActionExecutingException_HandledByLater()
        {
            // Arrange
            List<string> actionLog = new List<string>();
            Exception exception = new Exception("Some exception text.");
            ActionResult expectedResult = new ViewResult();
            Func<IAsyncResult> beginExecute = delegate
            {
                actionLog.Add("BeginExecute");
                throw exception;
            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting1"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted1"); }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting2"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    actionLog.Add("OnActionExecuted2");
                    Assert.Same(exception, filterContext.Exception);
                    filterContext.ExceptionHandled = true;
                    filterContext.Result = expectedResult;
                }
            };

            // Act
            ActionResult result = BeginInvokeActionMethodWithFiltersBeginTester(beginExecute, filter1, filter2);

            // Assert
            Assert.Equal(new[] { "OnActionExecuting1", "OnActionExecuting2", "BeginExecute", "OnActionExecuted2", "OnActionExecuted1" }, actionLog.ToArray());
            Assert.Equal(expectedResult, result);
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_BeginExecuteThrowsOnActionExecutingException_NotHandled()
        {
            // Arrange
            string expectedExceptionText = "Some exception text.";
            Exception expectedException = new Exception(expectedExceptionText);
            bool onActionExecutingWasCalled = false;
            bool onActionExecutedWasCalled = false;
            ActionFilterImpl actionFilter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = filterContext => { onActionExecutingWasCalled = true; },
                OnActionExecutedImpl = filterContext => { onActionExecutedWasCalled = true; }
            };
            Func<IAsyncResult> beginExecute = delegate
            {
                throw expectedException;
            };

            // Act & assert
            Assert.Throws<Exception>(
                delegate
                {
                    BeginInvokeActionMethodWithFiltersBeginTester(beginExecute, actionFilter);
                },
                expectedExceptionText);

            // Assert
            Assert.True(onActionExecutingWasCalled);
            Assert.True(onActionExecutedWasCalled);
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_BeginExecuteThrowsOnActionExecutingException_ThreadAbort()
        {
            // Arrange
            bool onActionExecutingWasCalled = false;
            bool onActionExecutedWasCalled = false;
            ActionFilterImpl actionFilter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = filterContext => { onActionExecutingWasCalled = true; },
                OnActionExecutedImpl = filterContext =>
                {
                    onActionExecutedWasCalled = true;
                    Thread.ResetAbort();
                }
            };
            Func<IAsyncResult> beginExecute = delegate
            {
                Thread.CurrentThread.Abort();
                return null;
            };

            // Act & assert
            Assert.Throws<ThreadAbortException>(
                delegate
                {
                    BeginInvokeActionMethodWithFiltersBeginTester(beginExecute, actionFilter);
                });

            // Assert
            Assert.True(onActionExecutingWasCalled);
            Assert.True(onActionExecutedWasCalled);
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_EndExecuteThrowsOnActionExecutedException_Handled()
        {
            // Arrange
            ViewResult expectedResult = new ViewResult();
            Exception exepctedException = new Exception("Some exception message.");
            bool actionCalled = false;
            bool onActionExecutedCalled = false;
            ActionFilterImpl actionFilter = new ActionFilterImpl()
            {
                OnActionExecutedImpl = (filterContext) =>
                {
                    onActionExecutedCalled = true;
                    Assert.Same(exepctedException, filterContext.Exception);
                    filterContext.ExceptionHandled = true;
                    filterContext.Result = expectedResult;
                }
            };
            Func<ActionResult> action = () =>
            {
                actionCalled = true;
                throw exepctedException;
            };

            using (var mockResult = new MockAsyncResult())
            {
                // Act
                ActionResult result = BeginInvokeActionMethodWithFiltersEndTester(mockResult, action, actionFilter);

                // Assert
                Assert.True(actionCalled);
                Assert.True(onActionExecutedCalled);
                Assert.Equal(expectedResult, result);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_EndExecuteThrowsOnActionExecutedException_HandledByEarlier()
        {
            // Arrange
            List<string> actionLog = new List<string>();
            Exception exception = new Exception("Some exception message.");
            ViewResult expectedResult = new ViewResult();
            Func<ActionResult> action = delegate
            {
                actionLog.Add("EndExecute");
                throw exception;

            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting1"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    actionLog.Add("OnActionExecuted1");
                    Assert.Same(exception, filterContext.Exception);
                    filterContext.ExceptionHandled = true;
                    filterContext.Result = expectedResult;
                }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting2"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted2"); }
            };

            using (var mockResult = new MockAsyncResult())
            {
                // Act
                ActionResult result = BeginInvokeActionMethodWithFiltersEndTester(mockResult, action, filter1, filter2);

                // Assert
                Assert.Equal(new[] { "OnActionExecuting1", "OnActionExecuting2", "EndExecute", "OnActionExecuted2", "OnActionExecuted1" }, actionLog.ToArray());
                Assert.Equal(expectedResult, result);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_EndExecuteThrowsOnActionExecutedException_HandledByLater()
        {
            // Arrange
            List<string> actionLog = new List<string>();
            Exception exception = new Exception("Some exception message.");
            ActionResult expectedResult = new ViewResult();
            Func<ActionResult> action = delegate
            {
                actionLog.Add("EndExecute");
                throw exception;

            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting1"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted1"); }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting2"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    actionLog.Add("OnActionExecuted2");
                    Assert.Same(exception, filterContext.Exception);
                    filterContext.ExceptionHandled = true;
                    filterContext.Result = expectedResult;
                }
            };

            using (var mockResult = new MockAsyncResult())
            {
                // Act
                ActionResult result = BeginInvokeActionMethodWithFiltersEndTester(mockResult, action, filter1, filter2);

                // Assert
                Assert.Equal(new[] { "OnActionExecuting1", "OnActionExecuting2", "EndExecute", "OnActionExecuted2", "OnActionExecuted1" }, actionLog.ToArray());
                Assert.Equal(expectedResult, result);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_EndExecuteThrowsOnActionExecutedException_NotHandled()
        {
            // Arrange
            bool onActionExecutedWasCalled = false;
            string expectedExceptionText = "Some exception text.";
            ActionFilterImpl actionFilter = new ActionFilterImpl()
            {
                OnActionExecutedImpl = filterContext => { onActionExecutedWasCalled = true; }
            };
            Func<ActionResult> action = delegate
            {
                throw new Exception(expectedExceptionText);
            };

            using (var mockResult = new MockAsyncResult())
            {
                // Act & assert
                Assert.Throws<Exception>(
                    () => BeginInvokeActionMethodWithFiltersEndTester(mockResult, action, actionFilter),
                    expectedExceptionText);

                // Assert
                Assert.True(onActionExecutedWasCalled);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_EndExecuteThrowsOnActionExecutedException_ThreadAbort()
        {
            // Arrange
            bool onActionExecutedWasCalled = false;
            ActionFilterImpl actionFilter = new ActionFilterImpl()
            {
                OnActionExecutedImpl = filterContext =>
                {
                    onActionExecutedWasCalled = true;
                    Thread.ResetAbort();
                }
            };
            Func<ActionResult> action = delegate
            {
                Thread.CurrentThread.Abort();
                return null;
            };

            using (var mockResult = new MockAsyncResult())
            {
                // Act & assert
                Assert.Throws<ThreadAbortException>(
                    () => BeginInvokeActionMethodWithFiltersEndTester(mockResult, action, actionFilter));

                // Assert
                Assert.True(onActionExecutedWasCalled);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_NormalExecutionNotCanceled()
        {
            // Arrange
            bool onActionExecutingWasCalled = false;
            bool onActionExecutedWasCalled = false;
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                ActionFilterImpl actionFilter = new ActionFilterImpl()
                {
                    OnActionExecutingImpl = _ => { onActionExecutingWasCalled = true; },
                    OnActionExecutedImpl = _ => { onActionExecutedWasCalled = true; }
                };
                Func<IAsyncResult> beginExecute = delegate
                {
                    return innerAsyncResult;
                };

                // Act
                ActionResult result = BeginInvokeActionMethodWithFiltersBeginTester(beginExecute, actionFilter);

                // Assert
                Assert.True(onActionExecutingWasCalled);
                Assert.True(onActionExecutedWasCalled);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_OnActionExecutingSetsResult()
        {
            // Arrange
            ActionResult expectedResult = new ViewResult();
            ActionResult overriddenResult = new ViewResult();
            bool onActionExecutingWasCalled = false;
            bool onActionExecutedWasCalled = false;
            ActionFilterImpl actionFilter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = filterContext =>
                {
                    onActionExecutingWasCalled = true;
                    filterContext.Result = expectedResult;
                },
                OnActionExecutedImpl = _ => { onActionExecutedWasCalled = true; }
            };
            Func<ActionResult> endExecute = delegate
            {
                return overriddenResult;
            };

            using (var mockResult = new MockAsyncResult())
            {
                // Act
                ActionResult result = BeginInvokeActionMethodWithFiltersTester(() => mockResult, endExecute, checkBegin: false, checkEnd: false, filters: new IActionFilter[] { actionFilter });

                // Assert
                Assert.True(onActionExecutingWasCalled);
                Assert.False(onActionExecutedWasCalled);
                Assert.Equal(expectedResult, result);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_FiltersOrderedCorrectly()
        {
            // Arrange
            List<string> actionLog = new List<string>();
            ActionResult actionResult = new ViewResult();
            Func<ActionResult> continuation = delegate
            {
                actionLog.Add("Continuation");
                return actionResult;

            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting1"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted1"); }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting2"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted2"); }
            };

            using (var mockResult = new MockAsyncResult())
            {
                // Act
                ActionResult result = BeginInvokeActionMethodWithFiltersEndTester(mockResult, continuation, filter1, filter2);

                // Assert
                Assert.Equal(new[] { "OnActionExecuting1", "OnActionExecuting2", "Continuation", "OnActionExecuted2", "OnActionExecuted1" }, actionLog.ToArray());
                Assert.Equal(actionResult, result);
            }
        }

        [Fact]
        public void BeginInvokeActionMethodWithFilters_ShortCircuited()
        {
            // Arrange
            List<string> actionLog = new List<string>();
            ActionResult shortCircuitResult = new ViewResult();
            ActionResult executeResult = new ViewResult();
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actionLog.Add("OnActionExecuting1"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted1"); }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext)
                {
                    actionLog.Add("OnActionExecuting2");
                    filterContext.Result = shortCircuitResult;
                },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actionLog.Add("OnActionExecuted2"); }
            };
            Func<ActionResult> endExecute = () =>
            {
                actionLog.Add("ExecuteCalled");
                return executeResult;
            };

            using (var asyncResult = new MockAsyncResult())
            {
                // Act
                ActionResult result = BeginInvokeActionMethodWithFiltersTester(() => asyncResult, endExecute, checkBegin: false, checkEnd: false, filters: new IActionFilter[] { filter1, filter2 });

                // Assert
                Assert.Equal(new[] { "OnActionExecuting1", "OnActionExecuting2", "OnActionExecuted1" }, actionLog.ToArray());
                Assert.Equal(shortCircuitResult, result);
            }
        }

        private ActionResult BeginInvokeActionMethodWithFiltersBeginTester(Func<IAsyncResult> beginFunction, params IActionFilter[] filters)
        {
            return BeginInvokeActionMethodWithFiltersTester(beginFunction, () => new Mock<ActionResult>().Object, checkBegin: true, checkEnd: false, filters: filters);
        }

        private ActionResult BeginInvokeActionMethodWithFiltersEndTester(IAsyncResult asyncResult, Func<ActionResult> endFunction, params IActionFilter[] filters)
        {
            return BeginInvokeActionMethodWithFiltersTester(() => asyncResult, endFunction, checkBegin: true, checkEnd: true, filters: filters);
        }

        private ActionResult BeginInvokeActionMethodWithFiltersTester(Func<IAsyncResult> beginFunction, Func<ActionResult> endFunction, bool checkBegin, bool checkEnd, IActionFilter[] filters)
        {
            AsyncControllerActionInvoker invoker = new AsyncControllerActionInvoker();
            ControllerContext controllerContext = new ControllerContext();
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            Mock<AsyncActionDescriptor> mockActionDescriptor = new Mock<AsyncActionDescriptor>();
            bool endExecuteCalled = false;
            bool beginExecuteCalled = false;
            Func<ActionResult> endExecute = () =>
            {
                endExecuteCalled = true;
                return endFunction();
            };
            Func<IAsyncResult> beingExecute = () =>
            {
                beginExecuteCalled = true;
                return beginFunction();
            };

            mockActionDescriptor.Setup(d => d.BeginExecute(controllerContext, parameters, It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(beingExecute);
            mockActionDescriptor.Setup(d => d.EndExecute(It.IsAny<IAsyncResult>())).Returns(endExecute);

            IAsyncResult outerAsyncResult = null;
            try
            {
                outerAsyncResult = invoker.BeginInvokeActionMethodWithFilters(controllerContext, filters, mockActionDescriptor.Object, parameters, null, null);
            }
            catch (Exception ex)
            {
                if (checkEnd)
                {
                    // Testing end, so not expecting exception thrown from begin
                    Assert.NotNull(ex);
                }
                else
                {
                    throw ex;
                }
            }

            Assert.NotNull(outerAsyncResult);
            Assert.Equal(checkBegin, beginExecuteCalled);
            Assert.False(endExecuteCalled);

            ActionExecutedContext postContext = invoker.EndInvokeActionMethodWithFilters(outerAsyncResult);

            Assert.NotNull(postContext);
            if (checkEnd)
            {
                Assert.True(endExecuteCalled);
            }
            return postContext.Result;
        }

        private static ActionExecutingContext GetActionExecutingContext()
        {
            return new ActionExecutingContext(new ControllerContext(), new Mock<ActionDescriptor>().Object, new Dictionary<string, object>());
        }

        private static ControllerContext GetControllerContext(bool passesRequestValidation = true)
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            if (passesRequestValidation)
            {
#pragma warning disable 618
                mockHttpContext.Setup(o => o.Request.ValidateInput()).AtMostOnce();
#pragma warning restore 618
            }
            else
            {
                mockHttpContext.Setup(o => o.Request.ValidateInput()).Throws(new HttpRequestValidationException());
            }

            return new ControllerContext()
            {
                Controller = new TestController(),
                HttpContext = mockHttpContext.Object
            };
        }

        private class ActionFilterImpl : IActionFilter, IResultFilter
        {
            public Action<ActionExecutingContext> OnActionExecutingImpl { get; set; }

            public void OnActionExecuting(ActionExecutingContext filterContext)
            {
                if (OnActionExecutingImpl != null)
                {
                    OnActionExecutingImpl(filterContext);
                }
            }

            public Action<ActionExecutedContext> OnActionExecutedImpl { get; set; }

            public void OnActionExecuted(ActionExecutedContext filterContext)
            {
                if (OnActionExecutedImpl != null)
                {
                    OnActionExecutedImpl(filterContext);
                }
            }

            public Action<ResultExecutingContext> OnResultExecutingImpl { get; set; }

            public void OnResultExecuting(ResultExecutingContext filterContext)
            {
                if (OnResultExecutingImpl != null)
                {
                    OnResultExecutingImpl(filterContext);
                }
            }

            public Action<ResultExecutedContext> OnResultExecutedImpl { get; set; }

            public void OnResultExecuted(ResultExecutedContext filterContext)
            {
                if (OnResultExecutedImpl != null)
                {
                    OnResultExecutedImpl(filterContext);
                }
            }
        }

        public class AsyncControllerActionInvokerHelper : AsyncControllerActionInvoker
        {
            public AsyncControllerActionInvokerHelper()
            {
                DescriptorCache = new ControllerDescriptorCache();
            }

            protected override ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext)
            {
                return PublicGetControllerDescriptor(controllerContext);
            }

            public virtual ControllerDescriptor PublicGetControllerDescriptor(ControllerContext controllerContext)
            {
                return base.GetControllerDescriptor(controllerContext);
            }

            protected override ExceptionContext InvokeExceptionFilters(ControllerContext controllerContext, IList<IExceptionFilter> filters, Exception exception)
            {
                return PublicInvokeExceptionFilters(controllerContext, filters, exception);
            }

            public virtual ExceptionContext PublicInvokeExceptionFilters(ControllerContext controllerContext, IList<IExceptionFilter> filters, Exception exception)
            {
                return base.InvokeExceptionFilters(controllerContext, filters, exception);
            }

            protected override void InvokeActionResult(ControllerContext controllerContext, ActionResult actionResult)
            {
                PublicInvokeActionResult(controllerContext, actionResult);
            }

            public virtual void PublicInvokeActionResult(ControllerContext controllerContext, ActionResult actionResult)
            {
                base.InvokeActionResult(controllerContext, actionResult);
            }

            protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return PublicGetFilters(controllerContext, actionDescriptor);
            }

            public virtual FilterInfo PublicGetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return base.GetFilters(controllerContext, actionDescriptor);
            }

            public virtual AuthenticationContext PublicInvokeAuthenticationFilters(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return base.InvokeAuthenticationFilters(controllerContext, filters, actionDescriptor);
            }

            protected override AuthenticationContext InvokeAuthenticationFilters(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return PublicInvokeAuthenticationFilters(controllerContext, filters, actionDescriptor);
            }

            public virtual AuthenticationChallengeContext PublicInvokeAuthenticationFiltersChallenge(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor, ActionResult result)
            {
                return base.InvokeAuthenticationFiltersChallenge(controllerContext, filters, actionDescriptor, result);
            }

            protected override AuthenticationChallengeContext InvokeAuthenticationFiltersChallenge(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor, ActionResult result)
            {
                return PublicInvokeAuthenticationFiltersChallenge(controllerContext, filters, actionDescriptor, result);
            }

            protected override AuthorizationContext InvokeAuthorizationFilters(ControllerContext controllerContext, IList<IAuthorizationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return PublicInvokeAuthorizationFilters(controllerContext, filters, actionDescriptor);
            }

            public virtual AuthorizationContext PublicInvokeAuthorizationFilters(ControllerContext controllerContext, IList<IAuthorizationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return base.InvokeAuthorizationFilters(controllerContext, filters, actionDescriptor);
            }

            protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
            {
                return PublicFindAction(controllerContext, controllerDescriptor, actionName);
            }

            public virtual ActionDescriptor PublicFindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
            {
                return base.FindAction(controllerContext, controllerDescriptor, actionName);
            }

            protected override IDictionary<string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return PublicGetParameterValues(controllerContext, actionDescriptor);
            }

            public virtual IDictionary<string, object> PublicGetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return base.GetParameterValues(controllerContext, actionDescriptor);
            }
        }

        public class AsyncControllerActionInvokerWithCustomFindAction : AsyncControllerActionInvoker
        {
            protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
            {
                return base.FindAction(controllerContext, controllerDescriptor, "NormalAction");
            }
        }

        [ResetThreadAbort]
        private class TestController : AsyncController
        {
            public string Log;

            public ActionResult ActionCallsThreadAbortAsync()
            {
                Thread.CurrentThread.Abort();
                return null;
            }

            public ActionResult ActionCallsThreadAbortCompleted()
            {
                return null;
            }

            public ActionResult ResultCallsThreadAbort()
            {
                return new ActionResultWhichCallsThreadAbort();
            }

            public ActionResult NormalAction()
            {
                return new LoggingActionResult("From action");
            }

            [AuthenticationFilterReturnsResult]
            public void AuthenticationFilterShortCircuits()
            {
            }

            [AuthenticationFilterChallengeSetsResult]
            public void AuthenticationFilterChallenges()
            {
            }

            [AuthenticationFilterReturnsResult]
            [AuthenticationFilterChallengeSetsResult]
            public void AuthenticationFilterShortCircuitsAndChallenges()
            {
            }

            [AuthorizationFilterReturnsResult]
            public void AuthorizationFilterShortCircuits()
            {
            }

            [AuthenticationFilterChallengeSetsResult]
            [AuthorizationFilterReturnsResult]
            public void AuthorizationFilterShortCircuitsAndChallenges()
            {
            }

            [CustomExceptionFilterHandlesError]
            public void ActionThrowsExceptionAndIsHandledAsync()
            {
                throw new Exception("Some exception text.");
            }

            public void ActionThrowsExceptionAndIsHandledCompleted()
            {
            }

            [CustomExceptionFilterDoesNotHandleError]
            public void ActionThrowsExceptionAndIsNotHandledAsync()
            {
                throw new Exception("Some exception text.");
            }

            public void ActionThrowsExceptionAndIsNotHandledCompleted()
            {
            }

            [CustomExceptionFilterHandlesError]
            public ActionResult ResultThrowsExceptionAndIsHandled()
            {
                return new ActionResultWhichThrowsException();
            }

            [CustomExceptionFilterDoesNotHandleError]
            public ActionResult ResultThrowsExceptionAndIsNotHandled()
            {
                return new ActionResultWhichThrowsException();
            }

            private class AuthenticationFilterChallengeSetsResultAttribute : FilterAttribute, IAuthenticationFilter
            {
                public void OnAuthentication(AuthenticationContext filterContext)
                {
                }

                public void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext)
                {
                    filterContext.Result = new LoggingActionResult("From authentication filter challenge");
                }
            }

            private class AuthenticationFilterReturnsResultAttribute : FilterAttribute, IAuthenticationFilter
            {
                public void OnAuthentication(AuthenticationContext filterContext)
                {
                    filterContext.Result = new LoggingActionResult("From authentication filter");
                }

                public void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext)
                {
                }
            }

            private class AuthorizationFilterReturnsResultAttribute : FilterAttribute, IAuthorizationFilter
            {
                public void OnAuthorization(AuthorizationContext filterContext)
                {
                    filterContext.Result = new LoggingActionResult("From authorization filter");
                }
            }

            private class CustomExceptionFilterDoesNotHandleErrorAttribute : FilterAttribute, IExceptionFilter
            {
                public void OnException(ExceptionContext filterContext)
                {
                }
            }

            private class CustomExceptionFilterHandlesErrorAttribute : FilterAttribute, IExceptionFilter
            {
                public void OnException(ExceptionContext filterContext)
                {
                    filterContext.ExceptionHandled = true;
                    filterContext.Result = new LoggingActionResult("From exception filter");
                }
            }

            private class ActionResultWhichCallsThreadAbort : ActionResult
            {
                public override void ExecuteResult(ControllerContext context)
                {
                    Thread.CurrentThread.Abort();
                }
            }

            private class ActionResultWhichThrowsException : ActionResult
            {
                public override void ExecuteResult(ControllerContext context)
                {
                    throw new Exception("Some exception text.");
                }
            }
        }

        private class ResetThreadAbortAttribute : ActionFilterAttribute
        {
            public override void OnActionExecuted(ActionExecutedContext filterContext)
            {
                try
                {
                    Thread.ResetAbort();
                }
                catch (ThreadStateException)
                {
                    // thread wasn't being aborted
                }
            }

            public override void OnResultExecuted(ResultExecutedContext filterContext)
            {
                try
                {
                    Thread.ResetAbort();
                }
                catch (ThreadStateException)
                {
                    // thread wasn't being aborted
                }
            }
        }

        private class LoggingActionResult : ActionResult
        {
            private readonly string _logText;

            public LoggingActionResult(string logText)
            {
                _logText = logText;
            }

            public override void ExecuteResult(ControllerContext context)
            {
                ((TestController)context.Controller).Log = _logText;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/AsyncManagerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class AsyncManagerTest
    {
        [Fact]
        public void FinishEvent_ExplicitCallToFinishMethod()
        {
            // Arrange
            AsyncManager helper = new AsyncManager();

            bool delegateCalled = false;
            helper.Finished += delegate { delegateCalled = true; };

            // Act
            helper.Finish();

            // Assert
            Assert.True(delegateCalled);
        }

        [Fact]
        public void FinishEvent_LinkedToOutstandingOperationsCompletedEvent()
        {
            // Arrange
            AsyncManager helper = new AsyncManager();

            bool delegateCalled = false;
            helper.Finished += delegate { delegateCalled = true; };

            // Act
            helper.OutstandingOperations.Increment();
            helper.OutstandingOperations.Decrement();

            // Assert
            Assert.True(delegateCalled);
        }

        [Fact]
        public void OutstandingOperationsProperty()
        {
            // Act
            AsyncManager helper = new AsyncManager();

            // Assert
            Assert.NotNull(helper.OutstandingOperations);
        }

        [Fact]
        public void ParametersProperty()
        {
            // Act
            AsyncManager helper = new AsyncManager();

            // Assert
            Assert.NotNull(helper.Parameters);
        }

        [Fact]
        public void Sync()
        {
            // Arrange
            Mock<SynchronizationContext> mockSyncContext = new Mock<SynchronizationContext>();
            mockSyncContext
                .Setup(c => c.Send(It.IsAny<SendOrPostCallback>(), null))
                .Callback(
                    delegate(SendOrPostCallback d, object state) { d(state); });

            AsyncManager helper = new AsyncManager(mockSyncContext.Object);
            bool wasCalled = false;

            // Act
            helper.Sync(() => { wasCalled = true; });

            // Assert
            Assert.True(wasCalled);
        }

        [Fact]
        public void TimeoutProperty()
        {
            // Arrange
            int setValue = 50;
            AsyncManager helper = new AsyncManager();

            // Act
            int defaultTimeout = helper.Timeout;
            helper.Timeout = setValue;
            int newTimeout = helper.Timeout;

            // Assert
            Assert.Equal(45000, defaultTimeout);
            Assert.Equal(setValue, newTimeout);
        }

        [Fact]
        public void TimeoutPropertyThrowsIfDurationIsOutOfRange()
        {
            // Arrange
            int timeout = -30;
            AsyncManager helper = new AsyncManager();

            // Act & assert
            Assert.ThrowsArgumentOutOfRange(
                delegate { helper.Timeout = timeout; }, "value",
                @"The timeout value must be non-negative or Timeout.Infinite.");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/AsyncResultWrapperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class AsyncResultWrapperTest
    {
        [Fact]
        public void Begin_AsynchronousCompletion()
        {
            // Arrange
            AsyncCallback capturedCallback = null;
            IAsyncResult resultGivenToCallback = null;
            using (MockAsyncResult innerResult = new MockAsyncResult())
            {
                // Act
                IAsyncResult outerResult = AsyncResultWrapper.Begin<object>(
                    ar => { resultGivenToCallback = ar; },
                    null,
                    (callback, callbackState, state) =>
                    {
                        capturedCallback = callback;
                        return innerResult;
                    },
                    (ar, state) => { },
                    null);

                capturedCallback(innerResult);

                // Assert
                Assert.Equal(outerResult, resultGivenToCallback);
            }
        }

        [Fact]
        public void Begin_AsynchronousCompletionWithState()
        {
            // Arrange
            using (MockAsyncResult innerResult = new MockAsyncResult())
            {
                object invokeState = new object();
                object capturedBeginState = null;
                object capturedEndState = null;

                // Act
                IAsyncResult outerResult = AsyncResultWrapper.Begin(
                    null,
                    null,
                    (AsyncCallback callback, object callbackState, object innerInvokeState) =>
                    {
                        capturedBeginState = innerInvokeState;
                        return innerResult;
                    },
                    (IAsyncResult result, object innerInvokeState) =>
                    {
                        capturedEndState = innerInvokeState;
                    },
                    invokeState,
                    null,
                    Timeout.Infinite);
                AsyncResultWrapper.End(outerResult);

                // Assert
                Assert.Same(invokeState, capturedBeginState);
                Assert.Same(invokeState, capturedEndState);
            }
        }

        [Fact]
        public void Begin_AsynchronousCompletionWithStateAndResult()
        {
            // Arrange
            using (MockAsyncResult innerResult = new MockAsyncResult())
            {
                object invokeState = new object();
                object capturedBeginState = null;
                object capturedEndState = null;
                object expectedRetun = new object();

                // Act
                IAsyncResult outerResult = AsyncResultWrapper.Begin(
                    null,
                    null,
                    (AsyncCallback callback, object callbackState, object innerInvokeState) =>
                    {
                        capturedBeginState = innerInvokeState;
                        return innerResult;
                    },
                    (IAsyncResult result, object innerInvokeState) =>
                    {
                        capturedEndState = innerInvokeState;
                        return expectedRetun;
                    },
                    invokeState,
                    null,
                    Timeout.Infinite);
                object endResult = AsyncResultWrapper.End<object>(outerResult);

                // Assert
                Assert.Same(expectedRetun, endResult);
                Assert.Same(invokeState, capturedBeginState);
                Assert.Same(invokeState, capturedEndState);
            }
        }

        [Fact]
        public void Begin_ReturnsAsyncResultWhichWrapsInnerResult()
        {
            // Arrange
            MockAsyncResult innerResult = new MockAsyncResult()
            {
                AsyncState = "inner state",
                CompletedSynchronously = true,
                IsCompleted = true
            };

            using (innerResult)
            {
                // Act
                IAsyncResult outerResult = AsyncResultWrapper.Begin<object>(
                    null, "outer state",
                    (callback, callbackState, state) => innerResult,
                    (ar, state) => { },
                    null);

                // Assert
                Assert.Equal(innerResult.AsyncState, outerResult.AsyncState);
                Assert.Null(outerResult.AsyncWaitHandle);
                Assert.Equal(innerResult.CompletedSynchronously, outerResult.CompletedSynchronously);
                Assert.Equal(innerResult.IsCompleted, outerResult.IsCompleted);
            }
        }

        [Fact]
        public void Begin_SynchronousCompletion()
        {
            // Arrange
            IAsyncResult resultGivenToCallback = null;
            using (MockAsyncResult innerResult = new MockAsyncResult())
            {
                // Act
                IAsyncResult outerResult = AsyncResultWrapper.Begin<object>(
                    ar => { resultGivenToCallback = ar; },
                    null,
                    (callback, callbackState, state) =>
                    {
                        callback(innerResult);
                        return innerResult;
                    },
                    (ar, state) => { },
                    null);

                // Assert
                Assert.Equal(outerResult, resultGivenToCallback);
            }
        }

        [Fact]
        public void Begin_AsynchronousButAlreadyCompleted()
        {
            // Arrange
            Mock<IAsyncResult> innerResultMock = new Mock<IAsyncResult>();
            innerResultMock.Setup(ir => ir.CompletedSynchronously).Returns(false);
            innerResultMock.Setup(ir => ir.IsCompleted).Returns(true);

            // Act
            IAsyncResult outerResult = AsyncResultWrapper.Begin<object>(
                null,
                null,
                (callback, callbackState, state) =>
                {
                    callback(innerResultMock.Object);
                    return innerResultMock.Object;
                },
                (ar, state) => { },
                null);

            // Assert
            Assert.True(outerResult.CompletedSynchronously);
        }

        [Fact]
        public void Begin_WithCallbackSyncContext_CallsSendIfOperationCompletedAsynchronously()
        {
            // Arrange
            MockAsyncResult asyncResult = new MockAsyncResult()
            {
                CompletedSynchronously = false,
                IsCompleted = false
            };

            using (asyncResult)
            {
                bool originalCallbackCalled = false;
                IAsyncResult passedAsyncResult = null;
                AsyncCallback passedCallback = null;
                AsyncCallback originalCallback = ar =>
                {
                    originalCallbackCalled = true;
                    passedAsyncResult = ar;
                };
                object originalState = new object();
                DummySynchronizationContext syncContext = new DummySynchronizationContext();

                // Act
                IAsyncResult outerResult = AsyncResultWrapper.Begin<object>(
                     originalCallback,
                     originalState,
                     (callback, callbackState, state) =>
                     {
                         passedCallback = callback;
                         asyncResult.AsyncState = callbackState;
                         return asyncResult;
                     },
                     (ar, state) =>
                     {
                         asyncResult.IsCompleted = true;
                         passedCallback(ar);
                     },
                     null,
                     callbackSyncContext: syncContext);
                AsyncResultWrapper.End(outerResult);

                // Assert
                Assert.True(originalCallbackCalled);
                Assert.False(passedAsyncResult.CompletedSynchronously);
                Assert.True(passedAsyncResult.IsCompleted);
                Assert.Same(originalState, passedAsyncResult.AsyncState);
                Assert.True(syncContext.SendCalled);
            }
        }

        [Fact]
        public void Begin_WithCallbackSyncContext_DoesNotCallSendIfOperationCompletedSynchronously()
        {
            // Arrange
            MockAsyncResult asyncResult = new MockAsyncResult()
            {
                CompletedSynchronously = true,
                IsCompleted = true
            };

            using (asyncResult)
            {
                bool originalCallbackCalled = false;
                IAsyncResult passedAsyncResult = null;
                AsyncCallback originalCallback = ar =>
                {
                    passedAsyncResult = ar;
                    originalCallbackCalled = true;
                };
                object originalState = new object();

                DummySynchronizationContext syncContext = new DummySynchronizationContext();

                // Act
                IAsyncResult outerResult = AsyncResultWrapper.Begin<object>(
                    originalCallback,
                    originalState,
                    (callback, callbackState, state) =>
                    {
                        asyncResult.AsyncState = callbackState;
                        return asyncResult;
                    },
                    (ar, state) => { },
                    null,
                    callbackSyncContext: syncContext);

                // Assert
                Assert.True(originalCallbackCalled);
                Assert.True(passedAsyncResult.CompletedSynchronously);
                Assert.True(passedAsyncResult.IsCompleted);
                Assert.Same(originalState, passedAsyncResult.AsyncState);
                Assert.False(syncContext.SendCalled);
            }
        }

        [Fact]
        public void Begin_WithCallbackSyncContext_ThrowsAsyncEvenIfSendContextCaptures()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("Some exception text.");
            CapturingSynchronizationContext capturingSyncContext = new CapturingSynchronizationContext();
            MockAsyncResult asyncResult = new MockAsyncResult()
            {
                CompletedSynchronously = false,
                IsCompleted = true
            };

            using (asyncResult)
            {
                bool originalCallbackCalled = false;
                IAsyncResult passedAsyncResult = null;
                AsyncCallback passedCallback = null;
                AsyncCallback originalCallback = ar =>
                {
                    passedAsyncResult = ar;
                    originalCallbackCalled = true;
                    throw exception;
                };

                // Act & Assert
                IAsyncResult outerResult = AsyncResultWrapper.Begin<object>(
                     originalCallback,
                     null,
                     (callback, callbackState, state) =>
                     {
                         passedCallback = callback;
                         asyncResult.AsyncState = callbackState;
                         return asyncResult;
                     },
                     (ar, state) =>
                     {
                         asyncResult.IsCompleted = true;
                         passedCallback(ar);
                     },
                     null,
                     callbackSyncContext: capturingSyncContext);
                SynchronousOperationException thrownException = Assert.Throws<SynchronousOperationException>(
                    delegate
                    {
                        AsyncResultWrapper.End(outerResult);
                    },
                    @"An operation that crossed a synchronization context failed. See the inner exception for more information.");

                // Assert
                Assert.Equal(exception, thrownException.InnerException);
                Assert.True(originalCallbackCalled);
                Assert.False(passedAsyncResult.CompletedSynchronously);
                Assert.True(capturingSyncContext.SendCalled);
            }
        }

        [Fact]
        public void Begin_WithCallbackSyncContext_ThrowsSynchronous()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("Some exception text.");
            CapturingSynchronizationContext capturingSyncContext = new CapturingSynchronizationContext();
            MockAsyncResult asyncResult = new MockAsyncResult()
            {
                CompletedSynchronously = true,
                IsCompleted = true
            };

            using (asyncResult)
            {
                bool originalCallbackCalled = false;
                IAsyncResult passedAsyncResult = null;
                AsyncCallback originalCallback = ar =>
                {
                    passedAsyncResult = ar;
                    originalCallbackCalled = true;
                    throw exception;
                };

                // Act & Assert
                InvalidOperationException thrownException = Assert.Throws<InvalidOperationException>(
                    delegate
                    {
                        AsyncResultWrapper.Begin<object>(
                            originalCallback,
                            null,
                            (callback, callbackState, state) =>
                            {
                                asyncResult.AsyncState = callbackState;
                                return asyncResult;
                            },
                            (ar, state) => { },
                            null,
                            callbackSyncContext: capturingSyncContext);
                    },
                    exception.Message);

                // Assert
                Assert.Equal(exception, thrownException);
                Assert.True(originalCallbackCalled);
                Assert.True(passedAsyncResult.CompletedSynchronously);
                Assert.False(capturingSyncContext.SendCalled);
            }
        }

        [Fact]
        public void BeginSynchronous_Action()
        {
            // Arrange
            bool actionCalled = false;

            // Act
            IAsyncResult asyncResult = AsyncResultWrapper.BeginSynchronous(callback: null, state: null, action: delegate { actionCalled = true; }, tag: null);
            AsyncResultWrapper.End(asyncResult);

            // Assert
            Assert.True(actionCalled);
            Assert.True(asyncResult.IsCompleted);
            Assert.True(asyncResult.CompletedSynchronously);
        }

        [Fact]
        public void BeginSynchronous_Func()
        {
            object expectedReturn = new object();
            object expectedState = new object();
            object expectedCallbackState = new object();
            bool funcCalled = false;
            bool asyncCalledbackCalled = false;

            // Act
            IAsyncResult asyncResult = AsyncResultWrapper.BeginSynchronous(
                callback: (innerIAsyncResult) =>
                {
                    asyncCalledbackCalled = true;
                    Assert.NotNull(innerIAsyncResult);
                    Assert.Same(expectedCallbackState, innerIAsyncResult.AsyncState);
                    Assert.True(innerIAsyncResult.IsCompleted);
                    Assert.True(innerIAsyncResult.CompletedSynchronously);
                },
                callbackState: expectedCallbackState,
                func: (innerIAsyncResult, innerState) =>
                {
                    funcCalled = true;
                    Assert.NotNull(innerIAsyncResult);
                    Assert.Same(expectedCallbackState, innerIAsyncResult.AsyncState);
                    Assert.Same(expectedState, innerState);
                    Assert.True(innerIAsyncResult.IsCompleted);
                    Assert.True(innerIAsyncResult.CompletedSynchronously);
                    return expectedReturn;
                },
                funcState: expectedState,
                tag: null);
            object retVal = AsyncResultWrapper.End<object>(asyncResult);

            // Assert
            Assert.Same(expectedReturn, retVal);
            Assert.True(asyncResult.IsCompleted);
            Assert.True(asyncResult.CompletedSynchronously);
            Assert.True(funcCalled);
            Assert.True(asyncCalledbackCalled);
        }

        [Fact]
        public void End_ExecutesStoredDelegateAndReturnsValue()
        {
            // Arrange
            using (var mockResult = new MockAsyncResult())
            {
                IAsyncResult asyncResult = AsyncResultWrapper.Begin(
                    null, null,
                    (callback, state) => mockResult,
                    ar => 42);

                // Act
                int returned = AsyncResultWrapper.End<int>(asyncResult);

                // Assert
                Assert.Equal(42, returned);
            }
        }

        [Fact]
        public void End_ThrowsIfAsyncResultIsIncorrectType()
        {
            // Arrange
            using (var mockResult = new MockAsyncResult())
            {
                IAsyncResult asyncResult = AsyncResultWrapper.Begin<object>(
                    null, null,
                    (callback, callbackState, state) => mockResult,
                    (ar, state) => { },
                    null);

                // Act & assert
                Assert.Throws<ArgumentException>(
                    delegate { AsyncResultWrapper.End<int>(asyncResult); },
                    "The provided IAsyncResult is not valid for this method." + Environment.NewLine
                  + "Parameter name: asyncResult");
            }
        }

        [Fact]
        public void End_ThrowsIfAsyncResultIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { AsyncResultWrapper.End(null); }, "asyncResult");
        }

        [Fact]
        public void End_ThrowsIfAsyncResultTagMismatch()
        {
            // Arrange
            using (var mockResult = new MockAsyncResult())
            {
                IAsyncResult asyncResult = AsyncResultWrapper.Begin<object>(
                    null, null,
                    (callback, callbackState, state) => mockResult,
                    (ar, state) => { },
                    null,
                    "some tag");

                // Act & assert
                Assert.Throws<ArgumentException>(
                    delegate { AsyncResultWrapper.End(asyncResult, "some other tag"); },
                    "The provided IAsyncResult is not valid for this method." + Environment.NewLine
                  + "Parameter name: asyncResult");
            }
        }

        [Fact]
        public void End_ThrowsIfCalledTwiceOnSameAsyncResult()
        {
            // Arrange
            using (var mockResult = new MockAsyncResult())
            {
                IAsyncResult asyncResult = AsyncResultWrapper.Begin<object>(
                null, null,
                (callback, callbackState, state) => mockResult,
                (ar, state) => { },
                null);

                // Act & assert
                AsyncResultWrapper.End(asyncResult);
                Assert.Throws<InvalidOperationException>(
                    delegate { AsyncResultWrapper.End(asyncResult); },
                    "The provided IAsyncResult has already been consumed.");
            }
        }

        [Fact]
        public void TimedOut()
        {
            // Arrange
            using (ManualResetEvent waitHandle = new ManualResetEvent(false /* initialState */))
            {
                AsyncCallback callback = ar => { waitHandle.Set(); };

                // Act & assert
                using (var mockResult = new MockAsyncResult())
                {
                    IAsyncResult asyncResult = AsyncResultWrapper.Begin<object>(
                    callback, null,
                    (innerCallback, callbackState, state) => mockResult,
                    (ar, state) => { Assert.True(false, "This callback should never execute since we timed out."); },
                    null,
                    null, 0);

                    // wait for the timeout
                    waitHandle.WaitOne();

                    Assert.True(asyncResult.IsCompleted);
                    Assert.Throws<TimeoutException>(
                        delegate { AsyncResultWrapper.End(asyncResult); });
                }
            }
        }

        private class DummySynchronizationContext : SynchronizationContext
        {
            public bool SendCalled { get; private set; }

            public override void Send(SendOrPostCallback d, object state)
            {
                SendCalled = true;
                base.Send(d, state);
            }
        }

        private class CapturingSynchronizationContext : SynchronizationContext
        {
            public bool SendCalled { get; private set; }

            public override void Send(SendOrPostCallback d, object state)
            {
                try
                {
                    SendCalled = true;
                    d(state);
                }
                catch
                {
                    // swallow exceptions, just like AspNetSynchronizationContext
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/MockAsyncResult.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc.Async.Test
{
    public class MockAsyncResult : IAsyncResult, IDisposable
    {
        private volatile object _asyncState;
        private volatile ManualResetEvent _asyncWaitHandle = new ManualResetEvent(false);
        private volatile bool _completedSynchronously;
        private volatile bool _isCompleted;

        public object AsyncState
        {
            get { return _asyncState; }
            set { _asyncState = value; }
        }

        public ManualResetEvent AsyncWaitHandle
        {
            get { return _asyncWaitHandle; }
            set { _asyncWaitHandle = value; }
        }

        public bool CompletedSynchronously
        {
            get { return _completedSynchronously; }
            set { _completedSynchronously = value; }
        }

        public bool IsCompleted
        {
            get { return _isCompleted; }
            set { _isCompleted = value; }
        }

        public void Dispose()
        {
            _asyncWaitHandle.Dispose();
        }

        #region IAsyncResult Members

        WaitHandle IAsyncResult.AsyncWaitHandle
        {
            get { return _asyncWaitHandle; }
        }

        #endregion
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/OperationCounterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Async.Test
{
    public class OperationCounterTest
    {
        [Fact]
        public void CompletedEvent()
        {
            // Arrange
            bool premature = true;
            bool eventFired = false;
            OperationCounter ops = new OperationCounter();
            ops.Completed += (sender, eventArgs) =>
            {
                if (premature)
                {
                    Assert.True(false, "Event fired too early!");
                }
                if (eventFired)
                {
                    Assert.True(false, "Event fired multiple times.");
                }

                Assert.Equal(ops, sender);
                Assert.Equal(eventArgs, EventArgs.Empty);
                eventFired = true;
            };

            // Act & assert
            ops.Increment(); // should not fire event (will throw exception)
            premature = false;

            ops.Decrement(); // should fire event
            Assert.True(eventFired);

            ops.Increment(); // should not fire event (will throw exception)
        }

        [Fact]
        public void CountStartsAtZero()
        {
            // Arrange
            OperationCounter ops = new OperationCounter();

            // Act & assert
            Assert.Equal(0, ops.Count);
        }

        [Fact]
        public void DecrementWithIntegerArgument()
        {
            // Arrange
            OperationCounter ops = new OperationCounter();

            // Act
            int returned = ops.Decrement(3);
            int newCount = ops.Count;

            // Assert
            Assert.Equal(-3, returned);
            Assert.Equal(-3, newCount);
        }

        [Fact]
        public void DecrementWithNoArguments()
        {
            // Arrange
            OperationCounter ops = new OperationCounter();

            // Act
            int returned = ops.Decrement();
            int newCount = ops.Count;

            // Assert
            Assert.Equal(-1, returned);
            Assert.Equal(-1, newCount);
        }

        [Fact]
        public void IncrementWithIntegerArgument()
        {
            // Arrange
            OperationCounter ops = new OperationCounter();

            // Act
            int returned = ops.Increment(3);
            int newCount = ops.Count;

            // Assert
            Assert.Equal(3, returned);
            Assert.Equal(3, newCount);
        }

        [Fact]
        public void IncrementWithNoArguments()
        {
            // Arrange
            OperationCounter ops = new OperationCounter();

            // Act
            int returned = ops.Increment();
            int newCount = ops.Count;

            // Assert
            Assert.Equal(1, returned);
            Assert.Equal(1, newCount);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/ReflectedAsyncActionDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class ReflectedAsyncActionDescriptorTest
    {
        private readonly MethodInfo _asyncMethod = typeof(ExecuteController).GetMethod("FooAsync");
        private readonly MethodInfo _completedMethod = typeof(ExecuteController).GetMethod("FooCompleted");

        [Fact]
        public void Constructor_SetsProperties()
        {
            // Arrange
            string actionName = "SomeAction";
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act
            ReflectedAsyncActionDescriptor ad = new ReflectedAsyncActionDescriptor(_asyncMethod, _completedMethod, actionName, cd);

            // Assert
            Assert.Equal(_asyncMethod, ad.AsyncMethodInfo);
            Assert.Equal(_completedMethod, ad.CompletedMethodInfo);
            Assert.Equal(actionName, ad.ActionName);
            Assert.Equal(cd, ad.ControllerDescriptor);
        }

        [Fact]
        public void Constructor_ThrowsIfActionNameIsEmpty()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new ReflectedAsyncActionDescriptor(_asyncMethod, _completedMethod, "", cd); }, "actionName");
        }

        [Fact]
        public void Constructor_ThrowsIfActionNameIsNull()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new ReflectedAsyncActionDescriptor(_asyncMethod, _completedMethod, null, cd); }, "actionName");
        }

        [Fact]
        public void Constructor_ThrowsIfAsyncMethodInfoIsInvalid()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            MethodInfo getHashCodeMethod = typeof(object).GetMethod("GetHashCode");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new ReflectedAsyncActionDescriptor(getHashCodeMethod, _completedMethod, "SomeAction", cd); },
                "Cannot create a descriptor for instance method 'Int32 GetHashCode()' on type 'System.Object' because the type does not derive from ControllerBase." + Environment.NewLine
              + "Parameter name: asyncMethodInfo");
        }

        [Fact]
        public void Constructor_ThrowsIfAsyncMethodInfoIsNull()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedAsyncActionDescriptor(null, _completedMethod, "SomeAction", cd); }, "asyncMethodInfo");
        }

        [Fact]
        public void Constructor_ThrowsIfCompletedMethodInfoIsInvalid()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            MethodInfo getHashCodeMethod = typeof(object).GetMethod("GetHashCode");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new ReflectedAsyncActionDescriptor(_asyncMethod, getHashCodeMethod, "SomeAction", cd); },
                "Cannot create a descriptor for instance method 'Int32 GetHashCode()' on type 'System.Object' because the type does not derive from ControllerBase." + Environment.NewLine
              + "Parameter name: completedMethodInfo");
        }

        [Fact]
        public void Constructor_ThrowsIfCompletedMethodInfoIsNull()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedAsyncActionDescriptor(_asyncMethod, null, "SomeAction", cd); }, "completedMethodInfo");
        }

        [Fact]
        public void Constructor_ThrowsIfControllerDescriptorIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedAsyncActionDescriptor(_asyncMethod, _completedMethod, "SomeAction", null); }, "controllerDescriptor");
        }

        [Fact]
        public void Execute()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.Controller).Returns(new ExecuteController());
            ControllerContext controllerContext = mockControllerContext.Object;

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "id1", 42 }
            };

            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);

            using (SignalContainer<object> resultContainer = new SignalContainer<object>())
            {
                AsyncCallback callback = ar =>
                {
                    object o = ad.EndExecute(ar);
                    resultContainer.Signal(o);
                };

                // Act
                ad.BeginExecute(controllerContext, parameters, callback, null);
                object retVal = resultContainer.Wait();

                // Assert
                Assert.Equal("Hello world: 42", retVal);
            }
        }

        [Fact]
        public void Execute_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.BeginExecute(null, new Dictionary<string, object>(), null, null); }, "controllerContext");
        }

        [Fact]
        public void Execute_ThrowsIfControllerIsNotAsyncManagerContainer()
        {
            // Arrange
            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);
            ControllerContext controllerContext = new ControllerContext()
            {
                Controller = new RegularSyncController()
            };

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { ad.BeginExecute(controllerContext, new Dictionary<string, object>(), null, null); },
                "The controller of type 'System.Web.Mvc.Async.Test.ReflectedAsyncActionDescriptorTest+RegularSyncController' must subclass AsyncController or implement the IAsyncManagerContainer interface.");
        }

        [Fact]
        public void Execute_ThrowsIfParametersIsNull()
        {
            // Arrange
            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.BeginExecute(new ControllerContext(), null, null, null); }, "parameters");
        }

        [Fact]
        public void GetCustomAttributes()
        {
            // Arrange
            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);

            // Act
            object[] attributes = ad.GetCustomAttributes(true /* inherit */);

            // Assert
            object attribute = Assert.Single(attributes);
            Assert.IsType<AuthorizeAttribute>(attribute);
        }

        [Fact]
        public void GetCustomAttributes_FilterByType()
        {
            // Shouldn't match attributes on the Completed() method, only the Async() method

            // Arrange
            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);

            // Act
            object[] attributes = ad.GetCustomAttributes(typeof(OutputCacheAttribute), true /* inherit */);

            // Assert
            Assert.Empty(attributes);
        }

        [Fact]
        public void GetParameters()
        {
            // Arrange
            ParameterInfo pInfo = _asyncMethod.GetParameters()[0];
            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);

            // Act
            ParameterDescriptor[] pDescsFirstCall = ad.GetParameters();
            ParameterDescriptor[] pDescsSecondCall = ad.GetParameters();

            // Assert
            Assert.NotSame(pDescsFirstCall, pDescsSecondCall);
            Assert.Equal(pDescsFirstCall, pDescsSecondCall);

            ParameterDescriptor parameterDescriptor = Assert.Single(pDescsFirstCall);
            ReflectedParameterDescriptor pDesc = Assert.IsType<ReflectedParameterDescriptor>(parameterDescriptor);

            Assert.NotNull(pDesc);
            Assert.Same(ad, pDesc.ActionDescriptor);
            Assert.Same(pInfo, pDesc.ParameterInfo);
        }

        [Fact]
        public void GetSelectors()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();

            Mock<ActionMethodSelectorAttribute> mockAttr = new Mock<ActionMethodSelectorAttribute>();
            mockAttr.Setup(attr => attr.IsValidForRequest(controllerContext, mockMethod.Object)).Returns(true).Verifiable();
            mockMethod.Setup(m => m.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true)).Returns(new ActionMethodSelectorAttribute[] { mockAttr.Object });

            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(mockMethod.Object, _completedMethod);

            // Act
            ICollection<ActionSelector> selectors = ad.GetSelectors();
            bool executedSuccessfully = selectors.All(s => s(controllerContext));

            // Assert
            Assert.Single(selectors);
            Assert.True(executedSuccessfully);
            mockAttr.Verify();
        }

        [Fact]
        public void IsDefined()
        {
            // Arrange
            ReflectedAsyncActionDescriptor ad = GetActionDescriptor(_asyncMethod, _completedMethod);

            // Act
            bool isDefined = ad.IsDefined(typeof(AuthorizeAttribute), true /* inherit */);

            // Assert
            Assert.True(isDefined);
        }

        private static ReflectedAsyncActionDescriptor GetActionDescriptor(MethodInfo asyncMethod, MethodInfo completedMethod)
        {
            return new ReflectedAsyncActionDescriptor(asyncMethod, completedMethod, "someName", new Mock<ControllerDescriptor>().Object, false /* validateMethod */)
            {
                DispatcherCache = new ActionMethodDispatcherCache()
            };
        }

        private class ExecuteController : AsyncController
        {
            private Func<object, string> _func;

            [Authorize]
            public void FooAsync(int id1)
            {
                _func = o => Convert.ToString(o, CultureInfo.InvariantCulture) + id1.ToString(CultureInfo.InvariantCulture);
                AsyncManager.Parameters["id2"] = "Hello world: ";
                AsyncManager.Finish();
            }

            [OutputCache]
            public string FooCompleted(string id2)
            {
                return _func(id2);
            }

            public string FooWithBool(bool id2)
            {
                return _func(id2);
            }

            public string FooWithException(Exception id2)
            {
                return _func(id2);
            }
        }

        private class RegularSyncController : ControllerBase
        {
            protected override void ExecuteCore()
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/ReflectedAsyncControllerDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class ReflectedAsyncControllerDescriptorTest
    {
        [Fact]
        public void ConstructorSetsControllerTypeProperty()
        {
            // Arrange
            Type controllerType = typeof(string);

            // Act
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(controllerType);

            // Assert
            Assert.Same(controllerType, cd.ControllerType);
        }

        [Fact]
        public void ConstructorThrowsIfControllerTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedAsyncControllerDescriptor(null); }, "controllerType");
        }

        [Fact]
        public void FindActionReturnsActionDescriptorIfFound()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            MethodInfo asyncMethodInfo = controllerType.GetMethod("FooAsync");
            MethodInfo completedMethodInfo = controllerType.GetMethod("FooCompleted");
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(controllerType);

            // Act
            ActionDescriptor ad = cd.FindAction(new ControllerContext(), "NewName");

            // Assert
            Assert.Equal("NewName", ad.ActionName);
            var castAd = Assert.IsType<ReflectedAsyncActionDescriptor>(ad);

            Assert.Same(asyncMethodInfo, castAd.AsyncMethodInfo);
            Assert.Same(completedMethodInfo, castAd.CompletedMethodInfo);
            Assert.Same(cd, ad.ControllerDescriptor);
        }

        [Fact]
        public void FindActionReturnsNullIfNoActionFound()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(controllerType);

            // Act
            ActionDescriptor ad = cd.FindAction(new ControllerContext(), "NonExistent");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionThrowsIfActionNameIsEmpty()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(controllerType);

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { cd.FindAction(new ControllerContext(), ""); }, "actionName");
        }

        [Fact]
        public void FindActionThrowsIfActionNameIsNull()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(controllerType);

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { cd.FindAction(new ControllerContext(), null); }, "actionName");
        }

        [Fact]
        public void FindActionThrowsIfControllerContextIsNull()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(controllerType);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { cd.FindAction(null, "someName"); }, "controllerContext");
        }

        [Fact]
        public void GetCanonicalActionsReturnsEmptyArray()
        {
            // this method does nothing by default

            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(controllerType);

            // Act
            ActionDescriptor[] canonicalActions = cd.GetCanonicalActions();

            // Assert
            Assert.Empty(canonicalActions);
        }

        [Fact]
        public void GetCustomAttributesCallsTypeGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<Type> mockType = new Mock<Type>();
            mockType.Setup(t => t.GetCustomAttributes(true)).Returns(expected);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(mockType.Object);

            // Act
            object[] returned = cd.GetCustomAttributes(true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetCustomAttributesWithAttributeTypeCallsTypeGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<Type> mockType = new Mock<Type>();
            mockType.Setup(t => t.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(mockType.Object);

            // Act
            object[] returned = cd.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void IsDefinedCallsTypeIsDefined()
        {
            // Arrange
            Mock<Type> mockType = new Mock<Type>();
            mockType.Setup(t => t.IsDefined(typeof(ObsoleteAttribute), true)).Returns(true);
            ReflectedAsyncControllerDescriptor cd = new ReflectedAsyncControllerDescriptor(mockType.Object);

            // Act
            bool isDefined = cd.IsDefined(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.True(isDefined);
        }

        private class MyController : AsyncController
        {
            [ActionName("NewName")]
            public void FooAsync()
            {
            }

            public void FooCompleted()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/SignalContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;

namespace System.Web.Mvc.Async.Test
{
    public sealed class SignalContainer<T>: IDisposable
    {
        private volatile object _item;
        private readonly AutoResetEvent _waitHandle = new AutoResetEvent(false /* initialState */);

        public void Signal(T item)
        {
            _item = item;
            _waitHandle.Set();
        }

        public T Wait()
        {
            _waitHandle.WaitOne();
            return (T)_item;
        }

        public void Dispose()
        {
            _waitHandle.Dispose();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/SimpleAsyncResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Async.Test
{
    public class SimpleAsyncResultTest
    {
        [Fact]
        public void AsyncStateProperty()
        {
            // Arrange
            string expected = "Hello!";
            SimpleAsyncResult asyncResult = new SimpleAsyncResult(expected);

            // Act
            object asyncState = asyncResult.AsyncState;

            // Assert
            Assert.Equal(expected, asyncState);
        }

        [Fact]
        public void AsyncWaitHandleProperty()
        {
            // Arrange
            SimpleAsyncResult asyncResult = new SimpleAsyncResult(null);

            // Act
            WaitHandle asyncWaitHandle = asyncResult.AsyncWaitHandle;

            // Assert
            Assert.Null(asyncWaitHandle);
        }

        [Fact]
        public void CompletedSynchronouslyProperty()
        {
            // Arrange
            SimpleAsyncResult asyncResult = new SimpleAsyncResult(null);

            // Act
            bool completedSynchronously = asyncResult.CompletedSynchronously;

            // Assert
            Assert.False(completedSynchronously);
        }

        [Fact]
        public void IsCompletedProperty()
        {
            // Arrange
            SimpleAsyncResult asyncResult = new SimpleAsyncResult(null);

            // Act
            bool isCompleted = asyncResult.IsCompleted;

            // Assert
            Assert.False(isCompleted);
        }

        [Fact]
        public void MarkCompleted_AsynchronousCompletion()
        {
            // Arrange
            SimpleAsyncResult asyncResult = new SimpleAsyncResult(null);

            bool callbackWasCalled = false;
            AsyncCallback callback = ar =>
            {
                callbackWasCalled = true;
                Assert.Equal(asyncResult, ar);
                Assert.True(ar.IsCompleted);
                Assert.False(ar.CompletedSynchronously);
            };

            // Act & assert
            asyncResult.MarkCompleted(false, callback);
            Assert.True(callbackWasCalled);
        }

        [Fact]
        public void MarkCompleted_SynchronousCompletion()
        {
            // Arrange
            SimpleAsyncResult asyncResult = new SimpleAsyncResult(null);

            bool callbackWasCalled = false;
            AsyncCallback callback = ar =>
            {
                callbackWasCalled = true;
                Assert.Equal(asyncResult, ar);
                Assert.True(ar.IsCompleted);
                Assert.True(ar.CompletedSynchronously);
            };

            // Act & assert
            asyncResult.MarkCompleted(true, callback);
            Assert.True(callbackWasCalled);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/SingleEntryGateTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Async.Test
{
    public class SingleEntryGateTest
    {
        [Fact]
        public void TryEnterShouldBeTrueForFirstCallAndFalseForSubsequentCalls()
        {
            // Arrange
            SingleEntryGate gate = new SingleEntryGate();

            // Act
            bool firstCall = gate.TryEnter();
            bool secondCall = gate.TryEnter();
            bool thirdCall = gate.TryEnter();

            // Assert
            Assert.True(firstCall);
            Assert.False(secondCall);
            Assert.False(thirdCall);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/SynchronizationContextUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class SynchronizationContextUtilTest
    {
        [Fact]
        public void SyncWithAction()
        {
            // Arrange
            bool actionWasCalled = false;
            bool sendWasCalled = false;

            Mock<SynchronizationContext> mockSyncContext = new Mock<SynchronizationContext>();
            mockSyncContext
                .Setup(sc => sc.Send(It.IsAny<SendOrPostCallback>(), null))
                .Callback(
                    delegate(SendOrPostCallback d, object state)
                    {
                        sendWasCalled = true;
                        d(state);
                    });

            // Act
            SynchronizationContextUtil.Sync(mockSyncContext.Object, () => { actionWasCalled = true; });

            // Assert
            Assert.True(actionWasCalled);
            Assert.True(sendWasCalled);
        }

        [Fact]
        public void SyncWithActionCapturesException()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("Some exception text.");

            Mock<SynchronizationContext> mockSyncContext = new Mock<SynchronizationContext>();
            mockSyncContext
                .Setup(sc => sc.Send(It.IsAny<SendOrPostCallback>(), null))
                .Callback(
                    delegate(SendOrPostCallback d, object state)
                    {
                        try
                        {
                            d(state);
                        }
                        catch
                        {
                            // swallow exceptions, just like AspNetSynchronizationContext
                        }
                    });

            // Act & assert
            SynchronousOperationException thrownException = Assert.Throws<SynchronousOperationException>(
                delegate { SynchronizationContextUtil.Sync(mockSyncContext.Object, () => { throw exception; }); },
                @"An operation that crossed a synchronization context failed. See the inner exception for more information.");

            Assert.Equal(exception, thrownException.InnerException);
        }

        [Fact]
        public void SyncWithFunc()
        {
            // Arrange
            bool sendWasCalled = false;

            Mock<SynchronizationContext> mockSyncContext = new Mock<SynchronizationContext>();
            mockSyncContext
                .Setup(sc => sc.Send(It.IsAny<SendOrPostCallback>(), null))
                .Callback(
                    delegate(SendOrPostCallback d, object state)
                    {
                        sendWasCalled = true;
                        d(state);
                    });

            // Act
            int retVal = SynchronizationContextUtil.Sync(mockSyncContext.Object, () => 42);

            // Assert
            Assert.Equal(42, retVal);
            Assert.True(sendWasCalled);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/SynchronousOperationExceptionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Async.Test
{
    public class SynchronousOperationExceptionTest
    {
        [Fact]
        public void ConstructorWithMessageAndInnerExceptionParameter()
        {
            // Arrange
            Exception innerException = new Exception();

            // Act
            SynchronousOperationException ex = new SynchronousOperationException("the message", innerException);

            // Assert
            Assert.Equal("the message", ex.Message);
            Assert.Equal(innerException, ex.InnerException);
        }

        [Fact]
        public void ConstructorWithMessageParameter()
        {
            // Act
            SynchronousOperationException ex = new SynchronousOperationException("the message");

            // Assert
            Assert.Equal("the message", ex.Message);
        }

        [Fact]
        public void ConstructorWithoutParameters()
        {
            // Act & assert
            Assert.Throws<SynchronousOperationException>(
                delegate { throw new SynchronousOperationException(); });
        }

        [Fact]
        public void TypeIsSerializable()
        {
            // Arrange
            MemoryStream ms = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            SynchronousOperationException ex = new SynchronousOperationException("the message", new Exception("inner exception"));

            // Act
            formatter.Serialize(ms, ex);
            ms.Position = 0;
            SynchronousOperationException deserialized = formatter.Deserialize(ms) as SynchronousOperationException;

            // Assert
            Assert.NotNull(deserialized);
            Assert.Equal("the message", deserialized.Message);
            Assert.NotNull(deserialized.InnerException);
            Assert.Equal("inner exception", deserialized.InnerException.Message);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/TaskAsyncActionDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class TaskAsyncActionDescriptorTest
    {
        private readonly MethodInfo _taskMethod = typeof(ExecuteController).GetMethod("SimpleTask");

        [Fact]
        public void Constructor_SetsProperties()
        {
            // Arrange
            string actionName = "SomeAction";
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act
            TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(_taskMethod, actionName, cd);

            // Assert
            Assert.Equal(_taskMethod, ad.TaskMethodInfo);
            Assert.Equal(actionName, ad.ActionName);
            Assert.Equal(cd, ad.ControllerDescriptor);
        }

        [Fact]
        public void Constructor_ThrowsIfActionNameIsEmpty()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new TaskAsyncActionDescriptor(_taskMethod, "", cd); }, "actionName");
        }

        [Fact]
        public void Constructor_ThrowsIfActionNameIsNull()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new TaskAsyncActionDescriptor(_taskMethod, null, cd); }, "actionName");
        }

        [Fact]
        public void Constructor_ThrowsIfTaskMethodInfoIsInvalid()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            MethodInfo getHashCodeMethod = typeof(object).GetMethod("GetHashCode");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new TaskAsyncActionDescriptor(getHashCodeMethod, "SomeAction", cd); },
                "Cannot create a descriptor for instance method 'Int32 GetHashCode()' on type 'System.Object' because the type does not derive from ControllerBase." + Environment.NewLine
              + "Parameter name: taskMethodInfo");
        }

        [Fact]
        public void Constructor_ThrowsIfTaskMethodInfoIsNull()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new TaskAsyncActionDescriptor(null, "SomeAction", cd); }, "taskMethodInfo");
        }

        [Fact]
        public void Constructor_ThrowsIfControllerDescriptorIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new TaskAsyncActionDescriptor(_taskMethod, "SomeAction", null); }, "controllerDescriptor");
        }

        [Fact]
        public void ExecuteTask()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTask"));

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "doWork", true }
            };

            ControllerContext controllerContext = GetControllerContext();

            // Act
            object retVal = ExecuteHelper(actionDescriptor, parameters, controllerContext);

            // Assert
            Assert.Null(retVal);
            Assert.True((controllerContext.Controller as ExecuteController).WorkDone);
        }

        [Fact]
        public void ExecuteTaskGeneric()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("GenericTask"));

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "taskId", "foo" }
            };

            // Act
            object retVal = ExecuteHelper(actionDescriptor, parameters);

            // Assert
            Assert.Equal("foo", retVal);
        }

        [Fact]
        public void ExecuteTaskPreservesStackTraceOnException()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTaskException"));

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "doWork", true }
            };

            // Act
            IAsyncResult result = actionDescriptor.BeginExecute(GetControllerContext(), parameters, null, null);

            // Assert
            InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
                () => actionDescriptor.EndExecute(result),
                "Test exception from action"
                );

            Assert.Contains("System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest.ExecuteController.", ex.StackTrace);
        }

        [Fact]
        public void ExecuteTaskGenericPreservesStackTraceOnException()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("GenericTaskException"));

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "taskId", "foo" },
                { "throwException", true }
            };

            // Act
            IAsyncResult result = actionDescriptor.BeginExecute(GetControllerContext(), parameters, null, null);

            // Assert
            InvalidOperationException ex = Assert.Throws<InvalidOperationException>(
                () => actionDescriptor.EndExecute(result),
                "Test exception from action"
                );

            Assert.Contains("System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest.ExecuteController.", ex.StackTrace);
        }

        [Fact]
        public void ExecuteTaskOfPrivateT()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskOfPrivateT"));
            ControllerContext controllerContext = GetControllerContext();

            Dictionary<string, object> parameters = new Dictionary<string, object>();

            // Act
            object retVal = ExecuteHelper(actionDescriptor, parameters, controllerContext);

            // Assert
            Assert.Null(retVal);
            Assert.True((controllerContext.Controller as ExecuteController).WorkDone);
        }

        [Fact]
        public void ExecuteTaskPreservesState()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTask"));

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "doWork", true }
            };

            ControllerContext controllerContext = GetControllerContext();

            // Act
            TaskWrapperAsyncResult result = (TaskWrapperAsyncResult)actionDescriptor.BeginExecute(GetControllerContext(), parameters, callback: null, state: "state");

            // Assert
            Assert.Equal("state", result.AsyncState);
        }

        [Fact]
        public void ExecuteTaskWithNullParameterAndTimeout()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskTimeoutWithNullParam"));

            Dictionary<string, object> token = new Dictionary<string, object>()
            {
                { "nullParam", null },
                { "cancellationToken", new CancellationToken() }
            };

            // Act & assert
            Assert.Throws<TimeoutException>(
                () => actionDescriptor.EndExecute(actionDescriptor.BeginExecute(GetControllerContext(0), parameters: token, callback: null, state: null)),
                "The operation has timed out."
                );
        }

        [Fact]
        public void ExecuteWithInfiniteTimeout()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskWithInfiniteTimeout"));
            ControllerContext controllerContext = GetControllerContext(Timeout.Infinite);

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "cancellationToken", new CancellationToken() }
            };

            // Act
            object retVal = ExecuteHelper(actionDescriptor, parameters);

            // Assert
            Assert.Equal("Task Completed", retVal);
        }

        [Fact]
        public void ExecuteTaskWithImmediateTimeout()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskTimeout"));

            Dictionary<string, object> token = new Dictionary<string, object>()
            {
                { "cancellationToken", new CancellationToken() }
            };

            // Act & assert
            Assert.Throws<TimeoutException>(
                () => actionDescriptor.EndExecute(actionDescriptor.BeginExecute(GetControllerContext(0), parameters: token, callback: null, state: null)),
                "The operation has timed out."
                );
        }

        [Fact]
        public void ExecuteTaskWithTimeout()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("TaskTimeout"));

            Dictionary<string, object> token = new Dictionary<string, object>()
            {
                { "cancellationToken", new CancellationToken() }
            };

            // Act & assert
            Assert.Throws<TimeoutException>(
                () => actionDescriptor.EndExecute(actionDescriptor.BeginExecute(GetControllerContext(2000), parameters: token, callback: null, state: null)),
                "The operation has timed out."
                );
        }

        [Fact]
        public void SynchronousExecuteThrows()
        {
            // Arrange
            TaskAsyncActionDescriptor actionDescriptor = GetActionDescriptor(GetExecuteControllerMethodInfo("SimpleTask"));

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { actionDescriptor.Execute(new ControllerContext(), new Dictionary<string, object>()); }, "The asynchronous action method 'someName' returns a Task, which cannot be executed synchronously.");
        }

        [Fact]
        public void Execute_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.BeginExecute(null, new Dictionary<string, object>(), null, null); }, "controllerContext");
        }

        [Fact]
        public void Execute_ThrowsIfControllerIsNotAsyncManagerContainer()
        {
            // Arrange
            TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);
            ControllerContext controllerContext = new ControllerContext()
            {
                Controller = new RegularSyncController()
            };

            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "doWork", true }
            };

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { ad.BeginExecute(controllerContext, parameters, null, null); },
                @"The controller of type 'System.Web.Mvc.Async.Test.TaskAsyncActionDescriptorTest+RegularSyncController' must subclass AsyncController or implement the IAsyncManagerContainer interface.");
        }

        [Fact]
        public void Execute_ThrowsIfParametersIsNull()
        {
            // Arrange
            TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.BeginExecute(new ControllerContext(), null, null, null); }, "parameters");
        }

        [Fact]
        public void GetCustomAttributesCallsMethodInfoGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
            mockMethod.Setup(mi => mi.GetCustomAttributes(true)).Returns(expected);
            TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
            {
                DispatcherCache = new ActionMethodDispatcherCache()
            };

            // Act
            object[] returned = ad.GetCustomAttributes(true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetCustomAttributesWithAttributeTypeCallsMethodInfoGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
            mockMethod.Setup(mi => mi.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
            TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
            {
                DispatcherCache = new ActionMethodDispatcherCache()
            };

            // Act
            object[] returned = ad.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetParameters()
        {
            // Arrange
            ParameterInfo pInfo = _taskMethod.GetParameters()[0];
            TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);

            // Act
            ParameterDescriptor[] pDescsFirstCall = ad.GetParameters();
            ParameterDescriptor[] pDescsSecondCall = ad.GetParameters();

            // Assert
            Assert.NotSame(pDescsFirstCall, pDescsSecondCall); // Should get a new array every time
            Assert.Equal(pDescsFirstCall, pDescsSecondCall);

            ParameterDescriptor parameterDescriptor = Assert.Single(pDescsFirstCall);
            ReflectedParameterDescriptor pDesc = Assert.IsType<ReflectedParameterDescriptor>(parameterDescriptor);

            Assert.NotNull(pDesc);
            Assert.Same(ad, pDesc.ActionDescriptor);
            Assert.Same(pInfo, pDesc.ParameterInfo);
        }

        [Fact]
        public void GetSelectors()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();

            Mock<ActionMethodSelectorAttribute> mockAttr = new Mock<ActionMethodSelectorAttribute>();
            mockAttr.Setup(attr => attr.IsValidForRequest(controllerContext, mockMethod.Object)).Returns(true).Verifiable();
            mockMethod.Setup(m => m.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true)).Returns(new ActionMethodSelectorAttribute[] { mockAttr.Object });

            TaskAsyncActionDescriptor ad = new TaskAsyncActionDescriptor(mockMethod.Object, "someName", new Mock<ControllerDescriptor>().Object, validateMethod: false)
            {
                DispatcherCache = new ActionMethodDispatcherCache()
            };

            // Act
            ICollection<ActionSelector> selectors = ad.GetSelectors();
            bool executedSuccessfully = selectors.All(s => s(controllerContext));

            // Assert
            Assert.Single(selectors);
            Assert.True(executedSuccessfully);
            mockAttr.Verify();
        }

        [Fact]
        public void IsDefined()
        {
            // Arrange
            TaskAsyncActionDescriptor ad = GetActionDescriptor(_taskMethod);

            // Act
            bool isDefined = ad.IsDefined(typeof(AuthorizeAttribute), inherit: true);

            // Assert
            Assert.True(isDefined);
        }

        public static object ExecuteHelper(TaskAsyncActionDescriptor actionDescriptor, Dictionary<string, object> parameters, ControllerContext controllerContext = null)
        {
            using (SignalContainer<object> resultContainer = new SignalContainer<object>())
            {
                AsyncCallback callback = ar =>
                {
                    object o = actionDescriptor.EndExecute(ar);
                    resultContainer.Signal(o);
                };

                actionDescriptor.BeginExecute(controllerContext ?? GetControllerContext(), parameters, callback, state: null);
                return resultContainer.Wait();
            }
        }

        private static TaskAsyncActionDescriptor GetActionDescriptor(MethodInfo taskMethod)
        {
            return new TaskAsyncActionDescriptor(taskMethod, "someName", new Mock<ControllerDescriptor>().Object)
            {
                DispatcherCache = new ActionMethodDispatcherCache()
            };
        }

        private static ControllerContext GetControllerContext(int timeout = 45 * 1000)
        {
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            ExecuteController controller = new ExecuteController();
            controller.AsyncManager.Timeout = timeout;
            mockControllerContext.Setup(c => c.Controller).Returns(controller);
            return mockControllerContext.Object;
        }

        private static MethodInfo GetExecuteControllerMethodInfo(string methodName)
        {
            return typeof(ExecuteController).GetMethod(methodName);
        }

        private class ExecuteController : AsyncController
        {
            public bool WorkDone { get; set; }

            public Task<ActionResult> ReturnedTask { get; set; }

            public Task<string> GenericTask(string taskId)
            {
                return Task.Factory.StartNew(() => taskId);
            }

            public Task<string> GenericTaskException(string taskId, bool throwException)
            {
                return Task.Factory.StartNew(() =>
                {
                    if (throwException)
                    {
                        ThrowException();
                    }
                    ;
                    return taskId;
                });
            }

            private void ThrowException()
            {
                throw new InvalidOperationException("Test exception from action");
            }

            [Authorize]
            public Task SimpleTask(bool doWork)
            {
                return Task.Factory.StartNew(() => { WorkDone = doWork; });
            }

            public Task SimpleTaskException(bool doWork)
            {
                return Task.Factory.StartNew(() => { ThrowException(); });
            }

            public Task<ActionResult> TaskTimeoutWithNullParam(Object nullParam, CancellationToken cancellationToken)
            {
                return TaskTimeout(cancellationToken);
            }

            public Task<string> TaskWithInfiniteTimeout(CancellationToken cancellationToken)
            {
                return Task.Factory.StartNew(() => "Task Completed");
            }

            public Task<ActionResult> TaskTimeout(CancellationToken cancellationToken)
            {
                TaskCompletionSource<ActionResult> completionSource = new TaskCompletionSource<ActionResult>();
                cancellationToken.Register(() => completionSource.TrySetCanceled());
                ReturnedTask = completionSource.Task;
                return ReturnedTask;
            }

            public Task TaskOfPrivateT()
            {
                var completionSource = new TaskCompletionSource<PrivateObject>();
                completionSource.SetResult(new PrivateObject());
                WorkDone = true;
                return completionSource.Task;
            }

            private class PrivateObject
            {
                public override string ToString()
                {
                    return "Private Object";
                }
            }
        }

        // Controller is async, so derive from ControllerBase to get sync behavior.
        private class RegularSyncController : ControllerBase
        {
            protected override void ExecuteCore()
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/TaskWrapperAsyncResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Threading.Tasks;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Async.Test
{
    public class TaskWrapperAsyncResultTest
    {
        [Fact]
        public void PropertiesHaveCorrectValues()
        {
            // Arrange
            Mock<MyTask> mockTask = new Mock<MyTask>();
            WaitHandle waitHandle = new Mock<WaitHandle>().Object;

            mockTask.Setup(o => o.AsyncState).Returns(10);
            mockTask.Setup(o => o.AsyncWaitHandle).Returns(waitHandle);
            mockTask.Setup(o => o.CompletedSynchronously).Returns(true);
            mockTask.Setup(o => o.IsCompleted).Returns(true);

            // Act
            TaskWrapperAsyncResult taskWrapper = new TaskWrapperAsyncResult(mockTask.Object, asyncState: 20);

            // Assert
            Assert.Equal(20, taskWrapper.AsyncState);
            Assert.Equal(waitHandle, taskWrapper.AsyncWaitHandle);
            Assert.True(taskWrapper.CompletedSynchronously);
            Assert.True(taskWrapper.IsCompleted);
            Assert.Equal(mockTask.Object, taskWrapper.Task);
        }

        // Assists in mocking a Task by passing a dummy action to the Task constructor [which defers execution]
        public class MyTask : Task, IAsyncResult
        {
            public MyTask()
                : base(() => { })
            {
            }

            public new virtual object AsyncState
            {
                get { throw new NotImplementedException(); }
            }

            public virtual WaitHandle AsyncWaitHandle
            {
                get { throw new NotImplementedException(); }
            }

            public virtual bool CompletedSynchronously
            {
                get { throw new NotImplementedException(); }
            }

            public new virtual bool IsCompleted
            {
                get { throw new NotImplementedException(); }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Async/Test/TriggerListenerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Async.Test
{
    public class TriggerListenerTest
    {
        [Fact]
        public void PerformTest()
        {
            // Arrange
            int count = 0;
            TriggerListener listener = new TriggerListener();
            Trigger trigger = listener.CreateTrigger();

            // Act & assert (hasn't fired yet)
            listener.SetContinuation(() => { count++; });
            listener.Activate();
            Assert.Equal(0, count);

            // Act & assert (fire it, get the callback)
            trigger.Fire();
            Assert.Equal(1, count);

            // Act & assert (fire again, but no callback since it already fired)
            Trigger trigger2 = listener.CreateTrigger();
            trigger2.Fire();
            Assert.Equal(1, count);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/BinaryExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class BinaryExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Add;
            Type expectedType = typeof(DateTime);
            MethodInfo expectedMethod = typeof(DateTime).GetMethod("op_Addition", new Type[] { typeof(DateTime), typeof(TimeSpan) });

            // Act
            BinaryExpressionFingerprint fingerprint = new BinaryExpressionFingerprint(expectedNodeType, expectedType, expectedMethod);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
            Assert.Equal(expectedMethod, fingerprint.Method);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Add;
            Type type = typeof(DateTime);
            MethodInfo method = typeof(DateTime).GetMethod("op_Addition", new Type[] { typeof(DateTime), typeof(TimeSpan) });

            // Act
            BinaryExpressionFingerprint fingerprint1 = new BinaryExpressionFingerprint(nodeType, type, method);
            BinaryExpressionFingerprint fingerprint2 = new BinaryExpressionFingerprint(nodeType, type, method);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Add;
            Type type = typeof(DateTime);
            MethodInfo method = typeof(DateTime).GetMethod("op_Addition", new Type[] { typeof(DateTime), typeof(TimeSpan) });

            // Act
            BinaryExpressionFingerprint fingerprint1 = new BinaryExpressionFingerprint(nodeType, type, method);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Method()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Add;
            Type type = typeof(DateTime);
            MethodInfo method = typeof(DateTime).GetMethod("op_Addition", new Type[] { typeof(DateTime), typeof(TimeSpan) });

            // Act
            BinaryExpressionFingerprint fingerprint1 = new BinaryExpressionFingerprint(nodeType, type, method);
            BinaryExpressionFingerprint fingerprint2 = new BinaryExpressionFingerprint(nodeType, type, null /* method */);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Add;
            Type type = typeof(DateTime);
            MethodInfo method = typeof(DateTime).GetMethod("op_Addition", new Type[] { typeof(DateTime), typeof(TimeSpan) });

            // Act
            BinaryExpressionFingerprint fingerprint1 = new BinaryExpressionFingerprint(nodeType, type, method);
            BinaryExpressionFingerprint fingerprint2 = new BinaryExpressionFingerprint(nodeType, typeof(object), method);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/CachedExpressionCompilerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class CachedExpressionCompilerTest
    {
        private delegate Func<TIn, TOut> Compiler<TIn, TOut>(Expression<Func<TIn, TOut>> expr);

        [Fact]
        public void Compiler_CompileFromConstLookup()
        {
            // Arrange
            Expression<Func<string, int>> expr = model => 42;
            var compiler = GetCompilerMethod<string, int>("CompileFromConstLookup");

            // Act
            var func = compiler(expr);
            int result = func("any model");

            // Assert
            Assert.Equal(42, result);
        }

        [Fact]
        public void Compiler_CompileFromFingerprint()
        {
            // Arrange
            Expression<Func<string, int>> expr = s => 20 * s.Length;
            var compiler = GetCompilerMethod<string, int>("CompileFromFingerprint");

            // Act
            var func = compiler(expr);
            int result = func("hello");

            // Assert
            Assert.Equal(100, result);
        }

        [Fact]
        public void Compiler_CompileFromIdentityFunc()
        {
            // Arrange
            Expression<Func<string, string>> expr = model => model;
            var compiler = GetCompilerMethod<string, string>("CompileFromIdentityFunc");

            // Act
            var func = compiler(expr);
            string result = func("hello");

            // Assert
            Assert.Equal("hello", result);
        }

        [Fact]
        public void Compiler_CompileFromMemberAccess_CapturedLocal()
        {
            // Arrange
            string capturedLocal = "goodbye";
            Expression<Func<string, string>> expr = _ => capturedLocal;
            var compiler = GetCompilerMethod<string, string>("CompileFromMemberAccess");

            // Act
            var func = compiler(expr);
            string result = func("hello");

            // Assert
            Assert.Equal("goodbye", result);
        }

        [Fact]
        public void Compiler_CompileFromMemberAccess_ParameterInstanceMember()
        {
            // Arrange
            Expression<Func<string, int>> expr = s => s.Length;
            var compiler = GetCompilerMethod<string, int>("CompileFromMemberAccess");

            // Act
            var func = compiler(expr);
            int result = func("hello");

            // Assert
            Assert.Equal(5, result);
        }

        [Fact]
        public void Compiler_CompileFromMemberAccess_StaticMember()
        {
            // Arrange
            Expression<Func<string, string>> expr = _ => String.Empty;
            var compiler = GetCompilerMethod<string, string>("CompileFromMemberAccess");

            // Act
            var func = compiler(expr);
            string result = func("hello");

            // Assert
            Assert.Equal("", result);
        }

        [Fact]
        public void Compiler_CompileSlow()
        {
            // Arrange
            Expression<Func<string, string>> expr = s => new StringBuilder(s).ToString();
            var compiler = GetCompilerMethod<string, string>("CompileSlow");

            // Act
            var func = compiler(expr);
            string result = func("hello");

            // Assert
            Assert.Equal("hello", result);
        }

        [Fact]
        public void Process()
        {
            // Arrange
            Expression<Func<string, string>> expr = s => new StringBuilder(s).ToString();

            // Act
            var func = CachedExpressionCompiler.Process(expr);
            string result = func("hello");

            // Assert
            Assert.Equal("hello", result);
        }

        // helper to create a delegate to a private method on the compiler
        private static Compiler<TIn, TOut> GetCompilerMethod<TIn, TOut>(string methodName)
        {
            Type openCompilerType = typeof(CachedExpressionCompiler).GetNestedType("Compiler`2", BindingFlags.NonPublic);
            Type closedCompilerType = openCompilerType.MakeGenericType(typeof(TIn), typeof(TOut));
            MethodInfo targetMethod = closedCompilerType.GetMethod(methodName, BindingFlags.Static | BindingFlags.NonPublic);
            return (Compiler<TIn, TOut>)Delegate.CreateDelegate(typeof(Compiler<TIn, TOut>), targetMethod);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/ConditionalExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class ConditionalExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Conditional;
            Type expectedType = typeof(object);

            // Act
            ConditionalExpressionFingerprint fingerprint = new ConditionalExpressionFingerprint(expectedNodeType, expectedType);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Conditional;
            Type type = typeof(object);

            // Act
            ConditionalExpressionFingerprint fingerprint1 = new ConditionalExpressionFingerprint(nodeType, type);
            ConditionalExpressionFingerprint fingerprint2 = new ConditionalExpressionFingerprint(nodeType, type);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Conditional;
            Type type = typeof(object);

            // Act
            ConditionalExpressionFingerprint fingerprint1 = new ConditionalExpressionFingerprint(nodeType, type);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Conditional;
            Type type = typeof(object);

            // Act
            ConditionalExpressionFingerprint fingerprint1 = new ConditionalExpressionFingerprint(nodeType, type);
            ConditionalExpressionFingerprint fingerprint2 = new ConditionalExpressionFingerprint(nodeType, typeof(string));

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/ConstantExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class ConstantExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Constant;
            Type expectedType = typeof(object);

            // Act
            ConstantExpressionFingerprint fingerprint = new ConstantExpressionFingerprint(expectedNodeType, expectedType);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Constant;
            Type type = typeof(object);

            // Act
            ConstantExpressionFingerprint fingerprint1 = new ConstantExpressionFingerprint(nodeType, type);
            ConstantExpressionFingerprint fingerprint2 = new ConstantExpressionFingerprint(nodeType, type);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Constant;
            Type type = typeof(object);

            // Act
            ConstantExpressionFingerprint fingerprint1 = new ConstantExpressionFingerprint(nodeType, type);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Constant;
            Type type = typeof(object);

            // Act
            ConstantExpressionFingerprint fingerprint1 = new ConstantExpressionFingerprint(nodeType, type);
            ConstantExpressionFingerprint fingerprint2 = new ConstantExpressionFingerprint(nodeType, typeof(string));

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/DefaultExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class DefaultExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Default;
            Type expectedType = typeof(object);

            // Act
            DefaultExpressionFingerprint fingerprint = new DefaultExpressionFingerprint(expectedNodeType, expectedType);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Default;
            Type type = typeof(object);

            // Act
            DefaultExpressionFingerprint fingerprint1 = new DefaultExpressionFingerprint(nodeType, type);
            DefaultExpressionFingerprint fingerprint2 = new DefaultExpressionFingerprint(nodeType, type);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Default;
            Type type = typeof(object);

            // Act
            DefaultExpressionFingerprint fingerprint1 = new DefaultExpressionFingerprint(nodeType, type);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_NodeType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Default;
            Type type = typeof(object);

            // Act
            DefaultExpressionFingerprint fingerprint1 = new DefaultExpressionFingerprint(nodeType, type);
            DefaultExpressionFingerprint fingerprint2 = new DefaultExpressionFingerprint(nodeType, typeof(string));

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/DummyExpressionFingerprint.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    // Represents an ExpressionFingerprint that is of the wrong type.
    internal sealed class DummyExpressionFingerprint : ExpressionFingerprint
    {
        public DummyExpressionFingerprint(ExpressionType nodeType, Type type)
            : base(nodeType, type)
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/ExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class ExpressionFingerprintTest
    {
        [Fact]
        public void Comparison_Equality()
        {
            // Act
            DummyExpressionFingerprint fingerprint1 = new DummyExpressionFingerprint(ExpressionType.Default, typeof(object));
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(ExpressionType.Default, typeof(object));

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_NodeType()
        {
            // Act
            DummyExpressionFingerprint fingerprint1 = new DummyExpressionFingerprint(ExpressionType.Default, typeof(object));
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(ExpressionType.Parameter, typeof(object));

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Act
            DummyExpressionFingerprint fingerprint1 = new DummyExpressionFingerprint(ExpressionType.Default, typeof(object));
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(ExpressionType.Default, typeof(string));

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/FingerprintingExpressionVisitorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class FingerprintingExpressionVisitorTest
    {
        private const ExpressionFingerprint _nullFingerprint = null;

        [Fact]
        public void TypeOverridesAllMethods()
        {
            // Ensures that the FingerprintingExpressionVisitor type overrides all VisitXxx methods so that
            // it can properly set the "I gave up" flag when it encounters an Expression it's not familiar
            // with.

            var methodsOnExpressionVisitorRequiringOverride = typeof(ExpressionVisitor).GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Where(mi => mi.IsVirtual).Select(mi => mi.GetBaseDefinition()).Where(mi => mi.DeclaringType == typeof(ExpressionVisitor));
            var methodsOnFingerprintingExpressionVisitor = typeof(FingerprintingExpressionVisitor).GetMethods(BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance).Where(mi => mi.DeclaringType == typeof(FingerprintingExpressionVisitor));

            var missingMethods = methodsOnExpressionVisitorRequiringOverride.Except(methodsOnFingerprintingExpressionVisitor.Select(mi => mi.GetBaseDefinition())).ToArray();
            if (missingMethods.Length != 0)
            {
                StringBuilder sb = new StringBuilder("The following methods are declared on ExpressionVisitor and must be overridden on FingerprintingExpressionVisitor:");
                foreach (MethodInfo method in missingMethods)
                {
                    sb.AppendLine();
                    sb.Append(method);
                }
                Assert.True(false, sb.ToString());
            }
        }

        [Fact]
        public void Visit_Null()
        {
            // Arrange

            // fingerprints as [ NULL ]
            Expression expr = null;

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Empty(capturedConstants);
            AssertChainEquals(fingerprint, _nullFingerprint);
        }

        [Fact]
        public void Visit_Unknown()
        {
            // Arrange

            // if we fingerprinted ctors, would fingerprint as [ NEW(StringBuilder(int)):StringBuilder, PARAM(0):int ]
            // but since we don't fingerprint ctors, should just return null (signaling failure)
            Expression expr = (Expression<Func<int, StringBuilder>>)(capacity => new StringBuilder(capacity));

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Null(fingerprint); // Can't fingerprint ctor
            Assert.Null(capturedConstants); // Can't fingerprint ctor
        }

        [Fact]
        public void VisitBinary()
        {
            // Arrange

            // fingerprints as [ OP_GREATERTHAN:bool, CONST:int, CONST:int ]
            Expression expr = Expression.MakeBinary(ExpressionType.GreaterThan, Expression.Constant(42), Expression.Constant(84));

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Equal(new object[] { 42, 84 }, capturedConstants.ToArray());
            AssertChainEquals(fingerprint,
                              new BinaryExpressionFingerprint(ExpressionType.GreaterThan, typeof(bool), null /* method */),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)));
        }

        [Fact]
        public void VisitConditional()
        {
            // Arrange

            // fingerprints as [ CONDITIONAL:int, CONST:bool, CONST:int, CONST:int ]
            Expression expr = Expression.Condition(Expression.Constant(true), Expression.Constant(42), Expression.Constant(84));

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Equal(new object[] { true, 42, 84 }, capturedConstants.ToArray());
            AssertChainEquals(fingerprint,
                              new ConditionalExpressionFingerprint(ExpressionType.Conditional, typeof(int)),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(bool)),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)));
        }

        [Fact]
        public void VisitConstant()
        {
            // Arrange

            // fingerprints as [ CONST:int ]
            Expression expr = Expression.Constant(42);

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Equal(new object[] { 42 }, capturedConstants.ToArray());
            AssertChainEquals(fingerprint,
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)));
        }

        [Fact]
        public void VisitDefault()
        {
            // Arrange

            // fingerprints as [ DEFAULT:int ]
            Expression expr = Expression.Default(typeof(int));

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Empty(capturedConstants);
            AssertChainEquals(fingerprint, new DefaultExpressionFingerprint(ExpressionType.Default, typeof(int)));
        }

        [Fact]
        public void VisitIndex()
        {
            // Arrange

            // fingerprints as [ INDEX:object, PARAM(0):object[], CONST:int ]
            Expression expr = Expression.MakeIndex(Expression.Parameter(typeof(object[])), null /* indexer */, new Expression[] { Expression.Constant(42) });

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Equal(new object[] { 42 }, capturedConstants.ToArray());
            AssertChainEquals(fingerprint,
                              new IndexExpressionFingerprint(ExpressionType.Index, typeof(object), null /* indexer */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(object[]), 0 /* parameterIndex */),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)));
        }

        [Fact]
        public void VisitLambda()
        {
            // Arrange

            // fingerprints as [ LAMBDA:Func<string, int>, CONST:int, PARAM(0):string ]
            Expression expr = (Expression<Func<string, int>>)(x => 42);

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Equal(new object[] { 42 }, capturedConstants.ToArray());
            AssertChainEquals(fingerprint,
                              new LambdaExpressionFingerprint(ExpressionType.Lambda, typeof(Func<string, int>)),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(string), 0 /* parameterIndex */));
        }

        [Fact]
        public void VisitMember()
        {
            // Arrange

            // fingerprints as [ MEMBER(String.Empty):string, NULL ]
            Expression expr = Expression.Field(null, typeof(string), "Empty");

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Empty(capturedConstants);
            AssertChainEquals(fingerprint,
                              new MemberExpressionFingerprint(ExpressionType.MemberAccess, typeof(string), typeof(string).GetField("Empty")),
                              _nullFingerprint);
        }

        [Fact]
        public void VisitMethodCall()
        {
            // Arrange

            // fingerprints as [ CALL(GC.KeepAlive):void, NULL, PARAM(0):object ]
            Expression expr = Expression.Call(typeof(GC).GetMethod("KeepAlive"), Expression.Parameter(typeof(object)));

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Empty(capturedConstants);
            AssertChainEquals(fingerprint,
                              new MethodCallExpressionFingerprint(ExpressionType.Call, typeof(void), typeof(GC).GetMethod("KeepAlive")),
                              _nullFingerprint,
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(object), 0 /* parameterIndex */));
        }

        [Fact]
        public void VisitParameter()
        {
            // Arrange

            // fingerprints as [ LAMBDA:Func<int, int, int>, OP_ADD:int, OP_ADD:int, OP_ADD:int, PARAM(0):int, PARAM(0):int, PARAM(1):int, PARAM(0):int, PARAM(1):int, PARAM(0):int ]
            // (note that the parameters are out of order since 'y' is used first, but this is ok due
            // to preservation of alpha equivalence within the VisitParameter method.)
            Expression expr = (Expression<Func<int, int, int>>)((x, y) => y + y + x + y);

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Empty(capturedConstants);
            AssertChainEquals(fingerprint,
                              new LambdaExpressionFingerprint(ExpressionType.Lambda, typeof(Func<int, int, int>)),
                              new BinaryExpressionFingerprint(ExpressionType.Add, typeof(int), null /* method */),
                              new BinaryExpressionFingerprint(ExpressionType.Add, typeof(int), null /* method */),
                              new BinaryExpressionFingerprint(ExpressionType.Add, typeof(int), null /* method */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(int), 0 /* parameterIndex */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(int), 0 /* parameterIndex */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(int), 1 /* parameterIndex */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(int), 0 /* parameterIndex */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(int), 1 /* parameterIndex */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(int), 0 /* parameterIndex */));
        }

        [Fact]
        public void VisitTypeBinary()
        {
            // Arrange

            // fingerprints as [ TYPEIS(DateTime):bool, CONST:string ]
            Expression expr = Expression.TypeIs(Expression.Constant("hello"), typeof(DateTime));

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Equal(new object[] { "hello" }, capturedConstants.ToArray());
            AssertChainEquals(fingerprint,
                              new TypeBinaryExpressionFingerprint(ExpressionType.TypeIs, typeof(bool), typeof(DateTime)),
                              new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(string)));
        }

        [Fact]
        public void VisitUnary()
        {
            // Arrange

            // fingerprints as [ OP_NOT:int, PARAM:int ]
            Expression expr = Expression.Not(Expression.Parameter(typeof(int)));

            // Act
            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(expr, out capturedConstants);

            // Assert
            Assert.Empty(capturedConstants);
            AssertChainEquals(fingerprint,
                              new UnaryExpressionFingerprint(ExpressionType.Not, typeof(int), null /* method */),
                              new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(int), 0 /* parameterIndex */));
        }

        internal static void AssertChainEquals(ExpressionFingerprintChain fingerprintChain, params ExpressionFingerprint[] expectedElements)
        {
            ExpressionFingerprintChain newChain = new ExpressionFingerprintChain();
            newChain.Elements.AddRange(expectedElements);
            Assert.Equal(fingerprintChain, newChain);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/HoistingExpressionVisitorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class HoistingExpressionVisitorTest
    {
        [Fact]
        public void Hoist()
        {
            // Arrange
            Expression<Func<string, int>> expr = s => (2 * s.Length) + 1;

            // Act
            Expression<Hoisted<string, int>> hoisted = HoistingExpressionVisitor<string, int>.Hoist(expr);

            // Assert
            // new expression should be (s, capturedConstants) => (int)(capturedConstants[0]) * s.Length + (int)(capturedConstants[1])
            // with fingerprint [ LAMBDA:Hoisted<string, int>, OP_ADD:int, OP_MULTIPLY:int, OP_CAST:int, INDEX(List<object>.get_Item):object, PARAM(0):List<object>, CONST:int, MEMBER(String.Length):int, PARAM(1):string, OP_CAST:int, INDEX(List<object>.get_Item):object, PARAM(0):List<object>, CONST:int, PARAM(1):string, PARAM(0):List<object> ]

            List<object> capturedConstants;
            ExpressionFingerprintChain fingerprint = FingerprintingExpressionVisitor.GetFingerprintChain(hoisted, out capturedConstants);

            Assert.Equal(new object[] { 0, 1 }, capturedConstants.ToArray()); // these are constants from the hoisted expression (array indexes), not the original expression
            FingerprintingExpressionVisitorTest.AssertChainEquals(
                fingerprint,
                new LambdaExpressionFingerprint(ExpressionType.Lambda, typeof(Hoisted<string, int>)),
                new BinaryExpressionFingerprint(ExpressionType.Add, typeof(int), null /* method */),
                new BinaryExpressionFingerprint(ExpressionType.Multiply, typeof(int), null /* method */),
                new UnaryExpressionFingerprint(ExpressionType.Convert, typeof(int), null /* method */),
                new IndexExpressionFingerprint(ExpressionType.Index, typeof(object), typeof(List<object>).GetProperty("Item")),
                new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(List<object>), 0 /* parameterIndex */),
                new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)),
                new MemberExpressionFingerprint(ExpressionType.MemberAccess, typeof(int), typeof(string).GetProperty("Length")),
                new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(string), 1 /* parameterIndex */),
                new UnaryExpressionFingerprint(ExpressionType.Convert, typeof(int), null /* method */),
                new IndexExpressionFingerprint(ExpressionType.Index, typeof(object), typeof(List<object>).GetProperty("Item")),
                new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(List<object>), 0 /* parameterIndex */),
                new ConstantExpressionFingerprint(ExpressionType.Constant, typeof(int)),
                new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(string), 1 /* parameterIndex */),
                new ParameterExpressionFingerprint(ExpressionType.Parameter, typeof(List<object>), 0 /* parameterIndex */));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/IndexExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class IndexExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Index;
            Type expectedType = typeof(char);
            PropertyInfo expectedIndexer = typeof(string).GetProperty("Chars");

            // Act
            IndexExpressionFingerprint fingerprint = new IndexExpressionFingerprint(expectedNodeType, expectedType, expectedIndexer);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
            Assert.Equal(expectedIndexer, fingerprint.Indexer);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Index;
            Type type = typeof(char);
            PropertyInfo indexer = typeof(string).GetProperty("Chars");

            // Act
            IndexExpressionFingerprint fingerprint1 = new IndexExpressionFingerprint(nodeType, type, indexer);
            IndexExpressionFingerprint fingerprint2 = new IndexExpressionFingerprint(nodeType, type, indexer);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Index;
            Type type = typeof(char);
            PropertyInfo indexer = typeof(string).GetProperty("Chars");

            // Act
            IndexExpressionFingerprint fingerprint1 = new IndexExpressionFingerprint(nodeType, type, indexer);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Indexer()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Index;
            Type type = typeof(char);
            PropertyInfo indexer = typeof(string).GetProperty("Chars");

            // Act
            IndexExpressionFingerprint fingerprint1 = new IndexExpressionFingerprint(nodeType, type, indexer);
            IndexExpressionFingerprint fingerprint2 = new IndexExpressionFingerprint(nodeType, type, null /* indexer */);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Index;
            Type type = typeof(char);
            PropertyInfo indexer = typeof(string).GetProperty("Chars");

            // Act
            IndexExpressionFingerprint fingerprint1 = new IndexExpressionFingerprint(nodeType, type, indexer);
            IndexExpressionFingerprint fingerprint2 = new IndexExpressionFingerprint(nodeType, typeof(object), indexer);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/LambdaExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class LambdaExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Lambda;
            Type expectedType = typeof(Action<object>);

            // Act
            LambdaExpressionFingerprint fingerprint = new LambdaExpressionFingerprint(expectedNodeType, expectedType);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Lambda;
            Type type = typeof(Action<object>);

            // Act
            LambdaExpressionFingerprint fingerprint1 = new LambdaExpressionFingerprint(nodeType, type);
            LambdaExpressionFingerprint fingerprint2 = new LambdaExpressionFingerprint(nodeType, type);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Lambda;
            Type type = typeof(Action<object>);

            // Act
            LambdaExpressionFingerprint fingerprint1 = new LambdaExpressionFingerprint(nodeType, type);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_NodeType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Lambda;
            Type type = typeof(Action<object>);

            // Act
            LambdaExpressionFingerprint fingerprint1 = new LambdaExpressionFingerprint(nodeType, type);
            LambdaExpressionFingerprint fingerprint2 = new LambdaExpressionFingerprint(nodeType, typeof(Action));

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/MemberExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class MemberExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.MemberAccess;
            Type expectedType = typeof(int);
            MemberInfo expectedMember = typeof(TimeSpan).GetProperty("Seconds");

            // Act
            MemberExpressionFingerprint fingerprint = new MemberExpressionFingerprint(expectedNodeType, expectedType, expectedMember);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
            Assert.Equal(expectedMember, fingerprint.Member);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.MemberAccess;
            Type type = typeof(int);
            MemberInfo member = typeof(TimeSpan).GetProperty("Seconds");

            // Act
            MemberExpressionFingerprint fingerprint1 = new MemberExpressionFingerprint(nodeType, type, member);
            MemberExpressionFingerprint fingerprint2 = new MemberExpressionFingerprint(nodeType, type, member);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.MemberAccess;
            Type type = typeof(int);
            MemberInfo member = typeof(TimeSpan).GetProperty("Seconds");

            // Act
            MemberExpressionFingerprint fingerprint1 = new MemberExpressionFingerprint(nodeType, type, member);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Member()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.MemberAccess;
            Type type = typeof(int);
            MemberInfo member = typeof(TimeSpan).GetProperty("Seconds");

            // Act
            MemberExpressionFingerprint fingerprint1 = new MemberExpressionFingerprint(nodeType, type, member);
            MemberExpressionFingerprint fingerprint2 = new MemberExpressionFingerprint(nodeType, type, null /* member */);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.MemberAccess;
            Type type = typeof(int);
            MemberInfo member = typeof(TimeSpan).GetProperty("Seconds");

            // Act
            MemberExpressionFingerprint fingerprint1 = new MemberExpressionFingerprint(nodeType, type, member);
            MemberExpressionFingerprint fingerprint2 = new MemberExpressionFingerprint(nodeType, typeof(object), member);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/MethodCallExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class MethodCallExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Call;
            Type expectedType = typeof(string);
            MethodInfo expectedMethod = typeof(string).GetMethod("Intern");

            // Act
            MethodCallExpressionFingerprint fingerprint = new MethodCallExpressionFingerprint(expectedNodeType, expectedType, expectedMethod);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
            Assert.Equal(expectedMethod, fingerprint.Method);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Call;
            Type type = typeof(string);
            MethodInfo method = typeof(string).GetMethod("Intern");

            // Act
            MethodCallExpressionFingerprint fingerprint1 = new MethodCallExpressionFingerprint(nodeType, type, method);
            MethodCallExpressionFingerprint fingerprint2 = new MethodCallExpressionFingerprint(nodeType, type, method);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Call;
            Type type = typeof(string);
            MethodInfo method = typeof(string).GetMethod("Intern");

            // Act
            MethodCallExpressionFingerprint fingerprint1 = new MethodCallExpressionFingerprint(nodeType, type, method);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Method()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Call;
            Type type = typeof(string);
            MethodInfo method = typeof(string).GetMethod("Intern");

            // Act
            MethodCallExpressionFingerprint fingerprint1 = new MethodCallExpressionFingerprint(nodeType, type, method);
            MethodCallExpressionFingerprint fingerprint2 = new MethodCallExpressionFingerprint(nodeType, type, null /* method */);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Call;
            Type type = typeof(string);
            MethodInfo method = typeof(string).GetMethod("Intern");

            // Act
            MethodCallExpressionFingerprint fingerprint1 = new MethodCallExpressionFingerprint(nodeType, type, method);
            MethodCallExpressionFingerprint fingerprint2 = new MethodCallExpressionFingerprint(nodeType, typeof(object), method);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/ParameterExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class ParameterExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Parameter;
            Type expectedType = typeof(object);
            int expectedParameterIndex = 1;

            // Act
            ParameterExpressionFingerprint fingerprint = new ParameterExpressionFingerprint(expectedNodeType, expectedType, expectedParameterIndex);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
            Assert.Equal(expectedParameterIndex, fingerprint.ParameterIndex);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Parameter;
            Type type = typeof(object);
            int parameterIndex = 1;

            // Act
            ParameterExpressionFingerprint fingerprint1 = new ParameterExpressionFingerprint(nodeType, type, parameterIndex);
            ParameterExpressionFingerprint fingerprint2 = new ParameterExpressionFingerprint(nodeType, type, parameterIndex);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Parameter;
            Type type = typeof(object);
            int parameterIndex = 1;

            // Act
            ParameterExpressionFingerprint fingerprint1 = new ParameterExpressionFingerprint(nodeType, type, parameterIndex);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Method()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Parameter;
            Type type = typeof(object);
            int parameterIndex = 1;

            // Act
            ParameterExpressionFingerprint fingerprint1 = new ParameterExpressionFingerprint(nodeType, type, parameterIndex);
            ParameterExpressionFingerprint fingerprint2 = new ParameterExpressionFingerprint(nodeType, type, -1 /* parameterIndex */);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Parameter;
            Type type = typeof(object);
            int parameterIndex = 1;

            // Act
            ParameterExpressionFingerprint fingerprint1 = new ParameterExpressionFingerprint(nodeType, type, parameterIndex);
            ParameterExpressionFingerprint fingerprint2 = new ParameterExpressionFingerprint(nodeType, typeof(string), parameterIndex);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/TypeBinaryExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class TypeBinaryExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.TypeIs;
            Type expectedType = typeof(bool);
            Type expectedTypeOperand = typeof(object);

            // Act
            TypeBinaryExpressionFingerprint fingerprint = new TypeBinaryExpressionFingerprint(expectedNodeType, expectedType, expectedTypeOperand);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
            Assert.Equal(expectedTypeOperand, fingerprint.TypeOperand);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.TypeIs;
            Type type = typeof(bool);
            Type typeOperand = typeof(object);

            // Act
            TypeBinaryExpressionFingerprint fingerprint1 = new TypeBinaryExpressionFingerprint(nodeType, type, typeOperand);
            TypeBinaryExpressionFingerprint fingerprint2 = new TypeBinaryExpressionFingerprint(nodeType, type, typeOperand);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.TypeIs;
            Type type = typeof(bool);
            Type typeOperand = typeof(object);

            // Act
            TypeBinaryExpressionFingerprint fingerprint1 = new TypeBinaryExpressionFingerprint(nodeType, type, typeOperand);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_TypeOperand()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.TypeIs;
            Type type = typeof(bool);
            Type typeOperand = typeof(object);

            // Act
            TypeBinaryExpressionFingerprint fingerprint1 = new TypeBinaryExpressionFingerprint(nodeType, type, typeOperand);
            TypeBinaryExpressionFingerprint fingerprint2 = new TypeBinaryExpressionFingerprint(nodeType, type, typeof(string) /* typeOperand */);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.TypeIs;
            Type type = typeof(bool);
            Type typeOperand = typeof(object);

            // Act
            TypeBinaryExpressionFingerprint fingerprint1 = new TypeBinaryExpressionFingerprint(nodeType, type, typeOperand);
            TypeBinaryExpressionFingerprint fingerprint2 = new TypeBinaryExpressionFingerprint(nodeType, typeof(object), typeOperand);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/ExpressionUtil/Test/UnaryExpressionFingerprintTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.ExpressionUtil.Test
{
    public class UnaryExpressionFingerprintTest
    {
        [Fact]
        public void Properties()
        {
            // Arrange
            ExpressionType expectedNodeType = ExpressionType.Not;
            Type expectedType = typeof(int);
            MethodInfo expectedMethod = typeof(object).GetMethod("GetHashCode");

            // Act
            UnaryExpressionFingerprint fingerprint = new UnaryExpressionFingerprint(expectedNodeType, expectedType, expectedMethod);

            // Assert
            Assert.Equal(expectedNodeType, fingerprint.NodeType);
            Assert.Equal(expectedType, fingerprint.Type);
            Assert.Equal(expectedMethod, fingerprint.Method);
        }

        [Fact]
        public void Comparison_Equality()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Not;
            Type type = typeof(int);
            MethodInfo method = typeof(object).GetMethod("GetHashCode");

            // Act
            UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
            UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, type, method);

            // Assert
            Assert.Equal(fingerprint1, fingerprint2);
            Assert.Equal(fingerprint1.GetHashCode(), fingerprint2.GetHashCode());
        }

        [Fact]
        public void Comparison_Inequality_FingerprintType()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Not;
            Type type = typeof(int);
            MethodInfo method = typeof(object).GetMethod("GetHashCode");

            // Act
            UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
            DummyExpressionFingerprint fingerprint2 = new DummyExpressionFingerprint(nodeType, type);

            // Assert
            Assert.NotEqual<ExpressionFingerprint>(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Method()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Not;
            Type type = typeof(int);
            MethodInfo method = typeof(object).GetMethod("GetHashCode");

            // Act
            UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
            UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, type, null /* method */);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }

        [Fact]
        public void Comparison_Inequality_Type()
        {
            // Arrange
            ExpressionType nodeType = ExpressionType.Not;
            Type type = typeof(int);
            MethodInfo method = typeof(object).GetMethod("GetHashCode");

            // Act
            UnaryExpressionFingerprint fingerprint1 = new UnaryExpressionFingerprint(nodeType, type, method);
            UnaryExpressionFingerprint fingerprint2 = new UnaryExpressionFingerprint(nodeType, typeof(object), method);

            // Assert
            Assert.NotEqual(fingerprint1, fingerprint2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/ChildActionExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Mvc.Properties;
using System.Web.Mvc.Routing;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    public class ChildActionExtensionsTest
    {
        private Mock<HtmlHelper> _htmlHelper;
        private Mock<HttpContextBase> _httpContext;
        private Mock<RouteBase> _route;
        private Mock<IViewDataContainer> _viewDataContainer;
         
        private RouteData _originalRouteData;
        private RouteCollection _routes;
        private ViewContext _viewContext;
        private VirtualPathData _virtualPathData;

        public ChildActionExtensionsTest()
        {
            _route = new Mock<RouteBase>();
            _route.Setup(r => r.GetVirtualPath(It.IsAny<RequestContext>(), It.IsAny<RouteValueDictionary>()))
                .Returns(() => _virtualPathData);

            _virtualPathData = new VirtualPathData(_route.Object, "~/VirtualPath");

            _routes = new RouteCollection();
            _routes.Add(_route.Object);

            _originalRouteData = new RouteData();

            string returnValue = "";
            _httpContext = new Mock<HttpContextBase>();
            _httpContext.Setup(hc => hc.Request.ApplicationPath).Returns("~");
            _httpContext.Setup(hc => hc.Response.ApplyAppPathModifier(It.IsAny<string>()))
                .Callback<string>(s => returnValue = s)
                .Returns(() => returnValue);
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()));

            _viewContext = new ViewContext
            {
                RequestContext = new RequestContext(_httpContext.Object, _originalRouteData)
            };

            _viewDataContainer = new Mock<IViewDataContainer>();

            _htmlHelper = new Mock<HtmlHelper>(_viewContext, _viewDataContainer.Object, _routes);
        }

        [Fact]
        public void GuardClauses()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => ChildActionExtensions.ActionHelper(null /* htmlHelper */, "abc", null /* controllerName */, null /* routeValues */, null /* textWriter */),
                "htmlHelper"
                );

            Assert.ThrowsArgumentNullOrEmpty(
                () => ChildActionExtensions.ActionHelper(_htmlHelper.Object, null /* actionName */, null /* controllerName */, null /* routeValues */, null /* textWriter */),
                "actionName"
                );

            Assert.ThrowsArgumentNullOrEmpty(
                () => ChildActionExtensions.ActionHelper(_htmlHelper.Object, String.Empty /* actionName */, null /* controllerName */, null /* routeValues */, null /* textWriter */),
                "actionName"
                );
        }

        [Fact]
        public void ServerExecuteCalledWithWrappedChildActionMvcHandler()
        {
            // Arrange
            IHttpHandler callbackHandler = null;
            TextWriter callbackTextWriter = null;
            bool callbackPreserveForm = false;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>(
                    (handler, textWriter, preserveForm) =>
                    {
                        callbackHandler = handler;
                        callbackTextWriter = textWriter;
                        callbackPreserveForm = preserveForm;
                    });
            TextWriter stringWriter = new StringWriter();

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, null /* routeValues */, stringWriter);

            // Assert
            Assert.NotNull(callbackHandler);
            HttpHandlerUtil.ServerExecuteHttpHandlerWrapper wrapper = callbackHandler as HttpHandlerUtil.ServerExecuteHttpHandlerWrapper;
            Assert.NotNull(wrapper);
            Assert.NotNull(wrapper.InnerHandler);
            ChildActionExtensions.ChildActionMvcHandler childHandler = wrapper.InnerHandler as ChildActionExtensions.ChildActionMvcHandler;
            Assert.NotNull(childHandler);
            Assert.Same(stringWriter, callbackTextWriter);
            Assert.True(callbackPreserveForm);
        }

        [Fact]
        public void RouteDataTokensIncludesParentActionViewContext()
        {
            // Arrange
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, null /* routeValues */, null /* textWriter */);

            // Assert
            Assert.Same(_viewContext, mvcHandler.RequestContext.RouteData.DataTokens[ControllerContext.ParentActionViewContextToken]);
        }

        [Fact]
        public void RouteValuesIncludeNewActionName()
        {
            // Arrange
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, null /* routeValues */, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.Equal("actionName", routeData.Values["action"]);
        }

        [Fact]
        public void RouteValuesIncludeOldControllerNameWhenControllerNameIsNullOrEmpty()
        {
            // Arrange
            _originalRouteData.Values["controller"] = "oldController";
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, null /* routeValues */, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.Equal("oldController", routeData.Values["controller"]);
        }

        [Fact]
        public void RouteValuesIncludeNewControllerNameWhenControllNameIsNotEmpty()
        {
            // Arrange
            _originalRouteData.Values["controller"] = "oldController";
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", "newController", null /* routeValues */, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.Equal("newController", routeData.Values["controller"]);
        }

        [Fact]
        public void PassedRouteValuesOverrideParentRequestRouteValues()
        {
            // Arrange
            _originalRouteData.Values["name1"] = "value1";
            _originalRouteData.Values["name2"] = "value2";
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, new RouteValueDictionary { { "name2", "newValue2" } }, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.Equal("value1", routeData.Values["name1"]);
            Assert.Equal("newValue2", routeData.Values["name2"]);

            Assert.Equal("newValue2", (routeData.Values[ChildActionValueProvider.ChildActionValuesKey] as DictionaryValueProvider<object>).GetValue("name2").RawValue);
        }

        [Fact]
        public void NoChildActionValuesDictionaryCreatedIfNoRouteValuesPassed()
        {
            // Arrange
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, null, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.Null(routeData.Values[ChildActionValueProvider.ChildActionValuesKey]);
        }

        [Fact]
        public void RouteValuesDoesNotIncludeExplicitlyPassedAreaName()
        {
            // Arrange
            Route route = _routes.MapRoute("my-area", "my-area");
            route.DataTokens["area"] = "myArea";
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, new RouteValueDictionary { { "area", "myArea" } }, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.False(routeData.Values.ContainsKey("area"));
            Assert.Null((routeData.Values[ChildActionValueProvider.ChildActionValuesKey] as DictionaryValueProvider<object>).GetValue("area"));
        }

        [Fact]
        public void RouteValuesIncludeExplicitlyPassedAreaNameIfAreasNotInUse()
        {
            // Arrange
            Route route = _routes.MapRoute("my-area", "my-area");
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, new RouteValueDictionary { { "area", "myArea" } }, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.True(routeData.Values.ContainsKey("area"));
            Assert.Equal("myArea", (routeData.Values[ChildActionValueProvider.ChildActionValuesKey] as DictionaryValueProvider<object>).GetValue("area").RawValue);
        }

        [Fact]
        public void NoMatchingRouteThrows()
        {
            // Arrange
            _routes.Clear();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => ChildActionExtensions.ActionHelper(_htmlHelper.Object, "actionName", null /* controllerName */, null /* routeValues */, null /* textWriter */),
                MvcResources.Common_NoRouteMatched
                );
        }

        [Fact]
        public void ActionHelper_ChildAction_WithControllerDirectRoute()
        {
            // Arrange
            AttributeRoutingMapper.MapAttributeRoutes(_routes, new Type[] { typeof(DirectRouteController) });
            
            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "Action", null /* controllerName */, null /* routeValues */, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.Equal("Action", routeData.Values["action"]);
        }

        [Fact]
        public void ActionHelper_ChildAction_WithActionDirectRoute()
        {
            // Arrange
            AttributeRoutingMapper.MapAttributeRoutes(_routes, new Type[] { typeof(DirectRouteActionController) });

            MvcHandler mvcHandler = null;
            _httpContext.Setup(hc => hc.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), It.IsAny<bool>()))
                .Callback<IHttpHandler, TextWriter, bool>((handler, _, __) => mvcHandler = (MvcHandler)((HttpHandlerUtil.ServerExecuteHttpHandlerWrapper)handler).InnerHandler);

            // Act
            ChildActionExtensions.ActionHelper(_htmlHelper.Object, "Action", null /* controllerName */, null /* routeValues */, null /* textWriter */);

            // Assert
            RouteData routeData = mvcHandler.RequestContext.RouteData;
            Assert.Equal("Action", routeData.Values["action"]);
        }

        [Route("controller/{action}")]
        private class DirectRouteController : Controller
        {
            public void Action()
            {
            }
        }
        
        private class DirectRouteActionController : Controller
        {
            [Route("controller/Action")]
            public void Action()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/DefaultDisplayTemplatesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Data.Objects.DataClasses;
using System.Globalization;
using System.IO;
using System.Web.UI.WebControls;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class DefaultDisplayTemplatesTest
    {
        // BooleanTemplate

        [Fact]
        public void BooleanTemplateTests()
        {
            // Boolean values

            Assert.Equal(
                "<input checked=\"checked\" class=\"check-box\" disabled=\"disabled\" type=\"checkbox\" />",
                DefaultDisplayTemplates.BooleanTemplate(MakeHtmlHelper<bool>(true)));

            Assert.Equal(
                "<input class=\"check-box\" disabled=\"disabled\" type=\"checkbox\" />",
                DefaultDisplayTemplates.BooleanTemplate(MakeHtmlHelper<bool>(false)));

            Assert.Equal(
                "<input class=\"check-box\" disabled=\"disabled\" type=\"checkbox\" />",
                DefaultDisplayTemplates.BooleanTemplate(MakeHtmlHelper<bool>(null)));

            // Nullable<Boolean> values

            Assert.Equal(
                "<select class=\"tri-state list-box\" disabled=\"disabled\"><option value=\"\">Not Set</option><option selected=\"selected\" value=\"true\">True</option><option value=\"false\">False</option></select>",
                DefaultDisplayTemplates.BooleanTemplate(MakeHtmlHelper<Nullable<bool>>(true)));

            Assert.Equal(
                "<select class=\"tri-state list-box\" disabled=\"disabled\"><option value=\"\">Not Set</option><option value=\"true\">True</option><option selected=\"selected\" value=\"false\">False</option></select>",
                DefaultDisplayTemplates.BooleanTemplate(MakeHtmlHelper<Nullable<bool>>(false)));

            Assert.Equal(
                "<select class=\"tri-state list-box\" disabled=\"disabled\"><option selected=\"selected\" value=\"\">Not Set</option><option value=\"true\">True</option><option value=\"false\">False</option></select>",
                DefaultDisplayTemplates.BooleanTemplate(MakeHtmlHelper<Nullable<bool>>(null)));
        }

        // CollectionTemplate

        private static string CollectionSpyCallback(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData)
        {
            return String.Format(CultureInfo.InvariantCulture,
                                 Environment.NewLine + "Model = {0}, ModelType = {1}, PropertyName = {2}, HtmlFieldName = {3}, TemplateName = {4}, Mode = {5}, TemplateInfo.HtmlFieldPrefix = {6}, AdditionalViewData = {7}",
                                 metadata.Model ?? "(null)",
                                 metadata.ModelType == null ? "(null)" : metadata.ModelType.FullName,
                                 metadata.PropertyName ?? "(null)",
                                 htmlFieldName == String.Empty ? "(empty)" : htmlFieldName ?? "(null)",
                                 templateName ?? "(null)",
                                 mode,
                                 html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix,
                                 AnonymousObject.Inspect(additionalViewData));
        }

        [Fact]
        public void CollectionTemplateWithNullModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<object>(null);

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void CollectionTemplateNonEnumerableModelThrows()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<object>(new object());

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback),
                "The Collection template was used with an object of type 'System.Object', which does not implement System.IEnumerable."
                );
        }

        [Fact]
        public void CollectionTemplateWithSingleItemCollectionWithoutPrefix()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<string>>(new List<string> { "foo" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = foo, ModelType = System.String, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateWithSingleItemCollectionWithPrefix()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<string>>(new List<string> { "foo" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "ModelProperty";

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = foo, ModelType = System.String, PropertyName = (null), HtmlFieldName = ModelProperty[0], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateWithMultiItemCollection()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<string>>(new List<string> { "foo", "bar", "baz" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = foo, ModelType = System.String, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = bar, ModelType = System.String, PropertyName = (null), HtmlFieldName = [1], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = baz, ModelType = System.String, PropertyName = (null), HtmlFieldName = [2], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateNullITemInWeaklyTypedCollectionUsesModelTypeOfString()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<ArrayList>(new ArrayList { null });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = (null), ModelType = System.String, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateNullItemInStronglyTypedCollectionUsesModelTypeFromIEnumerable()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<IHttpHandler>>(new List<IHttpHandler> { null });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = (null), ModelType = System.Web.IHttpHandler, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateUsesRealObjectTypes()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<object>>(new List<object> { 1, 2.3, "Hello World" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = 1, ModelType = System.Int32, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = 2.3, ModelType = System.Double, PropertyName = (null), HtmlFieldName = [1], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = Hello World, ModelType = System.String, PropertyName = (null), HtmlFieldName = [2], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateNullItemInCollectionOfNullableValueTypesDoesNotDiscardNullable()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<int?>>(new List<int?> { 1, null, 2 });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultDisplayTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = 1, ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = (null), ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = (null), HtmlFieldName = [1], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = 2, ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = (null), HtmlFieldName = [2], TemplateName = (null), Mode = ReadOnly, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        // DecimalTemplate

        [Fact]
        public void DecimalTemplateTests()
        {
            Assert.Equal(
                String.Format(CultureInfo.CurrentCulture, "{0:0.00}", 12.35M),
                DefaultDisplayTemplates.DecimalTemplate(MakeHtmlHelper<decimal>(12.3456M)));

            Assert.Equal(
                "Formatted Value",
                DefaultDisplayTemplates.DecimalTemplate(MakeHtmlHelper<decimal>(12.3456M, "Formatted Value")));

            Assert.Equal(
                "&lt;script&gt;alert(&#39;XSS!&#39;)&lt;/script&gt;",
                DefaultDisplayTemplates.DecimalTemplate(MakeHtmlHelper<decimal>(12.3456M, "<script>alert('XSS!')</script>")));
        }

        // EmailAddressTemplate

        [Fact]
        public void EmailAddressTemplateTests()
        {
            Assert.Equal(
                "<a href=\"mailto:foo@bar.com\">foo@bar.com</a>",
                DefaultDisplayTemplates.EmailAddressTemplate(MakeHtmlHelper<string>("foo@bar.com")));

            Assert.Equal(
                "<a href=\"mailto:foo@bar.com\">The FooBar User</a>",
                DefaultDisplayTemplates.EmailAddressTemplate(MakeHtmlHelper<string>("foo@bar.com", "The FooBar User")));

            Assert.Equal(
                "<a href=\"mailto:&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\">&lt;script&gt;alert(&#39;XSS!&#39;)&lt;/script&gt;</a>",
                DefaultDisplayTemplates.EmailAddressTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));

            Assert.Equal(
                "<a href=\"mailto:&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\">&lt;b&gt;Encode me!&lt;/b&gt;</a>",
                DefaultDisplayTemplates.EmailAddressTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>", "<b>Encode me!</b>")));
        }

        // HiddenInputTemplate

        [Fact]
        public void HiddenInputTemplateTests()
        {
            Assert.Equal(
                "Hidden Value",
                DefaultDisplayTemplates.HiddenInputTemplate(MakeHtmlHelper<string>("Hidden Value")));

            Assert.Equal(
                "&lt;b&gt;Encode me!&lt;/b&gt;",
                DefaultDisplayTemplates.HiddenInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>", "<b>Encode me!</b>")));

            var helperWithInvisibleHtml = MakeHtmlHelper<string>("<script>alert('XSS!')</script>", "<b>Encode me!</b>");
            helperWithInvisibleHtml.ViewData.ModelMetadata.HideSurroundingHtml = true;
            Assert.Equal(
                String.Empty,
                DefaultDisplayTemplates.HiddenInputTemplate(helperWithInvisibleHtml));
        }

        // HtmlTemplate

        [Fact]
        public void HtmlTemplateTests()
        {
            Assert.Equal(
                "Hello, world!",
                DefaultDisplayTemplates.HtmlTemplate(MakeHtmlHelper<string>("", "Hello, world!")));

            Assert.Equal(
                "<b>Hello, world!</b>",
                DefaultDisplayTemplates.HtmlTemplate(MakeHtmlHelper<string>("", "<b>Hello, world!</b>")));
        }

        // ObjectTemplate

        private static string SpyCallback(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData)
        {
            return String.Format("Model = {0}, ModelType = {1}, PropertyName = {2}, HtmlFieldName = {3}, TemplateName = {4}, Mode = {5}, AdditionalViewData = {6}",
                                 metadata.Model ?? "(null)",
                                 metadata.ModelType == null ? "(null)" : metadata.ModelType.FullName,
                                 metadata.PropertyName ?? "(null)",
                                 htmlFieldName == String.Empty ? "(empty)" : htmlFieldName ?? "(null)",
                                 templateName ?? "(null)",
                                 mode,
                                 AnonymousObject.Inspect(additionalViewData));
        }

        class ObjectTemplateModel
        {
            public ObjectTemplateModel()
            {
                ComplexInnerModel = new object();
            }

            public string Property1 { get; set; }
            public string Property2 { get; set; }
            public object ComplexInnerModel { get; set; }
        }

        [Fact]
        public void ObjectTemplateDisplaysSimplePropertiesOnObjectByDefault()
        {
            string expected =
                "<div class=\"display-label\">Property1</div>" + Environment.NewLine
              + "<div class=\"display-field\">Model = p1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine
              + "<div class=\"display-label\">Property2</div>" + Environment.NewLine
              + "<div class=\"display-field\">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel { Property1 = "p1", Property2 = null };
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateWithDisplayNameMetadata()
        {
            string expected =
                "<div class=\"display-field\">Model = (null), ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine
              + "<div class=\"display-label\">Custom display name</div>" + Environment.NewLine
              + "<div class=\"display-field\">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1") { DisplayName = String.Empty };
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property2") { DisplayName = "Custom display name" };
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateWithShowForDisplayMetadata()
        {
            string expected =
                "<div class=\"display-label\">Property1</div>" + Environment.NewLine
              + "<div class=\"display-field\">Model = (null), ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1") { ShowForDisplay = true };
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property2") { ShowForDisplay = false };
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplatePreventsRecursionOnModelValue()
        {
            string expected =
                "<div class=\"display-label\">Property2</div>" + Environment.NewLine
              + "<div class=\"display-field\">Model = propValue2, ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue1", typeof(string), "Property1");
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue2", typeof(string), "Property2");
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });
            html.ViewData.TemplateInfo.VisitedObjects.Add("propValue1");

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplatePreventsRecursionOnModelTypeForNullModelValues()
        {
            string expected =
                "<div class=\"display-label\">Property2</div>" + Environment.NewLine
              + "<div class=\"display-field\">Model = propValue2, ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)</div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1");
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue2", typeof(string), "Property2");
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });
            html.ViewData.TemplateInfo.VisitedObjects.Add(typeof(string));

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateDisplaysNullDisplayTextWhenObjectIsNull()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(null);
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(ObjectTemplateModel));
            metadata.NullDisplayText = "(null value)";
            html.ViewData.ModelMetadata = metadata;

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(metadata.NullDisplayText, result);
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ObjectTemplateDisplaysSimpleDisplayTextWhenTemplateDepthGreaterThanOne(
            string text,
            bool htmlEncode,
            string expectedResult)
        {
            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(ObjectTemplateModel));
            metadata.SimpleDisplayText = text;
            metadata.HtmlEncode = htmlEncode;

            html.ViewData.ModelMetadata = metadata;
            html.ViewData.TemplateInfo.VisitedObjects.Add("foo");
            html.ViewData.TemplateInfo.VisitedObjects.Add("bar");

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expectedResult, result);
        }

        [Fact]
        public void ObjectTemplateWithHiddenHtml()
        {
            string expected = "Model = propValue1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)";

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue1", typeof(string), "Property1") { HideSurroundingHtml = true };
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata });

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateAllPropertiesFromEntityObjectAreHidden()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(new MyEntityObject());

            // Act
            string result = DefaultDisplayTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        private class MyEntityObject : EntityObject
        {
        }

        // StringTemplate

        [Fact]
        public void StringTemplateTests()
        {
            Assert.Equal(
                "Hello, world!",
                DefaultDisplayTemplates.StringTemplate(MakeHtmlHelper<string>("", "Hello, world!")));

            Assert.Equal(
                "&lt;b&gt;Hello, world!&lt;/b&gt;",
                DefaultDisplayTemplates.StringTemplate(MakeHtmlHelper<string>("", "<b>Hello, world!</b>")));
        }

        // UrlTemplate

        [Fact]
        public void UrlTemplateTests()
        {
            Assert.Equal(
                "<a href=\"http://www.microsoft.com/testing.aspx?value1=foo&amp;value2=bar\">http://www.microsoft.com/testing.aspx?value1=foo&amp;value2=bar</a>",
                DefaultDisplayTemplates.UrlTemplate(MakeHtmlHelper<string>("http://www.microsoft.com/testing.aspx?value1=foo&value2=bar")));

            Assert.Equal(
                "<a href=\"http://www.microsoft.com/testing.aspx?value1=foo&amp;value2=bar\">&lt;b&gt;Microsoft!&lt;/b&gt;</a>",
                DefaultDisplayTemplates.UrlTemplate(MakeHtmlHelper<string>("http://www.microsoft.com/testing.aspx?value1=foo&value2=bar", "<b>Microsoft!</b>")));
        }

        // Helpers

        private HtmlHelper MakeHtmlHelper<TModel>(object model)
        {
            return MakeHtmlHelper<TModel>(model, model);
        }

        private HtmlHelper MakeHtmlHelper<TModel>(object model, object formattedModelValue)
        {
            ViewDataDictionary viewData = new ViewDataDictionary(model);
            viewData.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";
            viewData.TemplateInfo.FormattedModelValue = formattedModelValue;
            viewData.ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(TModel));

            ViewContext viewContext = new ViewContext(new ControllerContext(), new DummyView(), viewData, new TempDataDictionary(), new StringWriter());

            return new HtmlHelper(viewContext, new SimpleViewDataContainer(viewData));
        }

        private class DummyView : IView
        {
            public void Render(ViewContext viewContext, TextWriter writer)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/DefaultEditorTemplatesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Data.Linq;
using System.Data.Objects.DataClasses;
using System.Drawing;
using System.Globalization;
using System.IO;
using System.Web.UI.WebControls;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class DefaultEditorTemplatesTest : IDisposable
    {
        // BooleanTemplate

        [Fact]
        public void BooleanTemplateTests()
        {
            // Boolean values

            Assert.Equal(
                "<input checked=\"checked\" class=\"check-box\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"checkbox\" value=\"true\" /><input name=\"FieldPrefix\" type=\"hidden\" value=\"false\" />",
                DefaultEditorTemplates.BooleanTemplate(MakeHtmlHelper<bool>(true)));

            Assert.Equal(
                "<input class=\"check-box\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"checkbox\" value=\"true\" /><input name=\"FieldPrefix\" type=\"hidden\" value=\"false\" />",
                DefaultEditorTemplates.BooleanTemplate(MakeHtmlHelper<bool>(false)));

            Assert.Equal(
                "<input class=\"check-box\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"checkbox\" value=\"true\" /><input name=\"FieldPrefix\" type=\"hidden\" value=\"false\" />",
                DefaultEditorTemplates.BooleanTemplate(MakeHtmlHelper<bool>(null)));

            // Nullable<Boolean> values

            Assert.Equal(
                "<select class=\"list-box tri-state\" id=\"FieldPrefix\" name=\"FieldPrefix\"><option value=\"\">Not Set</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"true\">True</option>" + Environment.NewLine
              + "<option value=\"false\">False</option>" + Environment.NewLine
              + "</select>",
                DefaultEditorTemplates.BooleanTemplate(MakeHtmlHelper<Nullable<bool>>(true)));

            Assert.Equal(
                "<select class=\"list-box tri-state\" id=\"FieldPrefix\" name=\"FieldPrefix\"><option value=\"\">Not Set</option>" + Environment.NewLine
              + "<option value=\"true\">True</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"false\">False</option>" + Environment.NewLine
              + "</select>",
                DefaultEditorTemplates.BooleanTemplate(MakeHtmlHelper<Nullable<bool>>(false)));

            Assert.Equal(
                "<select class=\"list-box tri-state\" id=\"FieldPrefix\" name=\"FieldPrefix\"><option selected=\"selected\" value=\"\">Not Set</option>" + Environment.NewLine
              + "<option value=\"true\">True</option>" + Environment.NewLine
              + "<option value=\"false\">False</option>" + Environment.NewLine
              + "</select>",
                DefaultEditorTemplates.BooleanTemplate(MakeHtmlHelper<Nullable<bool>>(null)));
        }

        public static TheoryDataSet<object, string> BooleanTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input checked=\"checked\" class=\"form-control check-box\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"checkbox\" value=\"true\" /><input name=\"FieldPrefix\" type=\"hidden\" value=\"false\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input checked=\"checked\" class=\"form-control check-box\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"checkbox\" value=\"true\" /><input name=\"FieldPrefix\" type=\"hidden\" value=\"false\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("BooleanTemplateHtmlAttributeData")]
        public void BooleanTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<bool>(true);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.BooleanTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("BooleanTemplateHtmlAttributeData")]
        public void BooleanTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<bool>(true);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.BooleanTemplate(htmlHelper));
        }

        // CollectionTemplate

        private static string CollectionSpyCallback(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData)
        {
            return String.Format(CultureInfo.InvariantCulture,
                                 Environment.NewLine + "Model = {0}, ModelType = {1}, PropertyName = {2}, HtmlFieldName = {3}, TemplateName = {4}, Mode = {5}, TemplateInfo.HtmlFieldPrefix = {6}, AdditionalViewData = {7}",
                                 metadata.Model ?? "(null)",
                                 metadata.ModelType == null ? "(null)" : metadata.ModelType.FullName,
                                 metadata.PropertyName ?? "(null)",
                                 htmlFieldName == String.Empty ? "(empty)" : htmlFieldName ?? "(null)",
                                 templateName ?? "(null)",
                                 mode,
                                 html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix,
                                 AnonymousObject.Inspect(additionalViewData));
        }

        [Fact]
        public void CollectionTemplateWithNullModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<object>(null);

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void CollectionTemplateNonEnumerableModelThrows()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<object>(new object());

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback),
                "The Collection template was used with an object of type 'System.Object', which does not implement System.IEnumerable."
                );
        }

        [Fact]
        public void CollectionTemplateWithSingleItemCollectionWithoutPrefix()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<string>>(new List<string> { "foo" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = foo, ModelType = System.String, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateWithSingleItemCollectionWithPrefix()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<string>>(new List<string> { "foo" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "ModelProperty";

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = foo, ModelType = System.String, PropertyName = (null), HtmlFieldName = ModelProperty[0], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateWithMultiItemCollection()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<string>>(new List<string> { "foo", "bar", "baz" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = foo, ModelType = System.String, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = bar, ModelType = System.String, PropertyName = (null), HtmlFieldName = [1], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = baz, ModelType = System.String, PropertyName = (null), HtmlFieldName = [2], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateNullITemInWeaklyTypedCollectionUsesModelTypeOfString()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<ArrayList>(new ArrayList { null });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = (null), ModelType = System.String, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateNullItemInStronglyTypedCollectionUsesModelTypeFromIEnumerable()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<IHttpHandler>>(new List<IHttpHandler> { null });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = (null), ModelType = System.Web.IHttpHandler, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateUsesRealObjectTypes()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<object>>(new List<object> { 1, 2.3, "Hello World" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = 1, ModelType = System.Int32, PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = 2.3, ModelType = System.Double, PropertyName = (null), HtmlFieldName = [1], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = Hello World, ModelType = System.String, PropertyName = (null), HtmlFieldName = [2], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplateNullItemInCollectionOfNullableValueTypesDoesNotDiscardNullable()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<int?>>(new List<int?> { 1, null, 2 });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;

            // Act
            string result = DefaultEditorTemplates.CollectionTemplate(html, CollectionSpyCallback);

            // Assert
            Assert.Equal(
                Environment.NewLine
              + "Model = 1, ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = (null), HtmlFieldName = [0], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = (null), ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = (null), HtmlFieldName = [1], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)" + Environment.NewLine
              + "Model = 2, ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = (null), HtmlFieldName = [2], TemplateName = (null), Mode = Edit, TemplateInfo.HtmlFieldPrefix = , AdditionalViewData = (null)",
                result);
        }

        [Fact]
        public void CollectionTemplate_AddsHtmlAttributes()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<List<string>>(new List<string> { "foo", "bar", "baz" });
            html.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = null;
            html.ViewContext.ViewBag.htmlAttributes = new { @class = "form-control", foo = "bar" };

            // Act
            string result = RunWithoutViewEngine(() =>
                DefaultEditorTemplates.CollectionTemplate(html));

            // Assert
            Assert.Equal(
                "<input class=\"form-control text-box single-line\" foo=\"bar\" name=\"[0]\" type=\"text\" value=\"foo\" />"
              + "<input class=\"form-control text-box single-line\" foo=\"bar\" name=\"[1]\" type=\"text\" value=\"bar\" />"
              + "<input class=\"form-control text-box single-line\" foo=\"bar\" name=\"[2]\" type=\"text\" value=\"baz\" />",
                result);
        }

        // DecimalTemplate

        [Fact]
        public void DecimalTemplateTests()
        {
            Assert.Equal(
                String.Format(
                    CultureInfo.CurrentCulture,
                    "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"{0:0.00}\" />",
                    12.35M),
                DefaultEditorTemplates.DecimalTemplate(MakeHtmlHelper<decimal>(12.3456M)));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"Formatted Value\" />",
                DefaultEditorTemplates.DecimalTemplate(MakeHtmlHelper<decimal>(12.3456M, "Formatted Value")));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.DecimalTemplate(MakeHtmlHelper<decimal>(12.3456M, "<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> DecimalTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"12.30\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"12.30\" />"
                    }
                };
            }
        }

        [Theory]
        [ReplaceCulture]
        [PropertyData("DecimalTemplateHtmlAttributeData")]
        public void DecimalTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<decimal>(12.30);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DecimalTemplate(htmlHelper));
        }

        [Theory]
        [ReplaceCulture]
        [PropertyData("DecimalTemplateHtmlAttributeData")]
        public void DecimalTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<decimal>(12.30);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DecimalTemplate(htmlHelper));
        }

        // HiddenInputTemplate

        [Fact]
        public void HiddenInputTemplateTests()
        {
            Assert.Equal(
                "Hidden Value<input id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"hidden\" value=\"Hidden Value\" />",
                DefaultEditorTemplates.HiddenInputTemplate(MakeHtmlHelper<string>("Hidden Value")));

            Assert.Equal(
                "&lt;script&gt;alert(&#39;XSS!&#39;)&lt;/script&gt;<input id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"hidden\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.HiddenInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));

            var helperWithInvisibleHtml = MakeHtmlHelper<string>("<script>alert('XSS!')</script>", "<b>Encode me!</b>");
            helperWithInvisibleHtml.ViewData.ModelMetadata.HideSurroundingHtml = true;
            Assert.Equal(
                "<input id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"hidden\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.HiddenInputTemplate(helperWithInvisibleHtml));

            byte[] byteValues = { 1, 2, 3, 4, 5 };

            Assert.Equal(
                "&quot;AQIDBAU=&quot;<input id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"hidden\" value=\"AQIDBAU=\" />",
                DefaultEditorTemplates.HiddenInputTemplate(MakeHtmlHelper<Binary>(new Binary(byteValues))));

            Assert.Equal(
                "System.Byte[]<input id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"hidden\" value=\"AQIDBAU=\" />",
                DefaultEditorTemplates.HiddenInputTemplate(MakeHtmlHelper<byte[]>(byteValues)));
        }

        public static TheoryDataSet<object, string> HiddenInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "Hidden Value<input class=\"form-control\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"hidden\" value=\"Hidden Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "Hidden Value<input class=\"form-control\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"hidden\" value=\"Hidden Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("HiddenInputTemplateHtmlAttributeData")]
        public void HiddenInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Hidden Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.HiddenInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("HiddenInputTemplateHtmlAttributeData")]
        public void HiddenInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Hidden Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.HiddenInputTemplate(htmlHelper));
        }

        // MultilineText

        [Fact]
        public void MultilineTextTemplateTests()
        {
            Assert.Equal(
                "<textarea class=\"text-box multi-line\" id=\"FieldPrefix\" name=\"FieldPrefix\">" + Environment.NewLine
              + "Multiple" + Environment.NewLine
              + "Line" + Environment.NewLine
              + "Value!</textarea>",
                DefaultEditorTemplates.MultilineTextTemplate(MakeHtmlHelper<string>("", "Multiple" + Environment.NewLine + "Line" + Environment.NewLine + "Value!")));

            Assert.Equal(
                "<textarea class=\"text-box multi-line\" id=\"FieldPrefix\" name=\"FieldPrefix\">" + Environment.NewLine
              + "&lt;script&gt;alert(&#39;XSS!&#39;)&lt;/script&gt;</textarea>",
                DefaultEditorTemplates.MultilineTextTemplate(MakeHtmlHelper<string>("", "<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> MultilineTextTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<textarea class=\"form-control text-box multi-line\" id=\"FieldPrefix\" name=\"FieldPrefix\">" + Environment.NewLine
                      + "Multiple" + Environment.NewLine
                      + "Line" + Environment.NewLine
                      + "Value!</textarea>"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<textarea class=\"form-control text-box multi-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\">" + Environment.NewLine
                      + "Multiple" + Environment.NewLine
                      + "Line" + Environment.NewLine
                      + "Value!</textarea>"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("MultilineTextTemplateHtmlAttributeData")]
        public void MultilineTextTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("", "Multiple" + Environment.NewLine + "Line" + Environment.NewLine + "Value!");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.MultilineTextTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("MultilineTextTemplateHtmlAttributeData")]
        public void MultilineTextTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("", "Multiple" + Environment.NewLine + "Line" + Environment.NewLine + "Value!");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.MultilineTextTemplate(htmlHelper));
        }

        // ObjectTemplate

        private static string SpyCallback(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode, object additionalViewData)
        {
            return String.Format("Model = {0}, ModelType = {1}, PropertyName = {2}, HtmlFieldName = {3}, TemplateName = {4}, Mode = {5}, AdditionalViewData = {6}",
                                 metadata.Model ?? "(null)",
                                 metadata.ModelType == null ? "(null)" : metadata.ModelType.FullName,
                                 metadata.PropertyName ?? "(null)",
                                 htmlFieldName == String.Empty ? "(empty)" : htmlFieldName ?? "(null)",
                                 templateName ?? "(null)",
                                 mode,
                                 AnonymousObject.Inspect(additionalViewData));
        }

        private class ObjectTemplateModel
        {
            public ObjectTemplateModel()
            {
                ComplexInnerModel = new object();
            }

            public string Property1 { get; set; }

            public string Property2 { get; set; }

            public object ComplexInnerModel { get; set; }
        }

        [Fact]
        public void ObjectTemplateEditsSimplePropertiesOnObjectByDefault()
        {
            string expected =
                "<div class=\"editor-label\"><label for=\"FieldPrefix_Property1\">Property1</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = p1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine
              + "<div class=\"editor-label\"><label for=\"FieldPrefix_Property2\">Property2</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel { Property1 = "p1", Property2 = null };
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplate_AddsHtmlAttributes()
        {
            string expected =
                "<div class=\"editor-label\"><label for=\"FieldPrefix_Property1\">Property1</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\"><input class=\"form-control text-box single-line\" foo=\"bar\" id=\"FieldPrefix_Property1\" name=\"FieldPrefix.Property1\" type=\"text\" value=\"p1\" /> </div>" + Environment.NewLine
              + "<div class=\"editor-label\"><label for=\"FieldPrefix_Property2\">Property2</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\"><input class=\"form-control text-box single-line\" foo=\"bar\" id=\"FieldPrefix_Property2\" name=\"FieldPrefix.Property2\" type=\"text\" value=\"\" /> </div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel { Property1 = "p1", Property2 = null };
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            html.ViewContext.ViewBag.htmlAttributes = new { @class = "form-control", foo = "bar" };

            // Act
            string result = RunWithoutViewEngine(() =>
                DefaultEditorTemplates.ObjectTemplate(html));

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateWithModelError()
        {
            string expected =
                "<div class=\"editor-label\"><label for=\"FieldPrefix_Property1\">Property1</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = p1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) <span class=\"field-validation-error\">Error Message</span></div>" + Environment.NewLine
              + "<div class=\"editor-label\"><label for=\"FieldPrefix_Property2\">Property2</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel { Property1 = "p1", Property2 = null };
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            html.ViewData.ModelState.AddModelError("FieldPrefix.Property1", "Error Message");

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateWithDisplayNameMetadata()
        {
            string expected =
                "<div class=\"editor-field\">Model = (null), ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine
              + "<div class=\"editor-label\"><label for=\"FieldPrefix_Property2\">Custom display name</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = (null), ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1") { DisplayName = String.Empty };
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property2") { DisplayName = "Custom display name" };
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateWithShowForEditorMetadata()
        {
            string expected =
                "<div class=\"editor-label\"><label for=\"FieldPrefix_Property1\">Property1</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = (null), ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1") { ShowForEdit = true };
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property2") { ShowForEdit = false };
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplatePreventsRecursionOnModelValue()
        {
            string expected =
                "<div class=\"editor-label\"><label for=\"FieldPrefix_Property2\">Property2</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = propValue2, ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue1", typeof(string), "Property1");
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue2", typeof(string), "Property2");
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });
            html.ViewData.TemplateInfo.VisitedObjects.Add("propValue1");

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplatePreventsRecursionOnModelTypeForNullModelValues()
        {
            string expected =
                "<div class=\"editor-label\"><label for=\"FieldPrefix_Property2\">Property2</label></div>" + Environment.NewLine
              + "<div class=\"editor-field\">Model = propValue2, ModelType = System.String, PropertyName = Property2, HtmlFieldName = Property2, TemplateName = (null), Mode = Edit, AdditionalViewData = (null) </div>" + Environment.NewLine;

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), null, typeof(string), "Property1");
            ModelMetadata prop2Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue2", typeof(string), "Property2");
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata, prop2Metadata });
            html.ViewData.TemplateInfo.VisitedObjects.Add(typeof(string));

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateDisplaysNullDisplayTextWithNullModelAndTemplateDepthGreaterThanOne()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(null);
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(ObjectTemplateModel));
            metadata.NullDisplayText = "Null Display Text";
            metadata.SimpleDisplayText = "Simple Display Text";
            html.ViewData.ModelMetadata = metadata;
            html.ViewData.TemplateInfo.VisitedObjects.Add("foo");
            html.ViewData.TemplateInfo.VisitedObjects.Add("bar");

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(metadata.NullDisplayText, result);
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ObjectTemplateDisplaysSimpleDisplayTextWithNonNullModelTemplateDepthGreaterThanOne(
            string simpleDisplayText,
            bool htmlEncode,
            string expectedResult)
        {
            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(ObjectTemplateModel));
            html.ViewData.ModelMetadata = metadata;
            metadata.NullDisplayText = "Null Display Text";
            metadata.SimpleDisplayText = simpleDisplayText;
            metadata.HtmlEncode = htmlEncode;

            html.ViewData.TemplateInfo.VisitedObjects.Add("foo");
            html.ViewData.TemplateInfo.VisitedObjects.Add("bar");

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expectedResult, result);
        }

        // PasswordTemplate

        [Fact]
        public void PasswordTemplateTests()
        {
            Assert.Equal(
                "<input class=\"text-box single-line password\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"password\" />",
                DefaultEditorTemplates.PasswordTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                "<input class=\"text-box single-line password\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"password\" />",
                DefaultEditorTemplates.PasswordTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));
        }

        [Fact]
        public void PasswordTemplate_ReturnsInputElement_IgnoresValues()
        {
            // Arrange
            var expected = "<input class=\"text-box single-line password\" id=\"FieldPrefix\" name=\"FieldPrefix\" " +
                "type=\"password\" />";

            // Template ignores Model and FormattedModelValue.
            var helper = MakeHtmlHelper<string>(model: "Model string", formattedModelValue: "Formatted string");

            var viewData = helper.ViewData;
            var templateInfo = viewData.TemplateInfo;
            templateInfo.HtmlFieldPrefix = "FieldPrefix";

            // Template ignores ModelState and ViewData.
            var valueProviderResult = new ValueProviderResult(
                "Raw model string",
                "Attempted model string",
                CultureInfo.InvariantCulture);
            viewData.ModelState.SetModelValue("FieldPrefix", valueProviderResult);
            viewData["FieldPrefix"] = "ViewData string";

            // Act
            var result = DefaultEditorTemplates.PasswordTemplate(helper);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void PasswordTemplate_ReturnsInputElement_UsesHtmlAttributes()
        {
            // Arrange
            var expected = "<input class=\"super text-box single-line password\" id=\"FieldPrefix\" " +
                "name=\"FieldPrefix\" type=\"password\" value=\"Html attributes string\" />";
            var helper = MakeHtmlHelper<string>(model: null);
            var viewData = helper.ViewData;
            var templateInfo = viewData.TemplateInfo;
            templateInfo.HtmlFieldPrefix = "FieldPrefix";

            viewData["htmlAttributes"] = new { @class = "super", value = "Html attributes string" };

            // Act
            var result = DefaultEditorTemplates.PasswordTemplate(helper);

            // Assert
            Assert.Equal(expected, result);
        }

        public static TheoryDataSet<object, string> PasswordTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line password\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"password\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line password\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"password\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("PasswordTemplateHtmlAttributeData")]
        public void PasswordTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.PasswordTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("PasswordTemplateHtmlAttributeData")]
        public void PasswordTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.PasswordTemplate(htmlHelper));
        }

        [Fact]
        public void ObjectTemplateWithHiddenHtml()
        {
            string expected = "Model = propValue1, ModelType = System.String, PropertyName = Property1, HtmlFieldName = Property1, TemplateName = (null), Mode = Edit, AdditionalViewData = (null)";

            // Arrange
            ObjectTemplateModel model = new ObjectTemplateModel();
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(model);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Func<object> accessor = () => model;
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, accessor, typeof(ObjectTemplateModel), null);
            ModelMetadata prop1Metadata = new ModelMetadata(provider.Object, typeof(ObjectTemplateModel), () => "propValue1", typeof(string), "Property1") { HideSurroundingHtml = true };
            html.ViewData.ModelMetadata = metadata.Object;
            metadata.Setup(p => p.Properties).Returns(() => new[] { prop1Metadata });

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void ObjectTemplateAllPropertiesFromEntityObjectAreHidden()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper<ObjectTemplateModel>(new MyEntityObject());

            // Act
            string result = DefaultEditorTemplates.ObjectTemplate(html, SpyCallback);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        private class MyEntityObject : EntityObject
        {
        }

        // StringTemplate

        [Fact]
        public void StringTemplateTests()
        {
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"Value\" />",
                DefaultEditorTemplates.StringTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.StringTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> StringTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"text\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("StringTemplateHtmlAttributeData")]
        public void StringTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.StringTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("StringTemplateHtmlAttributeData")]
        public void StringTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.StringTemplate(htmlHelper));
        }

        // PhoneNumberInputTemplate

        [Fact]
        public void PhoneNumberInputTemplateTests()
        {
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"tel\" value=\"Value\" />",
                DefaultEditorTemplates.PhoneNumberInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"tel\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.PhoneNumberInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> PhoneNumberInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"tel\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"tel\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("PhoneNumberInputTemplateHtmlAttributeData")]
        public void PhoneNumberInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.PhoneNumberInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("PhoneNumberInputTemplateHtmlAttributeData")]
        public void PhoneNumberInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.PhoneNumberInputTemplate(htmlHelper));
        }

        // UrlInputTemplate

        [Fact]
        public void UrlInputTemplateTests()
        {
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"url\" value=\"Value\" />",
                DefaultEditorTemplates.UrlInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"url\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.UrlInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> UrlInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"url\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"url\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("UrlInputTemplateHtmlAttributeData")]
        public void UrlInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.UrlInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("UrlInputTemplateHtmlAttributeData")]
        public void UrlInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.UrlInputTemplate(htmlHelper));
        }

        // EmailAddressInputTemplate

        [Fact]
        public void EmailAddressTemplateTests()
        {
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"email\" value=\"Value\" />",
                DefaultEditorTemplates.EmailAddressInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"email\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.EmailAddressInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> EmailAddressInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"email\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"email\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("EmailAddressInputTemplateHtmlAttributeData")]
        public void EmailAddressInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.EmailAddressInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("EmailAddressInputTemplateHtmlAttributeData")]
        public void EmailAddressInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<string>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.EmailAddressInputTemplate(htmlHelper));
        }

        [Fact]
        public void DateTimeInputTemplateTests()
        {
            var type = "datetime";
            Assert.Equal(
                GetExpectedInputTag(type, "Value"),
                DefaultEditorTemplates.DateTimeInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                GetExpectedInputTag(type, "&lt;script>alert(&#39;XSS!&#39;)&lt;/script>"),
                DefaultEditorTemplates.DateTimeInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));

            var epocInLocalTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToLocalTime();
            var helper = MakeHtmlHelper<DateTime>(epocInLocalTime);

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString(CultureInfo.CurrentCulture)),
                DefaultEditorTemplates.DateTimeInputTemplate(helper));

            helper.Html5DateRenderingMode = Html5DateRenderingMode.Rfc3339;

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("yyyy-MM-ddTHH:mm:ss.fffK")),
                DefaultEditorTemplates.DateTimeInputTemplate(helper));

            // Override FormattedModelValue and let helper think this string came from a default [DataType] attribute.
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("yyyy-MM-ddTHH:mm:ss.fffK")),
                DefaultEditorTemplates.DateTimeInputTemplate(helper));

            // Override again but tell helper this string was explicitly user-provided.
            helper.ViewData.ModelMetadata.HasNonDefaultEditFormat = true;
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, "Another string"),
                DefaultEditorTemplates.DateTimeInputTemplate(helper));
        }

        public static TheoryDataSet<object, string> DateTimeInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"datetime\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"datetime\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("DateTimeInputTemplateHtmlAttributeData")]
        public void DateTimeInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DateTimeInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("DateTimeInputTemplateHtmlAttributeData")]
        public void DateTimeInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DateTimeInputTemplate(htmlHelper));
        }

        [Fact]
        public void DateTimeLocalInputTemplateTests()
        {
            var type = "datetime-local";
            Assert.Equal(
                GetExpectedInputTag(type, "Value"),
                DefaultEditorTemplates.DateTimeLocalInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                GetExpectedInputTag(type, "&lt;script>alert(&#39;XSS!&#39;)&lt;/script>"),
                DefaultEditorTemplates.DateTimeLocalInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));

            var epocInLocalTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToLocalTime();
            var helper = MakeHtmlHelper<DateTime>(epocInLocalTime);

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString(CultureInfo.CurrentCulture)),
                DefaultEditorTemplates.DateTimeLocalInputTemplate(helper));

            helper.Html5DateRenderingMode = Html5DateRenderingMode.Rfc3339;

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("yyyy-MM-ddTHH:mm:ss.fff")),
                DefaultEditorTemplates.DateTimeLocalInputTemplate(helper));

            // Override FormattedModelValue and let helper think this string came from a default [DataType] attribute.
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("yyyy-MM-ddTHH:mm:ss.fff")),
                DefaultEditorTemplates.DateTimeLocalInputTemplate(helper));

            // Override again but tell helper this string was explicitly user-provided.
            helper.ViewData.ModelMetadata.HasNonDefaultEditFormat = true;
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, "Another string"),
                DefaultEditorTemplates.DateTimeLocalInputTemplate(helper));
        }

        public static TheoryDataSet<object, string> DateTimeLocalInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"datetime-local\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"datetime-local\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("DateTimeLocalInputTemplateHtmlAttributeData")]
        public void DateTimeLocalInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DateTimeLocalInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("DateTimeLocalInputTemplateHtmlAttributeData")]
        public void DateTimeLocalInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DateTimeLocalInputTemplate(htmlHelper));
        }

        [Fact]
        public void DateInputTemplateTests()
        {
            var type = "date";
            Assert.Equal(
                GetExpectedInputTag(type, "Value"),
                DefaultEditorTemplates.DateInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                GetExpectedInputTag(type, "&lt;script>alert(&#39;XSS!&#39;)&lt;/script>"),
                DefaultEditorTemplates.DateInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));

            var epocInLocalTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToLocalTime();
            var helper = MakeHtmlHelper<DateTime>(epocInLocalTime);

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString(CultureInfo.CurrentCulture)),
                DefaultEditorTemplates.DateInputTemplate(helper));

            helper.Html5DateRenderingMode = Html5DateRenderingMode.Rfc3339;

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("yyyy-MM-dd")),
                DefaultEditorTemplates.DateInputTemplate(helper));

            // Override FormattedModelValue and let helper think this string came from a default [DataType] attribute.
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("yyyy-MM-dd")),
                DefaultEditorTemplates.DateInputTemplate(helper));

            // Override again but tell helper this string was explicitly user-provided.
            helper.ViewData.ModelMetadata.HasNonDefaultEditFormat = true;
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, "Another string"),
                DefaultEditorTemplates.DateInputTemplate(helper));
        }

        public static TheoryDataSet<object, string> DateInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"date\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"date\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("DateInputTemplateHtmlAttributeData")]
        public void DateInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DateInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("DateInputTemplateHtmlAttributeData")]
        public void DateInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.DateInputTemplate(htmlHelper));
        }

        [Fact]
        public void TimeInputTemplateTests()
        {
            var type = "time";
            Assert.Equal(
                GetExpectedInputTag(type, "Value"),
                DefaultEditorTemplates.TimeInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                GetExpectedInputTag(type, "&lt;script>alert(&#39;XSS!&#39;)&lt;/script>"),
                DefaultEditorTemplates.TimeInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));

            var epocInLocalTime = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc).ToLocalTime();
            var helper = MakeHtmlHelper<DateTime>(epocInLocalTime);

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString(CultureInfo.CurrentCulture)),
                DefaultEditorTemplates.TimeInputTemplate(helper));

            helper.Html5DateRenderingMode = Html5DateRenderingMode.Rfc3339;

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("HH:mm:ss.fff")),
                DefaultEditorTemplates.TimeInputTemplate(helper));

            // Override FormattedModelValue and let helper think this string came from a default [DataType] attribute.
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, epocInLocalTime.ToString("HH:mm:ss.fff")),
                DefaultEditorTemplates.TimeInputTemplate(helper));

            // Override again but tell helper this string was explicitly user-provided.
            helper.ViewData.ModelMetadata.HasNonDefaultEditFormat = true;
            helper.ViewData.TemplateInfo.FormattedModelValue = "Another string";

            Assert.Equal(
                GetExpectedInputTag(type, "Another string"),
                DefaultEditorTemplates.TimeInputTemplate(helper));
        }

        public static TheoryDataSet<object, string> TimeInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"time\" value=\"Value\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"time\" value=\"Value\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("TimeInputTemplateHtmlAttributeData")]
        public void TimeInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.TimeInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("TimeInputTemplateHtmlAttributeData")]
        public void TimeInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<DateTime>("Value");
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.TimeInputTemplate(htmlHelper));
        }

        // NumberInputTemplate

        [Fact]
        public void NumberInputTemplateTests()
        {
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"number\" value=\"Value\" />",
                DefaultEditorTemplates.NumberInputTemplate(MakeHtmlHelper<string>("Value")));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"number\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.NumberInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> NumberInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"number\" value=\"10\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"number\" value=\"10\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("NumberInputTemplateHtmlAttributeData")]
        public void NumberInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<int>(10);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.NumberInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("NumberInputTemplateHtmlAttributeData")]
        public void NumberInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var htmlHelper = MakeHtmlHelper<int>(10);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.NumberInputTemplate(htmlHelper));
        }

        // ColorInputTemplate

        [Fact]
        public void ColorInputTemplateTests()
        {
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"color\" value=\"#33F4CC\" />",
                DefaultEditorTemplates.ColorInputTemplate(MakeHtmlHelper<string>("#33F4CC")));

            var color = Color.FromArgb(0x33, 0xf4, 0xcc);
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"color\" value=\"#33F4CC\" />",
                DefaultEditorTemplates.ColorInputTemplate(MakeHtmlHelper<Color>(color)));

            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"color\" value=\"&lt;script>alert(&#39;XSS!&#39;)&lt;/script>\" />",
                DefaultEditorTemplates.ColorInputTemplate(MakeHtmlHelper<string>("<script>alert('XSS!')</script>")));
        }

        public static TheoryDataSet<object, string> ColorInputTemplateHtmlAttributeData
        {
            get
            {
                return new TheoryDataSet<object, string>
                {
                    {
                        new { @class = "form-control" },
                        "<input class=\"form-control text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"color\" value=\"#33F4CC\" />"
                    },
                    {
                        new { @class = "form-control", custom = "foo" },
                        "<input class=\"form-control text-box single-line\" custom=\"foo\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"color\" value=\"#33F4CC\" />"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("ColorInputTemplateHtmlAttributeData")]
        public void ColorInputTemplate_AddsHtmlAttributes(object htmlAttributes, string expectedHtml)
        {
            var color = Color.FromArgb(0x33, 0xf4, 0xcc);
            var htmlHelper = MakeHtmlHelper<Color>(color);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = htmlAttributes;
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.ColorInputTemplate(htmlHelper));
        }

        [Theory]
        [PropertyData("ColorInputTemplateHtmlAttributeData")]
        public void ColorInputTemplate_AddsHtmlAttributesDictionary(object htmlAttributes, string expectedHtml)
        {
            var color = Color.FromArgb(0x33, 0xf4, 0xcc);
            var htmlHelper = MakeHtmlHelper<Color>(color);
            htmlHelper.ViewContext.ViewBag.htmlAttributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            Assert.Equal(
                expectedHtml,
                DefaultEditorTemplates.ColorInputTemplate(htmlHelper));
        }

        // Helpers

        private static string GetExpectedInputTag(string type, string value)
        {
            return string.Format("<input class=\"text-box single-line\" id=\"FieldPrefix\" name=\"FieldPrefix\" type=\"{0}\" value=\"{1}\" />", type, value);
        }

        private HtmlHelper MakeHtmlHelper<TModel>(object model)
        {
            return MakeHtmlHelper<TModel>(model, model);
        }

        private HtmlHelper MakeHtmlHelper<TModel>(object model, object formattedModelValue)
        {
            ViewDataDictionary viewData = new ViewDataDictionary(model);
            viewData.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";
            viewData.TemplateInfo.FormattedModelValue = formattedModelValue;
            viewData.ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(TModel));

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Items).Returns(new Hashtable());

            ViewContext viewContext = new ViewContext(new ControllerContext { HttpContext = mockHttpContext.Object }, new DummyView(), viewData, new TempDataDictionary(), new StringWriter())
            {
                HttpContext = mockHttpContext.Object
            };

            // A new helper instance, is executing within a new scope, so it needs to be reset.
            ScopeStorage.CurrentProvider.CurrentScope = new ScopeStorageDictionary();

            return new HtmlHelper(viewContext, new SimpleViewDataContainer(viewData));
        }

        private class DummyView : IView
        {
            public void Render(ViewContext viewContext, TextWriter writer)
            {
                throw new NotImplementedException();
            }
        }

        private string RunWithoutViewEngine(Func<string> testCode)
        {
            lock (ViewEngines.Engines)
            {
                List<IViewEngine> viewEngines = new List<IViewEngine>(ViewEngines.Engines);
                ViewEngines.Engines.Clear();

                try
                {
                    return testCode();
                }
                finally
                {
                    foreach (var engine in viewEngines)
                    {
                        ViewEngines.Engines.Add(engine);
                    }
                }
            }
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ScopeStorage.CurrentProvider.CurrentScope) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Html/Test/DisplayExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class DisplayExtensionsTest
    {
        [Fact]
        public void DisplayNullExpressionThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => MvcHelper.GetHtmlHelper().Display(expression: null),
                "expression");
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void CollectionTemplateWrappingObjectTemplate_EncodesSimpleDisplayTextOfItems_IfHtmlEncode(
            string text,
            bool htmlEncode,
            string expectedResult)
        {
            // Arrange
            var innerModel = new ObjectTemplateModel
            {
                Property1 = text,           // SimpleDisplayText uses first property by default.
            };
            var model = new[] { innerModel, innerModel, };
            var viewData = new ViewDataDictionary<ObjectTemplateModel[]>(model);
            var html = MvcHelper.GetHtmlHelper(viewData);

            // GetHtmlHelper does not mock enough of the ViewContext for TemplateHelpers use.
            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            // Developers might need to do something similar (including MetadataOverrideScope or another approach
            // replacing ModelMetadataProviders.Current) since for example [DisplayFormat] cannot be applied to a class.
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(ObjectTemplateModel));
            metadata.HtmlEncode = htmlEncode;

            string displayResult;
            string displayForResult;
            string displayForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    displayResult = html.Display("").ToHtmlString();
                    displayForResult = html.DisplayFor(m => m).ToHtmlString();
                    displayForModelResult = html.DisplayForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(expectedResult + expectedResult, displayResult);
            Assert.Equal(expectedResult + expectedResult, displayForResult);
            Assert.Equal(expectedResult + expectedResult, displayForModelResult);
        }

        [Theory]
        [PropertyData("AttributeAndHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void EmailTemplate_AttributeAndHtmlEncodes(
            string text,
            bool htmlEncode,
            string attributeEncodedText,
            string htmlEncodedText)
        {
            // Arrange
            var expectedResult = "<a href=\"mailto:" + attributeEncodedText + "\">" + htmlEncodedText + "</a>";
            var viewData = new ViewDataDictionary<string>(text);
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(string));
            metadata.TemplateHint = "EmailAddress";
            metadata.HtmlEncode = htmlEncode;

            string displayResult;
            string displayForResult;
            string displayForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    displayResult = html.Display("").ToHtmlString();
                    displayForResult = html.DisplayFor(m => m).ToHtmlString();
                    displayForModelResult = html.DisplayForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(expectedResult, displayResult);
            Assert.Equal(expectedResult, displayForResult);
            Assert.Equal(expectedResult, displayForModelResult);
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void HtmlOrStringTemplate_HtmlEncodesValue_IfHtmlEncode(
            string text,
            bool htmlEncode,
            string expectedResult)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(text);
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(string));
            metadata.TemplateHint = htmlEncode ? "String" : "Html";

            string displayResult;
            string displayForResult;
            string displayForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    displayResult = html.Display("").ToHtmlString();
                    displayForResult = html.DisplayFor(m => m).ToHtmlString();
                    displayForModelResult = html.DisplayForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(expectedResult, displayResult);
            Assert.Equal(expectedResult, displayForResult);
            Assert.Equal(expectedResult, displayForModelResult);
        }

        // Inconsistent but long-standing behavior.
        [Theory]
        [PropertyData("HtmlEncodedData_JustText", PropertyType = typeof(EncodedDataSets))]
        public void ObjectTemplate_DoesNotEncodeNullDisplayText(string text)
        {
            // Arrange
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model: null);
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(ObjectTemplateModel));
            metadata.NullDisplayText = text;

            string displayResult;
            string displayForResult;
            string displayForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    displayResult = html.Display("").ToHtmlString();
                    displayForResult = html.DisplayFor(m => m).ToHtmlString();
                    displayForModelResult = html.DisplayForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(text, displayResult);
            Assert.Equal(text, displayForResult);
            Assert.Equal(text, displayForModelResult);
        }

        [Theory]
        [PropertyData("AttributeAndHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void UrlTemplate_AttributeAndHtmlEncodes(
            string text,
            bool htmlEncode,
            string attributeEncodedText,
            string htmlEncodedText)
        {
            // Arrange
            var expectedResult = "<a href=\"" + attributeEncodedText + "\">" + htmlEncodedText + "</a>";
            var viewData = new ViewDataDictionary<string>(text);
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(string));
            metadata.TemplateHint = "Url";
            metadata.HtmlEncode = htmlEncode;

            string displayResult;
            string displayForResult;
            string displayForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    displayResult = html.Display("").ToHtmlString();
                    displayForResult = html.DisplayFor(m => m).ToHtmlString();
                    displayForModelResult = html.DisplayForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(expectedResult, displayResult);
            Assert.Equal(expectedResult, displayForResult);
            Assert.Equal(expectedResult, displayForModelResult);
        }

        [Fact]
        public void Display_FindsViewDataMember()
        {
            // Arrange
            var model = new ObjectTemplateModel { Property1 = "Model string" };
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.Display("Property1");
            }

            // Assert
            Assert.Equal("ViewData string", result.ToString());
        }

        [Fact]
        public void DisplayFor_FindsModel()
        {
            var model = new ObjectTemplateModel { Property1 = "Model string" };
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.DisplayFor(m => m.Property1);
            }

            // Assert
            Assert.Equal("Model string", result.ToString());
        }

        [Fact]
        public void Display_FindsModel_IfNoViewDataMember()
        {
            // Arrange
            var model = new ObjectTemplateModel { Property1 = "Model string" };
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.Display("Property1");
            }

            // Assert
            Assert.Equal("Model string", result.ToString());
        }

        [Fact]
        public void DisplayFor_FindsModel_EvenIfNull()
        {
            var model = new ObjectTemplateModel();
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.DisplayFor(m => m.Property1);
            }

            // Assert
            Assert.Empty(result.ToString());
        }

        private class ObjectTemplateModel
        {
            public string Property1 { get; set; }
            public string Property2 { get; set; }
        }

        private class DummyView : IView
        {
            public void Render(ViewContext viewContext, TextWriter writer)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/DisplayNameExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    public class DisplayNameExtensionsTest
    {
        [Fact]
        public void DisplayNameNullExpressionThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => MvcHelper.GetHtmlHelper().DisplayName(expression: null),
                "expression");
        }

        [Fact]
        public void DisplayNameWithNoModelMetadataDisplayNameOverride()
        {
            // Act
            MvcHtmlString result = MvcHelper.GetHtmlHelper().DisplayNameInternal("PropertyName", new MetadataHelper().MetadataProvider.Object);

            // Assert
            Assert.Equal("PropertyName", result.ToHtmlString());
        }

        [Fact]
        public void DisplayNameUsesMetadataForDisplayText()
        {
            // Arrange
            MetadataHelper metadataHelper = new MetadataHelper();
            metadataHelper.Metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            // Act
            MvcHtmlString result = MvcHelper.GetHtmlHelper().DisplayNameInternal("PropertyName", metadataHelper.MetadataProvider.Object);

            // Assert
            Assert.Equal("Custom display name from metadata", result.ToHtmlString());
        }

        private sealed class Model
        {
            public string PropertyName { get; set; }
        }

        [Fact]
        public void DisplayNameConsultsMetadataProviderForMetadataAboutProperty()
        {
            // Arrange
            Model model = new Model { PropertyName = "propertyValue" };

            ViewDataDictionary viewData = new ViewDataDictionary();
            Mock<ViewContext> viewContext = new Mock<ViewContext>();
            viewContext.Setup(c => c.ViewData).Returns(viewData);

            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(c => c.ViewData).Returns(viewData);

            HtmlHelper<Model> html = new HtmlHelper<Model>(viewContext.Object, viewDataContainer.Object);
            viewData.Model = model;

            MetadataHelper metadataHelper = new MetadataHelper();

            metadataHelper.MetadataProvider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), typeof(Model), "PropertyName"))
                .Returns(metadataHelper.Metadata.Object)
                .Verifiable();

            // Act
            html.DisplayNameInternal("PropertyName", metadataHelper.MetadataProvider.Object);

            // Assert
            metadataHelper.MetadataProvider.Verify();
        }

        [Fact]
        public void DisplayNameUsesMetadataForPropertyName()
        {
            // Arrange
            MetadataHelper metadataHelper = new MetadataHelper();

            metadataHelper.Metadata = new Mock<ModelMetadata>(metadataHelper.MetadataProvider.Object, null, null, typeof(object), "Custom property name from metadata");
            metadataHelper.MetadataProvider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Returns(metadataHelper.Metadata.Object);

            // Act
            MvcHtmlString result = MvcHelper.GetHtmlHelper().DisplayNameInternal("PropertyName", metadataHelper.MetadataProvider.Object);

            // Assert
            Assert.Equal("Custom property name from metadata", result.ToHtmlString());
        }

        [Fact]
        public void DisplayNameForNullExpressionThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => MvcHelper.GetHtmlHelper().DisplayNameFor((Expression<Func<Object, Object>>)null),
                "expression");

            Assert.ThrowsArgumentNull(
                () => GetEnumerableHtmlHelper().DisplayNameFor((Expression<Func<Foo, Object>>)null),
                "expression");
        }

        [Fact]
        public void DisplayNameForNonMemberExpressionThrows()
        {
            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => MvcHelper.GetHtmlHelper().DisplayNameFor(model => new { foo = "Bar" }),
                "Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.");

            Assert.Throws<InvalidOperationException>(
                () => GetEnumerableHtmlHelper().DisplayNameFor((Expression<Func<IEnumerable<Foo>, object>>)(model => new { foo = "Bar" })),
                "Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.");
        }

        [Fact]
        public void DisplayNameForWithNoModelMetadataDisplayNameOverride()
        {
            // Arrange
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = MvcHelper.GetHtmlHelper().DisplayNameFor(model => unknownKey);
            MvcHtmlString enumerableResult = GetEnumerableHtmlHelper().DisplayNameFor((Expression<Func<IEnumerable<Foo>, string>>)(model => unknownKey));

            // Assert
            Assert.Equal("unknownKey", result.ToHtmlString());
            Assert.Equal("unknownKey", enumerableResult.ToHtmlString());
        }

        [Fact]
        public void DisplayNameForUsesModelMetadata()
        {
            // Arrange
            MetadataHelper metadataHelper = new MetadataHelper();

            metadataHelper.Metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = MvcHelper.GetHtmlHelper().DisplayNameForInternal(model => unknownKey, metadataHelper.MetadataProvider.Object);
            MvcHtmlString enumerableResult = GetEnumerableHtmlHelper().DisplayNameForInternal(model => model.Bar, metadataHelper.MetadataProvider.Object);

            // Assert
            Assert.Equal("Custom display name from metadata", result.ToHtmlString());
            Assert.Equal("Custom display name from metadata", enumerableResult.ToHtmlString());
        }

        [Fact]
        public void DisplayNameForEmptyDisplayNameReturnsEmptyName()
        {
            // Arrange
            MetadataHelper metadataHelper = new MetadataHelper();

            metadataHelper.Metadata.Setup(m => m.DisplayName).Returns(String.Empty);
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = MvcHelper.GetHtmlHelper().DisplayNameForInternal(model => unknownKey, metadataHelper.MetadataProvider.Object);
            MvcHtmlString enumerableResult = GetEnumerableHtmlHelper().DisplayNameForInternal(model => model.Bar, metadataHelper.MetadataProvider.Object);

            // Assert
            Assert.Equal(String.Empty, result.ToHtmlString());
            Assert.Equal(String.Empty, enumerableResult.ToHtmlString());
        }

        [Fact]
        public void DisplayNameForModelUsesModelMetadata()
        {
            // Arrange
            ViewDataDictionary viewData = new ViewDataDictionary();
            Mock<ModelMetadata> metadata = new MetadataHelper().Metadata;
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            viewData.ModelMetadata = metadata.Object;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";

            // Act
            MvcHtmlString result = MvcHelper.GetHtmlHelper(viewData).DisplayNameForModel();

            // Assert
            Assert.Equal("Custom display name from metadata", result.ToHtmlString());
        }

        [Fact]
        public void DisplayNameForWithNestedClass()
        {
            // Arrange
            ViewDataDictionary viewData = new ViewDataDictionary();
            Mock<ViewContext> viewContext = new Mock<ViewContext>();
            viewContext.Setup(c => c.ViewData).Returns(viewData);

            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(c => c.ViewData).Returns(viewData);

            HtmlHelper<NestedProduct> html = new HtmlHelper<NestedProduct>(viewContext.Object, viewDataContainer.Object);

            // Act
            MvcHtmlString result = html.DisplayNameForInternal(nested => nested.product.Id, new MetadataHelper().MetadataProvider.Object);

            //Assert
            Assert.Equal("Id", result.ToHtmlString());
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void DisplayNameHelpers_EncodeValue(string text, bool htmlEncode, string expectedResult)
        {
            // Arrange
            var viewData = new ViewDataDictionary<Cart>(model: null);
            viewData.ModelMetadata.DisplayName = text;
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var nameResult = helper.DisplayName("").ToHtmlString();
            var nameForResult = helper.DisplayNameFor(m => m).ToHtmlString();
            var nameForModelResult = helper.DisplayNameForModel().ToHtmlString();

            // Assert
            Assert.Equal(expectedResult, nameResult);
            Assert.Equal(expectedResult, nameForResult);
            Assert.Equal(expectedResult, nameForModelResult);
        }

        private class Product
        {
            public int Id { get; set; }
        }

        private class Cart
        {
            public Product[] Products { get; set; }
        }

        private class NestedProduct
        {
            public Product product = new Product();
        }

        private sealed class Foo
        {
            public string Bar { get; set; }
        }

        private static HtmlHelper<IEnumerable<Foo>> GetEnumerableHtmlHelper()
        {
            return MvcHelper.GetHtmlHelper(new ViewDataDictionary<IEnumerable<Foo>>());
        }

        private sealed class MetadataHelper
        {
            public Mock<ModelMetadata> Metadata { get; set; }
            public Mock<ModelMetadataProvider> MetadataProvider { get; set; }

            public MetadataHelper()
            {
                MetadataProvider = new Mock<ModelMetadataProvider>();
                Metadata = new Mock<ModelMetadata>(MetadataProvider.Object, null, null, typeof(object), null);

                MetadataProvider.Setup(p => p.GetMetadataForProperties(It.IsAny<object>(), It.IsAny<Type>()))
                    .Returns(new ModelMetadata[0]);
                MetadataProvider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                    .Returns(Metadata.Object);
                MetadataProvider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                    .Returns(Metadata.Object);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/DisplayTextExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Globalization;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    public class DisplayTextExtensionsTest
    {
        [Fact]
        public void DisplayText_ThrowsArgumentNull_IfNameNull()
        {
            // Arrange
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model: null);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act & Assert
            // Note ArgumentNullException uses incorrect parameter name.
            Assert.ThrowsArgumentNull(
                () => helper.DisplayText(name: null),
                "expression");
        }

        [Fact]
        public void DisplayTextFor_ThrowsArgumentNull_IfExpressionNull()
        {
            // Arrange
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model: null);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.DisplayTextFor<OverriddenToStringModel, string>(expression: null),
                "expression");
        }

        [Fact]
        public void DisplayText_ReturnsEmpty_IfValueNull()
        {
            // Arrange
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model: null);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("");

            // Assert
            Assert.Empty(result.ToHtmlString());
        }

        [Fact]
        public void DisplayTextFor_ReturnsEmpty_IfValueNull()
        {
            // Arrange
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model: null);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m);

            // Assert
            Assert.Empty(result.ToHtmlString());
        }

        [Fact]
        public void DisplayText_ReturnsNullDisplayText_IfSetAndValueNull()
        {
            // Arrange
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model: null);
            viewData.ModelMetadata.NullDisplayText = "Null display Text";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("");

            // Assert
            Assert.Equal("Null display Text", result.ToHtmlString());
        }

        [Fact]
        public void DisplayTextFor_ReturnsNullDisplayText_IfSetAndValueNull()
        {
            // Arrange
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model: null);
            viewData.ModelMetadata.NullDisplayText = "Null display Text";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m);

            // Assert
            Assert.Equal("Null display Text", result.ToHtmlString());
        }

        [Fact]
        public void DisplayText_ReturnsValue_IfNameEmpty()
        {
            // Arrange
            var model = new OverriddenToStringModel("Model value");
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("");

            // Assert
            Assert.Equal("Model value", result.ToHtmlString());
        }

        [Fact]
        public void DisplayText_ReturnsEmpty_IfNameNotFound()
        {
            // Arrange
            var model = new OverriddenToStringModel("Model value");
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("NonExistentProperty");

            // Assert
            Assert.Empty(result.ToHtmlString());
        }

        [Fact]
        public void DisplayTextFor_ReturnsValue_IfIdentityExpression()
        {
            // Arrange
            var model = new OverriddenToStringModel("Model value");
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m);

            // Assert
            Assert.Equal("Model value", result.ToHtmlString());
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void DisplayText_HonoursHtmlEncode_IfOverridden(string text, bool htmlEncode, string expectedResult)
        {
            // Arrange
            var model = new OverriddenToStringModel(text);
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("");

            // Assert
            Assert.Equal(expectedResult, result.ToHtmlString());
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void DisplayTextFor_HonoursHtmlEncode_IfOverridden(string text, bool htmlEncode, string expectedResult)
        {
            // Arrange
            var model = new OverriddenToStringModel(text);
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m);

            // Assert
            Assert.Equal(expectedResult, result.ToHtmlString());
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void DisplayText_HonoursHtmlEncode_ForProperty(string text, bool htmlEncode, string expectedResult)
        {
            // Arrange
            var model = new DontHtmlEncodeModel
            {
                Encoded = text,
                NotEncoded = text,
            };
            var viewData = new ViewDataDictionary<DontHtmlEncodeModel>(model);
            var helper = MvcHelper.GetHtmlHelper(viewData);
            var propertyName = htmlEncode ? "Encoded" : "NotEncoded";

            // Act
            MvcHtmlString result = helper.DisplayText(propertyName);

            // Assert
            Assert.Equal(expectedResult, result.ToHtmlString());
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void DisplayTextFor_HonoursHtmlEncode_ForProperty(string text, bool htmlEncode, string expectedResult)
        {
            // Arrange
            var model = new DontHtmlEncodeModel
            {
                Encoded = text,
                NotEncoded = text,
            };
            var viewData = new ViewDataDictionary<DontHtmlEncodeModel>(model);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result;
            if (htmlEncode)
            {
                result = helper.DisplayTextFor(m => m.Encoded);
            }
            else
            {
                result = helper.DisplayTextFor(m => m.NotEncoded);
            }

            // Assert
            Assert.Equal(expectedResult, result.ToHtmlString());
        }

        [Fact]
        public void DisplayText_ReturnsSimpleDisplayText_IfSetAndValueNonNull()
        {
            // Arrange
            var model = new OverriddenToStringModel("ignored text");
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            viewData.ModelMetadata.SimpleDisplayText = "Simple display text";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("");

            // Assert
            Assert.Equal("Simple display text", result.ToHtmlString());
        }

        [Fact]
        public void DisplayTextFor_ReturnsSimpleDisplayText_IfSetAndValueNonNull()
        {
            // Arrange
            var model = new OverriddenToStringModel("ignored text");
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            viewData.ModelMetadata.SimpleDisplayText = "Simple display text";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m);

            // Assert
            Assert.Equal("Simple display text", result.ToHtmlString());
        }

        [Fact]
        public void DisplayText_ReturnsPropertyValue_IfNameFound()
        {
            // Arrange
            var model = new OverriddenToStringModel("ignored text")
            {
                Name = "Property value",
            };
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("Name");

            // Assert
            Assert.Equal("Property value", result.ToHtmlString());
        }

        [Fact]
        public void DisplayTextFor_ReturnsPropertyValue_IfPropertyExpression()
        {
            // Arrange
            var model = new OverriddenToStringModel("ignored text")
            {
                Name = "Property value",
            };
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model);
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m.Name);

            // Assert
            Assert.Equal("Property value", result.ToHtmlString());
        }

        [Fact]
        public void DisplayText_ReturnsViewDataEntry()
        {
            // Arrange
            var model = new OverriddenToStringModel("Model value")
            {
                Name = "Property value",
            };
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model)
            {
                { "Name", "View data dictionary value" },
            };
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("Name");

            // Assert
            Assert.Equal("View data dictionary value", result.ToHtmlString());
        }

        [Fact]
        public void DisplayTextFor_IgnoresViewDataEntry()
        {
            // Arrange
            var model = new OverriddenToStringModel("Model value")
            {
                Name = "Property value",
            };
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model)
            {
                { "Name", "View data dictionary value" },
            };
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m.Name);

            // Assert
            Assert.Equal("Property value", result.ToHtmlString());
        }

        [Fact]
        public void DisplayText_ReturnsModelStateEntry()
        {
            // Arrange
            var model = new OverriddenToStringModel("Model value")
            {
                Name = "Property value",
            };
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model)
            {
                { "Name", "View data dictionary value" },
            };
            viewData.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";

            var modelState = new ModelState();
            modelState.Value = new ValueProviderResult(
                rawValue: new string[] { "Attempted name value" },
                attemptedValue: "Attempted name value",
                culture: CultureInfo.InvariantCulture);
            viewData.ModelState["FieldPrefix.Name"] = modelState;

            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayText("Name");

            // Assert
            Assert.Equal("View data dictionary value", result.ToHtmlString());
        }

        [Fact]
        public void DisplayTextFor_IgnoresModelStateEntry()
        {
            // Arrange
            var model = new OverriddenToStringModel("Model value")
            {
                Name = "Property value",
            };
            var viewData = new ViewDataDictionary<OverriddenToStringModel>(model)
            {
                { "Name", "View data dictionary value" },
            };
            viewData.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";

            var modelState = new ModelState();
            modelState.Value = new ValueProviderResult(
                rawValue: new string[] { "Attempted name value" },
                attemptedValue: "Attempted name value",
                culture: CultureInfo.InvariantCulture);
            viewData.ModelState["FieldPrefix.Name"] = modelState;

            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString result = helper.DisplayTextFor(m => m.Name);

            // Assert
            Assert.Equal("Property value", result.ToHtmlString());
        }

        private sealed class DontHtmlEncodeModel
        {
            public string Encoded { get; set; }

            [DisplayFormat(HtmlEncode = false)]
            public string NotEncoded { get; set; }
        }

        // ModelMetadata.SimpleDisplayText returns ToString() displayForModelResult if that method has been overridden.
        private sealed class OverriddenToStringModel
        {
            private readonly string _simpleDisplayText;

            public OverriddenToStringModel(string simpleDisplayText)
            {
                _simpleDisplayText = simpleDisplayText;
            }

            public string Name { get; set; }

            public override string ToString()
            {
                return _simpleDisplayText;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/EditorExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class EditorExtensionsTest
    {
        [Fact]
        public void EditorNullExpressionThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => MvcHelper.GetHtmlHelper().Editor(expression: null),
                "expression");
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void BooleanTemplate_AttributeEncodes_AddedHtmlAttributes(string text, string htmlEncodedText)
        {
            // Arrange
            var expectedResult = "<input attribute=\"" +
                htmlEncodedText +
                "\" checked=\"checked\" class=\"check-box\" id=\"Prefix\" name=\"Prefix\" type=\"checkbox\" " +
                "value=\"true\" />" +
                "<input name=\"Prefix\" type=\"hidden\" value=\"false\" />";
            var viewData = new ViewDataDictionary<bool>(true);
            viewData.Add("htmlAttributes", new { attribute = text, });
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";

            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            string editorResult;
            string editorForResult;
            string editorForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                editorResult = html.Editor("").ToHtmlString();
                editorForResult = html.EditorFor(m => m).ToHtmlString();
                editorForModelResult = html.EditorForModel().ToHtmlString();
            }

            // Assert
            Assert.Equal(expectedResult, editorResult);
            Assert.Equal(expectedResult, editorForResult);
            Assert.Equal(expectedResult, editorForModelResult);
        }

        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void CollectionTemplateWrappingObjectTemplate_EncodesSimpleDisplayTextOfItems_IfHtmlEncode(
            string text,
            bool htmlEncode,
            string expectedResult)
        {
            // Arrange
            var innerModel = new ObjectTemplateModel
            {
                Property1 = text,           // SimpleDisplayText uses first property by default.
            };
            var model = new[] { innerModel, innerModel, };
            var viewData = new ViewDataDictionary<ObjectTemplateModel[]>(model);
            var html = MvcHelper.GetHtmlHelper(viewData);

            // GetHtmlHelper does not mock enough of the ViewContext for TemplateHelpers use.
            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            // Developers might need to do something similar (including MetadataOverrideScope or another approach
            // replacing ModelMetadataProviders.Current) since for example [DisplayFormat] cannot be applied to a class.
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(ObjectTemplateModel));
            metadata.HtmlEncode = htmlEncode;

            string editorResult;
            string editorForResult;
            string editorForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    editorResult = html.Editor("").ToHtmlString();
                    editorForResult = html.EditorFor(m => m).ToHtmlString();
                    editorForModelResult = html.EditorForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(expectedResult + expectedResult, editorResult);
            Assert.Equal(expectedResult + expectedResult, editorForResult);
            Assert.Equal(expectedResult + expectedResult, editorForModelResult);
        }

        // Inconsistent but long-standing behavior.
        [Theory]
        [PropertyData("ConditionallyHtmlEncodedData_NoEncodedText", PropertyType = typeof(EncodedDataSets))]
        public void CollectionTemplateWrappingObjectTemplate_DoesNotEncodeNullDisplayText_IfNull(
            string text,
            bool htmlEncode)
        {
            // Arrange
            var model = new[] { (ObjectTemplateModel)null, };
            var viewData = new ViewDataDictionary<ObjectTemplateModel[]>(model);
            var html = MvcHelper.GetHtmlHelper(viewData);

            // GetHtmlHelper does not mock enough of the ViewContext for TemplateHelpers use.
            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            // Developers might need to do something similar (including MetadataOverrideScope or another approach
            // replacing ModelMetadataProviders.Current) since for example [DisplayFormat] cannot be applied to a class.
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(ObjectTemplateModel));
            metadata.HtmlEncode = htmlEncode;
            metadata.NullDisplayText = text;

            string editorResult;
            string editorForResult;
            string editorForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                using (new MetadataOverrideScope(metadata))
                {
                    // Act
                    editorResult = html.Editor("").ToHtmlString();
                    editorForResult = html.EditorFor(m => m).ToHtmlString();
                    editorForModelResult = html.EditorForModel().ToHtmlString();
                }
            }

            // Assert
            Assert.Equal(text, editorResult);
            Assert.Equal(text, editorForResult);
            Assert.Equal(text, editorForModelResult);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void StringTemplate_AttributeEncodes_AddedHtmlAttributes(string text, string htmlEncodedText)
        {
            // Arrange
            var expectedResult = "<input attribute=\"" +
                htmlEncodedText +
                "\" class=\"text-box single-line\" id=\"Prefix\" name=\"Prefix\" type=\"text\" value=\"string\" />";
            var viewData = new ViewDataDictionary<string>("string");
            viewData.Add("htmlAttributes", new { attribute = text, });
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";

            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            string editorResult;
            string editorForResult;
            string editorForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                editorResult = html.Editor("").ToHtmlString();
                editorForResult = html.EditorFor(m => m).ToHtmlString();
                editorForModelResult = html.EditorForModel().ToHtmlString();
            }

            // Assert
            Assert.Equal(expectedResult, editorResult);
            Assert.Equal(expectedResult, editorForResult);
            Assert.Equal(expectedResult, editorForModelResult);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void StringTemplate_AttributeEncodesText(string text, string htmlEncodedText)
        {
            // Arrange
            var expectedResult =
                "<input class=\"text-box single-line\" id=\"Prefix\" name=\"Prefix\" type=\"text\" value=\"" +
                    htmlEncodedText +
                    "\" />";
            var viewData = new ViewDataDictionary<string>(text);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";

            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            string editorResult;
            string editorForResult;
            string editorForModelResult;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                editorResult = html.Editor("").ToHtmlString();
                editorForResult = html.EditorFor(m => m).ToHtmlString();
                editorForModelResult = html.EditorForModel().ToHtmlString();
            }

            // Assert
            Assert.Equal(expectedResult, editorResult);
            Assert.Equal(expectedResult, editorForResult);
            Assert.Equal(expectedResult, editorForModelResult);
        }

        [Fact]
        public void Editor_FindsViewDataMember()
        {
            // Arrange
            var model = new ObjectTemplateModel { Property1 = "Model string" };
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.Editor("Property1");
            }

            // Assert
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"Property1\" name=\"Property1\" type=\"text\" value=\"ViewData string\" />",
                result.ToString());
        }

        [Fact]
        public void EditorFor_FindsModel()
        {
            var model = new ObjectTemplateModel { Property1 = "Model string" };
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.EditorFor(m => m.Property1);
            }

            // Assert
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"Property1\" name=\"Property1\" type=\"text\" value=\"Model string\" />",
                result.ToString());
        }

        [Fact]
        public void Editor_FindsModel_IfNoViewDataMember()
        {
            // Arrange
            var model = new ObjectTemplateModel { Property1 = "Model string" };
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.Editor("Property1");
            }

            // Assert
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"Property1\" name=\"Property1\" type=\"text\" value=\"Model string\" />",
                result.ToString());
        }

        [Fact]
        public void EditorFor_FindsModel_EvenIfNull()
        {
            var model = new ObjectTemplateModel();
            var viewData = new ViewDataDictionary<ObjectTemplateModel>(model);
            viewData["Property1"] = "ViewData string";
            var html = MvcHelper.GetHtmlHelper(viewData);

            var viewContext = Mock.Get(html.ViewContext);
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            MvcHtmlString result;
            using (new TemplateHelpersSafeScope())
            {
                // Act
                result = html.EditorFor(m => m.Property1);
            }

            // Assert
            Assert.Equal(
                "<input class=\"text-box single-line\" id=\"Property1\" name=\"Property1\" type=\"text\" value=\"\" />",
                result.ToString());
        }

        private class ObjectTemplateModel
        {
            public string Property1 { get; set; }
            public string Property2 { get; set; }
        }

        private class DummyView : IView
        {
            public void Render(ViewContext viewContext, TextWriter writer)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/EncodedDataSets.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Html.Test
{
    public static class EncodedDataSets
    {
        private static readonly List<StringSet> StringSets = new List<StringSet>
        {
            // Needs extra URL-escaping due to routing special cases.
            new StringSet("&'\"", "&amp;&#39;&quot;", "&amp;&#39;&quot;", "___", "%26&#39;%22"),

            // High ASCII
            new StringSet(" ¡ÿĀ", " ¡ÿĀ", "&#160;&#161;&#255;Ā", "____"),

            // Surrogate pair, Ugaritic letter beta, &x10381;
            new StringSet("\xD800\xDF81", "𐎁", "&#66433;", "__"),

            new StringSet(
                "<blink>text</blink>",
                "&lt;blink>text&lt;/blink>",
                "&lt;blink&gt;text&lt;/blink&gt;",
                "_blink_text__blink_"),

            // Remaining examples are only id-sanitized, not attribute- or HTML-encoded.
            new StringSet("Simple Display Text", "Simple Display Text", "Simple Display Text", "Simple_Display_Text"),
            new StringSet("Chinese西雅图Chars", "Chinese西雅图Chars", "Chinese西雅图Chars", "Chinese___Chars"), // Seattle
            new StringSet(
                "Unicode؃Format؃Char", // class Cf
                "Unicode؃Format؃Char",
                "Unicode؃Format؃Char",
                "Unicode_Format_Char"),
            new StringSet(
                "UnicodeῼTitlecaseῼChar", // class Lt
                "UnicodeῼTitlecaseῼChar",
                "UnicodeῼTitlecaseῼChar",
                "Unicode_Titlecase_Char"),
            new StringSet(
                "UnicodeःCombiningःChar", // class Mc
                "UnicodeःCombiningःChar",
                "UnicodeःCombiningःChar",
                "Unicode_Combining_Char"),
        };

        public static TheoryDataSet<string, bool, string, string> AttributeAndHtmlEncodedData
        {
            get
            {
                var result = new TheoryDataSet<string, bool, string, string>();
                foreach (var stringSet in StringSets)
                {
                    // Same results whether ModelMetadata.HtmlEncode is true or false.
                    result.Add(
                        stringSet.Text,
                        false,
                        stringSet.AttributeEncodedText,
                        stringSet.HtmlEncodedText);
                    result.Add(
                        stringSet.Text,
                        true,
                        stringSet.AttributeEncodedText,
                        stringSet.HtmlEncodedText);
                }

                return result;
            }
        }

        public static TheoryDataSet<string, bool, string> AttributeEncodedData
        {
            get
            {
                var result = new TheoryDataSet<string, bool, string>();
                foreach (var stringSet in StringSets)
                {
                    // Same results whether ModelMetadata.HtmlEncode is true or false.
                    result.Add(stringSet.Text, false, stringSet.AttributeEncodedText);
                    result.Add(stringSet.Text, true, stringSet.AttributeEncodedText);
                }

                return result;
            }
        }

        public static TheoryDataSet<string, bool> AttributeEncodedData_NoEncodedText
        {
            get
            {
                var dataSet = new TheoryDataSet<string, bool>();
                foreach (var stringSet in StringSets)
                {
                    dataSet.Add(stringSet.Text, false);
                    dataSet.Add(stringSet.Text, true);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<string, string> AttributeEncodedData_NoHtmlEncode
        {
            get
            {
                var dataSet = new TheoryDataSet<string, string>();
                foreach (var stringSet in StringSets)
                {
                    dataSet.Add(stringSet.Text, stringSet.AttributeEncodedText);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<string, bool, string> ConditionallyHtmlEncodedData
        {
            get
            {
                var result = new TheoryDataSet<string, bool, string>();
                foreach (var stringSet in StringSets)
                {
                    result.Add(stringSet.Text, false, stringSet.Text);
                    result.Add(stringSet.Text, true, stringSet.HtmlEncodedText);
                }

                return result;
            }
        }

        public static TheoryDataSet<string, bool> ConditionallyHtmlEncodedData_NoEncodedText
        {
            get
            {
                var dataSet = new TheoryDataSet<string, bool>();
                foreach (var stringSet in StringSets)
                {
                    dataSet.Add(stringSet.Text, false);
                    dataSet.Add(stringSet.Text, true);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<string, bool, string> HtmlEncodedData
        {
            get
            {
                var result = new TheoryDataSet<string, bool, string>();
                foreach (var stringSet in StringSets)
                {
                    // Same results whether ModelMetadata.HtmlEncode is true or false.
                    result.Add(stringSet.Text, false, stringSet.HtmlEncodedText);
                    result.Add(stringSet.Text, true, stringSet.HtmlEncodedText);
                }

                return result;
            }
        }

        public static TheoryDataSet<string, string> HtmlEncodedData_NoHtmlEncode
        {
            get
            {
                var dataSet = new TheoryDataSet<string, string>();
                foreach (var stringSet in StringSets)
                {
                    dataSet.Add(stringSet.Text, stringSet.HtmlEncodedText);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<string> HtmlEncodedData_JustText
        {
            get
            {
                var dataSet = new TheoryDataSet<string>();
                foreach (var stringSet in StringSets)
                {
                    dataSet.Add(stringSet.Text);
                }

                return dataSet;
            }
        }

        public static TheoryDataSet<string, bool, string> IdEncodedData
        {
            get
            {
                var result = new TheoryDataSet<string, bool, string>();
                foreach (var encodedString in StringSets)
                {
                    // Same results whether ModelMetadata.HtmlEncode is true or false.
                    // Add leading 'a' to avoid sanitizing to an empty string.
                    result.Add("a" + encodedString.Text, false, "a" + encodedString.IdEncodedText);
                    result.Add("a" + encodedString.Text, true, "a" + encodedString.IdEncodedText);
                }

                return result;
            }
        }

        public static TheoryDataSet<string, string> IdEncodedData_NoHtmlEncode
        {
            get
            {
                var result = new TheoryDataSet<string, string>();
                foreach (var encodedString in StringSets)
                {
                    // Add leading 'a' to avoid sanitizing to an empty string.
                    result.Add("a" + encodedString.Text, "a" + encodedString.IdEncodedText);
                }

                return result;
            }
        }

        public static TheoryDataSet<string, bool, string> UrlEncodedData
        {
            get
            {
                var result = new TheoryDataSet<string, bool, string>();
                foreach (var encodedString in StringSets)
                {
                    // Same results whether ModelMetadata.HtmlEncode is true or false.
                    result.Add(encodedString.Text, false, encodedString.UrlEncodedText);
                    result.Add(encodedString.Text, true, encodedString.UrlEncodedText);
                }

                return result;
            }
        }

        public static TheoryDataSet<string, string> UrlEncodedData_NoHtmlEncode
        {
            get
            {
                var result = new TheoryDataSet<string, string>();
                foreach (var encodedString in StringSets)
                {
                    result.Add(encodedString.Text, encodedString.UrlEncodedText);
                }

                return result;
            }
        }

        private class StringSet
        {
            public StringSet(string text, string attributeEncodedText, string htmlEncodedText, string idEncodedText)
                : this(text, attributeEncodedText, htmlEncodedText, idEncodedText, Uri.EscapeUriString(text))
            {
            }

            public StringSet(
                string text,
                string attributeEncodedText,
                string htmlEncodedText,
                string idEncodedText,
                string urlEncodedText)
            {
                Contract.Assert(!String.IsNullOrEmpty(text));
                Contract.Assert(!String.IsNullOrEmpty(attributeEncodedText));
                Contract.Assert(!String.IsNullOrEmpty(htmlEncodedText));
                Contract.Assert(!String.IsNullOrEmpty(idEncodedText));
                Contract.Assert(!String.IsNullOrEmpty(urlEncodedText));

                // Override default UrlEncodedText.
                Text = text;
                AttributeEncodedText = attributeEncodedText;
                HtmlEncodedText = htmlEncodedText;
                IdEncodedText = idEncodedText;
                UrlEncodedText = urlEncodedText;
            }

            public string Text { get; private set; }

            public string AttributeEncodedText { get; private set; }

            public string HtmlEncodedText { get; private set; }

            public string IdEncodedText { get; private set; }

            public string UrlEncodedText { get; private set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/EnumHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Web.Script.Serialization;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    public class EnumHelperTest
    {
        private static JavaScriptSerializer _serializer = new JavaScriptSerializer();

        // IsValidForEnumHelper()

        public static TheoryDataSet<Type, bool> IsValidForEnumHelperData
        {
            get
            {
                return new TheoryDataSet<Type, bool>
                {
                    { typeof(int), false },
                    { typeof(int?), false },
                    { typeof(EnumHelperTest), false },
                    { typeof(Enum), false },
                    { typeof(EnumWithDisplay), true },
                    { typeof(EnumWithoutAnything), true },
                    { typeof(EnumWithoutZero?), true },
                    { typeof(EnumWithFlags), false },
                    { typeof(EnumWithFlags?), false },
                };
            }
        }

        [Theory]
        [InlineData(null, false)]
        [PropertyData("IsValidForEnumHelperData")]
        public void IsValidForEnumHelperWithTypeIsSuccessful(Type type, bool expected)
        {
            // Arrange & Act
            bool isValid = EnumHelper.IsValidForEnumHelper(type);

            // Assert
            Assert.Equal(expected, isValid);
        }

        [Fact]
        public void IsValidForEnumHelperWithNullMetadataIsSuccessful()
        {
            // Arrange & Act
            bool isValid = EnumHelper.IsValidForEnumHelper((ModelMetadata)null);

            // Assert
            Assert.False(isValid);
        }

        // No way to run a test with non-null ModelMetadata and null ModelType
        [Theory]
        [PropertyData("IsValidForEnumHelperData")]
        public void IsValidForEnumHelperWithMetadataIsSuccessful(Type type, bool expected)
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, type, null);

            // Act
            bool isValid = EnumHelper.IsValidForEnumHelper(metadata);

            // Assert
            Assert.Equal(expected, isValid);
        }

        // GetSelectList()

        public static TheoryDataSet<Type, string> GetSelectListIsSuccessfulData
        {
            get
            {
                return new TheoryDataSet<Type, string>
                {
                    { typeof(EnumWithDisplay),
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"3\"}]" },
                    { typeof(EnumWithDuplicates),
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"2\"}]" },
                    { typeof(EnumWithGaps),
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"4\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"6\"}]" },
                    { typeof(EnumWithoutAnything), "[]" },
                    { typeof(EnumWithoutZero),
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"12\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"13\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"14\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"15\"}]" },
                    { typeof(EnumWithReversedValues),
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"3\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"0\"}]" },
                    { typeof(EnumWithReversedValues?),
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"\",\"Value\":\"\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"3\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"0\"}]" },
                };
            }
        }

        [Theory]
        [PropertyData("GetSelectListIsSuccessfulData")]
        public void GetSelectListWithTypeIsSuccessful(Type type, string expected)
        {
            // Arrange & Act
            IList<SelectListItem> selectList = EnumHelper.GetSelectList(type);

            // Assert
            Assert.Equal(expected, SelectListToString(selectList));
        }

        [Theory]
        [PropertyData("GetSelectListIsSuccessfulData")]
        public void GetSelectListWithMetadataIsSuccessful(Type type, string expected)
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, type, null);

            // Act
            IList<SelectListItem> selectList = EnumHelper.GetSelectList(metadata);

            // Assert
            Assert.Equal(expected, SelectListToString(selectList));
        }

        public static TheoryDataSet<Type, Enum, string> GetSelectListWithEnumIsSuccessfulData
        {
            get
            {
                return new TheoryDataSet<Type, Enum, string>
                {
                    { typeof(EnumWithDisplay?), EnumWithDisplay.Zero,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"\",\"Value\":\"\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"3\"}]" },
                    { typeof(EnumWithDuplicates), EnumWithDuplicates.Second, // Same value as EnumWithDuplicates.Third
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"Third\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"2\"}]" },
                    { typeof(EnumWithGaps?), EnumWithGaps.Third,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"\",\"Value\":\"\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"Third\",\"Value\":\"4\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"6\"}]" },
                    { typeof(EnumWithoutAnything), (EnumWithoutAnything)0,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"\",\"Value\":\"0\"}]" },
                    { typeof(EnumWithoutZero), EnumWithoutZero.Fourth,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"12\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"13\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"14\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"Fourth\",\"Value\":\"15\"}]" },
                    { typeof(EnumWithoutZero), (EnumWithoutZero)0,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"12\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"13\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"14\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"15\"}]" },
                    { typeof(EnumWithReversedValues?), (EnumWithReversedValues)32,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"\",\"Value\":\"32\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"3\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"0\"}]" },
                    { typeof(EnumWithDisplay?), null,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"\",\"Value\":\"\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"2\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"3\"}]" },
                    { typeof(EnumWithDuplicates), null,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"First\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"1\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"2\"}]" },
                    { typeof(EnumWithoutZero), null,
                        "[{\"Disabled\":false,\"Group\":null,\"Selected\":true,\"Text\":\"\",\"Value\":\"0\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"First\",\"Value\":\"12\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Second\",\"Value\":\"13\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Third\",\"Value\":\"14\"}," +
                        "{\"Disabled\":false,\"Group\":null,\"Selected\":false,\"Text\":\"Fourth\",\"Value\":\"15\"}]" },
                };
            }
        }

        [Theory]
        [PropertyData("GetSelectListWithEnumIsSuccessfulData")]
        public void GetSelectListWithTypeAndEnumIsSuccessful(Type type, Enum value, string expected)
        {
            // Arrange & Act
            IList<SelectListItem> selectList = EnumHelper.GetSelectList(type, value);

            // Assert
            Assert.Equal(expected, SelectListToString(selectList));
        }

        [Theory]
        [PropertyData("GetSelectListWithEnumIsSuccessfulData")]
        public void GetSelectListWithMetadataAndEnumIsSuccessful(Type type, Enum value, string expected)
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, type, null);

            // Act
            IList<SelectListItem> selectList = EnumHelper.GetSelectList(metadata, value);

            // Assert
            Assert.Equal(expected, SelectListToString(selectList));
        }

        [Fact]
        public void GetSelectListWithTypeThrowsArgumentNull()
        {
            // Arrange & Act & Assert
            Assert.ThrowsArgumentNull(() => EnumHelper.GetSelectList((Type)null), "type");
        }

        [Fact]
        public void GetSelectListWithMetadataThrowsArgumentNull()
        {
            // Arrange & Act & Assert
            Assert.ThrowsArgumentNull(() => EnumHelper.GetSelectList((ModelMetadata)null), "metadata");
        }

        [Fact]
        public void GetSelectListWithTypeAndEnumThrowsArgumentNull()
        {
            // Arrange & Act & Assert
            Assert.ThrowsArgumentNull(() => EnumHelper.GetSelectList((Type)null, EnumWithDisplay.Two), "type");
        }

        [Fact]
        public void GetSelectListWithMetadataAndEnumThrowsArgumentNull()
        {
            // Arrange & Act & Assert
            Assert.ThrowsArgumentNull(() => EnumHelper.GetSelectList((ModelMetadata)null, EnumWithDisplay.Two), "metadata");
        }

        public static TheoryDataSet<Type> GetSelectListThrowsArgumentData
        {
            get
            {
                return new TheoryDataSet<Type>
                {
                    { typeof(int) },
                    { typeof(int?) },
                    { typeof(EnumHelperTest) },
                    { typeof(Enum) },
                    { typeof(EnumWithFlags) },
                    { typeof(EnumWithFlags?) },
                };
            }
        }

        [Theory]
        [PropertyData("GetSelectListThrowsArgumentData")]
        public void GetSelectListWithTypeThrowsArgument(Type type)
        {
            // Arrange & Act & Assert
            Assert.ThrowsArgument(() => EnumHelper.GetSelectList(type), "type");
        }

        // No way to run a test with non-null ModelMetadata and null ModelType
        [Theory]
        [PropertyData("GetSelectListThrowsArgumentData")]
        public void GetSelectListWithMetadataThrowsArgument(Type type)
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, type, null);

            // Act & Assert
            Assert.ThrowsArgument(() => EnumHelper.GetSelectList(metadata), "metadata");
        }

        [Theory]
        [PropertyData("GetSelectListThrowsArgumentData")]
        public void GetSelectListWithTypeAndEnumThrowsArgument(Type type)
        {
            // Arrange & Act & Assert
            Assert.ThrowsArgument(() => EnumHelper.GetSelectList(type, EnumWithDisplay.Two), "type");
        }

        // No way to run a test with non-null ModelMetadata and null ModelType
        [Theory]
        [PropertyData("GetSelectListThrowsArgumentData")]
        public void GetSelectListWithMetadataAndEnumThrowsArgument(Type type)
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, type, null);

            // Act & Assert
            Assert.ThrowsArgument(() => EnumHelper.GetSelectList(metadata, EnumWithDisplay.Two), "metadata");
        }

        [Fact]
        public void GetSelectListWithTypeAndEnumThrowsArgumentOnMismatch()
        {
            // Arrange & Act & Assert
            Assert.ThrowsArgument(() => EnumHelper.GetSelectList(typeof(EnumWithDuplicates), EnumWithDisplay.Two),
                paramName: "value",
                exceptionMessage: "Invalid value parameter type " +
                "'System.Web.Mvc.Html.Test.EnumHelperTest+EnumWithDisplay'. Must match type parameter " +
                "'System.Web.Mvc.Html.Test.EnumHelperTest+EnumWithDuplicates'." + Environment.NewLine +
                "Parameter name: value");
        }

        [Fact]
        public void GetSelectListWithMetadataAndEnumThrowsArgumentOnMismatch()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(EnumWithDuplicates), null);

            // Act & Assert
            Assert.ThrowsArgument(() => EnumHelper.GetSelectList(metadata, EnumWithDisplay.Two), paramName: "value",
                exceptionMessage: "Invalid value parameter type " +
                "'System.Web.Mvc.Html.Test.EnumHelperTest+EnumWithDisplay'. Must match type parameter " +
                "'System.Web.Mvc.Html.Test.EnumHelperTest+EnumWithDuplicates'." + Environment.NewLine +
                "Parameter name: value");
        }

        // helpers

        private static string SelectListToString(IList<SelectListItem> selectList)
        {
            return _serializer.Serialize(selectList);
        }

        // enum definitions

        private enum EnumWithDisplay : byte
        {
            [Display(Name="First")]
            Zero,
            [Display(Name = "Second")]
            One,
            [Display(Name = "Third")]
            Two,
            [Display(Name = "Fourth")]
            Three,
        }

        private enum EnumWithoutAnything : byte
        {
        }

        private enum EnumWithoutZero : byte
        {
            First = 12,
            Second,
            Third,
            Fourth,
        }

        private enum EnumWithDuplicates : byte
        {
            First,
            Second,
            Third = 1,
            Fourth,
        }

        private enum EnumWithGaps : byte
        {
            First,
            Second = 2,
            Third = 4,
            Fourth = 6,
        }

        private enum EnumWithReversedValues : byte
        {
            First = 3,
            Second = 2,
            Third = 1,
            Fourth = 0,
        }

        [Flags]
        private enum EnumWithFlags : byte
        {
            First = 1,
            Second = 2,
            Third = 4,
            Fourth = 8,
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/FormExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Web.Routing;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class FormExtensionsTest : IDisposable
    {
        private static void BeginFormHelper(Func<HtmlHelper, MvcForm> beginForm, string expectedFormTag)
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            // Act
            IDisposable formDisposable = beginForm(htmlHelper);
            formDisposable.Dispose();

            // Assert
            Assert.Equal(expectedFormTag + "</form>", writer.ToString());
        }

        [Fact]
        public void BeginFormParameterDictionaryMerging()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", FormMethod.Get, new RouteValueDictionary(new { method = "post" })),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar"" method=""get"">");
        }

        [Fact]
        public void BeginFormSetsAndRestoresToDefault()
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            htmlHelper.ViewContext.FormContext = null;
            FormContext defaultFormContext = htmlHelper.ViewContext.FormContext;

            // Act & assert - push
            MvcForm theForm = htmlHelper.BeginForm();
            Assert.NotNull(htmlHelper.ViewContext.FormContext);
            Assert.NotEqual(defaultFormContext, htmlHelper.ViewContext.FormContext);

            // Act & assert - pop
            theForm.Dispose();
            Assert.Equal(defaultFormContext, htmlHelper.ViewContext.FormContext);
            Assert.Equal(@"<form action=""/some/path"" method=""post""></form>", writer.ToString());
        }

        [Fact]
        public void BeginFormWithClientValidationEnabled()
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            htmlHelper.ViewContext.ClientValidationEnabled = true;
            htmlHelper.ViewContext.FormContext = null;
            FormContext defaultFormContext = htmlHelper.ViewContext.FormContext;

            // Act & assert - push
            MvcForm theForm = htmlHelper.BeginForm();
            Assert.NotNull(htmlHelper.ViewContext.FormContext);
            Assert.NotEqual(defaultFormContext, htmlHelper.ViewContext.FormContext);
            Assert.Equal("form_id", htmlHelper.ViewContext.FormContext.FormId);

            // Act & assert - pop
            theForm.Dispose();
            Assert.Equal(defaultFormContext, htmlHelper.ViewContext.FormContext);
            Assert.Equal(@"<form action=""/some/path"" id=""form_id"" method=""post""></form><script type=""text/javascript"">
//<![CDATA[
if (!window.mvcClientValidationMetadata) { window.mvcClientValidationMetadata = []; }
window.mvcClientValidationMetadata.push({""Fields"":[],""FormId"":""form_id"",""ReplaceValidationSummary"":false});
//]]>
</script>", writer.ToString());
        }

        [Fact]
        public void BeginFormWithClientValidationAndUnobtrusiveJavaScriptEnabled()
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            htmlHelper.ViewContext.ClientValidationEnabled = true;
            htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled = true;

            // Act & assert - push
            MvcForm theForm = htmlHelper.BeginForm();
            Assert.Null(htmlHelper.ViewContext.FormContext.FormId);

            // Act & assert - pop
            theForm.Dispose();
            Assert.Equal(@"<form action=""/some/path"" method=""post""></form>", writer.ToString());
        }

        [Fact]
        public void BeginFormWithActionControllerInvalidFormMethodHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", (FormMethod)2, new RouteValueDictionary(new { baz = "baz" })),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar"" baz=""baz"" method=""post"">");
        }

        [Fact]
        public void BeginFormWithActionController()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo"),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar"" method=""post"">");
        }

        [Theory]
        [PropertyData("UrlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void BeginFormWithActionController_UrlEncodesAction(
            string text,
            string expectedText)
        {
            BeginFormHelper(
                helper => helper.BeginForm(text, "controller"),
                @"<form action=""" + MvcHelper.AppPathModifier + "/controller/" + expectedText + @""" method=""post"">");
        }

        [Theory]
        [PropertyData("UrlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void BeginFormWithActionController_UrlEncodesController(
            string text,
            string expectedText)
        {
            BeginFormHelper(
                helper => helper.BeginForm("action", text),
                @"<form action=""" + MvcHelper.AppPathModifier + "/" + expectedText + @"/action"" method=""post"">");
        }

        [Fact]
        public void BeginFormWithActionControllerFormMethodHtmlDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", FormMethod.Get, new RouteValueDictionary(new { baz = "baz" })),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar"" baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerFormMethodHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", FormMethod.Get, new { baz = "baz" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar"" baz=""baz"" method=""get"">");
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void BeginFormWithActionControllerFormMethodHtmlValues_AttributeEncodes_AddedHtmlAttributes(
            string text,
            string expectedText)
        {
            BeginFormHelper(
                helper => helper.BeginForm("action", "controller", FormMethod.Get, new { attribute = text }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/controller/action"" attribute=""" +
                    expectedText +
                    @""" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerFormMethodHtmlValuesWithUnderscores()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", FormMethod.Get, new { data_test = "value" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar"" data-test=""value"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerRouteDictionaryFormMethodHtmlDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", new RouteValueDictionary(new { id = "id" }), FormMethod.Get, new RouteValueDictionary(new { baz = "baz" })),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar/id"" baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerRouteValuesFormMethodHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", new { id = "id" }, FormMethod.Get, new { baz = "baz" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar/id"" baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerRouteValuesFormMethodHtmlValuesWithUnderscores()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", new { id = "id" }, FormMethod.Get, new { foo_baz = "baz" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar/id"" foo-baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerNullRouteValuesFormMethodNullHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("bar", "foo", null, FormMethod.Get, null),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/foo/bar"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithRouteValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm(new { action = "someOtherAction", id = "id" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/home/someOtherAction/id"" method=""post"">");
        }

        [Fact]
        public void BeginFormWithRouteDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm(new RouteValueDictionary { { "action", "someOtherAction" }, { "id", "id" } }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/home/someOtherAction/id"" method=""post"">");
        }

        [Fact]
        public void BeginFormWithActionControllerRouteValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("myAction", "myController", new { id = "id", pageNum = "123" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/myController/myAction/id?pageNum=123"" method=""post"">");
        }

        [Fact]
        public void BeginFormWithActionControllerRouteDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("myAction", "myController", new RouteValueDictionary { { "pageNum", "123" }, { "id", "id" } }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/myController/myAction/id?pageNum=123"" method=""post"">");
        }

        [Fact]
        public void BeginFormWithActionControllerMethod()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("myAction", "myController", FormMethod.Get),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/myController/myAction"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerRouteValuesMethod()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("myAction", "myController", new { id = "id", pageNum = "123" }, FormMethod.Get),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/myController/myAction/id?pageNum=123"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithActionControllerRouteDictionaryMethod()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm("myAction", "myController", new RouteValueDictionary { { "pageNum", "123" }, { "id", "id" } }, FormMethod.Get),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/myController/myAction/id?pageNum=123"" method=""get"">");
        }

        [Fact]
        public void BeginFormWithNoParams()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginForm(),
                @"<form action=""/some/path"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameInvalidFormMethodHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", (FormMethod)2, new RouteValueDictionary(new { baz = "baz" })),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" baz=""baz"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteName()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute"),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameFormMethodHtmlDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", FormMethod.Get, new RouteValueDictionary(new { baz = "baz" })),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameFormMethodHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", FormMethod.Get, new { baz = "baz" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" baz=""baz"" method=""get"">");
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void BeginRouteFormWithRouteNameFormMethodHtmlValues_AttributeEncodes_AddedHtmlAttributes(
            string text,
            string expectedText)
        {
            BeginFormHelper(
                helper => helper.BeginRouteForm("namedroute", FormMethod.Get, new { attribute = text }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" attribute=""" +
                    expectedText +
                    @""" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameFormMethodHtmlValuesWithUnderscores()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", FormMethod.Get, new { foo_baz = "baz" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" foo-baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameRouteDictionaryFormMethodHtmlDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", new RouteValueDictionary(new { id = "id" }), FormMethod.Get, new RouteValueDictionary(new { baz = "baz" })),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction/id"" baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameRouteValuesFormMethodHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", new { id = "id" }, FormMethod.Get, new { baz = "baz" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction/id"" baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameRouteValuesFormMethodHtmlValuesWithUnderscores()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", new { id = "id" }, FormMethod.Get, new { foo_baz = "baz" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction/id"" foo-baz=""baz"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameNullRouteValuesFormMethodNullHtmlValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", null, FormMethod.Get, null),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm(new { action = "someOtherAction", id = "id" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/home/someOtherAction/id"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm(new RouteValueDictionary { { "action", "someOtherAction" }, { "id", "id" } }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/home/someOtherAction/id"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormWithRouteNameRouteValues()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", new { id = "id", pageNum = "123" }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction/id?pageNum=123"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormWithActionControllerRouteDictionary()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", new RouteValueDictionary { { "pageNum", "123" }, { "id", "id" } }),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction/id?pageNum=123"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormCanUseNamedRouteWithoutSpecifyingDefaults()
        {
            // DevDiv 217072: Non-mvc specific helpers should not give default values for controller and action

            BeginFormHelper(
                htmlHelper =>
                {
                    htmlHelper.RouteCollection.MapRoute("MyRouteName", "any/url", new { controller = "Charlie" });
                    return htmlHelper.BeginRouteForm("MyRouteName");
                }, @"<form action=""" + MvcHelper.AppPathModifier + @"/any/url"" method=""post"">");
        }

        [Fact]
        public void BeginRouteFormWithActionControllerMethod()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", FormMethod.Get),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithActionControllerRouteValuesMethod()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", new { id = "id", pageNum = "123" }, FormMethod.Get),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction/id?pageNum=123"" method=""get"">");
        }

        [Fact]
        public void BeginRouteFormWithActionControllerRouteDictionaryMethod()
        {
            BeginFormHelper(
                htmlHelper => htmlHelper.BeginRouteForm("namedroute", new RouteValueDictionary { { "pageNum", "123" }, { "id", "id" } }, FormMethod.Get),
                @"<form action=""" + MvcHelper.AppPathModifier + @"/named/home/oldaction/id?pageNum=123"" method=""get"">");
        }

        [Fact]
        public void EndFormWritesCloseTag()
        {
            // Arrange
            StringWriter writer;
            HtmlHelper htmlHelper = GetFormHelper(out writer);

            // Act
            htmlHelper.EndForm();

            // Assert
            Assert.Equal("</form>", writer.ToString());
        }

        private static HtmlHelper GetFormHelper(out StringWriter writer)
        {
            Mock<ViewContext> mockViewContext = new Mock<ViewContext>() { CallBase = true };
            mockViewContext.Setup(c => c.HttpContext.Request.Url).Returns(new Uri("http://www.contoso.com/some/path"));
            mockViewContext.Setup(c => c.HttpContext.Request.RawUrl).Returns("/some/path");
            mockViewContext.Setup(c => c.HttpContext.Request.ApplicationPath).Returns("/");
            mockViewContext.Setup(c => c.HttpContext.Request.Path).Returns("/");
            mockViewContext.Setup(c => c.HttpContext.Request.ServerVariables).Returns((NameValueCollection)null);
            mockViewContext.Setup(c => c.HttpContext.Response.Write(It.IsAny<string>())).Throws(new Exception("Should not be called"));
            mockViewContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            mockViewContext.Setup(c => c.HttpContext.GetService(It.IsAny<Type>())).Returns(null);

            writer = new StringWriter();
            mockViewContext.Setup(c => c.Writer).Returns(writer);

            mockViewContext.Setup(c => c.HttpContext.Response.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(r => MvcHelper.AppPathModifier + r);

            RouteCollection rt = new RouteCollection();
            rt.Add(new Route("{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            RouteData rd = new RouteData();
            rd.Values.Add("controller", "home");
            rd.Values.Add("action", "oldaction");

            mockViewContext.Setup(c => c.RouteData).Returns(rd);
            HtmlHelper helper = new HtmlHelper(mockViewContext.Object, new Mock<IViewDataContainer>().Object, rt);
            helper.ViewContext.FormIdGenerator = () => "form_id";
            return helper;
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ViewContext.ClientValidationEnabled) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/InputExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Data.Linq;
using System.Linq.Expressions;
using System.Web.Mvc.Test;
using System.Web.Routing;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class InputExtensionsTest : IDisposable
    {
        // CheckBox

        [Fact]
        public void CheckBoxDictionaryOverridesImplicitParameters()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBox("baz", new { @checked = "checked", value = "false" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""baz"" name=""baz"" type=""checkbox"" value=""false"" />" +
                         @"<input name=""baz"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxExplicitParametersOverrideDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.CheckBox("foo", true /* isChecked */, new { @checked = "unchecked", value = "false" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" value=""false"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxShouldNotCopyAttributesForHidden()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.CheckBox("foo", true /* isChecked */, new { id = "myID" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""myID"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.CheckBox(String.Empty); },
                "name");
        }

        [Fact]
        public void CheckBoxWithInvalidBooleanThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act & Assert
            Assert.Throws<FormatException>(
                delegate { helper.CheckBox("bar"); },
                "String was not recognized as a valid Boolean.");
        }

        [Fact]
        public void CheckBoxCheckedWithOnlyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.CheckBox("foo", true /* isChecked */);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxShouldRespectModelStateAttemptedValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());
            helper.ViewData.ModelState.SetModelValue("foo", HtmlHelperTest.GetValueProviderResult("false", "false"));

            // Act
            MvcHtmlString html = helper.CheckBox("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithOnlyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBox("foo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithOnlyName_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.CheckBox("foo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithNameAndObjectAttribute()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBox("foo", _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithNameAndObjectAttributeWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBox("foo", _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input checked=""checked"" foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithObjectAttribute()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.CheckBox("foo", false /* isChecked */, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithObjectAttributeWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.CheckBox("foo", false /* isChecked */, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithAttributeDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.CheckBox("foo", false /* isChecked */, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.CheckBox("foo", false /* isChecked */, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""MyPrefix.foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.CheckBox("", false /* isChecked */, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""MyPrefix"" name=""MyPrefix"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""MyPrefix"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void CheckBox_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.CheckBox(name: "name", htmlAttributes: new { attribute = text, }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" +
                    encodedText +
                    @""" id=""name"" name=""name"" type=""checkbox"" value=""true"" />" +
                @"<input name=""name"" type=""hidden"" value=""false"" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void CheckBox_AttributeEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.CheckBox(text, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""id"" name=""" + encodedText + @""" type=""checkbox"" value=""true"" />" +
                @"<input name=""" + encodedText + @""" type=""hidden"" value=""false"" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void CheckBox_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.CheckBox(name: String.Empty, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""id"" name=""" + encodedText + @""" type=""checkbox"" value=""true"" />" +
                @"<input name=""" + encodedText + @""" type=""hidden"" value=""false"" />",
                result);
        }

        // No need for CheckBox_AttributeEncodes_Value() because CheckBox value is always true and hidden value
        // is always false.

        // CheckBoxFor

        [Fact]
        public void CheckBoxForWitNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.CheckBoxFor(null),
                "expression");
        }

        [Fact]
        public void CheckBoxForWithInvalidBooleanThrows()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act & Assert
            Assert.Throws<FormatException>(
                () => helper.CheckBoxFor(m => m.bar), // "bar" in ViewData isn't a valid boolean
                "String was not recognized as a valid Boolean.");
        }

        [Fact]
        public void CheckBoxForDictionaryOverridesImplicitParameters()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.baz, new { @checked = "checked", value = "false" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""baz"" name=""baz"" type=""checkbox"" value=""false"" />" +
                         @"<input name=""baz"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForShouldNotCopyAttributesForHidden()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo, new { id = "myID" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""myID"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForCheckedWithOnlyName()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForCheckedWithOnlyName_Unobtrusive()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input checked=""checked"" data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForShouldRespectModelStateAttemptedValue()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());
            helper.ViewContext.ViewData.ModelState.SetModelValue("foo", HtmlHelperTest.GetValueProviderResult("false", "false"));

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForWithObjectAttribute()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForWithObjectAttributeWithUnderscores()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input checked=""checked"" foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForWithAttributeDictionary()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxForWithPrefix()
        {
            // Arrange
            HtmlHelper<FooBarBazModel> helper = MvcHelper.GetHtmlHelper(GetCheckBoxViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.CheckBoxFor(m => m.foo, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""checkbox"" value=""true"" />" +
                         @"<input name=""MyPrefix.foo"" type=""hidden"" value=""false"" />",
                         html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void CheckBoxFor_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);
            var dummy = false;

            // Act
            var result = helper.CheckBoxFor(m => dummy, htmlAttributes: new { attribute = text, }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" +
                    encodedText +
                    @""" id=""dummy"" name=""dummy"" type=""checkbox"" value=""true"" />" +
                @"<input name=""dummy"" type=""hidden"" value=""false"" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void CheckBoxFor_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);
            var dummy = false;

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.CheckBoxFor(m => dummy, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""id"" name=""" + encodedText + @".dummy"" type=""checkbox"" value=""true"" />" +
                @"<input name=""" + encodedText + @".dummy"" type=""hidden"" value=""false"" />",
                result);
        }

        // No need for CheckBoxFor_AttributeEncodes_Value() because CheckBox value is always true and hidden value
        // is always false.

        // Culture tests

        [Fact]
        [ReplaceCulture]
        public void InputHelpersUseCurrentCultureToConvertValueParameter()
        {
            // Arrange
            DateTime dt = new DateTime(1900, 1, 1, 0, 0, 0);
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary { { "foo", dt } });

            var tests = new[]
            {
                // Hidden(name)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""hidden"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.Hidden("foo"))
                },
                // Hidden(name, value)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""hidden"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.Hidden("foo", dt))
                },
                // Hidden(name, value, htmlAttributes)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""hidden"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.Hidden("foo", dt, null))
                },
                // Hidden(name, value, htmlAttributes)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""hidden"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.Hidden("foo", dt, new RouteValueDictionary()))
                },
                // RadioButton(name, value)
                new
                {
                    Html = @"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.RadioButton("foo", dt))
                },
                // RadioButton(name, value, isChecked)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""radio"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.RadioButton("foo", dt, false))
                },
                // RadioButton(name, value, htmlAttributes)
                new
                {
                    Html = @"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.RadioButton("foo", dt, null))
                },
                // RadioButton(name, value)
                new
                {
                    Html = @"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.RadioButton("foo", dt, new RouteValueDictionary()))
                },
                // RadioButton(name, value, isChecked, htmlAttributes)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""radio"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.RadioButton("foo", dt, false, null))
                },
                // RadioButton(name, value, isChecked, htmlAttributes)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""radio"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.RadioButton("foo", dt, false, new RouteValueDictionary()))
                },
                // TextBox(name)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""text"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("foo"))
                },
                // TextBox(name, value)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""text"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("foo", dt))
                },
                // TextBox(name, value, hmtlAttributes)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""text"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("foo", dt, (object)null))
                },
                // TextBox(name, value, hmtlAttributes)
                new
                {
                    Html = @"<input id=""foo"" name=""foo"" type=""text"" value=""01/01/1900 00:00:00"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("foo", dt, new RouteValueDictionary()))
                }
            };

            // Act && Assert
            foreach (var test in tests)
            {
                Assert.Equal(test.Html, test.Action().ToHtmlString());
            }
        }

        // Hidden

        [Fact]
        public void HiddenWithByteArrayValueRendersBase64EncodedValue()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString result = htmlHelper.Hidden("ProductName", ByteArrayModelBinderTest.Base64TestBytes);

            // Assert
            Assert.Equal("<input id=\"ProductName\" name=\"ProductName\" type=\"hidden\" value=\"Fys1\" />", result.ToHtmlString());
        }

        [Fact]
        public void HiddenWithBinaryArrayValueRendersBase64EncodedValue()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString result = htmlHelper.Hidden("ProductName", new Binary(new byte[] { 23, 43, 53 }));

            // Assert
            Assert.Equal("<input id=\"ProductName\" name=\"ProductName\" type=\"hidden\" value=\"Fys1\" />", result.ToHtmlString());
        }

        [Fact]
        public void HiddenWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.Hidden(String.Empty); },
                "name");
        }

        [Fact]
        public void HiddenWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", "DefaultFoo", null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", "DefaultFoo", _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", "DefaultFoo", _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitValueAndAttributesObjectWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", "DefaultFoo", _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitValueNull()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", (string)null /* value */, (object)null /* htmlAttributes */);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithImplicitValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithImplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""hidden"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithImplicitValueAndAttributesDictionaryReturnsEmptyValueIfNotFound()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("keyNotFound", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""keyNotFound"" name=""keyNotFound"" type=""hidden"" value="""" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithImplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", null, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""hidden"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithNameAndValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Hidden("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.Hidden("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""hidden"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.Hidden("", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix"" name=""MyPrefix"" type=""hidden"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithNullNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.Hidden(null /* name */); },
                "name");
        }

        [Fact]
        public void HiddenWithViewDataErrors()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.Hidden("foo", null, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" class=""input-validation-error"" id=""foo"" name=""foo"" type=""hidden"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithViewDataErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.Hidden("foo", null, new { @class = "foo-class" });

            // Assert
            Assert.Equal(@"<input class=""input-validation-error foo-class"" id=""foo"" name=""foo"" type=""hidden"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Hidden_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.Hidden(name: "name", value: null, htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""hidden"" value="""" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Hidden_AttributeEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.Hidden(text, value: null, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""hidden"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Hidden_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.Hidden(name: String.Empty, value: null, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""hidden"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Hidden_AttributeEncodes_Value(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.Hidden("name", value: text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""name"" name=""name"" type=""hidden"" value=""" + encodedText + @""" />",
                result);
        }

        // HiddenFor

        [Fact]
        public void HiddenForWithNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.HiddenFor<HiddenModel, object>(null),
                "expression"
                );
        }

        [Fact]
        public void HiddenForWithStringValue()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewData.Model.foo = "DefaultFoo";

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithByteArrayValueRendersBase64EncodedValue()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewData.Model.bytes = ByteArrayModelBinderTest.Base64TestBytes;

            // Act
            MvcHtmlString result = helper.HiddenFor(m => m.bytes);

            // Assert
            Assert.Equal("<input id=\"bytes\" name=\"bytes\" type=\"hidden\" value=\"Fys1\" />", result.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithBinaryValueRendersBase64EncodedValue()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewData.Model.binary = new Binary(new byte[] { 23, 43, 53 });

            // Act
            MvcHtmlString result = helper.HiddenFor(m => m.binary);

            // Assert
            Assert.Equal("<input id=\"binary\" name=\"binary\" type=\"hidden\" value=\"Fys1\" />", result.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithAttributesDictionary()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewData.Model.foo = "DefaultFoo";

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m.foo, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithAttributesObject()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewData.Model.foo = "DefaultFoo";

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m.foo, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithAttributesObjectWithUnderscores()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewData.Model.foo = "DefaultFoo";

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m.foo, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithPrefix()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewData.Model.foo = "fooValue";
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""hidden"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m);

            // Assert
            Assert.Equal(@"<input id=""MyPrefix"" name=""MyPrefix"" type=""hidden"" value=""{ foo = (null) }"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithViewDataErrors()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m.foo, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" class=""input-validation-error"" id=""foo"" name=""foo"" type=""hidden"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenForWithViewDataErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper<HiddenModel> helper = MvcHelper.GetHtmlHelper(GetHiddenViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.HiddenFor(m => m.foo, new { @class = "foo-class" });

            // Assert
            Assert.Equal(@"<input class=""input-validation-error foo-class"" id=""foo"" name=""foo"" type=""hidden"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void HiddenFor_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "name";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.HiddenFor(m => m, htmlAttributes: new { attribute = text, }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""hidden"" value="""" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void HiddenFor_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.HiddenFor(m => m, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""hidden"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void HiddenFor_AttributeEncodes_Value(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.HiddenFor(m => text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""text"" name=""text"" type=""hidden"" value=""" + encodedText + @""" />",
                result);
        }

        // Password

        [Fact]
        public void PasswordWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.Password(String.Empty); },
                "name");
        }

        [Fact]
        public void PasswordDictionaryOverridesImplicitParameters()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", "Some Value", new { type = "fooType" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""fooType"" value=""Some Value"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordExplicitParametersOverrideDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", "Some Value", new { value = "Another Value", name = "bar" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" value=""Some Value"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", "DefaultFoo", (object)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValue_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.Password("foo", "DefaultFoo", (object)null);

            // Assert
            Assert.Equal(@"<input data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""password"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", "DefaultFoo", _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""password"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", "DefaultFoo", _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""password"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValueNull()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", (string)null /* value */, (object)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValueAndAttributesDictionaryReturnsEmptyValueIfNotFound()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("keyNotFound", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""keyNotFound"" name=""keyNotFound"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", null, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValueAndAttributesObjectWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", null, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithNameAndValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.Password("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.Password("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""password"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.Password("", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix"" name=""MyPrefix"" type=""password"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithNullNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.Password(null /* name */); },
                "name");
        }

        [Fact]
        public void PasswordWithViewDataErrors()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.Password("foo", null, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" class=""input-validation-error"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithViewDataErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetPasswordViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.Password("foo", null, new { @class = "foo-class" });

            // Assert
            Assert.Equal(@"<input class=""input-validation-error foo-class"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Password_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.Password(name: "name", value: null, htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""password"" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Password_AttributeEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.Password(text, value: null, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""password"" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Password_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.Password(name: String.Empty, value: null, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""password"" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void Password_AttributeEncodes_Value(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.Password("name", value: text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""name"" name=""name"" type=""password"" value=""" + encodedText + @""" />",
                result);
        }

        // PasswordFor

        [Fact]
        public void PasswordForWithNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.PasswordFor<FooModel, object>(null),
                "expression");
        }

        [Fact]
        public void PasswordForDictionaryOverridesImplicitParameters()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo, new { type = "fooType" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""fooType"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForExpressionNameOverridesDictionary()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo, new { name = "bar" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithImplicitValue()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithImplicitValue_Unobtrusive()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithDeepValueWithNullModel_Unobtrusive()
        { // Dev10 Bug #936192
            // Arrange
            HtmlHelper<DeepContainerModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<DeepContainerModel>());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();

            using (new CultureReplacer("en-US", "en-US"))
            {
                // Act
                MvcHtmlString html = helper.PasswordFor(m => m.contained.foo);

                // Assert
                Assert.Equal(@"<input data-val=""true"" data-val-required=""The foo field is required."" id=""contained_foo"" name=""contained.foo"" type=""password"" />", html.ToHtmlString());
            }
        }

        [Fact]
        public void PasswordForWithAttributesDictionary()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithAttributesObject()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithAttributesObjectWithUnderscores()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithPrefix()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithViewDataErrors()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" class=""input-validation-error"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordForWithViewDataErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(GetPasswordViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.PasswordFor(m => m.foo, new { @class = "foo-class" });

            // Assert
            Assert.Equal(@"<input class=""input-validation-error foo-class"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void PasswordFor_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "name";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.PasswordFor(m => m, htmlAttributes: new { attribute = text, }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""password"" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void PasswordFor_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.PasswordFor(m => m, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""password"" />", result);
        }

        // No need for PasswordFor_AttributeEncodes_Value() because PasswordFor() always uses a null value.

        // RadioButton

        [Fact]
        public void RadioButtonDictionaryOverridesImplicitParameters()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("bar", "ViewDataBar", new { @checked = "chucked", value = "baz" });

            // Assert
            Assert.Equal(@"<input checked=""chucked"" id=""bar"" name=""bar"" type=""radio"" value=""ViewDataBar"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonExplicitParametersOverrideDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("bar", "ViewDataBar", false, new { @checked = "checked", value = "baz" });

            // Assert
            Assert.Equal(@"<input id=""bar"" name=""bar"" type=""radio"" value=""ViewDataBar"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonShouldRespectModelStateAttemptedValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());
            helper.ViewData.ModelState.SetModelValue("foo", HtmlHelperTest.GetValueProviderResult("ModelStateFoo", "ModelStateFoo"));

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "ModelStateFoo", false, new { @checked = "checked", value = "baz" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""ModelStateFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonValueParameterAlwaysRendered()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "ViewDataFoo");
            MvcHtmlString html2 = helper.RadioButton("foo", "fooValue2");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""fooValue2"" />", html2.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.RadioButton(String.Empty, "value"); },
                "name");
        }

        [Fact]
        public void RadioButtonWithNullValueThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { helper.RadioButton("foo", null); },
                "value");
        }

        [Fact]
        public void RadioButtonWithNameAndValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "ViewDataFoo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithNameAndValue_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "ViewDataFoo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "ViewDataFoo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.RadioButton("", "ViewDataFoo");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix"" name=""MyPrefix"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithNameAndValueNotMatched()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithNameValueUnchecked()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("bar", "barValue", false /* isChecked */);

            // Assert
            Assert.Equal(@"<input id=""bar"" name=""bar"" type=""radio"" value=""barValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithNameValueChecked()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("bar", "barValue", true /* isChecked */);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""bar"" name=""bar"" type=""radio"" value=""barValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithObjectAttribute()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "fooValue", _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""radio"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithObjectAttributeWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "fooValue", _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""radio"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithAttributeDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("bar", "barValue", _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""bar"" name=""bar"" type=""radio"" value=""barValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithValueUnchecked()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "bar", false /* isChecked */);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""bar"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithValueAndObjectAttributeUnchecked()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "bar", false /* isChecked */, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithValueAndObjectAttributeWithUnderscoresUnchecked()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "bar", false /* isChecked */, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithValueAndAttributeDictionaryUnchecked()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButton("foo", "bar", false /* isChecked */, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void RadioButton_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.RadioButton(name: "name", value: "value", htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""radio"" value=""value"" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void RadioButton_AttributeEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.RadioButton(text, value: "value", htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""radio"" value=""value"" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void RadioButton_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.RadioButton(name: String.Empty, value: String.Empty, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""radio"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void RadioButton_AttributeEncodes_Value(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.RadioButton("name", value: text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""name"" name=""name"" type=""radio"" value=""" + encodedText + @""" />",
                result);
        }

        // RadioButtonFor

        [Fact]
        public void RadioButtonForWithNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.RadioButtonFor<FooBarModel, object>(null, "value"),
                "expression");
        }

        [Fact]
        public void RadioButtonForWithNullValueThrows()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.RadioButtonFor(m => m.foo, null),
                "value");
        }

        [Fact]
        public void RadioButtonForDictionaryOverridesImplicitParameters()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.bar, "ViewDataBar", new { @checked = "chucked", value = "baz" });

            // Assert
            Assert.Equal(@"<input checked=""chucked"" id=""bar"" name=""bar"" type=""radio"" value=""ViewDataBar"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForShouldRespectModelStateAttemptedValue()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());
            helper.ViewData.ModelState.SetModelValue("foo", HtmlHelperTest.GetValueProviderResult("ModelStateFoo", "ModelStateFoo"));

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.foo, "ModelStateFoo", new { @checked = "checked", value = "baz" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""ModelStateFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForValueParameterAlwaysRendered()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act & Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""ViewDataFoo"" />",
                         helper.RadioButtonFor(m => m.foo, "ViewDataFoo").ToHtmlString());
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""fooValue2"" />",
                         helper.RadioButtonFor(m => m.foo, "fooValue2").ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithNameAndValue()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.foo, "ViewDataFoo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithNestedNameAndValue()
        {
            // Arrange
            HtmlHelper<string> helper = MvcHelper.GetHtmlHelper(GetRadioButtonNestedAndUnsetViewData());

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m, "ViewItemFoo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""ViewItemFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithNameAndValue_Unobtrusive()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.foo, "ViewDataFoo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithPrefix()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.foo, "ViewDataFoo");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""radio"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithNameAndValueNotMatched()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.foo, "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithObjectAttribute()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.foo, "fooValue", _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""radio"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithObjectAttributeWithUnderscores()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.foo, "fooValue", _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""radio"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonForWithAttributeDictionary()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetRadioButtonViewData());

            // Act
            MvcHtmlString html = helper.RadioButtonFor(m => m.bar, "barValue", _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""bar"" name=""bar"" type=""radio"" value=""barValue"" />", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void RadioButtonFor_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "name";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.RadioButtonFor(m => m, value: String.Empty, htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""radio"" value="""" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void RadioButtonFor_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.RadioButtonFor(m => m, value: String.Empty, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""radio"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void RadioButtonFor_AttributeEncodes_Value(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "name";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.RadioButtonFor(m => m, value: text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""name"" name=""name"" type=""radio"" value=""" + encodedText + @""" />",
                result);
        }

        // TextBox

        [Fact]
        public void TextBoxDictionaryOverridesImplicitValues()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", "DefaultFoo", new { type = "fooType" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""fooType"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxExplicitParametersOverrideDictionaryValues()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", "DefaultFoo", new { value = "Some other value" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithDotReplacementForId()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo.bar.baz", null);

            // Assert
            Assert.Equal(@"<input id=""foo_bar_baz"" name=""foo.bar.baz"" type=""text"" value="""" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.TextBox(String.Empty); },
                "name");
        }

        [Fact]
        public void TextBoxWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", "DefaultFoo", (object)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithExplicitValue_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.TextBox("foo", "DefaultFoo", (object)null);

            // Assert
            Assert.Equal(@"<input data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithExplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", "DefaultFoo", _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithExplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", "DefaultFoo", _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithExplicitValueNull()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", (string)null /* value */, (object)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""text"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValueAndAttributesDictionaryReturnsEmptyValueIfNotFound()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("keyNotFound", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""keyNotFound"" name=""keyNotFound"" type=""text"" value="""" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", null, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""text"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValueAndAttributesObjectWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", null, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""text"" value=""ViewDataFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithNullNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.TextBox(null /* name */); },
                "name");
        }

        [Fact]
        public void TextBoxWithNameAndValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());

            // Act
            MvcHtmlString html = helper.TextBox("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextBox("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""text"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetHiddenViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextBox("", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""MyPrefix"" name=""MyPrefix"" type=""text"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithViewDataErrors()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextBox("foo", null, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" class=""input-validation-error"" id=""foo"" name=""foo"" type=""text"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithViewDataErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextBoxViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextBox("foo", null, new { @class = "foo-class" });

            // Assert
            Assert.Equal(@"<input class=""input-validation-error foo-class"" id=""foo"" name=""foo"" type=""text"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBox_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextBox(name: "name", value: null, htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""text"" value="""" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBox_AttributeEncodes_Format(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextBox("name", value: String.Empty, format: text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""name"" name=""name"" type=""text"" value=""" + encodedText + @""" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBox_AttributeEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.TextBox(text, value: null, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""text"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBox_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.TextBox(name: String.Empty, value: null, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""text"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBox_AttributeEncodes_Value(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextBox("name", value: text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""name"" name=""name"" type=""text"" value=""" + encodedText + @""" />",
                result);
        }

        // TextBoxFor

        [Fact]
        public void TextBoxForWithNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.TextBoxFor<FooBarModel, object>(null /* expression */),
                "expression"
                );
        }

        [Fact]
        public void TextBoxForWithSimpleExpression()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""ViewItemFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithSimpleExpression_Unobtrusive()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input data-val=""true"" data-val-type=""error"" id=""foo"" name=""foo"" type=""text"" value=""ViewItemFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithAttributesDictionary()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""text"" value=""ViewItemFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithAttributesObject()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" id=""foo"" name=""foo"" type=""text"" value=""ViewItemFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithAttributesObjectWithUnderscores()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo, _attributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(@"<input foo-baz=""BazObjValue"" id=""foo"" name=""foo"" type=""text"" value=""ViewItemFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithPrefix()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo);

            // Assert
            Assert.Equal(@"<input id=""MyPrefix_foo"" name=""MyPrefix.foo"" type=""text"" value=""ViewItemFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m);

            // Assert
            Assert.Equal(@"<input id=""MyPrefix"" name=""MyPrefix"" type=""text"" value=""{ foo = ViewItemFoo, bar = ViewItemBar }"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithErrors()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo, _attributesObjectDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazObjValue"" class=""input-validation-error"" id=""foo"" name=""foo"" type=""text"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxForWithErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetTextBoxViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextBoxFor(m => m.foo, new { @class = "foo-class" });

            // Assert
            Assert.Equal(@"<input class=""input-validation-error foo-class"" id=""foo"" name=""foo"" type=""text"" value=""AttemptedValueFoo"" />", html.ToHtmlString());
        }

        [Fact]
        [ReplaceCulture]
        public void TextBoxHelpersFormatValue()
        {
            // Arrange
            DateTime dt = new DateTime(1900, 1, 1, 0, 0, 0);
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary { { "viewDataDate", dt } });

            ViewDataDictionary<DateModel> viewData = new ViewDataDictionary<DateModel>() { Model = new DateModel { date = dt } };
            HtmlHelper<DateModel> dateModelhelper = MvcHelper.GetHtmlHelper(viewData);

            var tests = new[]
            {
                // TextBox(name, value, format)
                new
                {
                    Html = @"<input id=""viewDataDate"" name=""viewDataDate"" type=""text"" value=""-01/01/1900 00:00:00-"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("viewDataDate", null, "-{0}-"))
                },
                // TextBox(name, value, format)
                new
                {
                    Html = @"<input id=""date"" name=""date"" type=""text"" value=""-01/01/1900 00:00:00-"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("date", dt, "-{0}-"))
                },
                // TextBox(name, value, format, hmtlAttributes)
                new
                {
                    Html = @"<input id=""date"" name=""date"" type=""text"" value=""-01/01/1900 00:00:00-"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("date", dt, "-{0}-", (object)null))
                },
                // TextBox(name, value, format, hmtlAttributes)
                new
                {
                    Html = @"<input id=""date"" name=""date"" type=""text"" value=""-01/01/1900 00:00:00-"" />",
                    Action = new Func<MvcHtmlString>(() => helper.TextBox("date", dt, "-{0}-", new RouteValueDictionary()))
                },
                // TextBoxFor(expression, format)
                new
                {
                    Html = @"<input id=""date"" name=""date"" type=""text"" value=""-01/01/1900 00:00:00-"" />",
                    Action = new Func<MvcHtmlString>(() => dateModelhelper.TextBoxFor(m => m.date, "-{0}-"))
                },
                // TextBoxFor(expression, format, hmtlAttributes)
                new
                {
                    Html = @"<input id=""date"" name=""date"" type=""text"" value=""-01/01/1900 00:00:00-"" />",
                    Action = new Func<MvcHtmlString>(() => dateModelhelper.TextBoxFor(m => m.date, "-{0}-", (object)null))
                },
                // TextBoxFor(expression, format, hmtlAttributes)
                new
                {
                    Html = @"<input id=""date"" name=""date"" type=""text"" value=""-01/01/1900 00:00:00-"" />",
                    Action = new Func<MvcHtmlString>(() => dateModelhelper.TextBoxFor(m => m.date, "-{0}-", new RouteValueDictionary()))
                }
            };

            // Act && Assert
            foreach (var test in tests)
            {
                Assert.Equal(test.Html, test.Action().ToHtmlString());
            }
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBoxFor_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "name";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextBoxFor(m => m, htmlAttributes: new { attribute = text, }).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input attribute=""" + encodedText + @""" id=""name"" name=""name"" type=""text"" value="""" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBoxFor_AttributeEncodes_Format(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: String.Empty);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "name";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextBoxFor(m => m, format: text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""name"" name=""name"" type=""text"" value=""" + encodedText + @""" />",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBoxFor_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.TextBoxFor(m => m, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(@"<input id=""id"" name=""" + encodedText + @""" type=""text"" value="""" />", result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextBoxFor_AttributeEncodes_Value(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextBoxFor(m => text).ToHtmlString();

            // Assert
            Assert.Equal(
                @"<input id=""text"" name=""text"" type=""text"" value=""" + encodedText + @""" />",
                result);
        }

        // MODELS
        private class FooModel
        {
            public string foo { get; set; }

            public override string ToString()
            {
                return String.Format("{{ foo = {0} }}", foo ?? "(null)");
            }
        }

        private class FooBarModel : FooModel
        {
            public string bar { get; set; }

            public override string ToString()
            {
                return String.Format("{{ foo = {0}, bar = {1} }}", foo ?? "(null)", bar ?? "(null)");
            }
        }

        private class FooBarBazModel
        {
            public bool foo { get; set; }
            public bool bar { get; set; }
            public bool baz { get; set; }

            public override string ToString()
            {
                return String.Format("{{ foo = {0}, bar = {1}, baz = {2} }}", foo, bar, baz);
            }
        }

        private class ShallowModel
        {
            [Required]
            public string foo { get; set; }
        }

        private class DeepContainerModel
        {
            public ShallowModel contained { get; set; }
        }

        private class HiddenModel : FooModel
        {
            public byte[] bytes { get; set; }
            public Binary binary { get; set; }
        }

        private class DateModel
        {
            public DateTime date { get; set; }
        }

        // CHECKBOX
        private static ViewDataDictionary<FooBarBazModel> GetCheckBoxViewData()
        {
            ViewDataDictionary<FooBarBazModel> viewData = new ViewDataDictionary<FooBarBazModel> { { "foo", true }, { "bar", "NotTrue" }, { "baz", false } };
            return viewData;
        }

        // HIDDEN
        private static ViewDataDictionary<HiddenModel> GetHiddenViewData()
        {
            return new ViewDataDictionary<HiddenModel>(new HiddenModel()) { { "foo", "ViewDataFoo" } };
        }

        private static ViewDataDictionary<HiddenModel> GetHiddenViewDataWithErrors()
        {
            ViewDataDictionary<HiddenModel> viewData = new ViewDataDictionary<HiddenModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new HiddenModel();
            ModelState modelStateFoo = new ModelState();
            modelStateFoo.Errors.Add(new ModelError("foo error 1"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            viewData.ModelState["foo"] = modelStateFoo;
            modelStateFoo.Value = HtmlHelperTest.GetValueProviderResult("AttemptedValueFoo", "AttemptedValueFoo");

            return viewData;
        }

        // PASSWORD
        private static ViewDataDictionary<FooModel> GetPasswordViewData()
        {
            return new ViewDataDictionary<FooModel> { { "foo", "ViewDataFoo" } };
        }

        private static ViewDataDictionary<FooModel> GetPasswordViewDataWithErrors()
        {
            ViewDataDictionary<FooModel> viewData = new ViewDataDictionary<FooModel> { { "foo", "ViewDataFoo" } };
            ModelState modelStateFoo = new ModelState();
            modelStateFoo.Errors.Add(new ModelError("foo error 1"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            viewData.ModelState["foo"] = modelStateFoo;
            modelStateFoo.Value = HtmlHelperTest.GetValueProviderResult("AttemptedValueFoo", "AttemptedValueFoo");

            return viewData;
        }

        // RADIO
        private static ViewDataDictionary<FooBarModel> GetRadioButtonViewData()
        {
            ViewDataDictionary<FooBarModel> viewData = new ViewDataDictionary<FooBarModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new FooBarModel { foo = "ViewItemFoo", bar = "ViewItemBar" };
            ModelState modelState = new ModelState();
            modelState.Value = HtmlHelperTest.GetValueProviderResult("ViewDataFoo", "ViewDataFoo");
            viewData.ModelState["foo"] = modelState;

            return viewData;
        }

        private static ViewDataDictionary<string> GetRadioButtonNestedAndUnsetViewData()
        {
            ViewDataDictionary<FooBarModel> viewData = new ViewDataDictionary<FooBarModel> { };
            viewData.Model = new FooBarModel { foo = "ViewItemFoo", bar = "ViewItemBar" };


            Expression<Func<FooBarModel, string>> containedExpression = m => m.foo;

            var metadata = ModelMetadata.FromLambdaExpression(containedExpression, viewData);
            var htmlFieldName = ExpressionHelper.GetExpressionText(containedExpression);


            ViewDataDictionary nestedViewData = new ViewDataDictionary(viewData)
            {
                Model = metadata.Model,
                ModelMetadata = metadata,
                TemplateInfo = new TemplateInfo
                {
                    HtmlFieldPrefix = viewData.TemplateInfo.GetFullHtmlFieldName(htmlFieldName),
                }
            };

            return new ViewDataDictionary<string>(nestedViewData);
        }

        // TEXTBOX
        private static readonly RouteValueDictionary _attributesDictionary = new RouteValueDictionary(new { baz = "BazValue" });
        private static readonly object _attributesObjectDictionary = new { baz = "BazObjValue" };
        private static readonly object _attributesObjectUnderscoresDictionary = new { foo_baz = "BazObjValue" };

        private static ViewDataDictionary<FooBarModel> GetTextBoxViewData()
        {
            ViewDataDictionary<FooBarModel> viewData = new ViewDataDictionary<FooBarModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new FooBarModel { foo = "ViewItemFoo", bar = "ViewItemBar" };

            return viewData;
        }

        private static ViewDataDictionary<FooBarModel> GetTextBoxViewDataWithErrors()
        {
            ViewDataDictionary<FooBarModel> viewData = new ViewDataDictionary<FooBarModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new FooBarModel { foo = "ViewItemFoo", bar = "ViewItemBar" };
            ModelState modelStateFoo = new ModelState();
            modelStateFoo.Errors.Add(new ModelError("foo error 1"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            viewData.ModelState["foo"] = modelStateFoo;
            modelStateFoo.Value = HtmlHelperTest.GetValueProviderResult(new string[] { "AttemptedValueFoo" }, "AttemptedValueFoo");

            return viewData;
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ViewContext.ClientValidationEnabled) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/LabelExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    public class LabelExtensionsTest
    {
        Mock<ModelMetadataProvider> metadataProvider;
        Mock<ModelMetadata> metadata;
        ViewDataDictionary viewData;
        Mock<ViewContext> viewContext;
        Mock<IViewDataContainer> viewDataContainer;
        HtmlHelper<object> html;

        public LabelExtensionsTest()
        {
            metadataProvider = new Mock<ModelMetadataProvider>();
            metadata = new Mock<ModelMetadata>(metadataProvider.Object, null, null, typeof(object), null);
            viewData = new ViewDataDictionary();

            viewContext = new Mock<ViewContext>();
            viewContext.Setup(c => c.ViewData).Returns(viewData);

            viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(c => c.ViewData).Returns(viewData);

            html = new HtmlHelper<object>(viewContext.Object, viewDataContainer.Object);

            metadataProvider.Setup(p => p.GetMetadataForProperties(It.IsAny<object>(), It.IsAny<Type>()))
                .Returns(new ModelMetadata[0]);
            metadataProvider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Returns(metadata.Object);
            metadataProvider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Returns(metadata.Object);
        }

        // Label tests

        [Fact]
        public void LabelNullExpressionThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => html.Label(null),
                "expression");
        }

        [Fact]
        public void LabelViewDataNotFound()
        {
            // Act
            MvcHtmlString result = html.Label("PropertyName", null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""PropertyName"">PropertyName</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelViewDataNull()
        {
            // Act
            viewData["PropertyName"] = null;
            MvcHtmlString result = html.Label("PropertyName", null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""PropertyName"">PropertyName</label>", result.ToHtmlString());
        }

        class Model
        {
            public string PropertyName { get; set; }
        }

        [Fact]
        public void LabelViewDataFromPropertyGetsActualPropertyType()
        {
            // Arrange
            Model model = new Model { PropertyName = "propertyValue" };
            HtmlHelper<Model> html = new HtmlHelper<Model>(viewContext.Object, viewDataContainer.Object);
            viewData.Model = model;
            metadataProvider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), typeof(Model), "PropertyName"))
                .Returns(metadata.Object)
                .Verifiable();

            // Act
            html.Label("PropertyName", null, null, metadataProvider.Object);

            // Assert
            metadataProvider.Verify();
        }

        [Fact]
        public void LabelUsesTemplateInfoPrefix()
        {
            // Arrange
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";

            // Act
            MvcHtmlString result = html.Label("PropertyName", null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""Prefix_PropertyName"">PropertyName</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelUsesLabelTextBeforeMetadata()
        {
            // Arrange
            metadata = new Mock<ModelMetadata>(metadataProvider.Object, null, null, typeof(object), "Custom property name from metadata");
            metadataProvider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Returns(metadata.Object);

            //Act
            MvcHtmlString result = html.Label("PropertyName", "Label Text", null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""PropertyName"">Label Text</label>", result.ToHtmlString());
        }

        [Theory]
        [PropertyData("HtmlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void Label_HtmlEncodes_LabelText(string text, string expectedText)
        {
            // Arrange & Act
            var result =
                html.Label("PropertyName", text, htmlAttributes: null, metadataProvider: metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""PropertyName"">" + expectedText + "</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelUsesMetadataForDisplayTextWhenLabelTextIsNull()
        {
            // Arrange
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            // Act
            MvcHtmlString result = html.Label("PropertyName", null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""PropertyName"">Custom display name from metadata</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelUsesMetadataForPropertyNameWhenDisplayNameIsNull()
        {
            // Arrange
            metadata = new Mock<ModelMetadata>(metadataProvider.Object, null, null, typeof(object), "Custom property name from metadata");
            metadataProvider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Returns(metadata.Object);

            // Act
            MvcHtmlString result = html.Label("PropertyName", null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""PropertyName"">Custom property name from metadata</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelEmptyDisplayNameReturnsEmptyLabelText()
        {
            // Arrange
            metadata.Setup(m => m.DisplayName).Returns(String.Empty);

            // Act
            MvcHtmlString result = html.Label("PropertyName", null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(String.Empty, result.ToHtmlString());
        }

        [Fact]
        public void LabelWithAnonymousValues()
        {
            // Act
            MvcHtmlString result = html.Label("PropertyName", null, new { @for = "attrFor" }, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""attrFor"">PropertyName</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelWithAnonymousValuesAndLabelText()
        {
            // Act
            MvcHtmlString result = html.Label("PropertyName", "Label Text", new { @for = "attrFor" }, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""attrFor"">Label Text</label>", result.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void LabelWithAnonymousValues_AttributeEncodes_AddedHtmlAttributes(string text, string expectedText)
        {
            // Arrange & Act
            var result = html.Label("PropertyName", "text", new { attribute = text }, metadataProvider.Object);

            // Assert
            Assert.Equal(
                @"<label attribute=""" + expectedText + @""" for=""PropertyName"">text</label>",
                result.ToHtmlString());
        }

        [Fact]
        public void LabelWithTypedAttributes()
        {
            // Arrange
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "quux", "baz" }
            };

            // Act
            MvcHtmlString result = html.Label("PropertyName", null, htmlAttributes, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label foo=""bar"" for=""PropertyName"" quux=""baz"">PropertyName</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelWithTypedAttributesAndLabelText()
        {
            // Arrange
            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "quux", "baz" }
            };

            // Act
            MvcHtmlString result = html.Label("PropertyName", "Label Text", htmlAttributes, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label foo=""bar"" for=""PropertyName"" quux=""baz"">Label Text</label>", result.ToHtmlString());
        }

        // LabelFor tests

        [Fact]
        public void LabelForNullExpressionThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => html.LabelFor((Expression<Func<Object, Object>>)null),
                "expression");
        }

        [Fact]
        public void LabelForNonMemberExpressionThrows()
        {
            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => html.LabelFor(model => new { foo = "Bar" }, null, null, metadataProvider.Object),
                "Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.");
        }

        [Fact]
        public void LabelForViewDataNotFound()
        {
            // Arrange
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""unknownKey"">unknownKey</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForUsesTemplateInfoPrefix()
        {
            // Arrange
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""Prefix_unknownKey"">unknownKey</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForUsesLabelTextBeforeModelMetadata()
        {
            // Arrange
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");
            string unknownKey = "this is a dummy parameter value";

            //Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, "Label Text", null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""unknownKey"">Label Text</label>", result.ToHtmlString());
        }

        [Theory]
        [PropertyData("HtmlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void LabelFor_HtmlEncodes_LabelText(string text, string expectedText)
        {
            // Arrange
            var dummy = "this is a dummy parameter value";

            // Arrange & Act
            var result =
                html.LabelFor(m => dummy, text, htmlAttributes: null, metadataProvider: metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""dummy"">" + expectedText + "</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForUsesModelMetadata()
        {
            // Arrange
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""unknownKey"">Custom display name from metadata</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForEmptyDisplayNameReturnsEmptyLabelText()
        {
            // Arrange
            metadata.Setup(m => m.DisplayName).Returns(String.Empty);
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(String.Empty, result.ToHtmlString());
        }

        [Fact]
        public void LabelForWithAnonymousValues()
        {
            //Arrange
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, null, new { @for = "attrFor" }, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""attrFor"">unknownKey</label>", result.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void LabeForlWithAnonymousValues_AttributeEncodes_AddedHtmlAttributes(string text, string expectedText)
        {
            // Arrange
            var dummy = "this is a dummy parameter value";

            // Act
            var result =
                html.LabelFor(m => dummy, "text", new { attribute = text }, metadataProvider.Object);

            // Assert
            Assert.Equal(
                @"<label attribute=""" + expectedText + @""" for=""dummy"">text</label>",
                result.ToHtmlString());
        }

        [Fact]
        public void LabelForWithAnonymousValuesAndLabelText()
        {
            //Arrange
            string unknownKey = "this is a dummy parameter value";

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, "Label Text", new { @for = "attrFor" }, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""attrFor"">Label Text</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForWithTypedAttributes()
        {
            //Arrange
            string unknownKey = "this is a dummy parameter value";

            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "quux", "baz" }
            };

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, null, htmlAttributes, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label foo=""bar"" for=""unknownKey"" quux=""baz"">unknownKey</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForWithTypedAttributesAndLabelText()
        {
            //Arrange
            string unknownKey = "this is a dummy parameter value";

            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "quux", "baz" }
            };

            // Act
            MvcHtmlString result = html.LabelFor(model => unknownKey, "Label Text", htmlAttributes, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label foo=""bar"" for=""unknownKey"" quux=""baz"">Label Text</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForWithNestedClass()
        { // Dev10 Bug #936323
            // Arrange
            HtmlHelper<NestedProduct> html = new HtmlHelper<NestedProduct>(viewContext.Object, viewDataContainer.Object);

            // Act
            MvcHtmlString result = html.LabelFor(nested => nested.product.Id, null, null, metadataProvider.Object);

            //Assert
            Assert.Equal(@"<label for=""product_Id"">Id</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForWithArrayExpression()
        { // Dev10 Bug #905780
            // Arrange
            HtmlHelper<Cart> html = new HtmlHelper<Cart>(viewContext.Object, viewDataContainer.Object);

            // Act
            MvcHtmlString result = html.LabelFor(cart => cart.Products[0].Id, null, null, metadataProvider.Object);

            // Assert
            Assert.Equal(@"<label for=""Products_0__Id"">Id</label>", result.ToHtmlString());
        }

        private class Product
        {
            public int Id { get; set; }
        }

        private class Cart
        {
            public Product[] Products { get; set; }
        }

        private class NestedProduct
        {
            public Product product = new Product();
        }

        // LabelForModel tests

        [Fact]
        public void LabelForModelUsesLabelTextBeforeModelMetadata()
        {
            // Arrange
            viewData.ModelMetadata = metadata.Object;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            // Act
            MvcHtmlString result = html.LabelForModel("Label Text");

            // Assert
            Assert.Equal(@"<label for=""Prefix"">Label Text</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForModelUsesModelMetadata()
        {
            // Arrange
            viewData.ModelMetadata = metadata.Object;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            // Act
            MvcHtmlString result = html.LabelForModel();

            // Assert
            Assert.Equal(@"<label for=""Prefix"">Custom display name from metadata</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForModelWithAnonymousValues()
        {
            //Arrange
            viewData.ModelMetadata = metadata.Object;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            // Act
            MvcHtmlString result = html.LabelForModel(new { @for = "attrFor" });

            // Assert
            Assert.Equal(@"<label for=""attrFor"">Custom display name from metadata</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForModelWithAnonymousValuesAndLabelText()
        {
            //Arrange
            viewData.ModelMetadata = metadata.Object;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            // Act
            MvcHtmlString result = html.LabelForModel("Label Text", new { @for = "attrFor" });

            // Assert
            Assert.Equal(@"<label for=""attrFor"">Label Text</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForModelWithTypedAttributes()
        {
            //Arrange
            viewData.ModelMetadata = metadata.Object;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "quux", "baz" }
            };

            // Act
            MvcHtmlString result = html.LabelForModel(htmlAttributes);

            // Assert
            Assert.Equal(@"<label foo=""bar"" for=""Prefix"" quux=""baz"">Custom display name from metadata</label>", result.ToHtmlString());
        }

        [Fact]
        public void LabelForModelWithTypedAttributesAndLabelText()
        {
            //Arrange
            viewData.ModelMetadata = metadata.Object;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            metadata.Setup(m => m.DisplayName).Returns("Custom display name from metadata");

            Dictionary<string, object> htmlAttributes = new Dictionary<string, object>
            {
                { "foo", "bar" },
                { "quux", "baz" }
            };

            // Act
            MvcHtmlString result = html.LabelForModel("Label Text", htmlAttributes);

            // Assert
            Assert.Equal(@"<label foo=""bar"" for=""Prefix"" quux=""baz"">Label Text</label>", result.ToHtmlString());
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/LinkExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    public class LinkExtensionsTest
    {
        private const string AppPathModifier = MvcHelper.AppPathModifier;

        [Fact]
        public void ActionLink()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction");

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/home/newaction"">linktext</a>", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("UrlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void ActionLink_UrlEncodesAction(string text, string expectedText)
        {
            // Arrange
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.ActionLink(linkText: "link", actionName: text);

            // Assert
            Assert.Equal(
                @"<a href=""" + AppPathModifier + @"/app/home/" + expectedText + @""">link</a>",
                result.ToHtmlString());
        }

        [Fact]
        public void ActionLinkDictionaryOverridesImplicitValues()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", null, new { href = "http://foo.com" });

            // Assert
            Assert.Equal(@"<a href=""http://foo.com"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkExplictValuesOverrideDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "explicitAction", new { action = "dictionaryAction" }, null);

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/home/explicitAction"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkParametersNeedEscaping()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext<&>\"", "new action<&>\"");

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/home/new%20action%3C%26%3E%22"">linktext&lt;&amp;&gt;&quot;</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithActionNameAndValueDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", new RouteValueDictionary(new { controller = "home2" }));

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/home2/newaction"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithActionNameAndValueObject()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", new { controller = "home2" });

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/home2/newaction"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithControllerName()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2");

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/home2/newaction"">linktext</a>", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("UrlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void ActionLinkWithControllerName_UrlEncodesController(string text, string expectedText)
        {
            // Arrange
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.ActionLink(linkText: "link", actionName: "newAction", controllerName: text);

            // Assert
            Assert.Equal(
                @"<a href=""" + AppPathModifier + @"/app/" + expectedText + @"/newAction"">link</a>",
                result.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithControllerNameAndDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", new RouteValueDictionary(new { id = "someid" }), new RouteValueDictionary(new { baz = "baz" }));

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithControllerNameAndObjectProperties()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void ActionLinkWithControllerNameAndObjectProperties_AttributeEncodes_AddedHtmlAttributes(
            string text,
            string expectedText)
        {
            // Arrange
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result =
                helper.ActionLink("text", "action", "controller", routeValues: null, htmlAttributes: new { attribute = text });

            // Assert
            Assert.Equal(
                @"<a attribute=""" + expectedText + @""" href=""" + AppPathModifier + @"/app/controller/action"">text</a>",
                result.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithControllerNameAndObjectPropertiesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", new { id = "someid" }, new { foo_baz = "baz" });

            // Assert
            Assert.Equal(@"<a foo-baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", new RouteValueDictionary(new { Controller = "home2", id = "someid" }), new RouteValueDictionary(new { baz = "baz" }));

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithFragment()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "http", "foo.bar.com", "foo", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""http://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithFragmentAndAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "http", "foo.bar.com", "foo", new { id = "someid" }, new { foo_baz = "baz" });

            // Assert
            Assert.Equal(@"<a foo-baz=""baz"" href=""http://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullHostname()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "https", null /* hostName */, "foo", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://localhost" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullProtocolAndFragment()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", null /* protocol */, "foo.bar.com", null /* fragment */, new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""http://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNullProtocolNullHostNameAndNullFragment()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", null /* protocol */, null /* hostName */, null /* fragment */, new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithObjectProperties()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", new { Controller = "home2", id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithObjectPropertiesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", new { Controller = "home2", id = "someid" }, new { foo_baz = "baz" });

            // Assert
            Assert.Equal(@"<a foo-baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithProtocol()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "https", "foo.bar.com", null /* fragment */, new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithProtocolAndFragment()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "https", "foo.bar.com", "foo", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithDefaultPort()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(Uri.UriSchemeHttps, -1);

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "https", "foo.bar.com", "foo", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithDifferentPortProtocols()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(Uri.UriSchemeHttp, -1);

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "https", "foo.bar.com", "foo", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNonDefaultPortAndDifferentProtocol()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(Uri.UriSchemeHttp, 32768);

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "https", "foo.bar.com", "foo", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://foo.bar.com" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void ActionLinkWithNonDefaultPortAndSameProtocol()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(Uri.UriSchemeHttp, 32768);

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("linktext", "newaction", "home2", "http", "foo.bar.com", "foo", new { id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""http://foo.bar.com:32768" + AppPathModifier + @"/app/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void LinkGenerationDoesNotChangeProvidedDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();
            RouteValueDictionary valuesDictionary = new RouteValueDictionary();

            // Act
            htmlHelper.ActionLink("linkText", "actionName", valuesDictionary, new RouteValueDictionary());

            // Assert
            Assert.Empty(valuesDictionary);
            Assert.False(valuesDictionary.ContainsKey("action"));
        }

        [Fact]
        public void ActionLinkProducesLowercaseUrls()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();
            htmlHelper.RouteCollection.LowercaseUrls = true;

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("about", "About", "Home");

            // Assert
            Assert.True(html.ToHtmlString() == html.ToHtmlString().ToLowerInvariant());
        }

        [Fact]
        public void ActionLinkProducesLowercaseUrlsAfterRegisteringAnArea()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();
            MyAreaRegistration myArea = new MyAreaRegistration();
            myArea.CreateContextAndRegister(htmlHelper.RouteCollection, null);
            htmlHelper.RouteCollection.LowercaseUrls = true;

            // Act
            MvcHtmlString html = htmlHelper.ActionLink("about", "About", "Home");

            // Assert
            Assert.True(html.ToHtmlString() == html.ToHtmlString().ToLowerInvariant());
        }

        [Fact]
        public void NullOrEmptyStringParameterThrows()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();
            var tests = new[]
            {
                // ActionLink(string linkText, string actionName)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.ActionLink(String.Empty, "actionName")) },
                // ActionLink(string linkText, string actionName, object routeValues, object htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.ActionLink(String.Empty, "actionName", new Object(), null /* htmlAttributes */)) },
                // ActionLink(string linkText, string actionName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.ActionLink(String.Empty, "actionName", new RouteValueDictionary(), new RouteValueDictionary())) },
                // ActionLink(string linkText, string actionName, string controllerName)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.ActionLink(String.Empty, "actionName", "controllerName")) },
                // ActionLink(string linkText, string actionName, string controllerName, object routeValues, object htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.ActionLink(String.Empty, "actionName", "controllerName", new Object(), null /* htmlAttributes */)) },
                // ActionLink(string linkText, string actionName, string controllerName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.ActionLink(String.Empty, "actionName", "controllerName", new RouteValueDictionary(), new RouteValueDictionary())) },
                // ActionLink(string linkText, string actionName, string controllerName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.ActionLink(String.Empty, "actionName", "controllerName", null, null, null, new RouteValueDictionary(), new RouteValueDictionary())) },
                // RouteLink(string linkText, object routeValues, object htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, new Object(), null /* htmlAttributes */)) },
                // RouteLink(string linkText, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, new RouteValueDictionary(), new RouteValueDictionary())) },
                // RouteLink(string linkText, string routeName, object routeValues)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, "routeName", null /* routeValues */)) },
                // RouteLink(string linkText, string routeName, RouteValueDictionary routeValues)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, "routeName", new RouteValueDictionary() /* routeValues */)) },
                // RouteLink(string linkText, string routeName)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, (string)null /* routeName */)) },
                // RouteLink(string linkText, object routeValues)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, (object)null /* routeValues */)) },
                // RouteLink(string linkText, RouteValueDictionary routeValues)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, new RouteValueDictionary() /* routeValues */)) },
                // RouteLink(string linkText, string routeName, object routeValues, object htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, "routeName", new Object(), null /* htmlAttributes */)) },
                // RouteLink(string linkText, string routeName, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, "routeName", new RouteValueDictionary(), new RouteValueDictionary())) },
                // RouteLink(string linkText, string routeName, string protocol, string hostName, string fragment, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
                new { Parameter = "linkText", Action = new Action(() => htmlHelper.RouteLink(String.Empty, "routeName", null, null, null, new RouteValueDictionary(), new RouteValueDictionary())) },
            };

            // Act & Assert
            foreach (var test in tests)
            {
                Assert.ThrowsArgumentNullOrEmpty(test.Action, test.Parameter);
            }
        }

        [Fact]
        public void RouteLinkCanUseNamedRouteWithoutSpecifyingDefaults()
        {
            // DevDiv 217072: Non-mvc specific helpers should not give default values for controller and action

            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();
            htmlHelper.RouteCollection.MapRoute("MyRouteName", "any/url", new { controller = "Charlie" });

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "MyRouteName", null /* routeValues */);

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/any/url"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }), new RouteValueDictionary(new { baz = "baz" }));

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithFragment()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", "http", "foo.bar.com", "foo", new { Action = "newaction", Controller = "home2", id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""http://foo.bar.com" + AppPathModifier + @"/app/named/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithFragmentAndAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", "http", "foo.bar.com", "foo", new { Action = "newaction", Controller = "home2", id = "someid" }, new { foo_baz = "baz" });

            // Assert
            Assert.Equal(@"<a foo-baz=""baz"" href=""http://foo.bar.com" + AppPathModifier + @"/app/named/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithLinkTextAndRouteName()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();
            htmlHelper.RouteCollection.MapRoute("MyRouteName", "any/url", new { controller = "Charlie" });

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "MyRouteName");

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/any/url"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithObjectProperties()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", new { Action = "newaction", Controller = "home2", id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void RouteLinkWithObjectProperties_AttributeEncodes_AddedHtmlAttributes(
            string text,
            string expectedText)
        {
            // Arrange
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.RouteLink("text", routeValues: null, htmlAttributes: new { attribute = text });

            // Assert
            Assert.Equal(
                @"<a attribute=""" + expectedText + @""" href=""" + AppPathModifier + @"/app/home/oldaction"">text</a>",
                result.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithObjectPropertiesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", new { Action = "newaction", Controller = "home2", id = "someid" }, new { foo_baz = "baz" });

            // Assert
            Assert.Equal(@"<a foo-baz=""baz"" href=""" + AppPathModifier + @"/app/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithProtocol()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", "https", "foo.bar.com", null /* fragment */, new { Action = "newaction", Controller = "home2", id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://foo.bar.com" + AppPathModifier + @"/app/named/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithProtocolAndFragment()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", "https", "foo.bar.com", "foo", new { Action = "newaction", Controller = "home2", id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""https://foo.bar.com" + AppPathModifier + @"/app/named/home2/newaction/someid#foo"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithRouteNameAndDefaults()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", new { Action = "newaction" });

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/named/home/newaction"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithRouteNameAndDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }), new RouteValueDictionary());

            // Assert
            Assert.Equal(@"<a href=""" + AppPathModifier + @"/app/named/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithRouteNameAndObjectProperties()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", new { Action = "newaction", Controller = "home2", id = "someid" }, new { baz = "baz" });

            // Assert
            Assert.Equal(@"<a baz=""baz"" href=""" + AppPathModifier + @"/app/named/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        [Fact]
        public void RouteLinkWithRouteNameAndObjectPropertiesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = htmlHelper.RouteLink("linktext", "namedroute", new { Action = "newaction", Controller = "home2", id = "someid" }, new { foo_baz = "baz" });

            // Assert
            Assert.Equal(@"<a foo-baz=""baz"" href=""" + AppPathModifier + @"/app/named/home2/newaction/someid"">linktext</a>", html.ToHtmlString());
        }

        // Class for the ActionLinkProducesLowercaseUrlsAfterRegisteringAnArea test
        private class MyAreaRegistration : AreaRegistration
        {
            public override string AreaName
            {
                get
                {
                    return "MyArea";
                }
            }

            public override void RegisterArea(AreaRegistrationContext context)
            {
                context.MapRoute(
                    "MyArea_default",
                    "MyArea/{controller}/{action}/{id}",
                    new { action = "Index", id = UrlParameter.Optional }
                );
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/MetadataOverrideScope.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Moq;

namespace System.Web.Mvc.Html.Test
{
    /// <summary>
    /// <para>
    /// A scope within which the <see cref="ModelMetadata"/> for a single <see cref="Type"/> is overridden.  Could be
    /// used for example to ensure the metadata for <see cref="Exception"/> includes an additional property or
    /// has a non-<c>null</c> <see cref="ModelMetadata.DisplayName"/>.
    /// </para>
    /// <para>
    /// Notes: Does _not_ override the metadata for subclasses of the given <see cref="Type"/>.  And callers should
    /// override (likely, mock) the metadata of the containing <see cref="Type"/> when changing the metadata of a
    /// property e.g. modifying <see cref="ModelMetadata.IsRequired"/>.
    /// </para>
    /// </summary>
    public class MetadataOverrideScope : IDisposable
    {
        private static readonly DataAnnotationsModelMetadataProvider AnnotationsProvider =
            new DataAnnotationsModelMetadataProvider();

        private readonly ModelMetadataProvider _oldMetadataProvider;
        private readonly ModelMetadata _metadata;
        private readonly Type _modelType;

        public MetadataOverrideScope(ModelMetadata metadata)
        {
            if (metadata == null)
            {
                throw new ArgumentNullException("metadata");
            }
            if (metadata.ModelType == null)
            {
                throw new ArgumentException("Need ModelType", "metadata");
            }

            _oldMetadataProvider = ModelMetadataProviders.Current;
            _metadata = metadata;
            _modelType = metadata.ModelType;

            // Mock a ModelMetadataProvider which delegates to the old one in most cases.  No need to special-case
            // GetMetadataForProperties() because product code uses it only within ModelMetadata.Properties and our
            // metadata instance will call _oldMetadataProvider there.
            var metadataProvider = new Mock<ModelMetadataProvider>();
            metadataProvider
                .Setup(p => p.GetMetadataForProperties(It.IsAny<object>(), It.IsAny<Type>()))
                .Returns((object container, Type containerType) =>
                    _oldMetadataProvider.GetMetadataForProperties(container, containerType));
            metadataProvider
                .Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Returns((Func<object> modelAccessor, Type modelType) =>
                    _oldMetadataProvider.GetMetadataForType(modelAccessor, modelType));

            // When metadata for _modelType is requested, then return a clone of the provided metadata instance.
            // GetMetadataForProperty() is important because the static discovery methods (e.g.
            // ModelMetadata.FromLambdaExpression) use it.
            metadataProvider
                .Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), _modelType))
                .Returns((Func<object> modelAccessor, Type modelType) => GetMetadataForType(modelAccessor, modelType));
            metadataProvider
                .Setup(p =>
                    p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Returns((Func<object> modelAccessor, Type containerType, string propertyName) =>
                    GetMetadataForProperty(modelAccessor, containerType, propertyName));

            // Calls to GetMetadataForProperties for the modelType are incorrect because _metadata.Provider must
            // reference _oldMetadataProvider and not this mock.
            metadataProvider
                .Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), _modelType, It.IsAny<string>()))
                .Throws<InvalidOperationException>();

            // Finally make our ModelMetadataProvider visible everywhere.
            ModelMetadataProviders.Current = metadataProvider.Object;
        }

        public void Dispose()
        {
            ModelMetadataProviders.Current = _oldMetadataProvider;
        }

        private ModelMetadata GetMetadataForType(Func<object> modelAccessor, Type modelType)
        {
            return CloneMetadata(modelAccessor);
        }

        private ModelMetadata GetMetadataForProperty(
            Func<object> modelAccessor,
            Type containerType,
            string propertyName)
        {
            var propertyMetadata =
                _oldMetadataProvider.GetMetadataForProperty(modelAccessor, containerType, propertyName);
            if (propertyMetadata == null)
            {
                return null;
            }

            if (propertyMetadata.ModelType == _modelType)
            {
                return CloneMetadata(() => propertyMetadata.Model);
            }

            return propertyMetadata;
        }

        private ModelMetadata CloneMetadata(Func<object> modelAccessor)
        {
            var cachedMetadata = _metadata as CachedDataAnnotationsModelMetadata;
            var annotationsMetadata = _metadata as DataAnnotationsModelMetadata;
            ModelMetadata clonedMetadata;
            if (cachedMetadata != null)
            {
                clonedMetadata = new CachedDataAnnotationsModelMetadata(cachedMetadata, modelAccessor);
            }
            else if (annotationsMetadata != null)
            {
                var provider = (_oldMetadataProvider as DataAnnotationsModelMetadataProvider) ?? AnnotationsProvider;
                clonedMetadata = new DataAnnotationsModelMetadata(
                    provider,
                    annotationsMetadata.ContainerType,
                    modelAccessor,
                    _modelType,
                    annotationsMetadata.PropertyName,
                    displayColumnAttribute: null);      // Copying SimpleDisplayText below compensates for null here.
            }
            else
            {
                clonedMetadata = new ModelMetadata(
                    _oldMetadataProvider,
                    _metadata.ContainerType,
                    modelAccessor,
                    _modelType,
                    _metadata.PropertyName);
            }

            // Undo all the lazy-initialization of ModelMetadata and CachedDataAnnotationsModelMetadata...
            clonedMetadata.Container = _metadata.Container;        // May be incorrect.
            clonedMetadata.ConvertEmptyStringToNull = _metadata.ConvertEmptyStringToNull;
            clonedMetadata.DataTypeName = _metadata.DataTypeName;
            clonedMetadata.Description = _metadata.Description;
            clonedMetadata.DisplayFormatString = _metadata.DisplayFormatString;
            clonedMetadata.DisplayName = _metadata.DisplayName;
            clonedMetadata.EditFormatString = _metadata.EditFormatString;
            clonedMetadata.HasNonDefaultEditFormat = _metadata.HasNonDefaultEditFormat;
            clonedMetadata.HideSurroundingHtml = _metadata.HideSurroundingHtml;
            clonedMetadata.HtmlEncode = _metadata.HtmlEncode;
            clonedMetadata.IsReadOnly = _metadata.IsReadOnly;
            clonedMetadata.IsRequired = _metadata.IsRequired;
            clonedMetadata.NullDisplayText = _metadata.NullDisplayText;
            clonedMetadata.Order = _metadata.Order;
            clonedMetadata.RequestValidationEnabled = _metadata.RequestValidationEnabled;
            clonedMetadata.ShortDisplayName = _metadata.ShortDisplayName;
            clonedMetadata.ShowForDisplay = _metadata.ShowForDisplay;
            clonedMetadata.ShowForEdit = _metadata.ShowForEdit;
            clonedMetadata.SimpleDisplayText = _metadata.SimpleDisplayText;
            clonedMetadata.TemplateHint = _metadata.TemplateHint;
            clonedMetadata.Watermark = _metadata.Watermark;
            foreach (var keyValuePair in _metadata.AdditionalValues)
            {
                clonedMetadata.AdditionalValues.Add(keyValuePair.Key, keyValuePair.Value);
            }

            return clonedMetadata;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/MvcFormTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.IO;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    public class MvcFormTest
    {
        [Fact]
        public void ConstructorWithNullViewContextThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { new MvcForm((ViewContext)null); },
                "viewContext");
        }

        [Fact]
        public void DisposeRendersCloseFormTag()
        {
            // Arrange
            StringWriter writer = new StringWriter();
            ViewContext viewContext = GetViewContext(writer);

            MvcForm form = new MvcForm(viewContext);

            // Act
            form.Dispose();

            // Assert
            Assert.Equal("</form>", writer.ToString());
        }

        [Fact]
        public void EndFormRendersCloseFormTag()
        {
            // Arrange
            StringWriter writer = new StringWriter();
            ViewContext viewContext = GetViewContext(writer);

            MvcForm form = new MvcForm(viewContext);

            // Act
            form.EndForm();

            // Assert
            Assert.Equal("</form>", writer.ToString());
        }

        [Fact]
        public void DisposeTwiceRendersCloseFormTagOnce()
        {
            // Arrange
            StringWriter writer = new StringWriter();
            ViewContext viewContext = GetViewContext(writer);

            MvcForm form = new MvcForm(viewContext);

            // Act
            form.Dispose();
            form.Dispose();

            // Assert
            Assert.Equal("</form>", writer.ToString());
        }

        [Fact]
        public void EndFormTwiceRendersCloseFormTagOnce()
        {
            // Arrange
            StringWriter writer = new StringWriter();
            ViewContext viewContext = GetViewContext(writer);

            MvcForm form = new MvcForm(viewContext);

            // Act
            form.EndForm();
            form.EndForm();

            // Assert
            Assert.Equal("</form>", writer.ToString());
        }

        private static ViewContext GetViewContext(TextWriter writer)
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Items).Returns(new Hashtable());

            return new ViewContext()
            {
                HttpContext = mockHttpContext.Object,
                Writer = writer
            };
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/NameExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    public class NameExtensionsTest
    {
        [Fact]
        public void NonStronglyTypedWithNoPrefix()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.Equal("", html.IdForModel().ToHtmlString());
            Assert.Equal("foo", html.Id("foo").ToHtmlString());
            Assert.Equal("foo_bar", html.Id("foo.bar").ToHtmlString());
            Assert.Equal(String.Empty, html.Id("<script>alert(\"XSS!\")</script>").ToHtmlString());

            Assert.Equal("", html.NameForModel().ToHtmlString());
            Assert.Equal("foo", html.Name("foo").ToHtmlString());
            Assert.Equal("foo.bar", html.Name("foo.bar").ToHtmlString());
            Assert.Equal("&lt;script>alert(&quot;XSS!&quot;)&lt;/script>", html.Name("<script>alert(\"XSS!\")</script>").ToHtmlString());
        }

        [Fact]
        public void NonStronglyTypedWithPrefix()
        {
            // Arrange
            HtmlHelper html = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            html.ViewData.TemplateInfo.HtmlFieldPrefix = "prefix";

            // Act & Assert
            Assert.Equal("prefix", html.IdForModel().ToHtmlString());
            Assert.Equal("prefix_foo", html.Id("foo").ToHtmlString());
            Assert.Equal("prefix_foo_bar", html.Id("foo.bar").ToHtmlString());

            Assert.Equal("prefix", html.NameForModel().ToHtmlString());
            Assert.Equal("prefix.foo", html.Name("foo").ToHtmlString());
            Assert.Equal("prefix.foo.bar", html.Name("foo.bar").ToHtmlString());
        }

        [Fact]
        public void StronglyTypedWithNoPrefix()
        {
            // Arrange
            HtmlHelper<OuterClass> html = MvcHelper.GetHtmlHelper(new ViewDataDictionary<OuterClass>());

            // Act & Assert
            Assert.Equal("IntValue", html.IdFor(m => m.IntValue).ToHtmlString());
            Assert.Equal("Inner_StringValue", html.IdFor(m => m.Inner.StringValue).ToHtmlString());

            Assert.Equal("IntValue", html.NameFor(m => m.IntValue).ToHtmlString());
            Assert.Equal("Inner.StringValue", html.NameFor(m => m.Inner.StringValue).ToHtmlString());
        }

        [Fact]
        public void StronglyTypedWithPrefix()
        {
            // Arrange
            HtmlHelper<OuterClass> html = MvcHelper.GetHtmlHelper(new ViewDataDictionary<OuterClass>());
            html.ViewData.TemplateInfo.HtmlFieldPrefix = "prefix";

            // Act & Assert
            Assert.Equal("prefix_IntValue", html.IdFor(m => m.IntValue).ToHtmlString());
            Assert.Equal("prefix_Inner_StringValue", html.IdFor(m => m.Inner.StringValue).ToHtmlString());

            Assert.Equal("prefix.IntValue", html.NameFor(m => m.IntValue).ToHtmlString());
            Assert.Equal("prefix.Inner.StringValue", html.NameFor(m => m.Inner.StringValue).ToHtmlString());
        }

        // Regression test for codeplex #554 - editor templates for collections would add an extra dot to the
        // generated name.
        [Fact]
        public void StronglyTypedCollectionWithPrefix()
        {
            // Arrange
            HtmlHelper<List<OuterClass>> html = MvcHelper.GetHtmlHelper(new ViewDataDictionary<List<OuterClass>>());
            html.ViewData.TemplateInfo.HtmlFieldPrefix = "prefix";

            // Act & Assert
            Assert.Equal("prefix_0__IntValue", html.IdFor(m => m[0].IntValue).ToHtmlString());
            Assert.Equal("prefix_0__Inner_StringValue", html.IdFor(m => m[0].Inner.StringValue).ToHtmlString());

            Assert.Equal("prefix[0].IntValue", html.NameFor(m => m[0].IntValue).ToHtmlString());
            Assert.Equal("prefix[0].Inner.StringValue", html.NameFor(m => m[0].Inner.StringValue).ToHtmlString());
        }

        [Theory]
        [PropertyData("IdEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void Id_IdEncodes_PropertyName(string text, string expectedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            var helper = MvcHelper.GetHtmlHelper<string>(viewData);

            // Act
            var result = helper.Id(text);

            // Assert
            Assert.Equal(expectedText, result.ToHtmlString());
        }

        [Theory]
        [PropertyData("IdEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void IdHelpers_IdEncode_Prefix(string text, string expectedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper<string>(viewData);

            // Act
            var idResult = helper.Id("");
            var idForResult = helper.IdFor(m => m);
            var idForModelResult = helper.IdForModel();


            // Assert
            Assert.Equal(expectedText, idResult.ToHtmlString());
            Assert.Equal(expectedText, idForResult.ToHtmlString());
            Assert.Equal(expectedText, idForModelResult.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void Name_AttributeEncodes_PropertyName(string text, string expectedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            var helper = MvcHelper.GetHtmlHelper<string>(viewData);

            // Act
            var result = helper.Name(text);

            // Assert
            Assert.Equal(expectedText, result.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void NameHelpers_AttributeEncode_Prefix(string text, string expectedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper<string>(viewData);

            // Act
            var nameResult = helper.Name("");
            var nameForResult = helper.NameFor(m => m);
            var nameForModelResult = helper.NameForModel();


            // Assert
            Assert.Equal(expectedText, nameResult.ToHtmlString());
            Assert.Equal(expectedText, nameForResult.ToHtmlString());
            Assert.Equal(expectedText, nameForModelResult.ToHtmlString());
        }

        private sealed class OuterClass
        {
            public InnerClass Inner { get; set; }
            public int IntValue { get; set; }
        }

        private sealed class InnerClass
        {
            public string StringValue { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/PartialExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class PartialExtensionsTest
    {
        [Fact]
        public void PartialWithViewName()
        {
            // Arrange
            RenderPartialExtensionsTest.SpyHtmlHelper helper = RenderPartialExtensionsTest.SpyHtmlHelper.Create();

            // Act
            MvcHtmlString result = helper.Partial("partial-view");

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(helper.ViewData, helper.RenderPartialInternal_ViewData);
            Assert.Null(helper.RenderPartialInternal_Model);
            Assert.IsType<StringWriter>(helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
            Assert.Equal("This is the result of the view", result.ToHtmlString());
        }

        [Fact]
        public void PartialWithViewNameAndViewData()
        {
            // Arrange
            RenderPartialExtensionsTest.SpyHtmlHelper helper = RenderPartialExtensionsTest.SpyHtmlHelper.Create();
            ViewDataDictionary viewData = new ViewDataDictionary();

            // Act
            MvcHtmlString result = helper.Partial("partial-view", viewData);

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(viewData, helper.RenderPartialInternal_ViewData);
            Assert.Null(helper.RenderPartialInternal_Model);
            Assert.IsType<StringWriter>(helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
            Assert.Equal("This is the result of the view", result.ToHtmlString());
        }

        [Fact]
        public void PartialWithViewNameAndModel()
        {
            // Arrange
            RenderPartialExtensionsTest.SpyHtmlHelper helper = RenderPartialExtensionsTest.SpyHtmlHelper.Create();
            object model = new object();

            // Act
            MvcHtmlString result = helper.Partial("partial-view", model);

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(helper.ViewData, helper.RenderPartialInternal_ViewData);
            Assert.Same(model, helper.RenderPartialInternal_Model);
            Assert.IsType<StringWriter>(helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
            Assert.Equal("This is the result of the view", result.ToHtmlString());
        }

        [Fact]
        public void PartialWithViewNameAndModelAndViewData()
        {
            // Arrange
            RenderPartialExtensionsTest.SpyHtmlHelper helper = RenderPartialExtensionsTest.SpyHtmlHelper.Create();
            object model = new object();
            ViewDataDictionary viewData = new ViewDataDictionary();

            // Act
            MvcHtmlString result = helper.Partial("partial-view", model, viewData);

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(viewData, helper.RenderPartialInternal_ViewData);
            Assert.Same(model, helper.RenderPartialInternal_Model);
            Assert.IsType<StringWriter>(helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
            Assert.Equal("This is the result of the view", result.ToHtmlString());
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/RenderPartialExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class RenderPartialExtensionsTest
    {
        [Fact]
        public void RenderPartialWithViewName()
        {
            // Arrange
            SpyHtmlHelper helper = SpyHtmlHelper.Create();

            // Act
            helper.RenderPartial("partial-view");

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(helper.ViewData, helper.RenderPartialInternal_ViewData);
            Assert.Null(helper.RenderPartialInternal_Model);
            Assert.Same(helper.ViewContext.Writer, helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
        }

        [Fact]
        public void RenderPartialWithViewNameAndViewData()
        {
            // Arrange
            SpyHtmlHelper helper = SpyHtmlHelper.Create();
            ViewDataDictionary viewData = new ViewDataDictionary();

            // Act
            helper.RenderPartial("partial-view", viewData);

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(viewData, helper.RenderPartialInternal_ViewData);
            Assert.Null(helper.RenderPartialInternal_Model);
            Assert.Same(helper.ViewContext.Writer, helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
        }

        [Fact]
        public void RenderPartialWithViewNameAndModel()
        {
            // Arrange
            SpyHtmlHelper helper = SpyHtmlHelper.Create();
            object model = new object();

            // Act
            helper.RenderPartial("partial-view", model);

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(helper.ViewData, helper.RenderPartialInternal_ViewData);
            Assert.Same(model, helper.RenderPartialInternal_Model);
            Assert.Same(helper.ViewContext.Writer, helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
        }

        [Fact]
        public void RenderPartialWithViewNameAndModelAndViewData()
        {
            // Arrange
            SpyHtmlHelper helper = SpyHtmlHelper.Create();
            object model = new object();
            ViewDataDictionary viewData = new ViewDataDictionary();

            // Act
            helper.RenderPartial("partial-view", model, viewData);

            // Assert
            Assert.Equal("partial-view", helper.RenderPartialInternal_PartialViewName);
            Assert.Same(viewData, helper.RenderPartialInternal_ViewData);
            Assert.Same(model, helper.RenderPartialInternal_Model);
            Assert.Same(helper.ViewContext.Writer, helper.RenderPartialInternal_Writer);
            Assert.Same(ViewEngines.Engines, helper.RenderPartialInternal_ViewEngineCollection);
        }

        internal class SpyHtmlHelper : HtmlHelper
        {
            public string RenderPartialInternal_PartialViewName;
            public ViewDataDictionary RenderPartialInternal_ViewData;
            public object RenderPartialInternal_Model;
            public TextWriter RenderPartialInternal_Writer;
            public ViewEngineCollection RenderPartialInternal_ViewEngineCollection;

            SpyHtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer)
                : base(viewContext, viewDataContainer)
            {
            }

            public static SpyHtmlHelper Create()
            {
                ViewDataDictionary viewData = new ViewDataDictionary();

                Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
                mockViewContext.Setup(c => c.HttpContext.Response.Output).Throws(new Exception("Response.Output should never be called."));
                mockViewContext.Setup(c => c.ViewData).Returns(viewData);
                mockViewContext.Setup(c => c.Writer).Returns(new StringWriter());

                Mock<IViewDataContainer> container = new Mock<IViewDataContainer>();
                container.Setup(c => c.ViewData).Returns(viewData);

                return new SpyHtmlHelper(mockViewContext.Object, container.Object);
            }

            internal override void RenderPartialInternal(string partialViewName, ViewDataDictionary viewData, object model,
                                                         TextWriter writer, ViewEngineCollection viewEngineCollection)
            {
                RenderPartialInternal_PartialViewName = partialViewName;
                RenderPartialInternal_ViewData = viewData;
                RenderPartialInternal_Model = model;
                RenderPartialInternal_Writer = writer;
                RenderPartialInternal_ViewEngineCollection = viewEngineCollection;

                writer.Write("This is the result of the view");
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/SelectExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Web.Mvc.Test;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class SelectExtensionsTest : IDisposable
    {
        private static readonly ViewDataDictionary<FooModel> _listBoxViewData = new ViewDataDictionary<FooModel> { { "foo", new[] { "Bravo" } } };
        private static readonly ViewDataDictionary<FooModel> _dropDownListViewData = new ViewDataDictionary<FooModel> { { "foo", "Bravo" } };
        private static readonly ViewDataDictionary<FooContainerModel> _nestedDropDownListViewData = new ViewDataDictionary<FooContainerModel> { { "foo", "Bravo" } };
        private static readonly ViewDataDictionary<NonIEnumerableModel> _nonIEnumerableViewData = new ViewDataDictionary<NonIEnumerableModel> { { "foo", 1 } };
        private static readonly ViewDataDictionary<EnumModel> _enumDropDownListViewData = new ViewDataDictionary<EnumModel>
        {
            { "WithDisplay", EnumWithDisplay.Two },
            { "WithDuplicates", EnumWithDuplicates.Second },
            { "WithFlags", EnumWithFlags.Second },
        };
        private static readonly SelectList _selectList = new SelectList(
            new[]
            {
                new { Text = "UFO", Value = "ufo", Category = "" }, /* Empty Group */
                new { Text = "Volvo", Value = "volvo", Category = "Swedish Cars" },
                new { Text = "Mercedes-Benz", Value = "mercedes-benz", Category = "German Cars" },
                new { Text = "Saab", Value = "saab", Category = "Swedish Cars" },
                new { Text = "Audi", Value = "audi", Category = "German Cars" },
                new { Text = "Other", Value = "other", Category = (string) null }, /* Another Empty Group */
                new { Text = "Unknown", Value = "unknown", Category = " " } /* Unnamed Group */
            }, "Value", "Text", "Category", (object) "audi");
        private static readonly MultiSelectList _multiSelectList = new MultiSelectList(
            new[]
            {
                new { Text = "UFO", Value = "ufo", Category = "" }, /* Empty Group */
                new { Text = "Volvo", Value = "volvo", Category = "Swedish Cars" },
                new { Text = "Mercedes-Benz", Value = "mercedes-benz", Category = "German Cars" },
                new { Text = "Saab", Value = "saab", Category = "Swedish Cars" },
                new { Text = "Audi", Value = "audi", Category = "German Cars" },
                new { Text = "Other", Value = "other", Category = (string) null }, /* Another Empty Group */
                new { Text = "Unknown", Value = "unknown", Category = " " } /* Unnamed Group */
            }, "Value", "Text", "Category", new[] { "audi", "volvo" });

        private static ViewDataDictionary GetViewDataWithSelectList()
        {
            ViewDataDictionary viewData = new ViewDataDictionary();
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");
            viewData["foo"] = selectList;
            viewData["foo.bar"] = selectList;
            return viewData;
        }

        private static List<SelectListItem> GroupedItems_WithDisabled
        {
            get
            {
                List<SelectListItem> items = new List<SelectListItem>();
                SelectListGroup disabledGroup = new SelectListGroup { Disabled = true, Name = "DisabledGroup" };
                items.Add(new SelectListItem() { Text = "Alice", Value = "a" });
                items.Add(new SelectListItem() { Text = "Bob", Value = "b", Group = disabledGroup });
                items.Add(new SelectListItem() { Text = "Charlie", Value = "c", Group = disabledGroup });
                items.Add(new SelectListItem() { Text = "David", Value = "d", Disabled = true });

                return items;
            }
        }

        // DropDownList

        private static List<SelectListItem> GroupedItems
        {
            get
            {
                List<SelectListItem> items = new List<SelectListItem>();
                SelectListGroup swedish = new SelectListGroup { Name = "Swedish Cars" };
                SelectListGroup german = new SelectListGroup { Name = "German Cars" };
                SelectListGroup unnamed = new SelectListGroup();
                items.Add(new SelectListItem() { Text = "other1", Value = "other1" });
                items.Add(new SelectListItem() { Text = "other2", Value = "other2" });
                items.Add(new SelectListItem() { Group = swedish, Text = "Volvo", Value = "volvo" });
                items.Add(new SelectListItem() { Text = "other3", Value = "other3" });
                items.Add(new SelectListItem() { Group = unnamed, Text = "other4", Value = "other4" });
                items.Add(new SelectListItem() { Group = unnamed, Text = "other5", Value = "other5" });
                items.Add(new SelectListItem() { Group = german, Text = "Mercedes-Benz", Value = "mercedes-benz" });
                items.Add(new SelectListItem() { Group = swedish, Text = "Saab", Value = "saab", Selected = true });
                items.Add(new SelectListItem() { Group = german, Text = "Audi", Value = "audi", Disabled = true });
                items.Add(new SelectListItem() { Text = "other6", Value = "other6" });

                return items;
            }
        }

        [Fact]
        void DropDownList_WithGroups()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedDropDownListHtml = @"<select id=""List"" name=""List""><option value=""other1"">other1</option>
<option value=""other2"">other2</option>
<optgroup label=""Swedish Cars"">
<option value=""volvo"">Volvo</option>
<option selected=""selected"" value=""saab"">Saab</option>
</optgroup>
<option value=""other3"">other3</option>
<optgroup>
<option value=""other4"">other4</option>
<option value=""other5"">other5</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option disabled=""disabled"" value=""audi"">Audi</option>
</optgroup>
<option value=""other6"">other6</option>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownList("List", GroupedItems);

            // Assert
            Assert.Equal(expectedDropDownListHtml, html.ToHtmlString());
        }

        [Fact]
        void DropDownList_WithGroups_WithDisabled()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedDropDownListHtml = @"<select id=""List"" name=""List""><option value=""a"">Alice</option>
<optgroup disabled=""disabled"" label=""DisabledGroup"">
<option value=""b"">Bob</option>
<option value=""c"">Charlie</option>
</optgroup>
<option disabled=""disabled"" value=""d"">David</option>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownList("List", GroupedItems_WithDisabled);

            // Assert
            Assert.Equal(expectedDropDownListHtml, html.ToHtmlString());
        }


        [Fact]
        void DropDownList_SelectList_WithGroups()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedDropDownListHtml = @"<select id=""List"" name=""List""><option value=""ufo"">UFO</option>
<optgroup label=""Swedish Cars"">
<option value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option selected=""selected"" value=""audi"">Audi</option>
</optgroup>
<option value=""other"">Other</option>
<optgroup label="" "">
<option value=""unknown"">Unknown</option>
</optgroup>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownList("List", _selectList);

            // Assert
            Assert.Equal(expectedDropDownListHtml, html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesExplicitValueIfNotProvidedInViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesExplicitValueIfNotProvidedInViewData_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select data-val=\"true\" data-val-type=\"error\" id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataDefaultValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(_dropDownListViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), "Charlie");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataDefaultValueNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(_dropDownListViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), "Charlie");

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.DropDownList(String.Empty, (SelectList)null /* selectList */, (string)null /* optionLabel */); },
                "name");
        }

        [Fact]
        public void DropDownListWithErrors()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });
            ViewDataDictionary viewData = GetViewDataWithErrors();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" class=\"input-validation-error\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithErrorsAndCustomClass()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = GetViewDataWithErrors();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, new { @class = "foo-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error foo-class\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithNullNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.DropDownList(null /* name */, (SelectList)null /* selectList */, (string)null /* optionLabel */); },
                "name");
        }

        [Fact]
        public void DropDownListWithNullSelectListUsesViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionary()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = new ViewDataDictionary();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryWithUnderscores()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = new ViewDataDictionary();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndSelectList()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryWithUnderscoresAndSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndEmptyOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, String.Empty /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option value=\"\"></option>" + Environment.NewLine
              + "<option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndTitle()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, "[Select Something]", HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option value=\"\">[Select Something]</option>" + Environment.NewLine
              + "<option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataSelectList()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetViewDataWithSelectList());

            // Act
            MvcHtmlString html = helper.DropDownList("foo", (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesModelState()
        {
            // Arrange
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            ViewDataDictionary viewData = GetViewDataWithErrors();
            viewData["foo"] = selectList;
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListUsesViewDataSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetViewDataWithSelectList());

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithDotReplacementForId()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetViewDataWithSelectList());

            // Act
            MvcHtmlString html = helper.DropDownList("foo.bar");

            // Assert
            Assert.Equal(
                "<select id=\"foo_bar\" name=\"foo.bar\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableSelectListItem()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", MultiSelectListTest.GetSampleIEnumerableObjects() } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", "123456789" } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", MultiSelectListTest.GetSampleIEnumerableObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableOfSelectListItemMatchesEnumName()
        {
            // Arrange
            ViewDataDictionary<EnumWithDisplay> vdd = new ViewDataDictionary<EnumWithDisplay>
            {
                { "foo", EnumWithDisplay.Three }
            };
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html =
                helper.DropDownList("foo", GetSelectListWithNamedValuesForEnumWithDisplay(includeEmpty: false));

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" +
                "<option value=\"Zero\">Zero</option>" + Environment.NewLine +
                "<option value=\"One\">One</option>" + Environment.NewLine +
                "<option value=\"Two\">Two</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"Three\">Three</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithIEnumerableOfSelectListItemMatchesEnumValue()
        {
            // Arrange
            ViewDataDictionary<EnumWithDisplay> vdd = new ViewDataDictionary<EnumWithDisplay>
            {
                { "foo", EnumWithDisplay.Three }
            };
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html =
                helper.DropDownList("foo", GetSelectListWithNumericValuesForEnumWithDisplay(includeEmpty: false));

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" +
                "<option value=\"0\">Zero</option>" + Environment.NewLine +
                "<option value=\"1\">One</option>" + Environment.NewLine +
                "<option value=\"2\">Two</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"3\">Three</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithListOfSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", "123456789" } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo", MultiSelectListTest.GetSampleListObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithListOfSelectListItem()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", MultiSelectListTest.GetSampleListObjects() } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithNullViewDataValueThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { helper.DropDownList("foo", (string)null /* optionLabel */); },
                "There is no ViewData item of type 'IEnumerable<SelectListItem>' that has the key 'foo'.");
        }

        [Fact]
        public void DropDownListWithWrongViewDataTypeValueThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary { { "foo", 123 } });

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { helper.DropDownList("foo", (string)null /* optionLabel */); },
                "The ViewData item that has the key 'foo' is of type 'System.Int32' but must be of type 'IEnumerable<SelectListItem>'.");
        }

        [Fact]
        public void DropDownListWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownList("foo", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix_foo\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownList("", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix\" name=\"MyPrefix\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithPrefixAndNullSelectListUsesViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownList("foo");

            // Assert
            Assert.Equal(
                "<select id=\"MyPrefix_foo\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_AddedHtmlAttributes(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result =
                helper.DropDownList(name: "name", selectList: selectList, htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<select attribute=\"" +
                    encodedText +
                    "\" id=\"name\" name=\"name\"><option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_Name(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result =
                helper.DropDownList(name: text, selectList: selectList, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"id\" name=\"" +
                    encodedText +
                    "\"><option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_OptGroupLabel(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Group = new SelectListGroup { Name = text, }, Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><optgroup label=\"" +
                    encodedText +
                    "\">" +
                    Environment.NewLine +
                    "<option>text</option>" +
                    Environment.NewLine +
                    "</optgroup>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_HtmlEncodes_OptionLabel(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList, optionLabel: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><option value=\"\">" +
                    encodedText +
                    "</option>" +
                    Environment.NewLine +
                    "<option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_Prefix(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", },
            };
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result =
                helper.DropDownList(name: String.Empty, selectList: selectList, htmlAttributes: new { id = "id", })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"id\" name=\"" +
                    encodedText +
                    "\"><option>text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_HtmlEncodes_Text(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = text, },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><option>" +
                    encodedText +
                    "</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoHtmlEncode", PropertyType = typeof(EncodedDataSets))]
        public void DropDownList_AttributeEncodes_Value(string text, string encodedText)
        {
            // Arrange
            var selectList = new List<SelectListItem>
            {
                new SelectListItem { Text = "text", Value = text },
            };
            var helper = MvcHelper.GetHtmlHelper();

            // Act
            var result = helper.DropDownList(name: "name", selectList: selectList).ToHtmlString();

            // Assert
            Assert.Equal(
                "<select id=\"name\" name=\"name\"><option value=\"" +
                    encodedText +
                    "\">text</option>" +
                    Environment.NewLine +
                    "</select>",
                result);
        }

        // DropDownListFor

        [Fact]
        void DropDownListFor_WithGroups()
        {
            // Arrange
            ViewDataDictionary<FooModel> dict = new ViewDataDictionary<FooModel>();
            dict.Add("foo", "volvo");
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(dict);
            const string expectedListBox = @"<select id=""foo"" name=""foo""><option value="""">Cars</option>
<option value=""other1"">other1</option>
<option value=""other2"">other2</option>
<optgroup label=""Swedish Cars"">
<option selected=""selected"" value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<option value=""other3"">other3</option>
<optgroup>
<option value=""other4"">other4</option>
<option value=""other5"">other5</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option disabled=""disabled"" value=""audi"">Audi</option>
</optgroup>
<option value=""other6"">other6</option>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, GroupedItems, optionLabel: "Cars");

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        void DropDownListFor_WithGroups_WithDisabled()
        {
            // Arrange
            ViewDataDictionary<FooModel> dict = new ViewDataDictionary<FooModel>();
            dict.Add("foo", "d");
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(dict);
            const string expectedListBox = @"<select id=""foo"" name=""foo""><option value="""">Options</option>
<option value=""a"">Alice</option>
<optgroup disabled=""disabled"" label=""DisabledGroup"">
<option value=""b"">Bob</option>
<option value=""c"">Charlie</option>
</optgroup>
<option disabled=""disabled"" selected=""selected"" value=""d"">David</option>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, GroupedItems_WithDisabled, optionLabel: "Options");

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        void DropDownListFor_SelectList_WithGroups()
        {
            // Arrange
            ViewDataDictionary<FooModel> dict = new ViewDataDictionary<FooModel>();
            dict.Add("foo", "volvo");
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(dict);
            const string expectedListBox = @"<select id=""foo"" name=""foo""><option value="""">options...</option>
<option value=""ufo"">UFO</option>
<optgroup label=""Swedish Cars"">
<option selected=""selected"" value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option value=""audi"">Audi</option>
</optgroup>
<option value=""other"">Other</option>
<optgroup label="" "">
<option value=""unknown"">Unknown</option>
</optgroup>
</select>";

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, _selectList, optionLabel: "options...");

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<object> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<object>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.DropDownListFor<object, object>(null /* expression */, selectList),
                "expression"
                );
        }

        [Fact]
        public void DropDownListForUsesExplicitValueIfNotProvidedInViewData()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForUsesExplicitValueIfNotProvidedInViewData_Unobtrusive()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select data-val=\"true\" data-val-type=\"error\" id=\"foo\" name=\"foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithEnumerableModel_Unobtrusive()
        {
            // Arrange
            HtmlHelper<IEnumerable<RequiredModel>> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<IEnumerable<RequiredModel>>());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", "C");

            using (new CultureReplacer("en-US", "en-US"))
            {
                // Act
                MvcHtmlString html = helper.DropDownListFor(m => m.ElementAt(0).foo, selectList);

                // Assert
                Assert.Equal(
                    "<select data-val=\"true\" data-val-required=\"The foo field is required.\" id=\"MyPrefix_foo\" name=\"MyPrefix.foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
                  + "<option value=\"B\">Bravo</option>" + Environment.NewLine
                  + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
                  + "</select>",
                    html.ToHtmlString());
            }
        }

        [Fact]
        public void DropDownListForUsesViewDataDefaultValue()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(_dropDownListViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), "Charlie");

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, (string)null /* optionLabel */);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForUsesViewDataDefaultValueNoOptionLabel()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(_dropDownListViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), "Charlie");

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForUsesLambdaDefaultValue()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(_dropDownListViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }
        
        [Fact]
        public void DropDownListForUsesLambdaDefaultValueWhenNested()
        {
            // Arrange
            FooModel model = new FooModel { foo = "Bravo" };
            ViewDataDictionary<FooModel> viewData = new ViewDataDictionary<FooModel>(model);
            ViewDataDictionary<string> nestedViewData = MvcHelper.GetNestedViewData(viewData, m => m.foo);
            HtmlHelper<string> helper = MvcHelper.GetHtmlHelper(nestedViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m, selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForUsesLambdaDefaultValueFromViewDataWhenNested()
        {
            // Arrange
            ViewDataDictionary<FooModel> nestedViewData = MvcHelper.GetNestedViewData(_nestedDropDownListViewData, m => m.inner);
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(nestedViewData);
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList);

            // Assert
            Assert.Equal(
                "<select id=\"inner_foo\" name=\"inner.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForUsesLambdaDefaultValueWithNullSelectListUsesViewData()
        {
            // Arrange
            FooModel model = new FooModel { foo = "Bravo" };
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel>(model)
            {
                { "foo", new SelectList(MultiSelectListTest.GetSampleStrings()) }
            };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList: null);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForUsesLambdaDefaultValueWithNullSelectListUsesViewDataWhenNested()
        {
            // Arrange
            FooContainerModel model = new FooContainerModel { inner = new FooModel { foo = "Bravo" } };
            ViewDataDictionary<FooContainerModel> vdd = new ViewDataDictionary<FooContainerModel>(model)
            {
                { "foo", new SelectList(MultiSelectListTest.GetSampleStrings()) }
            };

            ViewDataDictionary<FooModel> nestedViewData = MvcHelper.GetNestedViewData(vdd, m => m.inner);


            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(nestedViewData);

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList: null);

            // Assert
            Assert.Equal(
                "<select id=\"inner_foo\" name=\"inner.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithAttributesDictionary()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, null /* optionLabel */, HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithErrors()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetViewDataWithErrors());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" class=\"input-validation-error\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetViewDataWithErrors());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, null /* optionLabel */, new { @class = "foo-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error foo-class\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithObjectDictionary()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithObjectDictionaryWithUnderscores()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, null /* optionLabel */, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithObjectDictionaryAndSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithObjectDictionaryWithUnderscoresAndSelectListNoOptionLabel()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithObjectDictionaryAndEmptyOptionLabel()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, String.Empty /* optionLabel */, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option value=\"\"></option>" + Environment.NewLine
              + "<option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithObjectDictionaryAndTitle()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, "[Select Something]", HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" name=\"foo\"><option value=\"\">[Select Something]</option>" + Environment.NewLine
              + "<option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithIEnumerableSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", "123456789" } };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, MultiSelectListTest.GetSampleIEnumerableObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithListOfSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", "123456789" } };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, MultiSelectListTest.GetSampleListObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithPrefix()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix_foo\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m, selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix\" name=\"MyPrefix\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListForWithPrefixAndIEnumerableSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", "123456789" } };
            vdd.TemplateInfo.HtmlFieldPrefix = "MyPrefix";
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.DropDownListFor(m => m.foo, MultiSelectListTest.GetSampleIEnumerableObjects());

            // Assert
            Assert.Equal(
                "<select id=\"MyPrefix_foo\" name=\"MyPrefix.foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        // EnumDropDownListFor

        [Fact]
        public void EnumDropDownListForWithNullExpressionThrowsArgumentNull()
        {
            // Arrange
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<EnumWithDisplay>());

            // Act & Assert
            Assert.ThrowsArgumentNull(() => helper.EnumDropDownListFor<EnumWithDisplay, EnumWithDisplay>(null),
                "expression");
        }

        [Fact]
        public void EnumDropDownListForWithUnsupportedExpressionThrowsInvalidOperation()
        {
            // Arrange
            IEnumerable<EnumModel> model = new List<EnumModel>
            {
                new EnumModel { WithDisplay = EnumWithDisplay.One, },
                new EnumModel { WithDisplay = EnumWithDisplay.Two, },
            };
            ViewDataDictionary<IEnumerable<EnumModel>> viewData = new ViewDataDictionary<IEnumerable<EnumModel>>(model);
            HtmlHelper<IEnumerable<EnumModel>> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => helper.EnumDropDownListFor(m => m.Select((item) => item.WithDisplay).First()),
                exceptionMessage: "Templates can be used only with field access, property access, " +
                "single-dimension array index, or single-parameter custom indexer expressions.");
        }

        [Fact]
        public void EnumDropDownListForWithIntExpressionTypeThrowsArgument()
        {
            // Arrange
            ViewDataDictionary<int> viewData = new ViewDataDictionary<int>
            {
                TemplateInfo = new TemplateInfo { HtmlFieldPrefix = "MyExpression", },
            };
            HtmlHelper<int> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act & Assert
            Assert.ThrowsArgument(() => helper.EnumDropDownListFor(model => model), paramName: "expression",
                exceptionMessage: "Return type 'System.Int32' is not supported." + Environment.NewLine +
                "Parameter name: expression");
        }

        [Fact]
        public void EnumDropDownListForWithUnsupportedExpressionTypeThrowsArgument()
        {
            // Arrange
            ViewDataDictionary<EnumWithFlags> viewData = new ViewDataDictionary<EnumWithFlags>
            {
                TemplateInfo = new TemplateInfo { HtmlFieldPrefix = "MyExpression", },
            };
            HtmlHelper<EnumWithFlags> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act & Assert
            Assert.ThrowsArgument(() => helper.EnumDropDownListFor(model => model), paramName: "expression",
                exceptionMessage: "Return type 'System.Web.Mvc.Html.Test.SelectExtensionsTest+EnumWithFlags' is not " +
                "supported. Type must not have a 'Flags' attribute." + Environment.NewLine +
                "Parameter name: expression");
        }

        // Like EnumDropDownListForWithUnsupportedExpressionTypeThrowsArgument but using EnumModel
        [Fact]
        public void EnumDropDownListForWithUnsupportedPropertyTypeThrowsArgument()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act & Assert
            Assert.ThrowsArgument(() => helper.EnumDropDownListFor(m => m.WithFlags), paramName: "expression",
                exceptionMessage: "Return type 'System.Web.Mvc.Html.Test.SelectExtensionsTest+EnumWithFlags' is not " +
                "supported. Type must not have a 'Flags' attribute." + Environment.NewLine +
                "Parameter name: expression");
        }

        [Fact]
        public void EnumDropDownListforIsSuccessfulIfNoValueProvided()
        {
            // Arrange
            ViewDataDictionary<EnumWithDisplay> viewData = new ViewDataDictionary<EnumWithDisplay>
            {
                TemplateInfo = new TemplateInfo { HtmlFieldPrefix = "MyExpression", },
            };
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(model => model, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"MyExpression\" name=\"MyExpression\">" +
                "<option selected=\"selected\" value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForIsSuccessfulIfNoValueProvidedAndEnumEmpty()
        {
            // Arrange
            ViewDataDictionary<EnumWithoutAnything> viewData = new ViewDataDictionary<EnumWithoutAnything>
            {
                TemplateInfo = new TemplateInfo { HtmlFieldPrefix = "MyExpression", },
            };
            HtmlHelper<EnumWithoutAnything> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(model => model, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"MyExpression\" name=\"MyExpression\">" +
                "<option selected=\"selected\" value=\"0\"></option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesModelValueIfNotProvidedInViewData()
        {
            // Arrange
            ViewDataDictionary<EnumWithDisplay> viewData = new ViewDataDictionary<EnumWithDisplay>(EnumWithDisplay.Two)
            {
                TemplateInfo = new TemplateInfo { HtmlFieldPrefix = "MyExpression", },
            };
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(model => model, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"MyExpression\" name=\"MyExpression\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesModelValueIfNotProvidedInViewData_EnumModel()
        {
            // Arrange
            EnumModel model = new EnumModel { WithDisplay = EnumWithDisplay.Two, };
            HtmlHelper<EnumModel> helper =
                MvcHelper.GetHtmlHelper(new ViewDataDictionary<EnumModel>(model));

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesModelValueIfNotProvidedInViewData_EnumWithoutAnything()
        {
            // Arrange
            EnumModel model = new EnumModel { WithoutAnything = (EnumWithoutAnything)23, };
            HtmlHelper<EnumModel> helper =
                MvcHelper.GetHtmlHelper(new ViewDataDictionary<EnumModel>(model));

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithoutAnything, optionLabel: "My Label");

            // Assert
            Assert.Equal(
                "<select id=\"WithoutAnything\" name=\"WithoutAnything\">" +
                "<option selected=\"selected\" value=\"23\">My Label</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesModelValueIfNotProvidedInViewData_Unobtrusive()
        {
            // Arrange
            EnumModel model = new EnumModel { WithDisplay = EnumWithDisplay.Two, };
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<EnumModel>(model));
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) =>
                new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select data-val=\"true\" data-val-type=\"error\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesViewDataDefaultValue()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesViewDataDefaultValue_Duplicates()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDuplicates, optionLabel: null);

            // Assert
            // TODO: https://aspnetwebstack.codeplex.com/workitem/1349 covers incorrect multi-select in this case
            Assert.Equal(
                "<select id=\"WithDuplicates\" name=\"WithDuplicates\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"1\">Third</option>" + Environment.NewLine +
                "<option value=\"2\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesViewDataDefaultValue_Unrecognized()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            viewData["WithDisplay"] = (EnumWithDisplay)34;
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option selected=\"selected\" value=\"34\"></option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesViewDataDefaultValue_NullableIsNull()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithNullable, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"WithNullable\" name=\"WithNullable\">" +
                "<option selected=\"selected\" value=\"\"></option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesViewDataDefaultValue_NullableNotNull()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            viewData["WithNullable"] = EnumWithDisplay.Three;
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithNullable, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"WithNullable\" name=\"WithNullable\">" +
                "<option value=\"\"></option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesViewDataDefaultValue_NullableUnrecognized()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            viewData["WithNullable"] = (EnumWithDisplay)34;
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithNullable, optionLabel: null);

            // Assert
            Assert.Equal(
                "<select id=\"WithNullable\" name=\"WithNullable\">" +
                "<option selected=\"selected\" value=\"34\"></option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForUsesViewDataDefaultValueNoOptionLabel()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay);

            // Assert
            Assert.Equal(
                "<select id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithTitle()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: "[Select Something]");

            // Assert
            Assert.Equal(
                "<select id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"\">[Select Something]</option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithTitle_Unrecognized()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            viewData["WithDisplay"] = (EnumWithDisplay)34;
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: "[Select Something]");

            // Assert
            Assert.Equal(
                "<select id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option selected=\"selected\" value=\"34\">[Select Something]</option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithTitle_NullableNull()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithNullable, optionLabel: "[Select Something]");

            // Assert
            Assert.Equal(
                "<select id=\"WithNullable\" name=\"WithNullable\">" +
                "<option selected=\"selected\" value=\"\">[Select Something]</option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithTitle_NullableNotNull()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            viewData["WithNullable"] = EnumWithDisplay.Three;
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithNullable, optionLabel: "[Select Something]");

            // Assert
            Assert.Equal(
                "<select id=\"WithNullable\" name=\"WithNullable\">" +
                "<option value=\"\">[Select Something]</option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithTitle_NullableUnrecognized()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            viewData["WithNullable"] = (EnumWithDisplay)34;
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithNullable, optionLabel: "[Select Something]");

            // Assert
            Assert.Equal(
                "<select id=\"WithNullable\" name=\"WithNullable\">" +
                "<option selected=\"selected\" value=\"34\">[Select Something]</option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithAttributesDictionary()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay,
                htmlAttributes: HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithAttributesDictionaryAndTitle()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: "[Select Something]",
                htmlAttributes: HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"\">[Select Something]</option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithErrors()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            ModelState modelState = new ModelState
            {
                Errors = { new ModelError("WithDisplay error 1"), new ModelError("WithDisplay error 2"), },
            };
            viewData.ModelState["WithDisplay"] = modelState;

            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay,
                htmlAttributes: HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" class=\"input-validation-error\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithErrorsAndValue()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData);
            ModelState modelState = new ModelState
            {
                Errors = { new ModelError("WithDisplay error 1"), new ModelError("WithDisplay error 2"), },
                Value = new ValueProviderResult(new string[] { "1", }, "1", null),
            };
            viewData.ModelState["WithDisplay"] = modelState;

            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay,
                htmlAttributes: HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" class=\"input-validation-error\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"1\">Second</option>" + Environment.NewLine +
                "<option value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithObjectDictionaryWithUnderscores()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: null,
                htmlAttributes: HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithObjectDictionaryWithUnderscoresNoOptionLabel()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay,
                htmlAttributes: HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithObjectDictionaryAndEmptyOptionLabel()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: String.Empty,
                htmlAttributes: HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"\"></option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithObjectDictionaryAndTitle()
        {
            // Arrange
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(_enumDropDownListViewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay, optionLabel: "[Select Something]",
                htmlAttributes: HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"WithDisplay\" name=\"WithDisplay\">" +
                "<option value=\"\">[Select Something]</option>" + Environment.NewLine +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithPrefix()
        {
            // Arrange
            ViewDataDictionary<EnumModel> viewData = new ViewDataDictionary<EnumModel>(_enumDropDownListViewData)
            {
                TemplateInfo = new TemplateInfo { HtmlFieldPrefix = "MyPrefix", },
            };
            HtmlHelper<EnumModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m.WithDisplay,
                htmlAttributes: HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix_WithDisplay\" name=\"MyPrefix.WithDisplay\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void EnumDropDownListForWithPrefixAndEmptyName()
        {
            // Arrange
            ViewDataDictionary<EnumWithDisplay> viewData = new ViewDataDictionary<EnumWithDisplay>(EnumWithDisplay.Two)
            {
                TemplateInfo = new TemplateInfo { HtmlFieldPrefix = "MyPrefix", },
            };
            HtmlHelper<EnumWithDisplay> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.EnumDropDownListFor(m => m,
                htmlAttributes: HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix\" name=\"MyPrefix\">" +
                "<option value=\"0\">First</option>" + Environment.NewLine +
                "<option value=\"1\">Second</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"2\">Third</option>" + Environment.NewLine +
                "<option value=\"3\">Fourth</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        // ListBox

        [Fact]
        void ListBox_WithGroups()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedListBox = @"<select id=""List"" multiple=""multiple"" name=""List""><option value=""other1"">other1</option>
<option value=""other2"">other2</option>
<optgroup label=""Swedish Cars"">
<option value=""volvo"">Volvo</option>
<option selected=""selected"" value=""saab"">Saab</option>
</optgroup>
<option value=""other3"">other3</option>
<optgroup>
<option value=""other4"">other4</option>
<option value=""other5"">other5</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option disabled=""disabled"" value=""audi"">Audi</option>
</optgroup>
<option value=""other6"">other6</option>
</select>";

            // Act
            MvcHtmlString html = helper.ListBox("List", GroupedItems);

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        void ListBox_WithGroups_WithDisabled()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedListBox = @"<select id=""List"" multiple=""multiple"" name=""List""><option value=""a"">Alice</option>
<optgroup disabled=""disabled"" label=""DisabledGroup"">
<option value=""b"">Bob</option>
<option value=""c"">Charlie</option>
</optgroup>
<option disabled=""disabled"" value=""d"">David</option>
</select>";

            // Act
            MvcHtmlString html = helper.ListBox("List", GroupedItems_WithDisabled);

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        void ListBox_MultiSelectList_WithGroups()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            const string expectedListBox = @"<select id=""List"" multiple=""multiple"" name=""List""><option value=""ufo"">UFO</option>
<optgroup label=""Swedish Cars"">
<option selected=""selected"" value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option selected=""selected"" value=""audi"">Audi</option>
</optgroup>
<option value=""other"">Other</option>
<optgroup label="" "">
<option value=""unknown"">Unknown</option>
</optgroup>
</select>";

            // Act
            MvcHtmlString html = helper.ListBox("List", _multiSelectList);

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        public void ListBoxUsesExplicitValueIfNotProvidedInViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", new[] { "A", "C" });

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxUsesExplicitValueIfNotProvidedInViewData_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", new[] { "A", "C" });

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList);

            // Assert
            Assert.Equal(
                "<select data-val=\"true\" data-val-type=\"error\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxUsesViewDataDefaultValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(_listBoxViewData);
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithErrors()
        {
            // Arrange
            ViewDataDictionary viewData = GetViewDataWithErrors();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);
            MultiSelectList list = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBox("foo", list);

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithErrorsAndCustomClass()
        {
            // Arrange
            ViewDataDictionary viewData = GetViewDataWithErrors();
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList, new { @class = "foo-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error foo-class\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithNameOnly()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBox("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithAttributesDictionary()
        {
            // Arrange
            ViewDataDictionary viewData = new ViewDataDictionary();
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());
            //viewData["foo"] = selectList;
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList, HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithAttributesDictionaryAndMultiSelectList()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList, HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithAttributesDictionaryOverridesName()
        {
            // DevDiv Bugs #217602:
            // SelectInternal() should override the user-provided 'name' attribute

            // Arrange
            ViewDataDictionary viewData = new ViewDataDictionary();
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());
            HtmlHelper helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList, new { myAttr = "myValue", name = "theName" });

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" myAttr=\"myValue\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.ListBox(String.Empty, (MultiSelectList)null /* selectList */); },
                "name");
        }

        [Fact]
        public void ListBoxWithNullNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.ListBox(null /* name */, (MultiSelectList)null /* selectList */); },
                "name");
        }

        [Fact]
        public void ListBoxWithNullSelectListUsesViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBox("foo", null);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithObjectDictionary()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithObjectDictionaryWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithIEnumerableSelectListItem()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", MultiSelectListTest.GetSampleIEnumerableObjects() } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.ListBox("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithIEnumerableOfSelectListItemMatchesEnumName()
        {
            // Arrange
            ViewDataDictionary<IEnumerable<EnumWithDisplay?>> vdd = new ViewDataDictionary<IEnumerable<EnumWithDisplay?>>
            {
                { "foo", new EnumWithDisplay?[] { EnumWithDisplay.One, null, EnumWithDisplay.Three, }}
            };
            HtmlHelper<IEnumerable<EnumWithDisplay?>> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html =
                helper.ListBox("foo", GetSelectListWithNamedValuesForEnumWithDisplay(includeEmpty: true));

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\">" +
                "<option selected=\"selected\" value=\"\"></option>" + Environment.NewLine +
                "<option value=\"Zero\">Zero</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"One\">One</option>" + Environment.NewLine +
                "<option value=\"Two\">Two</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"Three\">Three</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithIEnumerableOfSelectListItemMatchesEnumValue()
        {
            // Arrange
            ViewDataDictionary<IEnumerable<EnumWithDisplay?>> vdd = new ViewDataDictionary<IEnumerable<EnumWithDisplay?>>
            {
                { "foo", new EnumWithDisplay?[] { EnumWithDisplay.One, null, EnumWithDisplay.Three, }}
            };
            HtmlHelper<IEnumerable<EnumWithDisplay?>> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html =
                helper.ListBox("foo", GetSelectListWithNumericValuesForEnumWithDisplay(includeEmpty: true));

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\">" +
                "<option selected=\"selected\" value=\"\"></option>" + Environment.NewLine +
                "<option value=\"0\">Zero</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"1\">One</option>" + Environment.NewLine +
                "<option value=\"2\">Two</option>" + Environment.NewLine +
                "<option selected=\"selected\" value=\"3\">Three</option>" + Environment.NewLine +
                "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxThrowsWhenExpressionDoesNotEvaluateToIEnumerable()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", 123456789 } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => helper.ListBox("foo", MultiSelectListTest.GetSampleIEnumerableObjects()),
                "The parameter 'expression' must evaluate to an IEnumerable when multiple selection is allowed."
                );
        }

        [Fact]
        public void ListBoxThrowsWhenExpressionEvaluatesToString()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", "123456789" } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => helper.ListBox("foo", MultiSelectListTest.GetSampleIEnumerableObjects()),
                "The parameter 'expression' must evaluate to an IEnumerable when multiple selection is allowed."
                );
        }

        [Fact]
        public void ListBoxWithListOfSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", new string[] { "123456789", "111111111" } } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.ListBox("foo", MultiSelectListTest.GetSampleListObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithListOfSelectListItem()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary { { "foo", MultiSelectListTest.GetSampleListObjects() } };
            HtmlHelper helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.ListBox("foo");

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.ListBox("foo", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix_foo\" multiple=\"multiple\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.ListBox("", selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix\" multiple=\"multiple\" name=\"MyPrefix\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithPrefixAndNullSelectListUsesViewData()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.ListBox("foo");

            // Assert
            Assert.Equal(
                "<select id=\"MyPrefix_foo\" multiple=\"multiple\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        // ListBoxFor

        [Fact]
        void ListBoxFor_WithGroups()
        {
            // Arrange
            ViewDataDictionary<FooArrayModel> dict = new ViewDataDictionary<FooArrayModel>();
            dict.Add("foo", new[] { "volvo", "audi" });
            HtmlHelper<FooArrayModel> helper = MvcHelper.GetHtmlHelper(dict);
            const string expectedListBox = @"<select id=""foo"" multiple=""multiple"" name=""foo""><option value=""other1"">other1</option>
<option value=""other2"">other2</option>
<optgroup label=""Swedish Cars"">
<option selected=""selected"" value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<option value=""other3"">other3</option>
<optgroup>
<option value=""other4"">other4</option>
<option value=""other5"">other5</option>
</optgroup>
<optgroup label=""German Cars"">
<option value=""mercedes-benz"">Mercedes-Benz</option>
<option disabled=""disabled"" selected=""selected"" value=""audi"">Audi</option>
</optgroup>
<option value=""other6"">other6</option>
</select>";

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, GroupedItems);

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        void ListBoxFor_WithGroups_WithDisabled()
        {
            // Arrange
            ViewDataDictionary<FooArrayModel> dict = new ViewDataDictionary<FooArrayModel>();
            dict.Add("foo", new[] { "a", "d" });
            HtmlHelper<FooArrayModel> helper = MvcHelper.GetHtmlHelper(dict);
            const string expectedListBox = @"<select id=""foo"" multiple=""multiple"" name=""foo""><option selected=""selected"" value=""a"">Alice</option>
<optgroup disabled=""disabled"" label=""DisabledGroup"">
<option value=""b"">Bob</option>
<option value=""c"">Charlie</option>
</optgroup>
<option disabled=""disabled"" selected=""selected"" value=""d"">David</option>
</select>";

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, GroupedItems_WithDisabled);

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        void ListBoxFor_MultiSelectList_WithGroups()
        {
            // Arrange
            ViewDataDictionary<FooArrayModel> dict = new ViewDataDictionary<FooArrayModel>();
            dict.Add("foo", new[] { "mercedes-benz", "audi" });
            HtmlHelper<FooArrayModel> helper = MvcHelper.GetHtmlHelper(dict);
            const string expectedListBox = @"<select id=""foo"" multiple=""multiple"" name=""foo""><option value=""ufo"">UFO</option>
<optgroup label=""Swedish Cars"">
<option value=""volvo"">Volvo</option>
<option value=""saab"">Saab</option>
</optgroup>
<optgroup label=""German Cars"">
<option selected=""selected"" value=""mercedes-benz"">Mercedes-Benz</option>
<option selected=""selected"" value=""audi"">Audi</option>
</optgroup>
<option value=""other"">Other</option>
<optgroup label="" "">
<option value=""unknown"">Unknown</option>
</optgroup>
</select>";

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, _multiSelectList);

            // Assert
            Assert.Equal(expectedListBox, html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.ListBoxFor<FooModel, object>(null, null),
                "expression");
        }

        [Fact]
        public void ListBoxForUsesExplicitValueIfNotProvidedInViewData()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", new[] { "A", "C" });

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForUsesExplicitValueIfNotProvidedInViewData_Unobtrusive()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter", "FullWord", new[] { "A", "C" });

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList);

            // Assert
            Assert.Equal(
                "<select data-val=\"true\" data-val-type=\"error\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        [ReplaceCulture]
        public void ListBoxForWithEnumerableModel_Unobtrusive()
        {
            // Arrange
            HtmlHelper<IEnumerable<RequiredModel>> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<IEnumerable<RequiredModel>>());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleAnonymousObjects(), "Letter",
                "FullWord", new[] { "C" });

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.ElementAt(0).foo, selectList);

            // Assert
            Assert.Equal(
                "<select data-val=\"true\" data-val-required=\"The foo field is required.\" id=\"MyPrefix_foo\" multiple=\"multiple\" name=\"MyPrefix.foo\"><option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForUsesViewDataDefaultValue()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(_listBoxViewData);
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForUsesLambdaDefaultValue()
        {
            // Arrange
            FooArrayModel model = new FooArrayModel { foo = new[] { "Bravo" } };
            HtmlHelper<FooArrayModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooArrayModel>(model));
            SelectList selectList = new SelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForUsesLambdaDefaultValueWithNullSelectListUsesViewData()
        {
            // Arrange
            FooArrayModel model = new FooArrayModel { foo = new[] { "Bravo" } };
            ViewDataDictionary<FooArrayModel> vdd = new ViewDataDictionary<FooArrayModel>(model)
            {
                { "foo", new MultiSelectList(MultiSelectListTest.GetSampleStrings()) }
            };
            HtmlHelper<FooArrayModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList: null);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithErrors()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetViewDataWithErrors());
            MultiSelectList list = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, list);

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetViewDataWithErrors());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList, new { @class = "foo-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error foo-class\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithAttributesDictionary()
        {
            // Arrange
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList, HtmlHelperTest.AttributesDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazValue\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithAttributesDictionaryOverridesName()
        {
            // DevDiv Bugs #217602:
            // SelectInternal() should override the user-provided 'name' attribute

            // Arrange
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList, new { myAttr = "myValue", name = "theName" });

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" myAttr=\"myValue\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithNullSelectListUsesViewData()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            helper.ViewContext.ViewData["foo"] = new MultiSelectList(MultiSelectListTest.GetSampleStrings(), new[] { "Charlie" });

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, null);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithObjectDictionary()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithObjectDictionaryWithUnderscores()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList, HtmlHelperTest.AttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<select foo-baz=\"BazObjValue\" id=\"foo\" multiple=\"multiple\" name=\"foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithIEnumerableSelectListItem()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", MultiSelectListTest.GetSampleIEnumerableObjects() } };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, null);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForThrowsWhenExpressionDoesNotEvaluateToIEnumerable()
        {
            // Arrange
            ViewDataDictionary<NonIEnumerableModel> vdd = new ViewDataDictionary<NonIEnumerableModel> { { "foo", 123456789 } };
            HtmlHelper<NonIEnumerableModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => helper.ListBoxFor(m => m.foo, MultiSelectListTest.GetSampleIEnumerableObjects()),
                "The parameter 'expression' must evaluate to an IEnumerable when multiple selection is allowed."
                );
        }

        [Fact]
        public void ListBoxForThrowsWhenExpressionEvaluatesToString()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", "123456789" } };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => helper.ListBoxFor(m => m.foo, MultiSelectListTest.GetSampleIEnumerableObjects()),
                "The parameter 'expression' must evaluate to an IEnumerable when multiple selection is allowed."
                );
        }

        [Fact]
        public void ListBoxForWithListOfSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", new string[] { "123456789", "111111111" } } };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, MultiSelectListTest.GetSampleListObjects());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithListOfSelectListItem()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", MultiSelectListTest.GetSampleListObjects() } };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, null);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithPrefix()
        {
            // Arrange
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(new ViewDataDictionary<FooModel>());
            MultiSelectList selectList = new MultiSelectList(MultiSelectListTest.GetSampleStrings());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, selectList, HtmlHelperTest.AttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<select baz=\"BazObjValue\" id=\"MyPrefix_foo\" multiple=\"multiple\" name=\"MyPrefix.foo\"><option>Alpha</option>" + Environment.NewLine
              + "<option>Bravo</option>" + Environment.NewLine
              + "<option>Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxForWithPrefixAndListOfSelectListItemSelectsDefaultFromViewData()
        {
            // Arrange
            ViewDataDictionary<FooModel> vdd = new ViewDataDictionary<FooModel> { { "foo", new string[] { "123456789", "111111111" } } };
            HtmlHelper<FooModel> helper = MvcHelper.GetHtmlHelper(vdd);
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.ListBoxFor(m => m.foo, MultiSelectListTest.GetSampleListObjects());

            // Assert
            Assert.Equal(
                "<select id=\"MyPrefix_foo\" multiple=\"multiple\" name=\"MyPrefix.foo\"><option selected=\"selected\" value=\"123456789\">John</option>" + Environment.NewLine
              + "<option value=\"987654321\">Jane</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"111111111\">Joe</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        // Culture tests

        [Fact]
        [ReplaceCulture]
        public void SelectHelpersUseCurrentCultureToConvertValues()
        {
            // Arrange
            HtmlHelper defaultValueHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary
            {
                { "foo", new[] { new DateTime(1900, 1, 1, 0, 0, 1) } },
                { "bar", new DateTime(1900, 1, 1, 0, 0, 1) }
            });
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            SelectList selectList = new SelectList(GetSampleCultureAnonymousObjects(), "Date", "FullWord", new DateTime(1900, 1, 1, 0, 0, 0));

            var tests = new[]
            {
                // DropDownList(name, selectList, optionLabel)
                new
                {
                    Html = "<select id=\"foo\" name=\"foo\"><option selected=\"selected\" value=\"01/01/1900 00:00:00\">Alpha</option>" + Environment.NewLine
                         + "<option value=\"01/01/1900 00:00:01\">Bravo</option>" + Environment.NewLine
                         + "<option value=\"01/01/1900 00:00:02\">Charlie</option>" + Environment.NewLine
                         + "</select>",
                    Action = new Func<MvcHtmlString>(() => helper.DropDownList("foo", selectList, (string)null))
                },
                // DropDownList(name, selectList, optionLabel) (With default value selected from ViewData)
                new
                {
                    Html = "<select id=\"bar\" name=\"bar\"><option value=\"01/01/1900 00:00:00\">Alpha</option>" + Environment.NewLine
                         + "<option selected=\"selected\" value=\"01/01/1900 00:00:01\">Bravo</option>" + Environment.NewLine
                         + "<option value=\"01/01/1900 00:00:02\">Charlie</option>" + Environment.NewLine
                         + "</select>",
                    Action = new Func<MvcHtmlString>(() => defaultValueHelper.DropDownList("bar", selectList, (string)null))
                },
                // ListBox(name, selectList)
                new
                {
                    Html = "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option selected=\"selected\" value=\"01/01/1900 00:00:00\">Alpha</option>" + Environment.NewLine
                         + "<option value=\"01/01/1900 00:00:01\">Bravo</option>" + Environment.NewLine
                         + "<option value=\"01/01/1900 00:00:02\">Charlie</option>" + Environment.NewLine
                         + "</select>",
                    Action = new Func<MvcHtmlString>(() => helper.ListBox("foo", selectList))
                },
                // ListBox(name, selectList) (With default value selected from ViewData)
                new
                {
                    Html = "<select id=\"foo\" multiple=\"multiple\" name=\"foo\"><option value=\"01/01/1900 00:00:00\">Alpha</option>" + Environment.NewLine
                         + "<option selected=\"selected\" value=\"01/01/1900 00:00:01\">Bravo</option>" + Environment.NewLine
                         + "<option value=\"01/01/1900 00:00:02\">Charlie</option>" + Environment.NewLine
                         + "</select>",
                    Action = new Func<MvcHtmlString>(() => defaultValueHelper.ListBox("foo", selectList))
                }
            };

            // Act && Assert
            foreach (var test in tests)
            {
                Assert.Equal(test.Html, test.Action().ToHtmlString());
            }
        }

        // Helpers

        // Value and Text is constant name in all returned SelectListItem objects.
        private static IEnumerable<SelectListItem> GetSelectListWithNamedValuesForEnumWithDisplay(bool includeEmpty)
        {
            IList<SelectListItem> selectList = new List<SelectListItem>();
            if (includeEmpty)
            {
                // Similar to what we might generate for a Nullable<T>
                selectList.Add(new SelectListItem { Text = String.Empty, Value = String.Empty, });
            }

            foreach (string name in Enum.GetNames(typeof(EnumWithDisplay)))
            {
                selectList.Add(new SelectListItem { Text = name, Value = name, });
            }

            return selectList;
        }

        // Value is numeric value while Text is constant name in all returned SelectListItem objects.
        private static IEnumerable<SelectListItem> GetSelectListWithNumericValuesForEnumWithDisplay(bool includeEmpty)
        {
            IList<SelectListItem> selectList = new List<SelectListItem>();
            if (includeEmpty)
            {
                // Similar to what we might generate for a Nullable<T>
                selectList.Add(new SelectListItem { Text = String.Empty, Value = String.Empty, });
            }

            foreach (FieldInfo field in typeof(EnumWithDisplay).GetFields(
                BindingFlags.DeclaredOnly | BindingFlags.GetField | BindingFlags.Public | BindingFlags.Static))
            {
                string name = field.Name;
                object value = field.GetRawConstantValue();
                selectList.Add(new SelectListItem { Text = name, Value = value.ToString(), });
            }

            return selectList;
        }

        private class FooContainerModel
        {
            public FooModel inner { get; set; }
        }
        private class FooModel
        {
            public string foo { get; set; }
        }

        private class FooBarModel : FooModel
        {
            public string bar { get; set; }
        }

        private class FooArrayModel
        {
            public string[] foo { get; set; }
        }

        private class NonIEnumerableModel
        {
            public int foo { get; set; }
        }

        private static ViewDataDictionary<FooBarModel> GetViewDataWithErrors()
        {
            ViewDataDictionary<FooBarModel> viewData = new ViewDataDictionary<FooBarModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new FooBarModel { foo = "ViewItemFoo", bar = "ViewItemBar" };

            ModelState modelStateFoo = new ModelState();
            modelStateFoo.Errors.Add(new ModelError("foo error 1"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            viewData.ModelState["foo"] = modelStateFoo;
            modelStateFoo.Value = new ValueProviderResult(new string[] { "Bravo", "Charlie" }, "Bravo", CultureInfo.InvariantCulture);

            return viewData;
        }

        internal static IEnumerable GetSampleCultureAnonymousObjects()
        {
            return new[]
            {
                new { Date = new DateTime(1900, 1, 1, 0, 0, 0), FullWord = "Alpha" },
                new { Date = new DateTime(1900, 1, 1, 0, 0, 1), FullWord = "Bravo" },
                new { Date = new DateTime(1900, 1, 1, 0, 0, 2), FullWord = "Charlie" }
            };
        }

        private class RequiredModel
        {
            [Required]
            public string foo { get; set; }
        }

        private class EnumModel
        {
            public EnumWithDisplay WithDisplay { get; set; }
            public EnumWithDuplicates WithDuplicates { get; set; }
            public EnumWithFlags WithFlags { get; set; }
            public EnumWithDisplay? WithNullable { get; set; }
            public EnumWithoutAnything WithoutAnything { get; set; }
        }

        // enum definitions

        private enum EnumWithDisplay : byte
        {
            [Display(Name = "First")]
            Zero,
            [Display(Name = "Second")]
            One,
            [Display(Name = "Third")]
            Two,
            [Display(Name = "Fourth")]
            Three,
        }

        private enum EnumWithDuplicates : byte
        {
            First,
            Second,
            Third = 1,
            Fourth,
        }

        private enum EnumWithoutAnything : byte
        {
        }

        [Flags]
        private enum EnumWithFlags : byte
        {
            First = 1,
            Second = 2,
            Third = 4,
            Fourth = 8,
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ViewContext.ClientValidationEnabled) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/TemplateHelpersSafeScope.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.WebPages.Scope;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    /// <summary>
    /// A scope within which it is safe to invoke <see cref="TemplateHelpers"/> methods. For example
    /// <see cref="TemplateHelpers.ExecuteTemplate()"/> invokes <code>ViewEngines.Engines.FindPartialView()</code> and
    /// clones the current <see cref="ViewContext"/>.
    /// </summary>
    /// <remarks>Similar to TemplateHelpersTest.MockViewEngine but FindPartialView() succeed there and fail here. In
    /// addition TemplateHelpersTest tests do not continue far enough to need the transient scope.
    /// </remarks>
    public class TemplateHelpersSafeScope : IDisposable
    {
        private readonly List<IViewEngine> _oldEngines;
        private IDisposable _transientScope;

        public TemplateHelpersSafeScope()
        {
            // Copying an HtmlHelper instance reads and writes the current StorageScope.
            // Ensure that's not the global scope.
            _transientScope = ScopeStorage.CreateTransientScope();

            // Do not want templates to check disk for anything.
            var engine = new Mock<IViewEngine>(MockBehavior.Strict);
            engine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), It.IsAny<string>(), It.IsAny<bool>()))
                .Returns(new ViewEngineResult(Enumerable.Empty<string>()));

            _oldEngines = ViewEngines.Engines.ToList();
            ViewEngines.Engines.Clear();
            ViewEngines.Engines.Add(engine.Object);
        }

        public void Dispose()
        {
            ViewEngines.Engines.Clear();
            foreach (var oldEngine in _oldEngines)
            {
                ViewEngines.Engines.Add(oldEngine);
            }

            using (_transientScope)
            {
                _transientScope = null;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/TemplateHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Threading;
using System.Web.Routing;
using System.Web.UI.WebControls;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class TemplateHelpersTest
    {
        // ExecuteTemplate

        private class ExecuteTemplateModel
        {
            public string MyProperty { get; set; }
            public Nullable<int> MyNullableProperty { get; set; }
        }

        [Fact]
        public void ExecuteTemplateCallsGetViewNamesWithProvidedTemplateNameAndMetadataInformation()
        {
            using (new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel());
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                metadata.TemplateHint = "templateHint";
                metadata.DataTypeName = "dataType";
                string[] hints = null;

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, MakeViewData(html, metadata), "templateName", DataBoundControlMode.ReadOnly,
                    (_metadata, _hints) =>
                    {
                        hints = _hints;
                        return new[] { "String" };
                    },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                Assert.NotNull(hints);
                Assert.Equal(3, hints.Length);
                Assert.Equal("templateName", hints[0]);
                Assert.Equal("templateHint", hints[1]);
                Assert.Equal("dataType", hints[2]);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromViewEngineInReadOnlyMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewContext callbackViewContext = null;
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "DisplayTemplates/String", true))
                    .Returns(new ViewEngineResult(engine.View.Object, engine.Engine.Object))
                    .Verifiable();
                engine.View.Setup(v => v.Render(It.IsAny<ViewContext>(), It.IsAny<TextWriter>()))
                    .Callback<ViewContext, TextWriter>((vc, tw) =>
                    {
                        callbackViewContext = vc;
                        tw.Write("View Text");
                    })
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.ReadOnly,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                engine.View.Verify();
                Assert.Equal("View Text", result);
                Assert.Same(engine.View.Object, callbackViewContext.View);
                Assert.Same(viewData, callbackViewContext.ViewData);
                Assert.Same(html.ViewContext.TempData, callbackViewContext.TempData);
                TemplateHelpers.ActionCacheViewItem cacheItem = TemplateHelpers.GetActionCache(html)["DisplayTemplates/String"] as TemplateHelpers.ActionCacheViewItem;
                Assert.NotNull(cacheItem);
                Assert.Equal("DisplayTemplates/String", cacheItem.ViewName);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromViewEngineInEditMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewContext callbackViewContext = null;
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "EditorTemplates/String", true))
                    .Returns(new ViewEngineResult(engine.View.Object, engine.Engine.Object))
                    .Verifiable();
                engine.View.Setup(v => v.Render(It.IsAny<ViewContext>(), It.IsAny<TextWriter>()))
                    .Callback<ViewContext, TextWriter>((vc, tw) =>
                    {
                        callbackViewContext = vc;
                        tw.Write("View Text");
                    })
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                engine.View.Verify();
                Assert.Equal("View Text", result);
                Assert.Same(engine.View.Object, callbackViewContext.View);
                Assert.Same(viewData, callbackViewContext.ViewData);
                Assert.Same(html.ViewContext.TempData, callbackViewContext.TempData);
                TemplateHelpers.ActionCacheViewItem cacheItem = TemplateHelpers.GetActionCache(html)["EditorTemplates/String"] as TemplateHelpers.ActionCacheViewItem;
                Assert.NotNull(cacheItem);
                Assert.Equal("EditorTemplates/String", cacheItem.ViewName);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromDefaultActionsInReadOnlyMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "DisplayTemplates/String", It.IsAny<bool>()))
                    .Returns(new ViewEngineResult(new string[0]))
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.ReadOnly,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                TemplateHelpers.ActionCacheCodeItem cacheItem = TemplateHelpers.GetActionCache(html)["DisplayTemplates/String"] as TemplateHelpers.ActionCacheCodeItem;
                Assert.NotNull(cacheItem);
                Assert.Equal(DefaultDisplayTemplates.StringTemplate, cacheItem.Action);
            }
        }

        [Fact]
        public void ExecuteTemplateUsesViewFromDefaultActionsInEditMode()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                engine.Engine.Setup(e => e.FindPartialView(html.ViewContext, "EditorTemplates/String", It.IsAny<bool>()))
                    .Returns(new ViewEngineResult(new string[0]))
                    .Verifiable();
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                TemplateHelpers.ActionCacheCodeItem cacheItem = TemplateHelpers.GetActionCache(html)["EditorTemplates/String"] as TemplateHelpers.ActionCacheCodeItem;
                Assert.NotNull(cacheItem);
                Assert.Equal(DefaultEditorTemplates.StringTemplate, cacheItem.Action);
            }
        }

        [Fact]
        public void ExecuteTemplatePrefersExistingActionCacheItem()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);
                TemplateHelpers.GetActionCache(html).Add("EditorTemplates/String",
                                                         new TemplateHelpers.ActionCacheCodeItem { Action = _ => "Action Text" });

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                engine.Engine.Verify();
                engine.Engine.Verify(e => e.FindPartialView(It.IsAny<ControllerContext>(), It.IsAny<string>(), It.IsAny<bool>()), Times.Never());
                Assert.Equal("Action Text", result);
            }
        }

        [Fact]
        public void ExecuteTemplateThrowsWhenNoTemplatesMatch()
        {
            using (new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);

                // Act & Assert
                Assert.Throws<InvalidOperationException>(
                    () => TemplateHelpers.ExecuteTemplate(html, viewData, "templateName", DataBoundControlMode.Edit, delegate { return new string[0]; }, TemplateHelpers.GetDefaultActions),
                    "Unable to locate an appropriate template for type System.String.");
            }
        }

        [Fact]
        public void ExecuteTemplateCreatesNewHtmlHelperWithCorrectViewDataForDefaultAction()
        {
            using (MockViewEngine engine = new MockViewEngine(false))
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);
                HtmlHelper passedHtmlHelper = null;

                // Act
                TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    delegate
                    {
                        return new Dictionary<string, Func<HtmlHelper, string>>
                        {
                            {
                                "String", _htmlHelper =>
                                {
                                    passedHtmlHelper = _htmlHelper;
                                    return "content";
                                }
                                }
                        };
                    });

                // Assert
                Assert.NotNull(passedHtmlHelper);
                Assert.Same(passedHtmlHelper.ViewData, passedHtmlHelper.ViewContext.ViewData);
                Assert.NotSame(html.ViewData, passedHtmlHelper.ViewData);
            }
        }

        [Fact]
        public void ExecuteTemplateCreatesNewHtmlHelperWithCorrectViewDataForCachedAction()
        {
            using (MockViewEngine engine = new MockViewEngine())
            {
                // Arrange
                HtmlHelper html = MakeHtmlHelper(new ExecuteTemplateModel { MyProperty = "Hello" });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                ViewDataDictionary viewData = MakeViewData(html, metadata);
                HtmlHelper passedHtmlHelper = null;
                TemplateHelpers.GetActionCache(html).Add(
                    "EditorTemplates/String",
                    new TemplateHelpers.ActionCacheCodeItem
                    {
                        Action = _htmlHelper =>
                        {
                            passedHtmlHelper = _htmlHelper;
                            return "content";
                        }
                    });

                // Act
                string result = TemplateHelpers.ExecuteTemplate(
                    html, viewData, "templateName", DataBoundControlMode.Edit,
                    delegate { return new[] { "String" }; },
                    TemplateHelpers.GetDefaultActions);

                // Assert
                Assert.NotNull(passedHtmlHelper);
                Assert.Same(passedHtmlHelper.ViewData, passedHtmlHelper.ViewContext.ViewData);
                Assert.NotSame(html.ViewData, passedHtmlHelper.ViewData);
            }
        }

        // GetActionCache

        [Fact]
        public void CacheIsCreatedIfNotPresent()
        {
            // Arrange
            Hashtable items = new Hashtable();
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Items).Returns(items);
            Mock<ViewContext> viewContext = new Mock<ViewContext>();
            viewContext.Setup(c => c.HttpContext).Returns(context.Object);
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            HtmlHelper helper = new HtmlHelper(viewContext.Object, viewDataContainer.Object);

            // Act
            Dictionary<string, TemplateHelpers.ActionCacheItem> cache = TemplateHelpers.GetActionCache(helper);

            // Assert
            Assert.NotNull(cache);
            Assert.Empty(cache);
            Assert.Contains((object)cache, items.Values.OfType<object>());
        }

        [Fact]
        public void CacheIsReusedIfPresent()
        {
            // Arrange
            Hashtable items = new Hashtable();
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Items).Returns(items);
            Mock<ViewContext> viewContext = new Mock<ViewContext>();
            viewContext.Setup(c => c.HttpContext).Returns(context.Object);
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            HtmlHelper helper = new HtmlHelper(viewContext.Object, viewDataContainer.Object);

            // Act
            Dictionary<string, TemplateHelpers.ActionCacheItem> cache1 = TemplateHelpers.GetActionCache(helper);
            Dictionary<string, TemplateHelpers.ActionCacheItem> cache2 = TemplateHelpers.GetActionCache(helper);

            // Assert
            Assert.NotNull(cache1);
            Assert.Same(cache1, cache2);
        }

        // GetViewNames

        // Sample value types; some special cases below as well e.g. GetViewNamesFullOrderingOfString()
        [Theory]
        [InlineData(typeof(bool), "Boolean")]
        [InlineData(typeof(byte), "Byte")]
        [InlineData(typeof(char), "Char")]
        [InlineData(typeof(DateTime), "DateTime")]
        [InlineData(typeof(decimal), "Decimal")]
        [InlineData(typeof(double), "Double")]
        [InlineData(typeof(float), "Single")]
        [InlineData(typeof(Guid), "Guid")]
        [InlineData(typeof(TimeSpan), "TimeSpan")]
        [InlineData(typeof(int), "Int32")]
        [InlineData(typeof(ulong), "UInt64")]
        public void GetViewNamesFullOrderingOfBuiltInValueType(Type type, string expectedTypeName)
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, type);

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(4, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal(expectedTypeName, result[2]);
            Assert.Equal("String", result[3]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfComplexType()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(HttpWebRequest));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(6, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("HttpWebRequest", result[2]);
            Assert.Equal("WebRequest", result[3]);
            Assert.Equal("MarshalByRefObject", result[4]);
            Assert.Equal("Object", result[5]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfInterface()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IDisposable));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(4, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("IDisposable", result[2]);
            Assert.Equal("Object", result[3]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfComplexTypeThatImplementsIEnumerable()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(List<int>));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(5, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("List`1", result[2]);
            Assert.Equal("Collection", result[3]);
            Assert.Equal("Object", result[4]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfInterfaceThatRequiresIEnumerable()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IList<int>));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(5, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("IList`1", result[2]);
            Assert.Equal("Collection", result[3]);
            Assert.Equal("Object", result[4]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfString()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(String));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(3, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("String", result[2]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfEnumStruct()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(StringSplitOptions));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(5, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("StringSplitOptions", result[2]);
            Assert.Equal("Enum", result[3]);
            Assert.Equal("String", result[4]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfEnumType()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Enum));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(4, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("Enum", result[2]);
            Assert.Equal("String", result[3]);
        }

        [Fact]
        public void GetViewNamesFullOrderingOfDateTimeOffset()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(DateTimeOffset));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", "DataType").ToList();

            // Assert
            Assert.Equal(5, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("DataType", result[1]);
            Assert.Equal("DateTimeOffset", result[2]);
            Assert.Equal("DateTime", result[3]);
            Assert.Equal("String", result[4]);
        }

        [Fact]
        public void GetViewNamesNullUIHintNotIncludedInList()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Object));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, null, "DataType").ToList();

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("DataType", result[0]);
            Assert.Equal("Object", result[1]);
        }

        [Fact]
        public void GetViewNamesNullDataTypeNotIncludedInList()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Object));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, "UIHint", null).ToList();

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("UIHint", result[0]);
            Assert.Equal("Object", result[1]);
        }

        [Fact]
        public void GetViewNamesConvertsNullableOfTIntoT()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Nullable<int>));

            // Act
            List<string> result = TemplateHelpers.GetViewNames(metadata, null, null).ToList();

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("Int32", result[0]);
            Assert.Equal("String", result[1]);
        }

        // Template

        private class TemplateModel
        {
            public object MyProperty { get; set; }
        }

        [Fact]
        public void TemplateNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => TemplateHelpers.Template(html, null, "templateName", "htmlFieldName", DataBoundControlMode.ReadOnly,
                                               null /* additionalViewData */, TemplateHelperSpy),
                "expression");
        }

        [Fact]
        public void TemplateDataNotFound()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);

            // Act
            string result = TemplateHelpers.Template(html, "UnknownObject", "templateName", null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = (null), HtmlFieldName = UnknownObject, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateHtmlFieldNameReplacesExpression()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);

            // Act
            string result = TemplateHelpers.Template(html, "UnknownObject", "templateName", "htmlFieldName", DataBoundControlMode.ReadOnly,
                                                     new { foo = "Bar" }, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = (null), HtmlFieldName = htmlFieldName, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = { foo: Bar }", result);
        }

        [Fact]
        public void TemplateDataFoundInViewDataDictionaryHasNoPropertyName()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);
            html.ViewContext.ViewData["Key"] = 42;

            // Act
            string result = TemplateHelpers.Template(html, "Key", null, null, DataBoundControlMode.Edit, null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = 42, ModelType = System.Int32, RealModelType = System.Int32, PropertyName = (null), HtmlFieldName = Key, TemplateName = (null), Mode = Edit, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateDataFoundInViewDataDictionarySubPropertyHasPropertyName()
        {
            // Arrange
            HtmlHelper<object> html = MakeHtmlHelper<object>(null);
            html.ViewContext.ViewData["Key"] = new TemplateModel { MyProperty = "Hello!" };

            // Act
            string result = TemplateHelpers.Template(html, "Key.MyProperty", null, null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = Key.MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateDataFoundInModelHasPropertyName()
        {
            // Arrange
            HtmlHelper<TemplateModel> html = MakeHtmlHelper<TemplateModel>(new TemplateModel { MyProperty = "Hello!" });

            // Act
            string result = TemplateHelpers.Template(html, "MyProperty", null, null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateNullDataFoundInModelHasPropertyTypeInsteadOfActualModelType()
        {
            // Arrange
            HtmlHelper<TemplateModel> html = MakeHtmlHelper<TemplateModel>(new TemplateModel());

            // Act
            string result = TemplateHelpers.Template(html, "MyProperty", null, null, DataBoundControlMode.ReadOnly,
                                                     null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Object, RealModelType = System.Object, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        // TemplateFor

        private class TemplateForModel
        {
            public int MyField = 0;
            public object MyProperty { get; set; }
            public Nullable<int> MyNullableProperty { get; set; }
        }

        [Fact]
        public void TemplateForNonUnsupportedExpressionTypeThrows()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper<TemplateForModel>(null);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => TemplateHelpers.TemplateFor(html, model => new Object(), "templateName", "htmlFieldName", DataBoundControlMode.ReadOnly,
                                                  null /* additionalViewData */, TemplateHelperSpy),
                "Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.");
        }

        [Fact]
        public void TemplateForWithNonNullExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyProperty = "Hello!" });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, "templateName", null, DataBoundControlMode.ReadOnly,
                                                        new { foo = "Bar" }, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = { foo: Bar }", result);
        }

        [Fact]
        public void TemplateForHtmlFieldNameReplacesExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyProperty = "Hello!" });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, "templateName", "htmlFieldName",
                                                        DataBoundControlMode.ReadOnly, null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = Hello!, ModelType = System.Object, RealModelType = System.String, PropertyName = MyProperty, HtmlFieldName = htmlFieldName, TemplateName = templateName, Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullModelStillRetainsTypeInformation()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper<TemplateForModel>(null);

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Object, RealModelType = System.Object, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullPropertyStillRetainsTypeInformation()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel());

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Object, RealModelType = System.Object, PropertyName = MyProperty, HtmlFieldName = MyProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullableValueTYpePropertyRetainsNullableValueTYpeForNullPropertyValue()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel());

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyNullableProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], RealModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = MyNullableProperty, HtmlFieldName = MyNullableProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForNullableValueTypePropertyRetainsNullableValueTypeForNonNullPropertyValue()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyNullableProperty = 42 });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyNullableProperty, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = 42, ModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], RealModelType = System.Nullable`1[[System.Int32, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]], PropertyName = MyNullableProperty, HtmlFieldName = MyNullableProperty, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForWithParameterExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel());

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = System.Web.Mvc.Html.Test.TemplateHelpersTest+TemplateForModel, ModelType = System.Web.Mvc.Html.Test.TemplateHelpersTest+TemplateForModel, RealModelType = System.Web.Mvc.Html.Test.TemplateHelpersTest+TemplateForModel, PropertyName = (null), HtmlFieldName = (empty), TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        [Fact]
        public void TemplateForWithFieldExpression()
        {
            // Arrange
            HtmlHelper<TemplateForModel> html = MakeHtmlHelper(new TemplateForModel { MyField = 42 });

            // Act
            string result = TemplateHelpers.TemplateFor(html, model => model.MyField, null, null, DataBoundControlMode.ReadOnly,
                                                        null /* additionalViewData */, TemplateHelperSpy);

            // Assert
            Assert.Equal("Model = 42, ModelType = System.Int32, RealModelType = System.Int32, PropertyName = (null), HtmlFieldName = MyField, TemplateName = (null), Mode = ReadOnly, AdditionalViewData = (null)", result);
        }

        // TemplateHelper

        private class TemplateHelperModel
        {
            public string MyProperty { get; set; }
        }

        [Fact]
        public void TemplateHelperNonNullNonEmptyStringModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = Hello, ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = Hello, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperEmptyStringModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.ConvertEmptyStringToNull = false;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = , ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperConvertsEmptyStringsToNull()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.ConvertEmptyStringToNull = true;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperConvertsNullModelsToNullDisplayTextInReadOnlyMode()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.NullDisplayText = "NullDisplayText";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = NullDisplayText, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperDoesNotConvertNullModelsToNullDisplayTextInEditMode()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.NullDisplayText = "NullDisplayText";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.Edit,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = Edit", result);
        }

        [Fact]
        public void TemplateHelperAppliesDisplayFormatStringInReadOnlyMode()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.DisplayFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = Hello, ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = Hello world!, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperDoesNotApplyDisplayFormatStringInReadOnlyModeForNullModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.DisplayFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
        }

        [Fact]
        public void TemplateHelperAppliesEditFormatStringInEditMode()
        {
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.EditFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.Edit,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = Hello, ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = Hello world!, HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = Edit", result);
        }

        [Fact]
        public void TemplateHelperDoesNotApplyEditFormatStringInEditModeForNullModel()
        {
            // Arrange
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            metadata.EditFormatString = "{0} world!";

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.Edit,
                                                           null /* additionalViewData */, ExecuteTemplateSpy);

            // Assert
            Assert.Equal("Model = (null), ModelType = System.String, RealModelType = System.String, PropertyName = MyProperty, FormattedModelValue = , HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = Edit", result);
        }

        [Fact]
        public void TemplateHelperAddsNonNullModelToVisitedObjects()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary viewData = null;

            // Act
            TemplateHelpers.TemplateHelper(
                html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */,
                (_html, _viewData, _templateName, _mode, _getViews, _getDefaultActions) =>
                {
                    viewData = _viewData;
                    return String.Empty;
                });

            // Assert
            Assert.NotNull(viewData);
            Assert.Contains("Hello", viewData.TemplateInfo.VisitedObjects);
        }

        [Fact]
        public void TemplateHelperAddsNullModelsTypeToVisitedObjects()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary viewData = null;

            // Act
            TemplateHelpers.TemplateHelper(
                html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly, null /* additionalViewData */,
                (_html, _viewData, _templateName, _mode, _getViews, _getDefaultActions) =>
                {
                    viewData = _viewData;
                    return String.Empty;
                });

            // Assert
            Assert.NotNull(viewData);
            Assert.Contains(typeof(string), viewData.TemplateInfo.VisitedObjects);
        }

        [Fact]
        public void TemplateHelperReturnsEmptyStringForAlreadyVisitedObject()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel { MyProperty = "Hello" });
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            html.ViewData.TemplateInfo.VisitedObjects.Add("Hello");

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void TemplateHelperReturnsEmptyStringForAlreadyVisitedType()
        { // DDB #224750
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            html.ViewData.TemplateInfo.VisitedObjects.Add(typeof(string));

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void TemplateHelperPreservesSameInstanceOfModelMetadata()
        { // DDB #225858
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary callbackViewData = null;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */,
                                                           (_html, _viewData, _templateName, _mode, _getViewNames, _getDefaultActions) =>
                                                           {
                                                               callbackViewData = _viewData;
                                                               return String.Empty;
                                                           });

            // Assert
            Assert.NotNull(callbackViewData);
            Assert.Same(metadata, callbackViewData.ModelMetadata);
        }

        [Fact]
        public void TemplateHelperFormatsValuesUsingCurrentCulture()
        {
            CultureInfo existingCulture = Thread.CurrentThread.CurrentCulture;

            try
            {
                // Arrange
                Thread.CurrentThread.CurrentCulture = CultureInfo.GetCultureInfo("es-MX");
                HtmlHelper html = MakeHtmlHelper(new { MyProperty = new DateTime(2009, 11, 18, 16, 12, 8, DateTimeKind.Utc) });
                ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
                metadata.DisplayFormatString = "{0:F}";

                // Act
                string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                               null /* additionalViewData */, ExecuteTemplateSpy);

                // Assert
                Assert.Equal("Model = 18/11/2009 04:12:08 p. m., ModelType = System.DateTime, RealModelType = System.DateTime, PropertyName = MyProperty, FormattedModelValue = miércoles, 18 de noviembre de 2009 04:12:08 p. m., HtmlFieldPrefix = FieldPrefix.htmlFieldName, TemplateName = templateName, Mode = ReadOnly", result);
            }
            finally
            {
                Thread.CurrentThread.CurrentCulture = existingCulture;
            }
        }

        [Fact]
        public void TemplateHelperPreservesExistingViewData()
        {
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            html.ViewData["Foo"] = "Bar";
            html.ViewData["Baz"] = 42;
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary callbackViewData = null;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           null /* additionalViewData */,
                                                           (_html, _viewData, _templateName, _mode, _getViewNames, _getDefaultActions) =>
                                                           {
                                                               callbackViewData = _viewData;
                                                               return String.Empty;
                                                           });

            // Assert
            Assert.NotSame(html.ViewData, callbackViewData);
            Assert.Equal(2, callbackViewData.Count);
            Assert.Equal("Bar", callbackViewData["Foo"]);
            Assert.Equal(42, callbackViewData["Baz"]);
        }

        [Fact]
        public void TemplateHelperMergesAdditionalViewData()
        {
            HtmlHelper html = MakeHtmlHelper(new TemplateHelperModel());
            html.ViewData["Foo"] = "Bar";
            html.ViewData["Baz"] = 42;
            ModelMetadata metadata = ModelMetadata.FromStringExpression("MyProperty", html.ViewData);
            ViewDataDictionary callbackViewData = null;

            // Act
            string result = TemplateHelpers.TemplateHelper(html, metadata, "htmlFieldName", "templateName", DataBoundControlMode.ReadOnly,
                                                           new { foo = "New Foo", hello = "World!" },
                                                           (_html, _viewData, _templateName, _mode, _getViewNames, _getDefaultActions) =>
                                                           {
                                                               callbackViewData = _viewData;
                                                               return String.Empty;
                                                           });

            // Assert
            Assert.NotSame(html.ViewData, callbackViewData);
            Assert.Equal(3, callbackViewData.Count);
            Assert.Equal("New Foo", callbackViewData["Foo"]);
            Assert.Equal(42, callbackViewData["Baz"]);
            Assert.Equal("World!", callbackViewData["Hello"]);
        }

        // Helpers

        private static string ExecuteTemplateSpy(HtmlHelper html, ViewDataDictionary viewData, string templateName, DataBoundControlMode mode,
                                                 TemplateHelpers.GetViewNamesDelegate getViewNames, TemplateHelpers.GetDefaultActionsDelegate getDefaultActions)
        {
            Assert.Same(viewData.Model, viewData.ModelMetadata.Model);
            Assert.Equal<TemplateHelpers.GetViewNamesDelegate>(TemplateHelpers.GetViewNames, getViewNames);
            Assert.Equal<TemplateHelpers.GetDefaultActionsDelegate>(TemplateHelpers.GetDefaultActions, getDefaultActions);

            return String.Format("Model = {0}, ModelType = {1}, RealModelType = {2}, PropertyName = {3}, FormattedModelValue = {4}, HtmlFieldPrefix = {5}, TemplateName = {6}, Mode = {7}",
                                 viewData.ModelMetadata.Model ?? "(null)",
                                 viewData.ModelMetadata.ModelType == null ? "(null)" : viewData.ModelMetadata.ModelType.FullName,
                                 viewData.ModelMetadata.RealModelType == null ? "(null)" : viewData.ModelMetadata.RealModelType.FullName,
                                 viewData.ModelMetadata.PropertyName ?? "(null)",
                                 viewData.TemplateInfo.FormattedModelValue ?? "(null)",
                                 viewData.TemplateInfo.HtmlFieldPrefix == "" ? "(empty)" : viewData.TemplateInfo.HtmlFieldPrefix ?? "(null)",
                                 templateName ?? "(null)",
                                 mode);
        }

        private static string TemplateHelperSpy(HtmlHelper html, ModelMetadata metadata, string htmlFieldName, string templateName, DataBoundControlMode mode,
                                                object additionalViewData)
        {
            return String.Format("Model = {0}, ModelType = {1}, RealModelType = {2}, PropertyName = {3}, HtmlFieldName = {4}, TemplateName = {5}, Mode = {6}, AdditionalViewData = {7}",
                                 metadata.Model ?? "(null)",
                                 metadata.ModelType == null ? "(null)" : metadata.ModelType.FullName,
                                 metadata.RealModelType == null ? "(null)" : metadata.RealModelType.FullName,
                                 metadata.PropertyName ?? "(null)",
                                 htmlFieldName == String.Empty ? "(empty)" : htmlFieldName ?? "(null)",
                                 templateName ?? "(null)",
                                 mode,
                                 AnonymousObject.Inspect(additionalViewData));
        }

        private HtmlHelper<TModel> MakeHtmlHelper<TModel>(TModel model)
        {
            return MakeHtmlHelper<TModel>(model, model);
        }

        private HtmlHelper<TModel> MakeHtmlHelper<TModel>(TModel model, object formattedModelValue)
        {
            ViewDataDictionary viewData = new ViewDataDictionary(model);
            viewData.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";
            viewData.TemplateInfo.FormattedModelValue = formattedModelValue;
            viewData.ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(TModel));

            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>();
            httpContext.Setup(c => c.Items).Returns(new Hashtable());

            Mock<ViewContext> viewContext = new Mock<ViewContext> { CallBase = true };
            viewContext.Setup(c => c.View).Returns(new DummyView());
            viewContext.Setup(c => c.ViewData).Returns(viewData);
            viewContext.Setup(c => c.HttpContext).Returns(httpContext.Object);
            viewContext.Setup(c => c.RouteData).Returns(new RouteData());
            viewContext.Setup(c => c.TempData).Returns(new TempDataDictionary());
            viewContext.Setup(c => c.Writer).Returns(TextWriter.Null);

            return new HtmlHelper<TModel>(viewContext.Object, new SimpleViewDataContainer(viewData));
        }

        private ViewDataDictionary MakeViewData(HtmlHelper html, ModelMetadata metadata)
        {
            return new ViewDataDictionary(html.ViewDataContainer.ViewData)
            {
                Model = metadata.Model,
                ModelMetadata = metadata,
                TemplateInfo = new TemplateInfo
                {
                    FormattedModelValue = metadata.Model,
                    HtmlFieldPrefix = "FieldPrefix",
                }
            };
        }

        private class DummyView : IView
        {
            public void Render(ViewContext viewContext, TextWriter writer)
            {
                throw new NotImplementedException();
            }
        }

        private class MockViewEngine : IDisposable
        {
            List<IViewEngine> oldEngines;

            public MockViewEngine(bool returnView = true)
            {
                oldEngines = ViewEngines.Engines.ToList();

                View = new Mock<IView>();

                Engine = new Mock<IViewEngine>();

                Engine.Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), It.IsAny<string>(), It.IsAny<bool>()))
                    .Returns(returnView ? new ViewEngineResult(View.Object, Engine.Object) : new ViewEngineResult(new string[0]));

                ViewEngines.Engines.Clear();
                ViewEngines.Engines.Add(Engine.Object);
            }

            public void Dispose()
            {
                ViewEngines.Engines.Clear();

                foreach (IViewEngine engine in oldEngines)
                {
                    ViewEngines.Engines.Add(engine);
                }
            }

            public Mock<IViewEngine> Engine { get; set; }

            public Mock<IView> View { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/TextAreaExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Test;
using System.Web.Routing;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class TextAreaExtensionsTest : IDisposable
    {
        private static readonly RouteValueDictionary _textAreaAttributesDictionary = new RouteValueDictionary(new { rows = "15", cols = "12" });
        private static readonly object _textAreaAttributesObjectDictionary = new { rows = "15", cols = "12" };
        private static readonly object _textAreaAttributesObjectUnderscoresDictionary = new { rows = "15", cols = "12", foo_bar = "baz" };

        private class TextAreaModel
        {
            public string foo { get; set; }
            public string bar { get; set; }
        }

        private static ViewDataDictionary<TextAreaModel> GetTextAreaViewData()
        {
            ViewDataDictionary<TextAreaModel> viewData = new ViewDataDictionary<TextAreaModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new TextAreaModel { foo = "ViewItemFoo", bar = "ViewItemBar" };
            return viewData;
        }

        private static ViewDataDictionary<TextAreaModel> GetTextAreaViewDataWithErrors()
        {
            ViewDataDictionary<TextAreaModel> viewData = new ViewDataDictionary<TextAreaModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new TextAreaModel { foo = "ViewItemFoo", bar = "ViewItemBar" };

            ModelState modelStateFoo = new ModelState();
            modelStateFoo.Errors.Add(new ModelError("foo error 1"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            viewData.ModelState["foo"] = modelStateFoo;
            modelStateFoo.Value = HtmlHelperTest.GetValueProviderResult(new string[] { "AttemptedValueFoo" }, "AttemptedValueFoo");

            return viewData;
        }

        // TextArea

        [Fact]
        public void TextAreaParameterDictionaryMerging()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.TextArea("foo", new { rows = "30" });

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"foo\" name=\"foo\" rows=\"30\">" + Environment.NewLine
              + "</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaParameterDictionaryMerging_Unobtrusive()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            helper.ClientValidationRuleFactory = (name, metadata) => new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };

            // Act
            MvcHtmlString html = helper.TextArea("foo", new { rows = "30" });

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" data-val=\"true\" data-val-type=\"error\" id=\"foo\" name=\"foo\" rows=\"30\">" + Environment.NewLine
              + "</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaParameterDictionaryMergingExplicitParameters()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.TextArea("foo", "bar", 10, 25, new { rows = "30" });

            // Assert
            Assert.Equal(
                "<textarea cols=\"25\" id=\"foo\" name=\"foo\" rows=\"10\">" + Environment.NewLine
              + "bar</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaParameterDictionaryMergingExplicitParametersWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.TextArea("foo", "bar", 10, 25, new { rows = "30", foo_bar = "baz" });

            // Assert
            Assert.Equal(
                "<textarea cols=\"25\" foo-bar=\"baz\" id=\"foo\" name=\"foo\" rows=\"10\">" + Environment.NewLine
              + "bar</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { helper.TextArea(String.Empty); },
                "name");
        }

        [Fact]
        public void TextAreaWithOutOfRangeColsThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act & Assert
            Assert.ThrowsArgumentOutOfRange(
                delegate { helper.TextArea("Foo", null /* value */, 0, -1, null /* htmlAttributes */); },
                "columns",
                "The value must be greater than or equal to zero.");
        }

        [Fact]
        public void TextAreaWithOutOfRangeRowsThrows()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act & Assert
            Assert.ThrowsArgumentOutOfRange(
                delegate { helper.TextArea("Foo", null /* value */, -1, 0, null /* htmlAttributes */); },
                "rows",
                "The value must be greater than or equal to zero.");
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextArea_AttributeEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.TextArea(name: text, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"id\" name=\"" +
                    encodedText +
                    "\" rows=\"2\">" +
                    Environment.NewLine +
                    "</textarea>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextArea_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.TextArea(name: String.Empty, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"id\" name=\"" +
                    encodedText +
                    "\" rows=\"2\">" +
                    Environment.NewLine +
                    "</textarea>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextArea_HtmlEncodes_Value(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(text);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextArea("").ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"Prefix\" name=\"Prefix\" rows=\"2\">" +
                    Environment.NewLine +
                    encodedText +
                    "</textarea>",
                result);
        }

        [Fact]
        public void TextAreaWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();

            // Act
            MvcHtmlString html = helper.TextArea("foo", "bar");

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"foo\" name=\"foo\" rows=\"2\">" + Environment.NewLine
              + "bar</textarea>",
                html.ToHtmlString());
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextAreaWithExplicitValue_HtmlEncodes_Value(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextArea("name", text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"name\" name=\"name\" rows=\"2\">" +
                    Environment.NewLine +
                    encodedText +
                    "</textarea>",
                result);
        }

        [Fact]
        public void TextAreaWithDefaultAttributes()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo");

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"foo\" name=\"foo\" rows=\"2\">" + Environment.NewLine
              + "ViewDataFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithZeroRowsAndColumns()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", null, 0, 0, null);

            // Assert
            Assert.Equal(
                "<textarea id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "ViewDataFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithDotReplacementForId()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo.bar.baz");

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"foo_bar_baz\" name=\"foo.bar.baz\" rows=\"2\">" + Environment.NewLine
              + "</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithObjectAttributes()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", _textAreaAttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "ViewDataFoo</textarea>",
                html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextAreaWithObjectAttributes_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextArea(name: "", htmlAttributes: new { attribute = text, }).ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea attribute=\"" +
                    encodedText +
                    "\" cols=\"20\" id=\"Prefix\" name=\"Prefix\" rows=\"2\">" +
                    Environment.NewLine +
                    "</textarea>",
                result);
        }

        [Fact]
        public void TextAreaWithObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", _textAreaAttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" foo-bar=\"baz\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "ViewDataFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithDictionaryAttributes()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", _textAreaAttributesDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "ViewDataFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithExplicitValueAndObjectAttributes()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", "Hello World", _textAreaAttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "Hello World</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithExplicitValueAndObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", "Hello World", _textAreaAttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" foo-bar=\"baz\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "Hello World</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithExplicitValueAndDictionaryAttributes()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", "<Hello World>", _textAreaAttributesDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "&lt;Hello World&gt;</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithNoValueAndObjectAttributes()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("baz", _textAreaAttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" id=\"baz\" name=\"baz\" rows=\"15\">" + Environment.NewLine
              + "</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithNullValue()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextArea("foo", null, null);

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"foo\" name=\"foo\" rows=\"2\">" + Environment.NewLine
              + "ViewDataFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithViewDataErrors()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextArea("foo", _textAreaAttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<textarea class=\"input-validation-error\" cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "AttemptedValueFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithViewDataErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper(GetTextAreaViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextArea("foo", new { @class = "foo-class" });

            // Assert
            Assert.Equal(
                "<textarea class=\"input-validation-error foo-class\" cols=\"20\" id=\"foo\" name=\"foo\" rows=\"2\">" + Environment.NewLine
              + "AttemptedValueFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextArea("foo", "bar");

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"MyPrefix_foo\" name=\"MyPrefix.foo\" rows=\"2\">" + Environment.NewLine
              + "bar</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextArea("", "bar");

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"MyPrefix\" name=\"MyPrefix\" rows=\"2\">" + Environment.NewLine
              + "bar</textarea>",
                html.ToHtmlString());
        }

        // TextAreaFor

        [Fact]
        public void TextAreaForWithNullExpression()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.TextAreaFor<TextAreaModel, object>(null),
                "expression"
                );
        }

        [Fact]
        public void TextAreaForWithOutOfRangeColsThrows()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act & Assert
            Assert.ThrowsArgumentOutOfRange(
                () => helper.TextAreaFor(m => m.foo, 0, -1, null /* htmlAttributes */),
                "columns",
                "The value must be greater than or equal to zero."
                );
        }

        [Fact]
        public void TextAreaForWithOutOfRangeRowsThrows()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act & Assert
            Assert.ThrowsArgumentOutOfRange(
                () => helper.TextAreaFor(m => m.foo, -1, 0, null /* htmlAttributes */),
                "rows",
                "The value must be greater than or equal to zero."
                );
        }

        [Fact]
        public void TextAreaForParameterDictionaryMerging()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, new { rows = "30" });

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"foo\" name=\"foo\" rows=\"30\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForParameterDictionaryMerging_Unobtrusive()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());
            helper.ViewContext.ClientValidationEnabled = true;
            helper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
            helper.ViewContext.FormContext = new FormContext();
            ModelMetadata modelMetadata = null;
            helper.ClientValidationRuleFactory = (name, metadata) => {
                modelMetadata = metadata;
                return new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" } };
            };

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, new { rows = "30" });

            // Assert
            Assert.NotNull(modelMetadata);
            Assert.Equal("foo", modelMetadata.PropertyName);
            Assert.Equal(
                "<textarea cols=\"20\" data-val=\"true\" data-val-type=\"error\" id=\"foo\" name=\"foo\" rows=\"30\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForWithDefaultAttributes()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo);

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"foo\" name=\"foo\" rows=\"2\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForWithZeroRowsAndColumns()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, 0, 0, null);

            // Assert
            Assert.Equal(
                "<textarea id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextAreaFor_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            // htmlAttributes included only to avoid special-cased renaming done for id attribute.
            var result = helper.TextAreaFor(m => m, htmlAttributes: new { id = "id", }).ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"id\" name=\"" +
                    encodedText +
                    "\" rows=\"2\">" +
                    Environment.NewLine +
                    "</textarea>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextAreaFor_HtmlEncodes_Value(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(text);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextAreaFor(m => text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"text\" name=\"text\" rows=\"2\">" +
                    Environment.NewLine +
                    encodedText +
                    "</textarea>",
                result);
        }

        [Fact]
        public void TextAreaForWithObjectAttributes()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, _textAreaAttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void TextAreaForWithObjectAttributes_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var result = helper.TextAreaFor(m => m, htmlAttributes: new { attribute = text, }).ToHtmlString();

            // Assert
            Assert.Equal(
                "<textarea attribute=\"" +
                    encodedText +
                    "\" cols=\"20\" id=\"Prefix\" name=\"Prefix\" rows=\"2\">" +
                    Environment.NewLine +
                    "</textarea>",
                result);
        }

        [Fact]
        public void TextAreaForWithObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, _textAreaAttributesObjectUnderscoresDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" foo-bar=\"baz\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForWithDictionaryAttributes()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, _textAreaAttributesDictionary);

            // Assert
            Assert.Equal(
                "<textarea cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForWithViewDataErrors()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, _textAreaAttributesObjectDictionary);

            // Assert
            Assert.Equal(
                "<textarea class=\"input-validation-error\" cols=\"12\" id=\"foo\" name=\"foo\" rows=\"15\">" + Environment.NewLine
              + "AttemptedValueFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForWithViewDataErrorsAndCustomClass()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewDataWithErrors());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, new { @class = "foo-class" });

            // Assert
            Assert.Equal(
                "<textarea class=\"input-validation-error foo-class\" cols=\"20\" id=\"foo\" name=\"foo\" rows=\"2\">" + Environment.NewLine
              + "AttemptedValueFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForWithPrefix()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo);

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"MyPrefix_foo\" name=\"MyPrefix.foo\" rows=\"2\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForWithPrefixAndEmptyName()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());
            helper.ViewContext.ViewData.TemplateInfo.HtmlFieldPrefix = "MyPrefix";

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m);

            // Assert
            Assert.Equal(
                "<textarea cols=\"20\" id=\"MyPrefix\" name=\"MyPrefix\" rows=\"2\">" + Environment.NewLine
              + "System.Web.Mvc.Html.Test.TextAreaExtensionsTest+TextAreaModel</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForParameterDictionaryMergingWithObjectValues()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, 10, 25, new { rows = "30" });

            // Assert
            Assert.Equal(
                "<textarea cols=\"25\" id=\"foo\" name=\"foo\" rows=\"10\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForParameterDictionaryMergingWithObjectValuesWithUnderscores()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, 10, 25, new { rows = "30", foo_bar = "baz" });

            // Assert
            Assert.Equal(
                "<textarea cols=\"25\" foo-bar=\"baz\" id=\"foo\" name=\"foo\" rows=\"10\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaForParameterDictionaryMergingWithDictionaryValues()
        {
            // Arrange
            HtmlHelper<TextAreaModel> helper = MvcHelper.GetHtmlHelper(GetTextAreaViewData());

            // Act
            MvcHtmlString html = helper.TextAreaFor(m => m.foo, 10, 25, new RouteValueDictionary(new { rows = "30" }));

            // Assert
            Assert.Equal(
                "<textarea cols=\"25\" id=\"foo\" name=\"foo\" rows=\"10\">" + Environment.NewLine
              + "ViewItemFoo</textarea>",
                html.ToHtmlString());
        }

        [Fact]
        public void TextAreaHelperDoesNotEncodeInnerHtmlPrefix()
        {
            // Arrange
            HtmlHelper helper = MvcHelper.GetHtmlHelper();
            ModelMetadata metadata = ModelMetadata.FromStringExpression("foo", helper.ViewData);
            metadata.Model = "<model>";

            // Act
            MvcHtmlString html = TextAreaExtensions.TextAreaHelper(helper, metadata, "testEncoding", rowsAndColumns: null,
                                                                   htmlAttributes: null, innerHtmlPrefix: "<prefix>");

            // Assert
            Assert.Equal("<textarea id=\"testEncoding\" name=\"testEncoding\"><prefix>&lt;model&gt;</textarea>", html.ToHtmlString());
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ViewContext.ClientValidationEnabled) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/ValidationExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Routing;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Html.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ValidationExtensionsTest : IDisposable
    {
        // Validate

        [Fact]
        public void Validate_AddsClientValidationMetadata()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext()
                {
                    FormId = "form_id"
                };
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                htmlHelper.Validate("baz");

                // Assert
                Assert.NotNull(formContext.GetValidationMetadataForField("baz"));
                Assert.Equal(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        [Fact]
        public void Validate_DoesNothingIfClientValidationIsNotEnabled()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.ViewContext.FormContext = new FormContext();
            htmlHelper.ViewContext.ClientValidationEnabled = false;

            // Act
            htmlHelper.Validate("foo");

            // Assert
            Assert.Empty(htmlHelper.ViewContext.FormContext.FieldValidators);
        }

        [Fact]
        public void Validate_DoesNothingIfUnobtrusiveJavaScriptIsEnabled()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.ViewContext.FormContext = new FormContext();
            htmlHelper.ViewContext.ClientValidationEnabled = true;
            htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled = true;

            // Act
            htmlHelper.Validate("foo");

            // Assert
            Assert.Empty(htmlHelper.ViewContext.FormContext.FieldValidators);
        }

        [Fact]
        public void Validate_ThrowsIfModelNameIsNull()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { htmlHelper.Validate((string)null /* modelName */); }, "modelName");
        }

        [Fact]
        public void ValidateFor_AddsClientValidationMetadata()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext()
                {
                    FormId = "form_id"
                };
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                htmlHelper.ValidateFor(m => m.baz);

                // Assert
                Assert.NotNull(formContext.GetValidationMetadataForField("baz"));
                Assert.Equal(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        // ValidationMessage

        [Fact]
        public void ValidationMessageAllowsEmptyModelName()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.ModelState.AddModelError("", "some error text");
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(vdd);

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">some error text</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsNullForNullModelState()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithNullModelState());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo");

            // Assert
            Assert.Null(html);
        }

        [Fact]
        public void ValidationMessageReturnsFirstErrorWithMessage()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsGenericMessageInsteadOfExceptionText()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("quux");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">The value &#39;quuxValue&#39; is invalid.</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsNullForInvalidName()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("boo");

            // Assert
            Assert.Null(html);
        }

        [Fact]
        public void ValidationMessageReturnsWithObjectAttributes()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", new { bar = "bar" });

            // Assert
            Assert.Equal("<span bar=\"bar\" class=\"field-validation-error\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsWithObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", new { foo_bar = "bar" });

            // Assert
            Assert.Equal("<span class=\"field-validation-error\" foo-bar=\"bar\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsWithCustomMessage()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">bar error</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsWithCustomMessageAndObjectAttributes()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error", new { baz = "baz" });

            // Assert
            Assert.Equal("<span baz=\"baz\" class=\"field-validation-error\">bar error</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsWithCustomMessageAndObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error", new { foo_baz = "baz" });

            // Assert
            Assert.Equal("<span class=\"field-validation-error\" foo-baz=\"baz\">bar error</span>", html.ToHtmlString());
        }


        [Fact]
        public void ValidationMessageWithOverriddenTag_UsesGivenTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.SetValidationMessageElement("label");

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error");

            // Assert
            Assert.Equal(
                "<label class=\"field-validation-error\">bar error</label>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithOverriddenTag_SetPropertyInValidationMessageElement_UsesGivenTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.ViewContext.ValidationMessageElement = "label";

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error");

            // Assert
            Assert.Equal(
                "<label class=\"field-validation-error\">bar error</label>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithCustomTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error", "label");

            // Assert
            Assert.Equal(
                "<label class=\"field-validation-error\">bar error</label>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithObjectAttributesWithCustomTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error", new { baz = "baz"}, "label");

            // Assert
            Assert.Equal(
                "<label baz=\"baz\" class=\"field-validation-error\">bar error</label>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithAttributesDictionaryWithCustomTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            RouteValueDictionary htmlAttributes = new RouteValueDictionary();
            htmlAttributes["baz"] = "baz";

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", "bar error", htmlAttributes, "label");

            // Assert
            Assert.Equal(
                "<label baz=\"baz\" class=\"field-validation-error\">bar error</label>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithoutMessageWithAttributesDictionaryWithCustomTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            RouteValueDictionary htmlAttributes = new RouteValueDictionary();
            htmlAttributes["baz"] = "baz";

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", htmlAttributes, "label");

            // Assert
            Assert.Equal(
                "<label baz=\"baz\" class=\"field-validation-error\">foo error &lt;1&gt;</label>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithoutMessageWithObjectAttributesWithCustomTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo", new { bar = "bar", baz = "baz"}, "label");

            // Assert
            Assert.Equal(
                "<label bar=\"bar\" baz=\"baz\" class=\"field-validation-error\">foo error &lt;1&gt;</label>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageThrowsIfModelNameIsNull()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { htmlHelper.ValidationMessage(null); }, "modelName");
        }

        [Fact]
        public void ValidationMessageWithClientValidation_DefaultMessage_Valid()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext();
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                MvcHtmlString html = htmlHelper.ValidationMessage("baz"); // 'baz' is valid

                // Assert
                Assert.Equal("<span class=\"field-validation-valid\" id=\"baz_validationMessage\"></span>", html.ToHtmlString());
                Assert.NotNull(formContext.GetValidationMetadataForField("baz"));
                Assert.Equal("baz_validationMessage", formContext.FieldValidators["baz"].ValidationMessageId);
                Assert.True(formContext.FieldValidators["baz"].ReplaceValidationMessageContents);
                Assert.Equal(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        [Fact]
        public void ValidationMessageWithClientValidation_DefaultMessage_Valid_Unobtrusive()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext();
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                MvcHtmlString html = htmlHelper.ValidationMessage("baz"); // 'baz' is valid

                // Assert
                Assert.Equal("<span class=\"field-validation-valid\" data-valmsg-for=\"baz\" data-valmsg-replace=\"true\"></span>", html.ToHtmlString());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        [Fact]
        public void ValidationMessageWithClientValidation_ExplicitMessage_Valid()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext();
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                MvcHtmlString html = htmlHelper.ValidationMessage("baz", "some explicit message"); // 'baz' is valid

                // Assert
                Assert.Equal("<span class=\"field-validation-valid\" id=\"baz_validationMessage\">some explicit message</span>", html.ToHtmlString());
                Assert.NotNull(formContext.GetValidationMetadataForField("baz"));
                Assert.Equal("baz_validationMessage", formContext.FieldValidators["baz"].ValidationMessageId);
                Assert.False(formContext.FieldValidators["baz"].ReplaceValidationMessageContents);
                Assert.Equal(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        [Fact]
        public void ValidationMessageWithClientValidation_ExplicitMessage_Valid_Unobtrusive()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext();
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                MvcHtmlString html = htmlHelper.ValidationMessage("baz", "some explicit message"); // 'baz' is valid

                // Assert
                Assert.Equal("<span class=\"field-validation-valid\" data-valmsg-for=\"baz\" data-valmsg-replace=\"false\">some explicit message</span>", html.ToHtmlString());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        [Fact]
        public void ValidationMessageWithModelStateAndNoErrors()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("baz");

            // Assert
            Assert.Null(html);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessage_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();

            // Act
            var result = helper.ValidationMessage(modelName: "name", htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<span attribute=\"" +
                    encodedText +
                    "\" class=\"field-validation-valid\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\">" +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessage_HtmlEncodes_Message(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();

            // Act
            var result = helper.ValidationMessage(modelName: "name", validationMessage: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" data-valmsg-for=\"name\" data-valmsg-replace=\"false\">" +
                    encodedText +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessage_HtmlEncodes_ModelStateAttemptedValue(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError(key: "name", errorMessage: null);
            var valueProvider = new ValueProviderResult(rawValue: null, attemptedValue: text, culture: null);
            viewData.ModelState.SetModelValue(key: "name", value: valueProvider);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();

            // Act
            var result = helper.ValidationMessage(modelName: "name").ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\">The value &#39;" +
                    encodedText +
                    "&#39; is invalid.</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessage_HtmlEncodes_ModelStateError(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError("name", text);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();

            // Act
            var result = helper.ValidationMessage(modelName: "name").ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\">" +
                    encodedText +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessage_AttributeEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();

            // Act
            var result = helper.ValidationMessage(modelName: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" data-valmsg-for=\"" +
                    encodedText +
                    "\" data-valmsg-replace=\"true\"></span>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessage_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();

            // Act
            var result = helper.ValidationMessage(modelName: String.Empty).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" data-valmsg-for=\"" +
                    encodedText +
                    "\" data-valmsg-replace=\"true\"></span>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoEncodedText", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessage_DoesNotEncode_Tag(string text, bool htmlEncode)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();

            // Act
            var result = helper.ValidationMessage(modelName: "name", validationMessage: null, tag: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<" +
                    text +
                    " class=\"field-validation-valid\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\"></" +
                    text +
                    ">",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageNonUnobtrusive_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationMessage(modelName: "name", htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<span attribute=\"" +
                    encodedText +
                    "\" class=\"field-validation-valid\" id=\"name_validationMessage\">" +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageNonUnobtrusive_HtmlEncodes_Message(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationMessage(modelName: "name", validationMessage: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" id=\"name_validationMessage\">" + encodedText + "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageNonUnobtrusive_HtmlEncodes_ModelStateAttemptedValue(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError(key: "name", errorMessage: null);
            var valueProvider = new ValueProviderResult(rawValue: null, attemptedValue: text, culture: null);
            viewData.ModelState.SetModelValue(key: "name", value: valueProvider);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationMessage(modelName: "name").ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" id=\"name_validationMessage\">The value &#39;" +
                    encodedText +
                    "&#39; is invalid.</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageNonUnobtrusive_HtmlEncodes_ModelStateError(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError("name", text);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationMessage(modelName: "name").ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" id=\"name_validationMessage\">" + encodedText + "</span>",
                result);
        }

        [Theory]
        [PropertyData("IdEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageNonUnobtrusive_IdEncodes_Name(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationMessage(modelName: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" id=\"" + encodedText + "_validationMessage\"></span>",
                result);
        }

        [Theory]
        [PropertyData("IdEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageNonUnobtrusive_IdEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationMessage(modelName: String.Empty).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" id=\"" + encodedText + "_validationMessage\"></span>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoEncodedText", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageNonUnobtrusive_DoesNotEncode_Tag(string text, bool htmlEncode)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationMessage(modelName: "name", validationMessage: null, tag: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<" + text + " class=\"field-validation-valid\" id=\"name_validationMessage\"></" + text + ">",
                result);
        }

        // ValidationMessageFor

        [Fact]
        public void ValidationMessageForThrowsIfExpressionIsNull()
        {
            // Arrange
            HtmlHelper<object> htmlHelper = MvcHelper.GetHtmlHelper();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => htmlHelper.ValidationMessageFor<object, object>(null),
                "expression"
                );
        }

        [Fact]
        public void ValidationMessageForReturnsNullIfModelStateIsNull()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithNullModelState());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo);

            // Assert
            Assert.Null(html);
        }

        [Fact]
        public void ValidationMessageForReturnsFirstErrorWithErrorMessage()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo);

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForReturnsGenericMessageInsteadOfExceptionText()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.quux);

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">The value &#39;quuxValue&#39; is invalid.</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForReturnsWithObjectAttributes()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, null /* validationMessage */, new { bar = "bar" });

            // Assert
            Assert.Equal("<span bar=\"bar\" class=\"field-validation-error\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForReturnsWithObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, null /* validationMessage */, new { foo_bar = "bar" });

            // Assert
            Assert.Equal("<span class=\"field-validation-error\" foo-bar=\"bar\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForReturnsWithCustomMessage()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, "bar error");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">bar error</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForReturnsWithCustomMessageAndObjectAttributes()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, "bar error", new { baz = "baz" });

            // Assert
            Assert.Equal("<span baz=\"baz\" class=\"field-validation-error\">bar error</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForWithOverriddenTag_UsesGivenTag()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.SetValidationMessageElement("label");

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, "bar error");

            // Assert
            Assert.Equal("<label class=\"field-validation-error\">bar error</label>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForWithCustomTag()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, "bar error", "label");

            // Assert
            Assert.Equal("<label class=\"field-validation-error\">bar error</label>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForWithDictionaryAndCustomTag()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            RouteValueDictionary htmlAttributes = new RouteValueDictionary();
            htmlAttributes["class"] = "my-class";

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, "bar error", htmlAttributes, "label");

            // Assert
            Assert.Equal("<label class=\"field-validation-error my-class\">bar error</label>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForWithObjectAttributesAndCustomTag()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.foo, "bar error", new { @class = "baz" }, "label");

            // Assert
            Assert.Equal("<label class=\"field-validation-error baz\">bar error</label>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageForWithClientValidation()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext();
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.baz);

                // Assert
                Assert.Equal("<span class=\"field-validation-valid\" id=\"baz_validationMessage\"></span>", html.ToHtmlString());
                Assert.NotNull(formContext.GetValidationMetadataForField("baz"));
                Assert.Equal("baz_validationMessage", formContext.FieldValidators["baz"].ValidationMessageId);
                Assert.Equal(expectedValidationRules, formContext.FieldValidators["baz"].ValidationRules.ToArray());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        [Fact]
        public void ValidationMessageForWithClientValidation_Unobtrusive()
        {
            var originalProviders = ModelValidatorProviders.Providers.ToArray();
            ModelValidatorProviders.Providers.Clear();

            try
            {
                // Arrange
                HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
                FormContext formContext = new FormContext();
                htmlHelper.ViewContext.ClientValidationEnabled = true;
                htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled = true;
                htmlHelper.ViewContext.FormContext = formContext;

                ModelClientValidationRule[] expectedValidationRules = new ModelClientValidationRule[]
                {
                    new ModelClientValidationRule() { ValidationType = "ValidationRule1" },
                    new ModelClientValidationRule() { ValidationType = "ValidationRule2" }
                };

                Mock<ModelValidator> mockValidator = new Mock<ModelValidator>(ModelMetadata.FromStringExpression("", htmlHelper.ViewContext.ViewData), htmlHelper.ViewContext);
                mockValidator.Setup(v => v.GetClientValidationRules())
                    .Returns(expectedValidationRules);
                Mock<ModelValidatorProvider> mockValidatorProvider = new Mock<ModelValidatorProvider>();
                mockValidatorProvider.Setup(vp => vp.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new[] { mockValidator.Object });
                ModelValidatorProviders.Providers.Add(mockValidatorProvider.Object);

                // Act
                MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.baz);

                // Assert
                Assert.Equal("<span class=\"field-validation-valid\" data-valmsg-for=\"baz\" data-valmsg-replace=\"true\"></span>", html.ToHtmlString());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (var provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        [Fact]
        public void ValidationMessageForWithModelStateAndNoErrors()
        {
            // Arrange
            HtmlHelper<ValidationModel> htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessageFor(m => m.baz);

            // Assert
            Assert.Null(html);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageFor_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();
            string name = null;

            // Act
            var result =
                helper.ValidationMessageFor(m => name, validationMessage: null, htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<span attribute=\"" +
                    encodedText +
                    "\" class=\"field-validation-valid\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\">" +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageFor_HtmlEncodes_Message(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name, validationMessage: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" data-valmsg-for=\"name\" data-valmsg-replace=\"false\">" +
                    encodedText +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageFor_HtmlEncodes_ModelStateAttemptedValue(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError(key: "name", errorMessage: null);
            var valueProvider = new ValueProviderResult(rawValue: null, attemptedValue: text, culture: null);
            viewData.ModelState.SetModelValue(key: "name", value: valueProvider);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\">The value &#39;" +
                    encodedText +
                    "&#39; is invalid.</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageFor_HtmlEncodes_ModelStateError(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError("name", text);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\">" +
                    encodedText +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageFor_AttributeEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" data-valmsg-for=\"" +
                    encodedText +
                    ".name\" data-valmsg-replace=\"true\"></span>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoEncodedText", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageFor_DoesNotEncode_Tag(string text, bool htmlEncode)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript();
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name, validationMessage: null, tag: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<" +
                    text +
                    " class=\"field-validation-valid\" data-valmsg-for=\"name\" data-valmsg-replace=\"true\"></" +
                    text +
                    ">",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageForNonUnobtrusive_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(
                    m => name,
                    validationMessage: null,
                    htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<span attribute=\"" +
                    encodedText +
                    "\" class=\"field-validation-valid\" id=\"name_validationMessage\">" +
                    "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageForNonUnobtrusive_HtmlEncodes_Message(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name, validationMessage: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" id=\"name_validationMessage\">" + encodedText + "</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageForNonUnobtrusive_HtmlEncodes_ModelStateAttemptedValue(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError(key: "name", errorMessage: null);
            var valueProvider = new ValueProviderResult(rawValue: null, attemptedValue: text, culture: null);
            viewData.ModelState.SetModelValue(key: "name", value: valueProvider);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" id=\"name_validationMessage\">The value &#39;" +
                    encodedText +
                    "&#39; is invalid.</span>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageForNonUnobtrusive_HtmlEncodes_ModelStateError(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError("name", text);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-error\" id=\"name_validationMessage\">" + encodedText + "</span>",
                result);
        }

        [Theory]
        [PropertyData("IdEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageForNonUnobtrusive_IdEncodes_Prefix(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.TemplateInfo.HtmlFieldPrefix = text;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name).ToHtmlString();

            // Assert
            Assert.Equal(
                "<span class=\"field-validation-valid\" id=\"" + encodedText + "_name_validationMessage\"></span>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoEncodedText", PropertyType = typeof(EncodedDataSets))]
        public void ValidationMessageForNonUnobtrusive_DoesNotEncode_Tag(string text, bool htmlEncode)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);
            string name = null;

            // Act
            var result = helper.ValidationMessageFor(m => name, validationMessage: null, tag: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<" + text + " class=\"field-validation-valid\" id=\"name_validationMessage\"></" + text + ">",
                result);
        }

        // ValidationSummary

        [Fact]
        public void ValidationSummary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryAddsIdIfClientValidationEnabled()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.ViewContext.FormContext = new FormContext();
            htmlHelper.ViewContext.ClientValidationEnabled = true;

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\" id=\"validationSummary\"><ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
            Assert.Equal("validationSummary", htmlHelper.ViewContext.FormContext.ValidationSummaryId);
        }

        [Fact]
        public void ValidationSummaryDoesNotAddIdIfUnobtrusiveJavaScriptEnabled()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.ViewContext.FormContext = new FormContext();
            htmlHelper.ViewContext.ClientValidationEnabled = true;
            htmlHelper.ViewContext.UnobtrusiveJavaScriptEnabled = true;

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\" data-valmsg-summary=\"true\"><ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            RouteValueDictionary htmlAttributes = new RouteValueDictionary();
            htmlAttributes["class"] = "my-class";

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(null /* message */, htmlAttributes);

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors my-class\"><ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithDictionaryAndMessage()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            RouteValueDictionary htmlAttributes = new RouteValueDictionary();
            htmlAttributes["class"] = "my-class";

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary("This is my message.", htmlAttributes);

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors my-class\"><span>This is my message.</span>" + Environment.NewLine
              + "<ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithNoErrors_ReturnsNullIfClientValidationDisabled()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Null(html);
        }

        [Fact]
        public void ValidationSummaryWithNoErrors_EmptyUlIfClientValidationEnabled()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());
            htmlHelper.ViewContext.ClientValidationEnabled = true;
            htmlHelper.ViewContext.FormContext = new FormContext();

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-valid\" id=\"validationSummary\"><ul><li style=\"display:none\"></li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithObjectAttributes()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(null /* message */, new { baz = "baz" });

            // Assert
            Assert.Equal(
                "<div baz=\"baz\" class=\"validation-summary-errors\"><ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithObjectAttributesWithUnderscores()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(null /* message */, new { foo_baz = "baz" });

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\" foo-baz=\"baz\"><ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithObjectAttributesAndMessage()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary("This is my message.", new { baz = "baz" });

            // Assert
            Assert.Equal(
                "<div baz=\"baz\" class=\"validation-summary-errors\"><span>This is my message.</span>" + Environment.NewLine
              + "<ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithNoModelErrors()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(true /* excludePropertyErrors */, "This is my message.");

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><span>This is my message.</span>" + Environment.NewLine
              + "<ul><li style=\"display:none\"></li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithOnlyModelErrors()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelAndPropertyErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(true /* excludePropertyErrors */, "This is my message.");

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><span>This is my message.</span>" + Environment.NewLine
              + "<ul><li>Something is wrong.</li>" + Environment.NewLine
              + "<li>Something else is also wrong.</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithOnlyModelErrorsAndPrefix()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors("MyPrefix"));

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(true /* excludePropertyErrors */, "This is my message.");

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><span>This is my message.</span>" + Environment.NewLine
              + "<ul><li style=\"display:none\"></li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithOverriddenHeadingTag_UsesGivenTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            htmlHelper.SetValidationSummaryMessageElement("h4");

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(true /* excludePropertyErrors */, "This is my message.");

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><h4>This is my message.</h4>" + Environment.NewLine
              + "<ul><li style=\"display:none\"></li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithCustomHeadingTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary(true /* excludePropertyErrors */, "This is my message.", "h2");

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><h2>This is my message.</h2>" + Environment.NewLine
              + "<ul><li style=\"display:none\"></li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithDictionaryAndMessageWithCustomHeadingTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());
            RouteValueDictionary htmlAttributes = new RouteValueDictionary();
            htmlAttributes["class"] = "my-class";

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary("This is my message.", htmlAttributes, "h2");

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors my-class\"><h2>This is my message.</h2>" + Environment.NewLine
              + "<ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithObjectAttributesAndMessageWithCustomHeadingTag()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary("This is my message.", new { baz = "baz" }, "h2");

            // Assert
            Assert.Equal(
                "<div baz=\"baz\" class=\"validation-summary-errors\"><h2>This is my message.</h2>" + Environment.NewLine
              + "<ul><li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error 2</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error 2</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithPrefix()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelErrors("MyPrefix"));

            // Act
            MvcHtmlString html = htmlHelper.ValidationMessage("foo");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationErrorOrdering()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(GetViewDataWithModelWithDisplayOrderErrors());

            // Act
            MvcHtmlString html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><ul><li>Error 1</li>" + Environment.NewLine
              + "<li>Error 2</li>" + Environment.NewLine
              + "<li>Error 3</li>" + Environment.NewLine
              + "<li>Error 4</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());

        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationSummary_AttributeEncodes_AddedHtmlAttributes(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationSummary(
                    excludePropertyErrors: true,
                    message: null,
                    htmlAttributes: new { attribute = text, })
                .ToHtmlString();

            // Assert
            Assert.Equal(
                "<div attribute=\"" +
                    encodedText +
                    "\" class=\"validation-summary-valid\" id=\"validationSummary\"><ul><li style=\"display:none\"></li>" +
                    Environment.NewLine +
                    "</ul></div>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationSummary_HtmlEncodes_Message(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationSummary(message: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-valid\" id=\"validationSummary\"><span>" +
                    encodedText +
                    "</span>" +
                    Environment.NewLine +
                    "<ul><li style=\"display:none\"></li>" +
                    Environment.NewLine +
                    "</ul></div>",
                result);
        }

        [Theory]
        [PropertyData("HtmlEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValidationSummary_HtmlEncodes_ModelStateError(
            string text,
            bool htmlEncode,
            string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            viewData.ModelState.AddModelError("", text);

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationSummary().ToHtmlString();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\" id=\"validationSummary\"><ul><li>" +
                    encodedText +
                    "</li>" +
                    Environment.NewLine +
                    "</ul></div>",
                result);
        }

        [Theory]
        [PropertyData("AttributeEncodedData_NoEncodedText", PropertyType = typeof(EncodedDataSets))]
        public void ValidationSummary_DoesNotEncode_Tag(string text, bool htmlEncode)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(model: null);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;

            var helper = MvcHelper.GetHtmlHelper(viewData);
            helper.EnableClientValidation();
            helper.EnableUnobtrusiveJavaScript(enabled: false);

            // Act
            var result = helper.ValidationSummary(message: "message", headingTag: text).ToHtmlString();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-valid\" id=\"validationSummary\"><" +
                    text +
                    ">message</" +
                    text +
                    ">" +
                    Environment.NewLine +
                    "<ul><li style=\"display:none\"></li>" +
                    Environment.NewLine +
                    "</ul></div>",
                result);
        }

        private class ValidationModel
        {
            public string foo { get; set; }
            public string bar { get; set; }
            public string baz { get; set; }
            public string quux { get; set; }
        }

        public class ModelWithOrdering
        {
            [Required]
            [Display(Order = 2)]
            public int Second { get; set; }

            [Required]
            [Display(Order = 1)]
            public string First { get; set; }

            [Required]
            [Display(Order = 4)]
            public string Fourth { get; set; }

            [Required]
            [Display(Order = 3)]
            public string Third { get; set; }
        }

        private static ViewDataDictionary<ValidationModel> GetViewDataWithNullModelState()
        {
            ViewDataDictionary<ValidationModel> viewData = new ViewDataDictionary<ValidationModel>();
            viewData.ModelState["foo"] = null;
            return viewData;
        }

        private static ViewDataDictionary<ValidationModel> GetViewDataWithModelErrors()
        {
            ViewDataDictionary<ValidationModel> viewData = new ViewDataDictionary<ValidationModel>();
            ModelState modelStateFoo = new ModelState();
            ModelState modelStateBar = new ModelState();
            ModelState modelStateBaz = new ModelState();

            modelStateFoo.Errors.Add(new ModelError(new InvalidOperationException("foo error from exception")));
            modelStateFoo.Errors.Add(new ModelError("foo error <1>"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            modelStateBar.Errors.Add(new ModelError("bar error <1>"));
            modelStateBar.Errors.Add(new ModelError("bar error 2"));

            viewData.ModelState["foo"] = modelStateFoo;
            viewData.ModelState["bar"] = modelStateBar;
            viewData.ModelState["baz"] = modelStateBaz;

            viewData.ModelState.SetModelValue("quux", new ValueProviderResult(null, "quuxValue", null));
            viewData.ModelState.AddModelError("quux", new InvalidOperationException("Some error text."));
            return viewData;
        }

        private static ViewDataDictionary<ValidationModel> GetViewDataWithModelAndPropertyErrors()
        {
            ViewDataDictionary<ValidationModel> viewData = new ViewDataDictionary<ValidationModel>();
            ModelState modelStateFoo = new ModelState();
            ModelState modelStateBar = new ModelState();
            ModelState modelStateBaz = new ModelState();
            modelStateFoo.Errors.Add(new ModelError("foo error <1>"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            modelStateBar.Errors.Add(new ModelError("bar error <1>"));
            modelStateBar.Errors.Add(new ModelError("bar error 2"));
            viewData.ModelState["foo"] = modelStateFoo;
            viewData.ModelState["bar"] = modelStateBar;
            viewData.ModelState["baz"] = modelStateBaz;
            viewData.ModelState.SetModelValue("quux", new ValueProviderResult(null, "quuxValue", null));
            viewData.ModelState.AddModelError("quux", new InvalidOperationException("Some error text."));
            viewData.ModelState.AddModelError(String.Empty, "Something is wrong.");
            viewData.ModelState.AddModelError(String.Empty, "Something else is also wrong.");
            return viewData;
        }

        private static ViewDataDictionary<ValidationModel> GetViewDataWithModelErrors(string prefix)
        {
            ViewDataDictionary<ValidationModel> viewData = new ViewDataDictionary<ValidationModel>();
            viewData.TemplateInfo.HtmlFieldPrefix = prefix;
            ModelState modelStateFoo = new ModelState();
            ModelState modelStateBar = new ModelState();
            ModelState modelStateBaz = new ModelState();
            modelStateFoo.Errors.Add(new ModelError("foo error <1>"));
            modelStateFoo.Errors.Add(new ModelError("foo error 2"));
            modelStateBar.Errors.Add(new ModelError("bar error <1>"));
            modelStateBar.Errors.Add(new ModelError("bar error 2"));
            viewData.ModelState[prefix + ".foo"] = modelStateFoo;
            viewData.ModelState[prefix + ".bar"] = modelStateBar;
            viewData.ModelState[prefix + ".baz"] = modelStateBaz;
            viewData.ModelState.SetModelValue(prefix + ".quux", new ValueProviderResult(null, "quuxValue", null));
            viewData.ModelState.AddModelError(prefix + ".quux", new InvalidOperationException("Some error text."));
            return viewData;
        }

        private static ViewDataDictionary<ModelWithOrdering> GetViewDataWithModelWithDisplayOrderErrors()
        {
            ViewDataDictionary<ModelWithOrdering> viewData = new ViewDataDictionary<ModelWithOrdering>();

            var model = new ModelWithOrdering();

            // Error names for each property on ModelWithOrdering.
            viewData.ModelState.AddModelError("First", "Error 1");
            viewData.ModelState.AddModelError("Second", "Error 2");
            viewData.ModelState.AddModelError("Third", "Error 3");
            viewData.ModelState.AddModelError("Fourth", "Error 4");

            return viewData;
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ViewContext.ClientValidationEnabled) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Html/Test/ValueExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Test;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Html.Test
{
    public class ValueExtensionsTest
    {
        // Value

        [Fact]
        public void ValueWithNullNameThrows()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetValueViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.Value(name: null),
                "name"
                );
        }

        [Fact]
        public void ValueGetsValueFromViewData()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetValueViewData());

            // Act
            MvcHtmlString html = helper.Value("foo");

            // Assert
            Assert.Equal("ViewDataFoo", html.ToHtmlString());
        }

        // ValueFor

        [Fact]
        public void ValueForWithNullExpressionThrows()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetValueViewData());

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => helper.ValueFor<FooBarModel, object>(expression: null),
                "expression"
                );
        }

        [Fact]
        public void ValueForGetsExpressionValueFromViewDataModel()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetValueViewData());

            // Act
            MvcHtmlString html = helper.ValueFor(m => m.foo);

            // Assert
            Assert.Equal("ViewItemFoo", html.ToHtmlString());
        }

        // All Value Helpers including ValueForModel

        [Fact]
        public void ValueHelpersWithErrorsGetValueFromModelState()
        {
            // Arrange
            ViewDataDictionary<FooBarModel> viewDataWithErrors = new ViewDataDictionary<FooBarModel> { { "foo", "ViewDataFoo" } };
            viewDataWithErrors.Model = new FooBarModel() { foo = "ViewItemFoo", bar = "ViewItemBar" };
            viewDataWithErrors.TemplateInfo.HtmlFieldPrefix = "FieldPrefix";

            ModelState modelStateFoo = new ModelState();
            modelStateFoo.Value = HtmlHelperTest.GetValueProviderResult(new string[] { "AttemptedValueFoo" }, "AttemptedValueFoo");
            viewDataWithErrors.ModelState["FieldPrefix.foo"] = modelStateFoo;

            ModelState modelStateFooBar = new ModelState();
            modelStateFooBar.Value = HtmlHelperTest.GetValueProviderResult(new string[] { "AttemptedValueFooBar" }, "AttemptedValueFooBar");
            viewDataWithErrors.ModelState["FieldPrefix"] = modelStateFooBar;

            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(viewDataWithErrors);

            // Act & Assert
            Assert.Equal("AttemptedValueFoo", helper.Value("foo").ToHtmlString());
            Assert.Equal("AttemptedValueFoo", helper.ValueFor(m => m.foo).ToHtmlString());
            Assert.Equal("AttemptedValueFooBar", helper.ValueForModel().ToHtmlString());
        }

        [Fact]
        [ReplaceCulture]
        public void ValueHelpersWithEmptyNameConvertModelValueUsingCurrentCulture()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetValueViewData());
            string expectedModelValue = "{ foo = ViewItemFoo, bar = 01/01/1900 00:00:00 }";

            // Act & Assert
            Assert.Equal(expectedModelValue, helper.Value(name: String.Empty).ToHtmlString());
            Assert.Equal(expectedModelValue, helper.ValueFor(m => m).ToHtmlString());
            Assert.Equal(expectedModelValue, helper.ValueForModel().ToHtmlString());
        }

        [Fact]
        [ReplaceCulture]
        public void ValueHelpersFormatValue()
        {
            // Arrange
            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(GetValueViewData());
            string expectedModelValue = "-{ foo = ViewItemFoo, bar = 01/01/1900 00:00:00 }-";
            string expectedBarValue = "-01/01/1900 00:00:00-";

            // Act & Assert
            Assert.Equal(expectedModelValue, helper.ValueForModel("-{0}-").ToHtmlString());
            Assert.Equal(expectedBarValue, helper.Value("bar", "-{0}-").ToHtmlString());
            Assert.Equal(expectedBarValue, helper.ValueFor(m => m.bar, "-{0}-").ToHtmlString());
        }

        [Fact]
        public void ValueHelpersEncodeValue()
        {
            // Arrange
            ViewDataDictionary<FooBarModel> viewData = new ViewDataDictionary<FooBarModel> { { "foo", @"ViewDataFoo <"">" } };
            viewData.Model = new FooBarModel { foo = @"ViewItemFoo <"">" };

            ModelState modelStateFoo = new ModelState();
            modelStateFoo.Value = HtmlHelperTest.GetValueProviderResult(new string[] { @"AttemptedValueBar <"">" }, @"AttemptedValueBar <"">");
            viewData.ModelState["bar"] = modelStateFoo;

            HtmlHelper<FooBarModel> helper = MvcHelper.GetHtmlHelper(viewData);

            // Act & Assert
            Assert.Equal("&lt;{ foo = ViewItemFoo &lt;&quot;>, bar = (null) }", helper.ValueForModel("<{0}").ToHtmlString());
            Assert.Equal("&lt;ViewDataFoo &lt;&quot;>", helper.Value("foo", "<{0}").ToHtmlString());
            Assert.Equal("&lt;ViewItemFoo &lt;&quot;>", helper.ValueFor(m => m.foo, "<{0}").ToHtmlString());
            Assert.Equal("AttemptedValueBar &lt;&quot;>", helper.ValueFor(m => m.bar).ToHtmlString());
        }

        [Theory]
        [PropertyData("AttributeEncodedData", PropertyType = typeof(EncodedDataSets))]
        public void ValueHelpers_AttributeEncode_Value(string text, bool htmlEncode, string encodedText)
        {
            // Arrange
            var viewData = new ViewDataDictionary<string>(text);
            viewData.ModelMetadata.HtmlEncode = htmlEncode;
            var helper = MvcHelper.GetHtmlHelper(viewData);

            // Act
            var valueResult = helper.Value("").ToHtmlString();
            var valueForResult = helper.ValueFor(m => m).ToHtmlString();
            var valueForModelResult = helper.ValueForModel().ToHtmlString();

            // Assert
            Assert.Equal(encodedText, valueResult);
            Assert.Equal(encodedText, valueForResult);
            Assert.Equal(encodedText, valueForModelResult);
        }

        private sealed class FooBarModel
        {
            public string foo { get; set; }
            public object bar { get; set; }

            public override string ToString()
            {
                return String.Format("{{ foo = {0}, bar = {1} }}", foo ?? "(null)", bar ?? "(null)");
            }
        }

        private static ViewDataDictionary<FooBarModel> GetValueViewData()
        {
            ViewDataDictionary<FooBarModel> viewData = new ViewDataDictionary<FooBarModel> { { "foo", "ViewDataFoo" } };
            viewData.Model = new FooBarModel { foo = "ViewItemFoo", bar = new DateTime(1900, 1, 1, 0, 0, 0) };

            return viewData;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;

[assembly: CLSCompliant(false)]

================================================
FILE: test/System.Web.Mvc.Test/Properties/Resources.Designer.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.34003
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace System.Web.Properties {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("System.Web.Properties.Resources", typeof(Resources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hello &apos;{0}&apos;, goodbye &apos;{1}&apos;..
        /// </summary>
        internal static string CompareAttributeTestResource {
            get {
                return ResourceManager.GetString("CompareAttributeTestResource", resourceCulture);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Properties/Resources.resx
================================================
<?xml version="1.0" encoding="utf-8"?>
<root>
  <!-- 
    Microsoft ResX Schema 
    
    Version 2.0
    
    The primary goals of this format is to allow a simple XML format 
    that is mostly human readable. The generation and parsing of the 
    various data types are done through the TypeConverter classes 
    associated with the data types.
    
    Example:
    
    ... ado.net/XML headers & schema ...
    <resheader name="resmimetype">text/microsoft-resx</resheader>
    <resheader name="version">2.0</resheader>
    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
        <value>[base64 mime encoded serialized .NET Framework object]</value>
    </data>
    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
        <comment>This is a comment</comment>
    </data>
                
    There are any number of "resheader" rows that contain simple 
    name/value pairs.
    
    Each data row contains a name, and value. The row also contains a 
    type or mimetype. Type corresponds to a .NET class that support 
    text/value conversion through the TypeConverter architecture. 
    Classes that don't support this are serialized and stored with the 
    mimetype set.
    
    The mimetype is used for serialized objects, and tells the 
    ResXResourceReader how to depersist the object. This is currently not 
    extensible. For a given mimetype the value must be set accordingly:
    
    Note - application/x-microsoft.net.object.binary.base64 is the format 
    that the ResXResourceWriter will generate, however the reader can 
    read any of the formats listed below.
    
    mimetype: application/x-microsoft.net.object.binary.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
            : and then encoded with base64 encoding.
    
    mimetype: application/x-microsoft.net.object.soap.base64
    value   : The object must be serialized with 
            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
            : and then encoded with base64 encoding.

    mimetype: application/x-microsoft.net.object.bytearray.base64
    value   : The object must be serialized into a byte array 
            : using a System.ComponentModel.TypeConverter
            : and then encoded with base64 encoding.
    -->
  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
    <xsd:element name="root" msdata:IsDataSet="true">
      <xsd:complexType>
        <xsd:choice maxOccurs="unbounded">
          <xsd:element name="metadata">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" />
              </xsd:sequence>
              <xsd:attribute name="name" use="required" type="xsd:string" />
              <xsd:attribute name="type" type="xsd:string" />
              <xsd:attribute name="mimetype" type="xsd:string" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="assembly">
            <xsd:complexType>
              <xsd:attribute name="alias" type="xsd:string" />
              <xsd:attribute name="name" type="xsd:string" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="data">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
              <xsd:attribute ref="xml:space" />
            </xsd:complexType>
          </xsd:element>
          <xsd:element name="resheader">
            <xsd:complexType>
              <xsd:sequence>
                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
              </xsd:sequence>
              <xsd:attribute name="name" type="xsd:string" use="required" />
            </xsd:complexType>
          </xsd:element>
        </xsd:choice>
      </xsd:complexType>
    </xsd:element>
  </xsd:schema>
  <resheader name="resmimetype">
    <value>text/microsoft-resx</value>
  </resheader>
  <resheader name="version">
    <value>2.0</value>
  </resheader>
  <resheader name="reader">
    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <resheader name="writer">
    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
  </resheader>
  <data name="CompareAttributeTestResource" xml:space="preserve">
    <value>Hello '{0}', goodbye '{1}'.</value>
  </data>
</root>

================================================
FILE: test/System.Web.Mvc.Test/Razor/Test/MvcCSharpRazorCodeGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Collections.Generic;
using System.Web.Razor;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Razor.Test
{
    public class MvcCSharpRazorCodeGeneratorTest
    {
        [Fact]
        public void Constructor()
        {
            // Arrange
            Mock<RazorEngineHost> mockHost = new Mock<RazorEngineHost>();

            // Act
            var generator = new MvcCSharpRazorCodeGenerator("FooClass", "Root.Namespace", "SomeSourceFile.cshtml", mockHost.Object);

            // Assert
            Assert.Equal("FooClass", generator.ClassName);
            Assert.Equal("Root.Namespace", generator.RootNamespaceName);
            Assert.Equal("SomeSourceFile.cshtml", generator.SourceFileName);
            Assert.Same(mockHost.Object, generator.Host);
        }

        [Fact]
        public void Constructor_DoesNotSetBaseTypeForNonMvcHost()
        {
            // Arrange
            Mock<RazorEngineHost> mockHost = new Mock<RazorEngineHost>();
            mockHost.SetupGet(h => h.NamespaceImports).Returns(new HashSet<string>());

            // Act
            var generator = new MvcCSharpRazorCodeGenerator("FooClass", "Root.Namespace", "SomeSourceFile.cshtml", mockHost.Object);

            // Assert
            Assert.Empty(generator.Context.GeneratedClass.BaseTypes);
        }

        [Fact]
        public void Constructor_DoesNotSetBaseTypeForSpecialPage()
        {
            // Arrange
            Mock<MvcWebPageRazorHost> mockHost = new Mock<MvcWebPageRazorHost>("_viewStart.cshtml", "_viewStart.cshtml");
            mockHost.SetupGet(h => h.NamespaceImports).Returns(new HashSet<string>());

            // Act
            var generator = new MvcCSharpRazorCodeGenerator("FooClass", "Root.Namespace", "_viewStart.cshtml", mockHost.Object);

            // Assert
            Assert.Empty(generator.Context.GeneratedClass.BaseTypes);
        }

        [Fact]
        public void Constructor_SetsBaseTypeForRegularPage()
        {
            // Arrange
            Mock<MvcWebPageRazorHost> mockHost = new Mock<MvcWebPageRazorHost>("SomeSourceFile.cshtml", "SomeSourceFile.cshtml") { CallBase = true };
            mockHost.SetupGet(h => h.NamespaceImports).Returns(new HashSet<string>());

            // Act
            var generator = new MvcCSharpRazorCodeGenerator("FooClass", "Root.Namespace", "SomeSourceFile.cshtml", mockHost.Object);

            // Assert
            var baseType = Assert.IsType<CodeTypeReference>(Assert.Single(generator.Context.GeneratedClass.BaseTypes));
            Assert.Equal("System.Web.Mvc.WebViewPage<dynamic>", baseType.BaseType);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Razor/Test/MvcCSharpRazorCodeParserTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Razor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Razor.Test
{
    public class MvcCSharpRazorCodeParserTest
    {
        [Fact]
        public void Constructor_AddsModelKeyword()
        {
            var parser = new TestMvcCSharpRazorCodeParser();

            Assert.True(parser.HasDirective("model"));
        }

        [Fact]
        public void ParseModelKeyword_HandlesSingleInstance()
        {
            // Arrange + Act
            var document = "@model    Foo";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("   Foo")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}<{1}>"))
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_HandlesNullableTypes()
        {
            // Arrange + Act
            var document = "@model Foo?\r\nBar";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo?\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo?", "{0}<{1}>")),
                factory.Markup("Bar")
                    .With(new MarkupCodeGenerator())
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_HandlesArrays()
        {
            // Arrange + Act
            var document = "@model Foo[[]][]\r\nBar";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo[[]][]\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo[[]][]", "{0}<{1}>")),
                factory.Markup("Bar")
                    .With(new MarkupCodeGenerator())
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_HandlesVSTemplateSyntax()
        {
            // Arrange + Act
            var document = "@model $rootnamespace$.MyModel";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("$rootnamespace$.MyModel")
                    .As(new SetModelTypeCodeGenerator("$rootnamespace$.MyModel", "{0}<{1}>"))
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnMissingModelType()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document = "@model   ";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("  ")
                    .As(new SetModelTypeCodeGenerator(String.Empty, "{0}<{1}>")),
            };
            var expectedErrors = new[]
            {
                new RazorError("The 'model' keyword must be followed by a type name on the same line.", new SourceLocation(9, 0, 9), 1)
            };
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnMultipleModelStatements()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                "@model Foo" + Environment.NewLine
              + "@model Bar";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}<{1}>")),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar")
                    .As(new SetModelTypeCodeGenerator("Bar", "{0}<{1}>"))
            };

            var expectedErrors = new[]
            {
                new RazorError("Only one 'model' statement is allowed in a file.", new SourceLocation(18, 1, 6), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnModelFollowedByInherits()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                "@model Foo" + Environment.NewLine
              + "@inherits Bar";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}<{1}>")),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("inherits ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar")
                    .As(new SetBaseTypeCodeGenerator("Bar"))
            };

            var expectedErrors = new[]
            {
                new RazorError("The 'inherits' keyword is not allowed when a 'model' keyword is used.", new SourceLocation(21, 1, 9), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnInheritsFollowedByModel()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                "@inherits Bar" + Environment.NewLine
              + "@model Foo";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateCsHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("inherits ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar" + Environment.NewLine)
                    .As(new SetBaseTypeCodeGenerator("Bar")),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("model ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}<{1}>"))
            };

            var expectedErrors = new[]
            {
                new RazorError("The 'inherits' keyword is not allowed when a 'model' keyword is used.", new SourceLocation(9, 0, 9), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        private static List<Span> ParseDocument(string documentContents, IList<RazorError> errors = null)
        {
            errors = errors ?? new List<RazorError>();
            var markupParser = new HtmlMarkupParser();
            var codeParser = new TestMvcCSharpRazorCodeParser();
            var context = new ParserContext(new SeekableTextReader(documentContents), codeParser, markupParser, markupParser);
            codeParser.Context = context;
            markupParser.Context = context;
            markupParser.ParseDocument();

            ParserResults results = context.CompleteParse();
            foreach (RazorError error in results.ParserErrors)
            {
                errors.Add(error);
            }
            return results.Document.Flatten().ToList();
        }

        private sealed class TestMvcCSharpRazorCodeParser : MvcCSharpRazorCodeParser
        {
            public bool HasDirective(string directive)
            {
                Action handler;
                return TryGetDirectiveHandler(directive, out handler);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Razor/Test/MvcVBRazorCodeParserTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Razor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Razor.Test
{
    public class MvcVBRazorCodeParserTest
    {
        [Fact]
        public void Constructor_AddsModelKeyword()
        {
            var parser = new MvcVBRazorCodeParser();

            Assert.True(parser.IsDirectiveDefined(MvcVBRazorCodeParser.ModelTypeKeyword));
        }

        [Fact]
        public void ParseModelKeyword_HandlesSingleInstance()
        {
            // Arrange + Act
            var document = "@ModelType    Foo";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType    ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}(Of {1})"))
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_HandlesNullableTypes()
        {
            // Arrange + Act
            var document = "@ModelType Foo?\r\nBar";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo?\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo?", "{0}(Of {1})")),
                factory.Markup("Bar")
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_HandlesArrays()
        {
            // Arrange + Act
            var document = "@ModelType Foo(())()\r\nBar";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo(())()\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo(())()", "{0}(Of {1})")),
                factory.Markup("Bar")
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_HandlesVSTemplateSyntax()
        {
            // Arrange + Act
            var document = "@ModelType $rootnamespace$.MyModel";
            var spans = ParseDocument(document);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("$rootnamespace$.MyModel")
                    .As(new SetModelTypeCodeGenerator("$rootnamespace$.MyModel", "{0}(Of {1})"))
            };
            Assert.Equal(expectedSpans, spans.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnMissingModelType()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document = "@ModelType   ";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType   ")
                    .Accepts(AcceptedCharacters.None),
                factory.EmptyVB()
                    .As(new SetModelTypeCodeGenerator(String.Empty, "{0}(Of {1})"))
                    .Accepts(AcceptedCharacters.Any)
            };
            var expectedErrors = new[]
            {
                new RazorError("The 'ModelType' keyword must be followed by a type name on the same line.", new SourceLocation(10, 0, 10), 1)
            };
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_DoesNotAcceptNewlineIfInDesignTimeMode()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document = "@ModelType foo\r\n";
            var spans = ParseDocument(document, errors, designTimeMode: true);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("foo")
                    .As(new SetModelTypeCodeGenerator("foo", "{0}(Of {1})"))
                    .Accepts(AcceptedCharacters.Any),
                factory.Markup("\r\n")
            };
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Empty(errors);
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnMultipleModelStatements()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                "@ModelType Foo" + Environment.NewLine
              + "@ModelType Bar";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}(Of {1})")),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar")
                    .As(new SetModelTypeCodeGenerator("Bar", "{0}(Of {1})"))
            };

            var expectedErrors = new[]
            {
                new RazorError("Only one 'ModelType' statement is allowed in a file.", new SourceLocation(26, 1, 10), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnModelFollowedByInherits()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                "@ModelType Foo" + Environment.NewLine
              + "@Inherits Bar";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo\r\n")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}(Of {1})")),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("Inherits ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar")
                    .As(new SetBaseTypeCodeGenerator("Bar"))
            };

            var expectedErrors = new[]
            {
                new RazorError("The 'inherits' keyword is not allowed when a 'ModelType' keyword is used.", new SourceLocation(25, 1, 9), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        [Fact]
        public void ParseModelKeyword_ErrorOnInheritsFollowedByModel()
        {
            // Arrange + Act
            List<RazorError> errors = new List<RazorError>();
            var document =
                "@Inherits Bar" + Environment.NewLine
              + "@ModelType Foo";
            var spans = ParseDocument(document, errors);

            // Assert
            var factory = SpanFactory.CreateVbHtml();
            var expectedSpans = new Span[]
            {
                factory.EmptyHtml(),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("Inherits ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Bar\r\n")
                    .AsBaseType("Bar"),
                factory.CodeTransition(SyntaxConstants.TransitionString)
                    .Accepts(AcceptedCharacters.None),
                factory.MetaCode("ModelType ")
                    .Accepts(AcceptedCharacters.None),
                factory.Code("Foo")
                    .As(new SetModelTypeCodeGenerator("Foo", "{0}(Of {1})"))
            };

            var expectedErrors = new[]
            {
                new RazorError("The 'inherits' keyword is not allowed when a 'ModelType' keyword is used.", new SourceLocation(9, 0, 9), 1)
            };
            expectedSpans.Zip(spans, (exp, span) => new { expected = exp, span = span }).ToList().ForEach(i => Assert.Equal(i.expected, i.span));
            Assert.Equal(expectedSpans, spans.ToArray());
            Assert.Equal(expectedErrors, errors.ToArray());
        }

        private static List<Span> ParseDocument(string documentContents, List<RazorError> errors = null, bool designTimeMode = false)
        {
            errors = errors ?? new List<RazorError>();
            var markupParser = new HtmlMarkupParser();
            var codeParser = new MvcVBRazorCodeParser();
            var context = new ParserContext(new SeekableTextReader(documentContents), codeParser, markupParser, markupParser);
            context.DesignTimeMode = designTimeMode;
            codeParser.Context = context;
            markupParser.Context = context;
            markupParser.ParseDocument();

            ParserResults results = context.CompleteParse();
            foreach (RazorError error in results.ParserErrors)
            {
                errors.Add(error);
            }
            return results.Document.Flatten().ToList();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Razor/Test/MvcWebPageRazorHostTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Razor.Test
{
    public class MvcWebPageRazorHostTest
    {
        [Fact]
        public void Constructor()
        {
            MvcWebPageRazorHost host = new MvcWebPageRazorHost("foo.cshtml", "bar");

            Assert.Equal("foo.cshtml", host.VirtualPath);
            Assert.Equal("bar", host.PhysicalPath);
            Assert.Equal(typeof(WebViewPage).FullName, host.DefaultBaseClass);
        }

        [Fact]
        public void ConstructorRemovesUnwantedNamespaceImports()
        {
            MvcWebPageRazorHost host = new MvcWebPageRazorHost("foo.cshtml", "bar");

            Assert.False(host.NamespaceImports.Contains("System.Web.WebPages.Html"));

            // Even though MVC no longer needs to remove the following two namespaces
            // (because they are no longer imported by System.Web.WebPages), we want
            // to make sure that they don't get introduced again by default.
            Assert.False(host.NamespaceImports.Contains("WebMatrix.Data"));
            Assert.False(host.NamespaceImports.Contains("WebMatrix.WebData"));
        }

#if VB_ENABLED
        [Fact]
        public void DecorateGodeGenerator_ReplacesVBCodeGeneratorWithMvcSpecificOne() {
            // Arrange
            MvcWebPageRazorHost host = new MvcWebPageRazorHost("foo.vbhtml", "bar");
            var generator = new VBRazorCodeGenerator("someClass", "root.name", "foo.vbhtml", host);

            // Act
            var result = host.DecorateCodeGenerator(generator);

            // Assert
            Assert.IsType<MvcVBRazorCodeGenerator>(result);
            Assert.Equal("someClass", result.ClassName);
            Assert.Equal("root.name", result.RootNamespaceName);
            Assert.Equal("foo.vbhtml", result.SourceFileName);
            Assert.Same(host, result.Host);
        }
#endif

        [Fact]
        public void DecorateGodeGenerator_ReplacesCSharpCodeGeneratorWithMvcSpecificOne()
        {
            // Arrange
            MvcWebPageRazorHost host = new MvcWebPageRazorHost("foo.cshtml", "bar");
            var generator = new CSharpRazorCodeGenerator("someClass", "root.name", "foo.cshtml", host);

            // Act
            var result = host.DecorateCodeGenerator(generator);

            // Assert
            Assert.IsType<MvcCSharpRazorCodeGenerator>(result);
            Assert.Equal("someClass", result.ClassName);
            Assert.Equal("root.name", result.RootNamespaceName);
            Assert.Equal("foo.cshtml", result.SourceFileName);
            Assert.Same(host, result.Host);
        }

        [Fact]
        public void DecorateCodeParser_ThrowsOnNull()
        {
            MvcWebPageRazorHost host = new MvcWebPageRazorHost("foo.cshtml", "bar");
            Assert.ThrowsArgumentNull(delegate() { host.DecorateCodeParser(null); }, "incomingCodeParser");
        }

        [Fact]
        public void DecorateCodeParser_ReplacesCSharpCodeParserWithMvcSpecificOne()
        {
            // Arrange
            MvcWebPageRazorHost host = new MvcWebPageRazorHost("foo.cshtml", "bar");
            var parser = new CSharpCodeParser();

            // Act
            var result = host.DecorateCodeParser(parser);

            // Assert
            Assert.IsType<MvcCSharpRazorCodeParser>(result);
        }

#if VB_ENABLED
        [Fact]
        public void DecorateCodeParser_ReplacesVBCodeParserWithMvcSpecificOne() {
            // Arrange
            MvcWebPageRazorHost host = new MvcWebPageRazorHost("foo.vbhtml", "bar");
            var parser = new VBCodeParser();

            // Act
            var result = host.DecorateCodeParser(parser);

            // Assert
            Assert.IsType<MvcVBRazorCodeParser>(result);
        }
#endif
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Routing/AttributeRoutingLinkGenerationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Routing.Test
{
    public class AttributeRoutingLinkGenerationTest
    {
        [Fact]
        public void GenerateLink_ToArea_ControllerRoute_WithPrefix()
        {
            // Arrange
            Type[] controllerTypes = new Type[] { typeof(AreaWithPrefixWithControllerRouteController) };
            RouteCollection routes = MapControllers(controllerTypes);
            RequestContext requestContext = GetRequestContext();

            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "controller", "AreaWithPrefixWithControllerRoute" },
                { "action", "A1" },
                { "area", "Administration" }
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal("/Admin/Home/A1", vpd.VirtualPath);
        }

        [Fact]
        public void GenerateLink_ToArea_ActionRoute_WithPrefix()
        {
            // Arrange
            Type[] controllerTypes = new Type[] { typeof(AreaWithPrefixWithControllerRouteController) };
            RouteCollection routes = MapControllers(controllerTypes);
            RequestContext requestContext = GetRequestContext();

            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "controller", "AreaWithPrefixWithControllerRoute" },
                { "action", "A2" },
                { "area", "Administration" }
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal("/Admin", vpd.VirtualPath);
        }

        [Fact]
        public void GenerateLink_ToArea_ActionRoute_WithPrefix_WithinController()
        {
            // Arrange
            Type[] controllerTypes = new Type[] { typeof(AreaWithPrefixWithControllerRouteController) };
            RouteCollection routes = MapControllers(controllerTypes);
            RequestContext requestContext = GetRequestContext();

            requestContext.RouteData.DataTokens.Add("area", "Administration");
            requestContext.RouteData.DataTokens.Add("controller", "AreaWithPrefixWithControllerRoute");

            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "action", "A2" },
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal("/Admin", vpd.VirtualPath);
        }

        [Fact]
        public void GenerateLink_ToController_PrefersActionRoute()
        {
            // Arrange
            Type[] controllerTypes = new Type[] { typeof(MixedRoutingController) };
            RouteCollection routes = MapControllers(controllerTypes);
            RequestContext requestContext = GetRequestContext();

            requestContext.RouteData.DataTokens.Add("controller", "MixedRouting");

            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "action", "A2" },
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal("/A2", vpd.VirtualPath);
            Assert.True(((Route)vpd.Route).GetTargetIsAction());
        }

        [Fact]
        public void GenerateLink_ToController_PrefersControllerRouteWithOrder()
        {
            // Arrange
            Type[] controllerTypes = new Type[] { typeof(MixedRoutingWithOrderController) };
            RouteCollection routes = MapControllers(controllerTypes);
            RequestContext requestContext = GetRequestContext();

            requestContext.RouteData.DataTokens.Add("controller", "MixedRoutingWithOrder");

            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "action", "A2" },
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal("/mixedroutingwithorder/A2", vpd.VirtualPath);
            Assert.False(((Route)vpd.Route).GetTargetIsAction());
        }

        /// <summary>
        /// This test validates that these routes aren't overly greedy. We don't want the route
        /// for C2 to match when we're looking for C1.
        /// </summary>
        [Theory]
        [InlineData(typeof(Controller1Controller), typeof(Controller2Controller))]
        [InlineData(typeof(Controller2Controller), typeof(Controller1Controller))]
        public void GenerateLink_MultiplControllerRoutesMatch(Type c1, Type c2)
        {
            // Arrange
            Type[] controllerTypes = new Type[] { c1, c2 };
            RouteCollection routes = MapControllers(controllerTypes);
            RequestContext requestContext = GetRequestContext();

            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "action", "A1" },
                { "controller", "Controller1" }
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal("/c1/A1", vpd.VirtualPath);
        }

        private static RequestContext GetRequestContext()
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.Request.ApplicationPath).Returns("/");
            mockHttpContext.Setup(c => c.Response.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(virtualPath => virtualPath);

            return new RequestContext(mockHttpContext.Object, new RouteData());
        }

        private RouteCollection MapControllers(Type[] types)
        {
            RouteCollection routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, types);
            return routes;
        }

        [Route("Home/{action}")]
        [RouteArea("Administration", AreaPrefix = "Admin")]
        private class AreaWithPrefixWithControllerRouteController : Controller
        {
            public void A1()
            {
            }

            [Route]
            public void A2()
            {
            }
        }

        [Route("c1/{action}")]
        private class Controller1Controller : Controller
        {
            public void A1()
            {
            }
        }

        [Route("c2/{action}")]
        private class Controller2Controller : Controller
        {
            public void A1()
            {
            }
        }

        [Route("mixedrouting/{action}")]
        private class MixedRoutingController : Controller
        {
            public void A1()
            {
            }

            // The catch-all parameter is here to make sure this route has a worse precedence
            // than the controller-level route.
            [Route("A2/{*params}")]
            public void A2()
            {
            }
        }

        [Route("mixedroutingwithorder/{action}")]
        private class MixedRoutingWithOrderController : Controller
        {
            public void A1()
            {
            }

            // The order makes this 'worse' than the controller level route - if a user does this it's likely
            // because they have two actions with the same name.
            [Route("A2/{*params}", Order=55)]
            public void A2()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Routing/AttributeRoutingMapperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Routing
{
    public class AttributeRoutingMapperTest
    {
        [Fact]
        public void MapMvcAttributeRoutes_DoesNotTryToInferRouteNames()
        {
            var controllerType = typeof(MyController);

            var routeEntries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);

            var routeEntry = Assert.Single(routeEntries);
            Assert.Null(routeEntry.Name);
        }

        [Fact]
        public void MapMvcAttributeRoutes_RespectsActionNameAttribute()
        {
            // Arrange
            var controllerType = typeof(MyController);

            // Act
            var routeEntries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);

            // Assert
            var routeEntry = Assert.Single(routeEntries);
            Assert.Equal("ActionName", routeEntry.Route.Defaults["action"]);
        }

        [Fact]
        public void MapMvcAttributeRoutes_WithControllerRoute()
        {
            // Arrange
            var controllerType = typeof(AnotherController);

            // Act
            var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);

            // Assert
            var controllerEntry = Assert.Single(entries, r => !r.Route.Defaults.ContainsKey("action"));
            Assert.Same(controllerType, controllerEntry.Route.GetTargetControllerDescriptor().ControllerType);

            var actionMethods = controllerEntry.Route.GetTargetActionDescriptors().ToArray();
            Assert.Equal(2, actionMethods.Length);
            Assert.Single(actionMethods, a => a.ActionName == "RegularAction");
            Assert.Single(actionMethods, a => a.ActionName == "AnotherAction");
        }

        [Fact]
        public void MapMvcAttributeRoutes_WithControllerRoute_AndNoReachableActions()
        {
            // Arrange
            var controllerType = typeof(NoActionsController);

            // Act
            var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);

            // Assert
            Assert.Empty(entries);
        }

        [Fact]
        public void MapMvcAttributeRoutes_WithControllerRoute_ExcludesAttributeRoute()
        {
            // Arrange
            var controllerType = typeof(MixedRoutingController);

            // Act
            var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);

            // Assert
            var controllerEntry = Assert.Single(entries, r => !r.Route.Defaults.ContainsKey("action"));
            Assert.Same(controllerType, controllerEntry.Route.GetTargetControllerDescriptor().ControllerType);

            var actionMethods = controllerEntry.Route.GetTargetActionDescriptors().ToArray();
            Assert.Single(actionMethods);
            Assert.Single(actionMethods, a => a.ActionName == "GoodAction");

            var actionEntry = Assert.Single(entries, r => r.Route.Defaults.ContainsKey("action"));
            Assert.Equal("DirectRouteAction", Assert.Single(actionEntry.Route.GetTargetActionDescriptors()).ActionName);
        }

        [Fact]
        public void MapMvcAttributeRoutes_SetsTargetIsAction()
        {
            // Arrange
            var controllerType = typeof(MixedRoutingController);

            // Act
            var entries = AttributeRoutingMapper.GetAttributeRoutes(controllerType);

            // Assert
            var controllerEntry = Assert.Single(entries, r => !r.Route.Defaults.ContainsKey("action"));
            Assert.False(controllerEntry.Route.GetTargetIsAction());

            var actionEntry = Assert.Single(entries, r => r.Route.Defaults.ContainsKey("action"));
            Assert.True(actionEntry.Route.GetTargetIsAction());
        }

        [Fact]
        public void MapMvcAttributeRoutes_ValidatesConstraints()
        {
            // Arrange
            var controllerType = typeof(InvalidConstraintController);

            string expectedMessage =
                "The constraint entry 'custom' on the route with route template 'invalidconstraint/{action}' " +
                "must have a string value or be of a type which implements 'System.Web.Routing.IRouteConstraint'.";


            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => AttributeRoutingMapper.GetAttributeRoutes(controllerType), expectedMessage);
        }

        [InvalidConstraintRoute("invalidconstraint/{action}")]
        public class InvalidConstraintController : Controller
        {
            public void A1()
            {
            }
        }

        public class InvalidConstraintRouteAttribute : RouteFactoryAttribute
        {
            public InvalidConstraintRouteAttribute(string template)
                : base(template)
            {
            }

            public override RouteValueDictionary Constraints
            {
                get
                {
                    var result = new RouteValueDictionary();
                    result.Add("custom", new Uri("http://localhost"));
                    return result;
                }
            }
        }

        public class MyController : Controller
        {
            [HttpGet]
            [Route("")]
            [ActionName("ActionName")]
            public void MethodName()
            {
            }
        }

        [Route("controller/{action}")]
        public class AnotherController : Controller
        {
            public void RegularAction()
            {
            }

            public void AnotherAction()
            {
            }
        }

        [Route("controller/{action}")]
        public class NoActionsController : Controller
        {
        }

        [Route("controller/{action}")]
        public class MixedRoutingController : Controller
        {
            [Route("Yep")]
            public void DirectRouteAction()
            {
            }

            public void GoodAction()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Routing/AttributeRoutingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Reflection;
using System.Web.Mvc;
using System.Web.Mvc.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Routing
{
    public class AttributeRoutingTest
    {
        internal const string ResultKey = "MS_Test_Result";

        [Theory]
        [InlineData(typeof(DerivedController), "~/BaseMethodWithRoute", "BaseMethodWithRoute")]
        [InlineData(typeof(DerivedController), "~/BaseVirtualMethodWithRoute", "BaseVirtualMethodWithRoute")]
        [InlineData(typeof(DerivedController), "~/BaseVirtualMethodWithRouteToBeOverridenWithRoute", "BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        [InlineData(typeof(DerivedController), "~/DerivedMethodWithRoute", "DerivedMethodWithRoute")]
        [InlineData(typeof(DerivedController), "~/BaseVirtualMethodToBeOverridenWithRoute_Derived", "BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedController), "~/BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived", "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedController), "~/BaseMethodWithRouteWithName", "BaseMethodWithRouteWithName")]
        [InlineData(typeof(DerivedPrefixController), "~/BaseMethodWithRoute", "BaseMethodWithRoute")]
        [InlineData(typeof(DerivedPrefixController), "~/BaseVirtualMethodWithRoute", "BaseVirtualMethodWithRoute")]
        [InlineData(typeof(DerivedPrefixController), "~/BaseVirtualMethodWithRouteToBeOverridenWithRoute", "BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        [InlineData(typeof(DerivedPrefixController), "~/derived/DerivedMethodWithRoute", "DerivedMethodWithRoute")]
        [InlineData(typeof(DerivedPrefixController), "~/derived/BaseVirtualMethodToBeOverridenWithRoute_Derived", "BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedPrefixController), "~/derived/BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived", "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedFromBasePrefixController), "~/base/BaseMethodWithRoute", "BaseMethodWithRoute")]
        [InlineData(typeof(DerivedFromBasePrefixController), "~/base/BaseVirtualMethodWithRoute", "BaseVirtualMethodWithRoute")]
        [InlineData(typeof(DerivedFromBasePrefixController), "~/base/BaseVirtualMethodWithRouteToBeOverridenWithRoute", "BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        [InlineData(typeof(DerivedFromBasePrefixController), "~/DerivedMethodWithRoute", "DerivedMethodWithRoute")]
        [InlineData(typeof(DerivedFromBasePrefixController), "~/BaseVirtualMethodToBeOverridenWithRoute_Derived", "BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedFromBasePrefixController), "~/BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived", "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedWithPrefixFromBasePrefixController), "~/base/BaseMethodWithRoute", "BaseMethodWithRoute")]
        [InlineData(typeof(DerivedWithPrefixFromBasePrefixController), "~/base/BaseVirtualMethodWithRoute", "BaseVirtualMethodWithRoute")]
        [InlineData(typeof(DerivedWithPrefixFromBasePrefixController), "~/base/BaseVirtualMethodWithRouteToBeOverridenWithRoute", "BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        [InlineData(typeof(DerivedWithPrefixFromBasePrefixController), "~/derived/DerivedMethodWithRoute", "DerivedMethodWithRoute")]
        [InlineData(typeof(DerivedWithPrefixFromBasePrefixController), "~/derived/BaseVirtualMethodToBeOverridenWithRoute_Derived", "BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedWithPrefixFromBasePrefixController), "~/derived/BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived", "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedFromBaseRouteController), "~/BaseMethodWithRoute", "BaseMethodWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteController), "~/base/BaseVirtualMethodToBeOverridenWithRoute", "BaseVirtualMethodToBeOverridenWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteController), "~/BaseVirtualMethodWithRoute", "BaseVirtualMethodWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteController), "~/BaseVirtualMethodWithRouteToBeOverridenWithRoute", "BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteController), "~/DerivedMethodWithRoute", "DerivedMethodWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteController), "~/BaseVirtualMethodToBeOverridenWithRoute_Derived", "BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        [InlineData(typeof(DerivedFromBaseRouteWithRouteController), "~/derivedwithroute/BaseMethodWithRoute", "BaseMethodWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteWithRouteController), "~/derivedwithroute/BaseVirtualMethodToBeOverridenWithRoute", "BaseVirtualMethodToBeOverridenWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteWithRouteController), "~/derivedwithroute/BaseVirtualMethodWithRoute", "BaseVirtualMethodWithRoute")]
        [InlineData(typeof(DerivedFromBaseRouteWithRouteController), "~/derivedwithroute/BaseVirtualMethodWithRouteToBeOverridenWithRoute", "BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        public void AttributeRouting_WithInheritance_MethodOverrides(Type derivedController, string path, string expectedAction)
        {
            // Arrange
            var controllerTypes = new[] { derivedController, derivedController.BaseType };
            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            // Act
            handler.ProcessRequest(context);

            // Assert
            ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
            Assert.Equal(expectedAction, result.Content);
        }

        [Theory]
        [InlineData(typeof(DerivedController), "~/BaseMethodWithRouteTypo")]
        [InlineData(typeof(DerivedController), "~/derived/BaseMethodWithRoute")]
        [InlineData(typeof(DerivedPrefixController), "~/derived/BaseVirtualMethodWithRoute")]
        [InlineData(typeof(DerivedWithPrefixFromBasePrefixController), "~/derived/BaseVirtualMethodWithRoute")]
        public void AttributeRouting_WithInheritance_InvalidPaths(Type derivedController, string path)
        {
            // Arrange
            var controllerTypes = new[] { derivedController, derivedController.BaseType };
            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);
            HttpContextBase context = GetContext(path);

            // Act
            RouteData routeData = routes.GetRouteData(context);

            // Assert
            Assert.Null(routeData);
        }

        [Theory]
        [InlineData(typeof(MethodOverloadsController), "~/Get1", "Get1")]
        [InlineData(typeof(MethodOverloadsController), "~/Get2?id=42", "Get2_42")]
        public void AttributeRouting_MethodOverloads_WithDifferentActionNames(Type controllerType, string path, string expectedAction)
        {
            // Arrange
            var controllerTypes = new[] { controllerType };
            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            // Act
            handler.ProcessRequest(context);

            // Assert
            ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
            Assert.Equal(expectedAction, result.Content);
        }

        [Theory]
        [InlineData(typeof(MethodOverloadsController), "~/GetAmbiguous?id=42")]
        public void AttributeRouting_AmbiguousActions_ThrowsAmbiguousException(Type controllerType, string path)
        {
            // Arrange
            var controllerTypes = new[] { controllerType };
            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            Assert.Throws<AmbiguousMatchException>(() => handler.ProcessRequest(context));
        }

        [Theory]
        [InlineData(typeof(MixedRoutingController), "~/GetWithRoute", "GetWithRoute")]
        [InlineData(typeof(MixedRoutingController), "~/standard/GetWithoutRoute", "GetWithoutRoute")]
        [InlineData(typeof(MixedRoutingController), "~/standard/GetWithRoute", null)]
        [InlineData(typeof(MixedRoutingWithPrefixController), "~/prefix/GetWithRoute", "GetWithRoute")]
        [InlineData(typeof(MixedRoutingWithPrefixController), "~/standard/GetWithoutRoute", "GetWithoutRoute")]
        [InlineData(typeof(MixedRoutingWithPrefixController), "~/standard/GetWithRoute", null)]
        [InlineData(typeof(MixedRoutingWithRouteonController), "~/GetWithRoute", "GetWithRoute")]
        [InlineData(typeof(MixedRoutingWithRouteonController), "~/GetWithoutRoute", "GetWithoutRoute")]
        [InlineData(typeof(MixedRoutingWithRouteonController), "~/standard/GetWithoutRoute", null)]
        [InlineData(typeof(MixedRoutingWithRouteonController), "~/standard/GetWithRoute", null)]
        public void AttributeRouting_MixedWithGeneralRouting(Type controllerType, string path, string expectedAction)
        {
            // Arrange
            var controllerTypes = new[] { controllerType };
            var routes = new RouteCollection();
            object defaults = new { controller = controllerType.Name.Substring(0, controllerType.Name.Length - 10) };
            routes.Add(new Route("standard/{action}", new RouteValueDictionary(defaults), null));
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            if (expectedAction == null)
            {
                // Act & Assert
                Assert.Throws<HttpException>(() => handler.ProcessRequest(context));
            }
            else
            {
                // Act
                handler.ProcessRequest(context);

                // Assert
                ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
                Assert.Equal(expectedAction, result.Content);
            }
        }

        [Theory]
        [InlineData(typeof(ActionMethodSelectorsController), "~/Action1", "Action1(int)")]
        [InlineData(typeof(ActionMethodSelectorsController), "~/DoesntRun", null)]
        public void AttributeRouting_WithActionMethodSelectors(Type controllerType, string path, string expectedAction)
        {
            // Arrange
            var controllerTypes = new[] { controllerType };
            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            if (expectedAction == null)
            {
                // Act & Assert
                Assert.Throws<HttpException>(() => handler.ProcessRequest(context));
            }
            else
            {
                // Act
                handler.ProcessRequest(context);

                // Assert
                ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
                Assert.Equal(expectedAction, result.Content);
            }
        }

        [Theory]
        [InlineData(typeof(ActionNameSelectorsController), "~/SpecialName", "Action2()")]
        [InlineData(typeof(ActionNameSelectorsController), "~/AnotherSpecialName", "Action3()")]
        public void AttributeRouting_WithActionNameSelectors(Type controllerType, string path, string expectedAction)
        {
            // Arrange
            var controllerTypes = new[] { controllerType };
            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            if (expectedAction == null)
            {
                // Act & Assert
                Assert.Throws<HttpException>(() => handler.ProcessRequest(context));
            }
            else
            {
                // Act
                handler.ProcessRequest(context);

                // Assert
                ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
                Assert.Equal(expectedAction, result.Content);
            }
        }

        [Fact]
        public void AttributeRouting_OptionalParametersGetRemoved()
        {
            // Arrange
            var controllerTypes = new[] { typeof(OptionalParameterController) };
            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext("~/Create");
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            // Act
            handler.ProcessRequest(context);

            // Assert
            ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
            Assert.Equal("Create()", result.Content);

            // The request context should be updated to to contain the routedata of the direct route
            Assert.Equal("{action}/{id}", ((Route)requestContext.RouteData.Route).Url);
            Assert.Null(requestContext.RouteData.Values["id"]);
        }

        [Theory]
        [InlineData("~/Home1/Index", "Home1.Index()")]
        [InlineData("~/Home2/Index", "Home2.Index()")]
        public void AttributeRouting_WithSameControllerName(string path, string expectedAction)
        {
            // Arrange
            var controllerTypes = new[]
            {
                typeof(ControllersWithTheSameName.NS1.HomeController),
                typeof(ControllersWithTheSameName.NS2.HomeController),
            };

            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            // Act
            handler.ProcessRequest(context);

            // Assert
            ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
            Assert.Equal(expectedAction, result.Content);
        }

        [Theory]
        [InlineData("~/NS1Home/Introduction", "Home.Index()")]
        [InlineData("~/NS2Account/PeopleList", "Account.Index()")]
        [InlineData("~/Default/Unknown", "Default.Index()")]
        public void AttributeRouting_WithCustomizedRoutePrefixAttribute(string path, string expectedAction)
        {
            // Arrange
            var controllerTypes = new[]
            {
                typeof(ControllersWithCustomizedRoutePrefixAttribute.NS1.HomeController),
                typeof(ControllersWithCustomizedRoutePrefixAttribute.NS2.AccountController),
                typeof(ControllersWithCustomizedRoutePrefixAttribute.NS3.OtherController),
            };

            var routes = new RouteCollection();
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            HttpContextBase context = GetContext(path);
            RouteData routeData = routes.GetRouteData(context);
            RequestContext requestContext = new RequestContext(context, routeData);
            MvcHandler handler = new MvcHandler(requestContext);
            handler.ControllerBuilder.SetControllerFactory(GetControllerFactory(controllerTypes));

            // Act
            handler.ProcessRequest(context);

            // Assert
            ContentResult result = Assert.IsType<ContentResult>(context.Items[ResultKey]);
            Assert.Equal(expectedAction, result.Content);
        }

        [Fact]
        public void AttributeRouting_WithMultipleCustomizedRoutePrefixAttribute_ThrowsInvalidOperationException()
        {
            // Arrange
            var controllerTypes = new[]
            {
                typeof(ControllersWithCustomizedRoutePrefixAttribute.Invalid.HomeController)
            };

            var routes = new RouteCollection();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes),
                "Only one route prefix attribute is supported. Remove extra attributes from the controller of type 'System.Web.Routing.ControllersWithCustomizedRoutePrefixAttribute.Invalid.HomeController'.");
        }

        [Fact]
        public void AttributeRouting_WithNullPrefix_ThrowsInvalidOperationException()
        {
            // Arrange
            var controllerTypes = new[]
            {
                typeof(ControllersWithCustomizedRoutePrefixAttribute.Invalid.AccountController)
            };

            var routes = new RouteCollection();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes),
                "The property 'prefix' from route prefix attribute on controller of type 'System.Web.Routing.ControllersWithCustomizedRoutePrefixAttribute.Invalid.AccountController' cannot be null.");
        }

        private IControllerFactory GetControllerFactory(Type[] controllerTypes)
        {
            return new DefaultControllerFactory
            {
                BuildManager = new MockBuildManager(controllerTypes),
                ControllerTypeCache = new ControllerTypeCache()
            };
        }

        private HttpContextBase GetContext(string url)
        {
            Uri uri = new Uri("http://localhost/" + url.Substring(2));

            NameValueCollection queryString = HttpUtility.ParseQueryString(uri.Query);

            Mock<UnvalidatedRequestValuesBase> unvalidatedRequest = new Mock<UnvalidatedRequestValuesBase>();
            unvalidatedRequest.Setup(u => u.Form).Returns(new NameValueCollection());
            unvalidatedRequest.Setup(u => u.QueryString).Returns(queryString);

            // mock HttpRequest
            Mock<HttpRequestBase> requestMock = new Mock<HttpRequestBase>();
            requestMock.Setup(request => request.Url).Returns(uri);
            requestMock.Setup(request => request.HttpMethod).Returns("GET");
            requestMock.Setup(request => request.Form).Returns(new NameValueCollection());
            requestMock.Setup(request => request.ServerVariables).Returns(new NameValueCollection());
            requestMock.Setup(request => request.AppRelativeCurrentExecutionFilePath).Returns("~" + uri.AbsolutePath);
            requestMock.Setup(request => request.Unvalidated).Returns(unvalidatedRequest.Object);
            requestMock.Setup(request => request.ContentType).Returns("");
            requestMock.Setup(request => request.QueryString).Returns(queryString);
            requestMock.Setup(request => request.Files).Returns(new Mock<HttpFileCollectionBase>().Object);

            // mock HttpResponse
            Mock<HttpResponseBase> responseBase = new Mock<HttpResponseBase>();

            // mock HttpContext
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(context => context.Items).Returns(new Hashtable());
            contextMock.Setup(context => context.Request).Returns(requestMock.Object);
            contextMock.Setup(context => context.Response).Returns(responseBase.Object);
            return contextMock.Object;
        }

        private class MockBuildManager : IBuildManager
        {
            private Assembly[] _assemblies;

            public MockBuildManager(Type[] types)
            {
                MockAssembly assembly = new MockAssembly(types);
                _assemblies = new Assembly[] { assembly };
            }

            public bool FileExists(string virtualPath)
            {
                throw new NotImplementedException();
            }

            public Type GetCompiledType(string virtualPath)
            {
                throw new NotImplementedException();
            }

            public ICollection GetReferencedAssemblies()
            {
                return _assemblies;
            }

            public Stream ReadCachedFile(string fileName)
            {
                return null;
            }

            public Stream CreateCachedFile(string fileName)
            {
                return null;
            }

            private sealed class MockAssembly : Assembly
            {
                Type[] _types;

                public MockAssembly(params Type[] types)
                {
                    _types = types;
                }

                public override Type[] GetTypes()
                {
                    return _types;
                }
            }
        }
    }

    // stores the response from the action on the request context for later inspection.
    public class ResponseStoringController : Controller
    {
        protected override void OnActionExecuting(ActionExecutingContext filterContext)
        {
            // use the per-instance cache to avoid timing issues.
            filterContext.ActionDescriptor.DispatcherCache = new ActionMethodDispatcherCache();
            base.OnActionExecuting(filterContext);
        }

        protected override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            filterContext.RequestContext.HttpContext.Items[AttributeRoutingTest.ResultKey] = filterContext.Result;
        }
    }

    #region Inheritance Controllers

    public class BaseController : ResponseStoringController
    {
        [Route("BaseMethodWithRoute")]
        public string BaseMethodWithRoute()
        {
            return "BaseMethodWithRoute";
        }

        [Route("BaseMethodWithRouteWithName", Name = "BaseMethodWithRouteWithName")]
        public string BaseMethodWithRouteWithName()
        {
            return "BaseMethodWithRouteWithName";
        }

        public virtual string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute";
        }

        [Route("BaseVirtualMethodWithRoute")]
        public virtual string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        public virtual string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute";
        }
    }

    [RoutePrefix("base")]
    public class BasePrefixController : ResponseStoringController
    {
        [Route("BaseMethodWithRoute")]
        public string BaseMethodWithRoute()
        {
            return "BaseMethodWithRoute";
        }

        public virtual string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute";
        }

        [Route("BaseVirtualMethodWithRoute")]
        public virtual string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        public virtual string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute";
        }
    }

    [Route("base/{action}")]
    public class BaseRouteController : ResponseStoringController
    {
        [Route("BaseMethodWithRoute")]
        public string BaseMethodWithRoute()
        {
            return "BaseMethodWithRoute";
        }

        public virtual string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute";
        }

        [Route("BaseVirtualMethodWithRoute")]
        public virtual string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute")]
        public virtual string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute";
        }
    }

    public class DerivedController : BaseController
    {
        [Route("DerivedMethodWithRoute")]
        public string DerivedMethodWithRoute()
        {
            return "DerivedMethodWithRoute";
        }

        public override string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute_Derived";
        }

        [Route("BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute_Derived";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived";
        }
    }

    public class DerivedFromBasePrefixController : BasePrefixController
    {
        [Route("DerivedMethodWithRoute")]
        public string DerivedMethodWithRoute()
        {
            return "DerivedMethodWithRoute";
        }

        public override string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute_Derived";
        }

        [Route("BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute_Derived";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived";
        }
    }

    [RoutePrefix("derived")]
    public class DerivedPrefixController : BaseController
    {
        [Route("DerivedMethodWithRoute")]
        public string DerivedMethodWithRoute()
        {
            return "DerivedMethodWithRoute";
        }

        public override string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute_Derived";
        }

        [Route("BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute_Derived";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived";
        }
    }

    [RoutePrefix("derived")]
    public class DerivedWithPrefixFromBasePrefixController : BasePrefixController
    {
        [Route("DerivedMethodWithRoute")]
        public string DerivedMethodWithRoute()
        {
            return "DerivedMethodWithRoute";
        }

        public override string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute_Derived";
        }

        [Route("BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute_Derived";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived";
        }
    }

    public class DerivedFromBaseRouteController : BaseRouteController
    {
        [Route("DerivedMethodWithRoute")]
        public string DerivedMethodWithRoute()
        {
            return "DerivedMethodWithRoute";
        }

        public override string BaseVirtualMethodWithRoute()
        {
            return "BaseVirtualMethodWithRoute_Derived";
        }

        [Route("BaseVirtualMethodToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodToBeOverridenWithRoute_Derived";
        }

        [Route("BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived")]
        public override string BaseVirtualMethodWithRouteToBeOverridenWithRoute()
        {
            return "BaseVirtualMethodWithRouteToBeOverridenWithRoute_Derived";
        }
    }

    [Route("derivedwithroute/{action}")]
    public class DerivedFromBaseRouteWithRouteController : BaseRouteController
    {
    }

    #endregion

    public class MethodOverloadsController : ResponseStoringController
    {
        [Route("Get1")]
        public string Get()
        {
            return "Get1";
        }

        [Route("Get2")]
        public string Get(int id)
        {
            return "Get2_" + id;
        }

        [Route("GetAmbiguous")]
        public string GetAmbiguous(int id)
        {
            return "GetAmbiguous_Int";
        }

        [Route("GetAmbiguous")]
        public string GetAmbiguous(string id)
        {
            return "GetAmbiguous_String";
        }
    }

    public class MixedRoutingController : ResponseStoringController
    {
        public string GetWithoutRoute()
        {
            return "GetWithoutRoute";
        }

        [Route("GetWithRoute")]
        public string GetWithRoute()
        {
            return "GetWithRoute";
        }
    }

    [RoutePrefix("prefix")]
    public class MixedRoutingWithPrefixController : ResponseStoringController
    {
        public string GetWithoutRoute()
        {
            return "GetWithoutRoute";
        }

        [Route("GetWithRoute")]
        public string GetWithRoute()
        {
            return "GetWithRoute";
        }
    }

    [Route("{action}")]
    public class MixedRoutingWithRouteonController : ResponseStoringController
    {
        public string GetWithoutRoute()
        {
            return "GetWithoutRoute";
        }

        [Route("GetWithRoute")]
        public string GetWithRoute()
        {
            return "GetWithRoute";
        }
    }

    [Route("{action}")]
    public class ActionMethodSelectorsController : ResponseStoringController
    {
        public string Action1()
        {
            return "Action1()";
        }

        // This is a 'better' action than Action1() because it has a selector
        [BoolActionMethodSelector(true)]
        public string Action1(int id = 0)
        {
            return "Action1(int)";
        }

        // All ActionMethodSelectors need to return true
        [BoolActionMethodSelector(true)]
        [BoolActionMethodSelector(false)]
        public string DoesntRun()
        {
            return "DoesntRun";
        }
    }

    [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = true)]
    public class BoolActionMethodSelectorAttribute : ActionMethodSelectorAttribute
    {
        public BoolActionMethodSelectorAttribute(bool value)
        {
            Value = value;
        }

        private bool Value
        {
            get;
            set;
        }

        public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
        {
            return Value;
        }
    }

    [Route("{action}")]
    public class ActionNameSelectorsController : ResponseStoringController
    {
        [StringActionNameSelector("SpecialName")]
        public string Action1()
        {
            return "Action1()";
        }

        // This is 'better' because it has an action selector also
        [HttpGet]
        [StringActionNameSelector("SpecialName")]
        public string Action2()
        {
            return "Action2()";
        }

        [StringActionNameSelector("AnotherSpecialName")]
        public string Action3()
        {
            return "Action3()";
        }
    }

    /// <summary>
    /// A 'custom' implementation similar to ActionNameAttribute - using a custom attribute for tests
    /// because ActionNameAttribute is special cased by the ActionDescriptor class.
    /// </summary>
    public class StringActionNameSelectorAttribute : ActionNameSelectorAttribute
    {
        public StringActionNameSelectorAttribute(string actionName)
        {
            ActionName = actionName;
        }

        private string ActionName
        {
            get;
            set;
        }

        public override bool IsValidName(ControllerContext controllerContext, string actionName, MethodInfo methodInfo)
        {
            return String.Equals(actionName, ActionName, StringComparison.OrdinalIgnoreCase);
        }
    }

    [Route("{action}/{id?}")]
    public class OptionalParameterController : ResponseStoringController
    {
        public string Create()
        {
            return "Create()";
        }
    }

    namespace ControllersWithTheSameName
    {
        namespace NS1
        {
            [Route("Home1/{action}")]
            public class HomeController : ResponseStoringController
            {
                public ActionResult Index()
                {
                    return Content("Home1.Index()");
                }
            }
        }

        namespace NS2
        {
            [Route("Home2/{action}")]
            public class HomeController : ResponseStoringController
            {
                public ActionResult Index()
                {
                    return Content("Home2.Index()");
                }
            }
        }
    }

    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
    public class CustomizedRoutePrefixAttribute : Attribute, IRoutePrefix
    {
        public CustomizedRoutePrefixAttribute(Type controller)
        {
            if (controller == null)
            {
                throw Error.ArgumentNull("prefix");
            }

            if (controller.Equals(typeof(ControllersWithCustomizedRoutePrefixAttribute.NS1.HomeController)))
            {
                Prefix = "NS1Home";
            }
            else if (controller.Equals(typeof(ControllersWithCustomizedRoutePrefixAttribute.NS2.AccountController)))
            {
                Prefix = "NS2Account";
            }
            else
            {
                Prefix = "Default";
            }
        }

        public string Prefix { get; private set; }
    }

    public class ExtendedRoutePrefixAttribute : RoutePrefixAttribute
    {
    }

    namespace ControllersWithCustomizedRoutePrefixAttribute
    {
        namespace NS1
        {
            [CustomizedRoutePrefix(typeof(HomeController))]
            public class HomeController : ResponseStoringController
            {
                [Route("Introduction")]
                public ActionResult Index()
                {
                    return Content("Home.Index()");
                }
            }
        }

        namespace NS2
        {
            [CustomizedRoutePrefix(typeof(AccountController))]
            public class AccountController : ResponseStoringController
            {
                [Route("PeopleList")]
                public ActionResult Index()
                {
                    return Content("Account.Index()");
                }
            }
        }

        namespace NS3
        {
            [CustomizedRoutePrefix(typeof(OtherController))]
            public class OtherController : ResponseStoringController
            {
                [Route("Unknown")]
                public ActionResult Index()
                {
                    return Content("Default.Index()");
                }
            }
        }

        namespace Invalid
        {
            [CustomizedRoutePrefix(typeof(HomeController))]
            [RoutePrefix("InvalidExtraPrefix")]
            public class HomeController : ResponseStoringController
            {
                [Route("Introduction")]
                public ActionResult Index()
                {
                    return Content("Home.Index()");
                }
            }

            [ExtendedRoutePrefixAttribute]
            public class AccountController : ResponseStoringController
            {
                [Route("AnyRoute")]
                public ActionResult Index()
                {
                    return Content("Account.Index()");
                }
            }
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Routing/DefaultDirectRouteProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Mvc;
using System.Web.Mvc.Async;
using System.Web.Mvc.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Routing
{
    public class DefaultDirectRouteProviderTest
    {
        [Fact]
        public void CreateRouteEntry_IfDirectRouteProviderReturnsNull_Throws()
        {
            // Arrange
            string areaPrefix = null;
            string controllerPrefix = null;
            IDirectRouteFactory factory = CreateStubRouteFactory(null);
            ControllerDescriptor controllerDescriptor = CreateStubControllerDescriptor("IgnoreController");
            ActionDescriptor actionDescriptor = CreateStubActionDescriptor(controllerDescriptor, "IgnoreAction");
            IReadOnlyCollection<ActionDescriptor> actions = new ActionDescriptor[] { actionDescriptor };
            IInlineConstraintResolver constraintResolver =
                new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => DefaultDirectRouteProvider.CreateRouteEntry(areaPrefix,
                controllerPrefix, factory, actions, constraintResolver, targetIsAction: false),
                "IDirectRouteFactory.CreateRoute must not return null.");
        }

        [Fact]
        public void CreateRouteEntry_IfDirectRouteProviderReturnsRouteWithoutActionDescriptors_Throws()
        {
            // Arrange
            string areaPrefix = null;
            string controllerPrefix = null;
            Route route = new Route(url: null, routeHandler: null);
            Assert.Null(route.GetTargetActionDescriptors()); // Guard
            RouteEntry entry = new RouteEntry(name: null, route: route);
            IDirectRouteFactory factory = CreateStubRouteFactory(entry);
            ControllerDescriptor controllerDescriptor = CreateStubControllerDescriptor("IgnoreController");
            ActionDescriptor actionDescriptor = CreateStubActionDescriptor(controllerDescriptor, "IgnoreAction");
            IReadOnlyCollection<ActionDescriptor> actions = new ActionDescriptor[] { actionDescriptor };
            IInlineConstraintResolver constraintResolver =
                new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            // Act & Assert
            string expectedMessage = "The route does not have any associated action descriptors. Routing requires " +
                "that each direct route map to a non-empty set of actions.";
            Assert.Throws<InvalidOperationException>(() => DefaultDirectRouteProvider.CreateRouteEntry(areaPrefix,
                controllerPrefix, factory, actions, constraintResolver, targetIsAction: false), expectedMessage);
        }

        [Fact]
        public void CreateRouteEntry_IfDirectRouteProviderReturnsRouteWithEmptyActionDescriptors_Throws()
        {
            // Arrange
            string areaPrefix = null;
            string controllerPrefix = null;
            Route route = new Route(url: null, routeHandler: null);
            route.DataTokens = new RouteValueDictionary();
            route.DataTokens.Add(RouteDataTokenKeys.Actions, new ActionDescriptor[0]);
            ActionDescriptor[] originalActions = route.GetTargetActionDescriptors();
            Assert.NotNull(originalActions); // Guard
            Assert.Empty(originalActions); // Guard
            RouteEntry entry = new RouteEntry(name: null, route: route);
            IDirectRouteFactory factory = CreateStubRouteFactory(entry);
            ControllerDescriptor controllerDescriptor = CreateStubControllerDescriptor("IgnoreController");
            ActionDescriptor actionDescriptor = CreateStubActionDescriptor(controllerDescriptor, "IgnoreAction");
            IReadOnlyCollection<ActionDescriptor> actions = new ActionDescriptor[] { actionDescriptor };
            IInlineConstraintResolver constraintResolver =
                new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            // Act & Assert
            string expectedMessage = "The route does not have any associated action descriptors. Routing requires " +
                "that each direct route map to a non-empty set of actions.";
            Assert.Throws<InvalidOperationException>(() => DefaultDirectRouteProvider.CreateRouteEntry(areaPrefix,
                controllerPrefix, factory, actions, constraintResolver, targetIsAction: false), expectedMessage);
        }

        [Fact]
        public void CreateRouteEntry_IfDirectRouteProviderReturnsRouteWithHandler_Throws()
        {
            // Arrange
            string areaPrefix = null;
            string controllerPrefix = null;
            ControllerDescriptor controllerDescriptor = CreateStubControllerDescriptor("IgnoreController");
            ActionDescriptor actionDescriptor = CreateStubActionDescriptor(controllerDescriptor, "IgnoreAction");
            Route route = new Route(url: null, routeHandler: null);
            route.DataTokens = new RouteValueDictionary();
            route.DataTokens.Add(RouteDataTokenKeys.Actions, new ActionDescriptor[] { actionDescriptor });
            route.RouteHandler = new Mock<IRouteHandler>(MockBehavior.Strict).Object;
            ActionDescriptor[] originalActions = route.GetTargetActionDescriptors();
            RouteEntry entry = new RouteEntry(name: null, route: route);
            IDirectRouteFactory factory = CreateStubRouteFactory(entry);
            IReadOnlyCollection<ActionDescriptor> actions = new ActionDescriptor[] { actionDescriptor };
            IInlineConstraintResolver constraintResolver =
                new Mock<IInlineConstraintResolver>(MockBehavior.Strict).Object;

            // Act & Assert
            string expectedMessage = "Direct routing does not support per-route route handlers.";
            Assert.Throws<InvalidOperationException>(() => DefaultDirectRouteProvider.CreateRouteEntry(areaPrefix,
                controllerPrefix, factory, actions, constraintResolver, targetIsAction: false), expectedMessage);
        }

        private static ActionDescriptor CreateStubActionDescriptor(ControllerDescriptor controllerDescriptor, string actionName)
        {
            Mock<ActionDescriptor> mock = new Mock<ActionDescriptor>(MockBehavior.Strict);
            mock.SetupGet(d => d.ControllerDescriptor).Returns(controllerDescriptor);
            mock.SetupGet(d => d.ActionName).Returns(actionName);
            return mock.Object;
        }

        private static ControllerDescriptor CreateStubControllerDescriptor(string controllerName)
        {
            Mock<ControllerDescriptor> mock = new Mock<ControllerDescriptor>(MockBehavior.Strict);
            mock.SetupGet(d => d.ControllerName).Returns(controllerName);
            return mock.Object;
        }

        private static IDirectRouteFactory CreateStubRouteFactory(RouteEntry entry)
        {
            Mock<IDirectRouteFactory> mock = new Mock<IDirectRouteFactory>(MockBehavior.Strict);
            mock.Setup(p => p.CreateRoute(It.IsAny<DirectRouteFactoryContext>())).Returns(entry);
            return mock.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Routing/DirectRouteCandidateTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using System.Reflection;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Routing.Test
{
    public class DirectRouteCandidateTest
    {
        [Fact]
        public void SelectBestCandidate_ReturnsNullOnEmptyList()
        {
            // Arrange & Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(new List<DirectRouteCandidate>(), new ControllerContext());

            // Assert
            Assert.Null(actual);
        }

        [Fact]
        public void SelectBestCandidate_SelectByActionName()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            RouteData routeData = new RouteData();
            routeData.Values["action"] = "Action1";

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ControllerDescriptor = controllerDescriptor,
                RouteData = routeData,
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action2()),
                ControllerDescriptor = controllerDescriptor,
                RouteData = routeData,
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_SelectByActionNameSelector_UsesActionName()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            RouteData routeData = new RouteData();
            routeData.Values["action"] = "Action1";

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionNameSelectors = new ActionNameSelector[] { (context, name) => name == "Action1" },
                ControllerDescriptor = controllerDescriptor,
                RouteData = routeData,
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action2()),
                ActionNameSelectors = new ActionNameSelector[] { (context, name) => name == "Action2" },
                ControllerDescriptor = controllerDescriptor,
                RouteData = routeData,
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_SelectByActionNameSelector_RouteProvidesName()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            RouteData routeData = new RouteData();
            routeData.Values["action"] = "Action1";

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action2()),
                ActionNameSelectors = new ActionNameSelector[] { (context, name) => name == "Action1" },
                ControllerDescriptor = controllerDescriptor,
                RouteData = routeData,
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action2()),
                ControllerDescriptor = controllerDescriptor,
                RouteData = routeData,
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_ExcludesFailedActionSelectors()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ControllerDescriptor = controllerDescriptor,
                Order = 1,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => false, },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_ExcludesFailedActionSelectors_NoneValid()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => false, },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => false, },
                ControllerDescriptor = controllerDescriptor,
                Order = 1,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Null(actual);
        }

        [Fact]
        public void SelectBestCandidate_ChoosesByActionSelector()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ControllerDescriptor = controllerDescriptor,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_ChoosesByOrder()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ControllerDescriptor = controllerDescriptor,
                Order = 1,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_ChoosesByOrder_WithActionSelectors()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                Order = 1,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_ChoosesByOrder_AfterActionSelectors()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                Order = 1,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => false },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_ChoosesByPrecedence()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                Precedence = 1,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                Precedence = 2,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_ChoosesByPrecedence_WithActionSelectors()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate better = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                Precedence = 1,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate worse = new DirectRouteCandidate()
            {
                ActionDescriptor = ActionDescriptorFrom<TestController>(c => c.Action1()),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                Precedence = 2,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                better, 
                worse,
            };

            // Act
            DirectRouteCandidate actual = DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext());

            // Assert
            Assert.Same(better, actual);
        }

        [Fact]
        public void SelectBestCandidate_Ambiguity()
        {
            // Arrange
            Type controllerType = typeof(TestController);
            ReflectedControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            DirectRouteCandidate candidate1 = new DirectRouteCandidate()
            {
                ActionDescriptor = new ReflectedActionDescriptor(controllerType.GetMethod("Action1"), "Action1", controllerDescriptor),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                Precedence = 1,
                RouteData = new RouteData(),
            };

            DirectRouteCandidate candidate2 = new DirectRouteCandidate()
            {
                ActionDescriptor = new ReflectedActionDescriptor(controllerType.GetMethod("Action2"), "Action2", controllerDescriptor),
                ActionSelectors = new ActionSelector[] { (context) => true },
                ControllerDescriptor = controllerDescriptor,
                Order = 0,
                Precedence = 1,
                RouteData = new RouteData(),
            };

            List<DirectRouteCandidate> candidates = new List<DirectRouteCandidate>()
            {
                candidate1, 
                candidate2,
            };

            string message = 
                "The current request is ambiguous between the following action methods:" + Environment.NewLine +
                "Void Action1() on type System.Web.Mvc.Routing.Test.DirectRouteCandidateTest+TestController" + Environment.NewLine +
                "Void Action2() on type System.Web.Mvc.Routing.Test.DirectRouteCandidateTest+TestController";

            // Act & Assert
            Assert.Throws<AmbiguousMatchException>(() => DirectRouteCandidate.SelectBestCandidate(candidates, new ControllerContext()), message);
        }

        private static ActionDescriptor ActionDescriptorFrom<T>(Expression<Action<T>> methodCall)
        {
            var method = ((MethodCallExpression)methodCall.Body).Method;

            var controllerType = method.DeclaringType;
            var controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            return new ReflectedActionDescriptor(method, method.Name, controllerDescriptor);
        }

        private class TestController : Controller
        {
            [Route("cool")]
            public void Action1()
            {
            }

            [Route("cool")]
            public void Action2()
            {
            }
        }

        [Route("controller/{action")]
        private class ClassLevelTestController : Controller
        {
            public void Action1()
            {
            }

            public void Action2()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Routing/DirectRouteTestHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Diagnostics.Contracts;
using System.Linq;
using System.Linq.Expressions;
using System.Web.Mvc;
using System.Web.Mvc.Async;
using System.Web.Mvc.Routing;

namespace System.Web.Routing.Test
{
    internal static class DirectRouteTestHelpers
    {
        public static RouteCollectionRoute BuildDirectRouteFromMethod<T>(Expression<Action<T>> methodCall)
        {
            SubRouteCollection collector = new SubRouteCollection();
            AddDirectRouteFromMethod(collector, methodCall);
            return new RouteCollectionRoute(collector);
        }

        public static void AddDirectRouteFromMethod<T>(SubRouteCollection collector, Expression<Action<T>> methodCall)
        {
            var method = ((MethodCallExpression)methodCall.Body).Method;
            var attributes = method.GetCustomAttributes(false).OfType<IRouteInfoProvider>();

            var controllerDescriptor = new ReflectedAsyncControllerDescriptor(method.DeclaringType);
            var actionDescriptor = new ReflectedActionDescriptor(method, method.Name, controllerDescriptor);

            foreach (var attribute in attributes)
            {
                var subRoute = new Route(attribute.Template, routeHandler: null);
                subRoute.SetTargetActionDescriptors(new ActionDescriptor[] { actionDescriptor });
                collector.Add(new RouteEntry(null, subRoute));
            }
        }

        public static RouteCollectionRoute BuildDirectRouteFromController<T>()
        {
            SubRouteCollection collector = new SubRouteCollection();
            AddDirectRouteFromController<T>(collector);
            return new RouteCollectionRoute(collector);
        }

        public static void AddDirectRouteFromController<T>(SubRouteCollection collector)
        {
            var controllerType = typeof(T);
            AttributeRoutingMapper.AddRouteEntries(
                collector, 
                new Type[] { controllerType },
                new DefaultInlineConstraintResolver(),
                new DefaultDirectRouteProvider());
        }

        public static void AddDirectRouteMatches(this RouteData routeData, Func<RouteBase, RouteData, bool> selector = null)
        {
            RouteCollectionRoute route = (RouteCollectionRoute)routeData.Route;

            List<RouteData> matches = new List<RouteData>();
            foreach (var subRoute in route)
            {
                RouteData match = new RouteData() { Route = subRoute };
                bool isMatch = selector == null ? true : selector(subRoute, match);
                if (isMatch)
                {
                    matches.Add(match);
                }
            }

            if (matches.Any())
            {
                routeData.SetDirectRouteMatches(matches);
            }
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Routing/RouteAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;

namespace System.Web.Routing
{
    public class RouteAttributeTests
    {
        [Fact]
        public void Template_EmptyString_Ok()
        {
            new RouteAttribute("");
        }

        [Fact]
        public void Template_Null_NotOk()
        {
            Assert.Throws<ArgumentNullException>(() => new RouteAttribute(null));
        }

        [Fact]
        public void EmptyCtor_Is_EmptyString()
        {
            RouteAttribute attr = new RouteAttribute();

            Assert.Equal(String.Empty, attr.Template);
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Routing/RouteCollectionAttributeRoutingExtensionsTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc;
using System.Web.Mvc.Routing;
using System.Web.Mvc.Routing.Constraints;
using Microsoft.TestCommon;

namespace System.Web.Routing
{
    public class RouteCollectionAttributeRoutingExtensionsTests
    {
        [Fact]
        public void MapMvcAttributeRoutes_MapRouteAttributes()
        {
            // Arrange
            var controllerTypes = new[] { typeof(SimpleRoutingController) };
            var routes = new RouteCollection();

            // Act
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            // Assert
            var expectedResults = new List<Tuple<string, string>>
             {
                 new Tuple<string, string>("getme", "GetMe"),
                 new Tuple<string, string>("postme", "PostMe"),
                 new Tuple<string, string>("getorpostme", "GetOrPostMe"),
                 new Tuple<string, string>("routeme", "RouteMe"),
                 new Tuple<string, string>("once", "FoolMe"),
                 new Tuple<string, string>("twice", "FoolMe"),
                 new Tuple<string, string>("twice", "FoolMe"),
             };

            foreach (var expected in expectedResults)
            {
                var url = expected.Item1;
                var methodName = expected.Item2;

                var attributeRoutes = GetAttributeRoutes(routes);
                Route route = attributeRoutes.Cast<Route>().Single(r => r.Url == url);
                Assert.Equal(methodName, Assert.Single(route.GetTargetActionDescriptors()).ActionName);
            }
        }

        [Fact]
        public void MapMvcAttributeRoutes_CustomConstraintResolver()
        {
            // Arrange
            var controllerTypes = new[] { typeof(FruitConstraintController) };
            var routes = new RouteCollection();

            // Act
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes, new FruitConstraintResolver());

            // Assert
            var attributeRoutes = GetAttributeRoutes(routes);
            Assert.Equal(1, attributeRoutes.Count);
            Route route = (Route)attributeRoutes.Single();

            Assert.Equal("fruits/{apple}", route.Url);
            Assert.IsAssignableFrom<FruitConstraint>(route.Constraints["apple"]);
        }

        [Fact]
        public void MapMvcAttributeRoutes_WithInlineConstraints_ParseConstraintsDefaultsAndOptionals()
        {
            // Arrange
            var controllerTypes = new[] { typeof(SimpleRoutingController) };
            var routes = new RouteCollection();

            // Act
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            // Assert
            var attributeRoutes = GetAttributeRoutes(routes);
            Route route = attributeRoutes.Cast<Route>().Single(r => r.GetTargetActionDescriptors().Single().ActionName == "Parameterized");
            Assert.NotNull(route);

            Assert.Equal("i/{have}/{id}/{defaultsto}/{name}", route.Url);
            Assert.IsAssignableFrom<IntRouteConstraint>(route.Constraints["id"]);
            Assert.Equal("VAL", route.Defaults["defaultsto"]);
            Assert.Equal("", route.Defaults["name"].ToString());
        }

        [Fact]
        public void MapMvcAttributeRoutes_WithPrefixedController()
        {
            // Arrange
            var controllerTypes = new[] { typeof(PrefixedController) };
            var routes = new RouteCollection();

            // Act
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            // Assert
            var attributeRoutes = GetAttributeRoutes(routes);
            Assert.Equal(1, attributeRoutes.Count);

            Route route = (Route)attributeRoutes.Single();
            Assert.Equal("prefpref/getme", route.Url);
            Assert.Equal("GetMe", Assert.Single(route.GetTargetActionDescriptors()).ActionName);
        }

        [Fact]
        public void RoutePrefixAttribute_IsSingleInstance()
        {
            var attr = typeof(RoutePrefixAttribute);
            var attrs = attr.GetCustomAttributes(typeof(AttributeUsageAttribute), false);
            var usage = (AttributeUsageAttribute)attrs[0];

            Assert.Equal(AttributeTargets.Class, usage.ValidOn);
            Assert.False(usage.AllowMultiple); // only 1 per class
            Assert.False(usage.Inherited); // RoutePrefix is not inherited.
        }

        [Fact]
        public void MapMvcAttributeRoutes_WithArea()
        {
            // Arrange
            var controllerTypes = new[] { typeof(PugetSoundController) };
            var routes = new RouteCollection();

            // Act
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            // Assert
            var attributeRoutes = GetAttributeRoutes(routes);
            Assert.Equal(1, attributeRoutes.Count);

            Route route = (Route)attributeRoutes.Single();

            Assert.Equal("puget-sound/getme", route.Url);
            Assert.Equal("PugetSound", route.DataTokens["area"]);
            Assert.Equal((object)false, route.DataTokens["usenamespacefallback"]);
            Assert.Equal("GetMe", Assert.Single(route.GetTargetActionDescriptors()).ActionName);
            Assert.Equal(typeof(PugetSoundController).Namespace, ((string[])route.DataTokens["namespaces"])[0]);
        }

        [Fact]
        public void MapMvcAttributeRoutes_WithPrefixedArea()
        {
            // Arrange
            var controllerTypes = new[] { typeof(PrefixedPugetSoundController) };
            var routes = new RouteCollection();

            // Act
            AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes);

            // Assert
            var attributeRoutes = GetAttributeRoutes(routes);
            Assert.Equal(1, attributeRoutes.Count);

            Route route = (Route)attributeRoutes.Single();

            Assert.Equal("puget-sound/prefpref/getme", route.Url);
            Assert.Equal("PugetSound", route.DataTokens["area"]);
            Assert.Equal((object)false, route.DataTokens["usenamespacefallback"]);
            Assert.Equal("GetMe", Assert.Single(route.GetTargetActionDescriptors()).ActionName);
            Assert.Equal(typeof(PrefixedPugetSoundController).Namespace, ((string[])route.DataTokens["namespaces"])[0]);
        }

        [Theory]
        [InlineData(null, null, "", "")]
        [InlineData(null, null, "whatever", "whatever")]
        [InlineData(null, "", "", "")]
        [InlineData(null, "", "whatever", "whatever")]
        [InlineData(null, "pref", "", "pref")]
        [InlineData(null, "pref", "whatever", "pref/whatever")]
        [InlineData("", null, "", "")]
        [InlineData("", null, "whatever", "whatever")]
        [InlineData("", "", "", "")]
        [InlineData("", "", "whatever", "whatever")]
        [InlineData("", "pref", "", "pref")]
        [InlineData("", "pref", "whatever", "pref/whatever")]
        [InlineData("puget-sound", null, "", "puget-sound")]
        [InlineData("puget-sound", null, "whatever", "puget-sound/whatever")]
        [InlineData("puget-sound", "", "", "puget-sound")]
        [InlineData("puget-sound", "", "whatever", "puget-sound/whatever")]
        [InlineData("puget-sound", "pref", "", "puget-sound/pref")]
        [InlineData("puget-sound", "pref", "whatever", "puget-sound/pref/whatever")]
        [InlineData(null, null, "~/whatever", "whatever")]
        [InlineData("puget-sound", "pref", "~/", "")]
        [InlineData("puget-sound", "pref", "~/whatever", "whatever")]
        [InlineData("puget-sound", null, "~/whatever", "whatever")]
        [InlineData(null, "pref", "~/whatever", "whatever")]
        public void BuildRouteTemplate(string areaPrefix, string prefix, string template, string expected)
        {
            var result = DirectRouteFactoryContext.BuildRouteTemplate(areaPrefix, prefix, template);

            Assert.Equal(expected, result);
        }

        [Theory]
        [InlineData(typeof(Bad1Controller), "The route prefix '/pref' on the controller named 'Bad1' cannot begin or end with a forward slash.")]
        [InlineData(typeof(Bad2Controller), "The route prefix 'pref/' on the controller named 'Bad2' cannot begin or end with a forward slash.")]
        [InlineData(typeof(Bad3Controller), "The route template '/getme' on the action named 'GetMe' on the controller named 'Bad3' cannot begin with a forward slash.")]
        [InlineData(typeof(Bad4Controller), null)]
        [InlineData(typeof(Bad5Controller), "The route template '/puget-sound/getme' on the action named 'GetMe' on the controller named 'Bad5' cannot begin with a forward slash.")]
        [InlineData(typeof(Bad6Controller), "The prefix 'puget-sound/' of the route area named 'PugetSound' on the controller named 'Bad6' cannot end with a forward slash.")]
        public void TemplatesAreValidated(Type controllerType, string expectedErrorMessage)
        {
            // Arrange
            var controllerTypes = new[] { controllerType };
            var routes = new RouteCollection();

            // Act & Assert
            if (expectedErrorMessage == null)
            {
                Assert.DoesNotThrow(() => AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes));
            }
            else
            {
                Assert.Throws<InvalidOperationException>(() => AttributeRoutingMapper.MapAttributeRoutes(routes, controllerTypes), expectedErrorMessage);
            }
        }

        private class SimpleRoutingController : Controller
        {
            [Route("getme")]
            [HttpGet]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }

            [HttpPost]
            [Route("postme")]
            public ActionResult PostMe()
            {
                throw new NotImplementedException();
            }

            [Route("routeme")]
            public ActionResult RouteMe()
            {
                throw new NotImplementedException();
            }

            [AcceptVerbs(HttpVerbs.Get | HttpVerbs.Post)]
            [Route("getorpostme")]
            public ActionResult GetOrPostMe()
            {
                throw new NotImplementedException();
            }

            [HttpGet]
            [Route("once")]
            [Route("twice")]
            public ActionResult FoolMe()
            {
                throw new NotImplementedException("Shame on you!");
            }

            [HttpGet]
            [Route("i/{have}/{id:int}/{defaultsto=VAL}/{name?}")]
            public ActionResult Parameterized(string have, int id, string optional)
            {
                throw new NotImplementedException();
            }
        }

        [RoutePrefix("prefpref")]
        private class PrefixedController : Controller
        {
            [HttpGet]
            [Route("getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }

            public ActionResult IDontGetARoute()
            {
                throw new NotImplementedException();
            }
        }

        [RouteArea("PugetSound", AreaPrefix = "puget-sound")]
        private class PugetSoundController : Controller
        {
            [HttpGet]
            [Route("getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }

            public ActionResult IDontGetARoute()
            {
                throw new NotImplementedException();
            }
        }

        [RouteArea("PugetSound", AreaPrefix = "puget-sound")]
        [RoutePrefix("prefpref")]
        private class PrefixedPugetSoundController : Controller
        {
            [HttpGet]
            [Route("getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }

            public ActionResult IDontGetARoute()
            {
                throw new NotImplementedException();
            }
        }

        [RoutePrefix("/pref")]
        private class Bad1Controller : Controller
        {
            [HttpGet]
            [Route("getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }
        }

        [RoutePrefix("pref/")]
        private class Bad2Controller : Controller
        {
            [HttpGet]
            [Route("getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }
        }

        private class Bad3Controller : Controller
        {
            [HttpGet]
            [Route("/getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }
        }

        private class Bad4Controller : Controller
        {
            [HttpGet]
            [Route("getme/")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }
        }

        [RouteArea("PugetSound", AreaPrefix = "/puget-sound")]
        private class Bad5Controller : Controller
        {
            [HttpGet]
            [Route("getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }
        }

        [RouteArea("PugetSound", AreaPrefix = "puget-sound/")]
        private class Bad6Controller : Controller
        {
            [HttpGet]
            [Route("getme")]
            public ActionResult GetMe()
            {
                throw new NotImplementedException();
            }
        }

        private class FruitConstraintController : Controller
        {
            [HttpGet]
            [Route("fruits/{apple:fruit}")]
            public ActionResult Eat(string apple)
            {
                throw new NotImplementedException();
            }
        }

        class FruitConstraint : IRouteConstraint
        {
            public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values,
                              RouteDirection routeDirection)
            {
                throw new NotImplementedException();
            }
        }

        class FruitConstraintResolver : IInlineConstraintResolver
        {
            public IRouteConstraint ResolveConstraint(string inlineConstraint)
            {
                if (inlineConstraint == "fruit")
                {
                    return new FruitConstraint();
                }

                throw new InvalidOperationException();
            }
        }

        private IReadOnlyCollection<RouteBase> GetAttributeRoutes(RouteCollection routes)
        {
            return routes.OfType<IReadOnlyCollection<RouteBase>>().Single();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/System.Web.Mvc.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{8AC2A2E4-2F11-4D40-A887-62E2583A65E6}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web</RootNamespace>
    <AssemblyName>System.Web.Mvc.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <DefineConstants>$(DefineConstants);ASPNETMVC</DefineConstants>
    <!-- Temporarily disable Obsolete Warnings as Errors -->
    <NoWarn>0618</NoWarn>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Data.Entity" />
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Runtime.Caching" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.Abstractions" />
    <Reference Include="System.Web.Extensions" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\AttributeListTest.cs">
      <Link>Common\AttributeListTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RouteFactoryAttributeTests.cs">
      <Link>Routing\RouteFactoryAttributeTests.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\RoutePrecedenceTests.cs">
      <Link>Routing\RoutePrecedenceTests.cs</Link>
    </Compile>
    <Compile Include="Async\Test\TaskAsyncActionDescriptorTest.cs" />
    <Compile Include="Async\Test\TaskWrapperAsyncResultTest.cs" />
    <Compile Include="Html\Test\DisplayExtensionsTest.cs" />
    <Compile Include="Html\Test\DisplayNameExtensionsTest.cs" />
    <Compile Include="Html\Test\DisplayTextExtensionsTest.cs" />
    <Compile Include="Html\Test\EditorExtensionsTest.cs" />
    <Compile Include="Html\Test\EncodedDataSets.cs" />
    <Compile Include="Html\Test\EnumHelperTest.cs" />
    <Compile Include="Html\Test\MetadataOverrideScope.cs" />
    <Compile Include="Html\Test\NameExtensionsTest.cs" />
    <Compile Include="Html\Test\TemplateHelpersSafeScope.cs" />
    <Compile Include="Html\Test\ValueExtensionsTest.cs" />
    <Compile Include="Test\CopyOnWriteDictionaryTest.cs" />
    <Compile Include="Test\JQueryFormValueProviderFactoryTest.cs" />
    <Compile Include="Razor\Test\MvcCSharpRazorCodeGeneratorTest.cs" />
    <Compile Include="Properties\Resources.Designer.cs">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="Routing\AttributeRoutingLinkGenerationTest.cs" />
    <Compile Include="Routing\AttributeRoutingMapperTest.cs" />
    <Compile Include="Routing\AttributeRoutingTest.cs" />
    <Compile Include="..\Common\Routing\DirectRouteBuilderTests.cs">
      <Link>Routing\DirectRouteBuilderTests.cs</Link>
    </Compile>
    <Compile Include="Routing\DefaultDirectRouteProviderTest.cs" />
    <Compile Include="Routing\DirectRouteCandidateTest.cs" />
    <Compile Include="Routing\DirectRouteTestHelpers.cs" />
    <Compile Include="Routing\RouteAttributeTests.cs" />
    <Compile Include="..\Common\Routing\RouteConstraintsTests.cs">
      <Link>Routing\RouteConstraintsTests.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\DefaultInlineConstraintResolverTest.cs">
      <Link>Routing\DefaultInlineConstraintResolverTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\Routing\InlineRouteTemplateParserTests.cs">
      <Link>Routing\InlineRouteTemplateParserTests.cs</Link>
    </Compile>
    <Compile Include="Routing\RouteCollectionAttributeRoutingExtensionsTests.cs" />
    <Compile Include="..\Common\Routing\SubRouteCollectionTest.cs">
      <Link>Routing\SubRouteCollectionTest.cs</Link>
    </Compile>
    <Compile Include="Test\AjaxHelperOfTModelTest.cs" />
    <Compile Include="Test\CancellationTokenModelBinderTest.cs" />
    <Compile Include="Test\CachedAssociatedMetadataProviderTest.cs" />
    <Compile Include="Test\CachedDataAnnotationsModelMetadataProviderTest.cs" />
    <Compile Include="Test\ChildActionValueProviderFactoryTest.cs" />
    <Compile Include="ExpressionUtil\Test\BinaryExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\CachedExpressionCompilerTest.cs" />
    <Compile Include="ExpressionUtil\Test\ConditionalExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\ConstantExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\DefaultExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\DummyExpressionFingerprint.cs" />
    <Compile Include="ExpressionUtil\Test\ExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\FingerprintingExpressionVisitorTest.cs" />
    <Compile Include="ExpressionUtil\Test\HoistingExpressionVisitorTest.cs" />
    <Compile Include="ExpressionUtil\Test\IndexExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\LambdaExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\MemberExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\MethodCallExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\ParameterExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\TypeBinaryExpressionFingerprintTest.cs" />
    <Compile Include="ExpressionUtil\Test\UnaryExpressionFingerprintTest.cs" />
    <Compile Include="Test\AdditionalMetadataAttributeTest.cs" />
    <Compile Include="Test\BuildManagerCompiledViewTest.cs" />
    <Compile Include="Test\BuildManagerViewEngineTest.cs" />
    <Compile Include="Test\CompareAttributeTest.cs" />
    <Compile Include="Test\CompareAttributeAdapterTest.cs" />
    <Compile Include="Test\MinLengthAttributeAdapterTest.cs" />
    <Compile Include="Test\OverrideResultFiltersAttributeTests.cs" />
    <Compile Include="Test\OverrideAuthenticationAttributeTests.cs" />
    <Compile Include="Test\OverrideAuthorizationAttributeTests.cs" />
    <Compile Include="Test\OverrideExceptionFiltersAttributeTests.cs" />
    <Compile Include="Test\DataAnnotationsModelMetadataProviderTestBase.cs" />
    <Compile Include="Test\DataTypeUtilTest.cs" />
    <Compile Include="Test\FilterInfoTest.cs" />
    <Compile Include="Test\AllowHtmlAttributeTest.cs" />
    <Compile Include="Test\HtmlHelperOfTModelTest.cs" />
    <Compile Include="Test\HttpHeadAttributeTest.cs" />
    <Compile Include="Test\HttpOptionsAttributeTest.cs" />
    <Compile Include="Test\HttpPatchAttributeTest.cs" />
    <Compile Include="Test\MockableUnvalidatedRequestValues.cs" />
    <Compile Include="Test\DescriptorUtilTest.cs" />
    <Compile Include="Razor\Test\MvcVBRazorCodeParserTest.cs" />
    <Compile Include="Test\ModelBinderProviderCollectionTest.cs" />
    <Compile Include="Test\ModelBinderProvidersTest.cs" />
    <Compile Include="Razor\Test\MvcWebPageRazorHostTest.cs" />
    <Compile Include="Ajax\Test\AjaxExtensionsTest.cs" />
    <Compile Include="Ajax\Test\AjaxOptionsTest.cs" />
    <Compile Include="Async\Test\AsyncActionMethodSelectorTest.cs" />
    <Compile Include="Async\Test\AsyncControllerActionInvokerTest.cs" />
    <Compile Include="Async\Test\AsyncActionDescriptorTest.cs" />
    <Compile Include="Test\AsyncControllerTest.cs" />
    <Compile Include="Async\Test\SynchronousOperationExceptionTest.cs" />
    <Compile Include="Async\Test\AsyncManagerTest.cs" />
    <Compile Include="Async\Test\AsyncResultWrapperTest.cs" />
    <Compile Include="Test\AsyncTimeoutAttributeTest.cs" />
    <Compile Include="Test\ClientDataTypeModelValidatorProviderTest.cs" />
    <Compile Include="Test\ControllerInstanceFilterProviderTest.cs" />
    <Compile Include="Test\OverrideActionFiltersAttributeTests.cs" />
    <Compile Include="Test\OverrideFiltersAttributeTests.cs" />
    <Compile Include="Test\PreApplicationStartCodeTest.cs" />
    <Compile Include="Test\RemoteAttributeTest.cs" />
    <Compile Include="Test\MaxLengthAttributeAdapterTest.cs" />
    <Compile Include="Test\UrlHelperTest.cs" />
    <Compile Include="Test\UrlParameterTest.cs" />
    <Compile Include="Test\ViewStartPageTest.cs" />
    <Compile Include="Test\RazorViewEngineTest.cs" />
    <Compile Include="Test\RazorViewTest.cs" />
    <Compile Include="Test\DynamicViewDataDictionaryTest.cs" />
    <Compile Include="Test\FilterAttributeFilterProviderTest.cs" />
    <Compile Include="Test\FilterProviderCollectionTest.cs" />
    <Compile Include="Test\FilterProvidersTest.cs" />
    <Compile Include="Test\FilterTest.cs" />
    <Compile Include="Test\GlobalFilterCollectionTest.cs" />
    <Compile Include="Test\HttpFileCollectionValueProviderFactoryTest.cs" />
    <Compile Include="Test\HttpNotFoundResultTest.cs" />
    <Compile Include="Test\HttpStatusCodeResultTest.cs" />
    <Compile Include="Test\JsonValueProviderFactoryTest.cs" />
    <Compile Include="Razor\Test\MvcCSharpRazorCodeParserTest.cs" />
    <Compile Include="Test\MultiServiceResolverTest.cs" />
    <Compile Include="Test\DependencyResolverTest.cs" />
    <Compile Include="Test\MvcWebRazorHostFactoryTest.cs" />
    <Compile Include="Test\RangeAttributeAdapterTest.cs" />
    <Compile Include="Test\RegularExpressionAttributeAdapterTest.cs" />
    <Compile Include="Test\RequiredAttributeAdapterTest.cs" />
    <Compile Include="Test\RouteDataValueProviderFactoryTest.cs" />
    <Compile Include="Test\QueryStringValueProviderFactoryTest.cs" />
    <Compile Include="Test\FormValueProviderFactoryTest.cs" />
    <Compile Include="Test\SingleServiceResolverTest.cs" />
    <Compile Include="Test\StringLengthAttributeAdapterTest.cs" />
    <Compile Include="Test\ValidatableObjectAdapterTest.cs" />
    <Compile Include="Test\ValueProviderFactoryCollectionTest.cs" />
    <Compile Include="Test\TypeCacheUtilTest.cs" />
    <Compile Include="Test\TypeCacheSerializerTest.cs" />
    <Compile Include="Test\NoAsyncTimeoutAttributeTest.cs" />
    <Compile Include="Async\Test\OperationCounterTest.cs" />
    <Compile Include="Async\Test\ReflectedAsyncActionDescriptorTest.cs" />
    <Compile Include="Async\Test\ReflectedAsyncControllerDescriptorTest.cs" />
    <Compile Include="Async\Test\SignalContainer.cs" />
    <Compile Include="Async\Test\TriggerListenerTest.cs" />
    <Compile Include="Async\Test\MockAsyncResult.cs" />
    <Compile Include="Async\Test\SimpleAsyncResultTest.cs" />
    <Compile Include="Async\Test\SynchronizationContextUtilTest.cs" />
    <Compile Include="Html\Test\ChildActionExtensionsTest.cs" />
    <Compile Include="Html\Test\DefaultDisplayTemplatesTest.cs" />
    <Compile Include="Html\Test\DefaultEditorTemplatesTest.cs" />
    <Compile Include="Html\Test\FormExtensionsTest.cs" />
    <Compile Include="Html\Test\InputExtensionsTest.cs" />
    <Compile Include="Html\Test\LabelExtensionsTest.cs" />
    <Compile Include="Html\Test\LinkExtensionsTest.cs" />
    <Compile Include="Html\Test\MvcFormTest.cs" />
    <Compile Include="Html\Test\PartialExtensionsTest.cs" />
    <Compile Include="Html\Test\RenderPartialExtensionsTest.cs" />
    <Compile Include="Html\Test\SelectExtensionsTest.cs" />
    <Compile Include="Html\Test\TemplateHelpersTest.cs" />
    <Compile Include="Html\Test\TextAreaExtensionsTest.cs" />
    <Compile Include="Html\Test\ValidationExtensionsTest.cs" />
    <Compile Include="Test\ActionExecutedContextTest.cs" />
    <Compile Include="Test\ActionExecutingContextTest.cs" />
    <Compile Include="Test\AssociatedValidatorProviderTest.cs" />
    <Compile Include="Test\BindAttributeTest.cs" />
    <Compile Include="Test\AssociatedMetadataProviderTest.cs" />
    <Compile Include="Test\ByteArrayModelBinderTest.cs" />
    <Compile Include="Test\ChildActionOnlyAttributeTest.cs" />
    <Compile Include="Test\ControllerBaseTest.cs" />
    <Compile Include="Test\ActionMethodSelectorTest.cs" />
    <Compile Include="Test\ActionNameAttributeTest.cs" />
    <Compile Include="Test\AcceptVerbsAttributeTest.cs" />
    <Compile Include="Test\ControllerContextTest.cs" />
    <Compile Include="Test\AuthorizationContextTest.cs" />
    <Compile Include="Test\ParameterInfoUtilTest.cs" />
    <Compile Include="Test\ModelValidationResultTest.cs" />
    <Compile Include="Test\HttpHandlerUtilTest.cs" />
    <Compile Include="Test\ValueProviderFactoriesTest.cs" />
    <Compile Include="Test\ValueProviderCollectionTest.cs" />
    <Compile Include="Test\HttpFileCollectionValueProviderTest.cs" />
    <Compile Include="Test\DictionaryValueProviderTest.cs" />
    <Compile Include="Test\NameValueCollectionValueProviderTest.cs" />
    <Compile Include="Test\ValueProviderUtilTest.cs" />
    <Compile Include="Test\DataErrorInfoModelValidatorProviderTest.cs" />
    <Compile Include="Test\ModelValidatorProviderCollectionTest.cs" />
    <Compile Include="Test\HttpVerbAttributeHelper.cs" />
    <Compile Include="Test\HttpDeleteAttributeTest.cs" />
    <Compile Include="Test\HttpPutAttributeTest.cs" />
    <Compile Include="Test\HttpGetAttributeTest.cs" />
    <Compile Include="Test\DataAnnotationsModelValidatorTest.cs" />
    <Compile Include="Test\EmptyModelValidatorProviderTest.cs" />
    <Compile Include="Test\ModelValidatorProvidersTest.cs" />
    <Compile Include="Test\ModelValidatorTest.cs" />
    <Compile Include="Test\MvcHtmlStringTest.cs" />
    <Compile Include="Test\DataAnnotationsModelValidatorProviderTest.cs" />
    <Compile Include="Test\ExpressionHelperTest.cs" />
    <Compile Include="Test\FormContextTest.cs" />
    <Compile Include="Test\FieldValidationMetadataTest.cs" />
    <Compile Include="Test\ModelClientValidationRuleTest.cs" />
    <Compile Include="Test\RequireHttpsAttributeTest.cs" />
    <Compile Include="Test\HttpRequestExtensionsTest.cs" />
    <Compile Include="Test\DataAnnotationsModelMetadataProviderTest.cs" />
    <Compile Include="Test\ModelMetadataProvidersTest.cs" />
    <Compile Include="Test\ModelMetadataTest.cs" />
    <Compile Include="Test\AreaHelpersTest.cs" />
    <Compile Include="Test\AreaRegistrationContextTest.cs" />
    <Compile Include="Test\AreaRegistrationTest.cs" />
    <Compile Include="Async\Test\SingleEntryGateTest.cs" />
    <Compile Include="Test\HttpPostAttributeTest.cs" />
    <Compile Include="Test\LinqBinaryModelBinderTest.cs" />
    <Compile Include="Test\MockHelpers.cs" />
    <Compile Include="Test\ExceptionContextTest.cs" />
    <Compile Include="Test\ModelBindingContextTest.cs" />
    <Compile Include="Test\ResultExecutedContextTest.cs" />
    <Compile Include="Test\ResultExecutingContextTest.cs" />
    <Compile Include="Test\ValidateAntiForgeryTokenAttributeTest.cs" />
    <Compile Include="Test\DictionaryHelpersTest.cs" />
    <Compile Include="Test\AjaxRequestExtensionsTest.cs" />
    <Compile Include="Test\JavaScriptResultTest.cs" />
    <Compile Include="Test\ModelBinderDictionaryTest.cs" />
    <Compile Include="Test\DefaultViewLocationCacheTest.cs" />
    <Compile Include="Test\FormCollectionTest.cs" />
    <Compile Include="Test\HttpPostedFileBaseModelBinderTest.cs" />
    <Compile Include="Test\ValidateInputAttributeTest.cs" />
    <Compile Include="Test\FileContentResultTest.cs" />
    <Compile Include="Test\FilePathResultTest.cs" />
    <Compile Include="Test\FileResultTest.cs" />
    <Compile Include="Test\FileStreamResultTest.cs" />
    <Compile Include="Test\ControllerDescriptorTest.cs" />
    <Compile Include="Test\ControllerDescriptorCacheTest.cs" />
    <Compile Include="Test\ReaderWriterCacheTest.cs" />
    <Compile Include="Test\ReflectedParameterBindingInfoTest.cs" />
    <Compile Include="Test\ParameterBindingInfoTest.cs" />
    <Compile Include="Test\ReflectedControllerDescriptorTest.cs" />
    <Compile Include="Test\ActionDescriptorTest.cs" />
    <Compile Include="Test\ReflectedActionDescriptorTest.cs" />
    <Compile Include="Test\ReflectedParameterDescriptorTest.cs" />
    <Compile Include="Test\ParameterDescriptorTest.cs" />
    <Compile Include="Test\DefaultModelBinderTest.cs" />
    <Compile Include="Test\ValueProviderDictionaryTest.cs" />
    <Compile Include="Test\ValueProviderResultTest.cs" />
    <Compile Include="Test\ModelBinderAttributeTest.cs" />
    <Compile Include="Test\ModelBindersTest.cs" />
    <Compile Include="Test\ViewContextTest.cs" />
    <Compile Include="Test\ViewDataInfoTest.cs" />
    <Compile Include="Test\ViewEngineResultTest.cs" />
    <Compile Include="Test\NonActionAttributeTest.cs" />
    <Compile Include="Test\ModelStateDictionaryTest.cs" />
    <Compile Include="Test\ModelStateTest.cs" />
    <Compile Include="Test\ModelErrorCollectionTest.cs" />
    <Compile Include="Test\ModelErrorTest.cs" />
    <Compile Include="Test\AjaxHelperTest.cs" />
    <Compile Include="Test\AuthorizeAttributeTest.cs" />
    <Compile Include="Test\ControllerActionInvokerTest.cs" />
    <Compile Include="Test\ActionFilterAttributeTest.cs" />
    <Compile Include="Test\ControllerBuilderTest.cs" />
    <Compile Include="Test\ControllerTest.cs" />
    <Compile Include="Test\ContentResultTest.cs" />
    <Compile Include="Test\ActionMethodDispatcherTest.cs" />
    <Compile Include="Test\ActionMethodDispatcherCacheTest.cs" />
    <Compile Include="Test\PartialViewResultTest.cs" />
    <Compile Include="Test\ViewEngineCollectionTest.cs" />
    <Compile Include="Test\ViewMasterPageControlBuilderTest.cs" />
    <Compile Include="Test\ViewPageControlBuilderTest.cs" />
    <Compile Include="Test\ViewTypeParserFilterTest.cs" />
    <Compile Include="Test\ViewResultBaseTest.cs" />
    <Compile Include="Test\ViewUserControlControlBuilderTest.cs" />
    <Compile Include="Test\VirtualPathProviderViewEngineTest.cs" />
    <Compile Include="Test\WebFormViewTest.cs" />
    <Compile Include="Test\MvcHttpHandlerTest.cs" />
    <Compile Include="Test\HandleErrorAttributeTest.cs" />
    <Compile Include="Test\HandleErrorInfoTest.cs" />
    <Compile Include="Test\HttpUnauthorizedResultTest.cs" />
    <Compile Include="Test\SessionStateTempDataProviderTest.cs" />
    <Compile Include="Test\OutputCacheAttributeTest.cs" />
    <Compile Include="Test\JsonResultTest.cs" />
    <Compile Include="Test\NameValueCollectionExtensionsTest.cs" />
    <Compile Include="Test\MockBuildManager.cs" />
    <Compile Include="Test\DefaultControllerFactoryTest.cs" />
    <Compile Include="Test\HtmlHelperTest.cs" />
    <Compile Include="Test\MultiSelectListTest.cs" />
    <Compile Include="Test\MvcHandlerTest.cs" />
    <Compile Include="Test\MvcRouteHandlerTest.cs" />
    <Compile Include="Test\MvcTestHelper.cs" />
    <Compile Include="Test\RedirectResultTest.cs" />
    <Compile Include="Test\RedirectToRouteResultTest.cs" />
    <Compile Include="Test\RouteCollectionExtensionsTest.cs" />
    <Compile Include="Test\SelectListTest.cs" />
    <Compile Include="Test\TempDataDictionaryTest.cs" />
    <Compile Include="Test\TypeHelpersTest.cs" />
    <Compile Include="Test\ViewDataDictionaryTest.cs" />
    <Compile Include="Test\ViewEnginesTest.cs" />
    <Compile Include="Test\ViewMasterPageTest.cs" />
    <Compile Include="Test\ViewPageTest.cs" />
    <Compile Include="Test\ViewResultTest.cs" />
    <Compile Include="Test\ViewUserControlTest.cs" />
    <Compile Include="Test\WebFormViewEngineTest.cs" />
    <Compile Include="Util\AnonymousObject.cs" />
    <Compile Include="Util\DictionaryHelper.cs" />
    <Compile Include="Util\HttpContextHelpers.cs" />
    <Compile Include="Util\MvcHelper.cs" />
    <Compile Include="Util\Resolver.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="Util\SimpleValueProvider.cs" />
    <Compile Include="Util\SimpleViewDataContainer.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{DDC1CE0C-486E-4E35-BB3B-EAB61F8F9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3D3FFD8A-624D-4E9B-954B-E1C105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
    <ProjectReference Include="..\System.Web.Razor.Test\System.Web.Razor.Test.csproj">
      <Project>{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}</Project>
      <Name>System.Web.Razor.Test</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Properties\Resources.resx">
      <Generator>ResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Mvc.Test/Test/AcceptVerbsAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AcceptVerbsAttributeTest
    {
        private const string _invalidEnumFormatString = @"The enum '{0}' did not produce the correct array.
Expected: {1}
Actual: {2}";

        [Fact]
        public void ConstructorThrowsIfVerbsIsEmpty()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new AcceptVerbsAttribute(new string[0]); }, "verbs");
        }

        [Fact]
        public void ConstructorThrowsIfVerbsIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new AcceptVerbsAttribute((string[])null); }, "verbs");
        }

        [Fact]
        public void EnumToArray()
        {
            // Arrange
            IDictionary<string, HttpVerbs> enumValues = EnumToDictionary<HttpVerbs>();
            var allCombinations = EnumerableToCombinations(enumValues);

            // Act & assert
            foreach (var combination in allCombinations)
            {
                // generate all the names + values in this combination
                List<string> aggrNames = new List<string>();
                HttpVerbs aggrValues = (HttpVerbs)0;
                foreach (var entry in combination)
                {
                    aggrNames.Add(entry.Key);
                    aggrValues |= entry.Value;
                }

                // get the resulting array
                string[] array = AcceptVerbsAttribute.EnumToArray(aggrValues);
                var aggrNamesOrdered = aggrNames.OrderBy(name => name, StringComparer.OrdinalIgnoreCase);
                var arrayOrdered = array.OrderBy(name => name, StringComparer.OrdinalIgnoreCase);
                bool match = aggrNamesOrdered.SequenceEqual(arrayOrdered, StringComparer.OrdinalIgnoreCase);

                if (!match)
                {
                    string message = String.Format(_invalidEnumFormatString, aggrValues,
                                                   aggrNames.Aggregate((a, b) => a + ", " + b),
                                                   array.Aggregate((a, b) => a + ", " + b));
                    Assert.True(false, message);
                }
            }
        }

        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotInVerbsCollection()
        {
            // Arrange
            AcceptVerbsAttribute attr = new AcceptVerbsAttribute("get", "post");
            ControllerContext context = GetControllerContextWithHttpVerb("HEAD");

            // Act
            bool result = attr.IsValidForRequest(context, null);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsInVerbsCollection()
        {
            // Arrange
            AcceptVerbsAttribute attr = new AcceptVerbsAttribute("get", "post");
            ControllerContext context = GetControllerContextWithHttpVerb("POST");

            // Act
            bool result = attr.IsValidForRequest(context, null);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsOverridden()
        {
            // Arrange
            AcceptVerbsAttribute attr = new AcceptVerbsAttribute("put");
            ControllerContext context = GetControllerContextWithHttpVerb("POST", "PUT", null, null);

            // Act
            bool result = attr.IsValidForRequest(context, null);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            // Arrange
            AcceptVerbsAttribute attr = new AcceptVerbsAttribute("get", "post");

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { attr.IsValidForRequest(null, null); }, "controllerContext");
        }

        [Fact]
        public void VerbsPropertyFromEnumConstructor()
        {
            // Arrange
            AcceptVerbsAttribute attr = new AcceptVerbsAttribute(HttpVerbs.Get | HttpVerbs.Post);

            // Act
            ReadOnlyCollection<string> collection = attr.Verbs as ReadOnlyCollection<string>;

            // Assert
            Assert.NotNull(collection);
            Assert.Equal(2, collection.Count);
            Assert.Equal("GET", collection[0]);
            Assert.Equal("POST", collection[1]);
        }

        [Fact]
        public void VerbsPropertyFromStringArrayConstructor()
        {
            // Arrange
            AcceptVerbsAttribute attr = new AcceptVerbsAttribute("get", "post");

            // Act
            ReadOnlyCollection<string> collection = attr.Verbs as ReadOnlyCollection<string>;

            // Assert
            Assert.NotNull(collection);
            Assert.Equal(2, collection.Count);
            Assert.Equal("get", collection[0]);
            Assert.Equal("post", collection[1]);
        }

        internal static ControllerContext GetControllerContextWithHttpVerb(string httpRequestVerb)
        {
            return GetControllerContextWithHttpVerb(httpRequestVerb, null, null, null);
        }

        internal static ControllerContext GetControllerContextWithHttpVerb(string httpRequestVerb, string httpHeaderVerb, string httpFormVerb, string httpQueryStringVerb)
        {
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.HttpMethod).Returns(httpRequestVerb);

            NameValueCollection headers = new NameValueCollection();
            if (!String.IsNullOrEmpty(httpHeaderVerb))
            {
                headers.Add(HttpRequestExtensions.XHttpMethodOverrideKey, httpHeaderVerb);
            }
            mockControllerContext.Setup(c => c.HttpContext.Request.Headers).Returns(headers);

            NameValueCollection form = new NameValueCollection();
            if (!String.IsNullOrEmpty(httpFormVerb))
            {
                form.Add(HttpRequestExtensions.XHttpMethodOverrideKey, httpFormVerb);
            }
            mockControllerContext.Setup(c => c.HttpContext.Request.Form).Returns(form);

            NameValueCollection queryString = new NameValueCollection();
            if (!String.IsNullOrEmpty(httpQueryStringVerb))
            {
                queryString.Add(HttpRequestExtensions.XHttpMethodOverrideKey, httpQueryStringVerb);
            }
            mockControllerContext.Setup(c => c.HttpContext.Request.QueryString).Returns(queryString);

            return mockControllerContext.Object;
        }

        private static IDictionary<string, TEnum> EnumToDictionary<TEnum>()
        {
            // Arrange
            var values = Enum.GetValues(typeof(TEnum)).Cast<TEnum>();
            return values.ToDictionary(value => Enum.GetName(typeof(TEnum), value), value => value);
        }

        private static IEnumerable<ICollection<T>> EnumerableToCombinations<T>(IEnumerable<T> elements)
        {
            List<T> allElements = elements.ToList();

            int maxCount = 1 << allElements.Count;
            for (int idxCombination = 0; idxCombination < maxCount; idxCombination++)
            {
                List<T> thisCollection = new List<T>();
                for (int idxBit = 0; idxBit < 32; idxBit++)
                {
                    bool bitActive = (((uint)idxCombination >> idxBit) & 1) != 0;
                    if (bitActive)
                    {
                        thisCollection.Add(allElements[idxBit]);
                    }
                }
                yield return thisCollection;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ActionDescriptorTest
    {
        [Fact]
        public void ExtractParameterOrDefaultFromDictionary_ReturnsDefaultParameterValueIfMismatch()
        {
            // Arrange
            Dictionary<string, object> dictionary = new Dictionary<string, object>()
            {
                { "stringParameterWithDefaultValue", 42 }
            };

            // Act
            object value = ActionDescriptor.ExtractParameterOrDefaultFromDictionary(ParameterExtractionController.StringParameterWithDefaultValue, dictionary);

            // Assert
            Assert.Equal("hello", value);
        }

        [Fact]
        public void ExtractParameterOrDefaultFromDictionary_ReturnsDefaultTypeValueIfNoMatchAndNoDefaultParameterValue()
        {
            // Arrange
            Dictionary<string, object> dictionary = new Dictionary<string, object>();

            // Act
            object value = ActionDescriptor.ExtractParameterOrDefaultFromDictionary(ParameterExtractionController.IntParameter, dictionary);

            // Assert
            Assert.Equal(0, value);
        }

        [Fact]
        public void ExtractParameterOrDefaultFromDictionary_ReturnsDictionaryValueIfTypeMatch()
        {
            // Arrange
            Dictionary<string, object> dictionary = new Dictionary<string, object>()
            {
                { "stringParameterNoDefaultValue", "someValue" }
            };

            // Act
            object value = ActionDescriptor.ExtractParameterOrDefaultFromDictionary(ParameterExtractionController.StringParameterNoDefaultValue, dictionary);

            // Assert
            Assert.Equal("someValue", value);
        }

        [Fact]
        public void GetCustomAttributesReturnsEmptyArrayOfAttributeType()
        {
            // Arrange
            ActionDescriptor ad = GetActionDescriptor();

            // Act
            ObsoleteAttribute[] attrs = (ObsoleteAttribute[])ad.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Empty(attrs);
        }

        [Fact]
        public void GetCustomAttributesThrowsIfAttributeTypeIsNull()
        {
            // Arrange
            ActionDescriptor ad = GetActionDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.GetCustomAttributes(null /* attributeType */, true); }, "attributeType");
        }

        [Fact]
        public void GetCustomAttributesWithoutAttributeTypeCallsGetCustomAttributesWithAttributeType()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<ActionDescriptor> mockDescriptor = new Mock<ActionDescriptor>() { CallBase = true };
            mockDescriptor.Setup(d => d.GetCustomAttributes(typeof(object), true)).Returns(expected);
            ActionDescriptor ad = mockDescriptor.Object;

            // Act
            object[] returned = ad.GetCustomAttributes(true /* inherit */);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetFilterAttributes_CallsGetCustomAttributes()
        {
            // Arrange
            var mockDescriptor = new Mock<ActionDescriptor>() { CallBase = true };
            mockDescriptor.Setup(d => d.GetCustomAttributes(typeof(FilterAttribute), true)).Returns(new object[] { new Mock<FilterAttribute>().Object }).Verifiable();

            // Act
            var result = mockDescriptor.Object.GetFilterAttributes(true).ToList();

            // Assert
            mockDescriptor.Verify();
            Assert.Single(result);
        }

        [Fact]
        public void GetSelectorsReturnsEmptyCollection()
        {
            // Arrange
            ActionDescriptor ad = GetActionDescriptor();

            // Act
            ICollection<ActionSelector> selectors = ad.GetSelectors();

            // Assert
            Assert.IsType<ActionSelector[]>(selectors);
            Assert.Empty(selectors);
        }

        [Fact]
        public void IsDefinedReturnsFalse()
        {
            // Arrange
            ActionDescriptor ad = GetActionDescriptor();

            // Act
            bool isDefined = ad.IsDefined(typeof(object), true);

            // Assert
            Assert.False(isDefined);
        }

        [Fact]
        public void IsDefinedThrowsIfAttributeTypeIsNull()
        {
            // Arrange
            ActionDescriptor ad = GetActionDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.IsDefined(null /* attributeType */, true); }, "attributeType");
        }

        [Fact]
        public void UniqueId_SameTypeControllerDescriptorAndActionName_SameID()
        {
            // Arrange
            var controllerDescriptor = new Mock<ControllerDescriptor>().Object;

            var descriptor1 = new Mock<ActionDescriptor> { CallBase = true };
            descriptor1.SetupGet(d => d.ControllerDescriptor).Returns(controllerDescriptor);
            descriptor1.SetupGet(d => d.ActionName).Returns("Action1");

            var descriptor2 = new Mock<ActionDescriptor> { CallBase = true };
            descriptor2.SetupGet(d => d.ControllerDescriptor).Returns(controllerDescriptor);
            descriptor2.SetupGet(d => d.ActionName).Returns("Action1");

            // Act
            var id1 = descriptor1.Object.UniqueId;
            var id2 = descriptor2.Object.UniqueId;

            // Assert
            Assert.Equal(id1, id2);
        }

        [Fact]
        public void UniqueId_VariesWithActionName()
        {
            // Arrange
            var controllerDescriptor = new Mock<ControllerDescriptor>().Object;

            var descriptor1 = new Mock<ActionDescriptor> { CallBase = true };
            descriptor1.SetupGet(d => d.ControllerDescriptor).Returns(controllerDescriptor);
            descriptor1.SetupGet(d => d.ActionName).Returns("Action1");

            var descriptor2 = new Mock<ActionDescriptor> { CallBase = true };
            descriptor2.SetupGet(d => d.ControllerDescriptor).Returns(controllerDescriptor);
            descriptor2.SetupGet(d => d.ActionName).Returns("Action2");

            // Act
            var id1 = descriptor1.Object.UniqueId;
            var id2 = descriptor2.Object.UniqueId;

            // Assert
            Assert.NotEqual(id1, id2);
        }

        [Fact]
        public void UniqueId_VariesWithControllerDescriptorsUniqueId()
        {
            // Arrange
            var controllerDescriptor1 = new Mock<ControllerDescriptor>();
            controllerDescriptor1.SetupGet(cd => cd.UniqueId).Returns("1");
            var descriptor1 = new Mock<ActionDescriptor> { CallBase = true };
            descriptor1.SetupGet(d => d.ControllerDescriptor).Returns(controllerDescriptor1.Object);
            descriptor1.SetupGet(d => d.ActionName).Returns("Action1");

            var controllerDescriptor2 = new Mock<ControllerDescriptor>();
            controllerDescriptor2.SetupGet(cd => cd.UniqueId).Returns("2");
            var descriptor2 = new Mock<ActionDescriptor> { CallBase = true };
            descriptor2.SetupGet(d => d.ControllerDescriptor).Returns(controllerDescriptor2.Object);
            descriptor2.SetupGet(d => d.ActionName).Returns("Action1");

            // Act
            var id1 = descriptor1.Object.UniqueId;
            var id2 = descriptor2.Object.UniqueId;

            // Assert
            Assert.NotEqual(id1, id2);
        }

        [Fact]
        public void UniqueId_VariesWithActionDescriptorType()
        {
            // Arrange
            var descriptor1 = new BaseDescriptor();
            var descriptor2 = new DerivedDescriptor();

            // Act
            var id1 = descriptor1.UniqueId;
            var id2 = descriptor2.UniqueId;

            // Assert
            Assert.NotEqual(id1, id2);
        }

        class BaseDescriptor : ActionDescriptor
        {
            static ControllerDescriptor controllerDescriptor = new Mock<ControllerDescriptor>().Object;

            public override string ActionName
            {
                get { return "ActionName"; }
            }

            public override ControllerDescriptor ControllerDescriptor
            {
                get { return controllerDescriptor; }
            }

            public override object Execute(ControllerContext controllerContext, IDictionary<string, object> parameters)
            {
                throw new NotImplementedException();
            }

            public override ParameterDescriptor[] GetParameters()
            {
                throw new NotImplementedException();
            }
        }

        class DerivedDescriptor : BaseDescriptor
        {
        }

        private static ActionDescriptor GetActionDescriptor()
        {
            Mock<ActionDescriptor> mockDescriptor = new Mock<ActionDescriptor>() { CallBase = true };
            return mockDescriptor.Object;
        }

        private class ParameterExtractionController : Controller
        {
            public static readonly ParameterInfo IntParameter = typeof(ParameterExtractionController).GetMethod("SomeMethod").GetParameters()[0];
            public static readonly ParameterInfo StringParameterNoDefaultValue = typeof(ParameterExtractionController).GetMethod("SomeMethod").GetParameters()[1];
            public static readonly ParameterInfo StringParameterWithDefaultValue = typeof(ParameterExtractionController).GetMethod("SomeMethod").GetParameters()[2];

            public void SomeMethod(int intParameter, string stringParameterNoDefaultValue, [DefaultValue("hello")] string stringParameterWithDefaultValue)
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionExecutedContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ActionExecutedContextTest
    {
        [Fact]
        public void ConstructorThrowsIfActionDescriptorIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionDescriptor actionDescriptor = null;
            bool canceled = true;
            Exception exception = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ActionExecutedContext(controllerContext, actionDescriptor, canceled, exception); }, "actionDescriptor");
        }

        [Fact]
        public void PropertiesAreSetByConstructor()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionDescriptor actionDescriptor = new Mock<ActionDescriptor>().Object;
            bool canceled = true;
            Exception exception = new Exception();

            // Act
            ActionExecutedContext actionExecutedContext = new ActionExecutedContext(controllerContext, actionDescriptor, canceled, exception);

            // Assert
            Assert.Equal(actionDescriptor, actionExecutedContext.ActionDescriptor);
            Assert.Equal(canceled, actionExecutedContext.Canceled);
            Assert.Equal(exception, actionExecutedContext.Exception);
        }

        [Fact]
        public void ResultProperty()
        {
            // Arrange
            ActionExecutedContext actionExecutedContext = new Mock<ActionExecutedContext>().Object;

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(actionExecutedContext, "Result", new ViewResult(), EmptyResult.Instance);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionExecutingContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ActionExecutingContextTest
    {
        [Fact]
        public void ConstructorThrowsIfActionDescriptorIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionDescriptor actionDescriptor = null;
            Dictionary<string, object> actionParameters = new Dictionary<string, object>();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ActionExecutingContext(controllerContext, actionDescriptor, actionParameters); }, "actionDescriptor");
        }

        [Fact]
        public void ConstructorThrowsIfActionParametersIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionDescriptor actionDescriptor = new Mock<ActionDescriptor>().Object;
            Dictionary<string, object> actionParameters = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ActionExecutingContext(controllerContext, actionDescriptor, actionParameters); }, "actionParameters");
        }

        [Fact]
        public void PropertiesAreSetByConstructor()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionDescriptor actionDescriptor = new Mock<ActionDescriptor>().Object;
            Dictionary<string, object> actionParameters = new Dictionary<string, object>();

            // Act
            ActionExecutingContext actionExecutingContext = new ActionExecutingContext(controllerContext, actionDescriptor, actionParameters);

            // Assert
            Assert.Equal(actionDescriptor, actionExecutingContext.ActionDescriptor);
            Assert.Equal(actionParameters, actionExecutingContext.ActionParameters);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionFilterAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ActionFilterAttributeTest
    {
        [Fact]
        public void DefaultOrderIsNegativeOne()
        {
            // Act
            var attr = new EmptyActionFilterAttribute();

            // Assert
            Assert.Equal(-1, attr.Order);
        }

        [Fact]
        public void OrderIsSetCorrectly()
        {
            // Act
            var attr = new EmptyActionFilterAttribute() { Order = 98052 };

            // Assert
            Assert.Equal(98052, attr.Order);
        }

        [Fact]
        public void SpecifyingInvalidOrderThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentOutOfRange(
                delegate { new EmptyActionFilterAttribute() { Order = -2 }; },
                "value",
                "Order must be greater than or equal to -1.");
        }

        private class EmptyActionFilterAttribute : ActionFilterAttribute
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionMethodDispatcherCacheTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ActionMethodDispatcherCacheTest
    {
        [Fact]
        public void GetDispatcher()
        {
            // Arrange
            MethodInfo methodInfo = typeof(object).GetMethod("ToString");
            ActionMethodDispatcherCache cache = new ActionMethodDispatcherCache();

            // Act
            ActionMethodDispatcher dispatcher1 = cache.GetDispatcher(methodInfo);
            ActionMethodDispatcher dispatcher2 = cache.GetDispatcher(methodInfo);

            // Assert
            Assert.Same(methodInfo, dispatcher1.MethodInfo);
            Assert.Same(dispatcher1, dispatcher2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionMethodDispatcherTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ActionMethodDispatcherTest
    {
        [Fact]
        public void ExecuteWithNormalActionMethod()
        {
            // Arrange
            DispatcherController controller = new DispatcherController();
            object[] parameters = new object[] { 5, "some string", new DateTime(2001, 1, 1) };
            MethodInfo methodInfo = typeof(DispatcherController).GetMethod("NormalAction");
            ActionMethodDispatcher dispatcher = new ActionMethodDispatcher(methodInfo);

            // Act
            object returnValue = dispatcher.Execute(controller, parameters);

            // Assert
            var stringResult = Assert.IsType<string>(returnValue);
            Assert.Equal("Hello from NormalAction!", stringResult);

            Assert.Equal(5, controller._i);
            Assert.Equal("some string", controller._s);
            Assert.Equal(new DateTime(2001, 1, 1), controller._dt);
        }

        [Fact]
        public void ExecuteWithParameterlessActionMethod()
        {
            // Arrange
            DispatcherController controller = new DispatcherController();
            object[] parameters = new object[0];
            MethodInfo methodInfo = typeof(DispatcherController).GetMethod("ParameterlessAction");
            ActionMethodDispatcher dispatcher = new ActionMethodDispatcher(methodInfo);

            // Act
            object returnValue = dispatcher.Execute(controller, parameters);

            // Assert
            var intResult = Assert.IsType<int>(returnValue);
            Assert.Equal(53, intResult);
        }

        [Fact]
        public void ExecuteWithStaticActionMethod()
        {
            // Arrange
            DispatcherController controller = new DispatcherController();
            object[] parameters = new object[0];
            MethodInfo methodInfo = typeof(DispatcherController).GetMethod("StaticAction");
            ActionMethodDispatcher dispatcher = new ActionMethodDispatcher(methodInfo);

            // Act
            object returnValue = dispatcher.Execute(controller, parameters);

            // Assert
            var intResult = Assert.IsType<int>(returnValue);
            Assert.Equal(89, intResult);
        }

        [Fact]
        public void ExecuteWithVoidActionMethod()
        {
            // Arrange
            DispatcherController controller = new DispatcherController();
            object[] parameters = new object[] { 5, "some string", new DateTime(2001, 1, 1) };
            MethodInfo methodInfo = typeof(DispatcherController).GetMethod("VoidAction");
            ActionMethodDispatcher dispatcher = new ActionMethodDispatcher(methodInfo);

            // Act
            object returnValue = dispatcher.Execute(controller, parameters);

            // Assert
            Assert.Null(returnValue);
            Assert.Equal(5, controller._i);
            Assert.Equal("some string", controller._s);
            Assert.Equal(new DateTime(2001, 1, 1), controller._dt);
        }

        [Fact]
        public void MethodInfoProperty()
        {
            // Arrange
            MethodInfo original = typeof(object).GetMethod("ToString");
            ActionMethodDispatcher dispatcher = new ActionMethodDispatcher(original);

            // Act
            MethodInfo returned = dispatcher.MethodInfo;

            // Assert
            Assert.Same(original, returned);
        }

        private class DispatcherController : Controller
        {
            public int _i;
            public string _s;
            public DateTime _dt;

            public object NormalAction(int i, string s, DateTime dt)
            {
                VoidAction(i, s, dt);
                return "Hello from NormalAction!";
            }

            public int ParameterlessAction()
            {
                return 53;
            }

            public void VoidAction(int i, string s, DateTime dt)
            {
                _i = i;
                _s = s;
                _dt = dt;
            }

            public static int StaticAction()
            {
                return 89;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionMethodSelectorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Web.Mvc.Routing;
using System.Web.Routing;
using System.Web.Routing.Test;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ActionMethodSelectorTest
    {
        [Fact]
        public void AliasedMethodsProperty()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);

            // Act
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Assert
            Assert.Equal(2, selector.AliasedMethods.Length);

            List<MethodInfo> sortedAliasedMethods = selector.AliasedMethods.OrderBy(methodInfo => methodInfo.Name).ToList();
            Assert.Equal("Bar", sortedAliasedMethods[0].Name);
            Assert.Equal("FooRenamed", sortedAliasedMethods[1].Name);
        }

        [Fact]
        public void ControllerTypeProperty()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act & Assert
            Assert.Same(controllerType, selector.ControllerType);
        }

        [Fact]
        public void FindActionMethodReturnsMatchingMethodIfOneMethodMatches()
        {
            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "OneMatch");

            // Assert
            Assert.Equal("OneMatch", matchedMethod.Name);
            Assert.Equal(typeof(string), matchedMethod.GetParameters()[0].ParameterType);
        }

        [Fact]
        public void FindActionMethodReturnsMethodWithActionSelectionAttributeIfMultipleMethodsMatchRequest()
        {
            // DevDiv Bugs 212062: If multiple action methods match a request, we should match only the methods with an
            // [ActionMethod] attribute since we assume those methods are more specific.

            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "ShouldMatchMethodWithSelectionAttribute");

            // Assert
            Assert.Equal("MethodHasSelectionAttribute1", matchedMethod.Name);
        }

        [Fact]
        public void FindActionMethodReturnsMethodWithoutAttributeWhenOthersOptOut()
        {
            // Arrange
            Type controllerType = typeof(ControllerMatchMiddleNoAttribute);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "MiddleMatch");

            // Assert
            Assert.Equal("MiddleMatch", matchedMethod.Name);
        }

        [Fact]
        public void FindActionMethodReturnsMethodWithAttributeWhenOthersOptOutAndNoAttribute()
        {
            // Arrange
            Type controllerType = typeof(ControllerMatchMiddleWithAttribute);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "MiddleMatch");

            // Assert
            Assert.Equal("MiddleMatch", matchedMethod.Name);
        }

        [Fact]
        public void FindActionMethodReturnsMethodMultipleMatchesOverOneOptOut()
        {
            // Arrange
            Type controllerType = typeof(ControllerMatchMultipleAttributes);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "Match");

            // Assert
            Assert.Equal("Match", matchedMethod.Name);
        }

        [Fact]
        public void FindActionMethodReturnsNullIfNoMethodMatches()
        {
            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "ZeroMatch");

            // Assert
            Assert.Null(matchedMethod);
        }

        [Fact]
        public void FindActionMethod_IgnoresDirectRouteAttributedMethods()
        {
            // Arrange
            Type controllerType = typeof(WithRoutingAttributeController);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // This simulates what AttributeRoutingMapper will do
            selector.StandardRouteMethods.Remove(controllerType.GetMethod("ActionWithoutRoute"));
            selector.StandardRouteMethods.Remove(controllerType.GetMethod("DirectRouteOnly"));

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "Action");

            // Assert
            Assert.NotNull(matchedMethod);
            Assert.Equal("Action", matchedMethod.Name);
        }

        [Fact]
        public void FindActionMethod_IgnoresDirectRouteAttributedMethods_NoMatch()
        {
            // Arrange
            Type controllerType = typeof(WithRoutingAttributeController);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // This simulates what AttributeRoutingMapper will do
            selector.StandardRouteMethods.Remove(controllerType.GetMethod("ActionWithoutRoute"));
            selector.StandardRouteMethods.Remove(controllerType.GetMethod("DirectRouteOnly"));

            // Act
            MethodInfo matchedMethod = selector.FindActionMethod(new ControllerContext(), "DirectRouteOnly");

            // Assert
            Assert.Null(matchedMethod);
        }

        [Fact]
        public void FindActionMethodThrowsIfMultipleMethodsMatch()
        {
            // Arrange
            Type controllerType = typeof(SelectionAttributeController);
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Act & veriy
            Assert.Throws<AmbiguousMatchException>(
                delegate { selector.FindActionMethod(new ControllerContext(), "TwoMatch"); },
                "The current request for action 'TwoMatch' on controller type 'SelectionAttributeController' is ambiguous between the following action methods:" + Environment.NewLine
              + "Void TwoMatch2() on type System.Web.Mvc.Test.ActionMethodSelectorTest+SelectionAttributeController" + Environment.NewLine
              + "Void TwoMatch() on type System.Web.Mvc.Test.ActionMethodSelectorTest+SelectionAttributeController");
        }

        [Fact]
        public void NonAliasedMethodsProperty()
        {
            // Arrange
            Type controllerType = typeof(MethodLocatorController);

            // Act
            ActionMethodSelector selector = new ActionMethodSelector(controllerType);

            // Assert
            Assert.Single(selector.NonAliasedMethods);

            List<MethodInfo> sortedMethods = selector.NonAliasedMethods["foo"].OrderBy(methodInfo => methodInfo.GetParameters().Length).ToList();
            Assert.Equal("Foo", sortedMethods[0].Name);
            Assert.Empty(sortedMethods[0].GetParameters());
            Assert.Equal("Foo", sortedMethods[1].Name);
            Assert.Equal(typeof(string), sortedMethods[1].GetParameters()[0].ParameterType);
        }

        private class MethodLocatorController : Controller
        {
            public void Foo()
            {
            }

            public void Foo(string s)
            {
            }

            [ActionName("Foo")]
            public void FooRenamed()
            {
            }

            [ActionName("Bar")]
            public void Bar()
            {
            }

            [ActionName("PrivateVoid")]
            private void PrivateVoid()
            {
            }

            protected void ProtectedVoidAction()
            {
            }

            public static void StaticMethod()
            {
            }

            // ensure that methods inheriting from Controller or a base class are not matched
            [ActionName("Blah")]
            protected override void ExecuteCore()
            {
                throw new NotImplementedException();
            }

            public string StringProperty { get; set; }

#pragma warning disable 0067
            public event EventHandler<EventArgs> SomeEvent;
#pragma warning restore 0067
        }

        private class ControllerMatchMiddleNoAttribute : Controller
        {
            [Match(false)]
            [ActionName("MiddleMatch")]
            public void SkipMatchBefore()
            {
            }

            public void MiddleMatch()
            {
            }

            [Match(false)]
            [ActionName("MiddleMatch")]
            public void SkipMatchAfter()
            {
            }
        }

        private class ControllerMatchMultipleAttributes : Controller
        {
            [Match(false)]
            [Match(true)]
            [ActionName("Match")]
            public void SkipMatchBeforeOneOptOut()
            {
            }

            [Match(true)]
            [Match(true)]
            public void Match()
            {
            }

            [ActionName("Match")]
            public void SkipMatchAfterNoAttribute()
            {
            }
        }

        private class ControllerMatchMiddleWithAttribute : Controller
        {
            [Match(false)]
            [ActionName("MiddleMatch")]
            public void SkipMatchBeforeNonMatch()
            {
            }

            [ActionName("MiddleMatch")]
            public void SkipMatchBeforeNoSelection()
            {
            }

            [Match(true)]
            public void MiddleMatch()
            {
            }

            [ActionName("MiddleMatch")]
            public void SkipMatchAfterNoSelection()
            {
            }

            [Match(false)]
            [ActionName("MiddleMatch")]
            public void SkipMatchAfterNonMatch()
            {
            }
        }

        private class SelectionAttributeController : Controller
        {
            [Match(false)]
            public void OneMatch()
            {
            }

            public void OneMatch(string s)
            {
            }

            public void TwoMatch()
            {
            }

            [ActionName("TwoMatch")]
            public void TwoMatch2()
            {
            }

            [Match(true), ActionName("ShouldMatchMethodWithSelectionAttribute")]
            public void MethodHasSelectionAttribute1()
            {
            }

            [ActionName("ShouldMatchMethodWithSelectionAttribute")]
            public void MethodDoesNotHaveSelectionAttribute1()
            {
            }
        }

        private class WithRoutingAttributeController : Controller
        {
            [Route("route")]
            [ActionName("Action")] // to make things confusing
            public void ActionWithoutRoute()
            {
            }

            public void Action()
            {
            }

            [Route("routeonly")]
            public void DirectRouteOnly()
            {
            }
        }

        [AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
        private class MatchAttribute : ActionMethodSelectorAttribute
        {
            private bool _match;

            public MatchAttribute(bool match)
            {
                _match = match;
            }

            public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
            {
                return _match;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ActionNameAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ActionNameAttributeTest
    {
        [Fact]
        public void ConstructorThrowsIfNameIsEmpty()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new ActionNameAttribute(String.Empty); }, "name");
        }

        [Fact]
        public void ConstructorThrowsIfNameIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new ActionNameAttribute(null); }, "name");
        }

        [Fact]
        public void IsValidForRequestReturnsFalseIfGivenNameDoesNotMatch()
        {
            // Arrange
            ActionNameAttribute attr = new ActionNameAttribute("Bar");

            // Act
            bool returned = attr.IsValidName(null, "foo", null);

            // Assert
            Assert.False(returned);
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfGivenNameMatches()
        {
            // Arrange
            ActionNameAttribute attr = new ActionNameAttribute("Bar");

            // Act
            bool returned = attr.IsValidName(null, "bar", null);

            // Assert
            Assert.True(returned);
        }

        [Fact]
        public void NameProperty()
        {
            // Arrange
            ActionNameAttribute attr = new ActionNameAttribute("someName");

            // Act & Assert
            Assert.Equal("someName", attr.Name);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AdditionalMetadataAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AdditionalMetadataAttributeTest
    {
        [Fact]
        public void GuardClauses()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => new AdditionalMetadataAttribute(null, new object()),
                "name");

            AdditionalMetadataAttribute attr = new AdditionalMetadataAttribute("key", null);
            Assert.ThrowsArgumentNull(
                () => attr.OnMetadataCreated(null),
                "metadata");
        }

        [Fact]
        public void OnMetaDataCreatedSetsAdditionalValue()
        {
            // Arrange
            string name = "name";
            object value = new object();

            ModelMetadata modelMetadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(object), null);
            AdditionalMetadataAttribute attr = new AdditionalMetadataAttribute(name, value);

            // Act
            attr.OnMetadataCreated(modelMetadata);

            // Assert
            Assert.Equal(modelMetadata.AdditionalValues[name], value);
            Assert.Equal(attr.Name, name);
            Assert.Equal(attr.Value, value);
        }

        [Fact]
        public void MultipleAttributesCanSetValuesOnMetadata()
        {
            // Arrange
            string name1 = "name1";
            string name2 = "name2";

            object value1 = new object();
            object value2 = new object();
            object value3 = new object();

            ModelMetadata modelMetadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(object), null);
            AdditionalMetadataAttribute attr1 = new AdditionalMetadataAttribute(name1, value1);
            AdditionalMetadataAttribute attr2 = new AdditionalMetadataAttribute(name2, value2);
            AdditionalMetadataAttribute attr3 = new AdditionalMetadataAttribute(name1, value3);

            // Act
            attr1.OnMetadataCreated(modelMetadata);
            attr2.OnMetadataCreated(modelMetadata);
            attr3.OnMetadataCreated(modelMetadata);

            // Assert
            Assert.Equal(2, modelMetadata.AdditionalValues.Count);
            Assert.Equal(modelMetadata.AdditionalValues[name1], value3);
            Assert.Equal(modelMetadata.AdditionalValues[name2], value2);

            Assert.NotEqual(attr1.TypeId, attr2.TypeId);
            Assert.NotEqual(attr2.TypeId, attr3.TypeId);
            Assert.NotEqual(attr3.TypeId, attr1.TypeId);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AjaxHelperOfTModelTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AjaxHelperOfTModelTest
    {
        [Fact]
        public void ViewBagAndViewDataStayInSync()
        {
            // Arrange
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            // Act
            AjaxHelper<object> ajaxHelper = new AjaxHelper<object>(new Mock<ViewContext>().Object, viewDataContainer.Object);
            ajaxHelper.ViewData["B"] = 2;
            ajaxHelper.ViewBag.C = 3;

            // Assert

            // Original ViewData should not be modified by redfined ViewData and ViewBag
            AjaxHelper nonGenericAjaxHelper = ajaxHelper;
            Assert.Single(nonGenericAjaxHelper.ViewData.Keys);
            Assert.Equal(1, nonGenericAjaxHelper.ViewData["A"]);
            Assert.Equal(1, nonGenericAjaxHelper.ViewBag.A);

            // Redefined ViewData and ViewBag should be in sync
            Assert.Equal(3, ajaxHelper.ViewData.Keys.Count);

            Assert.Equal(1, ajaxHelper.ViewData["A"]);
            Assert.Equal(2, ajaxHelper.ViewData["B"]);
            Assert.Equal(3, ajaxHelper.ViewData["C"]);

            Assert.Equal(1, ajaxHelper.ViewBag.A);
            Assert.Equal(2, ajaxHelper.ViewBag.B);
            Assert.Equal(3, ajaxHelper.ViewBag.C);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AjaxHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AjaxHelperTest
    {
        [Fact]
        public void ConstructorWithNullViewContextThrows()
        {
            // Assert
            Assert.ThrowsArgumentNull(
                delegate { AjaxHelper ajaxHelper = new AjaxHelper(null, new Mock<IViewDataContainer>().Object); },
                "viewContext");
        }

        [Fact]
        public void ConstructorWithNullViewDataContainerThrows()
        {
            // Assert
            Assert.ThrowsArgumentNull(
                delegate { AjaxHelper ajaxHelper = new AjaxHelper(new Mock<ViewContext>().Object, null); },
                "viewDataContainer");
        }

        [Fact]
        public void ConstructorSetsProperties1()
        {
            // Arrange
            ViewContext viewContext = new Mock<ViewContext>().Object;
            IViewDataContainer vdc = new Mock<IViewDataContainer>().Object;

            // Act
            AjaxHelper ajaxHelper = new AjaxHelper(viewContext, vdc);

            // Assert
            Assert.Equal(viewContext, ajaxHelper.ViewContext);
            Assert.Equal(vdc, ajaxHelper.ViewDataContainer);
            Assert.Equal(RouteTable.Routes, ajaxHelper.RouteCollection);
        }

        [Fact]
        public void ConstructorSetsProperties2()
        {
            // Arrange
            ViewContext viewContext = new Mock<ViewContext>().Object;
            IViewDataContainer vdc = new Mock<IViewDataContainer>().Object;
            RouteCollection rc = new RouteCollection();

            // Act
            AjaxHelper ajaxHelper = new AjaxHelper(viewContext, vdc, rc);

            // Assert
            Assert.Equal(viewContext, ajaxHelper.ViewContext);
            Assert.Equal(vdc, ajaxHelper.ViewDataContainer);
            Assert.Equal(rc, ajaxHelper.RouteCollection);
        }

        [Fact]
        public void GenericHelperConstructorSetsProperties1()
        {
            // Arrange
            ViewContext viewContext = new Mock<ViewContext>().Object;
            ViewDataDictionary<Controller> vdd = new ViewDataDictionary<Controller>(new Mock<Controller>().Object);
            Mock<IViewDataContainer> vdc = new Mock<IViewDataContainer>();
            vdc.Setup(v => v.ViewData).Returns(vdd);

            // Act
            AjaxHelper<Controller> ajaxHelper = new AjaxHelper<Controller>(viewContext, vdc.Object);

            // Assert
            Assert.Equal(viewContext, ajaxHelper.ViewContext);
            Assert.Equal(vdc.Object, ajaxHelper.ViewDataContainer);
            Assert.Equal(RouteTable.Routes, ajaxHelper.RouteCollection);
            Assert.Equal(vdd.Model, ajaxHelper.ViewData.Model);
        }

        [Fact]
        public void GenericHelperConstructorSetsProperties2()
        {
            // Arrange
            ViewContext viewContext = new Mock<ViewContext>().Object;
            ViewDataDictionary<Controller> vdd = new ViewDataDictionary<Controller>(new Mock<Controller>().Object);
            Mock<IViewDataContainer> vdc = new Mock<IViewDataContainer>();
            vdc.Setup(v => v.ViewData).Returns(vdd);
            RouteCollection rc = new RouteCollection();

            // Act
            AjaxHelper<Controller> ajaxHelper = new AjaxHelper<Controller>(viewContext, vdc.Object, rc);

            // Assert
            Assert.Equal(viewContext, ajaxHelper.ViewContext);
            Assert.Equal(vdc.Object, ajaxHelper.ViewDataContainer);
            Assert.Equal(rc, ajaxHelper.RouteCollection);
            Assert.Equal(vdd.Model, ajaxHelper.ViewData.Model);
        }

        [Fact]
        public void GlobalizationScriptPathPropertyDefault()
        {
            try
            {
                // Act
                AjaxHelper.GlobalizationScriptPath = null;

                // Assert
                Assert.Equal("~/Scripts/Globalization", AjaxHelper.GlobalizationScriptPath);
            }
            finally
            {
                AjaxHelper.GlobalizationScriptPath = null;
            }
        }

        [Fact]
        public void GlobalizationScriptPathPropertySet()
        {
            try
            {
                // Act
                AjaxHelper.GlobalizationScriptPath = "/Foo/Bar";

                // Assert
                Assert.Equal("/Foo/Bar", AjaxHelper.GlobalizationScriptPath);
            }
            finally
            {
                AjaxHelper.GlobalizationScriptPath = null;
            }
        }

        [Fact]
        public void JavaScriptStringEncodeReturnsEmptyStringIfMessageIsEmpty()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper();

            // Act
            string encoded = ajaxHelper.JavaScriptStringEncode(String.Empty);

            // Assert
            Assert.Equal(String.Empty, encoded);
        }

        [Fact]
        public void JavaScriptStringEncodeReturnsEncodedMessage()
        {
            // Arrange
            string message = "I said, \"Hello, world!\"\nHow are you?";
            AjaxHelper ajaxHelper = GetAjaxHelper();

            // Act
            string encoded = ajaxHelper.JavaScriptStringEncode(message);

            // Assert
            Assert.Equal(@"I said, \""Hello, world!\""\nHow are you?", encoded);
        }

        [Fact]
        public void JavaScriptStringEncodeReturnsNullIfMessageIsNull()
        {
            // Arrange
            AjaxHelper ajaxHelper = GetAjaxHelper();

            // Act
            string encoded = ajaxHelper.JavaScriptStringEncode(null /* message */);

            // Assert
            Assert.Null(encoded);
        }

        [Fact]
        public void ViewBagProperty_ReflectsViewData()
        {
            // Arrange
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            // Act
            AjaxHelper ajaxHelper = new AjaxHelper(new Mock<ViewContext>().Object, viewDataContainer.Object);

            // Assert
            Assert.Equal(1, ajaxHelper.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_ReflectsNewViewDataContainerInstance()
        {
            // Arrange
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            ViewDataDictionary otherViewDataDictionary = new ViewDataDictionary() { { "A", 2 } };
            Mock<IViewDataContainer> otherViewDataContainer = new Mock<IViewDataContainer>();
            otherViewDataContainer.Setup(container => container.ViewData).Returns(otherViewDataDictionary);

            AjaxHelper ajaxHelper = new AjaxHelper(new Mock<ViewContext>().Object, viewDataContainer.Object, new RouteCollection());

            // Act
            ajaxHelper.ViewDataContainer = otherViewDataContainer.Object;

            // Assert
            Assert.Equal(2, ajaxHelper.ViewBag.A);
        }

        [Fact]
        public void ViewBag_PropagatesChangesToViewData()
        {
            // Arrange
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            AjaxHelper ajaxHelper = new AjaxHelper(new Mock<ViewContext>().Object, viewDataContainer.Object, new RouteCollection());

            // Act
            ajaxHelper.ViewBag.A = "foo";
            ajaxHelper.ViewBag.B = 2;

            // Assert
            Assert.Equal("foo", ajaxHelper.ViewData["A"]);
            Assert.Equal(2, ajaxHelper.ViewData["B"]);
        }

        private static AjaxHelper GetAjaxHelper()
        {
            ViewContext viewContext = new Mock<ViewContext>().Object;
            IViewDataContainer viewDataContainer = new Mock<IViewDataContainer>().Object;
            return new AjaxHelper(viewContext, viewDataContainer);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AjaxRequestExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AjaxRequestExtensionsTest
    {
        [Fact]
        public void IsAjaxRequestWithNullRequestThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { AjaxRequestExtensions.IsAjaxRequest(null); }, "request");
        }

        [Fact]
        public void IsAjaxRequestWithKeyIsTrue()
        {
            // Arrange
            Mock<HttpRequestBase> mockRequest = new Mock<HttpRequestBase>();
            mockRequest.Setup(r => r["X-Requested-With"]).Returns("XMLHttpRequest").Verifiable();
            HttpRequestBase request = mockRequest.Object;

            // Act
            bool retVal = AjaxRequestExtensions.IsAjaxRequest(request);

            // Assert
            Assert.True(retVal);
            mockRequest.Verify();
        }

        [Fact]
        public void IsAjaxRequestWithoutKeyOrHeaderIsFalse()
        {
            // Arrange
            Mock<HttpRequestBase> mockRequest = new Mock<HttpRequestBase>();
            NameValueCollection headerCollection = new NameValueCollection();
            mockRequest.Setup(r => r.Headers).Returns(headerCollection).Verifiable();
            mockRequest.Setup(r => r["X-Requested-With"]).Returns((string)null).Verifiable();
            HttpRequestBase request = mockRequest.Object;

            // Act
            bool retVal = AjaxRequestExtensions.IsAjaxRequest(request);

            // Assert
            Assert.False(retVal);
            mockRequest.Verify();
        }

        [Fact]
        public void IsAjaxRequestReturnsTrueIfHeaderSet()
        {
            // Arrange
            Mock<HttpRequestBase> mockRequest = new Mock<HttpRequestBase>();
            NameValueCollection headerCollection = new NameValueCollection();
            headerCollection["X-Requested-With"] = "XMLHttpRequest";
            mockRequest.Setup(r => r.Headers).Returns(headerCollection).Verifiable();
            HttpRequestBase request = mockRequest.Object;

            // Act
            bool retVal = AjaxRequestExtensions.IsAjaxRequest(request);

            // Assert
            Assert.True(retVal);
            mockRequest.Verify();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AllowHtmlAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AllowHtmlAttributeTest
    {
        [Fact]
        public void OnMetadataCreated_ThrowsIfMetadataIsNull()
        {
            // Arrange
            AllowHtmlAttribute attr = new AllowHtmlAttribute();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnMetadataCreated(null); }, "metadata");
        }

        [Fact]
        public void OnMetadataCreated()
        {
            // Arrange
            ModelMetadata modelMetadata = new ModelMetadata(new Mock<ModelMetadataProvider>().Object, null, null, typeof(object), "SomeProperty");
            AllowHtmlAttribute attr = new AllowHtmlAttribute();

            // Act
            bool originalValue = modelMetadata.RequestValidationEnabled;
            attr.OnMetadataCreated(modelMetadata);
            bool newValue = modelMetadata.RequestValidationEnabled;

            // Assert
            Assert.True(originalValue);
            Assert.False(newValue);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AreaHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class AreaHelpersTest
    {
        [Fact]
        public void GetAreaNameFromAreaRouteCollectionRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("area_name", routes);
            Route route = context.MapRoute(null, "the_url");

            // Act
            string areaName = AreaHelpers.GetAreaName(route);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameFromIAreaAssociatedItem()
        {
            // Arrange
            CustomRouteWithArea route = new CustomRouteWithArea();

            // Act
            string areaName = AreaHelpers.GetAreaName(route);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameFromRouteData()
        {
            // Arrange
            RouteData routeData = new RouteData();
            routeData.DataTokens["area"] = "area_name";

            // Act
            string areaName = AreaHelpers.GetAreaName(routeData);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameFromRouteDataFallsBackToRoute()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("area_name", routes);
            Route route = context.MapRoute(null, "the_url");
            RouteData routeData = new RouteData(route, new MvcRouteHandler());

            // Act
            string areaName = AreaHelpers.GetAreaName(routeData);

            // Assert
            Assert.Equal("area_name", areaName);
        }

        [Fact]
        public void GetAreaNameReturnsNullIfRouteNotAreaAware()
        {
            // Arrange
            Route route = new Route("the_url", new MvcRouteHandler());

            // Act
            string areaName = AreaHelpers.GetAreaName(route);

            // Assert
            Assert.Null(areaName);
        }

        private class CustomRouteWithArea : RouteBase, IRouteWithArea
        {
            public string Area
            {
                get { return "area_name"; }
            }

            public override RouteData GetRouteData(HttpContextBase httpContext)
            {
                throw new NotImplementedException();
            }

            public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AreaRegistrationContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class AreaRegistrationContextTest
    {
        [Fact]
        public void ConstructorSetsProperties()
        {
            // Arrange
            string areaName = "the_area";
            RouteCollection routes = new RouteCollection();

            // Act
            AreaRegistrationContext context = new AreaRegistrationContext(areaName, routes);

            // Assert
            Assert.Equal(areaName, context.AreaName);
            Assert.Same(routes, context.Routes);
        }

        [Fact]
        public void ConstructorThrowsIfAreaNameIsEmpty()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new AreaRegistrationContext("", new RouteCollection()); }, "areaName");
        }

        [Fact]
        public void ConstructorThrowsIfAreaNameIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new AreaRegistrationContext(null, new RouteCollection()); }, "areaName");
        }

        [Fact]
        public void ConstructorThrowsIfRoutesIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new AreaRegistrationContext("the_area", null); }, "routes");
        }

        [Fact]
        public void MapRouteWithEmptyStringNamespaces()
        {
            // Arrange
            string[] implicitNamespaces = new string[] { "implicit_1", "implicit_2" };
            string[] explicitNamespaces = new string[0];

            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("the_area", routes);
            ReplaceCollectionContents(context.Namespaces, implicitNamespaces);

            // Act
            Route route = context.MapRoute("the_name", "the_url", explicitNamespaces);

            // Assert
            Assert.Equal(route, routes["the_name"]);
            Assert.Equal("the_area", route.DataTokens["area"]);
            Assert.Equal((object)true, route.DataTokens["UseNamespaceFallback"]);
            Assert.Null(route.DataTokens["namespaces"]);
        }

        [Fact]
        public void MapRouteWithExplicitNamespaces()
        {
            // Arrange
            string[] implicitNamespaces = new string[] { "implicit_1", "implicit_2" };
            string[] explicitNamespaces = new string[] { "explicit_1", "explicit_2" };

            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("the_area", routes);
            ReplaceCollectionContents(context.Namespaces, implicitNamespaces);

            // Act
            Route route = context.MapRoute("the_name", "the_url", explicitNamespaces);

            // Assert
            Assert.Equal(route, routes["the_name"]);
            Assert.Equal("the_area", route.DataTokens["area"]);
            Assert.Equal((object)false, route.DataTokens["UseNamespaceFallback"]);
            Assert.Equal(explicitNamespaces, (string[])route.DataTokens["namespaces"]);
        }

        [Fact]
        public void MapRouteWithImplicitNamespaces()
        {
            // Arrange
            string[] implicitNamespaces = new string[] { "implicit_1", "implicit_2" };
            string[] explicitNamespaces = new string[] { "explicit_1", "explicit_2" };

            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("the_area", routes);
            ReplaceCollectionContents(context.Namespaces, implicitNamespaces);

            // Act
            Route route = context.MapRoute("the_name", "the_url");

            // Assert
            Assert.Equal(route, routes["the_name"]);
            Assert.Equal("the_area", route.DataTokens["area"]);
            Assert.Equal((object)false, route.DataTokens["UseNamespaceFallback"]);
            Assert.Equal(implicitNamespaces, (string[])route.DataTokens["namespaces"]);
        }

        [Fact]
        public void MapRouteWithoutNamespaces()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            AreaRegistrationContext context = new AreaRegistrationContext("the_area", routes);

            // Act
            Route route = context.MapRoute("the_name", "the_url");

            // Assert
            Assert.Equal(route, routes["the_name"]);
            Assert.Equal("the_area", route.DataTokens["area"]);
            Assert.Null(route.DataTokens["namespaces"]);
            Assert.Equal((object)true, route.DataTokens["UseNamespaceFallback"]);
        }

        private static void ReplaceCollectionContents(ICollection<string> collectionToReplace, IEnumerable<string> newContents)
        {
            collectionToReplace.Clear();
            foreach (string item in newContents)
            {
                collectionToReplace.Add(item);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AreaRegistrationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class AreaRegistrationTest
    {
        [Fact]
        public void CreateContextAndRegister()
        {
            // Arrange
            string[] expectedNamespaces = new string[] { "System.Web.Mvc.Test.*" };

            RouteCollection routes = new RouteCollection();
            MyAreaRegistration registration = new MyAreaRegistration();

            // Act
            registration.CreateContextAndRegister(routes, "some state");

            // Assert
            Assert.Equal(expectedNamespaces, registration.Namespaces);
            Assert.Equal("some state", registration.State);
        }

        [Fact]
        public void RegisterAllAreas()
        {
            // Arrange
            string[] expectedLoadedAreas = new string[] { "AreaRegistrationTest_AreaRegistration" };
            AnnotatedRouteCollection routes = new AnnotatedRouteCollection();
            MockBuildManager buildManager = new MockBuildManager(new Assembly[] { typeof(AreaRegistrationTest).Assembly });

            // Act
            AreaRegistration.RegisterAllAreas(routes, buildManager, null);

            // Assert
            Assert.Equal(expectedLoadedAreas, routes._areasLoaded.ToArray());
        }

        private class MyAreaRegistration : AreaRegistration
        {
            public string[] Namespaces;
            public object State;

            public override string AreaName
            {
                get { return "my_area"; }
            }

            public override void RegisterArea(AreaRegistrationContext context)
            {
                Namespaces = context.Namespaces.ToArray();
                State = context.State;
            }
        }
    }

    public class AnnotatedRouteCollection : RouteCollection
    {
        public List<string> _areasLoaded = new List<string>();
    }

    public abstract class AreaRegistrationTest_AbstractAreaRegistration : AreaRegistration
    {
        public override string AreaName
        {
            get { return "the_area"; }
        }

        public override void RegisterArea(AreaRegistrationContext context)
        {
            ((AnnotatedRouteCollection)context.Routes)._areasLoaded.Add("AreaRegistrationTest_AbstractAreaRegistration");
        }
    }

    public class AreaRegistrationTest_AreaRegistration : AreaRegistrationTest_AbstractAreaRegistration
    {
        public override void RegisterArea(AreaRegistrationContext context)
        {
            ((AnnotatedRouteCollection)context.Routes)._areasLoaded.Add("AreaRegistrationTest_AreaRegistration");
        }
    }

    public class AreaRegistrationTest_NoConstructorAreaRegistration : AreaRegistrationTest_AreaRegistration
    {
        private AreaRegistrationTest_NoConstructorAreaRegistration()
        {
        }

        public override void RegisterArea(AreaRegistrationContext context)
        {
            ((AnnotatedRouteCollection)context.Routes)._areasLoaded.Add("AreaRegistrationTest_NoConstructorAreaRegistration");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AssociatedMetadataProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class AssociatedMetadataProviderTest
    {
        // FilterAttributes

        [Fact]
        public void ReadOnlyAttributeIsFilteredOffWhenContainerTypeIsViewPage()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act
            provider.GetMetadataForProperty(() => null, typeof(ViewPage<PropertyModel>), "Model");

            // Assert
            CreateMetadataParams parms = provider.CreateMetadataLog.Single();
            Assert.DoesNotContain(parms.Attributes, a => a is ReadOnlyAttribute);
        }

        [Fact]
        public void ReadOnlyAttributeIsFilteredOffWhenContainerTypeIsViewUserControl()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act
            provider.GetMetadataForProperty(() => null, typeof(ViewUserControl<PropertyModel>), "Model");

            // Assert
            CreateMetadataParams parms = provider.CreateMetadataLog.Single();
            Assert.DoesNotContain(parms.Attributes, a => a is ReadOnlyAttribute);
        }

        [Fact]
        public void ReadOnlyAttributeIsPreservedForReadOnlyModelProperties()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act
            provider.GetMetadataForProperty(() => null, typeof(ModelWithReadOnlyProperty), "ReadOnlyProperty");

            // Assert
            CreateMetadataParams parms = provider.CreateMetadataLog.Single();
            Assert.Contains(parms.Attributes, a => a is ReadOnlyAttribute);
        }

        // GetMetadataForProperties

        [Fact]
        public void GetMetadataForPropertiesNullContainerTypeThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.GetMetadataForProperties(new Object(), null),
                "containerType");
        }

        [Fact]
        public void GetMetadataForPropertiesCreatesMetadataForAllPropertiesOnModelWithPropertyValues()
        {
            // Arrange
            PropertyModel model = new PropertyModel { LocalAttributes = 42, MetadataAttributes = "hello", MixedAttributes = 21.12 };
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act
            provider.GetMetadataForProperties(model, typeof(PropertyModel)).ToList(); // Call ToList() to force the lazy evaluation to evaluate

            // Assert
            CreateMetadataParams local =
                provider.CreateMetadataLog.Single(m => m.ContainerType == typeof(PropertyModel) &&
                                                       m.PropertyName == "LocalAttributes");
            Assert.Equal(typeof(int), local.ModelType);
            Assert.Equal(42, local.Model);
            Assert.Contains(local.Attributes, a => a is RequiredAttribute);

            CreateMetadataParams metadata =
                provider.CreateMetadataLog.Single(m => m.ContainerType == typeof(PropertyModel) &&
                                                       m.PropertyName == "MetadataAttributes");
            Assert.Equal(typeof(string), metadata.ModelType);
            Assert.Equal("hello", metadata.Model);
            Assert.Contains(metadata.Attributes, a => a is RangeAttribute);

            CreateMetadataParams mixed =
                provider.CreateMetadataLog.Single(m => m.ContainerType == typeof(PropertyModel) &&
                                                       m.PropertyName == "MixedAttributes");
            Assert.Equal(typeof(double), mixed.ModelType);
            Assert.Equal(21.12, mixed.Model);
            Assert.Contains(mixed.Attributes, a => a is RequiredAttribute);
            Assert.Contains(mixed.Attributes, a => a is RangeAttribute);
        }

        [Fact]
        public void GetMetadataForPropertiesContainerTest()
        {
            // Arrange
            PropertyModel model = new PropertyModel { LocalAttributes = 42, MetadataAttributes = "hello", MixedAttributes = 21.12 };
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();

            // Act
            List<ModelMetadata> metadata = provider.GetMetadataForProperties(model, typeof(PropertyModel)).ToList();

            // Assert
            Assert.Equal(3, metadata.Count());
            Assert.Same(model, metadata[0].Container);
            Assert.Same(model, metadata[1].Container);
            Assert.Same(model, metadata[2].Container);
        }

        [Fact]
        public void GetMetadataForPropertyWithNullContainerReturnsMetadataWithNullValuesForProperties()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act
            provider.GetMetadataForProperties(null, typeof(PropertyModel)).ToList(); // Call ToList() to force the lazy evaluation to evaluate

            // Assert
            Assert.True(provider.CreateMetadataLog.Any());
            foreach (var parms in provider.CreateMetadataLog)
            {
                Assert.Null(parms.Model);
            }
        }

        // GetMetadataForProperty

        [Fact]
        public void GetMetadataForPropertyNullContainerTypeThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.GetMetadataForProperty(null /* model */, null /* containerType */, "propertyName"),
                "containerType");
        }

        [Fact]
        public void GetMetadataForPropertyNullOrEmptyPropertyNameThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => provider.GetMetadataForProperty(null /* model */, typeof(object), null /* propertyName */),
                "propertyName");
            Assert.ThrowsArgumentNullOrEmpty(
                () => provider.GetMetadataForProperty(null, typeof(object), String.Empty),
                "propertyName");
        }

        [Fact]
        public void GetMetadataForPropertyInvalidPropertyNameThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => provider.GetMetadataForProperty(null, typeof(object), "BadPropertyName"),
                "The property System.Object.BadPropertyName could not be found.");
        }

        [Fact]
        public void GetMetadataForPropertyWithLocalAttributes()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, typeof(PropertyModel), null, typeof(int), "LocalAttributes");
            provider.CreateMetadataReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(PropertyModel), "LocalAttributes");

            // Assert
            Assert.Same(metadata, result);
            Assert.Contains(provider.CreateMetadataLog.Single().Attributes, a => a is RequiredAttribute);
        }

        [Fact]
        public void GetMetadataForPropertyWithMetadataAttributes()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, typeof(PropertyModel), null, typeof(string), "MetadataAttributes");
            provider.CreateMetadataReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(PropertyModel), "MetadataAttributes");

            // Assert
            Assert.Same(metadata, result);
            CreateMetadataParams parms = provider.CreateMetadataLog.Single(p => p.PropertyName == "MetadataAttributes");
            Assert.Contains(parms.Attributes, a => a is RangeAttribute);
        }

        [Fact]
        public void GetMetadataForPropertyWithMixedAttributes()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, typeof(PropertyModel), null, typeof(double), "MixedAttributes");
            provider.CreateMetadataReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(PropertyModel), "MixedAttributes");

            // Assert
            Assert.Same(metadata, result);
            CreateMetadataParams parms = provider.CreateMetadataLog.Single(p => p.PropertyName == "MixedAttributes");
            Assert.Contains(parms.Attributes, a => a is RequiredAttribute);
            Assert.Contains(parms.Attributes, a => a is RangeAttribute);
        }

        // GetMetadataForType

        [Fact]
        public void GetMetadataForTypeNullModelTypeThrows()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.GetMetadataForType(() => new Object(), null),
                "modelType");
        }

        [Fact]
        public void GetMetadataForTypeIncludesAttributesOnType()
        {
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, null, typeof(TypeModel), null);
            provider.CreateMetadataReturnValue = metadata;

            // Act
            ModelMetadata result = provider.GetMetadataForType(null, typeof(TypeModel));

            // Assert
            Assert.Same(metadata, result);
            CreateMetadataParams parms = provider.CreateMetadataLog.Single(p => p.ModelType == typeof(TypeModel));
            Assert.Contains(parms.Attributes, a => a is ReadOnlyAttribute);
        }

        [AdditionalMetadata("ClassName", "ClassValue")]
        class ClassWithAdditionalMetadata
        {
            [AdditionalMetadata("PropertyName", "PropertyValue")]
            public int MyProperty { get; set; }
        }

        [Fact]
        public void MetadataAwareAttributeCanModifyTypeMetadata()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            provider.CreateMetadataReturnValue = new ModelMetadata(provider, null, null, typeof(ClassWithAdditionalMetadata), null);

            // Act
            ModelMetadata metadata = provider.GetMetadataForType(null, typeof(ClassWithAdditionalMetadata));

            // Assert
            var kvp = metadata.AdditionalValues.Single();
            Assert.Equal("ClassName", kvp.Key);
            Assert.Equal("ClassValue", kvp.Value);
        }

        [Fact]
        public void MetadataAwareAttributeCanModifyPropertyMetadata()
        {
            // Arrange
            TestableAssociatedMetadataProvider provider = new TestableAssociatedMetadataProvider();
            provider.CreateMetadataReturnValue = new ModelMetadata(provider, typeof(ClassWithAdditionalMetadata), null, typeof(int), "MyProperty");

            // Act
            ModelMetadata metadata = provider.GetMetadataForProperty(null, typeof(ClassWithAdditionalMetadata), "MyProperty");

            // Assert
            var kvp = metadata.AdditionalValues.Single();
            Assert.Equal("PropertyName", kvp.Key);
            Assert.Equal("PropertyValue", kvp.Value);
        }

        // Helpers

        [MetadataType(typeof(Metadata))]
        private class PropertyModel
        {
            [Required]
            public int LocalAttributes { get; set; }

            public string MetadataAttributes { get; set; }

            [Required]
            public double MixedAttributes { get; set; }

            private class Metadata
            {
                [Range(10, 100)]
                public object MetadataAttributes { get; set; }

                [Range(10, 100)]
                public object MixedAttributes { get; set; }
            }
        }

        private class ModelWithReadOnlyProperty
        {
            public int ReadOnlyProperty { get; private set; }
        }

        [ReadOnly(true)]
        private class TypeModel
        {
        }

        class TestableAssociatedMetadataProvider : AssociatedMetadataProvider
        {
            public List<CreateMetadataParams> CreateMetadataLog = new List<CreateMetadataParams>();
            public ModelMetadata CreateMetadataReturnValue = null;

            protected override ModelMetadata CreateMetadata(IEnumerable<Attribute> attributes, Type containerType,
                                                            Func<object> modelAccessor, Type modelType,
                                                            string propertyName)
            {
                CreateMetadataLog.Add(new CreateMetadataParams
                {
                    Attributes = attributes,
                    ContainerType = containerType,
                    Model = modelAccessor == null ? null : modelAccessor(),
                    ModelType = modelType,
                    PropertyName = propertyName
                });

                return CreateMetadataReturnValue;
            }
        }

        class CreateMetadataParams
        {
            public IEnumerable<Attribute> Attributes { get; set; }
            public Type ContainerType { get; set; }
            public object Model { get; set; }
            public Type ModelType { get; set; }
            public string PropertyName { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AssociatedValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class AssociatedValidatorProviderTest
    {
        [Fact]
        public void GetValidatorsGuardClauses()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(object));
            Mock<AssociatedValidatorProvider> provider = new Mock<AssociatedValidatorProvider> { CallBase = true };

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => provider.Object.GetValidators(null, new ControllerContext()),
                "metadata");
            Assert.ThrowsArgumentNull(
                () => provider.Object.GetValidators(metadata, null),
                "context");
        }

        [Fact]
        public void GetValidatorsForPropertyWithLocalAttributes()
        {
            // Arrange
            IEnumerable<Attribute> callbackAttributes = null;
            ControllerContext context = new ControllerContext();
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(PropertyModel), "LocalAttributes");
            Mock<TestableAssociatedValidatorProvider> provider = new Mock<TestableAssociatedValidatorProvider> { CallBase = true };
            provider.Setup(p => p.AbstractGetValidators(metadata, context, It.IsAny<IEnumerable<Attribute>>()))
                .Callback<ModelMetadata, ControllerContext, IEnumerable<Attribute>>((m, c, attributes) => callbackAttributes = attributes)
                .Returns(() => null)
                .Verifiable();

            // Act
            provider.Object.GetValidators(metadata, context);

            // Assert
            provider.Verify();
            Assert.Contains(callbackAttributes, a => a is RequiredAttribute);
        }

        [Fact]
        public void GetValidatorsForPropertyWithMetadataAttributes()
        {
            // Arrange
            IEnumerable<Attribute> callbackAttributes = null;
            ControllerContext context = new ControllerContext();
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(PropertyModel), "MetadataAttributes");
            Mock<TestableAssociatedValidatorProvider> provider = new Mock<TestableAssociatedValidatorProvider> { CallBase = true };
            provider.Setup(p => p.AbstractGetValidators(metadata, context, It.IsAny<IEnumerable<Attribute>>()))
                .Callback<ModelMetadata, ControllerContext, IEnumerable<Attribute>>((m, c, attributes) => callbackAttributes = attributes)
                .Returns(() => null)
                .Verifiable();

            // Act
            provider.Object.GetValidators(metadata, context);

            // Assert
            provider.Verify();
            Assert.Contains(callbackAttributes, a => a is RangeAttribute);
        }

        [Fact]
        public void GetValidatorsForPropertyWithMixedAttributes()
        {
            // Arrange
            IEnumerable<Attribute> callbackAttributes = null;
            ControllerContext context = new ControllerContext();
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(PropertyModel), "MixedAttributes");
            Mock<TestableAssociatedValidatorProvider> provider = new Mock<TestableAssociatedValidatorProvider> { CallBase = true };
            provider.Setup(p => p.AbstractGetValidators(metadata, context, It.IsAny<IEnumerable<Attribute>>()))
                .Callback<ModelMetadata, ControllerContext, IEnumerable<Attribute>>((m, c, attributes) => callbackAttributes = attributes)
                .Returns(() => null)
                .Verifiable();

            // Act
            provider.Object.GetValidators(metadata, context);

            // Assert
            provider.Verify();
            Assert.Contains(callbackAttributes, a => a is RangeAttribute);
            Assert.Contains(callbackAttributes, a => a is RequiredAttribute);
        }

        [MetadataType(typeof(Metadata))]
        private class PropertyModel
        {
            [Required]
            public int LocalAttributes { get; set; }

            public string MetadataAttributes { get; set; }

            [Required]
            public double MixedAttributes { get; set; }

            private class Metadata
            {
                [Range(10, 100)]
                public object MetadataAttributes { get; set; }

                [Range(10, 100)]
                public object MixedAttributes { get; set; }
            }
        }

        public abstract class TestableAssociatedValidatorProvider : AssociatedValidatorProvider
        {
            protected override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes)
            {
                return AbstractGetValidators(metadata, context, attributes);
            }

            // Hoist access
            public abstract IEnumerable<ModelValidator> AbstractGetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable<Attribute> attributes);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AsyncControllerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc.Async;
using System.Web.Mvc.Async.Test;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AsyncControllerTest
    {
        [Fact]
        public void ActionInvokerProperty()
        {
            // Arrange
            EmptyController controller = new EmptyController();

            // Act
            IActionInvoker invoker = controller.ActionInvoker;

            // Assert
            Assert.IsType<AsyncControllerActionInvoker>(invoker);
        }

        [Fact]
        public void AsyncManagerProperty()
        {
            // Arrange
            EmptyController controller = new EmptyController();

            // Act
            AsyncManager asyncManager = controller.AsyncManager;

            // Assert
            Assert.NotNull(asyncManager);
        }

        [Fact]
        public void Execute_ThrowsIfCalledMoreThanOnce()
        {
            // Arrange
            IAsyncController controller = new EmptyController();
            RequestContext requestContext = GetRequestContext("SomeAction");

            // Act & assert
            controller.BeginExecute(requestContext, null, null);
            Assert.Throws<InvalidOperationException>(
                delegate { controller.BeginExecute(requestContext, null, null); },
                @"A single instance of controller 'System.Web.Mvc.Test.AsyncControllerTest+EmptyController' cannot be used to handle multiple requests. If a custom controller factory is in use, make sure that it creates a new instance of the controller for each request.");
        }

        [Fact]
        public void Execute_ThrowsIfRequestContextIsNull()
        {
            // Arrange
            IAsyncController controller = new EmptyController();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { controller.BeginExecute(null, null, null); }, "requestContext");
        }

        [Fact]
        public void ExecuteCore_Asynchronous_ActionFound()
        {
            // Arrange
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                Mock<IAsyncActionInvoker> mockActionInvoker = new Mock<IAsyncActionInvoker>();
                mockActionInvoker.Setup(o => o.BeginInvokeAction(It.IsAny<ControllerContext>(), "SomeAction", It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult);
                mockActionInvoker.Setup(o => o.EndInvokeAction(innerAsyncResult)).Returns(true);

                RequestContext requestContext = GetRequestContext("SomeAction");
                EmptyController controller = new EmptyController()
                {
                    ActionInvoker = mockActionInvoker.Object
                };

                // Act & assert
                IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null);
                Assert.False(controller.TempDataSaved);

                ((IAsyncController)controller).EndExecute(outerAsyncResult);
                Assert.True(controller.TempDataSaved);
                Assert.False(controller.HandleUnknownActionCalled);
            }
        }

        [Fact]
        public void ExecuteCore_Asynchronous_ActionNotFound()
        {
            // Arrange
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                Mock<IAsyncActionInvoker> mockActionInvoker = new Mock<IAsyncActionInvoker>();
                mockActionInvoker.Setup(o => o.BeginInvokeAction(It.IsAny<ControllerContext>(), "SomeAction", It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult);
                mockActionInvoker.Setup(o => o.EndInvokeAction(innerAsyncResult)).Returns(false);

                RequestContext requestContext = GetRequestContext("SomeAction");
                EmptyController controller = new EmptyController()
                {
                    ActionInvoker = mockActionInvoker.Object
                };

                // Act & assert
                IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null);
                Assert.False(controller.TempDataSaved);

                ((IAsyncController)controller).EndExecute(outerAsyncResult);
                Assert.True(controller.TempDataSaved);
                Assert.True(controller.HandleUnknownActionCalled);
            }
        }

        [Fact]
        public void ExecuteCore_Synchronous_ActionFound()
        {
            // Arrange
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                Mock<IActionInvoker> mockActionInvoker = new Mock<IActionInvoker>();
                mockActionInvoker.Setup(o => o.InvokeAction(It.IsAny<ControllerContext>(), "SomeAction")).Returns(true);

                RequestContext requestContext = GetRequestContext("SomeAction");
                EmptyController controller = new EmptyController()
                {
                    ActionInvoker = mockActionInvoker.Object
                };

                // Act & assert
                IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null);
                Assert.False(controller.TempDataSaved);

                ((IAsyncController)controller).EndExecute(outerAsyncResult);
                Assert.True(controller.TempDataSaved);
                Assert.False(controller.HandleUnknownActionCalled);
            }
        }

        [Fact]
        public void ExecuteCore_Synchronous_ActionNotFound()
        {
            // Arrange
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                Mock<IActionInvoker> mockActionInvoker = new Mock<IActionInvoker>();
                mockActionInvoker.Setup(o => o.InvokeAction(It.IsAny<ControllerContext>(), "SomeAction")).Returns(false);

                RequestContext requestContext = GetRequestContext("SomeAction");
                EmptyController controller = new EmptyController()
                {
                    ActionInvoker = mockActionInvoker.Object
                };

                // Act & assert
                IAsyncResult outerAsyncResult = ((IAsyncController)controller).BeginExecute(requestContext, null, null);
                Assert.False(controller.TempDataSaved);

                ((IAsyncController)controller).EndExecute(outerAsyncResult);
                Assert.True(controller.TempDataSaved);
                Assert.True(controller.HandleUnknownActionCalled);
            }
        }

        [Fact]
        public void ExecuteCore_SavesTempDataOnException()
        {
            // Arrange
            Mock<IAsyncActionInvoker> mockActionInvoker = new Mock<IAsyncActionInvoker>();
            mockActionInvoker
                .Setup(o => o.BeginInvokeAction(It.IsAny<ControllerContext>(), "SomeAction", It.IsAny<AsyncCallback>(), It.IsAny<object>()))
                .Throws(new Exception("Some exception text."));

            RequestContext requestContext = GetRequestContext("SomeAction");
            EmptyController controller = new EmptyController()
            {
                ActionInvoker = mockActionInvoker.Object
            };

            // Act & assert
            Assert.Throws<Exception>(
                delegate { ((IAsyncController)controller).BeginExecute(requestContext, null, null); },
                @"Some exception text.");
            Assert.True(controller.TempDataSaved);
        }

        [Fact]
        public void CreateActionInvokerCallsIntoResolverInstance()
        {
            // Controller uses an IDependencyResolver to create an IActionInvoker.
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            Mock<IAsyncActionInvoker> actionInvokerMock = new Mock<IAsyncActionInvoker>();
            resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvoker))).Returns(actionInvokerMock.Object);
            controller.Resolver = resolverMock.Object;

            var ai = controller.CreateActionInvoker();

            resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvoker)), Times.Once());
            Assert.Same(actionInvokerMock.Object, ai);
        }

        [Fact]
        public void CreateActionInvokerCallsIntoResolverInstanceAndCreatesANewOneIfNecessary()
        {
            // If IDependencyResolver is set, but empty, falls back and still creates.
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvoker))).Returns(null);
            resolverMock.Setup(r => r.GetService(typeof(IActionInvoker))).Returns(null);
            controller.Resolver = resolverMock.Object;

            var ai = controller.CreateActionInvoker();

            resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvoker)), Times.Once());
            resolverMock.Verify(r => r.GetService(typeof(IActionInvoker)), Times.Once());
            Assert.NotNull(ai);
        }


        private static RequestContext GetRequestContext(string actionName)
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = actionName;

            return new RequestContext(mockHttpContext.Object, routeData);
        }

        private class EmptyController : AsyncController
        {
            public bool TempDataSaved;
            public bool HandleUnknownActionCalled;

            protected override ITempDataProvider CreateTempDataProvider()
            {
                return new DummyTempDataProvider();
            }

            protected override void HandleUnknownAction(string actionName)
            {
                HandleUnknownActionCalled = true;
            }

            // Test can expose protected method as public.
            public new IActionInvoker CreateActionInvoker()
            {
                return base.CreateActionInvoker();
            }


            private class DummyTempDataProvider : ITempDataProvider
            {
                public IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
                {
                    return new TempDataDictionary();
                }

                public void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
                {
                    ((EmptyController)controllerContext.Controller).TempDataSaved = true;
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AsyncTimeoutAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class AsyncTimeoutAttributeTest
    {
        [Fact]
        public void ConstructorThrowsIfDurationIsOutOfRange()
        {
            // Act & assert
            Assert.ThrowsArgumentOutOfRange(() => new AsyncTimeoutAttribute(-1000), "duration",
                @"The timeout value must be non-negative or Timeout.Infinite.");
        }

        [Fact]
        public void DurationProperty()
        {
            // Act
            AsyncTimeoutAttribute attr = new AsyncTimeoutAttribute(45);

            // Assert
            Assert.Equal(45, attr.Duration);
        }

        [Fact]
        public void OnActionExecutingSetsTimeoutPropertyOnController()
        {
            // Arrange
            AsyncTimeoutAttribute attr = new AsyncTimeoutAttribute(45);

            MyAsyncController controller = new MyAsyncController();
            controller.AsyncManager.Timeout = 0;

            ActionExecutingContext filterContext = new ActionExecutingContext()
            {
                Controller = controller
            };

            // Act
            attr.OnActionExecuting(filterContext);

            // Assert
            Assert.Equal(45, controller.AsyncManager.Timeout);
        }

        [Fact]
        public void OnActionExecutingThrowsIfControllerIsNotAsyncManagerContainer()
        {
            // Arrange
            AsyncTimeoutAttribute attr = new AsyncTimeoutAttribute(45);

            ActionExecutingContext filterContext = new ActionExecutingContext()
            {
                Controller = new MyController()
            };

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { attr.OnActionExecuting(filterContext); },
                @"The controller of type 'System.Web.Mvc.Test.AsyncTimeoutAttributeTest+MyController' must subclass AsyncController or implement the IAsyncManagerContainer interface.");
        }

        [Fact]
        public void OnActionExecutingThrowsIfFilterContextIsNull()
        {
            // Arrange
            AsyncTimeoutAttribute attr = new AsyncTimeoutAttribute(45);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnActionExecuting(null); }, "filterContext");
        }

        private class MyController : ControllerBase
        {
            protected override void ExecuteCore()
            {
                throw new NotImplementedException();
            }
        }

        private class MyAsyncController : AsyncController
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AuthorizationContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AuthorizationContextTest
    {
        [Fact]
        public void ConstructorThrowsIfActionDescriptorIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionDescriptor actionDescriptor = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new AuthorizationContext(controllerContext, actionDescriptor); }, "actionDescriptor");
        }

        [Fact]
        public void PropertiesAreSetByConstructor()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionDescriptor actionDescriptor = new Mock<ActionDescriptor>().Object;

            // Act
            AuthorizationContext authorizationContext = new AuthorizationContext(controllerContext, actionDescriptor);

            // Assert
            Assert.Equal(actionDescriptor, authorizationContext.ActionDescriptor);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/AuthorizeAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Reflection;
using System.Security.Principal;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class AuthorizeAttributeTest
    {
        [Fact]
        public void AuthorizeAttributeReturnsUniqueTypeIDs()
        {
            // Arrange
            AuthorizeAttribute attr1 = new AuthorizeAttribute();
            AuthorizeAttribute attr2 = new AuthorizeAttribute();

            // Assert
            Assert.NotEqual(attr1.TypeId, attr2.TypeId);
        }

        [Authorize(Roles = "foo")]
        [Authorize(Roles = "bar")]
        private class ClassWithMultipleAuthorizeAttributes
        {
        }

        [Fact]
        public void CanRetrieveMultipleAuthorizeAttributesFromOneClass()
        {
            // Arrange
            ClassWithMultipleAuthorizeAttributes @class = new ClassWithMultipleAuthorizeAttributes();

            // Act
            IEnumerable<AuthorizeAttribute> attributes = TypeDescriptor.GetAttributes(@class).OfType<AuthorizeAttribute>();

            // Assert
            Assert.Equal(2, attributes.Count());
            Assert.Contains(attributes, a => a.Roles == "foo");
            Assert.Contains(attributes, a => a.Roles == "bar");
        }

        [Fact]
        public void AuthorizeCoreReturnsFalseIfNameDoesNotMatch()
        {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper() { Users = "SomeName" };

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.User.Identity.IsAuthenticated).Returns(true);
            mockHttpContext.Setup(c => c.User.Identity.Name).Returns("SomeOtherName");

            // Act
            bool retVal = helper.PublicAuthorizeCore(mockHttpContext.Object);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void AuthorizeCoreReturnsFalseIfRoleDoesNotMatch()
        {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper() { Roles = "SomeRole" };

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.User.Identity.IsAuthenticated).Returns(true);
            mockHttpContext.Setup(c => c.User.IsInRole("SomeRole")).Returns(false).Verifiable();

            // Act
            bool retVal = helper.PublicAuthorizeCore(mockHttpContext.Object);

            // Assert
            Assert.False(retVal);
            mockHttpContext.Verify();
        }

        [Fact]
        public void AuthorizeCoreReturnsFalseIfUserIsUnauthenticated()
        {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper();

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.User.Identity.IsAuthenticated).Returns(false);

            // Act
            bool retVal = helper.PublicAuthorizeCore(mockHttpContext.Object);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void AuthorizeCoreReturnsTrueIfUserIsAuthenticatedAndNamesOrRolesSpecified()
        {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper() { Users = "SomeUser, SomeOtherUser", Roles = "SomeRole, SomeOtherRole" };

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.User.Identity.IsAuthenticated).Returns(true);
            mockHttpContext.Setup(c => c.User.Identity.Name).Returns("SomeUser");
            mockHttpContext.Setup(c => c.User.IsInRole("SomeRole")).Returns(false).Verifiable();
            mockHttpContext.Setup(c => c.User.IsInRole("SomeOtherRole")).Returns(true).Verifiable();

            // Act
            bool retVal = helper.PublicAuthorizeCore(mockHttpContext.Object);

            // Assert
            Assert.True(retVal);
            mockHttpContext.Verify();
        }

        [Fact]
        public void AuthorizeCoreReturnsTrueIfUserIsAuthenticatedAndNoNamesOrRolesSpecified()
        {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper();

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.User.Identity.IsAuthenticated).Returns(true);

            // Act
            bool retVal = helper.PublicAuthorizeCore(mockHttpContext.Object);

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void AuthorizeCoreThrowsIfHttpContextIsNull()
        {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { helper.PublicAuthorizeCore((HttpContextBase)null); }, "httpContext");
        }

        [Fact]
        public void OnAuthorizationCallsHandleUnauthorizedRequestIfUserUnauthorized()
        {
            // Arrange
            CustomFailAuthorizeAttribute attr = new CustomFailAuthorizeAttribute();

            Mock<AuthorizationContext> mockAuthContext = new Mock<AuthorizationContext>();
            mockAuthContext.Setup(c => c.HttpContext.User.Identity.IsAuthenticated).Returns(false);
            mockAuthContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            mockAuthContext.Setup(c => c.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(AllowAnonymousAttribute), true)).Returns(false);
            AuthorizationContext authContext = mockAuthContext.Object;

            // Act
            attr.OnAuthorization(authContext);

            // Assert
            Assert.Equal(CustomFailAuthorizeAttribute.ExpectedResult, authContext.Result);
        }

        [Fact]
        public void OnAuthorizationFailedSetsHttpUnauthorizedResultIfUserUnauthorized()
        {
            // Arrange
            Mock<AuthorizeAttributeHelper> mockHelper = new Mock<AuthorizeAttributeHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicAuthorizeCore(It.IsAny<HttpContextBase>())).Returns(false);
            AuthorizeAttributeHelper helper = mockHelper.Object;

            AuthorizationContext filterContext = new Mock<AuthorizationContext>() { DefaultValue = DefaultValue.Mock }.Object;

            // Act
            helper.OnAuthorization(filterContext);

            // Assert
            Assert.IsType<HttpUnauthorizedResult>(filterContext.Result);
        }

        [Fact]
        public void OnAuthorizationHooksCacheValidationIfUserAuthorized()
        {
            // Arrange
            Mock<AuthorizeAttributeHelper> mockHelper = new Mock<AuthorizeAttributeHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicAuthorizeCore(It.IsAny<HttpContextBase>())).Returns(true);
            AuthorizeAttributeHelper helper = mockHelper.Object;

            MethodInfo callbackMethod = typeof(AuthorizeAttribute).GetMethod("CacheValidateHandler", BindingFlags.Instance | BindingFlags.NonPublic);
            Mock<AuthorizationContext> mockFilterContext = new Mock<AuthorizationContext>();
            mockFilterContext.Setup(c => c.HttpContext.Response.Cache.SetProxyMaxAge(new TimeSpan(0))).Verifiable();
            mockFilterContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            mockFilterContext
                .Setup(c => c.HttpContext.Response.Cache.AddValidationCallback(It.IsAny<HttpCacheValidateHandler>(), null /* data */))
                .Callback(
                    delegate(HttpCacheValidateHandler handler, object data)
                    {
                        Assert.Equal(helper, handler.Target);
                        Assert.Equal(callbackMethod, handler.Method);
                    })
                .Verifiable();
            mockFilterContext.Setup(c => c.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(AllowAnonymousAttribute), true)).Returns(false);
            AuthorizationContext filterContext = mockFilterContext.Object;

            // Act
            helper.OnAuthorization(filterContext);

            // Assert
            mockFilterContext.Verify();
        }

        [Fact]
        public void OnAuthorizationThrowsIfFilterContextIsNull()
        {
            // Arrange
            AuthorizeAttribute attr = new AuthorizeAttribute();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnAuthorization(null); }, "filterContext");
        }

        [Fact]
        public void OnAuthorizationReturnsWithNoResultIfAllowAnonymousAttributeIsDefinedOnAction()
        {
            // Arrange
            Mock<AuthorizeAttributeHelper> mockHelper = new Mock<AuthorizeAttributeHelper>() { CallBase = true };
            AuthorizeAttributeHelper helper = mockHelper.Object;

            Mock<AuthorizationContext> mockFilterContext = new Mock<AuthorizationContext>();
            mockFilterContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            mockFilterContext.Setup(c => c.ActionDescriptor.IsDefined(typeof(AllowAnonymousAttribute), true)).Returns(true);

            // Act
            helper.OnAuthorization(mockFilterContext.Object);

            // Assert
            Assert.Null(mockFilterContext.Object.Result);
            mockHelper.Verify(h => h.PublicAuthorizeCore(It.IsAny<HttpContextBase>()), Times.Never());
        }

        [Fact]
        public void OnAuthorizationReturnsWithNoResultIfAllowAnonymousAttributeIsDefinedOnController()
        {
            // Arrange
            Mock<AuthorizeAttributeHelper> mockHelper = new Mock<AuthorizeAttributeHelper>() { CallBase = true };
            AuthorizeAttributeHelper helper = mockHelper.Object;

            Mock<AuthorizationContext> mockFilterContext = new Mock<AuthorizationContext>();
            mockFilterContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            mockFilterContext.Setup(c => c.ActionDescriptor.ControllerDescriptor.IsDefined(typeof(AllowAnonymousAttribute), true)).Returns(true);

            // Act
            helper.OnAuthorization(mockFilterContext.Object);

            // Assert
            Assert.Null(mockFilterContext.Object.Result);
            mockHelper.Verify(h => h.PublicAuthorizeCore(It.IsAny<HttpContextBase>()), Times.Never());
        }

        [Fact]
        public void OnCacheAuthorizationReturnsIgnoreRequestIfUserIsUnauthorized()
        {
            // Arrange
            Mock<AuthorizeAttributeHelper> mockHelper = new Mock<AuthorizeAttributeHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicAuthorizeCore(It.IsAny<HttpContextBase>())).Returns(false);
            AuthorizeAttributeHelper helper = mockHelper.Object;

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.User).Returns(new Mock<IPrincipal>().Object);

            // Act
            HttpValidationStatus validationStatus = helper.PublicOnCacheAuthorization(mockHttpContext.Object);

            // Assert
            Assert.Equal(HttpValidationStatus.IgnoreThisRequest, validationStatus);
        }

        [Fact]
        public void OnCacheAuthorizationReturnsValidIfUserIsAuthorized()
        {
            // Arrange
            Mock<AuthorizeAttributeHelper> mockHelper = new Mock<AuthorizeAttributeHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicAuthorizeCore(It.IsAny<HttpContextBase>())).Returns(true);
            AuthorizeAttributeHelper helper = mockHelper.Object;

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.User).Returns(new Mock<IPrincipal>().Object);

            // Act
            HttpValidationStatus validationStatus = helper.PublicOnCacheAuthorization(mockHttpContext.Object);

            // Assert
            Assert.Equal(HttpValidationStatus.Valid, validationStatus);
        }

        [Fact]
        public void OnCacheAuthorizationThrowsIfHttpContextIsNull()
        {
            // Arrange
            AuthorizeAttributeHelper helper = new AuthorizeAttributeHelper();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { helper.PublicOnCacheAuthorization(null); }, "httpContext");
        }

        [Fact]
        public void RolesProperty()
        {
            // Arrange
            AuthorizeAttribute attr = new AuthorizeAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "Roles", String.Empty);
        }

        [Fact]
        public void UsersProperty()
        {
            // Arrange
            AuthorizeAttribute attr = new AuthorizeAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "Users", String.Empty);
        }

        public class AuthorizeAttributeHelper : AuthorizeAttribute
        {
            public virtual bool PublicAuthorizeCore(HttpContextBase httpContext)
            {
                return base.AuthorizeCore(httpContext);
            }

            protected override bool AuthorizeCore(HttpContextBase httpContext)
            {
                return PublicAuthorizeCore(httpContext);
            }

            public virtual HttpValidationStatus PublicOnCacheAuthorization(HttpContextBase httpContext)
            {
                return base.OnCacheAuthorization(httpContext);
            }

            protected override HttpValidationStatus OnCacheAuthorization(HttpContextBase httpContext)
            {
                return PublicOnCacheAuthorization(httpContext);
            }
        }

        public class CustomFailAuthorizeAttribute : AuthorizeAttribute
        {
            public static readonly ActionResult ExpectedResult = new ContentResult();

            protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
            {
                filterContext.Result = ExpectedResult;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/BindAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class BindAttributeTest
    {
        [Fact]
        public void PrefixProperty()
        {
            // Arrange
            BindAttribute attr = new BindAttribute { Prefix = "somePrefix" };

            // Act & assert
            Assert.Equal("somePrefix", attr.Prefix);
        }

        [Fact]
        public void PrefixPropertyDefaultsToNull()
        {
            // Arrange
            BindAttribute attr = new BindAttribute();

            // Act & assert
            Assert.Null(attr.Prefix);
        }

        [Fact]
        public void IncludePropertyDefaultsToEmptyString()
        {
            // Arrange
            BindAttribute attr = new BindAttribute { Include = null };

            // Act & assert
            Assert.Equal(String.Empty, attr.Include);
        }

        [Fact]
        public void ExcludePropertyDefaultsToEmptyString()
        {
            // Arrange
            BindAttribute attr = new BindAttribute { Exclude = null };

            // Act & assert
            Assert.Equal(String.Empty, attr.Exclude);
        }

        [Fact]
        public void IsPropertyAllowedReturnsFalseForBlacklistedPropertiesIfBindPropertiesIsExclude()
        {
            // Setup
            BindAttribute attr = new BindAttribute { Exclude = "FOO,BAZ" };

            // Act & assert
            Assert.False(attr.IsPropertyAllowed("foo"));
            Assert.True(attr.IsPropertyAllowed("bar"));
            Assert.False(attr.IsPropertyAllowed("baz"));
        }

        [Fact]
        public void IsPropertyAllowedReturnsTrueAlwaysIfBindPropertiesIsAll()
        {
            // Setup
            BindAttribute attr = new BindAttribute();

            // Act & assert
            Assert.True(attr.IsPropertyAllowed("foo"));
            Assert.True(attr.IsPropertyAllowed("bar"));
            Assert.True(attr.IsPropertyAllowed("baz"));
        }

        [Fact]
        public void IsPropertyAllowedReturnsTrueForWhitelistedPropertiesIfBindPropertiesIsInclude()
        {
            // Setup
            BindAttribute attr = new BindAttribute { Include = "FOO,BAR" };

            // Act & assert
            Assert.True(attr.IsPropertyAllowed("foo"));
            Assert.True(attr.IsPropertyAllowed("bar"));
            Assert.False(attr.IsPropertyAllowed("baz"));
        }

        [Fact]
        public void IsPropertyAllowedReturnsFalseForBlacklistOverridingWhitelistedProperties()
        {
            // Setup
            BindAttribute attr = new BindAttribute { Include = "FOO,BAR", Exclude = "bar,QUx" };

            // Act & assert
            Assert.True(attr.IsPropertyAllowed("foo"));
            Assert.False(attr.IsPropertyAllowed("bar"));
            Assert.False(attr.IsPropertyAllowed("baz"));
            Assert.False(attr.IsPropertyAllowed("qux"));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/BuildManagerCompiledViewTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class CompiledTypeViewTest
    {
        [Fact]
        public void GuardClauses()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new TestableBuildManagerCompiledView(new ControllerContext(), String.Empty),
                "viewPath"
                );

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new TestableBuildManagerCompiledView(new ControllerContext(), null),
                "viewPath"
                );

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new TestableBuildManagerCompiledView(null, "view path"),
                "controllerContext"
                );
        }

        [Fact]
        public void RenderWithNullContextThrows()
        {
            // Arrange
            TestableBuildManagerCompiledView view = new TestableBuildManagerCompiledView(new ControllerContext(), "~/view");

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => view.Render(null, new Mock<TextWriter>().Object),
                "viewContext"
                );
        }

        [Fact]
        public void RenderWithNullViewInstanceThrows()
        {
            // Arrange
            ViewContext context = new Mock<ViewContext>().Object;
            MockBuildManager buildManager = new MockBuildManager("view path", compiledType: null);
            TestableBuildManagerCompiledView view = new TestableBuildManagerCompiledView(new ControllerContext(), "view path");
            view.BuildManager = buildManager;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => view.Render(context, new Mock<TextWriter>().Object),
                "The view found at 'view path' was not created."
                );
        }

        [Fact]
        public void ViewPathProperty()
        {
            // Act
            BuildManagerCompiledView view = new TestableBuildManagerCompiledView(new ControllerContext(), "view path");

            // Assert
            Assert.Equal("view path", view.ViewPath);
        }

        [Fact]
        public void ViewCreationConsultsSetActivator()
        {
            // Arrange
            object viewInstance = new object();
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
            ControllerContext controllerContext = new ControllerContext();
            activator.Setup(a => a.Create(controllerContext, typeof(object))).Returns(viewInstance).Verifiable();
            MockBuildManager buildManager = new MockBuildManager("view path", typeof(object));
            BuildManagerCompiledView view = new TestableBuildManagerCompiledView(controllerContext, "view path", activator.Object) { BuildManager = buildManager };

            // Act
            view.Render(new Mock<ViewContext>().Object, new Mock<TextWriter>().Object);

            // Assert
            activator.Verify();
        }

        [Fact]
        public void ViewCreationDelegatesToDependencyResolverWhenActivatorIsNull()
        {
            // Arrange
            var viewInstance = new object();
            var controllerContext = new ControllerContext();
            var buildManager = new MockBuildManager("view path", typeof(object));
            var dependencyResolver = new Mock<IDependencyResolver>(MockBehavior.Strict);
            dependencyResolver.Setup(dr => dr.GetService(typeof(object))).Returns(viewInstance).Verifiable();
            var view = new TestableBuildManagerCompiledView(controllerContext, "view path", dependencyResolver: dependencyResolver.Object) { BuildManager = buildManager };

            // Act
            view.Render(new Mock<ViewContext>().Object, new Mock<TextWriter>().Object);

            // Assert
            dependencyResolver.Verify();
        }

        [Fact]
        public void ViewCreationDelegatesToActivatorCreateInstanceWhenDependencyResolverReturnsNull()
        {
            // Arrange
            var controllerContext = new ControllerContext();
            var buildManager = new MockBuildManager("view path", typeof(NoParameterlessCtor));
            var dependencyResolver = new Mock<IDependencyResolver>();
            var view = new TestableBuildManagerCompiledView(controllerContext, "view path", dependencyResolver: dependencyResolver.Object) { BuildManager = buildManager };

            // Act & Assert, confirming type name and full stack are available in Exception
            // Depend on the fact that Activator.CreateInstance cannot create an object without a parameterless ctor
            MissingMethodException ex = Assert.Throws<MissingMethodException>(
                () => view.Render(new Mock<ViewContext>().Object, new Mock<TextWriter>().Object),
                "No parameterless constructor defined for this object. Object type 'System.Web.Mvc.Test.CompiledTypeViewTest+NoParameterlessCtor'.");
            Assert.Contains("System.Activator.CreateInstance(", ex.ToString());
        }

        private class NoParameterlessCtor
        {
            public NoParameterlessCtor(int x)
            {
            }
        }

        private sealed class TestableBuildManagerCompiledView : BuildManagerCompiledView
        {
            public TestableBuildManagerCompiledView(ControllerContext controllerContext, string viewPath, IViewPageActivator viewPageActivator = null, IDependencyResolver dependencyResolver = null)
                : base(controllerContext, viewPath, viewPageActivator, dependencyResolver)
            {
            }

            protected override void RenderView(ViewContext viewContext, TextWriter writer, object instance)
            {
                return;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/BuildManagerViewEngineTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Hosting;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class BuildManagerViewEngineTest
    {
        [Fact]
        public void BuildManagerProperty()
        {
            // Arrange
            var engine = new TestableBuildManagerViewEngine();
            var buildManagerMock = new MockBuildManager(expectedVirtualPath: null, compiledType: null);

            // Act
            engine.BuildManager = buildManagerMock;

            // Assert
            Assert.Same(engine.BuildManager, buildManagerMock);
        }

        [Fact]
        public void FileExistsReturnsTrueForExistingPath()
        {
            // Arrange
            string testPath = "/Path.txt";
            var engine = new TestableBuildManagerViewEngine(pathProvider: CreatePathProvider(testPath));

            // Act
            bool result = engine.FileExists(testPath);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void FileExistsDoesNotQueryBuildManagerIfAppIsNotPrecompiledNonUpdateable()
        {
            // Arrange
            string testPath = "/Path.txt";
            var engine = new TestableBuildManagerViewEngine(pathProvider: CreatePathProvider("some random path"));
            var buildManagerMock = new Mock<MockBuildManager>();
            engine.BuildManager = buildManagerMock.Object;

            // Act
            bool result = engine.FileExists(testPath);

            // Assert
            buildManagerMock.Verify(b => b.FileExists(It.IsAny<string>()), Times.Never());
            Assert.False(result);
        }

        [Fact]
        public void FileExistsQueriesBuildManagerForFilesThatPathProviderDoesNotFindWhenRunningInPrecompiledNonUpdateableApp()
        {
            // Arrange
            string testPath = "/Path.txt";
            var engine = new TestableBuildManagerViewEngine(pathProvider: CreatePathProvider("some random path"));
            engine.SetIsPrecompiledNonUpdateableSite(true);
            var buildManagerMock = new MockBuildManager(testPath, typeof(object));
            engine.BuildManager = buildManagerMock;

            // Act
            bool result = engine.FileExists(testPath);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void FileExistsReturnsFalseWhenBuildManagerFileExistsReturnsFalse()
        {
            // Arrange
            var engine = new TestableBuildManagerViewEngine(pathProvider: CreatePathProvider());
            var buildManagerMock = new MockBuildManager("some path", false);
            engine.BuildManager = buildManagerMock;

            // Act
            bool result = engine.FileExists("some path");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void FileExistsReturnsTrueForExistingPath_VPPRegistrationChanging()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Arrange
                AppDomainUtils.SetAppData();
                new HostingEnvironment();

                // Expect null beforeProvider since hosting environment hasn't been initialized
                VirtualPathProvider beforeProvider = HostingEnvironment.VirtualPathProvider;
                string testPath = "/Path.txt";
                VirtualPathProvider afterProvider = CreatePathProvider(testPath);
                Mock<VirtualPathProvider> mockProvider = Mock.Get(afterProvider);

                TestableBuildManagerViewEngine engine = new TestableBuildManagerViewEngine();

                // Act
                VirtualPathProvider beforeEngineProvider = engine.VirtualPathProvider;
                HostingEnvironment.RegisterVirtualPathProvider(afterProvider);

                bool result = engine.FileExists(testPath);
                VirtualPathProvider afterEngineProvider = engine.VirtualPathProvider;

                // Assert
                Assert.True(result);
                Assert.Equal(beforeProvider, beforeEngineProvider);
                Assert.Equal(afterProvider, afterEngineProvider);

                mockProvider.Verify();
                mockProvider.Verify(c => c.FileExists(It.IsAny<String>()), Times.Once());
            });
        }

        [Fact]
        public void FileExistsReturnsFalseForNonExistentPath()
        {
            // Arrange
            string matchingPath = "/Path.txt";
            string nonMatchingPath = "/PathOther.txt";
            var engine = new TestableBuildManagerViewEngine(pathProvider: CreatePathProvider(matchingPath))
            {
                BuildManager = new MockBuildManager(nonMatchingPath, fileExists: false)
            };

            // Act
            bool result = engine.FileExists(nonMatchingPath);

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ViewPageActivatorConsultsSetActivatorResolver()
        {
            // Arrange
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>();

            // Act
            TestableBuildManagerViewEngine engine = new TestableBuildManagerViewEngine(activator.Object);

            //Assert
            Assert.Equal(activator.Object, engine.ViewPageActivator);
        }

        [Fact]
        public void ViewPageActivatorDelegatesToActivatorResolver()
        {
            // Arrange
            var activator = new Mock<IViewPageActivator>();
            var activatorResolver = new Resolver<IViewPageActivator> { Current = activator.Object };

            // Act
            TestableBuildManagerViewEngine engine = new TestableBuildManagerViewEngine(activatorResolver: activatorResolver);

            // Assert
            Assert.Equal(activator.Object, engine.ViewPageActivator);
        }

        [Fact]
        public void ViewPageActivatorDelegatesToDependencyResolverWhenActivatorResolverIsNull()
        {
            // Arrange
            var viewInstance = new object();
            var controllerContext = new ControllerContext();
            var buildManager = new MockBuildManager("view path", typeof(object));
            var dependencyResolver = new Mock<IDependencyResolver>(MockBehavior.Strict);
            dependencyResolver.Setup(dr => dr.GetService(typeof(object))).Returns(viewInstance).Verifiable();

            // Act
            TestableBuildManagerViewEngine engine = new TestableBuildManagerViewEngine(dependencyResolver: dependencyResolver.Object);
            engine.ViewPageActivator.Create(controllerContext, typeof(object));

            // Assert
            dependencyResolver.Verify();
        }

        [Fact]
        public void ViewPageActivatorDelegatesToActivatorCreateInstanceWhenDependencyResolverReturnsNull()
        {
            // Arrange
            var controllerContext = new ControllerContext();
            var buildManager = new MockBuildManager("view path", typeof(NoParameterlessCtor));
            var dependencyResolver = new Mock<IDependencyResolver>();

            var engine = new TestableBuildManagerViewEngine(dependencyResolver: dependencyResolver.Object);

            // Act & Assert, confirming type name and full stack are available in Exception
            // Depend on the fact that Activator.CreateInstance cannot create an object without a parameterless ctor
            MissingMethodException ex = Assert.Throws<MissingMethodException>(
                () => engine.ViewPageActivator.Create(controllerContext, typeof(NoParameterlessCtor)),
                "No parameterless constructor defined for this object. Object type 'System.Web.Mvc.Test.BuildManagerViewEngineTest+NoParameterlessCtor'.");
            Assert.Contains("System.Activator.CreateInstance(", ex.InnerException.StackTrace);
        }

        [Fact]
        public void ActivatorResolverAndDependencyResolverAreNeverCalledWhenViewPageActivatorIsPassedInContstructor()
        {
            // Arrange
            var controllerContext = new ControllerContext();
            var expectedController = new Goodcontroller();

            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>();

            var resolverActivator = new Mock<IViewPageActivator>(MockBehavior.Strict);
            var activatorResolver = new Resolver<IViewPageActivator> { Current = resolverActivator.Object };

            var dependencyResolver = new Mock<IDependencyResolver>(MockBehavior.Strict);

            //Act
            var engine = new TestableBuildManagerViewEngine(activator.Object, activatorResolver, dependencyResolver.Object);

            //Assert
            Assert.Same(activator.Object, engine.ViewPageActivator);
        }

        private static VirtualPathProvider CreatePathProvider(params string[] files)
        {
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.IsAny<string>())).Returns<string>(p => files.Contains(p, StringComparer.OrdinalIgnoreCase));
            return vpp.Object;
        }

        private class NoParameterlessCtor
        {
            public NoParameterlessCtor(int x)
            {
            }
        }

        private class TestableBuildManagerViewEngine : BuildManagerViewEngine
        {
            private bool _isPrecompiledNonUpdateableSite;

            public TestableBuildManagerViewEngine()
                : base()
            {
            }

            public TestableBuildManagerViewEngine(IViewPageActivator viewPageActivator)
                : base(viewPageActivator)
            {
            }

            public TestableBuildManagerViewEngine(IViewPageActivator viewPageActivator = null, IResolver<IViewPageActivator> activatorResolver = null, IDependencyResolver dependencyResolver = null, VirtualPathProvider pathProvider = null)
                : base(viewPageActivator, activatorResolver, dependencyResolver, pathProvider)
            {
            }

            public new IViewPageActivator ViewPageActivator
            {
                get { return base.ViewPageActivator; }
            }

            public new VirtualPathProvider VirtualPathProvider
            {
                get { return base.VirtualPathProvider; }
            }

            protected override bool IsPrecompiledNonUpdateableSite
            {
                get { return _isPrecompiledNonUpdateableSite; }
            }

            protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
            {
                throw new NotImplementedException();
            }

            protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
            {
                throw new NotImplementedException();
            }

            public bool FileExists(string virtualPath)
            {
                return base.FileExists(null, virtualPath);
            }

            internal void SetIsPrecompiledNonUpdateableSite(bool value)
            {
                _isPrecompiledNonUpdateableSite = value;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ByteArrayModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Test
{
    public class ByteArrayModelBinderTest
    {
        internal const string Base64TestString = "Fys1";
        internal static readonly byte[] Base64TestBytes = new byte[] { 23, 43, 53 };

        [Fact]
        public void BindModelWithNonExistentValueReturnsNull()
        {
            // Arrange
            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", null }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            ByteArrayModelBinder binder = new ByteArrayModelBinder();

            // Act
            object binderResult = binder.BindModel(null, bindingContext);

            // Assert
            Assert.Null(binderResult);
        }

        [Fact]
        public void BinderWithEmptyStringValueReturnsNull()
        {
            // Arrange
            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", "" }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            ByteArrayModelBinder binder = new ByteArrayModelBinder();

            // Act
            object binderResult = binder.BindModel(null, bindingContext);

            // Assert
            Assert.Null(binderResult);
        }

        [Fact]
        public void BindModelThrowsIfBindingContextIsNull()
        {
            // Arrange
            ByteArrayModelBinder binder = new ByteArrayModelBinder();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { binder.BindModel(null, null); }, "bindingContext");
        }

        [Fact]
        public void BindModelWithBase64QuotedValueReturnsByteArray()
        {
            // Arrange
            string base64Value = Base64TestString;
            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", "\"" + base64Value + "\"" }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            ByteArrayModelBinder binder = new ByteArrayModelBinder();

            // Act
            byte[] boundValue = binder.BindModel(null, bindingContext) as byte[];

            // Assert
            Assert.Equal(Base64TestBytes, boundValue);
        }

        [Fact]
        public void BindModelWithBase64UnquotedValueReturnsByteArray()
        {
            // Arrange
            string base64Value = Base64TestString;
            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", base64Value }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            ByteArrayModelBinder binder = new ByteArrayModelBinder();

            // Act
            byte[] boundValue = binder.BindModel(null, bindingContext) as byte[];

            // Assert
            Assert.Equal(Base64TestBytes, boundValue);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/CachedAssociatedMetadataProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Runtime.Caching;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class CachedAssociatedMetadataProviderTest
    {
        [Fact]
        public void GetMetadataForPropertyInvalidPropertyNameThrows()
        {
            // Arrange
            MockableCachedAssociatedMetadataProvider provider = new MockableCachedAssociatedMetadataProvider();

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => provider.GetMetadataForProperty(null, typeof(object), "BadPropertyName"),
                "The property System.Object.BadPropertyName could not be found.");
        }

        [Fact]
        public void GetCacheKey_ResultsForTypesDoNotCollide()
        {
            // Arrange
            var provider = new MockableCachedAssociatedMetadataProvider();
            var keys = new List<string>();

            // Act
            keys.Add(provider.GetCacheKey(typeof(string)));
            keys.Add(provider.GetCacheKey(typeof(int)));
            keys.Add(provider.GetCacheKey(typeof(Nullable<int>)));
            keys.Add(provider.GetCacheKey(typeof(Nullable<bool>)));
            keys.Add(provider.GetCacheKey(typeof(List<string>)));
            keys.Add(provider.GetCacheKey(typeof(List<bool>)));

            // Assert
            Assert.Equal(keys.Distinct().Count(), keys.Count);
        }

        [Fact]
        public void GetCacheKey_ResultsForTypesAndPropertiesDoNotCollide()
        {
            // Arrange
            var provider = new MockableCachedAssociatedMetadataProvider();
            var keys = new List<string>();

            // Act
            keys.Add(provider.GetCacheKey(typeof(string), "Foo"));
            keys.Add(provider.GetCacheKey(typeof(string), "Bar"));
            keys.Add(provider.GetCacheKey(typeof(int), "Foo"));
            keys.Add(provider.GetCacheKey(typeof(Nullable<int>), "Foo"));
            keys.Add(provider.GetCacheKey(typeof(Nullable<bool>), "Foo"));
            keys.Add(provider.GetCacheKey(typeof(List<string>), "Count"));
            keys.Add(provider.GetCacheKey(typeof(List<bool>), "Count"));
            keys.Add(provider.GetCacheKey(typeof(Foo), "BarBaz"));
            keys.Add(provider.GetCacheKey(typeof(FooBar), "Baz"));

            // Assert
            Assert.Equal(keys.Distinct().Count(), keys.Count);
        }

        private class Foo
        {
        }

        private class FooBar
        {
        }

        // GetMetadataForProperty

        [Fact]
        public void GetMetadataForPropertyCreatesPrototypeMetadataAndAddsItToCache()
        {
            // Arrange
            var provider = new Mock<MockableCachedAssociatedMetadataProvider> { CallBase = true };

            // Act
            provider.Object.GetMetadataForProperty(() => 3, typeof(string), "Length");

            // Assert
            provider.Verify(p => p.CreateMetadataPrototypeImpl(It.IsAny<IEnumerable<Attribute>>(),
                                                               typeof(string) /* containerType */,
                                                               typeof(int) /* modelType */,
                                                               "Length" /* propertyName */));
            provider.Object.Cache.Verify(c => c.Add(provider.Object.GetCacheKey(typeof(string), "Length"),
                                                    provider.Object.PrototypeMetadata,
                                                    provider.Object.CacheItemPolicy, null));
        }

        [Fact]
        public void GetMetadataForPropertyCreatesRealMetadataFromPrototype()
        {
            // Arrange
            Func<object> accessor = () => 3;
            var provider = new Mock<MockableCachedAssociatedMetadataProvider> { CallBase = true };

            // Act
            provider.Object.GetMetadataForProperty(accessor, typeof(string), "Length");

            // Assert
            provider.Verify(p => p.CreateMetadataFromPrototypeImpl(provider.Object.PrototypeMetadata, accessor));
        }

        [Fact]
        public void MetaDataAwareAttributesForPropertyAreAppliedToMetadata()
        {
            // Arrange
            MemoryCache memoryCache = new MemoryCache("testCache");
            MockableCachedAssociatedMetadataProvider provider = new MockableCachedAssociatedMetadataProvider(memoryCache);

            // Act
            ModelMetadata metadata = provider.GetMetadataForProperty(null, typeof(ClassWithMetaDataAwareAttributes), "PropertyWithAdditionalValue");

            // Assert
            Assert.True(metadata.AdditionalValues["baz"].Equals("biz"));
        }

        [Fact]
        public void GetMetadataForPropertyTwiceOnlyCreatesAndCachesPrototypeOnce()
        {
            // Arrange
            Func<object> accessor = () => 3;
            var provider = new Mock<MockableCachedAssociatedMetadataProvider> { CallBase = true };

            // Act
            provider.Object.GetMetadataForProperty(accessor, typeof(string), "Length");
            provider.Object.GetMetadataForProperty(accessor, typeof(string), "Length");

            // Assert
            provider.Verify(p => p.CreateMetadataPrototypeImpl(It.IsAny<IEnumerable<Attribute>>(),
                                                               typeof(string) /* containerType */,
                                                               typeof(int) /* modelType */,
                                                               "Length" /* propertyName */),
                            Times.Once());

            provider.Verify(p => p.CreateMetadataFromPrototypeImpl(provider.Object.PrototypeMetadata, accessor),
                            Times.Exactly(2));

            provider.Object.Cache.Verify(c => c.Add(provider.Object.GetCacheKey(typeof(string), "Length"),
                                                    provider.Object.PrototypeMetadata,
                                                    provider.Object.CacheItemPolicy, null),
                                         Times.Once());
        }

        // GetMetadataForType

        [Fact]
        public void GetMetadataForTypeCreatesPrototypeMetadataAndAddsItToCache()
        {
            // Arrange
            var provider = new Mock<MockableCachedAssociatedMetadataProvider> { CallBase = true };

            // Act
            provider.Object.GetMetadataForType(() => "foo", typeof(string));

            // Assert
            provider.Verify(p => p.CreateMetadataPrototypeImpl(It.IsAny<IEnumerable<Attribute>>(),
                                                               null /* containerType */,
                                                               typeof(string) /* modelType */,
                                                               null /* propertyName */));
            provider.Object.Cache.Verify(c => c.Add(provider.Object.GetCacheKey(typeof(string), null),
                                                    provider.Object.PrototypeMetadata,
                                                    provider.Object.CacheItemPolicy, null));
        }

        [Fact]
        public void GetMetadataForTypeCreatesRealMetadataFromPrototype()
        {
            // Arrange
            Func<object> accessor = () => "foo";
            var provider = new Mock<MockableCachedAssociatedMetadataProvider> { CallBase = true };

            // Act
            provider.Object.GetMetadataForType(accessor, typeof(string));

            // Assert
            provider.Verify(p => p.CreateMetadataFromPrototypeImpl(provider.Object.PrototypeMetadata, accessor));
        }

        [Fact]
        public void MetaDataAwareAttributesForTypeAreAppliedToMetadata()
        {
            // Arrange
            MemoryCache memoryCache = new MemoryCache("testCache");
            MockableCachedAssociatedMetadataProvider provider = new MockableCachedAssociatedMetadataProvider(memoryCache);

            // Act
            ModelMetadata metadata = provider.GetMetadataForType(null, typeof(ClassWithMetaDataAwareAttributes));

            // Assert
            Assert.True(metadata.AdditionalValues["foo"].Equals("bar"));
        }

        [Fact]
        public void GetMetadataForTypeTwiceOnlyCreatesAndCachesPrototypeOnce()
        {
            // Arrange
            Func<object> accessor = () => "foo";
            var provider = new Mock<MockableCachedAssociatedMetadataProvider> { CallBase = true };

            // Act
            provider.Object.GetMetadataForType(accessor, typeof(string));
            provider.Object.GetMetadataForType(accessor, typeof(string));

            // Assert
            provider.Verify(p => p.CreateMetadataPrototypeImpl(It.IsAny<IEnumerable<Attribute>>(),
                                                               null /* containerType */,
                                                               typeof(string) /* modelType */,
                                                               null /* propertyName */),
                            Times.Once());

            provider.Verify(p => p.CreateMetadataFromPrototypeImpl(provider.Object.PrototypeMetadata, accessor),
                            Times.Exactly(2));

            provider.Object.Cache.Verify(c => c.Add(provider.Object.GetCacheKey(typeof(string), null),
                                                    provider.Object.PrototypeMetadata,
                                                    provider.Object.CacheItemPolicy, null),
                                         Times.Once());
        }

        // Helpers

        public class MockableCachedAssociatedMetadataProvider : CachedAssociatedMetadataProvider<ModelMetadata>
        {
            public Mock<MemoryCache> Cache;
            public ModelMetadata PrototypeMetadata;
            public ModelMetadata RealMetadata;

            public MockableCachedAssociatedMetadataProvider()
                : this(null)
            {
            }

            public MockableCachedAssociatedMetadataProvider(MemoryCache memoryCache = null)
            {
                Cache = new Mock<MemoryCache>("MockMemoryCache", null) { CallBase = true };
                PrototypeMetadata = new ModelMetadata(this, null, null, typeof(string), null);
                RealMetadata = new ModelMetadata(this, null, null, typeof(string), null);

                PrototypeCache = memoryCache ?? Cache.Object;
            }

            public virtual ModelMetadata CreateMetadataPrototypeImpl(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName)
            {
                return PrototypeMetadata;
            }

            public virtual ModelMetadata CreateMetadataFromPrototypeImpl(ModelMetadata prototype, Func<object> modelAccessor)
            {
                return RealMetadata;
            }

            protected override ModelMetadata CreateMetadataPrototype(IEnumerable<Attribute> attributes, Type containerType, Type modelType, string propertyName)
            {
                return CreateMetadataPrototypeImpl(attributes, containerType, modelType, propertyName);
            }

            protected override ModelMetadata CreateMetadataFromPrototype(ModelMetadata prototype, Func<object> modelAccessor)
            {
                return CreateMetadataFromPrototypeImpl(prototype, modelAccessor);
            }
        }

        [AdditionalMetadata("foo", "bar")]
        private class ClassWithMetaDataAwareAttributes
        {
            [AdditionalMetadata("baz", "biz")]
            public string PropertyWithAdditionalValue { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/CachedDataAnnotationsModelMetadataProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Test
{
    public class CachedDataAnnotationsModelMetadataProviderTest : DataAnnotationsModelMetadataProviderTestBase
    {
        protected override AssociatedMetadataProvider MakeProvider()
        {
            return new CachedDataAnnotationsModelMetadataProvider();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/CancellationTokenModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class CancellationTokenModelBinderTest
    {
        [Fact]
        public void BinderReturnsDefaultCancellationToken()
        {
            // Arrange
            CancellationTokenModelBinder binder = new CancellationTokenModelBinder();

            // Act
            object binderResult = binder.BindModel(controllerContext: null, bindingContext: null);

            // Assert
            Assert.Equal(default(CancellationToken), binderResult);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ChildActionOnlyAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ChildActionOnlyAttributeTest
    {
        [Fact]
        public void GuardClause()
        {
            // Arrange
            ChildActionOnlyAttribute attr = new ChildActionOnlyAttribute();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => attr.OnAuthorization(null /* filterContext */),
                "filterContext"
                );
        }

        [Fact]
        public void DoesNothingForChildRequest()
        {
            // Arrange
            ChildActionOnlyAttribute attr = new ChildActionOnlyAttribute();
            Mock<AuthorizationContext> context = new Mock<AuthorizationContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act
            attr.OnAuthorization(context.Object);

            // Assert
            Assert.Null(context.Object.Result);
        }

        [Fact]
        public void ThrowsIfNotChildRequest()
        {
            // Arrange
            ChildActionOnlyAttribute attr = new ChildActionOnlyAttribute();
            Mock<AuthorizationContext> context = new Mock<AuthorizationContext>();
            context.Setup(c => c.IsChildAction).Returns(false);
            context.Setup(c => c.ActionDescriptor.ActionName).Returns("some name");

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { attr.OnAuthorization(context.Object); },
                @"The action 'some name' is accessible only by a child request.");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ChildActionValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ExpiicitRouteDataValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProviderReturnsChildActionValue()
        {
            // Arrange
            ChildActionValueProviderFactory factory = new ChildActionValueProviderFactory();

            ControllerContext controllerContext = new ControllerContext();
            controllerContext.RouteData = new RouteData();

            string conflictingKey = "conflictingKey";

            controllerContext.RouteData.Values["conflictingKey"] = 43;

            DictionaryValueProvider<object> explictValueDictionary = new DictionaryValueProvider<object>(new RouteValueDictionary { { conflictingKey, 42 } }, CultureInfo.InvariantCulture);
            controllerContext.RouteData.Values[ChildActionValueProvider.ChildActionValuesKey] = explictValueDictionary;

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(controllerContext);

            // Assert
            Assert.Equal(typeof(ChildActionValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue(conflictingKey);

            Assert.NotNull(vpResult);
            Assert.Equal(42, vpResult.RawValue);
            Assert.Equal("42", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProviderReturnsNullIfNoChildActionDictionary()
        {
            // Arrange
            ChildActionValueProviderFactory factory = new ChildActionValueProviderFactory();

            ControllerContext controllerContext = new ControllerContext();
            controllerContext.RouteData = new RouteData();
            controllerContext.RouteData.Values["forty-two"] = 42;

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(controllerContext);

            // Assert
            Assert.Equal(typeof(ChildActionValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("forty-two");

            Assert.Null(vpResult);
        }

        [Fact]
        public void GetValueProviderReturnsNullIfKeyIsNotInChildActionDictionary()
        {
            // Arrange
            ChildActionValueProviderFactory factory = new ChildActionValueProviderFactory();

            ControllerContext controllerContext = new ControllerContext();
            controllerContext.RouteData = new RouteData();
            controllerContext.RouteData.Values["forty-two"] = 42;

            DictionaryValueProvider<object> explictValueDictionary = new DictionaryValueProvider<object>(new RouteValueDictionary { { "forty-three", 42 } }, CultureInfo.CurrentUICulture);
            controllerContext.RouteData.Values[ChildActionValueProvider.ChildActionValuesKey] = explictValueDictionary;

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(controllerContext);

            // Assert
            Assert.Equal(typeof(ChildActionValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("forty-two");

            Assert.Null(vpResult);
        }

        [Fact]
        public void GetValueProvider_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            RouteDataValueProviderFactory factory = new RouteDataValueProviderFactory();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { factory.GetValueProvider(null); }, "controllerContext");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ClientDataTypeModelValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ClientDataTypeModelValidatorProviderTest
    {
        private static readonly ModelMetadataProvider _metadataProvider = new DataAnnotationsModelMetadataProvider();
        private static readonly ModelValidatorProvider _validatorProvider = new ClientDataTypeModelValidatorProvider();

        private bool ReturnsValidator<TValidator>(string propertyName)
        {
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(null, typeof(SampleModel), propertyName);
            IEnumerable<ModelValidator> validators = _validatorProvider.GetValidators(metadata, new ControllerContext());
            return validators.Any(v => v is TValidator);
        }

        [Theory]
        [InlineData("Byte"), InlineData("SByte"), InlineData("Int16"), InlineData("UInt16")]
        [InlineData("Int32"), InlineData("UInt32"), InlineData("Int64"), InlineData("UInt64")]
        [InlineData("Single"), InlineData("Double"), InlineData("Decimal"), InlineData("NullableInt32")]
        public void GetValidators_NumericValidatorTypes(string propertyName)
        {
            // Act & assert
            Assert.True(ReturnsValidator<ClientDataTypeModelValidatorProvider.NumericModelValidator>(propertyName));
        }

        [Theory]
        [InlineData("String"), InlineData("Object"), InlineData("DateTime"), InlineData("NullableDateTime")]
        public void GetValidators_NonNumericValidatorTypes(string propertyName)
        {
            // Act & assert
            Assert.False(ReturnsValidator<ClientDataTypeModelValidatorProvider.NumericModelValidator>(propertyName));
        }

        [Theory]
        [InlineData("DateTime"), InlineData("NullableDateTime")]
        public void GetValidators_DateTimeValidatorTypes(string propertyName)
        {
            // Act & assert
            Assert.True(ReturnsValidator<ClientDataTypeModelValidatorProvider.DateModelValidator>(propertyName));
        }

        [Theory]
        [InlineData("Int32"), InlineData("NullableInt32"), InlineData("String"), InlineData("Object"), InlineData("Time")]
        public void GetValidators_NonDateTimeValidatorTypes(string propertyName)
        {
            // Act & assert
            Assert.False(ReturnsValidator<ClientDataTypeModelValidatorProvider.DateModelValidator>(propertyName));
        }

        [Fact]
        public void GuardClauses()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(SampleModel));

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new ClientDataTypeModelValidatorProvider.ClientModelValidator(metadata, new ControllerContext(), "testValidationType", errorMessage: null),
                "errorMessage");

            Assert.ThrowsArgumentNullOrEmpty(
                () => new ClientDataTypeModelValidatorProvider.ClientModelValidator(metadata, new ControllerContext(), "testValidationType", errorMessage: String.Empty),
                "errorMessage");

            Assert.ThrowsArgumentNullOrEmpty(
                () => new ClientDataTypeModelValidatorProvider.ClientModelValidator(metadata, new ControllerContext(), validationType: null, errorMessage: "testErrorMessage"),
                "validationType");

            Assert.ThrowsArgumentNullOrEmpty(
                () => new ClientDataTypeModelValidatorProvider.ClientModelValidator(metadata, new ControllerContext(), validationType: String.Empty, errorMessage: "testErrorMessage"),
                "validationType");
        }

        [Fact]
        public void GetValidators_ThrowsIfContextIsNull()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(SampleModel));

            // Act & assert
            Assert.ThrowsArgumentNull(
                () => _validatorProvider.GetValidators(metadata, null),
                "context");
        }

        [Fact]
        public void GetValidators_ThrowsIfMetadataIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                () => _validatorProvider.GetValidators(null, new ControllerContext()),
                "metadata");
        }

        [Fact]
        public void NumericValidator_GetClientValidationRules()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(null, typeof(SampleModel), "Int32");
            var validator = new ClientDataTypeModelValidatorProvider.NumericModelValidator(metadata, new ControllerContext());

            // Act
            ModelClientValidationRule[] rules = validator.GetClientValidationRules().ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("number", rule.ValidationType);
            Assert.Empty(rule.ValidationParameters);
            Assert.Equal("The field Int32 must be a number.", rule.ErrorMessage);
        }

        [Fact]
        public void DateValidator_GetClientValidationRules()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(null, typeof(SampleModel), "DateTime");
            var validator = new ClientDataTypeModelValidatorProvider.DateModelValidator(metadata, new ControllerContext());

            // Act
            ModelClientValidationRule[] rules = validator.GetClientValidationRules().ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("date", rule.ValidationType);
            Assert.Empty(rule.ValidationParameters);
            Assert.Equal("The field DateTime must be a date.", rule.ErrorMessage);
        }

        [Fact]
        public void ClientModelValidator_Validate_DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[] validators = new ClientDataTypeModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            Assert.Equal(new Type[] { typeof(ClientDataTypeModelValidatorProvider.NumericModelValidator) }, Array.ConvertAll(validators, o => o.GetType()));
            Assert.Empty(results);
            Assert.False(model.PropertyWasRead());
        }

        [Fact]
        public void ClientModelValidator_Validate_ReturnsEmptyCollection()
        {
            // Arrange
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(object));
            var validator = new ClientDataTypeModelValidatorProvider.ClientModelValidator(metadata, new ControllerContext(), "testValidationType", "testErrorMessage");

            // Act
            IEnumerable<ModelValidationResult> result = validator.Validate(null);

            // Assert
            Assert.Empty(result);
        }

        private class SampleModel
        {
            // these should have 'numeric' validators associated with them
            public byte Byte { get; set; }
            public sbyte SByte { get; set; }
            public short Int16 { get; set; }
            public ushort UInt16 { get; set; }
            public int Int32 { get; set; }
            public uint UInt32 { get; set; }
            public long Int64 { get; set; }
            public ulong UInt64 { get; set; }
            public float Single { get; set; }
            public double Double { get; set; }
            public decimal Decimal { get; set; }

            // this should also have a 'numeric' validator
            public int? NullableInt32 { get; set; }

            // this should have a 'date' validator associated with it
            public DateTime DateTime { get; set; }

            // this should also have a 'date' validator associated with it
            public DateTime? NullableDateTime { get; set; }

            [DataType(DataType.Time)]
            public DateTime Time { get; set; }

            // these shouldn't have any validators
            public string String { get; set; }
            public object Object { get; set; }
        }

        private class ObservableModel
        {
            private bool _propertyWasRead;

            public int TheProperty
            {
                get
                {
                    _propertyWasRead = true;
                    return 42;
                }
            }

            public bool PropertyWasRead()
            {
                return _propertyWasRead;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/CompareAttributeAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Linq;
using Microsoft.TestCommon;
using AnnotationsCompareAttribute = System.ComponentModel.DataAnnotations.CompareAttribute;
using MyResources = System.Web.Properties.Resources;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class CompareAttributeAdapterTest
    {
        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithCompareAttribute_ErrorMessageUsesDisplayName()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(PropertyDisplayNameModel), "MyProperty");
            var context = new ControllerContext();
            var attribute = new AnnotationsCompareAttribute("OtherProperty");
            var adapter = new CompareAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("'MyPropertyDisplayName' and 'OtherPropertyDisplayName' do not match.", rule.ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithCompareAttribute_ErrorMessageUsesPropertyName()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(PropertyNameModel), "MyProperty");
            var context = new ControllerContext();
            var attribute = new AnnotationsCompareAttribute("OtherProperty");
            var adapter = new CompareAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("'MyProperty' and 'OtherProperty' do not match.", rule.ErrorMessage);
        }

        [Fact]
        public void ClientRulesWithCompareAttribute_ErrorMessageUsesOverride()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(PropertyNameModel), "MyProperty");
            ControllerContext context = new ControllerContext();
            AnnotationsCompareAttribute attribute = new AnnotationsCompareAttribute("OtherProperty")
            {
                ErrorMessage = "Hello '{0}', goodbye '{1}'.",
            };
            ModelValidator adapter = new CompareAttributeAdapter(metadata, context, attribute);

            // Act
            ModelClientValidationRule[] rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("Hello 'MyProperty', goodbye 'OtherProperty'.", rule.ErrorMessage);
        }

        [Fact]
        public void ClientRulesWithCompareAttribute_ErrorMessageUsesResourceOverride()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(PropertyNameModel), "MyProperty");
            ControllerContext context = new ControllerContext();
            AnnotationsCompareAttribute attribute = new AnnotationsCompareAttribute("OtherProperty")
            {
                ErrorMessageResourceName = "CompareAttributeTestResource",
                ErrorMessageResourceType = typeof(MyResources),
            };
            ModelValidator adapter = new CompareAttributeAdapter(metadata, context, attribute);

            // Act
            ModelClientValidationRule[] rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("Hello 'MyProperty', goodbye 'OtherProperty'.", rule.ErrorMessage);
        }

        private class PropertyDisplayNameModel
        {
            [DisplayName("MyPropertyDisplayName")]
            public string MyProperty { get; set; }

            [DisplayName("OtherPropertyDisplayName")]
            public string OtherProperty { get; set; }
        }

        private class PropertyNameModel
        {
            public string MyProperty { get; set; }

            public string OtherProperty { get; set; }
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Test/CompareAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class CompareAttributeTest
    {
        [Fact]
        public void GuardClauses()
        {
            //Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new CompareAttribute(null); }, "otherProperty");

            Assert.ThrowsArgumentNullOrEmpty(
                delegate { CompareAttribute.FormatPropertyForClientValidation(null); }, "property");
        }

        [Fact]
        public void FormatPropertyForClientValidationPrependsStarDot()
        {
            string prepended = CompareAttribute.FormatPropertyForClientValidation("test");
            Assert.Equal("*.test", prepended);
        }

        [Fact]
        public void ValidateDoesNotThrowWhenComparedObjectsAreEqual()
        {
            object otherObject = new CompareObject("test");
            CompareObject currentObject = new CompareObject("test");
            ValidationContext testContext = new ValidationContext(otherObject, null, null);

            CompareAttribute attr = new CompareAttribute("CompareProperty");
            attr.Validate(currentObject.CompareProperty, testContext);
        }

        [Fact]
        public void ValidateThrowsWhenComparedObjectsAreNotEqual()
        {
            CompareObject currentObject = new CompareObject("a");
            object otherObject = new CompareObject("b");

            ValidationContext testContext = new ValidationContext(otherObject, null, null);
            testContext.DisplayName = "CurrentProperty";

            CompareAttribute attr = new CompareAttribute("CompareProperty");
            Assert.Throws<ValidationException>(
                delegate { attr.Validate(currentObject.CompareProperty, testContext); }, "'CurrentProperty' and 'CompareProperty' do not match.");
        }

        [Fact]
        public void ValidateThrowsWithOtherPropertyDisplayName()
        {
            CompareObject currentObject = new CompareObject("a");
            object otherObject = new CompareObject("b");

            ValidationContext testContext = new ValidationContext(otherObject, null, null);
            testContext.DisplayName = "CurrentProperty";

            CompareAttribute attr = new CompareAttribute("ComparePropertyWithDisplayName");
            Assert.Throws<ValidationException>(
                delegate { attr.Validate(currentObject.CompareProperty, testContext); }, "'CurrentProperty' and 'DisplayName' do not match.");
        }

        [Fact]
        public void ValidateUsesSetDisplayName()
        {
            CompareObject currentObject = new CompareObject("a");
            object otherObject = new CompareObject("b");

            ValidationContext testContext = new ValidationContext(otherObject, null, null);
            testContext.DisplayName = "CurrentProperty";

            CompareAttribute attr = new CompareAttribute("ComparePropertyWithDisplayName");
            attr.OtherPropertyDisplayName = "SetDisplayName";

            Assert.Throws<ValidationException>(
                delegate { attr.Validate(currentObject.CompareProperty, testContext); }, "'CurrentProperty' and 'SetDisplayName' do not match.");
        }

        [Fact]
        public void ValidateThrowsWhenPropertyNameIsUnknown()
        {
            CompareObject currentObject = new CompareObject("a");
            object otherObject = new CompareObject("b");

            ValidationContext testContext = new ValidationContext(otherObject, null, null);
            testContext.DisplayName = "CurrentProperty";

            CompareAttribute attr = new CompareAttribute("UnknownPropertyName");
            Assert.Throws<ValidationException>(
                () => attr.Validate(currentObject.CompareProperty, testContext),
                "Could not find a property named UnknownPropertyName."
                );
        }

        [Fact]
        public void GetClientValidationRulesReturnsModelClientValidationEqualToRule()
        {
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Mock<ModelMetadata> metadata = new Mock<ModelMetadata>(provider.Object, null, null, typeof(string), null);
            metadata.Setup(m => m.DisplayName).Returns("CurrentProperty");

            CompareAttribute attr = new CompareAttribute("CompareProperty");
            List<ModelClientValidationRule> ruleList = new List<ModelClientValidationRule>(attr.GetClientValidationRules(metadata.Object, null));

            ModelClientValidationRule rule = Assert.Single(ruleList);
            ModelClientValidationEqualToRule actualRule = Assert.IsType<ModelClientValidationEqualToRule>(rule);

            Assert.Equal("'CurrentProperty' and 'CompareProperty' do not match.", actualRule.ErrorMessage);
            Assert.Equal("equalto", actualRule.ValidationType);
            Assert.Equal("*.CompareProperty", actualRule.ValidationParameters["other"]);
        }

        [Fact]
        public void ModelClientValidationEqualToRuleErrorMessageUsesOtherPropertyDisplayName()
        {
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, typeof(CompareObject), null, typeof(string), null);
            metadata.DisplayName = "CurrentProperty";

            CompareAttribute attr = new CompareAttribute("ComparePropertyWithDisplayName");
            List<ModelClientValidationRule> ruleList = new List<ModelClientValidationRule>(attr.GetClientValidationRules(metadata, null));

            ModelClientValidationRule rule = Assert.Single(ruleList);
            ModelClientValidationEqualToRule actualRule = Assert.IsType<ModelClientValidationEqualToRule>(rule);

            Assert.Equal("'CurrentProperty' and 'DisplayName' do not match.", actualRule.ErrorMessage);
            Assert.Equal("equalto", actualRule.ValidationType);
            Assert.Equal("*.ComparePropertyWithDisplayName", actualRule.ValidationParameters["other"]);
        }

        [Fact]
        public void ModelClientValidationEqualToRuleUsesSetDisplayName()
        {
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, typeof(CompareObject), null, typeof(string), null);
            metadata.DisplayName = "CurrentProperty";

            CompareAttribute attr = new CompareAttribute("ComparePropertyWithDisplayName");
            attr.OtherPropertyDisplayName = "SetDisplayName";

            List<ModelClientValidationRule> ruleList = new List<ModelClientValidationRule>(attr.GetClientValidationRules(metadata, null));
            ModelClientValidationRule rule = Assert.Single(ruleList);
            ModelClientValidationEqualToRule actualRule = Assert.IsType<ModelClientValidationEqualToRule>(rule);

            Assert.Equal("'CurrentProperty' and 'SetDisplayName' do not match.", actualRule.ErrorMessage);
        }

        [Fact]
        public void CompareAttributeCanBeDerivedFromAndOverrideIsValid()
        {
            object otherObject = new CompareObject("a");
            CompareObject currentObject = new CompareObject("b");
            ValidationContext testContext = new ValidationContext(otherObject, null, null);

            DerivedCompareAttribute attr = new DerivedCompareAttribute("CompareProperty");
            attr.Validate(currentObject.CompareProperty, testContext);
        }

        private class DerivedCompareAttribute : CompareAttribute
        {
            public DerivedCompareAttribute(string otherProperty)
                : base(otherProperty)
            {
            }

            public override bool IsValid(object value)
            {
                return false;
            }

            protected override ValidationResult IsValid(object value, ValidationContext context)
            {
                return null;
            }
        }

        private class CompareObject
        {
            public string CompareProperty { get; set; }

            [Display(Name = "DisplayName")]
            public string ComparePropertyWithDisplayName { get; set; }

            public CompareObject(string otherValue)
            {
                CompareProperty = otherValue;
                ComparePropertyWithDisplayName = otherValue;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ContentResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ContentResultTest
    {
        [Fact]
        public void AllPropertiesDefaultToNull()
        {
            // Act
            ContentResult result = new ContentResult();

            // Assert
            Assert.Null(result.Content);
            Assert.Null(result.ContentEncoding);
            Assert.Null(result.ContentType);
        }

        [Fact]
        public void EmptyContentTypeIsNotOutput()
        {
            // Arrange
            string content = "Some content.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(content)).Verifiable();

            ContentResult result = new ContentResult
            {
                Content = content,
                ContentType = String.Empty,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResult()
        {
            // Arrange
            string content = "Some content.";
            string contentType = "Some content type.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(content)).Verifiable();

            ContentResult result = new ContentResult
            {
                Content = content,
                ContentType = contentType,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultWithNullContextThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { new ContentResult().ExecuteResult(null /* context */); }, "context");
        }

        [Fact]
        public void NullContentIsNotOutput()
        {
            // Arrange
            string contentType = "Some content type.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();

            ContentResult result = new ContentResult
            {
                ContentType = contentType,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void NullContentEncodingIsNotOutput()
        {
            // Arrange
            string content = "Some content.";
            string contentType = "Some content type.";

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(content)).Verifiable();

            ContentResult result = new ContentResult
            {
                Content = content,
                ContentType = contentType,
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void NullContentTypeIsNotOutput()
        {
            // Arrange
            string content = "Some content.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(content)).Verifiable();

            ContentResult result = new ContentResult
            {
                Content = content,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerActionInvokerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Linq;
using System.Reflection;
using System.Security.Claims;
using System.Security.Principal;
using System.Threading;
using System.Web.Mvc.Filters;
using System.Web.Routing;
using System.Web.Routing.Test;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class ControllerActionInvokerTest
    {
        [Fact]
        public void CreateActionResultWithActionResultParameterReturnsParameterUnchanged()
        {
            // Arrange
            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper();
            ActionResult originalResult = new JsonResult();

            // Act
            ActionResult returnedActionResult = invoker.PublicCreateActionResult(null, null, originalResult);

            // Assert
            Assert.Same(originalResult, returnedActionResult);
        }

        [Fact]
        public void CreateActionResultWithNullParameterReturnsEmptyResult()
        {
            // Arrange
            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper();

            // Act
            ActionResult returnedActionResult = invoker.PublicCreateActionResult(null, null, null);

            // Assert
            Assert.IsType<EmptyResult>(returnedActionResult);
        }

        [Fact]
        public void CreateActionResultWithObjectParameterReturnsContentResult()
        {
            // Arrange
            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper();
            object originalReturnValue = new CultureReflector();

            // Act
            ActionResult returnedActionResult = invoker.PublicCreateActionResult(null, null, originalReturnValue);

            // Assert
            ContentResult contentResult = Assert.IsType<ContentResult>(returnedActionResult);
            Assert.Equal("ivl", contentResult.Content);
        }

        [Fact]
        public void FindAction()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ActionDescriptor expectedAd = new Mock<ActionDescriptor>().Object;
            Mock<ControllerDescriptor> mockCd = new Mock<ControllerDescriptor>();
            mockCd.Setup(cd => cd.FindAction(controllerContext, "someAction")).Returns(expectedAd);

            // Act
            ActionDescriptor returnedAd = helper.PublicFindAction(controllerContext, mockCd.Object, "someAction");

            // Assert
            Assert.Equal(expectedAd, returnedAd);
        }

        [Fact]
        public void FindActionDoesNotMatchConstructor()
        {
            // FindActionMethod() shouldn't match special-named methods like type constructors.

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, ".ctor");
            ActionDescriptor ad2 = helper.PublicFindAction(context, cd, "FindMethodController");

            // Assert
            Assert.Null(ad);
            Assert.Null(ad2);
        }

        [Fact]
        public void FindActionDoesNotMatchEvent()
        {
            // FindActionMethod() should skip methods that aren't publicly visible.

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "add_Event");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionDoesNotMatchInternalMethod()
        {
            // FindActionMethod() should skip methods that aren't publicly visible.

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "InternalMethod");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionDoesNotMatchMethodsDefinedOnControllerType()
        {
            // FindActionMethod() shouldn't match methods originally defined on the Controller type, e.g. Dispose().

            // Arrange
            Controller controller = new BlankController();
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(BlankController));
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            var methods = typeof(Controller).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);

            // Act & Assert
            foreach (var method in methods)
            {
                bool wasFound = true;
                try
                {
                    ActionDescriptor ad = helper.PublicFindAction(context, cd, method.Name);
                    wasFound = (ad != null);
                }
                finally
                {
                    Assert.False(wasFound, "FindAction() should return false for methods defined on the Controller class: " + method);
                }
            }
        }

        [Fact]
        public void FindActionDoesNotMatchMethodsDefinedOnObjectType()
        {
            // FindActionMethod() shouldn't match methods originally defined on the Object type, e.g. ToString().

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "ToString");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionDoesNotMatchNonActionMethod()
        {
            // FindActionMethod() should respect the [NonAction] attribute.

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "NonActionMethod");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionDoesNotMatchOverriddenNonActionMethod()
        {
            // FindActionMethod() should trace the method's inheritance chain looking for the [NonAction] attribute.

            // Arrange
            Controller controller = new DerivedFindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(DerivedFindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "InternalMethod");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionDoesNotMatchPrivateMethod()
        {
            // FindActionMethod() should skip methods that aren't publicly visible.

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "PrivateMethod");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionDoesNotMatchProperty()
        {
            // FindActionMethod() shouldn't match special-named methods like property getters.

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "get_Property");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionDoesNotMatchProtectedMethod()
        {
            // FindActionMethod() should skip methods that aren't publicly visible.

            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "ProtectedMethod");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionIsCaseInsensitive()
        {
            // Arrange
            Controller controller = new FindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(FindMethodController));
            MethodInfo expectedMethodInfo = typeof(FindMethodController).GetMethod("ValidActionMethod");

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad1 = helper.PublicFindAction(context, cd, "validactionmethod");
            ActionDescriptor ad2 = helper.PublicFindAction(context, cd, "VALIDACTIONMETHOD");

            // Assert
            ReflectedActionDescriptor rad1 = Assert.IsType<ReflectedActionDescriptor>(ad1);
            Assert.Same(expectedMethodInfo, rad1.MethodInfo);
            ReflectedActionDescriptor rad2 = Assert.IsType<ReflectedActionDescriptor>(ad2);
            Assert.Same(expectedMethodInfo, rad2.MethodInfo);
        }

        [Fact]
        public void FindActionMatchesActionMethodWithClosedGenerics()
        {
            // FindActionMethod() should work with generic methods as long as there are no open types.

            // Arrange
            Controller controller = new GenericFindMethodController<int>();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(GenericFindMethodController<int>));
            MethodInfo expectedMethodInfo = typeof(GenericFindMethodController<int>).GetMethod("ClosedGenericMethod");

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "ClosedGenericMethod");

            // Assert
            ReflectedActionDescriptor rad = Assert.IsType<ReflectedActionDescriptor>(ad);
            Assert.Same(expectedMethodInfo, rad.MethodInfo);
        }

        [Fact]
        public void FindActionMatchesNewActionMethodsHidingNonActionMethods()
        {
            // FindActionMethod() should stop looking for [NonAction] in the method's inheritance chain when it sees
            // that a method in a derived class hides the a method in the base class.

            // Arrange
            Controller controller = new DerivedFindMethodController();
            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new ReflectedControllerDescriptor(typeof(DerivedFindMethodController));
            MethodInfo expectedMethodInfo = typeof(DerivedFindMethodController).GetMethod("DerivedIsActionMethod");

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor ad = helper.PublicFindAction(context, cd, "DerivedIsActionMethod");

            // Assert
            ReflectedActionDescriptor rad = Assert.IsType<ReflectedActionDescriptor>(ad);
            Assert.Same(expectedMethodInfo, rad.MethodInfo);
        }

        [Fact]
        public void GetControllerDescriptor()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ControllerDescriptor cd = helper.PublicGetControllerDescriptor(controllerContext);

            // Assert
            Assert.IsType<ReflectedControllerDescriptor>(cd);
            Assert.Equal(typeof(EmptyController), cd.ControllerType);
        }

        [Fact]
        public void GetFiltersSplitsFilterObjectsIntoFilterInfo()
        {
            // Arrange
            IActionFilter actionFilter = new Mock<IActionFilter>().Object;
            IResultFilter resultFilter = new Mock<IResultFilter>().Object;
            IAuthorizationFilter authorizationFilter = new Mock<IAuthorizationFilter>().Object;
            IAuthenticationFilter authenticationFilter = new Mock<IAuthenticationFilter>().Object;
            IExceptionFilter exFilter = new Mock<IExceptionFilter>().Object;
            object noneOfTheAbove = new object();
            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper(actionFilter, authorizationFilter, authenticationFilter, exFilter, resultFilter, noneOfTheAbove);
            ControllerContext context = new ControllerContext();
            ActionDescriptor descriptor = new Mock<ActionDescriptor>().Object;

            // Act
            FilterInfo result = invoker.PublicGetFilters(context, descriptor);

            // Assert
            Assert.Same(actionFilter, result.ActionFilters.Single());
            Assert.Same(authorizationFilter, result.AuthorizationFilters.Single());
            Assert.Same(authenticationFilter, result.AuthenticationFilters.Single());
            Assert.Same(exFilter, result.ExceptionFilters.Single());
            Assert.Same(resultFilter, result.ResultFilters.Single());
        }

        [Fact]
        public void GetParameterValueAllowsAllSubpropertiesIfBindAttributeNotSpecified()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithoutBindAttribute = typeof(CustomConverterController).GetMethod("ParameterWithoutBindAttribute").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithoutBindAttribute, new Mock<ActionDescriptor>().Object);

            // Act
            object valueWithoutBindAttribute = helper.PublicGetParameterValue(controllerContext, pd);

            // Assert
            Assert.Equal("foo=True&bar=True", valueWithoutBindAttribute);
        }

        [Fact]
        public void GetParameterValueResolvesConvertersInCorrectOrderOfPrecedence()
        {
            // Order of precedence:
            //   1. Attributes on the parameter itself
            //   2. Query the global converter provider

            // Arrange
            CustomConverterController controller = new CustomConverterController();
            Dictionary<string, object> values = new Dictionary<string, object> { { "foo", "fooValue" } };
            ControllerContext controllerContext = GetControllerContext(controller, values);
            controller.ControllerContext = controllerContext;
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithOneConverter = typeof(CustomConverterController).GetMethod("ParameterHasOneConverter").GetParameters()[0];
            ReflectedParameterDescriptor pdOneConverter = new ReflectedParameterDescriptor(paramWithOneConverter, new Mock<ActionDescriptor>().Object);
            ParameterInfo paramWithNoConverters = typeof(CustomConverterController).GetMethod("ParameterHasNoConverters").GetParameters()[0];
            ReflectedParameterDescriptor pdNoConverters = new ReflectedParameterDescriptor(paramWithNoConverters, new Mock<ActionDescriptor>().Object);

            // Act
            object valueWithOneConverter = helper.PublicGetParameterValue(controllerContext, pdOneConverter);
            object valueWithNoConverters = helper.PublicGetParameterValue(controllerContext, pdNoConverters);

            // Assert
            Assert.Equal("foo_String", valueWithOneConverter);
            Assert.Equal("fooValue", valueWithNoConverters);
        }

        [Fact]
        public void GetParameterValueRespectsBindAttribute()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithBindAttribute = typeof(CustomConverterController).GetMethod("ParameterHasBindAttribute").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithBindAttribute, new Mock<ActionDescriptor>().Object);

            // Act
            object valueWithBindAttribute = helper.PublicGetParameterValue(controllerContext, pd);

            // Assert
            Assert.Equal("foo=True&bar=False", valueWithBindAttribute);
        }

        [Fact]
        public void GetParameterValueRespectsBindAttributePrefix()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            Dictionary<string, object> values = new Dictionary<string, object> { { "foo", "fooValue" }, { "bar", "barValue" } };
            ControllerContext controllerContext = GetControllerContext(controller, values);
            controller.ControllerContext = controllerContext;

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithFieldPrefix = typeof(CustomConverterController).GetMethod("ParameterHasFieldPrefix").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithFieldPrefix, new Mock<ActionDescriptor>().Object);

            // Act
            object parameterValue = helper.PublicGetParameterValue(controllerContext, pd);

            // Assert
            Assert.Equal("barValue", parameterValue);
        }

        [Fact]
        public void GetParameterValueRespectsBindAttributePrefixOnComplexType()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            Dictionary<string, object> values = new Dictionary<string, object> { { "intprop", "123" }, { "stringprop", "hello" } };
            ControllerContext controllerContext = GetControllerContext(controller, values);
            controller.ControllerContext = controllerContext;

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithFieldPrefix = typeof(CustomConverterController).GetMethod("ParameterHasPrefixAndComplexType").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithFieldPrefix, new Mock<ActionDescriptor>().Object);

            // Act
            MySimpleModel parameterValue = helper.PublicGetParameterValue(controllerContext, pd) as MySimpleModel;

            // Assert
            Assert.Null(parameterValue);
        }

        [Fact]
        public void GetParameterValueRespectsBindAttributeNullPrefix()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            Dictionary<string, object> values = new Dictionary<string, object> { { "foo", "fooValue" }, { "bar", "barValue" } };
            ControllerContext controllerContext = GetControllerContext(controller, values);
            controller.ControllerContext = controllerContext;

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithFieldPrefix = typeof(CustomConverterController).GetMethod("ParameterHasNullFieldPrefix").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithFieldPrefix, new Mock<ActionDescriptor>().Object);

            // Act
            object parameterValue = helper.PublicGetParameterValue(controllerContext, pd);

            // Assert
            Assert.Equal("fooValue", parameterValue);
        }

        [Fact]
        public void GetParameterValueRespectsBindAttributeNullPrefixOnComplexType()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            Dictionary<string, object> values = new Dictionary<string, object> { { "intprop", "123" }, { "stringprop", "hello" } };
            ControllerContext controllerContext = GetControllerContext(controller, values);
            controller.ControllerContext = controllerContext;

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithFieldPrefix = typeof(CustomConverterController).GetMethod("ParameterHasNoPrefixAndComplexType").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithFieldPrefix, new Mock<ActionDescriptor>().Object);

            // Act
            MySimpleModel parameterValue = helper.PublicGetParameterValue(controllerContext, pd) as MySimpleModel;

            // Assert
            Assert.NotNull(parameterValue);
            Assert.Equal(123, parameterValue.IntProp);
            Assert.Equal("hello", parameterValue.StringProp);
        }

        [Fact]
        public void GetParameterValueRespectsBindAttributeEmptyPrefix()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            Dictionary<string, object> values = new Dictionary<string, object> { { "foo", "fooValue" }, { "bar", "barValue" }, { "intprop", "123" }, { "stringprop", "hello" } };
            ControllerContext controllerContext = GetControllerContext(controller, values);
            controller.ControllerContext = controllerContext;

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo paramWithFieldPrefix = typeof(CustomConverterController).GetMethod("ParameterHasEmptyFieldPrefix").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithFieldPrefix, new Mock<ActionDescriptor>().Object);

            // Act
            MySimpleModel parameterValue = helper.PublicGetParameterValue(controllerContext, pd) as MySimpleModel;

            // Assert
            Assert.NotNull(parameterValue);
            Assert.Equal(123, parameterValue.IntProp);
            Assert.Equal("hello", parameterValue.StringProp);
        }

        [Fact]
        public void GetParameterValueRespectsDefaultValueAttribute()
        {
            // Arrange
            CustomConverterController controller = new CustomConverterController();
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            controller.ValueProvider = new SimpleValueProvider();

            ParameterInfo paramWithDefaultValueAttribute = typeof(CustomConverterController).GetMethod("ParameterHasDefaultValueAttribute").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(paramWithDefaultValueAttribute, new Mock<ActionDescriptor>().Object);

            // Act
            object valueWithDefaultValueAttribute = helper.PublicGetParameterValue(controllerContext, pd);

            // Assert
            Assert.Equal(42, valueWithDefaultValueAttribute);
        }

        [Fact]
        public void GetParameterValueReturnsNullIfCannotConvertNonRequiredParameter()
        {
            // Arrange
            Dictionary<string, object> dict = new Dictionary<string, object>()
            {
                { "id", DateTime.Now } // cannot convert DateTime to Nullable<int>
            };
            var controller = new ParameterTestingController();
            ControllerContext context = GetControllerContext(controller, dict);
            controller.ControllerContext = context;

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            MethodInfo mi = typeof(ParameterTestingController).GetMethod("TakesNullableInt");
            ParameterInfo[] pis = mi.GetParameters();
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(pis[0], new Mock<ActionDescriptor>().Object);

            // Act
            object oValue = helper.PublicGetParameterValue(context, pd);

            // Assert
            Assert.Null(oValue);
        }

        [Fact]
        public void GetParameterValueReturnsNullIfNullableTypeValueNotFound()
        {
            // Arrange
            var controller = new ParameterTestingController();
            ControllerContext context = GetControllerContext(controller);
            controller.ControllerContext = context;
            controller.ValueProvider = new SimpleValueProvider();

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            MethodInfo mi = typeof(ParameterTestingController).GetMethod("TakesNullableInt");
            ParameterInfo[] pis = mi.GetParameters();
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(pis[0], new Mock<ActionDescriptor>().Object);

            // Act
            object oValue = helper.PublicGetParameterValue(context, pd);

            // Assert
            Assert.Null(oValue);
        }

        [Fact]
        public void GetParameterValueReturnsNullIfReferenceTypeValueNotFound()
        {
            // Arrange
            var controller = new ParameterTestingController();
            ControllerContext context = GetControllerContext(controller);
            controller.ControllerContext = context;
            controller.ValueProvider = new SimpleValueProvider();

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            MethodInfo mi = typeof(ParameterTestingController).GetMethod("Foo");
            ParameterInfo[] pis = mi.GetParameters();
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(pis[0], new Mock<ActionDescriptor>().Object);

            // Act
            object oValue = helper.PublicGetParameterValue(context, pd);

            // Assert
            Assert.Null(oValue);
        }

        [Fact]
        public void GetParameterValuesCallsGetParameterValue()
        {
            // Arrange
            ControllerBase controller = new ParameterTestingController();
            IDictionary<string, object> dict = new Dictionary<string, object>();
            ControllerContext context = GetControllerContext(controller);
            MethodInfo mi = typeof(ParameterTestingController).GetMethod("Foo");
            ReflectedActionDescriptor ad = new ReflectedActionDescriptor(mi, "Foo", new Mock<ControllerDescriptor>().Object);
            ParameterDescriptor[] pds = ad.GetParameters();

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetParameterValue(context, pds[0])).Returns("Myfoo").Verifiable();
            mockHelper.Setup(h => h.PublicGetParameterValue(context, pds[1])).Returns("Mybar").Verifiable();
            mockHelper.Setup(h => h.PublicGetParameterValue(context, pds[2])).Returns("Mybaz").Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            IDictionary<string, object> parameters = helper.PublicGetParameterValues(context, ad);

            // Assert
            Assert.Equal(3, parameters.Count);
            Assert.Equal("Myfoo", parameters["foo"]);
            Assert.Equal("Mybar", parameters["bar"]);
            Assert.Equal("Mybaz", parameters["baz"]);
            mockHelper.Verify();
        }

        [Fact]
        public void GetParameterValuesReturnsEmptyDictionaryForParameterlessMethod()
        {
            // Arrange
            var controller = new ParameterTestingController();
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            MethodInfo mi = typeof(ParameterTestingController).GetMethod("Parameterless");
            ReflectedActionDescriptor ad = new ReflectedActionDescriptor(mi, "Parameterless", new Mock<ControllerDescriptor>().Object);

            // Act
            IDictionary<string, object> parameters = helper.PublicGetParameterValues(context, ad);

            // Assert
            Assert.Empty(parameters);
        }

        [Fact]
        public void GetParameterValuesReturnsValuesForParametersInOrder()
        {
            // We need to hook into GetParameterValue() to make sure that GetParameterValues() is calling it.

            // Arrange
            var controller = new ParameterTestingController();
            Dictionary<string, object> dict = new Dictionary<string, object>()
            {
                { "foo", "MyFoo" },
                { "bar", "MyBar" },
                { "baz", "MyBaz" }
            };
            ControllerContext context = GetControllerContext(controller, dict);
            controller.ControllerContext = context;

            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            MethodInfo mi = typeof(ParameterTestingController).GetMethod("Foo");
            ReflectedActionDescriptor ad = new ReflectedActionDescriptor(mi, "Foo", new Mock<ControllerDescriptor>().Object);

            // Act
            IDictionary<string, object> parameters = helper.PublicGetParameterValues(context, ad);

            // Assert
            Assert.Equal(3, parameters.Count);
            Assert.Equal("MyFoo", parameters["foo"]);
            Assert.Equal("MyBar", parameters["bar"]);
            Assert.Equal("MyBaz", parameters["baz"]);
        }

        [Fact]
        public void GetParameterValueUsesControllerValueProviderAsValueProvider()
        {
            // Arrange
            Dictionary<string, object> values = new Dictionary<string, object>()
            {
                { "foo", "fooValue" }
            };

            CustomConverterController controller = new CustomConverterController();
            ControllerContext controllerContext = GetControllerContext(controller, values);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            ParameterInfo parameter = typeof(CustomConverterController).GetMethod("ParameterHasNoConverters").GetParameters()[0];
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(parameter, new Mock<ActionDescriptor>().Object);

            // Act
            object parameterValue = helper.PublicGetParameterValue(controllerContext, pd);

            // Assert
            Assert.Equal("fooValue", parameterValue);
        }

        [Fact]
        public void InvokeAction()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;

            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();

            IDictionary<string, object> parameters = new Dictionary<string, object>();
            MethodInfo methodInfo = typeof(object).GetMethod("ToString");
            ActionResult actionResult = new EmptyResult();
            ActionExecutedContext postContext = new ActionExecutedContext(context, ad, false /* canceled */, null /* exception */)
            {
                Result = actionResult
            };
            ActionResult challengeResult = new EmptyResult();
            AuthenticationContext authenticationContext = new AuthenticationContext();
            AuthorizationContext authorizationContext = new AuthorizationContext();
            AuthenticationChallengeContext authenticationChallengeContext = new AuthenticationChallengeContext() { Result = challengeResult };

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthorizationFilters(context, filterInfo.AuthorizationFilters, ad)).Returns(authorizationContext).Verifiable();
            mockHelper.Setup(h => h.PublicGetParameterValues(context, ad)).Returns(parameters).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionMethodWithFilters(context, filterInfo.ActionFilters, ad, parameters)).Returns(postContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFiltersChallenge(context, filterInfo.AuthenticationFilters, ad, actionResult)).Returns(authenticationChallengeContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionResultWithFilters(context, filterInfo.ResultFilters, challengeResult)).Returns((ResultExecutedContext)null).Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            bool retVal = helper.InvokeAction(context, "SomeMethod");
            Assert.True(retVal);
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionCallsValidateRequestIfAsked()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            controller.ValidateRequest = true;
            bool validateInputWasCalled = false;

            ControllerContext context = GetControllerContext(controller, null, validateInputCallback: () => { validateInputWasCalled = true; });
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();
            AuthenticationContext authenticationContext = new AuthenticationContext();
            AuthorizationContext authorizationContext = new AuthorizationContext();

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>();
            mockHelper.CallBase = true;
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthorizationFilters(context, filterInfo.AuthorizationFilters, ad)).Returns(authorizationContext).Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            helper.InvokeAction(context, "SomeMethod");

            // Assert
            Assert.True(validateInputWasCalled);
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionDoesNotCallValidateRequestForChildActions()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            controller.ValidateRequest = true;

            ControllerContext context = GetControllerContext(controller, null);
            Mock.Get<ControllerContext>(context).SetupGet(c => c.IsChildAction).Returns(true);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();
            AuthenticationContext authenticationContext = new AuthenticationContext();
            AuthorizationContext authorizationContext = new AuthorizationContext();

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>();
            mockHelper.CallBase = true;
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthorizationFilters(context, filterInfo.AuthorizationFilters, ad)).Returns(authorizationContext).Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            helper.InvokeAction(context, "SomeMethod"); // No exception thrown

            // Assert
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionMethodFilterWhereContinuationThrowsExceptionAndIsHandled()
        {
            // Arrange
            List<string> actions = new List<string>();
            MethodInfo mi = typeof(object).GetMethod("ToString");
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            Exception exception = new Exception();
            ActionDescriptor action = new Mock<ActionDescriptor>().Object;

            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actions.Add("OnActionExecuting"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    actions.Add("OnActionExecuted");
                    Assert.Same(exception, filterContext.Exception);
                    Assert.Same(action, filterContext.ActionDescriptor);
                    Assert.False(filterContext.ExceptionHandled);
                    filterContext.ExceptionHandled = true;
                }
            };
            Func<ActionExecutedContext> continuation = delegate
            {
                actions.Add("Continuation");
                throw exception;
            };

            ActionExecutingContext context = new ActionExecutingContext(GetControllerContext(new EmptyController()), action, parameters);

            // Act
            ActionExecutedContext result = ControllerActionInvoker.InvokeActionMethodFilter(filter, context, continuation);

            // Assert
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnActionExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnActionExecuted", actions[2]);
            Assert.Same(exception, result.Exception);
            Assert.Same(action, result.ActionDescriptor);
            Assert.True(result.ExceptionHandled);
        }

        [Fact]
        public void InvokeActionMethodFilterWhereContinuationThrowsExceptionAndIsNotHandled()
        {
            // Arrange
            List<string> actions = new List<string>();
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            ActionDescriptor action = new Mock<ActionDescriptor>().Object;

            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actions.Add("OnActionExecuting"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    Assert.NotNull(filterContext.Exception);
                    Assert.Equal("Some exception message.", filterContext.Exception.Message);
                    Assert.Same(action, filterContext.ActionDescriptor);
                    actions.Add("OnActionExecuted");
                }
            };
            Func<ActionExecutedContext> continuation = delegate
            {
                actions.Add("Continuation");
                throw new Exception("Some exception message.");
            };

            ActionExecutingContext context = new ActionExecutingContext(GetControllerContext(new EmptyController()), action, parameters);

            // Act & Assert
            Assert.Throws<Exception>(
                delegate { ControllerActionInvoker.InvokeActionMethodFilter(filter, context, continuation); },
                "Some exception message.");
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnActionExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnActionExecuted", actions[2]);
        }

        [Fact]
        public void InvokeActionMethodFilterWhereContinuationThrowsThreadAbortException()
        {
            // Arrange
            List<string> actions = new List<string>();
            ActionResult actionResult = new EmptyResult();
            ActionDescriptor action = new Mock<ActionDescriptor>().Object;

            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actions.Add("OnActionExecuting"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    Thread.ResetAbort();
                    actions.Add("OnActionExecuted");
                    Assert.Null(filterContext.Exception);
                    Assert.False(filterContext.ExceptionHandled);
                    Assert.Same(action, filterContext.ActionDescriptor);
                }
            };
            Func<ActionExecutedContext> continuation = delegate
            {
                actions.Add("Continuation");
                Thread.CurrentThread.Abort();
                return null;
            };

            ActionExecutingContext context = new ActionExecutingContext(new Mock<ControllerContext>().Object, action, new Dictionary<string, object>());

            // Act & Assert
            Assert.Throws<ThreadAbortException>(
                delegate { ControllerActionInvoker.InvokeActionMethodFilter(filter, context, continuation); },
                "Thread was being aborted.");
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnActionExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnActionExecuted", actions[2]);
        }

        [Fact]
        public void InvokeActionMethodFilterWhereOnActionExecutingCancels()
        {
            // Arrange
            bool wasCalled = false;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            Dictionary<string, object> parameters = new Dictionary<string, object>();

            ActionResult actionResult = new EmptyResult();
            ActionDescriptor action = new Mock<ActionDescriptor>().Object;

            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext)
                {
                    Assert.False(wasCalled);
                    wasCalled = true;
                    filterContext.Result = actionResult;
                },
            };
            Func<ActionExecutedContext> continuation = delegate
            {
                Assert.True(false, "The continuation should not be called.");
                return null;
            };

            ActionExecutingContext context = new ActionExecutingContext(GetControllerContext(new EmptyController()), action, parameters);

            // Act
            ActionExecutedContext result = ControllerActionInvoker.InvokeActionMethodFilter(filter, context, continuation);

            // Assert
            Assert.True(wasCalled);
            Assert.Null(result.Exception);
            Assert.True(result.Canceled);
            Assert.Same(actionResult, result.Result);
            Assert.Same(action, result.ActionDescriptor);
        }

        [Fact]
        public void InvokeActionMethodFilterWithNormalControlFlow()
        {
            // Arrange
            List<string> actions = new List<string>();
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            ActionDescriptor action = new Mock<ActionDescriptor>().Object;

            ActionExecutingContext preContext = new ActionExecutingContext(GetControllerContext(new EmptyController()), action, parameters);
            Mock<ActionExecutedContext> mockPostContext = new Mock<ActionExecutedContext>();

            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext)
                {
                    Assert.Same(parameters, filterContext.ActionParameters);
                    Assert.Null(filterContext.Result);
                    actions.Add("OnActionExecuting");
                },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext)
                {
                    Assert.Equal(mockPostContext.Object, filterContext);
                    actions.Add("OnActionExecuted");
                }
            };
            Func<ActionExecutedContext> continuation = delegate
            {
                actions.Add("Continuation");
                return mockPostContext.Object;
            };

            // Act
            ActionExecutedContext result = ControllerActionInvoker.InvokeActionMethodFilter(filter, preContext, continuation);

            // Assert
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnActionExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnActionExecuted", actions[2]);
            Assert.Same(result, mockPostContext.Object);
        }

        [Fact]
        public void InvokeActionInvokesExceptionFiltersAndExecutesResultIfExceptionHandled()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;

            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();

            AuthenticationContext authenticationContext = new AuthenticationContext();
            Exception exception = new Exception();
            ActionResult actionResult = new EmptyResult();
            ExceptionContext exContext = new ExceptionContext(context, exception)
            {
                ExceptionHandled = true,
                Result = actionResult
            };

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Throws(exception).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeExceptionFilters(context, filterInfo.ExceptionFilters, exception)).Returns(exContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionResult(context, actionResult)).Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            bool retVal = helper.InvokeAction(context, "SomeMethod");
            Assert.True(retVal);
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionInvokesExceptionFiltersAndRethrowsExceptionIfNotHandled()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;

            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();

            AuthenticationContext authenticationContext = new AuthenticationContext();
            Exception exception = new Exception();
            ExceptionContext exContext = new ExceptionContext(context, exception);

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthorizationFilters(context, filterInfo.AuthorizationFilters, ad)).Throws(exception).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeExceptionFilters(context, filterInfo.ExceptionFilters, exception)).Returns(exContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionResult(context, It.IsAny<ActionResult>())).Callback(delegate { Assert.True(false, "InvokeActionResult() shouldn't be called if the exception was unhandled by filters."); });
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            Exception thrownException = Assert.Throws<Exception>(
                delegate { helper.InvokeAction(context, "SomeMethod"); });

            // Assert
            Assert.Same(exception, thrownException);
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionInvokesResultIfAuthenticationFilterReturnsResult()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;

            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();

            ActionResult actionResult = new EmptyResult();
            AuthenticationContext authenticationContext = new AuthenticationContext() { Result = actionResult };
            ActionResult challengeActionResult = new EmptyResult();
            AuthenticationChallengeContext authenticationChallengeContext = new AuthenticationChallengeContext() { Result = challengeActionResult };

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFiltersChallenge(context, filterInfo.AuthenticationFilters, ad, actionResult)).Returns(authenticationChallengeContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionResult(context, challengeActionResult)).Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            bool retVal = helper.InvokeAction(context, "SomeMethod");
            Assert.True(retVal);
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionInvokesResultIfAuthorizationFilterReturnsResult()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;

            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();

            ActionResult actionResult = new EmptyResult();
            AuthenticationContext authenticationContext = new AuthenticationContext();
            AuthorizationContext authorizationContext = new AuthorizationContext() { Result = actionResult };
            ActionResult challengeResult = new EmptyResult();
            AuthenticationChallengeContext authenticationChallengeContext = new AuthenticationChallengeContext() { Result = challengeResult };

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthorizationFilters(context, filterInfo.AuthorizationFilters, ad)).Returns(authorizationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFiltersChallenge(context, filterInfo.AuthenticationFilters, ad, actionResult)).Returns(authenticationChallengeContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionResult(context, challengeResult)).Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            bool retVal = helper.InvokeAction(context, "SomeMethod");
            Assert.True(retVal);
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionMethod()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            ControllerContext controllerContext = GetControllerContext(controller);
            Dictionary<string, object> parameters = new Dictionary<string, object>();

            ActionResult expectedResult = new Mock<ActionResult>().Object;

            Mock<ActionDescriptor> mockAd = new Mock<ActionDescriptor>();
            mockAd.Setup(ad => ad.Execute(controllerContext, parameters)).Returns("hello world");

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicCreateActionResult(controllerContext, mockAd.Object, "hello world")).Returns(expectedResult);
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            ActionResult returnedResult = helper.PublicInvokeActionMethod(controllerContext, mockAd.Object, parameters);

            // Assert
            Assert.Same(expectedResult, returnedResult);
        }

        [Fact]
        public void InvokeActionMethodWithFiltersOrdersFiltersCorrectly()
        {
            // Arrange
            List<string> actions = new List<string>();
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            ActionResult actionResult = new EmptyResult();

            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actions.Add("OnActionExecuting1"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actions.Add("OnActionExecuted1"); }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext) { actions.Add("OnActionExecuting2"); },
                OnActionExecutedImpl = delegate(ActionExecutedContext filterContext) { actions.Add("OnActionExecuted2"); }
            };
            Func<ActionResult> continuation = delegate
            {
                actions.Add("Continuation");
                return new EmptyResult();
            };
            ControllerBase controller = new ContinuationController(continuation);
            ControllerContext context = GetControllerContext(controller);
            ActionDescriptor actionDescriptor = new ReflectedActionDescriptor(ContinuationController.GoMethod, "someName", new Mock<ControllerDescriptor>().Object);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            List<IActionFilter> filters = new List<IActionFilter>() { filter1, filter2 };

            // Act
            helper.PublicInvokeActionMethodWithFilters(context, filters, actionDescriptor, parameters);

            // Assert
            Assert.Equal(5, actions.Count);
            Assert.Equal("OnActionExecuting1", actions[0]);
            Assert.Equal("OnActionExecuting2", actions[1]);
            Assert.Equal("Continuation", actions[2]);
            Assert.Equal("OnActionExecuted2", actions[3]);
            Assert.Equal("OnActionExecuted1", actions[4]);
        }

        [Fact]
        public void InvokeActionMethodWithFiltersPassesArgumentsCorrectly()
        {
            // Arrange
            bool wasCalled = false;
            MethodInfo mi = ContinuationController.GoMethod;
            Dictionary<string, object> parameters = new Dictionary<string, object>();
            ActionResult actionResult = new EmptyResult();
            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnActionExecutingImpl = delegate(ActionExecutingContext filterContext)
                {
                    Assert.Same(parameters, filterContext.ActionParameters);
                    Assert.False(wasCalled);
                    wasCalled = true;
                    filterContext.Result = actionResult;
                }
            };
            Func<ActionResult> continuation = delegate
            {
                Assert.True(false, "Continuation should not be called.");
                return null;
            };
            ControllerBase controller = new ContinuationController(continuation);
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            ActionDescriptor actionDescriptor = new ReflectedActionDescriptor(ContinuationController.GoMethod, "someName", new Mock<ControllerDescriptor>().Object);
            List<IActionFilter> filters = new List<IActionFilter>() { filter };

            // Act
            ActionExecutedContext result = helper.PublicInvokeActionMethodWithFilters(context, filters, actionDescriptor, parameters);

            // Assert
            Assert.True(wasCalled);
            Assert.Null(result.Exception);
            Assert.False(result.ExceptionHandled);
            Assert.Same(actionResult, result.Result);
            Assert.Same(actionDescriptor, result.ActionDescriptor);
        }

        [Fact]
        public void InvokeActionPropagatesThreadAbortException()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;

            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            FilterInfo filterInfo = new FilterInfo();

            ActionResult actionResult = new EmptyResult();
            ActionExecutedContext postContext = new ActionExecutedContext(context, ad, false /* canceled */, null /* exception */)
            {
                Result = actionResult
            };
            AuthenticationContext authenticationContext = new AuthenticationContext();
            AuthorizationContext authorizationContext = new AuthorizationContext() { Result = actionResult };

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper
                .Setup(h => h.PublicInvokeAuthorizationFilters(context, filterInfo.AuthorizationFilters, ad))
                .Returns(
                    delegate(ControllerContext cc, IList<IAuthorizationFilter> f, ActionDescriptor a)
                    {
                        Thread.CurrentThread.Abort();
                        return null;
                    });
            ControllerActionInvokerHelper helper = mockHelper.Object;

            bool wasAborted = false;

            // Act
            try
            {
                helper.InvokeAction(context, "SomeMethod");
            }
            catch (ThreadAbortException)
            {
                wasAborted = true;
                Thread.ResetAbort();
            }

            // Assert
            Assert.True(wasAborted);
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeActionReturnsFalseIfMethodNotFound()
        {
            // Arrange
            var controller = new BlankController();
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvoker invoker = new ControllerActionInvoker();

            // Act
            bool retVal = invoker.InvokeAction(context, "foo");

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void InvokeActionThrowsIfControllerContextIsNull()
        {
            // Arrange
            ControllerActionInvoker invoker = new ControllerActionInvoker();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { invoker.InvokeAction(null, "actionName"); }, "controllerContext");
        }

        [Fact]
        public void InvokeActionWithEmptyActionNameThrows()
        {
            // Arrange
            var controller = new BasicMethodInvokeController();
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvoker invoker = new ControllerActionInvoker();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { invoker.InvokeAction(context, String.Empty); },
                "actionName");
        }

        [Fact]
        public void InvokeActionWithNullActionNameThrows()
        {
            // Arrange
            var controller = new BasicMethodInvokeController();
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvoker invoker = new ControllerActionInvoker();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { invoker.InvokeAction(context, null /* actionName */); },
                "actionName");
        }

        [Fact]
        public void InvokeActionWithResultExceptionInvokesExceptionFiltersAndExecutesResultIfExceptionHandled()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;

            ControllerContext context = GetControllerContext(controller);
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            IDictionary<string, object> parameters = new Dictionary<string, object>();
            FilterInfo filterInfo = new FilterInfo();
            AuthenticationContext authenticationContext = new AuthenticationContext();
            AuthorizationContext authorizationContext = new AuthorizationContext();
            AuthenticationChallengeContext authenticationChallengeContext = new AuthenticationChallengeContext();

            Exception exception = new Exception();
            ActionResult actionResult = new EmptyResult();
            ActionExecutedContext postContext = new ActionExecutedContext(context, ad, false /* canceled */, null /* exception */)
            {
                Result = actionResult
            };
            ExceptionContext exContext = new ExceptionContext(context, exception)
            {
                ExceptionHandled = true,
                Result = actionResult
            };

            Mock<ControllerActionInvokerHelper> mockHelper = new Mock<ControllerActionInvokerHelper>() { CallBase = true };
            mockHelper.Setup(h => h.PublicGetControllerDescriptor(context)).Returns(cd).Verifiable();
            mockHelper.Setup(h => h.PublicFindAction(context, cd, "SomeMethod")).Returns(ad).Verifiable();
            mockHelper.Setup(h => h.PublicGetFilters(context, ad)).Returns(filterInfo).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFilters(context, filterInfo.AuthenticationFilters, ad)).Returns(authenticationContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthorizationFilters(context, filterInfo.AuthorizationFilters, ad)).Returns(authorizationContext).Verifiable();
            mockHelper.Setup(h => h.PublicGetParameterValues(context, ad)).Returns(parameters).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionMethodWithFilters(context, filterInfo.ActionFilters, ad, parameters)).Returns(postContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionResultWithFilters(context, filterInfo.ResultFilters, actionResult)).Throws(exception).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeAuthenticationFiltersChallenge(context, filterInfo.AuthenticationFilters, ad, actionResult)).Returns(authenticationChallengeContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeExceptionFilters(context, filterInfo.ExceptionFilters, exception)).Returns(exContext).Verifiable();
            mockHelper.Setup(h => h.PublicInvokeActionResult(context, actionResult)).Verifiable();
            ControllerActionInvokerHelper helper = mockHelper.Object;

            // Act
            bool retVal = helper.InvokeAction(context, "SomeMethod");
            Assert.True(retVal, "InvokeAction() should return True on success.");
            mockHelper.Verify();
        }

        [Fact]
        public void InvokeAuthorizationFilters()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            List<AuthorizationFilterHelper> callQueue = new List<AuthorizationFilterHelper>();
            AuthorizationFilterHelper filter1 = new AuthorizationFilterHelper(callQueue);
            AuthorizationFilterHelper filter2 = new AuthorizationFilterHelper(callQueue);
            IAuthorizationFilter[] filters = new IAuthorizationFilter[] { filter1, filter2 };

            // Act
            AuthorizationContext postContext = helper.PublicInvokeAuthorizationFilters(controllerContext, filters, ad);

            // Assert
            Assert.Equal(ad, postContext.ActionDescriptor);
            Assert.Equal(2, callQueue.Count);
            Assert.Same(filter1, callQueue[0]);
            Assert.Same(filter2, callQueue[1]);
        }

        [Fact]
        public void InvokeAuthorizationFiltersStopsExecutingIfResultProvided()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            ActionResult result = new EmptyResult();

            List<AuthorizationFilterHelper> callQueue = new List<AuthorizationFilterHelper>();
            AuthorizationFilterHelper filter1 = new AuthorizationFilterHelper(callQueue) { ShortCircuitResult = result };
            AuthorizationFilterHelper filter2 = new AuthorizationFilterHelper(callQueue);
            IAuthorizationFilter[] filters = new IAuthorizationFilter[] { filter1, filter2 };

            // Act
            AuthorizationContext postContext = helper.PublicInvokeAuthorizationFilters(controllerContext, filters, ad);

            // Assert
            Assert.Equal(ad, postContext.ActionDescriptor);
            Assert.Same(result, postContext.Result);
            AuthorizationFilterHelper resultFilter = Assert.Single(callQueue);
            Assert.Same(filter1, resultFilter);
        }

        [Fact]
        public void InvokeAuthenticationFilters()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            List<AuthenticationFilterHelper> callQueue = new List<AuthenticationFilterHelper>();
            AuthenticationFilterHelper filter1 = new AuthenticationFilterHelper(callQueue);
            AuthenticationFilterHelper filter2 = new AuthenticationFilterHelper(callQueue);
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter1, filter2 };
            AuthenticationContext postContext;

            using (new ThreadCurrentPrincipalContext())
            {
                // Act
                postContext = helper.PublicInvokeAuthenticationFilters(controllerContext, filters, ad);
            }

            // Assert
            Assert.Same(ad, postContext.ActionDescriptor);
            Assert.Same(controller, postContext.Controller);
            Assert.Equal(2, callQueue.Count);
            Assert.Same(filter1, callQueue[0]);
            Assert.Same(filter2, callQueue[1]);
        }

        [Fact]
        public void InvokeAuthenticationFiltersProvidesHttpContextUserAsPrincipalInFilterContext()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            IPrincipal principal = new ClaimsPrincipal();
            controllerContext.HttpContext.User = principal;
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            List<AuthenticationFilterHelper> callQueue = new List<AuthenticationFilterHelper>();
            AuthenticationFilterHelper filter = new AuthenticationFilterHelper(callQueue);
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
            AuthenticationContext postContext;

            using (new ThreadCurrentPrincipalContext())
            {
                // Act
                postContext = helper.PublicInvokeAuthenticationFilters(controllerContext, filters, ad);
            }

            // Assert
            Assert.Same(ad, postContext.ActionDescriptor);
            Assert.Same(controller, postContext.Controller);
            AuthenticationFilterHelper actualHelper = Assert.Single(callQueue);
            Assert.Same(filter, actualHelper);
            Assert.Same(principal, postContext.Principal);
        }

        [Fact]
        public void InvokeAuthenticationFiltersStopsExecutingIfResultProvided()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            ActionResult result = new EmptyResult();

            List<AuthenticationFilterHelper> callQueue = new List<AuthenticationFilterHelper>();
            AuthenticationFilterHelper filter1 = new AuthenticationFilterHelper(callQueue) { ShortCircuitResult = result };
            AuthenticationFilterHelper filter2 = new AuthenticationFilterHelper(callQueue);
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter1, filter2 };
            AuthenticationContext postContext;

            using (new ThreadCurrentPrincipalContext())
            {
                // Act
                postContext = helper.PublicInvokeAuthenticationFilters(controllerContext, filters, ad);
            }

            // Assert
            Assert.Same(ad, postContext.ActionDescriptor);
            Assert.Same(controller, postContext.Controller);
            Assert.Same(result, postContext.Result);
            AuthenticationFilterHelper resultFilter = Assert.Single(callQueue);
            Assert.Same(filter1, resultFilter);
        }

        [Fact]
        public void InvokeAuthenticationFiltersSetsHttpContextUserWhenPrincipalIsProvided()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            IPrincipal principal = new ClaimsPrincipal();

            List<AuthenticationFilterHelper> callQueue = new List<AuthenticationFilterHelper>();
            AuthenticationFilterHelper filter = new AuthenticationFilterHelper(callQueue) { Principal = principal };
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };
            AuthenticationContext postContext;

            using (new ThreadCurrentPrincipalContext())
            {
                // Act
                postContext = helper.PublicInvokeAuthenticationFilters(controllerContext, filters, ad);
            }

            // Assert
            Assert.Same(ad, postContext.ActionDescriptor);
            Assert.Same(controller, postContext.Controller);
            Assert.Same(principal, postContext.HttpContext.User);
            AuthenticationFilterHelper resultFilter = Assert.Single(callQueue);
            Assert.Same(filter, resultFilter);
        }

        [Fact]
        public void InvokeAuthenticationFiltersSetsThreadCurrentPrincipalWhenPrincipalIsProvided()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            IPrincipal principal = new ClaimsPrincipal();

            List<AuthenticationFilterHelper> callQueue = new List<AuthenticationFilterHelper>();
            AuthenticationFilterHelper filter = new AuthenticationFilterHelper(callQueue) { Principal = principal };
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };

            using (new ThreadCurrentPrincipalContext())
            {
                // Act
                AuthenticationContext postContext = helper.PublicInvokeAuthenticationFilters(controllerContext, filters, ad);

                // Assert
                Assert.Same(ad, postContext.ActionDescriptor);
                Assert.Same(controller, postContext.Controller);
                Assert.Same(principal, Thread.CurrentPrincipal);
                AuthenticationFilterHelper resultFilter = Assert.Single(callQueue);
                Assert.Same(filter, resultFilter);
            }
        }

        [Fact]
        public void InvokeAuthenticationFiltersDoesNotSetThreadCurrentPrincipalWhenPrincipalIsUnchanged()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            IPrincipal principal = new ClaimsPrincipal();
            controllerContext.HttpContext.User = principal;
            Assert.NotSame(controllerContext.HttpContext.User, Thread.CurrentPrincipal); // Guard
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            List<AuthenticationFilterHelper> callQueue = new List<AuthenticationFilterHelper>();
            AuthenticationFilterHelper filter = new AuthenticationFilterHelper(callQueue);
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter };

            using (new ThreadCurrentPrincipalContext())
            {
                // Act
                AuthenticationContext postContext = helper.PublicInvokeAuthenticationFilters(controllerContext, filters, ad);

                // Assert
                Assert.Same(ad, postContext.ActionDescriptor);
                Assert.Same(controller, postContext.Controller);
                Assert.NotSame(controllerContext.HttpContext.User, Thread.CurrentPrincipal);
                AuthenticationFilterHelper resultFilter = Assert.Single(callQueue);
                Assert.Same(filter, resultFilter);
            }
        }

        [Fact]
        public void InvokeAuthenticationFiltersChallenge()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            List<AuthenticationFilterHelper> callQueue = new List<AuthenticationFilterHelper>();
            AuthenticationFilterHelper filter1 = new AuthenticationFilterHelper(callQueue);
            AuthenticationFilterHelper filter2 = new AuthenticationFilterHelper(callQueue);
            IAuthenticationFilter[] filters = new IAuthenticationFilter[] { filter1, filter2 };
            ActionResult result = new EmptyResult();

            // Act
            AuthenticationChallengeContext postContext = helper.PublicInvokeAuthenticationFiltersChallenge(controllerContext, filters, ad, result);

            // Assert
            Assert.Same(ad, postContext.ActionDescriptor);
            Assert.Same(controller, postContext.Controller);
            Assert.Same(result, postContext.Result);
            Assert.Equal(2, callQueue.Count);
            Assert.Same(filter1, callQueue[0]);
            Assert.Same(filter2, callQueue[1]);
        }

        [Fact]
        public void InvokeExceptionFilters()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            Exception exception = new Exception();
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            List<ExceptionFilterHelper> callQueue = new List<ExceptionFilterHelper>();
            ExceptionFilterHelper filter1 = new ExceptionFilterHelper(callQueue);
            ExceptionFilterHelper filter2 = new ExceptionFilterHelper(callQueue);
            IExceptionFilter[] filters = new IExceptionFilter[] { filter1, filter2 };

            // Act
            ExceptionContext postContext = helper.PublicInvokeExceptionFilters(controllerContext, filters, exception);

            // Assert
            Assert.Same(exception, postContext.Exception);
            Assert.False(postContext.ExceptionHandled);
            Assert.Same(filter1.ContextPassed, filter2.ContextPassed);
            Assert.Equal(2, callQueue.Count);
            Assert.Same(filter2, callQueue[0]); // Exception filters are executed in reverse order
            Assert.Same(filter1, callQueue[1]);
        }

        [Fact]
        public void InvokeExceptionFiltersContinuesExecutingIfExceptionHandled()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            Exception exception = new Exception();
            ControllerContext controllerContext = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            List<ExceptionFilterHelper> callQueue = new List<ExceptionFilterHelper>();
            ExceptionFilterHelper filter1 = new ExceptionFilterHelper(callQueue) { ShouldHandleException = true };
            ExceptionFilterHelper filter2 = new ExceptionFilterHelper(callQueue);
            IExceptionFilter[] filters = new IExceptionFilter[] { filter1, filter2 };

            // Act
            ExceptionContext postContext = helper.PublicInvokeExceptionFilters(controllerContext, filters, exception);

            // Assert
            Assert.Same(exception, postContext.Exception);
            Assert.True(postContext.ExceptionHandled);
            Assert.Same(filter1.ContextPassed, filter2.ContextPassed);
            Assert.Equal(2, callQueue.Count);
            Assert.Same(filter2, callQueue[0]); // Exception filters are executed in reverse order
            Assert.Same(filter1, callQueue[1]);
        }

        [Fact]
        public void InvokeActionResultWithFiltersOrdersFiltersCorrectly()
        {
            // Arrange
            List<string> actions = new List<string>();
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext) { actions.Add("OnResultExecuting1"); },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext) { actions.Add("OnResultExecuted1"); }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext) { actions.Add("OnResultExecuting2"); },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext) { actions.Add("OnResultExecuted2"); }
            };
            Action continuation = delegate { actions.Add("Continuation"); };
            ActionResult actionResult = new ContinuationResult(continuation);
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            List<IResultFilter> filters = new List<IResultFilter>() { filter1, filter2 };

            // Act
            helper.PublicInvokeActionResultWithFilters(context, filters, actionResult);

            // Assert
            Assert.Equal(5, actions.Count);
            Assert.Equal("OnResultExecuting1", actions[0]);
            Assert.Equal("OnResultExecuting2", actions[1]);
            Assert.Equal("Continuation", actions[2]);
            Assert.Equal("OnResultExecuted2", actions[3]);
            Assert.Equal("OnResultExecuted1", actions[4]);
        }

        [Fact]
        public void InvokeActionResultWithFiltersPassesArgumentsCorrectly()
        {
            // Arrange
            bool wasCalled = false;
            Action continuation = delegate { Assert.True(false, "Continuation should not be called."); };
            ActionResult actionResult = new ContinuationResult(continuation);
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    Assert.Same(actionResult, filterContext.Result);
                    Assert.False(wasCalled);
                    wasCalled = true;
                    filterContext.Cancel = true;
                }
            };

            List<IResultFilter> filters = new List<IResultFilter>() { filter };

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(context, filters, actionResult);

            // Assert
            Assert.True(wasCalled);
            Assert.Null(result.Exception);
            Assert.False(result.ExceptionHandled);
            Assert.Same(actionResult, result.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersPassesSameContextObjectToInnerFilters()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);

            ResultExecutingContext storedContext = null;
            ActionResult result = new EmptyResult();
            List<IResultFilter> filters = new List<IResultFilter>()
            {
                new ActionFilterImpl()
                {
                    OnResultExecutingImpl = delegate(ResultExecutingContext ctx)
                    {
                        Assert.NotNull(ctx);
                        storedContext = ctx;
                    },
                    OnResultExecutedImpl = delegate { }
                },
                new ActionFilterImpl()
                {
                    OnResultExecutingImpl = delegate(ResultExecutingContext ctx)
                    {
                        Assert.NotNull(ctx);
                        Assert.Same(storedContext, ctx);
                    },
                    OnResultExecutedImpl = delegate { }
                },
            };
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ResultExecutedContext postContext = helper.PublicInvokeActionResultWithFilters(context, filters, result);

            // Assert
            Assert.Same(result, postContext.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereContinuationThrowsExceptionAndIsHandled()
        {
            // Arrange
            List<string> actions = new List<string>();
            Exception exception = new Exception();
            Action continuation = delegate
            {
                actions.Add("Continuation");
                throw exception;
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext) { actions.Add("OnResultExecuting"); },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted");
                    Assert.Same(actionResult, filterContext.Result);
                    Assert.Same(exception, filterContext.Exception);
                    Assert.False(filterContext.ExceptionHandled);
                    filterContext.ExceptionHandled = true;
                }
            };

            Mock<ResultExecutingContext> mockResultExecutingContext = new Mock<ResultExecutingContext>() { DefaultValue = DefaultValue.Mock };
            mockResultExecutingContext.Setup(c => c.Result).Returns(actionResult);
            List<IResultFilter> filters = new List<IResultFilter>() { filter, };
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(mockResultExecutingContext.Object, filters, actionResult);

            // Assert
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnResultExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnResultExecuted", actions[2]);
            Assert.Same(exception, result.Exception);
            Assert.True(result.ExceptionHandled);
            Assert.Same(actionResult, result.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereContinuationThrowsExceptionAndIsNotHandled()
        {
            // Arrange
            List<string> actions = new List<string>();
            Action continuation = delegate
            {
                actions.Add("Continuation");
                throw new Exception("Some exception message.");
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext) { actions.Add("OnResultExecuting"); },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext) { actions.Add("OnResultExecuted"); }
            };
            Mock<ResultExecutingContext> mockResultExecutingContext = new Mock<ResultExecutingContext>() { DefaultValue = DefaultValue.Mock };
            mockResultExecutingContext.Setup(c => c.Result).Returns(actionResult);
            List<IResultFilter> filters = new List<IResultFilter>() { filter, };
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act & Assert
            Assert.Throws<Exception>(
                delegate { helper.PublicInvokeActionResultWithFilters(mockResultExecutingContext.Object, filters, actionResult); },
                "Some exception message.");
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnResultExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnResultExecuted", actions[2]);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereContinuationThrowsThreadAbortException()
        {
            // Arrange
            List<string> actions = new List<string>();

            Action continuation = delegate
            {
                actions.Add("Continuation");
                Thread.CurrentThread.Abort();
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            Mock<ResultExecutingContext> mockPreContext = new Mock<ResultExecutingContext>() { DefaultValue = DefaultValue.Mock };
            mockPreContext.Setup(c => c.Result).Returns(actionResult);
            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext) { actions.Add("OnResultExecuting"); },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    Thread.ResetAbort();
                    actions.Add("OnResultExecuted");
                    Assert.Same(actionResult, filterContext.Result);
                    Assert.Null(filterContext.Exception);
                    Assert.False(filterContext.ExceptionHandled);
                }
            };
            List<IResultFilter> filters = new List<IResultFilter>() { filter, };
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act & Assert
            Assert.Throws<ThreadAbortException>(
                delegate { helper.PublicInvokeActionResultWithFilters(mockPreContext.Object, filters, actionResult); },
                "Thread was being aborted.");
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnResultExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnResultExecuted", actions[2]);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereContinuationThrowsUnhandledWithMultipleFilters()
        {
            // Arrange
            List<string> actions = new List<string>();
            string expectedExceptionMessage = "Some exception message.";
            Action continuation = delegate
            {
                actions.Add("Continuation");
                throw new Exception(expectedExceptionMessage);
            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting1");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted1");
                    Assert.NotNull(filterContext.Exception);
                    Assert.Equal(filterContext.Exception.Message, expectedExceptionMessage);
                }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting2");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted2");
                    Assert.NotNull(filterContext.Exception);
                    Assert.Equal(filterContext.Exception.Message, expectedExceptionMessage);
                }
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            List<IResultFilter> filters = new List<IResultFilter>() { filter1, filter2 };

            // Act
            Assert.Throws<Exception>(
                delegate { helper.PublicInvokeActionResultWithFilters(context, filters, actionResult); },
                expectedExceptionMessage);

            // Assert
            Assert.Equal(5, actions.Count);
            Assert.Equal("OnResultExecuting1", actions[0]);
            Assert.Equal("OnResultExecuting2", actions[1]);
            Assert.Equal("Continuation", actions[2]);
            Assert.Equal("OnResultExecuted2", actions[3]);
            Assert.Equal("OnResultExecuted1", actions[4]);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereContinuationThrowsHandledByEarlierFilter()
        {
            // Arrange
            List<string> actions = new List<string>();
            Exception exception = new Exception();
            Action continuation = delegate
            {
                actions.Add("Continuation");
                throw exception;
            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting1");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted1");
                    filterContext.ExceptionHandled = true;
                    Assert.Same(exception, filterContext.Exception);
                }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting2");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted2");
                    Assert.Same(exception, filterContext.Exception);
                }
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            List<IResultFilter> filters = new List<IResultFilter>() { filter1, filter2 };

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(context, filters, actionResult);

            // Assert
            Assert.Equal(5, actions.Count);
            Assert.Equal("OnResultExecuting1", actions[0]);
            Assert.Equal("OnResultExecuting2", actions[1]);
            Assert.Equal("Continuation", actions[2]);
            Assert.Equal("OnResultExecuted2", actions[3]);
            Assert.Equal("OnResultExecuted1", actions[4]);
            Assert.Same(exception, result.Exception);
            Assert.True(result.ExceptionHandled);
            Assert.Same(actionResult, result.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereContinuationThrowsHandledByLaterFilter()
        {
            // Arrange
            List<string> actions = new List<string>();
            Exception exception = new Exception();
            Action continuation = delegate
            {
                actions.Add("Continuation");
                throw exception;
            };
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting1");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted1");
                    Assert.True(filterContext.ExceptionHandled);
                }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting2");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted2");
                    Assert.Same(exception, filterContext.Exception);
                    filterContext.ExceptionHandled = true;
                }
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            List<IResultFilter> filters = new List<IResultFilter>() { filter1, filter2 };

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(context, filters, actionResult);

            // Assert
            Assert.Equal(5, actions.Count);
            Assert.Equal("OnResultExecuting1", actions[0]);
            Assert.Equal("OnResultExecuting2", actions[1]);
            Assert.Equal("Continuation", actions[2]);
            Assert.Equal("OnResultExecuted2", actions[3]);
            Assert.Equal("OnResultExecuted1", actions[4]);
            Assert.Same(exception, result.Exception);
            Assert.True(result.ExceptionHandled);
            Assert.Same(actionResult, result.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereCancelled()
        {
            // Arrange
            bool wasCalled = false;
            MethodInfo mi = typeof(object).GetMethod("ToString");
            object[] paramValues = new object[0];
            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    Assert.False(wasCalled);
                    wasCalled = true;
                    filterContext.Cancel = true;
                },
            };
            Action continuation = delegate
            {
                Assert.True(false, "The continuation should not be called.");
            };
            ActionResult actionResult = new ContinuationResult(continuation);

            Mock<ResultExecutingContext> mockResultExecutingContext = new Mock<ResultExecutingContext>() { DefaultValue = DefaultValue.Mock };
            mockResultExecutingContext.Setup(c => c.Result).Returns(actionResult);
            List<IResultFilter> filters = new List<IResultFilter>() { filter, };
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(mockResultExecutingContext.Object, filters, actionResult);

            // Assert
            Assert.True(wasCalled);
            Assert.Null(result.Exception);
            Assert.True(result.Canceled);
            Assert.Same(actionResult, result.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereCancelledByEarlierFilter()
        {
            // Arrange
            List<string> actions = new List<string>();
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting1");
                    filterContext.Cancel = true;
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted1");
                }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting2");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted2");
                }
            };
            Action continuation = delegate
            {
                actions.Add("Continuation");
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            List<IResultFilter> filters = new List<IResultFilter>() { filter1, filter2 };

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(context, filters, actionResult);

            // Assert
            string action = Assert.Single(actions);
            Assert.Equal("OnResultExecuting1", action);
            Assert.Null(result.Exception);
            Assert.True(result.Canceled);
            Assert.Same(actionResult, result.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWhereCancelledByLaterFilter()
        {
            // Arrange
            List<string> actions = new List<string>();
            ActionFilterImpl filter1 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting1");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted1");
                    Assert.True(filterContext.Canceled);
                }
            };
            ActionFilterImpl filter2 = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    actions.Add("OnResultExecuting2");
                    filterContext.Cancel = true;
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    actions.Add("OnResultExecuted2");
                }
            };
            Action continuation = delegate
            {
                actions.Add("Continuation");
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ControllerBase controller = new Mock<ControllerBase>().Object;
            ControllerContext context = GetControllerContext(controller);
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();
            List<IResultFilter> filters = new List<IResultFilter>() { filter1, filter2 };

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(context, filters, actionResult);

            // Assert
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnResultExecuting1", actions[0]);
            Assert.Equal("OnResultExecuting2", actions[1]);
            Assert.Equal("OnResultExecuted1", actions[2]);
            Assert.Null(result.Exception);
            Assert.True(result.Canceled);
            Assert.Same(actionResult, result.Result);
        }

        [Fact]
        public void InvokeActionResultWithFiltersWithNormalControlFlow()
        {
            // Arrange
            List<string> actions = new List<string>();
            Action continuation = delegate
            {
                actions.Add("Continuation");
            };
            ActionResult actionResult = new ContinuationResult(continuation);
            ActionFilterImpl filter = new ActionFilterImpl()
            {
                OnResultExecutingImpl = delegate(ResultExecutingContext filterContext)
                {
                    Assert.Same(actionResult, filterContext.Result);
                    Assert.False(filterContext.Cancel);
                    actions.Add("OnResultExecuting");
                },
                OnResultExecutedImpl = delegate(ResultExecutedContext filterContext)
                {
                    Assert.Same(actionResult, filterContext.Result);
                    Assert.False(filterContext.Canceled);
                    Assert.Null(filterContext.Exception);
                    Assert.False(filterContext.ExceptionHandled);
                    actions.Add("OnResultExecuted");
                }
            };
            Mock<ResultExecutingContext> mockResultExecutingContext = new Mock<ResultExecutingContext>();
            mockResultExecutingContext.Setup(c => c.Result).Returns(actionResult);
            List<IResultFilter> filters = new List<IResultFilter>() { filter, };
            ControllerActionInvokerHelper helper = new ControllerActionInvokerHelper();

            // Act
            ResultExecutedContext result = helper.PublicInvokeActionResultWithFilters(mockResultExecutingContext.Object, filters, actionResult);

            // Assert
            Assert.Equal(3, actions.Count);
            Assert.Equal("OnResultExecuting", actions[0]);
            Assert.Equal("Continuation", actions[1]);
            Assert.Equal("OnResultExecuted", actions[2]);
            Assert.Same(result.Result, actionResult);
        }

        [Fact]
        public void InvokeMethodCallsOverriddenCreateActionResult()
        {
            // Arrange
            CustomResultInvokerController controller = new CustomResultInvokerController();
            ControllerContext context = GetControllerContext(controller);
            CustomResultInvoker helper = new CustomResultInvoker();
            MethodInfo mi = typeof(CustomResultInvokerController).GetMethod("ReturnCustomResult");
            ReflectedActionDescriptor ad = new ReflectedActionDescriptor(mi, "ReturnCustomResult", new Mock<ControllerDescriptor>().Object);
            IDictionary<string, object> parameters = new Dictionary<string, object>();

            // Act
            ActionResult actionResult = helper.PublicInvokeActionMethod(context, ad, parameters);

            // Assert (arg got passed to method + back correctly)
            CustomResult customResult = Assert.IsType<CustomResult>(actionResult);
            Assert.Equal("abc123", customResult.ReturnValue);
        }

        [Fact]
        public void FindAction_MultipleMethodsSameActionOneWithRouteAttributeAndRouteWasMatched_ReturnsMethodWithRoutingAttribute()
        {
            // Arrange
            Type controllerType = typeof(WithRoutingAttributeController);
            ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            var context = new ControllerContext();
            context.RouteData = new RouteData();
            context.RouteData.Route = DirectRouteTestHelpers.BuildDirectRouteFromMethod<WithRoutingAttributeController>(c => c.Action());
            context.RouteData.AddDirectRouteMatches();

            var actionInvoker = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor actionDescriptor = actionInvoker.PublicFindAction(context, controllerDescriptor, actionName: null);

            var matchedMethod = ((ReflectedActionDescriptor)actionDescriptor).MethodInfo;

            // Assert
            Assert.Equal(typeof(WithRoutingAttributeController).GetMethod("Action"), matchedMethod);
        }

        [Fact]
        public void FindAction_ControllerLevelDirectRoute_FindsMatch()
        {
            // Arrange
            Type controllerType = typeof(AttributeRoutingOnTheController);
            ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            var context = new ControllerContext();
            context.RouteData = new RouteData();
            context.RouteData.Route = DirectRouteTestHelpers.BuildDirectRouteFromController<AttributeRoutingOnTheController>();

            // Simulate a match that binds the action parameter
            context.RouteData.AddDirectRouteMatches((r, rd) => { rd.Values.Add("action", "Action1"); return true; });

            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor actionDescriptor = invoker.PublicFindAction(context, controllerDescriptor, actionName: null);

            var matchedMethod = ((ReflectedActionDescriptor)actionDescriptor).MethodInfo;

            // Assert
            Assert.Equal(typeof(AttributeRoutingOnTheController).GetMethod("Action1"), matchedMethod);
        }

        [Fact]
        public void FindAction_ControllerLevelDirectRoute_NoMatch()
        {
            // Arrange
            Type controllerType = typeof(AttributeRoutingOnTheController);
            ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            var context = new ControllerContext();
            context.RouteData = new RouteData();
            context.RouteData.Route = DirectRouteTestHelpers.BuildDirectRouteFromController<AttributeRoutingOnTheController>();

            // Simulate a match that binds the action parameter
            context.RouteData.AddDirectRouteMatches((r, rd) => { rd.Values.Add("action", "Action3"); return true; });

            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor actionDescriptor = invoker.PublicFindAction(context, controllerDescriptor, actionName: null);

            // Assert
            Assert.Null(actionDescriptor);
        }

        [Fact]
        public void FindAction_ControllerLevelDirectRoute_AmbiguousMatch()
        {
            // Arrange
            Type controllerType = typeof(AttributeRoutingOnTheController);
            ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            var context = new ControllerContext();
            context.RouteData = new RouteData();
            context.RouteData.Route = DirectRouteTestHelpers.BuildDirectRouteFromController<AttributeRoutingOnTheController>();

            // Simulate a match that binds the action parameter
            context.RouteData.AddDirectRouteMatches((r, rd) => { rd.Values.Add("action", "Action2"); return true; });

            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper();

            // Act & Assert
            Assert.Throws<AmbiguousMatchException>(() => invoker.PublicFindAction(context, controllerDescriptor, actionName: null));
        }

        [Fact]
        public void FindActionMethod_MultipleMethodsSameActionOneWithRouteAttributeAndRouteWasMatched_ReturnsMethodWithRoutingAttribute()
        {
            // Arrange
            Type controllerType = typeof(WithRoutingAttributeController);
            ControllerDescriptor controllerDescriptor = new ReflectedControllerDescriptor(controllerType);

            var context = new ControllerContext();
            context.RouteData = new RouteData();
            context.RouteData.Route = DirectRouteTestHelpers.BuildDirectRouteFromMethod<WithRoutingAttributeController>(c => c.Action());
            context.RouteData.AddDirectRouteMatches();

            ControllerActionInvokerHelper invoker = new ControllerActionInvokerHelper();

            // Act
            ActionDescriptor actionDescriptor = invoker.PublicFindAction(context, controllerDescriptor, actionName: null);
            MethodInfo matchedMethod = ((ReflectedActionDescriptor)actionDescriptor).MethodInfo;

            // Assert
            Assert.Equal("Action", matchedMethod.Name);
        }

        private static ControllerContext GetControllerContext(ControllerBase controller)
        {
            return GetControllerContext(controller, null);
        }

        private static ControllerContext GetControllerContext(ControllerBase controller, IDictionary<string, object> values, Action validateInputCallback = null)
        {
            SimpleValueProvider valueProvider = new SimpleValueProvider();
            controller.ValueProvider = valueProvider;
            if (values != null)
            {
                foreach (var entry in values)
                {
                    valueProvider[entry.Key] = entry.Value;
                }
            }

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupGet(c => c.RouteData).Returns(new RouteData());
            mockControllerContext.SetupGet(c => c.HttpContext.Session).Returns((HttpSessionStateBase)null);
            mockControllerContext.SetupProperty(c => c.HttpContext.User);

            mockControllerContext.Setup(c => c.HttpContext.Request.ValidateInput()).Callback(() =>
            {
                if (!controller.ValidateRequest)
                {
                    Assert.True(false, "ValidateRequest() should not be called if the controller opted out.");
                }
                if (validateInputCallback != null)
                {
                    // signal to caller that ValidateInput was called
                    validateInputCallback();
                }
            });

            mockControllerContext.Setup(c => c.Controller).Returns(controller);
            return mockControllerContext.Object;
        }

        private class ActionFilterImpl : IActionFilter, IResultFilter
        {
            public Action<ActionExecutingContext> OnActionExecutingImpl { get; set; }

            public void OnActionExecuting(ActionExecutingContext filterContext)
            {
                OnActionExecutingImpl(filterContext);
            }

            public Action<ActionExecutedContext> OnActionExecutedImpl { get; set; }

            public void OnActionExecuted(ActionExecutedContext filterContext)
            {
                OnActionExecutedImpl(filterContext);
            }

            public Action<ResultExecutingContext> OnResultExecutingImpl { get; set; }

            public void OnResultExecuting(ResultExecutingContext filterContext)
            {
                OnResultExecutingImpl(filterContext);
            }

            public Action<ResultExecutedContext> OnResultExecutedImpl { get; set; }

            public void OnResultExecuted(ResultExecutedContext filterContext)
            {
                OnResultExecutedImpl(filterContext);
            }
        }

        // This controller serves only to test vanilla method invocation - nothing exciting here
        private class BasicMethodInvokeController : Controller
        {
            public ActionResult ReturnsRenderView(object viewItem)
            {
                return View("ReturnsRenderView", viewItem);
            }
        }

        private class BlankController : Controller
        {
        }

        private sealed class CustomResult : ActionResult
        {
            public object ReturnValue { get; set; }

            public override void ExecuteResult(ControllerContext context)
            {
                throw new NotImplementedException();
            }
        }

        private sealed class CustomResultInvokerController : Controller
        {
            public object ReturnCustomResult()
            {
                return "abc123";
            }
        }

        private sealed class CustomResultInvoker : ControllerActionInvokerHelper
        {
            protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
            {
                return new CustomResult
                {
                    ReturnValue = actionReturnValue
                };
            }
        }

        private class ContinuationController : Controller
        {
            private Func<ActionResult> _continuation;

            public ContinuationController(Func<ActionResult> continuation)
            {
                _continuation = continuation;
            }

            public ActionResult Go()
            {
                return _continuation();
            }

            public static MethodInfo GoMethod
            {
                get { return typeof(ContinuationController).GetMethod("Go"); }
            }
        }

        private class ContinuationResult : ActionResult
        {
            private Action _continuation;

            public ContinuationResult(Action continuation)
            {
                _continuation = continuation;
            }

            public override void ExecuteResult(ControllerContext context)
            {
                _continuation();
            }
        }

        private class EmptyController : Controller
        {
        }

        // This controller serves to test the default action method matching mechanism
        private class FindMethodController : Controller
        {
            public ActionResult ValidActionMethod()
            {
                return null;
            }

            [NonAction]
            public virtual ActionResult NonActionMethod()
            {
                return null;
            }

            [NonAction]
            public ActionResult DerivedIsActionMethod()
            {
                return null;
            }

            public ActionResult MethodOverloaded()
            {
                return null;
            }

            public ActionResult MethodOverloaded(string s)
            {
                return null;
            }

            public void WrongReturnType()
            {
            }

            protected ActionResult ProtectedMethod()
            {
                return null;
            }

            private ActionResult PrivateMethod()
            {
                return null;
            }

            internal ActionResult InternalMethod()
            {
                return null;
            }

            public override string ToString()
            {
                // originally defined on Object
                return base.ToString();
            }

            public ActionResult Property
            {
                get { return null; }
            }

#pragma warning disable 0067
            // CS0067: Event declared but never used. We use reflection to access this member.
            public event EventHandler Event;
#pragma warning restore 0067
        }

        private class DerivedFindMethodController : FindMethodController
        {
            public override ActionResult NonActionMethod()
            {
                return base.NonActionMethod();
            }

            // FindActionMethod() should accept this as a valid method since [NonAction] doesn't appear
            // in its inheritance chain.
            public new ActionResult DerivedIsActionMethod()
            {
                return base.DerivedIsActionMethod();
            }
        }

        // Similar to FindMethodController, but tests generics support specifically
        private class GenericFindMethodController<T> : Controller
        {
            public ActionResult ClosedGenericMethod(T t)
            {
                return null;
            }

            public ActionResult OpenGenericMethod<U>(U t)
            {
                return null;
            }
        }

        // Allows for testing parameter conversions, etc.
        private class ParameterTestingController : Controller
        {
            public ParameterTestingController()
            {
                Values = new Dictionary<string, object>();
            }

            public IDictionary<string, object> Values { get; private set; }

            public void Foo(string foo, string bar, string baz)
            {
                Values["foo"] = foo;
                Values["bar"] = bar;
                Values["baz"] = baz;
            }

            public void HasOutParam(out string foo)
            {
                foo = null;
            }

            public void HasRefParam(ref string foo)
            {
            }

            public void Parameterless()
            {
            }

            public void TakesInt(int id)
            {
                Values["id"] = id;
            }

            public ActionResult TakesNullableInt(int? id)
            {
                Values["id"] = id;
                return null;
            }

            public void TakesString(string id)
            {
            }

            public void TakesDateTime(DateTime id)
            {
            }
        }

        // Provides access to the protected members of ControllerActionInvoker
        public class ControllerActionInvokerHelper : ControllerActionInvoker
        {
            public ControllerActionInvokerHelper()
            {
                // set instance caches to prevent modifying global test application state
                DescriptorCache = new ControllerDescriptorCache();
            }

            public ControllerActionInvokerHelper(params object[] filters)
                : base(filters)
            {
                // set instance caches to prevent modifying global test application state
                DescriptorCache = new ControllerDescriptorCache();
            }

            public virtual ActionResult PublicCreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
            {
                return base.CreateActionResult(controllerContext, actionDescriptor, actionReturnValue);
            }

            protected override ActionResult CreateActionResult(ControllerContext controllerContext, ActionDescriptor actionDescriptor, object actionReturnValue)
            {
                return PublicCreateActionResult(controllerContext, actionDescriptor, actionReturnValue);
            }

            public virtual ActionDescriptor PublicFindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
            {
                return base.FindAction(controllerContext, controllerDescriptor, actionName);
            }

            protected override ActionDescriptor FindAction(ControllerContext controllerContext, ControllerDescriptor controllerDescriptor, string actionName)
            {
                return PublicFindAction(controllerContext, controllerDescriptor, actionName);
            }

            public virtual ControllerDescriptor PublicGetControllerDescriptor(ControllerContext controllerContext)
            {
                return base.GetControllerDescriptor(controllerContext);
            }

            protected override ControllerDescriptor GetControllerDescriptor(ControllerContext controllerContext)
            {
                return PublicGetControllerDescriptor(controllerContext);
            }

            public virtual FilterInfo PublicGetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return base.GetFilters(controllerContext, actionDescriptor);
            }

            protected override FilterInfo GetFilters(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return PublicGetFilters(controllerContext, actionDescriptor);
            }

            public virtual object PublicGetParameterValue(ControllerContext controllerContext, ParameterDescriptor parameterDescriptor)
            {
                return base.GetParameterValue(controllerContext, parameterDescriptor);
            }

            protected override object GetParameterValue(ControllerContext controllerContext, ParameterDescriptor parameterDescriptor)
            {
                return PublicGetParameterValue(controllerContext, parameterDescriptor);
            }

            public virtual IDictionary<string, object> PublicGetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return base.GetParameterValues(controllerContext, actionDescriptor);
            }

            protected override IDictionary<string, object> GetParameterValues(ControllerContext controllerContext, ActionDescriptor actionDescriptor)
            {
                return PublicGetParameterValues(controllerContext, actionDescriptor);
            }

            public virtual ActionResult PublicInvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
            {
                return base.InvokeActionMethod(controllerContext, actionDescriptor, parameters);
            }

            protected override ActionResult InvokeActionMethod(ControllerContext controllerContext, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
            {
                return PublicInvokeActionMethod(controllerContext, actionDescriptor, parameters);
            }

            public virtual ActionExecutedContext PublicInvokeActionMethodWithFilters(ControllerContext controllerContext, IList<IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
            {
                return base.InvokeActionMethodWithFilters(controllerContext, filters, actionDescriptor, parameters);
            }

            protected override ActionExecutedContext InvokeActionMethodWithFilters(ControllerContext controllerContext, IList<IActionFilter> filters, ActionDescriptor actionDescriptor, IDictionary<string, object> parameters)
            {
                return PublicInvokeActionMethodWithFilters(controllerContext, filters, actionDescriptor, parameters);
            }

            public virtual void PublicInvokeActionResult(ControllerContext controllerContext, ActionResult actionResult)
            {
                base.InvokeActionResult(controllerContext, actionResult);
            }

            protected override void InvokeActionResult(ControllerContext controllerContext, ActionResult actionResult)
            {
                PublicInvokeActionResult(controllerContext, actionResult);
            }

            public virtual ResultExecutedContext PublicInvokeActionResultWithFilters(ControllerContext controllerContext, IList<IResultFilter> filters, ActionResult actionResult)
            {
                return base.InvokeActionResultWithFilters(controllerContext, filters, actionResult);
            }

            protected override ResultExecutedContext InvokeActionResultWithFilters(ControllerContext controllerContext, IList<IResultFilter> filters, ActionResult actionResult)
            {
                return PublicInvokeActionResultWithFilters(controllerContext, filters, actionResult);
            }

            public virtual AuthorizationContext PublicInvokeAuthorizationFilters(ControllerContext controllerContext, IList<IAuthorizationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return base.InvokeAuthorizationFilters(controllerContext, filters, actionDescriptor);
            }

            protected override AuthorizationContext InvokeAuthorizationFilters(ControllerContext controllerContext, IList<IAuthorizationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return PublicInvokeAuthorizationFilters(controllerContext, filters, actionDescriptor);
            }

            public virtual AuthenticationContext PublicInvokeAuthenticationFilters(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return base.InvokeAuthenticationFilters(controllerContext, filters, actionDescriptor);
            }

            protected override AuthenticationContext InvokeAuthenticationFilters(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor)
            {
                return PublicInvokeAuthenticationFilters(controllerContext, filters, actionDescriptor);
            }

            public virtual AuthenticationChallengeContext PublicInvokeAuthenticationFiltersChallenge(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor, ActionResult result)
            {
                return base.InvokeAuthenticationFiltersChallenge(controllerContext, filters, actionDescriptor, result);
            }

            protected override AuthenticationChallengeContext InvokeAuthenticationFiltersChallenge(ControllerContext controllerContext, IList<IAuthenticationFilter> filters, ActionDescriptor actionDescriptor, ActionResult result)
            {
                return PublicInvokeAuthenticationFiltersChallenge(controllerContext, filters, actionDescriptor, result);
            }

            public virtual ExceptionContext PublicInvokeExceptionFilters(ControllerContext controllerContext, IList<IExceptionFilter> filters, Exception exception)
            {
                return base.InvokeExceptionFilters(controllerContext, filters, exception);
            }

            protected override ExceptionContext InvokeExceptionFilters(ControllerContext controllerContext, IList<IExceptionFilter> filters, Exception exception)
            {
                return PublicInvokeExceptionFilters(controllerContext, filters, exception);
            }
        }

        public class AuthorizationFilterHelper : IAuthorizationFilter
        {
            private IList<AuthorizationFilterHelper> _callQueue;
            public ActionResult ShortCircuitResult;

            public AuthorizationFilterHelper(IList<AuthorizationFilterHelper> callQueue)
            {
                _callQueue = callQueue;
            }

            public void OnAuthorization(AuthorizationContext filterContext)
            {
                _callQueue.Add(this);
                if (ShortCircuitResult != null)
                {
                    filterContext.Result = ShortCircuitResult;
                }
            }
        }

        public class AuthenticationFilterHelper : IAuthenticationFilter
        {
            private IList<AuthenticationFilterHelper> _callQueue;
            public ActionResult ShortCircuitResult;
            public IPrincipal Principal;

            public AuthenticationFilterHelper(IList<AuthenticationFilterHelper> callQueue)
            {
                _callQueue = callQueue;
            }

            public void OnAuthentication(AuthenticationContext filterContext)
            {
                _callQueue.Add(this);
                if (ShortCircuitResult != null)
                {
                    filterContext.Result = ShortCircuitResult;
                }
                if (Principal != null)
                {
                    filterContext.Principal = Principal;
                }
            }

            public void OnAuthenticationChallenge(AuthenticationChallengeContext filterContext)
            {
                _callQueue.Add(this);
            }
        }

        public class ExceptionFilterHelper : IExceptionFilter
        {
            private IList<ExceptionFilterHelper> _callQueue;
            public bool ShouldHandleException;
            public ExceptionContext ContextPassed;

            public ExceptionFilterHelper(IList<ExceptionFilterHelper> callQueue)
            {
                _callQueue = callQueue;
            }

            public void OnException(ExceptionContext filterContext)
            {
                _callQueue.Add(this);
                if (ShouldHandleException)
                {
                    filterContext.ExceptionHandled = true;
                }
                ContextPassed = filterContext;
            }
        }

        private class CustomConverterController : Controller
        {
            public void ParameterWithoutBindAttribute([PredicateReflector] string someParam)
            {
            }

            public void ParameterHasBindAttribute([Bind(Include = "foo"), PredicateReflector] string someParam)
            {
            }

            public void ParameterHasDefaultValueAttribute([DefaultValue(42)] int foo)
            {
            }

            public void ParameterHasFieldPrefix([Bind(Prefix = "bar")] string foo)
            {
            }

            public void ParameterHasNullFieldPrefix([Bind(Include = "whatever")] string foo)
            {
            }

            public void ParameterHasEmptyFieldPrefix([Bind(Prefix = "")] MySimpleModel foo)
            {
            }

            public void ParameterHasNoPrefixAndComplexType(MySimpleModel foo)
            {
            }

            public void ParameterHasPrefixAndComplexType([Bind(Prefix = "badprefix")] MySimpleModel foo)
            {
            }

            public void ParameterHasNoConverters(string foo)
            {
            }

            public void ParameterHasOneConverter([MyCustomConverter] string foo)
            {
            }

            public void ParameterHasTwoConverters([MyCustomConverter, MyCustomConverter] string foo)
            {
            }
        }

        public class MySimpleModel
        {
            public int IntProp { get; set; }
            public string StringProp { get; set; }
        }

        [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = true, Inherited = false)]
        private class PredicateReflectorAttribute : CustomModelBinderAttribute
        {
            public override IModelBinder GetBinder()
            {
                return new MyConverter();
            }

            private class MyConverter : IModelBinder
            {
                public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
                {
                    string s = String.Format("foo={0}&bar={1}", bindingContext.PropertyFilter("foo"), bindingContext.PropertyFilter("bar"));
                    return s;
                }
            }
        }

        [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = true, Inherited = false)]
        private class MyCustomConverterAttribute : CustomModelBinderAttribute
        {
            public override IModelBinder GetBinder()
            {
                return new MyConverter();
            }

            private class MyConverter : IModelBinder
            {
                public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
                {
                    string s = bindingContext.ModelName + "_" + bindingContext.ModelType.Name;
                    return s;
                }
            }
        }

        // helper class for making sure that we're performing culture-invariant string conversions
        public class CultureReflector : IFormattable
        {
            string IFormattable.ToString(string format, IFormatProvider formatProvider)
            {
                CultureInfo cInfo = (CultureInfo)formatProvider;
                return cInfo.ThreeLetterISOLanguageName;
            }
        }

        private sealed class ThreadCurrentPrincipalContext : IDisposable
        {
            private readonly IPrincipal _originalPrincipal;

            private bool _disposed;

            public ThreadCurrentPrincipalContext()
            {
                _originalPrincipal = Thread.CurrentPrincipal;
            }

            public void Dispose()
            {
                if (!_disposed)
                {
                    Thread.CurrentPrincipal = _originalPrincipal;
                    _disposed = true;
                }
            }
        }

        private class WithRoutingAttributeController : Controller
        {
            [Route("route")]
            [ActionName("Action")] // to make things confusing
            public void ActionWithoutRoute()
            {
            }

            [Route("route")]
            public void Action()
            {
            }
        }

        [Route("controller/{action}")]
        private class AttributeRoutingOnTheController : Controller
        {
            public void Action1()
            {
            }

            public void Action2()
            {
            }

            public void Action2(string name)
            {
            }
        }

        private class MatchAttribute : ActionMethodSelectorAttribute
        {
            private bool _match;

            public MatchAttribute(bool match)
            {
                _match = match;
            }

            public override bool IsValidForRequest(ControllerContext controllerContext, MethodInfo methodInfo)
            {
                return _match;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerBaseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Routing;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ControllerBaseTest
    {
        [Fact]
        public void ExecuteCallsControllerBaseExecute()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(HttpContextHelpers.GetMockHttpContext().Object, new RouteData());

            Mock<ControllerBaseHelper> mockController = new Mock<ControllerBaseHelper>() { CallBase = true };
            mockController.Setup(c => c.PublicInitialize(requestContext)).Verifiable();
            mockController.Setup(c => c.PublicExecuteCore()).Verifiable();
            IController controller = mockController.Object;

            // Act
            controller.Execute(requestContext);

            // Assert
            mockController.Verify();
        }

        [Fact]
        public void ExecuteThrowsIfCalledTwice()
        {
            // Arrange
            EmptyControllerBase controller = new EmptyControllerBase();
            RequestContext requestContext = new RequestContext(HttpContextHelpers.GetMockHttpContext().Object, new RouteData());

            // Act
            ((IController)controller).Execute(requestContext); // first call
            Assert.Throws<InvalidOperationException>(
                delegate
                {
                    ((IController)controller).Execute(requestContext); // second call
                },
                @"A single instance of controller 'System.Web.Mvc.Test.ControllerBaseTest+EmptyControllerBase' cannot be used to handle multiple requests. If a custom controller factory is in use, make sure that it creates a new instance of the controller for each request.");

            // Assert
            Assert.Equal(1, controller.NumTimesExecuteCoreCalled);
        }

        [Fact]
        public void ExecuteThrowsIfRequestContextIsNull()
        {
            // Arrange
            IController controller = new ControllerBaseHelper();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { controller.Execute(null); }, "requestContext");
        }

        [Fact]
        public void ExecuteThrowsIfRequestContextHttpContextIsNull()
        {
            //Arrange
            IController controller = new ControllerBaseHelper();

            //Act & Assert
            Assert.Throws<ArgumentException>(
                delegate { controller.Execute(new Mock<RequestContext>().Object); }, "Cannot execute Controller with a null HttpContext.\r\nParameter name: requestContext");
        }

        [Fact]
        public void InitializeSetsControllerContext()
        {
            // Arrange
            ControllerBaseHelper helper = new ControllerBaseHelper();
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());

            // Act
            helper.PublicInitialize(requestContext);

            // Assert
            Assert.Same(requestContext.HttpContext, helper.ControllerContext.HttpContext);
            Assert.Same(requestContext.RouteData, helper.ControllerContext.RouteData);
            Assert.Same(helper, helper.ControllerContext.Controller);
        }

        [Fact]
        public void TempDataProperty()
        {
            // Arrange
            ControllerBase controller = new ControllerBaseHelper();

            // Act & Assert
            MemberHelper.TestPropertyWithDefaultInstance(controller, "TempData", new TempDataDictionary());
        }

        [Fact]
        public void TempDataReturnsParentTempDataWhenInChildRequest()
        {
            // Arrange
            TempDataDictionary tempData = new TempDataDictionary();
            ViewContext viewContext = new ViewContext { TempData = tempData };
            RouteData routeData = new RouteData();
            routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = viewContext;
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, routeData);
            ControllerBaseHelper controller = new ControllerBaseHelper();
            controller.PublicInitialize(requestContext);

            // Act
            TempDataDictionary result = controller.TempData;

            // Assert
            Assert.Same(result, tempData);
        }

        [Fact]
        public void ValidateRequestProperty()
        {
            // Arrange
            ControllerBase controller = new ControllerBaseHelper();

            // Act & assert
            MemberHelper.TestBooleanProperty(controller, "ValidateRequest", true /* initialValue */, false /* testDefaultValue */);
        }

        [Fact]
        public void ValueProviderProperty()
        {
            // Arrange
            ControllerBase controller = new ControllerBaseHelper();
            IValueProvider valueProvider = new SimpleValueProvider();

            // Act & assert
            ValueProviderFactory[] originalFactories = ValueProviderFactories.Factories.ToArray();
            try
            {
                ValueProviderFactories.Factories.Clear();
                MemberHelper.TestPropertyWithDefaultInstance(controller, "ValueProvider", valueProvider);
            }
            finally
            {
                foreach (ValueProviderFactory factory in originalFactories)
                {
                    ValueProviderFactories.Factories.Add(factory);
                }
            }
        }

        [Fact]
        public void ViewDataProperty()
        {
            // Arrange
            ControllerBase controller = new ControllerBaseHelper();

            // Act & Assert
            MemberHelper.TestPropertyWithDefaultInstance(controller, "ViewData", new ViewDataDictionary());
        }

        [Fact]
        public void ViewBagProperty_ReflectsViewData()
        {
            // Arrange
            ControllerBase controller = new ControllerBaseHelper();
            controller.ViewData["A"] = 1;

            // Act & Assert
            Assert.NotNull(controller.ViewBag);
            Assert.Equal(1, controller.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_ReflectsNewViewDataInstance()
        {
            // Arrange
            ControllerBase controller = new ControllerBaseHelper();
            controller.ViewData["A"] = 1;
            controller.ViewData = new ViewDataDictionary() { { "A", "bar" } };

            // Act & Assert
            Assert.Equal("bar", controller.ViewBag.A);
        }

        [Fact]
        public void ViewBag_PropagatesChangesToViewData()
        {
            // Arrange
            ControllerBase controller = new ControllerBaseHelper();
            controller.ViewData["A"] = 1;

            // Act
            controller.ViewBag.A = "foo";
            controller.ViewBag.B = 2;

            // Assert
            Assert.Equal("foo", controller.ViewData["A"]);
            Assert.Equal(2, controller.ViewData["B"]);
        }

        public class ControllerBaseHelper : ControllerBase
        {
            protected override void Initialize(RequestContext requestContext)
            {
                PublicInitialize(requestContext);
            }

            public virtual void PublicInitialize(RequestContext requestContext)
            {
                base.Initialize(requestContext);
            }

            protected override void ExecuteCore()
            {
                PublicExecuteCore();
            }

            public virtual void PublicExecuteCore()
            {
                throw new NotImplementedException();
            }
        }

        private class EmptyControllerBase : ControllerBase
        {
            public int NumTimesExecuteCoreCalled = 0;

            protected override void ExecuteCore()
            {
                NumTimesExecuteCoreCalled++;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerBuilderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using System.Web.SessionState;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ControllerBuilderTest
    {
        [Fact]
        public void ControllerBuilderReturnsDefaultControllerBuilderByDefault()
        {
            // Arrange
            ControllerBuilder cb = new ControllerBuilder();

            // Act
            IControllerFactory cf = cb.GetControllerFactory();

            // Assert
            Assert.IsType<DefaultControllerFactory>(cf);
        }

        [Fact]
        public void CreateControllerWithFactoryThatCannotBeCreatedThrows()
        {
            // Arrange
            ControllerBuilder cb = new ControllerBuilder();
            cb.SetControllerFactory(typeof(ControllerFactoryThrowsFromConstructor));

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate
                {
                    RequestContext reqContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
                    reqContext.RouteData.Values["controller"] = "foo";
                    MvcHandlerWithNoVersionHeader handler = new MvcHandlerWithNoVersionHeader(reqContext)
                    {
                        ControllerBuilder = cb
                    };
                    handler.ProcessRequest(reqContext.HttpContext);
                },
                "An error occurred when trying to create the IControllerFactory 'System.Web.Mvc.Test.ControllerBuilderTest+ControllerFactoryThrowsFromConstructor'. Make sure that the controller factory has a public parameterless constructor.");
        }

        [Fact]
        public void CreateControllerWithFactoryThatReturnsNullThrows()
        {
            // Arrange
            ControllerBuilder cb = new ControllerBuilder();
            cb.SetControllerFactory(typeof(ControllerFactoryReturnsNull));

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate
                {
                    RequestContext reqContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
                    reqContext.RouteData.Values["controller"] = "boo";
                    MvcHandlerWithNoVersionHeader handler = new MvcHandlerWithNoVersionHeader(reqContext)
                    {
                        ControllerBuilder = cb
                    };
                    handler.ProcessRequest(reqContext.HttpContext);
                },
                "The IControllerFactory 'System.Web.Mvc.Test.ControllerBuilderTest+ControllerFactoryReturnsNull' did not return a controller for the name 'boo'.");
        }

        [Fact]
        public void CreateControllerWithFactoryThatThrowsDoesNothingSpecial()
        {
            // Arrange
            ControllerBuilder cb = new ControllerBuilder();
            cb.SetControllerFactory(typeof(ControllerFactoryThrows));

            // Act
            Assert.Throws<Exception>(
                delegate
                {
                    RequestContext reqContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
                    reqContext.RouteData.Values["controller"] = "foo";
                    MvcHandlerWithNoVersionHeader handler = new MvcHandlerWithNoVersionHeader(reqContext)
                    {
                        ControllerBuilder = cb
                    };
                    handler.ProcessRequest(reqContext.HttpContext);
                },
                "ControllerFactoryThrows");
        }

        [Fact]
        public void CreateControllerWithFactoryInstanceReturnsInstance()
        {
            // Arrange
            ControllerBuilder cb = new ControllerBuilder();
            DefaultControllerFactory factory = new DefaultControllerFactory();
            cb.SetControllerFactory(factory);

            // Act
            IControllerFactory cf = cb.GetControllerFactory();

            // Assert
            Assert.Same(factory, cf);
        }

        [Fact]
        public void CreateControllerWithFactoryTypeReturnsValidType()
        {
            // Arrange
            ControllerBuilder cb = new ControllerBuilder();
            cb.SetControllerFactory(typeof(MockControllerFactory));

            // Act
            IControllerFactory cf = cb.GetControllerFactory();

            // Assert
            Assert.IsType<MockControllerFactory>(cf);
        }

        [Fact]
        public void SetControllerFactoryInstanceWithNullThrows()
        {
            ControllerBuilder cb = new ControllerBuilder();
            Assert.ThrowsArgumentNull(
                delegate { cb.SetControllerFactory((IControllerFactory)null); },
                "controllerFactory");
        }

        [Fact]
        public void SetControllerFactoryTypeWithNullThrows()
        {
            ControllerBuilder cb = new ControllerBuilder();
            Assert.ThrowsArgumentNull(
                delegate { cb.SetControllerFactory((Type)null); },
                "controllerFactoryType");
        }

        [Fact]
        public void SetControllerFactoryTypeWithNonFactoryTypeThrows()
        {
            ControllerBuilder cb = new ControllerBuilder();
            Assert.Throws<ArgumentException>(
                delegate { cb.SetControllerFactory(typeof(int)); },
                "The controller factory type 'System.Int32' must implement the IControllerFactory interface.\r\nParameter name: controllerFactoryType");
        }

        [Fact]
        public void DefaultControllerFactoryIsDefaultControllerFactory()
        {
            // Arrange
            ControllerBuilder builder = new ControllerBuilder();

            // Act
            IControllerFactory returnedControllerFactory = builder.GetControllerFactory();

            //Assert
            Assert.Equal(typeof(DefaultControllerFactory), returnedControllerFactory.GetType());
        }

        [Fact]
        public void SettingControllerFactoryReturnsSetFactory()
        {
            // Arrange
            ControllerBuilder builder = new ControllerBuilder();
            Mock<IControllerFactory> setFactory = new Mock<IControllerFactory>();

            // Act
            builder.SetControllerFactory(setFactory.Object);

            // Assert
            Assert.Same(setFactory.Object, builder.GetControllerFactory());
        }

        [Fact]
        public void ControllerBuilderGetControllerFactoryDelegatesToResolver()
        {
            //Arrange
            Mock<IControllerFactory> factory = new Mock<IControllerFactory>();
            Resolver<IControllerFactory> resolver = new Resolver<IControllerFactory> { Current = factory.Object };
            ControllerBuilder builder = new ControllerBuilder(resolver);

            //Act
            IControllerFactory result = builder.GetControllerFactory();

            //Assert
            Assert.Same(factory.Object, result);
        }

        public class ControllerFactoryThrowsFromConstructor : IControllerFactory
        {
            public ControllerFactoryThrowsFromConstructor()
            {
                throw new Exception("ControllerFactoryThrowsFromConstructor");
            }

            public IController CreateController(RequestContext context, string controllerName)
            {
                return null;
            }

            public SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
            {
                return SessionStateBehavior.Default;
            }

            public void ReleaseController(IController controller)
            {
            }
        }

        public class ControllerFactoryReturnsNull : IControllerFactory
        {
            public IController CreateController(RequestContext context, string controllerName)
            {
                return null;
            }

            public SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
            {
                return SessionStateBehavior.Default;
            }

            public void ReleaseController(IController controller)
            {
            }
        }

        public class ControllerFactoryThrows : IControllerFactory
        {
            public IController CreateController(RequestContext context, string controllerName)
            {
                throw new Exception("ControllerFactoryThrows");
            }

            public SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
            {
                return SessionStateBehavior.Default;
            }

            public void ReleaseController(IController controller)
            {
            }
        }

        public class MockControllerFactory : IControllerFactory
        {
            public IController CreateController(RequestContext context, string controllerName)
            {
                throw new NotImplementedException();
            }

            public SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
            {
                return SessionStateBehavior.Default;
            }

            public void ReleaseController(IController controller)
            {
            }
        }

        private sealed class MvcHandlerWithNoVersionHeader : MvcHandler
        {
            public MvcHandlerWithNoVersionHeader(RequestContext requestContext)
                : base(requestContext)
            {
            }

            protected internal override void AddVersionHeader(HttpContextBase httpContext)
            {
                // Don't try to set the version header for the unit tests
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Web.Routing;
using System.Web.TestUtil;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ControllerContextTest
    {
        [Fact]
        public void ConstructorThrowsIfControllerIsNull()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            Controller controller = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ControllerContext(requestContext, controller); }, "controller");
        }

        [Fact]
        public void ConstructorThrowsIfRequestContextIsNull()
        {
            // Arrange
            RequestContext requestContext = null;
            Controller controller = new Mock<Controller>().Object;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ControllerContext(requestContext, controller); }, "requestContext");
        }

        [Fact]
        public void ConstructorWithHttpContextAndRouteData()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            RouteData routeData = new RouteData();
            Controller controller = new Mock<Controller>().Object;

            // Act
            ControllerContext controllerContext = new ControllerContext(httpContext, routeData, controller);

            // Assert
            Assert.Equal(httpContext, controllerContext.HttpContext);
            Assert.Equal(routeData, controllerContext.RouteData);
            Assert.Equal(controller, controllerContext.Controller);
        }

        [Fact]
        public void ControllerProperty()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            RouteData routeData = new RouteData();
            Controller controller = new Mock<Controller>().Object;

            // Act
            ControllerContext controllerContext = new ControllerContext(httpContext, routeData, controller);

            // Assert
            Assert.Equal(controller, controllerContext.Controller);
        }

        [Fact]
        public void CopyConstructorSetsProperties()
        {
            // Arrange
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>();
            httpContext.Setup(c => c.Items).Returns(new Hashtable());

            RequestContext requestContext = new RequestContext(httpContext.Object, new RouteData());
            Controller controller = new Mock<Controller>().Object;
            var displayMode = new DefaultDisplayMode("test");

            ControllerContext innerControllerContext = new ControllerContext(requestContext, controller);
            innerControllerContext.DisplayMode = displayMode;

            // Act
            ControllerContext outerControllerContext = new SubclassedControllerContext(innerControllerContext);

            // Assert
            Assert.Equal(requestContext, outerControllerContext.RequestContext);
            Assert.Equal(controller, outerControllerContext.Controller);

            // We don't actually set DisplayMode but verify it is identical to the inner controller context.
            Assert.Equal(displayMode, outerControllerContext.DisplayMode);
        }

        [Fact]
        public void DisplayModeDelegatesToHttpContext()
        {
            // Arrange
            IDisplayMode testDisplayMode = new DefaultDisplayMode("test");
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>();
            httpContext.Setup(c => c.Items).Returns(new Hashtable());
            Controller controller = new Mock<Controller>().Object;
            ControllerContext controllerContext = new ControllerContext(httpContext.Object, new RouteData(), controller);
            ControllerContext controllerContextWithIdenticalContext = new ControllerContext(httpContext.Object, new RouteData(), controller);

            // Act
            controllerContext.DisplayMode = testDisplayMode;

            // Assert
            Assert.Same(testDisplayMode, controllerContext.DisplayMode);
            Assert.Same(testDisplayMode, controllerContextWithIdenticalContext.DisplayMode);
        }

        [Fact]
        public void CopyConstructorThrowsIfControllerContextIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new SubclassedControllerContext(null); }, "controllerContext");
        }

        [Fact]
        public void HttpContextPropertyGetSetBehavior()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            ControllerContext controllerContext = new ControllerContext();

            // Act & assert
            MemberHelper.TestPropertyValue(controllerContext, "HttpContext", httpContext);
        }

        [Fact]
        public void HttpContextPropertyReturnsEmptyHttpContextIfRequestContextNotPresent()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();

            // Act
            HttpContextBase httpContext = controllerContext.HttpContext;
            HttpContextBase httpContext2 = controllerContext.HttpContext;

            // Assert
            Assert.NotNull(httpContext);
            Assert.Equal(httpContext, httpContext2);
        }

        [Fact]
        public void HttpContextPropertyReturnsRequestContextHttpContextIfPresent()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            RouteData routeData = new RouteData();
            RequestContext requestContext = new RequestContext(httpContext, routeData);
            Controller controller = new Mock<Controller>().Object;

            // Act
            ControllerContext controllerContext = new ControllerContext(requestContext, controller);

            // Assert
            Assert.Equal(httpContext, controllerContext.HttpContext);
        }

        [Fact]
        public void RequestContextPropertyCreatesDummyHttpContextAndRouteDataIfNecessary()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext).Returns((HttpContextBase)null);
            mockControllerContext.Setup(c => c.RouteData).Returns((RouteData)null);
            ControllerContext controllerContext = mockControllerContext.Object;

            // Act
            RequestContext requestContext = controllerContext.RequestContext;
            RequestContext requestContext2 = controllerContext.RequestContext;

            // Assert
            Assert.Equal(requestContext, requestContext2);
            Assert.NotNull(requestContext.HttpContext);
            Assert.NotNull(requestContext.RouteData);
        }

        [Fact]
        public void RequestContextPropertyUsesExistingHttpContextAndRouteData()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            RouteData routeData = new RouteData();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext).Returns(httpContext);
            mockControllerContext.Setup(c => c.RouteData).Returns(routeData);
            ControllerContext controllerContext = mockControllerContext.Object;

            // Act
            RequestContext requestContext = controllerContext.RequestContext;
            RequestContext requestContext2 = controllerContext.RequestContext;

            // Assert
            Assert.Equal(requestContext, requestContext2);
            Assert.Equal(httpContext, requestContext.HttpContext);
            Assert.Equal(routeData, requestContext.RouteData);
        }

        [Fact]
        public void RouteDataPropertyGetSetBehavior()
        {
            // Arrange
            RouteData routeData = new RouteData();
            ControllerContext controllerContext = new ControllerContext();

            // Act & assert
            MemberHelper.TestPropertyValue(controllerContext, "RouteData", routeData);
        }

        [Fact]
        public void RouteDataPropertyReturnsEmptyRouteDataIfRequestContextNotPresent()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();

            // Act
            RouteData routeData = controllerContext.RouteData;
            RouteData routeData2 = controllerContext.RouteData;

            // Assert
            Assert.Equal(routeData, routeData2);
            Assert.Empty(routeData.Values);
        }

        [Fact]
        public void RouteDataPropertyReturnsRequestContextRouteDataIfPresent()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            RouteData routeData = new RouteData();
            RequestContext requestContext = new RequestContext(httpContext, routeData);
            Controller controller = new Mock<Controller>().Object;

            // Act
            ControllerContext controllerContext = new ControllerContext(requestContext, controller);

            // Assert
            Assert.Equal(routeData, controllerContext.RouteData);
        }

        [Fact]
        public void IsChildActionReturnsFalseByDefault()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            RouteData routeData = new RouteData();
            RequestContext requestContext = new RequestContext(httpContext, routeData);
            Controller controller = new Mock<Controller>().Object;
            ControllerContext controllerContext = new ControllerContext(requestContext, controller);

            // Act
            bool result = controllerContext.IsChildAction;

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void IsChildActionReturnsTrueWhenRouteDataTokenIsSet()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            ViewContext viewContext = new ViewContext();
            RouteData routeData = new RouteData();
            routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = viewContext;
            RequestContext requestContext = new RequestContext(httpContext, routeData);
            Controller controller = new Mock<Controller>().Object;
            ControllerContext controllerContext = new ControllerContext(requestContext, controller);

            // Act
            bool result = controllerContext.IsChildAction;

            // Assert
            Assert.True(result);
            Assert.Same(viewContext, controllerContext.ParentActionViewContext);
        }

        public static ControllerContext CreateEmptyContext()
        {
            return new ControllerContext(new Mock<HttpContextBase>().Object, new RouteData(), new Mock<Controller>().Object);
        }

        private class SubclassedControllerContext : ControllerContext
        {
            public SubclassedControllerContext(ControllerContext controllerContext)
                : base(controllerContext)
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerDescriptorCacheTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ControllerDescriptorCacheTest
    {
        [Fact]
        public void GetDescriptorCaches()
        {
            // Arrange
            Type controllerType = typeof(object);
            ControllerDescriptorCache cache = new ControllerDescriptorCache();

            // Act
            ControllerDescriptor descriptor1 = cache.GetDescriptor(controllerType, () => new ReflectedControllerDescriptor(controllerType));
            ControllerDescriptor descriptor2 = cache.GetDescriptor(controllerType, () => new ReflectedControllerDescriptor(controllerType));

            // Assert
            Assert.Same(controllerType, descriptor1.ControllerType);
            Assert.Same(descriptor1, descriptor2);
        }

        [Fact]
        public void GetDescriptorWithArgumentCaches()
        {
            // Arrange
            Type controllerType = typeof(object);
            ControllerDescriptorCache cache = new ControllerDescriptorCache();
            object argument = new object();

            // Act
            ControllerDescriptor descriptor1 = cache.GetDescriptor(
                controllerType,
                (object innerState) =>
                {
                    Assert.Same(argument, innerState);
                    return new ReflectedControllerDescriptor(controllerType);
                },
                argument);
            ControllerDescriptor descriptor2 = cache.GetDescriptor(
                controllerType,
                (object innerState) =>
                {
                    Assert.Same(argument, innerState);
                    return new ReflectedControllerDescriptor(controllerType);
                },
                argument);

            // Assert
            Assert.Same(controllerType, descriptor1.ControllerType);
            Assert.Same(descriptor1, descriptor2);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ControllerDescriptorTest
    {
        [Fact]
        public void ControllerNamePropertyReturnsControllerTypeName()
        {
            // Arrange
            ControllerDescriptor cd = GetControllerDescriptor(typeof(object));

            // Act
            string name = cd.ControllerName;

            // Assert
            Assert.Equal("Object", name);
        }

        [Fact]
        public void ControllerNamePropertyReturnsControllerTypeNameWithoutControllerSuffix()
        {
            // Arrange
            Mock<Type> mockType = new Mock<Type>();
            mockType.Setup(t => t.Name).Returns("somecontroller");
            ControllerDescriptor cd = GetControllerDescriptor(mockType.Object);

            // Act
            string name = cd.ControllerName;

            // Assert
            Assert.Equal("some", name);
        }

        [Fact]
        public void GetCustomAttributesReturnsEmptyArrayOfAttributeType()
        {
            // Arrange
            ControllerDescriptor cd = GetControllerDescriptor();

            // Act
            ObsoleteAttribute[] attrs = (ObsoleteAttribute[])cd.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Empty(attrs);
        }

        [Fact]
        public void GetCustomAttributesThrowsIfAttributeTypeIsNull()
        {
            // Arrange
            ControllerDescriptor cd = GetControllerDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { cd.GetCustomAttributes(null /* attributeType */, true); }, "attributeType");
        }

        [Fact]
        public void GetCustomAttributesWithoutAttributeTypeCallsGetCustomAttributesWithAttributeType()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<ControllerDescriptor> mockDescriptor = new Mock<ControllerDescriptor>() { CallBase = true };
            mockDescriptor.Setup(d => d.GetCustomAttributes(typeof(object), true)).Returns(expected);
            ControllerDescriptor cd = mockDescriptor.Object;

            // Act
            object[] returned = cd.GetCustomAttributes(true /* inherit */);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetFilterAttributes_CallsGetCustomAttributes()
        {
            // Arrange
            var mockDescriptor = new Mock<ControllerDescriptor>() { CallBase = true };
            mockDescriptor.Setup(d => d.GetCustomAttributes(typeof(FilterAttribute), true)).Returns(new object[] { new Mock<FilterAttribute>().Object }).Verifiable();

            // Act
            var result = mockDescriptor.Object.GetFilterAttributes(true).ToList();

            // Assert
            mockDescriptor.Verify();
            Assert.Single(result);
        }

        [Fact]
        public void IsDefinedReturnsFalse()
        {
            // Arrange
            ControllerDescriptor cd = GetControllerDescriptor();

            // Act
            bool isDefined = cd.IsDefined(typeof(object), true);

            // Assert
            Assert.False(isDefined);
        }

        [Fact]
        public void IsDefinedThrowsIfAttributeTypeIsNull()
        {
            // Arrange
            ControllerDescriptor cd = GetControllerDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { cd.IsDefined(null /* attributeType */, true); }, "attributeType");
        }

        private static ControllerDescriptor GetControllerDescriptor()
        {
            return GetControllerDescriptor(null);
        }

        private static ControllerDescriptor GetControllerDescriptor(Type controllerType)
        {
            Mock<ControllerDescriptor> mockDescriptor = new Mock<ControllerDescriptor>() { CallBase = true };
            mockDescriptor.Setup(d => d.ControllerType).Returns(controllerType);
            return mockDescriptor.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerInstanceFilterProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ControllerInstanceFilterProviderTest
    {
        [Fact]
        public void GetFiltersWithNullControllerReturnsEmptyCollection()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var provider = new ControllerInstanceFilterProvider();

            // Act
            IEnumerable<Filter> result = provider.GetFilters(context, descriptor);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void GetFiltersWithControllerReturnsWrappedController()
        {
            // Arrange
            var controller = new Mock<ControllerBase>().Object;
            var context = new ControllerContext { Controller = controller };
            var descriptor = new Mock<ActionDescriptor>().Object;
            var provider = new ControllerInstanceFilterProvider();

            // Act
            IEnumerable<Filter> result = provider.GetFilters(context, descriptor);

            // Assert
            Filter filter = result.Single();
            Assert.Same(controller, filter.Instance);
            Assert.Equal(Int32.MinValue, filter.Order);
            Assert.Equal(FilterScope.First, filter.Scope);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ControllerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.IO;
using System.Reflection;
using System.Security.Principal;
using System.Text;
using System.Web.Mvc.Async;
using System.Web.Profile;
using System.Web.Routing;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;
using Moq.Protected;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ControllerTest
    {
        [Fact]
        public void ActionInvokerProperty()
        {
            // Arrange
            Controller controller = new EmptyController();

            // Act & Assert
            MemberHelper.TestPropertyWithDefaultInstance(controller, "ActionInvoker", new ControllerActionInvoker());
        }

        [Fact]
        public void ContentWithContentString()
        {
            // Arrange
            Controller controller = new EmptyController();
            string content = "Some content";

            // Act
            ContentResult result = controller.Content(content);

            // Assert
            Assert.Equal(content, result.Content);
        }

        [Fact]
        public void ContentWithContentStringAndContentType()
        {
            // Arrange
            Controller controller = new EmptyController();
            string content = "Some content";
            string contentType = "Some content type";

            // Act
            ContentResult result = controller.Content(content, contentType);

            // Assert
            Assert.Equal(content, result.Content);
            Assert.Equal(contentType, result.ContentType);
        }

        [Fact]
        public void ContentWithContentStringAndContentTypeAndEncoding()
        {
            // Arrange
            Controller controller = new EmptyController();
            string content = "Some content";
            string contentType = "Some content type";
            Encoding contentEncoding = Encoding.UTF8;

            // Act
            ContentResult result = controller.Content(content, contentType, contentEncoding);

            // Assert
            Assert.Equal(content, result.Content);
            Assert.Equal(contentType, result.ContentType);
            Assert.Same(contentEncoding, result.ContentEncoding);
        }

        [Fact]
        public void ContextProperty()
        {
            var controller = new EmptyController();
            MemberHelper.TestPropertyValue(controller, "ControllerContext", new Mock<ControllerContext>().Object);
        }

        [Fact]
        public void HttpContextProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.HttpContext);

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext).Returns(mockHttpContext.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockHttpContext.Object, c.HttpContext);
        }

        [Fact]
        public void HttpNotFound()
        {
            // Arrange
            var c = new EmptyController();

            // Act
            HttpNotFoundResult result = c.HttpNotFound();

            // Assert
            Assert.NotNull(result);
            Assert.Null(result.StatusDescription);
            Assert.Equal(404, result.StatusCode);
        }

        [Fact]
        public void HttpNotFoundWithNullStatusDescription()
        {
            // Arrange
            var c = new EmptyController();

            // Act
            HttpNotFoundResult result = c.HttpNotFound(statusDescription: null);

            // Assert
            Assert.NotNull(result);
            Assert.Null(result.StatusDescription);
            Assert.Equal(404, result.StatusCode);
        }

        [Fact]
        public void HttpNotFoundWithStatusDescription()
        {
            // Arrange
            var c = new EmptyController();

            // Act
            HttpNotFoundResult result = c.HttpNotFound(statusDescription: "I lost it");

            // Assert
            Assert.NotNull(result);
            Assert.Equal("I lost it", result.StatusDescription);
            Assert.Equal(404, result.StatusCode);
        }

        [Fact]
        public void ModelStateProperty()
        {
            // Arrange
            Controller controller = new EmptyController();

            // Act & assert
            Assert.Same(controller.ViewData.ModelState, controller.ModelState);
        }

        [Fact]
        public void ProfileProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Profile);

            Mock<ProfileBase> mockProfile = new Mock<ProfileBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Profile).Returns(mockProfile.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockProfile.Object, c.Profile);
        }

        [Fact]
        public void RequestProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpRequestBase> mockHttpRequest = new Mock<HttpRequestBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Request).Returns(mockHttpRequest.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockHttpRequest.Object, c.Request);
        }

        [Fact]
        public void ResponseProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpResponseBase> mockHttpResponse = new Mock<HttpResponseBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Response).Returns(mockHttpResponse.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockHttpResponse.Object, c.Response);
        }

        [Fact]
        public void ServerProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpServerUtilityBase> mockServerUtility = new Mock<HttpServerUtilityBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Server).Returns(mockServerUtility.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockServerUtility.Object, c.Server);
        }

        [Fact]
        public void SessionProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<HttpSessionStateBase> mockSessionState = new Mock<HttpSessionStateBase>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.Session).Returns(mockSessionState.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Same(mockSessionState.Object, c.Session);
        }

        [Fact]
        public void UrlProperty()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());

            // Act
            controller.PublicInitialize(requestContext);

            // Assert
            Assert.NotNull(controller.Url);
        }

        [Fact]
        public void UserProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            Mock<IPrincipal> mockUser = new Mock<IPrincipal>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.HttpContext.User).Returns(mockUser.Object);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(mockUser.Object, c.User);
        }

        [Fact]
        public void RouteDataProperty()
        {
            var c = new EmptyController();
            Assert.Null(c.Request);

            RouteData rd = new RouteData();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(cc => cc.Controller).Returns(c);
            mockControllerContext.Setup(cc => cc.RouteData).Returns(rd);

            c.ControllerContext = mockControllerContext.Object;
            Assert.Equal(rd, c.RouteData);
        }

        [Fact]
        public void ControllerMethodsDoNotHaveNonActionAttribute()
        {
            var methods = typeof(Controller).GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
            foreach (var method in methods)
            {
                var attrs = method.GetCustomAttributes(typeof(NonActionAttribute), true /* inherit */);
                Assert.True(attrs.Length == 0, "Methods on the Controller class should not be marked [NonAction]: " + method);
            }
        }

        [Fact]
        public void DisposeCallsProtectedDisposingMethod()
        {
            // Arrange
            Mock<Controller> mockController = new Mock<Controller>();
            mockController.Protected().Setup("Dispose", exactParameterMatch: true, args: true).Verifiable();
            Controller controller = mockController.Object;

            // Act
            controller.Dispose();

            // Assert
            mockController.Verify();
        }

        [Fact]
        public void ExecuteWithUnknownAction()
        {
            // Arrange
            UnknownActionController controller = new UnknownActionController();
            // We need a provider since Controller.Execute is called
            controller.TempDataProvider = new EmptyTempDataProvider();
            ControllerContext context = GetControllerContext("Foo");

            Mock<IActionInvoker> mockInvoker = new Mock<IActionInvoker>();
            mockInvoker.Setup(o => o.InvokeAction(context, "Foo")).Returns(false);
            controller.ActionInvoker = mockInvoker.Object;

            // Act
            ((IController)controller).Execute(context.RequestContext);

            // Assert
            Assert.True(controller.WasCalled);
        }

        [Fact]
        public void FileWithContents()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            byte[] fileContents = new byte[0];

            // Act
            FileContentResult result = controller.File(fileContents, "someContentType");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileContents, result.FileContents);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal(String.Empty, result.FileDownloadName);
        }

        [Fact]
        public void FileWithContentsAndFileDownloadName()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            byte[] fileContents = new byte[0];

            // Act
            FileContentResult result = controller.File(fileContents, "someContentType", "someDownloadName");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileContents, result.FileContents);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal("someDownloadName", result.FileDownloadName);
        }

        [Fact]
        public void FileWithPath()
        {
            // Arrange
            EmptyController controller = new EmptyController();

            // Act
            FilePathResult result = controller.File("somePath", "someContentType");

            // Assert
            Assert.NotNull(result);
            Assert.Equal("somePath", result.FileName);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal(String.Empty, result.FileDownloadName);
        }

        [Fact]
        public void FileWithPathAndFileDownloadName()
        {
            // Arrange
            EmptyController controller = new EmptyController();

            // Act
            FilePathResult result = controller.File("somePath", "someContentType", "someDownloadName");

            // Assert
            Assert.NotNull(result);
            Assert.Equal("somePath", result.FileName);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal("someDownloadName", result.FileDownloadName);
        }

        [Fact]
        public void FileWithStream()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            Stream fileStream = Stream.Null;

            // Act
            FileStreamResult result = controller.File(fileStream, "someContentType");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileStream, result.FileStream);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal(String.Empty, result.FileDownloadName);
        }

        [Fact]
        public void FileWithStreamAndFileDownloadName()
        {
            // Arrange
            EmptyController controller = new EmptyController();
            Stream fileStream = Stream.Null;

            // Act
            FileStreamResult result = controller.File(fileStream, "someContentType", "someDownloadName");

            // Assert
            Assert.NotNull(result);
            Assert.Same(fileStream, result.FileStream);
            Assert.Equal("someContentType", result.ContentType);
            Assert.Equal("someDownloadName", result.FileDownloadName);
        }

        [Fact]
        public void HandleUnknownActionThrows()
        {
            var controller = new EmptyController();
            Assert.Throws<HttpException>(
                delegate { controller.HandleUnknownAction("UnknownAction"); },
                "A public action method 'UnknownAction' was not found on controller 'System.Web.Mvc.Test.ControllerTest+EmptyController'.");
        }

        /// <summary>
        /// This is a scenario for attribute routing, we don't have a single action nameat this point
        /// </summary>
        [Fact]
        public void HandleUnknownAction_NoActionName_Throws()
        {
            var controller = new EmptyController();
            Assert.Throws<HttpException>(
                delegate { controller.HandleUnknownAction(null); },
                "No matching action was found on controller 'System.Web.Mvc.Test.ControllerTest+EmptyController'. " +
                "This can happen when a controller uses RouteAttribute for routing, but no action on that controller matches the request.");
        }

        [Fact]
        public void JavaScript()
        {
            // Arrange
            Controller controller = GetEmptyController();
            string script = "alert('foo');";

            // Act
            JavaScriptResult result = controller.JavaScript(script);

            // Assert
            Assert.Equal(script, result.Script);
        }

        [Fact]
        public void PartialView()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            PartialViewResult result = controller.PartialView();

            // Assert
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
            Assert.Same(ViewEngines.Engines, result.ViewEngineCollection);
        }

        [Fact]
        public void PartialView_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object model = new object();

            // Act
            PartialViewResult result = controller.PartialView(model);

            // Assert
            Assert.Same(model, result.ViewData.Model);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
        }

        [Fact]
        public void PartialView_ViewName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            PartialViewResult result = controller.PartialView("Some partial view");

            // Assert
            Assert.Equal("Some partial view", result.ViewName);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
        }

        [Fact]
        public void PartialView_ViewName_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object model = new object();

            // Act
            PartialViewResult result = controller.PartialView("Some partial view", model);

            // Assert
            Assert.Equal("Some partial view", result.ViewName);
            Assert.Same(model, result.ViewData.Model);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(controller.ViewData, result.ViewData);
        }

        [Fact]
        public void PartialView_ViewEngineCollection()
        {
            // Arrange
            Controller controller = GetEmptyController();
            ViewEngineCollection viewEngines = new ViewEngineCollection();
            controller.ViewEngineCollection = viewEngines;

            // Act
            PartialViewResult result = controller.PartialView();

            // Assert
            Assert.Same(viewEngines, result.ViewEngineCollection);
        }

        [Fact]
        public void RedirectToActionClonesRouteValueDictionary()
        {
            // The RedirectToAction() method should clone the provided dictionary, then operate on the clone.
            // The original dictionary should remain unmodified throughout the helper's execution.

            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary(new { Action = "SomeAction", Controller = "SomeController" });

            // Act
            controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);

            // Assert
            Assert.Equal(2, values.Count);
            Assert.Equal("SomeAction", values["action"]);
            Assert.Equal("SomeController", values["controller"]);
        }

        [Fact]
        public void RedirectToActionOverwritesActionDictionaryKey()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Action = "SomeAction" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Equal("SomeOtherAction", newValues["action"]);
        }

        [Fact]
        public void RedirectToActionOverwritesControllerDictionaryKeyIfSpecified()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Action = "SomeAction", Controller = "SomeController" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Equal("SomeOtherController", newValues["controller"]);
        }

        [Fact]
        public void RedirectToActionPreservesControllerDictionaryKeyIfNotSpecified()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Controller = "SomeController" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Equal("SomeController", newValues["controller"]);
        }

        [Fact]
        public void RedirectToActionWithActionName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction");

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndControllerName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController");

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeOtherController", result.RouteValues["controller"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndControllerNameAndValuesDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary(new { Foo = "SomeFoo" });

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeOtherController", result.RouteValues["controller"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndControllerNameAndValuesObject()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Foo = "SomeFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", "SomeOtherController", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeOtherController", result.RouteValues["controller"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionSelectsCurrentControllerByDefault()
        {
            // Arrange
            TestRouteController controller = new TestRouteController();
            controller.ControllerContext = GetControllerContext("SomeAction", "TestRoute");

            // Act
            RedirectToRouteResult route = controller.Index() as RedirectToRouteResult;

            // Assert
            Assert.Equal("SomeAction", route.RouteValues["action"]);
            Assert.Equal("TestRoute", route.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionDictionaryOverridesDefaultControllerName()
        {
            // Arrange
            TestRouteController controller = new TestRouteController();
            object values = new { controller = "SomeOtherController" };
            controller.ControllerContext = GetControllerContext("SomeAction", "TestRoute");

            // Act
            RedirectToRouteResult route = controller.RedirectToAction("SomeOtherAction", values);

            // Assert
            Assert.Equal("SomeOtherAction", route.RouteValues["action"]);
            Assert.Equal("SomeOtherController", route.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionSimpleOverridesCallLegacyMethod()
        {
            // The simple overrides need to call RedirectToAction(string, string, RouteValueDictionary) to maintain backwards compat

            // Arrange
            int invocationCount = 0;
            Mock<Controller> controllerMock = new Mock<Controller>();
            controllerMock.Setup(c => c.RedirectToAction(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<RouteValueDictionary>())).Callback(() => { invocationCount++; });

            Controller controller = controllerMock.Object;

            // Act
            controller.RedirectToAction("SomeAction");
            controller.RedirectToAction("SomeAction", (object)null);
            controller.RedirectToAction("SomeAction", (RouteValueDictionary)null);
            controller.RedirectToAction("SomeAction", "SomeController");
            controller.RedirectToAction("SomeAction", "SomeController", (object)null);

            // Assert
            Assert.Equal(5, invocationCount);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndValuesDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary(new { Foo = "SomeFoo" });

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithActionNameAndValuesObject()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object values = new { Foo = "SomeFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", values);

            // Assert
            Assert.Equal("", result.RouteName);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("SomeFoo", result.RouteValues["foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionWithNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToAction("SomeOtherAction", (RouteValueDictionary)null);
            RouteValueDictionary newValues = result.RouteValues;

            // Assert
            Assert.Single(newValues);
            Assert.Equal("SomeOtherAction", newValues["action"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToActionPermanent()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToActionPermanent("SomeOtherAction");

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Null(result.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionPermanentWithObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToActionPermanent("SomeOtherAction", controllerName: "SomeController", routeValues: new { foo = "bar" });

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("bar", result.RouteValues["foo"]);
            Assert.Equal("SomeController", result.RouteValues["controller"]);
        }

        [Fact]
        public void RedirectToActionPermanentWithRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToActionPermanent("SomeOtherAction", routeValues: new RouteValueDictionary(new { foo = "bar" }));

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("SomeOtherAction", result.RouteValues["action"]);
            Assert.Equal("bar", result.RouteValues["foo"]);
        }

        [Fact]
        public void RedirectToRouteSimpleOverridesCallLegacyMethod()
        {
            // The simple overrides need to call RedirectToRoute(string, RouteValueDictionary) to maintain backwards compat

            // Arrange
            int invocationCount = 0;
            Mock<Controller> controllerMock = new Mock<Controller>();
            controllerMock.Setup(c => c.RedirectToRoute(It.IsAny<string>(), It.IsAny<RouteValueDictionary>())).Callback(() => { invocationCount++; });

            Controller controller = controllerMock.Object;

            // Act
            controller.RedirectToRoute("SomeRoute");
            controller.RedirectToRoute("SomeRoute", (object)null);
            controller.RedirectToRoute((object)null);
            controller.RedirectToRoute((RouteValueDictionary)null);

            // Assert
            Assert.Equal(4, invocationCount);
        }

        [Fact]
        public void RedirectToRouteWithNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute((RouteValueDictionary)null);

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            var values = new { Foo = "MyFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary() { { "Foo", "MyFoo" } };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.NotSame(values, result.RouteValues);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo");

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNameAndNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo", (RouteValueDictionary)null);

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNullNameAndNullRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute(null, (RouteValueDictionary)null);

            // Assert
            Assert.Empty(result.RouteValues);
            Assert.Equal(String.Empty, result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNameAndObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            var values = new { Foo = "MyFoo" };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo", values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRouteWithNameAndRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();
            RouteValueDictionary values = new RouteValueDictionary() { { "Foo", "MyFoo" } };

            // Act
            RedirectToRouteResult result = controller.RedirectToRoute("foo", values);

            // Assert
            Assert.Single(result.RouteValues);
            Assert.Equal("MyFoo", result.RouteValues["Foo"]);
            Assert.NotSame(values, result.RouteValues);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectToRoutePermanentWithObjectDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoutePermanent(routeValues: new { Foo = "Bar" });

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("Bar", result.RouteValues["Foo"]);
        }

        [Fact]
        public void RedirectToRoutePermanentWithRouteValueDictionary()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            RedirectToRouteResult result = controller.RedirectToRoutePermanent(routeValues: new RouteValueDictionary(new { Foo = "Bar" }));

            // Assert
            Assert.True(result.Permanent);
            Assert.Equal("Bar", result.RouteValues["Foo"]);
        }

        [Fact]
        public void RedirectReturnsCorrectActionResult()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act & Assert
            var result = controller.Redirect("http://www.contoso.com/");

            // Assert
            Assert.Equal("http://www.contoso.com/", result.Url);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void RedirectPermanentReturnsCorrectActionResult()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act & Assert
            var result = controller.RedirectPermanent("http://www.contoso.com/");

            // Assert
            Assert.Equal("http://www.contoso.com/", result.Url);
            Assert.True(result.Permanent);
        }

        [Fact]
        public void RedirectWithEmptyUrlThrows()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { controller.Redirect(String.Empty); },
                "url");
        }

        [Fact]
        public void RedirectPermanentWithEmptyUrlThrows()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { controller.RedirectPermanent(String.Empty); },
                "url");
        }

        [Fact]
        public void RedirectWithNullUrlThrows()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { controller.Redirect(url: null); },
                "url");
        }

        [Fact]
        public void RedirectPermanentWithNullUrlThrows()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { controller.RedirectPermanent(url: null); },
                "url");
        }

        [Fact]
        public void View()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            ViewResult result = controller.View();

            // Assert
            Assert.Same(controller.ViewData, result.ViewData);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(ViewEngines.Engines, result.ViewEngineCollection);
        }

        [Fact]
        public void View_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object viewItem = new object();

            // Act
            ViewResult result = controller.View(viewItem);

            // Assert
            Assert.Same(viewItem, result.ViewData.Model);
            Assert.Same(controller.TempData, result.TempData);
        }

        [Fact]
        public void View_ViewName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            ViewResult result = controller.View("Foo");

            // Assert
            Assert.Equal("Foo", result.ViewName);
            Assert.Same(controller.ViewData, result.ViewData);
            Assert.Same(controller.TempData, result.TempData);
        }

        [Fact]
        public void View_ViewName_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object viewItem = new object();

            // Act
            ViewResult result = controller.View("Foo", viewItem);

            // Assert
            Assert.Equal("Foo", result.ViewName);
            Assert.Same(viewItem, result.ViewData.Model);
            Assert.Same(controller.TempData, result.TempData);
        }

        [Fact]
        public void View_ViewName_MasterViewName()
        {
            // Arrange
            Controller controller = GetEmptyController();

            // Act
            ViewResult result = controller.View("Foo", "Bar");

            // Assert
            Assert.Equal("Foo", result.ViewName);
            Assert.Equal("Bar", result.MasterName);
            Assert.Same(controller.ViewData, result.ViewData);
            Assert.Same(controller.TempData, result.TempData);
        }

        [Fact]
        public void View_ViewName_MasterViewName_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            object viewItem = new object();

            // Act
            ViewResult result = controller.View("Foo", "Bar", viewItem);

            // Assert
            Assert.Equal("Foo", result.ViewName);
            Assert.Equal("Bar", result.MasterName);
            Assert.Same(viewItem, result.ViewData.Model);
            Assert.Same(controller.TempData, result.TempData);
        }

        [Fact]
        public void View_View()
        {
            // Arrange
            Controller controller = GetEmptyController();
            IView view = new Mock<IView>().Object;

            // Act
            ViewResult result = controller.View(view);

            // Assert
            Assert.Same(result.View, view);
            Assert.Same(controller.ViewData, result.ViewData);
            Assert.Same(controller.TempData, result.TempData);
        }

        [Fact]
        public void View_View_Model()
        {
            // Arrange
            Controller controller = GetEmptyController();
            IView view = new Mock<IView>().Object;
            object model = new object();

            // Act
            ViewResult result = controller.View(view, model);

            // Assert
            Assert.Same(result.View, view);
            Assert.Same(controller.ViewData, result.ViewData);
            Assert.Same(controller.TempData, result.TempData);
            Assert.Same(model, result.ViewData.Model);
        }

        [Fact]
        public void View_ViewEngineCollection()
        {
            // Arrange
            Controller controller = GetEmptyController();
            ViewEngineCollection viewEngines = new ViewEngineCollection();
            controller.ViewEngineCollection = viewEngines;

            // Act
            ViewResult result = controller.View();

            // Assert
            Assert.Same(viewEngines, result.ViewEngineCollection);
        }

        internal static void AddRequestParams(Mock<HttpRequestBase> requestMock, object paramValues)
        {
            PropertyDescriptorCollection props = TypeDescriptor.GetProperties(paramValues);
            foreach (PropertyDescriptor prop in props)
            {
                requestMock.Setup(o => o[It.Is<string>(item => String.Equals(prop.Name, item, StringComparison.OrdinalIgnoreCase))]).Returns((string)prop.GetValue(paramValues));
            }
        }

        [Fact]
        public void TempDataGreetUserWithNoUserIDRedirects()
        {
            // Arrange
            TempDataHomeController tempDataHomeController = new TempDataHomeController();

            // Act
            RedirectToRouteResult result = tempDataHomeController.GreetUser() as RedirectToRouteResult;
            RouteValueDictionary values = result.RouteValues;

            // Assert
            Assert.True(values.ContainsKey("action"));
            Assert.Equal("ErrorPage", values["action"]);
            Assert.Empty(tempDataHomeController.TempData);
        }

        [Fact]
        public void TempDataGreetUserWithUserIDCopiesToViewDataAndRenders()
        {
            // Arrange
            TempDataHomeController tempDataHomeController = new TempDataHomeController();
            tempDataHomeController.TempData["UserID"] = "TestUserID";

            // Act
            ViewResult result = tempDataHomeController.GreetUser() as ViewResult;
            ViewDataDictionary viewData = tempDataHomeController.ViewData;

            // Assert
            Assert.Equal("GreetUser", result.ViewName);
            Assert.NotNull(viewData);
            Assert.True(viewData.ContainsKey("NewUserID"));
            Assert.Equal("TestUserID", viewData["NewUserID"]);
        }

        [Fact]
        public void TempDataIndexSavesUserIDAndRedirects()
        {
            // Arrange
            TempDataHomeController tempDataHomeController = new TempDataHomeController();

            // Act
            RedirectToRouteResult result = tempDataHomeController.Index() as RedirectToRouteResult;
            RouteValueDictionary values = result.RouteValues;

            // Assert
            Assert.True(values.ContainsKey("action"));
            Assert.Equal("GreetUser", values["action"]);

            Assert.True(tempDataHomeController.TempData.ContainsKey("UserID"));
            Assert.Equal("user123", tempDataHomeController.TempData["UserID"]);
        }

        [Fact]
        public void TempDataSavedWhenControllerThrows()
        {
            // Arrange
            BrokenController controller = new BrokenController() { ValidateRequest = false };
            Mock<HttpContextBase> mockContext = HttpContextHelpers.GetMockHttpContext();
            HttpSessionStateBase session = GetEmptySession();
            mockContext.Setup(o => o.Session).Returns(session);
            RouteData rd = new RouteData();
            rd.Values.Add("action", "Crash");
            controller.ControllerContext = new ControllerContext(mockContext.Object, rd, controller);

            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { ((IController)controller).Execute(controller.ControllerContext.RequestContext); });
            Assert.NotNull(mockContext.Object.Session[SessionStateTempDataProvider.TempDataSessionStateKey]);
            TempDataDictionary tempData = new TempDataDictionary();
            tempData.Load(controller.ControllerContext, controller.TempDataProvider);
            Assert.Equal("Value1", tempData["Key1"]);
        }

        [Fact]
        public void TempDataMovedToPreviousTempDataInDestinationController()
        {
            // Arrange
            Mock<Controller> mockController = new Mock<Controller>() { CallBase = true };
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            HttpSessionStateBase session = GetEmptySession();
            mockContext.Setup(o => o.Session).Returns(session);
            mockController.Object.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), mockController.Object);

            // Act
            mockController.Object.TempData.Add("Key", "Value");
            mockController.Object.TempData.Save(mockController.Object.ControllerContext, mockController.Object.TempDataProvider);

            // Assert
            Assert.True(mockController.Object.TempData.ContainsKey("Key"));
            Assert.True(mockController.Object.TempData.ContainsValue("Value"));

            // Instantiate "destination" controller with the same session state and see that it gets the temp data
            Mock<Controller> mockDestinationController = new Mock<Controller>() { CallBase = true };
            Mock<HttpContextBase> mockDestinationContext = new Mock<HttpContextBase>();
            mockDestinationContext.Setup(o => o.Session).Returns(session);
            mockDestinationController.Object.ControllerContext = new ControllerContext(mockDestinationContext.Object, new RouteData(), mockDestinationController.Object);
            mockDestinationController.Object.TempData.Load(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);

            // Assert
            Assert.True(mockDestinationController.Object.TempData.ContainsKey("Key"));

            // Act
            mockDestinationController.Object.TempData["NewKey"] = "NewValue";
            Assert.True(mockDestinationController.Object.TempData.ContainsKey("NewKey"));
            mockDestinationController.Object.TempData.Save(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);

            // Instantiate "second destination" controller with the same session state and see that it gets the temp data
            Mock<Controller> mockSecondDestinationController = new Mock<Controller>() { CallBase = true };
            Mock<HttpContextBase> mockSecondDestinationContext = new Mock<HttpContextBase>();
            mockSecondDestinationContext.Setup(o => o.Session).Returns(session);
            mockSecondDestinationController.Object.ControllerContext = new ControllerContext(mockSecondDestinationContext.Object, new RouteData(), mockSecondDestinationController.Object);
            mockSecondDestinationController.Object.TempData.Load(mockSecondDestinationController.Object.ControllerContext, mockSecondDestinationController.Object.TempDataProvider);

            // Assert
            Assert.True(mockSecondDestinationController.Object.TempData.ContainsKey("Key"));
            Assert.True(mockSecondDestinationController.Object.TempData.ContainsKey("NewKey"));
        }

        [Fact]
        public void TempDataRemovesKeyWhenRead()
        {
            // Arrange
            Mock<Controller> mockController = new Mock<Controller>() { CallBase = true };
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            HttpSessionStateBase session = GetEmptySession();
            mockContext.Setup(o => o.Session).Returns(session);
            mockController.Object.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), mockController.Object);

            // Act
            mockController.Object.TempData.Add("Key", "Value");
            mockController.Object.TempData.Save(mockController.Object.ControllerContext, mockController.Object.TempDataProvider);

            // Assert
            Assert.True(mockController.Object.TempData.ContainsKey("Key"));
            Assert.True(mockController.Object.TempData.ContainsValue("Value"));

            // Instantiate "destination" controller with the same session state and see that it gets the temp data
            Mock<Controller> mockDestinationController = new Mock<Controller>() { CallBase = true };
            Mock<HttpContextBase> mockDestinationContext = new Mock<HttpContextBase>();
            mockDestinationContext.Setup(o => o.Session).Returns(session);
            mockDestinationController.Object.ControllerContext = new ControllerContext(mockDestinationContext.Object, new RouteData(), mockDestinationController.Object);
            mockDestinationController.Object.TempData.Load(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);

            // Assert
            Assert.True(mockDestinationController.Object.TempData.ContainsKey("Key"));

            // Act
            object value = mockDestinationController.Object.TempData["Key"];
            mockDestinationController.Object.TempData.Save(mockDestinationController.Object.ControllerContext, mockDestinationController.Object.TempDataProvider);

            // Instantiate "second destination" controller with the same session state and see that it gets the temp data
            Mock<Controller> mockSecondDestinationController = new Mock<Controller>() { CallBase = true };
            Mock<HttpContextBase> mockSecondDestinationContext = new Mock<HttpContextBase>();
            mockSecondDestinationContext.Setup(o => o.Session).Returns(session);
            mockSecondDestinationController.Object.ControllerContext = new ControllerContext(mockSecondDestinationContext.Object, new RouteData(), mockSecondDestinationController.Object);
            mockSecondDestinationController.Object.TempData.Load(mockSecondDestinationController.Object.ControllerContext, mockSecondDestinationController.Object.TempDataProvider);

            // Assert
            Assert.False(mockSecondDestinationController.Object.TempData.ContainsKey("Key"));
        }

        [Fact]
        public void TempDataValidForSingleControllerWhenSessionStateDisabled()
        {
            // Arrange
            Mock<Controller> mockController = new Mock<Controller>();
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            HttpSessionStateBase session = null;
            mockContext.Setup(o => o.Session).Returns(session);
            mockController.Object.ControllerContext = new ControllerContext(mockContext.Object, new RouteData(), mockController.Object);
            mockController.Object.TempData = new TempDataDictionary();

            // Act
            mockController.Object.TempData["Key"] = "Value";

            // Assert
            Assert.True(mockController.Object.TempData.ContainsKey("Key"));
        }

        [Fact]
        public void TryUpdateModelCallsModelBinderForModel()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();
            IValueProvider valueProvider = new SimpleValueProvider();

            Controller controller = new EmptyController();
            controller.ControllerContext = GetControllerContext("someAction");

            // Act
            bool returned = controller.TryUpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" }, null, valueProvider);

            // Assert
            Assert.True(returned);
            Assert.Equal(valueProvider, myModel.BindingContext.ValueProvider);
            Assert.Equal("somePrefix", myModel.BindingContext.ModelName);
            Assert.Equal(controller.ModelState, myModel.BindingContext.ModelState);
            Assert.Equal(typeof(MyModel), myModel.BindingContext.ModelType);
            Assert.True(myModel.BindingContext.PropertyFilter("prop1"));
            Assert.True(myModel.BindingContext.PropertyFilter("prop2"));
            Assert.False(myModel.BindingContext.PropertyFilter("prop3"));
        }

        [Fact]
        public void TryUpdateModelReturnsFalseIfModelStateInvalid()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();

            Controller controller = new EmptyController();
            controller.ModelState.AddModelError("key", "some exception message");

            // Act
            bool returned = controller.TryUpdateModel(myModel, new SimpleValueProvider());

            // Assert
            Assert.False(returned);
        }

        [Fact]
        public void TryUpdateModelSuppliesControllerValueProviderIfNoValueProviderSpecified()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();
            IValueProvider valueProvider = new SimpleValueProvider();

            Controller controller = new EmptyController();
            controller.ValueProvider = valueProvider;

            // Act
            bool returned = controller.TryUpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" });

            // Assert
            Assert.True(returned);
            Assert.Equal(valueProvider, myModel.BindingContext.ValueProvider);
        }

        [Fact]
        public void TryUpdateModelSuppliesEmptyModelNameIfNoPrefixSpecified()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();
            Controller controller = new EmptyController();

            // Act
            bool returned = controller.TryUpdateModel(myModel, new[] { "prop1", "prop2" }, new SimpleValueProvider());

            // Assert
            Assert.True(returned);
            Assert.Equal(String.Empty, myModel.BindingContext.ModelName);
        }

        [Fact]
        public void TryUpdateModelThrowsIfModelIsNull()
        {
            // Arrange
            Controller controller = new EmptyController();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { controller.TryUpdateModel<object>(null, new SimpleValueProvider()); }, "model");
        }

        [Fact]
        public void TryUpdateModelThrowsIfValueProviderIsNull()
        {
            // Arrange
            Controller controller = new EmptyController();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { controller.TryUpdateModel(new object(), null, null, null, null); }, "valueProvider");
        }

        [Fact]
        public void UpdateModelReturnsIfModelStateValid()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();
            Controller controller = new EmptyController();

            // Act
            controller.UpdateModel(myModel, new SimpleValueProvider());

            // Assert
            // nothing to do - if we got here, the test passed
        }

        [Fact]
        public void TryUpdateModelWithoutBindPropertiesImpliesAllPropertiesAreUpdateable()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();
            Controller controller = new EmptyController();

            // Act
            bool returned = controller.TryUpdateModel(myModel, "somePrefix", new SimpleValueProvider());

            // Assert
            Assert.True(returned);
            Assert.True(myModel.BindingContext.PropertyFilter("prop1"));
            Assert.True(myModel.BindingContext.PropertyFilter("prop2"));
            Assert.True(myModel.BindingContext.PropertyFilter("prop3"));
        }

        [Fact]
        public void UpdateModelSuppliesControllerValueProviderIfNoValueProviderSpecified()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();
            IValueProvider valueProvider = new SimpleValueProvider();

            Controller controller = new EmptyController() { ValueProvider = valueProvider };

            // Act
            controller.UpdateModel(myModel, "somePrefix", new[] { "prop1", "prop2" });

            // Assert
            Assert.Equal(valueProvider, myModel.BindingContext.ValueProvider);
        }

        [Fact]
        public void UpdateModelThrowsIfModelStateInvalid()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();

            Controller controller = new EmptyController();
            controller.ModelState.AddModelError("key", "some exception message");

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { controller.UpdateModel(myModel, new SimpleValueProvider()); },
                "The model of type 'System.Web.Mvc.Test.ControllerTest+MyModel' could not be updated.");
        }

        [Fact]
        public void UpdateModelWithoutBindPropertiesImpliesAllPropertiesAreUpdateable()
        {
            // Arrange
            MyModel myModel = new MyModelSubclassed();
            Controller controller = new EmptyController();

            // Act
            controller.UpdateModel(myModel, "somePrefix", new SimpleValueProvider());

            // Assert
            Assert.True(myModel.BindingContext.PropertyFilter("prop1"));
            Assert.True(myModel.BindingContext.PropertyFilter("prop2"));
            Assert.True(myModel.BindingContext.PropertyFilter("prop3"));
        }

        [Fact]
        public void Json()
        {
            // Arrange
            MyModel model = new MyModel();
            Controller controller = new EmptyController();

            // Act
            JsonResult result = controller.Json(model);

            // Assert
            Assert.Same(model, result.Data);
            Assert.Null(result.ContentType);
            Assert.Null(result.ContentEncoding);
            Assert.Equal(JsonRequestBehavior.DenyGet, result.JsonRequestBehavior);
        }

        [Fact]
        public void JsonWithContentType()
        {
            // Arrange
            MyModel model = new MyModel();
            Controller controller = new EmptyController();

            // Act
            JsonResult result = controller.Json(model, "text/xml");

            // Assert
            Assert.Same(model, result.Data);
            Assert.Equal("text/xml", result.ContentType);
            Assert.Null(result.ContentEncoding);
            Assert.Equal(JsonRequestBehavior.DenyGet, result.JsonRequestBehavior);
        }

        [Fact]
        public void JsonWithContentTypeAndEncoding()
        {
            // Arrange
            MyModel model = new MyModel();
            Controller controller = new EmptyController();

            // Act
            JsonResult result = controller.Json(model, "text/xml", Encoding.UTF32);

            // Assert
            Assert.Same(model, result.Data);
            Assert.Equal("text/xml", result.ContentType);
            Assert.Equal(Encoding.UTF32, result.ContentEncoding);
            Assert.Equal(JsonRequestBehavior.DenyGet, result.JsonRequestBehavior);
        }

        [Fact]
        public void JsonWithBehavior()
        {
            // Arrange
            MyModel model = new MyModel();
            Controller controller = new EmptyController();

            // Act
            JsonResult result = controller.Json(model, JsonRequestBehavior.AllowGet);

            // Assert
            Assert.Same(model, result.Data);
            Assert.Null(result.ContentType);
            Assert.Null(result.ContentEncoding);
            Assert.Equal(JsonRequestBehavior.AllowGet, result.JsonRequestBehavior);
        }

        [Fact]
        public void JsonWithContentTypeAndBehavior()
        {
            // Arrange
            MyModel model = new MyModel();
            Controller controller = new EmptyController();

            // Act
            JsonResult result = controller.Json(model, "text/xml", JsonRequestBehavior.AllowGet);

            // Assert
            Assert.Same(model, result.Data);
            Assert.Equal("text/xml", result.ContentType);
            Assert.Null(result.ContentEncoding);
            Assert.Equal(JsonRequestBehavior.AllowGet, result.JsonRequestBehavior);
        }

        [Fact]
        public void JsonWithContentTypeAndEncodingAndBehavior()
        {
            // Arrange
            MyModel model = new MyModel();
            Controller controller = new EmptyController();

            // Act
            JsonResult result = controller.Json(model, "text/xml", Encoding.UTF32, JsonRequestBehavior.AllowGet);

            // Assert
            Assert.Same(model, result.Data);
            Assert.Equal("text/xml", result.ContentType);
            Assert.Equal(Encoding.UTF32, result.ContentEncoding);
            Assert.Equal(JsonRequestBehavior.AllowGet, result.JsonRequestBehavior);
        }

        [Fact]
        public void ExecuteDoesNotCallTempDataLoadOrSave()
        {
            // Arrange
            TempDataDictionary tempData = new TempDataDictionary();
            ViewContext viewContext = new ViewContext { TempData = tempData };
            RouteData routeData = new RouteData();
            routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = viewContext;
            routeData.Values["action"] = "SimpleAction";
            RequestContext requestContext = new RequestContext(HttpContextHelpers.GetMockHttpContext().Object, routeData);
            // Strict == no default implementations == calls to Load & Save are not allowed
            Mock<ITempDataProvider> tempDataProvider = new Mock<ITempDataProvider>(MockBehavior.Strict);
            SimpleController controller = new SimpleController();
            controller.ValidateRequest = false;

            // Act
            ((IController)controller).Execute(requestContext);

            // Assert
            tempDataProvider.Verify();
        }

        // Model validation

        [Fact]
        public void TryValidateModelGuardClauses()
        {
            // Arrange
            Controller controller = new SimpleController();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => controller.TryValidateModel(null),
                "model");
        }

        [Fact]
        public void TryValidateModelWithValidModel()
        {
            // Arrange
            Controller controller = new SimpleController();
            TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 15 };

            // Act
            bool result = controller.TryValidateModel(model);

            // Assert
            Assert.True(result);
            Assert.True(controller.ModelState.IsValid);
        }

        [Fact]
        public void TryValidateModelWithInvalidModel()
        {
            // Arrange
            Controller controller = new SimpleController();
            TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 5 };

            // Act
            bool result = controller.TryValidateModel(model, "Prefix");

            // Assert
            Assert.False(result);
            Assert.Equal("Out of range!", controller.ModelState["Prefix.IntegerProperty"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void ValidateModelGuardClauses()
        {
            // Arrange
            Controller controller = new SimpleController();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => controller.ValidateModel(null),
                "model");
        }

        [Fact]
        public void ValidateModelWithValidModel()
        {
            // Arrange
            Controller controller = new SimpleController();
            TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 15 };

            // Act
            controller.ValidateModel(model);

            // Assert
            Assert.True(controller.ModelState.IsValid);
        }

        [Fact]
        public void ValidateModelWithInvalidModel()
        {
            // Arrange
            Controller controller = new SimpleController();
            TryValidateModelModel model = new TryValidateModelModel { IntegerProperty = 5 };

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => controller.ValidateModel(model, "Prefix"),
                "The model of type '" + model.GetType().FullName + "' is not valid.");

            Assert.Equal("Out of range!", controller.ModelState["Prefix.IntegerProperty"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void ValidateControllerUsesCachedResolver()
        {
            var controller = new EmptyController();

            var resolver = controller.Resolver;

            Assert.Equal(DependencyResolver.CurrentCache.GetType(), resolver.GetType());
        }


        [Fact]
        public void CreateActionInvokerCallsAsyncActionInvokerFactoryCreateInstance()
        {
            // Controller uses an IDependencyResolver and an IAsyncActionInvokerFactory
            // to create an IAsyncActionInvoker.
            // Arrange
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            Mock<IAsyncActionInvoker> asyncActionInvokerMock = new Mock<IAsyncActionInvoker>();
            Mock<IAsyncActionInvokerFactory> asyncActionInvokerFactoryMock = new Mock<IAsyncActionInvokerFactory>();
            asyncActionInvokerFactoryMock.Setup(a => a.CreateInstance()).Returns(asyncActionInvokerMock.Object);
            resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvokerFactory)))
                .Returns(asyncActionInvokerFactoryMock.Object);
            resolverMock.Setup(r => r.GetService(typeof(IActionInvokerFactory)))
                .Returns((IActionInvokerFactory)null);
            controller.Resolver = resolverMock.Object;

            // Act
            var ai = controller.CreateActionInvoker();

            // Assert
            resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvokerFactory)), Times.Once());
            resolverMock.Verify(r => r.GetService(typeof(IActionInvokerFactory)), Times.Never());
            Assert.Same(asyncActionInvokerMock.Object, ai);
        }

        [Fact]
        public void CreateActionInvokerCallsActionInvokerFactoryCreateInstance()
        {
            // Controller uses an IDependencyResolver and an IActionInvokerFactory to create an IActionInvoker.
            // Arrange
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            Mock<IActionInvoker> actionInvokerMock = new Mock<IActionInvoker>();
            Mock<IActionInvokerFactory> actionInvokerFactoryMock = new Mock<IActionInvokerFactory>();
            actionInvokerFactoryMock.Setup(a => a.CreateInstance()).Returns(actionInvokerMock.Object);
            resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvokerFactory)))
                .Returns((IAsyncActionInvokerFactory)null);
            resolverMock.Setup(r => r.GetService(typeof(IActionInvokerFactory)))
                .Returns(actionInvokerFactoryMock.Object);
            controller.Resolver = resolverMock.Object;

            // Act
            var ai = controller.CreateActionInvoker();

            // Assert
            resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvokerFactory)), Times.Once());
            resolverMock.Verify(r => r.GetService(typeof(IActionInvokerFactory)), Times.Once());
            Assert.Same(actionInvokerMock.Object, ai);
        }

        [Fact]
        public void CreateActionInvokerCallsIntoResolverInstance()
        {
            // Controller uses an IDependencyResolver to create an IActionInvoker.
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            Mock<IAsyncActionInvoker> actionInvokerMock = new Mock<IAsyncActionInvoker>();
            resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvoker))).Returns(actionInvokerMock.Object);
            controller.Resolver = resolverMock.Object;

            var ai = controller.CreateActionInvoker();

            resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvoker)), Times.Once());
            Assert.Same(actionInvokerMock.Object, ai);
        }

        [Fact]
        public void CreateActionInvokerCallsIntoResolverInstanceAndCreatesANewOneIfNecessary()
        {
            // If IDependencyResolver is set, but empty, falls back and still creates.
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            resolverMock.Setup(r => r.GetService(typeof(IAsyncActionInvoker))).Returns(null);
            controller.Resolver = resolverMock.Object;

            IActionInvoker ai = controller.CreateActionInvoker();

            resolverMock.Verify(r => r.GetService(typeof(IAsyncActionInvoker)), Times.Once());
            Assert.NotNull(ai);
        }

        [Fact]
        public void CreateTempProviderWithResolver()
        {
            // Controller uses an IDependencyResolver to create an ITempDataProvider.
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            Mock<ITempDataProvider> tempMock = new Mock<ITempDataProvider>();
            resolverMock.Setup(r => r.GetService(typeof(ITempDataProvider))).Returns(tempMock.Object);
            controller.Resolver = resolverMock.Object;

            ITempDataProvider temp = controller.CreateTempDataProvider();

            resolverMock.Verify(r => r.GetService(typeof(ITempDataProvider)), Times.Once());
            Assert.Same(tempMock.Object, temp);
        }

        [Fact]
        public void CreateTempProviderWithResolver_ITempDataProviderFactory()
        {
            // Controller uses an IDependencyResolver and an ITempDataProviderFactory to create an ITempDataProvider.
            // Arrange
            var controller = new EmptyController();
            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            Mock<ITempDataProvider> tempMock = new Mock<ITempDataProvider>();
            Mock<ITempDataProviderFactory> factoryMock = new Mock<ITempDataProviderFactory>();
            factoryMock.Setup(f => f.CreateInstance()).Returns(tempMock.Object);
            resolverMock.Setup(r => r.GetService(typeof(ITempDataProvider))).Returns(tempMock.Object);
            resolverMock.Setup(r => r.GetService(typeof(ITempDataProviderFactory))).Returns(factoryMock.Object);
            controller.Resolver = resolverMock.Object;

            // Act
            ITempDataProvider temp = controller.CreateTempDataProvider();

            // Assert
            // Times.Once() and Times.Never() confirm the order.
            resolverMock.Verify(r => r.GetService(typeof(ITempDataProviderFactory)), Times.Once());
            resolverMock.Verify(r => r.GetService(typeof(ITempDataProvider)), Times.Never());
            Assert.Same(tempMock.Object, temp);
        }

        [Fact]
        public void CanMock_UrlHelper()
        {
            // Arrange
            var controller = new UrlHelperController();
            Mock<UrlHelper> urlHelper = new Mock<UrlHelper>();
            urlHelper.Setup(u => u.Action("SimpleAction", new { ID = 42 })).Verifiable();
            controller.Url = urlHelper.Object;

            // Act
            controller.SimpleAction();

            // Assert
            urlHelper.Verify();
        }

        private class TryValidateModelModel
        {
            [Range(10, 20, ErrorMessage = "Out of range!")]
            public int IntegerProperty { get; set; }
        }

        // Helpers

        private class UrlHelperController : Controller
        {
            public string SimpleAction()
            {
                return Url.Action("SimpleAction", new { ID = 42 });
            }
        }

        private class SimpleController : Controller
        {
            public SimpleController()
            {
                ControllerContext = new ControllerContext { Controller = this };
            }

            public void SimpleAction()
            {
            }
        }

        private static ControllerContext GetControllerContext(string actionName)
        {
            RouteData rd = new RouteData();
            rd.Values["action"] = actionName;

            Mock<HttpContextBase> mockHttpContext = HttpContextHelpers.GetMockHttpContext();
            mockHttpContext.Setup(c => c.Session).Returns((HttpSessionStateBase)null);

            return new ControllerContext(mockHttpContext.Object, rd, new Mock<Controller>().Object);
        }

        private static ControllerContext GetControllerContext(string actionName, string controllerName)
        {
            RouteData rd = new RouteData();
            rd.Values["action"] = actionName;
            rd.Values["controller"] = controllerName;

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.Session).Returns((HttpSessionStateBase)null);

            return new ControllerContext(mockHttpContext.Object, rd, new Mock<Controller>().Object);
        }

        private static Controller GetEmptyController()
        {
            ControllerContext context = GetControllerContext("Foo");
            var controller = new EmptyController()
            {
                ControllerContext = context,
                RouteCollection = new RouteCollection(),
                TempData = new TempDataDictionary(),
                TempDataProvider = new SessionStateTempDataProvider()
            };
            return controller;
        }

        private static HttpSessionStateBase GetEmptySession()
        {
            HttpSessionStateMock mockSession = new HttpSessionStateMock();
            return mockSession;
        }

        private sealed class HttpSessionStateMock : HttpSessionStateBase
        {
            private Hashtable _sessionData = new Hashtable(StringComparer.OrdinalIgnoreCase);

            public override void Remove(string name)
            {
                Assert.Equal(SessionStateTempDataProvider.TempDataSessionStateKey, name);
                _sessionData.Remove(name);
            }

            public override object this[string name]
            {
                get
                {
                    Assert.Equal(SessionStateTempDataProvider.TempDataSessionStateKey, name);
                    return _sessionData[name];
                }
                set
                {
                    Assert.Equal(SessionStateTempDataProvider.TempDataSessionStateKey, name);
                    _sessionData[name] = value;
                }
            }
        }

        public class Person
        {
            public string Name { get; set; }
            public int Age { get; set; }
        }

        private class EmptyController : Controller
        {
            public new void HandleUnknownAction(string actionName)
            {
                base.HandleUnknownAction(actionName);
            }

            public void PublicInitialize(RequestContext requestContext)
            {
                base.Initialize(requestContext);
            }

            // Test can expose protected method as public.
            public new IActionInvoker CreateActionInvoker()
            {
                return base.CreateActionInvoker();
            }

            public new ITempDataProvider CreateTempDataProvider()
            {
                return base.CreateTempDataProvider();
            }
        }


        private sealed class UnknownActionController : Controller
        {
            public bool WasCalled;

            protected override void HandleUnknownAction(string actionName)
            {
                WasCalled = true;
            }
        }

        private sealed class TempDataHomeController : Controller
        {
            public ActionResult Index()
            {
                // Save UserID into TempData and redirect to greeting page
                TempData["UserID"] = "user123";
                return RedirectToAction("GreetUser");
            }

            public ActionResult GreetUser()
            {
                // Check that the UserID is present. If it's not
                // there, redirect to error page. If it is, show
                // the greet user view.
                if (!TempData.ContainsKey("UserID"))
                {
                    return RedirectToAction("ErrorPage");
                }
                ViewData["NewUserID"] = TempData["UserID"];
                return View("GreetUser");
            }
        }

        public class BrokenController : Controller
        {
            public BrokenController()
            {
                ActionInvoker = new ControllerActionInvoker()
                {
                    DescriptorCache = new ControllerDescriptorCache()
                };
            }

            public ActionResult Crash()
            {
                TempData["Key1"] = "Value1";
                throw new InvalidOperationException("Crashing....");
            }
        }

        private sealed class TestRouteController : Controller
        {
            public ActionResult Index()
            {
                return RedirectToAction("SomeAction");
            }
        }

        [ModelBinder(typeof(MyModelBinder))]
        private class MyModel
        {
            public ControllerContext ControllerContext;
            public ModelBindingContext BindingContext;
        }

        private class MyModelSubclassed : MyModel
        {
        }

        private class MyModelBinder : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                MyModel myModel = (MyModel)bindingContext.Model;
                myModel.ControllerContext = controllerContext;
                myModel.BindingContext = bindingContext;
                return myModel;
            }
        }
    }

    internal class EmptyTempDataProvider : ITempDataProvider
    {
        public void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
        {
        }

        public IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
        {
            return new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/CopyOnWriteDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class CopyOnWriteDictionaryTest
    {
        [Fact]
        public void ReadOperation_DelegatesToSourceDictionary_IfNoMutationsArePerformed()
        {
            // Arrange
            var values = new List<object>();
            var enumerator = Mock.Of<IEnumerator<KeyValuePair<string, object>>>();
            var sourceDictionary = new Mock<IDictionary<string, object>>(MockBehavior.Strict);
            sourceDictionary.SetupGet(d => d.Count)
                            .Returns(100)
                            .Verifiable();
            sourceDictionary.SetupGet(d => d.Values)
                            .Returns(values)
                            .Verifiable();
            sourceDictionary.Setup(d => d.ContainsKey("test-key"))
                            .Returns(value: true)
                            .Verifiable();
            sourceDictionary.Setup(d => d.GetEnumerator())
                            .Returns(enumerator)
                            .Verifiable();
            sourceDictionary.Setup(d => d["key2"])
                            .Returns("key2-value")
                            .Verifiable();
            object value;
            sourceDictionary.Setup(d => d.TryGetValue("different-key", out value))
                            .Returns(false)
                            .Verifiable();

            var copyOnWriteDictionary = new CopyOnWriteDictionary<string, object>(sourceDictionary.Object,
                                                                                  StringComparer.OrdinalIgnoreCase);

            // Act and Assert
            Assert.Equal("key2-value", copyOnWriteDictionary["key2"]);
            Assert.Equal(100, copyOnWriteDictionary.Count);
            Assert.Same(values, copyOnWriteDictionary.Values);
            Assert.True(copyOnWriteDictionary.ContainsKey("test-key"));
            Assert.Same(enumerator, copyOnWriteDictionary.GetEnumerator());
            Assert.False(copyOnWriteDictionary.TryGetValue("different-key", out value));
            sourceDictionary.Verify();
        }

        [Fact]
        public void ReadOperation_DoesNotDelegateToSourceDictionary_OnceAValueIsChanged()
        {
            // Arrange
            var values = new List<object>();
            var sourceDictionary = new Dictionary<string, object>
            {
                { "key1", "value1" },
                { "key2", "value2" }
            };
            var copyOnWriteDictionary = new CopyOnWriteDictionary<string, object>(sourceDictionary,
                                                                                  StringComparer.OrdinalIgnoreCase);

            // Act
            copyOnWriteDictionary["key2"] = "value3";

            // Assert
            Assert.Equal("value2", sourceDictionary["key2"]);
            Assert.Equal(2, copyOnWriteDictionary.Count);
            Assert.Equal("value1", copyOnWriteDictionary["key1"]);
            Assert.Equal("value3", copyOnWriteDictionary["key2"]);
        }

        [Fact]
        public void ReadOperation_DoesNotDelegateToSourceDictionary_OnceDictionaryIsModified()
        {
            // Arrange
            var values = new List<object>();
            var sourceDictionary = new Dictionary<string, object>
            {
                { "key1", "value1" },
                { "key2", "value2" }
            };
            var copyOnWriteDictionary = new CopyOnWriteDictionary<string, object>(sourceDictionary,
                                                                                  StringComparer.OrdinalIgnoreCase);

            // Act
            copyOnWriteDictionary.Add("key3", "value3");
            copyOnWriteDictionary.Remove("key1");

            // Assert
            Assert.Equal(2, sourceDictionary.Count);
            Assert.Equal("value1", sourceDictionary["key1"]);
            Assert.Equal(2, copyOnWriteDictionary.Count);
            Assert.Equal("value2", copyOnWriteDictionary["KeY2"]);
            Assert.Equal("value3", copyOnWriteDictionary["key3"]);
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Test/DataAnnotationsModelMetadataProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Test
{
    public class DataAnnotationsModelMetadataProviderTest : DataAnnotationsModelMetadataProviderTestBase
    {
        protected override AssociatedMetadataProvider MakeProvider()
        {
            return new DataAnnotationsModelMetadataProvider();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DataAnnotationsModelMetadataProviderTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public abstract class DataAnnotationsModelMetadataProviderTestBase
    {
        protected abstract AssociatedMetadataProvider MakeProvider();

        [Fact]
        public void GetMetadataForPropertiesSetTypesAndPropertyNames()
        {
            // Arrange
            var provider = MakeProvider();

            // Act
            IEnumerable<ModelMetadata> result = provider.GetMetadataForProperties("foo", typeof(string));

            // Assert
            Assert.Contains(result, m => m.ModelType == typeof(int)
                                        && m.PropertyName == "Length"
                                        && (int)m.Model == 3);
        }

        [Fact]
        public void GetMetadataForPropertySetsTypeAndPropertyName()
        {
            // Arrange
            var provider = MakeProvider();

            // Act
            ModelMetadata result = provider.GetMetadataForProperty(null, typeof(string), "Length");

            // Assert
            Assert.Equal(typeof(int), result.ModelType);
            Assert.Equal("Length", result.PropertyName);
        }

        [Fact]
        public void GetMetadataForTypeSetsTypeWithNullPropertyName()
        {
            // Arrange
            var provider = MakeProvider();

            // Act
            ModelMetadata result = provider.GetMetadataForType(null, typeof(string));

            // Assert
            Assert.Equal(typeof(string), result.ModelType);
            Assert.Null(result.PropertyName);
        }

        // [HiddenInput] tests

        class HiddenModel
        {
            public int NoAttribute { get; set; }

            [HiddenInput]
            public int DefaultHidden { get; set; }

            [HiddenInput(DisplayValue = false)]
            public int HiddenWithDisplayValueFalse { get; set; }

            [HiddenInput]
            [UIHint("CustomUIHint")]
            public int HiddenAndUIHint { get; set; }
        }

        [Fact]
        public void HiddenAttributeSetsTemplateHintAndHideSurroundingHtml()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            ModelMetadata noAttributeMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "NoAttribute");
            Assert.Null(noAttributeMetadata.TemplateHint);
            Assert.False(noAttributeMetadata.HideSurroundingHtml);

            ModelMetadata defaultHiddenMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "DefaultHidden");
            Assert.Equal("HiddenInput", defaultHiddenMetadata.TemplateHint);
            Assert.False(defaultHiddenMetadata.HideSurroundingHtml);

            ModelMetadata hiddenWithDisplayValueFalseMetadata = provider.GetMetadataForProperty(null, typeof(HiddenModel), "HiddenWithDisplayValueFalse");
            Assert.Equal("HiddenInput", hiddenWithDisplayValueFalseMetadata.TemplateHint);
            Assert.True(hiddenWithDisplayValueFalseMetadata.HideSurroundingHtml);

            // [UIHint] overrides the template hint from [Hidden]
            Assert.Equal("CustomUIHint", provider.GetMetadataForProperty(null, typeof(HiddenModel), "HiddenAndUIHint").TemplateHint);
        }

        // [UIHint] tests

        class UIHintModel
        {
            public int NoAttribute { get; set; }

            [UIHint("MyCustomTemplate")]
            public int DefaultUIHint { get; set; }

            [UIHint("MyMvcTemplate", "MVC")]
            public int MvcUIHint { get; set; }

            [UIHint("MyWebFormsTemplate", "WebForms")]
            public int NoMvcUIHint { get; set; }

            [UIHint("MyDefaultTemplate")]
            [UIHint("MyWebFormsTemplate", "WebForms")]
            [UIHint("MyMvcTemplate", "MVC")]
            public int MultipleUIHint { get; set; }
        }

        [Fact]
        public void UIHintAttributeSetsTemplateHint()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(UIHintModel), "NoAttribute").TemplateHint);
            Assert.Equal("MyCustomTemplate", provider.GetMetadataForProperty(null, typeof(UIHintModel), "DefaultUIHint").TemplateHint);
            Assert.Equal("MyMvcTemplate", provider.GetMetadataForProperty(null, typeof(UIHintModel), "MvcUIHint").TemplateHint);
            Assert.Null(provider.GetMetadataForProperty(null, typeof(UIHintModel), "NoMvcUIHint").TemplateHint);

            Assert.Equal("MyMvcTemplate", provider.GetMetadataForProperty(null, typeof(UIHintModel), "MultipleUIHint").TemplateHint);
        }

        // [DataType] tests

        const string DerivedDataTypeAttributeFormatString = "Time is {0:HH:mm}";

        class DerivedDataTypeAttribute : DataTypeAttribute
        {
            public DerivedDataTypeAttribute()
                : base(DataType.Time)
            {
                DisplayFormat = new DisplayFormatAttribute
                {
                    ApplyFormatInEditMode = true,
                    DataFormatString = DerivedDataTypeAttributeFormatString,
                };
            }
        }

        class DataTypeModel
        {
            public int NoAttribute { get; set; }

            [DataType(DataType.EmailAddress)]
            public int EmailAddressProperty { get; set; }

            [DataType("CustomDataType")]
            public int CustomDataTypeProperty { get; set; }

            [DataType(DataType.Date)]
            public DateTime DateProperty { get; set; }

            [DerivedDataType]
            public DateTime TimeProperty { get; set; }
        }

        [Fact]
        public void DataTypeAttributeSetsDataTypeName()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DataTypeModel), "NoAttribute").DataTypeName);
            Assert.Equal("EmailAddress", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "EmailAddressProperty").DataTypeName);
            Assert.Equal("CustomDataType", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "CustomDataTypeProperty").DataTypeName);
            Assert.Equal("Date", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "DateProperty").DataTypeName);
            Assert.Equal("Time", provider.GetMetadataForProperty(null, typeof(DataTypeModel), "TimeProperty").DataTypeName);
        }

        [Theory]
        [InlineData("NoAttribute", null)]
        [InlineData("EmailAddressProperty", null)]
        [InlineData("CustomDataTypeProperty", null)]
        [InlineData("DateProperty", "{0:d}")] // DataType.Date default format
        [InlineData("TimeProperty", DerivedDataTypeAttributeFormatString)]
        public void DataTypeAttributeSetsDisplayFormats(string propertyName, string formatString)
        {
            // Arrange
            var provider = MakeProvider();

            // Act
            string displayFormat = provider.GetMetadataForProperty(null, typeof(DataTypeModel), propertyName).DisplayFormatString;
            string editFormat = provider.GetMetadataForProperty(null, typeof(DataTypeModel), propertyName).EditFormatString;

            // Assert
            Assert.Equal(formatString, displayFormat);
            Assert.Equal(formatString, editFormat);
        }

        [Theory]
        [InlineData("NoAttribute", false)]
        [InlineData("EmailAddressProperty", false)]
        [InlineData("CustomDataTypeProperty", false)]
        [InlineData("DateProperty", false)] // Uses DataType.Date default format
        [InlineData("TimeProperty", true)]
        public void DataTypeAttributeSetsHasNonDefaultEditFormat(string propertyName, bool expectedNonDefaultEditFormat)
        {
            // Arrange
            var provider = MakeProvider();

            // Act
            bool hasNonDefaultEditFormat = provider.GetMetadataForProperty(null, typeof(DataTypeModel), propertyName).HasNonDefaultEditFormat;

            // Assert
            Assert.Equal(expectedNonDefaultEditFormat, hasNonDefaultEditFormat);
        }

        // [ReadOnly] & [Editable] tests

        class ReadOnlyModel
        {
            public int NoAttributes { get; set; }

            [ReadOnly(true)]
            public int ReadOnlyAttribute { get; set; }

            [Editable(false)]
            public int EditableAttribute { get; set; }

            [ReadOnly(true)]
            [Editable(true)]
            public int BothAttributes { get; set; }

            // Editable trumps ReadOnly
        }

        [Fact]
        public void ReadOnlyTests()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.False(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "NoAttributes").IsReadOnly);
            Assert.True(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "ReadOnlyAttribute").IsReadOnly);
            Assert.True(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "EditableAttribute").IsReadOnly);
            Assert.False(provider.GetMetadataForProperty(null, typeof(ReadOnlyModel), "BothAttributes").IsReadOnly);
        }

        // [DisplayFormat] tests

        class DisplayFormatModel
        {
            public int NoAttribute { get; set; }

            [DisplayFormat(NullDisplayText = "(null value)")]
            public int NullDisplayText { get; set; }

            [DisplayFormat(DataFormatString = "Data {0} format")]
            public int DisplayFormatString { get; set; }

            [DisplayFormat(DataFormatString = "Data {0} format", ApplyFormatInEditMode = true)]
            public int DisplayAndEditFormatString { get; set; }

            [DisplayFormat(ConvertEmptyStringToNull = true)]
            public int ConvertEmptyStringToNullTrue { get; set; }

            [DisplayFormat(ConvertEmptyStringToNull = false)]
            public int ConvertEmptyStringToNullFalse { get; set; }

            [DataType(DataType.Currency)]
            public int DataTypeWithoutDisplayFormatOverride { get; set; }

            [DataType(DataType.Currency)]
            [DisplayFormat(DataFormatString = "format override", ApplyFormatInEditMode = true)]
            public int DataTypeWithDisplayFormatOverride { get; set; }

            [DisplayFormat(HtmlEncode = true)]
            public int HtmlEncodeTrue { get; set; }

            [DisplayFormat(HtmlEncode = false)]
            public int HtmlEncodeFalse { get; set; }

            [DataType(DataType.Currency)]
            [DisplayFormat(HtmlEncode = false)]
            public int HtmlEncodeFalseWithDataType { get; set; }

            // DataType trumps DisplayFormat.HtmlEncode
        }

        [Fact]
        public void DisplayFormatAttributetSetsNullDisplayText()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").NullDisplayText);
            Assert.Equal("(null value)", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NullDisplayText").NullDisplayText);
        }

        [Fact]
        public void DisplayFormatAttributeSetsDisplayFormatString()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").DisplayFormatString);
            Assert.Equal("Data {0} format", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayFormatString").DisplayFormatString);
            Assert.Equal("Data {0} format", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayAndEditFormatString").DisplayFormatString);
        }

        [Fact]
        public void DisplayFormatAttributeSetEditFormatString()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").EditFormatString);
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayFormatString").EditFormatString);
            Assert.Equal("Data {0} format", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DisplayAndEditFormatString").EditFormatString);
        }

        [Fact]
        public void DisplayFormatAttributeSetsConvertEmptyStringToNull()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.True(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").ConvertEmptyStringToNull);
            Assert.True(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "ConvertEmptyStringToNullTrue").ConvertEmptyStringToNull);
            Assert.False(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "ConvertEmptyStringToNullFalse").ConvertEmptyStringToNull);
        }

        [Fact]
        public void DataTypeWithoutDisplayFormatOverrideUsesDataTypesDisplayFormat()
        {
            // Arrange
            var provider = MakeProvider();

            // Act
            string result = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DataTypeWithoutDisplayFormatOverride").DisplayFormatString;

            // Assert
            Assert.Equal("{0:C}", result); // Currency's default format string
        }

        [Fact]
        public void DataTypeWithDisplayFormatOverrideUsesDisplayFormatOverride()
        {
            // Arrange
            var provider = MakeProvider();

            // Act
            string result = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "DataTypeWithDisplayFormatOverride").DisplayFormatString;

            // Assert
            Assert.Equal("format override", result);
        }

        [Fact]
        public void DataTypeInfluencedByDisplayFormatAttributeHtmlEncode()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "NoAttribute").DataTypeName);
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "HtmlEncodeTrue").DataTypeName);
            Assert.Equal("Html", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "HtmlEncodeFalse").DataTypeName);
            Assert.Equal("Currency", provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), "HtmlEncodeFalseWithDataType").DataTypeName);
        }

        [Theory]
        [InlineData("NoAttribute", false)]
        [InlineData("NullDisplayText", false)]
        [InlineData("DisplayFormatString", false)]
        [InlineData("DisplayAndEditFormatString", true)]
        [InlineData("ConvertEmptyStringToNullTrue", false)]
        [InlineData("ConvertEmptyStringToNullFalse", false)]
        [InlineData("DataTypeWithoutDisplayFormatOverride", false)]
        [InlineData("DataTypeWithDisplayFormatOverride", true)]
        [InlineData("HtmlEncodeTrue", false)]
        [InlineData("HtmlEncodeFalse", false)]
        [InlineData("HtmlEncodeFalseWithDataType", false)]
        public void DisplayFormatSetsHasNonDefaultEditFormat(string propertyName, bool expectedHasNonDefaultEditFormat)
        {
            // Arrange
            AssociatedMetadataProvider provider = MakeProvider();

            // Act
            bool hasNonDefaultEditFormat = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), propertyName).HasNonDefaultEditFormat;

            // Assert
            Assert.Equal(expectedHasNonDefaultEditFormat, hasNonDefaultEditFormat);
        }

        [Theory]
        [InlineData("NoAttribute", true)]
        [InlineData("HtmlEncodeTrue", true)]
        [InlineData("HtmlEncodeFalse", false)]
        [InlineData("HtmlEncodeFalseWithDataType", false)]
        public void DisplayFormatSetsHtmlEncode(string propertyName, bool expectedHtmlEncode)
        {
            // Arrange
            AssociatedMetadataProvider provider = MakeProvider();

            // Act
            bool htmlEncode = provider.GetMetadataForProperty(null, typeof(DisplayFormatModel), propertyName).HtmlEncode;

            // Assert
            Assert.Equal(expectedHtmlEncode, htmlEncode);
        }

        // [ScaffoldColumn] tests

        class ScaffoldColumnModel
        {
            public int NoAttribute { get; set; }

            [ScaffoldColumn(true)]
            public int ScaffoldColumnTrue { get; set; }

            [ScaffoldColumn(false)]
            public int ScaffoldColumnFalse { get; set; }
        }

        [Fact]
        public void ScaffoldColumnAttributeSetsShowForDisplay()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.True(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "NoAttribute").ShowForDisplay);
            Assert.True(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnTrue").ShowForDisplay);
            Assert.False(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnFalse").ShowForDisplay);
        }

        [Fact]
        public void ScaffoldColumnAttributeSetsShowForEdit()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.True(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "NoAttribute").ShowForEdit);
            Assert.True(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnTrue").ShowForEdit);
            Assert.False(provider.GetMetadataForProperty(null, typeof(ScaffoldColumnModel), "ScaffoldColumnFalse").ShowForEdit);
        }

        // [DisplayColumn] tests

        [DisplayColumn("NoPropertyWithThisName")]
        class UnknownDisplayColumnModel
        {
        }

        [Fact]
        public void SimpleDisplayNameWithUnknownDisplayColumnThrows()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => provider.GetMetadataForType(() => new UnknownDisplayColumnModel(), typeof(UnknownDisplayColumnModel)).SimpleDisplayText,
                typeof(UnknownDisplayColumnModel).FullName + " has a DisplayColumn attribute for NoPropertyWithThisName, but property NoPropertyWithThisName does not exist.");
        }

        [DisplayColumn("WriteOnlyProperty")]
        class WriteOnlyDisplayColumnModel
        {
            public int WriteOnlyProperty
            {
                set { }
            }
        }

        [DisplayColumn("PrivateReadPublicWriteProperty")]
        class PrivateReadPublicWriteDisplayColumnModel
        {
            public int PrivateReadPublicWriteProperty { private get; set; }
        }

        [Fact]
        public void SimpleDisplayTextForTypeWithWriteOnlyDisplayColumnThrows()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => provider.GetMetadataForType(() => new WriteOnlyDisplayColumnModel(), typeof(WriteOnlyDisplayColumnModel)).SimpleDisplayText,
                typeof(WriteOnlyDisplayColumnModel).FullName + " has a DisplayColumn attribute for WriteOnlyProperty, but property WriteOnlyProperty does not have a public getter.");

            Assert.Throws<InvalidOperationException>(
                () => provider.GetMetadataForType(() => new PrivateReadPublicWriteDisplayColumnModel(), typeof(PrivateReadPublicWriteDisplayColumnModel)).SimpleDisplayText,
                typeof(PrivateReadPublicWriteDisplayColumnModel).FullName + " has a DisplayColumn attribute for PrivateReadPublicWriteProperty, but property PrivateReadPublicWriteProperty does not have a public getter.");
        }

        [DisplayColumn("DisplayColumnProperty")]
        class SimpleDisplayTextAttributeModel
        {
            public int FirstProperty
            {
                get { return 42; }
            }

            [ScaffoldColumn(false)]
            public string DisplayColumnProperty { get; set; }
        }

        class SimpleDisplayTextAttributeModelContainer
        {
            [DisplayFormat(NullDisplayText = "This is the null display text")]
            public SimpleDisplayTextAttributeModel Inner { get; set; }
        }

        [Fact]
        public void SimpleDisplayTextForNonNullClassWithNonNullDisplayColumnValue()
        {
            // Arrange
            string expected = "Custom property display value";
            var provider = MakeProvider();
            var model = new SimpleDisplayTextAttributeModel { DisplayColumnProperty = expected };
            var metadata = provider.GetMetadataForType(() => model, typeof(SimpleDisplayTextAttributeModel));

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(expected, result);
        }

        [Fact]
        public void SimpleDisplayTextForNullClassRevertsToDefaultBehavior()
        {
            // Arrange
            var provider = MakeProvider();
            var metadata = provider.GetMetadataForProperty(null, typeof(SimpleDisplayTextAttributeModelContainer), "Inner");

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal("This is the null display text", result);
        }

        [Fact]
        public void SimpleDisplayTextForNonNullClassWithNullDisplayColumnValueRevertsToDefaultBehavior()
        {
            // Arrange
            var provider = MakeProvider();
            var model = new SimpleDisplayTextAttributeModel();
            var metadata = provider.GetMetadataForType(() => model, typeof(SimpleDisplayTextAttributeModel));

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal("42", result); // Falls back to the default logic of first property value
        }

        // [Required] tests

        class IsRequiredModel
        {
            public int NonNullableWithout { get; set; }

            public string NullableWithout { get; set; }

            [Required]
            public string NullableWith { get; set; }
        }

        [Fact]
        public void IsRequiredTests()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.True(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NonNullableWithout").IsRequired);
            Assert.False(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NullableWithout").IsRequired);
            Assert.True(provider.GetMetadataForProperty(null, typeof(IsRequiredModel), "NullableWith").IsRequired);
        }

        // [Display] & [DisplayName] tests

        class DisplayModel
        {
            public int NoAttribute { get; set; }

            // Description

            [Display]
            public int DescriptionNotSet { get; set; }

            [Display(Description = "Description text")]
            public int DescriptionSet { get; set; }

            // DisplayName

            [DisplayName("Value from DisplayName")]
            public int DisplayNameAttributeNoDisplayAttribute { get; set; }

            [Display]
            public int DisplayAttributeNameNotSet { get; set; }

            [Display(Name = "Non empty name")]
            public int DisplayAttributeNonEmptyName { get; set; }

            [Display]
            [DisplayName("Value from DisplayName")]
            public int BothAttributesNameNotSet { get; set; }

            [Display(Name = "Value from Display")]
            [DisplayName("Value from DisplayName")]
            public int BothAttributes { get; set; }

            // Display trumps DisplayName

            // Order

            [Display]
            public int OrderNotSet { get; set; }

            [Display(Order = 2112)]
            public int OrderSet { get; set; }

            // ShortDisplayName

            [Display]
            public int ShortNameNotSet { get; set; }

            [Display(ShortName = "Short name")]
            public int ShortNameSet { get; set; }

            // Watermark

            [Display]
            public int PromptNotSet { get; set; }

            [Display(Prompt = "Enter stuff here")]
            public int PromptSet { get; set; }
        }

        [Fact]
        public void DescriptionTests()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "NoAttribute").Description);
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "DescriptionNotSet").Description);
            Assert.Equal("Description text", provider.GetMetadataForProperty(null, typeof(DisplayModel), "DescriptionSet").Description);
        }

        [Fact]
        public void DisplayNameTests()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "NoAttribute").DisplayName);
            Assert.Equal("Value from DisplayName", provider.GetMetadataForProperty(null, typeof(DisplayModel), "DisplayNameAttributeNoDisplayAttribute").DisplayName);
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "DisplayAttributeNameNotSet").DisplayName);
            Assert.Equal("Non empty name", provider.GetMetadataForProperty(null, typeof(DisplayModel), "DisplayAttributeNonEmptyName").DisplayName);
            Assert.Equal("Value from DisplayName", provider.GetMetadataForProperty(null, typeof(DisplayModel), "BothAttributesNameNotSet").DisplayName);
            Assert.Equal("Value from Display", provider.GetMetadataForProperty(null, typeof(DisplayModel), "BothAttributes").DisplayName);
        }

        [Fact]
        public void OrderTests()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Equal(10000, provider.GetMetadataForProperty(null, typeof(DisplayModel), "NoAttribute").Order);
            Assert.Equal(10000, provider.GetMetadataForProperty(null, typeof(DisplayModel), "OrderNotSet").Order);
            Assert.Equal(2112, provider.GetMetadataForProperty(null, typeof(DisplayModel), "OrderSet").Order);
        }

        [Fact]
        public void ShortDisplayNameTests()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "NoAttribute").ShortDisplayName);
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "ShortNameNotSet").ShortDisplayName);
            Assert.Equal("Short name", provider.GetMetadataForProperty(null, typeof(DisplayModel), "ShortNameSet").ShortDisplayName);
        }

        [Fact]
        public void WatermarkTests()
        {
            // Arrange
            var provider = MakeProvider();

            // Act & Assert
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "NoAttribute").Watermark);
            Assert.Null(provider.GetMetadataForProperty(null, typeof(DisplayModel), "PromptNotSet").Watermark);
            Assert.Equal("Enter stuff here", provider.GetMetadataForProperty(null, typeof(DisplayModel), "PromptSet").Watermark);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DataAnnotationsModelValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Security;
using Microsoft.TestCommon;
using Moq;
using DataAnnotationsCompareAttribute = System.ComponentModel.DataAnnotations.CompareAttribute;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class DataAnnotationsModelValidatorProviderTest
    {
        // Validation attribute adapter registration

        private class MyValidationAttribute : ValidationAttribute
        {
            public override bool IsValid(object value)
            {
                throw new NotImplementedException();
            }
        }

        private class MyValidationAttributeAdapter : DataAnnotationsModelValidator<MyValidationAttribute>
        {
            public MyValidationAttributeAdapter(ModelMetadata metadata, ControllerContext context, MyValidationAttribute attribute)
                : base(metadata, context, attribute)
            {
            }
        }

        private class MyValidationAttributeAdapterBadCtor : ModelValidator
        {
            public MyValidationAttributeAdapterBadCtor(ModelMetadata metadata, ControllerContext context)
                : base(metadata, context)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                throw new NotImplementedException();
            }
        }

        private class MyDefaultValidationAttributeAdapter : DataAnnotationsModelValidator
        {
            public MyDefaultValidationAttributeAdapter(ModelMetadata metadata, ControllerContext context, ValidationAttribute attribute)
                : base(metadata, context, attribute)
            {
            }
        }

        [MyValidation]
        private class MyValidatedClass
        {
        }

        [Fact]
        public void RegisterAdapter()
        {
            var oldFactories = DataAnnotationsModelValidatorProvider.AttributeFactories;

            try
            {
                // Arrange
                DataAnnotationsModelValidatorProvider.AttributeFactories = new Dictionary<Type, DataAnnotationsModelValidationFactory>();

                // Act
                DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(MyValidationAttribute), typeof(MyValidationAttributeAdapter));

                // Assert
                var type = DataAnnotationsModelValidatorProvider.AttributeFactories.Keys.Single();
                Assert.Equal(typeof(MyValidationAttribute), type);

                var factory = DataAnnotationsModelValidatorProvider.AttributeFactories.Values.Single();
                var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(object));
                var context = new ControllerContext();
                var attribute = new MyValidationAttribute();
                var validator = factory(metadata, context, attribute);
                Assert.IsType<MyValidationAttributeAdapter>(validator);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.AttributeFactories = oldFactories;
            }
        }

        [Fact]
        public void RegisterAdapterGuardClauses()
        {
            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapter(null, typeof(MyValidationAttributeAdapter)),
                "attributeType");

            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(MyValidationAttribute), null),
                "adapterType");

            // Validation attribute must derive from ValidationAttribute
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(object), typeof(MyValidationAttributeAdapter)),
                "The type System.Object must derive from System.ComponentModel.DataAnnotations.ValidationAttribute\r\nParameter name: attributeType");

            // Adapter must derive from ModelValidator
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(MyValidationAttribute), typeof(object)),
                "The type System.Object must derive from System.Web.Mvc.ModelValidator\r\nParameter name: adapterType");

            // Adapter must have the expected constructor
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(MyValidationAttribute), typeof(MyValidationAttributeAdapterBadCtor)),
                "The type System.Web.Mvc.Test.DataAnnotationsModelValidatorProviderTest+MyValidationAttributeAdapterBadCtor must have a public constructor which accepts three parameters of types System.Web.Mvc.ModelMetadata, System.Web.Mvc.ControllerContext, and System.Web.Mvc.Test.DataAnnotationsModelValidatorProviderTest+MyValidationAttribute\r\nParameter name: adapterType");
        }

        [Fact]
        public void RegisterAdapterFactory()
        {
            var oldFactories = DataAnnotationsModelValidatorProvider.AttributeFactories;

            try
            {
                // Arrange
                DataAnnotationsModelValidatorProvider.AttributeFactories = new Dictionary<Type, DataAnnotationsModelValidationFactory>();
                DataAnnotationsModelValidationFactory factory = delegate { return null; };

                // Act
                DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(typeof(MyValidationAttribute), factory);

                // Assert
                var type = DataAnnotationsModelValidatorProvider.AttributeFactories.Keys.Single();
                Assert.Equal(typeof(MyValidationAttribute), type);
                Assert.Same(factory, DataAnnotationsModelValidatorProvider.AttributeFactories.Values.Single());
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.AttributeFactories = oldFactories;
            }
        }

        [Fact]
        public void RegisterAdapterFactoryGuardClauses()
        {
            DataAnnotationsModelValidationFactory factory = (metadata, context, attribute) => null;

            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(null, factory),
                "attributeType");

            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(typeof(MyValidationAttribute), null),
                "factory");

            // Validation attribute must derive from ValidationAttribute
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterAdapterFactory(typeof(object), factory),
                "The type System.Object must derive from System.ComponentModel.DataAnnotations.ValidationAttribute\r\nParameter name: attributeType");
        }

        [Fact]
        public void RegisterDefaultAdapter()
        {
            var oldFactory = DataAnnotationsModelValidatorProvider.DefaultAttributeFactory;

            try
            {
                // Arrange
                var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(MyValidatedClass));
                var context = new ControllerContext();
                DataAnnotationsModelValidatorProvider.RegisterDefaultAdapter(typeof(MyDefaultValidationAttributeAdapter));

                // Act
                var result = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, context).Single();

                // Assert
                Assert.IsType<MyDefaultValidationAttributeAdapter>(result);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.DefaultAttributeFactory = oldFactory;
            }
        }

        [Fact]
        public void RegisterDefaultAdapterGuardClauses()
        {
            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultAdapter(null),
                "adapterType");

            // Adapter must derive from ModelValidator
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultAdapter(typeof(object)),
                "The type System.Object must derive from System.Web.Mvc.ModelValidator\r\nParameter name: adapterType");

            // Adapter must have the expected constructor
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultAdapter(typeof(MyValidationAttributeAdapterBadCtor)),
                "The type System.Web.Mvc.Test.DataAnnotationsModelValidatorProviderTest+MyValidationAttributeAdapterBadCtor must have a public constructor which accepts three parameters of types System.Web.Mvc.ModelMetadata, System.Web.Mvc.ControllerContext, and System.ComponentModel.DataAnnotations.ValidationAttribute\r\nParameter name: adapterType");
        }

        [Fact]
        public void RegisterDefaultAdapterFactory()
        {
            var oldFactory = DataAnnotationsModelValidatorProvider.DefaultAttributeFactory;

            try
            {
                // Arrange
                var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(MyValidatedClass));
                var context = new ControllerContext();
                ModelValidator validator = new Mock<ModelValidator>(metadata, context).Object;
                DataAnnotationsModelValidationFactory factory = delegate { return validator; };
                DataAnnotationsModelValidatorProvider.RegisterDefaultAdapterFactory(factory);

                // Act
                var result = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, context).Single();

                // Assert
                Assert.Same(validator, result);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.DefaultAttributeFactory = oldFactory;
            }
        }

        [Fact]
        public void RegisterDefaultAdapterFactoryGuardClauses()
        {
            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultAdapterFactory(null),
                "factory");
        }

        // IValidatableObject adapter registration

        private class MyValidatableAdapter : ModelValidator
        {
            public MyValidatableAdapter(ModelMetadata metadata, ControllerContext context)
                : base(metadata, context)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                throw new NotImplementedException();
            }
        }

        private class MyValidatableAdapterBadCtor : ModelValidator
        {
            public MyValidatableAdapterBadCtor(ModelMetadata metadata, ControllerContext context, int unused)
                : base(metadata, context)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                throw new NotImplementedException();
            }
        }

        private class MyValidatableClass : IValidatableObject
        {
            public IEnumerable<ValidationResult> Validate(ValidationContext validationContext)
            {
                throw new NotImplementedException();
            }
        }

        [Fact]
        public void RegisterValidatableObjectAdapter()
        {
            var oldFactories = DataAnnotationsModelValidatorProvider.ValidatableFactories;

            try
            {
                // Arrange
                DataAnnotationsModelValidatorProvider.ValidatableFactories = new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();
                IValidatableObject validatable = new Mock<IValidatableObject>().Object;

                // Act
                DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapter(validatable.GetType(), typeof(MyValidatableAdapter));

                // Assert
                var type = DataAnnotationsModelValidatorProvider.ValidatableFactories.Keys.Single();
                Assert.Equal(validatable.GetType(), type);

                var factory = DataAnnotationsModelValidatorProvider.ValidatableFactories.Values.Single();
                var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(object));
                var context = new ControllerContext();
                var validator = factory(metadata, context);
                Assert.IsType<MyValidatableAdapter>(validator);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.ValidatableFactories = oldFactories;
            }
        }

        [Fact]
        public void RegisterValidatableObjectAdapterGuardClauses()
        {
            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapter(null, typeof(MyValidatableAdapter)),
                "modelType");

            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), null),
                "adapterType");

            // Validation attribute must derive from ValidationAttribute
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapter(typeof(object), typeof(MyValidatableAdapter)),
                "The type System.Object must derive from System.ComponentModel.DataAnnotations.IValidatableObject\r\nParameter name: modelType");

            // Adapter must derive from ModelValidator
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), typeof(object)),
                "The type System.Object must derive from System.Web.Mvc.ModelValidator\r\nParameter name: adapterType");

            // Adapter must have the expected constructor
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapter(typeof(MyValidatableClass), typeof(MyValidatableAdapterBadCtor)),
                "The type System.Web.Mvc.Test.DataAnnotationsModelValidatorProviderTest+MyValidatableAdapterBadCtor must have a public constructor which accepts two parameters of types System.Web.Mvc.ModelMetadata and System.Web.Mvc.ControllerContext.\r\nParameter name: adapterType");
        }

        [Fact]
        public void RegisterValidatableObjectAdapterFactory()
        {
            var oldFactories = DataAnnotationsModelValidatorProvider.ValidatableFactories;

            try
            {
                // Arrange
                DataAnnotationsModelValidatorProvider.ValidatableFactories = new Dictionary<Type, DataAnnotationsValidatableObjectAdapterFactory>();
                DataAnnotationsValidatableObjectAdapterFactory factory = delegate { return null; };

                // Act
                DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapterFactory(typeof(MyValidatableClass), factory);

                // Assert
                var type = DataAnnotationsModelValidatorProvider.ValidatableFactories.Keys.Single();
                Assert.Equal(typeof(MyValidatableClass), type);
                Assert.Same(factory, DataAnnotationsModelValidatorProvider.ValidatableFactories.Values.Single());
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.ValidatableFactories = oldFactories;
            }
        }

        [Fact]
        public void RegisterValidatableObjectAdapterFactoryGuardClauses()
        {
            DataAnnotationsValidatableObjectAdapterFactory factory = (metadata, context) => null;

            // Attribute type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapterFactory(null, factory),
                "modelType");

            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapterFactory(typeof(MyValidatableClass), null),
                "factory");

            // Validation attribute must derive from ValidationAttribute
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterValidatableObjectAdapterFactory(typeof(object), factory),
                "The type System.Object must derive from System.ComponentModel.DataAnnotations.IValidatableObject\r\nParameter name: modelType");
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapter()
        {
            var oldFactory = DataAnnotationsModelValidatorProvider.DefaultValidatableFactory;

            try
            {
                // Arrange
                var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(MyValidatableClass));
                var context = new ControllerContext();
                DataAnnotationsModelValidatorProvider.RegisterDefaultValidatableObjectAdapter(typeof(MyValidatableAdapter));

                // Act
                var result = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, context).Single();

                // Assert
                Assert.IsType<MyValidatableAdapter>(result);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.DefaultValidatableFactory = oldFactory;
            }
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapterGuardClauses()
        {
            // Adapter type cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultValidatableObjectAdapter(null),
                "adapterType");

            // Adapter must derive from ModelValidator
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultValidatableObjectAdapter(typeof(object)),
                "The type System.Object must derive from System.Web.Mvc.ModelValidator\r\nParameter name: adapterType");

            // Adapter must have the expected constructor
            Assert.Throws<ArgumentException>(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultValidatableObjectAdapter(typeof(MyValidatableAdapterBadCtor)),
                "The type System.Web.Mvc.Test.DataAnnotationsModelValidatorProviderTest+MyValidatableAdapterBadCtor must have a public constructor which accepts two parameters of types System.Web.Mvc.ModelMetadata and System.Web.Mvc.ControllerContext.\r\nParameter name: adapterType");
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapterFactory()
        {
            var oldFactory = DataAnnotationsModelValidatorProvider.DefaultValidatableFactory;

            try
            {
                // Arrange
                var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(MyValidatableClass));
                var context = new ControllerContext();
                ModelValidator validator = new Mock<ModelValidator>(metadata, context).Object;
                DataAnnotationsValidatableObjectAdapterFactory factory = delegate { return validator; };
                DataAnnotationsModelValidatorProvider.RegisterDefaultValidatableObjectAdapterFactory(factory);

                // Act
                var result = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, context).Single();

                // Assert
                Assert.Same(validator, result);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.DefaultValidatableFactory = oldFactory;
            }
        }

        [Fact]
        public void RegisterDefaultValidatableObjectAdapterFactoryGuardClauses()
        {
            // Factory cannot be null
            Assert.ThrowsArgumentNull(
                () => DataAnnotationsModelValidatorProvider.RegisterDefaultValidatableObjectAdapterFactory(null),
                "factory");
        }

        // Pre-configured adapters

        public static TheoryDataSet<Type, ValidationAttribute, Type, string> KnownAdapterTypeData
        {
            get
            {
                return new TheoryDataSet<Type, ValidationAttribute, Type, string>
                {
                    { typeof(RangeAttribute), new RangeAttribute(1, 100), typeof(RangeAttributeAdapter), null },
                    { typeof(RegularExpressionAttribute), new RegularExpressionAttribute("abc"), typeof(RegularExpressionAttributeAdapter), null },
                    { typeof(RequiredAttribute), new RequiredAttribute(), typeof(RequiredAttributeAdapter), null },
                    { typeof(StringLengthAttribute), new StringLengthAttribute(6), typeof(StringLengthAttributeAdapter), null },
                    { typeof(MaxLengthAttribute), new MaxLengthAttribute(), typeof(MaxLengthAttributeAdapter), null },
                    { typeof(MinLengthAttribute), new MinLengthAttribute(1), typeof(MinLengthAttributeAdapter), null },
                    { typeof(MembershipPasswordAttribute), new MembershipPasswordAttribute(), typeof(MembershipPasswordAttributeAdapter), null },
                    { typeof(DataAnnotationsCompareAttribute), new DataAnnotationsCompareAttribute("other"), typeof(CompareAttributeAdapter), null },
                    { typeof(FileExtensionsAttribute), new FileExtensionsAttribute(), typeof(FileExtensionsAttributeAdapter), null },
                    { typeof(CreditCardAttribute), new CreditCardAttribute(), typeof(DataTypeAttributeAdapter), "creditcard" },
                    { typeof(EmailAddressAttribute), new EmailAddressAttribute(), typeof(DataTypeAttributeAdapter), "email" },
                    { typeof(PhoneAttribute), new PhoneAttribute(), typeof(DataTypeAttributeAdapter), "phone" },
                    { typeof(UrlAttribute), new UrlAttribute(), typeof(DataTypeAttributeAdapter), "url" },
                };
            }
        }

        [Theory]
        [PropertyData("KnownAdapterTypeData")]
        public void AdapterForKnownTypeRegistered(Type attributeType, ValidationAttribute validationAttr,
            Type expectedAdapterType, string expectedRuleName)
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(object));
            var context = new ControllerContext();
            var adapters = DataAnnotationsModelValidatorProvider.AttributeFactories;
            var adapterFactory = adapters.Single(kvp => kvp.Key == attributeType).Value;

            // Act
            var adapter = adapterFactory(metadata, context, validationAttr);

            // Assert
            Assert.IsType(expectedAdapterType, adapter);
            if (expectedRuleName != null)
            {
                DataTypeAttributeAdapter dataTypeAdapter = adapter as DataTypeAttributeAdapter;
                Assert.NotNull(dataTypeAdapter);
                Assert.Equal(expectedRuleName, dataTypeAdapter.RuleName);
            }
        }

        // Default adapter factory for unknown attribute type

        [Fact]
        public void UnknownValidationAttributeGetsDefaultAdapter()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(DummyClassWithDummyValidationAttribute));

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            var validator = validators.Single();
            Assert.IsType<DataAnnotationsModelValidator>(validator);
        }

        private class DummyValidationAttribute : ValidationAttribute
        {
        }

        [DummyValidation]
        private class DummyClassWithDummyValidationAttribute
        {
        }

        // Default IValidatableObject adapter factory

        [Fact]
        public void IValidatableObjectGetsAValidator()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var mockValidatable = new Mock<IValidatableObject>();
            var context = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, mockValidatable.Object.GetType());

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            Assert.Single(validators);
        }

        // Implicit [Required] attribute

        [Fact]
        public void ReferenceTypesDontGetImplicitRequiredAttribute()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(string));

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            Assert.Empty(validators);
        }

        [Fact]
        public void NonNullableValueTypesGetImplicitRequiredAttribute()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(DummyRequiredAttributeHelperClass), "WithoutAttribute");

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelValidator validator = validators.Single();
            ModelClientValidationRule rule = validator.GetClientValidationRules().Single();
            Assert.IsType<ModelClientValidationRequiredRule>(rule);
        }

        [Fact]
        public void NonNullableValueTypesWithExplicitRequiredAttributeDoesntGetImplictRequiredAttribute()
        {
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(DummyRequiredAttributeHelperClass), "WithAttribute");

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelValidator validator = validators.Single();
            ModelClientValidationRule rule = validator.GetClientValidationRules().Single();
            Assert.IsType<ModelClientValidationRequiredRule>(rule);
            Assert.Equal("Custom Required Message", rule.ErrorMessage);
        }

        [Fact]
        public void NonNullableValueTypeDoesntGetImplicitRequiredAttributeWhenFlagIsOff()
        {
            DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

            try
            {
                // Arrange
                var provider = new DataAnnotationsModelValidatorProvider();
                var context = new ControllerContext();
                var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(DummyRequiredAttributeHelperClass), "WithoutAttribute");

                // Act
                IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

                // Assert
                Assert.Empty(validators);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = true;
            }
        }

        private class DummyRequiredAttributeHelperClass
        {
            [Required(ErrorMessage = "Custom Required Message")]
            public int WithAttribute { get; set; }

            public int WithoutAttribute { get; set; }
        }

        // Integration with metadata system

        [Fact]
        public void DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = new DataAnnotationsModelMetadataProvider().GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[] validators = new DataAnnotationsModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            Assert.Empty(validators);
            Assert.False(model.PropertyWasRead());
        }

        private class ObservableModel
        {
            private bool _propertyWasRead;

            public string TheProperty
            {
                get
                {
                    _propertyWasRead = true;
                    return "Hello";
                }
            }

            public bool PropertyWasRead()
            {
                return _propertyWasRead;
            }
        }

        private class BaseModel
        {
            public virtual string MyProperty { get; set; }
        }

        private class DerivedModel : BaseModel
        {
            [StringLength(10)]
            public override string MyProperty
            {
                get { return base.MyProperty; }
                set { base.MyProperty = value; }
            }

            [MinLength(2)]
            [MaxLength(4)]
            public List<DateTime> MinMaxProperty { get; set; }
        }

        [Fact]
        public void GetValidatorsReturnsClientValidatorForDerivedTypeAppliedAgainstBaseTypeViaFromLambdaExpression()
        { // Dev10 Bug #868619
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context = new ControllerContext();
            var viewdata = new ViewDataDictionary<DerivedModel>();
            var metadata = ModelMetadata.FromLambdaExpression(m => m.MyProperty, viewdata); // Bug is in FromLambdaExpression

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelValidator validator = validators.Single();
            ModelClientValidationRule clientRule = validator.GetClientValidationRules().Single();
            Assert.IsType<ModelClientValidationStringLengthRule>(clientRule);
            Assert.Equal(10, clientRule.ValidationParameters["max"]);
        }

        [Fact]
        public void GetValidatorsReturnsValidationRulesForPropertiesWithMinAndMaxLength()
        { // Dev10 Bug #868619
            // Arrange
            var provider = new DataAnnotationsModelValidatorProvider();
            var context = new ControllerContext();
            var viewdata = new ViewDataDictionary<DerivedModel>();
            var metadata = ModelMetadata.FromLambdaExpression(m => m.MinMaxProperty, viewdata);

            // Act
            IEnumerable<ModelValidator> validators = provider.GetValidators(metadata, context);

            // Assert
            ModelClientValidationRule[] clientRule = validators.SelectMany(v => v.GetClientValidationRules())
                                                               .OrderBy(t => t.GetType().Name)
                                                               .ToArray();
            Assert.IsType<ModelClientValidationMaxLengthRule>(clientRule[0]);
            Assert.IsType<ModelClientValidationMinLengthRule>(clientRule[1]);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DataAnnotationsModelValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class DataAnnotationsModelValidatorTest
    {
        [Fact]
        public void ConstructorGuards()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(object));
            ControllerContext context = new ControllerContext();
            RequiredAttribute attribute = new RequiredAttribute();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new DataAnnotationsModelValidator(null, context, attribute),
                "metadata");
            Assert.ThrowsArgumentNull(
                () => new DataAnnotationsModelValidator(metadata, null, attribute),
                "controllerContext");
            Assert.ThrowsArgumentNull(
                () => new DataAnnotationsModelValidator(metadata, context, null),
                "attribute");
        }

        [Fact]
        public void ValuesSet()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();
            RequiredAttribute attribute = new RequiredAttribute();

            // Act
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute);

            // Assert
            Assert.Same(attribute, validator.Attribute);
            Assert.Equal(attribute.FormatErrorMessage("Length"), validator.ErrorMessage);
        }

        public static TheoryDataSet<ModelMetadata, string> ValidateSetsMemberNamePropertyDataSet
        {
            get
            {
                return new TheoryDataSet<ModelMetadata, string>
                {
                    {
                        ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length"),
                        "Length"
                    },
                    {
                        ModelMetadataProviders.Current.GetMetadataForType(() => new object(), typeof(SampleModel)),
                        "SampleModel"
                    }
                };
            }
        }

        [Theory]
        [PropertyData("ValidateSetsMemberNamePropertyDataSet")]
        public void ValidateSetsMemberNamePropertyOfValidationContextForProperties(ModelMetadata metadata, string expectedMemberName)
        {
            // Arrange
            metadata.DisplayName = "Some-random-name";
            ControllerContext context = new ControllerContext();
            var attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Callback((object o, ValidationContext validationContext) =>
                     {
                         Assert.Equal(expectedMemberName, validationContext.MemberName);
                     })
                     .Returns(ValidationResult.Success)
                     .Verifiable();
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(container: null);

            // Assert
            Assert.Empty(results);
            attribute.VerifyAll();
        }

        [Fact]
        public void NoClientRulesByDefault()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();
            RequiredAttribute attribute = new RequiredAttribute();

            // Act
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute);

            // Assert
            Assert.Empty(validator.GetClientValidationRules());
        }

        [Fact]
        public void ValidateWithIsValidTrue()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Setup(a => a.IsValid(metadata.Model)).Returns(true);
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> result = validator.Validate(null);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void ValidateWithIsValidFalse()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Setup(a => a.IsValid(metadata.Model)).Returns(false);
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> result = validator.Validate(null);

            // Assert
            var validationResult = result.Single();
            Assert.Equal("", validationResult.MemberName);
            Assert.Equal(attribute.Object.FormatErrorMessage("Length"), validationResult.Message);
        }

        [Fact]
        public void ValidatateWithValidationResultSuccess()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                .Returns(ValidationResult.Success);
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> result = validator.Validate(null);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void ValidateReturnsSingleValidationResultIfMemberNameSequenceIsEmpty()
        {
            // Arrange
            const string errorMessage = "Some error message";
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Returns(new ValidationResult(errorMessage, memberNames: null));
            var validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(container: null);

            // Assert
            ModelValidationResult validationResult = Assert.Single(results);
            Assert.Equal(errorMessage, validationResult.Message);
            Assert.Empty(validationResult.MemberName);
        }

        [Fact]
        public void ValidateReturnsSingleValidationResultIfOneMemberNameIsSpecified()
        {
            // Arrange
            const string errorMessage = "A different error message";
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => new object(), typeof(object));
            ControllerContext context = new ControllerContext();
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Returns(new ValidationResult(errorMessage, new[] { "FirstName" }));
            var validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(container: null);

            // Assert
            ModelValidationResult validationResult = Assert.Single(results);
            Assert.Equal(errorMessage, validationResult.Message);
            Assert.Equal("FirstName", validationResult.MemberName);
        }

        [Fact]
        public void ValidateReturnsMemberNameIfItIsDifferentFromDisplayName()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => new SampleModel(), typeof(SampleModel));
            ControllerContext context = new ControllerContext();
            Mock<ValidationAttribute> attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.Protected()
                     .Setup<ValidationResult>("IsValid", ItExpr.IsAny<object>(), ItExpr.IsAny<ValidationContext>())
                     .Returns(new ValidationResult("Name error", new[] { "Name" }));
            DataAnnotationsModelValidator validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(container: null);

            // Assert
            ModelValidationResult validationResult = Assert.Single(results);
            Assert.Equal("Name", validationResult.MemberName);
        }

        [Fact]
        public void IsRequiredTests()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();

            // Act & Assert
            Assert.False(new DataAnnotationsModelValidator(metadata, context, new RangeAttribute(10, 20)).IsRequired);
            Assert.True(new DataAnnotationsModelValidator(metadata, context, new RequiredAttribute()).IsRequired);
            Assert.True(new DataAnnotationsModelValidator(metadata, context, new DerivedRequiredAttribute()).IsRequired);
        }

        [Fact]
        public void AttributeWithIClientValidatableGetsClientValidationRules()
        {
            // Arrange
            var expected = new ModelClientValidationStringLengthRule("Error", 1, 10);
            var context = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(string));
            var attribute = new Mock<ValidationAttribute> { CallBase = true };
            attribute.As<IClientValidatable>()
                .Setup(cv => cv.GetClientValidationRules(metadata, context))
                .Returns(new[] { expected })
                .Verifiable();
            var validator = new DataAnnotationsModelValidator(metadata, context, attribute.Object);

            // Act
            ModelClientValidationRule actual = validator.GetClientValidationRules().Single();

            // Assert
            attribute.Verify();
            Assert.Same(expected, actual);
        }

        class DerivedRequiredAttribute : RequiredAttribute
        {
        }

        class SampleModel
        {
            public string Name { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DataErrorInfoModelValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class DataErrorInfoModelValidatorProviderTest
    {
        private static readonly EmptyModelMetadataProvider _metadataProvider = new EmptyModelMetadataProvider();

        [Fact]
        public void GetValidatorsReturnsEmptyCollectionIfTypeNotIDataErrorInfo()
        {
            // Arrange
            DataErrorInfoModelValidatorProvider validatorProvider = new DataErrorInfoModelValidatorProvider();
            object model = new object();
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(() => model, typeof(object));

            // Act
            ModelValidator[] validators = validatorProvider.GetValidators(metadata, new ControllerContext()).ToArray();

            // Assert
            Assert.Empty(validators);
        }

        [Fact]
        public void GetValidatorsReturnsValidatorForIDataErrorInfoProperty()
        {
            // Arrange
            DataErrorInfoModelValidatorProvider validatorProvider = new DataErrorInfoModelValidatorProvider();
            DataErrorInfo1 model = new DataErrorInfo1();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model, typeof(DataErrorInfo1), "SomeStringProperty");
            Type[] expectedTypes = new Type[]
            {
                typeof(DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator)
            };

            // Act
            Type[] actualTypes = validatorProvider.GetValidators(metadata, new ControllerContext()).Select(v => v.GetType()).ToArray();

            // Assert
            Assert.Equal(expectedTypes, actualTypes);
        }

        [Fact]
        public void GetValidatorsReturnsValidatorForIDataErrorInfoRootType()
        {
            // Arrange
            DataErrorInfoModelValidatorProvider validatorProvider = new DataErrorInfoModelValidatorProvider();
            DataErrorInfo1 model = new DataErrorInfo1();
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(() => model, typeof(DataErrorInfo1));
            Type[] expectedTypes = new Type[]
            {
                typeof(DataErrorInfoModelValidatorProvider.DataErrorInfoClassModelValidator)
            };

            // Act
            Type[] actualTypes = validatorProvider.GetValidators(metadata, new ControllerContext()).Select(v => v.GetType()).ToArray();

            // Assert
            Assert.Equal(expectedTypes, actualTypes);
        }

        [Fact]
        public void GetValidatorsThrowsIfContextIsNull()
        {
            // Arrange
            DataErrorInfoModelValidatorProvider validatorProvider = new DataErrorInfoModelValidatorProvider();
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(null, typeof(DataErrorInfo1));

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { validatorProvider.GetValidators(metadata, null); }, "context");
        }

        [Fact]
        public void GetValidatorsThrowsIfMetadataIsNull()
        {
            // Arrange
            DataErrorInfoModelValidatorProvider validatorProvider = new DataErrorInfoModelValidatorProvider();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { validatorProvider.GetValidators(null, new ControllerContext()); }, "metadata");
        }

        [Fact]
        public void ClassValidator_Validate_IDataErrorInfoModelWithError()
        {
            // Arrange
            DataErrorInfo1 model = new DataErrorInfo1()
            {
                Error = "This is an error message."
            };
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(() => model, typeof(DataErrorInfo1));

            var validator = new DataErrorInfoModelValidatorProvider.DataErrorInfoClassModelValidator(metadata, new ControllerContext());

            // Act
            ModelValidationResult[] result = validator.Validate(null).ToArray();

            // Assert
            ModelValidationResult modelValidationResult = Assert.Single(result);
            Assert.Equal("This is an error message.", modelValidationResult.Message);
        }

        [Fact]
        public void ClassValidator_Validate_IDataErrorInfoModelWithNoErrorReturnsEmptyResults()
        {
            // Arrange
            DataErrorInfo1 model = new DataErrorInfo1();
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(() => model, typeof(DataErrorInfo1));

            var validator = new DataErrorInfoModelValidatorProvider.DataErrorInfoClassModelValidator(metadata, new ControllerContext());

            // Act
            ModelValidationResult[] result = validator.Validate(null).ToArray();

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void ClassValidator_Validate_NonIDataErrorInfoModelReturnsEmptyResults()
        {
            // Arrange
            object model = new object();
            ModelMetadata metadata = _metadataProvider.GetMetadataForType(() => model, typeof(object));

            var validator = new DataErrorInfoModelValidatorProvider.DataErrorInfoClassModelValidator(metadata, new ControllerContext());

            // Act
            ModelValidationResult[] result = validator.Validate(null).ToArray();

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void PropertyValidator_Validate_IDataErrorInfoSkipsErrorProperty()
        {
            // Arrange
            DataErrorInfo1 container = new DataErrorInfo1();
            container["Error"] = "This should never be shown.";
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => container, typeof(DataErrorInfo1), "Error");

            var validator = new DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator(metadata, new ControllerContext());

            // Act
            ModelValidationResult[] result = validator.Validate(container).ToArray();

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void PropertyValidator_Validate_DoesNotReadPropertyValue()
        {
            // Arrange
            ObservableModel model = new ObservableModel();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => model.TheProperty, typeof(ObservableModel), "TheProperty");
            ControllerContext controllerContext = new ControllerContext();

            // Act
            ModelValidator[] validators = new DataErrorInfoModelValidatorProvider().GetValidators(metadata, controllerContext).ToArray();
            ModelValidationResult[] results = validators.SelectMany(o => o.Validate(model)).ToArray();

            // Assert
            Assert.Equal(new[] { typeof(DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator) }, Array.ConvertAll(validators, o => o.GetType()));
            Assert.Equal(new[] { "TheProperty" }, model.GetColumnNamesPassed().ToArray());
            Assert.Empty(results);
            Assert.False(model.PropertyWasRead());
        }

        [Fact]
        public void PropertyValidator_Validate_IDataErrorInfoContainerWithError()
        {
            // Arrange
            DataErrorInfo1 container = new DataErrorInfo1();
            container["SomeStringProperty"] = "This is an error message.";
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => container, typeof(DataErrorInfo1), "SomeStringProperty");

            var validator = new DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator(metadata, new ControllerContext());

            // Act
            ModelValidationResult[] result = validator.Validate(container).ToArray();

            // Assert
            ModelValidationResult modelValidationResult = Assert.Single(result);
            Assert.Equal("This is an error message.", modelValidationResult.Message);
        }

        [Fact]
        public void PropertyValidator_Validate_IDataErrorInfoContainerWithNoErrorReturnsEmptyResults()
        {
            // Arrange
            DataErrorInfo1 container = new DataErrorInfo1();
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => container, typeof(DataErrorInfo1), "SomeStringProperty");

            var validator = new DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator(metadata, new ControllerContext());

            // Act
            ModelValidationResult[] result = validator.Validate(container).ToArray();

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void PropertyValidator_Validate_NonIDataErrorInfoContainerReturnsEmptyResults()
        {
            // Arrange
            DataErrorInfo1 container = new DataErrorInfo1();
            container["SomeStringProperty"] = "This is an error message.";
            ModelMetadata metadata = _metadataProvider.GetMetadataForProperty(() => container, typeof(DataErrorInfo1), "SomeStringProperty");

            var validator = new DataErrorInfoModelValidatorProvider.DataErrorInfoPropertyModelValidator(metadata, new ControllerContext());

            // Act
            ModelValidationResult[] result = validator.Validate(new object()).ToArray();

            // Assert
            Assert.Empty(result);
        }

        private class DataErrorInfo1 : IDataErrorInfo
        {
            private readonly Dictionary<string, string> _errors = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

            public string SomeStringProperty { get; set; }

            public string Error { get; set; }

            public string this[string columnName]
            {
                get
                {
                    string outVal;
                    _errors.TryGetValue(columnName, out outVal);
                    return outVal;
                }
                set { _errors[columnName] = value; }
            }
        }

        private class ObservableModel : IDataErrorInfo
        {
            private bool _propertyWasRead;
            private readonly List<string> _columnNamesPassed = new List<string>();

            public int TheProperty
            {
                get
                {
                    _propertyWasRead = true;
                    return 42;
                }
            }

            public bool PropertyWasRead()
            {
                return _propertyWasRead;
            }

            public string Error
            {
                get { throw new NotImplementedException(); }
            }

            public string this[string columnName]
            {
                get
                {
                    _columnNamesPassed.Add(columnName);
                    return null;
                }
            }

            public List<string> GetColumnNamesPassed()
            {
                return _columnNamesPassed;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DataTypeUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class DataTypeUtilTest
    {
        private class DerivedDataTypeAttribute : DataTypeAttribute
        {
            public DerivedDataTypeAttribute(DataType dataType)
                : base(dataType)
            {
            }

            public override string GetDataTypeName()
            {
                return "DerivedTypeName";
            }
        }

        [Fact]
        public void VirtualDataTypeNameCallsAttributeGetDataTypeName()
        {
            // Arrange
            DataTypeAttribute derivedAttr = new DerivedDataTypeAttribute(DataType.Html);
            string expectedTypeName = derivedAttr.GetDataTypeName();

            // Act
            string actualTypeName = DataTypeUtil.ToDataTypeName(derivedAttr);

            // Assert
            Assert.Equal(expectedTypeName, actualTypeName);
        }

        [Fact]
        public void DataTypeAttributeDoesNotCallAttributeGetDataTypeName()
        {
            // Arrange
            Func<DataTypeAttribute, Boolean> isDataTypeAttribute = t => (t as DataTypeAttribute) != null;

            foreach (DataType dataTypeValue in Enum.GetValues(typeof(DataType)))
            {
                if (dataTypeValue != DataType.Custom)
                {
                    Mock<DataTypeAttribute> dataType = new Mock<DataTypeAttribute>(dataTypeValue);

                    // Act
                    string actualTypeName = DataTypeUtil.ToDataTypeName(dataType.Object, dta => dta as DataTypeAttribute != null);

                    // Assert
                    Assert.Equal(dataTypeValue.ToString(), actualTypeName);
                    dataType.Verify(dt => dt.GetDataTypeName(), Times.Never());
                }
            }
        }

        [Fact]
        public void CustomDataTypeNameCallsAttributeGetDataTypeName()
        {
            // Arrange
            Func<DataTypeAttribute, Boolean> isDataTypeAttribute = t => (t as DataTypeAttribute) != null;

            Mock<DataTypeAttribute> customDataType = new Mock<DataTypeAttribute>(DataType.Custom);
            customDataType.Setup(c => c.GetDataTypeName()).Returns("CustomTypeName").Verifiable();

            // Act
            string actualTypeName = DataTypeUtil.ToDataTypeName(customDataType.Object);

            // Assert
            customDataType.Verify(c => c.GetDataTypeName(), Times.Once());
            Assert.Equal("CustomTypeName", actualTypeName);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DefaultControllerFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using System.Web.Mvc.Routing;
using System.Web.Routing;
using System.Web.Routing.Test;
using System.Web.SessionState;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class DefaultControllerFactoryTest
    {
        static DefaultControllerFactoryTest()
        {
            MvcTestHelper.CreateMvcAssemblies();
        }

        [Fact]
        public void CreateAmbiguousControllerException_RouteWithoutUrl()
        {
            // Arrange
            RouteBase route = new Mock<RouteBase>().Object;

            Type[] matchingTypes = new Type[]
            {
                typeof(object),
                typeof(string)
            };

            // Act
            InvalidOperationException exception = DefaultControllerFactory.CreateAmbiguousControllerException(route, "Foo", matchingTypes);

            // Assert
            Assert.Equal(
                "Multiple types were found that match the controller named 'Foo'. This can happen if the route that services this request does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' parameter." + Environment.NewLine
              + Environment.NewLine
              + "The request for 'Foo' has found the following matching controllers:" + Environment.NewLine
              + "System.Object" + Environment.NewLine
              + "System.String",
                exception.Message);
        }

        [Fact]
        public void CreateAmbiguousControllerException_RouteWithUrl()
        {
            // Arrange
            RouteBase route = new Route("{controller}/blah", new Mock<IRouteHandler>().Object);

            Type[] matchingTypes = new Type[]
            {
                typeof(object),
                typeof(string)
            };

            // Act
            InvalidOperationException exception = DefaultControllerFactory.CreateAmbiguousControllerException(route, "Foo", matchingTypes);

            // Assert
            Assert.Equal(
                "Multiple types were found that match the controller named 'Foo'. This can happen if the route that services this request ('{controller}/blah') does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' parameter." + Environment.NewLine
              + Environment.NewLine
              + "The request for 'Foo' has found the following matching controllers:" + Environment.NewLine
              + "System.Object" + Environment.NewLine
              + "System.String",
                exception.Message);
        }

        [Fact]
        public void CreateControllerWithNullContextThrows()
        {
            // Arrange
            DefaultControllerFactory factory = new DefaultControllerFactory();

            // Act
            Assert.ThrowsArgumentNull(
                delegate
                {
                    ((IControllerFactory)factory).CreateController(
                        null,
                        "foo");
                },
                "requestContext");
        }

        [Fact]
        public void CreateControllerWithEmptyControllerNameThrows()
        {
            // Arrange
            DefaultControllerFactory factory = new DefaultControllerFactory();

            // Act
            Assert.Throws<ArgumentException>(
                delegate
                {
                    ((IControllerFactory)factory).CreateController(
                        new RequestContext(new Mock<HttpContextBase>().Object, new RouteData()),
                        String.Empty);
                },
                "Value cannot be null or empty.\r\nParameter name: controllerName");
        }

        [Fact]
        public void CreateControllerReturnsControllerInstance()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            Mock<DefaultControllerFactory> factoryMock = new Mock<DefaultControllerFactory>();
            factoryMock.CallBase = true;
            factoryMock.Setup(o => o.GetControllerType(requestContext, "moo")).Returns(typeof(DummyController));

            // Act
            IController controller = ((IControllerFactory)factoryMock.Object).CreateController(requestContext, "moo");

            // Assert
            Assert.IsType<DummyController>(controller);
        }

        [Fact]
        public void CreateControllerCanReturnNull()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            Mock<DefaultControllerFactory> factoryMock = new Mock<DefaultControllerFactory>();
            factoryMock.Setup(o => o.GetControllerType(requestContext, "moo")).Returns(typeof(DummyController));
            factoryMock.Setup(o => o.GetControllerInstance(requestContext, typeof(DummyController))).Returns((ControllerBase)null);

            // Act
            IController controller = ((IControllerFactory)factoryMock.Object).CreateController(requestContext, "moo");

            // Assert
            Assert.Null(controller);
        }

        [Fact]
        public void DisposeControllerFactoryWithDisposableController()
        {
            // Arrange
            IControllerFactory factory = new DefaultControllerFactory();
            Mock<ControllerBase> mockController = new Mock<ControllerBase>();
            Mock<IDisposable> mockDisposable = mockController.As<IDisposable>();
            mockDisposable.Setup(d => d.Dispose()).Verifiable();

            // Act
            factory.ReleaseController(mockController.Object);

            // Assert
            mockDisposable.Verify();
        }

        [Fact]
        public void GetControllerInstanceThrowsIfControllerTypeIsNull()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            Mock<HttpRequestBase> requestMock = new Mock<HttpRequestBase>();
            contextMock.Setup(o => o.Request).Returns(requestMock.Object);
            requestMock.Setup(o => o.Path).Returns("somepath");
            RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
            Mock<DefaultControllerFactory> factoryMock = new Mock<DefaultControllerFactory> { CallBase = true };
            factoryMock.Setup(o => o.GetControllerType(requestContext, "moo")).Returns((Type)null);

            // Act
            Assert.ThrowsHttpException(
                delegate { ((IControllerFactory)factoryMock.Object).CreateController(requestContext, "moo"); },
                "The controller for path 'somepath' was not found or does not implement IController.",
                404);
        }

        [Fact]
        public void GetControllerInstanceThrowsIfControllerTypeIsNotControllerBase()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = new DefaultControllerFactory();

            // Act
            Assert.Throws<ArgumentException>(
                delegate { factory.GetControllerInstance(requestContext, typeof(int)); },
                "The controller type 'System.Int32' must implement IController.\r\nParameter name: controllerType");
        }

        [Fact]
        public void GetControllerInstanceWithBadConstructorThrows()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
            Mock<DefaultControllerFactory> factoryMock = new Mock<DefaultControllerFactory>();
            factoryMock.CallBase = true;
            factoryMock.Setup(o => o.GetControllerType(requestContext, "moo")).Returns(typeof(DummyControllerThrows));

            // Act
            Exception ex = Assert.Throws<InvalidOperationException>(
                delegate { ((IControllerFactory)factoryMock.Object).CreateController(requestContext, "moo"); },
                "An error occurred when trying to create a controller of type 'System.Web.Mvc.Test.DefaultControllerFactoryTest+DummyControllerThrows'. Make sure that the controller has a parameterless public constructor.");

            Assert.Equal("constructor", ex.InnerException.InnerException.Message);
        }

        [Fact]
        public void GetControllerSessionBehaviorGuardClauses()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            IControllerFactory factory = new DefaultControllerFactory();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => factory.GetControllerSessionBehavior(null, "controllerName"),
                "requestContext"
                );
            Assert.ThrowsArgumentNullOrEmpty(
                () => factory.GetControllerSessionBehavior(requestContext, null),
                "controllerName"
                );
            Assert.ThrowsArgumentNullOrEmpty(
                () => factory.GetControllerSessionBehavior(requestContext, ""),
                "controllerName"
                );
        }

        [Fact]
        public void GetControllerSessionBehaviorReturnsDefaultForNullControllerType()
        {
            // Arrange
            var factory = new DefaultControllerFactory();

            // Act
            SessionStateBehavior result = factory.GetControllerSessionBehavior(null, null);

            // Assert
            Assert.Equal(SessionStateBehavior.Default, result);
        }

        [Fact]
        public void GetControllerSessionBehaviorReturnsDefaultForControllerWithoutAttribute()
        {
            // Arrange
            var factory = new DefaultControllerFactory();

            // Act
            SessionStateBehavior result = factory.GetControllerSessionBehavior(null, typeof(object));

            // Assert
            Assert.Equal(SessionStateBehavior.Default, result);
        }

        [Fact]
        public void GetControllerSessionBehaviorReturnsAttributeValueFromController()
        {
            // Arrange
            var factory = new DefaultControllerFactory();

            // Act
            SessionStateBehavior result = factory.GetControllerSessionBehavior(null, typeof(MyReadOnlyController));

            // Assert
            Assert.Equal(SessionStateBehavior.ReadOnly, result);
        }

        [SessionState(SessionStateBehavior.ReadOnly)]
        class MyReadOnlyController
        {
        }

        [Fact]
        public void GetControllerTypeWithEmptyControllerNameThrows()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = new DefaultControllerFactory();

            // Act
            Assert.Throws<ArgumentException>(
                delegate { factory.GetControllerType(requestContext, String.Empty); },
                "Value cannot be null or empty.\r\nParameter name: controllerName");
        }

        [Fact]
        public void GetControllerTypeForNoAssemblies()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = new DefaultControllerFactory();
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type controllerType = factory.GetControllerType(requestContext, "sometype");

            // Assert
            Assert.Null(controllerType);
            Assert.Equal(0, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeForOneAssembly()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns2a.ns2b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type c1Type = factory.GetControllerType(requestContext, "C1");
            Type c2Type = factory.GetControllerType(requestContext, "c2");

            // Assert
            Assembly asm1 = Assembly.Load("MvcAssembly1");
            Type verifiedC1 = asm1.GetType("NS1a.NS1b.C1Controller");
            Type verifiedC2 = asm1.GetType("NS2a.NS2b.C2Controller");
            Assert.Equal(verifiedC1, c1Type);
            Assert.Equal(verifiedC2, c2Type);
            Assert.Equal(2, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeForManyAssemblies()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns2a.ns2b", "ns3a.ns3b", "ns4a.ns4b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1"), Assembly.Load("MvcAssembly2") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type c1Type = factory.GetControllerType(requestContext, "C1");
            Type c2Type = factory.GetControllerType(requestContext, "C2");
            Type c3Type = factory.GetControllerType(requestContext, "c3"); // lower case
            Type c4Type = factory.GetControllerType(requestContext, "c4"); // lower case

            // Assert
            Assembly asm1 = Assembly.Load("MvcAssembly1");
            Type verifiedC1 = asm1.GetType("NS1a.NS1b.C1Controller");
            Type verifiedC2 = asm1.GetType("NS2a.NS2b.C2Controller");
            Assembly asm2 = Assembly.Load("MvcAssembly2");
            Type verifiedC3 = asm2.GetType("NS3a.NS3b.C3Controller");
            Type verifiedC4 = asm2.GetType("NS4a.NS4b.C4Controller");
            Assert.NotNull(verifiedC1);
            Assert.NotNull(verifiedC2);
            Assert.NotNull(verifiedC3);
            Assert.NotNull(verifiedC4);
            Assert.Equal(verifiedC1, c1Type);
            Assert.Equal(verifiedC2, c2Type);
            Assert.Equal(verifiedC3, c3Type);
            Assert.Equal(verifiedC4, c4Type);
            Assert.Equal(4, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeDoesNotThrowIfSameControllerMatchedMultipleNamespaces()
        {
            // both namespaces "ns3a" and "ns3a.ns3b" will match a controller type, but it's actually
            // the same type. in this case, we shouldn't throw.

            // Arrange
            RequestContext requestContext = GetRequestContextWithNamespaces("ns3a", "ns3a.ns3b");
            requestContext.RouteData.DataTokens["UseNamespaceFallback"] = false;
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns2a.ns2b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly3") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type c1Type = factory.GetControllerType(requestContext, "C1");

            // Assert
            Assembly asm3 = Assembly.Load("MvcAssembly3");
            Type verifiedC1 = asm3.GetType("NS3a.NS3b.C1Controller");
            Assert.NotNull(verifiedC1);
            Assert.Equal(verifiedC1, c1Type);
        }

        [Fact]
        public void GetControllerTypeForAssembliesWithSameTypeNamesInDifferentNamespaces()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns2a.ns2b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1"), Assembly.Load("MvcAssembly3") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type c1Type = factory.GetControllerType(requestContext, "C1");
            Type c2Type = factory.GetControllerType(requestContext, "C2");

            // Assert
            Assembly asm1 = Assembly.Load("MvcAssembly1");
            Type verifiedC1 = asm1.GetType("NS1a.NS1b.C1Controller");
            Type verifiedC2 = asm1.GetType("NS2a.NS2b.C2Controller");
            Assert.NotNull(verifiedC1);
            Assert.NotNull(verifiedC2);
            Assert.Equal(verifiedC1, c1Type);
            Assert.Equal(verifiedC2, c2Type);
            Assert.Equal(4, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeForAssembliesWithSameTypeNamesInDifferentNamespacesThrowsIfAmbiguous()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns3a.ns3b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1"), Assembly.Load("MvcAssembly3") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { factory.GetControllerType(requestContext, "C1"); },
                "Multiple types were found that match the controller named 'C1'. This can happen if the route that services this request does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' parameter." + Environment.NewLine
              + Environment.NewLine
              + "The request for 'C1' has found the following matching controllers:" + Environment.NewLine
              + "NS1a.NS1b.C1Controller" + Environment.NewLine
              + "NS3a.NS3b.C1Controller");

            // Assert
            Assert.Equal(4, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeForAssembliesWithSameTypeNamesInSameNamespaceThrows()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1"), Assembly.Load("MvcAssembly4") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { factory.GetControllerType(requestContext, "C1"); },
                "Multiple types were found that match the controller named 'C1'. This can happen if the route that services this request does not specify namespaces to search for a controller that matches the request. If this is the case, register this route by calling an overload of the 'MapRoute' method that takes a 'namespaces' parameter." + Environment.NewLine
              + Environment.NewLine
              + "The request for 'C1' has found the following matching controllers:" + Environment.NewLine
              + "NS1a.NS1b.C1Controller" + Environment.NewLine
              + "NS1a.NS1b.C1Controller");

            // Assert
            Assert.Equal(4, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeSearchesAllNamespacesAsLastResort()
        {
            // Arrange
            RequestContext requestContext = GetRequestContextWithNamespaces("ns3a.ns3b");
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type c2Type = factory.GetControllerType(requestContext, "C2");

            // Assert
            Assembly asm1 = Assembly.Load("MvcAssembly1");
            Type verifiedC2 = asm1.GetType("NS2a.NS2b.C2Controller");
            Assert.NotNull(verifiedC2);
            Assert.Equal(verifiedC2, c2Type);
            Assert.Equal(2, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeSearchesOnlyRouteDefinedNamespacesIfRequested()
        {
            // Arrange
            RequestContext requestContext = GetRequestContextWithNamespaces("ns3a.ns3b");
            requestContext.RouteData.DataTokens["UseNamespaceFallback"] = false;
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns2a.ns2b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1"), Assembly.Load("MvcAssembly3") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type c1Type = factory.GetControllerType(requestContext, "C1");
            Type c2Type = factory.GetControllerType(requestContext, "C2");

            // Assert
            Assembly asm3 = Assembly.Load("MvcAssembly3");
            Type verifiedC1 = asm3.GetType("NS3a.NS3b.C1Controller");
            Assert.NotNull(verifiedC1);
            Assert.Equal(verifiedC1, c1Type);
            Assert.Null(c2Type);
        }

        [Fact]
        public void GetControllerTypeSearchesRouteDefinedNamespacesBeforeApplicationDefinedNamespaces()
        {
            // Arrange
            RequestContext requestContext = GetRequestContextWithNamespaces("ns3a.ns3b");
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns2a.ns2b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1"), Assembly.Load("MvcAssembly3") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type c1Type = factory.GetControllerType(requestContext, "C1");
            Type c2Type = factory.GetControllerType(requestContext, "C2");

            // Assert
            Assembly asm1 = Assembly.Load("MvcAssembly1");
            Type verifiedC2 = asm1.GetType("NS2a.NS2b.C2Controller");
            Assembly asm3 = Assembly.Load("MvcAssembly3");
            Type verifiedC1 = asm3.GetType("NS3a.NS3b.C1Controller");
            Assert.NotNull(verifiedC1);
            Assert.NotNull(verifiedC2);
            Assert.Equal(verifiedC1, c1Type);
            Assert.Equal(verifiedC2, c2Type);
            Assert.Equal(4, controllerTypeCache.Count);
        }

        [Fact]
        public void GetControllerTypeThatDoesntExist()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            DefaultControllerFactory factory = GetDefaultControllerFactory("ns1a.ns1b", "ns2a.ns2b", "ns3a.ns3b", "ns4a.ns4b");
            MockBuildManager buildManagerMock = new MockBuildManager(new Assembly[] { Assembly.Load("MvcAssembly1"), Assembly.Load("MvcAssembly2"), Assembly.Load("MvcAssembly3"), Assembly.Load("MvcAssembly4") });
            ControllerTypeCache controllerTypeCache = new ControllerTypeCache();

            factory.BuildManager = buildManagerMock;
            factory.ControllerTypeCache = controllerTypeCache;

            // Act
            Type randomType1 = factory.GetControllerType(requestContext, "Cx");
            Type randomType2 = factory.GetControllerType(requestContext, "Cy");
            Type randomType3 = factory.GetControllerType(requestContext, "Foo.Bar");
            Type randomType4 = factory.GetControllerType(requestContext, "C1Controller");

            // Assert
            Assert.Null(randomType1);
            Assert.Null(randomType2);
            Assert.Null(randomType3);
            Assert.Null(randomType4);
            Assert.Equal(8, controllerTypeCache.Count);
        }

        [Fact]
        public void IsControllerType()
        {
            // Act
            bool isController1 = ControllerTypeCache.IsControllerType(null);
            bool isController2 = ControllerTypeCache.IsControllerType(typeof(NonPublicController));
            bool isController3 = ControllerTypeCache.IsControllerType(typeof(MisspelledKontroller));
            bool isController4 = ControllerTypeCache.IsControllerType(typeof(AbstractController));
            bool isController5 = ControllerTypeCache.IsControllerType(typeof(NonIControllerController));
            bool isController6 = ControllerTypeCache.IsControllerType(typeof(Goodcontroller));

            // Assert
            Assert.False(isController1);
            Assert.False(isController2);
            Assert.False(isController3);
            Assert.False(isController4);
            Assert.False(isController5);
            Assert.True(isController6);
        }

        [Theory]
        [InlineData(null, false)]
        [InlineData("", true)]
        [InlineData("Dummy", false)]
        [InlineData("Dummy.*", true)]
        [InlineData("Dummy.Controller.*", false)]
        [InlineData("Dummy.Controllers", true)]
        [InlineData("Dummy.Controllers.*", true)]
        [InlineData("Dummy.Controllers*", false)]
        public void IsNamespaceMatch(string testNamespace, bool expectedResult)
        {
            // Act & Assert
            Assert.Equal(expectedResult, ControllerTypeCache.IsNamespaceMatch(testNamespace, "Dummy.Controllers"));
        }

        [Fact]
        public void GetControllerInstanceConsultsSetControllerActivator()
        {
            //Arrange
            Mock<IControllerActivator> activator = new Mock<IControllerActivator>();
            DefaultControllerFactory factory = new DefaultControllerFactory(activator.Object);
            RequestContext context = new RequestContext();

            //Act
            factory.GetControllerInstance(context, typeof(Goodcontroller));

            //Assert
            activator.Verify(l => l.Create(context, typeof(Goodcontroller)));
        }

        [Fact]
        public void GetControllerDelegatesToActivatorResolver()
        {
            //Arrange
            var context = new RequestContext();
            var expectedController = new Goodcontroller();
            var resolverActivator = new Mock<IControllerActivator>();
            resolverActivator.Setup(a => a.Create(context, typeof(Goodcontroller))).Returns(expectedController);
            var activatorResolver = new Resolver<IControllerActivator> { Current = resolverActivator.Object };
            var factory = new DefaultControllerFactory(null, activatorResolver, null);

            //Act
            IController returnedController = factory.GetControllerInstance(context, typeof(Goodcontroller));

            //Assert
            Assert.Same(returnedController, expectedController);
        }

        [Fact]
        public void GetControllerDelegatesToDependencyResolveWhenActivatorResolverIsNull()
        {
            // Arrange
            var context = new RequestContext();
            var expectedController = new Goodcontroller();
            var dependencyResolver = new Mock<IDependencyResolver>(MockBehavior.Strict);
            dependencyResolver.Setup(dr => dr.GetService(typeof(Goodcontroller))).Returns(expectedController);
            var factory = new DefaultControllerFactory(null, null, dependencyResolver.Object);

            // Act
            IController returnedController = factory.GetControllerInstance(context, typeof(Goodcontroller));

            // Assert
            Assert.Same(returnedController, expectedController);
        }

        [Fact]
        public void GetControllerDelegatesToActivatorCreateInstanceWhenDependencyResolverReturnsNull()
        {
            // Arrange
            var context = new RequestContext();
            var dependencyResolver = new Mock<IDependencyResolver>();
            var factory = new DefaultControllerFactory(null, null, dependencyResolver.Object);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => factory.GetControllerInstance(context, typeof(NoParameterlessCtor)),
                "An error occurred when trying to create a controller of type 'System.Web.Mvc.Test.DefaultControllerFactoryTest+NoParameterlessCtor'. Make sure that the controller has a parameterless public constructor."
                );
        }

        [Fact]
        public void ActivatorResolverAndDependencyResolverAreNeverCalledWhenControllerActivatorIsPassedInConstructor()
        {
            // Arrange
            var context = new RequestContext();
            var expectedController = new Goodcontroller();

            Mock<IControllerActivator> activator = new Mock<IControllerActivator>();
            activator.Setup(a => a.Create(context, typeof(Goodcontroller))).Returns(expectedController);

            var resolverActivator = new Mock<IControllerActivator>(MockBehavior.Strict);
            var activatorResolver = new Resolver<IControllerActivator> { Current = resolverActivator.Object };

            var dependencyResolver = new Mock<IDependencyResolver>(MockBehavior.Strict);

            //Act
            var factory = new DefaultControllerFactory(activator.Object, activatorResolver, dependencyResolver.Object);
            IController returnedController = factory.GetControllerInstance(context, typeof(Goodcontroller));

            //Assert
            Assert.Same(returnedController, expectedController);
        }

        [Fact]
        public void GetControllerType_WithMatchedDirectRoute_UseTargetMethodType()
        {
            // Arrange
            var requestContext = new RequestContext();
            requestContext.RouteData = new RouteData();
            requestContext.RouteData.Route = DirectRouteTestHelpers.BuildDirectRouteFromMethod<WithRoutingAttributeController>(c => c.Action());
            requestContext.RouteData.AddDirectRouteMatches();

            var expectedControllerType = typeof(WithRoutingAttributeController);

            var controllerActivator = new Mock<IControllerActivator>(MockBehavior.Strict).Object;
            var activatorResolver = new Resolver<IControllerActivator>();

            var factory = new DefaultControllerFactory(controllerActivator, activatorResolver, null);

            // Act
            // if it would not get the controller type from the DirectRoute, then it would not 
            // be able to find any controller
            var type = factory.GetControllerType(requestContext, controllerName: null);

            // Assert
            Assert.Equal(expectedControllerType, type);
        }

        [Fact]
        public void GetControllerType_WithMatchedDirectRoute_UseControllerDescriptorType()
        {
            // Arrange
            var requestContext = new RequestContext();
            requestContext.RouteData = new RouteData();
            requestContext.RouteData.Route = DirectRouteTestHelpers.BuildDirectRouteFromController<AttributeRouteAtControllerLevelController>();
            requestContext.RouteData.AddDirectRouteMatches();

            var expectedControllerType = typeof(AttributeRouteAtControllerLevelController);

            var controllerActivator = new Mock<IControllerActivator>(MockBehavior.Strict).Object;
            var activatorResolver = new Resolver<IControllerActivator>();

            var factory = new DefaultControllerFactory(controllerActivator, activatorResolver, null);

            // Act
            // if it would not get the controller type from the DirectRoute, then it would not 
            // be able to find any controller
            var type = factory.GetControllerType(requestContext, controllerName: null);

            // Assert
            Assert.Equal(expectedControllerType, type);
        }

        [Fact]
        public void GetControllerType_WithMultipleDirectRouteControllers_ThrowsInvalidOperationException()
        {
            // Arrange
            var requestContext = new RequestContext();
            requestContext.RouteData = new RouteData();
            SubRouteCollection subRoutes = new SubRouteCollection();
            DirectRouteTestHelpers.AddDirectRouteFromController<AttributeRouteAtControllerLevelController>(subRoutes);
            DirectRouteTestHelpers.AddDirectRouteFromMethod<WithRoutingAttributeController>(subRoutes, c => c.Action());
            requestContext.RouteData.Route = new RouteCollectionRoute(subRoutes);
            requestContext.RouteData.AddDirectRouteMatches();

            var controllerActivator = new Mock<IControllerActivator>(MockBehavior.Strict).Object;
            var activatorResolver = new Resolver<IControllerActivator>();

            var factory = new DefaultControllerFactory(controllerActivator, activatorResolver, null);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => factory.GetControllerType(requestContext, controllerName: null));
        }

        class NoParameterlessCtor : IController
        {
            public NoParameterlessCtor(int x)
            {
            }

            public void Execute(RequestContext requestContext)
            {
            }
        }

        private static DefaultControllerFactory GetDefaultControllerFactory(params string[] namespaces)
        {
            ControllerBuilder builder = new ControllerBuilder();
            builder.DefaultNamespaces.UnionWith(namespaces);
            return new DefaultControllerFactory() { ControllerBuilder = builder };
        }

        private static RequestContext GetRequestContextWithNamespaces(params string[] namespaces)
        {
            RouteData routeData = new RouteData();
            routeData.DataTokens["namespaces"] = namespaces;
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            RequestContext requestContext = new RequestContext(mockHttpContext.Object, routeData);
            return requestContext;
        }

        private sealed class DummyController : ControllerBase
        {
            protected override void ExecuteCore()
            {
                throw new NotImplementedException();
            }
        }

        private sealed class DummyControllerThrows : IController
        {
            public DummyControllerThrows()
            {
                throw new Exception("constructor");
            }

            #region IController Members

            void IController.Execute(RequestContext requestContext)
            {
                throw new NotImplementedException();
            }

            #endregion
        }

        public interface IDisposableController : IController, IDisposable
        {
        }
    }

    // BAD: type isn't public
    internal class NonPublicController : Controller
    {
    }

    // BAD: type doesn't end with 'Controller'
    public class MisspelledKontroller : Controller
    {
    }

    // BAD: type is abstract
    public abstract class AbstractController : Controller
    {
    }

    // BAD: type doesn't implement IController
    public class NonIControllerController
    {
    }

    // GOOD: 'Controller' suffix should be case-insensitive
    public class Goodcontroller : Controller
    {
    }

    public class WithRoutingAttributeController : Controller
    {
        [Route("route")]
        public void Action()
        {
        }
    }

    [Route("cool/{action}")]
    public class AttributeRouteAtControllerLevelController : Controller
    {
        public void Action()
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DefaultModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;
using Moq.Protected;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class DefaultModelBinderTest
    {
        [Fact]
        public void BindComplexElementalModelReturnsIfOnModelUpdatingReturnsFalse()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            MyModel model = new MyModel() { ReadWriteProperty = 3 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
            };

            Mock<DefaultModelBinderHelper> mockHelper = new Mock<DefaultModelBinderHelper>() { CallBase = true };
            mockHelper.Setup(b => b.PublicOnModelUpdating(controllerContext, It.IsAny<ModelBindingContext>())).Returns(false);
            DefaultModelBinderHelper helper = mockHelper.Object;

            // Act
            helper.BindComplexElementalModel(controllerContext, bindingContext, model);

            // Assert
            Assert.Equal(3, model.ReadWriteProperty);
            mockHelper.Verify();
            mockHelper.Verify(b => b.PublicGetModelProperties(controllerContext, It.IsAny<ModelBindingContext>()), Times.Never());
            mockHelper.Verify(b => b.PublicBindProperty(controllerContext, It.IsAny<ModelBindingContext>(), It.IsAny<PropertyDescriptor>()), Times.Never());
        }

        [Fact]
        public void BindComplexModelCanBindArrays()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0]", null },
                    { "foo[1]", null },
                    { "foo[2]", null }
                }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(typeof(int), bc.ModelType);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(bindingContext.PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            object newModel = binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            var newIntArray = Assert.IsType<int[]>(newModel);
            Assert.Equal(new[] { 0, 1, 2 }, newIntArray);
        }

        [Fact]
        public void BindComplexModelCanBindCollections()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IList<int>)),
                ModelName = "foo",
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0]", null },
                    { "foo[1]", null },
                    { "foo[2]", null }
                }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(typeof(int), bc.ModelType);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(bindingContext.PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            object newModel = binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            var modelAsList = Assert.IsAssignableFrom<IList<int>>(newModel);
            Assert.Equal(new[] { 0, 1, 2 }, modelAsList.ToArray());
        }

        [Fact]
        public void BindComplexModelCanBindDictionariesWithDotsNotation()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IDictionary<string, CountryState>)),
                ModelName = "countries",
                PropertyFilter = _ => true,
                ValueProvider = new DictionaryValueProvider<object>(new Dictionary<string, object>()
                {
                    { "countries.CA.Name", "Canada" },
                    { "countries.CA.States[0]", "Québec" },
                    { "countries.CA.States[1]", "British Columbia" },
                    { "countries.US.Name", "United States" },
                    { "countries.US.States[0]", "Washington" },
                    { "countries.US.States[1]", "Oregon" }
                }, CultureInfo.CurrentCulture)
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object newModel = binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            var modelAsDictionary = Assert.IsAssignableFrom<IDictionary<string, CountryState>>(newModel);
            Assert.Equal(2, modelAsDictionary.Count);
            Assert.Equal("Canada", modelAsDictionary["CA"].Name);
            Assert.Equal("United States", modelAsDictionary["US"].Name);
            Assert.Equal(2, modelAsDictionary["CA"].States.Count());
            Assert.Contains("Québec", modelAsDictionary["CA"].States);
            Assert.Contains("British Columbia", modelAsDictionary["CA"].States);
            Assert.Equal(2, modelAsDictionary["US"].States.Count());
            Assert.Contains("Washington", modelAsDictionary["US"].States);
            Assert.Contains("Oregon", modelAsDictionary["US"].States);
        }

        [Fact]
        public void BindComplexModelCanBindDictionariesWithBracketsNotation()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IDictionary<string, CountryState>)),
                ModelName = "countries",
                PropertyFilter = _ => true,
                ValueProvider = new DictionaryValueProvider<object>(new Dictionary<string, object>()
                {
                    { "countries[CA].Name", "Canada" },
                    { "countries[CA].States[0]", "Québec" },
                    { "countries[CA].States[1]", "British Columbia" },
                    { "countries[US].Name", "United States" },
                    { "countries[US].States[0]", "Washington" },
                    { "countries[US].States[1]", "Oregon" }
                }, CultureInfo.CurrentCulture)
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object newModel = binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            var modelAsDictionary = Assert.IsAssignableFrom<IDictionary<string, CountryState>>(newModel);
            Assert.Equal(2, modelAsDictionary.Count);
            Assert.Equal("Canada", modelAsDictionary["CA"].Name);
            Assert.Equal("United States", modelAsDictionary["US"].Name);
            Assert.Equal(2, modelAsDictionary["CA"].States.Count());
            Assert.Contains("Québec", modelAsDictionary["CA"].States);
            Assert.Contains("British Columbia", modelAsDictionary["CA"].States);
            Assert.Equal(2, modelAsDictionary["US"].States.Count());
            Assert.Contains("Washington", modelAsDictionary["US"].States);
            Assert.Contains("Oregon", modelAsDictionary["US"].States);
        }

        [Fact]
        public void BindComplexModelCanBindDictionariesWithBracketsAndDotsNotation()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IDictionary<string, CountryState>)),
                ModelName = "countries",
                PropertyFilter = _ => true,
                ValueProvider = new DictionaryValueProvider<object>(new Dictionary<string, object>()
                {
                    { "countries[CA].Name", "Canada" },
                    { "countries[CA].States[0]", "Québec" },
                    { "countries.CA.States[1]", "British Columbia" },
                    { "countries.US.Name", "United States" },
                    { "countries.US.States[0]", "Washington" },
                    { "countries.US.States[1]", "Oregon" }
                }, CultureInfo.CurrentCulture)
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object newModel = binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            var modelAsDictionary = Assert.IsAssignableFrom<IDictionary<string, CountryState>>(newModel);
            Assert.Equal(2, modelAsDictionary.Count);
            Assert.Equal("Canada", modelAsDictionary["CA"].Name);
            Assert.Equal("United States", modelAsDictionary["US"].Name);
            string state = Assert.Single(modelAsDictionary["CA"].States);
            Assert.Contains("Québec", state);

            // We do not accept double notation for a same entry, so we can't find that state.
            Assert.DoesNotContain("British Columbia", state);
            Assert.Equal(2, modelAsDictionary["US"].States.Count());
            Assert.Contains("Washington", modelAsDictionary["US"].States);
            Assert.Contains("Oregon", modelAsDictionary["US"].States);
        }

        [Fact]
        public void BindComplexModelCanBindDictionaries()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IDictionary<int, string>)),
                ModelName = "foo",
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0].key", null }, { "foo[0].value", null },
                    { "foo[1].key", null }, { "foo[1].value", null },
                    { "foo[2].key", null }, { "foo[2].value", null }
                }
            };

            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            mockIntBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(typeof(int), bc.ModelType);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(new ModelBindingContext().PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10;
                    });

            Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
            mockStringBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(typeof(string), bc.ModelType);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(bindingContext.PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return (Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10) + "Value";
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockIntBinder.Object },
                    { typeof(string), mockStringBinder.Object }
                }
            };

            // Act
            object newModel = binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            var modelAsDictionary = Assert.IsAssignableFrom<IDictionary<int, string>>(newModel);
            Assert.Equal(3, modelAsDictionary.Count);
            Assert.Equal("10Value", modelAsDictionary[10]);
            Assert.Equal("11Value", modelAsDictionary[11]);
            Assert.Equal("12Value", modelAsDictionary[12]);
        }

        [Fact]
        public void BindComplexModelCanBindObjects()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelWithoutBindAttribute model = new ModelWithoutBindAttribute()
            {
                Foo = "FooPreValue",
                Bar = "BarPreValue",
                Baz = "BazPreValue",
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { "Foo", null }, { "Bar", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return bc.ModelName + "PostValue";
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(string), mockInnerBinder.Object }
                }
            };

            // Act
            object updatedModel = binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal("FooPostValue", model.Foo);
            Assert.Equal("BarPostValue", model.Bar);
            Assert.Equal("BazPreValue", model.Baz);
        }

        [Fact]
        public void BindComplexModelReturnsNullArrayIfNoValuesProvided()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider() { { "foo", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc) { return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture); });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            object newModel = binder.BindComplexModel(null, bindingContext);

            // Assert
            Assert.Null(newModel);
        }

        [Fact]
        public void BindComplexModelWhereModelTypeContainsBindAttribute()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelWithBindAttribute model = new ModelWithBindAttribute()
            {
                Foo = "FooPreValue",
                Bar = "BarPreValue",
                Baz = "BazPreValue",
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { "Foo", null }, { "Bar", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return bc.ModelName + "PostValue";
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(string), mockInnerBinder.Object }
                }
            };

            // Act
            binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal("FooPreValue", model.Foo);
            Assert.Equal("BarPostValue", model.Bar);
            Assert.Equal("BazPreValue", model.Baz);
        }

        [Fact]
        public void BindComplexModelWhereModelTypeDoesNotContainBindAttribute()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelWithoutBindAttribute model = new ModelWithoutBindAttribute()
            {
                Foo = "FooPreValue",
                Bar = "BarPreValue",
                Baz = "BazPreValue",
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { "Foo", null }, { "Bar", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return bc.ModelName + "PostValue";
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(string), mockInnerBinder.Object }
                }
            };

            // Act
            binder.BindComplexModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal("FooPostValue", model.Foo);
            Assert.Equal("BarPostValue", model.Bar);
            Assert.Equal("BazPreValue", model.Baz);
        }

        // BindModel tests

        [Fact]
        public void BindModelCanBindObjects()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            ModelWithoutBindAttribute model = new ModelWithoutBindAttribute()
            {
                Foo = "FooPreValue",
                Bar = "BarPreValue",
                Baz = "BazPreValue",
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { "Foo", null }, { "Bar", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return bc.ModelName + "PostValue";
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(string), mockInnerBinder.Object }
                }
            };

            // Act
            object updatedModel = binder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal("FooPostValue", model.Foo);
            Assert.Equal("BarPostValue", model.Bar);
            Assert.Equal("BazPreValue", model.Baz);
        }

        [Fact]
        public void BindModelCanBindSimpleTypes()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo", "42" }
                }
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            Assert.Equal(42, updatedModel);
        }

        [Fact]
        public void BindModel_PerformsValidationByDefault()
        {
            // Arrange
            ModelMetadata metadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(string));

            ControllerContext controllerContext = new ControllerContext();
            controllerContext.Controller = new SimpleController();

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = metadata,
                ModelName = "foo",
                ValueProvider = new CustomUnvalidatedValueProvider()
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal("fooValidated", updatedModel);
        }

        [Fact]
        public void BindModel_SkipsValidationIfControllerOptsOut()
        {
            // Arrange
            ModelMetadata metadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(string));

            ControllerContext controllerContext = new ControllerContext();
            controllerContext.Controller = new SimpleController();
            controllerContext.Controller.ValidateRequest = false;

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = metadata,
                ModelName = "foo",
                ValueProvider = new CustomUnvalidatedValueProvider()
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal("fooUnvalidated", updatedModel);
        }

        [Fact]
        public void BindModel_SkipsValidationIfModelOptsOut()
        {
            // Arrange
            ModelMetadata metadata = new DataAnnotationsModelMetadataProvider().GetMetadataForType(null, typeof(string));
            metadata.RequestValidationEnabled = false;

            ControllerContext controllerContext = new ControllerContext();
            controllerContext.Controller = new SimpleController();

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = metadata,
                ModelName = "foo",
                ValueProvider = new CustomUnvalidatedValueProvider()
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(controllerContext, bindingContext);

            // Assert
            Assert.Equal("fooUnvalidated", updatedModel);
        }

        [Fact]
        public void BindModelReturnsNullIfKeyNotFound()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object returnedModel = binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            Assert.Null(returnedModel);
        }

        [Fact]
        public void BindModelThrowsIfBindingContextIsNull()
        {
            // Arrange
            DefaultModelBinder binder = new DefaultModelBinder();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { binder.BindModel(new ControllerContext(), null); }, "bindingContext");
        }

        [Fact]
        public void BindModelValuesCanBeOverridden()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => new ModelWithoutBindAttribute(), typeof(ModelWithoutBindAttribute)),
                ModelName = "",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo", "FooPostValue" },
                    { "bar", "BarPostValue" },
                    { "baz", "BazPostValue" }
                }
            };
            Mock<DefaultModelBinder> binder = new Mock<DefaultModelBinder> { CallBase = true };
            binder.Protected().Setup<object>("GetPropertyValue",
                                             ItExpr.IsAny<ControllerContext>(), ItExpr.IsAny<ModelBindingContext>(),
                                             ItExpr.IsAny<PropertyDescriptor>(), ItExpr.IsAny<IModelBinder>())
                .Returns("Hello, world!");

            // Act
            ModelWithoutBindAttribute model = (ModelWithoutBindAttribute)binder.Object.BindModel(new ControllerContext(), bindingContext);

            // Assert
            Assert.Equal("Hello, world!", model.Bar);
            Assert.Equal("Hello, world!", model.Baz);
            Assert.Equal("Hello, world!", model.Foo);
        }

        [Fact]
        public void BindModelWithTypeConversionErrorUpdatesModelStateMessage()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => new PropertyTestingModel(), typeof(PropertyTestingModel)),
                ModelName = "",
                ValueProvider = new SimpleValueProvider()
                {
                    { "IntReadWrite", "foo" }
                },
            };
            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            PropertyTestingModel model = (PropertyTestingModel)binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            ModelState modelState = bindingContext.ModelState["IntReadWrite"];
            Assert.NotNull(modelState);
            ModelError error = Assert.Single(modelState.Errors);
            Assert.Equal("The value 'foo' is not valid for IntReadWrite.", error.ErrorMessage);
        }

        [Fact]
        public void BindModelWithPrefix()
        {
            // Arrange
            ModelWithoutBindAttribute model = new ModelWithoutBindAttribute()
            {
                Foo = "FooPreValue",
                Bar = "BarPreValue",
                Baz = "BazPreValue",
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "prefix",
                ValueProvider = new SimpleValueProvider()
                {
                    { "prefix.foo", "FooPostValue" },
                    { "prefix.bar", "BarPostValue" }
                }
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal("FooPostValue", model.Foo);
            Assert.Equal("BarPostValue", model.Bar);
            Assert.Equal("BazPreValue", model.Baz);
        }

        [Fact]
        public void BindModelWithPrefixAndFallback()
        {
            // Arrange
            ModelWithoutBindAttribute model = new ModelWithoutBindAttribute()
            {
                Foo = "FooPreValue",
                Bar = "BarPreValue",
                Baz = "BazPreValue",
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "prefix",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo", "FooPostValue" },
                    { "bar", "BarPostValue" }
                }
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal("FooPostValue", model.Foo);
            Assert.Equal("BarPostValue", model.Bar);
            Assert.Equal("BazPreValue", model.Baz);
        }

        [Fact]
        public void BindModelWithPrefixReturnsNullIfFallbackNotSpecifiedAndValueProviderContainsNoEntries()
        {
            // Arrange
            ModelWithoutBindAttribute model = new ModelWithoutBindAttribute()
            {
                Foo = "FooPreValue",
                Bar = "BarPreValue",
                Baz = "BazPreValue",
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "prefix",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo", "FooPostValue" },
                    { "bar", "BarPostValue" }
                }
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            Assert.Null(updatedModel);
        }

        [Fact]
        public void BindModelReturnsNullIfSimpleTypeNotFound()
        {
            // DevDiv 216165: ModelBinders should not try and instantiate simple types

            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(string)),
                ModelName = "prefix",
                ValueProvider = new SimpleValueProvider()
                {
                    { "prefix.foo", "foo" },
                    { "prefix.bar", "bar" }
                }
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            Assert.Null(updatedModel);
        }

        // BindProperty tests

        [Fact]
        public void BindPropertyCanUpdateComplexReadOnlyProperties()
        {
            // Arrange
            // the Customer type contains a single read-only Address property
            Customer model = new Customer();
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { "Address", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Address address = (Address)bc.Model;
                        address.Street = "1 Microsoft Way";
                        address.Zip = "98052";
                        return address;
                    });

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)["Address"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(Address), mockInnerBinder.Object }
                }
            };

            // Act
            helper.PublicBindProperty(new ControllerContext(), bindingContext, pd);

            // Assert
            Assert.Equal("1 Microsoft Way", model.Address.Street);
            Assert.Equal("98052", model.Address.Zip);
        }

        [Fact]
        public void BindPropertyDoesNothingIfValueProviderContainsNoEntryForProperty()
        {
            // Arrange
            MyModel2 model = new MyModel2() { IntReadWrite = 3 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider()
            };

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)["IntReadWrite"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            helper.PublicBindProperty(new ControllerContext(), bindingContext, pd);

            // Assert
            Assert.Equal(3, model.IntReadWrite);
        }

        [Fact]
        public void BindProperty()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            MyModel2 model = new MyModel2() { IntReadWrite = 3 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider()
                {
                    { "IntReadWrite", "42" }
                }
            };

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)["IntReadWrite"];

            Mock<DefaultModelBinderHelper> mockHelper = new Mock<DefaultModelBinderHelper>() { CallBase = true };
            mockHelper.Setup(b => b.PublicOnPropertyValidating(controllerContext, bindingContext, pd, 42)).Returns(true).Verifiable();
            mockHelper.Setup(b => b.PublicSetProperty(controllerContext, bindingContext, pd, 42)).Verifiable();
            mockHelper.Setup(b => b.PublicOnPropertyValidated(controllerContext, bindingContext, pd, 42)).Verifiable();
            DefaultModelBinderHelper helper = mockHelper.Object;

            // Act
            helper.PublicBindProperty(controllerContext, bindingContext, pd);

            // Assert
            mockHelper.Verify();
        }

        [Fact]
        public void BindPropertyReturnsIfOnPropertyValidatingReturnsFalse()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            MyModel2 model = new MyModel2() { IntReadWrite = 3 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider()
                {
                    { "IntReadWrite", "42" }
                }
            };

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)["IntReadWrite"];

            Mock<DefaultModelBinderHelper> mockHelper = new Mock<DefaultModelBinderHelper>() { CallBase = true };
            mockHelper.Setup(b => b.PublicOnPropertyValidating(controllerContext, bindingContext, pd, 42)).Returns(false);
            DefaultModelBinderHelper helper = mockHelper.Object;

            // Act
            helper.PublicBindProperty(controllerContext, bindingContext, pd);

            // Assert
            Assert.Equal(3, model.IntReadWrite);
            mockHelper.Verify();
            mockHelper.Verify(b => b.PublicSetProperty(controllerContext, bindingContext, pd, 42), Times.Never());
            mockHelper.Verify(b => b.PublicOnPropertyValidated(controllerContext, bindingContext, pd, 42), Times.Never());
        }

        [Fact]
        public void BindPropertySetsPropertyToNullIfUserLeftTextEntryFieldBlankForOptionalValue()
        {
            // Arrange
            MyModel2 model = new MyModel2() { NullableIntReadWrite = 8 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { "NullableIntReadWrite", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder.Setup(b => b.BindModel(new ControllerContext(), It.IsAny<ModelBindingContext>())).Returns((object)null);

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)["NullableIntReadWrite"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int?), mockInnerBinder.Object }
                }
            };

            // Act
            helper.PublicBindProperty(new ControllerContext(), bindingContext, pd);

            // Assert
            Assert.Empty(bindingContext.ModelState);
            Assert.Null(model.NullableIntReadWrite);
        }

        [Fact]
        public void BindPropertyUpdatesPropertyOnFailureIfInnerBinderReturnsNonNullObject()
        {
            // Arrange
            MyModel2 model = new MyModel2() { IntReadWriteNonNegative = 8 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { "IntReadWriteNonNegative", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        bc.ModelState.AddModelError("IntReadWriteNonNegative", "Some error text.");
                        return 4;
                    });

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)["IntReadWriteNonNegative"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            helper.PublicBindProperty(new ControllerContext(), bindingContext, pd);

            // Assert
            Assert.False(bindingContext.ModelState.IsValidField("IntReadWriteNonNegative"));
            var error = Assert.Single(bindingContext.ModelState["IntReadWriteNonNegative"].Errors);
            Assert.Equal("Some error text.", error.ErrorMessage);
            Assert.Equal(4, model.IntReadWriteNonNegative);
        }

        [Fact]
        public void BindPropertyUpdatesPropertyOnSuccess()
        {
            // Arrange
            // Effectively, this is just testing updating a single property named "IntReadWrite"
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            MyModel2 model = new MyModel2() { IntReadWrite = 3 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                ModelState = new ModelStateDictionary() { { "blah", new ModelState() } },
                ValueProvider = new SimpleValueProvider() { { "foo.IntReadWrite", null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(3, bc.Model);
                        Assert.Equal(typeof(int), bc.ModelType);
                        Assert.Equal("foo.IntReadWrite", bc.ModelName);
                        Assert.Equal(new ModelBindingContext().PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return 4;
                    });

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)["IntReadWrite"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            helper.PublicBindProperty(controllerContext, bindingContext, pd);

            // Assert
            Assert.Equal(4, model.IntReadWrite);
        }

        [Theory]
        [InlineData(typeof(OverflowException))]
        [InlineData(typeof(FormatException))]
        public void BindPropertyReplaceErrorMessages(Type exceptionType)
        {
            // Arrange
            const string propertyName = "IntReadWriteNonNegative";
            MyModel2 model = new MyModel2() { IntReadWriteNonNegative = 8 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { propertyName, null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        bc.ModelState.AddModelError(propertyName, new Exception("", (Exception) Activator.CreateInstance(exceptionType)));
                        bc.ModelState[propertyName].Value = new ValueProviderResult(8, "8", CultureInfo.InvariantCulture);
                        return 4;
                    });

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)[propertyName];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            helper.PublicBindProperty(new ControllerContext(), bindingContext, pd);

            // Assert
            Assert.False(bindingContext.ModelState.IsValidField(propertyName));
            var error = Assert.Single(bindingContext.ModelState[propertyName].Errors);
            Assert.Equal("The value '8' is not valid for " + propertyName + ".", error.ErrorMessage);
            Assert.Equal(4, model.IntReadWriteNonNegative);
        }

        [Theory]
        [InlineData(typeof(MissingMemberException))]
        [InlineData(typeof(IndexOutOfRangeException))]
        public void BindPropertyNotShowErrorMessage(Type exceptionType)
        {
            // Arrange
            const string propertyName = "IntReadWriteNonNegative";
            MyModel2 model = new MyModel2() { IntReadWriteNonNegative = 8 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = new SimpleValueProvider() { { propertyName, null } }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        bc.ModelState.AddModelError(propertyName, new Exception("", (Exception)Activator.CreateInstance(exceptionType)));
                        bc.ModelState[propertyName].Value = new ValueProviderResult(8, "8", CultureInfo.InvariantCulture);
                        return 4;
                    });

            PropertyDescriptor pd = TypeDescriptor.GetProperties(model)[propertyName];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            helper.PublicBindProperty(new ControllerContext(), bindingContext, pd);

            // Assert
            Assert.False(bindingContext.ModelState.IsValidField(propertyName));
            var error = Assert.Single(bindingContext.ModelState[propertyName].Errors);
            Assert.Equal(String.Empty, error.ErrorMessage);
            Assert.Equal(4, model.IntReadWriteNonNegative);
        }

        // BindSimpleModel tests

        [Fact]
        public void BindSimpleModelCanReturnArrayTypes()
        {
            // Arrange
            ValueProviderResult result = new ValueProviderResult(42, null, null);
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(int[])),
                ModelName = "foo",
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object returnedValue = binder.BindSimpleModel(null, bindingContext, result);

            // Assert
            var returnedValueAsIntArray = Assert.IsType<int[]>(returnedValue);
            var returnedInt = Assert.Single(returnedValueAsIntArray);
            Assert.Equal(42, returnedInt);
        }

        [Fact]
        public void BindSimpleModelCanReturnCollectionTypes()
        {
            // Arrange
            ValueProviderResult result = new ValueProviderResult(new string[] { "42", "82" }, null, null);
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(IEnumerable<int>)),
                ModelName = "foo",
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object returnedValue = binder.BindSimpleModel(null, bindingContext, result);

            // Assert
            var returnedValueAsList = Assert.IsAssignableFrom<IEnumerable<int>>(returnedValue).ToList();
            Assert.Equal(2, returnedValueAsList.Count);
            Assert.Equal(42, returnedValueAsList[0]);
            Assert.Equal(82, returnedValueAsList[1]);
        }

        [Fact]
        public void BindSimpleModelCanReturnElementalTypes()
        {
            // Arrange
            ValueProviderResult result = new ValueProviderResult("42", null, null);
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object returnedValue = binder.BindSimpleModel(null, bindingContext, result);

            // Assert
            Assert.Equal(42, returnedValue);
        }

        [Fact]
        public void BindSimpleModelCanReturnStrings()
        {
            // Arrange
            ValueProviderResult result = new ValueProviderResult(new object[] { "42" }, null, null);
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(string)),
                ModelName = "foo",
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object returnedValue = binder.BindSimpleModel(null, bindingContext, result);

            // Assert
            Assert.Equal("42", returnedValue);
        }

        [Fact]
        public void BindSimpleModelChecksValueProviderResultRawValueType()
        {
            // Arrange
            ValueProviderResult result = new ValueProviderResult(new MemoryStream(), null, null);
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(Stream)),
                ModelName = "foo",
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object returnedValue = binder.BindSimpleModel(null, bindingContext, result);

            // Assert
            Assert.Equal(result, bindingContext.ModelState["foo"].Value);
            Assert.Same(result.RawValue, returnedValue);
        }

        [Fact]
        public void BindSimpleModelPropagatesErrorsOnFailure()
        {
            // Arrange
            ValueProviderResult result = new ValueProviderResult("invalid", null, null);
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(int)),
                ModelName = "foo",
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object returnedValue = binder.BindSimpleModel(null, bindingContext, result);

            // Assert
            Assert.False(bindingContext.ModelState.IsValidField("foo"));
            InvalidOperationException exception = Assert.IsType<InvalidOperationException>(bindingContext.ModelState["foo"].Errors[0].Exception);
            Assert.Equal("The parameter conversion from type 'System.String' to type 'System.Int32' failed. See the inner exception for more information.", exception.Message);
            Assert.Null(returnedValue);
        }

        [Fact]
        public void CreateComplexElementalModelBindingContext_ReadsBindAttributeFromBuddyClass()
        {
            // Arrange
            ModelBindingContext originalBindingContext = new ModelBindingContext()
            {
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(CreateComplexElementalModelBindingContext_ReadsBindAttributeFromBuddyClass_Model)),
                ModelName = "someName",
                ValueProvider = new SimpleValueProvider()
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            ModelBindingContext newBindingContext = binder.CreateComplexElementalModelBindingContext(new ControllerContext(), originalBindingContext, null);

            // Assert
            Assert.True(newBindingContext.PropertyFilter("foo"));
            Assert.False(newBindingContext.PropertyFilter("bar"));
        }

        [MetadataType(typeof(CreateComplexElementalModelBindingContext_ReadsBindAttributeFromBuddyClass_Model_BuddyClass))]
        private class CreateComplexElementalModelBindingContext_ReadsBindAttributeFromBuddyClass_Model
        {
            [Bind(Include = "foo")]
            private class CreateComplexElementalModelBindingContext_ReadsBindAttributeFromBuddyClass_Model_BuddyClass
            {
            }
        }

        [Fact]
        public void CreateInstanceCreatesModelInstance()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            object modelObj = helper.PublicCreateModel(null, null, typeof(Guid));

            // Assert
            Assert.Equal(Guid.Empty, modelObj);
        }

        [Fact]
        public void CreateInstanceCreatesModelInstanceForGenericICollection()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            object modelObj = helper.PublicCreateModel(null, null, typeof(ICollection<Guid>));

            // Assert
            Assert.IsAssignableFrom<ICollection<Guid>>(modelObj);
        }

        [Fact]
        public void CreateInstanceCreatesModelInstanceForGenericIDictionary()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            object modelObj = helper.PublicCreateModel(null, null, typeof(IDictionary<string, Guid>));

            // Assert
            Assert.IsAssignableFrom<IDictionary<string, Guid>>(modelObj);
        }

        [Fact]
        public void CreateInstanceCreatesModelInstanceForGenericIEnumerable()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            object modelObj = helper.PublicCreateModel(null, null, typeof(IEnumerable<Guid>));

            // Assert
            Assert.IsAssignableFrom<ICollection<Guid>>(modelObj);
        }

        [Fact]
        public void CreateInstanceCreatesModelInstanceForGenericIList()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            object modelObj = helper.PublicCreateModel(null, null, typeof(IList<Guid>));

            // Assert
            Assert.IsAssignableFrom<IList<Guid>>(modelObj);
        }

        [Fact]
        public void CreateInstanceCreatesModelInstanceForGenericIListWithoutParameterlessConstructor()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            // No need for type parameter to have a parameterless constructor
            object modelObject = helper.PublicCreateModel(null, null, typeof(IList<NoParameterlessCtor>));

            // Assert
            Assert.IsAssignableFrom<IList<NoParameterlessCtor>>(modelObject);
        }

        [Fact]
        public void CreateInstanceThrowsWithoutParameterlessConstructor()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act & Assert, confirming type name and full stack are available in Exception
            MissingMethodException exception = Assert.Throws<MissingMethodException>(
                () => helper.PublicCreateModel(null, null, typeof(NoParameterlessCtor)),
                "No parameterless constructor defined for this object. Object type 'System.Web.Mvc.Test.DefaultModelBinderTest+NoParameterlessCtor'.");
            Assert.Contains("System.Activator.CreateInstance(", exception.ToString());
        }

        [Fact]
        public void CreateSubIndexNameReturnsPrefixPlusIndex()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            string newName = helper.PublicCreateSubIndexName("somePrefix", 2);

            // Assert
            Assert.Equal("somePrefix[2]", newName);
        }

        [Fact]
        public void CreateSubPropertyNameReturnsPrefixPlusPropertyName()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            string newName = helper.PublicCreateSubPropertyName("somePrefix", "someProperty");

            // Assert
            Assert.Equal("somePrefix.someProperty", newName);
        }

        [Fact]
        public void CreateSubPropertyNameReturnsPropertyNameIfPrefixIsEmpty()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            string newName = helper.PublicCreateSubPropertyName(String.Empty, "someProperty");

            // Assert
            Assert.Equal("someProperty", newName);
        }

        [Fact]
        public void CreateSubPropertyNameReturnsPropertyNameIfPrefixIsNull()
        {
            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            string newName = helper.PublicCreateSubPropertyName(null, "someProperty");

            // Assert
            Assert.Equal("someProperty", newName);
        }

        [Fact]
        public void GetFilteredModelPropertiesFiltersNonUpdateableProperties()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(PropertyTestingModel)),
                PropertyFilter = new BindAttribute() { Exclude = "Blacklisted" }.IsPropertyAllowed
            };

            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            PropertyDescriptorCollection properties = new PropertyDescriptorCollection(helper.PublicGetFilteredModelProperties(null, bindingContext).ToArray());

            // Assert
            Assert.NotNull(properties["StringReadWrite"]);
            Assert.Null(properties["StringReadOnly"]);
            Assert.NotNull(properties["IntReadWrite"]);
            Assert.Null(properties["IntReadOnly"]);
            Assert.NotNull(properties["ArrayReadWrite"]);
            Assert.Null(properties["ArrayReadOnly"]);
            Assert.NotNull(properties["AddressReadWrite"]);
            Assert.NotNull(properties["AddressReadOnly"]);
            Assert.NotNull(properties["Whitelisted"]);
            Assert.Null(properties["Blacklisted"]);
            Assert.Equal(6, properties.Count);
        }

        [Fact]
        public void GetModelPropertiesReturnsUnfilteredPropertyList()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(PropertyTestingModel)),
                PropertyFilter = new BindAttribute() { Exclude = "Blacklisted" }.IsPropertyAllowed
            };

            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            PropertyDescriptorCollection properties = helper.PublicGetModelProperties(null, bindingContext);

            // Assert
            Assert.NotNull(properties["StringReadWrite"]);
            Assert.NotNull(properties["StringReadOnly"]);
            Assert.NotNull(properties["IntReadWrite"]);
            Assert.NotNull(properties["IntReadOnly"]);
            Assert.NotNull(properties["ArrayReadWrite"]);
            Assert.NotNull(properties["ArrayReadOnly"]);
            Assert.NotNull(properties["AddressReadWrite"]);
            Assert.NotNull(properties["AddressReadOnly"]);
            Assert.NotNull(properties["Whitelisted"]);
            Assert.NotNull(properties["Blacklisted"]);
            Assert.Equal(10, properties.Count);
        }

        [Fact]
        public void IsModelValidWithNullBindingContextThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => DefaultModelBinderHelper.PublicIsModelValid(null),
                "bindingContext");
        }

        [Fact]
        public void IsModelValidReturnsModelStateIsValidWhenModelNameIsEmpty()
        {
            // Arrange
            ModelBindingContext contextWithNoErrors = new ModelBindingContext { ModelName = "" };
            ModelBindingContext contextWithErrors = new ModelBindingContext { ModelName = "" };
            contextWithErrors.ModelState.AddModelError("foo", "bar");

            // Act & Assert
            Assert.True(DefaultModelBinderHelper.PublicIsModelValid(contextWithNoErrors));
            Assert.False(DefaultModelBinderHelper.PublicIsModelValid(contextWithErrors));
        }

        [Fact]
        public void IsModelValidReturnsValidityOfSubModelStateWhenModelNameIsNotEmpty()
        {
            // Arrange
            ModelBindingContext contextWithNoErrors = new ModelBindingContext { ModelName = "foo" };
            ModelBindingContext contextWithErrors = new ModelBindingContext { ModelName = "foo" };
            contextWithErrors.ModelState.AddModelError("foo.bar", "baz");
            ModelBindingContext contextWithUnrelatedErrors = new ModelBindingContext { ModelName = "foo" };
            contextWithUnrelatedErrors.ModelState.AddModelError("biff", "baz");

            // Act & Assert
            Assert.True(DefaultModelBinderHelper.PublicIsModelValid(contextWithNoErrors));
            Assert.False(DefaultModelBinderHelper.PublicIsModelValid(contextWithErrors));
            Assert.True(DefaultModelBinderHelper.PublicIsModelValid(contextWithUnrelatedErrors));
        }

        [Fact]
        public void OnModelUpdatingReturnsTrue()
        {
            // By default, this method does nothing, so we just want to make sure it returns true

            // Arrange
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            bool returned = helper.PublicOnModelUpdating(null, null);

            // Arrange
            Assert.True(returned);
        }

        // OnModelUpdated tests

        [Fact]
        public void OnModelUpdatedCalledWhenOnModelUpdatingReturnsTrue()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => new ModelWithoutBindAttribute(), typeof(ModelWithoutBindAttribute)),
                ModelName = "",
                ValueProvider = new SimpleValueProvider()
            };
            Mock<DefaultModelBinder> binder = new Mock<DefaultModelBinder> { CallBase = true };
            binder.Protected().Setup<bool>("OnModelUpdating",
                                           ItExpr.IsAny<ControllerContext>(), ItExpr.IsAny<ModelBindingContext>())
                .Returns(true);
            binder.Protected().Setup("OnModelUpdated",
                                     ItExpr.IsAny<ControllerContext>(), ItExpr.IsAny<ModelBindingContext>())
                .Verifiable();

            // Act
            binder.Object.BindModel(new ControllerContext(), bindingContext);

            // Assert
            binder.Verify();
        }

        [Fact]
        public void OnModelUpdatedNotCalledWhenOnModelUpdatingReturnsFalse()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => new ModelWithoutBindAttribute(), typeof(ModelWithoutBindAttribute)),
                ModelName = "",
                ValueProvider = new SimpleValueProvider()
            };
            Mock<DefaultModelBinder> binder = new Mock<DefaultModelBinder> { CallBase = true };
            binder.Protected().Setup<bool>("OnModelUpdating",
                                           ItExpr.IsAny<ControllerContext>(), ItExpr.IsAny<ModelBindingContext>())
                .Returns(false);

            // Act
            binder.Object.BindModel(new ControllerContext(), bindingContext);

            // Assert
            binder.Verify();
            binder.Protected().Verify("OnModelUpdated", Times.Never(),
                                      ItExpr.IsAny<ControllerContext>(), ItExpr.IsAny<ModelBindingContext>());
        }

        [Fact]
        public void OnModelUpdatedDoesntAddNewMessagesWhenMessagesAlreadyExist()
        {
            // Arrange
            var binder = new TestableDefaultModelBinder<SetPropertyModel>();
            binder.Context.ModelState.AddModelError(BASE_MODEL_NAME + ".NonNullableStringWithAttribute", "Some pre-existing error");

            // Act
            binder.OnModelUpdated();

            // Assert
            var modelState = binder.Context.ModelState[BASE_MODEL_NAME + ".NonNullableStringWithAttribute"];
            var error = Assert.Single(modelState.Errors);
            Assert.Equal("Some pre-existing error", error.ErrorMessage);
        }

        [Fact]
        public void OnPropertyValidatingNotCalledOnPropertiesWithErrors()
        {
            // Arrange
            ModelWithoutBindAttribute model = new ModelWithoutBindAttribute();
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo", "foo" }
                },
            };
            bindingContext.ModelState.AddModelError("foo", "Pre-existing error");
            Mock<DefaultModelBinder> binder = new Mock<DefaultModelBinder> { CallBase = true };

            // Act
            binder.Object.BindModel(new ControllerContext(), bindingContext);

            // Assert
            binder.Verify();
            binder.Protected().Verify("OnPropertyValidating", Times.Never(),
                                      ItExpr.IsAny<ControllerContext>(), ItExpr.IsAny<ModelBindingContext>(),
                                      ItExpr.IsAny<PropertyDescriptor>(), ItExpr.IsAny<object>());
        }

        public class ExtraValueModel
        {
            public int RequiredValue { get; set; }
        }

        [Fact]
        public void ExtraValueRequiredMessageNotAddedForAlreadyInvalidProperty()
        {
            // Arrange
            DefaultModelBinder binder = new DefaultModelBinder();
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(MyModel)),
                ModelName = "theModel",
                ValueProvider = new SimpleValueProvider()
            };
            bindingContext.ModelState.AddModelError("theModel.ReadWriteProperty", "Existing Error Message");

            // Act
            binder.BindModel(new ControllerContext(), bindingContext);

            // Assert
            ModelState modelState = bindingContext.ModelState["theModel.ReadWriteProperty"];
            var error = Assert.Single(modelState.Errors);
            Assert.Equal("Existing Error Message", error.ErrorMessage);
        }

        [Fact]
        public void OnPropertyValidatingReturnsTrueOnSuccess()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(MyModel)),
                ModelName = "theModel"
            };

            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MyModel))["ReadWriteProperty"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();
            bindingContext.PropertyMetadata["ReadWriteProperty"].Model = 42;

            // Act
            bool returned = helper.PublicOnPropertyValidating(new ControllerContext(), bindingContext, property, 42);

            // Assert
            Assert.True(returned);
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void UpdateCollectionCreatesDefaultEntriesForInvalidElements()
        {
            // Arrange
            List<int> model = new List<int>() { 4, 5, 6, 7, 8 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0]", null },
                    { "foo[1]", null },
                    { "foo[2]", null }
                }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        int fooIdx = Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
                        return (fooIdx == 1) ? (object)null : fooIdx;
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            object updatedModel = binder.UpdateCollection(null, bindingContext, typeof(int));

            // Assert
            Assert.Equal(3, model.Count);
            Assert.False(bindingContext.ModelState.IsValidField("foo[1]"));
            Assert.Equal("A value is required.", bindingContext.ModelState["foo[1]"].Errors[0].ErrorMessage);
            Assert.Equal(0, model[0]);
            Assert.Equal(0, model[1]);
            Assert.Equal(2, model[2]);
        }

        [Fact]
        public void UpdateCollectionReturnsModifiedCollectionOnSuccess_ExplicitIndex()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            List<int> model = new List<int>() { 4, 5, 6, 7, 8 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo.index", new string[] { "alpha", "bravo", "charlie" } }, // 'bravo' will be skipped
                    { "foo[alpha]", "10" },
                    { "foo[charlie]", "30" }
                }
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.UpdateCollection(controllerContext, bindingContext, typeof(int));

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal(2, model.Count);
            Assert.Equal(10, model[0]);
            Assert.Equal(30, model[1]);
        }

        [Fact]
        public void UpdateCollectionReturnsModifiedCollectionOnSuccess_ZeroBased()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            List<int> model = new List<int>() { 4, 5, 6, 7, 8 };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0]", null },
                    { "foo[1]", null },
                    { "foo[2]", null }
                }
            };

            Mock<IModelBinder> mockInnerBinder = new Mock<IModelBinder>();
            mockInnerBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(typeof(int), bc.ModelType);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(bindingContext.PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockInnerBinder.Object }
                }
            };

            // Act
            object updatedModel = binder.UpdateCollection(controllerContext, bindingContext, typeof(int));

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal(3, model.Count);
            Assert.Equal(0, model[0]);
            Assert.Equal(1, model[1]);
            Assert.Equal(2, model[2]);
        }

        [Fact]
        public void UpdateCollectionReturnsNullIfZeroIndexNotFound()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ValueProvider = new SimpleValueProvider()
            };
            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.UpdateCollection(null, bindingContext, typeof(object));

            // Assert
            Assert.Null(updatedModel);
        }

        [Fact]
        public void UpdateDictionaryCreatesDefaultEntriesForInvalidValues()
        {
            // Arrange
            Dictionary<string, int> model = new Dictionary<string, int>
            {
                { "one", 1 },
                { "two", 2 }
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0].key", null }, { "foo[0].value", null },
                    { "foo[1].key", null }, { "foo[1].value", null },
                    { "foo[2].key", null }, { "foo[2].value", null }
                }
            };

            Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
            mockStringBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc) { return (Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10) + "Value"; });

            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            mockIntBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        int fooIdx = Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
                        return (fooIdx == 1) ? (object)null : fooIdx;
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(string), mockStringBinder.Object },
                    { typeof(int), mockIntBinder.Object }
                }
            };

            // Act
            object updatedModel = binder.UpdateDictionary(null, bindingContext, typeof(string), typeof(int));

            // Assert
            Assert.Equal(3, model.Count);
            Assert.False(bindingContext.ModelState.IsValidField("foo[1].value"));
            Assert.Equal("A value is required.", bindingContext.ModelState["foo[1].value"].Errors[0].ErrorMessage);
            Assert.Equal(0, model["10Value"]);
            Assert.Equal(0, model["11Value"]);
            Assert.Equal(2, model["12Value"]);
        }

        [Fact]
        public void UpdateDictionaryReturnsModifiedDictionaryOnSuccess_ExplicitIndex()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            Dictionary<int, string> model = new Dictionary<int, string>
            {
                { 1, "one" },
                { 2, "two" }
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo.index", new string[] { "alpha", "bravo", "charlie" } }, // 'bravo' will be skipped
                    { "foo[alpha].key", "10" }, { "foo[alpha].value", "ten" },
                    { "foo[charlie].key", "30" }, { "foo[charlie].value", "thirty" }
                }
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            object updatedModel = binder.UpdateDictionary(controllerContext, bindingContext, typeof(int), typeof(string));

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal(2, model.Count);
            Assert.Equal("ten", model[10]);
            Assert.Equal("thirty", model[30]);
        }

        [Fact]
        public void UpdateDictionaryReturnsModifiedDictionaryOnSuccess_ZeroBased()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;

            Dictionary<int, string> model = new Dictionary<int, string>
            {
                { 1, "one" },
                { 2, "two" }
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0].key", null }, { "foo[0].value", null },
                    { "foo[1].key", null }, { "foo[1].value", null },
                    { "foo[2].key", null }, { "foo[2].value", null }
                }
            };

            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            mockIntBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(typeof(int), bc.ModelType);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(new ModelBindingContext().PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10;
                    });

            Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
            mockStringBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        Assert.Equal(controllerContext, cc);
                        Assert.Equal(typeof(string), bc.ModelType);
                        Assert.Equal(bindingContext.ModelState, bc.ModelState);
                        Assert.Equal(bindingContext.PropertyFilter, bc.PropertyFilter);
                        Assert.Equal(bindingContext.ValueProvider, bc.ValueProvider);
                        return (Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10) + "Value";
                    });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockIntBinder.Object },
                    { typeof(string), mockStringBinder.Object }
                }
            };

            // Act
            object updatedModel = binder.UpdateDictionary(controllerContext, bindingContext, typeof(int), typeof(string));

            // Assert
            Assert.Same(model, updatedModel);
            Assert.Equal(3, model.Count);
            Assert.Equal("10Value", model[10]);
            Assert.Equal("11Value", model[11]);
            Assert.Equal("12Value", model[12]);
        }

        [Fact]
        public void UpdateDictionaryReturnsEmptyDictionaryIfNoValidElementsFound()
        {
            // Arrange
            Mock<ControllerContext> mockController = new Mock<ControllerContext>();

            mockController
                .Setup(c => c.RouteData)
                .Returns(
                    delegate()
                    {
                        RouteData routeData = new RouteData();
                        routeData.Values["controller"] = "controller";
                        return routeData;
                    }
            );

            ControllerContext controllerContext = mockController.Object;

            Dictionary<int, string> model = new Dictionary<int, string>();

            RouteDataValueProviderFactory routeDataFactory = new RouteDataValueProviderFactory();

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ValueProvider = routeDataFactory.GetValueProvider(controllerContext)
            };

            DefaultModelBinder binder = new DefaultModelBinder();

            // Act
            Dictionary<int, string> updatedModel = binder.UpdateDictionary(controllerContext, bindingContext, typeof(int), typeof(string)) as Dictionary<int, string>;

            // Assert
            Assert.NotNull(updatedModel);
            Assert.Empty(updatedModel);
        }

        [Fact]
        public void UpdateDictionarySkipsInvalidKeys()
        {
            // Arrange
            Dictionary<int, string> model = new Dictionary<int, string>
            {
                { 1, "one" },
                { 2, "two" }
            };
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "foo",
                ValueProvider = new SimpleValueProvider()
                {
                    { "foo[0].key", null }, { "foo[0].value", null },
                    { "foo[1].key", null }, { "foo[1].value", null },
                    { "foo[2].key", null }, { "foo[2].value", null }
                }
            };

            Mock<IModelBinder> mockIntBinder = new Mock<IModelBinder>();
            mockIntBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc)
                    {
                        int fooIdx = Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture);
                        return (fooIdx == 1) ? (object)null : fooIdx;
                    });

            Mock<IModelBinder> mockStringBinder = new Mock<IModelBinder>();
            mockStringBinder
                .Setup(b => b.BindModel(It.IsAny<ControllerContext>(), It.IsAny<ModelBindingContext>()))
                .Returns(
                    delegate(ControllerContext cc, ModelBindingContext bc) { return (Int32.Parse(bc.ModelName.Substring(4, 1), CultureInfo.InvariantCulture) + 10) + "Value"; });

            DefaultModelBinder binder = new DefaultModelBinder()
            {
                Binders = new ModelBinderDictionary()
                {
                    { typeof(int), mockIntBinder.Object },
                    { typeof(string), mockStringBinder.Object }
                }
            };

            // Act
            object updatedModel = binder.UpdateDictionary(null, bindingContext, typeof(int), typeof(string));

            // Assert
            Assert.Equal(2, model.Count);
            Assert.False(bindingContext.ModelState.IsValidField("foo[1].key"));
            Assert.Equal("A value is required.", bindingContext.ModelState["foo[1].key"].Errors[0].ErrorMessage);
            Assert.Equal("10Value", model[0]);
            Assert.Equal("12Value", model[2]);
        }

        [ModelBinder(typeof(DefaultModelBinder))]
        private class MyModel
        {
            public int ReadOnlyProperty
            {
                get { return 4; }
            }

            public int ReadWriteProperty { get; set; }
            public int ReadWriteProperty2 { get; set; }
        }

        private class MyClassWithoutConverter
        {
        }

        [Bind(Exclude = "Alpha,Echo")]
        private class MyOtherModel
        {
            public string Alpha { get; set; }
            public string Bravo { get; set; }
            public string Charlie { get; set; }
            public string Delta { get; set; }
            public string Echo { get; set; }
            public string Foxtrot { get; set; }
        }

        public class Customer
        {
            private Address _address = new Address();

            public Address Address
            {
                get { return _address; }
            }
        }

        public class Address
        {
            public string Street { get; set; }
            public string Zip { get; set; }
        }

        public class IntegerContainer
        {
            public int Integer { get; set; }
            public int? NullableInteger { get; set; }
        }

        [TypeConverter(typeof(CultureAwareConverter))]
        public class StringContainer
        {
            public StringContainer(string value)
            {
                Value = value;
            }

            public string Value { get; private set; }
        }

        private class CultureAwareConverter : TypeConverter
        {
            public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType)
            {
                return (sourceType == typeof(string));
            }

            public override bool CanConvertTo(ITypeDescriptorContext context, Type destinationType)
            {
                return (destinationType == typeof(string));
            }

            public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
            {
                string stringValue = value as string;
                if (stringValue == null || stringValue.Length < 3)
                {
                    throw new Exception("Value must have at least 3 characters.");
                }
                return new StringContainer(AppendCultureName(stringValue, culture));
            }

            public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
            {
                StringContainer container = value as StringContainer;
                if (container.Value == null || container.Value.Length < 3)
                {
                    throw new Exception("Value must have at least 3 characters.");
                }

                return AppendCultureName(container.Value, culture);
            }

            private static string AppendCultureName(string value, CultureInfo culture)
            {
                string cultureName = (!String.IsNullOrEmpty(culture.Name)) ? culture.Name : culture.ThreeLetterWindowsLanguageName;
                return value + " (" + cultureName + ")";
            }
        }

        [ModelBinder(typeof(MyStringModelBinder))]
        private class MyStringModel
        {
            public string Value { get; set; }
        }

        private class MyStringModelBinder : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                MyStringModel castModel = bindingContext.Model as MyStringModel;
                if (castModel != null)
                {
                    castModel.Value += "_Update";
                }
                else
                {
                    castModel = new MyStringModel() { Value = bindingContext.ModelName + "_Create" };
                }
                return castModel;
            }
        }

        private class CustomUnvalidatedValueProvider : IUnvalidatedValueProvider
        {
            public ValueProviderResult GetValue(string key, bool skipValidation)
            {
                string newValue = key + ((skipValidation) ? "Unvalidated" : "Validated");
                return new ValueProviderResult(newValue, newValue, null);
            }

            public bool ContainsPrefix(string prefix)
            {
                return true;
            }

            public ValueProviderResult GetValue(string key)
            {
                return GetValue(key, skipValidation: false);
            }
        }

        private class SimpleController : Controller
        {
        }

        public class DefaultModelBinderHelper : DefaultModelBinder
        {
            public virtual void PublicBindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property)
            {
                base.BindProperty(controllerContext, bindingContext, property);
            }

            protected override void BindProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property)
            {
                PublicBindProperty(controllerContext, bindingContext, property);
            }

            public virtual object PublicCreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType)
            {
                return base.CreateModel(controllerContext, bindingContext, modelType);
            }

            protected override object CreateModel(ControllerContext controllerContext, ModelBindingContext bindingContext, Type modelType)
            {
                return PublicCreateModel(controllerContext, bindingContext, modelType);
            }

            public virtual IEnumerable<PropertyDescriptor> PublicGetFilteredModelProperties(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                return base.GetFilteredModelProperties(controllerContext, bindingContext);
            }

            public virtual PropertyDescriptorCollection PublicGetModelProperties(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                return base.GetModelProperties(controllerContext, bindingContext);
            }

            protected override PropertyDescriptorCollection GetModelProperties(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                return PublicGetModelProperties(controllerContext, bindingContext);
            }

            public string PublicCreateSubIndexName(string prefix, int indexName)
            {
                return CreateSubIndexName(prefix, indexName);
            }

            public string PublicCreateSubPropertyName(string prefix, string propertyName)
            {
                return CreateSubPropertyName(prefix, propertyName);
            }

            public static bool PublicIsModelValid(ModelBindingContext bindingContext)
            {
                return IsModelValid(bindingContext);
            }

            public virtual bool PublicOnModelUpdating(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                return base.OnModelUpdating(controllerContext, bindingContext);
            }

            protected override bool OnModelUpdating(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                return PublicOnModelUpdating(controllerContext, bindingContext);
            }

            public virtual void PublicOnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                base.OnModelUpdated(controllerContext, bindingContext);
            }

            protected override void OnModelUpdated(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                PublicOnModelUpdated(controllerContext, bindingContext);
            }

            public virtual bool PublicOnPropertyValidating(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property, object value)
            {
                return base.OnPropertyValidating(controllerContext, bindingContext, property, value);
            }

            protected override bool OnPropertyValidating(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property, object value)
            {
                return PublicOnPropertyValidating(controllerContext, bindingContext, property, value);
            }

            public virtual void PublicOnPropertyValidated(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property, object value)
            {
                base.OnPropertyValidated(controllerContext, bindingContext, property, value);
            }

            protected override void OnPropertyValidated(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property, object value)
            {
                PublicOnPropertyValidated(controllerContext, bindingContext, property, value);
            }

            public virtual void PublicSetProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property, object value)
            {
                base.SetProperty(controllerContext, bindingContext, property, value);
            }

            protected override void SetProperty(ControllerContext controllerContext, ModelBindingContext bindingContext, PropertyDescriptor property, object value)
            {
                PublicSetProperty(controllerContext, bindingContext, property, value);
            }
        }

        private class MyModel2
        {
            private int _intReadWriteNonNegative;

            public int IntReadOnly
            {
                get { return 4; }
            }

            public int IntReadWrite { get; set; }

            public int IntReadWriteNonNegative
            {
                get { return _intReadWriteNonNegative; }
                set
                {
                    if (value < 0)
                    {
                        throw new ArgumentOutOfRangeException("value", "Value must be non-negative.");
                    }
                    _intReadWriteNonNegative = value;
                }
            }

            public int? NullableIntReadWrite { get; set; }
        }

        [Bind(Exclude = "Foo")]
        private class ModelWithBindAttribute : ModelWithoutBindAttribute
        {
        }

        private class ModelWithoutBindAttribute
        {
            public string Foo { get; set; }
            public string Bar { get; set; }
            public string Baz { get; set; }
        }

        private class PropertyTestingModel
        {
            public string StringReadWrite { get; set; }
            public string StringReadOnly { get; private set; }
            public int IntReadWrite { get; set; }
            public int IntReadOnly { get; private set; }
            public object[] ArrayReadWrite { get; set; }
            public object[] ArrayReadOnly { get; private set; }
            public Address AddressReadWrite { get; set; }
            public Address AddressReadOnly { get; private set; }
            public string Whitelisted { get; set; }
            public string Blacklisted { get; set; }
        }

        // --------------------------------------------------------------------------------
        //  DataAnnotations tests

        public const string BASE_MODEL_NAME = "BaseModelName";

        // GetModelProperties tests

        [MetadataType(typeof(Metadata))]
        class GetModelPropertiesModel
        {
            [Required]
            public int LocalAttributes { get; set; }

            public int MetadataAttributes { get; set; }

            [Required]
            public int MixedAttributes { get; set; }

            class Metadata
            {
                [Range(10, 100)]
                public int MetadataAttributes { get; set; }

                [Range(10, 100)]
                public int MixedAttributes { get; set; }
            }
        }

        [Fact]
        public void GetModelPropertiesWithLocalAttributes()
        {
            // Arrange
            TestableDefaultModelBinder<GetModelPropertiesModel> modelBinder = new TestableDefaultModelBinder<GetModelPropertiesModel>();

            // Act
            PropertyDescriptor property = modelBinder.GetModelProperties()
                .Cast<PropertyDescriptor>()
                .Where(pd => pd.Name == "LocalAttributes")
                .Single();

            // Assert
            Assert.Contains(property.Attributes.Cast<Attribute>(), a => a is RequiredAttribute);
        }

        [Fact]
        public void GetModelPropertiesWithMetadataAttributes()
        {
            // Arrange
            TestableDefaultModelBinder<GetModelPropertiesModel> modelBinder = new TestableDefaultModelBinder<GetModelPropertiesModel>();

            // Act
            PropertyDescriptor property = modelBinder.GetModelProperties()
                .Cast<PropertyDescriptor>()
                .Where(pd => pd.Name == "MetadataAttributes")
                .Single();

            // Assert
            Assert.Contains(property.Attributes.Cast<Attribute>(), a => a is RangeAttribute);
        }

        [Fact]
        public void GetModelPropertiesWithMixedAttributes()
        {
            // Arrange
            TestableDefaultModelBinder<GetModelPropertiesModel> modelBinder = new TestableDefaultModelBinder<GetModelPropertiesModel>();

            // Act
            PropertyDescriptor property = modelBinder.GetModelProperties()
                .Cast<PropertyDescriptor>()
                .Where(pd => pd.Name == "MixedAttributes")
                .Single();

            // Assert
            Assert.Contains(property.Attributes.Cast<Attribute>(), a => a is RequiredAttribute);
            Assert.Contains(property.Attributes.Cast<Attribute>(), a => a is RangeAttribute);
        }

        // GetPropertyValue tests

        class GetPropertyValueModel
        {
            public string NoAttribute { get; set; }

            [DisplayFormat(ConvertEmptyStringToNull = false)]
            public string AttributeWithoutConversion { get; set; }

            [DisplayFormat(ConvertEmptyStringToNull = true)]
            public string AttributeWithConversion { get; set; }
        }

        [Fact]
        public void GetPropertyValueWithNoAttributeConvertsEmptyStringToNull()
        {
            // Arrange
            TestableDefaultModelBinder<GetPropertyValueModel> binder = new TestableDefaultModelBinder<GetPropertyValueModel>();
            binder.Context.ModelMetadata = binder.Context.PropertyMetadata["NoAttribute"];

            // Act
            object result = binder.GetPropertyValue("NoAttribute", String.Empty);

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public void GetPropertyValueWithFalseAttributeDoesNotConvertEmptyStringToNull()
        {
            // Arrange
            TestableDefaultModelBinder<GetPropertyValueModel> binder = new TestableDefaultModelBinder<GetPropertyValueModel>();
            binder.Context.ModelMetadata = binder.Context.PropertyMetadata["AttributeWithoutConversion"];

            // Act
            object result = binder.GetPropertyValue("AttributeWithoutConversion", String.Empty);

            // Assert
            Assert.Equal(String.Empty, result);
        }

        [Fact]
        public void GetPropertyValueWithTrueAttributeConvertsEmptyStringToNull()
        {
            // Arrange
            TestableDefaultModelBinder<GetPropertyValueModel> binder = new TestableDefaultModelBinder<GetPropertyValueModel>();
            binder.Context.ModelMetadata = binder.Context.PropertyMetadata["AttributeWithConversion"];

            // Act
            object result = binder.GetPropertyValue("AttributeWithConversion", String.Empty);

            // Assert
            Assert.Null(result);
        }

        // OnModelUpdated tests

        [Fact]
        public void OnModelUpdatedPassesNullContainerToValidate()
        {
            Mock<ModelValidatorProvider> provider = null;

            try
            {
                // Arrange
                ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(object));
                ControllerContext context = new ControllerContext();
                Mock<ModelValidator> validator = new Mock<ModelValidator>(metadata, context);
                provider = new Mock<ModelValidatorProvider>();
                provider.Setup(p => p.GetValidators(It.IsAny<ModelMetadata>(), It.IsAny<ControllerContext>()))
                    .Returns(new ModelValidator[] { validator.Object });
                ModelValidatorProviders.Providers.Add(provider.Object);
                object model = new object();
                TestableDefaultModelBinder<object> modelBinder = new TestableDefaultModelBinder<object>(model);

                // Act
                modelBinder.OnModelUpdated();

                // Assert
                validator.Verify(v => v.Validate(null));
            }
            finally
            {
                if (provider != null)
                {
                    ModelValidatorProviders.Providers.Remove(provider.Object);
                }
            }
        }

        public class MinMaxValidationAttribute : ValidationAttribute
        {
            public MinMaxValidationAttribute()
                : base("Minimum must be less than or equal to Maximum")
            {
            }

            public override bool IsValid(object value)
            {
                OnModelUpdatedModelMultipleParameters model = (OnModelUpdatedModelMultipleParameters)value;
                return model.Minimum <= model.Maximum;
            }
        }

        [MinMaxValidation]
        public class OnModelUpdatedModelMultipleParameters
        {
            public int Minimum { get; set; }
            public int Maximum { get; set; }
        }

        [Fact]
        public void OnModelUpdatedWithValidationAttributeMultipleParameters()
        {
            // Arrange
            OnModelUpdatedModelMultipleParameters model = new OnModelUpdatedModelMultipleParameters { Minimum = 250, Maximum = 100 };
            TestableDefaultModelBinder<OnModelUpdatedModelMultipleParameters> modelBinder = new TestableDefaultModelBinder<OnModelUpdatedModelMultipleParameters>(model);

            // Act
            modelBinder.OnModelUpdated();

            // Assert
            Assert.Single(modelBinder.ModelState);
            ModelState stateModel = modelBinder.ModelState[BASE_MODEL_NAME];
            Assert.NotNull(stateModel);
            ModelError error = Assert.Single(stateModel.Errors);
            Assert.Equal("Minimum must be less than or equal to Maximum", error.ErrorMessage);
        }

        [Fact]
        public void OnModelUpdatedWithInvalidPropertyValidationWillNotRunEntityLevelValidation()
        {
            // Arrange
            OnModelUpdatedModelMultipleParameters model = new OnModelUpdatedModelMultipleParameters { Minimum = 250, Maximum = 100 };
            TestableDefaultModelBinder<OnModelUpdatedModelMultipleParameters> modelBinder = new TestableDefaultModelBinder<OnModelUpdatedModelMultipleParameters>(model);
            modelBinder.ModelState.AddModelError(BASE_MODEL_NAME + ".Minimum", "The minimum value was invalid.");

            // Act
            modelBinder.OnModelUpdated();

            // Assert
            Assert.Null(modelBinder.ModelState[BASE_MODEL_NAME]);
        }

        public class AlwaysInvalidAttribute : ValidationAttribute
        {
            public AlwaysInvalidAttribute()
            {
            }

            public AlwaysInvalidAttribute(string message)
                : base(message)
            {
            }

            public override bool IsValid(object value)
            {
                return false;
            }
        }

        [AlwaysInvalid("The object just isn't right")]
        public class OnModelUpdatedModelNoParameters
        {
        }

        [Fact]
        public void OnModelUpdatedWithValidationAttributeNoParameters()
        {
            // Arrange
            TestableDefaultModelBinder<OnModelUpdatedModelNoParameters> modelBinder = new TestableDefaultModelBinder<OnModelUpdatedModelNoParameters>();

            // Act
            modelBinder.OnModelUpdated();

            // Assert
            Assert.Single(modelBinder.ModelState);
            ModelState stateModel = modelBinder.ModelState[BASE_MODEL_NAME];
            Assert.NotNull(stateModel);
            ModelError error = Assert.Single(stateModel.Errors);
            Assert.Equal("The object just isn't right", error.ErrorMessage);
        }

        [AlwaysInvalid]
        public class OnModelUpdatedModelNoValidationResult
        {
        }

        [Fact]
        [ReplaceCulture]
        public void OnModelUpdatedWithValidationAttributeNoValidationMessage()
        {
            // Arrange
            TestableDefaultModelBinder<OnModelUpdatedModelNoValidationResult> modelBinder = new TestableDefaultModelBinder<OnModelUpdatedModelNoValidationResult>();

            // Act
            modelBinder.OnModelUpdated();

            // Assert
            Assert.Single(modelBinder.ModelState);
            ModelState stateModel = modelBinder.ModelState[BASE_MODEL_NAME];
            Assert.NotNull(stateModel);
            ModelError error = Assert.Single(stateModel.Errors);
            Assert.Equal("The field OnModelUpdatedModelNoValidationResult is invalid.", error.ErrorMessage);
        }

        [Fact]
        public void OnModelUpdatedDoesNotPlaceErrorMessagesInModelStateWhenSubPropertiesHaveErrors()
        {
            // Arrange
            TestableDefaultModelBinder<OnModelUpdatedModelNoValidationResult> modelBinder = new TestableDefaultModelBinder<OnModelUpdatedModelNoValidationResult>();
            modelBinder.ModelState.AddModelError("Foo.Bar", "Foo.Bar is invalid");
            modelBinder.Context.ModelName = "Foo";

            // Act
            modelBinder.OnModelUpdated();

            // Assert
            Assert.Null(modelBinder.ModelState["Foo"]);
        }

        // OnPropertyValidating tests

        class OnPropertyValidatingModel
        {
            public string NotValidated { get; set; }

            [Range(10, 65)]
            public int RangedInteger { get; set; }

            [Required(ErrorMessage = "Custom Required Message")]
            public int RequiredInteger { get; set; }
        }

        [Fact]
        public void OnPropertyValidatingWithoutValidationAttribute()
        {
            // Arrange
            TestableDefaultModelBinder<OnPropertyValidatingModel> modelBinder = new TestableDefaultModelBinder<OnPropertyValidatingModel>();

            // Act
            modelBinder.OnPropertyValidating("NotValidated", 42);

            // Assert
            Assert.Empty(modelBinder.ModelState);
        }

        [Fact]
        public void OnPropertyValidatingWithValidationAttributePassing()
        {
            // Arrange
            TestableDefaultModelBinder<OnPropertyValidatingModel> modelBinder = new TestableDefaultModelBinder<OnPropertyValidatingModel>();
            modelBinder.Context.PropertyMetadata["RangedInteger"].Model = 42;

            // Act
            bool result = modelBinder.OnPropertyValidating("RangedInteger", 42);

            // Assert
            Assert.True(result);
            Assert.Empty(modelBinder.ModelState);
        }

        // SetProperty tests

        [Fact]
        public void SetPropertyWithRequiredOnValueTypeOnlyResultsInSingleMessage()
        { // DDB #225150
            // Arrange
            TestableDefaultModelBinder<OnPropertyValidatingModel> modelBinder = new TestableDefaultModelBinder<OnPropertyValidatingModel>();
            modelBinder.Context.ModelMetadata.Model = new OnPropertyValidatingModel();

            // Act
            modelBinder.SetProperty("RequiredInteger", null);

            // Assert
            ModelState modelState = modelBinder.ModelState[BASE_MODEL_NAME + ".RequiredInteger"];
            ModelError modelStateError = modelState.Errors.Single();
            Assert.Equal("Custom Required Message", modelStateError.ErrorMessage);
        }

        [Fact]
        public void SetPropertyAddsDefaultMessageForNonBindableNonNullableValueTypes()
        {
            DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = false;

            try
            {
                // Arrange
                TestableDefaultModelBinder<List<String>> modelBinder = new TestableDefaultModelBinder<List<String>>();
                modelBinder.Context.ModelMetadata.Model = null;

                // Act
                modelBinder.SetProperty("Count", null);

                // Assert
                ModelState modelState = modelBinder.ModelState[BASE_MODEL_NAME + ".Count"];
                ModelError modelStateError = modelState.Errors.Single();
                Assert.Equal("A value is required.", modelStateError.ErrorMessage);
            }
            finally
            {
                DataAnnotationsModelValidatorProvider.AddImplicitRequiredAttributeForValueTypes = true;
            }
        }

        [Fact]
        [ReplaceCulture]
        public void SetPropertyCreatesValueRequiredErrorIfNecessary()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => new MyModel(), typeof(MyModel)),
                ModelName = "theModel",
            };

            PropertyDescriptor property = TypeDescriptor.GetProperties(typeof(MyModel))["ReadWriteProperty"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            helper.PublicSetProperty(new ControllerContext(), bindingContext, property, null);

            // Assert
            Assert.Equal("The ReadWriteProperty field is required.", bindingContext.ModelState["theModel.ReadWriteProperty"].Errors[0].ErrorMessage);
        }

        [Fact]
        public void SetPropertyWithThrowingSetter()
        {
            // Arrange
            TestableDefaultModelBinder<SetPropertyModel> binder = new TestableDefaultModelBinder<SetPropertyModel>();

            // Act
            binder.SetProperty("NonNullableString", null);

            // Assert
            ModelState modelState = binder.Context.ModelState[BASE_MODEL_NAME + ".NonNullableString"];
            ModelError error = Assert.Single(modelState.Errors);
            Assert.IsType<ArgumentNullException>(error.Exception);
        }

        [Fact]
        public void SetPropertyWithNullValueAndThrowingSetterWithRequiredAttribute()
        { // DDB #227809
            // Arrange
            TestableDefaultModelBinder<SetPropertyModel> binder = new TestableDefaultModelBinder<SetPropertyModel>();

            // Act
            binder.SetProperty("NonNullableStringWithAttribute", null);

            // Assert
            ModelState modelState = binder.Context.ModelState[BASE_MODEL_NAME + ".NonNullableStringWithAttribute"];
            var error = Assert.Single(modelState.Errors);
            Assert.Equal("My custom required message", error.ErrorMessage);
        }

        [Fact]
        public void SetPropertyDoesNothingIfPropertyIsReadOnly()
        {
            // Arrange
            MyModel model = new MyModel();
            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()),
                ModelName = "theModel"
            };

            PropertyDescriptor property = TypeDescriptor.GetProperties(model)["ReadOnlyProperty"];
            DefaultModelBinderHelper helper = new DefaultModelBinderHelper();

            // Act
            helper.PublicSetProperty(new ControllerContext(), bindingContext, property, 42);

            // Assert
            Assert.Empty(bindingContext.ModelState);
        }

        [Fact]
        public void SetPropertySuccess()
        {
            // Arrange
            TestableDefaultModelBinder<SetPropertyModel> binder = new TestableDefaultModelBinder<SetPropertyModel>();

            // Act
            binder.SetProperty("NullableString", "The new value");

            // Assert
            Assert.Equal("The new value", ((SetPropertyModel)binder.Context.Model).NullableString);
            Assert.Empty(binder.Context.ModelState);
        }

        class SetPropertyModel
        {
            public string NullableString { get; set; }

            public string NonNullableString
            {
                get { return null; }
                set
                {
                    if (value == null)
                    {
                        throw new ArgumentNullException("value");
                    }
                }
            }

            [Required(ErrorMessage = "My custom required message")]
            public string NonNullableStringWithAttribute
            {
                get { return null; }
                set
                {
                    if (value == null)
                    {
                        throw new ArgumentNullException("value");
                    }
                }
            }
        }

        // Helper methods

        static PropertyDescriptor GetProperty<T>(string propertyName)
        {
            return TypeDescriptor.GetProperties(typeof(T))
                .Cast<PropertyDescriptor>()
                .Where(p => p.Name == propertyName)
                .Single();
        }

        static ICustomTypeDescriptor GetType<T>()
        {
            return TypeDescriptor.GetProvider(typeof(T)).GetTypeDescriptor(typeof(T));
        }

        // Helper classes

        class TestableDefaultModelBinder<TModel> : DefaultModelBinder
            where TModel : new()
        {
            public TestableDefaultModelBinder()
                : this(new TModel())
            {
            }

            public TestableDefaultModelBinder(TModel model)
            {
                ModelState = new ModelStateDictionary();

                Context = new ModelBindingContext();
                Context.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, typeof(TModel));
                Context.ModelName = BASE_MODEL_NAME;
                Context.ModelState = ModelState;
            }

            public ModelBindingContext Context { get; private set; }

            public ModelStateDictionary ModelState { get; set; }

            public void BindProperty(string propertyName)
            {
                base.BindProperty(new ControllerContext(), Context, GetProperty<TModel>(propertyName));
            }

            public PropertyDescriptorCollection GetModelProperties()
            {
                return base.GetModelProperties(new ControllerContext(), Context);
            }

            public object GetPropertyValue(string propertyName, object existingValue)
            {
                Mock<IModelBinder> mockModelBinder = new Mock<IModelBinder>();
                mockModelBinder.Setup(b => b.BindModel(It.IsAny<ControllerContext>(), Context)).Returns(existingValue);
                return base.GetPropertyValue(new ControllerContext(), Context, GetProperty<TModel>(propertyName), mockModelBinder.Object);
            }

            public bool OnPropertyValidating(string propertyName, object value)
            {
                return base.OnPropertyValidating(new ControllerContext(), Context, GetProperty<TModel>(propertyName), value);
            }

            public void OnPropertyValidated(string propertyName, object value)
            {
                base.OnPropertyValidated(new ControllerContext(), Context, GetProperty<TModel>(propertyName), value);
            }

            public void OnModelUpdated()
            {
                base.OnModelUpdated(new ControllerContext(), Context);
            }

            public void SetProperty(string propertyName, object value)
            {
                base.SetProperty(new ControllerContext(), Context, GetProperty<TModel>(propertyName), value);
            }
        }

        private class CountryState
        {
            public string Name { get; set; }

            public IEnumerable<string> States { get; set; }
        }

        private class NoParameterlessCtor
        {
            private NoParameterlessCtor()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DefaultViewLocationCacheTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class DefaultViewLocationCacheTest
    {
        [Fact]
        public void TimeSpanProperty()
        {
            // Arrange
            TimeSpan timeSpan = new TimeSpan(0, 20, 0);
            DefaultViewLocationCache viewCache = new DefaultViewLocationCache(timeSpan);

            // Assert
            Assert.Equal(timeSpan.Ticks, viewCache.TimeSpan.Ticks);
        }

        [Fact]
        public void ConstructorAssignsDefaultTimeSpan()
        {
            // Arrange
            DefaultViewLocationCache viewLocationCache = new DefaultViewLocationCache();
            TimeSpan timeSpan = new TimeSpan(0, 15, 0);

            // Assert
            Assert.Equal(timeSpan.Ticks, viewLocationCache.TimeSpan.Ticks);
        }

        [Fact]
        public void ConstructorWithNegativeTimeSpanThrows()
        {
            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { new DefaultViewLocationCache(new TimeSpan(-1, 0, 0)); },
                "The number of ticks for the TimeSpan value must be greater than or equal to 0.");
        }

        [Fact]
        public void GetViewLocationThrowsWithNullHttpContext()
        {
            // Arrange
            DefaultViewLocationCache viewLocationCache = new DefaultViewLocationCache();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { string viewLocation = viewLocationCache.GetViewLocation(null /* httpContext */, "foo"); },
                "httpContext");
        }

        [Fact]
        public void InsertViewLocationThrowsWithNullHttpContext()
        {
            // Arrange
            DefaultViewLocationCache viewLocationCache = new DefaultViewLocationCache();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { viewLocationCache.InsertViewLocation(null /* httpContext */, "foo", "fooPath"); },
                "httpContext");
        }

        [Fact]
        public void NullViewLocationCacheReturnsNullLocations()
        {
            // Act
            DefaultViewLocationCache.Null.InsertViewLocation(null /* httpContext */, "foo", "fooPath");

            // Assert
            Assert.Null(DefaultViewLocationCache.Null.GetViewLocation(null /* httpContext */, "foo"));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DependencyResolverTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class DependencyResolverTest
    {
        [Fact]
        public void GuardClauses()
        {
            // Arrange
            var resolver = new DependencyResolver();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => resolver.InnerSetResolver((IDependencyResolver)null),
                "resolver");
            Assert.ThrowsArgumentNull(
                () => resolver.InnerSetResolver((object)null),
                "commonServiceLocator");
            Assert.ThrowsArgumentNull(
                () => resolver.InnerSetResolver(null, type => null),
                "getService");
            Assert.ThrowsArgumentNull(
                () => resolver.InnerSetResolver(type => null, null),
                "getServices");
        }

        [Fact]
        public void DefaultServiceLocatorBehaviorTests()
        {
            // Arrange
            var resolver = new DependencyResolver();

            // Act & Assert
            Assert.NotNull(resolver.InnerCurrent.GetService<object>()); // Concrete type
            Assert.Null(resolver.InnerCurrent.GetService<ModelMetadataProvider>()); // Abstract type
            Assert.Null(resolver.InnerCurrent.GetService<IDisposable>()); // Interface
            Assert.Null(resolver.InnerCurrent.GetService(typeof(List<>))); // Open generic
        }

        [Fact]
        public void DefaultServiceLocatorResolvesNewInstances()
        {
            // Arrange
            var resolver = new DependencyResolver();

            // Act
            object obj1 = resolver.InnerCurrent.GetService<object>();
            object obj2 = resolver.InnerCurrent.GetService<object>();

            // Assert
            Assert.NotSame(obj1, obj2);
        }

        public class MockableResolver
        {
            public virtual object Get(Type type)
            {
                throw new NotImplementedException();
            }

            public virtual IEnumerable<object> GetAll(Type type)
            {
                throw new NotImplementedException();
            }
        }

        [Fact]
        public void ResolverPassesCallsToDelegateBasedResolver()
        {
            // Arrange
            var resolver = new DependencyResolver();
            var mockResolver = new Mock<MockableResolver>();
            resolver.InnerSetResolver(mockResolver.Object.Get, mockResolver.Object.GetAll);

            // Act & Assert
            resolver.InnerCurrent.GetService(typeof(object));
            mockResolver.Verify(r => r.Get(typeof(object)));

            resolver.InnerCurrent.GetServices(typeof(string));
            mockResolver.Verify(r => r.GetAll(typeof(string)));
        }

        public class MockableCommonServiceLocator
        {
            public virtual object GetInstance(Type type)
            {
                throw new NotImplementedException();
            }

            public virtual IEnumerable<object> GetAllInstances(Type type)
            {
                throw new NotImplementedException();
            }
        }

        [Fact]
        public void ResolverPassesCallsToICommonServiceLocator()
        {
            // Arrange
            var resolver = new DependencyResolver();
            var mockResolver = new Mock<MockableCommonServiceLocator>();
            resolver.InnerSetResolver(mockResolver.Object);

            // Act & Assert
            resolver.InnerCurrent.GetService(typeof(object));
            mockResolver.Verify(r => r.GetInstance(typeof(object)));

            resolver.InnerCurrent.GetServices(typeof(string));
            mockResolver.Verify(r => r.GetAllInstances(typeof(string)));
        }

        class MissingGetInstance
        {
            public IEnumerable<object> GetAllInstances(Type type)
            {
                return null;
            }
        }

        class MissingGetAllInstances
        {
            public object GetInstance(Type type)
            {
                return null;
            }
        }

        class GetInstanceHasWrongSignature
        {
            public string GetInstance(Type type)
            {
                return null;
            }

            public IEnumerable<object> GetAllInstances(Type type)
            {
                return null;
            }
        }

        class GetAllInstancesHasWrongSignature
        {
            public object GetInstance(Type type)
            {
                return null;
            }

            public IEnumerable<string> GetAllInstances(Type type)
            {
                return null;
            }
        }

        [Fact]
        public void ValidationOfCommonServiceLocatorTests()
        {
            // Arrange
            var resolver = new DependencyResolver();

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => resolver.InnerSetResolver(new MissingGetInstance()),
                "The type System.Web.Mvc.Test.DependencyResolverTest+MissingGetInstance does not appear to implement Microsoft.Practices.ServiceLocation.IServiceLocator." + Environment.NewLine
              + "Parameter name: commonServiceLocator");
            Assert.Throws<ArgumentException>(
                () => resolver.InnerSetResolver(new MissingGetAllInstances()),
                "The type System.Web.Mvc.Test.DependencyResolverTest+MissingGetAllInstances does not appear to implement Microsoft.Practices.ServiceLocation.IServiceLocator." + Environment.NewLine
              + "Parameter name: commonServiceLocator");
            Assert.Throws<ArgumentException>(
                () => resolver.InnerSetResolver(new GetInstanceHasWrongSignature()),
                "The type System.Web.Mvc.Test.DependencyResolverTest+GetInstanceHasWrongSignature does not appear to implement Microsoft.Practices.ServiceLocation.IServiceLocator." + Environment.NewLine
              + "Parameter name: commonServiceLocator");
            Assert.Throws<ArgumentException>(
                () => resolver.InnerSetResolver(new GetAllInstancesHasWrongSignature()),
                "The type System.Web.Mvc.Test.DependencyResolverTest+GetAllInstancesHasWrongSignature does not appear to implement Microsoft.Practices.ServiceLocation.IServiceLocator." + Environment.NewLine
              + "Parameter name: commonServiceLocator");
        }



        [Fact]
        public void DependencyResolverCache()
        {
            // Verify that when we ask for an interface twice, it only queries the underlying resolver once.
            var resolver = new DependencyResolver();

            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            resolverMock.Setup(r => r.GetService(typeof(object))).Returns(() => new object());
            resolverMock.Setup(r => r.GetService(typeof(int))).Returns(15);

            resolver.InnerSetResolver(resolverMock.Object);

            object result1 = resolver.InnerCurrentCache.GetService(typeof(object)); // 1st call
            object otherResult = resolver.InnerCurrentCache.GetService(typeof(int)); // 2nd call
            object result2 = resolver.InnerCurrentCache.GetService(typeof(object)); // Cached result from 1st call


            resolverMock.Verify(r => r.GetService(typeof(object)), Times.Once());
            resolverMock.Verify(r => r.GetService(typeof(int)), Times.Once());
            Assert.Same(result1, result2);
            Assert.Equal(15, otherResult);
        }

        [Fact]
        public void ClearDependencyResolverCache()
        {
            // Verify that when we ask for an interface twice, it only queries the underlying resolver once.
            var resolver = new DependencyResolver();

            Mock<IDependencyResolver> resolverMock = new Mock<IDependencyResolver>();
            resolverMock.Setup(r => r.GetService(typeof(object))).Returns(() => new object());
            resolverMock.Setup(r => r.GetService(typeof(int))).Returns(15);

            resolver.InnerSetResolver(resolverMock.Object);

            object result1 = resolver.InnerCurrentCache.GetService(typeof(object)); // 1st call
            object otherResult = resolver.InnerCurrentCache.GetService(typeof(int)); // 2nd call
            resolver.InnerSetResolver(resolverMock.Object); // This will clear the cache
            object result2 = resolver.InnerCurrentCache.GetService(typeof(object)); // 3rd call


            resolverMock.Verify(r => r.GetService(typeof(object)), Times.Exactly(2));
            resolverMock.Verify(r => r.GetService(typeof(int)), Times.Once());
            Assert.NotSame(result1, result2);
            Assert.Equal(15, otherResult);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DescriptorUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class DescriptorUtilTest
    {
        [Fact]
        public void AppendUniqueId_FromIUniquelyIdentifiable()
        {
            // Arrange
            CustomUniquelyIdentifiable custom = new CustomUniquelyIdentifiable("hello-world");
            StringBuilder builder = new StringBuilder();

            // Act
            DescriptorUtil.AppendUniqueId(builder, custom);

            // Assert
            Assert.Equal("[11]hello-world", builder.ToString());
        }

        [Fact]
        public void AppendUniqueId_FromMemberInfo()
        {
            // Arrange
            string moduleVersionId = typeof(DescriptorUtilTest).Module.ModuleVersionId.ToString();
            string metadataToken = typeof(DescriptorUtilTest).MetadataToken.ToString();
            string expected = String.Format("[{0}]{1}[{2}]{3}", moduleVersionId.Length, moduleVersionId, metadataToken.Length, metadataToken);
            StringBuilder builder = new StringBuilder();

            // Act
            DescriptorUtil.AppendUniqueId(builder, typeof(DescriptorUtilTest));

            // Assert
            Assert.Equal(expected, builder.ToString());
        }

        [Fact]
        public void CreateUniqueId_FromSimpleTypes()
        {
            // Act
            string retVal = DescriptorUtil.CreateUniqueId("foo", null, 12345);

            // Assert
            Assert.Equal("[3]foo[-1][5]12345", retVal);
        }

        private sealed class CustomUniquelyIdentifiable : IUniquelyIdentifiable
        {
            public CustomUniquelyIdentifiable(string uniqueId)
            {
                UniqueId = uniqueId;
            }

            public string UniqueId { get; private set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DictionaryHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class DictionaryHelpersTest
    {
        [Fact]
        public void DoesAnyKeyHavePrefixFailure()
        {
            // Arrange
            Dictionary<string, object> dict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)
            {
                { "FOOBAR", 42 }
            };

            // Act
            bool wasPrefixFound = DictionaryHelpers.DoesAnyKeyHavePrefix(dict, "foo");

            // Assert
            Assert.False(wasPrefixFound);
        }

        [Fact]
        public void DoesAnyKeyHavePrefixSuccess()
        {
            // Arrange
            Dictionary<string, object> dict = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)
            {
                { "FOO.BAR", 42 }
            };

            // Act
            bool wasPrefixFound = DictionaryHelpers.DoesAnyKeyHavePrefix(dict, "foo");

            // Assert
            Assert.True(wasPrefixFound);
        }

        [Fact]
        public void FindKeysWithPrefix()
        {
            // Arrange
            Dictionary<string, string> dict = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                { "FOO", "fooValue" },
                { "FOOBAR", "foobarValue" },
                { "FOO.BAR", "foo.barValue" },
                { "FOO[0]", "foo[0]Value" },
                { "BAR", "barValue" }
            };

            // Act
            var matchingEntries = DictionaryHelpers.FindKeysWithPrefix(dict, "foo");

            // Assert
            var matchingEntriesList = matchingEntries.OrderBy(entry => entry.Key).ToList();
            Assert.Equal(3, matchingEntriesList.Count);
            Assert.Equal("foo", matchingEntriesList[0].Key);
            Assert.Equal("fooValue", matchingEntriesList[0].Value);
            Assert.Equal("FOO.BAR", matchingEntriesList[1].Key);
            Assert.Equal("foo.barValue", matchingEntriesList[1].Value);
            Assert.Equal("FOO[0]", matchingEntriesList[2].Key);
            Assert.Equal("foo[0]Value", matchingEntriesList[2].Value);
        }

        [Fact]
        public void GetOrDefaultMissing()
        {
            Dictionary<string, int> dict = new Dictionary<string, int>();
            int @default = 15;

            int value = dict.GetOrDefault("two", @default);

            Assert.Equal(15, @default);
        }

        [Fact]
        public void GetOrDefaultPresent()
        {
            Dictionary<string, int> dict = new Dictionary<string, int>() { { "one", 1 } };

            int value = dict.GetOrDefault("one", -999);

            Assert.Equal(1, 1);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DictionaryValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class DictionaryValueProviderTest
    {
        private static readonly Dictionary<string, object> _backingStore = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)
        {
            { "forty.two", 42 },
            { "nineteen.eighty.four", new DateTime(1984, 1, 1) }
        };

        [Fact]
        public void Constructor_ThrowsIfDictionaryIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new DictionaryValueProvider<object>(null, CultureInfo.InvariantCulture); }, "dictionary");
        }

        [Fact]
        public void ContainsPrefix()
        {
            // Arrange
            DictionaryValueProvider<object> valueProvider = new DictionaryValueProvider<object>(_backingStore, null);

            // Act
            bool result = valueProvider.ContainsPrefix("forty");

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void ContainsPrefix_DoesNotContainEmptyPrefixIfBackingStoreIsEmpty()
        {
            // Arrange
            DictionaryValueProvider<object> valueProvider = new DictionaryValueProvider<object>(new Dictionary<string, object>(), null);

            // Act
            bool result = valueProvider.ContainsPrefix("");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ContainsPrefix_ThrowsIfPrefixIsNull()
        {
            // Arrange
            DictionaryValueProvider<object> valueProvider = new DictionaryValueProvider<object>(_backingStore, null);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { valueProvider.ContainsPrefix(null); }, "prefix");
        }

        [Fact]
        public void GetValue()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            DictionaryValueProvider<object> valueProvider = new DictionaryValueProvider<object>(_backingStore, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("nineteen.eighty.four");

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(new DateTime(1984, 1, 1), vpResult.RawValue);
            Assert.Equal("01/01/1984 00:00:00", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }

        [Fact]
        public void GetValue_ReturnsNullIfKeyNotFound()
        {
            // Arrange
            DictionaryValueProvider<object> valueProvider = new DictionaryValueProvider<object>(_backingStore, null);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("nineteen.eighty");

            // Assert
            Assert.Null(vpResult);
        }

        [Fact]
        public void GetValue_ThrowsIfKeyIsNull()
        {
            // Arrange
            DictionaryValueProvider<object> valueProvider = new DictionaryValueProvider<object>(_backingStore, null);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { valueProvider.GetValue(null); }, "key");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/DynamicViewDataDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Dynamic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class DynamicViewDataDictionaryTest
    {
        [Fact]
        public void Get_OnExistingProperty_ReturnsValue()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary()
            {
                { "Prop", "Value" }
            };
            dynamic dynamicVD = new DynamicViewDataDictionary(() => vd);

            // Act
            object value = dynamicVD.Prop;

            // Assert
            Assert.IsType<string>(value);
            Assert.Equal("Value", value);
        }

        [Fact]
        public void Get_OnNonExistentProperty_ReturnsNull()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary();
            dynamic dynamicVD = new DynamicViewDataDictionary(() => vd);

            // Act
            object value = dynamicVD.Prop;

            // Assert
            Assert.Null(value);
        }

        [Fact]
        public void Set_OnExistingProperty_OverridesValue()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary()
            {
                { "Prop", "Value" }
            };
            dynamic dynamicVD = new DynamicViewDataDictionary(() => vd);

            // Act
            dynamicVD.Prop = "NewValue";

            // Assert
            Assert.Equal("NewValue", dynamicVD.Prop);
            Assert.Equal("NewValue", vd["Prop"]);
        }

        [Fact]
        public void Set_OnNonExistentProperty_SetsValue()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary();
            dynamic dynamicVD = new DynamicViewDataDictionary(() => vd);

            // Act
            dynamicVD.Prop = "NewValue";

            // Assert
            Assert.Equal("NewValue", dynamicVD.Prop);
            Assert.Equal("NewValue", vd["Prop"]);
        }

        [Fact]
        public void TryGetMember_OnExistingProperty_ReturnsValueAndSucceeds()
        {
            // Arrange
            object result = null;
            ViewDataDictionary vd = new ViewDataDictionary()
            {
                { "Prop", "Value" }
            };
            DynamicViewDataDictionary dynamicVD = new DynamicViewDataDictionary(() => vd);
            Mock<GetMemberBinder> binderMock = new Mock<GetMemberBinder>("Prop", /* ignoreCase */ false);

            // Act
            bool success = dynamicVD.TryGetMember(binderMock.Object, out result);

            // Assert
            Assert.True(success);
            Assert.Equal("Value", result);
        }

        [Fact]
        public void TryGetMember_OnNonExistentProperty_ReturnsNullAndSucceeds()
        {
            // Arrange
            object result = null;
            ViewDataDictionary vd = new ViewDataDictionary();
            DynamicViewDataDictionary dynamicVD = new DynamicViewDataDictionary(() => vd);
            Mock<GetMemberBinder> binderMock = new Mock<GetMemberBinder>("Prop", /* ignoreCase */ false);

            // Act
            bool success = dynamicVD.TryGetMember(binderMock.Object, out result);

            // Assert
            Assert.True(success);
            Assert.Null(result);
        }

        [Fact]
        public void TrySetMember_OnExistingProperty_OverridesValueAndSucceeds()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary()
            {
                { "Prop", "Value" }
            };
            DynamicViewDataDictionary dynamicVD = new DynamicViewDataDictionary(() => vd);
            Mock<SetMemberBinder> binderMock = new Mock<SetMemberBinder>("Prop", /* ignoreCase */ false);

            // Act
            bool success = dynamicVD.TrySetMember(binderMock.Object, "NewValue");

            // Assert
            Assert.True(success);
            Assert.Equal("NewValue", ((dynamic)dynamicVD).Prop);
            Assert.Equal("NewValue", vd["Prop"]);
        }

        [Fact]
        public void TrySetMember_OnNonExistentProperty_SetsValueAndSucceeds()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary();
            DynamicViewDataDictionary dynamicVD = new DynamicViewDataDictionary(() => vd);
            Mock<SetMemberBinder> binderMock = new Mock<SetMemberBinder>("Prop", /* ignoreCase */ false);

            // Act
            bool success = dynamicVD.TrySetMember(binderMock.Object, "NewValue");

            // Assert
            Assert.True(success);
            Assert.Equal("NewValue", ((dynamic)dynamicVD).Prop);
            Assert.Equal("NewValue", vd["Prop"]);
        }

        [Fact]
        public void GetDynamicMemberNames_ReturnsEmptyListForEmptyViewDataDictionary()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary();
            DynamicViewDataDictionary dvd = new DynamicViewDataDictionary(() => vd);

            // Act
            IEnumerable<string> result = dvd.GetDynamicMemberNames();

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void GetDynamicMemberNames_ReturnsKeyNamesForFilledViewDataDictionary()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary()
            {
                { "Prop1", 1 },
                { "Prop2", 2 }
            };
            DynamicViewDataDictionary dvd = new DynamicViewDataDictionary(() => vd);

            // Act
            var result = dvd.GetDynamicMemberNames();

            // Assert
            Assert.Equal(new[] { "Prop1", "Prop2" }, result.OrderBy(s => s).ToArray());
        }

        [Fact]
        public void GetDynamicMemberNames_ReflectsChangesToUnderlyingViewDataDictionary()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary();
            vd["OldProp"] = 123;
            DynamicViewDataDictionary dvd = new DynamicViewDataDictionary(() => vd);
            vd["NewProp"] = "somevalue";

            // Act
            var result = dvd.GetDynamicMemberNames();

            // Assert
            Assert.Equal(new[] { "NewProp", "OldProp" }, result.OrderBy(s => s).ToArray());
        }

        [Fact]
        public void GetDynamicMemberNames_ReflectsChangesToDynamicObject()
        {
            // Arrange
            ViewDataDictionary vd = new ViewDataDictionary();
            vd["OldProp"] = 123;
            DynamicViewDataDictionary dvd = new DynamicViewDataDictionary(() => vd);
            ((dynamic)dvd).NewProp = "foo";

            // Act
            var result = dvd.GetDynamicMemberNames();

            // Assert
            Assert.Equal(new[] { "NewProp", "OldProp" }, result.OrderBy(s => s).ToArray());
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/EmptyModelValidatorProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class EmptyModelValidatorProviderTest
    {
        [Fact]
        public void ReturnsNoValidators()
        {
            // Arrange
            EmptyModelValidatorProvider provider = new EmptyModelValidatorProvider();

            // Act
            IEnumerable<ModelValidator> result = provider.GetValidators(null, null);

            // Assert
            Assert.Empty(result);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ExceptionContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ExceptionContextTest
    {
        [Fact]
        public void ConstructorThrowsIfExceptionIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            Exception exception = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ExceptionContext(controllerContext, exception); }, "exception");
        }

        [Fact]
        public void ExceptionProperty()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            Exception exception = new Exception();

            // Act
            ExceptionContext exceptionContext = new ExceptionContext(controllerContext, exception);

            // Assert
            Assert.Equal(exception, exceptionContext.Exception);
        }

        [Fact]
        public void ResultProperty()
        {
            // Arrange
            ExceptionContext exceptionContext = new Mock<ExceptionContext>().Object;

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(exceptionContext, "Result", new ViewResult(), EmptyResult.Instance);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ExpressionHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ExpressionHelperTest
    {
        [Fact]
        public void StringBasedExpressionTests()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();

            // Uses the given expression as the expression text
            Assert.Equal("?", ExpressionHelper.GetExpressionText("?"));

            // Exactly "Model" (case-insensitive) is turned into empty string
            Assert.Equal(String.Empty, ExpressionHelper.GetExpressionText("Model"));
            Assert.Equal(String.Empty, ExpressionHelper.GetExpressionText("mOdEl"));

            // Beginning with "Model" is untouched
            Assert.Equal("Model.Foo", ExpressionHelper.GetExpressionText("Model.Foo"));
        }

        [Fact]
        public void LambdaBasedExpressionTextTests()
        {
            // "Model" at the front of the expression is excluded (case insensitively)
            DummyContactModel Model = null;
            Assert.Equal(String.Empty, ExpressionHelper.GetExpressionText(Lambda<object, DummyContactModel>(m => Model)));
            Assert.Equal("FirstName", ExpressionHelper.GetExpressionText(Lambda<object, string>(m => Model.FirstName)));

            DummyContactModel mOdeL = null;
            Assert.Equal(String.Empty, ExpressionHelper.GetExpressionText(Lambda<object, DummyContactModel>(m => mOdeL)));
            Assert.Equal("FirstName", ExpressionHelper.GetExpressionText(Lambda<object, string>(m => mOdeL.FirstName)));

            // Model property of model is passed through
            Assert.Equal("Model", ExpressionHelper.GetExpressionText(Lambda<DummyModelContainer, DummyContactModel>(m => m.Model)));

            // "Model" in the middle of the expression is not excluded
            DummyModelContainer container = null;
            Assert.Equal("container.Model", ExpressionHelper.GetExpressionText(Lambda<object, DummyContactModel>(m => container.Model)));
            Assert.Equal("container.Model.FirstName", ExpressionHelper.GetExpressionText(Lambda<object, string>(m => container.Model.FirstName)));

            // The parameter is excluded
            Assert.Equal(String.Empty, ExpressionHelper.GetExpressionText(Lambda<DummyContactModel, DummyContactModel>(m => m)));
            Assert.Equal("FirstName", ExpressionHelper.GetExpressionText(Lambda<DummyContactModel, string>(m => m.FirstName)));

            // Integer indexer is included and properly computed from captured values
            int x = 2;
            Assert.Equal("container.Model[42].Length", ExpressionHelper.GetExpressionText(Lambda<object, int>(m => container.Model[x * 21].Length)));
            Assert.Equal("[42]", ExpressionHelper.GetExpressionText(Lambda<int[], int>(m => m[x * 21])));

            // String indexer is included and properly computed from captured values
            string y = "Hello world";
            Assert.Equal("container.Model[Hello].Length", ExpressionHelper.GetExpressionText(Lambda<object, int>(m => container.Model[y.Substring(0, 5)].Length)));

            // Back to back indexer is included
            Assert.Equal("container.Model[1024][2]", ExpressionHelper.GetExpressionText(Lambda<object, char>(m => container.Model[x * 512][x])));

            // Multi-parameter indexer is excluded
            Assert.Equal("Length", ExpressionHelper.GetExpressionText(Lambda<object, int>(m => container.Model[42, "Hello World"].Length)));

            // Single array indexer is included
            Assert.Equal("container.Model.Array[1024]", ExpressionHelper.GetExpressionText(Lambda<object, int>(m => container.Model.Array[x * 512])));

            // Double array indexer is excluded
            Assert.Equal("", ExpressionHelper.GetExpressionText(Lambda<object, int>(m => container.Model.DoubleArray[1, 2])));

            // Non-indexer method call is excluded
            Assert.Equal("Length", ExpressionHelper.GetExpressionText(Lambda<object, int>(m => container.Model.Method().Length)));

            // Lambda expression which involves indexer which references lambda parameter throws
            Assert.Throws<InvalidOperationException>(
                () => ExpressionHelper.GetExpressionText(Lambda<string, char>(s => s[s.Length - 4])),
                "The expression compiler was unable to evaluate the indexer expression '(s.Length - 4)' because it references the model parameter 's' which is unavailable.");
        }

        public static TheoryDataSet<LambdaExpression, string> ComplicatedLambdaExpressions
        {
            get
            {
                var collection = new List<DummyModelContainer>();
                var index = 20;
                var data = new TheoryDataSet<LambdaExpression, string>
                {

                    {
                        Lambda((List<DummyModelContainer> m) => collection[10].Model.FirstName),
                        "collection[10].Model.FirstName"
                    },
                    {
                        Lambda((List<DummyModelContainer> m) => m[10].Model.FirstName),
                        "[10].Model.FirstName"
                    },
                    {
                        Lambda((List<DummyModelContainer> m) => collection[index].Model.FirstName),
                        "collection[20].Model.FirstName"
                    },
                    {
                        Lambda((List<DummyModelContainer> m) => m[index].Model.FirstName),
                        "[20].Model.FirstName"
                    },
                };

                return data;
            }
        }

        [Theory]
        [PropertyData("ComplicatedLambdaExpressions")]
        public void GetExpressionText_WithComplicatedLambdaExpressions_ReturnsExpectedText(
            LambdaExpression expression,
            string expectedText)
        {
            // Arrange & Act
            var result = ExpressionHelper.GetExpressionText(expression);

            // Assert
            Assert.Equal(expectedText, result);
        }

        [Fact]
        public void GetExpressionText_WithinALoop_ReturnsExpectedText()
        {
            // Arrange 0
            var collection = new List<DummyModelContainer>();

            for (var i = 0; i < 2; i++)
            {
                // Arrange 1
                var expectedText = string.Format("collection[{0}].Model.FirstName", i);

                // Act 1
                var result = ExpressionHelper.GetExpressionText(Lambda(
                    (List<DummyModelContainer> m) => collection[i].Model.FirstName));

                // Assert 1
                Assert.Equal(expectedText, result);

                // Arrange 2
                expectedText = string.Format("[{0}].Model.FirstName", i);

                // Act 2
                result = ExpressionHelper.GetExpressionText(Lambda(
                    (List<DummyModelContainer> m) => m[i].Model.FirstName));

                // Assert 2
                Assert.Equal(expectedText, result);
            }
        }

        // Helpers

        private static LambdaExpression Lambda<T1, T2>(Expression<Func<T1, T2>> expression)
        {
            return expression;
        }

        class DummyContactModel
        {
            public string FirstName { get; set; }

            public string this[int index]
            {
                get { return index.ToString(); }
            }

            public string this[string index]
            {
                get { return index; }
            }

            public string this[int index, string index2]
            {
                get { return index2; }
            }

            public int[] Array { get; set; }

            public int[,] DoubleArray { get; set; }

            public string Method()
            {
                return String.Empty;
            }
        }

        class DummyModelContainer
        {
            public DummyContactModel Model { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FieldValidationMetadataTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class FieldValidationMetadataTest
    {
        [Fact]
        public void FieldNameProperty()
        {
            // Arrange
            FieldValidationMetadata metadata = new FieldValidationMetadata();

            // Act & assert
            MemberHelper.TestStringProperty(metadata, "FieldName", String.Empty);
        }

        [Fact]
        public void ValidationRulesProperty()
        {
            // Arrange
            FieldValidationMetadata metadata = new FieldValidationMetadata();

            // Act
            ICollection<ModelClientValidationRule> validationRules = metadata.ValidationRules;

            // Assert
            Assert.NotNull(validationRules);
            Assert.Empty(validationRules);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FileContentResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FileContentResultTest
    {
        [Fact]
        public void ConstructorSetsFileContentsProperty()
        {
            // Arrange
            byte[] fileContents = new byte[0];

            // Act
            FileContentResult result = new FileContentResult(fileContents, "contentType");

            // Assert
            Assert.Same(fileContents, result.FileContents);
        }

        [Fact]
        public void ConstructorThrowsIfFileContentsIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new FileContentResult(null, "contentType"); }, "fileContents");
        }

        [Fact]
        public void WriteFileCopiesBufferToOutputStream()
        {
            // Arrange
            byte[] buffer = new byte[] { 1, 2, 3, 4, 5 };

            Mock<Stream> mockOutputStream = new Mock<Stream>();
            mockOutputStream.Setup(s => s.Write(buffer, 0, buffer.Length)).Verifiable();
            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(r => r.OutputStream).Returns(mockOutputStream.Object);

            FileContentResultHelper helper = new FileContentResultHelper(buffer, "application/octet-stream");

            // Act
            helper.PublicWriteFile(mockResponse.Object);

            // Assert
            mockOutputStream.Verify();
            mockResponse.Verify();
        }

        private class FileContentResultHelper : FileContentResult
        {
            public FileContentResultHelper(byte[] fileContents, string contentType)
                : base(fileContents, contentType)
            {
            }

            public void PublicWriteFile(HttpResponseBase response)
            {
                WriteFile(response);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FilePathResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FilePathResultTest
    {
        [Fact]
        public void ConstructorSetsFileNameProperty()
        {
            // Act
            FilePathResult result = new FilePathResult("someFile", "contentType");

            // Assert
            Assert.Equal("someFile", result.FileName);
        }

        [Fact]
        public void ConstructorThrowsIfFileNameIsEmpty()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new FilePathResult(String.Empty, "contentType"); }, "fileName");
        }

        [Fact]
        public void ConstructorThrowsIfFileNameIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new FilePathResult(null, "contentType"); }, "fileName");
        }

        [Fact]
        public void WriteFileTransmitsFileToOutputStream()
        {
            // Arrange
            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(r => r.TransmitFile("someFile")).Verifiable();

            FilePathResultHelper helper = new FilePathResultHelper("someFile", "application/octet-stream");

            // Act
            helper.PublicWriteFile(mockResponse.Object);

            // Assert
            mockResponse.Verify();
        }

        private class FilePathResultHelper : FilePathResult
        {
            public FilePathResultHelper(string fileName, string contentType)
                : base(fileName, contentType)
            {
            }

            public void PublicWriteFile(HttpResponseBase response)
            {
                WriteFile(response);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FileResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Mime;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FileResultTest
    {
        [Fact]
        public void ConstructorSetsContentTypeProperty()
        {
            // Act
            FileResult result = new EmptyFileResult("someContentType");

            // Assert
            Assert.Equal("someContentType", result.ContentType);
        }

        [Fact]
        public void ConstructorThrowsIfContentTypeIsEmpty()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new EmptyFileResult(String.Empty); }, "contentType");
        }

        [Fact]
        public void ConstructorThrowsIfContentTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new EmptyFileResult(null); }, "contentType");
        }

        [Fact]
        public void ContentDispositionHeaderIsEncodedCorrectly()
        {
            // See comment in FileResult.cs detailing how the FileDownloadName should be encoded.

            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/my-type").Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.AddHeader("Content-Disposition", @"attachment; filename=""some\\file""")).Verifiable();

            EmptyFileResult result = new EmptyFileResult("application/my-type")
            {
                FileDownloadName = @"some\file"
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            Assert.True(result.WasWriteFileCalled);
            mockControllerContext.Verify();
        }

        [Fact]
        public void ContentDispositionHeaderIsEncodedCorrectlyForUnicodeCharacters()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/my-type").Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.AddHeader("Content-Disposition", @"attachment; filename*=UTF-8''ABCXYZabcxyz012789!%40%23$%25%5E&%2A%28%29-%3D_+.:~%CE%94")).Verifiable();

            EmptyFileResult result = new EmptyFileResult("application/my-type")
            {
                FileDownloadName = "ABCXYZabcxyz012789!@#$%^&*()-=_+.:~Δ"
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            Assert.True(result.WasWriteFileCalled);
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultDoesNotSetContentDispositionIfNotSpecified()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/my-type").Verifiable();

            EmptyFileResult result = new EmptyFileResult("application/my-type");

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            Assert.True(result.WasWriteFileCalled);
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultSetsContentDispositionIfSpecified()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/my-type").Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.AddHeader("Content-Disposition", "attachment; filename=filename.ext")).Verifiable();

            EmptyFileResult result = new EmptyFileResult("application/my-type")
            {
                FileDownloadName = "filename.ext"
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            Assert.True(result.WasWriteFileCalled);
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultThrowsIfContextIsNull()
        {
            // Arrange
            FileResult result = new EmptyFileResult();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { result.ExecuteResult(null); }, "context");
        }

        [Fact]
        public void FileDownloadNameProperty()
        {
            // Arrange
            FileResult result = new EmptyFileResult();

            // Act & assert
            MemberHelper.TestStringProperty(result, "FileDownloadName", String.Empty);
        }

        public static TheoryDataSet<string, string> ContentDispositionData
        {
            get
            {
                return new TheoryDataSet<string, string>
                {
                    { "09aAzZ", "attachment; filename=09aAzZ" },
                    { " ", "attachment; filename=\" \"" },
                    { "a b", "attachment; filename=\"a b\"" },
                    { "a\tb", "attachment; filename=\"a\tb\"" },
                    { "a\nb", PlatformInfo.Platform == Platform.Net40 ? "attachment; filename=\"a\\\nb\"" : "attachment; filename=\"=?utf-8?B?YQpi?=\"" },
                    { "a.b", "attachment; filename=a.b" },
                    { "-", "attachment; filename=-" },
                    { "_", "attachment; filename=_" },
                    { ":", "attachment; filename=\":\"" },
                    { ": :", "attachment; filename=\": :\"" },
                    { "~", "attachment; filename=~" },
                    { "$", "attachment; filename=$" },
                    { "&", "attachment; filename=&" },
                    { "+", "attachment; filename=+" },
                    { "@", "attachment; filename=\"@\"" },
                    { "\"", "attachment; filename=\"\\\"\"" },
                    { "#", "attachment; filename=#" },
                    { "résumé.txt", "attachment; filename*=UTF-8''r%C3%A9sum%C3%A9.txt" },
                    { "Δ", "attachment; filename*=UTF-8''%CE%94" },
                    { "Δ\t", "attachment; filename*=UTF-8''%CE%94%09" },
                    { "ABCXYZabcxyz012789!@#$%^&*()-=_+.:~Δ", @"attachment; filename*=UTF-8''ABCXYZabcxyz012789!%40%23$%25%5E&%2A%28%29-%3D_+.:~%CE%94" },
                };
            }
        }

        [Theory, PropertyData("ContentDispositionData")]
        public void GetHeaderValue_Produces_Correct_ContentDisposition(string input, string expectedOutput)
        {
            // Arrange & Act
            string actual = FileResult.ContentDispositionUtil.GetHeaderValue(input);

            // Assert
            Assert.Equal(expectedOutput, actual);
        }

        private class EmptyFileResult : FileResult
        {
            public bool WasWriteFileCalled;

            public EmptyFileResult()
                : this(MediaTypeNames.Application.Octet)
            {
            }

            public EmptyFileResult(string contentType)
                : base(contentType)
            {
            }

            protected override void WriteFile(HttpResponseBase response)
            {
                WasWriteFileCalled = true;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FileStreamResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FileStreamResultTest
    {
        private static readonly Random _random = new Random();

        [Fact]
        public void ConstructorSetsFileStreamProperty()
        {
            // Arrange
            Stream stream = new MemoryStream();

            // Act
            FileStreamResult result = new FileStreamResult(stream, "contentType");

            // Assert
            Assert.Same(stream, result.FileStream);
        }

        [Fact]
        public void ConstructorThrowsIfFileStreamIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new FileStreamResult(null, "contentType"); }, "fileStream");
        }

        [Fact]
        public void WriteFileCopiesProvidedStreamToOutputStream()
        {
            // Arrange
            int byteLen = 0x1234;
            byte[] originalBytes = GetRandomByteArray(byteLen);
            MemoryStream originalStream = new MemoryStream(originalBytes);
            MemoryStream outStream = new MemoryStream();

            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(r => r.OutputStream).Returns(outStream);

            FileStreamResultHelper helper = new FileStreamResultHelper(originalStream, "application/octet-stream");

            // Act
            helper.PublicWriteFile(mockResponse.Object);

            // Assert
            byte[] outBytes = outStream.ToArray();
            Assert.True(originalBytes.SequenceEqual(outBytes));
            mockResponse.Verify();
        }

        private static byte[] GetRandomByteArray(int length)
        {
            byte[] bytes = new byte[length];
            _random.NextBytes(bytes);
            return bytes;
        }

        private class FileStreamResultHelper : FileStreamResult
        {
            public FileStreamResultHelper(Stream fileStream, string contentType)
                : base(fileStream, contentType)
            {
            }

            public void PublicWriteFile(HttpResponseBase response)
            {
                WriteFile(response);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FilterAttributeFilterProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FilterAttributeFilterProviderTest
    {
        [Fact]
        public void GetFilters_WithNullController_ReturnsEmptyList()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var provider = new FilterAttributeFilterProvider();

            // Act
            IEnumerable<Filter> result = provider.GetFilters(context, descriptor);

            // Assert
            Assert.Empty(result);
        }

        [MyFilter(Order = 2112)]
        private class ControllerWithTypeAttribute : Controller
        {
        }

        [Fact]
        public void GetFilters_IncludesAttributesOnControllerType()
        {
            // Arrange
            var context = new ControllerContext { Controller = new ControllerWithTypeAttribute() };
            var controllerDescriptorMock = new Mock<ControllerDescriptor>();
            controllerDescriptorMock.Setup(cd => cd.GetFilterAttributes(It.IsAny<bool>()))
                .Returns(new FilterAttribute[] { new MyFilterAttribute { Order = 2112 } });
            var actionDescriptorMock = new Mock<ActionDescriptor>();
            actionDescriptorMock.Setup(ad => ad.ControllerDescriptor).Returns(controllerDescriptorMock.Object);
            var provider = new FilterAttributeFilterProvider();

            // Act
            Filter filter = provider.GetFilters(context, actionDescriptorMock.Object).Single();

            // Assert
            MyFilterAttribute attrib = filter.Instance as MyFilterAttribute;
            Assert.NotNull(attrib);
            Assert.Equal(FilterScope.Controller, filter.Scope);
            Assert.Equal(2112, filter.Order);
        }

        private class ControllerWithActionAttribute : Controller
        {
            [MyFilter(Order = 1234)]
            public ActionResult MyActionMethod()
            {
                return null;
            }
        }

        [Fact]
        public void GetFilters_IncludesAttributesOnActionMethod()
        {
            // Arrange
            var context = new ControllerContext { Controller = new ControllerWithActionAttribute() };
            var controllerDescriptor = new ReflectedControllerDescriptor(context.Controller.GetType());
            var action = context.Controller.GetType().GetMethod("MyActionMethod");
            var actionDescriptor = new ReflectedActionDescriptor(action, "MyActionMethod", controllerDescriptor);
            var provider = new FilterAttributeFilterProvider();

            // Act
            Filter filter = provider.GetFilters(context, actionDescriptor).Single();

            // Assert
            MyFilterAttribute attrib = filter.Instance as MyFilterAttribute;
            Assert.NotNull(attrib);
            Assert.Equal(FilterScope.Action, filter.Scope);
            Assert.Equal(1234, filter.Order);
        }

        private abstract class BaseController : Controller
        {
            public ActionResult MyActionMethod()
            {
                return null;
            }
        }

        [MyFilter]
        private class DerivedController : BaseController
        {
        }

        [Fact]
        public void GetFilters_IncludesTypeAttributesFromDerivedTypeWhenMethodIsOnBaseClass()
        { // DDB #208062
            // Arrange
            var context = new ControllerContext { Controller = new DerivedController() };
            var controllerDescriptor = new ReflectedControllerDescriptor(context.Controller.GetType());
            var action = context.Controller.GetType().GetMethod("MyActionMethod");
            var actionDescriptor = new ReflectedActionDescriptor(action, "MyActionMethod", controllerDescriptor);
            var provider = new FilterAttributeFilterProvider();

            // Act
            IEnumerable<Filter> filters = provider.GetFilters(context, actionDescriptor);

            // Assert
            Assert.NotNull(filters.Select(f => f.Instance).Cast<MyFilterAttribute>().Single());
        }

        private class MyFilterAttribute : FilterAttribute
        {
        }

        [Fact]
        public void GetFilters_RetrievesCachedAttributesByDefault()
        {
            // Arrange
            var provider = new FilterAttributeFilterProvider();
            var context = new ControllerContext { Controller = new DerivedController() };
            var controllerDescriptorMock = new Mock<ControllerDescriptor>();
            controllerDescriptorMock.Setup(cd => cd.GetFilterAttributes(true)).Returns(Enumerable.Empty<FilterAttribute>()).Verifiable();
            var actionDescriptorMock = new Mock<ActionDescriptor>();
            actionDescriptorMock.Setup(ad => ad.GetFilterAttributes(true)).Returns(Enumerable.Empty<FilterAttribute>()).Verifiable();
            actionDescriptorMock.Setup(ad => ad.ControllerDescriptor).Returns(controllerDescriptorMock.Object);

            // Act
            var result = provider.GetFilters(context, actionDescriptorMock.Object).ToList();

            // Assert
            controllerDescriptorMock.Verify();
            actionDescriptorMock.Verify();
        }

        [Fact]
        public void GetFilters_RetrievesNonCachedAttributesWhenConfiguredNotTo()
        {
            // Arrange
            var provider = new FilterAttributeFilterProvider(false);
            var context = new ControllerContext { Controller = new DerivedController() };
            var controllerDescriptorMock = new Mock<ControllerDescriptor>();
            controllerDescriptorMock.Setup(cd => cd.GetFilterAttributes(false)).Returns(Enumerable.Empty<FilterAttribute>()).Verifiable();
            var actionDescriptorMock = new Mock<ActionDescriptor>();
            actionDescriptorMock.Setup(ad => ad.GetFilterAttributes(false)).Returns(Enumerable.Empty<FilterAttribute>()).Verifiable();
            actionDescriptorMock.Setup(ad => ad.ControllerDescriptor).Returns(controllerDescriptorMock.Object);

            // Act
            var result = provider.GetFilters(context, actionDescriptorMock.Object).ToList();

            // Assert
            controllerDescriptorMock.Verify();
            actionDescriptorMock.Verify();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FilterInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Mvc.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FilterInfoTest
    {
        [Fact]
        public void Constructor_Default()
        {
            // Arrange + Act
            FilterInfo filterInfo = new FilterInfo();

            // Assert
            Assert.Empty(filterInfo.ActionFilters);
            Assert.Empty(filterInfo.AuthorizationFilters);
            Assert.Empty(filterInfo.AuthenticationFilters);
            Assert.Empty(filterInfo.ExceptionFilters);
            Assert.Empty(filterInfo.ResultFilters);
        }

        [Fact]
        public void Constructor_PopulatesFilterCollections()
        {
            // Arrange
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            IAuthorizationFilter expectedAuthorizationFilter = CreateDummyAuthorizationFilter();
            IAuthenticationFilter expectedAuthenticationFilter = CreateDummyAuthenticationFilter();
            IExceptionFilter expectedExceptionFilter = CreateDummyExceptionFilter();
            IResultFilter expectedResultFilter = CreateDummyResultFilter();

            List<Filter> filters = new List<Filter>()
            {
                CreateFilter(expectedActionFilter),
                CreateFilter(expectedAuthorizationFilter),
                CreateFilter(expectedAuthenticationFilter),
                CreateFilter(expectedExceptionFilter),
                CreateFilter(expectedResultFilter),
            };

            // Act
            FilterInfo filterInfo = new FilterInfo(filters);

            // Assert
            Assert.Same(expectedActionFilter, filterInfo.ActionFilters.SingleOrDefault());
            Assert.Same(expectedAuthorizationFilter, filterInfo.AuthorizationFilters.SingleOrDefault());
            Assert.Same(expectedAuthenticationFilter, filterInfo.AuthenticationFilters.SingleOrDefault());
            Assert.Same(expectedExceptionFilter, filterInfo.ExceptionFilters.SingleOrDefault());
            Assert.Same(expectedResultFilter, filterInfo.ResultFilters.SingleOrDefault());
        }

        [Fact]
        public void Constructor_IteratesOverFiltersOnlyOnce()
        {
            // Arrange
            var filtersMock = new Mock<IEnumerable<Filter>>();
            filtersMock.Setup(f => f.GetEnumerator()).Returns(new List<Filter>().GetEnumerator());

            // Act
            FilterInfo filterInfo = new FilterInfo(filtersMock.Object);

            // Assert
            filtersMock.Verify(f => f.GetEnumerator(), Times.Once());
        }

        [Fact]
        public void ActionFilters_ReturnsAllActionFilters_WhenOverrideScopeIsFirst()
        {
            // Arrange
            IActionFilter expectedFirstFilter = CreateDummyActionFilter();
            Filter firstFilter = CreateFilter(expectedFirstFilter, FilterScope.First);
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            Filter globalFilter = CreateFilter(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            Filter controllerFilter = CreateFilter(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            Filter actionFilter = CreateFilter(expectedActionFilter, FilterScope.Action);
            IActionFilter expectedLastFilter = CreateDummyActionFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IActionFilter)), FilterScope.First);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IActionFilter> actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(5, actionFilters.Count);
            Assert.Same(expectedFirstFilter, actionFilters[0]);
            Assert.Same(expectedGlobalFilter, actionFilters[1]);
            Assert.Same(expectedControllerFilter, actionFilters[2]);
            Assert.Same(expectedActionFilter, actionFilters[3]);
            Assert.Same(expectedLastFilter, actionFilters[4]);
        }

        [Fact]
        public void ActionFilters_ReturnsGlobalAndBelowActionFilters_WhenOverrideScopeIsGlobal()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.First);
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            Filter globalFilter = CreateFilter(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            Filter controllerFilter = CreateFilter(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            Filter actionFilter = CreateFilter(expectedActionFilter, FilterScope.Action);
            IActionFilter expectedLastFilter = CreateDummyActionFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IActionFilter)), FilterScope.Global);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IActionFilter> actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(4, actionFilters.Count);
            Assert.Same(expectedGlobalFilter, actionFilters[0]);
            Assert.Same(expectedControllerFilter, actionFilters[1]);
            Assert.Same(expectedActionFilter, actionFilters[2]);
            Assert.Same(expectedLastFilter, actionFilters[3]);
        }

        [Fact]
        public void ActionFilters_ReturnsControllerAndBelowActionFilters_WhenOverrideScopeIsController()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.First);
            Filter globalFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            Filter controllerFilter = CreateFilter(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            Filter actionFilter = CreateFilter(expectedActionFilter, FilterScope.Action);
            IActionFilter expectedLastFilter = CreateDummyActionFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IActionFilter)), FilterScope.Controller);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IActionFilter> actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(3, actionFilters.Count);
            Assert.Same(expectedControllerFilter, actionFilters[0]);
            Assert.Same(expectedActionFilter, actionFilters[1]);
            Assert.Same(expectedLastFilter, actionFilters[2]);
        }

        [Fact]
        public void ActionFilters_ReturnsActionScopeAndBelowActionFilters_WhenOverrideScopeIsAction()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.First);
            Filter globalFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.Global);
            Filter controllerFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            Filter actionFilter = CreateFilter(expectedActionFilter, FilterScope.Action);
            IActionFilter expectedLastFilter = CreateDummyActionFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IActionFilter)), FilterScope.Action);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IActionFilter> actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(2, actionFilters.Count);
            Assert.Same(expectedActionFilter, actionFilters[0]);
            Assert.Same(expectedLastFilter, actionFilters[1]);
        }

        [Fact]
        public void ActionFilters_ReturnLastActionFilters_WhenOverrideScopeIsLast()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.First);
            Filter globalFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.Global);
            Filter controllerFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.Controller);
            Filter actionFilter = CreateFilter(CreateDummyActionFilter(), FilterScope.Action);
            IActionFilter expectedLastFilter = CreateDummyActionFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IActionFilter)), FilterScope.Last);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IActionFilter> actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(1, actionFilters.Count);
            Assert.Same(expectedLastFilter, actionFilters[0]);
        }

        [Fact]
        public void ActionFilters_ReturnsAllActionFilters_WhenOtherFilterIsOverriddenAtActionLevel()
        {
            // Arrange
            IActionFilter expectedFirstFilter = CreateDummyActionFilter();
            Filter firstFilter = CreateFilter(expectedFirstFilter, FilterScope.First);
            IActionFilter expectedGlobalFilter = CreateDummyActionFilter();
            Filter globalFilter = CreateFilter(expectedGlobalFilter, FilterScope.Global);
            IActionFilter expectedControllerFilter = CreateDummyActionFilter();
            Filter controllerFilter = CreateFilter(expectedControllerFilter, FilterScope.Controller);
            IActionFilter expectedActionFilter = CreateDummyActionFilter();
            Filter actionFilter = CreateFilter(expectedActionFilter, FilterScope.Action);
            IActionFilter expectedLastFilter = CreateDummyActionFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(object)), FilterScope.Action);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IActionFilter> actionFilters = product.ActionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(5, actionFilters.Count);
            Assert.Same(expectedFirstFilter, actionFilters[0]);
            Assert.Same(expectedGlobalFilter, actionFilters[1]);
            Assert.Same(expectedControllerFilter, actionFilters[2]);
            Assert.Same(expectedActionFilter, actionFilters[3]);
            Assert.Same(expectedLastFilter, actionFilters[4]);
        }

        [Fact]
        public void AuthorizationFilters_ReturnsLastAuthorizationFilters_WhenOverrideScopeIsLast()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyAuthorizationFilter(), FilterScope.First);
            Filter globalFilter = CreateFilter(CreateDummyAuthorizationFilter(), FilterScope.Global);
            Filter controllerFilter = CreateFilter(CreateDummyAuthorizationFilter(), FilterScope.Controller);
            Filter actionFilter = CreateFilter(CreateDummyAuthorizationFilter(), FilterScope.Action);
            IAuthorizationFilter expectedLastFilter = CreateDummyAuthorizationFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IAuthorizationFilter)), FilterScope.Last);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IAuthorizationFilter> authorizationFilters = product.AuthorizationFilters;

            // Assert
            Assert.NotNull(authorizationFilters);
            Assert.Equal(1, authorizationFilters.Count);
            Assert.Same(expectedLastFilter, authorizationFilters[0]);
        }

        [Fact]
        public void AuthenticationFilters_ReturnsLastAuthenticationFilters_WhenOverrideScopeIsLast()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyAuthenticationFilter(), FilterScope.First);
            Filter globalFilter = CreateFilter(CreateDummyAuthenticationFilter(), FilterScope.Global);
            Filter controllerFilter = CreateFilter(CreateDummyAuthenticationFilter(), FilterScope.Controller);
            Filter actionFilter = CreateFilter(CreateDummyAuthenticationFilter(), FilterScope.Action);
            IAuthenticationFilter expectedLastFilter = CreateDummyAuthenticationFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IAuthenticationFilter)), FilterScope.Last);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IAuthenticationFilter> authenticationFilters = product.AuthenticationFilters;

            // Assert
            Assert.NotNull(authenticationFilters);
            Assert.Equal(1, authenticationFilters.Count);
            Assert.Same(expectedLastFilter, authenticationFilters[0]);
        }

        [Fact]
        public void ExceptionFilters_ReturnsLastExceptionFilters_WhenOverrideScopeIsLast()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyExceptionFilter(), FilterScope.First);
            Filter globalFilter = CreateFilter(CreateDummyExceptionFilter(), FilterScope.Global);
            Filter controllerFilter = CreateFilter(CreateDummyExceptionFilter(), FilterScope.Controller);
            Filter actionFilter = CreateFilter(CreateDummyExceptionFilter(), FilterScope.Action);
            IExceptionFilter expectedLastFilter = CreateDummyExceptionFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IExceptionFilter)), FilterScope.Last);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IExceptionFilter> exceptionFilters = product.ExceptionFilters;

            // Assert
            Assert.NotNull(exceptionFilters);
            Assert.Equal(1, exceptionFilters.Count);
            Assert.Same(expectedLastFilter, exceptionFilters[0]);
        }

        [Fact]
        public void ResultFilters_ReturnsLastResultFilters_WhenOverrideScopeIsLast()
        {
            // Arrange
            Filter firstFilter = CreateFilter(CreateDummyResultFilter(), FilterScope.First);
            Filter globalFilter = CreateFilter(CreateDummyResultFilter(), FilterScope.Global);
            Filter controllerFilter = CreateFilter(CreateDummyResultFilter(), FilterScope.Controller);
            Filter actionFilter = CreateFilter(CreateDummyResultFilter(), FilterScope.Action);
            IResultFilter expectedLastFilter = CreateDummyResultFilter();
            Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
            Filter overrideFilter = CreateFilter(CreateOverride(typeof(IResultFilter)), FilterScope.Last);
            IEnumerable<Filter> filters = new Filter[] { firstFilter, globalFilter, controllerFilter, actionFilter,
                lastFilter, overrideFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IResultFilter> resultFilters = product.ResultFilters;

            // Assert
            Assert.NotNull(resultFilters);
            Assert.Equal(1, resultFilters.Count);
            Assert.Same(expectedLastFilter, resultFilters[0]);
        }

        [Fact]
        public void FilterImplementingMultipleType_WhereOneTypeIsOverridden_AppearsOnlyInTheOtherList()
        {
            // Arrange
            object expectedInstance = new ActionAndExceptionFilter();
            Filter actionAndExceptionFilter = CreateFilter(expectedInstance, FilterScope.Global);
            Filter overrideExceptionFilter = CreateFilter(CreateOverride(typeof(IExceptionFilter)),
                FilterScope.Action);
            IEnumerable<Filter> filters = new Filter[] { actionAndExceptionFilter, overrideExceptionFilter };
            FilterInfo product = CreateProductUnderTest(filters);

            // Act
            IList<IActionFilter> actionFilters = product.ActionFilters;
            IList<IExceptionFilter> exceptionFilters = product.ExceptionFilters;

            // Assert
            Assert.NotNull(actionFilters);
            Assert.Equal(1, actionFilters.Count);
            Assert.Same(expectedInstance, actionFilters[0]);
            Assert.NotNull(exceptionFilters);
            Assert.Equal(0, exceptionFilters.Count);
        }

        private static IActionFilter CreateDummyActionFilter()
        {
            return new Mock<IActionFilter>(MockBehavior.Strict).Object;
        }

        private static IAuthenticationFilter CreateDummyAuthenticationFilter()
        {
            return new Mock<IAuthenticationFilter>(MockBehavior.Strict).Object;
        }

        private static IAuthorizationFilter CreateDummyAuthorizationFilter()
        {
            return new Mock<IAuthorizationFilter>(MockBehavior.Strict).Object;
        }

        private static IExceptionFilter CreateDummyExceptionFilter()
        {
            return new Mock<IExceptionFilter>(MockBehavior.Strict).Object;
        }

        private static IResultFilter CreateDummyResultFilter()
        {
            return new Mock<IResultFilter>(MockBehavior.Strict).Object;
        }

        private static IEnumerable<Filter> CreateEmptyFilters()
        {
            return new Filter[0];
        }

        private static IOverrideFilter CreateOverride(Type filtersToOverride)
        {
            Mock<IOverrideFilter> mock = new Mock<IOverrideFilter>();
            mock.Setup(f => f.FiltersToOverride).Returns(filtersToOverride);
            return mock.Object;
        }

        private static FilterInfo CreateProductUnderTest(IEnumerable<Filter> filters)
        {
            return new FilterInfo(filters);
        }

        private static Filter CreateFilter(object instance)
        {
            return CreateFilter(instance, FilterScope.Global);
        }

        private static Filter CreateFilter(object instance, FilterScope scope)
        {
            return new Filter(instance, scope, null);
        }

        private class ActionAndExceptionFilter : IActionFilter, IExceptionFilter
        {
            public void OnActionExecuting(ActionExecutingContext filterContext)
            {
                throw new NotImplementedException();
            }

            public void OnActionExecuted(ActionExecutedContext filterContext)
            {
                throw new NotImplementedException();
            }

            public void OnException(ExceptionContext filterContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FilterProviderCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FilterProviderCollectionTest
    {
        [Fact]
        public void GuardClauses()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var collection = new FilterProviderCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => collection.GetFilters(null, descriptor),
                "controllerContext"
                );
            Assert.ThrowsArgumentNull(
                () => collection.GetFilters(context, null),
                "actionDescriptor"
                );
        }

        [Fact]
        public void FilterProviderCollectionCombinedItemsCaches()
        {
            // Arrange
            var providers = new IFilterProvider[] 
            {
                new Mock<IFilterProvider>(MockBehavior.Strict).Object, 
                new Mock<IFilterProvider>(MockBehavior.Strict).Object
            };
            var collection = new FilterProviderCollection(providers);

            // Act
            IFilterProvider[] combined1 = collection.CombinedItems;
            IFilterProvider[] combined2 = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined1);
            Assert.Same(combined1, combined2);
        }

        [Fact]
        public void FilterProviderCollectionCombinedItemsClearResetsCache()
        {
            TestCacheReset((collection) => collection.Clear());
        }

        [Fact]
        public void FilterProviderCollectionCombinedItemsInsertResetsCache()
        {
            TestCacheReset((collection) => collection.Insert(0, new Mock<IFilterProvider>(MockBehavior.Strict).Object));
        }

        [Fact]
        public void FilterProviderCollectionCombinedItemsRemoveResetsCache()
        {
            TestCacheReset((collection) => collection.RemoveAt(0));
        }

        [Fact]
        public void FilterProviderCollectionCombinedItemsSetResetsCache()
        {
            TestCacheReset((collection) => collection[0] = new Mock<IFilterProvider>(MockBehavior.Strict).Object);
        }

        private static void TestCacheReset(Action<FilterProviderCollection> mutatingAction)
        {
            // Arrange
            var providers = new List<IFilterProvider>() 
            {
                new Mock<IFilterProvider>(MockBehavior.Strict).Object, 
                new Mock<IFilterProvider>(MockBehavior.Strict).Object
            };
            var collection = new FilterProviderCollection(providers);

            // Act
            mutatingAction(collection);

            IFilterProvider[] combined = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined);
        }

        [Fact]
        public void FilterProviderCollectionCombinedItemsDelegatesToResolver()
        {
            // Arrange
            var firstProvider = new Mock<IFilterProvider>();
            var secondProvider = new Mock<IFilterProvider>();
            var thirdProvider = new Mock<IFilterProvider>();
            var dependencyProviders = new IFilterProvider[] { firstProvider.Object, secondProvider.Object };
            var collectionProviders = new IFilterProvider[] { thirdProvider.Object };
            var expectedProviders = new IFilterProvider[] { firstProvider.Object, secondProvider.Object, thirdProvider.Object };

            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IFilterProvider))).Returns(dependencyProviders);

            var providers = new FilterProviderCollection(collectionProviders, resolver.Object);

            // Act
            IFilterProvider[] combined = providers.CombinedItems;

            // Assert
            Assert.Equal(expectedProviders, combined);
        }

        [Fact]
        public void GetFiltersUsesRegisteredProviders()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var filter = new Filter(new Object(), FilterScope.Action, null);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            var collection = new FilterProviderCollection(new[] { provider.Object });
            provider.Setup(p => p.GetFilters(context, descriptor)).Returns(new[] { filter });

            // Act
            IEnumerable<Filter> result = collection.GetFilters(context, descriptor);

            // Assert
            Assert.Same(filter, result.Single());
        }

        [Fact]
        public void GetFiltersDelegatesToResolver()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var filter = new Filter(new Object(), FilterScope.Action, null);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            provider.Setup(p => p.GetFilters(context, descriptor)).Returns(new[] { filter });

            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IFilterProvider))).Returns(new[] { provider.Object });


            var collection = new FilterProviderCollection(new IFilterProvider[0], resolver.Object);

            // Act
            IEnumerable<Filter> result = collection.GetFilters(context, descriptor);

            // Assert
            Assert.Same(filter, result.Single());
        }

        [Fact]
        public void GetFiltersSortsFiltersByOrderFirstThenScope()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var actionFilter = new Filter(new Object(), FilterScope.Action, null);
            var controllerFilter = new Filter(new Object(), FilterScope.Controller, null);
            var globalFilter = new Filter(new Object(), FilterScope.Global, null);
            var earlyActionFilter = new Filter(new Object(), FilterScope.Action, -100);
            var lateGlobalFilter = new Filter(new Object(), FilterScope.Global, 100);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            var collection = new FilterProviderCollection(new[] { provider.Object });
            provider.Setup(p => p.GetFilters(context, descriptor))
                .Returns(new[] { actionFilter, controllerFilter, globalFilter, earlyActionFilter, lateGlobalFilter });

            // Act
            Filter[] result = collection.GetFilters(context, descriptor).ToArray();

            // Assert
            Assert.Equal(5, result.Length);
            Assert.Same(earlyActionFilter, result[0]);
            Assert.Same(globalFilter, result[1]);
            Assert.Same(controllerFilter, result[2]);
            Assert.Same(actionFilter, result[3]);
            Assert.Same(lateGlobalFilter, result[4]);
        }

        [AttributeUsage(AttributeTargets.All, AllowMultiple = false)]
        private class AllowMultipleFalseAttribute : FilterAttribute
        {
        }

        [Fact]
        public void GetFiltersIncludesLastFilterOnlyWithAttributeUsageAllowMultipleFalse()
        { // DDB #222988
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var globalFilter = new Filter(new AllowMultipleFalseAttribute(), FilterScope.Global, null);
            var controllerFilter = new Filter(new AllowMultipleFalseAttribute(), FilterScope.Controller, null);
            var actionFilter = new Filter(new AllowMultipleFalseAttribute(), FilterScope.Action, null);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            var collection = new FilterProviderCollection(new[] { provider.Object });
            provider.Setup(p => p.GetFilters(context, descriptor))
                .Returns(new[] { controllerFilter, actionFilter, globalFilter });

            // Act
            IEnumerable<Filter> result = collection.GetFilters(context, descriptor);

            // Assert
            Assert.Same(actionFilter, result.Single());
        }

        [AttributeUsage(AttributeTargets.All, AllowMultiple = true)]
        private class AllowMultipleTrueAttribute : FilterAttribute
        {
        }

        [Fact]
        public void GetFiltersIncludesAllFiltersWithAttributeUsageAllowMultipleTrue()
        { // DDB #222988
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var globalFilter = new Filter(new AllowMultipleTrueAttribute(), FilterScope.Global, null);
            var controllerFilter = new Filter(new AllowMultipleTrueAttribute(), FilterScope.Controller, null);
            var actionFilter = new Filter(new AllowMultipleTrueAttribute(), FilterScope.Action, null);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            var collection = new FilterProviderCollection(new[] { provider.Object });
            provider.Setup(p => p.GetFilters(context, descriptor))
                .Returns(new[] { controllerFilter, actionFilter, globalFilter });

            // Act
            List<Filter> result = collection.GetFilters(context, descriptor).ToList();

            // Assert
            Assert.Same(globalFilter, result[0]);
            Assert.Same(controllerFilter, result[1]);
            Assert.Same(actionFilter, result[2]);
        }

        private class AllowMultipleCustomFilter : MvcFilter
        {
            public AllowMultipleCustomFilter(bool allowMultiple)
                : base(allowMultiple, -1)
            {
            }
        }

        [Fact]
        public void GetFiltersIncludesLastFilterOnlyWithCustomFilterAllowMultipleFalse()
        { // DDB #222988
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var globalFilter = new Filter(new AllowMultipleCustomFilter(false), FilterScope.Global, null);
            var controllerFilter = new Filter(new AllowMultipleCustomFilter(false), FilterScope.Controller, null);
            var actionFilter = new Filter(new AllowMultipleCustomFilter(false), FilterScope.Action, null);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            var collection = new FilterProviderCollection(new[] { provider.Object });
            provider.Setup(p => p.GetFilters(context, descriptor))
                .Returns(new[] { controllerFilter, actionFilter, globalFilter });

            // Act
            IEnumerable<Filter> result = collection.GetFilters(context, descriptor);

            // Assert
            Assert.Same(actionFilter, result.Single());
        }

        [Fact]
        public void GetFiltersIncludesAllFiltersWithCustomFilterAllowMultipleTrue()
        { // DDB #222988
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            var globalFilter = new Filter(new AllowMultipleCustomFilter(true), FilterScope.Global, null);
            var controllerFilter = new Filter(new AllowMultipleCustomFilter(true), FilterScope.Controller, null);
            var actionFilter = new Filter(new AllowMultipleCustomFilter(true), FilterScope.Action, null);
            var provider = new Mock<IFilterProvider>(MockBehavior.Strict);
            var collection = new FilterProviderCollection(new[] { provider.Object });
            provider.Setup(p => p.GetFilters(context, descriptor))
                .Returns(new[] { controllerFilter, actionFilter, globalFilter });

            // Act
            List<Filter> result = collection.GetFilters(context, descriptor).ToList();

            // Assert
            Assert.Same(globalFilter, result[0]);
            Assert.Same(controllerFilter, result[1]);
            Assert.Same(actionFilter, result[2]);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FilterProvidersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class FilterProvidersTest
    {
        [Fact]
        public void DefaultFilterProviders()
        {
            // Assert
            Assert.NotNull(FilterProviders.Providers.Single(fp => fp is GlobalFilterCollection));
            Assert.NotNull(FilterProviders.Providers.Single(fp => fp is FilterAttributeFilterProvider));
            Assert.NotNull(FilterProviders.Providers.Single(fp => fp is ControllerInstanceFilterProvider));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FilterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FilterTest
    {
        [Fact]
        public void GuardClause()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new Filter(null, FilterScope.Action, null),
                "instance"
                );
        }

        [Fact]
        public void FilterDoesNotImplementIOrderedFilter()
        {
            // Arrange
            var filterInstance = new object();

            // Act
            var filter = new Filter(filterInstance, FilterScope.Action, null);

            // Assert
            Assert.Same(filterInstance, filter.Instance);
            Assert.Equal(FilterScope.Action, filter.Scope);
            Assert.Equal(Filter.DefaultOrder, filter.Order);
        }

        [Fact]
        public void FilterImplementsIOrderedFilter()
        {
            // Arrange
            var filterInstance = new Mock<IMvcFilter>();
            filterInstance.SetupGet(f => f.Order).Returns(42);

            // Act
            var filter = new Filter(filterInstance.Object, FilterScope.Controller, null);

            // Assert
            Assert.Same(filterInstance.Object, filter.Instance);
            Assert.Equal(FilterScope.Controller, filter.Scope);
            Assert.Equal(42, filter.Order);
        }

        [Fact]
        public void ExplicitOrderOverridesIOrderedFilter()
        {
            // Arrange
            var filterInstance = new Mock<IMvcFilter>();
            filterInstance.SetupGet(f => f.Order).Returns(42);

            // Act
            var filter = new Filter(filterInstance.Object, FilterScope.Controller, 2112);

            // Assert
            Assert.Same(filterInstance.Object, filter.Instance);
            Assert.Equal(FilterScope.Controller, filter.Scope);
            Assert.Equal(2112, filter.Order);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FormCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FormCollectionTest
    {
        [Fact]
        public void ConstructorCopiesProvidedCollection()
        {
            // Arrange
            NameValueCollection nvc = new NameValueCollection()
            {
                { "foo", "fooValue" },
                { "bar", "barValue" }
            };

            // Act
            FormCollection formCollection = new FormCollection(nvc);

            // Assert
            Assert.Equal(2, formCollection.Count);
            Assert.Equal("fooValue", formCollection["foo"]);
            Assert.Equal("barValue", formCollection["bar"]);
        }

        [Fact]
        public void ConstructorThrowsIfCollectionIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new FormCollection(null); }, "collection");
        }

        [Fact]
        public void ConstructorUsesValidatedValuesWhenControllerIsNull()
        {
            // Arrange
            var values = new NameValueCollection()
            {
                { "foo", "fooValue" },
                { "bar", "barValue" }
            };

            // Act
            var result = new FormCollection(controller: null,
                                            validatedValuesThunk: () => values,
                                            unvalidatedValuesThunk: () => { throw new NotImplementedException(); });

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("fooValue", result["foo"]);
            Assert.Equal("barValue", result["bar"]);
        }

        [Fact]
        public void ConstructorUsesValidatedValuesWhenControllerValidateRequestIsTrue()
        {
            // Arrange
            var values = new NameValueCollection()
            {
                { "foo", "fooValue" },
                { "bar", "barValue" }
            };
            var controller = new Mock<ControllerBase>().Object;
            controller.ValidateRequest = true;

            // Act
            var result = new FormCollection(controller,
                                            validatedValuesThunk: () => values,
                                            unvalidatedValuesThunk: () => { throw new NotImplementedException(); });

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("fooValue", result["foo"]);
            Assert.Equal("barValue", result["bar"]);
        }

        [Fact]
        public void ConstructorUsesUnvalidatedValuesWhenControllerValidateRequestIsFalse()
        {
            // Arrange
            var values = new NameValueCollection()
            {
                { "foo", "fooValue" },
                { "bar", "barValue" }
            };
            var controller = new Mock<ControllerBase>().Object;
            controller.ValidateRequest = false;

            // Act
            var result = new FormCollection(controller,
                                            validatedValuesThunk: () => { throw new NotImplementedException(); },
                                            unvalidatedValuesThunk: () => values);

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("fooValue", result["foo"]);
            Assert.Equal("barValue", result["bar"]);
        }

        [Fact]
        public void CustomBinderBindModelReturnsFormCollection()
        {
            // Arrange
            NameValueCollection nvc = new NameValueCollection() { { "foo", "fooValue" }, { "bar", "barValue" } };
            IModelBinder binder = ModelBinders.Binders.GetBinder(typeof(FormCollection));

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.Form).Returns(nvc);

            // Act
            FormCollection formCollection = (FormCollection)binder.BindModel(mockControllerContext.Object, null);

            // Assert
            Assert.NotNull(formCollection);
            Assert.Equal(2, formCollection.Count);
            Assert.Equal("fooValue", nvc["foo"]);
            Assert.Equal("barValue", nvc["bar"]);
        }

        [Fact]
        public void CustomBinderBindModelThrowsIfControllerContextIsNull()
        {
            // Arrange
            IModelBinder binder = ModelBinders.Binders.GetBinder(typeof(FormCollection));

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { binder.BindModel(null, null); }, "controllerContext");
        }

        [Fact]
        public void GetValue_ThrowsIfNameIsNull()
        {
            // Arrange
            FormCollection formCollection = new FormCollection();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { formCollection.GetValue(null); }, "name");
        }

        [Fact]
        public void GetValue_KeyDoesNotExist_ReturnsNull()
        {
            // Arrange
            FormCollection formCollection = new FormCollection();

            // Act
            ValueProviderResult vpResult = formCollection.GetValue("");

            // Assert
            Assert.Null(vpResult);
        }

        [Fact]
        public void GetValue_KeyExists_ReturnsResult()
        {
            // Arrange
            FormCollection formCollection = new FormCollection()
            {
                { "foo", "1" },
                { "foo", "2" }
            };

            // Act
            ValueProviderResult vpResult = formCollection.GetValue("foo");

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(new[] { "1", "2" }, (string[])vpResult.RawValue);
            Assert.Equal("1,2", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult.Culture);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FormContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class FormContextTest
    {
        [Fact]
        public void FieldValidatorsProperty()
        {
            // Arrange
            FormContext context = new FormContext();

            // Act
            IDictionary<String, FieldValidationMetadata> fieldValidators = context.FieldValidators;

            // Assert
            Assert.NotNull(fieldValidators);
            Assert.Empty(fieldValidators);
        }

        [Fact]
        public void ReplaceValidationSummaryProperty()
        {
            // Arrange
            FormContext context = new FormContext();

            // Act & Assert
            MemberHelper.TestBooleanProperty(context, "ReplaceValidationSummary", false, false);
        }

        [Fact]
        public void GetJsonValidationMetadata_NoValidationSummary()
        {
            // Arrange
            FormContext context = new FormContext() { FormId = "theFormId" };

            ModelClientValidationRule rule = new ModelClientValidationRule() { ValidationType = "ValidationType1", ErrorMessage = "Error Message" };
            rule.ValidationParameters["theParam"] = new { FirstName = "John", LastName = "Doe", Age = 32 };
            FieldValidationMetadata metadata = new FieldValidationMetadata() { FieldName = "theFieldName", ValidationMessageId = "theFieldName_ValidationMessage" };
            metadata.ValidationRules.Add(rule);
            context.FieldValidators["theFieldName"] = metadata;

            // Act
            string jsonMetadata = context.GetJsonValidationMetadata();

            // Assert
            string expected = @"{""Fields"":[{""FieldName"":""theFieldName"",""ReplaceValidationMessageContents"":false,""ValidationMessageId"":""theFieldName_ValidationMessage"",""ValidationRules"":[{""ErrorMessage"":""Error Message"",""ValidationParameters"":{""theParam"":{""FirstName"":""John"",""LastName"":""Doe"",""Age"":32}},""ValidationType"":""ValidationType1""}]}],""FormId"":""theFormId"",""ReplaceValidationSummary"":false}";
            Assert.Equal(expected, jsonMetadata);
        }

        [Fact]
        public void GetJsonValidationMetadata_ValidationSummary()
        {
            // Arrange
            FormContext context = new FormContext() { FormId = "theFormId", ValidationSummaryId = "validationSummary" };

            ModelClientValidationRule rule = new ModelClientValidationRule() { ValidationType = "ValidationType1", ErrorMessage = "Error Message" };
            rule.ValidationParameters["theParam"] = new { FirstName = "John", LastName = "Doe", Age = 32 };
            FieldValidationMetadata metadata = new FieldValidationMetadata() { FieldName = "theFieldName", ValidationMessageId = "theFieldName_ValidationMessage" };
            metadata.ValidationRules.Add(rule);
            context.FieldValidators["theFieldName"] = metadata;

            // Act
            string jsonMetadata = context.GetJsonValidationMetadata();

            // Assert
            string expected = @"{""Fields"":[{""FieldName"":""theFieldName"",""ReplaceValidationMessageContents"":false,""ValidationMessageId"":""theFieldName_ValidationMessage"",""ValidationRules"":[{""ErrorMessage"":""Error Message"",""ValidationParameters"":{""theParam"":{""FirstName"":""John"",""LastName"":""Doe"",""Age"":32}},""ValidationType"":""ValidationType1""}]}],""FormId"":""theFormId"",""ReplaceValidationSummary"":false,""ValidationSummaryId"":""validationSummary""}";
            Assert.Equal(expected, jsonMetadata);
        }

        [Fact]
        public void GetValidationMetadataForField_Create_CreatesNewMetadataIfNotFound()
        {
            // Arrange
            FormContext context = new FormContext();

            // Act
            FieldValidationMetadata result = context.GetValidationMetadataForField("fieldName", true /* createIfNotFound */);

            // Assert
            Assert.NotNull(result);
            Assert.Equal("fieldName", result.FieldName);

            Assert.Single(context.FieldValidators);
            Assert.Equal(result, context.FieldValidators["fieldName"]);
        }

        [Fact]
        public void GetValidationMetadataForField_NoCreate_ReturnsMetadataIfFound()
        {
            // Arrange
            FormContext context = new FormContext();
            FieldValidationMetadata metadata = new FieldValidationMetadata();
            context.FieldValidators["fieldName"] = metadata;

            // Act
            FieldValidationMetadata result = context.GetValidationMetadataForField("fieldName");

            // Assert
            Assert.NotNull(result);
            Assert.Equal(metadata, result);
        }

        [Fact]
        public void GetValidationMetadataForField_NoCreate_ReturnsNullIfNotFound()
        {
            // Arrange
            FormContext context = new FormContext();

            // Act
            FieldValidationMetadata result = context.GetValidationMetadataForField("fieldName");

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public void GetValidationMetadataForFieldThrowsIfFieldNameIsEmpty()
        {
            // Arrange
            FormContext context = new FormContext();

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { context.GetValidationMetadataForField(String.Empty); }, "fieldName");
        }

        [Fact]
        public void GetValidationMetadataForFieldThrowsIfFieldNameIsNull()
        {
            // Arrange
            FormContext context = new FormContext();

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { context.GetValidationMetadataForField(null); }, "fieldName");
        }

        // RenderedField

        [Fact]
        public void RenderedFieldIsFalseByDefault()
        {
            // Arrange
            var context = new FormContext();

            // Act
            bool result = context.RenderedField(Guid.NewGuid().ToString());

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void CanSetRenderedFieldToBeTrue()
        {
            // Arrange
            var context = new FormContext();
            var name = Guid.NewGuid().ToString();
            context.RenderedField(name, true);

            // Act
            bool result = context.RenderedField(name);

            // Assert
            Assert.True(result);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/FormValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class FormValueProviderFactoryTest
    {
        private static readonly NameValueCollection _backingStore = new NameValueCollection()
        {
            { "foo", "fooValue" }
        };

        private static readonly NameValueCollection _unvalidatedBackingStore = new NameValueCollection()
        {
            { "foo", "fooUnvalidated" }
        };

        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            Mock<MockableUnvalidatedRequestValues> mockUnvalidatedValues = new Mock<MockableUnvalidatedRequestValues>();
            FormValueProviderFactory factory = new FormValueProviderFactory(_ => mockUnvalidatedValues.Object);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.Form).Returns(_backingStore);

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Equal(typeof(FormValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("foo");

            Assert.NotNull(vpResult);
            Assert.Equal("fooValue", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProvider_GetValue_SkipValidation()
        {
            // Arrange
            Mock<MockableUnvalidatedRequestValues> mockUnvalidatedValues = new Mock<MockableUnvalidatedRequestValues>();
            mockUnvalidatedValues.Setup(o => o.Form).Returns(_unvalidatedBackingStore);
            FormValueProviderFactory factory = new FormValueProviderFactory(_ => mockUnvalidatedValues.Object);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.Form).Returns(_backingStore);

            // Act
            IUnvalidatedValueProvider valueProvider = (IUnvalidatedValueProvider)factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Equal(typeof(FormValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("foo", skipValidation: true);

            Assert.NotNull(vpResult);
            Assert.Equal("fooUnvalidated", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProvider_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            FormValueProviderFactory factory = new FormValueProviderFactory();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { factory.GetValueProvider(null); }, "controllerContext");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/GlobalFilterCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class GlobalFilterCollectionTest
    {
        private GlobalFilterCollection _collection = new GlobalFilterCollection();
        private object _filterInstance = GetFilterInstance<IActionFilter>();

        public static IEnumerable<object[]> AddRejectsNonFilterInstancesData
        {
            get
            {
                return new List<object[]>
                {
                    new object[] { "string", },
                    new object[] { 42, },
                    new object[] { new System.Web.Http.AuthorizeAttribute(), },
                };
            }
        }

        [Theory]
        [PropertyData("AddRejectsNonFilterInstancesData")]
        public void AddRejectsNonFilterInstances(object instance)
        {
            // Act + Assert
            Assert.Throws<InvalidOperationException>(() =>
            {
                _collection.Add(instance);
            }, "The given filter instance must implement one or more of the following filter interfaces: System.Web.Mvc.IAuthorizationFilter, System.Web.Mvc.IActionFilter, System.Web.Mvc.IResultFilter, System.Web.Mvc.IExceptionFilter, System.Web.Mvc.Filters.IAuthenticationFilter.");
        }

        [Fact]
        public void AddAcceptsFilterInstances()
        {
            // Arrange
            var filters = new object[] {
                GetFilterInstance<IActionFilter>(),
                GetFilterInstance<IAuthorizationFilter>(),
                GetFilterInstance<IResultFilter>(),
                GetFilterInstance<IExceptionFilter>() 
            }.ToList();

            // Act
            filters.ForEach(f => _collection.Add(f));

            // Assert
            Assert.Equal(filters, _collection.Select(i => i.Instance));
        }

        [Fact]
        public void AddPlacesFilterInGlobalScope()
        {
            // Act
            _collection.Add(_filterInstance);

            // Assert
            Filter filter = Assert.Single(_collection);
            Assert.Same(_filterInstance, filter.Instance);
            Assert.Equal(FilterScope.Global, filter.Scope);
            Assert.Equal(-1, filter.Order);
        }

        [Fact]
        public void AddWithOrderPlacesFilterInGlobalScope()
        {
            // Act
            _collection.Add(_filterInstance, 42);

            // Assert
            Filter filter = Assert.Single(_collection);
            Assert.Same(_filterInstance, filter.Instance);
            Assert.Equal(FilterScope.Global, filter.Scope);
            Assert.Equal(42, filter.Order);
        }

        [Fact]
        public void ContainsFindsFilterByInstance()
        {
            // Arrange
            _collection.Add(_filterInstance);

            // Act
            bool result = _collection.Contains(_filterInstance);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void RemoveDeletesFilterByInstance()
        {
            // Arrange
            _collection.Add(_filterInstance);

            // Act
            _collection.Remove(_filterInstance);

            // Assert
            Assert.Empty(_collection);
        }

        [Fact]
        public void CollectionIsIFilterProviderWhichReturnsAllFilters()
        {
            // Arrange
            var context = new ControllerContext();
            var descriptor = new Mock<ActionDescriptor>().Object;
            _collection.Add(_filterInstance);
            var provider = (IFilterProvider)_collection;

            // Act
            IEnumerable<Filter> result = provider.GetFilters(context, descriptor);

            // Assert
            Filter filter = Assert.Single(result);
            Assert.Same(_filterInstance, filter.Instance);
        }

        private static TFilter GetFilterInstance<TFilter>() where TFilter : class
        {
            return new Mock<TFilter>().Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HandleErrorAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Web.Routing;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HandleErrorAttributeTest
    {
        [Fact]
        public void HandleErrorAttributeReturnsUniqueTypeIDs()
        {
            // Arrange
            HandleErrorAttribute attr1 = new HandleErrorAttribute();
            HandleErrorAttribute attr2 = new HandleErrorAttribute();

            // Assert
            Assert.NotEqual(attr1.TypeId, attr2.TypeId);
        }

        [HandleError(View = "foo")]
        [HandleError(View = "bar")]
        private class ClassWithMultipleHandleErrorAttributes
        {
        }

        [Fact]
        public void CanRetrieveMultipleAuthorizeAttributesFromOneClass()
        {
            // Arrange
            ClassWithMultipleHandleErrorAttributes @class = new ClassWithMultipleHandleErrorAttributes();

            // Act
            IEnumerable<HandleErrorAttribute> attributes = TypeDescriptor.GetAttributes(@class).OfType<HandleErrorAttribute>();

            // Assert
            Assert.Equal(2, attributes.Count());
            Assert.Contains(attributes, a => a.View == "foo");
            Assert.Contains(attributes, a => a.View == "bar");
        }

        [Fact]
        public void ExceptionTypeProperty()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();

            // Act
            Type origType = attr.ExceptionType;
            attr.ExceptionType = typeof(SystemException);
            Type newType = attr.ExceptionType;

            // Assert
            Assert.Equal(typeof(Exception), origType);
            Assert.Equal(typeof(SystemException), attr.ExceptionType);
        }

        [Fact]
        public void ExceptionTypePropertyWithNonExceptionTypeThrows()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();

            // Act & Assert
            Assert.Throws<ArgumentException>(
                delegate { attr.ExceptionType = typeof(string); },
                "The type 'System.String' does not inherit from Exception.");
        }

        [Fact]
        public void ExceptionTypePropertyWithNullValueThrows()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { attr.ExceptionType = null; }, "value");
        }

        [Fact]
        public void MasterProperty()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();

            // Act & Assert
            MemberHelper.TestStringProperty(attr, "Master", String.Empty);
        }

        [Fact]
        public void OnException()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute()
            {
                View = "SomeView",
                Master = "SomeMaster",
                ExceptionType = typeof(ArgumentException)
            };
            Exception exception = new ArgumentNullException();

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
            mockHttpContext.Setup(c => c.IsCustomErrorEnabled).Returns(true);
            mockHttpContext.Setup(c => c.Session).Returns((HttpSessionStateBase)null);
            mockHttpContext.Setup(c => c.Response.Clear()).Verifiable();
            mockHttpContext.SetupSet(c => c.Response.StatusCode = 500).Verifiable();
            mockHttpContext.SetupSet(c => c.Response.TrySkipIisCustomErrors = true).Verifiable();

            TempDataDictionary tempData = new TempDataDictionary();
            IViewEngine viewEngine = new Mock<IViewEngine>().Object;
            Controller controller = new Mock<Controller>().Object;
            controller.TempData = tempData;

            ExceptionContext context = GetExceptionContext(mockHttpContext.Object, controller, exception);

            // Exception
            attr.OnException(context);

            // Assert
            mockHttpContext.Verify();
            ViewResult viewResult = context.Result as ViewResult;
            Assert.NotNull(viewResult);
            Assert.Equal(tempData, viewResult.TempData);
            Assert.Equal("SomeView", viewResult.ViewName);
            Assert.Equal("SomeMaster", viewResult.MasterName);

            HandleErrorInfo viewData = viewResult.ViewData.Model as HandleErrorInfo;
            Assert.NotNull(viewData);
            Assert.Same(exception, viewData.Exception);
            Assert.Equal("SomeController", viewData.ControllerName);
            Assert.Equal("SomeAction", viewData.ActionName);
        }

        [Fact]
        public void OnExceptionWithCustomErrorsDisabledDoesNothing()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();
            ActionResult result = new EmptyResult();
            ExceptionContext context = GetExceptionContext(GetHttpContext(false), null, new Exception());
            context.Result = result;

            // Exception
            attr.OnException(context);

            // Assert
            Assert.Same(result, context.Result);
        }

        [Fact]
        public void OnExceptionWithExceptionHandledDoesNothing()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();
            ActionResult result = new EmptyResult();
            ExceptionContext context = GetExceptionContext(GetHttpContext(), null, new Exception());
            context.Result = result;
            context.ExceptionHandled = true;

            // Exception
            attr.OnException(context);

            // Assert
            Assert.Same(result, context.Result);
        }

        [Fact]
        public void OnExceptionWithNon500ExceptionDoesNothing()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();
            ActionResult result = new EmptyResult();
            ExceptionContext context = GetExceptionContext(GetHttpContext(), null, new HttpException(404, "Some Exception"));
            context.Result = result;

            // Exception
            attr.OnException(context);

            // Assert
            Assert.Same(result, context.Result);
        }

        [Fact]
        public void OnExceptionWithNullFilterContextThrows()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnException(null /* filterContext */); }, "filterContext");
        }

        [Fact]
        public void OnExceptionWithWrongExceptionTypeDoesNothing()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute() { ExceptionType = typeof(ArgumentException) };
            ActionResult result = new EmptyResult();
            ExceptionContext context = GetExceptionContext(GetHttpContext(), null, new InvalidCastException());
            context.Result = result;

            // Exception
            attr.OnException(context);

            // Assert
            Assert.Same(result, context.Result);
        }

        [Fact]
        public void ViewProperty()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();

            // Act & Assert
            MemberHelper.TestStringProperty(attr, "View", "Error", nullAndEmptyReturnValue: "Error");
        }

        private static ExceptionContext GetExceptionContext(HttpContextBase httpContext, ControllerBase controller, Exception exception)
        {
            RouteData rd = new RouteData();
            rd.Values["controller"] = "SomeController";
            rd.Values["action"] = "SomeAction";

            Mock<ExceptionContext> mockExceptionContext = new Mock<ExceptionContext>();
            mockExceptionContext.Setup(c => c.Controller).Returns(controller);
            mockExceptionContext.Setup(c => c.Exception).Returns(exception);
            mockExceptionContext.Setup(c => c.RouteData).Returns(rd);
            mockExceptionContext.Setup(c => c.HttpContext).Returns(httpContext);
            return mockExceptionContext.Object;
        }

        private static HttpContextBase GetHttpContext()
        {
            return GetHttpContext(true);
        }

        private static HttpContextBase GetHttpContext(bool isCustomErrorEnabled)
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>(MockBehavior.Strict);
            mockContext.Setup(c => c.IsCustomErrorEnabled).Returns(isCustomErrorEnabled);
            return mockContext.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HandleErrorInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HandleErrorInfoTest
    {
        [Fact]
        public void ConstructorSetsProperties()
        {
            // Arrange
            Exception exception = new Exception();
            string controller = "SomeController";
            string action = "SomeAction";

            // Act
            HandleErrorInfo viewData = new HandleErrorInfo(exception, controller, action);

            // Assert
            Assert.Same(exception, viewData.Exception);
            Assert.Equal(controller, viewData.ControllerName);
            Assert.Equal(action, viewData.ActionName);
        }

        [Fact]
        public void ConstructorWithEmptyActionThrows()
        {
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new HandleErrorInfo(new Exception(), "SomeController", String.Empty); }, "actionName");
        }

        [Fact]
        public void ConstructorWithEmptyControllerThrows()
        {
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new HandleErrorInfo(new Exception(), String.Empty, "SomeAction"); }, "controllerName");
        }

        [Fact]
        public void ConstructorWithNullActionThrows()
        {
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new HandleErrorInfo(new Exception(), "SomeController", null /* action */); }, "actionName");
        }

        [Fact]
        public void ConstructorWithNullControllerThrows()
        {
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new HandleErrorInfo(new Exception(), null /* controller */, "SomeAction"); }, "controllerName");
        }

        [Fact]
        public void ConstructorWithNullExceptionThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { new HandleErrorInfo(null /* exception */, "SomeController", "SomeAction"); }, "exception");
        }

        [Fact]
        public void ErrorHandlingDoesNotFireIfCalledInChildAction()
        {
            // Arrange
            HandleErrorAttribute attr = new HandleErrorAttribute();
            Mock<ExceptionContext> context = new Mock<ExceptionContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act
            attr.OnException(context.Object);

            // Assert
            Assert.IsType<EmptyResult>(context.Object.Result);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HtmlHelperOfTModelTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HtmlHelperOfTModelTest
    {
        [Fact]
        public void StronglyTypedViewBagAndStronglyTypedViewDataStayInSync()
        {
            // Arrange
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            // Act
            HtmlHelper<object> htmlHelper = new HtmlHelper<object>(new Mock<ViewContext>().Object, viewDataContainer.Object);
            htmlHelper.ViewData["B"] = 2;
            htmlHelper.ViewBag.C = 3;

            // Assert

            // Original ViewData should not be modified by redfined ViewData and ViewBag
            HtmlHelper baseHelper = (HtmlHelper)htmlHelper;
            Assert.Single(baseHelper.ViewData.Keys);
            Assert.Equal(1, baseHelper.ViewData["A"]);
            Assert.Equal(1, baseHelper.ViewBag.A);

            // Redefined ViewData and ViewBag should be in sync
            Assert.Equal(3, htmlHelper.ViewData.Keys.Count);

            Assert.Equal(1, htmlHelper.ViewData["A"]);
            Assert.Equal(2, htmlHelper.ViewData["B"]);
            Assert.Equal(3, htmlHelper.ViewData["C"]);

            Assert.Equal(1, htmlHelper.ViewBag.A);
            Assert.Equal(2, htmlHelper.ViewBag.B);
            Assert.Equal(3, htmlHelper.ViewBag.C);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HtmlHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Web.Routing;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class HtmlHelperTest : IDisposable
    {
        public static readonly RouteValueDictionary AttributesDictionary = new RouteValueDictionary(new { baz = "BazValue" });
        public static readonly object AttributesObjectDictionary = new { baz = "BazObjValue" };
        public static readonly object AttributesObjectUnderscoresDictionary = new { foo_baz = "BazObjValue" };

        // Constructor

        [Fact]
        public void ConstructorGuardClauses()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = MvcHelper.GetViewDataContainer(null);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new HtmlHelper(null, viewDataContainer),
                "viewContext"
                );
            Assert.ThrowsArgumentNull(
                () => new HtmlHelper(viewContext, null),
                "viewDataContainer"
                );
            Assert.ThrowsArgumentNull(
                () => new HtmlHelper(viewContext, viewDataContainer, null),
                "routeCollection"
                );
        }

        [Fact]
        public void PropertiesAreSet()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewData = new ViewDataDictionary<String>("The Model");
            var routes = new RouteCollection();
            var mockViewDataContainer = new Mock<IViewDataContainer>();
            mockViewDataContainer.Setup(vdc => vdc.ViewData).Returns(viewData);

            // Act
            var htmlHelper = new HtmlHelper(viewContext, mockViewDataContainer.Object, routes);

            // Assert
            Assert.Equal(viewContext, htmlHelper.ViewContext);
            Assert.Equal(mockViewDataContainer.Object, htmlHelper.ViewDataContainer);
            Assert.Equal(routes, htmlHelper.RouteCollection);
            Assert.Equal(viewData.Model, htmlHelper.ViewData.Model);
        }

        [Fact]
        public void DefaultRouteCollectionIsRouteTableRoutes()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = new Mock<IViewDataContainer>().Object;

            // Act
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);

            // Assert
            Assert.Equal(RouteTable.Routes, htmlHelper.RouteCollection);
        }

        // AnonymousObjectToHtmlAttributes tests

        [Fact]
        public void ConvertsUnderscoresInNamesToDashes()
        {
            // Arrange
            var attributes = new { foo = "Bar", baz_bif = "pow_wow" };

            // Act
            RouteValueDictionary result = HtmlHelper.AnonymousObjectToHtmlAttributes(attributes);

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("Bar", result["foo"]);
            Assert.Equal("pow_wow", result["baz-bif"]);
        }

        // AttributeEncode

        [Fact]
        public void AttributeEncodeObject()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.AttributeEncode((object)@"<"">");

            // Assert
            Assert.Equal("&lt;&quot;>", encodedHtml);
        }

        [Fact]
        public void AttributeEncodeObjectNull()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.AttributeEncode((object)null);

            // Assert
            Assert.Equal("", encodedHtml);
        }

        [Fact]
        public void AttributeEncodeString()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.AttributeEncode(@"<"">");

            // Assert
            Assert.Equal("&lt;&quot;>", encodedHtml);
        }

        [Fact]
        public void AttributeEncodeStringNull()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.AttributeEncode((string)null);

            // Assert
            Assert.Equal("", encodedHtml);
        }

        // EnableClientValidation

        [Fact]
        public void EnableClientValidation()
        {
            // Arrange
            var mockViewContext = new Mock<ViewContext>();
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(mockViewContext.Object, viewDataContainer);

            // Act
            htmlHelper.EnableClientValidation();

            // Act & assert
            mockViewContext.VerifySet(vc => vc.ClientValidationEnabled = true);
        }

        // EnableUnobtrusiveJavaScript

        [Fact]
        public void EnableUnobtrusiveJavaScript()
        {
            // Arrange
            var mockViewContext = new Mock<ViewContext>();
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(mockViewContext.Object, viewDataContainer);

            // Act
            htmlHelper.EnableUnobtrusiveJavaScript();

            // Act & assert
            mockViewContext.VerifySet(vc => vc.UnobtrusiveJavaScriptEnabled = true);
        }

        // Encode

        [Fact]
        public void EncodeObject()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.Encode((object)"<br />");

            // Assert
            Assert.Equal("&lt;br /&gt;", encodedHtml);
        }

        [Fact]
        public void EncodeObjectNull()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.Encode((object)null);

            // Assert
            Assert.Equal("", encodedHtml);
        }

        [Fact]
        public void EncodeString()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.Encode("<br />");

            // Assert
            Assert.Equal("&lt;br /&gt;", encodedHtml);
        }

        [Fact]
        public void EncodeStringNull()
        {
            // Arrange
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper();

            // Act
            string encodedHtml = htmlHelper.Encode((string)null);

            // Assert
            Assert.Equal("", encodedHtml);
        }

        // GetModelStateValue

        [Fact]
        public void GetModelStateValueReturnsNullIfModelStateHasNoValue()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.ModelState.AddModelError("foo", "some error text"); // didn't call SetModelValue()

            HtmlHelper helper = new HtmlHelper(new ViewContext(), new SimpleViewDataContainer(vdd));

            // Act
            object retVal = helper.GetModelStateValue("foo", typeof(object));

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void GetModelStateValueReturnsNullIfModelStateKeyNotPresent()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            HtmlHelper helper = new HtmlHelper(new ViewContext(), new SimpleViewDataContainer(vdd));

            // Act
            object retVal = helper.GetModelStateValue("key_not_present", typeof(object));

            // Assert
            Assert.Null(retVal);
        }

        // GenerateIdFromName

        [Fact]
        public void GenerateIdFromNameTests()
        {
            // Guard clauses
            Assert.ThrowsArgumentNull(
                () => HtmlHelper.GenerateIdFromName(null),
                "name"
                );
            Assert.ThrowsArgumentNull(
                () => HtmlHelper.GenerateIdFromName(null, "?"),
                "name"
                );
            Assert.ThrowsArgumentNull(
                () => HtmlHelper.GenerateIdFromName("?", null),
                "idAttributeDotReplacement"
                );

            // Default replacement tests
            Assert.Equal("", HtmlHelper.GenerateIdFromName(""));
            Assert.Equal("Foo", HtmlHelper.GenerateIdFromName("Foo"));
            Assert.Equal("Foo_Bar", HtmlHelper.GenerateIdFromName("Foo.Bar"));
            Assert.Equal("Foo_Bar_Baz", HtmlHelper.GenerateIdFromName("Foo.Bar.Baz"));
            Assert.Null(HtmlHelper.GenerateIdFromName("1Foo"));
            Assert.Equal("Foo_0_", HtmlHelper.GenerateIdFromName("Foo[0]"));

            // Custom replacement tests
            Assert.Equal("", HtmlHelper.GenerateIdFromName("", "?"));
            Assert.Equal("Foo", HtmlHelper.GenerateIdFromName("Foo", "?"));
            Assert.Equal("Foo?Bar", HtmlHelper.GenerateIdFromName("Foo.Bar", "?"));
            Assert.Equal("Foo?Bar?Baz", HtmlHelper.GenerateIdFromName("Foo.Bar.Baz", "?"));
            Assert.Equal("FooBarBaz", HtmlHelper.GenerateIdFromName("Foo.Bar.Baz", ""));
            Assert.Null(HtmlHelper.GenerateIdFromName("1Foo", "?"));
            Assert.Equal("Foo?0?", HtmlHelper.GenerateIdFromName("Foo[0]", "?"));
        }

        // RenderPartialInternal

        [Fact]
        public void NullPartialViewNameThrows()
        {
            // Arrange
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            ViewDataDictionary viewData = new ViewDataDictionary();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => helper.RenderPartialInternal(null /* partialViewName */, null /* viewData */, null /* model */, TextWriter.Null),
                "partialViewName");
        }

        [Fact]
        public void EmptyPartialViewNameThrows()
        {
            // Arrange
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            ViewDataDictionary viewData = new ViewDataDictionary();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => helper.RenderPartialInternal(String.Empty /* partialViewName */, null /* viewData */, null /* model */, TextWriter.Null),
                "partialViewName");
        }

        [Fact]
        public void EngineLookupSuccessCallsRender()
        {
            // Arrange
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            TextWriter writer = helper.ViewContext.Writer;
            Mock<IViewEngine> engine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            engine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), "partial-view", It.IsAny<bool>()))
                .Returns(new ViewEngineResult(view.Object, engine.Object))
                .Verifiable();
            view
                .Setup(v => v.Render(It.IsAny<ViewContext>(), writer))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, _) =>
                    {
                        Assert.Same(helper.ViewContext.View, viewContext.View);
                        Assert.Same(helper.ViewContext.TempData, viewContext.TempData);
                    })
                .Verifiable();

            // Act
            helper.RenderPartialInternal("partial-view", null /* viewData */, null /* model */, writer, engine.Object);

            // Assert
            engine.Verify();
            view.Verify();
        }

        [Fact]
        public void EngineLookupFailureThrows()
        {
            // Arrange
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            Mock<IViewEngine> engine = new Mock<IViewEngine>(MockBehavior.Strict);
            engine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), "partial-view", It.IsAny<bool>()))
                .Returns(new ViewEngineResult(new[] { "location1", "location2" }))
                .Verifiable();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => helper.RenderPartialInternal("partial-view", null /* viewData */, null /* model */, TextWriter.Null, engine.Object),
                "The partial view 'partial-view' was not found or no view engine supports the searched locations. The following locations were searched:" + Environment.NewLine
              + "location1" + Environment.NewLine
              + "location2");

            engine.Verify();
        }

        [Fact]
        public void RenderPartialInternalWithNullModelAndNullViewData()
        {
            // Arrange
            object model = new object();
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            helper.ViewData["Foo"] = "Bar";
            helper.ViewData.Model = model;
            Mock<IViewEngine> engine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            engine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), "partial-view", It.IsAny<bool>()))
                .Returns(new ViewEngineResult(view.Object, engine.Object))
                .Verifiable();
            view
                .Setup(v => v.Render(It.IsAny<ViewContext>(), TextWriter.Null))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.NotSame(helper.ViewData, viewContext.ViewData); // New view data instance
                        Assert.Equal("Bar", viewContext.ViewData["Foo"]); // Copy of the existing view data
                        Assert.Same(model, viewContext.ViewData.Model); // Keep existing model
                    })
                .Verifiable();

            // Act
            helper.RenderPartialInternal("partial-view", null /* viewData */, null /* model */, TextWriter.Null, engine.Object);

            // Assert
            engine.Verify();
            view.Verify();
        }

        [Fact]
        public void RenderPartialInternalWithNonNullModelAndNullViewData()
        {
            // Arrange
            object model = new object();
            object newModel = new object();
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            helper.ViewData["Foo"] = "Bar";
            helper.ViewData.Model = model;
            Mock<IViewEngine> engine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            engine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), "partial-view", It.IsAny<bool>()))
                .Returns(new ViewEngineResult(view.Object, engine.Object))
                .Verifiable();
            view
                .Setup(v => v.Render(It.IsAny<ViewContext>(), TextWriter.Null))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.NotSame(helper.ViewData, viewContext.ViewData); // New view data instance
                        Assert.Empty(viewContext.ViewData); // Empty (not copied)
                        Assert.Same(newModel, viewContext.ViewData.Model); // New model
                    })
                .Verifiable();

            // Act
            helper.RenderPartialInternal("partial-view", null /* viewData */, newModel, TextWriter.Null, engine.Object);

            // Assert
            engine.Verify();
            view.Verify();
        }

        [Fact]
        public void RenderPartialInternalWithNullModelAndNonNullViewData()
        {
            // Arrange
            object model = new object();
            object vddModel = new object();
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["Baz"] = "Biff";
            vdd.Model = vddModel;
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            helper.ViewData["Foo"] = "Bar";
            helper.ViewData.Model = model;
            Mock<IViewEngine> engine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            engine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), "partial-view", It.IsAny<bool>()))
                .Returns(new ViewEngineResult(view.Object, engine.Object))
                .Verifiable();
            view
                .Setup(v => v.Render(It.IsAny<ViewContext>(), TextWriter.Null))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.NotSame(helper.ViewData, viewContext.ViewData); // New view data instance
                        Assert.Single(viewContext.ViewData); // Copy of the passed view data, not original view data
                        Assert.Equal("Biff", viewContext.ViewData["Baz"]);
                        Assert.Same(vddModel, viewContext.ViewData.Model); // Keep model from passed view data, not original view data
                    })
                .Verifiable();

            // Act
            helper.RenderPartialInternal("partial-view", vdd, null /* model */, TextWriter.Null, engine.Object);

            // Assert
            engine.Verify();
            view.Verify();
        }

        [Fact]
        public void RenderPartialInternalWithNonNullModelAndNonNullViewData()
        {
            // Arrange
            object model = new object();
            object vddModel = new object();
            object newModel = new object();
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["Baz"] = "Biff";
            vdd.Model = vddModel;
            TestableHtmlHelper helper = TestableHtmlHelper.Create();
            helper.ViewData["Foo"] = "Bar";
            helper.ViewData.Model = model;
            Mock<IViewEngine> engine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            engine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), "partial-view", It.IsAny<bool>()))
                .Returns(new ViewEngineResult(view.Object, engine.Object))
                .Verifiable();
            view
                .Setup(v => v.Render(It.IsAny<ViewContext>(), TextWriter.Null))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.NotSame(helper.ViewData, viewContext.ViewData); // New view data instance
                        Assert.Single(viewContext.ViewData); // Copy of the passed view data, not original view data
                        Assert.Equal("Biff", viewContext.ViewData["Baz"]);
                        Assert.Same(newModel, viewContext.ViewData.Model); // New model
                    })
                .Verifiable();

            // Act
            helper.RenderPartialInternal("partial-view", vdd, newModel, TextWriter.Null, engine.Object);

            // Assert
            engine.Verify();
            view.Verify();
        }

        // HttpMethodOverride

        [Fact]
        public void HttpMethodOverrideGuardClauses()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = MvcHelper.GetViewDataContainer(null);
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => htmlHelper.HttpMethodOverride(null),
                "httpMethod"
                );
            Assert.Throws<ArgumentException>(
                () => htmlHelper.HttpMethodOverride((HttpVerbs)10000),
                "The specified HttpVerbs value is not supported. The supported values are Delete, Head, Put, Options, and Patch." + Environment.NewLine
              + "Parameter name: httpVerb"
                );
            Assert.Throws<ArgumentException>(
                () => htmlHelper.HttpMethodOverride(HttpVerbs.Get),
                "The specified HttpVerbs value is not supported. The supported values are Delete, Head, Put, Options, and Patch." + Environment.NewLine
              + "Parameter name: httpVerb"
                );
            Assert.Throws<ArgumentException>(
                () => htmlHelper.HttpMethodOverride(HttpVerbs.Post),
                "The specified HttpVerbs value is not supported. The supported values are Delete, Head, Put, Options, and Patch." + Environment.NewLine
              + "Parameter name: httpVerb"
                );
            Assert.Throws<ArgumentException>(
                () => htmlHelper.HttpMethodOverride("gEt"),
                "The GET and POST HTTP methods are not supported." + Environment.NewLine
              + "Parameter name: httpMethod"
                );
            Assert.Throws<ArgumentException>(
                () => htmlHelper.HttpMethodOverride("pOsT"),
                "The GET and POST HTTP methods are not supported." + Environment.NewLine
              + "Parameter name: httpMethod"
                );
        }

        [Fact]
        public void HttpMethodOverrideWithMethodRendersHiddenField()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = MvcHelper.GetViewDataContainer(null);
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);

            // Act
            MvcHtmlString hiddenField = htmlHelper.HttpMethodOverride("PUT");

            // Assert
            Assert.Equal(@"<input name=""X-HTTP-Method-Override"" type=""hidden"" value=""PUT"" />", hiddenField.ToHtmlString());
        }

        [Fact]
        public void HttpMethodOverrideWithVerbRendersHiddenField()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = MvcHelper.GetViewDataContainer(null);
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);

            // Act
            MvcHtmlString hiddenField = htmlHelper.HttpMethodOverride(HttpVerbs.Delete);

            // Assert
            Assert.Equal(@"<input name=""X-HTTP-Method-Override"" type=""hidden"" value=""DELETE"" />", hiddenField.ToHtmlString());
        }

        [Fact]
        public void ViewBagProperty_ReflectsViewData()
        {
            // Arrange
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            // Act
            HtmlHelper htmlHelper = new HtmlHelper(new Mock<ViewContext>().Object, viewDataContainer.Object);

            // Assert
            Assert.Equal(1, htmlHelper.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_ReflectsNewViewDataContainerInstance()
        {
            // Arrange
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            ViewDataDictionary otherViewDataDictionary = new ViewDataDictionary() { { "A", 2 } };
            Mock<IViewDataContainer> otherViewDataContainer = new Mock<IViewDataContainer>();
            otherViewDataContainer.Setup(container => container.ViewData).Returns(otherViewDataDictionary);

            HtmlHelper htmlHelper = new HtmlHelper(new Mock<ViewContext>().Object, viewDataContainer.Object, new RouteCollection());

            // Act
            htmlHelper.ViewDataContainer = otherViewDataContainer.Object;

            // Assert
            Assert.Equal(2, htmlHelper.ViewBag.A);
        }

        [Fact]
        public void ViewBag_PropagatesChangesToViewData()
        {
            // Arrange
            ViewDataDictionary viewDataDictionary = new ViewDataDictionary() { { "A", 1 } };
            Mock<IViewDataContainer> viewDataContainer = new Mock<IViewDataContainer>();
            viewDataContainer.Setup(container => container.ViewData).Returns(viewDataDictionary);

            HtmlHelper htmlHelper = new HtmlHelper(new Mock<ViewContext>().Object, viewDataContainer.Object, new RouteCollection());

            // Act
            htmlHelper.ViewBag.A = "foo";
            htmlHelper.ViewBag.B = 2;

            // Assert
            Assert.Equal("foo", htmlHelper.ViewData["A"]);
            Assert.Equal(2, htmlHelper.ViewData["B"]);
        }

        // Unobtrusive validation attributes

        [Fact]
        public void GetUnobtrusiveValidationAttributesReturnsEmptySetWhenClientValidationIsNotEnabled()
        {
            // Arrange
            var formContext = new FormContext();
            formContext.RenderedField("foobar", true);
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesReturnsEmptySetWhenUnobtrusiveJavaScriptIsNotEnabled()
        {
            // Arrange
            var formContext = new FormContext();
            formContext.RenderedField("foobar", true);
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesReturnsEmptySetWhenFieldHasAlreadyBeenRendered()
        {
            // Arrange
            var formContext = new FormContext();
            formContext.RenderedField("foobar", true);
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesReturnsEmptySetAndSetsFieldAsRenderedForFieldWithNoClientRules()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate { return Enumerable.Empty<ModelClientValidationRule>(); };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Empty(result);
            Assert.True(formContext.RenderedField("foobar"));
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesIncludesDataValTrueWithNonEmptyClientRuleList()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate { return new[] { new ModelClientValidationRule { ValidationType = "type" } }; };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("true", result["data-val"]);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesWithEmptyMessage()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate { return new[] { new ModelClientValidationRule { ValidationType = "type" } }; };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("", result["data-val-type"]);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesMessageIsNotHtmlEncoded()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate { return new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "<script>alert('xss')</script>" } }; };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("<script>alert('xss')</script>", result["data-val-type"]);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesWithMessageAndParameters()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate
            {
                ModelClientValidationRule rule = new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" };
                rule.ValidationParameters["foo"] = "bar";
                rule.ValidationParameters["baz"] = "biff";
                return new[] { rule };
            };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("error", result["data-val-type"]);
            Assert.Equal("bar", result["data-val-type-foo"]);
            Assert.Equal("biff", result["data-val-type-baz"]);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesWithTwoClientRules()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate
            {
                ModelClientValidationRule rule1 = new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" };
                rule1.ValidationParameters["foo"] = "bar";
                rule1.ValidationParameters["baz"] = "biff";
                ModelClientValidationRule rule2 = new ModelClientValidationRule { ValidationType = "othertype", ErrorMessage = "othererror" };
                rule2.ValidationParameters["true3"] = "false4";
                return new[] { rule1, rule2 };
            };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("error", result["data-val-type"]);
            Assert.Equal("bar", result["data-val-type-foo"]);
            Assert.Equal("biff", result["data-val-type-baz"]);
            Assert.Equal("othererror", result["data-val-othertype"]);
            Assert.Equal("false4", result["data-val-othertype-true3"]);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesUsesShortNameForModelMetadataLookup()
        {
            // Arrange
            string passedName = null;
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            var viewData = new ViewDataDictionary();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var viewDataContainer = MvcHelper.GetViewDataContainer(viewData);
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = (name, _) =>
            {
                passedName = name;
                return Enumerable.Empty<ModelClientValidationRule>();
            };

            // Act
            htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("foobar", passedName);
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributeUsesViewDataForModelMetadataLookup()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            var viewData = new ViewDataDictionary<MyModel>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var viewDataContainer = MvcHelper.GetViewDataContainer(viewData);
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("MyProperty");

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("true", result["data-val"]);
            Assert.Equal("My required message", result["data-val-required"]);
        }

        class MyModel
        {
            [Required(ErrorMessage = "My required message")]
            public object MyProperty { get; set; }
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesMarksRenderedFieldsWithFullName()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            var viewData = new ViewDataDictionary();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var viewDataContainer = MvcHelper.GetViewDataContainer(viewData);
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.False(formContext.RenderedField("foobar"));
            Assert.True(formContext.RenderedField("Prefix.foobar"));
        }

        [Fact]
        public void GetUnobtrusiveValidationAttributesGuardClauses()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act & Assert
            AssertBadClientValidationRule(htmlHelper, "Validation type names in unobtrusive client validation rules cannot be empty. Client rule type: System.Web.Mvc.ModelClientValidationRule", new ModelClientValidationRule());
            AssertBadClientValidationRule(htmlHelper, "Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"OnlyLowerCase\", client rule type: System.Web.Mvc.ModelClientValidationRule", new ModelClientValidationRule { ValidationType = "OnlyLowerCase" });
            AssertBadClientValidationRule(htmlHelper, "Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"nonumb3rs\", client rule type: System.Web.Mvc.ModelClientValidationRule", new ModelClientValidationRule { ValidationType = "nonumb3rs" });
            AssertBadClientValidationRule(htmlHelper, "Validation type names in unobtrusive client validation rules must be unique. The following validation type was seen more than once: rule", new ModelClientValidationRule { ValidationType = "rule" }, new ModelClientValidationRule { ValidationType = "rule" });

            var emptyParamName = new ModelClientValidationRule { ValidationType = "type" };
            emptyParamName.ValidationParameters[""] = "foo";
            AssertBadClientValidationRule(htmlHelper, "Validation parameter names in unobtrusive client validation rules cannot be empty. Client rule type: System.Web.Mvc.ModelClientValidationRule", emptyParamName);

            var paramNameMixedCase = new ModelClientValidationRule { ValidationType = "type" };
            paramNameMixedCase.ValidationParameters["MixedCase"] = "foo";
            AssertBadClientValidationRule(htmlHelper, "Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: MixedCase, client rule type: System.Web.Mvc.ModelClientValidationRule", paramNameMixedCase);

            var paramNameStartsWithNumber = new ModelClientValidationRule { ValidationType = "type" };
            paramNameStartsWithNumber.ValidationParameters["2112"] = "foo";
            AssertBadClientValidationRule(htmlHelper, "Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: 2112, client rule type: System.Web.Mvc.ModelClientValidationRule", paramNameStartsWithNumber);
        }

        [Fact]
        public void RawReturnsWrapperMarkup()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);
            string markup = "<b>bold</b>";

            // Act
            IHtmlString markupHtml = htmlHelper.Raw(markup);

            // Assert
            Assert.Equal("<b>bold</b>", markupHtml.ToString());
            Assert.Equal("<b>bold</b>", markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawAllowsNullValue()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);

            // Act
            IHtmlString markupHtml = htmlHelper.Raw(null);

            // Assert
            Assert.Null(markupHtml.ToString());
            Assert.Null(markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawAllowsNullObjectValue()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);

            // Act
            IHtmlString markupHtml = htmlHelper.Raw((object)null);

            // Assert
            Assert.Null(markupHtml.ToString());
            Assert.Null(markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawAllowsEmptyValue()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);

            // Act
            IHtmlString markupHtml = htmlHelper.Raw("");

            // Assert
            Assert.Equal("", markupHtml.ToString());
            Assert.Equal("", markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawReturnsWrapperMarkupOfObject()
        {
            // Arrange
            var viewContext = new Mock<ViewContext>().Object;
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(viewContext, viewDataContainer);
            ObjectWithWrapperMarkup obj = new ObjectWithWrapperMarkup();

            // Act
            IHtmlString markupHtml = htmlHelper.Raw(obj);

            // Assert
            Assert.Equal("<b>boldFromObject</b>", markupHtml.ToString());
            Assert.Equal("<b>boldFromObject</b>", markupHtml.ToHtmlString());
        }

        [Fact]
        public void EvalStringAndFormatValueWithNullValueReturnsEmptyString()
        {
            // Arrange
            var htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary());

            // Act & Assert
            Assert.Equal(String.Empty, htmlHelper.FormatValue(null, "-{0}-"));
            Assert.Equal(String.Empty, htmlHelper.EvalString("nonExistant"));
            Assert.Equal(String.Empty, htmlHelper.EvalString("nonExistant", "-{0}-"));
        }

        [Fact]
        [ReplaceCulture]
        public void EvalStringAndFormatValueUseCurrentCulture()
        {
            // Arrange
            DateTime dt = new DateTime(1900, 1, 1, 0, 0, 0);
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary() { { "date", dt } });
            string expectedFormattedDate = "-01/01/1900 00:00:00-";

            // Act && Assert
            Assert.Equal(expectedFormattedDate, htmlHelper.FormatValue(dt, "-{0}-"));
            Assert.Equal(expectedFormattedDate, htmlHelper.EvalString("date", "-{0}-"));
        }

        [Fact]
        [ReplaceCulture]
        public void EvalStringAndFormatValueWithEmptyFormatConvertsValueToString()
        {
            // Arrange
            DateTime dt = new DateTime(1900, 1, 1, 0, 0, 0);
            HtmlHelper htmlHelper = MvcHelper.GetHtmlHelper(new ViewDataDictionary() { { "date", dt } });
            string expectedUnformattedDate = "01/01/1900 00:00:00";

            // Act && Assert
            Assert.Equal(expectedUnformattedDate, htmlHelper.FormatValue(dt, String.Empty));
            Assert.Equal(expectedUnformattedDate, htmlHelper.EvalString("date", String.Empty));
            Assert.Equal(expectedUnformattedDate, htmlHelper.EvalString("date"));
        }


        [Fact]
        public void ObjectToDictionaryWithAnonymousTypeLooksUpProperties()
        {
            // Arrange
            object obj = new { _test = "value", oth_er = 1 };

            // Act
            IDictionary<string, object> dictValues = HtmlHelper.ObjectToDictionary(obj);

            // Assert
            Assert.NotNull(dictValues);
            Assert.Equal(2, dictValues.Count);
            Assert.Equal("value", dictValues["_test"]);
            Assert.Equal(1, dictValues["oth_er"]);
        }

        // SetValidationSummaryMessageElement

        [Fact]
        public void SetValidationSummaryMessageElement()
        {
            // Arrange
            var mockViewContext = new Mock<ViewContext>();
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(mockViewContext.Object, viewDataContainer);

            // Act
            htmlHelper.SetValidationSummaryMessageElement("label");

            // Act & assert
            mockViewContext.VerifySet(vc => vc.ValidationSummaryMessageElement = "label");
        }

        [Fact]
        public void SetValidationMessageElement()
        {
            // Arrange
            var mockViewContext = new Mock<ViewContext>();
            var viewDataContainer = new Mock<IViewDataContainer>().Object;
            var htmlHelper = new HtmlHelper(mockViewContext.Object, viewDataContainer);

            // Act
            htmlHelper.SetValidationMessageElement("label");

            // Act & assert
            mockViewContext.VerifySet(vc => vc.ValidationMessageElement = "label");
        }

        private class ObjectWithWrapperMarkup
        {
            public override string ToString()
            {
                return "<b>boldFromObject</b>";
            }
        }

        // Helpers

        private static void AssertBadClientValidationRule(HtmlHelper htmlHelper, string expectedMessage, params ModelClientValidationRule[] rules)
        {
            htmlHelper.ClientValidationRuleFactory = delegate { return rules; };
            Assert.Throws<InvalidOperationException>(
                () => htmlHelper.GetUnobtrusiveValidationAttributes(Guid.NewGuid().ToString()),
                expectedMessage
                );
        }

        internal static ValueProviderResult GetValueProviderResult(object rawValue, string attemptedValue)
        {
            return new ValueProviderResult(rawValue, attemptedValue, CultureInfo.InvariantCulture);
        }

        private class TestableHtmlHelper : HtmlHelper
        {
            TestableHtmlHelper(ViewContext viewContext, IViewDataContainer viewDataContainer)
                : base(viewContext, viewDataContainer)
            {
            }

            public static TestableHtmlHelper Create()
            {
                ViewDataDictionary viewData = new ViewDataDictionary();

                Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
                mockViewContext.Setup(c => c.HttpContext.Response.Output).Throws(new Exception("Response.Output should never be called."));
                mockViewContext.SetupGet(c => c.TempData).Returns(new TempDataDictionary());
                mockViewContext.SetupGet(c => c.View).Returns(Mock.Of<IView>());
                mockViewContext.Setup(c => c.ViewData).Returns(viewData);
                mockViewContext.Setup(c => c.Writer).Returns(new StringWriter());

                Mock<IViewDataContainer> container = new Mock<IViewDataContainer>();
                container.Setup(c => c.ViewData).Returns(viewData);

                return new TestableHtmlHelper(mockViewContext.Object, container.Object);
            }

            public void RenderPartialInternal(string partialViewName,
                                              ViewDataDictionary viewData,
                                              object model,
                                              TextWriter writer,
                                              params IViewEngine[] engines)
            {
                base.RenderPartialInternal(partialViewName, viewData, model, writer, new ViewEngineCollection(engines));
            }
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. htmlHelper.SetValidationSummaryMessageElement()) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpDeleteAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpDeleteAttributeTest
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithInvalidVerb<HttpDeleteAttribute>("POST");
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithValidVerb<HttpDeleteAttribute>("DELETE");
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeNullControllerContext<HttpDeleteAttribute>();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpFileCollectionValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HttpFileCollectionValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            HttpFileCollectionValueProviderFactory factory = new HttpFileCollectionValueProviderFactory();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.Files.Count).Returns(0);

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.IsType<HttpFileCollectionValueProvider>(valueProvider);
        }

        [Fact]
        public void GetValueProvider_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            HttpFileCollectionValueProviderFactory factory = new HttpFileCollectionValueProviderFactory();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { factory.GetValueProvider(null); }, "controllerContext");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpFileCollectionValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HttpFileCollectionValueProviderTest
    {
        private static readonly KeyValuePair<string, HttpPostedFileBase>[] _allFiles = new KeyValuePair<string, HttpPostedFileBase>[]
        {
            new KeyValuePair<string, HttpPostedFileBase>("foo", new MockHttpPostedFile(42, "fooFile1")),
            new KeyValuePair<string, HttpPostedFileBase>("foo", null),
            new KeyValuePair<string, HttpPostedFileBase>("foo", new MockHttpPostedFile(0, "") /* empty */),
            new KeyValuePair<string, HttpPostedFileBase>("foo", new MockHttpPostedFile(100, "fooFile2")),
            new KeyValuePair<string, HttpPostedFileBase>("bar.baz", new MockHttpPostedFile(200, "barBazFile"))
        };

        [Fact]
        public void ContainsPrefix()
        {
            // Arrange
            HttpFileCollectionValueProvider valueProvider = GetValueProvider();

            // Act
            bool result = valueProvider.ContainsPrefix("bar");

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void ContainsPrefix_DoesNotContainEmptyPrefixIfBackingStoreIsEmpty()
        {
            // Arrange
            HttpFileCollectionValueProvider valueProvider = GetEmptyValueProvider();

            // Act
            bool result = valueProvider.ContainsPrefix("");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ContainsPrefix_ThrowsIfPrefixIsNull()
        {
            // Arrange
            HttpFileCollectionValueProvider valueProvider = GetValueProvider();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { valueProvider.ContainsPrefix(null); }, "prefix");
        }

        [Fact]
        public void GetValue()
        {
            // Arrange
            HttpFileCollectionValueProvider valueProvider = GetValueProvider();

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("foo");

            // Assert
            Assert.NotNull(vpResult);

            HttpPostedFileBase[] expectedRawValues = (from el in _allFiles
                                                      where el.Key == "foo"
                                                      let file = el.Value
                                                      let hasContent = (file != null && file.ContentLength > 0 && !String.IsNullOrEmpty(file.FileName))
                                                      select (hasContent) ? file : null).ToArray();
            Assert.Equal(expectedRawValues, (HttpPostedFileBase[])vpResult.RawValue);
            Assert.Equal("System.Web.HttpPostedFileBase[]", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValue_ReturnsNullIfKeyNotFound()
        {
            // Arrange
            HttpFileCollectionValueProvider valueProvider = GetValueProvider();

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("bar");

            // Assert
            Assert.Null(vpResult);
        }

        [Fact]
        public void GetValue_ThrowsIfKeyIsNull()
        {
            // Arrange
            HttpFileCollectionValueProvider valueProvider = GetValueProvider();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { valueProvider.GetValue(null); }, "key");
        }

        private static HttpFileCollectionValueProvider GetEmptyValueProvider()
        {
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.Files.Count).Returns(0);
            return new HttpFileCollectionValueProvider(mockControllerContext.Object);
        }

        private static HttpFileCollectionValueProvider GetValueProvider()
        {
            Mock<HttpFileCollectionBase> mockFileCollection = new Mock<HttpFileCollectionBase>();
            mockFileCollection.SetupGet(c => c.Count).Returns(_allFiles.Length);
            mockFileCollection.SetupGet(c => c.AllKeys).Returns(_allFiles.Select(f => f.Key).ToArray());
            for (int i = 0; i < _allFiles.Length; i++)
            {
                int j = i;
                mockFileCollection.SetupGet(c => c[j]).Returns(_allFiles[j].Value);
            }

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupGet(o => o.HttpContext.Request.Files).Returns(mockFileCollection.Object);

            return new HttpFileCollectionValueProvider(mockControllerContext.Object);
        }

        private sealed class MockHttpPostedFile : HttpPostedFileBase
        {
            private readonly int _contentLength;
            private readonly string _fileName;

            public MockHttpPostedFile(int contentLength, string fileName)
            {
                _contentLength = contentLength;
                _fileName = fileName;
            }

            public override int ContentLength
            {
                get { return _contentLength; }
            }

            public override string FileName
            {
                get { return _fileName; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpGetAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpGetAttributeTest
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithInvalidVerb<HttpGetAttribute>("DELETE");
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithValidVerb<HttpGetAttribute>("GET");
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeNullControllerContext<HttpGetAttribute>();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpHandlerUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Hosting;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HttpHandlerUtilTest
    {
        [Fact]
        public void WrapForServerExecute_BeginProcessRequest_DelegatesCorrectly()
        {
            // Arrange
            IAsyncResult expectedResult = new Mock<IAsyncResult>().Object;
            AsyncCallback cb = delegate { };

            HttpContext httpContext = GetHttpContext();
            Mock<IHttpAsyncHandler> mockHttpHandler = new Mock<IHttpAsyncHandler>();
            mockHttpHandler.Setup(o => o.BeginProcessRequest(httpContext, cb, "extraData")).Returns(expectedResult);

            IHttpAsyncHandler wrapper = (IHttpAsyncHandler)HttpHandlerUtil.WrapForServerExecute(mockHttpHandler.Object);

            // Act
            IAsyncResult actualResult = wrapper.BeginProcessRequest(httpContext, cb, "extraData");

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }

        [Fact]
        public void WrapForServerExecute_EndProcessRequest_DelegatesCorrectly()
        {
            // Arrange
            IAsyncResult asyncResult = new Mock<IAsyncResult>().Object;

            HttpContext httpContext = GetHttpContext();
            Mock<IHttpAsyncHandler> mockHttpHandler = new Mock<IHttpAsyncHandler>();
            mockHttpHandler.Setup(o => o.EndProcessRequest(asyncResult)).Verifiable();

            IHttpAsyncHandler wrapper = (IHttpAsyncHandler)HttpHandlerUtil.WrapForServerExecute(mockHttpHandler.Object);

            // Act
            wrapper.EndProcessRequest(asyncResult);

            // Assert
            mockHttpHandler.Verify();
        }

        [Fact]
        public void WrapForServerExecute_ProcessRequest_DelegatesCorrectly()
        {
            // Arrange
            HttpContext httpContext = GetHttpContext();
            Mock<IHttpHandler> mockHttpHandler = new Mock<IHttpHandler>();
            mockHttpHandler.Setup(o => o.ProcessRequest(httpContext)).Verifiable();

            IHttpHandler wrapper = HttpHandlerUtil.WrapForServerExecute(mockHttpHandler.Object);

            // Act
            wrapper.ProcessRequest(httpContext);

            // Assert
            mockHttpHandler.Verify();
        }

        [Fact]
        public void WrapForServerExecute_ProcessRequest_PropagatesExceptionsIfNotHttpException()
        {
            // Arrange
            HttpContext httpContext = GetHttpContext();
            Mock<IHttpHandler> mockHttpHandler = new Mock<IHttpHandler>();
            mockHttpHandler.Setup(o => o.ProcessRequest(httpContext)).Throws(new InvalidOperationException("Some exception."));

            IHttpHandler wrapper = HttpHandlerUtil.WrapForServerExecute(mockHttpHandler.Object);

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { wrapper.ProcessRequest(httpContext); },
                @"Some exception.");
        }

        [Fact]
        public void WrapForServerExecute_ProcessRequest_PropagatesHttpExceptionIfStatusCode500()
        {
            // Arrange
            HttpContext httpContext = GetHttpContext();
            Mock<IHttpHandler> mockHttpHandler = new Mock<IHttpHandler>();
            mockHttpHandler.Setup(o => o.ProcessRequest(httpContext)).Throws(new HttpException(500, "Some exception."));

            IHttpHandler wrapper = HttpHandlerUtil.WrapForServerExecute(mockHttpHandler.Object);

            // Act & assert
            Assert.ThrowsHttpException(
                delegate { wrapper.ProcessRequest(httpContext); },
                @"Some exception.",
                500);
        }

        [Fact]
        public void WrapForServerExecute_ProcessRequest_WrapsHttpExceptionIfStatusCodeNot500()
        {
            // Arrange
            HttpContext httpContext = GetHttpContext();
            Mock<IHttpHandler> mockHttpHandler = new Mock<IHttpHandler>();
            mockHttpHandler.Setup(o => o.ProcessRequest(httpContext)).Throws(new HttpException(404, "Some exception."));

            IHttpHandler wrapper = HttpHandlerUtil.WrapForServerExecute(mockHttpHandler.Object);

            // Act & assert
            HttpException outerException = Assert.ThrowsHttpException(
                delegate { wrapper.ProcessRequest(httpContext); },
                @"Execution of the child request failed. Please examine the InnerException for more information.",
                500);

            HttpException innerException = outerException.InnerException as HttpException;
            Assert.NotNull(innerException);
            Assert.Equal(404, innerException.GetHttpCode());
            Assert.Equal("Some exception.", innerException.Message);
        }

        [Fact]
        public void WrapForServerExecute_ReturnsIHttpAsyncHandler()
        {
            // Arrange
            IHttpAsyncHandler httpHandler = new Mock<IHttpAsyncHandler>().Object;

            // Act
            IHttpHandler wrapper = HttpHandlerUtil.WrapForServerExecute(httpHandler);

            // Assert
            Assert.True(wrapper is IHttpAsyncHandler);
        }

        [Fact]
        public void WrapForServerExecute_ReturnsIHttpHandler()
        {
            // Arrange
            IHttpHandler httpHandler = new Mock<IHttpHandler>().Object;

            // Act
            IHttpHandler wrapper = HttpHandlerUtil.WrapForServerExecute(httpHandler);

            // Assert
            Assert.False(wrapper is IHttpAsyncHandler);
        }

        private static HttpContext GetHttpContext()
        {
            return new HttpContext(new SimpleWorkerRequest("/", "/", "Page", "Query", TextWriter.Null));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpHeadAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpHeadAttributeTest
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotHead()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithInvalidVerb<HttpHeadAttribute>("GET");
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsHead()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithValidVerb<HttpHeadAttribute>("HEAD");
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeNullControllerContext<HttpHeadAttribute>();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpNotFoundResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HttpNotFoundResultTest
    {
        [Fact]
        public void ExecuteResult()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 404).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusDescription = "Some description").Verifiable();

            HttpNotFoundResult result = new HttpNotFoundResult("Some description");

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void StatusCode()
        {
            Assert.Equal(404, new HttpNotFoundResult().StatusCode);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpOptionsAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpOptionsAttributeTest
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotOptions()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithInvalidVerb<HttpOptionsAttribute>("GET");
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsOptions()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithValidVerb<HttpOptionsAttribute>("OPTIONS");
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeNullControllerContext<HttpOptionsAttribute>();
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Test/HttpPatchAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test {
    public class HttpPatchAttributeTest 
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotPatch() 
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithInvalidVerb<HttpPatchAttribute>("GET");
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsPatch() 
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithValidVerb<HttpPatchAttribute>("PATCH");
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeNullControllerContext<HttpPatchAttribute>();
        }
    }
}

================================================
FILE: test/System.Web.Mvc.Test/Test/HttpPostAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpPostAttributeTest
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithInvalidVerb<HttpPostAttribute>("DELETE");
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithValidVerb<HttpPostAttribute>("POST");
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeNullControllerContext<HttpPostAttribute>();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpPostedFileBaseModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HttpPostedFileBaseModelBinderTest
    {
        [Fact]
        public void BindModelReturnsEmptyResultIfEmptyFileInputElementInPost()
        {
            // Arrange
            Mock<HttpPostedFileBase> mockFile = new Mock<HttpPostedFileBase>();
            mockFile.Setup(f => f.ContentLength).Returns(0);
            mockFile.Setup(f => f.FileName).Returns(String.Empty);
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupGet(c => c.HttpContext.Request.Files["fileName"]).Returns(mockFile.Object);

            HttpPostedFileBaseModelBinder binder = new HttpPostedFileBaseModelBinder();
            ModelBindingContext bindingContext = new ModelBindingContext() { ModelName = "fileName" };

            // Act
            object result = binder.BindModel(mockControllerContext.Object, bindingContext);

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public void BindModelReturnsNullIfNoFileInputElementInPost()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.Files["fileName"]).Returns((HttpPostedFileBase)null);

            HttpPostedFileBaseModelBinder binder = new HttpPostedFileBaseModelBinder();
            ModelBindingContext bindingContext = new ModelBindingContext() { ModelName = "fileName" };

            // Act
            object result = binder.BindModel(mockControllerContext.Object, bindingContext);

            // Assert
            Assert.Null(result);
        }

        [Fact]
        public void BindModelReturnsResultIfFileFound()
        {
            // Arrange
            Mock<HttpPostedFileBase> mockFile = new Mock<HttpPostedFileBase>();
            mockFile.Setup(f => f.ContentLength).Returns(1234);
            mockFile.Setup(f => f.FileName).Returns("somefile");
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupGet(c => c.HttpContext.Request.Files["fileName"]).Returns(mockFile.Object);

            HttpPostedFileBaseModelBinder binder = new HttpPostedFileBaseModelBinder();
            ModelBindingContext bindingContext = new ModelBindingContext() { ModelName = "fileName" };

            // Act
            object result = binder.BindModel(mockControllerContext.Object, bindingContext);

            // Assert
            Assert.NotNull(result);
            Assert.Same(mockFile.Object, result);
        }

        [Fact]
        public void BindModelThrowsIfBindingContextIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            HttpPostedFileBaseModelBinder binder = new HttpPostedFileBaseModelBinder();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { binder.BindModel(controllerContext, null); }, "bindingContext");
        }

        [Fact]
        public void BindModelThrowsIfControllerContextIsNull()
        {
            // Arrange
            HttpPostedFileBaseModelBinder binder = new HttpPostedFileBaseModelBinder();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { binder.BindModel(null, null); }, "controllerContext");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpPutAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpPutAttributeTest
    {
        [Fact]
        public void IsValidForRequestReturnsFalseIfHttpVerbIsNotPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithInvalidVerb<HttpPutAttribute>("GET");
        }

        [Fact]
        public void IsValidForRequestReturnsTrueIfHttpVerbIsPost()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeWithValidVerb<HttpPutAttribute>("PUT");
        }

        [Fact]
        public void IsValidForRequestThrowsIfControllerContextIsNull()
        {
            HttpVerbAttributeHelper.TestHttpVerbAttributeNullControllerContext<HttpPutAttribute>();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpRequestExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpRequestExtensionsTest
    {
        [Fact]
        public void GetHttpMethodOverrideWithNullRequestThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => HttpRequestExtensions.GetHttpMethodOverride(null),
                "request"
                );
        }

        [Theory]
        [InlineData("GET", "PUT", null, null, "GET")] // Cannot override GET with header PUT
        [InlineData("GET", null, "PUT", null, "GET")] // Cannot override GET with form PUT
        [InlineData("GET", null, null, "PUT", "GET")] // Cannot override GET with query string PUT
        [InlineData("PUT", "GET", null, null, "PUT")] // Cannot override PUT with GET
        [InlineData("PUT", "POST", null, null, "PUT")] // Cannot override PUT with POST
        [InlineData("POST", "GET", null, null, "POST")] // Cannot override POST with GET
        [InlineData("POST", "POST", null, null, "POST")] // Cannot override POST with POST
        [InlineData("POST", "PUT", null, null, "PUT")] // Can override POST with header PUT
        [InlineData("POST", null, "PUT", null, "PUT")] // Can override POST with form PUT
        [InlineData("POST", null, null, "PUT", "PUT")] // Can override POST with query string PUT
        [InlineData("POST", "PUT", "BOGUS", null, "PUT")] // Header override wins over form override
        [InlineData("POST", "PUT", null, "BOGUS", "PUT")] // Header override wins over query string override
        [InlineData("POST", null, "PUT", "BOGUS", "PUT")] // Form override wins over query string override
        public void TestHttpMethodOverride(string httpRequestVerb,
                                           string httpHeaderVerb,
                                           string httpFormVerb,
                                           string httpQueryStringVerb,
                                           string expectedMethod)
        {
            // Arrange
            ControllerContext context = AcceptVerbsAttributeTest.GetControllerContextWithHttpVerb(httpRequestVerb, httpHeaderVerb, httpFormVerb, httpQueryStringVerb);

            // Act
            string methodOverride = context.RequestContext.HttpContext.Request.GetHttpMethodOverride();

            // Assert
            Assert.Equal(expectedMethod, methodOverride);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpStatusCodeResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HttpStatusCodeResultTest
    {
        [Fact]
        public void ExecuteResult()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 666).Verifiable();

            HttpStatusCodeResult result = new HttpStatusCodeResult(666);

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultWithDescription()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 666).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusDescription = "Foo Bar").Verifiable();
            HttpStatusCodeResult result = new HttpStatusCodeResult(666, "Foo Bar");

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultWithNullContextThrows()
        {
            // Act and Assert
            Assert.ThrowsArgumentNull(delegate { new HttpStatusCodeResult(1).ExecuteResult(context: null); }, "context");
        }

        [Fact]
        public void StatusCode()
        {
            // Assert
            Assert.Equal(123, new HttpStatusCodeResult(123).StatusCode);
            Assert.Equal(234, new HttpStatusCodeResult(234, "foobar").StatusCode);
        }

        [Fact]
        public void StatusDescription()
        {
            // Assert
            Assert.Null(new HttpStatusCodeResult(123).StatusDescription);
            Assert.Equal("foobar", new HttpStatusCodeResult(234, "foobar").StatusDescription);
        }

        [Fact]
        public void HttpStatusCodeAndStatusDescription()
        {
            // Arrange
            int unusedStatusCode = 306;

            // Act
            HttpStatusCodeResult result = new HttpStatusCodeResult(HttpStatusCode.Unused, "foobar");

            // Assert
            Assert.Equal(unusedStatusCode, result.StatusCode);
            Assert.Equal("foobar", result.StatusDescription);
        }

        [Fact]
        public void ExecuteResultWithHttpStatusCode()
        {
            // Arrange
            int unusedStatusCode = 306;
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = unusedStatusCode).Verifiable();

            HttpStatusCodeResult result = new HttpStatusCodeResult(HttpStatusCode.Unused);

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpUnauthorizedResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class HttpUnauthorizedResultTest
    {
        [Fact]
        public void ExecuteResult()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusCode = 401).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.StatusDescription = "Some description").Verifiable();

            HttpUnauthorizedResult result = new HttpUnauthorizedResult("Some description");

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void StatusCode()
        {
            Assert.Equal(401, new HttpUnauthorizedResult().StatusCode);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/HttpVerbAttributeHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    internal static class HttpVerbAttributeHelper
    {
        internal static void TestHttpVerbAttributeNullControllerContext<THttpVerb>()
            where THttpVerb : ActionMethodSelectorAttribute, new()
        {
            // Arrange
            ActionMethodSelectorAttribute attribute = new THttpVerb();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { attribute.IsValidForRequest(null, null); }, "controllerContext");
        }

        internal static void TestHttpVerbAttributeWithValidVerb<THttpVerb>(string validVerb)
            where THttpVerb : ActionMethodSelectorAttribute, new()
        {
            // Arrange
            ActionMethodSelectorAttribute attribute = new THttpVerb();
            ControllerContext context = AcceptVerbsAttributeTest.GetControllerContextWithHttpVerb(validVerb);

            // Act
            bool result = attribute.IsValidForRequest(context, null);

            // Assert
            Assert.True(result);
        }

        internal static void TestHttpVerbAttributeWithInvalidVerb<THttpVerb>(string invalidVerb)
            where THttpVerb : ActionMethodSelectorAttribute, new()
        {
            // Arrange
            ActionMethodSelectorAttribute attribute = new THttpVerb();
            ControllerContext context = AcceptVerbsAttributeTest.GetControllerContextWithHttpVerb(invalidVerb);

            // Act
            bool result = attribute.IsValidForRequest(context, null);

            // Assert
            Assert.False(result);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/JQueryFormValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class JQueryFormValueProviderFactoryTest
    {
        private static readonly NameValueCollection _backingStore = new NameValueCollection()
        {
            { "foo", "fooValue" },
            { "fooArray[0][bar1]", "fooArrayValue"}
        };

        private static readonly NameValueCollection _unvalidatedBackingStore = new NameValueCollection()
        {
            { "foo", "fooUnvalidated" },
            { "fooArray[0][bar1][0][nested]", "fooNestedUnvalidatedValue" }
        };

        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            Mock<MockableUnvalidatedRequestValues> mockUnvalidatedValues = new Mock<MockableUnvalidatedRequestValues>();
            JQueryFormValueProviderFactory factory = 
                        new JQueryFormValueProviderFactory(_ => mockUnvalidatedValues.Object);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.Form).Returns(_backingStore);

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Equal(typeof(JQueryFormValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("fooArray[0].bar1");

            Assert.NotNull(vpResult);
            Assert.Equal("fooArrayValue", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProvider_GetValue_SkipValidation()
        {
            // Arrange
            Mock<MockableUnvalidatedRequestValues> mockUnvalidatedValues = new Mock<MockableUnvalidatedRequestValues>();
            mockUnvalidatedValues.Setup(o => o.Form).Returns(_unvalidatedBackingStore);
            JQueryFormValueProviderFactory factory = 
                        new JQueryFormValueProviderFactory(_ => mockUnvalidatedValues.Object);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.Form).Returns(_backingStore);

            // Act
            IUnvalidatedValueProvider valueProvider = 
                        (IUnvalidatedValueProvider)factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Equal(typeof(JQueryFormValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("fooArray[0].bar1[0].nested", skipValidation: true);

            Assert.NotNull(vpResult);
            Assert.Equal("fooNestedUnvalidatedValue", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProvider_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            JQueryFormValueProviderFactory factory = new JQueryFormValueProviderFactory();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { factory.GetValueProvider(null); }, "controllerContext");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/JavaScriptResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class JavaScriptResultTest
    {
        [Fact]
        public void AllPropertiesDefaultToNull()
        {
            // Act
            JavaScriptResult result = new JavaScriptResult();

            // Assert
            Assert.Null(result.Script);
        }

        [Fact]
        public void ExecuteResult()
        {
            // Arrange
            string script = "alert('foo');";
            string contentType = "application/x-javascript";

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(script)).Verifiable();

            JavaScriptResult result = new JavaScriptResult
            {
                Script = script
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultWithNullContextThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { new JavaScriptResult().ExecuteResult(null /* context */); }, "context");
        }

        [Fact]
        public void NullScriptIsNotOutput()
        {
            // Arrange
            string contentType = "application/x-javascript";

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();

            JavaScriptResult result = new JavaScriptResult();

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/JsonResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class JsonResultTest
    {
        private static readonly object _jsonData = new object[] { 1, 2, "three", "four" };
        private static readonly string _jsonSerializedData = "[1,2,\"three\",\"four\"]";

        [Fact]
        public void PropertyDefaults()
        {
            // Act
            JsonResult result = new JsonResult();

            // Assert
            Assert.Null(result.Data);
            Assert.Null(result.ContentEncoding);
            Assert.Null(result.ContentType);
            Assert.Null(result.MaxJsonLength);
            Assert.Null(result.RecursionLimit);
            Assert.Equal(JsonRequestBehavior.DenyGet, result.JsonRequestBehavior);
        }

        [Fact]
        public void EmptyContentTypeRendersDefault()
        {
            // Arrange
            object data = _jsonData;
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/json").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(_jsonSerializedData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data,
                ContentType = String.Empty,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResult()
        {
            // Arrange
            object data = _jsonData;
            string contentType = "Some content type.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(_jsonSerializedData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data,
                ContentType = contentType,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultWithNullContextThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { new JsonResult().ExecuteResult(null /* context */); }, "context");
        }

        [Fact]
        public void NullContentIsNotOutput()
        {
            // Arrange
            string contentType = "Some content type.";
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();

            // Though most other tests run fine with SetupSet(c => c.HttpContext.Response.ContentType = ...), this
            // one does not. Explicitly ensure Response property is not null.
            var response = new Mock<HttpResponseBase>(MockBehavior.Strict);
            response.SetupSet(r => r.ContentType = contentType).Verifiable();
            response.SetupSet(r => r.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.SetupGet(c => c.HttpContext.Response).Returns(response.Object);

            JsonResult result = new JsonResult
            {
                ContentType = contentType,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
            response.Verify();
        }

        [Fact]
        public void NullContentEncodingIsNotOutput()
        {
            // Arrange
            object data = _jsonData;
            string contentType = "Some content type.";

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = contentType).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(_jsonSerializedData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data,
                ContentType = contentType,
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void NullContentTypeRendersDefault()
        {
            // Arrange
            object data = _jsonData;
            Encoding contentEncoding = Encoding.UTF8;

            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/json").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentEncoding = contentEncoding).Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(_jsonSerializedData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data,
                ContentEncoding = contentEncoding
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void NullMaxJsonLengthDefaultIsUsed()
        {
            // Arrange
            string data = new String('1', 2100000);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST");

            // Though most other tests run fine with SetupSet(c => c.HttpContext.Response.ContentType = ...), this
            // one does not. Explicitly ensure Response property is not null.
            var response = new Mock<HttpResponseBase>(MockBehavior.Strict);
            response.SetupSet(r => r.ContentType = "application/json");
            mockControllerContext.SetupGet(c => c.HttpContext.Response).Returns(response.Object);

            JsonResult result = new JsonResult
            {
                Data = data
            };

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => result.ExecuteResult(mockControllerContext.Object),
                "Error during serialization or deserialization using the JSON JavaScriptSerializer. The length of the string exceeds the value set on the maxJsonLength property.");
        }

        [Fact]
        public void MaxJsonLengthIsPassedToSerializer()
        {
            // Arrange
            string data = new String('1', 2100000);
            string jsonData = "\"" + data + "\"";

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/json").Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(jsonData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data,
                MaxJsonLength = 2200000
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void RecursionLimitIsPassedToSerilizer()
        {
            // Arrange
            Tuple<string, Tuple<string, Tuple<string, string>>> data =
                new Tuple<string, Tuple<string, Tuple<string, string>>>("key1",
                                                                        new Tuple<string, Tuple<string, string>>("key2",
                                                                                                                 new Tuple<string, string>("key3", "value")
                                                                            )
                    );
            string jsonData = "{\"Item1\":\"key1\",\"Item2\":{\"Item1\":\"key2\",\"Item2\":{\"Item1\":\"key3\",\"Item2\":\"value\"}}}";

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/json").Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(jsonData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data,
                RecursionLimit = 2
            };

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => result.ExecuteResult(mockControllerContext.Object),
                "RecursionLimit exceeded.");
        }

        [Fact]
        public void NullRecursionLimitDefaultIsUsed()
        {
            // Arrange
            Tuple<string, Tuple<string, Tuple<string, string>>> data =
                new Tuple<string, Tuple<string, Tuple<string, string>>>("key1",
                                                                        new Tuple<string, Tuple<string, string>>("key2",
                                                                                                                 new Tuple<string, string>("key3", "value")
                                                                            )
                    );
            string jsonData = "{\"Item1\":\"key1\",\"Item2\":{\"Item1\":\"key2\",\"Item2\":{\"Item1\":\"key3\",\"Item2\":\"value\"}}}";

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("POST").Verifiable();
            mockControllerContext.SetupSet(c => c.HttpContext.Response.ContentType = "application/json").Verifiable();
            mockControllerContext.Setup(c => c.HttpContext.Response.Write(jsonData)).Verifiable();

            JsonResult result = new JsonResult
            {
                Data = data
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void GetRequestBlocked()
        {
            // Arrange expectations
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.SetupGet(c => c.HttpContext.Request.HttpMethod).Returns("GET").Verifiable();

            JsonResult result = new JsonResult();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => result.ExecuteResult(mockControllerContext.Object),
                "This request has been blocked because sensitive information could be disclosed to third party web sites when this is used in a GET request. To allow GET requests, set JsonRequestBehavior to AllowGet.");

            mockControllerContext.Verify();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/JsonValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.IO;
using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class JsonValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProvider_NullControllerContext_ThrowsException()
        {
            JsonValueProviderFactory factory = new JsonValueProviderFactory();

            Assert.ThrowsArgumentNull(delegate() { factory.GetValueProvider(controllerContext: null); }, "controllerContext");
        }

        [Fact]
        public void GetValueProvider_SimpleArrayJsonObject()
        {
            const string jsonString = @"
[ ""abc"", null, ""foobar"" ]
";
            ControllerContext cc = GetJsonEnabledControllerContext(jsonString);
            JsonValueProviderFactory factory = new JsonValueProviderFactory();

            // Act & assert
            IValueProvider valueProvider = factory.GetValueProvider(cc);
            Assert.True(valueProvider.ContainsPrefix("[0]"));
            Assert.True(valueProvider.ContainsPrefix("[2]"));
            Assert.False(valueProvider.ContainsPrefix("[3]"));

            ValueProviderResult vpResult1 = valueProvider.GetValue("[0]");
            Assert.Equal("abc", vpResult1.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult1.Culture);

            // null values should exist in the backing store as actual entries
            ValueProviderResult vpResult2 = valueProvider.GetValue("[1]");
            Assert.NotNull(vpResult2);
            Assert.Null(vpResult2.RawValue);
        }

        [Fact]
        public void GetValueProvider_SimpleDictionaryJsonObject()
        {
            const string jsonString = @"
{   ""FirstName"":""John"",
    ""LastName"": ""Doe""
}";

            ControllerContext cc = GetJsonEnabledControllerContext(jsonString);
            JsonValueProviderFactory factory = new JsonValueProviderFactory();

            // Act & assert
            IValueProvider valueProvider = factory.GetValueProvider(cc);
            Assert.True(valueProvider.ContainsPrefix("firstname"));

            ValueProviderResult vpResult1 = valueProvider.GetValue("firstname");
            Assert.Equal("John", vpResult1.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult1.Culture);
        }

        [Fact]
        public void GetValueProvider_ComplexJsonObject()
        {
            // Arrange
            const string jsonString = @"
[
  { 
    ""BillingAddress"": {
      ""Street"": ""1 Microsoft Way"",
      ""City"": ""Redmond"",
      ""State"": ""WA"",
      ""ZIP"": 98052 },
    ""ShippingAddress"": { 
      ""Street"": ""123 Anywhere Ln"",
      ""City"": ""Anytown"",
      ""State"": ""ZZ"",
      ""ZIP"": 99999 }
  },
  { 
    ""Enchiladas"": [ ""Delicious"", ""Nutritious""]
  }
]
";

            ControllerContext cc = GetJsonEnabledControllerContext(jsonString);
            JsonValueProviderFactory factory = new JsonValueProviderFactory();

            // Act & assert
            IValueProvider valueProvider = factory.GetValueProvider(cc);
            Assert.NotNull(valueProvider);

            Assert.True(valueProvider.ContainsPrefix("[0].billingaddress"));
            Assert.Null(valueProvider.GetValue("[0].billingaddress"));

            Assert.True(valueProvider.ContainsPrefix("[0].billingaddress.street"));
            Assert.NotNull(valueProvider.GetValue("[0].billingaddress.street"));

            ValueProviderResult vpResult1 = valueProvider.GetValue("[1].enchiladas[0]");
            Assert.NotNull(vpResult1);
            Assert.Equal("Delicious", vpResult1.AttemptedValue);
            Assert.Equal(CultureInfo.CurrentCulture, vpResult1.Culture);
        }

        [Fact]
        public void GetValueProvider_NoJsonBody_ReturnsNull()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.ContentType).Returns("application/json");
            mockControllerContext.Setup(o => o.HttpContext.Request.InputStream).Returns(new MemoryStream());

            JsonValueProviderFactory factory = new JsonValueProviderFactory();

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Null(valueProvider);
        }

        [Fact]
        public void GetValueProvider_NotJsonRequest_ReturnsNull()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.ContentType).Returns("not JSON");

            JsonValueProviderFactory factory = new JsonValueProviderFactory();

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Null(valueProvider);
        }

        private static ControllerContext GetJsonEnabledControllerContext(string jsonString)
        {
            byte[] jsonBytes = Encoding.UTF8.GetBytes(jsonString);
            MemoryStream jsonStream = new MemoryStream(jsonBytes);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.ContentType).Returns("application/json");
            mockControllerContext.Setup(o => o.HttpContext.Request.InputStream).Returns(jsonStream);
            return mockControllerContext.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/LinqBinaryModelBinderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Data.Linq;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Test
{
    public class LinqBinaryModelBinderTest
    {
        [Fact]
        public void BindModelWithNonExistentValueReturnsNull()
        {
            // Arrange
            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", null }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            LinqBinaryModelBinder binder = new LinqBinaryModelBinder();

            // Act
            object binderResult = binder.BindModel(null, bindingContext);

            // Assert
            Assert.Null(binderResult);
        }

        [Fact]
        public void BinderWithEmptyStringValueReturnsNull()
        {
            // Arrange
            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", "" }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            LinqBinaryModelBinder binder = new LinqBinaryModelBinder();

            // Act
            object binderResult = binder.BindModel(null, bindingContext);

            // Assert
            Assert.Null(binderResult);
        }

        [Fact]
        public void BindModelThrowsIfBindingContextIsNull()
        {
            // Arrange
            LinqBinaryModelBinder binder = new LinqBinaryModelBinder();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { binder.BindModel(null, null); }, "bindingContext");
        }

        [Fact]
        public void BindModelWithBase64QuotedValueReturnsBinary()
        {
            // Arrange
            string base64Value = ByteArrayModelBinderTest.Base64TestString;

            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", "\"" + base64Value + "\"" }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            LinqBinaryModelBinder binder = new LinqBinaryModelBinder();

            // Act
            Binary boundValue = binder.BindModel(null, bindingContext) as Binary;

            // Assert
            Assert.Equal(ByteArrayModelBinderTest.Base64TestBytes, boundValue);
        }

        [Fact]
        public void BindModelWithBase64UnquotedValueReturnsBinary()
        {
            // Arrange
            string base64Value = ByteArrayModelBinderTest.Base64TestString;
            SimpleValueProvider valueProvider = new SimpleValueProvider()
            {
                { "foo", base64Value }
            };

            ModelBindingContext bindingContext = new ModelBindingContext()
            {
                ModelName = "foo",
                ValueProvider = valueProvider
            };

            LinqBinaryModelBinder binder = new LinqBinaryModelBinder();

            // Act
            Binary boundValue = binder.BindModel(null, bindingContext) as Binary;

            // Assert
            Assert.Equal(ByteArrayModelBinderTest.Base64TestBytes, boundValue);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MaxLengthAttributeAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class MaxLengthAttributeAdapterTest
    {
        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithMaxLengthAttribute()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length");
            var context = new ControllerContext();
            var attribute = new MaxLengthAttribute(10);
            var adapter = new MaxLengthAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("maxlength", rule.ValidationType);
            Assert.Equal(1, rule.ValidationParameters.Count);
            Assert.Equal(10, rule.ValidationParameters["max"]);
            Assert.Equal("The field Length must be a string or array type with a maximum length of '10'.", rule.ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithMaxLengthAttributeAndCustomMessage()
        {
            // Arrange
            string propertyName = "Length";
            string message = "{0} must be at most {1}";
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string[]), propertyName);
            var context = new ControllerContext();
            var attribute = new MaxLengthAttribute(5) { ErrorMessage = message };
            var adapter = new MaxLengthAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("maxlength", rule.ValidationType);
            Assert.Equal(1, rule.ValidationParameters.Count);
            Assert.Equal(5, rule.ValidationParameters["max"]);
            Assert.Equal("Length must be at most 5", rule.ErrorMessage);
        }


    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MinLengthAttributeAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class MinLengthAttributeAdapterTest
    {
        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithMinLengthAttribute()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length");
            var context = new ControllerContext();
            var attribute = new MinLengthAttribute(6);
            var adapter = new MinLengthAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("minlength", rule.ValidationType);
            Assert.Equal(1, rule.ValidationParameters.Count);
            Assert.Equal(6, rule.ValidationParameters["min"]);
            Assert.Equal("The field Length must be a string or array type with a minimum length of '6'.", rule.ErrorMessage);
        }

        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithMinLengthAttributeAndCustomMessage()
        {
            // Arrange
            string propertyName = "Length";
            string message = "Array must have at least {1} items.";
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(int[]), propertyName);
            var context = new ControllerContext();
            var attribute = new MinLengthAttribute(2) { ErrorMessage = message };
            var adapter = new MinLengthAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("minlength", rule.ValidationType);
            Assert.Equal(1, rule.ValidationParameters.Count);
            Assert.Equal(2, rule.ValidationParameters["min"]);
            Assert.Equal("Array must have at least 2 items.", rule.ErrorMessage);
        }


    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MockBuildManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Reflection;

namespace System.Web.Mvc.Test
{
    // Custom mock IBuildManager since the mock framework doesn't support mocking internal types
    public class MockBuildManager : IBuildManager
    {
        private Assembly[] _referencedAssemblies;

        private Type _compiledType;
        private string _expectedVirtualPath;
        private bool _fileExists = true;

        public readonly Dictionary<string, Stream> CachedFileStore = new Dictionary<string, Stream>(StringComparer.OrdinalIgnoreCase);

        public MockBuildManager()
            : this(new Assembly[] { typeof(MockBuildManager).Assembly })
        {
        }

        public MockBuildManager(Assembly[] referencedAssemblies)
        {
            _referencedAssemblies = referencedAssemblies;
        }

        public MockBuildManager(string expectedVirtualPath, bool fileExists)
        {
            _expectedVirtualPath = expectedVirtualPath;
            _fileExists = fileExists;
        }

        public MockBuildManager(string expectedVirtualPath, Type compiledType)
        {
            _expectedVirtualPath = expectedVirtualPath;
            _compiledType = compiledType;
        }

        public virtual bool FileExists(string virtualPath)
        {
            if (_expectedVirtualPath == virtualPath)
            {
                return _fileExists;
            }

            throw new InvalidOperationException("Unexpected call to IBuildManager.FileExists()");
        }

        public Type GetCompiledType(string virtualPath)
        {
            if (_expectedVirtualPath == virtualPath)
            {
                return _compiledType;
            }

            throw new InvalidOperationException("Unexpected call to IBuildManager.GetCompiledType()");
        }

        public virtual ICollection GetReferencedAssemblies()
        {
            return _referencedAssemblies;
        }

        public virtual Stream ReadCachedFile(string fileName)
        {
            Stream stream;
            CachedFileStore.TryGetValue(fileName, out stream);
            return stream;
        }

        public virtual Stream CreateCachedFile(string fileName)
        {
            MemoryStream stream = new MemoryStream();
            CachedFileStore[fileName] = stream;
            return stream;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MockHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;
using Moq.Language.Flow;

namespace System.Web.Mvc.Test
{
    public static class MockHelpers
    {
        public static ISetup<HttpContextBase> ExpectMvcVersionResponseHeader(this Mock<HttpContextBase> mock)
        {
            Version mvcVersion = VersionTestHelper.GetVersionFromAssembly("System.Web.Mvc", typeof(Controller));

            string majorMinor = mvcVersion.Major + "." + mvcVersion.Minor;
            return mock.Setup(r => r.Response.AppendHeader(MvcHandler.MvcVersionHeaderName, majorMinor));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MockableUnvalidatedRequestValues.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;

namespace System.Web.Mvc.Test
{
    public abstract class MockableUnvalidatedRequestValues : IUnvalidatedRequestValues
    {
        public abstract NameValueCollection Form { get; }
        public abstract NameValueCollection QueryString { get; }
        public abstract string this[string key] { get; }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelBinderAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelBinderAttributeTest
    {
        [Fact]
        public void ConstructorWithInvalidBinderTypeThrows()
        {
            // Arrange
            Type badType = typeof(string);

            // Act & Assert
            Assert.Throws<ArgumentException>(
                delegate { new ModelBinderAttribute(badType); },
                "The type 'System.String' does not implement the IModelBinder interface.\r\nParameter name: binderType");
        }

        [Fact]
        public void ConstructorWithNullBinderTypeThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ModelBinderAttribute(null); }, "binderType");
        }

        [Fact]
        public void BinderTypeProperty()
        {
            // Arrange
            Type binderType = typeof(GoodConverter);
            ModelBinderAttribute attr = new ModelBinderAttribute(binderType);

            // Act & Assert
            Assert.Same(binderType, attr.BinderType);
        }

        [Fact]
        public void GetBinder()
        {
            // Arrange
            ModelBinderAttribute attr = new ModelBinderAttribute(typeof(GoodConverter));

            // Act
            IModelBinder binder = attr.GetBinder();

            // Assert
            Assert.IsType<GoodConverter>(binder);
        }

        [Fact]
        public void GetBinderWithBadConstructorThrows()
        {
            // Arrange
            ModelBinderAttribute attr = new ModelBinderAttribute(typeof(BadConverter));

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                delegate { attr.GetBinder(); },
                "An error occurred when trying to create the IModelBinder 'System.Web.Mvc.Test.ModelBinderAttributeTest+BadConverter'. Make sure that the binder has a public parameterless constructor.");
        }

        private class GoodConverter : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        private class BadConverter : IModelBinder
        {
            // no public parameterless constructor
            public BadConverter(string s)
            {
            }

            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelBinderDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ModelBinderDictionaryTest
    {
        [Fact]
        public void DefaultBinderIsInstanceOfDefaultModelBinder()
        {
            // Arrange
            ModelBinderDictionary binders = new ModelBinderDictionary();

            // Act
            IModelBinder defaultBinder = binders.DefaultBinder;

            // Assert
            Assert.IsType<DefaultModelBinder>(defaultBinder);
        }

        [Fact]
        public void DefaultBinderProperty()
        {
            // Arrange
            ModelBinderDictionary binders = new ModelBinderDictionary();
            IModelBinder binder = new Mock<IModelBinder>().Object;

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(binders, "DefaultBinder", binder);
        }

        [Fact]
        public void DictionaryInterface()
        {
            // Arrange
            DictionaryHelper<Type, IModelBinder> helper = new DictionaryHelper<Type, IModelBinder>()
            {
                Creator = () => new ModelBinderDictionary(),
                SampleKeys = new Type[] { typeof(object), typeof(string), typeof(int), typeof(long), typeof(long) },
                SampleValues = new IModelBinder[] { new DefaultModelBinder(), new DefaultModelBinder(), new DefaultModelBinder(), new DefaultModelBinder(), new DefaultModelBinder() },
                ThrowOnKeyNotFound = false
            };

            // Act & assert
            helper.Execute();
        }

        [Fact]
        public void GetBinderConsultsProviders()
        {
            // Arrange
            Type modelType = typeof(string);
            IModelBinder expectedBinderFromProvider = new Mock<IModelBinder>().Object;

            Mock<IModelBinderProvider> locatedProvider = new Mock<IModelBinderProvider>();
            locatedProvider.Setup(p => p.GetBinder(modelType))
                .Returns(expectedBinderFromProvider);

            Mock<IModelBinderProvider> secondProvider = new Mock<IModelBinderProvider>();

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection(new IModelBinderProvider[] { locatedProvider.Object, secondProvider.Object });
            ModelBinderDictionary binders = new ModelBinderDictionary(providers);

            // Act
            IModelBinder returnedBinder = binders.GetBinder(modelType);

            // Assert
            Assert.Same(expectedBinderFromProvider, returnedBinder);
        }

        [Fact]
        public void GetBinderDoesNotReturnDefaultBinderIfAskedNotTo()
        {
            // Proper order of precedence:
            // 1. Binder registered in the global table
            // 2. Binder attribute defined on the type
            // 3. <null>

            // Arrange
            IModelBinder registeredFirstBinder = new Mock<IModelBinder>().Object;
            ModelBinderDictionary binders = new ModelBinderDictionary()
            {
                { typeof(MyFirstConvertibleType), registeredFirstBinder }
            };

            // Act
            IModelBinder binder1 = binders.GetBinder(typeof(MyFirstConvertibleType), false /* fallbackToDefault */);
            IModelBinder binder2 = binders.GetBinder(typeof(MySecondConvertibleType), false /* fallbackToDefault */);
            IModelBinder binder3 = binders.GetBinder(typeof(object), false /* fallbackToDefault */);

            // Assert
            Assert.Same(registeredFirstBinder, binder1);
            Assert.IsType<MySecondBinder>(binder2);
            Assert.Null(binder3);
        }

        [Fact]
        public void GetBinderResolvesBindersWithCorrectPrecedence()
        {
            // Proper order of precedence:
            // 1. Binder registered in the global table
            // 2. Binder attribute defined on the type
            // 3. Default binder

            // Arrange
            IModelBinder registeredFirstBinder = new Mock<IModelBinder>().Object;
            ModelBinderDictionary binders = new ModelBinderDictionary()
            {
                { typeof(MyFirstConvertibleType), registeredFirstBinder }
            };

            IModelBinder defaultBinder = new Mock<IModelBinder>().Object;
            binders.DefaultBinder = defaultBinder;

            // Act
            IModelBinder binder1 = binders.GetBinder(typeof(MyFirstConvertibleType));
            IModelBinder binder2 = binders.GetBinder(typeof(MySecondConvertibleType));
            IModelBinder binder3 = binders.GetBinder(typeof(object));

            // Assert
            Assert.Same(registeredFirstBinder, binder1);
            Assert.IsType<MySecondBinder>(binder2);
            Assert.Same(defaultBinder, binder3);
        }

        [Fact]
        public void GetBinderThrowsIfModelTypeContainsMultipleAttributes()
        {
            // Arrange
            ModelBinderDictionary binders = new ModelBinderDictionary();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                delegate { binders.GetBinder(typeof(ConvertibleTypeWithSeveralBinders), true /* fallbackToDefault */); },
                "The type 'System.Web.Mvc.Test.ModelBinderDictionaryTest+ConvertibleTypeWithSeveralBinders' contains multiple attributes that inherit from CustomModelBinderAttribute.");
        }

        [Fact]
        public void GetBinderThrowsIfModelTypeIsNull()
        {
            // Arrange
            ModelBinderDictionary binders = new ModelBinderDictionary();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { binders.GetBinder(null); }, "modelType");
        }

        [ModelBinder(typeof(MyFirstBinder))]
        private class MyFirstConvertibleType
        {
        }

        private class MyFirstBinder : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        [ModelBinder(typeof(MySecondBinder))]
        private class MySecondConvertibleType
        {
        }

        private class MySecondBinder : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }

        [ModelBinder(typeof(MySecondBinder))]
        [MySubclassedBinder]
        private class ConvertibleTypeWithSeveralBinders
        {
        }

        private class MySubclassedBinderAttribute : CustomModelBinderAttribute
        {
            public override IModelBinder GetBinder()
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelBinderProviderCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ModelBinderProviderCollectionTest
    {
        [Fact]
        public void GuardClause()
        {
            // Arrange
            var collection = new ModelBinderProviderCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => collection.GetBinder(null),
                "modelType"
                );
        }

        [Fact]
        public void ModelBinderProviderCollectionCombinedItemsCaches()
        {
            // Arrange
            var providers = new IModelBinderProvider[] 
            {
                new Mock<IModelBinderProvider>(MockBehavior.Strict).Object, 
                new Mock<IModelBinderProvider>(MockBehavior.Strict).Object
            };
            var collection = new ModelBinderProviderCollection(providers);

            // Act
            var combined1 = collection.CombinedItems;
            var combined2 = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined1);
            Assert.Same(combined1, combined2);
        }

        [Fact]
        public void ModelBinderProviderCollectionCombinedItemsClearResetsCache()
        {
            TestCacheReset((collection) => collection.Clear());
        }

        [Fact]
        public void ModelBinderProviderCollectionCombinedItemsInsertResetsCache()
        {
            TestCacheReset((collection) => collection.Insert(0, new Mock<IModelBinderProvider>(MockBehavior.Strict).Object));
        }

        [Fact]
        public void ModelBinderProviderCollectionCombinedItemsRemoveResetsCache()
        {
            TestCacheReset((collection) => collection.RemoveAt(0));
        }

        [Fact]
        public void ModelBinderProviderCollectionCombinedItemsSetResetsCache()
        {
            TestCacheReset((collection) => collection[0] = new Mock<IModelBinderProvider>(MockBehavior.Strict).Object);
        }

        private static void TestCacheReset(Action<ModelBinderProviderCollection> mutatingAction)
        {
            // Arrange
            var providers = new List<IModelBinderProvider>() 
            {
                new Mock<IModelBinderProvider>(MockBehavior.Strict).Object, 
                new Mock<IModelBinderProvider>(MockBehavior.Strict).Object
            };
            var collection = new ModelBinderProviderCollection(providers);

            // Act
            mutatingAction(collection);

            IModelBinderProvider[] combined = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined);
        }

        [Fact]
        public void ModelBinderProviderCollectionCombinedItemsDelegatesToResolver()
        {
            // Arrange
            var firstProvider = new Mock<IModelBinderProvider>();
            var secondProvider = new Mock<IModelBinderProvider>();
            var thirdProvider = new Mock<IModelBinderProvider>();
            var dependencyProviders = new IModelBinderProvider[] { firstProvider.Object, secondProvider.Object };
            var collectionProviders = new IModelBinderProvider[] { thirdProvider.Object };
            var expectedProviders = new IModelBinderProvider[] { firstProvider.Object, secondProvider.Object, thirdProvider.Object };

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IModelBinderProvider))).Returns(dependencyProviders);

            var providers = new ModelBinderProviderCollection(collectionProviders, resolver.Object);

            // Act
            IModelBinderProvider[] combined = providers.CombinedItems;

            // Assert
            Assert.Equal(expectedProviders, combined);
        }

        [Fact]
        public void GetBinderUsesRegisteredProviders()
        {
            // Arrange
            var testType = typeof(string);
            var expectedBinder = new Mock<IModelBinder>().Object;

            var provider = new Mock<IModelBinderProvider>(MockBehavior.Strict);
            provider.Setup(p => p.GetBinder(testType)).Returns(expectedBinder);
            var collection = new ModelBinderProviderCollection(new[] { provider.Object });

            // Act
            IModelBinder returnedBinder = collection.GetBinder(testType);

            // Assert
            Assert.Same(expectedBinder, returnedBinder);
        }

        [Fact]
        public void GetBinderReturnsValueFromFirstSuccessfulBinderProvider()
        {
            // Arrange
            var testType = typeof(string);
            IModelBinder nullModelBinder = null;
            IModelBinder expectedBinder = new Mock<IModelBinder>().Object;
            IModelBinder secondMatchingBinder = new Mock<IModelBinder>().Object;

            var provider1 = new Mock<IModelBinderProvider>();
            provider1.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);

            var provider2 = new Mock<IModelBinderProvider>(MockBehavior.Strict);
            provider2.Setup(p => p.GetBinder(testType)).Returns(expectedBinder);

            var provider3 = new Mock<IModelBinderProvider>(MockBehavior.Strict);
            provider3.Setup(p => p.GetBinder(testType)).Returns(secondMatchingBinder);

            var collection = new ModelBinderProviderCollection(new[] { provider1.Object, provider2.Object, provider3.Object });

            // Act
            IModelBinder returnedBinder = collection.GetBinder(testType);

            // Assert
            Assert.Same(expectedBinder, returnedBinder);
        }

        [Fact]
        public void GetBinderReturnsNullWhenNoSuccessfulBinderProviders()
        {
            // Arrange
            var testType = typeof(string);
            IModelBinder nullModelBinder = null;

            var provider1 = new Mock<IModelBinderProvider>();
            provider1.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);

            var provider2 = new Mock<IModelBinderProvider>(MockBehavior.Strict);
            provider2.Setup(p => p.GetBinder(testType)).Returns(nullModelBinder);

            var collection = new ModelBinderProviderCollection(new[] { provider1.Object, provider2.Object });

            // Act
            IModelBinder returnedBinder = collection.GetBinder(testType);

            // Assert
            Assert.Null(returnedBinder);
        }

        [Fact]
        public void GetBinderDelegatesToResolver()
        {
            // Arrange
            Type modelType = typeof(string);
            IModelBinder expectedBinder = new Mock<IModelBinder>().Object;

            Mock<IModelBinderProvider> locatedProvider = new Mock<IModelBinderProvider>();
            locatedProvider.Setup(p => p.GetBinder(modelType))
                .Returns(expectedBinder);

            Mock<IModelBinderProvider> secondProvider = new Mock<IModelBinderProvider>();
            Mock<IModelBinderProvider> thirdProvider = new Mock<IModelBinderProvider>();
            IModelBinderProvider[] dependencyProviders = new IModelBinderProvider[] { locatedProvider.Object, secondProvider.Object };
            IModelBinderProvider[] collectionProviders = new IModelBinderProvider[] { thirdProvider.Object };

            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IModelBinderProvider))).Returns(dependencyProviders);

            ModelBinderProviderCollection providers = new ModelBinderProviderCollection(collectionProviders, resolver.Object);

            // Act
            IModelBinder returnedBinder = providers.GetBinder(modelType);

            // Assert
            Assert.Same(expectedBinder, returnedBinder);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelBinderProvidersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelBinderProvidersTest
    {
        [Fact]
        public void CollectionDefaults()
        {
            // Act
            Type[] actualTypes = ModelBinderProviders.BinderProviders.Select(b => b.GetType()).ToArray();

            // Assert
            Assert.Equal(Enumerable.Empty<Type>(), actualTypes);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelBindersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Data.Linq;
using System.Reflection;
using System.Threading;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ModelBindersTest
    {
        [Fact]
        public void BindersPropertyIsNotNull()
        {
            // Arrange & Act
            ModelBinderDictionary binders = ModelBinders.Binders;

            // Assert
            Assert.NotNull(binders);
        }

        [Fact]
        public void DefaultModelBinders()
        {
            // Act
            ModelBinderDictionary binders = ModelBinders.Binders;

            // Assert
            Assert.Equal(4, binders.Count);
            Assert.True(binders.ContainsKey(typeof(byte[])));
            Assert.IsType<ByteArrayModelBinder>(binders[typeof(byte[])]);
            Assert.True(binders.ContainsKey(typeof(HttpPostedFileBase)));
            Assert.IsType<HttpPostedFileBaseModelBinder>(binders[typeof(HttpPostedFileBase)]);
            Assert.True(binders.ContainsKey(typeof(Binary)));
            Assert.IsType<LinqBinaryModelBinder>(binders[typeof(Binary)]);
            Assert.True(binders.ContainsKey(typeof(CancellationToken)));
            Assert.IsType<CancellationTokenModelBinder>(binders[typeof(CancellationToken)]);
        }

        [Fact]
        public void GetBindersFromAttributes_ReadsModelBinderAttributeFromBuddyClass()
        {
            Action<Type> errorAction = (Type t) => { throw new InvalidOperationException(); };
            // Act
            IModelBinder binder = ModelBinders.GetBinderFromAttributes(typeof(SampleModel), errorAction);

            // Assert
            Assert.IsType<SampleModelBinder>(binder);
        }

        [Fact]
        public void GetBindersFromAttributes_NullIfGetCustomAttributesReturnsNull()
        {
            // Arrange
            var provider = new Mock<ICustomAttributeProvider>(MockBehavior.Strict);
            bool inherit = true;
            provider.Setup(p => p.GetCustomAttributes(typeof(CustomModelBinderAttribute), inherit)).Returns((object[])null);
            Action<ICustomAttributeProvider> errorAction = (ICustomAttributeProvider t) => { throw new InvalidOperationException(); };

            // Act
            IModelBinder binder = ModelBinders.GetBinderFromAttributes(provider.Object, errorAction);

            // Assert
            Assert.Null(binder);
        }

        [MetadataType(typeof(SampleModel_Buddy))]
        private class SampleModel
        {
            [ModelBinder(typeof(SampleModelBinder))]
            private class SampleModel_Buddy
            {
            }
        }

        private class SampleModelBinder : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelBindingContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class ModelBindingContextTest
    {
        [Fact]
        public void CopyConstructor()
        {
            // Arrange
            ModelBindingContext originalBindingContext = new ModelBindingContext()
            {
                FallbackToEmptyPrefix = true,
                ModelMetadata = new EmptyModelMetadataProvider().GetMetadataForType(null, typeof(object)),
                ModelName = "theName",
                ModelState = new ModelStateDictionary(),
                PropertyFilter = _ => false,
                ValueProvider = new SimpleValueProvider()
            };

            // Act
            ModelBindingContext newBindingContext = new ModelBindingContext(originalBindingContext);

            // Assert
            Assert.False(newBindingContext.FallbackToEmptyPrefix);
            Assert.Null(newBindingContext.ModelMetadata);
            Assert.Equal("", newBindingContext.ModelName);
            Assert.Equal(originalBindingContext.ModelState, newBindingContext.ModelState);
            Assert.True(newBindingContext.PropertyFilter("foo"));
            Assert.Equal(originalBindingContext.ValueProvider, newBindingContext.ValueProvider);
        }

        [Fact]
        public void ModelNameProperty()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();

            // Act & assert
            MemberHelper.TestStringProperty(bindingContext, "ModelName", String.Empty);
        }

        [Fact]
        public void ModelStateProperty()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();
            ModelStateDictionary modelState = new ModelStateDictionary();

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(bindingContext, "ModelState", modelState);
        }

        [Fact]
        public void PropertyFilterPropertyDefaultInstanceReturnsTrueForAnyInput()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();

            // Act
            Predicate<string> propertyFilter = bindingContext.PropertyFilter;

            // Assert
            // We can't test all inputs, but at least this gives us high confidence that we ignore the parameter by default
            Assert.True(propertyFilter(null));
            Assert.True(propertyFilter(String.Empty));
            Assert.True(propertyFilter("Foo"));
        }

        [Fact]
        public void PropertyFilterPropertyReturnsDefaultInstance()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();
            Predicate<string> propertyFilter = _ => true;

            // Act & assert
            MemberHelper.TestPropertyWithDefaultInstance(bindingContext, "PropertyFilter", propertyFilter);
        }

        [Fact]
        public void ModelAndModelTypeAreFedFromModelMetadata()
        {
            // Act
            ModelBindingContext bindingContext = new ModelBindingContext
            {
                ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => 42, typeof(int))
            };

            // Assert
            Assert.Equal(42, bindingContext.Model);
            Assert.Equal(typeof(int), bindingContext.ModelType);
        }

        [Fact]
        public void ModelIsNotSettable()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => bindingContext.Model = "foo",
                "This property setter is obsolete, because its value is derived from ModelMetadata.Model now.");
        }

        [Fact]
        public void ModelTypeIsNotSettable()
        {
            // Arrange
            ModelBindingContext bindingContext = new ModelBindingContext();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => bindingContext.ModelType = typeof(string),
                "This property setter is obsolete, because its value is derived from ModelMetadata.Model now.");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelClientValidationRuleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelClientValidationRuleTest
    {
        [Fact]
        public void ValidationParametersProperty()
        {
            // Arrange
            ModelClientValidationRule rule = new ModelClientValidationRule();

            // Act
            IDictionary<string, object> parameters = rule.ValidationParameters;

            // Assert
            Assert.NotNull(parameters);
            Assert.Empty(parameters);
        }

        [Fact]
        public void ValidationTypeProperty()
        {
            // Arrange
            ModelClientValidationRule rule = new ModelClientValidationRule();

            // Act & assert
            MemberHelper.TestStringProperty(rule, "ValidationType", String.Empty);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelErrorCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelErrorCollectionTest
    {
        [Fact]
        public void AddWithExceptionArgument()
        {
            // Arrange
            ModelErrorCollection collection = new ModelErrorCollection();
            Exception ex = new Exception("some message");

            // Act
            collection.Add(ex);

            // Assert
            ModelError modelError = Assert.Single(collection);
            Assert.Same(ex, modelError.Exception);
        }

        [Fact]
        public void AddWithStringArgument()
        {
            // Arrange
            ModelErrorCollection collection = new ModelErrorCollection();

            // Act
            collection.Add("some message");

            // Assert
            ModelError modelError = Assert.Single(collection);
            Assert.Equal("some message", modelError.ErrorMessage);
            Assert.Null(modelError.Exception);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelErrorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelErrorTest
    {
        [Fact]
        public void ConstructorThrowsIfExceptionIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ModelError((Exception)null); }, "exception");
        }

        [Fact]
        public void ConstructorWithExceptionAndStringArguments()
        {
            // Arrange
            Exception ex = new Exception("some message");

            // Act
            ModelError modelError = new ModelError(ex, "some other message");

            // Assert
            Assert.Equal("some other message", modelError.ErrorMessage);
            Assert.Same(ex, modelError.Exception);
        }

        [Fact]
        public void ConstructorWithExceptionArgument()
        {
            // Arrange
            Exception ex = new Exception("some message");

            // Act
            ModelError modelError = new ModelError(ex);

            // Assert
            Assert.Equal(String.Empty, modelError.ErrorMessage);
            Assert.Same(ex, modelError.Exception);
        }

        [Fact]
        public void ConstructorWithNullStringArgumentCreatesEmptyStringErrorMessage()
        {
            // Act
            ModelError modelError = new ModelError((string)null);

            // Assert
            Assert.Equal(String.Empty, modelError.ErrorMessage);
        }

        [Fact]
        public void ConstructorWithStringArgument()
        {
            // Act
            ModelError modelError = new ModelError("some message");

            // Assert
            Assert.Equal("some message", modelError.ErrorMessage);
            Assert.Null(modelError.Exception);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelMetadataProvidersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ModelMetadataProvidersTest
    {
        [Fact]
        public void DefaultModelMetadataProviderIsCachedDataAnnotations()
        {
            // Arrange
            ModelMetadataProviders providers = new ModelMetadataProviders();

            // Act
            ModelMetadataProvider provider = providers.CurrentInternal;

            // Assert
            Assert.IsType<CachedDataAnnotationsModelMetadataProvider>(provider);
        }

        [Fact]
        public void SettingModelMetadataProviderReturnsSetProvider()
        {
            // Arrange
            ModelMetadataProviders providers = new ModelMetadataProviders();
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act
            providers.CurrentInternal = provider.Object;

            // Assert
            Assert.Same(provider.Object, providers.CurrentInternal);
        }

        [Fact]
        public void SettingNullModelMetadataProviderUsesEmptyModelMetadataProvider()
        {
            // Arrange
            ModelMetadataProviders providers = new ModelMetadataProviders();

            // Act
            providers.CurrentInternal = null;

            // Assert
            Assert.IsType<EmptyModelMetadataProvider>(providers.CurrentInternal);
        }

        [Fact]
        public void ModelMetadataProvidersCurrentDelegatesToResolver()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            Resolver<ModelMetadataProvider> resolver = new Resolver<ModelMetadataProvider> { Current = provider.Object };
            ModelMetadataProviders providers = new ModelMetadataProviders(resolver);

            // Act
            ModelMetadataProvider result = providers.CurrentInternal;

            // Assert
            Assert.Same(provider.Object, result);
        }

        private class Resolver<T> : IResolver<T>
        {
            public T Current { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelMetadataTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Linq.Expressions;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class ModelMetadataTest
    {
        // Guard clauses

        [Fact]
        public void NullProviderThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new ModelMetadata(null /* provider */, null /* containerType */, null /* model */, typeof(object), null /* propertyName */),
                "provider");
        }

        [Fact]
        public void NullTypeThrows()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new ModelMetadata(provider.Object, null /* containerType */, null /* model */, null /* modelType */, null /* propertyName */),
                "modelType");
        }

        // Constructor

        [Fact]
        public void DefaultValues()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act
            ModelMetadata metadata = new ModelMetadata(provider.Object, typeof(Exception), () => "model", typeof(string), "propertyName");

            // Assert
            Assert.Equal(typeof(Exception), metadata.ContainerType);
            Assert.True(metadata.ConvertEmptyStringToNull);
            Assert.Null(metadata.DataTypeName);
            Assert.Null(metadata.Description);
            Assert.Null(metadata.DisplayFormatString);
            Assert.Null(metadata.DisplayName);
            Assert.Null(metadata.EditFormatString);
            Assert.False(metadata.HasNonDefaultEditFormat);
            Assert.False(metadata.HideSurroundingHtml);
            Assert.True(metadata.HtmlEncode);
            Assert.Equal("model", metadata.Model);
            Assert.Equal(typeof(string), metadata.ModelType);
            Assert.Null(metadata.NullDisplayText);
            Assert.Equal(10000, metadata.Order);
            Assert.Equal("propertyName", metadata.PropertyName);
            Assert.False(metadata.IsReadOnly);
            Assert.True(metadata.RequestValidationEnabled);
            Assert.Null(metadata.ShortDisplayName);
            Assert.True(metadata.ShowForDisplay);
            Assert.True(metadata.ShowForEdit);
            Assert.Null(metadata.TemplateHint);
            Assert.Null(metadata.Watermark);
        }

        // IsComplexType

        struct IsComplexTypeModel
        {
        }

        [Fact]
        public void IsComplexTypeTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Object), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsComplexType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(IsComplexTypeModel), null).IsComplexType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Nullable<IsComplexTypeModel>), null).IsComplexType);
        }

        // IsNullableValueType

        [Fact]
        public void IsNullableValueTypeTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsNullableValueType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsNullableValueType);
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsNullableValueType);
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsNullableValueType);
        }

        // IsRequired

        [Fact]
        public void IsRequiredTests()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();

            // Act & Assert
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(string), null).IsRequired); // Reference type not required
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(IDisposable), null).IsRequired); // Interface not required
            Assert.False(new ModelMetadata(provider.Object, null, null, typeof(Nullable<int>), null).IsRequired); // Nullable value type not required
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(int), null).IsRequired); // Value type required
            Assert.True(new ModelMetadata(provider.Object, null, null, typeof(DayOfWeek), null).IsRequired); // Enum (implicit value type) is required
        }

        // Properties

        [Fact]
        public void PropertiesCallsProvider()
        {
            // Arrange
            Type modelType = typeof(string);
            List<ModelMetadata> propertyMetadata = new List<ModelMetadata>();
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, modelType, null);
            provider.Setup(p => p.GetMetadataForProperties(null, modelType))
                .Returns(propertyMetadata)
                .Verifiable();

            // Act
            IEnumerable<ModelMetadata> result = metadata.Properties;

            // Assert
            Assert.Equal(propertyMetadata, result.ToList());
            provider.Verify();
        }

        [Fact]
        public void PropertiesUsesRealModelTypeRatherThanPassedModelType()
        {
            // Arrange
            string model = "String Value";
            Expression<Func<object, object>> accessor = _ => model;
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(accessor, new ViewDataDictionary<object>());

            // Act
            IEnumerable<ModelMetadata> result = metadata.Properties;

            // Assert
            Assert.Equal("Length", result.Single().PropertyName);
        }

        [Fact]
        public void PropertiesAreSortedByOrder()
        {
            // Arrange
            Type modelType = typeof(string);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            List<ModelMetadata> propertyMetadata = new List<ModelMetadata>
            {
                new ModelMetadata(provider.Object, null, () => 1, typeof(int), null) { Order = 20 },
                new ModelMetadata(provider.Object, null, () => 2, typeof(int), null) { Order = 30 },
                new ModelMetadata(provider.Object, null, () => 3, typeof(int), null) { Order = 10 },
            };
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, modelType, null);
            provider.Setup(p => p.GetMetadataForProperties(null, modelType))
                .Returns(propertyMetadata)
                .Verifiable();

            // Act
            List<ModelMetadata> result = metadata.Properties.ToList();

            // Assert
            Assert.Equal(3, result.Count);
            Assert.Equal(3, result[0].Model);
            Assert.Equal(1, result[1].Model);
            Assert.Equal(2, result[2].Model);
        }

        [Fact]
        public void PropertiesListGetsResetWhenModelGetsReset()
        { // Dev10 Bug #923263
            // Arrange
            var provider = new DataAnnotationsModelMetadataProvider();
            var metadata = new ModelMetadata(provider, null, () => new Class1(), typeof(Class1), null);

            // Act
            ModelMetadata[] originalProps = metadata.Properties.ToArray();
            metadata.Model = new Class2();
            ModelMetadata[] newProps = metadata.Properties.ToArray();

            // Assert
            ModelMetadata originalProp = Assert.Single(originalProps);
            Assert.Equal(typeof(string), originalProp.ModelType);
            Assert.Equal("Prop1", originalProp.PropertyName);
            ModelMetadata newProp = Assert.Single(newProps);
            Assert.Equal(typeof(int), newProp.ModelType);
            Assert.Equal("Prop2", newProp.PropertyName);
        }

        class Class1
        {
            public string Prop1 { get; set; }
        }

        class Class2
        {
            public int Prop2 { get; set; }
        }

        // SimpleDisplayText

        [Fact]
        public void SimpleDisplayTextReturnsNullDisplayTextForNullModel()
        {
            // Arrange
            string nullText = "(null)";
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null) { NullDisplayText = nullText };

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(nullText, result);
        }

        private class SimpleDisplayTextModelWithToString
        {
            public override string ToString()
            {
                return "Custom ToString Value";
            }
        }

        [Fact]
        public void SimpleDisplayTextReturnsToStringValueWhenOverridden()
        {
            // Arrange
            SimpleDisplayTextModelWithToString model = new SimpleDisplayTextModelWithToString();
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithToString), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(model.ToString(), result);
        }

        private class SimpleDisplayTextModelWithoutToString
        {
            public string FirstProperty { get; set; }

            public int SecondProperty { get; set; }
        }

        [Fact]
        public void SimpleDisplayTextReturnsFirstPropertyValueForNonNullModel()
        {
            // Arrange
            SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString
            {
                FirstProperty = "First Property Value"
            };
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(model.FirstProperty, result);
        }

        [Fact]
        public void SimpleDisplayTextReturnsFirstPropertyNullDisplayTextForNonNullModelWithNullDisplayColumnPropertyValue()
        {
            // Arrange
            SimpleDisplayTextModelWithoutToString model = new SimpleDisplayTextModelWithoutToString();
            EmptyModelMetadataProvider propertyProvider = new EmptyModelMetadataProvider();
            ModelMetadata propertyMetadata = propertyProvider.GetMetadataForProperty(() => model.FirstProperty, typeof(SimpleDisplayTextModelWithoutToString), "FirstProperty");
            propertyMetadata.NullDisplayText = "Null Display Text";
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            provider.Setup(p => p.GetMetadataForProperties(model, typeof(SimpleDisplayTextModelWithoutToString)))
                .Returns(new[] { propertyMetadata });
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(SimpleDisplayTextModelWithoutToString), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(propertyMetadata.NullDisplayText, result);
        }

        private class SimpleDisplayTextModelWithNoProperties
        {
        }

        [Fact]
        public void SimpleDisplayTextReturnsEmptyStringForNonNullModelWithNoVisibleProperties()
        {
            // Arrange
            SimpleDisplayTextModelWithNoProperties model = new SimpleDisplayTextModelWithNoProperties();
            EmptyModelMetadataProvider provider = new EmptyModelMetadataProvider();
            ModelMetadata metadata = new ModelMetadata(provider, null, () => model, typeof(SimpleDisplayTextModelWithNoProperties), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(String.Empty, result);
        }

        private class ObjectWithToStringOverride
        {
            private string _toStringValue;

            public ObjectWithToStringOverride(string toStringValue)
            {
                _toStringValue = toStringValue;
            }

            public override string ToString()
            {
                return _toStringValue;
            }
        }

        [Fact]
        public void SimpleDisplayTextReturnsToStringOfModelForNonNullModel()
        {
            // Arrange
            string toStringText = "text from ToString()";
            ObjectWithToStringOverride model = new ObjectWithToStringOverride(toStringText);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(ObjectWithToStringOverride), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(toStringText, result);
        }

        [Fact]
        public void SimpleDisplayTextReturnsEmptyStringForNonNullModelWithToStringNull()
        {
            // Arrange
            string toStringText = null;
            ObjectWithToStringOverride model = new ObjectWithToStringOverride(toStringText);
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, () => model, typeof(ObjectWithToStringOverride), null);

            // Act
            string result = metadata.SimpleDisplayText;

            // Assert
            Assert.Equal(String.Empty, result);
        }

        // FromStringExpression()

        [Fact]
        public void FromStringExpressionGuardClauses()
        {
            // Null expression throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromStringExpression(null, new ViewDataDictionary()),
                "expression");

            // Null view data dictionary throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromStringExpression("expression", null),
                "viewData");
        }

        [Fact]
        public void FromStringExpressionEmptyExpressionReturnsExistingModelMetadata()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData.ModelMetadata = metadata;

            // Act
            ModelMetadata result = ModelMetadata.FromStringExpression(String.Empty, viewData, provider.Object);

            // Assert
            Assert.Same(metadata, result);
        }

        [Fact]
        public void FromStringExpressionItemNotFoundInViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ViewDataDictionary viewData = new ViewDataDictionary();
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Null(accessor);
                    Assert.Equal(typeof(string), type); // Don't know the type, must fall back on string
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("UnknownObject", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNullItemFoundAtRootOfViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = null;
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(typeof(string), type); // Don't know the type, must fall back on string
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNonNullItemFoundAtRootOfViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            object model = new object();
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = model;
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Same(model, accessor());
                    Assert.Equal(typeof(object), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNullItemFoundOnPropertyOfItemInViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyModelContainer model = new DummyModelContainer();
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = model;
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(typeof(DummyModelContainer), type);
                    Assert.Equal("Model", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object.Model", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionNonNullItemFoundOnPropertyOfItemInViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyModelContainer model = new DummyModelContainer { Model = new DummyContactModel() };
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = model;
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Same(model.Model, accessor());
                    Assert.Equal(typeof(DummyModelContainer), type);
                    Assert.Equal("Model", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromStringExpression("Object.Model", viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromStringExpressionContainerTest()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyModelContainer model = new DummyModelContainer { Model = new DummyContactModel() };
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData["Object"] = model;
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Returns<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    return new ModelMetadata(provider.Object, model.GetType(), accessor, type, propertyName);
                });

            // Act
            ModelMetadata metadata = ModelMetadata.FromStringExpression("Object.Model", viewData, provider.Object);

            // Assert
            Assert.Same(model, metadata.Container);
        }

        [Fact]
        public void FromStringExpressionWithNullModelButValidModelMetadataShouldReturnProperPropertyMetadata()
        {
            // Arrange
            ViewDataDictionary viewData = new ViewDataDictionary();
            viewData.ModelMetadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(DummyContactModel));

            // Act
            ModelMetadata result = ModelMetadata.FromStringExpression("NullableIntValue", viewData);

            // Assert
            Assert.Null(result.Model);
            Assert.Equal(typeof(Nullable<int>), result.ModelType);
            Assert.Equal("NullableIntValue", result.PropertyName);
            Assert.Equal(typeof(DummyContactModel), result.ContainerType);
        }

        [Fact]
        public void FromStringExpressionValueInModelProperty()
        {
            // Arrange
            DummyContactModel model = new DummyContactModel { FirstName = "John" };
            ViewDataDictionary viewData = new ViewDataDictionary(model);

            // Act
            ModelMetadata metadata = ModelMetadata.FromStringExpression("FirstName", viewData);

            // Assert
            Assert.Equal("John", metadata.Model);
        }

        [Fact]
        public void FromStringExpressionValueInViewDataOverridesValueFromModelProperty()
        {
            // Arrange
            DummyContactModel model = new DummyContactModel { FirstName = "John" };
            ViewDataDictionary viewData = new ViewDataDictionary(model);
            viewData["FirstName"] = "Jim";

            // Act
            ModelMetadata metadata = ModelMetadata.FromStringExpression("FirstName", viewData);

            // Assert
            Assert.Equal("Jim", metadata.Model);
            Assert.Null(metadata.Container);
        }

        // FromLambdaExpression()

        [Fact]
        public void FromLambdaExpressionGuardClauseTests()
        {
            // Null expression throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromLambdaExpression<string, object>(null, new ViewDataDictionary<string>()),
                "expression");

            // Null view data throws
            Assert.ThrowsArgumentNull(
                () => ModelMetadata.FromLambdaExpression<string, object>(m => m, null),
                "viewData");

            // Unsupported expression type throws
            Assert.Throws<InvalidOperationException>(
                () => ModelMetadata.FromLambdaExpression<string, object>(m => new Object(), new ViewDataDictionary<string>()),
                "Templates can be used only with field access, property access, single-dimension array index, or single-parameter custom indexer expressions.");
        }

        [Fact]
        public void FromLambdaExpressionModelIdentityExpressionReturnsExistingModelMetadata()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            viewData.ModelMetadata = metadata;

            // Act
            ModelMetadata result = ModelMetadata.FromLambdaExpression<object, object>(m => m, viewData, provider.Object);

            // Assert
            Assert.Same(metadata, result);
        }

        [Fact]
        public void FromLambdaExpressionPropertyExpressionFromParameter()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { FirstName = "Test" };
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Equal("Test", accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                    Assert.Equal("FirstName", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, string>(m => m.FirstName, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionPropertyExpressionFromClosureValue()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { FirstName = "Test" };
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Equal("Test", accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                    Assert.Equal("FirstName", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<object, string>(m => model.FirstName, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionFieldExpressionFromParameter()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { IntField = 42 };
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal(42, accessor());
                    Assert.Equal(typeof(int), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, int>(m => m.IntField, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionFieldExpressionFromFieldOfClosureValue()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { IntField = 42 };
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal(42, accessor());
                    Assert.Equal(typeof(int), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<object, int>(m => model.IntField, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionFieldExpressionFromClosureValue()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel();
            ViewDataDictionary<object> viewData = new ViewDataDictionary<object>();
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Same(model, accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<object, DummyContactModel>(m => model, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionSingleParameterClassIndexer()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel();
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal("Indexed into 42", accessor());
                    Assert.Equal(typeof(string), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, string>(m => m[42], viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionSingleDimensionArrayIndex()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DummyContactModel model = new DummyContactModel { Array = new[] { 4, 8, 15, 16, 23, 42 } };
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>(model);
            provider.Setup(p => p.GetMetadataForType(It.IsAny<Func<object>>(), It.IsAny<Type>()))
                .Callback<Func<object>, Type>((accessor, type) =>
                {
                    Assert.Equal(16, accessor());
                    Assert.Equal(typeof(int), type);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, int>(m => m.Array[3], viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionNullReferenceExceptionsInPropertyExpressionPreserveAllExpressionInformation()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ViewDataDictionary<DummyContactModel> viewData = new ViewDataDictionary<DummyContactModel>();
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(typeof(DummyContactModel), type);
                    Assert.Equal("FirstName", propertyName);
                })
                .Returns(() => null)
                .Verifiable();

            // Act
            ModelMetadata.FromLambdaExpression<DummyContactModel, string>(m => m.FirstName, viewData, provider.Object);

            // Assert
            provider.Verify();
        }

        [Fact]
        public void FromLambdaExpressionSetsContainerTypeToDerivedMostType()
        { // Dev10 Bug #868619
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DerivedModel derivedModel = new DerivedModel();
            ViewDataDictionary<DerivedModel> viewData = new ViewDataDictionary<DerivedModel>(derivedModel);
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(derivedModel.GetType(), type);
                    Assert.Equal("MyProperty", propertyName);
                })
                .Returns<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    return new ModelMetadata(provider.Object, derivedModel.GetType(), accessor, type, propertyName);
                })
                .Verifiable();

            // Act
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression<DerivedModel, string>(m => m.MyProperty, viewData, provider.Object);

            // Assert
            provider.Verify();
            Assert.Same(derivedModel, metadata.Container);
        }

        [Fact]
        public void FromLambdaExpressionSetsContainerWithoutObjectInViewData()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            DerivedModel derivedModel = new DerivedModel();
            ViewDataDictionary<DerivedModel> viewData = new ViewDataDictionary<DerivedModel>();
            provider.Setup(p => p.GetMetadataForProperty(It.IsAny<Func<object>>(), It.IsAny<Type>(), It.IsAny<string>()))
                .Callback<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    Assert.Null(accessor());
                    Assert.Equal(derivedModel.GetType(), type);
                    Assert.Equal("MyProperty", propertyName);
                })
                .Returns<Func<object>, Type, string>((accessor, type, propertyName) =>
                {
                    return new ModelMetadata(provider.Object, derivedModel.GetType(), accessor, type, propertyName);
                })
                .Verifiable();

            // Act
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression<DerivedModel, string>(m => m.MyProperty, viewData, provider.Object);

            // Assert
            provider.Verify();
            Assert.Null(metadata.Container);
        }

        private class BaseModel
        {
            public virtual string MyProperty { get; set; }
        }

        private class DerivedModel : BaseModel
        {
            [Required]
            public override string MyProperty
            {
                get { return base.MyProperty; }
                set { base.MyProperty = value; }
            }
        }

        // GetDisplayName()

        [Fact]
        public void ReturnsDisplayNameWhenSet()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), "PropertyName") { DisplayName = "Display Name" };

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("Display Name", result);
        }

        [Fact]
        public void ReturnsPropertyNameWhenSetAndDisplayNameIsNull()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), "PropertyName");

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("PropertyName", result);
        }

        [Fact]
        public void ReturnsTypeNameWhenPropertyNameAndDisplayNameAreNull()
        {
            // Arrange
            Mock<ModelMetadataProvider> provider = new Mock<ModelMetadataProvider>();
            ModelMetadata metadata = new ModelMetadata(provider.Object, null, null, typeof(object), null);

            // Act
            string result = metadata.GetDisplayName();

            // Assert
            Assert.Equal("Object", result);
        }

        // Helpers

        private class DummyContactModel
        {
            public int IntField = 0;
            public string FirstName { get; set; }
            public string LastName { get; set; }
            public Nullable<int> NullableIntValue { get; set; }
            public int[] Array { get; set; }

            public string this[int index]
            {
                get { return "Indexed into " + index; }
            }
        }

        private class DummyModelContainer
        {
            public DummyContactModel Model { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelStateDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelStateDictionaryTest
    {
        [Fact]
        public void AddModelErrorCreatesModelStateIfNotPresent()
        {
            // Arrange
            ModelStateDictionary dictionary = new ModelStateDictionary();

            // Act
            dictionary.AddModelError("some key", "some error");

            // Assert
            KeyValuePair<string, ModelState> kvp = Assert.Single(dictionary);
            Assert.Equal("some key", kvp.Key);
            ModelError error = Assert.Single(kvp.Value.Errors);
            Assert.Equal("some error", error.ErrorMessage);
        }

        [Fact]
        public void AddModelErrorThrowsIfKeyIsNull()
        {
            // Arrange
            ModelStateDictionary dictionary = new ModelStateDictionary();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { dictionary.AddModelError(null, (string)null); }, "key");
        }

        [Fact]
        public void AddModelErrorUsesExistingModelStateIfPresent()
        {
            // Arrange
            ModelStateDictionary dictionary = new ModelStateDictionary();
            dictionary.AddModelError("some key", "some error");
            Exception ex = new Exception();

            // Act
            dictionary.AddModelError("some key", ex);

            // Assert
            KeyValuePair<string, ModelState> kvp = Assert.Single(dictionary);
            Assert.Equal("some key", kvp.Key);

            Assert.Equal(2, kvp.Value.Errors.Count);
            Assert.Equal("some error", kvp.Value.Errors[0].ErrorMessage);
            Assert.Same(ex, kvp.Value.Errors[1].Exception);
        }

        [Fact]
        public void ConstructorThrowsIfDictionaryIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ModelStateDictionary((ModelStateDictionary)null); }, "dictionary");
        }

        [Fact]
        public void ConstructorWithDictionaryParameter()
        {
            // Arrange
            ModelStateDictionary oldDictionary = new ModelStateDictionary()
            {
                { "foo", new ModelState() { Value = HtmlHelperTest.GetValueProviderResult("bar", "bar") } }
            };

            // Act
            ModelStateDictionary newDictionary = new ModelStateDictionary(oldDictionary);

            // Assert
            Assert.Single(newDictionary);
            Assert.Equal("bar", newDictionary["foo"].Value.ConvertTo(typeof(string)));
        }

        [Fact]
        public void ConstructorWithDictionaryParameterUsesCopyOnWriteDictionary()
        {
            // Arrange
            ModelStateDictionary oldDictionary = new ModelStateDictionary();

            // Act
            ModelStateDictionary newDictionary = new ModelStateDictionary(oldDictionary);

            // Assert
            Assert.IsType<Dictionary<string, ModelState>>(oldDictionary.InnerDictionary);
            Assert.IsType<CopyOnWriteDictionary<string, ModelState>>(newDictionary.InnerDictionary);
        }

        [Fact]
        public void DictionaryInterface()
        {
            // Arrange
            DictionaryHelper<string, ModelState> helper = new DictionaryHelper<string, ModelState>()
            {
                Creator = () => new ModelStateDictionary(),
                Comparer = StringComparer.OrdinalIgnoreCase,
                SampleKeys = new string[] { "foo", "bar", "baz", "quux", "QUUX" },
                SampleValues = new ModelState[] { new ModelState(), new ModelState(), new ModelState(), new ModelState(), new ModelState() },
                ThrowOnKeyNotFound = false
            };

            // Act & assert
            helper.Execute();
        }

        [Fact]
        public void DictionaryIsSerializable()
        {
            // Arrange
            MemoryStream stream = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();

            ModelStateDictionary originalDict = new ModelStateDictionary();
            originalDict.AddModelError("foo", new InvalidOperationException("Some invalid operation."));
            originalDict.AddModelError("foo", new InvalidOperationException("Some other invalid operation."));
            originalDict.AddModelError("bar", "Some exception text.");
            originalDict.SetModelValue("baz", new ValueProviderResult("rawValue", "attemptedValue", CultureInfo.GetCultureInfo("fr-FR")));

            // Act
            formatter.Serialize(stream, originalDict);
            stream.Position = 0;
            ModelStateDictionary deserializedDict = formatter.Deserialize(stream) as ModelStateDictionary;

            // Assert
            Assert.NotNull(deserializedDict);
            Assert.Equal(3, deserializedDict.Count);

            ModelState foo = deserializedDict["FOO"];
            InvalidOperationException exception0 = Assert.IsType<InvalidOperationException>(foo.Errors[0].Exception);
            Assert.Equal("Some invalid operation.", exception0.Message);
            InvalidOperationException exception1 = Assert.IsType<InvalidOperationException>(foo.Errors[1].Exception);
            Assert.Equal("Some other invalid operation.", exception1.Message);

            ModelState bar = deserializedDict["BAR"];
            Assert.Equal("Some exception text.", bar.Errors[0].ErrorMessage);

            ModelState baz = deserializedDict["BAZ"];
            Assert.Equal("rawValue", baz.Value.RawValue);
            Assert.Equal("attemptedValue", baz.Value.AttemptedValue);
            Assert.Equal(CultureInfo.GetCultureInfo("fr-FR"), baz.Value.Culture);
        }

        [Fact]
        public void IsValidFieldReturnsFalseIfDictionaryDoesNotContainKey()
        {
            // Arrange
            ModelStateDictionary msd = new ModelStateDictionary();

            // Act
            bool isValid = msd.IsValidField("foo");

            // Assert
            Assert.True(isValid);
        }

        [Fact]
        public void IsValidFieldReturnsFalseIfKeyChildContainsErrors()
        {
            // Arrange
            ModelStateDictionary msd = new ModelStateDictionary();
            msd.AddModelError("foo.bar", "error text");

            // Act
            bool isValid = msd.IsValidField("foo");

            // Assert
            Assert.False(isValid);
        }

        [Fact]
        public void IsValidFieldReturnsFalseIfKeyContainsErrors()
        {
            // Arrange
            ModelStateDictionary msd = new ModelStateDictionary();
            msd.AddModelError("foo", "error text");

            // Act
            bool isValid = msd.IsValidField("foo");

            // Assert
            Assert.False(isValid);
        }

        [Fact]
        public void IsValidFieldReturnsTrueIfModelStateDoesNotContainErrors()
        {
            // Arrange
            ModelStateDictionary msd = new ModelStateDictionary()
            {
                { "foo", new ModelState() { Value = new ValueProviderResult(null, null, null) } }
            };

            // Act
            bool isValid = msd.IsValidField("foo");

            // Assert
            Assert.True(isValid);
        }

        [Fact]
        public void IsValidFieldThrowsIfKeyIsNull()
        {
            // Arrange
            ModelStateDictionary msd = new ModelStateDictionary();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { msd.IsValidField(null); }, "key");
        }

        [Fact]
        public void IsValidPropertyReturnsFalseIfErrors()
        {
            // Arrange
            ModelState errorState = new ModelState() { Value = HtmlHelperTest.GetValueProviderResult("quux", "quux") };
            errorState.Errors.Add("some error");
            ModelStateDictionary dictionary = new ModelStateDictionary()
            {
                { "foo", new ModelState() { Value = HtmlHelperTest.GetValueProviderResult("bar", "bar") } },
                { "baz", errorState }
            };

            // Act
            bool isValid = dictionary.IsValid;

            // Assert
            Assert.False(isValid);
        }

        [Fact]
        public void IsValidPropertyReturnsTrueIfNoErrors()
        {
            // Arrange
            ModelStateDictionary dictionary = new ModelStateDictionary()
            {
                { "foo", new ModelState() { Value = HtmlHelperTest.GetValueProviderResult("bar", "bar") } },
                { "baz", new ModelState() { Value = HtmlHelperTest.GetValueProviderResult("quux", "bar") } }
            };

            // Act
            bool isValid = dictionary.IsValid;

            // Assert
            Assert.True(isValid);
        }

        [Fact]
        public void MergeCopiesDictionaryEntries()
        {
            // Arrange
            ModelStateDictionary fooDict = new ModelStateDictionary() { { "foo", new ModelState() } };
            ModelStateDictionary barDict = new ModelStateDictionary() { { "bar", new ModelState() } };

            // Act
            fooDict.Merge(barDict);

            // Assert
            Assert.Equal(2, fooDict.Count);
            Assert.Equal(barDict["bar"], fooDict["bar"]);
        }

        [Fact]
        public void MergeDoesNothingIfParameterIsNull()
        {
            // Arrange
            ModelStateDictionary fooDict = new ModelStateDictionary() { { "foo", new ModelState() } };

            // Act
            fooDict.Merge(null);

            // Assert
            Assert.Single(fooDict);
            Assert.True(fooDict.ContainsKey("foo"));
        }

        [Fact]
        public void SetAttemptedValueCreatesModelStateIfNotPresent()
        {
            // Arrange
            ModelStateDictionary dictionary = new ModelStateDictionary();

            // Act
            dictionary.SetModelValue("some key", HtmlHelperTest.GetValueProviderResult("some value", "some value"));

            // Assert
            Assert.Single(dictionary);
            ModelState modelState = dictionary["some key"];

            Assert.Empty(modelState.Errors);
            Assert.Equal("some value", modelState.Value.ConvertTo(typeof(string)));
        }

        [Fact]
        public void SetAttemptedValueUsesExistingModelStateIfPresent()
        {
            // Arrange
            ModelStateDictionary dictionary = new ModelStateDictionary();
            dictionary.AddModelError("some key", "some error");
            Exception ex = new Exception();

            // Act
            dictionary.SetModelValue("some key", HtmlHelperTest.GetValueProviderResult("some value", "some value"));

            // Assert
            Assert.Single(dictionary);
            ModelState modelState = dictionary["some key"];

            ModelError error = Assert.Single(modelState.Errors);
            Assert.Equal("some error", error.ErrorMessage);
            Assert.Equal("some value", modelState.Value.ConvertTo(typeof(string)));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelStateTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelStateTest
    {
        [Fact]
        public void ErrorsProperty()
        {
            // Arrange
            ModelState modelState = new ModelState();

            // Act & Assert
            Assert.NotNull(modelState.Errors);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelValidationResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelValidationResultTest
    {
        [Fact]
        public void MemberNameProperty()
        {
            // Arrange
            ModelValidationResult result = new ModelValidationResult();

            // Act & assert
            MemberHelper.TestStringProperty(result, "MemberName", String.Empty);
        }

        [Fact]
        public void MessageProperty()
        {
            // Arrange
            ModelValidationResult result = new ModelValidationResult();

            // Act & assert
            MemberHelper.TestStringProperty(result, "Message", String.Empty);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelValidatorProviderCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ModelValidatorProviderCollectionTest
    {
        [Fact]
        public void ListWrappingConstructor()
        {
            // Arrange
            List<ModelValidatorProvider> list = new List<ModelValidatorProvider>()
            {
                new Mock<ModelValidatorProvider>().Object, new Mock<ModelValidatorProvider>().Object
            };

            // Act
            ModelValidatorProviderCollection collection = new ModelValidatorProviderCollection(list);

            // Assert
            Assert.Equal(list, collection.ToList());
        }

        [Fact]
        public void ListWrappingConstructorThrowsIfListIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ModelValidatorProviderCollection((IList<ModelValidatorProvider>)null); },
                "list");
        }

        [Fact]
        public void DefaultConstructor()
        {
            // Act
            ModelValidatorProviderCollection collection = new ModelValidatorProviderCollection();

            // Assert
            Assert.Empty(collection);
        }

        [Fact]
        public void AddNullModelValidatorProviderThrows()
        {
            // Arrange
            ModelValidatorProviderCollection collection = new ModelValidatorProviderCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection.Add(null); },
                "item");
        }

        [Fact]
        public void ModelValidatorProviderCollectionCombinedItemsCaches()
        {
            // Arrange
            var providers = new ModelValidatorProvider[] 
            {
                new Mock<ModelValidatorProvider>(MockBehavior.Strict).Object, 
                new Mock<ModelValidatorProvider>(MockBehavior.Strict).Object
            };
            var collection = new ModelValidatorProviderCollection(providers);

            // Act
            var combined1 = collection.CombinedItems;
            var combined2 = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined1);
            Assert.Same(combined1, combined2);
        }

        [Fact]
        public void ModelValidatorProviderCollectionCombinedItemsClearResetsCache()
        {
            TestCacheReset((collection) => collection.Clear());
        }

        [Fact]
        public void ModelValidatorProviderCollectionCombinedItemsInsertResetsCache()
        {
            TestCacheReset((collection) => collection.Insert(0, new Mock<ModelValidatorProvider>(MockBehavior.Strict).Object));
        }

        [Fact]
        public void ModelValidatorProviderCollectionCombinedItemsRemoveResetsCache()
        {
            TestCacheReset((collection) => collection.RemoveAt(0));
        }

        [Fact]
        public void ModelValidatorProviderCollectionCombinedItemsSetResetsCache()
        {
            TestCacheReset((collection) => collection[0] = new Mock<ModelValidatorProvider>(MockBehavior.Strict).Object);
        }

        private static void TestCacheReset(Action<ModelValidatorProviderCollection> mutatingAction)
        {
            // Arrange
            var providers = new List<ModelValidatorProvider>() 
            {
                new Mock<ModelValidatorProvider>(MockBehavior.Strict).Object, 
                new Mock<ModelValidatorProvider>(MockBehavior.Strict).Object
            };
            var collection = new ModelValidatorProviderCollection(providers);

            // Act
            mutatingAction(collection);

            ModelValidatorProvider[] combined = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined);
        }

        [Fact]
        public void ModelBinderValidatorCollectionCombinedItemsDelegatesToResolver()
        {
            // Arrange
            var firstProvider = new Mock<ModelValidatorProvider>();
            var secondProvider = new Mock<ModelValidatorProvider>();
            var thirdProvider = new Mock<ModelValidatorProvider>();
            var dependencyProviders = new ModelValidatorProvider[] { firstProvider.Object, secondProvider.Object };
            var collectionProviders = new ModelValidatorProvider[] { thirdProvider.Object };
            var expectedProviders = new ModelValidatorProvider[] { firstProvider.Object, secondProvider.Object, thirdProvider.Object };

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(ModelValidatorProvider))).Returns(dependencyProviders);

            var providers = new ModelValidatorProviderCollection(collectionProviders, resolver.Object);

            // Act
            ModelValidatorProvider[] combined = providers.CombinedItems;

            // Assert
            Assert.Equal(expectedProviders, combined);
        }

        [Fact]
        public void SetItem()
        {
            // Arrange
            ModelValidatorProviderCollection collection = new ModelValidatorProviderCollection();
            collection.Add(new Mock<ModelValidatorProvider>().Object);

            ModelValidatorProvider newProvider = new Mock<ModelValidatorProvider>().Object;

            // Act
            collection[0] = newProvider;

            // Assert
            ModelValidatorProvider provider = Assert.Single(collection);
            Assert.Equal(newProvider, provider);
        }

        [Fact]
        public void SetNullModelValidatorProviderThrows()
        {
            // Arrange
            ModelValidatorProviderCollection collection = new ModelValidatorProviderCollection();
            collection.Add(new Mock<ModelValidatorProvider>().Object);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection[0] = null; },
                "item");
        }

        [Fact]
        public void GetValidators()
        {
            // Arrange
            ModelMetadata metadata = GetMetadata();
            ControllerContext controllerContext = new ControllerContext();

            ModelValidator[] allValidators = new ModelValidator[]
            {
                new SimpleModelValidator(),
                new SimpleModelValidator(),
                new SimpleModelValidator(),
                new SimpleModelValidator(),
                new SimpleModelValidator()
            };

            Mock<ModelValidatorProvider> provider1 = new Mock<ModelValidatorProvider>();
            provider1.Setup(p => p.GetValidators(metadata, controllerContext)).Returns(new ModelValidator[]
            {
                allValidators[0], allValidators[1]
            });

            Mock<ModelValidatorProvider> provider2 = new Mock<ModelValidatorProvider>();
            provider2.Setup(p => p.GetValidators(metadata, controllerContext)).Returns(new ModelValidator[]
            {
                allValidators[2], allValidators[3], allValidators[4]
            });

            ModelValidatorProviderCollection collection = new ModelValidatorProviderCollection();
            collection.Add(provider1.Object);
            collection.Add(provider2.Object);

            // Act
            IEnumerable<ModelValidator> returnedValidators = collection.GetValidators(metadata, controllerContext);

            // Assert
            Assert.Equal(allValidators, returnedValidators.ToArray());
        }

        [Fact]
        public void GetValidatorsDelegatesToResolver()
        {
            // Arrange
            ModelValidator[] allValidators = new ModelValidator[]
            {
                new SimpleModelValidator(),
                new SimpleModelValidator(),
                new SimpleModelValidator(),
                new SimpleModelValidator()
            };

            ModelMetadata metadata = GetMetadata();
            ControllerContext controllerContext = new ControllerContext();

            Mock<ModelValidatorProvider> resolverProvider1 = new Mock<ModelValidatorProvider>();
            resolverProvider1.Setup(p => p.GetValidators(metadata, controllerContext)).Returns(new ModelValidator[]
            {
                allValidators[0], allValidators[1]
            });

            Mock<ModelValidatorProvider> resolverprovider2 = new Mock<ModelValidatorProvider>();
            resolverprovider2.Setup(p => p.GetValidators(metadata, controllerContext)).Returns(new ModelValidator[]
            {
                allValidators[2], allValidators[3]
            });

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(ModelValidatorProvider))).Returns(new ModelValidatorProvider[] { resolverProvider1.Object, resolverprovider2.Object });

            ModelValidatorProviderCollection collection = new ModelValidatorProviderCollection(new ModelValidatorProvider[0], resolver.Object);

            // Act
            IEnumerable<ModelValidator> returnedValidators = collection.GetValidators(metadata, controllerContext);

            // Assert
            Assert.Equal(allValidators, returnedValidators.ToArray());
        }

        private static ModelMetadata GetMetadata()
        {
            ModelMetadataProvider provider = new EmptyModelMetadataProvider();
            return provider.GetMetadataForType(null, typeof(object));
        }

        private sealed class SimpleModelValidator : ModelValidator
        {
            public SimpleModelValidator()
                : base(GetMetadata(), new ControllerContext())
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelValidatorProvidersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelValidatorProvidersTest
    {
        [Fact]
        public void CollectionDefaults()
        {
            // Arrange
            Type[] expectedTypes = new Type[]
            {
                typeof(DataAnnotationsModelValidatorProvider),
                typeof(DataErrorInfoModelValidatorProvider),
                typeof(ClientDataTypeModelValidatorProvider)
            };

            // Act
            Type[] actualTypes = ModelValidatorProviders.Providers.Select(p => p.GetType()).ToArray();

            // Assert
            Assert.Equal(expectedTypes, actualTypes);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ModelValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class ModelValidatorTest
    {
        [Fact]
        public void ConstructorGuards()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(object));
            ControllerContext context = new ControllerContext();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new TestableModelValidator(null, context),
                "metadata");
            Assert.ThrowsArgumentNull(
                () => new TestableModelValidator(metadata, null),
                "controllerContext");
        }

        [Fact]
        public void ValuesSet()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();

            // Act
            TestableModelValidator validator = new TestableModelValidator(metadata, context);

            // Assert
            Assert.Same(context, validator.ControllerContext);
            Assert.Same(metadata, validator.Metadata);
        }

        [Fact]
        public void NoClientRulesByDefault()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();

            // Act
            TestableModelValidator validator = new TestableModelValidator(metadata, context);

            // Assert
            Assert.Empty(validator.GetClientValidationRules());
        }

        [Fact]
        public void IsRequiredFalseByDefault()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => 15, typeof(string), "Length");
            ControllerContext context = new ControllerContext();

            // Act
            TestableModelValidator validator = new TestableModelValidator(metadata, context);

            // Assert
            Assert.False(validator.IsRequired);
        }

        [Fact]
        public void GetModelValidator_DoesNotReadPropertyValues()
        {
            ModelValidatorProvider[] originalProviders = ModelValidatorProviders.Providers.ToArray();
            try
            {
                // Arrange
                ModelValidatorProviders.Providers.Clear();
                ModelValidatorProviders.Providers.Add(new ObservableModelValidatorProvider());

                ObservableModel model = new ObservableModel();
                ModelMetadata metadata = new EmptyModelMetadataProvider().GetMetadataForType(() => model, typeof(ObservableModel));
                ControllerContext controllerContext = new ControllerContext();

                // Act
                ModelValidator validator = ModelValidator.GetModelValidator(metadata, controllerContext);
                ModelValidationResult[] results = validator.Validate(model).ToArray();

                // Assert
                Assert.False(model.PropertyWasRead());
            }
            finally
            {
                ModelValidatorProviders.Providers.Clear();
                foreach (ModelValidatorProvider provider in originalProviders)
                {
                    ModelValidatorProviders.Providers.Add(provider);
                }
            }
        }

        private class ObservableModelValidatorProvider : ModelValidatorProvider
        {
            public override IEnumerable<ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context)
            {
                return new ModelValidator[] { new ObservableModelValidator(metadata, context) };
            }

            private class ObservableModelValidator : ModelValidator
            {
                public ObservableModelValidator(ModelMetadata metadata, ControllerContext controllerContext)
                    : base(metadata, controllerContext)
                {
                }

                public override IEnumerable<ModelValidationResult> Validate(object container)
                {
                    return Enumerable.Empty<ModelValidationResult>();
                }
            }
        }

        private class ObservableModel
        {
            private bool _propertyWasRead;

            public int TheProperty
            {
                get
                {
                    _propertyWasRead = true;
                    return 42;
                }
            }

            public bool PropertyWasRead()
            {
                return _propertyWasRead;
            }
        }

        [Fact]
        public void GetModelValidatorWithTypeLevelValidator()
        {
            // Arrange
            ControllerContext context = new ControllerContext();
            DataErrorInfo1 model = new DataErrorInfo1 { Error = "Some Type Error" };
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType());
            ModelValidator validator = ModelValidator.GetModelValidator(metadata, context);

            // Act
            ModelValidationResult result = validator.Validate(null).Single();

            // Assert
            Assert.Equal(String.Empty, result.MemberName);
            Assert.Equal("Some Type Error", result.Message);
        }

        [Fact]
        public void GetModelValidatorWithPropertyLevelValidator()
        {
            // Arrange
            ControllerContext context = new ControllerContext();
            DataErrorInfo1 model = new DataErrorInfo1();
            model["SomeStringProperty"] = "Some Property Error";
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType());
            ModelValidator validator = ModelValidator.GetModelValidator(metadata, context);

            // Act
            ModelValidationResult result = validator.Validate(null).Single();

            // Assert
            Assert.Equal("SomeStringProperty", result.MemberName);
            Assert.Equal("Some Property Error", result.Message);
        }

        [Fact]
        public void GetModelValidatorWithFailedPropertyValidatorsPreventsTypeValidatorFromRunning()
        {
            // Arrange
            ControllerContext context = new ControllerContext();
            DataErrorInfo1 model = new DataErrorInfo1 { Error = "Some Type Error" };
            model["SomeStringProperty"] = "Some Property Error";
            model["SomeOtherStringProperty"] = "Some Other Property Error";
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType());
            ModelValidator validator = ModelValidator.GetModelValidator(metadata, context);

            // Act
            List<ModelValidationResult> result = validator.Validate(null).ToList();

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("SomeStringProperty", result[0].MemberName);
            Assert.Equal("Some Property Error", result[0].Message);
            Assert.Equal("SomeOtherStringProperty", result[1].MemberName);
            Assert.Equal("Some Other Property Error", result[1].Message);
        }

        private class TestableModelValidator : ModelValidator
        {
            public TestableModelValidator(ModelMetadata metadata, ControllerContext context)
                : base(metadata, context)
            {
            }

            public override IEnumerable<ModelValidationResult> Validate(object container)
            {
                throw new NotImplementedException();
            }
        }

        private class DataErrorInfo1 : IDataErrorInfo
        {
            private readonly Dictionary<string, string> _errors = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);

            public string SomeStringProperty { get; set; }

            public string SomeOtherStringProperty { get; set; }

            public string Error { get; set; }

            public string this[string columnName]
            {
                get
                {
                    string outVal;
                    _errors.TryGetValue(columnName, out outVal);
                    return outVal;
                }
                set { _errors[columnName] = value; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MultiSelectListTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class MultiSelectListTest
    {
        [Fact]
        public void Constructor1SetsProperties()
        {
            // Arrange
            IEnumerable items = new object[0];

            // Act
            MultiSelectList multiSelect = new MultiSelectList(items);

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Null(multiSelect.DataValueField);
            Assert.Null(multiSelect.DataTextField);
            Assert.Null(multiSelect.SelectedValues);
        }

        [Fact]
        public void Constructor2SetsProperties()
        {
            // Arrange
            IEnumerable items = new object[0];
            IEnumerable selectedValues = new object[0];

            // Act
            MultiSelectList multiSelect = new MultiSelectList(items, selectedValues);

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Null(multiSelect.DataValueField);
            Assert.Null(multiSelect.DataTextField);
            Assert.Same(selectedValues, multiSelect.SelectedValues);
        }

        [Fact]
        public void Constructor3SetsProperties_SelectedValues_DisabledValues()
        {
            // Arrange
            IEnumerable items = new[] { "A", "B", "C" };
            IEnumerable selectedValues = new[] { "A", "C" };
            IEnumerable disabledValues = new[] { "B", "C" };

            // Act
            MultiSelectList multiSelect = new MultiSelectList(items, selectedValues, disabledValues);

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Equal(selectedValues, multiSelect.SelectedValues);
            Assert.Equal(disabledValues, multiSelect.DisabledValues);
            Assert.Null(multiSelect.DataTextField);
            Assert.Null(multiSelect.DataValueField);
        }

        [Fact]
        public void Constructor3SetsProperties_Value_Text()
        {
            // Arrange
            IEnumerable items = new object[0];

            // Act
            MultiSelectList multiSelect = new MultiSelectList(items, "SomeValueField", "SomeTextField");

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Equal("SomeValueField", multiSelect.DataValueField);
            Assert.Equal("SomeTextField", multiSelect.DataTextField);
            Assert.Null(multiSelect.SelectedValues);
        }

        [Fact]
        public void Constructor4SetsProperties()
        {
            // Arrange
            IEnumerable items = new object[0];
            IEnumerable selectedValues = new object[0];

            // Act
            MultiSelectList multiSelect = new MultiSelectList(items, "SomeValueField", "SomeTextField", selectedValues);

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Equal("SomeValueField", multiSelect.DataValueField);
            Assert.Equal("SomeTextField", multiSelect.DataTextField);
            Assert.Same(selectedValues, multiSelect.SelectedValues);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_SelectedValues_DisabledValues_Groups()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjectsWithGroups(),
                "Letter", "FullWord", "Group",
                selectedValues: new[] { "A", "C", "T" },
                disabledValues: new[] { "C" },
                disabledGroups: null);

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            Assert.Equal(3, listItems.Count);

            Assert.Equal("A", listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.True(listItems[0].Selected);
            Assert.False(listItems[0].Disabled);

            Assert.Equal("B", listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.False(listItems[1].Disabled);

            Assert.Equal("C", listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.True(listItems[2].Selected);
            Assert.True(listItems[2].Disabled);

            Assert.Equal("AB", listItems[0].Group.Name);
            Assert.Equal("AB", listItems[1].Group.Name);
            Assert.Equal("C", listItems[2].Group.Name);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_SelectedValues_DisabledValues_Groups_DisabledGroups()
        {
            // Arrange
            object[] disabledValues = { "C" };
            object[] disabledGroups = { "AB" };
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjectsWithGroups(),
                "Letter", "FullWord", "Group",
                selectedValues: new[] { "A", "C", "T" },
                disabledValues: disabledValues,
                disabledGroups: disabledGroups);

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            // Count of Items and Groups
            Assert.Equal(3, listItems.Count);

            // Getters
            Assert.Same(disabledValues, multiSelect.DisabledValues);
            Assert.Same(disabledGroups, multiSelect.DisabledGroups);

            // Item A
            Assert.Equal("A", listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.True(listItems[0].Selected);
            Assert.False(listItems[0].Disabled);

            // Item B
            Assert.Equal("B", listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.False(listItems[1].Disabled);

            // Item C
            Assert.Equal("C", listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.True(listItems[2].Selected);
            Assert.True(listItems[2].Disabled);

            // Group AB
            Assert.Equal("AB", listItems[0].Group.Name);
            Assert.Equal("AB", listItems[1].Group.Name);
            Assert.True(listItems[0].Group.Disabled);
            Assert.Same(listItems[0].Group, listItems[1].Group);

            // Group C is disabled.
            Assert.Equal("C", listItems[2].Group.Name);
            Assert.False(listItems[2].Group.Disabled);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_Value_Text_SelectedValues_DisabledValues_Groups()
        {
            // Arrange
            IEnumerable items = new object[0];
            IEnumerable selectedValues = new object[0];
            IEnumerable disabledValues = new object[0];

            // Act
            MultiSelectList multiSelect = new MultiSelectList(items, "SomeValueField", "SomeTextField", "SomeGroupField",
                selectedValues,
                disabledValues);

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Equal("SomeValueField", multiSelect.DataValueField);
            Assert.Equal("SomeTextField", multiSelect.DataTextField);
            Assert.Equal("SomeGroupField", multiSelect.DataGroupField);
            Assert.Same(selectedValues, multiSelect.SelectedValues);
            Assert.Equal(disabledValues, multiSelect.DisabledValues);
        }

        [Fact]
        public void DataGroupFieldSetByCtor()
        {
            // Arrange
            IEnumerable items = new object[0];
            IEnumerable selectedValues = new object[0];

            // Act
            MultiSelectList multiSelect = new MultiSelectList(items, "SomeValueField", "SomeTextField", "SomeGroupField",
                selectedValues);

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Equal("SomeValueField", multiSelect.DataValueField);
            Assert.Equal("SomeTextField", multiSelect.DataTextField);
            Assert.Same(selectedValues, multiSelect.SelectedValues);
            Assert.Equal("SomeGroupField", multiSelect.DataGroupField);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_Value_Text_SelectedValues_DisabledValues()
        {
            // Arrange
            object[] disabledValues = { "C" };
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjectsWithGroups(),
                "Letter", "FullWord",
                new[] { "A", "C", "T" },
                disabledValues);

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            // Count of Items
            Assert.Equal(3, listItems.Count);

            // Getters
            Assert.Same(disabledValues, multiSelect.DisabledValues);

            // Item A
            Assert.Equal("A", listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.True(listItems[0].Selected);
            Assert.False(listItems[0].Disabled);

            // Item B
            Assert.Equal("B", listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.False(listItems[1].Disabled);

            // Item C
            Assert.Equal("C", listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.True(listItems[2].Selected);
            Assert.True(listItems[2].Disabled);

            Assert.Equal(disabledValues, multiSelect.DisabledValues);
        }

        [Fact]
        public void ConstructorWithNullItemsThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { new MultiSelectList(null /* items */, "dataValueField", "dataTextField", null /* selectedValues */); }, "items");
        }

        [Fact]
        public void GetListItemsThrowsOnBindingFailure()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleFieldObjects(),
                                                              "Text", "Value", new string[] { "A", "C", "T" });

            // Assert
            Assert.ThrowsHttpException(
                delegate { IList<SelectListItem> listItems = multiSelect.GetListItems(); }, "DataBinding: 'System.Web.Mvc.Test.MultiSelectListTest+Item' does not contain a property with the name 'Text'.", 500);
        }

        [Fact]
        public void GetListItemsWithoutValueField()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleStrings());

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            Assert.Equal(3, listItems.Count);
            Assert.Null(listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.False(listItems[0].Selected);
            Assert.Null(listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.Null(listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.False(listItems[2].Selected);
        }

        [Fact]
        public void GetListItemsWithoutValueFieldWithSelections()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleStrings(), new string[] { "Alpha", "Charlie", "Tango" });

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            Assert.Equal(3, listItems.Count);
            Assert.Null(listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.True(listItems[0].Selected);
            Assert.Null(listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.Null(listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.True(listItems[2].Selected);
        }

        [Fact]
        public void GetListItemsWithValueField()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjects(), "Letter", "FullWord");

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            Assert.Equal(3, listItems.Count);
            Assert.Equal("A", listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.False(listItems[0].Selected);
            Assert.Equal("B", listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.Equal("C", listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.False(listItems[2].Selected);
        }

        [Fact]
        public void GetListItemsWithGroupField()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjectsWithGroups(),
                                                              "Letter",
                                                              "FullWord",
                                                              "Group");

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            Assert.Equal(3, listItems.Count);
            Assert.Equal("A", listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.False(listItems[0].Selected);
            Assert.Equal("B", listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.Equal("C", listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.False(listItems[2].Selected);
            Assert.Equal("AB", listItems[0].Group.Name);
            Assert.Equal("AB", listItems[1].Group.Name);
            Assert.Equal("C", listItems[2].Group.Name);
        }

        [Fact]
        public void GetListItemsWithValueFieldWithSelections()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjects(),
                                                              "Letter", "FullWord", new string[] { "A", "C", "T" });

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            Assert.Equal(3, listItems.Count);
            Assert.Equal("A", listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.True(listItems[0].Selected);
            Assert.Equal("B", listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.Equal("C", listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.True(listItems[2].Selected);
        }

        [Fact]
        public void GetListItemsWithValueFieldWithSelectionsWithGroupField()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjectsWithGroups(),
                "Letter", "FullWord", "Group", new string[] { "A", "C", "T" });

            // Act
            IList<SelectListItem> listItems = multiSelect.GetListItems();

            // Assert
            Assert.Equal(3, listItems.Count);
            Assert.Equal("A", listItems[0].Value);
            Assert.Equal("Alpha", listItems[0].Text);
            Assert.True(listItems[0].Selected);
            Assert.Equal("B", listItems[1].Value);
            Assert.Equal("Bravo", listItems[1].Text);
            Assert.False(listItems[1].Selected);
            Assert.Equal("C", listItems[2].Value);
            Assert.Equal("Charlie", listItems[2].Text);
            Assert.True(listItems[2].Selected);
            Assert.Equal("AB", listItems[0].Group.Name);
            Assert.Equal("AB", listItems[1].Group.Name);
            Assert.Equal("C", listItems[2].Group.Name);
        }

        [Fact]
        public void IEnumerableWithAnonymousObjectsAndTextValueFields()
        {
            // Arrange
            MultiSelectList multiSelect = new MultiSelectList(GetSampleAnonymousObjects(),
                                                              "Letter", "FullWord", new string[] { "A", "C", "T" });

            // Act
            IEnumerator enumerator = multiSelect.GetEnumerator();
            enumerator.MoveNext();
            SelectListItem firstItem = enumerator.Current as SelectListItem;
            SelectListItem lastItem = null;

            while (enumerator.MoveNext())
            {
                lastItem = enumerator.Current as SelectListItem;
            }

            // Assert
            Assert.True(firstItem != null);
            Assert.Equal("Alpha", firstItem.Text);
            Assert.Equal("A", firstItem.Value);
            Assert.True(firstItem.Selected);

            Assert.True(lastItem != null);
            Assert.Equal("Charlie", lastItem.Text);
            Assert.Equal("C", lastItem.Value);
            Assert.True(lastItem.Selected);
        }

        internal static IEnumerable GetSampleAnonymousObjects()
        {
            return new[]
            {
                new { Letter = 'A', FullWord = "Alpha" },
                new { Letter = 'B', FullWord = "Bravo" },
                new { Letter = 'C', FullWord = "Charlie" }
            };
        }

        internal static IEnumerable GetSampleAnonymousObjectsWithGroups()
        {
            return new[]
            {
                new { Letter = 'A', FullWord = "Alpha", Group = "AB" },
                new { Letter = 'B', FullWord = "Bravo", Group = "AB" },
                new { Letter = 'C', FullWord = "Charlie", Group = "C" },
            };
        }

        internal static IEnumerable GetSampleFieldObjects()
        {
            return new[]
            {
                new Item { Text = "A", Value = "Alpha" },
                new Item { Text = "B", Value = "Bravo" },
                new Item { Text = "C", Value = "Charlie" }
            };
        }

        internal static List<SelectListItem> GetSampleListObjects()
        {
            List<SelectListItem> list = new List<SelectListItem>();
            string selectedSSN = "111111111";

            foreach (Person person in GetSamplePeople())
            {
                list.Add(new SelectListItem
                {
                    Text = person.FirstName,
                    Value = person.SSN,
                    Selected = String.Equals(person.SSN, selectedSSN)
                });
            }
            return list;
        }

        internal static IEnumerable<SelectListItem> GetSampleIEnumerableObjects()
        {
            Person[] people = GetSamplePeople();

            string selectedSSN = "111111111";
            IEnumerable<SelectListItem> list = from person in people
                                               select new SelectListItem
                                               {
                                                   Text = person.FirstName,
                                                   Value = person.SSN,
                                                   Selected = String.Equals(person.SSN, selectedSSN)
                                               };
            return list;
        }

        internal static IEnumerable GetSampleStrings()
        {
            return new string[] { "Alpha", "Bravo", "Charlie" };
        }

        internal static Person[] GetSamplePeople()
        {
            return new Person[]
            {
                new Person
                {
                    FirstName = "John",
                    SSN = "123456789"
                },
                new Person
                {
                    FirstName = "Jane",
                    SSN = "987654321"
                },
                new Person
                {
                    FirstName = "Joe",
                    SSN = "111111111"
                }
            };
        }

        internal class Item
        {
            public string Text;
            public string Value;
        }

        internal class Person
        {
            public string FirstName { get; set; }

            public string SSN { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MultiServiceResolverTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class MultiServiceResolverTest
    {
        [Fact]
        public void GetCombinedPrependsFromResolver()
        {
            // Arrange
            IEnumerable<TestProvider> providersFromServiceLocation = GetProvidersFromService();
            IList<TestProvider> providersFromItemsThunk = GetProvidersFromItemsThunk().ToList();
            IEnumerable<TestProvider> expectedProviders = providersFromServiceLocation.Concat(providersFromItemsThunk);

            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(TestProvider)))
                .Returns(providersFromServiceLocation);

            // Act
            IEnumerable<TestProvider> returnedProviders = MultiServiceResolver.GetCombined<TestProvider>(providersFromItemsThunk, resolver.Object);

            // Assert
            Assert.Equal(expectedProviders.ToList(), returnedProviders.ToList());
        }

        [Fact]
        public void CurrentReturnsCurrentItemsWhenResolverReturnsNoInstances()
        {
            // Arrange
            IList<TestProvider> providersFromItemsThunk = GetProvidersFromItemsThunk().ToList();

            // Act
            IEnumerable<TestProvider> returnedProviders = MultiServiceResolver.GetCombined<TestProvider>(providersFromItemsThunk, null);

            // Assert
            Assert.Equal(providersFromItemsThunk.ToList(), returnedProviders.ToList());
        }

        [Fact]
        public void CurrentPropagatesExceptionWhenResolverThrowsNonActivationException()
        {
            // Arrange
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>(MockBehavior.Strict);

            // Act & Assert
            var ex = Assert.Throws<MockException>(
                () => MultiServiceResolver.GetCombined<TestProvider>(null, resolver.Object));
            Assert.Equal(
                "IDependencyResolver.GetServices(System.Web.Mvc.Test.MultiServiceResolverTest+TestProvider) invocation failed with mock behavior Strict." +
                Environment.NewLine +
                "All invocations on the mock must have a corresponding setup.",
                ex.Message,
                ignoreLineEndingDifferences: true);
        }

        private class TestProvider
        {
        }

        private IEnumerable<TestProvider> GetProvidersFromService()
        {
            return new TestProvider[]
            {
                new TestProvider(),
                new TestProvider()
            };
        }

        private IEnumerable<TestProvider> GetProvidersFromItemsThunk()
        {
            return new TestProvider[]
            {
                new TestProvider(),
                new TestProvider()
            };
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MvcHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Async;
using System.Web.Mvc.Async.Test;
using System.Web.Routing;
using System.Web.SessionState;
using Microsoft.TestCommon;
using Moq;
using Moq.Protected;

namespace System.Web.Mvc.Test
{
    public class MvcHandlerTest
    {
        [Fact]
        public void ConstructorWithNullRequestContextThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { new MvcHandler(null); },
                "requestContext");
        }

        [Fact]
        public void ProcessRequestWithRouteWithoutControllerThrows()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.ExpectMvcVersionResponseHeader().Verifiable();
            RouteData rd = new RouteData();
            MvcHandler mvcHandler = new MvcHandler(new RequestContext(contextMock.Object, rd));

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { mvcHandler.ProcessRequest(contextMock.Object); },
                "The RouteData must contain an item named 'controller' with a non-empty string value.");

            // Assert
            contextMock.Verify();
        }

        [Fact]
        public void ProcessRequestAddsServerHeaderCallsExecute()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.ExpectMvcVersionResponseHeader().Verifiable();

            RouteData rd = new RouteData();
            rd.Values.Add("controller", "foo");
            RequestContext requestContext = new RequestContext(contextMock.Object, rd);
            MvcHandler mvcHandler = new MvcHandler(requestContext);

            Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
            controllerMock.As<IController>().CallBase = true;
            controllerMock.Protected().Setup("Execute", requestContext).Verifiable();

            ControllerBuilder cb = new ControllerBuilder();
            Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
            controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
            controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
            cb.SetControllerFactory(controllerFactoryMock.Object);
            mvcHandler.ControllerBuilder = cb;

            // Act
            mvcHandler.ProcessRequest(contextMock.Object);

            // Assert
            contextMock.Verify();
            controllerMock.Verify();
        }

        [Fact]
        public void ProcessRequestRemovesOptionalParametersFromRouteValueDictionary()
        {
            // Arrange
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.ExpectMvcVersionResponseHeader();

            RouteData rd = new RouteData();
            rd.Values.Add("controller", "foo");
            rd.Values.Add("optional", UrlParameter.Optional);
            RequestContext requestContext = new RequestContext(contextMock.Object, rd);
            MvcHandler mvcHandler = new MvcHandler(requestContext);

            Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
            controllerMock.As<IController>().CallBase = true;
            controllerMock.Protected().Setup("Execute", requestContext).Verifiable();

            ControllerBuilder cb = new ControllerBuilder();
            Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
            controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
            controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
            cb.SetControllerFactory(controllerFactoryMock.Object);
            mvcHandler.ControllerBuilder = cb;

            // Act
            mvcHandler.ProcessRequest(contextMock.Object);

            // Assert
            controllerMock.Verify();
            Assert.False(rd.Values.ContainsKey("optional"));
        }

        [Fact]
        public void ProcessRequestWithDisabledServerHeaderOnlyCallsExecute()
        {
            bool oldResponseHeaderValue = MvcHandler.DisableMvcResponseHeader;
            try
            {
                // Arrange
                MvcHandler.DisableMvcResponseHeader = true;
                Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();

                RouteData rd = new RouteData();
                rd.Values.Add("controller", "foo");
                RequestContext requestContext = new RequestContext(contextMock.Object, rd);
                MvcHandler mvcHandler = new MvcHandler(requestContext);

                Mock<ControllerBase> controllerMock = new Mock<ControllerBase>();
                controllerMock.As<IController>().CallBase = true;
                controllerMock.Protected().Setup("Execute", requestContext).Verifiable();

                ControllerBuilder cb = new ControllerBuilder();
                Mock<IControllerFactory> controllerFactoryMock = new Mock<IControllerFactory>();
                controllerFactoryMock.Setup(o => o.CreateController(requestContext, "foo")).Returns(controllerMock.Object);
                controllerFactoryMock.Setup(o => o.ReleaseController(controllerMock.Object));
                cb.SetControllerFactory(controllerFactoryMock.Object);
                mvcHandler.ControllerBuilder = cb;

                // Act
                mvcHandler.ProcessRequest(contextMock.Object);

                // Assert
                controllerMock.Verify();
            }
            finally
            {
                MvcHandler.DisableMvcResponseHeader = oldResponseHeaderValue;
            }
        }

        [Fact]
        public void ProcessRequestDisposesControllerIfExecuteDoesNotThrowException()
        {
            // Arrange
            Mock<ControllerBase> mockController = new Mock<ControllerBase>();
            mockController.As<IDisposable>().Setup(c => c.Dispose()); // so that Verify can be called on Dispose later
            mockController.As<IController>().CallBase = true;
            mockController.Protected().Setup("Execute", ItExpr.IsAny<RequestContext>()).Verifiable();

            ControllerBuilder builder = new ControllerBuilder();
            builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));

            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.ExpectMvcVersionResponseHeader().Verifiable();
            RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
            requestContext.RouteData.Values["controller"] = "fooController";
            MvcHandler handler = new MvcHandler(requestContext)
            {
                ControllerBuilder = builder
            };

            // Act
            handler.ProcessRequest(requestContext.HttpContext);

            // Assert
            mockController.Verify();
            contextMock.Verify();
            mockController.As<IDisposable>().Verify(d => d.Dispose(), Times.AtMostOnce());
        }

        [Fact]
        public void ProcessRequestDisposesControllerIfExecuteThrowsException()
        {
            // Arrange
            Mock<ControllerBase> mockController = new Mock<ControllerBase>();
            mockController.As<IDisposable>().Setup(d => d.Dispose()); // so that Verify can be called on Dispose later
            mockController.As<IController>().CallBase = true;
            mockController.Protected().Setup("Execute", ItExpr.IsAny<RequestContext>()).Throws(new Exception("some exception"));

            ControllerBuilder builder = new ControllerBuilder();
            builder.SetControllerFactory(new SimpleControllerFactory(mockController.Object));

            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.ExpectMvcVersionResponseHeader().Verifiable();
            RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
            requestContext.RouteData.Values["controller"] = "fooController";
            MvcHandler handler = new MvcHandler(requestContext)
            {
                ControllerBuilder = builder
            };

            // Act
            Assert.Throws<Exception>(
                delegate { handler.ProcessRequest(requestContext.HttpContext); },
                "some exception");

            // Assert
            mockController.Verify();
            contextMock.Verify();
            mockController.As<IDisposable>().Verify(d => d.Dispose(), Times.AtMostOnce());
        }

        [Fact]
        public void ProcessRequestAsync_AsyncController_DisposesControllerOnException()
        {
            // Arrange
            Mock<IAsyncController> mockController = new Mock<IAsyncController>();
            mockController.Setup(o => o.BeginExecute(It.IsAny<RequestContext>(), It.IsAny<AsyncCallback>(), It.IsAny<object>())).Throws(new Exception("Some exception text."));
            mockController.As<IDisposable>().Setup(o => o.Dispose()).Verifiable();

            MvcHandler handler = GetMvcHandler(mockController.Object);

            // Act & assert
            Assert.Throws<Exception>(
                delegate { handler.BeginProcessRequest(handler.RequestContext.HttpContext, null, null); },
                @"Some exception text.");

            mockController.Verify();
        }

        [Fact]
        public void ProcessRequestAsync_AsyncController_NormalExecution()
        {
            // Arrange
            using (MockAsyncResult innerAsyncResult = new MockAsyncResult())
            {
                bool disposeWasCalled = false;

                Mock<IAsyncController> mockController = new Mock<IAsyncController>();
                mockController.Setup(o => o.BeginExecute(It.IsAny<RequestContext>(), It.IsAny<AsyncCallback>(), It.IsAny<object>())).Returns(innerAsyncResult);
                mockController.As<IDisposable>().Setup(o => o.Dispose()).Callback(delegate { disposeWasCalled = true; });

                MvcHandler handler = GetMvcHandler(mockController.Object);

                // Act & assert
                IAsyncResult outerAsyncResult = handler.BeginProcessRequest(handler.RequestContext.HttpContext, null, null);
                Assert.False(disposeWasCalled);

                handler.EndProcessRequest(outerAsyncResult);
                Assert.True(disposeWasCalled);
                mockController.Verify(o => o.EndExecute(innerAsyncResult), Times.AtMostOnce());
            }
        }

        [Fact]
        public void ProcessRequestAsync_SyncController_NormalExecution()
        {
            // Arrange
            bool executeWasCalled = false;
            bool disposeWasCalled = false;

            Mock<IController> mockController = new Mock<IController>();
            mockController.Setup(o => o.Execute(It.IsAny<RequestContext>())).Callback(delegate { executeWasCalled = true; });
            mockController.As<IDisposable>().Setup(o => o.Dispose()).Callback(delegate { disposeWasCalled = true; });

            MvcHandler handler = GetMvcHandler(mockController.Object);

            // Act & assert
            IAsyncResult outerAsyncResult = handler.BeginProcessRequest(handler.RequestContext.HttpContext, null, null);
            Assert.False(executeWasCalled);
            Assert.False(disposeWasCalled);

            handler.EndProcessRequest(outerAsyncResult);
            Assert.True(executeWasCalled);
            Assert.True(disposeWasCalled);
        }

        // Test that execute is called on a  user controller that derives from Controller
        [Fact]
        public void ProcessRequestAsync_SyncController_NormalExecution2()
        {
            // Arrange
            MyCustomerController controller = new MyCustomerController();

            MvcHandler handler = GetMvcHandler(controller);
            handler.RequestContext.RouteData.Values["action"] = "Widget";

            // Act
            IAsyncResult outerAsyncResult = handler.BeginProcessRequest(handler.RequestContext.HttpContext, null, null);
            handler.EndProcessRequest(outerAsyncResult);

            // Assert
            Assert.Equal(1, controller.Called);
        }

        private class EmptyActionInvoker : IActionInvoker
        {
            public bool InvokeAction(ControllerContext controllerContext, string actionName)
            {
                return true; // action handled.
            }
        }

        // Class that captures how an end-user would override and use a Controller
        private class MyCustomerController : Controller
        {
            public int Called { get; set; }

            protected override void ExecuteCore()
            {
                this.Called++;
            }

            protected override IActionInvoker CreateActionInvoker()
            {
                // The default action invoker relies on too much state (like having an HttpRequestContext), so stub it out.
                return new EmptyActionInvoker();
            }

            // Workaround.
            protected override bool DisableAsyncSupport
            {
                get
                {
                    return true; // ensure ExecuteCore still gets called.
                }
            }
        }

        private static MvcHandler GetMvcHandler(IController controller)
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Response.AddHeader("X-AspNetMvc-Version", "2.0"));

            RouteData routeData = new RouteData();
            routeData.Values["controller"] = "SomeController";
            RequestContext requestContext = new RequestContext(mockHttpContext.Object, routeData);

            ControllerBuilder controllerBuilder = new ControllerBuilder();
            controllerBuilder.SetControllerFactory(new SimpleControllerFactory(controller));

            return new MvcHandler(requestContext)
            {
                ControllerBuilder = controllerBuilder
            };
        }

        private class SimpleControllerFactory : IControllerFactory
        {
            private IController _instance;

            public SimpleControllerFactory(IController instance)
            {
                _instance = instance;
            }

            public IController CreateController(RequestContext context, string controllerName)
            {
                return _instance;
            }

            public SessionStateBehavior GetControllerSessionBehavior(RequestContext requestContext, string controllerName)
            {
                return SessionStateBehavior.Default;
            }

            public void ReleaseController(IController controller)
            {
                IDisposable disposable = controller as IDisposable;
                if (disposable != null)
                {
                    disposable.Dispose();
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MvcHtmlStringTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class MvcHtmlStringTest
    {
        // IsNullOrEmpty

        [Fact]
        public void IsNullOrEmptyTests()
        {
            // Act & Assert
            Assert.True(MvcHtmlString.IsNullOrEmpty(null));
            Assert.True(MvcHtmlString.IsNullOrEmpty(MvcHtmlString.Empty));
            Assert.True(MvcHtmlString.IsNullOrEmpty(MvcHtmlString.Create("")));
            Assert.False(MvcHtmlString.IsNullOrEmpty(MvcHtmlString.Create(" ")));
        }

        // ToHtmlString

        [Fact]
        public void ToHtmlStringReturnsOriginalString()
        {
            // Arrange
            MvcHtmlString htmlString = MvcHtmlString.Create("some value");

            // Act
            string retVal = htmlString.ToHtmlString();

            // Assert
            Assert.Equal("some value", retVal);
        }

        // ToString

        [Fact]
        public void ToStringReturnsOriginalString()
        {
            // Arrange
            MvcHtmlString htmlString = MvcHtmlString.Create("some value");

            // Act
            string retVal = htmlString.ToString();

            // Assert
            Assert.Equal("some value", retVal);
        }

        [Fact]
        public void ToStringReturnsEmptyStringIfOriginalStringWasNull()
        {
            // Arrange
            MvcHtmlString htmlString = MvcHtmlString.Create(null);

            // Act
            string retVal = htmlString.ToString();

            // Assert
            Assert.Equal("", retVal);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MvcHttpHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class MvcHttpHandlerTest
    {
        [Fact]
        public void ConstructorDoesNothing()
        {
            new MvcHttpHandler();
        }

        [Fact]
        public void VerifyAndProcessRequestWithNullHandlerThrows()
        {
            // Arrange
            PublicMvcHttpHandler handler = new PublicMvcHttpHandler();

            // Act
            Assert.ThrowsArgumentNull(
                delegate { handler.PublicVerifyAndProcessRequest(null, null); },
                "httpHandler");
        }

        [Fact]
        public void ProcessRequestCallsExecute()
        {
            // Arrange
            PublicMvcHttpHandler handler = new PublicMvcHttpHandler();
            Mock<IHttpHandler> mockTargetHandler = new Mock<IHttpHandler>();
            mockTargetHandler.Setup(h => h.ProcessRequest(It.IsAny<HttpContext>())).Verifiable();

            // Act
            handler.PublicVerifyAndProcessRequest(mockTargetHandler.Object, null);

            // Assert
            mockTargetHandler.Verify();
        }

        private sealed class DummyHttpHandler : IHttpHandler
        {
            bool IHttpHandler.IsReusable
            {
                get { throw new NotImplementedException(); }
            }

            void IHttpHandler.ProcessRequest(HttpContext context)
            {
                throw new NotImplementedException();
            }
        }

        private sealed class PublicMvcHttpHandler : MvcHttpHandler
        {
            public void PublicVerifyAndProcessRequest(IHttpHandler httpHandler, HttpContextBase httpContext)
            {
                base.VerifyAndProcessRequest(httpHandler, httpContext);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MvcRouteHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using System.Web.SessionState;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class MvcRouteHandlerTest
    {
        [Fact]
        public void GetHttpHandlerReturnsMvcHandlerWithRouteData()
        {
            // Arrange
            var routeData = new RouteData();
            routeData.Values["controller"] = "controllerName";
            var context = new RequestContext(new Mock<HttpContextBase>().Object, routeData);
            var controllerFactory = new Mock<IControllerFactory>();
            controllerFactory.Setup(f => f.GetControllerSessionBehavior(context, "controllerName"))
                .Returns(SessionStateBehavior.Default)
                .Verifiable();
            IRouteHandler rh = new MvcRouteHandler(controllerFactory.Object);

            // Act
            IHttpHandler httpHandler = rh.GetHttpHandler(context);

            // Assert
            MvcHandler h = httpHandler as MvcHandler;
            Assert.NotNull(h);
            Assert.Equal(context, h.RequestContext);
        }

        [Fact]
        public void GetHttpHandlerAsksControllerFactoryForSessionBehaviorOfController()
        {
            // Arrange
            var httpContext = new Mock<HttpContextBase>();
            var routeData = new RouteData();
            routeData.Values["controller"] = "controllerName";
            var requestContext = new RequestContext(httpContext.Object, routeData);
            var controllerFactory = new Mock<IControllerFactory>();
            controllerFactory.Setup(f => f.GetControllerSessionBehavior(requestContext, "controllerName"))
                .Returns(SessionStateBehavior.ReadOnly)
                .Verifiable();
            IRouteHandler routeHandler = new MvcRouteHandler(controllerFactory.Object);

            // Act
            routeHandler.GetHttpHandler(requestContext);

            // Assert
            controllerFactory.Verify();
            httpContext.Verify(c => c.SetSessionStateBehavior(SessionStateBehavior.ReadOnly));
        }

        [Fact]
        public void GetHttpHandlerThrowsIfTheRouteValuesDoesNotIncludeAControllerName()
        {
            // Arrange
            var httpContext = new Mock<HttpContextBase>();
            var routeData = new RouteData();
            var requestContext = new RequestContext(httpContext.Object, routeData);
            IRouteHandler routeHandler = new MvcRouteHandler();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => routeHandler.GetHttpHandler(requestContext),
                "The matched route does not include a 'controller' route value, which is required."
                );
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MvcTestHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Reflection.Emit;

namespace System.Web.Mvc.Test
{
    internal static class MvcTestHelper
    {
        private static bool _mvcAssembliesCreated;

        public static void CreateMvcAssemblies()
        {
            // Only create MVC assemblies once per appdomain. This method is called from the static ctor of several
            // test classes.
            if (_mvcAssembliesCreated)
            {
                return;
            }

            CreateMvcTestAssembly1();
            CreateMvcTestAssembly2();
            CreateMvcTestAssembly3();
            CreateMvcTestAssembly4();

            _mvcAssembliesCreated = true;
        }

        private static void CreateMvcTestAssembly1()
        {
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName("MvcAssembly1"),
                AssemblyBuilderAccess.Save);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(
                "MvcAssembly1", "MvcAssembly1.dll");

            CreateController(moduleBuilder, "NS1a.NS1b.C1Controller");
            CreateController(moduleBuilder, "NS2a.NS2b.C2Controller");

            assemblyBuilder.Save("MvcAssembly1.dll");
        }

        private static void CreateMvcTestAssembly2()
        {
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName("MvcAssembly2"),
                AssemblyBuilderAccess.Save);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(
                "MvcAssembly2", "MvcAssembly2.dll");

            CreateController(moduleBuilder, "NS3a.NS3b.C3Controller");
            CreateController(moduleBuilder, "NS4a.NS4b.C4Controller");

            assemblyBuilder.Save("MvcAssembly2.dll");
        }

        private static void CreateMvcTestAssembly3()
        {
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName("MvcAssembly3"),
                AssemblyBuilderAccess.Save);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(
                "MvcAssembly3", "MvcAssembly3.dll");

            // Type names (but not namespaces) are the same as those in TestAssembly1
            CreateController(moduleBuilder, "NS3a.NS3b.C1Controller");
            CreateController(moduleBuilder, "NS4a.NS4b.C2Controller");

            assemblyBuilder.Save("MvcAssembly3.dll");
        }

        private static void CreateMvcTestAssembly4()
        {
            AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName("MvcAssembly4"),
                AssemblyBuilderAccess.Save);
            ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule(
                "MvcAssembly4", "MvcAssembly4.dll");

            // Namespaces and type names are the same as those in TestAssembly1
            CreateController(moduleBuilder, "NS1a.NS1b.C1Controller");
            CreateController(moduleBuilder, "NS2a.NS2b.C2Controller");

            assemblyBuilder.Save("MvcAssembly4.dll");
        }

        private static void CreateController(ModuleBuilder moduleBuilder, string typeName)
        {
            //namespace {namespace} {
            //    public class {typename} : ControllerBase {
            //        protected virtual void ExecuteCore() {
            //            return;
            //        }
            //    }
            //}

            TypeBuilder controllerTypeBuilder = moduleBuilder.DefineType(typeName, TypeAttributes.Class | TypeAttributes.Public, typeof(ControllerBase));
            MethodBuilder executeMethodBuilder = controllerTypeBuilder.DefineMethod("ExecuteCore", MethodAttributes.Family | MethodAttributes.Virtual, typeof(void), Type.EmptyTypes);
            executeMethodBuilder.GetILGenerator().Emit(OpCodes.Ret);
            controllerTypeBuilder.DefineMethodOverride(executeMethodBuilder, typeof(ControllerBase).GetMethod("ExecuteCore", BindingFlags.Instance | BindingFlags.NonPublic));
            controllerTypeBuilder.CreateType();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/MvcWebRazorHostFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Razor;
using System.Web.WebPages.Razor;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class MvcWebRazorHostFactoryTest
    {
        [Fact]
        public void Constructor()
        {
            new MvcWebRazorHostFactory();

            // All is cool
        }

        [Fact]
        public void CreateHost_ReplacesRegularHostWithMvcSpecificOne()
        {
            // Arrange
            MvcWebRazorHostFactory factory = new MvcWebRazorHostFactory();

            // Act
            WebPageRazorHost result = factory.CreateHost("foo.cshtml", null);

            // Assert
            Assert.IsType<MvcWebPageRazorHost>(result);
        }

        [Fact]
        public void CreateHost_DoesNotChangeAppStartFileHost()
        {
            // Arrange
            MvcWebRazorHostFactory factory = new MvcWebRazorHostFactory();

            // Act
            WebPageRazorHost result = factory.CreateHost("_appstart.cshtml", null);

            // Assert
            Assert.IsNotType<MvcWebPageRazorHost>(result);
        }

        [Fact]
        public void CreateHost_DoesNotChangePageStartFileHost()
        {
            // Arrange
            MvcWebRazorHostFactory factory = new MvcWebRazorHostFactory();

            // Act
            WebPageRazorHost result = factory.CreateHost("_pagestart.cshtml", null);

            // Assert
            Assert.IsNotType<MvcWebPageRazorHost>(result);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/NameValueCollectionExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class NameValueCollectionExtensionsTest
    {
        [Fact]
        public void CopyTo()
        {
            // Arrange
            NameValueCollection collection = GetCollection();
            IDictionary<string, object> dictionary = GetDictionary();

            // Act
            collection.CopyTo(dictionary);

            // Assert
            Assert.Equal(3, dictionary.Count);
            Assert.Equal("FooDictionary", dictionary["foo"]);
            Assert.Equal("BarDictionary", dictionary["bar"]);
            Assert.Equal("BazCollection", dictionary["baz"]);
        }

        [Fact]
        public void CopyToReplaceExisting()
        {
            // Arrange
            NameValueCollection collection = GetCollection();
            IDictionary<string, object> dictionary = GetDictionary();

            // Act
            collection.CopyTo(dictionary, true /* replaceExisting */);

            // Assert
            Assert.Equal(3, dictionary.Count);
            Assert.Equal("FooCollection", dictionary["foo"]);
            Assert.Equal("BarDictionary", dictionary["bar"]);
            Assert.Equal("BazCollection", dictionary["baz"]);
        }

        [Fact]
        public void CopyToWithNullCollectionThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { NameValueCollectionExtensions.CopyTo(null /* collection */, null /* destination */); }, "collection");
        }

        [Fact]
        public void CopyToWithNullDestinationThrows()
        {
            // Arrange
            NameValueCollection collection = GetCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection.CopyTo(null /* destination */); }, "destination");
        }

        private static NameValueCollection GetCollection()
        {
            return new NameValueCollection
            {
                { "Foo", "FooCollection" },
                { "Baz", "BazCollection" }
            };
        }

        private static IDictionary<string, object> GetDictionary()
        {
            return new RouteValueDictionary(new { Foo = "FooDictionary", Bar = "BarDictionary" });
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/NameValueCollectionValueProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class NameValueCollectionValueProviderTest
    {
        private static readonly NameValueCollection _backingStore = new NameValueCollection()
        {
            { "foo", "fooValue1" },
            { "foo", "fooValue2" },
            { "bar.baz", "someOtherValue" }
        };

        [Fact]
        public void Constructor_ThrowsIfCollectionIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new NameValueCollectionValueProvider(null, CultureInfo.InvariantCulture); }, "collection");
        }

        [Fact]
        public void ContainsPrefix()
        {
            // Arrange
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(_backingStore, null);

            // Act
            bool result = valueProvider.ContainsPrefix("bar");

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void ContainsPrefix_DoesNotContainEmptyPrefixIfBackingStoreIsEmpty()
        {
            // Arrange
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(new NameValueCollection(), null);

            // Act
            bool result = valueProvider.ContainsPrefix("");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ContainsPrefix_ThrowsIfPrefixIsNull()
        {
            // Arrange
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(_backingStore, null);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { valueProvider.ContainsPrefix(null); }, "prefix");
        }

        [Fact]
        public void GetValue()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(_backingStore, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("foo");

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(_backingStore.GetValues("foo"), (string[])vpResult.RawValue);
            Assert.Equal("fooValue1,fooValue2", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }

        [Fact]
        public void GetValue_NonValidating()
        {
            // Arrange
            NameValueCollection unvalidatedCollection = new NameValueCollection()
            {
                { "foo", "fooValue3" },
                { "foo", "fooValue4" }
            };

            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(_backingStore, unvalidatedCollection, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("foo", skipValidation: true);

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(new[] { "fooValue3", "fooValue4" }, (string[])vpResult.RawValue);
            Assert.Equal("fooValue3,fooValue4", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }

        [Fact]
        public void GetValue_NonValidating_NoUnvalidatedCollectionSpecified_UsesDefaultCollectionValue()
        {
            // Arrange
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(_backingStore, null, culture);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("foo", skipValidation: true);

            // Assert
            Assert.NotNull(vpResult);
            Assert.Equal(_backingStore.GetValues("foo"), (string[])vpResult.RawValue);
            Assert.Equal("fooValue1,fooValue2", vpResult.AttemptedValue);
            Assert.Equal(culture, vpResult.Culture);
        }

        [Theory]
        [InlineData("foo", "fooValue", "foo", "fooValue")]
        [InlineData("fooArray[0][bar1][bar3]", "barValue1", "fooArray[0].bar1.bar3", "barValue1")]
        [InlineData("fooArray[0][bar2]", "barValue2", "fooArray[0].bar2", "barValue2")]
        [InlineData(
            "fooArray[1][bar1][0][nested]", "nestedArrayValue", "fooArray[1].bar1[0].nested", "nestedArrayValue")]
        [InlineData("fooArray[2].bar1", "noSquareBracesValue", "fooArray[2].bar1", "noSquareBracesValue")]
        [InlineData("foo.bar", "fooBarValue", "foo.bar", "fooBarValue")]
        public void GetValue_NonValidating_WithArraysInCollection(
                            string name, string value, string index, string expectedAttemptedValue)
        {
            // Arrange
            string[] expectedRawValue = new[] { expectedAttemptedValue };
            NameValueCollection unvalidatedCollection = new NameValueCollection();
            unvalidatedCollection.Add(name, value);

            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");
            NameValueCollectionValueProvider valueProvider = 
                    new NameValueCollectionValueProvider(_backingStore, unvalidatedCollection, culture, true);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue(index, skipValidation: true);
            
            // Asserts
            Assert.NotNull(vpResult);
            Assert.Equal(culture, vpResult.Culture);
            Assert.Equal(expectedRawValue, (string[])vpResult.RawValue);
            Assert.Equal(expectedAttemptedValue, vpResult.AttemptedValue);
        }

        [Fact]
        public void GetValue_NonValidating_WithArraysInCollection_Error()
        {
            // Arrange
            NameValueCollection unvalidatedCollection = new NameValueCollection()
            {
                { "foo", "fooValue3" },
                { "fooArray[0][bar1", "barValue1" }
            };

            NameValueCollectionValueProvider valueProvider =
                new NameValueCollectionValueProvider(
                                    _backingStore,
                                    unvalidatedCollection,
                                    culture: null,
                                    jQueryToMvcRequestNormalizationRequired: true);

            // Act & Assert
            Assert.ThrowsArgument(
                () => valueProvider.GetValue("foo", skipValidation: true),
                "key",
                "The key is invalid JQuery syntax because it is missing a closing bracket.");
        }

        [Fact]
        public void GetValue_ReturnsNullIfKeyNotFound()
        {
            // Arrange
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(_backingStore, null);

            // Act
            ValueProviderResult vpResult = valueProvider.GetValue("bar");

            // Assert
            Assert.Null(vpResult);
        }

        [Fact]
        public void GetValue_ThrowsIfKeyIsNull()
        {
            // Arrange
            NameValueCollectionValueProvider valueProvider = new NameValueCollectionValueProvider(_backingStore, null);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { valueProvider.GetValue(null); }, "key");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/NoAsyncTimeoutAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class NoAsyncTimeoutAttributeTest
    {
        [Fact]
        public void DurationPropertyIsZero()
        {
            // Act
            AsyncTimeoutAttribute attr = new NoAsyncTimeoutAttribute();

            // Assert
            Assert.Equal(Timeout.Infinite, attr.Duration);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/NonActionAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class NonActionAttributeTest
    {
        [Fact]
        public void InValidActionForRequestReturnsFalse()
        {
            // Arrange
            NonActionAttribute attr = new NonActionAttribute();

            // Act & Assert
            Assert.False(attr.IsValidForRequest(null, null));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/OutputCacheAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web.TestUtil;
using System.Web.UI;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class OutputCacheAttributeTest
    {
        [Fact]
        public void CacheProfileProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "CacheProfile", String.Empty);
        }

        [Fact]
        public void CacheSettingsProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute()
            {
                CacheProfile = "SomeProfile",
                Duration = 50,
                Location = OutputCacheLocation.Downstream,
                NoStore = true,
                SqlDependency = "SomeSqlDependency",
                VaryByContentEncoding = "SomeContentEncoding",
                VaryByCustom = "SomeCustom",
                VaryByHeader = "SomeHeader",
                VaryByParam = "SomeParam",
            };

            // Act
            OutputCacheParameters cacheSettings = attr.CacheSettings;

            // Assert
            Assert.Equal("SomeProfile", cacheSettings.CacheProfile);
            Assert.Equal(50, cacheSettings.Duration);
            Assert.Equal(OutputCacheLocation.Downstream, cacheSettings.Location);
            Assert.True(cacheSettings.NoStore);
            Assert.Equal("SomeSqlDependency", cacheSettings.SqlDependency);
            Assert.Equal("SomeContentEncoding", cacheSettings.VaryByContentEncoding);
            Assert.Equal("SomeCustom", cacheSettings.VaryByCustom);
            Assert.Equal("SomeHeader", cacheSettings.VaryByHeader);
            Assert.Equal("SomeParam", cacheSettings.VaryByParam);
        }

        [Fact]
        public void DurationProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestInt32Property(attr, "Duration", 10, 20);
        }

        [Fact]
        public void LocationProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestPropertyValue(attr, "Location", OutputCacheLocation.ServerAndClient);
        }

        [Fact]
        public void NoStoreProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestBooleanProperty(attr, "NoStore", false /* initialValue */, false /* testDefaultValue */);
        }

        [Fact]
        public void OnResultExecutingThrowsIfFilterContextIsNull()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnResultExecuting(null); }, "filterContext");
        }

        [Theory]
        [InlineData(0)]
        [InlineData(-1)]
        public void OnActionExecuting_Throws_IfDurationIsNotPositive(int duration)
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();
            attr.Duration = duration;
            Mock<ActionExecutingContext> context = new Mock<ActionExecutingContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                () => attr.OnActionExecuting(context.Object),
                "Duration must be a positive number.");
        }

        [Theory]
        [InlineData(null)]
        [InlineData("")]
        public void OnActionExecuting_Throws_IfVaryByParamIsNullOrEmptyAndDurationIsPositive(string varyByParam)
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();
            attr.Duration = 1;
            attr.VaryByParam = varyByParam;
            Mock<ActionExecutingContext> context = new Mock<ActionExecutingContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                () => attr.OnActionExecuting(context.Object),
                "VaryByParam must be '*', 'none', or a semicolon-delimited list of keys.");
        }

        [Fact]
        public void OnActionExecuting_Throws_IfCacheProfileSet()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();
            attr.CacheProfile = "something";
            Mock<ActionExecutingContext> context = new Mock<ActionExecutingContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                () => attr.OnActionExecuting(context.Object),
                "OutputCacheAttribute for child actions only supports Duration, VaryByCustom, and VaryByParam values. Please do not set CacheProfile, Location, NoStore, SqlDependency, VaryByContentEncoding, or VaryByHeader values for child actions.");
        }

        [Fact]
        public void SqlDependencyProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "SqlDependency", String.Empty);
        }

        [Fact]
        public void VaryByContentEncodingProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "VaryByContentEncoding", String.Empty);
        }

        [Fact]
        public void VaryByCustomProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "VaryByCustom", String.Empty);
        }

        [Fact]
        public void VaryByHeaderProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "VaryByHeader", String.Empty);
        }

        [Fact]
        public void VaryByParamProperty()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();

            // Act & assert
            MemberHelper.TestStringProperty(attr, "VaryByParam", "*");
        }

        [Fact]
        public void OutputCacheDoesNotExecuteIfInChildAction()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();
            Mock<ResultExecutingContext> context = new Mock<ResultExecutingContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act
            attr.OnResultExecuting(context.Object);

            // Assert
            context.Verify();
            context.Verify(c => c.Result, Times.Never());
        }

        [Fact]
        public void OutputCacheDurationDoesNotSetIfInChildAction()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute();
            Mock<ActionExecutingContext> context = new Mock<ActionExecutingContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act & assert
            Assert.Throws<InvalidOperationException>(delegate { attr.OnActionExecuting(context.Object); });
        }

        [Fact]
        public void OutputCacheLocationSetNoneIfInChildAction()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute()
            {
                Location = OutputCacheLocation.None
            };
            Mock<ActionExecutingContext> context = new Mock<ActionExecutingContext>();
            context.Setup(c => c.IsChildAction).Returns(true);

            // Act & assert
            Assert.DoesNotThrow(delegate { attr.OnActionExecuting(context.Object); });
        }

        // GetChildActionUniqueId

        [Fact]
        public void GetChildActionUniqueId_ReturnsRepeatableValueForIdenticalContext()
        {
            // Arrange
            var attr = new OutputCacheAttribute();
            var context = new MockActionExecutingContext();

            // Act
            string result1 = attr.GetChildActionUniqueId(context.Object);
            string result2 = attr.GetChildActionUniqueId(context.Object);

            // Assert
            Assert.Equal(result1, result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionDescriptorsUniqueId()
        {
            // Arrange
            var attr = new OutputCacheAttribute();
            var context1 = new MockActionExecutingContext();
            context1.Setup(c => c.ActionDescriptor.UniqueId).Returns("1");
            var context2 = new MockActionExecutingContext();
            context2.Setup(c => c.ActionDescriptor.UniqueId).Returns("2");

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.NotEqual(result1, result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByCustom()
        {
            // Arrange
            var attr = new OutputCacheAttribute { VaryByCustom = "foo" };
            var application1 = new Mock<HttpApplication>();
            application1.Setup(a => a.GetVaryByCustomString(It.IsAny<HttpContext>(), "foo")).Returns("1");
            var context1 = new MockActionExecutingContext();
            context1.SetupGet(c => c.HttpContext.ApplicationInstance).Returns(application1.Object);

            var application2 = new Mock<HttpApplication>();
            application2.Setup(a => a.GetVaryByCustomString(It.IsAny<HttpContext>(), "foo")).Returns("2");
            var context2 = new MockActionExecutingContext();
            context2.SetupGet(c => c.HttpContext.ApplicationInstance).Returns(application2.Object);

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(@"VjXrM/nTu6zOLCi+teZcx7qDQRk/Q+G5ZirKHhH7MOA=", result1);
            Assert.Equal(@"Wi7TLgf052Ao0ZJX890MgynId6jByOf+xZ1G+5RHJUU=", result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_AllParametersByDefault()
        {
            // Arrange
            var attr = new OutputCacheAttribute();
            var context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            var context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "2";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal("tXBiB5qdEzfISoXUUqXAzPcd7y/9Ik6eFqy8w9i3aDw=", result1);
            Assert.Equal("Bb+E/t8aWfczVF2UFVr+FUpuGYjR/SPhzt71q+oAlHk=", result2);
        }

        [Fact]
        public void GetChildActionUniqueId_DoesNotVaryByActionParametersWhenVaryByParamIsNone()
        {
            // Arrange
            var attr = new OutputCacheAttribute { VaryByParam = "none" };
            var context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            var context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "2";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(result1, result2);
            Assert.Equal("IA6+zemlkqp8Ye59mwMEMYGo69mUVkAcFLa5z0keL50=", result1);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "bar" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "2";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(result1, result2);
            Assert.Equal("sx9+LHPOjtSGct8z6Cn4ml+2yKODPojZtrLhrhJofKM=", result1);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_SingleSpecified_Different()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "foo" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "2";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal("tXBiB5qdEzfISoXUUqXAzPcd7y/9Ik6eFqy8w9i3aDw=", result1);
            Assert.Equal("Bb+E/t8aWfczVF2UFVr+FUpuGYjR/SPhzt71q+oAlHk=", result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_SingleSpecified_Same()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "foo" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal("tXBiB5qdEzfISoXUUqXAzPcd7y/9Ik6eFqy8w9i3aDw=", result1);
            Assert.Equal("tXBiB5qdEzfISoXUUqXAzPcd7y/9Ik6eFqy8w9i3aDw=", result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_MultipleSpecified_Different()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "foo;bar;blap" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["bar"] = "2";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";
            context2.ActionParameters["bar"] = "3";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.NotEqual(result1, result2);
        }

        public static TheoryDataSet<ActionExecutingContext, string, string>
            GetUniqueIdFromActionParameters_ReturnsValuesThatExistInFilterContextData
        {
            get
            {
                TheoryDataSet<ActionExecutingContext, string, string> theoryData =
                    new TheoryDataSet<ActionExecutingContext, string, string>();

                MockActionExecutingContext context1 = new MockActionExecutingContext();
                context1.ActionParameters["foo"] = "foo-value";
                context1.ActionParameters["bar"] = "bar-value";
                context1.ActionParameters["blap"] = "blap-value";

                string expected1 = "[3]FOO[9]foo-value[3]BAR[9]bar-value[4]BLAP[10]blap-value";

                theoryData.Add(context1.Object, "foo;bar;blap", expected1);
                theoryData.Add(context1.Object, "foo; bar;  blap;", expected1);
                theoryData.Add(context1.Object, ";foo;   bar; blap  ", expected1);
                theoryData.Add(context1.Object, "foo; BAR;Blap", expected1);

                MockActionExecutingContext context2 = new MockActionExecutingContext();
                context2.ActionParameters["test"] = "test-value";
                context2.ActionParameters["shouldnot-exist"] = "shouldnot-exist";
                context2.ActionParameters["test2"] = "test2-value";

                theoryData.Add(context2.Object, "test;test2", "[4]TEST[10]test-value[5]TEST2[11]test2-value");
                theoryData.Add(context2.Object, "test;test3", "[4]TEST[10]test-value[5]TEST3[-1]");

                MockActionExecutingContext context3 = new MockActionExecutingContext();
                theoryData.Add(context3.Object, "test1;test2", "[5]TEST1[-1][5]TEST2[-1]");

                return theoryData;
            }
        }

        [Theory]
        [PropertyData("GetUniqueIdFromActionParameters_ReturnsValuesThatExistInFilterContextData")]
        public static void BuildUniqueIdFromActionParameters_UsesValuesForActionParametersThatExistInVaryByParams(
            ActionExecutingContext context, string varyByParam, string expected)
        {
            // Arrange
            StringBuilder builder = new StringBuilder();
            OutputCacheAttribute attribute = new OutputCacheAttribute { VaryByParam = varyByParam };

            // Act
            attribute.BuildUniqueIdFromActionParameters(builder, context);

            // Assert
            Assert.Equal(expected, builder.ToString());
        }

        [Theory]
        [InlineData("Foo;bar")]
        [InlineData("FOO;bAr")]
        [InlineData("foo;bar")]
        public static void BuildUniqueIdFromActionParameters_LooksUpActionParametersInCaseInsensitiveManner(
            string varyByParam)
        {
            // Arrange
            MockActionExecutingContext context = new MockActionExecutingContext();
            Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal)
            {
                { "foo",  "foo-value" },
                { "Bar", "bar-value" }
            };
            context.ActionParameters = dictionary;
            string expected = "[3]FOO[9]foo-value[3]BAR[9]bar-value";

            StringBuilder builder = new StringBuilder();
            OutputCacheAttribute attribute = new OutputCacheAttribute { VaryByParam = varyByParam };

            // Act
            attribute.BuildUniqueIdFromActionParameters(builder, context.Object);

            // Assert
            Assert.Equal(expected, builder.ToString());
        }

        [Theory]
        [InlineData("none")]
        [InlineData("NONE")]
        [InlineData("None")]
        public static void BuildUniqueIdFromActionParameters_NoOpsIfVaryByParamIsNone(string varyByParam)
        {
            // Arrange
            StringBuilder builder = new StringBuilder();
            ActionExecutingContext context = new MockActionExecutingContext().Object;
            OutputCacheAttribute attribute = new OutputCacheAttribute { VaryByParam = varyByParam };

            // Act
            attribute.BuildUniqueIdFromActionParameters(builder, context);

            // Assert
            Assert.Empty(builder.ToString());
        }

        [Fact]
        public static void BuildUniqueIdFromActionParameters_UsesAllActionParametersIfStar()
        {
            // Arrange
            OutputCacheAttribute attribute = new OutputCacheAttribute { VaryByParam = "*" };
            StringBuilder builder1 = new StringBuilder();
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["test1"] = "test1-value";
            context1.ActionParameters["test2"] = 3;
            context1.ActionParameters["test3"] = null;
            string expected = "[5]TEST1[11]test1-value[5]TEST2[1]3[5]TEST3[-1]";

            // Act - 1
            attribute.BuildUniqueIdFromActionParameters(builder1, context1.Object);

            // Assert - 1
            Assert.Equal(expected, builder1.ToString());

            // Arrange - 2
            // Verify that the keys are stable sorted when "*" is used.
            StringBuilder builder2 = new StringBuilder();
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["test3"] = null;
            context2.ActionParameters["test2"] = 3;
            context2.ActionParameters["test1"] = "test1-value";

            // Act - 2
            attribute.BuildUniqueIdFromActionParameters(builder2, context2.Object);

            // Assert - 2
            Assert.Equal(expected, builder2.ToString());
        }

        [Fact]
        public static void BuildUniqueIdFromActionParameters_DoesNotCacheTokenizedStringsWhenStar()
        {
            // Arrange
            OutputCacheAttribute attribute = new OutputCacheAttribute { VaryByParam = "*" };
            StringBuilder builder1 = new StringBuilder();
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["test1"] = "test1-value";
            context1.ActionParameters["test2"] = "Test2-Value";
            context1.ActionParameters["test3"] = null;
            string expected1 = "[5]TEST1[11]test1-value[5]TEST2[11]Test2-Value[5]TEST3[-1]";

            // Act - 1
            attribute.BuildUniqueIdFromActionParameters(builder1, context1.Object);

            // Assert - 1
            Assert.Equal(expected1, builder1.ToString());

            // Arrange - 2
            // Verify that the keys are stable sorted when "*" is used.
            StringBuilder builder2 = new StringBuilder();
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["Foo"] = null;
            context2.ActionParameters["bar"] = "bar-value";
            string expected2 = "[3]BAR[9]bar-value[3]FOO[-1]";

            // Act - 2
            attribute.BuildUniqueIdFromActionParameters(builder2, context2.Object);

            // Assert - 2
            Assert.Equal(expected2, builder2.ToString());
        }

        public static IEnumerable<string> VaryByParamWithWhitespaceData = new[]
        {
            "foo;bar;blap",
            "foo; bar; blap",
            ";foo; bar; blap",
            "  foo;   bar;  blap",
            "  foo;bar;  blap; ",
            "  ;foo;   bar  ;  blap; ",
        };

        public static IEnumerable<object[]> GetChildActionUniqueId_VariesByActionParametersData
        {
            get
            {
                return VaryByParamWithWhitespaceData.Select(v => new[] { v });
            }
        }

        [Theory]
        [PropertyData("GetChildActionUniqueId_VariesByActionParametersData")]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByGivenParameters(string varbyParam)
        {
            // Arrange
            string expected = "z2Fr6HAipKCkLdVkHMdHgeDBJyYutdqqTW07BMO31fQ=";
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = varbyParam };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["bar"] = "2";
            context1.ActionParameters["blap"] = "3";
            context1.ActionParameters["xyz"] = Guid.NewGuid().ToString();
            context1.ActionParameters["some-key"] = Guid.NewGuid().ToString();
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";
            context2.ActionParameters["bar"] = "2";
            context2.ActionParameters["blap"] = "3";
            context2.ActionParameters["xyz"] = Guid.NewGuid().ToString();
            context2.ActionParameters["different-key"] = Guid.NewGuid().ToString();

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(expected, result1);
            Assert.Equal(expected, result2);
        }

        public static IEnumerable<object[]> GetChildActionUniqueId_VariesByActionParameters_WithDifferentValuesData
        {
            get
            {
                return VaryByParamWithWhitespaceData.Select(v => new[] { v, "20", "34" });
            }
        }

        [Theory]
        [PropertyData("GetChildActionUniqueId_VariesByActionParameters_WithDifferentValuesData")]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_MultipleSpecified_WithDifferentValues(
            string varyByParam, string value1, string value2)
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = varyByParam };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = value1;
            context1.ActionParameters["bar"] = "2";
            context1.ActionParameters["blap"] = "3";
            context1.ActionParameters["xyz"] = "abc";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = value2;
            context2.ActionParameters["bar"] = "2";
            context2.ActionParameters["blap"] = "3";
            context2.ActionParameters["xyz"] = "abc";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal("WBXQR5lxerJG33HR3XQ9sJsXuKu6eVPgmMqeWMu8t2s=", result1);
            Assert.Equal("CLMC7fAU4959ECaI79HRFglt7SnNRANMJeYderjF4m8=", result2);
        }

        [Theory]
        [PropertyData("GetChildActionUniqueId_VariesByActionParameters_WithDifferentValuesData")]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_MultipleSpecified_Whitespace_DifferentSecond(
            string varyByParam, string value1, string value2)
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = varyByParam };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["bar"] = value1;
            context1.ActionParameters["blap"] = "3";
            context1.ActionParameters["xyz"] = "abc";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";
            context2.ActionParameters["bar"] = value2;
            context2.ActionParameters["blap"] = "3";
            context2.ActionParameters["xyz"] = "abc";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.NotEqual(result1, result2);
        }

        [Theory]
        [PropertyData("GetChildActionUniqueId_VariesByActionParameters_WithDifferentValuesData")]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_MultipleSpecified_Whitespace_DifferentThird(
            string varyByParam, string value1, string value2)
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = varyByParam };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["bar"] = "2";
            context1.ActionParameters["blap"] = value1;
            context1.ActionParameters["xyz"] = "abc";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";
            context2.ActionParameters["bar"] = "2";
            context2.ActionParameters["blap"] = value2;
            context2.ActionParameters["xyz"] = "abc";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.NotEqual(result1, result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_MatchesActionParametersInCaseInsensitiveManner()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "foo ; bar ; blap" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["BAR"] = "2";
            context1.ActionParameters["blap"] = "3";
            context1.ActionParameters["xyz"] = "abc";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";
            context2.ActionParameters["bar"] = "2";
            context2.ActionParameters["BLAP"] = "3";
            context2.ActionParameters["xyz"] = "abc";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(result1, result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_Wildcard_Same()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "*" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["bar"] = "2";
            context1.ActionParameters["blap"] = "3";
            context1.ActionParameters["xyz"] = "abc";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";
            context2.ActionParameters["bar"] = "2";
            context2.ActionParameters["blap"] = "3";
            context2.ActionParameters["xyz"] = "abc";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(result1, result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_Wildcard_CaseOnly_Same()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "*" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["bar"] = "2";
            context1.ActionParameters["BLAP"] = "3";
            context1.ActionParameters["xyz"] = "abc";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["FOO"] = "1";
            context2.ActionParameters["bar"] = "2";
            context2.ActionParameters["blap"] = "3";
            context2.ActionParameters["xyz"] = "abc";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(result1, result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_Wildcard_Different()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "*" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            context1.ActionParameters["bar"] = "2";
            context1.ActionParameters["blap"] = "3";
            context1.ActionParameters["xyz"] = "abc";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "1";
            context2.ActionParameters["bar"] = "4";
            context2.ActionParameters["blap"] = "3";
            context2.ActionParameters["xyz"] = "abc";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.NotEqual(result1, result2);
        }

        [Fact]
        public void GetChildActionUniqueId_VariesByActionParameters_OnlyVariesByTheGivenParameters_None()
        {
            // Arrange
            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "none" };
            MockActionExecutingContext context1 = new MockActionExecutingContext();
            context1.ActionParameters["foo"] = "1";
            MockActionExecutingContext context2 = new MockActionExecutingContext();
            context2.ActionParameters["foo"] = "2";

            // Act
            string result1 = attr.GetChildActionUniqueId(context1.Object);
            string result2 = attr.GetChildActionUniqueId(context2.Object);

            // Assert
            Assert.Equal(result1, result2);
        }

        [Theory]
        [InlineData("bar", "VmmIPvA0bdX40A9EDzcQdDGenn9mW2fLitLhN3Q+q0o=")]
        [InlineData("*", "lRpCzLPVjS7Lwbix/vbtbdUWELWQOxiJaVemFCgM0ew=")]
        [InlineData("none", "IA6+zemlkqp8Ye59mwMEMYGo69mUVkAcFLa5z0keL50=")]
        public void GetChildActionUniqueId_ReturnsDifferentValuesIfVaryByParamValueIsModified(string varyByParam, string expected)
        {
            // Arrange
            MockActionExecutingContext context = new MockActionExecutingContext();
            context.ActionParameters["foo"] = "1";
            context.ActionParameters["bar"] = "2";

            OutputCacheAttribute attr = new OutputCacheAttribute { VaryByParam = "foo" };

            // Act - 1
            string result1 = attr.GetChildActionUniqueId(context.Object);

            // Assert - 1
            Assert.Equal("tXBiB5qdEzfISoXUUqXAzPcd7y/9Ik6eFqy8w9i3aDw=", result1);

            // Act - 2
            attr.VaryByParam = varyByParam;
            string result2 = attr.GetChildActionUniqueId(context.Object);

            // Assert - 2
            Assert.Equal(expected, result2);
        }

        class MockActionExecutingContext : Mock<ActionExecutingContext>
        {
            // StringComparer.OrdinalIgnoreCase matches the behavior of ControllerActionInvoker.
            public Dictionary<string, object> ActionParameters = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);

            public MockActionExecutingContext()
            {
                Setup(c => c.ActionDescriptor.UniqueId).Returns("abc123");
                Setup(c => c.ActionParameters).Returns(() => ActionParameters);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/OverrideActionFiltersAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc.Test
{
    public class OverrideActionFiltersAttributeTests : OverrideFiltersAttributeTests
    {
        protected override Type ExpectedFiltersToOverride
        {
            get { return typeof(IActionFilter); }
        }
        
        protected override Type ProductUnderTestType
        {
            get { return typeof(OverrideActionFiltersAttribute); }
        }

        protected override IOverrideFilter CreateProductUnderTest()
        {
            return new OverrideActionFiltersAttribute();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/OverrideAuthenticationAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc.Test
{
    public class OverrideAuthenticationAttributeTests : OverrideFiltersAttributeTests
    {
        protected override Type ExpectedFiltersToOverride
        {
            get { return typeof(IAuthenticationFilter); }
        }
        
        protected override Type ProductUnderTestType
        {
            get { return typeof(OverrideAuthenticationAttribute); }
        }

        protected override IOverrideFilter CreateProductUnderTest()
        {
            return new OverrideAuthenticationAttribute();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/OverrideAuthorizationAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc.Test
{
    public class OverrideAuthorizationAttributeTests : OverrideFiltersAttributeTests
    {
        protected override Type ExpectedFiltersToOverride
        {
            get { return typeof(IAuthorizationFilter); }
        }
        
        protected override Type ProductUnderTestType
        {
            get { return typeof(OverrideAuthorizationAttribute); }
        }

        protected override IOverrideFilter CreateProductUnderTest()
        {
            return new OverrideAuthorizationAttribute();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/OverrideExceptionFiltersAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc.Test
{
    public class OverrideExceptionFiltersAttributeTests : OverrideFiltersAttributeTests
    {
        protected override Type ExpectedFiltersToOverride
        {
            get { return typeof(IExceptionFilter); }
        }
        
        protected override Type ProductUnderTestType
        {
            get { return typeof(OverrideExceptionFiltersAttribute); }
        }

        protected override IOverrideFilter CreateProductUnderTest()
        {
            return new OverrideExceptionFiltersAttribute();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/OverrideFiltersAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc.Filters;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public abstract class OverrideFiltersAttributeTests
    {
        protected abstract Type ProductUnderTestType { get; }

        protected abstract Type ExpectedFiltersToOverride { get; }

        [Fact]
        public void FiltersToOverride_IsIActionFilter()
        {
            // Arrange
            IOverrideFilter product = CreateProductUnderTest();

            // Act
            Type filtersToOverride = product.FiltersToOverride;

            // Assert
            Assert.Same(ExpectedFiltersToOverride, filtersToOverride);
        }

        [Fact]
        public void AttributeUsage_IsAsSpecified()
        {
            // Act
            AttributeUsageAttribute usage = (AttributeUsageAttribute)Attribute.GetCustomAttribute(ProductUnderTestType,
                typeof(AttributeUsageAttribute));

            // Assert
            Assert.NotNull(usage);
            Assert.Equal(AttributeTargets.Class | AttributeTargets.Method, usage.ValidOn);
            Assert.True(usage.Inherited);
            Assert.False(usage.AllowMultiple);
        }

        [Fact]
        public void Integration_FilterAttributeFilterProvider_PassesThroughInstance()
        {
            // Arrange
            object expected = CreateProductUnderTest();
            FilterAttributeFilterProvider integrator = new FilterAttributeFilterProvider();
            ActionDescriptor actionDescriptor = CreateActionDescriptor(expected);
            ControllerContext controllerContext = CreateControllerContext();

            // Act
            IEnumerable<Filter> filters = integrator.GetFilters(controllerContext, actionDescriptor);

            // Assert
            Assert.NotNull(filters);
            Filter filter = Assert.Single(filters);
            Assert.NotNull(filter);
            Assert.Same(expected, filter.Instance);
        }

        private static ActionDescriptor CreateActionDescriptor(object filter)
        {
            Mock<ActionDescriptor> mock = new Mock<ActionDescriptor>(MockBehavior.Strict);
            FilterAttribute attribute = filter as FilterAttribute;
            mock.Setup(d => d.GetFilterAttributes(It.IsAny<bool>()))
                .Returns(attribute != null ? new FilterAttribute[] { attribute } : new FilterAttribute[0]);
            mock.Setup(d => d.ControllerDescriptor).Returns(new Mock<ControllerDescriptor>().Object);
            return mock.Object;
        }

        private static ControllerContext CreateControllerContext()
        {
            Mock<ControllerContext> mock = new Mock<ControllerContext>();
            mock.SetupGet(c => c.Controller).Returns(new Mock<ControllerBase>(MockBehavior.Strict).Object);
            return mock.Object;
        }

        protected abstract IOverrideFilter CreateProductUnderTest();
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/OverrideResultFiltersAttributeTests.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Filters;

namespace System.Web.Mvc.Test
{
    public class OverrideResultFiltersAttributeTests : OverrideFiltersAttributeTests
    {
        protected override Type ExpectedFiltersToOverride
        {
            get { return typeof(IResultFilter); }
        }
        
        protected override Type ProductUnderTestType
        {
            get { return typeof(OverrideResultFiltersAttribute); }
        }

        protected override IOverrideFilter CreateProductUnderTest()
        {
            return new OverrideResultFiltersAttribute();
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ParameterBindingInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ParameterBindingInfoTest
    {
        [Fact]
        public void BinderProperty()
        {
            // Arrange
            ParameterBindingInfo bindingInfo = new ParameterBindingInfoHelper();

            // Act & assert
            Assert.Null(bindingInfo.Binder);
        }

        [Fact]
        public void ExcludeProperty()
        {
            // Arrange
            ParameterBindingInfo bindingInfo = new ParameterBindingInfoHelper();

            // Act
            ICollection<string> exclude = bindingInfo.Exclude;

            // Assert
            Assert.NotNull(exclude);
            Assert.Empty(exclude);
        }

        [Fact]
        public void IncludeProperty()
        {
            // Arrange
            ParameterBindingInfo bindingInfo = new ParameterBindingInfoHelper();

            // Act
            ICollection<string> include = bindingInfo.Include;

            // Assert
            Assert.NotNull(include);
            Assert.Empty(include);
        }

        [Fact]
        public void PrefixProperty()
        {
            // Arrange
            ParameterBindingInfo bindingInfo = new ParameterBindingInfoHelper();

            // Act & assert
            Assert.Null(bindingInfo.Prefix);
        }

        private class ParameterBindingInfoHelper : ParameterBindingInfo
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ParameterDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ParameterDescriptorTest
    {
        [Fact]
        public void BindingInfoProperty()
        {
            // Arrange
            ParameterDescriptor pd = GetParameterDescriptor(typeof(object), "someName");

            // Act
            ParameterBindingInfo bindingInfo = pd.BindingInfo;

            // Assert
            Assert.IsType(typeof(ParameterDescriptor).GetNestedType("EmptyParameterBindingInfo", BindingFlags.NonPublic),
                          bindingInfo);
        }

        [Fact]
        public void DefaultValuePropertyDefaultsToNull()
        {
            // Arrange
            ParameterDescriptor pd = GetParameterDescriptor();

            // Act
            object defaultValue = pd.DefaultValue;

            // Assert
            Assert.Null(defaultValue);
        }

        [Fact]
        public void GetCustomAttributesReturnsEmptyArrayOfAttributeType()
        {
            // Arrange
            ParameterDescriptor pd = GetParameterDescriptor();

            // Act
            ObsoleteAttribute[] attrs = (ObsoleteAttribute[])pd.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Empty(attrs);
        }

        [Fact]
        public void GetCustomAttributesThrowsIfAttributeTypeIsNull()
        {
            // Arrange
            ParameterDescriptor pd = GetParameterDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { pd.GetCustomAttributes(null /* attributeType */, true); }, "attributeType");
        }

        [Fact]
        public void GetCustomAttributesWithoutAttributeTypeCallsGetCustomAttributesWithAttributeType()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<ParameterDescriptor> mockDescriptor = new Mock<ParameterDescriptor>() { CallBase = true };
            mockDescriptor.Setup(d => d.GetCustomAttributes(typeof(object), true)).Returns(expected);
            ParameterDescriptor pd = mockDescriptor.Object;

            // Act
            object[] returned = pd.GetCustomAttributes(true /* inherit */);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void IsDefinedReturnsFalse()
        {
            // Arrange
            ParameterDescriptor pd = GetParameterDescriptor();

            // Act
            bool isDefined = pd.IsDefined(typeof(object), true);

            // Assert
            Assert.False(isDefined);
        }

        [Fact]
        public void IsDefinedThrowsIfAttributeTypeIsNull()
        {
            // Arrange
            ParameterDescriptor pd = GetParameterDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { pd.IsDefined(null /* attributeType */, true); }, "attributeType");
        }

        private static ParameterDescriptor GetParameterDescriptor()
        {
            return GetParameterDescriptor(typeof(object), "someName");
        }

        private static ParameterDescriptor GetParameterDescriptor(Type type, string name)
        {
            Mock<ParameterDescriptor> mockDescriptor = new Mock<ParameterDescriptor>() { CallBase = true };
            mockDescriptor.Setup(d => d.ParameterType).Returns(type);
            mockDescriptor.Setup(d => d.ParameterName).Returns(name);
            return mockDescriptor.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ParameterInfoUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ParameterInfoUtilTest
    {
        [Fact]
        public void TryGetDefaultValue_FirstChecksDefaultValue()
        {
            // Arrange
            Mock<ParameterInfo> mockPInfo = new Mock<ParameterInfo>() { DefaultValue = DefaultValue.Mock };
            mockPInfo.Setup(p => p.DefaultValue).Returns(42);
            mockPInfo.Setup(p => p.Name).Returns("someParameter");

            // Act
            object defaultValue;
            bool retVal = ParameterInfoUtil.TryGetDefaultValue(mockPInfo.Object, out defaultValue);

            // Assert
            Assert.True(retVal);
            Assert.Equal(42, defaultValue);
        }

        [Fact]
        public void TryGetDefaultValue_SecondChecksDefaultValueAttribute()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("DefaultValues").GetParameters()[1]; // hasDefaultValue

            // Act
            object defaultValue;
            bool retVal = ParameterInfoUtil.TryGetDefaultValue(pInfo, out defaultValue);

            // Assert
            Assert.True(retVal);
            Assert.Equal("someValue", defaultValue);
        }

        [Fact]
        public void TryGetDefaultValue_RespectsNullDefaultValue()
        {
            // Arrange
            Mock<ParameterInfo> mockPInfo = new Mock<ParameterInfo>() { DefaultValue = DefaultValue.Mock };
            mockPInfo.Setup(p => p.DefaultValue).Returns(null);
            mockPInfo.Setup(p => p.Name).Returns("someParameter");
            mockPInfo
                .Setup(p => p.GetCustomAttributes(typeof(DefaultValueAttribute[]), false))
                .Returns(new DefaultValueAttribute[] { new DefaultValueAttribute(42) });

            // Act
            object defaultValue;
            bool retVal = ParameterInfoUtil.TryGetDefaultValue(mockPInfo.Object, out defaultValue);

            // Assert
            Assert.True(retVal);
            Assert.Null(defaultValue);
        }

        [Fact]
        public void TryGetDefaultValue_ReturnsFalseIfNoDefaultValue()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("DefaultValues").GetParameters()[0]; // noDefaultValue

            // Act
            object defaultValue;
            bool retVal = ParameterInfoUtil.TryGetDefaultValue(pInfo, out defaultValue);

            // Assert
            Assert.False(retVal);
            Assert.Equal(default(object), defaultValue);
        }

        [Fact]
        public void TryGetDefaultValue_DefaultValueAttributeParameters()
        {
            DefaultValueAttributeHelper<bool>(true, "boolParam");
            DefaultValueAttributeHelper<byte>(42, "byteParam");
            DefaultValueAttributeHelper<char>('a', "charParam");
            DefaultValueAttributeHelper<double>(1.0, "doubleParam");
            DefaultValueAttributeHelper<MyEnum>(MyEnum.All, "enumParam");
            DefaultValueAttributeHelper<float>((float)1.0, "floatParam");
            DefaultValueAttributeHelper<int>(42, "intParam");
            DefaultValueAttributeHelper<long>(42, "longParam");
            DefaultValueAttributeHelper<object>(null, "objectParam");
            DefaultValueAttributeHelper<short>(42, "shortParam");
            DefaultValueAttributeHelper<string>("abc", "stringParam");
            DefaultValueAttributeHelper<DateTime>(new DateTime(2010, 09, 27), "customParam");
        }

        [Fact]
        public void TryGetDefaultValue_OptionalParameters()
        {
            OptionalParamHelper<bool>(true, "boolParam");
            OptionalParamHelper<byte>(42, "byteParam");
            OptionalParamHelper<char>('a', "charParam");
            OptionalParamHelper<double>(1.0, "doubleParam");
            OptionalParamHelper<MyEnum>(MyEnum.All, "enumParam");
            OptionalParamHelper<float>((float)1.0, "floatParam");
            OptionalParamHelper<int>(42, "intParam");
            OptionalParamHelper<long>(42, "longParam");
            OptionalParamHelper<object>(null, "objectParam");
            OptionalParamHelper<short>(42, "shortParam");
            OptionalParamHelper<string>("abc", "stringParam");
        }

        private static void DefaultValueAttributeHelper<TParam>(TParam expectedValue, string paramName)
        {
            ParameterTestHelper<TParam>(expectedValue, paramName, "AttributeDefaultValues");
        }

        private static void OptionalParamHelper<TParam>(TParam expectedValue, string paramName)
        {
            ParameterTestHelper<TParam>(expectedValue, paramName, "OptionalParamDefaultValues");
        }

        private static void ParameterTestHelper<TParam>(TParam expectedValue, string paramName, string actionMethodName)
        {
            ParameterInfo pInfo = typeof(MyController).GetMethod(actionMethodName).GetParameters().Single(p => p.Name == paramName);
            object returnValueObject;
            bool result = ParameterInfoUtil.TryGetDefaultValue(pInfo, out returnValueObject);

            Assert.True(result);
            if (expectedValue != null)
            {
                Assert.IsType<TParam>(returnValueObject);
            }
            TParam returnValue = (TParam)returnValueObject;
            Assert.Equal<TParam>(expectedValue, returnValue);
        }

        private class MyController : Controller
        {
            public void DefaultValues(string noDefaultValue, [DefaultValue("someValue")] string hasDefaultValue)
            {
            }

            public void AttributeDefaultValues(
                [DefaultValue(true)] bool boolParam,
                [DefaultValue((byte)42)] byte byteParam,
                [DefaultValue('a')] char charParam,
                [DefaultValue(typeof(DateTime), "2010-09-27")] object customParam,
                [DefaultValue((double)1.0)] double doubleParam,
                [DefaultValue(MyEnum.All)] MyEnum enumParam,
                [DefaultValue((float)1.0)] float floatParam,
                [DefaultValue(42)] int intParam,
                [DefaultValue((long)42)] long longParam,
                [DefaultValue(null)] object objectParam,
                [DefaultValue((short)42)] short shortParam,
                [DefaultValue("abc")] string stringParam
                )
            {
            }

            public void OptionalParamDefaultValues(
                bool boolParam = true,
                byte byteParam = 42,
                char charParam = 'a',
                double doubleParam = 1.0,
                MyEnum enumParam = MyEnum.All,
                float floatParam = (float)1.0,
                int intParam = 42,
                long longParam = 42,
                object objectParam = null,
                short shortParam = 42,
                string stringParam = "abc"
                )
            {
            }
        }

        private enum MyEnum
        {
            None = 0,
            All = 1
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/PartialViewResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class PartialViewResultTest
    {
        private const string _viewName = "My cool partial view.";

        [Fact]
        public void EmptyViewNameUsesActionNameAsViewName()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = _viewName;
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IViewEngine> viewEngine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            List<IViewEngine> viewEngines = new List<IViewEngine>();
            viewEngines.Add(viewEngine.Object);
            Mock<ViewEngineCollection> viewEngineCollection = new Mock<ViewEngineCollection>(MockBehavior.Strict, viewEngines);
            PartialViewResult result = new PartialViewResultHelper { ViewEngineCollection = viewEngineCollection.Object };
            viewEngine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName, It.IsAny<bool>()))
                .Callback<ControllerContext, string, bool>(
                    (controllerContext, viewName, useCache) =>
                    {
                        Assert.Same(httpContext, controllerContext.HttpContext);
                        Assert.Same(routeData, controllerContext.RouteData);
                    })
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            viewEngineCollection
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName))
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            view
                .Setup(o => o.Render(It.IsAny<ViewContext>(), httpContext.Response.Output))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.Same(view.Object, viewContext.View);
                        Assert.Same(result.ViewData, viewContext.ViewData);
                        Assert.Same(result.TempData, viewContext.TempData);
                        Assert.Same(controller, viewContext.Controller);
                    });
            viewEngine
                .Setup(e => e.ReleaseView(context, It.IsAny<IView>()))
                .Callback<ControllerContext, IView>(
                    (controllerContext, releasedView) => { Assert.Same(releasedView, view.Object); });

            // Act
            result.ExecuteResult(context);

            // Assert
            viewEngine.Verify();
            viewEngineCollection.Verify();
            view.Verify();
        }

        [Fact]
        public void EngineLookupFailureThrows()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = _viewName;
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IViewEngine> viewEngine = new Mock<IViewEngine>(MockBehavior.Strict);
            List<IViewEngine> viewEngines = new List<IViewEngine>();
            viewEngines.Add(viewEngine.Object);
            Mock<ViewEngineCollection> viewEngineCollection = new Mock<ViewEngineCollection>(MockBehavior.Strict, viewEngines);
            PartialViewResult result = new PartialViewResultHelper { ViewEngineCollection = viewEngineCollection.Object };
            viewEngineCollection
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName))
                .Returns(new ViewEngineResult(new[] { "location1", "location2" }));
            viewEngine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName, It.IsAny<bool>()))
                .Callback<ControllerContext, string, bool>(
                    (controllerContext, viewName, useCache) =>
                    {
                        Assert.Same(httpContext, controllerContext.HttpContext);
                        Assert.Same(routeData, controllerContext.RouteData);
                    })
                .Returns(new ViewEngineResult(new[] { "location1", "location2" }));

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => result.ExecuteResult(context),
                "The partial view '" + _viewName + "' was not found or no view engine supports the searched locations. The following locations were searched:" + Environment.NewLine
              + "location1" + Environment.NewLine
              + "location2");

            viewEngine.Verify();
            viewEngineCollection.Verify();
        }

        [Fact]
        public void EngineLookupSuccessRendersView()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IViewEngine> viewEngine = new Mock<IViewEngine>(MockBehavior.Strict);
            List<IViewEngine> viewEngines = new List<IViewEngine>();
            viewEngines.Add(viewEngine.Object);
            Mock<ViewEngineCollection> viewEngineCollection = new Mock<ViewEngineCollection>(MockBehavior.Strict, viewEngines);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            PartialViewResult result = new PartialViewResultHelper { ViewEngineCollection = viewEngineCollection.Object, ViewName = _viewName };
            view
                .Setup(o => o.Render(It.IsAny<ViewContext>(), httpContext.Response.Output))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.Same(view.Object, viewContext.View);
                        Assert.Same(result.ViewData, viewContext.ViewData);
                        Assert.Same(result.TempData, viewContext.TempData);
                        Assert.Same(controller, viewContext.Controller);
                    });
            viewEngineCollection
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName))
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            viewEngine
                .Setup(e => e.FindPartialView(It.IsAny<ControllerContext>(), _viewName, It.IsAny<bool>()))
                .Callback<ControllerContext, string, bool>(
                    (controllerContext, viewName, useCache) =>
                    {
                        Assert.Same(httpContext, controllerContext.HttpContext);
                        Assert.Same(routeData, controllerContext.RouteData);
                    })
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            viewEngine
                .Setup(e => e.ReleaseView(context, It.IsAny<IView>()))
                .Callback<ControllerContext, IView>(
                    (controllerContext, releasedView) => { Assert.Same(releasedView, view.Object); });

            // Act
            result.ExecuteResult(context);

            // Assert
            viewEngineCollection.Verify();
            viewEngine.Verify();
            view.Verify();
        }

        [Fact]
        public void ExecuteResultWithExplicitViewObject()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = _viewName;
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            PartialViewResult result = new PartialViewResultHelper { View = view.Object };
            view
                .Setup(o => o.Render(It.IsAny<ViewContext>(), httpContext.Response.Output))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.Same(view.Object, viewContext.View);
                        Assert.Same(result.ViewData, viewContext.ViewData);
                        Assert.Same(result.TempData, viewContext.TempData);
                        Assert.Same(controller, viewContext.Controller);
                    });

            // Act
            result.ExecuteResult(context);

            // Assert
            view.Verify();
        }

        private static HttpContextBase CreateHttpContext()
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.Response.Output).Returns(TextWriter.Null);
            return mockHttpContext.Object;
        }

        private class PartialViewResultHelper : PartialViewResult
        {
            public PartialViewResultHelper()
            {
                ViewEngineCollection = new ViewEngineCollection(new IViewEngine[] { new WebFormViewEngine() });
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/PreApplicationStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Reflection;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class PreApplicationStartCodeTest
    {
        [Fact]
        public void PreApplicationStartCodeIsNotBrowsableTest()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }

        [Fact]
        public void PreApplicationStartMethodAttributeTest()
        {
            Assembly assembly = typeof(Controller).Assembly;
            object[] attributes = assembly.GetCustomAttributes(typeof(PreApplicationStartMethodAttribute), true);
            var preAppStartMethodAttribute = Assert.Single(attributes.Cast<PreApplicationStartMethodAttribute>());
            Type preAppStartMethodType = preAppStartMethodAttribute.Type;
            Assert.Equal(typeof(PreApplicationStartCode), preAppStartMethodType);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/QueryStringValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class QueryStringValueProviderFactoryTest
    {
        private static readonly NameValueCollection _backingStore = new NameValueCollection()
        {
            { "foo", "fooValue" }
        };

        private static readonly NameValueCollection _unvalidatedBackingStore = new NameValueCollection()
        {
            { "foo", "fooUnvalidated" }
        };

        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            Mock<MockableUnvalidatedRequestValues> mockUnvalidatedValues = new Mock<MockableUnvalidatedRequestValues>();
            QueryStringValueProviderFactory factory = new QueryStringValueProviderFactory(_ => mockUnvalidatedValues.Object);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.QueryString).Returns(_backingStore);

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Equal(typeof(QueryStringValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("foo");

            Assert.NotNull(vpResult);
            Assert.Equal("fooValue", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProvider_GetValue_SkipValidation()
        {
            // Arrange
            Mock<MockableUnvalidatedRequestValues> mockUnvalidatedValues = new Mock<MockableUnvalidatedRequestValues>();
            mockUnvalidatedValues.Setup(o => o.QueryString).Returns(_unvalidatedBackingStore);
            QueryStringValueProviderFactory factory = new QueryStringValueProviderFactory(_ => mockUnvalidatedValues.Object);

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Request.QueryString).Returns(_backingStore);

            // Act
            IUnvalidatedValueProvider valueProvider = (IUnvalidatedValueProvider)factory.GetValueProvider(mockControllerContext.Object);

            // Assert
            Assert.Equal(typeof(QueryStringValueProvider), valueProvider.GetType());
            ValueProviderResult vpResult = valueProvider.GetValue("foo", skipValidation: true);

            Assert.NotNull(vpResult);
            Assert.Equal("fooUnvalidated", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProvider_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            QueryStringValueProviderFactory factory = new QueryStringValueProviderFactory();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { factory.GetValueProvider(null); }, "controllerContext");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RangeAttributeAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class RangeAttributeAdapterTest
    {
        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithRangeAttribute()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length");
            var context = new ControllerContext();
            var attribute = new RangeAttribute(typeof(decimal), "0", "100");
            var adapter = new RangeAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("range", rule.ValidationType);
            Assert.Equal(2, rule.ValidationParameters.Count);
            Assert.Equal(0m, rule.ValidationParameters["min"]);
            Assert.Equal(100m, rule.ValidationParameters["max"]);
            Assert.Equal(@"The field Length must be between 0 and 100.", rule.ErrorMessage);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RazorViewEngineTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class RazorViewEngineTest
    {
        [Fact]
        public void AreaMasterLocationFormats()
        {
            // Arrange
            string[] expected = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.cshtml",
                "~/Areas/{2}/Views/{1}/{0}.vbhtml",
                "~/Areas/{2}/Views/Shared/{0}.cshtml",
                "~/Areas/{2}/Views/Shared/{0}.vbhtml"
            };

            // Act
            RazorViewEngine viewEngine = new RazorViewEngine();

            // Assert
            Assert.Equal(expected, viewEngine.AreaMasterLocationFormats);
        }

        [Fact]
        public void AreaPartialViewLocationFormats()
        {
            // Arrange
            string[] expected = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.cshtml",
                "~/Areas/{2}/Views/{1}/{0}.vbhtml",
                "~/Areas/{2}/Views/Shared/{0}.cshtml",
                "~/Areas/{2}/Views/Shared/{0}.vbhtml"
            };

            // Act
            RazorViewEngine viewEngine = new RazorViewEngine();

            // Assert
            Assert.Equal(expected, viewEngine.AreaPartialViewLocationFormats);
        }

        [Fact]
        public void AreaViewLocationFormats()
        {
            // Arrange
            string[] expected = new[]
            {
                "~/Areas/{2}/Views/{1}/{0}.cshtml",
                "~/Areas/{2}/Views/{1}/{0}.vbhtml",
                "~/Areas/{2}/Views/Shared/{0}.cshtml",
                "~/Areas/{2}/Views/Shared/{0}.vbhtml"
            };

            // Act
            RazorViewEngine viewEngine = new RazorViewEngine();

            // Assert
            Assert.Equal(expected, viewEngine.AreaViewLocationFormats);
        }

        [Fact]
        public void RazorViewEngineSetsViewPageActivator()
        {
            // Arrange
            Mock<IViewPageActivator> viewPageActivator = new Mock<IViewPageActivator>();
            TestableRazorViewEngine viewEngine = new TestableRazorViewEngine(viewPageActivator.Object);

            //Act & Assert
            Assert.Equal(viewPageActivator.Object, viewEngine.ViewPageActivator);
        }

        [Fact]
        public void CreatePartialView_PassesViewPageActivator()
        {
            // Arrange
            Mock<IViewPageActivator> viewPageActivator = new Mock<IViewPageActivator>();
            TestableRazorViewEngine viewEngine = new TestableRazorViewEngine(viewPageActivator.Object);

            // Act
            RazorView result = (RazorView)viewEngine.CreatePartialView("partial path");

            // Assert
            Assert.Equal(viewEngine.ViewPageActivator, result.ViewPageActivator);
        }

        [Fact]
        public void CreateView_PassesViewPageActivator()
        {
            // Arrange
            Mock<IViewPageActivator> viewPageActivator = new Mock<IViewPageActivator>();
            TestableRazorViewEngine viewEngine = new TestableRazorViewEngine(viewPageActivator.Object);

            // Act
            RazorView result = (RazorView)viewEngine.CreateView("partial path", "master path");

            // Assert
            Assert.Equal(viewEngine.ViewPageActivator, result.ViewPageActivator);
        }

        [Fact]
        public void CreatePartialView_ReturnsRazorView()
        {
            // Arrange
            TestableRazorViewEngine viewEngine = new TestableRazorViewEngine();

            // Act
            RazorView result = (RazorView)viewEngine.CreatePartialView("partial path");

            // Assert
            Assert.Equal("partial path", result.ViewPath);
            Assert.Equal(String.Empty, result.LayoutPath);
            Assert.False(result.RunViewStartPages);
        }

        [Fact]
        public void CreateView_ReturnsRazorView()
        {
            // Arrange
            TestableRazorViewEngine viewEngine = new TestableRazorViewEngine()
            {
                FileExtensions = new[] { "cshtml", "vbhtml", "razor" }
            };

            // Act
            RazorView result = (RazorView)viewEngine.CreateView("partial path", "master path");

            // Assert
            Assert.Equal("partial path", result.ViewPath);
            Assert.Equal("master path", result.LayoutPath);
            Assert.Equal(new[] { "cshtml", "vbhtml", "razor" }, result.ViewStartFileExtensions.ToArray());
            Assert.True(result.RunViewStartPages);
        }

        [Fact]
        public void FileExtensionsProperty()
        {
            // Arrange
            string[] expected = new[]
            {
                "cshtml",
                "vbhtml",
            };

            // Act
            RazorViewEngine viewEngine = new RazorViewEngine();

            // Assert
            Assert.Equal(expected, viewEngine.FileExtensions);
        }

        [Fact]
        public void MasterLocationFormats()
        {
            // Arrange
            string[] expected = new[]
            {
                "~/Views/{1}/{0}.cshtml",
                "~/Views/{1}/{0}.vbhtml",
                "~/Views/Shared/{0}.cshtml",
                "~/Views/Shared/{0}.vbhtml"
            };

            // Act
            RazorViewEngine viewEngine = new RazorViewEngine();

            // Assert
            Assert.Equal(expected, viewEngine.MasterLocationFormats);
        }

        [Fact]
        public void PartialViewLocationFormats()
        {
            // Arrange
            string[] expected = new[]
            {
                "~/Views/{1}/{0}.cshtml",
                "~/Views/{1}/{0}.vbhtml",
                "~/Views/Shared/{0}.cshtml",
                "~/Views/Shared/{0}.vbhtml"
            };

            // Act
            RazorViewEngine viewEngine = new RazorViewEngine();

            // Assert
            Assert.Equal(expected, viewEngine.PartialViewLocationFormats);
        }

        [Fact]
        public void ViewLocationFormats()
        {
            // Arrange
            string[] expected = new[]
            {
                "~/Views/{1}/{0}.cshtml",
                "~/Views/{1}/{0}.vbhtml",
                "~/Views/Shared/{0}.cshtml",
                "~/Views/Shared/{0}.vbhtml"
            };

            // Act
            RazorViewEngine viewEngine = new RazorViewEngine();

            // Assert
            Assert.Equal(expected, viewEngine.ViewLocationFormats);
        }

        [Fact]
        public void ViewStartFileName()
        {
            Assert.Equal("_ViewStart", RazorViewEngine.ViewStartFileName);
        }

        private sealed class TestableRazorViewEngine : RazorViewEngine
        {
            public TestableRazorViewEngine()
                : base()
            {
            }

            public TestableRazorViewEngine(IViewPageActivator viewPageActivator)
                : base(viewPageActivator)
            {
            }

            public new IViewPageActivator ViewPageActivator
            {
                get { return base.ViewPageActivator; }
            }

            public IView CreatePartialView(string partialPath)
            {
                return base.CreatePartialView(new ControllerContext(), partialPath);
            }

            public IView CreateView(string viewPath, string masterPath)
            {
                return base.CreateView(new ControllerContext(), viewPath, masterPath);
            }

            // This method should remain overridable in derived view engines
            protected override bool FileExists(ControllerContext controllerContext, string virtualPath)
            {
                return base.FileExists(controllerContext, virtualPath);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RazorViewTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class RazorViewTest
    {
        [Fact]
        public void Constructor_RunViewStartPagesParam()
        {
            var context = new ControllerContext();
            Assert.True(new RazorView(context, "~/view", "~/master", runViewStartPages: true, viewStartFileExtensions: null).RunViewStartPages);
            Assert.False(new RazorView(context, "~/view", "~/master", runViewStartPages: false, viewStartFileExtensions: null).RunViewStartPages);
            Assert.True(new RazorView(context, "~/view", "~/master", runViewStartPages: true, viewStartFileExtensions: null, viewPageActivator: new Mock<IViewPageActivator>().Object).RunViewStartPages);
            Assert.False(new RazorView(context, "~/view", "~/master", runViewStartPages: false, viewStartFileExtensions: null, viewPageActivator: new Mock<IViewPageActivator>().Object).RunViewStartPages);
        }

        [Fact]
        public void ConstructorWithEmptyViewPathThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new RazorView(new ControllerContext(), String.Empty, "~/master", false, Enumerable.Empty<string>()),
                "viewPath"
                );
        }

        [Fact]
        public void ConstructorWithNullViewPathThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new RazorView(new ControllerContext(), null, "~/master", false, Enumerable.Empty<string>()),
                "viewPath"
                );
        }

        [Fact]
        public void ConstructorWithNullControllerContextThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new RazorView(null, "view path", "~/master", false, Enumerable.Empty<string>()),
                "controllerContext"
                );
        }

        [Fact]
        public void LayoutPathProperty()
        {
            //Arrange
            ControllerContext controllerContext = new ControllerContext();

            // Act
            RazorView view = new RazorView(new ControllerContext(), "view path", "master path", false, Enumerable.Empty<string>());

            // Assert
            Assert.Equal("master path", view.LayoutPath);
        }

        [Fact]
        public void LayoutPathPropertyReturnsEmptyStringIfNullLayoutSpecified()
        {
            // Act
            RazorView view = new RazorView(new ControllerContext(), "view path", null, false, Enumerable.Empty<string>());

            // Assert
            Assert.Equal(String.Empty, view.LayoutPath);
        }

        [Fact]
        public void LayoutPathPropertyReturnsEmptyStringIfLayoutNotSpecified()
        {
            // Act
            RazorView view = new RazorView(new ControllerContext(), "view path", null, false, Enumerable.Empty<string>());

            // Assert
            Assert.Equal(String.Empty, view.LayoutPath);
        }

        [Fact]
        public void RenderWithNullWriterThrows()
        {
            // Arrange
            RazorView view = new RazorView(new ControllerContext(), "~/viewPath", null, false, Enumerable.Empty<string>());
            Mock<ViewContext> viewContextMock = new Mock<ViewContext>();

            MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
            view.BuildManager = buildManager;

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => view.Render(viewContextMock.Object, null),
                "writer"
                );
        }

        [Fact]
        public void RenderWithUnsupportedTypeThrows()
        {
            // Arrange
            ViewContext context = new Mock<ViewContext>().Object;
            MockBuildManager buildManagerMock = new MockBuildManager("view path", typeof(object));
            RazorView view = new RazorView(new ControllerContext(), "view path", null, false, Enumerable.Empty<string>());
            view.BuildManager = buildManagerMock;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => view.Render(context, new Mock<TextWriter>().Object),
                "The view at 'view path' must derive from WebViewPage, or WebViewPage<TModel>."
                );
        }

        [Fact]
        public void RenderWithViewPageAndNoStartPageLookupRendersView()
        {
            // Arrange
            StubWebViewPage viewPage = new StubWebViewPage();
            Mock<ViewContext> viewContextMock = new Mock<ViewContext>();
            viewContextMock.Setup(vc => vc.HttpContext.Items).Returns(new Dictionary<object, object>());
            viewContextMock.Setup(vc => vc.HttpContext.Request.IsLocal).Returns(false);
            MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
            ControllerContext controllerContext = new ControllerContext();
            activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
            RazorView view = new RazorView(controllerContext, "~/viewPath", null, false, Enumerable.Empty<string>(), activator.Object);
            view.StartPageLookup = (WebPageRenderingBase p, string n, IEnumerable<string> e) =>
            {
                Assert.True(false, "ViewStart page lookup should not be called");
                return null;
            };
            view.BuildManager = buildManager;

            // Act
            view.Render(viewContextMock.Object, new Mock<TextWriter>().Object);

            // Assert
            Assert.Null(viewPage.Layout);
            Assert.Equal("", viewPage.OverridenLayoutPath);
            Assert.Same(viewContextMock.Object, viewPage.ViewContext);
            Assert.Equal("~/viewPath", viewPage.VirtualPath);
        }

        [Fact]
        public void RenderWithViewPageAndStartPageLookupExecutesStartPage()
        {
            // Arrange
            StubWebViewPage viewPage = new StubWebViewPage();
            Mock<ViewContext> viewContextMock = new Mock<ViewContext>();
            viewContextMock.Setup(vc => vc.HttpContext.Items).Returns(new Dictionary<object, object>());
            MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
            ControllerContext controllerContext = new ControllerContext();
            activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
            RazorView view = new RazorView(controllerContext, "~/viewPath", null, true, new[] { "cshtml" }, activator.Object);
            Mock<ViewStartPage> startPage = new Mock<ViewStartPage>();
            startPage.Setup(sp => sp.ExecutePageHierarchy()).Verifiable();
            view.StartPageLookup = (WebPageRenderingBase page, string fileName, IEnumerable<string> extensions) =>
            {
                Assert.Equal(viewPage, page);
                Assert.Equal("_ViewStart", fileName);
                Assert.Equal(new[] { "cshtml" }, extensions.ToArray());
                return startPage.Object;
            };
            view.BuildManager = buildManager;

            // Act
            view.Render(viewContextMock.Object, new Mock<TextWriter>().Object);

            // Assert
            startPage.Verify(sp => sp.ExecutePageHierarchy(), Times.Once());
        }

        // TODO: This throws in WebPages and needs to be tracked down.
        [Fact]
        public void RenderWithViewPageAndLayoutPageRendersView()
        {
            // Arrange
            StubWebViewPage viewPage = new StubWebViewPage();
            Mock<ViewContext> viewContext = new Mock<ViewContext>();
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>();
            Mock<HttpRequestBase> httpRequest = new Mock<HttpRequestBase>();

            httpRequest.SetupGet(r => r.IsLocal).Returns(false);
            httpRequest.SetupGet(r => r.Browser.IsMobileDevice).Returns(false);
            httpRequest.SetupGet(r => r.Cookies).Returns(new HttpCookieCollection());

            httpContext.SetupGet(c => c.Request).Returns(httpRequest.Object);
            httpContext.SetupGet(c => c.Response.Cookies).Returns(new HttpCookieCollection());
            httpContext.SetupGet(c => c.Items).Returns(new Hashtable());

            viewContext.SetupGet(v => v.HttpContext).Returns(httpContext.Object);

            MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);

            Mock<WebPage> layoutPage = new Mock<WebPage> { CallBase = true };
            layoutPage.Setup(c => c.Execute()).Callback(() => layoutPage.Object.RenderBody());
            Mock<IVirtualPathFactory> virtualPathFactory = new Mock<IVirtualPathFactory>(MockBehavior.Strict);
            virtualPathFactory.Setup(f => f.Exists("~/layoutPath")).Returns(true);
            virtualPathFactory.Setup(f => f.CreateInstance("~/layoutPath")).Returns(layoutPage.Object);
            ControllerContext controllerContext = new ControllerContext();
            activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
            RazorView view = new RazorView(controllerContext, "~/viewPath", "~/layoutPath", false, Enumerable.Empty<string>(), activator.Object);
            view.BuildManager = buildManager;
            view.VirtualPathFactory = virtualPathFactory.Object;
            view.DisplayModeProvider = DisplayModeProvider.Instance;

            // Act
            view.Render(viewContext.Object, TextWriter.Null);

            // Assert
            Assert.Equal("~/layoutPath", viewPage.Layout);
            Assert.Equal("~/layoutPath", viewPage.OverridenLayoutPath);
            Assert.Same(viewContext.Object, viewPage.ViewContext);
            Assert.Equal("~/viewPath", viewPage.VirtualPath);
        }

        public class StubWebViewPage : WebViewPage
        {
            public bool InitHelpersCalled;
            public string ResultLayoutPage;
            public string ResultOverridenLayoutPath;
            public ViewContext ResultViewContext;
            public string ResultVirtualPath;

            public override void Execute()
            {
                ResultLayoutPage = Layout;
                ResultOverridenLayoutPath = OverridenLayoutPath;
                ResultViewContext = ViewContext;
                ResultVirtualPath = VirtualPath;
            }

            public override void InitHelpers()
            {
                base.InitHelpers();
                InitHelpersCalled = true;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ReaderWriterCacheTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ReaderWriterCacheTest
    {
        [Fact]
        public void PublicFetchOrCreateItemCreatesItemIfNotAlreadyInCache()
        {
            // Arrange
            ReaderWriterCacheHelper<int, string> helper = new ReaderWriterCacheHelper<int, string>();
            Dictionary<int, string> cache = helper.PublicCache;

            // Act
            string item = helper.PublicFetchOrCreateItem(42, () => "new");

            // Assert
            Assert.Equal("new", cache[42]);
            Assert.Equal("new", item);
        }

        [Fact]
        public void PublicFetchOrCreateItemReturnsExistingItemIfFound()
        {
            // Arrange
            ReaderWriterCacheHelper<int, string> helper = new ReaderWriterCacheHelper<int, string>();
            Dictionary<int, string> cache = helper.PublicCache;
            helper.PublicCache[42] = "original";

            // Act
            string item = helper.PublicFetchOrCreateItem(42, () => "new");

            // Assert
            Assert.Equal("original", cache[42]);
            Assert.Equal("original", item);
        }

        [Fact]
        public void PublicFetchOrCreateItemReturnsFirstItemIfTwoThreadsUpdateCacheSimultaneously()
        {
            // Arrange
            ReaderWriterCacheHelper<int, string> helper = new ReaderWriterCacheHelper<int, string>();
            Dictionary<int, string> cache = helper.PublicCache;
            Func<string> creator = delegate()
            {
                // fake a second thread coming along when we weren't looking
                string firstItem = helper.PublicFetchOrCreateItem(42, () => "original");

                Assert.Equal("original", cache[42]);
                Assert.Equal("original", firstItem);
                return "new";
            };

            // Act
            string secondItem = helper.PublicFetchOrCreateItem(42, creator);

            // Assert
            Assert.Equal("original", cache[42]);
            Assert.Equal("original", secondItem);
        }

        [Fact]
        public void PublicFetchOrCreateItemPassesArgument()
        {
            // Arrange
            ReaderWriterCacheHelper<int, string> helper = new ReaderWriterCacheHelper<int, string>();
            Dictionary<int, string> cache = helper.PublicCache;

            // Act
            string item = helper.PublicFetchOrCreateItem(42, (string argument) => argument, "new");

            // Assert
            Assert.Equal("new", cache[42]);
            Assert.Equal("new", item);
        }

        private class ReaderWriterCacheHelper<TKey, TValue> : ReaderWriterCache<TKey, TValue>
        {
            public Dictionary<TKey, TValue> PublicCache
            {
                get { return Cache; }
            }

            public TValue PublicFetchOrCreateItem(TKey key, Func<TValue> creator)
            {
                return FetchOrCreateItem(key, creator);
            }

            public TValue PublicFetchOrCreateItem<TArgument>(TKey key, Func<TArgument, TValue> creator, TArgument state)
            {
                return FetchOrCreateItem(key, creator, state);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RedirectResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc.Properties;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class RedirectResultTest
    {
        private static string _baseUrl = "http://www.contoso.com/";

        [Fact]
        public void ConstructorSetsUrl()
        {
            // Act
            var result = new RedirectResult(_baseUrl);

            // Assert
            Assert.Same(_baseUrl, result.Url);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void ConstructorSetsUrlAndPermanent()
        {
            // Act
            var result = new RedirectResult(_baseUrl, permanent: true);

            // Assert
            Assert.Same(_baseUrl, result.Url);
            Assert.True(result.Permanent);
        }

        [Fact]
        public void ConstructorWithEmptyUrlThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new RedirectResult(String.Empty); },
                "url");

            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new RedirectResult(String.Empty, true); },
                "url");
        }

        [Fact]
        public void ConstructorWithNullUrlThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new RedirectResult(url: null); },
                "url");

            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new RedirectResult(url: null, permanent: true); },
                "url");
        }

        [Fact]
        public void ExecuteResultCallsResponseRedirect()
        {
            // Arrange
            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(o => o.Redirect(_baseUrl, false /* endResponse */)).Verifiable();
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(o => o.Response).Returns(mockResponse.Object);
            ControllerContext context = new ControllerContext(mockContext.Object, new RouteData(), new Mock<ControllerBase>().Object);
            var result = new RedirectResult(_baseUrl);

            // Act
            result.ExecuteResult(context);

            // Assert
            mockResponse.Verify();
        }

        [Fact]
        public void ExecuteResultWithPermanentCallsResponseRedirectPermanent()
        {
            // Arrange
            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(o => o.RedirectPermanent(_baseUrl, false /* endResponse */)).Verifiable();
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(o => o.Response).Returns(mockResponse.Object);
            ControllerContext context = new ControllerContext(mockContext.Object, new RouteData(), new Mock<ControllerBase>().Object);
            var result = new RedirectResult(_baseUrl, permanent: true);

            // Act
            result.ExecuteResult(context);

            // Assert
            mockResponse.Verify();
        }

        [Fact]
        public void ExecuteResultWithNullControllerContextThrows()
        {
            // Arrange
            var result = new RedirectResult(_baseUrl);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { result.ExecuteResult(null /* context */); },
                "context");
        }

        [Fact]
        public void RedirectInChildActionThrows()
        {
            // Arrange
            RouteData routeData = new RouteData();
            routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = new ViewContext();
            ControllerContext context = new ControllerContext(new Mock<HttpContextBase>().Object, routeData, new Mock<ControllerBase>().Object);
            RedirectResult result = new RedirectResult(_baseUrl);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => result.ExecuteResult(context),
                MvcResources.RedirectAction_CannotRedirectInChildAction
                );
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RedirectToRouteResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class RedirectToRouteResultTest
    {
        [Fact]
        public void ConstructorWithNullValuesDictionary()
        {
            // Act
            var result = new RedirectToRouteResult(routeValues: null);

            // Assert
            Assert.NotNull(result.RouteValues);
            Assert.Empty(result.RouteValues);
            Assert.Equal(String.Empty, result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void ConstructorSetsValuesDictionary()
        {
            // Arrange
            RouteValueDictionary dict = new RouteValueDictionary();

            // Act
            var result = new RedirectToRouteResult(dict);

            // Assert
            Assert.Same(dict, result.RouteValues);
            Assert.Equal(String.Empty, result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void ConstructorSetsValuesDictionaryAndEmptyName()
        {
            // Arrange
            RouteValueDictionary dict = new RouteValueDictionary();

            // Act
            var result = new RedirectToRouteResult(null, dict);

            // Assert
            Assert.Same(dict, result.RouteValues);
            Assert.Equal(String.Empty, result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void ConstructorSetsValuesDictionaryAndName()
        {
            // Arrange
            RouteValueDictionary dict = new RouteValueDictionary();

            // Act
            var result = new RedirectToRouteResult("foo", dict);

            // Assert
            Assert.Same(dict, result.RouteValues);
            Assert.Equal("foo", result.RouteName);
            Assert.False(result.Permanent);
        }

        [Fact]
        public void ConstructorSetsPermanent()
        {
            // Act
            var result = new RedirectToRouteResult(null, null, true);

            // Assert
            Assert.True(result.Permanent);
        }

        [Fact]
        public void ExecuteResultCallsResponseRedirect()
        {
            // Arrange
            Mock<Controller> mockController = new Mock<Controller>();
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.ApplicationPath).Returns("/somepath");
            mockControllerContext.Setup(c => c.HttpContext.Response.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);
            mockControllerContext.Setup(c => c.HttpContext.Response.Redirect("/somepath/c/a/i", false)).Verifiable();
            mockControllerContext.Setup(c => c.Controller).Returns(mockController.Object);

            var values = new { Controller = "c", Action = "a", Id = "i" };
            RedirectToRouteResult result = new RedirectToRouteResult(new RouteValueDictionary(values))
            {
                Routes = new RouteCollection() { new Route("{controller}/{action}/{id}", null) },
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultWithPermanentCallsResponseRedirectPermanent()
        {
            // Arrange
            Mock<Controller> mockController = new Mock<Controller>();
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.ApplicationPath).Returns("/somepath");
            mockControllerContext.Setup(c => c.HttpContext.Response.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);
            mockControllerContext.Setup(c => c.HttpContext.Response.RedirectPermanent("/somepath/c/a/i", false)).Verifiable();
            mockControllerContext.Setup(c => c.Controller).Returns(mockController.Object);

            var values = new { Controller = "c", Action = "a", Id = "i" };
            RedirectToRouteResult result = new RedirectToRouteResult(null, new RouteValueDictionary(values), permanent: true)
            {
                Routes = new RouteCollection() { new Route("{controller}/{action}/{id}", null) },
            };

            // Act
            result.ExecuteResult(mockControllerContext.Object);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void ExecuteResultPreservesTempData()
        {
            // Arrange
            TempDataDictionary tempData = new TempDataDictionary();
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";
            Mock<Controller> mockController = new Mock<Controller>() { CallBase = true };
            mockController.Object.TempData = tempData;
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.ApplicationPath).Returns("/somepath");
            mockControllerContext.Setup(c => c.HttpContext.Response.ApplyAppPathModifier(It.IsAny<string>())).Returns((string s) => s);
            mockControllerContext.Setup(c => c.HttpContext.Response.Redirect("/somepath/c/a/i", false)).Verifiable();
            mockControllerContext.Setup(c => c.Controller).Returns(mockController.Object);

            var values = new { Controller = "c", Action = "a", Id = "i" };
            RedirectToRouteResult result = new RedirectToRouteResult(new RouteValueDictionary(values))
            {
                Routes = new RouteCollection() { new Route("{controller}/{action}/{id}", null) },
            };

            // Act
            object value = tempData["Foo"];
            result.ExecuteResult(mockControllerContext.Object);
            mockController.Object.TempData.Save(mockControllerContext.Object, new Mock<ITempDataProvider>().Object);

            // Assert
            Assert.True(tempData.ContainsKey("Foo"));
            Assert.True(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void ExecuteResultThrowsIfVirtualPathDataIsNull()
        {
            // Arrange
            var result = new RedirectToRouteResult(null)
            {
                Routes = new RouteCollection()
            };

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                delegate { result.ExecuteResult(ControllerContextTest.CreateEmptyContext()); },
                "No route in the route table matches the supplied values.");
        }

        [Fact]
        public void ExecuteResultWithNullControllerContextThrows()
        {
            // Arrange
            var result = new RedirectToRouteResult(null);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { result.ExecuteResult(null /* context */); },
                "context");
        }

        [Fact]
        public void RoutesPropertyDefaultsToGlobalRouteTable()
        {
            // Act
            var result = new RedirectToRouteResult(new RouteValueDictionary());

            // Assert
            Assert.Same(RouteTable.Routes, result.Routes);
        }

        [Fact]
        public void RedirectInChildActionThrows()
        {
            // Arrange
            RouteData routeData = new RouteData();
            routeData.DataTokens[ControllerContext.ParentActionViewContextToken] = new ViewContext();
            ControllerContext context = new ControllerContext(new Mock<HttpContextBase>().Object, routeData, new Mock<ControllerBase>().Object);
            RedirectToRouteResult result = new RedirectToRouteResult(new RouteValueDictionary());

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => result.ExecuteResult(context),
                "Child actions are not allowed to perform redirect actions.");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ReflectedActionDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ReflectedActionDescriptorTest
    {
        private static readonly MethodInfo _int32EqualsIntMethod = typeof(int).GetMethod("Equals", new Type[] { typeof(int) });

        [Fact]
        public void ConstructorSetsActionNameProperty()
        {
            // Arrange
            string name = "someName";

            // Act
            ReflectedActionDescriptor ad = new ReflectedActionDescriptor(new Mock<MethodInfo>().Object, "someName", new Mock<ControllerDescriptor>().Object, false /* validateMethod */);

            // Assert
            Assert.Equal(name, ad.ActionName);
        }

        [Fact]
        public void ConstructorSetsControllerDescriptorProperty()
        {
            // Arrange
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act
            ReflectedActionDescriptor ad = new ReflectedActionDescriptor(new Mock<MethodInfo>().Object, "someName", cd, false /* validateMethod */);

            // Assert
            Assert.Same(cd, ad.ControllerDescriptor);
        }

        [Fact]
        public void ConstructorSetsMethodInfoProperty()
        {
            // Arrange
            MethodInfo methodInfo = new Mock<MethodInfo>().Object;

            // Act
            ReflectedActionDescriptor ad = new ReflectedActionDescriptor(methodInfo, "someName", new Mock<ControllerDescriptor>().Object, false /* validateMethod */);

            // Assert
            Assert.Same(methodInfo, ad.MethodInfo);
        }

        [Fact]
        public void ConstructorThrowsIfActionNameIsEmpty()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new ReflectedActionDescriptor(new Mock<MethodInfo>().Object, "", new Mock<ControllerDescriptor>().Object); }, "actionName");
        }

        [Fact]
        public void ConstructorThrowsIfActionNameIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { new ReflectedActionDescriptor(new Mock<MethodInfo>().Object, null, new Mock<ControllerDescriptor>().Object); }, "actionName");
        }

        [Fact]
        public void ConstructorThrowsIfControllerDescriptorIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedActionDescriptor(new Mock<MethodInfo>().Object, "someName", null); }, "controllerDescriptor");
        }

        [Fact]
        public void ConstructorThrowsIfMethodInfoHasRefParameters()
        {
            // Arrange
            MethodInfo methodInfo = typeof(MyController).GetMethod("MethodHasRefParameter");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new ReflectedActionDescriptor(methodInfo, "someName", new Mock<ControllerDescriptor>().Object); },
                "Cannot call action method 'Void MethodHasRefParameter(Int32 ByRef)' on controller 'System.Web.Mvc.Test.ReflectedActionDescriptorTest+MyController' because the parameter 'Int32& i' is passed by reference." + Environment.NewLine
              + "Parameter name: methodInfo");
        }

        [Fact]
        public void ConstructorThrowsIfMethodInfoHasOutParameters()
        {
            // Arrange
            MethodInfo methodInfo = typeof(MyController).GetMethod("MethodHasOutParameter");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new ReflectedActionDescriptor(methodInfo, "someName", new Mock<ControllerDescriptor>().Object); },
                "Cannot call action method 'Void MethodHasOutParameter(Int32 ByRef)' on controller 'System.Web.Mvc.Test.ReflectedActionDescriptorTest+MyController' because the parameter 'Int32& i' is passed by reference." + Environment.NewLine
              + "Parameter name: methodInfo");
        }

        [Fact]
        public void ConstructorThrowsIfMethodInfoIsInstanceMethodOnNonControllerBaseType()
        {
            // Arrange
            MethodInfo methodInfo = typeof(string).GetMethod("Clone");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new ReflectedActionDescriptor(methodInfo, "someName", new Mock<ControllerDescriptor>().Object); },
                "Cannot create a descriptor for instance method 'System.Object Clone()' on type 'System.String' because the type does not derive from ControllerBase." + Environment.NewLine
              + "Parameter name: methodInfo");
        }

        [Fact]
        public void ConstructorThrowsIfMethodIsStatic()
        {
            // Arrange
            MethodInfo methodInfo = typeof(MyController).GetMethod("StaticMethod");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new ReflectedActionDescriptor(methodInfo, "someName", new Mock<ControllerDescriptor>().Object); },
                "Cannot call action method 'Void StaticMethod()' on controller 'System.Web.Mvc.Test.ReflectedActionDescriptorTest+MyController' because the action method is a static method." + Environment.NewLine
              + "Parameter name: methodInfo");
        }

        [Fact]
        public void ConstructorThrowsIfMethodInfoIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedActionDescriptor(null, "someName", new Mock<ControllerDescriptor>().Object); }, "methodInfo");
        }

        [Fact]
        public void ConstructorThrowsIfMethodInfoIsOpenGenericType()
        {
            // Arrange
            MethodInfo methodInfo = typeof(MyController).GetMethod("OpenGenericMethod");

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { new ReflectedActionDescriptor(methodInfo, "someName", new Mock<ControllerDescriptor>().Object); },
                "Cannot call action method 'Void OpenGenericMethod[T]()' on controller 'System.Web.Mvc.Test.ReflectedActionDescriptorTest+MyController' because the action method is a generic method." + Environment.NewLine
              + "Parameter name: methodInfo");
        }

        [Fact]
        public void ExecuteCallsMethodInfoOnSuccess()
        {
            // Arrange
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.Controller).Returns(new ConcatController());
            Dictionary<string, object> parameters = new Dictionary<string, object>()
            {
                { "a", "hello " },
                { "b", "world" }
            };

            ReflectedActionDescriptor ad = GetActionDescriptor(typeof(ConcatController).GetMethod("Concat"));

            // Act
            object result = ad.Execute(mockControllerContext.Object, parameters);

            // Assert
            Assert.Equal("hello world", result);
        }

        [Fact]
        public void ExecuteThrowsIfControllerContextIsNull()
        {
            // Arrange
            ReflectedActionDescriptor ad = GetActionDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.Execute(null, new Dictionary<string, object>()); }, "controllerContext");
        }

        [Fact]
        public void ExecuteThrowsIfParametersContainsNullForNonNullableParameter()
        {
            // Arrange
            ReflectedActionDescriptor ad = GetActionDescriptor(_int32EqualsIntMethod);
            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "obj", null } };

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { ad.Execute(new Mock<ControllerContext>().Object, parameters); },
                "The parameters dictionary contains a null entry for parameter 'obj' of non-nullable type 'System.Int32' for method 'Boolean Equals(Int32)' in 'System.Int32'. An optional parameter must be a reference type, a nullable type, or be declared as an optional parameter." + Environment.NewLine
              + "Parameter name: parameters");
        }

        [Fact]
        public void ExecuteThrowsIfParametersContainsValueOfWrongTypeForParameter()
        {
            // Arrange
            ReflectedActionDescriptor ad = GetActionDescriptor(_int32EqualsIntMethod);
            Dictionary<string, object> parameters = new Dictionary<string, object>() { { "obj", "notAnInteger" } };

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { ad.Execute(new Mock<ControllerContext>().Object, parameters); },
                "The parameters dictionary contains an invalid entry for parameter 'obj' for method 'Boolean Equals(Int32)' in 'System.Int32'. The dictionary contains a value of type 'System.String', but the parameter requires a value of type 'System.Int32'." + Environment.NewLine
              + "Parameter name: parameters");
        }

        [Fact]
        public void ExecuteThrowsIfParametersIsMissingAValue()
        {
            // Arrange
            ReflectedActionDescriptor ad = GetActionDescriptor(_int32EqualsIntMethod);
            Dictionary<string, object> parameters = new Dictionary<string, object>();

            // Act & assert
            Assert.Throws<ArgumentException>(
                delegate { ad.Execute(new Mock<ControllerContext>().Object, parameters); },
                "The parameters dictionary does not contain an entry for parameter 'obj' of type 'System.Int32' for method 'Boolean Equals(Int32)' in 'System.Int32'. The dictionary must contain an entry for each parameter, including parameters that have null values." + Environment.NewLine
              + "Parameter name: parameters");
        }

        [Fact]
        public void ExecuteThrowsIfParametersIsNull()
        {
            // Arrange
            ReflectedActionDescriptor ad = GetActionDescriptor();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { ad.Execute(new Mock<ControllerContext>().Object, null); }, "parameters");
        }

        [Fact]
        public void GetCustomAttributesCallsMethodInfoGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
            mockMethod.Setup(mi => mi.GetCustomAttributes(true)).Returns(expected);
            ReflectedActionDescriptor ad = GetActionDescriptor(mockMethod.Object);

            // Act
            object[] returned = ad.GetCustomAttributes(true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetCustomAttributesWithAttributeTypeCallsMethodInfoGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
            mockMethod.Setup(mi => mi.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
            ReflectedActionDescriptor ad = GetActionDescriptor(mockMethod.Object);

            // Act
            object[] returned = ad.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetParametersWrapsParameterInfos()
        {
            // Arrange
            ParameterInfo pInfo0 = typeof(ConcatController).GetMethod("Concat").GetParameters()[0];
            ParameterInfo pInfo1 = typeof(ConcatController).GetMethod("Concat").GetParameters()[1];
            ReflectedActionDescriptor ad = GetActionDescriptor(typeof(ConcatController).GetMethod("Concat"));

            // Act
            ParameterDescriptor[] pDescsFirstCall = ad.GetParameters();
            ParameterDescriptor[] pDescsSecondCall = ad.GetParameters();

            // Assert
            Assert.NotSame(pDescsFirstCall, pDescsSecondCall);
            Assert.True(pDescsFirstCall.SequenceEqual(pDescsSecondCall));
            Assert.Equal(2, pDescsFirstCall.Length);

            ReflectedParameterDescriptor pDesc0 = pDescsFirstCall[0] as ReflectedParameterDescriptor;
            ReflectedParameterDescriptor pDesc1 = pDescsFirstCall[1] as ReflectedParameterDescriptor;

            Assert.NotNull(pDesc0);
            Assert.Same(ad, pDesc0.ActionDescriptor);
            Assert.Same(pInfo0, pDesc0.ParameterInfo);
            Assert.NotNull(pDesc1);
            Assert.Same(ad, pDesc1.ActionDescriptor);
            Assert.Same(pInfo1, pDesc1.ParameterInfo);
        }

        [Fact]
        public void GetSelectorsWrapsSelectorAttributes()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();

            Mock<ActionMethodSelectorAttribute> mockAttr = new Mock<ActionMethodSelectorAttribute>();
            mockAttr.Setup(attr => attr.IsValidForRequest(controllerContext, mockMethod.Object)).Returns(true).Verifiable();
            mockMethod.Setup(m => m.GetCustomAttributes(typeof(ActionMethodSelectorAttribute), true)).Returns(new ActionMethodSelectorAttribute[] { mockAttr.Object });

            ReflectedActionDescriptor ad = GetActionDescriptor(mockMethod.Object);

            // Act
            ICollection<ActionSelector> selectors = ad.GetSelectors();
            bool executedSuccessfully = selectors.All(s => s(controllerContext));

            // Assert
            Assert.Single(selectors);
            Assert.True(executedSuccessfully);
            mockAttr.Verify();
        }

        [Fact]
        public void IsDefinedCallsMethodInfoIsDefined()
        {
            // Arrange
            Mock<MethodInfo> mockMethod = new Mock<MethodInfo>();
            mockMethod.Setup(mi => mi.IsDefined(typeof(ObsoleteAttribute), true)).Returns(true);
            ReflectedActionDescriptor ad = GetActionDescriptor(mockMethod.Object);

            // Act
            bool isDefined = ad.IsDefined(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.True(isDefined);
        }

        [Fact]
        public void TryCreateDescriptorReturnsDescriptorOnSuccess()
        {
            // Arrange
            MethodInfo methodInfo = typeof(MyController).GetMethod("GoodActionMethod");
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act
            ReflectedActionDescriptor ad = ReflectedActionDescriptor.TryCreateDescriptor(methodInfo, "someName", cd);

            // Assert
            Assert.NotNull(ad);
            Assert.Same(methodInfo, ad.MethodInfo);
            Assert.Equal("someName", ad.ActionName);
            Assert.Same(cd, ad.ControllerDescriptor);
        }

        [Fact]
        public void TryCreateDescriptorReturnsNullOnFailure()
        {
            // Arrange
            MethodInfo methodInfo = typeof(MyController).GetMethod("OpenGenericMethod");
            ControllerDescriptor cd = new Mock<ControllerDescriptor>().Object;

            // Act
            ReflectedActionDescriptor ad = ReflectedActionDescriptor.TryCreateDescriptor(methodInfo, "someName", cd);

            // Assert
            Assert.Null(ad);
        }

        private static ReflectedActionDescriptor GetActionDescriptor()
        {
            return GetActionDescriptor(new Mock<MethodInfo>().Object);
        }

        private static ReflectedActionDescriptor GetActionDescriptor(MethodInfo methodInfo)
        {
            return new ReflectedActionDescriptor(methodInfo, "someName", new Mock<ControllerDescriptor>().Object, false /* validateMethod */)
            {
                DispatcherCache = new ActionMethodDispatcherCache()
            };
        }

        private class ConcatController : Controller
        {
            public string Concat(string a, string b)
            {
                return a + b;
            }
        }

        [OutputCache(VaryByParam = "Class")]
        private class OverriddenAttributeController : Controller
        {
            [OutputCache(VaryByParam = "Method")]
            public void SomeMethod()
            {
            }
        }

        [KeyedActionFilter(Key = "BaseClass", Order = 0)]
        [KeyedAuthorizationFilter(Key = "BaseClass", Order = 0)]
        [KeyedExceptionFilter(Key = "BaseClass", Order = 0)]
        private class GetMemberChainController : Controller
        {
            [KeyedActionFilter(Key = "BaseMethod", Order = 0)]
            [KeyedAuthorizationFilter(Key = "BaseMethod", Order = 0)]
            public virtual void SomeVirtual()
            {
            }
        }

        [KeyedActionFilter(Key = "DerivedClass", Order = 1)]
        private class GetMemberChainDerivedController : GetMemberChainController
        {
        }

        [KeyedActionFilter(Key = "SubderivedClass", Order = 2)]
        private class GetMemberChainSubderivedController : GetMemberChainDerivedController
        {
            [KeyedActionFilter(Key = "SubderivedMethod", Order = 2)]
            public override void SomeVirtual()
            {
            }
        }

        private abstract class KeyedFilterAttribute : FilterAttribute
        {
            public string Key { get; set; }
        }

        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
        private class KeyedAuthorizationFilterAttribute : KeyedFilterAttribute, IAuthorizationFilter
        {
            public void OnAuthorization(AuthorizationContext filterContext)
            {
                throw new NotImplementedException();
            }
        }

        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
        private class KeyedExceptionFilterAttribute : KeyedFilterAttribute, IExceptionFilter
        {
            public void OnException(ExceptionContext filterContext)
            {
                throw new NotImplementedException();
            }
        }

        [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = true)]
        private class KeyedActionFilterAttribute : KeyedFilterAttribute, IActionFilter, IResultFilter
        {
            public void OnActionExecuting(ActionExecutingContext filterContext)
            {
                throw new NotImplementedException();
            }

            public void OnActionExecuted(ActionExecutedContext filterContext)
            {
                throw new NotImplementedException();
            }

            public void OnResultExecuting(ResultExecutingContext filterContext)
            {
                throw new NotImplementedException();
            }

            public void OnResultExecuted(ResultExecutedContext filterContext)
            {
                throw new NotImplementedException();
            }
        }

        private class MyController : Controller
        {
            public void GoodActionMethod()
            {
            }

            public static void StaticMethod()
            {
            }

            public void OpenGenericMethod<T>()
            {
            }

            public void MethodHasOutParameter(out int i)
            {
                i = 0;
            }

            public void MethodHasRefParameter(ref int i)
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ReflectedControllerDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ReflectedControllerDescriptorTest
    {
        [Fact]
        public void ConstructorSetsControllerTypeProperty()
        {
            // Arrange
            Type controllerType = typeof(string);

            // Act
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(controllerType);

            // Assert
            Assert.Same(controllerType, cd.ControllerType);
        }

        [Fact]
        public void ConstructorThrowsIfControllerTypeIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedControllerDescriptor(null); }, "controllerType");
        }

        [Fact]
        public void FindActionReturnsActionDescriptorIfFound()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            MethodInfo targetMethod = controllerType.GetMethod("AliasedMethod");
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(controllerType);

            // Act
            ActionDescriptor ad = cd.FindAction(new ControllerContext(), "NewName");

            // Assert
            Assert.Equal("NewName", ad.ActionName);
            ReflectedActionDescriptor actionDescriptor = Assert.IsType<ReflectedActionDescriptor>(ad);
            Assert.Same(targetMethod, actionDescriptor.MethodInfo);
            Assert.Same(cd, ad.ControllerDescriptor);
        }

        [Fact]
        public void FindActionReturnsNullIfNoActionFound()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(controllerType);

            // Act
            ActionDescriptor ad = cd.FindAction(new ControllerContext(), "NonExistent");

            // Assert
            Assert.Null(ad);
        }

        [Fact]
        public void FindActionThrowsIfActionNameIsEmpty()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(controllerType);

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { cd.FindAction(new Mock<ControllerContext>().Object, ""); }, "actionName");
        }

        [Fact]
        public void FindActionThrowsIfActionNameIsNull()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(controllerType);

            // Act & assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { cd.FindAction(new Mock<ControllerContext>().Object, null); }, "actionName");
        }

        [Fact]
        public void FindActionThrowsIfControllerContextIsNull()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(controllerType);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { cd.FindAction(null, "someName"); }, "controllerContext");
        }

        [Fact]
        public void GetCanonicalActionsWrapsMethodInfos()
        {
            // Arrange
            Type controllerType = typeof(MyController);
            MethodInfo mInfo0 = controllerType.GetMethod("AliasedMethod");
            MethodInfo mInfo1 = controllerType.GetMethod("NonAliasedMethod");
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(controllerType);

            // Act
            ActionDescriptor[] aDescsFirstCall = cd.GetCanonicalActions();
            ActionDescriptor[] aDescsSecondCall = cd.GetCanonicalActions();

            // Assert
            Assert.NotSame(aDescsFirstCall, aDescsSecondCall);
            Assert.True(aDescsFirstCall.SequenceEqual(aDescsSecondCall));
            Assert.Equal(2, aDescsFirstCall.Length);

            ReflectedActionDescriptor aDesc0 = aDescsFirstCall[0] as ReflectedActionDescriptor;
            ReflectedActionDescriptor aDesc1 = aDescsFirstCall[1] as ReflectedActionDescriptor;

            Assert.NotNull(aDesc0);
            Assert.Equal("AliasedMethod", aDesc0.ActionName);
            Assert.Same(mInfo0, aDesc0.MethodInfo);
            Assert.Same(cd, aDesc0.ControllerDescriptor);
            Assert.NotNull(aDesc1);
            Assert.Equal("NonAliasedMethod", aDesc1.ActionName);
            Assert.Same(mInfo1, aDesc1.MethodInfo);
            Assert.Same(cd, aDesc1.ControllerDescriptor);
        }

        [Fact]
        public void GetCustomAttributesCallsTypeGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<Type> mockType = new Mock<Type>();
            mockType.Setup(t => t.GetCustomAttributes(true)).Returns(expected);
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(mockType.Object);

            // Act
            object[] returned = cd.GetCustomAttributes(true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetCustomAttributesWithAttributeTypeCallsTypeGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<Type> mockType = new Mock<Type>();
            mockType.Setup(t => t.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(mockType.Object);

            // Act
            object[] returned = cd.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void IsDefinedCallsTypeIsDefined()
        {
            // Arrange
            Mock<Type> mockType = new Mock<Type>();
            mockType.Setup(t => t.IsDefined(typeof(ObsoleteAttribute), true)).Returns(true);
            ReflectedControllerDescriptor cd = new ReflectedControllerDescriptor(mockType.Object);

            // Act
            bool isDefined = cd.IsDefined(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.True(isDefined);
        }

        private class MyController : Controller
        {
            [ActionName("NewName")]
            public void AliasedMethod()
            {
            }

            public void NonAliasedMethod()
            {
            }

            public void GenericMethod<T>()
            {
            }

            private void PrivateMethod()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ReflectedParameterBindingInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ReflectedParameterBindingInfoTest
    {
        [Fact]
        public void BinderProperty()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasSingleModelBinderAttribute").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act
            IModelBinder binder = bindingInfo.Binder;

            // Assert
            Assert.IsType<MyModelBinder>(binder);
        }

        [Fact]
        public void BinderPropertyThrowsIfMultipleBinderAttributesFound()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasMultipleModelBinderAttributes").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { IModelBinder binder = bindingInfo.Binder; },
                "The parameter 'p1' on method 'Void ParameterHasMultipleModelBinderAttributes(System.Object)' contains multiple attributes that inherit from CustomModelBinderAttribute.");
        }

        [Fact]
        public void ExcludeProperty()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasBindAttribute").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act
            ICollection<string> excludes = bindingInfo.Exclude;

            // Assert
            Assert.IsType<ReadOnlyCollection<string>>(excludes);

            string[] excludesArray = excludes.ToArray();
            Assert.Equal(2, excludesArray.Length);
            Assert.Equal("excl_a", excludesArray[0]);
            Assert.Equal("excl_b", excludesArray[1]);
        }

        [Fact]
        public void ExcludePropertyReturnsEmptyArrayIfNoBindAttributeSpecified()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasNoBindAttributes").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act
            ICollection<string> excludes = bindingInfo.Exclude;

            // Assert
            Assert.NotNull(excludes);
            Assert.Empty(excludes);
        }

        [Fact]
        public void IncludeProperty()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasBindAttribute").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act
            ICollection<string> includes = bindingInfo.Include;

            // Assert
            Assert.IsType<ReadOnlyCollection<string>>(includes);

            string[] includesArray = includes.ToArray();
            Assert.Equal(2, includesArray.Length);
            Assert.Equal("incl_a", includesArray[0]);
            Assert.Equal("incl_b", includesArray[1]);
        }

        [Fact]
        public void IncludePropertyReturnsEmptyArrayIfNoBindAttributeSpecified()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasNoBindAttributes").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act
            ICollection<string> includes = bindingInfo.Include;

            // Assert
            Assert.NotNull(includes);
            Assert.Empty(includes);
        }

        [Fact]
        public void PrefixProperty()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasBindAttribute").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act
            string prefix = bindingInfo.Prefix;

            // Assert
            Assert.Equal("some prefix", prefix);
        }

        [Fact]
        public void PrefixPropertyReturnsNullIfNoBindAttributeSpecified()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("ParameterHasNoBindAttributes").GetParameters()[0];
            ReflectedParameterBindingInfo bindingInfo = new ReflectedParameterBindingInfo(pInfo);

            // Act
            string prefix = bindingInfo.Prefix;

            // Assert
            Assert.Null(prefix);
        }

        private class MyController : Controller
        {
            public void ParameterHasBindAttribute(
                [Bind(Prefix = "some prefix", Include = "incl_a, incl_b", Exclude = "excl_a, excl_b")] object p1)
            {
            }

            public void ParameterHasNoBindAttributes(object p1)
            {
            }

            public void ParameterHasSingleModelBinderAttribute([ModelBinder(typeof(MyModelBinder))] object p1)
            {
            }

            public void ParameterHasMultipleModelBinderAttributes([MyCustomModelBinder, MyCustomModelBinder] object p1)
            {
            }
        }

        [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = true, Inherited = true)]
        private class MyCustomModelBinderAttribute : CustomModelBinderAttribute
        {
            public override IModelBinder GetBinder()
            {
                throw new NotImplementedException();
            }
        }

        private class MyModelBinder : IModelBinder
        {
            public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ReflectedParameterDescriptorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel;
using System.Reflection;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ReflectedParameterDescriptorTest
    {
        [Fact]
        public void ConstructorSetsActionDescriptorProperty()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("Foo").GetParameters()[0];
            ActionDescriptor ad = new Mock<ActionDescriptor>().Object;

            // Act
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(pInfo, ad);

            // Assert
            Assert.Same(ad, pd.ActionDescriptor);
        }

        [Fact]
        public void ConstructorSetsParameterInfo()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("Foo").GetParameters()[0];

            // Act
            ReflectedParameterDescriptor pd = new ReflectedParameterDescriptor(pInfo, new Mock<ActionDescriptor>().Object);

            // Assert
            Assert.Same(pInfo, pd.ParameterInfo);
        }

        [Fact]
        public void ConstructorThrowsIfActionDescriptorIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedParameterDescriptor(new Mock<ParameterInfo>().Object, null); }, "actionDescriptor");
        }

        [Fact]
        public void ConstructorThrowsIfParameterInfoIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ReflectedParameterDescriptor(null, new Mock<ActionDescriptor>().Object); }, "parameterInfo");
        }

        [Fact]
        public void DefaultValuePropertyDefaultsToNull()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("DefaultValues").GetParameters()[0]; // noDefaultValue

            // Act
            ReflectedParameterDescriptor pd = GetParameterDescriptor(pInfo);

            // Assert
            Assert.Null(pd.DefaultValue);
        }

        [Fact]
        public void GetCustomAttributesCallsParameterInfoGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<ParameterInfo> mockParameter = new Mock<ParameterInfo>();
            mockParameter.Setup(pi => pi.Member).Returns(new Mock<MemberInfo>().Object);
            mockParameter.Setup(pi => pi.GetCustomAttributes(true)).Returns(expected);
            ReflectedParameterDescriptor pd = GetParameterDescriptor(mockParameter.Object);

            // Act
            object[] returned = pd.GetCustomAttributes(true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void GetCustomAttributesWithAttributeTypeCallsParameterInfoGetCustomAttributes()
        {
            // Arrange
            object[] expected = new object[0];
            Mock<ParameterInfo> mockParameter = new Mock<ParameterInfo>();
            mockParameter.Setup(pi => pi.Member).Returns(new Mock<MemberInfo>().Object);
            mockParameter.Setup(pi => pi.GetCustomAttributes(typeof(ObsoleteAttribute), true)).Returns(expected);
            ReflectedParameterDescriptor pd = GetParameterDescriptor(mockParameter.Object);

            // Act
            object[] returned = pd.GetCustomAttributes(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.Same(expected, returned);
        }

        [Fact]
        public void IsDefinedCallsParameterInfoIsDefined()
        {
            // Arrange
            Mock<ParameterInfo> mockParameter = new Mock<ParameterInfo>();
            mockParameter.Setup(pi => pi.Member).Returns(new Mock<MemberInfo>().Object);
            mockParameter.Setup(pi => pi.IsDefined(typeof(ObsoleteAttribute), true)).Returns(true);
            ReflectedParameterDescriptor pd = GetParameterDescriptor(mockParameter.Object);

            // Act
            bool isDefined = pd.IsDefined(typeof(ObsoleteAttribute), true);

            // Assert
            Assert.True(isDefined);
        }

        [Fact]
        public void ParameterNameProperty()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("Foo").GetParameters()[0];

            // Act
            ReflectedParameterDescriptor pd = GetParameterDescriptor(pInfo);

            // Assert
            Assert.Equal("s1", pd.ParameterName);
        }

        [Fact]
        public void ParameterTypeProperty()
        {
            // Arrange
            ParameterInfo pInfo = typeof(MyController).GetMethod("Foo").GetParameters()[0];

            // Act
            ReflectedParameterDescriptor pd = GetParameterDescriptor(pInfo);

            // Assert
            Assert.Equal(typeof(string), pd.ParameterType);
        }

        private static ReflectedParameterDescriptor GetParameterDescriptor(ParameterInfo parameterInfo)
        {
            return new ReflectedParameterDescriptor(parameterInfo, new Mock<ActionDescriptor>().Object);
        }

        private class MyController : Controller
        {
            public void Foo(string s1)
            {
            }

            public void DefaultValues(string noDefaultValue, [DefaultValue("someValue")] string hasDefaultValue)
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RegularExpressionAttributeAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class RegularExpressionAttributeAdapterTest
    {
        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithRegexAttribute()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length");
            var context = new ControllerContext();
            var attribute = new RegularExpressionAttribute("the_pattern");
            var adapter = new RegularExpressionAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("regex", rule.ValidationType);
            Assert.Single(rule.ValidationParameters);
            Assert.Equal("the_pattern", rule.ValidationParameters["pattern"]);
            Assert.Equal(@"The field Length must match the regular expression 'the_pattern'.", rule.ErrorMessage);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RemoteAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class RemoteAttributeTest
    {
        // Good route name, bad route name
        // Controller + Action

        [Fact]
        public void GuardClauses()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new RemoteAttribute(null, "controller"),
                "action");
            Assert.ThrowsArgumentNullOrEmpty(
                () => new RemoteAttribute("action", null),
                "controller");
            Assert.ThrowsArgumentNullOrEmpty(
                () => new RemoteAttribute(null),
                "routeName");
            Assert.ThrowsArgumentNullOrEmpty(
                () => RemoteAttribute.FormatPropertyForClientValidation(String.Empty),
                "property");
            Assert.ThrowsArgumentNullOrEmpty(
                () => new RemoteAttribute("foo").FormatAdditionalFieldsForClientValidation(String.Empty),
                "property");
        }

        [Fact]
        public void IsValidAlwaysReturnsTrue()
        {
            // Act & Assert
            Assert.True(new RemoteAttribute("RouteName", "ParameterName").IsValid(null));
            Assert.True(new RemoteAttribute("ActionName", "ControllerName", "ParameterName").IsValid(null));
        }

        [Fact]
        public void BadRouteNameThrows()
        {
            // Arrange
            ControllerContext context = new ControllerContext();
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForType(null, typeof(object));
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("RouteName");

            // Act & Assert
            Assert.Throws<ArgumentException>(
                () => new List<ModelClientValidationRule>(attribute.GetClientValidationRules(metadata, context)),
                "A route named 'RouteName' could not be found in the route collection.\r\nParameter name: name");
        }

        [Fact]
        public void NoRouteWithActionControllerThrows()
        {
            // Arrange
            ControllerContext context = new ControllerContext();
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(string), "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller");

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => new List<ModelClientValidationRule>(attribute.GetClientValidationRules(metadata, context)),
                "No url for remote validation could be found.");
        }

        [Fact]
        public void GoodRouteNameReturnsCorrectClientData()
        {
            // Arrange
            string url = null;
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(string), "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("RouteName");
            attribute.RouteTable.Add("RouteName", new Route("my/url", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule = attribute.GetClientValidationRules(metadata, GetMockControllerContext(url)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("'Length' is invalid.", rule.ErrorMessage);
            Assert.Equal(2, rule.ValidationParameters.Count);
            Assert.Equal("/my/url", rule.ValidationParameters["url"]);
        }

        [Fact]
        public void ActionControllerReturnsCorrectClientDataWithoutNamedParameters()
        {
            // Arrange
            string url = null;

            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(string), "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller");
            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule = attribute.GetClientValidationRules(metadata, GetMockControllerContext(url)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("'Length' is invalid.", rule.ErrorMessage);
            Assert.Equal(2, rule.ValidationParameters.Count);
            Assert.Equal("/Controller/Action", rule.ValidationParameters["url"]);
            Assert.Equal("*.Length", rule.ValidationParameters["additionalfields"]);
            Assert.Throws<KeyNotFoundException>(
                () => rule.ValidationParameters["type"],
                "The given key was not present in the dictionary.");
        }

        [Fact]
        public void ActionControllerReturnsCorrectClientDataWithNamedParameters()
        {
            // Arrange
            string url = null;

            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(null, typeof(string), "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller");
            attribute.HttpMethod = "POST";
            attribute.AdditionalFields = "Password,ConfirmPassword";

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule = attribute.GetClientValidationRules(metadata, GetMockControllerContext(url)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("'Length' is invalid.", rule.ErrorMessage);
            Assert.Equal(3, rule.ValidationParameters.Count);
            Assert.Equal("/Controller/Action", rule.ValidationParameters["url"]);
            Assert.Equal("*.Length,*.Password,*.ConfirmPassword", rule.ValidationParameters["additionalfields"]);
            Assert.Equal("POST", rule.ValidationParameters["type"]);
        }

        // Current area is root in this case.
        [Fact]
        public void ActionController_RemoteFindsControllerInCurrentArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller");
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContext(url: null)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Controller/Action", rule.ValidationParameters["url"]);
        }

        [Fact]
        public void ActionControllerArea_RemoteFindsControllerInNamedArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", "Test");
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContext(url: null)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Test/Controller/Action", rule.ValidationParameters["url"]);
        }

        // Current area is root in this case.
        [Fact]
        public void ActionControllerArea_WithEmptyArea_RemoteFindsControllerInCurrentArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", "");
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContext(url: null)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Controller/Action", rule.ValidationParameters["url"]);
        }

        // Current area is root in this case.
        [Fact]
        public void ActionControllerAreaReference_WithUseCurrent_RemoteFindsControllerInCurrentArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", AreaReference.UseCurrent);
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContext(url: null)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Controller/Action", rule.ValidationParameters["url"]);
        }

        [Fact]
        public void ActionControllerAreaReference_WithUseRoot_RemoteFindsControllerInRoot()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", AreaReference.UseRoot);
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContext(url: null)).Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Controller/Action", rule.ValidationParameters["url"]);
        }

        // Current area is Test in this case.
        [Fact]
        public void ActionController_InArea_RemoteFindsControllerInCurrentArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller");
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContextWithArea(url: null, areaName: "Test"))
                .Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Test/Controller/Action", rule.ValidationParameters["url"]);
        }

        // Explicit reference to the Test area.
        [Fact]
        public void ActionControllerArea_InSameArea_RemoteFindsControllerInNamedArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", "Test");
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContextWithArea(url: null, areaName: "Test"))
                .Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Test/Controller/Action", rule.ValidationParameters["url"]);
        }

        [Fact]
        public void ActionControllerArea_InArea_RemoteFindsControllerInNamedArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", "AnotherArea");
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");
            context = new AreaRegistrationContext("AnotherArea", attribute.RouteTable);
            context.MapRoute(name: null, url: "AnotherArea/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContextWithArea(url: null, areaName: "Test"))
                .Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/AnotherArea/Controller/Action", rule.ValidationParameters["url"]);
        }

        // Current area is Test in this case.
        [Fact]
        public void ActionControllerArea_WithEmptyAreaInArea_RemoteFindsControllerInCurrentArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", "");
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContextWithArea(url: null, areaName: "Test"))
                .Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Test/Controller/Action", rule.ValidationParameters["url"]);
        }

        // Current area is Test in this case.
        [Fact]
        public void ActionControllerAreaReference_WithUseCurrentInArea_RemoteFindsControllerInCurrentArea()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", AreaReference.UseCurrent);
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContextWithArea(url: null, areaName: "Test"))
                .Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Test/Controller/Action", rule.ValidationParameters["url"]);
        }

        [Fact]
        public void ActionControllerAreaReference_WithUseRootInArea_RemoteFindsControllerInRoot()
        {
            // Arrange
            ModelMetadata metadata = ModelMetadataProviders.Current.GetMetadataForProperty(modelAccessor: null,
                containerType: typeof(string), propertyName: "Length");
            TestableRemoteAttribute attribute = new TestableRemoteAttribute("Action", "Controller", AreaReference.UseRoot);
            attribute.HttpMethod = "POST";

            var context = new AreaRegistrationContext("Test", attribute.RouteTable);
            context.MapRoute(name: null, url: "Test/{controller}/{action}");

            attribute.RouteTable.Add(new Route("{controller}/{action}", new MvcRouteHandler()));

            // Act
            ModelClientValidationRule rule =
                attribute.GetClientValidationRules(metadata, GetMockControllerContextWithArea(url: null, areaName: "Test"))
                .Single();

            // Assert
            Assert.Equal("remote", rule.ValidationType);
            Assert.Equal("/Controller/Action", rule.ValidationParameters["url"]);
        }

        private ControllerContext GetMockControllerContext(string url)
        {
            Mock<ControllerContext> context = new Mock<ControllerContext>();
            context.Setup(c => c.HttpContext.Request.ApplicationPath)
                .Returns("/");
            context.Setup(c => c.HttpContext.Response.ApplyAppPathModifier(It.IsAny<string>()))
                .Callback<string>(vpath => url = vpath)
                .Returns(() => url);

            return context.Object;
        }

        private ControllerContext GetMockControllerContextWithArea(string url, string areaName)
        {
            Mock<ControllerContext> context = new Mock<ControllerContext>();
            context.Setup(c => c.HttpContext.Request.ApplicationPath)
                .Returns("/");
            context.Setup(c => c.HttpContext.Response.ApplyAppPathModifier(It.IsAny<string>()))
                .Callback<string>(vpath => url = vpath)
                .Returns(() => url);

            var controllerContext = context.Object;

            controllerContext.RequestContext.RouteData.DataTokens.Add("area", areaName);

            return controllerContext;
        }

        private class TestableRemoteAttribute : RemoteAttribute
        {
            public RouteCollection RouteTable = new RouteCollection();

            public TestableRemoteAttribute(string action, string controller, AreaReference areaReference)
                : base(action, controller, areaReference)
            {
            }

            public TestableRemoteAttribute(string action, string controller, string areaName)
                : base(action, controller, areaName)
            {
            }

            public TestableRemoteAttribute(string action, string controller)
                : base(action, controller)
            {
            }

            public TestableRemoteAttribute(string routeName)
                : base(routeName)
            {
            }

            protected override RouteCollection Routes
            {
                get { return RouteTable; }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RequireHttpsAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class RequireHttpsAttributeTest
    {
        [Fact]
        public void HandleNonHttpsRequestExtensibility()
        {
            // Arrange
            Mock<AuthorizationContext> mockAuthContext = new Mock<AuthorizationContext>();
            mockAuthContext.Setup(c => c.HttpContext.Request.IsSecureConnection).Returns(false);
            AuthorizationContext authContext = mockAuthContext.Object;

            RequireHttpsAttribute attr = new MyRequireHttpsAttribute();

            // Act
            attr.OnAuthorization(authContext);
            ContentResult result = authContext.Result as ContentResult;

            // Assert
            Assert.NotNull(result);
            Assert.Equal("Custom HandleNonHttpsRequest", result.Content);
        }

        [Fact]
        public void OnAuthorizationDoesNothingIfRequestIsSecure()
        {
            // Arrange
            Mock<AuthorizationContext> mockAuthContext = new Mock<AuthorizationContext>();
            mockAuthContext.Setup(c => c.HttpContext.Request.IsSecureConnection).Returns(true);
            AuthorizationContext authContext = mockAuthContext.Object;

            ViewResult result = new ViewResult();
            authContext.Result = result;

            RequireHttpsAttribute attr = new RequireHttpsAttribute();

            // Act
            attr.OnAuthorization(authContext);

            // Assert
            Assert.Same(result, authContext.Result);
        }

        [Fact]
        public void OnAuthorizationRedirectsIfRequestIsNotSecureAndMethodIsGet()
        {
            // Arrange
            Mock<AuthorizationContext> mockAuthContext = new Mock<AuthorizationContext>();
            mockAuthContext.Setup(c => c.HttpContext.Request.HttpMethod).Returns("get");
            mockAuthContext.Setup(c => c.HttpContext.Request.IsSecureConnection).Returns(false);
            mockAuthContext.Setup(c => c.HttpContext.Request.RawUrl).Returns("/alpha/bravo/charlie?q=quux");
            mockAuthContext.Setup(c => c.HttpContext.Request.Url).Returns(new Uri("http://www.example.com:8080/foo/bar/baz"));
            AuthorizationContext authContext = mockAuthContext.Object;

            RequireHttpsAttribute attr = new RequireHttpsAttribute();

            // Act
            attr.OnAuthorization(authContext);
            RedirectResult result = authContext.Result as RedirectResult;

            // Assert
            Assert.False(attr.Permanent);
            Assert.NotNull(result);
            Assert.Equal("https://www.example.com/alpha/bravo/charlie?q=quux", result.Url);
            Assert.False(result.Permanent);
        }

        [Theory]
        [InlineData(false)]
        [InlineData(true)]
        public void OnAuthorizationRedirectsIfPermanentConstructorParameterIsAndRequestIsNotSecureAndMethodIsGet(bool permanent)
        {
            // Arrange
            Mock<AuthorizationContext> mockAuthContext = new Mock<AuthorizationContext>();
            mockAuthContext.Setup(c => c.HttpContext.Request.HttpMethod).Returns("get");
            mockAuthContext.Setup(c => c.HttpContext.Request.IsSecureConnection).Returns(false);
            mockAuthContext.Setup(c => c.HttpContext.Request.RawUrl).Returns("/alpha/bravo/charlie?q=quux");
            mockAuthContext.Setup(c => c.HttpContext.Request.Url).Returns(new Uri("http://www.example.com:8080/foo/bar/baz"));
            AuthorizationContext authContext = mockAuthContext.Object;

            RequireHttpsAttribute attr = new RequireHttpsAttribute(permanent);

            // Act
            attr.OnAuthorization(authContext);
            RedirectResult result = authContext.Result as RedirectResult;

            // Assert
            Assert.Equal(permanent, attr.Permanent);
            Assert.NotNull(result);
            Assert.Equal("https://www.example.com/alpha/bravo/charlie?q=quux", result.Url);
            Assert.Equal(permanent, result.Permanent);
        }

        [Fact]
        public void OnAuthorizationThrowsIfFilterContextIsNull()
        {
            // Arrange
            RequireHttpsAttribute attr = new RequireHttpsAttribute();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnAuthorization(null); }, "filterContext");
        }

        [Fact]
        public void OnAuthorizationThrowsIfRequestIsNotSecureAndMethodIsNotGet()
        {
            // Arrange
            Mock<AuthorizationContext> mockAuthContext = new Mock<AuthorizationContext>();
            mockAuthContext.Setup(c => c.HttpContext.Request.HttpMethod).Returns("post");
            mockAuthContext.Setup(c => c.HttpContext.Request.IsSecureConnection).Returns(false);
            AuthorizationContext authContext = mockAuthContext.Object;

            RequireHttpsAttribute attr = new RequireHttpsAttribute();

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { attr.OnAuthorization(authContext); },
                @"The requested resource can only be accessed via SSL.");
        }

        private class MyRequireHttpsAttribute : RequireHttpsAttribute
        {
            protected override void HandleNonHttpsRequest(AuthorizationContext filterContext)
            {
                filterContext.Result = new ContentResult() { Content = "Custom HandleNonHttpsRequest" };
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RequiredAttributeAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class RequiredAttributeAdapterTest
    {
        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithRequiredAttribute()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length");
            var context = new ControllerContext();
            var attribute = new RequiredAttribute();
            var adapter = new RequiredAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("required", rule.ValidationType);
            Assert.Empty(rule.ValidationParameters);
            Assert.Equal(@"The Length field is required.", rule.ErrorMessage);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ResultExecutedContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ResultExecutedContextTest
    {
        [Fact]
        public void ConstructorThrowsIfControllerDescriptorIsNull()
        {
            // Arrange
            ControllerContext controllerContext = null;
            ActionResult result = new ViewResult();
            bool canceled = true;
            Exception exception = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ResultExecutedContext(controllerContext, result, canceled, exception); }, "controllerContext");
        }

        [Fact]
        public void ConstructorThrowsIfResultIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionResult result = null;
            bool canceled = true;
            Exception exception = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ResultExecutedContext(controllerContext, result, canceled, exception); }, "result");
        }

        [Fact]
        public void PropertiesAreSetByConstructor()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionResult result = new ViewResult();
            bool canceled = true;
            Exception exception = new Exception();

            // Act
            ResultExecutedContext resultExecutedContext = new ResultExecutedContext(controllerContext, result, canceled, exception);

            // Assert
            Assert.Equal(result, resultExecutedContext.Result);
            Assert.Equal(canceled, resultExecutedContext.Canceled);
            Assert.Equal(exception, resultExecutedContext.Exception);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ResultExecutingContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ResultExecutingContextTest
    {
        [Fact]
        public void ConstructorThrowsIfControllerContextIsNull()
        {
            // Arrange
            ControllerContext controllerContext = null;
            ActionResult result = new ViewResult();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ResultExecutingContext(controllerContext, result); }, "controllerContext");
        }

        [Fact]
        public void ConstructorThrowsIfResultIsNull()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionResult result = null;

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ResultExecutingContext(controllerContext, result); }, "result");
        }

        [Fact]
        public void ResultProperty()
        {
            // Arrange
            ControllerContext controllerContext = new Mock<ControllerContext>().Object;
            ActionResult result = new ViewResult();

            // Act
            ResultExecutingContext resultExecutingContext = new ResultExecutingContext(controllerContext, result);

            // Assert
            Assert.Equal(result, resultExecutingContext.Result);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RouteCollectionExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Routing;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class RouteCollectionExtensionsTest
    {
        private static string[] _nameSpaces = new string[] { "nsA.nsB.nsC", "ns1.ns2.ns3" };

        [Fact]
        public void GetVirtualPathForAreaDoesNotStripAreaTokenIfAreasNotInUse()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            routes.MapRoute(
                "Default",
                "no-area/{controller}/{action}/{id}",
                new { controller = "Home", action = "Index", id = "" }
                );

            RequestContext requestContext = GetRequestContext(null);
            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "controller", "home" },
                { "action", "about" },
                { "area", "some-area" }
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal(routes["Default"], vpd.Route);

            // note presence of 'area' query string parameter; RVD should not be modified if areas not in use
            Assert.Equal("/app/no-area/home/about?area=some-area", vpd.VirtualPath);
        }

        [Fact]
        public void GetVirtualPathForAreaForwardsCallIfRouteNameSpecified()
        {
            // Arrange
            RouteCollection routes = GetRouteCollection();
            RequestContext requestContext = GetRequestContext(null);
            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "controller", "home" },
                { "action", "index" },
                { "area", "some-area" }
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, "admin_default", values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal(routes["admin_default"], vpd.Route);

            // note presence of 'area' query string parameter; RVD should not be modified if route name was provided
            Assert.Equal("/app/admin-area?area=some-area", vpd.VirtualPath);
        }

        [Fact]
        public void GetVirtualPathForAreaThrowsIfRoutesIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { RouteCollectionExtensions.GetVirtualPathForArea(null, null, null); }, "routes");
        }

        [Fact]
        public void GetVirtualPathForAreaWillJumpBetweenAreasExplicitly()
        {
            // Arrange
            RouteCollection routes = GetRouteCollection();
            RequestContext requestContext = GetRequestContext(null);
            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "controller", "home" },
                { "action", "tenmostrecent" },
                { "tag", "some-tag" },
                { "area", "blog" }
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal(routes["blog_whatsnew"], vpd.Route);
            Assert.Equal("/app/whats-new/some-tag", vpd.VirtualPath);
        }

        [Fact]
        public void GetVirtualPathForAreaWillNotJumpBetweenAreasImplicitly()
        {
            // Arrange
            RouteCollection routes = GetRouteCollection();
            RequestContext requestContext = GetRequestContext("admin");
            RouteValueDictionary values = new RouteValueDictionary()
            {
                { "controller", "home" },
                { "action", "tenmostrecent" },
                { "tag", "some-tag" }
            };

            // Act
            VirtualPathData vpd = routes.GetVirtualPathForArea(requestContext, values);

            // Assert
            Assert.NotNull(vpd);
            Assert.Equal(routes["admin_default"], vpd.Route);
            Assert.Equal("/app/admin-area/home/tenmostrecent?tag=some-tag", vpd.VirtualPath);
        }

        [Fact]
        public void MapRoute3()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();

            // Act
            routes.MapRoute("RouteName", "SomeUrl");

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Same(route, routes["RouteName"]);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Empty(route.Defaults);
            Assert.Empty(route.Constraints);
            Assert.Empty(route.DataTokens);
        }

        [Fact]
        public void MapRoute3WithNameSpaces()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            //string[] namespaces = new string[] { "nsA.nsB.nsC", "ns1.ns2.ns3" };

            // Act
            routes.MapRoute("RouteName", "SomeUrl", _nameSpaces);

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.NotNull(route.DataTokens);
            Assert.NotNull(route.DataTokens["Namespaces"]);
            string[] routeNameSpaces = route.DataTokens["Namespaces"] as string[];
            Assert.Equal(2, routeNameSpaces.Length);
            Assert.Same(route, routes["RouteName"]);
            Assert.Same(routeNameSpaces, _nameSpaces);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Empty(route.Defaults);
            Assert.Empty(route.Constraints);
        }

        [Fact]
        public void MapRoute3WithEmptyNameSpaces()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();

            // Act
            routes.MapRoute("RouteName", "SomeUrl", new string[] { });

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Same(route, routes["RouteName"]);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Empty(route.Defaults);
            Assert.Empty(route.Constraints);
            Assert.Empty(route.DataTokens);
        }

        [Fact]
        public void MapRoute4()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            var defaults = new { Foo = "DefaultFoo" };

            // Act
            routes.MapRoute("RouteName", "SomeUrl", defaults);

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Same(route, routes["RouteName"]);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Equal("DefaultFoo", route.Defaults["Foo"]);
            Assert.Empty(route.Constraints);
            Assert.Empty(route.DataTokens);
        }

        [Fact]
        public void MapRoute4WithNameSpaces()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            var defaults = new { Foo = "DefaultFoo" };

            // Act
            routes.MapRoute("RouteName", "SomeUrl", defaults, _nameSpaces);

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.NotNull(route.DataTokens);
            Assert.NotNull(route.DataTokens["Namespaces"]);
            string[] routeNameSpaces = route.DataTokens["Namespaces"] as string[];
            Assert.Equal(2, routeNameSpaces.Length);
            Assert.Same(route, routes["RouteName"]);
            Assert.Same(routeNameSpaces, _nameSpaces);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Equal("DefaultFoo", route.Defaults["Foo"]);
            Assert.Empty(route.Constraints);
        }

        [Fact]
        public void MapRoute4WithDefaultsAsDictionary()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            var defaults = new Dictionary<string, object> { { "Foo", "DefaultFoo" } };

            // Act
            routes.MapRoute("RouteName", "SomeUrl", defaults);

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Same(route, routes["RouteName"]);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Equal("DefaultFoo", route.Defaults["Foo"]);
            Assert.Empty(route.Constraints);
            Assert.Empty(route.DataTokens);
        }

        [Fact]
        public void MapRoute5()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            var defaults = new { Foo = "DefaultFoo" };
            var constraints = new { Foo = "ConstraintFoo" };

            // Act
            routes.MapRoute("RouteName", "SomeUrl", defaults, constraints);

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Same(route, routes["RouteName"]);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Equal("DefaultFoo", route.Defaults["Foo"]);
            Assert.Equal("ConstraintFoo", route.Constraints["Foo"]);
            Assert.Empty(route.DataTokens);
        }

        [Fact]
        public void MapRoute5WithDefaultsAndConstraintsAsDictionary()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            var defaults = new Dictionary<string, object> { { "Foo", "DefaultFoo" } };
            var constraints = new Dictionary<string, object> { { "Foo", "ConstraintFoo" } };

            // Act
            routes.MapRoute("RouteName", "SomeUrl", defaults, constraints);

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Same(route, routes["RouteName"]);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<MvcRouteHandler>(route.RouteHandler);
            Assert.Equal("DefaultFoo", route.Defaults["Foo"]);
            Assert.Equal("ConstraintFoo", route.Constraints["Foo"]);
            Assert.Empty(route.DataTokens);
        }

        [Fact]
        public void MapRoute5WithNullRouteCollectionThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { RouteCollectionExtensions.MapRoute(null, null, null, null, null); },
                "routes");
        }

        [Fact]
        public void MapRoute5WithNullUrlThrows()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { routes.MapRoute(null, null /* url */, null, null); },
                "url");
        }

        [Fact]
        public void IgnoreRoute1WithNullRouteCollectionThrows()
        {
            Assert.ThrowsArgumentNull(
                delegate { RouteCollectionExtensions.IgnoreRoute(null, "foo"); },
                "routes");
        }

        [Fact]
        public void IgnoreRoute1WithNullUrlThrows()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { routes.IgnoreRoute(null); },
                "url");
        }

        [Fact]
        public void IgnoreRoute3()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();

            // Act
            routes.IgnoreRoute("SomeUrl");

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<StopRoutingHandler>(route.RouteHandler);
            Assert.Null(route.Defaults);
            Assert.Empty(route.Constraints);
        }

        [Fact]
        public void IgnoreRoute4()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            var constraints = new { Foo = "DefaultFoo" };

            // Act
            routes.IgnoreRoute("SomeUrl", constraints);

            // Assert
            Route route = Assert.Single(routes.Cast<Route>());
            Assert.NotNull(route);
            Assert.Equal("SomeUrl", route.Url);
            Assert.IsType<StopRoutingHandler>(route.RouteHandler);
            Assert.Null(route.Defaults);
            Assert.Single(route.Constraints);
            Assert.Equal("DefaultFoo", route.Constraints["Foo"]);
        }

        [Fact]
        public void IgnoreRouteInternalNeverMatchesUrlGeneration()
        {
            // Arrange
            RouteCollection routes = new RouteCollection();
            routes.IgnoreRoute("SomeUrl");
            Route route = routes[0] as Route;

            // Act
            VirtualPathData vpd = route.GetVirtualPath(new RequestContext(new Mock<HttpContextBase>().Object, new RouteData()), null);

            // Assert
            Assert.Null(vpd);
        }

        [Fact]
        public void MapRoute_ValidatesConstraintType_IRouteConstraint()
        {
            // Arrange
            var routes = new RouteCollection();

            var constraint = new CustomConstraint();
            var constraints = new RouteValueDictionary();
            constraints.Add("custom", constraint);

            // Act
            var route = routes.MapRoute("default", "{controller}/{id}", null, constraints);

            // Assert
            Assert.NotNull(route.Constraints["custom"]);
        }

        [Fact]
        public void MapRoute_ValidatesConstraintType_StringRegex()
        {
            // Arrange
            var routes = new RouteCollection();

            // We can't easily mock the ValidateConstraint method because all of this logic is in extension methods,
            // so we're just assuming here that it was called.
            var constraint = "product|products";
            var constraints = new RouteValueDictionary();
            constraints.Add("custom", constraint);

            // Act
            var route = routes.MapRoute("default", "{controller}/{id}", null, constraints);

            // Assert
            Assert.NotNull(route.Constraints["custom"]);
        }

        [Fact]
        public void MapRoute_ValidatesConstraintType_InvalidType()
        {
            // Arrange
            var routes = new RouteCollection();

            // We can't easily mock the ValidateConstraint method because all of this logic is in extension methods,
            // so we're just assuming here that it was called.
            var constraint = new Uri("http://localhost/");
            var constraints = new RouteValueDictionary();
            constraints.Add("custom", constraint);

            string expectedMessage =
                "The constraint entry 'custom' on the route with route template '{controller}/{id}' " +
                "must have a string value or be of a type which implements 'System.Web.Routing.IRouteConstraint'.";

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => routes.MapRoute("default", "{controller}/{id}", null, constraints), expectedMessage);
        }

        [Fact]
        public void IgnoreRoute_ValidatesConstraintType_InvalidType()
        {
            // Arrange
            var routes = new RouteCollection();

            var constraint = new Uri("http://localhost/");
            var constraints = new RouteValueDictionary();
            constraints.Add("custom", constraint);

            string expectedMessage =
                "The constraint entry 'custom' on the route with route template '{controller}/{id}' " +
                "must have a string value or be of a type which implements 'System.Web.Routing.IRouteConstraint'.";

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => routes.IgnoreRoute("{controller}/{id}", constraints), expectedMessage);
        }

        private static RequestContext GetRequestContext(string currentAreaName)
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.Request.ApplicationPath).Returns("/app");
            mockHttpContext.Setup(c => c.Response.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(virtualPath => virtualPath);

            RouteData routeData = new RouteData();
            routeData.DataTokens["area"] = currentAreaName;
            return new RequestContext(mockHttpContext.Object, routeData);
        }

        private static RouteCollection GetRouteCollection()
        {
            RouteCollection routes = new RouteCollection();
            routes.MapRoute(
                "Default",
                "no-area/{controller}/{action}/{id}",
                new { controller = "Home", action = "Index", id = "" }
                );

            AreaRegistrationContext blogContext = new AreaRegistrationContext("blog", routes);
            blogContext.MapRoute(
                "Blog_WhatsNew",
                "whats-new/{tag}",
                new { controller = "Home", action = "TenMostRecent", tag = "" }
                );
            blogContext.MapRoute(
                "Blog_Default",
                "blog-area/{controller}/{action}/{id}",
                new { controller = "Home", action = "Index", id = "" }
                );

            AreaRegistrationContext adminContext = new AreaRegistrationContext("admin", routes);
            adminContext.MapRoute(
                "Admin_Default",
                "admin-area/{controller}/{action}/{id}",
                new { controller = "Home", action = "Index", id = "" }
                );

            return routes;
        }

        private class CustomConstraint : IRouteConstraint
        {
            public bool Match(HttpContextBase httpContext, Route route, string parameterName, RouteValueDictionary values, RouteDirection routeDirection)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/RouteDataValueProviderFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Routing;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class RouteDataValueProviderFactoryTest
    {
        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            RouteDataValueProviderFactory factory = new RouteDataValueProviderFactory();

            ControllerContext controllerContext = new ControllerContext();
            controllerContext.RouteData = new RouteData();
            controllerContext.RouteData.Values["forty-two"] = 42;

            // Act
            IValueProvider valueProvider = factory.GetValueProvider(controllerContext);

            // Assert
            Assert.IsType<RouteDataValueProvider>(valueProvider);
            ValueProviderResult vpResult = valueProvider.GetValue("forty-two");

            Assert.NotNull(vpResult);
            Assert.Equal(42, vpResult.RawValue);
            Assert.Equal("42", vpResult.AttemptedValue);
            Assert.Equal(CultureInfo.InvariantCulture, vpResult.Culture);
        }

        [Fact]
        public void GetValueProvider_ThrowsIfControllerContextIsNull()
        {
            // Arrange
            RouteDataValueProviderFactory factory = new RouteDataValueProviderFactory();

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { factory.GetValueProvider(null); }, "controllerContext");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/SelectListTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class SelectListTest
    {
        [Fact]
        public void Constructor1SetsProperties()
        {
            // Arrange
            IEnumerable items = new object[0];

            // Act
            SelectList selectList = new SelectList(items);

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Null(selectList.DataValueField);
            Assert.Null(selectList.DataTextField);
            Assert.Null(selectList.SelectedValues);
            Assert.Null(selectList.SelectedValue);
        }

        [Fact]
        public void Constructor2SetsProperties_Items_SelectedValue()
        {
            // Arrange
            IEnumerable items = new object[0];
            object selectedValue = new object();

            // Act
            SelectList selectList = new SelectList(items, selectedValue);
            List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Null(selectList.DataValueField);
            Assert.Null(selectList.DataTextField);
            Assert.Same(selectedValue, selectList.SelectedValue);
            object resultValue = Assert.Single(selectedValues);
            Assert.Same(selectedValue, resultValue);
        }

        [Fact]
        public void Constructor3SetsProperties_SelectedValue_DisabledValues()
        {
            // Arrange
            IEnumerable items = new[] { "A", "B", "C" };
            IEnumerable selectedValues = "A";
            IEnumerable disabledValues = new[] { "B", "C" };

            // Act
            SelectList multiSelect = new SelectList(items, selectedValues, disabledValues);

            // Assert
            Assert.Same(items, multiSelect.Items);
            Assert.Equal(new object[] { selectedValues }, multiSelect.SelectedValues);
            Assert.Equal(disabledValues, multiSelect.DisabledValues);
            Assert.Null(multiSelect.DataTextField);
            Assert.Null(multiSelect.DataValueField);
        }

        [Fact]
        public void Constructor3SetsProperties_Value_Text()
        {
            // Arrange
            IEnumerable items = new object[0];

            // Act
            SelectList selectList = new SelectList(items, "SomeValueField", "SomeTextField");

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Equal("SomeValueField", selectList.DataValueField);
            Assert.Equal("SomeTextField", selectList.DataTextField);
            Assert.Null(selectList.SelectedValues);
            Assert.Null(selectList.SelectedValue);
        }

        [Fact]
        public void Constructor4SetsProperties()
        {
            // Arrange
            IEnumerable items = new object[0];
            object selectedValue = new object();

            // Act
            SelectList selectList = new SelectList(items, "SomeValueField", "SomeTextField", selectedValue);
            List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Equal("SomeValueField", selectList.DataValueField);
            Assert.Equal("SomeTextField", selectList.DataTextField);
            Assert.Same(selectedValue, selectList.SelectedValue);
            object resultValue = Assert.Single(selectedValues);
            Assert.Same(selectedValue, resultValue);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_DisabledValues()
        {
            // Arrange
            IEnumerable items = new[]
            {
                new { Value = "A", Text = "Alice" },
                new { Value = "B", Text = "Bravo" },
                new { Value = "C", Text = "Charlie" },
            };
            object selectedValue = "A";
            IEnumerable disabledValues = new[] { "B", "C" };

            // Act
            SelectList selectList = new SelectList(items,
                "Value",
                "Text",
                selectedValue,
                disabledValues);
            List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Equal("Value", selectList.DataValueField);
            Assert.Equal("Text", selectList.DataTextField);
            Assert.Same(selectedValue, selectList.SelectedValue);
            object resultValue = Assert.Single(selectedValues);
            Assert.Same(selectedValue, resultValue);
            Assert.Same(disabledValues, selectList.DisabledValues);
            Assert.Equal(disabledValues, selectList.DisabledValues);
            Assert.Null(selectList.DataGroupField);
            Assert.Null(selectList.DisabledGroups);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_Group()
        {
            // Arrange
            IEnumerable items = new[]
            {
                new { Value = "A", Text = "Alice", Group = "AB" },
                new { Value = "B", Text = "Bravo", Group = "AB" },
                new { Value = "C", Text = "Charlie", Group = "C" },
            };
            object selectedValue = "A";

            // Act
            SelectList selectList = new SelectList(items,
                "Value",
                "Text",
                "Group",
                selectedValue);
            List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Equal("Value", selectList.DataValueField);
            Assert.Equal("Text", selectList.DataTextField);
            Assert.Same(selectedValue, selectList.SelectedValue);
            object resultValue = Assert.Single(selectedValues);
            Assert.Same(selectedValue, resultValue);
            Assert.Equal("Group", selectList.DataGroupField);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_Group_DisabledGroups()
        {
            // Arrange
            IEnumerable items = new[]
            {
                new { Value = "A", Text = "Alice", Group = "AB" },
                new { Value = "B", Text = "Bravo", Group = "AB" },
                new { Value = "C", Text = "Charlie", Group = "C" },
            };
            object selectedValue = "A";
            IEnumerable disabledGroups = new[] { "AB" };

            // Act
            SelectList selectList = new SelectList(items,
                "Value",
                "Text",
                "Group",
                selectedValue,
                null,
                disabledGroups);
            List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Equal("Value", selectList.DataValueField);
            Assert.Equal("Text", selectList.DataTextField);
            Assert.Same(selectedValue, selectList.SelectedValue);
            object resultValue = Assert.Single(selectedValues);
            Assert.Same(selectedValue, resultValue);
            Assert.Equal("Group", selectList.DataGroupField);
            Assert.Equal(disabledGroups, selectList.DisabledGroups);
        }

        [Fact]
        public void Constructor_SetsProperties_Items_Value_Text_SelectedValue_DisabledValues_Group()
        {
            // Arrange
            IEnumerable items = new[]
            {
                new { Value = "A", Text = "Alice", Group = "AB" },
                new { Value = "B", Text = "Bravo", Group = "AB" },
                new { Value = "C", Text = "Charlie", Group = "C" },
            };
            object selectedValue = "A";
            IEnumerable disabledValues = new[] { "A", "C" };

            // Act
            SelectList selectList = new SelectList(items,
                "Value",
                "Text",
                "Group",
                selectedValue,
                disabledValues);
            List<object> selectedValues = selectList.SelectedValues.Cast<object>().ToList();

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Equal("Value", selectList.DataValueField);
            Assert.Equal("Text", selectList.DataTextField);
            Assert.Same(selectedValue, selectList.SelectedValue);
            object resultValue = Assert.Single(selectedValues);
            Assert.Same(selectedValue, resultValue);
            Assert.Equal("Group", selectList.DataGroupField);
            Assert.Same(disabledValues, selectList.DisabledValues);
        }

        [Fact]
        public void DataGroupFieldSetByCtor()
        {
            // Arrange
            IEnumerable items = new object[0];
            object selectedValue = new object();

            // Act
            SelectList selectList = new SelectList(items, "SomeValueField", "SomeTextField", "SomeGroupField",
                selectedValue);
            IEnumerable selectedValues = selectList.SelectedValues;

            // Assert
            Assert.Same(items, selectList.Items);
            Assert.Equal("SomeValueField", selectList.DataValueField);
            Assert.Equal("SomeTextField", selectList.DataTextField);
            Assert.Equal("SomeGroupField", selectList.DataGroupField);
            Assert.Same(selectedValue, selectList.SelectedValue);
            Assert.Single(selectedValues, selectedValue);
            Assert.Null(selectList.DisabledValues);
            Assert.Null(selectList.DisabledGroups);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/SessionStateTempDataProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class SessionStateTempDataProviderTest
    {
        [Fact]
        public void Load_NullSession_ReturnsEmptyDictionary()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();

            // Act
            IDictionary<string, object> tempDataDictionary = testProvider.LoadTempData(GetControllerContext());

            // Assert
            Assert.Empty(tempDataDictionary);
        }

        [Fact]
        public void Load_NonNullSession_NoSessionData_ReturnsEmptyDictionary()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            Mock<HttpSessionStateBase> mockSessionStateBase = new Mock<HttpSessionStateBase>();
            mockControllerContext.Setup(c => c.HttpContext.Session).Returns(mockSessionStateBase.Object);

            // Act
            IDictionary<string, object> result = testProvider.LoadTempData(mockControllerContext.Object);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void Load_NonNullSession_IncorrectSessionDataType_ReturnsEmptyDictionary()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            Mock<HttpSessionStateBase> mockSessionStateBase = new Mock<HttpSessionStateBase>();
            mockControllerContext.Setup(c => c.HttpContext.Session).Returns(mockSessionStateBase.Object);
            mockSessionStateBase.Setup(ssb => ssb[SessionStateTempDataProvider.TempDataSessionStateKey]).Returns(42);

            // Act
            IDictionary<string, object> result = testProvider.LoadTempData(mockControllerContext.Object);

            // Assert
            Assert.Empty(result);
        }

        [Fact]
        public void Load_NonNullSession_CorrectSessionDataType_ReturnsSessionData()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();
            Dictionary<string, object> tempData = new Dictionary<string, object> { { "foo", "bar" } };
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            Mock<HttpSessionStateBase> mockSessionStateBase = new Mock<HttpSessionStateBase>();
            mockControllerContext.Setup(c => c.HttpContext.Session).Returns(mockSessionStateBase.Object);
            mockSessionStateBase.Setup(ssb => ssb[SessionStateTempDataProvider.TempDataSessionStateKey]).Returns(tempData);

            // Act
            var result = testProvider.LoadTempData(mockControllerContext.Object);

            // Assert
            Assert.Same(tempData, result);
        }

        [Fact]
        public void Save_NullSession_NullDictionary_DoesNotThrow()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();

            // Act
            testProvider.SaveTempData(GetControllerContext(), null);
        }

        [Fact]
        public void Save_NullSession_EmptyDictionary_DoesNotThrow()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();

            // Act
            testProvider.SaveTempData(GetControllerContext(), new Dictionary<string, object>());
        }

        [Fact]
        public void Save_NullSession_NonEmptyDictionary_Throws()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                delegate { testProvider.SaveTempData(GetControllerContext(), new Dictionary<string, object> { { "foo", "bar" } }); },
                "The SessionStateTempDataProvider class requires session state to be enabled.");
        }

        [Fact]
        public void Save_NonNullSession_TempDataIsDirty_AssignsTempDataDictionaryIntoSession()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();
            Dictionary<string, object> tempData = new Dictionary<string, object> { { "foo", "bar" } };
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            Mock<HttpSessionStateBase> mockSessionStateBase = new Mock<HttpSessionStateBase>();
            mockControllerContext.Setup(c => c.HttpContext.Session).Returns(mockSessionStateBase.Object);
            mockSessionStateBase.SetupSet(ssb => ssb[SessionStateTempDataProvider.TempDataSessionStateKey] = tempData);

            // Act
            testProvider.SaveTempData(mockControllerContext.Object, tempData);

            // Assert
            mockSessionStateBase.VerifyAll();
        }

        [Fact]
        public void Save_NonNullSession_TempDataIsNotDirty_KeyDoesNotExistInSession_SessionRemainsUntouched()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();
            Dictionary<string, object> tempData = new Dictionary<string, object>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.Setup(o => o.HttpContext.Session[SessionStateTempDataProvider.TempDataSessionStateKey]).Returns(null);

            // Act
            testProvider.SaveTempData(mockControllerContext.Object, tempData);

            // Assert
            mockControllerContext.Verify();
        }

        [Fact]
        public void Save_NonNullSession_TempDataIsNotDirty_KeyExistsInSession_KeyRemovedFromSession()
        {
            // Arrange
            SessionStateTempDataProvider testProvider = new SessionStateTempDataProvider();
            Dictionary<string, object> tempData = new Dictionary<string, object>();

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>(MockBehavior.Strict);
            mockControllerContext.Setup(o => o.HttpContext.Session[SessionStateTempDataProvider.TempDataSessionStateKey]).Returns(new object());
            mockControllerContext.Setup(o => o.HttpContext.Session.Remove(SessionStateTempDataProvider.TempDataSessionStateKey)).Verifiable();

            // Act
            testProvider.SaveTempData(mockControllerContext.Object, tempData);

            // Assert
            mockControllerContext.Verify();
        }

        private static ControllerContext GetControllerContext()
        {
            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Session).Returns((HttpSessionStateBase)null);
            return mockControllerContext.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/SingleServiceResolverTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class SingleServiceResolverTest
    {
        [Fact]
        public void ConstructorWithNullThunkArgumentThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new SingleServiceResolver<TestProvider>(null, null, "TestProvider.Current"); },
                "currentValueThunk");

            Assert.ThrowsArgumentNull(
                delegate { new SingleServiceResolver<TestProvider>(null, null, "TestProvider.Current"); },
                "currentValueThunk");

            Assert.ThrowsArgumentNull(
                delegate { new SingleServiceResolver<TestProvider>(() => null, null, "TestProvider.Current"); },
                "defaultValue");
        }

        [Fact]
        public void CurrentConsultsResolver()
        {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            TestProvider providerFromServiceLocation = new TestProvider();

            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetService(typeof(TestProvider)))
                .Returns(providerFromServiceLocation);

            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromServiceLocation, returnedProvider);
        }

        [Fact]
        public void CurrentReturnsCurrentProviderNotDefaultIfSet()
        {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            TestProvider providerFromCurrentValueThunk = null;
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            providerFromCurrentValueThunk = new TestProvider();
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromCurrentValueThunk, returnedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)));
        }

        [Fact]
        public void CurrentCachesResolverResult()
        {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            TestProvider providerFromServiceLocation = new TestProvider();

            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetService(typeof(TestProvider)))
                .Returns(providerFromServiceLocation);

            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            TestProvider returnedProvider = singleResolver.Current;
            TestProvider cachedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromServiceLocation, returnedProvider);
            Assert.Equal(providerFromServiceLocation, cachedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)), Times.Exactly(1));
        }

        [Fact]
        public void CurrentDoesNotQueryResolverAfterReceivingNull()
        {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            TestProvider providerFromCurrentValueThunk = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            TestProvider returnedProvider = singleResolver.Current;
            TestProvider cachedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromCurrentValueThunk, returnedProvider);
            Assert.Equal(providerFromCurrentValueThunk, cachedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)), Times.Exactly(1));
        }

        [Fact]
        public void CurrentReturnsDefaultIfCurrentNotSet()
        {
            //Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            //Act
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(returnedProvider, providerFromDefaultValue);
            resolver.Verify(l => l.GetService(typeof(TestProvider)));
        }

        [Fact]
        public void CurrentThrowsIfCurrentSetThroughServiceAndSetter()
        {
            // Arrange
            TestProvider providerFromCurrentValueThunk = new TestProvider();
            TestProvider providerFromServiceLocation = new TestProvider();
            TestProvider providerFromDefaultValue = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();

            resolver.Setup(r => r.GetService(typeof(TestProvider)))
                .Returns(providerFromServiceLocation);

            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            //Act & assert
            Assert.Throws<InvalidOperationException>(
                () => singleResolver.Current,
                "An instance of TestProvider was found in the resolver as well as a custom registered provider in TestProvider.Current. Please set only one or the other."
                );
        }

        [Fact]
        public void CurrentPropagatesExceptionWhenResolverThrowsNonActivationException()
        {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>(MockBehavior.Strict);
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act & Assert
            var ex = Assert.Throws<MockException>(() => singleResolver.Current);
            Assert.Equal(
                "IDependencyResolver.GetService(System.Web.Mvc.Test.SingleServiceResolverTest+TestProvider) invocation failed with mock behavior Strict." +
                Environment.NewLine +
                "All invocations on the mock must have a corresponding setup.",
                ex.Message,
                ignoreLineEndingDifferences: true);
        }

        private class TestProvider
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/StringLengthAttributeAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class StringLengthAttributeAdapterTest
    {
        [Fact]
        [ReplaceCulture]
        public void ClientRulesWithStringLengthAttribute()
        {
            // Arrange
            var metadata = ModelMetadataProviders.Current.GetMetadataForProperty(() => null, typeof(string), "Length");
            var context = new ControllerContext();
            var attribute = new StringLengthAttribute(10) { MinimumLength = 3 };
            var adapter = new StringLengthAttributeAdapter(metadata, context, attribute);

            // Act
            var rules = adapter.GetClientValidationRules()
                .OrderBy(r => r.ValidationType)
                .ToArray();

            // Assert
            ModelClientValidationRule rule = Assert.Single(rules);
            Assert.Equal("length", rule.ValidationType);
            Assert.Equal(2, rule.ValidationParameters.Count);
            Assert.Equal(3, rule.ValidationParameters["min"]);
            Assert.Equal(10, rule.ValidationParameters["max"]);
            Assert.Equal("The field Length must be a string with a minimum length of 3 and a maximum length of 10.", rule.ErrorMessage);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/TempDataDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class TempDataDictionaryTest
    {
        [Fact]
        public void CompareIsOrdinalIgnoreCase()
        {
            // Arrange
            TempDataDictionary tempData = new TempDataDictionary();
            object item = new object();

            // Act
            tempData["Foo"] = item;
            object value = tempData["FOO"];

            // Assert
            Assert.Same(item, value);
        }

        [Fact]
        public void EnumeratingDictionaryMarksValuesForDeletion()
        {
            // Arrange
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";

            // Act
            IEnumerator<KeyValuePair<string, object>> enumerator = tempData.GetEnumerator();
            while (enumerator.MoveNext())
            {
                object value = enumerator.Current;
            }
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.False(tempData.ContainsKey("Foo"));
            Assert.False(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void EnumeratingTempDataAsIEnmerableMarksValuesForDeletion()
        {
            // Arrange
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";

            // Act
            IEnumerator enumerator = ((IEnumerable)tempData).GetEnumerator();
            while (enumerator.MoveNext())
            {
                object value = enumerator.Current;
            }
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.False(tempData.ContainsKey("Foo"));
            Assert.False(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void KeepRetainsAllKeysWhenSavingDictionary()
        {
            // Arrange
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            controllerContext.Setup(c => c.HttpContext.Request).Returns(new Mock<HttpRequestBase>().Object);
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";

            // Act
            tempData.Keep();
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.True(tempData.ContainsKey("Foo"));
            Assert.True(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void KeepRetainsSpecificKeysWhenSavingDictionary()
        {
            // Arrange
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            controllerContext.Setup(c => c.HttpContext.Request).Returns(new Mock<HttpRequestBase>().Object);
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";

            // Act
            tempData.Keep("Foo");
            object value = tempData["Bar"];
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.True(tempData.ContainsKey("Foo"));
            Assert.False(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void LoadAndSaveAreCaseInsensitive()
        {
            // Arrange
            Dictionary<string, object> data = new Dictionary<string, object>();
            data["Foo"] = "Foo";
            data["Bar"] = "Bar";
            TestTempDataProvider provider = new TestTempDataProvider(data);
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            TempDataDictionary tempData = new TempDataDictionary();

            // Act
            tempData.Load(controllerContext.Object, provider);
            object value = tempData["FOO"];
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.False(tempData.ContainsKey("foo"));
            Assert.True(tempData.ContainsKey("bar"));
        }

        [Fact]
        public void PeekDoesNotMarkKeyAsRead()
        {
            // Arrange
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            tempData["Bar"] = "barValue";

            // Act
            object value = tempData.Peek("bar");
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.Equal("barValue", value);
            Assert.True(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void RemovalOfKeysAreCaseInsensitive()
        {
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            object fooValue;
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";

            // Act
            tempData.TryGetValue("foo", out fooValue);
            object barValue = tempData["bar"];
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.False(tempData.ContainsKey("Foo"));
            Assert.False(tempData.ContainsKey("Boo"));
        }

        [Fact]
        public void SaveRetainsAllKeys()
        {
            // Arrange
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";

            // Act
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.True(tempData.ContainsKey("Foo"));
            Assert.True(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void SaveRemovesKeysThatWereRead()
        {
            // Arrange
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            tempData["Foo"] = "Foo";
            tempData["Bar"] = "Bar";

            // Act
            object value = tempData["Foo"];
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.False(tempData.ContainsKey("Foo"));
            Assert.True(tempData.ContainsKey("Bar"));
        }

        [Fact]
        public void TempDataIsADictionary()
        {
            // Arrange
            TempDataDictionary tempData = new TempDataDictionary();

            // Act
            tempData["Key1"] = "Value1";
            tempData.Add("Key2", "Value2");
            ((ICollection<KeyValuePair<string, object>>)tempData).Add(new KeyValuePair<string, object>("Key3", "Value3"));

            // Assert (IDictionary)
            Assert.Equal(3, tempData.Count);
            Assert.True(tempData.Remove("Key1"));
            Assert.False(tempData.Remove("Key4"));
            Assert.True(tempData.ContainsValue("Value2"));
            Assert.False(tempData.ContainsValue("Value1"));
            Assert.Null(tempData["Key6"]);

            IEnumerator tempDataEnumerator = tempData.GetEnumerator();
            tempDataEnumerator.Reset();
            while (tempDataEnumerator.MoveNext())
            {
                KeyValuePair<string, object> pair = (KeyValuePair<string, object>)tempDataEnumerator.Current;
                Assert.True(((ICollection<KeyValuePair<string, object>>)tempData).Contains(pair));
            }

            // Assert (ICollection)
            foreach (string key in tempData.Keys)
            {
                Assert.True(((ICollection<KeyValuePair<string, object>>)tempData).Contains(new KeyValuePair<string, object>(key, tempData[key])));
            }

            foreach (string value in tempData.Values)
            {
                Assert.True(tempData.ContainsValue(value));
            }

            foreach (string key in ((IDictionary<string, object>)tempData).Keys)
            {
                Assert.True(tempData.ContainsKey(key));
            }

            foreach (string value in ((IDictionary<string, object>)tempData).Values)
            {
                Assert.True(tempData.ContainsValue(value));
            }

            KeyValuePair<string, object>[] keyValuePairArray = new KeyValuePair<string, object>[tempData.Count];
            ((ICollection<KeyValuePair<string, object>>)tempData).CopyTo(keyValuePairArray, 0);

            Assert.False(((ICollection<KeyValuePair<string, object>>)tempData).IsReadOnly);

            Assert.False(((ICollection<KeyValuePair<string, object>>)tempData).Remove(new KeyValuePair<string, object>("Key5", "Value5")));

            IEnumerator<KeyValuePair<string, object>> keyValuePairEnumerator = ((ICollection<KeyValuePair<string, object>>)tempData).GetEnumerator();
            keyValuePairEnumerator.Reset();
            while (keyValuePairEnumerator.MoveNext())
            {
                KeyValuePair<string, object> pair = keyValuePairEnumerator.Current;
                Assert.True(((ICollection<KeyValuePair<string, object>>)tempData).Contains(pair));
            }

            // Act
            tempData.Clear();

            // Assert
            Assert.Empty(tempData);
        }

        [Fact]
        public void TempDataDictionaryCreatesEmptyDictionaryIfProviderReturnsNull()
        {
            // Arrange
            TempDataDictionary tempDataDictionary = new TempDataDictionary();
            NullTempDataProvider provider = new NullTempDataProvider();

            // Act
            tempDataDictionary.Load(null /* controllerContext */, provider);

            // Assert
            Assert.Empty(tempDataDictionary);
        }

        [Fact]
        public void TryGetValueMarksKeyForDeletion()
        {
            NullTempDataProvider provider = new NullTempDataProvider();
            TempDataDictionary tempData = new TempDataDictionary();
            Mock<ControllerContext> controllerContext = new Mock<ControllerContext>();
            object value;
            tempData["Foo"] = "Foo";

            // Act
            tempData.TryGetValue("Foo", out value);
            tempData.Save(controllerContext.Object, provider);

            // Assert
            Assert.False(tempData.ContainsKey("Foo"));
        }

        internal class NullTempDataProvider : ITempDataProvider
        {
            public void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
            {
            }

            public IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
            {
                return null;
            }
        }

        internal class TestTempDataProvider : ITempDataProvider
        {
            private IDictionary<string, object> _data;

            public TestTempDataProvider(IDictionary<string, object> data)
            {
                _data = data;
            }

            public void SaveTempData(ControllerContext controllerContext, IDictionary<string, object> values)
            {
            }

            public IDictionary<string, object> LoadTempData(ControllerContext controllerContext)
            {
                return _data;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/TypeCacheSerializerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class TypeCacheSerializerTest
    {
        private static string _expectedDeserializationFormat =
            "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + Environment.NewLine
          + "<!--This file is automatically generated. Please do not modify the contents of this file.-->" + Environment.NewLine
          + "<typeCache lastModified=\"__IGNORED__\" mvcVersionId=\"{0}\">" + Environment.NewLine
          + "  <assembly name=\"{1}\">" + Environment.NewLine
          + "    <module versionId=\"{2}\">" + Environment.NewLine
          + "      <type>System.String</type>" + Environment.NewLine
          + "      <type>System.Object</type>" + Environment.NewLine
          + "    </module>" + Environment.NewLine
          + "  </assembly>" + Environment.NewLine
          + "</typeCache>";

        private static readonly string _mscorlibAsmFullName = typeof(object).Assembly.FullName;

        [Fact]
        public void DeserializeTypes_ReturnsNullIfModuleVersionIdDoesNotMatch()
        {
            // Arrange
            string expected = String.Format(_expectedDeserializationFormat,
                                            GetMvidForType(typeof(TypeCacheSerializer)) /* mvcVersionId */,
                                            _mscorlibAsmFullName /* assembly.name */,
                                            Guid.Empty /* module.versionId */
                );

            TypeCacheSerializer serializer = new TypeCacheSerializer();
            StringReader input = new StringReader(expected);

            // Act
            List<Type> deserializedTypes = serializer.DeserializeTypes(input);

            // Assert
            Assert.Null(deserializedTypes);
        }

        [Fact]
        public void DeserializeTypes_ReturnsNullIfMvcVersionIdDoesNotMatch()
        {
            // Arrange
            string expected = String.Format(_expectedDeserializationFormat,
                                            Guid.Empty /* mvcVersionId */,
                                            _mscorlibAsmFullName /* assembly.name */,
                                            GetMvidForType(typeof(object)) /* module.versionId */
                );

            TypeCacheSerializer serializer = new TypeCacheSerializer();
            StringReader input = new StringReader(expected);

            // Act
            List<Type> deserializedTypes = serializer.DeserializeTypes(input);

            // Assert
            Assert.Null(deserializedTypes);
        }

        [Fact]
        public void DeserializeTypes_ReturnsNullIfTypeNotFound()
        {
            string expectedFormat =
                "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + Environment.NewLine
              + "<!--This file is automatically generated. Please do not modify the contents of this file.-->" + Environment.NewLine
              + "<typeCache lastModified=\"__IGNORED__\" mvcVersionId=\"{0}\">" + Environment.NewLine
              + "  <assembly name=\"{1}\">" + Environment.NewLine
              + "    <module versionId=\"{2}\">" + Environment.NewLine
              + "      <type>System.String</type>" + Environment.NewLine
              + "      <type>This.Type.Does.Not.Exist</type>" + Environment.NewLine
              + "    </module>" + Environment.NewLine
              + "  </assembly>" + Environment.NewLine
              + "</typeCache>";

            // Arrange
            string expected = String.Format(expectedFormat,
                                            GetMvidForType(typeof(TypeCacheSerializer)) /* mvcVersionId */,
                                            _mscorlibAsmFullName /* assembly.name */,
                                            GetMvidForType(typeof(object)) /* module.versionId */
                );

            TypeCacheSerializer serializer = new TypeCacheSerializer();
            StringReader input = new StringReader(expected);

            // Act
            List<Type> deserializedTypes = serializer.DeserializeTypes(input);

            // Assert
            Assert.Null(deserializedTypes);
        }

        [Fact]
        public void DeserializeTypes_Success()
        {
            // Arrange
            string expected = String.Format(_expectedDeserializationFormat,
                                            GetMvidForType(typeof(TypeCacheSerializer)) /* mvcVersionId */,
                                            _mscorlibAsmFullName /* assembly.name */,
                                            GetMvidForType(typeof(object)) /* module.versionId */
                );

            TypeCacheSerializer serializer = new TypeCacheSerializer();
            StringReader input = new StringReader(expected);

            Type[] expectedTypes = new Type[]
            {
                typeof(string),
                typeof(object)
            };

            // Act
            List<Type> deserializedTypes = serializer.DeserializeTypes(input);

            // Assert
            Assert.Equal(expectedTypes, deserializedTypes.ToArray());
        }

        [Fact]
        public void SerializeTypes()
        {
            // Arrange
            DateTime expectedDate = new DateTime(2001, 1, 1, 0, 0, 0, DateTimeKind.Utc); // Jan 1, 2001 midnight UTC
            string expectedFormat =
                "<?xml version=\"1.0\" encoding=\"utf-16\"?>" + Environment.NewLine
              + "<!--This file is automatically generated. Please do not modify the contents of this file.-->" + Environment.NewLine
              + "<typeCache lastModified=\"{0}\" mvcVersionId=\"{1}\">" + Environment.NewLine
              + "  <assembly name=\"{2}\">" + Environment.NewLine
              + "    <module versionId=\"{3}\">" + Environment.NewLine
              + "      <type>System.String</type>" + Environment.NewLine
              + "      <type>System.Object</type>" + Environment.NewLine
              + "    </module>" + Environment.NewLine
              + "  </assembly>" + Environment.NewLine
              + "</typeCache>";

            string expected = String.Format(CultureInfo.InvariantCulture,
                                            expectedFormat,
                                            expectedDate /* lastModified */,
                                            GetMvidForType(typeof(TypeCacheSerializer)) /* mvcVersionId */,
                                            _mscorlibAsmFullName /* assembly.name */,
                                            GetMvidForType(typeof(object)) /* module.versionId */
                );

            Type[] typesToSerialize = new Type[]
            {
                typeof(string),
                typeof(object)
            };

            TypeCacheSerializer serializer = new TypeCacheSerializer();
            serializer.CurrentDateOverride = expectedDate;

            StringWriter output = new StringWriter();

            // Act
            serializer.SerializeTypes(typesToSerialize, output);
            string outputString = output.ToString();

            // Assert
            Assert.Equal(expected, outputString);
        }

        private static Guid GetMvidForType(Type type)
        {
            return type.Module.ModuleVersionId;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/TypeCacheUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class TypeCacheUtilTest
    {
        [Fact]
        public void GetFilteredTypesFromAssemblies_FallThrough()
        {
            // Arrange
            Type[] expectedTypes = new Type[]
            {
                typeof(TypeCacheValidFoo),
                typeof(TypeCacheValidBar)
            };

            string cacheName = "testCache";
            MockBuildManager buildManager = new MockBuildManager();
            Predicate<Type> predicate = type => type.IsDefined(typeof(TypeCacheMarkerAttribute), true);

            // Act
            List<Type> returnedTypes = TypeCacheUtil.GetFilteredTypesFromAssemblies(cacheName, predicate, buildManager);

            // Assert
            Assert.Equal(expectedTypes, returnedTypes.ToArray());

            MemoryStream cachedStream = buildManager.CachedFileStore[cacheName] as MemoryStream;
            Assert.NotNull(cachedStream);
            Assert.NotEmpty(cachedStream.ToArray());
        }

        [Fact]
        public void SaveToCache_ReadFromCache_ReturnsNullIfTypesAreInvalid()
        {
            // SAVING

            // Arrange
            Type[] expectedTypes = new Type[]
            {
                typeof(object),
                typeof(string)
            };

            TypeCacheSerializer serializer = new TypeCacheSerializer();
            string cacheName = "testCache";
            MockBuildManager buildManager = new MockBuildManager();

            // Act
            TypeCacheUtil.SaveTypesToCache(cacheName, expectedTypes, buildManager, serializer);

            // Assert
            MemoryStream writeStream = buildManager.CachedFileStore[cacheName] as MemoryStream;
            Assert.NotNull(writeStream);

            byte[] streamContents = writeStream.ToArray();
            Assert.NotEmpty(streamContents);

            // READING

            // Arrange
            MemoryStream readStream = new MemoryStream(streamContents);
            buildManager.CachedFileStore[cacheName] = readStream;

            // Act
            List<Type> returnedTypes = TypeCacheUtil.ReadTypesFromCache(cacheName, _ => false /* all types are invalid */, buildManager, serializer);

            // Assert
            Assert.Null(returnedTypes);
        }

        [Fact]
        public void SaveToCache_ReadFromCache_Success()
        {
            // SAVING

            // Arrange
            Type[] expectedTypes = new Type[]
            {
                typeof(object),
                typeof(string)
            };

            TypeCacheSerializer serializer = new TypeCacheSerializer();
            string cacheName = "testCache";
            MockBuildManager buildManager = new MockBuildManager();

            // Act
            TypeCacheUtil.SaveTypesToCache(cacheName, expectedTypes, buildManager, serializer);

            // Assert
            MemoryStream writeStream = buildManager.CachedFileStore[cacheName] as MemoryStream;
            Assert.NotNull(writeStream);

            byte[] streamContents = writeStream.ToArray();
            Assert.NotEmpty(streamContents);

            // READING

            // Arrange
            MemoryStream readStream = new MemoryStream(streamContents);
            buildManager.CachedFileStore[cacheName] = readStream;

            // Act
            List<Type> returnedTypes = TypeCacheUtil.ReadTypesFromCache(cacheName, _ => true /* all types are valid */, buildManager, serializer);

            // Assert
            Assert.Equal(expectedTypes, returnedTypes.ToArray());
        }
    }

    public class TypeCacheMarkerAttribute : Attribute
    {
    }

    [TypeCacheMarker]
    public class TypeCacheValidFoo
    {
    }

    [TypeCacheMarker]
    public class TypeCacheValidBar
    {
    }

    [TypeCacheMarker]
    internal class TypeCacheInvalidInternal
    {
    }

    [TypeCacheMarker]
    public abstract class TypeCacheInvalidAbstract
    {
    }

    [TypeCacheMarker]
    public struct TypeCacheInvalidStruct
    {
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/TypeHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class TypeHelpersTest
    {
        [Fact]
        public void CreateDelegateBindsInstanceMethod()
        {
            // Act
            string s = "Hello, world!";
            Func<string, bool> endsWith = TypeHelpers.CreateDelegate<Func<string, bool>>(TypeHelpers.MsCorLibAssembly, "System.String", "EndsWith", s);

            // Assert
            Assert.NotNull(endsWith);
            Assert.True(endsWith("world!"));
        }

        [Fact]
        public void CreateDelegateBindsStaticMethod()
        {
            // Act
            Func<object, object, string> concat = TypeHelpers.CreateDelegate<Func<object, object, string>>(TypeHelpers.MsCorLibAssembly, "System.String", "Concat", null);

            // Assert
            Assert.NotNull(concat);
            Assert.Equal("45", concat(4, 5));
        }

        [Fact]
        public void CreateDelegateReturnsNullIfTypeDoesNotExist()
        {
            // Act
            Action d = TypeHelpers.CreateDelegate<Action>(TypeHelpers.MsCorLibAssembly, "System.xyz.TypeDoesNotExist", "SomeMethod", null);

            // Assert
            Assert.Null(d);
        }

        [Fact]
        public void CreateDelegateReturnsNullIfMethodDoesNotExist()
        {
            // Act
            Action d = TypeHelpers.CreateDelegate<Action>(TypeHelpers.MsCorLibAssembly, "System.String", "MethodDoesNotExist", null);

            // Assert
            Assert.Null(d);
        }

        [Fact]
        public void CreateTryGetValueDelegateReturnsNullForNonDictionaries()
        {
            // Arrange
            object notDictionary = "Hello, world";

            // Act
            TryGetValueDelegate d = TypeHelpers.CreateTryGetValueDelegate(notDictionary.GetType());

            // Assert
            Assert.Null(d);
        }

        [Fact]
        public void CreateTryGetValueDelegateWrapsGenericObjectDictionaries()
        {
            // Arrange
            object dictionary = new Dictionary<object, int>()
            {
                { "theKey", 42 }
            };

            // Act
            TryGetValueDelegate d = TypeHelpers.CreateTryGetValueDelegate(dictionary.GetType());

            object value;
            bool found = d(dictionary, "theKey", out value);

            // Assert
            Assert.True(found);
            Assert.Equal(42, value);
        }

        [Fact]
        public void CreateTryGetValueDelegateWrapsGenericStringDictionaries()
        {
            // Arrange
            object dictionary = new Dictionary<string, int>()
            {
                { "theKey", 42 }
            };

            // Act
            TryGetValueDelegate d = TypeHelpers.CreateTryGetValueDelegate(dictionary.GetType());

            object value;
            bool found = d(dictionary, "theKey", out value);

            // Assert
            Assert.True(found);
            Assert.Equal(42, value);
        }

        [Fact]
        public void CreateTryGetValueDelegateWrapsNonGenericDictionaries()
        {
            // Arrange
            object dictionary = new Hashtable()
            {
                { "foo", 42 }
            };

            // Act
            TryGetValueDelegate d = TypeHelpers.CreateTryGetValueDelegate(dictionary.GetType());

            object fooValue;
            bool fooIsFound = d(dictionary, "foo", out fooValue);

            object barValue;
            bool barIsFound = d(dictionary, "bar", out barValue);

            // Assert
            Assert.True(fooIsFound);
            Assert.Equal(42, fooValue);
            Assert.False(barIsFound);
            Assert.Null(barValue);
        }

        [Fact]
        public void GetDefaultValue_NullableValueType()
        {
            // Act
            object defaultValue = TypeHelpers.GetDefaultValue(typeof(int?));

            // Assert
            Assert.Equal(default(int?), defaultValue);
        }

        [Fact]
        public void GetDefaultValue_ReferenceType()
        {
            // Act
            object defaultValue = TypeHelpers.GetDefaultValue(typeof(object));

            // Assert
            Assert.Equal(default(object), defaultValue);
        }

        [Fact]
        public void GetDefaultValue_ValueType()
        {
            // Act
            object defaultValue = TypeHelpers.GetDefaultValue(typeof(int));

            // Assert
            Assert.Equal(default(int), defaultValue);
        }

        [Fact]
        public void IsCompatibleObjectReturnsTrueIfTypeIsNotNullableAndValueIsNull()
        {
            // Act
            bool retVal = TypeHelpers.IsCompatibleObject<int>(null);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void IsCompatibleObjectReturnsFalseIfValueIsIncorrectType()
        {
            // Arrange
            object value = new string[] { "Hello", "world" };

            // Act
            bool retVal = TypeHelpers.IsCompatibleObject<int>(value);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void IsCompatibleObjectReturnsTrueIfTypeIsNullableAndValueIsNull()
        {
            // Act
            bool retVal = TypeHelpers.IsCompatibleObject<int?>(null);

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void IsCompatibleObjectReturnsTrueIfValueIsOfCorrectType()
        {
            // Arrange
            object value = new string[] { "Hello", "world" };

            // Act
            bool retVal = TypeHelpers.IsCompatibleObject<IEnumerable<string>>(value);

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void TypeAllowsNullValueReturnsFalseForNonNullableGenericValueType()
        {
            Assert.False(TypeHelpers.TypeAllowsNullValue(typeof(KeyValuePair<int, string>)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsFalseForNonNullableGenericValueTypeDefinition()
        {
            Assert.False(TypeHelpers.TypeAllowsNullValue(typeof(KeyValuePair<,>)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsFalseForNonNullableValueType()
        {
            Assert.False(TypeHelpers.TypeAllowsNullValue(typeof(int)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsTrueForInterfaceType()
        {
            Assert.True(TypeHelpers.TypeAllowsNullValue(typeof(IDisposable)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsTrueForNullableType()
        {
            Assert.True(TypeHelpers.TypeAllowsNullValue(typeof(int?)));
        }

        [Fact]
        public void TypeAllowsNullValueReturnsTrueForReferenceType()
        {
            Assert.True(TypeHelpers.TypeAllowsNullValue(typeof(object)));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/UrlHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using Microsoft.TestCommon;
using Microsoft.Web.UnitTestUtil;
using Moq;

namespace System.Web.Mvc.Test
{
    public class UrlHelperTest
    {
        [Fact]
        public void IsLocalUrl_RejectsNull()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl(null));
        }

        [Fact]
        public void IsLocalUrl_RejectsEmptyString()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl(String.Empty));
            Assert.False(helper.IsLocalUrl(" "));
        }

        [Fact]
        public void IsLocalUrl_AcceptsRootedUrls()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();
            Assert.True(helper.IsLocalUrl("/fooo"));
            Assert.True(helper.IsLocalUrl("/www.hackerz.com"));
            Assert.True(helper.IsLocalUrl("/"));
        }

        [Fact]
        public void IsLocalUrl_AcceptsAppRelativeUrls()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();
            Assert.True(helper.IsLocalUrl("~/"));
            Assert.True(helper.IsLocalUrl("~/foobar.html"));
        }

        [Fact]
        public void IsLocalUrl_RejectsRelativeUrls()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();
            Assert.False(helper.IsLocalUrl("foobar.html"));
            Assert.False(helper.IsLocalUrl("../foobar.html"));
            Assert.False(helper.IsLocalUrl("fold/foobar.html"));
        }

        [Fact]
        public void IsLocalUrl_RejectValidButUnsafeRelativeUrls()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl("http:/foobar.html"));
            Assert.False(helper.IsLocalUrl("hTtP:foobar.html"));
            Assert.False(helper.IsLocalUrl("http:/www.hackerz.com"));
            Assert.False(helper.IsLocalUrl("HtTpS:/www.hackerz.com"));
        }

        [Fact]
        public void IsLocalUrl_RejectsUrlsOnTheSameHost()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl("http://www.mysite.com/appDir/foobar.html"));
            Assert.False(helper.IsLocalUrl("http://WWW.MYSITE.COM"));
        }

        [Fact]
        public void IsLocalUrl_RejectsUrlsOnLocalHost()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl("http://localhost/foobar.html"));
            Assert.False(helper.IsLocalUrl("http://127.0.0.1/foobar.html"));
        }

        [Fact]
        public void IsLocalUrl_RejectsUrlsOnTheSameHostButDifferentScheme()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl("https://www.mysite.com/"));
        }

        [Fact]
        public void IsLocalUrl_RejectsUrlsOnDifferentHost()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl("http://www.hackerz.com"));
            Assert.False(helper.IsLocalUrl("https://www.hackerz.com"));
            Assert.False(helper.IsLocalUrl("hTtP://www.hackerz.com"));
            Assert.False(helper.IsLocalUrl("HtTpS://www.hackerz.com"));
        }

        [Fact]
        public void IsLocalUrl_RejectsUrlsWithTooManySchemeSeparatorCharacters()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl("http://///www.hackerz.com/foobar.html"));
            Assert.False(helper.IsLocalUrl("https://///www.hackerz.com/foobar.html"));
            Assert.False(helper.IsLocalUrl("HtTpS://///www.hackerz.com/foobar.html"));

            Assert.False(helper.IsLocalUrl("http:///www.hackerz.com/foobar.html"));
            Assert.False(helper.IsLocalUrl("http:////www.hackerz.com/foobar.html"));
            Assert.False(helper.IsLocalUrl("http://///www.hackerz.com/foobar.html"));
        }

        [Fact]
        public void IsLocalUrl_RejectsUrlsWithMissingSchemeName()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl("//www.hackerz.com"));
            Assert.False(helper.IsLocalUrl("//www.hackerz.com/foobar.html"));
            Assert.False(helper.IsLocalUrl("///www.hackerz.com"));
            Assert.False(helper.IsLocalUrl("//////www.hackerz.com"));
        }

        [Fact]
        public void IsLocalUrl_RejectsInvalidUrls()
        {
            UrlHelper helper = GetUrlHelperForIsLocalUrl();

            Assert.False(helper.IsLocalUrl(@"http:\\www.hackerz.com"));
            Assert.False(helper.IsLocalUrl(@"http:\\www.hackerz.com\"));
        }

        [Fact]
        public void RequestContextProperty()
        {
            // Arrange
            RequestContext requestContext = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            UrlHelper urlHelper = new UrlHelper(requestContext);

            // Assert
            Assert.Equal(requestContext, urlHelper.RequestContext);
        }

        [Fact]
        public void ConstructorWithNullRequestContextThrows()
        {
            // Assert
            Assert.ThrowsArgumentNull(
                delegate { new UrlHelper(null); },
                "requestContext");
        }

        [Fact]
        public void ConstructorWithNullRouteCollectionThrows()
        {
            // Assert
            Assert.ThrowsArgumentNull(
                delegate { new UrlHelper(GetRequestContext(), null); },
                "routeCollection");
        }

        [Fact]
        public void ActionEmpty()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action();

            // Assert
            Assert.Equal("/app/", url);
        }

        [Fact]
        public void Action()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction");

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home/newaction", url);
        }

        [Fact]
        public void ActionWithControllerName()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", "home2");

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction", url);
        }

        [Fact]
        public void ActionWithControllerNameAndDictionary()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", "home2", new RouteValueDictionary(new { id = "someid" }));

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void ActionWithControllerNameAndObjectProperties()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", "home2", new { id = "someid" });

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void ActionWithDictionary()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", new RouteValueDictionary(new { Controller = "home2", id = "someid" }));

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void ActionWithNullActionName()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action(null);

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home/oldaction", url);
        }

        [Fact]
        public void ActionWithNullProtocol()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", "home2", new { id = "someid" }, null /* protocol */);

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void ActionParameterOverridesObjectProperties()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", new { Action = "action" });

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home/newaction", url);
        }

        [Fact]
        public void ActionWithObjectProperties()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", new { Controller = "home2", id = "someid" });

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void ActionWithProtocol()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", "home2", new { id = "someid" }, "https");

            // Assert
            Assert.Equal("https://localhost" + MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void ActionWithProtocolAndRouteValueDictionary()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Action("newaction", "home2", new RouteValueDictionary(new { id = "someid" }), "https");

            // Assert
            Assert.Equal("https://localhost" + MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void ContentWithAbsolutePath()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Content("/Content/Image.jpg");

            // Assert
            Assert.Equal("/Content/Image.jpg", url);
        }

        [Fact]
        public void ContentWithAppRelativePath()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Content("~/Content/Image.jpg");

            // Assert
            Assert.Equal("/app/Content/Image.jpg", url);
        }

        [Fact]
        public void ContentWithEmptyPathThrows()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate() { urlHelper.Content(String.Empty); },
                "contentPath");
        }

        [Fact]
        public void ContentWithRelativePath()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Content("Content/Image.jpg");

            // Assert
            Assert.Equal("Content/Image.jpg", url);
        }

        [Fact]
        public void ContentWithExternalUrl()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.Content("http://www.asp.net/App_Themes/Standard/i/logo.png");

            // Assert
            Assert.Equal("http://www.asp.net/App_Themes/Standard/i/logo.png", url);
        }

        [Fact]
        public void Encode()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string encodedUrl = urlHelper.Encode(@"SomeUrl /+\");

            // Assert
            Assert.Equal("SomeUrl+%2f%2b%5c", encodedUrl);
        }

        [Fact]
        public void GenerateContentUrlWithNullContentPathThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate() { UrlHelper.GenerateContentUrl(null, null); },
                "contentPath");
        }

        [Fact]
        public void GenerateContentUrlWithNullContextThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate() { UrlHelper.GenerateContentUrl("Content/foo.png", null); },
                "httpContext");
        }

        [Fact]
        public void GenerateUrlWithNullRequestContextThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate() { UrlHelper.GenerateUrl(null /* routeName */, null /* actionName */, null /* controllerName */, null /* routeValues */, new RouteCollection(), null /* requestContext */, false); },
                "requestContext");
        }

        [Fact]
        public void GenerateUrlWithNullRouteCollectionThrows()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate() { UrlHelper.GenerateUrl(null /* routeName */, null /* actionName */, null /* controllerName */, null /* routeValues */, null /* routeCollection */, null /* requestContext */, false); },
                "routeCollection");
        }

        [Fact]
        public void GenerateUrlWithEmptyCollectionsReturnsNull()
        {
            // Arrange
            RequestContext requestContext = GetRequestContext();

            // Act
            string url = UrlHelper.GenerateUrl(null, null, null, null, new RouteCollection(), requestContext, true);

            // Assert
            Assert.Null(url);
        }

        [Fact]
        public void GenerateUrlWithAction()
        {
            // Arrange
            RequestContext requestContext = GetRequestContext(GetRouteData());

            // Act
            string url = UrlHelper.GenerateUrl(null, "newaction", null, null, GetRouteCollection(), requestContext, true);

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home/newaction", url);
        }

        [Fact]
        public void GenerateUrlWithActionAndController()
        {
            // Arrange
            RequestContext requestContext = GetRequestContext(GetRouteData());

            // Act
            string url = UrlHelper.GenerateUrl(null, "newaction", "newcontroller", null, GetRouteCollection(), requestContext, true);

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/newcontroller/newaction", url);
        }

        [Fact]
        public void GenerateUrlWithImplicitValues()
        {
            // Arrange
            RequestContext requestContext = GetRequestContext(GetRouteData());

            // Act
            string url = UrlHelper.GenerateUrl(null, null, null, null, GetRouteCollection(), requestContext, true);

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home/oldaction", url);
        }

        [Fact]
        public void RouteUrlCanUseNamedRouteWithoutSpecifyingDefaults()
        {
            // DevDiv 217072: Non-mvc specific helpers should not give default values for controller and action

            // Arrange
            UrlHelper urlHelper = GetUrlHelper();
            urlHelper.RouteCollection.MapRoute("MyRouteName", "any/url", new { controller = "Charlie" });

            // Act
            string result = urlHelper.RouteUrl("MyRouteName");

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/any/url", result);
        }

        [Fact]
        public void RouteUrlWithDictionary()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl(new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }));

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithEmptyHostName()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute", new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }), "http", String.Empty /* hostName */);

            // Assert
            Assert.Equal("http://localhost" + MvcHelper.AppPathModifier + "/app/named/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithEmptyProtocol()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute", new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }), String.Empty /* protocol */, "foo.bar.com");

            // Assert
            Assert.Equal("http://foo.bar.com" + MvcHelper.AppPathModifier + "/app/named/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithNullProtocol()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute", new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }), null /* protocol */, "foo.bar.com");

            // Assert
            Assert.Equal("http://foo.bar.com" + MvcHelper.AppPathModifier + "/app/named/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithNullProtocolAndNullHostName()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute", new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }), null /* protocol */, null /* hostName */);

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/named/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithObjectProperties()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl(new { Action = "newaction", Controller = "home2", id = "someid" });

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithProtocol()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute", new { Action = "newaction", Controller = "home2", id = "someid" }, "https");

            // Assert
            Assert.Equal("https://localhost" + MvcHelper.AppPathModifier + "/app/named/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithRouteNameAndDefaults()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute");

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/named/home/oldaction", url);
        }

        [Fact]
        public void RouteUrlWithRouteNameAndDictionary()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute", new RouteValueDictionary(new { Action = "newaction", Controller = "home2", id = "someid" }));

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/named/home2/newaction/someid", url);
        }

        [Fact]
        public void RouteUrlWithRouteNameAndObjectProperties()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.RouteUrl("namedroute", new { Action = "newaction", Controller = "home2", id = "someid" });

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/named/home2/newaction/someid", url);
        }

        [Fact]
        public void HttpRouteUrlFindsHttpRoute()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();

            // Act
            string url = urlHelper.HttpRouteUrl("httproute", new { Action = "newaction", Controller = "home2", id = "someid" });

            // Assert
            Assert.Equal(MvcHelper.AppPathModifier + "/app/mock/http/route", url);
        }

        [Fact]
        public void UrlGenerationDoesNotChangeProvidedDictionary()
        {
            // Arrange
            UrlHelper urlHelper = GetUrlHelper();
            RouteValueDictionary valuesDictionary = new RouteValueDictionary();

            // Act
            urlHelper.Action("actionName", valuesDictionary);

            // Assert
            Assert.Empty(valuesDictionary);
            Assert.False(valuesDictionary.ContainsKey("action"));
        }

        [Fact]
        public void UrlGenerationReturnsNullWhenSubsequentSegmentHasValue()
        { // Dev10 Bug #924729
            // Arrange
            RouteCollection routes = new RouteCollection();
            routes.MapRoute("SampleRoute", "testing/{a}/{b}/{c}",
                            new
                            {
                                controller = "controller",
                                action = "action",
                                b = UrlParameter.Optional,
                                c = UrlParameter.Optional
                            });

            UrlHelper helper = GetUrlHelper(routeCollection: routes);

            // Act
            string url = helper.Action("action", "controller", new { a = 42, c = 2112 });

            // Assert
            Assert.Null(url);
        }

        private static RequestContext GetRequestContext()
        {
            HttpContextBase httpcontext = MvcHelper.GetHttpContext("/app/", null, null);
            RouteData rd = new RouteData();
            return new RequestContext(httpcontext, rd);
        }

        private static RequestContext GetRequestContext(RouteData routeData)
        {
            HttpContextBase httpcontext = MvcHelper.GetHttpContext("/app/", null, null);
            return new RequestContext(httpcontext, routeData);
        }

        private static RouteCollection GetRouteCollection()
        {
            RouteCollection rt = new RouteCollection();
            rt.Add(new Route("{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });

            // Adding a route that recognizes the httproute value for the HttpRouteUrl tests
            Mock<RouteBase> mockHttpRoute = new Mock<RouteBase>();
            mockHttpRoute.Setup(mock => mock.GetVirtualPath(It.IsAny<RequestContext>(), It.Is<RouteValueDictionary>(routeValues => routeValues.ContainsKey("httproute"))))
                .Returns(new VirtualPathData(null, "mock/http/route"));
            rt.Add("httproute", mockHttpRoute.Object);

            return rt;
        }

        private static RouteData GetRouteData()
        {
            RouteData rd = new RouteData();
            rd.Values.Add("controller", "home");
            rd.Values.Add("action", "oldaction");
            return rd;
        }

        private static UrlHelper GetUrlHelper()
        {
            return GetUrlHelper(GetRouteData(), GetRouteCollection());
        }

        private static UrlHelper GetUrlHelper(RouteData routeData = null, RouteCollection routeCollection = null)
        {
            HttpContextBase httpcontext = MvcHelper.GetHttpContext("/app/", null, null);
            UrlHelper urlHelper = new UrlHelper(new RequestContext(httpcontext, routeData ?? new RouteData()), routeCollection ?? new RouteCollection());
            return urlHelper;
        }

        private static UrlHelper GetUrlHelperForIsLocalUrl()
        {
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.SetupGet(context => context.Request.Url).Returns(new Uri("http://www.mysite.com/"));
            RequestContext requestContext = new RequestContext(contextMock.Object, new RouteData());
            UrlHelper helper = new UrlHelper(requestContext);
            return helper;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/UrlParameterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class UrlParameterTest
    {
        [Fact]
        public void UrlParameterOptionalToStringReturnsEmptyString()
        {
            // Act & Assert
            Assert.Empty(UrlParameter.Optional.ToString());
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValidatableObjectAdapterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class ValidatableObjectAdapterTest
    {
        // IValidatableObject support

        [Fact]
        public void NonIValidatableObjectInsideMetadataThrows()
        {
            // Arrange
            var context = new ControllerContext();
            var validatable = new Mock<IValidatableObject>();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => 42, typeof(IValidatableObject));
            var validator = new ValidatableObjectAdapter(metadata, context);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => validator.Validate(null),
                "The model object inside the metadata claimed to be compatible with System.ComponentModel.DataAnnotations.IValidatableObject, but was actually System.Int32.");
        }

        [Fact]
        public void IValidatableObjectGetsAProperlyPopulatedValidationContext()
        {
            // Arrange
            var context = new ControllerContext();
            var validatable = new Mock<IValidatableObject>();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => validatable.Object, validatable.Object.GetType());
            var validator = new ValidatableObjectAdapter(metadata, context);
            ValidationContext validationContext = null;
            validatable.Setup(vo => vo.Validate(It.IsAny<ValidationContext>()))
                .Callback<ValidationContext>(vc => validationContext = vc)
                .Returns(Enumerable.Empty<ValidationResult>())
                .Verifiable();

            // Act
            validator.Validate(null);

            // Assert
            validatable.Verify();
            Assert.Same(validatable.Object, validationContext.ObjectInstance);
            Assert.Null(validationContext.MemberName);
        }

        [Fact]
        public void IValidatableObjectWithNoErrors()
        {
            // Arrange
            var context = new ControllerContext();
            var validatable = new Mock<IValidatableObject>();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => validatable.Object, validatable.Object.GetType());
            var validator = new ValidatableObjectAdapter(metadata, context);
            validatable.Setup(vo => vo.Validate(It.IsAny<ValidationContext>()))
                .Returns(Enumerable.Empty<ValidationResult>());

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(null);

            // Assert
            Assert.Empty(results);
        }

        [Fact]
        public void IValidatableObjectWithModelLevelError()
        {
            // Arrange
            var context = new ControllerContext();
            var validatable = new Mock<IValidatableObject>();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => validatable.Object, validatable.Object.GetType());
            var validator = new ValidatableObjectAdapter(metadata, context);
            validatable.Setup(vo => vo.Validate(It.IsAny<ValidationContext>()))
                .Returns(new ValidationResult[] { new ValidationResult("Error Message") });

            // Act
            ModelValidationResult result = validator.Validate(null).Single();

            // Assert
            Assert.Equal("Error Message", result.Message);
            Assert.Equal(String.Empty, result.MemberName);
        }

        [Fact]
        public void IValidatableObjectWithMultipleModelLevelErrors()
        {
            // Arrange
            var context = new ControllerContext();
            var validatable = new Mock<IValidatableObject>();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => validatable.Object, validatable.Object.GetType());
            var validator = new ValidatableObjectAdapter(metadata, context);
            validatable.Setup(vo => vo.Validate(It.IsAny<ValidationContext>()))
                .Returns(new ValidationResult[]
                {
                    new ValidationResult("Error Message 1"),
                    new ValidationResult("Error Message 2")
                });

            // Act
            ModelValidationResult[] results = validator.Validate(null).ToArray();

            // Assert
            Assert.Equal(2, results.Length);
            Assert.Equal("Error Message 1", results[0].Message);
            Assert.Equal("Error Message 2", results[1].Message);
        }

        [Fact]
        public void IValidatableObjectWithMultiPropertyValidationFailure()
        {
            // Arrange
            var context = new ControllerContext();
            var validatable = new Mock<IValidatableObject>();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => validatable.Object, validatable.Object.GetType());
            var validator = new ValidatableObjectAdapter(metadata, context);
            validatable.Setup(vo => vo.Validate(It.IsAny<ValidationContext>()))
                .Returns(new[] { new ValidationResult("Error Message", new[] { "Property1", "Property2" }) })
                .Verifiable();

            // Act
            ModelValidationResult[] results = validator.Validate(null).ToArray();

            // Assert
            validatable.Verify();
            Assert.Equal(2, results.Length);
            Assert.Equal("Error Message", results[0].Message);
            Assert.Equal("Property1", results[0].MemberName);
            Assert.Equal("Error Message", results[1].Message);
            Assert.Equal("Property2", results[1].MemberName);
        }

        [Fact]
        public void IValidatableObjectWhichIsNullReturnsNoErrors()
        {
            // Arrange
            var context = new ControllerContext();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => null, typeof(IValidatableObject));
            var validator = new ValidatableObjectAdapter(metadata, context);

            // Act
            IEnumerable<ModelValidationResult> results = validator.Validate(null);

            // Assert
            Assert.Empty(results);
        }

        [Fact]
        public void IValidatableObjectWhichReturnsValidationResultSuccessReturnsNoErrors()
        {
            // Arrange
            var context = new ControllerContext();
            var validatable = new Mock<IValidatableObject>();
            var metadata = ModelMetadataProviders.Current.GetMetadataForType(() => validatable.Object, validatable.Object.GetType());
            var validator = new ValidatableObjectAdapter(metadata, context);
            validatable.Setup(vo => vo.Validate(It.IsAny<ValidationContext>()))
                .Returns(new[] { ValidationResult.Success })
                .Verifiable();

            // Act
            ModelValidationResult[] results = validator.Validate(null).ToArray();

            // Assert
            validatable.Verify();
            Assert.Empty(results);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValidateAntiForgeryTokenAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Helpers;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ValidateAntiForgeryTokenAttributeTest
    {
        [Fact]
        public void OnAuthorization_ThrowsIfFilterContextIsNull()
        {
            // Arrange
            ValidateAntiForgeryTokenAttribute attribute = new ValidateAntiForgeryTokenAttribute();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { attribute.OnAuthorization(null); }, "filterContext");
        }

        [Fact]
        public void OnAuthorization_ForwardsAttributes()
        {
            // Arrange
            HttpContextBase context = new Mock<HttpContextBase>().Object;
            Mock<AuthorizationContext> authorizationContextMock = new Mock<AuthorizationContext>();
            authorizationContextMock.SetupGet(ac => ac.HttpContext).Returns(context);
            bool validateCalled = false;
            Action validateMethod = () =>
            {
                validateCalled = true;
            };
            ValidateAntiForgeryTokenAttribute attribute = new ValidateAntiForgeryTokenAttribute(validateMethod);

            // Act
            attribute.OnAuthorization(authorizationContextMock.Object);

            // Assert
            Assert.True(validateCalled);
        }

        [Fact]
        public void ValidateThunk_DefaultsToAntiForgeryMethod()
        {
            // Arrange
            ValidateAntiForgeryTokenAttribute attribute = new ValidateAntiForgeryTokenAttribute();

            // Act & Assert
            Assert.Equal(AntiForgery.Validate, attribute.ValidateAction);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValidateInputAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ValidateInputAttributeTest
    {
        [Fact]
        public void EnableValidationProperty()
        {
            // Act
            ValidateInputAttribute attrTrue = new ValidateInputAttribute(true);
            ValidateInputAttribute attrFalse = new ValidateInputAttribute(false);

            // Assert
            Assert.True(attrTrue.EnableValidation);
            Assert.False(attrFalse.EnableValidation);
        }

        [Fact]
        public void OnAuthorizationSetsControllerValidateRequestToFalse()
        {
            // Arrange
            Controller controller = new EmptyController() { ValidateRequest = true };
            ValidateInputAttribute attr = new ValidateInputAttribute(enableValidation: false);
            AuthorizationContext authContext = GetAuthorizationContext(controller);

            // Act
            attr.OnAuthorization(authContext);

            // Assert
            Assert.False(controller.ValidateRequest);
        }

        [Fact]
        public void OnAuthorizationSetsControllerValidateRequestToTrue()
        {
            // Arrange
            Controller controller = new EmptyController() { ValidateRequest = false };
            ValidateInputAttribute attr = new ValidateInputAttribute(enableValidation: true);
            AuthorizationContext authContext = GetAuthorizationContext(controller);

            // Act
            attr.OnAuthorization(authContext);

            // Assert
            Assert.True(controller.ValidateRequest);
        }

        [Fact]
        public void OnAuthorizationThrowsIfFilterContextIsNull()
        {
            // Arrange
            ValidateInputAttribute attr = new ValidateInputAttribute(true);

            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { attr.OnAuthorization(null); }, "filterContext");
        }

        private static AuthorizationContext GetAuthorizationContext(ControllerBase controller)
        {
            Mock<AuthorizationContext> mockAuthContext = new Mock<AuthorizationContext>();
            mockAuthContext.Setup(c => c.Controller).Returns(controller);
            return mockAuthContext.Object;
        }

        private class EmptyController : Controller
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValueProviderCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ValueProviderCollectionTest
    {
        [Fact]
        public void ListWrappingConstructor()
        {
            // Arrange
            List<IValueProvider> list = new List<IValueProvider>()
            {
                new Mock<IValueProvider>().Object, new Mock<IValueProvider>().Object
            };

            // Act
            ValueProviderCollection collection = new ValueProviderCollection(list);

            // Assert
            Assert.Equal(list, collection.ToList());
        }

        [Fact]
        public void ListWrappingConstructorThrowsIfListIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ValueProviderCollection(null); },
                "list");
        }

        [Fact]
        public void DefaultConstructor()
        {
            // Act
            ValueProviderCollection collection = new ValueProviderCollection();

            // Assert
            Assert.Empty(collection);
        }

        [Fact]
        public void AddNullValueProviderThrows()
        {
            // Arrange
            ValueProviderCollection collection = new ValueProviderCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection.Add(null); },
                "item");
        }

        [Fact]
        public void SetItem()
        {
            // Arrange
            ValueProviderCollection collection = new ValueProviderCollection();
            collection.Add(new Mock<IValueProvider>().Object);

            IValueProvider newProvider = new Mock<IValueProvider>().Object;

            // Act
            collection[0] = newProvider;

            // Assert
            IValueProvider provider = Assert.Single(collection);
            Assert.Equal(newProvider, provider);
        }

        [Fact]
        public void SetNullValueProviderThrows()
        {
            // Arrange
            ValueProviderCollection collection = new ValueProviderCollection();
            collection.Add(new Mock<IValueProvider>().Object);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection[0] = null; },
                "item");
        }

        [Fact]
        public void ContainsPrefix()
        {
            // Arrange
            string prefix = "somePrefix";

            Mock<IValueProvider> mockProvider1 = new Mock<IValueProvider>();
            mockProvider1.Setup(p => p.ContainsPrefix(prefix)).Returns(false);
            Mock<IValueProvider> mockProvider2 = new Mock<IValueProvider>();
            mockProvider2.Setup(p => p.ContainsPrefix(prefix)).Returns(true);
            Mock<IValueProvider> mockProvider3 = new Mock<IValueProvider>();
            mockProvider3.Setup(p => p.ContainsPrefix(prefix)).Returns(false);

            ValueProviderCollection collection = new ValueProviderCollection()
            {
                mockProvider1.Object, mockProvider2.Object, mockProvider3.Object
            };

            // Act
            bool retVal = collection.ContainsPrefix(prefix);

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void GetValue()
        {
            // Arrange
            string key = "someKey";

            Mock<IValueProvider> mockProvider1 = new Mock<IValueProvider>();
            mockProvider1.Setup(p => p.GetValue(key)).Returns((ValueProviderResult)null);
            Mock<IValueProvider> mockProvider2 = new Mock<IValueProvider>();
            mockProvider2.Setup(p => p.GetValue(key)).Returns(new ValueProviderResult("2", "2", null));
            Mock<IValueProvider> mockProvider3 = new Mock<IValueProvider>();
            mockProvider3.Setup(p => p.GetValue(key)).Returns(new ValueProviderResult("3", "3", null));

            ValueProviderCollection collection = new ValueProviderCollection()
            {
                mockProvider1.Object, mockProvider2.Object, mockProvider3.Object
            };

            // Act
            ValueProviderResult result = collection.GetValue(key);

            // Assert
            Assert.NotNull(result);
            Assert.Equal(2, result.ConvertTo(typeof(int)));
        }

        [Fact]
        public void GetValueFromProvider_NormalProvider_DoNotSkipValidation()
        {
            // Arrange
            ValueProviderResult expectedResult = new ValueProviderResult("Success", "Success", null);

            Mock<IValueProvider> mockProvider = new Mock<IValueProvider>();
            mockProvider.Setup(o => o.GetValue("key")).Returns(expectedResult);

            // Act
            ValueProviderResult actualResult = ValueProviderCollection.GetValueFromProvider(mockProvider.Object, "key", skipValidation: false);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }

        [Fact]
        public void GetValueFromProvider_NormalProvider_SkipValidation()
        {
            // Arrange
            ValueProviderResult expectedResult = new ValueProviderResult("Success", "Success", null);

            Mock<IValueProvider> mockProvider = new Mock<IValueProvider>();
            mockProvider.Setup(o => o.GetValue("key")).Returns(expectedResult);

            // Act
            ValueProviderResult actualResult = ValueProviderCollection.GetValueFromProvider(mockProvider.Object, "key", skipValidation: true);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }

        [Fact]
        public void GetValueFromProvider_UnvalidatedProvider_DoNotSkipValidation()
        {
            // Arrange
            ValueProviderResult expectedResult = new ValueProviderResult("Success", "Success", null);

            Mock<IUnvalidatedValueProvider> mockProvider = new Mock<IUnvalidatedValueProvider>();
            mockProvider.Setup(o => o.GetValue("key", false)).Returns(expectedResult);

            // Act
            ValueProviderResult actualResult = ValueProviderCollection.GetValueFromProvider(mockProvider.Object, "key", skipValidation: false);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }

        [Fact]
        public void GetValueFromProvider_UnvalidatedProvider_SkipValidation()
        {
            // Arrange
            ValueProviderResult expectedResult = new ValueProviderResult("Success", "Success", null);

            Mock<IUnvalidatedValueProvider> mockProvider = new Mock<IUnvalidatedValueProvider>();
            mockProvider.Setup(o => o.GetValue("key", true)).Returns(expectedResult);

            // Act
            ValueProviderResult actualResult = ValueProviderCollection.GetValueFromProvider(mockProvider.Object, "key", skipValidation: true);

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }

        [Fact]
        public void GetValueFromProvider_EnumeratedProvider_GoodPrefix()
        {
            // Arrange
            IDictionary<string, string> expectedResult = new Dictionary<string, string>()
            {
                { "random", "random.hello" }
            };

            Mock<IEnumerableValueProvider> mockProvider = new Mock<IEnumerableValueProvider>();
            mockProvider.Setup(o => o.GetKeysFromPrefix("prefix")).Returns(expectedResult);

            ValueProviderCollection providerCollection = new ValueProviderCollection(new List<IValueProvider>() { mockProvider.Object });

            // Act
            IDictionary<string, string> actualResult = providerCollection.GetKeysFromPrefix("prefix");

            // Assert
            Assert.Equal(expectedResult, actualResult);
        }

        [Fact]
        public void GetValueFromProvider_EnumeratedProvider_NotFound_DoNotReturnNull()
        {
            // Arrange
            IDictionary<string, string> expectedResult = new Dictionary<string, string>()
            {
                { "random", "random.hello" }
            };

            Mock<IEnumerableValueProvider> mockProvider = new Mock<IEnumerableValueProvider>();
            mockProvider.Setup(o => o.GetKeysFromPrefix("notfound")).Returns(expectedResult);

            ValueProviderCollection providerCollection = new ValueProviderCollection(new List<IValueProvider>() { mockProvider.Object });

            // Act
            IDictionary<string, string> actualResult = providerCollection.GetKeysFromPrefix("prefix");

            // Assert
            Assert.NotNull(actualResult);
            Assert.Empty(actualResult);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValueProviderDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Globalization;
using System.Web.Routing;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

#pragma warning disable 0618    // ValueProviderDictionary is now obsolete

namespace System.Web.Mvc.Test
{
    public class ValueProviderDictionaryTest
    {
        [Fact]
        public void ConstructorCreatesEmptyDictionaryIfControllerContextIsNull()
        {
            // Act
            ValueProviderDictionary dict = new ValueProviderDictionary(null);

            // Assert
            Assert.Empty(dict);
        }

        [Fact]
        public void ControllerContextProperty()
        {
            // Arrange
            ControllerContext expected = GetControllerContext();
            ValueProviderDictionary dict = new ValueProviderDictionary(expected);

            // Act
            ControllerContext returned = dict.ControllerContext;

            // Assert
            Assert.Equal(expected, returned);
        }

        [Fact]
        public void DictionaryInterface()
        {
            // Arrange
            DictionaryHelper<string, ValueProviderResult> helper = new DictionaryHelper<string, ValueProviderResult>()
            {
                Creator = () => new ValueProviderDictionary(null),
                Comparer = StringComparer.OrdinalIgnoreCase,
                SampleKeys = new string[] { "foo", "bar", "baz", "quux", "QUUX" },
                SampleValues = new ValueProviderResult[]
                {
                    new ValueProviderResult(null, null, null),
                    new ValueProviderResult(null, null, null),
                    new ValueProviderResult(null, null, null),
                    new ValueProviderResult(null, null, null),
                    new ValueProviderResult(null, null, null)
                },
                ThrowOnKeyNotFound = false
            };

            // Act & assert
            helper.Execute();
        }

        [Fact]
        public void AddWithRawValueUsesInvariantCulture()
        {
            // Arrange
            ValueProviderDictionary dict = new ValueProviderDictionary(null);

            // Act
            dict.Add("foo", 42);

            // Assert
            ValueProviderResult vpResult = dict["foo"];
            Assert.Equal("42", vpResult.AttemptedValue);
            Assert.Equal(42, vpResult.RawValue);
            Assert.Equal(CultureInfo.InvariantCulture, vpResult.Culture);
        }

        [Fact]
        public void NullAndEmptyKeysAreIgnored()
        {
            // DevDiv Bugs #216667: Exception thrown when querystring contains name without value

            // Arrange
            ValueProviderDictionary dict = GetAndPopulateDictionary();

            // Act
            bool emptyKeyFound = dict.ContainsKey(String.Empty);

            // Assert
            Assert.False(emptyKeyFound);
        }

        [Fact]
        public void ValueFromForm()
        {
            // Arrange
            ValueProviderDictionary dict;

            // Act
            using (new CultureReplacer("fr-FR"))
            {
                dict = GetAndPopulateDictionary();
            }
            ValueProviderResult result = dict["foo"];

            // Assert
            Assert.NotNull(result);
            Assert.Equal("fooFromForm", result.AttemptedValue);
            string[] stringValues = Assert.IsType<string[]>(result.RawValue);
            string stringValue = Assert.Single(stringValues);
            Assert.Equal("fooFromForm", stringValue);
            Assert.Equal(CultureInfo.GetCultureInfo("fr-FR"), result.Culture);
        }

        [Fact]
        public void ValueFromQueryString()
        {
            // Arrange
            ValueProviderDictionary dict;

            // Act
            using (new CultureReplacer("fr-FR"))
            {
                dict = GetAndPopulateDictionary();
            }
            ValueProviderResult result = dict["baz"];

            // Assert
            Assert.NotNull(result);
            Assert.Equal("bazFromQueryString", result.AttemptedValue);
            string[] stringValues = Assert.IsType<string[]>(result.RawValue);
            string stringValue = Assert.Single(stringValues);
            Assert.Equal("bazFromQueryString", stringValue);
            Assert.Equal(CultureInfo.InvariantCulture, result.Culture);
        }

        [Fact]
        public void ValueFromRoute()
        {
            // Arrange
            ValueProviderDictionary dict;

            // Act
            using (new CultureReplacer("fr-FR"))
            {
                dict = GetAndPopulateDictionary();
            }
            ValueProviderResult result = dict["bar"];

            // Assert
            Assert.NotNull(result);
            Assert.Equal("barInRoute", result.AttemptedValue);
            Assert.Equal("barInRoute", result.RawValue);
            Assert.Equal(CultureInfo.InvariantCulture, result.Culture);
        }

        private static ValueProviderDictionary GetAndPopulateDictionary()
        {
            return new ValueProviderDictionary(GetControllerContext());
        }

        private static ControllerContext GetControllerContext()
        {
            NameValueCollection form = new NameValueCollection() { { "foo", "fooFromForm" } };

            RouteData rd = new RouteData();
            rd.Values["foo"] = "fooFromRoute";
            rd.Values["bar"] = "barInRoute";

            NameValueCollection queryString = new NameValueCollection()
            {
                { "foo", "fooFromQueryString" },
                { "bar", "barInQueryString" },
                { "baz", "bazFromQueryString" },
                { null, "nullValue" },
                { "", "emptyStringValue" }
            };

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.Form).Returns(form);
            mockControllerContext.Setup(c => c.HttpContext.Request.QueryString).Returns(queryString);
            mockControllerContext.Setup(c => c.RouteData).Returns(rd);
            return mockControllerContext.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValueProviderFactoriesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ValueProviderFactoriesTest
    {
        [Fact]
        public void CollectionDefaults()
        {
            // Arrange
            Type[] expectedTypes = new[]
            {
                typeof(ChildActionValueProviderFactory),
                typeof(FormValueProviderFactory),
                typeof(JsonValueProviderFactory),
                typeof(RouteDataValueProviderFactory),
                typeof(QueryStringValueProviderFactory),
                typeof(HttpFileCollectionValueProviderFactory),
                typeof(JQueryFormValueProviderFactory),
            };

            // Act
            Type[] actualTypes = ValueProviderFactories.Factories.Select(p => p.GetType()).ToArray();

            // Assert
            Assert.Equal(expectedTypes, actualTypes);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValueProviderFactoryCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ValueProviderFactoryCollectionTest
    {
        [Fact]
        public void ListWrappingConstructor()
        {
            // Arrange
            List<ValueProviderFactory> list = new List<ValueProviderFactory>()
            {
                new FormValueProviderFactory()
            };

            // Act
            ValueProviderFactoryCollection collection = new ValueProviderFactoryCollection(list);

            // Assert
            Assert.Equal(list, collection.ToList());
        }

        [Fact]
        public void ListWrappingConstructorThrowsIfListIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ValueProviderFactoryCollection(null); },
                "list");
        }

        [Fact]
        public void DefaultConstructor()
        {
            // Act
            ValueProviderFactoryCollection collection = new ValueProviderFactoryCollection();

            // Assert
            Assert.Empty(collection);
        }

        [Fact]
        public void AddNullValueProviderFactoryThrows()
        {
            // Arrange
            ValueProviderFactoryCollection collection = new ValueProviderFactoryCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection.Add(null); },
                "item");
        }

        [Fact]
        public void ValueProviderFactoryCollectionCombinedItemsCaches()
        {
            // Arrange
            var factories = new ValueProviderFactory[]
            {
                new Mock<ValueProviderFactory>(MockBehavior.Strict).Object,
                new Mock<ValueProviderFactory>(MockBehavior.Strict).Object
            };
            var collection = new ValueProviderFactoryCollection(factories);

            // Act
            var combined1 = collection.CombinedItems;
            var combined2 = collection.CombinedItems;

            // Assert
            Assert.Equal(factories, combined1);
            Assert.Same(combined1, combined2);
        }

        [Fact]
        public void ValueProviderFactoryCollectionCombinedItemsClearResetsCache()
        {
            TestCacheReset((collection) => collection.Clear());
        }

        [Fact]
        public void ValueProviderFactoryCollectionCombinedItemsInsertResetsCache()
        {
            TestCacheReset((collection) => collection.Insert(0, new Mock<ValueProviderFactory>(MockBehavior.Strict).Object));
        }

        [Fact]
        public void ValueProviderFactoryCollectionCombinedItemsRemoveResetsCache()
        {
            TestCacheReset((collection) => collection.RemoveAt(0));
        }

        [Fact]
        public void ValueProviderFactoryCollectionCombinedItemsSetResetsCache()
        {
            TestCacheReset((collection) => collection[0] = new Mock<ValueProviderFactory>(MockBehavior.Strict).Object);
        }

        private static void TestCacheReset(Action<ValueProviderFactoryCollection> mutatingAction)
        {
            // Arrange
            var providers = new List<ValueProviderFactory>()
            {
                new Mock<ValueProviderFactory>(MockBehavior.Strict).Object,
                new Mock<ValueProviderFactory>(MockBehavior.Strict).Object
            };
            var collection = new ValueProviderFactoryCollection(providers);

            // Act
            mutatingAction(collection);

            ValueProviderFactory[] combined = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined);
        }

        [Fact]
        public void ValueProviderFactoryCollectionCombinedItemsDelegatesToResolver()
        {
            // Arrange
            var firstFactory = new Mock<ValueProviderFactory>();
            var secondFactory = new Mock<ValueProviderFactory>();
            var thirdFactory = new Mock<ValueProviderFactory>();
            var dependencyFactories = new ValueProviderFactory[] { firstFactory.Object, secondFactory.Object };
            var collectionFactories = new ValueProviderFactory[] { thirdFactory.Object };
            var expectedFactories = new ValueProviderFactory[] { firstFactory.Object, secondFactory.Object, thirdFactory.Object };

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(ValueProviderFactory))).Returns(dependencyFactories);

            var factories = new ValueProviderFactoryCollection(collectionFactories, resolver.Object);

            // Act
            ValueProviderFactory[] combined = factories.CombinedItems;

            // Assert
            Assert.Equal(expectedFactories, combined);
        }

        [Fact]
        public void GetValueProvider()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            IValueProvider[] expectedValueProviders = new[]
            {
                new Mock<IValueProvider>().Object,
                new Mock<IValueProvider>().Object
            };

            Mock<ValueProviderFactory> mockFactory1 = new Mock<ValueProviderFactory>();
            mockFactory1.Setup(o => o.GetValueProvider(controllerContext)).Returns(expectedValueProviders[0]);
            Mock<ValueProviderFactory> mockFactory2 = new Mock<ValueProviderFactory>();
            mockFactory2.Setup(o => o.GetValueProvider(controllerContext)).Returns(expectedValueProviders[1]);

            ValueProviderFactoryCollection factories = new ValueProviderFactoryCollection()
            {
                mockFactory1.Object,
                mockFactory2.Object
            };

            // Act
            ValueProviderCollection valueProviders = (ValueProviderCollection)factories.GetValueProvider(controllerContext);

            // Assert
            Assert.Equal(expectedValueProviders, valueProviders.ToArray());
        }

        [Fact]
        public void GetValueProviderDelegatesToResolver()
        {
            // Arrange
            ControllerContext controllerContext = new ControllerContext();
            IValueProvider[] expectedValueProviders = new[]
            {
                new Mock<IValueProvider>().Object,
                new Mock<IValueProvider>().Object
            };

            Mock<ValueProviderFactory> mockFactory1 = new Mock<ValueProviderFactory>();
            mockFactory1.Setup(o => o.GetValueProvider(controllerContext)).Returns(expectedValueProviders[0]);
            Mock<ValueProviderFactory> mockFactory2 = new Mock<ValueProviderFactory>();
            mockFactory2.Setup(o => o.GetValueProvider(controllerContext)).Returns(expectedValueProviders[1]);

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(ValueProviderFactory))).Returns(new[] { mockFactory1.Object, mockFactory2.Object });
            ValueProviderFactoryCollection factories = new ValueProviderFactoryCollection(new ValueProviderFactory[0], resolver.Object);

            // Act
            ValueProviderCollection valueProviders = (ValueProviderCollection)factories.GetValueProvider(controllerContext);

            // Assert
            Assert.Equal(expectedValueProviders, valueProviders.ToArray());
        }

        [Fact]
        public void SetItem()
        {
            // Arrange
            ValueProviderFactoryCollection collection = new ValueProviderFactoryCollection();
            collection.Add(new Mock<ValueProviderFactory>().Object);

            ValueProviderFactory newFactory = new Mock<ValueProviderFactory>().Object;

            // Act
            collection[0] = newFactory;

            // Assert
            ValueProviderFactory factory = Assert.Single(collection);
            Assert.Equal(newFactory, factory);
        }

        [Fact]
        public void SetNullValueProviderFactoryThrows()
        {
            // Arrange
            ValueProviderFactoryCollection collection = new ValueProviderFactoryCollection();
            collection.Add(new Mock<ValueProviderFactory>().Object);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection[0] = null; },
                "item");
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValueProviderResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ValueProviderResultTest
    {
        [Fact]
        public void ConstructorSetsProperties()
        {
            // Arrange
            object rawValue = new object();
            string attemptedValue = "some string";
            CultureInfo culture = CultureInfo.GetCultureInfo("fr-FR");

            // Act
            ValueProviderResult result = new ValueProviderResult(rawValue, attemptedValue, culture);

            // Assert
            Assert.Same(rawValue, result.RawValue);
            Assert.Same(attemptedValue, result.AttemptedValue);
            Assert.Same(culture, result.Culture);
        }

        [Fact]
        public void ConvertToCanConvertArraysToArrays()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new int[] { 1, 20, 42 }, "", CultureInfo.InvariantCulture);

            // Act
            string[] converted = (string[])vpr.ConvertTo(typeof(string[]));

            // Assert
            Assert.NotNull(converted);
            Assert.Equal(3, converted.Length);
            Assert.Equal("1", converted[0]);
            Assert.Equal("20", converted[1]);
            Assert.Equal("42", converted[2]);
        }

        [Fact]
        public void ConvertToCanConvertArraysToSingleElements()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new int[] { 1, 20, 42 }, "", CultureInfo.InvariantCulture);

            // Act
            string converted = (string)vpr.ConvertTo(typeof(string));

            // Assert
            Assert.Equal("1", converted);
        }

        [Fact]
        public void ConvertToCanConvertSingleElementsToArrays()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(42, "", CultureInfo.InvariantCulture);

            // Act
            string[] converted = (string[])vpr.ConvertTo(typeof(string[]));

            // Assert
            Assert.NotNull(converted);
            string value = Assert.Single(converted);
            Assert.Equal("42", value);
        }

        [Fact]
        public void ConvertToCanConvertSingleElementsToSingleElements()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(42, "", CultureInfo.InvariantCulture);

            // Act
            string converted = (string)vpr.ConvertTo(typeof(string));

            // Assert
            Assert.NotNull(converted);
            Assert.Equal("42", converted);
        }

        [Fact]
        public void ConvertToChecksTypeConverterCanConvertFrom()
        {
            // Arrange
            object original = "someValue";
            ValueProviderResult vpr = new ValueProviderResult(original, null, CultureInfo.GetCultureInfo("fr-FR"));

            // Act
            DefaultModelBinderTest.StringContainer returned = (DefaultModelBinderTest.StringContainer)vpr.ConvertTo(typeof(DefaultModelBinderTest.StringContainer));

            // Assert
            Assert.Equal("someValue (fr-FR)", returned.Value);
        }

        [Fact]
        public void ConvertingNullStringToNullableIntReturnsNull()
        {
            // Arrange
            object original = null;
            ValueProviderResult vpr = new ValueProviderResult(original, "", CultureInfo.InvariantCulture);

            // Act
            int? returned = (int?)vpr.ConvertTo(typeof(int?));

            // Assert
            Assert.Null(returned);
        }

        [Fact]
        public void ConvertingWhiteSpaceStringToNullableIntReturnsNull()
        {
            // Arrange
            object original = " ";
            ValueProviderResult vpr = new ValueProviderResult(original, "", CultureInfo.InvariantCulture);

            // Act
            int? returned = (int?)vpr.ConvertTo(typeof(int?));

            // Assert
            Assert.Null(returned);
        }

        [Fact]
        public void ConvertToChecksTypeConverterCanConvertTo()
        {
            // Arrange
            object original = new DefaultModelBinderTest.StringContainer("someValue");
            ValueProviderResult vpr = new ValueProviderResult(original, "", CultureInfo.GetCultureInfo("en-US"));

            // Act
            string returned = (string)vpr.ConvertTo(typeof(string));

            // Assert
            Assert.Equal("someValue (en-US)", returned);
        }

        [Fact]
        public void ConvertToReturnsNullIfArrayElementValueIsNull()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new string[] { null }, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int));

            // Assert
            Assert.Null(outValue);
        }

        [Fact]
        public void ConvertToReturnsNullIfTryingToConvertEmptyArrayToSingleElement()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new int[0], "", CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int));

            // Assert
            Assert.Null(outValue);
        }

        [Fact]
        public void ConvertToReturnsNullIfValueIsEmptyString()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult("", null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int));

            // Assert
            Assert.Null(outValue);
        }

        [Fact]
        public void ConvertToReturnsNullIfTrimmedValueIsEmptyString()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(" \t \r\n ", null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int));

            // Assert
            Assert.Null(outValue);
        }

        [Fact]
        public void ConvertToReturnsNullIfValueIsNull()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(null /* rawValue */, null /* attemptedValue */, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int[]));

            // Assert
            Assert.Null(outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfArrayElementIsIntegerAndDestinationTypeIsEnum()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new object[] { 1 }, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(MyEnum));

            // Assert
            Assert.Equal(MyEnum.Value1, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfArrayElementIsStringValueAndDestinationTypeIsEnum()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new object[] { "1" }, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(MyEnum));

            // Assert
            Assert.Equal(MyEnum.Value1, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfArrayElementIsStringKeyAndDestinationTypeIsEnum()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new object[] { "Value1" }, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(MyEnum));

            // Assert
            Assert.Equal(MyEnum.Value1, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfElementIsStringAndDestionationIsNullableInteger()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult("12", null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int?));

            // Assert
            Assert.Equal(12, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfElementIsStringAndDestionationIsNullableDouble()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult("12.5", null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(double?));

            // Assert
            Assert.Equal(12.5, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfElementIsDecimalAndDestionationIsNullableInteger()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(12M, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int?));

            // Assert
            Assert.Equal(12, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfElementIsDecimalAndDestionationIsNullableDouble()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(12.5M, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(double?));

            // Assert
            Assert.Equal(12.5, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfElementIsDecimalDoubleAndDestionationIsNullableInteger()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(12.5M, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(int?));

            // Assert
            Assert.Equal(12, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfElementIsDecimalDoubleAndDestionationIsNullableLong()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(12.5M, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(long?));

            // Assert
            Assert.Equal(12L, outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfArrayElementInstanceOfDestinationType()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult(new object[] { "some string" }, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(string));

            // Assert
            Assert.Equal("some string", outValue);
        }

        [Fact]
        public void ConvertToReturnsValueIfInstanceOfDestinationType()
        {
            // Arrange
            string[] original = new string[] { "some string" };
            ValueProviderResult vpr = new ValueProviderResult(original, null, CultureInfo.InvariantCulture);

            // Act
            object outValue = vpr.ConvertTo(typeof(string[]));

            // Assert
            Assert.Same(original, outValue);
        }

        [Fact]
        public void ConvertToThrowsIfConverterThrows()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult("x", null, CultureInfo.InvariantCulture);
            Type destinationType = typeof(DefaultModelBinderTest.StringContainer);

            // Act & Assert
            // Will throw since the custom converter assumes the first 5 characters to be digits
            InvalidOperationException exception = Assert.Throws<InvalidOperationException>(
                delegate { vpr.ConvertTo(destinationType); },
                "The parameter conversion from type 'System.String' to type 'System.Web.Mvc.Test.DefaultModelBinderTest+StringContainer' failed. See the inner exception for more information.");

            Exception innerException = exception.InnerException;
            Assert.Equal("Value must have at least 3 characters.", innerException.Message);
        }

        [Fact]
        public void ConvertToThrowsIfNoConverterExists()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult("x", null, CultureInfo.InvariantCulture);
            Type destinationType = typeof(MyClassWithoutConverter);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                delegate { vpr.ConvertTo(destinationType); },
                "The parameter conversion from type 'System.String' to type 'System.Web.Mvc.Test.ValueProviderResultTest+MyClassWithoutConverter' failed because no type converter can convert between these types.");
        }

        [Fact]
        public void ConvertToThrowsIfTypeIsNull()
        {
            // Arrange
            ValueProviderResult vpr = new ValueProviderResult("x", null, CultureInfo.InvariantCulture);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { vpr.ConvertTo(null); }, "type");
        }

        [Fact]
        public void ConvertToUsesProvidedCulture()
        {
            // Arrange
            object original = "someValue";
            CultureInfo gbCulture = CultureInfo.GetCultureInfo("en-GB");
            ValueProviderResult vpr = new ValueProviderResult(original, null, CultureInfo.GetCultureInfo("fr-FR"));

            // Act
            DefaultModelBinderTest.StringContainer returned = (DefaultModelBinderTest.StringContainer)vpr.ConvertTo(typeof(DefaultModelBinderTest.StringContainer), gbCulture);

            // Assert
            Assert.Equal("someValue (en-GB)", returned.Value);
        }

        [Fact]
        public void CulturePropertyDefaultsToInvariantCulture()
        {
            // Arrange
            ValueProviderResult result = new ValueProviderResult(null, null, null);

            // Act & assert
            Assert.Same(CultureInfo.InvariantCulture, result.Culture);
        }

        [Theory]
        [PropertyData("IntrinsicConversionData")]
        public void ConvertToCanConvertIntrinsics<T>(object initialValue, T expectedValue)
        {
            // Arrange
            var result = new ValueProviderResult(initialValue, "", CultureInfo.InvariantCulture);

            // Act & Assert
            Assert.Equal(expectedValue, result.ConvertTo(typeof(T)));
        }

        public static IEnumerable<object[]> IntrinsicConversionData
        {
            get
            {
                return new TheoryDataSet<object, object>
                {
                    { 42, 42M },
                    { 42, 42L },
                    { 42, (float)42.0 },
                    { 42, (double)42.0 },
                    { 42M, 42 },
                    { 42L, 42 },
                    { (float)42.0, 42 },
                    { (double)42.0, 42 }
                };
            }
        }

        private class MyClassWithoutConverter
        {
        }

        private enum MyEnum
        {
            Value0 = 0,
            Value1 = 1
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ValueProviderUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ValueProviderUtilTest
    {
        [Fact]
        public void CollectionContainsPrefix_EmptyCollectionReturnsFalse()
        {
            // Arrange
            string[] collection = new string[0];

            // Act
            bool retVal = ValueProviderUtil.CollectionContainsPrefix(collection, "");

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void CollectionContainsPrefix_ExactMatch()
        {
            // Arrange
            string[] collection = new string[] { "Hello" };

            // Act
            bool retVal = ValueProviderUtil.CollectionContainsPrefix(collection, "Hello");

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void CollectionContainsPrefix_MatchIsCaseInsensitive()
        {
            // Arrange
            string[] collection = new string[] { "Hello" };

            // Act
            bool retVal = ValueProviderUtil.CollectionContainsPrefix(collection, "hello");

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void CollectionContainsPrefix_MatchIsNotSimpleSubstringMatch()
        {
            // Arrange
            string[] collection = new string[] { "Hello" };

            // Act
            bool retVal = ValueProviderUtil.CollectionContainsPrefix(collection, "He");

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void CollectionContainsPrefix_NonEmptyCollectionReturnsTrueIfPrefixIsEmptyString()
        {
            // Arrange
            string[] collection = new string[] { "Hello" };

            // Act
            bool retVal = ValueProviderUtil.CollectionContainsPrefix(collection, "");

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void CollectionContainsPrefix_PrefixBoundaries()
        {
            // Arrange
            string[] collection = new string[] { "Hello.There[0]" };

            // Act
            bool retVal1 = ValueProviderUtil.CollectionContainsPrefix(collection, "hello");
            bool retVal2 = ValueProviderUtil.CollectionContainsPrefix(collection, "hello.there");

            // Assert
            Assert.True(retVal1);
            Assert.True(retVal2);
            Assert.True(ValueProviderUtil.CollectionContainsPrefix(collection, "hello.there[0]"));
            Assert.False(ValueProviderUtil.CollectionContainsPrefix(collection, "hello.there.0"));
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Web.WebPages.Scope;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ViewContextTest
    {
        [Fact]
        public void GuardClauses()
        {
            // Arrange
            var controllerContext = new Mock<ControllerContext>().Object;
            var view = new Mock<IView>().Object;
            var viewData = new ViewDataDictionary();
            var tempData = new TempDataDictionary();
            var writer = new StringWriter();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new ViewContext(null, view, viewData, tempData, writer),
                "controllerContext"
                );
            Assert.ThrowsArgumentNull(
                () => new ViewContext(controllerContext, null, viewData, tempData, writer),
                "view"
                );
            Assert.ThrowsArgumentNull(
                () => new ViewContext(controllerContext, view, null, tempData, writer),
                "viewData"
                );
            Assert.ThrowsArgumentNull(
                () => new ViewContext(controllerContext, view, viewData, null, writer),
                "tempData"
                );
            Assert.ThrowsArgumentNull(
                () => new ViewContext(controllerContext, view, viewData, tempData, null),
                "writer"
                );
        }

        [Fact]
        public void FormIdGeneratorProperty()
        {
            // Arrange
            var mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Items).Returns(new Hashtable());
            var viewContext = new ViewContext
            {
                HttpContext = mockHttpContext.Object
            };

            // Act
            string form0Name = viewContext.FormIdGenerator();
            string form1Name = viewContext.FormIdGenerator();
            string form2Name = viewContext.FormIdGenerator();

            // Assert
            Assert.Equal("form0", form0Name);
            Assert.Equal("form1", form1Name);
            Assert.Equal("form2", form2Name);
        }

        [Fact]
        public void PropertiesAreSet()
        {
            // Arrange
            var mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(o => o.HttpContext.Items).Returns(new Hashtable());
            var view = new Mock<IView>().Object;
            var viewData = new ViewDataDictionary();
            var tempData = new TempDataDictionary();
            var writer = new StringWriter();

            // Act
            ViewContext viewContext = new ViewContext(mockControllerContext.Object, view, viewData, tempData, writer);

            // Setting FormContext to null will return the default one later
            viewContext.FormContext = null;

            // Assert
            Assert.Equal(view, viewContext.View);
            Assert.Equal(viewData, viewContext.ViewData);
            Assert.Equal(tempData, viewContext.TempData);
            Assert.Equal(writer, viewContext.Writer);
            Assert.False(viewContext.UnobtrusiveJavaScriptEnabled); // Unobtrusive JavaScript should be off by default
            Assert.NotNull(viewContext.FormContext); // We get the default FormContext
            Assert.Equal("span", viewContext.ValidationSummaryMessageElement); // gen a <span/> by default
            Assert.Equal("span", viewContext.ValidationMessageElement); // gen a <span/> by default
        }

        [Fact]
        public void ViewContextUsesScopeThunkForInstanceClientValidationFlag()
        {
            // Arrange
            var scope = new Dictionary<object, object>();
            var httpContext = new Mock<HttpContextBase>();
            var viewContext = new ViewContext { ScopeThunk = () => scope, HttpContext = httpContext.Object };
            httpContext.Setup(c => c.Items).Returns(new Hashtable());

            // Act & Assert
            Assert.False(viewContext.ClientValidationEnabled);
            viewContext.ClientValidationEnabled = true;
            Assert.True(viewContext.ClientValidationEnabled);
            Assert.Equal((object)true, scope[ViewContext.ClientValidationKeyName]);
            viewContext.ClientValidationEnabled = false;
            Assert.False(viewContext.ClientValidationEnabled);
            Assert.Equal((object)false, scope[ViewContext.ClientValidationKeyName]);
        }

        [Fact]
        public void ViewContextUsesScopeThunkForInstanceUnobstrusiveJavaScriptFlag()
        {
            // Arrange
            var scope = new Dictionary<object, object>();
            var httpContext = new Mock<HttpContextBase>();
            var viewContext = new ViewContext { ScopeThunk = () => scope, HttpContext = httpContext.Object };
            httpContext.Setup(c => c.Items).Returns(new Hashtable());

            // Act & Assert
            Assert.False(viewContext.UnobtrusiveJavaScriptEnabled);
            viewContext.UnobtrusiveJavaScriptEnabled = true;
            Assert.True(viewContext.UnobtrusiveJavaScriptEnabled);
            Assert.Equal((object)true, scope[ViewContext.UnobtrusiveJavaScriptKeyName]);
            viewContext.UnobtrusiveJavaScriptEnabled = false;
            Assert.False(viewContext.UnobtrusiveJavaScriptEnabled);
            Assert.Equal((object)false, scope[ViewContext.UnobtrusiveJavaScriptKeyName]);
        }

        [Fact]
        public void ViewContextUsesScopeThunkForValidationSummaryMessageElement()
        {
            // Arrange
            var scope = new Dictionary<object, object>();
            var httpContext = new Mock<HttpContextBase>();
            var viewContext = new ViewContext { ScopeThunk = () => scope, HttpContext = httpContext.Object };
            httpContext.Setup(c => c.Items).Returns(new Hashtable());

            // Act & Assert
            Assert.Equal("span", viewContext.ValidationSummaryMessageElement);
            viewContext.ValidationSummaryMessageElement = "h4";
            Assert.Equal("h4", viewContext.ValidationSummaryMessageElement);
            Assert.Equal("h4", scope[ViewContext.ValidationSummaryMessageElementKeyName]);
            viewContext.ValidationSummaryMessageElement = "div";
            Assert.Equal("div", viewContext.ValidationSummaryMessageElement);
            Assert.Equal("div", scope[ViewContext.ValidationSummaryMessageElementKeyName]);
        }

        [Fact]
        public void ViewContextUsesScopeThunkForValidationMessageElement()
        {
            // Arrange
            var scope = new Dictionary<object, object>();
            var httpContext = new Mock<HttpContextBase>();
            var viewContext = new ViewContext { ScopeThunk = () => scope, HttpContext = httpContext.Object };
            httpContext.Setup(c => c.Items).Returns(new Hashtable());

            // Act & Assert
            Assert.Equal("span", viewContext.ValidationMessageElement);
            viewContext.ValidationMessageElement = "h4";
            Assert.Equal("h4", viewContext.ValidationMessageElement);
            Assert.Equal("h4", scope[ViewContext.ValidationMessageElementKeyName]);
            viewContext.ValidationMessageElement = "div";
            Assert.Equal("div", viewContext.ValidationMessageElement);
            Assert.Equal("div", scope[ViewContext.ValidationMessageElementKeyName]);
        }

        [Fact]
        public void ViewContextGlobalValidationMessageElementAffectsLocalOne()
        {
            // Arrange
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var httpContext = new Mock<HttpContextBase>();
                ScopeStorageDictionary localScope = null;
                var globalViewContext = new ViewContext
                {
                    ScopeThunk = () => ScopeStorage.GlobalScope,
                    HttpContext = httpContext.Object
                };
                var localViewContext = new ViewContext
                {
                    ScopeThunk = () =>
                    {
                        if (localScope == null)
                        {
                            localScope = new ScopeStorageDictionary(ScopeStorage.GlobalScope);
                        };
                        return localScope;
                    },
                    HttpContext = httpContext.Object
                };
                // A ScopeCache object will be stored into the hash table but the ScopeCache class is private,
                // so we cannot get the validation message element from it for Assert.
                httpContext.Setup(c => c.Items).Returns(new Hashtable());

                // Act
                globalViewContext.ValidationMessageElement = "label";

                // Assert
                // Global element was changed from "span" to "label".
                Assert.Equal("label", HtmlHelper.ValidationMessageElement);
                Assert.Equal("label", globalViewContext.ValidationMessageElement);
                object value;
                ScopeStorage.GlobalScope.TryGetValue("ValidationMessageElement", out value);
                Assert.Equal("label", value);

                // Local element was also changed to "label".
                Assert.Equal("label", localViewContext.ValidationMessageElement);
                localScope.TryGetValue("ValidationMessageElement", out value);
                Assert.Equal("label", value);
            });
        }

        [Fact]
        public void ViewContextLocalValidationMessageElementDoesNotAffectGlobalOne()
        {
            // Arrange
            ScopeStorageDictionary localScope = null;
            var httpContext = new Mock<HttpContextBase>();
            var globalViewContext = new ViewContext
            {
                ScopeThunk = () => ScopeStorage.GlobalScope,
                HttpContext = httpContext.Object
            };
            var localViewContext = new ViewContext
            {
                ScopeThunk = () =>
                {
                    if (localScope == null)
                    {
                        localScope = new ScopeStorageDictionary(ScopeStorage.GlobalScope);
                    }
                    return localScope;
                },
                HttpContext = httpContext.Object
            };
            // A ScopeCache object will be stored into the hash table but the ScopeCache class is private,
            // so we cannot get the validation message element from it for Assert.
            httpContext.Setup(c => c.Items).Returns(new Hashtable());

            // Act & Assert
            // Local element will be changed from "span" to "h4".
            Assert.Equal("span", localViewContext.ValidationMessageElement);
            localViewContext.ValidationMessageElement = "h4";
            Assert.Equal("h4", localViewContext.ValidationMessageElement);
            object value;
            localScope.TryGetValue("ValidationMessageElement", out value);
            Assert.Equal("h4", value);

            // Global element is still "span".
            Assert.Equal("span", globalViewContext.ValidationMessageElement);
            Assert.Empty(ScopeStorage.GlobalScope);
            Assert.Equal("span", HtmlHelper.ValidationMessageElement);
        }

        [Fact]
        public void ViewBagProperty_ReflectsViewData()
        {
            // Arrange
            var mockControllerContext = new Mock<ControllerContext>();
            var view = new Mock<IView>().Object;
            var viewData = new ViewDataDictionary() { { "A", 1 } };

            // Act
            ViewContext viewContext = new ViewContext(mockControllerContext.Object, view, viewData, new TempDataDictionary(), new StringWriter());

            // Assert
            Assert.Equal(1, viewContext.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_ReflectsNewViewDataInstance()
        {
            // Arrange
            var mockControllerContext = new Mock<ControllerContext>();
            var view = new Mock<IView>().Object;
            var viewData = new ViewDataDictionary() { { "A", 1 } };

            ViewContext viewContext = new ViewContext(mockControllerContext.Object, view, viewData, new TempDataDictionary(), new StringWriter());

            // Act
            viewContext.ViewData = new ViewDataDictionary() { { "A", "bar" } };

            // Assert
            Assert.Equal("bar", viewContext.ViewBag.A);
        }

        [Fact]
        public void ViewBag_PropagatesChangesToViewData()
        {
            // Arrange
            var mockControllerContext = new Mock<ControllerContext>();
            var view = new Mock<IView>().Object;
            var viewData = new ViewDataDictionary() { { "A", 1 } };

            ViewContext viewContext = new ViewContext(mockControllerContext.Object, view, viewData, new TempDataDictionary(), new StringWriter());

            // Act
            viewContext.ViewBag.A = "foo";
            viewContext.ViewBag.B = 2;

            // Assert
            Assert.Equal("foo", viewContext.ViewData["A"]);
            Assert.Equal(2, viewContext.ViewData["B"]);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewDataDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")] // Uses ModelMetadataProviders.Current
    public class ViewDataDictionaryTest
    {
        [Fact]
        public void ConstructorThrowsIfDictionaryIsNull()
        {
            // Act & assert
            Assert.ThrowsArgumentNull(
                delegate { new ViewDataDictionary((ViewDataDictionary)null); }, "dictionary");
        }

        [Fact]
        public void ConstructorWithViewDataDictionaryCopiesModelAndModelState()
        {
            // Arrange
            ViewDataDictionary originalVdd = new ViewDataDictionary();
            object model = new object();
            originalVdd.Model = model;
            originalVdd["foo"] = "bar";
            originalVdd.ModelState.AddModelError("key", "error");

            // Act
            ViewDataDictionary newVdd = new ViewDataDictionary(originalVdd);

            // Assert
            Assert.Equal(model, newVdd.Model);
            Assert.True(newVdd.ModelState.ContainsKey("key"));
            Assert.Equal("error", newVdd.ModelState["key"].Errors[0].ErrorMessage);
            Assert.Equal("bar", newVdd["foo"]);
        }

        [Fact]
        public void ConstructorWithViewDataDictionaryUsesCopyOnWriteDictionary()
        {
            // Arrange
            ViewDataDictionary originalVdd = new ViewDataDictionary();

            // Act
            ViewDataDictionary newVdd = new ViewDataDictionary(originalVdd);

            // Assert
            Assert.IsType<Dictionary<string, object>>(originalVdd.InnerDictionary);
            Assert.IsType<CopyOnWriteDictionary<string, object>>(newVdd.InnerDictionary);
        }

        [Fact]
        public void DictionaryInterface()
        {
            // Arrange
            DictionaryHelper<string, object> helper = new DictionaryHelper<string, object>()
            {
                Creator = () => new ViewDataDictionary(),
                Comparer = StringComparer.OrdinalIgnoreCase,
                SampleKeys = new string[] { "foo", "bar", "baz", "quux", "QUUX" },
                SampleValues = new object[] { 42, "string value", new DateTime(2001, 1, 1), new object(), 32m },
                ThrowOnKeyNotFound = false
            };

            // Act & assert
            helper.Execute();
        }

        [Fact]
        public void EvalReturnsSimplePropertyValue()
        {
            var obj = new { Foo = "Bar" };
            ViewDataDictionary vdd = new ViewDataDictionary(obj);

            Assert.Equal("Bar", vdd.Eval("Foo"));
        }

        [Fact]
        public void EvalWithModelAndDictionaryPropertyEvaluatesDictionaryValue()
        {
            var obj = new { Foo = new Dictionary<string, object> { { "Bar", "Baz" } } };
            ViewDataDictionary vdd = new ViewDataDictionary(obj);

            Assert.Equal("Baz", vdd.Eval("Foo.Bar"));
        }

        [Fact]
        public void EvalEvaluatesDictionaryThenModel()
        {
            var obj = new { Foo = "NotBar" };
            ViewDataDictionary vdd = new ViewDataDictionary(obj);
            vdd.Add("Foo", "Bar");

            Assert.Equal("Bar", vdd.Eval("Foo"));
        }

        [Fact]
        public void EvalReturnsValueOfCompoundExpressionByFollowingObjectPath()
        {
            var obj = new { Foo = new { Bar = "Baz" } };
            ViewDataDictionary vdd = new ViewDataDictionary(obj);

            Assert.Equal("Baz", vdd.Eval("Foo.Bar"));
        }

        [Fact]
        public void EvalReturnsNullIfExpressionDoesNotMatch()
        {
            var obj = new { Foo = new { Biz = "Baz" } };
            ViewDataDictionary vdd = new ViewDataDictionary(obj);

            Assert.Null(vdd.Eval("Foo.Bar"));
        }

        [Fact]
        public void EvalReturnsValueJustAdded()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", "Blah");

            Assert.Equal("Blah", vdd.Eval("Foo"));
        }

        [Fact]
        public void EvalWithCompoundExpressionReturnsIndexedValue()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo.Bar", "Baz");

            Assert.Equal("Baz", vdd.Eval("Foo.Bar"));
        }

        [Fact]
        public void EvalWithCompoundExpressionReturnsPropertyOfAddedObject()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", new { Bar = "Baz" });

            Assert.Equal("Baz", vdd.Eval("Foo.Bar"));
        }

        [Fact]
        public void EvalWithCompoundIndexExpressionReturnsEval()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo.Bar", new { Baz = "Quux" });

            Assert.Equal("Quux", vdd.Eval("Foo.Bar.Baz"));
        }

        [Fact]
        public void EvalWithCompoundIndexAndCompoundExpressionReturnsValue()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo.Bar", new { Baz = new { Blah = "Quux" } });

            Assert.Equal("Quux", vdd.Eval("Foo.Bar.Baz.Blah"));
        }

        /// <summary>
        /// Make sure that dict["foo.bar"] gets chosen before dict["foo"]["bar"]
        /// </summary>
        [Fact]
        public void EvalChoosesValueInDictionaryOverOtherValue()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", new { Bar = "Not Baz" });
            vdd.Add("Foo.Bar", "Baz");

            Assert.Equal("Baz", vdd.Eval("Foo.Bar"));
        }

        /// <summary>
        /// Make sure that dict["foo.bar"]["baz"] gets chosen before dict["foo"]["bar"]["baz"]
        /// </summary>
        [Fact]
        public void EvalChoosesCompoundValueInDictionaryOverOtherValues()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", new { Bar = new { Baz = "Not Quux" } });
            vdd.Add("Foo.Bar", new { Baz = "Quux" });

            Assert.Equal("Quux", vdd.Eval("Foo.Bar.Baz"));
        }

        /// <summary>
        /// Make sure that dict["foo.bar"]["baz"] gets chosen before dict["foo"]["bar.baz"]
        /// </summary>
        [Fact]
        public void EvalChoosesCompoundValueInDictionaryOverOtherValuesWithCompoundProperty()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", new Person());
            vdd.Add("Foo.Bar", new { Baz = "Quux" });

            Assert.Equal("Quux", vdd.Eval("Foo.Bar.Baz"));
        }

        [Fact]
        public void EvalThrowsIfExpressionIsEmpty()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { vdd.Eval(String.Empty); }, "expression");
        }

        [Fact]
        public void EvalThrowsIfExpressionIsNull()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                delegate { vdd.Eval(null); }, "expression");
        }

        [Fact]
        public void EvalWithCompoundExpressionAndDictionarySubExpressionChoosesDictionaryValue()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", new Dictionary<string, object> { { "Bar", "Baz" } });

            Assert.Equal("Baz", vdd.Eval("Foo.Bar"));
        }

        [Fact]
        public void EvalWithDictionaryAndNoMatchReturnsNull()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", new Dictionary<string, object> { { "NotBar", "Baz" } });

            object result = vdd.Eval("Foo.Bar");
            Assert.Null(result);
        }

        [Fact]
        public void EvalWithNestedDictionariesEvalCorrectly()
        {
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd.Add("Foo", new Dictionary<string, object> { { "Bar", new Hashtable { { "Baz", "Quux" } } } });

            Assert.Equal("Quux", vdd.Eval("Foo.Bar.Baz"));
        }

        [Fact]
        public void EvalFormatWithNullValueReturnsEmptyString()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();

            // Act
            string formattedValue = vdd.Eval("foo", "for{0}mat");

            // Assert
            Assert.Equal(String.Empty, formattedValue);
        }

        [Fact]
        public void EvalFormatWithEmptyFormatReturnsViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["foo"] = "value";

            // Act
            string formattedValue = vdd.Eval("foo", "");

            // Assert
            Assert.Equal("value", formattedValue);
        }

        [Fact]
        public void EvalFormatWithFormatReturnsFormattedViewData()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["foo"] = "value";

            // Act
            string formattedValue = vdd.Eval("foo", "for{0}mat");

            // Assert
            Assert.Equal("forvaluemat", formattedValue);
        }

        [Fact]
        public void EvalPropertyNamedModel()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["Title"] = "Home Page";
            vdd["Message"] = "Welcome to ASP.NET MVC!";
            vdd.Model = new TheQueryStringParam
            {
                Name = "The Name",
                Value = "The Value",
                Model = "The Model",
            };

            // Act
            object o = vdd.Eval("Model");

            // Assert
            Assert.Equal("The Model", o);
        }

        [Fact]
        public void EvalSubPropertyNamedValueInModel()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();
            vdd["Title"] = "Home Page";
            vdd["Message"] = "Welcome to ASP.NET MVC!";
            vdd.Model = new TheQueryStringParam
            {
                Name = "The Name",
                Value = "The Value",
                Model = "The Model",
            };

            // Act
            object o = vdd.Eval("Value");

            // Assert
            Assert.Equal("The Value", o);
        }

        [Fact]
        public void GetViewDataInfoFromDictionary()
        {
            // Arrange
            ViewDataDictionary fooVdd = new ViewDataDictionary()
            {
                { "Bar", "barValue" }
            };
            ViewDataDictionary vdd = new ViewDataDictionary()
            {
                { "Foo", fooVdd }
            };

            // Act
            ViewDataInfo info = vdd.GetViewDataInfo("foo.bar");

            // Assert
            Assert.NotNull(info);
            Assert.Equal(fooVdd, info.Container);
            Assert.Equal("barValue", info.Value);
        }

        [Fact]
        public void GetViewDataInfoFromDictionaryWithMissingEntry()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();

            // Act
            ViewDataInfo info = vdd.GetViewDataInfo("foo");

            // Assert
            Assert.Null(info);
        }

        [Fact]
        public void GetViewDataInfoFromDictionaryWithNullEntry()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary()
            {
                { "Foo", null }
            };

            // Act
            ViewDataInfo info = vdd.GetViewDataInfo("foo");

            // Assert
            Assert.NotNull(info);
            Assert.Equal(vdd, info.Container);
            Assert.Null(info.Value);
        }

        [Fact]
        public void GetViewDataInfoFromModel()
        {
            // Arrange
            object model = new { foo = "fooValue" };
            ViewDataDictionary vdd = new ViewDataDictionary(model);

            PropertyDescriptor propDesc = TypeDescriptor.GetProperties(model).Find("foo", true /* ignoreCase */);

            // Act
            ViewDataInfo info = vdd.GetViewDataInfo("foo");

            // Assert
            Assert.NotNull(info);
            Assert.Equal(model, info.Container);
            Assert.Equal(propDesc, info.PropertyDescriptor);
            Assert.Equal("fooValue", info.Value);
        }

        [Fact]
        public void FabricatesModelMetadataFromModelWhenModelMetadataHasNotBeenSet()
        {
            // Arrange
            object model = new { foo = "fooValue", bar = "barValue" };
            ViewDataDictionary vdd = new ViewDataDictionary(model);

            // Act
            ModelMetadata metadata = vdd.ModelMetadata;

            // Assert
            Assert.NotNull(metadata);
            Assert.Equal(model.GetType(), metadata.ModelType);
        }

        [Fact]
        public void ReturnsExistingModelMetadata()
        {
            // Arrange
            object model = new { foo = "fooValue", bar = "barValue" };
            ModelMetadata originalMetadata = ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType());
            ViewDataDictionary vdd = new ViewDataDictionary(model) { ModelMetadata = originalMetadata };

            // Act
            ModelMetadata metadata = vdd.ModelMetadata;

            // Assert
            Assert.Same(originalMetadata, metadata);
        }

        [Fact]
        public void ModelMetadataIsNullIfModelMetadataHasNotBeenSetAndModelIsNull()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary();

            // Act
            ModelMetadata metadata = vdd.ModelMetadata;

            // Assert
            Assert.Null(metadata);
        }

        [Fact]
        public void ModelMetadataCanBeFabricatedWithNullModelAndGenericViewDataDictionary()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary<Exception>();

            // Act
            ModelMetadata metadata = vdd.ModelMetadata;

            // Assert
            Assert.NotNull(metadata);
            Assert.Equal(typeof(Exception), metadata.ModelType);
        }

        [Fact]
        public void ModelSetterThrowsIfValueIsNullAndModelTypeIsNonNullable()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary<int>();

            // Act & assert
            Assert.Throws<InvalidOperationException>(
                delegate { vdd.Model = null; },
                @"The model item passed into the dictionary is null, but this dictionary requires a non-null model item of type 'System.Int32'.");
        }

        [Fact]
        public void ChangingModelReplacesModelMetadata()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary(new Object());
            ModelMetadata originalMetadata = vdd.ModelMetadata;

            // Act
            vdd.Model = "New Model";

            // Assert
            Assert.NotSame(originalMetadata, vdd.ModelMetadata);
        }

        public class TheQueryStringParam
        {
            public string Name { get; set; }
            public string Value { get; set; }
            public string Model { get; set; }
        }

        public class Person : CustomTypeDescriptor
        {
            public override PropertyDescriptorCollection GetProperties()
            {
                return new PropertyDescriptorCollection(new PersonPropertyDescriptor[] { new PersonPropertyDescriptor() });
            }
        }

        public class PersonPropertyDescriptor : PropertyDescriptor
        {
            public PersonPropertyDescriptor()
                : base("Bar.Baz", null)
            {
            }

            public override object GetValue(object component)
            {
                return "Quux";
            }

            public override bool CanResetValue(object component)
            {
                return false;
            }

            public override Type ComponentType
            {
                get { return typeof(Person); }
            }

            public override bool IsReadOnly
            {
                get { return false; }
            }

            public override Type PropertyType
            {
                get { return typeof(string); }
            }

            public override void ResetValue(object component)
            {
            }

            public override void SetValue(object component, object value)
            {
            }

            public override bool ShouldSerializeValue(object component)
            {
                return true;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewDataInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ViewDataInfoTest
    {
        [Fact]
        public void ViewDataInfoDoesNotCallAccessorUntilValuePropertyAccessed()
        {
            // Arrange
            bool called = false;
            ViewDataInfo vdi = new ViewDataInfo(() =>
            {
                called = true;
                return 21;
            });

            // Act & Assert
            Assert.False(called);
            object result = vdi.Value;
            Assert.True(called);
            Assert.Equal(21, result);
        }

        [Fact]
        public void AccessorIsOnlyCalledOnce()
        {
            // Arrange
            int callCount = 0;
            ViewDataInfo vdi = new ViewDataInfo(() =>
            {
                ++callCount;
                return null;
            });

            // Act & Assert
            Assert.Equal(0, callCount);
            object unused;
            unused = vdi.Value;
            unused = vdi.Value;
            unused = vdi.Value;
            Assert.Equal(1, callCount);
        }

        [Fact]
        public void SettingExplicitValueOverridesAccessorMethod()
        {
            // Arrange
            bool called = false;
            ViewDataInfo vdi = new ViewDataInfo(() =>
            {
                called = true;
                return null;
            });

            // Act & Assert
            Assert.False(called);
            vdi.Value = 42;
            object result = vdi.Value;
            Assert.False(called);
            Assert.Equal(42, result);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewEngineCollectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ViewEngineCollectionTest
    {
        [Fact]
        public void ListWrappingConstructor()
        {
            // Arrange
            List<IViewEngine> list = new List<IViewEngine>() { new Mock<IViewEngine>().Object, new Mock<IViewEngine>().Object };

            // Act
            ViewEngineCollection collection = new ViewEngineCollection(list);

            // Assert
            Assert.Equal(2, collection.Count);
            Assert.Same(list[0], collection[0]);
            Assert.Same(list[1], collection[1]);
        }

        [Fact]
        public void ListWrappingConstructorThrowsIfListIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ViewEngineCollection((IList<IViewEngine>)null); },
                "list");
        }

        [Fact]
        public void DefaultConstructor()
        {
            // Act
            ViewEngineCollection collection = new ViewEngineCollection();

            // Assert
            Assert.Empty(collection);
        }

        [Fact]
        public void ViewEngineCollectionCombinedItemsCaches()
        {
            // Arrange
            var engines = new IViewEngine[] 
            {
                new Mock<IViewEngine>(MockBehavior.Strict).Object, 
                new Mock<IViewEngine>(MockBehavior.Strict).Object
            };
            var collection = new ViewEngineCollection(engines);

            // Act
            var combined1 = collection.CombinedItems;
            var combined2 = collection.CombinedItems;

            // Assert
            Assert.Equal(engines, combined1);
            Assert.Same(combined1, combined2);
        }

        [Fact]
        public void ViewEngineCollectionCombinedItemsClearResetsCache()
        {
            TestCacheReset((collection) => collection.Clear());
        }

        [Fact]
        public void ViewEngineCollectionCombinedItemsInsertResetsCache()
        {
            TestCacheReset((collection) => collection.Insert(0, new Mock<IViewEngine>(MockBehavior.Strict).Object));
        }

        [Fact]
        public void ViewEngineCollectionCombinedItemsRemoveResetsCache()
        {
            TestCacheReset((collection) => collection.RemoveAt(0));
        }

        [Fact]
        public void ViewEngineCollectionCombinedItemsSetResetsCache()
        {
            TestCacheReset((collection) => collection[0] = new Mock<IViewEngine>(MockBehavior.Strict).Object);
        }

        private static void TestCacheReset(Action<ViewEngineCollection> mutatingAction)
        {
            // Arrange
            var providers = new List<IViewEngine>() 
            {
                new Mock<IViewEngine>(MockBehavior.Strict).Object, 
                new Mock<IViewEngine>(MockBehavior.Strict).Object
            };
            var collection = new ViewEngineCollection(providers);

            // Act
            mutatingAction(collection);

            IViewEngine[] combined = collection.CombinedItems;

            // Assert
            Assert.Equal(providers, combined);
        }

        [Fact]
        public void ViewEngineCollectionCombinedItemsDelegatesToResolver()
        {
            // Arrange
            var firstEngine = new Mock<IViewEngine>();
            var secondEngine = new Mock<IViewEngine>();
            var thirdEngine = new Mock<IViewEngine>();
            var dependencyEngines = new IViewEngine[] { firstEngine.Object, secondEngine.Object };
            var collectionEngines = new IViewEngine[] { thirdEngine.Object };
            var expectedEngines = new IViewEngine[] { firstEngine.Object, secondEngine.Object, thirdEngine.Object };

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IViewEngine))).Returns(dependencyEngines);

            var engines = new ViewEngineCollection(collectionEngines, resolver.Object);

            // Act
            IViewEngine[] combined = engines.CombinedItems;

            // Assert
            Assert.Equal(expectedEngines, combined);
        }

        [Fact]
        public void AddNullViewEngineThrows()
        {
            // Arrange
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection.Add(null); },
                "item");
        }

        [Fact]
        public void SetNullViewEngineThrows()
        {
            // Arrange
            ViewEngineCollection collection = new ViewEngineCollection();
            collection.Add(new Mock<IViewEngine>().Object);

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { collection[0] = null; },
                "item");
        }

        [Fact]
        public void FindPartialViewAggregatesAllSearchedLocationsIfAllEnginesFail()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection viewEngineCollection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "location1", "location2" });
            engine1.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new[] { "location3", "location4" });
            engine2.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine2Result);
            viewEngineCollection.Add(engine1.Object);
            viewEngineCollection.Add(engine2.Object);

            // Act
            ViewEngineResult result = viewEngineCollection.FindPartialView(context, "partial");

            // Assert
            Assert.Null(result.View);
            Assert.Equal(4, result.SearchedLocations.Count());
            Assert.Contains("location1", result.SearchedLocations);
            Assert.Contains("location2", result.SearchedLocations);
            Assert.Contains("location3", result.SearchedLocations);
            Assert.Contains("location4", result.SearchedLocations);
        }

        [Fact]
        public void FindPartialViewFailureWithOneEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new[] { "location1", "location2" });
            engine.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engineResult);
            collection.Add(engine.Object);

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Null(result.View);
            Assert.Equal(2, result.SearchedLocations.Count());
            Assert.Contains("location1", result.SearchedLocations);
            Assert.Contains("location2", result.SearchedLocations);
        }

        [Fact]
        public void FindPartialViewLooksAtCacheFirst()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindPartialView(context, "partial", true)).Returns(engineResult);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Same(engineResult, result);
            engine.Verify(e => e.FindPartialView(context, "partial", true), Times.Once());
            engine.Verify(e => e.FindPartialView(context, "partial", false), Times.Never());
        }

        [Fact]
        public void FindPartialViewLooksAtLocatorIfCacheEmpty()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindPartialView(context, "partial", true)).Returns(new ViewEngineResult(new[] { "path" }));
            engine.Setup(e => e.FindPartialView(context, "partial", false)).Returns(engineResult);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Same(engineResult, result);
            engine.Verify(e => e.FindPartialView(context, "partial", true), Times.Once());
            engine.Verify(e => e.FindPartialView(context, "partial", false), Times.Once());
        }

        [Fact]
        public void FindPartialViewIgnoresSearchLocationsFromCache()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            engine.Setup(e => e.FindPartialView(context, "partial", true)).Returns(new ViewEngineResult(new[] { "cachePath" }));
            engine.Setup(e => e.FindPartialView(context, "partial", false)).Returns(new ViewEngineResult(new[] { "locatorPath" }));
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            string searchedLocation = Assert.Single(result.SearchedLocations);
            Assert.Equal("locatorPath", searchedLocation);
            engine.Verify(e => e.FindPartialView(context, "partial", true), Times.Once());
            engine.Verify(e => e.FindPartialView(context, "partial", false), Times.Once());
        }

        [Fact]
        public void FindPartialViewIteratesThroughCollectionUntilFindsSuccessfulEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "location1", "location2" });
            engine1.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new Mock<IView>().Object, engine2.Object);
            engine2.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine2Result);
            collection.Add(engine1.Object);
            collection.Add(engine2.Object);

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Same(engine2Result, result);
        }

        [Fact]
        public void FindPartialViewRemovesDuplicateSearchedLocationsFromMultipleEngines()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "repeatLocation", "location1" });
            engine1.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new[] { "location2", "repeatLocation" });
            engine2.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine2Result);
            ViewEngineCollection viewEngineCollection = new ViewEngineCollection()
            {
                engine1.Object,
                engine2.Object,
            };

            // Act
            ViewEngineResult result = viewEngineCollection.FindPartialView(context, "partial");

            // Assert
            var expectedLocations = new[] { "repeatLocation", "location1", "location2" };
            Assert.Null(result.View);
            Assert.Equal(expectedLocations, result.SearchedLocations.ToArray());
        }

        [Fact]
        public void FindPartialViewReturnsNoViewAndEmptySearchedLocationsIfCollectionEmpty()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Null(result.View);
            Assert.Empty(result.SearchedLocations);
        }

        [Fact]
        public void FindPartialViewReturnsValueFromFirstSuccessfulEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new Mock<IView>().Object, engine1.Object);
            engine1.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new Mock<IView>().Object, engine2.Object);
            engine2.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engine2Result);
            collection.Add(engine1.Object);
            collection.Add(engine2.Object);

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Same(engine1Result, result);
        }

        [Fact]
        public void FindPartialViewSuccessWithOneEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindPartialView(context, "partial", It.IsAny<bool>())).Returns(engineResult);
            collection.Add(engine.Object);

            // Act
            ViewEngineResult result = collection.FindPartialView(context, "partial");

            // Assert
            Assert.Same(engineResult, result);
        }

        [Fact]
        public void FindPartialViewThrowsIfPartialViewNameIsEmpty()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => collection.FindPartialView(context, ""),
                "partialViewName");
        }

        [Fact]
        public void FindPartialViewThrowsIfPartialViewNameIsNull()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => collection.FindPartialView(context, null),
                "partialViewName");
        }

        [Fact]
        public void FindPartialViewThrowsIfControllerContextIsNull()
        {
            // Arrange
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => collection.FindPartialView(null, "partial"),
                "controllerContext");
        }

        [Fact]
        public void FindViewAggregatesAllSearchedLocationsIfAllEnginesFail()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "location1", "location2" });
            engine1.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new[] { "location3", "location4" });
            engine2.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine2Result);
            collection.Add(engine1.Object);
            collection.Add(engine2.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Null(result.View);
            Assert.Equal(4, result.SearchedLocations.Count());
            Assert.Contains("location1", result.SearchedLocations);
            Assert.Contains("location2", result.SearchedLocations);
            Assert.Contains("location3", result.SearchedLocations);
            Assert.Contains("location4", result.SearchedLocations);
        }

        [Fact]
        public void FindViewFailureWithOneEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new[] { "location1", "location2" });
            engine.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engineResult);
            collection.Add(engine.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Null(result.View);
            Assert.Equal(2, result.SearchedLocations.Count());
            Assert.Contains("location1", result.SearchedLocations);
            Assert.Contains("location2", result.SearchedLocations);
        }

        [Fact]
        public void FindViewLooksAtCacheFirst()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindView(context, "view", "master", true)).Returns(engineResult);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engineResult, result);
            engine.Verify(e => e.FindView(context, "view", "master", true), Times.Once());
            engine.Verify(e => e.FindView(context, "view", "master", false), Times.Never());
        }

        [Fact]
        public void FindViewLooksAtLocatorIfCacheEmpty()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindView(context, "view", "master", true)).Returns(new ViewEngineResult(new[] { "path" }));
            engine.Setup(e => e.FindView(context, "view", "master", false)).Returns(engineResult);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engineResult, result);
            engine.Verify(e => e.FindView(context, "view", "master", true), Times.Once());
            engine.Verify(e => e.FindView(context, "view", "master", false), Times.Once());
        }

        [Fact]
        public void FindViewIgnoresSearchLocationsFromCache()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            engine.Setup(e => e.FindView(context, "view", "master", true)).Returns(new ViewEngineResult(new[] { "cachePath" }));
            engine.Setup(e => e.FindView(context, "view", "master", false)).Returns(new ViewEngineResult(new[] { "locatorPath" }));
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine.Object,
            };

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            string searchedLocation = Assert.Single(result.SearchedLocations);
            Assert.Equal("locatorPath", searchedLocation);
            engine.Verify(e => e.FindView(context, "view", "master", true), Times.Once());
            engine.Verify(e => e.FindView(context, "view", "master", false), Times.Once());
        }

        [Fact]
        public void FindViewIteratesThroughCollectionUntilFindsSuccessfulEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "location1", "location2" });
            engine1.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new Mock<IView>().Object, engine2.Object);
            engine2.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine2Result);
            collection.Add(engine1.Object);
            collection.Add(engine2.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engine2Result, result);
        }

        [Fact]
        public void FindViewRemovesDuplicateSearchedLocationsFromMultipleEngines()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new[] { "repeatLocation", "location1" });
            engine1.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new[] { "location2", "repeatLocation" });
            engine2.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine2Result);
            ViewEngineCollection collection = new ViewEngineCollection()
            {
                engine1.Object,
                engine2.Object,
            };

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Null(result.View);
            var expectedLocations = new[] { "repeatLocation", "location1", "location2" };
            Assert.Equal(expectedLocations, result.SearchedLocations.ToArray());
        }

        [Fact]
        public void FindViewReturnsNoViewAndEmptySearchedLocationsIfCollectionEmpty()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act
            ViewEngineResult result = collection.FindView(context, "view", null);

            // Assert
            Assert.Null(result.View);
            Assert.Empty(result.SearchedLocations);
        }

        [Fact]
        public void FindViewReturnsValueFromFirstSuccessfulEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine1 = new Mock<IViewEngine>();
            ViewEngineResult engine1Result = new ViewEngineResult(new Mock<IView>().Object, engine1.Object);
            engine1.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine1Result);
            Mock<IViewEngine> engine2 = new Mock<IViewEngine>();
            ViewEngineResult engine2Result = new ViewEngineResult(new Mock<IView>().Object, engine2.Object);
            engine2.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engine2Result);
            collection.Add(engine1.Object);
            collection.Add(engine2.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engine1Result, result);
        }

        [Fact]
        public void FindViewSuccessWithOneEngine()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();
            Mock<IViewEngine> engine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(new Mock<IView>().Object, engine.Object);
            engine.Setup(e => e.FindView(context, "view", "master", It.IsAny<bool>())).Returns(engineResult);
            collection.Add(engine.Object);

            // Act
            ViewEngineResult result = collection.FindView(context, "view", "master");

            // Assert
            Assert.Same(engineResult, result);
        }

        [Fact]
        public void FindViewThrowsIfControllerContextIsNull()
        {
            // Arrange
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => collection.FindView(null, "view", null),
                "controllerContext"
                );
        }

        [Fact]
        public void FindViewThrowsIfViewNameIsEmpty()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => collection.FindView(context, "", null),
                "viewName"
                );
        }

        [Fact]
        public void FindViewThrowsIfViewNameIsNull()
        {
            // Arrange
            ControllerContext context = new Mock<ControllerContext>().Object;
            ViewEngineCollection collection = new ViewEngineCollection();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => collection.FindView(context, null, null),
                "viewName"
                );
        }

        [Fact]
        public void FindViewDelegatesToResolver()
        {
            // Arrange
            Mock<IView> view = new Mock<IView>();
            ControllerContext context = new ControllerContext();
            Mock<IViewEngine> locatedEngine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(view.Object, locatedEngine.Object);
            locatedEngine.Setup(e => e.FindView(context, "ViewName", "MasterName", true))
                .Returns(engineResult);
            Mock<IViewEngine> secondEngine = new Mock<IViewEngine>();

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IViewEngine))).Returns(new IViewEngine[] { locatedEngine.Object, secondEngine.Object });

            ViewEngineCollection engines = new ViewEngineCollection(new IViewEngine[0], resolver.Object);

            // Act
            ViewEngineResult result = engines.FindView(context, "ViewName", "MasterName");

            // Assert
            Assert.Same(engineResult, result);
            secondEngine.Verify(e => e.FindView(context, "ViewName", "MasterName", It.IsAny<bool>()), Times.Never());
        }

        [Fact]
        public void FindPartialViewDelegatesToResolver()
        {
            // Arrange
            Mock<IView> view = new Mock<IView>();
            ControllerContext context = new ControllerContext();
            Mock<IViewEngine> locatedEngine = new Mock<IViewEngine>();
            ViewEngineResult engineResult = new ViewEngineResult(view.Object, locatedEngine.Object);
            locatedEngine.Setup(e => e.FindPartialView(context, "ViewName", true))
                .Returns(engineResult);
            Mock<IViewEngine> secondEngine = new Mock<IViewEngine>();

            var resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetServices(typeof(IViewEngine))).Returns(new IViewEngine[] { locatedEngine.Object, secondEngine.Object });

            ViewEngineCollection engines = new ViewEngineCollection(new IViewEngine[0], resolver.Object);

            // Act
            ViewEngineResult result = engines.FindPartialView(context, "ViewName");

            // Assert
            Assert.Same(engineResult, result);
            secondEngine.Verify(e => e.FindPartialView(context, "ViewName", It.IsAny<bool>()), Times.Never());
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewEngineResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ViewEngineResultTest
    {
        [Fact]
        public void ConstructorThrowsIfSearchedLocationsIsNull()
        {
            // Arrange
            string[] searchedLocations = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ViewEngineResult(searchedLocations); }, "searchedLocations");
        }

        [Fact]
        public void ConstructorThrowsIfViewIsNull()
        {
            // Arrange
            IView view = null;

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ViewEngineResult(view, null); }, "view");
        }

        [Fact]
        public void ConstructorThrowsIfViewEngineIsNull()
        {
            // Arrange
            IView view = new Mock<IView>().Object;

            // Act & Assert
            Assert.ThrowsArgumentNull(
                delegate { new ViewEngineResult(view, null); }, "viewEngine");
        }

        [Fact]
        public void SearchedLocationsProperty()
        {
            // Arrange
            string[] searchedLocations = new string[0];
            ViewEngineResult result = new ViewEngineResult(searchedLocations);

            // Act & Assert
            Assert.Same(searchedLocations, result.SearchedLocations);
            Assert.Null(result.View);
        }

        [Fact]
        public void ViewProperty()
        {
            // Arrange
            IView view = new Mock<IView>().Object;
            IViewEngine viewEngine = new Mock<IViewEngine>().Object;
            ViewEngineResult result = new ViewEngineResult(view, viewEngine);

            // Act & Assert
            Assert.Same(view, result.View);
            Assert.Null(result.SearchedLocations);
        }

        [Fact]
        public void ViewEngineProperty()
        {
            // Arrange
            IView view = new Mock<IView>().Object;
            IViewEngine viewEngine = new Mock<IViewEngine>().Object;
            ViewEngineResult result = new ViewEngineResult(view, viewEngine);

            // Act & Assert
            Assert.Same(viewEngine, result.ViewEngine);
            Assert.Null(result.SearchedLocations);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewEnginesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ViewEnginesTest
    {
        [Fact]
        public void EnginesProperty()
        {
            // Act
            ViewEngineCollection collection = ViewEngines.Engines;

            // Assert
            Assert.Equal(2, collection.Count);
            Assert.IsType<WebFormViewEngine>(collection[0]);
            Assert.IsType<RazorViewEngine>(collection[1]);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewMasterPageControlBuilderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ViewMasterPageControlBuilderTest
    {
        [Fact]
        public void BuilderWithoutInheritsDoesNothing()
        {
            // Arrange
            var builder = new ViewMasterPageControlBuilder();
            var derivedType = new CodeTypeDeclaration();
            derivedType.BaseTypes.Add("basetype");

            // Act
            builder.ProcessGeneratedCode(null, null, derivedType, null, null);

            // Assert
            Assert.Equal("basetype", derivedType.BaseTypes.Cast<CodeTypeReference>().Single().BaseType);
        }

        [Fact]
        public void BuilderWithInheritsSetsBaseType()
        {
            // Arrange
            var builder = new ViewMasterPageControlBuilder { Inherits = "inheritedtype" };
            var derivedType = new CodeTypeDeclaration();
            derivedType.BaseTypes.Add("basetype");

            // Act
            builder.ProcessGeneratedCode(null, null, derivedType, null, null);

            // Assert
            Assert.Equal("inheritedtype", derivedType.BaseTypes.Cast<CodeTypeReference>().Single().BaseType);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewMasterPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Routing;
using System.Web.UI;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ViewMasterPageTest
    {
        [Fact]
        public void GetModelFromViewPage()
        {
            // Arrange
            ViewMasterPage vmp = new ViewMasterPage();
            ViewPage vp = new ViewPage();
            vmp.Page = vp;
            object model = new object();
            vp.ViewData = new ViewDataDictionary(model);

            // Assert
            Assert.Equal(model, vmp.Model);
        }

        [Fact]
        public void GetModelFromViewPageStronglyTyped()
        {
            // Arrange
            ViewMasterPage<FooModel> vmp = new ViewMasterPage<FooModel>();
            ViewPage vp = new ViewPage();
            vmp.Page = vp;
            FooModel model = new FooModel();
            vp.ViewData = new ViewDataDictionary(model);

            // Assert
            Assert.Equal(model, vmp.Model);
        }

        [Fact]
        public void GetViewDataFromViewPage()
        {
            // Arrange
            ViewMasterPage vmp = new ViewMasterPage();
            ViewPage vp = new ViewPage();
            vmp.Page = vp;
            vp.ViewData = new ViewDataDictionary { { "a", "123" }, { "b", "456" } };

            // Assert
            Assert.Equal("123", vmp.ViewData.Eval("a"));
            Assert.Equal("456", vmp.ViewData.Eval("b"));
        }

        [Fact]
        public void GetViewItemFromViewPageTViewData()
        {
            // Arrange
            MockViewMasterPageDummyViewData vmp = new MockViewMasterPageDummyViewData();
            MockViewPageDummyViewData vp = new MockViewPageDummyViewData();
            vmp.Page = vp;
            vp.ViewData.Model = new DummyViewData { MyInt = 123, MyString = "abc" };

            // Assert
            Assert.Equal(123, vmp.ViewData.Model.MyInt);
            Assert.Equal("abc", vmp.ViewData.Model.MyString);
        }

        [Fact]
        public void GetWriterFromViewPage()
        {
            // Arrange
            bool triggered = false;
            HtmlTextWriter writer = new HtmlTextWriter(TextWriter.Null);
            ViewMasterPage vmp = new ViewMasterPage();
            MockViewPage vp = new MockViewPage();
            vp.RenderCallback = delegate()
            {
                triggered = true;
                Assert.Equal(writer, vmp.Writer);
            };
            vmp.Page = vp;

            // Act & Assert
            Assert.Null(vmp.Writer);
            vp.RenderControl(writer);
            Assert.Null(vmp.Writer);
            Assert.True(triggered);
        }

        [Fact]
        public void GetViewDataFromPageThrows()
        {
            // Arrange
            ViewMasterPage vmp = new ViewMasterPage();
            vmp.Page = new Page();

            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { object foo = vmp.ViewData; },
                "A ViewMasterPage can be used only with content pages that derive from ViewPage or ViewPage<TModel>.");
        }

        [Fact]
        public void GetViewItemFromWrongGenericViewPageType()
        {
            // Arrange
            MockViewMasterPageDummyViewData vmp = new MockViewMasterPageDummyViewData();
            MockViewPageBogusViewData vp = new MockViewPageBogusViewData();
            vmp.Page = vp;
            vp.ViewData.Model = new SelectListItem();

            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { object foo = vmp.ViewData.Model; },
                "The model item passed into the dictionary is of type 'System.Web.Mvc.SelectListItem', but this dictionary requires a model item of type 'System.Web.Mvc.Test.ViewMasterPageTest+DummyViewData'.");
        }

        [Fact]
        public void GetViewDataFromNullPageThrows()
        {
            // Arrange
            MockViewMasterPageDummyViewData vmp = new MockViewMasterPageDummyViewData();

            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { object foo = vmp.ViewData; },
                "A ViewMasterPage can be used only with content pages that derive from ViewPage or ViewPage<TModel>.");
        }

        [Fact]
        public void GetViewDataFromRegularPageThrows()
        {
            // Arrange
            MockViewMasterPageDummyViewData vmp = new MockViewMasterPageDummyViewData();
            vmp.Page = new Page();

            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { object foo = vmp.ViewData; },
                "A ViewMasterPage can be used only with content pages that derive from ViewPage or ViewPage<TModel>.");
        }

        [Fact]
        public void GetHtmlHelperFromViewPage()
        {
            // Arrange
            ViewMasterPage vmp = new ViewMasterPage();
            ViewPage vp = new ViewPage();
            vmp.Page = vp;
            ViewContext vc = new Mock<ViewContext>().Object;

            HtmlHelper<object> htmlHelper = new HtmlHelper<object>(vc, vp);
            vp.Html = htmlHelper;

            // Assert
            Assert.Equal(vmp.Html, htmlHelper);
        }

        [Fact]
        public void GetUrlHelperFromViewPage()
        {
            // Arrange
            ViewMasterPage vmp = new ViewMasterPage();
            ViewPage vp = new ViewPage();
            vmp.Page = vp;
            RequestContext rc = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            UrlHelper urlHelper = new UrlHelper(rc);
            vp.Url = urlHelper;

            // Assert
            Assert.Equal(vmp.Url, urlHelper);
        }

        [Fact]
        public void ViewBagProperty_ReflectsViewData()
        {
            // Arrange
            ViewPage page = new ViewPage();
            ViewMasterPage masterPage = new ViewMasterPage();
            masterPage.Page = page;
            masterPage.ViewData["A"] = 1;

            // Act & Assert
            Assert.NotNull(masterPage.ViewBag);
            Assert.Equal(1, masterPage.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_PropagatesChangesToViewData()
        {
            // Arrange
            ViewPage page = new ViewPage();
            ViewMasterPage masterPage = new ViewMasterPage();
            masterPage.Page = page;
            masterPage.ViewData["A"] = 1;

            // Act
            masterPage.ViewBag.A = "foo";
            masterPage.ViewBag.B = 2;

            // Assert
            Assert.Equal("foo", masterPage.ViewData["A"]);
            Assert.Equal(2, masterPage.ViewData["B"]);
        }

        // Master page types
        private sealed class MockViewMasterPageDummyViewData : ViewMasterPage<DummyViewData>
        {
        }

        // View data types
        private sealed class DummyViewData
        {
            public int MyInt { get; set; }
            public string MyString { get; set; }
        }

        // Page types
        private sealed class MockViewPageBogusViewData : ViewPage<SelectListItem>
        {
        }

        private sealed class MockViewPageDummyViewData : ViewPage<DummyViewData>
        {
        }

        private sealed class MockViewPage : ViewPage
        {
            public Action RenderCallback { get; set; }

            protected override void RenderChildren(HtmlTextWriter writer)
            {
                if (RenderCallback != null)
                {
                    RenderCallback();
                }
                base.RenderChildren(writer);
            }
        }

        private sealed class FooModel
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewPageControlBuilderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ViewPageControlBuilderTest
    {
        [Fact]
        public void BuilderWithoutInheritsDoesNothing()
        {
            // Arrange
            var builder = new ViewPageControlBuilder();
            var derivedType = new CodeTypeDeclaration();
            derivedType.BaseTypes.Add("basetype");

            // Act
            builder.ProcessGeneratedCode(null, null, derivedType, null, null);

            // Assert
            Assert.Equal("basetype", derivedType.BaseTypes.Cast<CodeTypeReference>().Single().BaseType);
        }

        [Fact]
        public void BuilderWithInheritsSetsBaseType()
        {
            // Arrange
            var builder = new ViewPageControlBuilder { Inherits = "inheritedtype" };
            var derivedType = new CodeTypeDeclaration();
            derivedType.BaseTypes.Add("basetype");

            // Act
            builder.ProcessGeneratedCode(null, null, derivedType, null, null);

            // Assert
            Assert.Equal("inheritedtype", derivedType.BaseTypes.Cast<CodeTypeReference>().Single().BaseType);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.UI;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ViewPageTest
    {
        [Fact]
        public void ModelProperty()
        {
            // Arrange
            object model = new object();
            ViewDataDictionary viewData = new ViewDataDictionary(model);
            ViewPage viewPage = new ViewPage();
            viewPage.ViewData = viewData;

            // Act
            object viewPageModel = viewPage.Model;

            // Assert
            Assert.Equal(model, viewPageModel);
            Assert.Equal(model, viewPage.ViewData.Model);
        }

        [Fact]
        public void ModelPropertyStronglyTypedViewPage()
        {
            // Arrange
            FooModel model = new FooModel();
            ViewDataDictionary<FooModel> viewData = new ViewDataDictionary<FooModel>(model);
            ViewPage<FooModel> viewPage = new ViewPage<FooModel>();
            viewPage.ViewData = viewData;

            // Act
            object viewPageModelObject = ((ViewPage)viewPage).Model;
            FooModel viewPageModelPerson = viewPage.Model;

            // Assert
            Assert.Equal(model, viewPageModelObject);
            Assert.Equal(model, viewPageModelPerson);
        }

        [Fact]
        public void SetViewItemOnBaseClassPropagatesToDerivedClass()
        {
            // Arrange
            ViewPage<object> vpInt = new ViewPage<object>();
            ViewPage vp = vpInt;
            object o = new object();

            // Act
            vp.ViewData.Model = o;

            // Assert
            Assert.Equal(o, vpInt.ViewData.Model);
            Assert.Equal(o, vp.ViewData.Model);
        }

        [Fact]
        public void SetViewItemOnDerivedClassPropagatesToBaseClass()
        {
            // Arrange
            ViewPage<object> vpInt = new ViewPage<object>();
            ViewPage vp = vpInt;
            object o = new object();

            // Act
            vpInt.ViewData.Model = o;

            // Assert
            Assert.Equal(o, vpInt.ViewData.Model);
            Assert.Equal(o, vp.ViewData.Model);
        }

        [Fact]
        public void SetViewItemToWrongTypeThrows()
        {
            // Arrange
            ViewPage vp = new ViewPage<string>();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                delegate { vp.ViewData.Model = 50; },
                "The model item passed into the dictionary is of type 'System.Int32', but this dictionary requires a model item of type 'System.String'.");
        }

        [Fact]
        public void RenderInitsHelpersAndSetsID()
        {
            // Arrange
            ViewPageWithNoProcessRequest viewPage = new ViewPageWithNoProcessRequest();
            TextWriter writer = new StringWriter();

            Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
            mockViewContext.Setup(c => c.Writer).Returns(writer);
            mockViewContext.Setup(c => c.HttpContext.Response.Output).Returns(TextWriter.Null);
            mockViewContext.Setup(c => c.HttpContext.Server.Execute(It.IsAny<IHttpHandler>(), It.IsAny<TextWriter>(), true))
                .Callback<IHttpHandler, TextWriter, bool>((_h, _w, _pf) =>
                {
                    ViewPage.SwitchWriter switchWriter = _w as ViewPage.SwitchWriter;
                    Assert.NotNull(switchWriter);
                    Assert.Same(writer, switchWriter.InnerWriter);
                })
                .Verifiable();

            // Act
            viewPage.RenderView(mockViewContext.Object);

            // Assert
            mockViewContext.Verify();
            Assert.NotNull(viewPage.Ajax);
            Assert.NotNull(viewPage.Html);
            Assert.NotNull(viewPage.Url);
        }

        [Fact]
        public void GenericPageRenderInitsHelpersAndSetsID()
        {
            // Arrange
            Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
            mockViewContext.Setup(c => c.Writer).Returns(new StringWriter());
            mockViewContext.Setup(c => c.HttpContext.Response.Output).Returns(TextWriter.Null);
            mockViewContext.Setup(c => c.HttpContext.Server).Returns(new Mock<HttpServerUtilityBase>().Object);

            ViewPageWithNoProcessRequest<Controller> viewPage = new ViewPageWithNoProcessRequest<Controller>();

            // Act
            viewPage.RenderView(mockViewContext.Object);

            // Assert
            Assert.NotNull(viewPage.Ajax);
            Assert.NotNull(viewPage.Html);
            Assert.NotNull(viewPage.Url);
            Assert.NotNull(((ViewPage)viewPage).Html);
            Assert.NotNull(((ViewPage)viewPage).Url);
        }

        private static void WriterSetCorrectlyInternal(bool throwException)
        {
            // Arrange
            bool triggered = false;
            HtmlTextWriter writer = new HtmlTextWriter(TextWriter.Null);
            MockViewPage vp = new MockViewPage();
            vp.RenderCallback = delegate()
            {
                triggered = true;
                Assert.Equal(writer, vp.Writer);
                if (throwException)
                {
                    throw new CallbackException();
                }
            };

            // Act & Assert
            Assert.Null(vp.Writer);
            try
            {
                vp.RenderControl(writer);
            }
            catch (CallbackException)
            {
            }
            Assert.Null(vp.Writer);
            Assert.True(triggered);
        }

        [Fact]
        public void WriterSetCorrectly()
        {
            WriterSetCorrectlyInternal(false /* throwException */);
        }

        [Fact]
        public void WriterSetCorrectlyThrowException()
        {
            WriterSetCorrectlyInternal(true /* throwException */);
        }

        private sealed class ViewPageWithNoProcessRequest : ViewPage
        {
            public override void ProcessRequest(HttpContext context)
            {
            }
        }

        private sealed class ViewPageWithNoProcessRequest<TModel> : ViewPage<TModel>
        {
            public override void ProcessRequest(HttpContext context)
            {
            }
        }

        [Fact]
        public void ViewBagProperty_ReflectsViewData()
        {
            // Arrange
            ViewPage page = new ViewPage();
            page.ViewData["A"] = 1;

            // Act & Assert
            Assert.NotNull(page.ViewBag);
            Assert.Equal(1, page.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_ReflectsNewViewDataInstance()
        {
            // Arrange
            ViewPage page = new ViewPage();
            page.ViewData["A"] = 1;
            page.ViewData = new ViewDataDictionary() { { "A", "bar" } };

            // Act & Assert
            Assert.Equal("bar", page.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_PropagatesChangesToViewData()
        {
            // Arrange
            ViewPage page = new ViewPage();
            page.ViewData["A"] = 1;

            // Act
            page.ViewBag.A = "foo";
            page.ViewBag.B = 2;

            // Assert
            Assert.Equal("foo", page.ViewData["A"]);
            Assert.Equal(2, page.ViewData["B"]);
        }

        private sealed class MockViewPage : ViewPage
        {
            public MockViewPage()
            {
            }

            public Action RenderCallback { get; set; }

            protected override void RenderChildren(HtmlTextWriter writer)
            {
                if (RenderCallback != null)
                {
                    RenderCallback();
                }
                base.RenderChildren(writer);
            }
        }

        private sealed class FooModel
        {
        }

        private sealed class CallbackException : Exception
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewResultBaseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ViewResultBaseTest
    {
        [Fact]
        public void ExecuteResultWithNullControllerContextThrows()
        {
            // Arrange
            ViewResultBaseHelper result = new ViewResultBaseHelper();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => result.ExecuteResult(null),
                "context");
        }

        [Fact]
        public void TempDataProperty()
        {
            // Arrange
            TempDataDictionary newDict = new TempDataDictionary();
            ViewResultBaseHelper result = new ViewResultBaseHelper();

            // Act & Assert
            MemberHelper.TestPropertyWithDefaultInstance(result, "TempData", newDict);
        }

        [Fact]
        public void ViewDataProperty()
        {
            // Arrange
            ViewDataDictionary newDict = new ViewDataDictionary();
            ViewResultBaseHelper result = new ViewResultBaseHelper();

            // Act & Assert
            MemberHelper.TestPropertyWithDefaultInstance(result, "ViewData", newDict);
        }

        [Fact]
        public void ViewEngineCollectionProperty()
        {
            // Arrange
            ViewEngineCollection viewEngineCollection = new ViewEngineCollection();
            ViewResultBaseHelper result = new ViewResultBaseHelper();

            // Act & Assert
            MemberHelper.TestPropertyWithDefaultInstance(result, "ViewEngineCollection", viewEngineCollection);
        }

        [Fact]
        public void ViewNameProperty()
        {
            // Arrange
            ViewResultBaseHelper result = new ViewResultBaseHelper();

            // Act & Assert
            MemberHelper.TestStringProperty(result, "ViewName", String.Empty);
        }

        public class ViewResultBaseHelper : ViewResultBase
        {
            protected override ViewEngineResult FindView(ControllerContext context)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewResultTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Web.Routing;
using System.Web.TestUtil;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ViewResultTest
    {
        private const string _viewName = "My cool view.";
        private const string _masterName = "My cool master.";

        [Fact]
        public void EmptyViewNameUsesActionNameAsViewName()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = _viewName;
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IViewEngine> viewEngine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            List<IViewEngine> viewEngines = new List<IViewEngine>();
            viewEngines.Add(viewEngine.Object);
            Mock<ViewEngineCollection> viewEngineCollection = new Mock<ViewEngineCollection>(MockBehavior.Strict, viewEngines);
            ViewResult result = new ViewResultHelper { ViewEngineCollection = viewEngineCollection.Object };
            viewEngineCollection
                .Setup(e => e.FindView(It.IsAny<ControllerContext>(), _viewName, _masterName))
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            viewEngine
                .Setup(e => e.FindView(It.IsAny<ControllerContext>(), _viewName, _masterName, It.IsAny<bool>()))
                .Callback<ControllerContext, string, string, bool>(
                    (controllerContext, viewName, masterName, useCache) =>
                    {
                        Assert.Same(httpContext, controllerContext.HttpContext);
                        Assert.Same(routeData, controllerContext.RouteData);
                    })
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            view
                .Setup(o => o.Render(It.IsAny<ViewContext>(), httpContext.Response.Output))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.Same(view.Object, viewContext.View);
                        Assert.Same(result.ViewData, viewContext.ViewData);
                        Assert.Same(result.TempData, viewContext.TempData);
                        Assert.Same(controller, viewContext.Controller);
                    });
            viewEngine
                .Setup(e => e.ReleaseView(context, It.IsAny<IView>()))
                .Callback<ControllerContext, IView>(
                    (controllerContext, releasedView) => { Assert.Same(releasedView, view.Object); });

            // Act
            result.ExecuteResult(context);

            // Assert
            viewEngine.Verify();
            viewEngineCollection.Verify();
            view.Verify();
        }

        [Fact]
        public void EngineLookupFailureThrows()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = _viewName;
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IViewEngine> viewEngine = new Mock<IViewEngine>(MockBehavior.Strict);
            List<IViewEngine> viewEngines = new List<IViewEngine>();
            viewEngines.Add(viewEngine.Object);
            Mock<ViewEngineCollection> viewEngineCollection = new Mock<ViewEngineCollection>(MockBehavior.Strict, viewEngines);
            ViewResult result = new ViewResultHelper { ViewEngineCollection = viewEngineCollection.Object };
            viewEngineCollection
                .Setup(e => e.FindView(It.IsAny<ControllerContext>(), _viewName, _masterName))
                .Returns(new ViewEngineResult(new[] { "location1", "location2" }));
            viewEngine
                .Setup(e => e.FindView(It.IsAny<ControllerContext>(), _viewName, _masterName, It.IsAny<bool>()))
                .Callback<ControllerContext, string, string, bool>(
                    (controllerContext, viewName, masterName, useCache) =>
                    {
                        Assert.Same(httpContext, controllerContext.HttpContext);
                        Assert.Same(routeData, controllerContext.RouteData);
                    })
                .Returns(new ViewEngineResult(new[] { "location1", "location2" }));

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => result.ExecuteResult(context),
                "The view '" + _viewName + "' or its master was not found or no view engine supports the searched locations. The following locations were searched:" + Environment.NewLine
              + "location1" + Environment.NewLine
              + "location2");

            viewEngine.Verify();
            viewEngineCollection.Verify();
        }

        [Fact]
        public void EngineLookupSuccessRendersView()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IViewEngine> viewEngine = new Mock<IViewEngine>(MockBehavior.Strict);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            List<IViewEngine> viewEngines = new List<IViewEngine>();
            viewEngines.Add(viewEngine.Object);
            Mock<ViewEngineCollection> viewEngineCollection = new Mock<ViewEngineCollection>(MockBehavior.Strict, viewEngines);
            ViewResult result = new ViewResultHelper { ViewName = _viewName, ViewEngineCollection = viewEngineCollection.Object };
            view
                .Setup(o => o.Render(It.IsAny<ViewContext>(), httpContext.Response.Output))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.Same(view.Object, viewContext.View);
                        Assert.Same(result.ViewData, viewContext.ViewData);
                        Assert.Same(result.TempData, viewContext.TempData);
                        Assert.Same(controller, viewContext.Controller);
                    });
            viewEngineCollection
                .Setup(e => e.FindView(It.IsAny<ControllerContext>(), _viewName, _masterName))
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            viewEngine
                .Setup(e => e.FindView(It.IsAny<ControllerContext>(), _viewName, _masterName, It.IsAny<bool>()))
                .Callback<ControllerContext, string, string, bool>(
                    (controllerContext, viewName, masterName, useCache) =>
                    {
                        Assert.Same(httpContext, controllerContext.HttpContext);
                        Assert.Same(routeData, controllerContext.RouteData);
                    })
                .Returns(new ViewEngineResult(view.Object, viewEngine.Object));
            viewEngine
                .Setup(e => e.ReleaseView(context, It.IsAny<IView>()))
                .Callback<ControllerContext, IView>(
                    (controllerContext, releasedView) => { Assert.Same(releasedView, view.Object); });

            // Act
            result.ExecuteResult(context);

            // Assert
            viewEngine.Verify();
            viewEngineCollection.Verify();
            view.Verify();
        }

        [Fact]
        public void ExecuteResultWithExplicitViewObject()
        {
            // Arrange
            ControllerBase controller = new Mock<ControllerBase>().Object;
            HttpContextBase httpContext = CreateHttpContext();
            RouteData routeData = new RouteData();
            routeData.Values["action"] = _viewName;
            ControllerContext context = new ControllerContext(httpContext, routeData, controller);
            Mock<IView> view = new Mock<IView>(MockBehavior.Strict);
            ViewResult result = new ViewResultHelper { View = view.Object };
            view
                .Setup(o => o.Render(It.IsAny<ViewContext>(), httpContext.Response.Output))
                .Callback<ViewContext, TextWriter>(
                    (viewContext, writer) =>
                    {
                        Assert.Same(view.Object, viewContext.View);
                        Assert.Same(result.ViewData, viewContext.ViewData);
                        Assert.Same(result.TempData, viewContext.TempData);
                        Assert.Same(controller, viewContext.Controller);
                    });

            // Act
            result.ExecuteResult(context);

            // Assert
            view.Verify();
        }

        [Fact]
        public void ExecuteResultWithNullControllerContextThrows()
        {
            // Arrange
            ViewResult result = new ViewResultHelper();

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => result.ExecuteResult(null),
                "context");
        }

        [Fact]
        public void MasterNameProperty()
        {
            // Arrange
            ViewResult result = new ViewResult();

            // Act & Assert
            MemberHelper.TestStringProperty(result, "MasterName", String.Empty);
        }

        private static HttpContextBase CreateHttpContext()
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(c => c.Response.Output).Returns(TextWriter.Null);
            return mockHttpContext.Object;
        }

        private class ViewResultHelper : ViewResult
        {
            public ViewResultHelper()
            {
                ViewEngineCollection = new ViewEngineCollection(new IViewEngine[] { new WebFormViewEngine() });
                MasterName = _masterName;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewStartPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Routing;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ViewStartPageTest
    {
        [Fact]
        public void Html_DelegatesToChildPage()
        {
            // Arrange
            MockViewStartPage viewStart = new MockViewStartPage();
            var viewPage = new Mock<WebViewPage>() { CallBase = true };
            var helper = new HtmlHelper<object>(new ViewContext() { ViewData = new ViewDataDictionary() }, viewPage.Object, new RouteCollection());
            viewPage.Object.Html = helper;
            viewStart.ChildPage = viewPage.Object;

            // Act
            var result = viewStart.Html;

            // Assert
            Assert.Same(helper, result);
        }

        [Fact]
        public void Url_DelegatesToChildPage()
        {
            // Arrange
            MockViewStartPage viewStart = new MockViewStartPage();
            var viewPage = new Mock<WebViewPage>() { CallBase = true };
            var helper = new UrlHelper(new RequestContext());
            viewPage.Object.Url = helper;
            viewStart.ChildPage = viewPage.Object;

            // Act
            var result = viewStart.Url;

            // Assert
            Assert.Same(helper, result);
        }

        [Fact]
        public void ViewContext_DelegatesToChildPage()
        {
            // Arrange
            MockViewStartPage viewStart = new MockViewStartPage();
            var viewPage = new Mock<WebViewPage>() { CallBase = true };
            var viewContext = new ViewContext();
            viewPage.Object.ViewContext = viewContext;
            viewStart.ChildPage = viewPage.Object;

            // Act
            var result = viewStart.ViewContext;

            // Assert
            Assert.Same(viewContext, result);
        }

        [Fact]
        public void ViewStartPageChild_ThrowsOnNonMvcChildPage()
        {
            // Arrange
            MockViewStartPage viewStart = new MockViewStartPage();
            viewStart.ChildPage = new Mock<WebPage>().Object;

            // Act + Assert
            Assert.Throws<InvalidOperationException>(delegate() { var c = viewStart.ViewStartPageChild; }, "A ViewStartPage can be used only with with a page that derives from WebViewPage or another ViewStartPage.");
        }

        [Fact]
        public void ViewStartPageChild_WorksWithWebViewPage()
        {
            // Arrange
            MockViewStartPage viewStart = new MockViewStartPage();
            var viewPage = new Mock<WebViewPage>();
            viewStart.ChildPage = viewPage.Object;

            // Act
            var result = viewStart.ViewStartPageChild;

            // Assert
            Assert.Same(viewPage.Object, result);
        }

        [Fact]
        public void ViewStartPageChild_WorksWithAnotherRazorStartPage()
        {
            // Arrange
            MockViewStartPage viewStart = new MockViewStartPage();
            var anotherViewStart = new Mock<ViewStartPage>();
            viewStart.ChildPage = anotherViewStart.Object;

            // Act
            var result = viewStart.ViewStartPageChild;

            // Assert
            Assert.Same(anotherViewStart.Object, result);
        }

        class MockViewStartPage : ViewStartPage
        {
            public override void Execute()
            {
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewTypeParserFilterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.UI;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ViewTypeParserFilterTest
    {
        // Non-generic directives

        [Fact]
        public void NonGenericPageDirectiveDoesNotChangeInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("page", attributes);
            filter.ParseComplete(builder);

            Assert.Equal("foobar", attributes["inherits"]);
            Assert.Null(builder.Inherits);
        }

        [Fact]
        public void NonGenericControlDirectiveDoesNotChangeInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("control", attributes);
            filter.ParseComplete(builder);

            Assert.Equal("foobar", attributes["inherits"]);
            Assert.Null(builder.Inherits);
        }

        [Fact]
        public void NonGenericMasterDirectiveDoesNotChangeInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("master", attributes);
            filter.ParseComplete(builder);

            Assert.Equal("foobar", attributes["inherits"]);
            Assert.Null(builder.Inherits);
        }

        // C#-style generic directives

        [Fact]
        public void CSGenericUnknownDirectiveDoesNotChangeInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar<baz>" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("unknown", attributes);
            filter.ParseComplete(builder);

            Assert.Equal("foobar<baz>", attributes["inherits"]);
            Assert.Null(builder.Inherits);
        }

        [Fact]
        public void CSGenericPageDirectiveChangesInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar<baz>" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("page", attributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewPage).FullName, attributes["inherits"]);
            Assert.Equal("foobar<baz>", builder.Inherits);
        }

        [Fact]
        public void CSGenericControlDirectiveChangesInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar<baz>" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("control", attributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewUserControl).FullName, attributes["inherits"]);
            Assert.Equal("foobar<baz>", builder.Inherits);
        }

        [Fact]
        public void CSGenericMasterDirectiveChangesInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar<baz>" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("master", attributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewMasterPage).FullName, attributes["inherits"]);
            Assert.Equal("foobar<baz>", builder.Inherits);
        }

        [Fact]
        public void CSDirectivesAfterPageDirectiveProperlyPreserveInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var pageAttributes = new Dictionary<string, string> { { "inherits", "foobar<baz>" } };
            var importAttributes = new Dictionary<string, string> { { "inherits", "dummyvalue<baz>" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("page", pageAttributes);
            filter.PreprocessDirective("import", importAttributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewPage).FullName, pageAttributes["inherits"]);
            Assert.Equal("foobar<baz>", builder.Inherits);
        }

        // VB.NET-style generic directives

        [Fact]
        public void VBGenericUnknownDirectiveDoesNotChangeInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar(of baz)" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("unknown", attributes);
            filter.ParseComplete(builder);

            Assert.Equal("foobar(of baz)", attributes["inherits"]);
            Assert.Null(builder.Inherits);
        }

        [Fact]
        public void VBGenericPageDirectiveChangesInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar(of baz)" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("page", attributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewPage).FullName, attributes["inherits"]);
            Assert.Equal("foobar(of baz)", builder.Inherits);
        }

        [Fact]
        public void VBGenericControlDirectiveChangesInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar(of baz)" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("control", attributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewUserControl).FullName, attributes["inherits"]);
            Assert.Equal("foobar(of baz)", builder.Inherits);
        }

        [Fact]
        public void VBGenericMasterDirectiveChangesInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var attributes = new Dictionary<string, string> { { "inherits", "foobar(of baz)" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("master", attributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewMasterPage).FullName, attributes["inherits"]);
            Assert.Equal("foobar(of baz)", builder.Inherits);
        }

        [Fact]
        public void VBDirectivesAfterPageDirectiveProperlyPreserveInheritsDirective()
        {
            var filter = new ViewTypeParserFilter();
            var pageAttributes = new Dictionary<string, string> { { "inherits", "foobar(of baz)" } };
            var importAttributes = new Dictionary<string, string> { { "inherits", "dummyvalue(of baz)" } };
            var builder = new MvcBuilder();

            filter.PreprocessDirective("page", pageAttributes);
            filter.PreprocessDirective("import", importAttributes);
            filter.ParseComplete(builder);

            Assert.Equal(typeof(ViewPage).FullName, pageAttributes["inherits"]);
            Assert.Equal("foobar(of baz)", builder.Inherits);
        }

        // Helpers

        private class MvcBuilder : RootBuilder, IMvcControlBuilder
        {
            public string Inherits { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewUserControlControlBuilderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ViewUserControlControlBuilderTest
    {
        [Fact]
        public void BuilderWithoutInheritsDoesNothing()
        {
            // Arrange
            var builder = new ViewUserControlControlBuilder();
            var derivedType = new CodeTypeDeclaration();
            derivedType.BaseTypes.Add("basetype");

            // Act
            builder.ProcessGeneratedCode(null, null, derivedType, null, null);

            // Assert
            Assert.Equal("basetype", derivedType.BaseTypes.Cast<CodeTypeReference>().Single().BaseType);
        }

        [Fact]
        public void BuilderWithInheritsSetsBaseType()
        {
            // Arrange
            var builder = new ViewUserControlControlBuilder { Inherits = "inheritedtype" };
            var derivedType = new CodeTypeDeclaration();
            derivedType.BaseTypes.Add("basetype");

            // Act
            builder.ProcessGeneratedCode(null, null, derivedType, null, null);

            // Assert
            Assert.Equal("inheritedtype", derivedType.BaseTypes.Cast<CodeTypeReference>().Single().BaseType);
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/ViewUserControlTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Routing;
using System.Web.TestUtil;
using System.Web.UI;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class ViewUserControlTest
    {
        [Fact]
        public void ModelProperty()
        {
            // Arrange
            object model = new object();
            ViewDataDictionary viewData = new ViewDataDictionary(model);
            ViewUserControl viewUserControl = new ViewUserControl();
            viewUserControl.ViewData = viewData;

            // Act
            object viewPageModel = viewUserControl.Model;

            // Assert
            Assert.Equal(model, viewPageModel);
            Assert.Equal(model, viewUserControl.ViewData.Model);
        }

        [Fact]
        public void ModelPropertyStronglyTyped()
        {
            // Arrange
            FooModel model = new FooModel();
            ViewDataDictionary<FooModel> viewData = new ViewDataDictionary<FooModel>(model);
            ViewUserControl<FooModel> viewUserControl = new ViewUserControl<FooModel>();
            viewUserControl.ViewData = viewData;

            // Act
            object viewPageModelObject = ((ViewUserControl)viewUserControl).Model;
            FooModel viewPageModelPerson = viewUserControl.Model;

            // Assert
            Assert.Equal(model, viewPageModelObject);
            Assert.Equal(model, viewPageModelPerson);
        }

        [Fact]
        public void RenderViewAndRestoreContentType()
        {
            // Arrange
            Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
            mockViewContext.SetupProperty(c => c.HttpContext.Response.ContentType);
            ViewContext vc = mockViewContext.Object;

            Mock<ViewPage> mockViewPage = new Mock<ViewPage>();
            mockViewPage.Setup(vp => vp.RenderView(vc)).Callback(() => vc.HttpContext.Response.ContentType = "newContentType");

            // Act
            vc.HttpContext.Response.ContentType = "oldContentType";
            ViewUserControl.RenderViewAndRestoreContentType(mockViewPage.Object, vc);
            string postContentType = vc.HttpContext.Response.ContentType;

            // Assert
            Assert.Equal("oldContentType", postContentType);
        }

        [Fact]
        public void SetViewItem()
        {
            // Arrange
            ViewUserControl vuc = new ViewUserControl();
            object viewItem = new object();
            vuc.ViewData = new ViewDataDictionary(viewItem);

            // Act
            vuc.ViewData.Model = viewItem;
            object newViewItem = vuc.ViewData.Model;

            // Assert
            Assert.Same(viewItem, newViewItem);
        }

        [Fact]
        public void SetViewItemOnBaseClassPropagatesToDerivedClass()
        {
            // Arrange
            ViewUserControl<object> vucInt = new ViewUserControl<object>();
            ViewUserControl vuc = vucInt;
            vuc.ViewData = new ViewDataDictionary();
            object o = new object();

            // Act
            vuc.ViewData.Model = o;

            // Assert
            Assert.Equal(o, vucInt.ViewData.Model);
            Assert.Equal(o, vuc.ViewData.Model);
        }

        [Fact]
        public void SetViewItemOnDerivedClassPropagatesToBaseClass()
        {
            // Arrange
            ViewUserControl<object> vucInt = new ViewUserControl<object>();
            ViewUserControl vuc = vucInt;
            vucInt.ViewData = new ViewDataDictionary<object>();
            object o = new object();

            // Act
            vucInt.ViewData.Model = o;

            // Assert
            Assert.Equal(o, vucInt.ViewData.Model);
            Assert.Equal(o, vuc.ViewData.Model);
        }

        [Fact]
        public void SetViewItemToWrongTypeThrows()
        {
            // Arrange
            ViewUserControl<string> vucString = new ViewUserControl<string>();
            vucString.ViewData = new ViewDataDictionary<string>();
            ViewUserControl vuc = vucString;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                delegate { vuc.ViewData.Model = 50; },
                "The model item passed into the dictionary is of type 'System.Int32', but this dictionary requires a model item of type 'System.String'.");
        }

        [Fact]
        public void GetViewDataWhenNoPageSetThrows()
        {
            ViewUserControl vuc = new ViewUserControl();
            vuc.AppRelativeVirtualPath = "~/Foo.ascx";

            Assert.Throws<InvalidOperationException>(
                delegate { var foo = vuc.ViewData["Foo"]; },
                "The ViewUserControl '~/Foo.ascx' cannot find an IViewDataContainer object. The ViewUserControl must be inside a ViewPage, a ViewMasterPage, or another ViewUserControl.");
        }

        [Fact]
        public void GetViewDataWhenRegularPageSetThrows()
        {
            Page p = new Page();
            p.Controls.Add(new Control());
            ViewUserControl vuc = new ViewUserControl();
            p.Controls[0].Controls.Add(vuc);
            vuc.AppRelativeVirtualPath = "~/Foo.ascx";

            Assert.Throws<InvalidOperationException>(
                delegate { var foo = vuc.ViewData["Foo"]; },
                "The ViewUserControl '~/Foo.ascx' cannot find an IViewDataContainer object. The ViewUserControl must be inside a ViewPage, a ViewMasterPage, or another ViewUserControl.");
        }

        [Fact]
        public void GetViewDataFromViewPage()
        {
            // Arrange
            ViewPage p = new ViewPage();
            p.Controls.Add(new Control());
            ViewUserControl vuc = new ViewUserControl();
            p.Controls[0].Controls.Add(vuc);
            p.ViewData = new ViewDataDictionary { { "FirstName", "Joe" }, { "LastName", "Schmoe" } };

            // Act
            object firstName = vuc.ViewData.Eval("FirstName");
            object lastName = vuc.ViewData.Eval("LastName");

            // Assert
            Assert.Equal("Joe", firstName);
            Assert.Equal("Schmoe", lastName);
        }

        [Fact]
        public void GetViewDataFromViewPageWithViewDataKeyPointingToObject()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary()
            {
                { "Foo", "FooParent" },
                { "Bar", "BarParent" },
                { "Child", new object() }
            };

            ViewPage p = new ViewPage();
            p.Controls.Add(new Control());
            ViewUserControl vuc = new ViewUserControl() { ViewDataKey = "Child" };
            p.Controls[0].Controls.Add(vuc);
            p.ViewData = vdd;

            // Act
            object oFoo = vuc.ViewData.Eval("Foo");
            object oBar = vuc.ViewData.Eval("Bar");

            // Assert
            Assert.Equal(vdd["Child"], vuc.ViewData.Model);
            Assert.Equal("FooParent", oFoo);
            Assert.Equal("BarParent", oBar);
        }

        [Fact]
        public void GetViewDataFromViewPageWithViewDataKeyPointingToViewDataDictionary()
        {
            // Arrange
            ViewDataDictionary vdd = new ViewDataDictionary()
            {
                { "Foo", "FooParent" },
                { "Bar", "BarParent" },
                {
                    "Child",
                    new ViewDataDictionary()
                    {
                        { "Foo", "FooChild" },
                        { "Bar", "BarChild" }
                    }
                    }
            };

            ViewPage p = new ViewPage();
            p.Controls.Add(new Control());
            ViewUserControl vuc = new ViewUserControl() { ViewDataKey = "Child" };
            p.Controls[0].Controls.Add(vuc);
            p.ViewData = vdd;

            // Act
            object oFoo = vuc.ViewData.Eval("Foo");
            object oBar = vuc.ViewData.Eval("Bar");

            // Assert
            Assert.Equal(vdd["Child"], vuc.ViewData);
            Assert.Equal("FooChild", oFoo);
            Assert.Equal("BarChild", oBar);
        }

        [Fact]
        public void GetViewDataFromViewUserControl()
        {
            // Arrange
            ViewPage p = new ViewPage();
            p.Controls.Add(new Control());
            ViewUserControl outerVuc = new ViewUserControl();
            p.Controls[0].Controls.Add(outerVuc);
            outerVuc.Controls.Add(new Control());
            ViewUserControl vuc = new ViewUserControl();
            outerVuc.Controls[0].Controls.Add(vuc);

            p.ViewData = new ViewDataDictionary { { "FirstName", "Joe" }, { "LastName", "Schmoe" } };

            // Act
            object firstName = vuc.ViewData.Eval("FirstName");
            object lastName = vuc.ViewData.Eval("LastName");

            // Assert
            Assert.Equal("Joe", firstName);
            Assert.Equal("Schmoe", lastName);
        }

        [Fact]
        public void GetViewDataFromViewUserControlWithViewDataKeyOnInnerControl()
        {
            // Arrange
            ViewPage p = new ViewPage();
            p.Controls.Add(new Control());
            ViewUserControl outerVuc = new ViewUserControl();
            p.Controls[0].Controls.Add(outerVuc);
            outerVuc.Controls.Add(new Control());
            ViewUserControl vuc = new ViewUserControl() { ViewDataKey = "SubData" };
            outerVuc.Controls[0].Controls.Add(vuc);

            p.ViewData = new ViewDataDictionary { { "FirstName", "Joe" }, { "LastName", "Schmoe" } };
            p.ViewData["SubData"] = new ViewDataDictionary { { "FirstName", "SubJoe" }, { "LastName", "SubSchmoe" } };

            // Act
            object firstName = vuc.ViewData.Eval("FirstName");
            object lastName = vuc.ViewData.Eval("LastName");

            // Assert
            Assert.Equal("SubJoe", firstName);
            Assert.Equal("SubSchmoe", lastName);
        }

        [Fact]
        public void GetViewDataFromViewUserControlWithViewDataKeyOnOuterControl()
        {
            // Arrange
            ViewPage p = new ViewPage();
            p.Controls.Add(new Control());
            ViewUserControl outerVuc = new ViewUserControl() { ViewDataKey = "SubData" };
            p.Controls[0].Controls.Add(outerVuc);
            outerVuc.Controls.Add(new Control());
            ViewUserControl vuc = new ViewUserControl();
            outerVuc.Controls[0].Controls.Add(vuc);

            p.ViewData = new ViewDataDictionary { { "FirstName", "Joe" }, { "LastName", "Schmoe" } };
            p.ViewData["SubData"] = new ViewDataDictionary { { "FirstName", "SubJoe" }, { "LastName", "SubSchmoe" } };

            // Act
            object firstName = vuc.ViewData.Eval("FirstName");
            object lastName = vuc.ViewData.Eval("LastName");

            // Assert
            Assert.Equal("SubJoe", firstName);
            Assert.Equal("SubSchmoe", lastName);
        }

        [Fact]
        public void ViewDataKeyProperty()
        {
            MemberHelper.TestStringProperty(new ViewUserControl(), "ViewDataKey", String.Empty, testDefaultValueAttribute: true);
        }

        [Fact]
        public void GetWrongGenericViewItemTypeThrows()
        {
            // Arrange
            ViewPage p = new ViewPage();
            p.ViewData = new ViewDataDictionary();
            p.ViewData["Foo"] = new DummyViewData { MyInt = 123, MyString = "Whatever" };

            MockViewUserControl<MyViewData> vuc = new MockViewUserControl<MyViewData>() { ViewDataKey = "FOO" };
            vuc.AppRelativeVirtualPath = "~/Foo.aspx";
            p.Controls.Add(new Control());
            p.Controls[0].Controls.Add(vuc);

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { var foo = vuc.ViewData.Model.IntProp; },
                @"The model item passed into the dictionary is of type 'System.Web.Mvc.Test.ViewUserControlTest+DummyViewData', but this dictionary requires a model item of type 'System.Web.Mvc.Test.ViewUserControlTest+MyViewData'.");
        }

        [Fact]
        public void GetGenericViewItemType()
        {
            // Arrange
            ViewPage p = new ViewPage();
            p.Controls.Add(new Control());
            MockViewUserControl<MyViewData> vuc = new MockViewUserControl<MyViewData>() { ViewDataKey = "FOO" };
            p.Controls[0].Controls.Add(vuc);
            p.ViewData = new ViewDataDictionary();
            p.ViewData["Foo"] = new MyViewData { IntProp = 123, StringProp = "miao" };

            // Act
            int intProp = vuc.ViewData.Model.IntProp;
            string stringProp = vuc.ViewData.Model.StringProp;

            // Assert
            Assert.Equal(123, intProp);
            Assert.Equal("miao", stringProp);
        }

        [Fact]
        public void GetHtmlHelperFromViewPage()
        {
            // Arrange
            ViewUserControl vuc = new ViewUserControl();
            ViewPage containerPage = new ViewPage();
            containerPage.Controls.Add(vuc);
            ViewContext vc = new Mock<ViewContext>().Object;
            vuc.ViewContext = vc;

            // Act
            HtmlHelper htmlHelper = vuc.Html;

            // Assert
            Assert.Equal(vc, htmlHelper.ViewContext);
            Assert.Equal(vuc, htmlHelper.ViewDataContainer);
        }

        [Fact]
        public void GetHtmlHelperFromRegularPage()
        {
            // Arrange
            ViewUserControl vuc = new ViewUserControl();
            Page containerPage = new Page();
            containerPage.Controls.Add(vuc);

            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { HtmlHelper foo = vuc.Html; },
                "A ViewUserControl can be used only in pages that derive from ViewPage or ViewPage<TModel>.");
        }

        [Fact]
        public void GetUrlHelperFromViewPage()
        {
            // Arrange
            ViewUserControl vuc = new ViewUserControl();
            ViewPage containerPage = new ViewPage();
            containerPage.Controls.Add(vuc);
            RequestContext rc = new RequestContext(new Mock<HttpContextBase>().Object, new RouteData());
            UrlHelper urlHelper = new UrlHelper(rc);
            containerPage.Url = urlHelper;

            // Assert
            Assert.Equal(vuc.Url, urlHelper);
        }

        [Fact]
        public void GetUrlHelperFromRegularPage()
        {
            // Arrange
            ViewUserControl vuc = new ViewUserControl();
            Page containerPage = new Page();
            containerPage.Controls.Add(vuc);

            // Assert
            Assert.Throws<InvalidOperationException>(
                delegate { UrlHelper foo = vuc.Url; },
                "A ViewUserControl can be used only in pages that derive from ViewPage or ViewPage<TModel>.");
        }

        [Fact]
        public void GetWriterFromViewPage()
        {
            // Arrange
            MockViewUserControl vuc = new MockViewUserControl();
            MockViewUserControlContainerPage containerPage = new MockViewUserControlContainerPage(vuc);
            bool triggered = false;
            HtmlTextWriter writer = new HtmlTextWriter(TextWriter.Null);
            containerPage.RenderCallback = delegate()
            {
                triggered = true;
                Assert.Equal(writer, vuc.Writer);
            };

            // Act & Assert
            Assert.Null(vuc.Writer);
            containerPage.RenderControl(writer);
            Assert.Null(vuc.Writer);
            Assert.True(triggered);
        }

        [Fact]
        public void GetWriterFromRegularPageThrows()
        {
            // Arrange
            MockViewUserControl vuc = new MockViewUserControl();
            Page containerPage = new Page();
            containerPage.Controls.Add(vuc);

            // Act
            Assert.Throws<InvalidOperationException>(
                delegate { HtmlTextWriter writer = vuc.Writer; },
                "A ViewUserControl can be used only in pages that derive from ViewPage or ViewPage<TModel>.");
        }

        [Fact]
        public void ViewBagProperty_ReflectsViewData()
        {
            // Arrange
            ViewPage containerPage = new ViewPage();
            ViewUserControl userControl = new ViewUserControl();
            containerPage.Controls.Add(userControl);
            userControl.ViewData["A"] = 1;

            // Act & Assert
            Assert.NotNull(userControl.ViewBag);
            Assert.Equal(1, userControl.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_ReflectsNewViewDataInstance()
        {
            // Arrange
            ViewPage containerPage = new ViewPage();
            ViewUserControl userControl = new ViewUserControl();
            containerPage.Controls.Add(userControl);
            userControl.ViewData["A"] = 1;
            userControl.ViewData = new ViewDataDictionary() { { "A", "bar" } };

            // Act & Assert
            Assert.Equal("bar", userControl.ViewBag.A);
        }

        [Fact]
        public void ViewBagProperty_PropagatesChangesToViewData()
        {
            // Arrange
            ViewPage containerPage = new ViewPage();
            ViewUserControl userControl = new ViewUserControl();
            containerPage.Controls.Add(userControl);
            userControl.ViewData["A"] = 1;

            // Act
            userControl.ViewBag.A = "foo";
            userControl.ViewBag.B = 2;

            // Assert
            Assert.Equal("foo", userControl.ViewData["A"]);
            Assert.Equal(2, userControl.ViewData["B"]);
        }

        private sealed class DummyViewData
        {
            public int MyInt { get; set; }
            public string MyString { get; set; }
        }

        private sealed class MockViewUserControlContainerPage : ViewPage
        {
            public Action RenderCallback { get; set; }

            public MockViewUserControlContainerPage(ViewUserControl userControl)
            {
                Controls.Add(userControl);
            }

            protected override void RenderChildren(HtmlTextWriter writer)
            {
                if (RenderCallback != null)
                {
                    RenderCallback();
                }
                base.RenderChildren(writer);
            }
        }

        private sealed class MockViewUserControl : ViewUserControl
        {
        }

        private sealed class MockViewUserControl<TViewData> : ViewUserControl<TViewData>
        {
        }

        private sealed class MyViewData
        {
            public int IntProp { get; set; }
            public string StringProp { get; set; }
        }

        private sealed class FooModel
        {
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/VirtualPathProviderViewEngineTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.IO;
using System.Linq;
using System.Web.Hosting;
using System.Web.Routing;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class VirtualPathProviderViewEngineTest : IDisposable
    {
        private ControllerContext _context = CreateContext();
        private ControllerContext _mobileContext = CreateContext(isMobileDevice: true);
        private TestableVirtualPathProviderViewEngine _engine = new TestableVirtualPathProviderViewEngine();

        public void Dispose()
        {
            // If any mock failures get reported in this method they might mask other failures that occurred in the main test body.
            // If you are seeing any test failures, try commenting out these lines first to aid in debugging.
            _engine.MockCache.Verify();
            _engine.MockPathProvider.Verify();
        }

        [Fact]
        public void CreateCacheKey_IncludesAssemblyName()
        {
            // Arrange
            var engine = new DerivedVirtualPathProviderViewEngine();

            // Act
            var key = engine.CreateCacheKey("prefix", "viewName", "controllerName", "areaName");

            // Assert
            Assert.Equal(":ViewCacheEntry:System.Web.Mvc.Test.VirtualPathProviderViewEngineTest+DerivedVirtualPathProviderViewEngine, System.Web.Mvc.Test, Version=0.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35:prefix:viewName:controllerName:areaName:", key);
        }

        [Fact]
        public void FindView_NullControllerContext_Throws()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => _engine.FindView(null, "view name", null, false),
                "controllerContext"
                );
        }

        [Theory]
        [InlineData(null)]
        [InlineData("")]
        public void FindView_InvalidViewName_Throws(string viewName)
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => _engine.FindView(_context, viewName, null, false),
                "viewName"
                );
        }

        [Fact]
        public void FindView_ControllerNameNotInRequestContext_Throws()
        {
            // Arrange
            _context.RouteData.Values.Remove("controller");

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => _engine.FindView(_context, "viewName", null, false),
                "The RouteData must contain an item named 'controller' with a non-empty string value."
                );
        }

        [Fact]
        public void FindView_EmptyViewLocations_Throws()
        {
            // Arrange
            _engine.ClearViewLocations();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => _engine.FindView(_context, "viewName", null, false),
                "The property 'ViewLocationFormats' cannot be null or empty."
                );
        }

        [Fact]
        public void FindView_ViewDoesNotExistAndNoMaster_ReturnsSearchedLocationsResult()
        {
            // Arrange
            SetupFileDoesNotExist("~/vpath/controllerName/viewName.view");

            // Act
            ViewEngineResult result = _engine.FindView(_context, "viewName", null, false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal("~/vpath/controllerName/viewName.view", Assert.Single(result.SearchedLocations));
        }

        [Fact]
        public void FindView_ViewExistsAndNoMaster_ReturnsView()
        {
            // Arrange
            _engine.ClearMasterLocations(); // If master is not provided, master locations can be empty

            SetupFileExists("~/vpath/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View), "~/vpath/controllerName/viewName.view");

            SetupFileDoesNotExist("~/vpath/controllerName/viewName.Mobile.view");
            SetupCacheMiss(CreateCacheKey(Cache.View, displayMode: "Mobile"));

            // Act
            ViewEngineResult result = _engine.FindView(_context, "viewName", null, false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal("~/vpath/controllerName/viewName.view", view.Path);
            Assert.Equal(String.Empty, view.MasterPath);
        }

        [Theory]
        [InlineData("~/foo/bar.view")]
        [InlineData("/foo/bar.view")]
        public void FindView_PathViewExistsAndNoMaster_ReturnsView(string path)
        {
            // Arrange
            _engine.ClearMasterLocations();

            SetupFileExists(path);
            SetupCacheHit(CreateCacheBaseKey(Cache.View, path, "", ""), path);

            // Act
            ViewEngineResult result = _engine.FindView(_context, path, null, false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal(path, view.Path);
            Assert.Equal(String.Empty, view.MasterPath);
        }

        [Theory]
        [InlineData("~/foo/bar.unsupported")]
        [InlineData("/foo/bar.unsupported")]
        public void FindView_PathViewExistsAndNoMaster_Legacy_ReturnsView(string path)
        {
            // Arrange
            _engine.FileExtensions = null; // Set FileExtensions to null to simulate View Engines that do not set this property            
            _engine.ClearMasterLocations();

            SetupFileExists(path);
            SetupCacheHit(CreateCacheBaseKey(Cache.View, path, "", ""), path);

            // Act
            ViewEngineResult result = _engine.FindView(_context, path, null, false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal(path, view.Path);
            Assert.Equal(String.Empty, view.MasterPath);
        }

        [Theory]
        [InlineData("~/foo/bar.view")]
        [InlineData("/foo/bar.view")]
        public void FindView_PathViewDoesNotExistAndNoMaster_ReturnsSearchedLocationsResult(string path)
        {
            // Arrange
            SetupFileDoesNotExist(path);
            SetupCacheMiss(CreateCacheBaseKey(Cache.View, path, "", ""));

            // Act
            ViewEngineResult result = _engine.FindView(_context, path, null, false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal(path, Assert.Single(result.SearchedLocations));
        }

        [Theory]
        [InlineData("~/foo/bar.unsupported")]
        [InlineData("/foo/bar.unsupported")]
        public void FindView_PathViewNotSupportedAndNoMaster_ReturnsSearchedLocationsResult(string path)
        {
            // Arrange
            SetupCacheMiss(CreateCacheBaseKey(Cache.View, path, "", ""));

            // Act
            ViewEngineResult result = _engine.FindView(_context, path, null, false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal(path, Assert.Single(result.SearchedLocations));
            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(path), Times.Never());
        }

        [Fact]
        public void FindView_ViewExistsAndMasterNameProvidedButEmptyMasterLocations_Throws()
        {
            // Arrange
            _engine.ClearMasterLocations();
            SetupFileExists("~/vpath/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View), "~/vpath/controllerName/viewName.view");
            SetupFileDoesNotExist("~/vpath/controllerName/viewName.Mobile.view");
            SetupCacheMiss(CreateCacheKey(Cache.View, displayMode: "Mobile"));

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => _engine.FindView(_context, "viewName", "masterName", false),
                "The property 'MasterLocationFormats' cannot be null or empty."
                );
        }

        [Fact]
        public void FindView_ViewDoesNotExistAndMasterDoesNotExist_ReturnsSearchedLocationsResult()
        {
            // Arrange
            SetupFileDoesNotExist("~/vpath/controllerName/viewName.view");
            SetupFileDoesNotExist("~/vpath/controllerName/masterName.master");

            // Act
            ViewEngineResult result = _engine.FindView(_context, "viewName", "masterName", false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal(2, result.SearchedLocations.Count()); // Both view and master locations
            Assert.Contains("~/vpath/controllerName/viewName.view", result.SearchedLocations);
            Assert.Contains("~/vpath/controllerName/masterName.master", result.SearchedLocations);
        }

        [Fact]
        public void FindView_ViewExistsButMasterDoesNotExist_ReturnsSearchedLocationsResult()
        {
            // Arrange
            SetupFileExists("~/vpath/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View), "~/vpath/controllerName/viewName.view");

            SetupFileDoesNotExist("~/vpath/controllerName/viewName.Mobile.view");
            SetupCacheMiss(CreateCacheKey(Cache.View, displayMode: "Mobile"));

            SetupFileDoesNotExist("~/vpath/controllerName/masterName.master");

            // Act
            ViewEngineResult result = _engine.FindView(_context, "viewName", "masterName", false);

            // Assert
            Assert.Null(result.View);
            // View was found, not included in 'searched locations'
            Assert.Equal("~/vpath/controllerName/masterName.master", Assert.Single(result.SearchedLocations));
        }

        [Fact]
        public void FindView_MasterInAreaDoesNotExist_ReturnsSearchedLocationsResult()
        {
            // Arrange
            _context.RouteData.DataTokens["area"] = "areaName";
            SetupFileExists("~/vpath/areaName/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View, area: "areaName"), "~/vpath/areaName/controllerName/viewName.view");

            SetupFileDoesNotExist("~/vpath/areaName/controllerName/viewName.Mobile.view");
            SetupCacheMiss(CreateCacheKey(Cache.View, area: "areaName", displayMode: "Mobile"));

            SetupFileDoesNotExist("~/vpath/areaName/controllerName/masterName.master");
            SetupFileDoesNotExist("~/vpath/controllerName/masterName.master");

            // Act
            ViewEngineResult result = _engine.FindView(_context, "viewName", "masterName", false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal(2, result.SearchedLocations.Count()); // View was found, not included in 'searched locations'
            Assert.Contains("~/vpath/areaName/controllerName/masterName.master", result.SearchedLocations);
            Assert.Contains("~/vpath/controllerName/masterName.master", result.SearchedLocations);
        }

        [Fact]
        public void FindView_ViewExistsAndMasterExists_ReturnsView()
        {
            // Arrange
            SetupFileExists("~/vpath/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View), "~/vpath/controllerName/viewName.view");

            SetupFileDoesNotExist("~/vpath/controllerName/viewName.Mobile.view");
            SetupCacheMiss(CreateCacheKey(Cache.View, displayMode: "Mobile"));

            SetupFileExists("~/vpath/controllerName/masterName.master");
            SetupCacheHit(CreateCacheKey(Cache.Master), "~/vpath/controllerName/masterName.master");

            SetupFileDoesNotExist("~/vpath/controllerName/masterName.Mobile.master");
            SetupCacheMiss(CreateCacheKey(Cache.Master, displayMode: "Mobile"));

            // Act
            ViewEngineResult result = _engine.FindView(_context, "viewName", "masterName", false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal("~/vpath/controllerName/viewName.view", view.Path);
            Assert.Equal("~/vpath/controllerName/masterName.master", view.MasterPath);
        }

        [Fact]
        public void FindView_ViewInAreaExistsAndMasterExists_ReturnsView()
        {
            // Arrange
            _context.RouteData.DataTokens["area"] = "areaName";
            SetupFileExists("~/vpath/areaName/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View, area: "areaName"), "~/vpath/areaName/controllerName/viewName.view");

            SetupFileDoesNotExist("~/vpath/areaName/controllerName/viewName.Mobile.view");
            SetupCacheMiss(CreateCacheKey(Cache.View, area: "areaName", displayMode: "Mobile"));

            SetupFileDoesNotExist("~/vpath/areaName/controllerName/masterName.master");

            SetupFileExists("~/vpath/controllerName/masterName.master");
            SetupCacheHit(CreateCacheKey(Cache.Master, area: "areaName"), "~/vpath/controllerName/masterName.master");

            SetupFileDoesNotExist("~/vpath/controllerName/masterName.Mobile.master");
            SetupCacheMiss(CreateCacheKey(Cache.Master, area: "areaName", displayMode: "Mobile"));


            // Act
            ViewEngineResult result = _engine.FindView(_context, "viewName", "masterName", false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal("~/vpath/areaName/controllerName/viewName.view", view.Path);
            Assert.Equal("~/vpath/controllerName/masterName.master", view.MasterPath);
        }

        [Fact]
        public void FindView_ViewInAreaExistsAndMasterExists_ReturnsView_Mobile()
        {
            // Arrange
            _mobileContext.RouteData.DataTokens["area"] = "areaName";
            SetupFileExists("~/vpath/areaName/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View, area: "areaName"), "~/vpath/areaName/controllerName/viewName.view");

            SetupFileExists("~/vpath/areaName/controllerName/viewName.Mobile.view");
            SetupCacheHit(CreateCacheKey(Cache.View, area: "areaName", displayMode: "Mobile"), "~/vpath/areaName/controllerName/viewName.Mobile.view");

            SetupFileDoesNotExist("~/vpath/areaName/controllerName/masterName.master");
            SetupFileDoesNotExist("~/vpath/areaName/controllerName/masterName.Mobile.master");

            SetupFileExists("~/vpath/controllerName/masterName.master");
            SetupCacheHit(CreateCacheKey(Cache.Master, area: "areaName"), "~/vpath/controllerName/masterName.master");

            SetupFileExists("~/vpath/controllerName/masterName.Mobile.master");
            SetupCacheHit(CreateCacheKey(Cache.Master, area: "areaName", displayMode: "Mobile"), "~/vpath/controllerName/masterName.Mobile.master");

            // Act
            ViewEngineResult result = _engine.FindView(_mobileContext, "viewName", "masterName", false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_mobileContext, view.ControllerContext);
            Assert.Equal("~/vpath/areaName/controllerName/viewName.Mobile.view", view.Path);
            Assert.Equal("~/vpath/controllerName/masterName.Mobile.master", view.MasterPath);
        }

        [Fact]
        public void FindPartialView_NullControllerContext_Throws()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => _engine.FindPartialView(null, "view name", false),
                "controllerContext"
                );
        }

        [Theory]
        [InlineData(null)]
        [InlineData("")]
        public void FindPartialView_InvalidPartialViewName_Throws(string partialViewName)
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => _engine.FindPartialView(_context, partialViewName, false),
                "partialViewName"
                );
        }

        [Fact]
        public void FindPartialView_ControllerNameNotInRequestContext_Throws()
        {
            // Arrange
            _context.RouteData.Values.Remove("controller");

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => _engine.FindPartialView(_context, "partialName", false),
                "The RouteData must contain an item named 'controller' with a non-empty string value."
                );
        }

        [Fact]
        public void FindPartialView_EmptyPartialViewLocations_Throws()
        {
            // Arrange
            _engine.ClearPartialViewLocations();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => _engine.FindPartialView(_context, "partialName", false),
                "The property 'PartialViewLocationFormats' cannot be null or empty."
                );
        }

        [Fact]
        public void FindPartialView_ViewDoesNotExist_ReturnsSearchLocationsResult()
        {
            // Arrange
            SetupFileDoesNotExist("~/vpath/controllerName/partialName.partial");

            // Act
            ViewEngineResult result = _engine.FindPartialView(_context, "partialName", false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal("~/vpath/controllerName/partialName.partial", Assert.Single(result.SearchedLocations));
        }

        [Fact]
        public void FindPartialView_ViewExists_ReturnsView()
        {
            // Arrange
            SetupFileExists("~/vpath/controllerName/partialName.partial");
            SetupCacheHit(CreateCacheKey(Cache.Partial), "~/vpath/controllerName/partialName.partial");

            SetupFileDoesNotExist("~/vpath/controllerName/partialName.Mobile.partial");
            SetupCacheMiss(CreateCacheKey(Cache.Partial, displayMode: "Mobile"));

            // Act
            ViewEngineResult result = _engine.FindPartialView(_context, "partialName", false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal("~/vpath/controllerName/partialName.partial", view.Path);
        }

        [Theory]
        [InlineData("~/foo/bar.partial")]
        [InlineData("/foo/bar.partial")]
        public void FindPartialView_PathViewExists_ReturnsView(string path)
        {
            // Arrange
            SetupFileExists(path);
            SetupCacheHit(CreateCacheBaseKey(Cache.Partial, path, "", ""), path);

            // Act
            ViewEngineResult result = _engine.FindPartialView(_context, path, false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal(path, view.Path);
        }

        [Theory]
        [InlineData("/foo/bar.unsupported")]
        [InlineData("~/foo/bar.unsupported")]
        public void FindPartialView_PathViewExists_Legacy_ReturnsView(string path)
        {
            // Arrange
            _engine.FileExtensions = null; // Set FileExtensions to null to simulate View Engines that do not set this property
            SetupFileExists(path);
            SetupCacheHit(CreateCacheBaseKey(Cache.Partial, path, "", ""), path);

            // Act
            ViewEngineResult result = _engine.FindPartialView(_context, path, false);

            // Assert
            TestView view = Assert.IsType<TestView>(result.View);
            Assert.Null(result.SearchedLocations);
            Assert.Same(_context, view.ControllerContext);
            Assert.Equal(path, view.Path);
        }

        [Theory]
        [InlineData("~/foo/bar.partial")]
        [InlineData("/foo/bar.partial")]
        public void FindPartialView_PathViewDoesNotExist_ReturnsSearchedLocationsResult(string path)
        {
            // Arrange
            SetupFileDoesNotExist(path);
            SetupCacheMiss(CreateCacheBaseKey(Cache.Partial, path, "", ""));

            // Act
            ViewEngineResult result = _engine.FindPartialView(_context, path, false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal(path, Assert.Single(result.SearchedLocations));
        }

        [Theory]
        [InlineData("~/foo/bar.unsupported")]
        [InlineData("/foo/bar.unsupported")]
        public void FindPartialView_PathViewNotSupported_ReturnsSearchedLocationsResult(string path)
        {
            // Arrange
            SetupCacheMiss(CreateCacheBaseKey(Cache.Partial, path, "", ""));

            // Act
            ViewEngineResult result = _engine.FindPartialView(_context, path, false);

            // Assert
            Assert.Null(result.View);
            Assert.Equal(path, Assert.Single(result.SearchedLocations));
            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(path), Times.Never());
        }

        [Fact]
        public void FileExtensions()
        {
            // Arrange + Assert
            Assert.Null(new Mock<VirtualPathProviderViewEngine>().Object.FileExtensions);
        }

        [Fact]
        public void GetExtensionThunk()
        {
            // Arrange and Assert
            Assert.Equal(VirtualPathUtility.GetExtension, new Mock<VirtualPathProviderViewEngine>().Object.GetExtensionThunk);
        }

        [Fact]
        public void DisplayModeSetOncePerRequest()
        {
            // Arrange
            SetupFileExists("~/vpath/controllerName/viewName.view");
            SetupCacheHit(CreateCacheKey(Cache.View), "~/vpath/controllerName/viewName.view");

            SetupFileDoesNotExist("~/vpath/controllerName/viewName.Mobile.view");
            SetupCacheMiss(CreateCacheKey(Cache.View, displayMode: "Mobile"));

            SetupFileDoesNotExist("~/vpath/controllerName/partialName.partial");
            SetupCacheMiss(CreateCacheKey(Cache.Partial));

            SetupFileExists("~/vpath/controllerName/partialName.Mobile.partial");
            _engine.MockCache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), "~/vpath/controllerName/partialName.Mobile.partial"))
                .Callback<HttpContextBase, string, string>((httpContext, key, virtualPath) =>
                {
                    _engine.MockCache
                        .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), key))
                        .Returns("~/vpath/controllerName/partialName.Mobile.partial")
                        .Verifiable();
                })
                .Verifiable();

            // Act
            ViewEngineResult viewResult = _engine.FindView(_mobileContext, "viewName", masterName: null, useCache: false);

            // Mobile display mode will be used to locate the view with and without the cache.
            // In neither case should this set the DisplayModeId to Mobile because it has already been set.
            ViewEngineResult partialResult = _engine.FindPartialView(_mobileContext, "partialName", useCache: false);
            ViewEngineResult cachedPartialResult = _engine.FindPartialView(_mobileContext, "partialName", useCache: true);

            // Assert

            Assert.Equal(DisplayModeProvider.DefaultDisplayModeId, _mobileContext.DisplayMode.DisplayModeId);
        }

        // The core caching scenarios are covered in the FindView/FindPartialView tests. These
        // extra tests deal with the cache itself, rather than specifics around finding views.

        private const string MASTER_VIRTUAL = "~/vpath/controllerName/name.master";
        private const string PARTIAL_VIRTUAL = "~/vpath/controllerName/name.partial";
        private const string VIEW_VIRTUAL = "~/vpath/controllerName/name.view";
        private const string MOBILE_VIEW_VIRTUAL = "~/vpath/controllerName/name.Mobile.view";

        [Fact]
        public void UsesDifferentKeysForViewMasterAndPartial()
        {
            string keyMaster = null;
            string keyPartial = null;
            string keyView = null;

            // Arrange
            SetupFileExists(VIEW_VIRTUAL);
            SetupFileDoesNotExist(MOBILE_VIEW_VIRTUAL);
            SetupCacheMiss(CreateCacheKey(Cache.View, name: "name", displayMode: "Mobile"));
            SetupFileExists(MASTER_VIRTUAL);
            SetupFileDoesNotExist("~/vpath/controllerName/name.Mobile.master");
            SetupCacheMiss(CreateCacheKey(Cache.Master, name: "name", displayMode: "Mobile"));
            SetupFileExists(PARTIAL_VIRTUAL);
            SetupFileDoesNotExist("~/vpath/controllerName/name.Mobile.partial");
            SetupCacheMiss(CreateCacheKey(Cache.Partial, name: "name", displayMode: "Mobile"));
            _engine.MockCache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), VIEW_VIRTUAL))
                .Callback<HttpContextBase, string, string>((httpContext, key, path) => keyView = key)
                .Verifiable();
            _engine.MockCache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), MASTER_VIRTUAL))
                .Callback<HttpContextBase, string, string>((httpContext, key, path) => keyMaster = key)
                .Verifiable();
            _engine.MockCache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), PARTIAL_VIRTUAL))
                .Callback<HttpContextBase, string, string>((httpContext, key, path) => keyPartial = key)
                .Verifiable();

            // Act
            _engine.FindView(_context, "name", "name", false);
            _engine.FindPartialView(_context, "name", false);

            // Assert
            Assert.NotNull(keyMaster);
            Assert.NotNull(keyPartial);
            Assert.NotNull(keyView);
            Assert.NotEqual(keyMaster, keyPartial);
            Assert.NotEqual(keyMaster, keyView);
            Assert.NotEqual(keyPartial, keyView);
            _engine.MockPathProvider
                .Verify(vpp => vpp.FileExists(VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockPathProvider
                .Verify(vpp => vpp.FileExists(MASTER_VIRTUAL), Times.AtMostOnce());
            _engine.MockPathProvider
                .Verify(vpp => vpp.FileExists(PARTIAL_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache
                .Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache
                .Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), MASTER_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache
                .Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), PARTIAL_VIRTUAL), Times.AtMostOnce());
        }

        // This tests the protocol involved with two calls to FindView for the same view name
        // where the request succeeds. The calls happen in this order:
        //
        //    FindView("view")
        //      Cache.GetViewLocation(key for "view") -> returns null (not found)
        //      VirtualPathProvider.FileExists(virtual path for "view") -> returns true
        //      Cache.InsertViewLocation(key for "view", virtual path for "view")
        //    FindView("view")
        //      Cache.GetViewLocation(key for "view") -> returns virtual path for "view"
        //
        // The mocking code is written as it is because we don't want to make any assumptions
        // about the format of the cache key. So we intercept the first call to Cache.GetViewLocation and
        // take the key they gave us to set up the rest of the mock expectations.
        // The ViewCollection class will typically place to successive calls to FindView and FindPartialView and
        // set the useCache parameter to true/false respectively. To simulate this, both calls to FindView are executed
        // with useCache set to true. This mimics the behavior of always going to the cache first and after finding a
        // view, ensuring that subsequent calls from the cache are successful.

        [Fact]
        public void ValueInCacheBypassesVirtualPathProvider()
        {
            // Arrange
            string cacheKey = null;

            SetupFileExists(VIEW_VIRTUAL); // It wasn't found, so they call vpp.FileExists
            SetupFileDoesNotExist(MOBILE_VIEW_VIRTUAL);
            SetupCacheMiss(CreateCacheKey(Cache.View, name: "name", displayMode: "Mobile"));
            _engine.MockCache // Then they set the value into the cache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), VIEW_VIRTUAL))
                .Callback<HttpContextBase, string, string>((httpContext, key, virtualPath) =>
                {
                    cacheKey = key;
                    _engine.MockCache // Second time through, we give them a cache hit
                        .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), key))
                        .Returns(VIEW_VIRTUAL)
                        .Verifiable();
                })
                .Verifiable();

            // Act
            _engine.FindView(_context, "name", null, false); // Call it once with false to seed the cache
            _engine.FindView(_context, "name", null, true); // Call it once with true to check the cache

            // Assert

            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache.Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache.Verify(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), cacheKey), Times.AtMostOnce());

            // We seed the cache with all possible display modes but since the mobile view does not exist we don't insert it into the cache.
            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(MOBILE_VIEW_VIRTUAL), Times.Exactly(1));
            _engine.MockCache.Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), MOBILE_VIEW_VIRTUAL), Times.Never());
            _engine.MockCache.Verify(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), VirtualPathProviderViewEngine.AppendDisplayModeToCacheKey(cacheKey, DisplayModeProvider.MobileDisplayModeId)), Times.Never());
        }

        [Fact]
        public void ValueInCacheBypassesVirtualPathProviderForAllAvailableDisplayModesForContext()
        {
            // Arrange
            string cacheKey = null;
            string mobileCacheKey = null;

            SetupFileExists(VIEW_VIRTUAL);
            SetupFileExists(MOBILE_VIEW_VIRTUAL);

            _engine.MockCache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), VIEW_VIRTUAL))
                .Callback<HttpContextBase, string, string>((httpContext, key, virtualPath) =>
                {
                    cacheKey = key;
                    _engine.MockCache
                        .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), key))
                        .Returns(MOBILE_VIEW_VIRTUAL)
                        .Verifiable();
                })
                .Verifiable();
            _engine.MockCache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), MOBILE_VIEW_VIRTUAL))
                .Callback<HttpContextBase, string, string>((httpContext, key, virtualPath) =>
                {
                    mobileCacheKey = key;
                    _engine.MockCache
                        .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), key))
                        .Returns(MOBILE_VIEW_VIRTUAL)
                        .Verifiable();
                })
                .Verifiable();

            // Act
            _engine.FindView(_mobileContext, "name", null, false);
            _engine.FindView(_mobileContext, "name", null, true);

            // Assert

            // DefaultDisplayMode with Mobile substitution is cached and hit on the second call to FindView
            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(MOBILE_VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache.Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), MOBILE_VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache.Verify(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), VirtualPathProviderViewEngine.AppendDisplayModeToCacheKey(cacheKey, DisplayModeProvider.MobileDisplayModeId)), Times.AtMostOnce());

            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache.Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), VIEW_VIRTUAL), Times.Exactly(1));

            Assert.NotEqual(cacheKey, mobileCacheKey);

            // Act
            _engine.FindView(_context, "name", null, true);

            // Assert

            // The first call to FindView without a mobile browser results in a cache hit
            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(VIEW_VIRTUAL), Times.AtMostOnce());
            _engine.MockCache.Verify(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>(), VIEW_VIRTUAL), Times.Exactly(1));
            _engine.MockCache.Verify(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), cacheKey), Times.Exactly(1));
        }

        [Fact]
        public void NoValueInCacheButFileExists_ReturnsNullIfUsingCache()
        {
            // Arrange
            string mobileKey = CreateCacheKey(Cache.View, name: "name", displayMode: "Mobile");
            _engine.MockCache
                .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), mobileKey))
                .Returns((string)null)
                .Verifiable();

            // Act
            IView viewNotInCache = _engine.FindView(_mobileContext, "name", masterName: null, useCache: true).View;

            // Assert
            Assert.Null(viewNotInCache);

            // On a cache miss we should never check the file system. FindView will be called on a second pass
            // without using the cache.
            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(MOBILE_VIEW_VIRTUAL), Times.Never());
            _engine.MockPathProvider.Verify(vpp => vpp.FileExists(VIEW_VIRTUAL), Times.Never());

            SetupFileExists(MOBILE_VIEW_VIRTUAL);
            SetupCacheHit(CreateCacheKey(Cache.View, name: "name", displayMode: "Mobile"), MOBILE_VIEW_VIRTUAL);
            SetupFileExists(VIEW_VIRTUAL);
            SetupCacheHit(CreateCacheKey(Cache.View, name: "name"), VIEW_VIRTUAL);

            // Act & Assert
            ViewEngineResult result = _engine.FindView(_mobileContext, "name", masterName: null, useCache: false);
            //At this point the view on disk should be found and cached.
            var view = Assert.IsType<TestView>(result.View);
            Assert.Equal(MOBILE_VIEW_VIRTUAL, view.Path);
        }

        [Fact]
        public void NoValueInCacheAndFileDoesNotExist_ReturnsNullIfUsingCache()
        {
            // Arrange
            string mobileKey = CreateCacheKey(Cache.View, name: "name", displayMode: "Mobile");
            _engine.MockCache
                .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), mobileKey))
                .Returns("")
                .Verifiable();
            string desktopKey = CreateCacheKey(Cache.View, name: "name");
            _engine.MockCache
                .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), desktopKey))
                .Returns("")
                .Verifiable();

            // Act
            IView viewNotInCache = _engine.FindView(_mobileContext, "name", masterName: null, useCache: true).View;

            // Assert
            Assert.Null(viewNotInCache);
        }

        [Fact]
        public void ReleaseViewCallsDispose()
        {
            // Arrange
            IView view = new TestView();

            // Act
            _engine.ReleaseView(_context, view);

            // Assert
            Assert.True(((TestView)view).Disposed);
        }

        [Fact]
        public void ViewLocationCache_RoundTrips()
        {
            // Arrange & Act
            IViewLocationCache locationCache = _engine.ViewLocationCache;

            // Assert
            Assert.NotNull(locationCache);
            Assert.Equal(_engine.MockCache.Object, _engine.ViewLocationCache);
        }

        [Fact]
        public void ViewLocationCache_DefaultNullCache()
        {
            // Arrange
            Mock<VirtualPathProviderViewEngine> engineMock = new Mock<VirtualPathProviderViewEngine>();
            VirtualPathProviderViewEngine engine = engineMock.Object;

            // Act
            IViewLocationCache cache = engine.ViewLocationCache;

            // Assert
            Assert.NotNull(cache);
            Assert.Equal(DefaultViewLocationCache.Null, cache);
            Assert.IsNotType<DefaultViewLocationCache>(cache);
        }

        [Fact]
        public void ViewLocationCache_DefaultRealCache()
        {
            // Arrange
            Mock<VirtualPathProviderViewEngine> engineMock = new Mock<VirtualPathProviderViewEngine>();
            VirtualPathProviderViewEngine engine = engineMock.Object;

            HttpRequest request = new HttpRequest("foo.txt", "http://localhost", String.Empty);
            HttpResponse response = new HttpResponse(TextWriter.Null);
            HttpContext context = new HttpContext(request, response);
            HttpContext savedContext = HttpContext.Current;

            // Act
            IViewLocationCache cache;
            try
            {
                HttpContext.Current = context;
                cache = engine.ViewLocationCache;
            }
            finally
            {
                HttpContext.Current = savedContext;
            }

            // Assert
            Assert.NotNull(cache);
            Assert.IsType<DefaultViewLocationCache>(cache);
        }

        [Fact]
        public void VirtualPathProvider_RoundTrips()
        {
            // Arrange & Act & Assert
            Assert.Equal(_engine.MockPathProvider.Object, _engine.VirtualPathProvider);
        }

        // Not a valid production scenario -- no HostingEnvironment
        [Fact]
        public void VirtualPathProvider_Null()
        {
            // Arrange
            TestableVirtualPathProviderViewEngine viewEngine =
                new TestableVirtualPathProviderViewEngine(skipVPPInitialization: true);

            // Act & Assert
            Assert.Null(viewEngine.VirtualPathProvider);
        }

        [Fact]
        public void VirtualPathProvider_VPPRegistrationChanging()
        {
            // Arrange
            Mock<VirtualPathProvider> provider1 = new Mock<VirtualPathProvider>(MockBehavior.Strict);
            Mock<VirtualPathProvider> provider2 = new Mock<VirtualPathProvider>(MockBehavior.Strict);
            VirtualPathProvider provider = provider1.Object;

            // Act
            TestableVirtualPathProviderViewEngine viewEngine =
                new TestableVirtualPathProviderViewEngine(skipVPPInitialization: true)
            {
                VirtualPathProviderFunc = () => provider,
            };

            // The moral equivalent of HostingEnvironment.RegisterVirtualPathProvider(provider2.Object)
            provider = provider2.Object;

            // Assert
            Assert.Equal(provider2.Object, viewEngine.VirtualPathProvider);
            provider1.Verify();
            provider2.Verify();
        }

        [Fact]
        public void FileExists_VPPRegistrationChanging()
        {
            // Arrange
            Mock<VirtualPathProvider> provider1 = new Mock<VirtualPathProvider>(MockBehavior.Strict);
            provider1.Setup(vpp => vpp.FileExists(It.IsAny<string>())).Returns(true);
            Mock<VirtualPathProvider> provider2 = new Mock<VirtualPathProvider>(MockBehavior.Strict);
            provider2.Setup(vpp => vpp.FileExists(It.IsAny<string>())).Returns(true);
            VirtualPathProvider provider = provider1.Object;

            string path = "~/Index.cshtml";
            ControllerContext context = CreateContext();
            TestableVirtualPathProviderViewEngine viewEngine =
                new TestableVirtualPathProviderViewEngine(skipVPPInitialization: true)
            {
                VirtualPathProviderFunc = () => provider,
            };

            // Act
            bool fileExists1 = viewEngine.FileExists(context, path);

            // The moral equivalent of HostingEnvironment.RegisterVirtualPathProvider(provider2.Object)
            provider = provider2.Object;

            bool fileExists2 = viewEngine.FileExists(context, path);

            // Assert
            Assert.True(fileExists1);
            provider1.Verify(vpp => vpp.FileExists(path), Times.Once());
            Assert.True(fileExists2);
            provider2.Verify(vpp => vpp.FileExists(path), Times.Once());
        }

        private static string CreateCacheBaseKey(string prefix, string name, string controllerName, string area)
        {
            var r = String.Join(":", prefix, name, controllerName, area) + ":";
            return r;
        }

        private static string CreateCacheKey(Cache prefix, string name = null, string controller = "controllerName", string area = "", string displayMode = "")
        {
            if (name == null)
            {
                name = prefix.ToString().ToLowerInvariant() + "Name";
            }
            var r = CreateCacheBaseKey(prefix, name, controller, area) + displayMode + ":";
            return r;
        }

        private static ControllerContext CreateContext(bool isMobileDevice = false)
        {
            RouteData routeData = new RouteData();
            routeData.Values["controller"] = "controllerName";
            routeData.Values["action"] = "actionName";

            Mock<ControllerContext> mockControllerContext = new Mock<ControllerContext>();
            mockControllerContext.Setup(c => c.HttpContext.Request.Browser.IsMobileDevice).Returns(isMobileDevice);
            mockControllerContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            mockControllerContext.Setup(c => c.RouteData).Returns(routeData);

            mockControllerContext.Setup(c => c.HttpContext.Response.Cookies).Returns(new HttpCookieCollection());
            mockControllerContext.Setup(c => c.HttpContext.Request.Cookies).Returns(new HttpCookieCollection());

            return mockControllerContext.Object;
        }

        private void SetupFileExists(string path)
        {
            SetupFileExistsHelper(path, exists: true);
        }

        private void SetupFileDoesNotExist(string path)
        {
            SetupFileExistsHelper(path, exists: false);
        }

        private void SetupCacheHit(string key, string path)
        {
            _engine.MockCache
                .Setup(c => c.InsertViewLocation(It.IsAny<HttpContextBase>(), key, path))
                .Verifiable();
        }

        private void SetupCacheMiss(string key)
        {
            SetupCacheHit(key, "");
        }

        private void SetupFileExistsHelper(string path, bool exists)
        {
            _engine.MockPathProvider.Setup(vpp => vpp.FileExists(path)).Returns(exists).Verifiable();
        }

        private class Cache
        {
            private string _value;

            private Cache(string value)
            {
                _value = value;
            }

            public static Cache View = new Cache("View");
            public static Cache Partial = new Cache("Partial");
            public static Cache Master = new Cache("Master");

            public override string ToString()
            {
                return _value;
            }

            public static implicit operator string(Cache c)
            {
                return c.ToString();
            }
        }

        private class TestView : IView, IDisposable
        {
            public bool Disposed { get; set; }
            public ControllerContext ControllerContext { get; set; }
            public string Path { get; set; }
            public string MasterPath { get; set; }

            void IDisposable.Dispose()
            {
                Disposed = true;
            }

            void IView.Render(ViewContext viewContext, TextWriter writer)
            {
            }
        }

        private class TestableVirtualPathProviderViewEngine : VirtualPathProviderViewEngine
        {
            public Mock<IViewLocationCache> MockCache = new Mock<IViewLocationCache>(MockBehavior.Strict);
            public Mock<VirtualPathProvider> MockPathProvider = new Mock<VirtualPathProvider>(MockBehavior.Strict);

            public TestableVirtualPathProviderViewEngine()
                : this(skipVPPInitialization: false)
            {
            }

            public TestableVirtualPathProviderViewEngine(bool skipVPPInitialization)
            {
                MasterLocationFormats = new[] { "~/vpath/{1}/{0}.master" };
                ViewLocationFormats = new[] { "~/vpath/{1}/{0}.view" };
                PartialViewLocationFormats = new[] { "~/vpath/{1}/{0}.partial" };
                AreaMasterLocationFormats = new[] { "~/vpath/{2}/{1}/{0}.master" };
                AreaViewLocationFormats = new[] { "~/vpath/{2}/{1}/{0}.view" };
                AreaPartialViewLocationFormats = new[] { "~/vpath/{2}/{1}/{0}.partial" };
                FileExtensions = new[] { "view", "partial", "master" };

                ViewLocationCache = MockCache.Object;
                MockCache
                    .Setup(c => c.GetViewLocation(It.IsAny<HttpContextBase>(), It.IsAny<string>()))
                    .Returns((string)null);

                if (!skipVPPInitialization)
                {
                    VirtualPathProvider = MockPathProvider.Object;
                }

                GetExtensionThunk = GetExtension;
            }

            public new VirtualPathProvider VirtualPathProvider
            {
                get
                {
                    return base.VirtualPathProvider;
                }
                private set
                {
                    base.VirtualPathProvider = value;
                }
            }

            public void ClearViewLocations()
            {
                ViewLocationFormats = new string[0];
            }

            public void ClearMasterLocations()
            {
                MasterLocationFormats = new string[0];
            }

            public void ClearPartialViewLocations()
            {
                PartialViewLocationFormats = new string[0];
            }

            public new bool FileExists(ControllerContext controllerContext, string virtualPath)
            {
                return base.FileExists(controllerContext, virtualPath);
            }

            protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
            {
                return new TestView() { ControllerContext = controllerContext, Path = partialPath };
            }

            protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
            {
                return new TestView() { ControllerContext = controllerContext, Path = viewPath, MasterPath = masterPath };
            }

            internal override string CreateCacheKey(string prefix, string name, string controllerName, string areaName)
            {
                return VirtualPathProviderViewEngineTest.CreateCacheBaseKey(prefix, name, controllerName, areaName);
            }

            private static string GetExtension(string virtualPath)
            {
                var extension = virtualPath.Substring(virtualPath.LastIndexOf('.'));
                return extension;
            }
        }

        public class DerivedVirtualPathProviderViewEngine : VirtualPathProviderViewEngine
        {
            protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
            {
                throw new NotImplementedException();
            }

            protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/WebFormViewEngineTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Hosting;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class WebFormViewEngineTest
    {
        [Fact]
        public void CreatePartialViewCreatesWebFormView()
        {
            // Arrange
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Act
            WebFormView result = (WebFormView)engine.CreatePartialView("partial path");

            // Assert
            Assert.Equal("partial path", result.ViewPath);
            Assert.Equal(String.Empty, result.MasterPath);
        }

        [Fact]
        public void CreateViewCreatesWebFormView()
        {
            // Arrange
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Act
            WebFormView result = (WebFormView)engine.CreateView("view path", "master path");

            // Assert
            Assert.Equal("view path", result.ViewPath);
            Assert.Equal("master path", result.MasterPath);
        }

        [Fact]
        public void WebFormViewEngineSetsViewPageActivator()
        {
            // Arrange
            Mock<IViewPageActivator> viewPageActivator = new Mock<IViewPageActivator>();
            TestableWebFormViewEngine viewEngine = new TestableWebFormViewEngine(viewPageActivator.Object);

            //Act & Assert
            Assert.Equal(viewPageActivator.Object, viewEngine.ViewPageActivator);
        }

        [Fact]
        public void CreatePartialView_PassesViewPageActivator()
        {
            // Arrange
            Mock<IViewPageActivator> viewPageActivator = new Mock<IViewPageActivator>();
            TestableWebFormViewEngine viewEngine = new TestableWebFormViewEngine(viewPageActivator.Object);

            // Act
            WebFormView result = (WebFormView)viewEngine.CreatePartialView("partial path");

            // Assert
            Assert.Equal(viewEngine.ViewPageActivator, result.ViewPageActivator);
        }

        [Fact]
        public void CreateView_PassesViewPageActivator()
        {
            // Arrange
            Mock<IViewPageActivator> viewPageActivator = new Mock<IViewPageActivator>();
            TestableWebFormViewEngine viewEngine = new TestableWebFormViewEngine(viewPageActivator.Object);

            // Act
            WebFormView result = (WebFormView)viewEngine.CreateView("partial path", "master path");

            // Assert
            Assert.Equal(viewEngine.ViewPageActivator, result.ViewPageActivator);
        }

        [Fact]
        public void MasterLocationFormatsProperty()
        {
            // Arrange
            string[] expected = new string[]
            {
                "~/Views/{1}/{0}.master",
                "~/Views/Shared/{0}.master"
            };

            // Act
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Assert
            Assert.Equal(expected, engine.MasterLocationFormats);
        }

        [Fact]
        public void AreaMasterLocationFormatsProperty()
        {
            // Arrange
            string[] expected = new string[]
            {
                "~/Areas/{2}/Views/{1}/{0}.master",
                "~/Areas/{2}/Views/Shared/{0}.master",
            };

            // Act
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Assert
            Assert.Equal(expected, engine.AreaMasterLocationFormats);
        }

        [Fact]
        public void PartialViewLocationFormatsProperty()
        {
            // Arrange
            string[] expected = new string[]
            {
                "~/Views/{1}/{0}.aspx",
                "~/Views/{1}/{0}.ascx",
                "~/Views/Shared/{0}.aspx",
                "~/Views/Shared/{0}.ascx"
            };

            // Act
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Assert
            Assert.Equal(expected, engine.PartialViewLocationFormats);
        }

        [Fact]
        public void AreaPartialViewLocationFormatsProperty()
        {
            // Arrange
            string[] expected = new string[]
            {
                "~/Areas/{2}/Views/{1}/{0}.aspx",
                "~/Areas/{2}/Views/{1}/{0}.ascx",
                "~/Areas/{2}/Views/Shared/{0}.aspx",
                "~/Areas/{2}/Views/Shared/{0}.ascx",
            };

            // Act
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Assert
            Assert.Equal(expected, engine.AreaPartialViewLocationFormats);
        }

        [Fact]
        public void ViewLocationFormatsProperty()
        {
            // Arrange
            string[] expected = new string[]
            {
                "~/Views/{1}/{0}.aspx",
                "~/Views/{1}/{0}.ascx",
                "~/Views/Shared/{0}.aspx",
                "~/Views/Shared/{0}.ascx"
            };

            // Act
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Assert
            Assert.Equal(expected, engine.ViewLocationFormats);
        }

        [Fact]
        public void AreaViewLocationFormatsProperty()
        {
            // Arrange
            string[] expected = new string[]
            {
                "~/Areas/{2}/Views/{1}/{0}.aspx",
                "~/Areas/{2}/Views/{1}/{0}.ascx",
                "~/Areas/{2}/Views/Shared/{0}.aspx",
                "~/Areas/{2}/Views/Shared/{0}.ascx",
            };

            // Act
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Assert
            Assert.Equal(expected, engine.AreaViewLocationFormats);
        }

        [Fact]
        public void FileExtensionsProperty()
        {
            // Arrange
            string[] expected = new string[]
            {
                "aspx",
                "ascx",
                "master",
            };

            // Act
            TestableWebFormViewEngine engine = new TestableWebFormViewEngine();

            // Assert
            Assert.Equal(expected, engine.FileExtensions);
        }

        private sealed class TestableWebFormViewEngine : WebFormViewEngine
        {
            public TestableWebFormViewEngine()
                : base()
            {
            }

            public TestableWebFormViewEngine(IViewPageActivator viewPageActivator)
                : base(viewPageActivator)
            {
            }

            public new IViewPageActivator ViewPageActivator
            {
                get { return base.ViewPageActivator; }
            }

            public new VirtualPathProvider VirtualPathProvider
            {
                get { return base.VirtualPathProvider; }
                set { base.VirtualPathProvider = value; }
            }

            public IView CreatePartialView(string partialPath)
            {
                return base.CreatePartialView(new ControllerContext(), partialPath);
            }

            public IView CreateView(string viewPath, string masterPath)
            {
                return base.CreateView(new ControllerContext(), viewPath, masterPath);
            }

            // This method should remain overridable in derived view engines
            protected override bool FileExists(ControllerContext controllerContext, string virtualPath)
            {
                return base.FileExists(controllerContext, virtualPath);
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Test/WebFormViewTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.Mvc.Test
{
    public class WebFormViewTest
    {
        [Fact]
        public void GuardClauses()
        {
            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new WebFormView(new ControllerContext(), String.Empty, "~/master"),
                "viewPath"
                );

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmpty(
                () => new WebFormView(new ControllerContext(), null, "~/master"),
                "viewPath"
                );

            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => new WebFormView(null, "view path", "~/master"),
                "controllerContext"
                );
        }

        [Fact]
        public void MasterPathProperty()
        {
            // Act
            WebFormView view = new WebFormView(new ControllerContext(), "view path", "master path");

            // Assert
            Assert.Equal("master path", view.MasterPath);
        }

        [Fact]
        public void MasterPathPropertyReturnsEmptyStringIfMasterNotSpecified()
        {
            // Act
            WebFormView view = new WebFormView(new ControllerContext(), "view path", null);

            // Assert
            Assert.Equal(String.Empty, view.MasterPath);
        }

        [Fact]
        public void RenderWithUnsupportedTypeThrows()
        {
            // Arrange
            ViewContext context = new Mock<ViewContext>().Object;
            MockBuildManager buildManagerMock = new MockBuildManager("view path", typeof(int));
            WebFormView view = new WebFormView(new ControllerContext(), "view path", null);
            view.BuildManager = buildManagerMock;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => view.Render(context, null),
                "The view at 'view path' must derive from ViewPage, ViewPage<TModel>, ViewUserControl, or ViewUserControl<TModel>."
                );
        }

        [Fact]
        public void RenderWithViewPageAndMasterRendersView()
        {
            // Arrange
            ViewContext context = new Mock<ViewContext>().Object;
            MockBuildManager buildManager = new MockBuildManager("view path", typeof(object));
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
            ControllerContext controllerContext = new ControllerContext();
            StubViewPage viewPage = new StubViewPage();
            activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
            WebFormView view = new WebFormView(controllerContext, "view path", "master path", activator.Object);
            view.BuildManager = buildManager;

            // Act
            view.Render(context, null);

            // Assert
            Assert.Equal(context, viewPage.ResultViewContext);
            Assert.Equal("master path", viewPage.MasterLocation);
        }

        [Fact]
        public void RenderWithViewPageRendersView()
        {
            // Arrange
            ViewContext context = new Mock<ViewContext>().Object;
            MockBuildManager buildManager = new MockBuildManager("view path", typeof(object));
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
            ControllerContext controllerContext = new ControllerContext();
            StubViewPage viewPage = new StubViewPage();
            activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
            WebFormView view = new WebFormView(controllerContext, "view path", null, activator.Object);
            view.BuildManager = buildManager;

            // Act
            view.Render(context, null);

            // Assert
            Assert.Equal(context, viewPage.ResultViewContext);
            Assert.Equal(String.Empty, viewPage.MasterLocation);
        }

        [Fact]
        public void RenderWithViewUserControlAndMasterThrows()
        {
            // Arrange
            ViewContext context = new Mock<ViewContext>().Object;
            MockBuildManager buildManagerMock = new MockBuildManager("view path", typeof(StubViewUserControl));
            WebFormView view = new WebFormView(new ControllerContext(), "view path", "master path");
            view.BuildManager = buildManagerMock;

            // Act & Assert
            Assert.Throws<InvalidOperationException>(
                () => view.Render(context, null),
                "A master name cannot be specified when the view is a ViewUserControl."
                );
        }

        [Fact]
        public void RenderWithViewUserControlRendersView()
        {
            // Arrange
            ViewContext context = new Mock<ViewContext>().Object;
            MockBuildManager buildManager = new MockBuildManager("view path", typeof(object));
            Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
            ControllerContext controllerContext = new ControllerContext();
            StubViewUserControl viewUserControl = new StubViewUserControl();
            activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewUserControl);
            WebFormView view = new WebFormView(controllerContext, "view path", null, activator.Object) { BuildManager = buildManager };

            // Act
            view.Render(context, null);

            // Assert
            Assert.Equal(context, viewUserControl.ResultViewContext);
        }

        public sealed class StubViewPage : ViewPage
        {
            public ViewContext ResultViewContext;

            public override void RenderView(ViewContext viewContext)
            {
                ResultViewContext = viewContext;
            }
        }

        public sealed class StubViewUserControl : ViewUserControl
        {
            public ViewContext ResultViewContext;

            public override void RenderView(ViewContext viewContext)
            {
                ResultViewContext = viewContext;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Util/AnonymousObject.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;

namespace Microsoft.Web.UnitTestUtil
{
    public static class AnonymousObject
    {
        public static string Inspect(object obj)
        {
            if (obj == null)
            {
                return "(null)";
            }

            object[] args = Enumerable.Empty<Object>().ToArray();
            IEnumerable<string> values = obj.GetType()
                .GetProperties()
                .Select(prop => String.Format("{0}: {1}", prop.Name, prop.GetValue(obj, args)));

            if (!values.Any())
            {
                return "(no properties)";
            }

            return "{ " + values.Aggregate((left, right) => left + ", " + right) + " }";
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Util/DictionaryHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.TestUtil
{
    public class DictionaryHelper<TKey, TValue>
    {
        public IEqualityComparer<TKey> Comparer { get; set; }

        public Func<IDictionary<TKey, TValue>> Creator { get; set; }

        public IList<TKey> SampleKeys { get; set; }

        public IList<TValue> SampleValues { get; set; }

        public bool SkipItemPropertyTest { get; set; }

        public bool ThrowOnKeyNotFound { get; set; }

        public void Execute()
        {
            ValidateProperties();

            Executor executor = new Executor()
            {
                Comparer = Comparer,
                Creator = Creator,
                ThrowOnKeyNotFound = ThrowOnKeyNotFound,
                Values = SampleValues.ToArray()
            };
            SeparateKeys(out executor.ExcludedKey, out executor.ConflictingKeys, out executor.NonConflictingKeys);

            executor.TestAdd1();
            executor.TestAdd1ThrowsArgumentExceptionIfKeyAlreadyInDictionary();
            executor.TestAdd2();
            executor.TestClear();
            executor.TestContains();
            executor.TestContainsKey();
            executor.TestCopyTo();
            executor.TestCountProperty();
            executor.TestGetEnumerator();
            executor.TestGetEnumeratorGeneric();
            executor.TestIsReadOnlyProperty();

            if (!SkipItemPropertyTest)
            {
                executor.TestItemProperty();
            }

            executor.TestKeysProperty();
            executor.TestRemove1();
            executor.TestRemove2();
            executor.TestTryGetValue();
            executor.TestValuesProperty();
        }

        private void SeparateKeys(out TKey excludedKey, out TKey[] conflictingKeys, out TKey[] nonConflictingKeys)
        {
            List<TKey> nonConflictingKeyList = new List<TKey>();
            TKey[] newConflictingKeys = null;

            var keyLookup = SampleKeys.ToLookup(key => key, Comparer);
            foreach (var entry in keyLookup)
            {
                if (entry.Count() == 1)
                {
                    // not a conflict
                    nonConflictingKeyList.AddRange(entry);
                }
                else
                {
                    // conflict
                    newConflictingKeys = entry.ToArray();
                }
            }

            excludedKey = nonConflictingKeyList[nonConflictingKeyList.Count - 1];
            nonConflictingKeyList.RemoveAt(nonConflictingKeyList.Count - 1);
            conflictingKeys = newConflictingKeys;
            nonConflictingKeys = nonConflictingKeyList.ToArray();
        }

        private void ValidateProperties()
        {
            if (Creator == null)
            {
                throw new InvalidOperationException("The Creator property must not be null.");
            }
            if (SampleKeys == null || SampleKeys.Count < 4)
            {
                throw new InvalidOperationException("The SampleKeys property must contain at least 4 elements.");
            }
            if (SampleValues == null || SampleValues.Count != SampleKeys.Count)
            {
                throw new InvalidOperationException("The SampleValues property must contain as many elements as the SampleKeys property.");
            }

            HashSet<TKey> keys = new HashSet<TKey>(SampleKeys, Comparer);
            if (keys.Count != SampleKeys.Count - 1)
            {
                throw new InvalidOperationException("The SampleKeys property must contain exactly one colliding keypair using the given comparer.");
            }
        }

        private class Executor
        {
            public IEqualityComparer<TKey> Comparer;
            public Func<IDictionary<TKey, TValue>> Creator;
            public TKey ExcludedKey;
            public TKey[] ConflictingKeys;
            public TKey[] NonConflictingKeys;
            public bool ThrowOnKeyNotFound;
            public TValue[] Values;

            private IEnumerable<KeyValuePair<TKey, TValue>> MakeKeyValuePairs()
            {
                return MakeKeyValuePairs(false /* includeConflictingKeys */);
            }

            private IEnumerable<KeyValuePair<TKey, TValue>> MakeKeyValuePairs(bool includeConflictingKeys)
            {
                for (int i = 0; i < NonConflictingKeys.Length; i++)
                {
                    TKey key = NonConflictingKeys[i];
                    TValue value = Values[i];
                    yield return new KeyValuePair<TKey, TValue>(key, value);
                }
                if (includeConflictingKeys)
                {
                    for (int i = 0; i < 2; i++)
                    {
                        TKey key = ConflictingKeys[i];
                        TValue value = Values[NonConflictingKeys.Length + i];
                        yield return new KeyValuePair<TKey, TValue>(key, value);
                    }
                }
            }

            public void TestAdd1()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act
                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }

                // Assert
                VerifyDictionaryEntriesEqual(controlDictionary, testDictionary);
            }

            public void TestAdd1ThrowsArgumentExceptionIfKeyAlreadyInDictionary()
            {
                // Arrange
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act & assert
                var pairs = MakeKeyValuePairs(true /* includeConflictingKeys */).Skip(NonConflictingKeys.Length).ToArray();
                testDictionary.Add(pairs[0].Key, pairs[1].Value);

                Assert.Throws<ArgumentException>(
                    delegate { testDictionary.Add(pairs[1].Key, pairs[1].Value); },
                    "An item with the same key has already been added."
                    );
            }

            public void TestAdd2()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act
                foreach (var entry in MakeKeyValuePairs())
                {
                    ((IDictionary<TKey, TValue>)controlDictionary).Add(entry);
                    testDictionary.Add(entry);
                }

                // Assert
                VerifyDictionaryEntriesEqual(controlDictionary, testDictionary);
            }

            public void TestClear()
            {
                // Arrange
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act
                foreach (var entry in MakeKeyValuePairs())
                {
                    testDictionary.Add(entry);
                }
                testDictionary.Clear();

                // Assert
                Assert.Empty(testDictionary);
            }

            public void TestCountProperty()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act & assert
                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                    Assert.Equal(controlDictionary.Count, testDictionary.Count);
                }
            }

            public void TestContains()
            {
                // Arrange
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act
                foreach (var entry in MakeKeyValuePairs())
                {
                    testDictionary.Add(entry);
                }

                // Assert
                var shouldBeFound = MakeKeyValuePairs().First();
                var shouldNotBeFound = new KeyValuePair<TKey, TValue>(ExcludedKey, Values[Values.Length - 1]);
                Assert.True(testDictionary.Contains(shouldBeFound), String.Format("Test dictionary should have contained entry for KVP '{0}'.", shouldBeFound));
                Assert.False(testDictionary.Contains(shouldNotBeFound), String.Format("Test dictionary should not have contained entry for KVP '{0}'.", shouldNotBeFound));
            }

            public void TestContainsKey()
            {
                // Arrange
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act
                foreach (var entry in MakeKeyValuePairs())
                {
                    testDictionary.Add(entry);
                }

                // Assert
                Assert.True(testDictionary.ContainsKey(NonConflictingKeys[0]), String.Format("Test dictionary should have contained entry for key '{0}'.", NonConflictingKeys[0]));
                Assert.False(testDictionary.ContainsKey(ExcludedKey), String.Format("Test dictionary should not have contained entry for key '{0}'.", ExcludedKey));
            }

            public void TestCopyTo()
            {
                // Arrange
                IDictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }
                KeyValuePair<TKey, TValue>[] testKvps = new KeyValuePair<TKey, TValue>[testDictionary.Count + 2];

                // Act
                testDictionary.CopyTo(testKvps, 2);

                // Assert
                for (int i = 0; i < 2; i++)
                {
                    var defaultValue = default(KeyValuePair<TKey, TValue>);
                    var entry = testKvps[i];
                    Assert.Equal(defaultValue, entry);
                }
                for (int i = 2; i < testKvps.Length; i++)
                {
                    var entry = testKvps[i];
                    Assert.True(controlDictionary.Contains(entry), String.Format("The value '{0}' wasn't present in the control dictionary.", entry));
                    controlDictionary.Remove(entry);
                }

                Assert.Empty(controlDictionary);
            }

            public void TestGetEnumerator()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }

                IEnumerable testDictionaryAsEnumerable = (IEnumerable)testDictionary;

                // Act
                Dictionary<TKey, TValue> newTestDictionary = new Dictionary<TKey, TValue>(Comparer);
                foreach (object entry in testDictionaryAsEnumerable)
                {
                    var kvp = Assert.IsType<KeyValuePair<TKey, TValue>>(entry);
                    newTestDictionary.Add(kvp.Key, kvp.Value);
                }

                // Assert
                VerifyDictionaryEntriesEqual(controlDictionary, newTestDictionary);
            }

            public void TestGetEnumeratorGeneric()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }

                // Act & assert
                VerifyDictionaryEntriesEqual(controlDictionary, testDictionary);
            }

            public void TestIsReadOnlyProperty()
            {
                // Arrange
                IDictionary<TKey, TValue> testDictionary = Creator();

                // Act & assert
                Assert.False(testDictionary.IsReadOnly, "Dictionary should not be read only.");
            }

            public void TestItemProperty()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                var shouldBeFound = MakeKeyValuePairs().First();
                var shouldNotBeFound = new KeyValuePair<TKey, TValue>(ExcludedKey, Values[Values.Length - 1]);

                // Act & assert
                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary[entry.Key] = entry.Value;
                }
                VerifyDictionaryEntriesEqual(controlDictionary, testDictionary);

                TValue value = testDictionary[shouldBeFound.Key];
                Assert.Equal(shouldBeFound.Value, value);

                if (ThrowOnKeyNotFound)
                {
                    Assert.Throws<KeyNotFoundException>(
                        delegate { TValue valueNotFound = testDictionary[shouldNotBeFound.Key]; }, allowDerivedExceptions: true);
                }
                else
                {
                    TValue valueNotFound = testDictionary[shouldNotBeFound.Key];
                    Assert.Equal(default(TValue), valueNotFound); // Should not throw
                }
            }

            public void TestKeysProperty()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }

                // Act
                HashSet<TKey> controlKeys = new HashSet<TKey>(controlDictionary.Keys, Comparer);
                HashSet<TKey> testKeys = new HashSet<TKey>(testDictionary.Keys, Comparer);

                // Assert
                Assert.True(controlKeys.SetEquals(testKeys), "Control dictionary and test dictionary key sets were not equal.");
            }

            public void TestRemove1()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }

                // Act
                bool removalSuccess = testDictionary.Remove(NonConflictingKeys[0]);
                bool removalFailure = testDictionary.Remove(ExcludedKey);

                // Assert
                Assert.True(removalSuccess, "Remove() should return true if the key was removed.");
                Assert.False(removalFailure, "Remove() should return false if the key was not removed.");

                controlDictionary.Remove(NonConflictingKeys[0]);
                VerifyDictionaryEntriesEqual(controlDictionary, testDictionary);
            }

            public void TestRemove2()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    ((IDictionary<TKey, TValue>)controlDictionary).Add(entry);
                    testDictionary.Add(entry);
                }

                // Act
                var shouldBeFound = MakeKeyValuePairs().First();
                var shouldNotBeFound = new KeyValuePair<TKey, TValue>(ExcludedKey, Values[Values.Length - 1]);
                bool removalSuccess = testDictionary.Remove(shouldBeFound);
                bool removalFailure = testDictionary.Remove(shouldNotBeFound);

                // Assert
                Assert.True(removalSuccess, "Remove() should return true if the key was removed.");
                Assert.False(removalFailure, "Remove() should return false if the key was not removed.");

                ((IDictionary<TKey, TValue>)controlDictionary).Remove(shouldBeFound);
                VerifyDictionaryEntriesEqual(controlDictionary, testDictionary);
            }

            public void TestTryGetValue()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }

                var shouldBeFound = MakeKeyValuePairs().First();
                var shouldNotBeFound = new KeyValuePair<TKey, TValue>(ExcludedKey, Values[Values.Length - 1]);

                // Act
                TValue value1;
                bool returned1 = testDictionary.TryGetValue(shouldBeFound.Key, out value1);
                TValue value2;
                bool returned2 = testDictionary.TryGetValue(shouldNotBeFound.Key, out value2);

                // Assert
                Assert.True(returned1, String.Format("The entry '{0}' should have been found.", shouldBeFound));
                Assert.Equal(shouldBeFound.Value, value1);
                Assert.False(returned2, String.Format("The entry '{0}' should not have been found.", shouldNotBeFound));
                Assert.Equal(default(TValue), value2);
            }

            public void TestValuesProperty()
            {
                // Arrange
                Dictionary<TKey, TValue> controlDictionary = new Dictionary<TKey, TValue>(Comparer);
                IDictionary<TKey, TValue> testDictionary = Creator();

                foreach (var entry in MakeKeyValuePairs())
                {
                    controlDictionary.Add(entry.Key, entry.Value);
                    testDictionary.Add(entry.Key, entry.Value);
                }

                // Act
                List<TValue> controlValues = controlDictionary.Values.ToList();
                List<TValue> testValues = testDictionary.Values.ToList();

                // Assert
                foreach (var entry in controlValues)
                {
                    Assert.True(testValues.Contains(entry), String.Format("Test dictionary did not contain value '{0}'.", entry));
                }
                foreach (var entry in testValues)
                {
                    Assert.True(controlValues.Contains(entry), String.Format("Control dictionary did not contain value '{0}'.", entry));
                }
            }

            private void VerifyDictionaryEntriesEqual(Dictionary<TKey, TValue> controlDictionary, IDictionary<TKey, TValue> testDictionary)
            {
                Assert.Equal(controlDictionary.Count, testDictionary.Count);

                Dictionary<TKey, TValue> clonedControlDictionary = new Dictionary<TKey, TValue>(controlDictionary, controlDictionary.Comparer);

                foreach (var entry in testDictionary)
                {
                    var key = entry.Key;
                    Assert.True(clonedControlDictionary.ContainsKey(entry.Key), String.Format("Control dictionary did not contain key '{0}'.", key));
                    clonedControlDictionary.Remove(key);
                }

                foreach (var entry in clonedControlDictionary)
                {
                    var key = entry.Key;
                    Assert.True(false, String.Format("Test dictionary did not contain key '{0}'.", key));
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Util/HttpContextHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Moq;

namespace System.Web.Mvc.Test
{
    public static class HttpContextHelpers
    {
        public static Mock<HttpContextBase> GetMockHttpContext()
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(m => m.Items).Returns(new Dictionary<object, object>());
            return mockContext;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Util/MvcHelper.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.IO;
using System.Linq.Expressions;
using System.Web;
using System.Web.Mvc;
using System.Web.Routing;
using Moq;

namespace Microsoft.Web.UnitTestUtil
{
    public static class MvcHelper
    {
        public const string AppPathModifier = "/$(SESSION)";

        public static HtmlHelper<object> GetHtmlHelper()
        {
            HttpContextBase httpcontext = GetHttpContext("/app/", null, null);
            RouteCollection rt = new RouteCollection();
            rt.Add(new Route("{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            RouteData rd = new RouteData();
            rd.Values.Add("controller", "home");
            rd.Values.Add("action", "oldaction");

            ViewDataDictionary vdd = new ViewDataDictionary();

            ViewContext viewContext = new ViewContext()
            {
                HttpContext = httpcontext,
                RouteData = rd,
                ViewData = vdd
            };
            Mock<IViewDataContainer> mockVdc = new Mock<IViewDataContainer>();
            mockVdc.Setup(vdc => vdc.ViewData).Returns(vdd);

            HtmlHelper<object> htmlHelper = new HtmlHelper<object>(viewContext, mockVdc.Object, rt);
            return htmlHelper;
        }

        public static HtmlHelper GetHtmlHelper(string protocol, int port)
        {
            HttpContextBase httpcontext = GetHttpContext("/app/", null, null, protocol, port);
            RouteCollection rt = new RouteCollection();
            rt.Add(new Route("{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            rt.Add("namedroute", new Route("named/{controller}/{action}/{id}", null) { Defaults = new RouteValueDictionary(new { id = "defaultid" }) });
            RouteData rd = new RouteData();
            rd.Values.Add("controller", "home");
            rd.Values.Add("action", "oldaction");

            ViewDataDictionary vdd = new ViewDataDictionary();

            Mock<ViewContext> mockViewContext = new Mock<ViewContext>();
            mockViewContext.Setup(c => c.HttpContext).Returns(httpcontext);
            mockViewContext.Setup(c => c.RouteData).Returns(rd);
            mockViewContext.Setup(c => c.ViewData).Returns(vdd);
            Mock<IViewDataContainer> mockVdc = new Mock<IViewDataContainer>();
            mockVdc.Setup(vdc => vdc.ViewData).Returns(vdd);

            HtmlHelper htmlHelper = new HtmlHelper(mockViewContext.Object, mockVdc.Object, rt);
            return htmlHelper;
        }

        public static HtmlHelper GetHtmlHelper(ViewDataDictionary viewData)
        {
            Mock<ViewContext> mockViewContext = new Mock<ViewContext>() { CallBase = true };
            mockViewContext.Setup(c => c.ViewData).Returns(viewData);
            mockViewContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            IViewDataContainer container = GetViewDataContainer(viewData);
            return new HtmlHelper(mockViewContext.Object, container);
        }

        public static HtmlHelper<TModel> GetHtmlHelper<TModel>(ViewDataDictionary<TModel> viewData)
        {
            Mock<ViewContext> mockViewContext = new Mock<ViewContext>() { CallBase = true };
            mockViewContext.Setup(c => c.ViewData).Returns(viewData);
            mockViewContext.Setup(c => c.HttpContext.Items).Returns(new Hashtable());
            IViewDataContainer container = GetViewDataContainer(viewData);
            return new HtmlHelper<TModel>(mockViewContext.Object, container);
        }

        public static HtmlHelper GetHtmlHelperWithPath(ViewDataDictionary viewData)
        {
            return GetHtmlHelperWithPath(viewData, "/");
        }

        public static HtmlHelper GetHtmlHelperWithPath(ViewDataDictionary viewData, string appPath)
        {
            ViewContext viewContext = GetViewContextWithPath(appPath, viewData);
            Mock<IViewDataContainer> mockContainer = new Mock<IViewDataContainer>();
            mockContainer.Setup(c => c.ViewData).Returns(viewData);
            IViewDataContainer container = mockContainer.Object;
            return new HtmlHelper(viewContext, container, new RouteCollection());
        }

        public static HtmlHelper<TModel> GetHtmlHelperWithPath<TModel>(ViewDataDictionary<TModel> viewData, string appPath)
        {
            ViewContext viewContext = GetViewContextWithPath(appPath, viewData);
            Mock<IViewDataContainer> mockContainer = new Mock<IViewDataContainer>();
            mockContainer.Setup(c => c.ViewData).Returns(viewData);
            IViewDataContainer container = mockContainer.Object;
            return new HtmlHelper<TModel>(viewContext, container, new RouteCollection());
        }

        public static HtmlHelper<TModel> GetHtmlHelperWithPath<TModel>(ViewDataDictionary<TModel> viewData)
        {
            return GetHtmlHelperWithPath(viewData, "/");
        }

        public static HttpContextBase GetHttpContext(string appPath, string requestPath, string httpMethod, string protocol, int port)
        {
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();

            if (!String.IsNullOrEmpty(appPath))
            {
                mockHttpContext.Setup(o => o.Request.ApplicationPath).Returns(appPath);
                mockHttpContext.Setup(o => o.Request.RawUrl).Returns(appPath);
            }
            if (!String.IsNullOrEmpty(requestPath))
            {
                mockHttpContext.Setup(o => o.Request.AppRelativeCurrentExecutionFilePath).Returns(requestPath);
            }

            Uri uri;

            if (port >= 0)
            {
                uri = new Uri(protocol + "://localhost" + ":" + Convert.ToString(port));
            }
            else
            {
                uri = new Uri(protocol + "://localhost");
            }
            mockHttpContext.Setup(o => o.Request.Url).Returns(uri);

            mockHttpContext.Setup(o => o.Request.PathInfo).Returns(String.Empty);
            if (!String.IsNullOrEmpty(httpMethod))
            {
                mockHttpContext.Setup(o => o.Request.HttpMethod).Returns(httpMethod);
            }

            mockHttpContext.Setup(o => o.Session).Returns((HttpSessionStateBase)null);
            mockHttpContext.Setup(o => o.Response.ApplyAppPathModifier(It.IsAny<string>())).Returns<string>(r => AppPathModifier + r);
            mockHttpContext.Setup(o => o.Items).Returns(new Hashtable());
            return mockHttpContext.Object;
        }

        public static HttpContextBase GetHttpContext(string appPath, string requestPath, string httpMethod)
        {
            return GetHttpContext(appPath, requestPath, httpMethod, Uri.UriSchemeHttp.ToString(), -1);
        }

        public static ViewDataDictionary<TValue> GetNestedViewData<TModel, TValue>(ViewDataDictionary<TModel> viewData, Expression<Func<TModel, TValue>> expression)
        {
            var metadata = ModelMetadata.FromLambdaExpression(expression, viewData);
            var htmlFieldName = ExpressionHelper.GetExpressionText(expression);


            ViewDataDictionary nestedViewData = new ViewDataDictionary(viewData)
            {
                Model = metadata.Model,
                ModelMetadata = metadata,
                TemplateInfo = new TemplateInfo
                {
                    HtmlFieldPrefix = viewData.TemplateInfo.GetFullHtmlFieldName(htmlFieldName),
                }
            };

            return new ViewDataDictionary<TValue>(nestedViewData);
        }

        public static ViewContext GetViewContextWithPath(string appPath, ViewDataDictionary viewData)
        {
            HttpContextBase httpContext = GetHttpContext(appPath, "/request", "GET");

            Mock<ViewContext> mockViewContext = new Mock<ViewContext>() { DefaultValue = DefaultValue.Mock };
            mockViewContext.Setup(c => c.HttpContext).Returns(httpContext);
            mockViewContext.Setup(c => c.ViewData).Returns(viewData);
            mockViewContext.Setup(c => c.Writer).Returns(new StringWriter());
            return mockViewContext.Object;
        }

        public static ViewContext GetViewContextWithPath(ViewDataDictionary viewData)
        {
            return GetViewContextWithPath("/", viewData);
        }

        public static IViewDataContainer GetViewDataContainer(ViewDataDictionary viewData)
        {
            Mock<IViewDataContainer> mockContainer = new Mock<IViewDataContainer>();
            mockContainer.Setup(c => c.ViewData).Returns(viewData);
            return mockContainer.Object;
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Util/Resolver.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Mvc.Test
{
    public class Resolver<T> : IResolver<T>
    {
        public T Current { get; set; }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Util/SimpleValueProvider.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Web.Mvc;

namespace Microsoft.Web.UnitTestUtil
{
    // just a simple value provider used for unit testing

    public sealed class SimpleValueProvider : Dictionary<string, object>, IValueProvider
    {
        private readonly CultureInfo _culture;

        public SimpleValueProvider()
            : this(null)
        {
        }

        public SimpleValueProvider(CultureInfo culture)
            : base(StringComparer.OrdinalIgnoreCase)
        {
            _culture = culture ?? CultureInfo.InvariantCulture;
        }

        // copied from ValueProviderUtil
        public bool ContainsPrefix(string prefix)
        {
            foreach (string key in Keys)
            {
                if (key != null)
                {
                    if (prefix.Length == 0)
                    {
                        return true; // shortcut - non-null key matches empty prefix
                    }

                    if (key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                    {
                        if (key.Length == prefix.Length)
                        {
                            return true; // exact match
                        }
                        else
                        {
                            switch (key[prefix.Length])
                            {
                                case '.': // known separator characters
                                case '[':
                                    return true;
                            }
                        }
                    }
                }
            }

            return false; // nothing found
        }

        public ValueProviderResult GetValue(string key)
        {
            object rawValue;
            if (TryGetValue(key, out rawValue))
            {
                return new ValueProviderResult(rawValue, Convert.ToString(rawValue, _culture), _culture);
            }
            else
            {
                // value not found
                return null;
            }
        }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/Util/SimpleViewDataContainer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;

namespace Microsoft.Web.UnitTestUtil
{
    public class SimpleViewDataContainer : IViewDataContainer
    {
        public SimpleViewDataContainer(ViewDataDictionary viewData)
        {
            ViewData = viewData;
        }

        public ViewDataDictionary ViewData { get; set; }
    }
}


================================================
FILE: test/System.Web.Mvc.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.Razor.Test/CSharpRazorCodeLanguageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using Microsoft.CSharp;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test
{
    public class CSharpRazorCodeLanguageTest
    {
        [Fact]
        public void CreateCodeParserReturnsNewCSharpCodeParser()
        {
            // Arrange
            RazorCodeLanguage service = new CSharpRazorCodeLanguage();

            // Act
            ParserBase parser = service.CreateCodeParser();

            // Assert
            Assert.NotNull(parser);
            Assert.IsType<CSharpCodeParser>(parser);
        }

        [Fact]
        public void CreateCodeGeneratorParserListenerReturnsNewCSharpCodeGeneratorParserListener()
        {
            // Arrange
            RazorCodeLanguage service = new CSharpRazorCodeLanguage();

            // Act
            RazorEngineHost host = new RazorEngineHost(service);
            RazorCodeGenerator generator = service.CreateCodeGenerator("Foo", "Bar", "Baz", host);

            // Assert
            Assert.NotNull(generator);
            Assert.IsType<CSharpRazorCodeGenerator>(generator);
            Assert.Equal("Foo", generator.ClassName);
            Assert.Equal("Bar", generator.RootNamespaceName);
            Assert.Equal("Baz", generator.SourceFileName);
            Assert.Same(host, generator.Host);
        }

        [Fact]
        public void CodeDomProviderTypeReturnsVBCodeProvider()
        {
            // Arrange
            RazorCodeLanguage service = new CSharpRazorCodeLanguage();

            // Assert
            Assert.Equal(typeof(CSharpCodeProvider), service.CodeDomProviderType);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/CodeCompileUnitExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.CodeDom.Compiler;
using System.IO;
using System.Text;

namespace System.Web.Razor.Test
{
    internal static class CodeCompileUnitExtensions
    {
        public static string GenerateCode<T>(this CodeCompileUnit ccu) where T : CodeDomProvider, new()
        {
            StringBuilder output = new StringBuilder();
            using (StringWriter writer = new StringWriter(output))
            {
                T provider = new T();
                provider.GenerateCodeFromCompileUnit(ccu, writer, new CodeGeneratorOptions() { IndentString = "    " });
            }

            return output.ToString();
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Editor/RazorEditorParserTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Web.Razor.Editor;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Test.Utils;
using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.CSharp;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Razor.Test.Editor
{
    public class RazorEditorParserTest
    {
        private static readonly TestFile SimpleCSHTMLDocument = TestFile.Create("DesignTime.Simple.cshtml");
        private static readonly TestFile SimpleCSHTMLDocumentGenerated = TestFile.Create("DesignTime.Simple.txt");
        private const string TestLinePragmaFileName = "C:\\This\\Path\\Is\\Just\\For\\Line\\Pragmas.cshtml";

        [Fact]
        public void ConstructorRequiresNonNullHost()
        {
            Assert.ThrowsArgumentNull(() => new RazorEditorParser(null, TestLinePragmaFileName),
                                          "host");
        }

        [Fact]
        public void ConstructorRequiresNonNullPhysicalPath()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => new RazorEditorParser(CreateHost(), null),
                                                 "sourceFileName");
        }

        [Fact]
        public void ConstructorRequiresNonEmptyPhysicalPath()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => new RazorEditorParser(CreateHost(), String.Empty),
                                                 "sourceFileName");
        }

        [Fact]
        public void TreesAreDifferentReturnsTrueIfTreeStructureIsDifferent()
        {
            var factory = SpanFactory.CreateCsHtml();
            Block original = new MarkupBlock(
                factory.Markup("<p>"),
                new ExpressionBlock(
                    factory.CodeTransition()),
                factory.Markup("</p>"));
            Block modified = new MarkupBlock(
                factory.Markup("<p>"),
                new ExpressionBlock(
                    factory.CodeTransition("@"),
                    factory.Code("f")
                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)),
                factory.Markup("</p>"));
            ITextBuffer oldBuffer = new StringTextBuffer("<p>@</p>");
            ITextBuffer newBuffer = new StringTextBuffer("<p>@f</p>");
            Assert.True(BackgroundParser.TreesAreDifferent(
                original, modified, new[] {
                    new TextChange(position: 4, oldLength: 0, oldBuffer: oldBuffer, newLength: 1, newBuffer: newBuffer)
                }));
        }

        [Fact]
        public void TreesAreDifferentReturnsFalseIfTreeStructureIsSame()
        {
            var factory = SpanFactory.CreateCsHtml();
            Block original = new MarkupBlock(
                factory.Markup("<p>"),
                new ExpressionBlock(
                    factory.CodeTransition(),
                    factory.Code("f")
                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)),
                factory.Markup("</p>"));
            factory.Reset();
            Block modified = new MarkupBlock(
                factory.Markup("<p>"),
                new ExpressionBlock(
                    factory.CodeTransition(),
                    factory.Code("foo")
                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)),
                factory.Markup("</p>"));
            original.LinkNodes();
            modified.LinkNodes();
            ITextBuffer oldBuffer = new StringTextBuffer("<p>@f</p>");
            ITextBuffer newBuffer = new StringTextBuffer("<p>@foo</p>");
            Assert.False(BackgroundParser.TreesAreDifferent(
                original, modified, new[] {
                    new TextChange(position: 5, oldLength: 0, oldBuffer: oldBuffer, newLength: 2, newBuffer: newBuffer)
                }));
        }

        [Fact]
        public void CheckForStructureChangesRequiresNonNullBufferInChange()
        {
            TextChange change = new TextChange();
            Assert.ThrowsArgument(
                () => new RazorEditorParser(
                    CreateHost(),
                    "C:\\Foo.cshtml").CheckForStructureChanges(change),
                "change",
                String.Format(RazorResources.Structure_Member_CannotBeNull, "Buffer", "TextChange"));
        }

        private static RazorEngineHost CreateHost()
        {
            return new RazorEngineHost(new CSharpRazorCodeLanguage()) { DesignTimeMode = true };
        }

        [Fact]
        [ReplaceCulture]
        public void CheckForStructureChangesStartsReparseAndFiresDocumentParseCompletedEventIfNoAdditionalChangesQueued()
        {
            // Arrange
            using (RazorEditorParser parser = CreateClientParser())
            {
                StringTextBuffer input = new StringTextBuffer(SimpleCSHTMLDocument.ReadAllText());

                DocumentParseCompleteEventArgs capturedArgs = null;
                using (ManualResetEventSlim parseComplete = new ManualResetEventSlim(false))
                {
                    parser.DocumentParseComplete += (sender, args) =>
                    {
                        capturedArgs = args;
                        parseComplete.Set();
                    };

                    // Act
                    parser.CheckForStructureChanges(new TextChange(0, 0, new StringTextBuffer(String.Empty), input.Length, input));

                    // Assert
                    MiscUtils.DoWithTimeoutIfNotDebugging(parseComplete.Wait);

                    string generatedCode = capturedArgs.GeneratorResults.GeneratedCode.GenerateCode<CSharpCodeProvider>();

                    Assert.Equal(
                        SimpleCSHTMLDocumentGenerated.ReadAllText(),
                        MiscUtils.StripRuntimeVersion(generatedCode));
                }
            }
        }

        [Fact]
        public void CheckForStructureChangesStartsFullReparseIfChangeOverlapsMultipleSpans()
        {
            // Arrange
            using (RazorEditorParser parser = new RazorEditorParser(CreateHost(), TestLinePragmaFileName))
            {
                ITextBuffer original = new StringTextBuffer("Foo @bar Baz");
                ITextBuffer changed = new StringTextBuffer("Foo @bap Daz");
                TextChange change = new TextChange(7, 3, original, 3, changed);

                using (ManualResetEventSlim parseComplete = new ManualResetEventSlim())
                {
                    int parseCount = 0;
                    parser.DocumentParseComplete += (sender, args) =>
                    {
                        Interlocked.Increment(ref parseCount);
                        parseComplete.Set();
                    };

                    Assert.Equal(PartialParseResult.Rejected, parser.CheckForStructureChanges(new TextChange(0, 0, new StringTextBuffer(String.Empty), 12, original)));
                    MiscUtils.DoWithTimeoutIfNotDebugging(parseComplete.Wait); // Wait for the parse to finish
                    parseComplete.Reset();

                    // Act
                    PartialParseResult result = parser.CheckForStructureChanges(change);

                    // Assert
                    Assert.Equal(PartialParseResult.Rejected, result);
                    MiscUtils.DoWithTimeoutIfNotDebugging(parseComplete.Wait);
                    Assert.Equal(2, parseCount);
                }
            }
        }

        private TextChange CreateDummyChange()
        {
            return new TextChange(0, 0, new StringTextBuffer(String.Empty), 3, new StringTextBuffer("foo"));
        }

        private static Mock<RazorEditorParser> CreateMockParser()
        {
            return new Mock<RazorEditorParser>(CreateHost(), TestLinePragmaFileName) { CallBase = true };
        }

        private static RazorEditorParser CreateClientParser()
        {
            return new RazorEditorParser(CreateHost(), TestLinePragmaFileName);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/BlockExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Test.Framework
{
    public static class BlockExtensions
    {
        public static void LinkNodes(this Block self)
        {
            Span first = null;
            Span previous = null;
            foreach (Span span in self.Flatten())
            {
                if (first == null)
                {
                    first = span;
                }
                span.Previous = previous;

                if (previous != null)
                {
                    previous.Next = span;
                }
                previous = span;
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/BlockTypes.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Test.Framework
{
    // The product code doesn't need this, but having subclasses for the block types makes tests much cleaner :)

    public class StatementBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Statement;

        public StatementBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public StatementBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public StatementBlock(params SyntaxTreeNode[] children)
            : this(BlockCodeGenerator.Null, children)
        {
        }

        public StatementBlock(IEnumerable<SyntaxTreeNode> children)
            : this(BlockCodeGenerator.Null, children)
        {
        }
    }

    public class DirectiveBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Directive;

        public DirectiveBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public DirectiveBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public DirectiveBlock(params SyntaxTreeNode[] children)
            : this(BlockCodeGenerator.Null, children)
        {
        }

        public DirectiveBlock(IEnumerable<SyntaxTreeNode> children)
            : this(BlockCodeGenerator.Null, children)
        {
        }
    }

    public class FunctionsBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Functions;

        public FunctionsBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public FunctionsBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public FunctionsBlock(params SyntaxTreeNode[] children)
            : this(BlockCodeGenerator.Null, children)
        {
        }

        public FunctionsBlock(IEnumerable<SyntaxTreeNode> children)
            : this(BlockCodeGenerator.Null, children)
        {
        }
    }

    public class ExpressionBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Expression;

        public ExpressionBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public ExpressionBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public ExpressionBlock(params SyntaxTreeNode[] children)
            : this(new ExpressionCodeGenerator(), children)
        {
        }

        public ExpressionBlock(IEnumerable<SyntaxTreeNode> children)
            : this(new ExpressionCodeGenerator(), children)
        {
        }
    }

    public class HelperBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Helper;

        public HelperBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public HelperBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public HelperBlock(params SyntaxTreeNode[] children)
            : this(BlockCodeGenerator.Null, children)
        {
        }

        public HelperBlock(IEnumerable<SyntaxTreeNode> children)
            : this(BlockCodeGenerator.Null, children)
        {
        }
    }

    public class MarkupBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Markup;

        public MarkupBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public MarkupBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public MarkupBlock(params SyntaxTreeNode[] children)
            : this(BlockCodeGenerator.Null, children)
        {
        }

        public MarkupBlock(IEnumerable<SyntaxTreeNode> children)
            : this(BlockCodeGenerator.Null, children)
        {
        }
    }

    public class SectionBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Section;

        public SectionBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public SectionBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public SectionBlock(params SyntaxTreeNode[] children)
            : this(BlockCodeGenerator.Null, children)
        {
        }

        public SectionBlock(IEnumerable<SyntaxTreeNode> children)
            : this(BlockCodeGenerator.Null, children)
        {
        }
    }

    public class TemplateBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Template;

        public TemplateBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public TemplateBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public TemplateBlock(params SyntaxTreeNode[] children)
            : this(new TemplateBlockCodeGenerator(), children)
        {
        }

        public TemplateBlock(IEnumerable<SyntaxTreeNode> children)
            : this(new TemplateBlockCodeGenerator(), children)
        {
        }
    }

    public class CommentBlock : Block
    {
        private const BlockType ThisBlockType = BlockType.Comment;

        public CommentBlock(IBlockCodeGenerator codeGenerator, IEnumerable<SyntaxTreeNode> children)
            : base(ThisBlockType, children, codeGenerator)
        {
        }

        public CommentBlock(IBlockCodeGenerator codeGenerator, params SyntaxTreeNode[] children)
            : this(codeGenerator, (IEnumerable<SyntaxTreeNode>)children)
        {
        }

        public CommentBlock(params SyntaxTreeNode[] children)
            : this(new RazorCommentCodeGenerator(), children)
        {
        }

        public CommentBlock(IEnumerable<SyntaxTreeNode> children)
            : this(new RazorCommentCodeGenerator(), children)
        {
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/CodeParserTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Test.Framework
{
    public abstract class CodeParserTestBase : ParserTestBase
    {
        protected abstract ISet<string> KeywordSet { get; }

        protected override ParserBase SelectActiveParser(ParserBase codeParser, ParserBase markupParser)
        {
            return codeParser;
        }

        protected void ImplicitExpressionTest(string input, params RazorError[] errors)
        {
            ImplicitExpressionTest(input, AcceptedCharacters.NonWhiteSpace, errors);
        }

        protected void ImplicitExpressionTest(string input, AcceptedCharacters acceptedCharacters, params RazorError[] errors)
        {
            ImplicitExpressionTest(input, input, acceptedCharacters, errors);
        }

        protected void ImplicitExpressionTest(string input, string expected, params RazorError[] errors)
        {
            ImplicitExpressionTest(input, expected, AcceptedCharacters.NonWhiteSpace, errors);
        }

        protected override void SingleSpanBlockTest(string document, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
        {
            SingleSpanBlockTest(document, blockType, spanType, acceptedCharacters, expectedError: null);
        }

        protected override void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
        {
            SingleSpanBlockTest(document, spanContent, blockType, spanType, acceptedCharacters, expectedErrors: null);
        }

        protected override void SingleSpanBlockTest(string document, BlockType blockType, SpanKind spanType, params RazorError[] expectedError)
        {
            SingleSpanBlockTest(document, document, blockType, spanType, expectedError);
        }

        protected override void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, params RazorError[] expectedErrors)
        {
            SingleSpanBlockTest(document, spanContent, blockType, spanType, AcceptedCharacters.Any, expectedErrors ?? new RazorError[0]);
        }

        protected override void SingleSpanBlockTest(string document, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedError)
        {
            SingleSpanBlockTest(document, document, blockType, spanType, acceptedCharacters, expectedError);
        }

        protected override void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedErrors)
        {
            Block b = CreateSimpleBlockAndSpan(spanContent, blockType, spanType, acceptedCharacters);
            ParseBlockTest(document, b, expectedErrors ?? new RazorError[0]);
        }

        protected void ImplicitExpressionTest(string input, string expected, AcceptedCharacters acceptedCharacters, params RazorError[] errors)
        {
            var factory = CreateSpanFactory();
            ParseBlockTest(SyntaxConstants.TransitionString + input,
                           new ExpressionBlock(
                               factory.CodeTransition(),
                               factory.Code(expected)
                                   .AsImplicitExpression(KeywordSet)
                                   .Accepts(acceptedCharacters)),
                           errors);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/CsHtmlCodeParserTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser;

namespace System.Web.Razor.Test.Framework
{
    public abstract class CsHtmlCodeParserTestBase : CodeParserTestBase
    {
        protected override ISet<string> KeywordSet
        {
            get { return CSharpCodeParser.DefaultKeywords; }
        }

        protected override SpanFactory CreateSpanFactory()
        {
            return SpanFactory.CreateCsHtml();
        }

        public override ParserBase CreateMarkupParser()
        {
            return new HtmlMarkupParser();
        }

        public override ParserBase CreateCodeParser()
        {
            return new CSharpCodeParser();
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/CsHtmlMarkupParserTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser;

namespace System.Web.Razor.Test.Framework
{
    public abstract class CsHtmlMarkupParserTestBase : MarkupParserTestBase
    {
        protected override ISet<string> KeywordSet
        {
            get { return CSharpCodeParser.DefaultKeywords; }
        }

        protected override SpanFactory CreateSpanFactory()
        {
            return SpanFactory.CreateCsHtml();
        }

        public override ParserBase CreateMarkupParser()
        {
            return new HtmlMarkupParser();
        }

        public override ParserBase CreateCodeParser()
        {
            return new CSharpCodeParser();
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/ErrorCollector.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text;
using System.Web.Razor.Utils;

namespace System.Web.Razor.Test.Framework
{
    public class ErrorCollector
    {
        private StringBuilder _message = new StringBuilder();
        private int _indent = 0;

        public bool Success { get; private set; }

        public string Message
        {
            get { return _message.ToString(); }
        }

        public ErrorCollector()
        {
            Success = true;
        }

        public void AddError(string msg, params object[] args)
        {
            Append("F", msg, args);
            Success = false;
        }

        public void AddMessage(string msg, params object[] args)
        {
            Append("P", msg, args);
        }

        public IDisposable Indent()
        {
            _indent++;
            return new DisposableAction(Unindent);
        }

        public void Unindent()
        {
            _indent--;
        }

        private void Append(string prefix, string msg, object[] args)
        {
            _message.Append(prefix);
            _message.Append(":");
            _message.Append(new String('\t', _indent));
            _message.AppendFormat(msg, args);
            _message.AppendLine();
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/MarkupParserTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Test.Framework
{
    public abstract class MarkupParserTestBase : CodeParserTestBase
    {
        protected override ParserBase SelectActiveParser(ParserBase codeParser, ParserBase markupParser)
        {
            return markupParser;
        }

        protected virtual void SingleSpanDocumentTest(string document, BlockType blockType, SpanKind spanType)
        {
            Block b = CreateSimpleBlockAndSpan(document, blockType, spanType);
            ParseDocumentTest(document, b);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/ParserTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

//#define PARSER_TRACE

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Framework
{
    public abstract class ParserTestBase
    {
        protected static Block IgnoreOutput = new IgnoreOutputBlock();

        public SpanFactory Factory { get; private set; }

        protected ParserTestBase()
        {
            Factory = CreateSpanFactory();
        }

        public abstract ParserBase CreateMarkupParser();
        public abstract ParserBase CreateCodeParser();

        protected abstract ParserBase SelectActiveParser(ParserBase codeParser, ParserBase markupParser);

        public virtual ParserContext CreateParserContext(ITextDocument input, ParserBase codeParser, ParserBase markupParser)
        {
            return new ParserContext(input, codeParser, markupParser, SelectActiveParser(codeParser, markupParser));
        }

        protected abstract SpanFactory CreateSpanFactory();

        protected virtual void ParseBlockTest(string document)
        {
            ParseBlockTest(document, null, false, new RazorError[0]);
        }

        protected virtual void ParseBlockTest(string document, bool designTimeParser)
        {
            ParseBlockTest(document, null, designTimeParser, new RazorError[0]);
        }

        protected virtual void ParseBlockTest(string document, params RazorError[] expectedErrors)
        {
            ParseBlockTest(document, false, expectedErrors);
        }

        protected virtual void ParseBlockTest(string document, bool designTimeParser, params RazorError[] expectedErrors)
        {
            ParseBlockTest(document, null, designTimeParser, expectedErrors);
        }

        protected virtual void ParseBlockTest(string document, Block expectedRoot)
        {
            ParseBlockTest(document, expectedRoot, false, null);
        }

        protected virtual void ParseBlockTest(string document, Block expectedRoot, bool designTimeParser)
        {
            ParseBlockTest(document, expectedRoot, designTimeParser, null);
        }

        protected virtual void ParseBlockTest(string document, Block expectedRoot, params RazorError[] expectedErrors)
        {
            ParseBlockTest(document, expectedRoot, false, expectedErrors);
        }

        protected virtual void ParseBlockTest(string document, Block expectedRoot, bool designTimeParser, params RazorError[] expectedErrors)
        {
            RunParseTest(document, parser => parser.ParseBlock, expectedRoot, (expectedErrors ?? new RazorError[0]).ToList(), designTimeParser);
        }

        protected virtual void SingleSpanBlockTest(string document, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
        {
            SingleSpanBlockTest(document, blockType, spanType, acceptedCharacters, expectedError: null);
        }

        protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
        {
            SingleSpanBlockTest(document, spanContent, blockType, spanType, acceptedCharacters, expectedErrors: null);
        }

        protected virtual void SingleSpanBlockTest(string document, BlockType blockType, SpanKind spanType, params RazorError[] expectedError)
        {
            SingleSpanBlockTest(document, document, blockType, spanType, expectedError);
        }

        protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, params RazorError[] expectedErrors)
        {
            SingleSpanBlockTest(document, spanContent, blockType, spanType, AcceptedCharacters.Any, expectedErrors ?? new RazorError[0]);
        }

        protected virtual void SingleSpanBlockTest(string document, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedError)
        {
            SingleSpanBlockTest(document, document, blockType, spanType, acceptedCharacters, expectedError);
        }

        protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedErrors)
        {
            BlockBuilder builder = new BlockBuilder();
            builder.Type = blockType;
            ParseBlockTest(
                document,
                ConfigureAndAddSpanToBlock(
                    builder,
                    Factory.Span(spanType, spanContent, spanType == SpanKind.Markup)
                           .Accepts(acceptedCharacters)),
                expectedErrors ?? new RazorError[0]);
        }

        protected virtual void ParseDocumentTest(string document) {
            ParseDocumentTest(document, null, false);
        }

        protected virtual void ParseDocumentTest(string document, Block expectedRoot) {
            ParseDocumentTest(document, expectedRoot, false, null);
        }

        protected virtual void ParseDocumentTest(string document, Block expectedRoot, params RazorError[] expectedErrors) {
            ParseDocumentTest(document, expectedRoot, false, expectedErrors);
        }

        protected virtual void ParseDocumentTest(string document, bool designTimeParser) {
            ParseDocumentTest(document, null, designTimeParser);
        }

        protected virtual void ParseDocumentTest(string document, Block expectedRoot, bool designTimeParser) {
            ParseDocumentTest(document, expectedRoot, designTimeParser, null);
        }

        protected virtual void ParseDocumentTest(string document, Block expectedRoot, bool designTimeParser, params RazorError[] expectedErrors) {
            RunParseTest(document, parser => parser.ParseDocument, expectedRoot, expectedErrors, designTimeParser, parserSelector: c => c.MarkupParser);
        }

        protected virtual ParserResults ParseDocument(string document) {
            return ParseDocument(document, designTimeParser: false);
        }

        protected virtual ParserResults ParseDocument(string document, bool designTimeParser) {
            return RunParse(document, parser => parser.ParseDocument, designTimeParser, parserSelector: c => c.MarkupParser);
        }

        protected virtual ParserResults ParseBlock(string document) {
            return ParseBlock(document, designTimeParser: false);
        }

        protected virtual ParserResults ParseBlock(string document, bool designTimeParser) {
            return RunParse(document, parser => parser.ParseBlock, designTimeParser);
        }

        protected virtual ParserResults RunParse(string document, Func<ParserBase, Action> parserActionSelector, bool designTimeParser, Func<ParserContext, ParserBase> parserSelector = null)
        {
            parserSelector = parserSelector ?? (c => c.ActiveParser);

            // Create the source
            ParserResults results = null;
            using (SeekableTextReader reader = new SeekableTextReader(document))
            {
                try
                {
                    ParserBase codeParser = CreateCodeParser();
                    ParserBase markupParser = CreateMarkupParser();
                    ParserContext context = CreateParserContext(reader, codeParser, markupParser);
                    context.DesignTimeMode = designTimeParser;

                    codeParser.Context = context;
                    markupParser.Context = context;

                    // Run the parser
                    parserActionSelector(parserSelector(context))();
                    results = context.CompleteParse();
                }
                finally
                {
                    if (results != null && results.Document != null)
                    {
                        WriteTraceLine(String.Empty);
                        WriteTraceLine("Actual Parse Tree:");
                        WriteNode(0, results.Document);
                    }
                }
            }
            return results;
        }

        protected virtual void RunParseTest(string document, Func<ParserBase, Action> parserActionSelector, Block expectedRoot, IList<RazorError> expectedErrors, bool designTimeParser, Func<ParserContext, ParserBase> parserSelector = null)
        {
            // Create the source
            ParserResults results = RunParse(document, parserActionSelector, designTimeParser, parserSelector);

            // Evaluate the results
            if (!ReferenceEquals(expectedRoot, IgnoreOutput))
            {
                EvaluateResults(results, expectedRoot, expectedErrors);
            }
        }

        [Conditional("PARSER_TRACE")]
        private void WriteNode(int indent, SyntaxTreeNode node)
        {
            string content = node.ToString().Replace("\r", "\\r")
                .Replace("\n", "\\n")
                .Replace("{", "{{")
                .Replace("}", "}}");
            if (indent > 0)
            {
                content = new String('.', indent * 2) + content;
            }
            WriteTraceLine(content);
            Block block = node as Block;
            if (block != null)
            {
                foreach (SyntaxTreeNode child in block.Children)
                {
                    WriteNode(indent + 1, child);
                }
            }
        }

        public static void EvaluateResults(ParserResults results, Block expectedRoot)
        {
            EvaluateResults(results, expectedRoot, null);
        }

        public static void EvaluateResults(ParserResults results, Block expectedRoot, IList<RazorError> expectedErrors)
        {
            EvaluateParseTree(results.Document, expectedRoot);
            EvaluateRazorErrors(results.ParserErrors, expectedErrors);
        }

        public static void EvaluateParseTree(Block actualRoot, Block expectedRoot)
        {
            // Evaluate the result
            ErrorCollector collector = new ErrorCollector();

            // Link all the nodes
            expectedRoot.LinkNodes();

            if (expectedRoot == null)
            {
                Assert.Null(actualRoot);
            }
            else
            {
                Assert.NotNull(actualRoot);
                EvaluateSyntaxTreeNode(collector, actualRoot, expectedRoot);
                if (collector.Success)
                {
                    WriteTraceLine("Parse Tree Validation Succeeded:\r\n{0}", collector.Message);
                }
                else
                {
                    Assert.True(false, String.Format("\r\n{0}", collector.Message));
                }
            }
        }

        private static void EvaluateSyntaxTreeNode(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
        {
            if (actual == null)
            {
                AddNullActualError(collector, actual, expected);
            }

            if (actual.IsBlock != expected.IsBlock)
            {
                AddMismatchError(collector, actual, expected);
            }
            else
            {
                if (expected.IsBlock)
                {
                    EvaluateBlock(collector, (Block)actual, (Block)expected);
                }
                else
                {
                    EvaluateSpan(collector, (Span)actual, (Span)expected);
                }
            }
        }

        private static void EvaluateSpan(ErrorCollector collector, Span actual, Span expected)
        {
            if (!Equals(expected, actual))
            {
                AddMismatchError(collector, actual, expected);
            }
            else
            {
                AddPassedMessage(collector, expected);
            }
        }

        private static void EvaluateBlock(ErrorCollector collector, Block actual, Block expected)
        {
            if (actual.Type != expected.Type || !expected.CodeGenerator.Equals(actual.CodeGenerator))
            {
                AddMismatchError(collector, actual, expected);
            }
            else
            {
                AddPassedMessage(collector, expected);
                using (collector.Indent())
                {
                    IEnumerator<SyntaxTreeNode> expectedNodes = expected.Children.GetEnumerator();
                    IEnumerator<SyntaxTreeNode> actualNodes = actual.Children.GetEnumerator();
                    while (expectedNodes.MoveNext())
                    {
                        if (!actualNodes.MoveNext())
                        {
                            collector.AddError("{0} - FAILED :: No more elements at this node", expectedNodes.Current);
                        }
                        else
                        {
                            EvaluateSyntaxTreeNode(collector, actualNodes.Current, expectedNodes.Current);
                        }
                    }
                    while (actualNodes.MoveNext())
                    {
                        collector.AddError("End of Node - FAILED :: Found Node: {0}", actualNodes.Current);
                    }
                }
            }
        }

        private static void AddPassedMessage(ErrorCollector collector, SyntaxTreeNode expected)
        {
            collector.AddMessage("{0} - PASSED", expected);
        }

        private static void AddMismatchError(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
        {
            collector.AddError("{0} - FAILED :: Actual: {1}", expected, actual);
        }

        private static void AddNullActualError(ErrorCollector collector, SyntaxTreeNode actual, SyntaxTreeNode expected)
        {
            collector.AddError("{0} - FAILED :: Actual: << Null >>", expected);
        }

        public static void EvaluateRazorErrors(IList<RazorError> actualErrors, IList<RazorError> expectedErrors)
        {
            // Evaluate the errors
            if (expectedErrors == null || expectedErrors.Count == 0)
            {
                Assert.True(actualErrors.Count == 0,
                            String.Format("Expected that no errors would be raised, but the following errors were:\r\n{0}", FormatErrors(actualErrors)));
            }
            else
            {
                Assert.True(expectedErrors.Count == actualErrors.Count,
                            String.Format("Expected that {0} errors would be raised, but {1} errors were.\r\nExpected Errors: \r\n{2}\r\nActual Errors: \r\n{3}",
                                          expectedErrors.Count,
                                          actualErrors.Count,
                                          FormatErrors(expectedErrors),
                                          FormatErrors(actualErrors)));
                Assert.Equal(expectedErrors.ToArray(), actualErrors.ToArray());
            }
            WriteTraceLine("Expected Errors were raised:\r\n{0}", FormatErrors(expectedErrors));
        }

        public static string FormatErrors(IList<RazorError> errors)
        {
            if (errors == null)
            {
                return "\t<< No Errors >>";
            }

            StringBuilder builder = new StringBuilder();
            foreach (RazorError err in errors)
            {
                builder.AppendFormat("\t{0}", err);
                builder.AppendLine();
            }
            return builder.ToString();
        }

        [Conditional("PARSER_TRACE")]
        private static void WriteTraceLine(string format, params object[] args)
        {
            Trace.WriteLine(String.Format(format, args));
        }

        protected virtual Block CreateSimpleBlockAndSpan(string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
        {
            SpanConstructor span = Factory.Span(spanType, spanContent, spanType == SpanKind.Markup).Accepts(acceptedCharacters);
            BlockBuilder b = new BlockBuilder()
            {
                Type = blockType
            };
            return ConfigureAndAddSpanToBlock(b, span);
        }

        protected virtual Block ConfigureAndAddSpanToBlock(BlockBuilder block, SpanConstructor span)
        {
            switch (block.Type)
            {
                case BlockType.Markup:
                    span.With(new MarkupCodeGenerator());
                    break;
                case BlockType.Statement:
                    span.With(new StatementCodeGenerator());
                    break;
                case BlockType.Expression:
                    block.CodeGenerator = new ExpressionCodeGenerator();
                    span.With(new ExpressionCodeGenerator());
                    break;
            }
            block.Children.Add(span);
            return block.Build();
        }

        private class IgnoreOutputBlock : Block
        {
            public IgnoreOutputBlock() : base(BlockType.Template, Enumerable.Empty<SyntaxTreeNode>(), null) { }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/RawTextSymbol.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.Internal.Web.Utils;

namespace System.Web.Razor.Test.Framework
{
    internal class RawTextSymbol : ISymbol
    {
        public SourceLocation Start { get; private set; }
        public string Content { get; private set; }

        public RawTextSymbol(SourceLocation start, string content)
        {
            if (content == null)
            {
                throw new ArgumentNullException("content");
            }

            Start = start;
            Content = content;
        }

        public override bool Equals(object obj)
        {
            RawTextSymbol other = obj as RawTextSymbol;
            return Equals(Start, other.Start) && Equals(Content, other.Content);
        }

        internal bool EquivalentTo(ISymbol sym)
        {
            return Equals(Start, sym.Start) && Equals(Content, sym.Content);
        }

        public override int GetHashCode()
        {
            return HashCodeCombiner.Start()
                .Add(Start)
                .Add(Content)
                .CombinedHash;
        }

        public void OffsetStart(SourceLocation documentStart)
        {
            Start = documentStart + Start;
        }

        public void ChangeStart(SourceLocation newStart)
        {
            Start = newStart;
        }

        public override string ToString()
        {
            return String.Format(CultureInfo.InvariantCulture, "{0} RAW - [{1}]", Start, Content);
        }

        internal void CalculateStart(Span prev)
        {
            if (prev == null)
            {
                Start = SourceLocation.Zero;
            }
            else
            {
                Start = new SourceLocationTracker(prev.Start).UpdateLocation(prev.Content).CurrentLocation;
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/TestSpanBuilder.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Test.Framework
{
    public static class SpanFactoryExtensions
    {
        public static UnclassifiedCodeSpanConstructor EmptyCSharp(this SpanFactory self)
        {
            return new UnclassifiedCodeSpanConstructor(
                self.Span(SpanKind.Code, new CSharpSymbol(self.LocationTracker.CurrentLocation, String.Empty, CSharpSymbolType.Unknown)));
        }

        public static UnclassifiedCodeSpanConstructor EmptyVB(this SpanFactory self)
        {
            return new UnclassifiedCodeSpanConstructor(
                self.Span(SpanKind.Code, new VBSymbol(self.LocationTracker.CurrentLocation, String.Empty, VBSymbolType.Unknown)));
        }

        public static SpanConstructor EmptyHtml(this SpanFactory self)
        {
            return self.Span(SpanKind.Markup, new HtmlSymbol(self.LocationTracker.CurrentLocation, String.Empty, HtmlSymbolType.Unknown))
                .With(new MarkupCodeGenerator());
        }

        public static UnclassifiedCodeSpanConstructor Code(this SpanFactory self, string content)
        {
            return new UnclassifiedCodeSpanConstructor(
                self.Span(SpanKind.Code, content, markup: false));
        }

        public static SpanConstructor CodeTransition(this SpanFactory self)
        {
            return self.Span(SpanKind.Transition, SyntaxConstants.TransitionString, markup: false).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor CodeTransition(this SpanFactory self, string content)
        {
            return self.Span(SpanKind.Transition, content, markup: false).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor CodeTransition(this SpanFactory self, CSharpSymbolType type)
        {
            return self.Span(SpanKind.Transition, SyntaxConstants.TransitionString, type).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor CodeTransition(this SpanFactory self, string content, CSharpSymbolType type)
        {
            return self.Span(SpanKind.Transition, content, type).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor CodeTransition(this SpanFactory self, VBSymbolType type)
        {
            return self.Span(SpanKind.Transition, SyntaxConstants.TransitionString, type).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor CodeTransition(this SpanFactory self, string content, VBSymbolType type)
        {
            return self.Span(SpanKind.Transition, content, type).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor MarkupTransition(this SpanFactory self)
        {
            return self.Span(SpanKind.Transition, SyntaxConstants.TransitionString, markup: true).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor MarkupTransition(this SpanFactory self, string content)
        {
            return self.Span(SpanKind.Transition, content, markup: true).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor MarkupTransition(this SpanFactory self, HtmlSymbolType type)
        {
            return self.Span(SpanKind.Transition, SyntaxConstants.TransitionString, type).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor MarkupTransition(this SpanFactory self, string content, HtmlSymbolType type)
        {
            return self.Span(SpanKind.Transition, content, type).Accepts(AcceptedCharacters.None);
        }

        public static SpanConstructor MetaCode(this SpanFactory self, string content)
        {
            return self.Span(SpanKind.MetaCode, content, markup: false);
        }

        public static SpanConstructor MetaCode(this SpanFactory self, string content, CSharpSymbolType type)
        {
            return self.Span(SpanKind.MetaCode, content, type);
        }

        public static SpanConstructor MetaCode(this SpanFactory self, string content, VBSymbolType type)
        {
            return self.Span(SpanKind.MetaCode, content, type);
        }

        public static SpanConstructor MetaMarkup(this SpanFactory self, string content)
        {
            return self.Span(SpanKind.MetaCode, content, markup: true);
        }

        public static SpanConstructor MetaMarkup(this SpanFactory self, string content, HtmlSymbolType type)
        {
            return self.Span(SpanKind.MetaCode, content, type);
        }

        public static SpanConstructor Comment(this SpanFactory self, string content, CSharpSymbolType type)
        {
            return self.Span(SpanKind.Comment, content, type);
        }

        public static SpanConstructor Comment(this SpanFactory self, string content, VBSymbolType type)
        {
            return self.Span(SpanKind.Comment, content, type);
        }

        public static SpanConstructor Comment(this SpanFactory self, string content, HtmlSymbolType type)
        {
            return self.Span(SpanKind.Comment, content, type);
        }

        public static SpanConstructor Markup(this SpanFactory self, string content)
        {
            return self.Span(SpanKind.Markup, content, markup: true).With(new MarkupCodeGenerator());
        }

        public static SpanConstructor Markup(this SpanFactory self, params string[] content)
        {
            return self.Span(SpanKind.Markup, content, markup: true).With(new MarkupCodeGenerator());
        }

        public static SourceLocation GetLocationAndAdvance(this SourceLocationTracker self, string content)
        {
            SourceLocation ret = self.CurrentLocation;
            self.UpdateLocation(content);
            return ret;
        }
    }

    public class SpanFactory
    {
        public Func<ITextDocument, ITokenizer> MarkupTokenizerFactory { get; set; }
        public Func<ITextDocument, ITokenizer> CodeTokenizerFactory { get; set; }
        public SourceLocationTracker LocationTracker { get; private set; }

        public static SpanFactory CreateCsHtml()
        {
            return new SpanFactory()
            {
                MarkupTokenizerFactory = doc => new HtmlTokenizer(doc),
                CodeTokenizerFactory = doc => new CSharpTokenizer(doc)
            };
        }

        public static SpanFactory CreateVbHtml()
        {
            return new SpanFactory()
            {
                MarkupTokenizerFactory = doc => new HtmlTokenizer(doc),
                CodeTokenizerFactory = doc => new VBTokenizer(doc)
            };
        }

        public SpanFactory()
        {
            LocationTracker = new SourceLocationTracker();
        }

        public SpanConstructor Span(SpanKind kind, string content, CSharpSymbolType type)
        {
            return CreateSymbolSpan(kind, content, st => new CSharpSymbol(st, content, type));
        }

        public SpanConstructor Span(SpanKind kind, string content, VBSymbolType type)
        {
            return CreateSymbolSpan(kind, content, st => new VBSymbol(st, content, type));
        }

        public SpanConstructor Span(SpanKind kind, string content, HtmlSymbolType type)
        {
            return CreateSymbolSpan(kind, content, st => new HtmlSymbol(st, content, type));
        }

        public SpanConstructor Span(SpanKind kind, string content, bool markup)
        {
            return new SpanConstructor(kind, Tokenize(new[] { content }, markup));
        }

        public SpanConstructor Span(SpanKind kind, string[] content, bool markup)
        {
            return new SpanConstructor(kind, Tokenize(content, markup));
        }

        public SpanConstructor Span(SpanKind kind, params ISymbol[] symbols)
        {
            return new SpanConstructor(kind, symbols);
        }

        private SpanConstructor CreateSymbolSpan(SpanKind kind, string content, Func<SourceLocation, ISymbol> ctor)
        {
            SourceLocation start = LocationTracker.CurrentLocation;
            LocationTracker.UpdateLocation(content);
            return new SpanConstructor(kind, new[] { ctor(start) });
        }

        public void Reset()
        {
            LocationTracker.CurrentLocation = SourceLocation.Zero;
        }

        private IEnumerable<ISymbol> Tokenize(IEnumerable<string> contentFragments, bool markup)
        {
            return contentFragments.SelectMany(fragment => Tokenize(fragment, markup));
        }

        private IEnumerable<ISymbol> Tokenize(string content, bool markup)
        {
            ITokenizer tok = MakeTokenizer(markup, new SeekableTextReader(content));
            ISymbol sym;
            ISymbol last = null;
            while ((sym = tok.NextSymbol()) != null)
            {
                OffsetStart(sym, LocationTracker.CurrentLocation);
                last = sym;
                yield return sym;
            }
            LocationTracker.UpdateLocation(content);
        }

        private ITokenizer MakeTokenizer(bool markup, SeekableTextReader seekableTextReader)
        {
            if (markup)
            {
                return MarkupTokenizerFactory(seekableTextReader);
            }
            else
            {
                return CodeTokenizerFactory(seekableTextReader);
            }
        }

        private void OffsetStart(ISymbol sym, SourceLocation sourceLocation)
        {
            sym.OffsetStart(sourceLocation);
        }
    }

    public static class SpanConstructorExtensions
    {
        public static SpanConstructor Accepts(this SpanConstructor self, AcceptedCharacters accepted)
        {
            return self.With(eh => eh.AcceptedCharacters = accepted);
        }

        public static SpanConstructor AutoCompleteWith(this SpanConstructor self, string autoCompleteString)
        {
            return AutoCompleteWith(self, autoCompleteString, atEndOfSpan: false);
        }

        public static SpanConstructor AutoCompleteWith(this SpanConstructor self, string autoCompleteString, bool atEndOfSpan)
        {
            return self.With(new AutoCompleteEditHandler(SpanConstructor.TestTokenizer) { AutoCompleteString = autoCompleteString, AutoCompleteAtEndOfSpan = atEndOfSpan });
        }

        public static SpanConstructor WithEditorHints(this SpanConstructor self, EditorHints hints)
        {
            return self.With(eh => eh.EditorHints = hints);
        }
    }

    public class UnclassifiedCodeSpanConstructor
    {
        SpanConstructor _self;

        public UnclassifiedCodeSpanConstructor(SpanConstructor self)
        {
            _self = self;
        }

        public SpanConstructor AsMetaCode()
        {
            _self.Builder.Kind = SpanKind.MetaCode;
            return _self;
        }

        public SpanConstructor AsStatement()
        {
            return _self.With(new StatementCodeGenerator());
        }

        public SpanConstructor AsExpression()
        {
            return _self.With(new ExpressionCodeGenerator());
        }

        public SpanConstructor AsImplicitExpression(ISet<string> keywords)
        {
            return AsImplicitExpression(keywords, acceptTrailingDot: false);
        }

        public SpanConstructor AsImplicitExpression(ISet<string> keywords, bool acceptTrailingDot)
        {
            return _self.With(new ImplicitExpressionEditHandler(SpanConstructor.TestTokenizer, keywords, acceptTrailingDot))
                .With(new ExpressionCodeGenerator());
        }

        public SpanConstructor AsFunctionsBody()
        {
            return _self.With(new TypeMemberCodeGenerator());
        }

        public SpanConstructor AsNamespaceImport(string ns, int namespaceKeywordLength)
        {
            return _self.With(new AddImportCodeGenerator(ns, namespaceKeywordLength));
        }

        public SpanConstructor Hidden()
        {
            return _self.With(SpanCodeGenerator.Null);
        }

        public SpanConstructor AsBaseType(string baseType)
        {
            return _self.With(new SetBaseTypeCodeGenerator(baseType));
        }

        public SpanConstructor AsRazorDirectiveAttribute(string key, string value)
        {
            return _self.With(new RazorDirectiveAttributeCodeGenerator(key, value));
        }

        public SpanConstructor As(ISpanCodeGenerator codeGenerator)
        {
            return _self.With(codeGenerator);
        }
    }

    public class SpanConstructor
    {
        public SpanBuilder Builder { get; private set; }

        internal static IEnumerable<ISymbol> TestTokenizer(string str)
        {
            yield return new RawTextSymbol(SourceLocation.Zero, str);
        }

        public SpanConstructor(SpanKind kind, IEnumerable<ISymbol> symbols)
        {
            Builder = new SpanBuilder();
            Builder.Kind = kind;
            Builder.EditHandler = SpanEditHandler.CreateDefault(TestTokenizer);
            foreach (ISymbol sym in symbols)
            {
                Builder.Accept(sym);
            }
        }

        private Span Build()
        {
            return Builder.Build();
        }

        public SpanConstructor With(ISpanCodeGenerator generator)
        {
            Builder.CodeGenerator = generator;
            return this;
        }

        public SpanConstructor With(SpanEditHandler handler)
        {
            Builder.EditHandler = handler;
            return this;
        }

        public SpanConstructor With(Action<ISpanCodeGenerator> generatorConfigurer)
        {
            generatorConfigurer(Builder.CodeGenerator);
            return this;
        }

        public SpanConstructor With(Action<SpanEditHandler> handlerConfigurer)
        {
            handlerConfigurer(Builder.EditHandler);
            return this;
        }

        public static implicit operator Span(SpanConstructor self)
        {
            return self.Build();
        }

        public SpanConstructor Hidden()
        {
            Builder.CodeGenerator = SpanCodeGenerator.Null;
            return this;
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/VBHtmlCodeParserTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser;

namespace System.Web.Razor.Test.Framework
{
    public abstract class VBHtmlCodeParserTestBase : CodeParserTestBase
    {
        protected override ISet<string> KeywordSet
        {
            get { return VBCodeParser.DefaultKeywords; }
        }

        protected override SpanFactory CreateSpanFactory()
        {
            return SpanFactory.CreateVbHtml();
        }

        public override ParserBase CreateMarkupParser()
        {
            return new HtmlMarkupParser();
        }

        public override ParserBase CreateCodeParser()
        {
            return new VBCodeParser();
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Framework/VBHtmlMarkupParserTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser;

namespace System.Web.Razor.Test.Framework
{
    public abstract class VBHtmlMarkupParserTestBase : MarkupParserTestBase
    {
        protected override ISet<string> KeywordSet
        {
            get { return VBCodeParser.DefaultKeywords; }
        }

        protected override SpanFactory CreateSpanFactory()
        {
            return SpanFactory.CreateVbHtml();
        }

        public override ParserBase CreateMarkupParser()
        {
            return new HtmlMarkupParser();
        }

        public override ParserBase CreateCodeParser()
        {
            return new VBCodeParser();
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Generator/CSharpRazorCodeGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Generator
{
    public class CSharpRazorCodeGeneratorTest : RazorCodeGeneratorTest<CSharpRazorCodeLanguage>
    {
        protected override string FileExtension
        {
            get { return "cshtml"; }
        }

        protected override string LanguageName
        {
            get { return "CS"; }
        }

        protected override string BaselineExtension
        {
            get { return "cs"; }
        }

        private const string TestPhysicalPath = @"C:\Bar.cshtml";
        private const string TestVirtualPath = "~/Foo/Bar.cshtml";

        [Fact]
        public void ConstructorRequiresNonNullClassName()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => new CSharpRazorCodeGenerator(null, TestRootNamespaceName, TestPhysicalPath, CreateHost()), "className");
        }

        [Fact]
        public void ConstructorRequiresNonEmptyClassName()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => new CSharpRazorCodeGenerator(String.Empty, TestRootNamespaceName, TestPhysicalPath, CreateHost()), "className");
        }

        [Fact]
        public void ConstructorRequiresNonNullRootNamespaceName()
        {
            Assert.ThrowsArgumentNull(() => new CSharpRazorCodeGenerator("Foo", null, TestPhysicalPath, CreateHost()), "rootNamespaceName");
        }

        [Fact]
        public void ConstructorAllowsEmptyRootNamespaceName()
        {
            new CSharpRazorCodeGenerator("Foo", String.Empty, TestPhysicalPath, CreateHost());
        }

        [Fact]
        public void ConstructorRequiresNonNullHost()
        {
            Assert.ThrowsArgumentNull(() => new CSharpRazorCodeGenerator("Foo", TestRootNamespaceName, TestPhysicalPath, null), "host");
        }

        [Theory]
        [InlineData("NestedCodeBlocks")]
        [InlineData("CodeBlock")]
        [InlineData("ExplicitExpression")]
        [InlineData("MarkupInCodeBlock")]
        [InlineData("Blocks")]
        [InlineData("ImplicitExpression")]
        [InlineData("Imports")]
        [InlineData("ExpressionsInCode")]
        [InlineData("FunctionsBlock")]
        [InlineData("FunctionsBlock_Tabs")]
        [InlineData("Templates")]
        [InlineData("Sections")]
        [InlineData("RazorComments")]
        [InlineData("Helpers")]
        [InlineData("HelpersMissingCloseParen")]
        [InlineData("HelpersMissingOpenBrace")]
        [InlineData("HelpersMissingOpenParen")]
        [InlineData("NestedHelpers")]
        [InlineData("InlineBlocks")]
        [InlineData("LayoutDirective")]
        [InlineData("ConditionalAttributes")]
        [InlineData("ResolveUrl")]
        public void CSharpCodeGeneratorCorrectlyGeneratesRunTimeCode(string testType)
        {
            RunTest(testType);
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesMappingsForSimpleUnspacedIf()
        {
            RunTest("SimpleUnspacedIf",
                    "SimpleUnspacedIf.DesignTime.Tabs",
                    designTimeMode: true,
                    tabTest: TabTest.Tabs,
                    expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
                    {
                        /* 01 */ new GeneratedCodeMapping(1, 2, 1, 15),
                        /* 02 */ new GeneratedCodeMapping(3, 13, 7, 3),
                    });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesMappingsForRazorCommentsAtDesignTime()
        {
            RunTest("RazorComments", "RazorComments.DesignTime", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(4, 3, 3, 6),
                /* 02 */ new GeneratedCodeMapping(5, 40, 39, 22),
                /* 03 */ new GeneratedCodeMapping(6, 50, 49, 58),
                /* 04 */ new GeneratedCodeMapping(12, 3, 3, 24),
                /* 05 */ new GeneratedCodeMapping(13, 46, 46, 3),
                /* 06 */ new GeneratedCodeMapping(15, 3, 7, 1),
                /* 07 */ new GeneratedCodeMapping(15, 8, 8, 1)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGenerateMappingForOpenedCurlyIf()
        {
            OpenedIf(withTabs: true);
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGenerateMappingForOpenedCurlyIfSpaces()
        {
            OpenedIf(withTabs: false);
        }

        private void OpenedIf(bool withTabs)
        {
            int tabOffsetForMapping = 0;

            // where the test is running with tabs, the offset into the CS buffer changes for the whitespace mapping
            // with spaces we get 7xspace -> offset of 8 (column = offset+1)
            // with tabs we get tab + 3 spaces -> offset of 4 chars + 1 = 5
            if (withTabs)
            {
                tabOffsetForMapping = 3;
            }

            RunTest("OpenedIf",
                "OpenedIf.DesignTime" + (withTabs ? ".Tabs" : ""),
                    designTimeMode: true,
                    tabTest: withTabs ? TabTest.Tabs : TabTest.NoTabs,
                    spans: new TestSpan[]
            {
                new TestSpan(SpanKind.Markup, 0, 16),
                new TestSpan(SpanKind.Transition, 16, 17),
                new TestSpan(SpanKind.Code, 17, 31),
                new TestSpan(SpanKind.Markup, 31, 38),
                new TestSpan(SpanKind.Code, 38, 40),
                new TestSpan(SpanKind.Markup, 40, 47),
                new TestSpan(SpanKind.Code, 47, 47),
            },
            expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 2, 1, 14),
                /* 02 */ new GeneratedCodeMapping(4, 8, 8 - tabOffsetForMapping, 2),
                /* 03 */ new GeneratedCodeMapping(5, 8, 8 - tabOffsetForMapping, 0),
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesImportStatementsAtDesignTime()
        {
            RunTest("Imports", "Imports.DesignTime", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 2, 1, 15),
                /* 02 */ new GeneratedCodeMapping(2, 2, 1, 32),
                /* 03 */ new GeneratedCodeMapping(3, 2, 1, 12),
                /* 04 */ new GeneratedCodeMapping(5, 30, 30, 21),
                /* 05 */ new GeneratedCodeMapping(6, 36, 36, 20),
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesFunctionsBlocksAtDesignTime()
        {
            RunTest("FunctionsBlock",
                    "FunctionsBlock.DesignTime",
                    designTimeMode: true,
                    tabTest: TabTest.NoTabs,
                    expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 13, 13, 4),
                /* 02 */ new GeneratedCodeMapping(5, 13, 13, 104),
                /* 03 */ new GeneratedCodeMapping(12, 26, 26, 11)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesFunctionsBlocksAtDesignTimeTabs()
        {
            RunTest("FunctionsBlock",
                    "FunctionsBlock.DesignTime" + ".Tabs",
                    designTimeMode: true,
                    tabTest: TabTest.Tabs,
                    expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 13, 4, 4),
                /* 02 */ new GeneratedCodeMapping(5, 13, 4, 104),
                /* 03 */ new GeneratedCodeMapping(12, 26, 14, 11)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesMinimalFunctionsBlocksAtDesignTimeTabs()
        {
            RunTest("FunctionsBlockMinimal",
                    "FunctionsBlockMinimal.DesignTime" + ".Tabs",
                    designTimeMode: true,
                    tabTest: TabTest.Tabs,
                    expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 13, 7, 55),
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesHiddenSpansWithinCode()
        {
            RunTest("HiddenSpansInCode", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>
            {
                /* 01 */ new GeneratedCodeMapping(1, 3, 3, 6),
                /* 02 */ new GeneratedCodeMapping(2, 6, 6, 5)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorGeneratesCodeWithParserErrorsInDesignTimeMode()
        {
            RunTest("ParserError", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 3, 3, 31)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesInheritsAtRuntime()
        {
            RunTest("Inherits", baselineName: "Inherits.Runtime");
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesInheritsAtDesigntime()
        {
            RunTest("Inherits", baselineName: "Inherits.Designtime", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 2, 7, 5),
                /* 02 */ new GeneratedCodeMapping(3, 11, 11, 25),
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForUnfinishedExpressionsInCode()
        {
            RunTest("UnfinishedExpressionInCode", tabTest: TabTest.NoTabs, designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 3, 3, 2),
                /* 02 */ new GeneratedCodeMapping(2, 2, 7, 9),
                /* 03 */ new GeneratedCodeMapping(2, 11, 11, 2)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForUnfinishedExpressionsInCodeTabs()
        {
            RunTest("UnfinishedExpressionInCode",
                    "UnfinishedExpressionInCode.Tabs",
                    tabTest: TabTest.Tabs,
                    designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 3, 3, 2),
                /* 02 */ new GeneratedCodeMapping(2, 2, 7, 9),
                /* 03 */ new GeneratedCodeMapping(2, 11, 5, 2)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasMarkupAndExpressions()
        {
            RunTest("DesignTime",
                designTimeMode: true,
                tabTest: TabTest.NoTabs,
                expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(2, 14, 13, 36),
                /* 02 */ new GeneratedCodeMapping(3, 23, 23, 1),
                /* 03 */ new GeneratedCodeMapping(3, 28, 28, 15),
                /* 04 */ new GeneratedCodeMapping(8, 3, 7, 12),
                /* 05 */ new GeneratedCodeMapping(9, 2, 7, 4),
                /* 06 */ new GeneratedCodeMapping(9, 15, 15, 3),
                /* 07 */ new GeneratedCodeMapping(9, 26, 26, 1),
                /* 08 */ new GeneratedCodeMapping(14, 6, 7, 3),
                /* 09 */ new GeneratedCodeMapping(17, 9, 24, 7),
                /* 10 */ new GeneratedCodeMapping(17, 16, 16, 26),
                /* 11 */ new GeneratedCodeMapping(19, 19, 19, 9),
                /* 12 */ new GeneratedCodeMapping(21, 1, 1, 1)
            });
        }


        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForImplicitExpressionStartedAtEOF()
        {
            RunTest("ImplicitExpressionAtEOF", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 2, 7, 0)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForExplicitExpressionStartedAtEOF()
        {
            RunTest("ExplicitExpressionAtEOF", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 3, 7, 0)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForCodeBlockStartedAtEOF()
        {
            RunTest("CodeBlockAtEOF", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 3, 3, 0)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyImplicitExpression()
        {
            RunTest("EmptyImplicitExpression", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 2, 7, 0)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyImplicitExpressionInCode()
        {
            RunTest("EmptyImplicitExpressionInCode", tabTest: TabTest.NoTabs, designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 3, 3, 6),
                /* 02 */ new GeneratedCodeMapping(2, 6, 7, 0),
                /* 03 */ new GeneratedCodeMapping(2, 6, 6, 2)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyImplicitExpressionInCodeTabs()
        {
            RunTest("EmptyImplicitExpressionInCode",
                    "EmptyImplicitExpressionInCode.Tabs",
                    tabTest: TabTest.Tabs,
                    designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 3, 3, 6),
                /* 02 */ new GeneratedCodeMapping(2, 6, 7, 0),
                /* 03 */ new GeneratedCodeMapping(2, 6, 3, 2)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyExplicitExpression()
        {
            RunTest("EmptyExplicitExpression", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 3, 7, 0)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyCodeBlock()
        {
            RunTest("EmptyCodeBlock", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 3, 3, 0)
            });
        }

        [Fact]
        public void CSharpCodeGeneratorDoesNotRenderLinePragmasIfGenerateLinePragmasIsSetToFalse()
        {
            RunTest("NoLinePragmas", generatePragmas: false);
        }

        [Fact]
        public void CSharpCodeGeneratorRendersHelpersBlockCorrectlyWhenInstanceHelperRequested()
        {
            RunTest("Helpers", baselineName: "Helpers.Instance", hostConfig: h => h.StaticHelpers = false);
        }

        [Fact]
        public void CSharpCodeGeneratorCorrectlyInstrumentsRazorCodeWhenInstrumentationRequested()
        {
            RunTest("Instrumented", hostConfig: host =>
            {
                host.EnableInstrumentation = true;
                host.InstrumentedSourceFilePath = String.Format("~/{0}.cshtml", host.DefaultClassName);
            });
        }

        [Fact]
        public void CSharpCodeGeneratorGeneratesUrlsCorrectlyWithCommentsAndQuotes()
        {
            RunTest("HtmlCommentWithQuote_Single",
                    tabTest: TabTest.NoTabs);

            RunTest("HtmlCommentWithQuote_Double",
                    tabTest: TabTest.NoTabs);

        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Generator/GeneratedCodeMappingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Generator
{
    public class GeneratedCodeMappingTest
    {
        [Fact]
        public void GeneratedCodeMappingsAreEqualIfDataIsEqual()
        {
            GeneratedCodeMapping left = new GeneratedCodeMapping(12, 34, 56, 78);
            GeneratedCodeMapping right = new GeneratedCodeMapping(12, 34, 56, 78);
            Assert.True(left == right);
            Assert.True(left.Equals(right));
            Assert.True(right.Equals(left));
            Assert.True(Equals(left, right));
        }

        [Fact]
        public void GeneratedCodeMappingsAreNotEqualIfCodeLengthIsNotEqual()
        {
            GeneratedCodeMapping left = new GeneratedCodeMapping(12, 34, 56, 87);
            GeneratedCodeMapping right = new GeneratedCodeMapping(12, 34, 56, 78);
            Assert.False(left == right);
            Assert.False(left.Equals(right));
            Assert.False(right.Equals(left));
            Assert.False(Equals(left, right));
        }

        [Fact]
        public void GeneratedCodeMappingsAreNotEqualIfStartGeneratedColumnIsNotEqual()
        {
            GeneratedCodeMapping left = new GeneratedCodeMapping(12, 34, 56, 87);
            GeneratedCodeMapping right = new GeneratedCodeMapping(12, 34, 65, 87);
            Assert.False(left == right);
            Assert.False(left.Equals(right));
            Assert.False(right.Equals(left));
            Assert.False(Equals(left, right));
        }

        [Fact]
        public void GeneratedCodeMappingsAreNotEqualIfStartColumnIsNotEqual()
        {
            GeneratedCodeMapping left = new GeneratedCodeMapping(12, 34, 56, 87);
            GeneratedCodeMapping right = new GeneratedCodeMapping(12, 43, 56, 87);
            Assert.False(left == right);
            Assert.False(left.Equals(right));
            Assert.False(right.Equals(left));
            Assert.False(Equals(left, right));
        }

        [Fact]
        public void GeneratedCodeMappingsAreNotEqualIfStartLineIsNotEqual()
        {
            GeneratedCodeMapping left = new GeneratedCodeMapping(12, 34, 56, 87);
            GeneratedCodeMapping right = new GeneratedCodeMapping(21, 34, 56, 87);
            Assert.False(left == right);
            Assert.False(left.Equals(right));
            Assert.False(right.Equals(left));
            Assert.False(Equals(left, right));
        }
    }
}

================================================
FILE: test/System.Web.Razor.Test/Generator/PaddingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Generator
{
    public class PaddingTest
    {
        [Fact]
        public void CalculatePaddingForEmptySpanReturnsZero()
        {
            RazorEngineHost host = CreateHost(designTime: true);

            Span span = new Span(new SpanBuilder());

            int padding = CodeGeneratorPaddingHelper.CalculatePadding(host, span, 0);

            Assert.Equal(0, padding);
        }

        [Theory]
        [InlineData(true, false, 4)]
        [InlineData(true, false, 2)]
        [InlineData(false, true, 4)]
        [InlineData(false, true, 2)]
        [InlineData(false, false, 4)]
        [InlineData(false, false, 2)]
        [InlineData(true, true, 4)]
        [InlineData(true, true, 2)]
        [InlineData(true, true, 1)]
        [InlineData(true, true, 0)]
        public void CalculatePaddingForEmptySpanWith4Spaces(bool designTime, bool isIndentingWithTabs, int tabSize)
        {
            RazorEngineHost host = CreateHost(designTime: designTime, isIndentingWithTabs: isIndentingWithTabs, tabSize: tabSize);

            Span span = GenerateSpan(@"    @{", SpanKind.Code, 3, "");

            int padding = CodeGeneratorPaddingHelper.CalculatePadding(host, span, 0);

            Assert.Equal(6, padding);
        }

        [Theory]
        [InlineData(true, false, 4)]
        [InlineData(true, false, 2)]
        [InlineData(false, true, 4)]
        [InlineData(false, true, 2)]
        [InlineData(false, false, 4)]
        [InlineData(false, false, 2)]
        [InlineData(true, true, 4)]
        [InlineData(true, true, 2)]
        [InlineData(true, true, 1)]
        [InlineData(true, true, 0)]
        public void CalculatePaddingForIfSpanWith4Spaces(bool designTime, bool isIndentingWithTabs, int tabSize)
        {
            RazorEngineHost host = CreateHost(designTime: designTime, isIndentingWithTabs: isIndentingWithTabs, tabSize: tabSize);

            Span span = GenerateSpan(@"    @if (true)", SpanKind.Code, 2, "if (true)");

            int padding = CodeGeneratorPaddingHelper.CalculatePadding(host, span, 1);

            Assert.Equal(4, padding);
        }

        [Theory]
        [InlineData(true, false, 4, 0, 4)]
        [InlineData(true, false, 2, 0, 4)]
        [InlineData(true, true, 4, 1, 0)]
        [InlineData(true, true, 2, 2, 0)]
        [InlineData(true, true, 1, 4, 0)]
        [InlineData(true, true, 0, 4, 0)]
        [InlineData(true, true, 3, 1, 1)]

        // in non design time mode padding falls back to spaces to keep runtime code identical to v2 code.
        [InlineData(false, true, 4, 0, 5)]
        [InlineData(false, true, 2, 0, 5)]

        [InlineData(false, false, 4, 0, 5)]
        [InlineData(false, false, 2, 0, 5)]
        public void VerifyPaddingForIfSpanWith4Spaces(bool designTime, bool isIndentingWithTabs, int tabSize, int numTabs, int numSpaces)
        {
            RazorEngineHost host = CreateHost(designTime: designTime, isIndentingWithTabs: isIndentingWithTabs, tabSize: tabSize);

            // no new lines involved
            Span span = GenerateSpan("    @if (true)", SpanKind.Code, 2, "if (true)");

            int generatedStart = 1;
            string code = " if (true)";
            int paddingCharCount;

            string padded = CodeGeneratorPaddingHelper.PadStatement(host, code, span, ref generatedStart, out paddingCharCount);

            VerifyPadded(numTabs, numSpaces, code, padded, paddingCharCount);

            // with new lines involved
            Span newLineSpan = GenerateSpan("\t<div>\r\n    @if (true)", SpanKind.Code, 3, "if (true)");

            string newLinePadded = CodeGeneratorPaddingHelper.PadStatement(host, code, span, ref generatedStart, out paddingCharCount);

            VerifyPadded(numTabs, numSpaces, code, newLinePadded, paddingCharCount);
        }

        [Theory]
        [InlineData(true, false, 4, 0, 8)]
        [InlineData(true, false, 2, 0, 4)]
        [InlineData(true, true, 4, 2, 0)]
        [InlineData(true, true, 2, 2, 0)]
        [InlineData(true, true, 1, 2, 0)]
        [InlineData(true, true, 0, 2, 0)]
        [InlineData(true, true, 3, 2, 0)]

        // in non design time mode padding falls back to spaces to keep runtime code identical to v2 code.
        [InlineData(false, true, 4, 0, 9)]
        [InlineData(false, true, 2, 0, 5)]

        [InlineData(false, false, 4, 0, 9)]
        [InlineData(false, false, 2, 0, 5)]
        public void VerifyPaddingForIfSpanWithTwoTabs(bool designTime, bool isIndentingWithTabs, int tabSize, int numTabs, int numSpaces)
        {
            RazorEngineHost host = CreateHost(designTime: designTime, isIndentingWithTabs: isIndentingWithTabs, tabSize: tabSize);

            // no new lines involved
            Span span = GenerateSpan("\t\t@if (true)", SpanKind.Code, 2, "if (true)");

            int generatedStart = 1;
            string code = " if (true)";
            int paddingCharCount;

            string padded = CodeGeneratorPaddingHelper.PadStatement(host, code, span, ref generatedStart, out paddingCharCount);

            VerifyPadded(numTabs, numSpaces, code, padded, paddingCharCount);

            // with new lines involved
            Span newLineSpan = GenerateSpan("\t<div>\r\n\t\t@if (true)", SpanKind.Code, 3, "if (true)");

            string newLinePadded = CodeGeneratorPaddingHelper.PadStatement(host, code, span, ref generatedStart, out paddingCharCount);

            VerifyPadded(numTabs, numSpaces, code, newLinePadded, paddingCharCount);
        }

        [Theory]
        [InlineData(true, false, 4, 0, 8)]
        [InlineData(true, false, 2, 0, 4)]
        [InlineData(true, true, 4, 2, 0)]
        [InlineData(true, true, 2, 2, 0)]
        [InlineData(true, true, 1, 2, 0)]
        [InlineData(true, true, 0, 2, 0)]

        // in non design time mode padding falls back to spaces to keep runtime code identical to v2 code.
        [InlineData(false, true, 4, 0, 9)]
        [InlineData(false, true, 2, 0, 5)]

        [InlineData(false, false, 4, 0, 9)]
        [InlineData(false, false, 2, 0, 5)]
        public void CalculatePaddingForOpenedIf(bool designTime, bool isIndentingWithTabs, int tabSize, int numTabs, int numSpaces)
        {
            RazorEngineHost host = CreateHost(designTime: designTime, isIndentingWithTabs: isIndentingWithTabs, tabSize: tabSize);

            string text = "\r\n<html>\r\n<body>\r\n\t\t@if (true) { \r\n</body>\r\n</html>";

            Span span = GenerateSpan(text, SpanKind.Code, 3, "if (true) { \r\n");

            int generatedStart = 1;
            string code = " if (true) { \r\n";
            int paddingCharCount;
            string padded = CodeGeneratorPaddingHelper.PadStatement(host, code, span, ref generatedStart, out paddingCharCount);

            VerifyPadded(numTabs, numSpaces, code, padded, paddingCharCount);
        }

        private static void VerifyPadded(int numTabs, int numSpaces, string code, string padded, int paddingCharCount)
        {
            Assert.Equal(numTabs + numSpaces + code.Length, padded.Length);

            if (numTabs > 0 || numSpaces > 0)
            {
                Assert.True(padded.Length > numTabs + numSpaces, "padded string too short");
            }

            for (int i = 0; i < numTabs; i++)
            {
                Assert.Equal('\t', padded[i]);
            }

            for (int i = numTabs; i < numTabs + numSpaces; i++)
            {
                Assert.Equal(' ', padded[i]);
            }

            Assert.Equal(numSpaces + numTabs, paddingCharCount);
        }

        private static RazorEngineHost CreateHost(bool designTime, bool isIndentingWithTabs = false, int tabSize = 4)
        {
            return new RazorEngineHost(new CSharpRazorCodeLanguage())
            {
                DesignTimeMode = designTime,
                IsIndentingWithTabs = isIndentingWithTabs,
                TabSize = tabSize,
            };
        }

        private static Span GenerateSpan(string text, SpanKind spanKind, int spanIndex, string spanText)
        {
            Span[] spans = GenerateSpans(text, spanKind, spanIndex, spanText);

            return spans[spanIndex];
        }

        private static Span[] GenerateSpans(string text, SpanKind spanKind, int spanIndex, string spanText)
        {
            Assert.True(spanIndex > 0);

            RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());

            Span[] spans;

            using (var reader = new StringReader(text))
            {
                ParserResults results = parser.Parse(reader);
                spans = results.Document.Flatten().ToArray();
            }

            Assert.True(spans.Length > spanIndex);
            Assert.Equal(spanKind, spans[spanIndex].Kind);
            Assert.Equal(spanText, spans[spanIndex].Content);

            return spans;
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Generator/RazorCodeGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

//#define GENERATE_BASELINES

using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Utils;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Generator
{
    public abstract class RazorCodeGeneratorTest<TLanguage>
        where TLanguage : RazorCodeLanguage, new()
    {
        protected static readonly string TestRootNamespaceName = "TestOutput";

        protected abstract string FileExtension { get; }
        protected abstract string LanguageName { get; }
        protected abstract string BaselineExtension { get; }

        protected RazorEngineHost CreateHost()
        {
            return new RazorEngineHost(new TLanguage());
        }

        protected void RunTest(string name,
                               string baselineName = null,
                               bool generatePragmas = true,
                               bool designTimeMode = false,
                               IList<GeneratedCodeMapping> expectedDesignTimePragmas = null,
                               TestSpan[] spans = null,
                               TabTest tabTest = TabTest.Both,
                               Action<RazorEngineHost> hostConfig = null)
        {
            bool testRun = false;

            if ((tabTest & TabTest.Tabs) == TabTest.Tabs)
            {
                // CodeDOM will inject its strings into the generated file header, so we force English.
                using (new CultureReplacer())
                {
                    RunTestInternal(
                        name: name,
                        baselineName: baselineName,
                        generatePragmas: generatePragmas,
                        designTimeMode: designTimeMode,
                        expectedDesignTimePragmas: expectedDesignTimePragmas,
                        spans: spans,
                        withTabs: true,
                        hostConfig: hostConfig);
                }

                testRun = true;
            }

            if ((tabTest & TabTest.NoTabs) == TabTest.NoTabs)
            {
                // CodeDOM will inject its strings into the generated file header, so we force English.
                using (new CultureReplacer())
                {
                    RunTestInternal(
                        name: name,
                        baselineName: baselineName,
                        generatePragmas: generatePragmas,
                        designTimeMode: designTimeMode,
                        expectedDesignTimePragmas: expectedDesignTimePragmas,
                        spans: spans,
                        withTabs: false,
                        hostConfig: hostConfig);
                }

                testRun = true;
            }

            Assert.True(testRun, "No test was run because TabTest is not set correctly");
        }

        private void RunTestInternal(string name,
                               string baselineName,
                               bool generatePragmas,
                               bool designTimeMode,
                               IList<GeneratedCodeMapping> expectedDesignTimePragmas,
                               TestSpan[] spans,
                               bool withTabs,
                               Action<RazorEngineHost> hostConfig)
        {
            // Load the test files
            if (baselineName == null)
            {
                baselineName = name;
            }

            string source = TestFile.Create(String.Format("CodeGenerator.{1}.Source.{0}.{2}", name, LanguageName, FileExtension)).ReadAllText();
            string expectedOutput = TestFile.Create(String.Format("CodeGenerator.{1}.Output.{0}.{2}", baselineName, LanguageName, BaselineExtension)).ReadAllText();

            // Set up the host and engine
            RazorEngineHost host = CreateHost();
            host.NamespaceImports.Add("System");
            host.DesignTimeMode = designTimeMode;
            host.StaticHelpers = true;
            host.DefaultClassName = name;

            // Add support for templates, etc.
            host.GeneratedClassContext = new GeneratedClassContext(GeneratedClassContext.DefaultExecuteMethodName,
                                                                   GeneratedClassContext.DefaultWriteMethodName,
                                                                   GeneratedClassContext.DefaultWriteLiteralMethodName,
                                                                   "WriteTo",
                                                                   "WriteLiteralTo",
                                                                   "Template",
                                                                   "DefineSection",
                                                                   "BeginContext",
                                                                   "EndContext")
                                                                   {
                                                                       LayoutPropertyName = "Layout",
                                                                       ResolveUrlMethodName = "Href"
                                                                   };
            if (hostConfig != null)
            {
                hostConfig(host);
            }

            host.IsIndentingWithTabs = withTabs;

            RazorTemplateEngine engine = new RazorTemplateEngine(host);

            // Generate code for the file
            GeneratorResults results = null;
            using (StringTextBuffer buffer = new StringTextBuffer(source))
            {
                results = engine.GenerateCode(buffer, className: name, rootNamespace: TestRootNamespaceName, sourceFileName: generatePragmas ? String.Format("{0}.{1}", name, FileExtension) : null);
            }

            // Generate code
            CodeCompileUnit ccu = results.GeneratedCode;
            CodeDomProvider codeProvider = (CodeDomProvider)Activator.CreateInstance(host.CodeLanguage.CodeDomProviderType);

            CodeGeneratorOptions options = new CodeGeneratorOptions();

            // Both run-time and design-time use these settings. See:
            // * $/Dev10/pu/SP_WebTools/venus/html/Razor/Impl/RazorCodeGenerator.cs:204
            // * $/Dev10/Releases/RTMRel/ndp/fx/src/xsp/System/Web/Compilation/BuildManagerHost.cs:373
            options.BlankLinesBetweenMembers = false;
            options.IndentString = String.Empty;

            StringBuilder output = new StringBuilder();
            using (StringWriter writer = new StringWriter(output))
            {
                codeProvider.GenerateCodeFromCompileUnit(ccu, writer, options);
            }

            WriteBaseline(String.Format(@"test\System.Web.Razor.Test\TestFiles\CodeGenerator\{0}\Output\{1}.{2}", LanguageName, baselineName, BaselineExtension), MiscUtils.StripRuntimeVersion(output.ToString()));

#if !GENERATE_BASELINES
            string textOutput = MiscUtils.StripRuntimeVersion(output.ToString());

            //// Verify code against baseline
            Assert.Equal(expectedOutput, textOutput);
#endif

            IEnumerable<Span> generatedSpans = results.Document.Flatten();

            foreach (var span in generatedSpans)
            {
                VerifyNoBrokenEndOfLines(span.Content);
            }

            // Verify design-time pragmas
            if (designTimeMode)
            {
                if (spans != null)
                {
                    Assert.Equal(spans, generatedSpans.Select(span => new TestSpan(span)).ToArray());
                }

                if (expectedDesignTimePragmas != null)
                {
                    Assert.True(results.DesignTimeLineMappings != null && results.DesignTimeLineMappings.Count > 0);

                    Assert.Equal(expectedDesignTimePragmas.Count, results.DesignTimeLineMappings.Count);

                    Assert.Equal(
                        expectedDesignTimePragmas.ToArray(),
                        results.DesignTimeLineMappings
                               .OrderBy(p => p.Key)
                               .Select(p => p.Value)
                               .ToArray());
                }
            }
        }

        [Conditional("GENERATE_BASELINES")]
        private void WriteBaseline(string baselineFile, string output)
        {
            string root = RecursiveFind("Runtime.sln", Path.GetFullPath("."));
            string baselinePath = Path.Combine(root, baselineFile);

            // Update baseline
            // IMPORTANT! Replace this path with the local path on your machine to the baseline files!
            if (File.Exists(baselinePath))
            {
                File.Delete(baselinePath);
            }
            File.WriteAllText(baselinePath, output.ToString());
        }

        private string RecursiveFind(string path, string start)
        {
            string test = Path.Combine(start, path);
            if (File.Exists(test))
            {
                return start;
            }
            else
            {
                return RecursiveFind(path, new DirectoryInfo(start).Parent.FullName);
            }
        }

        private void VerifyNoBrokenEndOfLines(string text)
        {
            for (int i = 0; i < text.Length; i++)
            {
                if (text[i] == '\r')
                {
                    Assert.True(text.Length > i + 1);
                    Assert.Equal('\n', text[i + 1]);
                }
                else if (text[i] == '\n')
                {
                    Assert.True(i > 0);
                    Assert.Equal('\r', text[i - 1]);
                }
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Generator/TabTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Razor.Test.Generator
{
    [Flags]
    public enum TabTest
    {
        NoTabs = 1,
        Tabs = 2,
        Both = 3
    }
}


================================================
FILE: test/System.Web.Razor.Test/Generator/TestSpan.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Web.Razor.Parser.SyntaxTree;

namespace System.Web.Razor.Test.Generator
{
    public class TestSpan
    {
        /// <summary>
        /// Test span to simplify the generation of the actual Span in test initializer.
        /// </summary>
        /// <param name="kind">Span kind</param>
        /// <param name="start">Zero indexed start char index in the buffer.</param>
        /// <param name="end">End Column, if the text length is zero Start == End.</param>
        public TestSpan(SpanKind kind, int start, int end)
        {
            Kind = kind;
            Start = start;
            End = end;
        }

        public TestSpan(Span span)
            : this(span.Kind,
                   span.Start.AbsoluteIndex,
                   span.Start.AbsoluteIndex + span.Length)
        {
        }

        public SpanKind Kind { get; private set; }
        public int Start { get; private set; }
        public int End { get; private set; }

        public override string ToString()
        {
            return String.Format("{0}: {1}-{2}", Kind, Start, End);
        }

        public override bool Equals(object obj)
        {
            TestSpan other = obj as TestSpan;

            if (other != null)
            {
                return (Kind == other.Kind) &&
                       (Start == other.Start) &&
                       (End == other.End);
            }

            return false;
        }

        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Generator/VBRazorCodeGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Generator;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Generator
{
    public class VBRazorCodeGeneratorTest : RazorCodeGeneratorTest<VBRazorCodeLanguage>
    {
        private const string TestPhysicalPath = @"C:\Bar.vbhtml";
        private const string TestVirtualPath = "~/Foo/Bar.vbhtml";

        protected override string FileExtension
        {
            get { return "vbhtml"; }
        }

        protected override string LanguageName
        {
            get { return "VB"; }
        }

        protected override string BaselineExtension
        {
            get { return "vb"; }
        }

        [Fact]
        public void ConstructorRequiresNonNullClassName()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => new VBRazorCodeGenerator(null, TestRootNamespaceName, TestPhysicalPath, CreateHost()), "className");
        }

        [Fact]
        public void ConstructorRequiresNonEmptyClassName()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => new VBRazorCodeGenerator(String.Empty, TestRootNamespaceName, TestPhysicalPath, CreateHost()), "className");
        }

        [Fact]
        public void ConstructorRequiresNonNullRootNamespaceName()
        {
            Assert.ThrowsArgumentNull(() => new VBRazorCodeGenerator("Foo", null, TestPhysicalPath, CreateHost()), "rootNamespaceName");
        }

        [Fact]
        public void ConstructorAllowsEmptyRootNamespaceName()
        {
            new VBRazorCodeGenerator("Foo", String.Empty, TestPhysicalPath, CreateHost());
        }

        [Fact]
        public void ConstructorRequiresNonNullHost()
        {
            Assert.ThrowsArgumentNull(() => new VBRazorCodeGenerator("Foo", TestRootNamespaceName, TestPhysicalPath, null), "host");
        }

        [Theory]
        [InlineData("NestedCodeBlocks")]
        [InlineData("CodeBlock")]
        [InlineData("ExplicitExpression")]
        [InlineData("MarkupInCodeBlock")]
        [InlineData("Blocks")]
        [InlineData("ImplicitExpression")]
        [InlineData("Imports")]
        [InlineData("ExpressionsInCode")]
        [InlineData("FunctionsBlock")]
        [InlineData("Options")]
        [InlineData("Templates")]
        [InlineData("RazorComments")]
        [InlineData("Sections")]
        [InlineData("EmptySection")] // this scenario causes a crash in Razor V2.0
        [InlineData("Helpers")]
        [InlineData("HelpersMissingCloseParen")]
        [InlineData("HelpersMissingOpenParen")]
        [InlineData("NestedHelpers")]
        [InlineData("LayoutDirective")]
        [InlineData("ConditionalAttributes")]
        [InlineData("ResolveUrl")]
        public void VBCodeGeneratorCorrectlyGeneratesRunTimeCode(string testName)
        {
            RunTest(testName);
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesMappingsForRazorCommentsAtDesignTime()
        {
            // (4, 6) -> (?, 6) [6]
            // ( 5, 40) -> (?, 39) [2]
            // ( 8, 6) -> (?, 6) [33]
            // ( 9, 46) -> (?, 46) [3]
            // ( 12, 3) -> (?, 7) [3]
            // ( 12, 8) -> (?, 8) [1]
            RunTest("RazorComments", "RazorComments.DesignTime", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(4, 6, 6, 6),
                /* 02 */ new GeneratedCodeMapping(5, 40, 39, 2),
                /* 03 */ new GeneratedCodeMapping(8, 6, 6, 33),
                /* 04 */ new GeneratedCodeMapping(9, 46, 46, 3),
                /* 05 */ new GeneratedCodeMapping(12, 3, 7, 1),
                /* 06 */ new GeneratedCodeMapping(12, 8, 8, 1)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesHelperMissingNameAtDesignTime()
        {
            RunTest("HelpersMissingName", designTimeMode: true);
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesImportStatementsAtDesignTimeButCannotWrapPragmasAroundImportStatement()
        {
            RunTest("Imports", "Imports.DesignTime", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 2, 1, 19),
                /* 02 */ new GeneratedCodeMapping(2, 2, 1, 36),
                /* 03 */ new GeneratedCodeMapping(3, 2, 1, 16),
                /* 04 */ new GeneratedCodeMapping(5, 30, 30, 22),
                /* 05 */ new GeneratedCodeMapping(6, 36, 36, 21),
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesFunctionsBlocksAtDesignTime()
        {
            RunTest("FunctionsBlock", "FunctionsBlock.DesignTime", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 11, 11, 4),
                /* 02 */ new GeneratedCodeMapping(5, 11, 11, 129),
                /* 03 */ new GeneratedCodeMapping(12, 26, 26, 11)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesFunctionsBlocksAtDesignTimeTabs()
        {
            RunTest("FunctionsBlock", "FunctionsBlock.DesignTime.Tabs", designTimeMode: true, tabTest: TabTest.Tabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 11, 5, 4),
                /* 02 */ new GeneratedCodeMapping(5, 11, 5, 129),
                /* 03 */ new GeneratedCodeMapping(12, 26, 14, 11)
            });
        }

        [Fact]
        public void VBCodeGeneratorGeneratesCodeWithParserErrorsInDesignTimeMode()
        {
            RunTest("ParserError", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 6, 6, 16)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesInheritsAtRuntime()
        {
            RunTest("Inherits", baselineName: "Inherits.Runtime");
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesInheritsAtDesigntime()
        {
            RunTest("Inherits", baselineName: "Inherits.Designtime", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 11, 25, 27)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasForUnfinishedExpressionsInCode()
        {
            RunTest("UnfinishedExpressionInCode", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 6, 6, 2),
                /* 02 */ new GeneratedCodeMapping(2, 2, 7, 9),
                /* 03 */ new GeneratedCodeMapping(2, 11, 11, 2)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasMarkupAndExpressions()
        {
            RunTest("DesignTime", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(2, 14, 13, 17),
                /* 02 */ new GeneratedCodeMapping(3, 20, 20, 1),
                /* 03 */ new GeneratedCodeMapping(3, 25, 25, 20),
                /* 04 */ new GeneratedCodeMapping(8, 3, 7, 12),
                /* 05 */ new GeneratedCodeMapping(9, 2, 7, 4),
                /* 06 */ new GeneratedCodeMapping(9, 16, 16, 3),
                /* 07 */ new GeneratedCodeMapping(9, 27, 27, 1),
                /* 08 */ new GeneratedCodeMapping(14, 6, 7, 3),
                /* 09 */ new GeneratedCodeMapping(17, 9, 24, 5),
                /* 10 */ new GeneratedCodeMapping(17, 14, 14, 28),
                /* 11 */ new GeneratedCodeMapping(19, 20, 20, 14)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasForImplicitExpressionStartedAtEOF()
        {
            RunTest("ImplicitExpressionAtEOF", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 2, 7, 0)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasForExplicitExpressionStartedAtEOF()
        {
            RunTest("ExplicitExpressionAtEOF", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 3, 7, 0)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasForCodeBlockStartedAtEOF()
        {
            RunTest("CodeBlockAtEOF", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 6, 6, 0)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyImplicitExpression()
        {
            RunTest("EmptyImplicitExpression", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 2, 7, 0)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyImplicitExpressionInCode()
        {
            RunTest("EmptyImplicitExpressionInCode", designTimeMode: true, tabTest: TabTest.NoTabs, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(1, 6, 6, 6),
                /* 02 */ new GeneratedCodeMapping(2, 6, 7, 0),
                /* 03 */ new GeneratedCodeMapping(2, 6, 6, 2)
            });
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyGeneratesDesignTimePragmasForEmptyExplicitExpression()
        {
            RunTest("EmptyExplicitExpression", designTimeMode: true, expectedDesignTimePragmas: new List<GeneratedCodeMapping>()
            {
                /* 01 */ new GeneratedCodeMapping(3, 3, 7, 0)
            });
        }

        [Fact]
        public void VBCodeGeneratorDoesNotRenderLinePragmasIfGenerateLinePragmasIsSetToFalse()
        {
            RunTest("NoLinePragmas", generatePragmas: false);
        }

        [Fact]
        public void VBCodeGeneratorRendersHelpersBlockCorrectlyWhenInstanceHelperRequested()
        {
            RunTest("Helpers", baselineName: "Helpers.Instance", hostConfig: h => h.StaticHelpers = false);
        }

        [Fact]
        public void VBCodeGeneratorCorrectlyInstrumentsRazorCodeWhenInstrumentationRequested()
        {
            RunTest("Instrumented", hostConfig: host =>
            {
                host.EnableInstrumentation = true;
                host.InstrumentedSourceFilePath = String.Format("~/{0}.vbhtml", host.DefaultClassName);
            });
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/BlockTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser
{
    public class BlockTest
    {
        [Fact]
        public void ConstructorWithBlockBuilderSetsParent()
        {
            // Arrange
            BlockBuilder builder = new BlockBuilder() { Type = BlockType.Comment };
            Span span = new SpanBuilder() { Kind = SpanKind.Code }.Build();
            builder.Children.Add(span);

            // Act
            Block block = builder.Build();

            // Assert
            Assert.Same(block, span.Parent);
        }

        [Fact]
        public void ConstructorCopiesBasicValuesFromBlockBuilder()
        {
            // Arrange
            BlockBuilder builder = new BlockBuilder()
            {
                Name = "Foo",
                Type = BlockType.Helper
            };

            // Act
            Block actual = builder.Build();

            // Assert
            Assert.Equal("Foo", actual.Name);
            Assert.Equal(BlockType.Helper, actual.Type);
        }

        [Fact]
        public void ConstructorTransfersInstanceOfCodeGeneratorFromBlockBuilder()
        {
            // Arrange
            IBlockCodeGenerator expected = new ExpressionCodeGenerator();
            BlockBuilder builder = new BlockBuilder()
            {
                Type = BlockType.Helper,
                CodeGenerator = expected
            };

            // Act
            Block actual = builder.Build();

            // Assert
            Assert.Same(expected, actual.CodeGenerator);
        }

        [Fact]
        public void ConstructorTransfersChildrenFromBlockBuilder()
        {
            // Arrange
            Span expected = new SpanBuilder() { Kind = SpanKind.Code }.Build();
            BlockBuilder builder = new BlockBuilder()
            {
                Type = BlockType.Functions
            };
            builder.Children.Add(expected);

            // Act
            Block block = builder.Build();

            // Assert
            Assert.Same(expected, block.Children.Single());
        }

        [Fact]
        public void LocateOwnerReturnsNullIfNoSpanReturnsTrueForOwnsSpan()
        {
            // Arrange
            var factory = SpanFactory.CreateCsHtml();
            Block block = new MarkupBlock(
                factory.Markup("Foo "),
                new StatementBlock(
                    factory.CodeTransition(),
                    factory.Code("bar").AsStatement()),
                factory.Markup(" Baz"));
            TextChange change = new TextChange(128, 1, new StringTextBuffer("Foo @bar Baz"), 1, new StringTextBuffer("Foo @bor Baz"));

            // Act
            Span actual = block.LocateOwner(change);

            // Assert
            Assert.Null(actual);
        }

        [Fact]
        public void LocateOwnerReturnsNullIfChangeCrossesMultipleSpans()
        {
            // Arrange
            var factory = SpanFactory.CreateCsHtml();
            Block block = new MarkupBlock(
                factory.Markup("Foo "),
                new StatementBlock(
                    factory.CodeTransition(),
                    factory.Code("bar").AsStatement()),
                factory.Markup(" Baz"));
            TextChange change = new TextChange(4, 10, new StringTextBuffer("Foo @bar Baz"), 10, new StringTextBuffer("Foo @bor Baz"));

            // Act
            Span actual = block.LocateOwner(change);

            // Assert
            Assert.Null(actual);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpAutoCompleteTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpAutoCompleteTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void FunctionsDirectiveAutoCompleteAtEOF()
        {
            ParseBlockTest("@functions{",
                           new FunctionsBlock(
                               Factory.CodeTransition("@")
                                   .Accepts(AcceptedCharacters.None),
                               Factory.MetaCode("functions{")
                                   .Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp()
                                   .AsFunctionsBody()
                                   .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
                                   {
                                       AutoCompleteString = "}"
                                   })),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "functions", "}", "{"),
                                          1, 0, 1));
        }

        [Fact]
        public void HelperDirectiveAutoCompleteAtEOF()
        {
            ParseBlockTest("@helper Strong(string value) {",
                           new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Strong(string value) {", 8, 0, 8), headerComplete: true),
                                           Factory.CodeTransition(),
                                           Factory.MetaCode("helper ")
                                               .Accepts(AcceptedCharacters.None),
                                           Factory.Code("Strong(string value) {")
                                               .Hidden()
                                               .Accepts(AcceptedCharacters.None),
                                           new StatementBlock(
                                               Factory.EmptyCSharp()
                                                   .AsStatement()
                                                   .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = "}" })
                                               )
                               ),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "helper", "}", "{"),
                                          1, 0, 1));
        }

        [Fact]
        public void SectionDirectiveAutoCompleteAtEOF()
        {
            ParseBlockTest("@section Header {",
                new SectionBlock(new SectionCodeGenerator("Header"),
                    Factory.CodeTransition(),
                    Factory.MetaCode("section Header {")
                           .AutoCompleteWith("}", atEndOfSpan: true)
                           .Accepts(AcceptedCharacters.Any),
                    new MarkupBlock()),
                new RazorError(
                    String.Format(RazorResources.ParseError_Expected_X, "}"),
                    17, 0, 17));
        }

        [Fact]
        public void VerbatimBlockAutoCompleteAtEOF()
        {
            ParseBlockTest("@{",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp()
                                   .AsStatement()
                                   .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = "}" })
                               ),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, RazorResources.BlockName_Code, "}", "{"),
                                          1, 0, 1));
        }

        [Fact]
        public void FunctionsDirectiveAutoCompleteAtStartOfFile()
        {
            ParseBlockTest("@functions{" + Environment.NewLine
                         + "foo",
                           new FunctionsBlock(
                               Factory.CodeTransition("@")
                                   .Accepts(AcceptedCharacters.None),
                               Factory.MetaCode("functions{")
                                   .Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\nfoo")
                                   .AsFunctionsBody()
                                   .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
                                   {
                                       AutoCompleteString = "}"
                                   })),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "functions", "}", "{"),
                                          1, 0, 1));
        }

        [Fact]
        public void HelperDirectiveAutoCompleteAtStartOfFile()
        {
            ParseBlockTest("@helper Strong(string value) {" + Environment.NewLine
                         + "<p></p>",
                           new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Strong(string value) {", 8, 0, 8), headerComplete: true),
                                           Factory.CodeTransition(),
                                           Factory.MetaCode("helper ")
                                               .Accepts(AcceptedCharacters.None),
                                           Factory.Code("Strong(string value) {")
                                               .Hidden()
                                               .Accepts(AcceptedCharacters.None),
                                           new StatementBlock(
                                               Factory.Code("\r\n")
                                                   .AsStatement()
                                                   .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = "}" }),
                                               new MarkupBlock(
                                                   Factory.Markup(@"<p></p>")
                                                       .With(new MarkupCodeGenerator())
                                                       .Accepts(AcceptedCharacters.None)
                                                   ),
                                               Factory.Span(SpanKind.Code, new CSharpSymbol(Factory.LocationTracker.CurrentLocation, String.Empty, CSharpSymbolType.Unknown))
                                                   .With(new StatementCodeGenerator())
                                               )
                               ),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "helper", "}", "{"),
                                          1, 0, 1));
        }

        [Fact]
        public void SectionDirectiveAutoCompleteAtStartOfFile()
        {
            ParseBlockTest("@section Header {" + Environment.NewLine
                         + "<p>Foo</p>",
                new SectionBlock(new SectionCodeGenerator("Header"),
                    Factory.CodeTransition(),
                    Factory.MetaCode("section Header {")
                           .AutoCompleteWith("}", atEndOfSpan: true)
                           .Accepts(AcceptedCharacters.Any),
                    new MarkupBlock(
                        Factory.Markup("\r\n<p>Foo</p>"))),
                new RazorError(String.Format(RazorResources.ParseError_Expected_X, "}"),
                                29, 1, 10));
        }

        [Fact]
        public void VerbatimBlockAutoCompleteAtStartOfFile()
        {
            ParseBlockTest("@{" + Environment.NewLine
                         + "<p></p>",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n")
                                   .AsStatement()
                                   .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = "}" }),
                               new MarkupBlock(
                                   Factory.Markup(@"<p></p>")
                                       .With(new MarkupCodeGenerator())
                                       .Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Span(SpanKind.Code, new CSharpSymbol(Factory.LocationTracker.CurrentLocation, String.Empty, CSharpSymbolType.Unknown))
                                   .With(new StatementCodeGenerator())
                               ),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, RazorResources.BlockName_Code, "}", "{"),
                                          1, 0, 1));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpBlockTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpBlockTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseBlockMethodThrowsArgNullExceptionOnNullContext()
        {
            // Arrange
            CSharpCodeParser parser = new CSharpCodeParser();

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => parser.ParseBlock(), RazorResources.Parser_Context_Not_Set);
        }

        [Fact]
        public void BalancingBracketsIgnoresStringLiteralCharactersAndBracketsInsideSingleLineComments()
        {
            SingleSpanBlockTest(@"if(foo) {
    // bar } "" baz '
    zoop();
}", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void NestedCodeBlockWithAtCausesError()
        {
            ParseBlockTest("if (true) { @if(false) { } }",
                           new StatementBlock(
                               Factory.Code("if (true) { ").AsStatement(),
                               new StatementBlock(
                                   Factory.CodeTransition(),
                                   Factory.Code("if(false) { }").AsStatement()
                                   ),
                               Factory.Code(" }").AsStatement()),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Unexpected_Keyword_After_At,
                                             "if"),
                               new SourceLocation(13, 0, 13)));
        }

        [Fact]
        public void BalancingBracketsIgnoresStringLiteralCharactersAndBracketsInsideBlockComments()
        {
            SingleSpanBlockTest(
                @"if(foo) {
    /* bar } "" */ ' baz } '
    zoop();
}", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSkipsParenthesisedExpressionAndThenBalancesBracesIfFirstIdentifierIsForKeyword()
        {
            SingleSpanBlockTest("for(int i = 0; i < 10; new Foo { Bar = \"baz\" }) { Debug.WriteLine(@\"foo } bar\"); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSkipsParenthesisedExpressionAndThenBalancesBracesIfFirstIdentifierIsForeachKeyword()
        {
            SingleSpanBlockTest("foreach(int i = 0; i < 10; new Foo { Bar = \"baz\" }) { Debug.WriteLine(@\"foo } bar\"); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSkipsParenthesisedExpressionAndThenBalancesBracesIfFirstIdentifierIsWhileKeyword()
        {
            SingleSpanBlockTest("while(int i = 0; i < 10; new Foo { Bar = \"baz\" }) { Debug.WriteLine(@\"foo } bar\"); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSkipsParenthesisedExpressionAndThenBalancesBracesIfFirstIdentifierIsUsingKeywordFollowedByParen()
        {
            SingleSpanBlockTest("using(int i = 0; i < 10; new Foo { Bar = \"baz\" }) { Debug.WriteLine(@\"foo } bar\"); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsUsingsNestedWithinOtherBlocks()
        {
            SingleSpanBlockTest("if(foo) { using(int i = 0; i < 10; new Foo { Bar = \"baz\" }) { Debug.WriteLine(@\"foo } bar\"); } }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSkipsParenthesisedExpressionAndThenBalancesBracesIfFirstIdentifierIsIfKeywordWithNoElseBranches()
        {
            SingleSpanBlockTest("if(int i = 0; i < 10; new Foo { Bar = \"baz\" }) { Debug.WriteLine(@\"foo } bar\"); }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockAllowsEmptyBlockStatement()
        {
            SingleSpanBlockTest("if(false) { }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockTerminatesParenBalancingAtEOF()
        {
            ImplicitExpressionTest("Html.En(code()", "Html.En(code()",
                                   AcceptedCharacters.Any,
                                   new RazorError(
                                       String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                                     "(", ")"),
                                       new SourceLocation(8, 0, 8)));
        }

        [Fact]
        public void ParseBlockSupportsBlockCommentBetweenIfAndElseClause()
        {
            SingleSpanBlockTest("if(foo) { bar(); } /* Foo */ /* Bar */ else { baz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsRazorCommentBetweenIfAndElseClause()
        {
            RunRazorCommentBetweenClausesTest("if(foo) { bar(); } ", " else { baz(); }", acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsBlockCommentBetweenElseIfAndElseClause()
        {
            SingleSpanBlockTest("if(foo) { bar(); } else if(bar) { baz(); } /* Foo */ /* Bar */ else { biz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsRazorCommentBetweenElseIfAndElseClause()
        {
            RunRazorCommentBetweenClausesTest("if(foo) { bar(); } else if(bar) { baz(); } ", " else { baz(); }", acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsBlockCommentBetweenIfAndElseIfClause()
        {
            SingleSpanBlockTest("if(foo) { bar(); } /* Foo */ /* Bar */ else if(bar) { baz(); }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsRazorCommentBetweenIfAndElseIfClause()
        {
            RunRazorCommentBetweenClausesTest("if(foo) { bar(); } ", " else if(bar) { baz(); }");
        }

        [Fact]
        public void ParseBlockSupportsLineCommentBetweenIfAndElseClause()
        {
            SingleSpanBlockTest(@"if(foo) { bar(); } 
// Foo
// Bar
else { baz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsLineCommentBetweenElseIfAndElseClause()
        {
            SingleSpanBlockTest(@"if(foo) { bar(); } else if(bar) { baz(); }
// Foo
// Bar
else { biz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsLineCommentBetweenIfAndElseIfClause()
        {
            SingleSpanBlockTest(@"if(foo) { bar(); }
// Foo
// Bar
else if(bar) { baz(); }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockParsesElseIfBranchesOfIfStatement()
        {
            const string ifStatement = @"if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) {
    Debug.WriteLine(@""foo } bar""); 
}";
            const string elseIfBranch = @" else if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) { 
    Debug.WriteLine(@""bar } baz""); 
}";
            const string document = ifStatement + elseIfBranch;

            SingleSpanBlockTest(document, BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockParsesMultipleElseIfBranchesOfIfStatement()
        {
            const string ifStatement = @"if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) {
    Debug.WriteLine(@""foo } bar""); 
}";
            const string elseIfBranch = @" else if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) { 
    Debug.WriteLine(@""bar } baz""); 
}";
            const string document = ifStatement + elseIfBranch + elseIfBranch + elseIfBranch + elseIfBranch;
            SingleSpanBlockTest(document, BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockParsesMultipleElseIfBranchesOfIfStatementFollowedByOneElseBranch()
        {
            const string ifStatement = @"if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) {
    Debug.WriteLine(@""foo } bar""); 
}";
            const string elseIfBranch = @" else if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) { 
    Debug.WriteLine(@""bar } baz""); 
}";
            const string elseBranch = @" else { Debug.WriteLine(@""bar } baz""); }";
            const string document = ifStatement + elseIfBranch + elseIfBranch + elseBranch;

            SingleSpanBlockTest(document, BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockStopsParsingCodeAfterElseBranch()
        {
            const string ifStatement = @"if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) {
    Debug.WriteLine(@""foo } bar""); 
}";
            const string elseIfBranch = @" else if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) { 
    Debug.WriteLine(@""bar } baz""); 
}";
            const string elseBranch = @" else { Debug.WriteLine(@""bar } baz""); }";
            const string document = ifStatement + elseIfBranch + elseBranch + elseIfBranch;
            const string expected = ifStatement + elseIfBranch + elseBranch;

            ParseBlockTest(document, new StatementBlock(Factory.Code(expected).AsStatement().Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockStopsParsingIfIfStatementNotFollowedByElse()
        {
            const string document = @"if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) {
    Debug.WriteLine(@""foo } bar""); 
}";

            SingleSpanBlockTest(document, BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockAcceptsElseIfWithNoCondition()
        {
            // We don't want to be a full C# parser - If the else if is missing it's condition, the C# compiler can handle that, we have all the info we need to keep parsing
            const string ifBranch = @"if(int i = 0; i < 10; new Foo { Bar = ""baz"" }) {
    Debug.WriteLine(@""foo } bar""); 
}";
            const string elseIfBranch = @" else if { foo(); }";
            const string document = ifBranch + elseIfBranch;

            SingleSpanBlockTest(document, BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockCorrectlyParsesDoWhileBlock()
        {
            SingleSpanBlockTest("do { var foo = bar; } while(foo != bar);", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockCorrectlyParsesDoWhileBlockMissingSemicolon()
        {
            SingleSpanBlockTest("do { var foo = bar; } while(foo != bar)", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockCorrectlyParsesDoWhileBlockMissingWhileCondition()
        {
            SingleSpanBlockTest("do { var foo = bar; } while", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockCorrectlyParsesDoWhileBlockMissingWhileConditionWithSemicolon()
        {
            SingleSpanBlockTest("do { var foo = bar; } while;", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockCorrectlyParsesDoWhileBlockMissingWhileClauseEntirely()
        {
            SingleSpanBlockTest("do { var foo = bar; } narf;", "do { var foo = bar; }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsBlockCommentBetweenDoAndWhileClause()
        {
            SingleSpanBlockTest("do { var foo = bar; } /* Foo */ /* Bar */ while(true);", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsLineCommentBetweenDoAndWhileClause()
        {
            SingleSpanBlockTest(@"do { var foo = bar; } 
// Foo
// Bar
while(true);", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsRazorCommentBetweenDoAndWhileClause()
        {
            RunRazorCommentBetweenClausesTest("do { var foo = bar; } ", " while(true);", acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockCorrectlyParsesMarkupInDoWhileBlock()
        {
            ParseBlockTest("@do { var foo = bar; <p>Foo</p> foo++; } while (foo<bar>);",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("do { var foo = bar;").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Foo</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("foo++; } while (foo<bar>);").AsStatement().Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockSkipsParenthesisedExpressionAndThenBalancesBracesIfFirstIdentifierIsSwitchKeyword()
        {
            SingleSpanBlockTest(@"switch(foo) {
    case 0:
        break;
    case 1:
        {
            break;
        }
    case 2:
        return;
    default:
        return;
}", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSkipsParenthesisedExpressionAndThenBalancesBracesIfFirstIdentifierIsLockKeyword()
        {
            SingleSpanBlockTest("lock(foo) { Debug.WriteLine(@\"foo } bar\"); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockHasErrorsIfNamespaceImportMissingSemicolon()
        {
            NamespaceImportTest("using Foo.Bar.Baz", " Foo.Bar.Baz", acceptedCharacters: AcceptedCharacters.NonWhiteSpace | AcceptedCharacters.WhiteSpace, location: new SourceLocation(17, 0, 17));
        }

        [Fact]
        public void ParseBlockHasErrorsIfNamespaceAliasMissingSemicolon()
        {
            NamespaceImportTest("using Foo.Bar.Baz = FooBarBaz", " Foo.Bar.Baz = FooBarBaz", acceptedCharacters: AcceptedCharacters.NonWhiteSpace | AcceptedCharacters.WhiteSpace, location: new SourceLocation(29, 0, 29));
        }

        [Fact]
        public void ParseBlockParsesNamespaceImportWithSemicolonForUsingKeywordIfIsInValidFormat()
        {
            NamespaceImportTest("using Foo.Bar.Baz;", " Foo.Bar.Baz", AcceptedCharacters.NonWhiteSpace | AcceptedCharacters.WhiteSpace);
        }

        [Fact]
        public void ParseBlockDoesntCaptureWhitespaceAfterUsing()
        {
            ParseBlockTest("using Foo   ",
                           new DirectiveBlock(
                               Factory.Code("using Foo")
                                   .AsNamespaceImport(" Foo", CSharpCodeParser.UsingKeywordLength)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace | AcceptedCharacters.WhiteSpace)));
        }

        [Fact]
        public void ParseBlockParsesNamespaceAliasWithSemicolonForUsingKeywordIfIsInValidFormat()
        {
            NamespaceImportTest("using FooBarBaz = FooBarBaz;", " FooBarBaz = FooBarBaz", AcceptedCharacters.NonWhiteSpace | AcceptedCharacters.WhiteSpace);
        }

        [Fact]
        public void ParseBlockTerminatesUsingKeywordAtEOFAndOutputsFileCodeBlock()
        {
            SingleSpanBlockTest("using                    ", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockTerminatesSingleLineCommentAtEndOfFile()
        {
            const string document = "foreach(var f in Foo) { // foo bar baz";
            SingleSpanBlockTest(document, document, BlockType.Statement, SpanKind.Code,
                                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "foreach", '}', '{'), SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockTerminatesBlockCommentAtEndOfFile()
        {
            const string document = "foreach(var f in Foo) { /* foo bar baz";
            SingleSpanBlockTest(document, document, BlockType.Statement, SpanKind.Code,
                                new RazorError(String.Format(RazorResources.ParseError_BlockComment_Not_Terminated), 24, 0, 24),
                                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "foreach", '}', '{'), SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockTerminatesSingleSlashAtEndOfFile()
        {
            const string document = "foreach(var f in Foo) { / foo bar baz";
            SingleSpanBlockTest(document, document, BlockType.Statement, SpanKind.Code,
                                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "foreach", '}', '{'), SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockSupportsBlockCommentBetweenTryAndFinallyClause()
        {
            SingleSpanBlockTest("try { bar(); } /* Foo */ /* Bar */ finally { baz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsRazorCommentBetweenTryAndFinallyClause()
        {
            RunRazorCommentBetweenClausesTest("try { bar(); } ", " finally { biz(); }", acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsBlockCommentBetweenCatchAndFinallyClause()
        {
            SingleSpanBlockTest("try { bar(); } catch(bar) { baz(); } /* Foo */ /* Bar */ finally { biz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsRazorCommentBetweenCatchAndFinallyClause()
        {
            RunRazorCommentBetweenClausesTest("try { bar(); } catch(bar) { baz(); } ", " finally { biz(); }", acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsBlockCommentBetweenTryAndCatchClause()
        {
            SingleSpanBlockTest("try { bar(); } /* Foo */ /* Bar */ catch(bar) { baz(); }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsRazorCommentBetweenTryAndCatchClause()
        {
            RunRazorCommentBetweenClausesTest("try { bar(); }", " catch(bar) { baz(); }");
        }

        [Fact]
        public void ParseBlockSupportsLineCommentBetweenTryAndFinallyClause()
        {
            SingleSpanBlockTest(@"try { bar(); } 
// Foo
// Bar
finally { baz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsLineCommentBetweenCatchAndFinallyClause()
        {
            SingleSpanBlockTest(@"try { bar(); } catch(bar) { baz(); }
// Foo
// Bar
finally { biz(); }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsLineCommentBetweenTryAndCatchClause()
        {
            SingleSpanBlockTest(@"try { bar(); }
// Foo
// Bar
catch(bar) { baz(); }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsTryStatementWithNoAdditionalClauses()
        {
            SingleSpanBlockTest("try { var foo = new { } }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsMarkupWithinTryClause()
        {
            RunSimpleWrappedMarkupTest("try {", " <p>Foo</p> ", "}");
        }

        [Fact]
        public void ParseBlockSupportsTryStatementWithOneCatchClause()
        {
            SingleSpanBlockTest("try { var foo = new { } } catch(Foo Bar Baz) { var foo = new { } }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsMarkupWithinCatchClause()
        {
            RunSimpleWrappedMarkupTest("try { var foo = new { } } catch(Foo Bar Baz) {", " <p>Foo</p> ", "}");
        }

        [Fact]
        public void ParseBlockSupportsTryStatementWithMultipleCatchClause()
        {
            SingleSpanBlockTest("try { var foo = new { } } catch(Foo Bar Baz) { var foo = new { } } catch(Foo Bar Baz) { var foo = new { } } catch(Foo Bar Baz) { var foo = new { } }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsExceptionLessCatchClauses()
        {
            SingleSpanBlockTest("try { var foo = new { } } catch { var foo = new { } }", BlockType.Statement, SpanKind.Code);
        }

        [Fact]
        public void ParseBlockSupportsMarkupWithinAdditionalCatchClauses()
        {
            RunSimpleWrappedMarkupTest("try { var foo = new { } } catch(Foo Bar Baz) { var foo = new { } } catch(Foo Bar Baz) { var foo = new { } } catch(Foo Bar Baz) {", " <p>Foo</p> ", "}");
        }

        [Fact]
        public void ParseBlockSupportsTryStatementWithFinallyClause()
        {
            SingleSpanBlockTest("try { var foo = new { } } finally { var foo = new { } }", BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsMarkupWithinFinallyClause()
        {
            RunSimpleWrappedMarkupTest("try { var foo = new { } } finally {", " <p>Foo</p> ", "}", acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockStopsParsingCatchClausesAfterFinallyBlock()
        {
            string expectedContent = "try { var foo = new { } } finally { var foo = new { } }";
            SingleSpanBlockTest(expectedContent + " catch(Foo Bar Baz) { }", expectedContent, BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockDoesNotAllowMultipleFinallyBlocks()
        {
            string expectedContent = "try { var foo = new { } } finally { var foo = new { } }";
            SingleSpanBlockTest(expectedContent + " finally { }", expectedContent, BlockType.Statement, SpanKind.Code, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockAcceptsTrailingDotIntoImplicitExpressionWhenEmbeddedInCode()
        {
            // Arrange
            ParseBlockTest(@"if(foo) { @foo. }",
                           new StatementBlock(
                               Factory.Code("if(foo) { ").AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.Code("foo.")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)
                                   ),
                               Factory.Code(" }").AsStatement()
                               ));
        }

        [Fact]
        public void ParseBlockParsesExpressionOnSwitchCharacterFollowedByOpenParen()
        {
            // Arrange
            ParseBlockTest(@"if(foo) { @(foo + bar) }",
                           new StatementBlock(
                               Factory.Code("if(foo) { ").AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                                   Factory.Code("foo + bar").AsExpression(),
                                   Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code(" }").AsStatement()
                               ));
        }

        [Fact]
        public void ParseBlockParsesExpressionOnSwitchCharacterFollowedByIdentifierStart()
        {
            // Arrange
            ParseBlockTest(@"if(foo) { @foo[4].bar() }",
                           new StatementBlock(
                               Factory.Code("if(foo) { ").AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.Code("foo[4].bar()")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)
                                   ),
                               Factory.Code(" }").AsStatement()
                               ));
        }

        [Fact]
        public void ParseBlockTreatsDoubleAtSignAsEscapeSequenceIfAtStatementStart()
        {
            // Arrange
            ParseBlockTest(@"if(foo) { @@class.Foo() }",
                           new StatementBlock(
                               Factory.Code("if(foo) { ").AsStatement(),
                               Factory.Code("@").Hidden(),
                               Factory.Code("@class.Foo() }").AsStatement()
                               ));
        }

        [Fact]
        public void ParseBlockTreatsAtSignsAfterFirstPairAsPartOfCSharpStatement()
        {
            // Arrange
            ParseBlockTest(@"if(foo) { @@@@class.Foo() }",
                           new StatementBlock(
                               Factory.Code("if(foo) { ").AsStatement(),
                               Factory.Code("@").Hidden(),
                               Factory.Code("@@@class.Foo() }").AsStatement()
                               ));
        }

        [Fact]
        public void ParseBlockDoesNotParseMarkupStatementOrExpressionOnSwitchCharacterNotFollowedByOpenAngleOrColon()
        {
            // Arrange
            ParseBlockTest("if(foo) { @\"Foo\".ToString(); }",
                           new StatementBlock(
                               Factory.Code("if(foo) { @\"Foo\".ToString(); }").AsStatement()));
        }

        [Fact]
        public void ParsersCanNestRecursively()
        {
            // Arrange
            ParseBlockTest("foreach(var c in db.Categories) {" + Environment.NewLine
                         + "            <div>" + Environment.NewLine
                         + "                <h1>@c.Name</h1>" + Environment.NewLine
                         + "                <ul>" + Environment.NewLine
                         + "                    @foreach(var p in c.Products) {" + Environment.NewLine
                         + "                        <li><a href=\"@Html.ActionUrl(\"Products\", \"Detail\", new { id = p.Id })\">@p.Name</a></li>" + Environment.NewLine
                         + "                    }" + Environment.NewLine
                         + "                </ul>" + Environment.NewLine
                         + "            </div>" + Environment.NewLine
                         + "        }",
                new StatementBlock(
                    Factory.Code("foreach(var c in db.Categories) {\r\n").AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("            <div>\r\n                <h1>"),
                        new ExpressionBlock(
                            Factory.CodeTransition(),
                            Factory.Code("c.Name")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        Factory.Markup("</h1>\r\n                <ul>\r\n"),
                        new StatementBlock(
                            Factory.Code(@"                    ").AsStatement(),
                            Factory.CodeTransition(),
                            Factory.Code("foreach(var p in c.Products) {\r\n").AsStatement(),
                            new MarkupBlock(
                                Factory.Markup("                        <li><a"),
                                new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href=\"", 193, 5, 30), new LocationTagged<string>("\"", 256, 5, 93)),
                                    Factory.Markup(" href=\"").With(SpanCodeGenerator.Null),
                                    new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 200, 5, 37), 200, 5, 37),
                                        new ExpressionBlock(
                                            Factory.CodeTransition(),
                                            Factory.Code("Html.ActionUrl(\"Products\", \"Detail\", new { id = p.Id })")
                                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                                   .Accepts(AcceptedCharacters.NonWhiteSpace))),
                                    Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                                Factory.Markup(">"),
                                new ExpressionBlock(
                                    Factory.CodeTransition(),
                                    Factory.Code("p.Name")
                                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                           .Accepts(AcceptedCharacters.NonWhiteSpace)),
                                Factory.Markup("</a></li>\r\n").Accepts(AcceptedCharacters.None)),
                            Factory.Code("                    }\r\n").AsStatement().Accepts(AcceptedCharacters.None)),
                        Factory.Markup("                </ul>\r\n            </div>\r\n")
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code("        }").AsStatement().Accepts(AcceptedCharacters.None)));
        }

        private void RunRazorCommentBetweenClausesTest(string preComment, string postComment, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
        {
            ParseBlockTest(preComment + "@* Foo *@ @* Bar *@" + postComment,
                           new StatementBlock(
                               Factory.Code(preComment).AsStatement(),
                               new CommentBlock(
                                   Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                   Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                   Factory.Comment(" Foo ", CSharpSymbolType.RazorComment),
                                   Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                   Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                   ),
                               Factory.Code(" ").AsStatement(),
                               new CommentBlock(
                                   Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                   Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                   Factory.Comment(" Bar ", CSharpSymbolType.RazorComment),
                                   Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                   Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                   ),
                               Factory.Code(postComment).AsStatement().Accepts(acceptedCharacters)));
        }

        private void RunSimpleWrappedMarkupTest(string prefix, string markup, string suffix, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
        {
            ParseBlockTest(prefix + markup + suffix,
                           new StatementBlock(
                               Factory.Code(prefix).AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(markup).Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code(suffix).AsStatement().Accepts(acceptedCharacters)
                               ));
        }

        private void NamespaceImportTest(string content, string expectedNS, AcceptedCharacters acceptedCharacters = AcceptedCharacters.None, string errorMessage = null, SourceLocation? location = null)
        {
            var errors = new RazorError[0];
            if (!String.IsNullOrEmpty(errorMessage) && location.HasValue)
            {
                errors = new RazorError[]
                {
                    new RazorError(errorMessage, location.Value)
                };
            }
            ParseBlockTest(content,
                           new DirectiveBlock(
                               Factory.Code(content)
                                   .AsNamespaceImport(expectedNS, CSharpCodeParser.UsingKeywordLength)
                                   .Accepts(acceptedCharacters)),
                           errors);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpDirectivesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpDirectivesTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void InheritsDirective()
        {
            ParseBlockTest("@inherits System.Web.WebPages.WebPage",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(SyntaxConstants.CSharp.InheritsKeyword + " ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("System.Web.WebPages.WebPage")
                           .AsBaseType("System.Web.WebPages.WebPage")));
        }

        [Fact]
        public void InheritsDirectiveSupportsArrays()
        {
            ParseBlockTest("@inherits string[[]][]",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(SyntaxConstants.CSharp.InheritsKeyword + " ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("string[[]][]")
                           .AsBaseType("string[[]][]")));
        }

        [Fact]
        public void InheritsDirectiveSupportsNestedGenerics()
        {
            ParseBlockTest("@inherits System.Web.Mvc.WebViewPage<IEnumerable<MvcApplication2.Models.RegisterModel>>",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(SyntaxConstants.CSharp.InheritsKeyword + " ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("System.Web.Mvc.WebViewPage<IEnumerable<MvcApplication2.Models.RegisterModel>>")
                           .AsBaseType("System.Web.Mvc.WebViewPage<IEnumerable<MvcApplication2.Models.RegisterModel>>")));
        }

        [Fact]
        public void InheritsDirectiveSupportsTypeKeywords()
        {
            ParseBlockTest("@inherits string",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(SyntaxConstants.CSharp.InheritsKeyword + " ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("string")
                           .AsBaseType("string")));
        }

        [Fact]
        public void InheritsDirectiveSupportsVSTemplateTokens()
        {
            ParseBlockTest("@inherits $rootnamespace$.MyBase",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(SyntaxConstants.CSharp.InheritsKeyword + " ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("$rootnamespace$.MyBase")
                           .AsBaseType("$rootnamespace$.MyBase")));
        }

        [Fact]
        public void SessionStateDirectiveWorks()
        {
            ParseBlockTest("@sessionstate InProc",
                           new DirectiveBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode(SyntaxConstants.CSharp.SessionStateKeyword + " ")
                                   .Accepts(AcceptedCharacters.None),
                               Factory.Code("InProc")
                                      .AsRazorDirectiveAttribute("sessionstate", "InProc")
                               ));
        }

        [Fact]
        public void SessionStateDirectiveParsesInvalidSessionValue()
        {
            ParseBlockTest("@sessionstate Blah",
                           new DirectiveBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode(SyntaxConstants.CSharp.SessionStateKeyword + " ")
                                   .Accepts(AcceptedCharacters.None),
                               Factory.Code("Blah")
                                   .AsRazorDirectiveAttribute("sessionstate", "Blah")
                               ));
        }

        [Fact]
        public void FunctionsDirective()
        {
            ParseBlockTest("@functions { foo(); bar(); }",
                new FunctionsBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(SyntaxConstants.CSharp.FunctionsKeyword + " {")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code(" foo(); bar(); ")
                           .AsFunctionsBody(),
                    Factory.MetaCode("}")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void EmptyFunctionsDirective()
        {
            ParseBlockTest("@functions { }",
                new FunctionsBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(SyntaxConstants.CSharp.FunctionsKeyword + " {")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code(" ")
                           .AsFunctionsBody(),
                    Factory.MetaCode("}")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void SectionDirective()
        {
            ParseBlockTest("@section Header { <p>F{o}o</p> }",
                new SectionBlock(new SectionCodeGenerator("Header"),
                    Factory.CodeTransition(),
                    Factory.MetaCode("section Header {")
                           .AutoCompleteWith(null, atEndOfSpan: true)
                           .Accepts(AcceptedCharacters.Any),
                    new MarkupBlock(
                        Factory.Markup(" <p>F", "{", "o", "}", "o", "</p> ")),
                    Factory.MetaCode("}")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void HelperDirective()
        {
            ParseBlockTest("@helper Strong(string value) { foo(); }",
                new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Strong(string value) {", new SourceLocation(8, 0, 8)), headerComplete: true),
                    Factory.CodeTransition(),
                    Factory.MetaCode("helper ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Strong(string value) {")
                           .Hidden()
                           .Accepts(AcceptedCharacters.None),
                    new StatementBlock(
                        Factory.Code(" foo(); ")
                               .AsStatement()
                               .With(new StatementCodeGenerator())),
                    Factory.Code("}")
                           .Hidden()
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpErrorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpErrorTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseBlockHandlesQuotesAfterTransition()
        {
            ParseBlockTest("@\"",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.EmptyCSharp()
                                   .AsImplicitExpression(KeywordSet)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS, '"'),
                               1, 0, 1));
        }

        [Fact]
        public void ParseBlockCapturesWhitespaceToEndOfLineInInvalidUsingStatementAndTreatsAsFileCode()
        {
            ParseBlockTest("using          " + Environment.NewLine
                         + Environment.NewLine,
                           new StatementBlock(
                               Factory.Code("using          \r\n").AsStatement()
                               ));
        }

        [Fact]
        public void ParseBlockMethodOutputsOpenCurlyAsCodeSpanIfEofFoundAfterOpenCurlyBrace()
        {
            ParseBlockTest("{",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp()
                                   .AsStatement()
                                   .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = "}" })
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             RazorResources.BlockName_Code,
                                             "}", "{"),
                               SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockMethodOutputsZeroLengthCodeSpanIfStatementBlockEmpty()
        {
            ParseBlockTest("{}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp().AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockMethodProducesErrorIfNewlineFollowsTransition()
        {
            ParseBlockTest("@" + Environment.NewLine,
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.EmptyCSharp()
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                           new RazorError(RazorResources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_CS, new SourceLocation(1, 0, 1)));
        }

        [Fact]
        public void ParseBlockMethodProducesErrorIfWhitespaceBetweenTransitionAndBlockStartInEmbeddedExpression()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    @   {}" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    ").AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.EmptyCSharp()
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                               Factory.Code("   {}\r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ),
                           new RazorError(RazorResources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_CS, 8, 1, 5));
        }

        [Fact]
        public void ParseBlockMethodProducesErrorIfEOFAfterTransitionInEmbeddedExpression()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    @",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    ").AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.EmptyCSharp()
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                               Factory.EmptyCSharp().AsStatement()
                               ),
                           new RazorError(RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock, 8, 1, 5),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, RazorResources.BlockName_Code, "}", "{"),
                               SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockMethodParsesNothingIfFirstCharacterIsNotIdentifierStartOrParenOrBrace()
        {
            ParseBlockTest("@!!!",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.EmptyCSharp()
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS, "!"),
                               1, 0, 1));
        }

        [Fact]
        public void ParseBlockShouldReportErrorAndTerminateAtEOFIfIfParenInExplicitExpressionUnclosed()
        {
            ParseBlockTest("(foo bar" + Environment.NewLine
                         + "baz",
                           new ExpressionBlock(
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("foo bar\r\nbaz").AsExpression()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             RazorResources.BlockName_ExplicitExpression, ')', '('),
                               new SourceLocation(0, 0, 0)));
        }

        [Fact]
        public void ParseBlockShouldReportErrorAndTerminateAtMarkupIfIfParenInExplicitExpressionUnclosed()
        {
            ParseBlockTest("(foo bar" + Environment.NewLine
                         + "<html>" + Environment.NewLine
                         + "baz" + Environment.NewLine
                         + "</html",
                           new ExpressionBlock(
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("foo bar\r\n").AsExpression()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             RazorResources.BlockName_ExplicitExpression, ')', '('),
                               new SourceLocation(0, 0, 0)));
        }

        [Fact]
        public void ParseBlockCorrectlyHandlesInCorrectTransitionsIfImplicitExpressionParensUnclosed()
        {
            ParseBlockTest("Href(" + Environment.NewLine
                         + "<h1>@Html.Foo(Bar);</h1>" + Environment.NewLine,
                           new ExpressionBlock(
                               Factory.Code("Href(\r\n")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "(", ")"),
                               new SourceLocation(4, 0, 4)));
        }

        [Fact]
        // Test for fix to Dev10 884975 - Incorrect Error Messaging
        public void ParseBlockShouldReportErrorAndTerminateAtEOFIfParenInImplicitExpressionUnclosed()
        {
            ParseBlockTest("Foo(Bar(Baz)" + Environment.NewLine
                         + "Biz" + Environment.NewLine
                         + "Boz",
                           new ExpressionBlock(
                               Factory.Code("Foo(Bar(Baz)\r\nBiz\r\nBoz")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               ),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                                        "(", ")"),
                                          new SourceLocation(3, 0, 3)));
        }

        [Fact]
        // Test for fix to Dev10 884975 - Incorrect Error Messaging
        public void ParseBlockShouldReportErrorAndTerminateAtMarkupIfParenInImplicitExpressionUnclosed()
        {
            ParseBlockTest("Foo(Bar(Baz)" + Environment.NewLine
                         + "Biz" + Environment.NewLine
                         + "<html>" + Environment.NewLine
                         + "Boz" + Environment.NewLine
                         + "</html>",
                           new ExpressionBlock(
                               Factory.Code("Foo(Bar(Baz)\r\nBiz\r\n")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               ),
                           new RazorError(String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                                        "(", ")"),
                                          new SourceLocation(3, 0, 3)));
        }

        [Fact]
        // Test for fix to Dev10 884975 - Incorrect Error Messaging
        public void ParseBlockShouldReportErrorAndTerminateAtEOFIfBracketInImplicitExpressionUnclosed()
        {
            ParseBlockTest("Foo[Bar[Baz]" + Environment.NewLine
                         + "Biz" + Environment.NewLine
                         + "Boz",
                           new ExpressionBlock(
                               Factory.Code("Foo[Bar[Baz]\r\nBiz\r\nBoz")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "[", "]"),
                               new SourceLocation(3, 0, 3)));
        }

        [Fact]
        // Test for fix to Dev10 884975 - Incorrect Error Messaging
        public void ParseBlockShouldReportErrorAndTerminateAtMarkupIfBracketInImplicitExpressionUnclosed()
        {
            ParseBlockTest("Foo[Bar[Baz]" + Environment.NewLine
                         + "Biz" + Environment.NewLine
                         + "<b>" + Environment.NewLine
                         + "Boz" + Environment.NewLine
                         + "</b>",
                           new ExpressionBlock(
                               Factory.Code("Foo[Bar[Baz]\r\nBiz\r\n")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "[", "]"),
                               new SourceLocation(3, 0, 3)));
        }

        // Simple EOF handling errors:
        [Fact]
        public void ParseBlockReportsErrorIfExplicitCodeBlockUnterminatedAtEOF()
        {
            ParseBlockTest("{ var foo = bar; if(foo != null) { bar(); } ",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" var foo = bar; if(foo != null) { bar(); } ").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             RazorResources.BlockName_Code, '}', '{'),
                               SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockReportsErrorIfClassBlockUnterminatedAtEOF()
        {
            ParseBlockTest("functions { var foo = bar; if(foo != null) { bar(); } ",
                           new FunctionsBlock(
                               Factory.MetaCode("functions {").Accepts(AcceptedCharacters.None),
                               Factory.Code(" var foo = bar; if(foo != null) { bar(); } ").AsFunctionsBody()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             "functions", '}', '{'),
                               SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockReportsErrorIfIfBlockUnterminatedAtEOF()
        {
            RunUnterminatedSimpleKeywordBlock("if");
        }

        [Fact]
        public void ParseBlockReportsErrorIfElseBlockUnterminatedAtEOF()
        {
            ParseBlockTest("if(foo) { baz(); } else { var foo = bar; if(foo != null) { bar(); } ",
                           new StatementBlock(
                               Factory.Code("if(foo) { baz(); } else { var foo = bar; if(foo != null) { bar(); } ").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             "else", '}', '{'),
                               new SourceLocation(19, 0, 19)));
        }

        [Fact]
        public void ParseBlockReportsErrorIfElseIfBlockUnterminatedAtEOF()
        {
            ParseBlockTest("if(foo) { baz(); } else if { var foo = bar; if(foo != null) { bar(); } ",
                           new StatementBlock(
                               Factory.Code("if(foo) { baz(); } else if { var foo = bar; if(foo != null) { bar(); } ").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             "else if", '}', '{'),
                               new SourceLocation(19, 0, 19)));
        }

        [Fact]
        public void ParseBlockReportsErrorIfDoBlockUnterminatedAtEOF()
        {
            ParseBlockTest("do { var foo = bar; if(foo != null) { bar(); } ",
                           new StatementBlock(
                               Factory.Code("do { var foo = bar; if(foo != null) { bar(); } ").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             "do", '}', '{'),
                               SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockReportsErrorIfTryBlockUnterminatedAtEOF()
        {
            ParseBlockTest("try { var foo = bar; if(foo != null) { bar(); } ",
                           new StatementBlock(
                               Factory.Code("try { var foo = bar; if(foo != null) { bar(); } ").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             "try", '}', '{'),
                               SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockReportsErrorIfCatchBlockUnterminatedAtEOF()
        {
            ParseBlockTest("try { baz(); } catch(Foo) { var foo = bar; if(foo != null) { bar(); } ",
                           new StatementBlock(
                               Factory.Code("try { baz(); } catch(Foo) { var foo = bar; if(foo != null) { bar(); } ").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             "catch", '}', '{'),
                               new SourceLocation(15, 0, 15)));
        }

        [Fact]
        public void ParseBlockReportsErrorIfFinallyBlockUnterminatedAtEOF()
        {
            ParseBlockTest("try { baz(); } finally { var foo = bar; if(foo != null) { bar(); } ",
                           new StatementBlock(
                               Factory.Code("try { baz(); } finally { var foo = bar; if(foo != null) { bar(); } ").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             "finally", '}', '{'),
                               new SourceLocation(15, 0, 15)));
        }

        [Fact]
        public void ParseBlockReportsErrorIfForBlockUnterminatedAtEOF()
        {
            RunUnterminatedSimpleKeywordBlock("for");
        }

        [Fact]
        public void ParseBlockReportsErrorIfForeachBlockUnterminatedAtEOF()
        {
            RunUnterminatedSimpleKeywordBlock("foreach");
        }

        [Fact]
        public void ParseBlockReportsErrorIfWhileBlockUnterminatedAtEOF()
        {
            RunUnterminatedSimpleKeywordBlock("while");
        }

        [Fact]
        public void ParseBlockReportsErrorIfSwitchBlockUnterminatedAtEOF()
        {
            RunUnterminatedSimpleKeywordBlock("switch");
        }

        [Fact]
        public void ParseBlockReportsErrorIfLockBlockUnterminatedAtEOF()
        {
            RunUnterminatedSimpleKeywordBlock("lock");
        }

        [Fact]
        public void ParseBlockReportsErrorIfUsingBlockUnterminatedAtEOF()
        {
            RunUnterminatedSimpleKeywordBlock("using");
        }

        [Fact]
        public void ParseBlockRequiresControlFlowStatementsToHaveBraces()
        {
            string expectedMessage = String.Format(RazorResources.ParseError_SingleLine_ControlFlowStatements_Not_Allowed, "{", "<");
            ParseBlockTest("if(foo) <p>Bar</p> else if(bar) <p>Baz</p> else <p>Boz</p>",
                           new StatementBlock(
                               Factory.Code("if(foo) ").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("<p>Bar</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("else if(bar) ").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("<p>Baz</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("else ").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("<p>Boz</p>").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.EmptyCSharp().AsStatement()
                               ),
                           new RazorError(expectedMessage, 8, 0, 8),
                           new RazorError(expectedMessage, 32, 0, 32),
                           new RazorError(expectedMessage, 48, 0, 48));
        }

        [Fact]
        public void ParseBlockIncludesUnexpectedCharacterInSingleStatementControlFlowStatementError()
        {
            ParseBlockTest("if(foo)) { var bar = foo; }",
                           new StatementBlock(
                               Factory.Code("if(foo)) { var bar = foo; }").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_SingleLine_ControlFlowStatements_Not_Allowed,
                                             "{", ")"),
                               new SourceLocation(7, 0, 7)));
        }

        [Fact]
        public void ParseBlockOutputsErrorIfAtSignFollowedByLessThanSignAtStatementStart()
        {
            ParseBlockTest("if(foo) { @<p>Bar</p> }",
                           new StatementBlock(
                               Factory.Code("if(foo) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" "),
                                   Factory.MarkupTransition(),
                                   Factory.Markup("<p>Bar</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("}").AsStatement()
                               ),
                           new RazorError(
                               RazorResources.ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start,
                               10, 0, 10));
        }

        [Fact]
        public void ParseBlockTerminatesIfBlockAtEOLWhenRecoveringFromMissingCloseParen()
        {
            ParseBlockTest("if(foo bar" + Environment.NewLine
                         + "baz",
                           new StatementBlock(
                               Factory.Code("if(foo bar\r\n").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "(", ")"),
                               new SourceLocation(2, 0, 2)));
        }

        [Fact]
        public void ParseBlockTerminatesForeachBlockAtEOLWhenRecoveringFromMissingCloseParen()
        {
            ParseBlockTest("foreach(foo bar" + Environment.NewLine
                         + "baz",
                           new StatementBlock(
                               Factory.Code("foreach(foo bar\r\n").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "(", ")"),
                               new SourceLocation(7, 0, 7)));
        }

        [Fact]
        public void ParseBlockTerminatesWhileClauseInDoStatementAtEOLWhenRecoveringFromMissingCloseParen()
        {
            ParseBlockTest("do { } while(foo bar" + Environment.NewLine
                         + "baz",
                           new StatementBlock(
                               Factory.Code("do { } while(foo bar\r\n").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "(", ")"),
                               new SourceLocation(12, 0, 12)));
        }

        [Fact]
        public void ParseBlockTerminatesUsingBlockAtEOLWhenRecoveringFromMissingCloseParen()
        {
            ParseBlockTest("using(foo bar" + Environment.NewLine
                         + "baz",
                           new StatementBlock(
                               Factory.Code("using(foo bar\r\n").AsStatement()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "(", ")"),
                               new SourceLocation(5, 0, 5)));
        }

        [Fact]
        public void ParseBlockResumesIfStatementAfterOpenParen()
        {
            ParseBlockTest("if(" + Environment.NewLine
                         + "else { <p>Foo</p> }",
                           new StatementBlock(
                               Factory.Code("if(\r\nelse {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Foo</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("}").AsStatement().Accepts(AcceptedCharacters.None)
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF,
                                             "(", ")"),
                               new SourceLocation(2, 0, 2)));
        }

        [Fact]
        public void ParseBlockTerminatesNormalCSharpStringsAtEOLIfEndQuoteMissing()
        {
            SingleSpanBlockTest("if(foo) {" + Environment.NewLine
                              + "    var p = \"foo bar baz" + Environment.NewLine
                              + ";" + Environment.NewLine
                              + "}",
                                BlockType.Statement, SpanKind.Code,
                                new RazorError(RazorResources.ParseError_Unterminated_String_Literal, 23, 1, 12));
        }

        [Fact]
        public void ParseBlockTerminatesNormalStringAtEndOfFile()
        {
            SingleSpanBlockTest("if(foo) { var foo = \"blah blah blah blah blah", BlockType.Statement, SpanKind.Code,
                                new RazorError(RazorResources.ParseError_Unterminated_String_Literal, 20, 0, 20),
                                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "if", '}', '{'), SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockTerminatesVerbatimStringAtEndOfFile()
        {
            SingleSpanBlockTest("if(foo) { var foo = @\"blah " + Environment.NewLine
                              + "blah; " + Environment.NewLine
                              + "<p>Foo</p>" + Environment.NewLine
                              + "blah " + Environment.NewLine
                              + "blah",
                                BlockType.Statement, SpanKind.Code,
                                new RazorError(RazorResources.ParseError_Unterminated_String_Literal, 20, 0, 20),
                                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "if", '}', '{'), SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockCorrectlyParsesMarkupIncorrectyAssumedToBeWithinAStatement()
        {
            ParseBlockTest("if(foo) {" + Environment.NewLine
                         + "    var foo = \"foo bar baz" + Environment.NewLine
                         + "    <p>Foo is @foo</p>" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.Code("if(foo) {\r\n    var foo = \"foo bar baz\r\n    ").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("<p>Foo is "),
                                   new ExpressionBlock(
                                       Factory.CodeTransition(),
                                       Factory.Code("foo")
                                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                           .Accepts(AcceptedCharacters.NonWhiteSpace)),
                                   Factory.Markup("</p>\r\n").Accepts(AcceptedCharacters.None)),
                               Factory.Code("}").AsStatement()
                               ),
                           new RazorError(
                               RazorResources.ParseError_Unterminated_String_Literal,
                               25, 1, 14));
        }

        [Fact]
        public void ParseBlockCorrectlyParsesAtSignInDelimitedBlock()
        {
            ParseBlockTest("(Request[\"description\"] ?? @photo.Description)",
                           new ExpressionBlock(
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("Request[\"description\"] ?? @photo.Description").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockCorrectlyRecoversFromMissingCloseParenInExpressionWithinCode()
        {
            ParseBlockTest(@"{String.Format(<html></html>}",
                new StatementBlock(
                    Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                    Factory.Code("String.Format(")
                           .AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("<html></html>").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyCSharp().AsStatement(),
                    Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                expectedErrors: new[] {
                    new RazorError(
                        String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF, "(", ")"),
                        14, 0, 14)
                });

        }

        private void RunUnterminatedSimpleKeywordBlock(string keyword)
        {
            SingleSpanBlockTest(keyword + " (foo) { var foo = bar; if(foo != null) { bar(); } ", BlockType.Statement, SpanKind.Code,
                                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, keyword, '}', '{'), SourceLocation.Zero));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpExplicitExpressionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpExplicitExpressionTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseBlockShouldOutputZeroLengthCodeSpanIfExplicitExpressionIsEmpty()
        {
            ParseBlockTest("@()",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp().AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldOutputZeroLengthCodeSpanIfEOFOccursAfterStartOfExplicitExpression()
        {
            ParseBlockTest("@(",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp().AsExpression()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                                             RazorResources.BlockName_ExplicitExpression,
                                             ")", "("),
                               new SourceLocation(1, 0, 1)));
        }

        [Fact]
        public void ParseBlockShouldAcceptEscapedQuoteInNonVerbatimStrings()
        {
            ParseBlockTest("@(\"\\\"\")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("\"\\\"\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldAcceptEscapedQuoteInVerbatimStrings()
        {
            ParseBlockTest("@(@\"\"\"\")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("@\"\"\"\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldAcceptMultipleRepeatedEscapedQuoteInVerbatimStrings()
        {
            ParseBlockTest("@(@\"\"\"\"\"\")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("@\"\"\"\"\"\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldAcceptMultiLineVerbatimStrings()
        {
            ParseBlockTest(@"@(@""" + Environment.NewLine
                         + @"Foo" + Environment.NewLine
                         + @"Bar" + Environment.NewLine
                         + @"Baz" + Environment.NewLine
                         + @""")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("@\"\r\nFoo\r\nBar\r\nBaz\r\n\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldAcceptMultipleEscapedQuotesInNonVerbatimStrings()
        {
            ParseBlockTest("@(\"\\\"hello, world\\\"\")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("\"\\\"hello, world\\\"\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldAcceptMultipleEscapedQuotesInVerbatimStrings()
        {
            ParseBlockTest("@(@\"\"\"hello, world\"\"\")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("@\"\"\"hello, world\"\"\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldAcceptConsecutiveEscapedQuotesInNonVerbatimStrings()
        {
            ParseBlockTest("@(\"\\\"\\\"\")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("\"\\\"\\\"\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockShouldAcceptConsecutiveEscapedQuotesInVerbatimStrings()
        {
            ParseBlockTest("@(@\"\"\"\"\"\")",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("@\"\"\"\"\"\"").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpHelperTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void ParseHelperCorrectlyParsesHelperWithNoSpaceInBody()
        {
            ParseDocumentTest("@helper Foo(){@Bar()}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(){", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(){").Hidden().Accepts(AcceptedCharacters.None),
                        new StatementBlock(
                            Factory.EmptyCSharp().AsStatement(),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("Bar()")
                                    .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                    .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            Factory.EmptyCSharp().AsStatement()),
                        Factory.Code("}").Hidden().Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseHelperCorrectlyParsesIncompleteHelperPreceedingCodeBlock()
        {
            ParseDocumentTest("@helper" + Environment.NewLine
                            + "@{}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper")),
                    Factory.Markup("\r\n"),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        Factory.EmptyCSharp().AsStatement(),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        RazorResources.ErrorComponent_Newline),
                    7, 0, 7));
        }

        [Fact]
        public void ParseHelperRequiresSpaceBeforeSignature()
        {
            ParseDocumentTest("@helper{",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper")),
                    Factory.Markup("{")),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        String.Format(RazorResources.ErrorComponent_Character, "{")),
                    7, 0, 7));
        }

        [Fact]
        public void ParseHelperOutputsErrorButContinuesIfLParenFoundAfterHelperKeyword()
        {
            ParseDocumentTest("@helper () {",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("() {", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("() {").Hidden().Accepts(AcceptedCharacters.None),
                        new StatementBlock(
                            Factory.EmptyCSharp()
                                   .AsStatement()
                                   .AutoCompleteWith("}")))),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        String.Format(RazorResources.ErrorComponent_Character, "(")),
                    8, 0, 8),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                        "helper", "}", "{"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseHelperStatementOutputsMarkerHelperHeaderSpanOnceKeywordComplete()
        {
            ParseDocumentTest("@helper ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>(String.Empty, 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.EmptyCSharp().Hidden())),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        RazorResources.ErrorComponent_EndOfFile),
                    8, 0, 8));
        }

        [Fact]
        public void ParseHelperStatementMarksHelperSpanAsCanGrowIfMissingTrailingSpace()
        {
            ParseDocumentTest("@helper",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper").Accepts(AcceptedCharacters.Any))),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        RazorResources.ErrorComponent_EndOfFile),
                    7, 0, 7));
        }

        [Fact]
        public void ParseHelperStatementCapturesWhitespaceToEndOfLineIfHelperStatementMissingName()
        {
            ParseDocumentTest("@helper                       " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("                      ", 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("                      \r\n").Hidden()),
                    Factory.Markup(@"    ")),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        RazorResources.ErrorComponent_Newline),
                    30, 0, 30));
        }

        [Fact]
        public void ParseHelperStatementCapturesWhitespaceToEndOfLineIfHelperStatementMissingOpenParen()
        {
            ParseDocumentTest("@helper Foo    " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo    ", 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo    \r\n").Hidden()),
                    Factory.Markup("    ")),
                new RazorError(
                    String.Format(RazorResources.ParseError_MissingCharAfterHelperName, "("),
                    15, 0, 15));
        }

        [Fact]
        public void ParseHelperStatementCapturesAllContentToEndOfFileIfHelperStatementMissingCloseParenInParameterList()
        {
            ParseDocumentTest("@helper Foo(Foo Bar" + Environment.NewLine
                            + "Biz" + Environment.NewLine
                            + "Boz",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(Foo Bar\r\nBiz\r\nBoz", 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(Foo Bar\r\nBiz\r\nBoz").Hidden())),
                new RazorError(
                    RazorResources.ParseError_UnterminatedHelperParameterList,
                    11, 0, 11));
        }

        [Fact]
        public void ParseHelperStatementCapturesWhitespaceToEndOfLineIfHelperStatementMissingOpenBraceAfterParameterList()
        {
            ParseDocumentTest("@helper Foo(string foo)    " + Environment.NewLine,
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo)    ", 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(string foo)    \r\n").Hidden())),
                new RazorError(
                    String.Format(RazorResources.ParseError_MissingCharAfterHelperParameters, "{"),
                    29, 1, 0));
        }

        [Fact]
        public void ParseHelperStatementContinuesParsingHelperUntilEOF()
        {
            ParseDocumentTest("@helper Foo(string foo) {    " + Environment.NewLine
                            + "    <p>Foo</p>",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo) {", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code(@"Foo(string foo) {").Hidden().Accepts(AcceptedCharacters.None),
                        new StatementBlock(
                            Factory.Code("    \r\n")
                                   .AsStatement()
                                   .AutoCompleteWith("}"),
                            new MarkupBlock(
                                Factory.Markup("    <p>Foo</p>").Accepts(AcceptedCharacters.None)),
                            Factory.EmptyCSharp().AsStatement()))),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                        "helper", "}", "{"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseHelperStatementCorrectlyParsesHelperWithEmbeddedCode()
        {
            ParseDocumentTest("@helper Foo(string foo) {    " + Environment.NewLine
                            + "    <p>@foo</p>" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo) {", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code(@"Foo(string foo) {").Hidden().Accepts(AcceptedCharacters.None),
                        new StatementBlock(
                            Factory.Code("    \r\n").AsStatement(),
                            new MarkupBlock(
                                Factory.Markup("    <p>"),
                                new ExpressionBlock(
                                    Factory.CodeTransition(),
                                    Factory.Code("foo")
                                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                           .Accepts(AcceptedCharacters.NonWhiteSpace)),
                                Factory.Markup("</p>\r\n").Accepts(AcceptedCharacters.None)),
                            Factory.EmptyCSharp().AsStatement()),
                        Factory.Code("}").Hidden().Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseHelperStatementCorrectlyParsesHelperWithNewlinesBetweenCloseParenAndOpenBrace()
        {
            ParseDocumentTest("@helper Foo(string foo)" + Environment.NewLine
                            + Environment.NewLine
                            + Environment.NewLine
                            + Environment.NewLine
                            + "{    " + Environment.NewLine
                            + "    <p>@foo</p>" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo)\r\n\r\n\r\n\r\n{", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(string foo)\r\n\r\n\r\n\r\n{").Hidden().Accepts(AcceptedCharacters.None),
                        new StatementBlock(
                            Factory.Code("    \r\n").AsStatement(),
                            new MarkupBlock(
                                Factory.Markup(@"    <p>"),
                                new ExpressionBlock(
                                    Factory.CodeTransition(),
                                    Factory.Code("foo")
                                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                           .Accepts(AcceptedCharacters.NonWhiteSpace)),
                                Factory.Markup("</p>\r\n").Accepts(AcceptedCharacters.None)),
                            Factory.EmptyCSharp().AsStatement()),
                        Factory.Code("}").Hidden().Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseHelperStatementGivesWhitespaceAfterOpenBraceToMarkupInDesignMode()
        {
            ParseDocumentTest("@helper Foo(string foo) {    " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo) {", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code(@"Foo(string foo) {").Hidden().Accepts(AcceptedCharacters.None),
                        new StatementBlock(
                            Factory.Code("    \r\n    ")
                                   .AsStatement()
                                   .AutoCompleteWith("}")))),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(
                        String.Format(
                            RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, 
                            "helper", "}", "{"),
                        new SourceLocation(1, 0, 1))
                });
        }

        [Fact]
        public void ParseHelperAcceptsNestedHelpersButOutputsError()
        {
            ParseDocumentTest(@"@helper Foo(string foo) {" + Environment.NewLine
                            + "    @helper Bar(string baz) {" + Environment.NewLine
                            + "    }" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo) {", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code(@"Foo(string foo) {").Hidden().Accepts(AcceptedCharacters.None),
                        new StatementBlock(
                            Factory.Code("\r\n    ").AsStatement(),
                            new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Bar(string baz) {", 39, 1, 12), headerComplete: true),
                                Factory.CodeTransition(),
                                Factory.MetaCode("helper ").Accepts(AcceptedCharacters.None),
                                Factory.Code(@"Bar(string baz) {").Hidden().Accepts(AcceptedCharacters.None),
                                new StatementBlock(
                                    Factory.Code("\r\n    ").AsStatement()),
                                Factory.Code("}").Hidden().Accepts(AcceptedCharacters.None)),
                            Factory.Code("\r\n").AsStatement()),
                        Factory.Code("}").Hidden().Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(RazorResources.ParseError_Helpers_Cannot_Be_Nested, 38, 1, 11)
                });
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpImplicitExpressionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpImplicitExpressionTest : CsHtmlCodeParserTestBase
    {
        private const string TestExtraKeyword = "model";

        public override ParserBase CreateCodeParser()
        {
            return new CSharpCodeParser();
        }

        [Fact]
        public void NestedImplicitExpression()
        {
            ParseBlockTest("if (true) { @foo }",
                           new StatementBlock(
                               Factory.Code("if (true) { ").AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.Code("foo")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                               Factory.Code(" }").AsStatement()));
        }

        [Fact]
        public void ParseBlockAcceptsNonEnglishCharactersThatAreValidIdentifiers()
        {
            ImplicitExpressionTest("हळूँजद॔.", "हळूँजद॔");
        }

        [Fact]
        public void ParseBlockOutputsZeroLengthCodeSpanIfInvalidCharacterFollowsTransition()
        {
            ParseBlockTest("@/",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.EmptyCSharp()
                                   .AsImplicitExpression(KeywordSet)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS, "/"),
                               new SourceLocation(1, 0, 1)));
        }

        [Fact]
        public void ParseBlockOutputsZeroLengthCodeSpanIfEOFOccursAfterTransition()
        {
            ParseBlockTest("@",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.EmptyCSharp()
                                   .AsImplicitExpression(KeywordSet)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                           new RazorError(
                               RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock,
                               new SourceLocation(1, 0, 1)));
        }

        [Fact]
        public void ParseBlockSupportsSlashesWithinComplexImplicitExpressions()
        {
            ImplicitExpressionTest("DataGridColumn.Template(\"Years of Service\", e => (int)Math.Round((DateTime.Now - dt).TotalDays / 365))");
        }

        [Fact]
        public void ParseBlockMethodParsesSingleIdentifierAsImplicitExpression()
        {
            ImplicitExpressionTest("foo");
        }

        [Fact]
        public void ParseBlockMethodDoesNotAcceptSemicolonIfExpressionTerminatedByWhitespace()
        {
            ImplicitExpressionTest("foo ;", "foo");
        }

        [Fact]
        public void ParseBlockMethodIgnoresSemicolonAtEndOfSimpleImplicitExpression()
        {
            RunTrailingSemicolonTest("foo");
        }

        [Fact]
        public void ParseBlockMethodParsesDottedIdentifiersAsImplicitExpression()
        {
            ImplicitExpressionTest("foo.bar.baz");
        }

        [Fact]
        public void ParseBlockMethodIgnoresSemicolonAtEndOfDottedIdentifiers()
        {
            RunTrailingSemicolonTest("foo.bar.baz");
        }

        [Fact]
        public void ParseBlockMethodDoesNotIncludeDotAtEOFInImplicitExpression()
        {
            ImplicitExpressionTest("foo.bar.", "foo.bar");
        }

        [Fact]
        public void ParseBlockMethodDoesNotIncludeDotFollowedByInvalidIdentifierCharacterInImplicitExpression()
        {
            ImplicitExpressionTest("foo.bar.0", "foo.bar");
            ImplicitExpressionTest("foo.bar.</p>", "foo.bar");
        }

        [Fact]
        public void ParseBlockMethodDoesNotIncludeSemicolonAfterDot()
        {
            ImplicitExpressionTest("foo.bar.;", "foo.bar");
        }

        [Fact]
        public void ParseBlockMethodTerminatesAfterIdentifierUnlessFollowedByDotOrParenInImplicitExpression()
        {
            ImplicitExpressionTest("foo.bar</p>", "foo.bar");
        }

        [Fact]
        public void ParseBlockProperlyParsesParenthesesAndBalancesThemInImplicitExpression()
        {
            ImplicitExpressionTest(@"foo().bar(""bi\""z"", 4)(""chained method; call"").baz(@""bo""""z"", '\'', () => { return 4; }, (4+5+new { foo = bar[4] }))");
        }

        [Fact]
        public void ParseBlockProperlyParsesBracketsAndBalancesThemInImplicitExpression()
        {
            ImplicitExpressionTest(@"foo.bar[4 * (8 + 7)][""fo\""o""].baz");
        }

        [Fact]
        public void ParseBlockTerminatesImplicitExpressionAtHtmlEndTag()
        {
            ImplicitExpressionTest("foo().bar.baz</p>zoop", "foo().bar.baz");
        }

        [Fact]
        public void ParseBlockTerminatesImplicitExpressionAtHtmlStartTag()
        {
            ImplicitExpressionTest("foo().bar.baz<p>zoop", "foo().bar.baz");
        }

        [Fact]
        public void ParseBlockTerminatesImplicitExpressionBeforeDotIfDotNotFollowedByIdentifierStartCharacter()
        {
            ImplicitExpressionTest("foo().bar.baz.42", "foo().bar.baz");
        }

        [Fact]
        public void ParseBlockStopsBalancingParenthesesAtEOF()
        {
            ImplicitExpressionTest("foo(()", "foo(()",
                                   acceptedCharacters: AcceptedCharacters.Any,
                                   errors: new RazorError(String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF, "(", ")"), new SourceLocation(4, 0, 4)));
        }

        [Fact]
        public void ParseBlockTerminatesImplicitExpressionIfCloseParenFollowedByAnyWhiteSpace()
        {
            ImplicitExpressionTest("foo.bar() (baz)", "foo.bar()");
        }

        [Fact]
        public void ParseBlockTerminatesImplicitExpressionIfIdentifierFollowedByAnyWhiteSpace()
        {
            ImplicitExpressionTest("foo .bar() (baz)", "foo");
        }

        [Fact]
        public void ParseBlockTerminatesImplicitExpressionAtLastValidPointIfDotFollowedByWhitespace()
        {
            ImplicitExpressionTest("foo. bar() (baz)", "foo");
        }

        [Fact]
        public void ParseBlockOutputExpressionIfModuleTokenNotFollowedByBrace()
        {
            ImplicitExpressionTest("module.foo()");
        }

        private void RunTrailingSemicolonTest(string expr)
        {
            ParseBlockTest(SyntaxConstants.TransitionString + expr + ";",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.Code(expr)
                                   .AsImplicitExpression(KeywordSet)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpLayoutDirectiveTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpLayoutDirectiveTest : CsHtmlCodeParserTestBase
    {
        [Theory]
        [InlineData("Layout")]
        [InlineData("LAYOUT")]
        [InlineData("layOut")]
        [InlineData("LayOut")]
        private void LayoutKeywordIsCaseSensitive(string word)
        {
            ParseBlockTest(word,
                new ExpressionBlock(
                    Factory.Code(word)
                        .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                        .Accepts(AcceptedCharacters.NonWhiteSpace)
                    ));
        }

        [Fact]
        public void LayoutDirectiveAcceptsAllTextToEndOfLine()
        {
            ParseBlockTest("@layout Foo Bar Baz",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("layout ").Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Foo Bar Baz")
                           .With(new SetLayoutCodeGenerator("Foo Bar Baz"))
                           .WithEditorHints(EditorHints.VirtualPath | EditorHints.LayoutPage)
                )
            );
        }

        [Fact]
        public void LayoutDirectiveAcceptsAnyIfNoWhitespaceFollowingLayoutKeyword()
        {
            ParseBlockTest("@layout",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("layout")
                )
            );
        }

        [Fact]
        public void LayoutDirectiveOutputsMarkerSpanIfAnyWhitespaceAfterLayoutKeyword()
        {
            ParseBlockTest("@layout ",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("layout ").Accepts(AcceptedCharacters.None),
                    Factory.EmptyCSharp()
                           .AsMetaCode()
                           .With(new SetLayoutCodeGenerator(String.Empty))
                           .WithEditorHints(EditorHints.VirtualPath | EditorHints.LayoutPage)
                )
            );
        }

        [Fact]
        public void LayoutDirectiveAcceptsTrailingNewlineButDoesNotIncludeItInLayoutPath()
        {
            ParseBlockTest("@layout Foo" + Environment.NewLine,
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("layout ").Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Foo\r\n")
                           .With(new SetLayoutCodeGenerator("Foo"))
                           .Accepts(AcceptedCharacters.None)
                           .WithEditorHints(EditorHints.VirtualPath | EditorHints.LayoutPage)
                )
            );
        }

        [Fact]
        public void LayoutDirectiveCorrectlyRestoresContextAfterCompleting()
        {
            ParseDocumentTest("@layout Foo" + Environment.NewLine
                            + "@foo",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new DirectiveBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("layout ").Accepts(AcceptedCharacters.None),
                        Factory.MetaCode("Foo\r\n")
                               .With(new SetLayoutCodeGenerator("Foo"))
                               .Accepts(AcceptedCharacters.None)
                               .WithEditorHints(EditorHints.VirtualPath | EditorHints.LayoutPage)
                    ),
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.EmptyHtml()));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpNestedStatementsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpNestedStatementsTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void NestedSimpleStatement()
        {
            ParseBlockTest("@while(true) { foo(); }",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("while(true) { foo(); }")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void NestedKeywordStatement()
        {
            ParseBlockTest("@while(true) { for(int i = 0; i < 10; i++) { foo(); } }",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("while(true) { for(int i = 0; i < 10; i++) { foo(); } }")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void NestedCodeBlock()
        {
            ParseBlockTest("@while(true) { { { { foo(); } } } }",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("while(true) { { { { foo(); } } } }")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void NestedImplicitExpression()
        {
            ParseBlockTest("@while(true) { @foo }",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("while(true) { ")
                           .AsStatement(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Code(" }")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void NestedExplicitExpression()
        {
            ParseBlockTest("@while(true) { @(foo) }",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("while(true) { ")
                           .AsStatement(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("(")
                               .Accepts(AcceptedCharacters.None),
                        Factory.Code("foo")
                               .AsExpression(),
                        Factory.MetaCode(")")
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code(" }")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void NestedMarkupBlock()
        {
            ParseBlockTest("@while(true) { <p>Hello</p> }",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("while(true) {")
                           .AsStatement(),
                    new MarkupBlock(
                        Factory.Markup(" <p>Hello</p> ")
                               .With(new MarkupCodeGenerator())
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code("}")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpRazorCommentsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpRazorCommentsTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void UnterminatedRazorComment()
        {
            ParseDocumentTest("@*",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                               .Accepts(AcceptedCharacters.None),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                               .Accepts(AcceptedCharacters.None),
                        Factory.Span(SpanKind.Comment, new HtmlSymbol(
                            Factory.LocationTracker.CurrentLocation,
                            String.Empty,
                            HtmlSymbolType.Unknown))
                               .Accepts(AcceptedCharacters.Any))),
                new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 0, 0, 0));
        }

        [Fact]
        public void EmptyRazorComment()
        {
            ParseDocumentTest("@**@",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                               .Accepts(AcceptedCharacters.None),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                               .Accepts(AcceptedCharacters.None),
                        Factory.Span(SpanKind.Comment, new HtmlSymbol(
                            Factory.LocationTracker.CurrentLocation,
                            String.Empty,
                            HtmlSymbolType.Unknown))
                               .Accepts(AcceptedCharacters.Any),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                               .Accepts(AcceptedCharacters.None),
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                               .Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void RazorCommentInImplicitExpressionMethodCall()
        {
            ParseDocumentTest("@foo(" + Environment.NewLine
                            + "@**@" + Environment.NewLine,
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo(\r\n")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                        new CommentBlock(
                            Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.Span(SpanKind.Comment, new CSharpSymbol(
                                Factory.LocationTracker.CurrentLocation,
                                String.Empty,
                                CSharpSymbolType.Unknown))
                                   .Accepts(AcceptedCharacters.Any),
                            Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None)),
                        Factory.Code("\r\n")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords))),
                new RazorError(
                    String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF, "(", ")"),
                    4, 0, 4));
        }

        [Fact]
        public void UnterminatedRazorCommentInImplicitExpressionMethodCall()
        {
            ParseDocumentTest("@foo(@*",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo(")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                        new CommentBlock(
                            Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.Span(SpanKind.Comment, new CSharpSymbol(
                                Factory.LocationTracker.CurrentLocation,
                                String.Empty,
                                CSharpSymbolType.Unknown))
                                    .Accepts(AcceptedCharacters.Any)))),
                new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 5, 0, 5),
                new RazorError(String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF, "(", ")"), 4, 0, 4));
        }

        [Fact]
        public void RazorCommentInVerbatimBlock()
        {
            ParseDocumentTest("@{" + Environment.NewLine
                            + "    <text" + Environment.NewLine
                            + "    @**@" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        Factory.Code("\r\n").AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("    "),
                            Factory.MarkupTransition("<text").Accepts(AcceptedCharacters.Any),
                            Factory.Markup("\r\n    "),
                            new CommentBlock(
                                Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                       .Accepts(AcceptedCharacters.None),
                                Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                                       .Accepts(AcceptedCharacters.None),
                                Factory.Span(SpanKind.Comment, new HtmlSymbol(
                                    Factory.LocationTracker.CurrentLocation,
                                    String.Empty,
                                    HtmlSymbolType.Unknown))
                                       .Accepts(AcceptedCharacters.Any),
                                Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                                       .Accepts(AcceptedCharacters.None),
                                Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                       .Accepts(AcceptedCharacters.None)),
                            Factory.Markup("\r\n}")))),
                new RazorError(RazorResources.ParseError_TextTagCannotContainAttributes, 8, 1, 4),
                new RazorError(String.Format(RazorResources.ParseError_MissingEndTag, "text"), 8, 1, 4),
                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, RazorResources.BlockName_Code, "}", "{"), 1, 0, 1));
        }

        [Fact]
        public void UnterminatedRazorCommentInVerbatimBlock()
        {
            ParseDocumentTest("@{@*",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        Factory.EmptyCSharp()
                               .AsStatement(),
                        new CommentBlock(
                            Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.Span(SpanKind.Comment, new CSharpSymbol(Factory.LocationTracker.CurrentLocation,
                                                                        String.Empty,
                                                                        CSharpSymbolType.Unknown))
                                   .Accepts(AcceptedCharacters.Any)))),
                new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 2, 0, 2),
                new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, RazorResources.BlockName_Code, "}", "{"), 1, 0, 1));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpReservedWordsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpReservedWordsTest : CsHtmlCodeParserTestBase
    {
        [Theory]
        [InlineData("namespace")]
        [InlineData("class")]
        public void ReservedWords(string word)
        {
            ParseBlockTest(word,
                           new DirectiveBlock(
                               Factory.MetaCode(word).Accepts(AcceptedCharacters.None)
                               ),
                           new RazorError(String.Format(RazorResources.ParseError_ReservedWord, word), SourceLocation.Zero));
        }

        [Theory]
        [InlineData("Namespace")]
        [InlineData("Class")]
        [InlineData("NAMESPACE")]
        [InlineData("CLASS")]
        [InlineData("nameSpace")]
        [InlineData("NameSpace")]
        private void ReservedWordsAreCaseSensitive(string word)
        {
            ParseBlockTest(word,
                           new ExpressionBlock(
                               Factory.Code(word)
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpSectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpSectionTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void ParseSectionBlockCapturesNewlineImmediatelyFollowing()
        {
            ParseDocumentTest("@section" + Environment.NewLine,
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator(String.Empty),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section\r\n"))),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start,
                        RazorResources.ErrorComponent_EndOfFile),
                    10, 1, 0));
        }

        [Fact]
        public void ParseSectionBlockCapturesWhitespaceToEndOfLineInSectionStatementMissingOpenBrace()
        {
            ParseDocumentTest("@section Foo         " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo         \r\n")),
                    Factory.Markup("    ")),
                new RazorError(RazorResources.ParseError_MissingOpenBraceAfterSection, 12, 0, 12));
        }

        [Fact]
        public void ParseSectionBlockCapturesWhitespaceToEndOfLineInSectionStatementMissingName()
        {
            ParseDocumentTest("@section         " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator(String.Empty),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section         \r\n")),
                    Factory.Markup("    ")),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start,
                        RazorResources.ErrorComponent_EndOfFile),
                    23, 1, 4));
        }

        [Fact]
        public void ParseSectionBlockIgnoresSectionUnlessAllLowerCase()
        {
            ParseDocumentTest("@Section foo",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Section")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" foo")));
        }

        [Fact]
        public void ParseSectionBlockReportsErrorAndTerminatesSectionBlockIfKeywordNotFollowedByIdentifierStartCharacter()
        {
            ParseDocumentTest("@section 9 { <p>Foo</p> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator(String.Empty),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section ")),
                    Factory.Markup("9 { <p>Foo</p> }")),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start,
                        String.Format(RazorResources.ErrorComponent_Character, "9")),
                    9, 0, 9));
        }

        [Fact]
        public void ParseSectionBlockReportsErrorAndTerminatesSectionBlockIfNameNotFollowedByOpenBrace()
        {
            ParseDocumentTest("@section foo-bar { <p>Foo</p> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo")),
                    Factory.Markup("-bar { <p>Foo</p> }")),
                new RazorError(RazorResources.ParseError_MissingOpenBraceAfterSection, 12, 0, 12));
        }
        
        [Fact]
        public void ParserOutputsErrorOnNestedSections()
        {
            ParseDocumentTest("@section foo { @section bar { <p>Foo</p> } }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" "),
                            new SectionBlock(new SectionCodeGenerator("bar"),
                                Factory.CodeTransition(),
                                Factory.MetaCode("section bar {")
                                       .AutoCompleteWith(null, atEndOfSpan: true),
                                new MarkupBlock(
                                    Factory.Markup(" <p>Foo</p> ")),
                                Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                            Factory.Markup(" ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Sections_Cannot_Be_Nested,
                        RazorResources.SectionExample_CS),
                    23, 0, 23));
        }

        [Fact]
        public void ParseSectionBlockHandlesEOFAfterOpenBrace()
        {
            ParseDocumentTest("@section foo {",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {")
                               .AutoCompleteWith("}", atEndOfSpan: true),
                        new MarkupBlock())),
                new RazorError(
                    String.Format(RazorResources.ParseError_Expected_X, "}"),
                    14, 0, 14));
        }

        [Fact]
        public void ParseSectionBlockHandlesUnterminatedSection()
        {
            ParseDocumentTest("@section foo { <p>Foo{}</p>",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {")
                               .AutoCompleteWith("}", atEndOfSpan: true),
                        new MarkupBlock(
                // Need to provide the markup span as fragments, since the parser will split the {} into separate symbols.
                            Factory.Markup(" <p>Foo", "{", "}", "</p>")))),
                new RazorError(
                    String.Format(RazorResources.ParseError_Expected_X, "}"),
                    27, 0, 27));
        }

        [Fact]
        public void ParseSectionBlockReportsErrorAndAcceptsWhitespaceToEndOfLineIfSectionNotFollowedByOpenBrace()
        {
            ParseDocumentTest("@section foo      " + Environment.NewLine,
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo      \r\n"))),
                new RazorError(RazorResources.ParseError_MissingOpenBraceAfterSection, 12, 0, 12));
        }

        [Fact]
        public void ParseSectionBlockAcceptsOpenBraceMultipleLinesBelowSectionName()
        {
            ParseDocumentTest("@section foo      " + Environment.NewLine
                            + Environment.NewLine
                            + Environment.NewLine
                            + Environment.NewLine
                            + Environment.NewLine
                            + Environment.NewLine
                            + "{" + Environment.NewLine
                            + "<p>Foo</p>" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo      \r\n\r\n\r\n\r\n\r\n\r\n{")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("\r\n<p>Foo</p>\r\n")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockParsesNamedSectionCorrectly()
        {
            ParseDocumentTest("@section foo { <p>Foo</p> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <p>Foo</p> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockDoesNotRequireSpaceBetweenSectionNameAndOpenBrace()
        {
            ParseDocumentTest("@section foo{ <p>Foo</p> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo{")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <p>Foo</p> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockBalancesBraces()
        {
            ParseDocumentTest("@section foo { <script>(function foo() { return 1; })();</script> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <script>(function foo() { return 1; })();</script> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockAllowsBracesInCSharpExpression()
        {
            ParseDocumentTest("@section foo { I really want to render a close brace, so here I go: @(\"}\") }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" I really want to render a close brace, so here I go: "),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                                Factory.Code("\"}\"").AsExpression(),
                                Factory.MetaCode(")").Accepts(AcceptedCharacters.None)),
                            Factory.Markup(" ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void SectionIsCorrectlyTerminatedWhenCloseBraceImmediatelyFollowsCodeBlock()
        {
            ParseDocumentTest("@section Foo {" + Environment.NewLine
                            + "@if(true) {" + Environment.NewLine
                            + "}" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("\r\n"),
                            new StatementBlock(
                                Factory.CodeTransition(),
                                Factory.Code("if(true) {\r\n}\r\n").AsStatement()
                            )),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void SectionIsCorrectlyTerminatedWhenCloseBraceImmediatelyFollowsCodeBlockNoWhitespace()
        {
            ParseDocumentTest("@section Foo {" + Environment.NewLine
                            + "@if(true) {" + Environment.NewLine
                            + "}}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("\r\n"),
                            new StatementBlock(
                                Factory.CodeTransition(),
                                Factory.Code("if(true) {\r\n}").AsStatement()
                            )),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockCorrectlyTerminatesWhenCloseBraceImmediatelyFollowsMarkup()
        {
            ParseDocumentTest("@section foo {something}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("something")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockParsesComment()
        {
            ParseDocumentTest("@section s {<!-- -->}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("s"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section s {")
                            .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("<!-- -->")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        // This was a user reported bug (codeplex #710), the section parser wasn't handling
        // comments.
        [Fact]
        public void ParseSectionBlockParsesCommentWithDelimiters()
        {
            ParseDocumentTest("@section s {<!-- > \" '-->}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("s"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section s {")
                            .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("<!-- > \" '-->")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockCommentRecoversFromUnclosedTag()
        {
            ParseDocumentTest(
                "@section s {" + Environment.NewLine + "<a" + Environment.NewLine + "<!--  > \" '-->}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("s"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section s {")
                            .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(Environment.NewLine + "<a" + Environment.NewLine + "<!--  > \" '-->")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionBlockParsesXmlProcessingInstruction()
        {
            ParseDocumentTest(
                "@section s { <? xml bleh ?>}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("s"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section s {")
                            .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <? xml bleh ?>")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpSpecialBlockTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpSpecialBlockTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseInheritsStatementMarksInheritsSpanAsCanGrowIfMissingTrailingSpace()
        {
            ParseBlockTest("inherits",
                           new DirectiveBlock(
                               Factory.MetaCode("inherits").Accepts(AcceptedCharacters.Any)
                               ),
                           new RazorError(
                               RazorResources.ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName,
                               new SourceLocation(8, 0, 8)));
        }

        [Fact]
        public void InheritsBlockAcceptsMultipleGenericArguments()
        {
            ParseBlockTest("inherits Foo.Bar<Biz<Qux>, string, int>.Baz",
                           new DirectiveBlock(
                               Factory.MetaCode("inherits ").Accepts(AcceptedCharacters.None),
                               Factory.Code("Foo.Bar<Biz<Qux>, string, int>.Baz")
                                   .AsBaseType("Foo.Bar<Biz<Qux>, string, int>.Baz")
                               ));
        }

        [Fact]
        public void InheritsBlockOutputsErrorIfInheritsNotFollowedByTypeButAcceptsEntireLineAsCode()
        {
            ParseBlockTest("inherits                " + Environment.NewLine
                         + "foo",
                           new DirectiveBlock(
                               Factory.MetaCode("inherits ").Accepts(AcceptedCharacters.None),
                               Factory.Code("               \r\n")
                                   .AsBaseType(String.Empty)
                               ),
                           new RazorError(RazorResources.ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName, 24, 0, 24));
        }

        [Fact]
        public void NamespaceImportInsideCodeBlockCausesError()
        {
            ParseBlockTest("{ using Foo.Bar.Baz; var foo = bar; }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" using Foo.Bar.Baz; var foo = bar; ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ),
                           new RazorError(
                               RazorResources.ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock,
                               new SourceLocation(2, 0, 2)));
        }

        [Fact]
        public void TypeAliasInsideCodeBlockIsNotHandledSpecially()
        {
            ParseBlockTest("{ using Foo = Bar.Baz; var foo = bar; }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" using Foo = Bar.Baz; var foo = bar; ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ),
                           new RazorError(
                               RazorResources.ParseError_NamespaceImportAndTypeAlias_Cannot_Exist_Within_CodeBlock,
                               new SourceLocation(2, 0, 2)));
        }

        [Fact]
        public void Plan9FunctionsKeywordInsideCodeBlockIsNotHandledSpecially()
        {
            ParseBlockTest("{ functions Foo; }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" functions Foo; ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void NonKeywordStatementInCodeBlockIsHandledCorrectly()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    List<dynamic> photos = gallery.Photo.ToList();" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    List<dynamic> photos = gallery.Photo.ToList();\r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockBalancesBracesOutsideStringsIfFirstCharacterIsBraceAndReturnsSpanOfTypeCode()
        {
            // Arrange
            const string code = "foo\"b}ar\" if(condition) { String.Format(\"{0}\"); } ";

            // Act/Assert
            ParseBlockTest("{" + code + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(code).AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockBalancesParensOutsideStringsIfFirstCharacterIsParenAndReturnsSpanOfTypeExpression()
        {
            // Arrange
            const string code = "foo\"b)ar\" if(condition) { String.Format(\"{0}\"); } ";

            // Act/Assert
            ParseBlockTest("(" + code + ")",
                           new ExpressionBlock(
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code(code).AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockBalancesBracesAndOutputsContentAsClassLevelCodeSpanIfFirstIdentifierIsFunctionsKeyword()
        {
            const string code = " foo(); \"bar}baz\" ";
            ParseBlockTest("functions {" + code + "} zoop",
                           new FunctionsBlock(
                               Factory.MetaCode("functions {").Accepts(AcceptedCharacters.None),
                               Factory.Code(code).AsFunctionsBody(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockDoesNoErrorRecoveryForFunctionsBlock()
        {
            ParseBlockTest("functions { { { { { } zoop",
                           new FunctionsBlock(
                               Factory.MetaCode("functions {").Accepts(AcceptedCharacters.None),
                               Factory.Code(" { { { { } zoop").AsFunctionsBody()
                               ),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "functions", "}", "{"),
                               SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockIgnoresFunctionsUnlessAllLowerCase()
        {
            ParseBlockTest("Functions { foo() }",
                           new ExpressionBlock(
                               Factory.Code("Functions")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void ParseBlockIgnoresSingleSlashAtStart()
        {
            ParseBlockTest("@/ foo",
                           new ExpressionBlock(
                               Factory.CodeTransition(),
                               Factory.EmptyCSharp()
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                           new RazorError(
                               String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS, "/"),
                               1, 0, 1));
        }

        [Fact]
        public void ParseBlockTerminatesSingleLineCommentAtEndOfLine()
        {
            ParseBlockTest("if(!false) {" + Environment.NewLine
                         + "    // Foo" + Environment.NewLine
                         + "\t<p>A real tag!</p>" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.Code("if(!false) {\r\n    // Foo\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("\t<p>A real tag!</p>\r\n")
                                       .Accepts(AcceptedCharacters.None)),
                               Factory.Code("}").AsStatement()
                               ));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpStatementTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    // Basic Tests for C# Statements:
    //  * Basic case for each statement
    //  * Basic case for ALL clauses

    // This class DOES NOT contain
    //  * Error cases
    //  * Tests for various types of nested statements
    //  * Comment tests

    public class CSharpStatementTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void ForStatement()
        {
            ParseBlockTest("@for(int i = 0; i++; i < length) { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("for(int i = 0; i++; i < length) { foo(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ForEachStatement()
        {
            ParseBlockTest("@foreach(var foo in bar) { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("foreach(var foo in bar) { foo(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void WhileStatement()
        {
            ParseBlockTest("@while(true) { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("while(true) { foo(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void SwitchStatement()
        {
            ParseBlockTest("@switch(foo) { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("switch(foo) { foo(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void LockStatement()
        {
            ParseBlockTest("@lock(baz) { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("lock(baz) { foo(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void IfStatement()
        {
            ParseBlockTest("@if(true) { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("if(true) { foo(); }")
                                   .AsStatement()
                               ));
        }

        [Fact]
        public void ElseIfClause()
        {
            ParseBlockTest("@if(true) { foo(); } else if(false) { foo(); } else if(!false) { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("if(true) { foo(); } else if(false) { foo(); } else if(!false) { foo(); }")
                                   .AsStatement()
                               ));
        }

        [Fact]
        public void ElseClause()
        {
            ParseBlockTest("@if(true) { foo(); } else { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("if(true) { foo(); } else { foo(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void TryStatement()
        {
            ParseBlockTest("@try { foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("try { foo(); }")
                                   .AsStatement()
                               ));
        }

        [Fact]
        public void CatchClause()
        {
            ParseBlockTest("@try { foo(); } catch(IOException ioex) { handleIO(); } catch(Exception ex) { handleOther(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("try { foo(); } catch(IOException ioex) { handleIO(); } catch(Exception ex) { handleOther(); }")
                                   .AsStatement()
                               ));
        }

        [Fact]
        public void FinallyClause()
        {
            ParseBlockTest("@try { foo(); } finally { Dispose(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("try { foo(); } finally { Dispose(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void UsingStatement()
        {
            ParseBlockTest("@using(var foo = new Foo()) { foo.Bar(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("using(var foo = new Foo()) { foo.Bar(); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void UsingTypeAlias()
        {
            ParseBlockTest("@using StringDictionary = System.Collections.Generic.Dictionary<string, string>",
                           new DirectiveBlock(
                               Factory.CodeTransition(),
                               Factory.Code("using StringDictionary = System.Collections.Generic.Dictionary<string, string>")
                                   .AsNamespaceImport(" StringDictionary = System.Collections.Generic.Dictionary<string, string>", 5)
                                   .Accepts(AcceptedCharacters.AnyExceptNewline)
                               ));
        }

        [Fact]
        public void UsingNamespaceImport()
        {
            ParseBlockTest("@using System.Text.Encoding.ASCIIEncoding",
                           new DirectiveBlock(
                               Factory.CodeTransition(),
                               Factory.Code("using System.Text.Encoding.ASCIIEncoding")
                                   .AsNamespaceImport(" System.Text.Encoding.ASCIIEncoding", 5)
                                   .Accepts(AcceptedCharacters.AnyExceptNewline)
                               ));
        }

        [Fact]
        public void DoStatement()
        {
            ParseBlockTest("@do { foo(); } while(true);",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.Code("do { foo(); } while(true);")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void NonBlockKeywordTreatedAsImplicitExpression()
        {
            ParseBlockTest("@is foo",
                           new ExpressionBlock(new ExpressionCodeGenerator(),
                                               Factory.CodeTransition(),
                                               Factory.Code("is")
                                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpTemplateTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpTemplateTest : CsHtmlCodeParserTestBase
    {
        private const string TestTemplateCode = " @<p>Foo #@item</p>";

        private TemplateBlock TestTemplate()
        {
            return new TemplateBlock(
                new MarkupBlock(
                    Factory.MarkupTransition(),
                    Factory.Markup("<p>Foo #"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("item")
                            .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                            .Accepts(AcceptedCharacters.NonWhiteSpace)
                        ),
                    Factory.Markup("</p>").Accepts(AcceptedCharacters.None)
                    )
                );
        }

        private const string TestNestedTemplateCode = " @<p>Foo #@Html.Repeat(10, @<p>@item</p>)</p>";

        private TemplateBlock TestNestedTemplate()
        {
            return new TemplateBlock(
                new MarkupBlock(
                    Factory.MarkupTransition(),
                    Factory.Markup("<p>Foo #"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Html.Repeat(10, ")
                            .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                        new TemplateBlock(
                            new MarkupBlock(
                                Factory.MarkupTransition(),
                                Factory.Markup("<p>"),
                                new ExpressionBlock(
                                    Factory.CodeTransition(),
                                    Factory.Code("item")
                                        .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                        .Accepts(AcceptedCharacters.NonWhiteSpace)
                                    ),
                                Factory.Markup("</p>").Accepts(AcceptedCharacters.None)
                                )
                            ),
                        Factory.Code(")")
                            .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                            .Accepts(AcceptedCharacters.NonWhiteSpace)
                        ),
                    Factory.Markup("</p>").Accepts(AcceptedCharacters.None)
                    )
                );
        }

        [Fact]
        public void ParseBlockHandlesSingleLineTemplate()
        {
            ParseBlockTest("{ var foo = @: bar" + Environment.NewLine
                         + "; }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" var foo = ").AsStatement(),
                               new TemplateBlock(
                                   new MarkupBlock(
                                       Factory.MarkupTransition(),
                                       Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                       Factory.Markup(" bar\r\n")
                                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString))
                                           .Accepts(AcceptedCharacters.None)
                                       )
                                   ),
                               Factory.Code("; ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockHandlesSingleLineImmediatelyFollowingStatementChar()
        {
            ParseBlockTest("{i@: bar" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("i").AsStatement(),
                               new TemplateBlock(
                                   new MarkupBlock(
                                       Factory.MarkupTransition(),
                                       Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                       Factory.Markup(" bar\r\n")
                                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString))
                                           .Accepts(AcceptedCharacters.None)
                                       )
                                   ),
                               Factory.EmptyCSharp().AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockHandlesSimpleTemplateInExplicitExpressionParens()
        {
            ParseBlockTest("(Html.Repeat(10," + TestTemplateCode + "))",
                           new ExpressionBlock(
                               Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                               Factory.Code("Html.Repeat(10, ").AsExpression(),
                               TestTemplate(),
                               Factory.Code(")").AsExpression(),
                               Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockHandlesSimpleTemplateInImplicitExpressionParens()
        {
            ParseBlockTest("Html.Repeat(10," + TestTemplateCode + ")",
                           new ExpressionBlock(
                               Factory.Code("Html.Repeat(10, ")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                               TestTemplate(),
                               Factory.Code(")")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ));
        }

        [Fact]
        public void ParseBlockHandlesTwoTemplatesInImplicitExpressionParens()
        {
            ParseBlockTest("Html.Repeat(10," + TestTemplateCode + "," + TestTemplateCode + ")",
                           new ExpressionBlock(
                               Factory.Code("Html.Repeat(10, ")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                               TestTemplate(),
                               Factory.Code(", ")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                               TestTemplate(),
                               Factory.Code(")")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)
                               ));
        }

        [Fact]
        public void ParseBlockProducesErrorButCorrectlyParsesNestedTemplateInImplicitExpressionParens()
        {
            ParseBlockTest("Html.Repeat(10," + TestNestedTemplateCode + ")",
                           new ExpressionBlock(
                               Factory.Code("Html.Repeat(10, ")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                               TestNestedTemplate(),
                               Factory.Code(")")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ),
                           GetNestedTemplateError(42));
        }

        [Fact]
        public void ParseBlockHandlesSimpleTemplateInStatementWithinCodeBlock()
        {
            ParseBlockTest("foreach(foo in Bar) { Html.ExecuteTemplate(foo," + TestTemplateCode + "); }",
                           new StatementBlock(
                               Factory.Code("foreach(foo in Bar) { Html.ExecuteTemplate(foo, ").AsStatement(),
                               TestTemplate(),
                               Factory.Code("); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockHandlesTwoTemplatesInStatementWithinCodeBlock()
        {
            ParseBlockTest("foreach(foo in Bar) { Html.ExecuteTemplate(foo," + TestTemplateCode + "," + TestTemplateCode + "); }",
                           new StatementBlock(
                               Factory.Code("foreach(foo in Bar) { Html.ExecuteTemplate(foo, ").AsStatement(),
                               TestTemplate(),
                               Factory.Code(", ").AsStatement(),
                               TestTemplate(),
                               Factory.Code("); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockProducesErrorButCorrectlyParsesNestedTemplateInStatementWithinCodeBlock()
        {
            ParseBlockTest("foreach(foo in Bar) { Html.ExecuteTemplate(foo," + TestNestedTemplateCode + "); }",
                           new StatementBlock(
                               Factory.Code("foreach(foo in Bar) { Html.ExecuteTemplate(foo, ").AsStatement(),
                               TestNestedTemplate(),
                               Factory.Code("); }")
                                   .AsStatement()
                                   .Accepts(AcceptedCharacters.None)
                               ),
                           GetNestedTemplateError(74));
        }

        [Fact]
        public void ParseBlockHandlesSimpleTemplateInStatementWithinStatementBlock()
        {
            ParseBlockTest("{ var foo = bar; Html.ExecuteTemplate(foo," + TestTemplateCode + "); }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" var foo = bar; Html.ExecuteTemplate(foo, ").AsStatement(),
                               TestTemplate(),
                               Factory.Code("); ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockHandlessTwoTemplatesInStatementWithinStatementBlock()
        {
            ParseBlockTest("{ var foo = bar; Html.ExecuteTemplate(foo," + TestTemplateCode + "," + TestTemplateCode + "); }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" var foo = bar; Html.ExecuteTemplate(foo, ").AsStatement(),
                               TestTemplate(),
                               Factory.Code(", ").AsStatement(),
                               TestTemplate(),
                               Factory.Code("); ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockProducesErrorButCorrectlyParsesNestedTemplateInStatementWithinStatementBlock()
        {
            ParseBlockTest("{ var foo = bar; Html.ExecuteTemplate(foo," + TestNestedTemplateCode + "); }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" var foo = bar; Html.ExecuteTemplate(foo, ").AsStatement(),
                               TestNestedTemplate(),
                               Factory.Code("); ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ),
                           GetNestedTemplateError(69));
        }

        private static RazorError GetNestedTemplateError(int characterIndex)
        {
            return new RazorError(RazorResources.ParseError_InlineMarkup_Blocks_Cannot_Be_Nested, new SourceLocation(characterIndex, 0, characterIndex));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpToMarkupSwitchTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpToMarkupSwitchTest : CsHtmlCodeParserTestBase
    {
        [Fact]
        public void SingleAngleBracketDoesNotCauseSwitchIfOuterBlockIsTerminated()
        {
            ParseBlockTest("{ List< }",
                new StatementBlock(
                    Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                    Factory.Code(" List< ").AsStatement(),
                    Factory.MetaCode("}").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockGivesSpacesToCodeOnAtTagTemplateTransitionInDesignTimeMode()
        {
            ParseBlockTest("Foo(    @<p>Foo</p>    )",
                           new ExpressionBlock(
                               Factory.Code("Foo(    ")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.Any),
                               new TemplateBlock(
                                   new MarkupBlock(
                                       Factory.MarkupTransition(),
                                       Factory.Markup("<p>Foo</p>").Accepts(AcceptedCharacters.None)
                                       )
                                   ),
                               Factory.Code("    )")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ), designTimeParser: true);
        }

        [Fact]
        public void ParseBlockGivesSpacesToCodeOnAtColonTemplateTransitionInDesignTimeMode()
        {
            ParseBlockTest("Foo(    " + Environment.NewLine
                         + "@:<p>Foo</p>    " + Environment.NewLine
                         + ")",
                           new ExpressionBlock(
                               Factory.Code("Foo(    \r\n").AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                               new TemplateBlock(
                                   new MarkupBlock(
                                       Factory.MarkupTransition(),
                                       Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                       Factory.Markup("<p>Foo</p>    \r\n")
                                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                       )
                                   ),
                               Factory.Code(")")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ), designTimeParser: true);
        }

        [Fact]
        public void ParseBlockGivesSpacesToCodeOnTagTransitionInDesignTimeMode()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    <p>Foo</p>    " + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    ").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("<p>Foo</p>").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("    \r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ), designTimeParser: true);
        }

        [Fact]
        public void ParseBlockGivesSpacesToCodeOnInvalidAtTagTransitionInDesignTimeMode()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    @<p>Foo</p>    " + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    ").AsStatement(),
                               new MarkupBlock(
                                   Factory.MarkupTransition(),
                                   Factory.Markup("<p>Foo</p>").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("    \r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ), true,
                           new RazorError(RazorResources.ParseError_AtInCode_Must_Be_Followed_By_Colon_Paren_Or_Identifier_Start, 7, 1, 4));
        }

        [Fact]
        public void ParseBlockGivesSpacesToCodeOnAtColonTransitionInDesignTimeMode()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    @:<p>Foo</p>    " + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    ").AsStatement(),
                               new MarkupBlock(
                                   Factory.MarkupTransition(),
                                   Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                   Factory.Markup("<p>Foo</p>    \r\n")
                                       .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                   ),
                               Factory.EmptyCSharp().AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ), designTimeParser: true);
        }

        [Fact]
        public void ParseBlockShouldSupportSingleLineMarkupContainingStatementBlock()
        {
            ParseBlockTest("Repeat(10," + Environment.NewLine
                         + "    @: @{}" + Environment.NewLine
                         + ")",
                           new ExpressionBlock(
                               Factory.Code("Repeat(10,\r\n    ")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords),
                               new TemplateBlock(
                                   new MarkupBlock(
                                       Factory.MarkupTransition(),
                                       Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                       Factory.Markup(" ")
                                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)),
                                       new StatementBlock(
                                           Factory.CodeTransition(),
                                           Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                                           Factory.EmptyCSharp().AsStatement(),
                                           Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                                           ),
                                       Factory.Markup("\r\n")
                                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                       )
                                   ),
                               Factory.Code(")")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)
                               ));
        }

        [Fact]
        public void ParseBlockShouldSupportMarkupWithoutPreceedingWhitespace()
        {
            ParseBlockTest("foreach(var file in files){" + Environment.NewLine
                         + Environment.NewLine
                         + Environment.NewLine
                         + "@:Baz" + Environment.NewLine
                         + "<br/>" + Environment.NewLine
                         + "<a>Foo</a>" + Environment.NewLine
                         + "@:Bar" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.Code("foreach(var file in files){\r\n\r\n\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.MarkupTransition(),
                                   Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                   Factory.Markup("Baz\r\n")
                                       .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                   ),
                               new MarkupBlock(
                                   Factory.Markup("<br/>\r\n")
                                       .Accepts(AcceptedCharacters.None)
                                   ),
                               new MarkupBlock(
                                   Factory.Markup("<a>Foo</a>\r\n")
                                       .Accepts(AcceptedCharacters.None)
                                   ),
                               new MarkupBlock(
                                   Factory.MarkupTransition(),
                                   Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                   Factory.Markup("Bar\r\n")
                                       .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                   ),
                               Factory.Code("}").AsStatement().Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockGivesAllWhitespaceOnSameLineExcludingPreceedingNewlineButIncludingTrailingNewLineToMarkup()
        {
            ParseBlockTest("if(foo) {" + Environment.NewLine
                         + "    var foo = \"After this statement there are 10 spaces\";          " + Environment.NewLine
                         + "    <p>" + Environment.NewLine
                         + "        Foo" + Environment.NewLine
                         + "        @bar" + Environment.NewLine
                         + "    </p>" + Environment.NewLine
                         + "    @:Hello!" + Environment.NewLine
                         + "    var biz = boz;" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.Code("if(foo) {\r\n    var foo = \"After this statement there are 10 spaces\";          \r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("    <p>\r\n        Foo\r\n"),
                                   new ExpressionBlock(
                                       Factory.Code("        ").AsStatement(),
                                       Factory.CodeTransition(),
                                       Factory.Code("bar").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)
                                       ),
                                   Factory.Markup("\r\n    </p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               new MarkupBlock(
                                   Factory.Markup("    "),
                                   Factory.MarkupTransition(),
                                   Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                   Factory.Markup("Hello!\r\n").With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                   ),
                               Factory.Code("    var biz = boz;\r\n}").AsStatement()));
        }

        [Fact]
        public void ParseBlockAllowsMarkupInIfBodyWithBraces()
        {
            ParseBlockTest("if(foo) { <p>Bar</p> } else if(bar) { <p>Baz</p> } else { <p>Boz</p> }",
                           new StatementBlock(
                               Factory.Code("if(foo) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Bar</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} else if(bar) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Baz</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} else {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Boz</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("}").AsStatement().Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockAllowsMarkupInIfBodyWithBracesWithinCodeBlock()
        {
            ParseBlockTest("{ if(foo) { <p>Bar</p> } else if(bar) { <p>Baz</p> } else { <p>Boz</p> } }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" if(foo) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Bar</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} else if(bar) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Baz</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} else {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Boz</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockSupportsMarkupInCaseAndDefaultBranchesOfSwitch()
        {
            // Arrange
            ParseBlockTest("switch(foo) {" + Environment.NewLine
                         + "    case 0:" + Environment.NewLine
                         + "        <p>Foo</p>" + Environment.NewLine
                         + "        break;" + Environment.NewLine
                         + "    case 1:" + Environment.NewLine
                         + "        <p>Bar</p>" + Environment.NewLine
                         + "        return;" + Environment.NewLine
                         + "    case 2:" + Environment.NewLine
                         + "        {" + Environment.NewLine
                         + "            <p>Baz</p>" + Environment.NewLine
                         + "            <p>Boz</p>" + Environment.NewLine
                         + "        }" + Environment.NewLine
                         + "    default:" + Environment.NewLine
                         + "        <p>Biz</p>" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.Code("switch(foo) {\r\n    case 0:\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        <p>Foo</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("        break;\r\n    case 1:\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        <p>Bar</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("        return;\r\n    case 2:\r\n        {\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("            <p>Baz</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               new MarkupBlock(
                                   Factory.Markup("            <p>Boz</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("        }\r\n    default:\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        <p>Biz</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("}").AsStatement().Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSupportsMarkupInCaseAndDefaultBranchesOfSwitchInCodeBlock()
        {
            // Arrange
            ParseBlockTest("{ switch(foo) {" + Environment.NewLine
                         + "    case 0:" + Environment.NewLine
                         + "        <p>Foo</p>" + Environment.NewLine
                         + "        break;" + Environment.NewLine
                         + "    case 1:" + Environment.NewLine
                         + "        <p>Bar</p>" + Environment.NewLine
                         + "        return;" + Environment.NewLine
                         + "    case 2:" + Environment.NewLine
                         + "        {" + Environment.NewLine
                         + "            <p>Baz</p>" + Environment.NewLine
                         + "            <p>Boz</p>" + Environment.NewLine
                         + "        }" + Environment.NewLine
                         + "    default:" + Environment.NewLine
                         + "        <p>Biz</p>" + Environment.NewLine
                         + "} }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" switch(foo) {\r\n    case 0:\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        <p>Foo</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("        break;\r\n    case 1:\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        <p>Bar</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("        return;\r\n    case 2:\r\n        {\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("            <p>Baz</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               new MarkupBlock(
                                   Factory.Markup("            <p>Boz</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("        }\r\n    default:\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        <p>Biz</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockParsesMarkupStatementOnOpenAngleBracket()
        {
            ParseBlockTest("for(int i = 0; i < 10; i++) { <p>Foo</p> }",
                           new StatementBlock(
                               Factory.Code("for(int i = 0; i < 10; i++) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Foo</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("}").AsStatement().Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void ParseBlockParsesMarkupStatementOnOpenAngleBracketInCodeBlock()
        {
            ParseBlockTest("{ for(int i = 0; i < 10; i++) { <p>Foo</p> } }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" for(int i = 0; i < 10; i++) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" <p>Foo</p> ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockParsesMarkupStatementOnSwitchCharacterFollowedByColon()
        {
            // Arrange
            ParseBlockTest("if(foo) { @:Bar" + Environment.NewLine
                         + "} zoop",
                           new StatementBlock(
                               Factory.Code("if(foo) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" "),
                                   Factory.MarkupTransition(),
                                   Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                   Factory.Markup("Bar\r\n").With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                   ),
                               Factory.Code("}").AsStatement()));
        }

        [Fact]
        public void ParseBlockParsesMarkupStatementOnSwitchCharacterFollowedByColonInCodeBlock()
        {
            // Arrange
            ParseBlockTest("{ if(foo) { @:Bar" + Environment.NewLine
                         + "} } zoop",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" if(foo) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" "),
                                   Factory.MarkupTransition(),
                                   Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                   Factory.Markup("Bar\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockCorrectlyReturnsFromMarkupBlockWithPseudoTag()
        {
            ParseBlockTest("if (i > 0) { <text>;</text> }",
                           new StatementBlock(
                               Factory.Code("if (i > 0) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" "),
                                   Factory.MarkupTransition("<text>").Accepts(AcceptedCharacters.None),
                                   Factory.Markup(";"),
                                   Factory.MarkupTransition("</text>").Accepts(AcceptedCharacters.None),
                                   Factory.Markup(" ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("}").AsStatement()));
        }

        [Fact]
        public void ParseBlockCorrectlyReturnsFromMarkupBlockWithPseudoTagInCodeBlock()
        {
            ParseBlockTest("{ if (i > 0) { <text>;</text> } }",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code(" if (i > 0) {").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup(" "),
                                   Factory.MarkupTransition("<text>").Accepts(AcceptedCharacters.None),
                                   Factory.Markup(";"),
                                   Factory.MarkupTransition("</text>").Accepts(AcceptedCharacters.None),
                                   Factory.Markup(" ").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("} ").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSupportsAllKindsOfImplicitMarkupInCodeBlock()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    if(true) {" + Environment.NewLine
                         + "        @:Single Line Markup" + Environment.NewLine
                         + "    }" + Environment.NewLine
                         + "    foreach (var p in Enumerable.Range(1, 10)) {" + Environment.NewLine
                         + "        <text>The number is @p</text>" + Environment.NewLine
                         + "    }" + Environment.NewLine
                         + "    if(!false) {" + Environment.NewLine
                         + "        <p>A real tag!</p>" + Environment.NewLine
                         + "    }" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    if(true) {\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        "),
                                   Factory.MarkupTransition(),
                                   Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                                   Factory.Markup("Single Line Markup\r\n").With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                                   ),
                               Factory.Code("    }\r\n    foreach (var p in Enumerable.Range(1, 10)) {\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        "),
                                   Factory.MarkupTransition("<text>").Accepts(AcceptedCharacters.None),
                                   Factory.Markup("The number is "),
                                   new ExpressionBlock(
                                       Factory.CodeTransition(),
                                       Factory.Code("p").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)
                                       ),
                                   Factory.MarkupTransition("</text>").Accepts(AcceptedCharacters.None),
                                   Factory.Markup("\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("    }\r\n    if(!false) {\r\n").AsStatement(),
                               new MarkupBlock(
                                   Factory.Markup("        <p>A real tag!</p>\r\n").Accepts(AcceptedCharacters.None)
                                   ),
                               Factory.Code("    }\r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpVerbatimBlockTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpVerbatimBlockTest : CsHtmlCodeParserTestBase
    {
        private const string TestExtraKeyword = "model";

        [Fact]
        public void VerbatimBlock()
        {
            ParseBlockTest("@{ foo(); }",
                           new StatementBlock(
                               Factory.CodeTransition(),
                               Factory.MetaCode("{")
                                   .Accepts(AcceptedCharacters.None),
                               Factory.Code(" foo(); ")
                                   .AsStatement(),
                               Factory.MetaCode("}")
                                   .Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void InnerImplicitExpressionWithOnlySingleAtOutputsZeroLengthCodeSpan()
        {
            ParseBlockTest("{@}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp().AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.EmptyCSharp().AsImplicitExpression(KeywordSet, acceptTrailingDot: true).Accepts(AcceptedCharacters.NonWhiteSpace)
                                   ),
                               Factory.EmptyCSharp().AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                           designTimeParser: true,
                           expectedErrors: new[]
                           {
                               new RazorError(String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS, "}"), new SourceLocation(2, 0, 2))
                           });
        }

        [Fact]
        public void InnerImplicitExpressionDoesNotAcceptDotAfterAt()
        {
            ParseBlockTest("{@.}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp().AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.EmptyCSharp().AsImplicitExpression(KeywordSet, acceptTrailingDot: true).Accepts(AcceptedCharacters.NonWhiteSpace)
                                   ),
                               Factory.Code(".").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                           designTimeParser: true,
                           expectedErrors: new[]
                           {
                               new RazorError(String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_CS, "."), new SourceLocation(2, 0, 2))
                           });
        }

        [Fact]
        public void InnerImplicitExpressionWithOnlySingleAtAcceptsSingleSpaceOrNewlineAtDesignTime()
        {
            ParseBlockTest("{" + Environment.NewLine
                         + "    @" + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.Code("\r\n    ").AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.EmptyCSharp().AsImplicitExpression(KeywordSet, acceptTrailingDot: true).Accepts(AcceptedCharacters.NonWhiteSpace)
                                   ),
                               Factory.Code("\r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                /* designTimeParser */ true,
                           new RazorError(RazorResources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_CS, 8, 1, 5));
        }

        [Fact]
        public void InnerImplicitExpressionDoesNotAcceptTrailingNewlineInRunTimeMode()
        {
            ParseBlockTest("{@foo." + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp().AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.Code("foo.").AsImplicitExpression(KeywordSet, acceptTrailingDot: true).Accepts(AcceptedCharacters.NonWhiteSpace)),
                               Factory.Code("\r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void InnerImplicitExpressionAcceptsTrailingNewlineInDesignTimeMode()
        {
            ParseBlockTest("{@foo." + Environment.NewLine
                         + "}",
                           new StatementBlock(
                               Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                               Factory.EmptyCSharp().AsStatement(),
                               new ExpressionBlock(
                                   Factory.CodeTransition(),
                                   Factory.Code("foo.").AsImplicitExpression(KeywordSet, acceptTrailingDot: true).Accepts(AcceptedCharacters.NonWhiteSpace)),
                               Factory.Code("\r\n").AsStatement(),
                               Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                           designTimeParser: true);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CSharpWhitespaceHandlingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CSharpWhitespaceHandlingTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void StatementBlockDoesNotAcceptTrailingNewlineIfNewlinesAreSignificantToAncestor()
        {
            ParseBlockTest("@: @if (true) { }" + Environment.NewLine
                         + "}",
                           new MarkupBlock(
                               Factory.MarkupTransition()
                                   .Accepts(AcceptedCharacters.None),
                               Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                               Factory.Markup(" "),
                               new StatementBlock(
                                   Factory.CodeTransition()
                                       .Accepts(AcceptedCharacters.None),
                                   Factory.Code("if (true) { }")
                                       .AsStatement()
                                   ),
                               Factory.Markup("\r\n")
                                   .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CSharp/CsHtmlDocumentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.CSharp
{
    public class CsHtmlDocumentTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void UnterminatedBlockCommentCausesRazorError()
        {
            ParseDocumentTest("@* Foo Bar",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new CommentBlock(
                                      Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                                      Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                      Factory.Comment(" Foo Bar", HtmlSymbolType.RazorComment)
                                      )
                                  ),
                              new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, SourceLocation.Zero));
        }

        [Fact]
        public void BlockCommentInMarkupDocumentIsHandledCorrectly()
        {
            ParseDocumentTest("<ul>" + Environment.NewLine
                            + "                @* This is a block comment </ul> *@ foo",
                              new MarkupBlock(
                                  Factory.Markup("<ul>\r\n                "),
                                  new CommentBlock(
                                      Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                                      Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                      Factory.Comment(" This is a block comment </ul> ", HtmlSymbolType.RazorComment),
                                      Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                      Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                      ),
                                  Factory.Markup(" foo")
                                  ));
        }

        [Fact]
        public void BlockCommentInMarkupBlockIsHandledCorrectly()
        {
            ParseBlockTest("<ul>" + Environment.NewLine
                         + "                @* This is a block comment </ul> *@ foo </ul>",
                           new MarkupBlock(
                               Factory.Markup("<ul>\r\n                "),
                               new CommentBlock(
                                   Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                                   Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                   Factory.Comment(" This is a block comment </ul> ", HtmlSymbolType.RazorComment),
                                   Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                   Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                   ),
                               Factory.Markup(" foo </ul>").Accepts(AcceptedCharacters.None)
                               ));
        }

        [Fact]
        public void BlockCommentAtStatementStartInCodeBlockIsHandledCorrectly()
        {
            ParseDocumentTest("@if(Request.IsAuthenticated) {" + Environment.NewLine
                            + "    @* User is logged in! } *@" + Environment.NewLine
                            + "    Write(\"Hello friend!\");" + Environment.NewLine
                            + "}",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new StatementBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("if(Request.IsAuthenticated) {\r\n    ").AsStatement(),
                                      new CommentBlock(
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.Comment(" User is logged in! } ", CSharpSymbolType.RazorComment),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                          ),
                                      Factory.Code("\r\n    Write(\"Hello friend!\");\r\n}").AsStatement())));
        }

        [Fact]
        public void BlockCommentInStatementInCodeBlockIsHandledCorrectly()
        {
            ParseDocumentTest("@if(Request.IsAuthenticated) {" + Environment.NewLine
                            + "    var foo = @* User is logged in! ; *@;" + Environment.NewLine
                            + "    Write(\"Hello friend!\");" + Environment.NewLine
                            + "}",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new StatementBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("if(Request.IsAuthenticated) {\r\n    var foo = ").AsStatement(),
                                      new CommentBlock(
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.Comment(" User is logged in! ; ", CSharpSymbolType.RazorComment),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                          ),
                                      Factory.Code(";\r\n    Write(\"Hello friend!\");\r\n}").AsStatement())));
        }

        [Fact]
        public void BlockCommentInStringIsIgnored()
        {
            ParseDocumentTest("@if(Request.IsAuthenticated) {" + Environment.NewLine
                            + "    var foo = \"@* User is logged in! ; *\";" + Environment.NewLine
                            + "    Write(\"Hello friend!\");" + Environment.NewLine
                            + "}",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new StatementBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("if(Request.IsAuthenticated) {" + Environment.NewLine
                                                 + "    var foo = \"@* User is logged in! ; *\";" + Environment.NewLine
                                                 + "    Write(\"Hello friend!\");" + Environment.NewLine
                                                 + "}").AsStatement())));
        }

        [Fact]
        public void BlockCommentInCSharpBlockCommentIsIgnored()
        {
            ParseDocumentTest("@if(Request.IsAuthenticated) {" + Environment.NewLine
                            + "    var foo = /*@* User is logged in! */ *@ */;" + Environment.NewLine
                            + "    Write(\"Hello friend!\");" + Environment.NewLine
                            + "}",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new StatementBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("if(Request.IsAuthenticated) {" + Environment.NewLine
                                                 + "    var foo = /*@* User is logged in! */ *@ */;" + Environment.NewLine
                                                 + "    Write(\"Hello friend!\");" + Environment.NewLine
                                                 + "}").AsStatement())));
        }

        [Fact]
        public void BlockCommentInCSharpLineCommentIsIgnored()
        {
            ParseDocumentTest("@if(Request.IsAuthenticated) {" + Environment.NewLine
                            + "    var foo = //@* User is logged in! */ *@;" + Environment.NewLine
                            + "    Write(\"Hello friend!\");" + Environment.NewLine
                            + "}",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new StatementBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("if(Request.IsAuthenticated) {" + Environment.NewLine
                                                 + "    var foo = //@* User is logged in! */ *@;" + Environment.NewLine
                                                 + "    Write(\"Hello friend!\");" + Environment.NewLine
                                                 + "}").AsStatement())));
        }

        [Fact]
        public void BlockCommentInImplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@Html.Foo@*bar*@",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new ExpressionBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("Html.Foo").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)
                                      ),
                                  Factory.EmptyHtml(),
                                  new CommentBlock(
                                      Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                                      Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                      Factory.Comment("bar", HtmlSymbolType.RazorComment),
                                      Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                      Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                      ),
                                  Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentAfterDotOfImplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@Html.@*bar*@",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new ExpressionBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("Html").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)
                                      ),
                                  Factory.Markup("."),
                                  new CommentBlock(
                                      Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                                      Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                      Factory.Comment("bar", HtmlSymbolType.RazorComment),
                                      Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                      Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                      ),
                                  Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInParensOfImplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@Html.Foo(@*bar*@ 4)",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new ExpressionBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("Html.Foo(").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.Any),
                                      new CommentBlock(
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.Comment("bar", CSharpSymbolType.RazorComment),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                          ),
                                      Factory.Code(" 4)").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)
                                      ),
                                  Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInBracketsOfImplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@Html.Foo[@*bar*@ 4]",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new ExpressionBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("Html.Foo[").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.Any),
                                      new CommentBlock(
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.Comment("bar", CSharpSymbolType.RazorComment),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                          ),
                                      Factory.Code(" 4]").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)
                                      ),
                                  Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInParensOfConditionIsHandledCorrectly()
        {
            ParseDocumentTest("@if(@*bar*@) {}",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new StatementBlock(
                                      Factory.CodeTransition(),
                                      Factory.Code("if(").AsStatement(),
                                      new CommentBlock(
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.Comment("bar", CSharpSymbolType.RazorComment),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                          ),
                                      Factory.Code(") {}").AsStatement()
                                      )));
        }

        [Fact]
        public void BlockCommentInExplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@(1 + @*bar*@ 1)",
                              new MarkupBlock(
                                  Factory.EmptyHtml(),
                                  new ExpressionBlock(
                                      Factory.CodeTransition(),
                                      Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                                      Factory.Code("1 + ").AsExpression(),
                                      new CommentBlock(
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.Comment("bar", CSharpSymbolType.RazorComment),
                                          Factory.MetaCode("*", CSharpSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                                          Factory.CodeTransition(CSharpSymbolType.RazorCommentTransition)
                                          ),
                                      Factory.Code(" 1").AsExpression(),
                                      Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                                      ),
                                  Factory.EmptyHtml()));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/CallbackParserListenerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Razor.Test.Parser
{
    public class CallbackParserListenerTest
    {
        [Fact]
        public void ListenerConstructedWithSpanCallbackCallsCallbackOnEndSpan()
        {
            RunOnEndSpanTest(callback => new CallbackVisitor(callback));
        }

        [Fact]
        public void ListenerConstructedWithSpanCallbackDoesNotThrowOnStartBlockEndBlockOrError()
        {
            // Arrange
            Action<Span> spanCallback = _ => { };
            CallbackVisitor listener = new CallbackVisitor(spanCallback);

            // Act/Assert
            listener.VisitStartBlock(new FunctionsBlock());
            listener.VisitError(new RazorError("Error", SourceLocation.Zero));
            listener.VisitEndBlock(new FunctionsBlock());
        }

        [Fact]
        public void ListenerConstructedWithSpanAndErrorCallbackCallsCallbackOnEndSpan()
        {
            RunOnEndSpanTest(spanCallback => new CallbackVisitor(spanCallback, _ => { }));
        }

        [Fact]
        public void ListenerConstructedWithSpanAndErrorCallbackCallsCallbackOnError()
        {
            RunOnErrorTest(errorCallback => new CallbackVisitor(_ => { }, errorCallback));
        }

        [Fact]
        public void ListenerConstructedWithAllCallbacksCallsCallbackOnEndSpan()
        {
            RunOnEndSpanTest(spanCallback => new CallbackVisitor(spanCallback, _ => { }, _ => { }, _ => { }));
        }

        [Fact]
        public void ListenerConstructedWithAllCallbacksCallsCallbackOnError()
        {
            RunOnErrorTest(errorCallback => new CallbackVisitor(_ => { }, errorCallback, _ => { }, _ => { }));
        }

        [Fact]
        public void ListenerConstructedWithAllCallbacksCallsCallbackOnStartBlock()
        {
            RunOnStartBlockTest(startBlockCallback => new CallbackVisitor(_ => { }, _ => { }, startBlockCallback, _ => { }));
        }

        [Fact]
        public void ListenerConstructedWithAllCallbacksCallsCallbackOnEndBlock()
        {
            RunOnEndBlockTest(endBlockCallback => new CallbackVisitor(_ => { }, _ => { }, _ => { }, endBlockCallback));
        }

        [Fact]
        public void ListenerCallsOnEndSpanCallbackUsingSynchronizationContextIfSpecified()
        {
            RunSyncContextTest(new SpanBuilder().Build(),
                               spanCallback => new CallbackVisitor(spanCallback, _ => { }, _ => { }, _ => { }),
                               (listener, expected) => listener.VisitSpan(expected));
        }

        [Fact]
        public void ListenerCallsOnStartBlockCallbackUsingSynchronizationContextIfSpecified()
        {
            RunSyncContextTest(BlockType.Template,
                               startBlockCallback => new CallbackVisitor(_ => { }, _ => { }, startBlockCallback, _ => { }),
                               (listener, expected) => listener.VisitStartBlock(new BlockBuilder() { Type = expected }.Build()));
        }

        [Fact]
        public void ListenerCallsOnEndBlockCallbackUsingSynchronizationContextIfSpecified()
        {
            RunSyncContextTest(BlockType.Template,
                               endBlockCallback => new CallbackVisitor(_ => { }, _ => { }, _ => { }, endBlockCallback),
                               (listener, expected) => listener.VisitEndBlock(new BlockBuilder() { Type = expected }.Build()));
        }

        [Fact]
        public void ListenerCallsOnErrorCallbackUsingSynchronizationContextIfSpecified()
        {
            RunSyncContextTest(new RazorError("Bar", 42, 42, 42),
                               errorCallback => new CallbackVisitor(_ => { }, errorCallback, _ => { }, _ => { }),
                               (listener, expected) => listener.VisitError(expected));
        }

        private static void RunSyncContextTest<T>(T expected, Func<Action<T>, CallbackVisitor> ctor, Action<CallbackVisitor, T> call)
        {
            // Arrange
            Mock<SynchronizationContext> mockContext = new Mock<SynchronizationContext>();
            mockContext.Setup(c => c.Post(It.IsAny<SendOrPostCallback>(), It.IsAny<object>()))
                .Callback<SendOrPostCallback, object>((callback, state) => { callback(expected); });

            // Act/Assert
            RunCallbackTest<T>(default(T), callback =>
            {
                CallbackVisitor listener = ctor(callback);
                listener.SynchronizationContext = mockContext.Object;
                return listener;
            }, call, (original, actual) =>
            {
                Assert.NotEqual(original, actual);
                Assert.Equal(expected, actual);
            });
        }

        private static void RunOnStartBlockTest(Func<Action<BlockType>, CallbackVisitor> ctor, Action<BlockType, BlockType> verifyResults = null)
        {
            RunCallbackTest(BlockType.Markup, ctor, (listener, expected) => listener.VisitStartBlock(new BlockBuilder() { Type = expected }.Build()), verifyResults);
        }

        private static void RunOnEndBlockTest(Func<Action<BlockType>, CallbackVisitor> ctor, Action<BlockType, BlockType> verifyResults = null)
        {
            RunCallbackTest(BlockType.Markup, ctor, (listener, expected) => listener.VisitEndBlock(new BlockBuilder() { Type = expected }.Build()), verifyResults);
        }

        private static void RunOnErrorTest(Func<Action<RazorError>, CallbackVisitor> ctor, Action<RazorError, RazorError> verifyResults = null)
        {
            RunCallbackTest(new RazorError("Foo", SourceLocation.Zero), ctor, (listener, expected) => listener.VisitError(expected), verifyResults);
        }

        private static void RunOnEndSpanTest(Func<Action<Span>, CallbackVisitor> ctor, Action<Span, Span> verifyResults = null)
        {
            RunCallbackTest(new SpanBuilder().Build(), ctor, (listener, expected) => listener.VisitSpan(expected), verifyResults);
        }

        private static void RunCallbackTest<T>(T expected, Func<Action<T>, CallbackVisitor> ctor, Action<CallbackVisitor, T> call, Action<T, T> verifyResults = null)
        {
            // Arrange
            object actual = null;
            Action<T> callback = t => actual = t;

            CallbackVisitor listener = ctor(callback);

            // Act
            call(listener, expected);

            // Assert
            if (verifyResults == null)
            {
                Assert.Equal(expected, actual);
            }
            else
            {
                verifyResults(expected, (T)actual);
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.Html
{
    public class HtmlAttributeTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void SimpleLiteralAttribute()
        {
            ParseBlockTest("<a href='Foo' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href='", 2, 0, 2), suffix: new LocationTagged<string>("'", 12, 0, 12)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("Foo").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(String.Empty, 9, 0, 9), value: new LocationTagged<string>("Foo", 9, 0, 9))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void MultiPartLiteralAttribute()
        {
            ParseBlockTest("<a href='Foo Bar Baz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href='", 2, 0, 2), suffix: new LocationTagged<string>("'", 20, 0, 20)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("Foo").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(String.Empty, 9, 0, 9), value: new LocationTagged<string>("Foo", 9, 0, 9))),
                        Factory.Markup(" Bar").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(" ", 12, 0, 12), value: new LocationTagged<string>("Bar", 13, 0, 13))),
                        Factory.Markup(" Baz").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(" ", 16, 0, 16), value: new LocationTagged<string>("Baz", 17, 0, 17))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void DoubleQuotedLiteralAttribute()
        {
            ParseBlockTest("<a href=\"Foo Bar Baz\" />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href=\"", 2, 0, 2), suffix: new LocationTagged<string>("\"", 20, 0, 20)),
                        Factory.Markup(" href=\"").With(SpanCodeGenerator.Null),
                        Factory.Markup("Foo").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(String.Empty, 9, 0, 9), value: new LocationTagged<string>("Foo", 9, 0, 9))),
                        Factory.Markup(" Bar").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(" ", 12, 0, 12), value: new LocationTagged<string>("Bar", 13, 0, 13))),
                        Factory.Markup(" Baz").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(" ", 16, 0, 16), value: new LocationTagged<string>("Baz", 17, 0, 17))),
                        Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void UnquotedLiteralAttribute()
        {
            ParseBlockTest("<a href=Foo Bar Baz />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href=", 2, 0, 2), suffix: new LocationTagged<string>(String.Empty, 11, 0, 11)),
                        Factory.Markup(" href=").With(SpanCodeGenerator.Null),
                        Factory.Markup("Foo").With(new LiteralAttributeCodeGenerator(prefix: new LocationTagged<string>(String.Empty, 8, 0, 8), value: new LocationTagged<string>("Foo", 8, 0, 8)))),
                    Factory.Markup(" Bar Baz />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void SimpleExpressionAttribute()
        {
            ParseBlockTest("<a href='@foo' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href='", 2, 0, 2), suffix: new LocationTagged<string>("'", 13, 0, 13)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 9, 0, 9), 9, 0, 9),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("foo")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void MultiValueExpressionAttribute()
        {
            ParseBlockTest("<a href='@foo bar @baz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href='", 2, 0, 2), suffix: new LocationTagged<string>("'", 22, 0, 22)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 9, 0, 9), 9, 0, 9),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("foo")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup(" bar").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(" ", 13, 0, 13), new LocationTagged<string>("bar", 14, 0, 14))),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(" ", 17, 0, 17), 18, 0, 18),
                            Factory.Markup(" ").With(SpanCodeGenerator.Null),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("baz")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VirtualPathAttributesWorkWithConditionalAttributes()
        {
            ParseBlockTest("<a href='@foo ~/Foo/Bar' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href='", 2, 0, 2), suffix: new LocationTagged<string>("'", 23, 0, 23)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 9, 0, 9), 9, 0, 9),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("foo")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup(" ~/Foo/Bar")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(" ", 13, 0, 13),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 14, 0, 14))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void UnquotedAttributeWithCodeWithSpacesInBlock()
        {
            ParseBlockTest("<input value=@foo />",
                new MarkupBlock(
                    Factory.Markup("<input"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "value", prefix: new LocationTagged<string>(" value=", 6, 0, 6), suffix: new LocationTagged<string>(String.Empty, 17, 0, 17)),
                        Factory.Markup(" value=").With(SpanCodeGenerator.Null),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 13, 0, 13), 13, 0, 13),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("foo")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)))),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void UnquotedAttributeWithCodeWithSpacesInDocument()
        {
            ParseDocumentTest("<input value=@foo />",
                new MarkupBlock(
                    Factory.Markup("<input"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "value", prefix: new LocationTagged<string>(" value=", 6, 0, 6), suffix: new LocationTagged<string>(String.Empty, 17, 0, 17)),
                        Factory.Markup(" value=").With(SpanCodeGenerator.Null),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 13, 0, 13), 13, 0, 13),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("foo")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)))),
                    Factory.Markup(" />")));
        }

        [Fact]
        public void ConditionalAttributeCollapserDoesNotRemoveUrlAttributeValues()
        {
            // Act
            ParserResults results = ParseDocument("<a href='~/Foo/Bar' />");
            Block rewritten = new ConditionalAttributeCollapser(new HtmlMarkupParser().BuildSpan).Rewrite(results.Document);
            rewritten = new MarkupCollapser(new HtmlMarkupParser().BuildSpan).Rewrite(rewritten);

            // Assert
            Assert.Equal(0, results.ParserErrors.Count);
            EvaluateParseTree(rewritten,
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator(name: "href", prefix: new LocationTagged<string>(" href='", 2, 0, 2), suffix: new LocationTagged<string>("'", 18, 0, 18)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo/Bar")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 9, 0, 9),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 9, 0, 9))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />")));
        }

        [Fact]
        public void ConditionalAttributesDoNotCreateExtraDataForEntirelyLiteralAttribute()
        {
            // Arrange
            const string code =
 @"<div class=""sidebar"">
    <h1>Title</h1>
    <p>
        As the author, you can <a href=""/Photo/Edit/photoId"">edit</a>
        or <a href=""/Photo/Remove/photoId"">remove</a> this photo.
    </p>
    <dl>
        <dt class=""description"">Description</dt>
        <dd class=""description"">
            The uploader did not provide a description for this photo.
        </dd>
        <dt class=""uploaded-by"">Uploaded by</dt>
        <dd class=""uploaded-by""><a href=""/User/View/user.UserId"">user.DisplayName</a></dd>
        <dt class=""upload-date"">Upload date</dt>
        <dd class=""upload-date"">photo.UploadDate</dd>
        <dt class=""part-of-gallery"">Gallery</dt>
        <dd><a href=""/View/gallery.Id"" title=""View gallery.Name gallery"">gallery.Name</a></dd>
        <dt class=""tags"">Tags</dt>
        <dd class=""tags"">
            <ul class=""tags"">
                <li>This photo has no tags.</li>
            </ul>
            <a href=""/Photo/EditTags/photoId"">edit tags</a>
        </dd>
    </dl>

    <p>
        <a class=""download"" href=""/Photo/Full/photoId"" title=""Download: (photo.FileTitle + photo.FileExtension)"">Download full photo</a> ((photo.FileSize / 1024) KB)
    </p>
</div>
<div class=""main"">
    <img class=""large-photo"" alt=""photo.FileTitle"" src=""/Photo/Thumbnail"" />
    <h2>Nobody has commented on this photo</h2>
    <ol class=""comments"">
        <li>
            <h3 class=""comment-header"">
                <a href=""/User/View/comment.UserId"" title=""View comment.DisplayName's profile"">comment.DisplayName</a> commented at comment.CommentDate:
            </h3>
            <p class=""comment-body"">comment.CommentText</p>
        </li>
    </ol>

    <form method=""post"" action="""">
        <fieldset id=""addComment"">
            <legend>Post new comment</legend>
            <ol>
                <li>
                    <label for=""newComment"">Comment</label>
                    <textarea id=""newComment"" name=""newComment"" title=""Your comment"" rows=""6"" cols=""70""></textarea>
                </li>
            </ol>
            <p class=""form-actions"">
                <input type=""submit"" title=""Add comment"" value=""Add comment"" />
            </p>
        </fieldset>
    </form>
</div>";

            // Act
            ParserResults results = ParseDocument(code);
            Block rewritten = new ConditionalAttributeCollapser(new HtmlMarkupParser().BuildSpan).Rewrite(results.Document);
            rewritten = new MarkupCollapser(new HtmlMarkupParser().BuildSpan).Rewrite(rewritten);

            // Assert
            Assert.Equal(0, results.ParserErrors.Count);
            EvaluateParseTree(rewritten, new MarkupBlock(Factory.Markup(code)));
        }

        [Fact]
        public void ConditionalAttributesAreDisabledForDataAttributesInBlock()
        {
            ParseBlockTest("<span data-foo='@foo'></span>",
                new MarkupBlock(
                    Factory.Markup("<span"),
                    new MarkupBlock(
                        Factory.Markup(" data-foo='"),
                        new ExpressionBlock(
                            Factory.CodeTransition(),
                            Factory.Code("foo")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        Factory.Markup("'")),
                    Factory.Markup("></span>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ConditionalAttributesAreDisabledForDataAttributesInDocument()
        {
            ParseDocumentTest("<span data-foo='@foo'></span>",
                new MarkupBlock(
                    Factory.Markup("<span"),
                    new MarkupBlock(
                        Factory.Markup(" data-foo='"),
                        new ExpressionBlock(
                            Factory.CodeTransition(),
                            Factory.Code("foo")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        Factory.Markup("'")),
                    Factory.Markup("></span>")));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlBlockTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.Html
{
    public class HtmlBlockTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void ParseBlockMethodThrowsArgNullExceptionOnNullContext()
        {
            // Arrange
            HtmlMarkupParser parser = new HtmlMarkupParser();

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => parser.ParseBlock(), RazorResources.Parser_Context_Not_Set);
        }

        [Fact]
        public void ParseBlockHandlesOpenAngleAtEof()
        {
            ParseDocumentTest("@{" + Environment.NewLine
                            + "<",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        Factory.Code("\r\n").AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("<")))),
                new RazorError(
                    String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, RazorResources.BlockName_Code, "}", "{"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseBlockHandlesOpenAngleWithProperTagFollowingIt()
        {
            ParseDocumentTest("@{" + Environment.NewLine
                            + "<" + Environment.NewLine
                            + "</html>",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        Factory.Code("\r\n").AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("<\r\n")
                        ),
                        new MarkupBlock(
                            Factory.Markup(@"</html>").Accepts(AcceptedCharacters.None)
                        ),
                        Factory.EmptyCSharp().AsStatement()
                    )
                ),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(String.Format(RazorResources.ParseError_UnexpectedEndTag, "html"), 7, 2, 0),
                    new RazorError(String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "code", "}", "{"), 1, 0, 1)
                });
        }

        [Fact]
        public void TagWithoutCloseAngleDoesNotTerminateBlock()
        {
            ParseBlockTest("<                      " + Environment.NewLine
                         + "   ",
                new MarkupBlock(
                    Factory.Markup("<                      \r\n   ")),
                designTimeParser: true,
                expectedErrors: new RazorError(String.Format(RazorResources.ParseError_UnfinishedTag, String.Empty), 0, 0, 0));
        }

        [Fact]
        public void ParseBlockAllowsStartAndEndTagsToDifferInCase()
        {
            SingleSpanBlockTest("<li><p>Foo</P></lI>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockReadsToEndOfLineIfFirstCharacterAfterTransitionIsColon()
        {
            ParseBlockTest("@:<li>Foo Bar Baz" + Environment.NewLine
                         + "bork",
                new MarkupBlock(
                    Factory.MarkupTransition(),
                    Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                    Factory.Markup("<li>Foo Bar Baz\r\n")
                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))
                ));
        }

        [Fact]
        public void ParseBlockStopsParsingSingleLineBlockAtEOFIfNoEOLReached()
        {
            ParseBlockTest("@:foo bar",
                new MarkupBlock(
                    Factory.MarkupTransition(),
                    Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                    Factory.Markup(@"foo bar")
                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString))
                    ));
        }

        [Fact]
        public void ParseBlockStopsAtMatchingCloseTagToStartTag()
        {
            SingleSpanBlockTest("<a><b></b></a><c></c>", "<a><b></b></a>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockParsesUntilMatchingEndTagIfFirstNonWhitespaceCharacterIsStartTag()
        {
            SingleSpanBlockTest("<baz><boz><biz></biz></boz></baz>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockAllowsUnclosedTagsAsLongAsItCanRecoverToAnExpectedEndTag()
        {
            SingleSpanBlockTest("<foo><bar><baz></foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockWithSelfClosingTagJustEmitsTag()
        {
            SingleSpanBlockTest("<foo />", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockCanHandleSelfClosingTagsWithinBlock()
        {
            SingleSpanBlockTest("<foo><bar /></foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsTagsWithAttributes()
        {
            ParseBlockTest("<foo bar=\"baz\"><biz><boz zoop=zork/></biz></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("bar", new LocationTagged<string>(" bar=\"", 4, 0, 4), new LocationTagged<string>("\"", 13, 0, 13)),
                        Factory.Markup(" bar=\"").With(SpanCodeGenerator.Null),
                        Factory.Markup("baz").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 10, 0, 10), new LocationTagged<string>("baz", 10, 0, 10))),
                        Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                    Factory.Markup("><biz><boz"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("zoop", new LocationTagged<string>(" zoop=", 24, 0, 24), new LocationTagged<string>(String.Empty, 34, 0, 34)),
                        Factory.Markup(" zoop=").With(SpanCodeGenerator.Null),
                        Factory.Markup("zork").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 30, 0, 30), new LocationTagged<string>("zork", 30, 0, 30)))),
                    Factory.Markup("/></biz></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockAllowsCloseAngleBracketInAttributeValueIfDoubleQuoted()
        {
            ParseBlockTest("<foo><bar baz=\">\" /></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><bar"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("baz", new LocationTagged<string>(" baz=\"", 9, 0, 9), new LocationTagged<string>("\"", 16, 0, 16)),
                        Factory.Markup(" baz=\"").With(SpanCodeGenerator.Null),
                        Factory.Markup(">").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 15, 0, 15), new LocationTagged<string>(">", 15, 0, 15))),
                        Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" /></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockAllowsCloseAngleBracketInAttributeValueIfSingleQuoted()
        {
            ParseBlockTest("<foo><bar baz=\'>\' /></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><bar"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("baz", new LocationTagged<string>(" baz='", 9, 0, 9), new LocationTagged<string>("'", 16, 0, 16)),
                        Factory.Markup(" baz='").With(SpanCodeGenerator.Null),
                        Factory.Markup(">").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 15, 0, 15), new LocationTagged<string>(">", 15, 0, 15))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" /></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockAllowsSlashInAttributeValueIfDoubleQuoted()
        {
            ParseBlockTest("<foo><bar baz=\"/\"></bar></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><bar"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("baz", new LocationTagged<string>(" baz=\"", 9, 0, 9), new LocationTagged<string>("\"", 16, 0, 16)),
                        Factory.Markup(" baz=\"").With(SpanCodeGenerator.Null),
                        Factory.Markup("/").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 15, 0, 15), new LocationTagged<string>("/", 15, 0, 15))),
                        Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                    Factory.Markup("></bar></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockAllowsSlashInAttributeValueIfSingleQuoted()
        {
            ParseBlockTest("<foo><bar baz=\'/\'></bar></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><bar"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("baz", new LocationTagged<string>(" baz='", 9, 0, 9), new LocationTagged<string>("'", 16, 0, 16)),
                        Factory.Markup(" baz='").With(SpanCodeGenerator.Null),
                        Factory.Markup("/").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 15, 0, 15), new LocationTagged<string>("/", 15, 0, 15))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup("></bar></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockTerminatesAtEOF()
        {
            SingleSpanBlockTest("<foo>", "<foo>", BlockType.Markup, SpanKind.Markup,
                                new RazorError(String.Format(RazorResources.ParseError_MissingEndTag, "foo"), new SourceLocation(0, 0, 0)));
        }

        [Fact]
        public void ParseBlockSupportsCommentAsBlock()
        {
            SingleSpanBlockTest("<!-- foo -->", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsCommentWithinBlock()
        {
            SingleSpanBlockTest("<foo>bar<!-- zoop -->baz</foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockProperlyBalancesCommentStartAndEndTags()
        {
            SingleSpanBlockTest("<!--<foo></bar>-->", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockTerminatesAtEOFWhenParsingComment()
        {
            SingleSpanBlockTest("<!--<foo>", "<!--<foo>", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseBlockOnlyTerminatesCommentOnFullEndSequence()
        {
            SingleSpanBlockTest("<!--<foo>--</bar>-->", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockTerminatesCommentAtFirstOccurrenceOfEndSequence()
        {
            SingleSpanBlockTest("<foo><!--<foo></bar-->--></foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockTreatsMalformedTagsAsContent()
        {
            SingleSpanBlockTest(
                "<foo></!-- bar --></foo>",
                "<foo></!-- bar -->",
                BlockType.Markup,
                SpanKind.Markup,
                AcceptedCharacters.None,
                new RazorError(String.Format(RazorResources.ParseError_MissingEndTag, "foo"), 0, 0, 0));
        }


        [Fact]
        public void ParseBlockParsesSGMLDeclarationAsEmptyTag()
        {
            SingleSpanBlockTest("<foo><!DOCTYPE foo bar baz></foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockTerminatesSGMLDeclarationAtFirstCloseAngle()
        {
            SingleSpanBlockTest("<foo><!DOCTYPE foo bar> baz></foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockParsesXMLProcessingInstructionAsEmptyTag()
        {
            SingleSpanBlockTest("<foo><?xml foo bar baz?></foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockTerminatesXMLProcessingInstructionAtQuestionMarkCloseAnglePair()
        {
            SingleSpanBlockTest("<foo><?xml foo bar?> baz</foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockDoesNotTerminateXMLProcessingInstructionAtCloseAngleUnlessPreceededByQuestionMark()
        {
            SingleSpanBlockTest("<foo><?xml foo bar> baz?></foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsScriptTagsWithLessThanSignsInThem()
        {
            SingleSpanBlockTest(@"<script>if(foo<bar) { alert(""baz"");)</script>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsScriptTagsWithSpacedLessThanSignsInThem()
        {
            SingleSpanBlockTest(@"<script>if(foo < bar) { alert(""baz"");)</script>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockAcceptsEmptyTextTag()
        {
            ParseBlockTest("<text/>",
                new MarkupBlock(
                    Factory.MarkupTransition("<text/>")
                ));
        }

        [Fact]
        public void ParseBlockAcceptsTextTagAsOuterTagButDoesNotRender()
        {
            ParseBlockTest("<text>Foo Bar <foo> Baz</text> zoop",
                new MarkupBlock(
                    Factory.MarkupTransition("<text>"),
                    Factory.Markup("Foo Bar <foo> Baz"),
                    Factory.MarkupTransition("</text>"),
                    Factory.Markup(" ").Accepts(AcceptedCharacters.None)
                ));
        }

        [Fact]
        public void ParseBlockRendersLiteralTextTagIfDoubled()
        {
            ParseBlockTest("<text><text>Foo Bar <foo> Baz</text></text> zoop",
                new MarkupBlock(
                    Factory.MarkupTransition("<text>"),
                    Factory.Markup("<text>Foo Bar <foo> Baz</text>"),
                    Factory.MarkupTransition("</text>"),
                    Factory.Markup(" ").Accepts(AcceptedCharacters.None)
                ));
        }

        [Fact]
        public void ParseBlockDoesNotConsiderPsuedoTagWithinMarkupBlock()
        {
            ParseBlockTest("<foo><text><bar></bar></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><text><bar></bar></foo>").Accepts(AcceptedCharacters.None)
                ));
        }

        [Fact]
        public void ParseBlockStopsParsingMidEmptyTagIfEOFReached()
        {
            ParseBlockTest("<br/",
                new MarkupBlock(
                    Factory.Markup("<br/")
                ),
                new RazorError(String.Format(RazorResources.ParseError_UnfinishedTag, "br"), SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockCorrectlyHandlesSingleLineOfMarkupWithEmbeddedStatement()
        {
            ParseBlockTest("<div>Foo @if(true) {} Bar</div>",
                new MarkupBlock(
                    Factory.Markup("<div>Foo "),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("if(true) {}").AsStatement()),
                    Factory.Markup(" Bar</div>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockIgnoresTagsInContentsOfScriptTag()
        {
            ParseBlockTest(@"<script>foo<bar baz='@boz'></script>",
                new MarkupBlock(
                    Factory.Markup("<script>foo<bar baz='"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("boz")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("'></script>")
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlDocumentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.Html
{
    public class HtmlDocumentTest : CsHtmlMarkupParserTestBase
    {
        private static readonly TestFile Nested1000 = TestFile.Create("nested-1000.html");

        [Fact]
        public void ParseDocumentMethodThrowsArgNullExceptionOnNullContext()
        {
            // Arrange
            HtmlMarkupParser parser = new HtmlMarkupParser();

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => parser.ParseDocument(), RazorResources.Parser_Context_Not_Set);
        }

        [Fact]
        public void ParseSectionMethodThrowsArgNullExceptionOnNullContext()
        {
            // Arrange
            HtmlMarkupParser parser = new HtmlMarkupParser();

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => parser.ParseSection(null, true), RazorResources.Parser_Context_Not_Set);
        }

        [Fact]
        public void ParseDocumentOutputsEmptyBlockWithEmptyMarkupSpanIfContentIsEmptyString()
        {
            ParseDocumentTest(String.Empty, new MarkupBlock(Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseDocumentOutputsWhitespaceOnlyContentAsSingleWhitespaceMarkupSpan()
        {
            SingleSpanDocumentTest("          ", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseDocumentAcceptsSwapTokenAtEndOfFileAndOutputsZeroLengthCodeSpan()
        {
            ParseDocumentTest("@",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.EmptyCSharp()
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.EmptyHtml()),
                new RazorError(RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock, 1, 0, 1));
        }

        [Fact]
        public void ParseDocumentCorrectlyHandlesSingleLineOfMarkupWithEmbeddedStatement()
        {
            ParseDocumentTest("<div>Foo @if(true) {} Bar</div>",
                new MarkupBlock(
                    Factory.Markup("<div>Foo "),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("if(true) {}").AsStatement()),
                    Factory.Markup(" Bar</div>")));
        }

        [Fact]
        public void ParseDocumentWithinSectionDoesNotCreateDocumentLevelSpan()
        {
            ParseDocumentTest("@section Foo {" + Environment.NewLine
                            + "    <html></html>" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <html></html>\r\n")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseDocumentParsesWholeContentAsOneSpanIfNoSwapCharacterEncountered()
        {
            SingleSpanDocumentTest("foo <bar>baz</bar>", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseDocumentHandsParsingOverToCodeParserWhenAtSignEncounteredAndEmitsOutput()
        {
            ParseDocumentTest("foo @bar baz",
                new MarkupBlock(
                    Factory.Markup("foo "),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" baz")));
        }

        [Fact]
        public void ParseDocumentEmitsAtSignAsMarkupIfAtEndOfFile()
        {
            ParseDocumentTest("foo @",
                new MarkupBlock(
                    Factory.Markup("foo "),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.EmptyCSharp()
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.EmptyHtml()),
                new RazorError(RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock, 5, 0, 5));
        }

        [Fact]
        public void ParseDocumentEmitsCodeBlockIfFirstCharacterIsSwapCharacter()
        {
            ParseDocumentTest("@bar",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseDocumentDoesNotSwitchToCodeOnEmailAddressInText()
        {
            SingleSpanDocumentTest("<foo>anurse@microsoft.com</foo>", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseDocumentDoesNotSwitchToCodeOnEmailAddressInAttribute()
        {
            ParseDocumentTest("<a href=\"mailto:anurse@microsoft.com\">Email me</a>",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href=\"", 2, 0, 2), new LocationTagged<string>("\"", 36, 0, 36)),
                        Factory.Markup(" href=\"").With(SpanCodeGenerator.Null),
                        Factory.Markup("mailto:anurse@microsoft.com")
                               .With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 9, 0, 9), new LocationTagged<string>("mailto:anurse@microsoft.com", 9, 0, 9))),
                        Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                    Factory.Markup(">Email me</a>")));
        }

        [Fact]
        public void ParseDocumentDoesNotReturnErrorOnMismatchedTags()
        {
            SingleSpanDocumentTest("Foo <div><p></p></p> Baz", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseDocumentReturnsOneMarkupSegmentIfNoCodeBlocksEncountered()
        {
            SingleSpanDocumentTest("Foo <p>Baz<!--Foo-->Bar<!-F> Qux", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseDocumentRendersTextPseudoTagAsMarkup()
        {
            SingleSpanDocumentTest("Foo <text>Foo</text>", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseDocumentAcceptsEndTagWithNoMatchingStartTag()
        {
            SingleSpanDocumentTest("Foo </div> Bar", BlockType.Markup, SpanKind.Markup);
        }

        [Fact]
        public void ParseDocumentNoLongerSupportsDollarOpenBraceCombination()
        {
            ParseDocumentTest("<foo>${bar}</foo>",
                new MarkupBlock(
                    Factory.Markup("<foo>${bar}</foo>")));
        }

        [Fact]
        public void ParseDocumentIgnoresTagsInContentsOfScriptTag()
        {
            ParseDocumentTest(@"<script>foo<bar baz='@boz'></script>",
                new MarkupBlock(
                    Factory.Markup("<script>foo<bar baz='"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("boz")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("'></script>")));
        }

        [Fact]
        public void ParseSectionIgnoresTagsInContentsOfScriptTag()
        {
            ParseDocumentTest(@"@section Foo { <script>foo<bar baz='@boz'></script> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {"),
                        new MarkupBlock(
                            Factory.Markup(" <script>foo<bar baz='"),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("boz")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: false)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            Factory.Markup("'></script> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseBlockCanParse1000NestedElements()
        {
            string content = Nested1000.ReadAllText();
            SingleSpanDocumentTest(content, BlockType.Markup, SpanKind.Markup);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlErrorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.Html
{
    public class HtmlErrorTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void ParseBlockAllowsInvalidTagNamesAsLongAsParserCanIdentifyEndTag()
        {
            SingleSpanBlockTest("<1-foo+bar>foo</1-foo+bar>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockThrowsErrorIfStartTextTagContainsTextAfterName()
        {
            ParseBlockTest("<text foo bar></text>",
                new MarkupBlock(
                    Factory.MarkupTransition("<text").Accepts(AcceptedCharacters.Any),
                    Factory.Markup(" foo bar>"),
                    Factory.MarkupTransition("</text>")),
                new RazorError(RazorResources.ParseError_TextTagCannotContainAttributes, SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockThrowsErrorIfEndTextTagContainsTextAfterName()
        {
            ParseBlockTest("<text></text foo bar>",
                new MarkupBlock(
                    Factory.MarkupTransition("<text>"),
                    Factory.MarkupTransition("</text").Accepts(AcceptedCharacters.Any),
                    Factory.Markup(" ")),
                new RazorError(RazorResources.ParseError_TextTagCannotContainAttributes, 6, 0, 6));
        }

        [Fact]
        public void ParseBlockThrowsExceptionIfBlockDoesNotStartWithTag()
        {
            ParseBlockTest("foo bar <baz>",
                new MarkupBlock(),
                new RazorError(RazorResources.ParseError_MarkupBlock_Must_Start_With_Tag, SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockStartingWithEndTagProducesRazorErrorThenOutputsMarkupSegmentAndEndsBlock()
        {
            ParseBlockTest("</foo> bar baz",
                new MarkupBlock(
                    Factory.Markup("</foo> ").Accepts(AcceptedCharacters.None)),
                new RazorError(String.Format(RazorResources.ParseError_UnexpectedEndTag, "foo"), SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockWithUnclosedTopLevelTagThrowsMissingEndTagParserExceptionOnOutermostUnclosedTag()
        {
            ParseBlockTest("<p><foo></bar>",
                new MarkupBlock(
                    Factory.Markup("<p><foo></bar>").Accepts(AcceptedCharacters.None)),
                new RazorError(String.Format(RazorResources.ParseError_MissingEndTag, "p"), new SourceLocation(0, 0, 0)));
        }

        [Fact]
        public void ParseBlockWithUnclosedTagAtEOFThrowsMissingEndTagException()
        {
            ParseBlockTest("<foo>blah blah blah blah blah",
                new MarkupBlock(
                    Factory.Markup("<foo>blah blah blah blah blah")),
                new RazorError(String.Format(RazorResources.ParseError_MissingEndTag, "foo"), new SourceLocation(0, 0, 0)));
        }

        [Fact]
        public void ParseBlockWithUnfinishedTagAtEOFThrowsIncompleteTagException()
        {
            ParseBlockTest("<foo bar=baz",
                new MarkupBlock(
                    Factory.Markup("<foo"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("bar", new LocationTagged<string>(" bar=", 4, 0, 4), new LocationTagged<string>(String.Empty, 12, 0, 12)),
                        Factory.Markup(" bar=").With(SpanCodeGenerator.Null),
                        Factory.Markup("baz").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 9, 0, 9), new LocationTagged<string>("baz", 9, 0, 9))))),
                new RazorError(String.Format(RazorResources.ParseError_UnfinishedTag, "foo"), new SourceLocation(0, 0, 0)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlParserTestUtils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;

namespace System.Web.Razor.Test.Parser.Html
{
    internal class HtmlParserTestUtils
    {
        public static void RunSingleAtEscapeTest(Action<string, Block> testMethod, AcceptedCharacters lastSpanAcceptedCharacters = AcceptedCharacters.None)
        {
            var factory = SpanFactory.CreateCsHtml();
            testMethod("<foo>@@bar</foo>",
                new MarkupBlock(
                    factory.Markup("<foo>"),
                    factory.Markup("@").Hidden(),
                    factory.Markup("@bar</foo>").Accepts(lastSpanAcceptedCharacters)));
        }

        public static void RunMultiAtEscapeTest(Action<string, Block> testMethod, AcceptedCharacters lastSpanAcceptedCharacters = AcceptedCharacters.None)
        {
            var factory = SpanFactory.CreateCsHtml();
            testMethod("<foo>@@@@@bar</foo>",
                new MarkupBlock(
                    factory.Markup("<foo>"),
                    factory.Markup("@").Hidden(),
                    factory.Markup("@"),
                    factory.Markup("@").Hidden(),
                    factory.Markup("@"),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup("</foo>").Accepts(lastSpanAcceptedCharacters)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlTagsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.Html
{
    public class HtmlTagsTest : CsHtmlMarkupParserTestBase
    {
        public static IEnumerable<string[]> VoidElementNames
        {
            get
            {
                yield return new[] { "area" };
                yield return new[] { "base" };
                yield return new[] { "br" };
                yield return new[] { "col" };
                yield return new[] { "command" };
                yield return new[] { "embed" };
                yield return new[] { "hr" };
                yield return new[] { "img" };
                yield return new[] { "input" };
                yield return new[] { "keygen" };
                yield return new[] { "link" };
                yield return new[] { "meta" };
                yield return new[] { "param" };
                yield return new[] { "source" };
                yield return new[] { "track" };
                yield return new[] { "wbr" };
            }
        }

        [Fact]
        public void EmptyTagNestsLikeNormalTag()
        {
            ParseBlockTest("<p></> Bar",
                new MarkupBlock(
                    Factory.Markup("<p></> ").Accepts(AcceptedCharacters.None)),
                new RazorError(String.Format(RazorResources.ParseError_MissingEndTag, "p"), 0, 0, 0));
        }

        [Fact]
        public void EmptyTag()
        {
            ParseBlockTest("<></> Bar",
                new MarkupBlock(
                    Factory.Markup("<></> ").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void CommentTag()
        {
            ParseBlockTest("<!--Foo--> Bar",
                new MarkupBlock(
                    Factory.Markup("<!--Foo--> ").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void DocTypeTag()
        {
            ParseBlockTest("<!DOCTYPE html> foo",
                new MarkupBlock(
                    Factory.Markup("<!DOCTYPE html> ").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ProcessingInstructionTag()
        {
            ParseBlockTest("<?xml version=\"1.0\" ?> foo",
                new MarkupBlock(
                    Factory.Markup("<?xml version=\"1.0\" ?> ").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ElementTags()
        {
            ParseBlockTest("<p>Foo</p> Bar",
                new MarkupBlock(
                    Factory.Markup("<p>Foo</p> ").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void TextTags()
        {
            ParseBlockTest("<text>Foo</text>}",
                new MarkupBlock(
                    Factory.MarkupTransition("<text>"),
                    Factory.Markup("Foo"),
                    Factory.MarkupTransition("</text>")));
        }

        [Fact]
        public void CDataTag()
        {
            ParseBlockTest("<![CDATA[Foo]]> Bar",
                new MarkupBlock(
                    Factory.Markup("<![CDATA[Foo]]> ").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ScriptTag()
        {
            ParseDocumentTest("<script>foo < bar && quantity.toString() !== orderQty.val()</script>",
                new MarkupBlock(
                    Factory.Markup("<script>foo < bar && quantity.toString() !== orderQty.val()</script>")));
        }

        [Theory]
        [PropertyData("VoidElementNames")]
        public void VoidElementFollowedByContent(string tagName)
        {
            ParseBlockTest("<" + tagName + ">foo",
                new MarkupBlock(
                    Factory.Markup("<" + tagName + ">")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Theory]
        [PropertyData("VoidElementNames")]
        public void VoidElementFollowedByOtherTag(string tagName)
        {
            ParseBlockTest("<" + tagName + "><other>foo",
                new MarkupBlock(
                    Factory.Markup("<" + tagName + ">")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Theory]
        [PropertyData("VoidElementNames")]
        public void VoidElementFollowedByCloseTag(string tagName)
        {
            ParseBlockTest("<" + tagName + "> </" + tagName + ">foo",
                new MarkupBlock(
                    Factory.Markup("<" + tagName + "> </" + tagName + ">")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Theory]
        [PropertyData("VoidElementNames")]
        public void IncompleteVoidElementEndTag(string tagName)
        {
            ParseBlockTest("<" + tagName + "></" + tagName,
                new MarkupBlock(
                    Factory.Markup("<" + tagName + "></" + tagName)
                           .Accepts(AcceptedCharacters.Any)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlToCodeSwitchTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.Html
{
    public class HtmlToCodeSwitchTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void ParseBlockSwitchesWhenCharacterBeforeSwapIsNonAlphanumeric()
        {
            ParseBlockTest("<p>foo#@i</p>",
                new MarkupBlock(
                    Factory.Markup("<p>foo#"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("i").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("</p>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSwitchesToCodeWhenSwapCharacterEncounteredMidTag()
        {
            ParseBlockTest("<foo @bar />",
                new MarkupBlock(
                    Factory.Markup("<foo "),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSwitchesToCodeWhenSwapCharacterEncounteredInAttributeValue()
        {
            ParseBlockTest("<foo bar=\"@baz\" />",
                new MarkupBlock(
                    Factory.Markup("<foo"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("bar", new LocationTagged<string>(" bar=\"", 4, 0, 4), new LocationTagged<string>("\"", 14, 0, 14)),
                        Factory.Markup(" bar=\"").With(SpanCodeGenerator.Null),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 10, 0, 10), 10, 0, 10),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("baz")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSwitchesToCodeWhenSwapCharacterEncounteredInTagContent()
        {
            ParseBlockTest("<foo>@bar<baz>@boz</baz></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo>"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("<baz>"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("boz")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("</baz></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockParsesCodeWithinSingleLineMarkup()
        {
            ParseBlockTest("@:<li>Foo @Bar Baz" + Environment.NewLine
                         + "bork",
                new MarkupBlock(
                    Factory.MarkupTransition(),
                    Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                    Factory.Markup("<li>Foo ").With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" Baz\r\n")
                           .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString, AcceptedCharacters.None))));
        }

        [Fact]
        public void ParseBlockSupportsCodeWithinComment()
        {
            ParseBlockTest("<foo><!-- @foo --></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><!-- "),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" --></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSupportsCodeWithinSGMLDeclaration()
        {
            ParseBlockTest("<foo><!DOCTYPE foo @bar baz></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><!DOCTYPE foo "),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" baz></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSupportsCodeWithinCDataDeclaration()
        {
            ParseBlockTest("<foo><![CDATA[ foo @bar baz]]></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><![CDATA[ foo "),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" baz]]></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSupportsCodeWithinXMLProcessingInstruction()
        {
            ParseBlockTest("<foo><?xml foo @bar baz?></foo>",
                new MarkupBlock(
                    Factory.Markup("<foo><?xml foo "),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup(" baz?></foo>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockDoesNotSwitchToCodeOnEmailAddressInText()
        {
            SingleSpanBlockTest("<foo>anurse@microsoft.com</foo>", BlockType.Markup, SpanKind.Markup, acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockDoesNotSwitchToCodeOnEmailAddressInAttribute()
        {
            ParseBlockTest("<a href=\"mailto:anurse@microsoft.com\">Email me</a>",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href=\"", 2, 0, 2), new LocationTagged<string>("\"", 36, 0, 36)),
                        Factory.Markup(" href=\"").With(SpanCodeGenerator.Null),
                        Factory.Markup("mailto:anurse@microsoft.com")
                               .With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 9, 0, 9), new LocationTagged<string>("mailto:anurse@microsoft.com", 9, 0, 9))),
                        Factory.Markup("\"").With(SpanCodeGenerator.Null)),
                    Factory.Markup(">Email me</a>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockGivesWhitespacePreceedingAtToCodeIfThereIsNoMarkupOnThatLine()
        {
            ParseBlockTest("   <ul>" + Environment.NewLine
                         + "    @foreach(var p in Products) {" + Environment.NewLine
                         + "        <li>Product: @p.Name</li>" + Environment.NewLine
                         + "    }" + Environment.NewLine
                         + "    </ul>",
                new MarkupBlock(
                    Factory.Markup("   <ul>\r\n"),
                    new StatementBlock(
                        Factory.Code("    ").AsStatement(),
                        Factory.CodeTransition(),
                        Factory.Code("foreach(var p in Products) {\r\n").AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("        <li>Product: "),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("p.Name")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            Factory.Markup("</li>\r\n").Accepts(AcceptedCharacters.None)),
                        Factory.Code("    }\r\n").AsStatement().Accepts(AcceptedCharacters.None)),
                    Factory.Markup("    </ul>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseDocumentGivesWhitespacePreceedingAtToCodeIfThereIsNoMarkupOnThatLine()
        {
            ParseDocumentTest("   <ul>" + Environment.NewLine
                            + "    @foreach(var p in Products) {" + Environment.NewLine
                            + "        <li>Product: @p.Name</li>" + Environment.NewLine
                            + "    }" + Environment.NewLine
                            + "    </ul>",
                new MarkupBlock(
                    Factory.Markup("   <ul>\r\n"),
                    new StatementBlock(
                        Factory.Code("    ").AsStatement(),
                        Factory.CodeTransition(),
                        Factory.Code("foreach(var p in Products) {\r\n").AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("        <li>Product: "),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("p.Name")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            Factory.Markup("</li>\r\n").Accepts(AcceptedCharacters.None)),
                        Factory.Code("    }\r\n").AsStatement().Accepts(AcceptedCharacters.None)),
                    Factory.Markup("    </ul>")));
        }

        [Fact]
        public void SectionContextGivesWhitespacePreceedingAtToCodeIfThereIsNoMarkupOnThatLine()
        {
            ParseDocumentTest("@section foo {" + Environment.NewLine
                            + "    <ul>" + Environment.NewLine
                            + "        @foreach(var p in Products) {" + Environment.NewLine
                            + "            <li>Product: @p.Name</li>" + Environment.NewLine
                            + "        }" + Environment.NewLine
                            + "    </ul>" + Environment.NewLine
                            + "}",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section foo {").AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <ul>\r\n"),
                            new StatementBlock(
                                Factory.Code("        ").AsStatement(),
                                Factory.CodeTransition(),
                                Factory.Code("foreach(var p in Products) {\r\n").AsStatement(),
                                new MarkupBlock(
                                    Factory.Markup("            <li>Product: "),
                                    new ExpressionBlock(
                                        Factory.CodeTransition(),
                                        Factory.Code("p.Name")
                                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                                    Factory.Markup("</li>\r\n").Accepts(AcceptedCharacters.None)),
                                Factory.Code("        }\r\n").AsStatement().Accepts(AcceptedCharacters.None)),
                            Factory.Markup("    </ul>\r\n")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void CSharpCodeParserDoesNotAcceptLeadingOrTrailingWhitespaceInDesignMode()
        {
            ParseBlockTest("   <ul>" + Environment.NewLine
                         + "    @foreach(var p in Products) {" + Environment.NewLine
                         + "        <li>Product: @p.Name</li>" + Environment.NewLine
                         + "    }" + Environment.NewLine
                         + "    </ul>",
                new MarkupBlock(
                    Factory.Markup("   <ul>\r\n    "),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foreach(var p in Products) {\r\n        ").AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("<li>Product: "),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("p.Name").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                            Factory.Markup("</li>").Accepts(AcceptedCharacters.None)),
                        Factory.Code("\r\n    }").AsStatement().Accepts(AcceptedCharacters.None)),
                    Factory.Markup("\r\n    </ul>").Accepts(AcceptedCharacters.None)),
                designTimeParser: true);
        }

        // Tests for "@@" escape sequence:
        [Fact]
        public void ParseBlockTreatsTwoAtSignsAsEscapeSequence()
        {
            HtmlParserTestUtils.RunSingleAtEscapeTest(ParseBlockTest);
        }

        [Fact]
        public void ParseBlockTreatsPairsOfAtSignsAsEscapeSequence()
        {
            HtmlParserTestUtils.RunMultiAtEscapeTest(ParseBlockTest);
        }

        [Fact]
        public void ParseDocumentTreatsTwoAtSignsAsEscapeSequence()
        {
            HtmlParserTestUtils.RunSingleAtEscapeTest(ParseDocumentTest, lastSpanAcceptedCharacters: AcceptedCharacters.Any);
        }

        [Fact]
        public void ParseDocumentTreatsPairsOfAtSignsAsEscapeSequence()
        {
            HtmlParserTestUtils.RunMultiAtEscapeTest(ParseDocumentTest, lastSpanAcceptedCharacters: AcceptedCharacters.Any);
        }

        [Fact]
        public void SectionBodyTreatsTwoAtSignsAsEscapeSequence()
        {
            ParseDocumentTest("@section Foo { <foo>@@bar</foo> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {").AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <foo>"),
                            Factory.Markup("@").Hidden(),
                            Factory.Markup("@bar</foo> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void SectionBodyTreatsPairsOfAtSignsAsEscapeSequence()
        {
            ParseDocumentTest("@section Foo { <foo>@@@@@bar</foo> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {").AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <foo>"),
                            Factory.Markup("@").Hidden(),
                            Factory.Markup("@"),
                            Factory.Markup("@").Hidden(),
                            Factory.Markup("@"),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("bar")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            Factory.Markup("</foo> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/Html/HtmlUrlAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.Html
{
    public class HtmlUrlAttributeTest : CsHtmlMarkupParserTestBase
    {
        [Fact]
        public void SimpleUrlInAttributeInMarkupBlock()
        {
            ParseBlockTest("<a href='~/Foo/Bar/Baz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 2, 0, 2), new LocationTagged<string>("'", 22, 0, 22)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo/Bar/Baz")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 9, 0, 9),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 9, 0, 9))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void SimpleUrlInAttributeInMarkupDocument()
        {
            ParseDocumentTest("<a href='~/Foo/Bar/Baz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 2, 0, 2), new LocationTagged<string>("'", 22, 0, 22)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo/Bar/Baz")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 9, 0, 9),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 9, 0, 9))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />")));
        }

        [Fact]
        public void SimpleUrlInAttributeInMarkupSection()
        {
            ParseDocumentTest("@section Foo { <a href='~/Foo/Bar/Baz' /> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true)
                               .Accepts(AcceptedCharacters.Any),
                        new MarkupBlock(
                            Factory.Markup(" <a"),
                            new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 17, 0, 17), new LocationTagged<string>("'", 37, 0, 37)),
                                Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                                Factory.Markup("~/Foo/Bar/Baz")
                                       .WithEditorHints(EditorHints.VirtualPath)
                                       .With(new LiteralAttributeCodeGenerator(
                                           new LocationTagged<string>(String.Empty, 24, 0, 24),
                                           new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 24, 0, 24))),
                                Factory.Markup("'").With(SpanCodeGenerator.Null)),
                            Factory.Markup(" /> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void UrlWithExpressionsInAttributeInMarkupBlock()
        {
            ParseBlockTest("<a href='~/Foo/@id/Baz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                        new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 2, 0, 2), new LocationTagged<string>("'", 22, 0, 22)),
                            Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                            Factory.Markup("~/Foo/")
                                    .WithEditorHints(EditorHints.VirtualPath)
                                    .With(new LiteralAttributeCodeGenerator(
                                        new LocationTagged<string>(String.Empty, 9, 0, 9),
                                        new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 9, 0, 9))),
                            new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 15, 0, 15), 15, 0, 15),
                                new ExpressionBlock(
                                    Factory.CodeTransition().Accepts(AcceptedCharacters.None),
                                    Factory.Code("id")
                                           .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                           .Accepts(AcceptedCharacters.NonWhiteSpace))),
                            Factory.Markup("/Baz")
                                   .With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 18, 0, 18), new LocationTagged<string>("/Baz", 18, 0, 18))),
                            Factory.Markup("'").With(SpanCodeGenerator.Null)),
                        Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void UrlWithExpressionsInAttributeInMarkupDocument()
        {
            ParseDocumentTest("<a href='~/Foo/@id/Baz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 2, 0, 2), new LocationTagged<string>("'", 22, 0, 22)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo/")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 9, 0, 9),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 9, 0, 9))),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 15, 0, 15), 15, 0, 15),
                            new ExpressionBlock(
                                Factory.CodeTransition().Accepts(AcceptedCharacters.None),
                                Factory.Code("id")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup("/Baz")
                               .With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 18, 0, 18), new LocationTagged<string>("/Baz", 18, 0, 18))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />")));
        }

        [Fact]
        public void UrlWithExpressionsInAttributeInMarkupSection()
        {
            ParseDocumentTest("@section Foo { <a href='~/Foo/@id/Baz' /> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <a"),
                            new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 17, 0, 17), new LocationTagged<string>("'", 37, 0, 37)),
                                Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                                Factory.Markup("~/Foo/")
                                       .WithEditorHints(EditorHints.VirtualPath)
                                       .With(new LiteralAttributeCodeGenerator(
                                           new LocationTagged<string>(String.Empty, 24, 0, 24),
                                           new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 24, 0, 24))),
                                new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 30, 0, 30), 30, 0, 30),
                                    new ExpressionBlock(
                                        Factory.CodeTransition().Accepts(AcceptedCharacters.None),
                                        Factory.Code("id")
                                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                               .Accepts(AcceptedCharacters.NonWhiteSpace))),
                                Factory.Markup("/Baz")
                                       .With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 33, 0, 33), new LocationTagged<string>("/Baz", 33, 0, 33))),
                                Factory.Markup("'").With(SpanCodeGenerator.Null)),
                            Factory.Markup(" /> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void UrlWithComplexCharactersInAttributeInMarkupBlock()
        {
            ParseBlockTest("<a href='~/Foo+Bar:Baz(Biz),Boz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 2, 0, 2), new LocationTagged<string>("'", 31, 0, 31)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo+Bar:Baz(Biz),Boz")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 9, 0, 9),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 9, 0, 9))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void UrlWithComplexCharactersInAttributeInMarkupDocument()
        {
            ParseDocumentTest("<a href='~/Foo+Bar:Baz(Biz),Boz' />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href='", 2, 0, 2), new LocationTagged<string>("'", 31, 0, 31)),
                        Factory.Markup(" href='").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo+Bar:Baz(Biz),Boz")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 9, 0, 9),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 9, 0, 9))),
                        Factory.Markup("'").With(SpanCodeGenerator.Null)),
                    Factory.Markup(" />")));
        }

        [Fact]
        public void UrlInUnquotedAttributeValueInMarkupBlock()
        {
            ParseBlockTest("<a href=~/Foo+Bar:Baz(Biz),Boz/@id/Boz />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href=", 2, 0, 2), new LocationTagged<string>(String.Empty, 38, 0, 38)),
                        Factory.Markup(" href=").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo+Bar:Baz(Biz),Boz/")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 8, 0, 8),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 8, 0, 8))),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 31, 0, 31), 31, 0, 31),
                            new ExpressionBlock(
                                Factory.CodeTransition()
                                       .Accepts(AcceptedCharacters.None),
                                Factory.Code("id")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                            .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup("/Boz").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 34, 0, 34), new LocationTagged<string>("/Boz", 34, 0, 34)))),
                    Factory.Markup(" />").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void UrlInUnquotedAttributeValueInMarkupDocument()
        {
            ParseDocumentTest("<a href=~/Foo+Bar:Baz(Biz),Boz/@id/Boz />",
                new MarkupBlock(
                    Factory.Markup("<a"),
                    new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href=", 2, 0, 2), new LocationTagged<string>(String.Empty, 38, 0, 38)),
                        Factory.Markup(" href=").With(SpanCodeGenerator.Null),
                        Factory.Markup("~/Foo+Bar:Baz(Biz),Boz/")
                               .WithEditorHints(EditorHints.VirtualPath)
                               .With(new LiteralAttributeCodeGenerator(
                                   new LocationTagged<string>(String.Empty, 8, 0, 8),
                                   new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 8, 0, 8))),
                        new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 31, 0, 31), 31, 0, 31),
                            new ExpressionBlock(
                                Factory.CodeTransition()
                                       .Accepts(AcceptedCharacters.None),
                                Factory.Code("id")
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                            .Accepts(AcceptedCharacters.NonWhiteSpace))),
                        Factory.Markup("/Boz").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 34, 0, 34), new LocationTagged<string>("/Boz", 34, 0, 34)))),
                    Factory.Markup(" />")));
        }

        [Fact]
        public void UrlInUnquotedAttributeValueInMarkupSection()
        {
            ParseDocumentTest("@section Foo { <a href=~/Foo+Bar:Baz(Biz),Boz/@id/Boz /> }",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("section Foo {")
                               .AutoCompleteWith(null, atEndOfSpan: true),
                        new MarkupBlock(
                            Factory.Markup(" <a"),
                            new MarkupBlock(new AttributeBlockCodeGenerator("href", new LocationTagged<string>(" href=", 17, 0, 17), new LocationTagged<string>(String.Empty, 53, 0, 53)),
                                Factory.Markup(" href=").With(SpanCodeGenerator.Null),
                                Factory.Markup("~/Foo+Bar:Baz(Biz),Boz/")
                                        .WithEditorHints(EditorHints.VirtualPath)
                                        .With(new LiteralAttributeCodeGenerator(
                                            new LocationTagged<string>(String.Empty, 23, 0, 23),
                                            new LocationTagged<SpanCodeGenerator>(new ResolveUrlCodeGenerator(), 23, 0, 23))),
                                new MarkupBlock(new DynamicAttributeBlockCodeGenerator(new LocationTagged<string>(String.Empty, 46, 0, 46), 46, 0, 46),
                                    new ExpressionBlock(
                                        Factory.CodeTransition()
                                               .Accepts(AcceptedCharacters.None),
                                        Factory.Code("id")
                                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                    .Accepts(AcceptedCharacters.NonWhiteSpace))),
                                Factory.Markup("/Boz").With(new LiteralAttributeCodeGenerator(new LocationTagged<string>(String.Empty, 49, 0, 49), new LocationTagged<string>("/Boz", 49, 0, 49)))),
                            Factory.Markup(" /> ")),
                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/ParserContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Razor.Test.Parser
{
    public class ParserContextTest
    {
        [Fact]
        public void ConstructorRequiresNonNullSource()
        {
            var codeParser = new CSharpCodeParser();
            Assert.ThrowsArgumentNull(() => new ParserContext(null, codeParser, new HtmlMarkupParser(), codeParser), "source");
        }

        [Fact]
        public void ConstructorRequiresNonNullCodeParser()
        {
            var codeParser = new CSharpCodeParser();
            Assert.ThrowsArgumentNull(() => new ParserContext(new SeekableTextReader(TextReader.Null), null, new HtmlMarkupParser(), codeParser), "codeParser");
        }

        [Fact]
        public void ConstructorRequiresNonNullMarkupParser()
        {
            var codeParser = new CSharpCodeParser();
            Assert.ThrowsArgumentNull(() => new ParserContext(new SeekableTextReader(TextReader.Null), codeParser, null, codeParser), "markupParser");
        }

        [Fact]
        public void ConstructorRequiresNonNullActiveParser()
        {
            Assert.ThrowsArgumentNull(() => new ParserContext(new SeekableTextReader(TextReader.Null), new CSharpCodeParser(), new HtmlMarkupParser(), null), "activeParser");
        }

        [Fact]
        public void ConstructorThrowsIfActiveParserIsNotCodeOrMarkupParser()
        {
            Assert.ThrowsArgument(() => new ParserContext(new SeekableTextReader(TextReader.Null), new CSharpCodeParser(), new HtmlMarkupParser(), new CSharpCodeParser()),
                                                    "activeParser",
                                                    RazorResources.ActiveParser_Must_Be_Code_Or_Markup_Parser);
        }

        [Fact]
        public void ConstructorAcceptsActiveParserIfIsSameAsEitherCodeOrMarkupParser()
        {
            var codeParser = new CSharpCodeParser();
            var markupParser = new HtmlMarkupParser();
            new ParserContext(new SeekableTextReader(TextReader.Null), codeParser, markupParser, codeParser);
            new ParserContext(new SeekableTextReader(TextReader.Null), codeParser, markupParser, markupParser);
        }

        [Fact]
        public void ConstructorInitializesProperties()
        {
            // Arrange
            SeekableTextReader expectedBuffer = new SeekableTextReader(TextReader.Null);
            CSharpCodeParser expectedCodeParser = new CSharpCodeParser();
            HtmlMarkupParser expectedMarkupParser = new HtmlMarkupParser();

            // Act
            ParserContext context = new ParserContext(expectedBuffer, expectedCodeParser, expectedMarkupParser, expectedCodeParser);

            // Assert
            Assert.NotNull(context.Source);
            Assert.Same(expectedCodeParser, context.CodeParser);
            Assert.Same(expectedMarkupParser, context.MarkupParser);
            Assert.Same(expectedCodeParser, context.ActiveParser);
        }

        [Fact]
        public void CurrentCharacterReturnsCurrentCharacterInTextBuffer()
        {
            // Arrange
            ParserContext context = SetupTestContext("bar", b => b.Read());

            // Act
            char actual = context.CurrentCharacter;

            // Assert
            Assert.Equal('a', actual);
        }

        [Fact]
        public void CurrentCharacterReturnsNulCharacterIfTextBufferAtEOF()
        {
            // Arrange
            ParserContext context = SetupTestContext("bar", b => b.ReadToEnd());

            // Act
            char actual = context.CurrentCharacter;

            // Assert
            Assert.Equal('\0', actual);
        }

        [Fact]
        public void EndOfFileReturnsFalseIfTextBufferNotAtEOF()
        {
            // Arrange
            ParserContext context = SetupTestContext("bar");

            // Act/Assert
            Assert.False(context.EndOfFile);
        }

        [Fact]
        public void EndOfFileReturnsTrueIfTextBufferAtEOF()
        {
            // Arrange
            ParserContext context = SetupTestContext("bar", b => b.ReadToEnd());

            // Act/Assert
            Assert.True(context.EndOfFile);
        }

        [Fact]
        public void StartBlockCreatesNewBlock()
        {
            // Arrange
            ParserContext context = SetupTestContext("phoo");

            // Act
            context.StartBlock(BlockType.Expression);

            // Assert
            BlockBuilder blockBuilder = Assert.Single(context.BlockStack);
            Assert.Equal(BlockType.Expression, blockBuilder.Type);
        }

        [Fact]
        public void EndBlockAddsCurrentBlockToParentBlock()
        {
            // Arrange
            Mock<ParserVisitor> mockListener = new Mock<ParserVisitor>();
            ParserContext context = SetupTestContext("phoo");

            // Act
            context.StartBlock(BlockType.Expression);
            context.StartBlock(BlockType.Statement);
            context.EndBlock();

            // Assert
            BlockBuilder blockBuilder = Assert.Single(context.BlockStack);
            Assert.Equal(BlockType.Expression, blockBuilder.Type);
            SyntaxTreeNode node = Assert.Single(blockBuilder.Children);
            Assert.Equal(BlockType.Statement, Assert.IsType<Block>(node).Type);
        }

        [Fact]
        public void AddSpanAddsSpanToCurrentBlockBuilder()
        {
            // Arrange
            var factory = SpanFactory.CreateCsHtml();
            Mock<ParserVisitor> mockListener = new Mock<ParserVisitor>();
            ParserContext context = SetupTestContext("phoo");

            SpanBuilder builder = new SpanBuilder()
            {
                Kind = SpanKind.Code
            };
            builder.Accept(new CSharpSymbol(1, 0, 1, "foo", CSharpSymbolType.Identifier));
            Span added = builder.Build();

            using (context.StartBlock(BlockType.Functions))
            {
                context.AddSpan(added);
            }

            BlockBuilder expected = new BlockBuilder()
            {
                Type = BlockType.Functions,
            };
            expected.Children.Add(added);

            // Assert
            ParserTestBase.EvaluateResults(context.CompleteParse(), expected.Build());
        }

        [Fact]
        public void SwitchActiveParserSetsMarkupParserAsActiveIfCodeParserCurrentlyActive()
        {
            // Arrange
            var codeParser = new CSharpCodeParser();
            var markupParser = new HtmlMarkupParser();
            ParserContext context = SetupTestContext("barbazbiz", b => b.Read(), codeParser, markupParser, codeParser);
            Assert.Same(codeParser, context.ActiveParser);

            // Act
            context.SwitchActiveParser();

            // Assert
            Assert.Same(markupParser, context.ActiveParser);
        }

        [Fact]
        public void SwitchActiveParserSetsCodeParserAsActiveIfMarkupParserCurrentlyActive()
        {
            // Arrange
            var codeParser = new CSharpCodeParser();
            var markupParser = new HtmlMarkupParser();
            ParserContext context = SetupTestContext("barbazbiz", b => b.Read(), codeParser, markupParser, markupParser);
            Assert.Same(markupParser, context.ActiveParser);

            // Act
            context.SwitchActiveParser();

            // Assert
            Assert.Same(codeParser, context.ActiveParser);
        }

        private ParserContext SetupTestContext(string document)
        {
            var codeParser = new CSharpCodeParser();
            var markupParser = new HtmlMarkupParser();
            return SetupTestContext(document, b => { }, codeParser, markupParser, codeParser);
        }

        private ParserContext SetupTestContext(string document, Action<TextReader> positioningAction)
        {
            var codeParser = new CSharpCodeParser();
            var markupParser = new HtmlMarkupParser();
            return SetupTestContext(document, positioningAction, codeParser, markupParser, codeParser);
        }

        private ParserContext SetupTestContext(string document, Action<TextReader> positioningAction, ParserBase codeParser, ParserBase markupParser, ParserBase activeParser)
        {
            ParserContext context = new ParserContext(new SeekableTextReader(new StringReader(document)), codeParser, markupParser, activeParser);
            positioningAction(context.Source);
            return context;
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/ParserVisitorExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Razor.Test.Parser
{
    public class ParserVisitorExtensionsTest
    {
        [Fact]
        public void VisitThrowsOnNullVisitor()
        {
            ParserVisitor target = null;
            ParserResults results = new ParserResults(new BlockBuilder() { Type = BlockType.Comment }.Build(), new List<RazorError>());

            Assert.ThrowsArgumentNull(() => target.Visit(results), "self");
        }

        [Fact]
        public void VisitThrowsOnNullResults()
        {
            ParserVisitor target = new Mock<ParserVisitor>().Object;
            Assert.ThrowsArgumentNull(() => target.Visit(null), "result");
        }

        [Fact]
        public void VisitSendsDocumentToVisitor()
        {
            // Arrange
            Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>();
            Block root = new BlockBuilder() { Type = BlockType.Comment }.Build();
            ParserResults results = new ParserResults(root, new List<RazorError>());

            // Act
            targetMock.Object.Visit(results);

            // Assert
            targetMock.Verify(v => v.VisitBlock(root));
        }

        [Fact]
        public void VisitSendsErrorsToVisitor()
        {
            // Arrange
            Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>();
            Block root = new BlockBuilder() { Type = BlockType.Comment }.Build();
            List<RazorError> errors = new List<RazorError>() {
                new RazorError("Foo", 1, 0, 1),
                new RazorError("Bar", 2, 0, 2)
            };
            ParserResults results = new ParserResults(root, errors);

            // Act
            targetMock.Object.Visit(results);

            // Assert
            targetMock.Verify(v => v.VisitError(errors[0]));
            targetMock.Verify(v => v.VisitError(errors[1]));
        }

        [Fact]
        public void VisitCallsOnCompleteWhenAllNodesHaveBeenVisited()
        {
            // Arrange
            Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>();
            Block root = new BlockBuilder() { Type = BlockType.Comment }.Build();
            List<RazorError> errors = new List<RazorError>() {
                new RazorError("Foo", 1, 0, 1),
                new RazorError("Bar", 2, 0, 2)
            };
            ParserResults results = new ParserResults(root, errors);

            // Act
            targetMock.Object.Visit(results);

            // Assert
            targetMock.Verify(v => v.OnComplete());
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/PartialParsing/CSharpPartialParsingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.PartialParsing
{
    public class CSharpPartialParsingTest : PartialParsingTestBase<CSharpRazorCodeLanguage>
    {
        [Fact]
        public void ImplicitExpressionAcceptsInnerInsertionsInStatementBlock()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{" + Environment.NewLine
                                                          + "    @DateTime..Now" + Environment.NewLine
                                                          + "}");
            StringTextBuffer old = new StringTextBuffer("@{" + Environment.NewLine
                                                      + "    @DateTime.Now" + Environment.NewLine
                                                      + "}");

            // Act and Assert
            RunPartialParseTest(new TextChange(17, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        factory.Code("\r\n    ").AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("DateTime..Now")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Code("\r\n").AsStatement(),
                        factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionAcceptsInnerInsertions()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @DateTime..Now baz");
            StringTextBuffer old = new StringTextBuffer("foo @DateTime.Now baz");

            // Act and Assert
            RunPartialParseTest(new TextChange(13, 0, old, 1, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("DateTime..Now").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")), additionalFlags: PartialParseResult.Provisional);
        }

        [Fact]
        public void ImplicitExpressionAcceptsWholeIdentifierReplacement()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer old = new StringTextBuffer("foo @date baz");
            StringTextBuffer changed = new StringTextBuffer("foo @DateTime baz");

            // Act and Assert
            RunPartialParseTest(new TextChange(5, 4, old, 8, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("DateTime").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionRejectsWholeIdentifierReplacementToKeyword()
        {
            // Arrange
            RazorEngineHost host = CreateHost();
            RazorEditorParser parser = new RazorEditorParser(host, @"C:\This\Is\A\Test\Path");

            using (TestParserManager manager = new TestParserManager(parser))
            {
                StringTextBuffer old = new StringTextBuffer("foo @date baz");
                StringTextBuffer changed = new StringTextBuffer("foo @if baz");
                TextChange textChange = new TextChange(5, 4, old, 2, changed);
                manager.InitializeWithDocument(old);

                // Act
                PartialParseResult result = manager.CheckForStructureChangesAndWait(textChange);

                // Assert
                Assert.Equal(PartialParseResult.Rejected, result);
                Assert.Equal(2, manager.ParseCount);
            }
        }

        [Fact]
        public void ImplicitExpressionRejectsWholeIdentifierReplacementToDirective()
        {
            // Arrange
            RazorEngineHost host = CreateHost();
            RazorEditorParser parser = new RazorEditorParser(host, @"C:\This\Is\A\Test\Path");

            using (var manager = new TestParserManager(parser))
            {
                StringTextBuffer old = new StringTextBuffer("foo @date baz");
                StringTextBuffer changed = new StringTextBuffer("foo @inherits baz");
                TextChange textChange = new TextChange(5, 4, old, 8, changed);
                manager.InitializeWithDocument(old);

                // Act
                PartialParseResult result = manager.CheckForStructureChangesAndWait(textChange);

                // Assert
                Assert.Equal(PartialParseResult.Rejected | PartialParseResult.SpanContextChanged, result);
                Assert.Equal(2, manager.ParseCount);
            }
        }

        [Fact]
        public void ImplicitExpressionAcceptsPrefixIdentifierReplacements_SingleSymbol()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer old = new StringTextBuffer("foo @dTime baz");
            StringTextBuffer changed = new StringTextBuffer("foo @DateTime baz");

            // Act and Assert
            RunPartialParseTest(new TextChange(5, 1, old, 4, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("DateTime").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsPrefixIdentifierReplacements_MultipleSymbols()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer old = new StringTextBuffer("foo @dTime.Now baz");
            StringTextBuffer changed = new StringTextBuffer("foo @DateTime.Now baz");

            // Act and Assert
            RunPartialParseTest(new TextChange(5, 1, old, 4, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("DateTime.Now").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsSuffixIdentifierReplacements_SingleSymbol()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer old = new StringTextBuffer("foo @Datet baz");
            StringTextBuffer changed = new StringTextBuffer("foo @DateTime baz");

            // Act and Assert
            RunPartialParseTest(new TextChange(9, 1, old, 4, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("DateTime").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsSuffixIdentifierReplacements_MultipleSymbols()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer old = new StringTextBuffer("foo @DateTime.n baz");
            StringTextBuffer changed = new StringTextBuffer("foo @DateTime.Now baz");

            // Act and Assert
            RunPartialParseTest(new TextChange(14, 1, old, 3, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("DateTime.Now").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsSurroundedIdentifierReplacements()
        {
            // Arrange
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer old = new StringTextBuffer("foo @DateTime.n.ToString() baz");
            StringTextBuffer changed = new StringTextBuffer("foo @DateTime.Now.ToString() baz");

            // Act and Assert
            RunPartialParseTest(new TextChange(14, 1, old, 3, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("DateTime.Now.ToString()").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsDotlessCommitInsertionsInStatementBlockAfterIdentifiers()
        {
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{" + Environment.NewLine
                                                          + "    @DateTime." + Environment.NewLine
                                                          + "}");
            StringTextBuffer old = new StringTextBuffer("@{" + Environment.NewLine
                                                      + "    @DateTime" + Environment.NewLine
                                                      + "}");

            var textChange = new TextChange(17, 0, old, 1, changed);
            using (TestParserManager manager = CreateParserManager())
            {
                Action<TextChange, PartialParseResult, string> applyAndVerifyPartialChange = (changeToApply, expectedResult, expectedCode) =>
                {
                    PartialParseResult result = manager.CheckForStructureChangesAndWait(textChange);

                    // Assert
                    Assert.Equal(expectedResult, result);
                    Assert.Equal(1, manager.ParseCount);
                    ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree, new MarkupBlock(
                        factory.EmptyHtml(),
                        new StatementBlock(
                            factory.CodeTransition(),
                            factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                            factory.Code("\r\n    ").AsStatement(),
                            new ExpressionBlock(
                                factory.CodeTransition(),
                                factory.Code(expectedCode)
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            factory.Code("\r\n").AsStatement(),
                            factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                        factory.EmptyHtml()));
                };

                manager.InitializeWithDocument(textChange.OldBuffer);

                // This is the process of a dotless commit when doing "." insertions to commit intellisense changes.
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime.");

                old = changed;
                changed = new StringTextBuffer("@{" + Environment.NewLine
                                            + "    @DateTime.." + Environment.NewLine
                                            + "}");
                textChange = new TextChange(18, 0, old, 1, changed);

                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime..");

                old = changed;
                changed = new StringTextBuffer("@{" + Environment.NewLine
                                            + "    @DateTime.Now." + Environment.NewLine
                                            + "}");
                textChange = new TextChange(18, 0, old, 3, changed);

                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime.Now.");
            }
        }

        [Fact]
        public void ImplicitExpressionAcceptsDotlessCommitInsertionsInStatementBlock()
        {
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{" + Environment.NewLine
                                                          + "    @DateT." + Environment.NewLine
                                                          + "}");
            StringTextBuffer old = new StringTextBuffer("@{" + Environment.NewLine
                                                      + "    @DateT" + Environment.NewLine
                                                      + "}");

            var textChange = new TextChange(14, 0, old, 1, changed);
            using (TestParserManager manager = CreateParserManager())
            {
                Action<TextChange, PartialParseResult, string> applyAndVerifyPartialChange = (changeToApply, expectedResult, expectedCode) =>
                {
                    PartialParseResult result = manager.CheckForStructureChangesAndWait(textChange);

                    // Assert
                    Assert.Equal(expectedResult, result);
                    Assert.Equal(1, manager.ParseCount);
                    ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree, new MarkupBlock(
                        factory.EmptyHtml(),
                        new StatementBlock(
                            factory.CodeTransition(),
                            factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                            factory.Code("\r\n    ").AsStatement(),
                            new ExpressionBlock(
                                factory.CodeTransition(),
                                factory.Code(expectedCode)
                                       .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            factory.Code("\r\n").AsStatement(),
                            factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                        factory.EmptyHtml()));
                };

                manager.InitializeWithDocument(textChange.OldBuffer);

                // This is the process of a dotless commit when doing "." insertions to commit intellisense changes.
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateT.");

                old = changed;
                changed = new StringTextBuffer("@{" + Environment.NewLine
                                            + "    @DateTime." + Environment.NewLine
                                            + "}");
                textChange = new TextChange(14, 0, old, 3, changed);

                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime.");
            }
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsDotlessCommitInsertions()
        {
            SpanFactory factory = SpanFactory.CreateCsHtml();
            var changed = new StringTextBuffer("foo @DateT. baz");
            var old = new StringTextBuffer("foo @DateT baz");
            var textChange = new TextChange(10, 0, old, 1, changed);
            using (TestParserManager manager = CreateParserManager())
            {
                Action<TextChange, PartialParseResult, string> applyAndVerifyPartialChange = (changeToApply, expectedResult, expectedCode) =>
                {
                    PartialParseResult result = manager.CheckForStructureChangesAndWait(textChange);

                    // Assert
                    Assert.Equal(expectedResult, result);
                    Assert.Equal(1, manager.ParseCount);

                    ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree, new MarkupBlock(
                        factory.Markup("foo "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code(expectedCode).AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Markup(" baz")));
                };

                manager.InitializeWithDocument(textChange.OldBuffer);

                // This is the process of a dotless commit when doing "." insertions to commit intellisense changes.
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted | PartialParseResult.Provisional, "DateT.");

                old = changed;
                changed = new StringTextBuffer("foo @DateTime. baz");
                textChange = new TextChange(10, 0, old, 3, changed);

                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted | PartialParseResult.Provisional, "DateTime.");
            }
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsDotlessCommitInsertionsAfterIdentifiers()
        {
            SpanFactory factory = SpanFactory.CreateCsHtml();
            var changed = new StringTextBuffer("foo @DateTime. baz");
            var old = new StringTextBuffer("foo @DateTime baz");
            var textChange = new TextChange(13, 0, old, 1, changed);
            using (TestParserManager manager = CreateParserManager())
            {
                Action<TextChange, PartialParseResult, string> applyAndVerifyPartialChange = (changeToApply, expectedResult, expectedCode) =>
                {
                    PartialParseResult result = manager.CheckForStructureChangesAndWait(textChange);

                    // Assert
                    Assert.Equal(expectedResult, result);
                    Assert.Equal(1, manager.ParseCount);

                    ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree, new MarkupBlock(
                        factory.Markup("foo "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code(expectedCode).AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Markup(" baz")));
                };

                manager.InitializeWithDocument(textChange.OldBuffer);

                // This is the process of a dotless commit when doing "." insertions to commit intellisense changes.
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted | PartialParseResult.Provisional, "DateTime.");

                old = changed;
                changed = new StringTextBuffer("foo @DateTime.. baz");
                textChange = new TextChange(14, 0, old, 1, changed);

                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted | PartialParseResult.Provisional, "DateTime..");

                old = changed;
                changed = new StringTextBuffer("foo @DateTime.Now. baz");
                textChange = new TextChange(14, 0, old, 3, changed);

                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted | PartialParseResult.Provisional, "DateTime.Now.");
            }
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsCaseInsensitiveDotlessCommitInsertions_NewRoslynIntegration()
        {
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer old = new StringTextBuffer("foo @date baz");
            StringTextBuffer changed = new StringTextBuffer("foo @date. baz");
            TextChange textChange = new TextChange(9, 0, old, 1, changed);
            using (TestParserManager manager = CreateParserManager())
            {
                Action<TextChange, PartialParseResult, string> applyAndVerifyPartialChange = (changeToApply, expectedResult, expectedCode) =>
                {
                    PartialParseResult result = manager.CheckForStructureChangesAndWait(textChange);

                    // Assert
                    Assert.Equal(expectedResult, result);
                    Assert.Equal(1, manager.ParseCount);

                    ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree, new MarkupBlock(
                        factory.Markup("foo "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code(expectedCode).AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Markup(" baz")));
                };

                manager.InitializeWithDocument(textChange.OldBuffer);

                // This is the process of a dotless commit when doing "." insertions to commit intellisense changes.

                // @date => @date.
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted | PartialParseResult.Provisional, "date.");

                old = changed;
                changed = new StringTextBuffer("foo @date baz");
                textChange = new TextChange(9, 1, old, 0, changed);

                // @date. => @date
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "date");

                old = changed;
                changed = new StringTextBuffer("foo @DateTime baz");
                textChange = new TextChange(5, 4, old, 8, changed);

                // @date => @DateTime
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted, "DateTime");

                old = changed;
                changed = new StringTextBuffer("foo @DateTime. baz");
                textChange = new TextChange(13, 0, old, 1, changed);

                // @DateTime => @DateTime.
                applyAndVerifyPartialChange(textChange, PartialParseResult.Accepted | PartialParseResult.Provisional, "DateTime.");
            }
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsDeleteOfIdentifierPartsIfDotRemains()
        {
            SpanFactory factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @User. baz");
            StringTextBuffer old = new StringTextBuffer("foo @User.Name baz");
            RunPartialParseTest(new TextChange(10, 4, old, 0, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("User.").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")),
                additionalFlags: PartialParseResult.Provisional);
        }

        [Fact]
        public void ImplicitExpressionAcceptsDeleteOfIdentifierPartsIfSomeOfIdentifierRemains()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @Us baz");
            StringTextBuffer old = new StringTextBuffer("foo @User baz");
            RunPartialParseTest(new TextChange(7, 2, old, 0, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("Us").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsMultipleInsertionIfItCausesIdentifierExpansionAndTrailingDot()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @User. baz");
            StringTextBuffer old = new StringTextBuffer("foo @U baz");
            RunPartialParseTest(new TextChange(6, 0, old, 4, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("User.").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")),
                additionalFlags: PartialParseResult.Provisional);
        }

        [Fact]
        public void ImplicitExpressionAcceptsMultipleInsertionIfItOnlyCausesIdentifierExpansion()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @barbiz baz");
            StringTextBuffer old = new StringTextBuffer("foo @bar baz");
            RunPartialParseTest(new TextChange(8, 0, old, 3, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("barbiz").AsImplicitExpression(CSharpCodeParser.DefaultKeywords).Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsIdentifierExpansionAtEndOfNonWhitespaceCharacters()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{" + Environment.NewLine
                                                          + "    @food" + Environment.NewLine
                                                          + "}");
            StringTextBuffer old = new StringTextBuffer("@{" + Environment.NewLine
                                                      + "    @foo" + Environment.NewLine
                                                      + "}");
            RunPartialParseTest(new TextChange(12, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        factory.Code("\r\n    ").AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("food")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Code("\r\n").AsStatement(),
                        factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionAcceptsIdentifierAfterDotAtEndOfNonWhitespaceCharacters()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{" + Environment.NewLine
                                                          + "    @foo.d" + Environment.NewLine
                                                          + "}");
            StringTextBuffer old = new StringTextBuffer("@{" + Environment.NewLine
                                                      + "    @foo." + Environment.NewLine
                                                      + "}");
            RunPartialParseTest(new TextChange(13, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        factory.Code("\r\n    ").AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo.d")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Code("\r\n").AsStatement(),
                        factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionAcceptsDotAtEndOfNonWhitespaceCharacters()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{" + Environment.NewLine
                                                          + "    @foo." + Environment.NewLine
                                                          + "}");
            StringTextBuffer old = new StringTextBuffer("@{" + Environment.NewLine
                                                      + "    @foo" + Environment.NewLine
                                                      + "}");
            RunPartialParseTest(new TextChange(12, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        factory.Code("\r\n    ").AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code(@"foo.")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Code("\r\n").AsStatement(),
                        factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionRejectsChangeWhichWouldHaveBeenAcceptedIfLastChangeWasProvisionallyAcceptedOnDifferentSpan()
        {
            var factory = SpanFactory.CreateCsHtml();

            // Arrange
            TextChange dotTyped = new TextChange(8, 0, new StringTextBuffer("foo @foo @bar"), 1, new StringTextBuffer("foo @foo. @bar"));
            TextChange charTyped = new TextChange(14, 0, new StringTextBuffer("foo @foo. @bar"), 1, new StringTextBuffer("foo @foo. @barb"));
            using (TestParserManager manager = CreateParserManager())
            {
                manager.InitializeWithDocument(dotTyped.OldBuffer);

                // Apply the dot change
                Assert.Equal(PartialParseResult.Provisional | PartialParseResult.Accepted, manager.CheckForStructureChangesAndWait(dotTyped));

                // Act (apply the identifier start char change)
                PartialParseResult result = manager.CheckForStructureChangesAndWait(charTyped);

                // Assert
                Assert.Equal(PartialParseResult.Rejected, result);
                Assert.False(manager.Parser.LastResultProvisional, "LastResultProvisional flag should have been cleared but it was not");
                ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree,
                    new MarkupBlock(
                        factory.Markup("foo "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Markup(". "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("barb")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.EmptyHtml()));
            }
        }

        [Fact]
        public void ImplicitExpressionAcceptsIdentifierTypedAfterDotIfLastChangeWasProvisionalAcceptanceOfDot()
        {
            var factory = SpanFactory.CreateCsHtml();

            // Arrange
            TextChange dotTyped = new TextChange(8, 0, new StringTextBuffer("foo @foo bar"), 1, new StringTextBuffer("foo @foo. bar"));
            TextChange charTyped = new TextChange(9, 0, new StringTextBuffer("foo @foo. bar"), 1, new StringTextBuffer("foo @foo.b bar"));
            using (TestParserManager manager = CreateParserManager())
            {
                manager.InitializeWithDocument(dotTyped.OldBuffer);

                // Apply the dot change
                Assert.Equal(PartialParseResult.Provisional | PartialParseResult.Accepted, manager.CheckForStructureChangesAndWait(dotTyped));

                // Act (apply the identifier start char change)
                PartialParseResult result = manager.CheckForStructureChangesAndWait(charTyped);

                // Assert
                Assert.Equal(PartialParseResult.Accepted, result);
                Assert.False(manager.Parser.LastResultProvisional, "LastResultProvisional flag should have been cleared but it was not");
                ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree,
                    new MarkupBlock(
                        factory.Markup("foo "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo.b")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Markup(" bar")));
            }
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsDotAfterIdentifierInMarkup()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @foo. bar");
            StringTextBuffer old = new StringTextBuffer("foo @foo bar");
            RunPartialParseTest(new TextChange(8, 0, old, 1, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("foo.")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" bar")),
                additionalFlags: PartialParseResult.Provisional);
        }

        [Fact]
        public void ImplicitExpressionAcceptsAdditionalIdentifierCharactersIfEndOfSpanIsIdentifier()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @foob bar");
            StringTextBuffer old = new StringTextBuffer("foo @foo bar");
            RunPartialParseTest(new TextChange(8, 0, old, 1, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("foob")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" bar")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsAdditionalIdentifierStartCharactersIfEndOfSpanIsDot()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{@foo.b}");
            StringTextBuffer old = new StringTextBuffer("@{@foo.}");
            RunPartialParseTest(new TextChange(7, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        factory.EmptyCSharp().AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo.b")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.EmptyCSharp().AsStatement(),
                        factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionAcceptsDotIfTrailingDotsAreAllowed()
        {
            var factory = SpanFactory.CreateCsHtml();
            StringTextBuffer changed = new StringTextBuffer("@{@foo.}");
            StringTextBuffer old = new StringTextBuffer("@{@foo}");
            RunPartialParseTest(new TextChange(6, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                        factory.EmptyCSharp().AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo.")
                                   .AsImplicitExpression(CSharpCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.EmptyCSharp().AsStatement(),
                        factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfIfKeywordTyped()
        {
            RunTypeKeywordTest("if");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfDoKeywordTyped()
        {
            RunTypeKeywordTest("do");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfTryKeywordTyped()
        {
            RunTypeKeywordTest("try");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfForKeywordTyped()
        {
            RunTypeKeywordTest("for");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfForEachKeywordTyped()
        {
            RunTypeKeywordTest("foreach");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfWhileKeywordTyped()
        {
            RunTypeKeywordTest("while");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfSwitchKeywordTyped()
        {
            RunTypeKeywordTest("switch");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfLockKeywordTyped()
        {
            RunTypeKeywordTest("lock");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfUsingKeywordTyped()
        {
            RunTypeKeywordTest("using");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfSectionKeywordTyped()
        {
            RunTypeKeywordTest("section");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfInheritsKeywordTyped()
        {
            RunTypeKeywordTest("inherits");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfHelperKeywordTyped()
        {
            RunTypeKeywordTest("helper");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfFunctionsKeywordTyped()
        {
            RunTypeKeywordTest("functions");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfNamespaceKeywordTyped()
        {
            RunTypeKeywordTest("namespace");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfClassKeywordTyped()
        {
            RunTypeKeywordTest("class");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfLayoutKeywordTyped()
        {
            RunTypeKeywordTest("layout");
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/PartialParsing/PartialParsingTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Threading;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Test.Utils;
using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.PartialParsing
{
    public abstract class PartialParsingTestBase<TLanguage>
        where TLanguage : RazorCodeLanguage, new()
    {
        private const string TestLinePragmaFileName = "C:\\This\\Path\\Is\\Just\\For\\Line\\Pragmas.cshtml";

        protected static void RunFullReparseTest(TextChange change, PartialParseResult additionalFlags = (PartialParseResult)0)
        {
            // Arrange
            using (TestParserManager manager = CreateParserManager())
            {
                manager.InitializeWithDocument(change.OldBuffer);

                // Act
                PartialParseResult result = manager.CheckForStructureChangesAndWait(change);

                // Assert
                Assert.Equal(PartialParseResult.Rejected | additionalFlags, result);
                Assert.Equal(2, manager.ParseCount);
            }
        }

        protected static void RunPartialParseTest(TextChange change, Block newTreeRoot, PartialParseResult additionalFlags = (PartialParseResult)0)
        {
            // Arrange
            using (TestParserManager manager = CreateParserManager())
            {
                manager.InitializeWithDocument(change.OldBuffer);

                // Act
                PartialParseResult result = manager.CheckForStructureChangesAndWait(change);

                // Assert
                Assert.Equal(PartialParseResult.Accepted | additionalFlags, result);
                Assert.Equal(1, manager.ParseCount);
                ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree, newTreeRoot);
            }
        }

        protected static TestParserManager CreateParserManager()
        {
            RazorEngineHost host = CreateHost();
            RazorEditorParser parser = new RazorEditorParser(host, TestLinePragmaFileName);
            return new TestParserManager(parser);
        }

        protected static RazorEngineHost CreateHost()
        {
            return new RazorEngineHost(new TLanguage())
            {
                GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral", "WriteTo", "WriteLiteralTo", "Template", "DefineSection"),
                DesignTimeMode = true
            };
        }

        protected static void RunTypeKeywordTest(string keyword)
        {
            string before = "@" + keyword.Substring(0, keyword.Length - 1);
            string after = "@" + keyword;
            StringTextBuffer changed = new StringTextBuffer(after);
            StringTextBuffer old = new StringTextBuffer(before);
            RunFullReparseTest(new TextChange(keyword.Length, 0, old, 1, changed), additionalFlags: PartialParseResult.SpanContextChanged);
        }

        protected class TestParserManager : IDisposable
        {
            public RazorEditorParser Parser;
            public ManualResetEventSlim ParserComplete;
            public int ParseCount;

            public TestParserManager(RazorEditorParser parser)
            {
                ParserComplete = new ManualResetEventSlim();
                ParseCount = 0;
                Parser = parser;
                parser.DocumentParseComplete += (sender, args) =>
                {
                    Interlocked.Increment(ref ParseCount);
                    ParserComplete.Set();
                };
            }

            public void InitializeWithDocument(ITextBuffer startDocument)
            {
                CheckForStructureChangesAndWait(new TextChange(0, 0, new StringTextBuffer(String.Empty), startDocument.Length, startDocument));
            }

            public PartialParseResult CheckForStructureChangesAndWait(TextChange change)
            {
                PartialParseResult result = Parser.CheckForStructureChanges(change);
                if (result.HasFlag(PartialParseResult.Rejected))
                {
                    WaitForParse();
                }
                return result;
            }

            public void WaitForParse()
            {
                MiscUtils.DoWithTimeoutIfNotDebugging(ParserComplete.Wait); // Wait for the parse to finish
                ParserComplete.Reset();
            }

            public void Dispose()
            {
                Parser.Dispose();
                ParserComplete.Dispose();
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/PartialParsing/VBPartialParsingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.PartialParsing
{
    public class VBPartialParsingTest : PartialParsingTestBase<VBRazorCodeLanguage>
    {
        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsDeleteOfIdentifierPartsIfDotRemains()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @User. baz");
            StringTextBuffer old = new StringTextBuffer("foo @User.Name baz");
            RunPartialParseTest(new TextChange(10, 4, old, 0, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("User.")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")),
                additionalFlags: PartialParseResult.Provisional);
        }

        [Fact]
        public void ImplicitExpressionAcceptsDeleteOfIdentifierPartsIfSomeOfIdentifierRemains()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @Us baz");
            StringTextBuffer old = new StringTextBuffer("foo @User baz");
            RunPartialParseTest(new TextChange(7, 2, old, 0, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("Us")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsMultipleInsertionIfItCausesIdentifierExpansionAndTrailingDot()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @User. baz");
            StringTextBuffer old = new StringTextBuffer("foo @U baz");
            RunPartialParseTest(new TextChange(6, 0, old, 4, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("User.")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")),
                additionalFlags: PartialParseResult.Provisional);
        }

        [Fact]
        public void ImplicitExpressionAcceptsMultipleInsertionIfItOnlyCausesIdentifierExpansion()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @barbiz baz");
            StringTextBuffer old = new StringTextBuffer("foo @bar baz");
            RunPartialParseTest(new TextChange(8, 0, old, 3, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("barbiz")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ImplicitExpressionRejectsChangeWhichWouldHaveBeenAcceptedIfLastChangeWasProvisionallyAcceptedOnDifferentSpan()
        {
            var factory = SpanFactory.CreateVbHtml();

            // Arrange
            TextChange dotTyped = new TextChange(8, 0, new StringTextBuffer("foo @foo @bar"), 1, new StringTextBuffer("foo @foo. @bar"));
            TextChange charTyped = new TextChange(14, 0, new StringTextBuffer("foo @foo. @barb"), 1, new StringTextBuffer("foo @foo. @barb"));
            using (TestParserManager manager = CreateParserManager())
            {
                manager.InitializeWithDocument(dotTyped.OldBuffer);

                // Apply the dot change
                Assert.Equal(PartialParseResult.Provisional | PartialParseResult.Accepted, manager.CheckForStructureChangesAndWait(dotTyped));

                // Act (apply the identifier start char change)
                PartialParseResult result = manager.CheckForStructureChangesAndWait(charTyped);

                // Assert
                Assert.Equal(PartialParseResult.Rejected, result);
                Assert.False(manager.Parser.LastResultProvisional, "LastResultProvisional flag should have been cleared but it was not");
                ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree,
                    new MarkupBlock(
                        factory.Markup("foo "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo")
                                   .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Markup(". "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("barb")
                                   .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.EmptyHtml()));
            }
        }

        [Fact]
        public void ImplicitExpressionAcceptsIdentifierTypedAfterDotIfLastChangeWasProvisionalAcceptanceOfDot()
        {
            var factory = SpanFactory.CreateVbHtml();

            // Arrange
            TextChange dotTyped = new TextChange(8, 0, new StringTextBuffer("foo @foo bar"), 1, new StringTextBuffer("foo @foo. bar"));
            TextChange charTyped = new TextChange(9, 0, new StringTextBuffer("foo @foo. bar"), 1, new StringTextBuffer("foo @foo.b bar"));
            using (TestParserManager manager = CreateParserManager())
            {
                manager.InitializeWithDocument(dotTyped.OldBuffer);

                // Apply the dot change
                Assert.Equal(PartialParseResult.Provisional | PartialParseResult.Accepted, manager.CheckForStructureChangesAndWait(dotTyped));

                // Act (apply the identifier start char change)
                PartialParseResult result = manager.CheckForStructureChangesAndWait(charTyped);

                // Assert
                Assert.Equal(PartialParseResult.Accepted, result);
                Assert.False(manager.Parser.LastResultProvisional, "LastResultProvisional flag should have been cleared but it was not");
                ParserTestBase.EvaluateParseTree(manager.Parser.CurrentParseTree,
                    new MarkupBlock(
                        factory.Markup("foo "),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo.b")
                                   .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Markup(" bar")));
            }
        }
        [Fact]
        public void ImplicitExpressionAcceptsIdentifierExpansionAtEndOfNonWhitespaceCharacters()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("@Code" + Environment.NewLine
                                                          + "    @food" + Environment.NewLine
                                                          + "End Code");
            StringTextBuffer old = new StringTextBuffer("@Code" + Environment.NewLine
                                                      + "    @foo" + Environment.NewLine
                                                      + "End Code");
            RunPartialParseTest(new TextChange(15, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("Code")
                               .Accepts(AcceptedCharacters.None),
                        factory.Code("\r\n    ").AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("food")
                                   .AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Code("\r\n").AsStatement(),
                        factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionProvisionallyAcceptsDotAfterIdentifierInMarkup()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @foo. bar");
            StringTextBuffer old = new StringTextBuffer("foo @foo bar");
            RunPartialParseTest(new TextChange(8, 0, old, 1, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("foo.")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" bar")),
                additionalFlags: PartialParseResult.Provisional);
        }

        [Fact]
        public void ImplicitExpressionAcceptsAdditionalIdentifierCharactersIfEndOfSpanIsIdentifier()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("foo @foob baz");
            StringTextBuffer old = new StringTextBuffer("foo @foo bar");
            RunPartialParseTest(new TextChange(8, 0, old, 1, changed),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("foob")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" bar")));
        }

        [Fact]
        public void ImplicitExpressionAcceptsAdditionalIdentifierStartCharactersIfEndOfSpanIsDot()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("@Code @foo.b End Code");
            StringTextBuffer old = new StringTextBuffer("@Code @foo. End Code");
            RunPartialParseTest(new TextChange(11, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                        factory.Code(" ").AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo.b")
                                   .AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Code(" ").AsStatement(),
                        factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionAcceptsDotIfTrailingDotsAreAllowed()
        {
            var factory = SpanFactory.CreateVbHtml();
            StringTextBuffer changed = new StringTextBuffer("@Code @foo. End Code");
            StringTextBuffer old = new StringTextBuffer("@Code @foo End Code");
            RunPartialParseTest(new TextChange(10, 0, old, 1, changed),
                new MarkupBlock(
                    factory.EmptyHtml(),
                    new StatementBlock(
                        factory.CodeTransition(),
                        factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                        factory.Code(" ").AsStatement(),
                        new ExpressionBlock(
                            factory.CodeTransition(),
                            factory.Code("foo.")
                                   .AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        factory.Code(" ").AsStatement(),
                        factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)),
                    factory.EmptyHtml()));
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfFunctionsKeywordTyped()
        {
            RunTypeKeywordTest("functions");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfCodeKeywordTyped()
        {
            RunTypeKeywordTest("code");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfSectionKeywordTyped()
        {
            RunTypeKeywordTest("section");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfDoKeywordTyped()
        {
            RunTypeKeywordTest("do");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfWhileKeywordTyped()
        {
            RunTypeKeywordTest("while");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfIfKeywordTyped()
        {
            RunTypeKeywordTest("if");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfSelectKeywordTyped()
        {
            RunTypeKeywordTest("select");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfForKeywordTyped()
        {
            RunTypeKeywordTest("for");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfTryKeywordTyped()
        {
            RunTypeKeywordTest("try");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfWithKeywordTyped()
        {
            RunTypeKeywordTest("with");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfSyncLockKeywordTyped()
        {
            RunTypeKeywordTest("synclock");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfUsingKeywordTyped()
        {
            RunTypeKeywordTest("using");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfImportsKeywordTyped()
        {
            RunTypeKeywordTest("imports");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfInheritsKeywordTyped()
        {
            RunTypeKeywordTest("inherits");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfOptionKeywordTyped()
        {
            RunTypeKeywordTest("option");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfHelperKeywordTyped()
        {
            RunTypeKeywordTest("helper");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfNamespaceKeywordTyped()
        {
            RunTypeKeywordTest("namespace");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfClassKeywordTyped()
        {
            RunTypeKeywordTest("class");
        }

        [Fact]
        public void ImplicitExpressionCorrectlyTriggersReparseIfLayoutKeywordTyped()
        {
            RunTypeKeywordTest("layout");
        }
    }
}

================================================
FILE: test/System.Web.Razor.Test/Parser/RazorParserTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Razor.Test.Parser
{
    public class RazorParserTest
    {
        [Fact]
        public void ConstructorRequiresNonNullCodeParser()
        {
            Assert.ThrowsArgumentNull(() => new RazorParser(null, new HtmlMarkupParser()), "codeParser");
        }

        [Fact]
        public void ConstructorRequiresNonNullMarkupParser()
        {
            Assert.ThrowsArgumentNull(() => new RazorParser(new CSharpCodeParser(), null), "markupParser");
        }

        [Fact]
        public void ParseMethodCallsParseDocumentOnMarkupParserAndReturnsResults()
        {
            var factory = SpanFactory.CreateCsHtml();

            // Arrange
            RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());

            // Act/Assert
            ParserTestBase.EvaluateResults(parser.Parse(new StringReader("foo @bar baz")),
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void Parse_ParsesDocumentAndInvokesVisitor()
        {
            // Arrange
            var factory = SpanFactory.CreateCsHtml();
            var visitor = new Mock<ParserVisitor> { CallBase = true };
            var parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());

            // Act
            parser.Parse(new StringReader("foo @bar baz"), visitor.Object);

            // Assert
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Markup && s.Content == "foo ")));
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Transition && s.Content == "@")));
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Code && s.Content == "bar")));
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Markup && s.Content == " baz")));
        }

        [Fact]
        public async Task CreateParseTask_ParsesDocumentAndInvokesVisitor()
        {
            // Arrange
            var factory = SpanFactory.CreateCsHtml();
            var visitor = new Mock<ParserVisitor> { CallBase = true };
            var parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());

            // Act
            var task = parser.CreateParseTask(new StringReader("foo @bar baz"), visitor.Object);
            task.Start();
            await task;

            // Assert
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Markup && s.Content == "foo ")));
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Transition && s.Content == "@")));
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Code && s.Content == "bar")));
            visitor.Verify(v => v.VisitSpan(It.Is<Span>(s => s.Kind == SpanKind.Markup && s.Content == " baz")));
        }

        [Fact]
        public async Task CreateParseTask_ReturnsWithoutThrowingIfTaskIsCancelled()
        {
            // Arrange
            var factory = SpanFactory.CreateCsHtml();
            var visitor = new Mock<ParserVisitor> { CallBase = true };
            var parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());
            var cancelTokenSource = new CancellationTokenSource();
            var visited = false;

            // Act
            var task = parser.CreateParseTask(new StringReader("foo @bar baz"),
                                              (span) =>
                                              {
                                                  visited = true;
                                                  Assert.Equal("foo ", span.Content);
                                                  cancelTokenSource.Cancel();
                                              },
                                              errorCallback: null,
                                              cancelToken: cancelTokenSource.Token);
            task.Start();
            await task;

            // Assert
            Assert.True(visited);
        }

        [Fact]
        public void ParseMethodUsesProvidedParserListenerIfSpecified()
        {
            var factory = SpanFactory.CreateCsHtml();

            // Arrange
            RazorParser parser = new RazorParser(new CSharpCodeParser(), new HtmlMarkupParser());

            // Act
            ParserResults results = parser.Parse(new StringReader("foo @bar baz"));

            // Assert
            ParserTestBase.EvaluateResults(results,
                new MarkupBlock(
                    factory.Markup("foo "),
                    new ExpressionBlock(
                        factory.CodeTransition(),
                        factory.Code("bar")
                               .AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    factory.Markup(" baz")));
        }

        [Fact]
        public void ParseMethodSetsUpRunWithSpecifiedCodeParserMarkupParserAndListenerAndPassesToMarkupParser()
        {
            RunParseWithListenerTest((parser, reader) => parser.Parse(reader));
        }

        private static void RunParseWithListenerTest(Action<RazorParser, TextReader> parserAction)
        {
            // Arrange
            ParserBase markupParser = new MockMarkupParser();
            ParserBase codeParser = new CSharpCodeParser();
            RazorParser parser = new RazorParser(codeParser, markupParser);
            TextReader expectedReader = new StringReader("foo");

            // Act
            parserAction(parser, expectedReader);

            // Assert
            ParserContext actualContext = markupParser.Context;
            Assert.NotNull(actualContext);
            Assert.Same(markupParser, actualContext.MarkupParser);
            Assert.Same(markupParser, actualContext.ActiveParser);
            Assert.Same(codeParser, actualContext.CodeParser);
        }

        private class MockMarkupParser : ParserBase
        {
            public override bool IsMarkupParser
            {
                get
                {
                    return true;
                }
            }

            public override void ParseDocument()
            {
                using (Context.StartBlock(BlockType.Markup))
                {
                }
            }

            public override void ParseSection(Tuple<string, string> nestingSequences, bool caseSensitive = true)
            {
                using (Context.StartBlock(BlockType.Markup))
                {
                }
            }

            public override void ParseBlock()
            {
                using (Context.StartBlock(BlockType.Markup))
                {
                }
            }

            protected override ParserBase OtherParser
            {
                get { return Context.CodeParser; }
            }

            public override void BuildSpan(SpanBuilder span, Razor.Text.SourceLocation start, string content)
            {
                throw new NotImplementedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBAutoCompleteTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBAutoCompleteTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void FunctionsDirective_AutoComplete_At_EOF()
        {
            ParseBlockTest("@Functions",
                new FunctionsBlock(
                    Factory.CodeTransition("@")
                           .Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Functions")
                           .Accepts(AcceptedCharacters.None),
                    Factory.EmptyVB()
                           .AsFunctionsBody()
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
                           {
                               AutoCompleteString = SyntaxConstants.VB.EndFunctionsKeyword
                           })),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Functions", "End Functions"),
                    1, 0, 1));
        }

        [Fact]
        public void HelperDirective_AutoComplete_At_EOF()
        {
            ParseBlockTest("@Helper Strong(value As String)",
                new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Strong(value As String)", 8, 0, 8), headerComplete: true),
                    Factory.CodeTransition(),
                    Factory.MetaCode("Helper ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Strong(value As String)")
                           .Hidden()
                           .Accepts(AcceptedCharacters.None)
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = SyntaxConstants.VB.EndHelperKeyword }),
                    new StatementBlock()),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Helper", "End Helper"),
                    1, 0, 1));
        }

        [Fact]
        public void SectionDirective_AutoComplete_At_EOF()
        {
            ParseBlockTest("@Section Header",
                new SectionBlock(new SectionCodeGenerator("Header"),
                    Factory.CodeTransition(),
                    Factory.MetaCode("Section Header")
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = SyntaxConstants.VB.EndSectionKeyword }),
                    new MarkupBlock()),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Section", "End Section"),
                    1, 0, 1));
        }

        [Fact]
        public void VerbatimBlock_AutoComplete_At_EOF()
        {
            ParseBlockTest("@Code",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Span(SpanKind.Code, new VBSymbol(5, 0, 5, String.Empty, VBSymbolType.Unknown))
                           .With(new StatementCodeGenerator())
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = SyntaxConstants.VB.EndCodeKeyword })),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Code", "End Code"),
                    1, 0, 1));
        }

        [Fact]
        public void FunctionsDirective_AutoComplete_At_StartOfFile()
        {
            ParseBlockTest("@Functions" + Environment.NewLine
                         + "foo",
                new FunctionsBlock(
                    Factory.CodeTransition("@").Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Functions").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\nfoo")
                           .AsFunctionsBody()
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString)
                           {
                               AutoCompleteString = SyntaxConstants.VB.EndFunctionsKeyword
                           })),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Functions", "End Functions"),
                    1, 0, 1));
        }

        [Fact]
        public void HelperDirective_AutoComplete_At_StartOfFile()
        {
            ParseBlockTest("@Helper Strong(value As String)" + Environment.NewLine
                         + "Foo",
                new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Strong(value As String)", 8, 0, 8), headerComplete: true),
                    Factory.CodeTransition(),
                    Factory.MetaCode("Helper ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Strong(value As String)")
                           .Hidden()
                           .Accepts(AcceptedCharacters.None)
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = SyntaxConstants.VB.EndHelperKeyword }),
                    new StatementBlock(
                        Factory.Code("\r\nFoo").AsStatement())),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Helper", "End Helper"),
                    1, 0, 1));
        }

        [Fact]
        public void SectionDirective_AutoComplete_At_StartOfFile()
        {
            ParseBlockTest("@Section Header" + Environment.NewLine
                         + "Foo",
                new SectionBlock(new SectionCodeGenerator("Header"),
                    Factory.CodeTransition(),
                    Factory.MetaCode("Section Header")
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = SyntaxConstants.VB.EndSectionKeyword }),
                    new MarkupBlock(
                        Factory.Markup("\r\nFoo")
                               .With(new MarkupCodeGenerator()))),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Section", "End Section"),
                    1, 0, 1));
        }

        [Fact]
        public void VerbatimBlock_AutoComplete_At_StartOfFile()
        {
            ParseBlockTest("@Code" + Environment.NewLine
                         + "Foo",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\nFoo")
                           .AsStatement()
                           .With(new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = SyntaxConstants.VB.EndCodeKeyword })),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Code", "End Code"),
                    1, 0, 1));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBBlockTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBBlockTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseBlockMethodThrowsArgNullExceptionOnNullContext()
        {
            // Arrange
            VBCodeParser parser = new VBCodeParser();

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => parser.ParseBlock(), RazorResources.Parser_Context_Not_Set);
        }

        [Fact]
        public void ParseBlockAcceptsImplicitExpression()
        {
            ParseBlockTest("If True Then" + Environment.NewLine
                         + "    @foo" + Environment.NewLine
                         + "End If",
                new StatementBlock(
                    Factory.Code("If True Then\r\n    ").AsStatement(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Code("\r\nEnd If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockAcceptsIfStatementWithinCodeBlockIfInDesignTimeMode()
        {
            ParseBlockTest("If True Then" + Environment.NewLine
                         + "    @If True Then" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End If",
                new StatementBlock(
                    Factory.Code("If True Then\r\n    ").AsStatement(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("If True Then\r\n    End If\r\n")
                               .AsStatement()
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code(@"End If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSupportsSpacesInStrings()
        {
            ParseBlockTest("for each p in db.Query(\"SELECT * FROM PRODUCTS\")" + Environment.NewLine
                         + "    @<p>@p.Name</p>" + Environment.NewLine
                         + "next",
                new StatementBlock(
                    Factory.Code("for each p in db.Query(\"SELECT * FROM PRODUCTS\")\r\n")
                           .AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("    "),
                        Factory.MarkupTransition(),
                        Factory.Markup("<p>"),
                        new ExpressionBlock(
                            Factory.CodeTransition(),
                            Factory.Code("p.Name")
                                   .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                                   .Accepts(AcceptedCharacters.NonWhiteSpace)),
                        Factory.Markup("</p>\r\n").Accepts(AcceptedCharacters.None)),
                    Factory.Code("next")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.WhiteSpace | AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void ParseBlockSupportsSimpleCodeBlock()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    If foo IsNot Nothing" + Environment.NewLine
                         + "        Bar(foo)" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    If foo IsNot Nothing\r\n        Bar(foo)\r\n    End If\r\n")
                           .AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockRejectsNewlineBetweenEndAndCodeIfNotPrefixedWithUnderscore()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    If foo IsNot Nothing" + Environment.NewLine
                         + "        Bar(foo)" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End" + Environment.NewLine
                         + "Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    If foo IsNot Nothing\r\n        Bar(foo)\r\n    End If\r\nEnd\r\nCode")
                           .AsStatement()),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Code", "End Code"),
                    SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockAcceptsNewlineBetweenEndAndCodeIfPrefixedWithUnderscore()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    If foo IsNot Nothing" + Environment.NewLine
                         + "        Bar(foo)" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End _" + Environment.NewLine
                         + "_" + Environment.NewLine
                         + " _" + Environment.NewLine
                         + "Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    If foo IsNot Nothing\r\n        Bar(foo)\r\n    End If\r\n")
                           .AsStatement(),
                    Factory.MetaCode("End _\r\n_\r\n _\r\nCode").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockSupportsSimpleFunctionsBlock()
        {
            ParseBlockTest("Functions" + Environment.NewLine
                         + "    Public Sub Foo()" + Environment.NewLine
                         + "        Bar()" + Environment.NewLine
                         + "    End Sub" + Environment.NewLine
                         + Environment.NewLine
                         + "    Private Function Bar() As Object" + Environment.NewLine
                         + "        Return Nothing" + Environment.NewLine
                         + "    End Function" + Environment.NewLine
                         + "End Functions",
                new FunctionsBlock(
                    Factory.MetaCode("Functions").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    Public Sub Foo()\r\n        Bar()\r\n    End Sub\r\n\r\n    Private Function Bar() As Object\r\n        Return Nothing\r\n    End Function\r\n")
                           .AsFunctionsBody(),
                    Factory.MetaCode("End Functions").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockRejectsNewlineBetweenEndAndFunctionsIfNotPrefixedWithUnderscore()
        {
            ParseBlockTest("Functions" + Environment.NewLine
                         + "    If foo IsNot Nothing" + Environment.NewLine
                         + "        Bar(foo)" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End" + Environment.NewLine
                         + "Functions",
                new FunctionsBlock(
                    Factory.MetaCode("Functions").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    If foo IsNot Nothing\r\n        Bar(foo)\r\n    End If\r\nEnd\r\nFunctions")
                           .AsFunctionsBody()),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Functions", "End Functions"),
                    SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockAcceptsNewlineBetweenEndAndFunctionsIfPrefixedWithUnderscore()
        {
            ParseBlockTest("Functions" + Environment.NewLine
                         + "    If foo IsNot Nothing" + Environment.NewLine
                         + "        Bar(foo)" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End _" + Environment.NewLine
                         + "_" + Environment.NewLine
                         + " _" + Environment.NewLine
                         + "Functions",
                new FunctionsBlock(
                    Factory.MetaCode("Functions").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    If foo IsNot Nothing\r\n        Bar(foo)\r\n    End If\r\n")
                           .AsFunctionsBody(),
                    Factory.MetaCode("End _\r\n_\r\n _\r\nFunctions").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockCorrectlyHandlesExtraEndsInEndCode()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    Bar End" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    Bar End\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockCorrectlyHandlesExtraEndsInEndFunctions()
        {
            ParseBlockTest("Functions" + Environment.NewLine
                         + "    Bar End" + Environment.NewLine
                         + "End Functions",
                new FunctionsBlock(
                    Factory.MetaCode("Functions").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    Bar End\r\n").AsFunctionsBody().AutoCompleteWith(null, atEndOfSpan: false),
                    Factory.MetaCode("End Functions").Accepts(AcceptedCharacters.None)));
        }

        [Theory]
        [InlineData("If", "End", "If")]
        [InlineData("Try", "End", "Try")]
        [InlineData("While", "End", "While")]
        [InlineData("Using", "End", "Using")]
        [InlineData("With", "End", "With")]
        public void KeywordAllowsNewlinesIfPrefixedByUnderscore(string startKeyword, string endKeyword1, string endKeyword2)
        {
            string code = startKeyword + Environment.NewLine
                        + "    ' In the block" + Environment.NewLine
                        + endKeyword1 + " _" + Environment.NewLine
                        + "_" + Environment.NewLine
                        + "_" + Environment.NewLine
                        + "_" + Environment.NewLine
                        + "_" + Environment.NewLine
                        + "_" + Environment.NewLine
                        + "  " + endKeyword2 + Environment.NewLine;
            ParseBlockTest(code + "foo bar baz",
                new StatementBlock(
                    Factory.Code(code)
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Theory]
        [InlineData("While", "EndWhile", "End While")]
        [InlineData("If", "EndIf", "End If")]
        [InlineData("Select", "EndSelect", "End Select")]
        [InlineData("Try", "EndTry", "End Try")]
        [InlineData("With", "EndWith", "End With")]
        [InlineData("Using", "EndUsing", "End Using")]
        public void EndTerminatedKeywordRequiresSpaceBetweenEndAndKeyword(string startKeyword, string wrongEndKeyword, string endKeyword)
        {
            string code = startKeyword + Environment.NewLine
                        + "    ' This should not end the code" + Environment.NewLine
                        + "    " + wrongEndKeyword + Environment.NewLine
                        + "    ' But this should" + Environment.NewLine
                        + endKeyword;
            ParseBlockTest(code,
                new StatementBlock(
                    Factory.Code(code)
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Theory]
        [InlineData("While", "End While", false)]
        [InlineData("Do", "Loop", true)]
        [InlineData("If", "End If", false)]
        [InlineData("Select", "End Select", false)]
        [InlineData("For", "Next", true)]
        [InlineData("Try", "End Try", false)]
        [InlineData("With", "End With", false)]
        [InlineData("Using", "End Using", false)]
        public void EndSequenceInString(string keyword, string endSequence, bool acceptToEndOfLine)
        {
            string code = keyword + Environment.NewLine
                        + "    \"" + endSequence + "\"" + Environment.NewLine
                        + endSequence + (acceptToEndOfLine ? " foo bar baz" : "") + Environment.NewLine;
            ParseBlockTest(code + "biz boz",
                new StatementBlock(
                    Factory.Code(code).AsStatement().Accepts(GetAcceptedCharacters(acceptToEndOfLine))));
        }

        [Theory]
        [InlineData("While", "End While", false)]
        [InlineData("Do", "Loop", true)]
        [InlineData("If", "End If", false)]
        [InlineData("Select", "End Select", false)]
        [InlineData("For", "Next", true)]
        [InlineData("Try", "End Try", false)]
        [InlineData("With", "End With", false)]
        [InlineData("Using", "End Using", false)]
        private void CommentedEndSequence(string keyword, string endSequence, bool acceptToEndOfLine)
        {
            string code = keyword + Environment.NewLine
                        + "    '" + endSequence + Environment.NewLine
                        + endSequence + (acceptToEndOfLine ? @" foo bar baz" : "") + Environment.NewLine;
            ParseBlockTest(code + "biz boz",
                new StatementBlock(
                    Factory.Code(code).AsStatement().Accepts(GetAcceptedCharacters(acceptToEndOfLine))));
        }

        [Theory]
        [InlineData("While", "End While", false)]
        [InlineData("Do", "Loop", true)]
        [InlineData("If", "End If", false)]
        [InlineData("Select", "End Select", false)]
        [InlineData("For", "Next", true)]
        [InlineData("Try", "End Try", false)]
        [InlineData("With", "End With", false)]
        [InlineData("SyncLock", "End SyncLock", false)]
        [InlineData("Using", "End Using", false)]
        private void NestedKeywordBlock(string keyword, string endSequence, bool acceptToEndOfLine)
        {
            string code = keyword + Environment.NewLine
                        + "    " + keyword + Environment.NewLine
                        + "        Bar(foo)" + Environment.NewLine
                        + "    " + endSequence + Environment.NewLine
                        + endSequence + (acceptToEndOfLine ? " foo bar baz" : "") + Environment.NewLine;
            ParseBlockTest(code + "biz boz",
                new StatementBlock(
                    Factory.Code(code).AsStatement().Accepts(GetAcceptedCharacters(acceptToEndOfLine))));
        }

        [Theory]
        [InlineData("While True", "End While", false)]
        [InlineData("Do", "Loop", true)]
        [InlineData("If foo IsNot Nothing", "End If", false)]
        [InlineData("Select Case foo", "End Select", false)]
        [InlineData("For Each p in Products", "Next", true)]
        [InlineData("Try", "End Try", false)]
        [InlineData("With", "End With", false)]
        [InlineData("SyncLock", "End SyncLock", false)]
        [InlineData("Using", "End Using", false)]
        private void SimpleKeywordBlock(string keyword, string endSequence, bool acceptToEndOfLine)
        {
            string code = keyword + Environment.NewLine
                        + "    Bar(foo)" + Environment.NewLine
                        + endSequence + (acceptToEndOfLine ? " foo bar baz" : "") + Environment.NewLine;
            ParseBlockTest(code + "biz boz",
                new StatementBlock(
                    Factory.Code(code).AsStatement().Accepts(GetAcceptedCharacters(acceptToEndOfLine))));
        }

        [Theory]
        [InlineData("While True", "Exit While", "End While", false)]
        [InlineData("Do", "Exit Do", "Loop", true)]
        [InlineData("For Each p in Products", "Exit For", "Next", true)]
        [InlineData("While True", "Continue While", "End While", false)]
        [InlineData("Do", "Continue Do", "Loop", true)]
        [InlineData("For Each p in Products", "Continue For", "Next", true)]
        private void KeywordWithExitOrContinue(string startKeyword, string exitKeyword, string endKeyword, bool acceptToEndOfLine)
        {
            string code = startKeyword + Environment.NewLine
                         + "    ' This is before the exit" + Environment.NewLine
                         + "    " + exitKeyword + Environment.NewLine
                         + "    ' This is after the exit" + Environment.NewLine
                         + endKeyword + Environment.NewLine;
            ParseBlockTest(code + "foo bar baz",
                new StatementBlock(
                    Factory.Code(code).AsStatement().Accepts(GetAcceptedCharacters(acceptToEndOfLine))));
        }

        private AcceptedCharacters GetAcceptedCharacters(bool acceptToEndOfLine)
        {
            return acceptToEndOfLine ?
                AcceptedCharacters.WhiteSpace | AcceptedCharacters.NonWhiteSpace :
                AcceptedCharacters.None;
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBContinueStatementTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    // VB Continue Statement: http://msdn.microsoft.com/en-us/library/801hyx6f.aspx
    public class VBContinueStatementTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void VB_Do_Statement_With_Continue()
        {
            ParseBlockTest("@Do While True" + Environment.NewLine
                         + "    Continue Do" + Environment.NewLine
                         + "Loop" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Do While True\r\n    Continue Do\r\nLoop\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_For_Statement_With_Continue()
        {
            ParseBlockTest("@For i = 1 To 12" + Environment.NewLine
                         + "    Continue For" + Environment.NewLine
                         + "Next i" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("For i = 1 To 12\r\n    Continue For\r\nNext i\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_While_Statement_With_Continue()
        {
            ParseBlockTest("@While True" + Environment.NewLine
                         + "    Continue While" + Environment.NewLine
                         + "End While" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("While True\r\n    Continue While\r\nEnd While\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBDirectiveTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBDirectiveTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void VB_Code_Directive()
        {
            ParseBlockTest("@Code" + Environment.NewLine
                         + "    foo()" + Environment.NewLine
                         + "End Code" + Environment.NewLine
                         + "' Not part of the block",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Code")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    foo()\r\n")
                           .AsStatement()
                           .With(new AutoCompleteEditHandler(VBLanguageCharacteristics.Instance.TokenizeString)),
                    Factory.MetaCode("End Code")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Functions_Directive()
        {
            ParseBlockTest("@Functions" + Environment.NewLine
                         + "    Public Function Foo() As String" + Environment.NewLine
                         + "        Return \"Foo\"" + Environment.NewLine
                         + "    End Function" + Environment.NewLine
                         + Environment.NewLine
                         + "    Public Sub Bar()" + Environment.NewLine
                         + "    End Sub" + Environment.NewLine
                         + "End Functions" + Environment.NewLine
                         + "' Not part of the block",
                new FunctionsBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Functions")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    Public Function Foo() As String\r\n        Return \"Foo\"\r\n    End Function\r\n\r\n    Public Sub Bar()\r\n    End Sub\r\n")
                           .AsFunctionsBody(),
                    Factory.MetaCode("End Functions")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Section_Directive()
        {
            ParseBlockTest("@Section Header" + Environment.NewLine
                         + "    <p>Foo</p>" + Environment.NewLine
                         + "End Section",
                new SectionBlock(new SectionCodeGenerator("Header"),
                    Factory.CodeTransition(SyntaxConstants.TransitionString),
                    Factory.MetaCode("Section Header"),
                    new MarkupBlock(
                        Factory.Markup("\r\n    <p>Foo</p>\r\n")),
                    Factory.MetaCode("End Section")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void SessionStateDirectiveWorks()
        {
            ParseBlockTest("@SessionState InProc" + Environment.NewLine,
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("SessionState ")
                        .Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("InProc\r\n")
                        .Accepts(AcceptedCharacters.None)
                        .With(new RazorDirectiveAttributeCodeGenerator("SessionState", "InProc"))
                )
            );
        }

        [Fact]
        public void SessionStateDirectiveIsCaseInsensitive()
        {
            ParseBlockTest("@sessionstate disabled" + Environment.NewLine,
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("sessionstate ")
                        .Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("disabled\r\n")
                        .Accepts(AcceptedCharacters.None)
                        .With(new RazorDirectiveAttributeCodeGenerator("SessionState", "disabled"))
                )
            );
        }

        [Fact]
        public void VB_Helper_Directive()
        {
            ParseBlockTest("@Helper Strong(s as String)" + Environment.NewLine
                         + "    s = s.ToUpperCase()" + Environment.NewLine
                         + "    @<strong>s</strong>" + Environment.NewLine
                         + "End Helper",
                new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Strong(s as String)", 8, 0, 8), headerComplete: true),
                    Factory.CodeTransition(SyntaxConstants.TransitionString),
                    Factory.MetaCode("Helper ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Strong(s as String)").Hidden(),
                    new StatementBlock(
                        Factory.Code("\r\n    s = s.ToUpperCase()\r\n")
                               .AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("    "),
                            Factory.MarkupTransition(SyntaxConstants.TransitionString),
                            Factory.Markup("<strong>s</strong>\r\n")
                                   .Accepts(AcceptedCharacters.None)),
                        Factory.EmptyVB()
                               .AsStatement(),
                        Factory.MetaCode("End Helper")
                               .Accepts(AcceptedCharacters.None))));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBErrorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBErrorTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void ParserOutputsErrorAndRecoversToEndOfLineIfExplicitExpressionUnterminated()
        {
            ParseBlockTest(@"(foo
bar",
                new ExpressionBlock(
                    Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                    Factory.Code("foo").AsExpression()),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                        RazorResources.BlockName_ExplicitExpression,
                        ")", "("),
                    SourceLocation.Zero));
        }

        [Fact]
        public void ParserOutputsZeroLengthCodeSpanIfEofReachedAfterStartOfExplicitExpression()
        {
            ParseBlockTest("(",
                new ExpressionBlock(
                    Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                    Factory.EmptyVB().AsExpression()),
                new RazorError(
                    String.Format(RazorResources.ParseError_Expected_EndOfBlock_Before_EOF, "explicit expression", ")", "("),
                    SourceLocation.Zero));
        }

        [Fact]
        public void ParserOutputsZeroLengthCodeSpanIfEofReachedAfterAtSign()
        {
            ParseBlockTest(String.Empty,
                new ExpressionBlock(
                    Factory.EmptyVB().AsImplicitExpression(KeywordSet).Accepts(AcceptedCharacters.NonWhiteSpace)),
                new RazorError(
                    RazorResources.ParseError_Unexpected_EndOfFile_At_Start_Of_CodeBlock,
                    SourceLocation.Zero));
        }

        [Fact]
        public void ParserOutputsZeroLengthCodeSpanIfOnlyWhitespaceFoundAfterAtSign()
        {
            ParseBlockTest(" ",
                new ExpressionBlock(
                    Factory.EmptyVB().AsImplicitExpression(KeywordSet).Accepts(AcceptedCharacters.NonWhiteSpace)),
                new RazorError(
                    RazorResources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_VB,
                    SourceLocation.Zero));
        }

        [Fact]
        public void ParserOutputsZeroLengthCodeSpanIfInvalidCharacterFoundAfterAtSign()
        {
            ParseBlockTest("!!!",
                new ExpressionBlock(
                    Factory.EmptyVB().AsImplicitExpression(KeywordSet).Accepts(AcceptedCharacters.NonWhiteSpace)),
                new RazorError(
                    String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_VB, "!"),
                    SourceLocation.Zero));
        }

        [Theory]
        [InlineData("Code", "End Code", true, true)]
        [InlineData("Do", "Loop", false, false)]
        [InlineData("While", "End While", false, false)]
        [InlineData("If", "End If", false, false)]
        [InlineData("Select Case", "End Select", false, false)]
        [InlineData("For", "Next", false, false)]
        [InlineData("Try", "End Try", false, false)]
        [InlineData("With", "End With", false, false)]
        [InlineData("Using", "End Using", false, false)]
        public void EofBlock(string keyword, string expectedTerminator, bool autoComplete, bool keywordIsMetaCode)
        {
            EofBlockCore(keyword, expectedTerminator, autoComplete, BlockType.Statement, keywordIsMetaCode, c => c.AsStatement());
        }

        [Fact]
        public void EofFunctionsBlock()
        {
            EofBlockCore("Functions", "End Functions", true, BlockType.Functions, true, c => c.AsFunctionsBody());
        }

        private void EofBlockCore(string keyword, string expectedTerminator, bool autoComplete, BlockType blockType, bool keywordIsMetaCode, Func<UnclassifiedCodeSpanConstructor, SpanConstructor> classifier)
        {
            BlockBuilder expected = new BlockBuilder();
            expected.Type = blockType;
            if (keywordIsMetaCode)
            {
                expected.Children.Add(Factory.MetaCode(keyword).Accepts(AcceptedCharacters.None));
                expected.Children.Add(
                classifier(Factory.EmptyVB())
                       .With((SpanEditHandler)(
                            autoComplete ?
                                new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = expectedTerminator } :
                                SpanEditHandler.CreateDefault())));
            }
            else
            {
                expected.Children.Add(
                    classifier(Factory.Code(keyword))
                           .With((SpanEditHandler)(
                                autoComplete ?
                                    new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = expectedTerminator } :
                                    SpanEditHandler.CreateDefault())));
            }

            ParseBlockTest(keyword,
                expected.Build(),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, keyword, expectedTerminator),
                    SourceLocation.Zero));
        }

        [Theory]
        [InlineData("Code", "End Code", true)]
        [InlineData("Do", "Loop", false)]
        [InlineData("While", "End While", false)]
        [InlineData("If", "End If", false)]
        [InlineData("Select Case", "End Select", false)]
        [InlineData("For", "Next", false)]
        [InlineData("Try", "End Try", false)]
        [InlineData("With", "End With", false)]
        [InlineData("Using", "End Using", false)]
        public void UnterminatedBlock(string keyword, string expectedTerminator, bool keywordIsMetaCode)
        {
            UnterminatedBlockCore(keyword, expectedTerminator, BlockType.Statement, keywordIsMetaCode, c => c.AsStatement());
        }

        [Fact]
        public void UnterminatedFunctionsBlock()
        {
            UnterminatedBlockCore("Functions", "End Functions", BlockType.Functions, true, c => c.AsFunctionsBody());
        }

        private void UnterminatedBlockCore(string keyword, string expectedTerminator, BlockType blockType, bool keywordIsMetaCode, Func<UnclassifiedCodeSpanConstructor, SpanConstructor> classifier)
        {
            const string blockBody = @"
    ' This block is not correctly terminated!";

            BlockBuilder expected = new BlockBuilder();
            expected.Type = blockType;
            if (keywordIsMetaCode)
            {
                expected.Children.Add(Factory.MetaCode(keyword).Accepts(AcceptedCharacters.None));
                expected.Children.Add(classifier(Factory.Code(blockBody)));
            }
            else
            {
                expected.Children.Add(classifier(Factory.Code(keyword + blockBody)));
            }

            ParseBlockTest(keyword + blockBody,
                expected.Build(),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, keyword, expectedTerminator),
                    SourceLocation.Zero));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBExitStatementTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    // VB Exit Statement: http://msdn.microsoft.com/en-us/library/t2at9t47.aspx
    public class VBExitStatementTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void VB_Do_Statement_With_Exit()
        {
            ParseBlockTest("@Do While True" + Environment.NewLine
                         + "    Exit Do" + Environment.NewLine
                         + "Loop" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Do While True\r\n    Exit Do\r\nLoop\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_For_Statement_With_Exit()
        {
            ParseBlockTest("@For i = 1 To 12" + Environment.NewLine
                         + "    Exit For" + Environment.NewLine
                         + "Next i" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("For i = 1 To 12\r\n    Exit For\r\nNext i\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_Select_Statement_With_Exit()
        {
            ParseBlockTest("@Select Case Foo" + Environment.NewLine
                         + "    Case 1" + Environment.NewLine
                         + "        Exit Select" + Environment.NewLine
                         + "    Case 2" + Environment.NewLine
                         + "        Exit Select" + Environment.NewLine
                         + "End Select" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Select Case Foo\r\n    Case 1\r\n        Exit Select\r\n    Case 2\r\n        Exit Select\r\nEnd Select\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Try_Statement_With_Exit()
        {
            ParseBlockTest("@Try" + Environment.NewLine
                         + "    Foo()" + Environment.NewLine
                         + "    Exit Try" + Environment.NewLine
                         + "Catch Bar" + Environment.NewLine
                         + "    Throw Bar" + Environment.NewLine
                         + "Finally" + Environment.NewLine
                         + "    Baz()" + Environment.NewLine
                         + "End Try" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("Try\r\n    Foo()\r\n    Exit Try\r\nCatch Bar\r\n    Throw Bar\r\nFinally\r\n    Baz()\r\nEnd Try\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_While_Statement_With_Exit()
        {
            ParseBlockTest("@While True" + Environment.NewLine
                         + "    Exit While" + Environment.NewLine
                         + "End While" + Environment.NewLine
                         + "' Not in the block!",
                new StatementBlock(
                    Factory.CodeTransition(SyntaxConstants.TransitionString)
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("While True\r\n    Exit While\r\nEnd While\r\n")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBExplicitExpressionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBExplicitExpressionTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void VB_Simple_ExplicitExpression()
        {
            ParseBlockTest("@(foo)",
                new ExpressionBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                    Factory.Code("foo").AsExpression(),
                    Factory.MetaCode(")").Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBExpressionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBExpressionTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseBlockCorrectlyHandlesCodeBlockInBodyOfExplicitExpressionDueToUnclosedExpression()
        {
            ParseBlockTest(@"(
@Code
    Dim foo = bar
End Code",
                new ExpressionBlock(
                    Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                    Factory.EmptyVB().AsExpression()),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Expected_EndOfBlock_Before_EOF,
                        RazorResources.BlockName_ExplicitExpression,
                        ")", "("),
                     SourceLocation.Zero));
        }

        [Fact]
        public void ParseBlockAcceptsNonEnglishCharactersThatAreValidIdentifiers()
        {
            ImplicitExpressionTest("हळूँजद॔.", "हळूँजद॔");
        }

        [Fact]
        public void ParseBlockDoesNotTreatXmlAxisPropertyAsTransitionToMarkup()
        {
            SingleSpanBlockTest(
                @"If foo Is Nothing Then
    Dim bar As XElement
    Dim foo = bar.<foo>
End If",
                BlockType.Statement,
                SpanKind.Code,
                acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockDoesNotTreatXmlAttributePropertyAsTransitionToMarkup()
        {
            SingleSpanBlockTest(
                @"If foo Is Nothing Then
    Dim bar As XElement
    Dim foo = bar.@foo
End If",
                BlockType.Statement,
                SpanKind.Code,
                acceptedCharacters: AcceptedCharacters.None);
        }

        [Fact]
        public void ParseBlockSupportsSimpleImplicitExpression()
        {
            ImplicitExpressionTest("Foo");
        }

        [Fact]
        public void ParseBlockSupportsImplicitExpressionWithDots()
        {
            ImplicitExpressionTest("Foo.Bar.Baz");
        }

        [Fact]
        public void ParseBlockSupportsImplicitExpressionWithParens()
        {
            ImplicitExpressionTest("Foo().Bar().Baz()");
        }

        [Fact]
        public void ParseBlockSupportsImplicitExpressionWithStuffInParens()
        {
            ImplicitExpressionTest("Foo().Bar(sdfkhj sdfksdfjs \")\" sjdfkjsdf).Baz()");
        }

        [Fact]
        public void ParseBlockSupportsImplicitExpressionWithCommentInParens()
        {
            ImplicitExpressionTest("Foo().Bar(sdfkhj sdfksdfjs \")\" '))))))))\r\nsjdfkjsdf).Baz()");
        }

        [Theory]
        [InlineData("Foo")]
        [InlineData("Foo(Of String).Bar(1, 2, 3).Biz")]
        [InlineData("Foo(Of String).Bar(\")\").Biz")]
        [InlineData("Foo(Of String).Bar(\"Foo\"\"Bar)\"\"Baz\").Biz")]
        [InlineData("\"foo\r\nbar")]
        [InlineData("Foo.Bar. _\r\nREM )\r\nBaz()\r\n")]
        [InlineData("Foo.Bar. _\r\n' )\r\nBaz()\r\n")]
        public void ValidExplicitExpressions(string body)
        {
            ParseBlockTest("(" + body + ")",
                new ExpressionBlock(
                    Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                    Factory.Code(body).AsExpression(),
                    Factory.MetaCode(")").Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBExpressionsInCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBExpressionsInCodeTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void InnerImplicitExpressionWithOnlySingleAtAcceptsSingleSpaceOrNewlineAtDesignTime()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    @" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    ").AsStatement(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.EmptyVB()
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Code("\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(RazorResources.ParseError_Unexpected_WhiteSpace_At_Start_Of_CodeBlock_VB, 11, 1, 5)
                });
        }

        [Fact]
        public void InnerImplicitExpressionDoesNotAcceptDotAfterAt()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    @." + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    ").AsStatement(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.EmptyVB()
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Code(".\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(
                        String.Format(RazorResources.ParseError_Unexpected_Character_At_Start_Of_CodeBlock_VB, "."), 
                        11, 1, 5)
                });
        }

        [Theory]
        [InlineData("Foo.Bar.", true)]
        [InlineData("Foo", true)]
        [InlineData("Foo.Bar.Baz", true)]
        [InlineData("Foo().Bar().Baz()", true)]
        [InlineData("Foo().Bar(sdfkhj sdfksdfjs \")\" sjdfkjsdf).Baz()", true)]
        [InlineData("Foo().Bar(sdfkhj sdfksdfjs \")\" '))))))))\r\nsjdfkjsdf).Baz()", true)]
        [InlineData("Foo", false)]
        [InlineData("Foo(Of String).Bar(1, 2, 3).Biz", false)]
        [InlineData("Foo(Of String).Bar(\")\").Biz", false)]
        [InlineData("Foo(Of String).Bar(\"Foo\"\"Bar)\"\"Baz\").Biz", false)]
        [InlineData("Foo.Bar. _\r\nREM )\r\nBaz()\r\n", false)]
        [InlineData("Foo.Bar. _\r\n' )\r\nBaz()\r\n", false)]
        public void ExpressionInCode(string expression, bool isImplicit)
        {
            ExpressionBlock expressionBlock;
            if (isImplicit)
            {
                expressionBlock =
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code(expression)
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords, acceptTrailingDot: true)
                               .Accepts(AcceptedCharacters.NonWhiteSpace));
            }
            else
            {
                expressionBlock =
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                        Factory.Code(expression).AsExpression(),
                        Factory.MetaCode(")").Accepts(AcceptedCharacters.None));
            }

            string code;
            if (isImplicit)
            {
                code = "If foo IsNot Nothing Then" + Environment.NewLine
                     + "    @" + expression + Environment.NewLine
                     + "End If";
            }
            else
            {
                code = "If foo IsNot Nothing Then" + Environment.NewLine
                     + "    @(" + expression + ")" + Environment.NewLine
                     + "End If";
            }

            ParseBlockTest(code,
                new StatementBlock(
                    Factory.Code("If foo IsNot Nothing Then\r\n    ")
                           .AsStatement(),
                    expressionBlock,
                    Factory.Code("\r\nEnd If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBHelperTest : VBHtmlMarkupParserTestBase
    {
        [Fact]
        public void ParseHelperOutputsErrorButContinuesIfLParenFoundAfterHelperKeyword()
        {
            ParseDocumentTest("@Helper ()",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("()", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("()").Hidden().AutoCompleteWith(SyntaxConstants.VB.EndHelperKeyword),
                        new StatementBlock())),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        String.Format(RazorResources.ErrorComponent_Character, "(")),
                    8, 0, 8),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Helper", "End Helper"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseHelperStatementOutputsMarkerHelperHeaderSpanOnceKeywordComplete()
        {
            ParseDocumentTest("@Helper ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>(String.Empty, 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.EmptyVB().Hidden())),
                new RazorError(
                    String.Format(RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start, RazorResources.ErrorComponent_EndOfFile),
                    8, 0, 8));
        }

        [Fact]
        public void ParseHelperStatementMarksHelperSpanAsCanGrowIfMissingTrailingSpace()
        {
            ParseDocumentTest("@Helper",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper"))),
                new RazorError(
                    String.Format(RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start, RazorResources.ErrorComponent_EndOfFile),
                    7, 0, 7));
        }

        [Fact]
        public void ParseHelperStatementTerminatesEarlyIfHeaderNotComplete()
        {
            ParseDocumentTest("@Helper" + Environment.NewLine
                            + "@Helper",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper\r\n").Accepts(AcceptedCharacters.None),
                        Factory.EmptyVB().Hidden()),
                    new HelperBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper"))),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(
                        String.Format(
                            RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start, 
                            String.Format(RazorResources.ErrorComponent_Character, "@")),
                        9, 1, 0),
                    new RazorError(
                        String.Format(
                            RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start, 
                            RazorResources.ErrorComponent_EndOfFile),
                        16, 1, 7)
                });
        }

        [Fact]
        public void ParseHelperStatementTerminatesEarlyIfHeaderNotCompleteWithSpace()
        {
            ParseDocumentTest(@"@Helper @Helper",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>(String.Empty, 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode(@"Helper ").Accepts(AcceptedCharacters.None),
                        Factory.EmptyVB().Hidden()),
                    new HelperBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper").Accepts(AcceptedCharacters.Any))),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(
                        String.Format(
                            RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                            String.Format(RazorResources.ErrorComponent_Character, "@")),
                        8, 0, 8),
                    new RazorError(
                        String.Format(
                            RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start, 
                            RazorResources.ErrorComponent_EndOfFile),
                        15, 0, 15)
                });
        }

        [Fact]
        public void ParseHelperStatementAllowsDifferentlyCasedEndHelperKeyword()
        {
            ParseDocumentTest("@Helper Foo()" + Environment.NewLine
                            + "end helper",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo()", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo()").Hidden(),
                        new StatementBlock(
                            Factory.Code("\r\n").AsStatement(),
                            Factory.MetaCode("end helper").Accepts(AcceptedCharacters.None))),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseHelperStatementCapturesWhitespaceToEndOfLineIfHelperStatementMissingName()
        {
            ParseDocumentTest("@Helper                       " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("                      ", 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("                      ").Hidden()),
                    Factory.Markup("\r\n    ")),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Helper_Name_Start,
                        RazorResources.ErrorComponent_Newline),
                    30, 0, 30));
        }

        [Fact]
        public void ParseHelperStatementCapturesWhitespaceToEndOfLineIfHelperStatementMissingOpenParen()
        {
            ParseDocumentTest("@Helper Foo    " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo    ", 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo    ").Hidden()),
                    Factory.Markup("\r\n    ")),
                new RazorError(
                    String.Format(RazorResources.ParseError_MissingCharAfterHelperName, "("),
                    15, 0, 15));
        }

        [Fact]
        public void ParseHelperStatementCapturesAllContentToEndOfFileIfHelperStatementMissingCloseParenInParameterList()
        {
            ParseDocumentTest("@Helper Foo(Foo Bar" + Environment.NewLine
                            + "Biz" + Environment.NewLine
                            + "Boz",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(Foo Bar\r\nBiz\r\nBoz", 8, 0, 8), headerComplete: false),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(Foo Bar\r\nBiz\r\nBoz").Hidden())),
                new RazorError(RazorResources.ParseError_UnterminatedHelperParameterList, 11, 0, 11));
        }

        [Fact]
        public void ParseHelperStatementCapturesWhitespaceToEndOfLineIfHelperStatementMissingOpenBraceAfterParameterList()
        {
            ParseDocumentTest("@Helper Foo(foo as String)    " + Environment.NewLine,
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(foo as String)", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(foo as String)")
                               .Hidden()
                               .AutoCompleteWith(SyntaxConstants.VB.EndHelperKeyword),
                        new StatementBlock(
                            Factory.Code("    \r\n").AsStatement()))),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Helper", "End Helper"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseHelperStatementContinuesParsingHelperUntilEOF()
        {
            ParseDocumentTest("@Helper Foo(foo as String)" + Environment.NewLine
                            + "    @<p>Foo</p>",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(foo as String)", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(foo as String)")
                               .Hidden()
                               .AutoCompleteWith(SyntaxConstants.VB.EndHelperKeyword),
                        new StatementBlock(
                            Factory.Code("\r\n").AsStatement(),
                            new MarkupBlock(
                                Factory.Markup("    "),
                                Factory.MarkupTransition(),
                                Factory.Markup("<p>Foo</p>").Accepts(AcceptedCharacters.None)),
                            Factory.EmptyVB().AsStatement()))),
                new RazorError(
                    String.Format(RazorResources.ParseError_BlockNotTerminated, "Helper", "End Helper"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseHelperStatementCorrectlyParsesHelperWithEmbeddedCode()
        {
            ParseDocumentTest("@Helper Foo(foo as String, bar as String)" + Environment.NewLine
                            + "    @<p>@foo</p>" + Environment.NewLine
                            + "End Helper",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(foo as String, bar as String)", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(foo as String, bar as String)").Hidden(),
                        new StatementBlock(
                            Factory.Code("\r\n").AsStatement(),
                            new MarkupBlock(
                                Factory.Markup("    "),
                                Factory.MarkupTransition(),
                                Factory.Markup("<p>"),
                                new ExpressionBlock(
                                    Factory.CodeTransition(),
                                    Factory.Code("foo")
                                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                                           .Accepts(AcceptedCharacters.NonWhiteSpace)),
                                Factory.Markup("</p>\r\n").Accepts(AcceptedCharacters.None)),
                            Factory.EmptyVB().AsStatement(),
                            Factory.MetaCode("End Helper").Accepts(AcceptedCharacters.None))),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseHelperStatementGivesWhitespaceAfterCloseParenToMarkup()
        {
            ParseDocumentTest("@Helper Foo(string foo)     " + Environment.NewLine
                            + "    ",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo)", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(string foo)")
                               .Hidden()
                               .AutoCompleteWith(SyntaxConstants.VB.EndHelperKeyword),
                        new StatementBlock(
                            Factory.Code("     \r\n    ").AsStatement()))),
                designTimeParser: true,
                expectedErrors:
                    new RazorError(
                        String.Format(
                            RazorResources.ParseError_BlockNotTerminated,
                            "Helper", "End Helper"),
                        1, 0, 1));
        }

        [Fact]
        public void ParseHelperAcceptsNestedHelpersButOutputsError()
        {
            ParseDocumentTest("@Helper Foo(string foo)" + Environment.NewLine
                            + "    @Helper Bar(string baz)" + Environment.NewLine
                            + "    End Helper" + Environment.NewLine
                            + "End Helper",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Foo(string foo)", 8, 0, 8), headerComplete: true),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo(string foo)").Hidden(),
                        new StatementBlock(
                            Factory.Code("\r\n    ").AsStatement(),
                            new HelperBlock(new HelperCodeGenerator(new LocationTagged<string>("Bar(string baz)", 37, 1, 12), headerComplete: true),
                                Factory.CodeTransition(),
                                Factory.MetaCode("Helper ").Accepts(AcceptedCharacters.None),
                                Factory.Code("Bar(string baz)").Hidden(),
                                new StatementBlock(
                                    Factory.Code("\r\n    ").AsStatement(),
                                    Factory.MetaCode("End Helper").Accepts(AcceptedCharacters.None))),
                            Factory.Code("\r\n").AsStatement(),
                            Factory.MetaCode("End Helper").Accepts(AcceptedCharacters.None))),
                    Factory.EmptyHtml()),
                designTimeParser: true,
                expectedErrors: new[]
                {
                    new RazorError(
                        RazorResources.ParseError_Helpers_Cannot_Be_Nested,
                        30, 1, 5)
                });
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBHtmlDocumentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBHtmlDocumentTest : VBHtmlMarkupParserTestBase
    {
        [Fact]
        public void BlockCommentInMarkupDocumentIsHandledCorrectly()
        {
            ParseDocumentTest(@"<ul>" + Environment.NewLine
                            + @"                @* This is a block comment </ul> *@ foo",
                new MarkupBlock(
                    Factory.Markup("<ul>" + Environment.NewLine + "                "),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.Comment(" This is a block comment </ul> ", HtmlSymbolType.RazorComment),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)),
                    Factory.Markup(" foo")));
        }

        [Fact]
        public void BlockCommentInMarkupBlockIsHandledCorrectly()
        {
            ParseBlockTest(@"<ul>" + Environment.NewLine
                         + @"                @* This is a block comment </ul> *@ foo </ul>",
                new MarkupBlock(
                    Factory.Markup("<ul>" + Environment.NewLine + "                "),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.Comment(" This is a block comment </ul> ", HtmlSymbolType.RazorComment),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)),
                    Factory.Markup(" foo </ul>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void BlockCommentAtStatementStartInCodeBlockIsHandledCorrectly()
        {
            ParseDocumentTest(@"@If Request.IsAuthenticated Then" + Environment.NewLine
                            + @"    @* User is logged in! End If *@" + Environment.NewLine
                            + @"    Write(""Hello friend!"")" + Environment.NewLine
                            + @"End If",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("If Request.IsAuthenticated Then" + Environment.NewLine + "    ").AsStatement(),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.Comment(" User is logged in! End If ", VBSymbolType.RazorComment),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)),
                        Factory.Code("" + Environment.NewLine + "    Write(\"Hello friend!\")" + Environment.NewLine + "End If")
                               .AsStatement()
                               .Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInStatementInCodeBlockIsHandledCorrectly()
        {
            ParseDocumentTest(@"@If Request.IsAuthenticated Then" + Environment.NewLine
                            + @"    Dim foo = @* User is logged in! End If *@ bar" + Environment.NewLine
                            + @"    Write(""Hello friend!"")" + Environment.NewLine
                            + @"End If",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("If Request.IsAuthenticated Then" + Environment.NewLine + "    Dim foo = ").AsStatement(),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.Comment(" User is logged in! End If ", VBSymbolType.RazorComment),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)),
                        Factory.Code(" bar" + Environment.NewLine + "    Write(\"Hello friend!\")" + Environment.NewLine + "End If")
                               .AsStatement()
                               .Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInStringInCodeBlockIsIgnored()
        {
            ParseDocumentTest(@"@If Request.IsAuthenticated Then" + Environment.NewLine
                            + @"    Dim foo = ""@* User is logged in! End If *@ bar""" + Environment.NewLine
                            + @"    Write(""Hello friend!"")" + Environment.NewLine
                            + @"End If",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("If Request.IsAuthenticated Then" + Environment.NewLine + "    Dim foo = \"@* User is logged in! End If *@ bar\"" + Environment.NewLine + "    Write(\"Hello friend!\")" + Environment.NewLine + "End If")
                               .AsStatement()
                               .Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInTickCommentInCodeBlockIsIgnored()
        {
            ParseDocumentTest(@"@If Request.IsAuthenticated Then" + Environment.NewLine
                            + @"    Dim foo = '@* User is logged in! End If *@ bar" + Environment.NewLine
                            + @"    Write(""Hello friend!"")" + Environment.NewLine
                            + @"End If",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("If Request.IsAuthenticated Then" + Environment.NewLine + "    Dim foo = '@* User is logged in! End If *@ bar" + Environment.NewLine + "    Write(\"Hello friend!\")" + Environment.NewLine + "End If")
                               .AsStatement()
                               .Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInRemCommentInCodeBlockIsIgnored()
        {
            ParseDocumentTest(@"@If Request.IsAuthenticated Then" + Environment.NewLine
                            + @"    Dim foo = REM @* User is logged in! End If *@ bar" + Environment.NewLine
                            + @"    Write(""Hello friend!"")" + Environment.NewLine
                            + @"End If",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("If Request.IsAuthenticated Then" + Environment.NewLine + "    Dim foo = REM @* User is logged in! End If *@ bar" + Environment.NewLine + "    Write(\"Hello friend!\")" + Environment.NewLine + "End If")
                               .AsStatement()
                               .Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInImplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@Html.Foo@*bar*@",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Html.Foo")
                               .AsImplicitExpression(KeywordSet)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.EmptyHtml(),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.Comment("bar", HtmlSymbolType.RazorComment),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentAfterDotOfImplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@Html.@*bar*@",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Html")
                               .AsImplicitExpression(KeywordSet)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("."),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.Comment("bar", HtmlSymbolType.RazorComment),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInParensOfImplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest("@Html.Foo(@*bar*@ 4)",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Html.Foo(")
                               .AsImplicitExpression(KeywordSet)
                               .Accepts(AcceptedCharacters.Any),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.Comment("bar", VBSymbolType.RazorComment),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)),
                        Factory.Code(" 4)")
                               .AsImplicitExpression(KeywordSet)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInConditionIsHandledCorrectly()
        {
            ParseDocumentTest("@If @*bar*@ Then End If",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.Code("If ").AsStatement(),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.Comment("bar", VBSymbolType.RazorComment),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)),
                        Factory.Code(" Then End If").AsStatement().Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void BlockCommentInExplicitExpressionIsHandledCorrectly()
        {
            ParseDocumentTest(@"@(1 + @*bar*@ 1)",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                        Factory.Code(@"1 + ").AsExpression(),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.Comment("bar", VBSymbolType.RazorComment),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar).Accepts(AcceptedCharacters.None),
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)
                            ),
                        Factory.Code(" 1").AsExpression(),
                        Factory.MetaCode(")").Accepts(AcceptedCharacters.None)
                        ),
                    Factory.EmptyHtml()));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBImplicitExpressionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBImplicitExpressionTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void VB_Simple_ImplicitExpression()
        {
            ParseBlockTest("@foo not-part-of-the-block",
                new ExpressionBlock(
                    Factory.CodeTransition(),
                    Factory.Code("foo")
                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                           .Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void VB_ImplicitExpression_With_Keyword_At_Start()
        {
            ParseBlockTest("@Partial",
                new ExpressionBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Partial")
                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                           .Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void VB_ImplicitExpression_With_Keyword_In_Body()
        {
            ParseBlockTest("@Html.Partial",
                new ExpressionBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Html.Partial")
                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                           .Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void VB_ImplicitExpression_With_MethodCallOrArrayIndex()
        {
            ParseBlockTest("@foo(42) not-part-of-the-block",
                new ExpressionBlock(
                    Factory.CodeTransition(),
                    Factory.Code("foo(42)")
                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                           .Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void VB_ImplicitExpression_Terminates_If_Trailing_Dot_Not_Followed_By_Valid_Token()
        {
            ParseBlockTest("@foo(42). ",
                new ExpressionBlock(
                    Factory.CodeTransition(),
                    Factory.Code("foo(42)")
                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                           .Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void VB_ImplicitExpression_Supports_Complex_Expressions()
        {
            ParseBlockTest("@foo(42).bar(Biz.Boz / 42 * 8)(1).Burf not part of the block",
                new ExpressionBlock(
                    Factory.CodeTransition()
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("foo(42).bar(Biz.Boz / 42 * 8)(1).Burf")
                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                           .Accepts(AcceptedCharacters.NonWhiteSpace)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBLayoutDirectiveTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBLayoutDirectiveTest : VBHtmlCodeParserTestBase
    {
        [Theory]
        [InlineData("layout")]
        [InlineData("Layout")]
        [InlineData("LAYOUT")]
        [InlineData("layOut")]
        [InlineData("LayOut")]
        [InlineData("LaYoUt")]
        [InlineData("lAyOuT")]
        public void LayoutDirectiveSupportsAnyCasingOfKeyword(string keyword)
        {
            ParseBlockTest("@" + keyword,
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode(keyword)
                )
            );
        }

        [Fact]
        public void LayoutDirectiveAcceptsAllTextToEndOfLine()
        {
            ParseBlockTest("@Layout Foo Bar Baz",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Layout ").Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Foo Bar Baz")
                           .With(new SetLayoutCodeGenerator("Foo Bar Baz"))
                           .WithEditorHints(EditorHints.VirtualPath | EditorHints.LayoutPage)
                )
            );
        }

        [Fact]
        public void LayoutDirectiveAcceptsAnyIfNoWhitespaceFollowingLayoutKeyword()
        {
            ParseBlockTest("@Layout",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Layout")
                )
            );
        }

        [Fact]
        public void LayoutDirectiveOutputsMarkerSpanIfAnyWhitespaceAfterLayoutKeyword()
        {
            ParseBlockTest("@Layout ",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Layout ").Accepts(AcceptedCharacters.None),
                    Factory.EmptyVB()
                           .AsMetaCode()
                           .With(new SetLayoutCodeGenerator(String.Empty))
                           .WithEditorHints(EditorHints.VirtualPath | EditorHints.LayoutPage)
                )
            );
        }

        [Fact]
        public void LayoutDirectiveAcceptsTrailingNewlineButDoesNotIncludeItInLayoutPath()
        {
            ParseBlockTest("@Layout Foo" + Environment.NewLine,
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Layout ").Accepts(AcceptedCharacters.None),
                    Factory.MetaCode("Foo\r\n")
                           .With(new SetLayoutCodeGenerator("Foo"))
                           .Accepts(AcceptedCharacters.None)
                           .WithEditorHints(EditorHints.VirtualPath | EditorHints.LayoutPage)
                )
            );
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBNestedStatementsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBNestedStatementsTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void VB_Nested_If_Statement()
        {
            ParseBlockTest("@If True Then" + Environment.NewLine
                         + "    If False Then" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End If",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("If True Then\r\n    If False Then\r\n    End If\r\nEnd If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Nested_Do_Statement()
        {
            ParseBlockTest("@Do While True" + Environment.NewLine
                         + "    Do" + Environment.NewLine
                         + "    Loop Until False" + Environment.NewLine
                         + "Loop",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Do While True\r\n    Do\r\n    Loop Until False\r\nLoop")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_Nested_Markup_Statement_In_If()
        {
            ParseBlockTest("@If True Then" + Environment.NewLine
                         + "    @<p>Tag</p>" + Environment.NewLine
                         + "End If",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("If True Then\r\n")
                           .AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("    "),
                        Factory.MarkupTransition(),
                        Factory.Markup("<p>Tag</p>\r\n")
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code("End If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Nested_Markup_Statement_In_Code()
        {
            ParseBlockTest("@Code" + Environment.NewLine
                         + "    Foo()" + Environment.NewLine
                         + "    @<p>Tag</p>" + Environment.NewLine
                         + "    Bar()" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Code")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    Foo()\r\n")
                           .AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("    "),
                        Factory.MarkupTransition(),
                        Factory.Markup("<p>Tag</p>\r\n")
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code("    Bar()\r\n")
                           .AsStatement(),
                    Factory.MetaCode("End Code")
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Nested_Markup_Statement_In_Do()
        {
            ParseBlockTest("@Do" + Environment.NewLine
                         + "    @<p>Tag</p>" + Environment.NewLine
                         + "Loop While True",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Do\r\n")
                           .AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("    "),
                        Factory.MarkupTransition(),
                        Factory.Markup("<p>Tag</p>\r\n")
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code("Loop While True")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_Nested_Single_Line_Markup_Statement_In_Do()
        {
            ParseBlockTest("@Do" + Environment.NewLine
                         + "    @:<p>Tag" + Environment.NewLine
                         + "Loop While True",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Do\r\n")
                           .AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("    "),
                        Factory.MarkupTransition(),
                        Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                        Factory.Markup("<p>Tag\r\n")
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code("Loop While True")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_Nested_Implicit_Expression_In_If()
        {
            ParseBlockTest("@If True Then" + Environment.NewLine
                         + "    @Foo.Bar" + Environment.NewLine
                         + "End If",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("If True Then\r\n    ")
                           .AsStatement(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Foo.Bar")
                               .AsExpression()
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Code("\r\nEnd If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Nested_Explicit_Expression_In_If()
        {
            ParseBlockTest("@If True Then" + Environment.NewLine
                         + "    @(Foo.Bar + 42)" + Environment.NewLine
                         + "End If",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("If True Then\r\n    ")
                           .AsStatement(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("(")
                               .Accepts(AcceptedCharacters.None),
                        Factory.Code("Foo.Bar + 42")
                               .AsExpression(),
                        Factory.MetaCode(")")
                               .Accepts(AcceptedCharacters.None)),
                    Factory.Code("\r\nEnd If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBRazorCommentsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBRazorCommentsTest : VBHtmlMarkupParserTestBase
    {
        [Fact]
        public void UnterminatedRazorComment()
        {
            ParseDocumentTest("@*",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                               .Accepts(AcceptedCharacters.None),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                               .Accepts(AcceptedCharacters.None),
                        Factory.Span(SpanKind.Comment, new HtmlSymbol(
                            Factory.LocationTracker.CurrentLocation,
                            String.Empty,
                            HtmlSymbolType.Unknown))
                               .Accepts(AcceptedCharacters.Any))),
                new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 0, 0, 0));
        }

        [Fact]
        public void EmptyRazorComment()
        {
            ParseDocumentTest("@**@",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new CommentBlock(
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                               .Accepts(AcceptedCharacters.None),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                               .Accepts(AcceptedCharacters.None),
                        Factory.Span(SpanKind.Comment, new HtmlSymbol(
                            Factory.LocationTracker.CurrentLocation,
                            String.Empty,
                            HtmlSymbolType.Unknown))
                               .Accepts(AcceptedCharacters.Any),
                        Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                               .Accepts(AcceptedCharacters.None),
                        Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                               .Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void RazorCommentInImplicitExpressionMethodCall()
        {
            ParseDocumentTest(@"@foo(@**@",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo(")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.Span(SpanKind.Comment, new VBSymbol(
                                Factory.LocationTracker.CurrentLocation,
                                String.Empty,
                                VBSymbolType.Unknown))
                                   .Accepts(AcceptedCharacters.Any),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None)),
                        Factory.EmptyVB()
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords))),
                new RazorError(
                    String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF, "(", ")"),
                    4, 0, 4));
        }

        [Fact]
        public void UnterminatedRazorCommentInImplicitExpressionMethodCall()
        {
            ParseDocumentTest("@foo(@*",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("foo(")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.Span(SpanKind.Comment, new VBSymbol(
                                Factory.LocationTracker.CurrentLocation,
                                String.Empty,
                                VBSymbolType.Unknown))
                                    .Accepts(AcceptedCharacters.Any)))),
                new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 5, 0, 5),
                new RazorError(String.Format(RazorResources.ParseError_Expected_CloseBracket_Before_EOF, "(", ")"), 4, 0, 4));
        }

        [Fact]
        public void RazorCommentInVerbatimBlock()
        {
            ParseDocumentTest("@Code" + Environment.NewLine
                            + "    @<text" + Environment.NewLine
                            + "    @**@" + Environment.NewLine
                            + "End Code",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                        Factory.Code("\r\n").AsStatement(),
                        new MarkupBlock(
                            Factory.Markup("    "),
                            Factory.MarkupTransition("@"),
                            Factory.MarkupTransition("<text").Accepts(AcceptedCharacters.Any),
                            Factory.Markup("\r\n    "),
                            new CommentBlock(
                                Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                       .Accepts(AcceptedCharacters.None),
                                Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                                       .Accepts(AcceptedCharacters.None),
                                Factory.Span(SpanKind.Comment, new HtmlSymbol(
                                    Factory.LocationTracker.CurrentLocation,
                                    String.Empty,
                                    HtmlSymbolType.Unknown))
                                       .Accepts(AcceptedCharacters.Any),
                                Factory.MetaMarkup("*", HtmlSymbolType.RazorCommentStar)
                                       .Accepts(AcceptedCharacters.None),
                                Factory.MarkupTransition(HtmlSymbolType.RazorCommentTransition)
                                       .Accepts(AcceptedCharacters.None)),
                            Factory.Markup("\r\nEnd Code")))),
                new RazorError(RazorResources.ParseError_TextTagCannotContainAttributes, 12, 1, 5),
                new RazorError(String.Format(RazorResources.ParseError_MissingEndTag, "text"), 12, 1, 5),
                new RazorError(String.Format(RazorResources.ParseError_BlockNotTerminated, SyntaxConstants.VB.CodeKeyword, SyntaxConstants.VB.EndCodeKeyword), 1, 0, 1));
        }

        [Fact]
        public void UnterminatedRazorCommentInVerbatimBlock()
        {
            ParseDocumentTest("@Code" + Environment.NewLine
                            + "@*",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new StatementBlock(
                        Factory.CodeTransition(),
                        Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                        Factory.Code("\r\n")
                               .AsStatement(),
                        new CommentBlock(
                            Factory.CodeTransition(VBSymbolType.RazorCommentTransition)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.MetaCode("*", VBSymbolType.RazorCommentStar)
                                   .Accepts(AcceptedCharacters.None),
                            Factory.Span(SpanKind.Comment, new VBSymbol(Factory.LocationTracker.CurrentLocation,
                                                                        String.Empty,
                                                                        VBSymbolType.Unknown))
                                   .Accepts(AcceptedCharacters.Any)))),
                new RazorError(RazorResources.ParseError_RazorComment_Not_Terminated, 7, 1, 0),
                new RazorError(String.Format(RazorResources.ParseError_BlockNotTerminated, SyntaxConstants.VB.CodeKeyword, SyntaxConstants.VB.EndCodeKeyword), 1, 0, 1));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBReservedWordsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBReservedWordsTest : VBHtmlCodeParserTestBase
    {
        [Theory]
        [InlineData("Namespace")]
        [InlineData("Class")]
        [InlineData("NAMESPACE")]
        [InlineData("CLASS")]
        [InlineData("NameSpace")]
        [InlineData("nameSpace")]
        private void ReservedWords(string word)
        {
            ParseBlockTest(word,
                new DirectiveBlock(
                    Factory.MetaCode(word).Accepts(AcceptedCharacters.None)),
                new RazorError(
                    String.Format(RazorResources.ParseError_ReservedWord, word),
                    SourceLocation.Zero));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBSectionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBSectionTest : VBHtmlMarkupParserTestBase
    {
        [Fact]
        public void ParseSectionBlockCapturesNewlineImmediatelyFollowing()
        {
            ParseDocumentTest("@Section" + Environment.NewLine,
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator(String.Empty),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section\r\n"),
                        new MarkupBlock())),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start,
                        RazorResources.ErrorComponent_EndOfFile),
                    10, 1, 0),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_BlockNotTerminated,
                        "Section", "End Section"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseSectionRequiresNameBeOnSameLineAsSectionKeyword()
        {
            ParseDocumentTest("@Section " + Environment.NewLine
                            + "Foo" + Environment.NewLine
                            + "    <p>Body</p>" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator(String.Empty),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section "),
                        new MarkupBlock(
                            Factory.Markup("\r\nFoo\r\n    <p>Body</p>\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start,
                        RazorResources.ErrorComponent_Newline),
                    9, 0, 9));
        }

        [Fact]
        public void ParseSectionAllowsNameToBeOnDifferentLineAsSectionKeywordIfUnderscoresUsed()
        {
            ParseDocumentTest("@Section _" + Environment.NewLine
                            + "_" + Environment.NewLine
                            + "Foo" + Environment.NewLine
                            + "    <p>Body</p>" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section _\r\n_\r\nFoo"),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <p>Body</p>\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionReportsErrorAndTerminatesSectionBlockIfKeywordNotFollowedByIdentifierStartCharacter()
        {
            ParseDocumentTest("@Section 9" + Environment.NewLine
                            + "    <p>Foo</p>" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator(String.Empty),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section "),
                        new MarkupBlock(
                            Factory.Markup("9\r\n    <p>Foo</p>\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Unexpected_Character_At_Section_Name_Start,
                        String.Format(RazorResources.ErrorComponent_Character, "9")),
                    9, 0, 9));
        }

        [Fact]
        public void ParserOutputsErrorOnNestedSections()
        {
            ParseDocumentTest("@Section foo" + Environment.NewLine
                            + "    @Section bar" + Environment.NewLine
                            + "        <p>Foo</p>" + Environment.NewLine
                            + "    End Section" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section foo"),
                        new MarkupBlock(
                            Factory.Markup("\r\n"),
                            new SectionBlock(new SectionCodeGenerator("bar"),
                                Factory.Code("    ").AsStatement(),
                                Factory.CodeTransition(),
                                Factory.MetaCode("Section bar"),
                                new MarkupBlock(
                                    Factory.Markup("\r\n        <p>Foo</p>\r\n    ")),
                                Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                            Factory.Markup("\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_Sections_Cannot_Be_Nested,
                        RazorResources.SectionExample_VB),
                    26, 1, 12));
        }

        [Fact]
        public void ParseSectionHandlesEOFAfterIdentifier()
        {
            ParseDocumentTest("@Section foo",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section foo")
                               .AutoCompleteWith(SyntaxConstants.VB.EndSectionKeyword),
                        new MarkupBlock())),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_BlockNotTerminated,
                        "Section", "End Section"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseSectionHandlesUnterminatedSection()
        {
            ParseDocumentTest("@Section foo" + Environment.NewLine
                            + "    <p>Foo</p>",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section foo")
                               .AutoCompleteWith(SyntaxConstants.VB.EndSectionKeyword),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <p>Foo</p>")))),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_BlockNotTerminated,
                        "Section", "End Section"),
                    1, 0, 1));
        }

        [Fact]
        public void ParseDocumentParsesNamedSectionCorrectly()
        {
            ParseDocumentTest("@Section foo" + Environment.NewLine
                            + "    <p>Foo</p>" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section foo"),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <p>Foo</p>\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void ParseSectionTerminatesOnFirstEndSection()
        {
            ParseDocumentTest("@Section foo" + Environment.NewLine
                            + "    <p>End Section</p>",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section foo"),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <p>")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.Markup("</p>")));
        }

        [Fact]
        public void ParseSectionAllowsEndSectionInVBExpression()
        {
            ParseDocumentTest("@Section foo" + Environment.NewLine
                            + "    I really want to render the word @(\"End Section\"), so this is how I do it" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section foo"),
                        new MarkupBlock(
                            Factory.Markup("\r\n    I really want to render the word "),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                                Factory.Code("\"End Section\"").AsExpression(),
                                Factory.MetaCode(")").Accepts(AcceptedCharacters.None)),
                            Factory.Markup(", so this is how I do it\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        // These are tests that are normally in HtmlToCodeSwitchTest, but we want to verify them for VB 
        // since VB has slightly different section terminating behavior which follow slightly different
        // code paths

        [Fact]
        public void SectionBodyTreatsTwoAtSignsAsEscapeSequence()
        {
            ParseDocumentTest("@Section Foo" + Environment.NewLine
                            + "    <foo>@@bar</foo>" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section Foo").AutoCompleteWith(null),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <foo>"),
                            Factory.Markup("@").Hidden(),
                            Factory.Markup("@bar</foo>\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }

        [Fact]
        public void SectionBodyTreatsPairsOfAtSignsAsEscapeSequence()
        {
            ParseDocumentTest("@Section Foo" + Environment.NewLine
                            + "    <foo>@@@@@bar</foo>" + Environment.NewLine
                            + "End Section",
                new MarkupBlock(
                    Factory.EmptyHtml(),
                    new SectionBlock(new SectionCodeGenerator("Foo"),
                        Factory.CodeTransition(),
                        Factory.MetaCode("Section Foo").AutoCompleteWith(null),
                        new MarkupBlock(
                            Factory.Markup("\r\n    <foo>"),
                            Factory.Markup("@").Hidden(),
                            Factory.Markup("@"),
                            Factory.Markup("@").Hidden(),
                            Factory.Markup("@"),
                            new ExpressionBlock(
                                Factory.CodeTransition(),
                                Factory.Code("bar")
                                       .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                                       .Accepts(AcceptedCharacters.NonWhiteSpace)),
                            Factory.Markup("</foo>\r\n")),
                        Factory.MetaCode("End Section").Accepts(AcceptedCharacters.None)),
                    Factory.EmptyHtml()));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBSpecialKeywordsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBSpecialKeywordsTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseInheritsStatementMarksInheritsSpanAsCanGrowIfMissingTrailingSpace()
        {
            ParseBlockTest("inherits",
                new DirectiveBlock(
                    Factory.MetaCode("inherits")),
                new RazorError(
                    RazorResources.ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName,
                    8, 0, 8));
        }

        [Fact]
        public void InheritsBlockAcceptsMultipleGenericArguments()
        {
            ParseBlockTest("inherits Foo.Bar(Of Biz(Of Qux), String, Integer).Baz",
                new DirectiveBlock(
                    Factory.MetaCode("inherits ").Accepts(AcceptedCharacters.None),
                    Factory.Code("Foo.Bar(Of Biz(Of Qux), String, Integer).Baz")
                           .AsBaseType("Foo.Bar(Of Biz(Of Qux), String, Integer).Baz")));
        }

        [Fact]
        public void InheritsDirectiveSupportsVSTemplateTokens()
        {
            ParseBlockTest("@Inherits $rootnamespace$.MyBase",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Inherits ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("$rootnamespace$.MyBase")
                           .AsBaseType("$rootnamespace$.MyBase")));
        }

        [Fact]
        public void InheritsBlockOutputsErrorIfInheritsNotFollowedByTypeButAcceptsEntireLineAsCode()
        {
            ParseBlockTest("inherits                " + Environment.NewLine
                         + "foo",
                new DirectiveBlock(
                    Factory.MetaCode("inherits                ").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n").AsBaseType(String.Empty)),
                new RazorError(
                    RazorResources.ParseError_InheritsKeyword_Must_Be_Followed_By_TypeName,
                    8, 0, 8));
        }

        [Fact]
        public void ParseBlockShouldSupportNamespaceImports()
        {
            ParseBlockTest("Imports Foo.Bar.Baz.Biz.Boz",
                new DirectiveBlock(
                    Factory.MetaCode("Imports Foo.Bar.Baz.Biz.Boz")
                           .With(new AddImportCodeGenerator(
                               ns: " Foo.Bar.Baz.Biz.Boz",
                               namespaceKeywordLength: SyntaxConstants.VB.ImportsKeywordLength))));
        }

        [Fact]
        public void ParseBlockShowsErrorIfNamespaceNotOnSameLineAsImportsKeyword()
        {
            ParseBlockTest("Imports" + Environment.NewLine
                         + "Foo",
                new DirectiveBlock(
                    Factory.MetaCode("Imports\r\n")
                           .With(new AddImportCodeGenerator(
                               ns: "\r\n",
                               namespaceKeywordLength: SyntaxConstants.VB.ImportsKeywordLength))),
                new RazorError(
                    RazorResources.ParseError_NamespaceOrTypeAliasExpected,
                    7, 0, 7));
        }

        [Fact]
        public void ParseBlockShowsErrorIfTypeBeingAliasedNotOnSameLineAsImportsKeyword()
        {
            ParseBlockTest("Imports Foo =" + Environment.NewLine
                         + "System.Bar",
                new DirectiveBlock(
                    Factory.MetaCode("Imports Foo =\r\n")
                           .With(new AddImportCodeGenerator(
                               ns: " Foo =\r\n",
                               namespaceKeywordLength: SyntaxConstants.VB.ImportsKeywordLength))));
        }

        [Fact]
        public void ParseBlockShouldSupportTypeAliases()
        {
            ParseBlockTest("Imports Foo = Bar.Baz.Biz.Boz",
                new DirectiveBlock(
                    Factory.MetaCode("Imports Foo = Bar.Baz.Biz.Boz")
                           .With(new AddImportCodeGenerator(
                               ns: " Foo = Bar.Baz.Biz.Boz",
                               namespaceKeywordLength: SyntaxConstants.VB.ImportsKeywordLength))));
        }

        [Fact]
        public void ParseBlockThrowsErrorIfOptionIsNotFollowedByStrictOrExplicit()
        {
            ParseBlockTest("Option FizzBuzz On",
                new DirectiveBlock(
                    Factory.MetaCode("Option FizzBuzz On")
                           .With(new SetVBOptionCodeGenerator(optionName: null, value: true))),
                new RazorError(
                    String.Format(RazorResources.ParseError_UnknownOption, "FizzBuzz"),
                    7, 0, 7));
        }

        [Fact]
        public void ParseBlockThrowsErrorIfOptionStrictIsNotFollowedByOnOrOff()
        {
            ParseBlockTest("Option Strict Yes",
                new DirectiveBlock(
                    Factory.MetaCode("Option Strict Yes")
                           .With(SetVBOptionCodeGenerator.Strict(true))),
                new RazorError(
                    String.Format(
                        RazorResources.ParseError_InvalidOptionValue,
                        "Strict", "Yes"),
                    14, 0, 14));
        }

        [Fact]
        public void ParseBlockReadsToAfterOnKeywordIfOptionStrictBlock()
        {
            ParseBlockTest("Option Strict On Foo Bar Baz",
                new DirectiveBlock(
                    Factory.MetaCode("Option Strict On")
                           .With(SetVBOptionCodeGenerator.Strict(true))));
        }

        [Fact]
        public void ParseBlockReadsToAfterOffKeywordIfOptionStrictBlock()
        {
            ParseBlockTest("Option Strict Off Foo Bar Baz",
                new DirectiveBlock(
                    Factory.MetaCode("Option Strict Off")
                           .With(SetVBOptionCodeGenerator.Strict(false))));
        }

        [Fact]
        public void ParseBlockReadsToAfterOnKeywordIfOptionExplicitBlock()
        {
            ParseBlockTest("Option Explicit On Foo Bar Baz",
                new DirectiveBlock(
                    Factory.MetaCode("Option Explicit On")
                           .With(SetVBOptionCodeGenerator.Explicit(true))));
        }

        [Fact]
        public void ParseBlockReadsToAfterOffKeywordIfOptionExplicitBlock()
        {
            ParseBlockTest("Option Explicit Off Foo Bar Baz",
                new DirectiveBlock(
                    Factory.MetaCode("Option Explicit Off")
                           .With(SetVBOptionCodeGenerator.Explicit(false))));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBStatementTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBStatementTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void VB_Inherits_Statement()
        {
            ParseBlockTest("@Inherits System.Foo.Bar(Of Baz)",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Inherits ").Accepts(AcceptedCharacters.None),
                    Factory.Code("System.Foo.Bar(Of Baz)")
                           .AsBaseType("System.Foo.Bar(Of Baz)")));
        }

        [Fact]
        public void InheritsDirectiveSupportsArrays()
        {
            ParseBlockTest("@Inherits System.String(())()",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Inherits ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("System.String(())()")
                           .AsBaseType("System.String(())()")));
        }

        [Fact]
        public void InheritsDirectiveSupportsNestedGenerics()
        {
            ParseBlockTest("@Inherits System.Web.Mvc.WebViewPage(Of IEnumerable(Of MvcApplication2.Models.RegisterModel))",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Inherits ")
                           .Accepts(AcceptedCharacters.None),
                    Factory.Code("System.Web.Mvc.WebViewPage(Of IEnumerable(Of MvcApplication2.Models.RegisterModel))")
                           .AsBaseType("System.Web.Mvc.WebViewPage(Of IEnumerable(Of MvcApplication2.Models.RegisterModel))")));
        }

        [Fact]
        public void InheritsDirectiveSupportsTypeKeywords()
        {
            ParseBlockTest("@Inherits String",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Inherits ").Accepts(AcceptedCharacters.None),
                    Factory.Code("String").AsBaseType("String")));
        }

        [Fact]
        public void VB_Option_Strict_Statement()
        {
            ParseBlockTest("@Option Strict Off",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Option Strict Off")
                           .With(SetVBOptionCodeGenerator.Strict(false))));
        }

        [Fact]
        public void VB_Option_Explicit_Statement()
        {
            ParseBlockTest("@Option Explicit Off",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Option Explicit Off")
                           .With(SetVBOptionCodeGenerator.Explicit(false))));
        }

        [Fact]
        public void VB_Imports_Statement()
        {
            ParseBlockTest("@Imports Biz = System.Foo.Bar(Of Boz.Baz(Of Qux))",
                new DirectiveBlock(
                    Factory.CodeTransition(),
                    Factory.MetaCode("Imports Biz = System.Foo.Bar(Of Boz.Baz(Of Qux))")
                           .With(new AddImportCodeGenerator(
                               ns: " Biz = System.Foo.Bar(Of Boz.Baz(Of Qux))",
                               namespaceKeywordLength: SyntaxConstants.VB.ImportsKeywordLength))));
        }

        [Fact]
        public void VB_Using_Statement()
        {
            ParseBlockTest("@Using foo as Bar" + Environment.NewLine
                         + "    foo()" + Environment.NewLine
                         + "End Using",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Using foo as Bar\r\n    foo()\r\nEnd Using")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Do_Loop_Statement()
        {
            ParseBlockTest("@Do" + Environment.NewLine
                         + "    foo()" + Environment.NewLine
                         + "Loop While True",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Do\r\n    foo()\r\nLoop While True")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_While_Statement()
        {
            ParseBlockTest("@While True" + Environment.NewLine
                         + "    foo()" + Environment.NewLine
                         + "End While",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("While True\r\n    foo()\r\nEnd While")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_If_Statement()
        {
            ParseBlockTest("@If True Then" + Environment.NewLine
                         + "    foo()" + Environment.NewLine
                         + "ElseIf False Then" + Environment.NewLine
                         + "    bar()" + Environment.NewLine
                         + "Else" + Environment.NewLine
                         + "    baz()" + Environment.NewLine
                         + "End If",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("If True Then\r\n    foo()\r\nElseIf False Then\r\n    bar()\r\nElse\r\n    baz()\r\nEnd If")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_Select_Statement()
        {
            ParseBlockTest("@Select Case foo" + Environment.NewLine
                         + "    Case 1" + Environment.NewLine
                         + "        foo()" + Environment.NewLine
                         + "    Case 2" + Environment.NewLine
                         + "        bar()" + Environment.NewLine
                         + "    Case Else" + Environment.NewLine
                         + "        baz()" + Environment.NewLine
                         + "End Select",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Select Case foo\r\n    Case 1\r\n        foo()\r\n    Case 2\r\n        bar()\r\n    Case Else\r\n        baz()\r\nEnd Select")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_For_Statement()
        {
            ParseBlockTest("@For Each foo In bar" + Environment.NewLine
                         + "    baz()" + Environment.NewLine
                         + "Next",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("For Each foo In bar\r\n    baz()\r\nNext")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.AnyExceptNewline)));
        }

        [Fact]
        public void VB_Try_Statement()
        {
            ParseBlockTest("@Try" + Environment.NewLine
                         + "    foo()" + Environment.NewLine
                         + "Catch ex as Exception" + Environment.NewLine
                         + "    bar()" + Environment.NewLine
                         + "Finally" + Environment.NewLine
                         + "    baz()" + Environment.NewLine
                         + "End Try",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("Try\r\n    foo()\r\nCatch ex as Exception\r\n    bar()\r\nFinally\r\n    baz()\r\nEnd Try")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_With_Statement()
        {
            ParseBlockTest("@With foo" + Environment.NewLine
                         + "    .bar()" + Environment.NewLine
                         + "End With",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("With foo\r\n    .bar()\r\nEnd With")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void VB_SyncLock_Statement()
        {
            ParseBlockTest("@SyncLock foo" + Environment.NewLine
                         + "    foo.bar()" + Environment.NewLine
                         + "End SyncLock",
                new StatementBlock(
                    Factory.CodeTransition(),
                    Factory.Code("SyncLock foo\r\n    foo.bar()\r\nEnd SyncLock")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.None)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBTemplateTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Resources;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBTemplateTest : VBHtmlCodeParserTestBase
    {
        private const string TestTemplateCode = "@@<p>Foo #@item</p>";

        private TemplateBlock TestTemplate()
        {
            return new TemplateBlock(new TemplateBlockCodeGenerator(),
                new MarkupBlock(
                    Factory.MarkupTransition(),
                    Factory.MetaMarkup("@"),
                    Factory.Markup("<p>Foo #"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("item")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("</p>").Accepts(AcceptedCharacters.None)));
        }

        private const string TestNestedTemplateCode = "@@<p>Foo #@Html.Repeat(10,@@<p>@item</p>)</p>";

        private TemplateBlock TestNestedTemplate()
        {
            return new TemplateBlock(new TemplateBlockCodeGenerator(),
                new MarkupBlock(
                    Factory.MarkupTransition(),
                    Factory.MetaMarkup("@"),
                    Factory.Markup("<p>Foo #"),
                    new ExpressionBlock(
                        Factory.CodeTransition(),
                        Factory.Code("Html.Repeat(10,")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.Any),
                        new TemplateBlock(new TemplateBlockCodeGenerator(),
                            new MarkupBlock(
                                Factory.MarkupTransition(),
                                Factory.MetaMarkup("@"),
                                Factory.Markup("<p>"),
                                new ExpressionBlock(
                                    Factory.CodeTransition(),
                                    Factory.Code("item")
                                           .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                                           .Accepts(AcceptedCharacters.NonWhiteSpace)),
                                Factory.Markup("</p>").Accepts(AcceptedCharacters.None))),
                        Factory.Code(")")
                               .AsImplicitExpression(VBCodeParser.DefaultKeywords)
                               .Accepts(AcceptedCharacters.NonWhiteSpace)),
                    Factory.Markup("</p>").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockHandlesSimpleAnonymousSectionInExplicitExpressionParens()
        {
            ParseBlockTest("(Html.Repeat(10," + TestTemplateCode + "))",
                new ExpressionBlock(
                    Factory.MetaCode("(").Accepts(AcceptedCharacters.None),
                    Factory.Code("Html.Repeat(10,").AsExpression(),
                    TestTemplate(),
                    Factory.Code(")").AsExpression(),
                    Factory.MetaCode(")").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockHandlesSimpleAnonymousSectionInImplicitExpressionParens()
        {
            ParseBlockTest("Html.Repeat(10," + TestTemplateCode + ")",
                new ExpressionBlock(
                    Factory.Code("Html.Repeat(10,").AsImplicitExpression(KeywordSet),
                    TestTemplate(),
                    Factory.Code(")").AsImplicitExpression(KeywordSet).Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void ParseBlockHandlesTwoAnonymousSectionsInImplicitExpressionParens()
        {
            ParseBlockTest("Html.Repeat(10," + TestTemplateCode + "," + TestTemplateCode + ")",
                new ExpressionBlock(
                    Factory.Code("Html.Repeat(10,").AsImplicitExpression(KeywordSet),
                    TestTemplate(),
                    Factory.Code(",").AsImplicitExpression(KeywordSet),
                    TestTemplate(),
                    Factory.Code(")").AsImplicitExpression(KeywordSet).Accepts(AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void ParseBlockProducesErrorButCorrectlyParsesNestedAnonymousSectionInImplicitExpressionParens()
        {
            ParseBlockTest("Html.Repeat(10," + TestNestedTemplateCode + ")",
                new ExpressionBlock(
                    Factory.Code("Html.Repeat(10,").AsImplicitExpression(KeywordSet),
                    TestNestedTemplate(),
                    Factory.Code(")").AsImplicitExpression(KeywordSet).Accepts(AcceptedCharacters.NonWhiteSpace)),
                GetNestedSectionError(41, 0, 41));
        }

        [Fact]
        public void ParseBlockHandlesSimpleAnonymousSectionInStatementWithinCodeBlock()
        {
            ParseBlockTest("For Each foo in Bar " + Environment.NewLine
                         + "    Html.ExecuteTemplate(foo," + TestTemplateCode + ")" + Environment.NewLine
                         + "Next foo",
                new StatementBlock(
                    Factory.Code("For Each foo in Bar \r\n    Html.ExecuteTemplate(foo,")
                           .AsStatement(),
                    TestTemplate(),
                    Factory.Code(")\r\nNext foo")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.WhiteSpace | AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void ParseBlockHandlesTwoAnonymousSectionsInStatementWithinCodeBlock()
        {
            ParseBlockTest("For Each foo in Bar " + Environment.NewLine
                         + "    Html.ExecuteTemplate(foo," + TestTemplateCode + "," + TestTemplateCode + ")" + Environment.NewLine
                         + "Next foo",
                new StatementBlock(
                    Factory.Code("For Each foo in Bar \r\n    Html.ExecuteTemplate(foo,")
                           .AsStatement(),
                    TestTemplate(),
                    Factory.Code(",").AsStatement(),
                    TestTemplate(),
                    Factory.Code(")\r\nNext foo")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.WhiteSpace | AcceptedCharacters.NonWhiteSpace)));
        }

        [Fact]
        public void ParseBlockProducesErrorButCorrectlyParsesNestedAnonymousSectionInStatementWithinCodeBlock()
        {
            ParseBlockTest("For Each foo in Bar " + Environment.NewLine
                         + "    Html.ExecuteTemplate(foo," + TestNestedTemplateCode + ")" + Environment.NewLine
                         + "Next foo",
                new StatementBlock(
                    Factory.Code("For Each foo in Bar \r\n    Html.ExecuteTemplate(foo,")
                           .AsStatement(),
                    TestNestedTemplate(),
                    Factory.Code(")\r\nNext foo")
                           .AsStatement()
                           .Accepts(AcceptedCharacters.WhiteSpace | AcceptedCharacters.NonWhiteSpace)),
                GetNestedSectionError(77, 1, 55));
        }

        [Fact]
        public void ParseBlockHandlesSimpleAnonymousSectionInStatementWithinStatementBlock()
        {
            ParseBlockTest("Code " + Environment.NewLine
                         + "    Dim foo = bar" + Environment.NewLine
                         + "    Html.ExecuteTemplate(foo," + TestTemplateCode + ")" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code(" \r\n    Dim foo = bar\r\n    Html.ExecuteTemplate(foo,")
                           .AsStatement(),
                    TestTemplate(),
                    Factory.Code(")\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockHandlessTwoAnonymousSectionsInStatementWithinStatementBlock()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    Dim foo = bar" + Environment.NewLine
                         + "    Html.ExecuteTemplate(foo," + TestTemplateCode + "," + TestTemplateCode + ")" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    Dim foo = bar\r\n    Html.ExecuteTemplate(foo,")
                           .AsStatement(),
                    TestTemplate(),
                    Factory.Code(",").AsStatement(),
                    TestTemplate(),
                    Factory.Code(")\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockProducesErrorButCorrectlyParsesNestedAnonymousSectionInStatementWithinStatementBlock()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    Dim foo = bar" + Environment.NewLine
                         + "    Html.ExecuteTemplate(foo," + TestNestedTemplateCode + ")" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    Dim foo = bar\r\n    Html.ExecuteTemplate(foo,")
                           .AsStatement(),
                    TestNestedTemplate(),
                    Factory.Code(")\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)),
                GetNestedSectionError(80, 2, 55));
        }

        private static RazorError GetNestedSectionError(int absoluteIndex, int lineIndex, int characterIndex)
        {
            return new RazorError(
                RazorResources.ParseError_InlineMarkup_Blocks_Cannot_Be_Nested,
                absoluteIndex, lineIndex, characterIndex);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/VB/VBToMarkupSwitchTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Editor;
using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser.VB
{
    public class VBToMarkupSwitchTest : VBHtmlCodeParserTestBase
    {
        [Fact]
        public void ParseBlockSwitchesToMarkupWhenAtSignFollowedByLessThanInStatementBlock()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    If True Then" + Environment.NewLine
                         + "        @<p>It's True!</p>" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    If True Then\r\n").AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("        "),
                        Factory.MarkupTransition(),
                        Factory.Markup("<p>It's True!</p>\r\n").Accepts(AcceptedCharacters.None)),
                    Factory.Code("    End If\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)));
        }

        [Fact]
        public void ParseBlockGivesWhiteSpacePreceedingMarkupBlockToCodeInDesignTimeMode()
        {
            ParseBlockTest("Code" + Environment.NewLine
                         + "    @<p>Foo</p>" + Environment.NewLine
                         + "End Code",
                new StatementBlock(
                    Factory.MetaCode("Code").Accepts(AcceptedCharacters.None),
                    Factory.Code("\r\n    ").AsStatement(),
                    new MarkupBlock(
                        Factory.MarkupTransition(),
                        Factory.Markup("<p>Foo</p>").Accepts(AcceptedCharacters.None)),
                    Factory.Code("\r\n").AsStatement(),
                    Factory.MetaCode("End Code").Accepts(AcceptedCharacters.None)),
                designTimeParser: true);
        }

        [Theory]
        [InlineData("While", "End While", AcceptedCharacters.None)]
        [InlineData("If", "End If", AcceptedCharacters.None)]
        [InlineData("Select", "End Select", AcceptedCharacters.None)]
        [InlineData("For", "Next", AcceptedCharacters.WhiteSpace | AcceptedCharacters.NonWhiteSpace)]
        [InlineData("Try", "End Try", AcceptedCharacters.None)]
        [InlineData("With", "End With", AcceptedCharacters.None)]
        [InlineData("Using", "End Using", AcceptedCharacters.None)]
        public void SimpleMarkupSwitch(string keyword, string endSequence, AcceptedCharacters acceptedCharacters)
        {
            ParseBlockTest(keyword + Environment.NewLine
                         + "    If True Then" + Environment.NewLine
                         + "        @<p>It's True!</p>" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + endSequence,
                new StatementBlock(
                    Factory.Code(keyword + "\r\n    If True Then\r\n").AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("        "),
                        Factory.MarkupTransition(),
                        Factory.Markup("<p>It's True!</p>\r\n").Accepts(AcceptedCharacters.None)),
                    Factory.Code("    End If\r\n" + endSequence).AsStatement().Accepts(acceptedCharacters)));
        }

        [Theory]
        [InlineData("While", "End While", AcceptedCharacters.None)]
        [InlineData("If", "End If", AcceptedCharacters.None)]
        [InlineData("Select", "End Select", AcceptedCharacters.None)]
        [InlineData("For", "Next", AcceptedCharacters.WhiteSpace | AcceptedCharacters.NonWhiteSpace)]
        [InlineData("Try", "End Try", AcceptedCharacters.None)]
        [InlineData("With", "End With", AcceptedCharacters.None)]
        [InlineData("Using", "End Using", AcceptedCharacters.None)]
        public void SingleLineMarkupSwitch(string keyword, string endSequence, AcceptedCharacters acceptedCharacters)
        {
            ParseBlockTest(keyword + Environment.NewLine
                         + "    If True Then" + Environment.NewLine
                         + "        @:<p>It's True!</p>" + Environment.NewLine
                         + "        This is code!" + Environment.NewLine
                         + "    End If" + Environment.NewLine
                         + endSequence,
                new StatementBlock(
                    Factory.Code(keyword + "\r\n    If True Then\r\n").AsStatement(),
                    new MarkupBlock(
                        Factory.Markup("        "),
                        Factory.MarkupTransition(),
                        Factory.MetaMarkup(":", HtmlSymbolType.Colon),
                        Factory.Markup("<p>It's True!</p>\r\n")
                                .With(new SingleLineMarkupEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString))
                                .Accepts(AcceptedCharacters.None)),
                    Factory.Code("        This is code!\r\n    End If\r\n" + endSequence)
                            .AsStatement()
                            .Accepts(acceptedCharacters)));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Parser/WhitespaceRewriterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Parser;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Test.Framework;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Parser
{
    public class WhitespaceRewriterTest
    {
        [Fact]
        public void Constructor_Requires_NonNull_SymbolConverter()
        {
            Assert.ThrowsArgumentNull(() => new WhiteSpaceRewriter(null), "markupSpanFactory");
        }

        [Fact]
        public void Rewrite_Moves_Whitespace_Preceeding_ExpressionBlock_To_Parent_Block()
        {
            // Arrange
            var factory = SpanFactory.CreateCsHtml();
            Block start = new MarkupBlock(
                factory.Markup("test"),
                new ExpressionBlock(
                    factory.Code("    ").AsExpression(),
                    factory.CodeTransition(SyntaxConstants.TransitionString),
                    factory.Code("foo").AsExpression()
                    ),
                factory.Markup("test")
                );
            WhiteSpaceRewriter rewriter = new WhiteSpaceRewriter(new HtmlMarkupParser().BuildSpan);

            // Act
            Block actual = rewriter.Rewrite(start);

            factory.Reset();

            // Assert
            ParserTestBase.EvaluateParseTree(actual, new MarkupBlock(
                                                         factory.Markup("test"),
                                                         factory.Markup("    "),
                                                         new ExpressionBlock(
                                                             factory.CodeTransition(SyntaxConstants.TransitionString),
                                                             factory.Code("foo").AsExpression()
                                                             ),
                                                         factory.Markup("test")
                                                         ));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/RazorCodeLanguageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Razor.Test
{
    public class RazorCodeLanguageTest
    {
        [Fact]
        public void ServicesPropertyContainsEntriesForCSharpCodeLanguageService()
        {
            // Assert
            Assert.Equal(2, RazorCodeLanguage.Languages.Count);
            Assert.IsType<CSharpRazorCodeLanguage>(RazorCodeLanguage.Languages["cshtml"]);
            Assert.IsType<VBRazorCodeLanguage>(RazorCodeLanguage.Languages["vbhtml"]);
        }

        [Fact]
        public void GetServiceByExtensionReturnsEntryMatchingExtensionWithoutPreceedingDot()
        {
            Assert.IsType<CSharpRazorCodeLanguage>(RazorCodeLanguage.GetLanguageByExtension("cshtml"));
        }

        [Fact]
        public void GetServiceByExtensionReturnsEntryMatchingExtensionWithPreceedingDot()
        {
            Assert.IsType<CSharpRazorCodeLanguage>(RazorCodeLanguage.GetLanguageByExtension(".cshtml"));
        }

        [Fact]
        public void GetServiceByExtensionReturnsNullIfNoServiceForSpecifiedExtension()
        {
            Assert.Null(RazorCodeLanguage.GetLanguageByExtension("foobar"));
        }

        [Fact]
        public void MultipleCallsToGetServiceWithSameExtensionReturnSameObject()
        {
            // Arrange
            RazorCodeLanguage expected = RazorCodeLanguage.GetLanguageByExtension("cshtml");

            // Act
            RazorCodeLanguage actual = RazorCodeLanguage.GetLanguageByExtension("cshtml");

            // Assert
            Assert.Same(expected, actual);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/RazorDirectiveAttributeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test
{
    public class RazorDirectiveAttributeTest
    {
        [Fact]
        public void ConstructorThrowsIfNameIsNullOrEmpty()
        {
            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => new RazorDirectiveAttribute(name: null, value: "blah"), "name");
            Assert.ThrowsArgumentNullOrEmptyString(() => new RazorDirectiveAttribute(name: "", value: "blah"), "name");
        }

        [Fact]
        public void EnsureRazorDirectiveProperties()
        {
            // Arrange
            var attribute = (AttributeUsageAttribute)typeof(RazorDirectiveAttribute).GetCustomAttributes(typeof(AttributeUsageAttribute), inherit: false)
                                                                                     .SingleOrDefault();

            // Assert
            Assert.True(attribute.AllowMultiple);
            Assert.Equal(AttributeTargets.Class, attribute.ValidOn);
            Assert.True(attribute.Inherited);
        }

        [Fact]
        public void EqualsAndGetHashCodeIgnoresCase()
        {
            // Arrange
            var attribute1 = new RazorDirectiveAttribute("foo", "bar");
            var attribute2 = new RazorDirectiveAttribute("fOo", "BAr");

            // Act
            var hashCode1 = attribute1.GetHashCode();
            var hashCode2 = attribute2.GetHashCode();

            // Assert
            Assert.Equal(attribute1, attribute2);
            Assert.Equal(hashCode1, hashCode2);
        }

        [Fact]
        public void EqualsAndGetHashCodeDoNotThrowIfValueIsNullOrEmpty()
        {
            // Arrange
            var attribute1 = new RazorDirectiveAttribute("foo", null);
            var attribute2 = new RazorDirectiveAttribute("foo", "BAr");

            // Act
            bool result = attribute1.Equals(attribute2);
            var hashCode = attribute1.GetHashCode();

            // Assert
            Assert.False(result);
            // If we've got this far, GetHashCode did not throw
        }

        [Fact]
        public void EqualsAndGetHashCodeReturnDifferentValuesForNullAndEmpty()
        {
            // Arrange
            var attribute1 = new RazorDirectiveAttribute("foo", null);
            var attribute2 = new RazorDirectiveAttribute("foo", "");

            // Act
            bool result = attribute1.Equals(attribute2);
            var hashCode1 = attribute1.GetHashCode();
            var hashCode2 = attribute2.GetHashCode();

            // Assert
            Assert.False(result);
            Assert.NotEqual(hashCode1, hashCode2);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/RazorEngineHostTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test
{
    public class RazorEngineHostTest
    {
        [Fact]
        public void ConstructorRequiresNonNullCodeLanguage()
        {
            Assert.ThrowsArgumentNull(() => new RazorEngineHost(null), "codeLanguage");
            Assert.ThrowsArgumentNull(() => new RazorEngineHost(null, () => new HtmlMarkupParser()), "codeLanguage");
        }

        [Fact]
        public void ConstructorRequiresNonNullMarkupParser()
        {
            Assert.ThrowsArgumentNull(() => new RazorEngineHost(new CSharpRazorCodeLanguage(), null), "markupParserFactory");
        }

        [Fact]
        public void ConstructorWithCodeLanguageSetsPropertiesAppropriately()
        {
            // Arrange
            RazorCodeLanguage language = new CSharpRazorCodeLanguage();

            // Act
            RazorEngineHost host = new RazorEngineHost(language);

            // Assert
            VerifyCommonDefaults(host);
            Assert.Same(language, host.CodeLanguage);
            Assert.IsType<HtmlMarkupParser>(host.CreateMarkupParser());
        }

        [Fact]
        public void ConstructorWithCodeLanguageAndMarkupParserSetsPropertiesAppropriately()
        {
            // Arrange
            RazorCodeLanguage language = new CSharpRazorCodeLanguage();
            ParserBase expected = new HtmlMarkupParser();

            // Act
            RazorEngineHost host = new RazorEngineHost(language, () => expected);

            // Assert
            VerifyCommonDefaults(host);
            Assert.Same(language, host.CodeLanguage);
            Assert.Same(expected, host.CreateMarkupParser());
        }

        [Fact]
        public void DecorateCodeParserRequiresNonNullCodeParser()
        {
            Assert.ThrowsArgumentNull(() => CreateHost().DecorateCodeParser(null), "incomingCodeParser");
        }

        [Fact]
        public void DecorateMarkupParserRequiresNonNullMarkupParser()
        {
            Assert.ThrowsArgumentNull(() => CreateHost().DecorateMarkupParser(null), "incomingMarkupParser");
        }

        [Fact]
        public void DecorateCodeGeneratorRequiresNonNullCodeGenerator()
        {
            Assert.ThrowsArgumentNull(() => CreateHost().DecorateCodeGenerator(null), "incomingCodeGenerator");
        }

        [Fact]
        public void PostProcessGeneratedCodeRequiresNonNullCompileUnit()
        {
            Assert.ThrowsArgumentNull(() => CreateHost().PostProcessGeneratedCode(codeCompileUnit: null,
                                                                                      generatedNamespace: new CodeNamespace(),
                                                                                      generatedClass: new CodeTypeDeclaration(),
                                                                                      executeMethod: new CodeMemberMethod()),
                                          "codeCompileUnit");
        }

        [Fact]
        public void PostProcessGeneratedCodeRequiresNonNullGeneratedNamespace()
        {
            Assert.ThrowsArgumentNull(() => CreateHost().PostProcessGeneratedCode(codeCompileUnit: new CodeCompileUnit(),
                                                                                      generatedNamespace: null,
                                                                                      generatedClass: new CodeTypeDeclaration(),
                                                                                      executeMethod: new CodeMemberMethod()),
                                          "generatedNamespace");
        }

        [Fact]
        public void PostProcessGeneratedCodeRequiresNonNullGeneratedClass()
        {
            Assert.ThrowsArgumentNull(() => CreateHost().PostProcessGeneratedCode(codeCompileUnit: new CodeCompileUnit(),
                                                                                      generatedNamespace: new CodeNamespace(),
                                                                                      generatedClass: null,
                                                                                      executeMethod: new CodeMemberMethod()),
                                          "generatedClass");
        }

        [Fact]
        public void PostProcessGeneratedCodeRequiresNonNullExecuteMethod()
        {
            Assert.ThrowsArgumentNull(() => CreateHost().PostProcessGeneratedCode(codeCompileUnit: new CodeCompileUnit(),
                                                                                      generatedNamespace: new CodeNamespace(),
                                                                                      generatedClass: new CodeTypeDeclaration(),
                                                                                      executeMethod: null),
                                          "executeMethod");
        }

        [Fact]
        public void DecorateCodeParserDoesNotModifyIncomingParser()
        {
            // Arrange
            ParserBase expected = new CSharpCodeParser();

            // Act
            ParserBase actual = CreateHost().DecorateCodeParser(expected);

            // Assert
            Assert.Same(expected, actual);
        }

        [Fact]
        public void DecorateMarkupParserReturnsIncomingParser()
        {
            // Arrange
            ParserBase expected = new HtmlMarkupParser();

            // Act
            ParserBase actual = CreateHost().DecorateMarkupParser(expected);

            // Assert
            Assert.Same(expected, actual);
        }

        [Fact]
        public void DecorateCodeGeneratorReturnsIncomingCodeGenerator()
        {
            // Arrange
            RazorCodeGenerator expected = new CSharpRazorCodeGenerator("Foo", "Bar", "Baz", CreateHost());

            // Act
            RazorCodeGenerator actual = CreateHost().DecorateCodeGenerator(expected);

            // Assert
            Assert.Same(expected, actual);
        }

        [Fact]
        public void PostProcessGeneratedCodeDoesNotModifyCode()
        {
            // Arrange
            CodeCompileUnit compileUnit = new CodeCompileUnit();
            CodeNamespace ns = new CodeNamespace();
            CodeTypeDeclaration typeDecl = new CodeTypeDeclaration();
            CodeMemberMethod execMethod = new CodeMemberMethod();

            // Act
            CreateHost().PostProcessGeneratedCode(compileUnit, ns, typeDecl, execMethod);

            // Assert
            Assert.Empty(compileUnit.Namespaces);
            Assert.Empty(ns.Imports);
            Assert.Empty(ns.Types);
            Assert.Empty(typeDecl.Members);
            Assert.Empty(execMethod.Statements);
        }

        private static RazorEngineHost CreateHost()
        {
            return new RazorEngineHost(new CSharpRazorCodeLanguage());
        }

        private static void VerifyCommonDefaults(RazorEngineHost host)
        {
            Assert.Equal(GeneratedClassContext.Default, host.GeneratedClassContext);
            Assert.Empty(host.NamespaceImports);
            Assert.False(host.DesignTimeMode);
            Assert.Equal(RazorEngineHost.InternalDefaultClassName, host.DefaultClassName);
            Assert.Equal(RazorEngineHost.InternalDefaultNamespace, host.DefaultNamespace);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/RazorTemplateEngineTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Threading;
using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Razor.Test
{
    public class RazorTemplateEngineTest
    {
        [Fact]
        public void ConstructorRequiresNonNullHost()
        {
            Assert.ThrowsArgumentNull(() => new RazorTemplateEngine(null), "host");
        }

        [Fact]
        public void ConstructorInitializesHost()
        {
            // Arrange
            RazorEngineHost host = new RazorEngineHost(new CSharpRazorCodeLanguage());

            // Act
            RazorTemplateEngine engine = new RazorTemplateEngine(host);

            // Assert
            Assert.Same(host, engine.Host);
        }

        [Fact]
        public void CreateParserMethodIsConstructedFromHost()
        {
            // Arrange
            RazorEngineHost host = CreateHost();
            RazorTemplateEngine engine = new RazorTemplateEngine(host);

            // Act
            RazorParser parser = engine.CreateParser();

            // Assert
            Assert.IsType<CSharpCodeParser>(parser.CodeParser);
            Assert.IsType<HtmlMarkupParser>(parser.MarkupParser);
        }

        [Fact]
        public void CreateParserMethodSetsParserContextToDesignTimeModeIfHostSetToDesignTimeMode()
        {
            // Arrange
            RazorEngineHost host = CreateHost();
            RazorTemplateEngine engine = new RazorTemplateEngine(host);
            host.DesignTimeMode = true;

            // Act
            RazorParser parser = engine.CreateParser();

            // Assert
            Assert.True(parser.DesignTimeMode);
        }

        [Fact]
        public void CreateParserMethodPassesParsersThroughDecoratorMethodsOnHost()
        {
            // Arrange
            ParserBase expectedCode = new Mock<ParserBase>().Object;
            ParserBase expectedMarkup = new Mock<ParserBase>().Object;

            var mockHost = new Mock<RazorEngineHost>(new CSharpRazorCodeLanguage()) { CallBase = true };
            mockHost.Setup(h => h.DecorateCodeParser(It.IsAny<CSharpCodeParser>()))
                .Returns(expectedCode);
            mockHost.Setup(h => h.DecorateMarkupParser(It.IsAny<HtmlMarkupParser>()))
                .Returns(expectedMarkup);
            RazorTemplateEngine engine = new RazorTemplateEngine(mockHost.Object);

            // Act
            RazorParser actual = engine.CreateParser();

            // Assert
            Assert.Equal(expectedCode, actual.CodeParser);
            Assert.Equal(expectedMarkup, actual.MarkupParser);
        }

        [Fact]
        public void CreateCodeGeneratorMethodPassesCodeGeneratorThroughDecorateMethodOnHost()
        {
            // Arrange
            var mockHost = new Mock<RazorEngineHost>(new CSharpRazorCodeLanguage()) { CallBase = true };

            RazorCodeGenerator expected = new Mock<RazorCodeGenerator>("Foo", "Bar", "Baz", mockHost.Object).Object;

            mockHost.Setup(h => h.DecorateCodeGenerator(It.IsAny<CSharpRazorCodeGenerator>()))
                .Returns(expected);
            RazorTemplateEngine engine = new RazorTemplateEngine(mockHost.Object);

            // Act
            RazorCodeGenerator actual = engine.CreateCodeGenerator("Foo", "Bar", "Baz");

            // Assert
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void ParseTemplateCopiesTextReaderContentToSeekableTextReaderAndPassesToParseTemplateCore()
        {
            // Arrange
            Mock<RazorTemplateEngine> mockEngine = new Mock<RazorTemplateEngine>(CreateHost());
            TextReader reader = new StringReader("foo");
            CancellationTokenSource source = new CancellationTokenSource();

            // Act
            mockEngine.Object.ParseTemplate(reader, cancelToken: source.Token);

            // Assert
            mockEngine.Verify(e => e.ParseTemplateCore(It.Is<SeekableTextReader>(l => l.ReadToEnd() == "foo"),
                                                       source.Token));
        }

        [Fact]
        public void GenerateCodeCopiesTextReaderContentToSeekableTextReaderAndPassesToGenerateCodeCore()
        {
            // Arrange
            Mock<RazorTemplateEngine> mockEngine = new Mock<RazorTemplateEngine>(CreateHost());
            TextReader reader = new StringReader("foo");
            CancellationTokenSource source = new CancellationTokenSource();
            string className = "Foo";
            string ns = "Bar";
            string src = "Baz";

            // Act
            mockEngine.Object.GenerateCode(reader, className: className, rootNamespace: ns, sourceFileName: src, cancelToken: source.Token);

            // Assert
            mockEngine.Verify(e => e.GenerateCodeCore(It.Is<SeekableTextReader>(l => l.ReadToEnd() == "foo"),
                                                      className, ns, src, source.Token));
        }

        [Fact]
        public void ParseTemplateOutputsResultsOfParsingProvidedTemplateSource()
        {
            // Arrange
            RazorTemplateEngine engine = new RazorTemplateEngine(CreateHost());

            // Act
            ParserResults results = engine.ParseTemplate(new StringTextBuffer("foo @bar("));

            // Assert
            Assert.False(results.Success);
            Assert.Single(results.ParserErrors);
            Assert.NotNull(results.Document);
        }

        [Fact]
        public void GenerateOutputsResultsOfParsingAndGeneration()
        {
            // Arrange
            RazorTemplateEngine engine = new RazorTemplateEngine(CreateHost());

            // Act
            GeneratorResults results = engine.GenerateCode(new StringTextBuffer("foo @bar("));

            // Assert
            Assert.False(results.Success);
            Assert.Single(results.ParserErrors);
            Assert.NotNull(results.Document);
            Assert.NotNull(results.GeneratedCode);
            Assert.Null(results.DesignTimeLineMappings);
        }

        [Fact]
        public void GenerateOutputsDesignTimeMappingsIfDesignTimeSetOnHost()
        {
            // Arrange
            RazorTemplateEngine engine = new RazorTemplateEngine(CreateHost(designTime: true));

            // Act
            GeneratorResults results = engine.GenerateCode(new StringTextBuffer("foo @bar()"), className: null, rootNamespace: null, sourceFileName: "foo.cshtml");

            // Assert
            Assert.True(results.Success);
            Assert.Empty(results.ParserErrors);
            Assert.NotNull(results.Document);
            Assert.NotNull(results.GeneratedCode);
            Assert.NotNull(results.DesignTimeLineMappings);
        }

        private static RazorEngineHost CreateHost(bool designTime = false)
        {
            return new RazorEngineHost(new CSharpRazorCodeLanguage())
            {
                DesignTimeMode = designTime
            };
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/StringTextBuffer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;

namespace System.Web.WebPages.TestUtils
{
    public class StringTextBuffer : ITextBuffer, IDisposable
    {
        private string _buffer;
        public bool Disposed { get; set; }

        public StringTextBuffer(string buffer)
        {
            _buffer = buffer;
        }

        public int Length
        {
            get { return _buffer.Length; }
        }

        public int Position { get; set; }

        public int Read()
        {
            if (Position >= _buffer.Length)
            {
                return -1;
            }
            return _buffer[Position++];
        }

        public int Peek()
        {
            if (Position >= _buffer.Length)
            {
                return -1;
            }
            return _buffer[Position];
        }

        public void Dispose()
        {
            Disposed = true;
        }

        public object VersionToken
        {
            get { return _buffer; }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/System.Web.Razor.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{0BB62A1D-E6B5-49FA-9E3C-6AF679A66DFE}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.Razor.Test</RootNamespace>
    <AssemblyName>System.Web.Razor.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NoWarn>0618</NoWarn>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core">
      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    </Reference>
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="CodeCompileUnitExtensions.cs" />
    <Compile Include="Framework\BlockExtensions.cs" />
    <Compile Include="Framework\BlockTypes.cs" />
    <Compile Include="Framework\CodeParserTestBase.cs" />
    <Compile Include="Framework\CsHtmlCodeParserTestBase.cs" />
    <Compile Include="Framework\CsHtmlMarkupParserTestBase.cs" />
    <Compile Include="Framework\ErrorCollector.cs" />
    <Compile Include="Framework\MarkupParserTestBase.cs" />
    <Compile Include="Framework\ParserTestBase.cs" />
    <Compile Include="Framework\RawTextSymbol.cs" />
    <Compile Include="Framework\TestSpanBuilder.cs" />
    <Compile Include="Framework\VBHtmlCodeParserTestBase.cs" />
    <Compile Include="Framework\VBHtmlMarkupParserTestBase.cs" />
    <Compile Include="Generator\GeneratedCodeMappingTest.cs" />
    <Compile Include="Generator\PaddingTest.cs" />
    <Compile Include="Generator\TabTest.cs" />
    <Compile Include="Generator\TestSpan.cs" />
    <Compile Include="Parser\CSharp\CSharpAutoCompleteTest.cs" />
    <Compile Include="Parser\CSharp\CSharpDirectivesTest.cs" />
    <Compile Include="Parser\CSharp\CSharpLayoutDirectiveTest.cs" />
    <Compile Include="Parser\CSharp\CSharpNestedStatementsTest.cs" />
    <Compile Include="Parser\CSharp\CSharpRazorCommentsTest.cs" />
    <Compile Include="Parser\CSharp\CSharpStatementTest.cs" />
    <Compile Include="Parser\CSharp\CSharpTemplateTest.cs" />
    <Compile Include="Parser\CSharp\CSharpToMarkupSwitchTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Parser\CSharp\CSharpVerbatimBlockTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Parser\CSharp\CSharpWhitespaceHandlingTest.cs" />
    <Compile Include="Parser\CSharp\CsHtmlDocumentTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Parser\Html\HtmlAttributeTest.cs" />
    <Compile Include="Parser\Html\HtmlUrlAttributeTest.cs" />
    <Compile Include="Parser\ParserVisitorExtensionsTest.cs" />
    <Compile Include="Parser\VB\VBRazorCommentsTest.cs" />
    <Compile Include="Parser\VB\VBLayoutDirectiveTest.cs" />
    <Compile Include="Parser\VB\VBAutoCompleteTest.cs" />
    <Compile Include="Parser\Html\HtmlTagsTest.cs" />
    <Compile Include="Parser\VB\VBContinueStatementTest.cs" />
    <Compile Include="Parser\VB\VBDirectiveTest.cs" />
    <Compile Include="Parser\VB\VBExitStatementTest.cs" />
    <Compile Include="Parser\VB\VBExplicitExpressionTest.cs" />
    <Compile Include="Parser\VB\VBImplicitExpressionTest.cs" />
    <Compile Include="Parser\VB\VBReservedWordsTest.cs" />
    <Compile Include="Parser\CSharp\CSharpReservedWordsTest.cs" />
    <Compile Include="Parser\PartialParsing\VBPartialParsingTest.cs" />
    <Compile Include="Parser\PartialParsing\CSharpPartialParsingTest.cs" />
    <Compile Include="Parser\VB\VBHelperTest.cs" />
    <Compile Include="Parser\CSharp\CSharpHelperTest.cs" />
    <Compile Include="Generator\RazorCodeGeneratorTest.cs" />
    <Compile Include="Parser\PartialParsing\PartialParsingTestBase.cs" />
    <Compile Include="Parser\VB\VBNestedStatementsTest.cs" />
    <Compile Include="Parser\VB\VBStatementTest.cs" />
    <Compile Include="Parser\WhitespaceRewriterTest.cs" />
    <Compile Include="RazorCodeLanguageTest.cs" />
    <Compile Include="Parser\VB\VBHtmlDocumentTest.cs" />
    <Compile Include="Parser\VB\VBErrorTest.cs" />
    <Compile Include="Parser\VB\VBSectionTest.cs" />
    <Compile Include="Parser\VB\VBTemplateTest.cs" />
    <Compile Include="Parser\VB\VBExpressionsInCodeTest.cs" />
    <Compile Include="Parser\VB\VBSpecialKeywordsTest.cs" />
    <Compile Include="Parser\VB\VBBlockTest.cs" />
    <Compile Include="Parser\VB\VBToMarkupSwitchTest.cs" />
    <Compile Include="Editor\RazorEditorParserTest.cs" />
    <Compile Include="RazorDirectiveAttributeTest.cs" />
    <Compile Include="RazorEngineHostTest.cs" />
    <Compile Include="RazorTemplateEngineTest.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Blocks.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\CodeBlock.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\CodeBlockAtEOF.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Comments.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ConditionalAttributes.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\DesignTime.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\EmptyCodeBlock.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\EmptyExplicitExpression.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\EmptyImplicitExpression.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\EmptyImplicitExpressionInCode.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ExplicitExpression.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ExplicitExpressionAtEOF.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ExpressionsInCode.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\FunctionsBlock.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\FunctionsBlock.DesignTime.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Helpers.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Helpers.Instance.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\HelpersMissingCloseParen.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\HelpersMissingName.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\HelpersMissingOpenBrace.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\HelpersMissingOpenParen.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\HiddenSpansInCode.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ImplicitExpression.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ImplicitExpressionAtEOF.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Imports.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Imports.DesignTime.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Inherits.Designtime.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Inherits.Runtime.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\InlineBlocks.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Instrumented.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\LayoutDirective.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\MarkupInCodeBlock.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\NestedCodeBlocks.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\NestedHelpers.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\NoLinePragmas.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ParserError.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\RazorComments.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\ResolveUrl.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Sections.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\Templates.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\UnfinishedExpressionInCode.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\RazorComments.DesignTime.cs" />
    <Compile Include="StringTextBuffer.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\OpenedIf.DesignTime.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\OpenedIf.DesignTime.Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\UnfinishedExpressionInCode.Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\EmptyImplicitExpressionInCode.Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\DesignTime.Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\FunctionsBlock.DesignTime.Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\FunctionsBlock_Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\FunctionsBlockMinimal.DesignTime.Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\SimpleUnspacedIf.DesignTime.Tabs.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\HtmlCommentWithQuote_Single.cs" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Output\HtmlCommentWithQuote_Double.cs" />
    <Compile Include="Text\LineTrackingStringBufferTest.cs" />
    <Compile Include="Tokenizer\VBTokenizerLiteralTest.cs" />
    <Compile Include="Tokenizer\VBTokenizerIdentifierTest.cs" />
    <Compile Include="Tokenizer\VBTokenizerCommentTest.cs" />
    <Compile Include="Tokenizer\VBTokenizerOperatorsTest.cs" />
    <Compile Include="Tokenizer\VBTokenizerTestBase.cs" />
    <Compile Include="Tokenizer\VBTokenizerTest.cs" />
    <Compile Include="Tokenizer\CSharpTokenizerCommentTest.cs" />
    <Compile Include="Tokenizer\CSharpTokenizerLiteralTest.cs" />
    <Compile Include="Tokenizer\CSharpTokenizerIdentifierTest.cs" />
    <Compile Include="Tokenizer\CSharpTokenizerOperatorsTest.cs" />
    <Compile Include="Tokenizer\CSharpTokenizerTestBase.cs" />
    <Compile Include="Tokenizer\CSharpTokenizerTest.cs" />
    <Compile Include="Tokenizer\TokenizerLookaheadTest.cs" />
    <Compile Include="Tokenizer\HtmlTokenizerTest.cs" />
    <Compile Include="Tokenizer\HtmlTokenizerTestBase.cs" />
    <Compile Include="Tokenizer\TokenizerTestBase.cs" />
    <Compile Include="Utils\MiscUtils.cs" />
    <Compile Include="Generator\VBRazorCodeGeneratorTest.cs" />
    <Compile Include="Generator\CSharpRazorCodeGeneratorTest.cs" />
    <Compile Include="CSharpRazorCodeLanguageTest.cs" />
    <Compile Include="Parser\CallbackParserListenerTest.cs" />
    <Compile Include="Parser\CSharp\CSharpExplicitExpressionTest.cs" />
    <Compile Include="Parser\CSharp\CSharpSectionTest.cs" />
    <Compile Include="Parser\BlockTest.cs" />
    <Compile Include="Parser\VB\VBExpressionTest.cs" />
    <Compile Include="Text\BufferingTextReaderTest.cs" />
    <Compile Include="Parser\CSharp\CSharpErrorTest.cs" />
    <Compile Include="Parser\CSharp\CSharpImplicitExpressionTest.cs" />
    <Compile Include="Parser\CSharp\CSharpSpecialBlockTest.cs" />
    <Compile Include="Parser\Html\HtmlBlockTest.cs" />
    <Compile Include="Parser\CSharp\CSharpBlockTest.cs" />
    <Compile Include="Text\LookaheadTextReaderTestBase.cs" />
    <Compile Include="Text\SourceLocationTrackerTest.cs" />
    <Compile Include="Text\TextBufferReaderTest.cs" />
    <Compile Include="Utils\DisposableActionTest.cs" />
    <Compile Include="Parser\Html\HtmlDocumentTest.cs" />
    <Compile Include="Parser\ParserContextTest.cs" />
    <Compile Include="Parser\Html\HtmlErrorTest.cs" />
    <Compile Include="Parser\Html\HtmlParserTestUtils.cs" />
    <Compile Include="Parser\Html\HtmlToCodeSwitchTest.cs" />
    <Compile Include="Parser\RazorParserTest.cs" />
    <Compile Include="Text\SourceLocationTest.cs" />
    <Compile Include="Utils\SpanAssert.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="VBRazorCodeLanguageTest.cs" />
    <Compile Include="Text\TextChangeTest.cs" />
    <Compile Include="Text\TextReaderExtensionsTest.cs" />
    <Compile Include="Utils\EnumerableUtils.cs" />
    <Compile Include="Utils\MiscAssert.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\nested-1000.html" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\CodeBlock.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ExplicitExpression.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\MarkupInCodeBlock.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Blocks.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ImplicitExpression.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\NoLinePragmas.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Imports.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ExpressionsInCode.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\FunctionsBlock.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Options.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Templates.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Sections.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\DesignTime.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\Templates.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\Blocks.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\CodeBlock.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\NoLinePragmas.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ExplicitExpression.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ImplicitExpression.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\Imports.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\MarkupInCodeBlock.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\DesignTime.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ExpressionsInCode.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\FunctionsBlock.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\Sections.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\Inherits.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Inherits.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\NestedHelpers.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\NestedHelpers.vbhtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\Instrumented.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Instrumented.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\RazorComments.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\RazorComments.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ParserError.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ParserError.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ImplicitExpressionAtEOF.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\CodeBlockAtEOF.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ExplicitExpressionAtEOF.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\EmptyCodeBlock.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\EmptyExplicitExpression.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\EmptyImplicitExpression.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\CodeBlockAtEOF.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\EmptyExplicitExpression.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\EmptyImplicitExpression.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ExplicitExpressionAtEOF.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ImplicitExpressionAtEOF.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\UnfinishedExpressionInCode.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\UnfinishedExpressionInCode.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\DesignTime\Simple.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\DesignTime\Simple.txt" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\Helpers.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\HelpersMissingCloseParen.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\HelpersMissingName.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\HelpersMissingOpenBrace.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\HelpersMissingOpenParen.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\HelpersMissingOpenParen.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\Helpers.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\HelpersMissingCloseParen.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\HelpersMissingName.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\NestedCodeBlocks.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\NestedCodeBlocks.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\InlineBlocks.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\EmptyImplicitExpressionInCode.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\EmptyImplicitExpressionInCode.vbhtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\HiddenSpansInCode.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ResolveUrl.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ResolveUrl.vbhtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\LayoutDirective.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\LayoutDirective.vbhtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\ConditionalAttributes.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\ConditionalAttributes.vbhtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Source\EmptySection.vbhtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\OpenedIf.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\FunctionsBlock_Tabs.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\FunctionsBlockMinimal.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\SimpleUnspacedIf.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\HtmlCommentWithQuote_Double.cshtml" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\CS\Source\HtmlCommentWithQuote_Single.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Blocks.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\CodeBlock.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\CodeBlockAtEOF.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Comments.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ConditionalAttributes.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\DesignTime.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\EmptyExplicitExpression.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\EmptyImplicitExpression.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\EmptyImplicitExpressionInCode.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ExplicitExpression.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ExplicitExpressionAtEOF.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ExpressionsInCode.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\FunctionsBlock.DesignTime.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\FunctionsBlock.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Helpers.Instance.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Helpers.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\HelpersMissingCloseParen.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\HelpersMissingName.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\HelpersMissingOpenParen.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ImplicitExpression.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ImplicitExpressionAtEOF.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Imports.DesignTime.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Imports.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Inherits.Designtime.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Inherits.Runtime.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Instrumented.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\LayoutDirective.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\MarkupInCodeBlock.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\NestedCodeBlocks.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\NestedHelpers.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\NoLinePragmas.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Options.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ParserError.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\RazorComments.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\ResolveUrl.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Sections.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\Templates.vb" />
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\UnfinishedExpressionInCode.vb" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\RazorComments.DesignTime.vb" />
  </ItemGroup>
  <ItemGroup>
    <Folder Include="Properties\" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\EmptySection.vb" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\CodeGenerator\VB\Output\FunctionsBlock.DesignTime.Tabs.vb" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Blocks.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Blocks {
#line hidden
public Blocks() {
}
public override void Execute() {

#line 1 "Blocks.cshtml"
  
    int i = 1;


#line default
#line hidden
WriteLiteral("\r\n\r\n");


#line 5 "Blocks.cshtml"
 while(i <= 10) {


#line default
#line hidden
WriteLiteral("    <p>Hello from C#, #");


#line 6 "Blocks.cshtml"
                   Write(i);


#line default
#line hidden
WriteLiteral("</p>\r\n");


#line 7 "Blocks.cshtml"
    i += 1;
}


#line default
#line hidden
WriteLiteral("\r\n");


#line 10 "Blocks.cshtml"
 if(i == 11) {


#line default
#line hidden
WriteLiteral("    <p>We wrote 10 lines!</p>\r\n");


#line 12 "Blocks.cshtml"
}


#line default
#line hidden
WriteLiteral("\r\n");


#line 14 "Blocks.cshtml"
 switch(i) {
    case 11:


#line default
#line hidden
WriteLiteral("        <p>No really, we wrote 10 lines!</p>\r\n");


#line 17 "Blocks.cshtml"
        break;
    default:


#line default
#line hidden
WriteLiteral("        <p>Actually, we didn\'t...</p>\r\n");


#line 20 "Blocks.cshtml"
        break;
}


#line default
#line hidden
WriteLiteral("\r\n");


#line 23 "Blocks.cshtml"
 for(int j = 1; j <= 10; j += 2) {


#line default
#line hidden
WriteLiteral("    <p>Hello again from C#, #");


#line 24 "Blocks.cshtml"
                         Write(j);


#line default
#line hidden
WriteLiteral("</p>\r\n");


#line 25 "Blocks.cshtml"
}


#line default
#line hidden
WriteLiteral("\r\n");


#line 27 "Blocks.cshtml"
 try {


#line default
#line hidden
WriteLiteral("    <p>That time, we wrote 5 lines!</p>\r\n");


#line 29 "Blocks.cshtml"
} catch(Exception ex) {


#line default
#line hidden
WriteLiteral("    <p>Oh no! An error occurred: ");


#line 30 "Blocks.cshtml"
                             Write(ex.Message);


#line default
#line hidden
WriteLiteral("</p>\r\n");


#line 31 "Blocks.cshtml"
}


#line default
#line hidden
WriteLiteral("\r\n<p>i is now ");


#line 33 "Blocks.cshtml"
       Write(i);


#line default
#line hidden
WriteLiteral("</p>\r\n\r\n");


#line 35 "Blocks.cshtml"
 lock(new object()) {


#line default
#line hidden
WriteLiteral("    <p>This block is locked, for your security!</p>\r\n");


#line 37 "Blocks.cshtml"
}

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/CodeBlock.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class CodeBlock {
#line hidden
public CodeBlock() {
}
public override void Execute() {

#line 1 "CodeBlock.cshtml"
  
    for(int i = 1; i <= 10; i++) {
        Output.Write("<p>Hello from C#, #" + i.ToString() + "</p>");
    }


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/CodeBlockAtEOF.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class CodeBlockAtEOF {
#line hidden
public CodeBlockAtEOF() {
}
public override void Execute() {

#line 1 "CodeBlockAtEOF.cshtml"
  

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Comments.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Comments {
public override void Execute() {


#line 1 "Comments.cshtml"
 //This is not going to be rendered


#line default
#line hidden
WriteLiteral("<p>This is going to be rendered</p>\r\n");



#line 3 "Comments.cshtml"
 /* Neither is this
    nor this
    nor this */

#line default
#line hidden

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ConditionalAttributes.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ConditionalAttributes {
#line hidden
public ConditionalAttributes() {
}
public override void Execute() {

#line 1 "ConditionalAttributes.cshtml"
  
    var ch = true;
    var cls = "bar";


#line default
#line hidden
WriteLiteral("    <a");

WriteLiteral(" href=\"Foo\"");

WriteLiteral(" />\r\n");

WriteLiteral("    <p");

WriteAttribute("class", Tuple.Create(" class=\"", 74), Tuple.Create("\"", 86)

#line 5 "ConditionalAttributes.cshtml"
, Tuple.Create(Tuple.Create("", 82), Tuple.Create<System.Object, System.Int32>(cls

#line default
#line hidden
, 82), false)
);

WriteLiteral(" />\r\n");

WriteLiteral("    <p");

WriteAttribute("class", Tuple.Create(" class=\"", 98), Tuple.Create("\"", 114)
, Tuple.Create(Tuple.Create("", 106), Tuple.Create("foo", 106), true)

#line 6 "ConditionalAttributes.cshtml"
, Tuple.Create(Tuple.Create(" ", 109), Tuple.Create<System.Object, System.Int32>(cls

#line default
#line hidden
, 110), false)
);

WriteLiteral(" />\r\n");

WriteLiteral("    <p");

WriteAttribute("class", Tuple.Create(" class=\"", 126), Tuple.Create("\"", 142)

#line 7 "ConditionalAttributes.cshtml"
, Tuple.Create(Tuple.Create("", 134), Tuple.Create<System.Object, System.Int32>(cls

#line default
#line hidden
, 134), false)
, Tuple.Create(Tuple.Create(" ", 138), Tuple.Create("foo", 139), true)
);

WriteLiteral(" />\r\n");

WriteLiteral("    <input");

WriteLiteral(" type=\"checkbox\"");

WriteAttribute("checked", Tuple.Create(" checked=\"", 174), Tuple.Create("\"", 187)

#line 8 "ConditionalAttributes.cshtml"
, Tuple.Create(Tuple.Create("", 184), Tuple.Create<System.Object, System.Int32>(ch

#line default
#line hidden
, 184), false)
);

WriteLiteral(" />\r\n");

WriteLiteral("    <input");

WriteLiteral(" type=\"checkbox\"");

WriteAttribute("checked", Tuple.Create(" checked=\"", 219), Tuple.Create("\"", 236)
, Tuple.Create(Tuple.Create("", 229), Tuple.Create("foo", 229), true)

#line 9 "ConditionalAttributes.cshtml"
, Tuple.Create(Tuple.Create(" ", 232), Tuple.Create<System.Object, System.Int32>(ch

#line default
#line hidden
, 233), false)
);

WriteLiteral(" />\r\n");

WriteLiteral("    <p");

WriteAttribute("class", Tuple.Create(" class=\"", 248), Tuple.Create("\"", 281)
, Tuple.Create(Tuple.Create("", 256), Tuple.Create<System.Object, System.Int32>(new Template(__razor_attribute_value_writer => {


#line 10 "ConditionalAttributes.cshtml"
               if(cls != null) { 

#line default
#line hidden

#line 10 "ConditionalAttributes.cshtml"
WriteTo(__razor_attribute_value_writer, cls);


#line default
#line hidden

#line 10 "ConditionalAttributes.cshtml"
                                      }

#line default
#line hidden
}), 256), false)
);

WriteLiteral(" />\r\n");

WriteLiteral("    <a");

WriteAttribute("href", Tuple.Create(" href=\"", 293), Tuple.Create("\"", 305)
, Tuple.Create(Tuple.Create("", 300), Tuple.Create<System.Object, System.Int32>(Href("~/Foo")
, 300), false)
);

WriteLiteral(" />\r\n");

WriteLiteral("    <script");

WriteAttribute("src", Tuple.Create(" src=\"", 322), Tuple.Create("\"", 373)

#line 12 "ConditionalAttributes.cshtml"
, Tuple.Create(Tuple.Create("", 328), Tuple.Create<System.Object, System.Int32>(Url.Content("~/Scripts/jquery-1.6.2.min.js")

#line default
#line hidden
, 328), false)
);

WriteLiteral(" type=\"text/javascript\"");

WriteLiteral("></script>\r\n");

WriteLiteral("    <script");

WriteAttribute("src", Tuple.Create(" src=\"", 420), Tuple.Create("\"", 487)

#line 13 "ConditionalAttributes.cshtml"
, Tuple.Create(Tuple.Create("", 426), Tuple.Create<System.Object, System.Int32>(Url.Content("~/Scripts/modernizr-2.0.6-development-only.js")

#line default
#line hidden
, 426), false)
);

WriteLiteral(" type=\"text/javascript\"");

WriteLiteral("></script>\r\n");

WriteLiteral("    <script");

WriteLiteral(" src=\"http://ajax.aspnetcdn.com/ajax/jquery.ui/1.8.16/jquery-ui.min.js\"");

WriteLiteral(" type=\"text/javascript\"");

WriteLiteral("></script>\r\n");


#line 15 "ConditionalAttributes.cshtml"


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/DesignTime.Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class DesignTime {
private static object @__o;
#line hidden
#line 9 "DesignTime.cshtml"
public static Template Foo() {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 10 "DesignTime.cshtml"
			   
    if(true) {
        

#line default
#line hidden

#line 11 "DesignTime.cshtml"
				  
    }


#line default
#line hidden
});

#line 12 "DesignTime.cshtml"
}
#line default
#line hidden

public DesignTime() {
}
public override void Execute() {

#line 1 "DesignTime.cshtml"
			for(int i = 1; i <= 10; i++) {
    

#line default
#line hidden

#line 2 "DesignTime.cshtml"
				__o = i;


#line default
#line hidden

#line 3 "DesignTime.cshtml"
						   
            }

#line default
#line hidden

#line 4 "DesignTime.cshtml"
__o = Foo(Bar.Baz);


#line default
#line hidden

#line 5 "DesignTime.cshtml"
__o = Foo(item => new Template(__razor_template_writer => {


#line default
#line hidden

#line 6 "DesignTime.cshtml"
		__o = baz;


#line default
#line hidden

#line 7 "DesignTime.cshtml"
					   }));


#line default
#line hidden
DefineSection("Footer", () => {


#line 8 "DesignTime.cshtml"
__o = bar;


#line default
#line hidden
});

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/DesignTime.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class DesignTime {
private static object @__o;
#line hidden
#line 9 "DesignTime.cshtml"
public static Template Foo() {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 10 "DesignTime.cshtml"
               
    if(true) {
        

#line default
#line hidden

#line 11 "DesignTime.cshtml"
                  
    }


#line default
#line hidden
});

#line 12 "DesignTime.cshtml"
}
#line default
#line hidden

public DesignTime() {
}
public override void Execute() {

#line 1 "DesignTime.cshtml"
            for(int i = 1; i <= 10; i++) {
    

#line default
#line hidden

#line 2 "DesignTime.cshtml"
                __o = i;


#line default
#line hidden

#line 3 "DesignTime.cshtml"
                           
            }

#line default
#line hidden

#line 4 "DesignTime.cshtml"
__o = Foo(Bar.Baz);


#line default
#line hidden

#line 5 "DesignTime.cshtml"
__o = Foo(item => new Template(__razor_template_writer => {


#line default
#line hidden

#line 6 "DesignTime.cshtml"
        __o = baz;


#line default
#line hidden

#line 7 "DesignTime.cshtml"
                       }));


#line default
#line hidden
DefineSection("Footer", () => {


#line 8 "DesignTime.cshtml"
__o = bar;


#line default
#line hidden
});

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/EmptyCodeBlock.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class EmptyCodeBlock {
#line hidden
public EmptyCodeBlock() {
}
public override void Execute() {

#line 1 "EmptyCodeBlock.cshtml"
  

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/EmptyExplicitExpression.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class EmptyExplicitExpression {
private static object @__o;
#line hidden
public EmptyExplicitExpression() {
}
public override void Execute() {

#line 1 "EmptyExplicitExpression.cshtml"
__o = ;


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/EmptyImplicitExpression.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class EmptyImplicitExpression {
private static object @__o;
#line hidden
public EmptyImplicitExpression() {
}
public override void Execute() {

#line 1 "EmptyImplicitExpression.cshtml"
__o = ;


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/EmptyImplicitExpressionInCode.Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class EmptyImplicitExpressionInCode {
private static object @__o;
#line hidden
public EmptyImplicitExpressionInCode() {
}
public override void Execute() {

#line 1 "EmptyImplicitExpressionInCode.cshtml"
  
    

#line default
#line hidden

#line 2 "EmptyImplicitExpressionInCode.cshtml"
__o = ;


#line default
#line hidden

#line 3 "EmptyImplicitExpressionInCode.cshtml"
	 


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/EmptyImplicitExpressionInCode.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class EmptyImplicitExpressionInCode {
private static object @__o;
#line hidden
public EmptyImplicitExpressionInCode() {
}
public override void Execute() {

#line 1 "EmptyImplicitExpressionInCode.cshtml"
  
    

#line default
#line hidden

#line 2 "EmptyImplicitExpressionInCode.cshtml"
__o = ;


#line default
#line hidden

#line 3 "EmptyImplicitExpressionInCode.cshtml"
     


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ExplicitExpression.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ExplicitExpression {
#line hidden
public ExplicitExpression() {
}
public override void Execute() {
WriteLiteral("1 + 1 = ");


#line 1 "ExplicitExpression.cshtml"
    Write(1+1);


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ExplicitExpressionAtEOF.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ExplicitExpressionAtEOF {
private static object @__o;
#line hidden
public ExplicitExpressionAtEOF() {
}
public override void Execute() {

#line 1 "ExplicitExpressionAtEOF.cshtml"
__o = ;


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ExpressionsInCode.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ExpressionsInCode {
#line hidden
public ExpressionsInCode() {
}
public override void Execute() {

#line 1 "ExpressionsInCode.cshtml"
  
    object foo = null;
    string bar = "Foo";


#line default
#line hidden
WriteLiteral("\r\n\r\n");


#line 6 "ExpressionsInCode.cshtml"
 if(foo != null) {
    

#line default
#line hidden

#line 7 "ExpressionsInCode.cshtml"
Write(foo);


#line default
#line hidden

#line 7 "ExpressionsInCode.cshtml"
        
} else {


#line default
#line hidden
WriteLiteral("    <p>Foo is Null!</p>\r\n");


#line 10 "ExpressionsInCode.cshtml"
}


#line default
#line hidden
WriteLiteral("\r\n<p>\r\n");


#line 13 "ExpressionsInCode.cshtml"
 if(!String.IsNullOrEmpty(bar)) {
    

#line default
#line hidden

#line 14 "ExpressionsInCode.cshtml"
Write(bar.Replace("F", "B"));


#line default
#line hidden

#line 14 "ExpressionsInCode.cshtml"
                            
}


#line default
#line hidden
WriteLiteral("</p>");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/FunctionsBlock.DesignTime.Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class FunctionsBlock {
private static object @__o;
#line hidden
#line 1 "FunctionsBlock.cshtml"
			


#line default
#line hidden

#line 2 "FunctionsBlock.cshtml"
			
    Random _rand = new Random();
    private int RandomInt() {
        return _rand.Next();
    }

#line default
#line hidden

public FunctionsBlock() {
}
public override void Execute() {

#line 3 "FunctionsBlock.cshtml"
				   __o = RandomInt();


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/FunctionsBlock.DesignTime.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class FunctionsBlock {
private static object @__o;
#line hidden
#line 1 "FunctionsBlock.cshtml"
            


#line default
#line hidden

#line 2 "FunctionsBlock.cshtml"
            
    Random _rand = new Random();
    private int RandomInt() {
        return _rand.Next();
    }

#line default
#line hidden

public FunctionsBlock() {
}
public override void Execute() {

#line 3 "FunctionsBlock.cshtml"
                   __o = RandomInt();


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/FunctionsBlock.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class FunctionsBlock {
#line hidden
#line 1 "FunctionsBlock.cshtml"
            


#line default
#line hidden

#line 5 "FunctionsBlock.cshtml"
            
    Random _rand = new Random();
    private int RandomInt() {
        return _rand.Next();
    }

#line default
#line hidden

public FunctionsBlock() {
}
public override void Execute() {
WriteLiteral("\r\n");

WriteLiteral("\r\nHere\'s a random number: ");


#line 12 "FunctionsBlock.cshtml"
                   Write(RandomInt());


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/FunctionsBlockMinimal.DesignTime.Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class FunctionsBlockMinimal {
#line hidden
#line 1 "FunctionsBlockMinimal.cshtml"
			   
string foo(string input) {
	return input + "!";
}

#line default
#line hidden

public FunctionsBlockMinimal() {
}
public override void Execute() {
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/FunctionsBlock_Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class FunctionsBlock_Tabs {
#line hidden
#line 1 "FunctionsBlock_Tabs.cshtml"
            


#line default
#line hidden

#line 5 "FunctionsBlock_Tabs.cshtml"
            
	Random _rand = new Random();
	private int RandomInt() {
		return _rand.Next();
	}

#line default
#line hidden

public FunctionsBlock_Tabs() {
}
public override void Execute() {
WriteLiteral("\r\n");

WriteLiteral("\r\nHere\'s a random number: ");


#line 12 "FunctionsBlock_Tabs.cshtml"
                   Write(RandomInt());


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Helpers.Instance.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Helpers {
#line hidden
#line 1 "Helpers.cshtml"
public Template Bold(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "Helpers.cshtml"
                        
    s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <strong>");


#line 3 "Helpers.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</strong>\r\n");


#line 4 "Helpers.cshtml"


#line default
#line hidden
});

#line 4 "Helpers.cshtml"
}
#line default
#line hidden

#line 6 "Helpers.cshtml"
public Template Italic(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 6 "Helpers.cshtml"
                          
    s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <em>");


#line 8 "Helpers.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</em>\r\n");


#line 9 "Helpers.cshtml"


#line default
#line hidden
});

#line 9 "Helpers.cshtml"
}
#line default
#line hidden

public Helpers() {
}
public override void Execute() {
WriteLiteral("\r\n");

WriteLiteral("\r\n");


#line 11 "Helpers.cshtml"
Write(Bold("Hello"));


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Helpers.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Helpers {
#line hidden
#line 1 "Helpers.cshtml"
public static Template Bold(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "Helpers.cshtml"
                        
    s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <strong>");


#line 3 "Helpers.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</strong>\r\n");


#line 4 "Helpers.cshtml"


#line default
#line hidden
});

#line 4 "Helpers.cshtml"
}
#line default
#line hidden

#line 6 "Helpers.cshtml"
public static Template Italic(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 6 "Helpers.cshtml"
                          
    s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <em>");


#line 8 "Helpers.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</em>\r\n");


#line 9 "Helpers.cshtml"


#line default
#line hidden
});

#line 9 "Helpers.cshtml"
}
#line default
#line hidden

public Helpers() {
}
public override void Execute() {
WriteLiteral("\r\n");

WriteLiteral("\r\n");


#line 11 "Helpers.cshtml"
Write(Bold("Hello"));


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/HelpersMissingCloseParen.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class HelpersMissingCloseParen {
#line hidden
#line 1 "HelpersMissingCloseParen.cshtml"
public static Template Bold(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "HelpersMissingCloseParen.cshtml"
                        
    s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <strong>");


#line 3 "HelpersMissingCloseParen.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</strong>\r\n");


#line 4 "HelpersMissingCloseParen.cshtml"


#line default
#line hidden
});

#line 4 "HelpersMissingCloseParen.cshtml"
}
#line default
#line hidden

#line 6 "HelpersMissingCloseParen.cshtml"
public static Template Italic(string s
@Bold("Hello")
#line default
#line hidden

public HelpersMissingCloseParen() {
}
public override void Execute() {
WriteLiteral("\r\n");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/HelpersMissingName.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class HelpersMissingName {
#line hidden
public HelpersMissingName() {
}
public override void Execute() {
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/HelpersMissingOpenBrace.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class HelpersMissingOpenBrace {
#line hidden
#line 1 "HelpersMissingOpenBrace.cshtml"
public static Template Bold(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "HelpersMissingOpenBrace.cshtml"
                        
    s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <strong>");


#line 3 "HelpersMissingOpenBrace.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</strong>\r\n");


#line 4 "HelpersMissingOpenBrace.cshtml"


#line default
#line hidden
});

#line 4 "HelpersMissingOpenBrace.cshtml"
}
#line default
#line hidden

#line 6 "HelpersMissingOpenBrace.cshtml"
public static Template Italic(string s) 
#line default
#line hidden

public HelpersMissingOpenBrace() {
}
public override void Execute() {
WriteLiteral("\r\n");


#line 7 "HelpersMissingOpenBrace.cshtml"
Write(Italic(s));


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/HelpersMissingOpenParen.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class HelpersMissingOpenParen {
#line hidden
#line 1 "HelpersMissingOpenParen.cshtml"
public static Template Bold(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "HelpersMissingOpenParen.cshtml"
                        
    s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <strong>");


#line 3 "HelpersMissingOpenParen.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</strong>\r\n");


#line 4 "HelpersMissingOpenParen.cshtml"


#line default
#line hidden
});

#line 4 "HelpersMissingOpenParen.cshtml"
}
#line default
#line hidden

#line 6 "HelpersMissingOpenParen.cshtml"
public static Template Italic
#line default
#line hidden

public HelpersMissingOpenParen() {
}
public override void Execute() {
WriteLiteral("\r\n");


#line 7 "HelpersMissingOpenParen.cshtml"
Write(Bold("Hello"));


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/HiddenSpansInCode.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class HiddenSpansInCode {
#line hidden
public HiddenSpansInCode() {
}
public override void Execute() {

#line 1 "HiddenSpansInCode.cshtml"
  
    

#line default
#line hidden

#line 2 "HiddenSpansInCode.cshtml"
     @Da


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/HtmlCommentWithQuote_Double.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class HtmlCommentWithQuote_Double {
#line hidden
public HtmlCommentWithQuote_Double() {
}
public override void Execute() {
WriteLiteral("<!-- \" -->\r\n<img");

WriteAttribute("src", Tuple.Create(" src=\"", 16), Tuple.Create("\"", 41)
, Tuple.Create(Tuple.Create("", 22), Tuple.Create<System.Object, System.Int32>(Href("~/images/submit.png")
, 22), false)
);

WriteLiteral(" />");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/HtmlCommentWithQuote_Single.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class HtmlCommentWithQuote_Single {
#line hidden
public HtmlCommentWithQuote_Single() {
}
public override void Execute() {
WriteLiteral("<!-- \' -->\r\n<img");

WriteAttribute("src", Tuple.Create(" src=\"", 16), Tuple.Create("\"", 41)
, Tuple.Create(Tuple.Create("", 22), Tuple.Create<System.Object, System.Int32>(Href("~/images/submit.png")
, 22), false)
);

WriteLiteral(" />");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ImplicitExpression.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ImplicitExpression {
#line hidden
public ImplicitExpression() {
}
public override void Execute() {

#line 1 "ImplicitExpression.cshtml"
 for(int i = 1; i <= 10; i++) {


#line default
#line hidden
WriteLiteral("    <p>This is item #");


#line 2 "ImplicitExpression.cshtml"
                Write(i);


#line default
#line hidden
WriteLiteral("</p>\r\n");


#line 3 "ImplicitExpression.cshtml"
}

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ImplicitExpressionAtEOF.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ImplicitExpressionAtEOF {
private static object @__o;
#line hidden
public ImplicitExpressionAtEOF() {
}
public override void Execute() {

#line 1 "ImplicitExpressionAtEOF.cshtml"
__o = ;


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Imports.DesignTime.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {

#line 3 "Imports.cshtml"
using System;

#line default
#line hidden

#line 1 "Imports.cshtml"
using System.IO;

#line default
#line hidden

#line 2 "Imports.cshtml"
using Foo = System.Text.Encoding;

#line default
#line hidden

public class Imports {
private static object @__o;
#line hidden
public Imports() {
}
public override void Execute() {

#line 4 "Imports.cshtml"
                       __o = typeof(Path).FullName;


#line default
#line hidden

#line 5 "Imports.cshtml"
                             __o = typeof(Foo).FullName;


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Imports.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {

#line 3 "Imports.cshtml"
using System;

#line default
#line hidden

#line 1 "Imports.cshtml"
using System.IO;

#line default
#line hidden

#line 2 "Imports.cshtml"
using Foo = System.Text.Encoding;

#line default
#line hidden

public class Imports {
#line hidden
public Imports() {
}
public override void Execute() {
WriteLiteral("\r\n<p>Path\'s full type name is ");


#line 5 "Imports.cshtml"
                       Write(typeof(Path).FullName);


#line default
#line hidden
WriteLiteral("</p>\r\n<p>Foo\'s actual full type name is ");


#line 6 "Imports.cshtml"
                             Write(typeof(Foo).FullName);


#line default
#line hidden
WriteLiteral("</p>");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Inherits.Designtime.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Inherits : foo.bar<baz<biz>>.boz bar {
private static object @__o;
#line hidden
public Inherits() {
}
private void @__RazorDesignTimeHelpers__() {
#pragma warning disable 219

#line 2 "Inherits.cshtml"
          foo.bar<baz<biz>>.boz bar __inheritsHelper = null;


#line default
#line hidden
#pragma warning restore 219
}
public override void Execute() {

#line 1 "Inherits.cshtml"
__o = foo();


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Inherits.Runtime.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Inherits : foo.bar<baz<biz>>.boz bar {
#line hidden
public Inherits() {
}
public override void Execute() {

#line 1 "Inherits.cshtml"
Write(foo());


#line default
#line hidden
WriteLiteral("\r\n\r\n");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/InlineBlocks.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class InlineBlocks {
#line hidden
#line 1 "InlineBlocks.cshtml"
public static Template Link(string link) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "InlineBlocks.cshtml"
                           


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <a");

WriteAttributeTo(__razor_helper_writer, "href", Tuple.Create(" href=\"", 35), Tuple.Create("\"", 93)
, Tuple.Create(Tuple.Create("", 42), Tuple.Create<System.Object, System.Int32>(new Template(__razor_attribute_value_writer => {


#line 2 "InlineBlocks.cshtml"
              if(link != null) { 

#line default
#line hidden

#line 2 "InlineBlocks.cshtml"
WriteTo(__razor_attribute_value_writer, link);


#line default
#line hidden

#line 2 "InlineBlocks.cshtml"
                                       } else {

#line default
#line hidden
WriteLiteralTo(__razor_attribute_value_writer, " ");

WriteLiteralTo(__razor_attribute_value_writer, "#");

WriteLiteralTo(__razor_attribute_value_writer, " ");


#line 2 "InlineBlocks.cshtml"
                                                               }

#line default
#line hidden
}), 42), false)
);

WriteLiteralTo(__razor_helper_writer, " />\r\n");


#line 3 "InlineBlocks.cshtml"


#line default
#line hidden
});

#line 3 "InlineBlocks.cshtml"
}
#line default
#line hidden

public InlineBlocks() {
}
public override void Execute() {
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Instrumented.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Instrumented {
#line hidden
#line 1 "Instrumented.cshtml"
public static Template Strong(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "Instrumented.cshtml"
                          


#line default
#line hidden
BeginContext(__razor_helper_writer, "~/Instrumented.cshtml", 28, 12, true);

WriteLiteralTo(__razor_helper_writer, "    <strong>");

EndContext(__razor_helper_writer, "~/Instrumented.cshtml", 28, 12, true);

BeginContext(__razor_helper_writer, "~/Instrumented.cshtml", 41, 1, false);


#line 2 "Instrumented.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
EndContext(__razor_helper_writer, "~/Instrumented.cshtml", 41, 1, false);

BeginContext(__razor_helper_writer, "~/Instrumented.cshtml", 42, 11, true);

WriteLiteralTo(__razor_helper_writer, "</strong>\r\n");

EndContext(__razor_helper_writer, "~/Instrumented.cshtml", 42, 11, true);


#line 3 "Instrumented.cshtml"


#line default
#line hidden
});

#line 3 "Instrumented.cshtml"
}
#line default
#line hidden

public Instrumented() {
}
public override void Execute() {
BeginContext("~/Instrumented.cshtml", 56, 2, true);

WriteLiteral("\r\n");

EndContext("~/Instrumented.cshtml", 56, 2, true);


#line 5 "Instrumented.cshtml"
  
    int i = 1;
    var foo = 

#line default
#line hidden
item => new Template(__razor_template_writer => {

BeginContext(__razor_template_writer, "~/Instrumented.cshtml", 93, 10, true);

WriteLiteralTo(__razor_template_writer, "<p>Bar</p>");

EndContext(__razor_template_writer, "~/Instrumented.cshtml", 93, 10, true);

})

#line 7 "Instrumented.cshtml"
                         ;


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 106, 4, true);

WriteLiteral("    ");

EndContext("~/Instrumented.cshtml", 106, 4, true);

BeginContext("~/Instrumented.cshtml", 112, 14, true);

WriteLiteral("Hello, World\r\n");

EndContext("~/Instrumented.cshtml", 112, 14, true);

BeginContext("~/Instrumented.cshtml", 126, 25, true);

WriteLiteral("    <p>Hello, World</p>\r\n");

EndContext("~/Instrumented.cshtml", 126, 25, true);


#line 10 "Instrumented.cshtml"


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 152, 4, true);

WriteLiteral("\r\n\r\n");

EndContext("~/Instrumented.cshtml", 152, 4, true);


#line 12 "Instrumented.cshtml"
 while(i <= 10) {


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 175, 23, true);

WriteLiteral("    <p>Hello from C#, #");

EndContext("~/Instrumented.cshtml", 175, 23, true);

BeginContext("~/Instrumented.cshtml", 200, 1, false);


#line 13 "Instrumented.cshtml"
                   Write(i);


#line default
#line hidden
EndContext("~/Instrumented.cshtml", 200, 1, false);

BeginContext("~/Instrumented.cshtml", 202, 6, true);

WriteLiteral("</p>\r\n");

EndContext("~/Instrumented.cshtml", 202, 6, true);


#line 14 "Instrumented.cshtml"
    i += 1;
}


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 224, 2, true);

WriteLiteral("\r\n");

EndContext("~/Instrumented.cshtml", 224, 2, true);


#line 17 "Instrumented.cshtml"
 if(i == 11) {


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 242, 31, true);

WriteLiteral("    <p>We wrote 10 lines!</p>\r\n");

EndContext("~/Instrumented.cshtml", 242, 31, true);


#line 19 "Instrumented.cshtml"
}


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 276, 2, true);

WriteLiteral("\r\n");

EndContext("~/Instrumented.cshtml", 276, 2, true);


#line 21 "Instrumented.cshtml"
 switch(i) {
    case 11:


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 306, 46, true);

WriteLiteral("        <p>No really, we wrote 10 lines!</p>\r\n");

EndContext("~/Instrumented.cshtml", 306, 46, true);


#line 24 "Instrumented.cshtml"
        break;
    default:


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 382, 39, true);

WriteLiteral("        <p>Actually, we didn\'t...</p>\r\n");

EndContext("~/Instrumented.cshtml", 382, 39, true);


#line 27 "Instrumented.cshtml"
        break;
}


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 440, 2, true);

WriteLiteral("\r\n");

EndContext("~/Instrumented.cshtml", 440, 2, true);


#line 30 "Instrumented.cshtml"
 for(int j = 1; j <= 10; j += 2) {


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 478, 29, true);

WriteLiteral("    <p>Hello again from C#, #");

EndContext("~/Instrumented.cshtml", 478, 29, true);

BeginContext("~/Instrumented.cshtml", 509, 1, false);


#line 31 "Instrumented.cshtml"
                         Write(j);


#line default
#line hidden
EndContext("~/Instrumented.cshtml", 509, 1, false);

BeginContext("~/Instrumented.cshtml", 511, 6, true);

WriteLiteral("</p>\r\n");

EndContext("~/Instrumented.cshtml", 511, 6, true);


#line 32 "Instrumented.cshtml"
}


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 520, 2, true);

WriteLiteral("\r\n");

EndContext("~/Instrumented.cshtml", 520, 2, true);


#line 34 "Instrumented.cshtml"
 try {


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 530, 41, true);

WriteLiteral("    <p>That time, we wrote 5 lines!</p>\r\n");

EndContext("~/Instrumented.cshtml", 530, 41, true);


#line 36 "Instrumented.cshtml"
} catch(Exception ex) {


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 596, 33, true);

WriteLiteral("    <p>Oh no! An error occurred: ");

EndContext("~/Instrumented.cshtml", 596, 33, true);

BeginContext("~/Instrumented.cshtml", 631, 10, false);


#line 37 "Instrumented.cshtml"
                             Write(ex.Message);


#line default
#line hidden
EndContext("~/Instrumented.cshtml", 631, 10, false);

BeginContext("~/Instrumented.cshtml", 642, 6, true);

WriteLiteral("</p>\r\n");

EndContext("~/Instrumented.cshtml", 642, 6, true);


#line 38 "Instrumented.cshtml"
}


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 651, 2, true);

WriteLiteral("\r\n");

EndContext("~/Instrumented.cshtml", 651, 2, true);


#line 40 "Instrumented.cshtml"
 lock(new object()) {


#line default
#line hidden
BeginContext("~/Instrumented.cshtml", 676, 53, true);

WriteLiteral("    <p>This block is locked, for your security!</p>\r\n");

EndContext("~/Instrumented.cshtml", 676, 53, true);


#line 42 "Instrumented.cshtml"
}

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/LayoutDirective.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class LayoutDirective {
#line hidden
public LayoutDirective() {
}
public override void Execute() {
Layout = "~/Foo/Bar/Baz";
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/MarkupInCodeBlock.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class MarkupInCodeBlock {
#line hidden
public MarkupInCodeBlock() {
}
public override void Execute() {

#line 1 "MarkupInCodeBlock.cshtml"
  
    for(int i = 1; i <= 10; i++) {


#line default
#line hidden
WriteLiteral("        <p>Hello from C#, #");


#line 3 "MarkupInCodeBlock.cshtml"
                       Write(i.ToString());


#line default
#line hidden
WriteLiteral("</p>\r\n");


#line 4 "MarkupInCodeBlock.cshtml"
    }


#line default
#line hidden
WriteLiteral("\r\n");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/NestedCodeBlocks.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class NestedCodeBlocks {
#line hidden
public NestedCodeBlocks() {
}
public override void Execute() {

#line 1 "NestedCodeBlocks.cshtml"
 if(foo) {
    

#line default
#line hidden

#line 2 "NestedCodeBlocks.cshtml"
     if(bar) {
    }

#line default
#line hidden

#line 3 "NestedCodeBlocks.cshtml"
     
}

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/NestedHelpers.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class NestedHelpers {
#line hidden
#line 3 "NestedHelpers.cshtml"
public static Template Bold(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 3 "NestedHelpers.cshtml"
                            
        s = s.ToUpper();


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "        <strong>");


#line 5 "NestedHelpers.cshtml"
WriteTo(__razor_helper_writer, s);


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</strong>\r\n");


#line 6 "NestedHelpers.cshtml"
    

#line default
#line hidden
});

#line 6 "NestedHelpers.cshtml"
}
#line default
#line hidden

#line 1 "NestedHelpers.cshtml"
public static Template Italic(string s) {
#line default
#line hidden
return new Template(__razor_helper_writer => {

#line 1 "NestedHelpers.cshtml"
                          
    s = s.ToUpper();
    

#line default
#line hidden

#line 6 "NestedHelpers.cshtml"
     


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "    <em>");


#line 7 "NestedHelpers.cshtml"
WriteTo(__razor_helper_writer, Bold(s));


#line default
#line hidden
WriteLiteralTo(__razor_helper_writer, "</em>\r\n");


#line 8 "NestedHelpers.cshtml"


#line default
#line hidden
});

#line 8 "NestedHelpers.cshtml"
}
#line default
#line hidden

public NestedHelpers() {
}
public override void Execute() {
WriteLiteral("\r\n");


#line 10 "NestedHelpers.cshtml"
Write(Italic("Hello"));


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/NoLinePragmas.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class NoLinePragmas {
#line hidden
public NoLinePragmas() {
}
public override void Execute() {
  
    int i = 1;

WriteLiteral("\r\n\r\n");

 while(i <= 10) {

WriteLiteral("    <p>Hello from C#, #");

                   Write(i);

WriteLiteral("</p>\r\n");

    i += 1;
}

WriteLiteral("\r\n");

 if(i == 11) {

WriteLiteral("    <p>We wrote 10 lines!</p>\r\n");

}

WriteLiteral("\r\n");

 switch(i) {
    case 11:

WriteLiteral("        <p>No really, we wrote 10 lines!</p>\r\n");

        break;
    default:

WriteLiteral("        <p>Actually, we didn\'t...</p>\r\n");

        break;
}

WriteLiteral("\r\n");

 for(int j = 1; j <= 10; j += 2) {

WriteLiteral("    <p>Hello again from C#, #");

                         Write(j);

WriteLiteral("</p>\r\n");

}

WriteLiteral("\r\n");

 try {

WriteLiteral("    <p>That time, we wrote 5 lines!</p>\r\n");

} catch(Exception ex) {

WriteLiteral("    <p>Oh no! An error occurred: ");

                             Write(ex.Message);

WriteLiteral("</p>\r\n");

}


                                  

WriteLiteral("<p>i is now ");

       Write(i);

WriteLiteral("</p>\r\n\r\n");

 lock(new object()) {

WriteLiteral("    <p>This block is locked, for your security!</p>\r\n");

}
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/OpenedIf.DesignTime.Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class OpenedIf {
#line hidden
public OpenedIf() {
}
public override void Execute() {

#line 1 "OpenedIf.cshtml"
if (true) { 


#line default
#line hidden

#line 2 "OpenedIf.cshtml"
	   


#line default
#line hidden

#line 3 "OpenedIf.cshtml"
	   

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/OpenedIf.DesignTime.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class OpenedIf {
#line hidden
public OpenedIf() {
}
public override void Execute() {

#line 1 "OpenedIf.cshtml"
if (true) { 


#line default
#line hidden

#line 2 "OpenedIf.cshtml"
       


#line default
#line hidden

#line 3 "OpenedIf.cshtml"
       

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ParserError.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ParserError {
#line hidden
public ParserError() {
}
public override void Execute() {

#line 1 "ParserError.cshtml"
  
/*
int i =10;
int j =20;
}

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/RazorComments.DesignTime.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class RazorComments {
private static object @__o;
#line hidden
public RazorComments() {
}
public override void Execute() {

#line 1 "RazorComments.cshtml"
  
    

#line default
#line hidden

#line 2 "RazorComments.cshtml"
                                      
    Exception foo = 

#line default
#line hidden

#line 3 "RazorComments.cshtml"
                                                 null;
    if(foo != null) {
        throw foo;
    }


#line default
#line hidden

#line 4 "RazorComments.cshtml"
   var bar = "@* bar *@"; 

#line default
#line hidden

#line 5 "RazorComments.cshtml"
                                       __o = bar;


#line default
#line hidden

#line 6 "RazorComments.cshtml"
__o = a

#line default
#line hidden

#line 7 "RazorComments.cshtml"
       b;


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/RazorComments.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class RazorComments {
#line hidden
public RazorComments() {
}
public override void Execute() {
WriteLiteral("\r\n<p>This should ");

WriteLiteral(" be shown</p>\r\n\r\n");


#line 4 "RazorComments.cshtml"
  
    

#line default
#line hidden

#line 5 "RazorComments.cshtml"
                                       
    Exception foo = 

#line default
#line hidden

#line 6 "RazorComments.cshtml"
                                                  null;
    if(foo != null) {
        throw foo;
    }


#line default
#line hidden
WriteLiteral("\r\n\r\n");


#line 12 "RazorComments.cshtml"
   var bar = "@* bar *@"; 

#line default
#line hidden
WriteLiteral("\r\n<p>But this should show the comment syntax: ");


#line 13 "RazorComments.cshtml"
                                       Write(bar);


#line default
#line hidden
WriteLiteral("</p>\r\n\r\n");


#line 15 "RazorComments.cshtml"
Write(a

#line default
#line hidden

#line 15 "RazorComments.cshtml"
       b);


#line default
#line hidden
WriteLiteral("\r\n");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/ResolveUrl.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class ResolveUrl {
#line hidden
public ResolveUrl() {
}
public override void Execute() {
WriteLiteral("<a");

WriteAttribute("href", Tuple.Create(" href=\"", 2), Tuple.Create("\"", 14)
, Tuple.Create(Tuple.Create("", 9), Tuple.Create<System.Object, System.Int32>(Href("~/Foo")
, 9), false)
);

WriteLiteral(">Foo</a>\r\n<a");

WriteAttribute("href", Tuple.Create(" href=\"", 27), Tuple.Create("\"", 56)
, Tuple.Create(Tuple.Create("", 34), Tuple.Create<System.Object, System.Int32>(Href("~/Products/")
, 34), false)

#line 2 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 45), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 45), false)
);

WriteLiteral(">");


#line 2 "ResolveUrl.cshtml"
                            Write(product.Name);


#line default
#line hidden
WriteLiteral("</a>\r\n<a");

WriteAttribute("href", Tuple.Create(" href=\"", 79), Tuple.Create("\"", 115)
, Tuple.Create(Tuple.Create("", 86), Tuple.Create<System.Object, System.Int32>(Href("~/Products/")
, 86), false)

#line 3 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 97), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 97), false)
, Tuple.Create(Tuple.Create("", 108), Tuple.Create("/Detail", 108), true)
);

WriteLiteral(">Details</a>\r\n<a");

WriteAttribute("href", Tuple.Create(" href=\"", 132), Tuple.Create("\"", 187)
, Tuple.Create(Tuple.Create("", 139), Tuple.Create<System.Object, System.Int32>(Href("~/A+Really(Crazy),Url.Is:This/")
, 139), false)

#line 4 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 169), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 169), false)
, Tuple.Create(Tuple.Create("", 180), Tuple.Create("/Detail", 180), true)
);

WriteLiteral(">Crazy Url!</a>\r\n\r\n");


#line 6 "ResolveUrl.cshtml"
  


#line default
#line hidden
WriteLiteral("    ");

WriteLiteral("\r\n        <a");

WriteAttribute("href", Tuple.Create(" href=\"", 233), Tuple.Create("\"", 245)
, Tuple.Create(Tuple.Create("", 240), Tuple.Create<System.Object, System.Int32>(Href("~/Foo")
, 240), false)
);

WriteLiteral(">Foo</a>\r\n        <a");

WriteAttribute("href", Tuple.Create(" href=\"", 266), Tuple.Create("\"", 295)
, Tuple.Create(Tuple.Create("", 273), Tuple.Create<System.Object, System.Int32>(Href("~/Products/")
, 273), false)

#line 9 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 284), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 284), false)
);

WriteLiteral(">");


#line 9 "ResolveUrl.cshtml"
                                    Write(product.Name);


#line default
#line hidden
WriteLiteral("</a>\r\n        <a");

WriteAttribute("href", Tuple.Create(" href=\"", 326), Tuple.Create("\"", 362)
, Tuple.Create(Tuple.Create("", 333), Tuple.Create<System.Object, System.Int32>(Href("~/Products/")
, 333), false)

#line 10 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 344), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 344), false)
, Tuple.Create(Tuple.Create("", 355), Tuple.Create("/Detail", 355), true)
);

WriteLiteral(">Details</a>\r\n        <a");

WriteAttribute("href", Tuple.Create(" href=\"", 387), Tuple.Create("\"", 442)
, Tuple.Create(Tuple.Create("", 394), Tuple.Create<System.Object, System.Int32>(Href("~/A+Really(Crazy),Url.Is:This/")
, 394), false)

#line 11 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 424), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 424), false)
, Tuple.Create(Tuple.Create("", 435), Tuple.Create("/Detail", 435), true)
);

WriteLiteral(">Crazy Url!</a>\r\n    ");

WriteLiteral("\r\n");


#line 13 "ResolveUrl.cshtml"


#line default
#line hidden
WriteLiteral("\r\n\r\n");

DefineSection("Foo", () => {

WriteLiteral("\r\n    <a");

WriteAttribute("href", Tuple.Create(" href=\"", 500), Tuple.Create("\"", 512)
, Tuple.Create(Tuple.Create("", 507), Tuple.Create<System.Object, System.Int32>(Href("~/Foo")
, 507), false)
);

WriteLiteral(">Foo</a>\r\n    <a");

WriteAttribute("href", Tuple.Create(" href=\"", 529), Tuple.Create("\"", 558)
, Tuple.Create(Tuple.Create("", 536), Tuple.Create<System.Object, System.Int32>(Href("~/Products/")
, 536), false)

#line 17 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 547), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 547), false)
);

WriteLiteral(">");


#line 17 "ResolveUrl.cshtml"
                                Write(product.Name);


#line default
#line hidden
WriteLiteral("</a>\r\n    <a");

WriteAttribute("href", Tuple.Create(" href=\"", 585), Tuple.Create("\"", 621)
, Tuple.Create(Tuple.Create("", 592), Tuple.Create<System.Object, System.Int32>(Href("~/Products/")
, 592), false)

#line 18 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 603), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 603), false)
, Tuple.Create(Tuple.Create("", 614), Tuple.Create("/Detail", 614), true)
);

WriteLiteral(">Details</a>\r\n    <a");

WriteAttribute("href", Tuple.Create(" href=\"", 642), Tuple.Create("\"", 697)
, Tuple.Create(Tuple.Create("", 649), Tuple.Create<System.Object, System.Int32>(Href("~/A+Really(Crazy),Url.Is:This/")
, 649), false)

#line 19 "ResolveUrl.cshtml"
, Tuple.Create(Tuple.Create("", 679), Tuple.Create<System.Object, System.Int32>(product.id

#line default
#line hidden
, 679), false)
, Tuple.Create(Tuple.Create("", 690), Tuple.Create("/Detail", 690), true)
);

WriteLiteral(">Crazy Url!</a>\r\n");

});

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Sections.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Sections {
#line hidden
public Sections() {
}
public override void Execute() {

#line 1 "Sections.cshtml"
  
    Layout = "_SectionTestLayout.cshtml"


#line default
#line hidden
WriteLiteral("\r\n\r\n<div>This is in the Body>\r\n\r\n");

DefineSection("Section2", () => {

WriteLiteral("\r\n    <div>This is in Section 2</div>\r\n");

});

WriteLiteral("\r\n");

DefineSection("Section1", () => {

WriteLiteral("\r\n    <div>This is in Section 1</div>\r\n");

});

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/SimpleUnspacedIf.DesignTime.Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class SimpleUnspacedIf {
#line hidden
public SimpleUnspacedIf() {
}
public override void Execute() {

#line 1 "SimpleUnspacedIf.cshtml"
if (true)
{
	

#line default
#line hidden

#line 2 "SimpleUnspacedIf.cshtml"
			   
}

#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/Templates.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class Templates {
#line hidden
#line 1 "Templates.cshtml"
            
    public HelperResult Repeat(int times, Func<int, object> template) {
        return new HelperResult((writer) => {
            for(int i = 0; i < times; i++) {
                ((HelperResult)template(i)).WriteTo(writer);
            }
        });
    }

#line default
#line hidden

public Templates() {
}
public override void Execute() {
WriteLiteral("\r\n");


#line 11 "Templates.cshtml"
  
    Func<dynamic, object> foo = 

#line default
#line hidden
item => new Template(__razor_template_writer => {

WriteLiteralTo(__razor_template_writer, "This works ");


#line 12 "Templates.cshtml"
                  WriteTo(__razor_template_writer, item);


#line default
#line hidden
WriteLiteralTo(__razor_template_writer, "!");

})

#line 12 "Templates.cshtml"
                                                               ;
    

#line default
#line hidden

#line 13 "Templates.cshtml"
Write(foo(""));


#line default
#line hidden

#line 13 "Templates.cshtml"
            


#line default
#line hidden
WriteLiteral("\r\n\r\n<ul>\r\n");


#line 17 "Templates.cshtml"
Write(Repeat(10, item => new Template(__razor_template_writer => {


#line default
#line hidden
WriteLiteralTo(__razor_template_writer, "<li>Item #");


#line 17 "Templates.cshtml"
WriteTo(__razor_template_writer, item);


#line default
#line hidden
WriteLiteralTo(__razor_template_writer, "</li>");


#line 17 "Templates.cshtml"
                                })));


#line default
#line hidden
WriteLiteral("\r\n</ul>\r\n\r\n<p>\r\n");


#line 21 "Templates.cshtml"
Write(Repeat(10,
    item => new Template(__razor_template_writer => {


#line default
#line hidden
WriteLiteralTo(__razor_template_writer, " This is line#");


#line 22 "Templates.cshtml"
WriteTo(__razor_template_writer, item);


#line default
#line hidden
WriteLiteralTo(__razor_template_writer, " of markup<br/>\r\n");


#line 23 "Templates.cshtml"
})));


#line default
#line hidden
WriteLiteral("\r\n</p>\r\n\r\n<ul>\r\n");

WriteLiteral("    ");


#line 27 "Templates.cshtml"
Write(Repeat(10, item => new Template(__razor_template_writer => {


#line default
#line hidden
WriteLiteralTo(__razor_template_writer, "<li>\r\n        Item #");


#line 28 "Templates.cshtml"
WriteTo(__razor_template_writer, item);


#line default
#line hidden
WriteLiteralTo(__razor_template_writer, "\r\n");


#line 29 "Templates.cshtml"
        

#line default
#line hidden

#line 29 "Templates.cshtml"
          var parent = item;

#line default
#line hidden
WriteLiteralTo(__razor_template_writer, "\r\n        <ul>\r\n            <li>Child Items... ?</li>\r\n            ");

WriteLiteralTo(__razor_template_writer, "\r\n        </ul>\r\n    </li>");


#line 34 "Templates.cshtml"
       })));


#line default
#line hidden
WriteLiteral("\r\n</ul> ");

}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/UnfinishedExpressionInCode.Tabs.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class UnfinishedExpressionInCode {
private static object @__o;
#line hidden
public UnfinishedExpressionInCode() {
}
public override void Execute() {

#line 1 "UnfinishedExpressionInCode.cshtml"
  


#line default
#line hidden

#line 2 "UnfinishedExpressionInCode.cshtml"
__o = DateTime.;


#line default
#line hidden

#line 3 "UnfinishedExpressionInCode.cshtml"
		  


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Output/UnfinishedExpressionInCode.cs
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace TestOutput {
using System;

public class UnfinishedExpressionInCode {
private static object @__o;
#line hidden
public UnfinishedExpressionInCode() {
}
public override void Execute() {

#line 1 "UnfinishedExpressionInCode.cshtml"
  


#line default
#line hidden

#line 2 "UnfinishedExpressionInCode.cshtml"
__o = DateTime.;


#line default
#line hidden

#line 3 "UnfinishedExpressionInCode.cshtml"
          


#line default
#line hidden
}
}
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/Blocks.cshtml
================================================
@{
    int i = 1;
}

@while(i <= 10) {
    <p>Hello from C#, #@(i)</p>
    i += 1;
}

@if(i == 11) {
    <p>We wrote 10 lines!</p>
}

@switch(i) {
    case 11:
        <p>No really, we wrote 10 lines!</p>
        break;
    default:
        <p>Actually, we didn't...</p>
        break;
}

@for(int j = 1; j <= 10; j += 2) {
    <p>Hello again from C#, #@(j)</p>
}

@try {
    <p>That time, we wrote 5 lines!</p>
} catch(Exception ex) {
    <p>Oh no! An error occurred: @(ex.Message)</p>
}

<p>i is now @i</p>

@lock(new object()) {
    <p>This block is locked, for your security!</p>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/CodeBlock.cshtml
================================================
@{
    for(int i = 1; i <= 10; i++) {
        Output.Write("<p>Hello from C#, #" + i.ToString() + "</p>");
    }
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/CodeBlockAtEOF.cshtml
================================================
@{

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ConditionalAttributes.cshtml
================================================
@{
    var ch = true;
    var cls = "bar";
    <a href="Foo" />
    <p class="@cls" />
    <p class="foo @cls" />
    <p class="@cls foo" />
    <input type="checkbox" checked="@ch" />
    <input type="checkbox" checked="foo @ch" />
    <p class="@if(cls != null) { @cls }" />
    <a href="~/Foo" />
    <script src="@Url.Content("~/Scripts/jquery-1.6.2.min.js")" type="text/javascript"></script>
    <script src="@Url.Content("~/Scripts/modernizr-2.0.6-development-only.js")" type="text/javascript"></script>
    <script src="http://ajax.aspnetcdn.com/ajax/jquery.ui/1.8.16/jquery-ui.min.js" type="text/javascript"></script>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/DesignTime.cshtml
================================================
<div>
            @for(int i = 1; i <= 10; i++) {
    <p>This is item #@i</p>
            }
</div>

<p>
@(Foo(Bar.Baz))
@Foo(@<p>Bar @baz Biz</p>)
</p>

@section Footer {
    <p>Foo</p>
    @bar
}

@helper Foo() {
    if(true) {
        <p>Foo</p>
    }
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/EmptyCodeBlock.cshtml
================================================
This is markup

@{}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/EmptyExplicitExpression.cshtml
================================================
This is markup

@()

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/EmptyImplicitExpression.cshtml
================================================
This is markup

@!

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/EmptyImplicitExpressionInCode.cshtml
================================================
@{
    @
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ExplicitExpression.cshtml
================================================
1 + 1 = @(1+1)

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ExplicitExpressionAtEOF.cshtml
================================================
This is markup

@(

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ExpressionsInCode.cshtml
================================================
@{
    object foo = null;
    string bar = "Foo";
}

@if(foo != null) {
    @foo
} else {
    <p>Foo is Null!</p>
}

<p>
@if(!String.IsNullOrEmpty(bar)) {
    @(bar.Replace("F", "B"))
}
</p>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/FunctionsBlock.cshtml
================================================
@functions {

}

@functions {
    Random _rand = new Random();
    private int RandomInt() {
        return _rand.Next();
    }
}

Here's a random number: @RandomInt()

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/FunctionsBlockMinimal.cshtml
================================================


	@functions{
string foo(string input) {
	return input + "!";
}
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/FunctionsBlock_Tabs.cshtml
================================================
@functions {

}

@functions {
	Random _rand = new Random();
	private int RandomInt() {
		return _rand.Next();
	}
}

Here's a random number: @RandomInt()

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/Helpers.cshtml
================================================
@helper Bold(string s) {
    s = s.ToUpper();
    <strong>@s</strong>
}

@helper Italic(string s) {
    s = s.ToUpper();
    <em>@s</em>
}

@Bold("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/HelpersMissingCloseParen.cshtml
================================================
@helper Bold(string s) {
    s = s.ToUpper();
    <strong>@s</strong>
}

@helper Italic(string s
@Bold("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/HelpersMissingName.cshtml
================================================
@helper

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/HelpersMissingOpenBrace.cshtml
================================================
@helper Bold(string s) {
    s = s.ToUpper();
    <strong>@s</strong>
}

@helper Italic(string s) 
@Italic(s)

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/HelpersMissingOpenParen.cshtml
================================================
@helper Bold(string s) {
    s = s.ToUpper();
    <strong>@s</strong>
}

@helper Italic
@Bold("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/HiddenSpansInCode.cshtml
================================================
@{
    @@Da
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/HtmlCommentWithQuote_Double.cshtml
================================================
<!-- " -->
<img src="~/images/submit.png" />

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/HtmlCommentWithQuote_Single.cshtml
================================================
<!-- ' -->
<img src="~/images/submit.png" />

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ImplicitExpression.cshtml
================================================
@for(int i = 1; i <= 10; i++) {
    <p>This is item #@i</p>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ImplicitExpressionAtEOF.cshtml
================================================
This is markup

@

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/Imports.cshtml
================================================
@using System.IO
@using Foo = System.Text.Encoding
@using System

<p>Path's full type name is @typeof(Path).FullName</p>
<p>Foo's actual full type name is @typeof(Foo).FullName</p>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/Inherits.cshtml
================================================
@foo()

@inherits foo.bar<baz<biz>>.boz bar


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/InlineBlocks.cshtml
================================================
@helper Link(string link) {
    <a href="@if(link != null) { @link } else { <text>#</text> }" />
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/Instrumented.cshtml
================================================
@helper Strong(string s) {
    <strong>@s</strong>
}

@{
    int i = 1;
    var foo = @<p>Bar</p>;
    @:Hello, World
    <p>Hello, World</p>
}

@while(i <= 10) {
    <p>Hello from C#, #@(i)</p>
    i += 1;
}

@if(i == 11) {
    <p>We wrote 10 lines!</p>
}

@switch(i) {
    case 11:
        <p>No really, we wrote 10 lines!</p>
        break;
    default:
        <p>Actually, we didn't...</p>
        break;
}

@for(int j = 1; j <= 10; j += 2) {
    <p>Hello again from C#, #@(j)</p>
}

@try {
    <p>That time, we wrote 5 lines!</p>
} catch(Exception ex) {
    <p>Oh no! An error occurred: @(ex.Message)</p>
}

@lock(new object()) {
    <p>This block is locked, for your security!</p>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/LayoutDirective.cshtml
================================================
@layout ~/Foo/Bar/Baz

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/MarkupInCodeBlock.cshtml
================================================
@{
    for(int i = 1; i <= 10; i++) {
        <p>Hello from C#, #@(i.ToString())</p>
    }
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/NestedCodeBlocks.cshtml
================================================
@if(foo) {
    @if(bar) {
    }
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/NestedHelpers.cshtml
================================================
@helper Italic(string s) {
    s = s.ToUpper();
    @helper Bold(string s) {
        s = s.ToUpper();
        <strong>@s</strong>
    }
    <em>@Bold(s)</em>
}

@Italic("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/NoLinePragmas.cshtml
================================================
@{
    int i = 1;
}

@while(i <= 10) {
    <p>Hello from C#, #@(i)</p>
    i += 1;
}

@if(i == 11) {
    <p>We wrote 10 lines!</p>
}

@switch(i) {
    case 11:
        <p>No really, we wrote 10 lines!</p>
        break;
    default:
        <p>Actually, we didn't...</p>
        break;
}

@for(int j = 1; j <= 10; j += 2) {
    <p>Hello again from C#, #@(j)</p>
}

@try {
    <p>That time, we wrote 5 lines!</p>
} catch(Exception ex) {
    <p>Oh no! An error occurred: @(ex.Message)</p>
}

@* With has no equivalent in C# *@
<p>i is now @i</p>

@lock(new object()) {
    <p>This block is locked, for your security!</p>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/OpenedIf.cshtml
================================================
<html>
<body>
@if (true) { 
</body>
</html>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ParserError.cshtml
================================================
@{
/*
int i =10;
int j =20;
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/RazorComments.cshtml
================================================
@*This is not going to be rendered*@
<p>This should @* not *@ be shown</p>

@{
    @* throw new Exception("Oh no!") *@
    Exception foo = @* new Exception("Oh no!") *@ null;
    if(foo != null) {
        throw foo;
    }
}

@{ var bar = "@* bar *@"; }
<p>But this should show the comment syntax: @bar</p>

@(a@**@b)


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/ResolveUrl.cshtml
================================================
<a href="~/Foo">Foo</a>
<a href="~/Products/@product.id">@product.Name</a>
<a href="~/Products/@product.id/Detail">Details</a>
<a href="~/A+Really(Crazy),Url.Is:This/@product.id/Detail">Crazy Url!</a>

@{
    <text>
        <a href="~/Foo">Foo</a>
        <a href="~/Products/@product.id">@product.Name</a>
        <a href="~/Products/@product.id/Detail">Details</a>
        <a href="~/A+Really(Crazy),Url.Is:This/@product.id/Detail">Crazy Url!</a>
    </text>
}

@section Foo {
    <a href="~/Foo">Foo</a>
    <a href="~/Products/@product.id">@product.Name</a>
    <a href="~/Products/@product.id/Detail">Details</a>
    <a href="~/A+Really(Crazy),Url.Is:This/@product.id/Detail">Crazy Url!</a>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/Sections.cshtml
================================================
@{
    Layout = "_SectionTestLayout.cshtml"
}

<div>This is in the Body>

@section Section2 {
    <div>This is in Section 2</div>
}

@section Section1 {
    <div>This is in Section 1</div>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/SimpleUnspacedIf.cshtml
================================================
@if (true)
{
	<div></div>
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/Templates.cshtml
================================================
@functions {
    public HelperResult Repeat(int times, Func<int, object> template) {
        return new HelperResult((writer) => {
            for(int i = 0; i < times; i++) {
                ((HelperResult)template(i)).WriteTo(writer);
            }
        });
    }
}

@{
    Func<dynamic, object> foo = @<text>This works @item!</text>;
    @foo("")
}

<ul>
@(Repeat(10, @<li>Item #@item</li>))
</ul>

<p>
@Repeat(10,
    @: This is line#@item of markup<br/>
)
</p>

<ul>
    @Repeat(10, @<li>
        Item #@item
        @{var parent = item;}
        <ul>
            <li>Child Items... ?</li>
            @*Repeat(10, @<li>Item #@(parent).@item</li>)*@
        </ul>
    </li>)
</ul> 

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/CS/Source/UnfinishedExpressionInCode.cshtml
================================================
@{
@DateTime.
}

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Blocks.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class Blocks
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("Blocks.vbhtml",1)
     
    Dim i as Integer = 1


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",5)
 While i <= 10


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>Hello from VB.Net, #")


#ExternalSource("Blocks.vbhtml",6)
                        Write(i)


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",7)
    i += 1
End While


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",10)
 If i = 11 Then


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>We wrote 10 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",12)
End If


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",14)
 Do


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>Hello again: ")


#ExternalSource("Blocks.vbhtml",15)
                Write(i)


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",16)
    i -= 1
Loop While i > 0


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",19)
 Select Case i
    Case 11


#End ExternalSource
WriteLiteral("        ")

WriteLiteral("<p>No really, we wrote 10 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",22)
    Case Else


#End ExternalSource
WriteLiteral("        ")

WriteLiteral("<p>We wrote a bunch more lines too!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",24)
End Select


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",26)
 For j as Integer = 1 to 10 Step 2


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>Hello again from VB.Net, #")


#ExternalSource("Blocks.vbhtml",27)
                              Write(j)


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",28)
Next j


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",30)
 Try


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>That time, we wrote 5 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",32)
Catch ex as Exception


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>Oh no! An error occurred: ")


#ExternalSource("Blocks.vbhtml",33)
                              Write(ex.Message)


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",34)
End Try


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",36)
 With i


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>i is now ")


#ExternalSource("Blocks.vbhtml",37)
             Write(.ToString())


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",38)
End With


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",40)
 SyncLock New Object()


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>This block is locked, for your security!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",42)
End SyncLock


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",44)
 Using New System.IO.MemoryStream()


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>Some random memory stream will be disposed after rendering this block</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Blocks.vbhtml",46)
End Using

#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/CodeBlock.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class CodeBlock
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("CodeBlock.vbhtml",1)
     
    Test()


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/CodeBlockAtEOF.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class CodeBlockAtEOF
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("CodeBlockAtEOF.vbhtml",1)
     

#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Comments.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class Comments
Public Overrides Sub Execute()


#ExternalSource("Comments.vbhtml",1)
 'This is not going to be rendered


#End ExternalSource
WriteLiteral("<p>This is going to be rendered</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))



#ExternalSource("Comments.vbhtml",3)
 REM Neither is this


#End ExternalSource


#ExternalSource("Comments.vbhtml",4)
 rem nor this


#End ExternalSource


#ExternalSource("Comments.vbhtml",5)
 rEm nor this

#End ExternalSource

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ConditionalAttributes.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ConditionalAttributes

#ExternalSource("ConditionalAttributes.vbhtml", 1)
Public Shared Function Link(ByVal url As String, text As String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("ConditionalAttributes.vbhtml", 1)
                                                  


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<a")

WriteAttributeTo(__razor_helper_writer, "href", Tuple.Create(" href=""", 59), Tuple.Create("""", 70) _
, Tuple.Create(Tuple.Create("", 66), Tuple.Create(Of System.Object, System.Int32)(url _
, 66), False) _
)

WriteLiteralTo(__razor_helper_writer, ">")


#ExternalSource("ConditionalAttributes.vbhtml", 2)
WriteTo(__razor_helper_writer, text)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</a> "&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ConditionalAttributes.vbhtml", 3)


#End ExternalSource
End Sub)
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(" "&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ConditionalAttributes.vbhtml",5)
     
    Dim ch = True
    Dim cls = "bar"


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<a")

WriteLiteral(" href=""Foo""")

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")

WriteLiteral("<p")

WriteAttribute("class", Tuple.Create(" class=""", 176), Tuple.Create("""", 188) _
, Tuple.Create(Tuple.Create("", 184), Tuple.Create(Of System.Object, System.Int32)(cls _
, 184), False) _
)

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")

WriteLiteral("<p")

WriteAttribute("class", Tuple.Create(" class=""", 201), Tuple.Create("""", 217) _
, Tuple.Create(Tuple.Create("", 209), Tuple.Create("foo", 209), True) _
, Tuple.Create(Tuple.Create(" ", 212), Tuple.Create(Of System.Object, System.Int32)(cls _
, 213), False) _
)

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")

WriteLiteral("<p")

WriteAttribute("class", Tuple.Create(" class=""", 230), Tuple.Create("""", 246) _
, Tuple.Create(Tuple.Create("", 238), Tuple.Create(Of System.Object, System.Int32)(cls _
, 238), False) _
, Tuple.Create(Tuple.Create(" ", 242), Tuple.Create("foo", 243), True) _
)

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")

WriteLiteral("<input")

WriteLiteral(" type=""checkbox""")

WriteAttribute("checked", Tuple.Create(" checked=""", 279), Tuple.Create("""", 292) _
, Tuple.Create(Tuple.Create("", 289), Tuple.Create(Of System.Object, System.Int32)(ch _
, 289), False) _
)

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")

WriteLiteral("<input")

WriteLiteral(" type=""checkbox""")

WriteAttribute("checked", Tuple.Create(" checked=""", 325), Tuple.Create("""", 342) _
, Tuple.Create(Tuple.Create("", 335), Tuple.Create("foo", 335), True) _
, Tuple.Create(Tuple.Create(" ", 338), Tuple.Create(Of System.Object, System.Int32)(ch _
, 339), False) _
)

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")

WriteLiteral("<p")

WriteAttribute("class", Tuple.Create(" class=""", 355), Tuple.Create("""", 401) _
, Tuple.Create(Tuple.Create("", 363), Tuple.Create(Of System.Object, System.Int32)(New Template(Sub (__razor_attribute_value_writer)


#ExternalSource("ConditionalAttributes.vbhtml",14)
                If cls IsNot Nothing Then 

#End ExternalSource

#ExternalSource("ConditionalAttributes.vbhtml",14)
   WriteTo(__razor_attribute_value_writer, cls)


#End ExternalSource

#ExternalSource("ConditionalAttributes.vbhtml",14)
                                               End If

#End ExternalSource
End Sub), 363), False) _
)

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")

WriteLiteral("<a")

WriteAttribute("href", Tuple.Create(" href=""", 414), Tuple.Create("""", 426) _
, Tuple.Create(Tuple.Create("", 421), Tuple.Create(Of System.Object, System.Int32)(Href("~/Foo") _
, 421), False) _
)

WriteLiteral(" />"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ConditionalAttributes.vbhtml",16)


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/DesignTime.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class DesignTime
Private Shared __o As Object

#ExternalSource("DesignTime.vbhtml", 9)
Public Shared Function Foo() As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("DesignTime.vbhtml", 10)
             
    If True Then
        

#End ExternalSource

#ExternalSource("DesignTime.vbhtml", 11)
                   
    End If


#End ExternalSource
End Sub)
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("DesignTime.vbhtml",1)
            For i = 1 to 10


#End ExternalSource

#ExternalSource("DesignTime.vbhtml",2)
             __o = i


#End ExternalSource

#ExternalSource("DesignTime.vbhtml",3)
                        
            Next


#End ExternalSource

#ExternalSource("DesignTime.vbhtml",4)
__o = Foo(Bar.Baz)


#End ExternalSource

#ExternalSource("DesignTime.vbhtml",5)
__o = Foo(Function (item) New Template(Sub (__razor_template_writer)


#End ExternalSource

#ExternalSource("DesignTime.vbhtml",6)
         __o = baz


#End ExternalSource

#ExternalSource("DesignTime.vbhtml",7)
                  End Sub))


#End ExternalSource
DefineSection("Footer", Sub ()


#ExternalSource("DesignTime.vbhtml",8)
__o = bar


#End ExternalSource
End Sub)

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/EmptyExplicitExpression.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class EmptyExplicitExpression
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("EmptyExplicitExpression.vbhtml",1)
__o = 


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/EmptyImplicitExpression.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class EmptyImplicitExpression
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("EmptyImplicitExpression.vbhtml",1)
__o = 


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/EmptyImplicitExpressionInCode.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class EmptyImplicitExpressionInCode
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("EmptyImplicitExpressionInCode.vbhtml",1)
     
    

#End ExternalSource

#ExternalSource("EmptyImplicitExpressionInCode.vbhtml",2)
__o = 


#End ExternalSource

#ExternalSource("EmptyImplicitExpressionInCode.vbhtml",3)
     


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/EmptySection.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class EmptySection
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
DefineSection("anything", Sub ()

WriteLiteral(" ")

End Sub)

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ExplicitExpression.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ExplicitExpression
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("ExplicitExpression.vbhtml",1)
Write(Foo(Bar.Baz))


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ExplicitExpressionAtEOF.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ExplicitExpressionAtEOF
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("ExplicitExpressionAtEOF.vbhtml",1)
__o = 


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ExpressionsInCode.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ExpressionsInCode
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("ExpressionsInCode.vbhtml",1)
     
    Dim foo As Object = Nothing
    Dim bar as String = "Foo"


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ExpressionsInCode.vbhtml",6)
 If foo IsNot Nothing Then
    

#End ExternalSource

#ExternalSource("ExpressionsInCode.vbhtml",7)
Write(foo)


#End ExternalSource

#ExternalSource("ExpressionsInCode.vbhtml",7)
        
Else


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>Foo is Null!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ExpressionsInCode.vbhtml",10)
End If


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ExpressionsInCode.vbhtml",13)
 If Not String.IsNullOrEmpty(bar) Then
    

#End ExternalSource

#ExternalSource("ExpressionsInCode.vbhtml",14)
Write(bar.Replace("F", "B"))


#End ExternalSource

#ExternalSource("ExpressionsInCode.vbhtml",14)
                            
End If


#End ExternalSource
WriteLiteral("</p>")

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/FunctionsBlock.DesignTime.Tabs.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class FunctionsBlock
Private Shared __o As Object

#ExternalSource("FunctionsBlock.vbhtml",1)
		  


#End ExternalSource

#ExternalSource("FunctionsBlock.vbhtml",2)
		  
    Private _rand as New Random()
    Private Function RandomInt() as Integer
        Return _rand.Next()
    End Function

#End ExternalSource

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("FunctionsBlock.vbhtml",3)
				   __o = RandomInt()


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/FunctionsBlock.DesignTime.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class FunctionsBlock
Private Shared __o As Object

#ExternalSource("FunctionsBlock.vbhtml",1)
          


#End ExternalSource

#ExternalSource("FunctionsBlock.vbhtml",2)
          
    Private _rand as New Random()
    Private Function RandomInt() as Integer
        Return _rand.Next()
    End Function

#End ExternalSource

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("FunctionsBlock.vbhtml",3)
                   __o = RandomInt()


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/FunctionsBlock.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class FunctionsBlock

#ExternalSource("FunctionsBlock.vbhtml",1)
          


#End ExternalSource

#ExternalSource("FunctionsBlock.vbhtml",5)
          
    Private _rand as New Random()
    Private Function RandomInt() as Integer
        Return _rand.Next()
    End Function

#End ExternalSource

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"Here's a random number: ")


#ExternalSource("FunctionsBlock.vbhtml",12)
                   Write(RandomInt())


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Helpers.Instance.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class Helpers

#ExternalSource("Helpers.vbhtml", 1)
Public Function Bold(s as String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("Helpers.vbhtml", 1)
                         
    s = s.ToUpper()


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<strong>")


#ExternalSource("Helpers.vbhtml", 3)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</strong>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Helpers.vbhtml", 4)


#End ExternalSource
End Sub)
End Function

#ExternalSource("Helpers.vbhtml", 6)
Public Function Italic(s as String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("Helpers.vbhtml", 6)
                           
    s = s.ToUpper()


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<em>")


#ExternalSource("Helpers.vbhtml", 8)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</em>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Helpers.vbhtml", 9)


#End ExternalSource
End Sub)
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Helpers.vbhtml",11)
Write(Bold("Hello"))


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Helpers.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class Helpers

#ExternalSource("Helpers.vbhtml", 1)
Public Shared Function Bold(s as String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("Helpers.vbhtml", 1)
                         
    s = s.ToUpper()


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<strong>")


#ExternalSource("Helpers.vbhtml", 3)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</strong>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Helpers.vbhtml", 4)


#End ExternalSource
End Sub)
End Function

#ExternalSource("Helpers.vbhtml", 6)
Public Shared Function Italic(s as String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("Helpers.vbhtml", 6)
                           
    s = s.ToUpper()


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<em>")


#ExternalSource("Helpers.vbhtml", 8)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</em>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Helpers.vbhtml", 9)


#End ExternalSource
End Sub)
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Helpers.vbhtml",11)
Write(Bold("Hello"))


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/HelpersMissingCloseParen.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class HelpersMissingCloseParen

#ExternalSource("HelpersMissingCloseParen.vbhtml", 1)
Public Shared Function Bold(s as String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("HelpersMissingCloseParen.vbhtml", 1)
                         
    s = s.ToUpper()


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<strong>")


#ExternalSource("HelpersMissingCloseParen.vbhtml", 3)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</strong>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("HelpersMissingCloseParen.vbhtml", 4)


#End ExternalSource
End Sub)
End Function

#ExternalSource("HelpersMissingCloseParen.vbhtml", 6)
Public Shared Function Italic(s as String

@Bold("Hello")
#End ExternalSource
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/HelpersMissingName.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class HelpersMissingName
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/HelpersMissingOpenParen.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class HelpersMissingOpenParen

#ExternalSource("HelpersMissingOpenParen.vbhtml", 1)
Public Shared Function Bold(s as String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("HelpersMissingOpenParen.vbhtml", 1)
                         
    s = s.ToUpper()


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<strong>")


#ExternalSource("HelpersMissingOpenParen.vbhtml", 3)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</strong>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("HelpersMissingOpenParen.vbhtml", 4)


#End ExternalSource
End Sub)
End Function

#ExternalSource("HelpersMissingOpenParen.vbhtml", 6)
Public Shared Function Italic
#End ExternalSource
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("HelpersMissingOpenParen.vbhtml",8)
Write(Bold("Hello"))


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ImplicitExpression.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ImplicitExpression
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("ImplicitExpression.vbhtml",1)
 For i = 1 To 10


#End ExternalSource
WriteLiteral("    ")

WriteLiteral("<p>This is item #")


#ExternalSource("ImplicitExpression.vbhtml",2)
                 Write(i)


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ImplicitExpression.vbhtml",3)
Next


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ImplicitExpression.vbhtml",5)
Write(SyntaxSampleHelpers.CodeForLink(Me))


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ImplicitExpressionAtEOF.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ImplicitExpressionAtEOF
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("ImplicitExpressionAtEOF.vbhtml",1)
__o = 


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Imports.DesignTime.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports Foo = System.Text.Encoding

Imports System
Imports System.IO


Namespace TestOutput
Public Class [Imports]
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("Imports.vbhtml",4)
                       __o = GetType(Path).FullName


#End ExternalSource

#ExternalSource("Imports.vbhtml",5)
                             __o = GetType(Foo).FullName


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Imports.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports Foo = System.Text.Encoding

Imports System
Imports System.IO


Namespace TestOutput
Public Class [Imports]
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<p>Path's full type name is ")


#ExternalSource("Imports.vbhtml",5)
                       Write(GetType(Path).FullName)


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<p>Foo's actual full type name is ")


#ExternalSource("Imports.vbhtml",6)
                             Write(GetType(Foo).FullName)


#End ExternalSource
WriteLiteral("</p>")

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Inherits.Designtime.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class [Inherits]
Inherits System.Web.WebPages.WebPage
Public Sub New()
MyBase.New
End Sub
Private Sub __RazorDesignTimeHelpers__()


#ExternalSource("Inherits.vbhtml",1)
Dim __inheritsHelper As System.Web.WebPages.WebPage = Nothing


#End ExternalSource

End Sub
Public Overrides Sub Execute()
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Inherits.Runtime.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class [Inherits]
Inherits System.Web.WebPages.WebPage
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Instrumented.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class Instrumented

#ExternalSource("Instrumented.vbhtml", 1)
Public Shared Function Strong(s As String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("Instrumented.vbhtml", 1)
                           


#End ExternalSource
BeginContext(__razor_helper_writer, "~/Instrumented.vbhtml", 29, 4, true)

WriteLiteralTo(__razor_helper_writer, "    ")

EndContext(__razor_helper_writer, "~/Instrumented.vbhtml", 29, 4, true)

BeginContext(__razor_helper_writer, "~/Instrumented.vbhtml", 34, 8, true)

WriteLiteralTo(__razor_helper_writer, "<strong>")

EndContext(__razor_helper_writer, "~/Instrumented.vbhtml", 34, 8, true)

BeginContext(__razor_helper_writer, "~/Instrumented.vbhtml", 43, 1, false)


#ExternalSource("Instrumented.vbhtml", 2)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
EndContext(__razor_helper_writer, "~/Instrumented.vbhtml", 43, 1, false)

BeginContext(__razor_helper_writer, "~/Instrumented.vbhtml", 44, 11, true)

WriteLiteralTo(__razor_helper_writer, "</strong>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext(__razor_helper_writer, "~/Instrumented.vbhtml", 44, 11, true)


#ExternalSource("Instrumented.vbhtml", 3)


#End ExternalSource
End Sub)
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
BeginContext("~/Instrumented.vbhtml", 65, 4, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 65, 4, true)


#ExternalSource("Instrumented.vbhtml",5)
     
    Dim i As Integer = 1
    Dim foo = 

#End ExternalSource
Function (item) New Template(Sub (__razor_template_writer)

BeginContext(__razor_template_writer, "~/Instrumented.vbhtml", 118, 12, true)

WriteLiteralTo(__razor_template_writer, "<p>Foo</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext(__razor_template_writer, "~/Instrumented.vbhtml", 118, 12, true)

BeginContext("~/Instrumented.vbhtml", 130, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 130, 4, true)

BeginContext("~/Instrumented.vbhtml", 136, 15, true)

WriteLiteral("Hello, World!"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 136, 15, true)

BeginContext("~/Instrumented.vbhtml", 151, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 151, 4, true)

BeginContext("~/Instrumented.vbhtml", 156, 22, true)

WriteLiteral("<p>Hello, World!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 156, 22, true)

End Sub)

#ExternalSource("Instrumented.vbhtml",10)


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 186, 4, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 186, 4, true)


#ExternalSource("Instrumented.vbhtml",12)
 While i <= 10


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 206, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 206, 4, true)

BeginContext("~/Instrumented.vbhtml", 211, 23, true)

WriteLiteral("<p>Hello from VB.Net, #")

EndContext("~/Instrumented.vbhtml", 211, 23, true)

BeginContext("~/Instrumented.vbhtml", 236, 1, false)


#ExternalSource("Instrumented.vbhtml",13)
                        Write(i)


#End ExternalSource
EndContext("~/Instrumented.vbhtml", 236, 1, false)

BeginContext("~/Instrumented.vbhtml", 238, 6, true)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 238, 6, true)


#ExternalSource("Instrumented.vbhtml",14)
    i += 1
End While


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 267, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 267, 2, true)


#ExternalSource("Instrumented.vbhtml",17)
 If i = 11 Then


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 286, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 286, 4, true)

BeginContext("~/Instrumented.vbhtml", 291, 27, true)

WriteLiteral("<p>We wrote 10 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 291, 27, true)


#ExternalSource("Instrumented.vbhtml",19)
End If


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 326, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 326, 2, true)


#ExternalSource("Instrumented.vbhtml",21)
 Do


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 333, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 333, 4, true)

BeginContext("~/Instrumented.vbhtml", 338, 16, true)

WriteLiteral("<p>Hello again: ")

EndContext("~/Instrumented.vbhtml", 338, 16, true)

BeginContext("~/Instrumented.vbhtml", 355, 1, false)


#ExternalSource("Instrumented.vbhtml",22)
                Write(i)


#End ExternalSource
EndContext("~/Instrumented.vbhtml", 355, 1, false)

BeginContext("~/Instrumented.vbhtml", 356, 6, true)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 356, 6, true)


#ExternalSource("Instrumented.vbhtml",23)
    i -= 1
Loop While i > 0


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 392, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 392, 2, true)


#ExternalSource("Instrumented.vbhtml",26)
 Select Case i
    Case 11


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 423, 8, true)

WriteLiteral("        ")

EndContext("~/Instrumented.vbhtml", 423, 8, true)

BeginContext("~/Instrumented.vbhtml", 432, 38, true)

WriteLiteral("<p>No really, we wrote 10 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 432, 38, true)


#ExternalSource("Instrumented.vbhtml",29)
    Case Else


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 485, 8, true)

WriteLiteral("        ")

EndContext("~/Instrumented.vbhtml", 485, 8, true)

BeginContext("~/Instrumented.vbhtml", 494, 41, true)

WriteLiteral("<p>We wrote a bunch more lines too!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 494, 41, true)


#ExternalSource("Instrumented.vbhtml",31)
End Select


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 547, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 547, 2, true)


#ExternalSource("Instrumented.vbhtml",33)
 For j as Integer = 1 to 10 Step 2


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 585, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 585, 4, true)

BeginContext("~/Instrumented.vbhtml", 590, 29, true)

WriteLiteral("<p>Hello again from VB.Net, #")

EndContext("~/Instrumented.vbhtml", 590, 29, true)

BeginContext("~/Instrumented.vbhtml", 621, 1, false)


#ExternalSource("Instrumented.vbhtml",34)
                              Write(j)


#End ExternalSource
EndContext("~/Instrumented.vbhtml", 621, 1, false)

BeginContext("~/Instrumented.vbhtml", 623, 6, true)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 623, 6, true)


#ExternalSource("Instrumented.vbhtml",35)
Next j


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 637, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 637, 2, true)


#ExternalSource("Instrumented.vbhtml",37)
 Try


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 645, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 645, 4, true)

BeginContext("~/Instrumented.vbhtml", 650, 37, true)

WriteLiteral("<p>That time, we wrote 5 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 650, 37, true)


#ExternalSource("Instrumented.vbhtml",39)
Catch ex as Exception


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 710, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 710, 4, true)

BeginContext("~/Instrumented.vbhtml", 715, 29, true)

WriteLiteral("<p>Oh no! An error occurred: ")

EndContext("~/Instrumented.vbhtml", 715, 29, true)

BeginContext("~/Instrumented.vbhtml", 746, 10, false)


#ExternalSource("Instrumented.vbhtml",40)
                              Write(ex.Message)


#End ExternalSource
EndContext("~/Instrumented.vbhtml", 746, 10, false)

BeginContext("~/Instrumented.vbhtml", 757, 6, true)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 757, 6, true)


#ExternalSource("Instrumented.vbhtml",41)
End Try


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 772, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 772, 2, true)


#ExternalSource("Instrumented.vbhtml",43)
 With i


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 783, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 783, 4, true)

BeginContext("~/Instrumented.vbhtml", 788, 12, true)

WriteLiteral("<p>i is now ")

EndContext("~/Instrumented.vbhtml", 788, 12, true)

BeginContext("~/Instrumented.vbhtml", 802, 11, false)


#ExternalSource("Instrumented.vbhtml",44)
             Write(.ToString())


#End ExternalSource
EndContext("~/Instrumented.vbhtml", 802, 11, false)

BeginContext("~/Instrumented.vbhtml", 814, 6, true)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 814, 6, true)


#ExternalSource("Instrumented.vbhtml",45)
End With


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 830, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 830, 2, true)


#ExternalSource("Instrumented.vbhtml",47)
 SyncLock New Object()


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 856, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 856, 4, true)

BeginContext("~/Instrumented.vbhtml", 861, 49, true)

WriteLiteral("<p>This block is locked, for your security!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 861, 49, true)


#ExternalSource("Instrumented.vbhtml",49)
End SyncLock


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 924, 2, true)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 924, 2, true)


#ExternalSource("Instrumented.vbhtml",51)
 Using New System.IO.MemoryStream()


#End ExternalSource
BeginContext("~/Instrumented.vbhtml", 963, 4, true)

WriteLiteral("    ")

EndContext("~/Instrumented.vbhtml", 963, 4, true)

BeginContext("~/Instrumented.vbhtml", 968, 78, true)

WriteLiteral("<p>Some random memory stream will be disposed after rendering this block</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

EndContext("~/Instrumented.vbhtml", 968, 78, true)


#ExternalSource("Instrumented.vbhtml",53)
End Using

#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/LayoutDirective.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class LayoutDirective
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
Layout = "~/Foo/Bar/Baz"
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/MarkupInCodeBlock.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class MarkupInCodeBlock
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("MarkupInCodeBlock.vbhtml",1)
     
    For i = 1 To 10


#End ExternalSource
WriteLiteral("        ")

WriteLiteral("<p>Hello from VB.Net, #")


#ExternalSource("MarkupInCodeBlock.vbhtml",3)
                            Write(i.ToString())


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("MarkupInCodeBlock.vbhtml",4)
    Next i


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/NestedCodeBlocks.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class NestedCodeBlocks
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("NestedCodeBlocks.vbhtml",1)
 If True Then
    

#End ExternalSource

#ExternalSource("NestedCodeBlocks.vbhtml",2)
     If True Then
    End If


#End ExternalSource

#ExternalSource("NestedCodeBlocks.vbhtml",4)
End If

#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/NestedHelpers.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class NestedHelpers

#ExternalSource("NestedHelpers.vbhtml", 3)
Public Shared Function Bold(s As String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("NestedHelpers.vbhtml", 3)
                             
        s = s.ToUpper()


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "        ")

WriteLiteralTo(__razor_helper_writer, "<strong>")


#ExternalSource("NestedHelpers.vbhtml", 5)
WriteTo(__razor_helper_writer, s)


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</strong>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("NestedHelpers.vbhtml", 6)
    

#End ExternalSource
End Sub)
End Function

#ExternalSource("NestedHelpers.vbhtml", 1)
Public Shared Function Italic(s As String) As Template

#End ExternalSource
Return New Template(Sub (__razor_helper_writer)

#ExternalSource("NestedHelpers.vbhtml", 1)
                           
    s = s.ToUpper()
    

#End ExternalSource

#ExternalSource("NestedHelpers.vbhtml", 6)
              


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "    ")

WriteLiteralTo(__razor_helper_writer, "<em>")


#ExternalSource("NestedHelpers.vbhtml", 7)
WriteTo(__razor_helper_writer, Bold(s))


#End ExternalSource
WriteLiteralTo(__razor_helper_writer, "</em>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("NestedHelpers.vbhtml", 8)


#End ExternalSource
End Sub)
End Function

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("NestedHelpers.vbhtml",10)
Write(Italic("Hello"))


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/NoLinePragmas.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class NoLinePragmas
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
     
    Dim i as Integer = 1

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 While i <= 10

WriteLiteral("    ")

WriteLiteral("<p>Hello from VB.Net, #")

                        Write(i)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

    i += 1
    'End While
End While

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 If i = 11 Then

WriteLiteral("    ")

WriteLiteral("<p>We wrote 10 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

    Dim s = "End If"
End If

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 Select Case i
    Case 11

WriteLiteral("        ")

WriteLiteral("<p>No really, we wrote 10 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

    Case Else

WriteLiteral("        ")

WriteLiteral("<p>Actually, we didn't...</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Select

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 For j as Integer = 1 to 10 Step 2

WriteLiteral("    ")

WriteLiteral("<p>Hello again from VB.Net, #")

                              Write(j)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

Next

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 Try

WriteLiteral("    ")

WriteLiteral("<p>That time, we wrote 5 lines!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

Catch ex as Exception

WriteLiteral("    ")

WriteLiteral("<p>Oh no! An error occurred: ")

                              Write(ex.Message)

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Try

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 With i

WriteLiteral("    ")

WriteLiteral("<p>i is now ")

             Write(.ToString())

WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End With

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 SyncLock New Object()

WriteLiteral("    ")

WriteLiteral("<p>This block is locked, for your security!</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End SyncLock

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

 Using New System.IO.MemoryStream()

WriteLiteral("    ")

WriteLiteral("<p>Some random memory stream will be disposed after rendering this block</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Using

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

Write(SyntaxSampleHelpers.CodeForLink(Me))

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Options.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict On
Option Explicit Off

Imports System

Namespace TestOutput
Public Class Options
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"Hello, World!")

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ParserError.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ParserError
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("ParserError.vbhtml",1)
     
Foo
'End Code

#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/RazorComments.DesignTime.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class RazorComments
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("RazorComments.vbhtml",1)
     
    

#End ExternalSource

#ExternalSource("RazorComments.vbhtml",2)
                                      


#End ExternalSource

#ExternalSource("RazorComments.vbhtml",3)
      Dim bar As String = "@* bar *@" 

#End ExternalSource

#ExternalSource("RazorComments.vbhtml",4)
                                       __o = bar


#End ExternalSource

#ExternalSource("RazorComments.vbhtml",5)
__o = a _

#End ExternalSource

#ExternalSource("RazorComments.vbhtml",6)
       b


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/RazorComments.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class RazorComments
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<p>This should ")

WriteLiteral(" be shown</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("RazorComments.vbhtml",4)
     
    

#End ExternalSource

#ExternalSource("RazorComments.vbhtml",5)
                                       


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("RazorComments.vbhtml",8)
      Dim bar As String = "@* bar *@" 

#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<p>But this should show the comment syntax: ")


#ExternalSource("RazorComments.vbhtml",9)
                                       Write(bar)


#End ExternalSource
WriteLiteral("</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<p>So should this: ")

WriteLiteral("@* bar *")

WriteLiteral("@</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("RazorComments.vbhtml",12)
Write(a _

#End ExternalSource

#ExternalSource("RazorComments.vbhtml",12)
       b)


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/ResolveUrl.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class ResolveUrl
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral("<a")

WriteAttribute("href", Tuple.Create(" href=""", 2), Tuple.Create("""", 14) _
, Tuple.Create(Tuple.Create("", 9), Tuple.Create(Of System.Object, System.Int32)(Href("~/Foo") _
, 9), False) _
)

WriteLiteral(">Foo</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<a")

WriteAttribute("href", Tuple.Create(" href=""", 27), Tuple.Create("""", 56) _
, Tuple.Create(Tuple.Create("", 34), Tuple.Create(Of System.Object, System.Int32)(Href("~/Products/") _
, 34), False) _
, Tuple.Create(Tuple.Create("", 45), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 45), False) _
)

WriteLiteral(">")


#ExternalSource("ResolveUrl.vbhtml",2)
                            Write(product.Name)


#End ExternalSource
WriteLiteral("</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<a")

WriteAttribute("href", Tuple.Create(" href=""", 79), Tuple.Create("""", 115) _
, Tuple.Create(Tuple.Create("", 86), Tuple.Create(Of System.Object, System.Int32)(Href("~/Products/") _
, 86), False) _
, Tuple.Create(Tuple.Create("", 97), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 97), False) _
, Tuple.Create(Tuple.Create("", 108), Tuple.Create("/Detail", 108), True) _
)

WriteLiteral(">Details</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<a")

WriteAttribute("href", Tuple.Create(" href=""", 132), Tuple.Create("""", 187) _
, Tuple.Create(Tuple.Create("", 139), Tuple.Create(Of System.Object, System.Int32)(Href("~/A+Really(Crazy),Url.Is:This/") _
, 139), False) _
, Tuple.Create(Tuple.Create("", 169), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 169), False) _
, Tuple.Create(Tuple.Create("", 180), Tuple.Create("/Detail", 180), True) _
)

WriteLiteral(">Crazy Url!</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ResolveUrl.vbhtml",6)
     


#End ExternalSource
WriteLiteral("    ")

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"        <a")

WriteAttribute("href", Tuple.Create(" href=""", 237), Tuple.Create("""", 249) _
, Tuple.Create(Tuple.Create("", 244), Tuple.Create(Of System.Object, System.Int32)(Href("~/Foo") _
, 244), False) _
)

WriteLiteral(">Foo</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"        <a")

WriteAttribute("href", Tuple.Create(" href=""", 270), Tuple.Create("""", 299) _
, Tuple.Create(Tuple.Create("", 277), Tuple.Create(Of System.Object, System.Int32)(Href("~/Products/") _
, 277), False) _
, Tuple.Create(Tuple.Create("", 288), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 288), False) _
)

WriteLiteral(">")


#ExternalSource("ResolveUrl.vbhtml",9)
                                    Write(product.Name)


#End ExternalSource
WriteLiteral("</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"        <a")

WriteAttribute("href", Tuple.Create(" href=""", 330), Tuple.Create("""", 366) _
, Tuple.Create(Tuple.Create("", 337), Tuple.Create(Of System.Object, System.Int32)(Href("~/Products/") _
, 337), False) _
, Tuple.Create(Tuple.Create("", 348), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 348), False) _
, Tuple.Create(Tuple.Create("", 359), Tuple.Create("/Detail", 359), True) _
)

WriteLiteral(">Details</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"        <a")

WriteAttribute("href", Tuple.Create(" href=""", 391), Tuple.Create("""", 446) _
, Tuple.Create(Tuple.Create("", 398), Tuple.Create(Of System.Object, System.Int32)(Href("~/A+Really(Crazy),Url.Is:This/") _
, 398), False) _
, Tuple.Create(Tuple.Create("", 428), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 428), False) _
, Tuple.Create(Tuple.Create("", 439), Tuple.Create("/Detail", 439), True) _
)

WriteLiteral(">Crazy Url!</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    ")

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("ResolveUrl.vbhtml",13)


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

DefineSection("Foo", Sub ()

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    <a")

WriteAttribute("href", Tuple.Create(" href=""", 509), Tuple.Create("""", 521) _
, Tuple.Create(Tuple.Create("", 516), Tuple.Create(Of System.Object, System.Int32)(Href("~/Foo") _
, 516), False) _
)

WriteLiteral(">Foo</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    <a")

WriteAttribute("href", Tuple.Create(" href=""", 538), Tuple.Create("""", 567) _
, Tuple.Create(Tuple.Create("", 545), Tuple.Create(Of System.Object, System.Int32)(Href("~/Products/") _
, 545), False) _
, Tuple.Create(Tuple.Create("", 556), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 556), False) _
)

WriteLiteral(">")


#ExternalSource("ResolveUrl.vbhtml",17)
                                Write(product.Name)


#End ExternalSource
WriteLiteral("</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    <a")

WriteAttribute("href", Tuple.Create(" href=""", 594), Tuple.Create("""", 630) _
, Tuple.Create(Tuple.Create("", 601), Tuple.Create(Of System.Object, System.Int32)(Href("~/Products/") _
, 601), False) _
, Tuple.Create(Tuple.Create("", 612), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 612), False) _
, Tuple.Create(Tuple.Create("", 623), Tuple.Create("/Detail", 623), True) _
)

WriteLiteral(">Details</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    <a")

WriteAttribute("href", Tuple.Create(" href=""", 651), Tuple.Create("""", 706) _
, Tuple.Create(Tuple.Create("", 658), Tuple.Create(Of System.Object, System.Int32)(Href("~/A+Really(Crazy),Url.Is:This/") _
, 658), False) _
, Tuple.Create(Tuple.Create("", 688), Tuple.Create(Of System.Object, System.Int32)(product.id _
, 688), False) _
, Tuple.Create(Tuple.Create("", 699), Tuple.Create("/Detail", 699), True) _
)

WriteLiteral(">Crazy Url!</a>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Sub)

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Sections.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class Sections
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("Sections.vbhtml",1)
     
    Layout = "_SectionTestLayout.vbhtml"


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<div>This is in the Body>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

DefineSection("Section2", Sub ()

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    <div>This is in Section 2</div>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Sub)

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

DefineSection("Section1", Sub ()

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    <div>This is in Section 1</div>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

End Sub)

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/Templates.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System
Imports System.Web.Helpers


Namespace TestOutput
Public Class Templates

#ExternalSource("Templates.vbhtml",3)
          
    Public Function Repeat(times As Integer, template As Func(Of Integer, object)) As HelperResult
        Return New HelperResult(Sub(writer)
            For i = 0 to times
                DirectCast(template(i), HelperResult).WriteTo(writer)
            Next i
        End Sub)
    End Function

#End ExternalSource

Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Templates.vbhtml",13)
     
    Dim foo As Func(Of Object, Object) =

#End ExternalSource
WriteLiteral(" ")

WriteLiteral("This works ")


#ExternalSource("Templates.vbhtml",14)
                                                      Write(item)


#End ExternalSource
WriteLiteral("!")

WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Templates.vbhtml",15)
    

#End ExternalSource

#ExternalSource("Templates.vbhtml",15)
Write(foo("too"))


#End ExternalSource

#ExternalSource("Templates.vbhtml",15)
               


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<ul>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Templates.vbhtml",19)
Write(Repeat(10, Function (item) New Template(Sub (__razor_template_writer)


#End ExternalSource
WriteLiteralTo(__razor_template_writer, "<li>Item #")


#ExternalSource("Templates.vbhtml",19)
WriteTo(__razor_template_writer, item)


#End ExternalSource
WriteLiteralTo(__razor_template_writer, "</li>")


#ExternalSource("Templates.vbhtml",19)
                           End Sub)))


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"</ul>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Templates.vbhtml",23)
Write(Repeat(10,
    Function (item) New Template(Sub (__razor_template_writer)


#End ExternalSource
WriteLiteralTo(__razor_template_writer, " This is line#")


#ExternalSource("Templates.vbhtml",24)
WriteTo(__razor_template_writer, item)


#End ExternalSource
WriteLiteralTo(__razor_template_writer, " of markup<br/>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Templates.vbhtml",25)
End Sub)))


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"</p>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"<ul>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))

WriteLiteral("    ")


#ExternalSource("Templates.vbhtml",29)
Write(Repeat(10, Function (item) New Template(Sub (__razor_template_writer)


#End ExternalSource
WriteLiteralTo(__razor_template_writer, "<li>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"        Item #")


#ExternalSource("Templates.vbhtml",30)
WriteTo(__razor_template_writer, item)


#End ExternalSource
WriteLiteralTo(__razor_template_writer, ""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10))


#ExternalSource("Templates.vbhtml",31)
        

#End ExternalSource

#ExternalSource("Templates.vbhtml",31)
              Dim parent = item 

#End ExternalSource
WriteLiteralTo(__razor_template_writer, ""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"        <ul>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"            <li>Child Items... ?</li>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"        </ul>"&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"    </li>")


#ExternalSource("Templates.vbhtml",35)
 End Sub)))


#End ExternalSource
WriteLiteral(""&Global.Microsoft.VisualBasic.ChrW(13)&Global.Microsoft.VisualBasic.ChrW(10)&"</ul>")

End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Output/UnfinishedExpressionInCode.vb
================================================
'------------------------------------------------------------------------------
' <auto-generated>
'     This code was generated by a tool.
'     Runtime Version:N.N.NNNNN.N
'
'     Changes to this file may cause incorrect behavior and will be lost if
'     the code is regenerated.
' </auto-generated>
'------------------------------------------------------------------------------

Option Strict Off
Option Explicit On

Imports System

Namespace TestOutput
Public Class UnfinishedExpressionInCode
Private Shared __o As Object
Public Sub New()
MyBase.New
End Sub
Public Overrides Sub Execute()

#ExternalSource("UnfinishedExpressionInCode.vbhtml",1)
     


#End ExternalSource

#ExternalSource("UnfinishedExpressionInCode.vbhtml",2)
__o = DateTime.


#End ExternalSource

#ExternalSource("UnfinishedExpressionInCode.vbhtml",3)
          


#End ExternalSource
End Sub
End Class
End Namespace


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Blocks.vbhtml
================================================
@Code
    Dim i as Integer = 1
End Code

@While i <= 10
    @<p>Hello from VB.Net, #@(i)</p>
    i += 1
End While

@If i = 11 Then
    @<p>We wrote 10 lines!</p>
End If

@Do
    @<p>Hello again: @i</p>
    i -= 1
Loop While i > 0

@Select Case i
    Case 11
        @<p>No really, we wrote 10 lines!</p>
    Case Else
        @<p>We wrote a bunch more lines too!</p>
End Select

@For j as Integer = 1 to 10 Step 2
    @<p>Hello again from VB.Net, #@(j)</p>
Next j

@Try
    @<p>That time, we wrote 5 lines!</p>
Catch ex as Exception
    @<p>Oh no! An error occurred: @(ex.Message)</p>
End Try

@With i
    @<p>i is now @(.ToString())</p>
End With

@SyncLock New Object()
    @<p>This block is locked, for your security!</p>
End SyncLock

@Using New System.IO.MemoryStream()
    @<p>Some random memory stream will be disposed after rendering this block</p>
End Using

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/CodeBlock.vbhtml
================================================
@Code
    Test()
End Code

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/CodeBlockAtEOF.vbhtml
================================================
This is markup

@Code

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ConditionalAttributes.vbhtml
================================================
@Helper Link(ByVal url As String, text As String) 
    @<a href="@url">@text</a> 
End Helper 

@Code
    Dim ch = True
    Dim cls = "bar"
    @<a href="Foo" />
    @<p class="@cls" />
    @<p class="foo @cls" />
    @<p class="@cls foo" />
    @<input type="checkbox" checked="@ch" />
    @<input type="checkbox" checked="foo @ch" />
    @<p class="@If cls IsNot Nothing Then @cls End If" />
    @<a href="~/Foo" />
End Code

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/DesignTime.vbhtml
================================================
<div>
            @For i = 1 to 10
@<p>This is item #@i</p>
            Next
</div>

<p>
@(Foo(Bar.Baz))
@Foo(@@<p>Bar @baz Biz</p>)
</p>

@Section Footer
    <p>Foo</p>
    @bar
End Section

@Helper Foo()
    If True Then
        @<p>Foo</p>
    End If
End Helper

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/EmptyExplicitExpression.vbhtml
================================================
This is markup

@()

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/EmptyImplicitExpression.vbhtml
================================================
This is markup

@!

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/EmptyImplicitExpressionInCode.vbhtml
================================================
@Code
    @
End Code

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/EmptySection.vbhtml
================================================
@section anything End

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ExplicitExpression.vbhtml
================================================
@(Foo(Bar.Baz))

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ExplicitExpressionAtEOF.vbhtml
================================================
This is markup

@(

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ExpressionsInCode.vbhtml
================================================
@Code
    Dim foo As Object = Nothing
    Dim bar as String = "Foo"
End Code

@If foo IsNot Nothing Then
    @foo
Else
    @<p>Foo is Null!</p>
End If

<p>
@If Not String.IsNullOrEmpty(bar) Then
    @(bar.Replace("F", "B"))
End If
</p>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/FunctionsBlock.vbhtml
================================================
@Functions

End Functions

@Functions
    Private _rand as New Random()
    Private Function RandomInt() as Integer
        Return _rand.Next()
    End Function
End Functions

Here's a random number: @RandomInt()

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Helpers.vbhtml
================================================
@Helper Bold(s as String)
    s = s.ToUpper()
    @<strong>@s</strong>
End Helper

@Helper Italic(s as String)
    s = s.ToUpper()
    @<em>@s</em>
End Helper

@Bold("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/HelpersMissingCloseParen.vbhtml
================================================
@Helper Bold(s as String)
    s = s.ToUpper()
    @<strong>@s</strong>
End Helper

@Helper Italic(s as String

@Bold("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/HelpersMissingName.vbhtml
================================================
@Helper

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/HelpersMissingOpenParen.vbhtml
================================================
@Helper Bold(s as String)
    s = s.ToUpper()
    @<strong>@s</strong>
End Helper

@Helper Italic

@Bold("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ImplicitExpression.vbhtml
================================================
@For i = 1 To 10
    @<p>This is item #@i</p>
Next

@SyntaxSampleHelpers.CodeForLink(Me)

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ImplicitExpressionAtEOF.vbhtml
================================================
This is markup

@

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Imports.vbhtml
================================================
@Imports System.IO
@Imports Foo = System.Text.Encoding
@Imports System

<p>Path's full type name is @GetType(Path).FullName</p>
<p>Foo's actual full type name is @GetType(Foo).FullName</p>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Inherits.vbhtml
================================================
@Inherits System.Web.WebPages.WebPage


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Instrumented.vbhtml
================================================
@Helper Strong(s As String)
    @<strong>@s</strong>
End Helper

@Code
    Dim i As Integer = 1
    Dim foo = @@<p>Foo</p>
    @:Hello, World!
    @<p>Hello, World!</p>
End Code

@While i <= 10
    @<p>Hello from VB.Net, #@(i)</p>
    i += 1
End While

@If i = 11 Then
    @<p>We wrote 10 lines!</p>
End If

@Do
    @<p>Hello again: @i</p>
    i -= 1
Loop While i > 0

@Select Case i
    Case 11
        @<p>No really, we wrote 10 lines!</p>
    Case Else
        @<p>We wrote a bunch more lines too!</p>
End Select

@For j as Integer = 1 to 10 Step 2
    @<p>Hello again from VB.Net, #@(j)</p>
Next j

@Try
    @<p>That time, we wrote 5 lines!</p>
Catch ex as Exception
    @<p>Oh no! An error occurred: @(ex.Message)</p>
End Try

@With i
    @<p>i is now @(.ToString())</p>
End With

@SyncLock New Object()
    @<p>This block is locked, for your security!</p>
End SyncLock

@Using New System.IO.MemoryStream()
    @<p>Some random memory stream will be disposed after rendering this block</p>
End Using

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/LayoutDirective.vbhtml
================================================
@Layout ~/Foo/Bar/Baz

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/MarkupInCodeBlock.vbhtml
================================================
@Code
    For i = 1 To 10
        @<p>Hello from VB.Net, #@(i.ToString())</p>
    Next i
End Code


================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/NestedCodeBlocks.vbhtml
================================================
@If True Then
    @If True Then
    End If
End If

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/NestedHelpers.vbhtml
================================================
@Helper Italic(s As String)
    s = s.ToUpper()
    @Helper Bold(s As String)
        s = s.ToUpper()
        @<strong>@s</strong>
    End Helper
    @<em>@Bold(s)</em>
End Helper

@Italic("Hello")

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/NoLinePragmas.vbhtml
================================================
@Code
    Dim i as Integer = 1
End Code

@While i <= 10
    @<p>Hello from VB.Net, #@(i)</p>
    i += 1
    'End While
End While

@If i = 11 Then
    @<p>We wrote 10 lines!</p>
    Dim s = "End If"
End If

@Select Case i
    Case 11
        @<p>No really, we wrote 10 lines!</p>
    Case Else
        @<p>Actually, we didn't...</p>
End Select

@For j as Integer = 1 to 10 Step 2
    @<p>Hello again from VB.Net, #@(j)</p>
Next

@Try
    @<p>That time, we wrote 5 lines!</p>
Catch ex as Exception
    @<p>Oh no! An error occurred: @(ex.Message)</p>
End Try

@With i
    @<p>i is now @(.ToString())</p>
End With

@SyncLock New Object()
    @<p>This block is locked, for your security!</p>
End SyncLock

@Using New System.IO.MemoryStream()
    @<p>Some random memory stream will be disposed after rendering this block</p>
End Using

@SyntaxSampleHelpers.CodeForLink(Me)

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Options.vbhtml
================================================
@Option Strict On
@Option Explicit Off

Hello, World!

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ParserError.vbhtml
================================================
@Code
Foo
'End Code

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/RazorComments.vbhtml
================================================
@*This is not going to be rendered*@
<p>This should @* not *@ be shown</p>

@Code
    @* Throw new Exception("Oh no!") *@
End Code

@Code Dim bar As String = "@* bar *@" End Code
<p>But this should show the comment syntax: @bar</p>
<p>So should this: @@* bar *@@</p>

@(a@**@b)

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/ResolveUrl.vbhtml
================================================
<a href="~/Foo">Foo</a>
<a href="~/Products/@product.id">@product.Name</a>
<a href="~/Products/@product.id/Detail">Details</a>
<a href="~/A+Really(Crazy),Url.Is:This/@product.id/Detail">Crazy Url!</a>

@Code
    @<text>
        <a href="~/Foo">Foo</a>
        <a href="~/Products/@product.id">@product.Name</a>
        <a href="~/Products/@product.id/Detail">Details</a>
        <a href="~/A+Really(Crazy),Url.Is:This/@product.id/Detail">Crazy Url!</a>
    </text>
End Code

@Section Foo
    <a href="~/Foo">Foo</a>
    <a href="~/Products/@product.id">@product.Name</a>
    <a href="~/Products/@product.id/Detail">Details</a>
    <a href="~/A+Really(Crazy),Url.Is:This/@product.id/Detail">Crazy Url!</a>
End Section

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Sections.vbhtml
================================================
@Code
    Layout = "_SectionTestLayout.vbhtml"
End Code

<div>This is in the Body>

@Section Section2
    <div>This is in Section 2</div>
End Section

@Section Section1
    <div>This is in Section 1</div>
End Section

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/Templates.vbhtml
================================================
@Imports System.Web.Helpers

@Functions
    Public Function Repeat(times As Integer, template As Func(Of Integer, object)) As HelperResult
        Return New HelperResult(Sub(writer)
            For i = 0 to times
                DirectCast(template(i), HelperResult).WriteTo(writer)
            Next i
        End Sub)
    End Function
End Functions

@Code
    Dim foo As Func(Of Object, Object) = @<text>This works @item!</text>
    @foo("too")
End Code

<ul>
@(Repeat(10, @@<li>Item #@item</li>))
</ul>

<p>
@Repeat(10,
    @@: This is line#@item of markup<br/>
)
</p>

<ul>
    @Repeat(10, @@<li>
        Item #@item
        @Code Dim parent = item End Code
        <ul>
            <li>Child Items... ?</li>
        </ul>
    </li>)
</ul>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/CodeGenerator/VB/Source/UnfinishedExpressionInCode.vbhtml
================================================
@Code
@DateTime.
End Code

================================================
FILE: test/System.Web.Razor.Test/TestFiles/DesignTime/Simple.cshtml
================================================
@{
    string hello = "Hello, World";
}

<html>
    <head>
        <title>Simple Page</title>
    </head>
    <body>
        <h1>Simple Page</h1>
        <p>@hello</p>
        <p>
            @foreach(char c in hello) {@c}
        </p>
    </body>
</html>

================================================
FILE: test/System.Web.Razor.Test/TestFiles/DesignTime/Simple.txt
================================================
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:N.N.NNNNN.N
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Razor {
    
    
    public class @__CompiledTemplate {
        
        private static object @__o;
        
#line hidden
        
        public @__CompiledTemplate() {
        }
        
        public override void Execute() {
            
            #line 1 "C:\This\Path\Is\Just\For\Line\Pragmas.cshtml"
  
    string hello = "Hello, World";

            
            #line default
            #line hidden
            
            #line 2 "C:\This\Path\Is\Just\For\Line\Pragmas.cshtml"
      __o = hello;

            
            #line default
            #line hidden
            
            #line 3 "C:\This\Path\Is\Just\For\Line\Pragmas.cshtml"
            foreach(char c in hello) {
            
            #line default
            #line hidden
            
            #line 4 "C:\This\Path\Is\Just\For\Line\Pragmas.cshtml"
                                  __o = c;

            
            #line default
            #line hidden
            
            #line 5 "C:\This\Path\Is\Just\For\Line\Pragmas.cshtml"
                                         }
            
            #line default
            #line hidden
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/TestFiles/nested-1000.html
================================================
<outer>
<elem-1>
<elem-2>
<elem-3>
<elem-4>
<elem-5>
<elem-6>
<elem-7>
<elem-8>
<elem-9>
<elem-10>
<elem-11>
<elem-12>
<elem-13>
<elem-14>
<elem-15>
<elem-16>
<elem-17>
<elem-18>
<elem-19>
<elem-20>
<elem-21>
<elem-22>
<elem-23>
<elem-24>
<elem-25>
<elem-26>
<elem-27>
<elem-28>
<elem-29>
<elem-30>
<elem-31>
<elem-32>
<elem-33>
<elem-34>
<elem-35>
<elem-36>
<elem-37>
<elem-38>
<elem-39>
<elem-40>
<elem-41>
<elem-42>
<elem-43>
<elem-44>
<elem-45>
<elem-46>
<elem-47>
<elem-48>
<elem-49>
<elem-50>
<elem-51>
<elem-52>
<elem-53>
<elem-54>
<elem-55>
<elem-56>
<elem-57>
<elem-58>
<elem-59>
<elem-60>
<elem-61>
<elem-62>
<elem-63>
<elem-64>
<elem-65>
<elem-66>
<elem-67>
<elem-68>
<elem-69>
<elem-70>
<elem-71>
<elem-72>
<elem-73>
<elem-74>
<elem-75>
<elem-76>
<elem-77>
<elem-78>
<elem-79>
<elem-80>
<elem-81>
<elem-82>
<elem-83>
<elem-84>
<elem-85>
<elem-86>
<elem-87>
<elem-88>
<elem-89>
<elem-90>
<elem-91>
<elem-92>
<elem-93>
<elem-94>
<elem-95>
<elem-96>
<elem-97>
<elem-98>
<elem-99>
<elem-100>
<elem-101>
<elem-102>
<elem-103>
<elem-104>
<elem-105>
<elem-106>
<elem-107>
<elem-108>
<elem-109>
<elem-110>
<elem-111>
<elem-112>
<elem-113>
<elem-114>
<elem-115>
<elem-116>
<elem-117>
<elem-118>
<elem-119>
<elem-120>
<elem-121>
<elem-122>
<elem-123>
<elem-124>
<elem-125>
<elem-126>
<elem-127>
<elem-128>
<elem-129>
<elem-130>
<elem-131>
<elem-132>
<elem-133>
<elem-134>
<elem-135>
<elem-136>
<elem-137>
<elem-138>
<elem-139>
<elem-140>
<elem-141>
<elem-142>
<elem-143>
<elem-144>
<elem-145>
<elem-146>
<elem-147>
<elem-148>
<elem-149>
<elem-150>
<elem-151>
<elem-152>
<elem-153>
<elem-154>
<elem-155>
<elem-156>
<elem-157>
<elem-158>
<elem-159>
<elem-160>
<elem-161>
<elem-162>
<elem-163>
<elem-164>
<elem-165>
<elem-166>
<elem-167>
<elem-168>
<elem-169>
<elem-170>
<elem-171>
<elem-172>
<elem-173>
<elem-174>
<elem-175>
<elem-176>
<elem-177>
<elem-178>
<elem-179>
<elem-180>
<elem-181>
<elem-182>
<elem-183>
<elem-184>
<elem-185>
<elem-186>
<elem-187>
<elem-188>
<elem-189>
<elem-190>
<elem-191>
<elem-192>
<elem-193>
<elem-194>
<elem-195>
<elem-196>
<elem-197>
<elem-198>
<elem-199>
<elem-200>
<elem-201>
<elem-202>
<elem-203>
<elem-204>
<elem-205>
<elem-206>
<elem-207>
<elem-208>
<elem-209>
<elem-210>
<elem-211>
<elem-212>
<elem-213>
<elem-214>
<elem-215>
<elem-216>
<elem-217>
<elem-218>
<elem-219>
<elem-220>
<elem-221>
<elem-222>
<elem-223>
<elem-224>
<elem-225>
<elem-226>
<elem-227>
<elem-228>
<elem-229>
<elem-230>
<elem-231>
<elem-232>
<elem-233>
<elem-234>
<elem-235>
<elem-236>
<elem-237>
<elem-238>
<elem-239>
<elem-240>
<elem-241>
<elem-242>
<elem-243>
<elem-244>
<elem-245>
<elem-246>
<elem-247>
<elem-248>
<elem-249>
<elem-250>
<elem-251>
<elem-252>
<elem-253>
<elem-254>
<elem-255>
<elem-256>
<elem-257>
<elem-258>
<elem-259>
<elem-260>
<elem-261>
<elem-262>
<elem-263>
<elem-264>
<elem-265>
<elem-266>
<elem-267>
<elem-268>
<elem-269>
<elem-270>
<elem-271>
<elem-272>
<elem-273>
<elem-274>
<elem-275>
<elem-276>
<elem-277>
<elem-278>
<elem-279>
<elem-280>
<elem-281>
<elem-282>
<elem-283>
<elem-284>
<elem-285>
<elem-286>
<elem-287>
<elem-288>
<elem-289>
<elem-290>
<elem-291>
<elem-292>
<elem-293>
<elem-294>
<elem-295>
<elem-296>
<elem-297>
<elem-298>
<elem-299>
<elem-300>
<elem-301>
<elem-302>
<elem-303>
<elem-304>
<elem-305>
<elem-306>
<elem-307>
<elem-308>
<elem-309>
<elem-310>
<elem-311>
<elem-312>
<elem-313>
<elem-314>
<elem-315>
<elem-316>
<elem-317>
<elem-318>
<elem-319>
<elem-320>
<elem-321>
<elem-322>
<elem-323>
<elem-324>
<elem-325>
<elem-326>
<elem-327>
<elem-328>
<elem-329>
<elem-330>
<elem-331>
<elem-332>
<elem-333>
<elem-334>
<elem-335>
<elem-336>
<elem-337>
<elem-338>
<elem-339>
<elem-340>
<elem-341>
<elem-342>
<elem-343>
<elem-344>
<elem-345>
<elem-346>
<elem-347>
<elem-348>
<elem-349>
<elem-350>
<elem-351>
<elem-352>
<elem-353>
<elem-354>
<elem-355>
<elem-356>
<elem-357>
<elem-358>
<elem-359>
<elem-360>
<elem-361>
<elem-362>
<elem-363>
<elem-364>
<elem-365>
<elem-366>
<elem-367>
<elem-368>
<elem-369>
<elem-370>
<elem-371>
<elem-372>
<elem-373>
<elem-374>
<elem-375>
<elem-376>
<elem-377>
<elem-378>
<elem-379>
<elem-380>
<elem-381>
<elem-382>
<elem-383>
<elem-384>
<elem-385>
<elem-386>
<elem-387>
<elem-388>
<elem-389>
<elem-390>
<elem-391>
<elem-392>
<elem-393>
<elem-394>
<elem-395>
<elem-396>
<elem-397>
<elem-398>
<elem-399>
<elem-400>
<elem-401>
<elem-402>
<elem-403>
<elem-404>
<elem-405>
<elem-406>
<elem-407>
<elem-408>
<elem-409>
<elem-410>
<elem-411>
<elem-412>
<elem-413>
<elem-414>
<elem-415>
<elem-416>
<elem-417>
<elem-418>
<elem-419>
<elem-420>
<elem-421>
<elem-422>
<elem-423>
<elem-424>
<elem-425>
<elem-426>
<elem-427>
<elem-428>
<elem-429>
<elem-430>
<elem-431>
<elem-432>
<elem-433>
<elem-434>
<elem-435>
<elem-436>
<elem-437>
<elem-438>
<elem-439>
<elem-440>
<elem-441>
<elem-442>
<elem-443>
<elem-444>
<elem-445>
<elem-446>
<elem-447>
<elem-448>
<elem-449>
<elem-450>
<elem-451>
<elem-452>
<elem-453>
<elem-454>
<elem-455>
<elem-456>
<elem-457>
<elem-458>
<elem-459>
<elem-460>
<elem-461>
<elem-462>
<elem-463>
<elem-464>
<elem-465>
<elem-466>
<elem-467>
<elem-468>
<elem-469>
<elem-470>
<elem-471>
<elem-472>
<elem-473>
<elem-474>
<elem-475>
<elem-476>
<elem-477>
<elem-478>
<elem-479>
<elem-480>
<elem-481>
<elem-482>
<elem-483>
<elem-484>
<elem-485>
<elem-486>
<elem-487>
<elem-488>
<elem-489>
<elem-490>
<elem-491>
<elem-492>
<elem-493>
<elem-494>
<elem-495>
<elem-496>
<elem-497>
<elem-498>
<elem-499>
<elem-500>
<elem-501>
<elem-502>
<elem-503>
<elem-504>
<elem-505>
<elem-506>
<elem-507>
<elem-508>
<elem-509>
<elem-510>
<elem-511>
<elem-512>
<elem-513>
<elem-514>
<elem-515>
<elem-516>
<elem-517>
<elem-518>
<elem-519>
<elem-520>
<elem-521>
<elem-522>
<elem-523>
<elem-524>
<elem-525>
<elem-526>
<elem-527>
<elem-528>
<elem-529>
<elem-530>
<elem-531>
<elem-532>
<elem-533>
<elem-534>
<elem-535>
<elem-536>
<elem-537>
<elem-538>
<elem-539>
<elem-540>
<elem-541>
<elem-542>
<elem-543>
<elem-544>
<elem-545>
<elem-546>
<elem-547>
<elem-548>
<elem-549>
<elem-550>
<elem-551>
<elem-552>
<elem-553>
<elem-554>
<elem-555>
<elem-556>
<elem-557>
<elem-558>
<elem-559>
<elem-560>
<elem-561>
<elem-562>
<elem-563>
<elem-564>
<elem-565>
<elem-566>
<elem-567>
<elem-568>
<elem-569>
<elem-570>
<elem-571>
<elem-572>
<elem-573>
<elem-574>
<elem-575>
<elem-576>
<elem-577>
<elem-578>
<elem-579>
<elem-580>
<elem-581>
<elem-582>
<elem-583>
<elem-584>
<elem-585>
<elem-586>
<elem-587>
<elem-588>
<elem-589>
<elem-590>
<elem-591>
<elem-592>
<elem-593>
<elem-594>
<elem-595>
<elem-596>
<elem-597>
<elem-598>
<elem-599>
<elem-600>
<elem-601>
<elem-602>
<elem-603>
<elem-604>
<elem-605>
<elem-606>
<elem-607>
<elem-608>
<elem-609>
<elem-610>
<elem-611>
<elem-612>
<elem-613>
<elem-614>
<elem-615>
<elem-616>
<elem-617>
<elem-618>
<elem-619>
<elem-620>
<elem-621>
<elem-622>
<elem-623>
<elem-624>
<elem-625>
<elem-626>
<elem-627>
<elem-628>
<elem-629>
<elem-630>
<elem-631>
<elem-632>
<elem-633>
<elem-634>
<elem-635>
<elem-636>
<elem-637>
<elem-638>
<elem-639>
<elem-640>
<elem-641>
<elem-642>
<elem-643>
<elem-644>
<elem-645>
<elem-646>
<elem-647>
<elem-648>
<elem-649>
<elem-650>
<elem-651>
<elem-652>
<elem-653>
<elem-654>
<elem-655>
<elem-656>
<elem-657>
<elem-658>
<elem-659>
<elem-660>
<elem-661>
<elem-662>
<elem-663>
<elem-664>
<elem-665>
<elem-666>
<elem-667>
<elem-668>
<elem-669>
<elem-670>
<elem-671>
<elem-672>
<elem-673>
<elem-674>
<elem-675>
<elem-676>
<elem-677>
<elem-678>
<elem-679>
<elem-680>
<elem-681>
<elem-682>
<elem-683>
<elem-684>
<elem-685>
<elem-686>
<elem-687>
<elem-688>
<elem-689>
<elem-690>
<elem-691>
<elem-692>
<elem-693>
<elem-694>
<elem-695>
<elem-696>
<elem-697>
<elem-698>
<elem-699>
<elem-700>
<elem-701>
<elem-702>
<elem-703>
<elem-704>
<elem-705>
<elem-706>
<elem-707>
<elem-708>
<elem-709>
<elem-710>
<elem-711>
<elem-712>
<elem-713>
<elem-714>
<elem-715>
<elem-716>
<elem-717>
<elem-718>
<elem-719>
<elem-720>
<elem-721>
<elem-722>
<elem-723>
<elem-724>
<elem-725>
<elem-726>
<elem-727>
<elem-728>
<elem-729>
<elem-730>
<elem-731>
<elem-732>
<elem-733>
<elem-734>
<elem-735>
<elem-736>
<elem-737>
<elem-738>
<elem-739>
<elem-740>
<elem-741>
<elem-742>
<elem-743>
<elem-744>
<elem-745>
<elem-746>
<elem-747>
<elem-748>
<elem-749>
<elem-750>
<elem-751>
<elem-752>
<elem-753>
<elem-754>
<elem-755>
<elem-756>
<elem-757>
<elem-758>
<elem-759>
<elem-760>
<elem-761>
<elem-762>
<elem-763>
<elem-764>
<elem-765>
<elem-766>
<elem-767>
<elem-768>
<elem-769>
<elem-770>
<elem-771>
<elem-772>
<elem-773>
<elem-774>
<elem-775>
<elem-776>
<elem-777>
<elem-778>
<elem-779>
<elem-780>
<elem-781>
<elem-782>
<elem-783>
<elem-784>
<elem-785>
<elem-786>
<elem-787>
<elem-788>
<elem-789>
<elem-790>
<elem-791>
<elem-792>
<elem-793>
<elem-794>
<elem-795>
<elem-796>
<elem-797>
<elem-798>
<elem-799>
<elem-800>
<elem-801>
<elem-802>
<elem-803>
<elem-804>
<elem-805>
<elem-806>
<elem-807>
<elem-808>
<elem-809>
<elem-810>
<elem-811>
<elem-812>
<elem-813>
<elem-814>
<elem-815>
<elem-816>
<elem-817>
<elem-818>
<elem-819>
<elem-820>
<elem-821>
<elem-822>
<elem-823>
<elem-824>
<elem-825>
<elem-826>
<elem-827>
<elem-828>
<elem-829>
<elem-830>
<elem-831>
<elem-832>
<elem-833>
<elem-834>
<elem-835>
<elem-836>
<elem-837>
<elem-838>
<elem-839>
<elem-840>
<elem-841>
<elem-842>
<elem-843>
<elem-844>
<elem-845>
<elem-846>
<elem-847>
<elem-848>
<elem-849>
<elem-850>
<elem-851>
<elem-852>
<elem-853>
<elem-854>
<elem-855>
<elem-856>
<elem-857>
<elem-858>
<elem-859>
<elem-860>
<elem-861>
<elem-862>
<elem-863>
<elem-864>
<elem-865>
<elem-866>
<elem-867>
<elem-868>
<elem-869>
<elem-870>
<elem-871>
<elem-872>
<elem-873>
<elem-874>
<elem-875>
<elem-876>
<elem-877>
<elem-878>
<elem-879>
<elem-880>
<elem-881>
<elem-882>
<elem-883>
<elem-884>
<elem-885>
<elem-886>
<elem-887>
<elem-888>
<elem-889>
<elem-890>
<elem-891>
<elem-892>
<elem-893>
<elem-894>
<elem-895>
<elem-896>
<elem-897>
<elem-898>
<elem-899>
<elem-900>
<elem-901>
<elem-902>
<elem-903>
<elem-904>
<elem-905>
<elem-906>
<elem-907>
<elem-908>
<elem-909>
<elem-910>
<elem-911>
<elem-912>
<elem-913>
<elem-914>
<elem-915>
<elem-916>
<elem-917>
<elem-918>
<elem-919>
<elem-920>
<elem-921>
<elem-922>
<elem-923>
<elem-924>
<elem-925>
<elem-926>
<elem-927>
<elem-928>
<elem-929>
<elem-930>
<elem-931>
<elem-932>
<elem-933>
<elem-934>
<elem-935>
<elem-936>
<elem-937>
<elem-938>
<elem-939>
<elem-940>
<elem-941>
<elem-942>
<elem-943>
<elem-944>
<elem-945>
<elem-946>
<elem-947>
<elem-948>
<elem-949>
<elem-950>
<elem-951>
<elem-952>
<elem-953>
<elem-954>
<elem-955>
<elem-956>
<elem-957>
<elem-958>
<elem-959>
<elem-960>
<elem-961>
<elem-962>
<elem-963>
<elem-964>
<elem-965>
<elem-966>
<elem-967>
<elem-968>
<elem-969>
<elem-970>
<elem-971>
<elem-972>
<elem-973>
<elem-974>
<elem-975>
<elem-976>
<elem-977>
<elem-978>
<elem-979>
<elem-980>
<elem-981>
<elem-982>
<elem-983>
<elem-984>
<elem-985>
<elem-986>
<elem-987>
<elem-988>
<elem-989>
<elem-990>
<elem-991>
<elem-992>
<elem-993>
<elem-994>
<elem-995>
<elem-996>
<elem-997>
<elem-998>
<elem-999>
<elem-1000>
</elem-1000>
</elem-999>
</elem-998>
</elem-997>
</elem-996>
</elem-995>
</elem-994>
</elem-993>
</elem-992>
</elem-991>
</elem-990>
</elem-989>
</elem-988>
</elem-987>
</elem-986>
</elem-985>
</elem-984>
</elem-983>
</elem-982>
</elem-981>
</elem-980>
</elem-979>
</elem-978>
</elem-977>
</elem-976>
</elem-975>
</elem-974>
</elem-973>
</elem-972>
</elem-971>
</elem-970>
</elem-969>
</elem-968>
</elem-967>
</elem-966>
</elem-965>
</elem-964>
</elem-963>
</elem-962>
</elem-961>
</elem-960>
</elem-959>
</elem-958>
</elem-957>
</elem-956>
</elem-955>
</elem-954>
</elem-953>
</elem-952>
</elem-951>
</elem-950>
</elem-949>
</elem-948>
</elem-947>
</elem-946>
</elem-945>
</elem-944>
</elem-943>
</elem-942>
</elem-941>
</elem-940>
</elem-939>
</elem-938>
</elem-937>
</elem-936>
</elem-935>
</elem-934>
</elem-933>
</elem-932>
</elem-931>
</elem-930>
</elem-929>
</elem-928>
</elem-927>
</elem-926>
</elem-925>
</elem-924>
</elem-923>
</elem-922>
</elem-921>
</elem-920>
</elem-919>
</elem-918>
</elem-917>
</elem-916>
</elem-915>
</elem-914>
</elem-913>
</elem-912>
</elem-911>
</elem-910>
</elem-909>
</elem-908>
</elem-907>
</elem-906>
</elem-905>
</elem-904>
</elem-903>
</elem-902>
</elem-901>
</elem-900>
</elem-899>
</elem-898>
</elem-897>
</elem-896>
</elem-895>
</elem-894>
</elem-893>
</elem-892>
</elem-891>
</elem-890>
</elem-889>
</elem-888>
</elem-887>
</elem-886>
</elem-885>
</elem-884>
</elem-883>
</elem-882>
</elem-881>
</elem-880>
</elem-879>
</elem-878>
</elem-877>
</elem-876>
</elem-875>
</elem-874>
</elem-873>
</elem-872>
</elem-871>
</elem-870>
</elem-869>
</elem-868>
</elem-867>
</elem-866>
</elem-865>
</elem-864>
</elem-863>
</elem-862>
</elem-861>
</elem-860>
</elem-859>
</elem-858>
</elem-857>
</elem-856>
</elem-855>
</elem-854>
</elem-853>
</elem-852>
</elem-851>
</elem-850>
</elem-849>
</elem-848>
</elem-847>
</elem-846>
</elem-845>
</elem-844>
</elem-843>
</elem-842>
</elem-841>
</elem-840>
</elem-839>
</elem-838>
</elem-837>
</elem-836>
</elem-835>
</elem-834>
</elem-833>
</elem-832>
</elem-831>
</elem-830>
</elem-829>
</elem-828>
</elem-827>
</elem-826>
</elem-825>
</elem-824>
</elem-823>
</elem-822>
</elem-821>
</elem-820>
</elem-819>
</elem-818>
</elem-817>
</elem-816>
</elem-815>
</elem-814>
</elem-813>
</elem-812>
</elem-811>
</elem-810>
</elem-809>
</elem-808>
</elem-807>
</elem-806>
</elem-805>
</elem-804>
</elem-803>
</elem-802>
</elem-801>
</elem-800>
</elem-799>
</elem-798>
</elem-797>
</elem-796>
</elem-795>
</elem-794>
</elem-793>
</elem-792>
</elem-791>
</elem-790>
</elem-789>
</elem-788>
</elem-787>
</elem-786>
</elem-785>
</elem-784>
</elem-783>
</elem-782>
</elem-781>
</elem-780>
</elem-779>
</elem-778>
</elem-777>
</elem-776>
</elem-775>
</elem-774>
</elem-773>
</elem-772>
</elem-771>
</elem-770>
</elem-769>
</elem-768>
</elem-767>
</elem-766>
</elem-765>
</elem-764>
</elem-763>
</elem-762>
</elem-761>
</elem-760>
</elem-759>
</elem-758>
</elem-757>
</elem-756>
</elem-755>
</elem-754>
</elem-753>
</elem-752>
</elem-751>
</elem-750>
</elem-749>
</elem-748>
</elem-747>
</elem-746>
</elem-745>
</elem-744>
</elem-743>
</elem-742>
</elem-741>
</elem-740>
</elem-739>
</elem-738>
</elem-737>
</elem-736>
</elem-735>
</elem-734>
</elem-733>
</elem-732>
</elem-731>
</elem-730>
</elem-729>
</elem-728>
</elem-727>
</elem-726>
</elem-725>
</elem-724>
</elem-723>
</elem-722>
</elem-721>
</elem-720>
</elem-719>
</elem-718>
</elem-717>
</elem-716>
</elem-715>
</elem-714>
</elem-713>
</elem-712>
</elem-711>
</elem-710>
</elem-709>
</elem-708>
</elem-707>
</elem-706>
</elem-705>
</elem-704>
</elem-703>
</elem-702>
</elem-701>
</elem-700>
</elem-699>
</elem-698>
</elem-697>
</elem-696>
</elem-695>
</elem-694>
</elem-693>
</elem-692>
</elem-691>
</elem-690>
</elem-689>
</elem-688>
</elem-687>
</elem-686>
</elem-685>
</elem-684>
</elem-683>
</elem-682>
</elem-681>
</elem-680>
</elem-679>
</elem-678>
</elem-677>
</elem-676>
</elem-675>
</elem-674>
</elem-673>
</elem-672>
</elem-671>
</elem-670>
</elem-669>
</elem-668>
</elem-667>
</elem-666>
</elem-665>
</elem-664>
</elem-663>
</elem-662>
</elem-661>
</elem-660>
</elem-659>
</elem-658>
</elem-657>
</elem-656>
</elem-655>
</elem-654>
</elem-653>
</elem-652>
</elem-651>
</elem-650>
</elem-649>
</elem-648>
</elem-647>
</elem-646>
</elem-645>
</elem-644>
</elem-643>
</elem-642>
</elem-641>
</elem-640>
</elem-639>
</elem-638>
</elem-637>
</elem-636>
</elem-635>
</elem-634>
</elem-633>
</elem-632>
</elem-631>
</elem-630>
</elem-629>
</elem-628>
</elem-627>
</elem-626>
</elem-625>
</elem-624>
</elem-623>
</elem-622>
</elem-621>
</elem-620>
</elem-619>
</elem-618>
</elem-617>
</elem-616>
</elem-615>
</elem-614>
</elem-613>
</elem-612>
</elem-611>
</elem-610>
</elem-609>
</elem-608>
</elem-607>
</elem-606>
</elem-605>
</elem-604>
</elem-603>
</elem-602>
</elem-601>
</elem-600>
</elem-599>
</elem-598>
</elem-597>
</elem-596>
</elem-595>
</elem-594>
</elem-593>
</elem-592>
</elem-591>
</elem-590>
</elem-589>
</elem-588>
</elem-587>
</elem-586>
</elem-585>
</elem-584>
</elem-583>
</elem-582>
</elem-581>
</elem-580>
</elem-579>
</elem-578>
</elem-577>
</elem-576>
</elem-575>
</elem-574>
</elem-573>
</elem-572>
</elem-571>
</elem-570>
</elem-569>
</elem-568>
</elem-567>
</elem-566>
</elem-565>
</elem-564>
</elem-563>
</elem-562>
</elem-561>
</elem-560>
</elem-559>
</elem-558>
</elem-557>
</elem-556>
</elem-555>
</elem-554>
</elem-553>
</elem-552>
</elem-551>
</elem-550>
</elem-549>
</elem-548>
</elem-547>
</elem-546>
</elem-545>
</elem-544>
</elem-543>
</elem-542>
</elem-541>
</elem-540>
</elem-539>
</elem-538>
</elem-537>
</elem-536>
</elem-535>
</elem-534>
</elem-533>
</elem-532>
</elem-531>
</elem-530>
</elem-529>
</elem-528>
</elem-527>
</elem-526>
</elem-525>
</elem-524>
</elem-523>
</elem-522>
</elem-521>
</elem-520>
</elem-519>
</elem-518>
</elem-517>
</elem-516>
</elem-515>
</elem-514>
</elem-513>
</elem-512>
</elem-511>
</elem-510>
</elem-509>
</elem-508>
</elem-507>
</elem-506>
</elem-505>
</elem-504>
</elem-503>
</elem-502>
</elem-501>
</elem-500>
</elem-499>
</elem-498>
</elem-497>
</elem-496>
</elem-495>
</elem-494>
</elem-493>
</elem-492>
</elem-491>
</elem-490>
</elem-489>
</elem-488>
</elem-487>
</elem-486>
</elem-485>
</elem-484>
</elem-483>
</elem-482>
</elem-481>
</elem-480>
</elem-479>
</elem-478>
</elem-477>
</elem-476>
</elem-475>
</elem-474>
</elem-473>
</elem-472>
</elem-471>
</elem-470>
</elem-469>
</elem-468>
</elem-467>
</elem-466>
</elem-465>
</elem-464>
</elem-463>
</elem-462>
</elem-461>
</elem-460>
</elem-459>
</elem-458>
</elem-457>
</elem-456>
</elem-455>
</elem-454>
</elem-453>
</elem-452>
</elem-451>
</elem-450>
</elem-449>
</elem-448>
</elem-447>
</elem-446>
</elem-445>
</elem-444>
</elem-443>
</elem-442>
</elem-441>
</elem-440>
</elem-439>
</elem-438>
</elem-437>
</elem-436>
</elem-435>
</elem-434>
</elem-433>
</elem-432>
</elem-431>
</elem-430>
</elem-429>
</elem-428>
</elem-427>
</elem-426>
</elem-425>
</elem-424>
</elem-423>
</elem-422>
</elem-421>
</elem-420>
</elem-419>
</elem-418>
</elem-417>
</elem-416>
</elem-415>
</elem-414>
</elem-413>
</elem-412>
</elem-411>
</elem-410>
</elem-409>
</elem-408>
</elem-407>
</elem-406>
</elem-405>
</elem-404>
</elem-403>
</elem-402>
</elem-401>
</elem-400>
</elem-399>
</elem-398>
</elem-397>
</elem-396>
</elem-395>
</elem-394>
</elem-393>
</elem-392>
</elem-391>
</elem-390>
</elem-389>
</elem-388>
</elem-387>
</elem-386>
</elem-385>
</elem-384>
</elem-383>
</elem-382>
</elem-381>
</elem-380>
</elem-379>
</elem-378>
</elem-377>
</elem-376>
</elem-375>
</elem-374>
</elem-373>
</elem-372>
</elem-371>
</elem-370>
</elem-369>
</elem-368>
</elem-367>
</elem-366>
</elem-365>
</elem-364>
</elem-363>
</elem-362>
</elem-361>
</elem-360>
</elem-359>
</elem-358>
</elem-357>
</elem-356>
</elem-355>
</elem-354>
</elem-353>
</elem-352>
</elem-351>
</elem-350>
</elem-349>
</elem-348>
</elem-347>
</elem-346>
</elem-345>
</elem-344>
</elem-343>
</elem-342>
</elem-341>
</elem-340>
</elem-339>
</elem-338>
</elem-337>
</elem-336>
</elem-335>
</elem-334>
</elem-333>
</elem-332>
</elem-331>
</elem-330>
</elem-329>
</elem-328>
</elem-327>
</elem-326>
</elem-325>
</elem-324>
</elem-323>
</elem-322>
</elem-321>
</elem-320>
</elem-319>
</elem-318>
</elem-317>
</elem-316>
</elem-315>
</elem-314>
</elem-313>
</elem-312>
</elem-311>
</elem-310>
</elem-309>
</elem-308>
</elem-307>
</elem-306>
</elem-305>
</elem-304>
</elem-303>
</elem-302>
</elem-301>
</elem-300>
</elem-299>
</elem-298>
</elem-297>
</elem-296>
</elem-295>
</elem-294>
</elem-293>
</elem-292>
</elem-291>
</elem-290>
</elem-289>
</elem-288>
</elem-287>
</elem-286>
</elem-285>
</elem-284>
</elem-283>
</elem-282>
</elem-281>
</elem-280>
</elem-279>
</elem-278>
</elem-277>
</elem-276>
</elem-275>
</elem-274>
</elem-273>
</elem-272>
</elem-271>
</elem-270>
</elem-269>
</elem-268>
</elem-267>
</elem-266>
</elem-265>
</elem-264>
</elem-263>
</elem-262>
</elem-261>
</elem-260>
</elem-259>
</elem-258>
</elem-257>
</elem-256>
</elem-255>
</elem-254>
</elem-253>
</elem-252>
</elem-251>
</elem-250>
</elem-249>
</elem-248>
</elem-247>
</elem-246>
</elem-245>
</elem-244>
</elem-243>
</elem-242>
</elem-241>
</elem-240>
</elem-239>
</elem-238>
</elem-237>
</elem-236>
</elem-235>
</elem-234>
</elem-233>
</elem-232>
</elem-231>
</elem-230>
</elem-229>
</elem-228>
</elem-227>
</elem-226>
</elem-225>
</elem-224>
</elem-223>
</elem-222>
</elem-221>
</elem-220>
</elem-219>
</elem-218>
</elem-217>
</elem-216>
</elem-215>
</elem-214>
</elem-213>
</elem-212>
</elem-211>
</elem-210>
</elem-209>
</elem-208>
</elem-207>
</elem-206>
</elem-205>
</elem-204>
</elem-203>
</elem-202>
</elem-201>
</elem-200>
</elem-199>
</elem-198>
</elem-197>
</elem-196>
</elem-195>
</elem-194>
</elem-193>
</elem-192>
</elem-191>
</elem-190>
</elem-189>
</elem-188>
</elem-187>
</elem-186>
</elem-185>
</elem-184>
</elem-183>
</elem-182>
</elem-181>
</elem-180>
</elem-179>
</elem-178>
</elem-177>
</elem-176>
</elem-175>
</elem-174>
</elem-173>
</elem-172>
</elem-171>
</elem-170>
</elem-169>
</elem-168>
</elem-167>
</elem-166>
</elem-165>
</elem-164>
</elem-163>
</elem-162>
</elem-161>
</elem-160>
</elem-159>
</elem-158>
</elem-157>
</elem-156>
</elem-155>
</elem-154>
</elem-153>
</elem-152>
</elem-151>
</elem-150>
</elem-149>
</elem-148>
</elem-147>
</elem-146>
</elem-145>
</elem-144>
</elem-143>
</elem-142>
</elem-141>
</elem-140>
</elem-139>
</elem-138>
</elem-137>
</elem-136>
</elem-135>
</elem-134>
</elem-133>
</elem-132>
</elem-131>
</elem-130>
</elem-129>
</elem-128>
</elem-127>
</elem-126>
</elem-125>
</elem-124>
</elem-123>
</elem-122>
</elem-121>
</elem-120>
</elem-119>
</elem-118>
</elem-117>
</elem-116>
</elem-115>
</elem-114>
</elem-113>
</elem-112>
</elem-111>
</elem-110>
</elem-109>
</elem-108>
</elem-107>
</elem-106>
</elem-105>
</elem-104>
</elem-103>
</elem-102>
</elem-101>
</elem-100>
</elem-99>
</elem-98>
</elem-97>
</elem-96>
</elem-95>
</elem-94>
</elem-93>
</elem-92>
</elem-91>
</elem-90>
</elem-89>
</elem-88>
</elem-87>
</elem-86>
</elem-85>
</elem-84>
</elem-83>
</elem-82>
</elem-81>
</elem-80>
</elem-79>
</elem-78>
</elem-77>
</elem-76>
</elem-75>
</elem-74>
</elem-73>
</elem-72>
</elem-71>
</elem-70>
</elem-69>
</elem-68>
</elem-67>
</elem-66>
</elem-65>
</elem-64>
</elem-63>
</elem-62>
</elem-61>
</elem-60>
</elem-59>
</elem-58>
</elem-57>
</elem-56>
</elem-55>
</elem-54>
</elem-53>
</elem-52>
</elem-51>
</elem-50>
</elem-49>
</elem-48>
</elem-47>
</elem-46>
</elem-45>
</elem-44>
</elem-43>
</elem-42>
</elem-41>
</elem-40>
</elem-39>
</elem-38>
</elem-37>
</elem-36>
</elem-35>
</elem-34>
</elem-33>
</elem-32>
</elem-31>
</elem-30>
</elem-29>
</elem-28>
</elem-27>
</elem-26>
</elem-25>
</elem-24>
</elem-23>
</elem-22>
</elem-21>
</elem-20>
</elem-19>
</elem-18>
</elem-17>
</elem-16>
</elem-15>
</elem-14>
</elem-13>
</elem-12>
</elem-11>
</elem-10>
</elem-9>
</elem-8>
</elem-7>
</elem-6>
</elem-5>
</elem-4>
</elem-3>
</elem-2>
</elem-1>
</outer>

================================================
FILE: test/System.Web.Razor.Test/Text/BufferingTextReaderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Text
{
    public class BufferingTextReaderTest : LookaheadTextReaderTestBase
    {
        private const string TestString = "abcdefg";

        private class DisposeTestMockTextReader : TextReader
        {
            public bool Disposed { get; set; }

            protected override void Dispose(bool disposing)
            {
                base.Dispose(disposing);
                Disposed = true;
            }
        }

        protected override LookaheadTextReader CreateReader(string testString)
        {
            return new BufferingTextReader(new StringReader(testString));
        }

        [Fact]
        public void ConstructorRequiresNonNullSourceReader()
        {
            Assert.ThrowsArgumentNull(() => new BufferingTextReader(null), "source");
        }

        [Fact]
        public void PeekReturnsCurrentCharacterWithoutAdvancingPosition()
        {
            RunPeekTest("abc", peekAt: 2);
        }

        [Fact]
        public void PeekReturnsNegativeOneAtEndOfSourceReader()
        {
            RunPeekTest("abc", peekAt: 3);
        }

        [Fact]
        public void ReadReturnsCurrentCharacterAndAdvancesToNextCharacter()
        {
            RunReadTest("abc", readAt: 2);
        }

        [Fact]
        public void EndingLookaheadReturnsReaderToPreviousLocation()
        {
            RunLookaheadTest("abcdefg", "abcb",
                             Read,
                             Lookahead(
                                 Read,
                                 Read),
                             Read);
        }

        [Fact]
        public void MultipleLookaheadsCanBePerformed()
        {
            RunLookaheadTest("abcdefg", "abcbcdc",
                             Read,
                             Lookahead(
                                 Read,
                                 Read),
                             Read,
                             Lookahead(
                                 Read,
                                 Read),
                             Read);
        }

        [Fact]
        public void LookaheadsCanBeNested()
        {
            RunLookaheadTest("abcdefg", "abcdefebc",
                             Read, // Appended: "a" Reader: "bcdefg"
                             Lookahead( // Reader: "bcdefg"
                                 Read, // Appended: "b" Reader: "cdefg";
                                 Read, // Appended: "c" Reader: "defg";
                                 Read, // Appended: "d" Reader: "efg";
                                 Lookahead( // Reader: "efg"
                                     Read, // Appended: "e" Reader: "fg";
                                     Read // Appended: "f" Reader: "g";
                                     ), // Reader: "efg"
                                 Read // Appended: "e" Reader: "fg";
                                 ), // Reader: "bcdefg"
                             Read, // Appended: "b" Reader: "cdefg";
                             Read); // Appended: "c" Reader: "defg";
        }

        [Fact]
        public void SourceLocationIsZeroWhenInitialized()
        {
            RunSourceLocationTest("abcdefg", SourceLocation.Zero, checkAt: 0);
        }

        [Fact]
        public void CharacterAndAbsoluteIndicesIncreaseAsCharactersAreRead()
        {
            RunSourceLocationTest("abcdefg", new SourceLocation(4, 0, 4), checkAt: 4);
        }

        [Fact]
        public void CharacterAndAbsoluteIndicesIncreaseAsSlashRInTwoCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\r\nb", new SourceLocation(2, 0, 2), checkAt: 2);
        }

        [Fact]
        public void CharacterIndexResetsToZeroAndLineIndexIncrementsWhenSlashNInTwoCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\r\nb", new SourceLocation(3, 1, 0), checkAt: 3);
        }

        [Fact]
        public void CharacterIndexResetsToZeroAndLineIndexIncrementsWhenSlashRInSingleCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\rb", new SourceLocation(2, 1, 0), checkAt: 2);
        }

        [Fact]
        public void CharacterIndexResetsToZeroAndLineIndexIncrementsWhenSlashNInSingleCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\nb", new SourceLocation(2, 1, 0), checkAt: 2);
        }

        [Fact]
        public void EndingLookaheadResetsRawCharacterAndLineIndexToValuesWhenLookaheadBegan()
        {
            RunEndLookaheadUpdatesSourceLocationTest();
        }

        [Fact]
        public void OnceBufferingBeginsReadsCanContinuePastEndOfBuffer()
        {
            RunLookaheadTest("abcdefg", "abcbcdefg",
                             Read,
                             Lookahead(Read(2)),
                             Read(2),
                             ReadToEnd);
        }

        [Fact]
        public void DisposeDisposesSourceReader()
        {
            RunDisposeTest(r => r.Dispose());
        }

        [Fact]
        public void CloseDisposesSourceReader()
        {
            RunDisposeTest(r => r.Close());
        }

        [Fact]
        public void ReadWithBufferSupportsLookahead()
        {
            RunBufferReadTest((reader, buffer, index, count) => reader.Read(buffer, index, count));
        }

        [Fact]
        public void ReadBlockSupportsLookahead()
        {
            RunBufferReadTest((reader, buffer, index, count) => reader.ReadBlock(buffer, index, count));
        }

        [Fact]
        public void ReadLineSupportsLookahead()
        {
            RunReadUntilTest(r => r.ReadLine(), expectedRaw: 8, expectedChar: 0, expectedLine: 2);
        }

        [Fact]
        public void ReadToEndSupportsLookahead()
        {
            RunReadUntilTest(r => r.ReadToEnd(), expectedRaw: 11, expectedChar: 3, expectedLine: 2);
        }

        [Fact]
        public void ReadLineMaintainsCorrectCharacterPosition()
        {
            RunSourceLocationTest("abc\r\ndef", new SourceLocation(5, 1, 0), r => r.ReadLine());
        }

        [Fact]
        public void ReadToEndWorksAsInNormalTextReader()
        {
            RunReadToEndTest();
        }

        [Fact]
        public void CancelBacktrackStopsNextEndLookaheadFromBacktracking()
        {
            RunLookaheadTest("abcdefg", "abcdefg",
                             Lookahead(
                                 Read(2),
                                 CancelBacktrack
                                 ),
                             ReadToEnd);
        }

        [Fact]
        public void CancelBacktrackThrowsInvalidOperationExceptionIfCalledOutsideOfLookahead()
        {
            RunCancelBacktrackOutsideLookaheadTest();
        }

        [Fact]
        public void CancelBacktrackOnlyCancelsBacktrackingForInnermostNestedLookahead()
        {
            RunLookaheadTest("abcdefg", "abcdabcdefg",
                             Lookahead(
                                 Read(2),
                                 Lookahead(
                                     Read,
                                     CancelBacktrack
                                     ),
                                 Read
                                 ),
                             ReadToEnd);
        }

        [Fact]
        public void BacktrackBufferIsClearedWhenEndReachedAndNoCurrentLookaheads()
        {
            // Arrange
            StringReader source = new StringReader(TestString);
            BufferingTextReader reader = new BufferingTextReader(source);

            reader.Read(); // Reader: "bcdefg"
            using (reader.BeginLookahead())
            {
                reader.Read(); // Reader: "cdefg"
            } // Reader: "bcdefg"
            reader.Read(); // Reader: "cdefg"
            Assert.NotNull(reader.Buffer); // Verify our assumption that the buffer still exists

            // Act
            reader.Read();

            // Assert
            Assert.False(reader.Buffering, "The buffer was not reset when the end was reached");
            Assert.Equal(0, reader.Buffer.Length);
        }

        private static void RunDisposeTest(Action<LookaheadTextReader> triggerAction)
        {
            // Arrange
            DisposeTestMockTextReader source = new DisposeTestMockTextReader();
            LookaheadTextReader reader = new BufferingTextReader(source);

            // Act
            triggerAction(reader);

            // Assert
            Assert.True(source.Disposed);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Text/LineTrackingStringBufferTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Text
{
    public class LineTrackingStringBufferTest
    {
        [Fact]
        public void CtorInitializesProperties()
        {
            LineTrackingStringBuffer buffer = new LineTrackingStringBuffer();
            Assert.Equal(0, buffer.Length);
        }

        [Fact]
        public void CharAtCorrectlyReturnsLocation()
        {
            LineTrackingStringBuffer buffer = new LineTrackingStringBuffer();
            buffer.Append("foo\rbar\nbaz\r\nbiz");
            LineTrackingStringBuffer.CharacterReference chr = buffer.CharAt(14);
            Assert.Equal('i', chr.Character);
            Assert.Equal(new SourceLocation(14, 3, 1), chr.Location);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Text/LookaheadTextReaderTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Text;
using System.Web.Razor.Resources;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Text
{
    public abstract class LookaheadTextReaderTestBase
    {
        protected abstract LookaheadTextReader CreateReader(string testString);

        protected void RunPeekTest(string input, int peekAt = 0)
        {
            RunPeekOrReadTest(input, peekAt, false);
        }

        protected void RunReadTest(string input, int readAt = 0)
        {
            RunPeekOrReadTest(input, readAt, true);
        }

        protected void RunSourceLocationTest(string input, SourceLocation expected, int checkAt = 0)
        {
            RunSourceLocationTest(input, expected, r => AdvanceReader(checkAt, r));
        }

        protected void RunSourceLocationTest(string input, SourceLocation expected, Action<LookaheadTextReader> readerAction)
        {
            // Arrange
            LookaheadTextReader reader = CreateReader(input);
            readerAction(reader);

            // Act
            SourceLocation actual = reader.CurrentLocation;

            // Assert
            Assert.Equal(expected, actual);
        }

        protected void RunEndLookaheadUpdatesSourceLocationTest()
        {
            SourceLocation? expectedLocation = null;
            SourceLocation? actualLocation = null;

            RunLookaheadTest("abc\r\ndef\r\nghi", null,
                             Read(6),
                             CaptureSourceLocation(s => expectedLocation = s),
                             Lookahead(Read(6)),
                             CaptureSourceLocation(s => actualLocation = s));
            // Assert
            Assert.Equal(expectedLocation.Value.AbsoluteIndex, actualLocation.Value.AbsoluteIndex);
            Assert.Equal(expectedLocation.Value.CharacterIndex, actualLocation.Value.CharacterIndex);
            Assert.Equal(expectedLocation.Value.LineIndex, actualLocation.Value.LineIndex);
        }

        protected void RunReadToEndTest()
        {
            // Arrange
            LookaheadTextReader reader = CreateReader("abcdefg");

            // Act
            string str = reader.ReadToEnd();

            // Assert
            Assert.Equal("abcdefg", str);
        }

        protected void RunCancelBacktrackOutsideLookaheadTest()
        {
            // Arrange
            LookaheadTextReader reader = CreateReader("abcdefg");

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => reader.CancelBacktrack(), RazorResources.CancelBacktrack_Must_Be_Called_Within_Lookahead);
        }

        protected Action<StringBuilder, LookaheadTextReader> CaptureSourceLocation(Action<SourceLocation> capture)
        {
            return (_, reader) => { capture(reader.CurrentLocation); };
        }

        protected Action<StringBuilder, LookaheadTextReader> Read(int count)
        {
            return (builder, reader) =>
            {
                for (int i = 0; i < count; i++)
                {
                    Read(builder, reader);
                }
            };
        }

        protected void Read(StringBuilder builder, LookaheadTextReader reader)
        {
            builder.Append((char)reader.Read());
        }

        protected void ReadToEnd(StringBuilder builder, LookaheadTextReader reader)
        {
            builder.Append(reader.ReadToEnd());
        }

        protected void CancelBacktrack(StringBuilder builder, LookaheadTextReader reader)
        {
            reader.CancelBacktrack();
        }

        protected Action<StringBuilder, LookaheadTextReader> Lookahead(params Action<StringBuilder, LookaheadTextReader>[] readerCommands)
        {
            return (builder, reader) =>
            {
                using (reader.BeginLookahead())
                {
                    RunAll(readerCommands, builder, reader);
                }
            };
        }

        protected void RunLookaheadTest(string input, string expected, params Action<StringBuilder, LookaheadTextReader>[] readerCommands)
        {
            // Arrange
            StringBuilder builder = new StringBuilder();
            using (LookaheadTextReader reader = CreateReader(input))
            {
                RunAll(readerCommands, builder, reader);
            }

            if (expected != null)
            {
                Assert.Equal(expected, builder.ToString());
            }
        }

        protected void RunReadUntilTest(Func<LookaheadTextReader, string> readMethod, int expectedRaw, int expectedChar, int expectedLine)
        {
            // Arrange
            LookaheadTextReader reader = CreateReader("a\r\nbcd\r\nefg");

            reader.Read(); // Reader: "\r\nbcd\r\nefg"
            reader.Read(); // Reader: "\nbcd\r\nefg"
            reader.Read(); // Reader: "bcd\r\nefg"

            // Act
            string read = null;
            SourceLocation actualLocation;
            using (reader.BeginLookahead())
            {
                read = readMethod(reader);
                actualLocation = reader.CurrentLocation;
            }

            // Assert
            Assert.Equal(3, reader.CurrentLocation.AbsoluteIndex);
            Assert.Equal(0, reader.CurrentLocation.CharacterIndex);
            Assert.Equal(1, reader.CurrentLocation.LineIndex);
            Assert.Equal(expectedRaw, actualLocation.AbsoluteIndex);
            Assert.Equal(expectedChar, actualLocation.CharacterIndex);
            Assert.Equal(expectedLine, actualLocation.LineIndex);
            Assert.Equal('b', reader.Peek());
            Assert.Equal(read, readMethod(reader));
        }

        protected void RunBufferReadTest(Func<LookaheadTextReader, char[], int, int, int> readMethod)
        {
            // Arrange
            LookaheadTextReader reader = CreateReader("abcdefg");

            reader.Read(); // Reader: "bcdefg"

            // Act
            char[] buffer = new char[4];
            int read = -1;
            SourceLocation actualLocation;
            using (reader.BeginLookahead())
            {
                read = readMethod(reader, buffer, 0, 4);
                actualLocation = reader.CurrentLocation;
            }

            // Assert
            Assert.Equal("bcde", new String(buffer));
            Assert.Equal(4, read);
            Assert.Equal(5, actualLocation.AbsoluteIndex);
            Assert.Equal(5, actualLocation.CharacterIndex);
            Assert.Equal(0, actualLocation.LineIndex);
            Assert.Equal(1, reader.CurrentLocation.CharacterIndex);
            Assert.Equal(0, reader.CurrentLocation.LineIndex);
            Assert.Equal('b', reader.Peek());
        }

        private static void RunAll(Action<StringBuilder, LookaheadTextReader>[] readerCommands, StringBuilder builder, LookaheadTextReader reader)
        {
            foreach (Action<StringBuilder, LookaheadTextReader> readerCommand in readerCommands)
            {
                readerCommand(builder, reader);
            }
        }

        private void RunPeekOrReadTest(string input, int offset, bool isRead)
        {
            using (LookaheadTextReader reader = CreateReader(input))
            {
                AdvanceReader(offset, reader);

                // Act
                int? actual = null;
                if (isRead)
                {
                    actual = reader.Read();
                }
                else
                {
                    actual = reader.Peek();
                }

                Assert.NotNull(actual);

                // Asserts
                AssertReaderValueCorrect(actual.Value, input, offset, "Peek");

                if (isRead)
                {
                    AssertReaderValueCorrect(reader.Peek(), input, offset + 1, "Read");
                }
                else
                {
                    Assert.Equal(actual, reader.Peek());
                }
            }
        }

        private static void AdvanceReader(int offset, LookaheadTextReader reader)
        {
            for (int i = 0; i < offset; i++)
            {
                reader.Read();
            }
        }

        private void AssertReaderValueCorrect(int actual, string input, int expectedOffset, string methodName)
        {
            if (expectedOffset < input.Length)
            {
                Assert.Equal(input[expectedOffset], actual);
            }
            else
            {
                Assert.Equal(-1, actual);
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Text/SourceLocationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Text
{
    public class SourceLocationTest
    {
        [Fact]
        public void ConstructorWithLineAndCharacterIndexSetsAssociatedProperties()
        {
            // Act
            SourceLocation loc = new SourceLocation(0, 42, 24);

            // Assert
            Assert.Equal(0, loc.AbsoluteIndex);
            Assert.Equal(42, loc.LineIndex);
            Assert.Equal(24, loc.CharacterIndex);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Text/SourceLocationTrackerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Text
{
    public class SourceLocationTrackerTest
    {
        private static readonly SourceLocation TestStartLocation = new SourceLocation(10, 42, 45);

        [Fact]
        public void ConstructorSetsCurrentLocationToZero()
        {
            Assert.Equal(SourceLocation.Zero, new SourceLocationTracker().CurrentLocation);
        }

        [Fact]
        public void ConstructorWithSourceLocationSetsCurrentLocationToSpecifiedValue()
        {
            SourceLocation loc = new SourceLocation(10, 42, 4);
            Assert.Equal(loc, new SourceLocationTracker(loc).CurrentLocation);
        }

        [Fact]
        public void UpdateLocationAdvancesCorrectlyForMultiLineString()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation("foo\nbar\rbaz\r\nbox");

            // Assert
            Assert.Equal(26, tracker.CurrentLocation.AbsoluteIndex);
            Assert.Equal(45, tracker.CurrentLocation.LineIndex);
            Assert.Equal(3, tracker.CurrentLocation.CharacterIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesAbsoluteIndexOnNonNewlineCharacter()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('f', 'o');

            // Assert
            Assert.Equal(11, tracker.CurrentLocation.AbsoluteIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesCharacterIndexOnNonNewlineCharacter()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('f', 'o');

            // Assert
            Assert.Equal(46, tracker.CurrentLocation.CharacterIndex);
        }

        [Fact]
        public void UpdateLocationDoesNotAdvanceLineIndexOnNonNewlineCharacter()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('f', 'o');

            // Assert
            Assert.Equal(42, tracker.CurrentLocation.LineIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesLineIndexOnSlashN()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\n', 'o');

            // Assert
            Assert.Equal(43, tracker.CurrentLocation.LineIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesAbsoluteIndexOnSlashN()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\n', 'o');

            // Assert
            Assert.Equal(11, tracker.CurrentLocation.AbsoluteIndex);
        }

        [Fact]
        public void UpdateLocationResetsCharacterIndexOnSlashN()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\n', 'o');

            // Assert
            Assert.Equal(0, tracker.CurrentLocation.CharacterIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesLineIndexOnSlashRFollowedByNonNewlineCharacter()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\r', 'o');

            // Assert
            Assert.Equal(43, tracker.CurrentLocation.LineIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesAbsoluteIndexOnSlashRFollowedByNonNewlineCharacter()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\r', 'o');

            // Assert
            Assert.Equal(11, tracker.CurrentLocation.AbsoluteIndex);
        }

        [Fact]
        public void UpdateLocationResetsCharacterIndexOnSlashRFollowedByNonNewlineCharacter()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\r', 'o');

            // Assert
            Assert.Equal(0, tracker.CurrentLocation.CharacterIndex);
        }

        [Fact]
        public void UpdateLocationDoesNotAdvanceLineIndexOnSlashRFollowedBySlashN()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\r', '\n');

            // Assert
            Assert.Equal(42, tracker.CurrentLocation.LineIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesAbsoluteIndexOnSlashRFollowedBySlashN()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\r', '\n');

            // Assert
            Assert.Equal(11, tracker.CurrentLocation.AbsoluteIndex);
        }

        [Fact]
        public void UpdateLocationAdvancesCharacterIndexOnSlashRFollowedBySlashN()
        {
            // Arrange
            SourceLocationTracker tracker = new SourceLocationTracker(TestStartLocation);

            // Act
            tracker.UpdateLocation('\r', '\n');

            // Assert
            Assert.Equal(46, tracker.CurrentLocation.CharacterIndex);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Text/TextBufferReaderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Text
{
    public class TextBufferReaderTest : LookaheadTextReaderTestBase
    {
        protected override LookaheadTextReader CreateReader(string testString)
        {
            return new TextBufferReader(new StringTextBuffer(testString));
        }

        [Fact]
        public void ConstructorRequiresNonNullTextBuffer()
        {
            Assert.ThrowsArgumentNull(() => new TextBufferReader(null), "buffer");
        }

        [Fact]
        public void PeekReturnsCurrentCharacterWithoutAdvancingPosition()
        {
            RunPeekTest("abc", peekAt: 2);
        }

        [Fact]
        public void PeekReturnsNegativeOneAtEndOfSourceReader()
        {
            RunPeekTest("abc", peekAt: 3);
        }

        [Fact]
        public void ReadReturnsCurrentCharacterAndAdvancesToNextCharacter()
        {
            RunReadTest("abc", readAt: 2);
        }

        [Fact]
        public void EndingLookaheadReturnsReaderToPreviousLocation()
        {
            RunLookaheadTest("abcdefg", "abcb",
                             Read,
                             Lookahead(
                                 Read,
                                 Read),
                             Read);
        }

        [Fact]
        public void MultipleLookaheadsCanBePerformed()
        {
            RunLookaheadTest("abcdefg", "abcbcdc",
                             Read,
                             Lookahead(
                                 Read,
                                 Read),
                             Read,
                             Lookahead(
                                 Read,
                                 Read),
                             Read);
        }

        [Fact]
        public void LookaheadsCanBeNested()
        {
            RunLookaheadTest("abcdefg", "abcdefebc",
                             Read, // Appended: "a" Reader: "bcdefg"
                             Lookahead( // Reader: "bcdefg"
                                 Read, // Appended: "b" Reader: "cdefg";
                                 Read, // Appended: "c" Reader: "defg";
                                 Read, // Appended: "d" Reader: "efg";
                                 Lookahead( // Reader: "efg"
                                     Read, // Appended: "e" Reader: "fg";
                                     Read // Appended: "f" Reader: "g";
                                     ), // Reader: "efg"
                                 Read // Appended: "e" Reader: "fg";
                                 ), // Reader: "bcdefg"
                             Read, // Appended: "b" Reader: "cdefg";
                             Read); // Appended: "c" Reader: "defg";
        }

        [Fact]
        public void SourceLocationIsZeroWhenInitialized()
        {
            RunSourceLocationTest("abcdefg", SourceLocation.Zero, checkAt: 0);
        }

        [Fact]
        public void CharacterAndAbsoluteIndicesIncreaseAsCharactersAreRead()
        {
            RunSourceLocationTest("abcdefg", new SourceLocation(4, 0, 4), checkAt: 4);
        }

        [Fact]
        public void CharacterAndAbsoluteIndicesIncreaseAsSlashRInTwoCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\r\nb", new SourceLocation(2, 0, 2), checkAt: 2);
        }

        [Fact]
        public void CharacterIndexResetsToZeroAndLineIndexIncrementsWhenSlashNInTwoCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\r\nb", new SourceLocation(3, 1, 0), checkAt: 3);
        }

        [Fact]
        public void CharacterIndexResetsToZeroAndLineIndexIncrementsWhenSlashRInSingleCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\rb", new SourceLocation(2, 1, 0), checkAt: 2);
        }

        [Fact]
        public void CharacterIndexResetsToZeroAndLineIndexIncrementsWhenSlashNInSingleCharacterNewlineIsRead()
        {
            RunSourceLocationTest("f\nb", new SourceLocation(2, 1, 0), checkAt: 2);
        }

        [Fact]
        public void EndingLookaheadResetsRawCharacterAndLineIndexToValuesWhenLookaheadBegan()
        {
            RunEndLookaheadUpdatesSourceLocationTest();
        }

        [Fact]
        public void OnceBufferingBeginsReadsCanContinuePastEndOfBuffer()
        {
            RunLookaheadTest("abcdefg", "abcbcdefg",
                             Read,
                             Lookahead(Read(2)),
                             Read(2),
                             ReadToEnd);
        }

        [Fact]
        public void DisposeDisposesSourceReader()
        {
            RunDisposeTest(r => r.Dispose());
        }

        [Fact]
        public void CloseDisposesSourceReader()
        {
            RunDisposeTest(r => r.Close());
        }

        [Fact]
        public void ReadWithBufferSupportsLookahead()
        {
            RunBufferReadTest((reader, buffer, index, count) => reader.Read(buffer, index, count));
        }

        [Fact]
        public void ReadBlockSupportsLookahead()
        {
            RunBufferReadTest((reader, buffer, index, count) => reader.ReadBlock(buffer, index, count));
        }

        [Fact]
        public void ReadLineSupportsLookahead()
        {
            RunReadUntilTest(r => r.ReadLine(), expectedRaw: 8, expectedChar: 0, expectedLine: 2);
        }

        [Fact]
        public void ReadToEndSupportsLookahead()
        {
            RunReadUntilTest(r => r.ReadToEnd(), expectedRaw: 11, expectedChar: 3, expectedLine: 2);
        }

        [Fact]
        public void ReadLineMaintainsCorrectCharacterPosition()
        {
            RunSourceLocationTest("abc\r\ndef", new SourceLocation(5, 1, 0), r => r.ReadLine());
        }

        [Fact]
        public void ReadToEndWorksAsInNormalTextReader()
        {
            RunReadToEndTest();
        }

        [Fact]
        public void CancelBacktrackStopsNextEndLookaheadFromBacktracking()
        {
            RunLookaheadTest("abcdefg", "abcdefg",
                             Lookahead(
                                 Read(2),
                                 CancelBacktrack
                                 ),
                             ReadToEnd);
        }

        [Fact]
        public void CancelBacktrackThrowsInvalidOperationExceptionIfCalledOutsideOfLookahead()
        {
            RunCancelBacktrackOutsideLookaheadTest();
        }

        [Fact]
        public void CancelBacktrackOnlyCancelsBacktrackingForInnermostNestedLookahead()
        {
            RunLookaheadTest("abcdefg", "abcdabcdefg",
                             Lookahead(
                                 Read(2),
                                 Lookahead(
                                     Read,
                                     CancelBacktrack
                                     ),
                                 Read
                                 ),
                             ReadToEnd);
        }

        private static void RunDisposeTest(Action<LookaheadTextReader> triggerAction)
        {
            // Arrange
            StringTextBuffer source = new StringTextBuffer("abcdefg");
            LookaheadTextReader reader = new TextBufferReader(source);

            // Act
            triggerAction(reader);

            // Assert
            Assert.True(source.Disposed);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Text/TextChangeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Razor.Test.Text
{
    public class TextChangeTest
    {
        [Fact]
        public void ConstructorRequiresNonNegativeOldPosition()
        {
            Assert.ThrowsArgumentOutOfRange(() => new TextChange(-1, 0, new Mock<ITextBuffer>().Object, 0, 0, new Mock<ITextBuffer>().Object), "oldPosition", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void ConstructorRequiresNonNegativeNewPosition()
        {
            Assert.ThrowsArgumentOutOfRange(() => new TextChange(0, 0, new Mock<ITextBuffer>().Object, -1, 0, new Mock<ITextBuffer>().Object), "newPosition", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void ConstructorRequiresNonNegativeOldLength()
        {
            Assert.ThrowsArgumentOutOfRange(() => new TextChange(0, -1, new Mock<ITextBuffer>().Object, 0, 0, new Mock<ITextBuffer>().Object), "oldLength", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void ConstructorRequiresNonNegativeNewLength()
        {
            Assert.ThrowsArgumentOutOfRange(() => new TextChange(0, 0, new Mock<ITextBuffer>().Object, 0, -1, new Mock<ITextBuffer>().Object), "newLength", "Value must be greater than or equal to 0.");
        }

        [Fact]
        public void ConstructorRequiresNonNullOldBuffer()
        {
            Assert.ThrowsArgumentNull(() => new TextChange(0, 0, null, 0, 0, new Mock<ITextBuffer>().Object), "oldBuffer");
        }

        [Fact]
        public void ConstructorRequiresNonNullNewBuffer()
        {
            Assert.ThrowsArgumentNull(() => new TextChange(0, 0, new Mock<ITextBuffer>().Object, 0, 0, null), "newBuffer");
        }

        [Fact]
        public void ConstructorInitializesProperties()
        {
            // Act
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(42, 24, oldBuffer, 1337, newBuffer);

            // Assert
            Assert.Equal(42, change.OldPosition);
            Assert.Equal(24, change.OldLength);
            Assert.Equal(1337, change.NewLength);
            Assert.Same(newBuffer, change.NewBuffer);
            Assert.Same(oldBuffer, change.OldBuffer);
        }

        [Fact]
        public void TestIsDelete()
        {
            // Arrange 
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(0, 1, oldBuffer, 0, newBuffer);

            // Assert
            Assert.True(change.IsDelete);
        }

        [Fact]
        public void TestDeleteCreatesTheRightSizeChange()
        {
            // Arrange 
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(0, 1, oldBuffer, 0, newBuffer);

            // Assert
            Assert.Equal(0, change.NewText.Length);
            Assert.Equal(1, change.OldText.Length);
        }

        [Fact]
        public void TestIsInsert()
        {
            // Arrange 
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(0, 0, oldBuffer, 35, newBuffer);

            // Assert
            Assert.True(change.IsInsert);
        }

        [Fact]
        public void TestInsertCreateTheRightSizeChange()
        {
            // Arrange 
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(0, 0, oldBuffer, 1, newBuffer);

            // Assert
            Assert.Equal(1, change.NewText.Length);
            Assert.Equal(0, change.OldText.Length);
        }

        [Fact]
        public void TestIsReplace()
        {
            // Arrange 
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(0, 5, oldBuffer, 10, newBuffer);

            // Assert
            Assert.True(change.IsReplace);
        }

        [Fact]
        public void ReplaceCreatesTheRightSizeChange()
        {
            // Arrange 
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(0, 5, oldBuffer, 10, newBuffer);

            // Assert
            Assert.Equal(10, change.NewText.Length);
            Assert.Equal(5, change.OldText.Length);
        }

        [Fact]
        public void ReplaceCreatesTheRightSizeChange1()
        {
            // Arrange 
            ITextBuffer oldBuffer = new Mock<ITextBuffer>().Object;
            ITextBuffer newBuffer = new Mock<ITextBuffer>().Object;
            TextChange change = new TextChange(0, 5, oldBuffer, 1, newBuffer);

            // Assert
            Assert.Equal(1, change.NewText.Length);
            Assert.Equal(5, change.OldText.Length);
        }

        [Fact]
        public void OldTextReturnsOldSpanFromOldBuffer()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("test");
            var oldBuffer = new StringTextBuffer("text");
            var textChange = new TextChange(2, 1, oldBuffer, 1, newBuffer);

            // Act
            string text = textChange.OldText;

            // Assert
            Assert.Equal("x", text);
        }

        [Fact]
        public void OldTextReturnsOldSpanFromOldBuffer2()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("test");
            var oldBuffer = new StringTextBuffer("text");
            var textChange = new TextChange(2, 2, oldBuffer, 1, newBuffer);

            // Act
            string text = textChange.OldText;

            // Assert
            Assert.Equal("xt", text);
        }

        [Fact]
        public void NewTextWithInsertReturnsChangedTextFromBuffer()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("test");
            var oldBuffer = new StringTextBuffer("");
            var textChange = new TextChange(0, 0, oldBuffer, 3, newBuffer);

            // Act
            string text = textChange.NewText;
            string oldText = textChange.OldText;

            // Assert
            Assert.Equal("tes", text);
            Assert.Equal("", oldText);
        }

        [Fact]
        public void NewTextWithDeleteReturnsEmptyString()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("test");
            var oldBuffer = new StringTextBuffer("");
            var textChange = new TextChange(1, 1, oldBuffer, 0, newBuffer);

            // Act
            string text = textChange.NewText;

            // Assert
            Assert.Equal(String.Empty, text);
        }

        [Fact]
        public void NewTextWithReplaceReturnsChangedTextFromBuffer()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("test");
            var oldBuffer = new StringTextBuffer("tebb");
            var textChange = new TextChange(2, 2, oldBuffer, 1, newBuffer);

            // Act
            string newText = textChange.NewText;
            string oldText = textChange.OldText;

            // Assert
            Assert.Equal("s", newText);
            Assert.Equal("bb", oldText);
        }

        [Fact]
        public void ApplyChangeWithInsertedTextReturnsNewContentWithChangeApplied()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("test");
            var oldBuffer = new StringTextBuffer("");
            var textChange = new TextChange(0, 0, oldBuffer, 3, newBuffer);

            // Act
            string text = textChange.ApplyChange("abcd", 0);

            // Assert
            Assert.Equal("tesabcd", text);
        }

        [Fact]
        public void ApplyChangeWithRemovedTextReturnsNewContentWithChangeApplied()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("abcdefg");
            var oldBuffer = new StringTextBuffer("");
            var textChange = new TextChange(1, 1, oldBuffer, 0, newBuffer);

            // Act
            string text = textChange.ApplyChange("abcdefg", 1);

            // Assert
            Assert.Equal("bcdefg", text);
        }

        [Fact]
        public void ApplyChangeWithReplacedTextReturnsNewContentWithChangeApplied()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("abcdefg");
            var oldBuffer = new StringTextBuffer("");
            var textChange = new TextChange(1, 1, oldBuffer, 2, newBuffer);

            // Act
            string text = textChange.ApplyChange("abcdefg", 1);

            // Assert
            Assert.Equal("bcbcdefg", text);
        }

        [Fact]
        public void NormalizeFixesUpIntelliSenseStyleReplacements()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("Date.");
            var oldBuffer = new StringTextBuffer("Date");
            var original = new TextChange(0, 4, oldBuffer, 5, newBuffer);

            // Act
            TextChange normalized = original.Normalize();

            // Assert
            Assert.Equal(new TextChange(4, 0, oldBuffer, 1, newBuffer), normalized);
        }

        [Fact]
        public void NormalizeDoesntAffectChangesWithoutCommonPrefixes()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("DateTime.");
            var oldBuffer = new StringTextBuffer("Date.");
            var original = new TextChange(0, 5, oldBuffer, 9, newBuffer);

            // Act
            TextChange normalized = original.Normalize();

            // Assert
            Assert.Equal(original, normalized);
        }

        [Fact]
        public void NormalizeDoesntAffectShrinkingReplacements()
        {
            // Arrange
            var newBuffer = new StringTextBuffer("D");
            var oldBuffer = new StringTextBuffer("DateTime");
            var original = new TextChange(0, 8, oldBuffer, 1, newBuffer);

            // Act
            TextChange normalized = original.Normalize();

            // Assert
            Assert.Equal(original, normalized);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Text/TextReaderExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Razor.Parser;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Text
{
    public class TextReaderExtensionsTest
    {
        [Fact]
        public void ReadUntilWithCharThrowsArgNullIfReaderNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(null, '@'), "reader");
        }

        [Fact]
        public void ReadUntilInclusiveWithCharThrowsArgNullIfReaderNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(null, '@', inclusive: true), "reader");
        }

        [Fact]
        public void ReadUntilWithMultipleTerminatorsThrowsArgNullIfReaderNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(null, '/', '>'), "reader");
        }

        [Fact]
        public void ReadUntilInclusiveWithMultipleTerminatorsThrowsArgNullIfReaderNull()
        {
            // NOTE: Using named parameters would be difficult here, hence the inline comment
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(null, /* inclusive */ true, '/', '>'), "reader");
        }

        [Fact]
        public void ReadUntilWithPredicateThrowsArgNullIfReaderNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(null, c => true), "reader");
        }

        [Fact]
        public void ReadUntilInclusiveWithPredicateThrowsArgNullIfReaderNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(null, c => true, inclusive: true), "reader");
        }

        [Fact]
        public void ReadUntilWithPredicateThrowsArgExceptionIfPredicateNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(new StringReader("Foo"), (Predicate<char>)null), "condition");
        }

        [Fact]
        public void ReadUntilInclusiveWithPredicateThrowsArgExceptionIfPredicateNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadUntil(new StringReader("Foo"), (Predicate<char>)null, inclusive: true), "condition");
        }

        [Fact]
        public void ReadWhileWithPredicateThrowsArgNullIfReaderNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadWhile(null, c => true), "reader");
        }

        [Fact]
        public void ReadWhileInclusiveWithPredicateThrowsArgNullIfReaderNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadWhile(null, c => true, inclusive: true), "reader");
        }

        [Fact]
        public void ReadWhileWithPredicateThrowsArgNullIfPredicateNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadWhile(new StringReader("Foo"), (Predicate<char>)null), "condition");
        }

        [Fact]
        public void ReadWhileInclusiveWithPredicateThrowsArgNullIfPredicateNull()
        {
            Assert.ThrowsArgumentNull(() => TextReaderExtensions.ReadWhile(new StringReader("Foo"), (Predicate<char>)null, inclusive: true), "condition");
        }

        [Fact]
        public void ReadUntilWithCharReadsAllTextUpToSpecifiedCharacterButNotPast()
        {
            RunReaderTest("foo bar baz @biz", "foo bar baz ", '@', r => r.ReadUntil('@'));
        }

        [Fact]
        public void ReadUntilWithCharWithInclusiveFlagReadsAllTextUpToSpecifiedCharacterButNotPastIfInclusiveFalse()
        {
            RunReaderTest("foo bar baz @biz", "foo bar baz ", '@', r => r.ReadUntil('@', inclusive: false));
        }

        [Fact]
        public void ReadUntilWithCharWithInclusiveFlagReadsAllTextUpToAndIncludingSpecifiedCharacterIfInclusiveTrue()
        {
            RunReaderTest("foo bar baz @biz", "foo bar baz @", 'b', r => r.ReadUntil('@', inclusive: true));
        }

        [Fact]
        public void ReadUntilWithCharReadsToEndIfSpecifiedCharacterNotFound()
        {
            RunReaderTest("foo bar baz", "foo bar baz", -1, r => r.ReadUntil('@'));
        }

        [Fact]
        public void ReadUntilWithMultipleTerminatorsReadsUntilAnyTerminatorIsFound()
        {
            RunReaderTest("<bar/>", "<bar", '/', r => r.ReadUntil('/', '>'));
        }

        [Fact]
        public void ReadUntilWithMultipleTerminatorsHonorsInclusiveFlagWhenFalse()
        {
            // NOTE: Using named parameters would be difficult here, hence the inline comment
            RunReaderTest("<bar/>", "<bar", '/', r => r.ReadUntil(/* inclusive */ false, '/', '>'));
        }

        [Fact]
        public void ReadUntilWithMultipleTerminatorsHonorsInclusiveFlagWhenTrue()
        {
            // NOTE: Using named parameters would be difficult here, hence the inline comment
            RunReaderTest("<bar/>", "<bar/", '>', r => r.ReadUntil(/* inclusive */ true, '/', '>'));
        }

        [Fact]
        public void ReadUntilWithPredicateStopsWhenPredicateIsTrue()
        {
            RunReaderTest("foo bar baz 0 zoop zork zoink", "foo bar baz ", '0', r => r.ReadUntil(c => Char.IsDigit(c)));
        }

        [Fact]
        public void ReadUntilWithPredicateHonorsInclusiveFlagWhenFalse()
        {
            RunReaderTest("foo bar baz 0 zoop zork zoink", "foo bar baz ", '0', r => r.ReadUntil(c => Char.IsDigit(c), inclusive: false));
        }

        [Fact]
        public void ReadUntilWithPredicateHonorsInclusiveFlagWhenTrue()
        {
            RunReaderTest("foo bar baz 0 zoop zork zoink", "foo bar baz 0", ' ', r => r.ReadUntil(c => Char.IsDigit(c), inclusive: true));
        }

        [Fact]
        public void ReadWhileWithPredicateStopsWhenPredicateIsFalse()
        {
            RunReaderTest("012345a67890", "012345", 'a', r => r.ReadWhile(c => Char.IsDigit(c)));
        }

        [Fact]
        public void ReadWhileWithPredicateHonorsInclusiveFlagWhenFalse()
        {
            RunReaderTest("012345a67890", "012345", 'a', r => r.ReadWhile(c => Char.IsDigit(c), inclusive: false));
        }

        [Fact]
        public void ReadWhileWithPredicateHonorsInclusiveFlagWhenTrue()
        {
            RunReaderTest("012345a67890", "012345a", '6', r => r.ReadWhile(c => Char.IsDigit(c), inclusive: true));
        }

        private static void RunReaderTest(string testString, string expectedOutput, int expectedPeek, Func<TextReader, string> action)
        {
            // Arrange
            StringReader reader = new StringReader(testString);

            // Act
            string read = action(reader);

            // Assert
            Assert.Equal(expectedOutput, read);

            if (expectedPeek == -1)
            {
                Assert.True(reader.Peek() == -1, "Expected that the reader would be positioned at the end of the input stream");
            }
            else
            {
                Assert.Equal((char)expectedPeek, (char)reader.Peek());
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/CSharpTokenizerCommentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class CSharpTokenizerCommentTest : CSharpTokenizerTestBase
    {
        [Fact]
        public void Next_Ignores_Star_At_EOF_In_RazorComment()
        {
            TestTokenizer("@* Foo * Bar * Baz *",
                          new CSharpSymbol(0, 0, 0, "@", CSharpSymbolType.RazorCommentTransition),
                          new CSharpSymbol(1, 0, 1, "*", CSharpSymbolType.RazorCommentStar),
                          new CSharpSymbol(2, 0, 2, " Foo * Bar * Baz *", CSharpSymbolType.RazorComment));
        }

        [Fact]
        public void Next_Ignores_Star_Without_Trailing_At()
        {
            TestTokenizer("@* Foo * Bar * Baz *@",
                          new CSharpSymbol(0, 0, 0, "@", CSharpSymbolType.RazorCommentTransition),
                          new CSharpSymbol(1, 0, 1, "*", CSharpSymbolType.RazorCommentStar),
                          new CSharpSymbol(2, 0, 2, " Foo * Bar * Baz ", CSharpSymbolType.RazorComment),
                          new CSharpSymbol(19, 0, 19, "*", CSharpSymbolType.RazorCommentStar),
                          new CSharpSymbol(20, 0, 20, "@", CSharpSymbolType.RazorCommentTransition));
        }

        [Fact]
        public void Next_Returns_RazorComment_Token_For_Entire_Razor_Comment()
        {
            TestTokenizer("@* Foo Bar Baz *@",
                          new CSharpSymbol(0, 0, 0, "@", CSharpSymbolType.RazorCommentTransition),
                          new CSharpSymbol(1, 0, 1, "*", CSharpSymbolType.RazorCommentStar),
                          new CSharpSymbol(2, 0, 2, " Foo Bar Baz ", CSharpSymbolType.RazorComment),
                          new CSharpSymbol(15, 0, 15, "*", CSharpSymbolType.RazorCommentStar),
                          new CSharpSymbol(16, 0, 16, "@", CSharpSymbolType.RazorCommentTransition));
        }

        [Fact]
        public void Next_Returns_Comment_Token_For_Entire_Single_Line_Comment()
        {
            TestTokenizer("// Foo Bar Baz", new CSharpSymbol(0, 0, 0, "// Foo Bar Baz", CSharpSymbolType.Comment));
        }

        [Fact]
        public void Single_Line_Comment_Is_Terminated_By_Newline()
        {
            TestTokenizer("// Foo Bar Baz\na", new CSharpSymbol(0, 0, 0, "// Foo Bar Baz", CSharpSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void Multi_Line_Comment_In_Single_Line_Comment_Has_No_Effect()
        {
            TestTokenizer("// Foo/*Bar*/ Baz\na", new CSharpSymbol(0, 0, 0, "// Foo/*Bar*/ Baz", CSharpSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Comment_Token_For_Entire_Multi_Line_Comment()
        {
            TestTokenizer("/* Foo\nBar\nBaz */", new CSharpSymbol(0, 0, 0, "/* Foo\nBar\nBaz */", CSharpSymbolType.Comment));
        }

        [Fact]
        public void Multi_Line_Comment_Is_Terminated_By_End_Sequence()
        {
            TestTokenizer("/* Foo\nBar\nBaz */a", new CSharpSymbol(0, 0, 0, "/* Foo\nBar\nBaz */", CSharpSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void Unterminated_Multi_Line_Comment_Captures_To_EOF()
        {
            TestTokenizer("/* Foo\nBar\nBaz", new CSharpSymbol(0, 0, 0, "/* Foo\nBar\nBaz", CSharpSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void Nested_Multi_Line_Comments_Terminated_At_First_End_Sequence()
        {
            TestTokenizer("/* Foo/*\nBar\nBaz*/ */", new CSharpSymbol(0, 0, 0, "/* Foo/*\nBar\nBaz*/", CSharpSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void Nested_Multi_Line_Comments_Terminated_At_Full_End_Sequence()
        {
            TestTokenizer("/* Foo\nBar\nBaz* */", new CSharpSymbol(0, 0, 0, "/* Foo\nBar\nBaz* */", CSharpSymbolType.Comment), IgnoreRemaining);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/CSharpTokenizerIdentifierTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class CSharpTokenizerIdentifierTest : CSharpTokenizerTestBase
    {
        [Fact]
        public void Simple_Identifier_Is_Recognized()
        {
            TestTokenizer("foo", new CSharpSymbol(0, 0, 0, "foo", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Starting_With_Underscore_Is_Recognized()
        {
            TestTokenizer("_foo", new CSharpSymbol(0, 0, 0, "_foo", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Digits()
        {
            TestTokenizer("foo4", new CSharpSymbol(0, 0, 0, "foo4", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Titlecase_Letter()
        {
            TestTokenizer("ῼfoo", new CSharpSymbol(0, 0, 0, "ῼfoo", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Letter_Modifier()
        {
            TestTokenizer("ᵊfoo", new CSharpSymbol(0, 0, 0, "ᵊfoo", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Other_Letter()
        {
            TestTokenizer("ƻfoo", new CSharpSymbol(0, 0, 0, "ƻfoo", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Number_Letter()
        {
            TestTokenizer("Ⅽool", new CSharpSymbol(0, 0, 0, "Ⅽool", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Non_Spacing_Mark()
        {
            TestTokenizer("foo\u0300", new CSharpSymbol(0, 0, 0, "foo\u0300", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Spacing_Combining_Mark()
        {
            TestTokenizer("fooः", new CSharpSymbol(0, 0, 0, "fooः", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Non_English_Digit()
        {
            TestTokenizer("foo١", new CSharpSymbol(0, 0, 0, "foo١", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Connector_Punctuation()
        {
            TestTokenizer("foo‿bar", new CSharpSymbol(0, 0, 0, "foo‿bar", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Format_Character()
        {
            TestTokenizer("foo؃bar", new CSharpSymbol(0, 0, 0, "foo؃bar", CSharpSymbolType.Identifier));
        }

        [Fact]
        public void Keywords_Are_Recognized_As_Keyword_Tokens()
        {
            TestKeyword("abstract", CSharpKeyword.Abstract);
            TestKeyword("byte", CSharpKeyword.Byte);
            TestKeyword("class", CSharpKeyword.Class);
            TestKeyword("delegate", CSharpKeyword.Delegate);
            TestKeyword("event", CSharpKeyword.Event);
            TestKeyword("fixed", CSharpKeyword.Fixed);
            TestKeyword("if", CSharpKeyword.If);
            TestKeyword("internal", CSharpKeyword.Internal);
            TestKeyword("new", CSharpKeyword.New);
            TestKeyword("override", CSharpKeyword.Override);
            TestKeyword("readonly", CSharpKeyword.Readonly);
            TestKeyword("short", CSharpKeyword.Short);
            TestKeyword("struct", CSharpKeyword.Struct);
            TestKeyword("try", CSharpKeyword.Try);
            TestKeyword("unsafe", CSharpKeyword.Unsafe);
            TestKeyword("volatile", CSharpKeyword.Volatile);
            TestKeyword("as", CSharpKeyword.As);
            TestKeyword("do", CSharpKeyword.Do);
            TestKeyword("is", CSharpKeyword.Is);
            TestKeyword("params", CSharpKeyword.Params);
            TestKeyword("ref", CSharpKeyword.Ref);
            TestKeyword("switch", CSharpKeyword.Switch);
            TestKeyword("ushort", CSharpKeyword.Ushort);
            TestKeyword("while", CSharpKeyword.While);
            TestKeyword("case", CSharpKeyword.Case);
            TestKeyword("const", CSharpKeyword.Const);
            TestKeyword("explicit", CSharpKeyword.Explicit);
            TestKeyword("float", CSharpKeyword.Float);
            TestKeyword("null", CSharpKeyword.Null);
            TestKeyword("sizeof", CSharpKeyword.Sizeof);
            TestKeyword("typeof", CSharpKeyword.Typeof);
            TestKeyword("implicit", CSharpKeyword.Implicit);
            TestKeyword("private", CSharpKeyword.Private);
            TestKeyword("this", CSharpKeyword.This);
            TestKeyword("using", CSharpKeyword.Using);
            TestKeyword("extern", CSharpKeyword.Extern);
            TestKeyword("return", CSharpKeyword.Return);
            TestKeyword("stackalloc", CSharpKeyword.Stackalloc);
            TestKeyword("uint", CSharpKeyword.Uint);
            TestKeyword("base", CSharpKeyword.Base);
            TestKeyword("catch", CSharpKeyword.Catch);
            TestKeyword("continue", CSharpKeyword.Continue);
            TestKeyword("double", CSharpKeyword.Double);
            TestKeyword("for", CSharpKeyword.For);
            TestKeyword("in", CSharpKeyword.In);
            TestKeyword("lock", CSharpKeyword.Lock);
            TestKeyword("object", CSharpKeyword.Object);
            TestKeyword("protected", CSharpKeyword.Protected);
            TestKeyword("static", CSharpKeyword.Static);
            TestKeyword("false", CSharpKeyword.False);
            TestKeyword("public", CSharpKeyword.Public);
            TestKeyword("sbyte", CSharpKeyword.Sbyte);
            TestKeyword("throw", CSharpKeyword.Throw);
            TestKeyword("virtual", CSharpKeyword.Virtual);
            TestKeyword("decimal", CSharpKeyword.Decimal);
            TestKeyword("else", CSharpKeyword.Else);
            TestKeyword("operator", CSharpKeyword.Operator);
            TestKeyword("string", CSharpKeyword.String);
            TestKeyword("ulong", CSharpKeyword.Ulong);
            TestKeyword("bool", CSharpKeyword.Bool);
            TestKeyword("char", CSharpKeyword.Char);
            TestKeyword("default", CSharpKeyword.Default);
            TestKeyword("foreach", CSharpKeyword.Foreach);
            TestKeyword("long", CSharpKeyword.Long);
            TestKeyword("void", CSharpKeyword.Void);
            TestKeyword("enum", CSharpKeyword.Enum);
            TestKeyword("finally", CSharpKeyword.Finally);
            TestKeyword("int", CSharpKeyword.Int);
            TestKeyword("out", CSharpKeyword.Out);
            TestKeyword("sealed", CSharpKeyword.Sealed);
            TestKeyword("true", CSharpKeyword.True);
            TestKeyword("goto", CSharpKeyword.Goto);
            TestKeyword("unchecked", CSharpKeyword.Unchecked);
            TestKeyword("interface", CSharpKeyword.Interface);
            TestKeyword("break", CSharpKeyword.Break);
            TestKeyword("checked", CSharpKeyword.Checked);
            TestKeyword("namespace", CSharpKeyword.Namespace);
        }

        private void TestKeyword(string keyword, CSharpKeyword keywordType)
        {
            TestTokenizer(keyword, new CSharpSymbol(0, 0, 0, keyword, CSharpSymbolType.Keyword) { Keyword = keywordType });
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/CSharpTokenizerLiteralTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class CSharpTokenizerLiteralTest : CSharpTokenizerTestBase
    {
        [Fact]
        public void Simple_Integer_Literal_Is_Recognized()
        {
            TestSingleToken("01189998819991197253", CSharpSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Integer_Type_Suffix_Is_Recognized()
        {
            TestSingleToken("42U", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("42u", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("42L", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("42l", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("42UL", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("42Ul", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("42uL", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("42ul", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("42LU", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("42Lu", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("42lU", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("42lu", CSharpSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Trailing_Letter_Is_Not_Part_Of_Integer_Literal_If_Not_Type_Sufix()
        {
            TestTokenizer("42a", new CSharpSymbol(0, 0, 0, "42", CSharpSymbolType.IntegerLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Simple_Hex_Literal_Is_Recognized()
        {
            TestSingleToken("0x0123456789ABCDEF", CSharpSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Integer_Type_Suffix_Is_Recognized_In_Hex_Literal()
        {
            TestSingleToken("0xDEADBEEFU", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("0xDEADBEEFu", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("0xDEADBEEFL", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("0xDEADBEEFl", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("0xDEADBEEFUL", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("0xDEADBEEFUl", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("0xDEADBEEFuL", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("0xDEADBEEFul", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("0xDEADBEEFLU", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("0xDEADBEEFLu", CSharpSymbolType.IntegerLiteral);

            TestSingleToken("0xDEADBEEFlU", CSharpSymbolType.IntegerLiteral);
            TestSingleToken("0xDEADBEEFlu", CSharpSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Trailing_Letter_Is_Not_Part_Of_Hex_Literal_If_Not_Type_Sufix()
        {
            TestTokenizer("0xDEADBEEFz", new CSharpSymbol(0, 0, 0, "0xDEADBEEF", CSharpSymbolType.IntegerLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Dot_Followed_By_Non_Digit_Is_Not_Part_Of_Real_Literal()
        {
            TestTokenizer("3.a", new CSharpSymbol(0, 0, 0, "3", CSharpSymbolType.IntegerLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Simple_Real_Literal_Is_Recognized()
        {
            TestTokenizer("3.14159", new CSharpSymbol(0, 0, 0, "3.14159", CSharpSymbolType.RealLiteral));
        }

        [Fact]
        public void Real_Literal_Between_Zero_And_One_Is_Recognized()
        {
            TestTokenizer(".14159", new CSharpSymbol(0, 0, 0, ".14159", CSharpSymbolType.RealLiteral));
        }

        [Fact]
        public void Integer_With_Real_Type_Suffix_Is_Recognized()
        {
            TestSingleToken("42F", CSharpSymbolType.RealLiteral);
            TestSingleToken("42f", CSharpSymbolType.RealLiteral);
            TestSingleToken("42D", CSharpSymbolType.RealLiteral);
            TestSingleToken("42d", CSharpSymbolType.RealLiteral);
            TestSingleToken("42M", CSharpSymbolType.RealLiteral);
            TestSingleToken("42m", CSharpSymbolType.RealLiteral);
        }

        [Fact]
        public void Integer_With_Exponent_Is_Recognized()
        {
            TestSingleToken("1e10", CSharpSymbolType.RealLiteral);
            TestSingleToken("1E10", CSharpSymbolType.RealLiteral);
            TestSingleToken("1e+10", CSharpSymbolType.RealLiteral);
            TestSingleToken("1E+10", CSharpSymbolType.RealLiteral);
            TestSingleToken("1e-10", CSharpSymbolType.RealLiteral);
            TestSingleToken("1E-10", CSharpSymbolType.RealLiteral);
        }

        [Fact]
        public void Real_Number_With_Type_Suffix_Is_Recognized()
        {
            TestSingleToken("3.14F", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14f", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14D", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14d", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14M", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14m", CSharpSymbolType.RealLiteral);
        }

        [Fact]
        public void Real_Number_With_Exponent_Is_Recognized()
        {
            TestSingleToken("3.14E10", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14e10", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14E+10", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14e+10", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14E-10", CSharpSymbolType.RealLiteral);
            TestSingleToken("3.14e-10", CSharpSymbolType.RealLiteral);
        }

        [Fact]
        public void Real_Number_With_Exponent_And_Type_Suffix_Is_Recognized()
        {
            TestSingleToken("3.14E+10F", CSharpSymbolType.RealLiteral);
        }

        [Fact]
        public void Single_Character_Literal_Is_Recognized()
        {
            TestSingleToken("'f'", CSharpSymbolType.CharacterLiteral);
        }

        [Fact]
        public void Multi_Character_Literal_Is_Recognized()
        {
            TestSingleToken("'foo'", CSharpSymbolType.CharacterLiteral);
        }

        [Fact]
        public void Character_Literal_Is_Terminated_By_EOF_If_Unterminated()
        {
            TestSingleToken("'foo bar", CSharpSymbolType.CharacterLiteral);
        }

        [Fact]
        public void Character_Literal_Not_Terminated_By_Escaped_Quote()
        {
            TestSingleToken("'foo\\'bar'", CSharpSymbolType.CharacterLiteral);
        }

        [Fact]
        public void Character_Literal_Is_Terminated_By_EOL_If_Unterminated()
        {
            TestTokenizer("'foo\n", new CSharpSymbol(0, 0, 0, "'foo", CSharpSymbolType.CharacterLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Character_Literal_Terminated_By_EOL_Even_When_Last_Char_Is_Slash()
        {
            TestTokenizer("'foo\\\n", new CSharpSymbol(0, 0, 0, "'foo\\", CSharpSymbolType.CharacterLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Character_Literal_Terminated_By_EOL_Even_When_Last_Char_Is_Slash_And_Followed_By_Stuff()
        {
            TestTokenizer("'foo\\\nflarg", new CSharpSymbol(0, 0, 0, "'foo\\", CSharpSymbolType.CharacterLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Character_Literal_Terminated_By_CRLF_Even_When_Last_Char_Is_Slash()
        {
            TestTokenizer("'foo\\\r\n", new CSharpSymbol(0, 0, 0, "'foo\\", CSharpSymbolType.CharacterLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Character_Literal_Terminated_By_CRLF_Even_When_Last_Char_Is_Slash_And_Followed_By_Stuff()
        {
            TestTokenizer("'foo\\\r\nflarg", new CSharpSymbol(0, 0, 0, "'foo\\", CSharpSymbolType.CharacterLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Character_Literal_Allows_Escaped_Escape()
        {
            TestTokenizer("'foo\\\\'blah", new CSharpSymbol(0, 0, 0, "'foo\\\\'", CSharpSymbolType.CharacterLiteral), IgnoreRemaining);
        }

        [Fact]
        public void String_Literal_Is_Recognized()
        {
            TestSingleToken("\"foo\"", CSharpSymbolType.StringLiteral);
        }

        [Fact]
        public void String_Literal_Is_Terminated_By_EOF_If_Unterminated()
        {
            TestSingleToken("\"foo bar", CSharpSymbolType.StringLiteral);
        }

        [Fact]
        public void String_Literal_Not_Terminated_By_Escaped_Quote()
        {
            TestSingleToken("\"foo\\\"bar\"", CSharpSymbolType.StringLiteral);
        }

        [Fact]
        public void String_Literal_Is_Terminated_By_EOL_If_Unterminated()
        {
            TestTokenizer("\"foo\n", new CSharpSymbol(0, 0, 0, "\"foo", CSharpSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void String_Literal_Terminated_By_EOL_Even_When_Last_Char_Is_Slash()
        {
            TestTokenizer("\"foo\\\n", new CSharpSymbol(0, 0, 0, "\"foo\\", CSharpSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void String_Literal_Terminated_By_EOL_Even_When_Last_Char_Is_Slash_And_Followed_By_Stuff()
        {
            TestTokenizer("\"foo\\\nflarg", new CSharpSymbol(0, 0, 0, "\"foo\\", CSharpSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void String_Literal_Terminated_By_CRLF_Even_When_Last_Char_Is_Slash()
        {
            TestTokenizer("\"foo\\\r\n", new CSharpSymbol(0, 0, 0, "\"foo\\", CSharpSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void String_Literal_Terminated_By_CRLF_Even_When_Last_Char_Is_Slash_And_Followed_By_Stuff()
        {
            TestTokenizer("\"foo\\\r\nflarg", new CSharpSymbol(0, 0, 0, "\"foo\\", CSharpSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void String_Literal_Allows_Escaped_Escape()
        {
            TestTokenizer("\"foo\\\\\"blah", new CSharpSymbol(0, 0, 0, "\"foo\\\\\"", CSharpSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Verbatim_String_Literal_Can_Contain_Newlines()
        {
            TestSingleToken("@\"foo\nbar\nbaz\"", CSharpSymbolType.StringLiteral);
        }

        [Fact]
        public void Verbatim_String_Literal_Not_Terminated_By_Escaped_Double_Quote()
        {
            TestSingleToken("@\"foo\"\"bar\"", CSharpSymbolType.StringLiteral);
        }

        [Fact]
        public void Verbatim_String_Literal_Is_Terminated_By_Slash_Double_Quote()
        {
            TestTokenizer("@\"foo\\\"bar\"", new CSharpSymbol(0, 0, 0, "@\"foo\\\"", CSharpSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Verbatim_String_Literal_Is_Terminated_By_EOF()
        {
            TestSingleToken("@\"foo", CSharpSymbolType.StringLiteral);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/CSharpTokenizerOperatorsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class CSharpTokenizerOperatorsTest : CSharpTokenizerTestBase
    {
        [Fact]
        public void LeftBrace_Is_Recognized()
        {
            TestSingleToken("{", CSharpSymbolType.LeftBrace);
        }

        [Fact]
        public void Plus_Is_Recognized()
        {
            TestSingleToken("+", CSharpSymbolType.Plus);
        }

        [Fact]
        public void Assign_Is_Recognized()
        {
            TestSingleToken("=", CSharpSymbolType.Assign);
        }

        [Fact]
        public void Arrow_Is_Recognized()
        {
            TestSingleToken("->", CSharpSymbolType.Arrow);
        }

        [Fact]
        public void AndAssign_Is_Recognized()
        {
            TestSingleToken("&=", CSharpSymbolType.AndAssign);
        }

        [Fact]
        public void RightBrace_Is_Recognized()
        {
            TestSingleToken("}", CSharpSymbolType.RightBrace);
        }

        [Fact]
        public void Minus_Is_Recognized()
        {
            TestSingleToken("-", CSharpSymbolType.Minus);
        }

        [Fact]
        public void LessThan_Is_Recognized()
        {
            TestSingleToken("<", CSharpSymbolType.LessThan);
        }

        [Fact]
        public void Equals_Is_Recognized()
        {
            TestSingleToken("==", CSharpSymbolType.Equals);
        }

        [Fact]
        public void OrAssign_Is_Recognized()
        {
            TestSingleToken("|=", CSharpSymbolType.OrAssign);
        }

        [Fact]
        public void LeftBracket_Is_Recognized()
        {
            TestSingleToken("[", CSharpSymbolType.LeftBracket);
        }

        [Fact]
        public void Star_Is_Recognized()
        {
            TestSingleToken("*", CSharpSymbolType.Star);
        }

        [Fact]
        public void GreaterThan_Is_Recognized()
        {
            TestSingleToken(">", CSharpSymbolType.GreaterThan);
        }

        [Fact]
        public void NotEqual_Is_Recognized()
        {
            TestSingleToken("!=", CSharpSymbolType.NotEqual);
        }

        [Fact]
        public void XorAssign_Is_Recognized()
        {
            TestSingleToken("^=", CSharpSymbolType.XorAssign);
        }

        [Fact]
        public void RightBracket_Is_Recognized()
        {
            TestSingleToken("]", CSharpSymbolType.RightBracket);
        }

        [Fact]
        public void Slash_Is_Recognized()
        {
            TestSingleToken("/", CSharpSymbolType.Slash);
        }

        [Fact]
        public void QuestionMark_Is_Recognized()
        {
            TestSingleToken("?", CSharpSymbolType.QuestionMark);
        }

        [Fact]
        public void LessThanEqual_Is_Recognized()
        {
            TestSingleToken("<=", CSharpSymbolType.LessThanEqual);
        }

        [Fact]
        public void LeftShift_Is_Not_Specially_Recognized()
        {
            TestTokenizer("<<",
                new CSharpSymbol(0, 0, 0, "<", CSharpSymbolType.LessThan),
                new CSharpSymbol(1, 0, 1, "<", CSharpSymbolType.LessThan));
        }

        [Fact]
        public void LeftParen_Is_Recognized()
        {
            TestSingleToken("(", CSharpSymbolType.LeftParenthesis);
        }

        [Fact]
        public void Modulo_Is_Recognized()
        {
            TestSingleToken("%", CSharpSymbolType.Modulo);
        }

        [Fact]
        public void NullCoalesce_Is_Recognized()
        {
            TestSingleToken("??", CSharpSymbolType.NullCoalesce);
        }

        [Fact]
        public void GreaterThanEqual_Is_Recognized()
        {
            TestSingleToken(">=", CSharpSymbolType.GreaterThanEqual);
        }

        [Fact]
        public void EqualGreaterThan_Is_Recognized()
        {
            TestSingleToken("=>", CSharpSymbolType.GreaterThanEqual);
        }

        [Fact]
        public void RightParen_Is_Recognized()
        {
            TestSingleToken(")", CSharpSymbolType.RightParenthesis);
        }

        [Fact]
        public void And_Is_Recognized()
        {
            TestSingleToken("&", CSharpSymbolType.And);
        }

        [Fact]
        public void DoubleColon_Is_Recognized()
        {
            TestSingleToken("::", CSharpSymbolType.DoubleColon);
        }

        [Fact]
        public void PlusAssign_Is_Recognized()
        {
            TestSingleToken("+=", CSharpSymbolType.PlusAssign);
        }

        [Fact]
        public void Semicolon_Is_Recognized()
        {
            TestSingleToken(";", CSharpSymbolType.Semicolon);
        }

        [Fact]
        public void Tilde_Is_Recognized()
        {
            TestSingleToken("~", CSharpSymbolType.Tilde);
        }

        [Fact]
        public void DoubleOr_Is_Recognized()
        {
            TestSingleToken("||", CSharpSymbolType.DoubleOr);
        }

        [Fact]
        public void ModuloAssign_Is_Recognized()
        {
            TestSingleToken("%=", CSharpSymbolType.ModuloAssign);
        }

        [Fact]
        public void Colon_Is_Recognized()
        {
            TestSingleToken(":", CSharpSymbolType.Colon);
        }

        [Fact]
        public void Not_Is_Recognized()
        {
            TestSingleToken("!", CSharpSymbolType.Not);
        }

        [Fact]
        public void DoubleAnd_Is_Recognized()
        {
            TestSingleToken("&&", CSharpSymbolType.DoubleAnd);
        }

        [Fact]
        public void DivideAssign_Is_Recognized()
        {
            TestSingleToken("/=", CSharpSymbolType.DivideAssign);
        }

        [Fact]
        public void Comma_Is_Recognized()
        {
            TestSingleToken(",", CSharpSymbolType.Comma);
        }

        [Fact]
        public void Xor_Is_Recognized()
        {
            TestSingleToken("^", CSharpSymbolType.Xor);
        }

        [Fact]
        public void Decrement_Is_Recognized()
        {
            TestSingleToken("--", CSharpSymbolType.Decrement);
        }

        [Fact]
        public void MultiplyAssign_Is_Recognized()
        {
            TestSingleToken("*=", CSharpSymbolType.MultiplyAssign);
        }

        [Fact]
        public void Dot_Is_Recognized()
        {
            TestSingleToken(".", CSharpSymbolType.Dot);
        }

        [Fact]
        public void Or_Is_Recognized()
        {
            TestSingleToken("|", CSharpSymbolType.Or);
        }

        [Fact]
        public void Increment_Is_Recognized()
        {
            TestSingleToken("++", CSharpSymbolType.Increment);
        }

        [Fact]
        public void MinusAssign_Is_Recognized()
        {
            TestSingleToken("-=", CSharpSymbolType.MinusAssign);
        }

        [Fact]
        public void RightShift_Is_Not_Specially_Recognized()
        {
            TestTokenizer(">>",
                new CSharpSymbol(0, 0, 0, ">", CSharpSymbolType.GreaterThan),
                new CSharpSymbol(1, 0, 1, ">", CSharpSymbolType.GreaterThan));
        }

        [Fact]
        public void Hash_Is_Recognized()
        {
            TestSingleToken("#", CSharpSymbolType.Hash);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/CSharpTokenizerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class CSharpTokenizerTest : CSharpTokenizerTestBase
    {
        [Fact]
        public void Constructor_Throws_ArgNull_If_Null_Source_Provided()
        {
            Assert.ThrowsArgumentNull(() => new CSharpTokenizer(null), "source");
        }

        [Fact]
        public void Next_Returns_Null_When_EOF_Reached()
        {
            TestTokenizer("");
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_CR()
        {
            TestTokenizer("\r\ra",
                          new CSharpSymbol(0, 0, 0, "\r", CSharpSymbolType.NewLine),
                          new CSharpSymbol(1, 1, 0, "\r", CSharpSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_LF()
        {
            TestTokenizer("\n\na",
                          new CSharpSymbol(0, 0, 0, "\n", CSharpSymbolType.NewLine),
                          new CSharpSymbol(1, 1, 0, "\n", CSharpSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_NEL()
        {
            // NEL: Unicode "Next Line" U+0085
            TestTokenizer("\u0085\u0085a",
                          new CSharpSymbol(0, 0, 0, "\u0085", CSharpSymbolType.NewLine),
                          new CSharpSymbol(1, 1, 0, "\u0085", CSharpSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_Line_Separator()
        {
            // Unicode "Line Separator" U+2028
            TestTokenizer("\u2028\u2028a",
                          new CSharpSymbol(0, 0, 0, "\u2028", CSharpSymbolType.NewLine),
                          new CSharpSymbol(1, 1, 0, "\u2028", CSharpSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_Paragraph_Separator()
        {
            // Unicode "Paragraph Separator" U+2029
            TestTokenizer("\u2029\u2029a",
                          new CSharpSymbol(0, 0, 0, "\u2029", CSharpSymbolType.NewLine),
                          new CSharpSymbol(1, 1, 0, "\u2029", CSharpSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Single_Newline_Token_For_CRLF()
        {
            TestTokenizer("\r\n\r\na",
                          new CSharpSymbol(0, 0, 0, "\r\n", CSharpSymbolType.NewLine),
                          new CSharpSymbol(2, 1, 0, "\r\n", CSharpSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Token_For_Whitespace_Characters()
        {
            TestTokenizer(" \f\t\u000B \n ",
                          new CSharpSymbol(0, 0, 0, " \f\t\u000B ", CSharpSymbolType.WhiteSpace),
                          new CSharpSymbol(5, 0, 5, "\n", CSharpSymbolType.NewLine),
                          new CSharpSymbol(6, 1, 0, " ", CSharpSymbolType.WhiteSpace));
        }

        [Fact]
        public void Transition_Is_Recognized()
        {
            TestSingleToken("@", CSharpSymbolType.Transition);
        }

        [Fact]
        public void Transition_Is_Recognized_As_SingleCharacter()
        {
            TestTokenizer("@(",
                          new CSharpSymbol(0, 0, 0, "@", CSharpSymbolType.Transition),
                          new CSharpSymbol(1, 0, 1, "(", CSharpSymbolType.LeftParenthesis));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/CSharpTokenizerTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Test.Tokenizer
{
    public abstract class CSharpTokenizerTestBase : TokenizerTestBase<CSharpSymbol, CSharpSymbolType>
    {
        private static CSharpSymbol _ignoreRemaining = new CSharpSymbol(0, 0, 0, String.Empty, CSharpSymbolType.Unknown);

        protected override CSharpSymbol IgnoreRemaining
        {
            get { return _ignoreRemaining; }
        }

        protected override Tokenizer<CSharpSymbol, CSharpSymbolType> CreateTokenizer(ITextDocument source)
        {
            return new CSharpTokenizer(source);
        }

        protected void TestSingleToken(string text, CSharpSymbolType expectedSymbolType)
        {
            TestTokenizer(text, new CSharpSymbol(0, 0, 0, text, expectedSymbolType));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/HtmlTokenizerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class HtmlTokenizerTest : HtmlTokenizerTestBase
    {
        [Fact]
        public void Constructor_Throws_ArgNull_If_Null_Source_Provided()
        {
            Assert.ThrowsArgumentNull(() => new HtmlTokenizer(null), "source");
        }

        [Fact]
        public void Next_Returns_Null_When_EOF_Reached()
        {
            TestTokenizer("");
        }

        [Fact]
        public void Text_Is_Recognized()
        {
            TestTokenizer("foo-9309&smlkmb;::-3029022,.sdkq92384",
                          new HtmlSymbol(0, 0, 0, "foo-9309&smlkmb;::-3029022,.sdkq92384", HtmlSymbolType.Text));
        }

        [Fact]
        public void Whitespace_Is_Recognized()
        {
            TestTokenizer(" \t\f ",
                          new HtmlSymbol(0, 0, 0, " \t\f ", HtmlSymbolType.WhiteSpace));
        }

        [Fact]
        public void Newline_Is_Recognized()
        {
            TestTokenizer("\n\r\r\n",
                          new HtmlSymbol(0, 0, 0, "\n", HtmlSymbolType.NewLine),
                          new HtmlSymbol(1, 1, 0, "\r", HtmlSymbolType.NewLine),
                          new HtmlSymbol(2, 2, 0, "\r\n", HtmlSymbolType.NewLine));
        }

        [Fact]
        public void Transition_Is_Not_Recognized_Mid_Text_If_Surrounded_By_Alphanumeric_Characters()
        {
            TestSingleToken("foo@bar", HtmlSymbolType.Text);
        }

        [Fact]
        public void OpenAngle_Is_Recognized()
        {
            TestSingleToken("<", HtmlSymbolType.OpenAngle);
        }

        [Fact]
        public void Bang_Is_Recognized()
        {
            TestSingleToken("!", HtmlSymbolType.Bang);
        }

        [Fact]
        public void Solidus_Is_Recognized()
        {
            TestSingleToken("/", HtmlSymbolType.Solidus);
        }

        [Fact]
        public void QuestionMark_Is_Recognized()
        {
            TestSingleToken("?", HtmlSymbolType.QuestionMark);
        }

        [Fact]
        public void LeftBracket_Is_Recognized()
        {
            TestSingleToken("[", HtmlSymbolType.LeftBracket);
        }

        [Fact]
        public void CloseAngle_Is_Recognized()
        {
            TestSingleToken(">", HtmlSymbolType.CloseAngle);
        }

        [Fact]
        public void RightBracket_Is_Recognized()
        {
            TestSingleToken("]", HtmlSymbolType.RightBracket);
        }

        [Fact]
        public void Equals_Is_Recognized()
        {
            TestSingleToken("=", HtmlSymbolType.Equals);
        }

        [Fact]
        public void DoubleQuote_Is_Recognized()
        {
            TestSingleToken("\"", HtmlSymbolType.DoubleQuote);
        }

        [Fact]
        public void SingleQuote_Is_Recognized()
        {
            TestSingleToken("'", HtmlSymbolType.SingleQuote);
        }

        [Fact]
        public void Transition_Is_Recognized()
        {
            TestSingleToken("@", HtmlSymbolType.Transition);
        }

        [Fact]
        public void DoubleHyphen_Is_Recognized()
        {
            TestSingleToken("--", HtmlSymbolType.DoubleHyphen);
        }

        [Fact]
        public void SingleHyphen_Is_Not_Recognized()
        {
            TestSingleToken("-", HtmlSymbolType.Text);
        }

        [Fact]
        public void SingleHyphen_Mid_Text_Is_Not_Recognized_As_Separate_Token()
        {
            TestSingleToken("foo-bar", HtmlSymbolType.Text);
        }

        [Fact]
        public void Next_Ignores_Star_At_EOF_In_RazorComment()
        {
            TestTokenizer("@* Foo * Bar * Baz *",
                          new HtmlSymbol(0, 0, 0, "@", HtmlSymbolType.RazorCommentTransition),
                          new HtmlSymbol(1, 0, 1, "*", HtmlSymbolType.RazorCommentStar),
                          new HtmlSymbol(2, 0, 2, " Foo * Bar * Baz *", HtmlSymbolType.RazorComment));
        }

        [Fact]
        public void Next_Ignores_Star_Without_Trailing_At()
        {
            TestTokenizer("@* Foo * Bar * Baz *@",
                          new HtmlSymbol(0, 0, 0, "@", HtmlSymbolType.RazorCommentTransition),
                          new HtmlSymbol(1, 0, 1, "*", HtmlSymbolType.RazorCommentStar),
                          new HtmlSymbol(2, 0, 2, " Foo * Bar * Baz ", HtmlSymbolType.RazorComment),
                          new HtmlSymbol(19, 0, 19, "*", HtmlSymbolType.RazorCommentStar),
                          new HtmlSymbol(20, 0, 20, "@", HtmlSymbolType.RazorCommentTransition));
        }

        [Fact]
        public void Next_Returns_RazorComment_Token_For_Entire_Razor_Comment()
        {
            TestTokenizer("@* Foo Bar Baz *@",
                          new HtmlSymbol(0, 0, 0, "@", HtmlSymbolType.RazorCommentTransition),
                          new HtmlSymbol(1, 0, 1, "*", HtmlSymbolType.RazorCommentStar),
                          new HtmlSymbol(2, 0, 2, " Foo Bar Baz ", HtmlSymbolType.RazorComment),
                          new HtmlSymbol(15, 0, 15, "*", HtmlSymbolType.RazorCommentStar),
                          new HtmlSymbol(16, 0, 16, "@", HtmlSymbolType.RazorCommentTransition));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/HtmlTokenizerTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Test.Tokenizer
{
    public abstract class HtmlTokenizerTestBase : TokenizerTestBase<HtmlSymbol, HtmlSymbolType>
    {
        private static HtmlSymbol _ignoreRemaining = new HtmlSymbol(0, 0, 0, String.Empty, HtmlSymbolType.Unknown);

        protected override HtmlSymbol IgnoreRemaining
        {
            get { return _ignoreRemaining; }
        }

        protected override Tokenizer<HtmlSymbol, HtmlSymbolType> CreateTokenizer(ITextDocument source)
        {
            return new HtmlTokenizer(source);
        }

        protected void TestSingleToken(string text, HtmlSymbolType expectedSymbolType)
        {
            TestTokenizer(text, new HtmlSymbol(0, 0, 0, text, expectedSymbolType));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/TokenizerLookaheadTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class TokenizerLookaheadTest : HtmlTokenizerTestBase
    {
        [Fact]
        public void After_Cancelling_Lookahead_Tokenizer_Returns_Same_Tokens_As_It_Did_Before_Lookahead()
        {
            HtmlTokenizer tokenizer = new HtmlTokenizer(new SeekableTextReader(new StringReader("<foo>")));
            using (tokenizer.Source.BeginLookahead())
            {
                Assert.Equal(new HtmlSymbol(0, 0, 0, "<", HtmlSymbolType.OpenAngle), tokenizer.NextSymbol());
                Assert.Equal(new HtmlSymbol(1, 0, 1, "foo", HtmlSymbolType.Text), tokenizer.NextSymbol());
                Assert.Equal(new HtmlSymbol(4, 0, 4, ">", HtmlSymbolType.CloseAngle), tokenizer.NextSymbol());
            }
            Assert.Equal(new HtmlSymbol(0, 0, 0, "<", HtmlSymbolType.OpenAngle), tokenizer.NextSymbol());
            Assert.Equal(new HtmlSymbol(1, 0, 1, "foo", HtmlSymbolType.Text), tokenizer.NextSymbol());
            Assert.Equal(new HtmlSymbol(4, 0, 4, ">", HtmlSymbolType.CloseAngle), tokenizer.NextSymbol());
        }

        [Fact]
        public void After_Accepting_Lookahead_Tokenizer_Returns_Next_Token()
        {
            HtmlTokenizer tokenizer = new HtmlTokenizer(new SeekableTextReader(new StringReader("<foo>")));
            using (LookaheadToken lookahead = tokenizer.Source.BeginLookahead())
            {
                Assert.Equal(new HtmlSymbol(0, 0, 0, "<", HtmlSymbolType.OpenAngle), tokenizer.NextSymbol());
                Assert.Equal(new HtmlSymbol(1, 0, 1, "foo", HtmlSymbolType.Text), tokenizer.NextSymbol());
                lookahead.Accept();
            }
            Assert.Equal(new HtmlSymbol(4, 0, 4, ">", HtmlSymbolType.CloseAngle), tokenizer.NextSymbol());
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/TokenizerTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.IO;
using System.Text;
using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public abstract class TokenizerTestBase<TSymbol, TSymbolType>
        where TSymbol : SymbolBase<TSymbolType>
    {
        protected abstract TSymbol IgnoreRemaining { get; }
        protected abstract Tokenizer<TSymbol, TSymbolType> CreateTokenizer(ITextDocument source);

        protected void TestTokenizer(string input, params TSymbol[] expectedSymbols)
        {
            // Arrange
            bool success = true;
            StringBuilder output = new StringBuilder();
            using (StringReader reader = new StringReader(input))
            {
                using (SeekableTextReader source = new SeekableTextReader(reader))
                {
                    Tokenizer<TSymbol, TSymbolType> tokenizer = CreateTokenizer(source);
                    int counter = 0;
                    TSymbol current = null;
                    while ((current = tokenizer.NextSymbol()) != null)
                    {
                        if (counter >= expectedSymbols.Length)
                        {
                            output.AppendLine(String.Format("F: Expected: << Nothing >>; Actual: {0}", current));
                            success = false;
                        }
                        else if (ReferenceEquals(expectedSymbols[counter], IgnoreRemaining))
                        {
                            output.AppendLine(String.Format("P: Ignored {0}", current));
                        }
                        else
                        {
                            if (!Equals(expectedSymbols[counter], current))
                            {
                                output.AppendLine(String.Format("F: Expected: {0}; Actual: {1}", expectedSymbols[counter], current));
                                success = false;
                            }
                            else
                            {
                                output.AppendLine(String.Format("P: Expected: {0}", expectedSymbols[counter]));
                            }
                            counter++;
                        }
                    }
                    if (counter < expectedSymbols.Length && !ReferenceEquals(expectedSymbols[counter], IgnoreRemaining))
                    {
                        success = false;
                        for (; counter < expectedSymbols.Length; counter++)
                        {
                            output.AppendLine(String.Format("F: Expected: {0}; Actual: << None >>", expectedSymbols[counter]));
                        }
                    }
                }
            }
            Assert.True(success, "\r\n" + output.ToString());
            WriteTraceLine(output.Replace("{", "{{").Replace("}", "}}").ToString());
        }

        [Conditional("PARSER_TRACE")]
        private static void WriteTraceLine(string format, params object[] args)
        {
            Trace.WriteLine(String.Format(format, args));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/VBTokenizerCommentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class VBTokenizerCommentTest : VBTokenizerTestBase
    {
        [Fact]
        public void Next_Ignores_Star_At_EOF_In_RazorComment()
        {
            TestTokenizer("@* Foo * Bar * Baz *",
                          new VBSymbol(0, 0, 0, "@", VBSymbolType.RazorCommentTransition),
                          new VBSymbol(1, 0, 1, "*", VBSymbolType.RazorCommentStar),
                          new VBSymbol(2, 0, 2, " Foo * Bar * Baz *", VBSymbolType.RazorComment));
        }

        [Fact]
        public void Next_Ignores_Star_Without_Trailing_At()
        {
            TestTokenizer("@* Foo * Bar * Baz *@",
                          new VBSymbol(0, 0, 0, "@", VBSymbolType.RazorCommentTransition),
                          new VBSymbol(1, 0, 1, "*", VBSymbolType.RazorCommentStar),
                          new VBSymbol(2, 0, 2, " Foo * Bar * Baz ", VBSymbolType.RazorComment),
                          new VBSymbol(19, 0, 19, "*", VBSymbolType.RazorCommentStar),
                          new VBSymbol(20, 0, 20, "@", VBSymbolType.RazorCommentTransition));
        }

        [Fact]
        public void Next_Returns_RazorComment_Token_For_Entire_Razor_Comment()
        {
            TestTokenizer("@* Foo Bar Baz *@",
                          new VBSymbol(0, 0, 0, "@", VBSymbolType.RazorCommentTransition),
                          new VBSymbol(1, 0, 1, "*", VBSymbolType.RazorCommentStar),
                          new VBSymbol(2, 0, 2, " Foo Bar Baz ", VBSymbolType.RazorComment),
                          new VBSymbol(15, 0, 15, "*", VBSymbolType.RazorCommentStar),
                          new VBSymbol(16, 0, 16, "@", VBSymbolType.RazorCommentTransition));
        }

        [Fact]
        public void Tick_Comment_Is_Recognized()
        {
            TestTokenizer("' Foo Bar Baz", new VBSymbol(0, 0, 0, "' Foo Bar Baz", VBSymbolType.Comment));
        }

        [Fact]
        public void Tick_Comment_Is_Terminated_By_Newline()
        {
            TestTokenizer("' Foo Bar Baz\na", new VBSymbol(0, 0, 0, "' Foo Bar Baz", VBSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void LeftQuote_Comment_Is_Recognized()
        {
            // U+2018 - Left Quote: ‘
            TestTokenizer("‘ Foo Bar Baz", new VBSymbol(0, 0, 0, "‘ Foo Bar Baz", VBSymbolType.Comment));
        }

        [Fact]
        public void LeftQuote_Comment_Is_Terminated_By_Newline()
        {
            // U+2018 - Left Quote: ‘
            TestTokenizer("‘ Foo Bar Baz\na", new VBSymbol(0, 0, 0, "‘ Foo Bar Baz", VBSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void RightQuote_Comment_Is_Recognized()
        {
            // U+2019 - Right Quote: ’
            TestTokenizer("’ Foo Bar Baz", new VBSymbol(0, 0, 0, "’ Foo Bar Baz", VBSymbolType.Comment));
        }

        [Fact]
        public void RightQuote_Comment_Is_Terminated_By_Newline()
        {
            // U+2019 - Right Quote: ’
            TestTokenizer("’ Foo Bar Baz\na", new VBSymbol(0, 0, 0, "’ Foo Bar Baz", VBSymbolType.Comment), IgnoreRemaining);
        }

        [Fact]
        public void Rem_Comment_Is_Recognized()
        {
            TestTokenizer("REM Foo Bar Baz", new VBSymbol(0, 0, 0, "REM Foo Bar Baz", VBSymbolType.Comment));
        }

        [Fact]
        public void Rem_Comment_Is_Terminated_By_Newline()
        {
            TestTokenizer("REM Foo Bar Baz\na", new VBSymbol(0, 0, 0, "REM Foo Bar Baz", VBSymbolType.Comment), IgnoreRemaining);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/VBTokenizerIdentifierTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class VBTokenizerIdentifierTest : VBTokenizerTestBase
    {
        [Fact]
        public void Simple_Identifier_Is_Recognized()
        {
            TestTokenizer("foo", new VBSymbol(0, 0, 0, "foo", VBSymbolType.Identifier));
        }

        [Fact]
        public void Escaped_Identifier_Terminates_At_EOF()
        {
            TestTokenizer("[foo", new VBSymbol(0, 0, 0, "[foo", VBSymbolType.Identifier));
        }

        [Fact]
        public void Escaped_Identifier_Terminates_At_Whitespace()
        {
            TestTokenizer("[foo ", new VBSymbol(0, 0, 0, "[foo", VBSymbolType.Identifier), IgnoreRemaining);
        }

        [Fact]
        public void Escaped_Identifier_Terminates_At_RightBracket_And_Does_Not_Read_TypeCharacter()
        {
            TestTokenizer("[foo]&", new VBSymbol(0, 0, 0, "[foo]", VBSymbolType.Identifier), IgnoreRemaining);
        }

        [Fact]
        public void Identifier_Starting_With_Underscore_Is_Recognized()
        {
            TestTokenizer("_foo", new VBSymbol(0, 0, 0, "_foo", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Digits()
        {
            TestTokenizer("foo4", new VBSymbol(0, 0, 0, "foo4", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Titlecase_Letter()
        {
            TestTokenizer("ῼfoo", new VBSymbol(0, 0, 0, "ῼfoo", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Letter_Modifier()
        {
            TestTokenizer("ᵊfoo", new VBSymbol(0, 0, 0, "ᵊfoo", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Other_Letter()
        {
            TestTokenizer("ƻfoo", new VBSymbol(0, 0, 0, "ƻfoo", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Start_With_Number_Letter()
        {
            TestTokenizer("Ⅽool", new VBSymbol(0, 0, 0, "Ⅽool", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Non_Spacing_Mark()
        {
            TestTokenizer("foo\u0300", new VBSymbol(0, 0, 0, "foo\u0300", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Spacing_Combining_Mark()
        {
            TestTokenizer("fooः", new VBSymbol(0, 0, 0, "fooः", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Non_English_Digit()
        {
            TestTokenizer("foo١", new VBSymbol(0, 0, 0, "foo١", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Connector_Punctuation()
        {
            TestTokenizer("foo‿bar", new VBSymbol(0, 0, 0, "foo‿bar", VBSymbolType.Identifier));
        }

        [Fact]
        public void Identifier_Can_Contain_Format_Character()
        {
            TestTokenizer("foo؃bar", new VBSymbol(0, 0, 0, "foo؃bar", VBSymbolType.Identifier));
        }

        [Fact]
        public void Escaped_Keyword_Is_Recognized_As_Identifier()
        {
            TestSingleToken("[AddHandler]", VBSymbolType.Identifier);
        }

        [Fact]
        public void Keywords_Are_Recognized_As_Keyword_Tokens()
        {
            TestKeyword("AddHandler", VBKeyword.AddHandler);
            TestKeyword("AndAlso", VBKeyword.AndAlso);
            TestKeyword("Byte", VBKeyword.Byte);
            TestKeyword("Catch", VBKeyword.Catch);
            TestKeyword("CDate", VBKeyword.CDate);
            TestKeyword("CInt", VBKeyword.CInt);
            TestKeyword("Const", VBKeyword.Const);
            TestKeyword("CSng", VBKeyword.CSng);
            TestKeyword("CULng", VBKeyword.CULng);
            TestKeyword("Declare", VBKeyword.Declare);
            TestKeyword("DirectCast", VBKeyword.DirectCast);
            TestKeyword("Else", VBKeyword.Else);
            TestKeyword("Enum", VBKeyword.Enum);
            TestKeyword("Exit", VBKeyword.Exit);
            TestKeyword("Friend", VBKeyword.Friend);
            TestKeyword("GetXmlNamespace", VBKeyword.GetXmlNamespace);
            TestKeyword("Handles", VBKeyword.Handles);
            TestKeyword("In", VBKeyword.In);
            TestKeyword("Is", VBKeyword.Is);
            TestKeyword("Like", VBKeyword.Like);
            TestKeyword("Mod", VBKeyword.Mod);
            TestKeyword("MyBase", VBKeyword.MyBase);
            TestKeyword("New", VBKeyword.New);
            TestKeyword("AddressOf", VBKeyword.AddressOf);
            TestKeyword("As", VBKeyword.As);
            TestKeyword("ByVal", VBKeyword.ByVal);
            TestKeyword("CBool", VBKeyword.CBool);
            TestKeyword("CDbl", VBKeyword.CDbl);
            TestKeyword("Class", VBKeyword.Class);
            TestKeyword("Continue", VBKeyword.Continue);
            TestKeyword("CStr", VBKeyword.CStr);
            TestKeyword("CUShort", VBKeyword.CUShort);
            TestKeyword("Default", VBKeyword.Default);
            TestKeyword("Do", VBKeyword.Do);
            TestKeyword("ElseIf", VBKeyword.ElseIf);
            TestKeyword("Erase", VBKeyword.Erase);
            TestKeyword("False", VBKeyword.False);
            TestKeyword("Function", VBKeyword.Function);
            TestKeyword("Global", VBKeyword.Global);
            TestKeyword("If", VBKeyword.If);
            TestKeyword("Inherits", VBKeyword.Inherits);
            TestKeyword("IsNot", VBKeyword.IsNot);
            TestKeyword("Long", VBKeyword.Long);
            TestKeyword("Module", VBKeyword.Module);
            TestKeyword("MyClass", VBKeyword.MyClass);
            TestKeyword("Next", VBKeyword.Next);
            TestKeyword("Alias", VBKeyword.Alias);
            TestKeyword("Boolean", VBKeyword.Boolean);
            TestKeyword("Call", VBKeyword.Call);
            TestKeyword("CByte", VBKeyword.CByte);
            TestKeyword("CDec", VBKeyword.CDec);
            TestKeyword("CLng", VBKeyword.CLng);
            TestKeyword("CSByte", VBKeyword.CSByte);
            TestKeyword("CType", VBKeyword.CType);
            TestKeyword("Date", VBKeyword.Date);
            TestKeyword("Delegate", VBKeyword.Delegate);
            TestKeyword("Double", VBKeyword.Double);
            TestKeyword("End", VBKeyword.End);
            TestKeyword("Error", VBKeyword.Error);
            TestKeyword("Finally", VBKeyword.Finally);
            TestKeyword("Get", VBKeyword.Get);
            TestKeyword("GoSub", VBKeyword.GoSub);
            TestKeyword("Implements", VBKeyword.Implements);
            TestKeyword("Integer", VBKeyword.Integer);
            TestKeyword("Let", VBKeyword.Let);
            TestKeyword("Loop", VBKeyword.Loop);
            TestKeyword("MustInherit", VBKeyword.MustInherit);
            TestKeyword("Namespace", VBKeyword.Namespace);
            TestKeyword("Not", VBKeyword.Not);
            TestKeyword("And", VBKeyword.And);
            TestKeyword("ByRef", VBKeyword.ByRef);
            TestKeyword("Case", VBKeyword.Case);
            TestKeyword("CChar", VBKeyword.CChar);
            TestKeyword("Char", VBKeyword.Char);
            TestKeyword("CObj", VBKeyword.CObj);
            TestKeyword("CShort", VBKeyword.CShort);
            TestKeyword("CUInt", VBKeyword.CUInt);
            TestKeyword("Decimal", VBKeyword.Decimal);
            TestKeyword("Dim", VBKeyword.Dim);
            TestKeyword("Each", VBKeyword.Each);
            TestKeyword("EndIf", VBKeyword.EndIf);
            TestKeyword("Event", VBKeyword.Event);
            TestKeyword("For", VBKeyword.For);
            TestKeyword("GetType", VBKeyword.GetType);
            TestKeyword("GoTo", VBKeyword.GoTo);
            TestKeyword("Imports", VBKeyword.Imports);
            TestKeyword("Interface", VBKeyword.Interface);
            TestKeyword("Lib", VBKeyword.Lib);
            TestKeyword("Me", VBKeyword.Me);
            TestKeyword("MustOverride", VBKeyword.MustOverride);
            TestKeyword("Narrowing", VBKeyword.Narrowing);
            TestKeyword("Nothing", VBKeyword.Nothing);
            TestKeyword("NotInheritable", VBKeyword.NotInheritable);
            TestKeyword("On", VBKeyword.On);
            TestKeyword("Or", VBKeyword.Or);
            TestKeyword("Overrides", VBKeyword.Overrides);
            TestKeyword("Property", VBKeyword.Property);
            TestKeyword("ReadOnly", VBKeyword.ReadOnly);
            TestKeyword("Resume", VBKeyword.Resume);
            TestKeyword("Set", VBKeyword.Set);
            TestKeyword("Single", VBKeyword.Single);
            TestKeyword("String", VBKeyword.String);
            TestKeyword("Then", VBKeyword.Then);
            TestKeyword("Try", VBKeyword.Try);
            TestKeyword("ULong", VBKeyword.ULong);
            TestKeyword("Wend", VBKeyword.Wend);
            TestKeyword("With", VBKeyword.With);
            TestKeyword("NotOverridable", VBKeyword.NotOverridable);
            TestKeyword("Operator", VBKeyword.Operator);
            TestKeyword("OrElse", VBKeyword.OrElse);
            TestKeyword("ParamArray", VBKeyword.ParamArray);
            TestKeyword("Protected", VBKeyword.Protected);
            TestKeyword("ReDim", VBKeyword.ReDim);
            TestKeyword("Return", VBKeyword.Return);
            TestKeyword("Shadows", VBKeyword.Shadows);
            TestKeyword("Static", VBKeyword.Static);
            TestKeyword("Structure", VBKeyword.Structure);
            TestKeyword("Throw", VBKeyword.Throw);
            TestKeyword("TryCast", VBKeyword.TryCast);
            TestKeyword("UShort", VBKeyword.UShort);
            TestKeyword("When", VBKeyword.When);
            TestKeyword("WithEvents", VBKeyword.WithEvents);
            TestKeyword("Object", VBKeyword.Object);
            TestKeyword("Option", VBKeyword.Option);
            TestKeyword("Overloads", VBKeyword.Overloads);
            TestKeyword("Partial", VBKeyword.Partial);
            TestKeyword("Public", VBKeyword.Public);
            TestKeyword("SByte", VBKeyword.SByte);
            TestKeyword("Shared", VBKeyword.Shared);
            TestKeyword("Step", VBKeyword.Step);
            TestKeyword("Sub", VBKeyword.Sub);
            TestKeyword("To", VBKeyword.To);
            TestKeyword("TypeOf", VBKeyword.TypeOf);
            TestKeyword("Using", VBKeyword.Using);
            TestKeyword("While", VBKeyword.While);
            TestKeyword("WriteOnly", VBKeyword.WriteOnly);
            TestKeyword("Of", VBKeyword.Of);
            TestKeyword("Optional", VBKeyword.Optional);
            TestKeyword("Overridable", VBKeyword.Overridable);
            TestKeyword("Private", VBKeyword.Private);
            TestKeyword("RaiseEvent", VBKeyword.RaiseEvent);
            TestKeyword("RemoveHandler", VBKeyword.RemoveHandler);
            TestKeyword("Select", VBKeyword.Select);
            TestKeyword("Short", VBKeyword.Short);
            TestKeyword("Stop", VBKeyword.Stop);
            TestKeyword("SyncLock", VBKeyword.SyncLock);
            TestKeyword("True", VBKeyword.True);
            TestKeyword("UInteger", VBKeyword.UInteger);
            TestKeyword("Variant", VBKeyword.Variant);
            TestKeyword("Widening", VBKeyword.Widening);
            TestKeyword("Xor", VBKeyword.Xor);
        }

        private void TestKeyword(string keyword, VBKeyword keywordType)
        {
            TestTokenizer(keyword, new VBSymbol(0, 0, 0, keyword, VBSymbolType.Keyword) { Keyword = keywordType });
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/VBTokenizerLiteralTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class VBTokenizerLiteralTest : VBTokenizerTestBase
    {
        [Fact]
        public void Decimal_Integer_Literal_Is_Recognized()
        {
            TestSingleToken("01189998819991197253", VBSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Integer_Type_Suffixes_Are_Recognized_In_Decimal_Literal()
        {
            TestSingleToken("42S", VBSymbolType.IntegerLiteral);
            TestSingleToken("42I", VBSymbolType.IntegerLiteral);
            TestSingleToken("42L", VBSymbolType.IntegerLiteral);
            TestSingleToken("42US", VBSymbolType.IntegerLiteral);
            TestSingleToken("42UI", VBSymbolType.IntegerLiteral);
            TestSingleToken("42UL", VBSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Hex_Integer_Literal_Is_Recognized()
        {
            TestSingleToken("&HDeadBeef", VBSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Integer_Type_Suffixes_Are_Recognized_In_Hex_Literal()
        {
            TestSingleToken("&HDeadBeefS", VBSymbolType.IntegerLiteral);
            TestSingleToken("&HDeadBeefI", VBSymbolType.IntegerLiteral);
            TestSingleToken("&HDeadBeefL", VBSymbolType.IntegerLiteral);
            TestSingleToken("&HDeadBeefUS", VBSymbolType.IntegerLiteral);
            TestSingleToken("&HDeadBeefUI", VBSymbolType.IntegerLiteral);
            TestSingleToken("&HDeadBeefUL", VBSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Octal_Integer_Literal_Is_Recognized()
        {
            TestSingleToken("&O77", VBSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Integer_Type_Suffixes_Are_Recognized_In_Octal_Literal()
        {
            TestSingleToken("&O77S", VBSymbolType.IntegerLiteral);
            TestSingleToken("&O77I", VBSymbolType.IntegerLiteral);
            TestSingleToken("&O77L", VBSymbolType.IntegerLiteral);
            TestSingleToken("&O77US", VBSymbolType.IntegerLiteral);
            TestSingleToken("&O77UI", VBSymbolType.IntegerLiteral);
            TestSingleToken("&O77UL", VBSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Incomplete_Type_Suffix_Is_Recognized()
        {
            TestSingleToken("42U", VBSymbolType.IntegerLiteral);
            TestSingleToken("&H42U", VBSymbolType.IntegerLiteral);
            TestSingleToken("&O77U", VBSymbolType.IntegerLiteral);
        }

        [Fact]
        public void Integer_With_FloatingPoint_Type_Suffix_Is_Recognized_As_FloatingPointLiteral()
        {
            TestSingleToken("42F", VBSymbolType.FloatingPointLiteral);
            TestSingleToken("42R", VBSymbolType.FloatingPointLiteral);
            TestSingleToken("42D", VBSymbolType.FloatingPointLiteral);
        }

        [Fact]
        public void Simple_FloatingPoint_Is_Recognized()
        {
            TestSingleToken("3.14159", VBSymbolType.FloatingPointLiteral);
        }

        [Fact]
        public void Integer_With_Exponent_Is_Recognized()
        {
            TestSingleToken("1E10", VBSymbolType.FloatingPointLiteral);
            TestSingleToken("1e10", VBSymbolType.FloatingPointLiteral);
            TestSingleToken("1E+10", VBSymbolType.FloatingPointLiteral);
            TestSingleToken("1e+10", VBSymbolType.FloatingPointLiteral);
            TestSingleToken("1E-10", VBSymbolType.FloatingPointLiteral);
            TestSingleToken("1e-10", VBSymbolType.FloatingPointLiteral);
        }

        [Fact]
        public void Simple_FloatingPoint_With_Exponent_Is_Recognized()
        {
            TestSingleToken("3.14159e10", VBSymbolType.FloatingPointLiteral);
        }

        [Fact]
        public void FloatingPoint_Between_Zero_And_One_Is_Recognized()
        {
            TestSingleToken(".314159e1", VBSymbolType.FloatingPointLiteral);
        }

        [Fact]
        public void Simple_String_Literal_Is_Recognized()
        {
            TestSingleToken("\"Foo Bar Baz\"", VBSymbolType.StringLiteral);
        }

        [Fact]
        public void Two_Double_Quotes_Are_Recognized_As_Escape_Sequence()
        {
            TestSingleToken("\"Foo \"\"Bar\"\" Baz\"", VBSymbolType.StringLiteral);
        }

        [Fact]
        public void String_Literal_Is_Terminated_At_EOF()
        {
            TestSingleToken("\"Foo", VBSymbolType.StringLiteral);
        }

        [Fact]
        public void String_Literal_Is_Terminated_At_EOL()
        {
            TestTokenizer("\"Foo\nBar", new VBSymbol(0, 0, 0, "\"Foo", VBSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void Character_Literal_Is_Recognized_By_Trailing_C_After_String_Literal()
        {
            TestSingleToken("\"abc\"c", VBSymbolType.CharacterLiteral);
        }

        [Fact]
        public void LeftDoubleQuote_Is_Valid_DoubleQuote()
        {
            // Repeat all the above tests with Unicode Left Double Quote Character U+201C: “
            TestSingleToken("“Foo Bar Baz“", VBSymbolType.StringLiteral);
            TestSingleToken("“Foo ““Bar““ Baz“", VBSymbolType.StringLiteral);
            TestSingleToken("“Foo", VBSymbolType.StringLiteral);
            TestSingleToken("“abc“c", VBSymbolType.CharacterLiteral);
            TestTokenizer("“Foo\nBar", new VBSymbol(0, 0, 0, "“Foo", VBSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void RightDoubleQuote_Is_Valid_DoubleQuote()
        {
            // Repeat all the above tests with Unicode Right Double Quote Character U+201D: ”
            TestSingleToken("”Foo Bar Baz”", VBSymbolType.StringLiteral);
            TestSingleToken("”Foo ””Bar”” Baz”", VBSymbolType.StringLiteral);
            TestSingleToken("”Foo", VBSymbolType.StringLiteral);
            TestSingleToken("”abc”c", VBSymbolType.CharacterLiteral);
            TestTokenizer("”Foo\nBar", new VBSymbol(0, 0, 0, "”Foo", VBSymbolType.StringLiteral), IgnoreRemaining);
        }

        [Fact]
        public void DateLiteral_Is_Recognized()
        {
            TestSingleToken("# 8/23/1970 3:45:39AM #", VBSymbolType.DateLiteral);
        }

        [Fact]
        public void DateLiteral_Is_Terminated_At_EndHash()
        {
            TestTokenizer("# 8/23/1970 # 3:45:39AM", new VBSymbol(0, 0, 0, "# 8/23/1970 #", VBSymbolType.DateLiteral), IgnoreRemaining);
        }

        [Fact]
        public void DateLiteral_Is_Terminated_At_EOF()
        {
            TestSingleToken("# 8/23/1970 3:45:39AM", VBSymbolType.DateLiteral);
        }

        [Fact]
        public void DateLiteral_Is_Terminated_At_EOL()
        {
            TestTokenizer("# 8/23/1970\n3:45:39AM", new VBSymbol(0, 0, 0, "# 8/23/1970", VBSymbolType.DateLiteral), IgnoreRemaining);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/VBTokenizerOperatorsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class VBTokenizerOperatorsTest : VBTokenizerTestBase
    {
        [Fact]
        public void Line_Continuation_Character_Is_Recognized()
        {
            TestSingleToken("_", VBSymbolType.LineContinuation);
        }

        [Fact]
        public void LeftParen_Is_Recognized()
        {
            TestSingleToken("(", VBSymbolType.LeftParenthesis);
        }

        [Fact]
        public void RightParen_Is_Recognized()
        {
            TestSingleToken(")", VBSymbolType.RightParenthesis);
        }

        [Fact]
        public void LeftBracket_Is_Recognized()
        {
            TestSingleToken("[", VBSymbolType.LeftBracket);
        }

        [Fact]
        public void RightBracket_Is_Recognized()
        {
            TestSingleToken("]", VBSymbolType.RightBracket);
        }

        [Fact]
        public void LeftBrace_Is_Recognized()
        {
            TestSingleToken("{", VBSymbolType.LeftBrace);
        }

        [Fact]
        public void RightBrace_Is_Recognized()
        {
            TestSingleToken("}", VBSymbolType.RightBrace);
        }

        [Fact]
        public void Bang_Is_Recognized()
        {
            TestSingleToken("!", VBSymbolType.Bang);
        }

        [Fact]
        public void Hash_Is_Recognized()
        {
            TestSingleToken("#", VBSymbolType.Hash);
        }

        [Fact]
        public void Comma_Is_Recognized()
        {
            TestSingleToken(",", VBSymbolType.Comma);
        }

        [Fact]
        public void Dot_Is_Recognized()
        {
            TestSingleToken(".", VBSymbolType.Dot);
        }

        [Fact]
        public void Colon_Is_Recognized()
        {
            TestSingleToken(":", VBSymbolType.Colon);
        }

        [Fact]
        public void QuestionMark_Is_Recognized()
        {
            TestSingleToken("?", VBSymbolType.QuestionMark);
        }

        [Fact]
        public void Concatenation_Is_Recognized()
        {
            TestSingleToken("&", VBSymbolType.Concatenation);
        }

        [Fact]
        public void Multiply_Is_Recognized()
        {
            TestSingleToken("*", VBSymbolType.Multiply);
        }

        [Fact]
        public void Add_Is_Recognized()
        {
            TestSingleToken("+", VBSymbolType.Add);
        }

        [Fact]
        public void Subtract_Is_Recognized()
        {
            TestSingleToken("-", VBSymbolType.Subtract);
        }

        [Fact]
        public void Divide_Is_Recognized()
        {
            TestSingleToken("/", VBSymbolType.Divide);
        }

        [Fact]
        public void IntegerDivide_Is_Recognized()
        {
            TestSingleToken("\\", VBSymbolType.IntegerDivide);
        }

        [Fact]
        public void Exponentiation_Is_Recognized()
        {
            TestSingleToken("^", VBSymbolType.Exponentiation);
        }

        [Fact]
        public void Equal_Is_Recognized()
        {
            TestSingleToken("=", VBSymbolType.Equal);
        }

        [Fact]
        public void LessThan_Is_Recognized()
        {
            TestSingleToken("<", VBSymbolType.LessThan);
        }

        [Fact]
        public void GreaterThan_Is_Recognized()
        {
            TestSingleToken(">", VBSymbolType.GreaterThan);
        }

        [Fact]
        public void Dollar_Is_Recognized()
        {
            TestSingleToken("$", VBSymbolType.Dollar);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/VBTokenizerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Tokenizer
{
    public class VBTokenizerTest : VBTokenizerTestBase
    {
        [Fact]
        public void Constructor_Throws_ArgNull_If_Null_Source_Provided()
        {
            Assert.ThrowsArgumentNull(() => new CSharpTokenizer(null), "source");
        }

        [Fact]
        public void Next_Returns_Null_When_EOF_Reached()
        {
            TestTokenizer("");
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_CR()
        {
            TestTokenizer("\r\ra",
                          new VBSymbol(0, 0, 0, "\r", VBSymbolType.NewLine),
                          new VBSymbol(1, 1, 0, "\r", VBSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_LF()
        {
            TestTokenizer("\n\na",
                          new VBSymbol(0, 0, 0, "\n", VBSymbolType.NewLine),
                          new VBSymbol(1, 1, 0, "\n", VBSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_NEL()
        {
            // NEL: Unicode "Next Line" U+0085
            TestTokenizer("\u0085\u0085a",
                          new VBSymbol(0, 0, 0, "\u0085", VBSymbolType.NewLine),
                          new VBSymbol(1, 1, 0, "\u0085", VBSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_Line_Separator()
        {
            // Unicode "Line Separator" U+2028
            TestTokenizer("\u2028\u2028a",
                          new VBSymbol(0, 0, 0, "\u2028", VBSymbolType.NewLine),
                          new VBSymbol(1, 1, 0, "\u2028", VBSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Newline_Token_For_Single_Paragraph_Separator()
        {
            // Unicode "Paragraph Separator" U+2029
            TestTokenizer("\u2029\u2029a",
                          new VBSymbol(0, 0, 0, "\u2029", VBSymbolType.NewLine),
                          new VBSymbol(1, 1, 0, "\u2029", VBSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Single_Newline_Token_For_CRLF()
        {
            TestTokenizer("\r\n\r\na",
                          new VBSymbol(0, 0, 0, "\r\n", VBSymbolType.NewLine),
                          new VBSymbol(2, 1, 0, "\r\n", VBSymbolType.NewLine),
                          IgnoreRemaining);
        }

        [Fact]
        public void Next_Returns_Token_For_Whitespace_Characters()
        {
            TestTokenizer(" \f\t\u000B \n ",
                          new VBSymbol(0, 0, 0, " \f\t\u000B ", VBSymbolType.WhiteSpace),
                          new VBSymbol(5, 0, 5, "\n", VBSymbolType.NewLine),
                          new VBSymbol(6, 1, 0, " ", VBSymbolType.WhiteSpace));
        }

        [Fact]
        public void Transition_Is_Recognized()
        {
            TestSingleToken("@", VBSymbolType.Transition);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Tokenizer/VBTokenizerTestBase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Text;
using System.Web.Razor.Tokenizer;
using System.Web.Razor.Tokenizer.Symbols;

namespace System.Web.Razor.Test.Tokenizer
{
    public abstract class VBTokenizerTestBase : TokenizerTestBase<VBSymbol, VBSymbolType>
    {
        private static VBSymbol _ignoreRemaining = new VBSymbol(0, 0, 0, String.Empty, VBSymbolType.Unknown);

        protected override VBSymbol IgnoreRemaining
        {
            get { return _ignoreRemaining; }
        }

        protected override Tokenizer<VBSymbol, VBSymbolType> CreateTokenizer(ITextDocument source)
        {
            return new VBTokenizer(source);
        }

        protected void TestSingleToken(string text, VBSymbolType expectedSymbolType)
        {
            TestTokenizer(text, new VBSymbol(0, 0, 0, text, expectedSymbolType));
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Utils/DisposableActionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Utils;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Utils
{
    public class DisposableActionTest
    {
        [Fact]
        public void ConstructorRequiresNonNullAction()
        {
            Assert.ThrowsArgumentNull(() => new DisposableAction(null), "action");
        }

        [Fact]
        public void ActionIsExecutedOnDispose()
        {
            // Arrange
            bool called = false;
            DisposableAction action = new DisposableAction(() => { called = true; });

            // Act
            action.Dispose();

            // Assert
            Assert.True(called, "The action was not run when the DisposableAction was disposed");
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Utils/EnumerableUtils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Razor.Test.Utils
{
    public static class EnumerableUtils
    {
        public static void RunPairwise<T, V>(IEnumerable<T> left, IEnumerable<V> right, Action<T, V> action)
        {
            IEnumerator<T> leftEnum = left.GetEnumerator();
            IEnumerator<V> rightEnum = right.GetEnumerator();
            while (leftEnum.MoveNext() && rightEnum.MoveNext())
            {
                action(leftEnum.Current, rightEnum.Current);
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Utils/MiscAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq.Expressions;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Utils
{
    public static class MiscAssert
    {
        public static void AssertBothNullOrPropertyEqual<T>(T expected, T actual, Expression<Func<T, object>> propertyExpr, string objectName)
            where T : class
        {
            // Unpack convert expressions
            Expression expr = propertyExpr.Body;
            while (expr.NodeType == ExpressionType.Convert)
            {
                expr = ((UnaryExpression)expr).Operand;
            }

            string propertyName = ((MemberExpression)expr).Member.Name;
            Func<T, object> property = propertyExpr.Compile();

            if (expected == null)
            {
                Assert.Null(actual);
            }
            else
            {
                Assert.NotNull(actual);
                Assert.Equal(property(expected), property(actual));
            }
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Utils/MiscUtils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Diagnostics;
using System.Text.RegularExpressions;
using System.Threading;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Utils
{
    class MiscUtils
    {
        public const int TimeoutInSeconds = 1;

        public static string StripRuntimeVersion(string s)
        {
            return Regex.Replace(s, @"Runtime Version:[\d.]*", "Runtime Version:N.N.NNNNN.N");
        }

        public static void DoWithTimeoutIfNotDebugging(Func<int, bool> withTimeout)
        {
#if DEBUG
            if (Debugger.IsAttached)
            {
                withTimeout(Timeout.Infinite);
            }
            else
            {
#endif
                Assert.True(withTimeout((int)TimeSpan.FromSeconds(TimeoutInSeconds).TotalMilliseconds), "Timeout expired!");
#if DEBUG
            }
#endif
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/Utils/SpanAssert.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Web.Razor.Parser.SyntaxTree;
using System.Web.Razor.Text;
using Microsoft.TestCommon;

namespace System.Web.Razor.Test.Utils
{
    public static class EventAssert
    {
        public static void NoMoreSpans(IEnumerator<Span> enumerator)
        {
            IList<Span> tokens = new List<Span>();
            while (enumerator.MoveNext())
            {
                tokens.Add(enumerator.Current);
            }

            Assert.False(tokens.Count > 0, String.Format(CultureInfo.InvariantCulture, @"There are more tokens available from the source: {0}", FormatList(tokens)));
        }

        private static string FormatList<T>(IList<T> items)
        {
            StringBuilder tokenString = new StringBuilder();
            foreach (T item in items)
            {
                tokenString.AppendLine(item.ToString());
            }
            return tokenString.ToString();
        }

        public static void NextSpanIs(IEnumerator<Span> enumerator, SpanKind type, string content, SourceLocation location)
        {
            Assert.True(enumerator.MoveNext(), "There is no next token!");
            IsSpan(enumerator.Current, type, content, location);
        }

        public static void NextSpanIs(IEnumerator<Span> enumerator, SpanKind type, string content, int actualIndex, int lineIndex, int charIndex)
        {
            NextSpanIs(enumerator, type, content, new SourceLocation(actualIndex, lineIndex, charIndex));
        }

        public static void IsSpan(Span tok, SpanKind type, string content, int actualIndex, int lineIndex, int charIndex)
        {
            IsSpan(tok, type, content, new SourceLocation(actualIndex, lineIndex, charIndex));
        }

        public static void IsSpan(Span tok, SpanKind type, string content, SourceLocation location)
        {
            Assert.Equal(content, tok.Content);
            Assert.Equal(type, tok.Kind);
            Assert.Equal(location, tok.Start);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/VBRazorCodeLanguageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor.Generator;
using System.Web.Razor.Parser;
using Microsoft.TestCommon;
using Microsoft.VisualBasic;

namespace System.Web.Razor.Test
{
    public class VBRazorCodeLanguageTest
    {
        [Fact]
        public void CreateCodeParserReturnsNewVBCodeParser()
        {
            // Arrange
            RazorCodeLanguage service = new VBRazorCodeLanguage();

            // Act
            ParserBase parser = service.CreateCodeParser();

            // Assert
            Assert.NotNull(parser);
            Assert.IsType<VBCodeParser>(parser);
        }

        [Fact]
        public void CreateCodeGeneratorParserListenerReturnsNewCSharpCodeGeneratorParserListener()
        {
            // Arrange
            RazorCodeLanguage service = new VBRazorCodeLanguage();

            // Act
            RazorEngineHost host = new RazorEngineHost(new VBRazorCodeLanguage());
            RazorCodeGenerator generator = service.CreateCodeGenerator("Foo", "Bar", "Baz", host);

            // Assert
            Assert.NotNull(generator);
            Assert.IsType<VBRazorCodeGenerator>(generator);
            Assert.Equal("Foo", generator.ClassName);
            Assert.Equal("Bar", generator.RootNamespaceName);
            Assert.Equal("Baz", generator.SourceFileName);
            Assert.Same(host, generator.Host);
        }

        [Fact]
        public void CodeDomProviderTypeReturnsVBCodeProvider()
        {
            // Arrange
            RazorCodeLanguage service = new VBRazorCodeLanguage();

            // Assert
            Assert.Equal(typeof(VBCodeProvider), service.CodeDomProviderType);
        }
    }
}


================================================
FILE: test/System.Web.Razor.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.WebPages.Administration.Test/AdminPackageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.IO;
using System.Text;
using System.Web.Helpers;
using System.Web.Hosting;
using System.Web.Security;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Administration.Test
{
    public class AdminPackageTest
    {
        [Fact]
        public void GetAdminVirtualPathThrowsIfPathIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(() => SiteAdmin.GetVirtualPath(null), "virtualPath");
        }

        [Fact]
        public void GetAdminVirtualPathDoesNotAppendAdminVirtualPathIfPathStartsWithAdminVirtualPath()
        {
            // Act
            string vpath = SiteAdmin.GetVirtualPath("~/_Admin/Foo");

            // Assert
            Assert.Equal("~/_Admin/Foo", vpath);
        }

        [Fact]
        public void GetAdminVirtualPathAppendsAdminVirtualPath()
        {
            // Act
            string vpath = SiteAdmin.GetVirtualPath("~/Foo");

            // Assert
            Assert.Equal("~/_Admin/Foo", vpath);
        }

        [Fact]
        public void SetAuthCookieAddsAuthCookieToResponseCollection()
        {
            // Arrange
            var mockResponse = new Mock<HttpResponseBase>();
            var cookies = new HttpCookieCollection();
            mockResponse.Setup(m => m.Cookies).Returns(cookies);

            // Act
            AdminSecurity.SetAuthCookie(mockResponse.Object);

            // Assert
            Assert.NotNull(cookies[".ASPXADMINAUTH"]);
        }

        [Fact]
        public void GetAuthAdminCookieCreatesAnAuthTicketWithUserDataSetToAdmin()
        {
            // Arrange
            var cookie = AdminSecurity.GetAuthCookie();

            // Act
            FormsAuthenticationTicket ticket = FormsAuthentication.Decrypt(cookie.Value);

            // Assert
            Assert.Equal(".ASPXADMINAUTH", cookie.Name);
            Assert.True(cookie.HttpOnly);
            Assert.Equal(2, ticket.Version);
            Assert.Equal("ADMIN", ticket.UserData);
        }

        [Fact]
        public void IsAuthenticatedReturnsFalseIfAuthCookieNotInCollection()
        {
            // Arrange
            var mockRequest = new Mock<HttpRequestBase>();
            var cookies = new HttpCookieCollection();
            mockRequest.Setup(m => m.Cookies).Returns(cookies);

            // Act
            bool authorized = AdminSecurity.IsAuthenticated(mockRequest.Object);

            // Assert
            Assert.False(authorized);
        }

        [Fact]
        public void IsAuthenticatedReturnsFalseIfAuthCookieInCollectionAndIsNotAValidAdminAuthCookie()
        {
            // Arrange
            var mockRequest = new Mock<HttpRequestBase>();
            var cookies = new HttpCookieCollection();
            mockRequest.Setup(m => m.Cookies).Returns(cookies);
            cookies.Add(new HttpCookie(".ASPXADMINAUTH", "test"));

            // Act
            bool authorized = AdminSecurity.IsAuthenticated(mockRequest.Object);

            // Assert
            Assert.False(authorized);
        }

        [Fact]
        public void IsAuthenticatedReturnsTrueIfAuthCookieIsValid()
        {
            // Arrange
            var mockRequest = new Mock<HttpRequestBase>();
            var cookies = new HttpCookieCollection();
            mockRequest.Setup(m => m.Cookies).Returns(cookies);
            cookies.Add(AdminSecurity.GetAuthCookie());

            // Act
            bool authorized = AdminSecurity.IsAuthenticated(mockRequest.Object);

            // Assert
            Assert.True(authorized);
        }

        [Fact]
        public void GetRedirectUrlAppendsAppRelativePathAsReturnUrl()
        {
            // Arrange            
            var mockRequest = new Mock<HttpRequestBase>();
            mockRequest.Setup(m => m.RawUrl).Returns("~/_Admin/foo/bar/baz");
            mockRequest.Setup(m => m.QueryString).Returns(new NameValueCollection());

            // Act
            string redirectUrl = SiteAdmin.GetRedirectUrl(mockRequest.Object, "register", MakeAppRelative);

            // Assert
            Assert.Equal("~/_Admin/register?ReturnUrl=%7e%2f_Admin%2ffoo%2fbar%2fbaz", redirectUrl);
        }

        [Fact]
        public void GetRedirectUrlDoesNotAppendsAppRelativePathAsReturnUrlIfAlreadyExists()
        {
            // Arrange            
            var mockRequest = new Mock<HttpRequestBase>();
            mockRequest.Setup(m => m.RawUrl).Returns("~/_Admin/foo/bar/baz?ReturnUrl=~/foo");
            var queryString = new NameValueCollection();
            queryString["ReturnUrl"] = "~/foo";
            mockRequest.Setup(m => m.QueryString).Returns(queryString);

            // Act
            string redirectUrl = SiteAdmin.GetRedirectUrl(mockRequest.Object, "register", MakeAppRelative);

            // Assert
            Assert.Equal("~/_Admin/register?ReturnUrl=%7e%2ffoo", redirectUrl);
        }

        [Fact]
        public void GetReturnUrlReturnsNullIfNotSet()
        {
            // Arrange            
            var mockRequest = new Mock<HttpRequestBase>();
            mockRequest.Setup(m => m.QueryString).Returns(new NameValueCollection());

            // Act
            string returlUrl = SiteAdmin.GetReturnUrl(mockRequest.Object);

            // Assert
            Assert.Null(returlUrl);
        }

        [Fact]
        public void GetReturnUrlThrowsIfReturnUrlIsNotAppRelative()
        {
            // Arrange            
            var mockRequest = new Mock<HttpRequestBase>();
            var queryString = new NameValueCollection();
            queryString["ReturnUrl"] = "http://www.bing.com";
            mockRequest.Setup(m => m.QueryString).Returns(queryString);

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => SiteAdmin.GetReturnUrl(mockRequest.Object), "The return URL specified for request redirection is invalid.");
        }

        [Fact]
        public void GetReturnUrlReturnsReturlUrlQueryStringParameterIfItIsAppRelative()
        {
            // Arrange            
            var mockRequest = new Mock<HttpRequestBase>();
            var queryString = new NameValueCollection();
            queryString["ReturnUrl"] = "~/_Admin/bar?foo=1";
            mockRequest.Setup(m => m.QueryString).Returns(queryString);

            // Act
            string returnUrl = SiteAdmin.GetReturnUrl(mockRequest.Object);

            // Assert
            Assert.Equal("~/_Admin/bar?foo=1", returnUrl);
        }

        [Fact]
        public void SaveAdminPasswordUsesCryptoToWritePasswordAndSalt()
        {
            // Arrange
            var password = "some-random-password";
            MemoryStream ms = new MemoryStream();

            // Act
            bool passwordSaved = AdminSecurity.SaveTemporaryPassword(password, () => ms);

            // Assert
            Assert.True(passwordSaved);
            string savedPassword = Encoding.Default.GetString(ms.ToArray());
            // Trim everything after the new line. Cannot use the properties from the stream since it is already closed by the writer.
            savedPassword = savedPassword.Substring(0, savedPassword.IndexOf(Environment.NewLine));

            Assert.True(Crypto.VerifyHashedPassword(savedPassword, password));
        }

        [Fact]
        public void SaveAdminPasswordReturnsFalseIfGettingStreamThrowsUnauthorizedAccessException()
        {
            // Act
            bool passwordSaved = AdminSecurity.SaveTemporaryPassword("password", () => { throw new UnauthorizedAccessException(); });

            // Assert
            Assert.False(passwordSaved);
        }

        [Fact]
        public void CheckPasswordReturnsTrueIfPasswordIsValid()
        {
            // Arrange
            var ms = new MemoryStream();
            var writer = new StreamWriter(ms);
            writer.WriteLine(Crypto.HashPassword("password"));
            writer.Flush();
            ms.Seek(0, SeekOrigin.Begin);

            // Act
            bool passwordIsValid = AdminSecurity.CheckPassword("password", () => ms);

            // Assert
            Assert.True(passwordIsValid);

            writer.Close();
        }

        [Fact]
        public void HasAdminPasswordReturnsTrueIfAdminPasswordFileExists()
        {
            // Arrange
            Mock<VirtualPathProvider> mockVpp = new Mock<VirtualPathProvider>();
            mockVpp.Setup(m => m.FileExists("~/App_Data/Admin/Password.config")).Returns(true);

            // Act
            bool hasPassword = AdminSecurity.HasAdminPassword(mockVpp.Object);

            // Assert
            Assert.True(hasPassword);
        }

        [Fact]
        public void HasAdminPasswordReturnsFalseIfAdminPasswordFileDoesNotExists()
        {
            // Arrange
            Mock<VirtualPathProvider> mockVpp = new Mock<VirtualPathProvider>();
            mockVpp.Setup(m => m.FileExists("~/App_Data/Admin/Password.config")).Returns(false);

            // Act
            bool hasPassword = AdminSecurity.HasAdminPassword(mockVpp.Object);

            // Assert
            Assert.False(hasPassword);
        }

        [Fact]
        public void HasTemporaryPasswordReturnsTrueIfAdminPasswordFileExists()
        {
            // Arrange
            Mock<VirtualPathProvider> mockVpp = new Mock<VirtualPathProvider>();
            mockVpp.Setup(m => m.FileExists("~/App_Data/Admin/_Password.config")).Returns(true);

            // Act
            bool hasPassword = AdminSecurity.HasTemporaryPassword(mockVpp.Object);

            // Assert
            Assert.True(hasPassword);
        }

        [Fact]
        public void HasTemporaryPasswordReturnsFalseIfAdminPasswordFileDoesNotExists()
        {
            // Arrange
            Mock<VirtualPathProvider> mockVpp = new Mock<VirtualPathProvider>();
            mockVpp.Setup(m => m.FileExists("~/App_Data/Admin/_Password.config")).Returns(false);

            // Act
            bool hasPassword = AdminSecurity.HasTemporaryPassword(mockVpp.Object);

            // Assert
            Assert.False(hasPassword);
        }

        [Fact]
        public void NoPasswordOrTemporaryPasswordRedirectsToRegisterPage()
        {
            AssertSecure(requestUrl: "~/",
                         passwordExists: false,
                         temporaryPasswordExists: false,
                         expectedUrl: "~/_Admin/Register.cshtml?ReturnUrl=%7e%2f");
        }

        [Fact]
        public void IfPasswordExistsRedirectsToLoginPage()
        {
            AssertSecure(requestUrl: "~/",
                         passwordExists: true,
                         temporaryPasswordExists: false,
                         expectedUrl: "~/_Admin/Login.cshtml?ReturnUrl=%7e%2f");
        }

        [Fact]
        public void IfPasswordExistsRedirectsToLoginPageEvenIfTemporaryPasswordFileExists()
        {
            AssertSecure(requestUrl: "~/",
                         passwordExists: true,
                         temporaryPasswordExists: true,
                         expectedUrl: "~/_Admin/Login.cshtml?ReturnUrl=%7e%2f");
        }

        [Fact]
        public void IfTemporaryPasswordExistsRedirectsToInstructionsPage()
        {
            AssertSecure(requestUrl: "~/",
                         passwordExists: false,
                         temporaryPasswordExists: true,
                         expectedUrl: "~/_Admin/EnableInstructions.cshtml?ReturnUrl=%7e%2f");
        }

        [Fact]
        public void NoRedirectIfAlreadyGoingToRedirectPage()
        {
            AssertSecure(requestUrl: "~/_Admin/Register.cshtml",
                         passwordExists: false,
                         temporaryPasswordExists: false,
                         expectedUrl: null);

            AssertSecure(requestUrl: "~/_Admin/Login.cshtml",
                         passwordExists: true,
                         temporaryPasswordExists: false,
                         expectedUrl: null);

            AssertSecure(requestUrl: "~/_Admin/EnableInstructions.cshtml",
                         passwordExists: false,
                         temporaryPasswordExists: true,
                         expectedUrl: null);
        }

        private static void AssertSecure(string requestUrl, bool passwordExists, bool temporaryPasswordExists, string expectedUrl)
        {
            // Arrange
            var vpp = new Mock<VirtualPathProvider>();
            if (temporaryPasswordExists)
            {
                vpp.Setup(m => m.FileExists("~/App_Data/Admin/_Password.config")).Returns(true);
            }

            if (passwordExists)
            {
                vpp.Setup(m => m.FileExists("~/App_Data/Admin/Password.config")).Returns(true);
            }

            string redirectUrl = null;
            var response = new Mock<HttpResponseBase>();
            response.Setup(m => m.Redirect(It.IsAny<string>())).Callback<string>(url => redirectUrl = url);
            var request = new Mock<HttpRequestBase>();
            request.Setup(m => m.QueryString).Returns(new NameValueCollection());
            request.Setup(m => m.RawUrl).Returns(requestUrl);
            var cookies = new HttpCookieCollection();
            request.Setup(m => m.Cookies).Returns(cookies);
            var context = new Mock<HttpContextBase>();
            context.Setup(m => m.Request).Returns(request.Object);
            context.Setup(m => m.Response).Returns(response.Object);
            var startPage = new Mock<StartPage>() { CallBase = true };
            var page = new Mock<WebPageRenderingBase>();
            page.Setup(m => m.VirtualPath).Returns(requestUrl);
            startPage.Object.ChildPage = page.Object;
            page.Setup(m => m.Context).Returns(context.Object);

            // Act
            AdminSecurity.Authorize(startPage.Object, vpp.Object, MakeAppRelative);

            // Assert
            Assert.Equal(expectedUrl, redirectUrl);
        }

        private static string MakeAppRelative(string path)
        {
            return path;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/PackageManagerModuleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.WebPages.Administration.PackageManager;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Administration.Test
{
    public class PackageManagerModuleTest
    {
        [Fact]
        public void InitSourceFileDoesNotAffectSourcesFileWhenFeedIsNotNull()
        {
            // Arrange
            bool sourceFileCalled = false;
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(s => s.Exists()).Returns(false);
            sourceFile.Setup(s => s.WriteSources(It.IsAny<IEnumerable<WebPackageSource>>())).Callback(() => sourceFileCalled = true);
            sourceFile.Setup(c => c.ReadSources()).Callback(() => sourceFileCalled = true);
            ISet<WebPackageSource> set = new HashSet<WebPackageSource>();

            // Act
            PackageManagerModule.InitPackageSourceFile(sourceFile.Object, ref set);

            // Assert
            Assert.False(sourceFileCalled);
        }

        [Fact]
        public void InitSourceFileWritesToDiskIfSourcesFileDoesNotExist()
        {
            // Arrange
            ISet<WebPackageSource> set = null;
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(s => s.Exists()).Returns(false);
            sourceFile.Setup(s => s.WriteSources(It.IsAny<IEnumerable<WebPackageSource>>()));

            // Act
            PackageManagerModule.InitPackageSourceFile(sourceFile.Object, ref set);

            Assert.NotNull(set);
            Assert.Equal(2, set.Count());
            Assert.Equal("http://go.microsoft.com/fwlink/?LinkID=226946", set.First().Source);
            Assert.Equal("http://go.microsoft.com/fwlink/?LinkID=226948", set.Last().Source);
        }

        [Fact]
        public void InitSourceFileReadsFromDiskWhenFileAlreadyExists()
        {
            // Arrange
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(s => s.Exists()).Returns(true);
            ISet<WebPackageSource> set = null;

            // Act
            PackageManagerModule.InitPackageSourceFile(sourceFile.Object, ref set);

            // Assert
            Assert.NotNull(set);
            Assert.Equal(2, set.Count());
        }

        [Fact]
        public void AddFeedWritesSourceIfItDoesNotExist()
        {
            // Arrange
            bool writeCalled = false;
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(c => c.WriteSources(It.IsAny<IEnumerable<WebPackageSource>>())).Callback(() => writeCalled = true);
            ISet<WebPackageSource> set = new HashSet<WebPackageSource>(GetSources());

            // Act
            bool returnValue = PackageManagerModule.AddPackageSource(sourceFile.Object, set, new WebPackageSource(source: "http://www.microsoft.com/feed3", name: "Feed3"));

            // Assert
            Assert.Equal(3, set.Count());
            Assert.True(writeCalled);
            Assert.True(returnValue);
        }

        [Fact]
        public void AddFeedDoesNotWritesSourceIfExists()
        {
            // Arrange
            bool writeCalled = false;
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(c => c.WriteSources(It.IsAny<IEnumerable<WebPackageSource>>())).Callback(() => writeCalled = true);
            ISet<WebPackageSource> set = new HashSet<WebPackageSource>(GetSources());

            // Act
            bool returnValue = PackageManagerModule.AddPackageSource(sourceFile.Object, set, new WebPackageSource(source: "http://www.microsoft.com/feed1", name: "Feed1"));

            // Assert
            Assert.Equal(2, set.Count());
            Assert.False(writeCalled);
            Assert.False(returnValue);
        }

        [Fact]
        public void RemoveFeedRemovesSourceFromSet()
        {
            // Arrange
            bool writeCalled = false;
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(c => c.WriteSources(It.IsAny<IEnumerable<WebPackageSource>>())).Callback(() => writeCalled = true);
            ISet<WebPackageSource> set = new HashSet<WebPackageSource>(GetSources());

            // Act
            PackageManagerModule.RemovePackageSource(sourceFile.Object, set, "feed1");

            // Assert
            Assert.Single(set);
            Assert.DoesNotContain(set, s => s.Name == "Feed1");
            Assert.True(writeCalled);
        }

        [Fact]
        public void RemoveFeedDoesNotAffectSourceFileIsFeedDoesNotExist()
        {
            // Arrange
            bool writeCalled = false;
            var sourceFile = GetPackagesSourceFile();
            sourceFile.Setup(c => c.WriteSources(It.IsAny<IEnumerable<WebPackageSource>>())).Callback(() => writeCalled = true);
            ISet<WebPackageSource> set = new HashSet<WebPackageSource>(GetSources());

            // Act
            PackageManagerModule.RemovePackageSource(sourceFile.Object, set, "feed3");

            // Assert
            Assert.Equal(2, set.Count());
            Assert.False(writeCalled);
        }

        private static Mock<IPackagesSourceFile> GetPackagesSourceFile()
        {
            var sourceFile = new Mock<IPackagesSourceFile>();
            sourceFile.Setup(c => c.ReadSources()).Returns(GetSources());
            return sourceFile;
        }

        private static IEnumerable<WebPackageSource> GetSources()
        {
            return new[]
            {
                new WebPackageSource(name: "Feed1", source: "http://www.microsoft.com/feed1"),
                new WebPackageSource(name: "Feed2", source: "http://www.microsoft.com/feed2")
            };
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/PackagesSourceFileTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Text;
using System.Web.WebPages.Administration.PackageManager;
using System.Xml.Linq;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Administration.Test
{
    public class PackagesSourceFileTest
    {
        [Fact]
        public void PackagesSourceFileThrowsIfTheXmlElementDoesNotContainNameAndUrl()
        {
            // Arrange
            var element = new XElement("source");

            // Act and Assert
            Assert.Throws<FormatException>(() => PackageSourceFile.ParsePackageSource(element));
        }

        [Fact]
        public void PackagesSourceFileThrowsIfTheXmlElementDoesNotContainUrl()
        {
            // Arrange
            var element = new XElement("source", new XAttribute("displayname", "foo"), new XAttribute("filterpreferred", false));

            // Act and Assert
            Assert.Throws<FormatException>(() => PackageSourceFile.ParsePackageSource(element));
        }

        [Fact]
        public void PackagesSourceFileThrowsIfTheXmlElementDoesNotContainName()
        {
            // Arrange
            var element = new XElement("source", new XAttribute("url", "http://microsoft.com"), new XAttribute("filterpreferred", false));

            // Act and Assert
            Assert.Throws<FormatException>(() => PackageSourceFile.ParsePackageSource(element));
        }

        [Fact]
        public void PackagesSourceFileDoesNotThrowIfXmlElementDoesNotContainPreferred()
        {
            // Arrange
            var element = new XElement("source", new XAttribute("displayname", "foo"), new XAttribute("url", "http://microsoft.com"));

            // Act 
            var item = PackageSourceFile.ParsePackageSource(element);

            // Assert
            Assert.NotNull(item);
        }

        [Fact]
        public void PackagesSourceFileThrowsIfTheFeedUrlIsMalformed()
        {
            // Arrange
            var element = new XElement("source",
                                       new XAttribute("displayname", "foo"),
                                       new XAttribute("url", "bad-url.com"),
                                       new XAttribute("filterpreferred", false)
                );

            // Act and Assert
            Assert.Throws<FormatException>(() => PackageSourceFile.ParsePackageSource(element));
        }

        [Fact]
        public void PackagesSourceFileParsesXElement()
        {
            // Arrange
            var element = new XElement("source",
                                       new XAttribute("displayname", "foo"),
                                       new XAttribute("url", "http://www.microsoft.com"),
                                       new XAttribute("filterpreferred", true)
                );

            // Act 
            var WebPackageSource = PackageSourceFile.ParsePackageSource(element);

            // Assert
            Assert.Equal("foo", WebPackageSource.Name);
            Assert.Equal("http://www.microsoft.com", WebPackageSource.Source);
            Assert.True(WebPackageSource.FilterPreferredPackages);
        }

        [Fact]
        public void PackagesSourceFileReadsAllFeedsFromStream()
        {
            // Arrange
            var document = new XDocument(
                new XElement("sources",
                             new XElement("source", new XAttribute("displayname", "Feed1"), new XAttribute("url", "http://www.microsoft.com/feed1"), new XAttribute("filterpreferred", true)),
                             new XElement("source", new XAttribute("displayname", "Feed2"), new XAttribute("url", "http://www.microsoft.com/feed2"), new XAttribute("filterpreferred", true))
                    ));
            var stream = new MemoryStream();
            document.Save(stream);
            stream = new MemoryStream(stream.ToArray());
            string xml = new StreamReader(stream).ReadToEnd().TrimEnd('\0');

            // Act 
            var result = PackageSourceFile.ReadFeeds(() => new MemoryStream(Encoding.Default.GetBytes(xml)));

            // Assert
            Assert.Equal(2, result.Count());
            Assert.Equal("Feed1", result.First().Name);
            Assert.Equal("Feed2", result.Last().Name);
        }

        [Fact]
        public void PackagesSourceFileWritesAllFeedsToStream()
        {
            // Arrange
            var packagesSources = new[]
            {
                new WebPackageSource(name: "Feed1", source: "http://www.microsoft.com/Feed1"),
                new WebPackageSource(name: "Feed2", source: "http://www.microsoft.com/Feed2") { FilterPreferredPackages = true }
            };
            var stream = new MemoryStream();

            // Act
            PackageSourceFile.WriteFeeds(packagesSources, () => stream);
            stream = new MemoryStream(stream.ToArray());
            string result = new StreamReader(stream).ReadToEnd().TrimEnd('\0');

            // Assert
            var document = XDocument.Parse(result);
            Assert.Equal("sources", document.Root.Name);
            Assert.Equal(2, document.Root.Elements().Count());

            var firstFeed = document.Root.Elements().First();
            Assert.Equal("source", firstFeed.Name);
            Assert.Equal("Feed1", firstFeed.Attribute("displayname").Value);
            Assert.Equal("http://www.microsoft.com/Feed1", firstFeed.Attribute("url").Value);
            Assert.Equal("false", firstFeed.Attribute("filterpreferred").Value);

            var secondFeed = document.Root.Elements().Last();
            Assert.Equal("source", secondFeed.Name);
            Assert.Equal("Feed2", secondFeed.Attribute("displayname").Value);
            Assert.Equal("http://www.microsoft.com/Feed2", secondFeed.Attribute("url").Value);
            Assert.Equal("true", secondFeed.Attribute("filterpreferred").Value);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/PageUtilsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web.WebPages.Administration.PackageManager;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Administration.Test
{
    public class PageUtilsTest
    {
        [Fact]
        public void GetFilterValueReturnsNullIfValueWasNotFound()
        {
            // Arrange
            var request = new Mock<HttpRequestBase>();
            request.Setup(c => c.QueryString).Returns(new NameValueCollection());
            request.Setup(c => c.Cookies).Returns(new HttpCookieCollection());

            // Act
            var value = PageUtils.GetFilterValue(request.Object, "foo", "my-key");

            // Assert
            Assert.Null(value);
        }

        [Fact]
        public void GetFilterValueReturnsValueFromCookieIfQueryStringDoesNotContainKey()
        {
            // Arrange
            const string key = "my-key";
            const string value = "my-cookie-value";
            var request = new Mock<HttpRequestBase>();
            request.Setup(c => c.QueryString).Returns(new NameValueCollection());
            var cookies = new HttpCookieCollection();
            var cookie = new HttpCookie("foo");
            cookie[key] = value;
            cookies.Add(cookie);
            request.Setup(c => c.Cookies).Returns(cookies);

            // Act
            var returnedValue = PageUtils.GetFilterValue(request.Object, "foo", key);

            // Assert
            Assert.Equal(value, returnedValue);
        }

        [Fact]
        public void GetFilterValueReturnsValueFromQueryString()
        {
            // Arrange
            const string key = "my-key";
            const string requestValue = "my-request-value";
            const string cookieValue = "my-cookie-value";
            var request = new Mock<HttpRequestBase>();
            var queryString = new NameValueCollection();
            queryString[key] = requestValue;
            request.Setup(c => c.QueryString).Returns(queryString);
            var cookies = new HttpCookieCollection();
            var cookie = new HttpCookie("foo");
            cookie[key] = cookieValue;
            request.Setup(c => c.Cookies).Returns(cookies);

            // Act
            var returnedValue = PageUtils.GetFilterValue(request.Object, "foo", key);

            // Assert
            Assert.Equal(requestValue, returnedValue);
        }

        [Fact]
        public void PersistFilterCreatesCookieIfItDoesNotExist()
        {
            // Arrange
            var cookies = new HttpCookieCollection();
            var response = new Mock<HttpResponseBase>();
            response.Setup(c => c.Cookies).Returns(cookies);

            // Act
            PageUtils.PersistFilter(response.Object, "my-cookie", new Dictionary<string, string>());

            // Assert
            Assert.NotNull(cookies["my-cookie"]);
        }

        [Fact]
        public void PersistFilterUsesExistingCookie()
        {
            // Arrange
            var cookieName = "my-cookie";
            var cookies = new HttpCookieCollection();
            cookies.Add(new HttpCookie(cookieName));
            var response = new Mock<HttpResponseBase>();
            response.Setup(c => c.Cookies).Returns(cookies);

            // Act
            PageUtils.PersistFilter(response.Object, "my-cookie", new Dictionary<string, string>());

            // Assert
            Assert.Single(cookies);
        }

        [Fact]
        public void PersistFilterAddsDictionaryEntriesToCookie()
        {
            // Arrange
            var cookies = new HttpCookieCollection();
            var response = new Mock<HttpResponseBase>();
            response.Setup(c => c.Cookies).Returns(cookies);

            // Act
            PageUtils.PersistFilter(response.Object, "my-cookie", new Dictionary<string, string>() { { "a", "b" }, { "x", "y" } });

            // Assert
            var cookie = cookies["my-cookie"];
            Assert.Equal("b", cookie["a"]);
            Assert.Equal("y", cookie["x"]);
        }

        [Fact]
        public void IsValidLicenseUrlReturnsTrueForHttpUris()
        {
            // Arrange
            var uri = new Uri("http://www.microsoft.com");

            // Act and Assert
            Assert.True(PageUtils.IsValidLicenseUrl(uri));
        }

        [Fact]
        public void IsValidLicenseUrlReturnsTrueForHttpsUris()
        {
            // Arrange
            var uri = new Uri("HTTPs://www.asp.net");

            // Act and Assert
            Assert.True(PageUtils.IsValidLicenseUrl(uri));
        }

        [Fact]
        public void IsValidLicenseUrlReturnsFalseForNonHttpUris()
        {
            // Arrange
            var jsUri = new Uri("javascript:alert('Hello world');");
            var fileShareUri = new Uri(@"c:\windows\system32\notepad.exe");
            var mailToUti = new Uri("mailto:invalid-email@microsoft.com");

            // Act and Assert
            Assert.False(PageUtils.IsValidLicenseUrl(jsUri));
            Assert.False(PageUtils.IsValidLicenseUrl(fileShareUri));
            Assert.False(PageUtils.IsValidLicenseUrl(mailToUti));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/PreApplicationStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Administration.Test
{
    public class PreApplicationStartCodeTest
    {
        [Fact]
        public void StartTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var adminPackageAssembly = typeof(PreApplicationStartCode).Assembly;
                AppDomainUtils.SetPreAppStartStage();
                PreApplicationStartCode.Start();
                // Call a second time to ensure multiple calls do not cause issues
                PreApplicationStartCode.Start();

                // TODO: Need a way to see if the module was actually registered
                var registeredAssemblies = ApplicationPart.GetRegisteredParts().ToList();
                ApplicationPart part = Assert.Single(registeredAssemblies);
                part.Assembly.Equals(adminPackageAssembly);
            });
        }

        [Fact]
        public void TestPreAppStartClass()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/RemoteAssemblyTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.WebPages.Administration.PackageManager;
using Microsoft.TestCommon;
using Moq;
using NuGet.Runtime;

namespace System.Web.WebPages.Administration.Test
{
    public class RemoteAssemblyTest
    {
        [Fact]
        public void GetAssembliesForBindingRedirectReturnsEmptySequenceIfNoBinAssembliesAreFound()
        {
            // Act
            var assemblies = RemoteAssembly.GetAssembliesForBindingRedirect(AppDomain.CurrentDomain, @"x:\site\bin", (_, __) => Enumerable.Empty<IAssembly>());

            // Assert
            Assert.Empty(assemblies);
        }

        [Fact]
        public void RemoteAssemblyComparesById()
        {
            // Arrange
            var assemblyA = new RemoteAssembly("A", null, null, null);
            var assemblyB = new Mock<IAssembly>(MockBehavior.Strict);
            assemblyB.SetupGet(b => b.Name).Returns("Z").Verifiable();

            // Act
            var result = RemoteAssembly.Compare(assemblyA, assemblyB.Object);

            // Assert
            Assert.Equal(-25, result);
            assemblyB.Verify();
        }

        [Fact]
        public void RemoteAssemblyComparesByVersionIfIdsAreIdentical()
        {
            // Arrange
            var assemblyA = new RemoteAssembly("A", new Version("2.0.0.0"), null, null);
            var assemblyB = new Mock<IAssembly>(MockBehavior.Strict);
            assemblyB.SetupGet(b => b.Name).Returns("A").Verifiable();
            assemblyB.SetupGet(b => b.Version).Returns(new Version("1.0.0.0")).Verifiable();

            // Act
            var result = RemoteAssembly.Compare(assemblyA, assemblyB.Object);

            // Assert
            Assert.Equal(1, result);
            assemblyB.Verify();
        }

        [Fact]
        public void RemoteAssemblyComparesByPublicKeyIfIdsAndVersionAreIdentical()
        {
            // Arrange
            var assemblyA = new RemoteAssembly("A", new Version("1.0.0.0"), "C", null);
            var assemblyB = new Mock<IAssembly>(MockBehavior.Strict);
            assemblyB.SetupGet(b => b.Name).Returns("A").Verifiable();
            assemblyB.SetupGet(b => b.Version).Returns(new Version("1.0.0.0")).Verifiable();
            assemblyB.SetupGet(b => b.PublicKeyToken).Returns("E").Verifiable();

            // Act
            var result = RemoteAssembly.Compare(assemblyA, assemblyB.Object);

            // Assert
            Assert.Equal(-2, result);
            assemblyB.Verify();
        }

        [Fact]
        public void RemoteAssemblyComparesByCultureIfIdVersionAndPublicKeyAreIdentical()
        {
            // Arrange
            var assemblyA = new RemoteAssembly("A", new Version("1.0.0.0"), "public-key", "en-us");
            var assemblyB = new Mock<IAssembly>(MockBehavior.Strict);
            assemblyB.SetupGet(b => b.Name).Returns("A").Verifiable();
            assemblyB.SetupGet(b => b.Version).Returns(new Version("1.0.0.0")).Verifiable();
            assemblyB.SetupGet(b => b.PublicKeyToken).Returns("public-key").Verifiable();
            assemblyB.SetupGet(b => b.Culture).Returns("en-uk").Verifiable();

            // Act
            var result = RemoteAssembly.Compare(assemblyA, assemblyB.Object);

            // Assert
            Assert.Equal(8, result);
            assemblyB.Verify();
        }

        [Fact]
        public void RemoteAssemblyReturns0IfAllValuesAreIdentical()
        {
            // Arrange
            var assemblyA = new RemoteAssembly("A", new Version("1.0.0.0"), "public-key", "en-us");
            var assemblyB = new RemoteAssembly("A", new Version("1.0.0.0"), "public-key", "en-us");

            // Act
            var result = RemoteAssembly.Compare(assemblyA, assemblyB);

            // Assert
            Assert.Equal(0, result);
        }

        [Fact]
        public void RemoteAssemblyReturns1IfValueToBeComparedToIsNull()
        {
            // Arrange
            RemoteAssembly assemblyA = new RemoteAssembly("A", new Version("1.0.0.0"), "public-key", "en-us");
            RemoteAssembly assemblyB = null;

            // Act
            var result = assemblyA.CompareTo(assemblyB);

            // Assert
            Assert.Equal(1, result);
        }

        [Fact]
        public void EqualReturnsTrueIfValuesAreIdentical()
        {
            // Arrange
            var assemblyA = new RemoteAssembly("A", new Version("1.0.0.0"), "public-key", "en-us");
            var assemblyB = new RemoteAssembly("A", new Version("1.0.0.0"), "public-key", "en-us");

            // Act
            var result = assemblyA.Equals(assemblyB);

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void EqualReturnsFalseIfValuesAreNotIdentical()
        {
            // Arrange
            var assemblyA = new RemoteAssembly("A", new Version("1.0.0.0"), "public-key", "en-us");
            var assemblyB = new RemoteAssembly("A", new Version("1.0.0.1"), "public-key", "en-us");

            // Act
            var result = assemblyA.Equals(assemblyB);

            // Assert
            Assert.False(result);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/System.Web.WebPages.Administration.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{21C729D6-ECF8-47EF-A236-7C6A4272EAF0}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.WebPages.Administration.Test</RootNamespace>
    <AssemblyName>System.Web.WebPages.Administration.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="NuGet.Core, Version=1.6.30117.9648, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
      <Private>True</Private>
      <HintPath>..\..\packages\Nuget.Core.1.6.2\lib\net40\NuGet.Core.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core">
      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    </Reference>
    <Reference Include="System.Web" />
    <Reference Include="System.XML" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
      <Visible>False</Visible>
    </CodeAnalysisDependentAssemblyPaths>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Administration\System.Web.WebPages.Administration.csproj">
      <Project>{C23F02FC-4538-43F5-ABBA-38BA069AEA8F}</Project>
      <Name>System.Web.WebPages.Administration</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9B7E3740-6161-4548-833C-4BBCA43B970E}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AdminPackageTest.cs" />
    <Compile Include="PackageManagerModuleTest.cs" />
    <Compile Include="PackagesSourceFileTest.cs" />
    <Compile Include="PageUtilsTest.cs" />
    <Compile Include="PreApplicationStartCodeTest.cs" />
    <Compile Include="RemoteAssemblyTest.cs" />
    <Compile Include="WebProjectManagerTest.cs" />
    <Compile Include="WebProjectSystemTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.WebPages.Administration.Test/WebProjectManagerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.WebPages.Administration.PackageManager;
using Microsoft.TestCommon;
using Moq;
using NuGet;

namespace System.Web.WebPages.Administration.Test
{
    public class WebPackageManagerTest
    {
        [Fact]
        public void ConstructorThrowsIfRemoteSourceIsNullOrEmpty()
        {
            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebProjectManager((string)null, "foo"), "remoteSource");
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebProjectManager("", @"D:\baz"), "remoteSource");
        }

        [Fact]
        public void ConstructorThrowsIfSiteRootIsNullOrEmpty()
        {
            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebProjectManager("foo", null), "siteRoot");
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebProjectManager("foo", ""), "siteRoot");
        }

        [Fact]
        public void AllowInstallingPackageWithToolsFolderDoNotThrow()
        {
            // Arrange
            var projectManager = new Mock<IProjectManager>();
            projectManager.Setup(p => p.AddPackageReference("A", new SemanticVersion("1.0"), false, false)).Verifiable();

            var webProjectManager = new WebProjectManager(projectManager.Object, @"x:\")
            {
                DoNotAddBindingRedirects = true
            };

            var packageFile1 = new Mock<IPackageFile>();
            packageFile1.Setup(p => p.Path).Returns("tools\\install.ps1");

            var packageFile2 = new Mock<IPackageFile>();
            packageFile2.Setup(p => p.Path).Returns("content\\A.txt");

            var package = new Mock<IPackage>();
            package.Setup(p => p.Id).Returns("A");
            package.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
            package.Setup(p => p.GetFiles()).Returns(new[] { packageFile1.Object, packageFile2.Object });

            // Act
            webProjectManager.InstallPackage(package.Object, appDomain: null);

            // Assert
            projectManager.Verify();
        }

        [Fact]
        public void GetLocalRepositoryReturnsPackagesFolderUnderAppData()
        {
            // Arrange
            var siteRoot = "my-site";

            // Act
            var repositoryFolder = WebProjectManager.GetWebRepositoryDirectory(siteRoot);

            Assert.Equal(@"my-site\App_Data\packages", repositoryFolder);
        }

        [Fact]
        public void GetPackagesReturnsAllItemsWhenNoSearchTermIsIncluded()
        {
            // Arrange
            var repository = GetRepository();

            // Act
            var result = WebProjectManager.GetPackages(repository, String.Empty);

            // Assert
            Assert.Equal(3, result.Count());
        }

        [Fact]
        public void GetPackagesReturnsItemsContainingSomeSearchToken()
        {
            // Arrange
            var repository = GetRepository();

            // Act
            var result = WebProjectManager.GetPackages(repository, "testing .NET");
            var package = result.SingleOrDefault();

            // Assert
            Assert.NotNull(package);
            Assert.Equal("A", package.Id);
        }

        [Fact]
        public void GetPackagesWithLicenseReturnsAllDependenciesWithRequiresAcceptance()
        {
            // Arrange
            var remoteRepository = GetRepository();
            var localRepository = new Mock<IPackageRepository>().Object;

            // Act
            var package = remoteRepository.GetPackages().Find("C").SingleOrDefault();
            var result = WebProjectManager.GetPackagesRequiringLicenseAcceptance(package, localRepository, remoteRepository);

            // Assert
            Assert.Equal(2, result.Count());
            Assert.Contains(result, c => c.Id == "C");
            Assert.Contains(result, c => c.Id == "B");
        }

        [Fact]
        public void GetPackagesWithLicenseReturnsEmptyResultForPackageThatDoesNotRequireLicenses()
        {
            // Arrange
            var remoteRepository = GetRepository();
            var localRepository = new Mock<IPackageRepository>().Object;

            // Act
            var package = remoteRepository.GetPackages().Find("A").SingleOrDefault();
            var result = WebProjectManager.GetPackagesRequiringLicenseAcceptance(package, localRepository, remoteRepository);

            // Assert
            Assert.False(result.Any());
        }

        private static IPackageRepository GetRepository()
        {
            Mock<IPackageRepository> repository = new Mock<IPackageRepository>();
            var packages = new[]
            {
                GetPackage("A", desc: "testing"),
                GetPackage("B", version: "1.1", requiresLicense: true),
                GetPackage("C", requiresLicense: true, dependencies: new[]
                {
                    new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0") })
                })
            };
            repository.Setup(c => c.GetPackages()).Returns(packages.AsQueryable());

            return repository.Object;
        }

        private static IPackage GetPackage(string id, string version = "1.0", string desc = null, bool requiresLicense = false, IEnumerable<PackageDependency> dependencies = null)
        {
            Mock<IPackage> package = new Mock<IPackage>();
            package.SetupGet(c => c.Id).Returns(id);
            package.SetupGet(c => c.Version).Returns(SemanticVersion.Parse(version));
            package.SetupGet(c => c.Description).Returns(desc ?? id);
            package.SetupGet(c => c.RequireLicenseAcceptance).Returns(requiresLicense);
            package.SetupGet(c => c.LicenseUrl).Returns(new Uri("http://www." + id + ".com"));
            package.SetupGet(c => c.Dependencies).Returns(dependencies ?? Enumerable.Empty<PackageDependency>());
            return package.Object;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/WebProjectSystemTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.WebPages.Administration.PackageManager;
using System.Xml.Linq;
using Microsoft.TestCommon;
using Moq;
using NuGet;

namespace System.Web.WebPages.Administration.Test
{
    public class WebProjectSystemTest
    {
        [Fact]
        public void ResolvePathReturnsAppCodePathIfPathIsSourceFile()
        {
            // Arrange
            var path = "Foo.cs";
            var webProjectSystem = new WebProjectSystem(@"x:\");

            // Act
            var resolvedPath = webProjectSystem.ResolvePath(path);

            // Assert
            Assert.Equal(@"App_Code\Foo.cs", resolvedPath);
        }

        [Fact]
        public void ResolvePathReturnsOriginalPathIfSourceFilePathIsAlreadyUnderAppCode()
        {
            // Arrange
            var path = @"App_Code\Foo.cs";
            var webProjectSystem = new WebProjectSystem(@"x:\");

            // Act
            var resolvedPath = webProjectSystem.ResolvePath(path);

            // Assert
            Assert.Equal(path, resolvedPath);
        }

        [Fact]
        public void ResolvePathReturnsOriginalPathIfFileIsNotSource()
        {
            // Arrange
            var path = @"Foo.js";
            var webProjectSystem = new WebProjectSystem(@"x:\");

            // Act
            var resolvedPath = webProjectSystem.ResolvePath(path);

            // Assert
            Assert.Equal(path, resolvedPath);
        }

        [Fact]
        public void AddPackageWithFrameworkReferenceCreatesWebConfigIfItDoesNotExist()
        {
            // Arrange
            string webConfigPath = @"x:\my-website\web.config";
            MemoryStream memoryStream = new MemoryStream();

            var fileSystem = new Mock<IFileSystem>();
            fileSystem.SetupGet(f => f.Root).Returns("x:\\my-website");
            fileSystem.Setup(f => f.FileExists(It.Is<string>(p => p.Equals(webConfigPath)))).Returns(false).Verifiable();
            fileSystem.Setup(f => f.AddFile(It.Is<string>(p => p.Equals(webConfigPath)), It.IsAny<Stream>()))
                .Callback<string, Stream>((_, s) => { s.CopyTo(memoryStream); });

            var references = "System";

            // Act
            WebProjectSystem.AddReferencesToConfig(fileSystem.Object, references);

            // Assert
            memoryStream.Seek(0, SeekOrigin.Begin);
            XDocument document = XDocument.Load(memoryStream);

            var element = document.Root;
            Assert.Equal("configuration", element.Name);

            // Use SingleOrDefault to ensure there's exactly one element with that name
            var assemblies = document.Root
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("system.web"))
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("compilation"))
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("assemblies"));

            Assert.Equal(references, assemblies.Elements().First().Attribute("assembly").Value);
        }

        [Fact]
        public void AddPackageWithFrameworkReferenceCreatesWebConfigIfItExistsWithoutAssembliesNode()
        {
            // Arrange
            var webConfigPath = @"x:\my-website\web.config";
            var webConfigContent = @"<?xml version=""1.0""?>
                <configuration>
                    <connectionStrings>
                        <add name=""test"" />
                    </connectionStrings>
                    <system.web>
                        <profiles><add name=""awesomeprofile"" /></profiles>
                    </system.web>
                </configuration>

".AsStream();
            MemoryStream memoryStream = new MemoryStream();

            var fileSystem = new Mock<IFileSystem>();
            fileSystem.SetupGet(f => f.Root).Returns("x:\\my-website");
            fileSystem.Setup(f => f.FileExists(It.Is<string>(p => p.Equals(webConfigPath)))).Returns(true).Verifiable();
            fileSystem.Setup(f => f.OpenFile(It.Is<string>(p => p.Equals(webConfigPath)))).Returns(webConfigContent);
            fileSystem.Setup(f => f.AddFile(It.Is<string>(p => p.Equals(webConfigPath)), It.IsAny<Stream>()))
                .Callback<string, Stream>((_, s) => { s.CopyTo(memoryStream); });

            var references = "System.Data";

            // Act
            WebProjectSystem.AddReferencesToConfig(fileSystem.Object, references);

            // Assert
            memoryStream.Seek(0, SeekOrigin.Begin);
            XDocument document = XDocument.Load(memoryStream);

            var element = document.Root;
            Assert.Equal("configuration", element.Name);

            // Use SingleOrDefault to ensure there's exactly one element with that name
            var assemblies = document.Root
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("system.web"))
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("compilation"))
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("assemblies"));

            Assert.Equal(references, assemblies.Elements().First().Attribute("assembly").Value);

            // Make sure the original web.config content is unaffected
            Assert.Equal("test", document.Root
                                     .Elements().SingleOrDefault(e => e.Name.ToString().Equals("connectionStrings"))
                                     .Elements().SingleOrDefault(e => e.Name.ToString().Equals("add"))
                                     .Attributes().SingleOrDefault(e => e.Name.ToString().Equals("name")).Value);

            Assert.Equal("awesomeprofile", document.Root.Element("system.web").Element("profiles").Element("add").Attribute("name").Value);
        }

        [Fact]
        public void AddPackageWithFrameworkReferenceDoesNotAffectWebConfigIfReferencesAlreadyExist()
        {
            // Arrange
            var webConfigPath = @"x:\my-website\web.config";
            var memoryStream = new NeverCloseMemoryStream(@"<?xml version=""1.0""?>
                <configuration>
                    <connectionStrings>
                        <add name=""test"" />
                    </connectionStrings>
                    <system.web>
                        <compilation>
                            <assemblies>
                                <add assembly=""System.Data, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35"" />
                            </assemblies>
                        </compilation>
                        <profiles><add name=""awesomeprofile"" /></profiles>
                    </system.web>
                </configuration>

");

            var fileSystem = new Mock<IFileSystem>();
            fileSystem.SetupGet(f => f.Root).Returns("x:\\my-website");
            fileSystem.Setup(f => f.FileExists(It.Is<string>(p => p.Equals(webConfigPath)))).Returns(true);
            fileSystem.Setup(f => f.OpenFile(It.Is<string>(p => p.Equals(webConfigPath)))).Returns(() =>
            {
                memoryStream.Seek(0, SeekOrigin.Begin);
                return memoryStream;
            });
            fileSystem.Setup(f => f.AddFile(It.Is<string>(p => p.Equals(webConfigPath)), It.IsAny<Stream>()))
                .Callback<string, Stream>((_, stream) => { memoryStream = new NeverCloseMemoryStream(stream.ReadToEnd()); });

            // Act
            WebProjectSystem.AddReferencesToConfig(fileSystem.Object, "System.Data");
            WebProjectSystem.AddReferencesToConfig(fileSystem.Object, "Microsoft.Abstractions");

            // Assert
            memoryStream.Seek(0, SeekOrigin.Begin);
            XDocument document = XDocument.Load(memoryStream);

            var element = document.Root;
            Assert.Equal("configuration", element.Name);

            // Use SingleOrDefault to ensure there's exactly one element with that name
            var assemblies = document.Root
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("system.web"))
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("compilation"))
                .Elements().SingleOrDefault(e => e.Name.ToString().Equals("assemblies"));

            Assert.Equal(2, assemblies.Elements("add").Count());
            Assert.Equal("System.Data, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35",
                         assemblies.Elements().First().Attribute("assembly").Value);
            Assert.Equal("Microsoft.Abstractions",
                         assemblies.Elements().Last().Attribute("assembly").Value);

            // Make sure the original web.config content is unaffected
            Assert.Equal("test", document.Root
                                     .Elements().SingleOrDefault(e => e.Name.ToString().Equals("connectionStrings"))
                                     .Elements().SingleOrDefault(e => e.Name.ToString().Equals("add"))
                                     .Attributes().SingleOrDefault(e => e.Name.ToString().Equals("name")).Value);

            Assert.Equal("awesomeprofile", document.Root.Element("system.web").Element("profiles").Element("add").Attribute("name").Value);
        }

        [Fact]
        public void ResolveAssemblyPartialNameForCommonAssemblies()
        {
            // Arrange
            var commonAssemblies = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                { "System.Data", "System.Data, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" },
                { "System.Data.Linq", "System.Data.Linq, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" },
                { "System.Net", "System.Net, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" },
                { "System.Runtime.Caching", "System.Runtime.Caching, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" },
                { "System.Xml", "System.Xml, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" },
                { "System.Web.DynamicData", "System.Web.DynamicData, Version=4.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" },
            };

            // Act and Assert
            foreach (var item in commonAssemblies)
            {
                var resolvedName = WebProjectSystem.ResolvePartialAssemblyName(item.Key);

                Assert.Equal(item.Value, resolvedName);
            }
        }

        private static IFileSystem GetFileSystem()
        {
            var fileSystem = new Mock<IFileSystem>();
            fileSystem.Setup(c => c.Root).Returns(@"X:\packages\");
            return fileSystem.Object;
        }

        private class NeverCloseMemoryStream : MemoryStream
        {
            public NeverCloseMemoryStream(string content)
                : base(Encoding.UTF8.GetBytes(content))
            {
            }

            protected override void Dispose(bool disposing)
            {
                // Do nothing
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Administration.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Nuget.Core" version="1.6.2" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/App.Config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
</configuration>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/AssemblyUtilsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Deployment.Test
{
    public class AssemblyUtilsTest
    {
        private static readonly string LatestVersion = LatestRazorVersion.LatestVersion.ToString();

        private string LatestAssemblyName()
        {
            return AssemblyName(LatestVersion);
        }

        private string AssemblyName(string version, string culture = "neutral", string publicKeyToken = "31bf3856ad364e35")
        {
            return AssemblyNameFor("System.Web.WebPages.Deployment", version, culture, publicKeyToken);
        }

        private string AssemblyNameFor(string name)
        {
            return AssemblyNameFor(name, LatestVersion);
        }

        private string AssemblyNameFor(string name, string version, string culture = "neutral", string publicKeyToken = "31bf3856ad364e35")
        {
            string formatString = "{0}, Version={1}, Culture={2}, PublicKeyToken={3}";

            return string.Format(CultureInfo.InvariantCulture, formatString, name, version, culture, publicKeyToken);
        }

        [Fact]
        public void GetMaxAssemblyVersionReturnsMaximumAvailableVersion()
        {
            // Arrange
            var assemblies = new[]
            {
                new AssemblyName(AssemblyName("1.0.0.0")),
                new AssemblyName(AssemblyName("3.0.0.0")),
                new AssemblyName(LatestAssemblyName()),
                new AssemblyName(AssemblyName("2.0.0.0")),
            };

            // Act
            var maxVersion = AssemblyUtils.GetMaxWebPagesVersion(assemblies);

            // Assert
            Assert.Equal(LatestRazorVersion.LatestVersion, maxVersion);
        }

        [Fact]
        public void GetMaxAssemblyVersionMatchesExactName()
        {
            // Arrange
            var assemblies = new[]
            {
                new AssemblyName(AssemblyName("1.0.0.0")),
                new AssemblyName(AssemblyName("2.2.0.0")),
                new AssemblyName(AssemblyName("2.2.0.0", publicKeyToken: "7777777777777777")),
                new AssemblyName(AssemblyName("2.2.0.0", culture: "en-US")),
                new AssemblyName(AssemblyName("3.0.0.0")),
                new AssemblyName(LatestAssemblyName()),
            };

            // Act
            var maxVersion = AssemblyUtils.GetMaxWebPagesVersion(assemblies);

            // Assert
            Assert.Equal(LatestRazorVersion.LatestVersion, maxVersion);
        }

        [Fact]
        public void GetVersionFromBinReturnsNullIfNoFileWithDeploymentAssemblyNameIsFoundInBin()
        {
            // Arrange
            var binDirectory = @"X:\test\project";
            TestFileSystem fileSystem = new TestFileSystem();

            // Act
            var binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, fileSystem, getAssemblyNameThunk: null);

            // Assert
            Assert.Null(binVersion);
        }

        [Fact]
        public void GetVersionFromBinReturnsVersionFromBinIfLower()
        {
            // Arrange
            var binDirectory = @"X:\test\project";
            TestFileSystem fileSystem = new TestFileSystem();
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName(AssemblyName("1.0.0.0"));

            // Act
            var binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, fileSystem, getAssembyName);

            // Assert
            Assert.Equal(new Version("1.0.0.0"), binVersion);
        }

        [Fact]
        public void GetVersionFromBinReturnsVersionFromBinIfSameVersion()
        {
            // Arrange
            var binDirectory = @"X:\test\project";
            TestFileSystem fileSystem = new TestFileSystem();
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName(LatestAssemblyName());

            // Act
            var binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, fileSystem, getAssembyName);

            // Assert
            Assert.Equal(LatestRazorVersion.LatestVersion, binVersion);
        }

        [Fact]
        public void GetVersionFromBinReturnsVersionFromBinIfHigherVersion()
        {
            // Arrange
            var binDirectory = @"X:\test\project";
            TestFileSystem fileSystem = new TestFileSystem();
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName("System.Web.WebPages.Deployment, Version=8.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");

            // Act
            var binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, fileSystem, getAssembyName);

            // Assert
            Assert.Equal(new Version("8.0.0.0"), binVersion);
        }

        [Fact]
        public void GetVersionFromBinReturnsNullIfFileInBinIsNotAValidBinary()
        {
            // Arrange
            var binDirectory = @"X:\test\project";
            TestFileSystem fileSystem = new TestFileSystem();
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            Func<string, AssemblyName> getAssembyName = _ => { throw new FileLoadException(); };

            // Act
            var binVersion = AssemblyUtils.GetVersionFromBin(binDirectory, fileSystem, getAssembyName);

            // Assert
            Assert.Null(binVersion);
        }

        [Fact]
        public void GetAssembliesForVersionReturnsCorrectSetForV1()
        {
            // Arrange
            var expectedAssemblies = new[]
            {
                "Microsoft.Web.Infrastructure, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                "System.Web.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                "System.Web.Helpers, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                "System.Web.WebPages, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                "System.Web.WebPages.Administration, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                "System.Web.WebPages.Razor, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                "WebMatrix.Data, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                "WebMatrix.WebData, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35"
            };

            // Act 
            var assemblies = AssemblyUtils.GetAssembliesForVersion(new Version("1.0.0.0"))
                .Select(c => c.ToString())
                .ToArray();

            // Assert
            Assert.Equal(expectedAssemblies, assemblies);
        }

        [Fact]
        public void GetAssembliesForVersionReturnsCorrectSetForVCurrent()
        {
            // Arrange
            var expectedAssemblies = new[]
            {
                AssemblyNameFor("Microsoft.Web.Infrastructure", "1.0.0.0"),
                AssemblyNameFor("System.Web.Razor"),
                AssemblyNameFor("System.Web.Helpers"),
                AssemblyNameFor("System.Web.WebPages"),
                AssemblyNameFor("System.Web.WebPages.Administration"),
                AssemblyNameFor("System.Web.WebPages.Razor"),
                AssemblyNameFor("WebMatrix.Data"),
                AssemblyNameFor("WebMatrix.WebData"),
            };

            // Act 
            var assemblies = AssemblyUtils.GetAssembliesForVersion(LatestRazorVersion.LatestVersion)
                .Select(c => c.ToString())
                .ToArray();

            // Assert
            Assert.Equal(expectedAssemblies, assemblies);
        }

        [Fact]
        public void GetMatchingAssembliesReturnsEmptyDictionaryIfAssemblyReferencesCollectionIsNull()
        {
            // Arrange
            Dictionary<string, IEnumerable<string>> assemblyReferences = null;

            // Act
            var referencedAssemblies = AssemblyUtils.GetAssembliesMatchingOtherVersions(assemblyReferences);

            // Assert
            Assert.Empty(referencedAssemblies);
        }

        [Fact]
        public void GetMatchingAssembliesReturnsEmptyDictionaryIfAssemblyReferencesCollectionIsEmpty()
        {
            // Arrange
            var assemblyReferences = new Dictionary<string, IEnumerable<string>>();

            // Act
            var referencedAssemblies = AssemblyUtils.GetAssembliesMatchingOtherVersions(assemblyReferences);

            // Assert
            Assert.Empty(referencedAssemblies);
        }

        [Fact]
        public void GetMatchingAssembliesReturnsEmptyDictionaryIfNoReferencesMatchWebPagesAssemblies()
        {
            // Arrange
            var assemblyReferences = new Dictionary<string, IEnumerable<string>>
            {
                { @"x:\site\bin\A.dll", new List<string> { "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null" }},
                { @"x:\site\bin\B.dll", new List<string> { "System.Web.Mvc, Version=2.1.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" }},
            };

            // Act
            var referencedAssemblies = AssemblyUtils.GetAssembliesMatchingOtherVersions(assemblyReferences);

            // Assert
            Assert.Empty(referencedAssemblies);
        }

        [Fact]
        public void GetMatchingAssembliesReturnsReferencingAssemblyAndWebPagesVersionForMatchingReferences()
        {
            // Arrange
            var assemblyReferences = new Dictionary<string, IEnumerable<string>>
            {
                { @"x:\site\bin\A.dll", new[] { "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null" }},
                { @"x:\site\bin\B.dll", new[] 
                    {
                        "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null",
                        AssemblyNameFor("System.Web.WebPages", "1.0.0.0"),
                        AssemblyNameFor("System.Web.Helpers", "1.0.0.0"),
                    }
                },
            };

            // Act
            var referencedAssemblies = AssemblyUtils.GetAssembliesMatchingOtherVersions(assemblyReferences);

            // Assert
            Assert.Equal(1, referencedAssemblies.Count);
            Assert.Equal(@"x:\site\bin\B.dll", referencedAssemblies.Single().Key);
            Assert.Equal(new Version("1.0.0.0"), referencedAssemblies.Single().Value);
        }

        [Fact]
        public void GetMatchingAssembliesFiltersWebPagesVersionsThatMatch()
        {
            // Arrange
            var assemblyReferences = new Dictionary<string, IEnumerable<string>>
            {
                { @"x:\site\bin\A.dll", new[] { "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null" }},
                { @"x:\site\bin\B.dll", new[] 
                    { 
                        "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null",
                        String.Format(CultureInfo.InvariantCulture, "System.Web.WebPages, Version={0}, Culture=neutral, PublicKeyToken=31bf3856ad364e35", AssemblyUtils.ThisAssemblyName.Version),
                        String.Format(CultureInfo.InvariantCulture, "System.Web.Helpers, Version={0}, Culture=neutral, PublicKeyToken=31bf3856ad364e35", AssemblyUtils.ThisAssemblyName.Version)
                    }
                },
                { @"x:\site\bin\C.dll", new[] 
                    { 
                        "mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=null",
                        "System.Web.WebPages.Razor, Version=1.2.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                        "System.Web.WebPages.Razor, Version=1.3.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35",
                    }
                },
            };

            // Act
            var referencedAssemblies = AssemblyUtils.GetAssembliesMatchingOtherVersions(assemblyReferences);

            // Assert
            Assert.Equal(1, referencedAssemblies.Count);
            Assert.Equal(@"x:\site\bin\C.dll", referencedAssemblies.Single().Key);
            Assert.Equal(new Version("1.2.0.0"), referencedAssemblies.Single().Value);
        }

        private static void EnsureDirectory(string directory)
        {
            if (!Directory.Exists(directory))
            {
                Directory.CreateDirectory(directory);
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Deployment.Test/DeploymentUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;

namespace System.Web.WebPages.Deployment.Test
{
    internal static class DeploymentUtil
    {
        public static string GetBinDirectory()
        {
            var tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
            return Path.Combine(tempDirectory, "bin");
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Deployment.Test/LatestRazorVersion.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Deployment.Test
{
    public static class LatestRazorVersion
    {
        public static readonly Version LatestVersion = VersionTestHelper.GetVersionFromAssembly("System.Web.Razor", typeof(ParserResults));
    }
}


================================================
FILE: test/System.Web.WebPages.Deployment.Test/PreApplicationStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Deployment.Test
{
    public class PreApplicationStartCodeTest
    {
        private const string DeploymentVersionFile = "System.Web.WebPages.Deployment";

        private readonly string LatestVersion = LatestRazorVersion.LatestVersion.ToString();

        [Fact]
        public void PreApplicationStartCodeDoesNothingIfWebPagesIsExplicitlyDisabled()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1", "2");

            var fileSystem = new TestFileSystem();
            var buildManager = new TestBuildManager();
            var nameValueCollection = GetAppSettings(enabled: false, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", "bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.False(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeUsesVersionSpecifiedInConfigIfWebPagesIsImplicitlyEnabled()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.12.123.1234", LatestVersion);
            Version webPagesVersion = new Version("1.12.123.1234");

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Default.cshtml");
            var buildManager = new TestBuildManager();
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: webPagesVersion);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", "bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, getAssemblyNameThunk: null);

            // Assert
            Assert.True(loaded);
            Assert.Equal(webPagesVersion, loadedVersion);
            Assert.False(registeredForChangeNotification);
            VerifyVersionFile(buildManager, webPagesVersion);
        }

        [Fact]
        public void PreApplicationStartCodeDoesNotLoadCurrentWebPagesIfOnlyVersionIsListedInConfigAndNoFilesAreFoundInSiteRoot()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            Version webPagesVersion = AssemblyUtils.ThisAssemblyName.Version;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies(LatestVersion);

            var fileSystem = new TestFileSystem();
            var buildManager = new TestBuildManager();
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: webPagesVersion);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Arrange
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", "bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.True(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeRegistersForChangeNotificationIfNotExplicitlyDisabledAndNoFilesFoundInSiteRoot()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies(LatestVersion);

            var fileSystem = new TestFileSystem();
            var buildManager = new TestBuildManager();
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", "bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.True(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeDoesNothingIfV1IsAvailableInBinAndSiteIsExplicitlyEnabled()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            var v1Version = new Version("1.0.0.0");
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.0.0.0", LatestVersion);

            var binDirectory = DeploymentUtil.GetBinDirectory();

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            var buildManager = new TestBuildManager();
            var nameValueCollection = GetAppSettings(enabled: true, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName("System.Web.WebPages.Deployment, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", binDirectory, nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, getAssembyName);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.False(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeDoesNothingIfV1IsAvailableInBinAndFileExistsInRootOfWebSite()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            var v1Version = new Version("1.0.0.0");
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.0.0.0", LatestVersion);

            var binDirectory = DeploymentUtil.GetBinDirectory();

            var fileSystem = new TestFileSystem();
            var buildManager = new TestBuildManager();
            fileSystem.AddFile("Default.cshtml");
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName("System.Web.WebPages.Deployment, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", binDirectory, nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, getAssembyName);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.False(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeDoesNothingIfItIsAvailableInBinAndFileExistsInRootOfWebSite()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            var webPagesVersion = AssemblyUtils.ThisAssemblyName.Version;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies(AssemblyUtils.ThisAssemblyName.Version.ToString());

            var fileSystem = new TestFileSystem();
            var binDirectory = DeploymentUtil.GetBinDirectory();

            var buildManager = new TestBuildManager();
            fileSystem.AddFile("Default.vbhtml");
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName("System.Web.WebPages.Deployment, Version=" + AssemblyUtils.ThisAssemblyName.Version.ToString() + ", Culture=neutral, PublicKeyToken=31bf3856ad364e35");

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", binDirectory, nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, getAssembyName);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.False(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeLoadsV1IfNoVersionIsSpecifiedAndCurrentAssemblyIsTheMaximumVersionAvailable()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            var webPagesVersion = AssemblyUtils.ThisAssemblyName.Version;
            var v1Version = new Version("1.0.0.0");
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.0.0.0", LatestVersion);

            // Note: For this test to work with future versions we would need to create corresponding embedded resources with that version in it.
            var fileSystem = new TestFileSystem();
            var buildManager = new TestBuildManager();
            fileSystem.AddFile("Index.cshtml");
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", "bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null);

            // Assert
            Assert.True(loaded);
            Assert.Equal(v1Version, loadedVersion);
            Assert.False(registeredForChangeNotification);
            VerifyVersionFile(buildManager, v1Version);
        }

        [Fact]
        public void PreApplicationStartCodeThrowsIfNoVersionIsSpecifiedAndV1IsNotAvailable()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            var webPagesVersion = AssemblyUtils.ThisAssemblyName.Version;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies(LatestVersion);

            // Note: For this test to work with future versions we would need to create corresponding embedded resources with that version in it.
            var fileSystem = new TestFileSystem();
            var buildManager = new TestBuildManager();
            fileSystem.AddFile("Index.cshtml");
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() =>
                PreApplicationStartCode.StartCore(fileSystem, "", "bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null),
@"Could not determine which version of ASP.NET Web Pages to use.

In order to use this site, specify a version in the site’s web.config file. For more information, see the following article on the Microsoft support site: http://go.microsoft.com/fwlink/?LinkId=254126");
            Assert.False(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeDoesNotLoadIfAHigherVersionIsAvailableInBin()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies(LatestVersion, "8.0.0.0");

            var binDirectory = DeploymentUtil.GetBinDirectory();

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Index.cshtml");
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            var buildManager = new TestBuildManager();
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName("System.Web.WebPages.Deployment, Version=8.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", binDirectory, nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, getAssembyName);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.False(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeDoesNotLoadIfAHigherVersionIsAvailableInGac()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            // Hopefully we'd have figured out a better way to load Plan9 by v8.
            var webPagesVersion = new Version("8.0.0.0");
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.0.0.0", LatestVersion, "8.0.0.0");

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Index.cshtml");
            var buildManager = new TestBuildManager();
            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: null);
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", "bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null);

            // Assert
            Assert.False(loaded);
            Assert.Null(loadedVersion);
            Assert.False(registeredForChangeNotification);
            Assert.Equal(0, buildManager.Stream.Length);
        }

        [Fact]
        public void PreApplicationStartCodeForcesRecompileIfPreviousVersionIsNotTheSameAsCurrentVersion()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies(LatestVersion);

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Index.cshtml");
            var buildManager = new TestBuildManager();
            var content = "1.0.0.0" + Environment.NewLine;
            buildManager.Stream = new MemoryStream(Encoding.Default.GetBytes(content));

            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: new Version(LatestVersion));
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act
            var ex = Assert.Throws<HttpCompileException>(() =>
                PreApplicationStartCode.StartCore(fileSystem, "", @"site\bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null)
            );

            // Assert
            Assert.Equal("Changes were detected in the Web Pages runtime version that require your application to be recompiled. Refresh your browser window to continue.", ex.Message);
            Assert.Equal((object)true, ex.Data["WebPages.VersionChange"]);
            Assert.False(registeredForChangeNotification);
            VerifyVersionFile(buildManager, new Version(LatestVersion));
            Assert.True(fileSystem.FileExists(@"site\bin\WebPagesRecompilation.deleteme"));
        }

        [Fact]
        public void PreApplicationStartCodeDoesNotForceRecompileIfNewVersionIsV1AndCurrentAssemblyIsNotMaxVersion()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies(LatestVersion, "5.0.0.0");

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Index.cshtml");
            var buildManager = new TestBuildManager();
            var content = AssemblyUtils.ThisAssemblyName.Version + Environment.NewLine;
            buildManager.Stream = new MemoryStream(Encoding.Default.GetBytes(content));

            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: new Version("1.0.0"));
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };

            // Act
            bool loaded = PreApplicationStartCode.StartCore(fileSystem, "", @"site\bin", nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, null);

            // Assert
            Assert.False(loaded);
            Assert.False(registeredForChangeNotification);
            VerifyVersionFile(buildManager, AssemblyUtils.ThisAssemblyName.Version);
            Assert.False(fileSystem.FileExists(@"site\bin\WebPagesRecompilation.deleteme"));
        }

        [Fact]
        public void PreApplicationStartCodeThrowsIfWebPagesIsInBinAndDifferentVersionIsSpecifiedInConfig()
        {
            // Arrange
            Version loadedVersion = null;
            bool registeredForChangeNotification = false;
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.0.0.0", LatestVersion);

            var binDirectory = DeploymentUtil.GetBinDirectory();

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Index.cshtml");
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            var buildManager = new TestBuildManager();
            var content = AssemblyUtils.ThisAssemblyName.Version + Environment.NewLine;
            buildManager.Stream = new MemoryStream(Encoding.Default.GetBytes(content));

            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: new Version(LatestVersion));
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { registeredForChangeNotification = true; };
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName("System.Web.WebPages.Deployment, Version=1.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35");

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() =>
                PreApplicationStartCode.StartCore(fileSystem, "", binDirectory, nameValueCollection, loadedAssemblies, buildManager, loadWebPages, registerForChange, getAssembyName),
                @"Conflicting versions of ASP.NET Web Pages detected: specified version is """ + LatestVersion + @""", but the version in bin is ""1.0.0.0"". To continue, remove files from the application's bin directory or remove the version specification in web.config."
            );

            Assert.False(registeredForChangeNotification);
            Assert.Null(loadedVersion);
        }

        [Fact]
        public void PreApplicationStartCodeThrowsIfVersionIsSpecifiedInConfigAndDifferentVersionExistsInBin()
        {
            // Arrange
            Version loadedVersion = null;

            var binDirectory = DeploymentUtil.GetBinDirectory();
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.0.0.0", AssemblyUtils.ThisAssemblyName.Version.ToString());

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Index.cshtml");
            fileSystem.AddFile(Path.Combine(binDirectory, "System.Web.WebPages.Deployment.dll"));
            var buildManager = new TestBuildManager();
            var content = AssemblyUtils.ThisAssemblyName.Version + Environment.NewLine;
            buildManager.Stream = new MemoryStream(Encoding.Default.GetBytes(content));

            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: new Version("1.0.0"));
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { };
            Func<string, AssemblyName> getAssembyName = _ => new AssemblyName("System.Web.WebPages.Deployment, Version=" + AssemblyUtils.ThisAssemblyName.Version + ", Culture=neutral, PublicKeyToken=31bf3856ad364e35");

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() =>
                                                              PreApplicationStartCode.StartCore(fileSystem, "", binDirectory, nameValueCollection, loadedAssemblies, buildManager: buildManager, loadWebPages: loadWebPages, registerForChangeNotification: registerForChange, getAssemblyNameThunk: getAssembyName),
                                                              String.Format(@"Conflicting versions of ASP.NET Web Pages detected: specified version is ""1.0.0.0"", but the version in bin is ""{0}"". To continue, remove files from the application's bin directory or remove the version specification in web.config.",
                                                                            AssemblyUtils.ThisAssemblyName.Version));
        }

        [Fact]
        public void PreApplicationStartCodeThrowsIfVersionSpecifiedInConfigIsNotAvailable()
        {
            // Arrange
            Version loadedVersion = null;

            var binDirectory = DeploymentUtil.GetBinDirectory();
            IEnumerable<AssemblyName> loadedAssemblies = GetAssemblies("1.0.0.0", AssemblyUtils.ThisAssemblyName.Version.ToString());

            var fileSystem = new TestFileSystem();
            fileSystem.AddFile("Index.cshtml");
            var buildManager = new TestBuildManager();
            var content = AssemblyUtils.ThisAssemblyName.Version + Environment.NewLine;
            buildManager.Stream = new MemoryStream(Encoding.Default.GetBytes(content));

            var nameValueCollection = GetAppSettings(enabled: null, webPagesVersion: new Version("1.5"));
            Action<Version> loadWebPages = (version) => { loadedVersion = version; };
            Action registerForChange = () => { };

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() =>
                                                              PreApplicationStartCode.StartCore(fileSystem, "", binDirectory, nameValueCollection, loadedAssemblies, buildManager: buildManager, loadWebPages: loadWebPages, registerForChangeNotification: registerForChange, getAssemblyNameThunk: null),
                                                              String.Format("Specified Web Pages version \"1.5.0.0\" could not be found. Update your web.config to specify a different version. Current version: \"{0}\".",
                                                                            AssemblyUtils.ThisAssemblyName.Version));
        }

        [Fact]
        public void TestPreAppStartClass()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }

        private static NameValueCollection GetAppSettings(bool? enabled, Version webPagesVersion)
        {
            var nameValueCollection = new NameValueCollection();
            if (enabled.HasValue)
            {
                nameValueCollection["webpages:enabled"] = enabled.Value ? "true" : "false";
            }
            if (webPagesVersion != null)
            {
                nameValueCollection["webpages:version"] = webPagesVersion.ToString();
            }

            return nameValueCollection;
        }

        private static void VerifyVersionFile(TestBuildManager buildManager, Version webPagesVersion)
        {
            var content = Encoding.UTF8.GetString(buildManager.Stream.ToArray());
            Version version = Version.Parse(content);
            Assert.Equal(webPagesVersion, version);
        }

        private class TestBuildManager : IBuildManager
        {
            private MemoryStream _memoryStream = new MemoryStream();

            public MemoryStream Stream
            {
                get { return _memoryStream; }
                set { _memoryStream = value; }
            }

            public Stream CreateCachedFile(string fileName)
            {
                Assert.Equal(DeploymentVersionFile, fileName);
                CopyMemoryStream();
                return _memoryStream;
            }

            public Stream ReadCachedFile(string fileName)
            {
                Assert.Equal(DeploymentVersionFile, fileName);
                CopyMemoryStream();
                return _memoryStream;
            }

            /// <summary>
            /// Need to do this because the MemoryStream is read and written to in consecutive calls which causes it to be closed / non-expandable.
            /// </summary>
            private void CopyMemoryStream()
            {
                var content = _memoryStream.ToArray();
                if (content.Length > 0)
                {
                    _memoryStream = new MemoryStream(_memoryStream.ToArray());
                }
                else
                {
                    _memoryStream = new MemoryStream();
                }
            }
        }

        private static IEnumerable<AssemblyName> GetAssemblies(params string[] versions)
        {
            return from version in versions
                   select new AssemblyName("System.Web.WebPages.Deployment, Version=" + version + ", Culture=neutral, PublicKeyToken=31bf3856ad364e35");
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Deployment.Test/System.Web.WebPages.Deployment.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{268DEE9D-F323-4A00-8ED8-3784388C3E3A}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.WebPages.Deployment.Test</RootNamespace>
    <AssemblyName>System.Web.WebPages.Deployment.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System" />
    <Reference Include="System.Web" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="AssemblyUtilsTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="DeploymentUtil.cs" />
    <Compile Include="LatestRazorVersion.cs" />
    <Compile Include="PreApplicationStartCodeTest.cs" />
    <Compile Include="TestFileSystem.cs" />
    <Compile Include="WebPagesDeploymentTest.cs">
      <SubType>Code</SubType>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8f18041b-9410-4c36-a9c5-067813df5f31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22BABB60-8F02-4027-AFFC-ACF069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="App.Config" />
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="TestFiles\ConfigTestAssemblies\V2_Signed\System.Web.WebPages.Deployment.dll" />
    <EmbeddedResource Include="TestFiles\ConfigTestAssemblies\V2_Unsigned\System.Web.WebPages.Deployment.dll" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\CshtmlFileConfigV1\Default.cshtml" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\CshtmlFileConfigV1\web.config" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\CshtmlFileNoVersion\Default.cshtml" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtml\Default.htm" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlConfigV1\Default.htm" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlConfigV1\web.config" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlNoConfigSetting\Default.htm" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlNoConfigSetting\web.config" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlWithEnabledSetting\Default.htm" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlWithEnabledSetting\web.config" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlWithEnabledSettingFalse\Default.htm" />
    <EmbeddedResource Include="TestFiles\ConfigTestSites\NoCshtmlWithEnabledSettingFalse\web.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFileSystem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Linq;
using Microsoft.Internal.Web.Utils;

namespace System.Web.WebPages.Deployment.Test
{
    public class TestFileSystem : IFileSystem
    {
        private readonly Dictionary<string, MemoryStream> _files = new Dictionary<string, MemoryStream>(StringComparer.OrdinalIgnoreCase);

        public void AddFile(string file, MemoryStream content = null)
        {
            content = content ?? new MemoryStream();
            _files[file] = content;
        }

        public bool FileExists(string path)
        {
            return _files.ContainsKey(path);
        }

        public Stream ReadFile(string path)
        {
            return _files[path];
        }

        public Stream OpenFile(string path)
        {
            MemoryStream memoryStream;
            if (_files.TryGetValue(path, out memoryStream))
            {
                var copiedStream = new MemoryStream(memoryStream.ToArray());
                _files[path] = copiedStream;
            }
            else
            {
                AddFile(path);
            }
            return _files[path];
        }

        public IEnumerable<string> EnumerateFiles(string path)
        {
            return from file in _files.Keys
                   where Path.GetDirectoryName(file).Equals(path, StringComparison.OrdinalIgnoreCase)
                   select file;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/CshtmlFileConfigV1/Default.cshtml
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
	<body>
	    Not a plan9 app!
	</body>
</html>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/CshtmlFileConfigV1/web.config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <appSettings>
        <add key="webpages:Version" value="1.0" />
    </appSettings>
</configuration>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/CshtmlFileNoVersion/Default.cshtml
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
	<body>
	    Not a plan9 app!
	</body>
</html>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtml/Default.htm
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
	<body>
	    Not a plan9 app!
	</body>
</html>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlConfigv1/Default.htm
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
	<body>
	    Not a plan9 app!
	</body>
</html>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlConfigv1/web.config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <appSettings>
        <add key="webPages:version" value="1.0" />
    </appSettings>
</configuration>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlNoConfigSetting/Default.htm
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
	<body>
	    Not a plan9 app!
	</body>
</html>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlNoConfigSetting/web.config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
</configuration>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlWithEnabledSetting/Default.htm
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
	<body>
	    Not a plan9 app!
	</body>
</html>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlWithEnabledSetting/web.config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <appSettings>
        <add key="webpages:Enabled" value="true" />
    </appSettings>
</configuration>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlWithEnabledSettingFalse/Default.htm
================================================
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
	<head>
		<title></title>
	</head>
	<body>
	    Not a plan9 app!
	</body>
</html>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/TestFiles/ConfigTestSites/NoCshtmlWithEnabledSettingFalse/web.config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <appSettings>
        <add key="webpages:Enabled" value="false" />
    </appSettings>
</configuration>

================================================
FILE: test/System.Web.WebPages.Deployment.Test/WebPagesDeploymentTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Reflection;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Deployment.Test
{
    // We need to mark this type Serializable for TDD.Net to work with some of the AppDomain tests
    [Serializable]
    public class WebPagesDeploymentTest : IDisposable
    {
        private const string TestNamespacePrefix = "System.Web.WebPages.Deployment.Test.TestFiles.";

        private static readonly IDictionary<string, string> _deploymentPaths = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
        {
            { @"ConfigTestSites.CshtmlFileNoVersion.Default.cshtml", @"ConfigTestSites\CshtmlFileNoVersion\Default.cshtml" },
            { @"ConfigTestSites.NoCshtmlWithEnabledSetting.Default.htm", @"ConfigTestSites\NoCshtmlWithEnabledSetting\Default.htm" },
            { @"ConfigTestSites.NoCshtmlNoConfigSetting.web.config", @"ConfigTestSites\NoCshtmlNoConfigSetting\web.config" },
            { @"ConfigTestSites.NoCshtmlWithEnabledSetting.web.config", @"ConfigTestSites\NoCshtmlWithEnabledSetting\web.config" },
            { @"ConfigTestSites.NoCshtmlWithEnabledSettingFalse.Default.htm", @"ConfigTestSites\NoCshtmlWithEnabledSettingFalse\Default.htm" },
            { @"ConfigTestAssemblies.V2_Unsigned.System.Web.WebPages.Deployment.dll", @"ConfigTestAssemblies\V2_Unsigned\System.Web.WebPages.Deployment.dll" },
            { @"ConfigTestAssemblies.V2_Signed.System.Web.WebPages.Deployment.dll", @"ConfigTestAssemblies\V2_Signed\System.Web.WebPages.Deployment.dll" },
            { @"ConfigTestSites.NoCshtmlWithEnabledSettingFalse.web.config", @"ConfigTestSites\NoCshtmlWithEnabledSettingFalse\web.config" },
            { @"ConfigTestSites.CshtmlFileConfigV1.Default.cshtml", @"ConfigTestSites\CshtmlFileConfigV1\Default.cshtml" },
            { @"ConfigTestSites.NoCshtml.Default.htm", @"ConfigTestSites\NoCshtml\Default.htm" },
            { @"ConfigTestSites.NoCshtmlNoConfigSetting.Default.htm", @"ConfigTestSites\NoCshtmlNoConfigSetting\Default.htm" },
            { @"ConfigTestSites.CshtmlFileConfigV1.web.config", @"ConfigTestSites\CshtmlFileConfigV1\web.config" },
            { @"ConfigTestSites.NoCshtmlConfigV1.Default.htm", @"ConfigTestSites\NoCshtmlConfigV1\Default.htm" },
            { @"ConfigTestSites.NoCshtmlConfigV1.web.config", @"ConfigTestSites\NoCshtmlConfigV1\web.config" },
        };

        private readonly string _tempPath = GetTempPath();

        public WebPagesDeploymentTest()
        {
            var assembly = typeof(WebPagesDeploymentTest).Assembly;
            foreach (var item in _deploymentPaths)
            {
                new TestFile(TestNamespacePrefix + item.Key, assembly).Save(Path.Combine(_tempPath, item.Value));
            }
        }

        public void Dispose()
        {
            try
            {
                Directory.Delete(_tempPath, recursive: true);
            }
            catch
            {
            }
        }

        [Fact]
        public void IsEnabledReturnsFalseIfNoCshtmlOrConfigFile()
        {
            Assert.False(WebPagesDeployment.IsEnabled(Path.Combine(_tempPath, @"ConfigTestSites\NoCshtml")));
        }

        [Fact]
        public void IsEnabledReturnsFalseIfNoCshtmlAndNoConfigSetting()
        {
            Assert.False(WebPagesDeployment.IsEnabled(Path.Combine(_tempPath, @"ConfigTestSites\NoCshtmlNoConfigSetting")));
        }

        [Fact]
        public void IsEnabledReturnsTrueIfNoCshtmlAndEnabledConfigSetting()
        {
            Assert.True(WebPagesDeployment.IsEnabled(Path.Combine(_tempPath, @"ConfigTestSites\NoCshtmlWithEnabledSetting")));
        }

        [Fact]
        public void IsEnabledReturnsTrueIfCshtmlFilePresent()
        {
            Assert.True(WebPagesDeployment.IsEnabled(Path.Combine(_tempPath, @"ConfigTestSites\CshtmlFileNoVersion")));
        }

        [Fact]
        public void IsExplicitlyDisabledReturnsTrueIfNoCshtmlAndEnabledConfigSettingSetToFalse()
        {
            Assert.True(WebPagesDeployment.IsExplicitlyDisabled(Path.Combine(_tempPath, @"ConfigTestSites\NoCshtmlWithEnabledSettingFalse")));
        }

        [Fact]
        public void IsExplicitlyDisabledReturnsFalseIfNoCshtmlAndEnabledConfigSettingSetToTrue()
        {
            Assert.False(WebPagesDeployment.IsExplicitlyDisabled(Path.Combine(_tempPath, @"ConfigTestSites\NoCshtmlWithEnabledSetting")));
        }

        [Fact]
        public void IsExplicitlyDisabledReturnsFalseIfNoCshtmlAndNoConfigSetting()
        {
            Assert.False(WebPagesDeployment.IsExplicitlyDisabled(Path.Combine(_tempPath, @"ConfigTestSites\NoCshtmlNoConfigSetting")));
        }

        [Fact]
        public void IsExplicitlyDisabledReturnsFalseIfNoCshtmlOrConfigFile()
        {
            Assert.False(WebPagesDeployment.IsExplicitlyDisabled(Path.Combine(_tempPath, @"ConfigTestSites\NoCshtml")));
        }

        [Fact]
        public void GetVersionReturnsValueFromAppSettingsIfNotExplicitlyDisabled()
        {
            // Arrange
            var version = "1.2.3.4";
            var appSettings = new NameValueCollection { { "webPages:Version", version } };
            var maxVersion = new Version("2.0");

            // Act
            var actualVersion = WebPagesDeployment.GetVersionInternal(appSettings, binVersion: null, defaultVersion: null);

            // Assert
            Assert.Equal(new Version(version), actualVersion);
        }

        [Fact]
        public void GetVersionReturnsValueEvenIfExplicitlyDisabled()
        {
            // Arrange
            var version = "1.2.3.4";
            var appSettings = new NameValueCollection { { "webPages:Version", version }, { "webPages:Enabled", "False" } };
            var maxVersion = new Version("2.0");

            // Act
            var actualVersion = WebPagesDeployment.GetVersionInternal(appSettings, binVersion: null, defaultVersion: null);

            // Assert
            Assert.Equal(new Version(version), actualVersion);
        }

        [Fact]
        public void GetVersionReturnsLowerVersionIfSpecifiedInConfig()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Arrange - Load v2 Config
                Assembly asm = Assembly.LoadFrom(Path.Combine(_tempPath, @"ConfigTestAssemblies\V2_Signed\System.Web.WebPages.Deployment.dll"));
                Assert.Equal(new Version(2, 0, 0, 0), asm.GetName().Version);
                Assert.Equal("System.Web.WebPages.Deployment", asm.GetName().Name);

                using (WebUtils.CreateHttpRuntime(@"~\foo", "."))
                {
                    string path = Path.Combine(_tempPath, @"ConfigTestSites\CshtmlFileConfigV1");

                    // Act
                    Version ver = WebPagesDeployment.GetVersionWithoutEnabledCheck(path);
                    Version explicitVersion = WebPagesDeployment.GetExplicitWebPagesVersion(path);

                    // Assert
                    Assert.Equal(new Version(1, 0, 0, 0), ver);
                    Assert.Equal(new Version(1, 0, 0, 0), explicitVersion);
                }
            });
        }

        [Fact]
        public void GetVersionReturnsLowerVersionIfSpecifiedInConfigAndNotExplicitlyDisabled()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Arrange - Load v2 Config
                Assembly asm = Assembly.LoadFrom(Path.Combine(_tempPath, @"ConfigTestAssemblies\V2_Signed\System.Web.WebPages.Deployment.dll"));
                Assert.Equal(new Version(2, 0, 0, 0), asm.GetName().Version);
                Assert.Equal("System.Web.WebPages.Deployment", asm.GetName().Name);

                using (WebUtils.CreateHttpRuntime(@"~\foo", "."))
                {
                    string path = Path.Combine(_tempPath, @"ConfigTestSites\NoCshtmlConfigV1");

                    // Act
                    Version ver = WebPagesDeployment.GetVersionWithoutEnabledCheck(path);
                    Version explicitVersion = WebPagesDeployment.GetExplicitWebPagesVersion(path);

                    // Assert
                    Assert.Equal(new Version(1, 0, 0, 0), ver);
                    Assert.Equal(new Version(1, 0, 0, 0), explicitVersion);
                }
            });
        }

        [Fact]
        public void GetVersionIgnoresUnsignedConfigDll()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Arrange - Load v2 Config
                Assembly asm = Assembly.LoadFrom(Path.Combine(_tempPath, @"ConfigTestAssemblies\V2_Unsigned\System.Web.WebPages.Deployment.dll"));
                Assert.Equal(new Version(2, 0, 0, 0), asm.GetName().Version);
                Assert.Equal("System.Web.WebPages.Deployment", asm.GetName().Name);

                using (WebUtils.CreateHttpRuntime(@"~\foo", "."))
                {
                    // Act
                    Version ver = WebPagesDeployment.GetVersionWithoutEnabledCheck(Path.Combine(_tempPath, @"ConfigTestSites\CshtmlFileNoVersion"));

                    // Assert
                    Assert.Equal(new Version("1.0.0.0"), ver);
                }
            });
        }

        [Fact]
        public void GetVersionReturnsV1IfCshtmlFilePresentButNoVersionIsSpecifiedInConfigOrBin()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Arrange - Load v2 Config
                Assembly asm = Assembly.LoadFrom(Path.Combine(_tempPath, @"ConfigTestAssemblies\V2_Signed\System.Web.WebPages.Deployment.dll"));
                Assert.Equal(new Version(2, 0, 0, 0), asm.GetName().Version);
                Assert.Equal("System.Web.WebPages.Deployment", asm.GetName().Name);

                using (WebUtils.CreateHttpRuntime(@"~\foo", "."))
                {
                    string path = Path.Combine(_tempPath, @"ConfigTestSites\CshtmlFileNoVersion");

                    // Act
                    Version ver = WebPagesDeployment.GetVersionWithoutEnabledCheck(path);
                    Version explicitVersion = WebPagesDeployment.GetExplicitWebPagesVersion(path);

                    // Assert
                    Assert.Equal(new Version("1.0.0.0"), ver);
                    Assert.Null(explicitVersion);
                }
            });
        }

        [Fact]
        public void GetVersionThrowsIfPathNullOrEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => WebPagesDeployment.GetVersionWithoutEnabledCheck(null), "path");
            Assert.ThrowsArgumentNullOrEmptyString(() => WebPagesDeployment.GetVersionWithoutEnabledCheck(String.Empty), "path");
        }

        [Fact]
        public void IsEnabledThrowsIfPathNullOrEmpty()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => WebPagesDeployment.IsEnabled(null), "path");
            Assert.ThrowsArgumentNullOrEmptyString(() => WebPagesDeployment.IsEnabled(String.Empty), "path");
        }

        [Theory]
        [InlineData(new object[] { null })]
        [InlineData(new object[] { "" })]
        public void ObsoleteGetVersionThrowsIfPathIsNullOrEmpty(string path)
        {
            // Arrange
            var fileSystem = new TestFileSystem();
            var configuration = new NameValueCollection();

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => WebPagesDeployment.GetObsoleteVersionInternal(path, configuration, fileSystem), "path");
        }

        [Fact]
        public void ObsoleteGetVersionReturnsNullIfNoFilesInTheSite()
        {
            // Arrange
            var path = "blah";
            var fileSystem = new TestFileSystem();
            var configuration = new NameValueCollection();

            // Act
            var version = WebPagesDeployment.GetObsoleteVersionInternal(path, configuration, fileSystem);

            // Assert
            Assert.Null(version);
        }

        [Fact]
        public void ObsoleteGetVersionReturnsV1VersionIfNoValueInConfigNoFilesInBinSiteContainsCshtmlFiles()
        {
            // Arrange
            var path = "blah";
            var fileSystem = new TestFileSystem();
            fileSystem.AddFile(@"blah\Foo.cshtml");
            var configuration = new NameValueCollection();

            // Act
            var version = WebPagesDeployment.GetObsoleteVersionInternal(path, configuration, fileSystem);

            // Assert
            Assert.Equal(new Version("1.0.0.0"), version);
        }

        [Fact]
        public void ObsoleteGetVersionReturnsVersionFromConfigIfDisabled()
        {
            // Arrange
            var maxVersion = new Version("3.0.3.4");
            var fileSystem = new TestFileSystem();
            var configuration = new NameValueCollection();
            configuration["webPages:Enabled"] = "False";
            configuration["webPages:Version"] = "3.0";
            var path = "blah";

            // Act
            var version = WebPagesDeployment.GetObsoleteVersionInternal(path, configuration, fileSystem);

            // Assert
            Assert.Equal(new Version("3.0.0.0"), version);
        }

        private static string GetTempPath()
        {
            return Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Deployment.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.WebPages.Razor.Test/PreApplicationStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Compilation;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Razor.Test
{
    public class PreApplicationStartCodeTest
    {
        [Fact]
        public void StartTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                AppDomainUtils.SetPreAppStartStage();
                PreApplicationStartCode.Start();
                var buildProviders = typeof(BuildProvider).GetField("s_dynamicallyRegisteredProviders", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
                Assert.Equal(2, buildProviders.GetType().GetProperty("Count", BindingFlags.Public | BindingFlags.Instance).GetValue(buildProviders, new object[] { }));
            });
        }

        [Fact]
        public void TestPreAppStartClass()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Razor.Test/RazorBuildProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.CodeDom.Compiler;
using System.Collections;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Web.Compilation;
using ASP;
using Microsoft.CSharp;
using Microsoft.TestCommon;
using Moq;

namespace ASP
{
    public class _Page_Foo_Test_cshtml
    {
    }
}

namespace System.Web.WebPages.Razor.Test
{
    public class RazorBuildProviderTest
    {
        private class MockAssemblyBuilder : IAssemblyBuilder
        {
            public BuildProvider BuildProvider { get; private set; }
            public CodeCompileUnit CompileUnit { get; private set; }
            public string LastTypeFactoryGenerated { get; private set; }

            public void AddCodeCompileUnit(BuildProvider buildProvider, CodeCompileUnit compileUnit)
            {
                BuildProvider = buildProvider;
                CompileUnit = compileUnit;
            }

            public void GenerateTypeFactory(string typeName)
            {
                LastTypeFactoryGenerated = typeName;
            }
        }

        [Fact]
        public void CodeCompilerTypeReturnsTypeFromCodeLanguage()
        {
            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Baz.cshtml", @"C:\Foo\Baz.cshtml");
            RazorBuildProvider provider = CreateBuildProvider("foo @bar baz");
            provider.Host = host;

            // Act
            CompilerType type = provider.CodeCompilerType;

            // Assert
            Assert.Equal(typeof(CSharpCodeProvider), type.CodeDomProviderType);
        }

        [Fact]
        public void CodeCompilerTypeSetsDebugFlagInFullTrust()
        {
            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Baz.cshtml", @"C:\Foo\Baz.cshtml");
            RazorBuildProvider provider = CreateBuildProvider("foo @bar baz");
            provider.Host = host;

            // Act
            CompilerType type = provider.CodeCompilerType;

            // Assert
            Assert.True(type.CompilerParameters.IncludeDebugInformation);
        }

        [Fact]
        public void GetGeneratedTypeUsesNameAndNamespaceFromHostToExtractType()
        {
            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Test.cshtml", @"C:\Foo\Test.cshtml");
            RazorBuildProvider provider = new RazorBuildProvider() { Host = host };
            CompilerResults results = new CompilerResults(new TempFileCollection());
            results.CompiledAssembly = typeof(_Page_Foo_Test_cshtml).Assembly;

            // Act
            Type typ = provider.GetGeneratedType(results);

            // Assert
            Assert.Equal(typeof(_Page_Foo_Test_cshtml), typ);
        }

        [Fact]
        public void GenerateCodeCoreAddsGeneratedCodeToAssemblyBuilder()
        {
            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Baz.cshtml", @"C:\Foo\Baz.cshtml");
            RazorBuildProvider provider = new RazorBuildProvider();
            CodeCompileUnit ccu = new CodeCompileUnit();
            MockAssemblyBuilder asmBuilder = new MockAssemblyBuilder();
            provider.Host = host;
            provider.GeneratedCode = ccu;

            // Act
            provider.GenerateCodeCore(asmBuilder);

            // Assert
            Assert.Same(provider, asmBuilder.BuildProvider);
            Assert.Same(ccu, asmBuilder.CompileUnit);
            Assert.Equal("ASP._Page_Foo_Baz_cshtml", asmBuilder.LastTypeFactoryGenerated);
        }

        [Fact]
        public void CodeGenerationStartedTest()
        {
            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Baz.cshtml", @"C:\Foo\Baz.cshtml");
            RazorBuildProvider provider = CreateBuildProvider("foo @bar baz");
            provider.Host = host;

            // Expected original base dependencies
            var baseDependencies = new ArrayList();
            baseDependencies.Add("/Samples/Foo/Baz.cshtml");

            // Expected list of dependencies after GenerateCode is called
            var dependencies = new ArrayList();
            dependencies.Add(baseDependencies[0]);
            dependencies.Add("/Samples/Foo/Foo.cshtml");

            // Set up the event handler
            provider.CodeGenerationStartedInternal += (sender, e) =>
            {
                var bp = sender as RazorBuildProvider;
                bp.AddVirtualPathDependency("/Samples/Foo/Foo.cshtml");
            };

            // Set up the base dependency
            MockAssemblyBuilder builder = new MockAssemblyBuilder();
            typeof(BuildProvider).GetField("_virtualPath", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(provider, CreateVirtualPath("/Samples/Foo/Baz.cshtml"));

            // Test that VirtualPathDependencies returns the original dependency before GenerateCode is called
            Assert.True(baseDependencies.OfType<string>().SequenceEqual(provider.VirtualPathDependencies.OfType<string>()));

            // Act
            provider.GenerateCodeCore(builder);

            // Assert
            Assert.NotNull(provider.AssemblyBuilderInternal);
            Assert.Equal(builder, provider.AssemblyBuilderInternal);
            Assert.True(dependencies.OfType<string>().SequenceEqual(provider.VirtualPathDependencies.OfType<string>()));
            Assert.Equal("/Samples/Foo/Baz.cshtml", provider.VirtualPath);
        }

        [Fact]
        public void AfterGeneratedCodeEventGetsExecutedAtCorrectTime()
        {
            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Baz.cshtml", @"C:\Foo\Baz.cshtml");
            RazorBuildProvider provider = CreateBuildProvider("foo @bar baz");
            provider.Host = host;

            provider.CodeGenerationCompletedInternal += (sender, e) =>
            {
                Assert.Equal("~/Foo/Baz.cshtml", e.VirtualPath);
                e.GeneratedCode.Namespaces.Add(new CodeNamespace("DummyNamespace"));
            };

            // Act
            CodeCompileUnit generated = provider.GeneratedCode;

            // Assert
            Assert.NotNull(generated.Namespaces
                               .OfType<CodeNamespace>()
                               .SingleOrDefault(ns => String.Equals(ns.Name, "DummyNamespace")));
        }

        [Fact]
        public void GeneratedCodeThrowsHttpParseExceptionForLastParserError()
        {
            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Baz.cshtml", @"C:\Foo\Baz.cshtml");
            RazorBuildProvider provider = CreateBuildProvider("foo @{ if( baz");
            provider.Host = host;

            // Act
            Assert.Throws<HttpParseException>(() => { CodeCompileUnit ccu = provider.GeneratedCode; });
        }

        [Fact]
        public void BuildProviderFiresEventToAlterHostBeforeBuildingPath()
        {
            // Arrange
            WebPageRazorHost expected = new TestHost("~/Foo/Boz.cshtml", @"C:\Foo\Boz.cshtml");
            WebPageRazorHost expectedBefore = new WebPageRazorHost("~/Foo/Baz.cshtml", @"C:\Foo\Baz.cshtml");
            RazorBuildProvider provider = CreateBuildProvider("foo");
            typeof(BuildProvider).GetField("_virtualPath", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(provider, CreateVirtualPath("/Samples/Foo/Baz.cshtml"));
            Mock.Get(provider).Setup(p => p.GetHostFromConfig()).Returns(expectedBefore);
            bool called = false;
            EventHandler<CompilingPathEventArgs> handler = (sender, args) =>
            {
                Assert.Equal("/Samples/Foo/Baz.cshtml", args.VirtualPath);
                Assert.Same(expectedBefore, args.Host);
                args.Host = expected;
                called = true;
            };
            RazorBuildProvider.CompilingPath += handler;

            try
            {
                // Act
                CodeCompileUnit ccu = provider.GeneratedCode;

                // Assert
                Assert.Equal("Test", ccu.Namespaces[0].Name);
                Assert.Same(expected, provider.Host);
                Assert.True(called);
            }
            finally
            {
                RazorBuildProvider.CompilingPath -= handler;
            }
        }

        private static object CreateVirtualPath(string path)
        {
            var vPath = typeof(BuildProvider).Assembly.GetType("System.Web.VirtualPath");
            var method = vPath.GetMethod("CreateNonRelative", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
            return method.Invoke(null, new object[] { path });
        }

        private static RazorBuildProvider CreateBuildProvider(string razorContent)
        {
            Mock<RazorBuildProvider> mockProvider = new Mock<RazorBuildProvider>()
            {
                CallBase = true
            };
            mockProvider.Setup(p => p.InternalOpenReader())
                .Returns(() => new StringReader(razorContent));
            return mockProvider.Object;
        }

        private class TestHost : WebPageRazorHost
        {
            public TestHost(string virtualPath, string physicalPath) : base(virtualPath, physicalPath) { }

            public override void PostProcessGeneratedCode(Web.Razor.Generator.CodeGeneratorContext context)
            {
                context.CompileUnit.Namespaces.Insert(0, new CodeNamespace("Test"));
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Razor.Test/System.Web.WebPages.Razor.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{66A74F3C-A106-4C1E-BAA0-001908FEA2CA}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.WebPages.Razor.Test</RootNamespace>
    <AssemblyName>System.Web.WebPages.Razor.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <!-- Temporarily disable Obsolete Warnings as Errors -->
    <NoWarn>0618</NoWarn>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Compile Include="PreApplicationStartCodeTest.cs" />
    <Compile Include="RazorBuildProviderTest.cs" />
    <Compile Include="WebCodeRazorEngineHostTest.cs" />
    <Compile Include="WebPageRazorEngineHostTest.cs" />
    <Compile Include="WebRazorHostFactoryTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Web" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="app.config">
      <SubType>Designer</SubType>
    </None>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.WebPages.Razor.Test/WebCodeRazorEngineHostTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.Linq;
using System.Web.Razor.Generator;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Razor.Test
{
    public class WebCodeRazorEngineHostTest
    {
        [Fact]
        public void ConstructorWithMalformedVirtualPathSetsDefaultProperties()
        {
            // Act
            WebCodeRazorHost host = new WebCodeRazorHost(@"~/Foo/App_Code\Bar\Baz\Qux.cshtml");

            // Assert
            Assert.Equal("System.Web.WebPages.HelperPage", host.DefaultBaseClass);
            Assert.Equal("ASP.Bar.Baz", host.DefaultNamespace);
            Assert.Equal("Qux", host.DefaultClassName);
            Assert.False(host.DefaultDebugCompilation);
            Assert.True(host.StaticHelpers);
        }

        [Fact]
        public void ConstructorWithFileOnlyVirtualPathSetsDefaultProperties()
        {
            // Act
            WebCodeRazorHost host = new WebCodeRazorHost(@"Foo.cshtml");

            // Assert
            Assert.Equal("System.Web.WebPages.HelperPage", host.DefaultBaseClass);
            Assert.Equal("ASP", host.DefaultNamespace);
            Assert.Equal("Foo", host.DefaultClassName);
            Assert.False(host.DefaultDebugCompilation);
        }

        [Fact]
        public void ConstructorWithVirtualPathSetsDefaultProperties()
        {
            // Act
            WebCodeRazorHost host = new WebCodeRazorHost("~/Foo/App_Code/Bar/Baz/Qux.cshtml");

            // Assert
            Assert.Equal("System.Web.WebPages.HelperPage", host.DefaultBaseClass);
            Assert.Equal("ASP.Bar.Baz", host.DefaultNamespace);
            Assert.Equal("Qux", host.DefaultClassName);
            Assert.False(host.DefaultDebugCompilation);
        }

        [Fact]
        public void ConstructorWithVirtualAndPhysicalPathSetsDefaultProperties()
        {
            // Act
            WebCodeRazorHost host = new WebCodeRazorHost("~/Foo/App_Code/Bar/Baz/Qux.cshtml", @"C:\Qux.doodad");

            // Assert
            Assert.Equal("System.Web.WebPages.HelperPage", host.DefaultBaseClass);
            Assert.Equal("ASP.Bar.Baz", host.DefaultNamespace);
            Assert.Equal("Qux", host.DefaultClassName);
            Assert.False(host.DefaultDebugCompilation);
        }

        [Fact]
        public void PostProcessGeneratedCodeRemovesExecuteMethod()
        {
            // Arrange
            WebCodeRazorHost host = new WebCodeRazorHost("Foo.cshtml");
            CodeGeneratorContext context = CodeGeneratorContext.Create(
                host,
                () => new CSharpCodeWriter(),
                "TestClass",
                "TestNamespace",
                "TestFile.cshtml",
                shouldGenerateLinePragmas: true);

            // Act
            host.PostProcessGeneratedCode(context);

            // Assert
            Assert.Empty(context.GeneratedClass.Members.OfType<CodeMemberMethod>());
        }

        [Fact]
        public void PostProcessGeneratedCodeAddsStaticApplicationInstanceProperty()
        {
            // Arrange
            WebCodeRazorHost host = new WebCodeRazorHost("Foo.cshtml");
            CodeGeneratorContext context =
                CodeGeneratorContext.Create(
                    host,
                    () => new CSharpCodeWriter(),
                    "TestClass",
                    "TestNamespace",
                    "Foo.cshtml",
                    shouldGenerateLinePragmas: true);

            // Act
            host.PostProcessGeneratedCode(context);

            // Assert
            CodeMemberProperty appInstance = context.GeneratedClass
                .Members
                .OfType<CodeMemberProperty>()
                .Where(p => p.Name.Equals("ApplicationInstance"))
                .SingleOrDefault();
            Assert.NotNull(appInstance);
            Assert.True(appInstance.Attributes.HasFlag(MemberAttributes.Static));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Razor.Test/WebPageRazorEngineHostTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.CodeDom;
using System.CodeDom.Compiler;
using System.IO;
using System.Linq;
using System.Text;
using System.Web.Razor;
using System.Web.Razor.Generator;
using Microsoft.CSharp;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Razor.Test
{
    public class WebPageRazorEngineHostTest
    {
        [Fact]
        public void ConstructorRequiresNonNullOrEmptyVirtualPath()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebPageRazorHost(null), "virtualPath");
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebPageRazorHost(String.Empty), "virtualPath");
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebPageRazorHost(null, "foo"), "virtualPath");
            Assert.ThrowsArgumentNullOrEmptyString(() => new WebPageRazorHost(String.Empty, "foo"), "virtualPath");
        }

        [Fact]
        public void ConstructorWithVirtualPathUsesItToDetermineBaseClassClassNameAndLanguage()
        {
            // Act
            WebPageRazorHost host = new WebPageRazorHost("~/Foo/Bar.cshtml");

            // Assert
            Assert.Equal("_Page_Foo_Bar_cshtml", host.DefaultClassName);
            Assert.Equal("System.Web.WebPages.WebPage", host.DefaultBaseClass);
            Assert.IsType<CSharpRazorCodeLanguage>(host.CodeLanguage);
            Assert.False(host.StaticHelpers);
        }

        [Fact]
        public void PostProcessGeneratedCodeAddsGlobalImports()
        {
            // Arrange
            WebPageRazorHost.AddGlobalImport("Foo.Bar");
            WebPageRazorHost host = new WebPageRazorHost("Foo.cshtml");
            CodeGeneratorContext context = CodeGeneratorContext.Create(
                host,
                () => new CSharpCodeWriter(),
                "TestClass",
                "TestNs",
                "TestFile.cshtml",
                shouldGenerateLinePragmas: true);

            // Act
            host.PostProcessGeneratedCode(context);

            // Assert
            Assert.Contains(context.Namespace.Imports.OfType<CodeNamespaceImport>(), import => String.Equals("Foo.Bar", import.Namespace));
        }

        [Fact]
        public void PostProcessGeneratedCodeAddsApplicationInstanceProperty()
        {
            string expectedPropertyCode =
                Environment.NewLine
              + "protected Foo.Bar ApplicationInstance {" + Environment.NewLine
              + "    get {" + Environment.NewLine
              + "        return ((Foo.Bar)(Context.ApplicationInstance));" + Environment.NewLine
              + "    }" + Environment.NewLine
              + "}" + Environment.NewLine;

            // Arrange
            WebPageRazorHost host = new WebPageRazorHost("Foo.cshtml")
            {
                GlobalAsaxTypeName = "Foo.Bar"
            };
            CodeGeneratorContext context = CodeGeneratorContext.Create(
                host,
                () => new CSharpCodeWriter(),
                "TestClass",
                "TestNs",
                "TestFile.cshtml",
                shouldGenerateLinePragmas: true);

            // Act
            host.PostProcessGeneratedCode(context);

            // Assert
            CodeMemberProperty property = context.GeneratedClass.Members[0] as CodeMemberProperty;
            Assert.NotNull(property);

            CSharpCodeProvider provider = new CSharpCodeProvider();
            StringBuilder builder = new StringBuilder();
            using (StringWriter writer = new StringWriter(builder))
            {
                provider.GenerateCodeFromMember(property, writer, new CodeGeneratorOptions());
            }

            Assert.Equal(expectedPropertyCode, builder.ToString());
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Razor.Test/WebRazorHostFactoryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Configuration;
using System.Reflection;
using System.Web.Configuration;
using System.Web.WebPages.Razor.Configuration;
using System.Web.WebPages.Razor.Resources;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Razor.Test
{
    public class WebRazorHostFactoryTest
    {
        public class TestFactory : WebRazorHostFactory
        {
            public override WebPageRazorHost CreateHost(string virtualPath, string physicalPath = null)
            {
                return new TestHost();
            }
        }

        public class TestHost : WebPageRazorHost
        {
            public TestHost()
                : base("Foo.cshtml")
            {
            }

            public new void RegisterSpecialFile(string fileName, Type baseType)
            {
                base.RegisterSpecialFile(fileName, baseType);
            }

            public new void RegisterSpecialFile(string fileName, string baseType)
            {
                base.RegisterSpecialFile(fileName, baseType);
            }
        }

        [Fact]
        public void CreateHostReturnsWebPageHostWithWebPageAsBaseClassIfVirtualPathIsNormalPage()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/Baz.cshtml", null);

            // Assert
            Assert.IsType<WebPageRazorHost>(host);
            Assert.Equal(WebPageRazorHost.PageBaseClass, host.DefaultBaseClass);
        }

        [Fact]
        public void CreateHostReturnsWebPageHostWithInitPageAsBaseClassIfVirtualPathIsPageStart()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/_pagestart.cshtml", null);

            // Assert
            Assert.IsType<WebPageRazorHost>(host);
            Assert.Equal(typeof(StartPage).FullName, host.DefaultBaseClass);
        }

        [Fact]
        public void CreateHostReturnsWebPageHostWithStartPageAsBaseClassIfVirtualPathIsAppStart()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/_appstart.cshtml", null);

            // Assert
            Assert.IsType<WebPageRazorHost>(host);
            Assert.Equal(typeof(ApplicationStartPage).FullName, host.DefaultBaseClass);
        }

        [Fact]
        public void CreateHostPassesPhysicalPathOnToWebCodeRazorHost()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/Baz/App_Code/Bar", @"C:\Foo.cshtml");

            // Assert
            Assert.Equal(@"C:\Foo.cshtml", host.PhysicalPath);
        }

        [Fact]
        public void CreateHostPassesPhysicalPathOnToWebPageRazorHost()
        {
            // Act
            WebPageRazorHost host = new WebRazorHostFactory().CreateHost("~/Foo/Bar/Baz/Bar", @"C:\Foo.cshtml");

            // Assert
            Assert.Equal(@"C:\Foo.cshtml", host.PhysicalPath);
        }

        [Fact]
        public void CreateHostFromConfigRequiresNonNullVirtualPath()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => WebRazorHostFactory.CreateHostFromConfig(virtualPath: null,
                                                                                                physicalPath: "foo"), "virtualPath");
            Assert.ThrowsArgumentNullOrEmptyString(() => WebRazorHostFactory.CreateHostFromConfig(config: new RazorWebSectionGroup(),
                                                                                                virtualPath: null,
                                                                                                physicalPath: "foo"), "virtualPath");
        }

        [Fact]
        public void CreateHostFromConfigRequiresNonEmptyVirtualPath()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => WebRazorHostFactory.CreateHostFromConfig(virtualPath: String.Empty,
                                                                                                physicalPath: "foo"), "virtualPath");
            Assert.ThrowsArgumentNullOrEmptyString(() => WebRazorHostFactory.CreateHostFromConfig(config: new RazorWebSectionGroup(),
                                                                                                virtualPath: String.Empty,
                                                                                                physicalPath: "foo"), "virtualPath");
        }

        [Fact]
        public void CreateHostFromConfigRequiresNonNullSectionGroup()
        {
            Assert.ThrowsArgumentNull(() => WebRazorHostFactory.CreateHostFromConfig(config: (RazorWebSectionGroup)null,
                                                                                         virtualPath: String.Empty,
                                                                                         physicalPath: "foo"), "config");
        }

        [Fact]
        public void CreateHostFromConfigReturnsWebCodeHostIfVirtualPathStartsWithAppCode()
        {
            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfigCore(null, "~/App_Code/Bar.cshtml", null);

            // Assert
            Assert.IsType<WebCodeRazorHost>(host);
        }

        [Fact]
        public void CreateHostFromConfigUsesDefaultFactoryIfNoRazorWebSectionGroupFound()
        {
            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfigCore(null, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.IsType<WebPageRazorHost>(host);
        }

        [Fact]
        public void CreateHostFromConfigUsesDefaultFactoryIfNoHostSectionFound()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = null,
                Pages = null
            };

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.IsType<WebPageRazorHost>(host);
        }

        [Fact]
        public void CreateHostFromConfigUsesDefaultFactoryIfNullFactoryType()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = new HostSection()
                {
                    FactoryType = null
                },
                Pages = null
            };

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.IsType<WebPageRazorHost>(host);
        }

        [Fact]
        public void CreateHostFromConfigUsesFactorySpecifiedInConfig()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = new HostSection()
                {
                    FactoryType = typeof(TestFactory).FullName
                },
                Pages = null
            };
            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.IsType<TestHost>(host);
        }

        [Fact]
        public void CreateHostFromConfigThrowsInvalidOperationExceptionIfFactoryTypeNotFound()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = new HostSection()
                {
                    FactoryType = "Foo"
                },
                Pages = null
            };
            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            Assert.Throws<InvalidOperationException>(
                () => WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null),
                String.Format(RazorWebResources.Could_Not_Locate_FactoryType, "Foo"));
        }

        [Fact]
        public void CreateHostFromConfigAppliesBaseTypeFromConfigToHost()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = null,
                Pages = new RazorPagesSection()
                {
                    PageBaseType = "System.Foo.Bar"
                }
            };
            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.Equal("System.Foo.Bar", host.DefaultBaseClass);
        }

        [Fact]
        public void CreateHostFromConfigIgnoresBaseTypeFromConfigIfPageIsPageStart()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = null,
                Pages = new RazorPagesSection()
                {
                    PageBaseType = "System.Foo.Bar"
                }
            };
            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/_pagestart.cshtml", null);

            // Assert
            Assert.Equal(typeof(StartPage).FullName, host.DefaultBaseClass);
        }

        [Fact]
        public void CreateHostFromConfigIgnoresBaseTypeFromConfigIfPageIsAppStart()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = null,
                Pages = new RazorPagesSection()
                {
                    PageBaseType = "System.Foo.Bar"
                }
            };
            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/_appstart.cshtml", null);

            // Assert
            Assert.Equal(typeof(ApplicationStartPage).FullName, host.DefaultBaseClass);
        }

        [Fact]
        public void CreateHostFromConfigMergesNamespacesFromConfigToHost()
        {
            // Arrange
            RazorWebSectionGroup config = new RazorWebSectionGroup()
            {
                Host = null,
                Pages = new RazorPagesSection()
                {
                    Namespaces = new NamespaceCollection()
                    {
                        new NamespaceInfo("System"),
                        new NamespaceInfo("Foo")
                    }
                }
            };
            WebRazorHostFactory.TypeFactory = name => Assembly.GetExecutingAssembly().GetType(name, throwOnError: false);

            // Act
            WebPageRazorHost host = WebRazorHostFactory.CreateHostFromConfig(config, "/Foo/Bar.cshtml", null);

            // Assert
            Assert.True(host.NamespaceImports.Contains("System"));
            Assert.True(host.NamespaceImports.Contains("Foo"));
        }

        [Fact]
        public void HostFactoryTypeIsCorrectlyLoadedFromConfig()
        {
            // Act
            RazorWebSectionGroup group = GetRazorGroup();
            HostSection host = (HostSection)group.Host;

            // Assert
            Assert.NotNull(host);
            Assert.Equal("System.Web.WebPages.Razor.Test.TestRazorHostFactory, System.Web.WebPages.Razor.Test", host.FactoryType);
        }

        [Fact]
        public void PageBaseTypeIsCorrectlyLoadedFromConfig()
        {
            // Act
            RazorWebSectionGroup group = GetRazorGroup();
            RazorPagesSection pages = (RazorPagesSection)group.Pages;

            // Assert
            Assert.NotNull(pages);
            Assert.Equal("System.Web.WebPages.Razor.Test.TestPageBase, System.Web.WebPages.Razor.Test", pages.PageBaseType);
        }

        [Fact]
        public void NamespacesAreCorrectlyLoadedFromConfig()
        {
            // Act
            RazorWebSectionGroup group = GetRazorGroup();
            RazorPagesSection pages = (RazorPagesSection)group.Pages;

            // Assert
            Assert.NotNull(pages);
            NamespaceInfo namespaceInfo = Assert.IsType<NamespaceInfo>(Assert.Single(pages.Namespaces));
            Assert.Equal("System.Text.RegularExpressions", namespaceInfo.Namespace);
        }

        [Fact]
        public void RegisterSpecialFile_ThrowsOnNullFileName()
        {
            TestHost host = new TestHost();
            Assert.ThrowsArgumentNullOrEmptyString(() => host.RegisterSpecialFile(null, typeof(string)), "fileName");
            Assert.ThrowsArgumentNullOrEmptyString(() => host.RegisterSpecialFile(null, "string"), "fileName");
        }

        [Fact]
        public void RegisterSpecialFile_ThrowsOnEmptyFileName()
        {
            TestHost host = new TestHost();
            Assert.ThrowsArgumentNullOrEmptyString(() => host.RegisterSpecialFile(String.Empty, typeof(string)), "fileName");
            Assert.ThrowsArgumentNullOrEmptyString(() => host.RegisterSpecialFile(String.Empty, "string"), "fileName");
        }

        [Fact]
        public void RegisterSpecialFile_ThrowsOnNullBaseType()
        {
            TestHost host = new TestHost();
            Assert.ThrowsArgumentNull(() => host.RegisterSpecialFile("file", (Type)null), "baseType");
        }

        [Fact]
        public void RegisterSpecialFile_ThrowsOnNullBaseTypeName()
        {
            TestHost host = new TestHost();
            Assert.ThrowsArgumentNullOrEmptyString(() => host.RegisterSpecialFile("file", (string)null), "baseTypeName");
        }

        [Fact]
        public void RegisterSpecialFile_ThrowsOnEmptyBaseTypeName()
        {
            TestHost host = new TestHost();
            Assert.ThrowsArgumentNullOrEmptyString(() => host.RegisterSpecialFile("file", String.Empty), "baseTypeName");
        }

        private static RazorWebSectionGroup GetRazorGroup()
        {
            return (RazorWebSectionGroup)ConfigurationManager.OpenExeConfiguration(null).GetSectionGroup(RazorWebSectionGroup.GroupName);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Razor.Test/app.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<configuration>
    <configSections>
        <sectionGroup name="system.web.webPages.razor" type="System.Web.WebPages.Razor.Configuration.RazorWebSectionGroup, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35">
            <section name="host" type="System.Web.WebPages.Razor.Configuration.HostSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
            <section name="pages" type="System.Web.WebPages.Razor.Configuration.RazorPagesSection, System.Web.WebPages.Razor, Version=3.0.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" requirePermission="false" />
        </sectionGroup>
    </configSections>
    <system.web.webPages.razor>
        <host factoryType="System.Web.WebPages.Razor.Test.TestRazorHostFactory, System.Web.WebPages.Razor.Test" />
        <pages pageBaseType="System.Web.WebPages.Razor.Test.TestPageBase, System.Web.WebPages.Razor.Test">
            <namespaces>
                <add namespace="System.IO.Packaging" />
                <clear />
                <add namespace="System.Security" />
                <add namespace="System.Text.RegularExpressions" />
                <remove namespace="System.Security" />
            </namespaces>
        </pages>
    </system.web.webPages.razor>
</configuration>

================================================
FILE: test/System.Web.WebPages.Razor.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/System.Web.WebPages.Test/App.config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.data>
    <DbProviderFactories>
      <remove invariant="System.Data.SqlServerCe.4.0"></remove>
      <add name="Microsoft SQL Server Compact Data Provider" invariant="System.Data.SqlServerCe.4.0" description=".NET Framework Data Provider for Microsoft SQL Server Compact" type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91"/>
    </DbProviderFactories>
  </system.data>
  <runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
      <dependentAssembly>
        <!-- Need this because the BinarySerializer uses the TypeForwardedFrom attribute and deserializes to the original assembly (MVC 2.0) for the HttpAntiForgeryException test -->
        <assemblyIdentity name="System.Web.Mvc" publicKeyToken="31bf3856ad364e35" />
        <bindingRedirect oldVersion="1.0.0.0-5.3.0.0" newVersion="5.3.0.0" />
      </dependentAssembly>
    </assemblyBinding>
  </runtime>
</configuration>

================================================
FILE: test/System.Web.WebPages.Test/ApplicationParts/ApplicationPartRegistryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.WebPages.ApplicationParts;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test.ApplicationModule
{
    public class ApplicationPartRegistryTest
    {
        [Fact]
        public void ApplicationModuleGeneratesRootRelativePaths()
        {
            // Arrange
            var path1 = "foo/bar";
            var path2 = "~/xyz/pqr";
            var root1 = "~/myappmodule";
            var root2 = "~/myappmodule2/";

            // Act
            var actualPath11 = ApplicationPartRegistry.GetRootRelativeVirtualPath(root1, path1);
            var actualPath12 = ApplicationPartRegistry.GetRootRelativeVirtualPath(root1, path2);
            var actualPath21 = ApplicationPartRegistry.GetRootRelativeVirtualPath(root2, path1);
            var actualPath22 = ApplicationPartRegistry.GetRootRelativeVirtualPath(root2, path2);

            // Assert
            Assert.Equal(actualPath11, root1 + "/" + path1);
            Assert.Equal(actualPath12, root1 + path2.TrimStart('~'));
            Assert.Equal(actualPath21, root2 + path1);
            Assert.Equal(actualPath22, root2 + path2.TrimStart('~', '/'));
        }

        [Fact]
        public void ApplicationPartRegistryLooksUpPartsByName()
        {
            // Arrange
            var part = new ApplicationPart(BuildAssembly(), "~/mymodule");
            var dictionary = new DictionaryBasedVirtualPathFactory();
            var registry = new ApplicationPartRegistry(dictionary);
            Func<object> myFunc = () => "foo";

            // Act
            registry.Register(part, myFunc);

            // Assert
            Assert.Equal(registry["my-assembly"], part);
            Assert.Equal(registry["MY-aSSembly"], part);
        }

        [Fact]
        public void ApplicationPartRegistryLooksUpPartsByAssembly()
        {
            // Arrange
            var assembly = BuildAssembly();
            var part = new ApplicationPart(assembly, "~/mymodule");
            var dictionary = new DictionaryBasedVirtualPathFactory();
            var registry = new ApplicationPartRegistry(dictionary);
            Func<object> myFunc = () => "foo";

            // Act
            registry.Register(part, myFunc);

            // Assert
            Assert.Equal(registry[assembly], part);
        }

        [Fact]
        public void RegisterThrowsIfAssemblyAlreadyRegistered()
        {
            // Arrange
            var part = new ApplicationPart(BuildAssembly(), "~/mymodule");
            var dictionary = new DictionaryBasedVirtualPathFactory();
            var registry = new ApplicationPartRegistry(dictionary);
            Func<object> myFunc = () => "foo";

            // Act
            registry.Register(part, myFunc);

            // Assert
            Assert.Throws<InvalidOperationException>(() => registry.Register(part, myFunc),
                                                              String.Format("The assembly \"{0}\" is already registered.", part.Assembly.ToString()));
        }

        [Fact]
        public void RegisterThrowsIfPathAlreadyRegistered()
        {
            // Arrange
            var part = new ApplicationPart(BuildAssembly(), "~/mymodule");
            var dictionary = new DictionaryBasedVirtualPathFactory();
            var registry = new ApplicationPartRegistry(dictionary);
            Func<object> myFunc = () => "foo";

            // Act
            registry.Register(part, myFunc);

            // Assert
            var newPart = new ApplicationPart(BuildAssembly("different-assembly"), "~/mymodule");
            Assert.Throws<InvalidOperationException>(() => registry.Register(newPart, myFunc),
                                                              "An application module is already registered for virtual path \"~/mymodule/\".");
        }

        [Fact]
        public void RegisterCreatesRoutesForValidPages()
        {
            // Arrange
            var part = new ApplicationPart(BuildAssembly(), "~/mymodule");
            var dictionary = new DictionaryBasedVirtualPathFactory();
            var registry = new ApplicationPartRegistry(dictionary);
            Func<object> myFunc = () => "foo";

            // Act
            registry.Register(part, myFunc);

            // Assert
            Assert.True(dictionary.Exists("~/mymodule/Page1"));
            Assert.Equal("foo", dictionary.CreateInstance("~/mymodule/Page1"));
            Assert.False(dictionary.Exists("~/mymodule/Page2"));
            Assert.False(dictionary.Exists("~/mymodule/Page3"));
        }

        private static IResourceAssembly BuildAssembly(string name = "my-assembly")
        {
            Mock<TestResourceAssembly> assembly = new Mock<TestResourceAssembly>();
            assembly.SetupGet(c => c.Name).Returns(name);
            assembly.Setup(c => c.GetHashCode()).Returns(name.GetHashCode());
            assembly.Setup(c => c.Equals(It.IsAny<TestResourceAssembly>())).Returns((TestResourceAssembly c) => c.Name == name);

            assembly.Setup(c => c.GetTypes()).Returns(new[]
            {
                BuildPageType(inherits: true, virtualPath: "~/Page1"),
                BuildPageType(inherits: true, virtualPath: null),
                BuildPageType(inherits: false, virtualPath: "~/Page3"),
            });

            return assembly.Object;
        }

        private static Type BuildPageType(bool inherits, string virtualPath)
        {
            Mock<Type> type = new Mock<Type>();
            type.Setup(c => c.IsSubclassOf(typeof(WebPageRenderingBase))).Returns(inherits);

            if (virtualPath != null)
            {
                type.Setup(c => c.GetCustomAttributes(typeof(PageVirtualPathAttribute), false))
                    .Returns(new[] { new PageVirtualPathAttribute(virtualPath) });
            }
            return type.Object;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ApplicationParts/ApplicationPartTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class ApplicationPartTest
    {
        [Fact]
        public void ApplicationPartThrowsIfRootVirtualPathIsNullOrEmpty()
        {
            // Arrange
            var assembly = new Mock<TestResourceAssembly>().Object;

            Assert.ThrowsArgumentNullOrEmptyString(() => new ApplicationPart(assembly, rootVirtualPath: null), "rootVirtualPath");
            Assert.ThrowsArgumentNullOrEmptyString(() => new ApplicationPart(assembly, rootVirtualPath: String.Empty), "rootVirtualPath");
        }

        [Fact]
        public void ResolveVirtualPathResolvesRegularPathsUsingBaseVirtualPath()
        {
            // Arrange
            var basePath = "~/base/";
            var path = "somefile";
            var appPartRoot = "~/app/";

            // Act
            var virtualPath = ApplicationPart.ResolveVirtualPath(appPartRoot, basePath, path);

            // Assert
            Assert.Equal("~/base/somefile", virtualPath);
        }

        [Fact]
        public void ResolveVirtualPathResolvesAppRelativePathsUsingAppVirtualPath()
        {
            // Arrange
            var basePath = "~/base";
            var path = "@/somefile";
            var appPartRoot = "~/app/";

            // Act
            var virtualPath = ApplicationPart.ResolveVirtualPath(appPartRoot, basePath, path);

            // Assert
            Assert.Equal("~/app/somefile", virtualPath);
        }

        [Fact]
        public void ResolveVirtualPathDoesNotAffectRootRelativePaths()
        {
            // Arrange
            var basePath = "~/base";
            var path = "~/somefile";
            var appPartRoot = "~/app/";

            // Act
            var virtualPath = ApplicationPart.ResolveVirtualPath(appPartRoot, basePath, path);

            // Assert
            Assert.Equal("~/somefile", virtualPath);
        }

        [Fact]
        public void GetResourceNameFromVirtualPathForTopLevelPath()
        {
            // Arrange
            var moduleName = "my-module";
            var path = "foo.baz";

            // Act
            var name = ApplicationPart.GetResourceNameFromVirtualPath(moduleName, path);

            // Assert
            Assert.Equal(name, moduleName + "." + path);
        }

        [Fact]
        public void GetResourceNameFromVirtualPathForItemInSubDir()
        {
            // Arrange
            var moduleName = "my-module";
            var path = "/bar/foo";

            // Act
            var name = ApplicationPart.GetResourceNameFromVirtualPath(moduleName, path);

            // Assert
            Assert.Equal("my-module.bar.foo", name);
        }

        [Fact]
        public void GetResourceNameFromVirtualPathForItemWithSpaces()
        {
            // Arrange
            var moduleName = "my-module";
            var path = "/program files/data files/my file .foo";

            // Act
            var name = ApplicationPart.GetResourceNameFromVirtualPath(moduleName, path);

            // Assert
            Assert.Equal("my-module.program_files.data_files.my file .foo", name);
        }

        [Fact]
        public void GetResourceVirtualPathForTopLevelItem()
        {
            // Arrange
            var moduleName = "my-module";
            var moduleRoot = "~/root-path";
            var path = moduleRoot + "/foo.txt";

            // Act
            var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path);

            // Assert
            Assert.Equal("~/r.ashx/" + moduleName + "/" + "foo.txt", virtualPath);
        }

        [Fact]
        public void GetResourceVirtualPathForTopLevelItemAndModuleRootWithTrailingSlash()
        {
            // Arrange
            var moduleName = "my-module";
            var moduleRoot = "~/root-path/";
            var path = moduleRoot + "/foo.txt";

            // Act
            var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path);

            // Assert
            Assert.Equal("~/r.ashx/" + moduleName + "/" + "foo.txt", virtualPath);
        }

        [Fact]
        public void GetResourceVirtualPathForTopLevelItemAndNestedModuleRootPath()
        {
            // Arrange
            var moduleName = "my-module";
            var moduleRoot = "~/root-path/sub-path";
            var path = moduleRoot + "/foo.txt";

            // Act
            var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path);

            // Assert
            Assert.Equal("~/r.ashx/" + moduleName + "/" + "foo.txt", virtualPath);
        }

        [Fact]
        public void GetResourceVirtualPathEncodesModuleName()
        {
            // Arrange
            var moduleName = "Debugger Package v?&%";
            var moduleRoot = "~/root-path/sub-path";
            var path = moduleRoot + "/foo.txt";

            // Act
            var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path);

            // Assert
            Assert.Equal("~/r.ashx/" + "Debugger%20Package%20v?&%" + "/" + "foo.txt", virtualPath);
        }

        [Fact]
        public void GetResourceVirtualPathForNestedItemPath()
        {
            // Arrange
            var moduleName = "DebuggerPackage";
            var moduleRoot = "~/root-path/sub-path";
            var itemPath = "some-path/some-more-please/foo.txt";
            var path = moduleRoot + "/" + itemPath;

            // Act
            var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path);

            // Assert
            Assert.Equal("~/r.ashx/" + moduleName + "/" + itemPath, virtualPath);
        }

        [Fact]
        public void GetResourceVirtualPathForItemPathWithParameters()
        {
            // Arrange
            var moduleName = "DebuggerPackage";
            var moduleRoot = "~/root-path/sub-path";
            var itemPath = "some-path/some-more-please/foo.jpg?size=45&height=20";
            var path = moduleRoot + "/" + itemPath;

            // Act
            var virtualPath = ApplicationPart.GetResourceVirtualPath(moduleName, moduleRoot, path);

            // Assert
            Assert.Equal("~/r.ashx/" + moduleName + "/" + itemPath, virtualPath);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ApplicationParts/MimeMappingTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.Internal.Web.Utils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class MimeMappingTest
    {
        [Fact]
        public void MimeMappingThrowsForNullFileName()
        {
            // Arrange
            string fileName = null;

            // Act and Assert
            Assert.ThrowsArgumentNull(() => MimeMapping.GetMimeMapping(fileName), "fileName");
        }

        [Fact]
        public void MimeMappingReturnsGenericTypeForUnknownExtensions()
        {
            // Arrange
            string fileName = "file.does-not-exist";

            // Act
            string mimeType = MimeMapping.GetMimeMapping(fileName);

            // Assert
            Assert.Equal("application/octet-stream", mimeType);
        }

        [Fact]
        public void MimeMappingReturnsGenericTypeForNoExtensions()
        {
            // Arrange
            string fileName = "file";

            // Act
            string mimeType = MimeMapping.GetMimeMapping(fileName);

            // Assert
            Assert.Equal("application/octet-stream", mimeType);
        }

        [Fact]
        public void MimeMappingPerformsCaseInsensitiveSearches()
        {
            // Arrange
            string fileName1 = "file.doc";
            string fileName2 = "file.dOC";

            // Act
            string mimeType1 = MimeMapping.GetMimeMapping(fileName1);
            string mimeType2 = MimeMapping.GetMimeMapping(fileName2);

            // Assert
            Assert.Equal("application/msword", mimeType1);
            Assert.Equal("application/msword", mimeType2);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ApplicationParts/ResourceHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Text;
using System.Web.WebPages.ApplicationParts;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class ResourceHandlerTest
    {
        private const string _fileContent = "contents of jpeg file";

        [Fact]
        public void ResourceHandlerWritesContentsOfFileToStream()
        {
            // Arrange
            var applicationPart = new ApplicationPart(BuildAssembly(), "~/my-app-assembly");
            MemoryStream stream = new MemoryStream();
            var response = new Mock<HttpResponseBase>();
            response.SetupGet(c => c.OutputStream).Returns(stream);
            response.SetupSet(c => c.ContentType = "image/jpeg").Verifiable();
            var resourceHandler = new ResourceHandler(applicationPart, "bar.foo.jpg");

            // Act
            resourceHandler.ProcessRequest(response.Object);

            // Assert
            response.Verify();
            Assert.Equal(_fileContent, Encoding.Default.GetString(stream.ToArray()));
        }

        [Fact]
        public void ResourceHandlerThrows404IfResourceNotFound()
        {
            // Arrange
            var applicationPart = new ApplicationPart(BuildAssembly(), "~/my-app-assembly");
            MemoryStream stream = new MemoryStream();
            var response = new Mock<HttpResponseBase>();
            response.SetupGet(c => c.OutputStream).Returns(stream);
            response.SetupSet(c => c.ContentType = "image/jpeg").Verifiable();
            var resourceHandler = new ResourceHandler(applicationPart, "does-not-exist");

            // Act and Assert
            Assert.Throws<HttpException>(() => resourceHandler.ProcessRequest(response.Object),
                                                  "The resource file \"does-not-exist\" could not be found.");
        }

        private static IResourceAssembly BuildAssembly(string name = "my-assembly")
        {
            Mock<TestResourceAssembly> assembly = new Mock<TestResourceAssembly>();
            assembly.SetupGet(c => c.Name).Returns("my-assembly");

            byte[] content = Encoding.Default.GetBytes(_fileContent);
            assembly.Setup(c => c.GetManifestResourceStream("my-assembly.bar.foo.jpg")).Returns(new MemoryStream(content));

            assembly.Setup(c => c.GetManifestResourceNames()).Returns(new[] { "my-assembly.bar.foo.jpg" });

            return assembly.Object;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ApplicationParts/TestResourceAssembly.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Web.WebPages.ApplicationParts;

namespace System.Web.WebPages.Test
{
    public abstract class TestResourceAssembly : IResourceAssembly
    {
        public abstract string Name { get; }

        public abstract Stream GetManifestResourceStream(string name);

        public abstract IEnumerable<string> GetManifestResourceNames();

        public abstract IEnumerable<Type> GetTypes();
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Extensions/HttpContextExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.WebPages.Test.Helpers
{
    public class HttpContextExtensionsTest
    {
        class RedirectData
        {
            public string RequestUrl { get; set; }
            public string RedirectUrl { get; set; }
        }

        private static HttpContextBase GetContextForRedirectLocal(RedirectData data)
        {
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(context => context.Request.Url).Returns(new Uri(data.RequestUrl));
            contextMock.Setup(context => context.Response.Redirect(It.IsAny<string>())).Callback((string url) => data.RedirectUrl = url);
            return contextMock.Object;
        }

        [Fact]
        public void RedirectLocalWithNullGoesToRootTest()
        {
            RedirectData data = new RedirectData() { RequestUrl = "http://foo" };
            var context = GetContextForRedirectLocal(data);
            context.RedirectLocal("");
            Assert.Equal("~/", data.RedirectUrl);
        }

        [Fact]
        public void RedirectLocalWithEmptyStringGoesToRootTest()
        {
            RedirectData data = new RedirectData() { RequestUrl = "http://foo" };
            var context = GetContextForRedirectLocal(data);
            context.RedirectLocal("");
            Assert.Equal("~/", data.RedirectUrl);
        }

        [Fact]
        public void RedirectLocalWithNonLocalGoesToRootTest()
        {
            RedirectData data = new RedirectData() { RequestUrl = "http://foo" };
            var context = GetContextForRedirectLocal(data);
            context.RedirectLocal("");
            Assert.Equal("~/", data.RedirectUrl);
        }

        [Fact]
        public void RedirectLocalWithDifferentHostGoesToRootTest()
        {
            RedirectData data = new RedirectData() { RequestUrl = "http://foo" };
            var context = GetContextForRedirectLocal(data);
            context.RedirectLocal("http://bar");
            Assert.Equal("~/", data.RedirectUrl);
        }

        [Fact]
        public void RedirectLocalOnSameHostTest()
        {
            RedirectData data = new RedirectData() { RequestUrl = "http://foo" };
            var context = GetContextForRedirectLocal(data);
            context.RedirectLocal("http://foo/bar/baz");
            Assert.Equal("~/", data.RedirectUrl);
            context.RedirectLocal("http://foo/bar/baz/woot.htm");
            Assert.Equal("~/", data.RedirectUrl);
        }

        [Fact]
        public void RedirectLocalRelativeTest()
        {
            RedirectData data = new RedirectData() { RequestUrl = "http://foo" };
            var context = GetContextForRedirectLocal(data);
            context.RedirectLocal("/bar");
            Assert.Equal("/bar", data.RedirectUrl);
            context.RedirectLocal("/bar/hey.you");
            Assert.Equal("/bar/hey.you", data.RedirectUrl);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Extensions/HttpRequestExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Web;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.WebPages.Test.Helpers
{
    public class HttpRequestExtensionsTest
    {
        private static HttpRequestBase GetRequestForIsUrlLocalToHost(string url)
        {
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(context => context.Request.Url).Returns(new Uri(url));
            return contextMock.Object.Request;
        }

        [Fact]
        public void IsUrlLocalToHost_ReturnsFalseOnEmpty()
        {
            var request = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(request.IsUrlLocalToHost(null));
            Assert.False(request.IsUrlLocalToHost(String.Empty));
        }

        [Fact]
        public void IsUrlLocalToHost_AcceptsRootedUrls()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.True(helper.IsUrlLocalToHost("/foo.html"));
            Assert.True(helper.IsUrlLocalToHost("/www.hackerz.com"));
            Assert.True(helper.IsUrlLocalToHost("/"));
        }

        [Fact]
        public void IsUrlLocalToHost_AcceptsApplicationRelativeUrls()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.True(helper.IsUrlLocalToHost("~/"));
            Assert.True(helper.IsUrlLocalToHost("~/foobar.html"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsRelativeUrls()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("../foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("fold/foobar.html"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectValidButUnsafeRelativeUrls()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("http:/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("hTtP:foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("http:/www.hackerz.com"));
            Assert.False(helper.IsUrlLocalToHost("HtTpS:/www.hackerz.com"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsUrlsOnTheSameHost()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("http://www.mysite.com/appDir/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("http://WWW.MYSITE.COM"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsUrlsOnLocalHost()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("http://localhost/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("http://127.0.0.1/foobar.html"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsUrlsOnTheSameHostButDifferentScheme()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("https://www.mysite.com/"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsUrlsOnDifferentHost()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("http://www.hackerz.com"));
            Assert.False(helper.IsUrlLocalToHost("https://www.hackerz.com"));
            Assert.False(helper.IsUrlLocalToHost("hTtP://www.hackerz.com"));
            Assert.False(helper.IsUrlLocalToHost("HtTpS://www.hackerz.com"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsUrlsWithTooManySchemeSeparatorCharacters()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("http://///www.hackerz.com/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("https://///www.hackerz.com/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("HtTpS://///www.hackerz.com/foobar.html"));

            Assert.False(helper.IsUrlLocalToHost("http:///www.hackerz.com/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("http:////www.hackerz.com/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("http://///www.hackerz.com/foobar.html"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsUrlsWithMissingSchemeName()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost("//www.hackerz.com"));
            Assert.False(helper.IsUrlLocalToHost("//www.hackerz.com?"));
            Assert.False(helper.IsUrlLocalToHost("//www.hackerz.com:80"));
            Assert.False(helper.IsUrlLocalToHost("//www.hackerz.com/foobar.html"));
            Assert.False(helper.IsUrlLocalToHost("///www.hackerz.com"));
            Assert.False(helper.IsUrlLocalToHost("//////www.hackerz.com"));
        }

        [Fact]
        public void IsUrlLocalToHost_RejectsInvalidUrls()
        {
            var helper = GetRequestForIsUrlLocalToHost("http://www.mysite.com/");
            Assert.False(helper.IsUrlLocalToHost(@"http:\\www.hackerz.com"));
            Assert.False(helper.IsUrlLocalToHost(@"http:\\www.hackerz.com\"));
            Assert.False(helper.IsUrlLocalToHost(@"/\"));
            Assert.False(helper.IsUrlLocalToHost(@"/\foo"));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Extensions/HttpResponseExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.IO;
using System.Net;
using System.Text;
using System.Web;
using System.Web.WebPages;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.WebPages.Test.Helpers
{
    public class HttpResponseExtensionsTest
    {
        HttpResponseBase _response;
        string _redirectUrl;
        StringBuilder _output;
        Stream _outputStream;

        public HttpResponseExtensionsTest()
        {
            _output = new StringBuilder();
            _outputStream = new MemoryStream();
            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.SetupProperty(response => response.StatusCode);
            mockResponse.SetupProperty(response => response.ContentType);
            mockResponse.Setup(response => response.Redirect(It.IsAny<string>())).Callback((string url) => _redirectUrl = url);
            mockResponse.Setup(response => response.Write(It.IsAny<string>())).Callback((string str) => _output.Append(str));
            mockResponse.Setup(response => response.OutputStream).Returns(_outputStream);
            mockResponse.Setup(response => response.OutputStream).Returns(_outputStream);
            mockResponse.Setup(response => response.Output).Returns(new StringWriter(_output));
            _response = mockResponse.Object;
        }

        [Fact]
        public void SetStatusWithIntTest()
        {
            int status = 200;
            _response.SetStatus(status);
            Assert.Equal(status, _response.StatusCode);
        }

        [Fact]
        public void SetStatusWithHttpStatusCodeTest()
        {
            HttpStatusCode status = HttpStatusCode.Forbidden;
            _response.SetStatus(status);
            Assert.Equal((int)status, _response.StatusCode);
        }

        [Fact]
        public void WriteBinaryTest()
        {
            string foo = "I am a string, please don't mangle me!";
            _response.WriteBinary(ASCIIEncoding.ASCII.GetBytes(foo));
            _outputStream.Flush();
            _outputStream.Position = 0;
            StreamReader reader = new StreamReader(_outputStream);
            Assert.Equal(foo, reader.ReadToEnd());
        }

        [Fact]
        public void WriteBinaryWithMimeTypeTest()
        {
            string foo = "I am a string, please don't mangle me!";
            string mimeType = "mime/foo";
            _response.WriteBinary(ASCIIEncoding.ASCII.GetBytes(foo), mimeType);
            _outputStream.Flush();
            _outputStream.Position = 0;
            StreamReader reader = new StreamReader(_outputStream);
            Assert.Equal(foo, reader.ReadToEnd());
            Assert.Equal(mimeType, _response.ContentType);
        }

        [Fact]
        public void OutputCacheSetsExpirationTimeBasedOnCurrentContext()
        {
            // Arrange
            var timestamp = new DateTime(2011, 1, 1, 0, 0, 0);
            var context = new Mock<HttpContextBase>();
            context.SetupGet(c => c.Timestamp).Returns(timestamp);
            var response = new Mock<HttpResponseBase>().Object;

            var cache = new Mock<HttpCachePolicyBase>();
            cache.Setup(c => c.SetCacheability(It.Is<HttpCacheability>(p => p == HttpCacheability.Public))).Verifiable();
            cache.Setup(c => c.SetExpires(It.Is<DateTime>(p => p == timestamp.AddSeconds(20)))).Verifiable();
            cache.Setup(c => c.SetMaxAge(It.Is<TimeSpan>(p => p == TimeSpan.FromSeconds(20)))).Verifiable();
            cache.Setup(c => c.SetValidUntilExpires(It.Is<bool>(p => p == true))).Verifiable();
            cache.Setup(c => c.SetLastModified(It.Is<DateTime>(p => p == timestamp))).Verifiable();
            cache.Setup(c => c.SetSlidingExpiration(It.Is<bool>(p => p == false))).Verifiable();

            // Act
            ResponseExtensions.OutputCache(context.Object, cache.Object, 20, false, null, null, null, HttpCacheability.Public);

            // Assert
            cache.VerifyAll();
        }

        [Fact]
        public void OutputCacheSetsVaryByValues()
        {
            // Arrange
            var timestamp = new DateTime(2011, 1, 1, 0, 0, 0);
            var context = new Mock<HttpContextBase>();
            context.SetupGet(c => c.Timestamp).Returns(timestamp);
            var response = new Mock<HttpResponseBase>().Object;

            var varyByParams = new HttpCacheVaryByParams();
            var varyByHeader = new HttpCacheVaryByHeaders();
            var varyByContentEncoding = new HttpCacheVaryByContentEncodings();

            var cache = new Mock<HttpCachePolicyBase>();
            cache.SetupGet(c => c.VaryByParams).Returns(varyByParams);
            cache.SetupGet(c => c.VaryByHeaders).Returns(varyByHeader);
            cache.SetupGet(c => c.VaryByContentEncodings).Returns(varyByContentEncoding);

            // Act
            ResponseExtensions.OutputCache(context.Object, cache.Object, 20, false, new[] { "foo" }, new[] { "bar", "bar2" },
                                           new[] { "baz", "baz2" }, HttpCacheability.Public);

            // Assert
            Assert.True(varyByParams["foo"]);
            Assert.True(varyByHeader["bar"]);
            Assert.True(varyByHeader["bar2"]);
            Assert.True(varyByContentEncoding["baz"]);
            Assert.True(varyByContentEncoding["baz2"]);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Extensions/StringExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.TestUtil;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class StringExtensionsTest
    {
        [Fact]
        public void IsIntTests()
        {
            Assert.False("1.3".IsInt());
            Assert.False(".13".IsInt());
            Assert.False("0.0".IsInt());
            Assert.False("12345678900123456".IsInt());
            Assert.False("gooblygook".IsInt());
            Assert.True("0".IsInt());
            Assert.True("123456".IsInt());
            Assert.True(Int32.MaxValue.ToString().IsInt());
            Assert.True(Int32.MinValue.ToString().IsInt());
            Assert.False(((string)null).IsInt());
        }

        [Fact]
        public void AsIntBasicTests()
        {
            Assert.Equal(-123, "-123".AsInt());
            Assert.Equal(12345, "12345".AsInt());
            Assert.Equal(0, "0".AsInt());
        }

        [Fact]
        public void AsIntDefaultTests()
        {
            // Illegal values default to 0
            Assert.Equal(0, "-100000000000000000000000".AsInt());

            // Illegal values default to 0
            Assert.Equal(0, "adlfkj".AsInt());

            Assert.Equal(-1, "adlfkj".AsInt(-1));
            Assert.Equal(-1, "-100000000000000000000000".AsInt(-1));
        }

        [Fact]
        public void IsDecimalTests()
        {
            Assert.True(1.3m.ToString("0.0").IsDecimal());
            Assert.True(0.13m.ToString(".00").IsDecimal());
            Assert.True(0m.ToString("0.0").IsDecimal());
            Assert.True("12345678900123456".IsDecimal());
            Assert.True("0".IsDecimal());
            Assert.True("123456".IsDecimal());
            Assert.True(decimal.MaxValue.ToString().IsDecimal());
            Assert.True(decimal.MinValue.ToString().IsDecimal());
            Assert.False("gooblygook".IsDecimal());
            Assert.False("..0".IsDecimal());
            Assert.False(((string)null).IsDecimal());
        }

        [Fact]
        public void AsDecimalBasicTests()
        {
            Assert.Equal(-123m, -123m.ToString().AsDecimal());
            Assert.Equal(9.99m, 9.99m.ToString().AsDecimal());
            Assert.Equal(0m, "0".AsDecimal());
            Assert.Equal(-1.1111m, -1.1111m.ToString().AsDecimal());
        }

        [Fact]
        public void AsDecimalDefaultTests()
        {
            // Illegal values default to 0
            Assert.Equal(0m, "abc".AsDecimal());

            Assert.Equal(-1.11m, "adlfkj".AsDecimal(-1.11m));
        }

        [Fact]
        public void AsDecimalUsesCurrentCulture()
        {
            decimal value = 12345.00M;
            using (new CultureReplacer("ar-DZ"))
            {
                Assert.Equal("12345.00", value.ToString(CultureInfo.CurrentCulture));
                Assert.Equal("12345.00", value.ToString());
            }

            using (new CultureReplacer("bg-BG"))
            {
                Assert.Equal("12345,00", value.ToString(CultureInfo.CurrentCulture));
                Assert.Equal("12345,00", value.ToString());
            }
        }

        [Fact]
        public void IsAndAsDecimalsUsesCurrentCulture()
        {
            // Pretty identical to the earlier test case. This was a post on the forums, making sure it works.
            using (new CultureReplacer(culture: "lt-LT"))
            {
                Assert.False("1.2".IsDecimal());
                Assert.True("1,2".IsDecimal());

                Assert.Equal(1.2M, "1,2".AsDecimal());
                Assert.Equal(0, "1.2".AsDecimal());
            }
        }

        [Fact]
        public void IsFloatTests()
        {
            Assert.True(1.3f.ToString("0.0").IsFloat());
            Assert.True(0.13f.ToString(".00").IsFloat());
            Assert.True(0f.ToString("0.0").IsFloat());
            Assert.True("12345678900123456".IsFloat());
            Assert.True("0".IsFloat());
            Assert.True("123456".IsFloat());
            Assert.True(float.MaxValue.ToString().IsFloat());
            Assert.True(float.MinValue.ToString().IsFloat());
            Assert.True(float.NegativeInfinity.ToString().IsFloat());
            Assert.True(float.PositiveInfinity.ToString().IsFloat());
            Assert.False("gooblygook".IsFloat());
            Assert.False(((string)null).IsFloat());
        }

        [Fact]
        public void AsFloatBasicTests()
        {
            Assert.Equal(-123f, -123f.ToString().AsFloat());
            Assert.Equal(9.99f, 9.99f.ToString().AsFloat());
            Assert.Equal(0f, "0".AsFloat());
            Assert.Equal(-1.1111f, -1.1111f.ToString().AsFloat());
        }

        [Fact]
        public void AsFloatDefaultTests()
        {
            // Illegal values default to 0
            Assert.Equal(0f, "abc".AsFloat());

            Assert.Equal(-1.11f, "adlfkj".AsFloat(-1.11f));
        }

        [Fact]
        public void IsDateTimeTests()
        {
            using (new CultureReplacer())
            {
                Assert.True("Sat, 01 Nov 2008 19:35:00 GMT".IsDateTime());
                Assert.True("1/5/1979".IsDateTime());
                Assert.False("0".IsDateTime());
                Assert.True(DateTime.MaxValue.ToString().IsDateTime());
                Assert.True(DateTime.MinValue.ToString().IsDateTime());
                Assert.True(new DateTime(2010, 12, 21).ToUniversalTime().ToString().IsDateTime());
                Assert.False("gooblygook".IsDateTime());
                Assert.False(((string)null).IsDateTime());
            }
        }

        /// <remarks>Tests for bug 153439</remarks>
        [Fact]
        public void IsDateTimeUsesLocalCulture()
        {
            using (new CultureReplacer(culture: "en-gb"))
            {
                Assert.True(new DateTime(2010, 12, 21).ToString().IsDateTime());
                Assert.True(new DateTime(2010, 12, 11).ToString().IsDateTime());
                Assert.True("2010/01/01".IsDateTime());
                Assert.True("12/01/2010".IsDateTime());
                Assert.True("12/12/2010".IsDateTime());
                Assert.True("13/12/2010".IsDateTime());
                Assert.True("2010-12-01".IsDateTime());
                Assert.True("2010-12-13".IsDateTime());

                Assert.False("12/13/2010".IsDateTime());
                Assert.False("13/13/2010".IsDateTime());
                Assert.False("2010-13-12".IsDateTime());
            }
        }

        [Fact]
        public void AsDateTimeBasicTests()
        {
            using (new CultureReplacer("en-US"))
            {
                Assert.Equal(DateTime.Parse("1/14/1979"), "1/14/1979".AsDateTime());
                Assert.Equal(DateTime.Parse("Sat, 01 Nov 2008 19:35:00 GMT"), "Sat, 01 Nov 2008 19:35:00 GMT".AsDateTime());
            }
        }

        [Theory]
        [InlineData(new object[] { "en-us" })]
        [InlineData(new object[] { "en-gb" })]
        [InlineData(new object[] { "ug" })]
        [InlineData(new object[] { "lt-LT" })]
        public void AsDateTimeDefaultTests(string culture)
        {
            using (new CultureReplacer(culture))
            {
                // Illegal values default to MinTime
                Assert.Equal(DateTime.MinValue, "1".AsDateTime());

                DateTime defaultV = new DateTime(1979, 01, 05);
                Assert.Equal(defaultV, "adlfkj".AsDateTime(defaultV));
                Assert.Equal(defaultV, "Jn 69".AsDateTime(defaultV));
            }
        }

        [Theory]
        [InlineData(new object[] { "en-us" })]
        [InlineData(new object[] { "en-gb" })]
        [InlineData(new object[] { "lt-LT" })]
        public void IsDateTimeDefaultTests(string culture)
        {
            using (new CultureReplacer(culture))
            {
                var dateTime = new DateTime(2011, 10, 25, 10, 10, 00);
                Assert.True(dateTime.ToShortDateString().IsDateTime());
                Assert.True(dateTime.ToString().IsDateTime());
                Assert.True(dateTime.ToLongDateString().IsDateTime());
            }
        }

        [Fact]
        public void IsBoolTests()
        {
            Assert.True("TRUE".IsBool());
            Assert.True("TRUE   ".IsBool());
            Assert.True("false".IsBool());
            Assert.False("falsey".IsBool());
            Assert.False("gooblygook".IsBool());
            Assert.False("".IsBool());
            Assert.False(((string)null).IsBool());
        }

        [Fact]
        public void AsBoolTests()
        {
            Assert.True("TRuE".AsBool());
            Assert.False("False".AsBool());
            Assert.False("Die".AsBool(false));
            Assert.True("true!".AsBool(true));
            Assert.False("".AsBool());
            Assert.False(((string)null).AsBool());
            Assert.True("".AsBool(true));
            Assert.True(((string)null).AsBool(true));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Extensions/StringWriterExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Linq;
using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class StringWriterExtensionsTest
    {
        [Fact]
        public void CopiesResult()
        {
            // Note that a preable is not expected on the generated stream.
            string text = "Hello world";
            Byte[] textInBytes = Encoding.UTF8.GetBytes(text);
            string outputText;

            Byte[] buffer = new Byte[1024];

            using (MemoryStream stream = new MemoryStream(buffer))
            using (StringWriter writer = new StringWriter())
            using (StreamWriter outputWriter = new StreamWriter(stream))
            {
                writer.Write(text);
                writer.CopyTo(outputWriter);

                outputText = writer.ToString();
            }

            Assert.Equal(text, outputText, StringComparer.Ordinal);

            for (int i = 0; i < textInBytes.Length; i++)
            {
                Assert.Equal(textInBytes[i], buffer[i]);
            }
        }

        [Theory]
        [InlineData(1)]
        [InlineData(1023)]
        [InlineData(1024)]
        [InlineData(1025)]
        [InlineData(20000)]
        [InlineData(100000)]
        public void OnlyUsesBufferUpToSize(int count)
        {
            string text = new string('a', count);
            Byte[] textInBytes = Encoding.UTF8.GetBytes(text);

            Mock<StreamWriter> mock;

            Byte[] buffer = new Byte[textInBytes.Length + 100];

            using (MemoryStream stream = new MemoryStream(buffer))
            {
                StringWriter writer = new StringWriter();

                mock = new Mock<StreamWriter>(MockBehavior.Strict, stream) { CallBase = true };
                mock.Setup(sw => sw.Write(It.IsAny<char[]>(),
                                          It.IsAny<int>(),
                                          It.Is<int>(c => c == StringWriterExtensions.BufferSize ||
                                                          c == textInBytes.Length % StringWriterExtensions.BufferSize)))
                    .Verifiable();

                StreamWriter outputWriter = mock.Object;
                writer.Write(text);
                writer.CopyTo(outputWriter);

                mock.Verify();
            }
        }

        [Theory]
        [InlineData(1)]
        [InlineData(1023/7)]
        [InlineData(20000/7)]
        [InlineData(100000/7)]
        public void ProperlyCopiesLargeSetsOfText(int count)
        {
            // The char א turns into a two byte sequence so we end up with a
            // 7 byte sequence that is not a divider or 1024.
            string text = string.Join(string.Empty, Enumerable.Repeat("abcdeא", count));

            Byte[] textInBytes = Encoding.UTF8.GetBytes(text);
            string outputText;

            Byte[] buffer = new Byte[textInBytes.Length + 100];

            using (MemoryStream stream = new MemoryStream(buffer))
            using (StringWriter writer = new StringWriter())
            {
                using (StreamWriter outputWriter = new StreamWriter(stream))
                {
                    writer.Write(text);
                    writer.CopyTo(outputWriter);

                    outputText = writer.ToString();
                }
            }

            Assert.Equal(text, outputText, StringComparer.Ordinal);

            for (int i = 0; i < textInBytes.Length; i++)
            {
                Assert.Equal(textInBytes[i], buffer[i]);
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiForgeryConfigTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class AntiForgeryConfigTest
    {
        [Theory]
        [InlineData(null, "__RequestVerificationToken")]
        [InlineData("", "__RequestVerificationToken")]
        [InlineData("/", "__RequestVerificationToken")]
        [InlineData("/path", "__RequestVerificationToken_L3BhdGg1")]
        public void GetAntiForgeryCookieName(string appPath, string expectedCookieName)
        {
            // Act
            string retVal = AntiForgeryConfig.GetAntiForgeryCookieName(appPath);

            // Assert
            Assert.Equal(expectedCookieName, retVal);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiForgeryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class AntiForgeryTest
    {
        [Fact]
        public void GetHtml_ThrowsWhenNotCalledInWebContext()
        {
            Assert.Throws<ArgumentException>(() => AntiForgery.GetHtml(),
                                                    "An HttpContext is required to perform this operation. Check that this operation is being performed during a web request.");
        }

        [Fact]
        public void GetTokens_ThrowsWhenNotCalledInWebContext()
        {
            Assert.Throws<ArgumentException>(() => { string dummy1, dummy2; AntiForgery.GetTokens("dummy", out dummy1, out dummy2); },
                                                    "An HttpContext is required to perform this operation. Check that this operation is being performed during a web request.");
        }

        [Fact]
        public void Validate_ThrowsWhenNotCalledInWebContext()
        {
            Assert.Throws<ArgumentException>(() => AntiForgery.Validate(),
                                                    "An HttpContext is required to perform this operation. Check that this operation is being performed during a web request.");

            Assert.Throws<ArgumentException>(() => AntiForgery.Validate("cookie-token", "form-token"),
                                                    "An HttpContext is required to perform this operation. Check that this operation is being performed during a web request.");
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/AntiForgeryTokenSerializerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Text;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class AntiForgeryTokenSerializerTest
    {
        private static readonly AntiForgeryTokenSerializer _testSerializer = new AntiForgeryTokenSerializer(cryptoSystem: CreateIdentityTransformCryptoSystem());

        private static readonly BinaryBlob _claimUid = new BinaryBlob(256, new byte[] { 0x6F, 0x16, 0x48, 0xE9, 0x72, 0x49, 0xAA, 0x58, 0x75, 0x40, 0x36, 0xA6, 0x7E, 0x24, 0x8C, 0xF0, 0x44, 0xF0, 0x7E, 0xCF, 0xB0, 0xED, 0x38, 0x75, 0x56, 0xCE, 0x02, 0x9A, 0x4F, 0x9A, 0x40, 0xE0 });
        private static readonly BinaryBlob _securityToken = new BinaryBlob(128, new byte[] { 0x70, 0x5E, 0xED, 0xCC, 0x7D, 0x42, 0xF1, 0xD6, 0xB3, 0xB9, 0x8A, 0x59, 0x36, 0x25, 0xBB, 0x4C });

        [Theory]
        [InlineData(
            "01" // Version
            + "705EEDCC7D42F1D6B3B9" // SecurityToken
            // (WRONG!) Stream ends too early
            )]
        [InlineData(
            "01" // Version
            + "705EEDCC7D42F1D6B3B98A593625BB4C" // SecurityToken
            + "01" // IsSessionToken
            + "00" // (WRONG!) Too much data in stream
            )]
        [InlineData(
            "02" // (WRONG! - must be 0x01) Version
            + "705EEDCC7D42F1D6B3B98A593625BB4C" // SecurityToken
            + "01" // IsSessionToken
            )]
        [InlineData(
            "01" // Version
            + "705EEDCC7D42F1D6B3B98A593625BB4C" // SecurityToken
            + "00" // IsSessionToken
            + "00" // IsClaimsBased
            + "05" // Username length header
            + "0000" // (WRONG!) Too little data in stream
            )]
        public void Deserialize_BadToken(string serializedToken)
        {
            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => _testSerializer.Deserialize(serializedToken));
            Assert.Equal(@"The anti-forgery token could not be decrypted. If this application is hosted by a Web Farm or cluster, ensure that all machines are running the same version of ASP.NET Web Pages and that the <machineKey> configuration specifies explicit encryption and validation keys. AutoGenerate cannot be used in a cluster.", ex.Message);
        }

        [Fact]
        public void Serialize_FieldToken_WithClaimUid()
        {
            // Arrange
            const string expectedSerializedData =
                "01" // Version
                + "705EEDCC7D42F1D6B3B98A593625BB4C" // SecurityToken
                + "00" // IsSessionToken
                + "01" // IsClaimsBased
                + "6F1648E97249AA58754036A67E248CF044F07ECFB0ED387556CE029A4F9A40E0" // ClaimUid
                + "05" // AdditionalData length header
                + "E282AC3437"; // AdditionalData ("€47") as UTF8

            AntiForgeryToken token = new AntiForgeryToken()
            {
                SecurityToken = _securityToken,
                IsSessionToken = false,
                ClaimUid = _claimUid,
                AdditionalData = "€47"
            };

            // Act & assert - serialization
            string actualSerializedData = _testSerializer.Serialize(token);
            Assert.Equal(expectedSerializedData, actualSerializedData);

            // Act & assert - deserialization
            AntiForgeryToken deserializedToken = _testSerializer.Deserialize(actualSerializedData);
            AssertTokensEqual(token, deserializedToken);
        }

        [Fact]
        public void Serialize_FieldToken_WithUsername()
        {
            // Arrange
            const string expectedSerializedData =
                "01" // Version
                + "705EEDCC7D42F1D6B3B98A593625BB4C" // SecurityToken
                + "00" // IsSessionToken
                + "00" // IsClaimsBased
                + "08" // Username length header
                + "4AC3A972C3B46D65" // Username ("Jérôme") as UTF8
                + "05" // AdditionalData length header
                + "E282AC3437"; // AdditionalData ("€47") as UTF8

            AntiForgeryToken token = new AntiForgeryToken()
            {
                SecurityToken = _securityToken,
                IsSessionToken = false,
                Username = "Jérôme",
                AdditionalData = "€47"
            };

            // Act & assert - serialization
            string actualSerializedData = _testSerializer.Serialize(token);
            Assert.Equal(expectedSerializedData, actualSerializedData);

            // Act & assert - deserialization
            AntiForgeryToken deserializedToken = _testSerializer.Deserialize(actualSerializedData);
            AssertTokensEqual(token, deserializedToken);
        }

        [Fact]
        public void Serialize_SessionToken()
        {
            // Arrange
            const string expectedSerializedData =
                "01" // Version
                + "705EEDCC7D42F1D6B3B98A593625BB4C" // SecurityToken
                + "01"; // IsSessionToken

            AntiForgeryToken token = new AntiForgeryToken()
            {
                SecurityToken = _securityToken,
                IsSessionToken = true
            };

            // Act & assert - serialization
            string actualSerializedData = _testSerializer.Serialize(token);
            Assert.Equal(expectedSerializedData, actualSerializedData);

            // Act & assert - deserialization
            AntiForgeryToken deserializedToken = _testSerializer.Deserialize(actualSerializedData);
            AssertTokensEqual(token, deserializedToken);
        }

        private static string BytesToHex(byte[] bytes)
        {
            StringBuilder sb = new StringBuilder();
            foreach (byte b in bytes)
            {
                sb.AppendFormat(CultureInfo.InvariantCulture, "{0:X2}", b);
            }
            return sb.ToString();
        }

        private static byte[] HexToBytes(string hex)
        {
            List<byte> bytes = new List<byte>();
            for (int i = 0; i < hex.Length; i += 2)
            {
                byte b = Byte.Parse(hex.Substring(i, 2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture);
                bytes.Add(b);
            }
            return bytes.ToArray();
        }

        private static ICryptoSystem CreateIdentityTransformCryptoSystem()
        {
            Mock<MockableCryptoSystem> mockCryptoSystem = new Mock<MockableCryptoSystem>();
            mockCryptoSystem.Setup(o => o.Protect(It.IsAny<byte[]>())).Returns<byte[]>(HexUtil.HexEncode);
            mockCryptoSystem.Setup(o => o.Unprotect(It.IsAny<string>())).Returns<string>(HexUtil.HexDecode);
            return mockCryptoSystem.Object;
        }

        private static void AssertTokensEqual(AntiForgeryToken expected, AntiForgeryToken actual)
        {
            Assert.NotNull(expected);
            Assert.NotNull(actual);
            Assert.Equal(expected.AdditionalData, actual.AdditionalData);
            Assert.Equal(expected.ClaimUid, actual.ClaimUid);
            Assert.Equal(expected.IsSessionToken, actual.IsSessionToken);
            Assert.Equal(expected.SecurityToken, actual.SecurityToken);
            Assert.Equal(expected.Username, actual.Username);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/AntiForgeryTokenStoreTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class AntiForgeryTokenStoreTest
    {
        [Fact]
        public void GetCookieToken_CookieDoesNotExist_ReturnsNull()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.Cookies).Returns(new HttpCookieCollection());

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                CookieName = "cookie-name"
            };

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: null);

            // Act
            AntiForgeryToken token = tokenStore.GetCookieToken(mockHttpContext.Object);

            // Assert
            Assert.Null(token);
        }

        [Fact]
        public void GetCookieToken_CookieIsEmpty_ReturnsNull()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.Cookies).Returns(new HttpCookieCollection()
            {
                new HttpCookie("cookie-name", "")
            });

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                CookieName = "cookie-name"
            };

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: null);

            // Act
            AntiForgeryToken token = tokenStore.GetCookieToken(mockHttpContext.Object);

            // Assert
            Assert.Null(token);
        }

        [Fact]
        public void GetCookieToken_CookieIsInvalid_PropagatesException()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.Cookies).Returns(new HttpCookieCollection()
            {
                new HttpCookie("cookie-name", "invalid-value")
            });

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                CookieName = "cookie-name"
            };

            HttpAntiForgeryException expectedException = new HttpAntiForgeryException("some exception");
            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>();
            mockSerializer.Setup(o => o.Deserialize("invalid-value")).Throws(expectedException);

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: mockSerializer.Object);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => tokenStore.GetCookieToken(mockHttpContext.Object));
            Assert.Equal(expectedException, ex);
        }

        [Fact]
        public void GetCookieToken_CookieIsValid_ReturnsToken()
        {
            // Arrange
            AntiForgeryToken expectedToken = new AntiForgeryToken();

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.Cookies).Returns(new HttpCookieCollection()
            {
                new HttpCookie("cookie-name", "valid-value")
            });

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                CookieName = "cookie-name"
            };

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>();
            mockSerializer.Setup(o => o.Deserialize("valid-value")).Returns((object)expectedToken);

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: mockSerializer.Object);

            // Act
            AntiForgeryToken retVal = tokenStore.GetCookieToken(mockHttpContext.Object);

            // Assert
            Assert.Same(expectedToken, retVal);
        }

        [Fact]
        public void GetFormToken_FormFieldIsEmpty_ReturnsNull()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.Form.Get("form-field-name")).Returns("");

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "form-field-name"
            };

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: null);

            // Act
            AntiForgeryToken token = tokenStore.GetFormToken(mockHttpContext.Object);

            // Assert
            Assert.Null(token);
        }

        [Fact]
        public void GetFormToken_FormFieldIsInvalid_PropagatesException()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.Form.Get("form-field-name")).Returns("invalid-value");

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "form-field-name"
            };

            HttpAntiForgeryException expectedException = new HttpAntiForgeryException("some exception");
            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>();
            mockSerializer.Setup(o => o.Deserialize("invalid-value")).Throws(expectedException);

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: mockSerializer.Object);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => tokenStore.GetFormToken(mockHttpContext.Object));
            Assert.Same(expectedException, ex);
        }

        [Fact]
        public void GetFormToken_FormFieldIsValid_ReturnsToken()
        {
            // Arrange
            AntiForgeryToken expectedToken = new AntiForgeryToken();

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.Form.Get("form-field-name")).Returns("valid-value");

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "form-field-name"
            };

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>();
            mockSerializer.Setup(o => o.Deserialize("valid-value")).Returns((object)expectedToken);

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: mockSerializer.Object);

            // Act
            AntiForgeryToken retVal = tokenStore.GetFormToken(mockHttpContext.Object);

            // Assert
            Assert.Same(expectedToken, retVal);
        }

        [Theory]
        [InlineData(true, true)]
        [InlineData(false, null)]
        public void SaveCookieToken(bool requireSsl, bool? expectedCookieSecureFlag)
        {
            // Arrange
            AntiForgeryToken token = new AntiForgeryToken();
            HttpCookieCollection cookies = new HttpCookieCollection();
            bool defaultCookieSecureValue = expectedCookieSecureFlag ?? new HttpCookie("name", "value").Secure; // pulled from config; set by ctor

            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Response.Cookies).Returns(cookies);

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>();
            mockSerializer.Setup(o => o.Serialize(token)).Returns("serialized-value");

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                CookieName = "cookie-name",
                RequireSSL = requireSsl
            };

            AntiForgeryTokenStore tokenStore = new AntiForgeryTokenStore(
                config: config,
                serializer: mockSerializer.Object);

            // Act
            tokenStore.SaveCookieToken(mockHttpContext.Object, token);

            // Assert
            Assert.Single(cookies);
            HttpCookie cookie = cookies["cookie-name"];

            Assert.NotNull(cookie);
            Assert.Equal("serialized-value", cookie.Value);
            Assert.True(cookie.HttpOnly);
            Assert.Equal(defaultCookieSecureValue, cookie.Secure);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/AntiForgeryTokenTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class AntiForgeryTokenTest
    {
        [Fact]
        public void AdditionalDataProperty()
        {
            // Arrange
            AntiForgeryToken token = new AntiForgeryToken();

            // Act & assert - 1
            Assert.Equal("", token.AdditionalData);

            // Act & assert - 2
            token.AdditionalData = "additional data";
            Assert.Equal("additional data", token.AdditionalData);

            // Act & assert - 3
            token.AdditionalData = null;
            Assert.Equal("", token.AdditionalData);
        }

        [Fact]
        public void ClaimUidProperty()
        {
            // Arrange
            AntiForgeryToken token = new AntiForgeryToken();

            // Act & assert - 1
            Assert.Null(token.ClaimUid);

            // Act & assert - 2
            BinaryBlob blob = new BinaryBlob(32);
            token.ClaimUid = blob;
            Assert.Equal(blob, token.ClaimUid);

            // Act & assert - 3
            token.ClaimUid = null;
            Assert.Null(token.ClaimUid);
        }

        [Fact]
        public void IsSessionTokenProperty()
        {
            // Arrange
            AntiForgeryToken token = new AntiForgeryToken();

            // Act & assert - 1
            Assert.False(token.IsSessionToken);

            // Act & assert - 2
            token.IsSessionToken = true;
            Assert.True(token.IsSessionToken);

            // Act & assert - 3
            token.IsSessionToken = false;
            Assert.False(token.IsSessionToken);
        }

        [Fact]
        public void SecurityTokenProperty()
        {
            // Arrange
            AntiForgeryToken token = new AntiForgeryToken();

            // Act & assert - 1
            BinaryBlob securityToken = token.SecurityToken;
            Assert.NotNull(securityToken);
            Assert.Equal(AntiForgeryToken.SecurityTokenBitLength, securityToken.BitLength);
            Assert.Equal(securityToken, token.SecurityToken); // check that we're not making a new one each property call

            // Act & assert - 2
            securityToken = new BinaryBlob(64);
            token.SecurityToken = securityToken;
            Assert.Equal(securityToken, token.SecurityToken);

            // Act & assert - 3
            token.SecurityToken = null;
            securityToken = token.SecurityToken;
            Assert.NotNull(securityToken);
            Assert.Equal(AntiForgeryToken.SecurityTokenBitLength, securityToken.BitLength);
            Assert.Equal(securityToken, token.SecurityToken); // check that we're not making a new one each property call
        }

        [Fact]
        public void UsernameProperty()
        {
            // Arrange
            AntiForgeryToken token = new AntiForgeryToken();

            // Act & assert - 1
            Assert.Equal("", token.Username);

            // Act & assert - 2
            token.Username = "my username";
            Assert.Equal("my username", token.Username);

            // Act & assert - 3
            token.Username = null;
            Assert.Equal("", token.Username);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/AntiForgeryWorkerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.IO;
using System.Security.Principal;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class AntiForgeryWorkerTest
    {
        [Fact]
        public void ChecksSSL()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.Request.IsSecureConnection).Returns(false);

            IAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                RequireSSL = true
            };

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: config,
                serializer: null,
                tokenStore: null,
                validator: null);

            // Act & assert
            var ex = Assert.Throws<InvalidOperationException>(() => worker.Validate(mockHttpContext.Object, "session-token", "field-token"));
            Assert.Equal(@"The anti-forgery system has the configuration value AntiForgeryConfig.RequireSsl = true, but the current request is not an SSL request.", ex.Message);

            ex = Assert.Throws<InvalidOperationException>(() => worker.Validate(mockHttpContext.Object));
            Assert.Equal(@"The anti-forgery system has the configuration value AntiForgeryConfig.RequireSsl = true, but the current request is not an SSL request.", ex.Message);

            ex = Assert.Throws<InvalidOperationException>(() => worker.GetFormInputElement(mockHttpContext.Object));
            Assert.Equal(@"The anti-forgery system has the configuration value AntiForgeryConfig.RequireSsl = true, but the current request is not an SSL request.", ex.Message);

            ex = Assert.Throws<InvalidOperationException>(() => { string dummy1, dummy2; worker.GetTokens(mockHttpContext.Object, "cookie-token", out dummy1, out dummy2); });
            Assert.Equal(@"The anti-forgery system has the configuration value AntiForgeryConfig.RequireSsl = true, but the current request is not an SSL request.", ex.Message);
        }

        [Fact]
        public void GetFormInputElement_ExistingInvalidCookieToken()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(r => r.Headers).Returns(new NameValueCollection());
            mockHttpContext.Setup(o => o.Response).Returns(mockResponse.Object);

            AntiForgeryToken oldCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken newCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken formToken = new AntiForgeryToken();

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "form-field-name"
            };

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>(MockBehavior.Strict);
            mockSerializer.Setup(o => o.Serialize(formToken)).Returns("serialized-form-token");

            Mock<MockableTokenStore> mockTokenStore = new Mock<MockableTokenStore>(MockBehavior.Strict);
            mockTokenStore.Setup(o => o.GetCookieToken(mockHttpContext.Object)).Returns(oldCookieToken);
            mockTokenStore.Setup(o => o.SaveCookieToken(mockHttpContext.Object, newCookieToken)).Verifiable();

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>(MockBehavior.Strict);
            mockValidator.Setup(o => o.GenerateFormToken(mockHttpContext.Object, identity, newCookieToken)).Returns(formToken);
            mockValidator.Setup(o => o.IsCookieTokenValid(oldCookieToken)).Returns(false);
            mockValidator.Setup(o => o.IsCookieTokenValid(newCookieToken)).Returns(true);
            mockValidator.Setup(o => o.GenerateCookieToken()).Returns(newCookieToken);

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: config,
                serializer: mockSerializer.Object,
                tokenStore: mockTokenStore.Object,
                validator: mockValidator.Object);

            // Act
            TagBuilder retVal = worker.GetFormInputElement(mockHttpContext.Object);

            // Assert
            Assert.Equal(@"<input name=""form-field-name"" type=""hidden"" value=""serialized-form-token"" />", retVal.ToString(TagRenderMode.SelfClosing));
            mockTokenStore.Verify();
        }

        [Fact]
        public void GetFormInputElement_ExistingInvalidCookieToken_SwallowsExceptions()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(r => r.Headers).Returns(new NameValueCollection());
            mockHttpContext.Setup(o => o.Response).Returns(mockResponse.Object);

            AntiForgeryToken oldCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken newCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken formToken = new AntiForgeryToken();

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "form-field-name"
            };

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>(MockBehavior.Strict);
            mockSerializer.Setup(o => o.Serialize(formToken)).Returns("serialized-form-token");

            Mock<MockableTokenStore> mockTokenStore = new Mock<MockableTokenStore>(MockBehavior.Strict);
            mockTokenStore.Setup(o => o.GetCookieToken(mockHttpContext.Object)).Throws(new Exception("should be swallowed"));
            mockTokenStore.Setup(o => o.SaveCookieToken(mockHttpContext.Object, newCookieToken)).Verifiable();

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>(MockBehavior.Strict);
            mockValidator.Setup(o => o.GenerateFormToken(mockHttpContext.Object, identity, newCookieToken)).Returns(formToken);
            mockValidator.Setup(o => o.IsCookieTokenValid(null)).Returns(false);
            mockValidator.Setup(o => o.IsCookieTokenValid(newCookieToken)).Returns(true);
            mockValidator.Setup(o => o.GenerateCookieToken()).Returns(newCookieToken);

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: config,
                serializer: mockSerializer.Object,
                tokenStore: mockTokenStore.Object,
                validator: mockValidator.Object);

            // Act
            TagBuilder retVal = worker.GetFormInputElement(mockHttpContext.Object);

            // Assert
            Assert.Equal(@"<input name=""form-field-name"" type=""hidden"" value=""serialized-form-token"" />", retVal.ToString(TagRenderMode.SelfClosing));
            mockTokenStore.Verify();
        }

        [Fact]
        public void GetFormInputElement_ExistingValidCookieToken()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(r => r.Headers).Returns(new NameValueCollection());
            mockHttpContext.Setup(o => o.Response).Returns(mockResponse.Object);
            
            AntiForgeryToken cookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken formToken = new AntiForgeryToken();

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "form-field-name"
            };

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>(MockBehavior.Strict);
            mockSerializer.Setup(o => o.Serialize(formToken)).Returns("serialized-form-token");

            Mock<MockableTokenStore> mockTokenStore = new Mock<MockableTokenStore>(MockBehavior.Strict);
            mockTokenStore.Setup(o => o.GetCookieToken(mockHttpContext.Object)).Returns(cookieToken);

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>(MockBehavior.Strict);
            mockValidator.Setup(o => o.GenerateFormToken(mockHttpContext.Object, identity, cookieToken)).Returns(formToken);
            mockValidator.Setup(o => o.IsCookieTokenValid(cookieToken)).Returns(true);

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: config,
                serializer: mockSerializer.Object,
                tokenStore: mockTokenStore.Object,
                validator: mockValidator.Object);

            // Act
            TagBuilder retVal = worker.GetFormInputElement(mockHttpContext.Object);

            // Assert
            Assert.Equal(@"<input name=""form-field-name"" type=""hidden"" value=""serialized-form-token"" />", retVal.ToString(TagRenderMode.SelfClosing));
        }

        [Theory]
        [InlineData(false, "SAMEORIGIN")]
        [InlineData(true, null)]
        public void GetFormInputElement_AddsXFrameOptionsHeader(bool suppressXFrameOptions, string expectedHeaderValue)
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            NameValueCollection headers = new NameValueCollection();
            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(r => r.Headers).Returns(headers);
            mockResponse.Setup(r => r.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((k, v) =>
            {
                headers.Add(k, v);
            });
            mockHttpContext.Setup(o => o.Response).Returns(mockResponse.Object);

            AntiForgeryToken oldCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken newCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken formToken = new AntiForgeryToken();

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "form-field-name",
                SuppressXFrameOptionsHeader = suppressXFrameOptions
            };

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>(MockBehavior.Strict);
            mockSerializer.Setup(o => o.Serialize(formToken)).Returns("serialized-form-token");

            Mock<MockableTokenStore> mockTokenStore = new Mock<MockableTokenStore>(MockBehavior.Strict);
            mockTokenStore.Setup(o => o.GetCookieToken(mockHttpContext.Object)).Returns(oldCookieToken);
            mockTokenStore.Setup(o => o.SaveCookieToken(mockHttpContext.Object, newCookieToken)).Verifiable();

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>(MockBehavior.Strict);
            mockValidator.Setup(o => o.GenerateFormToken(mockHttpContext.Object, identity, newCookieToken)).Returns(formToken);
            mockValidator.Setup(o => o.IsCookieTokenValid(oldCookieToken)).Returns(false);
            mockValidator.Setup(o => o.IsCookieTokenValid(newCookieToken)).Returns(true);
            mockValidator.Setup(o => o.GenerateCookieToken()).Returns(newCookieToken);

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: config,
                serializer: mockSerializer.Object,
                tokenStore: mockTokenStore.Object,
                validator: mockValidator.Object);
            HttpContextBase context = mockHttpContext.Object;

            // Act
            TagBuilder retVal = worker.GetFormInputElement(context);

            // Assert
            string xFrameOptions = context.Response.Headers["X-FRAME-OPTIONS"];
            Assert.Equal(expectedHeaderValue, xFrameOptions);
        }

        [Fact]
        public void GetTokens_ExistingInvalidCookieToken()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            AntiForgeryToken oldCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken newCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken formToken = new AntiForgeryToken();

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>(MockBehavior.Strict);
            mockSerializer.Setup(o => o.Deserialize("serialized-old-cookie-token")).Returns(oldCookieToken);
            mockSerializer.Setup(o => o.Serialize(newCookieToken)).Returns("serialized-new-cookie-token");
            mockSerializer.Setup(o => o.Serialize(formToken)).Returns("serialized-form-token");

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>(MockBehavior.Strict);
            mockValidator.Setup(o => o.GenerateFormToken(mockHttpContext.Object, identity, newCookieToken)).Returns(formToken);
            mockValidator.Setup(o => o.IsCookieTokenValid(oldCookieToken)).Returns(false);
            mockValidator.Setup(o => o.IsCookieTokenValid(newCookieToken)).Returns(true);
            mockValidator.Setup(o => o.GenerateCookieToken()).Returns(newCookieToken);

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: new MockAntiForgeryConfig(),
                serializer: mockSerializer.Object,
                tokenStore: null,
                validator: mockValidator.Object);

            // Act
            string serializedNewCookieToken, serializedFormToken;
            worker.GetTokens(mockHttpContext.Object, "serialized-old-cookie-token", out serializedNewCookieToken, out serializedFormToken);

            // Assert
            Assert.Equal("serialized-new-cookie-token", serializedNewCookieToken);
            Assert.Equal("serialized-form-token", serializedFormToken);
        }

        [Fact]
        public void GetTokens_ExistingInvalidCookieToken_SwallowsExceptions()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            AntiForgeryToken oldCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken newCookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken formToken = new AntiForgeryToken();

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>(MockBehavior.Strict);
            mockSerializer.Setup(o => o.Deserialize("serialized-old-cookie-token")).Throws(new Exception("should be swallowed"));
            mockSerializer.Setup(o => o.Serialize(newCookieToken)).Returns("serialized-new-cookie-token");
            mockSerializer.Setup(o => o.Serialize(formToken)).Returns("serialized-form-token");

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>(MockBehavior.Strict);
            mockValidator.Setup(o => o.GenerateFormToken(mockHttpContext.Object, identity, newCookieToken)).Returns(formToken);
            mockValidator.Setup(o => o.IsCookieTokenValid(null)).Returns(false);
            mockValidator.Setup(o => o.IsCookieTokenValid(newCookieToken)).Returns(true);
            mockValidator.Setup(o => o.GenerateCookieToken()).Returns(newCookieToken);

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: new MockAntiForgeryConfig(),
                serializer: mockSerializer.Object,
                tokenStore: null,
                validator: mockValidator.Object);

            // Act
            string serializedNewCookieToken, serializedFormToken;
            worker.GetTokens(mockHttpContext.Object, "serialized-old-cookie-token", out serializedNewCookieToken, out serializedFormToken);

            // Assert
            Assert.Equal("serialized-new-cookie-token", serializedNewCookieToken);
            Assert.Equal("serialized-form-token", serializedFormToken);
        }

        [Fact]
        public void GetTokens_ExistingValidCookieToken()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            AntiForgeryToken cookieToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken formToken = new AntiForgeryToken();

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>(MockBehavior.Strict);
            mockSerializer.Setup(o => o.Deserialize("serialized-old-cookie-token")).Returns(cookieToken);
            mockSerializer.Setup(o => o.Serialize(formToken)).Returns("serialized-form-token");

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>(MockBehavior.Strict);
            mockValidator.Setup(o => o.GenerateFormToken(mockHttpContext.Object, identity, cookieToken)).Returns(formToken);
            mockValidator.Setup(o => o.IsCookieTokenValid(cookieToken)).Returns(true);

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: new MockAntiForgeryConfig(),
                serializer: mockSerializer.Object,
                tokenStore: null,
                validator: mockValidator.Object);

            // Act
            string serializedNewCookieToken, serializedFormToken;
            worker.GetTokens(mockHttpContext.Object, "serialized-old-cookie-token", out serializedNewCookieToken, out serializedFormToken);

            // Assert
            Assert.Null(serializedNewCookieToken);
            Assert.Equal("serialized-form-token", serializedFormToken);
        }

        [Fact]
        public void Validate_FromStrings_Failure()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            AntiForgeryToken cookieToken = new AntiForgeryToken();
            AntiForgeryToken formToken = new AntiForgeryToken();

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>();
            mockSerializer.Setup(o => o.Deserialize("cookie-token")).Returns(cookieToken);
            mockSerializer.Setup(o => o.Deserialize("form-token")).Returns(formToken);

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>();
            mockValidator.Setup(o => o.ValidateTokens(mockHttpContext.Object, identity, cookieToken, formToken)).Throws(new HttpAntiForgeryException("my-message"));

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: new MockAntiForgeryConfig(),
                serializer: mockSerializer.Object,
                tokenStore: null,
                validator: mockValidator.Object);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => worker.Validate(mockHttpContext.Object, "cookie-token", "form-token"));
            Assert.Equal("my-message", ex.Message);
        }

        [Fact]
        public void Validate_FromStrings_Success()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            AntiForgeryToken cookieToken = new AntiForgeryToken();
            AntiForgeryToken formToken = new AntiForgeryToken();

            Mock<MockableAntiForgeryTokenSerializer> mockSerializer = new Mock<MockableAntiForgeryTokenSerializer>();
            mockSerializer.Setup(o => o.Deserialize("cookie-token")).Returns(cookieToken);
            mockSerializer.Setup(o => o.Deserialize("form-token")).Returns(formToken);

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>();
            mockValidator.Setup(o => o.ValidateTokens(mockHttpContext.Object, identity, cookieToken, formToken)).Verifiable();

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: new MockAntiForgeryConfig(),
                serializer: mockSerializer.Object,
                tokenStore: null,
                validator: mockValidator.Object);

            // Act
            worker.Validate(mockHttpContext.Object, "cookie-token", "form-token");

            // Assert
            mockValidator.Verify();
        }

        [Fact]
        public void Validate_FromStore_Failure()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            AntiForgeryToken cookieToken = new AntiForgeryToken();
            AntiForgeryToken formToken = new AntiForgeryToken();

            Mock<MockableTokenStore> mockTokenStore = new Mock<MockableTokenStore>();
            mockTokenStore.Setup(o => o.GetCookieToken(mockHttpContext.Object)).Returns(cookieToken);
            mockTokenStore.Setup(o => o.GetFormToken(mockHttpContext.Object)).Returns(formToken);

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>();
            mockValidator.Setup(o => o.ValidateTokens(mockHttpContext.Object, identity, cookieToken, formToken)).Throws(new HttpAntiForgeryException("my-message"));

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: new MockAntiForgeryConfig(),
                serializer: null,
                tokenStore: mockTokenStore.Object,
                validator: mockValidator.Object);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => worker.Validate(mockHttpContext.Object));
            Assert.Equal("my-message", ex.Message);
        }

        [Fact]
        public void Validate_FromStore_Success()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("some-user");
            Mock<HttpContextBase> mockHttpContext = new Mock<HttpContextBase>();
            mockHttpContext.Setup(o => o.User).Returns(new GenericPrincipal(identity, new string[0]));

            AntiForgeryToken cookieToken = new AntiForgeryToken();
            AntiForgeryToken formToken = new AntiForgeryToken();

            Mock<MockableTokenStore> mockTokenStore = new Mock<MockableTokenStore>();
            mockTokenStore.Setup(o => o.GetCookieToken(mockHttpContext.Object)).Returns(cookieToken);
            mockTokenStore.Setup(o => o.GetFormToken(mockHttpContext.Object)).Returns(formToken);

            Mock<MockableTokenValidator> mockValidator = new Mock<MockableTokenValidator>();
            mockValidator.Setup(o => o.ValidateTokens(mockHttpContext.Object, identity, cookieToken, formToken)).Verifiable();

            AntiForgeryWorker worker = new AntiForgeryWorker(
                config: new MockAntiForgeryConfig(),
                serializer: null,
                tokenStore: mockTokenStore.Object,
                validator: mockValidator.Object);

            // Act
            worker.Validate(mockHttpContext.Object);

            // Assert
            mockValidator.Verify();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/BinaryBlobTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class BinaryBlobTest
    {
        [Fact]
        public void Ctor_BitLength()
        {
            // Act
            BinaryBlob blob = new BinaryBlob(bitLength: 64);
            byte[] data = blob.GetData();

            // Assert
            Assert.Equal(64, blob.BitLength);
            Assert.Equal(64 / 8, data.Length);
            Assert.NotEqual(new byte[64 / 8], data); // should not be a zero-filled array
        }

        [Theory]
        [InlineData(24)]
        [InlineData(33)]
        public void Ctor_BitLength_Bad(int bitLength)
        {
            // Act & assert
            var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new BinaryBlob(bitLength));
            Assert.Equal("bitLength", ex.ParamName);
        }

        [Fact]
        public void Ctor_BitLength_ProducesDifferentValues()
        {
            // Act
            BinaryBlob blobA = new BinaryBlob(bitLength: 64);
            BinaryBlob blobB = new BinaryBlob(bitLength: 64);

            // Assert
            Assert.NotEqual(blobA.GetData(), blobB.GetData());
        }

        [Fact]
        public void Ctor_Data()
        {
            // Arrange
            byte[] expectedData = new byte[] { 0x01, 0x02, 0x03, 0x04 };

            // Act
            BinaryBlob blob = new BinaryBlob(32, expectedData);

            // Assert
            Assert.Equal(32, blob.BitLength);
            Assert.Equal(expectedData, blob.GetData());
        }

        [Theory]
        [InlineData((object[])null)]
        [InlineData(new byte[] { 0x01, 0x02, 0x03 })]
        public void Ctor_Data_Bad(byte[] data)
        {
            // Act & assert
            var ex = Assert.Throws<ArgumentOutOfRangeException>(() => new BinaryBlob(32, data));
            Assert.Equal("data", ex.ParamName);
        }

        [Fact]
        public void Equals_DifferentData_ReturnsFalse()
        {
            // Arrange
            object blobA = new BinaryBlob(32, new byte[] { 0x01, 0x02, 0x03, 0x04 });
            object blobB = new BinaryBlob(32, new byte[] { 0x04, 0x03, 0x02, 0x01 });

            // Act & assert
            Assert.NotEqual(blobA, blobB);
        }

        [Fact]
        public void Equals_NotABlob_ReturnsFalse()
        {
            // Arrange
            object blobA = new BinaryBlob(32);
            object blobB = "hello";

            // Act & assert
            Assert.NotEqual(blobA, blobB);
        }

        [Fact]
        public void Equals_Null_ReturnsFalse()
        {
            // Arrange
            object blobA = new BinaryBlob(32);
            object blobB = null;

            // Act & assert
            Assert.NotEqual(blobA, blobB);
        }

        [Fact]
        public void Equals_SameData_ReturnsTrue()
        {
            // Arrange
            object blobA = new BinaryBlob(32, new byte[] { 0x01, 0x02, 0x03, 0x04 });
            object blobB = new BinaryBlob(32, new byte[] { 0x01, 0x02, 0x03, 0x04 });

            // Act & assert
            Assert.Equal(blobA, blobB);
        }

        [Fact]
        public void GetHashCodeTest()
        {
            // Arrange
            byte[] blobData = new byte[] { 0x01, 0x02, 0x03, 0x04 };
            int expectedHashCode = BitConverter.ToInt32(blobData, 0);

            BinaryBlob blob = new BinaryBlob(32, blobData);

            // Act
            int actualHashCode = blob.GetHashCode();

            // Assert
            Assert.Equal(expectedHashCode, actualHashCode);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/ClaimUidExtractorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using System.Security.Principal;
using System.Web.Helpers.Claims;
using System.Web.Helpers.Claims.Test;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class ClaimUidExtractorTest
    {
        [Fact]
        public void ExtractClaimUid_NullIdentity()
        {
            // Arrange
            ClaimUidExtractor extractor = new ClaimUidExtractor(
                config: null,
                claimsIdentityConverter: null);

            // Act
            BinaryBlob retVal = extractor.ExtractClaimUid(null);

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void ExtractClaimUid_Unauthenticated()
        {
            // Arrange
            ClaimUidExtractor extractor = new ClaimUidExtractor(
                config: null,
                claimsIdentityConverter: null);

            Mock<IIdentity> mockIdentity = new Mock<IIdentity>();
            mockIdentity.Setup(o => o.IsAuthenticated).Returns(false);

            // Act
            BinaryBlob retVal = extractor.ExtractClaimUid(mockIdentity.Object);

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void ExtractClaimUid_ClaimsIdentityHeuristicsSuppressed()
        {
            // Arrange
            GenericIdentity identity = new GenericIdentity("the-user");
            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                SuppressIdentityHeuristicChecks = true
            };

            ClaimUidExtractor extractor = new ClaimUidExtractor(
                config: config,
                claimsIdentityConverter: null);

            // Act
            BinaryBlob retVal = extractor.ExtractClaimUid(identity);

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void ExtractClaimUid_NotAClaimsIdentity()
        {
            // Arrange
            Mock<IIdentity> mockIdentity = new Mock<IIdentity>();
            mockIdentity.Setup(o => o.IsAuthenticated).Returns(true);
            MockAntiForgeryConfig config = new MockAntiForgeryConfig();
            ClaimsIdentityConverter converter = new ClaimsIdentityConverter(new Func<IIdentity, ClaimsIdentity>[0]);

            ClaimUidExtractor extractor = new ClaimUidExtractor(
                config: config,
                claimsIdentityConverter: converter);

            // Act
            BinaryBlob retVal = extractor.ExtractClaimUid(mockIdentity.Object);

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void ExtractClaimUid_ClaimsIdentity()
        {
            // Arrange
            Mock<IIdentity> mockIdentity = new Mock<IIdentity>();
            mockIdentity.Setup(o => o.IsAuthenticated).Returns(true);
            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                UniqueClaimTypeIdentifier = "unique-identifier"
            };
            ClaimsIdentityConverter converter = new ClaimsIdentityConverter(new Func<IIdentity, ClaimsIdentity>[] {
               identity =>
               {
                   Assert.Equal(mockIdentity.Object, identity);
                   MockClaimsIdentity claimsIdentity = new MockClaimsIdentity();
                   claimsIdentity.AddClaim("unique-identifier", "some-value");
                   return claimsIdentity;
               }
            });

            ClaimUidExtractor extractor = new ClaimUidExtractor(
                config: config,
                claimsIdentityConverter: converter);

            // Act
            BinaryBlob retVal = extractor.ExtractClaimUid(mockIdentity.Object);

            // Assert
            Assert.NotNull(retVal);
            Assert.Equal("CA9CCFF86F903FBB7505BAAA9F222E49EC2A1E8FAD630AE73DE180BD679751ED", HexUtil.HexEncode(retVal.GetData()));
        }

        [Theory]
        [DefaultUniqueClaimTypes_NotPresent_Data]
        public void DefaultUniqueClaimTypes_NotPresent_Throws(object identity)
        {
            // Arrange
            ClaimsIdentity claimsIdentity = (ClaimsIdentity)identity;

            // Act & assert
            var ex = Assert.Throws<InvalidOperationException>(() => ClaimUidExtractor.GetUniqueIdentifierParameters(claimsIdentity, null));
            Assert.Equal(@"A claim of type 'http://schemas.xmlsoap.org/ws/2005/05/identity/claims/nameidentifier' or 'http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider' was not present on the provided ClaimsIdentity. To enable anti-forgery token support with claims-based authentication, please verify that the configured claims provider is providing both of these claims on the ClaimsIdentity instances it generates. If the configured claims provider instead uses a different claim type as a unique identifier, it can be configured by setting the static property AntiForgeryConfig.UniqueClaimTypeIdentifier.", ex.Message);
        }

        [Fact]
        public void DefaultUniqueClaimTypes_Present()
        {
            // Arrange
            MockClaimsIdentity identity = new MockClaimsIdentity();
            identity.AddClaim("fooClaim", "fooClaimValue");
            identity.AddClaim(ClaimUidExtractor.NameIdentifierClaimType, "nameIdentifierValue");
            identity.AddClaim(ClaimUidExtractor.IdentityProviderClaimType, "identityProviderValue");

            // Act
            var retVal = ClaimUidExtractor.GetUniqueIdentifierParameters(identity, null);

            // Assert
            Assert.Equal(new string[] {
                ClaimUidExtractor.NameIdentifierClaimType,
                "nameIdentifierValue",
                ClaimUidExtractor.IdentityProviderClaimType,
                "identityProviderValue"
            }, retVal);
        }

        [Fact]
        public void ExplicitUniqueClaimType_Present()
        {
            // Arrange
            MockClaimsIdentity identity = new MockClaimsIdentity();
            identity.AddClaim("fooClaim", "fooClaimValue");
            identity.AddClaim(ClaimUidExtractor.NameIdentifierClaimType, "nameIdentifierValue");
            identity.AddClaim(ClaimUidExtractor.IdentityProviderClaimType, "identityProviderValue");

            // Act
            var retVal = ClaimUidExtractor.GetUniqueIdentifierParameters(identity, "fooClaim");

            // Assert
            Assert.Equal(new string[] {
                "fooClaim",
                "fooClaimValue"
            }, retVal);
        }

        [Theory]
        [ExplicitUniqueClaimType_NotPresent_Data]
        public void ExplicitUniqueClaimType_NotPresent_Throws(object identity)
        {
            // Arrange
            ClaimsIdentity claimsIdentity = (ClaimsIdentity)identity;

            // Act & assert
            var ex = Assert.Throws<InvalidOperationException>(() => ClaimUidExtractor.GetUniqueIdentifierParameters(claimsIdentity, "fooClaim"));
            Assert.Equal(@"A claim of type 'fooClaim' was not present on the provided ClaimsIdentity.", ex.Message);
        }

        private sealed class DefaultUniqueClaimTypes_NotPresent_DataAttribute : DataAttribute
        {
            public override IEnumerable<object[]> GetData(MethodInfo methodUnderTest, Type[] parameterTypes)
            {
                MockClaimsIdentity identity1 = new MockClaimsIdentity();
                identity1.AddClaim(ClaimUidExtractor.IdentityProviderClaimType, "identityProviderValue");
                yield return new object[] { identity1 };

                MockClaimsIdentity identity2 = new MockClaimsIdentity();
                identity2.AddClaim(ClaimUidExtractor.NameIdentifierClaimType, String.Empty);
                identity2.AddClaim(ClaimUidExtractor.IdentityProviderClaimType, "identityProviderValue");
                yield return new object[] { identity2 };

                MockClaimsIdentity identity3 = new MockClaimsIdentity();
                identity3.AddClaim(ClaimUidExtractor.NameIdentifierClaimType, "nameIdentifierValue");
                yield return new object[] { identity3 };

                MockClaimsIdentity identity4 = new MockClaimsIdentity();
                identity4.AddClaim(ClaimUidExtractor.NameIdentifierClaimType, "nameIdentifierValue");
                identity4.AddClaim(ClaimUidExtractor.IdentityProviderClaimType, String.Empty);
                yield return new object[] { identity4 };

                MockClaimsIdentity identity5 = new MockClaimsIdentity();
                identity5.AddClaim(ClaimUidExtractor.NameIdentifierClaimType.ToUpper(), "nameIdentifierValue");
                identity5.AddClaim(ClaimUidExtractor.IdentityProviderClaimType.ToUpper(), "identityProviderValue");
                yield return new object[] { identity5 };
            }
        }

        private sealed class ExplicitUniqueClaimType_NotPresent_DataAttribute : DataAttribute
        {
            public override IEnumerable<object[]> GetData(MethodInfo methodUnderTest, Type[] parameterTypes)
            {
                MockClaimsIdentity identity1 = new MockClaimsIdentity();
                yield return new object[] { identity1 };

                MockClaimsIdentity identity2 = new MockClaimsIdentity();
                identity2.AddClaim("fooClaim", String.Empty);
                yield return new object[] { identity2 };

                MockClaimsIdentity identity3 = new MockClaimsIdentity();
                identity3.AddClaim("FOOCLAIM", "fooClaimValue");
                yield return new object[] { identity3 };

                MockClaimsIdentity identity4 = new MockClaimsIdentity();
                identity4.AddClaim(ClaimUidExtractor.NameIdentifierClaimType, "nameIdentifierValue");
                identity4.AddClaim(ClaimUidExtractor.IdentityProviderClaimType, "identityProviderValue");
                yield return new object[] { identity4 };
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/HexUtil.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Text;

namespace System.Web.Helpers.AntiXsrf.Test
{
    internal static class HexUtil
    {
        public static string HexEncode(byte[] data)
        {
            StringBuilder sb = new StringBuilder(data.Length * 2);
            foreach (byte b in data)
            {
                sb.AppendFormat(CultureInfo.InvariantCulture, "{0:X2}", b);
            }
            return sb.ToString();
        }

        public static byte[] HexDecode(string input)
        {
            List<byte> bytes = new List<byte>(input.Length / 2);
            for (int i = 0; i < input.Length; i += 2)
            {
                bytes.Add(Byte.Parse(input.Substring(i, 2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture));
            }
            return bytes.ToArray();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/MachineKey45CryptoSystemTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class MachineKey45CryptoSystemTest
    {
        [Fact]
        public void Protect()
        {
            // Arrange
            byte[] unprotectedBytes = new byte[] { 1, 2, 3, 4, 5 };
            string unprotectedString = HttpServerUtility.UrlTokenEncode(unprotectedBytes);

            MachineKey45CryptoSystem cryptoSystem = new MachineKey45CryptoSystem();

            // Act
            string protectedString = cryptoSystem.Protect(unprotectedBytes);

            // Assert
            Assert.NotEqual(unprotectedString, protectedString);
        }

        [Fact]
        public void Unprotect()
        {
            // Arrange
            byte[] unprotectedBytes = new byte[] { 1, 2, 3, 4, 5 };

            MachineKey45CryptoSystem cryptoSystem = new MachineKey45CryptoSystem();

            // Act
            string protectedString = cryptoSystem.Protect(unprotectedBytes);
            byte[] output = cryptoSystem.Unprotect(protectedString);

            // Assert
            Assert.Equal(unprotectedBytes, output);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/MockAntiForgeryConfig.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf.Test
{
    public sealed class MockAntiForgeryConfig : IAntiForgeryConfig
    {
        public IAntiForgeryAdditionalDataProvider AdditionalDataProvider
        {
            get;
            set;
        }

        public string CookieName
        {
            get;
            set;
        }

        public string FormFieldName
        {
            get;
            set;
        }

        public bool RequireSSL
        {
            get;
            set;
        }

        public bool SuppressIdentityHeuristicChecks
        {
            get;
            set;
        }

        public string UniqueClaimTypeIdentifier
        {
            get;
            set;
        }

        public bool SuppressXFrameOptionsHeader
        {
            get;
            set;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/MockableAntiForgeryTokenSerializer.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf.Test
{
    // An IAntiForgeryTokenSerializer that can be passed to MoQ.
    public abstract class MockableAntiForgeryTokenSerializer : IAntiForgeryTokenSerializer
    {
        public abstract object Deserialize(string serializedToken);
        public abstract string Serialize(object token);

        AntiForgeryToken IAntiForgeryTokenSerializer.Deserialize(string serializedToken)
        {
            return (AntiForgeryToken)Deserialize(serializedToken);
        }

        string IAntiForgeryTokenSerializer.Serialize(AntiForgeryToken token)
        {
            return Serialize(token);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/MockableClaimUidExtractor.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Principal;

namespace System.Web.Helpers.AntiXsrf.Test
{
    // An IClaimUidExtractor that can be passed to MoQ
    public abstract class MockableClaimUidExtractor : IClaimUidExtractor
    {
        public abstract object ExtractClaimUid(IIdentity identity);

        BinaryBlob IClaimUidExtractor.ExtractClaimUid(IIdentity identity)
        {
            return (BinaryBlob)ExtractClaimUid(identity);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/MockableCryptoSystem.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace System.Web.Helpers.AntiXsrf.Test
{
    // An ICryptoSystem that can be passed to MoQ
    public abstract class MockableCryptoSystem : ICryptoSystem
    {
        public abstract string Protect(byte[] data);
        public abstract byte[] Unprotect(string protectedData);
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/MockableTokenStore.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.


namespace System.Web.Helpers.AntiXsrf.Test
{
    // An ITokenStore that can be passed to MoQ
    public abstract class MockableTokenStore : ITokenStore
    {
        public abstract object GetCookieToken(HttpContextBase httpContext);
        public abstract object GetFormToken(HttpContextBase httpContext);
        public abstract void SaveCookieToken(HttpContextBase httpContext, object token);

        AntiForgeryToken ITokenStore.GetCookieToken(HttpContextBase httpContext)
        {
            return (AntiForgeryToken)GetCookieToken(httpContext);
        }

        AntiForgeryToken ITokenStore.GetFormToken(HttpContextBase httpContext)
        {
            return (AntiForgeryToken)GetFormToken(httpContext);
        }

        void ITokenStore.SaveCookieToken(HttpContextBase httpContext, AntiForgeryToken token)
        {
            SaveCookieToken(httpContext, (AntiForgeryToken)token);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/MockableTokenValidator.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Principal;

namespace System.Web.Helpers.AntiXsrf.Test
{
    // An ITokenValidator that can be passed to MoQ
    public abstract class MockableTokenValidator : ITokenValidator
    {
        public abstract object GenerateCookieToken();
        public abstract object GenerateFormToken(HttpContextBase httpContext, IIdentity identity, object cookieToken);
        public abstract bool IsCookieTokenValid(object cookieToken);
        public abstract void ValidateTokens(HttpContextBase httpContext, IIdentity identity, object cookieToken, object formToken);

        AntiForgeryToken ITokenValidator.GenerateCookieToken()
        {
            return (AntiForgeryToken)GenerateCookieToken();
        }

        AntiForgeryToken ITokenValidator.GenerateFormToken(HttpContextBase httpContext, IIdentity identity, AntiForgeryToken cookieToken)
        {
            return (AntiForgeryToken)GenerateFormToken(httpContext, identity, (AntiForgeryToken)cookieToken);
        }

        bool ITokenValidator.IsCookieTokenValid(AntiForgeryToken cookieToken)
        {
            return IsCookieTokenValid((AntiForgeryToken)cookieToken);
        }

        void ITokenValidator.ValidateTokens(HttpContextBase httpContext, IIdentity identity, AntiForgeryToken cookieToken, AntiForgeryToken formToken)
        {
            ValidateTokens(httpContext, identity, (AntiForgeryToken)cookieToken, (AntiForgeryToken)formToken);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/AntiXsrf/TokenValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Security.Principal;
using System.Web.Mvc;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.AntiXsrf.Test
{
    public class TokenValidatorTest
    {
        [Fact]
        public void GenerateCookieToken()
        {
            // Arrange
            TokenValidator tokenValidator = new TokenValidator(
                config: null,
                claimUidExtractor: null);

            // Act
            AntiForgeryToken retVal = tokenValidator.GenerateCookieToken();

            // Assert
            Assert.NotNull(retVal);
        }

        [Fact]
        public void GenerateFormToken_AnonymousUser()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken() { IsSessionToken = true };
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            Mock<IIdentity> mockIdentity = new Mock<IIdentity>();
            mockIdentity.Setup(o => o.IsAuthenticated).Returns(false);

            IAntiForgeryConfig config = new MockAntiForgeryConfig();

            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: null);

            // Act
            var fieldToken = validator.GenerateFormToken(httpContext, mockIdentity.Object, cookieToken);

            // Assert
            Assert.NotNull(fieldToken);
            Assert.Equal(cookieToken.SecurityToken, fieldToken.SecurityToken);
            Assert.False(fieldToken.IsSessionToken);
            Assert.Equal("", fieldToken.Username);
            Assert.Null(fieldToken.ClaimUid);
            Assert.Equal("", fieldToken.AdditionalData);
        }

        [Fact]
        public void GenerateFormToken_AuthenticatedWithoutUsernameAndNoAdditionalData_NoAdditionalData()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken()
            {
                IsSessionToken = true
            };

            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new MyAuthenticatedIdentityWithoutUsername();
            IAntiForgeryConfig config = new MockAntiForgeryConfig();
            IClaimUidExtractor claimUidExtractor = new Mock<MockableClaimUidExtractor>().Object;

            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: claimUidExtractor);

            // Act & assert
            var ex = Assert.Throws<InvalidOperationException>(() => validator.GenerateFormToken(httpContext, identity, cookieToken));
            Assert.Equal(@"The provided identity of type 'System.Web.Helpers.AntiXsrf.Test.TokenValidatorTest+MyAuthenticatedIdentityWithoutUsername' is marked IsAuthenticated = true but does not have a value for Name. By default, the anti-forgery system requires that all authenticated identities have a unique Name. If it is not possible to provide a unique Name for this identity, consider setting the static property AntiForgeryConfig.AdditionalDataProvider to an instance of a type that can provide some form of unique identifier for the current user.", ex.Message);
        }

        [Fact]
        public void GenerateFormToken_AuthenticatedWithoutUsernameAndNoAdditionalData_NoAdditionalData_SuppressHeuristics()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken() { IsSessionToken = true };
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new MyAuthenticatedIdentityWithoutUsername();

            IAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                SuppressIdentityHeuristicChecks = true
            };
            IClaimUidExtractor claimUidExtractor = new Mock<MockableClaimUidExtractor>().Object;

            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: claimUidExtractor);

            // Act
            var fieldToken = validator.GenerateFormToken(httpContext, identity, cookieToken);

            // Assert
            Assert.NotNull(fieldToken);
            Assert.Equal(cookieToken.SecurityToken, fieldToken.SecurityToken);
            Assert.False(fieldToken.IsSessionToken);
            Assert.Equal("", fieldToken.Username);
            Assert.Null(fieldToken.ClaimUid);
            Assert.Equal("", fieldToken.AdditionalData);
        }

        [Fact]
        public void GenerateFormToken_AuthenticatedWithoutUsername_WithAdditionalData()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken() { IsSessionToken = true };
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new MyAuthenticatedIdentityWithoutUsername();

            Mock<IAntiForgeryAdditionalDataProvider> mockAdditionalDataProvider = new Mock<IAntiForgeryAdditionalDataProvider>();
            mockAdditionalDataProvider.Setup(o => o.GetAdditionalData(httpContext)).Returns("additional-data");

            IAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                AdditionalDataProvider = mockAdditionalDataProvider.Object
            };
            IClaimUidExtractor claimUidExtractor = new Mock<MockableClaimUidExtractor>().Object;

            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: claimUidExtractor);

            // Act
            var fieldToken = validator.GenerateFormToken(httpContext, identity, cookieToken);

            // Assert
            Assert.NotNull(fieldToken);
            Assert.Equal(cookieToken.SecurityToken, fieldToken.SecurityToken);
            Assert.False(fieldToken.IsSessionToken);
            Assert.Equal("", fieldToken.Username);
            Assert.Null(fieldToken.ClaimUid);
            Assert.Equal("additional-data", fieldToken.AdditionalData);
        }

        [Fact]
        public void GenerateFormToken_ClaimsBasedIdentity()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken() { IsSessionToken = true };
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new GenericIdentity("some-identity");

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                UniqueClaimTypeIdentifier = "unique-identifier"
            };

            BinaryBlob expectedClaimUid = new BinaryBlob(256);
            Mock<MockableClaimUidExtractor> mockClaimUidExtractor = new Mock<MockableClaimUidExtractor>();
            mockClaimUidExtractor.Setup(o => o.ExtractClaimUid(identity)).Returns((object)expectedClaimUid);

            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: mockClaimUidExtractor.Object);

            // Act
            var fieldToken = validator.GenerateFormToken(httpContext, identity, cookieToken);

            // Assert
            Assert.NotNull(fieldToken);
            Assert.Equal(cookieToken.SecurityToken, fieldToken.SecurityToken);
            Assert.False(fieldToken.IsSessionToken);
            Assert.Equal("", fieldToken.Username);
            Assert.Equal(expectedClaimUid, fieldToken.ClaimUid);
            Assert.Equal("", fieldToken.AdditionalData);
        }

        [Fact]
        public void GenerateFormToken_RegularUserWithUsername()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken() { IsSessionToken = true };

            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            Mock<IIdentity> mockIdentity = new Mock<IIdentity>();
            mockIdentity.Setup(o => o.IsAuthenticated).Returns(true);
            mockIdentity.Setup(o => o.Name).Returns("my-username");

            IAntiForgeryConfig config = new MockAntiForgeryConfig();
            IClaimUidExtractor claimUidExtractor = new Mock<MockableClaimUidExtractor>().Object;

            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: claimUidExtractor);

            // Act
            var fieldToken = validator.GenerateFormToken(httpContext, mockIdentity.Object, cookieToken);

            // Assert
            Assert.NotNull(fieldToken);
            Assert.Equal(cookieToken.SecurityToken, fieldToken.SecurityToken);
            Assert.False(fieldToken.IsSessionToken);
            Assert.Equal("my-username", fieldToken.Username);
            Assert.Null(fieldToken.ClaimUid);
            Assert.Equal("", fieldToken.AdditionalData);
        }

        [Fact]
        public void IsCookieTokenValid_FieldToken_ReturnsFalse()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken()
            {
                IsSessionToken = false
            };

            TokenValidator validator = new TokenValidator(
                config: null,
                claimUidExtractor: null);

            // Act
            bool retVal = validator.IsCookieTokenValid(cookieToken);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void IsCookieTokenValid_NullToken_ReturnsFalse()
        {
            // Arrange
            AntiForgeryToken cookieToken = null;
            TokenValidator validator = new TokenValidator(
                config: null,
                claimUidExtractor: null);

            // Act
            bool retVal = validator.IsCookieTokenValid(cookieToken);

            // Assert
            Assert.False(retVal);
        }

        [Fact]
        public void IsCookieTokenValid_ValidToken_ReturnsTrue()
        {
            // Arrange
            AntiForgeryToken cookieToken = new AntiForgeryToken()
            {
                IsSessionToken = true
            };

            TokenValidator validator = new TokenValidator(
                config: null,
                claimUidExtractor: null);

            // Act
            bool retVal = validator.IsCookieTokenValid(cookieToken);

            // Assert
            Assert.True(retVal);
        }

        [Fact]
        public void ValidateTokens_SessionTokenMissing()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new Mock<IIdentity>().Object;
            AntiForgeryToken sessionToken = null;
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { IsSessionToken = false };

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                CookieName = "my-cookie-name"
            };
            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: null);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken));
            Assert.Equal(@"The required anti-forgery cookie ""my-cookie-name"" is not present.", ex.Message);
        }

        [Fact]
        public void ValidateTokens_FieldTokenMissing()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new Mock<IIdentity>().Object;
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = null;

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                FormFieldName = "my-form-field-name"
            };
            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: null);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken));
            Assert.Equal(@"The required anti-forgery form field ""my-form-field-name"" is not present.", ex.Message);
        }

        [Fact]
        public void ValidateTokens_FieldAndSessionTokensSwapped()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new Mock<IIdentity>().Object;
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { IsSessionToken = false };

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                CookieName = "my-cookie-name",
                FormFieldName = "my-form-field-name"
            };
            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: null);

            // Act & assert
            var ex1 = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, fieldtoken, fieldtoken));
            Assert.Equal(@"Validation of the provided anti-forgery token failed. The cookie ""my-cookie-name"" and the form field ""my-form-field-name"" were swapped.", ex1.Message);

            var ex2 = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, sessionToken, sessionToken));
            Assert.Equal(@"Validation of the provided anti-forgery token failed. The cookie ""my-cookie-name"" and the form field ""my-form-field-name"" were swapped.", ex2.Message);
        }

        [Fact]
        public void ValidateTokens_FieldAndSessionTokensHaveDifferentSecurityKeys()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new Mock<IIdentity>().Object;
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { IsSessionToken = false };

            TokenValidator validator = new TokenValidator(
                config: null,
                claimUidExtractor: null);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken));
            Assert.Equal(@"The anti-forgery cookie token and form field token do not match.", ex.Message);
        }

        [Theory]
        [InlineData("the-user", "the-other-user")]
        [InlineData("http://example.com/uri-casing", "http://example.com/URI-casing")]
        [InlineData("https://example.com/secure-uri-casing", "https://example.com/secure-URI-casing")]
        public void ValidateTokens_UsernameMismatch(string identityUsername, string embeddedUsername)
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new GenericIdentity(identityUsername);
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { SecurityToken = sessionToken.SecurityToken, Username = embeddedUsername, IsSessionToken = false };

            Mock<MockableClaimUidExtractor> mockClaimUidExtractor = new Mock<MockableClaimUidExtractor>();
            mockClaimUidExtractor.Setup(o => o.ExtractClaimUid(identity)).Returns((object)null);

            TokenValidator validator = new TokenValidator(
                config: null,
                claimUidExtractor: mockClaimUidExtractor.Object);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken));
            Assert.Equal(@"The provided anti-forgery token was meant for user """ + embeddedUsername + @""", but the current user is """ + identityUsername + @""".", ex.Message);
        }

        [Fact]
        public void ValidateTokens_ClaimUidMismatch()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new GenericIdentity("the-user");
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { SecurityToken = sessionToken.SecurityToken, IsSessionToken = false, ClaimUid = new BinaryBlob(256) };

            Mock<MockableClaimUidExtractor> mockClaimUidExtractor = new Mock<MockableClaimUidExtractor>();
            mockClaimUidExtractor.Setup(o => o.ExtractClaimUid(identity)).Returns(new BinaryBlob(256));

            TokenValidator validator = new TokenValidator(
                config: null,
                claimUidExtractor: mockClaimUidExtractor.Object);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken));
            Assert.Equal(@"The provided anti-forgery token was meant for a different claims-based user than the current user.", ex.Message);
        }

        [Fact]
        public void ValidateTokens_AdditionalDataRejected()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new GenericIdentity(String.Empty);
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { SecurityToken = sessionToken.SecurityToken, Username = String.Empty, IsSessionToken = false, AdditionalData = "some-additional-data" };

            Mock<IAntiForgeryAdditionalDataProvider> mockAdditionalDataProvider = new Mock<IAntiForgeryAdditionalDataProvider>();
            mockAdditionalDataProvider.Setup(o => o.ValidateAdditionalData(httpContext, "some-additional-data")).Returns(false);

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                AdditionalDataProvider = mockAdditionalDataProvider.Object
            };
            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: null);

            // Act & assert
            var ex = Assert.Throws<HttpAntiForgeryException>(() => validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken));
            Assert.Equal(@"The provided anti-forgery token failed a custom data check.", ex.Message);
        }

        [Fact]
        public void ValidateTokens_Success_AnonymousUser()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new GenericIdentity(String.Empty);
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { SecurityToken = sessionToken.SecurityToken, Username = String.Empty, IsSessionToken = false, AdditionalData = "some-additional-data" };

            Mock<IAntiForgeryAdditionalDataProvider> mockAdditionalDataProvider = new Mock<IAntiForgeryAdditionalDataProvider>();
            mockAdditionalDataProvider.Setup(o => o.ValidateAdditionalData(httpContext, "some-additional-data")).Returns(true);

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                AdditionalDataProvider = mockAdditionalDataProvider.Object
            };
            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: null);

            // Act
            validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken);

            // Assert
            // Nothing to assert - if we got this far, success!
        }

        [Fact]
        public void ValidateTokens_Success_AuthenticatedUserWithUsername()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new GenericIdentity("the-user");
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { SecurityToken = sessionToken.SecurityToken, Username = "THE-USER", IsSessionToken = false, AdditionalData = "some-additional-data" };

            Mock<IAntiForgeryAdditionalDataProvider> mockAdditionalDataProvider = new Mock<IAntiForgeryAdditionalDataProvider>();
            mockAdditionalDataProvider.Setup(o => o.ValidateAdditionalData(httpContext, "some-additional-data")).Returns(true);

            MockAntiForgeryConfig config = new MockAntiForgeryConfig()
            {
                AdditionalDataProvider = mockAdditionalDataProvider.Object
            };
            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: new Mock<MockableClaimUidExtractor>().Object);

            // Act
            validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken);

            // Assert
            // Nothing to assert - if we got this far, success!
        }

        [Fact]
        public void ValidateTokens_Success_ClaimsBasedUser()
        {
            // Arrange
            HttpContextBase httpContext = new Mock<HttpContextBase>().Object;
            IIdentity identity = new GenericIdentity("the-user");
            AntiForgeryToken sessionToken = new AntiForgeryToken() { IsSessionToken = true };
            AntiForgeryToken fieldtoken = new AntiForgeryToken() { SecurityToken = sessionToken.SecurityToken, IsSessionToken = false, ClaimUid = new BinaryBlob(256) };

            Mock<MockableClaimUidExtractor> mockClaimUidExtractor = new Mock<MockableClaimUidExtractor>();
            mockClaimUidExtractor.Setup(o => o.ExtractClaimUid(identity)).Returns(fieldtoken.ClaimUid);

            MockAntiForgeryConfig config = new MockAntiForgeryConfig();

            TokenValidator validator = new TokenValidator(
                config: config,
                claimUidExtractor: mockClaimUidExtractor.Object);

            // Act
            validator.ValidateTokens(httpContext, identity, sessionToken, fieldtoken);

            // Assert
            // Nothing to assert - if we got this far, success!
        }

        private sealed class MyAuthenticatedIdentityWithoutUsername : IIdentity
        {
            public string AuthenticationType
            {
                get { throw new NotImplementedException(); }
            }

            public bool IsAuthenticated
            {
                get { return true; }
            }

            public string Name
            {
                get { return String.Empty; }
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/Claims/ClaimTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Helpers.Claims.Test
{
    public class ClaimTest
    {
        [Fact]
        public void CtorAndProperties()
        {
            // Act
            Claim claim = new Claim("claim-type", "claim-value");

            // Assert
            Assert.Equal("claim-type", claim.ClaimType);
            Assert.Equal("claim-value", claim.Value);
        }

        [Fact]
        public void Create_WithClaimTypeProperty()
        {
            // Act
            Claim claim = Claim.Create<IClaimType1>(new MyClaimType());

            // Assert
            Assert.Equal("my-claim-type-1", claim.ClaimType);
            Assert.Equal("my-claim-value-1", claim.Value);
        }

        [Fact]
        public void Create_WithTypeProperty()
        {
            // Act
            Claim claim = Claim.Create<IClaimType2>(new MyClaimType());

            // Assert
            Assert.Equal("my-claim-type-2", claim.ClaimType);
            Assert.Equal("my-claim-value-2", claim.Value);
        }

        private interface IClaimType1
        {
            string ClaimType { get; }
            string Value { get; }
        }

        private interface IClaimType2
        {
            string Type { get; }
            string Value { get; }
        }

        private sealed class MyClaimType : IClaimType1, IClaimType2
        {
            string IClaimType1.ClaimType { get { return "my-claim-type-1"; } }
            string IClaimType1.Value { get { return "my-claim-value-1"; } }

            string IClaimType2.Type { get { return "my-claim-type-2"; } }
            string IClaimType2.Value { get { return "my-claim-value-2"; } }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/Claims/ClaimsIdentityConverterTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Reflection;
using System.Security.Principal;
using System.Web.Security;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.Helpers.Claims.Test
{
    public class ClaimsIdentityConverterTest
    {
        [Fact]
        public void TryConvert_NoMatches_ReturnsNull()
        {
            // Arrange
            IIdentity identity = new Mock<IIdentity>().Object;
            ClaimsIdentityConverter converter = new ClaimsIdentityConverter(new Func<IIdentity, ClaimsIdentity>[0]);

            // Act
            ClaimsIdentity retVal = converter.TryConvert(identity);

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void TryConvert_ReturnsFirstMatch()
        {
            // Arrange
            IIdentity identity = new Mock<IIdentity>().Object;
            ClaimsIdentity claimsIdentity = new MockClaimsIdentity();

            ClaimsIdentityConverter converter = new ClaimsIdentityConverter(new Func<IIdentity, ClaimsIdentity>[]
            {
                _ => null,
                i => (i == identity) ? claimsIdentity : null
            });

            // Act
            ClaimsIdentity retVal = converter.TryConvert(identity);

            // Assert
            Assert.Same(claimsIdentity, retVal);
        }

        [Theory]
        [GrandfatheredTypesData]
        public void TryConvert_SkipsGrandfatheredTypes(IIdentity identity)
        {
            // Arrange
            ClaimsIdentityConverter converter = new ClaimsIdentityConverter(new Func<IIdentity, ClaimsIdentity>[]
            {
                _ => { throw new Exception("Should never be called."); }
            });

            // Act
            ClaimsIdentity retVal = converter.TryConvert(identity);

            // Assert
            Assert.Null(retVal);
        }

        private sealed class GrandfatheredTypesDataAttribute : DataAttribute
        {
            // We need to subclass these types so that they implement the
            // appropriate interface to be claims-based.
            public override IEnumerable<object[]> GetData(MethodInfo methodUnderTest, Type[] parameterTypes)
            {
                yield return new object[] { new SubclassedFormsIdentity() };
                yield return new object[] { new SubclassedGenericIdentity() };

                SubclassedWindowsIdentity subclassedWindowsIdentity = null;
                using (WindowsIdentity originalIdentity = WindowsIdentity.GetCurrent())
                {
                    subclassedWindowsIdentity = new SubclassedWindowsIdentity(originalIdentity.Token);
                }
                yield return new object[] { subclassedWindowsIdentity };
            }
        }

        private sealed class SubclassedFormsIdentity : FormsIdentity
        {
            public SubclassedFormsIdentity() : base(new FormsAuthenticationTicket("my-name", false, 60)) { }
        }

        private sealed class SubclassedGenericIdentity : GenericIdentity
        {
            public SubclassedGenericIdentity() : base("my-name") { }
        }

        private sealed class SubclassedWindowsIdentity : WindowsIdentity
        {
            public SubclassedWindowsIdentity(IntPtr userToken) : base(userToken) { }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/Claims/ClaimsIdentityTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Security.Principal;
using Microsoft.TestCommon;

namespace System.Web.Helpers.Claims.Test
{
    public class ClaimsIdentityTest
    {
        [Fact]
        public void TryConvert_GetClaims()
        {
            // Act
            ClaimsIdentity claimsIdentity = ClaimsIdentity.TryConvert<IClaimsIdentity, IClaim>(new MyClaimsIdentity());
            var claims = claimsIdentity.GetClaims().ToArray();

            // Assert
            Assert.Equal(2, claims.Length);
            Assert.Equal("claim-type-1", claims[0].ClaimType);
            Assert.Equal("claim-value-1", claims[0].Value);
            Assert.Equal("claim-type-2", claims[1].ClaimType);
            Assert.Equal("claim-value-2", claims[1].Value);
        }

        private interface IClaimsIdentity : IIdentity
        {
            IEnumerable<IClaim> Claims { get; }
        }

        private interface IClaim
        {
            string ClaimType { get; }
            string Value { get; }
        }

        private sealed class MyClaimsIdentity : IClaimsIdentity, IIdentity
        {
            IEnumerable<IClaim> IClaimsIdentity.Claims
            {
                get
                {
                    return new MyClaim[]
                    {
                        new MyClaim() { ClaimType = "claim-type-1", Value = "claim-value-1" },
                        new MyClaim() { ClaimType = "claim-type-2", Value = "claim-value-2" }
                    };
                }
            }

            string IIdentity.AuthenticationType
            {
                get { throw new NotImplementedException(); }
            }

            bool IIdentity.IsAuthenticated
            {
                get { throw new NotImplementedException(); }
            }

            string IIdentity.Name
            {
                get { throw new NotImplementedException(); }
            }

            private sealed class MyClaim : IClaim
            {
                public string ClaimType { get; set; }
                public string Value { get; set; }
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/Claims/MockClaimsIdentity.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace System.Web.Helpers.Claims.Test
{
    // Convenient class for mocking a ClaimsIdentity instance given some
    // prefabricated Claim instances.
    internal sealed class MockClaimsIdentity : ClaimsIdentity
    {
        private readonly List<Claim> _claims = new List<Claim>();

        public void AddClaim(string claimType, string value)
        {
            _claims.Add(new Claim(claimType, value));
        }

        public override IEnumerable<Claim> GetClaims()
        {
            return _claims;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/CryptoUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Helpers.Test
{
    public class CryptoUtilTest
    {
        [Theory]
        [InlineData(new byte[0], null)]
        [InlineData(null, new byte[0])]
        [InlineData(new byte[0], new byte[] { 0x00 })]
        [InlineData(new byte[] { 0x01, 0x02 }, new byte[] { 0x02, 0x01 })]
        public void AreByteArraysEqual_False(byte[] a, byte[] b)
        {
            // Act
            bool retVal = CryptoUtil.AreByteArraysEqual(a, b);

            // Assert
            Assert.NotEqual(a, b);
        }

        [Fact]
        public void AreByteArraysEqual_True()
        {
            // Arrange
            byte[] a = new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 };
            byte[] b = (byte[])a.Clone();

            // Act
            bool retVal = CryptoUtil.AreByteArraysEqual(a, b);

            // Assert
            Assert.Equal(a, b);
        }

        [Fact]
        public void TestVectors_Empty()
        {
            // Act
            byte[] retVal = CryptoUtil.ComputeSHA256(new string[0]);

            // Assert
            Assert.Equal("47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=", Convert.ToBase64String(retVal));
        }

        [Fact]
        public void TestVectors_NonEmpty()
        {
            // Act
            byte[] retVal = CryptoUtil.ComputeSHA256(new string[] { "a parameter", "another parameter" });

            // Assert
            Assert.Equal("Bez9yYh4Zq9jK1H5jD21wh04HTZi/vgxp6yDE7Y6cfo=", Convert.ToBase64String(retVal));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Helpers/UnvalidatedRequestValuesTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Web;
using Microsoft.TestCommon;
using Moq;

namespace Microsoft.WebPages.Test.Helpers
{
    public class UnvalidatedRequestValuesTest
    {
        [Fact]
        public void Constructor_SetsPropertiesCorrectly()
        {
            // Arrange
            NameValueCollection expectedForm = new NameValueCollection();
            NameValueCollection expectedQueryString = new NameValueCollection();

            Mock<System.Web.UnvalidatedRequestValuesBase> mockUnvalidatedRequestValue = new Mock<System.Web.UnvalidatedRequestValuesBase>();
            mockUnvalidatedRequestValue.SetupGet(u => u.Form).Returns(expectedForm);
            mockUnvalidatedRequestValue.SetupGet(u => u.QueryString).Returns(expectedQueryString);

            Mock<HttpRequestBase> mockRequest = new Mock<HttpRequestBase>();
            mockRequest.SetupGet(r => r.Unvalidated).Returns(mockUnvalidatedRequestValue.Object);

            // Act
#pragma warning disable 0618 // Obsolete System.Web.Helpers.UnvalidatedRequestValues
            System.Web.Helpers.UnvalidatedRequestValues unvalidatedValues = new System.Web.Helpers.UnvalidatedRequestValues(mockRequest.Object);
#pragma warning restore

            // Assert
            Assert.Same(expectedForm, unvalidatedValues.Form);
            Assert.Same(expectedQueryString, unvalidatedValues.QueryString);
        }

        [Fact]
        public void Indexer_LooksUpValuesInCorrectOrder()
        {
            // Order should be QueryString, Form, Cookies, ServerVariables

            // Arrange
            NameValueCollection queryString = new NameValueCollection()
            {
                { "foo", "fooQueryString" }
            };

            NameValueCollection form = new NameValueCollection()
            {
                { "foo", "fooInForm" },
                { "bar", "barInForm" },
            };

            HttpCookieCollection cookies = new HttpCookieCollection()
            {
                new HttpCookie("foo", "fooCookie"),
                new HttpCookie("bar", "barCookie"),
                new HttpCookie("baz", "bazCookie")
            };

            NameValueCollection serverVars = new NameValueCollection()
            {
                { "foo", "fooServerVars" },
                { "bar", "barServerVars" },
                { "baz", "bazServerVars" },
                { "quux", "quuxServerVars" },
            };

            Mock<HttpRequestBase> mockRequest = new Mock<HttpRequestBase>();
            mockRequest.SetupGet(r => r.ServerVariables).Returns(serverVars);
            mockRequest.SetupGet(r => r.Form).Returns(form);
            mockRequest.SetupGet(r => r.QueryString).Returns(queryString);
            mockRequest.SetupGet(r => r.Cookies).Returns(cookies);

            TestUnvalidatedRequestValues testUnvalidatedRequestValue = new TestUnvalidatedRequestValues(mockRequest.Object);

            mockRequest.SetupGet(r => r.Unvalidated).Returns(testUnvalidatedRequestValue);

#pragma warning disable 0618 // Obsolete System.Web.Helpers.UnvalidatedRequestValues
            System.Web.Helpers.UnvalidatedRequestValues unvalidatedValues = new System.Web.Helpers.UnvalidatedRequestValues(mockRequest.Object);
#pragma warning restore

            // Act
            string fooValue = unvalidatedValues["foo"];
            string barValue = unvalidatedValues["bar"];
            string bazValue = unvalidatedValues["baz"];
            string quuxValue = unvalidatedValues["quux"];
            string notFoundValue = unvalidatedValues["not-found"];

            // Assert
            Assert.Equal("fooQueryString", fooValue);
            Assert.Equal("barInForm", barValue);
            Assert.Equal("bazCookie", bazValue);
            Assert.Equal("quuxServerVars", quuxValue);
            Assert.Null(notFoundValue);
        }

        private sealed class TestUnvalidatedRequestValues : UnvalidatedRequestValuesBase
        {
            HttpRequestBase _request;
            NameValueCollection _queryString;
            NameValueCollection _form;

            public TestUnvalidatedRequestValues(HttpRequestBase request)
            {
                _request = request;
            }

            public override HttpCookieCollection Cookies
            {
                get
                {
                    // HttpCookieCollection copy constructor is not public, so just return it from the request.
                    return _request.Cookies;
                }
            }

            public override NameValueCollection QueryString
            {
                get
                {
                    if (_queryString == null)
                    {
                        _queryString = new NameValueCollection(_request.QueryString);
                    }

                    return _queryString;
                }
            }

            public override NameValueCollection Form
            {
                get
                {
                    if (_form == null)
                    {
                        _form = new NameValueCollection(_request.Form);
                    }

                    return _form;
                }
            }

            public override string this[string key]
            {
                // this item getter follows the same logic as UnvalidatedRequestValues.get_Item
                get
                {
                    string queryStringValue = QueryString[key];
                    if (queryStringValue != null)
                    {
                        return queryStringValue;
                    }

                    string formValue = Form[key];
                    if (formValue != null)
                    {
                        return formValue;
                    }

                    HttpCookie cookie = Cookies[key];
                    if (cookie != null)
                    {
                        return cookie.Value;
                    }

                    string serverVarValue = _request.ServerVariables[key];
                    if (serverVarValue != null)
                    {
                        return serverVarValue;
                    }

                    return null;
                }
            }
        }
    }
}

================================================
FILE: test/System.Web.WebPages.Test/Html/CheckBoxTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Html;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class CheckBoxTest : IDisposable
    {
        [Fact]
        public void CheckboxWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act and assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.CheckBox(null), "name");
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.CheckBox(String.Empty), "name");
        }

        [Fact]
        public void CheckboxWithDefaultArguments()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckboxWithObjectAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo", new { attr = "attr-value" });

            // Assert
            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckboxWithDictionaryAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo", new Dictionary<string, object> { { "attr", "attr-value" } });

            // Assert
            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckboxWithExplicitChecked()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo", true);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckboxWithModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", true);
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.CheckBox("foo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckboxWithNonBooleanModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", Boolean.TrueString);
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.CheckBox("foo");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());

            modelState.SetModelValue("foo", new object());
            helper = HtmlHelperFactory.Create(modelState);

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => helper.CheckBox("foo"),
                                                              "The parameter conversion from type \"System.Object\" to type \"System.Boolean\" failed because no " +
                                                              "type converter can convert between these types.");
        }

        [Fact]
        public void CheckboxWithModelAndExplictValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", false);
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.CheckBox("foo", true);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());

            modelState.SetModelValue("foo", true);

            // Act
            html = helper.CheckBox("foo", false);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithCheckedHtmlAttribute()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo", new { @checked = "checked" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithExplicitCheckedOverwritesHtmlAttribute()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo", false, new { @checked = "checked" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithModelStateCheckedOverwritesHtmlAttribute()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", false);
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo", false, new { @checked = "checked" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithError()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", false);
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.CheckBox("foo", true);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxWithErrorAndCustomCss()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.CheckBox("foo", true, new { @class = "my-class" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" class=""input-validation-error my-class"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxUsesCustomErrorClass()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "error");
            HtmlHelper.ValidationInputCssClassName = "my-error-class";
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.CheckBox("foo", true, new { @class = "my-class" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" class=""my-error-class my-class"" id=""foo"" name=""foo"" type=""checkbox"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckBoxOverwritesImplicitAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.CheckBox("foo", true, new { type = "fooType", name = "bar" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""fooType"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void CheckboxAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.CheckBox(fieldName, new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(@"<input data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" type=""checkbox"" />",
                         html.ToString());
        }

        [Fact]
        public void CheckboxWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.CheckBox("foo", attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.CheckBox("foo", true, attributes));
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. HtmlHelper.ValidationInputCssClassName) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/HtmlHelperFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.WebPages.Html;
using Moq;

namespace System.Web.WebPages.Test
{
    public static class HtmlHelperFactory
    {
        internal static HtmlHelper Create(ModelStateDictionary modelStateDictionary = null, ValidationHelper validationHelper = null)
        {
            modelStateDictionary = modelStateDictionary ?? new ModelStateDictionary();
            var httpContext = new Mock<HttpContextBase>();
            validationHelper = validationHelper ?? new ValidationHelper(httpContext.Object, modelStateDictionary);
            return new HtmlHelper(modelStateDictionary, validationHelper);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/HtmlHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Routing;
using System.Web.WebPages.Html;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class HtmlHelperTest
    {
        [Fact]
        public void ValidationInputCssClassNameThrowsWhenAssignedNull()
        {
            // Act and Assert
            Assert.ThrowsArgumentNull(() => HtmlHelper.ValidationInputCssClassName = null, "value");
        }

        [Fact]
        public void ValidationSummaryClassNameThrowsWhenAssignedNull()
        {
            // Act and Assert
            Assert.ThrowsArgumentNull(() => HtmlHelper.ValidationSummaryClass = null, "value");
        }

        [Fact]
        public void EncodeObject()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
            object text = "<br />" as object;

            // Act
            string encodedHtml = htmlHelper.Encode(text);

            // Assert
            Assert.Equal("&lt;br /&gt;", encodedHtml);
        }

        [Fact]
        public void EncodeObjectNull()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
            object text = null;

            // Act
            string encodedHtml = htmlHelper.Encode(text);

            // Assert
            Assert.Equal(String.Empty, encodedHtml);
        }

        [Fact]
        public void EncodeString()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
            var text = "<br />";

            // Act
            string encodedHtml = htmlHelper.Encode(text);

            // Assert
            Assert.Equal("&lt;br /&gt;", encodedHtml);
        }

        [Fact]
        public void EncodeStringNull()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
            string text = null;

            // Act
            string encodedHtml = htmlHelper.Encode(text);

            // Assert
            Assert.Equal("", encodedHtml);
        }

        [Fact]
        public void RawAllowsNullValue()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();

            // Act
            IHtmlString markupHtml = htmlHelper.Raw(null);

            // Assert
            Assert.Null(markupHtml.ToString());
            Assert.Null(markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawAllowsNullObjectValue()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();

            // Act
            IHtmlString markupHtml = htmlHelper.Raw((object)null);

            // Assert
            Assert.Null(markupHtml.ToString());
            Assert.Null(markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawAllowsEmptyValue()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();

            // Act
            IHtmlString markupHtml = htmlHelper.Raw("");

            // Assert
            Assert.Equal("", markupHtml.ToString());
            Assert.Equal("", markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawReturnsWrapperMarkup()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
            string markup = "<b>bold</b>";

            // Act
            IHtmlString markupHtml = htmlHelper.Raw(markup);

            // Assert
            Assert.Equal("<b>bold</b>", markupHtml.ToString());
            Assert.Equal("<b>bold</b>", markupHtml.ToHtmlString());
        }

        [Fact]
        public void RawReturnsWrapperMarkupOfObject()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();
            ObjectWithWrapperMarkup obj = new ObjectWithWrapperMarkup();

            // Act
            IHtmlString markupHtml = htmlHelper.Raw(obj);

            // Assert
            Assert.Equal("<b>boldFromObject</b>", markupHtml.ToString());
            Assert.Equal("<b>boldFromObject</b>", markupHtml.ToHtmlString());
        }

        [Fact]
        public void ConvertsUnderscoresInNamesToDashes()
        {
            // Arrange
            var attributes = GetAttributes();

            // Act
            RouteValueDictionary result = HtmlHelper.AnonymousObjectToHtmlAttributes(attributes);

            // Assert
            Assert.Equal(7, result.Count);
            Assert.Equal("Bar", result["foo"]);
            Assert.Equal("pow_wow", result["baz-bif"]);
        }

        [Fact]
        public void ObjectToDictionaryWithAnonymousTypeLooksUpProperties()
        {
            // Arrange
            object obj = new { _test = "value", oth_er = 1 };

            // Act
            IDictionary<string, object> dictValues = HtmlHelper.ObjectToDictionary(obj);

            // Assert
            Assert.NotNull(dictValues);
            Assert.Equal(2, dictValues.Count);
            Assert.Equal("value", dictValues["_test"]);
            Assert.Equal(1, dictValues["oth_er"]);
        }

        private static object GetAttributes()
        {
            return new { foo = "Bar",
                         baz_bif = "pow_wow",
                         other1 = "xx",
                         other2 = "yy",
                         other3 = "zz",
                         other4 = "aa",
                         other5 = "bb",
                       };
        }

        /// <summary>
        /// Will invoke a helper with overload that accepts custom attribute with a name containing
        /// and underscore as an anonymous object, and will then assert that the resulted html
        /// has the attribute name underscore correctly transformed to a dash
        /// </summary>
        /// <param name="helperInvocation"></param>
        internal static void AssertHelperTransformsAttributesUnderscoresToDashs(Func<HtmlHelper, object, IHtmlString> helperInvocation)
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();
            const string expected = @"data-name=""value""";
            const string unexpected = @"data_name=""value""";
            var attributes = new { data_name = "value" };

            // Act
            var htmlString = helperInvocation(helper, attributes).ToHtmlString();

            // Assert
            Assert.DoesNotContain(unexpected, htmlString);
            Assert.Contains(expected, htmlString);
        }

        private class ObjectWithWrapperMarkup
        {
            public override string ToString()
            {
                return "<b>boldFromObject</b>";
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/InputHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Data.Linq;
using System.Web.WebPages.Html;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class InputHelperTest
    {
        private static readonly IDictionary<string, object> _attributesDictionary = new Dictionary<string, object> { { "baz", "BazValue" } };
        private static readonly object _attributesObject = new { baz = "BazValue" };

        [Fact]
        public void HiddenWithBinaryArrayValueRendersBase64EncodedValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var result = helper.Hidden("ProductName", new Binary(new byte[] { 23, 43, 53 }));

            // Assert
            Assert.Equal("<input id=\"ProductName\" name=\"ProductName\" type=\"hidden\" value=\"Fys1\" />", result.ToHtmlString());
        }

        [Fact]
        public void HiddenWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.Hidden(String.Empty), "name");
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.Hidden(null), "name");
        }

        [Fact]
        public void HiddenWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Hidden("foo", "DefaultFoo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Hidden("foo", "DefaultFoo", new Dictionary<string, object> { { "attr", "attr-val" } });

            // Assert
            Assert.Equal(@"<input attr=""attr-val"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitValueAndObjectDictionary()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Hidden("foo", "DefaultFoo", new { attr = "attr-val" });

            // Assert
            Assert.Equal(@"<input attr=""attr-val"" id=""foo"" name=""foo"" type=""hidden"" value=""DefaultFoo"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitValueNull()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Hidden("foo", value: null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value="""" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithModelValue()
        {
            // Arrange
            var model = new ModelStateDictionary();
            model.SetModelValue("foo", "bar");
            HtmlHelper helper = HtmlHelperFactory.Create(model);

            // Act
            var html = helper.Hidden("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""bar"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithModelValueAndAttributesDictionary()
        {
            // Arrange
            var model = new ModelStateDictionary();
            model.SetModelValue("foo", "bar");
            HtmlHelper helper = HtmlHelperFactory.Create(model);

            // Act
            var html = helper.Hidden("foo", null, new Dictionary<string, object> { { "attr", "attr-val" } });

            // Assert
            Assert.Equal(@"<input attr=""attr-val"" id=""foo"" name=""foo"" type=""hidden"" value=""bar"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithImplicitValueAndAttributesObject()
        {
            // Arrange
            var model = new ModelStateDictionary();
            model.SetModelValue("foo", "bar");
            HtmlHelper helper = HtmlHelperFactory.Create(model);

            // Act
            var html = helper.Hidden("foo", null, new { attr = "attr-val" });

            // Assert
            Assert.Equal(@"<input attr=""attr-val"" id=""foo"" name=""foo"" type=""hidden"" value=""bar"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithNameAndValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Hidden("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithExplicitOverwritesAttributeValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Hidden("foo", "fooValue", new { value = "barValue" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenWithModelValueOverwritesAttributeValue()
        {
            // Arrange
            var model = new ModelStateDictionary();
            model.SetModelValue("foo", "fooValue");
            HtmlHelper helper = HtmlHelperFactory.Create(model);

            // Act
            var html = helper.Hidden("foo", null, new { value = "barValue" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""hidden"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void HiddenAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.Hidden(fieldName, value: null, htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(@"<input data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" type=""hidden"" value="""" />",
                         html.ToString());
        }

        // Password

        [Fact]
        public void PasswordWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.Password(String.Empty), "name");
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.Password(null), "name");
        }

        [Fact]
        public void PasswordDictionaryOverridesImplicitParameters()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", "Some Value", new { type = "fooType" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""fooType"" value=""Some Value"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordExplicitParametersOverrideDictionary()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", "Some Value", new { value = "Another Value", name = "bar" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" value=""Some Value"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", "DefaultFoo", (object)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", "DefaultFoo", new { baz = "BazValue" });

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""password"" value=""DefaultFoo"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", "DefaultFoo", new Dictionary<string, object> { { "baz", "BazValue" } });

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""password"" value=""DefaultFoo"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithExplicitValueNull()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", value: (string)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValueAndAttributesDictionaryReturnsEmptyValueIfNotFound()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("keyNotFound", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""keyNotFound"" name=""keyNotFound"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithImplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", null, _attributesObject);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""password"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithNameAndValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.Password("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""password"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void PasswordWithNullNameThrows()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.Password(null), "name");
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.Password(String.Empty), "name");
        }

        [Fact]
        public void PasswordAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.Password(fieldName, value: null, htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(@"<input data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" type=""password"" />",
                         html.ToString());
        }

        //Input 
        [Fact]
        public void TextBoxDictionaryOverridesImplicitValues()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextBox("foo", "DefaultFoo", new { type = "fooType" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""fooType"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxExplicitParametersOverrideDictionaryValues()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextBox("foo", "DefaultFoo", new { value = "Some other value" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithDotReplacementForId()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextBox("foo.bar.baz", null);

            // Assert
            Assert.Equal(@"<input id=""foo_bar_baz"" name=""foo.bar.baz"" type=""text"" value="""" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.TextBox(null), "name");
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.TextBox(String.Empty), "name");
        }

        [Fact]
        public void TextBoxWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextBox("foo", "DefaultFoo", (object)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithExplicitValueAndAttributesDictionary()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextBox("foo", "DefaultFoo", _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithExplicitValueAndAttributesObject()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextBox("foo", "DefaultFoo", _attributesObject);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""text"" value=""DefaultFoo"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithExplicitValueNull()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "fooModelValue");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextBox("foo", (string)null /* value */, (object)null);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""fooModelValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "fooModelValue");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextBox("foo");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""fooModelValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValueAndAttributesDictionary()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "fooModelValue");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextBox("foo", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""text"" value=""fooModelValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValueAndAttributesDictionaryReturnsEmptyValueIfNotFound()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "fooModelValue");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextBox("keyNotFound", null, _attributesDictionary);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""keyNotFound"" name=""keyNotFound"" type=""text"" value="""" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithImplicitValueAndAttributesObject()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "fooModelValue");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextBox("foo", null, _attributesObject);

            // Assert
            Assert.Equal(@"<input baz=""BazValue"" id=""foo"" name=""foo"" type=""text"" value=""fooModelValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxWithNameAndValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextBox("foo", "fooValue");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""text"" value=""fooValue"" />", html.ToHtmlString());
        }

        [Fact]
        public void TextBoxAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.TextBox(fieldName, value: null, htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(@"<input data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" type=""text"" value="""" />",
                         html.ToString());
        }

        [Fact]
        public void TextBoxWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.TextBox("foo", "value", attributes));
        }

        [Fact]
        public void HiddenTextBoxWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.Hidden("foo", "value", attributes));
        }

        [Fact]
        public void PasswordTextBoxWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.Password("foo", "value", attributes));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/LabelHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class LabelHelperTest
    {
        [Fact]
        public void LabelWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.Label("foo", attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.Label("foo", "bar", attributes));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/RadioButtonTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Html;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class RadioButtonTest
    {
        [Fact]
        public void RadioButtonWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act and assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.RadioButton(null, null), "name");
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.RadioButton(String.Empty, null), "name");
        }

        [Fact]
        public void RadioButtonWithDefaultArguments()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.RadioButton("foo", "bar", true);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());

            html = helper.RadioButton("foo", "bar", false);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithObjectAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.RadioButton("foo", "bar", new { attr = "attr-value" });

            // Assert
            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithDictionaryAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.RadioButton("foo", "bar", new Dictionary<string, object> { { "attr", "attr-value" } });

            // Assert
            Assert.Equal(@"<input attr=""attr-value"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonUsesModelStateToAssignChecked()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "bar");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.RadioButton("foo", "bar");

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonUsesModelStateToRemoveChecked()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "not-a-bar");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.RadioButton("foo", "bar", new { @checked = "checked" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithoutModelStateDoesNotAffectChecked()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.RadioButton("foo", "bar", new { @checked = "checked" });

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithNonStringModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", new List<double>());
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.RadioButton("foo", "bar");

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithNonStringValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "bar");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.RadioButton("foo", 2.53);

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""radio"" value=""2.53"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonWithExplicitChecked()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "bar");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.RadioButton("foo", "not-bar", true);

            // Assert
            Assert.Equal(@"<input checked=""checked"" id=""foo"" name=""foo"" type=""radio"" value=""not-bar"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonOverwritesImplicitAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.RadioButton("foo", "foo-value", new { value = "bazValue", type = "fooType", name = "bar" });

            // Assert
            Assert.Equal(@"<input id=""foo"" name=""foo"" type=""fooType"" value=""foo-value"" />",
                         html.ToHtmlString());
        }

        [Fact]
        public void RadioButtonAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.RadioButton(fieldName, value: 8, htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(@"<input data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" type=""radio"" value=""8"" />",
                         html.ToString());
        }

        [Fact]
        public void RadioButtonWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.RadioButton("foo", true, attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.RadioButton("foo", true, true, attributes));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/SelectHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using System.Web.WebPages.Html;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class SelectExtensionsTest
    {
        [Fact]
        public void DropDownListThrowsWithNoName()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act and assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.DropDownList(name: null, selectList: null), "name");
        }

        [Fact]
        public void DropDownListWithNoSelectedItem()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.DropDownList("foo", GetSelectList());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithDefaultOption()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.DropDownList("foo", "select-one", GetSelectList());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"\">select-one</option>" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.DropDownList("foo", GetSelectList(), new { attr = "attr-val", attr2 = "attr-val2" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" attr2=\"attr-val2\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.DropDownList("foo", null, GetSelectList(), "B", new Dictionary<string, object> { { "attr", "attr-val" } });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownWithModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "C");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.DropDownList("foo", GetSelectList(), new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownWithExplictAndModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "C");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.DropDownList("foo", null, GetSelectList(), "B", new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownWithNonStringModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", 23);
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.DropDownList("foo", null, GetSelectList(), new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownWithNonStringExplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.DropDownList("foo", null, GetSelectList(), new List<int>(), new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownWithErrors()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.DropDownList("foo", GetSelectList());

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithErrorsAndCustomClass()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.DropDownList("foo", GetSelectList(), new { @class = "my-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error my-class\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithEmptyOptionLabel()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.DropDownList("foo", GetSelectList(), new { @class = "my-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error my-class\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithObjectDictionaryAndTitle()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.DropDownList("foo", "Select One", GetSelectList(), new { @class = "my-class" });

            // Assert
            Assert.Equal(
                "<select class=\"my-class\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"\">Select One</option>" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownListWithDotReplacementForId()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.DropDownList("foo.bar", "Select One", GetSelectList());

            // Assert
            Assert.Equal(
                "<select id=\"foo_bar\" name=\"foo.bar\">" + Environment.NewLine
              + "<option value=\"\">Select One</option>" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void DropDownAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.DropDownList(fieldName, GetSelectList(), htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(
                "<select data-some-val=\"5\" data-val=\"true\" data-val-length=\"Name cannot exceed 30 characters\" data-val-length-max=\"30\" data-val-required=\"Please specify a valid Name.\" id=\"name\" name=\"name\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToString());
        }

        [Fact]
        public void DropDownWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.DropDownList("foo", GetSelectList(), attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.DropDownList("foo", "val", GetSelectList(), attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.DropDownList("foo", "val", GetSelectList(), "val", attributes));
        }

        // ListBox

        [Fact]
        public void ListBoxThrowsWithNoName()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act and assert
            Assert.ThrowsArgumentNullOrEmptyString(() => helper.ListBox(name: null, selectList: null), "name");
        }

        [Fact]
        public void ListBoxWithNoSelectedItem()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", GetSelectList());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithDefaultOption()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", "select-one", GetSelectList());

            // Assert
            Assert.Equal(
                "<select id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"\">select-one</option>" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", GetSelectList(), new { attr = "attr-val", attr2 = "attr-val2" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" attr2=\"attr-val2\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithExplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", null, GetSelectList(), "B", new Dictionary<string, object> { { "attr", "attr-val" } });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "C");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", GetSelectList(), new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithExplicitMultipleValuesAndNoMultiple()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", null, GetSelectList(), new[] { "B", "C" }, new Dictionary<string, object> { { "attr", "attr-val" } });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithExplicitMultipleValuesAndMultiple()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", null, GetSelectList(), new[] { "B", "C" }, 4, true);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\" size=\"4\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithMultipleModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", new[] { "A", "C" });
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", GetSelectList(), new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithModelValueAndExplicitSelectItem()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", new[] { "C", "D" });
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
            var selectList = GetSelectList().ToList();
            selectList[1].Selected = true;

            // Act
            var html = helper.ListBox("foo", selectList, new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithMultiSelectAndMultipleModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", new[] { "A", "C" });
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", GetSelectList(), null, 4, true);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\" size=\"4\">" + Environment.NewLine
              + "<option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithMultiSelectAndMultipleExplicitValues()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", GetSelectList(), new[] { "A", "C" }, 4, true);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\" size=\"4\">" + Environment.NewLine
              + "<option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithMultiSelectAndExplitSelectValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();
            var selectList = GetSelectList().ToList();
            selectList.First().Selected = selectList.Last().Selected = true;

            // Act
            var html = helper.ListBox("foo", selectList, new[] { "B" }, 4, true);

            // Assert
            Assert.Equal(
                "<select id=\"foo\" multiple=\"multiple\" name=\"foo\" size=\"4\">" + Environment.NewLine
              + "<option selected=\"selected\" value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithExplictAndModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "C");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", defaultOption: null, selectList: GetSelectList(),
                                      selectedValues: "B", htmlAttributes: new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option selected=\"selected\" value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithErrorAndExplictAndModelState()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "C");
            modelState.AddError("foo", "test");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo.bar", "Select One", GetSelectList());

            // Assert
            Assert.Equal(
                "<select id=\"foo_bar\" name=\"foo.bar\">" + Environment.NewLine
              + "<option value=\"\">Select One</option>" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithNonStringModelValue()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", 23);
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", null, GetSelectList(), new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithNonStringExplicitValue()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", null, GetSelectList(), new List<int>(), new { attr = "attr-val" });

            // Assert
            Assert.Equal(
                "<select attr=\"attr-val\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithErrors()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", GetSelectList());

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithErrorsAndCustomClass()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", GetSelectList(), new { @class = "my-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error my-class\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithEmptyOptionLabel()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.ListBox("foo", GetSelectList(), new { @class = "my-class" });

            // Assert
            Assert.Equal(
                "<select class=\"input-validation-error my-class\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithObjectDictionaryAndTitle()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo", "Select One", GetSelectList(), new { @class = "my-class" });

            // Assert
            Assert.Equal(
                "<select class=\"my-class\" id=\"foo\" name=\"foo\">" + Environment.NewLine
              + "<option value=\"\">Select One</option>" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxWithDotReplacementForId()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.ListBox("foo.bar", "Select One", GetSelectList());

            // Assert
            Assert.Equal(
                "<select id=\"foo_bar\" name=\"foo.bar\">" + Environment.NewLine
              + "<option value=\"\">Select One</option>" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToHtmlString());
        }

        [Fact]
        public void ListBoxAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.ListBox(fieldName, GetSelectList(), htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(
                "<select data-some-val=\"5\" data-val=\"true\" data-val-length=\"Name cannot exceed 30 characters\" data-val-length-max=\"30\" data-val-required=\"Please specify a valid Name.\" id=\"name\" name=\"name\">" + Environment.NewLine
              + "<option value=\"A\">Alpha</option>" + Environment.NewLine
              + "<option value=\"B\">Bravo</option>" + Environment.NewLine
              + "<option value=\"C\">Charlie</option>" + Environment.NewLine
              + "</select>",
                html.ToString());
        }

        [Fact]
        public void ListBoxWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.ListBox("foo", GetSelectList(), attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.ListBox("foo", "val", GetSelectList(), "val", attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.ListBox("foo", "val", GetSelectList(), "val", attributes));
        }

        private static IEnumerable<SelectListItem> GetSelectList()
        {
            yield return new SelectListItem() { Text = "Alpha", Value = "A" };
            yield return new SelectListItem() { Text = "Bravo", Value = "B" };
            yield return new SelectListItem() { Text = "Charlie", Value = "C" };
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/TextAreaHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Html;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class TextAreaExtensionsTest : IDisposable
    {
        [Fact]
        public void TextAreaWithEmptyNameThrows()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act and assert
            Assert.ThrowsArgument(() => helper.TextArea(null), "name", "Value cannot be null or an empty string.");

            // Act and assert
            Assert.ThrowsArgument(() => helper.TextArea(String.Empty), "name", "Value cannot be null or an empty string.");
        }

        [Fact]
        public void TextAreaWithDefaultRowsAndCols()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextArea("foo");

            // Assert
            Assert.Equal(@"<textarea cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>", html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithZeroRowsAndColumns()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextArea("foo", null, 0, 0, null);

            // Assert
            Assert.Equal(@"<textarea id=""foo"" name=""foo""></textarea>", html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithNonZeroRowsAndColumns()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();

            // Act
            var html = helper.TextArea("foo", null, 4, 10, null);

            // Assert
            Assert.Equal(@"<textarea cols=""10"" id=""foo"" name=""foo"" rows=""4""></textarea>", html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithObjectAttributes()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "foo-value");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextArea("foo", new { attr = "value", cols = 6 });

            // Assert
            Assert.Equal(@"<textarea attr=""value"" cols=""6"" id=""foo"" name=""foo"" rows=""2"">foo-value</textarea>", html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithExplicitValue()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "explicit-foo-value");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextArea("foo", "explicit-foo-value", new { attr = "attr-value", cols = 6 });

            // Assert
            Assert.Equal(@"<textarea attr=""attr-value"" cols=""6"" id=""foo"" name=""foo"" rows=""2"">explicit-foo-value</textarea>",
                         html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithDictionaryAttributes()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "explicit-foo-value");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
            var attributes = new Dictionary<string, object>() { { "attr", "attr-val" }, { "rows", 15 }, { "cols", 12 } };
            // Act
            var html = helper.TextArea("foo", attributes);

            // Assert
            Assert.Equal(@"<textarea attr=""attr-val"" cols=""12"" id=""foo"" name=""foo"" rows=""15"">explicit-foo-value</textarea>",
                         html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithNoValueAndObjectAttributes()
        {
            // Arrange
            HtmlHelper helper = HtmlHelperFactory.Create();
            var attributes = new Dictionary<string, object>() { { "attr", "attr-val" }, { "rows", 15 }, { "cols", 12 } };
            // Act
            var html = helper.TextArea("foo", attributes);

            // Assert
            Assert.Equal(@"<textarea attr=""attr-val"" cols=""12"" id=""foo"" name=""foo"" rows=""15""></textarea>",
                         html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithNullValue()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.SetModelValue("foo", "explicit-foo-value");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);
            var attributes = new Dictionary<string, object>() { { "attr", "attr-val" }, { "rows", 15 }, { "cols", 12 } };
            // Act
            var html = helper.TextArea("foo", null, attributes);

            // Assert
            Assert.Equal(@"<textarea attr=""attr-val"" cols=""12"" id=""foo"" name=""foo"" rows=""15"">explicit-foo-value</textarea>",
                         html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithError()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextArea("foo", String.Empty);

            // Assert
            Assert.Equal(@"<textarea class=""input-validation-error"" cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>",
                         html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithErrorAndCustomCssClass()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextArea("foo", String.Empty, new { @class = "my-css" });

            // Assert
            Assert.Equal(@"<textarea class=""input-validation-error my-css"" cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>",
                         html.ToHtmlString());
        }

        [Fact]
        public void TextAreaWithCustomErrorClass()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddError("foo", "some error");
            HtmlHelper.ValidationInputCssClassName = "custom-input-validation-error";
            HtmlHelper helper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = helper.TextArea("foo", String.Empty, new { @class = "my-css" });

            // Assert
            Assert.Equal(@"<textarea class=""custom-input-validation-error my-css"" cols=""20"" id=""foo"" name=""foo"" rows=""2""></textarea>",
                         html.ToHtmlString());
        }

        [Fact]
        public void TextAreaAddsUnobtrusiveValidationAttributes()
        {
            // Arrange
            const string fieldName = "name";
            var modelStateDictionary = new ModelStateDictionary();
            var validationHelper = new ValidationHelper(new Mock<HttpContextBase>().Object, modelStateDictionary);
            HtmlHelper helper = HtmlHelperFactory.Create(modelStateDictionary, validationHelper);

            // Act
            validationHelper.RequireField(fieldName, "Please specify a valid Name.");
            validationHelper.Add(fieldName, Validator.StringLength(30, errorMessage: "Name cannot exceed {0} characters"));
            var html = helper.TextArea(fieldName, htmlAttributes: new Dictionary<string, object> { { "data-some-val", "5" } });

            // Assert
            Assert.Equal(@"<textarea cols=""20"" data-some-val=""5"" data-val=""true"" data-val-length=""Name cannot exceed 30 characters"" data-val-length-max=""30"" data-val-required=""Please specify a valid Name."" id=""name"" name=""name"" rows=""2""></textarea>",
                         html.ToString());
        }

        [Fact]
        public void TextAreaWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.TextArea("foo", attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.TextArea("foo", "value", attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.TextArea("foo", "value", 1, 1, attributes));
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. HtmlHelper.ValidationInputCssClassName) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Html/ValidationHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Html;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ValidationHelperTest : IDisposable
    {
        [Fact]
        public void ValidationMessageAllowsEmptyModelName()
        {
            // Arrange
            ModelStateDictionary dictionary = new ModelStateDictionary();
            dictionary.AddError("test", "some error text");
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(dictionary);

            // Act
            var html = htmlHelper.ValidationMessage("test");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\" data-valmsg-for=\"test\" data-valmsg-replace=\"true\">some error text</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsFirstError()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationMessage("foo");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\" data-valmsg-for=\"foo\" data-valmsg-replace=\"true\">foo error &lt;1&gt;</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageUsesValidCssClassIfFieldDoesNotHaveErrors()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationMessage("baz");

            // Assert
            Assert.Equal("<span class=\"field-validation-valid\" data-valmsg-for=\"baz\" data-valmsg-replace=\"true\"></span>", html.ToString());
        }

        [Fact]
        public void ValidationMessageReturnsWithObjectAttributes()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationMessage("foo", new { attr = "attr-value" });

            // Assert
            Assert.Equal("<span attr=\"attr-value\" class=\"field-validation-error\" data-valmsg-for=\"foo\" data-valmsg-replace=\"true\">foo error &lt;1&gt;</span>",
                         html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsWithCustomMessage()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Atc
            var html = htmlHelper.ValidationMessage("foo", "bar error");

            // Assert
            Assert.Equal("<span class=\"field-validation-error\" data-valmsg-for=\"foo\" data-valmsg-replace=\"false\">bar error</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageReturnsWithCustomMessageAndObjectAttributes()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationMessage("foo", "bar error", new { baz = "baz" });

            // Assert
            Assert.Equal("<span baz=\"baz\" class=\"field-validation-error\" data-valmsg-for=\"foo\" data-valmsg-replace=\"false\">bar error</span>", html.ToHtmlString());
        }

        [Fact]
        public void ValidationMessageWithModelStateAndNoErrors()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationMessage("baz");

            // Assert
            Assert.Equal("<span class=\"field-validation-valid\" data-valmsg-for=\"baz\" data-valmsg-replace=\"true\"></span>", html.ToString());
        }

        [Fact]
        public void ValidationMessageWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.ValidationMessage("foo", attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                helper.ValidationMessage("foo", "bar", attributes));
        }

        [Fact]
        public void ValidationSummary()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\" data-valmsg-summary=\"true\"><ul>" + Environment.NewLine
              + "<li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithMessage()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationSummary("test message");

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\" data-valmsg-summary=\"true\"><span>test message</span>" + Environment.NewLine
              + "<ul>" + Environment.NewLine
              + "<li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithFormErrors()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithFormErrors());

            // Act
            var html = htmlHelper.ValidationSummary();

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\" data-valmsg-summary=\"true\"><ul>" + Environment.NewLine
              + "<li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>some form error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>some form error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithFormErrorsAndExcludeFieldErrors()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithFormErrors());

            // Act
            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><ul>" + Environment.NewLine
              + "<li>some form error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>some form error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithObjectProperties()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationSummary(new { attr = "attr-value", @class = "my-class" });

            // Assert
            Assert.Equal(
                "<div attr=\"attr-value\" class=\"validation-summary-errors my-class\" data-valmsg-summary=\"true\"><ul>" + Environment.NewLine
              + "<li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithDictionary()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationSummary(new Dictionary<string, object> { { "attr", "attr-value" }, { "class", "my-class" } });

            // Assert
            Assert.Equal(
                "<div attr=\"attr-value\" class=\"validation-summary-errors my-class\" data-valmsg-summary=\"true\"><ul>" + Environment.NewLine
              + "<li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithDictionaryAndMessage()
        {
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationSummary("This is a message.", new Dictionary<string, object> { { "attr", "attr-value" }, { "class", "my-class" } });

            // Assert
            Assert.Equal(
                "<div attr=\"attr-value\" class=\"validation-summary-errors my-class\" data-valmsg-summary=\"true\"><span>This is a message.</span>" + Environment.NewLine
              + "<ul>" + Environment.NewLine
              + "<li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithCustomValidationSummaryClass()
        {
            // Arrange
            HtmlHelper.ValidationSummaryClass = "my-val-class";
            HtmlHelper htmlHelper = HtmlHelperFactory.Create(GetModelStateWithErrors());

            // Act
            var html = htmlHelper.ValidationSummary("This is a message.", new Dictionary<string, object> { { "attr", "attr-value" }, { "class", "my-class" } });

            // Assert
            Assert.Equal(
                "<div attr=\"attr-value\" class=\"my-val-class my-class\" data-valmsg-summary=\"true\"><span>This is a message.</span>" + Environment.NewLine
              + "<ul>" + Environment.NewLine
              + "<li>foo error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>foo error &lt;2&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>bar error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithNoErrorReturnsNullIfExcludeFieldErrorsIsSetToFalse()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();

            // Act
            var html = htmlHelper.ValidationSummary(excludeFieldErrors: false);

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-valid\" data-valmsg-summary=\"true\"><ul>" + Environment.NewLine
              + "</ul></div>",
                html.ToString());
        }

        [Fact]
        public void ValidationSummaryWithNoErrorReturnsNull()
        {
            // Arrange
            HtmlHelper htmlHelper = HtmlHelperFactory.Create();

            // Act
            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);

            // Assert
            Assert.Null(html);
        }

        [Fact]
        public void ValidationSummaryWithNoFormErrorsAndExcludedFieldErrorsReturnsNull()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddError("foo", "error");
            modelState.AddError("bar", "error");

            HtmlHelper htmlHelper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);

            // Assert
            Assert.Null(html);
        }

        [Fact]
        public void ValidationSummaryWithMultipleFormErrorsAndExcludedFieldErrors()
        {
            // Arrange
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddFormError("error <1>");
            modelState.AddFormError("error <2>");

            HtmlHelper htmlHelper = HtmlHelperFactory.Create(modelState);

            // Act
            var html = htmlHelper.ValidationSummary(excludeFieldErrors: true);

            // Assert
            Assert.Equal(
                "<div class=\"validation-summary-errors\"><ul>" + Environment.NewLine
              + "<li>error &lt;1&gt;</li>" + Environment.NewLine
              + "<li>error &lt;2&gt;</li>" + Environment.NewLine
              + "</ul></div>",
                html.ToHtmlString());
        }

        [Fact]
        public void ValidationSummaryWithAttributesFromAnonymousObject_WithUnderscoreInName_TransformsUnderscoresToDashs()
        {
            // Arrange
            var modelState = new ModelStateDictionary();
            modelState.AddFormError("error");

            HtmlHelper htmlHelper = HtmlHelperFactory.Create(modelState);

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                htmlHelper.ValidationSummary(attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                htmlHelper.ValidationSummary("foo", attributes));

            HtmlHelperTest.AssertHelperTransformsAttributesUnderscoresToDashs((helper, attributes) =>
                htmlHelper.ValidationSummary("foo", true, attributes));
        }

        private static ModelStateDictionary GetModelStateWithErrors()
        {
            ModelStateDictionary modelState = new ModelStateDictionary();
            modelState.AddError("foo", "foo error <1>");
            modelState.AddError("foo", "foo error <2>");
            modelState.AddError("bar", "bar error <1>");
            modelState.AddError("bar", "bar error <2>");
            return modelState;
        }

        private static ModelStateDictionary GetModelStateWithFormErrors()
        {
            ModelStateDictionary modelState = GetModelStateWithErrors();
            modelState.AddFormError("some form error <1>");
            modelState.AddFormError("some form error <2>");
            return modelState;
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. HtmlHelper.ValidationSummaryClass) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Instrumentation/InstrumentationServiceTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Dynamic;
using System.IO;
using System.Web.WebPages.Instrumentation;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test.Instrumentation
{
    public class InstrumentationServiceTest
    {
        [Fact]
        public void BeginContextDelegatesToRegisteredListeners()
        {
            // Arrange
            dynamic listener1 = CreateListener();
            dynamic listener2 = CreateListener();
            InstrumentationService inst = CreateInstrumentationService(listener1, listener2);
            TextWriter mockWriter = new StringWriter();

            // Act
            inst.BeginContext(null, "Foo.cshtml", mockWriter, 42, 24, isLiteral: false);

            // Assert
            Assert.Equal(1, listener1.BeginContextCalls.Count);
            Assert.Equal(0, listener1.EndContextCalls.Count);
            Assert.Equal(1, listener2.BeginContextCalls.Count);
            Assert.Equal(0, listener2.EndContextCalls.Count);

            AssertContext("Foo.cshtml", mockWriter, 42, 24, false, listener1.BeginContextCalls[0]);
            AssertContext("Foo.cshtml", mockWriter, 42, 24, false, listener2.BeginContextCalls[0]);
        }

        [Fact]
        public void EndContextDelegatesToRegisteredListeners()
        {
            // Arrange
            dynamic listener1 = CreateListener();
            dynamic listener2 = CreateListener();
            InstrumentationService inst = CreateInstrumentationService(listener1, listener2);
            TextWriter mockWriter = new StringWriter();

            // Act
            inst.EndContext(null, "Foo.cshtml", mockWriter, 42, 24, isLiteral: false);

            // Assert
            Assert.Equal(1, listener1.EndContextCalls.Count);
            Assert.Equal(0, listener1.BeginContextCalls.Count);
            Assert.Equal(1, listener2.EndContextCalls.Count);
            Assert.Equal(0, listener2.BeginContextCalls.Count);

            AssertContext("Foo.cshtml", mockWriter, 42, 24, false, listener1.EndContextCalls[0]);
            AssertContext("Foo.cshtml", mockWriter, 42, 24, false, listener2.EndContextCalls[0]);
        }

        private void AssertContext(string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral, dynamic context)
        {
            PageExecutionContextAdapter ctx = new PageExecutionContextAdapter(context);
            Assert.Equal(virtualPath, ctx.VirtualPath);
            Assert.Same(writer, ctx.TextWriter);
            Assert.Equal(startPosition, ctx.StartPosition);
            Assert.Equal(length, ctx.Length);
            Assert.Equal(isLiteral, ctx.IsLiteral);
        }

        private InstrumentationService CreateInstrumentationService(params dynamic[] listeners)
        {
            dynamic service = new ExpandoObject();
            service.ExecutionListeners = new List<dynamic>(listeners);
            InstrumentationService inst = new InstrumentationService();
            inst.IsAvailable = true;
            inst.ExtractInstrumentationService = _ => new PageInstrumentationServiceAdapter(service);
            inst.CreateContext = CreateExpandoContext;
            return inst;
        }

        private dynamic CreateListener()
        {
            dynamic listener = new ExpandoObject();
            listener.BeginContextCalls = new List<dynamic>();
            listener.EndContextCalls = new List<dynamic>();
            listener.BeginContext = (Action<dynamic>)(d => { listener.BeginContextCalls.Add(d); });
            listener.EndContext = (Action<dynamic>)(d => { listener.EndContextCalls.Add(d); });
            return listener;
        }

        private PageExecutionContextAdapter CreateExpandoContext(string virtualPath, TextWriter writer, int startPosition, int length, bool isLiteral)
        {
            dynamic ctx = new ExpandoObject();
            ctx.VirtualPath = virtualPath;
            ctx.TextWriter = writer;
            ctx.StartPosition = startPosition;
            ctx.Length = length;
            ctx.IsLiteral = isLiteral;
            return new PageExecutionContextAdapter(ctx);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/LatestRazorVersion.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Razor;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public static class LatestRazorVersion
    {
        private static readonly Version LatestVersion = VersionTestHelper.GetVersionFromAssembly("System.Web.Razor", typeof(ParserResults));

        public static readonly string MajorMinor = LatestVersion.Major + "." + LatestVersion.Minor;
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Mvc/HttpAntiForgeryExceptionTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class HttpAntiForgeryExceptionTest
    {
        [Fact]
        public void ConstructorWithMessageAndInnerExceptionParameter()
        {
            // Arrange
            Exception innerException = new Exception();

            // Act
            HttpAntiForgeryException ex = new HttpAntiForgeryException("the message", innerException);

            // Assert
            Assert.Equal("the message", ex.Message);
            Assert.Equal(innerException, ex.InnerException);
        }

        [Fact]
        public void ConstructorWithMessageParameter()
        {
            // Act
            HttpAntiForgeryException ex = new HttpAntiForgeryException("the message");

            // Assert
            Assert.Equal("the message", ex.Message);
        }

        [Fact]
        public void ConstructorWithoutParameters()
        {
            // Act & assert
            Assert.Throws<HttpAntiForgeryException>(
                delegate { throw new HttpAntiForgeryException(); });
        }

        [Fact]
        public void TypeIsSerializable()
        {
            // If this ever fails with SerializationException : Unable to find assembly 'System.Web.Mvc, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35'
            // (usually when the assembly version is incremented) you need to modify the App.config file in this test project to reference the new version.

            // Arrange
            MemoryStream ms = new MemoryStream();
            BinaryFormatter formatter = new BinaryFormatter();
            HttpAntiForgeryException ex = new HttpAntiForgeryException("the message", new Exception("inner exception"));

            // Act
            formatter.Serialize(ms, ex);
            ms.Position = 0;
            HttpAntiForgeryException deserialized = formatter.Deserialize(ms) as HttpAntiForgeryException;

            // Assert
            Assert.NotNull(deserialized);
            Assert.Equal("the message", deserialized.Message);
            Assert.NotNull(deserialized.InnerException);
            Assert.Equal("inner exception", deserialized.InnerException.Message);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Mvc/ModelClientValidationMaxLengthRuleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelClientValidationMaxLengthRuleTest
    {
        [Fact]
        public void ModelClientValidationMaxLengthRuleTestAddsMaxLengthParameter()
        {
            // Arrange
            var clientValidationRule = new ModelClientValidationMaxLengthRule("Max length error message", 8);

            // Assert
            Assert.Equal(1, clientValidationRule.ValidationParameters.Count);
            Assert.Equal(8, clientValidationRule.ValidationParameters["max"]);
            Assert.Equal("Max length error message", clientValidationRule.ErrorMessage);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Mvc/ModelClientValidationMembershipPasswordRuleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelClientValidationMembershipPasswordRuleTest
    {
        [Fact]
        public void Constructor()
        {
            // Arrange & Act
            var rule = new ModelClientValidationMembershipPasswordRule("ErrorMessage", 10, 5, "regex-value");

            // Assert
            Assert.Equal("password", rule.ValidationType);
            Assert.Equal("ErrorMessage", rule.ErrorMessage);
            Assert.Equal(10, rule.ValidationParameters["min"]);
            Assert.Equal(5, rule.ValidationParameters["nonalphamin"]);
            Assert.Equal("regex-value", rule.ValidationParameters["regex"]);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Mvc/ModelClientValidationMinLengthRuleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelClientValidationMinLengthRuleTest
    {
        [Fact]
        public void ModelClientValidationMinLengthRuleTestAddsMinLengthParameter()
        {
            // Arrange
            var clientValidationRule = new ModelClientValidationMinLengthRule("Min Length message", 2);

            // Assert
            Assert.Equal(1, clientValidationRule.ValidationParameters.Count);
            Assert.Equal(2, clientValidationRule.ValidationParameters["min"]);
            Assert.Equal("Min Length message", clientValidationRule.ErrorMessage);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Mvc/ModelClientValidationStringLengthRuleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class ModelClientValidationStringLengthRuleTest
    {
        [Fact]
        public void ModelClientValidationStringLengthRuleTestDoesNotAddMinLengthParameterIfSpecifiedValueIs0()
        {
            // Arrange
            var clientValidationRule = new ModelClientValidationStringLengthRule("Test message", 0, 10);

            // Assert
            Assert.Equal(1, clientValidationRule.ValidationParameters.Count);
            Assert.Equal(10, clientValidationRule.ValidationParameters["max"]);
        }

        [Fact]
        public void ModelClientValidationStringLengthRuleTestDoesNotAddMaxLengthIfSpecifiedValueIsMaxValue()
        {
            // Arrange
            var clientValidationRule = new ModelClientValidationStringLengthRule("Test message", 3, Int32.MaxValue);

            // Assert
            Assert.Equal(1, clientValidationRule.ValidationParameters.Count);
            Assert.Equal(3, clientValidationRule.ValidationParameters["min"]);
        }

        [Fact]
        public void ModelClientValidationStringLengthRuleTestAddsMinLengthParameter()
        {
            // Arrange
            string message = "Password must contain only letters and must be between 3-8 characters long";
            var clientValidationRule = new ModelClientValidationStringLengthRule(message, 3, 8);

            // Assert
            Assert.Equal(2, clientValidationRule.ValidationParameters.Count);
            Assert.Equal(message, clientValidationRule.ErrorMessage);
            Assert.Equal(3, clientValidationRule.ValidationParameters["min"]);
            Assert.Equal(8, clientValidationRule.ValidationParameters["max"]);
        }

    }
}


================================================
FILE: test/System.Web.WebPages.Test/Mvc/TagBuilderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Html;
using Microsoft.TestCommon;

namespace System.Web.Mvc.Test
{
    public class TagBuilderTest
    {
        [Fact]
        public void AddCssClassPrepends()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");
            builder.MergeAttribute("class", "oldA");

            // Act
            builder.AddCssClass("newA");

            // Assert
            Assert.Equal("newA oldA", builder.Attributes["class"]);
        }

        [Fact]
        public void AttributesProperty()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");

            // Act
            SortedDictionary<string, string> attributes = builder.Attributes as SortedDictionary<string, string>;

            // Assert
            Assert.NotNull(attributes);
            Assert.Equal(StringComparer.Ordinal, attributes.Comparer);
        }

        [Fact]
        public void ConstructorSetsTagNameProperty()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");

            // Act
            string tagName = builder.TagName;

            // Assert
            Assert.Equal("SomeTag", tagName);
        }

        [Fact]
        public void ConstructorWithEmptyTagNameThrows()
        {
            Assert.ThrowsArgumentNullOrEmptyString(
                delegate { new TagBuilder(String.Empty); }, "tagName");
        }

        [Fact]
        public void ConstructorWithNullTagNameThrows()
        {
            Assert.ThrowsArgumentNullOrEmptyString(
                delegate { new TagBuilder(null /* tagName */); }, "tagName");
        }

        [Fact]
        public void CreateSanitizedIdThrowsIfInvalidCharReplacementIsNull()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(
                () => TagBuilder.CreateSanitizedId("tagId", null),
                "invalidCharReplacement");
        }

        [Fact]
        public void CreateSanitizedIdDefaultsToHtmlHelperIdAttributeDotReplacement()
        {
            // Arrange
            String defaultReplacementChar = HtmlHelper.IdAttributeDotReplacement;

            // Act
            string sanitizedId = TagBuilder.CreateSanitizedId("Hello world");

            // Assert
            Assert.Equal("Hello" + defaultReplacementChar + "world", sanitizedId);
        }

        [Fact]
        public void CreateSanitizedId_ReturnsNullIfOriginalIdBeginsWithNonLetter()
        {
            // Act
            string retVal = TagBuilder.CreateSanitizedId("_DoesNotBeginWithALetter", "!REPL!");

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void CreateSanitizedId_ReturnsNullIfOriginalIdIsEmpty()
        {
            // Act
            string retVal = TagBuilder.CreateSanitizedId("", "!REPL!");

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void CreateSanitizedId_ReturnsNullIfOriginalIdIsNull()
        {
            // Act
            string retVal = TagBuilder.CreateSanitizedId(null, "!REPL!");

            // Assert
            Assert.Null(retVal);
        }

        [Fact]
        public void CreateSanitizedId_ReturnsSanitizedId()
        {
            // Arrange
            string expected = "ABCXYZabcxyz012789!REPL!!REPL!!REPL!!REPL!!REPL!!REPL!!REPL!!REPL!!REPL!!REPL!-!REPL!_!REPL!!REPL!:";

            // Act
            string retVal = TagBuilder.CreateSanitizedId("ABCXYZabcxyz012789!@#$%^&*()-=_+.:", "!REPL!");

            // Assert
            Assert.Equal(expected, retVal);
        }

        [Fact]
        public void GenerateId_AddsSanitizedId()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("div");
            builder.IdAttributeDotReplacement = "x";

            // Act
            builder.GenerateId("Hello, world.");

            // Assert
            Assert.Equal("Helloxxworldx", builder.Attributes["id"]);
        }

        [Fact]
        public void GenerateId_DoesNotAddIdIfIdAlreadyExists()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("div");
            builder.GenerateId("old");

            // Act
            builder.GenerateId("new");

            // Assert
            Assert.Equal("old", builder.Attributes["id"]);
        }

        [Fact]
        public void GenerateId_DoesNotAddIdIfSanitizationReturnsNull()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("div");

            // Act
            builder.GenerateId("");

            // Assert
            Assert.False(builder.Attributes.ContainsKey("id"));
        }

        [Fact]
        public void InnerHtmlProperty()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");

            // Act & Assert
            Assert.Equal(String.Empty, builder.InnerHtml);
            builder.InnerHtml = "foo";
            Assert.Equal("foo", builder.InnerHtml);
            builder.InnerHtml = null;
            Assert.Equal(String.Empty, builder.InnerHtml);
        }

        [Fact]
        public void MergeAttributeDoesNotOverwriteExistingValuesByDefault()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");
            builder.MergeAttribute("a", "oldA");

            // Act
            builder.MergeAttribute("a", "newA");

            // Assert
            Assert.Equal("oldA", builder.Attributes["a"]);
        }

        [Fact]
        public void MergeAttributeOverwritesExistingValueIfAsked()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");
            builder.MergeAttribute("a", "oldA");

            // Act
            builder.MergeAttribute("a", "newA", true);

            // Assert
            Assert.Equal("newA", builder.Attributes["a"]);
        }

        [Fact]
        public void MergeAttributeWithEmptyKeyThrows()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmptyString(
                delegate { builder.MergeAttribute(String.Empty, "value"); }, "key");
        }

        [Fact]
        public void MergeAttributeWithNullKeyThrows()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");

            // Act & Assert
            Assert.ThrowsArgumentNullOrEmptyString(
                delegate { builder.MergeAttribute(null, "value"); }, "key");
        }

        [Fact]
        public void MergeAttributesDoesNotOverwriteExistingValuesByDefault()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");
            builder.Attributes["a"] = "oldA";

            Dictionary<string, string> newAttrs = new Dictionary<string, string>
            {
                { "a", "newA" },
                { "b", "newB" }
            };

            // Act
            builder.MergeAttributes(newAttrs);

            // Assert
            Assert.Equal(2, builder.Attributes.Count);
            Assert.Equal("oldA", builder.Attributes["a"]);
            Assert.Equal("newB", builder.Attributes["b"]);
        }

        [Fact]
        public void MergeAttributesOverwritesExistingValueIfAsked()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");
            builder.Attributes["a"] = "oldA";

            Dictionary<string, string> newAttrs = new Dictionary<string, string>
            {
                { "a", "newA" },
                { "b", "newB" }
            };

            // Act
            builder.MergeAttributes(newAttrs, true);

            // Assert
            Assert.Equal(2, builder.Attributes.Count);
            Assert.Equal("newA", builder.Attributes["a"]);
            Assert.Equal("newB", builder.Attributes["b"]);
        }

        [Fact]
        public void MergeAttributesWithNullAttributesDoesNothing()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");

            // Act
            builder.MergeAttributes<string, string>(null);

            // Assert
            Assert.Equal(0, builder.Attributes.Count);
        }

        [Fact]
        public void SetInnerTextEncodes()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");

            // Act
            builder.SetInnerText("<>");

            // Assert
            Assert.Equal("&lt;&gt;", builder.InnerHtml);
        }

        [Fact]
        public void ToStringDefaultsToNormal()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag")
            {
                InnerHtml = "<x&y>"
            };
            builder.MergeAttributes(GetAttributesDictionary());

            // Act
            string output = builder.ToString();

            // Assert
            Assert.Equal(@"<SomeTag a=""Foo"" b=""Bar&amp;Baz"" c=""&lt;&quot;Quux&quot;>""><x&y></SomeTag>", output);
        }

        [Fact]
        public void ToStringDoesNotOutputEmptyIdTags()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag");
            builder.Attributes["foo"] = "fooValue";
            builder.Attributes["bar"] = "barValue";
            builder.Attributes["id"] = "";

            // Act
            string output = builder.ToString(TagRenderMode.SelfClosing);

            Assert.Equal(@"<SomeTag bar=""barValue"" foo=""fooValue"" />", output);
        }

        [Fact]
        public void ToStringEndTag()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag")
            {
                InnerHtml = "<x&y>"
            };
            builder.MergeAttributes(GetAttributesDictionary());

            // Act
            string output = builder.ToString(TagRenderMode.EndTag);

            // Assert
            Assert.Equal(@"</SomeTag>", output);
        }

        [Fact]
        public void ToStringNormal()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag")
            {
                InnerHtml = "<x&y>"
            };
            builder.MergeAttributes(GetAttributesDictionary());

            // Act
            string output = builder.ToString(TagRenderMode.Normal);

            // Assert
            Assert.Equal(@"<SomeTag a=""Foo"" b=""Bar&amp;Baz"" c=""&lt;&quot;Quux&quot;>""><x&y></SomeTag>", output);
        }

        [Fact]
        public void ToStringSelfClosing()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag")
            {
                InnerHtml = "<x&y>"
            };
            builder.MergeAttributes(GetAttributesDictionary());

            // Act
            string output = builder.ToString(TagRenderMode.SelfClosing);

            // Assert
            Assert.Equal(@"<SomeTag a=""Foo"" b=""Bar&amp;Baz"" c=""&lt;&quot;Quux&quot;>"" />", output);
        }

        [Fact]
        public void ToStringStartTag()
        {
            // Arrange
            TagBuilder builder = new TagBuilder("SomeTag")
            {
                InnerHtml = "<x&y>"
            };
            builder.MergeAttributes(GetAttributesDictionary());

            // Act
            string output = builder.ToString(TagRenderMode.StartTag);

            // Assert
            Assert.Equal(@"<SomeTag a=""Foo"" b=""Bar&amp;Baz"" c=""&lt;&quot;Quux&quot;>"">", output);
        }

        private static IDictionary<string, string> GetAttributesDictionary()
        {
            return new SortedDictionary<string, string>
            {
                { "a", "Foo" },
                { "b", "Bar&Baz" },
                { "c", @"<""Quux"">" }
            };
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Mvc/UnobtrusiveValidationAttributesGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.Mvc;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test.Mvc
{
    public class UnobtrusiveValidationAttributesGeneratorTest
    {
        [Fact]
        public void GetValidationAttributesReturnsAttributesWhenMinAndMaxLengthRulesAreApplied()
        {
            // Arrange
            var clientRules = new ModelClientValidationRule[]
            {
                new ModelClientValidationMaxLengthRule("Max length message", 8),
                new ModelClientValidationMinLengthRule("Min length message", 2)
            };
            var attributes = new Dictionary<string, object>();

            // Act
            UnobtrusiveValidationAttributesGenerator.GetValidationAttributes(clientRules, attributes);

            // Assert
            Assert.Equal(5, attributes.Count);
            Assert.Equal("true", attributes["data-val"]);
            Assert.Equal("Max length message", attributes["data-val-maxlength"]);
            Assert.Equal(8, attributes["data-val-maxlength-max"]);
            Assert.Equal("Min length message", attributes["data-val-minlength"]);
            Assert.Equal(2, attributes["data-val-minlength-min"]);
        }

        [Fact]
        public void GetValidationAttributesReturnsAttributesWhenMinAndStringLengthRulesAreApplied()
        {
            // Arrange
            var clientRules = new ModelClientValidationRule[]
            {
                new ModelClientValidationMinLengthRule("Min length message", 2),
                new ModelClientValidationStringLengthRule("String length rule", 2, 6)
            };
            var attributes = new Dictionary<string, object>();

            // Act
            UnobtrusiveValidationAttributesGenerator.GetValidationAttributes(clientRules, attributes);

            // Assert
            Assert.Equal(6, attributes.Count);
            Assert.Equal("true", attributes["data-val"]);
            Assert.Equal("String length rule", attributes["data-val-length"]);
            Assert.Equal(2, attributes["data-val-length-min"]);
            Assert.Equal(6, attributes["data-val-length-max"]);
            Assert.Equal("Min length message", attributes["data-val-minlength"]);
            Assert.Equal(2, attributes["data-val-minlength-min"]);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/PreApplicationStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Routing;
using System.Web.Security;
using System.Web.UI;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class PreApplicationStartCodeTest
    {
        [Fact]
        public void StartTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                AppDomainUtils.SetPreAppStartStage();
                PreApplicationStartCode.Start();
                // Call a second time to ensure multiple calls do not cause issues
                PreApplicationStartCode.Start();

                Assert.False(RouteTable.Routes.RouteExistingFiles, "We should not be setting RouteExistingFiles");
                Assert.Empty(RouteTable.Routes);

                Assert.False(PageParser.EnableLongStringsAsResources);

                string formsAuthLoginUrl = (string)typeof(FormsAuthentication).GetField("_LoginUrl", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
                Assert.Null(formsAuthLoginUrl);
            });
        }

        [Fact]
        public void TestPreAppStartClass()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ScopeStorage/AspNetRequestScopeStorageProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class AspNetRequestStorageProvider
    {
        [Fact]
        public void AspNetStorageProviderReturnsApplicationStateBeforeAppStart()
        {
            // Arrange
            var provider = GetProvider(() => false);

            // Act and Assert
            Assert.NotNull(provider.ApplicationScope);
            Assert.NotNull(provider.GlobalScope);
            Assert.Equal(provider.ApplicationScope, provider.GlobalScope);
        }

        [Fact]
        public void AspNetStorageProviderThrowsWhenAccessingRequestScopeBeforeAppStart()
        {
            // Arrange
            var provider = GetProvider(() => false);

            // Act and Assert
            Assert.Throws<InvalidOperationException>(
                () => { var x = provider.RequestScope; },
                "RequestScope cannot be created when _AppStart is executing.");
        }

        [Fact]
        public void AspNetStorageProviderThrowsWhenAssigningScopeBeforeAppStart()
        {
            // Arrange
            var provider = GetProvider(() => false);

            // Act and Assert
            Assert.Throws<InvalidOperationException>(
                () => { provider.CurrentScope = new ScopeStorageDictionary(); },
                "Storage scopes cannot be created when _AppStart is executing.");
        }

        [Fact]
        public void AspNetStorageProviderReturnsRequestScopeAfterAppStart()
        {
            // Arrange
            var provider = GetProvider();

            // Act and Assert 
            Assert.NotNull(provider.RequestScope);
            Assert.Equal(provider.RequestScope, provider.CurrentScope);
        }

        [Fact]
        public void AspNetStorageRetrievesRequestScopeAfterSettingAnonymousScopes()
        {
            // Arrange
            var provider = GetProvider();

            // Act 
            var requestScope = provider.RequestScope;

            var Scope = new ScopeStorageDictionary();
            provider.CurrentScope = Scope;

            Assert.Equal(provider.CurrentScope, Scope);
            Assert.Equal(provider.RequestScope, requestScope);
        }

        [Fact]
        public void AspNetStorageUsesApplicationScopeAsGlobalScope()
        {
            // Arrange
            var provider = GetProvider();

            // Act and Assert
            Assert.Equal(provider.GlobalScope, provider.ApplicationScope);
        }

        private AspNetRequestScopeStorageProvider GetProvider(Func<bool> appStartExecuted = null)
        {
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Items).Returns(new Dictionary<object, object>());
            appStartExecuted = appStartExecuted ?? (() => true);

            return new AspNetRequestScopeStorageProvider(context.Object, appStartExecuted);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ScopeStorage/ScopeStorageDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class ScopeStorageDictionaryTest
    {
        [Fact]
        public void ScopeStorageDictionaryLooksUpLocalValuesFirst()
        {
            // Arrange
            var stateStorage = GetChainedStorageStateDictionary();

            // Act and Assert
            Assert.Equal("f2", stateStorage["f"]);
        }

        [Fact]
        public void ScopeStorageDictionaryOverridesParentValuesWithLocalValues()
        {
            // Arrange
            var stateStorage = GetChainedStorageStateDictionary();

            // Act and Assert
            Assert.Equal("a2", stateStorage["a"]);
            Assert.Equal("d2", stateStorage["d"]);
        }

        [Fact]
        public void ScopeStorageDictionaryLooksUpParentValuesWhenNotFoundLocally()
        {
            // Arrange
            var stateStorage = GetChainedStorageStateDictionary();

            // Act and Assert
            Assert.Equal("c0", stateStorage["c"]);
            Assert.Equal("b1", stateStorage["b"]);
        }

        [Fact]
        public void ScopeStorageDictionaryTreatsNullAsOrdinaryValues()
        {
            // Arrange
            var stateStorage = GetChainedStorageStateDictionary();
            stateStorage["b"] = null;

            // Act and Assert
            Assert.Null(stateStorage["b"]);
        }

        [Fact]
        public void ContainsKeyReturnsTrueIfItContainsKey()
        {
            // Arrange
            var scopeStorage = GetChainedStorageStateDictionary();

            // Act and Assert
            Assert.True(scopeStorage.ContainsKey("f"));
        }

        [Fact]
        public void ContainsKeyReturnsTrueIfBaseContainsKey()
        {
            // Arrange
            var scopeStorage = GetChainedStorageStateDictionary();

            // Act and Assert
            Assert.True(scopeStorage.ContainsKey("e"));
        }

        [Fact]
        public void ContainsKeyReturnsFalseIfItDoesNotContainKeyAndBaseIsNull()
        {
            // Arrange
            var scopeStorage = new ScopeStorageDictionary() { { "foo", "bar" } };

            // Act and Assert
            Assert.False(scopeStorage.ContainsKey("baz"));
        }

        [Fact]
        public void CountReturnsCountFromCurrentAndBaseScope()
        {
            // Arrange
            var scopeStorage = GetChainedStorageStateDictionary();

            // Act and Assert
            Assert.Equal(6, scopeStorage.Count);
        }

        [Fact]
        public void ScopeStorageDictionaryGetsValuesFromCurrentAndBaseScope()
        {
            // Arrange
            var scopeStorage = GetChainedStorageStateDictionary();

            // Act and Assert
            Assert.Equal("a2", scopeStorage["a"]);
            Assert.Equal("b1", scopeStorage["b"]);
            Assert.Equal("c0", scopeStorage["c"]);
            Assert.Equal("d2", scopeStorage["d"]);
            Assert.Equal("e1", scopeStorage["e"]);
            Assert.Equal("f2", scopeStorage["f"]);
        }

        [Fact]
        public void ClearRemovesAllItemsFromCurrentScope()
        {
            // Arrange
            var dictionary = new ScopeStorageDictionary { { "foo", "bar" }, { "foo2", "bar2" } };

            // Act
            dictionary.Clear();

            // Assert
            Assert.Empty(dictionary);
        }

        [Fact]
        public void ScopeStorageDictionaryIsNotReadOnly()
        {
            // Arrange
            var dictionary = new ScopeStorageDictionary();

            // Act and Assert
            Assert.False(dictionary.IsReadOnly);
        }

        [Fact]
        public void CopyToCopiesItemsToArrayAtSpecifiedIndex()
        {
            // Arrange
            var dictionary = GetChainedStorageStateDictionary();
            var array = new KeyValuePair<object, object>[8];

            // Act
            dictionary.CopyTo(array, 2);

            // Assert
            Assert.Equal("a", array[2].Key);
            Assert.Equal("a2", array[2].Value);
            Assert.Equal("f", array[4].Key);
            Assert.Equal("f2", array[4].Value);
            Assert.Equal("c", array[7].Key);
            Assert.Equal("c0", array[7].Value);
        }

        private ScopeStorageDictionary GetChainedStorageStateDictionary()
        {
            var root = new ScopeStorageDictionary();
            root["a"] = "a0";
            root["b"] = "b0";
            root["c"] = "c0";

            var firstGen = new ScopeStorageDictionary(baseScope: root);
            firstGen["a"] = "a1";
            firstGen["b"] = "b1";
            firstGen["d"] = "d1";
            firstGen["e"] = "e1";

            var secondGen = new ScopeStorageDictionary(baseScope: firstGen);
            secondGen["a"] = "a2";
            secondGen["d"] = "d2";
            secondGen["f"] = "f2";

            return secondGen;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ScopeStorage/ScopeStorageKeyComparerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class ScopeStorageKeyComparerTest
    {
        [Fact]
        public void ScopeStorageComparerPerformsCaseInsensitiveOrdinalComparisonForStrings()
        {
            // Arrange
            var dictionary = new Dictionary<object, object>(ScopeStorageComparer.Instance) { { "foo", "bar" } };

            // Act and Assert
            Assert.Equal("bar", dictionary["foo"]);
            Assert.Equal(dictionary["foo"], dictionary["FOo"]);
        }

        [Fact]
        public void ScopeStorageComparerPerformsRegularComparisonForOtherTypes()
        {
            // Arrange
            var stateStorage = new Dictionary<object, object> { { 4, "4-value" }, { new Person { ID = 10 }, "person-value" } };

            // Act and Assert
            Assert.Equal("4-value", stateStorage[4]);
            Assert.Equal(stateStorage[(int)8 / 2], stateStorage[4]);
            Assert.Equal("person-value", stateStorage[new Person { ID = 10 }]);
        }

        private class Person
        {
            public int ID { get; set; }

            public override bool Equals(object o)
            {
                var other = o as Person;
                return (other != null) && (other.ID == ID);
            }

            public override int GetHashCode()
            {
                return ID;
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/ScopeStorage/WebConfigScopeStorageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Reflection;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class WebConfigScopeStorageTest
    {
        [Fact]
        public void WebConfigScopeStorageReturnsConfigValue()
        {
            // Arrange
            var stateStorage = GetWebConfigScopeStorage();

            // Assert
            Assert.Equal("bar1", stateStorage["foo1"]);
            Assert.Equal("bar2", stateStorage["foo2"]);
        }

        [Fact]
        public void WebConfigScopeStoragePerformsCaseInsensitiveKeyCompares()
        {
            // Arrange
            var stateStorage = GetWebConfigScopeStorage();

            // Assert
            Assert.Equal("bar1", stateStorage["FOO1"]);
            Assert.Equal("bar2", stateStorage["FoO2"]);
        }

        [Fact]
        public void WebConfigScopeStorageThrowsWhenWriting()
        {
            // Arrange
            var stateStorage = GetWebConfigScopeStorage();

            // Act and Assert
            Assert.Throws<NotSupportedException>(() => stateStorage["foo"] = "some value", "Storage scope is read only.");
            Assert.Throws<NotSupportedException>(() => stateStorage.Add("foo", "value"), "Storage scope is read only.");
            Assert.Throws<NotSupportedException>(() => stateStorage.Remove("foo"), "Storage scope is read only.");
            Assert.Throws<NotSupportedException>(() => stateStorage.Clear(), "Storage scope is read only.");
            Assert.Throws<NotSupportedException>(() => stateStorage.Remove(new KeyValuePair<object, object>("foo", "bar")), "Storage scope is read only.");
        }

        [Fact]
        public void WebConfigStateAllowsEnumeratingOverConfigItems()
        {
            // Arrange
            var dictionary = new Dictionary<string, string> { { "a", "b" }, { "c", "d" }, { "x12", "y34" } };
            var stateStorage = GetWebConfigScopeStorage(dictionary);

            // Act and Assert
            Assert.True(dictionary.All(item => item.Value == stateStorage[item.Key] as string));
        }

        [Fact]
        public void WebConfigScopeStorage_WithDuplicatesInUnderlyingSettings_ResolveToTheFirst()
        {
            // Arrange
            // Start with a normal NameValueCollection
            var values = new NameValueCollection();
            values.Add("foo1", "bar1");

            // Now mess it up
            // We are simulating what might happen in rare cases (probably during app-start and high load) - 
            // the AppSettings NameValueCollection gets messed up internally, however keep functioning normally.
            // The duplication in AllKeys cause the bug https://aspnetwebstack.codeplex.com/workitem/912, 
            var entryType = typeof(NameObjectCollectionBase).GetNestedType("NameObjectEntry", BindingFlags.NonPublic);
            var entry = entryType.GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0].Invoke(new object[] { "foo1", "bar2" });
            var entriesArray = (ArrayList)typeof(NameObjectCollectionBase).GetField("_entriesArray", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(values);
            entriesArray.Add(entry);
            Assert.Equal(2, values.AllKeys.Length);

            // Act - should not throw;
            var stateStorage = new WebConfigScopeDictionary(values);

            // Assert
            Assert.Equal("bar1", stateStorage["foo1"]);
        }

        private WebConfigScopeDictionary GetWebConfigScopeStorage(IDictionary<string, string> values = null)
        {
            NameValueCollection collection = new NameValueCollection();
            if (values == null)
            {
                collection.Add("foo1", "bar1");
                collection.Add("foo2", "bar2");
            }
            else
            {
                foreach (var item in values)
                {
                    collection.Add(item.Key, item.Value);
                }
            }

            return new WebConfigScopeDictionary(collection);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/System.Web.WebPages.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{0F4870DB-A799-4DBA-99DF-0D74BB52FEC2}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>System.Web.WebPages.Test</RootNamespace>
    <AssemblyName>System.Web.WebPages.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core">
      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    </Reference>
    <Reference Include="System.Data.Linq" />
    <Reference Include="System.Web" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\Common\CollectionExtensionsTest.cs">
      <Link>Common\CollectionExtensionsTest.cs</Link>
    </Compile>
    <Compile Include="..\Common\PathHelpersTest.cs">
      <Link>Common\PathHelpersTest.cs</Link>
    </Compile>
    <Compile Include="ApplicationParts\ApplicationPartTest.cs" />
    <Compile Include="ApplicationParts\ApplicationPartRegistryTest.cs" />
    <Compile Include="ApplicationParts\MimeMappingTest.cs" />
    <Compile Include="ApplicationParts\ResourceHandlerTest.cs" />
    <Compile Include="ApplicationParts\TestResourceAssembly.cs" />
    <Compile Include="Extensions\StringWriterExtensionsTest.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryTokenStoreTest.cs" />
    <Compile Include="Helpers\AntiXsrf\MachineKey45CryptoSystemTest.cs" />
    <Compile Include="Helpers\AntiXsrf\MockableTokenStore.cs" />
    <Compile Include="Helpers\AntiXsrf\MockableTokenValidator.cs" />
    <Compile Include="Helpers\AntiXsrf\TokenValidatorTest.cs" />
    <Compile Include="Helpers\AntiXsrf\MockableClaimUidExtractor.cs" />
    <Compile Include="Helpers\AntiXsrf\MockableCryptoSystem.cs" />
    <Compile Include="Helpers\AntiXsrf\HexUtil.cs" />
    <Compile Include="Helpers\Claims\ClaimTest.cs" />
    <Compile Include="Helpers\Claims\ClaimsIdentityTest.cs" />
    <Compile Include="Helpers\Claims\ClaimsIdentityConverterTest.cs" />
    <Compile Include="Helpers\AntiXsrf\ClaimUidExtractorTest.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryTokenTest.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryTokenSerializerTest.cs" />
    <Compile Include="Helpers\AntiXsrf\AntiForgeryWorkerTest.cs" />
    <Compile Include="Helpers\AntiForgeryConfigTest.cs" />
    <Compile Include="Helpers\AntiXsrf\MockableAntiForgeryTokenSerializer.cs" />
    <Compile Include="Helpers\AntiXsrf\MockAntiForgeryConfig.cs" />
    <Compile Include="Helpers\CryptoUtilTest.cs" />
    <Compile Include="Helpers\Claims\MockClaimsIdentity.cs" />
    <Compile Include="Helpers\AntiXsrf\BinaryBlobTest.cs" />
    <Compile Include="Html\LabelHelperTest.cs" />
    <Compile Include="LatestRazorVersion.cs" />
    <Compile Include="Mvc\ModelClientValidationMembershipPasswordRuleTest.cs" />
    <Compile Include="Mvc\ModelClientValidationMaxLengthRuleTest.cs" />
    <Compile Include="Mvc\ModelClientValidationMinLengthRuleTest.cs" />
    <Compile Include="Mvc\ModelClientValidationStringLengthRuleTest.cs" />
    <Compile Include="Mvc\UnobtrusiveValidationAttributesGeneratorTest.cs" />
    <Compile Include="Utils\HtmlAttributePropertyHelperTest.cs" />
    <Compile Include="Utils\PropertyHelperTest.cs" />
    <Compile Include="Utils\SessionStateUtilTest.cs" />
    <Compile Include="Utils\UrlRewriterHelperTest.cs" />
    <Compile Include="WebPage\BrowserHelpersTest.cs" />
    <Compile Include="WebPage\BrowserOverrideStoresTest.cs" />
    <Compile Include="WebPage\CookieBrowserOverrideStoreTest.cs" />
    <Compile Include="WebPage\DefaultDisplayModeTest.cs" />
    <Compile Include="WebPage\DisplayInfoTest.cs" />
    <Compile Include="WebPage\DisplayModeProviderTest.cs" />
    <Compile Include="Extensions\HttpContextExtensionsTest.cs" />
    <Compile Include="Extensions\HttpRequestExtensionsTest.cs" />
    <Compile Include="Extensions\StringExtensionsTest.cs" />
    <Compile Include="Extensions\HttpResponseExtensionsTest.cs" />
    <Compile Include="Helpers\AntiForgeryTest.cs" />
    <Compile Include="Helpers\UnvalidatedRequestValuesTest.cs" />
    <Compile Include="Html\CheckBoxTest.cs" />
    <Compile Include="Html\HtmlHelperFactory.cs" />
    <Compile Include="Html\HtmlHelperTest.cs" />
    <Compile Include="Html\InputHelperTest.cs" />
    <Compile Include="Html\RadioButtonTest.cs" />
    <Compile Include="Html\SelectHelperTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Html\TextAreaHelperTest.cs">
      <SubType>Code</SubType>
    </Compile>
    <Compile Include="Html\ValidationHelperTest.cs" />
    <Compile Include="Instrumentation\InstrumentationServiceTest.cs" />
    <Compile Include="Mvc\HttpAntiForgeryExceptionTest.cs" />
    <Compile Include="Mvc\TagBuilderTest.cs" />
    <Compile Include="PreApplicationStartCodeTest.cs" />
    <Compile Include="ScopeStorage\AspNetRequestScopeStorageProviderTest.cs" />
    <Compile Include="ScopeStorage\ScopeStorageDictionaryTest.cs" />
    <Compile Include="ScopeStorage\ScopeStorageKeyComparerTest.cs" />
    <Compile Include="ScopeStorage\WebConfigScopeStorageTest.cs" />
    <Compile Include="Utils\CultureUtilTest.cs" />
    <Compile Include="Utils\PathUtilTest.cs" />
    <Compile Include="Utils\TestObjectFactory.cs" />
    <Compile Include="Utils\TypeHelperTest.cs" />
    <Compile Include="Utils\UrlUtilTest.cs" />
    <Compile Include="Validation\ValidationHelperTest.cs" />
    <Compile Include="Validation\ValidatorTest.cs" />
    <Compile Include="WebPage\ApplicationStartPageTest.cs" />
    <Compile Include="WebPage\DynamicHttpApplicationStateTest.cs" />
    <Compile Include="WebPage\DynamicPageDataDictionaryTest.cs" />
    <Compile Include="WebPage\FileExistenceCacheTest.cs" />
    <Compile Include="WebPage\RequestBrowserOverrideStoreTest.cs" />
    <Compile Include="WebPage\RequestResourceTrackerTest.cs" />
    <Compile Include="WebPage\TemplateStackTest.cs" />
    <Compile Include="WebPage\BuildManagerWrapperTest.cs" />
    <Compile Include="WebPage\VirtualPathFactoryExtensionsTest.cs" />
    <Compile Include="WebPage\VirtualPathFactoryManagerTest.cs" />
    <Compile Include="WebPage\WebPageContextTest.cs" />
    <Compile Include="WebPage\WebPageExecutingBaseTest.cs" />
    <Compile Include="WebPage\WebPageHttpModuleTest.cs" />
    <Compile Include="WebPage\WebPageHttpHandlerTest.cs" />
    <Compile Include="WebPage\UrlDataTest.cs" />
    <Compile Include="WebPage\StartPageTest.cs" />
    <Compile Include="WebPage\Utils.cs" />
    <Compile Include="WebPage\PageDataDictionaryTest.cs" />
    <Compile Include="WebPage\WebPageRenderingBaseTest.cs" />
    <Compile Include="WebPage\WebPageRouteTest.cs" />
    <Compile Include="WebPage\RenderPageTest.cs" />
    <Compile Include="WebPage\BuildManagerExceptionUtilTest.cs" />
    <Compile Include="WebPage\LayoutTest.cs" />
    <Compile Include="WebPage\WebPageTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76EFA9C5-8D7E-4FDF-B710-E20F8B6B00D2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="App.config" />
    <None Include="packages.config" />
    <None Include="TestFiles\Deployed\Bar" />
    <None Include="TestFiles\Deployed\Bar.foohtml" />
  </ItemGroup>
  <ItemGroup>
    <Content Include="TestFiles\Deployed\Bar.cshtml" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/System.Web.WebPages.Test/TestFiles/Deployed/Bar
================================================


================================================
FILE: test/System.Web.WebPages.Test/TestFiles/Deployed/Bar.cshtml
================================================


================================================
FILE: test/System.Web.WebPages.Test/TestFiles/Deployed/Bar.foohtml
================================================


================================================
FILE: test/System.Web.WebPages.Test/Utils/CultureUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Threading;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class CultureUtilTest
    {
        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoCultureWithNoUserLanguagesDoesNothing()
        {
            // Arrange
            var context = GetContextForSetCulture(null);
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentCulture;

            // Act
            CultureUtil.SetCulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentCulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoUICultureWithNoUserLanguagesDoesNothing()
        {
            // Arrange
            var context = GetContextForSetCulture(null);
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentUICulture;

            // Act
            CultureUtil.SetUICulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentUICulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoCultureWithEmptyUserLanguagesDoesNothing()
        {
            // Arrange
            var context = GetContextForSetCulture(Enumerable.Empty<string>());
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentCulture;

            // Act
            CultureUtil.SetCulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentCulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoUICultureWithEmptyUserLanguagesDoesNothing()
        {
            // Arrange
            var context = GetContextForSetCulture(Enumerable.Empty<string>());
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentUICulture;

            // Act
            CultureUtil.SetUICulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentUICulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoCultureWithBlankUserLanguagesDoesNothing()
        {
            // Arrange
            var context = GetContextForSetCulture(new[] { " " });
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentCulture;

            // Act
            CultureUtil.SetCulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentCulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoUICultureWithBlankUserLanguagesDoesNothing()
        {
            // Arrange
            var context = GetContextForSetCulture(new[] { " " });
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentUICulture;

            // Act
            CultureUtil.SetUICulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentUICulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoCultureWithInvalidLanguageDoesNothing()
        {
            // Arrange
            // "sans-culture" is an invalid culture name everywhere -- even on Windows 10.
            var context = GetContextForSetCulture(new[] { "sans-culture", "bb-BB", "cc-CC" });
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentCulture;

            // Act
            CultureUtil.SetCulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentCulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoUICultureWithInvalidLanguageDoesNothing()
        {
            // Arrange
            // "sans-culture" is an invalid culture name everywhere -- even on Windows 10.
            var context = GetContextForSetCulture(new[] { "sans-culture", "bb-BB", "cc-CC" });
            Thread thread = Thread.CurrentThread;
            CultureInfo culture = thread.CurrentUICulture;

            // Act
            CultureUtil.SetUICulture(thread, context, "auto");

            // Assert
            Assert.Equal(culture, thread.CurrentUICulture);
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoCultureDetectsUserLanguageCulture()
        {
            // Arrange
            var context = GetContextForSetCulture(new[] { "en-GB", "en-US", "ar-eg" });
            Thread thread = Thread.CurrentThread;

            // Act
            CultureUtil.SetCulture(thread, context, "auto");

            // Assert
            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentCulture);
            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentCulture));
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoUICultureDetectsUserLanguageCulture()
        {
            // Arrange
            var context = GetContextForSetCulture(new[] { "en-GB", "en-US", "ar-eg" });
            Thread thread = Thread.CurrentThread;

            // Act
            CultureUtil.SetUICulture(thread, context, "auto");

            // Assert
            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentUICulture);
            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentUICulture));
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoCultureUserLanguageWithQParameterCulture()
        {
            // Arrange
            var context = GetContextForSetCulture(new[] { "en-GB;q=0.3", "en-US", "ar-eg;q=0.5" });
            Thread thread = Thread.CurrentThread;

            // Act
            CultureUtil.SetCulture(thread, context, "auto");

            // Assert
            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentCulture);
            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentCulture));
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetAutoUICultureDetectsUserLanguageWithQParameterCulture()
        {
            // Arrange
            var context = GetContextForSetCulture(new[] { "en-GB;q=0.3", "en-US", "ar-eg;q=0.5" });
            Thread thread = Thread.CurrentThread;

            // Act
            CultureUtil.SetUICulture(thread, context, "auto");

            // Assert
            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentUICulture);
            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentUICulture));
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetCultureWithInvalidCultureThrows()
        {
            // Arrange
            var context = GetContextForSetCulture();
            Thread thread = Thread.CurrentThread;

            // Act and Assert
            Assert.Throws<CultureNotFoundException>(() => CultureUtil.SetCulture(thread, context, "sans-culture"));
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetUICultureWithInvalidCultureThrows()
        {
            // Arrange
            var context = GetContextForSetCulture();
            Thread thread = Thread.CurrentThread;

            // Act and Assert
            Assert.Throws<CultureNotFoundException>(() => CultureUtil.SetUICulture(thread, context, "sans-culture"));
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetCultureWithValidCulture()
        {
            // Arrange
            var context = GetContextForSetCulture();
            Thread thread = Thread.CurrentThread;

            // Act
            CultureUtil.SetCulture(thread, context, "en-GB");

            // Assert
            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentCulture);
            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentCulture));
        }

        [Fact]
        [ReplaceCulture(Culture = "es-PR", UICulture = "es-PR")]
        public void SetUICultureWithValidCulture()
        {
            // Arrange
            var context = GetContextForSetCulture();
            Thread thread = Thread.CurrentThread;

            // Act
            CultureUtil.SetUICulture(thread, context, "en-GB");

            // Assert
            Assert.Equal(CultureInfo.GetCultureInfo("en-GB"), thread.CurrentUICulture);
            Assert.Equal("05/01/1979", new DateTime(1979, 1, 5).ToString("d", thread.CurrentUICulture));
        }

        private static HttpContextBase GetContextForSetCulture(IEnumerable<string> userLanguages = null)
        {
            Mock<HttpContextBase> contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(context => context.Request.UserLanguages).Returns(userLanguages == null ? null : userLanguages.ToArray());
            return contextMock.Object;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/HtmlAttributePropertyHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class HtmlAttributePropertyHelperTest
    {
        [Fact]
        public void HtmlAttributePropertyHelperRenamesPropertyNames()
        {
            // Arrange
            var anonymous = new { bar_baz = "foo" };
            PropertyInfo property = anonymous.GetType().GetProperties().First();

            // Act
            HtmlAttributePropertyHelper helper = new HtmlAttributePropertyHelper(property);

            // Assert
            Assert.Equal("bar_baz", property.Name);
            Assert.Equal("bar-baz", helper.Name);
        }

        [Fact]
        public void HtmlAttributePropertyHelperReturnsNameCorrectly()
        {
            // Arrange
            var anonymous = new { foo = "bar" };
            PropertyInfo property = anonymous.GetType().GetProperties().First();

            // Act
            HtmlAttributePropertyHelper helper = new HtmlAttributePropertyHelper(property);

            // Assert
            Assert.Equal("foo", property.Name);
            Assert.Equal("foo", helper.Name);
        }

        [Fact]
        public void HtmlAttributePropertyHelperReturnsValueCorrectly()
        {
            // Arrange
            var anonymous = new { bar = "baz" };
            PropertyInfo property = anonymous.GetType().GetProperties().First();

            // Act
            HtmlAttributePropertyHelper helper = new HtmlAttributePropertyHelper(property);

            // Assert
            Assert.Equal("bar", helper.Name);
            Assert.Equal("baz", helper.GetValue(anonymous));
        }

        [Fact]
        public void HtmlAttributePropertyHelperReturnsValueCorrectlyForValueTypes()
        {
            // Arrange
            var anonymous = new { foo = 32 };
            PropertyInfo property = anonymous.GetType().GetProperties().First();

            // Act
            HtmlAttributePropertyHelper helper = new HtmlAttributePropertyHelper(property);

            // Assert
            Assert.Equal("foo", helper.Name);
            Assert.Equal(32, helper.GetValue(anonymous));
        }

        [Fact]
        public void HtmlAttributePropertyHelperReturnsCachedPropertyHelper()
        {
            // Arrange
            var anonymous = new { foo = "bar" };

            // Act
            PropertyHelper[] helpers1 = HtmlAttributePropertyHelper.GetProperties(anonymous);
            PropertyHelper[] helpers2 = HtmlAttributePropertyHelper.GetProperties(anonymous);

            // Assert
            Assert.Single(helpers1);
            Assert.ReferenceEquals(helpers1, helpers2);
            Assert.ReferenceEquals(helpers1[0], helpers2[0]);
        }

        [Fact]
        public void HtmlAttributeDoesNotShareCacheWithPropertyHelper()
        {
            // Arrange
            var anonymous = new { bar_baz1 = "foo" };

            // Act
            PropertyHelper[] helpers1 = HtmlAttributePropertyHelper.GetProperties(anonymous);
            PropertyHelper[] helpers2 = PropertyHelper.GetProperties(anonymous);

            // Assert
            PropertyHelper helper1 = Assert.Single(helpers1);
            PropertyHelper helper2 = Assert.Single(helpers2);

            Assert.NotEqual(helpers1, helpers2);
            Assert.NotEqual(helper1, helper2);

            Assert.IsType<HtmlAttributePropertyHelper>(helper1);
            Assert.IsNotType<HtmlAttributePropertyHelper>(helper2);

            Assert.Equal("bar-baz1", helper1.Name);
            Assert.Equal("bar_baz1", helper2.Name);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/PathUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Web.WebPages.TestUtils;
using Microsoft.Internal.Web.Utils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class PathUtilTest
    {
        [Fact]
        public void IsSimpleNameTest()
        {
            Assert.True(PathUtil.IsSimpleName("Test.cshtml"));
            Assert.True(PathUtil.IsSimpleName("Test.Hello.cshtml"));
            Assert.False(PathUtil.IsSimpleName("~/myapp/Test/Hello.cshtml"));
            Assert.False(PathUtil.IsSimpleName("../Test/Hello.cshtml"));
            Assert.False(PathUtil.IsSimpleName("../../Test/Hello.cshtml"));
            Assert.False(PathUtil.IsSimpleName("/Test/Hello.cshtml"));
        }

        [Fact]
        public void GetExtensionForNullPathsReturnsNull()
        {
            // Arrange
            string path = null;

            // Act
            string extension = PathUtil.GetExtension(path);

            // Assert
            Assert.Null(extension);
        }

        [Fact]
        public void GetExtensionForEmptyPathsReturnsEmptyString()
        {
            // Arrange
            string path = String.Empty;

            // Act
            string extension = PathUtil.GetExtension(path);

            // Assert
            Assert.Equal(0, extension.Length);
        }

        [Fact]
        public void GetExtensionReturnsEmptyStringForPathsThatDoNotContainExtension()
        {
            // Arrange
            string[] paths = new[] { "SomePath", "SomePath/", "SomePath/MorePath", "SomePath/MorePath/" };

            // Act
            var extensions = paths.Select(PathUtil.GetExtension);

            // Assert
            Assert.All(extensions, ext => Assert.Empty(ext));
        }

        [Fact]
        public void GetExtensionReturnsEmptyStringForPathsContainingPathInfo()
        {
            // Arrange
            string[] paths = new[] { "SomePath.cshtml/", "SomePath.html/path/info" };

            // Act
            var extensions = paths.Select(PathUtil.GetExtension);

            // Assert
            Assert.All(extensions, ext => Assert.Empty(ext));
        }

        [Fact]
        public void GetExtensionReturnsEmptyStringForPathsTerminatingWithADot()
        {
            // Arrange
            string[] paths = new[] { "SomePath.", "SomeDirectory/SomePath/SomePath.", "SomeDirectory/SomePath.foo." };

            // Act
            var extensions = paths.Select(PathUtil.GetExtension);

            // Assert
            Assert.All(extensions, ext => Assert.Empty(ext));
        }

        [Fact]
        public void GetExtensionReturnsExtensionsForPathsTerminatingInExtension()
        {
            // Arrange
            string path1 = "SomePath.cshtml";
            string path2 = "SomeDir/SomePath.txt";

            // Act
            string ext1 = PathUtil.GetExtension(path1);
            string ext2 = PathUtil.GetExtension(path2);

            // Assert
            Assert.Equal(".cshtml", ext1);
            Assert.Equal(".txt", ext2);
        }

        [Fact]
        public void GetExtensionDoesNotThrowForPathsWithInvalidCharacters()
        {
            // Arrange
            // Repro from test case in Bug 93828
            string path = "Insights/110786998958803%7C2.d24wA6Y3MiT2w8p3OT4yTw__.3600.1289415600-708897727%7CRLN-t1w9bXtKWZ_11osz15Rk_jY";

            // Act
            string extension = PathUtil.GetExtension(path);

            // Assert
            Assert.Equal(".1289415600-708897727%7CRLN-t1w9bXtKWZ_11osz15Rk_jY", extension);
        }

        [Fact]
        public void IsWithinAppRootNestedTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var root = "/subfolder1/website1";
                using (Utils.CreateHttpRuntime(root))
                {
                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/default.cshtml"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/test/default.cshtml"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1/"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1/default.cshtml"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/subfolder1/website1/test/default.cshtml"));

                    Assert.False(PathUtil.IsWithinAppRoot(root, "/"));
                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1"));
                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1/"));
                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1/website2"));
                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder2"));
                }
            });
        }

        [Fact]
        public void IsWithinAppRootTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var root = "/website1";
                using (Utils.CreateHttpRuntime(root))
                {
                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/default.cshtml"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "~/test/default.cshtml"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1/"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1/default.cshtml"));
                    Assert.True(PathUtil.IsWithinAppRoot(root, "/website1/test/default.cshtml"));

                    Assert.False(PathUtil.IsWithinAppRoot(root, "/"));
                    Assert.False(PathUtil.IsWithinAppRoot(root, "/website2"));
                    Assert.False(PathUtil.IsWithinAppRoot(root, "/subfolder1/"));
                }
            });
        }

        private class TestVirtualPathUtility : IVirtualPathUtility
        {
            public string Combine(string basePath, string relativePath)
            {
                return basePath + "/" + relativePath;
            }

            public string ToAbsolute(string virtualPath)
            {
                return virtualPath;
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/PropertyHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Reflection;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class PropertyHelperTest
    {
        [Fact]
        public void PropertyHelperReturnsNameCorrectly()
        {
            // Arrange
            var anonymous = new { foo = "bar" };
            PropertyInfo property = anonymous.GetType().GetProperties().First();

            // Act
            PropertyHelper helper = new PropertyHelper(property);

            // Assert
            Assert.Equal("foo", property.Name);
            Assert.Equal("foo", helper.Name);
        }

        [Fact]
        public void PropertyHelperReturnsValueCorrectly()
        {
            // Arrange
            var anonymous = new { bar = "baz" };
            PropertyInfo property = anonymous.GetType().GetProperties().First();

            // Act
            PropertyHelper helper = new PropertyHelper(property);

            // Assert
            Assert.Equal("bar", helper.Name);
            Assert.Equal("baz", helper.GetValue(anonymous));
        }

        [Fact]
        public void PropertyHelperReturnsValueCorrectlyForValueTypes()
        {
            // Arrange
            var anonymous = new { foo = 32 };
            PropertyInfo property = anonymous.GetType().GetProperties().First();

            // Act
            PropertyHelper helper = new PropertyHelper(property);

            // Assert
            Assert.Equal("foo", helper.Name);
            Assert.Equal(32, helper.GetValue(anonymous));
        }

        [Fact]
        public void PropertyHelperReturnsCachedPropertyHelper()
        {
            // Arrange
            var anonymous = new { foo = "bar" };

            // Act
            PropertyHelper[] helpers1 = PropertyHelper.GetProperties(anonymous);
            PropertyHelper[] helpers2 = PropertyHelper.GetProperties(anonymous);

            // Assert
            Assert.Single(helpers1);
            Assert.ReferenceEquals(helpers1, helpers2);
            Assert.ReferenceEquals(helpers1[0], helpers2[0]);
        }

        [Fact]
        public void PropertyHelperDoesNotChangeUnderscores()
        {
            // Arrange
            var anonymous = new { bar_baz2 = "foo" };

            // Act + Assert
            PropertyHelper helper = Assert.Single(PropertyHelper.GetProperties(anonymous));
            Assert.Equal("bar_baz2", helper.Name);
        }

        private class PrivateProperties
        {
            public int Prop1 { get; set; }
            protected int Prop2 { get; set; }
            private int Prop3 { get; set; }
        }

        [Fact]
        public void PropertyHelperDoesNotFindPrivateProperties()
        {
            // Arrange
            var anonymous = new PrivateProperties();

            // Act + Assert
            PropertyHelper helper = Assert.Single(PropertyHelper.GetProperties(anonymous));
            Assert.Equal("Prop1", helper.Name);
        }

        private class Static
        {
            public static int Prop2 { get; set; }
            public int Prop5 { get; set; }
        }

        [Fact]
        public void PropertyHelperDoesNotFindStaticProperties()
        {
            // Arrange
            var anonymous = new Static();

            // Act + Assert
            PropertyHelper helper = Assert.Single(PropertyHelper.GetProperties(anonymous));
            Assert.Equal("Prop5", helper.Name);
        }

        private class SetOnly
        {
            public int Prop2 { set { } }
            public int Prop6 { get; set; }
        }

        [Fact]
        public void PropertyHelperDoesNotFindSetOnlyProperties()
        {
            // Arrange
            var anonymous = new SetOnly();

            // Act + Assert
            PropertyHelper helper = Assert.Single(PropertyHelper.GetProperties(anonymous));
            Assert.Equal("Prop6", helper.Name);
        }

        private struct MyProperties
        {
            public int IntProp { get; set; }
            public string StringProp { get; set; }
        }

        [Fact]
        public void PropertyHelperWorksForStruct()
        {
            // Arrange
            var anonymous = new MyProperties();

            anonymous.IntProp = 3;
            anonymous.StringProp = "Five";

            // Act + Assert
            PropertyHelper helper1 = Assert.Single(PropertyHelper.GetProperties(anonymous), prop => prop.Name == "IntProp");
            PropertyHelper helper2 = Assert.Single(PropertyHelper.GetProperties(anonymous), prop => prop.Name == "StringProp");
            Assert.Equal(3, helper1.GetValue(anonymous));
            Assert.Equal("Five", helper2.GetValue(anonymous));
        }

        public class BaseClass
        {
            public string PropA { get; set; }

            protected string PropProtected { get; set; }
        }

        public class DerivedClass : BaseClass
        {
            public string PropB { get; set; }
        }

        public class BaseClassWithVirtual
        {
            public virtual string PropA { get; set; }
            public string PropB { get; set; }
        }

        public class DerivedClassWithNew : BaseClassWithVirtual
        {
            public new string PropB { get { return "Newed"; } }
        }

        public class DerivedClassWithOverride : BaseClassWithVirtual
        {
            public override string PropA { get { return "Overriden"; } }
        }

        [Fact]
        public void PropertyHelperForDerivedClass()
        {
            // Arrange
            object derived = new DerivedClass { PropA = "propAValue", PropB = "propBValue" };

            // Act
            PropertyHelper[] helpers = PropertyHelper.GetProperties(derived).ToArray();

            // Assert
            Assert.NotNull(helpers);
            Assert.Equal(2, helpers.Length);

            PropertyHelper propAHelper = Assert.Single(helpers, h => h.Name == "PropA");
            PropertyHelper propBHelper = Assert.Single(helpers, h => h.Name == "PropB");

            Assert.Equal("propAValue", propAHelper.GetValue(derived));
            Assert.Equal("propBValue", propBHelper.GetValue(derived));
        }

        [Fact]
        public void PropertyHelperForDerivedClassWithNew()
        {
            // Arrange
            object derived = new DerivedClassWithNew { PropA = "propAValue" };

            // Act
            PropertyHelper[] helpers = PropertyHelper.GetProperties(derived).ToArray();

            // Assert
            Assert.NotNull(helpers);
            Assert.Equal(2, helpers.Length);

            PropertyHelper propAHelper = Assert.Single(helpers, h => h.Name == "PropA");
            PropertyHelper propBHelper = Assert.Single(helpers, h => h.Name == "PropB");

            Assert.Equal("propAValue", propAHelper.GetValue(derived));
            Assert.Equal("Newed", propBHelper.GetValue(derived));
        }

        [Fact]
        public void PropertyHelperForDerivedWithVirtual()
        {
            // Arrange
            object derived = new DerivedClassWithOverride { PropA = "propAValue", PropB = "propBValue" };

            // Act
            PropertyHelper[] helpers = PropertyHelper.GetProperties(derived).ToArray();

            // Assert
            Assert.NotNull(helpers);
            Assert.Equal(2, helpers.Length);

            PropertyHelper propAHelper = Assert.Single(helpers, h => h.Name == "PropA");
            PropertyHelper propBHelper = Assert.Single(helpers, h => h.Name == "PropB");

            Assert.Equal("Overriden", propAHelper.GetValue(derived));
            Assert.Equal("propBValue", propBHelper.GetValue(derived));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/SessionStateUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Web.Razor;
using System.Web.SessionState;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class SessionStateUtilTest
    {
        [Fact]
        public void SetUpSessionStateDoesNotInvokeSessionStateBehaviorIfNoPageHasDirective()
        {
            // Arrange
            var page = new Mock<WebPage>(MockBehavior.Strict);
            var startPage = new Mock<StartPage>(MockBehavior.Strict);
            var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage.Object));
            var context = new Mock<HttpContextBase>(MockBehavior.Strict);

            // Act
            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());

            // Assert
            context.Verify(c => c.SetSessionStateBehavior(It.IsAny<SessionStateBehavior>()), Times.Never());
        }

        [Fact]
        public void SetUpSessionStateUsesSessionStateValueFromRequestingPageIfAvailable()
        {
            // Arrange
            var page = new DisabledSessionWebPage();
            var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
            context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Disabled)).Verifiable();

            // Act
            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());

            // Assert
            context.Verify();
        }

        [Fact]
        public void SetUpSessionStateUsesSessionStateValueFromStartPageHierarchy()
        {
            // Arrange
            var page = new Mock<WebPage>(MockBehavior.Strict);
            var startPage = new DefaultSessionWebPage
            {
                ChildPage = new ReadOnlySessionWebPage()
            };
            var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage));
            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
            context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.ReadOnly)).Verifiable();

            // Act
            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());

            // Assert
            context.Verify();
        }

        [Fact]
        public void SetUpSessionStateThrowsIfSessionStateValueIsInvalid()
        {
            // Arrange
            var page = new Mock<WebPage>(MockBehavior.Strict);
            var startPage = new InvalidSessionState();
            var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage));
            var context = new Mock<HttpContextBase>(MockBehavior.Strict);

            // Act
            Assert.Throws<ArgumentException>(() => SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>()),
                "Value \"jabberwocky\" specified in \"~/_Invalid.cshtml\" is an invalid value for the SessionState directive. Possible values are: \"Default, Required, ReadOnly, Disabled\".");
        }

        [Fact]
        public void SetUpSessionStateThrowsIfMultipleSessionStateValueIsInvalid()
        {
            // Arrange
            var page = new PageWithMultipleSesionStateAttributes();
            var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
            var context = new Mock<HttpContextBase>(MockBehavior.Strict);

            // Act
            Assert.Throws<InvalidOperationException>(() => SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>()),
                "At most one SessionState value can be declared per page.");
        }

        [Fact]
        public void SetUpSessionStateUsesCache()
        {
            // Arrange
            var page = new PageWithBadAttribute();
            var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
            var context = new Mock<HttpContextBase>(MockBehavior.Strict);
            var dictionary = new ConcurrentDictionary<Type, SessionStateBehavior?>();
            dictionary.TryAdd(webPageHttpHandler.GetType(), SessionStateBehavior.Default);
            context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Default)).Verifiable();

            // Act
            SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, dictionary);

            // Assert
            context.Verify();
            Assert.Throws<Exception>(() => page.GetType().GetCustomAttributes(inherit: false), "Can't call me!");
        }

        [RazorDirective("sessionstate", "disabled")]
        private sealed class DisabledSessionWebPage : WebPage
        {
            public override void Execute()
            {
                throw new NotSupportedException();
            }
        }

        [RazorDirective("sessionstate", "ReadOnly")]
        private sealed class ReadOnlySessionWebPage : StartPage
        {
            public override void Execute()
            {
                throw new NotSupportedException();
            }
        }

        [RazorDirective("SessionState", "Default")]
        private sealed class DefaultSessionWebPage : StartPage
        {
            public override void Execute()
            {
                throw new NotSupportedException();
            }
        }

        [RazorDirective("SessionState", "jabberwocky")]
        private sealed class InvalidSessionState : StartPage
        {
            public override string VirtualPath
            {
                get
                {
                    return "~/_Invalid.cshtml";
                }
                set
                {
                    VirtualPath = value;
                }
            }
            public override void Execute()
            {
                throw new NotSupportedException();
            }
        }

        private sealed class BadAttribute : Attribute
        {
            public BadAttribute()
            {
                throw new Exception("Can't call me!");
            }
        }

        [RazorDirective("SessionState", "Default"), Bad]
        private sealed class PageWithBadAttribute : WebPage
        {
            public override void Execute()
            {
                throw new NotSupportedException();
            }
        }

        [RazorDirective("SessionState", "Disabled"), RazorDirective("SessionState", "ReadOnly")]
        private sealed class PageWithMultipleSesionStateAttributes : WebPage
        {
            public override void Execute()
            {
                throw new NotSupportedException();
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/TestObjectFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;

namespace System.Web.WebPages.Test
{
    public class HashVirtualPathFactory : IVirtualPathFactory
    {
        private IDictionary<string, object> _pages;

        public HashVirtualPathFactory(params WebPageExecutingBase[] pages)
        {
            _pages = pages.ToDictionary(p => p.VirtualPath, p => (object)p, StringComparer.OrdinalIgnoreCase);
        }

        public bool Exists(string virtualPath)
        {
            return _pages.ContainsKey(virtualPath);
        }

        public object CreateInstance(string virtualPath)
        {
            object value;
            if (_pages.TryGetValue(virtualPath, out value))
            {
                return value;
            }
            return null;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/TypeHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class TypeHelperTest
    {
        [Fact]
        public void ObjectToDictionaryWithNullObjectReturnsEmptyDictionary()
        {
            // Arrange
            object dict = null;

            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);

            Assert.NotNull(dictValues);
            Assert.Equal(0, dictValues.Count);
        }

        [Fact]
        public void ObjectToDictionaryWithPlainObjectTypeReturnsEmptyDictionary()
        {
            // Arrange
            object dict = new object();

            // Act
            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);

            // Assert
            Assert.NotNull(dictValues);
            Assert.Equal(0, dictValues.Count);
        }

        [Fact]
        public void ObjectToDictionaryWithPrimitiveTypeLooksUpPublicProperties()
        {
            // Arrange
            object dict = "test";

            // Act
            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);

            // Assert
            Assert.NotNull(dictValues);
            Assert.Equal(1, dictValues.Count);
            Assert.Equal(4, dictValues["Length"]);
        }

        [Fact]
        public void ObjectToDictionaryWithAnonymousTypeLooksUpProperties()
        {
            // Arrange
            object dict = new { test = "value", other = 1 };

            // Act
            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);

            // Assert
            Assert.NotNull(dictValues);
            Assert.Equal(2, dictValues.Count);
            Assert.Equal("value", dictValues["test"]);
            Assert.Equal(1, dictValues["other"]);
        }

        [Fact]
        public void ObjectToDictionaryReturnsCaseInsensitiveDictionary()
        {
            // Arrange
            object dict = new { TEST = "value", oThEr = 1 };

            // Act
            IDictionary<string, object> dictValues = TypeHelper.ObjectToDictionary(dict);

            // Assert
            Assert.NotNull(dictValues);
            Assert.Equal(2, dictValues.Count);
            Assert.Equal("value", dictValues["test"]);
            Assert.Equal(1, dictValues["other"]);
        }

        [Fact]
        public void AddAnonymousTypeObjectToDictionaryTest()
        {
            IDictionary<string, object> d = new Dictionary<string, object>();
            d.Add("X", "Xvalue");
            TypeHelper.AddAnonymousObjectToDictionary(d, new { A = "a", B = "b" });
            Assert.Equal("Xvalue", d["X"]);
            Assert.Equal("a", d["A"]);
            Assert.Equal("b", d["B"]);
        }

        [Fact]
        public void IsAnonymousTypeTest()
        {
            Assert.False(TypeHelper.IsAnonymousType(typeof(object)));
            Assert.False(TypeHelper.IsAnonymousType(typeof(string)));
            Assert.False(TypeHelper.IsAnonymousType(typeof(IDictionary<object, object>)));
            Assert.True(TypeHelper.IsAnonymousType((new { A = "a", B = "b" }.GetType())));
            var x = "x";
            var y = "y";
            Assert.True(TypeHelper.IsAnonymousType((new { x, y }.GetType())));
        }

        [Fact]
        public void IsAnonymousTypeNullTest()
        {
            Assert.ThrowsArgumentNull(() => TypeHelper.IsAnonymousType(null), "type");
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/UrlRewriterHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class UrlRewriterHelperTest
    {
        [Fact]
        public void WasRequestRewritten_FalseIfUrlRewriterIsTurnedOff()
        {
            // Arrange
            UrlRewriterHelper helper = new UrlRewriterHelper();
            UrlRewriteMocks request = CreateMockContext(isUrlRewriteOnForServer: false, isUrlRewriteOnForRequest: false);

            // Act
            bool result = helper.WasRequestRewritten(request.Context.Object);

            // Assert
            Assert.False(result);
            request.WorkerRequest.Verify();
            request.WorkerRequest.Verify(wr => wr.GetServerVariable(UrlRewriterHelper.UrlWasRewrittenServerVar), Times.Never());
        }

        [Fact]
        public void WasRequestRewritten_FalseIfUrlRewriterIsTurnedOnButRequestWasNotRewritten()
        {
            // Arrange
            UrlRewriterHelper helper = new UrlRewriterHelper();
            UrlRewriteMocks request = CreateMockContext(isUrlRewriteOnForServer: true, isUrlRewriteOnForRequest: false);

            // Act
            bool result = helper.WasRequestRewritten(request.Context.Object);

            // Assert
            Assert.False(result);
            request.WorkerRequest.Verify();
        }

        [Fact]
        public void WasRequestRewritten_TrueIfUrlRewriterIsTurnedOnAndRequestWasRewritten()
        {
            // Arrange
            UrlRewriterHelper helper = new UrlRewriterHelper();
            UrlRewriteMocks request = CreateMockContext(isUrlRewriteOnForServer: true, isUrlRewriteOnForRequest: true);

            // Act
            bool result = helper.WasRequestRewritten(request.Context.Object);

            // Assert
            Assert.True(result);
            request.WorkerRequest.Verify();
        }

        [Fact]
        public void WasRequestRewritten_ChecksIfUrlRewriterIsTurnedOnOnlyOnce()
        {
            // Arrange
            UrlRewriterHelper helper = new UrlRewriterHelper();
            UrlRewriteMocks request1 = CreateMockContext(isUrlRewriteOnForServer: false, isUrlRewriteOnForRequest: false);
            UrlRewriteMocks request2 = CreateMockContext(isUrlRewriteOnForServer: false, isUrlRewriteOnForRequest: false);

            // Act
            bool result1 = helper.WasRequestRewritten(request1.Context.Object);
            bool result2 = helper.WasRequestRewritten(request2.Context.Object);

            // Assert
            request1.WorkerRequest.Verify(c => c.GetServerVariable(UrlRewriterHelper.UrlRewriterEnabledServerVar), Times.Once());
            request2.WorkerRequest.Verify(c => c.GetServerVariable(UrlRewriterHelper.UrlRewriterEnabledServerVar), Times.Never());
            Assert.False(result1);
            Assert.False(result2);
        }

        [Fact]
        public void WasRequestRewritten_ChecksRequest_OnlyOnce_Positive()
        {
            // Arrange
            UrlRewriterHelper helper = new UrlRewriterHelper();
            UrlRewriteMocks request1 = CreateMockContext(isUrlRewriteOnForServer: true, isUrlRewriteOnForRequest: true);

            // Act
            bool result1 = helper.WasRequestRewritten(request1.Context.Object);
            bool result2 = helper.WasRequestRewritten(request1.Context.Object);

            // Assert
            request1.WorkerRequest.Verify(c => c.GetServerVariable(UrlRewriterHelper.UrlWasRewrittenServerVar), Times.Once());
            Assert.True(result1);
            Assert.True(result2);
        }

        [Fact]
        public void WasRequestRewritten_ChecksRequest_OnlyOnce_Negative()
        {
            // Arrange
            UrlRewriterHelper helper = new UrlRewriterHelper();
            UrlRewriteMocks request1 = CreateMockContext(isUrlRewriteOnForServer: true, isUrlRewriteOnForRequest: false);

            // Act
            bool result1 = helper.WasRequestRewritten(request1.Context.Object);
            bool result2 = helper.WasRequestRewritten(request1.Context.Object);

            // Assert
            request1.WorkerRequest.Verify(c => c.GetServerVariable(UrlRewriterHelper.UrlWasRewrittenServerVar), Times.Once());
            Assert.False(result1);
            Assert.False(result2);
        }

        private UrlRewriteMocks CreateMockContext(bool isUrlRewriteOnForServer, bool isUrlRewriteOnForRequest)
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();

            Mock<HttpWorkerRequest> mockWorkerRequest = new Mock<HttpWorkerRequest>();
            mockContext.As<IServiceProvider>().Setup(sp => sp.GetService(typeof(HttpWorkerRequest))).Returns(mockWorkerRequest.Object);

            if (isUrlRewriteOnForServer)
            {
                mockWorkerRequest.Setup(wr => wr.GetServerVariable(UrlRewriterHelper.UrlRewriterEnabledServerVar)).Returns("On!").Verifiable();
            }
            else
            {
                mockWorkerRequest.Setup(wr => wr.GetServerVariable(UrlRewriterHelper.UrlRewriterEnabledServerVar)).Returns((string)null).Verifiable();
            }

            if (isUrlRewriteOnForRequest)
            {
                mockWorkerRequest.Setup(wr => wr.GetServerVariable(UrlRewriterHelper.UrlWasRewrittenServerVar)).Returns("Yup!").Verifiable();
            }
            else
            {
                // this won't be called if rewrite is off for the server
                mockWorkerRequest.Setup(wr => wr.GetServerVariable(UrlRewriterHelper.UrlWasRewrittenServerVar)).Returns((string)null);
            }

            NameValueCollection serverVars = new NameValueCollection();
            mockContext.Setup(c => c.Request.ServerVariables).Returns(serverVars);
            mockContext.Setup(c => c.Request.ApplicationPath).Returns("/myapp");

            mockContext.Setup(c => c.Items).Returns(new HybridDictionary());

            return new UrlRewriteMocks()
            {
                Context = mockContext,
                WorkerRequest = mockWorkerRequest,
            };
        }

        private class UrlRewriteMocks
        {
            public Mock<HttpContextBase> Context { get; set; }
            public Mock<HttpWorkerRequest> WorkerRequest { get; set; }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Utils/UrlUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class UrlUtilTest
    {
        [Fact]
        public void GenerateClientUrl_ResolvesVirtualPath_WithApplicationAtRoot()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/"),
                                   __ = Utils.CreateHttpRuntime("/"))
                {
                    // Arrange
                    var vpath = "~/";
                    var href = "~/world/test.aspx";
                    var expected = "/world/test.aspx";
                    var context = new HttpContextWrapper(HttpContext.Current);
                    var page = new MockPage { VirtualPath = vpath, Context = context };

                    // Act
                    var actual1 = UrlUtil.GenerateClientUrl(context, vpath, href);
                    var actual2 = page.Href(href);

                    // Assert
                    Assert.Equal(expected, actual1);
                    Assert.Equal(expected, actual2);
                }
            });
        }

        [Fact]
        public void GenerateClientUrl_ResolvesVirtualPathWithSubfolder_WithApplicationPath()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx"),
                                   __ = Utils.CreateHttpRuntime("/WebSite1/"))
                {
                    // Arrange
                    var vpath = "~/subfolder1/default.aspx";
                    var href = "~/world/test.aspx";
                    var expected = "/WebSite1/world/test.aspx";
                    var context = new HttpContextWrapper(HttpContext.Current);
                    var page = new MockPage() { VirtualPath = vpath, Context = context };

                    // Act
                    var actual1 = UrlUtil.GenerateClientUrl(context, vpath, href);
                    var actual2 = page.Href(href);

                    // Assert
                    Assert.Equal(expected, actual1);
                    Assert.Equal(expected, actual2);
                }
            });
        }

        [Fact]
        public void GenerateClientUrl_ResolvesVirtualPath_WithApplicationPath()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/WebSite1/default.aspx"),
                                   __ = Utils.CreateHttpRuntime("/WebSite1/"))
                {
                    // Arrange
                    var vpath = "~/default.aspx";
                    var href = "~/world/test.aspx";
                    var expected = "/WebSite1/world/test.aspx";
                    var context = new HttpContextWrapper(HttpContext.Current);
                    var page = new MockPage() { VirtualPath = vpath, Context = context };

                    // Act
                    var actual1 = UrlUtil.GenerateClientUrl(context, vpath, href);
                    var actual2 = page.Href(href);

                    // Assert
                    Assert.Equal(expected, actual1);
                    Assert.Equal(expected, actual2);
                }
            });
        }

        [Fact]
        public void GenerateClientUrl_ResolvesRelativePathToSubfolder_WithApplicationPath()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx"),
                                   __ = Utils.CreateHttpRuntime("/WebSite1/"))
                {
                    // Arrange
                    var vpath = "~/subfolder1/default.aspx";
                    var href = "world/test.aspx";
                    var expected = "/WebSite1/subfolder1/world/test.aspx";
                    var context = new HttpContextWrapper(HttpContext.Current);
                    var page = new MockPage() { VirtualPath = vpath, Context = context };

                    // Act
                    var actual1 = UrlUtil.GenerateClientUrl(context, vpath, href);
                    var actual2 = page.Href(href);

                    // Assert
                    Assert.Equal(expected, actual1);
                    Assert.Equal(expected, actual2);
                }
            });
        }

        [Fact]
        public void GenerateClientUrl_ResolvesVirtualPath_WithUrlRewrite()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Arrange
                var vpath = "~/subfolder1/default.aspx";
                var href = "world/test.aspx";
                var expected = "/subfolder1/world/test.aspx";
                var contextMock = GetMockHttpContext(true);
                contextMock.Setup(c => c.Request.RawUrl).Returns("/subfolder1/default.aspx");
                contextMock.Setup(c => c.Request.Path).Returns("/myapp/subfolder1/default.aspx");
                    
                // Act
                var actual1 = UrlUtil.GenerateClientUrl(contextMock.Object, vpath, href);

                // Assert
                Assert.Equal(expected, actual1);
            });
        }

        [Fact]
        public void BuildUrlEncodesPagePart()
        {
            // Arrange
            var page = "This is a really bad name for a page";
            var expected = "This%20is%20a%20really%20bad%20name%20for%20a%20page";

            // Act
            string query;
            var path = UrlUtil.BuildUrl(page, out query);

            // Assert
            Assert.Equal(path + query, expected);
        }

        [Fact]
        public void BuildUrlAppendsNonAnonymousTypesToPathPortion()
        {
            // Arrange
            object[] pathParts = new object[] { "part", Decimal.One, 1.25f };
            var page = "home";

            // Act
            string query;
            var path = UrlUtil.BuildUrl(page, out query, pathParts);

            // Assert
            Assert.Equal(path + query, page + "/part/1/1.25");
        }

        [Fact]
        public void BuildUrlEncodesAppendedPathPortion()
        {
            // Arrange
            object[] pathParts = new object[] { "path portion", "ζ" };
            var page = "home";

            // Act
            string query;
            var path = UrlUtil.BuildUrl(page, out query, pathParts);

            // Assert
            Assert.Equal(path + query, page + "/path%20portion/%ce%b6");
        }

        [Fact]
        public void BuildUrlAppendsAnonymousObjectsToQueryString()
        {
            // Arrange
            var page = "home";
            var queryString = new { sort = "FName", dir = "desc" };

            // Act
            string query;
            var path = UrlUtil.BuildUrl(page, out query, queryString);

            // Assert
            Assert.Equal(path + query, page + "?sort=FName&dir=desc");
        }

        [Fact]
        public void BuildUrlAppendsMultipleAnonymousObjectsToQueryString()
        {
            // Arrange
            var page = "home";
            var queryString1 = new { sort = "FName", dir = "desc" };
            var queryString2 = new { view = "Activities", page = 7 };

            // Act
            string query;
            var path = UrlUtil.BuildUrl(page, out query, queryString1, queryString2);

            // Assert
            Assert.Equal(path + query, page + "?sort=FName&dir=desc&view=Activities&page=7");
        }

        [Fact]
        public void BuildUrlEncodesQueryStringKeysAndValues()
        {
            // Arrange
            var page = "home";
            var queryString = new { ζ = "my=value&", mykey = "<π" };

            // Act
            string query;
            var path = UrlUtil.BuildUrl(page, out query, queryString);

            // Assert
            Assert.Equal(path + query, page + "?%ce%b6=my%3dvalue%26&mykey=%3c%cf%80");
        }

        [Fact]
        public void BuildUrlGeneratesPathPartsAndQueryString()
        {
            // Arrange
            var page = "home";

            // Act
            string query;
            var path = UrlUtil.BuildUrl(page, out query, "products", new { cat = 37 }, "furniture", new { sort = "name", dir = "desc" });

            // Assert
            Assert.Equal(path + query, page + "/products/furniture?cat=37&sort=name&dir=desc");
        }

        [Fact]
        public void UrlAnonymousObjectTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                using (IDisposable _ = Utils.CreateHttpContext("default.aspx", "http://localhost/"),
                                   __ = Utils.CreateHttpRuntime("/"))
                {
                    Assert.Equal("/world/test.cshtml?Prop1=value1",
                                 UrlUtil.GenerateClientUrl(new HttpContextWrapper(HttpContext.Current), "~/world/page.cshtml", "test.cshtml", new { Prop1 = "value1" }));
                    Assert.Equal("/world/test.cshtml?Prop1=value1&Prop2=value2",
                                 UrlUtil.GenerateClientUrl(new HttpContextWrapper(HttpContext.Current), "~/world/page.cshtml", "test.cshtml", new { Prop1 = "value1", Prop2 = "value2" }));
                }
            });
        }

        [Fact]
        public void GenerateClientUrlWithAbsoluteContentPathAndRewritingDisabled()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = GetMockHttpContext(isUrlRewriteOn: false);

            // Act
            string returnedUrl = UrlUtil.GenerateClientUrl(mockHttpContext.Object, "should remain unchanged");

            // Assert
            Assert.Equal("should remain unchanged", returnedUrl);
        }

        [Fact]
        public void GenerateClientUrlWithAbsoluteContentPathAndRewritingEnabled()
        {
            UrlUtil.ResetUrlRewriterHelper(); // Reset the "is URL rewriting enabled?" cache

            // Arrange
            Mock<HttpContextBase> mockHttpContext = GetMockHttpContext(isUrlRewriteOn: true);
            mockHttpContext.Setup(c => c.Request.RawUrl).Returns("/quux/foo/bar/baz");
            mockHttpContext.Setup(c => c.Request.Path).Returns("/myapp/foo/bar/baz");

            // Act
            string returnedUrl = UrlUtil.GenerateClientUrl(mockHttpContext.Object, "/myapp/some/absolute/path?alpha=bravo");

            // Assert
            Assert.Equal("/quux/some/absolute/path?alpha=bravo", returnedUrl);
        }

        [Fact]
        public void GenerateClientUrlWithAppRelativeContentPathAndRewritingDisabled()
        {
            // Arrange
            Mock<HttpContextBase> mockHttpContext = GetMockHttpContext(isUrlRewriteOn: false);

            // Act
            string returnedUrl = UrlUtil.GenerateClientUrl(mockHttpContext.Object, "~/foo/bar?alpha=bravo");

            // Assert
            Assert.Equal("/myapp/foo/bar?alpha=bravo", returnedUrl);
        }

        [Fact]
        public void GenerateClientUrlWithAppRelativeContentPathAndRewritingEnabled()
        {
            UrlUtil.ResetUrlRewriterHelper(); // Reset the "is URL rewriting enabled?" cache

            // Arrange
            Mock<HttpContextBase> mockHttpContext = GetMockHttpContext(isUrlRewriteOn: true);
            mockHttpContext.Setup(c => c.Request.RawUrl).Returns("/quux/foo/baz");
            mockHttpContext.Setup(c => c.Request.Path).Returns("/myapp/foo/baz");

            // Act
            string returnedUrl = UrlUtil.GenerateClientUrl(mockHttpContext.Object, "~/foo/bar?alpha=bravo");

            // Assert
            Assert.Equal("/quux/foo/bar?alpha=bravo", returnedUrl);
        }

        [Fact]
        public void GenerateClientUrlWithEmptyContentPathReturnsEmptyString()
        {
            // Act
            string returnedUrl = UrlUtil.GenerateClientUrl(null, "");

            // Assert
            Assert.Equal("", returnedUrl);
        }

        [Fact]
        public void GenerateClientUrlWithNullContentPathReturnsNull()
        {
            // Act
            string returnedUrl = UrlUtil.GenerateClientUrl(null, null);

            // Assert
            Assert.Null(returnedUrl);
        }

        [Fact]
        public void GenerateClientUrlWithOnlyQueryStringForContentPathReturnsOriginalContentPath()
        {
            // Act
            string returnedUrl = UrlUtil.GenerateClientUrl(null, "?foo=bar");

            // Assert
            Assert.Equal("?foo=bar", returnedUrl);
        }

        [Fact]
        public void MakeAbsoluteFromDirectoryToParent()
        {
            // Act
            string returnedUrl = UrlUtil.MakeAbsolute("/Account/Register", "../Account");

            // Assert
            Assert.Equal("/Account", returnedUrl);
        }

        [Fact]
        public void MakeAbsoluteFromDirectoryToSelf()
        {
            // Act
            string returnedUrl = UrlUtil.MakeAbsolute("/foo/", "./");

            // Assert
            Assert.Equal("/foo/", returnedUrl);
        }

        [Fact]
        public void MakeAbsoluteFromFileToFile()
        {
            // Act
            string returnedUrl = UrlUtil.MakeAbsolute("/foo", "bar");

            // Assert
            Assert.Equal("/bar", returnedUrl);
        }

        [Fact]
        public void MakeAbsoluteFromFileWithQueryToFile()
        {
            // Act
            string returnedUrl = UrlUtil.MakeAbsolute("/foo/bar?alpha=bravo", "baz");

            // Assert
            Assert.Equal("/foo/baz", returnedUrl);
        }

        [Fact]
        public void MakeAbsoluteFromRootToSelf()
        {
            // Act
            string returnedUrl = UrlUtil.MakeAbsolute("/", "./");

            // Assert
            Assert.Equal("/", returnedUrl);
        }

        [Fact]
        public void MakeRelativeFromFileToDirectory()
        {
            // Act
            string returnedUrl = UrlUtil.MakeRelative("/foo/bar", "/foo/");

            // Assert
            Assert.Equal("./", returnedUrl);
        }

        [Fact]
        public void MakeRelativeFromFileToDirectoryWithQueryString()
        {
            // Act
            string returnedUrl = UrlUtil.MakeRelative("/foo/bar", "/foo/?alpha=bravo");

            // Assert
            Assert.Equal("./?alpha=bravo", returnedUrl);
        }

        [Fact]
        public void MakeRelativeFromFileToFile()
        {
            // Act
            string returnedUrl = UrlUtil.MakeRelative("/foo/bar", "/baz/quux");

            // Assert
            Assert.Equal("../baz/quux", returnedUrl);
        }

        [Fact]
        public void MakeRelativeFromFileToFileWithQuery()
        {
            // Act
            string returnedUrl = UrlUtil.MakeRelative("/foo/bar", "/baz/quux?alpha=bravo");

            // Assert
            Assert.Equal("../baz/quux?alpha=bravo", returnedUrl);
        }

        [Fact]
        public void MakeRelativeFromFileWithQueryToFileWithQuery()
        {
            // Act
            string returnedUrl = UrlUtil.MakeRelative("/foo/bar?charlie=delta", "/baz/quux?alpha=bravo");

            // Assert
            Assert.Equal("../baz/quux?alpha=bravo", returnedUrl);
        }

        [Fact]
        public void MakeRelativeFromRootToRoot()
        {
            // Act
            string returnedUrl = UrlUtil.MakeRelative("/", "/");

            // Assert
            Assert.Equal("./", returnedUrl);
        }

        [Fact]
        public void MakeRelativeFromRootToRootWithQueryString()
        {
            // Act
            string returnedUrl = UrlUtil.MakeRelative("/", "/?foo=bar");

            // Assert
            Assert.Equal("./?foo=bar", returnedUrl);
        }

        internal static Mock<HttpContextBase> GetMockHttpContext(bool isUrlRewriteOn)
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();

            Mock<HttpWorkerRequest> mockWorkerRequest = new Mock<HttpWorkerRequest>();
            mockContext.As<IServiceProvider>().Setup(sp => sp.GetService(typeof(HttpWorkerRequest))).Returns(mockWorkerRequest.Object);
            mockWorkerRequest.Setup(wr => wr.GetServerVariable(UrlRewriterHelper.UrlRewriterEnabledServerVar)).Returns("On!");
            if (isUrlRewriteOn)
            {
                mockWorkerRequest.Setup(wr => wr.GetServerVariable(UrlRewriterHelper.UrlWasRewrittenServerVar)).Returns("Yup!");
            }

            NameValueCollection serverVars = new NameValueCollection();
            mockContext.Setup(c => c.Request.ServerVariables).Returns(serverVars);
            mockContext.Setup(c => c.Request.ApplicationPath).Returns("/myapp");

            mockContext.Setup(c => c.Items).Returns(new HybridDictionary());

            return mockContext;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Validation/ValidationHelperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Web.Mvc;
using System.Web.WebPages.Html;
using System.Web.WebPages.Scope;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Validation.Test
{
    [Xunit.Collection("Uses ScopeStorage or ViewEngines.Engines")]
    public class ValidationHelperTest : IDisposable
    {
        [Fact]
        public void FormFieldKeyIsCommonToModelStateAndValidationHelper()
        {
            // Arrange
            const string key = "_FORM";
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.Equal(key, ModelStateDictionary.FormFieldKey);
            Assert.Equal(key, validationHelper.FormField);
        }

        [Fact]
        public void AddThrowsIfFieldIsEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: null), "field");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: String.Empty), "field");
        }

        [Fact]
        public void AddThrowsIfValidatorsParamsArrayIsNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNull(() => validationHelper.Add("foo", null), "validators");
        }

        [Fact]
        public void AddThrowsIfValidatorsAreNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNull(() => validationHelper.Add("foo", Validator.Required(), null, Validator.Range(0, 10)), "validators");
        }

        [Fact]
        public void RequiredReturnsErrorMessageIfFieldIsNotPresentInForm()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is required.";
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            validationHelper.RequireField("foo", message);
            var results = validationHelper.Validate();

            // Assert
            ValidationResult result = Assert.Single(results);
            Assert.Equal(message, result.ErrorMessage);
        }

        [Fact]
        public void RequiredReturnsErrorMessageIfFieldIsEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is required.";
            ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "" }));

            // Act
            validationHelper.RequireField("foo", message);
            var results = validationHelper.Validate();

            // Assert
            ValidationResult result = Assert.Single(results);
            Assert.Equal(message, result.ErrorMessage);
        }

        [Fact]
        public void RequiredReturnsNoValidationResultsIfFieldIsPresent()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is required.";
            ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "some value" }));

            // Act
            validationHelper.RequireField("foo", message);
            var results = validationHelper.Validate();

            // Assert
            Assert.Empty(results);
        }

        [Fact]
        public void RequiredUsesDefaultErrorMessageIfNoValueIsProvided()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            validationHelper.RequireField("foo");
            var results = validationHelper.Validate();

            // Assert
            ValidationResult result = Assert.Single(results);
            Assert.Equal("This field is required.", result.ErrorMessage);
        }

        [Fact]
        public void RequiredReturnsValidationResultForEachFieldThatFailed()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "This field is required.";
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            validationHelper.RequireFields("foo", "bar");
            var results = validationHelper.Validate();

            // Assert
            Assert.Equal(2, results.Count());
            Assert.Equal(message, results.First().ErrorMessage);
            Assert.Equal("foo", results.First().MemberNames.Single());

            Assert.Equal(message, results.Last().ErrorMessage);
            Assert.Equal("bar", results.Last().MemberNames.Single());
        }

        [Fact]
        public void RequiredReturnsValidationResultForEachFieldThatFailedWhenFieldsIsEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "This field is required.";
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            validationHelper.RequireFields("foo", "bar");
            var results = validationHelper.Validate(fields: null);

            // Assert
            Assert.Equal(2, results.Count());
            Assert.Equal(message, results.First().ErrorMessage);
            Assert.Equal("foo", results.First().MemberNames.Single());

            Assert.Equal(message, results.Last().ErrorMessage);
            Assert.Equal("bar", results.Last().MemberNames.Single());
        }

        [Fact]
        public void GetValidationHtmlThrowsIfArgumentIsNullOrEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.For(field: null), "field");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.For(field: String.Empty), "field");
        }

        [Fact]
        public void RequireFieldThrowsIfValueIsNullOrEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: null), "field");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: String.Empty), "field");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: null, errorMessage: "baz"), "field");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireField(field: String.Empty, errorMessage: null), "field");
        }

        [Fact]
        public void RequireFieldsThrowsIfFieldsAreNullOrHasEmptyValues()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNull(() => validationHelper.RequireFields(fields: null), "fields");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireFields(fields: new[] { "foo", null }), "field");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.RequireFields(fields: new[] { "foo", "" }), "field");
        }

        [Fact]
        public void AddThrowsIfFieldIsNullOrEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: null), "field");
            Assert.ThrowsArgumentNullOrEmptyString(() => validationHelper.Add(field: String.Empty), "field");
        }

        [Fact]
        public void AddThrowsIfValidatorsIsNullOrAnyValidatorIsNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act and Assert
            Assert.ThrowsArgumentNull(() => validationHelper.Add(field: "foo", validators: null), "validators");
            Assert.ThrowsArgumentNull(() => validationHelper.Add(field: "foo", validators: new[] { Validator.DateTime(), null }), "validators");
        }

        [Fact]
        public void AddFormErrorCallsMethodInUnderlyingModelStateDictionary()
        {
            // Arrange
            var message = "This is a form error.";
            var dictionary = new ModelStateDictionary();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(), dictionary);

            // Act
            validationHelper.AddFormError(message);

            // Assert
            Assert.Equal(message, dictionary["_FORM"].Errors.Single());
        }

        [Fact]
        public void GetValidationHtmlForRequired()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is required.";
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            validationHelper.RequireField("foo", message);
            var validationHtml = validationHelper.For("foo");

            // Assert
            Assert.Equal(@"data-val-required=""Foo is required."" data-val=""true""", validationHtml.ToString());
        }

        [Fact]
        public void ValidateReturnsAnEmptySequenceIfNoValidationsAreRegistered()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            var results = validationHelper.Validate();

            // Assert
            Assert.False(results.Any());
        }

        [Fact]
        public void ValidatePopulatesModelStateDictionary()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var modelStateDictionary = new ModelStateDictionary();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);

            // Act
            validationHelper.RequireFields(new[] { "foo", "bar" });
            validationHelper.Validate();

            // Assert
            Assert.False(modelStateDictionary.IsValid);
            Assert.False(modelStateDictionary.IsValidField("foo"));
            Assert.False(modelStateDictionary.IsValidField("bar"));
            Assert.Equal("This field is required.", modelStateDictionary["foo"].Errors.Single());
            Assert.Equal("This field is required.", modelStateDictionary["bar"].Errors.Single());
        }

        [Fact]
        public void IsValidPopulatesModelStateDictionary()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var modelStateDictionary = new ModelStateDictionary();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);

            // Act
            validationHelper.RequireFields("foo", "bar");
            validationHelper.IsValid();

            // Assert
            Assert.False(modelStateDictionary.IsValid);
            Assert.False(modelStateDictionary.IsValidField("foo"));
            Assert.False(modelStateDictionary.IsValidField("bar"));
            Assert.Equal("This field is required.", modelStateDictionary["foo"].Errors.Single());
            Assert.Equal("This field is required.", modelStateDictionary["bar"].Errors.Single());
        }

        [Fact]
        public void GetErrorsPopulatesModelStateDictionary()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var modelStateDictionary = new ModelStateDictionary();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);

            // Act
            validationHelper.RequireFields("foo", "bar");
            validationHelper.GetErrors();

            // Assert
            Assert.False(modelStateDictionary.IsValid);
            Assert.False(modelStateDictionary.IsValidField("foo"));
            Assert.False(modelStateDictionary.IsValidField("bar"));
            Assert.Equal("This field is required.", modelStateDictionary["foo"].Errors.Single());
            Assert.Equal("This field is required.", modelStateDictionary["bar"].Errors.Single());
        }

        [Fact]
        public void GetErrorsReturnsAnEmptySequenceIfNoValidationsAreRegistered()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            var results = validationHelper.GetErrors();

            // Assert
            Assert.False(results.Any());
        }

        [Fact]
        public void GetErrorsReturnsErrorsAddedViaAddError()
        {
            // Arrange
            var modelStateDictionary = new ModelStateDictionary();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);

            // Act
            modelStateDictionary.AddError("foo", "Foo error");
            var errors = validationHelper.GetErrors("foo");

            // Assert
            Assert.Equal(new[] { "Foo error" }, errors);
        }

        [Fact]
        public void GetErrorsReturnsFormErrors()
        {
            // Arrange
            string error = "Unable to connect to remote servers.";
            var modelStateDictionary = new ModelStateDictionary();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);

            // Act
            validationHelper.AddFormError(error);
            var errors = validationHelper.GetErrors();

            // Assert
            Assert.Equal(error, errors.Single());
        }

        [Fact]
        public void InvokingValidateMultipleTimesDoesNotCauseErrorMessagesToBeDuplicated()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var modelStateDictionary = new ModelStateDictionary();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(), modelStateDictionary);

            // Act
            validationHelper.RequireField("foo", "Foo is required.");
            validationHelper.RequireField("bar", "Bar is required.");
            validationHelper.Validate();
            Assert.False(validationHelper.IsValid());
            validationHelper.Validate();
            validationHelper.Validate();

            // Assert
            Assert.False(modelStateDictionary.IsValid);
            Assert.False(modelStateDictionary.IsValidField("foo"));
            Assert.False(modelStateDictionary.IsValidField("bar"));
            Assert.Equal("Foo is required.", modelStateDictionary["foo"].Errors.Single());
            Assert.Equal("Bar is required.", modelStateDictionary["bar"].Errors.Single());
        }

        [Fact]
        public void AddWorksForCustomValidator()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is not an odd number.";
            var oddValidator = new Mock<IValidator>();
            oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
            {
                var context = Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
                var value = Int32.Parse(context.Request.Form["foo"]);

                if (value % 2 != 0)
                {
                    return ValidationResult.Success;
                }
                return new ValidationResult(message);
            }).Verifiable();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "6" }));

            // Act
            validationHelper.Add("foo", oddValidator.Object);
            var results = validationHelper.Validate();

            // Assert
            ValidationResult result = Assert.Single(results);
            Assert.Equal(message, result.ErrorMessage);
            oddValidator.Verify();
        }

        [Fact]
        public void ValidateRunsForSpecifiedFields()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is not an odd number.";
            var oddValidator = new Mock<IValidator>();
            oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
            {
                var context = Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
                if (context.Request.Form["foo"].IsEmpty())
                {
                    return ValidationResult.Success;
                }
                int value = context.Request.Form["foo"].AsInt();
                if (value % 2 != 0)
                {
                    return ValidationResult.Success;
                }
                return new ValidationResult(message);
            }).Verifiable();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "", bar = "" }));

            // Act
            validationHelper.Add(new[] { "foo", "bar" }, oddValidator.Object);
            validationHelper.RequireField("foo");
            var results = validationHelper.Validate("foo");

            // Assert
            ValidationResult result = Assert.Single(results);
            Assert.Equal("This field is required.", result.ErrorMessage);
        }

        [Fact]
        public void GetErrorsReturnsAllErrorsIfNoParametersAreSpecified()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is not an odd number.";
            var oddValidator = new Mock<IValidator>();
            oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
            {
                var context = Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
                if (context.Request.Form["foo"].IsEmpty())
                {
                    return ValidationResult.Success;
                }
                int value = context.Request.Form["foo"].AsInt();
                if (value % 2 != 0)
                {
                    return ValidationResult.Success;
                }
                return new ValidationResult(message);
            }).Verifiable();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "4", bar = "" }));

            // Act
            validationHelper.Add("foo", oddValidator.Object);
            validationHelper.RequireFields(new[] { "bar", "foo" });
            var result = validationHelper.GetErrors();

            // Assert
            Assert.Equal(2, result.Count());
            Assert.Equal("Foo is not an odd number.", result.First());
            Assert.Equal("This field is required.", result.Last());
        }

        [Fact]
        public void IsValidReturnsTrueIfAllValuesPassValidation()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is not an odd number.";
            var oddValidator = new Mock<IValidator>();
            oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
            {
                var context = Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
                if (context.Request.Form["foo"].IsEmpty())
                {
                    return ValidationResult.Success;
                }
                int value = context.Request.Form["foo"].AsInt();
                if (value % 2 != 0)
                {
                    return ValidationResult.Success;
                }
                return new ValidationResult(message);
            }).Verifiable();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "5", bar = "2" }));

            // Act
            validationHelper.Add(new[] { "foo", "bar" }, oddValidator.Object);
            validationHelper.RequireField("foo");
            var result = validationHelper.IsValid();

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void IsValidValidatesSpecifiedFields()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            string message = "Foo is not an odd number.";
            var oddValidator = new Mock<IValidator>();
            oddValidator.Setup(c => c.Validate(It.IsAny<ValidationContext>())).Returns<ValidationContext>(v =>
            {
                var context = Assert.IsAssignableFrom<HttpContextBase>(v.ObjectInstance);
                int value;
                if (!Int32.TryParse(context.Request.Form["foo"], out value))
                {
                    return ValidationResult.Success;
                }
                if (value % 2 != 0)
                {
                    return ValidationResult.Success;
                }
                return new ValidationResult(message);
            }).Verifiable();
            ValidationHelper validationHelper = GetValidationHelper(GetContext(new { foo = "3", bar = "" }));

            // Act
            validationHelper.Add(new[] { "foo", "bar" }, oddValidator.Object);
            validationHelper.RequireFields(new[] { "foo", "bar" });
            var result = validationHelper.IsValid("foo");

            // Assert
            Assert.True(result);
        }

        [Fact]
        public void GetValidationHtmlReturnsNullIfNoRulesAreRegistered()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Assert
            var validationAttributes = validationHelper.For("bar");

            // Assert
            Assert.Null(validationAttributes);
        }

        [Fact]
        public void GetValidationHtmlReturnsAttributesForRegisteredValidators()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = new Mock<IValidator>();
            var clientRules = new ModelClientValidationRule { ValidationType = "foo", ErrorMessage = "Foo error." };
            clientRules.ValidationParameters["qux"] = "some data";
            validator.Setup(c => c.ClientValidationRule).Returns(clientRules).Verifiable();
            var expected = @"data-val-required=""This field is required."" data-val-foo=""Foo error."" data-val-foo-qux=""some data"" data-val=""true""";

            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Act
            validationHelper.RequireField("foo");
            validationHelper.Add("foo", validator.Object);
            var validationAttributes = validationHelper.For("foo");

            // Assert
            Assert.Equal(expected, validationAttributes.ToString());
        }

        [Fact]
        public void GetValidationHtmlHtmlEncodesAttributeValues()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = new Mock<IValidator>();
            var clientRules = new ModelClientValidationRule { ValidationType = "biz", ErrorMessage = "<Biz error.>" };
            clientRules.ValidationParameters["qux"] = "<some ' data>";
            validator.Setup(c => c.ClientValidationRule).Returns(clientRules).Verifiable();
            var expected = @"data-val-required=""This field is required."" data-val-biz=""&lt;Biz error.&gt;"" data-val-biz-qux=""&lt;some &#39; data&gt;"" data-val=""true""";

            // Act
            ValidationHelper validationHelper = GetValidationHelper(GetContext());

            // Assert
            validationHelper.RequireField("foo");
            validationHelper.Add("foo", validator.Object);
            var validationAttributes = validationHelper.For("foo");

            // Assert
            Assert.Equal(expected, validationAttributes.ToString());
        }

        [Fact]
        public void GetValidationFromClientValidationRulesThrowsIfValidationTypeIsNullOrEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var clientRule = new ModelClientValidationRule { ValidationType = null };

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
                                                              "Validation type names in unobtrusive client validation rules cannot be empty. Client rule type: System.Web.Mvc.ModelClientValidationRule");

            clientRule.ValidationType = String.Empty;
            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
                                                              "Validation type names in unobtrusive client validation rules cannot be empty. Client rule type: System.Web.Mvc.ModelClientValidationRule");
        }

        [Fact]
        public void GetValidationFromClientValidationRulesThrowsIfSameValidationTypeIsSpecifiedMultipleTimes()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var clientRule1 = new ModelClientValidationRule { ValidationType = "foo" };
            var clientRule2 = new ModelClientValidationRule { ValidationType = "foo" };

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule1, clientRule2 }),
                                                              "Validation type names in unobtrusive client validation rules must be unique. The following validation type was seen more than once: foo");
        }

        [Fact]
        public void GetValidationFromClientValidationRulesThrowsIfValidationTypeDoesNotContainAllLowerCaseCharacters()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var clientRule = new ModelClientValidationRule { ValidationType = "Foo" };

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
                                                              "Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"Foo\", client rule type: System.Web.Mvc.ModelClientValidationRule");

            clientRule.ValidationType = "bAr";
            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
                                                              "Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"bAr\", client rule type: System.Web.Mvc.ModelClientValidationRule");

            clientRule.ValidationType = "bar123";
            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
                                                              "Validation type names in unobtrusive client validation rules must consist of only lowercase letters. Invalid name: \"bar123\", client rule type: System.Web.Mvc.ModelClientValidationRule");
        }

        [Fact]
        public void GetValidationFromClientValidationRulesThrowsIfValidationParamaterContainsNonAlphaNumericCharacters()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var clientRule = new ModelClientValidationRule { ValidationType = "required" };
            clientRule.ValidationParameters["min^"] = "some-val";

            // Act and Assert
            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
                                                              "Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: min^, client rule type: System.Web.Mvc.ModelClientValidationRule");

            clientRule.ValidationParameters.Clear();
            clientRule.ValidationParameters["Min"] = "some-val";

            Assert.Throws<InvalidOperationException>(() => ValidationHelper.GenerateHtmlFromClientValidationRules(new[] { clientRule }),
                                                              "Validation parameter names in unobtrusive client validation rules must start with a lowercase letter and consist of only lowercase letters or digits. Validation parameter name: Min, client rule type: System.Web.Mvc.ModelClientValidationRule");
        }

        [Fact]
        public void DefaultValidCssClassIsNull()
        {
            Assert.Null(ValidationHelper.ValidCssClass);
        }

        [Fact]
        public void DefaultInvalidCssClassIsSameAsHtmlHelper()
        {
            Assert.Equal(HtmlHelper.DefaultValidationInputErrorCssClass, ValidationHelper.InvalidCssClass);
        }

        [Fact]
        public void InvalidCssClassIsNullIfExplicitlySetToNull()
        {
            using (ValidationHelper.OverrideScope())
            {
                ValidationHelper.InvalidCssClass = null;
                Assert.Null(ValidationHelper.InvalidCssClass);
            }
        }

        [Fact]
        public void ValidCssClassIsScopeBacked()
        {
            // Set a value
            string old = ValidationHelper.ValidCssClass;
            ValidationHelper.ValidCssClass = "outer";
            using (ScopeStorage.CreateTransientScope())
            {
                ValidationHelper.ValidCssClass = "inner";
                Assert.Equal("inner", ValidationHelper.ValidCssClass);
            }
            Assert.Equal("outer", ValidationHelper.ValidCssClass);
            ValidationHelper.ValidCssClass = old;
        }

        [Fact]
        public void InvalidCssClassIsScopeBacked()
        {
            // Set a value
            string old = ValidationHelper.InvalidCssClass;
            ValidationHelper.InvalidCssClass = "outer";
            using (ScopeStorage.CreateTransientScope())
            {
                ValidationHelper.InvalidCssClass = "inner";
                Assert.Equal("inner", ValidationHelper.InvalidCssClass);
            }
            Assert.Equal("outer", ValidationHelper.InvalidCssClass);
            ValidationHelper.InvalidCssClass = old;
        }

        [Fact]
        public void ClassForReturnsNullIfNotPost()
        {
            // Arrange
            ValidationHelper helper = GetValidationHelper();

            // Act/Assert
            Assert.Null(helper.ClassFor("foo"));
        }

        [Fact]
        public void ClassForReturnsValidClassNameIfNoErrorsAddedForField()
        {
            // Arrange
            ValidationHelper helper = GetPostValidationHelper();

            // Act/Assert
            HtmlString html = helper.ClassFor("foo");
            string str = html == null ? null : html.ToHtmlString();
            Assert.Equal(ValidationHelper.ValidCssClass, str);
        }

        [Fact]
        public void ClassForReturnsInvalidClassNameIfFieldHasErrors()
        {
            // Arrange
            ValidationHelper helper = GetPostValidationHelper();
            helper.Add("foo", new AutoFailValidator());

            // Act/Assert
            Assert.Equal(ValidationHelper.InvalidCssClass, helper.ClassFor("foo").ToHtmlString());
        }

        private static ValidationHelper GetPostValidationHelper()
        {
            HttpContextBase context = GetContext();
            Mock.Get(context.Request).SetupGet(c => c.HttpMethod).Returns("POST");
            ValidationHelper helper = GetValidationHelper(httpContext: context);
            return helper;
        }

        private static HttpContextBase GetContext(object formValues = null)
        {
            var context = new Mock<HttpContextBase>();
            var request = new Mock<HttpRequestBase>();

            var nameValueCollection = new NameValueCollection();
            if (formValues != null)
            {
                foreach (var prop in formValues.GetType().GetProperties())
                {
                    nameValueCollection.Add(prop.Name, prop.GetValue(formValues, null).ToString());
                }
            }
            request.SetupGet(c => c.Form).Returns(nameValueCollection);
            context.SetupGet(c => c.Request).Returns(request.Object);

            return context.Object;
        }

        private static ValidationHelper GetValidationHelper(HttpContextBase httpContext = null, ModelStateDictionary modelStateDictionary = null)
        {
            httpContext = httpContext ?? GetContext();
            modelStateDictionary = modelStateDictionary ?? new ModelStateDictionary();

            return new ValidationHelper(httpContext, modelStateDictionary);
        }

        private class AutoFailValidator : IValidator
        {
            public ValidationResult Validate(ValidationContext validationContext)
            {
                return new ValidationResult("Failed!");
            }

            public ModelClientValidationRule ClientValidationRule
            {
                get { throw new NotImplementedException(); }
            }
        }

        public void Dispose()
        {
            // Reset ScopeStorage (written via e.g. ValidationHelper.InvalidCssClass) between tests to avoid unexpected interactions.
            ScopeStorage.CurrentProvider = new StaticScopeStorageProvider();
            ScopeStorage.GlobalScope.Clear();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/Validation/ValidatorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Specialized;
using System.ComponentModel.DataAnnotations;
using System.Globalization;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Validation.Test
{
    public class ValidatorTest
    {
        [Fact]
        public void RequiredValidatorValidatesIfStringIsNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var requiredValidator = Validator.Required();
            var validationContext = GetValidationContext(GetContext(), "foo");

            // Act
            var result = requiredValidator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("This field is required.", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void RequiredValidatorValidatesIfStringIsEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var requiredValidator = Validator.Required();
            var validationContext = GetValidationContext(GetContext(new { foo = "" }), "foo");

            // Act
            var result = requiredValidator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("This field is required.", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void RequiredValidatorReturnsCustomErrorMessagesIfSpecified()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var requiredValidator = Validator.Required("There is no string");
            var httpContext = GetContext(new { foo = "" });
            var validationContext = GetValidationContext(httpContext, "foo");

            // Act
            var result = requiredValidator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("There is no string", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void RequiredValidatorReturnsSuccessIfNoFieldIsNotNullOrEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var requiredValidator = Validator.Required("foo");
            var validationContext = GetValidationContext(GetContext(new { foo = "some value" }), "foo");

            // Act
            var result = requiredValidator.Validate(validationContext);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void GetClientValidationRulesForRequiredValidatorWithDefaultErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var requiredValidator = Validator.Required();

            // Act
            var result = requiredValidator.ClientValidationRule;

            // Assert
            Assert.Equal("required", result.ValidationType);
            Assert.Equal("This field is required.", result.ErrorMessage);
            Assert.False(result.ValidationParameters.Any());
        }

        [Fact]
        public void GetClientValidationRulesForRequiredValidatorWithCustomErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var requiredValidator = Validator.Required("custom message");

            // Act
            var result = requiredValidator.ClientValidationRule;

            // Assert
            Assert.Equal("required", result.ValidationType);
            Assert.Equal("custom message", result.ErrorMessage);
            Assert.False(result.ValidationParameters.Any());
        }

        [Fact]
        public void RangeValidatorReturnsSuccessIfValueIsInRange()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var rangeValidator = Validator.Range(10, 12);
            var validationContext = GetValidationContext(GetContext(new { foo = 11 }), "foo");

            // Act
            var result = rangeValidator.Validate(validationContext);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void RangeValidatorReturnsDefaultErrorMessageIfValueIsNotInRange()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var rangeValidator = Validator.Range(10, 12);
            var validationContext = GetValidationContext(GetContext(new { foo = 7 }), "foo");

            // Act
            var result = rangeValidator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Value must be an integer between 10 and 12.", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void RangeValidatorReturnsDefaultErrorMessageIfValueIsNotInRangeForFloatingPointValues()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var rangeValidator = Validator.Range(10.8, 12.2);
            var validationContext = GetValidationContext(GetContext(new { foo = 7 }), "foo");

            // Act
            var result = rangeValidator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal(
                String.Format(CultureInfo.CurrentCulture, "Value must be a decimal between {0} and {1}.", 10.8, 12.2),
                result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void RangeValidatorReturnsCustomErrorMessageIfSpecified()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var rangeValidator = Validator.Range(10, 12, "Custom error message");
            var validationContext = GetValidationContext(GetContext(new { foo = 13 }), "foo");

            // Act
            var result = rangeValidator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Custom error message", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void RangeValidatorFormatsCustomErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var rangeValidator = Validator.Range(10, 12, "Valid range: {0}-{1}");
            var validationContext = GetValidationContext(GetContext(new { foo = 13 }), "foo");

            // Act
            var result = rangeValidator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Valid range: 10-12", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void GetClientValidationRulesForRangeValidatorWithDefaultErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var rangeValidator = Validator.Range(10, 12);

            // Act
            var result = rangeValidator.ClientValidationRule;

            // Assert
            Assert.Equal("range", result.ValidationType);
            Assert.Equal("Value must be an integer between 10 and 12.", result.ErrorMessage);
            Assert.Equal(10, result.ValidationParameters["min"]);
            Assert.Equal(12, result.ValidationParameters["max"]);
        }

        [Fact]
        public void GetClientValidationRulesForRangeValidatorWithCustomErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var rangeValidator = Validator.Range(10, 11, "Range: {0}-{1}");

            // Act
            var result = rangeValidator.ClientValidationRule;

            // Assert
            Assert.Equal("range", result.ValidationType);
            Assert.Equal("Range: 10-11", result.ErrorMessage);
            Assert.Equal(10, result.ValidationParameters["min"]);
            Assert.Equal(11, result.ValidationParameters["max"]);
        }

        [Fact]
        public void StringLengthValidatorReturnsSuccessIfStringLengthIsSmallerThanMaxValue()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(10);
            var validationContext = GetValidationContext(GetContext(new { baz = "hello" }), "baz");

            // Act
            var result = validator.Validate(validationContext);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void StringLengthValidatorReturnsSuccessIfStringLengthIsRangeOfMinAndMaxValue()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(10, minLength: 6);
            var validationContext = GetValidationContext(GetContext(new { bar = "woof woof" }), "bar");

            // Act
            var result = validator.Validate(validationContext);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void StringLengthValidatorReturnsFailureIfStringLengthIsLongerThanMaxValue()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(4);
            var validationContext = GetValidationContext(GetContext(new { baz = "woof woof" }), "baz");

            // Act
            var result = validator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Max length: 4.", result.ErrorMessage);
            Assert.Equal("baz", result.MemberNames.Single());
        }

        [Fact]
        public void StringLengthValidatorReturnsCustomErrorMessageIfStringLengthIsLongerThanMaxValue()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(4, errorMessage: "String must be at least {0} characters long.");
            var validationContext = GetValidationContext(GetContext(new { baz = "woof woof" }), "baz");

            // Act
            var result = validator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("String must be at least 4 characters long.", result.ErrorMessage);
            Assert.Equal("baz", result.MemberNames.Single());
        }

        [Fact]
        public void StringLengthValidatorReturnsFailureIfStringLengthIsNotInRange()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(6, 4);
            var validationContext = GetValidationContext(GetContext(new { baz = "woof woof" }), "baz");

            // Act
            var result = validator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("String must be between 4 and 6 characters.", result.ErrorMessage);
            Assert.Equal("baz", result.MemberNames.Single());
        }

        [Fact]
        public void StringLengthValidatorReturnsCustomErrorMessageIfStringLengthIsNotInRange()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(6, 4, "Range {0} - {1}");
            var validationContext = GetValidationContext(GetContext(new { baz = "woof woof" }), "baz");

            // Act
            var result = validator.Validate(validationContext);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Range 4 - 6", result.ErrorMessage);
            Assert.Equal("baz", result.MemberNames.Single());
        }

        [Fact]
        public void GetClientValidationRulesForStringLengthValidatorWithDefaultErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(6, 4);

            // Act
            var result = validator.ClientValidationRule;

            // Assert
            Assert.Equal("length", result.ValidationType);
            Assert.Equal("String must be between 4 and 6 characters.", result.ErrorMessage);
            Assert.Equal(4, result.ValidationParameters["min"]);
            Assert.Equal(6, result.ValidationParameters["max"]);
        }

        [Fact]
        public void GetClientValidationRulesForStringLengthValidatorWithCustomErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.StringLength(6, errorMessage: "Must be at least 6 letters.");

            // Act
            var result = validator.ClientValidationRule;

            // Assert
            Assert.Equal("length", result.ValidationType);
            Assert.Equal("Must be at least 6 letters.", result.ErrorMessage);
            Assert.Equal(6, result.ValidationParameters["max"]);
        }

        [Fact]
        public void RegexThrowsIfPatternIsNullOrEmpty()
        {
            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => Validator.Regex(null), "pattern");
            Assert.ThrowsArgumentNullOrEmptyString(() => Validator.Regex(String.Empty), "pattern");
        }

        [Fact]
        public void RegexReturnsSuccessIfValueMatches()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Regex("^a+b+c$");
            var context = GetValidationContext(GetContext(new { foo = "aaabbc" }), "foo");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void RegexReturnsDefaultErrorMessageIfValidationFails()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Regex("^a+b+c$");
            var context = GetValidationContext(GetContext(new { foo = "aaXabbc" }), "foo");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Value is invalid.", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void RegexReturnsCustomErrorMessageIfValidationFails()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Regex("^a+b+c$");
            var context = GetValidationContext(GetContext(new { foo = "aaXabbc" }), "foo");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Value is invalid.", result.ErrorMessage);
            Assert.Equal("foo", result.MemberNames.Single());
        }

        [Fact]
        public void IntegerReturnsSuccessIfValueIsNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Integer();
            var context = GetValidationContext(GetContext(new { Name = "Not-Age" }), "age");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void IntegerReturnsSuccessIfValueIsEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Integer();
            var context = GetValidationContext(GetContext(new { Age = "" }), "age");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void IntegerReturnsSuccessIfValueIsValidInteger()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Integer();
            var context = GetValidationContext(GetContext(new { Age = "10" }), "age");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void IntegerReturnsSuccessIfValueIsNegativeInteger()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Integer();
            var context = GetValidationContext(GetContext(new { Age = "-42" }), "age");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void IntegerReturnsSuccessIfValueIsZero()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Integer();
            var context = GetValidationContext(GetContext(new { Age = 0 }), "age");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void IntegerReturnsErrorMessageIfValueIsFloatingPointValue()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Integer();
            var context = GetValidationContext(GetContext(new { Age = 1.3 }), "age");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Input format is invalid.", result.ErrorMessage);
            Assert.Equal("age", result.MemberNames.Single());
        }

        [Fact]
        public void IntegerReturnsErrorMessageIfValueIsNotAnInteger()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Integer();
            var context = GetValidationContext(GetContext(new { Age = "2008-04-01" }), "age");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Input format is invalid.", result.ErrorMessage);
            Assert.Equal("age", result.MemberNames.Single());
        }

        [Fact]
        public void FloatReturnsSuccessIfValueIsNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Float();
            var context = GetValidationContext(GetContext(new { }), "Price");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void FloatReturnsSuccessIfValueIsEmptyString()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Float();
            var context = GetValidationContext(GetContext(new { Price = "" }), "Price");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void FloatReturnsSuccessIfValueIsValidFloatString()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Float();
            var context = GetValidationContext(GetContext(new { Price = Single.MaxValue.ToString() }), "Price");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void FloatReturnsSuccessIfValueIsValidInteger()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Float();
            var context = GetValidationContext(GetContext(new { Price = "1" }), "Price");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void FloatReturnsErrorIfValueIsNotAValidFloat()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Float();
            var context = GetValidationContext(GetContext(new { Price = "Free!!!" }), "Price");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Input format is invalid.", result.ErrorMessage);
            Assert.Equal("Price", result.MemberNames.Single());
        }

        [Fact]
        public void DateTimeReturnsSuccessIfValueIsNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.DateTime();
            var context = GetValidationContext(GetContext(new { }), "dateOfBirth");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void DateTimeReturnsSuccessIfValueIsEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.DateTime();
            var context = GetValidationContext(GetContext(new { dateOfBirth = "" }), "dateOfBirth");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void DateTimeReturnsSuccessIfValueIsValidDateTime()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.DateTime();
            var context = GetValidationContext(GetContext(new { dateOfBirth = DateTime.Now.ToString() }), "dateOfBirth");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void DateTimeReturnsErrorIfValueIsInvalidDateTime()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.DateTime();
            var context = GetValidationContext(GetContext(new { dateOfBirth = "23.28" }), "dateOfBirth");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Input format is invalid.", result.ErrorMessage);
            Assert.Equal("dateOfBirth", result.MemberNames.Single());
        }

        [Fact]
        public void UrlReturnsSuccessIfInputIsNull()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Url();
            var context = GetValidationContext(GetContext(new { }), "blogUrl");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void UrlReturnsSuccessIfInputIsEmptyString()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Url();
            var context = GetValidationContext(GetContext(new { blogUrl = "" }), "blogUrl");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void UrlReturnsSuccessIfInputIsValidUrl()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Url();
            var context = GetValidationContext(GetContext(new { blogUrl = "http://www.microsoft.com?query-param=query-param-value&some-val=&quot;true&quot;" }), "blogUrl");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void UrlReturnsErrorMessageIfInputIsPhysicalPath()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Url();
            var context = GetValidationContext(GetContext(new { blogUrl = @"x:\some-path\foo.txt" }), "blogUrl");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Input format is invalid.", result.ErrorMessage);
            Assert.Equal("blogUrl", result.MemberNames.Single());
        }

        [Fact]
        public void UrlReturnsErrorMessageIfInputIsNetworkPath()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Url();
            var context = GetValidationContext(GetContext(new { blogUrl = @"\\network-share\some-path\" }), "blogUrl");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Input format is invalid.", result.ErrorMessage);
            Assert.Equal("blogUrl", result.MemberNames.Single());
        }

        [Fact]
        public void UrlReturnsErrorMessageIfInputIsNotAnUrl()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Url();
            var context = GetValidationContext(GetContext(new { blogUrl = 65 }), "blogUrl");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Input format is invalid.", result.ErrorMessage);
            Assert.Equal("blogUrl", result.MemberNames.Single());
        }

        [Fact]
        public void EqualsToValidatorThrowsIfFieldIsNullOrEmpty()
        {
            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => Validator.EqualsTo(null), "otherFieldName");
        }

        [Fact]
        public void EqualsToValidatorReturnsFalseIfEitherFieldIsEmpty()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.EqualsTo("password");
            var context = GetValidationContext(GetContext(new { password = "", confirmPassword = "abcd" }), "confirmPassword");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Values do not match.", result.ErrorMessage);
            Assert.Equal("confirmPassword", result.MemberNames.Single());

            context = GetValidationContext(GetContext(new { password = "abcd", confirmPassword = "" }), "confirmPassword");

            // Act
            result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Values do not match.", result.ErrorMessage);
            Assert.Equal("confirmPassword", result.MemberNames.Single());
        }

        [Fact]
        public void EqualsToValidatorReturnsFalseIfValuesDoNotMatch()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.EqualsTo("password");
            var context = GetValidationContext(GetContext(new { password = "password2", confirmPassword = "abcd" }), "confirmPassword");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.NotEqual(ValidationResult.Success, result);
            Assert.Equal("Values do not match.", result.ErrorMessage);
            Assert.Equal("confirmPassword", result.MemberNames.Single());
        }

        [Fact]
        public void EqualsToValidatorReturnsTrueIfValuesMatch()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.EqualsTo("password");
            var context = GetValidationContext(GetContext(new { password = "abcd", confirmPassword = "abcd" }), "confirmPassword");

            // Act
            var result = validator.Validate(context);

            // Assert
            Assert.Equal(ValidationResult.Success, result);
        }

        [Fact]
        public void GetClientValidationRulesForRegex()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Regex("^a+b+c$");

            // Act
            var result = validator.ClientValidationRule;

            // Assert
            Assert.Equal("regex", result.ValidationType);
            Assert.Equal("Value is invalid.", result.ErrorMessage);
            Assert.Equal("^a+b+c$", result.ValidationParameters["pattern"]);
        }

        [Fact]
        public void GetClientValidationRulesForRegexWithCustomErrorMessage()
        {
            // Arrange
            RequestFieldValidatorBase.IgnoreUseUnvalidatedValues = true;
            var validator = Validator.Regex("^a+b+c$", "Example aaabbc");

            // Act
            var result = validator.ClientValidationRule;

            // Assert
            Assert.Equal("regex", result.ValidationType);
            Assert.Equal("Example aaabbc", result.ErrorMessage);
            Assert.Equal("^a+b+c$", result.ValidationParameters["pattern"]);
        }

        private static HttpContextBase GetContext(object formValues = null)
        {
            var context = new Mock<HttpContextBase>();
            var request = new Mock<HttpRequestBase>();

            var nameValueCollection = new NameValueCollection();
            if (formValues != null)
            {
                foreach (var prop in formValues.GetType().GetProperties())
                {
                    nameValueCollection.Add(prop.Name, prop.GetValue(formValues, null).ToString());
                }
            }
            request.SetupGet(c => c.Form).Returns(nameValueCollection);
            context.SetupGet(c => c.Request).Returns(request.Object);

            return context.Object;
        }

        private static ValidationContext GetValidationContext(HttpContextBase httpContext, string memberName)
        {
            return new ValidationContext(httpContext, null, null) { MemberName = memberName };
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/ApplicationStartPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Reflection;
using System.Text;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class ApplicationStartPageTest
    {
        [Fact]
        public void StartPageBasicTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var page = new ApplicationStartPageTest().CreateStartPage(p =>
                {
                    p.AppState["x"] = "y";
                    p.WriteLiteral("test");
                });
                page.ExecuteInternal();
                Assert.Equal("y", page.ApplicationState["x"]);
                Assert.Equal("test", ApplicationStartPage.Markup.ToHtmlString());
            });
        }

        [Fact]
        public void StartPageDynamicAppStateBasicTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var page = new ApplicationStartPageTest().CreateStartPage(p =>
                {
                    p.App.x = "y";
                    p.WriteLiteral("test");
                });
                page.ExecuteInternal();
                Assert.Equal("y", page.ApplicationState["x"]);
                Assert.Equal("y", page.App["x"]);
                Assert.Equal("y", page.App.x);
                Assert.Equal("test", ApplicationStartPage.Markup.ToHtmlString());
            });
        }

        [Fact]
        public void ExceptionTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var msg = "This is an error message";
                var e = new InvalidOperationException(msg);
                var page = new ApplicationStartPageTest().CreateStartPage(p => { throw e; });
                var ex = Assert.Throws<HttpException>(() => page.ExecuteStartPage());
                Assert.Equal(msg, ex.InnerException.Message);
                Assert.Equal(e, ApplicationStartPage.Exception);
            });
        }

        [Fact]
        public void HtmlEncodeTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                // Set HideRequestResponse to true to simulate the condition in IIS 7/7.5
                var context = new HttpContext(new HttpRequest("default.cshtml", "http://localhost/default.cshtml", null), new HttpResponse(new StringWriter(new StringBuilder())));
                var hideRequestResponse = typeof(HttpContext).GetField("HideRequestResponse", BindingFlags.NonPublic | BindingFlags.Instance);
                hideRequestResponse.SetValue(context, true);

                HttpContext.Current = context;
                var page = new ApplicationStartPageTest().CreateStartPage(p => { p.Write("test"); });
                page.ExecuteStartPage();
            });
        }

        [Fact]
        public void GetVirtualPathTest()
        {
            var page = new MockStartPage();
            Assert.Equal(ApplicationStartPage.StartPageVirtualPath, page.VirtualPath);
        }

        [Fact]
        public void SetVirtualPathTest()
        {
            var page = new MockStartPage();
            Assert.Throws<NotSupportedException>(() => { page.VirtualPath = "~/hello.cshtml"; });
        }

        [Fact]
        public void ExecuteStartPageTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var startPage = new MockStartPage() { ExecuteAction = p => p.AppState["x"] = "y" };
                var objectFactory = GetMockVirtualPathFactory(startPage);
                ApplicationStartPage.ExecuteStartPage(new WebPageHttpApplication(),
                                                      p => { },
                                                      objectFactory,
                                                      new string[] { "cshtml", "vbhtml" });
                Assert.Equal("y", startPage.ApplicationState["x"]);
            });
        }

        [Fact]
        public void ExecuteStartPageDynamicAppStateTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var startPage = new MockStartPage() { ExecuteAction = p => p.App.x = "y" };
                var objectFactory = GetMockVirtualPathFactory(startPage);
                ApplicationStartPage.ExecuteStartPage(new WebPageHttpApplication(),
                                                      p => { },
                                                      objectFactory,
                                                      new string[] { "cshtml", "vbhtml" });
                Assert.Equal("y", startPage.ApplicationState["x"]);
                Assert.Equal("y", startPage.App.x);
                Assert.Equal("y", startPage.App["x"]);
            });
        }

        public class MockStartPage : ApplicationStartPage
        {
            public Action<ApplicationStartPage> ExecuteAction { get; set; }
            public HttpApplicationStateBase ApplicationState = new HttpApplicationStateWrapper(Activator.CreateInstance(typeof(HttpApplicationState), true) as HttpApplicationState);

            public override void Execute()
            {
                ExecuteAction(this);
            }

            public override HttpApplicationStateBase AppState
            {
                get { return ApplicationState; }
            }

            public void ExecuteStartPage()
            {
                ExecuteStartPage(new WebPageHttpApplication(),
                                 p => { },
                                 GetMockVirtualPathFactory(this),
                                 new string[] { "cshtml", "vbhtml" });
            }
        }

        public MockStartPage CreateStartPage(Action<ApplicationStartPage> action)
        {
            var startPage = new MockStartPage() { ExecuteAction = action };
            return startPage;
        }

        public sealed class WebPageHttpApplication : HttpApplication
        {
        }

        private static IVirtualPathFactory GetMockVirtualPathFactory(ApplicationStartPage page)
        {
            var mockFactory = new Mock<IVirtualPathFactory>();
            mockFactory.Setup(c => c.Exists(It.IsAny<string>())).Returns<string>(_ => true);
            mockFactory.Setup(c => c.CreateInstance(It.IsAny<string>())).Returns<string>(_ => page);

            return mockFactory.Object;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/BrowserHelpersTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Web.Configuration;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class BrowserHelpersTest
    {
        [Fact]
        public void GetOverriddenUserAgentGetsUserAgentFromHttpContext()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            string testUserAgent = "testUserAgent";

            // Act
            context.Object.SetOverriddenBrowser(testUserAgent);
            Assert.Equal(testUserAgent, context.Object.GetOverriddenUserAgent());
            context.Object.Response.Cookies.Clear();
            context.Object.Request.Cookies.Clear();

            // Assert
            Assert.Equal(testUserAgent, context.Object.GetOverriddenUserAgent());
        }

        [Fact]
        public void GetOverriddenUserAgentFallsBackToStoreUserAgent()
        {
            // Arrange
            string testUserAgent = "testUserAgent";
            HttpCookie existingOverrideCookie = new HttpCookie(CookieBrowserOverrideStore.BrowserOverrideCookieName, testUserAgent);
            HttpContextBase context = CookieBrowserOverrideStoreTest.CreateCookieContext(requestCookie: existingOverrideCookie).Object;

            // Act & Assert
            Assert.Equal(testUserAgent, context.GetOverriddenUserAgent());
        }

        [Fact]
        public void GetOverriddenUserAgentDefaultsToRequestUserAgent()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            context.Setup(c => c.Request.UserAgent).Returns("requestUserAgent");

            // Act & Assert
            Assert.Equal("requestUserAgent", context.Object.GetOverriddenUserAgent());
        }

        [Fact]
        public void SetOverriddenBrowserWithBrowserOverrideSetBrowserMobile()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            context.Setup(c => c.Request.Browser.IsMobileDevice).Returns(false);

            // Act
            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);

            // Assert
            Assert.True(context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory).IsMobileDevice);
        }

        [Fact]
        public void SetOverriddenBrowserWithUnsupportedBrowserOverrideClearsBrowser()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            Mock<HttpBrowserCapabilitiesBase> requestBrowser = new Mock<HttpBrowserCapabilitiesBase>();
            context.Setup(c => c.Request.Browser).Returns(requestBrowser.Object);

            // Act & Assert
            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);
            Assert.NotSame(requestBrowser.Object, context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory));

            context.Object.SetOverriddenBrowser((BrowserOverride)(-1));
            Assert.Same(requestBrowser.Object, context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory));
        }

        [Fact]
        public void SetOverriddenBrowserWithBrowserOverrideSetBrowserDesktop()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            context.Setup(c => c.Request.Browser.IsMobileDevice).Returns(true);

            // Act
            context.Object.SetOverriddenBrowser(BrowserOverride.Desktop);

            // Assert
            Assert.False(context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory).IsMobileDevice);
        }

        [Fact]
        public void SetOverriddenBrowserWithStringOverrideSetBrowser()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            context.Setup(c => c.Request.Browser.IsMobileDevice).Returns(false);

            // Act
            context.Object.SetOverriddenBrowser("Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7A341 Safari/528.16");

            // Assert
            Assert.True(context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory).IsMobileDevice);
        }

        [Fact]
        public void SetOverriddenBrowserClearsCachedBrowser()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            context.Setup(c => c.Request.UserAgent).Returns("testUserAgent");

            // Act
            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);
            context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory);

            // If the browser is generated this will throw an exception because we are going through the provider.
            // We must be getting the cached overridden browser.
            context.Object.GetOverriddenBrowser();
            context.Object.SetOverriddenBrowser("testUserAgent");

            // Assert

            // The browser has been cleared from HttpContext and the user agent has been set to the original user agent.
            // Otherwise we will either get the cached browser or an exception when trying to generate the browser from the
            // mobile user agent.
            Assert.Null(context.Object.GetOverriddenBrowser());
        }

        [Fact]
        public void SetOverridenBrowserInSameOverrideClassClearsOverridenBrowser()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            context.Setup(c => c.Request.Browser.IsMobileDevice).Returns(true);
            context.Setup(c => c.Request.UserAgent).Returns("sampleUserAgent");

            // Act
            context.Object.SetOverriddenBrowser(BrowserOverride.Desktop);
            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);

            // Assert
            Assert.Equal("sampleUserAgent", context.Object.GetOverriddenUserAgent());
        }

        [Fact]
        public void GetOverriddenBrowserGetsBrowserFromHttpContext()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();

            // Act
            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);
            context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory);

            // Assert

            // If the browser is generated this will throw an exception because we are going through the provider.
            // We must be getting the cached overridden browser.
            Assert.True(context.Object.GetOverriddenBrowser().IsMobileDevice);
        }

        [Fact]
        public void GetOverriddenBrowserWithStoredBrowserAndNoBrowserInContext()
        {
            // Arrange
            string mobileUserAgent = "Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7A341 Safari/528.16";
            HttpCookie existingOverrideCookie = new HttpCookie(CookieBrowserOverrideStore.BrowserOverrideCookieName, mobileUserAgent);
            HttpContextBase context = CookieBrowserOverrideStoreTest.CreateCookieContext(requestCookie: existingOverrideCookie).Object;

            // Act & Assert
            Assert.True(context.GetOverriddenBrowser(CreateBrowserThroughFactory).IsMobileDevice);
        }

        [Fact]
        public void GetOverriddenBrowserDefaultsToRequestBrowser()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            Mock<HttpBrowserCapabilitiesBase> currentBrowser = new Mock<HttpBrowserCapabilitiesBase>();
            context.Setup(c => c.Request.Browser).Returns(currentBrowser.Object);

            // Act & Assert
            Assert.Same(currentBrowser.Object, context.Object.GetOverriddenBrowser());
        }

        [Fact]
        public void ClearOverriddenBrowserClearsSetBrowser()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            Mock<HttpBrowserCapabilitiesBase> requestBrowser = new Mock<HttpBrowserCapabilitiesBase>();
            context.Setup(c => c.Request.Browser).Returns(requestBrowser.Object);

            // Act & Assert
            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);
            Assert.NotSame(requestBrowser.Object, context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory));

            context.Object.ClearOverriddenBrowser();
            Assert.Same(requestBrowser.Object, context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory));
        }

        [Fact]
        public void ClearOverriddenBrowserWithNoSetBrowser()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            Mock<HttpBrowserCapabilitiesBase> requestBrowser = new Mock<HttpBrowserCapabilitiesBase>();
            context.Setup(c => c.Request.Browser).Returns(requestBrowser.Object);

            // Act & Assert
            context.Object.ClearOverriddenBrowser();
            Assert.Same(requestBrowser.Object, context.Object.GetOverriddenBrowser(CreateBrowserThroughFactory));
        }

        [Fact]
        public void GetOverriddenBrowserVariesBySetOverriddenBrowserMobile()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            Mock<HttpBrowserCapabilitiesBase> currentBrowser = new Mock<HttpBrowserCapabilitiesBase>();
            currentBrowser.Setup(c => c.IsMobileDevice).Returns(true);
            context.Setup(c => c.Request.Browser).Returns(currentBrowser.Object);

            // Act
            string originalBrowserType = GetOverriddenBrowserType(context.Object, CreateBrowserThroughFactory);

            context.Object.SetOverriddenBrowser(BrowserOverride.Desktop);
            string deskTopBrowserType = GetOverriddenBrowserType(context.Object, CreateBrowserThroughFactory);

            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);
            string mobileBrowserType = GetOverriddenBrowserType(context.Object, CreateBrowserThroughFactory);

            // Assert
            Assert.Equal(originalBrowserType, mobileBrowserType);
            Assert.NotEqual(originalBrowserType, deskTopBrowserType);
            Assert.NotEqual(mobileBrowserType, deskTopBrowserType);
        }

        [Fact]
        public void GetOverriddenBrowserVariesBySetOverriddenBrowserDesktop()
        {
            // Arrange
            Mock<HttpContextBase> context = CookieBrowserOverrideStoreTest.CreateCookieContext();
            Mock<HttpBrowserCapabilitiesBase> currentBrowser = new Mock<HttpBrowserCapabilitiesBase>();
            currentBrowser.Setup(c => c.IsMobileDevice).Returns(false);
            context.Setup(c => c.Request.Browser).Returns(currentBrowser.Object);

            // Act
            string originalBrowserType = GetOverriddenBrowserType(context.Object, CreateBrowserThroughFactory);

            context.Object.SetOverriddenBrowser(BrowserOverride.Mobile);
            string mobileBrowserType = GetOverriddenBrowserType(context.Object, CreateBrowserThroughFactory);

            context.Object.SetOverriddenBrowser(BrowserOverride.Desktop);
            string deskTopBrowserType = GetOverriddenBrowserType(context.Object, CreateBrowserThroughFactory);

            // Assert
            Assert.NotEqual(originalBrowserType, mobileBrowserType);
            Assert.Equal(originalBrowserType, deskTopBrowserType);
            Assert.NotEqual(mobileBrowserType, deskTopBrowserType);
        }

        [Fact]
        public void GetOverriddenBrowser_OverridenUserAgentMatchingIsCaseInsensitive()
        {
            // Arrange
            string mobileUserAgent = "Mozilla/5.0 (iPhone; U; CPU iPhone OS 3_0 like Mac OS X; en-us) AppleWebKit/528.18 (KHTML, like Gecko) Version/4.0 Mobile/7A341 Safari/528.16";
            string mobileUserAgentLowerCase = mobileUserAgent.ToLowerInvariant();

            HttpCookie existingOverrideCookie = new HttpCookie(CookieBrowserOverrideStore.BrowserOverrideCookieName, mobileUserAgent);
            HttpContextBase context = CookieBrowserOverrideStoreTest.CreateCookieContext(requestCookie: existingOverrideCookie).Object;
            Mock.Get(context).Setup(c => c.Request.UserAgent).Returns(mobileUserAgent);
            Mock.Get(context).Setup(c => c.Request.Browser).Returns(new HttpBrowserCapabilitiesWrapper(new HttpBrowserCapabilities()));

            // this will set the overriden user agent
            context.SetOverriddenBrowser(mobileUserAgentLowerCase);

            // overriden browser is only created if the overriden userAgent is different from the request's user agent
            bool overridenBrowserWasCreated = false;

            // Act
            var overriden = context.GetOverriddenBrowser(x => { overridenBrowserWasCreated = true; return null; });

            // Assert
            Assert.False(overridenBrowserWasCreated);
            Assert.Same(context.Request.Browser, overriden);
        }

        // We need to call the .ctor of SimpleWorkerRequest that depends on HttpRuntime so for unit testing
        // simply create the browser capabilities by going directly through the factory.
        private static HttpBrowserCapabilitiesBase CreateBrowserThroughFactory(string userAgent)
        {
            HttpBrowserCapabilities browser = new HttpBrowserCapabilities
            {
                Capabilities = new Dictionary<string, string>
                {
                    { String.Empty, userAgent }
                }
            };

            BrowserCapabilitiesFactory factory = new BrowserCapabilitiesFactory();
            factory.ConfigureBrowserCapabilities(new NameValueCollection(), browser);

            return new HttpBrowserCapabilitiesWrapper(browser);
        }

        private static string GetOverriddenBrowserType(HttpContextBase context, Func<string, HttpBrowserCapabilitiesBase> factory)
        {
            return context.GetOverriddenBrowser(factory).Type;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/BrowserOverrideStoresTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class BrowserOverrideStoresTest
    {
        [Fact]
        public void DefaultBrowserOverrideStoreIsCookie()
        {
            // Act & Assert
            Assert.Equal(typeof(CookieBrowserOverrideStore), BrowserOverrideStores.Current.GetType());
        }

        [Fact]
        public void SetBrowserOverrideStoreReturnsSetBrowserOverrideStore()
        {
            // Arrange
            BrowserOverrideStores stores = new BrowserOverrideStores();
            Mock<BrowserOverrideStore> store = new Mock<BrowserOverrideStore>();

            // Act
            stores.CurrentInternal = store.Object;

            // Assert
            Assert.Same(store.Object, stores.CurrentInternal);
        }

        [Fact]
        public void SetBrowserOverrideStoreNullReturnsRequestBrowserOverrideStore()
        {
            //Arrange
            BrowserOverrideStores stores = new BrowserOverrideStores();

            // Act
            stores.CurrentInternal = null;

            // Assert
            Assert.Equal(typeof(RequestBrowserOverrideStore), stores.CurrentInternal.GetType());
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/BuildManagerExceptionUtilTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Runtime.CompilerServices;
using System.Web.WebPages.Resources;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class UtilTest
    {
        [Fact]
        public void IsUnsupportedExtensionError()
        {
            Assert.False(BuildManagerExceptionUtil.IsUnsupportedExtensionError(new HttpException("The following file could not be rendered because its extension \".txt\" might not be supported: \"myfile.txt\".")));

            var e = CompilationUtil.GetBuildProviderException(".txt");
            Assert.NotNull(e);
            Assert.True(BuildManagerExceptionUtil.IsUnsupportedExtensionError(e));
        }

        [Fact]
        public void IsUnsupportedExtensionThrowsTest()
        {
            var extension = ".txt";
            var virtualPath = "Layout.txt";
            var e = CompilationUtil.GetBuildProviderException(extension);

            Assert.Throws<HttpException>(
                () => { BuildManagerExceptionUtil.ThrowIfUnsupportedExtension(virtualPath, e); }, String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_FileNotSupported, extension, virtualPath));
        }

        [Fact]
        public void CodeDomDefinedExtensionThrowsTest()
        {
            var extension = ".js";
            var virtualPath = "Layout.js";

            Assert.Throws<HttpException>(
                () => { BuildManagerExceptionUtil.ThrowIfCodeDomDefinedExtension(virtualPath, new HttpCompileException()); }, String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_FileNotSupported, extension, virtualPath));
        }

        [Fact]
        public void CodeDomDefinedExtensionDoesNotThrowTest()
        {
            var virtualPath = "Layout.txt";
            // Should not throw an exception
            BuildManagerExceptionUtil.ThrowIfCodeDomDefinedExtension(virtualPath, new HttpCompileException());
        }
    }

    // Dummy class to simulate exception from CompilationUtil.GetBuildProviderTypeFromExtension
    internal class CompilationUtil : IVirtualPathFactory
    {
        /// <remarks>
        /// The method that consumes this exception walks the stack trace and uses the class name and method name to uniquely identify an exception.
        /// In release build, the method is inlined causing the call site to appear as the method GetBuildProviderException which causes the test to fail.
        /// These attributes prevent the compiler from inlining this method.
        /// </remarks>
        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
        public static void GetBuildProviderTypeFromExtension(string extension)
        {
            throw new HttpException(extension);
        }

        public static HttpException GetBuildProviderException(string extension)
        {
            try
            {
                GetBuildProviderTypeFromExtension(extension);
            }
            catch (HttpException e)
            {
                return e;
            }
            return null;
        }

        public bool Exists(string virtualPath)
        {
            string extension = PathUtil.GetExtension(virtualPath);
            GetBuildProviderTypeFromExtension(extension);
            return false;
        }

        public object CreateInstance(string virtualPath)
        {
            throw new NotSupportedException();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/BuildManagerWrapperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Web.Hosting;
using Microsoft.Internal.Web.Utils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class BuildManagerWrapperTest
    {
        private const string _precompileConfigFileName = "~/PrecompiledApp.config";

        [Fact]
        public void CanCreateObjectFactoryReturnsFalseIfExtensionIsNotRegistered()
        {
            // Arrange
            var buildManagerWrapper = CreateWrapperInstance();

            // Act
            bool supported = buildManagerWrapper.IsPathExtensionSupported("~/styles/index.css");

            // Assert
            Assert.False(supported);
        }

        [Fact]
        public void CanCreateObjectFactoryReturnsFalseIfVirtualPathIsExtensionless()
        {
            // Arrange
            var buildManagerWrapper = CreateWrapperInstance();

            // Act
            bool supported = buildManagerWrapper.IsPathExtensionSupported("~/default");

            // Assert
            Assert.False(supported);
        }

        [Fact]
        public void CanCreateObjectFactoryReturnsFalseIfVirtualPathExtensionIsEmpty()
        {
            // Arrange
            var buildManagerWrapper = CreateWrapperInstance();

            // Act
            bool supported = buildManagerWrapper.IsPathExtensionSupported("~/default.");

            // Assert
            Assert.False(supported);
        }

        [Fact]
        public void CanCreateObjectFactoryReturnsTrueIfVirtualPathExtensionIsRegistered()
        {
            // Arrange
            var buildManagerWrapper = CreateWrapperInstance();

            // Act
            bool supported = buildManagerWrapper.IsPathExtensionSupported("~/default.cshtml");

            // Assert
            Assert.True(supported);
        }

        [Fact]
        public void CanCreateObjectFactoryPerformsCaseInsenitiveComparison()
        {
            // Arrange
            var buildManagerWrapper = CreateWrapperInstance();

            // Act
            bool supported = buildManagerWrapper.IsPathExtensionSupported("~/default.CShTml");

            // Assert
            Assert.True(supported);
        }

        [Fact]
        public void CanCreateObjectFactoryWorksForAllRegisteredExtensions()
        {
            // Arrange
            var buildManagerWrapper = CreateWrapperInstance();

            // Act
            bool supported = buildManagerWrapper.IsPathExtensionSupported("~/default.vbHtml");

            // Assert
            Assert.True(supported);
        }

        [Fact]
        public void IsNonPrecompiledAppReturnsFalseIfPrecompiledConfigFileDoesNotExist()
        {
            // Arrange
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.IsAny<string>())).Returns(false);
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var isPrecompiled = buildManagerWrapper.IsNonUpdatablePrecompiledApp();

            // Assert
            Assert.False(isPrecompiled);
            vpp.Verify();
        }

        [Fact]
        public void IsNonPrecompiledAppReturnsFalseIfPrecompiledConfigFileIsNotValidXml()
        {
            // Arrange
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            var file = new Mock<VirtualFile>();
            vpp.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile("some random text that is clearly not xml!"));
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var isPrecompiled = buildManagerWrapper.IsNonUpdatablePrecompiledApp();

            // Assert
            Assert.False(isPrecompiled);
            vpp.Verify();
        }

        [Fact]
        public void IsNonPrecompiledAppReturnsFalseIfConfigFileDoesNotContainExpectedElements()
        {
            // Arrange
            var fileContent = @"<?xml version=""1.0""?><configuration><appSettings></appSettings></configuration>";
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            vpp.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile(fileContent)).Verifiable();
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var isPrecompiled = buildManagerWrapper.IsNonUpdatablePrecompiledApp();

            // Assert
            Assert.False(isPrecompiled);
            vpp.Verify();
        }

        [Fact]
        public void IsNonPrecompiledAppReturnsFalseIfAppIsUpdatable()
        {
            // Arrange
            var fileContent = @"<precompiledApp version=""2"" updatable=""true""/>";
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            vpp.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile(fileContent)).Verifiable();
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var isPrecompiled = buildManagerWrapper.IsNonUpdatablePrecompiledApp();

            // Assert
            Assert.False(isPrecompiled);
            vpp.Verify();
        }

        [Fact]
        public void IsNonPrecompiledAppReturnsTrueIfConfigFileIsValidAndIsAppIsNotUpdatable()
        {
            // Arrange
            var fileContent = @"<precompiledApp version=""2"" updatable=""false""/>";
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            vpp.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile(fileContent)).Verifiable();
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var isPrecompiled = buildManagerWrapper.IsNonUpdatablePrecompiledApp();

            // Assert
            Assert.True(isPrecompiled);
            vpp.Verify();
        }

        [Fact]
        public void ExistsUsesVppIfSiteIfNotPrecompiled()
        {
            // Arrange
            var virtualPath = "~/default.cshtml";
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(false).Verifiable();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(virtualPath)))).Returns(true).Verifiable();
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var exists = buildManagerWrapper.Exists(virtualPath);

            // Assert
            vpp.Verify();
            Assert.True(exists);
        }

        [Fact]
        public void ExistsUsesVppIfSiteIfSiteIsPrecompiledButUpdateable()
        {
            // Arrange
            var virtualPath = "~/default.cshtml";
            var fileContent = @"<precompiledApp version=""2"" updatable=""true""/>";
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            vpp.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile(fileContent)).Verifiable();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(virtualPath)))).Returns(true).Verifiable();
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var exists = buildManagerWrapper.Exists(virtualPath);

            // Assert
            vpp.Verify();
            Assert.True(exists);
        }

        /// <remarks>
        /// This method adds items to HttpRuntime.Cache. 
        /// </summary>
        [Fact]
        public void ExistsInPrecompiledReturnsFalseIfExtensionIsUnsupported()
        {
            // Arrange
            var virtualPath = "~/ExistsInPrecompiledReturnsFalseIfExtensionIsUnsupported.jpeg";
            var fileContent = @"<precompiledApp version=""2"" updatable=""false""/>";
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            vpp.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile(fileContent)).Verifiable();
            var buildManagerWrapper = new BuildManagerWrapper(vpp.Object, GetVirtualPathUtility());

            // Act
            var exists = buildManagerWrapper.Exists(virtualPath);

            // Assert
            vpp.Verify();
            Assert.False(exists);
            object cachedValue = HttpRuntime.Cache.Get(BuildManagerWrapper.KeyGuid + "_" + virtualPath);
            Assert.NotNull(cachedValue);
            Assert.False((bool)cachedValue.GetType().GetProperty("Exists").GetValue(cachedValue, null));
        }

        [Fact]
        public void IsNonPrecompiledAppReturnsTrue_VPPRegistrationChanging()
        {
            // Arrange
            string fileContent = @"<precompiledApp version=""2"" updatable=""false""/>";
            IVirtualPathUtility pathUtility = GetVirtualPathUtility();

            Mock<VirtualPathProvider> mockProvider1 = new Mock<VirtualPathProvider>();
            mockProvider1.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            mockProvider1.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile(fileContent)).Verifiable();

            Mock<VirtualPathProvider> mockProvider2 = new Mock<VirtualPathProvider>();
            mockProvider2.Setup(c => c.FileExists(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(true).Verifiable();
            mockProvider2.Setup(c => c.GetFile(It.Is<string>(p => p.Equals(_precompileConfigFileName)))).Returns(GetFile(fileContent)).Verifiable();

            VirtualPathProvider provider = mockProvider1.Object;

            // Act; uses one VirtualPathProvider in constructor and the other when IsNonUpdatablePrecompiledApp() is called directly
            BuildManagerWrapper buildManagerWrapper = new BuildManagerWrapper(() => provider, pathUtility);

            // The moral equivalent of HostingEnvironment.RegisterVirtualPathProvider(provider2.Object)
            provider = mockProvider2.Object;

            bool isPrecompiled = buildManagerWrapper.IsNonUpdatablePrecompiledApp();

            // Assert
            Assert.True(isPrecompiled);
            mockProvider1.Verify();
            mockProvider1.Verify(vpp => vpp.FileExists(It.IsAny<string>()), Times.Once());
            mockProvider1.Verify(vpp => vpp.GetFile(It.IsAny<string>()), Times.Once());
            mockProvider2.Verify();
            mockProvider2.Verify(vpp => vpp.FileExists(It.IsAny<string>()), Times.Once());
            mockProvider2.Verify(vpp => vpp.GetFile(It.IsAny<string>()), Times.Once());
        }

        private static BuildManagerWrapper CreateWrapperInstance(IEnumerable<string> supportedExtensions = null)
        {
            return new BuildManagerWrapper(new Mock<VirtualPathProvider>().Object, GetVirtualPathUtility()) { SupportedExtensions = supportedExtensions ?? new[] { "cshtml", "vbhtml" } };
        }

        private static VirtualFile GetFile(string content)
        {
            var file = new Mock<VirtualFile>("test file");
            file.Setup(f => f.Open()).Returns(() => new MemoryStream(Encoding.UTF8.GetBytes(content)));
            return file.Object;
        }

        private static IVirtualPathUtility GetVirtualPathUtility()
        {
            var utility = new Mock<VirtualPathUtilityBase>();
            utility.Setup(c => c.ToAbsolute(It.IsAny<string>())).Returns<string>(c => c);

            return utility.Object;
        }
    }

    public abstract class VirtualPathUtilityBase : IVirtualPathUtility
    {
        public virtual string Combine(string basePath, string relativePath)
        {
            throw new NotImplementedException();
        }

        public virtual string ToAbsolute(string virtualPath)
        {
            throw new NotImplementedException();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/CookieBrowserOverrideStoreTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class CookieBrowserOverrideStoreTest
    {
        [Fact]
        public void GetOverriddenUserAgentReturnsNullIfNoResponseOrRequestCookieIsSet()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();

            // Act & Assert
            Assert.Null(store.GetOverriddenUserAgent(CreateCookieContext().Object));
        }

        [Fact]
        public void GetOverriddenUserAgentReturnsUserAgentFromRequestCookieIfNoResponseCookie()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();
            HttpCookie existingOverrideCookie = new HttpCookie(CookieBrowserOverrideStore.BrowserOverrideCookieName, "existingRequestAgent");
            HttpContextBase context = CreateCookieContext(requestCookie: existingOverrideCookie).Object;

            // Act & Assert
            Assert.Equal("existingRequestAgent", store.GetOverriddenUserAgent(context));
        }

        [Fact]
        public void SetOverriddenUserAgentWithNoExistingCookie()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();
            HttpContextBase context = CreateCookieContext().Object;

            // Act
            store.SetOverriddenUserAgent(context, "setUserAgent");

            // Assert
            Assert.Equal("setUserAgent", store.GetOverriddenUserAgent(context));
        }

        [Fact]
        public void SetOverriddenUserWithExistingRequestCookie()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();
            HttpCookie existingOverrideCookie = new HttpCookie(CookieBrowserOverrideStore.BrowserOverrideCookieName, "existingRequestAgent");
            HttpContextBase context = CreateCookieContext(requestCookie: existingOverrideCookie).Object;

            // Act
            store.SetOverriddenUserAgent(context, "setUserAgent");

            // Assert
            Assert.Equal("setUserAgent", store.GetOverriddenUserAgent(context));
        }

        [Fact]
        public void SetOverriddenUserWithExistingResponseCookie()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();
            HttpContextBase context = CreateCookieContext().Object;

            // Act & Assert
            store.SetOverriddenUserAgent(context, "testUserAgent");
            Assert.Equal("testUserAgent", store.GetOverriddenUserAgent(context));

            store.SetOverriddenUserAgent(context, "subsequentTestUserAgent");
            Assert.Equal("subsequentTestUserAgent", store.GetOverriddenUserAgent(context));
        }

        [Fact]
        public void SetOverriddenUserAgentNullWithRequestCookie()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();
            HttpCookie existingOverrideCookie = new HttpCookie(CookieBrowserOverrideStore.BrowserOverrideCookieName, "setUserAgent");
            HttpContextBase context = CreateCookieContext(requestCookie: existingOverrideCookie).Object;

            // Act
            store.SetOverriddenUserAgent(context, null);

            // Assert
            Assert.Null(store.GetOverriddenUserAgent(context));
        }

        [Fact]
        public void SetOverriddenUserAgentNullWithNoExistingCookie()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();
            HttpContextBase context = CreateCookieContext().Object;

            // Act
            store.SetOverriddenUserAgent(context, null);

            // Assert
            Assert.Null(store.GetOverriddenUserAgent(context));
        }

        [Fact]
        public void SetOverriddenUserAgentSetsExpiration()
        {
            // Arrange
            CookieBrowserOverrideStore store = new CookieBrowserOverrideStore();
            CookieBrowserOverrideStore sessionStore = new CookieBrowserOverrideStore(daysToExpire: 0);
            CookieBrowserOverrideStore longTermStore = new CookieBrowserOverrideStore(daysToExpire: 100);
            CookieBrowserOverrideStore negativeTermStore = new CookieBrowserOverrideStore(daysToExpire: -1);

            HttpContextBase context = CreateCookieContext().Object;

            // Act & Assert
            store.SetOverriddenUserAgent(context, "testUserAgent");
            Assert.True(DateTime.Now.AddDays(6.5) < context.Response.Cookies[CookieBrowserOverrideStore.BrowserOverrideCookieName].Expires &&
                        context.Response.Cookies[CookieBrowserOverrideStore.BrowserOverrideCookieName].Expires < DateTime.Now.AddDays(7.5));

            sessionStore.SetOverriddenUserAgent(context, "testUserAgent");
            Assert.True(context.Response.Cookies[CookieBrowserOverrideStore.BrowserOverrideCookieName].Expires < DateTime.Now);

            longTermStore.SetOverriddenUserAgent(context, "testUserAgent");
            Assert.True(context.Response.Cookies[CookieBrowserOverrideStore.BrowserOverrideCookieName].Expires > DateTime.Now.AddDays(99));

            negativeTermStore.SetOverriddenUserAgent(context, "testUserAgent");
            Assert.True(context.Response.Cookies[CookieBrowserOverrideStore.BrowserOverrideCookieName].Expires < DateTime.Now);
        }

        internal static Mock<HttpContextBase> CreateCookieContext(HttpCookie requestCookie = null, HttpCookie responseCookie = null)
        {
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();

            HttpCookieCollection requestCookies = new HttpCookieCollection();
            if (requestCookie != null)
            {
                requestCookies.Add(requestCookie);
            }

            HttpCookieCollection responseCookies = new HttpCookieCollection();
            if (responseCookie != null)
            {
                responseCookies.Add(responseCookie);
            }

            context.Setup(c => c.Request.Cookies).Returns(requestCookies);
            context.Setup(c => c.Response.Cookies).Returns(responseCookies);
            context.Setup(c => c.Items).Returns(new Hashtable());

            return context;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/DefaultDisplayModeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class DefaultDisplayModeTest
    {
        [Fact]
        public void DefaultDisplayModeWithEmptySuffix()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode();

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, "/bar/baz.aspx", virtualPath => true);

            // Assert
            Assert.Equal(String.Empty, displayMode.DisplayModeId);
            Assert.Equal("/bar/baz.aspx", info.FilePath);
        }

        [Fact]
        public void DefaultDisplayModeWithNullSuffix()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode(null);

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, "/bar/baz.aspx", virtualPath => true);

            // Assert
            Assert.Equal(String.Empty, displayMode.DisplayModeId);
            Assert.Equal("/bar/baz.aspx", info.FilePath);
        }

        [Fact]
        public void DefaultDisplayModeSetSuffixAsId()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act & Assert
            Assert.Equal("foo", displayMode.DisplayModeId);
        }

        [Fact]
        public void GetDisplayInfoWithNullOrEmptySuffixReturnsPathThatExists()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, "/bar/baz.aspx", virtualPath => true);

            // Assert
            Assert.IsType<DefaultDisplayMode>(info.DisplayMode);
            Assert.Equal("/bar/baz.foo.aspx", info.FilePath);
        }

        [Fact]
        public void GetDisplayInfoInsertsSuffixIntoVirtualPathThatExists()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, "/bar/baz.aspx", virtualPath => true);

            // Assert
            Assert.IsType<DefaultDisplayMode>(info.DisplayMode);
            Assert.Equal("/bar/baz.foo.aspx", info.FilePath);
        }

        [Fact]
        public void GetDisplayInfoInsertsSuffixBeforeLastSectionOfExtension()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, "/bar/baz.txt.aspx", virtualPath => true);

            // Assert
            Assert.Equal("/bar/baz.txt.foo.aspx", info.FilePath);
        }

        [Fact]
        public void GetDisplayInfoSuffixesPathWithNoExtension()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, "/bar/baz", virtualPath => true);

            // Assert
            Assert.Equal("/bar/baz.foo", info.FilePath);
        }

        [Fact]
        public void GetDisplayInfoWithNullVirtualPath()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, virtualPath: null, virtualPathExists: virtualPath => true);

            // Assert
            Assert.Null(info);
        }

        [Fact]
        public void GetDisplayInfoSuffixesPathWithEmptyVirtualPath()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, String.Empty, virtualPath => true);

            // Assert
            Assert.Equal(String.Empty, info.FilePath);
        }

        [Fact]
        public void GetDisplayInfoReturnsNullIfPathDoesNotExist()
        {
            // Arrange
            DefaultDisplayMode displayMode = new DefaultDisplayMode("foo");

            // Act
            DisplayInfo info = displayMode.GetDisplayInfo(new Mock<HttpContextBase>(MockBehavior.Strict).Object, "/bar/baz", virtualPath => false);

            // Assert
            Assert.Null(info);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/DisplayInfoTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class DisplayInfoTest
    {
        [Fact]
        public void GuardClauses()
        {
            // Act & Assert
            Assert.ThrowsArgumentNull(() => new DisplayInfo(filePath: null, displayMode: new Mock<IDisplayMode>().Object), "filePath");
            Assert.ThrowsArgumentNull(() => new DisplayInfo("testPath", displayMode: null), "displayMode");
        }

        [Fact]
        public void ConstructorSetsDisplayInfoProperties()
        {
            // Arrange
            string path = "testPath";
            IDisplayMode displayMode = new Mock<IDisplayMode>().Object;

            // Act
            DisplayInfo info = new DisplayInfo(path, displayMode);

            // Assert
            Assert.Equal(path, info.FilePath);
            Assert.Equal(displayMode, info.DisplayMode);
        }

        [Fact]
        public void ConstructorSetsEmptyFilePath()
        {
            // Act & Assert
            Assert.Equal(String.Empty, new DisplayInfo(String.Empty, new Mock<IDisplayMode>().Object).FilePath);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/DisplayModeProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class DisplayModesTest
    {
        [Fact]
        public void DefaultInstanceHasDefaultModes()
        {
            // Act
            IList<IDisplayMode> displayModes = DisplayModeProvider.Instance.Modes;

            // Assert
            Assert.Equal(2, displayModes.Count);

            Assert.IsType<DefaultDisplayMode>(displayModes[0]);
            Assert.Equal(displayModes[0].DisplayModeId, DisplayModeProvider.MobileDisplayModeId);

            Assert.IsType<DefaultDisplayMode>(displayModes[1]);
            Assert.Equal(displayModes[1].DisplayModeId, DisplayModeProvider.DefaultDisplayModeId);
        }

        [Fact]
        public void GetDisplayInfoForVirtualPathReturnsDisplayInfoFromFirstDisplayModeToHandleRequest()
        {
            // Arrange
            var displayModeProvider = new DisplayModeProvider();
            displayModeProvider.Modes.Clear();
            var displayMode1 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode1.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode1.Object);

            var displayMode2 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode2.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode2.Object);

            var displayMode3 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode3.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode3.Object);

            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);

            var expected = new DisplayInfo("Foo", displayMode3.Object);
            Func<string, bool> fileExists = path => true;
            displayMode3.Setup(d => d.GetDisplayInfo(httpContext.Object, "path", fileExists)).Returns(expected);

            // Act
            DisplayInfo result = displayModeProvider.GetDisplayInfoForVirtualPath("path", httpContext.Object, fileExists, currentDisplayMode: null);

            // Assert
            Assert.Same(expected, result);
        }

        [Fact]
        public void GetDisplayInfoForVirtualPathWithConsistentDisplayModeBeginsSearchAtCurrentDisplayMode()
        {
            // Arrange
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);

            var displayModeProvider = new DisplayModeProvider();
            displayModeProvider.Modes.Clear();
            var displayMode1 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode1.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode1.Object);

            var displayMode2 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode2.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode2.Object);

            var displayMode3 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode3.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode3.Object);

            var displayInfo = new DisplayInfo("Foo", displayMode3.Object);
            Func<string, bool> fileExists = path => true;
            displayMode3.Setup(d => d.GetDisplayInfo(httpContext.Object, "path", fileExists)).Returns(displayInfo);

            // Act
            DisplayInfo result = displayModeProvider.GetDisplayInfoForVirtualPath("path", httpContext.Object, fileExists, currentDisplayMode: displayMode2.Object,
                requireConsistentDisplayMode: true);

            // Assert
            Assert.Same(displayInfo, result);
        }

        [Fact]
        public void GetDisplayInfoForVirtualPathWithoutConsistentDisplayModeIgnoresCurrentDisplayMode()
        {
            // Arrange
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
            var displayModeProvider = new DisplayModeProvider();
            displayModeProvider.Modes.Clear();
            var displayMode1 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode1.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode1.Object);

            var displayMode2 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode2.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode2.Object);

            var displayMode3 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode3.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode3.Object);

            var displayInfo = new DisplayInfo("Foo", displayMode3.Object);
            Func<string, bool> fileExists = path => true;
            displayMode1.Setup(d => d.GetDisplayInfo(httpContext.Object, "path", fileExists)).Returns(displayInfo);

            // Act
            DisplayInfo result = displayModeProvider.GetDisplayInfoForVirtualPath("path", httpContext.Object, fileExists, currentDisplayMode: displayMode1.Object,
                requireConsistentDisplayMode: false);

            // Assert
            Assert.Same(displayInfo, result);
        }

        [Fact]
        public void GetDisplayModesForRequestReturnsNullIfNoDisplayModesHandleRequest()
        {
            // Arrange
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
            var displayModeProvider = new DisplayModeProvider();
            displayModeProvider.Modes.Clear();
            var displayMode1 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode1.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode1.Object);

            var displayMode2 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode2.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode2.Object);

            var displayMode3 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode3.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode3.Object);

            // Act
            DisplayInfo displayModeForRequest = displayModeProvider.GetDisplayInfoForVirtualPath("path", httpContext.Object, path => false, currentDisplayMode: null);

            // Assert
            Assert.Null(displayModeForRequest);
        }

        [Fact]
        public void GetAvailableDisplayModesForContextWithRestrictingPageElements()
        {
            // Arrange
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
            var displayModeProvider = new DisplayModeProvider();
            displayModeProvider.Modes.Clear();
            var displayMode1 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode1.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode1.Object);

            var displayMode2 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode2.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode2.Object);

            var displayMode3 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode3.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode3.Object);

            // Act
            var availableDisplayModes = displayModeProvider.GetAvailableDisplayModesForContext(httpContext.Object, displayMode2.Object, requireConsistentDisplayMode: true).ToList();

            // Assert
            var availableDisplayMode = Assert.Single(availableDisplayModes);
            Assert.Equal(displayMode3.Object, availableDisplayMode);
        }

        [Fact]
        public void GetAvailableDisplayModesForContextWithoutRestrictingPageElements()
        {
            // Arrange
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
            var displayModeProvider = new DisplayModeProvider();
            displayModeProvider.Modes.Clear();

            var displayMode1 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode1.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode1.Object);

            var displayMode2 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode2.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode2.Object);

            var displayMode3 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode3.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode3.Object);

            // Act
            var availableDisplayModes = displayModeProvider.GetAvailableDisplayModesForContext(httpContext.Object, displayMode2.Object, requireConsistentDisplayMode: false).ToList();

            // Assert
            Assert.Equal(2, availableDisplayModes.Count);
            Assert.Same(displayMode1.Object, availableDisplayModes[0]);
            Assert.Same(displayMode3.Object, availableDisplayModes[1]);
        }

        [Fact]
        public void GetAvailableDisplayModesReturnsOnlyModesThatCanHandleContext()
        {
            // Arrange
            Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>(MockBehavior.Strict);
            var displayModeProvider = new DisplayModeProvider();
            displayModeProvider.Modes.Clear();
            var displayMode1 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode1.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode1.Object);

            var displayMode2 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode2.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(true);
            displayModeProvider.Modes.Add(displayMode2.Object);

            var displayMode3 = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode3.Setup(d => d.CanHandleContext(It.IsAny<HttpContextBase>())).Returns(false);
            displayModeProvider.Modes.Add(displayMode3.Object);

            // Act
            var availableDisplayModes = displayModeProvider.GetAvailableDisplayModesForContext(httpContext.Object, displayMode1.Object, requireConsistentDisplayMode: false).ToList();

            // Assert
            IDisplayMode availableDisplayMode = Assert.Single(availableDisplayModes);
            Assert.Equal(displayMode2.Object, availableDisplayMode);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/DynamicHttpApplicationStateTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.WebPages.Resources;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class DynamicHttpApplicationStateTest
    {
        private static HttpApplicationStateBase CreateAppStateInstance()
        {
            return new HttpApplicationStateWrapper((HttpApplicationState)Activator.CreateInstance(typeof(HttpApplicationState), true));
        }

        [Fact]
        public void DynamicTest()
        {
            HttpApplicationStateBase appState = CreateAppStateInstance();
            dynamic d = new DynamicHttpApplicationState(appState);
            d["x"] = "y";
            Assert.Equal("y", d.x);
            Assert.Equal("y", d[0]);
            d.a = "b";
            Assert.Equal("b", d["a"]);
            d.Foo = "bar";
            Assert.Equal("bar", d.Foo);
            Assert.Null(d.XYZ);
            Assert.Null(d["xyz"]);
            Assert.Throws<ArgumentOutOfRangeException>(() => { var x = d[5]; });
            var a = d.Baz = 42;
            Assert.Equal(42, a);
            var b = d["test"] = 666;
            Assert.Equal(666, b);
        }

        [Fact]
        public void InvalidNumberOfIndexes()
        {
            Assert.Throws<ArgumentException>(() =>
            {
                HttpApplicationStateBase appState = CreateAppStateInstance();
                dynamic d = new DynamicHttpApplicationState(appState);
                d[1, 2] = 3;
            }, WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);

            Assert.Throws<ArgumentException>(() =>
            {
                HttpApplicationStateBase appState = CreateAppStateInstance();
                dynamic d = new DynamicHttpApplicationState(appState);
                var x = d[1, 2];
            }, WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);
        }

        [Fact]
        public void InvalidTypeWhenSetting()
        {
            Assert.Throws<ArgumentException>(() =>
            {
                HttpApplicationStateBase appState = CreateAppStateInstance();
                dynamic d = new DynamicHttpApplicationState(appState);
                d[new object()] = 3;
            }, WebPageResources.DynamicHttpApplicationState_UseOnlyStringToSet);
        }

        [Fact]
        public void InvalidTypeWhenGetting()
        {
            Assert.Throws<ArgumentException>(() =>
            {
                HttpApplicationStateBase appState = CreateAppStateInstance();
                dynamic d = new DynamicHttpApplicationState(appState);
                var x = d[new object()];
            }, WebPageResources.DynamicHttpApplicationState_UseOnlyStringOrIntToGet);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/DynamicPageDataDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Web.WebPages.Resources;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class DynamicPageDataDictionaryTest
    {
        [Fact]
        public void DynamicTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            d["x"] = "y";
            Assert.Equal("y", d.x);
            d.a = "b";
            Assert.Equal("b", d["a"]);
            d[0] = "zero";
            Assert.Equal("zero", d[0]);
            d.Foo = "bar";
            Assert.Equal("bar", d.Foo);
            var a = d.Baz = 42;
            Assert.Equal(42, a);
            var b = d[new object()] = 666;
            Assert.Equal(666, b);
        }

        [Fact]
        public void CastToDictionaryTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            var typeCheckCast = d as IDictionary<object, dynamic>;
            var directCast = (IDictionary<object, dynamic>)d;

            Assert.NotNull(typeCheckCast);
            Assert.NotNull(directCast);
        }

        [Fact]
        public void AddTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            var item = new KeyValuePair<object, object>("x", 2);
            d.Add(item);
            Assert.True(d.Contains(item));
            Assert.Equal(2, d.x);
            Assert.Equal(2, d["x"]);
        }

        [Fact]
        public void AddTest1()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            object key = "x";
            object value = 1;
            d.Add(key, value);
            Assert.True(d.ContainsKey(key));
            Assert.Equal(1, d[key]);
            Assert.Equal(1, d.x);
        }

        [Fact]
        public void ClearTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            d.x = 2;
            d.Clear();
            Assert.Equal(0, d.Count);
        }

        [Fact]
        public void ContainsTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            var item = new KeyValuePair<object, object>("x", 1);
            d.Add(item);
            Assert.True(d.Contains(item));
            var item2 = new KeyValuePair<object, object>("y", 2);
            Assert.False(d.Contains(item2));
        }

        [Fact]
        public void ContainsKeyTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            object key = "x";
            Assert.False(d.ContainsKey(key));
            d.Add(key, 1);
            Assert.True(d.ContainsKey(key));
            Assert.True(d.ContainsKey("x"));
        }

        [Fact]
        public void CopyToTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            KeyValuePair<object, object>[] array = new KeyValuePair<object, object>[1];
            d.Add("x", 1);
            d.CopyTo(array, 0);
            Assert.Equal(new KeyValuePair<object, object>("x", 1), array[0]);
        }

        [Fact]
        public void GetEnumeratorTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            d.Add("x", 1);
            var e = d.GetEnumerator();
            e.MoveNext();
            Assert.Equal(new KeyValuePair<object, object>("x", 1), e.Current);
        }

        [Fact]
        public void RemoveTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            var key = "x";
            d.Add(key, 1);
            d.Remove(key);
            Assert.False(d.ContainsKey(key));
        }

        [Fact]
        public void RemoveTest1()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            var item = new KeyValuePair<object, object>("x", 2);
            d.Add(item);
            Assert.True(d.Contains(item));
            d.Remove(item);
            Assert.False(d.Contains(item));
        }

        [Fact]
        public void GetEnumeratorTest1()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            d.Add("x", 1);
            var e = ((IEnumerable)d).GetEnumerator();
            e.MoveNext();
            Assert.Equal(new KeyValuePair<object, object>("x", 1), e.Current);
        }

        [Fact]
        public void TryGetValueTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            object key = "x";
            d.Add(key, 1);
            object value = null;
            Assert.True(d.TryGetValue(key, out value));
            Assert.Equal(1, value);
        }

        [Fact]
        public void CountTest()
        {
            var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            dynamic dyn = d;
            Assert.IsType<int>(dyn.Count);
            d.Add("x", 1);
            Assert.Single(d);
            d.Add("y", 2);
            Assert.Equal(2, d.Count);
            dyn.Count = "foo";
            Assert.Equal("foo", d["Count"]);
            Assert.Equal(3, d.Count);
        }

        [Fact]
        public void IsReadOnlyTest()
        {
            PageDataDictionary<dynamic> dict = new PageDataDictionary<dynamic>();
            var d = new DynamicPageDataDictionary<dynamic>(dict);
            dynamic dyn = d;
            Assert.IsType<bool>(dyn.IsReadOnly);
            Assert.Equal(dict.IsReadOnly, d.IsReadOnly);
            dyn.IsReadOnly = "foo";
            Assert.Equal("foo", d["IsReadOnly"]);
            Assert.Equal(dict.IsReadOnly, d.IsReadOnly);
            Assert.Equal(dict.IsReadOnly, dyn.IsReadOnly);
        }

        [Fact]
        public void ItemTest()
        {
            dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.Equal(1, d["x"]);
            Assert.Equal(2, d["y"]);
        }

        [Fact]
        public void KeysTest()
        {
            var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            dynamic dyn = d;
            Assert.IsAssignableFrom<ICollection<object>>(dyn.Keys);
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.True(d.Keys.Contains("x"));
            Assert.True(d.Keys.Contains("y"));
            Assert.Equal(2, d.Keys.Count);
            dyn.Keys = "foo";
            Assert.Equal("foo", dyn["Keys"]);
            Assert.Equal(3, d.Count);
        }

        [Fact]
        public void ValuesTest()
        {
            var d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
            dynamic dyn = d;
            Assert.IsAssignableFrom<ICollection<dynamic>>(dyn.Values);
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.True(d.Values.Contains(1));
            Assert.True(d.Values.Contains(2));
            Assert.Equal(2, d.Values.Count);
            dyn.Values = "foo";
            Assert.Equal("foo", dyn["Values"]);
            Assert.Equal(3, d.Count);
        }

        [Fact]
        public void InvalidNumberOfIndexes()
        {
            Assert.Throws<ArgumentException>(() =>
            {
                dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
                d[1, 2] = 3;
            }, WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);

            Assert.Throws<ArgumentException>(() =>
            {
                dynamic d = new DynamicPageDataDictionary<dynamic>(new PageDataDictionary<dynamic>());
                var x = d[1, 2];
            }, WebPageResources.DynamicDictionary_InvalidNumberOfIndexes);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/FileExistenceCacheTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using System.Threading;
using System.Web.Hosting;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class FileExistenceCacheTest
    {
        [Fact]
        public void ConstructorTest()
        {
            var ms = 1000;
            FileExistenceCache cache;

            var vpp = new Mock<VirtualPathProvider>().Object;
            cache = new FileExistenceCache(vpp);
            Assert.Equal(vpp, cache.VirtualPathProvider);
            Assert.Equal(ms, cache.MilliSecondsBeforeReset);

            ms = 9999;
            cache = new FileExistenceCache(vpp, ms);
            Assert.Equal(vpp, cache.VirtualPathProvider);
            Assert.Equal(ms, cache.MilliSecondsBeforeReset);
        }

        // Not a valid production scenario -- no HostingEnvironment
        [Fact]
        public void ConstructorTestWithNull()
        {
            // Arrange & Act
            FileExistenceCache cache = new FileExistenceCache(() => null);

            // Assert
            Assert.Null(cache.VirtualPathProvider);
        }

        [Fact]
        public void ConstructorTest_VPPRegistrationChanging()
        {
            // Arrange
            Mock<VirtualPathProvider> mockProvider = new Mock<VirtualPathProvider>(MockBehavior.Strict);
            VirtualPathProvider provider = null;

            // Act
            FileExistenceCache cache = new FileExistenceCache(() => provider);

            // The moral equivalent of HostingEnvironment.RegisterVirtualPathProvider(mockProvider.Object)
            provider = mockProvider.Object;

            // Assert
            Assert.Equal(provider, cache.VirtualPathProvider);
            mockProvider.Verify();
        }

        [Fact]
        public void FileExistsTest_VPPRegistrationChanging()
        {
            // Arrange
            string path = "~/Index.cshtml";
            Mock<VirtualPathProvider> mockProvider = new Mock<VirtualPathProvider>(MockBehavior.Strict);
            mockProvider.Setup(c => c.FileExists(It.IsAny<string>())).Returns<string>(p => p.Equals(path)).Verifiable();
            VirtualPathProvider provider = null;

            // Act
            FileExistenceCache cache = new FileExistenceCache(() => provider);

            // The moral equivalent of HostingEnvironment.RegisterVirtualPathProvider(mockProvider.Object)
            provider = mockProvider.Object;

            bool createExists = cache.FileExists("~/Create.cshtml");
            bool indexExists = cache.FileExists(path);

            // Assert
            Assert.False(createExists);
            Assert.True(indexExists);
            mockProvider.Verify();
            mockProvider.Verify(vpp => vpp.FileExists(It.IsAny<string>()), Times.Exactly(2));
        }

        [Fact]
        public void TimeExceededFalseTest()
        {
            var ms = 100000;
            var cache = new FileExistenceCache(GetVpp(), ms);
            Assert.False(cache.TimeExceeded);
        }

        [Fact]
        public void TimeExceededTrueTest()
        {
            var ms = 5;
            var cache = new FileExistenceCache(GetVpp(), ms);
            Thread.Sleep(300);
            Assert.True(cache.TimeExceeded);
        }

        [Fact]
        public void ResetTest()
        {
            var cache = new FileExistenceCache(GetVpp());
            var cacheInternal = cache.CacheInternal;
            cache.Reset();
            Assert.NotSame(cacheInternal, cache.CacheInternal);
        }

        [Fact]
        public void FileExistsTest()
        {
            var path = "~/index.cshtml";
            var cache = new FileExistenceCache(GetVpp(path));
            Assert.True(cache.FileExists(path));
            Assert.False(cache.FileExists("~/test.cshtml"));
        }

        [Fact]
        public void FileExistsVppLaterTest()
        {
            var path = "~/index.cshtml";
            var cache = new FileExistenceCache(GetVpp(path));
            Assert.True(cache.FileExists(path));
            Assert.False(cache.FileExists("~/test.cshtml"));
        }

        [Fact]
        public void FileExistsTimeExceededTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var path = "~/index.cshtml";
                Utils.SetupVirtualPathInAppDomain(path, "");

                var cache = new FileExistenceCache(GetVpp(path));
                var cacheInternal = cache.CacheInternal;
                cache.MilliSecondsBeforeReset = 5;
                Thread.Sleep(300);
                Assert.True(cache.FileExists(path));
                Assert.False(cache.FileExists("~/test.cshtml"));
                Assert.NotEqual(cacheInternal, cache.CacheInternal);
            });
        }

        private static VirtualPathProvider GetVpp(params string[] files)
        {
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(c => c.FileExists(It.IsAny<string>())).Returns<string>(p => files.Contains(p, StringComparer.OrdinalIgnoreCase));
            return vpp.Object;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/LayoutTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Globalization;
using System.Web.WebPages.Resources;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class LayoutTest
    {
        [Fact]
        public void LayoutBasicTest()
        {
            var layoutPath = "~/Layout.cshtml";
            LayoutBasicTestInternal(layoutPath);
        }

        [Fact]
        public void RelativeLayoutPageTest()
        {
            var pagePath = "~/MyApp/index.cshtml";
            var layoutPath = "~/MyFiles/Layout.cshtml";
            var layoutPage = "../MyFiles/Layout.cshtml";
            LayoutBasicTestInternal(layoutPath, pagePath, layoutPage);
        }

        [Fact]
        public void AppRelativeLayoutPageTest()
        {
            var pagePath = "~/MyApp/index.cshtml";
            var layoutPath = "~/MyFiles/Layout.cshtml";
            var layoutPage = "~/MyFiles/Layout.cshtml";
            LayoutBasicTestInternal(layoutPath, pagePath, layoutPage);
        }

        [Fact]
        public void SourceFileWithLayoutPageTest()
        {
            // Arrange
            var pagePath = "~/MyApp/index.cshtml";
            var layoutPath = "~/MyFiles/Layout.cshtml";
            var layoutPage = "~/MyFiles/Layout.cshtml";
            var content = "hello world";
            var title = "MyPage";
            var page = CreatePageWithLayout(
                p =>
                {
                    p.PageData["Title"] = title;
                    p.WriteLiteral(content);
                },
                p =>
                {
                    p.WriteLiteral(p.PageData["Title"]);
                    p.Write(p.RenderBody());
                }, pagePath, layoutPath, layoutPage);
            var request = new Mock<HttpRequestBase>();
            request.SetupGet(c => c.Path).Returns("/myapp/index.cshtml");
            request.SetupGet(c => c.RawUrl).Returns("http://localhost:8080/index.cshtml");
            request.SetupGet(c => c.IsLocal).Returns(true);
            request.Setup(c => c.MapPath(It.IsAny<string>())).Returns<string>(c => c);
            request.Setup(c => c.Browser.IsMobileDevice).Returns(false);
            request.Setup(c => c.Cookies).Returns(new HttpCookieCollection());

            var result = Utils.RenderWebPage(page, request: request.Object);
            Assert.Equal(2, page.PageContext.SourceFiles.Count);
            Assert.Contains("~/MyApp/index.cshtml", page.PageContext.SourceFiles);
            Assert.Contains("~/MyFiles/Layout.cshtml", page.PageContext.SourceFiles);
        }

        private static void LayoutBasicTestInternal(string layoutPath, string pagePath = "~/index.cshtml", string layoutPage = "Layout.cshtml")
        {
            // The page ~/index.cshtml does the following:
            // PageData["Title"] = "MyPage";
            // Layout = "Layout.cshtml";
            // WriteLiteral("hello world");
            //
            // The layout page ~/Layout.cshtml does the following:
            // WriteLiteral(Title);
            // RenderBody();
            //
            // Expected rendered result is "MyPagehello world"

            var content = "hello world";
            var title = "MyPage";
            var result = RenderPageWithLayout(
                p =>
                {
                    p.PageData["Title"] = title;
                    p.WriteLiteral(content);
                },
                p =>
                {
                    p.WriteLiteral(p.PageData["Title"]);
                    p.Write(p.RenderBody());
                },
                pagePath, layoutPath, layoutPage);

            Assert.Equal(title + content, result);
        }

        [Fact]
        public void LayoutNestedTest()
        {
            // Testing nested layout pages
            //
            // The page ~/index.cshtml does the following:
            // PageData["Title"] = "MyPage";
            // Layout = "Layout1.cshtml";
            // WriteLiteral("hello world");
            //
            // The first layout page ~/Layout1.cshtml does the following:
            // Layout = "Layout2.cshtml";
            // WriteLiteral("<layout1>");
            // RenderBody();
            // WriteLiteral("</layout1>");
            //
            // The second layout page ~/Layout2.cshtml does the following:
            // WriteLiteral(Title);
            // WriteLiteral("<layout2>");
            // RenderBody();
            // WriteLiteral("</layout2>");
            //
            // Expected rendered result is "MyPage<layout2><layout1>hello world</layout1></layout2>"

            var layout2Path = "~/Layout2.cshtml";
            var layout2 = Utils.CreatePage(
                p =>
                {
                    p.WriteLiteral(p.PageData["Title"]);
                    p.WriteLiteral("<layout2>");
                    p.Write(p.RenderBody());
                    p.WriteLiteral("</layout2>");
                },
                layout2Path);

            var layout1Path = "~/Layout1.cshtml";
            var layout1 = Utils.CreatePage(
                p =>
                {
                    p.Layout = "Layout2.cshtml";
                    p.WriteLiteral("<layout1>");
                    p.Write(p.RenderBody());
                    p.WriteLiteral("</layout1>");
                },
                layout1Path);

            var page = Utils.CreatePage(
                p =>
                {
                    p.PageData["Title"] = "MyPage";
                    p.Layout = "Layout1.cshtml";
                    p.WriteLiteral("hello world");
                });

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, layout1, layout2);

            var result = Utils.RenderWebPage(page);
            Assert.Equal("MyPage<layout2><layout1>hello world</layout1></layout2>", result);
        }

        [Fact]
        public void LayoutSectionsTest()
        {
            // Testing nested layout pages with sections
            //
            // The page ~/index.cshtml does the following:
            // PageData["Title"] = "MyPage";
            // Layout = "Layout1.cshtml";
            // DefineSection("header1", () => {
            //     WriteLiteral("index header");
            // });
            // WriteLiteral("hello world");
            // DefineSection("footer1", () => {
            //     WriteLiteral("index footer");
            // });
            //
            // The first layout page ~/Layout1.cshtml does the following:
            // Layout = "Layout2.cshtml";
            // DefineSection("header2", () => {
            //     WriteLiteral("<layout1 header>");
            //     RenderSection("header1");
            //     WriteLiteral("</layout1 header>");
            // });
            // WriteLiteral("<layout1>");
            // RenderBody();
            // WriteLiteral("</layout1>");
            // DefineSection("footer2", () => {
            //     WriteLiteral("<layout1 footer>");
            //     RenderSection("header2");
            //     WriteLiteral("</layout1 footer>");
            // });
            //
            // The second layout page ~/Layout2.cshtml does the following:
            // WriteLiteral(Title);
            // WriteLiteral("\n<layout2 header>");
            // RenderSection("header2");
            // WriteLiteral("</layout2 header>\n");
            // WriteLiteral("<layout2>");
            // RenderBody();
            // WriteLiteral("</layout2>\n");
            // WriteLiteral("<layout2 footer>");
            // RenderSection("footer");
            // WriteLiteral("</layout2 footer>");
            //
            // Expected rendered result is:
            // MyPage
            // <layout2 header><layout1 header>index header</layout1 header></layout2 header>
            // <layout2><layout1>hello world</layout1></layout2>"
            // <layout2 footer><layout1 footer>index footer</layout1 footer></layout2 footer>

            var layout2Path = "~/Layout2.cshtml";
            var layout2 = Utils.CreatePage(
                p =>
                {
                    p.WriteLiteral(p.PageData["Title"]);
                    p.WriteLiteral("\r\n");
                    p.WriteLiteral("<layout2 header>");
                    p.Write(p.RenderSection("header2"));
                    p.WriteLiteral("</layout2 header>");
                    p.WriteLiteral("\r\n");

                    p.WriteLiteral("<layout2>");
                    p.Write(p.RenderBody());
                    p.WriteLiteral("</layout2>");
                    p.WriteLiteral("\r\n");

                    p.WriteLiteral("<layout2 footer>");
                    p.Write(p.RenderSection("footer2"));
                    p.WriteLiteral("</layout2 footer>");
                },
                layout2Path);

            var layout1Path = "~/Layout1.cshtml";
            var layout1 = Utils.CreatePage(
                p =>
                {
                    p.Layout = "Layout2.cshtml";
                    p.DefineSection("header2", () =>
                    {
                        p.WriteLiteral("<layout1 header>");
                        p.Write(p.RenderSection("header1"));
                        p.WriteLiteral("</layout1 header>");
                    });

                    p.WriteLiteral("<layout1>");
                    p.Write(p.RenderBody());
                    p.WriteLiteral("</layout1>");

                    p.DefineSection("footer2", () =>
                    {
                        p.WriteLiteral("<layout1 footer>");
                        p.Write(p.RenderSection("footer1"));
                        p.WriteLiteral("</layout1 footer>");
                    });
                },
                layout1Path);

            var page = Utils.CreatePage(
                p =>
                {
                    p.PageData["Title"] = "MyPage";
                    p.Layout = "Layout1.cshtml";
                    p.DefineSection("header1", () => { p.WriteLiteral("index header"); });
                    p.WriteLiteral("hello world");
                    p.DefineSection("footer1", () => { p.WriteLiteral("index footer"); });
                });

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, layout1, layout2);

            var result = Utils.RenderWebPage(page);
            var expected = "MyPage" + Environment.NewLine
                         + "<layout2 header><layout1 header>index header</layout1 header></layout2 header>" + Environment.NewLine
                         + "<layout2><layout1>hello world</layout1></layout2>" + Environment.NewLine
                         + "<layout2 footer><layout1 footer>index footer</layout1 footer></layout2 footer>";
            Assert.Equal(expected, result);
        }

        [Fact]
        public void LayoutSectionsNestedNamesTest()
        {
            // Tests nested layout using the same section names at different levels.
            //
            // The page ~/index.cshtml does the following:
            // Layout = "Layout1.cshtml";
            // @section body {
            //     body in index
            // }
            //
            // The page ~/layout1.cshtml does the following:
            // Layout = "Layout2.cshtml";
            // @section body {
            //     body in layout1
            //     @RenderSection("body")
            // }
            //
            // The page ~/layout2.cshtml does the following:
            // body in layout2
            // @RenderSection("body")
            //
            // Expected rendered result is:
            // body in layout2 body in layout1 body in index
            var layout2Path = "~/Layout2.cshtml";
            var layout2 = Utils.CreatePage(
                p =>
                {
                    p.WriteLiteral("body in layout2 ");
                    p.Write(p.RenderSection("body"));
                },
                layout2Path);
            var layout1Path = "~/Layout1.cshtml";
            var layout1 = Utils.CreatePage(
                p =>
                {
                    p.Layout = "Layout2.cshtml";
                    p.DefineSection("body", () =>
                    {
                        p.WriteLiteral("body in layout1 ");
                        p.Write(p.RenderSection("body"));
                    });
                },
                layout1Path);

            var page = Utils.CreatePage(
                p =>
                {
                    p.Layout = "Layout1.cshtml";
                    p.DefineSection("body", () => { p.WriteLiteral("body in index"); });
                });

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, layout1, layout2);

            var result = Utils.RenderWebPage(page);
            var expected = "body in layout2 body in layout1 body in index";
            Assert.Equal(expected, result);
        }

        [Fact]
        public void CaseInsensitiveSectionNamesTest()
        {
            var page = CreatePageWithLayout(
                p =>
                {
                    p.Write("123");
                    p.DefineSection("abc", () => { p.Write("abc"); });
                    p.DefineSection("XYZ", () => { p.Write("xyz"); });
                    p.Write("456");
                },
                p =>
                {
                    p.Write(p.RenderSection("AbC"));
                    p.Write(p.RenderSection("xyZ"));
                    p.Write(p.RenderBody());
                });
            var result = Utils.RenderWebPage(page);
            var expected = "abcxyz123456";
            Assert.Equal(expected, result);
        }

        [Fact]
        public void MissingLayoutPageTest()
        {
            var layoutPage = "Layout.cshtml";
            var page = Utils.CreatePage(
                p =>
                {
                    p.PageData["Title"] = "MyPage";
                    p.Layout = layoutPage;
                });
            var layoutPath1 = "~/Layout.cshtml";

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_LayoutPageNotFound, layoutPage, layoutPath1));
        }

        [Fact]
        public void RenderBodyAlreadyCalledTest()
        {
            // Layout page calls RenderBody more than once.
            var page = CreatePageWithLayout(
                p => { },
                p =>
                {
                    p.Write(p.RenderBody());
                    p.Write(p.RenderBody());
                });

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page), WebPageResources.WebPage_RenderBodyAlreadyCalled);
        }

        [Fact]
        public void RenderBodyNotCalledTest()
        {
            // Page does not define any sections, but layout page does not call RenderBody
            var layoutPath = "~/Layout.cshtml";
            var page = CreatePageWithLayout(
                p => { },
                p => { },
                layoutPath: layoutPath);

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_RenderBodyNotCalled, layoutPath));
        }

        [Fact]
        public void RenderBodyCalledDirectlyTest()
        {
            // A Page that is not a layout page calls the RenderBody method
            var page = Utils.CreatePage(p => { p.RenderBody(); });
            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_CannotRequestDirectly, "~/index.cshtml", "RenderBody"));
        }

        [Fact]
        public void RenderSectionCalledDirectlyTest()
        {
            // A Page that is not a layout page calls the RenderBody method
            var page = Utils.CreatePage(p => { p.RenderSection(""); });
            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_CannotRequestDirectly, "~/index.cshtml", "RenderSection"));
        }

        [Fact]
        public void SectionAlreadyDefinedTest()
        {
            // The page calls DefineSection more than once on the same name
            var sectionName = "header";
            var page = Utils.CreatePage(p =>
            {
                p.Layout = "Layout.cshtml";
                p.DefineSection(sectionName, () => { });
                p.DefineSection(sectionName, () => { });
            });

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.InvariantCulture, WebPageResources.WebPage_SectionAleadyDefined, sectionName));
        }

        [Fact]
        public void SectionAlreadyDefinedCaseInsensitiveTest()
        {
            // The page calls DefineSection more than once on the same name but with different casing
            var name1 = "section1";
            var name2 = "SecTion1";

            var page = Utils.CreatePage(p =>
            {
                p.Layout = "Layout.cshtml";
                p.DefineSection(name1, () => { });
                p.DefineSection(name2, () => { });
            });

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.InvariantCulture, WebPageResources.WebPage_SectionAleadyDefined, name2));
        }

        [Fact]
        public void SectionNotDefinedTest()
        {
            // Layout page calls RenderSection on a name that has not been defined.
            var sectionName = "NoSuchSection";
            var page = CreatePageWithLayout(
                p => { },
                p => { p.Write(p.RenderSection(sectionName)); });

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.InvariantCulture, WebPageResources.WebPage_SectionNotDefined, sectionName));
        }

        [Fact]
        public void SectionAlreadyRenderedTest()
        {
            // Layout page calls RenderSection on the same name more than once.
            var sectionName = "header";
            var page = CreatePageWithLayout(
                p =>
                {
                    p.Layout = "Layout.cshtml";
                    p.DefineSection(sectionName, () => { });
                },
                p =>
                {
                    p.Write(p.RenderSection(sectionName));
                    p.Write(p.RenderSection(sectionName));
                });

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.InvariantCulture, WebPageResources.WebPage_SectionAleadyRendered, sectionName));
        }

        [Fact]
        public void SectionsNotRenderedTest()
        {
            // Layout page does not render all the defined sections.

            var layoutPath = "~/Layout.cshtml";
            var sectionName1 = "section1";
            var sectionName2 = "section2";
            var sectionName3 = "section3";
            var sectionName4 = "section4";
            var sectionName5 = "section5";
            // A dummy section action that does nothing
            SectionWriter sectionAction = () => { };

            // The page defines 5 sections.
            var page = CreatePageWithLayout(
                p =>
                {
                    p.DefineSection(sectionName1, sectionAction);
                    p.DefineSection(sectionName2, sectionAction);
                    p.DefineSection(sectionName3, sectionAction);
                    p.DefineSection(sectionName4, sectionAction);
                    p.DefineSection(sectionName5, sectionAction);
                },
                // The layout page renders only two of the sections
                p =>
                {
                    p.Write(p.RenderSection(sectionName2));
                    p.Write(p.RenderSection(sectionName4));
                },
                layoutPath: layoutPath);

            var sectionsNotRendered = "section1; section3; section5";
            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_SectionsNotRendered, layoutPath, sectionsNotRendered));
        }

        [Fact]
        public void SectionsNotRenderedRenderBodyTest()
        {
            // Layout page does not render all the defined sections, but it calls RenderBody.
            var layoutPath = "~/Layout.cshtml";
            var sectionName1 = "section1";
            var sectionName2 = "section2";
            // A dummy section action that does nothing
            SectionWriter sectionAction = () => { };

            var page = CreatePageWithLayout(
                p =>
                {
                    p.DefineSection(sectionName1, sectionAction);
                    p.DefineSection(sectionName2, sectionAction);
                },
                // The layout page only calls RenderBody
                p => { p.Write(p.RenderBody()); },
                layoutPath: layoutPath);

            var sectionsNotRendered = "section1; section2";
            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_SectionsNotRendered, layoutPath, sectionsNotRendered));
        }

        [Fact]
        public void InvalidPageTypeTest()
        {
            var layoutPath = "~/Layout.js";
            var contents = "hello world";
            var page = Utils.CreatePage(p =>
            {
                p.Layout = layoutPath;
                p.Write(contents);
            });
            var layoutPage = new object();

            var objectFactory = new Mock<IVirtualPathFactory>();
            objectFactory.Setup(c => c.Exists(It.IsAny<string>())).Returns<string>(p => layoutPath.Equals(p, StringComparison.OrdinalIgnoreCase));
            objectFactory.Setup(c => c.CreateInstance(It.IsAny<string>())).Returns<string>(_ => layoutPage as WebPageBase);
            page.VirtualPathFactory = objectFactory.Object;

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_InvalidPageType, layoutPath));

            Assert.Throws<HttpException>(() => Utils.RenderWebPage(page),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_InvalidPageType, layoutPath));
        }

        [Fact]
        public void ValidPageTypeTest()
        {
            var layoutPath = "~/Layout.js";
            var contents = "hello world";
            var page = Utils.CreatePage(p =>
            {
                p.Layout = layoutPath;
                p.Write(contents);
            });
            var layoutPage = Utils.CreatePage(p => p.WriteLiteral(p.RenderBody()), layoutPath);

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, layoutPage);

            Assert.Equal(contents, Utils.RenderWebPage(page));
        }

        [Fact]
        public void IsSectionDefinedTest()
        {
            // Tests for the IsSectionDefined method

            // Only sections named section1 and section3 are defined.
            var page = CreatePageWithLayout(
                p =>
                {
                    p.DefineSection("section1", () => { });
                    p.DefineSection("section3", () => { });
                },
                p =>
                {
                    p.Write(p.RenderSection("section1"));
                    p.Write(p.RenderSection("section3"));
                    p.Write("section1: " + p.IsSectionDefined("section1") + "; ");
                    p.Write("section2: " + p.IsSectionDefined("section2") + "; ");
                    p.Write("section3: " + p.IsSectionDefined("section3") + "; ");
                    p.Write("section4: " + p.IsSectionDefined("section4") + "; ");
                });
            var result = Utils.RenderWebPage(page);
            var expected = "section1: True; section2: False; section3: True; section4: False; ";
            Assert.Equal(expected, result);
        }

        [Fact]
        public void OptionalSectionsTest()
        {
            // Only sections named section1 and section3 are defined.
            var page = CreatePageWithLayout(
                p =>
                {
                    p.DefineSection("section1", () => { p.Write("section1 "); });
                    p.DefineSection("section3", () => { p.Write("section3"); });
                },
                p =>
                {
                    p.Write(p.RenderSection("section1", required: false));
                    p.Write(p.RenderSection("section2", required: false));
                    p.Write(p.RenderSection("section3", required: false));
                    p.Write(p.RenderSection("section4", required: false));
                });
            var result = Utils.RenderWebPage(page);
            var expected = "section1 section3";
            Assert.Equal(expected, result);
        }

        [Fact]
        public void PageDataTest()
        {
            // Layout page uses items in PageData set by content page
            var contents = "my contents";
            var page = CreatePageWithLayout(
                p =>
                {
                    p.PageData["contents"] = contents;
                    p.Write(" body");
                },
                p =>
                {
                    p.Write(p.PageData["contents"]);
                    p.Write(p.RenderBody());
                });
            var result = Utils.RenderWebPage(page);
            var expected = contents + " body";
            Assert.Equal(expected, result);
        }

        [Fact]
        public void RenderPageAndLayoutPage()
        {
            //Dev10 bug 928341 - a page that has a layout page, and the page calls RenderPage should not cause an error
            var layoutPagePath = "~/layout.cshtml";
            var page = Utils.CreatePage(p =>
            {
                p.DefineSection("foo", () => { p.Write("This is foo"); });
                p.Write(p.RenderPage("bar.cshtml"));
                p.Layout = layoutPagePath;
            });
            var layoutPage = Utils.CreatePage(p =>
            {
                p.Write(p.RenderBody());
                p.Write(" ");
                p.Write(p.RenderSection("foo"));
            }, layoutPagePath);

            var subPage = Utils.CreatePage(p => p.Write("This is bar"), "~/bar.cshtml");
            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, layoutPage, subPage);

            var result = Utils.RenderWebPage(page);
            var expected = "This is bar This is foo";
            Assert.Equal(expected, result);
        }

        public static string RenderPageWithLayout(Action<WebPage> pageExecuteAction, Action<WebPage> layoutExecuteAction,
                                                  string pagePath = "~/index.cshtml", string layoutPath = "~/Layout.cshtml", string layoutPage = "Layout.cshtml")
        {
            var page = CreatePageWithLayout(pageExecuteAction, layoutExecuteAction, pagePath, layoutPath, layoutPage);
            return Utils.RenderWebPage(page);
        }

        public static MockPage CreatePageWithLayout(Action<WebPage> pageExecuteAction, Action<WebPage> layoutExecuteAction,
                                                    string pagePath = "~/index.cshtml", string layoutPath = "~/Layout.cshtml", string layoutPageName = "Layout.cshtml")
        {
            var page = Utils.CreatePage(
                p =>
                {
                    p.Layout = layoutPageName;
                    pageExecuteAction(p);
                },
                pagePath);
            var layoutPage = Utils.CreatePage(
                p => { layoutExecuteAction(p); },
                layoutPath);

            Utils.AssignObjectFactoriesAndDisplayModeProvider(layoutPage, page);

            return page;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/PageDataDictionaryTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class PageDataDictionaryTest
    {
        [Fact]
        public void PageDataDictionaryConstructorTest()
        {
            var d = new PageDataDictionary<dynamic>();
            Assert.NotNull(d.Data);
        }

        [Fact]
        public void AddTest()
        {
            var d = new PageDataDictionary<dynamic>();
            var item = new KeyValuePair<object, object>("x", 2);
            d.Add(item);
            Assert.True(d.Data.Contains(item));
        }

        [Fact]
        public void AddTest1()
        {
            var d = new PageDataDictionary<dynamic>();
            object key = "x";
            object value = 1;
            d.Add(key, value);
            Assert.True(d.Data.ContainsKey(key));
            Assert.Equal(1, d.Data[key]);
            // Use uppercase string key
            Assert.Equal(1, d.Data["X"]);
        }

        [Fact]
        public void ClearTest()
        {
            var d = new PageDataDictionary<dynamic>();
            d.Add("x", 2);
            d.Clear();
            Assert.Equal(0, d.Data.Count);
        }

        [Fact]
        public void ContainsTest()
        {
            var d = new PageDataDictionary<dynamic>();
            var item = new KeyValuePair<object, object>("x", 1);
            d.Add(item);
            Assert.Contains<KeyValuePair<object, object>>(item, d);
            var item2 = new KeyValuePair<object, object>("y", 2);
            Assert.DoesNotContain<KeyValuePair<object, object>>(item2, d);
        }

        [Fact]
        public void ContainsKeyTest()
        {
            var d = new PageDataDictionary<dynamic>();
            object key = "x";
            Assert.False(d.ContainsKey(key));
            d.Add(key, 1);
            Assert.True(d.ContainsKey(key));
            Assert.True(d.ContainsKey("X"));
        }

        [Fact]
        public void CopyToTest()
        {
            var d = new PageDataDictionary<dynamic>();
            KeyValuePair<object, object>[] array = new KeyValuePair<object, object>[1];
            d.Add("x", 1);
            d.CopyTo(array, 0);
            Assert.Equal(new KeyValuePair<object, object>("x", 1), array[0]);
        }

        [Fact]
        public void GetEnumeratorTest()
        {
            var d = new PageDataDictionary<dynamic>();
            d.Add("x", 1);
            var e = d.GetEnumerator();
            e.MoveNext();
            Assert.Equal<object>(new KeyValuePair<object, object>("x", 1), e.Current);
        }

        [Fact]
        public void RemoveTest()
        {
            var d = new PageDataDictionary<dynamic>();
            var key = "x";
            d.Add(key, 1);
            d.Remove(key);
            Assert.False(d.Data.ContainsKey(key));
        }

        [Fact]
        public void RemoveTest1()
        {
            var d = new PageDataDictionary<dynamic>();
            var item = new KeyValuePair<object, object>("x", 2);
            d.Add(item);
            Assert.Contains<KeyValuePair<object, object>>(item, d);
            d.Remove(item);
            Assert.DoesNotContain<KeyValuePair<object, object>>(item, d);
        }

        [Fact]
        public void GetEnumeratorTest1()
        {
            var d = new PageDataDictionary<dynamic>();
            d.Add("x", 1);
            var e = ((IEnumerable)d).GetEnumerator();
            e.MoveNext();
            Assert.Equal(new KeyValuePair<object, object>("x", 1), e.Current);
        }

        [Fact]
        public void TryGetValueTest()
        {
            var d = new PageDataDictionary<dynamic>();
            object key = "x";
            d.Add(key, 1);
            object value = null;
            Assert.True(d.TryGetValue(key, out value));
            Assert.Equal(1, value);
        }

        [Fact]
        public void CountTest()
        {
            var d = new PageDataDictionary<dynamic>();
            d.Add("x", 1);
            Assert.Single(d);
            d.Add("y", 2);
            Assert.Equal(2, d.Count);
        }

        [Fact]
        public void IsReadOnlyTest()
        {
            var d = new PageDataDictionary<dynamic>();
            Assert.Equal(d.Data.IsReadOnly, d.IsReadOnly);
        }

        [Fact]
        public void ItemTest()
        {
            var d = new PageDataDictionary<dynamic>();
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.Equal(1, d["x"]);
            Assert.Equal(2, d["y"]);
        }

        [Fact]
        public void KeysTest()
        {
            var d = new PageDataDictionary<dynamic>();
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.True(d.Keys.Contains("x"));
            Assert.True(d.Keys.Contains("y"));
            Assert.Equal(2, d.Keys.Count);
        }

        [Fact]
        public void ValuesTest()
        {
            var d = new PageDataDictionary<dynamic>();
            d.Add("x", 1);
            d.Add("y", 2);
            Assert.True(d.Values.Contains(1));
            Assert.True(d.Values.Contains(2));
            Assert.Equal(2, d.Values.Count);
        }

        [Fact]
        public void KeysReturnsNumericKeysIfPresent()
        {
            // Arrange
            var d = new PageDataDictionary<string>();

            // Act
            d[100] = "foo";
            d[200] = "bar";

            // Assert
            Assert.Equal(2, d.Keys.Count);
            Assert.Equal(100, d.Keys.ElementAt(0));
            Assert.Equal(200, d.Keys.ElementAt(1));
        }

        [Fact]
        public void KeysReturnsUniqueSetOfValues()
        {
            // Act
            var innerDict = new Dictionary<string, object>()
            {
                { "my-key", "value" },
                { "test", "test-val" }
            };
            var dict = PageDataDictionary<dynamic>.CreatePageDataFromParameters(new PageDataDictionary<dynamic>(), innerDict);

            // Act
            dict.Add("my-key", "added-value");
            dict["foo"] = "bar";

            // Assert
            Assert.Equal(4, dict.Keys.Count);
            Assert.Equal("my-key", dict.Keys.ElementAt(0));
            Assert.Equal("test", dict.Keys.ElementAt(1));
            Assert.Equal(0, dict.Keys.ElementAt(2));
            Assert.Equal("foo", dict.Keys.ElementAt(3));
            Assert.Equal(dict[0], innerDict);
        }

        [Fact]
        public void AddValueOverwritesIndexDictionaryIfKeyExists()
        {
            // Act
            var dict = PageDataDictionary<dynamic>.CreatePageDataFromParameters(new PageDataDictionary<dynamic>(), new[] { "index-0-orig", "index-1" });

            // Act
            dict[0] = "index-0-new";

            // Assert
            Assert.Equal(2, dict.Keys.Count);
            Assert.Equal("index-0-new", dict[0]);
            Assert.Equal("index-1", dict[1]);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/RenderPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Web.WebPages.Resources;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class RenderPageTest
    {
        [Fact]
        public void RenderBasicTest()
        {
            // A simple page that does the following:
            // @{ PageData["Title"] = "MyPage"; }
            // @PageData["Title"]
            // hello world
            //
            // Expected rendered result is "MyPagehello world"

            var content = "hello world";
            var title = "MyPage";
            var result = Utils.RenderWebPage(
                p =>
                {
                    p.PageData["Title"] = title;
                    p.Write(p.PageData["Title"]);
                    p.Write(content);
                });

            Assert.Equal(title + content, result);
        }

        [Fact]
        public void RenderDynamicDictionaryBasicTest()
        {
            // A simple page that does the following:
            // @{ Page.Title = "MyPage"; }
            // @Page.Title
            // hello world
            //
            // Expected rendered result is "MyPagehello world"

            var content = "hello world";
            var title = "MyPage";
            var result = Utils.RenderWebPage(
                p =>
                {
                    p.Page.Title = title;
                    p.Write(p.Page.Title);
                    p.Write(content);
                });

            Assert.Equal(title + content, result);
        }

        [Fact]
        public void RenderPageBasicTest()
        {
            // ~/index.cshtml does the following:
            // hello
            // @RenderPage("subpage.cshtml")
            //
            // ~/subpage.cshtml does the following:
            // world
            //
            // Expected output is "helloworld"

            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.Write("hello");
                    p.Write(p.RenderPage("subpage.cshtml"));
                },
                p => { p.Write("world"); });
            Assert.Equal("helloworld", result);
        }

        [Fact]
        public void RenderPageAnonymousTypeTest()
        {
            // Test for passing an anonymous type object as an argument to RenderPage
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new { HelloKey = "hellovalue", MyKey = "myvalue" })
            //
            // ~/subpage.cshtml does the following:
            // @PageData["HelloKey"] @PageData["MyKey"] @Model.HelloKey @Model.MyKey
            //
            // Expected result: hellovalue myvalue hellovalue myvalue
            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", new { HelloKey = "hellovalue", MyKey = "myvalue" })); },
                p =>
                {
                    p.Write(p.PageData["HelloKey"]);
                    p.Write(" ");
                    p.Write(p.PageData["MyKey"]);
                    p.Write(" ");
                    p.Write(p.Model.HelloKey);
                    p.Write(" ");
                    p.Write(p.Model.MyKey);
                });
            Assert.Equal("hellovalue myvalue hellovalue myvalue", result);
        }

        [Fact]
        public void RenderPageDynamicDictionaryAnonymousTypeTest()
        {
            // Test for passing an anonymous type object as an argument to RenderPage
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new { HelloKey = "hellovalue", MyKey = "myvalue" })
            //
            // ~/subpage.cshtml does the following:
            // @Page.HelloKey @Page.MyKey @Model.HelloKey @Model.MyKey
            //
            // Expected result: hellovalue myvalue hellovalue myvalue
            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", new { HelloKey = "hellovalue", MyKey = "myvalue" })); },
                p =>
                {
                    p.Write(p.Page.HelloKey);
                    p.Write(" ");
                    p.Write(p.Page.MyKey);
                    p.Write(" ");
                    p.Write(p.Model.HelloKey);
                    p.Write(" ");
                    p.Write(p.Model.MyKey);
                });
            Assert.Equal("hellovalue myvalue hellovalue myvalue", result);
        }

        [Fact]
        public void RenderPageDictionaryTest()
        {
            // Test for passing a dictionary instance as an argument to RenderPage
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new Dictionary<string, object>(){ { "foo", 1 }, { "bar", "hello"} })
            //
            // ~/subpage.cshtml does the following:
            // @PageData["foo"] @PageData["bar"] @PageData[0]
            //
            // Expected result: 1 hello System.Collections.Generic.Dictionary`2[System.String,System.Object]

            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", new Dictionary<string, object>() { { "foo", 1 }, { "bar", "hello" } })); },
                p =>
                {
                    p.Write(p.PageData["foo"]);
                    p.Write(" ");
                    p.Write(p.PageData["bar"]);
                    p.Write(" ");
                    p.Write(p.PageData[0]);
                });
            Assert.Equal("1 hello System.Collections.Generic.Dictionary`2[System.String,System.Object]", result);
        }

        [Fact]
        public void RenderPageDynamicDictionaryTest()
        {
            // Test for passing a dictionary instance as an argument to RenderPage
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new Dictionary<string, object>(){ { "foo", 1 }, { "bar", "hello"} })
            //
            // ~/subpage.cshtml does the following:
            // @Page.foo @Page.bar @Page[0]
            //
            // Expected result: 1 hello System.Collections.Generic.Dictionary`2[System.String,System.Object]

            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", new Dictionary<string, object>() { { "foo", 1 }, { "bar", "hello" } })); },
                p =>
                {
                    p.Write(p.Page.foo);
                    p.Write(" ");
                    p.Write(p.Page.bar);
                    p.Write(" ");
                    p.Write(p.Page[0]);
                });
            Assert.Equal("1 hello System.Collections.Generic.Dictionary`2[System.String,System.Object]", result);
        }

        [Fact]
        public void RenderPageListTest()
        {
            // Test for passing a list of arguments to RenderPage
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", "hello", "world", 1, 2, 3)
            //
            // ~/subpage.cshtml does the following:
            // @PageData[0] @PageData[1] @PageData[2] @PageData[3] @PageData[4]
            //
            // Expected result: hello world 1 2 3

            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", "hello", "world", 1, 2, 3)); },
                p =>
                {
                    p.Write(p.PageData[0]);
                    p.Write(" ");
                    p.Write(p.PageData[1]);
                    p.Write(" ");
                    p.Write(p.PageData[2]);
                    p.Write(" ");
                    p.Write(p.PageData[3]);
                    p.Write(" ");
                    p.Write(p.PageData[4]);
                });
            Assert.Equal("hello world 1 2 3", result);
        }

        [Fact]
        public void RenderPageDynamicDictionaryListTest()
        {
            // Test for passing a list of arguments to RenderPage
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", "hello", "world", 1, 2, 3)
            //
            // ~/subpage.cshtml does the following:
            // @Page[0] @Page[1] @Page[2] @Page[3] @Page[4]
            //
            // Expected result: hello world 1 2 3

            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", "hello", "world", 1, 2, 3)); },
                p =>
                {
                    p.Write(p.Page[0]);
                    p.Write(" ");
                    p.Write(p.Page[1]);
                    p.Write(" ");
                    p.Write(p.Page[2]);
                    p.Write(" ");
                    p.Write(p.Page[3]);
                    p.Write(" ");
                    p.Write(p.Page[4]);
                });
            Assert.Equal("hello world 1 2 3", result);
        }

        private class Person
        {
            public string FirstName { get; set; }
        }

        [Fact]
        public void RenderPageDynamicValueTest()
        {
            // Test that PageData[key] returns a dynamic value.
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new Person(){ FirstName="MyFirstName" })
            //
            // ~/subpage.cshtml does the following:
            // @PageData[0].FirstName
            //
            // Expected result: MyFirstName
            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", new Person() { FirstName = "MyFirstName" })); },
                p => { p.Write(p.PageData[0].FirstName); });
            Assert.Equal("MyFirstName", result);
        }

        [Fact]
        public void RenderPageDynamicDictionaryDynamicValueTest()
        {
            // Test that PageData[key] returns a dynamic value.
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new Person(){ FirstName="MyFirstName" })
            //
            // ~/subpage.cshtml does the following:
            // @Page[0].FirstName
            //
            // Expected result: MyFirstName
            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", new Person() { FirstName = "MyFirstName" })); },
                p => { p.Write(p.Page[0].FirstName); });
            Assert.Equal("MyFirstName", result);
        }

        [Fact]
        public void PageDataSetByParentTest()
        {
            // Items set in the PageData should be accessible by the subpage
            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.PageData["test"] = "hello";
                    p.Write(p.RenderPage("subpage.cshtml"));
                },
                p => { p.Write(p.PageData["test"]); });
            Assert.Equal("hello", result);
        }

        [Fact]
        public void DynamicDictionarySetByParentTest()
        {
            // Items set in the PageData should be accessible by the subpage
            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.Page.test = "hello";
                    p.Write(p.RenderPage("subpage.cshtml"));
                },
                p => { p.Write(p.Page.test); });
            Assert.Equal("hello", result);
        }

        [Fact]
        public void OverridePageDataSetByParentTest()
        {
            // Items set in the PageData should be accessible by the subpage unless
            // overriden by parameters passed into RenderPage, in which case the 
            // specified value should be used.
            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.PageData["test"] = "hello";
                    p.Write(p.RenderPage("subpage.cshtml", new { Test = "world" }));
                },
                p =>
                {
                    p.Write(p.PageData["test"]);
                    p.Write(p.PageData[0].Test);
                });
            Assert.Equal("worldworld", result);
        }

        [Fact]
        public void OverrideDynamicDictionarySetByParentTest()
        {
            // Items set in the PageData should be accessible by the subpage unless
            // overriden by parameters passed into RenderPage, in which case the 
            // specified value should be used.
            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.PageData["test"] = "hello";
                    p.Write(p.RenderPage("subpage.cshtml", new { Test = "world" }));
                },
                p =>
                {
                    p.Write(p.Page.test);
                    p.Write(p.Page[0].Test);
                });
            Assert.Equal("worldworld", result);
        }

        [Fact]
        public void RenderPageMissingKeyTest()
        {
            // Test that using PageData with a missing key returns null
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new Dictionary<string, object>(){ { "foo", 1 }, { "bar", "hello"} })
            // @RenderPage("subpage.cshtml", "x", "y", "z")
            //
            // ~/subpage.cshtml does the following:
            // @(PageData[1] ?? "null")
            // @(PageData["bar"] ?? "null")
            //
            // Expected result: null hello y null

            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.Write(p.RenderPage("subpage.cshtml", new Dictionary<string, object>() { { "foo", 1 }, { "bar", "hello" } }));
                    p.Write(p.RenderPage("subpage.cshtml", "x", "y", "z"));
                },
                p =>
                {
                    p.Write(p.PageData[1] ?? "null1");
                    p.Write(" ");
                    p.Write(p.PageData["bar"] ?? "null2");
                    p.Write(" ");
                });
            Assert.Equal("null1 hello y null2 ", result);
        }

        [Fact]
        public void RenderPageDynamicDictionaryMissingKeyTest()
        {
            // Test that using PageData with a missing key returns null
            //
            // ~/index.cshtml does the following:
            // @RenderPage("subpage.cshtml", new Dictionary<string, object>(){ { "foo", 1 }, { "bar", "hello"} })
            // @RenderPage("subpage.cshtml", "x", "y", "z")
            //
            // ~/subpage.cshtml does the following:
            // @(Page[1] ?? "null")
            // @(Page.bar ?? "null")
            //
            // Expected result: null hello y null

            Action<WebPage> subPage = p =>
            {
                p.Write(p.Page[1] ?? "null1");
                p.Write(" ");
                p.Write(p.Page.bar ?? "null2");
                p.Write(" ");
            };
            var result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", new Dictionary<string, object>() { { "foo", 1 }, { "bar", "hello" } })); }, subPage);
            Assert.Equal("null1 hello ", result);
            result = Utils.RenderWebPageWithSubPage(
                p => { p.Write(p.RenderPage("subpage.cshtml", "x", "y", "z")); }, subPage);
            Assert.Equal("y null2 ", result);
        }

        [Fact]
        public void RenderPageNoArgumentsTest()
        {
            // Test that using PageData within the calling page, and also 
            // within the subppage when the calling page doesn't provide any arguments
            //
            // ~/index.cshtml does the following:
            // @(PageData["foo"] ?? "null1")
            // @RenderPage("subpage.cshtml")
            //
            // ~/subpage.cshtml does the following:
            // @(PageData[1] ?? "null2")
            // @(PageData["bar"] ?? "null3")
            //
            // Expected result: null1 null2 null3

            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "null1 ");
                    p.Write(p.RenderPage("subpage.cshtml"));
                },
                p =>
                {
                    p.Write(p.PageData[1] ?? "null2");
                    p.Write(" ");
                    p.Write(p.PageData["bar"] ?? "null3");
                });
            Assert.Equal("null1 null2 null3", result);
        }

        [Fact]
        public void RenderPageDynamicDictionaryNoArgumentsTest()
        {
            // Test that using PageData within the calling page, and also 
            // within the subppage when the calling page doesn't provide any arguments
            //
            // ~/index.cshtml does the following:
            // @(Page.foo ?? "null1")
            // @RenderPage("subpage.cshtml")
            //
            // ~/subpage.cshtml does the following:
            // @(Page[1] ?? "null2")
            // @(Page.bar ?? "null3")
            //
            // Expected result: null1 null2 null3

            var result = Utils.RenderWebPageWithSubPage(
                p =>
                {
                    p.Write(p.Page.foo ?? "null1 ");
                    p.Write(p.RenderPage("subpage.cshtml"));
                },
                p =>
                {
                    p.Write(p.Page[1] ?? "null2");
                    p.Write(" ");
                    p.Write(p.Page.bar ?? "null3");
                });
            Assert.Equal("null1 null2 null3", result);
        }

        [Fact]
        public void RenderPageNestedSubPageListTest()
        {
            // Test that PageData for each level of nesting returns the values as specified in the 
            // previous calling page.
            //
            // ~/index.cshtml does the following:
            // @(PageData["foo"] ?? "null")
            // @RenderPage("subpage1.cshtml", "a", "b", "c")
            //
            // ~/subpage1.cshtml does the following:
            // @(PageData[0] ?? "sub1null0")
            // @(PageData[1] ?? "sub1null1")
            // @(PageData[2] ?? "sub1null2")
            // @(PageData[3] ?? "sub1null3")
            // @RenderPage("subpage2.cshtml", "x", "y", "z")
            //
            // ~/subpage2.cshtml does the following:
            // @(PageData[0] ?? "sub2null0")
            // @(PageData[1] ?? "sub2null1")
            // @(PageData[2] ?? "sub2null2")
            // @(PageData[3] ?? "sub2null3")
            //
            // Expected result: null a b c sub1null3 x y z sub2null3
            var page = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "null ");
                    p.Write(p.RenderPage("subpage1.cshtml", "a", "b", "c"));
                });
            var subpage1Path = "~/subpage1.cshtml";
            var subpage1 = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData[0] ?? "sub1null0");
                    p.Write(" ");
                    p.Write(p.PageData[1] ?? "sub1null1");
                    p.Write(" ");
                    p.Write(p.PageData[2] ?? "sub1null2");
                    p.Write(" ");
                    p.Write(p.PageData[3] ?? "sub1null3");
                    p.Write(" ");
                    p.Write(p.RenderPage("subpage2.cshtml", "x", "y", "z"));
                }, subpage1Path);
            var subpage2Path = "~/subpage2.cshtml";
            var subpage2 = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData[0] ?? "sub2null0");
                    p.Write(" ");
                    p.Write(p.PageData[1] ?? "sub2null1");
                    p.Write(" ");
                    p.Write(p.PageData[2] ?? "sub2null2");
                    p.Write(" ");
                    p.Write(p.PageData[3] ?? "sub2null3");
                }, subpage2Path);

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, subpage1, subpage2);

            var result = Utils.RenderWebPage(page);
            Assert.Equal("null a b c sub1null3 x y z sub2null3", result);
        }

        [Fact]
        public void RenderPageNestedSubPageAnonymousTypeTest()
        {
            // Test that PageData for each level of nesting returns the values as specified in the 
            // previous calling page.
            //
            // ~/index.cshtml does the following:
            // @(PageData["foo"] ?? "null")
            // @RenderPage("subpage.cshtml", new { foo = 1 , bar = "hello" })
            //
            // ~/subpage1.cshtml does the following:
            // @(PageData["foo"] ?? "sub1nullfoo")
            // @(PageData["bar"] ?? "sub1nullbar")
            // @(PageData["x"] ?? "sub1nullx")
            // @(PageData["y"] ?? "sub1nully")
            // @RenderPage("subpage2.cshtml", new { bar = "world", x = "good", y = "bye"})
            //
            // ~/subpage2.cshtml does the following:
            // @(PageData["foo"] ?? "sub2nullfoo")
            // @(PageData["bar"] ?? "sub2nullbar")
            // @(PageData["x"] ?? "sub2nullx")
            // @(PageData["y"] ?? "sub2nully")
            //
            // Expected result: null 1 hello sub1nullx sub1nully sub2nullfoo world good bye
            var page = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "null ");
                    p.Write(p.RenderPage("subpage1.cshtml", new { foo = 1, bar = "hello" }));
                });
            var subpage1Path = "~/subpage1.cshtml";
            var subpage1 = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "sub1nullfoo");
                    p.Write(" ");
                    p.Write(p.PageData["bar"] ?? "sub1nullbar");
                    p.Write(" ");
                    p.Write(p.PageData["x"] ?? "sub1nullx");
                    p.Write(" ");
                    p.Write(p.PageData["y"] ?? "sub1nully");
                    p.Write(" ");
                    p.Write(p.RenderPage("subpage2.cshtml", new { bar = "world", x = "good", y = "bye" }));
                }, subpage1Path);
            var subpage2Path = "~/subpage2.cshtml";
            var subpage2 = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "sub2nullfoo");
                    p.Write(" ");
                    p.Write(p.PageData["bar"] ?? "sub2nullbar");
                    p.Write(" ");
                    p.Write(p.PageData["x"] ?? "sub2nullx");
                    p.Write(" ");
                    p.Write(p.PageData["y"] ?? "sub2nully");
                }, subpage2Path);

            Utils.AssignObjectFactoriesAndDisplayModeProvider(subpage1, subpage2, page);

            var result = Utils.RenderWebPage(page);
            Assert.Equal("null 1 hello sub1nullx sub1nully sub2nullfoo world good bye", result);
        }

        [Fact]
        public void RenderPageNestedSubPageDictionaryTest()
        {
            // Test that PageData for each level of nesting returns the values as specified in the 
            // previous calling page.
            //
            // ~/index.cshtml does the following:
            // @(PageData["foo"] ?? "null")
            // @RenderPage("subpage.cshtml", new Dictionary<string, object>(){ { "foo", 1 }, { "bar", "hello"} })
            //
            // ~/subpage1.cshtml does the following:
            // @(PageData["foo"] ?? "sub1nullfoo")
            // @(PageData["bar"] ?? "sub1nullbar")
            // @(PageData["x"] ?? "sub1nullx")
            // @(PageData["y"] ?? "sub1nully")
            // @RenderPage("subpage2.cshtml", new Dictionary<string, object>(){ { { "bar", "world"}, {"x", "good"}, {"y", "bye"} })
            //
            // ~/subpage2.cshtml does the following:
            // @(PageData["foo"] ?? "sub2nullfoo")
            // @(PageData["bar"] ?? "sub2nullbar")
            // @(PageData["x"] ?? "sub2nullx")
            // @(PageData["y"] ?? "sub2nully")
            //
            // Expected result: null 1 hello sub1nullx sub1nully sub2nullfoo world good bye
            var page = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "null ");
                    p.Write(p.RenderPage("subpage1.cshtml", new Dictionary<string, object>() { { "foo", 1 }, { "bar", "hello" } }));
                });
            var subpage1Path = "~/subpage1.cshtml";
            var subpage1 = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "sub1nullfoo");
                    p.Write(" ");
                    p.Write(p.PageData["bar"] ?? "sub1nullbar");
                    p.Write(" ");
                    p.Write(p.PageData["x"] ?? "sub1nullx");
                    p.Write(" ");
                    p.Write(p.PageData["y"] ?? "sub1nully");
                    p.Write(" ");
                    p.Write(p.RenderPage("subpage2.cshtml", new Dictionary<string, object>() { { "bar", "world" }, { "x", "good" }, { "y", "bye" } }));
                }, subpage1Path);
            var subpage2Path = "~/subpage2.cshtml";
            var subpage2 = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["foo"] ?? "sub2nullfoo");
                    p.Write(" ");
                    p.Write(p.PageData["bar"] ?? "sub2nullbar");
                    p.Write(" ");
                    p.Write(p.PageData["x"] ?? "sub2nullx");
                    p.Write(" ");
                    p.Write(p.PageData["y"] ?? "sub2nully");
                }, subpage2Path);

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, subpage1, subpage2);

            var result = Utils.RenderWebPage(page);
            Assert.Equal("null 1 hello sub1nullx sub1nully sub2nullfoo world good bye", result);
        }

        [Fact]
        public void RenderPageNestedParentPageDataTest()
        {
            // PageData should return values set by parent pages.
            var page = Utils.CreatePage(
                p =>
                {
                    p.PageData["key1"] = "value1";
                    p.Write(p.RenderPage("subpage1.cshtml"));
                });
            var subpage1Path = "~/subpage1.cshtml";
            var subpage1 = Utils.CreatePage(
                p =>
                {
                    p.WriteLiteral("<subpage1>");
                    p.Write(p.PageData["key1"]);
                    p.Write(p.RenderPage("subpage2.cshtml"));
                    p.Write(p.PageData["key1"]);
                    p.PageData["key1"] = "value2";
                    p.Write(p.RenderPage("subpage2.cshtml"));
                    p.WriteLiteral("</subpage1>");
                }, subpage1Path);
            var subpage2Path = "~/subpage2.cshtml";
            var subpage2 = Utils.CreatePage(
                p =>
                {
                    p.WriteLiteral("<subpage2>");
                    p.Write(p.PageData["key1"]);
                    // Setting the value in the child page should
                    // not affect the parent page
                    p.PageData["key1"] = "value3";
                    p.Write(p.RenderPage("subpage3.cshtml", new { Key1 = "value4" }));
                    p.WriteLiteral("</subpage2>");
                }, subpage2Path);
            var subpage3Path = "~/subpage3.cshtml";
            var subpage3 = Utils.CreatePage(
                p =>
                {
                    p.WriteLiteral("<subpage3>");
                    p.Write(p.PageData["key1"]);
                    p.WriteLiteral("</subpage3>");
                }, subpage3Path);

            Utils.AssignObjectFactoriesAndDisplayModeProvider(subpage1, subpage2, subpage3, page);

            var result = Utils.RenderWebPage(page);
            Assert.Equal("<subpage1>value1<subpage2>value1<subpage3>value4</subpage3></subpage2>value1<subpage2>value2<subpage3>value4</subpage3></subpage2></subpage1>", result);
        }

        [Fact]
        public void WriteNullTest()
        {
            // Test for @null
            var result = Utils.RenderWebPage(
                p =>
                {
                    p.Write(null);
                    p.Write((object)null);
                    p.Write((HelperResult)null);
                });

            Assert.Equal("", result);
        }

        [Fact]
        public void WriteTest()
        {
            // Test for calling WebPage.Write on text and HtmlHelper
            var text = "Hello";
            var wrote = false;
            Action<TextWriter> action = tw =>
            {
                tw.Write(text);
                wrote = true;
            };
            var helper = new HelperResult(action);
            var result = Utils.RenderWebPage(
                p => { p.Write(helper); });
            Assert.Equal(text, result);
            Assert.True(wrote);
        }

        [Fact]
        public void WriteLiteralTest()
        {
            // Test for calling WebPage.WriteLiteral on text and HtmlHelper
            var text = "Hello";
            var wrote = false;
            Action<TextWriter> action = tw =>
            {
                tw.Write(text);
                wrote = true;
            };
            var helper = new HelperResult(action);
            var result = Utils.RenderWebPage(
                p => { p.WriteLiteral(helper); });
            Assert.Equal(text, result);
            Assert.True(wrote);
        }

        [Fact]
        public void ExtensionNotSupportedTest()
        {
            // Tests that calling RenderPage on an unsupported extension returns a new simpler error message
            // instead of the full error about build providers in system.web.dll.
            var vpath = "~/hello/world.txt";
            var ext = ".txt";
            var compilationUtilThrowingBuildManager = new CompilationUtil();
            var otherExceptionBuildManager = new Mock<IVirtualPathFactory>();
            var msg = "The file \"~/hello/world.txt\" could not be rendered, because it does not exist or is not a valid page.";
            otherExceptionBuildManager.Setup(c => c.CreateInstance(It.IsAny<string>())).Throws(new HttpException(msg));

            Assert.Throws<HttpException>(() =>
                                                  WebPage.CreateInstanceFromVirtualPath(vpath, new VirtualPathFactoryManager(compilationUtilThrowingBuildManager)),
                                                  String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_FileNotSupported, ext, vpath));

            // Test that other error messages are thrown unmodified.
            Assert.Throws<HttpException>(() => WebPage.CreateInstanceFromVirtualPath(vpath, otherExceptionBuildManager.Object), msg);
        }

        [Fact]
        public void RenderBodyCalledInChildPageTest()
        {
            // A Page that is called by RenderPage should not be able to call RenderBody().

            Assert.Throws<HttpException>(() =>
                Utils.RenderWebPageWithSubPage(
                    p =>
                    {
                        p.Write("hello");
                        p.Write(p.RenderPage("subpage.cshtml"));
                    },
                    p =>
                    {
                        p.Write("world");
                        p.RenderBody();
                    }),
                String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_CannotRequestDirectly, "~/subpage.cshtml", "RenderBody"));
        }

        [Fact]
        public void RenderPageInvalidPageType()
        {
            var pagePath = "~/foo.js";
            var page = Utils.CreatePage(p => { p.Write(p.RenderPage(pagePath)); });

            var objectFactory = new Mock<IVirtualPathFactory>();
            objectFactory.Setup(c => c.Exists(It.IsAny<string>())).Returns<string>(p => pagePath.Equals(p, StringComparison.OrdinalIgnoreCase));
            objectFactory.Setup(c => c.CreateInstance(It.IsAny<string>())).Returns<string>(_ => null);
            page.VirtualPathFactory = objectFactory.Object;

            Assert.Throws<HttpException>(() =>
            {
                page.VirtualPathFactory = objectFactory.Object;
                page.DisplayModeProvider = new DisplayModeProvider();
                Utils.RenderWebPage(page);
            },
            String.Format(CultureInfo.CurrentCulture, WebPageResources.WebPage_InvalidPageType, pagePath));
        }

        [Fact]
        public void RenderPageValidPageType()
        {
            var pagePath = "~/foo.js";
            var page = Utils.CreatePage(p => { p.Write(p.RenderPage(pagePath)); });

            var contents = "hello world";
            var subPage = Utils.CreatePage(p => p.Write(contents), pagePath);

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, subPage);

            Assert.Equal(contents, Utils.RenderWebPage(page));
        }

        [Fact]
        public void RenderPageNull()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => Utils.RenderWebPage(p => p.RenderPage(null)), "path");
        }

        [Fact]
        public void RenderPageEmptyString()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => Utils.RenderWebPage(p => p.RenderPage("")), "path");
        }

        [Fact]
        public void SamePageCaseInsensitiveTest()
        {
            var result = Utils.RenderWebPage(
                p =>
                {
                    p.PageData["xyz"] = "value";
                    p.PageData["XYZ"] = "VALUE";
                    p.Write(p.PageData["xYz"]);
                });

            Assert.Equal("VALUE", result);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/RequestBrowserOverrideStoreTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class RequestBrowserOverrideStoreTest
    {
        [Fact]
        public void GetOverriddenUserAgentReturnsRequestUserAgent()
        {
            // Arrange
            RequestBrowserOverrideStore requestStore = new RequestBrowserOverrideStore();
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Request.UserAgent).Returns("testUserAgent");

            // Act & Assert
            Assert.Equal("testUserAgent", requestStore.GetOverriddenUserAgent(context.Object));
        }

        [Fact]
        public void SetOverriddenUserAgentDoesNotOverrideUserAgent()
        {
            // Arrange
            RequestBrowserOverrideStore requestStore = new RequestBrowserOverrideStore();
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Request.UserAgent).Returns("testUserAgent");

            // Act
            requestStore.SetOverriddenUserAgent(context.Object, "setUserAgent");

            // Assert
            Assert.Equal("testUserAgent", requestStore.GetOverriddenUserAgent(context.Object));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/RequestResourceTrackerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class RequestResourceTrackerTest
    {
        [Fact]
        public void RegisteringForDisposeDisposesObjects()
        {
            // Arrange
            var context = new Mock<HttpContextBase>();
            IDictionary items = new Hashtable();
            context.Setup(m => m.Items).Returns(items);
            var disposable = new Mock<IDisposable>();
            disposable.Setup(m => m.Dispose()).Verifiable();

            // Act
            RequestResourceTracker.RegisterForDispose(context.Object, disposable.Object);
            RequestResourceTracker.DisposeResources(context.Object);

            // Assert
            disposable.VerifyAll();
        }

        [Fact]
        public void RegisteringForDisposeExtensionMethodNullContextThrows()
        {
            // Arrange
            var disposable = new Mock<IDisposable>();

            // Act
            Assert.ThrowsArgumentNull(() => HttpContextExtensions.RegisterForDispose(null, disposable.Object), "context");
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/StartPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;
using System.Web.Caching;
using System.Web.Compilation;
using System.Web.Hosting;
using System.Web.Profile;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class StartPageTest
    {
        // The page ~/_pagestart.cshtml does the following:
        // this is the init page
        //
        // The page ~/index.cshtml does the following:
        // hello world
        // Expected result:
        // this is the init page hello world
        [Fact]
        public void InitPageBasicTest()
        {
            var init = Utils.CreateStartPage(p =>
                                             p.Write("this is the init page "));
            var page = Utils.CreatePage(p =>
                                        p.Write("hello world"));

            init.ChildPage = page;

            var result = Utils.RenderWebPage(page, init);
            Assert.Equal("this is the init page hello world", result);
        }

        // The page ~/_pagestart.cshtml does the following:
        // this is the init page
        //
        // The page ~/folder1/index.cshtml does the following:
        // hello world
        // Expected result:
        // this is the init page hello world
        [Fact]
        public void InitSubfolderTest()
        {
            var init = Utils.CreateStartPage(p =>
                                             p.Write("this is the init page "));
            var page = Utils.CreatePage(p =>
                                        p.Write("hello world"), "~/folder1/index.cshtml");

            init.ChildPage = page;

            var result = Utils.RenderWebPage(page, init);
            Assert.Equal("this is the init page hello world", result);
        }

        // The page ~/_pagestart.cshtml does the following:
        // PageData["Title"] = "InitPage";
        // Layout = "Layout.cshtml";
        // this is the init page
        //
        // The page ~/index.cshtml does the following:
        // PageData["Title"] = "IndexCshtmlPage"
        // hello world
        //
        // The layout page ~/Layout.cshtml does the following:
        // layout start
        // @PageData["Title"]
        // @RenderBody()
        // layout end
        //
        // Expected result:
        // layout start IndexCshtmlPage this is the init page hello world layout end
        [Fact]
        public void InitPageLayoutTest()
        {
            var init = Utils.CreateStartPage(p =>
            {
                p.Layout = "Layout.cshtml";
                p.Write(" this is the init page ");
                Assert.Equal("~/Layout.cshtml", p.Layout);
            });
            var page = Utils.CreatePage(p =>
            {
                p.PageData["Title"] = "IndexCshtmlPage";
                p.Write("hello world");
            });
            var layoutPage = Utils.CreatePage(p =>
            {
                p.Write("layout start ");
                p.Write(p.PageData["Title"]);
                p.WriteLiteral(p.RenderBody());
                p.Write(" layout end");
            }, "~/Layout.cshtml");

            init.ChildPage = page;
            Utils.AssignObjectFactoriesAndDisplayModeProvider(init, page, layoutPage);

            var result = Utils.RenderWebPage(page, init);
            Assert.Equal("layout start IndexCshtmlPage this is the init page hello world layout end", result);
        }

        // _pagestart.cshtml sets the LayoutPage to be null
        [Fact]
        public void InitPageNullLayoutPageTest()
        {
            var init1 = Utils.CreateStartPage(
                p =>
                {
                    p.Layout = "~/Layout.cshtml";
                    p.WriteLiteral("<init1>");
                    p.RunPage();
                    p.WriteLiteral("</init1>");
                });
            var init2path = "~/folder1/_pagestart.cshtml";
            var init2 = Utils.CreateStartPage(
                p =>
                {
                    p.Layout = null;
                    p.WriteLiteral("<init2>");
                    p.RunPage();
                    p.WriteLiteral("</init2>");
                }, init2path);
            var page = Utils.CreatePage(p =>
                                        p.Write("hello world"), "~/folder1/index.cshtml");
            var layoutPage = Utils.CreatePage(p =>
                                              p.Write("layout page"), "~/Layout.cshtml");

            Utils.AssignObjectFactoriesAndDisplayModeProvider(page, layoutPage, init1, init2);

            init1.ChildPage = init2;
            init2.ChildPage = page;

            var result = Utils.RenderWebPage(page, init1);
            Assert.Equal("<init1><init2>hello world</init2></init1>", result);
        }

        // _pagestart.cshtml sets the LayoutPage, but page sets it to null
        [Fact]
        public void PageSetsNullLayoutPageTest()
        {
            var init1 = Utils.CreateStartPage(
                p =>
                {
                    p.Layout = "~/Layout.cshtml";
                    p.WriteLiteral("<init1>");
                    p.RunPage();
                    p.WriteLiteral("</init1>");
                });
            var layoutPage = Utils.CreatePage(p =>
                                              p.Write("layout page"), "~/Layout.cshtml");
            var page = Utils.CreatePage(p =>
            {
                p.Layout = null;
                p.Write("hello world");
            });
            Utils.AssignObjectFactoriesAndDisplayModeProvider(init1, layoutPage, page);
            init1.ChildPage = page;
            var result = Utils.RenderWebPage(page, init1);
            Assert.Equal("<init1>hello world</init1>", result);
        }

        [Fact]
        public void PageSetsEmptyLayoutPageTest()
        {
            var init1 = Utils.CreateStartPage(
                p =>
                {
                    p.Layout = "~/Layout.cshtml";
                    p.WriteLiteral("<init1>");
                    p.RunPage();
                    p.WriteLiteral("</init1>");
                });
            var layoutPage = Utils.CreatePage(p =>
                                              p.Write("layout page"), "~/Layout.cshtml");
            var page = Utils.CreatePage(p =>
            {
                p.Layout = "";
                p.Write("hello world");
            });
            Utils.AssignObjectFactoriesAndDisplayModeProvider(init1, layoutPage, page);
            init1.ChildPage = page;
            var result = Utils.RenderWebPage(page, init1);
            Assert.Equal("<init1>hello world</init1>", result);
        }

        // The page ~/_pagestart.cshtml does the following:
        // init page start
        // @RunPage()
        // init page end
        //
        // The page ~/index.cshtml does the following:
        // hello world
        //
        // Expected result:
        // init page start hello world init page end
        [Fact]
        public void RunPageTest()
        {
            var init = Utils.CreateStartPage(
                p =>
                {
                    p.Write("init page start ");
                    p.RunPage();
                    p.Write(" init page end");
                });
            var page = Utils.CreatePage(p =>
                                        p.Write("hello world"));

            init.ChildPage = page;

            var result = Utils.RenderWebPage(page, init);
            Assert.Equal("init page start hello world init page end", result);
        }

        // The page ~/_pagestart.cshtml does the following:
        // <init1>
        // @RunPage()
        // </init1>
        //
        // The page ~/folder1/_pagestart.cshtml does the following:
        // <init2>
        // @RunPage()
        // </init2>
        //
        // The page ~/folder1/index.cshtml does the following:
        // hello world
        //
        // Expected result:
        // <init1><init2>hello world</init2></init1>
        [Fact]
        public void NestedRunPageTest()
        {
            var init1 = Utils.CreateStartPage(
                p =>
                {
                    p.WriteLiteral("<init1>");
                    p.RunPage();
                    p.WriteLiteral("</init1>");
                });
            var init2path = "~/folder1/_pagestart.cshtml";
            var init2 = Utils.CreateStartPage(
                p =>
                {
                    p.WriteLiteral("<init2>");
                    p.RunPage();
                    p.WriteLiteral("</init2>");
                }, init2path);
            var page = Utils.CreatePage(p =>
                                        p.Write("hello world"), "~/folder1/index.cshtml");

            init1.ChildPage = init2;
            init2.ChildPage = page;

            var result = Utils.RenderWebPage(page, init1);
            Assert.Equal("<init1><init2>hello world</init2></init1>", result);
        }

        // The page ~/_pagestart.cshtml does the following:
        // PageData["key1"] = "value1";
        //
        // The page ~/folder1/_pagestart.cshtml does the following:
        // PageData["key2"] = "value2";
        //
        // The page ~/folder1/index.cshtml does the following:
        // @PageData["key1"] @PageData["key2"] @PageData["key3"]
        //
        // Expected result:
        // value1 value2
        [Fact]
        public void PageDataTest()
        {
            var init1 = Utils.CreateStartPage(p => p.PageData["key1"] = "value1");
            var init2path = "~/folder1/_pagestart.cshtml";
            var init2 = Utils.CreateStartPage(p => p.PageData["key2"] = "value2", init2path);
            var page = Utils.CreatePage(
                p =>
                {
                    p.Write(p.PageData["key1"]);
                    p.Write(" ");
                    p.Write(p.PageData["key2"]);
                },
                "~/folder1/index.cshtml");

            init1.ChildPage = init2;
            init2.ChildPage = page;

            var result = Utils.RenderWebPage(page, init1);
            Assert.Equal("value1 value2", result);
        }

        // The page ~/_pagestart.cshtml does the following:
        // init page
        // @RenderPage("subpage.cshtml", "init_data");
        //
        // The page ~/subpage.cshtml does the following:
        // subpage
        // @PageData[0]
        //
        // The page ~/index.cshtml does the following:
        // hello world
        //
        // Expected result:
        // init page subpage init_data hello world
        [Fact]
        public void RenderPageTest()
        {
            var init = Utils.CreateStartPage(
                p =>
                {
                    p.Write("init page ");
                    p.Write(p.RenderPage("subpage.cshtml", "init_data"));
                });
            var subpagePath = "~/subpage.cshtml";
            var subpage = Utils.CreatePage(
                p =>
                {
                    p.Write("subpage ");
                    p.Write(p.PageData[0]);
                }, subpagePath);
            var page = Utils.CreatePage(p =>
                                        p.Write(" hello world"));

            init.ChildPage = page;
            Utils.AssignObjectFactoriesAndDisplayModeProvider(init, page, subpage);

            var result = Utils.RenderWebPage(page, init);
            Assert.Equal("init page subpage init_data hello world", result);
        }

        [Fact]
        // The page ~/_pagestart.cshtml does the following:
        // <init>
        // @{
        //     try {
        //         RunPage();
        //     } catch (Exception e) {
        //         Write("Exception: " + e.Message);
        //     }
        // }
        // </init>
        //
        // The page ~/index.cshtml does the following:
        // hello world
        // @{throw new InvalidOperation("exception from index.cshtml");}
        //
        // Expected result:
        // <init>hello world Exception: exception from index.cshtml</init>
        public void InitCatchExceptionTest()
        {
            var init = Utils.CreateStartPage(
                p =>
                {
                    p.WriteLiteral("<init>");
                    try
                    {
                        p.RunPage();
                    }
                    catch (Exception e)
                    {
                        p.Write("Exception: " + e.Message);
                    }
                    p.WriteLiteral("</init>");
                });
            var page = Utils.CreatePage(
                p =>
                {
                    p.WriteLiteral("hello world ");
                    throw new InvalidOperationException("exception from index.cshtml");
                });

            init.ChildPage = page;

            var result = Utils.RenderWebPage(page, init);
            Assert.Equal("<init>hello world Exception: exception from index.cshtml</init>", result);
        }

        public class MockInitPage : MockStartPage
        {
            internal object GetBuildManager()
            {
                return typeof(BuildManager).GetField("_theBuildManager", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
            }
        }

        // Simulate a site that is nested, eg /subfolder1/website1
        [Fact]
        public void ExecuteWithinInitTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                Utils.CreateHttpRuntime("/subfolder1/website1");
                new HostingEnvironment();
                var stringSet = Activator.CreateInstance(typeof(BuildManager).Assembly.GetType("System.Web.Util.StringSet"), true);
                typeof(BuildManager).GetField("_forbiddenTopLevelDirectories", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(new MockInitPage().GetBuildManager(), stringSet);
                ;

                var init = new MockInitPage()
                {
                    VirtualPath = "~/_pagestart.cshtml",
                    ExecuteAction = p => { },
                };
                var page = Utils.CreatePage(p => { });

                Utils.AssignObjectFactoriesAndDisplayModeProvider(page, init);

                var result = Utils.RenderWebPage(page);
            });
        }

        [Fact]
        public void SetGetPropertiesTest()
        {
            var init = new MockInitPage();
            var page = new MockPage();
            init.ChildPage = page;

            // Context
            var context = new Mock<HttpContextBase>().Object;
            init.Context = context;
            Assert.Equal(context, init.Context);
            Assert.Equal(context, page.Context);

            // Profile/Request/Response/Server/Cache/Session/Application
            var profile = new Mock<ProfileBase>().Object;
            var request = new Mock<HttpRequestBase>().Object;
            var response = new Mock<HttpResponseBase>().Object;
            var server = new Mock<HttpServerUtilityBase>().Object;
            var cache = new Cache();
            var app = new Mock<HttpApplicationStateBase>().Object;
            var session = new Mock<HttpSessionStateBase>().Object;

            var contextMock = new Mock<HttpContextBase>();
            contextMock.Setup(c => c.Profile).Returns(profile);
            contextMock.Setup(c => c.Request).Returns(request);
            contextMock.Setup(c => c.Response).Returns(response);
            contextMock.Setup(c => c.Cache).Returns(cache);
            contextMock.Setup(c => c.Server).Returns(server);
            contextMock.Setup(c => c.Application).Returns(app);
            contextMock.Setup(c => c.Session).Returns(session);

            context = contextMock.Object;
            page.Context = context;
            Assert.Same(profile, init.Profile);
            Assert.Same(request, init.Request);
            Assert.Same(response, init.Response);
            Assert.Same(cache, init.Cache);
            Assert.Same(server, init.Server);
            Assert.Same(session, init.Session);
            Assert.Same(app, init.AppState);
        }

        [Fact]
        public void GetDirectoryTest()
        {
            var initPage = new Mock<StartPage>().Object;
            Assert.Equal("/website1/", initPage.GetDirectory("/website1/default.cshtml"));
            Assert.Equal("~/", initPage.GetDirectory("~/default.cshtml"));
            Assert.Equal("/", initPage.GetDirectory("/website1/"));
            Assert.Null(initPage.GetDirectory("/"));
        }

        [Fact]
        public void GetStartPageReturnsStartPageFromCurrentDirectoryIfExists()
        {
            // Arrange
            var initPage = Utils.CreateStartPage(p => p.Write("<init>"), "~/subdir/_pagestart.vbhtml");
            var page = Utils.CreatePage(p => p.Write("test"), "~/subdir/_index.cshtml");
            var objectFactory = Utils.AssignObjectFactoriesAndDisplayModeProvider(page, initPage);

            // Act
            var result = StartPage.GetStartPage(page, objectFactory, null, WebPageHttpHandler.StartPageFileName, new string[] { "cshtml", "vbhtml" });

            // Assert
            Assert.Equal(initPage, result);
        }

        [Fact]
        public void GetStartPageReturnsStartPageFromParentDirectoryIfStartPageDoesNotExistInCurrentDirectory()
        {
            // Arrange
            var initPage = Utils.CreateStartPage(null, "~/subdir/_pagestart.vbhtml");
            var page = Utils.CreatePage(null, "~/subdir/subsubdir/test.cshtml");
            var objectFactory = Utils.AssignObjectFactoriesAndDisplayModeProvider(page, initPage);

            // Act
            var result = StartPage.GetStartPage(page, objectFactory, null, WebPageHttpHandler.StartPageFileName, new string[] { "cshtml", "vbhtml" });

            // Assert
            Assert.Equal(initPage, result);
        }

        [Fact]
        public void GetStartPageCreatesChainOfStartPages()
        {
            // Arrange
            var subInitPage = Utils.CreateStartPage(null, "~/subdir/_pagestart.vbhtml");
            var initPage = Utils.CreateStartPage(null, "~/_pagestart.vbhtml");
            var page = Utils.CreatePage(null, "~/subdir/subsubdir/subsubsubdir/test.cshtml");
            var objectFactory = Utils.AssignObjectFactoriesAndDisplayModeProvider(page, initPage, subInitPage);

            // Act
            var result = StartPage.GetStartPage(page, objectFactory, null, WebPageHttpHandler.StartPageFileName, new string[] { "cshtml", "vbhtml" });

            // Assert
            Assert.Equal(initPage, result);
            Assert.Equal(subInitPage, (result as StartPage).ChildPage);
        }

        [Fact]
        public void GetStartPageReturnsStartPageFromRoot()
        {
            // Arrange
            var initPage = Utils.CreateStartPage(null, "~/_pagestart.vbhtml");
            var page = Utils.CreatePage(null, "~/subdir/subsubdir/subsubsubdir/subsubsubsubdir/why-does-this-remind-me-of-a-movie-title.cshtml");
            var objectFactory = Utils.AssignObjectFactoriesAndDisplayModeProvider(page, initPage);

            // Act
            var result = StartPage.GetStartPage(page, objectFactory, null, WebPageHttpHandler.StartPageFileName, new string[] { "cshtml", "vbhtml" });

            // Assert
            Assert.Equal(initPage, result);
        }

        [Fact]
        public void GetStartPageUsesBothFileNamesAndExtensionsWhenDeterminingStartPage()
        {
            // Arrange
            var subInitPage = Utils.CreateStartPage(null, "~/subdir/_pagestart.jshtml");
            var initPage = Utils.CreateStartPage(null, "~/_pagestart.vbhtml");
            var page = Utils.CreatePage(null, "~/subdir/test.cshtml");
            var objectFactory = Utils.AssignObjectFactoriesAndDisplayModeProvider(page, initPage, subInitPage);

            // Act
            var result = StartPage.GetStartPage(page, objectFactory, null, WebPageHttpHandler.StartPageFileName, new string[] { "cshtml", "vbhtml" });

            // Assert
            Assert.Equal(initPage, result);
        }

        [Fact]
        public void GetStartPage_ThrowsOnNullPage()
        {
            Assert.ThrowsArgumentNull(() => StartPage.GetStartPage(null, "name", new[] { "cshtml" }), "page");
        }

        [Fact]
        public void GetStartPage_ThrowsOnNullFileName()
        {
            var page = Utils.CreatePage(p => p.Write("test"));
            Assert.ThrowsArgumentNullOrEmptyString(() => StartPage.GetStartPage(page, null, new[] { "cshtml" }), "fileName");
        }

        [Fact]
        public void GetStartPage_ThrowsOnEmptyFileName()
        {
            var page = Utils.CreatePage(p => p.Write("test"));
            Assert.ThrowsArgumentNullOrEmptyString(() => StartPage.GetStartPage(page, String.Empty, new[] { "cshtml" }), "fileName");
        }

        [Fact]
        public void GetStartPage_ThrowsOnNullSupportedExtensions()
        {
            var page = Utils.CreatePage(p => p.Write("test"));
            Assert.ThrowsArgumentNull(() => StartPage.GetStartPage(page, "name", null), "supportedExtensions");
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/TemplateStackTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class WebPageContextStackTest
    {
        [Fact]
        public void GetCurrentContextReturnsNullWhenStackIsEmpty()
        {
            // Arrange
            var httpContext = GetHttpContext();

            // Act
            var template = TemplateStack.GetCurrentTemplate(httpContext);

            // Assert
            Assert.Equal(1, httpContext.Items.Count);
            Assert.Null(template);
        }

        [Fact]
        public void GetCurrentContextReturnsCurrentContext()
        {
            // Arrange
            var template = GetTemplateFile();
            var httpContext = GetHttpContext();

            // Act
            TemplateStack.Push(httpContext, template);

            // Assert
            var currentTemplate = TemplateStack.GetCurrentTemplate(httpContext);
            Assert.Equal(template, currentTemplate);
        }

        [Fact]
        public void GetCurrentContextReturnsLastPushedContext()
        {
            // Arrange
            var httpContext = GetHttpContext();
            var template1 = GetTemplateFile("page1");
            var template2 = GetTemplateFile("page2");

            // Act
            TemplateStack.Push(httpContext, template1);
            TemplateStack.Push(httpContext, template2);

            // Assert
            var currentTemplate = TemplateStack.GetCurrentTemplate(httpContext);
            Assert.Equal(template2, currentTemplate);
        }

        [Fact]
        public void GetCurrentContextReturnsNullAfterPop()
        {
            // Arrange
            var httpContext = GetHttpContext();
            var template = GetTemplateFile();

            // Act
            TemplateStack.Push(httpContext, template);
            TemplateStack.Pop(httpContext);

            // Assert
            Assert.Null(TemplateStack.GetCurrentTemplate(httpContext));
        }

        private static HttpContextBase GetHttpContext()
        {
            Mock<HttpContextBase> context = new Mock<HttpContextBase>();
            context.Setup(c => c.Items).Returns(new Dictionary<object, object>());

            return context.Object;
        }

        private static ITemplateFile GetTemplateFile(string path = null)
        {
            Mock<ITemplateFile> templateFile = new Mock<ITemplateFile>();
            templateFile.Setup(f => f.TemplateInfo).Returns(new TemplateFileInfo(path));

            return templateFile.Object;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/UrlDataTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class UrlDataTest
    {
        [Fact]
        public void UrlDataListConstructorTests()
        {
            Assert.NotNull(new UrlDataList(null));
            Assert.NotNull(new UrlDataList(String.Empty));
            Assert.NotNull(new UrlDataList("abc/foo"));
        }

        [Fact]
        public void AddTest()
        {
            var d = new UrlDataList(null);
            var item = "!!@#$#$";
            Assert.Throws<NotSupportedException>(() => { d.Add(item); }, "The UrlData collection is read-only.");
        }

        [Fact]
        public void ClearTest()
        {
            var d = new UrlDataList(null);
            Assert.Throws<NotSupportedException>(() => { d.Clear(); }, "The UrlData collection is read-only.");
        }

        [Fact]
        public void IndexOfTest()
        {
            var item = "!!@#$#$";
            var item2 = "13l53125";
            var d = new UrlDataList(item + "/" + item2);
            Assert.Equal(0, d.IndexOf(item));
            Assert.Equal(1, d.IndexOf(item2));
        }

        [Fact]
        public void InsertAtTest()
        {
            var d = new UrlDataList("x/y/z");
            Assert.Throws<NotSupportedException>(() => { d.Insert(1, "a"); }, "The UrlData collection is read-only.");
        }

        [Fact]
        public void ContainsTest()
        {
            var item = "!!@#$#$";
            var d = new UrlDataList(item);
            Assert.Contains(item, d);
        }

        [Fact]
        public void CopyToTest()
        {
            var d = new UrlDataList("x/y");
            string[] array = new string[2];
            d.CopyTo(array, 0);
            Assert.Equal(array[0], d[0]);
            Assert.Equal(array[1], d[1]);
        }

        [Fact]
        public void GetEnumeratorTest()
        {
            var d = new UrlDataList("x");
            var e = d.GetEnumerator();
            e.MoveNext();
            Assert.Equal("x", e.Current);
        }

        [Fact]
        public void RemoveTest()
        {
            var d = new UrlDataList("x");
            Assert.Throws<NotSupportedException>(() => { d.Remove("x"); }, "The UrlData collection is read-only.");
        }

        [Fact]
        public void RemoveAtTest()
        {
            var d = new UrlDataList("x/y");
            Assert.Throws<NotSupportedException>(() => { d.RemoveAt(0); }, "The UrlData collection is read-only.");
        }

        [Fact]
        public void CountTest()
        {
            var d = new UrlDataList("x");
            Assert.Single(d);
        }

        [Fact]
        public void IsReadOnlyTest()
        {
            var d = new UrlDataList(null);
            Assert.True(d.IsReadOnly);
        }

        [Fact]
        public void ItemTest()
        {
            var d = new UrlDataList("x/y");
            Assert.Equal("x", d[0]);
            Assert.Equal("y", d[1]);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/Utils.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.IO;
using System.Reflection;
using System.Text;
using System.Web.Hosting;
using System.Web.WebPages.TestUtils;
using Moq;

namespace System.Web.WebPages.Test
{
    public static class Utils
    {
        public static string RenderWebPage(WebPage page, StartPage startPage = null, HttpRequestBase request = null)
        {
            var writer = new StringWriter();

            // Create an actual dummy HttpContext that has a request object
            var filename = "default.aspx";
            var url = "http://localhost/default.aspx";

            request = request ?? CreateTestRequest(filename, url).Object;
            var httpContext = CreateTestContext(request);

            var pageContext = new WebPageContext { HttpContext = httpContext.Object };
            page.ExecutePageHierarchy(pageContext, writer, startPage);
            return writer.ToString();
        }

        public static Mock<HttpContextBase> CreateTestContext(HttpRequestBase request = null, HttpResponseBase response = null, IDictionary items = null)
        {
            items = items ?? new Hashtable();
            request = request ?? CreateTestRequest("default.cshtml", "http://localhost/default.cshtml").Object;

            if (response == null)
            {
                var mockResponse = new Mock<HttpResponseBase>();
                mockResponse.Setup(r => r.Cookies).Returns(new HttpCookieCollection());
                response = mockResponse.Object;
            }

            var httpContext = new Mock<HttpContextBase>();
            httpContext.SetupGet(c => c.Items).Returns(items);
            httpContext.SetupGet(c => c.Request).Returns(request);
            httpContext.SetupGet(c => c.Response).Returns(response);
            return httpContext;
        }

        public static Mock<HttpRequestBase> CreateTestRequest(string filename, string url)
        {
            var mockRequest = new Mock<HttpRequestBase> { CallBase = true };
            mockRequest.SetupGet(r => r.Path).Returns(filename);
            mockRequest.SetupGet(r => r.RawUrl).Returns(url);
            mockRequest.SetupGet(r => r.IsLocal).Returns(false);
            mockRequest.SetupGet(r => r.QueryString).Returns(new NameValueCollection());
            mockRequest.SetupGet(r => r.Browser.IsMobileDevice).Returns(false);
            mockRequest.SetupGet(r => r.Cookies).Returns(new HttpCookieCollection());
            mockRequest.SetupGet(r => r.UserAgent).Returns(String.Empty);

            return mockRequest;
        }

        public static string RenderWebPage(Action<WebPage> pageExecuteAction, string pagePath = "~/index.cshtml")
        {
            var page = CreatePage(pageExecuteAction, pagePath);
            return RenderWebPage(page);
        }

        public static MockPage CreatePage(Action<WebPage> pageExecuteAction, string pagePath = "~/index.cshtml")
        {
            var page = new MockPage()
            {
                VirtualPath = pagePath,
                ExecuteAction = p => { pageExecuteAction(p); }
            };
            page.VirtualPathFactory = new HashVirtualPathFactory(page);
            page.DisplayModeProvider = new DisplayModeProvider();
            return page;
        }

        public static MockStartPage CreateStartPage(Action<StartPage> pageExecuteAction, string pagePath = "~/_pagestart.cshtml")
        {
            var page = new MockStartPage()
            {
                VirtualPath = pagePath,
                ExecuteAction = p => { pageExecuteAction(p); }
            };
            page.VirtualPathFactory = new HashVirtualPathFactory(page);
            page.DisplayModeProvider = new DisplayModeProvider();
            return page;
        }

        public static string RenderWebPageWithSubPage(Action<WebPage> pageExecuteAction, Action<WebPage> subpageExecuteAction,
                                                      string pagePath = "~/index.cshtml", string subpagePath = "~/subpage.cshtml")
        {
            var page = CreatePage(pageExecuteAction);
            var subPage = CreatePage(subpageExecuteAction, subpagePath);
            var virtualPathFactory = new HashVirtualPathFactory(page, subPage);
            subPage.VirtualPathFactory = virtualPathFactory;
            page.VirtualPathFactory = virtualPathFactory;
            return RenderWebPage(page);
        }

        // E.g. "default.aspx", "http://localhost/WebSite1/subfolder1/default.aspx"

        /// <summary>
        /// Creates an instance of HttpContext and assigns it to HttpContext.Current. Ensure that the returned value is disposed at the end of the test.
        /// </summary>
        /// <returns>Returns an IDisposable that restores the original HttpContext.</returns>
        internal static IDisposable CreateHttpContext(string filename, string url)
        {
            var request = new HttpRequest(filename, url, null);
            var httpContext = new HttpContext(request, new HttpResponse(new StringWriter(new StringBuilder())));
            HttpContext.Current = httpContext;

            return new DisposableAction(RestoreHttpContext);
        }

        internal static void RestoreHttpContext()
        {
            HttpContext.Current = null;
        }

        internal static IDisposable CreateHttpRuntime(string appVPath)
        {
            return WebUtils.CreateHttpRuntime(appVPath);
        }

        public static void SetupVirtualPathInAppDomain(string vpath, string contents)
        {
            var file = new Mock<VirtualFile>(vpath);
            file.Setup(f => f.Open()).Returns(new MemoryStream(ASCIIEncoding.Default.GetBytes(contents)));
            var vpp = new Mock<VirtualPathProvider>();
            vpp.Setup(p => p.FileExists(vpath)).Returns(true);
            vpp.Setup(p => p.GetFile(vpath)).Returns(file.Object);
            AppDomainUtils.SetAppData();
            var env = new HostingEnvironment();

            var register = typeof(HostingEnvironment).GetMethod("RegisterVirtualPathProviderInternal", BindingFlags.Static | BindingFlags.NonPublic);
            register.Invoke(null, new object[] { vpp.Object });
        }

        /// <summary>
        /// Assigns a common object factory to the pages.
        /// </summary>
        internal static IVirtualPathFactory AssignObjectFactoriesAndDisplayModeProvider(params WebPageExecutingBase[] pages)
        {
            var objectFactory = new HashVirtualPathFactory(pages);
            var displayModeProvider = new DisplayModeProvider();
            foreach (var item in pages)
            {
                item.VirtualPathFactory = objectFactory;
                var webPageRenderingBase = item as WebPageRenderingBase;
                if (webPageRenderingBase != null)
                {
                    webPageRenderingBase.DisplayModeProvider = displayModeProvider;
                }
            }

            return objectFactory;
        }

        internal static DisplayModeProvider AssignDisplayModeProvider(params WebPageRenderingBase[] pages)
        {
            var displayModeProvider = new DisplayModeProvider();
            foreach (var item in pages)
            {
                item.DisplayModeProvider = displayModeProvider;
            }
            return displayModeProvider;
        }
    }

    public class MockPageHelper
    {
        internal static string GetDirectory(string virtualPath)
        {
            var dir = Path.GetDirectoryName(virtualPath);
            if (dir == "~")
            {
                return null;
            }
            return dir;
        }
    }

    // This is a mock implementation of WebPage mainly to make the Render method work and
    // generate a string.
    // The Execute method simulates what is typically generated based on markup by the parsers.
    public class MockPage : WebPage
    {
        public Action<WebPage> ExecuteAction { get; set; }

        internal override string GetDirectory(string virtualPath)
        {
            return MockPageHelper.GetDirectory(virtualPath);
        }

        public override void Execute()
        {
            ExecuteAction(this);
        }
    }

    public class MockStartPage : StartPage
    {
        public Action<StartPage> ExecuteAction { get; set; }

        internal override string GetDirectory(string virtualPath)
        {
            return MockPageHelper.GetDirectory(virtualPath);
        }

        public override void Execute()
        {
            ExecuteAction(this);
        }

        public Dictionary<string, object> CombinedPageInstances
        {
            get
            {
                var combinedInstances = new Dictionary<string, object>();
                var instances = new Dictionary<string, object>();
                WebPageRenderingBase childPage = this;
                while (childPage != null)
                {
                    if (childPage is MockStartPage)
                    {
                        var initPage = childPage as MockStartPage;
                        childPage = initPage.ChildPage;
                    }
                    else if (childPage is MockPage)
                    {
                        childPage = null;
                    }
                    foreach (var kvp in instances)
                    {
                        combinedInstances.Add(kvp.Key, kvp.Value);
                    }
                }
                return combinedInstances;
            }
        }
    }

    public class MockHttpRuntime
    {
        public static Version RequestValidationMode { get; set; }
    }

    public class MockHttpApplication
    {
        public static Type ModuleType { get; set; }

        public static void RegisterModule(Type moduleType)
        {
            ModuleType = moduleType;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/VirtualPathFactoryExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class VirtualPathFactoryExtensionsTest
    {
        [Fact]
        public void VirtualPathFactoryExtensionsSpecialCasesVirtualPathFactoryManager()
        {
            // Arrange
            var virtualPath = "~/index.cshtml";
            var mockPage = Utils.CreatePage(_ => { }, virtualPath);
            var factory = new Mock<IVirtualPathFactory>();
            factory.Setup(c => c.Exists(virtualPath)).Returns(true).Verifiable();
            factory.Setup(c => c.CreateInstance(virtualPath)).Returns(mockPage);

            // Act
            var factoryManager = new VirtualPathFactoryManager(factory.Object);
            var page = factoryManager.CreateInstance<WebPageBase>(virtualPath);

            // Assert
            Assert.Equal(mockPage, page);
            factory.Verify();
        }

        [Fact]
        public void GenericCreateInstanceLoopsOverAllRegisteredFactories()
        {
            // Arrange
            var virtualPath = "~/index.cshtml";
            var mockPage = Utils.CreatePage(_ => { }, virtualPath);
            var factory1 = new HashVirtualPathFactory(mockPage);
            var factory2 = new HashVirtualPathFactory(Utils.CreatePage(null, "~/_admin/index.cshtml"));

            // Act
            var factoryManager = new VirtualPathFactoryManager(factory2);
            factoryManager.RegisterVirtualPathFactoryInternal(factory1);
            var page = factoryManager.CreateInstance<WebPageBase>(virtualPath);

            // Assert
            Assert.Equal(mockPage, page);
        }

        [Fact]
        public void GenericCreateInstanceReturnsNullIfNoFactoryCanCreateVirtualPath()
        {
            // Arrange
            var factory1 = new HashVirtualPathFactory(Utils.CreatePage(_ => { }, "~/index.cshtml"));
            var factory2 = new HashVirtualPathFactory(Utils.CreatePage(null, "~/_admin/index.cshtml"));

            // Act
            var factoryManager = new VirtualPathFactoryManager(factory2);
            factoryManager.RegisterVirtualPathFactoryInternal(factory1);
            var page = factoryManager.CreateInstance<WebPageBase>("~/does-not-exist.cshtml");

            // Assert
            Assert.Null(page);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/VirtualPathFactoryManagerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class VirtualPathFactoryManagerTest
    {
        [Fact]
        public void DefaultFactoryIsListedInRegisteredFactories()
        {
            // Arrange
            var factory = new HashVirtualPathFactory();

            // Act
            var factoryManager = new VirtualPathFactoryManager(factory);

            // Assert
            Assert.Equal(factory, factoryManager.RegisteredFactories.Single());
        }

        [Fact]
        public void RegisterFactoryEnsuresDefaultFactoryRemainsTheLast()
        {
            // Arrange
            var defaultFactory = new HashVirtualPathFactory();
            var factory1 = new HashVirtualPathFactory();
            var factory2 = new HashVirtualPathFactory();
            var factory3 = new HashVirtualPathFactory();

            // Act
            var factoryManager = new VirtualPathFactoryManager(defaultFactory);
            factoryManager.RegisterVirtualPathFactoryInternal(factory1);
            factoryManager.RegisterVirtualPathFactoryInternal(factory2);
            factoryManager.RegisterVirtualPathFactoryInternal(factory3);

            // Assert
            Assert.Equal(factory1, factoryManager.RegisteredFactories.ElementAt(0));
            Assert.Equal(factory2, factoryManager.RegisteredFactories.ElementAt(1));
            Assert.Equal(factory3, factoryManager.RegisteredFactories.ElementAt(2));
            Assert.Equal(defaultFactory, factoryManager.RegisteredFactories.Last());
        }

        [Fact]
        public void CreateInstanceUsesRegisteredFactoriesForExistence()
        {
            // Arrange
            var path = "~/index.cshtml";
            var factory1 = new Mock<IVirtualPathFactory>();
            factory1.Setup(c => c.Exists(path)).Returns(false).Verifiable();
            var factory2 = new Mock<IVirtualPathFactory>();
            factory2.Setup(c => c.Exists(path)).Returns(true).Verifiable();
            var factory3 = new Mock<IVirtualPathFactory>();
            factory3.Setup(c => c.Exists(path)).Throws(new Exception("This factory should not be called since the page has already been found in 2"));
            var defaultFactory = new Mock<IVirtualPathFactory>();
            defaultFactory.Setup(c => c.Exists(path)).Throws(new Exception("This factory should not be called since it always called last"));

            var vpfm = new VirtualPathFactoryManager(defaultFactory.Object);
            vpfm.RegisterVirtualPathFactoryInternal(factory1.Object);
            vpfm.RegisterVirtualPathFactoryInternal(factory2.Object);
            vpfm.RegisterVirtualPathFactoryInternal(factory3.Object);

            // Act
            var result = vpfm.Exists(path);

            // Assert
            Assert.True(result);

            factory1.Verify();
            factory2.Verify();
        }

        [Fact]
        public void CreateInstanceLooksThroughAllRegisteredFactoriesForExistence()
        {
            // Arrange
            var page = Utils.CreatePage(null);
            var factory1 = new Mock<IVirtualPathFactory>();
            factory1.Setup(c => c.Exists(page.VirtualPath)).Returns(false).Verifiable();
            var factory2 = new Mock<IVirtualPathFactory>();
            factory2.Setup(c => c.Exists(page.VirtualPath)).Returns(true).Verifiable();
            factory2.Setup(c => c.CreateInstance(page.VirtualPath)).Returns(page).Verifiable();
            var factory3 = new Mock<IVirtualPathFactory>();
            factory3.Setup(c => c.Exists(page.VirtualPath)).Throws(new Exception("This factory should not be called since the page has already been found in 2"));
            var defaultFactory = new Mock<IVirtualPathFactory>();
            defaultFactory.Setup(c => c.Exists(page.VirtualPath)).Throws(new Exception("This factory should not be called since it always called last"));

            var vpfm = new VirtualPathFactoryManager(defaultFactory.Object);
            vpfm.RegisterVirtualPathFactoryInternal(factory1.Object);
            vpfm.RegisterVirtualPathFactoryInternal(factory2.Object);
            vpfm.RegisterVirtualPathFactoryInternal(factory3.Object);

            // Act
            var result = vpfm.CreateInstance(page.VirtualPath);

            // Assert
            Assert.Equal(page, result);

            factory1.Verify();
            factory2.Verify();
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/WebPageContextTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using System.IO;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class WebPageContextTest
    {
        [Fact]
        public void CreateNestedPageContextCopiesPropertiesFromParentPageContext()
        {
            // Arrange
            var httpContext = new Mock<HttpContextBase>();
            var pageDataDictionary = new Dictionary<object, dynamic>();
            var model = new { Hello = "World" };
            Action<TextWriter> bodyAction = writer => { };
            var sectionWritersStack = new Stack<Dictionary<string, SectionWriter>>();
            var basePageContext = new WebPageContext(httpContext.Object, null, null) { BodyAction = bodyAction, SectionWritersStack = sectionWritersStack };

            // Act
            var subPageContext = WebPageContext.CreateNestedPageContext(basePageContext, pageDataDictionary, model, isLayoutPage: false);

            // Assert
            Assert.Equal(basePageContext.HttpContext, subPageContext.HttpContext);
            Assert.Equal(basePageContext.OutputStack, subPageContext.OutputStack);
            Assert.Equal(basePageContext.Validation, subPageContext.Validation);
            Assert.Equal(basePageContext.ModelState, subPageContext.ModelState);
            Assert.Equal(pageDataDictionary, subPageContext.PageData);
            Assert.Equal(model, subPageContext.Model);
            Assert.Null(subPageContext.BodyAction);
        }

        [Fact]
        public void CreateNestedPageCopiesBodyActionAndSectionWritersWithOtherPropertiesFromParentPageContext()
        {
            // Arrange
            var httpContext = new Mock<HttpContextBase>();
            var pageDataDictionary = new Dictionary<object, dynamic>();
            var model = new { Hello = "World" };
            Action<TextWriter> bodyAction = writer => { };
            var sectionWritersStack = new Stack<Dictionary<string, SectionWriter>>();
            var basePageContext = new WebPageContext(httpContext.Object, null, null) { BodyAction = bodyAction, SectionWritersStack = sectionWritersStack };

            // Act
            var subPageContext = WebPageContext.CreateNestedPageContext(basePageContext, pageDataDictionary, model, isLayoutPage: true);

            // Assert
            Assert.Equal(basePageContext.HttpContext, subPageContext.HttpContext);
            Assert.Equal(basePageContext.OutputStack, subPageContext.OutputStack);
            Assert.Equal(basePageContext.Validation, subPageContext.Validation);
            Assert.Equal(basePageContext.ModelState, subPageContext.ModelState);
            Assert.Equal(pageDataDictionary, subPageContext.PageData);
            Assert.Equal(model, subPageContext.Model);
            Assert.Equal(sectionWritersStack, subPageContext.SectionWritersStack);
            Assert.Equal(bodyAction, subPageContext.BodyAction);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/WebPageExecutingBaseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.IO;
using System.Text;
using System.Web.WebPages.Instrumentation;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class WebPageExecutingBaseTest
    {
        [Fact]
        public void NormalizeLayoutPageUsesVirtualPathFactoryManagerToDetermineIfLayoutFileExists()
        {
            // Arrange
            var layoutPagePath = "~/sitelayout.cshtml";
            var layoutPage = Utils.CreatePage(null, layoutPagePath);
            var page = Utils.CreatePage(null);
            var objectFactory = new Mock<IVirtualPathFactory>();
            objectFactory.Setup(c => c.Exists(It.Is<string>(p => p.Equals(layoutPagePath)))).Returns(true).Verifiable();
            page.VirtualPathFactory = objectFactory.Object;

            // Act
            var path = page.NormalizeLayoutPagePath(layoutPage.VirtualPath);

            // Assert
            objectFactory.Verify();
            Assert.Equal(path, layoutPage.VirtualPath);
        }

        [Fact]
        public void NormalizeLayoutPageAcceptsRelativePathsToLayoutPage()
        {
            // Arrange
            var page = Utils.CreatePage(null, "~/dir/default.cshtml");
            var layoutPage = Utils.CreatePage(null, "~/layouts/sitelayout.cshtml");
            var objectFactory = new HashVirtualPathFactory(page, layoutPage);
            page.VirtualPathFactory = objectFactory;

            // Act
            var path = page.NormalizeLayoutPagePath(@"../layouts/sitelayout.cshtml");

            // Assert
            Assert.Equal(path, layoutPage.VirtualPath);
        }

        [Fact]
        public void BeginContextSilentlyFailsIfInstrumentationIsNotAvailable()
        {
            // Arrange
            bool called = false;

            var pageMock = new Mock<WebPageExecutingBase>() { CallBase = true };
            pageMock.Setup(p => p.Context).Returns(new Mock<HttpContextBase>().Object);
            pageMock.Object.InstrumentationService.IsAvailable = false;
            pageMock.Object.InstrumentationService.ExtractInstrumentationService = c =>
            {
                called = true;
                return null;
            };

            // Act
            pageMock.Object.BeginContext("~/dir/default.cshtml", 0, 1, true);

            // Assert
            Assert.False(called);
        }

        [Fact]
        public void EndContextSilentlyFailsIfInstrumentationIsNotAvailable()
        {
            // Arrange
            bool called = false;

            var pageMock = new Mock<WebPageExecutingBase>() { CallBase = true };
            pageMock.Setup(p => p.Context).Returns(new Mock<HttpContextBase>().Object);
            pageMock.Object.InstrumentationService.IsAvailable = false;
            pageMock.Object.InstrumentationService.ExtractInstrumentationService = c =>
            {
                called = true;
                return null;
            };

            // Act
            pageMock.Object.EndContext("~/dir/default.cshtml", 0, 1, true);

            // Assert
            Assert.False(called);
        }

        [Fact]
        public void WriteAttributeToWritesAttributeNormallyIfNoValuesSpecified()
        {
            WriteAttributeTest(
                name: "alt",
                prefix: new PositionTagged<string>(" alt=\"", 42),
                suffix: new PositionTagged<string>("\"", 24),
                expected: " alt=\"\"");
        }

        [Fact]
        public void WriteAttributeToWritesNothingIfSingleNullValueProvided()
        {
            WriteAttributeTest(
                name: "alt",
                prefix: new PositionTagged<string>(" alt=\"", 42),
                suffix: new PositionTagged<string>("\"", 24),
                values: new[] {
                    new AttributeValue(new PositionTagged<string>(String.Empty, 142), new PositionTagged<object>(null, 124), literal: true)
                },
                expected: "");
        }

        [Fact]
        public void WriteAttributeToWritesNothingIfSingleFalseValueProvided()
        {
            WriteAttributeTest(
                name: "alt",
                prefix: new PositionTagged<string>(" alt=\"", 42),
                suffix: new PositionTagged<string>("\"", 24),
                values: new[] {
                    new AttributeValue(new PositionTagged<string>(String.Empty, 142), new PositionTagged<object>(false, 124), literal: true)
                },
                expected: "");
        }

        [Fact]
        public void WriteAttributeToWritesGlobalPrefixIfSingleValueProvided()
        {
            WriteAttributeTest(
                name: "alt",
                prefix: new PositionTagged<string>(" alt=\"", 42),
                suffix: new PositionTagged<string>("\"", 24),
                values: new[] {
                    new AttributeValue(new PositionTagged<string>("    ", 142), new PositionTagged<object>("foo", 124), literal: true)
                },
                expected: " alt=\"foo\"");
        }

        [Fact]
        public void WriteAttributeToWritesLocalPrefixForSecondValueProvided()
        {
            WriteAttributeTest(
                name: "alt",
                prefix: new PositionTagged<string>(" alt=\"", 42),
                suffix: new PositionTagged<string>("\"", 24),
                values: new[] {
                    new AttributeValue(new PositionTagged<string>("    ", 142), new PositionTagged<object>("foo", 124), literal: true),
                    new AttributeValue(new PositionTagged<string>("glorb", 142), new PositionTagged<object>("bar", 124), literal: true)
                },
                expected: " alt=\"fooglorbbar\"");
        }

        [Fact]
        public void WriteAttributeToWritesGlobalPrefixOnlyIfSecondValueIsFirstNonNullOrFalse()
        {
            WriteAttributeTest(
                name: "alt",
                prefix: new PositionTagged<string>(" alt=\"", 42),
                suffix: new PositionTagged<string>("\"", 24),
                values: new[] {
                    new AttributeValue(new PositionTagged<string>("    ", 142), new PositionTagged<object>(null, 124), literal: true),
                    new AttributeValue(new PositionTagged<string>("glorb", 142), new PositionTagged<object>("bar", 124), literal: true)
                },
                expected: " alt=\"bar\"");
        }

        /// <remarks>
        /// This is a regression test for Html.Raw behaving incorrectly in attributes - the code here is derived from that generated
        /// by the Razor engine on input like the following:
        /// 
        /// cool="@Html.Raw("this is cool text")"
        /// </remarks>
        [Fact]
        public void WriteAttributeWithRawHtmlString()
        {
            string alreadyEncoded = "Show Size 6½-8";
            WriteAttributeTest(
                name: "alt",
                prefix: new PositionTagged<string>(" cool=\"", 33),
                suffix: new PositionTagged<string>("\"", 70),
                values: new[] {
                    AttributeValue.FromTuple(Tuple.Create(Tuple.Create("", 40), Tuple.Create<Object, Int32>(new HtmlString(alreadyEncoded), 40), false)), 
                },
                expected: " cool=\"" + alreadyEncoded + "\"");
        }

        private void WriteAttributeTest(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, string expected)
        {
            WriteAttributeTest(name, prefix, suffix, new AttributeValue[0], expected);
        }

        private void WriteAttributeTest(string name, PositionTagged<string> prefix, PositionTagged<string> suffix, AttributeValue[] values, string expected)
        {
            // Arrange
            var pageMock = new Mock<WebPageExecutingBase>() { CallBase = true };
            pageMock.Setup(p => p.Context).Returns(new Mock<HttpContextBase>().Object);
            pageMock.Object.InstrumentationService.IsAvailable = false;

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

            // Act
            pageMock.Object.WriteAttributeTo(writer, name, prefix, suffix, values);

            // Assert
            Assert.Equal(expected, written.ToString());
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/WebPageHttpHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Security;
using System.Text;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class WebPageHttpHandlerTest
    {
        [Fact]
        public void ConstructorThrowsWithNullPage()
        {
            Assert.ThrowsArgumentNull(() => new WebPageHttpHandler(null), "webPage");
        }

        [Fact]
        public void IsReusableTest()
        {
            WebPage dummyPage = new DummyPage();
            Assert.False(new WebPageHttpHandler(dummyPage).IsReusable);
        }

        [Fact]
        public void ProcessRequestTest()
        {
            var contents = "test";
            var tw = new StringWriter(new StringBuilder());
            var httpContext = CreateTestContext(tw);
            var page = Utils.CreatePage(p => p.Write(contents));
            new WebPageHttpHandler(page).ProcessRequestInternal(httpContext);
            Assert.Equal(contents, tw.ToString());
        }

        [Fact]
        public void SourceFileHeaderTest()
        {
            // Arrange
            var contents = "test";
            var writer = new StringWriter();

            Mock<HttpResponseBase> httpResponse = new Mock<HttpResponseBase>();
            httpResponse.SetupGet(r => r.Output).Returns(writer);
            Mock<HttpRequestBase> httpRequest = Utils.CreateTestRequest("~/index.cshtml", "~/index.cshtml");
            httpRequest.SetupGet(r => r.IsLocal).Returns(true);
            httpRequest.Setup(r => r.MapPath(It.IsAny<string>())).Returns<string>(p => p);
            Mock<HttpContextBase> context = Utils.CreateTestContext(httpRequest.Object, httpResponse.Object);
            var page = Utils.CreatePage(p => p.Write(contents));

            // Act
            var webPageHttpHandler = new WebPageHttpHandler(page);
            webPageHttpHandler.ProcessRequestInternal(context.Object);

            // Assert
            Assert.Equal(contents, writer.ToString());
            Assert.Single(page.PageContext.SourceFiles);
            Assert.Contains("~/index.cshtml", page.PageContext.SourceFiles);
        }

        [Fact]
        public void GenerateSourceFilesHeaderGenerates2047EncodedValue()
        {
            // Arrange
            string headerKey = null, headerValue = null;
            var context = new Mock<HttpContextBase>();
            var response = new Mock<HttpResponseBase>();
            response.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback(
                (string key, string value) =>
                {
                    headerKey = key;
                    headerValue = value;
                });
            context.Setup(c => c.Response).Returns(response.Object);
            context.Setup(c => c.Items).Returns(new Hashtable());

            var webPageContext = new WebPageContext(context.Object, page: null, model: null);
            webPageContext.SourceFiles.Add("foo");
            webPageContext.SourceFiles.Add("bar");
            webPageContext.SourceFiles.Add("λ");

            // Act
            WebPageHttpHandler.GenerateSourceFilesHeader(webPageContext);

            // Assert
            Assert.Equal("X-SourceFiles", headerKey);
            Assert.Equal("=?UTF-8?B?Zm9vfGJhcnzOuw==?=", headerValue);
        }

        [Fact]
        public void HttpHandlerGeneratesSourceFilesHeadersIfRequestIsLocal()
        {
            // Arrange
            string pagePath = "~/index.cshtml", layoutPath = "~/Layout.cshtml", layoutPageName = "Layout.cshtml";
            var page = Utils.CreatePage(p => { p.Layout = layoutPageName; }, pagePath);
            var layoutPage = Utils.CreatePage(p => { p.RenderBody(); }, layoutPath);
            Utils.AssignObjectFactoriesAndDisplayModeProvider(layoutPage, page);


            var headers = new NameValueCollection();
            var request = Utils.CreateTestRequest(pagePath, pagePath);
            request.Setup(c => c.IsLocal).Returns(true);
            request.Setup(c => c.MapPath(It.IsAny<string>())).Returns<string>(path => path);
            request.Setup(c => c.Cookies).Returns(new HttpCookieCollection());

            var response = new Mock<HttpResponseBase>() { CallBase = true };
            response.SetupGet(r => r.Headers).Returns(headers);
            response.SetupGet(r => r.Output).Returns(TextWriter.Null);
            response.Setup(r => r.AppendHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((name, value) => headers.Add(name, value));
            response.Setup(r => r.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((name, value) => headers.Add(name, value));
            response.Setup(r => r.Cookies).Returns(new HttpCookieCollection());

            var context = Utils.CreateTestContext(request.Object, response.Object);

            // Act
            var webPageHttpHandler = new WebPageHttpHandler(page);
            webPageHttpHandler.ProcessRequestInternal(context.Object);

            // Assert
            Assert.Equal(LatestRazorVersion.MajorMinor, headers[WebPageHttpHandler.WebPagesVersionHeaderName]);
            Assert.Equal("=?UTF-8?B?fi9pbmRleC5jc2h0bWx8fi9MYXlvdXQuY3NodG1s?=", headers["X-SourceFiles"]);
        }

        [Fact]
        public void ExceptionTest()
        {
            var contents = "test";
            var httpContext = Utils.CreateTestContext().Object;
            var page = Utils.CreatePage(p => { throw new InvalidOperationException(contents); });
            var e = Assert.Throws<HttpUnhandledException>(
                () => new WebPageHttpHandler(page).ProcessRequestInternal(httpContext)
            );
            Assert.IsType<InvalidOperationException>(e.InnerException);
            Assert.Equal(contents, e.InnerException.Message, StringComparer.Ordinal);
        }

        [Fact]
        public void SecurityExceptionTest()
        {
            var contents = "test";
            var httpContext = Utils.CreateTestContext().Object;
            var page = Utils.CreatePage(p => { throw new SecurityException(contents); });
            Assert.Throws<SecurityException>(
                () => new WebPageHttpHandler(page).ProcessRequestInternal(httpContext),
                contents);
        }

        [Fact]
        public void CreateFromVirtualPathTest()
        {
            var contents = "test";
            var textWriter = new StringWriter();

            var httpResponse = new Mock<HttpResponseBase>();
            httpResponse.SetupGet(r => r.Output).Returns(textWriter);
            var httpContext = Utils.CreateTestContext(response: httpResponse.Object);
            var mockBuildManager = new Mock<IVirtualPathFactory>();
            var virtualPath = "~/hello/test.cshtml";
            var page = Utils.CreatePage(p => p.Write(contents));
            mockBuildManager.Setup(c => c.Exists(It.Is<string>(p => p.Equals(virtualPath)))).Returns<string>(_ => true).Verifiable();
            mockBuildManager.Setup(c => c.CreateInstance(It.Is<string>(p => p.Equals(virtualPath)))).Returns(page).Verifiable();

            // Act
            IHttpHandler handler = WebPageHttpHandler.CreateFromVirtualPath(virtualPath, new VirtualPathFactoryManager(mockBuildManager.Object));
            WebPageHttpHandler webPageHttpHandler = Assert.IsType<WebPageHttpHandler>(handler);
            webPageHttpHandler.ProcessRequestInternal(httpContext.Object);

            // Assert
            Assert.Equal(contents, textWriter.ToString());
            mockBuildManager.Verify();
        }

        [Fact]
        public void VersionHeaderTest()
        {
            Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
            mockResponse.Setup(response => response.AppendHeader("X-AspNetWebPages-Version", LatestRazorVersion.MajorMinor)).Verifiable();

            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.SetupGet(context => context.Response).Returns(mockResponse.Object);

            WebPageHttpHandler.AddVersionHeader(mockContext.Object);
            mockResponse.Verify();
        }

        [Fact]
        public void CreateFromVirtualPathNonWebPageTest()
        {
            // Arrange
            var virtualPath = "~/hello/test.cshtml";
            var handler = new WebPageHttpHandler(new DummyPage());
            var mockBuildManager = new Mock<IVirtualPathFactory>();
            mockBuildManager.Setup(c => c.CreateInstance(It.IsAny<string>())).Returns(handler);
            mockBuildManager.Setup(c => c.Exists(It.Is<string>(p => p.Equals(virtualPath)))).Returns<string>(_ => true).Verifiable();

            // Act
            var result = WebPageHttpHandler.CreateFromVirtualPath(virtualPath, new VirtualPathFactoryManager(mockBuildManager.Object));

            // Assert
            Assert.Equal(handler, result);
            mockBuildManager.Verify();
        }

        [Fact]
        public void CreateFromVirtualPathReturnsIHttpHandlerIfItCannotCreateAWebPageType()
        {
            // Arrange
            var pageVirtualPath = "~/hello/test.cshtml";
            var handlerVirtualPath = "~/handler.asmx";
            var page = new DummyPage();
            var handler = new Mock<IHttpHandler>().Object;
            var mockFactory = new Mock<IVirtualPathFactory>();
            mockFactory.Setup(c => c.Exists(It.IsAny<string>())).Returns(true);
            mockFactory.Setup(c => c.CreateInstance(pageVirtualPath)).Returns(page);
            mockFactory.Setup(c => c.CreateInstance(handlerVirtualPath)).Returns(handler);

            // Act
            var handlerResult = WebPageHttpHandler.CreateFromVirtualPath(handlerVirtualPath, mockFactory.Object);
            var pageResult = WebPageHttpHandler.CreateFromVirtualPath(pageVirtualPath, mockFactory.Object);

            // Assert
            Assert.Equal(handler, handlerResult);
            Assert.NotNull(pageResult as WebPageHttpHandler);
        }

        private static HttpContextBase CreateTestContext(TextWriter textWriter)
        {
            var filename = "default.aspx";
            var url = "http://localhost/WebSite1/subfolder1/default.aspx";
            var request = Utils.CreateTestRequest(filename, url);

            var response = new Mock<HttpResponseBase>();
            response.SetupGet(r => r.Output).Returns(textWriter);

            return Utils.CreateTestContext(request: request.Object, response: response.Object).Object;
        }

        private sealed class DummyPage : WebPage
        {
            public override void Execute()
            {
            }
        }
    }
}

================================================
FILE: test/System.Web.WebPages.Test/WebPage/WebPageHttpModuleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace System.Web.WebPages.Test
{
    public class WebPageHttpModuleTest
    {
        [Fact]
        public void InitializeApplicationTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var moduleEvents = new ModuleEvents();
                var app = new MyHttpApplication();
                WebPageHttpModule.InitializeApplication(app,
                                                        moduleEvents.OnApplicationPostResolveRequestCache,
                                                        moduleEvents.Initialize);
                Assert.True(moduleEvents.CalledInitialize);
            });
        }

        [Fact]
        public void StartApplicationTest()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                var moduleEvents = new ModuleEvents();
                var app = new MyHttpApplication();
                WebPageHttpModule.StartApplication(app, moduleEvents.ExecuteStartPage, moduleEvents.ApplicationStart);
                Assert.Equal(1, moduleEvents.CalledExecuteStartPage);
                Assert.Equal(1, moduleEvents.CalledApplicationStart);

                // Call a second time to make sure the methods are only called once
                WebPageHttpModule.StartApplication(app, moduleEvents.ExecuteStartPage, moduleEvents.ApplicationStart);
                Assert.Equal(1, moduleEvents.CalledExecuteStartPage);
                Assert.Equal(1, moduleEvents.CalledApplicationStart);
            });
        }

        public class MyHttpApplication : HttpApplication
        {
            public MyHttpApplication()
            {
            }
        }

        public class ModuleEvents
        {
            public void OnApplicationPostResolveRequestCache(object sender, EventArgs e)
            {
            }

            public void OnBeginRequest(object sender, EventArgs e)
            {
            }

            public void OnEndRequest(object sender, EventArgs e)
            {
            }

            public bool CalledInitialize;

            public void Initialize(object sender, EventArgs e)
            {
                CalledInitialize = true;
            }

            public int CalledExecuteStartPage;

            public void ExecuteStartPage(HttpApplication application)
            {
                CalledExecuteStartPage++;
            }

            public int CalledApplicationStart;

            public void ApplicationStart(object sender, EventArgs e)
            {
                CalledApplicationStart++;
            }
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/WebPageRenderingBaseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class WebPageRenderingBaseTest
    {
        [Fact]
        public void SetCultureThrowsIfValueIsNull()
        {
            // Arrange
            string value = null;
            var webPageRenderingBase = new Mock<WebPageRenderingBase>() { CallBase = true }.Object;

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => webPageRenderingBase.Culture = value, "value");
        }

        [Fact]
        public void SetCultureThrowsIfValueIsEmpty()
        {
            // Arrange
            string value = String.Empty;
            var webPageRenderingBase = new Mock<WebPageRenderingBase>() { CallBase = true }.Object;

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => webPageRenderingBase.Culture = value, "value");
        }

        [Fact]
        public void SetUICultureThrowsIfValueIsNull()
        {
            // Arrange
            string value = null;
            var webPageRenderingBase = new Mock<WebPageRenderingBase>() { CallBase = true }.Object;

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => webPageRenderingBase.UICulture = value, "value");
        }

        [Fact]
        public void SetUICultureThrowsIfValueIsEmpty()
        {
            // Arrange
            string value = String.Empty;
            var webPageRenderingBase = new Mock<WebPageRenderingBase>() { CallBase = true }.Object;

            // Act and Assert
            Assert.ThrowsArgumentNullOrEmptyString(() => webPageRenderingBase.UICulture = value, "value");
        }

        [Fact]
        public void DisplayModePropertyWithNullContext()
        {
            // Arrange
            var context = new Mock<HttpContextBase>();
            var displayMode = new DefaultDisplayMode("test");
            var webPageRenderingBase = new Mock<WebPageRenderingBase>() { CallBase = true };

            // Act & Assert
            Assert.Null(webPageRenderingBase.Object.DisplayMode);
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/WebPageRouteTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class WebPageRouteTest
    {
        private class HashyBuildManager : IVirtualPathFactory
        {
            private readonly HashSet<string> _existingFiles;

            public HashyBuildManager(IEnumerable<string> validFilePaths)
            {
                _existingFiles = new HashSet<string>(validFilePaths, StringComparer.InvariantCultureIgnoreCase);
            }

            public bool Exists(string virtualPath)
            {
                return _existingFiles.Contains(virtualPath);
            }

            public object CreateInstance(string virtualPath)
            {
                throw new NotSupportedException();
            }
        }

        // Helper to test smarty route match, null match string is used for no expected match
        private static void ConstraintTest(IEnumerable<string> validFiles, IEnumerable<string> supportedExt, string url, string match, string pathInfo, bool mobileDevice = false)
        {
            var objectFactory = new HashyBuildManager(validFiles);
            var mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(context => context.Items).Returns(new Hashtable());
            mockContext.Setup(c => c.Request.Browser.IsMobileDevice).Returns(mobileDevice);
            mockContext.Setup(c => c.Request.Cookies).Returns(new HttpCookieCollection());
            mockContext.Setup(c => c.Response.Cookies).Returns(new HttpCookieCollection());
            var displayModeProvider = new DisplayModeProvider();

            WebPageMatch smartyMatch = WebPageRoute.MatchRequest(url, supportedExt.ToArray(), objectFactory.Exists, mockContext.Object, displayModeProvider);
            if (match != null)
            {
                Assert.NotNull(smartyMatch);
                Assert.Equal(match, smartyMatch.MatchedPath);
                Assert.Equal(pathInfo, smartyMatch.PathInfo);
            }
            else
            {
                Assert.Null(smartyMatch);
            }
        }

        [Theory,
         InlineData("1.1/2/3", "1.1/2/3.3", ""),
         InlineData("1/2/3/4", "1.one", "2/3/4"),
         InlineData("2/3/4", "2.two", "3/4"),
         InlineData("one/two/3/4/5/6", "one/two/3/4.4", "5/6"),
         InlineData("one/two/3/4/5/6/foo", "one/two/3/4.4", "5/6/foo"),
         InlineData("one/two/3/4/5/6/foo.htm", null, null)]
        public void MultipleExtensionsTest(string url, string match, string pathInfo)
        {
            string[] files = new[] { "~/1.one", "~/2.two", "~/1.1/2/3.3", "~/one/two/3/4.4", "~/one/two/3/4/5/6/foo.htm" };
            string[] extensions = new[] { "aspx", "hao", "one", "two", "3", "4" };

            ConstraintTest(files, extensions, url, match, pathInfo);
        }

        [Theory,
         InlineData("1.1/2/3", "1.1/2/3.Mobile.3", ""),
         InlineData("1/2/3/4", "1.Mobile.one", "2/3/4"),
         InlineData("2/3/4", "2.Mobile.two", "3/4"),
         InlineData("one/two/3/4/5/6", "one/two/3/4.Mobile.4", "5/6"),
         InlineData("one/two/3/4/5/6/foo", "one/two/3/4.Mobile.4", "5/6/foo"),
         InlineData("one/two/3/4/5/6/foo.Mobile.htm", null, null)]
        public void MultipleExtensionsMobileTest(string url, string match, string pathInfo)
        {
            string[] files = new[]
            {
                "~/1.one", "~/2.two", "~/1.1/2/3.3", "~/one/two/3/4.4", "~/one/two/3/4/5/6/foo.htm",
                "~/1.Mobile.one", "~/2.Mobile.two", "~/1.1/2/3.Mobile.3", "~/one/two/3/4.Mobile.4", "~/one/two/3/4/5/6/foo.Mobile.htm"
            };
            string[] extensions = new[] { "aspx", "hao", "one", "two", "3", "4" };

            ConstraintTest(files, extensions, url, match, pathInfo, mobileDevice: true);
        }

        [Fact]
        public void FilesWithLeadingUnderscoresAreNeverServed()
        {
            string[] files = new[] { "~/hi.evil", "~/_hi.evil", "~/_nest/good.evil", "~/_nest/_hide.evil", "~/_ok.good" };
            string[] extensions = new[] { "evil" };

            ConstraintTest(files, extensions, "hi", "hi.evil", "");
            ConstraintTest(files, extensions, "_nest/good/some/extra/path/info", "_nest/good.evil", "some/extra/path/info");
            Assert.Throws<HttpException>(() => { ConstraintTest(files, extensions, "_hi", null, null); }, "Files with leading underscores (\"_\") cannot be served.");
            Assert.Throws<HttpException>(() => { ConstraintTest(files, extensions, "_nest/_hide", null, null); }, "Files with leading underscores (\"_\") cannot be served.");
        }

        [Theory]
        [InlineData(new object[] { "_foo", "_foo/default.cshtml" })]
        [InlineData(new object[] { "_bar/_baz", "_bar/_baz/index.cshtml" })]
        public void DirectoriesWithLeadingUnderscoresAreServed(string requestPath, string expectedPath)
        {
            // Arramge
            var files = new[] { "~/_foo/default.cshtml", "~/_bar/_baz/index.cshtml" };
            var extensions = new[] { "cshtml" };

            // Act
            ConstraintTest(files, extensions, requestPath, expectedPath, "");
        }

        [Fact]
        public void TransformedUnderscoreAreNotServed()
        {
            string[] files = new[] { "~/_ok.Mobile.ext", "~/ok.ext" };
            string[] extensions = new[] { "ext" };

            ConstraintTest(files, extensions, "ok.ext", "ok.ext", "", mobileDevice: true);
            ConstraintTest(files, extensions, "ok/some/extra/path/info", "ok.ext", "some/extra/path/info", mobileDevice: true);

            Assert.Throws<HttpException>(() => { ConstraintTest(files, extensions, "_ok.Mobile.ext", null, null, mobileDevice: true); }, "Files with leading underscores (\"_\") cannot be served.");
        }

        [Fact]
        public void MobileFilesAreReturnedInthePresenceOfUnderscoreFiles()
        {
            string[] files = new[] { "~/_ok.Mobile.ext", "~/ok.ext", "~/ok.mobile.ext" };
            string[] extensions = new[] { "ext" };

            ConstraintTest(files, extensions, "ok.ext", "ok.Mobile.ext", "", mobileDevice: true);
            ConstraintTest(files, extensions, "ok/some/extra/path/info", "ok.Mobile.ext", "some/extra/path/info", mobileDevice: true);
            ConstraintTest(files, extensions, "ok.mobile", "ok.mobile.ext", "", mobileDevice: false);
        }

        [Fact]
        public void UnsupportedExtensionExistingFileTest()
        {
            ConstraintTest(new[] { "~/hao.aspx", "~/hao/hao.txt" }, new[] { "aspx" }, "hao/hao.txt", null, null);
        }

        [Fact]
        public void NullPathValueDoesNotMatchTest()
        {
            ConstraintTest(new[] { "~/hao.aspx", "~/hao/hao.txt" }, new[] { "aspx" }, null, null, null);
        }

        [Fact]
        public void RightToLeftPrecedenceTest()
        {
            ConstraintTest(new[] { "~/one/two/three.aspx", "~/one/two.aspx", "~/one.aspx" }, new[] { "aspx" }, "one/two/three", "one/two/three.aspx", "");
        }

        [Fact]
        public void DefaultPrecedenceTests()
        {
            string[] files = new[] { "~/one/two/default.aspx", "~/one/default.aspx", "~/default.aspx" };
            string[] extensions = new[] { "aspx" };

            // Default only tries to look at the full path level
            ConstraintTest(files, extensions, "one/two/three", null, null);
            ConstraintTest(files, extensions, "one/two", "one/two/default.aspx", "");
            ConstraintTest(files, extensions, "one", "one/default.aspx", "");
            ConstraintTest(files, extensions, "", "default.aspx", "");
            ConstraintTest(files, extensions, "one/two/three/four/five/six/7/8", null, null);
        }

        [Fact]
        public void IndexTests()
        {
            string[] files = new[] { "~/one/two/index.aspx", "~/one/index.aspx", "~/index.aspq" };
            string[] extensions = new[] { "aspx", "aspq" };

            // index only tries to look at the full path level
            ConstraintTest(files, extensions, "one/two/three", null, null);
            ConstraintTest(files, extensions, "one/two", "one/two/index.aspx", "");
            ConstraintTest(files, extensions, "one", "one/index.aspx", "");
            ConstraintTest(files, extensions, "", "index.aspq", "");
            ConstraintTest(files, extensions, "one/two/three/four/five/six/7/8", null, null);
        }

        [Fact]
        public void DefaultVsIndexNestedTest()
        {
            string[] files = new[] { "~/one/two/index.aspx", "~/one/index.aspx", "~/one/default.aspx", "~/index.aspq", "~/default.aspx" };
            string[] extensions = new[] { "aspx", "aspq" };

            ConstraintTest(files, extensions, "one/two", "one/two/index.aspx", "");
            ConstraintTest(files, extensions, "one", "one/default.aspx", "");
            ConstraintTest(files, extensions, "", "default.aspx", "");
        }

        [Fact]
        public void DefaultVsIndexSameExtensionTest()
        {
            string[] files = new[] { "~/one/two/index.aspx", "~/one/index.aspx", "~/one/default.aspx", "~/index.aspq", "~/default.aspx" };
            string[] extensions = new[] { "aspx" };

            ConstraintTest(files, extensions, "one", "one/default.aspx", "");
        }

        [Fact]
        public void DefaultVsIndexDifferentExtensionTest()
        {
            string[] files = new[] { "~/index.aspq", "~/default.aspx" };
            string[] extensions = new[] { "aspx", "aspq" };

            ConstraintTest(files, extensions, "", "default.aspx", "");
        }

        [Fact]
        public void DefaultVsIndexOnlyOneExtensionTest()
        {
            string[] files = new[] { "~/index.aspq", "~/default.aspx" };
            string[] extensions = new[] { "aspq" };

            ConstraintTest(files, extensions, "", "index.aspq", "");
        }

        [Fact]
        public void FullMatchNoPathInfoTest()
        {
            ConstraintTest(new[] { "~/hao.aspx" }, new[] { "aspx" }, "hao", "hao.aspx", "");
        }

        [Fact]
        public void MatchFileWithExtensionTest()
        {
            string[] files = new[] { "~/page.aspq" };
            string[] extensions = new[] { "aspq" };

            ConstraintTest(files, extensions, "page.aspq", "page.aspq", "");
        }

        [Fact]
        public void NoMatchFileWithWrongExtensionTest()
        {
            string[] files = new[] { "~/page.aspx" };
            string[] extensions = new[] { "aspq" };

            ConstraintTest(files, extensions, "page.aspx", null, null);
        }

        [Fact]
        public void WebPageRouteDoesNotPerformMappingIfRootLevelIsExplicitlyDisabled()
        {
            // Arrange
            var webPageRoute = new WebPageRoute { IsExplicitlyDisabled = true };
            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.RemapHandler(It.IsAny<IHttpHandler>())).Throws(new Exception("Smarty route should be disabled."));
            context.SetupGet(c => c.Request).Throws(new Exception("We do not need to use the request to identify if the app is disabled."));

            // Act 
            webPageRoute.DoPostResolveRequestCache(context.Object);

            // Assert. 
            // If we've come this far, neither of the setups threw.
            Assert.True(true);
        }

        [Fact]
        public void MatchRequestSetsDisplayModeOfFirstMatchPerContext()
        {
            // Arrange
            var objectFactory = new HashyBuildManager(new string[] { "~/page.Mobile.aspx", "~/nonMobile.aspx" });
            var mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(context => context.Items).Returns(new Hashtable());
            mockContext.Setup(c => c.Request.Browser.IsMobileDevice).Returns(true);
            mockContext.Setup(c => c.Request.Cookies).Returns(new HttpCookieCollection());
            mockContext.Setup(c => c.Response.Cookies).Returns(new HttpCookieCollection());

            var displayModeProvider = new DisplayModeProvider();

            // Act
            WebPageMatch mobileMatch = WebPageRoute.MatchRequest("page.aspx", new string[] { "aspx" }, objectFactory.Exists, mockContext.Object, displayModeProvider);

            // Assert
            Assert.NotNull(mobileMatch.MatchedPath);
            Assert.Equal(DisplayModeProvider.MobileDisplayModeId, DisplayModeProvider.GetDisplayMode(mockContext.Object).DisplayModeId);
        }

        [Fact]
        public void MatchRequestDoesNotSetDisplayModeIfNoMatch()
        {
            // Arrange
            var objectFactory = new HashyBuildManager(new string[] { "~/page.Mobile.aspx" });
            var mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(context => context.Items).Returns(new Hashtable());
            mockContext.Setup(c => c.Request.Browser.IsMobileDevice).Returns(true);
            mockContext.Setup(c => c.Request.Cookies).Returns(new HttpCookieCollection());
            mockContext.Setup(c => c.Response.Cookies).Returns(new HttpCookieCollection());

            var displayModeProvider = new DisplayModeProvider();
            var displayMode = new Mock<IDisplayMode>(MockBehavior.Strict);
            displayMode.Setup(d => d.CanHandleContext(mockContext.Object)).Returns(false);
            displayModeProvider.Modes.Add(displayMode.Object);

            // Act
            WebPageMatch smartyMatch = WebPageRoute.MatchRequest("notThere.aspx", new string[] { "aspx" }, objectFactory.Exists, mockContext.Object, displayModeProvider);

            // Assert
            Assert.Null(DisplayModeProvider.GetDisplayMode(mockContext.Object));
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/WebPage/WebPageTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Web.Caching;
using Microsoft.TestCommon;
using Moq;

namespace System.Web.WebPages.Test
{
    public class WebPageTest
    {
        private const string XmlHttpRequestKey = "X-Requested-With";
        private const string XmlHttpRequestValue = "XMLHttpRequest";

        [Fact]
        public void CreatePageFromVirtualPathAssignsVirtualPathFactory()
        {
            // Arrange
            var path = "~/index.cshtml";
            var page = Utils.CreatePage(null, path);
            var factory = new HashVirtualPathFactory(page);

            // Act
            var result = WebPage.CreateInstanceFromVirtualPath(path, factory);

            // Assert
            Assert.Equal(page, result);
            Assert.Equal(page.VirtualPathFactory, factory);
            Assert.Equal(page.VirtualPath, path);
        }

        [Fact]
        public void NormalizeLayoutPagePathTest()
        {
            var layoutPage = "Layout.cshtml";
            var layoutPath1 = "~/MyApp/Layout.cshtml";
            var page = new Mock<WebPage>() { CallBase = true }.Object;
            page.VirtualPath = "~/MyApp/index.cshtml";

            var mockBuildManager = new Mock<IVirtualPathFactory>();
            mockBuildManager.Setup(c => c.Exists(It.IsAny<string>())).Returns<string>(p => p.Equals(layoutPath1, StringComparison.OrdinalIgnoreCase));
            page.VirtualPathFactory = mockBuildManager.Object;

            Assert.Equal(layoutPath1, page.NormalizeLayoutPagePath(layoutPage));

            mockBuildManager.Setup(c => c.Exists(It.IsAny<string>())).Returns<string>(_ => false);

            Assert.Throws<HttpException>(() => page.NormalizeLayoutPagePath(layoutPage),
                                                  @"The layout page ""Layout.cshtml"" could not be found at the following path: ""~/MyApp/Layout.cshtml"".");
        }

        [Fact]
        public void UrlDataBasicTests()
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(context => context.Items).Returns(new Hashtable());
            string pathInfo = String.Format("{0}/{1}/{2}/{3}", "one", 2, 3.0, 4.0005);
            mockContext.Object.Items[typeof(WebPageMatch)] = new WebPageMatch("~/a.cshtml", pathInfo);
            WebPage page = new Mock<WebPage>() { CallBase = true }.Object;
            page.Context = mockContext.Object;

            Assert.Equal("one", page.UrlData[0]);
            Assert.Equal(2, page.UrlData[1].AsInt());
            Assert.Equal(3.0f, page.UrlData[2].AsFloat());
            Assert.Equal(4.0005m, page.UrlData[3].AsDecimal());
        }

        [Fact]
        public void UrlDataEmptyTests()
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(context => context.Items).Returns(new Hashtable());
            mockContext.Object.Items[typeof(WebPageMatch)] = new WebPageMatch("~/a.cshtml", "one///two/");
            WebPage page = new Mock<WebPage>() { CallBase = true }.Object;
            page.Context = mockContext.Object;

            Assert.Equal("one", page.UrlData[0]);
            Assert.True(page.UrlData[1].IsEmpty());
            Assert.True(page.UrlData[2].IsEmpty());
            Assert.Equal("two", page.UrlData[3]);
            Assert.True(page.UrlData[4].IsEmpty());
        }

        [Fact]
        public void UrlDataReadOnlyTest()
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(context => context.Items).Returns(new Hashtable());
            mockContext.Object.Items[typeof(WebPageMatch)] = new WebPageMatch("~/a.cshtml", "one/2/3.0/4.0005");
            WebPage page = new Mock<WebPage>() { CallBase = true }.Object;
            page.Context = mockContext.Object;

            Assert.Throws<NotSupportedException>(() => { page.UrlData.Add("bogus"); }, "The UrlData collection is read-only.");
            Assert.Throws<NotSupportedException>(() => { page.UrlData.Insert(0, "bogus"); }, "The UrlData collection is read-only.");
            Assert.Throws<NotSupportedException>(() => { page.UrlData.Remove("one"); }, "The UrlData collection is read-only.");
        }

        [Fact]
        public void UrlDataOutOfBoundsTest()
        {
            Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
            mockContext.Setup(context => context.Items).Returns(new Hashtable());
            mockContext.Object.Items[typeof(WebPageMatch)] = new WebPageMatch("~/a.cshtml", "");
            WebPage page = new Mock<WebPage>() { CallBase = true }.Object;
            page.Context = mockContext.Object;

            Assert.Equal(String.Empty, page.UrlData[0]);
            Assert.Equal(String.Empty, page.UrlData[1]);
        }

        [Fact]
        public void NullModelTest()
        {
            var page = CreateMockPageWithPostContext().Object;
            page.PageContext.Model = null;
            Assert.Null(page.Model);
        }

        internal class ModelTestClass
        {
            public string Prop1 { get; set; }

            public string GetProp1()
            {
                return Prop1;
            }

            public override string ToString()
            {
                return Prop1;
            }
        }

        [Fact]
        public void ModelTest()
        {
            var v = "value1";
            var page = CreateMockPageWithPostContext().Object;
            var model = new ModelTestClass() { Prop1 = v };
            page.PageContext.Model = model;
            Assert.NotNull(page.Model);
            Assert.Equal(v, page.Model.Prop1);
            Assert.Equal(v, page.Model.GetProp1());
            Assert.Equal(v, page.Model.ToString());
            Assert.Equal(model, (ModelTestClass)page.Model);
            // No such property
            Assert.Null(page.Model.Prop2);
            // No such method
            Assert.Throws<MissingMethodException>(() => page.Model.DoSomething());
        }

        [Fact]
        public void AnonymousObjectModelTest()
        {
            var v = "value1";
            var page = CreateMockPageWithPostContext().Object;
            var model = new { Prop1 = v };
            page.PageContext.Model = model;
            Assert.NotNull(page.Model);
            Assert.Equal(v, page.Model.Prop1);
            // No such property
            Assert.Null(page.Model.Prop2);
            // No such method
            Assert.Throws<MissingMethodException>(() => page.Model.DoSomething());
        }

        [Fact]
        public void SessionPropertyTest()
        {
            var page = CreateMockPageWithPostContext().Object;
#pragma warning disable xUnit2013 // Do not use equality check to check for collection size.
            Assert.Equal(0, page.Session.Count);
#pragma warning restore xUnit2013 // Do not use equality check to check for collection size.
        }

        [Fact]
        public void AppStatePropertyTest()
        {
            var page = CreateMockPageWithPostContext().Object;
#pragma warning disable xUnit2013 // Do not use equality check to check for collection size.
            Assert.Equal(0, page.AppState.Count);
#pragma warning restore xUnit2013 // Do not use equality check to check for collection size.
        }

        [Fact]
        public void ExecutePageHierarchyTest()
        {
            var page = new Mock<WebPage>();
            page.Object.TopLevelPage = true;

            var executors = new List<IWebPageRequestExecutor>();

            // First executor returns false
            var executor1 = new Mock<IWebPageRequestExecutor>();
            executor1.Setup(exec => exec.Execute(It.IsAny<WebPage>())).Returns(false);
            executors.Add(executor1.Object);

            // Second executor returns true
            var executor2 = new Mock<IWebPageRequestExecutor>();
            executor2.Setup(exec => exec.Execute(It.IsAny<WebPage>())).Returns(true);
            executors.Add(executor2.Object);

            // Third executor should never get called, since we stop after the first true
            var executor3 = new Mock<IWebPageRequestExecutor>();
            executor3.Setup(exec => exec.Execute(It.IsAny<WebPage>())).Returns(false);
            executors.Add(executor3.Object);

            page.Object.ExecutePageHierarchy(executors);

            // Make sure the first two got called but not the third
            executor1.Verify(exec => exec.Execute(It.IsAny<WebPage>()));
            executor2.Verify(exec => exec.Execute(It.IsAny<WebPage>()));
            executor3.Verify(exec => exec.Execute(It.IsAny<WebPage>()), Times.Never());
        }

        [Fact]
        public void IsPostReturnsTrueWhenMethodIsPost()
        {
            // Arrange
            var page = CreateMockPageWithPostContext();

            // Act and Assert
            Assert.True(page.Object.IsPost);
        }

        [Fact]
        public void IsPostReturnsFalseWhenMethodIsNotPost()
        {
            // Arrange
            var methods = new[] { "GET", "DELETE", "PUT", "RANDOM" };

            // Act and Assert
            Assert.True(methods.All(method => !CreateMockPageWithContext(method).Object.IsPost));
        }

        [Fact]
        public void IsAjaxReturnsTrueWhenRequestContainsAjaxHeader()
        {
            // Arrange
            var headers = new NameValueCollection();
            headers.Add("X-Requested-With", "XMLHttpRequest");
            var context = CreateContext("GET", new NameValueCollection(), headers);
            var page = CreatePage(context);

            // Act and Assert
            Assert.True(page.Object.IsAjax);
        }

        [Fact]
        public void IsAjaxReturnsTrueWhenRequestBodyContainsAjaxHeader()
        {
            // Arrange
            var headers = new NameValueCollection();
            headers.Add("X-Requested-With", "XMLHttpRequest");
            var context = CreateContext("POST", headers, headers);
            var page = CreatePage(context);

            // Act and Assert
            Assert.True(page.Object.IsAjax);
        }

        [Fact]
        public void IsAjaxReturnsFalseWhenRequestDoesNotContainAjaxHeaders()
        {
            // Arrange
            var page = CreateMockPageWithPostContext();

            // Act and Assert
            Assert.True(!page.Object.IsAjax);
        }

        private static Mock<WebPage> CreatePage(Mock<HttpContextBase> context)
        {
            var page = new Mock<WebPage>() { CallBase = true };
            var pageContext = new WebPageContext();
            page.Object.Context = context.Object;
            page.Object.PageContext = pageContext;
            return page;
        }

        private static Mock<WebPage> CreateMockPageWithPostContext()
        {
            return CreateMockPageWithContext("POST");
        }

        private static Mock<WebPage> CreateMockPageWithContext(string httpMethod)
        {
            var context = CreateContext(httpMethod, new NameValueCollection());
            var page = CreatePage(context);
            return page;
        }

        private static Mock<HttpContextBase> CreateContext(string httpMethod, NameValueCollection queryString, NameValueCollection httpHeaders = null)
        {
            var request = new Mock<HttpRequestBase>();
            request.Setup(r => r.HttpMethod).Returns(httpMethod);
            request.Setup(r => r.QueryString).Returns(queryString);
            request.Setup(r => r.Form).Returns(new NameValueCollection());
            request.Setup(r => r.Files).Returns(new Mock<HttpFileCollectionBase>().Object);
            request.Setup(c => c.Headers).Returns(httpHeaders);
            var context = new Mock<HttpContextBase>();
            context.Setup(c => c.Response).Returns(new Mock<HttpResponseBase>().Object);
            context.Setup(c => c.Request).Returns(request.Object);
            context.Setup(c => c.Items).Returns(new Hashtable());
            context.Setup(c => c.Session).Returns(new Mock<HttpSessionStateBase>().Object);
            context.Setup(c => c.Application).Returns(new Mock<HttpApplicationStateBase>().Object);
            context.Setup(c => c.Cache).Returns(new Cache());
            context.Setup(c => c.Server).Returns(new Mock<HttpServerUtilityBase>().Object);
            return context;
        }
    }
}


================================================
FILE: test/System.Web.WebPages.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/WebApiHelpPage.Test/Controllers/UsersController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Web.Http;

namespace WebApiHelpPageWebHost.UnitTest.Controllers
{
    public class User
    {
        public string Name { get; set; }

        public List<Order> Orders { get; set; }

        public Address Address { get; set; }
    }

    public class Order
    {
        public int Id { get; set; }

        public Product[] Products { get; set; }
    }

    public class Product
    {
        public Guid Id { get; set; }

        public string Name { get; set; }

        public string Description { get; set; }
    }

    public class Address
    {
        public string Street { get; set; }

        public string City { get; set; }

        public string Country { get; set; }
    }

    /// <summary>
    /// Resource for Users.
    /// </summary>
    public class UsersController : ApiController
    {
        public IEnumerable<User> Get()
        {
            return null;
        }

        public string Post(User user)
        {
            return null;
        }
    }
}

================================================
FILE: test/WebApiHelpPage.Test/Controllers/ValuesController.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Globalization;
using System.Net;
using System.Net.Http;
using System.Web.Http;

namespace WebApiHelpPageWebHost.UnitTest.Controllers
{
    /// <summary>
    /// Resource for Values.
    /// </summary>
    public class ValuesController : ApiController
    {
        /// <summary>
        /// Gets all the values.
        /// </summary>
        /// <returns>A list of values.</returns>
        public IEnumerable<string> Get()
        {
            return new string[] { "value1", "value2" };
        }

        /// <summary>
        /// Gets the value by id.
        /// </summary>
        /// <param name="id">The id.</param>
        /// <returns>A value string.</returns>
        public string Get(int id)
        {
            return "value";
        }

        /// <summary>
        /// Gets the value by name.
        /// </summary>
        /// <param name="name">The name.</param>
        /// <returns>A value identified by name.</returns>
        public string Get(string name)
        {
            return "name";
        }

        /// <summary>
        /// Gets the value by the point.
        /// This is a test for a type with TypeConverter.
        /// </summary>
        /// <param name="point">The type defined with TypeConverter.</param>
        /// <returns>A point string.</returns>
        public string Get([FromUri]Point point)
        {
            return "point";
        }

        /// <summary>
        /// Create a new value.
        /// </summary>
        /// <param name="value">The value.</param>
        /// <returns>A response.</returns>
        public HttpResponseMessage Post([FromBody]string value)
        {
            return Request.CreateResponse<string>(HttpStatusCode.OK, "hello");
        }

        /// <summary>
        /// Updates the value.
        /// </summary>
        /// <param name="id">The id.</param>
        /// <param name="value">The value.</param>
        public void Put(int id, [FromBody]string value)
        {
        }

        /// <summary>
        /// Updates the value pair collection.
        /// </summary>
        /// <param name="valuePairCollection">The value pair collection.</param>
        public void Put(List<Tuple<int, string>> valuePairCollection)
        {
        }

        /// <summary>
        /// Deletes the value.
        /// </summary>
        /// <param name="id">The id.</param>
        public void Delete(int? id)
        {
        }

        /// <summary>
        /// Patches the value pair.
        /// </summary>
        /// <param name="valuePair">The pair.</param>
        public void Patch(Tuple<int, string> valuePair)
        {
        }

        /// <summary>
        /// Returns the options.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>All the options.</returns>
        public string Options(HttpRequestMessage request)
        {
            return "options";
        }

        public string[] HeadNoDocumentation(int id)
        {
            return new string[] { "value1", "value2" };
        }

        /// <summary>
        /// Resource for nested values.
        /// </summary>
        public class NestedValuesController : ApiController
        {
            public string[] Get()
            {
                return new string[] { "nvalue1", "nvalue2" };
            }
        }

        public class PointConverter : TypeConverter
        {
            // Overrides the CanConvertFrom method of TypeConverter.
            // The ITypeDescriptorContext interface provides the context for the
            // conversion. Typically, this interface is used at design time to 
            // provide information about the design-time container.
            public override bool CanConvertFrom(ITypeDescriptorContext context,
               Type sourceType)
            {
                if (sourceType == typeof(string))
                {
                    return true;
                }
                return base.CanConvertFrom(context, sourceType);
            }
            // Overrides the ConvertFrom method of TypeConverter.
            public override object ConvertFrom(ITypeDescriptorContext context,
               CultureInfo culture, object value)
            {
                if (value is string)
                {
                    string[] v = ((string)value).Split(new char[] { ',' });
                    return new Point(int.Parse(v[0]), int.Parse(v[1]));
                }
                return base.ConvertFrom(context, culture, value);
            }
            // Overrides the ConvertTo method of TypeConverter.
            public override object ConvertTo(ITypeDescriptorContext context,
               CultureInfo culture, object value, Type destinationType)
            {
                if (destinationType == typeof(string))
                {
                    return ((Point)value).X + "," + ((Point)value).Y;
                }
                return base.ConvertTo(context, culture, value, destinationType);
            }
        }

        [TypeConverter(typeof(PointConverter))]
        public class Point
        {
            public Point(int x, int y)
            {
                X = x;
                Y = y;
            }

            public int X { get; set; }

            public int Y { get; set; }
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/HelpControllerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Http;
using System.Web.Mvc;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Controllers;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class HelpControllerTest
    {
        [Fact]
        public void Constructor_Default()
        {
            HelpController controller = new HelpController();
            Assert.Same(GlobalConfiguration.Configuration, controller.Configuration);
        }

        [Fact]
        public void Constructor_OneParameter()
        {
            HttpConfiguration config = new HttpConfiguration();
            HelpController controller = new HelpController(config);
            Assert.Same(config, controller.Configuration);
        }

        [Fact]
        public void Index_ReturnsCachedModels()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpController controller = new HelpController(config);

            ViewResult result = Assert.IsType<ViewResult>(controller.Index());
            ViewResult result2 = Assert.IsType<ViewResult>(controller.Index());

            Assert.NotNull(result.Model);
            Assert.NotNull(result2.Model);

            // Make sure the model is cached
            Assert.Same(config.Services.GetApiExplorer().ApiDescriptions, result.Model);
            Assert.Same(result.Model, result2.Model);
        }

        [Theory]
        [InlineData("Get-Values")]
        [InlineData("get-values")]
        [InlineData("Get-Values_name")]
        [InlineData("get-values_NAME")]
        [InlineData("Get-Values-id")]
        [InlineData("Get-Values-ID")]
        [InlineData("Post-Values")]
        [InlineData("POST-VALUES")]
        [InlineData("Put-Values-id")]
        [InlineData("Put-VALUES-ID")]
        [InlineData("Put-Values")]
        [InlineData("Put-VALUES")]
        [InlineData("Delete-Values-id")]
        [InlineData("Delete-VALUES-id")]
        [InlineData("Patch-Values")]
        [InlineData("Patch-VALUES")]
        [InlineData("Options-Values")]
        [InlineData("OpTions-VALUES")]
        [InlineData("Head-Values-id")]
        [InlineData("HEAD-VALUES-id")]
        public void API_ReturnsCachedModels(string apiDescriptionId)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpController controller = new HelpController(config);

            ViewResult result = Assert.IsType<ViewResult>(controller.Api(apiDescriptionId));
            ViewResult result2 = Assert.IsType<ViewResult>(controller.Api(apiDescriptionId));

            Assert.NotNull(result.Model);
            Assert.NotNull(result2.Model);

            // Make sure the model is cached
            Assert.Same(config.GetHelpPageApiModel(apiDescriptionId), result.Model);
            Assert.Same(result.Model, result2.Model);
        }

        [Theory]
        [InlineData("")]
        [InlineData(null)]
        [InlineData("@@@@@@@")]
        public void API_ReturnsNullModels_WhenApiIdIsInvalid(string apiDescriptionId)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpController controller = new HelpController(config);

            ViewResult result = Assert.IsType<ViewResult>(controller.Api(apiDescriptionId));
            ViewResult result2 = Assert.IsType<ViewResult>(controller.Api(apiDescriptionId));

            Assert.Null(result.Model);
            Assert.Null(result2.Model);
        }

        [Theory]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.User")]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.Order")]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.Product")]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.Address")]
        [InlineData("webapihelppagewebhost.unittest.controllers.user")]
        [InlineData("WEBAPIHELPPAGEWEBHOST.UNITTEST.CONTROLLERS.ORDER")]
        [InlineData("webApiHelpPageWebHost.UnitTest.Controllers.Product")]
        [InlineData("WebApiHelpPageWebHost.unittest.Controllers.ADDRESS")]
        public void ResourceModel_ReturnsCachedModels(string modelName)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpController controller = new HelpController(config);
            ModelDescriptionGenerator modelDescriptionGenerator = config.GetModelDescriptionGenerator();
            ModelDescription expectedModelDescription;
            modelDescriptionGenerator.GeneratedModels.TryGetValue(modelName, out expectedModelDescription);

            ViewResult result = Assert.IsType<ViewResult>(controller.ResourceModel(modelName));
            ViewResult result2 = Assert.IsType<ViewResult>(controller.ResourceModel(modelName));

            Assert.Same(expectedModelDescription, result.Model);
            Assert.Same(result.Model, result2.Model);
        }

        [Theory]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.User")]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.Order")]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.Product")]
        [InlineData("WebApiHelpPageWebHost.UnitTest.Controllers.Address")]
        [InlineData("webapihelppagewebhost.unittest.controllers.user")]
        [InlineData("WEBAPIHELPPAGEWEBHOST.UNITTEST.CONTROLLERS.ORDER")]
        [InlineData("webApiHelpPageWebHost.UnitTest.Controllers.Product")]
        [InlineData("WebApiHelpPageWebHost.unittest.Controllers.ADDRESS")]
        public void ResourceModel_ReturnsCachedModels_UnusedParameters(string modelName)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{unused}/{id}", new { id = RouteParameter.Optional });
            HelpController controller = new HelpController(config);
            ModelDescriptionGenerator modelDescriptionGenerator = config.GetModelDescriptionGenerator();
            ModelDescription expectedModelDescription;
            modelDescriptionGenerator.GeneratedModels.TryGetValue(modelName, out expectedModelDescription);

            ViewResult result = Assert.IsType<ViewResult>(controller.ResourceModel(modelName));
            ViewResult result2 = Assert.IsType<ViewResult>(controller.ResourceModel(modelName));

            Assert.Same(expectedModelDescription, result.Model);
            Assert.Same(result.Model, result2.Model);
        }

        [Theory]
        [InlineData("")]
        [InlineData(null)]
        [InlineData("@@@@@@@")]
        public void ResourceModel_ReturnsNullModels_WhenAModelNameIsInvalid(string modelName)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpController controller = new HelpController(config);

            ViewResult result = Assert.IsType<ViewResult>(controller.ResourceModel(modelName));
            ViewResult result2 = Assert.IsType<ViewResult>(controller.ResourceModel(modelName));

            Assert.Null(result.Model);
            Assert.Null(result2.Model);
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/HelpPageApiModelTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Net.Http.Headers;
using System.Web.Http.Description;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class HelpPageApiModelTest
    {
        [Fact]
        public void Default_Constructor()
        {
            HelpPageApiModel model = new HelpPageApiModel();
            Assert.NotNull(model.SampleRequests);
            Assert.NotNull(model.SampleResponses);
            Assert.NotNull(model.ErrorMessages);
            Assert.Null(model.ApiDescription);
        }

        [Fact]
        public void ApiDescription_Property()
        {
            HelpPageApiModel model = new HelpPageApiModel();
            ApiDescription description = new ApiDescription();
            model.ApiDescription = description;
            Assert.NotNull(model.ApiDescription);
            Assert.Same(description, model.ApiDescription);
        }

        [Fact]
        public void ErrorMessages_Property()
        {
            HelpPageApiModel model = new HelpPageApiModel();
            string error = "an error";
            model.ErrorMessages.Add(error);
            Assert.NotEmpty(model.ErrorMessages);
            Assert.Same(error, model.ErrorMessages[0]);
        }

        [Fact]
        public void SampleRequests_Property()
        {
            HelpPageApiModel model = new HelpPageApiModel();
            ImageSample sample = new ImageSample("http://host/image.png");
            model.SampleRequests.Add(new MediaTypeHeaderValue("text/plain"), sample);
            object sampleRequest;
            model.SampleRequests.TryGetValue(new MediaTypeHeaderValue("text/plain"), out sampleRequest);
            Assert.NotEmpty(model.SampleRequests);
            Assert.Same(sample, sampleRequest);
        }

        [Fact]
        public void SampleResponses_Property()
        {
            HelpPageApiModel model = new HelpPageApiModel();
            InvalidSample sample = new InvalidSample("invalid");
            model.SampleResponses.Add(new MediaTypeHeaderValue("text/xml"), sample);
            object sampleResponse;
            model.SampleResponses.TryGetValue(new MediaTypeHeaderValue("text/xml"), out sampleResponse);
            Assert.NotEmpty(model.SampleResponses);
            Assert.Same(sample, sampleResponse);
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/HelpPageAreaRegistrationTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Web.Mvc;
using System.Web.Routing;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class HelpPageAreaRegistrationTest
    {
        [Fact]
        public void AreaName()
        {
            HelpPageAreaRegistration area = new HelpPageAreaRegistration();
            Assert.Equal("HelpPage", area.AreaName);
        }

        [Fact]
        public void RegisterArea()
        {
            HelpPageAreaRegistration area = new HelpPageAreaRegistration();
            AreaRegistrationContext context = new AreaRegistrationContext("HelpPage", RouteTable.Routes);
            area.RegisterArea(context);
            Assert.NotEmpty(context.Routes);
            Route route = Assert.IsType<Route>(context.Routes[0]);
            Assert.Equal("Help/{action}/{apiId}", route.Url);
            Assert.Equal("Help", route.Defaults["controller"]);
            Assert.Equal("Index", route.Defaults["action"]);
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/HelpPageConfigurationExtensionsTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Headers;
using System.Web.Http;
using System.Web.Http.Description;
using System.Web.Http.ModelBinding;
using Microsoft.TestCommon;
using Moq;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.Models;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class HelpPageConfigurationExtensionsTest
    {
        [Theory]
        [InlineData("Get-Values")]
        [InlineData("get-values")]
        [InlineData("Get-Values_Name")]
        [InlineData("get-values_NAME")]
        [InlineData("Get-Values-id")]
        [InlineData("Get-Values-ID")]
        [InlineData("Post-Values")]
        [InlineData("POST-VALUES")]
        [InlineData("Put-Values-id")]
        [InlineData("Put-VALUES-ID")]
        [InlineData("Put-Values")]
        [InlineData("Put-VALUES")]
        [InlineData("Delete-Values-id")]
        [InlineData("Delete-VALUES-id")]
        [InlineData("Patch-Values")]
        [InlineData("Patch-VALUES")]
        [InlineData("Options-Values")]
        [InlineData("OpTions-VALUES")]
        [InlineData("Head-Values-id")]
        [InlineData("HEAD-VALUES-id")]
        public void GetHelpPageApiModel_ReturnsTheModel_WhenIdIsValid(string apiId)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpPageApiModel model = config.GetHelpPageApiModel(apiId);
            Assert.NotNull(model);
            Assert.Same(model, config.GetHelpPageApiModel(apiId));
            Assert.Equal(apiId, model.ApiDescription.GetFriendlyId(), StringComparer.OrdinalIgnoreCase);
        }

        [Fact]
        public void GetHelpPageApiModel_TypeConverterModel_GeneratesUriParameter()
        {
            // If class Point with properties X and Y is defined with a TypeConverter, 
            // the UriParameters should be a single parameter name "point" instead of two member properties X and Y,
            // because X and Y do not appear in the Relative Path and it is the user that should specify how the query
            // string is parsed.
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });

            // Act
            HelpPageApiModel model = config.GetHelpPageApiModel("GET-Values_point");

            // Assert
            Assert.NotNull(model);
            string expectedParameter = Assert.Single(model.ApiDescription.ParameterDescriptions).Name;
            ParameterDescription parameterDescription = Assert.Single(model.UriParameters);
            Assert.Equal(expectedParameter, parameterDescription.Name);
        }

        [Theory]
        [InlineData("Get-Values-Unused")]
        [InlineData("get-values-unused")]
        [InlineData("Get-Values-Unused_Name")]
        [InlineData("get-values-unused_NAME")]
        [InlineData("Get-Values-Unused-id")]
        [InlineData("Get-Values-unused-ID")]
        [InlineData("Post-Values-Unused")]
        [InlineData("POST-VALUES-UNUSED")]
        [InlineData("Put-Values-Unused-id")]
        [InlineData("Put-VALUES-UNUSED-ID")]
        [InlineData("Put-Values-Unused")]
        [InlineData("Put-VALUES-UNUSED")]
        [InlineData("Delete-Values-Unused-id")]
        [InlineData("Delete-VALUES-UNUSED-id")]
        [InlineData("Patch-Values-Unused")]
        [InlineData("Patch-VALUES-UNUSED")]
        [InlineData("Options-Values-Unused")]
        [InlineData("OpTions-VALUES-UNUSED")]
        [InlineData("Head-Values-Unused-id")]
        [InlineData("HEAD-VALUES-UNUSED-id")]
        public void GetHelpPageApiModel_ReturnsTheModel_WhenIdIsValid_UnusedParameters(string apiId)
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{unused}/{id}", new { id = RouteParameter.Optional });

            // Act
            HelpPageApiModel model = config.GetHelpPageApiModel(apiId);

            // Assert
            Assert.NotNull(model);
            Assert.Same(model, config.GetHelpPageApiModel(apiId));
            Assert.Equal(apiId, model.ApiDescription.GetFriendlyId(), StringComparer.OrdinalIgnoreCase);
        }

        [Theory]
        [InlineData("foo")]
        [InlineData("bar")]
        [InlineData("@alpha")]
        [InlineData("GetValues/{id}/{name}")]
        public void GetHelpPageApiModel_ReturnsNull_WhenIdIsInvalid(string apiId)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpPageApiModel model = config.GetHelpPageApiModel(apiId);
            Assert.Null(model);
        }

        [Theory]
        [InlineData("Get-Values")]
        [InlineData("get-values")]
        [InlineData("Get-Values-id")]
        [InlineData("Get-Values-ID")]
        public void GetHelpPageApiModel_ReturnsNull_IfNoRoute(string apiId)
        {
            HttpConfiguration config = new HttpConfiguration();
            HelpPageApiModel model = config.GetHelpPageApiModel(apiId);
            Assert.Null(model);
        }

        [Fact]
        public void GetHelpPageApiModel_HandlesException_ThrownDuringSampleGeneration()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            Mock<HelpPageSampleGenerator> faultyGenerator = new Mock<HelpPageSampleGenerator>();
            faultyGenerator.Setup(g => g.GetSample(It.IsAny<ApiDescription>(), It.IsAny<SampleDirection>())).Returns(() => { throw new InvalidOperationException("This is a faulty sample generator."); });
            config.SetHelpPageSampleGenerator(faultyGenerator.Object);
            HelpPageApiModel model = config.GetHelpPageApiModel("Get-Values");
            Assert.NotNull(model);
            Assert.NotEmpty(model.ErrorMessages);
            Assert.Equal("An exception has occurred while generating the sample. Exception message: This is a faulty sample generator.", model.ErrorMessages[0]);
        }

        [Fact]
        public void GetHelpPageApiModel_HandlesException_ThrownDuringSampleObjectSerialization()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Formatters.Clear();
            config.Formatters.Add(new JQueryMvcFormUrlEncodedFormatter());
            config.SetSampleObjects(new Dictionary<Type, object> { { typeof(string), "sample" } });
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            HelpPageApiModel model = config.GetHelpPageApiModel("Post-Values");
            Assert.NotNull(model);
            Assert.NotEmpty(model.ErrorMessages);
            Assert.Equal("Failed to generate the sample for media type 'application/x-www-form-urlencoded'. Cannot use formatter 'JQueryMvcFormUrlEncodedFormatter' to write type 'String'.", model.ErrorMessages[0]);
        }

        [Fact]
        public void GetHelpPageApiModel_UnwrapsAggregateException()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });
            Mock<HelpPageSampleGenerator> faultyGenerator = new Mock<HelpPageSampleGenerator>();
            faultyGenerator.Setup(g => g.GetSample(It.IsAny<ApiDescription>(), It.IsAny<SampleDirection>())).Returns(() => { throw new AggregateException(new InvalidOperationException("Sample generator failed.")); });
            config.SetHelpPageSampleGenerator(faultyGenerator.Object);
            HelpPageApiModel model = config.GetHelpPageApiModel("Get-Values");
            Assert.NotNull(model);
            Assert.NotEmpty(model.ErrorMessages);
            Assert.Equal("An exception has occurred while generating the sample. Exception message: Sample generator failed.", model.ErrorMessages[0]);
        }

        [Theory]
        [InlineData("Post-Users", true)]
        [InlineData("Post-Values", true)]
        [InlineData("Put-Values", true)]
        [InlineData("Get-Values", false)]
        [InlineData("Get-Users", false)]
        [InlineData("Get-Values-id", false)]
        [InlineData("Head-Values-id", false)]
        public void GetHelpPageApiModel_ReturnsExpectedRequestModelDescription(string apiId, bool hasRequestModelDescription)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.Routes.MapHttpRoute("Default", "{controller}/{id}", new { id = RouteParameter.Optional });

            HelpPageApiModel model = config.GetHelpPageApiModel(apiId);

            Assert.NotNull(model);
            if (hasRequestModelDescription)
            {
                Assert.NotNull(model.RequestModelDescription);
            }
            else
            {
                Assert.Null(model.RequestModelDescription);
            }
        }

        [Fact]
        public void SetDocumentationProvider()
        {
            HttpConfiguration config = new HttpConfiguration();
            Mock<IDocumentationProvider> docProviderMock = new Mock<IDocumentationProvider>();
            IDocumentationProvider docProvider = docProviderMock.Object;
            config.SetDocumentationProvider(docProvider);

            Assert.Same(docProvider, config.Services.GetDocumentationProvider());
        }

        [Fact]
        public void SetSampleObjects()
        {
            HttpConfiguration config = new HttpConfiguration();
            Dictionary<Type, object> sampleObjects = new Dictionary<Type, object>
            {
                {typeof(int), 21},
                {typeof(string), "sample"}
            };
            config.SetSampleObjects(sampleObjects);

            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.Same(sampleObjects, sampleGenerator.SampleObjects);
        }

        [Fact]
        public void SetSampleRequest()
        {
            HttpConfiguration config = new HttpConfiguration();
            TextSample sample = new TextSample("test");
            config.SetSampleRequest(sample, new MediaTypeHeaderValue("application/xml"), "values", "get");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActionSamples);
            var actionSample = sampleGenerator.ActionSamples.First();
            Assert.Equal("values", actionSample.Key.ControllerName);
            Assert.Equal("get", actionSample.Key.ActionName);
            Assert.Equal(new MediaTypeHeaderValue("application/xml"), actionSample.Key.MediaType);
            Assert.Equal(SampleDirection.Request, actionSample.Key.SampleDirection);
            Assert.NotEmpty(actionSample.Key.ParameterNames);
            Assert.Equal("*", actionSample.Key.ParameterNames.First());
            Assert.Same(sample, actionSample.Value);
        }

        [Fact]
        public void SetSampleRequest_WithParameters()
        {
            HttpConfiguration config = new HttpConfiguration();
            TextSample sample = new TextSample("test");
            config.SetSampleRequest(sample, new MediaTypeHeaderValue("application/json"), "values", "post", "id", "name");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActionSamples);
            var actionSample = sampleGenerator.ActionSamples.First();
            Assert.Equal("values", actionSample.Key.ControllerName);
            Assert.Equal("post", actionSample.Key.ActionName);
            Assert.Equal(new MediaTypeHeaderValue("application/json"), actionSample.Key.MediaType);
            Assert.Equal(SampleDirection.Request, actionSample.Key.SampleDirection);
            Assert.Equal(2, actionSample.Key.ParameterNames.Count);
            Assert.True(actionSample.Key.ParameterNames.SetEquals(new[] { "id", "name" }));
            Assert.Same(sample, actionSample.Value);
        }

        [Fact]
        public void SetSampleResponse()
        {
            HttpConfiguration config = new HttpConfiguration();
            TextSample sample = new TextSample("test");
            config.SetSampleResponse(sample, new MediaTypeHeaderValue("application/xml"), "values", "get");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActionSamples);
            var actionSample = sampleGenerator.ActionSamples.First();
            Assert.Equal("values", actionSample.Key.ControllerName);
            Assert.Equal("get", actionSample.Key.ActionName);
            Assert.Equal(new MediaTypeHeaderValue("application/xml"), actionSample.Key.MediaType);
            Assert.Equal(SampleDirection.Response, actionSample.Key.SampleDirection);
            Assert.NotEmpty(actionSample.Key.ParameterNames);
            Assert.Equal("*", actionSample.Key.ParameterNames.First());
            Assert.Same(sample, actionSample.Value);
        }

        [Fact]
        public void SetSampleResponse_WithParameters()
        {
            HttpConfiguration config = new HttpConfiguration();
            TextSample sample = new TextSample("test");
            config.SetSampleResponse(sample, new MediaTypeHeaderValue("application/json"), "values", "post", "id", "name");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActionSamples);
            var actionSample = sampleGenerator.ActionSamples.First();
            Assert.Equal("values", actionSample.Key.ControllerName);
            Assert.Equal("post", actionSample.Key.ActionName);
            Assert.Equal(new MediaTypeHeaderValue("application/json"), actionSample.Key.MediaType);
            Assert.Equal(SampleDirection.Response, actionSample.Key.SampleDirection);
            Assert.Equal(2, actionSample.Key.ParameterNames.Count);
            Assert.True(actionSample.Key.ParameterNames.SetEquals(new[] { "id", "name" }));
            Assert.Same(sample, actionSample.Value);
        }

        [Fact]
        public void SetSampleForType()
        {
            HttpConfiguration config = new HttpConfiguration();
            ImageSample sample = new ImageSample("http://localhost/test.png");
            config.SetSampleForType(sample, new MediaTypeHeaderValue("image/png"), typeof(string));
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActionSamples);
            var actionSample = sampleGenerator.ActionSamples.First();
            Assert.Equal(String.Empty, actionSample.Key.ControllerName);
            Assert.Equal(String.Empty, actionSample.Key.ActionName);
            Assert.Equal(new MediaTypeHeaderValue("image/png"), actionSample.Key.MediaType);
            Assert.Null(actionSample.Key.SampleDirection);
            Assert.Empty(actionSample.Key.ParameterNames);
            Assert.Same(sample, actionSample.Value);
        }

        [Fact]
        public void SetActualRequestType()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.SetActualRequestType(typeof(string), "c", "a");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActualHttpMessageTypes);
            var actualType = sampleGenerator.ActualHttpMessageTypes.First();
            Assert.Equal("c", actualType.Key.ControllerName);
            Assert.Equal("a", actualType.Key.ActionName);
            Assert.Null(actualType.Key.MediaType);
            Assert.Equal(SampleDirection.Request, actualType.Key.SampleDirection);
            Assert.NotEmpty(actualType.Key.ParameterNames);
            Assert.Equal("*", actualType.Key.ParameterNames.First());
            Assert.Equal(typeof(string), actualType.Value);
        }

        [Fact]
        public void SetActualRequestType_WithParameters()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.SetActualRequestType(typeof(string), "c", "a", "id");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActualHttpMessageTypes);
            var actualType = sampleGenerator.ActualHttpMessageTypes.First();
            Assert.Equal("c", actualType.Key.ControllerName);
            Assert.Equal("a", actualType.Key.ActionName);
            Assert.Null(actualType.Key.MediaType);
            Assert.Equal(SampleDirection.Request, actualType.Key.SampleDirection);
            Assert.NotEmpty(actualType.Key.ParameterNames);
            Assert.Equal("id", actualType.Key.ParameterNames.First());
            Assert.Equal(typeof(string), actualType.Value);
        }

        [Fact]
        public void SetActualResponseType()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.SetActualResponseType(typeof(int), "c", "a");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActualHttpMessageTypes);
            var actualType = sampleGenerator.ActualHttpMessageTypes.First();
            Assert.Equal("c", actualType.Key.ControllerName);
            Assert.Equal("a", actualType.Key.ActionName);
            Assert.Null(actualType.Key.MediaType);
            Assert.Equal(SampleDirection.Response, actualType.Key.SampleDirection);
            Assert.NotEmpty(actualType.Key.ParameterNames);
            Assert.Equal("*", actualType.Key.ParameterNames.First());
            Assert.Equal(typeof(int), actualType.Value);
        }

        [Fact]
        public void SetActualResponseType_WithParameters()
        {
            HttpConfiguration config = new HttpConfiguration();
            config.SetActualResponseType(typeof(int), "c", "a", "id");
            object sampleGeneratorObj;
            config.Properties.TryGetValue(typeof(HelpPageSampleGenerator), out sampleGeneratorObj);
            HelpPageSampleGenerator sampleGenerator = Assert.IsType<HelpPageSampleGenerator>(sampleGeneratorObj);
            Assert.NotEmpty(sampleGenerator.ActualHttpMessageTypes);
            var actualType = sampleGenerator.ActualHttpMessageTypes.First();
            Assert.Equal("c", actualType.Key.ControllerName);
            Assert.Equal("a", actualType.Key.ActionName);
            Assert.Null(actualType.Key.MediaType);
            Assert.Equal(SampleDirection.Response, actualType.Key.SampleDirection);
            Assert.NotEmpty(actualType.Key.ParameterNames);
            Assert.Equal("id", actualType.Key.ParameterNames.First());
            Assert.Equal(typeof(int), actualType.Value);
        }

        [Fact]
        public void GetHelpPageSampleGenerator_ReturnsDefaultValue()
        {
            HttpConfiguration config = new HttpConfiguration();
            HelpPageSampleGenerator helpPageSampleGenerator = config.GetHelpPageSampleGenerator();
            Assert.NotNull(helpPageSampleGenerator);
            Assert.Same(helpPageSampleGenerator, config.GetHelpPageSampleGenerator());
        }

        [Fact]
        public void SetHelpPageSampleGenerator_ChangesTheDefault()
        {
            HttpConfiguration config = new HttpConfiguration();
            Mock<HelpPageSampleGenerator> helpPageSampleGenerator = new Mock<HelpPageSampleGenerator>();
            config.SetHelpPageSampleGenerator(helpPageSampleGenerator.Object);
            Assert.Same(helpPageSampleGenerator.Object, config.GetHelpPageSampleGenerator());
        }
    }
}

================================================
FILE: test/WebApiHelpPage.Test/HelpPageSampleKeyTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Net.Http.Headers;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class HelpPageSampleKeyTest
    {
        [Fact]
        public void Constructor_TwoParameters()
        {
            HelpPageSampleKey key = new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), typeof(Tuple<int, string>));
            Assert.Equal(new MediaTypeHeaderValue("application/xml"), key.MediaType);
            Assert.Equal(typeof(Tuple<int, string>), key.ParameterType);
            Assert.Null(key.SampleDirection);
            Assert.Equal(String.Empty, key.ControllerName);
            Assert.Equal(String.Empty, key.ActionName);
            Assert.Empty(key.ParameterNames);
        }

        [Fact]
        public void Constructor_FourParameters()
        {
            HelpPageSampleKey key = new HelpPageSampleKey(SampleDirection.Request, "myController", "myAction", new[] { "id", "name" });
            Assert.Null(key.MediaType);
            Assert.Null(key.ParameterType);
            Assert.Equal(SampleDirection.Request, key.SampleDirection.Value);
            Assert.Equal("myController", key.ControllerName);
            Assert.Equal("myAction", key.ActionName);
            Assert.NotEmpty(key.ParameterNames);
            Assert.True(key.ParameterNames.SetEquals(new[] { "name", "id" }));
        }

        [Fact]
        public void Constructor_FiveParameters()
        {
            HelpPageSampleKey key = new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Request, "myController", "myAction", new[] { "id", "name" });
            Assert.Equal(new MediaTypeHeaderValue("application/xml"), key.MediaType);
            Assert.Null(key.ParameterType);
            Assert.Equal(SampleDirection.Request, key.SampleDirection.Value);
            Assert.Equal("myController", key.ControllerName);
            Assert.Equal("myAction", key.ActionName);
            Assert.NotEmpty(key.ParameterNames);
            Assert.True(key.ParameterNames.SetEquals(new[] { "name", "id" }));
        }

        public static IEnumerable<object[]> Constructor_ThrowsArgumentNullException_PropertyData
        {
            get
            {
                yield return new Func<object>[] { () => new HelpPageSampleKey(null, typeof(Tuple<int, string>)) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), null) };

                yield return new Func<object>[] { () => new HelpPageSampleKey(SampleDirection.Request, "c", "a", null) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(SampleDirection.Request, null, "a", new string[0]) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(SampleDirection.Request, "c", null, new string[0]) };

                yield return new Func<object>[] { () => new HelpPageSampleKey(null, SampleDirection.Request, "c", "a", new string[0]) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Request, "c", "a", null) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Request, null, "a", new string[0]) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Request, "c", null, new string[0]) };
            }
        }

        [Theory]
        [PropertyData("Constructor_ThrowsArgumentNullException_PropertyData")]
        public void Constructor_ThrowsArgumentNullException(Func<object> constructorDelegate)
        {
            Assert.Throws(typeof(ArgumentNullException), constructorDelegate);
        }

        public static IEnumerable<object[]> Constructor_ThrowsArgumentException_PropertyData
        {
            get
            {
                yield return new Func<object>[] { () => new HelpPageSampleKey(SampleDirection.Request, null, "a", new string[0])};
                yield return new Func<object>[] { () => new HelpPageSampleKey(SampleDirection.Request, "c", null, new string[0]) };

                yield return new Func<object>[] { () => new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Request, null, "a", new string[0]) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Request, "c", null, new string[0]) };
            }
        }

        public static IEnumerable<object[]> Constructor_ThrowsInvalidEnumArgumentException_PropertyData
        {
            get
            {
                yield return new Func<object>[] { () => new HelpPageSampleKey((SampleDirection)10, "c", "a", new string[0]) };
                yield return new Func<object>[] { () => new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), (SampleDirection)9, "c", "a", new string[0]) };
            }
        }

        [Theory]
        [PropertyData("Constructor_ThrowsInvalidEnumArgumentException_PropertyData")]
        public void Constructor_ThrowsInvalidEnumArgumentException(Func<object> constructorDelegate)
        {
            Assert.Throws(typeof(InvalidEnumArgumentException), constructorDelegate);
        }

        public static IEnumerable<object[]> Equals_ReturnsTrue_PropertyData
        {
            get
            {
                HelpPageSampleKey key1 = new HelpPageSampleKey(SampleDirection.Request, "myController", "myAction", new[] { "id", "name" });
                HelpPageSampleKey key2 = new HelpPageSampleKey(SampleDirection.Request, "MyController", "myAction", new[] { "ID", "name" });
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(SampleDirection.Request, "myController", "myAction", new[] { "id", "name" });
                key2 = new HelpPageSampleKey((SampleDirection)0, "MyController", "myAction", new[] { "ID", "name" });
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), typeof(Tuple<int, string>));
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("TEXT/custom"), typeof(Tuple<int, string>));
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "controller", "myAction", new string[0]);
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "CONTROLLER", "MYACTION", new string[0]);
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Response, "controller", "myAction", new[] { "ID", "NAME" });
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Response, "CONTROLLER", "MYACTION", new[] { "id", "name" });
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "controller", "action", new string[0]);
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "controller", "action", new string[0]);
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Response, "controller", "action", new string[0]);
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), (SampleDirection)1, "controller", "action", new string[0]);
                yield return new object[] { key1, key2 };
            }
        }

        [Theory]
        [PropertyData("Equals_ReturnsTrue_PropertyData")]
        public void Equals_ReturnsTrue(HelpPageSampleKey key1, HelpPageSampleKey key2)
        {
            Assert.True(key1.Equals(key2));
        }

        public static IEnumerable<object[]> Equals_ReturnsFalse_PropertyData
        {
            get
            {
                HelpPageSampleKey key1 = new HelpPageSampleKey(SampleDirection.Request, "myController", "myAction", new[] { "id", "name" });
                HelpPageSampleKey key2 = new HelpPageSampleKey(SampleDirection.Request, "MyController", "myAction", new string[0]);
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), typeof(Tuple<int, int>));
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("TEXT/custom"), typeof(Tuple<int, string>));
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "controller", "action", new string[0]);
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("TEXT/custom"), SampleDirection.Response, "controller", "action", new string[0]);
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), (SampleDirection)0, "controller", "action", new string[0]);
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("TEXT/custom"), (SampleDirection)1, "controller", "action", new string[0]);
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "controller", "action", new string[] { "" });
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "controller", "action", new string[0]);
                yield return new object[] { key1, key2 };

                key1 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), typeof(Tuple<int, int>));
                key2 = new HelpPageSampleKey(new MediaTypeHeaderValue("text/custom"), SampleDirection.Request, "controller", "action", new string[0]);
                yield return new object[] { key1, key2 };
            }
        }

        [Theory]
        [PropertyData("Equals_ReturnsFalse_PropertyData")]
        public void Equals_ReturnsFalse(HelpPageSampleKey key1, HelpPageSampleKey key2)
        {
            Assert.False(key1.Equals(key2));
        }

        [Theory]
        [PropertyData("Equals_ReturnsTrue_PropertyData")]
        public void GetHashCode_ReturnsSame(HelpPageSampleKey key1, HelpPageSampleKey key2)
        {
            Assert.Equal(key1.GetHashCode(), key2.GetHashCode());
        }

        [Theory]
        [PropertyData("Equals_ReturnsFalse_PropertyData")]
        public void GetHashCode_ReturnsDifferent(HelpPageSampleKey key1, HelpPageSampleKey key2)
        {
            Assert.NotEqual(key1.GetHashCode(), key2.GetHashCode());
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/Helpers/ApiDescriptionHelpers.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Formatting;
using System.Web.Http;
using System.Web.Http.Controllers;
using System.Web.Http.Description;

namespace WebApiHelpPageWebHost.UnitTest.Helpers
{
    public static class ApiDescriptionHelpers
    {
        public static ApiDescription GetApiDescription(HttpConfiguration config, string controllerName, string actionName, params string[] parameterNames)
        {
            if (config == null)
            {
                config = new HttpConfiguration();
                config.Formatters.Clear();
                config.Formatters.Add(new XmlMediaTypeFormatter());
                config.Formatters.Add(new JsonMediaTypeFormatter());
                config.Routes.MapHttpRoute("Default", "{controller}");
            }
            HashSet<string> parameterSet = new HashSet<string>(parameterNames, StringComparer.OrdinalIgnoreCase);
            foreach (var apiDescription in config.Services.GetApiExplorer().ApiDescriptions)
            {
                HttpActionDescriptor actionDescriptor = apiDescription.ActionDescriptor;
                if (String.Equals(actionDescriptor.ControllerDescriptor.ControllerName, controllerName, StringComparison.OrdinalIgnoreCase) &&
                    String.Equals(actionDescriptor.ActionName, actionName, StringComparison.OrdinalIgnoreCase))
                {
                    HashSet<string> actionParameterSet = new HashSet<string>(actionDescriptor.GetParameters().Select(p => p.ParameterName), StringComparer.OrdinalIgnoreCase);
                    if (parameterSet.SetEquals(actionParameterSet))
                    {
                        return apiDescription;
                    }
                }
            }

            return null;
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/Helpers/CustomTypes.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Runtime.Serialization;
using System.Web.Http.Description;
using System.Xml.Serialization;
using Newtonsoft.Json;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class MyGenericType<T, T2>
    {
        public T MyProperty { get; set; }

        public T2 MyProperty2 { get; set; }
    }

    public class Customer
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public List<Order> Orders { get; set; }
    }

    public class Order
    {
        public Guid Id { get; set; }

        public Dictionary<Item, string> Items { get; set; }

        public DateTime ShipDate { get; set; }
    }

    public class Item
    {
        public Customer Buyer { get; set; }

        public string Name { get; set; }

        public double Price { get; set; }
    }

    public class ComplexTypeWithPublicFields
    {
        public string Name;
        public Guid Id;
        public Item item;
    }

    public struct ComplexStruct
    {
        public string Name;
        public Guid Id;

        public DateTime Time { get; set; }

        public DateTimeKind Kind { get; set; }
    }

    public class TypeWithNoDefaultConstructor
    {
        public TypeWithNoDefaultConstructor(int id, string name)
        {
        }
    }

    internal class NonPublicType { }

    public enum EmptyEnum { }

    [ModelName("CustomUser")]
    public class User
    {
        /// <summary>
        /// User name.
        /// </summary>
        [Required]
        public string Name { get; set; }

        /// <summary>
        /// Age of the user.
        /// </summary>
        [Required]
        [Range(1, 200)]
        public int Age { get; set; }

        /// <summary>
        /// User comment.
        /// </summary>
        [StringLength(100)]
        public string Comment { get; set; }

        /// <summary>
        /// U.S. phone number.
        /// </summary>
        public int PhoneNumber { get; set; }
    }

    [ModelName("MyAddress")]
    public class Address
    {
        [DataType(DataType.PostalCode)]
        public string ZipCode { get; set; }

        /// <summary>
        /// Street name.
        /// </summary>
        [RegularExpression("[a-z]")]
        public string Street { get; set; }

        /// <summary>
        /// Geo-coordinate of the address.
        /// </summary>
        [MinLength(2)]
        [MaxLength(3)]
        public int[] Coordinates { get; set; }
    }

    [DataContract]
    public struct StructDataContractType
    {
        public int NoMember { get; set; }

        [DataMember]
        public int Member { get; set; }

        public int NoField { get; set; }

        [DataMember]
        public int Field { get; set; }
    }

    [DataContract]
    public enum EnumDataContractType
    {
        [EnumMember]
        Value,
        NoValue
    }

    [DataContract]
    public class DataContractType
    {
        public int NoMember { get; set; }

        [DataMember]
        public int Member { get; set; }

        public int NoField { get; set; }

        [DataMember]
        public int Field { get; set; }
    }

    public class TypeWithIgnores
    {
        [XmlIgnore]
        public int NoXmlMember { get; set; }

        [JsonIgnore]
        public int NoJsonMember { get; set; }

        [ApiExplorerSettings(IgnoreApi = true)]
        public int NoMember { get; set; }

        [ApiExplorerSettings(IgnoreApi = false)]
        public int Member { get; set; }

        [IgnoreDataMember]
        public int NoDataMember{ get; set; }

        [DataMember]
        public int DataMember { get; set; }

        public int RegularMember { get; set; }

        [XmlIgnore]
        public int NoXmlField;

        [JsonIgnore]
        public int NoJsonField;

        [IgnoreDataMember]
        public int NoDataField;

        [NonSerialized]
        public int NoSerializedField;

        [ApiExplorerSettings(IgnoreApi = true)]
        public int NoField;

        [ApiExplorerSettings(IgnoreApi = false)]
        public int Field;

        [DataMember]
        public int DataField;

        public int RegularField;
    }

    public class DerivedType : TypeWithIgnores
    {
        public string DerivedField;

        public string DerivedMember { get; set; }
    }

    public class PropertyAliasType
    {
        [DataMember(Name = "RenamedField")]
        public string Bar;

        [JsonProperty("RenamedMember")]
        public string Foo { get; set; }

        [JsonProperty("JsonField")]
        [DataMember(Name = "XmlField")]
        public string FooBar;

        [JsonProperty("JsonProperty")]
        [DataMember(Name = "XmlProperty")]
        public string Property4 { get; set; }
    }

    [DataContract]
    public class DataContractPropertyAliasType
    {
        [DataMember(Name = "RenamedField")]
        public string Bar;

        [JsonProperty("RenamedMember")]
        public string Foo { get; set; }

        [JsonProperty("JsonField")]
        [DataMember(Name = "XmlField")]
        public string FooBar;

        [JsonProperty("JsonProperty")]
        [DataMember(Name = "XmlProperty")]
        public string Property4 { get; set; }
    }

    public class MultipleDataAnnotations
    {
        [Range(1, 200)]
        [StringLength(100)]
        [DataType(DataType.PostalCode)]
        [RegularExpression("[a-z]")]
        [Required]
        [MinLength(2)]
        [MaxLength(3)]
        public string Property { get; set; }

        [MinLength(2)]
        [MaxLength(3)]
        [Range(1, 200)]
        [StringLength(100)]
        [DataType(DataType.PostalCode)]
        [RegularExpression("[a-z]")]
        public string OptionalProperty { get; set; }
    }
}

namespace WebApiHelpPageWebHost.UnitTest2
{
    public class Customer
    {
        public string Name { get; set; }
    }
}

================================================
FILE: test/WebApiHelpPage.Test/HelppageSampleGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Net.Http.Formatting;
using System.Net.Http.Headers;
using System.Threading.Tasks;
using System.Web.Http.Description;
using Microsoft.TestCommon;
using Moq;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;
using WebApiHelpPageWebHost.UnitTest.Helpers;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class HelpPageSampleGeneratorTest
    {
        [Fact]
        public void Constructor()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            Assert.NotNull(sampleGenerator.SampleObjects);
            Assert.NotNull(sampleGenerator.ActionSamples);
            Assert.NotNull(sampleGenerator.ActualHttpMessageTypes);
        }

        [Fact]
        public void GetSampleRequests_Empty()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Get");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleRequests(apiDescription);
            Assert.Empty(samples);
        }

        [Fact]
        public void GetSampleRequests_FromSampleObjects()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            sampleGenerator.SampleObjects.Add(typeof(string), "sample value");
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Post", "value");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleRequests(apiDescription);
            Assert.NotEmpty(samples);
            foreach (var samplePair in samples)
            {
                Assert.Contains("sample value", ((TextSample)samplePair.Value).Text);
            }
        }

        [Fact]
        public void GetSampleRequests_FromSampleObjects_AndSettingActualRequestTypes()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            sampleGenerator.ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Request, "values", "options", new[] { "request" }), typeof(string));
            sampleGenerator.SampleObjects.Add(typeof(string), "sample value");
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "values", "options", "request");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleRequests(apiDescription);
            Assert.NotEmpty(samples);
            foreach (var samplePair in samples)
            {
                Assert.Contains("sample value", ((TextSample)samplePair.Value).Text);
            }
        }

        [Fact]
        public void GetSampleRequests_FromActionSamples_BasedOnMediaTypeAndType()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            var sample = new TextSample("test");
            sampleGenerator.ActionSamples.Add(new HelpPageSampleKey(new MediaTypeHeaderValue("application/json"), typeof(Tuple<int, string>)), sample);
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Patch", "valuePair");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleRequests(apiDescription);
            Assert.NotEmpty(samples);
            object result;
            samples.TryGetValue(new MediaTypeHeaderValue("application/json"), out result);
            Assert.Same(sample, result);
            samples.TryGetValue(new MediaTypeHeaderValue("application/xml"), out result);
            Assert.NotSame(sample, result);
        }

        [Fact]
        public void GetSampleRequests_FromActionSamples_BasedOnMediaTypeAndNames()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            var sample = new TextSample("test");
            sampleGenerator.ActionSamples.Add(new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Request, "Values", "Put", new[] { "valuePairCollection" }), sample);
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Put", "valuePairCollection");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleRequests(apiDescription);
            Assert.NotEmpty(samples);
            object result;
            samples.TryGetValue(new MediaTypeHeaderValue("application/xml"), out result);
            Assert.Same(sample, result);
            samples.TryGetValue(new MediaTypeHeaderValue("application/json"), out result);
            Assert.NotSame(sample, result);
        }

        [Fact]
        public void GetSampleRequests_FromActionSamples_WhenTheParameterIsHttpRequestMessage()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            var sample = new TextSample("test");
            sampleGenerator.ActionSamples.Add(new HelpPageSampleKey(new MediaTypeHeaderValue("plain/text"), SampleDirection.Request, "Values", "Options", new[] { "request" }), sample);
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Options", "request");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleRequests(apiDescription);
            Assert.NotEmpty(samples);
            object result;
            samples.TryGetValue(new MediaTypeHeaderValue("plain/text"), out result);
            Assert.Same(sample, result);
            samples.TryGetValue(new MediaTypeHeaderValue("application/json"), out result);
            Assert.Null(result);
        }

        [Fact]
        public void GetSampleResponses_Empty()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Delete", "id");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleResponses(apiDescription);
            Assert.Empty(samples);
        }

        [Fact]
        public void GetSampleResponses_FromSampleObjects()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            sampleGenerator.SampleObjects.Add(typeof(string), "sample value");
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Get", "id");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleResponses(apiDescription);
            Assert.NotEmpty(samples);
            foreach (var samplePair in samples)
            {
                Assert.Contains("sample value", ((TextSample)samplePair.Value).Text);
            }
        }

        [Fact]
        public void GetSampleResponses_FromSampleObjects_AndSettingActualResponseTypes()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            sampleGenerator.ActualHttpMessageTypes.Add(new HelpPageSampleKey(SampleDirection.Response, "values", "post", new[] { "value" }), typeof(string));
            sampleGenerator.SampleObjects.Add(typeof(string), "sample value");
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "values", "post", "value");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleResponses(apiDescription);
            Assert.NotEmpty(samples);
            foreach (var samplePair in samples)
            {
                Assert.Contains("sample value", ((TextSample)samplePair.Value).Text);
            }
        }

        [Fact]
        public void GetSampleResponses_FromActionSamples_BasedOnMediaTypeAndType()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            var sample = new TextSample("test");
            sampleGenerator.ActionSamples.Add(new HelpPageSampleKey(new MediaTypeHeaderValue("application/json"), typeof(IEnumerable<string>)), sample);
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Get", new string[0]);
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleResponses(apiDescription);
            Assert.NotEmpty(samples);
            object result;
            samples.TryGetValue(new MediaTypeHeaderValue("application/json"), out result);
            Assert.Same(sample, result);
            samples.TryGetValue(new MediaTypeHeaderValue("application/xml"), out result);
            Assert.NotSame(sample, result);
        }

        [Fact]
        public void GetSampleResponses_FromActionSamples_BasedOnMediaTypeAndNames()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            var sample = new TextSample("test");
            sampleGenerator.ActionSamples.Add(new HelpPageSampleKey(new MediaTypeHeaderValue("application/xml"), SampleDirection.Response, "Values", "Get", new[] { "id" }), sample);
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Get", "id");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleResponses(apiDescription);
            Assert.NotEmpty(samples);
            object result;
            samples.TryGetValue(new MediaTypeHeaderValue("application/xml"), out result);
            Assert.Same(sample, result);
            samples.TryGetValue(new MediaTypeHeaderValue("application/json"), out result);
            Assert.NotSame(sample, result);
        }

        [Fact]
        public void GetSampleResponses_FromActionSamples_WhenTheReturnTypeIsHttpResponseMessage()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            var sample = new TextSample("test");
            sampleGenerator.ActionSamples.Add(new HelpPageSampleKey(new MediaTypeHeaderValue("plain/text"), SampleDirection.Response, "Values", "Post", new[] { "value" }), sample);
            ApiDescription apiDescription = ApiDescriptionHelpers.GetApiDescription(null, "Values", "Post", "value");
            IDictionary<MediaTypeHeaderValue, object> samples = sampleGenerator.GetSampleResponses(apiDescription);
            Assert.NotEmpty(samples);
            object result;
            samples.TryGetValue(new MediaTypeHeaderValue("plain/text"), out result);
            Assert.Same(sample, result);
            samples.TryGetValue(new MediaTypeHeaderValue("application/json"), out result);
            Assert.Null(result);
        }

        [Fact]
        public void GetActionSample_ReturnNullWhenSampleNotProvided()
        {
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            Assert.Null(
                sampleGenerator.GetActionSample(
                    "a",
                    "b",
                    new string[0],
                    typeof(string),
                    new XmlMediaTypeFormatter(),
                    new MediaTypeHeaderValue("text/xml"),
                    SampleDirection.Response
                ));
        }

        [Fact]
        public void WriteSampleObjectUsingFormatter_ReturnsFormatterError()
        {
            Mock<MediaTypeFormatter> bogusFormatter = new Mock<MediaTypeFormatter>();
            bogusFormatter.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true);
            bogusFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<TransportContext>())).Returns(() =>
            {
                throw new ApplicationException("formatter failed.");
            });
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            InvalidSample sampleNotProvided = Assert.IsType<InvalidSample>(
                sampleGenerator.WriteSampleObjectUsingFormatter(
                    bogusFormatter.Object,
                    "hello world",
                    typeof(string),
                    new MediaTypeHeaderValue("text/json")
                ));
            Assert.Equal("An exception has occurred while using the formatter 'MediaTypeFormatterProxy' to generate sample for media type 'text/json'. Exception message: formatter failed.",
                sampleNotProvided.ErrorMessage);
        }

        [Fact]
        public void WriteSampleObjectUsingFormatter_TryFormattingNonXmlSamples_DoesNotThrow()
        {
            Mock<MediaTypeFormatter> customFormatter = new Mock<MediaTypeFormatter>();
            customFormatter.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true);
            customFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<TransportContext>())).Returns(
            (Type type, object obj, Stream stream, HttpContent content, TransportContext context) =>
            {
                StreamWriter writer = new StreamWriter(stream);
                writer.Write("some\r\nnon xml string");
                writer.Flush();
                TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
                tcs.SetResult(null);
                return tcs.Task;
            });
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            TextSample sample = Assert.IsType<TextSample>(
                sampleGenerator.WriteSampleObjectUsingFormatter(
                    customFormatter.Object,
                    "hello world",
                    typeof(string),
                    new MediaTypeHeaderValue("text/xml")
                ));
            Assert.Equal("some\r\nnon xml string", sample.Text);
        }

        [Fact]
        public void WriteSampleObjectUsingFormatter_TryFormattingNonJsonSamples_DoesNotThrow()
        {
            Mock<MediaTypeFormatter> customFormatter = new Mock<MediaTypeFormatter>();
            customFormatter.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true);
            customFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<TransportContext>())).Returns(
            (Type type, object obj, Stream stream, HttpContent content, TransportContext context) =>
            {
                StreamWriter writer = new StreamWriter(stream);
                writer.Write("some\r\nnon <json> string");
                writer.Flush();
                TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
                tcs.SetResult(null);
                return tcs.Task;
            });
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            TextSample sample = Assert.IsType<TextSample>(
                sampleGenerator.WriteSampleObjectUsingFormatter(
                    customFormatter.Object,
                    "hello world",
                    typeof(string),
                    new MediaTypeHeaderValue("text/json")
                ));
            Assert.Equal("some\r\nnon <json> string", sample.Text);
        }

        [Fact]
        public void WriteSampleObjectUsingFormatter_UnwrapsAggregateException()
        {
            Mock<MediaTypeFormatter> bogusFormatter = new Mock<MediaTypeFormatter>();
            bogusFormatter.Setup(f => f.CanWriteType(It.IsAny<Type>())).Returns(true);
            bogusFormatter.Setup(f => f.WriteToStreamAsync(It.IsAny<Type>(), It.IsAny<object>(), It.IsAny<Stream>(), It.IsAny<HttpContent>(), It.IsAny<TransportContext>())).Returns(() =>
            {
                throw new AggregateException(new FormatException("Invalid format."));
            });
            HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
            InvalidSample sampleNotProvided = Assert.IsType<InvalidSample>(
                sampleGenerator.WriteSampleObjectUsingFormatter(
                    bogusFormatter.Object,
                    "hello world",
                    typeof(string),
                    new MediaTypeHeaderValue("text/json")
                ));
            Assert.Equal("An exception has occurred while using the formatter 'MediaTypeFormatterProxy' to generate sample for media type 'text/json'. Exception message: Invalid format.",
                sampleNotProvided.ErrorMessage);
        }

        [Fact]
        public void ResolveType_ThrowsInvalidEnumArgumentException()
        {
            Assert.Throws(typeof(InvalidEnumArgumentException), () =>
            {
                Collection<MediaTypeFormatter> formatters;
                HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
                sampleGenerator.ResolveType(new ApiDescription(), "c", "a", new[] { "p" }, (SampleDirection)78, out formatters);
            });
        }

        public static IEnumerable<object[]> GetSample_ThrowsArgumentNullException_PropertyData
        {
            get
            {
                yield return new Action[] { () =>
                {
                    HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
                    sampleGenerator.GetSample(null, SampleDirection.Request);
                }};
            }
        }

        public static IEnumerable<object[]> ResolveType_ThrowsArgumentNullException_PropertyData
        {
            get
            {
                yield return new Action[] { () =>
                {
                    HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
                    Collection<MediaTypeFormatter> formatters;
                    sampleGenerator.ResolveType(null, "a", "c", new string[0], SampleDirection.Request, out formatters);
                }};
            }
        }

        public static IEnumerable<object[]> WriteSampleObjectUsingFormatter_ThrowsArgumentNullException_PropertyData
        {
            get
            {
                yield return new Action[] { () =>
                {
                    HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
                    sampleGenerator.WriteSampleObjectUsingFormatter(null, "sample", typeof(string), new MediaTypeHeaderValue("text/xml"));
                }};
                yield return new Action[] { () =>
                {
                    HelpPageSampleGenerator sampleGenerator = new HelpPageSampleGenerator();
                    sampleGenerator.WriteSampleObjectUsingFormatter(new XmlMediaTypeFormatter(), "sample", typeof(string), null);
                }};
            }
        }

        [Theory]
        [PropertyData("GetSample_ThrowsArgumentNullException_PropertyData")]
        [PropertyData("ResolveType_ThrowsArgumentNullException_PropertyData")]
        [PropertyData("WriteSampleObjectUsingFormatter_ThrowsArgumentNullException_PropertyData")]
        public void Method_ThrowsArgumentNullException(Action constructorDelegate)
        {
            Assert.Throws(typeof(ArgumentNullException), constructorDelegate);
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/ImageSampleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class ImageSampleTest
    {
        [Fact]
        public void Constructor()
        {
            ImageSample sample = new ImageSample("http://host/image.png");
            Assert.Equal("http://host/image.png", sample.Src);
        }

        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new ImageSample(null));
        }

        [Fact]
        public void Equals_ReturnsTrue()
        {
            ImageSample sample = new ImageSample("http://host/image.png");
            Assert.Equal(new ImageSample("http://host/image.png"), sample);
        }

        [Fact]
        public void ToString_ReturnsSrc()
        {
            ImageSample sample = new ImageSample("http://host/image.png");
            Assert.Equal("http://host/image.png", sample.ToString());
        }

        [Fact]
        public void GetHashCode_ReturnsSrcHashCode()
        {
            ImageSample sample = new ImageSample("http://host/image.png");
            Assert.Equal("http://host/image.png".GetHashCode(), sample.GetHashCode());
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/InvalidSampleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class InvalidSampleTest
    {
        [Fact]
        public void Constructor()
        {
            InvalidSample sample = new InvalidSample("something failed");
            Assert.Equal("something failed", sample.ErrorMessage);
        }

        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new InvalidSample(null));
        }

        [Fact]
        public void Equals_ReturnsTrue()
        {
            InvalidSample sample = new InvalidSample("something failed");
            Assert.Equal(new InvalidSample("something failed"), sample);
        }

        [Fact]
        public void ToString_ReturnsSrc()
        {
            InvalidSample sample = new InvalidSample("something failed");
            Assert.Equal("something failed", sample.ToString());
        }

        [Fact]
        public void GetHashCode_ReturnsSrcHashCode()
        {
            InvalidSample sample = new InvalidSample("something failed");
            Assert.Equal("something failed".GetHashCode(), sample.GetHashCode());
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/ModelDescriptionGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http;
using System.Web.Http.Description;
using System.Web.Mvc;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage.ModelDescriptions;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class ModelDescriptionGeneratorTest
    {
        [Theory]
        [InlineData(typeof(bool), "Boolean", "boolean")]
        [InlineData(typeof(byte), "Byte", "byte")]
        [InlineData(typeof(char), "Char", "character")]
        [InlineData(typeof(Decimal), "Decimal", "decimal number")]
        [InlineData(typeof(double), "Double", "decimal number")]
        [InlineData(typeof(Guid), "Guid", "globally unique identifier")]
        [InlineData(typeof(int), "Int32", "integer")]
        [InlineData(typeof(string), "String", "string")]
        [InlineData(typeof(float), "Single", "decimal number")]
        [InlineData(typeof(long), "Int64", "integer")]
        [InlineData(typeof(uint), "UInt32", "unsigned integer")]
        [InlineData(typeof(ulong), "UInt64", "unsigned integer")]
        [InlineData(typeof(sbyte), "SByte", "signed byte")]
        [InlineData(typeof(DateTime), "DateTime", "date")]
        [InlineData(typeof(DateTimeOffset), "DateTimeOffset", "date")]
        [InlineData(typeof(TimeSpan), "TimeSpan", "time interval")]
        [InlineData(typeof(UInt16), "UInt16", "unsigned integer")]
        [InlineData(typeof(Int16), "Int16", "integer")]
        [InlineData(typeof(Uri), "Uri", "URI")]
        public void CreateModelDescription_SimpleTypes(Type type, string expectedModelName, string expectedDocumentation)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            SimpleTypeModelDescription simpleModel = Assert.IsType<SimpleTypeModelDescription>(modelGenerator.GetOrCreateModelDescription(type));

            Assert.NotNull(simpleModel);
            Assert.Equal(expectedModelName, simpleModel.Name);
            Assert.Equal(type, simpleModel.ModelType);
            Assert.Equal(expectedDocumentation, simpleModel.Documentation);
        }

        [Theory]
        [InlineData(typeof(IEnumerable<string>), typeof(string))]
        [InlineData(typeof(IEnumerable<List<string>>), typeof(List<string>))]
        [InlineData(typeof(IEnumerable<int>), typeof(int))]
        [InlineData(typeof(IEnumerable<Nullable<double>>), typeof(double))]
        [InlineData(typeof(IEnumerable<DateTime>), typeof(DateTime))]
        [InlineData(typeof(ICollection<string>), typeof(string))]
        [InlineData(typeof(ICollection<int>), typeof(int))]
        [InlineData(typeof(ICollection<Nullable<double>>), typeof(double))]
        [InlineData(typeof(ICollection<DateTime>), typeof(DateTime))]
        [InlineData(typeof(IList<string>), typeof(string))]
        [InlineData(typeof(IList<int>), typeof(int))]
        [InlineData(typeof(IList<Nullable<double>>), typeof(double))]
        [InlineData(typeof(IList<DateTime>), typeof(DateTime))]
        [InlineData(typeof(List<string>), typeof(string))]
        [InlineData(typeof(List<int>), typeof(int))]
        [InlineData(typeof(List<Nullable<double>>), typeof(double))]
        [InlineData(typeof(List<DateTime>), typeof(DateTime))]
        [InlineData(typeof(IEnumerable<KeyValuePair<string, int>>), typeof(KeyValuePair<string, int>))]
        [InlineData(typeof(IEnumerable<KeyValuePair<DateTime, int?>>), typeof(KeyValuePair<DateTime, int?>))]
        [InlineData(typeof(IEnumerable), typeof(object))]
        [InlineData(typeof(ICollection), typeof(object))]
        [InlineData(typeof(IList), typeof(object))]
        [InlineData(typeof(ArrayList), typeof(object))]
        [InlineData(typeof(HashSet<string>), typeof(string))]
        [InlineData(typeof(IQueryable<string>), typeof(string))]
        [InlineData(typeof(IQueryable<Customer>), typeof(Customer))]
        [InlineData(typeof(IQueryable<HttpVerbs[]>), typeof(HttpVerbs[]))]
        [InlineData(typeof(IQueryable<List<DateTime>>), typeof(List<DateTime>))]
        [InlineData(typeof(IQueryable), typeof(object))]
        [InlineData(typeof(string[]), typeof(string))]
        [InlineData(typeof(int[]), typeof(int))]
        [InlineData(typeof(double?[]), typeof(double))]
        [InlineData(typeof(DateTime[]), typeof(DateTime))]
        [InlineData(typeof(Customer[]), typeof(Customer))]
        [InlineData(typeof(HttpVerbs[]), typeof(HttpVerbs))]
        public void CreateModelDescription_Collection(Type collectionType, Type itemType)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            CollectionModelDescription collectionModel = Assert.IsType<CollectionModelDescription>(modelGenerator.GetOrCreateModelDescription(collectionType));

            Assert.NotNull(collectionModel);
            Assert.Equal(collectionType, collectionModel.ModelType);
            Assert.Equal(itemType, collectionModel.ElementDescription.ModelType);
        }

        [Theory]
        [InlineData(typeof(Dictionary<string, int>), typeof(string), typeof(int))]
        [InlineData(typeof(Dictionary<string, Dictionary<Customer, Order>>), typeof(string), typeof(Dictionary<Customer, Order>))]
        [InlineData(typeof(Hashtable), typeof(object), typeof(object))]
        [InlineData(typeof(IDictionary), typeof(object), typeof(object))]
        [InlineData(typeof(IDictionary<string, DateTime>), typeof(string), typeof(DateTime))]
        [InlineData(typeof(SortedDictionary<string, Guid>), typeof(string), typeof(Guid))]
        [InlineData(typeof(OrderedDictionary), typeof(object), typeof(object))]
        [InlineData(typeof(ConcurrentDictionary<Guid, DateTime>), typeof(Guid), typeof(DateTime))]
        public void CreateModelDescription_Dictionary(Type dictionaryType, Type keyType, Type valueType)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            DictionaryModelDescription dictionaryModel = Assert.IsType<DictionaryModelDescription>(modelGenerator.GetOrCreateModelDescription(dictionaryType));

            Assert.NotNull(dictionaryModel);
            Assert.Equal(dictionaryType, dictionaryModel.ModelType);
            Assert.Equal(keyType, dictionaryModel.KeyModelDescription.ModelType);
            Assert.Equal(valueType, dictionaryModel.ValueModelDescription.ModelType);
        }

        [Theory]
        [InlineData(typeof(KeyValuePair<string, int>), typeof(string), typeof(int))]
        [InlineData(typeof(KeyValuePair<Dictionary<int, string>, int>), typeof(Dictionary<int, string>), typeof(int))]
        [InlineData(typeof(KeyValuePair<string, User>), typeof(string), typeof(User))]
        public void CreateModelDescription_KeyValuePair(Type modelType, Type keyType, Type valueType)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            KeyValuePairModelDescription keyValuePairModel = Assert.IsType<KeyValuePairModelDescription>(modelGenerator.GetOrCreateModelDescription(modelType));

            Assert.NotNull(keyValuePairModel);
            Assert.Equal(modelType, keyValuePairModel.ModelType);
            Assert.Equal(keyType, keyValuePairModel.KeyModelDescription.ModelType);
            Assert.Equal(valueType, keyValuePairModel.ValueModelDescription.ModelType);
        }

        [Theory]
        [InlineData(typeof(HttpStatusCode), 47)]
        [InlineData(typeof(HttpVerbs), 7)]
        [InlineData(typeof(ApiParameterSource), 3)]
        [InlineData(typeof(SampleDirection), 2)]
        [InlineData(typeof(ConsoleColor), 16)]
        [InlineData(typeof(HttpCompletionOption), 2)]
        [InlineData(typeof(EnumDataContractType), 1)]
        public void CreateModelDescription_Enum(Type type, int enumValueCount)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            EnumTypeModelDescription enumModel = Assert.IsType<EnumTypeModelDescription>(modelGenerator.GetOrCreateModelDescription(type));

            Assert.NotNull(enumModel);
            Assert.Equal(type, enumModel.ModelType);
            Assert.Equal(enumValueCount, enumModel.Values.Count);
        }

        [Theory]
        [InlineData(typeof(ComplexTypeWithPublicFields), new[] { "Name", "Id", "item" })]
        [InlineData(typeof(ComplexStruct), new[] { "Name", "Id", "Time", "Kind" })]
        [InlineData(typeof(ApiDescription), new[] { "HttpMethod", "RelativePath", "ActionDescriptor", "Route", "Documentation", "SupportedResponseFormatters", "SupportedRequestBodyFormatters", "ParameterDescriptions", "ResponseDescription", "ID" })]
        [InlineData(typeof(ApiParameterDescription), new[] { "Name", "Documentation", "Source", "ParameterDescriptor" })]
        [InlineData(typeof(Customer), new[] { "Name", "Id", "Orders" })] // Circular reference
        [InlineData(typeof(Order), new[] { "Items", "Id", "ShipDate" })] // Circular reference
        [InlineData(typeof(Item), new[] { "Name", "Buyer", "Price" })] // Circular reference
        [InlineData(typeof(DataContractType), new[] { "Member", "Field" })]
        [InlineData(typeof(StructDataContractType), new[] { "Member", "Field" })]
        [InlineData(typeof(TypeWithIgnores), new[] { "Member", "DataMember", "RegularMember", "Field", "DataField", "RegularField" })]
        [InlineData(typeof(DerivedType), new[] { "Member", "DataMember", "RegularMember", "Field", "DataField", "RegularField", "DerivedField", "DerivedMember" })]
        [InlineData(typeof(PropertyAliasType), new[] { "RenamedMember", "Bar", "JsonField", "JsonProperty" })]
        [InlineData(typeof(DataContractPropertyAliasType), new[] { "RenamedField", "JsonField", "JsonProperty" })]
        public void CreateModelDescription_ComplexType(Type type, string[] expectedPropertyNames)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            ComplexTypeModelDescription complexModel = Assert.IsType<ComplexTypeModelDescription>(modelGenerator.GetOrCreateModelDescription(type));
            var propertyNames = complexModel.Properties.Select(m => m.Name).ToArray();

            Assert.NotNull(complexModel);
            Assert.Equal(type, complexModel.ModelType);
            Assert.Equal(expectedPropertyNames.Length, propertyNames.Length);
            foreach (var expectedPropertyName in expectedPropertyNames)
            {
                Assert.Contains(expectedPropertyName, propertyNames);
            }
        }

        [Theory]
        [InlineData(typeof(ComplexTypeWithPublicFields), "ComplexTypeWithPublicFields")]
        [InlineData(typeof(ComplexStruct), "ComplexStruct")]
        [InlineData(typeof(Customer), "Customer")]
        [InlineData(typeof(Order), "Order")]
        [InlineData(typeof(Item), "Item")]
        [InlineData(typeof(User), "CustomUser")]
        [InlineData(typeof(Address), "MyAddress")]
        public void CreateModelDescription_ComplexType_ReturnsExpectedModelName(Type type, string expectedModelName)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            ComplexTypeModelDescription complexModel = Assert.IsType<ComplexTypeModelDescription>(modelGenerator.GetOrCreateModelDescription(type));

            Assert.NotNull(complexModel);
            Assert.Equal(type, complexModel.ModelType);
            Assert.Equal(expectedModelName, complexModel.Name);
        }

        public static IEnumerable<object[]> CreateModelDescription_ComplexType_WithAnnotation_PropertyData
        {
            get
            {
                object type;
                object annotationMapping;

                type = typeof(User);
                annotationMapping = new Dictionary<string, string[]>
                {
                    { "Name", new[] { "Required" } },
                    { "Age", new[] { "Required", "Range: inclusive between 1 and 200" } },
                    { "Comment", new[] { "String length: inclusive between 0 and 100" } },
                    { "PhoneNumber", new string[0] },
                };

                yield return new[] { type, annotationMapping };

                type = typeof(Address);
                annotationMapping = new Dictionary<string, string[]>
                {
                    { "ZipCode", new[] { "Data type: PostalCode" } },
                    { "Street", new[] { "Matching regular expression pattern: [a-z]" } },
                    { "Coordinates", new[] { "Max length: 3", "Min length: 2" } },
                };

                yield return new[] { type, annotationMapping };

                type = typeof(MultipleDataAnnotations);
                annotationMapping = new Dictionary<string, string[]>
                {
                    {
                        "Property", new[] {
                            "Required",
                            "Data type: PostalCode",
                            "Matching regular expression pattern: [a-z]",
                            "Max length: 3",
                            "Min length: 2",
                            "Range: inclusive between 1 and 200",
                            "String length: inclusive between 0 and 100"}
                    },
                    {
                        "OptionalProperty", new[] {
                            "Data type: PostalCode",
                            "Matching regular expression pattern: [a-z]",
                            "Max length: 3",
                            "Min length: 2",
                            "Range: inclusive between 1 and 200",
                            "String length: inclusive between 0 and 100"}
                    }
                };

                yield return new[] { type, annotationMapping };
            }
        }

        [Theory]
        [PropertyData("CreateModelDescription_ComplexType_WithAnnotation_PropertyData")]
        public void CreateModelDescription_ComplexType_WithAnnotation(Type type, Dictionary<string, string[]> annotationMapping)
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            ComplexTypeModelDescription complexModel = Assert.IsType<ComplexTypeModelDescription>(modelGenerator.GetOrCreateModelDescription(type));

            Assert.NotNull(complexModel);
            Assert.Equal(type, complexModel.ModelType);
            Assert.Equal(annotationMapping.Count, complexModel.Properties.Count);
            foreach (var property in complexModel.Properties)
            {
                string[] expectedAnnotations = annotationMapping[property.Name];
                Assert.Equal(expectedAnnotations.Length, property.Annotations.Count);
                for (int i = 0; i < expectedAnnotations.Length; i++)
                {
                    Assert.Equal(expectedAnnotations[i], property.Annotations[i].Documentation);
                }
            }
        }

        public static IEnumerable<object[]> CreateModelDescription_ComplexType_WithDocumentation_PropertyData
        {
            get
            {
                object type;
                object annotationMapping;

                type = typeof(User);
                annotationMapping = new Dictionary<string, string>
                {
                    { "Name", "User name."},
                    { "Age", "Age of the user." },
                    { "Comment", "User comment." },
                    { "PhoneNumber", "U.S. phone number." },
                };

                yield return new[] { type, annotationMapping };

                type = typeof(Address);
                annotationMapping = new Dictionary<string, string>
                {
                    { "ZipCode", null },
                    { "Street", "Street name." },
                    { "Coordinates", "Geo-coordinate of the address." },
                };

                yield return new[] { type, annotationMapping };
            }
        }

        [Theory]
        [PropertyData("CreateModelDescription_ComplexType_WithDocumentation_PropertyData")]
        public void CreateModelDescription_ComplexType_WithDocumentation(Type type, Dictionary<string, string> documentationMapping)
        {
            HttpConfiguration config = new HttpConfiguration();
            config.SetDocumentationProvider(new XmlDocumentationProvider("WebApiHelpPage.Test.XML"));
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            ComplexTypeModelDescription complexModel = Assert.IsType<ComplexTypeModelDescription>(modelGenerator.GetOrCreateModelDescription(type));

            Assert.NotNull(complexModel);
            Assert.Equal(type, complexModel.ModelType);
            Assert.Equal(documentationMapping.Count, complexModel.Properties.Count);
            foreach (var property in complexModel.Properties)
            {
                string expectedDocumentation = documentationMapping[property.Name];
                Assert.Equal(expectedDocumentation, property.Documentation);
            }
        }

        [Fact]
        public void CreateModelDescription_ThrowsOnDuplicateModelName()
        {
            HttpConfiguration config = new HttpConfiguration();
            ModelDescriptionGenerator modelGenerator = new ModelDescriptionGenerator(config);

            Assert.Throws<InvalidOperationException>(() =>
            {
                modelGenerator.GetOrCreateModelDescription(typeof(Customer));
                modelGenerator.GetOrCreateModelDescription(typeof(WebApiHelpPageWebHost.UnitTest2.Customer));
            },
            "A model description could not be created. Duplicate model name 'Customer' was found for types 'WebApiHelpPageWebHost.UnitTest.Customer' and 'WebApiHelpPageWebHost.UnitTest2.Customer'. Use the [ModelName] attribute to change the model name for at least one of the types so that it has a unique name.");
        }
    }
}

================================================
FILE: test/WebApiHelpPage.Test/ObjectGeneratorTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Web.Http.Description;
using System.Web.Mvc;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class ObjectGeneratorTest
    {
        [Theory]
        [InlineData(typeof(bool))]
        [InlineData(typeof(byte))]
        [InlineData(typeof(char))]
        [InlineData(typeof(DBNull))]
        [InlineData(typeof(Decimal))]
        [InlineData(typeof(double))]
        [InlineData(typeof(Guid))]
        [InlineData(typeof(int))]
        [InlineData(typeof(string))]
        [InlineData(typeof(float))]
        [InlineData(typeof(long))]
        [InlineData(typeof(uint))]
        [InlineData(typeof(ulong))]
        [InlineData(typeof(sbyte))]
        [InlineData(typeof(DateTime))]
        [InlineData(typeof(DateTimeOffset))]
        [InlineData(typeof(TimeSpan))]
        [InlineData(typeof(UInt16))]
        [InlineData(typeof(Int16))]
        [InlineData(typeof(Guid))]
        [InlineData(typeof(Uri))]
        public void GenerateObject_SimpleTypes(Type type)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            object instance = objectGenerator.GenerateObject(type);
            Assert.NotNull(instance);
            Assert.IsType(type, instance);
        }

        [Theory]
        [InlineData(typeof(KeyValuePair<string, int>))]
        [InlineData(typeof(KeyValuePair<string, KeyValuePair<int, DateTime>>))]
        [InlineData(typeof(Tuple<string>))]
        [InlineData(typeof(Tuple<string, int>))]
        [InlineData(typeof(Tuple<string, int, double, DateTime>))]
        [InlineData(typeof(Tuple<string, int, double, DateTime, Tuple<int?>>))]
        [InlineData(typeof(Tuple<string, int, double, DateTime, Tuple<int?>, Tuple<double, string>>))]
        [InlineData(typeof(Tuple<string, int, double, Type, DateTimeOffset, byte, sbyte>))]
        [InlineData(typeof(Tuple<string, int, double, Type, DateTimeOffset, byte, sbyte, Tuple<char, uint>>))]
        [InlineData(typeof(MyGenericType<int, string>))]
        [InlineData(typeof(MyGenericType<int, Tuple<string, DateTime>>))]
        [InlineData(typeof(MyGenericType<MyGenericType<DateTime, HttpVerbs>, string>))]
        public void GenerateObject_Generic(Type genericType)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            object instance = objectGenerator.GenerateObject(genericType);
            Assert.NotNull(instance);
            Assert.IsType(genericType, instance);
        }

        [Theory]
        [InlineData(typeof(IEnumerable<string>), typeof(string))]
        [InlineData(typeof(IEnumerable<List<string>>), typeof(List<string>))]
        [InlineData(typeof(IEnumerable<int>), typeof(int))]
        [InlineData(typeof(IEnumerable<Nullable<double>>), typeof(double))]
        [InlineData(typeof(IEnumerable<DateTime>), typeof(DateTime))]
        [InlineData(typeof(ICollection<string>), typeof(string))]
        [InlineData(typeof(ICollection<int>), typeof(int))]
        [InlineData(typeof(ICollection<Nullable<double>>), typeof(double))]
        [InlineData(typeof(ICollection<DateTime>), typeof(DateTime))]
        [InlineData(typeof(IList<string>), typeof(string))]
        [InlineData(typeof(IList<int>), typeof(int))]
        [InlineData(typeof(IList<Nullable<double>>), typeof(double))]
        [InlineData(typeof(IList<DateTime>), typeof(DateTime))]
        [InlineData(typeof(List<string>), typeof(string))]
        [InlineData(typeof(List<int>), typeof(int))]
        [InlineData(typeof(List<Nullable<double>>), typeof(double))]
        [InlineData(typeof(List<DateTime>), typeof(DateTime))]
        [InlineData(typeof(IEnumerable<KeyValuePair<string, int>>), typeof(KeyValuePair<string, int>))]
        [InlineData(typeof(IEnumerable<KeyValuePair<DateTime, int?>>), typeof(KeyValuePair<DateTime, int?>))]
        [InlineData(typeof(IEnumerable), typeof(object))]
        [InlineData(typeof(ICollection), typeof(object))]
        [InlineData(typeof(IList), typeof(object))]
        [InlineData(typeof(ArrayList), typeof(object))]
        [InlineData(typeof(HashSet<string>), typeof(string))]
        public void GenerateObject_Collection(Type collectionType, Type itemType)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            IEnumerable collection = objectGenerator.GenerateObject(collectionType) as IEnumerable;
            Assert.NotEmpty(collection);
            foreach (var item in collection)
            {
                Assert.NotNull(item);
                Assert.IsType(itemType, item);
            }
        }

        [Theory]
        [InlineData(typeof(IQueryable<string>), typeof(string))]
        [InlineData(typeof(IQueryable<Customer>), typeof(Customer))]
        [InlineData(typeof(IQueryable<HttpVerbs[]>), typeof(HttpVerbs[]))]
        [InlineData(typeof(IQueryable<List<DateTime>>), typeof(List<DateTime>))]
        [InlineData(typeof(IQueryable), typeof(object))]
        public void GenerateObject_IQueryable(Type collectionType, Type itemType)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            IQueryable collection = objectGenerator.GenerateObject(collectionType) as IQueryable;
            Assert.NotEmpty(collection);
            foreach (var item in collection)
            {
                Assert.NotNull(item);
                Assert.IsType(itemType, item);
            }
        }

        [Theory]
        [InlineData(typeof(string[]), typeof(string))]
        [InlineData(typeof(int[]), typeof(int))]
        [InlineData(typeof(double?[]), typeof(double))]
        [InlineData(typeof(DateTime[]), typeof(DateTime))]
        [InlineData(typeof(Customer[]), typeof(Customer))]
        [InlineData(typeof(HttpVerbs[]), typeof(HttpVerbs))]
        public void GenerateObject_Array(Type arrayType, Type elementType)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            Array array = objectGenerator.GenerateObject(arrayType) as Array;
            Assert.NotEmpty(array);
            foreach (var item in array)
            {
                Assert.NotNull(item);
                Assert.IsType(elementType, item);
            }
        }

        [Theory]
        [InlineData(typeof(Dictionary<string, int>), typeof(string), typeof(int))]
        [InlineData(typeof(Dictionary<string, Dictionary<Customer, Order>>), typeof(string), typeof(Dictionary<Customer, Order>))]
        [InlineData(typeof(Hashtable), typeof(object), typeof(object))]
        [InlineData(typeof(IDictionary), typeof(object), typeof(object))]
        [InlineData(typeof(IDictionary<string, DateTime>), typeof(string), typeof(DateTime))]
        [InlineData(typeof(SortedDictionary<string, Guid>), typeof(string), typeof(Guid))]
        [InlineData(typeof(OrderedDictionary), typeof(object), typeof(object))]
        [InlineData(typeof(ConcurrentDictionary<Guid, DateTime>), typeof(Guid), typeof(DateTime))]
        public void GenerateObject_Dictionary(Type dictionaryType, Type keyType, Type valueType)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            IDictionary dictionary = objectGenerator.GenerateObject(dictionaryType) as IDictionary;
            Assert.NotEmpty(dictionary);
            foreach (var key in dictionary.Keys)
            {
                Assert.NotNull(key);
                Assert.IsType(keyType, key);
            }
            foreach (var value in dictionary.Values)
            {
                Assert.NotNull(value);
                Assert.IsType(valueType, value);
            }
        }

        [Theory]
        [InlineData(typeof(HttpStatusCode))]
        [InlineData(typeof(HttpVerbs))]
        [InlineData(typeof(ApiParameterSource))]
        [InlineData(typeof(SampleDirection))]
        [InlineData(typeof(ConsoleColor))]
        [InlineData(typeof(HttpCompletionOption))]
        public void GenerateObject_Enum(Type type)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            object enumValue = objectGenerator.GenerateObject(type);
            Assert.NotNull(enumValue);
            Assert.True(Enum.IsDefined(type, enumValue));
        }

        [Theory]
        [InlineData(typeof(HttpResponseMessage))]
        [InlineData(typeof(ComplexTypeWithPublicFields))]
        [InlineData(typeof(ComplexStruct))]
        [InlineData(typeof(ApiDescription))]
        [InlineData(typeof(ApiParameterDescription))]
        [InlineData(typeof(Customer))] // Circular reference
        [InlineData(typeof(Order))] // Circular reference
        [InlineData(typeof(Item))] // Circular reference
        public void GenerateObject_ComplexType(Type type)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            object instance = objectGenerator.GenerateObject(type);
            Assert.NotNull(instance);
            Assert.IsType(type, instance);
        }

        [Theory]
        [InlineData(typeof(TypeWithNoDefaultConstructor))]
        [InlineData(typeof(NonPublicType))]
        [InlineData(typeof(EmptyEnum))]
        [InlineData(typeof(HttpRequestMessage))]
        [InlineData(typeof(KeyValuePair<EmptyEnum, NonPublicType>))]
        [InlineData(typeof(Tuple<EmptyEnum, NonPublicType, TypeWithNoDefaultConstructor>))]
        [InlineData(typeof(List<EmptyEnum>))]
        [InlineData(typeof(Dictionary<EmptyEnum, NonPublicType>))]
        [InlineData(typeof(EmptyEnum[]))]
        [InlineData(typeof(IQueryable<EmptyEnum>))]
        public void GenerateObject_ReturnsNull_WhenInstanceCannotBeCreated(Type type)
        {
            ObjectGenerator objectGenerator = new ObjectGenerator();
            Assert.Null(objectGenerator.GenerateObject(type));
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/TextSampleTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class TextSampleTest
    {
        [Fact]
        public void Constructor()
        {
            TextSample sample = new TextSample("some text");
            Assert.Equal("some text", sample.Text);
        }

        [Fact]
        public void Constructor_ThrowsArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new TextSample(null));
        }

        [Fact]
        public void Equals_ReturnsTrue()
        {
            TextSample sample = new TextSample("some text");
            Assert.Equal(new TextSample("some text"), sample);
        }

        [Fact]
        public void ToString_ReturnsText()
        {
            TextSample sample = new TextSample("some text");
            Assert.Equal("some text", sample.ToString());
        }

        [Fact]
        public void GetHashCode_ReturnsTextHashCode()
        {
            TextSample sample = new TextSample("some text");
            Assert.Equal("some text".GetHashCode(), sample.GetHashCode());
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/WebApiHelpPage.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{291EF478-BF24-4935-BC78-E0DCCD0C9A1B}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>WebApiHelpPage</RootNamespace>
    <AssemblyName>WebApiHelpPage.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <NoWarn>1591</NoWarn>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Web" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="Controllers\UsersController.cs" />
    <Compile Include="Controllers\ValuesController.cs" />
    <Compile Include="ModelDescriptionGeneratorTest.cs" />
    <Compile Include="Helpers\CustomTypes.cs" />
    <Compile Include="ObjectGeneratorTest.cs" />
    <Compile Include="InvalidSampleTest.cs" />
    <Compile Include="HelpPageApiModelTest.cs" />
    <Compile Include="TextSampleTest.cs" />
    <Compile Include="ImageSampleTest.cs" />
    <Compile Include="HelpPageAreaRegistrationTest.cs" />
    <Compile Include="HelpPageSampleKeyTest.cs" />
    <Compile Include="Helpers\ApiDescriptionHelpers.cs" />
    <Compile Include="HelppageSampleGeneratorTest.cs" />
    <Compile Include="HelpControllerTest.cs" />
    <Compile Include="WebConfigTest.cs" />
    <Compile Include="XmlDocumentationProviderTest.cs" />
    <Compile Include="HelpPageConfigurationExtensionsTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config">
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\..\src\WebApiHelpPage\Areas\HelpPage\Views\Web.config">
      <Link>TestFiles\Web.config</Link>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9b7e3740-6161-4548-833c-4bbca43b970e}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.WebHost\System.Web.Http.WebHost.csproj">
      <Project>{a0187bc2-8325-4bb2-8697-7f955cf4173e}</Project>
      <Name>System.Web.Http.WebHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3d3ffd8a-624d-4e9b-954b-e1c105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8f18041b-9410-4c36-a9c5-067813df5f31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22babb60-8f02-4027-affc-acf069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939b11a-fe4e-4ba1-8ad6-d97741ee314f}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76efa9c5-8d7e-4fdf-b710-e20f8b6b00d2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\WebApiHelpPage\WebApiHelpPage.csproj">
      <Project>{FEDFE6CA-8282-4C5B-A756-E97189690982}</Project>
      <Name>WebApiHelpPage</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{fccc4cb7-baf7-4a57-9f89-e5766fe536c0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: test/WebApiHelpPage.Test/WebConfigTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.IO;
using System.Linq;
using System.Web.Mvc;
using System.Xml.Linq;
using Microsoft.TestCommon;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class WebConfigTest
    {
        [Fact]
        public void WebConfig_HelpPageReferencesCorrectMvcHostVersion()
        {
            // Arrange
            Version mvcVersion = VersionTestHelper.GetVersionFromAssembly("System.Web.Mvc", typeof(Controller));
            string expectedFactoryType = "System.Web.Mvc.MvcWebRazorHostFactory, System.Web.Mvc, Version=" + mvcVersion
                + ", Culture=neutral, PublicKeyToken=31BF3856AD364E35";
            using (Stream webConfigStream = typeof(WebConfigTest).Assembly
                .GetManifestResourceStream(@"WebApiHelpPage.TestFiles.Web.config"))
            {
                XDocument document = XDocument.Load(webConfigStream);

                // Act
                string actualFactoryType = document.Root
                    .Element("system.web.webPages.razor")
                    .Element("host")
                    .Attribute("factoryType")
                    .Value;

                // Assert
                Assert.Equal(expectedFactoryType, actualFactoryType);
            }
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/XmlDocumentationProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Web.Http;
using System.Web.Http.Controllers;
using Microsoft.TestCommon;
using ROOT_PROJECT_NAMESPACE.Areas.HelpPage;
using WebApiHelpPageWebHost.UnitTest.Controllers;

namespace WebApiHelpPageWebHost.UnitTest
{
    public class XmlDocumentationProviderTest
    {
        [Fact]
        public void Constructor_ThrowArgumentNullException()
        {
            Assert.Throws<ArgumentNullException>(() => new XmlDocumentationProvider(null));
        }

        public static IEnumerable<object[]> GetDocumentationForAction_PropertyData
        {
            get
            {
                ValuesController controller = new ValuesController();

                Func<IEnumerable<string>> getAction = controller.Get;
                HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), getAction.Method);
                yield return new object[] { actionDescriptor, "Gets all the values." };

                Func<int, string> getIdAction = controller.Get;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), getIdAction.Method);
                yield return new object[] { actionDescriptor, "Gets the value by id." };

                Func<string, string> getNameAction = controller.Get;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), getNameAction.Method);
                yield return new object[] { actionDescriptor, "Gets the value by name." };

                Func<string, HttpResponseMessage> postAction = controller.Post;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), postAction.Method);
                yield return new object[] { actionDescriptor, "Create a new value." };

                Action<int, string> putAction = controller.Put;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), putAction.Method);
                yield return new object[] { actionDescriptor, "Updates the value." };

                Action<List<Tuple<int, string>>> putCollectionAction = controller.Put;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), putCollectionAction.Method);
                yield return new object[] { actionDescriptor, "Updates the value pair collection." };

                Action<int?> deleteAction = controller.Delete;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), deleteAction.Method);
                yield return new object[] { actionDescriptor, "Deletes the value." };

                Action<Tuple<int, string>> patchAction = controller.Patch;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), patchAction.Method);
                yield return new object[] { actionDescriptor, "Patches the value pair." };

                Func<HttpRequestMessage, string> optionsAction = controller.Options;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), optionsAction.Method);
                yield return new object[] { actionDescriptor, "Returns the options." };

                Func<int, string[]> headAction = controller.HeadNoDocumentation;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), headAction.Method);
                yield return new object[] { actionDescriptor, null };
            }
        }

        [Theory]
        [PropertyData("GetDocumentationForAction_PropertyData")]
        public void GetDocumentationForAction(HttpActionDescriptor actionDescriptor, string expectedString)
        {
            XmlDocumentationProvider provider = new XmlDocumentationProvider("WebApiHelpPage.Test.XML");
            string documentationString = provider.GetDocumentation(actionDescriptor);
            Assert.Equal(expectedString, documentationString);
        }

        public static IEnumerable<object[]> GetDocumentationForParameters_PropertyData
        {
            get
            {
                HttpActionDescriptor[] actionDescriptors = GetDocumentationForAction_PropertyData.Select(a => (HttpActionDescriptor)a[0]).ToArray();
                Dictionary<string, string>[] expectedResults = 
                {
                    new Dictionary<string,string>(),
                    new Dictionary<string, string>{{"id","The id."}},
                    new Dictionary<string, string>{{"name","The name."}},
                    new Dictionary<string, string>{{"value","The value."}},
                    new Dictionary<string, string>{{"id","The id."}, {"value","The value."}},
                    new Dictionary<string, string>{{"valuePairCollection","The value pair collection."}},
                    new Dictionary<string, string>{{"id","The id."}},
                    new Dictionary<string, string>{{"valuePair","The pair."}},
                    new Dictionary<string, string>{{"request","The request."}},
                    new Dictionary<string, string>{{"id", null}},
                };

                Assert.Equal(expectedResults.Length, actionDescriptors.Length);

                for (int i = 0; i < actionDescriptors.Length; i++)
                {
                    var actionDescriptor = actionDescriptors[i];
                    foreach (var parameterDescriptor in actionDescriptor.GetParameters())
                    {
                        yield return new object[] { parameterDescriptor, expectedResults[i][parameterDescriptor.ParameterName] };
                    }
                }
            }
        }

        [Theory]
        [PropertyData("GetDocumentationForParameters_PropertyData")]
        public void GetDocumentationForParameters(HttpParameterDescriptor parameterDescriptor, string expectedString)
        {
            XmlDocumentationProvider provider = new XmlDocumentationProvider("WebApiHelpPage.Test.XML");
            string documentationString = provider.GetDocumentation(parameterDescriptor);
            Assert.Equal(expectedString, documentationString);
        }

        public static IEnumerable<object[]> GetDocumentationForController_PropertyData
        {
            get
            {
                HttpControllerDescriptor controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "Values", typeof(ValuesController));
                yield return new object[] { controllerDescriptor, "Resource for Values." };

                controllerDescriptor = new HttpControllerDescriptor(new HttpConfiguration(), "NestedValues", typeof(ValuesController.NestedValuesController));
                yield return new object[] { controllerDescriptor, "Resource for nested values." };
            }
        }

        [Theory]
        [PropertyData("GetDocumentationForController_PropertyData")]
        public void GetDocumentationForController(HttpControllerDescriptor controllerDescriptor, string expectedString)
        {
            XmlDocumentationProvider provider = new XmlDocumentationProvider("WebApiHelpPage.Test.XML");
            string documentationString = provider.GetDocumentation(controllerDescriptor);
            Assert.Equal(expectedString, documentationString);
        }

        public static IEnumerable<object[]> GetDocumentationForActionResponse_PropertyData
        {
            get
            {
                ValuesController controller = new ValuesController();

                Func<IEnumerable<string>> getAction = controller.Get;
                HttpActionDescriptor actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), getAction.Method);
                yield return new object[] { actionDescriptor, "A list of values." };

                Func<int, string> getIdAction = controller.Get;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), getIdAction.Method);
                yield return new object[] { actionDescriptor, "A value string." };

                Func<string, string> getNameAction = controller.Get;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), getNameAction.Method);
                yield return new object[] { actionDescriptor, "A value identified by name." };

                Func<string, HttpResponseMessage> postAction = controller.Post;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), postAction.Method);
                yield return new object[] { actionDescriptor, "A response." };

                Action<int, string> putAction = controller.Put;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), putAction.Method);
                yield return new object[] { actionDescriptor, null };

                Action<List<Tuple<int, string>>> putCollectionAction = controller.Put;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), putCollectionAction.Method);
                yield return new object[] { actionDescriptor, null };

                Action<int?> deleteAction = controller.Delete;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), deleteAction.Method);
                yield return new object[] { actionDescriptor, null };

                Action<Tuple<int, string>> patchAction = controller.Patch;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), patchAction.Method);
                yield return new object[] { actionDescriptor, null };

                Func<HttpRequestMessage, string> optionsAction = controller.Options;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), optionsAction.Method);
                yield return new object[] { actionDescriptor, "All the options." };

                Func<int, string[]> headAction = controller.HeadNoDocumentation;
                actionDescriptor = new ReflectedHttpActionDescriptor(new HttpControllerDescriptor(), headAction.Method);
                yield return new object[] { actionDescriptor, null };
            }
        }

        [Theory]
        [PropertyData("GetDocumentationForActionResponse_PropertyData")]
        public void GetDocumentationForActionResponse(HttpActionDescriptor actionDescriptor, string expectedString)
        {
            XmlDocumentationProvider provider = new XmlDocumentationProvider("WebApiHelpPage.Test.XML");
            string documentationString = provider.GetResponseDocumentation(actionDescriptor);
            Assert.Equal(expectedString, documentationString);
        }
    }
}


================================================
FILE: test/WebApiHelpPage.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Microsoft.Web.Infrastructure" version="1.0.0.0" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="Newtonsoft.Json" version="13.0.1" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/WebApiHelpPage.VB.Test/WebApiHelpPage.VB.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{41D5691F-2720-44A0-9185-EEFE928D2679}</ProjectGuid>
    <OutputType>Library</OutputType>
    <RootNamespace>WebApiHelpPage</RootNamespace>
    <AssemblyName>WebApiHelpPage.VB.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <DocumentationFile>$(OutputPath)$(AssemblyName).xml</DocumentationFile>
    <NoWarn>1591</NoWarn>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Newtonsoft.Json, Version=13.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Newtonsoft.Json.13.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.ComponentModel.DataAnnotations" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Net.Http" />
    <Reference Include="System.Net.Http.WebRequest" />
    <Reference Include="System.Runtime.Serialization" />
    <Reference Include="System.Web" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="..\WebApiHelpPage.Test\Controllers\UsersController.cs">
      <Link>Controllers\UsersController.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\Controllers\ValuesController.cs">
      <Link>Controllers\ValuesController.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\Helpers\CustomTypes.cs">
      <Link>Helpers\CustomTypes.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\ObjectGeneratorTest.cs">
      <Link>ObjectGeneratorTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\InvalidSampleTest.cs">
      <Link>InvalidSampleTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\HelpPageApiModelTest.cs">
      <Link>HelpPageApiModelTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\TextSampleTest.cs">
      <Link>TextSampleTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\ImageSampleTest.cs">
      <Link>ImageSampleTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\HelpPageAreaRegistrationTest.cs">
      <Link>HelpPageAreaRegistrationTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\HelpPageSampleKeyTest.cs">
      <Link>HelpPageSampleKeyTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\Helpers\ApiDescriptionHelpers.cs">
      <Link>Helpers\ApiDescriptionHelpers.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\HelppageSampleGeneratorTest.cs">
      <Link>HelppageSampleGeneratorTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\HelpControllerTest.cs">
      <Link>HelpControllerTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\XmlDocumentationProviderTest.cs">
      <Link>XmlDocumentationProviderTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\HelpPageConfigurationExtensionsTest.cs">
      <Link>HelpPageConfigurationExtensionsTest.cs</Link>
    </Compile>
    <Compile Include="..\WebApiHelpPage.Test\WebConfigTest.cs">
      <Link>WebConfigTest.cs</Link>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <None Include="..\WebApiHelpPage.Test\packages.config">
      <Link>packages.config</Link>
      <SubType>Designer</SubType>
    </None>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="..\..\src\WebApiHelpPage\VB\Areas\HelpPage\Views\Web.config">
      <Link>TestFiles\Web.config</Link>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Net.Http.Formatting\System.Net.Http.Formatting.csproj">
      <Project>{668e9021-ce84-49d9-98fb-df125a9fcdb0}</Project>
      <Name>System.Net.Http.Formatting</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Helpers\System.Web.Helpers.csproj">
      <Project>{9b7e3740-6161-4548-833c-4bbca43b970e}</Project>
      <Name>System.Web.Helpers</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http.WebHost\System.Web.Http.WebHost.csproj">
      <Project>{a0187bc2-8325-4bb2-8697-7f955cf4173e}</Project>
      <Name>System.Web.Http.WebHost</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Http\System.Web.Http.csproj">
      <Project>{ddc1ce0c-486e-4e35-bb3b-eab61f8f9440}</Project>
      <Name>System.Web.Http</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Mvc\System.Web.Mvc.csproj">
      <Project>{3d3ffd8a-624d-4e9b-954b-e1c105507975}</Project>
      <Name>System.Web.Mvc</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8f18041b-9410-4c36-a9c5-067813df5f31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Deployment\System.Web.WebPages.Deployment.csproj">
      <Project>{22babb60-8f02-4027-affc-acf069954536}</Project>
      <Name>System.Web.WebPages.Deployment</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939b11a-fe4e-4ba1-8ad6-d97741ee314f}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages\System.Web.WebPages.csproj">
      <Project>{76efa9c5-8d7e-4fdf-b710-e20f8b6b00d2}</Project>
      <Name>System.Web.WebPages</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\WebApiHelpPage\VB\WebApiHelpPageVB.vbproj">
      <Project>{22075d5a-e9a1-4e2d-aba7-8e7cbf2a049e}</Project>
      <Name>WebApiHelpPageVB</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{fccc4cb7-baf7-4a57-9f89-e5766fe536c0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

================================================
FILE: test/WebMatrix.Data.Test/App.config
================================================
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <system.data>
    <DbProviderFactories>
      <remove invariant="System.Data.SqlServerCe.4.0"></remove>
      <add name="Microsoft SQL Server Compact Data Provider" invariant="System.Data.SqlServerCe.4.0" description=".NET Framework Data Provider for Microsoft SQL Server Compact" type="System.Data.SqlServerCe.SqlCeProviderFactory, System.Data.SqlServerCe, Version=4.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91"/>
    </DbProviderFactories>
  </system.data>
</configuration>

================================================
FILE: test/WebMatrix.Data.Test/ConfigurationManagerWrapperTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using Microsoft.TestCommon;
using Moq;
using WebMatrix.Data.Test.Mocks;

namespace WebMatrix.Data.Test
{
    public class ConfigurationManagerWrapperTest
    {
        [Fact]
        public void GetConnectionGetsConnectionFromConfig()
        {
            // Arrange            
            var configManager = new ConfigurationManagerWrapper(new Dictionary<string, IDbFileHandler>(), "DataDirectory");
            Func<string, bool> fileExists = path => false;
            Func<string, IConnectionConfiguration> getFromConfig = name => new MockConnectionConfiguration("connection string");

            // Act
            IConnectionConfiguration configuration = configManager.GetConnection("foo", getFromConfig, fileExists);

            // Assert
            Assert.NotNull(configuration);
            Assert.Equal("connection string", configuration.ConnectionString);
        }

        [Fact]
        public void GetConnectionGetsConnectionFromDataDirectoryIfFileWithSupportedExtensionExists()
        {
            // Arrange   
            var mockHandler = new Mock<MockDbFileHandler>();
            mockHandler.Setup(m => m.GetConnectionConfiguration(@"DataDirectory\Bar.foo")).Returns(new MockConnectionConfiguration("some file based connection"));
            var handlers = new Dictionary<string, IDbFileHandler>
            {
                { ".foo", mockHandler.Object }
            };
            var configManager = new ConfigurationManagerWrapper(handlers, "DataDirectory");
            Func<string, bool> fileExists = path => path.Equals(@"DataDirectory\Bar.foo");
            Func<string, IConnectionConfiguration> getFromConfig = name => null;

            // Act
            IConnectionConfiguration configuration = configManager.GetConnection("Bar", getFromConfig, fileExists);

            // Assert
            Assert.NotNull(configuration);
            Assert.Equal("some file based connection", configuration.ConnectionString);
        }

        [Fact]
        public void GetConnectionSdfAndMdfFile_MdfFileWins()
        {
            // Arrange
            var mockSdfHandler = new Mock<MockDbFileHandler>();
            mockSdfHandler.Setup(m => m.GetConnectionConfiguration(@"DataDirectory\Bar.sdf")).Returns(new MockConnectionConfiguration("sdf connection"));
            var mockMdfHandler = new Mock<MockDbFileHandler>();
            mockMdfHandler.Setup(m => m.GetConnectionConfiguration(@"DataDirectory\Bar.mdf")).Returns(new MockConnectionConfiguration("mdf connection"));
            var handlers = new Dictionary<string, IDbFileHandler>
            {
                { ".sdf", mockSdfHandler.Object },
                { ".mdf", mockMdfHandler.Object },
            };
            var configManager = new ConfigurationManagerWrapper(handlers, "DataDirectory");
            Func<string, bool> fileExists = path => path.Equals(@"DataDirectory\Bar.mdf") ||
                                                    path.Equals(@"DataDirectory\Bar.sdf");
            Func<string, IConnectionConfiguration> getFromConfig = name => null;

            // Act
            IConnectionConfiguration configuration = configManager.GetConnection("Bar", getFromConfig, fileExists);

            // Assert
            Assert.NotNull(configuration);
            Assert.Equal("mdf connection", configuration.ConnectionString);
        }

        [Fact]
        public void GetConnectionReturnsNullIfNoConnectionFound()
        {
            // Act
            var configManager = new ConfigurationManagerWrapper(new Dictionary<string, IDbFileHandler>(), "DataDirectory");
            Func<string, bool> fileExists = path => false;
            Func<string, IConnectionConfiguration> getFromConfig = name => null;

            // Act
            IConnectionConfiguration configuration = configManager.GetConnection("test", getFromConfig, fileExists);

            // Assert
            Assert.Null(configuration);
        }
    }
}


================================================
FILE: test/WebMatrix.Data.Test/DatabaseTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Data.Common;
using Microsoft.TestCommon;
using Moq;
using WebMatrix.Data.Test.Mocks;

namespace WebMatrix.Data.Test
{
    public class DatabaseTest
    {
        [Fact]
        public void OpenWithNullConnectionStringNameThrowsException()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => Database.Open(null), "name");
        }

        [Fact]
        public void OpenConnectionStringWithNullConnectionStringThrowsException()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => Database.OpenConnectionString(null), "connectionString");
        }

        [Fact]
        public void OpenConnectionStringWithEmptyConnectionStringThrowsException()
        {
            Assert.ThrowsArgumentNullOrEmptyString(() => Database.OpenConnectionString(String.Empty), "connectionString");
        }

        [Fact]
        public void OpenNamedConnectionUsesConnectionStringFromConfigurationIfExists()
        {
            // Arrange
            MockConfigurationManager mockConfigurationManager = new MockConfigurationManager();
            Mock<DbConnection> mockConnection = new Mock<DbConnection>();
            mockConnection.Setup(m => m.ConnectionString).Returns("connection string");
            Mock<MockDbProviderFactory> mockProviderFactory = new Mock<MockDbProviderFactory>();
            mockProviderFactory.Setup(m => m.CreateConnection("connection string")).Returns(mockConnection.Object);
            mockConfigurationManager.AddConnection("foo", new ConnectionConfiguration(mockProviderFactory.Object, "connection string"));

            // Act            
            Database db = Database.OpenNamedConnection("foo", mockConfigurationManager);

            // Assert
            Assert.Equal("connection string", db.Connection.ConnectionString);
        }

        [Fact]
        public void OpenNamedConnectionThrowsIfNoConnectionFound()
        {
            // Arrange
            IConfigurationManager mockConfigurationManager = new MockConfigurationManager();

            // Act & Assert
            Assert.Throws<InvalidOperationException>(() => Database.OpenNamedConnection("foo", mockConfigurationManager), "Connection string \"foo\" was not found.");
        }

        [Fact]
        public void GetConnectionConfigurationGetConnectionForFileHandlersIfRegistered()
        {
            // Arrange
            var mockHandler = new Mock<MockDbFileHandler>();
            mockHandler.Setup(m => m.GetConnectionConfiguration("filename.foo")).Returns(new MockConnectionConfiguration("some file based connection"));
            var handlers = new Dictionary<string, IDbFileHandler>
            {
                { ".foo", mockHandler.Object }
            };

            // Act
            IConnectionConfiguration configuration = Database.GetConnectionConfiguration("filename.foo", handlers);

            // Assert
            Assert.NotNull(configuration);
            Assert.Equal("some file based connection", configuration.ConnectionString);
        }

        [Fact]
        public void GetConnectionThrowsIfNoHandlersRegisteredForExtension()
        {
            // Arrange
            var handlers = new Dictionary<string, IDbFileHandler>();

            // Act
            Assert.Throws<InvalidOperationException>(() => Database.GetConnectionConfiguration("filename.foo", handlers), "Unable to determine the provider for the database file \"filename.foo\".");
        }
    }
}


================================================
FILE: test/WebMatrix.Data.Test/DynamicRecordTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using System.Data;
using System.Linq;
using Microsoft.TestCommon;
using Moq;

namespace WebMatrix.Data.Test
{
    public class DynamicRecordTest
    {
        [Fact]
        public void GetFieldValueByNameAccessesUnderlyingRecordForValue()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            mockRecord.SetupGet(m => m["A"]).Returns(1);
            mockRecord.SetupGet(m => m["B"]).Returns(2);

            dynamic record = new DynamicRecord(new[] { "A", "B" }, mockRecord.Object);

            // Assert
            Assert.Equal(1, record.A);
            Assert.Equal(2, record.B);
        }

        [Fact]
        public void GetFieldValueByIndexAccessesUnderlyingRecordForValue()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            mockRecord.SetupGet(m => m[0]).Returns(1);
            mockRecord.SetupGet(m => m[1]).Returns(2);

            dynamic record = new DynamicRecord(new[] { "A", "B" }, mockRecord.Object);

            // Assert
            Assert.Equal(1, record[0]);
            Assert.Equal(2, record[1]);
        }

        [Fact]
        public void GetFieldValueByNameReturnsNullIfValueIsDbNull()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            mockRecord.SetupGet(m => m["A"]).Returns(DBNull.Value);

            dynamic record = new DynamicRecord(new[] { "A" }, mockRecord.Object);

            // Assert
            Assert.Null(record.A);
        }

        [Fact]
        public void GetFieldValueByIndexReturnsNullIfValueIsDbNull()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            mockRecord.SetupGet(m => m[0]).Returns(DBNull.Value);

            dynamic record = new DynamicRecord(new[] { "A" }, mockRecord.Object);

            // Assert
            Assert.Null(record[0]);
        }

        [Fact]
        public void GetInvalidFieldValueThrows()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            dynamic record = new DynamicRecord(Enumerable.Empty<string>(), mockRecord.Object);

            // Assert
            Assert.Throws<InvalidOperationException>(() => { var value = record.C; }, "Invalid column name \"C\".");
        }

        [Fact]
        public void VerfiyCustomTypeDescriptorMethods()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            mockRecord.SetupGet(m => m["A"]).Returns(1);
            mockRecord.SetupGet(m => m["B"]).Returns(2);

            // Act
            ICustomTypeDescriptor record = new DynamicRecord(new[] { "A", "B" }, mockRecord.Object);

            // Assert
            Assert.Equal(AttributeCollection.Empty, record.GetAttributes());
            Assert.Null(record.GetClassName());
            Assert.Null(record.GetConverter());
            Assert.Null(record.GetDefaultEvent());
            Assert.Null(record.GetComponentName());
            Assert.Null(record.GetDefaultProperty());
            Assert.Null(record.GetEditor(null));
            Assert.Equal(EventDescriptorCollection.Empty, record.GetEvents());
            Assert.Equal(EventDescriptorCollection.Empty, record.GetEvents(null));
            Assert.Same(record, record.GetPropertyOwner(null));
            Assert.Equal(2, record.GetProperties().Count);
            Assert.Equal(2, record.GetProperties(null).Count);
            Assert.NotNull(record.GetProperties()["A"]);
            Assert.NotNull(record.GetProperties()["B"]);
        }

        [Fact]
        public void VerifyPropertyDescriptorProperties()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            mockRecord.SetupGet(m => m["A"]).Returns(1);
            mockRecord.Setup(m => m.GetOrdinal("A")).Returns(0);
            mockRecord.Setup(m => m.GetFieldType(0)).Returns(typeof(string));

            // Act
            ICustomTypeDescriptor record = new DynamicRecord(new[] { "A" }, mockRecord.Object);

            // Assert
            var aDescriptor = record.GetProperties().Find("A", ignoreCase: false);

            Assert.NotNull(aDescriptor);
            Assert.Null(aDescriptor.GetValue(null));
            Assert.Equal(1, aDescriptor.GetValue(record));
            Assert.True(aDescriptor.IsReadOnly);
            Assert.Equal(typeof(string), aDescriptor.PropertyType);
            Assert.Equal(typeof(DynamicRecord), aDescriptor.ComponentType);
            Assert.False(aDescriptor.ShouldSerializeValue(record));
            Assert.False(aDescriptor.CanResetValue(record));
        }

        [Fact]
        public void SetAndResetValueOnPropertyDescriptorThrows()
        {
            // Arrange
            var mockRecord = new Mock<IDataRecord>();
            mockRecord.SetupGet(m => m["A"]).Returns(1);

            // Act
            ICustomTypeDescriptor record = new DynamicRecord(new[] { "A" }, mockRecord.Object);

            // Assert
            var aDescriptor = record.GetProperties().Find("A", ignoreCase: false);
            Assert.NotNull(aDescriptor);
            Assert.Throws<InvalidOperationException>(() => aDescriptor.SetValue(record, 1), "Unable to modify the value of column \"A\" because the record is read only.");
            Assert.Throws<InvalidOperationException>(() => aDescriptor.ResetValue(record), "Unable to modify the value of column \"A\" because the record is read only.");
        }
    }
}


================================================
FILE: test/WebMatrix.Data.Test/FileHandlerTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.TestCommon;

namespace WebMatrix.Data.Test
{
    public class FileHandlerTest
    {
        [Fact]
        public void SqlCeFileHandlerReturnsDataDirectoryRelativeConnectionStringIfPathIsNotRooted()
        {
            // Act
            string connectionString = SqlCeDbFileHandler.GetConnectionString("foo.sdf");

            // Assert
            Assert.NotNull(connectionString);
            Assert.Equal(@"Data Source=|DataDirectory|\foo.sdf;File Access Retry Timeout=10", connectionString);
        }

        [Fact]
        public void SqlCeFileHandlerReturnsFullPathConnectionStringIfPathIsNotRooted()
        {
            // Act
            string connectionString = SqlCeDbFileHandler.GetConnectionString(@"c:\foo.sdf");

            // Assert
            Assert.NotNull(connectionString);
            Assert.Equal(@"Data Source=c:\foo.sdf;File Access Retry Timeout=10", connectionString);
        }

        [Fact]
        public void SqlServerFileHandlerReturnsDataDirectoryRelativeConnectionStringIfPathIsNotRooted()
        {
            // Act           
            string connectionString = SqlServerDbFileHandler.GetConnectionString("foo.mdf", "datadir");

            // Assert
            Assert.NotNull(connectionString);
            Assert.Equal(@"Data Source=.\SQLEXPRESS;AttachDbFilename=|DataDirectory|\foo.mdf;Initial Catalog=datadir\foo.mdf;Integrated Security=True;User Instance=True;MultipleActiveResultSets=True",
                         connectionString);
        }

        [Fact]
        public void SqlServerFileHandlerReturnsFullPathConnectionStringIfPathIsNotRooted()
        {
            // Act
            string connectionString = SqlServerDbFileHandler.GetConnectionString(@"c:\foo.mdf", "datadir");

            // Assert
            Assert.NotNull(connectionString);
            Assert.Equal(@"Data Source=.\SQLEXPRESS;AttachDbFilename=c:\foo.mdf;Initial Catalog=c:\foo.mdf;Integrated Security=True;User Instance=True;MultipleActiveResultSets=True", connectionString);
        }
    }
}


================================================
FILE: test/WebMatrix.Data.Test/Mocks/MockConfigurationManager.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace WebMatrix.Data.Test.Mocks
{
    internal class MockConfigurationManager : IConfigurationManager
    {
        private Dictionary<string, IConnectionConfiguration> _connectionStrings = new Dictionary<string, IConnectionConfiguration>();

        public MockConfigurationManager()
        {
            AppSettings = new Dictionary<string, string>();
        }

        public IDictionary<string, string> AppSettings { get; private set; }

        public void AddConnection(string name, IConnectionConfiguration configuration)
        {
            _connectionStrings.Add(name, configuration);
        }

        public IConnectionConfiguration GetConnection(string name)
        {
            IConnectionConfiguration configuration;
            _connectionStrings.TryGetValue(name, out configuration);
            return configuration;
        }
    }
}


================================================
FILE: test/WebMatrix.Data.Test/Mocks/MockConnectionConfiguration.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace WebMatrix.Data.Test.Mocks
{
    public class MockConnectionConfiguration : IConnectionConfiguration
    {
        public MockConnectionConfiguration(string connectionString)
        {
            ConnectionString = connectionString;
        }

        public string ConnectionString { get; private set; }

        string IConnectionConfiguration.ConnectionString
        {
            get { return ConnectionString; }
        }

        IDbProviderFactory IConnectionConfiguration.ProviderFactory
        {
            get { return null; }
        }
    }
}


================================================
FILE: test/WebMatrix.Data.Test/Mocks/MockDbFileHandler.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

namespace WebMatrix.Data.Test.Mocks
{
    public abstract class MockDbFileHandler : IDbFileHandler
    {
        IConnectionConfiguration IDbFileHandler.GetConnectionConfiguration(string fileName)
        {
            return GetConnectionConfiguration(fileName);
        }

        public abstract MockConnectionConfiguration GetConnectionConfiguration(string fileName);
    }
}


================================================
FILE: test/WebMatrix.Data.Test/Mocks/MockDbProviderFactory.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Data.Common;

namespace WebMatrix.Data.Test.Mocks
{
    // Needs to be public for Moq to work
    public abstract class MockDbProviderFactory : IDbProviderFactory
    {
        public abstract DbConnection CreateConnection(string connectionString);
    }
}


================================================
FILE: test/WebMatrix.Data.Test/WebMatrix.Data.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{E2D008A9-4D1D-4F6B-8325-4ED717D6EA0A}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>WebMatrix.Data.Test</RootNamespace>
    <AssemblyName>WebMatrix.Data.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Configuration" />
    <Reference Include="System.Core">
      <RequiredTargetFramework>3.5</RequiredTargetFramework>
    </Reference>
    <Reference Include="System.Data" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
      <Private>True</Private>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <CodeAnalysisDependentAssemblyPaths Condition=" '$(VS100COMNTOOLS)' != '' " Include="$(VS100COMNTOOLS)..\IDE\PrivateAssemblies">
      <Visible>False</Visible>
    </CodeAnalysisDependentAssemblyPaths>
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\WebMatrix.Data\WebMatrix.Data.csproj">
      <Project>{4D39BAAF-8A96-473E-AB79-C8A341885137}</Project>
      <Name>WebMatrix.Data</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="ConfigurationManagerWrapperTest.cs" />
    <Compile Include="DynamicRecordTest.cs" />
    <Compile Include="FileHandlerTest.cs" />
    <Compile Include="Mocks\MockConfigurationManager.cs" />
    <Compile Include="Mocks\MockConnectionConfiguration.cs" />
    <Compile Include="Mocks\MockDbFileHandler.cs" />
    <Compile Include="Mocks\MockDbProviderFactory.cs" />
    <Compile Include="DatabaseTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/WebMatrix.Data.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: test/WebMatrix.WebData.Test/MockDatabase.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;

namespace WebMatrix.WebData.Test
{
    public abstract class MockDatabase : IDatabase
    {
        public abstract dynamic QuerySingle(string commandText, params object[] args);

        public abstract IEnumerable<dynamic> Query(string commandText, params object[] parameters);

        public abstract dynamic QueryValue(string commandText, params object[] parameters);

        public abstract int Execute(string commandText, params object[] args);

        public void Dispose()
        {
            // Do nothing.
        }
    }
}


================================================
FILE: test/WebMatrix.WebData.Test/PreApplicationStartCodeTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Configuration;
using System.Linq;
using System.Reflection;
using System.Web.Security;
using System.Web.WebPages.Razor;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;

namespace WebMatrix.WebData.Test
{
    public class PreApplicationStartCodeTest
    {
        [Fact]
        public void StartRegistersRazorNamespaces()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                AppDomainUtils.SetPreAppStartStage();
                PreApplicationStartCode.Start();
                // Call a second time to ensure multiple calls do not cause issues
                PreApplicationStartCode.Start();

                // Verify namespaces
                var imports = WebPageRazorHost.GetGlobalImports();
                Assert.Contains(imports, ns => ns.Equals("WebMatrix.Data"));
                Assert.Contains(imports, ns => ns.Equals("WebMatrix.WebData"));
            });
        }

        [Fact]
        public void StartInitializesFormsAuthByDefault()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                AppDomainUtils.SetPreAppStartStage();
                PreApplicationStartCode.Start();

                string formsAuthLoginUrl = (string)typeof(FormsAuthentication).GetField("_LoginUrl", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
                Assert.Equal(FormsAuthenticationSettings.DefaultLoginUrl, formsAuthLoginUrl);
            });
        }

        [Fact]
        public void StartDoesNotInitializeFormsAuthWhenDisabled()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                AppDomainUtils.SetPreAppStartStage();
                ConfigurationManager.AppSettings[WebSecurity.EnableSimpleMembershipKey] = "False";
                PreApplicationStartCode.Start();

                string formsAuthLoginUrl = (string)typeof(FormsAuthentication).GetField("_LoginUrl", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
                Assert.Null(formsAuthLoginUrl);
            });
        }

        [Fact]
        public void StartInitializesSimpleMembershipByDefault()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                AppDomainUtils.SetPreAppStartStage();
                PreApplicationStartCode.Start();

                // Verify simple membership
                var providers = Membership.Providers;
                Assert.NotEmpty(providers.OfType<SimpleMembershipProvider>());
                Assert.True(Roles.Enabled);
            });
        }

        [Fact]
        public void StartDoesNotInitializeSimpleMembershipWhenDisabled()
        {
            AppDomainUtils.RunInSeparateAppDomain(() =>
            {
                AppDomainUtils.SetPreAppStartStage();
                ConfigurationManager.AppSettings[WebSecurity.EnableSimpleMembershipKey] = "False";
                PreApplicationStartCode.Start();

                // Verify simple membership
                var providers = Membership.Providers;
                Assert.Empty(providers.OfType<SimpleMembershipProvider>());
                Assert.False(Roles.Enabled);
            });
        }

        [Fact]
        public void TestPreAppStartClass()
        {
            PreAppStartTestHelper.TestPreAppStartClass(typeof(PreApplicationStartCode));
        }
    }
}


================================================
FILE: test/WebMatrix.WebData.Test/SimpleMembershipProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using System.Data;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using Microsoft.TestCommon;
using Moq;
using WebMatrix.Data;

namespace WebMatrix.WebData.Test
{
    public class SimpleMembershipProviderTest
    {
        [Fact]
        public void ConfirmAccountReturnsFalseIfNoRecordExistsForToken()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
                .Returns(Enumerable.Empty<DynamicRecord>());
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("foo");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ConfirmAccountReturnsFalseIfConfirmationTokenDoesNotMatchInCase()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            DynamicRecord record = GetRecord(98, "Foo");
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
                .Returns(new[] { record });
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("foo");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ConfirmAccountReturnsFalseIfNoConfirmationTokenFromMultipleListMatchesInCase()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            DynamicRecord recordA = GetRecord(98, "Foo");
            DynamicRecord recordB = GetRecord(99, "fOo");
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
                .Returns(new[] { recordA, recordB });
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("foo");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ConfirmAccountUpdatesIsConfirmedFieldIfConfirmationTokenMatches()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            DynamicRecord record = GetRecord(100, "foo");
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
                .Returns(new[] { record }).Verifiable();
            database.Setup(d => d.Execute("UPDATE webpages_Membership SET [IsConfirmed] = 1 WHERE [UserId] = @0", 100)).Returns(1).Verifiable();
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("foo");

            // Assert
            Assert.True(result);
            database.Verify();
        }

        [Fact]
        public void ConfirmAccountUpdatesIsConfirmedFieldIfAnyOneOfReturnRecordConfirmationTokenMatches()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            DynamicRecord recordA = GetRecord(100, "Foo");
            DynamicRecord recordB = GetRecord(101, "foo");
            DynamicRecord recordC = GetRecord(102, "fOo");
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.Query("SELECT [UserId], [ConfirmationToken] FROM webpages_Membership WHERE [ConfirmationToken] = @0", "foo"))
                .Returns(new[] { recordA, recordB, recordC }).Verifiable();
            database.Setup(d => d.Execute("UPDATE webpages_Membership SET [IsConfirmed] = 1 WHERE [UserId] = @0", 101)).Returns(1).Verifiable();
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object);

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("foo");

            // Assert
            Assert.True(result);
            database.Verify();
        }

        [Fact]
        public void ConfirmAccountWithUserNameReturnsFalseIfNoRecordExistsForToken()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.QuerySingle("SELECT m.[UserId], m.[ConfirmationToken] FROM webpages_Membership m JOIN [Users] u ON m.[UserId] = u.[UserId] WHERE m.[ConfirmationToken] = @0 AND u.[UserName] = @1", "foo", "user12")).Returns(null);
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object) { UserIdColumn = "UserId", UserNameColumn = "UserName", UserTableName = "Users" };

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("user12", "foo");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ConfirmAccountWithUserNameReturnsFalseIfConfirmationTokenDoesNotMatchInCase()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            DynamicRecord record = GetRecord(98, "Foo");
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.QuerySingle("SELECT m.[UserId], m.[ConfirmationToken] FROM webpages_Membership m JOIN [Users_bkp2_1] u ON m.[UserId] = u.[wishlist_site_real_user_id] WHERE m.[ConfirmationToken] = @0 AND u.[wishlist_site_real_user_name] = @1", "foo", "user13")).Returns(record);
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object) { UserIdColumn = "wishlist_site_real_user_id", UserNameColumn = "wishlist_site_real_user_name", UserTableName = "Users_bkp2_1" };

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("user13", "foo");

            // Assert
            Assert.False(result);
        }

        [Fact]
        public void ConfirmAccountWithUserNameUpdatesIsConfirmedFieldIfConfirmationTokenMatches()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            DynamicRecord record = GetRecord(100, "foo");
            database.As<IDisposable>().Setup(d => d.Dispose());
            database.Setup(d => d.QuerySingle("SELECT m.[UserId], m.[ConfirmationToken] FROM webpages_Membership m JOIN [Users] u ON m.[UserId] = u.[Id] WHERE m.[ConfirmationToken] = @0 AND u.[UserName] = @1", "foo", "user14"))
                .Returns(record).Verifiable();
            database.Setup(d => d.Execute("UPDATE webpages_Membership SET [IsConfirmed] = 1 WHERE [UserId] = @0", 100)).Returns(1).Verifiable();
            var simpleMembershipProvider = new TestSimpleMembershipProvider(database.Object) { UserTableName = "Users", UserIdColumn = "Id", UserNameColumn = "UserName" };

            // Act
            bool result = simpleMembershipProvider.ConfirmAccount("user14", "foo");

            // Assert
            Assert.True(result);
            database.Verify();
        }

        [Fact]
        public void GenerateTokenHtmlEncodesValues()
        {
            // Arrange
            var generator = new Mock<RandomNumberGenerator>(MockBehavior.Strict);
            var generatedBytes = Encoding.Default.GetBytes("|aÿx§#½oÿ↨îA8Eµ");
            generator.Setup(g => g.GetBytes(It.IsAny<byte[]>())).Callback((byte[] array) => Array.Copy(generatedBytes, array, generatedBytes.Length));

            // Act
            var result = SimpleMembershipProvider.GenerateToken(generator.Object);

            // Assert
            Assert.Equal("fGH/eKcjvW//P+5BOEW1", Convert.ToBase64String(generatedBytes));
            Assert.Equal("fGH_eKcjvW__P-5BOEW1AA2", result);
        }

        [Fact]
        public void GetUserId_WithCaseNormalization()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            var expectedQuery = @"SELECT userId FROM users WHERE (UPPER(userName) = UPPER(@0))";
            database.Setup(d => d.QueryValue(expectedQuery, "zeke")).Returns(999);

            // Act
            var result = SimpleMembershipProvider.GetUserId(
                database.Object,
                "users",
                "userName",
                "userId",
                SimpleMembershipProviderCasingBehavior.NormalizeCasing,
                "zeke");

            // Assert
            Assert.Equal(999, result);
        }

        [Fact]
        public void GetUserId_WithoutCaseNormalization()
        {
            // Arrange
            var database = new Mock<MockDatabase>(MockBehavior.Strict);
            var expectedQuery = @"SELECT userId FROM users WHERE (userName = @0)";
            database.Setup(d => d.QueryValue(expectedQuery, "zeke")).Returns(999);

            // Act
            var result = SimpleMembershipProvider.GetUserId(
                database.Object,
                "users",
                "userName",
                "userId",
                SimpleMembershipProviderCasingBehavior.RelyOnDatabaseCollation,
                "zeke");

            // Assert
            Assert.Equal(999, result);
        }

        [Theory]
        [ReplaceCulture]
        [InlineData(-1, false)]
        [InlineData(0, true)]
        [InlineData(1, true)]
        [InlineData(2, false)]
        public void SimpleMembershipProvider_CasingBehavior_ValidatesRange(int value, bool isValid)
        {
            // Arrange
            var provider = new SimpleMembershipProvider();

            var message =
                "The value of argument 'value' (" + value + ") is invalid for Enum type " +
                "'SimpleMembershipProviderCasingBehavior'." + Environment.NewLine +
                "Parameter name: value";

            // Act
            Exception exception = null;

            try
            {
                provider.CasingBehavior = (SimpleMembershipProviderCasingBehavior)value;
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            // Assert
            if (isValid)
            {
                Assert.Equal((SimpleMembershipProviderCasingBehavior)value, provider.CasingBehavior);
            }
            else
            {
                Assert.NotNull(exception);
                Assert.IsAssignableFrom<InvalidEnumArgumentException>(exception);
                Assert.Equal(message, exception.Message);
            }
        }

        private static DynamicRecord GetRecord(int userId, string confirmationToken)
        {
            var data = new Mock<IDataRecord>(MockBehavior.Strict);
            data.Setup(c => c[0]).Returns(userId);
            data.Setup(c => c[1]).Returns(confirmationToken);
            return new DynamicRecord(new[] { "UserId", "ConfirmationToken" }, data.Object);
        }

        private class TestSimpleMembershipProvider : SimpleMembershipProvider
        {
            private readonly IDatabase _database;

            public TestSimpleMembershipProvider(IDatabase database)
            {
                _database = database;
            }

            internal override IDatabase ConnectToDatabase()
            {
                return _database;
            }

            internal override void VerifyInitialized()
            {
                // Do nothing.
            }
        }
    }
}


================================================
FILE: test/WebMatrix.WebData.Test/SimpleRoleProviderTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.ComponentModel;
using Microsoft.TestCommon;

namespace WebMatrix.WebData.Test
{
    public class SimpleRoleProviderTest
    {
        [Theory]
        [ReplaceCulture]
        [InlineData(-1, false)]
        [InlineData(0, true)]
        [InlineData(1, true)]
        [InlineData(2, false)]
        public void SimpleRoleProvider_CasingBehavior_ValidatesRange(int value, bool isValid)
        {
            // Arrange
            var provider = new SimpleRoleProvider();

            var message =
                "The value of argument 'value' (" + value + ") is invalid for Enum type " +
                "'SimpleMembershipProviderCasingBehavior'." + Environment.NewLine +
                "Parameter name: value";

            // Act
            Exception exception = null;

            try
            {
                provider.CasingBehavior = (SimpleMembershipProviderCasingBehavior)value;
            }
            catch (Exception ex)
            {
                exception = ex;
            }

            // Assert
            if (isValid)
            {
                Assert.Equal((SimpleMembershipProviderCasingBehavior)value, provider.CasingBehavior);
            }
            else
            {
                Assert.NotNull(exception);
                Assert.IsAssignableFrom<InvalidEnumArgumentException>(exception);
                Assert.Equal(message, exception.Message);
            }
        }
    }
}


================================================
FILE: test/WebMatrix.WebData.Test/WebMatrix.WebData.Test.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import Project="..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props" Condition="Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" />
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.props" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" />
  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory),Runtime.sln))\tools\WebStack.settings.targets" />
  <PropertyGroup>
    <ProjectGuid>{CD48EB41-92A5-4628-A0F7-6A43DF58827E}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>WebMatrix.WebData.Test</RootNamespace>
    <AssemblyName>WebMatrix.WebData.Test</AssemblyName>
    <OutputPath>..\..\bin\$(Configuration)\Test\</OutputPath>
    <NuGetPackageImportStamp>
    </NuGetPackageImportStamp>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="Castle.Core, Version=5.0.0.0, Culture=neutral, PublicKeyToken=407dd0808d44fbdc, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Castle.Core.5.1.1\lib\net462\Castle.Core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="Moq, Version=4.18.0.0, Culture=neutral, PublicKeyToken=69f491c39445e920, processorArchitecture=MSIL">
      <HintPath>..\..\packages\Moq.4.18.4\lib\net462\Moq.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.configuration" />
    <Reference Include="System.Core" />
    <Reference Include="System.Web" />
    <Reference Include="System.Web.ApplicationServices" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="xunit.abstractions, Version=2.0.0.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.abstractions.2.0.3\lib\net35\xunit.abstractions.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.assert, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.assert.2.4.2\lib\netstandard1.1\xunit.assert.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.core, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.core.2.4.2\lib\net452\xunit.core.dll</HintPath>
      <Private>True</Private>
    </Reference>
    <Reference Include="xunit.execution.desktop, Version=2.4.2.0, Culture=neutral, PublicKeyToken=8d05b1bb7a6fdb6c, processorArchitecture=MSIL">
      <HintPath>..\..\packages\xunit.extensibility.execution.2.4.2\lib\net452\xunit.execution.desktop.dll</HintPath>
    </Reference>
  </ItemGroup>
  <ItemGroup>
    <Compile Include="MockDatabase.cs" />
    <Compile Include="PreApplicationStartCodeTest.cs" />
    <Compile Include="SimpleMembershipProviderTest.cs" />
    <Compile Include="SimpleRoleProviderTest.cs" />
    <Compile Include="WebSecurityTest.cs" />
  </ItemGroup>
  <ItemGroup>
    <ProjectReference Include="..\..\src\System.Web.Razor\System.Web.Razor.csproj">
      <Project>{8F18041B-9410-4C36-A9C5-067813DF5F31}</Project>
      <Name>System.Web.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\System.Web.WebPages.Razor\System.Web.WebPages.Razor.csproj">
      <Project>{0939B11A-FE4E-4BA1-8AD6-D97741EE314F}</Project>
      <Name>System.Web.WebPages.Razor</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\WebMatrix.Data\WebMatrix.Data.csproj">
      <Project>{4D39BAAF-8A96-473E-AB79-C8A341885137}</Project>
      <Name>WebMatrix.Data</Name>
    </ProjectReference>
    <ProjectReference Include="..\..\src\WebMatrix.WebData\WebMatrix.WebData.csproj">
      <Project>{55A15F40-1435-4248-A7F2-2A146BB83586}</Project>
      <Name>WebMatrix.WebData</Name>
    </ProjectReference>
    <ProjectReference Include="..\Microsoft.TestCommon\Microsoft.TestCommon.csproj">
      <Project>{FCCC4CB7-BAF7-4A57-9F89-E5766FE536C0}</Project>
      <Name>Microsoft.TestCommon</Name>
    </ProjectReference>
  </ItemGroup>
  <ItemGroup>
    <None Include="packages.config" />
  </ItemGroup>
  <ItemGroup>
    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
  </ItemGroup>
  <ItemGroup>
    <Analyzer Include="..\..\packages\xunit.analyzers.1.1.0\analyzers\dotnet\cs\xunit.analyzers.dll" />
  </ItemGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
    <PropertyGroup>
      <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
    </PropertyGroup>
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.props'))" />
    <Error Condition="!Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.core.2.4.2\build\xunit.core.targets'))" />
    <Error Condition="!Exists('..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props')" Text="$([System.String]::Format('$(ErrorText)', '..\..\packages\xunit.runner.visualstudio.2.4.5\build\net462\xunit.runner.visualstudio.props'))" />
  </Target>
  <Import Project="..\..\packages\xunit.core.2.4.2\build\xunit.core.targets" Condition="Exists('..\..\packages\xunit.core.2.4.2\build\xunit.core.targets')" />
</Project>

================================================
FILE: test/WebMatrix.WebData.Test/WebSecurityTest.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Collections.Generic;
using System.Configuration.Provider;
using System.Reflection;
using System.Web.Security;
using System.Web.WebPages.TestUtils;
using Microsoft.TestCommon;
using Moq;

namespace WebMatrix.WebData.Test
{
    public class WebSecurityTest
    {
        [Fact]
        public void CreateUserAndAccount_WillAcceptBothObjectsAndDictionariesForExtendedParameters()
        {
            // since it is a static helper - you gotta love 'em
            AppDomainUtils.RunInSeparateAppDomain(() =>
                {
                    // we need that in order to make sure the Membership static class is initialized correctly
                    var discard = Membership.Provider as ProviderBase;

                    // Arrange
                    var providerMock = new Mock<ExtendedMembershipProvider>();
                    providerMock.Setup(
                        p => p.CreateUserAndAccount(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<bool>(), It.IsAny<IDictionary<string, object>>()))
                                .Returns((string username, string password, bool requireConfirmation, IDictionary<string, object> values) => "foo = " + values["foo"]);
                    typeof(Membership).GetField("s_Provider", BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, providerMock.Object);

                    // Act
                    var resultWithObject = WebSecurity.CreateUserAndAccount("name", "pass", new { foo = "bar" });
                    var resultWithDictionary = WebSecurity.CreateUserAndAccount("name", "pass", new Dictionary<string, object> { { "foo", "baz" } });

                    // Assert
                    Assert.Equal("foo = bar", resultWithObject);
                    Assert.Equal("foo = baz", resultWithDictionary);
                });
        }

        [Fact]
        public void VerifyExtendedMembershipProviderMethodsThrowWithInvalidProvider()
        {
            const string errorString = "To call this method, the \"Membership.Provider\" property must be an instance of \"ExtendedMembershipProvider\".";
            Assert.Throws<InvalidOperationException>(() => WebSecurity.ConfirmAccount(""), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.GeneratePasswordResetToken(""), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetUserIdFromPasswordResetToken(""), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.ResetPassword("", "whatever"), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.CreateUserAndAccount("", "whatever"), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.CreateAccount("", "whatever"), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.IsConfirmed("whatever"), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetPasswordFailuresSinceLastSuccess("whatever"), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetCreateDate("whatever"), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetLastPasswordFailureDate("whatever"), errorString);
            Assert.Throws<InvalidOperationException>(() => WebSecurity.GetPasswordChangedDate("whatever"), errorString);
        }
    }
}


================================================
FILE: test/WebMatrix.WebData.Test/packages.config
================================================
<?xml version="1.0" encoding="utf-8"?>
<packages>
  <package id="Castle.Core" version="5.1.1" targetFramework="net462" />
  <package id="Moq" version="4.18.4" targetFramework="net462" />
  <package id="xunit" version="2.4.2" targetFramework="net462" />
  <package id="xunit.abstractions" version="2.0.3" targetFramework="net462" />
  <package id="xunit.analyzers" version="1.1.0" targetFramework="net462" />
  <package id="xunit.assert" version="2.4.2" targetFramework="net462" />
  <package id="xunit.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.core" version="2.4.2" targetFramework="net462" />
  <package id="xunit.extensibility.execution" version="2.4.2" targetFramework="net462" />
  <package id="xunit.runner.visualstudio" version="2.4.5" targetFramework="net462" developmentDependency="true" />
</packages>

================================================
FILE: tools/SkipStrongNames.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<assemblies defaultPublicKeyToken="31bf3856ad364e35">
  <!-- Production assemblies -->
  <assembly name="Microsoft.AspNet.Facebook"/>
  <assembly name="System.Web.Cors"/>
  <assembly name="Microsoft.Web.Helpers"/>
  <assembly name="Microsoft.Web.Http.Data"/>
  <assembly name="Microsoft.Web.Http.Data.EntityFramework"/>
  <assembly name="Microsoft.Web.Http.Data.Helpers"/>
  <assembly name="Microsoft.Web.WebPages.OAuth"/>
  <assembly name="System.Json"/>
  <assembly name="System.Net.Http.Formatting"/>
  <assembly name="System.Web.Helpers"/>
  <assembly name="System.Web.Http"/>
  <assembly name="System.Web.Http.Common"/>
  <assembly name="System.Web.Http.Cors"/>
  <assembly name="System.Web.Http.OData"/>
  <assembly name="System.Web.Http.Owin"/>
  <assembly name="System.Web.Http.SelfHost"/>
  <assembly name="System.Web.Http.SignalR"/>
  <assembly name="System.Web.Http.Tracing"/>
  <assembly name="System.Web.Http.WebHost"/>
  <assembly name="System.Web.Mvc"/>
  <assembly name="System.Web.OData"/>
  <assembly name="System.Web.Razor"/>
  <assembly name="System.Web.WebPages"/>
  <assembly name="System.Web.WebPages.Administration"/>
  <assembly name="System.Web.WebPages.Deployment"/>
  <assembly name="System.Web.WebPages.Razor"/>
  <assembly name="WebApiHelpPage"/>
  <assembly name="WebApiHelpPageVB"/>
  <assembly name="WebMatrix.Data"/>
  <assembly name="WebMatrix.WebData"/>

  <!-- Unit test assemblies and helpers -->
  <assembly name="Microsoft.AspNet.Facebook.Test"/>
  <assembly name="Microsoft.TestCommon"/>
  <assembly name="Microsoft.Web.Helpers.Test"/>
  <assembly name="Microsoft.Web.Http.Data.Test"/>
  <assembly name="Microsoft.Web.WebPages.OAuth.Test"/>
  <assembly name="System.Json.Test"/>
  <assembly name="System.Json.Test.Integration"/>
  <assembly name="System.Net.Http.Formatting.Test"/>
  <assembly name="System.Net.Http.Formatting.ns1_3.Test"/>
  <assembly name="System.Net.Http.Formatting.ns2_0.Test"/>
  <assembly name="System.Net.Http.Formatting.Test.Integration"/>
  <assembly name="System.Web.Cors.Test"/>
  <assembly name="System.Web.Helpers.Test"/>
  <assembly name="System.Web.Http.Common.Test"/>
  <assembly name="System.Web.Http.Cors.Test"/>
  <assembly name="System.Web.Http.Integration.Test"/>
  <assembly name="System.Web.Http.OData.Test"/>
  <assembly name="System.Web.Http.Owin.Test"/>
  <assembly name="System.Web.Http.SelfHost.Test"/>
  <assembly name="System.Web.Http.SignalR.Test"/>
  <assembly name="System.Web.Http.Test"/>
  <assembly name="System.Web.Http.Tracing.Test"/>
  <assembly name="System.Web.Http.WebHost.Test"/>
  <assembly name="System.Web.Mvc.Test"/>
  <assembly name="System.Web.OData.Test"/>
  <assembly name="System.Web.Razor.Test"/>
  <assembly name="System.Web.WebPages.Administration.Test"/>
  <assembly name="System.Web.WebPages.Deployment.Test"/>
  <assembly name="System.Web.WebPages.Razor.Test"/>
  <assembly name="System.Web.WebPages.Test"/>
  <assembly name="WebApiHelpPage.Test"/>
  <assembly name="WebApiHelpPage.VB.Test" />
  <assembly name="WebMatrix.Data.Test"/>
  <assembly name="WebMatrix.WebData.Test"/>
</assemblies>


================================================
FILE: tools/WebStack.StyleCop.targets
================================================
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <ItemGroup>
    <StyleCopMsBuildRunner Include="$(WebStackRootPath)packages\StyleCop.5.0.0\**\StyleCop.dll"/>
    <StyleCopAdditionalAddins Include="$(WebStackRootPath)packages\Microsoft.Web.SkipStrongNames.1.0.0\**\Microsoft.Web.StyleCop.dll" />
    <StyleCopAdditionalAddinPaths Include="@(StyleCopAdditionalAddins -> '%(RootDir)%(Directory)')" />
  </ItemGroup>

  <UsingTask AssemblyFile="@(StyleCopMsBuildRunner)" TaskName="StyleCopTask" Condition=" '@(StyleCopMsBuildRunner)' != '' " />

  <PropertyGroup>
    <PrepareForRunDependsOn>$(PrepareForRunDependsOn);StyleCop</PrepareForRunDependsOn>
  </PropertyGroup>

  <PropertyGroup>
    <IsStyleCopEnabled Condition="'$(IsStyleCopEnabled)' == ''">$(StyleCopEnabled)</IsStyleCopEnabled>
    <StyleCopForceFullAnalysis Condition="'$(StyleCopForceFullAnalysis)' == ''">false</StyleCopForceFullAnalysis>
    <StyleCopCacheResults Condition="'$(StyleCopCacheResults)' == ''">true</StyleCopCacheResults>
    <StyleCopTreatErrorsAsWarnings Condition="'$(StyleCopTreatErrorsAsWarnings)' == ''">true</StyleCopTreatErrorsAsWarnings>
    <StyleCopOverrideSettingsFile Condition="'$(StyleCopOverrideSettingsFile)' == ''"> </StyleCopOverrideSettingsFile>
    <StyleCopOutputFile Condition="'$(StyleCopOutputFile)' == ''">$(IntermediateOutputPath)StyleCopViolations.xml</StyleCopOutputFile>
    <StyleCopSuccessMarkerFile Condition="'$(StyleCopSuccessMarkerFile)' == ''">$(IntermediateOutputPath)StyleCop.success</StyleCopSuccessMarkerFile>
    <!-- Specifying 0 will cause StyleCop to use the default violation count limit.
         Specifying any positive number will cause StyleCop to use that number as the violation count limit.
         Specifying any negative number will cause StyleCop to allow any number of violations without limit. -->
    <StyleCopMaxViolationCount Condition="'$(StyleCopMaxViolationCount)' == ''">0</StyleCopMaxViolationCount>
  </PropertyGroup>

  <!-- Define target: StyleCop -->
  <Target Name="StyleCop" Inputs="@(Compile)" Outputs="$(StyleCopSuccessMarkerFile)" Condition="'$(IsStyleCopEnabled)' == 'true'">
    <PropertyGroup>
      <StyleCopMsBuildRunner>@(StyleCopMsBuildRunner)</StyleCopMsBuildRunner>
    </PropertyGroup>
    <Error Text="Multiple StyleCop copies detected. Please clean out your packages folder and try again."
           Condition=" $(StyleCopMsBuildRunner.Contains(';')) " />

    <Delete Files="$(StyleCopSuccessMarkerFile)" Condition="Exists('$(StyleCopSuccessMarkerFile)')" />

    <Message Text="Running Style Analysis..." Importance="high" />
    <Message Text="Forcing full StyleCop reanalysis." Condition="'$(StyleCopForceFullAnalysis)' == 'true'" Importance="Low" />

    <!-- Determine what files should be checked. Take all Compile items, but exclude those that have
        set ExcludeFromStyleCop=true or ExcludeFromSourceAnalysis=true. -->
    <ItemGroup>
      <StyleCopFiles Include="@(Compile)" Condition=" '%(Compile.ExcludeFromStyleCop)' != 'true' and '%(Compile.ExcludeFromSourceAnalysis)' != 'true'" />
      <StyleCopExcludedFiles Include="@(Compile)" Condition=" '%(Compile.ExcludeFromStyleCop)' == 'true' or '%(Compile.ExcludeFromSourceAnalysis)' == 'true'" />
    </ItemGroup>

    <Message Text="Analyzing @(StyleCopFiles)" Importance="Low" />

    <!-- Show list of what files should be excluded. checked. Take all Compile items, but exclude those that have
        set ExcludeFromStyleCop=true or ExcludeFromSourceAnalysis=true. -->
    <Message Text="Excluding @(StyleCopExcludedFiles)" Importance="Normal" Condition=" '@(StyleCopExcludedFiles)' != '' "/>

    <!-- Run the StyleCop MSBuild task. -->
    <StyleCopTask
      ProjectFullPath="$(MSBuildProjectDirectory)"
      SourceFiles="@(StyleCopFiles)"
      AdditionalAddinPaths="@(StyleCopAdditionalAddinPaths)"
      ForceFullAnalysis="$(StyleCopForceFullAnalysis)"
      DefineConstants="$(DefineConstants)"
      TreatErrorsAsWarnings="$(StyleCopTreatErrorsAsWarnings)"
      CacheResults="$(StyleCopCacheResults)"
      OverrideSettingsFile="$(StyleCopOverrideSettingsFile)"
      OutputFile="$(StyleCopOutputFile)"
      MaxViolationCount="$(StyleCopMaxViolationCount)" />

    <!-- Make output files cleanable -->
    <ItemGroup>
      <FileWrites Include="$(StyleCopOutputFile)" />
      <FileWrites Include="$(StyleCopSuccessMarkerFile)" />
    </ItemGroup>

    <Touch Files="$(StyleCopSuccessMarkerFile)" AlwaysCreate="true" />

    <!-- Add the StyleCop.cache file to the list of files we've written - so they can be cleaned up on a Build Clean. -->
    <CreateItem Include="StyleCop.Cache" Condition="'$(StyleCopCacheResults)' == 'true'">
      <Output TaskParameter="Include" ItemName="FileWrites"/>
    </CreateItem>
  </Target>
</Project>


================================================
FILE: tools/WebStack.settings.targets
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <Import
      Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props"
      Condition="'$(MicrosoftCommonPropsHasBeenImported)' != 'true' AND Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')"/>
  <Import Project="$(CustomBeforeWebStackTargets)" Condition="Exists('$(CustomBeforeWebStackTargets)')" Label="Pre-targets Build Extensibility Point"/>

  <PropertyGroup>
    <!-- Define some basic reference paths -->
    <WebStackRootPath>$([System.IO.Path]::GetFullPath('$(MSBuildThisFileDirectory)..\'))</WebStackRootPath>
    <WebStackToolsPath>$(MSBuildThisFileDirectory)</WebStackToolsPath>

    <!-- Use CustomAfterMicrosoftCommonTargets property (defined in Microsoft.Common.targets) to
             inject post-Common targets files without requiring the inclusion -->
    <CustomAfterMicrosoftCommonTargets>$(WebStackToolsPath)WebStack.targets</CustomAfterMicrosoftCommonTargets>

    <!-- Force rebuild if this file changes -->
    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
  </PropertyGroup>

  <!-- Project Defaults -->
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <OutputPath Condition="'$(OutputPath)' == ''">$(WebStackRootPath)bin\$(Configuration)\</OutputPath>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <FileAlignment>512</FileAlignment>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>

    <!-- Variables for output redirection (localization, signing, etc)-->
    <Language Condition=" '$(Language)' == '' ">ENU</Language>
    <LocalizedPath Condition=" '$(LocalizedPath)' == '' "></LocalizedPath>

    <!-- StyleCop support -->
    <StyleCopTreatErrorsAsWarnings Condition=" '$(StyleCopTreatErrorsAsWarnings)' == '' ">false</StyleCopTreatErrorsAsWarnings>
    <StyleCopEnabled Condition=" '$(StyleCopEnabled)' == '' ">false</StyleCopEnabled>

    <!-- Use latest C# compiler supported in Visual Studio 2019. -->
    <LangVersion Condition=" '$(MSBuildProjectExtension)' == '.csproj' ">9.0</LangVersion>

    <!-- Everything is delay signed by default -->
    <SignAssembly>true</SignAssembly>
    <DelaySign>true</DelaySign>
    <AssemblyOriginatorKeyFile>$(WebStackRootPath)\tools\35MSSharedLib1024.snk</AssemblyOriginatorKeyFile>
  </PropertyGroup>

  <!-- Per-configuration properties -->
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <DefineConstants>TRACE;DEBUG;CODE_ANALYSIS</DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <DefineConstants>TRACE</DefineConstants>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'CodeAnalysis|AnyCPU' ">
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <DefineConstants>TRACE;CODE_ANALYSIS</DefineConstants>
  </PropertyGroup>
</Project>

================================================
FILE: tools/WebStack.targets
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <Import Project="$(WebStackToolsPath)WebStack.StyleCop.targets"/>
    <Import Project="$(CustomAfterWebStackTargets)" Condition="Exists('$(CustomAfterWebStackTargets)')" Label="Post-targets Build Extensibility Point" />
</Project>

================================================
FILE: tools/WebStack.tasks.targets
================================================
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <BuildTaskAssemblyReference Condition=" '$(BuildTaskAssemblyReference)' == '' And Exists('$(MSBuildToolsPath)\Microsoft.Build.Tasks.Core.dll') ">Microsoft.Build.Tasks.Core</BuildTaskAssemblyReference>
    <BuildTaskAssemblyReference Condition=" '$(BuildTaskAssemblyReference)' == '' And Exists('$(MSBuildToolsPath)\Microsoft.Build.Tasks.v$(MSBuildToolsVersion).dll') ">Microsoft.Build.Tasks.v$(MSBuildToolsVersion)</BuildTaskAssemblyReference>
    <BuildTaskAssemblyReference Condition=" '$(BuildTaskAssemblyReference)' == '' And Exists('$(MSBuildToolsPath)\Microsoft.Build.Tasks.v4.0.dll') ">Microsoft.Build.Tasks.v4.0</BuildTaskAssemblyReference>
    <!-- Know this file does not exist. But, error message will contain meaningful information. -->
    <BuildTaskAssemblyReference Condition=" '$(BuildTaskAssemblyReference)' == '' ">Microsoft.Build.Tasks.Core</BuildTaskAssemblyReference>
    <CodeTaskFactoryAssemblyFile Condition=" '$(CodeTaskFactoryAssemblyFile)' == '' ">$(MSBuildToolsPath)\$(BuildTaskAssemblyReference).dll</CodeTaskFactoryAssemblyFile>
  </PropertyGroup>

  <!-- This task does not support concurrent execution from multiple project files. Its use is only appropriate when
        NuGet.exe is not in use. -->
  <UsingTask TaskName="DownloadNuGet" TaskFactory="CodeTaskFactory" AssemblyFile="$(CodeTaskFactoryAssemblyFile)">
    <ParameterGroup>
      <OutputFileName ParameterType="System.String" Required="true" />
      <MinimumVersion ParameterType="System.String" Required="true" />
    </ParameterGroup>
    <Task>
      <Reference Include="System.Core" />
      <Using Namespace="System" />
      <Using Namespace="System.Diagnostics" />
      <Using Namespace="System.IO" />
      <Using Namespace="System.Net" />
      <Using Namespace="Microsoft.Build.Framework" />
      <Using Namespace="Microsoft.Build.Utilities" />
      <Code Type="Fragment" Language="cs">
        <![CDATA[
                Version minimumRequiredVersion;

                if (!Version.TryParse(MinimumVersion, out minimumRequiredVersion))
                {
                    Log.LogError("MinimumVersion '{0}' is not a valid Version.", MinimumVersion);
                    return false;
                }

                try
                {
                    OutputFileName = Path.GetFullPath(OutputFileName);

                    if (File.Exists(OutputFileName))
                    {
                        // If NuGet.exe exists but is less than the minimum required version, delete it so that the
                        // latest version will be downloaded.
                        FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(OutputFileName);

                        string toParse;

                        if (versionInfo != null && versionInfo.ProductVersion != null)
                        {
                            toParse = versionInfo.ProductVersion;
                            int index = toParse.IndexOfAny(new[] {'-', '+'});
                            if (index > 0)
                            {
                                toParse = toParse.Substring(0, index);
                            }
                        }
                        else
                        {
                            toParse = null;
                        }

                        Version current;
                        Version parsed;

                        if (toParse != null && Version.TryParse(toParse, out parsed))
                        {
                            current = parsed;
                        }
                        else
                        {
                            // Treat a missing or invalid version like V0.0 (which will trigger a delete and download).
                            current = new Version(0, 0);
                        }

                        if (current < minimumRequiredVersion)
                        {
                            File.Delete(OutputFileName);
                        }
                    }

                    if (!File.Exists(OutputFileName))
                    {
                        Log.LogMessage(MessageImportance.High, "Downloading latest version of NuGet.exe...");
                        WebClient webClient = new WebClient();
                        webClient.DownloadFile("https://dist.nuget.org/win-x86-commandline/latest/nuget.exe", OutputFileName);
                    }

                    return true;
                }
                catch (Exception ex)
                {
                    Log.LogErrorFromException(ex);
                    return false;
                }
            ]]>
      </Code>
    </Task>
  </UsingTask>

  <UsingTask TaskName="PrintTestRunSummary" TaskFactory="CodeTaskFactory" AssemblyFile="$(CodeTaskFactoryAssemblyFile)">
    <ParameterGroup>
      <TestResultsDirectory ParameterType="System.String" Required="true" />
    </ParameterGroup>
    <Task>
      <Reference Include="System.Xml" />
      <Reference Include="System.Xml.Linq" />
      <Using Namespace="System" />
      <Using Namespace="System.Collections.Generic" />
      <Using Namespace="System.IO" />
      <Using Namespace="System.Linq" />
      <Using Namespace="System.Text" />
      <Using Namespace="System.Text.RegularExpressions" />
      <Using Namespace="System.Xml.Linq" />
      <Using Namespace="Microsoft.Build.Framework" />
      <Using Namespace="Microsoft.Build.Utilities" />
      <Code Type="Fragment" Language="cs">
        <![CDATA[
                try
                {
                    string[] testResultFiles = Directory.GetFiles(TestResultsDirectory);
                    Regex regex = new Regex("&#x(?<char>[0-9A-Fa-f]+);",
                        RegexOptions.Multiline | RegexOptions.Compiled);
                    int testsPassed = 0;
                    int testsFailed = 0;
                    int testsSkipped = 0;
                    decimal timeSpent = 0;
                    List<string> testFailures = new List<string>();

                    foreach (string testResultFile in testResultFiles)
                    {
                        // Replace potentially illegal escaped characters (if they get through validations done during Save).
                        string fullPath = Path.GetFullPath(testResultFile);
                        string originalText = File.ReadAllText(fullPath);
                        bool matched = regex.IsMatch(originalText);

                        if (matched)
                        {
                            File.SetAttributes(fullPath, File.GetAttributes(fullPath) & ~FileAttributes.ReadOnly);
                            File.WriteAllText(fullPath, regex.Replace(originalText, "\0x${char}"), Encoding.UTF8);
                        }

                        // Collect test failure information from results file.
                        XElement xml;
                        using (FileStream fileStream = File.OpenRead(fullPath))
                        {
                            xml = XElement.Load(fileStream);
                        }

                        var assemblies = xml.Elements(XName.Get("assembly"));
                        foreach (XElement assembly in assemblies)
                        {
                            XAttribute failed = assembly.Attribute(XName.Get("failed"));
                            if (failed == null)
                            {
                                // Occasionally xUnit does not write information about test assembly completion.
                                XAttribute name = assembly.Attribute(XName.Get("name"));
                                Log.LogWarning(
                                    "No results in {0} for {1}.",
                                    testResultFile,
                                    name == null ? "unknown assembly" : name.Value);

                                continue;
                            }

                            int failures = Int32.Parse(failed.Value);
                            testsFailed += failures;

                            testsPassed += Int32.Parse(assembly.Attribute(XName.Get("passed")).Value);
                            testsSkipped += Int32.Parse(assembly.Attribute(XName.Get("skipped")).Value);
                            timeSpent += Decimal.Parse(assembly.Attribute(XName.Get("time")).Value);

                            if (failures > 0)
                            {
                                foreach (XElement classWithFailure in assembly.Elements(XName.Get("collection"))
                                    .Where(c => Int32.Parse(c.Attribute(XName.Get("failed")).Value) > 0))
                                {
                                    foreach (XElement failure in classWithFailure.Elements(XName.Get("test"))
                                        .Where(test => test.Attribute(XName.Get("result")).Value == "Fail"))
                                    {
                                        testFailures.Add(failure.Attribute("name").Value);
                                    }
                                }
                            }
                        }
                    }

                    // Log all test failures.
                    if (testFailures.Count > 0)
                    {
                        Log.LogMessage(MessageImportance.High, string.Empty);
                        Log.LogError("Tests failed...");
                        foreach (string testFailure in testFailures)
                        {
                            // Provide the list of failed tests but don't repeat it in the build summary. List
                            // is usually less helpful than errors from tests themselves (which are repeated)
                            // because those errors include the exact failure locations. On the other hand,
                            // this is more compact.
                            Log.LogMessage(MessageImportance.High, testFailure);
                        }
                    }

                    // Log summary of all results.
                    Log.LogMessage(MessageImportance.High, string.Empty);
                    Log.LogMessage(MessageImportance.High,
                        "Tests passed: {0}, Tests failed: {1}, Tests skipped: {2}",
                        testsPassed,
                        testsFailed,
                        testsSkipped);
                    Log.LogMessage(MessageImportance.High,
                        "Time spent running tests: {0} seconds", timeSpent);

                    return !Log.HasLoggedErrors;
                }
                catch (Exception ex)
                {
                    Log.LogErrorFromException(ex);
                    return false;
                }
            ]]>
      </Code>
    </Task>
  </UsingTask>
</Project>


================================================
FILE: tools/WebStack.testing.targets
================================================
<Project ToolsVersion="4.0" DefaultTargets="Xunit" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <!--
    This is a separate MSBuild file so that we can survive upgrades of the xunit NuGet package
    and also still work with NuGet Package Restore.
  -->
  <Import Project="..\packages\xunit.runner.msbuild.2.4.2\**\xunit.runner.msbuild.props"/>

  <Target Name="TestAssembly" Returns="@(_ExitCodes)">
    <xunit Assemblies="$(TestAssembly)"
        Condition=" '$(UseVSTest)' != 'true' "
        IgnoreFailures="true"
        Xml="$(XmlPath)">
      <Output TaskParameter="ExitCode" PropertyName="_ExitCode" />
    </xunit>
    <Exec Command="dotnet vstest $(TestAssembly) --logger:&quot;xunit;LogFilePath=$(XmlPath)&quot;"
        Condition=" '$(UseVSTest)' == 'true' "
        IgnoreExitCode="true"
        IgnoreStandardErrorWarningFormat="true">
      <Output TaskParameter="ExitCode" PropertyName="_ExitCode" />
    </Exec>

    <ItemGroup>
      <_ExitCodes Include="$(TestAssembly)" Code="$(_ExitCode)" />
    </ItemGroup>
  </Target>
</Project>


================================================
FILE: tools/src/Microsoft.Web.FxCop/DoNotCallProblematicMethodsOnTaskRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.FxCop.Sdk;

namespace Microsoft.Web.FxCop
{
    public class DoNotCallProblematicMethodsOnTaskRule : IntrospectionRule
    {
        private readonly Dictionary<string, string> _problematicMethods = GetProblematicMethods();

        public DoNotCallProblematicMethodsOnTaskRule()
            : base("DoNotCallProblematicMethodsOnTask")
        {
        }

        public override ProblemCollection Check(Member member)
        {
            var method = member as Method;
            if (method != null)
            {
                VisitStatements(method.Body.Statements);
            }

            return Problems;
        }

        public override void VisitMemberBinding(MemberBinding memberBinding)
        {
            var method = memberBinding.BoundMember as Method;
            if (method != null)
            {
                string message;
                if (_problematicMethods.TryGetValue(method.Name.Name, out message) &&
                    method.DeclaringType.IsTask())
                {
                    Problems.Add(new Problem(GetResolution(method.Name.Name, message), memberBinding.UniqueKey.ToString()));
                }
            }

            base.VisitMemberBinding(memberBinding);
        }

        private static Dictionary<string, string> GetProblematicMethods()
        {
            return new Dictionary<string, string>
            {
                { "get_Result", "Calls to this method are difficult to get correct or do not have good performance characteristics. Use the .Then(), .Catch(), or .Finally() extension method instead." },
                { "get_Factory", "If you need to create a Task, use the TaskHelpers class instead." },
                { "ContinueWith", "Calls to this method are difficult to get correct or do not have good performance characteristics. Use the .Then(), .Catch(), or .Finally() extension method instead." },
                { "Dispose", "Tasks should never be disposed of." },
                { "Run", "If you need to create a Task, use the TaskHelpers class instead." },
                { "RunSynchronously", "If you need to create a Task, use the TaskHelpers class instead." },
                { "Start", "If you need to create a Task, use the TaskHelpers class instead." },
                { "Wait", "This is a blocking call. Switch to an asynchronous call like .Then() instead." },
                { "WaitAll", "This is a blocking call. Switch to an asynchronous call like .Then() instead." },
                { "WaitAny", "This is a blocking call. Switch to an asynchronous call like .Then() instead." },
                { "Yield", "This call forces a thread transition which can hurt server performance. Do not use." },
            };
        }
    }
}


================================================
FILE: tools/src/Microsoft.Web.FxCop/DoNotConstructTaskInstancesRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.FxCop.Sdk;

namespace Microsoft.Web.FxCop
{
    public class DoNotConstructTaskInstancesRule : IntrospectionRule
    {
        public DoNotConstructTaskInstancesRule()
            : base("DoNotConstructTaskInstances")
        {
        }

        public override ProblemCollection Check(Member member)
        {
            var method = member as Method;
            if (method != null)
            {
                VisitStatements(method.Body.Statements);
            }

            return Problems;
        }

        public override void VisitConstruct(Construct construct)
        {
            var memberBinding = construct.Constructor as MemberBinding;

            if (memberBinding != null
                && memberBinding.BoundMember.Name.Name == ".ctor"
                && memberBinding.BoundMember.DeclaringType.IsTask())
            {
                Problems.Add(new Problem(GetResolution(), construct.UniqueKey.ToString()));
            }

            base.VisitConstruct(construct);
        }
    }
}


================================================
FILE: tools/src/Microsoft.Web.FxCop/DoNotUseFinalizersRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.FxCop.Sdk;

namespace Microsoft.Web.FxCop
{
    public class DoNotUseFinalizersRule : IntrospectionRule
    {
        public DoNotUseFinalizersRule()
            : base("DoNotUseFinalizers")
        {
        }

        public override ProblemCollection Check(Member member)
        {
            if (member.NodeType == NodeType.Method && member.Name.Name == "Finalize")
            {
                Problems.Add(new Problem(GetResolution(member.DeclaringType.FullName), member));
            }

            return Problems;
        }
    }
}


================================================
FILE: tools/src/Microsoft.Web.FxCop/DoNotUseProblematicTaskTypesRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Generic;
using Microsoft.FxCop.Sdk;

namespace Microsoft.Web.FxCop
{
    public class DoNotUseProblematicTaskTypesRule : IntrospectionRule
    {
        private readonly Dictionary<string, string> _problematicTypes = GetProblematicTypes();

        public DoNotUseProblematicTaskTypesRule()
            : base("DoNotUseProblematicTaskTypes")
        {
        }

        public override ProblemCollection Check(Member member)
        {
            var method = member as Method;
            if (method != null)
            {
                VisitStatements(method.Body.Statements);
            }

            return Problems;
        }

        public override void VisitMemberBinding(MemberBinding memberBinding)
        {
            var method = memberBinding.BoundMember as Method;
            if (method != null)
            {
                string message;
                if (_problematicTypes.TryGetValue(method.DeclaringType.FullName, out message))
                {
                    Problems.Add(new Problem(GetResolution(method.DeclaringType.FullName, message), memberBinding.UniqueKey.ToString()));
                }
            }

            base.VisitMemberBinding(memberBinding);
        }

        private static Dictionary<string, string> GetProblematicTypes()
        {
            return new Dictionary<string, string>
            {
                { "System.Threading.Tasks.Parallel", "The methods on this type are blocking operations." },
                { "System.Threading.Tasks.TaskExtensions", "The .Unwrap() method does not have good performance characteristics. Use the .FastUnwrap() extension method instead." },
                { "System.Threading.Tasks.TaskFactory", "If you need to create a Task, use the TaskHelpers class instead." },
                { "System.Threading.Tasks.TaskScheduler", "If you need to create a Task, use the TaskHelpers class instead." }
            };
        }
    }
}


================================================
FILE: tools/src/Microsoft.Web.FxCop/IntrospectionRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using Microsoft.FxCop.Sdk;

namespace Microsoft.Web.FxCop
{
    public abstract class IntrospectionRule : BaseIntrospectionRule
    {
        protected IntrospectionRule(string name)
            : base(name, "Microsoft.Web.FxCop.Rules", typeof(IntrospectionRule).Assembly)
        {
        }
    }
}


================================================
FILE: tools/src/Microsoft.Web.FxCop/Microsoft.Web.FxCop.csproj
================================================
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
    <ProductVersion>8.0.30703</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{F439D4E6-3FAC-4C30-9585-6D258133A2BF}</ProjectGuid>
    <OutputType>Library</OutputType>
    <AppDesignerFolder>Properties</AppDesignerFolder>
    <RootNamespace>Microsoft.Web.FxCop</RootNamespace>
    <AssemblyName>Microsoft.Web.FxCop</AssemblyName>
    <!-- May need to be updated as FxCopSdk.dll is migrated to newer TFMs. -->
    <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
    <OutputPath Condition=" '$(OutputPath)' == '' ">bin\$(Configuration)</OutputPath>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <Optimize>false</Optimize>
    <DefineConstants>DEBUG;TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
    <PlatformTarget>x86</PlatformTarget>
    <DebugType>pdbonly</DebugType>
    <Optimize>true</Optimize>
    <DefineConstants>TRACE</DefineConstants>
    <ErrorReport>prompt</ErrorReport>
    <WarningLevel>4</WarningLevel>
  </PropertyGroup>
  <PropertyGroup>
    <FxCopLocation>$(VsInstallRoot)\Team Tools\Static Analysis Tools\FxCop\</FxCopLocation>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="FxCopSdk">
      <HintPath>$(FxCopLocation)FxCopSdk.dll</HintPath>
      <Private>False</Private>
    </Reference>
    <Reference Include="Microsoft.Cci">
      <HintPath>$(FxCopLocation)Microsoft.Cci.dll</HintPath>
      <Private>False</Private>
    </Reference>
    <Reference Include="System" />
    <Reference Include="System.Core" />
    <Reference Include="System.Xml.Linq" />
    <Reference Include="System.Data.DataSetExtensions" />
    <Reference Include="Microsoft.CSharp" />
    <Reference Include="System.Data" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="DoNotUseFinalizersRule.cs" />
    <Compile Include="DoNotCallProblematicMethodsOnTaskRule.cs" />
    <Compile Include="DoNotConstructTaskInstancesRule.cs" />
    <Compile Include="IntrospectionRule.cs" />
    <Compile Include="UnusedResourceUsageRule.cs" />
    <Compile Include="Properties\AssemblyInfo.cs" />
    <Compile Include="DoNotUseProblematicTaskTypesRule.cs" />
    <Compile Include="TypeNodeExtensions.cs" />
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="Rules.xml">
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
  <PropertyGroup>
    <!-- If the FxCop SDK does not exist at all have this build no-op. -->
    <BuildDependsOn Condition=" !Exists('$(FxCopLocation)') ">
    </BuildDependsOn>
  </PropertyGroup>
</Project>

================================================
FILE: tools/src/Microsoft.Web.FxCop/Properties/AssemblyInfo.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Reflection;

[assembly: AssemblyProduct("Microsoft.Web.FxCop")]
[assembly: AssemblyDescription("FxCop rules used by the Microsoft ASP.NET WebStack projects")]
[assembly: AssemblyCompany(".NET Foundation")]
[assembly: AssemblyCopyright("Copyright © .NET Foundation. All rights reserved.")]


================================================
FILE: tools/src/Microsoft.Web.FxCop/Rules.xml
================================================
<?xml version="1.0" encoding="utf-8"?>
<Rules FriendlyName="FxCop rules used by the ASP.NET Webstack team">

    <!-- MW10xx: Resource rules -->
    <Rule TypeName="UnusedResourceUsageRule" Category="Microsoft.Web.FxCop" CheckId="MW1000">
        <Name>UnusedResourceUsageRule</Name>
        <Description>This rule fires when a resource is unused in the assembly.</Description>
        <Url></Url>
        <Resolution>Remove the unused resource '{0}' from '{1}'.</Resolution>
        <Email></Email>
        <MessageLevel Certainty="95">Error</MessageLevel>
        <FixCategories>Breaking</FixCategories>
        <Owner></Owner>
    </Rule>

    <!-- MW11xx: Finalizer rules -->
    <Rule TypeName="DoNotUseFinalizers" Category="Microsoft.Web.FxCop" CheckId="MW1100">
        <Name>Do not use finalizers</Name>
        <Description>For performance reasons, managed types should not implement finalizers.</Description>
        <Url></Url>
        <Resolution>Type '{0}' has a finalizer. Use SafeHandle to contain unmanaged data instead.</Resolution>
        <Email></Email>
        <MessageLevel Certainty="100">Error</MessageLevel>
        <FixCategories>Breaking</FixCategories>
        <Owner></Owner>
    </Rule>

    <!-- MW12xx: Task rules -->
    <Rule TypeName="DoNotConstructTaskInstances" Category="Microsoft.Web.FxCop" CheckId="MW1200">
        <Name>Do not construct instances of the Task-related types</Name>
        <Description>For performance reasons, all tasks should be created using the TaskHelpers library.</Description>
        <Url></Url>
        <Resolution>Do not construct instances of Task-related types. If you need to create a Task, use the TaskHelpers class instead.</Resolution>
        <Email></Email>
        <MessageLevel Certainty="100">Error</MessageLevel>
        <FixCategories>NonBreaking</FixCategories>
        <Owner></Owner>
    </Rule>
    <Rule TypeName="DoNotCallProblematicMethodsOnTask" Category="Microsoft.Web.FxCop" CheckId="MW1201">
        <Name>Do not call problematic methods on Task</Name>
        <Description>For performance reasons, use the TaskHelpers and TaskHelpersExtensions library rather than methods on Task.</Description>
        <Url></Url>
        <Resolution>Do not call the method 'Task.{0}'. {1}</Resolution>
        <Email></Email>
        <MessageLevel Certainty="100">Error</MessageLevel>
        <FixCategories>NonBreaking</FixCategories>
        <Owner></Owner>
    </Rule>
    <Rule TypeName="DoNotUseProblematicTaskTypes" Category="Microsoft.Web.FxCop" CheckId="MW1202">
        <Name>Do not call use problematic Task types</Name>
        <Description>For performance reasons, use the TaskHelpers and TaskHelpersExtensions library rather than Task-related types.</Description>
        <Url></Url>
        <Resolution>Do not use the type '{0}'. {1}</Resolution>
        <Email></Email>
        <MessageLevel Certainty="100">Error</MessageLevel>
        <FixCategories>NonBreaking</FixCategories>
        <Owner></Owner>
    </Rule>
</Rules>


================================================
FILE: tools/src/Microsoft.Web.FxCop/TypeNodeExtensions.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System;
using System.Diagnostics.Contracts;
using System.Linq;
using Microsoft.FxCop.Sdk;

namespace Microsoft.Web.FxCop
{
    public static class TypeNodeExtensions
    {
        private const string TaskPortableAssembly = "System.Threading.Tasks";
        private const string TaskNamespace = "System.Threading.Tasks";
        private const string TaskType = "Task";
        private const string TaskGenericType = "Task`1";
        private static readonly object _taskLock = new object();

        private static TypeNode _task;
        private static TypeNode _taskGeneric;

        public static bool IsTask(this TypeNode type)
        {
            if (type.IsAbstract)
            {
                // Short-circuit because Task is not an abstract type.
                //
                // This also avoids NREs when the passed type is an interface. May be passed an interface when caller
                // encounters a method that is explicitly implemented e.g. Dispose() is not visible directly on
                // JsonReader though JsonReader implements System.IDisposable. Interfaces such as IDisposable are
                // defined very low in the module hierarchy, leading to NREs in GetTaskAssembly(). Therefore, use only
                // concrete types to initialize the fields.
                return false;
            }

            EnsureTaskTypesInitialized(type);
            return IsTaskCore(type);
        }

        private static bool IsTaskCore(TypeNode type)
        {
            Contract.Assert(_task != null);
            Contract.Assert(_taskGeneric != null);

            if (type.Name.UniqueIdKey == _task.Name.UniqueIdKey)
            {
                return true;
            }

            if (!type.IsGeneric)
            {
                return false;
            }

            TypeNode targetType = _taskGeneric.GetGenericTemplateInstance(_taskGeneric.DeclaringModule, type.ConsolidatedTemplateArguments);
            return targetType.Name.UniqueIdKey == type.Name.UniqueIdKey;
        }

        private static void EnsureTaskTypesInitialized(TypeNode type)
        {
            lock (_taskLock)
            {
                if (_task == null)
                {
                    Contract.Assert(_task == null);
                    Contract.Assert(_taskGeneric == null);

                    AssemblyNode taskAssembly = GetTaskAssembly(type);
                    Contract.Assert(taskAssembly != null);

                    _task = GetTypeNode(taskAssembly, TaskNamespace, TaskType);
                    _taskGeneric = GetTypeNode(taskAssembly, TaskNamespace, TaskGenericType);

                    Contract.Assert(_task != null);
                    Contract.Assert(_taskGeneric != null);
                }
            }
        }

        private static TypeNode GetTypeNode(AssemblyNode assembly, string ns, string name)
        {
            Contract.Assert(assembly != null);

            return assembly.GetType(Identifier.For(ns), Identifier.For(name));
        }

        private static AssemblyNode GetTaskAssembly(TypeNode type)
        {
            AssemblyNode taskAssembly = null;

            // Check if the type's located in mscorlib
            TypeNode taskTypeNode = GetTypeNode(FrameworkAssemblies.Mscorlib, TaskNamespace, TaskGenericType);
            if (taskTypeNode != null)
            {
                taskAssembly = FrameworkAssemblies.Mscorlib;
            }
            else if (type.DeclaringModule.Name.Equals(TaskPortableAssembly))
            {
                // If the type is a type in the portable assembly, no need to loop through the assembly references
                taskAssembly = type.DeclaringModule.ContainingAssembly;
            }
            else
            {
                AssemblyReference assemblyReference = type.DeclaringModule
                                                          .AssemblyReferences
                                                          .FirstOrDefault(reference => reference.Name.Equals(TaskPortableAssembly, StringComparison.Ordinal));
                Contract.Assert(assemblyReference != null);
                taskAssembly = assemblyReference.Assembly;
            }

            Contract.Assert(taskAssembly != null);
            return taskAssembly;
        }
    }
}


================================================
FILE: tools/src/Microsoft.Web.FxCop/UnusedResourceUsageRule.cs
================================================
// Copyright (c) .NET Foundation. All rights reserved.
// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.

using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using Microsoft.FxCop.Sdk;

namespace Microsoft.Web.FxCop
{
    public class UnusedResourceUsageRule : IntrospectionRule
    {
        private static readonly object _lock = new object();
        private static readonly IDictionary<AssemblyNode, ISet<PropertyNode>> _availableResources = new ConcurrentDictionary<AssemblyNode, ISet<PropertyNode>>();
        private static readonly IDictionary<AssemblyNode, ISet<PropertyNode>> _usedResources = new ConcurrentDictionary<AssemblyNode, ISet<PropertyNode>>();

        public UnusedResourceUsageRule()
            : base("UnusedResourceUsageRule")
        {
        }

        public override TargetVisibilities TargetVisibility
        {
            get { return TargetVisibilities.All; }
        }

        public override ProblemCollection Check(ModuleNode node)
        {
            var assemblyNode = node as AssemblyNode;
            if (assemblyNode != null)
            {
                var assemblyAvailableResources = new HashSet<PropertyNode>();
                var assemblyUsedResources = new HashSet<PropertyNode>();

                _availableResources[assemblyNode] = assemblyAvailableResources;
                _usedResources[assemblyNode] = assemblyUsedResources;

                VisitAssembly(assemblyNode);

                IEnumerable<PropertyNode> unusedResources = from res in assemblyAvailableResources.Except(assemblyUsedResources)
                                                            where !IsCommonResource(res)
                                                            select res;

                foreach (PropertyNode item in unusedResources)
                {
                    Problems.Add(new Problem(this.GetResolution(item.Name.Name, item.DeclaringType.FullName), item.UniqueKey.ToString()));
                }
            }

            return Problems;
        }

        public override void VisitProperty(PropertyNode property)
        {
            if (IsResourceType(property.DeclaringType) && IsResource(property))
            {
                AddItemWithLock(_availableResources[(AssemblyNode)property.DeclaringType.DeclaringModule], property);
            }

            base.VisitProperty(property);
        }

        public override void VisitMethodCall(MethodCall call)
        {
            MemberBinding mb = call.Callee as MemberBinding;
            if (mb != null)
            {
                Method methodBeingCalled = mb.BoundMember as Method;
                if (methodBeingCalled != null
                        && IsResourceType(methodBeingCalled.DeclaringType)
                        && IsResource(methodBeingCalled.DeclaringMember as PropertyNode))
                {

                    var property = methodBeingCalled.DeclaringMember as PropertyNode;

                    ISet<PropertyNode> properties = null;
                    // Look up the assembly from the dictionary. If the assembly could not be looked up, the resource must have been declared outside the current assembly
                    if (_usedResources.TryGetValue((AssemblyNode)property.DeclaringType.DeclaringModule, out properties))
                    {
                        AddItemWithLock(properties, property);
                    }
                }
            }

            base.VisitMethodCall(call);
        }

        private static void AddItemWithLock<T>(ISet<T> item, T value)
        {
            lock (_lock)
            {
                item.Add(value);
            }
        }

        private static bool IsResource(PropertyNode property)
        {
            return property != null && property.Type.FullName.Equals(typeof(System.String).FullName);
        }

        private static bool IsResourceType(TypeNode typeNode)
        {
            var classNode = typeNode as ClassNode;
            return (classNode != null
                && classNode.Attributes.Any(c => c.Type.FullName.Equals(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute).FullName))
                && classNode.Name.Name.Contains("Resource"));
        }

        /// <summary>
        /// Hack to determine if the file is "Common*Resources.resx" that is shared amongst multiple WebStack projects. 
        /// Strings in this resx are ignored since they may have dependencies outside the current assembly.
        /// </summary>
        private static bool IsCommonResource(PropertyNode property)
        {
            string name = property.DeclaringType.Name.Name;
            return name.StartsWith("Common") && name.EndsWith("Resources");
        }
    }
}



================================================
FILE: tools/vslicense/dotnet-library-license.htm
================================================
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=Windows-1252">
<meta name="Generator" content="Microsoft Word 15 (filtered)">
<style>
<!--
@font-face
	{font-family:Wingdings}
@font-face
	{font-family:"MS Mincho"}
@font-face
	{font-family:SimSun}
@font-face
	{font-family:"Cambria Math"}
@font-face
	{font-family:Calibri}
@font-face
	{font-family:Tahoma}
@font-face
	{font-family:"Trebuchet MS"}
@font-face
	{}
@font-face
	{}
p.MsoNormal, li.MsoNormal, div.MsoNormal
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:0in;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
h1
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:17.85pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
h2
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:.5in;
	text-indent:-18.15pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
h3
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:53.85pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:normal}
h4
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:71.75pt;
	text-indent:-17.9pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:normal}
h5
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:89.6pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:normal}
h6
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:107.45pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:normal}
p.MsoHeading7, li.MsoHeading7, div.MsoHeading7
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:125.3pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.MsoHeading8, li.MsoHeading8, div.MsoHeading8
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:143.15pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.MsoHeading9, li.MsoHeading9, div.MsoHeading9
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:161.05pt;
	text-indent:-17.9pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.MsoCommentText, li.MsoCommentText, div.MsoCommentText
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:0in;
	font-size:10.0pt;
	font-family:"Tahoma",sans-serif}
p.MsoHeader, li.MsoHeader, div.MsoHeader
	{margin:0in;
	margin-bottom:.0001pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.MsoFooter, li.MsoFooter, div.MsoFooter
	{margin:0in;
	margin-bottom:.0001pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
a:link, span.MsoHyperlink
	{font-family:"Times New Roman",serif;
	color:blue;
	text-decoration:underline}
a:visited, span.MsoHyperlinkFollowed
	{color:purple;
	text-decoration:underline}
p.MsoPlainText, li.MsoPlainText, div.MsoPlainText
	{margin:0in;
	margin-bottom:.0001pt;
	font-size:11.0pt;
	font-family:"Calibri",sans-serif}
p.MsoCommentSubject, li.MsoCommentSubject, div.MsoCommentSubject
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:0in;
	font-size:10.0pt;
	font-family:"Tahoma",sans-serif;
	font-weight:bold}
p.MsoAcetate, li.MsoAcetate, div.MsoAcetate
	{margin:0in;
	margin-bottom:.0001pt;
	font-size:8.0pt;
	font-family:"Tahoma",sans-serif}
span.Heading1Char
	{font-family:"Tahoma",sans-serif;
	font-weight:bold}
span.Heading2Char
	{font-family:"Tahoma",sans-serif;
	font-weight:bold}
span.Heading3Char
	{font-family:"Tahoma",sans-serif}
span.Heading4Char
	{font-family:"Tahoma",sans-serif}
span.Heading5Char
	{font-family:"Tahoma",sans-serif}
span.Heading6Char
	{font-family:"Tahoma",sans-serif}
span.Heading7Char
	{font-family:"Tahoma",sans-serif}
span.Heading8Char
	{font-family:"Tahoma",sans-serif}
span.Heading9Char
	{font-family:"Tahoma",sans-serif}
p.Body1, li.Body1, div.Body1
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.Bullet2, li.Bullet2, div.Bullet2
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:.5in;
	text-indent:-18.15pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.Bullet3, li.Bullet3, div.Bullet3
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:53.85pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.HeadingEULA, li.HeadingEULA, div.HeadingEULA
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:0in;
	font-size:14.0pt;
	font-family:"Tahoma",sans-serif;
	font-weight:bold}
p.HeadingSoftwareTitle, li.HeadingSoftwareTitle, div.HeadingSoftwareTitle
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:0in;
	border:none;
	padding:0in;
	font-size:14.0pt;
	font-family:"Tahoma",sans-serif;
	font-weight:bold}
p.Preamble, li.Preamble, div.Preamble
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:0in;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:bold}
p.PreambleBorderAbove, li.PreambleBorderAbove, div.PreambleBorderAbove
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:0in;
	border:none;
	padding:0in;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:bold}
p.Body0Bold, li.Body0Bold, div.Body0Bold
	{margin:0in;
	margin-bottom:.0001pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:bold}
p.Body0, li.Body0, div.Body0
	{margin:0in;
	margin-bottom:.0001pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
span.BalloonTextChar
	{font-family:"Tahoma",sans-serif}
p.Bullet1, li.Bullet1, div.Bullet1
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:17.85pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.Bullet4, li.Bullet4, div.Bullet4
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:71.75pt;
	text-indent:-17.9pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.Bullet5, li.Bullet5, div.Bullet5
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:89.6pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif}
p.Heading3Bold, li.Heading3Bold, div.Heading3Bold
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:53.85pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	font-weight:bold}
p.Bullet4Underline, li.Bullet4Underline, div.Bullet4Underline
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:71.75pt;
	text-indent:-17.9pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	text-decoration:underline}
span.Body2Char
	{font-family:"Tahoma",sans-serif}
span.Body3Char
	{font-family:"Tahoma",sans-serif}
span.CommentTextChar
	{font-family:"Tahoma",sans-serif}
span.CommentSubjectChar
	{font-family:"Tahoma",sans-serif;
	font-weight:bold}
span.Bullet3Char1
	{font-family:"Tahoma",sans-serif}
p.Bullet4Underlined, li.Bullet4Underlined, div.Bullet4Underlined
	{margin-top:6.0pt;
	margin-right:0in;
	margin-bottom:6.0pt;
	margin-left:17.85pt;
	text-indent:-17.85pt;
	font-size:9.5pt;
	font-family:"Tahoma",sans-serif;
	text-decoration:underline}
span.Heading3BoldChar
	{font-family:"Tahoma",sans-serif;
	font-weight:bold}
span.PlainTextChar
	{font-family:"Calibri",sans-serif}
span.HeaderChar
	{font-family:"Tahoma",sans-serif}
span.FooterChar
	{font-family:"Tahoma",sans-serif}
p.bullet30, li.bullet30, div.bullet30
	{margin-right:0in;
	margin-left:0in;
	font-size:12.0pt;
	font-family:"Times New Roman",serif}
p.bullet40, li.bullet40, div.bullet40
	{margin-right:0in;
	margin-left:0in;
	font-size:12.0pt;
	font-family:"Times New Roman",serif}
.MsoChpDefault
	{font-family:"Calibri",sans-serif}
.MsoPapDefault
	{margin-left:.25in;
	text-indent:-.25in}
@page WordSection1
	{margin:1.0in 1.0in 1.0in 1.0in}
div.WordSection1
	{}
ol
	{margin-bottom:0in}
ul
	{margin-bottom:0in}
-->
</style>
</head>
<body lang="EN-US" link="blue" vlink="purple">
<div class="WordSection1">
<p class="HeadingEULA"><span style="font-size:10.0pt">MICROSOFT SOFTWARE LICENSE TERMS</span></p>
<div style="border:none; border-bottom:solid windowtext 1.0pt; padding:0in 0in 1.0pt 0in">
<p class="HeadingSoftwareTitle"><span style="font-size:10.0pt">MICROSOFT .NET LIBRARY</span></p>
</div>
<p class="Preamble"><span style="font-size:10.0pt; font-weight:normal">These license terms are an agreement between you and Microsoft Corporation (or based on where you live, one of its affiliates). They apply to the software named above. The terms also apply
 to any Microsoft services or updates for the software, except to the extent those have different terms.</span></p>
<div style="border:none; border-top:solid windowtext 1.0pt; padding:1.0pt 0in 0in 0in">
<p class="PreambleBorderAbove"><span style="font-size:10.0pt; text-transform:uppercase">If you comply with these license terms, you have the rights below.</span></p>
</div>
<h1 style="margin-top:6.0pt; margin-right:0in; margin-bottom:0in; margin-left:.25in; margin-bottom:.0001pt; text-indent:-.25in">
<span style="font-size:10.0pt">1.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp; </span>
</span><span style="font-size:10.0pt">INSTALLATION AND USE RIGHTS. </span></h1>
<p class="Bullet3" style="margin-top:0in; margin-right:0in; margin-bottom:6.0pt; margin-left:.25in; text-indent:0in">
<span style="font-size:10.0pt">You may install and use any number of copies of the software
</span><span style="font-size:10.0pt; color:black">to develop and test your applications.&nbsp;
</span></p>
<h1><span style="font-size:10.0pt">2.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">THIRD PARTY COMPONENTS. </span><span style="font-weight:normal">The software may include third party components with separate legal notices or governed by other agreements, as may be described in the ThirdPartyNotices
 file(s) </span><span style="font-size:10.0pt; font-weight:normal">accompanying the software.</span></h1>
<h1><span style="font-size:10.0pt">3.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; color:black">ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.</span></h1>
<h2><span style="font-size:10.0pt; color:black">a.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; color:black">DISTRIBUTABLE CODE.&nbsp; </span>
<span style="font-size:10.0pt; color:black; font-weight:normal">T</span><span style="font-size:10.0pt; color:black; font-weight:normal">he software is comprised of Distributable Code. Distributable Code is code that you are permitted to distribute in applications
 you develop if you comply with the terms below.</span></h2>
<h3 style="margin-top:0in; margin-right:0in; margin-bottom:0in; margin-left:53.85pt; margin-bottom:.0001pt">
<b><span style="font-size:10.0pt; color:black">i.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span></b><b><span style="font-size:10.0pt; color:black">Right to Use and Distribute.
</span></b></h3>
<p class="bullet30" style="margin-top:6.0pt; margin-right:0in; margin-bottom:6.0pt; margin-left:1.0in; text-indent:-.25in">
<span style="font-size:10.0pt; font-family:Symbol; color:black"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:black">You may copy and distribute the object code form of the software.</span></p>
<p class="bullet30" style="margin-top:6.0pt; margin-right:0in; margin-bottom:6.0pt; margin-left:1.0in; text-indent:-.25in">
<span style="font-size:10.0pt; font-family:Symbol; color:black"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:black">Third Party Distribution. You may permit distributors of your applications to copy and distribute the Distributable Code as part of those applications.</span></p>
<h3 style="margin-top:0in; margin-right:0in; margin-bottom:0in; margin-left:53.85pt; margin-bottom:.0001pt">
<b><span style="font-size:10.0pt; color:black">ii.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;
</span></span></b><b><span style="font-size:10.0pt; color:black">Distribution Requirements. For any Distributable Code you distribute, you must</span></b></h3>
<p class="bullet30" style="margin-top:6.0pt; margin-right:0in; margin-bottom:6.0pt; margin-left:1.0in; text-indent:-.25in">
<span style="font-size:10.0pt; font-family:Symbol; color:black"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:black">use the Distributable Code in your applications and not as a standalone distribution;</span></p>
<p class="bullet30" style="margin-top:6.0pt; margin-right:0in; margin-bottom:6.0pt; margin-left:1.0in; text-indent:-.25in">
<span style="font-size:10.0pt; font-family:Symbol; color:black"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:black">require distributors and external end users to agree to terms that protect it at least as much as this agreement; and</span></p>
<p class="bullet30" style="margin-top:6.0pt; margin-right:0in; margin-bottom:6.0pt; margin-left:1.0in; text-indent:-.25in">
<span style="font-size:10.0pt; font-family:Symbol; color:black"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:black">indemnify, defend, and hold harmless Microsoft from any claims, including attorneys fees, related to the distribution or use of your applications, except to the extent
 that any claim is based solely on the unmodified Distributable Code.</span></p>
<h3 style="margin-top:0in; margin-right:0in; margin-bottom:0in; margin-left:53.85pt; margin-bottom:.0001pt">
<b><span style="font-size:10.0pt; color:black">iii.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;
</span></span></b><b><span style="font-size:10.0pt; color:black">Distribution Restrictions. You may not</span></b></h3>
<p class="bullet30" style="margin-top:6.0pt; margin-right:0in; margin-bottom:6.0pt; margin-left:1.0in; text-indent:-.25in">
<span style="font-size:10.0pt; font-family:Symbol; color:black"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:black">use Microsofts trademarks in your applications names or in a way that suggests your applications come from or are endorsed by Microsoft; or</span></p>
<p class="bullet30" style="margin-top:6.0pt; margin-right:0in; margin-bottom:6.0pt; margin-left:1.0in; text-indent:-.25in">
<span style="font-size:10.0pt; font-family:Symbol; color:black"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:black">modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An Excluded License is one that requires,
 as a condition of use, modification or distribution of code, that (i) it be disclosed or distributed in source code form; or (ii) others have the right to modify it.</span></p>
<h1><span style="font-size:10.0pt">4.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">DATA.</span></h1>
<h2><span style="font-size:10.0pt">a.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">Data Collection. </span><span style="font-size:10.0pt; font-weight:normal">The software may collect information about you and your use of the software, and send that to Microsoft. Microsoft may use this information
 to provide services and improve our products and services.&nbsp; You may opt-out of many of these scenarios, but not all, as described in the software documentation.&nbsp; There are also s<span style="color:black">ome features in the software that may enable you and
 Microsoft to collect data from users of your applications.</span> If you use these features, you must comply with applicable law, including providing appropriate notices to users of your applications together with Microsofts privacy statement. Our privacy
 statement is located at </span><a href="https://go.microsoft.com/fwlink/?LinkID=824704"><span style="font-size:10.0pt; font-weight:normal">https://go.microsoft.com/fwlink/?LinkID=824704</span></a><span style="font-size:10.0pt; font-weight:normal">. You can
 learn more about data collection and its use from the software documentation and our privacy statement. Your use of the software operates as your consent to these practices.</span></h2>
<h2><span style="font-size:10.0pt">b.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">Processing of Personal Data. </span>
<span style="font-size:10.0pt; font-weight:normal">To the extent Microsoft is a processor or subprocessor of personal data in connection with the software, Microsoft makes the commitments in the European Union General Data Protection Regulation Terms of the
 Online Services Terms to all customers effective May 25, 2018, at </span><span class="MsoHyperlink"><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; font-weight:normal">https://docs.microsoft.com/en-us/legal/gdpr</span></span><span style="font-size:10.0pt; font-weight:normal">.</span></h2>
<h1><span style="font-size:10.0pt">5.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; text-transform:uppercase">Scope of License</span><span style="font-size:10.0pt">.</span><span style="font-size:10.0pt; font-weight:normal"> The software is licensed, not sold. This agreement only gives you some rights
 to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations
 in the software that only allow you to use it in certain ways. You may not</span></h1>
<p class="Bullet2"><span style="font-size:10.0pt; font-family:Symbol"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">work around any technical limitations in the software</span><span style="font-size:10.0pt">;</span></p>
<p class="Bullet2"><span style="font-size:10.0pt; font-family:Symbol"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">reverse engineer, decompile or disassemble the software, or otherwise attempt to derive the source code for the software, except and to the extent required by third party licensing terms governing use of certain
 open source components that may be included in the software;</span></p>
<p class="Bullet2"><span style="font-size:10.0pt; font-family:Symbol"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">remove, minimize, block or modify any notices of Microsoft or its suppliers in the software;
</span></p>
<p class="Bullet2"><span style="font-size:10.0pt; font-family:Symbol"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">use the software in any way that is against the law; or</span></p>
<p class="Bullet2"><span style="font-size:10.0pt; font-family:Symbol"><span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">share, publish, rent or lease the software, provide the software as a stand-alone offering for others to use, or transfer the software or this agreement to any third party.</span></p>
<h1><span class="MsoHyperlink"><span style="font-size:10.0pt; font-family:&quot;Tahoma&quot;,sans-serif; color:windowtext; text-decoration:none">6.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span></span><span style="font-size:10.0pt; text-transform:uppercase">Export Restrictions</span><span style="font-size:10.0pt">.</span><span style="font-size:10.0pt; font-weight:normal">
</span><span style="font-size:10.0pt; font-weight:normal">You must comply with all domestic and international export laws and regulations that apply to the software, which include restrictions on destinations, end users, and end use. For further information
 on export restrictions, visit www.microsoft.com/exporting.</span><span class="MsoHyperlink"><span style="font-size:10.0pt; font-weight:normal">
</span></span><span style="font-size:10.0pt; font-weight:normal">&nbsp;</span></h1>
<h1><span style="font-size:10.0pt">7.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; text-transform:uppercase">SUPPORT SERVICES.</span><span style="font-size:10.0pt">
</span><span style="font-size:10.0pt; font-weight:normal">Because this software is as is, we may not provide support services for it.</span></h1>
<h1><span style="font-size:10.0pt">8.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; text-transform:uppercase">Entire Agreement.</span><span style="font-size:10.0pt; font-weight:normal"> This agreement, and the terms for supplements, updates, Internet-based services and support services that you
 use, are the entire agreement for the software and support services.</span></h1>
<h1 style="margin-left:.25in; text-indent:-.25in"><span style="font-size:10.0pt">9.<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt; text-transform:uppercase">Applicable Law</span><span style="font-size:10.0pt">.&nbsp;
</span><span style="font-size:10.0pt; font-weight:normal">If you acquired the software in the United States, Washington law applies to interpretation of and claims for breach of this agreement, and the laws of the state where you live apply to all other claims.
 If you acquired the software in any other country, its laws apply.</span></h1>
<h1 style="margin-left:.25in; text-indent:-.25in"><span style="font-size:10.0pt">10.<span style="font:7.0pt &quot;Times New Roman&quot;">
</span></span><span style="font-size:10.0pt">CONSUMER RIGHTS; REGIONAL VARIATIONS.
</span><span style="font-size:10.0pt; font-weight:normal">This agreement describes certain legal rights. You may have other rights, including consumer rights, under the laws of your state or country. Separate and apart from your relationship with Microsoft,
 you may also have rights with respect to the party from which you acquired the software. This agreement does not change those other rights if the laws of your state or country do not permit it to do so. For example, if you acquired the software in one of the
 below regions, or mandatory country law applies, then the following provisions apply to you:</span></h1>
<h2 style="margin-left:35.85pt; text-indent:-.25in"><span style="font-size:10.0pt">a)<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">Australia. </span><span style="font-size:10.0pt; font-weight:normal">You have statutory guarantees under the Australian Consumer Law and nothing in this agreement is intended to affect those rights.</span></h2>
<h2 style="margin-left:35.85pt; text-indent:-.25in"><span style="font-size:10.0pt">b)<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">Canada. </span><span style="font-size:10.0pt; font-weight:normal">If you acquired this software in Canada, you may stop receiving updates by turning off the automatic update feature, disconnecting your device from
 the Internet (if and when you re-connect to the Internet, however, the software will resume checking for and installing updates), or uninstalling the software. The product documentation, if any, may also specify how to turn off updates for your specific device
 or software.</span></h2>
<h2 style="margin-left:35.85pt; text-indent:-.25in"><span style="font-size:10.0pt">c)<span style="font:7.0pt &quot;Times New Roman&quot;">&nbsp;&nbsp;&nbsp;
</span></span><span style="font-size:10.0pt">Germany and Austria</span><span style="font-size:10.0pt; font-weight:normal">.</span></h2>
<p class="MsoNormal" style="margin-left:35.85pt"><b><span style="font-size:10.0pt">(i)</span></b><span style="font-size:10.0pt">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<b>Warranty</b>. The software will perform substantially as described in any Microsoft materials that accompany it. However, Microsoft gives no contractual guarantee in relation to the software.</span></p>
<p class="MsoNormal" style="margin-left:35.85pt"><b><span style="font-size:10.0pt">(ii)</span></b><span style="font-size:10.0pt">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
<b>Limitation of Liability</b>. In case of intentional conduct, gross negligence, claims based on the Product Liability Act, as well as in case of death or personal or physical injury, Microsoft is liable according to the statutory law.</span></p>
<h1 style="margin-left:22.5pt; text-indent:0in"><span style="font-size:10.0pt; font-weight:normal">Subject to the foregoing clause (ii), Microsoft will only be liable for slight negligence if Microsoft is in breach of such material contractual obligations,
 the fulfillment of which facilitate the due performance of this agreement, the breach of which would endanger the purpose of this agreement and the compliance with which a party may constantly trust in (so-called &quot;cardinal obligations&quot;). In other cases of
 slight negligence, Microsoft will not be liable for slight negligence</span></h1>
<h1><span style="font-size:10.0pt; text-transform:uppercase">11.<span style="font:7.0pt &quot;Times New Roman&quot;">
</span></span><span style="font-size:10.0pt; text-transform:uppercase">Disclaimer of Warranty.</span><span style="font-size:10.0pt"> THE SOFTWARE IS LICENSED AS-IS. YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS.
 TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
</span></h1>
<h1><span style="font-size:10.0pt">12.<span style="font:7.0pt &quot;Times New Roman&quot;">
</span></span><span style="font-size:10.0pt; text-transform:uppercase">Limitation on and Exclusion of Remedies and Damages.
</span><span style="font-size:10.0pt">YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.</span></h1>
<p class="Body1"><span style="font-size:10.0pt">This limitation applies to (a) anything related to the software, services, content (including code) on third party Internet sites, or third party applications; and (b) claims for breach of contract, breach of
 warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.</span></p>
<p class="MsoNormal" style="margin-left:.25in"><span style="font-size:10.0pt">It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your state or country
 may not allow the exclusion or limitation of incidental, consequential or other damages.</span></p>
<p class="MsoNormal"><span style="font-size:10.0pt">&nbsp;</span></p>
</div>
</body>
</html>


================================================
FILE: tools/vslicense/dotnet-library-license.md
================================================
**MICROSOFT SOFTWARE LICENSE TERMS**

**MICROSOFT .NET LIBRARY**

------------------------------------------------------------------------------
These license terms are an agreement between you and Microsoft Corporation (or based on where you live, one of its affiliates). They apply to the software named above. The terms also apply to any Microsoft services or updates for the software, except to the extent those have different terms.

------------------------------------------------------------------------------
**IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE RIGHTS BELOW.**

**1. INSTALLATION AND USE RIGHTS.**

> You may install and use any number of copies of the software to develop and test your applications.

**2. THIRD PARTY COMPONENTS.** The software may include third party components with separate legal notices or governed by other agreements, as may be described in the ThirdPartyNotices file(s) accompanying the software.

**3. ADDITIONAL LICENSING REQUIREMENTS AND/OR USE RIGHTS.**

> **a. DISTRIBUTABLE CODE.** The software is comprised of Distributable Code. "Distributable Code" is code that you are permitted to distribute in applications you develop if you comply with the terms below.

>> **i. Right to Use and Distribute.**

>> - You may copy and distribute the object code form of the software.

>> - Third Party Distribution. You may permit distributors of your applications to copy and distribute the Distributable Code as part of those applications.

>> **ii. Distribution Requirements. For any Distributable Code you distribute, you must**

>> - use the Distributable Code in your applications and not as a standalone distribution;

>> - require distributors and external end users to agree to terms that protect it at least as much as this agreement; and

>> - indemnify, defend, and hold harmless Microsoft from any claims, including attorneys' fees, related to the distribution or use of your applications, except to the extent that any claim is based solely on the unmodified Distributable Code.

>> **iii. Distribution Restrictions. You may not**

>> - use Microsoft's trademarks in your applications' names or in a way that suggests your applications come from or are endorsed by Microsoft; or

>> - modify or distribute the source code of any Distributable Code so that any part of it becomes subject to an Excluded License. An "Excluded License" is one that requires, as a condition of use, modification or distribution of code, that (i) it be disclosed or distributed in source code form; or (ii) others have the right to modify it.

**4. DATA.**

> **a. Data Collection.** The software may collect information about you and your use of the software, and send that to Microsoft. Microsoft may use this information to provide services and improve our products and services. You may opt-out of many of these scenarios, but not all, as described in the software documentation. There are also some features in the software that may enable you and Microsoft to collect data from users of your applications. If you use these features, you must comply with applicable law, including providing appropriate notices to users of your applications together with Microsoft's privacy statement. Our privacy statement is located at https://go.microsoft.com/fwlink/?LinkID=824704. You can learn more about data collection and its use from the software documentation and our privacy statement. Your use of the software operates as your consent to these practices.

> **b. Processing of Personal Data.** To the extent Microsoft is a processor or subprocessor of personal data in connection with the software, Microsoft makes the commitments in the European Union General Data Protection Regulation Terms of the Online Services Terms to all customers effective May 25, 2018, at https://docs.microsoft.com/en-us/legal/gdpr.

**5. SCOPE OF LICENSE.** The software is licensed, not sold. This agreement only gives you some rights to use the software. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you may use the software only as expressly permitted in this agreement. In doing so, you must comply with any technical limitations in the software that only allow you to use it in certain ways. You may not

> - work around any technical limitations in the software;

> - reverse engineer, decompile or disassemble the software, or otherwise attempt to derive the source code for the software, except and to the extent required by third party licensing terms governing use of certain open source components that may be included in the software;

> - remove, minimize, block or modify any notices of Microsoft or its suppliers in the software;

> - use the software in any way that is against the law; or

> - share, publish, rent or lease the software, provide the software as a stand-alone offering for others to use, or transfer the software or this agreement to any third party.

**6. EXPORT RESTRICTIONS.** You must comply with all domestic and international export laws and regulations that apply to the software, which include restrictions on destinations, end users, and end use. For further information on export restrictions, visit www.microsoft.com/exporting.

**7. SUPPORT SERVICES.** Because this software is "as is", we may not provide support services for it.

**8. ENTIRE AGREEMENT.** This agreement, and the terms for supplements, updates, Internet-based services and support services that you use, are the entire agreement for the software and support services.

**9. APPLICABLE LAW.** If you acquired the software in the United States, Washington law applies to interpretation of and claims for breach of this agreement, and the laws of the state where you live apply to all other claims. If you acquired the software in any other country, its laws apply.

**10. CONSUMER RIGHTS; REGIONAL VARIATIONS.** This agreement describes certain legal rights. You may have other rights, including consumer rights, under the laws of your state or country. Separate and apart from your relationship with Microsoft, you may also have rights with respect to the party from which you acquired the software. This agreement does not change those other rights if the laws of your state or country do not permit it to do so. For example, if you acquired the software in one of the below regions, or mandatory country law applies, then the following provisions apply to you:

> **a) Australia.** You have statutory guarantees under the Australian Consumer Law and nothing in this agreement is intended to affect those rights.

> **b) Canada.** If you acquired this software in Canada, you may stop receiving updates by turning off the automatic update feature, disconnecting your device from the Internet (if and when you re-connect to the Internet, however, the software will resume checking for and installing updates), or uninstalling the software. The product documentation, if any, may also specify how to turn off updates for your specific device or software.

> **c) Germany and Austria.**

>> **(i) Warranty.** The software will perform substantially as described in any Microsoft materials that accompany it. However, Microsoft gives no contractual guarantee in relation to the software.

>> **(ii) Limitation of Liability.** In case of intentional conduct, gross negligence, claims based on the Product Liability Act, as well as in case of death or personal or physical injury, Microsoft is liable according to the statutory law.

> Subject to the foregoing clause (ii), Microsoft will only be liable for slight negligence if Microsoft is in breach of such material contractual obligations, the fulfillment of which facilitate the due performance of this agreement, the breach of which would endanger the purpose of this agreement and the compliance with which a party may constantly trust in (so-called "cardinal obligations"). In other cases of slight negligence, Microsoft will not be liable for slight negligence

**11. Disclaimer of Warranty. THE SOFTWARE IS LICENSED "AS-IS". YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES OR CONDITIONS. TO THE EXTENT PERMITTED UNDER YOUR LOCAL LAWS, MICROSOFT EXCLUDES THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.**

**12. Limitation on and Exclusion of Remedies and Damages. YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT OR INCIDENTAL DAMAGES.**

This limitation applies to (a) anything related to the software, services, content (including code) on third party Internet sites, or third party applications; and (b) claims for breach of contract, breach of warranty, guarantee or condition, strict liability, negligence, or other tort to the extent permitted by applicable law.

It also applies even if Microsoft knew or should have known about the possibility of the damages. The above limitation or exclusion may not apply to you because your state or country may not allow the exclusion or limitation of incidental, consequential or other damages.